/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1992,1997 by Sun Microsystems, Inc.
 * All rights reserved.
 */
/* Copyright (c) 1990 Mentat Inc. */

#include <sys/types.h>
#include <sys/stream.h>
#include <sys/ddi.h>
#include <sys/isa_defs.h>
#include <inet/common.h>

#define FOLD_SUM(sum) \
{ sum = (sum >> 16) + (sum & 0xFFFF); sum = (sum >> 16) + (sum & 0xFFFF); }
#define U16AM(p, i, m)  ((((uint16_t *)(p))[i]) & (uint32_t)(m))

/*
 * For maximum efficiency, these access macros should be redone for
 * machines that can access unaligned data.  NOTE: these assume
 * ability to fetch from a zero extended 'uint8_t' and 'uint16_t'.  Add explicit
 * masks in the U8_FETCH, U16_FETCH, PREV_TWO and NEXT_TWO as needed.
 */

#ifdef  _LITTLE_ENDIAN
#define U8_FETCH_FIRST(p)       ((p)[0])
#define U8_FETCH_SECOND(p)      (((uint32_t)(p)[0]) << 8)
#define PREV_ONE(p)             U16AM(p, -1, 0xFF00)
#define NEXT_ONE(p)             U16AM(p, 0, 0xFF)
#else
#define U8_FETCH_FIRST(p)       ((uint32_t)((p)[0]) << 8)
#define U8_FETCH_SECOND(p)      ((p)[0])
#define PREV_ONE(p)             U16AM(p, -1, 0xFF)
#define NEXT_ONE(p)             U16AM(p, 0, 0xFF00)
#endif

#define U16_FETCH(p)            U8_FETCH_FIRST(p) + U8_FETCH_SECOND(p+1)
#define PREV_TWO(p)             ((uint32_t)(((uint16_t *)(p))[-1]))
#define NEXT_TWO(p)             ((uint32_t)(((uint16_t *)(p))[0]))

/*
 * Return the ones complement checksum from the mblk chain at mp,
 * after skipping offset bytes, and adding in the supplied partial
 * sum.  Note that a final complement of the return value is needed
 * if no further contributions to the checksum are forthcoming.
 */
uint16_t
ip_csum(mp, offset, sum)
        mblk_t *mp;
        int     offset;
        uint32_t        sum;
{
        uint8_t *startp = mp->b_rptr + offset;
        uint8_t *endp = mp->b_wptr;
/* >= 0x2 means flipped for memory align, 0x1 means last count was odd */
        int     odd_total = 0;

#ifdef  TEST_COVERAGE
        mblk_t *safe_mp;
#define INIT_COVERAGE() (safe_mp = mp, safe_mp->b_next = NULL)
#define MARK_COVERAGE(flag) (safe_mp->b_next = \
        (mblk_t *)((uint32_t)safe_mp->b_next | flag))
