mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-12-14 07:13:03 +00:00
929 lines
28 KiB
C
929 lines
28 KiB
C
/******************************************************************************
|
|
*
|
|
* Name: skcsum.c
|
|
* Project: GEnesis, PCI Gigabit Ethernet Adapter
|
|
* Version: $Revision: 1.10 $
|
|
* Date: $Date: 2002/04/11 10:02:04 $
|
|
* Purpose: Store/verify Internet checksum in send/receive packets.
|
|
*
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
*
|
|
* (C)Copyright 1998-2001 SysKonnect GmbH.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* The information in this file is provided "AS IS" without warranty.
|
|
*
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
*
|
|
* History:
|
|
*
|
|
* $Log: skcsum.c,v $
|
|
* Revision 1.10 2002/04/11 10:02:04 rwahl
|
|
* Fix in SkCsGetSendInfo():
|
|
* - function did not return ProtocolFlags in every case.
|
|
* - pseudo header csum calculated wrong for big endian.
|
|
*
|
|
* Revision 1.9 2001/06/13 07:42:08 gklug
|
|
* fix: NetNumber was wrong in CLEAR_STAT event
|
|
* add: check for good NetNumber in Clear STAT
|
|
*
|
|
* Revision 1.8 2001/02/06 11:15:36 rassmann
|
|
* Supporting two nets on dual-port adapters.
|
|
*
|
|
* Revision 1.7 2000/06/29 13:17:05 rassmann
|
|
* Corrected reception of a packet with UDP checksum == 0 (which means there
|
|
* is no UDP checksum).
|
|
*
|
|
* Revision 1.6 2000/02/21 12:35:10 cgoos
|
|
* Fixed license header comment.
|
|
*
|
|
* Revision 1.5 2000/02/21 11:05:19 cgoos
|
|
* Merged changes back to common source.
|
|
* Fixed rx path for BIG ENDIAN architecture.
|
|
*
|
|
* Revision 1.1 1999/07/26 15:28:12 mkarl
|
|
* added return SKCS_STATUS_IP_CSUM_ERROR_UDP and
|
|
* SKCS_STATUS_IP_CSUM_ERROR_TCP to pass the NidsTester
|
|
* changed from common source to windows specific source
|
|
* therefore restarting with v1.0
|
|
*
|
|
* Revision 1.3 1999/05/10 08:39:33 mkarl
|
|
* prevent overflows in SKCS_HTON16
|
|
* fixed a bug in pseudo header checksum calculation
|
|
* added some comments
|
|
*
|
|
* Revision 1.2 1998/10/22 11:53:28 swolf
|
|
* Now using SK_DBG_MSG.
|
|
*
|
|
* Revision 1.1 1998/09/01 15:35:41 swolf
|
|
* initial revision
|
|
*
|
|
* 13-May-1998 sw Created.
|
|
*
|
|
******************************************************************************/
|
|
|
|
#include <config.h>
|
|
|
|
#ifdef CONFIG_SK98
|
|
|
|
#ifdef SK_USE_CSUM /* Check if CSUM is to be used. */
|
|
|
|
#ifndef lint
|
|
static const char SysKonnectFileId[] = "@(#)"
|
|
"$Id: skcsum.c,v 1.10 2002/04/11 10:02:04 rwahl Exp $"
|
|
" (C) SysKonnect.";
|
|
#endif /* !lint */
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Description:
|
|
*
|
|
* This is the "GEnesis" common module "CSUM".
|
|
*
|
|
* This module contains the code necessary to calculate, store, and verify the
|
|
* Internet Checksum of IP, TCP, and UDP frames.
|
|
*
|
|
* "GEnesis" is an abbreviation of "Gigabit Ethernet Network System in Silicon"
|
|
* and is the code name of this SysKonnect project.
|
|
*
|
|
* Compilation Options:
|
|
*
|
|
* SK_USE_CSUM - Define if CSUM is to be used. Otherwise, CSUM will be an
|
|
* empty module.
|
|
*
|
|
* SKCS_OVERWRITE_PROTO - Define to overwrite the default protocol id
|
|
* definitions. In this case, all SKCS_PROTO_xxx definitions must be made
|
|
* external.
|
|
*
|
|
* SKCS_OVERWRITE_STATUS - Define to overwrite the default return status
|
|
* definitions. In this case, all SKCS_STATUS_xxx definitions must be made
|
|
* external.
|
|
*
|
|
* Include File Hierarchy:
|
|
*
|
|
* "h/skdrv1st.h"
|
|
* "h/skcsum.h"
|
|
* "h/sktypes.h"
|
|
* "h/skqueue.h"
|
|
* "h/skdrv2nd.h"
|
|
*
|
|
******************************************************************************/
|
|
|
|
#include "h/skdrv1st.h"
|
|
#include "h/skcsum.h"
|
|
#include "h/skdrv2nd.h"
|
|
|
|
/* defines ********************************************************************/
|
|
|
|
/* The size of an Ethernet MAC header. */
|
|
#define SKCS_ETHERNET_MAC_HEADER_SIZE (6+6+2)
|
|
|
|
/* The size of the used topology's MAC header. */
|
|
#define SKCS_MAC_HEADER_SIZE SKCS_ETHERNET_MAC_HEADER_SIZE
|
|
|
|
/* The size of the IP header without any option fields. */
|
|
#define SKCS_IP_HEADER_SIZE 20
|
|
|
|
/*
|
|
* Field offsets within the IP header.
|
|
*/
|
|
|
|
/* "Internet Header Version" and "Length". */
|
|
#define SKCS_OFS_IP_HEADER_VERSION_AND_LENGTH 0
|
|
|
|
/* "Total Length". */
|
|
#define SKCS_OFS_IP_TOTAL_LENGTH 2
|
|
|
|
/* "Flags" "Fragment Offset". */
|
|
#define SKCS_OFS_IP_FLAGS_AND_FRAGMENT_OFFSET 6
|
|
|
|
/* "Next Level Protocol" identifier. */
|
|
#define SKCS_OFS_IP_NEXT_LEVEL_PROTOCOL 9
|
|
|
|
/* Source IP address. */
|
|
#define SKCS_OFS_IP_SOURCE_ADDRESS 12
|
|
|
|
/* Destination IP address. */
|
|
#define SKCS_OFS_IP_DESTINATION_ADDRESS 16
|
|
|
|
|
|
/*
|
|
* Field offsets within the UDP header.
|
|
*/
|
|
|
|
/* UDP checksum. */
|
|
#define SKCS_OFS_UDP_CHECKSUM 6
|
|
|
|
/* IP "Next Level Protocol" identifiers (see RFC 790). */
|
|
#define SKCS_PROTO_ID_TCP 6 /* Transport Control Protocol */
|
|
#define SKCS_PROTO_ID_UDP 17 /* User Datagram Protocol */
|
|
|
|
/* IP "Don't Fragment" bit. */
|
|
#define SKCS_IP_DONT_FRAGMENT SKCS_HTON16(0x4000)
|
|
|
|
/* Add a byte offset to a pointer. */
|
|
#define SKCS_IDX(pPtr, Ofs) ((void *) ((char *) (pPtr) + (Ofs)))
|
|
|
|
/*
|
|
* Macros that convert host to network representation and vice versa, i.e.
|
|
* little/big endian conversion on little endian machines only.
|
|
*/
|
|
#ifdef SK_LITTLE_ENDIAN
|
|
#define SKCS_HTON16(Val16) (((unsigned) (Val16) >> 8) | (((Val16) & 0xFF) << 8))
|
|
#endif /* SK_LITTLE_ENDIAN */
|
|
#ifdef SK_BIG_ENDIAN
|
|
#define SKCS_HTON16(Val16) (Val16)
|
|
#endif /* SK_BIG_ENDIAN */
|
|
#define SKCS_NTOH16(Val16) SKCS_HTON16(Val16)
|
|
|
|
/* typedefs *******************************************************************/
|
|
|
|
/* function prototypes ********************************************************/
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkCsGetSendInfo - get checksum information for a send packet
|
|
*
|
|
* Description:
|
|
* Get all checksum information necessary to send a TCP or UDP packet. The
|
|
* function checks the IP header passed to it. If the high-level protocol
|
|
* is either TCP or UDP the pseudo header checksum is calculated and
|
|
* returned.
|
|
*
|
|
* The function returns the total length of the IP header (including any
|
|
* IP option fields), which is the same as the start offset of the IP data
|
|
* which in turn is the start offset of the TCP or UDP header.
|
|
*
|
|
* The function also returns the TCP or UDP pseudo header checksum, which
|
|
* should be used as the start value for the hardware checksum calculation.
|
|
* (Note that any actual pseudo header checksum can never calculate to
|
|
* zero.)
|
|
*
|
|
* Note:
|
|
* There is a bug in the ASIC which may lead to wrong checksums.
|
|
*
|
|
* Arguments:
|
|
* pAc - A pointer to the adapter context struct.
|
|
*
|
|
* pIpHeader - Pointer to IP header. Must be at least the IP header *not*
|
|
* including any option fields, i.e. at least 20 bytes.
|
|
*
|
|
* Note: This pointer will be used to address 8-, 16-, and 32-bit
|
|
* variables with the respective alignment offsets relative to the pointer.
|
|
* Thus, the pointer should point to a 32-bit aligned address. If the
|
|
* target system cannot address 32-bit variables on non 32-bit aligned
|
|
* addresses, then the pointer *must* point to a 32-bit aligned address.
|
|
*
|
|
* pPacketInfo - A pointer to the packet information structure for this
|
|
* packet. Before calling this SkCsGetSendInfo(), the following field must
|
|
* be initialized:
|
|
*
|
|
* ProtocolFlags - Initialize with any combination of
|
|
* SKCS_PROTO_XXX bit flags. SkCsGetSendInfo() will only work on
|
|
* the protocols specified here. Any protocol(s) not specified
|
|
* here will be ignored.
|
|
*
|
|
* Note: Only one checksum can be calculated in hardware. Thus, if
|
|
* SKCS_PROTO_IP is specified in the 'ProtocolFlags',
|
|
* SkCsGetSendInfo() must calculate the IP header checksum in
|
|
* software. It might be a better idea to have the calling
|
|
* protocol stack calculate the IP header checksum.
|
|
*
|
|
* Returns: N/A
|
|
* On return, the following fields in 'pPacketInfo' may or may not have
|
|
* been filled with information, depending on the protocol(s) found in the
|
|
* packet:
|
|
*
|
|
* ProtocolFlags - Returns the SKCS_PROTO_XXX bit flags of the protocol(s)
|
|
* that were both requested by the caller and actually found in the packet.
|
|
* Protocol(s) not specified by the caller and/or not found in the packet
|
|
* will have their respective SKCS_PROTO_XXX bit flags reset.
|
|
*
|
|
* Note: For IP fragments, TCP and UDP packet information is ignored.
|
|
*
|
|
* IpHeaderLength - The total length in bytes of the complete IP header
|
|
* including any option fields is returned here. This is the start offset
|
|
* of the IP data, i.e. the TCP or UDP header if present.
|
|
*
|
|
* IpHeaderChecksum - If IP has been specified in the 'ProtocolFlags', the
|
|
* 16-bit Internet Checksum of the IP header is returned here. This value
|
|
* is to be stored into the packet's 'IP Header Checksum' field.
|
|
*
|
|
* PseudoHeaderChecksum - If this is a TCP or UDP packet and if TCP or UDP
|
|
* has been specified in the 'ProtocolFlags', the 16-bit Internet Checksum
|
|
* of the TCP or UDP pseudo header is returned here.
|
|
*/
|
|
#if 0
|
|
void SkCsGetSendInfo(
|
|
SK_AC *pAc, /* Adapter context struct. */
|
|
void *pIpHeader, /* IP header. */
|
|
SKCS_PACKET_INFO *pPacketInfo, /* Packet information struct. */
|
|
int NetNumber) /* Net number */
|
|
{
|
|
/* Internet Header Version found in IP header. */
|
|
unsigned InternetHeaderVersion;
|
|
|
|
/* Length of the IP header as found in IP header. */
|
|
unsigned IpHeaderLength;
|
|
|
|
/* Bit field specifiying the desired/found protocols. */
|
|
unsigned ProtocolFlags;
|
|
|
|
/* Next level protocol identifier found in IP header. */
|
|
unsigned NextLevelProtocol;
|
|
|
|
/* Length of IP data portion. */
|
|
unsigned IpDataLength;
|
|
|
|
/* TCP/UDP pseudo header checksum. */
|
|
unsigned long PseudoHeaderChecksum;
|
|
|
|
/* Pointer to next level protocol statistics structure. */
|
|
SKCS_PROTO_STATS *NextLevelProtoStats;
|
|
|
|
/* Temporary variable. */
|
|
unsigned Tmp;
|
|
|
|
Tmp = *(SK_U8 *)
|
|
SKCS_IDX(pIpHeader, SKCS_OFS_IP_HEADER_VERSION_AND_LENGTH);
|
|
|
|
/* Get the Internet Header Version (IHV). */
|
|
/* Note: The IHV is stored in the upper four bits. */
|
|
|
|
InternetHeaderVersion = Tmp >> 4;
|
|
|
|
/* Check the Internet Header Version. */
|
|
/* Note: We currently only support IP version 4. */
|
|
|
|
if (InternetHeaderVersion != 4) { /* IPv4? */
|
|
SK_DBG_MSG(pAc, SK_DBGMOD_CSUM, SK_DBGCAT_ERR | SK_DBGCAT_TX,
|
|
("Tx: Unknown Internet Header Version %u.\n",
|
|
InternetHeaderVersion));
|
|
pPacketInfo->ProtocolFlags = 0;
|
|
pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].TxUnableCts++;
|
|
return;
|
|
}
|
|
|
|
/* Get the IP header length (IHL). */
|
|
/*
|
|
* Note: The IHL is stored in the lower four bits as the number of
|
|
* 4-byte words.
|
|
*/
|
|
|
|
IpHeaderLength = (Tmp & 0xf) * 4;
|
|
pPacketInfo->IpHeaderLength = IpHeaderLength;
|
|
|
|
/* Check the IP header length. */
|
|
|
|
/* 04-Aug-1998 sw - Really check the IHL? Necessary? */
|
|
|
|
if (IpHeaderLength < 5*4) {
|
|
SK_DBG_MSG(pAc, SK_DBGMOD_CSUM, SK_DBGCAT_ERR | SK_DBGCAT_TX,
|
|
("Tx: Invalid IP Header Length %u.\n", IpHeaderLength));
|
|
pPacketInfo->ProtocolFlags = 0;
|
|
pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].TxUnableCts++;
|
|
return;
|
|
}
|
|
|
|
/* This is an IPv4 frame with a header of valid length. */
|
|
|
|
pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].TxOkCts++;
|
|
|
|
/* Check if we should calculate the IP header checksum. */
|
|
|
|
ProtocolFlags = pPacketInfo->ProtocolFlags;
|
|
|
|
if (ProtocolFlags & SKCS_PROTO_IP) {
|
|
pPacketInfo->IpHeaderChecksum =
|
|
SkCsCalculateChecksum(pIpHeader, IpHeaderLength);
|
|
}
|
|
|
|
/* Get the next level protocol identifier. */
|
|
|
|
NextLevelProtocol =
|
|
*(SK_U8 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_NEXT_LEVEL_PROTOCOL);
|
|
|
|
/*
|
|
* Check if this is a TCP or UDP frame and if we should calculate the
|
|
* TCP/UDP pseudo header checksum.
|
|
*
|
|
* Also clear all protocol bit flags of protocols not present in the
|
|
* frame.
|
|
*/
|
|
|
|
if ((ProtocolFlags & SKCS_PROTO_TCP) != 0 &&
|
|
NextLevelProtocol == SKCS_PROTO_ID_TCP) {
|
|
/* TCP/IP frame. */
|
|
ProtocolFlags &= SKCS_PROTO_TCP | SKCS_PROTO_IP;
|
|
NextLevelProtoStats =
|
|
&pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_TCP];
|
|
}
|
|
else if ((ProtocolFlags & SKCS_PROTO_UDP) != 0 &&
|
|
NextLevelProtocol == SKCS_PROTO_ID_UDP) {
|
|
/* UDP/IP frame. */
|
|
ProtocolFlags &= SKCS_PROTO_UDP | SKCS_PROTO_IP;
|
|
NextLevelProtoStats =
|
|
&pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_UDP];
|
|
}
|
|
else {
|
|
/*
|
|
* Either not a TCP or UDP frame and/or TCP/UDP processing not
|
|
* specified.
|
|
*/
|
|
pPacketInfo->ProtocolFlags = ProtocolFlags & SKCS_PROTO_IP;
|
|
return;
|
|
}
|
|
|
|
/* Check if this is an IP fragment. */
|
|
|
|
/*
|
|
* Note: An IP fragment has a non-zero "Fragment Offset" field and/or
|
|
* the "More Fragments" bit set. Thus, if both the "Fragment Offset"
|
|
* and the "More Fragments" are zero, it is *not* a fragment. We can
|
|
* easily check both at the same time since they are in the same 16-bit
|
|
* word.
|
|
*/
|
|
|
|
if ((*(SK_U16 *)
|
|
SKCS_IDX(pIpHeader, SKCS_OFS_IP_FLAGS_AND_FRAGMENT_OFFSET) &
|
|
~SKCS_IP_DONT_FRAGMENT) != 0) {
|
|
/* IP fragment; ignore all other protocols. */
|
|
pPacketInfo->ProtocolFlags = ProtocolFlags & SKCS_PROTO_IP;
|
|
NextLevelProtoStats->TxUnableCts++;
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Calculate the TCP/UDP pseudo header checksum.
|
|
*/
|
|
|
|
/* Get total length of IP header and data. */
|
|
|
|
IpDataLength =
|
|
*(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_TOTAL_LENGTH);
|
|
|
|
/* Get length of IP data portion. */
|
|
|
|
IpDataLength = SKCS_NTOH16(IpDataLength) - IpHeaderLength;
|
|
|
|
/* Calculate the sum of all pseudo header fields (16-bit). */
|
|
|
|
PseudoHeaderChecksum =
|
|
(unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
|
|
SKCS_OFS_IP_SOURCE_ADDRESS + 0) +
|
|
(unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
|
|
SKCS_OFS_IP_SOURCE_ADDRESS + 2) +
|
|
(unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
|
|
SKCS_OFS_IP_DESTINATION_ADDRESS + 0) +
|
|
(unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
|
|
SKCS_OFS_IP_DESTINATION_ADDRESS + 2) +
|
|
(unsigned long) SKCS_HTON16(NextLevelProtocol) +
|
|
(unsigned long) SKCS_HTON16(IpDataLength);
|
|
|
|
/* Add-in any carries. */
|
|
|
|
SKCS_OC_ADD(PseudoHeaderChecksum, PseudoHeaderChecksum, 0);
|
|
|
|
/* Add-in any new carry. */
|
|
|
|
SKCS_OC_ADD(pPacketInfo->PseudoHeaderChecksum, PseudoHeaderChecksum, 0);
|
|
|
|
pPacketInfo->ProtocolFlags = ProtocolFlags;
|
|
NextLevelProtoStats->TxOkCts++; /* Success. */
|
|
} /* SkCsGetSendInfo */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkCsGetReceiveInfo - verify checksum information for a received packet
|
|
*
|
|
* Description:
|
|
* Verify a received frame's checksum. The function returns a status code
|
|
* reflecting the result of the verification.
|
|
*
|
|
* Note:
|
|
* Before calling this function you have to verify that the frame is
|
|
* not padded and Checksum1 and Checksum2 are bigger than 1.
|
|
*
|
|
* Arguments:
|
|
* pAc - Pointer to adapter context struct.
|
|
*
|
|
* pIpHeader - Pointer to IP header. Must be at least the length in bytes
|
|
* of the received IP header including any option fields. For UDP packets,
|
|
* 8 additional bytes are needed to access the UDP checksum.
|
|
*
|
|
* Note: The actual length of the IP header is stored in the lower four
|
|
* bits of the first octet of the IP header as the number of 4-byte words,
|
|
* so it must be multiplied by four to get the length in bytes. Thus, the
|
|
* maximum IP header length is 15 * 4 = 60 bytes.
|
|
*
|
|
* Checksum1 - The first 16-bit Internet Checksum calculated by the
|
|
* hardware starting at the offset returned by SkCsSetReceiveFlags().
|
|
*
|
|
* Checksum2 - The second 16-bit Internet Checksum calculated by the
|
|
* hardware starting at the offset returned by SkCsSetReceiveFlags().
|
|
*
|
|
* Returns:
|
|
* SKCS_STATUS_UNKNOWN_IP_VERSION - Not an IP v4 frame.
|
|
* SKCS_STATUS_IP_CSUM_ERROR - IP checksum error.
|
|
* SKCS_STATUS_IP_CSUM_ERROR_TCP - IP checksum error in TCP frame.
|
|
* SKCS_STATUS_IP_CSUM_ERROR_UDP - IP checksum error in UDP frame
|
|
* SKCS_STATUS_IP_FRAGMENT - IP fragment (IP checksum ok).
|
|
* SKCS_STATUS_IP_CSUM_OK - IP checksum ok (not a TCP or UDP frame).
|
|
* SKCS_STATUS_TCP_CSUM_ERROR - TCP checksum error (IP checksum ok).
|
|
* SKCS_STATUS_UDP_CSUM_ERROR - UDP checksum error (IP checksum ok).
|
|
* SKCS_STATUS_TCP_CSUM_OK - IP and TCP checksum ok.
|
|
* SKCS_STATUS_UDP_CSUM_OK - IP and UDP checksum ok.
|
|
* SKCS_STATUS_IP_CSUM_OK_NO_UDP - IP checksum OK and no UDP checksum.
|
|
*
|
|
* Note: If SKCS_OVERWRITE_STATUS is defined, the SKCS_STATUS_XXX values
|
|
* returned here can be defined in some header file by the module using CSUM.
|
|
* In this way, the calling module can assign return values for its own needs,
|
|
* e.g. by assigning bit flags to the individual protocols.
|
|
*/
|
|
SKCS_STATUS SkCsGetReceiveInfo(
|
|
SK_AC *pAc, /* Adapter context struct. */
|
|
void *pIpHeader, /* IP header. */
|
|
unsigned Checksum1, /* Hardware checksum 1. */
|
|
unsigned Checksum2, /* Hardware checksum 2. */
|
|
int NetNumber) /* Net number */
|
|
{
|
|
/* Internet Header Version found in IP header. */
|
|
unsigned InternetHeaderVersion;
|
|
|
|
/* Length of the IP header as found in IP header. */
|
|
unsigned IpHeaderLength;
|
|
|
|
/* Length of IP data portion. */
|
|
unsigned IpDataLength;
|
|
|
|
/* IP header checksum. */
|
|
unsigned IpHeaderChecksum;
|
|
|
|
/* IP header options checksum, if any. */
|
|
unsigned IpOptionsChecksum;
|
|
|
|
/* IP data checksum, i.e. TCP/UDP checksum. */
|
|
unsigned IpDataChecksum;
|
|
|
|
/* Next level protocol identifier found in IP header. */
|
|
unsigned NextLevelProtocol;
|
|
|
|
/* The checksum of the "next level protocol", i.e. TCP or UDP. */
|
|
unsigned long NextLevelProtocolChecksum;
|
|
|
|
/* Pointer to next level protocol statistics structure. */
|
|
SKCS_PROTO_STATS *NextLevelProtoStats;
|
|
|
|
/* Temporary variable. */
|
|
unsigned Tmp;
|
|
|
|
Tmp = *(SK_U8 *)
|
|
SKCS_IDX(pIpHeader, SKCS_OFS_IP_HEADER_VERSION_AND_LENGTH);
|
|
|
|
/* Get the Internet Header Version (IHV). */
|
|
/* Note: The IHV is stored in the upper four bits. */
|
|
|
|
InternetHeaderVersion = Tmp >> 4;
|
|
|
|
/* Check the Internet Header Version. */
|
|
/* Note: We currently only support IP version 4. */
|
|
|
|
if (InternetHeaderVersion != 4) { /* IPv4? */
|
|
SK_DBG_MSG(pAc, SK_DBGMOD_CSUM, SK_DBGCAT_ERR | SK_DBGCAT_RX,
|
|
("Rx: Unknown Internet Header Version %u.\n",
|
|
InternetHeaderVersion));
|
|
pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].RxUnableCts++;
|
|
return (SKCS_STATUS_UNKNOWN_IP_VERSION);
|
|
}
|
|
|
|
/* Get the IP header length (IHL). */
|
|
/*
|
|
* Note: The IHL is stored in the lower four bits as the number of
|
|
* 4-byte words.
|
|
*/
|
|
|
|
IpHeaderLength = (Tmp & 0xf) * 4;
|
|
|
|
/* Check the IP header length. */
|
|
|
|
/* 04-Aug-1998 sw - Really check the IHL? Necessary? */
|
|
|
|
if (IpHeaderLength < 5*4) {
|
|
SK_DBG_MSG(pAc, SK_DBGMOD_CSUM, SK_DBGCAT_ERR | SK_DBGCAT_RX,
|
|
("Rx: Invalid IP Header Length %u.\n", IpHeaderLength));
|
|
pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].RxErrCts++;
|
|
return (SKCS_STATUS_IP_CSUM_ERROR);
|
|
}
|
|
|
|
/* This is an IPv4 frame with a header of valid length. */
|
|
|
|
/* Get the IP header and data checksum. */
|
|
|
|
IpDataChecksum = Checksum2;
|
|
|
|
/*
|
|
* The IP header checksum is calculated as follows:
|
|
*
|
|
* IpHeaderChecksum = Checksum1 - Checksum2
|
|
*/
|
|
|
|
SKCS_OC_SUB(IpHeaderChecksum, Checksum1, Checksum2);
|
|
|
|
/* Check if any IP header options. */
|
|
|
|
if (IpHeaderLength > SKCS_IP_HEADER_SIZE) {
|
|
|
|
/* Get the IP options checksum. */
|
|
|
|
IpOptionsChecksum = SkCsCalculateChecksum(
|
|
SKCS_IDX(pIpHeader, SKCS_IP_HEADER_SIZE),
|
|
IpHeaderLength - SKCS_IP_HEADER_SIZE);
|
|
|
|
/* Adjust the IP header and IP data checksums. */
|
|
|
|
SKCS_OC_ADD(IpHeaderChecksum, IpHeaderChecksum, IpOptionsChecksum);
|
|
|
|
SKCS_OC_SUB(IpDataChecksum, IpDataChecksum, IpOptionsChecksum);
|
|
}
|
|
|
|
/*
|
|
* Check if the IP header checksum is ok.
|
|
*
|
|
* NOTE: We must check the IP header checksum even if the caller just wants
|
|
* us to check upper-layer checksums, because we cannot do any further
|
|
* processing of the packet without a valid IP checksum.
|
|
*/
|
|
|
|
/* Get the next level protocol identifier. */
|
|
|
|
NextLevelProtocol = *(SK_U8 *)
|
|
SKCS_IDX(pIpHeader, SKCS_OFS_IP_NEXT_LEVEL_PROTOCOL);
|
|
|
|
if (IpHeaderChecksum != 0xFFFF) {
|
|
pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_IP].RxErrCts++;
|
|
/* the NDIS tester wants to know the upper level protocol too */
|
|
if (NextLevelProtocol == SKCS_PROTO_ID_TCP) {
|
|
return(SKCS_STATUS_IP_CSUM_ERROR_TCP);
|
|
}
|
|
else if (NextLevelProtocol == SKCS_PROTO_ID_UDP) {
|
|
return(SKCS_STATUS_IP_CSUM_ERROR_UDP);
|
|
}
|
|
return (SKCS_STATUS_IP_CSUM_ERROR);
|
|
}
|
|
|
|
/*
|
|
* Check if this is a TCP or UDP frame and if we should calculate the
|
|
* TCP/UDP pseudo header checksum.
|
|
*
|
|
* Also clear all protocol bit flags of protocols not present in the
|
|
* frame.
|
|
*/
|
|
|
|
if ((pAc->Csum.ReceiveFlags[NetNumber] & SKCS_PROTO_TCP) != 0 &&
|
|
NextLevelProtocol == SKCS_PROTO_ID_TCP) {
|
|
/* TCP/IP frame. */
|
|
NextLevelProtoStats =
|
|
&pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_TCP];
|
|
}
|
|
else if ((pAc->Csum.ReceiveFlags[NetNumber] & SKCS_PROTO_UDP) != 0 &&
|
|
NextLevelProtocol == SKCS_PROTO_ID_UDP) {
|
|
/* UDP/IP frame. */
|
|
NextLevelProtoStats =
|
|
&pAc->Csum.ProtoStats[NetNumber][SKCS_PROTO_STATS_UDP];
|
|
}
|
|
else {
|
|
/*
|
|
* Either not a TCP or UDP frame and/or TCP/UDP processing not
|
|
* specified.
|
|
*/
|
|
return (SKCS_STATUS_IP_CSUM_OK);
|
|
}
|
|
|
|
/* Check if this is an IP fragment. */
|
|
|
|
/*
|
|
* Note: An IP fragment has a non-zero "Fragment Offset" field and/or
|
|
* the "More Fragments" bit set. Thus, if both the "Fragment Offset"
|
|
* and the "More Fragments" are zero, it is *not* a fragment. We can
|
|
* easily check both at the same time since they are in the same 16-bit
|
|
* word.
|
|
*/
|
|
|
|
if ((*(SK_U16 *)
|
|
SKCS_IDX(pIpHeader, SKCS_OFS_IP_FLAGS_AND_FRAGMENT_OFFSET) &
|
|
~SKCS_IP_DONT_FRAGMENT) != 0) {
|
|
/* IP fragment; ignore all other protocols. */
|
|
NextLevelProtoStats->RxUnableCts++;
|
|
return (SKCS_STATUS_IP_FRAGMENT);
|
|
}
|
|
|
|
/*
|
|
* 08-May-2000 ra
|
|
*
|
|
* From RFC 768 (UDP)
|
|
* If the computed checksum is zero, it is transmitted as all ones (the
|
|
* equivalent in one's complement arithmetic). An all zero transmitted
|
|
* checksum value means that the transmitter generated no checksum (for
|
|
* debugging or for higher level protocols that don't care).
|
|
*/
|
|
|
|
if (NextLevelProtocol == SKCS_PROTO_ID_UDP &&
|
|
*(SK_U16*)SKCS_IDX(pIpHeader, IpHeaderLength + 6) == 0x0000) {
|
|
|
|
NextLevelProtoStats->RxOkCts++;
|
|
|
|
return (SKCS_STATUS_IP_CSUM_OK_NO_UDP);
|
|
}
|
|
|
|
/*
|
|
* Calculate the TCP/UDP checksum.
|
|
*/
|
|
|
|
/* Get total length of IP header and data. */
|
|
|
|
IpDataLength =
|
|
*(SK_U16 *) SKCS_IDX(pIpHeader, SKCS_OFS_IP_TOTAL_LENGTH);
|
|
|
|
/* Get length of IP data portion. */
|
|
|
|
IpDataLength = SKCS_NTOH16(IpDataLength) - IpHeaderLength;
|
|
|
|
NextLevelProtocolChecksum =
|
|
|
|
/* Calculate the pseudo header checksum. */
|
|
|
|
(unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
|
|
SKCS_OFS_IP_SOURCE_ADDRESS + 0) +
|
|
(unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
|
|
SKCS_OFS_IP_SOURCE_ADDRESS + 2) +
|
|
(unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
|
|
SKCS_OFS_IP_DESTINATION_ADDRESS + 0) +
|
|
(unsigned long) *(SK_U16 *) SKCS_IDX(pIpHeader,
|
|
SKCS_OFS_IP_DESTINATION_ADDRESS + 2) +
|
|
(unsigned long) SKCS_HTON16(NextLevelProtocol) +
|
|
(unsigned long) SKCS_HTON16(IpDataLength) +
|
|
|
|
/* Add the TCP/UDP header checksum. */
|
|
|
|
(unsigned long) IpDataChecksum;
|
|
|
|
/* Add-in any carries. */
|
|
|
|
SKCS_OC_ADD(NextLevelProtocolChecksum, NextLevelProtocolChecksum, 0);
|
|
|
|
/* Add-in any new carry. */
|
|
|
|
SKCS_OC_ADD(NextLevelProtocolChecksum, NextLevelProtocolChecksum, 0);
|
|
|
|
/* Check if the TCP/UDP checksum is ok. */
|
|
|
|
if ((unsigned) NextLevelProtocolChecksum == 0xFFFF) {
|
|
|
|
/* TCP/UDP checksum ok. */
|
|
|
|
NextLevelProtoStats->RxOkCts++;
|
|
|
|
return (NextLevelProtocol == SKCS_PROTO_ID_TCP ?
|
|
SKCS_STATUS_TCP_CSUM_OK : SKCS_STATUS_UDP_CSUM_OK);
|
|
}
|
|
|
|
/* TCP/UDP checksum error. */
|
|
|
|
NextLevelProtoStats->RxErrCts++;
|
|
|
|
return (NextLevelProtocol == SKCS_PROTO_ID_TCP ?
|
|
SKCS_STATUS_TCP_CSUM_ERROR : SKCS_STATUS_UDP_CSUM_ERROR);
|
|
} /* SkCsGetReceiveInfo */
|
|
#endif
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkCsSetReceiveFlags - set checksum receive flags
|
|
*
|
|
* Description:
|
|
* Use this function to set the various receive flags. According to the
|
|
* protocol flags set by the caller, the start offsets within received
|
|
* packets of the two hardware checksums are returned. These offsets must
|
|
* be stored in all receive descriptors.
|
|
*
|
|
* Arguments:
|
|
* pAc - Pointer to adapter context struct.
|
|
*
|
|
* ReceiveFlags - Any combination of SK_PROTO_XXX flags of the protocols
|
|
* for which the caller wants checksum information on received frames.
|
|
*
|
|
* pChecksum1Offset - The start offset of the first receive descriptor
|
|
* hardware checksum to be calculated for received frames is returned
|
|
* here.
|
|
*
|
|
* pChecksum2Offset - The start offset of the second receive descriptor
|
|
* hardware checksum to be calculated for received frames is returned
|
|
* here.
|
|
*
|
|
* Returns: N/A
|
|
* Returns the two hardware checksum start offsets.
|
|
*/
|
|
void SkCsSetReceiveFlags(
|
|
SK_AC *pAc, /* Adapter context struct. */
|
|
unsigned ReceiveFlags, /* New receive flags. */
|
|
unsigned *pChecksum1Offset, /* Offset for hardware checksum 1. */
|
|
unsigned *pChecksum2Offset, /* Offset for hardware checksum 2. */
|
|
int NetNumber)
|
|
{
|
|
/* Save the receive flags. */
|
|
|
|
pAc->Csum.ReceiveFlags[NetNumber] = ReceiveFlags;
|
|
|
|
/* First checksum start offset is the IP header. */
|
|
*pChecksum1Offset = SKCS_MAC_HEADER_SIZE;
|
|
|
|
/*
|
|
* Second checksum start offset is the IP data. Note that this may vary
|
|
* if there are any IP header options in the actual packet.
|
|
*/
|
|
*pChecksum2Offset = SKCS_MAC_HEADER_SIZE + SKCS_IP_HEADER_SIZE;
|
|
} /* SkCsSetReceiveFlags */
|
|
|
|
#ifndef SkCsCalculateChecksum
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkCsCalculateChecksum - calculate checksum for specified data
|
|
*
|
|
* Description:
|
|
* Calculate and return the 16-bit Internet Checksum for the specified
|
|
* data.
|
|
*
|
|
* Arguments:
|
|
* pData - Pointer to data for which the checksum shall be calculated.
|
|
* Note: The pointer should be aligned on a 16-bit boundary.
|
|
*
|
|
* Length - Length in bytes of data to checksum.
|
|
*
|
|
* Returns:
|
|
* The 16-bit Internet Checksum for the specified data.
|
|
*
|
|
* Note: The checksum is calculated in the machine's natural byte order,
|
|
* i.e. little vs. big endian. Thus, the resulting checksum is different
|
|
* for the same input data on little and big endian machines.
|
|
*
|
|
* However, when written back to the network packet, the byte order is
|
|
* always in correct network order.
|
|
*/
|
|
unsigned SkCsCalculateChecksum(
|
|
void *pData, /* Data to checksum. */
|
|
unsigned Length) /* Length of data. */
|
|
{
|
|
SK_U16 *pU16; /* Pointer to the data as 16-bit words. */
|
|
unsigned long Checksum; /* Checksum; must be at least 32 bits. */
|
|
|
|
/* Sum up all 16-bit words. */
|
|
|
|
pU16 = (SK_U16 *) pData;
|
|
for (Checksum = 0; Length > 1; Length -= 2) {
|
|
Checksum += *pU16++;
|
|
}
|
|
|
|
/* If this is an odd number of bytes, add-in the last byte. */
|
|
|
|
if (Length > 0) {
|
|
#ifdef SK_BIG_ENDIAN
|
|
/* Add the last byte as the high byte. */
|
|
Checksum += ((unsigned) *(SK_U8 *) pU16) << 8;
|
|
#else /* !SK_BIG_ENDIAN */
|
|
/* Add the last byte as the low byte. */
|
|
Checksum += *(SK_U8 *) pU16;
|
|
#endif /* !SK_BIG_ENDIAN */
|
|
}
|
|
|
|
/* Add-in any carries. */
|
|
|
|
SKCS_OC_ADD(Checksum, Checksum, 0);
|
|
|
|
/* Add-in any new carry. */
|
|
|
|
SKCS_OC_ADD(Checksum, Checksum, 0);
|
|
|
|
/* Note: All bits beyond the 16-bit limit are now zero. */
|
|
|
|
return ((unsigned) Checksum);
|
|
} /* SkCsCalculateChecksum */
|
|
|
|
#endif /* SkCsCalculateChecksum */
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkCsEvent - the CSUM event dispatcher
|
|
*
|
|
* Description:
|
|
* This is the event handler for the CSUM module.
|
|
*
|
|
* Arguments:
|
|
* pAc - Pointer to adapter context.
|
|
*
|
|
* Ioc - I/O context.
|
|
*
|
|
* Event - Event id.
|
|
*
|
|
* Param - Event dependent parameter.
|
|
*
|
|
* Returns:
|
|
* The 16-bit Internet Checksum for the specified data.
|
|
*
|
|
* Note: The checksum is calculated in the machine's natural byte order,
|
|
* i.e. little vs. big endian. Thus, the resulting checksum is different
|
|
* for the same input data on little and big endian machines.
|
|
*
|
|
* However, when written back to the network packet, the byte order is
|
|
* always in correct network order.
|
|
*/
|
|
int SkCsEvent(
|
|
SK_AC *pAc, /* Pointer to adapter context. */
|
|
SK_IOC Ioc, /* I/O context. */
|
|
SK_U32 Event, /* Event id. */
|
|
SK_EVPARA Param) /* Event dependent parameter. */
|
|
{
|
|
int ProtoIndex;
|
|
int NetNumber;
|
|
|
|
switch (Event) {
|
|
/*
|
|
* Clear protocol statistics.
|
|
*
|
|
* Param - Protocol index, or -1 for all protocols.
|
|
* - Net number.
|
|
*/
|
|
case SK_CSUM_EVENT_CLEAR_PROTO_STATS:
|
|
|
|
ProtoIndex = (int)Param.Para32[1];
|
|
NetNumber = (int)Param.Para32[0];
|
|
if (ProtoIndex < 0) { /* Clear for all protocols. */
|
|
if (NetNumber >= 0) {
|
|
memset(&pAc->Csum.ProtoStats[NetNumber][0], 0,
|
|
sizeof(pAc->Csum.ProtoStats[NetNumber]));
|
|
}
|
|
}
|
|
else { /* Clear for individual protocol. */
|
|
memset(&pAc->Csum.ProtoStats[NetNumber][ProtoIndex], 0,
|
|
sizeof(pAc->Csum.ProtoStats[NetNumber][ProtoIndex]));
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return (0); /* Success. */
|
|
} /* SkCsEvent */
|
|
|
|
#endif /* SK_USE_CSUM */
|
|
|
|
#endif /* CONFIG_SK98 */
|