#else
#define INIT_COVERAGE() /* */
#define MARK_COVERAGE(flag)     /* */
#endif

        for (;;) {
                INIT_COVERAGE();
                if ((endp - startp) < 10) {
                        MARK_COVERAGE(0x1);
                        while ((endp - startp) >= 2) {
                                MARK_COVERAGE(0x2);
                                sum += U16_FETCH(startp);
                                startp += 2;
                        }
                        if ((endp - startp) >= 1) {
                                MARK_COVERAGE(0x4);
                                odd_total = 1;
                                sum += U8_FETCH_FIRST(startp);
                        }
                        MARK_COVERAGE(0x8);
                        FOLD_SUM(sum);
                        goto next_frag;
                }
                if ((uint32_t)startp & 0x1) {
                        MARK_COVERAGE(0x10);
                        odd_total = 3;
                        startp++;
                        sum = (sum << 8) + PREV_ONE(startp);
                }
                if ((uint32_t)startp & 0x2) {
                        MARK_COVERAGE(0x20);
                        startp += 2;
                        sum += PREV_TWO(startp);
                }
                if ((uint32_t)endp & 0x1) {
                        MARK_COVERAGE(0x40);
                        odd_total ^= 0x1;
                        endp--;
                        sum += NEXT_ONE(endp);
                }
                if ((uint32_t)endp & 0x2) {
                        MARK_COVERAGE(0x80);
                        endp -= 2;
                        sum += NEXT_TWO(endp);
                }

                {
#ifdef  NOT_ALL_PTRS_EQUAL
#define INC_PTR(cnt)    ptr += cnt
#define INC_ENDPTR(cnt) endptr += cnt
                        uint32_t        *ptr = (uint32_t *)startp;
                        uint32_t        *endptr = (uint32_t *)endp;
#else
#define INC_PTR(cnt)    startp += (cnt * sizeof (uint32_t))
#define INC_ENDPTR(cnt) endp += (cnt * sizeof (uint32_t))
#define ptr             ((uint32_t *)startp)
#define endptr          ((uint32_t *)endp)
#endif


#ifdef  USE_FETCH_AND_SHIFT
                        uint32_t        u1, u2;
                        uint32_t        mask = 0xFFFF;
#define LOAD1(i)        u1 = ptr[i]
#define LOAD2(i)        u2 = ptr[i]
#define SUM1(i)         sum += (u1 & mask) + (u1 >> 16)
#define SUM2(i)         sum += (u2 & mask) + (u2 >> 16)
#endif

#ifdef  USE_FETCH_AND_ADDC
                        uint32_t        u1, u2;
#define LOAD1(i)        u1 = ptr[i]
#define LOAD2(i)        u2 = ptr[i]
#define SUM1(i)         sum += u1
#define SUM2(i)         sum += u2
#endif

#ifdef  USE_ADDC
#define SUM1(i)         sum += ptr[i]
#endif

#ifdef  USE_POSTINC
#define SUM1(i)         sum += *((uint16_t *)ptr)++; sum += *((uint16_t *)ptr)++
#undef  INC_PTR
#define INC_PTR(i)      /* */
#endif

#ifndef LOAD1
#define LOAD1(i)        /* */
#endif

#ifndef LOAD2
#define LOAD2(i)        /* */
#endif

#ifndef SUM2
#define SUM2(i)         SUM1(i)
#endif

/* USE_INDEXING is the default */
#ifndef SUM1
#define SUM1(i)
        sum += ((uint16_t *)ptr)[i * 2]; sum += ((uint16_t *)ptr)[(i * 2) + 1]
#endif

                LOAD1(0);
                INC_ENDPTR(-8);
                if (ptr <= endptr) {
                        MARK_COVERAGE(0x100);
                        do {
                                LOAD2(1); SUM1(0);
                                LOAD1(2); SUM2(1);
                                LOAD2(3); SUM1(2);
                                LOAD1(4); SUM2(3);
                                LOAD2(5); SUM1(4);
                                LOAD1(6); SUM2(5);
                                LOAD2(7); SUM1(6);
                                LOAD1(8); SUM2(7);
                                INC_PTR(8);
                        } while (ptr <= endptr);
                }
#ifdef USE_TAIL_SWITCH
                switch ((endptr + 8) - ptr) {
                case 7: LOAD2(6); SUM2(6);
                case 6: LOAD2(5); SUM2(5);
                case 5: LOAD2(4); SUM2(4);
                case 4: LOAD2(3); SUM2(3);
                case 3: LOAD2(2); SUM2(2);
                case 2: LOAD2(1); SUM2(1);
                case 1: SUM1(0);
                case 0: break;
                }
#else
                INC_ENDPTR(4);
                if (ptr <= endptr) {
                        MARK_COVERAGE(0x200);
                        LOAD2(1); SUM1(0);
                        LOAD1(2); SUM2(1);
                        LOAD2(3); SUM1(2);
                        LOAD1(4); SUM2(3);
                        INC_PTR(4);
                }
                INC_ENDPTR(4);
                if (ptr < endptr) {
                        MARK_COVERAGE(0x400);
                        do {
                                SUM1(0); LOAD1(1);
                                INC_PTR(1);
                        } while (ptr < endptr);
                }
#endif
                }

                FOLD_SUM(sum);
                if (odd_total > 1) {
                        MARK_COVERAGE(0x800);
                        sum = ((sum << 8) | (sum >> 8)) & 0xFFFF;
                        odd_total -= 2;
                }
next_frag:
                mp = mp->b_cont;
                if (!mp) {
                        MARK_COVERAGE(0x1000);
                        {
                        uint32_t        u1 = sum;
                        return ((uint16_t)u1);
                        }
                }
                MARK_COVERAGE(0x4000);
                startp = mp->b_rptr;
                endp = mp->b_wptr;
                if (odd_total && (endp > startp)) {
                        MARK_COVERAGE(0x8000);
                        odd_total = 0;
                        sum += U8_FETCH_SECOND(startp);
                        startp++;
                }
        }
}
#undef  endptr
#undef  INIT_COVERAGE
#undef  INC_PTR
#undef  INC_ENDPTR
#undef  LOAD1
#undef  LOAD2
#undef  MARK_COVERAGE
#undef  ptr
#undef  SUM1
#undef  SUM2



#undef  FOLD_SUM
#undef  NEXT_ONE
#undef  NEXT_TWO
#undef  PREV_ONE
#undef  PREV_TWO
#undef  U8_FETCH_FIRST
#undef  U8_FETCH_SECOND
#undef  U16AM
#undef  U16_FETCH