开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
nicEvbEnd.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：61k
源码类别：

VxWorks

开发平台：

C/C++

nicEvbEnd.c：源码内容
  1. /* nicEvbEnd.c - National Semiconductor ST-NIC Chip network interface driver */
  3. /* Copyright 1984-2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01j,16may02,wap  Release dmaSem before passing packets up the stack (SPR
  10.                  #77005)
  11. 01i,02aug00,stv  removed netMblkClChainFree() in Pollsend routine (SPR# 32885).
  12. 01h,11jun00,ham  removed reference to etherLib.
  13. 01g,01dec99,stv  freed mBlk chain before returning ERROR (SPR #28492).
  14. 01f,10feb98,sut  added poll mode support
  15. 01e,09feb98,sut  added multicast support
  16. 01d,08feb98,sut  got working
  17. 01c,25jan98,sut  working with initMem
  18. 01b,21jan98,sut  investcating descritor
  19. 01a,20jan99,sut  from netif/if_nicEvb.c
  20. */
  22. /*
  23. This module implements the National Semiconductor 83902A ST-NIC Ethernet
  24. network interface driver.
  26. This driver is non-generic and is for use on the IBM EVB403 board.  
  27. The driver must be given several target-specific parameters.  These
  28. parameters, and the mechanisms used to communicate them to the driver, are
  29. detailed below.
  32. BOARD LAYOUT
  33. This device is on-board.  No jumpering diagram is necessary.
  35. EXTERNAL INTERFACE
  36. The only external interface is the nicEvbEndLoad() routine, which expects
  37. the <initString> parameter as input.  This parameter passes in a 
  38. colon-delimited string of the format:
  40. <unit>:<nic_addr>:<int_vector>:<int_level>
  42. The nicEvbEndLoad() function uses strtok() to parse the string.
  44. TARGET-SPECIFIC PARAMETERS
  45. .IP <unit>
  46. A convenient holdover from the former model.  This parameter is used only
  47. in the string name for the driver.
  48. .IP <nic_addr>
  49. Base address for NIC chip
  50. .IP <int_vector>
  51. Configures the NIC device to generate hardware interrupts for various events
  52. within the device. Thus, it contains an interrupt handler routine.  The driver
  53. calls sysIntConnect() to connect its interrupt handler to the interrupt vector.
  54. .IP <int_level>
  55. This parameter is passed to an external support routine, sysLanIntEnable(),
  56. which is described below in "External Support Requirements." This routine 
  57. is called during as part of driver's initialization.  It handles any 
  58. board-specific operations required to allow the servicing of a NIC 
  59. interrupt on targets that use additional interrupt controller devices to 
  60. help organize and service the various interrupt sources.  This parameter 
  61. makes it possible for this driver to avoid all board-specific knowledge of 
  62. such devices.  
  63. .iP "device restart/reset delay"
  64. The global variable nicRestartDelay (UINT32), defined in this file, 
  65. should be initialized in the BSP sysHwInit() routine. nicRestartDelay is 
  66. used only with PowerPC platform and is equal to the number of time base 
  67. increments which makes for 1.6 msec. This corresponds to the delay necessary 
  68. to respect when restarting or resetting the device.
  69. .LP
  71. EXTERNAL SUPPORT REQUIREMENTS
  72. This driver requires several external support functions, defined as macros:
  73. .CS
  74.     SYS_INT_CONNECT(pDrvCtrl, routine, arg)
  75.     SYS_INT_DISCONNECT (pDrvCtrl, routine, arg)
  76.     SYS_INT_ENABLE(pDrvCtrl)
  77. .CE
  79. There are default values in the source code for these macros.  They presume
  80. memory-mapped accesses to the device registers and the normal intConnect(),
  81. and intEnable() BSP functions.  The first argument to each is the device
  82. controller structure. Thus, each has access back to all the device-specific
  83. information.  Having the pointer in the macro facilitates the addition 
  84. of new features to this driver.
  87. SYSTEM RESOURCE USAGE
  88. When implemented, this driver requires the following system resources:
  90.     - one mutual exclusion semaphore
  91.     - one interrupt vector
  93. SEE ALSO: muxLib
  94. */
  96. /* configurations */
  98. #define NIC_INSTRUMENT /* instrument the driver */
  99. #undef DRV_DEBUG /* log debug messages */
  101. #if (CPU_FAMILY == PPC)
  102. #define NIC_USE_PPCTIMEBASE
  103. #else   /* CPU_FAMILY == PPC */
  104. #undef NIC_USE_PPCTIMEBASE
  105. #endif /* CPU_FAMILY == PPC */
  107. /* 
  108.  * NIC_FASTER, if defined, improved the driver throuput, however the driver
  109.  * seems to be less reliable. Left undefined for now.
  110.  */
  112. #undef NIC_FASTER /* improve throuput but less stable */
  115. /* includes */
  117. #include "vxWorks.h"
  119. #include "wdLib.h"
  120. #include "iv.h"
  121. #include "vme.h"
  122. #include "net/mbuf.h"
  123. #include "net/unixLib.h"
  124. #include "net/protosw.h"
  125. #include "sys/socket.h"
  126. #include "sys/ioctl.h"
  127. #include "errno.h"
  128. #include "memLib.h"
  129. #include "intLib.h"
  130. #include "net/route.h"
  131. #include "iosLib.h"
  132. #include "errnoLib.h"
  134. #ifdef DRV_DEBUG
  135. #include "logLib.h"
  136. #endif
  138. #include "cacheLib.h"
  139. #include "netLib.h"
  140. #include "stdio.h"
  141. #include "stdlib.h"
  142. #include "sysLib.h"
  146. #include "net/systm.h"
  147. #include "sys/times.h"
  148. #include "net/if_subr.h"
  149. #include "netinet/if_ether.h"
  151. #include "drv/end/nicEvbEnd.h"
  153. #undef ETHER_MAP_IP_MULTICAST
  154. #include "etherMultiLib.h"
  155. #include "end.h"
  156. #include "endLib.h"
  158. #include "lstLib.h"
  159. #include "semLib.h"
  162. /* defines */
  164. #define NIC_EVB_DEV_NAME "nicEvb"
  165. #define NIC_EVB_DEV_NAME_LEN 7
  166. #define NIC_EVB_EADR_LEN 6
  167. #define NIC_EVB_SPEED 10000000 /* HELP */
  168. #define NIC_TRANS_TIMEOUT 400 /* times to poll for end of Tx */
  169. #define NIC_CRC_POLY 0x04c11db7
  171. /* debug macros */
  173. #ifdef DRV_DEBUG
  175. #define DRV_DEBUG_OFF 0x0000
  176. #define DRV_DEBUG_RX 0x0001
  177. #define DRV_DEBUG_TX 0x0002
  178. #define DRV_DEBUG_INT 0x0004
  179. #define DRV_DEBUG_POLL (DRV_DEBUG_POLL_RX | DRV_DEBUG_POLL_TX)
  180. #define DRV_DEBUG_POLL_RX 0x0008
  181. #define DRV_DEBUG_POLL_TX 0x0010
  182. #define DRV_DEBUG_LOAD 0x0020
  183. #define DRV_DEBUG_IOCTL 0x0040
  184. #define DRV_DEBUG_POLL_REDIR 0x10000
  185. #define DRV_DEBUG_LOG_NVRAM 0x20000
  186. #define DRV_DEBUG_MB 0x40000
  188. #ifdef LOCAL
  189. #undef LOCAL
  190. #define LOCAL
  192. NET_POOL nicNetPool;
  194. #endif
  197. /* int nicEvbDebug = DRV_DEBUG_LOAD | DRV_DEBUG_TX | DRV_DEBUG_RX; */
  198. int nicEvbDebug = DRV_DEBUG_POLL;
  200. #define DRV_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)
  201. if (nicEvbDebug & FLG)
  202.             logMsg(X0, X1, X2, X3, X4, X5, X6);
  204. #define DRV_PRINT(FLG, X0, X1, X2, X3, X4, X5, X6)
  205. if (nicEvbDebug & FLG)
  206.             printf(X0, X1, X2, X3, X4, X5, X6);
  208. #else /*DRV_DEBUG*/
  210. #define DRV_LOG(DBG_SW, X0, X1, X2, X3, X4, X5, X6)
  211. #define DRV_PRINT(DBG_SW,X)
  213. #endif /*DRV_DEBUG*/
  217. /*
  218.  * Default macro definitions for BSP interface.
  219.  * These macros can be redefined in a wrapper file, to generate
  220.  * a new module with an optimized interface.
  221.  */
  224. #ifndef SYS_INT_CONNECT
  225. #define SYS_INT_CONNECT(pDrvCtrl,rtn,arg,pResult) 
  226.     {
  227.     IMPORT STATUS sysIntConnect(); 
  228.     *pResult = intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (pDrvCtrl->ivec), 
  229.      rtn, (int)arg); 
  230.     }
  231. #endif /*SYS_INT_CONNECT*/
  233. #ifndef SYS_INT_DISCONNECT
  234. #define SYS_INT_DISCONNECT(pDrvCtrl,rtn,arg,pResult) 
  235.     { 
  236.     *pResult = OK; 
  237.     }
  238. #endif /*SYS_INT_DISCONNECT*/
  240. #ifndef SYS_INT_ENABLE
  241. #define SYS_INT_ENABLE(ivec) 
  242.     { 
  243.     IMPORT void sysLanIntEnable();      
  244.     sysLanIntEnable (ivec);
  245.     }
  246. #endif /*SYS_INT_ENABLE*/
  249. #ifndef SYS_ENET_ADDR_GET
  250. #define SYS_ENET_ADDR_GET(pDrvCtrl, pAddress) 
  251.     { 
  252.     IMPORT sysEnetAddrGet (int, char*);
  253.     nicEvbEnetAddrGet (pDrvCtrl, pAddress); 
  254.     }
  255. #endif /* SYS_ENET_ADDR_GET */
  257. #define DRV_FLAGS_SET(setBits)                                          
  258. (pDrvCtrl->flags |= (setBits))
  260. #define DRV_FLAGS_ISSET(setBits)                                        
  261. (pDrvCtrl->flags & (setBits))
  263. #define DRV_FLAGS_CLR(clrBits)                                          
  264. (pDrvCtrl->flags &= ~(clrBits))
  266. #define DRV_FLAGS_GET()                                                 
  267.         (pDrvCtrl->flags)
  269. #define NIC_IS_IN_POLL_MODE()
  270. ((DRV_FLAGS_GET() & NIC_FLAG_POLL) == NIC_FLAG_POLL)
  272. /* A shortcut for getting the hardware address from the MIB II stuff. */
  273. #define END_HADDR(pEnd)
  274. ((pEnd)->mib2Tbl.ifPhysAddress.phyAddress)
  276. #define END_HADDR_LEN(pEnd) 
  277. ((pEnd)->mib2Tbl.ifPhysAddress.addrLength)
  279. #define END_FLAGS_ISSET(pEnd, setBits) 
  280.             ((pEnd)->flags & (setBits))
  284. /* typedefs */
  286. typedef struct rx_hdr
  287.     {
  288.     UINT8 status; /* status of packet */
  289.     UINT8 nextRxPage; /* page next pkt starts at */
  290.     UINT8 cntL; /* low byte of frame length */
  291.     UINT8 cntH; /* high byte of frame length */
  292.     } NIC_RX_HDR;
  295. #define NIC_RX_HDR_SZ sizeof(NIC_RX_HDR)
  298. typedef struct rx_frame
  299.     {
  300.     UINT16 pad1;
  301.     NIC_RX_HDR rxHdr; /* receive status header */
  302.     struct ether_header enetHdr; /* ethernet header */
  303.     UINT8 data [ETHERMTU];/* frame data */
  304.     UINT32 fcs; /* frame check sequence */
  305.     UINT8 refCnt; /* loaner reference count */
  306.     UINT8 pad2;
  307.     } NIC_RX_FRAME;
  309. /*
  310.  * Macros for read and write descriptors.
  311.  *
  312.  */
  313. #define NIC_FRAME_DATA_ADDR_GET(pFrame) 
  314. pFrame = ((char *)(pFrame) + sizeof(UINT16) + sizeof(NIC_RX_HDR_SZ));
  317. #define NIC_RBR_LEN ((PSTOP - PSTART) + 1)
  318. #define NIC_BUF_SZ sizeof(NIC_RX_FRAME)
  319. #define NIC_ETH_CRC_LEN 4
  321. typedef char* NIC_CLUSTER;
  323. typedef struct nic_end_device /* driver control structure */
  324.     {
  325.     END_OBJ end; /* The class we inherit from. */
  326.     int unit; /* unit number */
  327.     int rmdIndex; /* current RMD index */
  328.     int rringSize; /* RMD ring size */
  329.     int  rringLen; /* RMD ring length (bytes) */
  330.     UCHAR enetAddr[NIC_EVB_EADR_LEN]; /* ethernet address */
  331.     BOOL txBlocked;  /* transmit flow control */
  332.     BOOL         txCleaning;    
  333.     NIC_DEVICE* pNic; /* address of NIC chip */
  334.     int          ivec; /* interrupt vector */
  335.     int ilevel; /* interrupt level */
  336.     SEM_ID       dmaSem; /* exclusive use of remote DMA */
  337.     UINT8 nextPkt; /* NIC buf page for next pkt */
  338.     NIC_CLUSTER pRxCluster; /* Rx frame memory */
  339.     CL_POOL_ID pClPoolId;
  340.     NIC_DRV_FLAG flags; /* device specific flags */
  341.     } NICEVB_END_DEVICE;
  344. /* globals */
  346. UINT32  nicEvbRestartDelay = 30000;/* number of time base ticks to wait for */
  347. /* when resetting the chip */
  349. UINT32 nicIntNb = 0; /* number of receive interrupt */
  350. UINT32 nicTxTimeout = 0; /* number of transmit time-out */
  352. #ifdef NIC_INSTRUMENT
  353. UINT32 nicRestartNb = 0; /* number of restart due to ring overflow */
  354. UINT32 nicLen = 0; /* lenght of the current received packet */
  355. UINT32 nicHdrStat = 0; /* status byte of the current received packet */
  356. UINT32 nicNextPage = 0; /* page pointer to the next received packet */
  357. UINT32 nicCurrentPage = 0; /* start page of the current packet */
  358. UINT32 nicTxNb = 0; /* number of transmitted packets */
  359. UINT32 nicInitNb = 0; /* number of time device is re-initialized */
  360. #endif
  366. /* locals */
  369. /* forward declarations */
  371. LOCAL int nicEvbMblkDataLenGet (M_BLK* pMblk);
  372. LOCAL void nicEvbEnetAddrGet (NICEVB_END_DEVICE* pDrvCtrl, char* pAddress);
  373. LOCAL void nicEvbMARSet (NICEVB_END_DEVICE* pDrvCtrl, UINT8 index, BOOL bSet);
  374. LOCAL void nicEvbAddrFilterSet (NICEVB_END_DEVICE *pDrvCtrl, char* pAddr, BOOL bSet);
  375. LOCAL int nicEvbHashIndex (char* eAddr);
  377. LOCAL void nicEvbReset (NICEVB_END_DEVICE* pDrvCtrl);
  378. LOCAL void nicEvbInt (NICEVB_END_DEVICE* pDrvCtrl);
  379. LOCAL void nicEvbRestart (NICEVB_END_DEVICE *pDrvCtrl, UINT8 cr);
  380. LOCAL void nicEvbHandleInt (NICEVB_END_DEVICE *pDrvCtrl);
  381. LOCAL BOOL nicEvbRead (NICEVB_END_DEVICE *pDrvCtrl);
  382. LOCAL NIC_CLUSTER nicEvbReadFrame (NICEVB_END_DEVICE* pDrvCtrl);
  383. LOCAL STATUS nicEvbToStack (NICEVB_END_DEVICE* pDrvCtrl, NIC_CLUSTER pCluster);
  386. LOCAL void nicEvbConfig (NICEVB_END_DEVICE* pDrvCtrl);
  389. LOCAL STATUS nicEvbPktBufRead (NICEVB_END_DEVICE *pDrvCtrl, UINT32
  390.                                   nicBufAddr, UINT32 len, char *pData);
  392. LOCAL void nicEvbWriteCr (NIC_DEVICE *pNic, UINT8 value);
  393. LOCAL void nicEvbWriteReg (NIC_DEVICE *pNic, volatile UINT8 *pReg,
  394.                                 UINT8 value, UINT8 page);
  396. LOCAL UINT8 nicEvbReadReg (NIC_DEVICE *pNic, volatile UINT8 *pReg, char page);
  397. LOCAL STATUS nicEvbTransmit (NICEVB_END_DEVICE *pDrvCtrl,
  398.                                 M_BLK* pMblk, BOOL waitFlag);
  400. LOCAL void nicEvbWritePort (UINT8 value);
  401. LOCAL STATUS nicEvbReceive (NICEVB_END_DEVICE *pDrvCtrl,
  402.                                UINT32 nicBufAddr, char *pData, int len);
  404. LOCAL UINT8 nicEvbReadPort (void);
  405. LOCAL void nicLoanFree (NICEVB_END_DEVICE *pDrvCtrl, NIC_RX_FRAME *pRx);
  406. LOCAL BOOL nicEvbPagePtrUpdate (NICEVB_END_DEVICE * pDrvCtrl,
  407.                                      NIC_CLUSTER pRxCluster);
  408. LOCAL void nicEvbResetDelay (void);
  412. LOCAL STATUS nicEvbInitParse (NICEVB_END_DEVICE* pDrvCtrl, char * initString);
  413. LOCAL STATUS nicEvbInitMem (NICEVB_END_DEVICE* pDrvCtrl);
  415. /* END Specific interfaces. */
  417. END_OBJ * nicEvbEndLoad (char *initString);
  418. LOCAL STATUS nicEvbUnload (NICEVB_END_DEVICE* pDrvCtrl);
  419. LOCAL STATUS nicEvbStart (NICEVB_END_DEVICE* pDrvCtrl);
  420. LOCAL STATUS nicEvbStop (NICEVB_END_DEVICE* pDrvCtrl);
  421. LOCAL int nicEvbIoctl (NICEVB_END_DEVICE* pDrvCtrl, int cmd, caddr_t data);
  422. LOCAL STATUS nicEvbSend (NICEVB_END_DEVICE* pDrvCtrl, M_BLK *pMblk);
  425. LOCAL STATUS nicEvbMCastAddrAdd (NICEVB_END_DEVICE *pDrvCtrl, char* pAddress);
  426. LOCAL STATUS nicEvbMCastAddrDel (NICEVB_END_DEVICE *pDrvCtrl, char* pAddress);
  427. LOCAL STATUS nicEvbMCastAddrGet (NICEVB_END_DEVICE *pDrvCtrl, 
  428.                                       MULTI_TABLE *pTable);
  429. LOCAL STATUS nicEvbPollSend (NICEVB_END_DEVICE *pDrvCtrl, M_BLK *pMblk);
  430. LOCAL STATUS nicEvbPollReceive (NICEVB_END_DEVICE *pDrvCtrl, M_BLK *pMblk);
  431. LOCAL STATUS nicEvbPollStart (NICEVB_END_DEVICE *pDrvCtrl);
  432. LOCAL STATUS nicEvbPollStop (NICEVB_END_DEVICE *pDrvCtrl);
  435. /*
  436.  * Declare our function table.  This is static across all driver
  437.  * instances.
  438.  */
  439. LOCAL NET_FUNCS nicEvbFuncTable =
  440.     {
  441.     (FUNCPTR)nicEvbStart, /* Function to start the device. */
  442.     (FUNCPTR)nicEvbStop, /* Function to stop the device. */
  443.     (FUNCPTR)nicEvbUnload, /* Unloading function for the driver. */
  444.     (FUNCPTR)nicEvbIoctl, /* Ioctl function for the driver. */
  445.     (FUNCPTR)nicEvbSend, /* Send function for the driver. */
  446.     (FUNCPTR)nicEvbMCastAddrAdd, /* Multicast address add */
  447.     (FUNCPTR)nicEvbMCastAddrDel, /* Multicast address delete */
  448.     (FUNCPTR)nicEvbMCastAddrGet, /* Multicast table retrieve */
  449.     (FUNCPTR)nicEvbPollSend,  /* Polling send function for the driver. */
  450.     (FUNCPTR)nicEvbPollReceive, /* Polling receive function for the driver. */
  451.     endEtherAddressForm,        /* Put address info into a packet.  */
  452.     endEtherPacketDataGet,      /* Get a pointer to packet data. */
  453.     endEtherPacketAddrGet       /* Get packet addresses. */
  454.     };
  457. /******************************************************************************
  458. *
  459. * nicEndLoad - initialize the driver and device
  460. *
  461. * This routine initializes the driver and the device to the operational state.
  462. * All of the device-specific parameters are passed in <initString>, which
  463. * expects a string of the following format:
  464. *
  465. * <unit>:<base_addr>:<int_vector>:<int_level>
  466. *
  467. * This routine can be called in two modes. If it is called with an empty but
  468. * allocated string, it places the name of this device (that is, "ln") into 
  469. * the <initString> and returns 0.
  470. *
  471. * If the string is allocated and not empty, the routine attempts to load
  472. * the driver using the values specified in the string.
  473. *
  474. * RETURNS: An END object pointer, or NULL on error, or 0 and the name of the
  475. * device if the <initString> was NULL.
  476. */
  478. END_OBJ* nicEvbEndLoad
  479.     (
  480.     char* initString /* string to be parse by the driver */
  481.     )
  482.     {
  483.     NICEVB_END_DEVICE *pDrvCtrl;
  485.     DRV_LOG (DRV_DEBUG_LOAD, "Loading nic...n", 1, 2, 3, 4, 5, 6);
  487.     if (initString == NULL)
  488.         return (NULL);
  489.     
  490.     if (initString[0] == NULL)
  491.         {
  492.         bcopy((char *)NIC_EVB_DEV_NAME, initString, NIC_EVB_DEV_NAME_LEN);
  493.         return (0);
  494.         }
  495.     
  496.     /* allocate the device structure */
  498.     pDrvCtrl = (NICEVB_END_DEVICE *)calloc (sizeof (NICEVB_END_DEVICE), 1);
  499.     if (pDrvCtrl == NULL)
  500. goto errorExit;
  502.     /* init device object */
  503.     pDrvCtrl->pRxCluster = NULL;
  504.     pDrvCtrl->flags = 0x00;    
  505.     
  507.     /* parse the init string, filling in the device structure */
  509.     if (nicEvbInitParse (pDrvCtrl, initString) == ERROR)
  510. goto errorExit;
  512.     
  513.     /* Have the BSP hand us our address. */
  515.     SYS_ENET_ADDR_GET(pDrvCtrl,(char*)&(pDrvCtrl->enetAddr));
  517.     /* initialize the END and MIB2 parts of the structure */
  519.     if (END_OBJ_INIT (&pDrvCtrl->end, (DEV_OBJ *)pDrvCtrl, NIC_EVB_DEV_NAME,
  520.     pDrvCtrl->unit, &nicEvbFuncTable,
  521.                       "ST-NIC Enhanced Network Driver") == ERROR
  522.      || END_MIB_INIT (&pDrvCtrl->end, M2_ifType_ethernet_csmacd,
  523.                       &pDrvCtrl->enetAddr[0], NIC_EVB_EADR_LEN, ETHERMTU,
  524.                       NIC_EVB_SPEED)
  525.     == ERROR)
  526. goto errorExit;
  528.     /* Perform memory allocation */
  530.     if (nicEvbInitMem (pDrvCtrl) == ERROR)
  531. goto errorExit;
  533.     /* set the flags to indicate readiness */
  535.     END_OBJ_READY (&pDrvCtrl->end,
  536.                    IFF_NOTRAILERS | IFF_MULTICAST | IFF_BROADCAST);
  537.     
  538.     DRV_LOG (DRV_DEBUG_LOAD, "Done loading nicEvb...n", 1, 2, 3, 4, 5, 6);
  540.     return (&pDrvCtrl->end);
  542.     errorExit:
  543.         {
  544.         nicEvbUnload (pDrvCtrl);
  545.         return NULL;
  546.         }
  547.     }
  550. /*******************************************************************************
  551. *
  552. * nicEvbInitParse - parse the initialization string
  553. *
  554. * Parse the input string.  Fill in values in the driver control structure.
  555. * The initialization string format is:
  556. * <unit>:<base_adrs>:<vecnum>:<intLvl>
  557. *
  558. * .IP <unit>
  559. * Device unit number, a small integer.
  560. * .IP <base_adrs>
  561. * Base address for NIC device
  562. * .IP <vecNum>
  563. * Interrupt vector number (used with sysIntConnect() ).
  564. * .IP <intLvl>
  565. * Interrupt level.
  566. *
  567. * RETURNS: OK, or ERROR if any arguments are invalid.
  568. */
  570. STATUS nicEvbInitParse
  571.     (
  572.     NICEVB_END_DEVICE * pDrvCtrl,
  573.     char * initString
  574.     )
  575.     {
  576.     char * tok;
  577.     char * pHolder = NULL;
  578.     long address;
  579.     
  580.     /* Parse the initString */
  582.     /* Unit number. */
  584.     tok = strtok_r (initString, ":", &pHolder);
  585.     if (tok == NULL)
  586. return ERROR;
  587.     pDrvCtrl->unit = atoi (tok);
  589.     /* NIC address. */
  590.     
  591.     tok = strtok_r (NULL, ":", &pHolder);
  592.     if (tok == NULL)
  593. return ERROR;
  594.     address = strtoul (tok, NULL, 16);
  595.     pDrvCtrl->pNic = (NIC_DEVICE* )address;
  598.     /* Interrupt vector. */
  600.     tok = strtok_r (NULL, ":", &pHolder);
  601.     if (tok == NULL)
  602. return ERROR;
  603.     pDrvCtrl->ivec = atoi (tok);
  605.     /* Interrupt level. */
  606.     tok = strtok_r (NULL, ":", &pHolder);
  607.     if (tok == NULL)
  608. return ERROR;
  609.     pDrvCtrl->ilevel = atoi (tok);
  611.     DRV_LOG (DRV_DEBUG_LOAD, "Processed all arugmentsn", 1, 2, 3, 4, 5, 6);
  613.     DRV_LOG (DRV_DEBUG_LOAD, "Address %p Level %u ivec %dn",
  614.                pDrvCtrl->pNic, pDrvCtrl->ilevel, pDrvCtrl->ivec, 4, 5, 6);    
  616.     return OK;
  617.     }
  619. /*******************************************************************************
  620. *
  621. * nicEvbInitMem - initialize memory for Lance chip
  622. *
  623. * Using data in the control structure, setup and initialize the memory
  624. * areas needed.  If the memory address is not already specified, then allocate
  625. * cache safe memory.
  626. *
  627. * RETURNS: OK or ERROR.
  628. */
  630. LOCAL STATUS nicEvbInitMem
  631.     (
  632.     NICEVB_END_DEVICE * pDrvCtrl /* device to be initialized */
  633.     )
  634.     {
  635.     M_CL_CONFIG mclBlkConfig;
  636.     CL_DESC clDesc; /* cluster description */
  640.     pDrvCtrl->rringSize = NIC_RBR_LEN; /* size of the whole ring */
  641.     pDrvCtrl->rringLen = pDrvCtrl->rringSize * NIC_BUF_SZ; /* rec ring len */    
  642.     pDrvCtrl->rmdIndex = 0; /* init recv buf index */
  643.     pDrvCtrl->nextPkt = CURR; /* reset to initial value */
  645.     /* for remote DMA access */
  646.     
  647.     pDrvCtrl->dmaSem = semMCreate (SEM_Q_PRIORITY);
  648.     
  649.     
  650.     /*
  651.      * Allocate receive buffers from our own private pool.
  652.      */
  654.     /* Initialize net buffer pool for tx/rx buffers */
  656.     bzero ((char *)&mclBlkConfig, sizeof(mclBlkConfig));
  657.     bzero ((char *)&clDesc, sizeof(clDesc));
  658.     
  660.     if ((pDrvCtrl->end.pNetPool = malloc (sizeof(NET_POOL))) == NULL)
  661.         return (ERROR);
  663.     mclBlkConfig.mBlkNum  = pDrvCtrl->rringSize * 8;
  664.     clDesc.clNum   = pDrvCtrl->rringSize * 8;
  665.     mclBlkConfig.clBlkNum = clDesc.clNum;
  667.     mclBlkConfig.memSize = (mclBlkConfig.mBlkNum * (MSIZE + sizeof (long))) +
  668.                           (mclBlkConfig.clBlkNum * (CL_BLK_SZ + sizeof(long)));
  670.     if ((mclBlkConfig.memArea = (char *) memalign (sizeof(long),
  671.                                                    mclBlkConfig.memSize)) == NULL)
  672.         return (ERROR);
  673.     
  676.     clDesc.clSize  = NIC_BUF_SZ;
  677.     clDesc.memSize = ((clDesc.clNum * (clDesc.clSize + 4)) + 4);
  680.    clDesc.memArea = memalign (sizeof(long), clDesc.memSize);
  681.    pDrvCtrl->pRxCluster = (NIC_CLUSTER)clDesc.memArea;
  682.    
  684.    if (clDesc.memArea == NULL)
  685.         {
  686.         DRV_LOG (DRV_DEBUG_LOAD, "system memory unavailablen", 1, 2, 3, 4, 5, 6);
  687.         return (ERROR);
  688.         }
  690.     /* Initialize the net buffer pool with transmit buffers */    
  691.     if (netPoolInit(pDrvCtrl->end.pNetPool, &mclBlkConfig,
  692.                     &clDesc, 1, NULL) == ERROR)
  693.         
  694.         {
  695.         DRV_LOG (DRV_DEBUG_LOAD, "Could not init bufferingn",
  696.                  1, 2, 3, 4, 5, 6);
  697.         return (ERROR);
  698.         }
  699.     
  700. #ifdef DRV_DEBUG
  701.     nicNetPool = *pDrvCtrl->end.pNetPool;
  702. #endif
  703.     /* Store the cluster pool id as others need it later. */
  704.     pDrvCtrl->pClPoolId = clPoolIdGet(pDrvCtrl->end.pNetPool, NIC_BUF_SZ, FALSE);
  707.     
  708.     /* Setup the receive ring */
  709.     return OK;
  710.     }
  713. /*******************************************************************************
  714. *
  715. * nicEvbStart - start the device
  716. *
  717. * This function calls BSP functions to connect interrupts and start the
  718. * device running in interrupt mode.
  719. *
  720. * RETURNS: OK or ERROR
  721. *
  722. */
  724. LOCAL STATUS nicEvbStart
  725.     (
  726.     NICEVB_END_DEVICE *pDrvCtrl
  727.     )
  728.     {
  729.     STATUS result;
  731.     pDrvCtrl->txCleaning = FALSE;
  732.     pDrvCtrl->txBlocked = FALSE;
  733.     
  734.     SYS_INT_CONNECT (pDrvCtrl, nicEvbInt, (int)pDrvCtrl, &result);
  735.     
  736.     if (result == ERROR)
  737. return ERROR;
  738.     
  739.     DRV_LOG (DRV_DEBUG_LOAD, "Interrupt connected.n", 1, 2, 3, 4, 5, 6);
  741.     /* reset the device */
  742.     nicEvbReset (pDrvCtrl);
  744.     nicEvbConfig (pDrvCtrl); /* device config */
  746.     /* mark the interface -- up */
  747.     END_FLAGS_SET (&pDrvCtrl->end, (IFF_UP | IFF_RUNNING));
  749.     
  750.     SYS_INT_ENABLE (pDrvCtrl->ivec);
  752.     
  753.     DRV_LOG (DRV_DEBUG_LOAD, "interrupt enabled.n", 1, 2, 3, 4, 5, 6);
  755.     return (OK);
  756.     }
  759. /*******************************************************************************
  760. *
  761. * nicEvbConfig - configure the NIC chip and program address
  762. *
  763. * This routine follows the algorythm in the ST-NIC manual for enabling
  764. * a NIC device on an active network.  Essentially, this routine initializes
  765. * the NIC device.
  766. *
  767. * RETURNS: N/A.
  768. */
  770. LOCAL void nicEvbConfig
  771.     (
  772.     NICEVB_END_DEVICE * pDrvCtrl /* device to be configured */    
  773.     )
  774.     {
  775.     NIC_DEVICE* pNic = pDrvCtrl->pNic;
  776.     UCHAR* pEnetAddr = pDrvCtrl->enetAddr;
  777.     
  778.     nicEvbWriteCr (pNic, RPAGE0 | STP | ABORT);
  780.     nicEvbResetDelay ();
  782.     nicEvbWriteReg (pNic, &pNic->Dcr, NOTLS | FIFO8, RPAGE0);
  784.     /* clear remote DMA byte count registers */
  786.     nicEvbWriteReg (pNic, &pNic->Rbcr0, 0, RPAGE0);             
  787.     nicEvbWriteReg (pNic, &pNic->Rbcr1, 0, RPAGE0);
  789.     /* accept broadcast and multicast, but not runt */
  791.     /* MULTI */
  792.     nicEvbWriteReg (pNic, &pNic->Rcr, AB, RPAGE0);    
  793.     nicEvbWriteReg (pNic, &pNic->Rcr, (AB | AM), RPAGE0);
  794.     nicEvbWriteReg (pNic, &pNic->Tcr, MODE1, RPAGE0); /* int loopback mode */
  796.     nicEvbWriteReg (pNic, &pNic->Pstart, PSTART, RPAGE0);
  797.     nicEvbWriteReg (pNic, &pNic->Pstop, PSTOP, RPAGE0);
  798.     nicEvbWriteReg (pNic, &pNic->Bnry, BNRY, RPAGE0);
  800.     nicEvbWriteReg (pNic, &pNic->Isr, 0xff, RPAGE0); /* clr pending ints */
  801.     nicEvbWriteReg (pNic, &pNic->Imr, PRXE | OVWE, RPAGE0); /* enable int */
  803.     
  804.     /* set up page 1 registers */
  806.     nicEvbWriteReg (pNic, &pNic->Par0, pEnetAddr [0], RPAGE1);
  807.     nicEvbWriteReg (pNic, &pNic->Par1, pEnetAddr [1], RPAGE1);
  808.     nicEvbWriteReg (pNic, &pNic->Par2, pEnetAddr [2], RPAGE1);
  809.     nicEvbWriteReg (pNic, &pNic->Par3, pEnetAddr [3], RPAGE1);
  810.     nicEvbWriteReg (pNic, &pNic->Par4, pEnetAddr [4], RPAGE1);
  811.     nicEvbWriteReg (pNic, &pNic->Par5, pEnetAddr [5], RPAGE1);
  814.     nicEvbWriteReg (pNic, &pNic->nic_pg1.mar0, 0x00, RPAGE1);
  815.     nicEvbWriteReg (pNic, &pNic->nic_pg1.mar1, 0x00, RPAGE1);
  816.     nicEvbWriteReg (pNic, &pNic->nic_pg1.mar2, 0x00, RPAGE1);
  817.     nicEvbWriteReg (pNic, &pNic->nic_pg1.mar3, 0x00, RPAGE1);
  818.     nicEvbWriteReg (pNic, &pNic->nic_pg1.mar4, 0x00, RPAGE1);
  819.     nicEvbWriteReg (pNic, &pNic->nic_pg1.mar5, 0x00, RPAGE1);
  820.     nicEvbWriteReg (pNic, &pNic->nic_pg1.mar6, 0x00, RPAGE1);
  821.     nicEvbWriteReg (pNic, &pNic->nic_pg1.mar7, 0x00, RPAGE1);
  822.     
  823.     nicEvbWriteReg (pNic, &pNic->Curr, CURR, RPAGE1);
  825.     nicEvbWriteCr (pNic, RPAGE0 | ABORT | STA); /* back to page 0 */
  826.     nicEvbWriteReg (pNic, &pNic->Tcr, MODE0, RPAGE0); /* Tx normal mode */
  827.     }
  831. /*******************************************************************************
  832. *
  833. * nicEvbResetDelay - performs the delay required before resetting the chip 
  834. *
  835. * This routine performs a 1.6 ms delay for PowerPC architecture if 
  836. * using the internal PPC time base (the number of time base increment to
  837. * count for 1.6 msec is defined by the value nicRestartDelay which must 
  838. * be set in the BSP), or waits for one system clock tick otherwise.
  839. *
  840. * RETURNS: N/A.
  841. */
  842.  
  843. LOCAL void nicEvbResetDelay (void)
  844.     {
  845. #ifdef  NIC_USE_PPCTIMEBASE
  846.     UINT32 tbu1, tbu2;
  847.     UINT32 tbl1, tbl2;
  848. #endif
  850. #ifdef  NIC_USE_PPCTIMEBASE
  851.     vxTimeBaseGet (&tbu1, &tbl1);
  852.     while (1)  {
  853.         vxTimeBaseGet (&tbu2, &tbl2);
  854.         if ((tbu2-tbu1) != 0)
  855.             vxTimeBaseGet (&tbu1, &tbl1);
  856.         else
  857.     if ((tbl2 - tbl1) > nicEvbRestartDelay)
  858.              break;
  859.         }
  860. #else
  861.     taskDelay (1);                      /* wait at least 1.6 mSec */
  862. #endif
  863.     }
  866. /*******************************************************************************
  867. *
  868. * nicEvbWriteCr - write to the NIC command register
  869. *
  870. * RETURNS: N/A.
  871. */
  873. LOCAL void nicEvbWriteCr
  874.     (
  875.     NIC_DEVICE *pNic,
  876.     UINT8 value
  877.     )
  878.     {
  879.     int level = intLock ();
  881.     do {
  882.         pNic->Cr = value;
  883.         } while (!((*(volatile UINT8 *)NIC_DMA) & ACC_MASK));
  885.     intUnlock (level);
  886.     }
  889. /*******************************************************************************
  890. *
  891. * nicEvbWriteReg - write to a NIC register
  892. *
  893. * RETURNS: N/A.
  894. */
  896. LOCAL void nicEvbWriteReg 
  897.     (
  898.     NIC_DEVICE * pNic,
  899.     volatile UINT8 * pReg,
  900.     UINT8 value,
  901.     UINT8 page
  902.     )
  903.     {
  904.     volatile UINT8 * nicDma = (volatile UINT8 *) NIC_DMA;
  905.     UINT8 cr;
  906.     int level = intLock ();
  908.     do {
  909. cr = pNic->Cr;
  910. } while (!((*nicDma) & ACC_MASK));
  912.     if ((cr & PBMASK) != page)
  913. do {
  914.     pNic->Cr = (cr & 0x3f) | page;
  915.     } while (!((*nicDma) & ACC_MASK));
  917.     do {
  918. *pReg = value;
  919. } while (!((*nicDma) & ACC_MASK));
  921.     intUnlock (level);
  922.     }
  924. /*******************************************************************************
  925. *
  926. * nicReadReg - read from a NIC register
  927. *
  928. * RETURNS: the register value.
  929. */
  931. LOCAL UINT8 nicEvbReadReg 
  932.     (
  933.     NIC_DEVICE * pNic,
  934.     volatile UINT8 * pReg,
  935.     char page
  936.     )
  937.     {
  938.     volatile UINT8 * nicDma = (volatile UINT8 *) NIC_DMA;
  939.     UINT8 cr;
  940.     int level = intLock ();
  942.     do {
  943. cr = pNic->Cr;
  944. } while (!((*nicDma) & ACC_MASK));
  946.     if ((cr & PBMASK) != page)
  947. do {
  948.     pNic->Cr = (cr & 0x3f) | page;
  949.     } while (!((*nicDma) & ACC_MASK));
  951.     do {
  952. cr = *pReg;
  953. } while (!((*nicDma) & ACC_MASK));
  955.     intUnlock (level);
  956.     return (cr);
  957.     }
  960. /*******************************************************************************
  961. *
  962. * nicEvbReadPort - read from the DMA port
  963. *
  964. * RETURNS: the DMA port value.
  965. */
  967. LOCAL UINT8 nicEvbReadPort (void)
  968.     {
  969.     UINT8 value;
  970. #ifndef NIC_FASTER
  971.     int level = intLock ();
  972. #endif
  974.     do
  975. {
  976. value = *(volatile UINT8 *) NIC_PORT;
  977.         }
  978.     while (!((*(volatile UINT8 *) NIC_DMA) & ACC_MASK));
  980. #ifndef NIC_FASTER
  981.     intUnlock (level);
  982. #endif
  983.     return (value);
  984.     }
  987. /*******************************************************************************
  988. *
  989. * nicEvbReceive - receive data from the NIC network interface
  990. *
  991. * This routine transfers data from the NIC device ring buffers via the
  992. * remote DMA.
  993. *
  994. * RETURNS: OK, always.
  995. */
  997. LOCAL STATUS nicEvbReceive 
  998.     (
  999.     NICEVB_END_DEVICE* pDrvCtrl,    
  1000.     UINT32 nicBufAddr, 
  1001.     char* pData, 
  1002.     int len
  1003.     )
  1004.     {
  1005.     NIC_DEVICE * pNic = pDrvCtrl->pNic;
  1006.     int residual;
  1007.     int dmaCnt;
  1008.     int ix;
  1010. #ifdef NIC_FASTER
  1011.     nicEvbWriteReg(pNic, &pNic->Imr, 0, RPAGE0); /* disable all interrupts */
  1012. #endif
  1014.     DRV_LOG (DRV_DEBUG_RX, "nicReceive: nicBufAddr:%u pData:%p len:%dn",
  1015.              nicBufAddr, pData, len, 0, 0, 0);        
  1016.     
  1017.     if ((nicBufAddr + len) < (PSTOP * PACKET_SIZE))
  1018. {
  1020. nicEvbWriteReg (pNic, &pNic->Rbcr0, (len & 0xff), RPAGE0);
  1021. nicEvbWriteReg (pNic, &pNic->Rbcr1, ((len & 0xff00) >> 8), RPAGE0);
  1022. nicEvbWriteReg (pNic, &pNic->Rsar0, (nicBufAddr & 0xff), RPAGE0);
  1023. nicEvbWriteReg (pNic, &pNic->Rsar1, (((nicBufAddr & 0xff00)>> 8)), RPAGE0);
  1024. nicEvbWriteCr (pNic, RREAD);
  1026. for (ix = 0; ix < len; ix ++)
  1027.     *pData++ = nicEvbReadPort ();
  1028. }
  1029.     else
  1030. {
  1032. residual = (nicBufAddr + len) - (PSTOP * PACKET_SIZE);
  1033. dmaCnt = len - residual;
  1035. nicEvbWriteReg (pNic, &pNic->Rbcr0, (dmaCnt & 0xff), RPAGE0);
  1036. nicEvbWriteReg (pNic, &pNic->Rbcr1, ((dmaCnt & 0xff00) >> 8), RPAGE0);
  1037. nicEvbWriteReg (pNic, &pNic->Rsar0, (nicBufAddr & 0xff), RPAGE0);
  1038. nicEvbWriteReg (pNic, &pNic->Rsar1, (((nicBufAddr & 0xff00)>> 8)), RPAGE0);
  1039. nicEvbWriteCr (pNic, RREAD);
  1041. for (ix = 0; ix < dmaCnt; ix++)
  1042.     *pData++ = nicEvbReadPort ();
  1044. nicEvbWriteReg (pNic, &pNic->Rbcr0, (residual & 0xff), RPAGE0);
  1045. nicEvbWriteReg (pNic, &pNic->Rbcr1, ((residual & 0xff00) >> 8), RPAGE0);
  1046. nicEvbWriteReg (pNic, &pNic->Rsar0, 0x00, RPAGE0);
  1047. nicEvbWriteReg (pNic, &pNic->Rsar1, PSTART, RPAGE0);
  1048. nicEvbWriteCr (pNic, RREAD);
  1050. for (ix = 0; ix < residual; ix++)
  1051.     *pData++ = nicEvbReadPort ();
  1052. }
  1054. #ifdef NIC_FASTER
  1055.     nicEvbWriteReg(pNic, &pNic->Imr, PRXE | OVWE, RPAGE0); /* re-enable intr. */
  1056. #endif
  1057.     return (OK);
  1058.     } 
  1060. /*******************************************************************************
  1061. *
  1062. * nicEvbPktBufRead - read data from the NIC receive ring buffer
  1063. *
  1064. * This routine gets exclusive access to the remote DMA, and calls
  1065. * nicReceive() to get data from the NIC's receive ring buffer.
  1066. *
  1067. * RETURNS: OK, or ERROR if obtaining the requested bytes encountered an error.
  1068. */
  1070. LOCAL STATUS nicEvbPktBufRead
  1071.     (
  1072.     NICEVB_END_DEVICE* pDrvCtrl,
  1073.     UINT32 nicBufAddr,
  1074.     UINT32 len,
  1075.     char* pData
  1076.     )
  1077.     {
  1078.     STATUS status = OK;
  1080.     
  1081.     /* avoid starting DMA if device is down to to fatal error */
  1083.     if ((END_FLAGS_GET(&pDrvCtrl->end) & (IFF_UP | IFF_RUNNING)) !=
  1084.         (IFF_UP | IFF_RUNNING))
  1085.         {
  1086.         DRV_LOG (DRV_DEBUG_RX, "nicPktBufRead: NOT UP and RUNNINGn",
  1087.                  0, 0, 0, 0, 0, 0);        
  1088.         return (ERROR);
  1089.         }
  1091.     if (!NIC_IS_IN_POLL_MODE())
  1092.         {
  1093.         if (semTake (pDrvCtrl->dmaSem, 100) == ERROR) /* get DMA */
  1094.             {
  1095.             DRV_LOG (DRV_DEBUG_LOAD, "nicPktBufRead: can't obtain dmaSemn",
  1096.                      0, 0, 0, 0, 0, 0);
  1097.             semTake (pDrvCtrl->dmaSem, WAIT_FOREVER);
  1098.             }
  1099.         }
  1101.     status = nicEvbReceive (pDrvCtrl, nicBufAddr, pData, len);
  1103.     if (!NIC_IS_IN_POLL_MODE())
  1104.         semGive(pDrvCtrl->dmaSem);
  1106.     return (status);
  1107.     }
  1109. /*******************************************************************************
  1110. *
  1111. * nicEvbPagePtrUpdate - updates receive buffer/page pointers
  1112. *
  1113. * This routine updates the receive buffer/page pointer and the receive
  1114. * boundary register (BNRY). The chip is re-initialized if the receive next 
  1115. * packet pointer recorded in the current packet header is out of range.
  1116. *
  1117. * RETURNS: TRUE, or FALSE if next packet pointer is out of range.
  1118. */
  1119.  
  1120. LOCAL BOOL nicEvbPagePtrUpdate
  1121.     (
  1122.     NICEVB_END_DEVICE* pDrvCtrl,
  1123.     NIC_CLUSTER pRxCluster
  1124.     )
  1125.     {
  1126.     NIC_RX_FRAME* pRx = (NIC_RX_FRAME*)pRxCluster;
  1127.     NIC_DEVICE* pNic = pDrvCtrl->pNic;
  1129.     /* update ring buffer/page pointers */
  1131.     if ((pRx->rxHdr.nextRxPage < PSTART)||(pRx->rxHdr.nextRxPage >= PSTOP))
  1132.         {
  1133.         DRV_LOG (DRV_DEBUG_LOAD,
  1134.                  "nicPagePtrUpdate: statusHeader=0x%x nextRxPage=%d IntNb=%dn",
  1135.                  pRx->rxHdr.status, pRx->rxHdr.nextRxPage, nicIntNb, 0, 0, 0);
  1137. #ifdef NIC_INSTRUMENT
  1138.      nicInitNb++;
  1139. #endif
  1140.         /* TODO MID increament error count */
  1141.         /* pDrvCtrl->idr.ac_if.if_ierrors++; */
  1143. /* restart the chip - we should never end up here - */
  1145.      /* nicEvbConfig (0); HELP was index 0 */
  1146.         nicEvbConfig (pDrvCtrl);
  1147.      pDrvCtrl->nextPkt = CURR;
  1149.         /* mark the interface -- up */
  1150.         END_FLAGS_SET (&pDrvCtrl->end,
  1151.                        (IFF_UP | IFF_RUNNING | IFF_MULTICAST | IFF_BROADCAST));    
  1153.         return (FALSE);
  1154.         }
  1156.     /* updates the Boundary pointer register (BNRY) */
  1158.     if ((pDrvCtrl->nextPkt = pRx->rxHdr.nextRxPage) == PSTART)
  1159.         nicEvbWriteReg (pNic, &pNic->Bnry, PSTOP - 1, RPAGE0);
  1160.     else
  1161.         nicEvbWriteReg (pNic, &pNic->Bnry, pDrvCtrl->nextPkt - 1, RPAGE0);
  1163.     return (TRUE);
  1164.     }
  1166. /*******************************************************************************
  1167. *
  1168. * nicEvToStack - passes received data to stack
  1169. *
  1170. * This routine grabs a MBuf from the pool, assigns data pointer to pointes the 
  1171. * receive data and passes the MBuf to stack.
  1172. *
  1173. * RETURNS: OK, or ERROR in case of any error.
  1174. */
  1175. LOCAL STATUS nicEvbToStack
  1176.     (
  1177.     NICEVB_END_DEVICE* pDrvCtrl, /* the device */
  1178.     NIC_CLUSTER pCluster
  1179.     )
  1180.     {
  1181.     NIC_RX_FRAME* pRx = (NIC_RX_FRAME*)pCluster;    
  1182.     CL_BLK_ID pClBlk;
  1183.     M_BLK_ID pMblk;
  1184.     UINT32 len;
  1185.     STATUS nRetValue = ERROR;
  1187.     len = pRx->rxHdr.cntL + (pRx->rxHdr.cntH << 8) - NIC_ETH_CRC_LEN;
  1188.     
  1189.     if ((pClBlk = netClBlkGet (pDrvCtrl->end.pNetPool, M_DONTWAIT)) == NULL)
  1190.         {
  1191.         DRV_LOG (DRV_DEBUG_RX, "Out of Cluster Blocks!n", 1, 2, 3, 4, 5, 6);
  1192.         netClFree (pDrvCtrl->end.pNetPool, pCluster);        
  1193.         END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1194.         goto cleanRXD;
  1195.         }
  1197.     /*
  1198.      * OK we've got a spare, let's get an M_BLK_ID and marry it to the
  1199.      * one in the ring.
  1200.      */
  1202.     if ((pMblk = mBlkGet(pDrvCtrl->end.pNetPool, M_DONTWAIT, MT_DATA)) ==
  1203.         NULL)
  1204.         {
  1205.         netClBlkFree (pDrvCtrl->end.pNetPool, pClBlk);
  1206.         netClFree (pDrvCtrl->end.pNetPool, pCluster);                
  1207.         DRV_LOG (DRV_DEBUG_MB, "Out of M Blocks!n", 1, 2, 3, 4, 5, 6);
  1208.         END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1209.         goto cleanRXD;
  1210.         }
  1212.     END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_UCAST, +1);
  1215.     /* Join the cluster to the MBlock */
  1217.     netClBlkJoin (pClBlk, (char*)pCluster, len, NULL, 0, 0, 0);
  1218.     netMblkClJoin (pMblk, pClBlk);
  1220.     /* make the packet data coherent */
  1221.     /* LN_CACHE_INVALIDATE (pMblk->mBlkHdr.mData, len); */
  1223.     /* pMblk->mBlkHdr.mData += pDrvCtrl->offset; */
  1224.     NIC_FRAME_DATA_ADDR_GET(pCluster);    
  1225.     pMblk->mBlkHdr.mLen = len;
  1226.     pMblk->mBlkHdr.mData = pCluster;
  1227.     pMblk->mBlkHdr.mFlags |= M_PKTHDR;
  1228.     pMblk->mBlkPktHdr.len = len;
  1231.     /* Call the upper layer's receive routine. */
  1232.     END_RCV_RTN_CALL(&pDrvCtrl->end, pMblk);
  1234.     return nRetValue;
  1236. cleanRXD:
  1238.     return OK;
  1239.     }
  1242. /*******************************************************************************
  1243. *
  1244. * nicEvbRead - read a packet off the interface ring buffer
  1245. *
  1246. * nicRead copies packets from local memory into an mbuf and hands it to
  1247. * the next higher layer (IP).
  1248. *
  1249. * RETURNS: TRUE, or FALSE if the packet reception encountered errors.
  1250. */
  1252. LOCAL BOOL nicEvbRead
  1253.     (
  1254.     NICEVB_END_DEVICE* pDrvCtrl
  1255.     )
  1256.     {
  1257.     NIC_CLUSTER pRxCluster;    
  1258.     DRV_LOG (DRV_DEBUG_POLL, "Start Read!n", 1, 2, 3, 4, 5, 6);    
  1260.     pRxCluster = (NIC_CLUSTER)nicEvbReadFrame (pDrvCtrl);
  1262.     /* Pass the data up to the stack */    
  1263.     if (pRxCluster == NULL)
  1264.         return FALSE;
  1265.     
  1266.     nicEvbToStack (pDrvCtrl, pRxCluster);
  1268.     return (TRUE);
  1270.     }
  1272. /*******************************************************************************
  1273. *
  1274. * nicEvbReadFrame - read a packet off the interface ring buffer into a cluster
  1275. *
  1276. * Allocates a new cluster from the cluster pool, and reads the frame from the
  1277. * device into the cluster.
  1278. *
  1279. * RETURNS: a cluster or NULL if any error
  1280. */
  1281. LOCAL NIC_CLUSTER nicEvbReadFrame
  1282.     (
  1283.     NICEVB_END_DEVICE* pDrvCtrl
  1284.     )
  1285.     {
  1286.     NIC_RX_FRAME* pRx;
  1287.     UINT32 len; /* len of Rx pkt */
  1288.     int cur;
  1289.     NIC_CLUSTER pRetCluster = NULL;
  1290.     NIC_DEVICE* pNic = pDrvCtrl->pNic; /* NIC registers */
  1291.     
  1292.     if (!(END_FLAGS_GET(&pDrvCtrl->end) & (IFF_UP | IFF_RUNNING)) ||
  1293.         (pDrvCtrl->nextPkt == (cur = nicEvbReadReg (pNic, &pNic->Curr,
  1294.                                                     RPAGE1))))
  1295.         return (pRetCluster);
  1297.     /*
  1298.      * OK, there is work to be done.
  1299.      * First we copy the NIC receive status header from the NIC buffer
  1300.      * into our local area. This is done so that we can obtain the length
  1301.      * of the packet before copying out the rest of it. Note that the length
  1302.      * field in the NIC header includes the Ethernet header, the data, and
  1303.      * the 4 byte FCS field.
  1304.      */
  1306.     /* Get a cluster */
  1307.     if ((pRx = (NIC_RX_FRAME*)netClusterGet(pDrvCtrl->end.pNetPool,
  1308.                                            pDrvCtrl->pClPoolId)) == NULL)
  1309.         {
  1310.         DRV_LOG (DRV_DEBUG_RX, "Cannot loan!n", 1, 2, 3, 4, 5, 6);
  1311.         END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1312.         return (pRetCluster);
  1313.         }
  1314.     
  1316.     /* read header in cluster*/
  1317.     DRV_LOG (DRV_DEBUG_RX, "nicPktBufRead : Reading Headern", 1, 2, 3, 4, 5, 6);    
  1318.     if (nicEvbPktBufRead (pDrvCtrl, pDrvCtrl->nextPkt << 8,
  1319.                           (NIC_RX_HDR_SZ), (char *) &pRx->rxHdr) == ERROR)
  1320.         {
  1322.         DRV_LOG (DRV_DEBUG_RX,
  1323.                  "nicRead could not read packet headern",
  1324.                  0, 0, 0, 0, 0, 0);
  1325.         return (pRetCluster);
  1326.         }
  1328.     /* TODO */
  1329.     len = pRx->rxHdr.cntL + (pRx->rxHdr.cntH << 8) - NIC_ETH_CRC_LEN;
  1330.     
  1331.     /* valid frame checks */
  1333.     /*
  1334.      * NOTE: if the packet's receive status byte indicates an error
  1335.      * the packet is discarded and the receive page pointers are updated to
  1336.      * point to the next packet.
  1337.      */
  1339. #ifdef NIC_INSTRUMENT
  1340.     nicLen = len;
  1341.     nicHdrStat = pRx->rxHdr.status;
  1342.     nicNextPage = pRx->rxHdr.nextRxPage;
  1343.     nicCurrentPage = cur;
  1344. #endif
  1346.     if ((len < 60) || (len > 1514) || ((pRx->rxHdr.status & ~PHY) != PRX))
  1347. {
  1348.         /* TODO increament error count */
  1349. /* pDrvCtrl->idr.ac_if.if_ierrors++; */
  1351.         DRV_LOG (DRV_DEBUG_LOAD,
  1352.                  "nicRead receive error: statusHeader=0x%x nextRxPage=%d 
  1353.                            currentPage=%d len=%d IntNb=%dn",
  1354.                  pRx->rxHdr.status, pRx->rxHdr.nextRxPage, cur,len,nicIntNb,
  1355.                  0);
  1356.         
  1357.         END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1359. nicEvbPagePtrUpdate (pDrvCtrl, (NIC_CLUSTER)pRx);
  1361.         return (pRetCluster);
  1362. }
  1364.     /* copy Ethernet packet section of the frame */
  1365.     
  1366.     DRV_LOG (DRV_DEBUG_RX, "nicPktBufRead : Reading Framen",
  1367.              1, 2, 3, 4, 5, 6);
  1368.     
  1369.     if (nicEvbPktBufRead (pDrvCtrl, (pDrvCtrl->nextPkt << 8) + NIC_RX_HDR_SZ,
  1370.                           len, (char *) &pRx->enetHdr) == ERROR)
  1371.         {
  1373.         DRV_LOG (DRV_DEBUG_LOAD, "nicRead: Could not read packet datan",
  1374.                  0, 0, 0, 0, 0, 0);
  1376.         END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);        
  1378. nicEvbPagePtrUpdate(pDrvCtrl, (NIC_CLUSTER)pRx);
  1379.         return (pRetCluster);
  1380.         
  1381. }
  1383.     /* update ring buffer/page pointers */
  1384.     if (!nicEvbPagePtrUpdate (pDrvCtrl, (NIC_CLUSTER)pRx))
  1385. {
  1386. return (pRetCluster);
  1387. }
  1389.     END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_UCAST, +1);    
  1391.     DRV_LOG (DRV_DEBUG_POLL, "End Read!n", 1, 2, 3, 4, 5, 6);     
  1393.     return (NIC_CLUSTER)pRx;
  1394.     }
  1397. /*******************************************************************************
  1398. *
  1399. * nicEvbRestart - restart chip after receive ring buffer overflow
  1400. *
  1401. * This routine is the task-level handler that deals with a receive DMA
  1402. * overflow condition.  It gets access to the remote DMA, cleans up NIC
  1403. * registers, empties the receive ring buffers, and then resends any
  1404. * packet that was in the midst of transmission when the overflow hit.
  1405. *
  1406. * RETURNS: N/A.
  1407. */
  1409. LOCAL void nicEvbRestart
  1410.     (
  1411.     NICEVB_END_DEVICE* pDrvCtrl,
  1412.     UINT8 cr
  1413.     )
  1414.     {
  1415.     NIC_DEVICE * pNic = pDrvCtrl->pNic; /* NIC registers */
  1416.     BOOL resend = FALSE;
  1420. #ifdef NIC_INSTRUMENT
  1421.     nicRestartNb++;
  1423. #endif
  1424.     nicEvbWriteCr (pNic, STP);
  1427.     nicEvbResetDelay (); /* wait at least 1.6 mSec */
  1430.     if(!NIC_IS_IN_POLL_MODE())
  1431.         {
  1432.         if (semTake(pDrvCtrl->dmaSem, 100) == ERROR)
  1433.             {
  1434.             DRV_LOG (DRV_DEBUG_LOAD, "nicRestart: can't obtain dmaSemn",
  1435.                      0, 0, 0, 0, 0,0);
  1436.             semTake (pDrvCtrl->dmaSem, WAIT_FOREVER);
  1437.             }
  1438.         }
  1440.     nicEvbWriteReg (pNic, &pNic->Rbcr0, 0, RPAGE0);
  1441.     nicEvbWriteReg (pNic, &pNic->Rbcr1, 0, RPAGE0);
  1443.     if ((cr & TXP) && (!(nicEvbReadReg (pNic, &pNic->Isr, RPAGE0) &
  1444.         (TXE | PTX))))
  1445.      resend = TRUE;
  1447.     nicEvbWriteReg (pNic, &pNic->Tcr, MODE1, RPAGE0);
  1448.     nicEvbWriteCr (pNic, RPAGE0 | ABORT | STA); /* back to page 0 */
  1450.     END_FLAGS_SET (&pDrvCtrl->end, IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);
  1452.     /*
  1453.      * Release the dmaSem semaphore here since a) it will be re-acquired
  1454.      * later if needed and b) we don't want to hold it while sending things
  1455.      * up the stack since this may cause a deadlock if an application
  1456.      * tries to send something down the stack to us. (The send routine
  1457.      * will try to acquire the semaphore while we're still holding it
  1458.      * here.)
  1459.      */
  1460.  
  1461.     if(!NIC_IS_IN_POLL_MODE())
  1462.         semGive(pDrvCtrl->dmaSem);
  1464.     while (nicEvbRead (pDrvCtrl))
  1465. ;
  1467.     if(!NIC_IS_IN_POLL_MODE())
  1468.         {
  1469.         if (semTake(pDrvCtrl->dmaSem, 100) == ERROR)
  1470.             {
  1471.             DRV_LOG (DRV_DEBUG_LOAD, "nicRestart: can't obtain dmaSemn",
  1472.                      0, 0, 0, 0, 0,0);
  1473.             semTake (pDrvCtrl->dmaSem, WAIT_FOREVER);
  1474.             }
  1475.         }
  1477.     nicEvbWriteReg(pNic, &pNic->Isr, OVW, RPAGE0);
  1478.     nicEvbWriteReg (pNic, &pNic->Tcr, MODE0, RPAGE0);
  1480.     if (resend)
  1481.         nicEvbWriteCr (pNic, RPAGE0 | STA | TXP | ABORT);
  1483.     if(!NIC_IS_IN_POLL_MODE())
  1484.         semGive(pDrvCtrl->dmaSem);
  1486.     nicEvbWriteReg (pNic, &pNic->Imr, PRXE | OVWE, RPAGE0);
  1487.     }
  1490. /*******************************************************************************
  1491. *
  1492. * nicEvbHandleInt - deferred receive interrupt handler
  1493. *
  1494. * This function handles the received frames from the device.  It runs in the
  1495. * context of the netTask, which was triggered by a received packet interrupt.
  1496. * Actual processing of the packet is done by calling nicEvbRead().
  1497. *
  1498. * RETURNS: N/A.
  1499. */
  1501. LOCAL void nicEvbHandleInt
  1502.     (
  1503.     NICEVB_END_DEVICE* pDrvCtrl    
  1504.     )
  1505.     {
  1506.     /* empties the receive ring buffer of its packets */
  1508.     while (nicEvbRead (pDrvCtrl));
  1509.     }
  1514. /*******************************************************************************
  1515. *
  1516. * nicIntr - The driver's interrupt handler
  1517. *
  1518. * This function clears the cause of the device interrupt(s) and then acts
  1519. * on the individual possible causes.  The primary goal of this routine is to
  1520. * minimize the time spent in it.  This is accomplished by deferring processing
  1521. * to the netTask via the netJobAdd() function.
  1522. *
  1523. * Note that in case the receiver overruns, we promptly mark the interface as
  1524. * "down" and leave error handling to task-level.   This is in case netTask
  1525. * is in the midst of DMA activity, we must allow it to complete.  The receive
  1526. * handler will give up when it discovers the interface is down, which will
  1527. * then allow netTask to run our OVW handler.  This provides a nice orderly
  1528. * error recovery.
  1529. *
  1530. * RETURNS: N/A.
  1531. */
  1533. LOCAL void nicEvbInt
  1534.     (
  1535.     NICEVB_END_DEVICE* pDrvCtrl
  1536.     )
  1537.     {
  1538.     NIC_DEVICE * pNic = pDrvCtrl->pNic; /* NIC registers */
  1539.     UINT8 isr; /* copy of ISR */
  1540.     UINT8 cr; /* copy of CR */
  1542. #ifdef DRV_DEBUG
  1543.     nicIntNb++;
  1544. #endif
  1546.     DRV_LOG (DRV_DEBUG_INT, "Inside INTn", 1, 2, 3, 4, 5, 6);
  1547.     
  1548.     isr = nicEvbReadReg(pNic, &pNic->Isr, RPAGE0);
  1549.     nicEvbWriteReg(pNic, &pNic->Isr, isr, RPAGE0);
  1552.     /* handle receiver overrun */
  1554.     if  ((isr & OVW) && (END_FLAGS_GET(&pDrvCtrl->end) & (IFF_UP | IFF_RUNNING)))
  1555. {
  1556. cr = nicEvbReadReg (pNic, &pNic->Cr, RPAGE0);
  1558. nicEvbWriteReg(pNic, &pNic->Imr, 0, RPAGE0); /* disable all interrupts */
  1560.         /* mark the interface -- down */
  1561.         END_FLAGS_CLR (&pDrvCtrl->end, IFF_UP | IFF_RUNNING);
  1562.         
  1563. netJobAdd ((FUNCPTR) nicEvbRestart, (int) pDrvCtrl, cr, 0, 0, 0);
  1564.         return;
  1565. }
  1567.     /* handle packet received */
  1569.     if  ((isr & PRX) && (END_FLAGS_GET(&pDrvCtrl->end) & (IFF_UP | IFF_RUNNING)))
  1570. netJobAdd ((FUNCPTR) nicEvbHandleInt, (int) pDrvCtrl, 0, 0, 0, 0);
  1571.     }
  1574. /*******************************************************************************
  1575. *
  1576. * nicEvbSend - the driver's actual output routine
  1577. *
  1578. * This routine accepts outgoing packets from the snd queue, and then 
  1579. * gains exclusive access to the DMA (through a mutex semaphore),
  1580. * then calls nicEvbTransmit() to send the packet out onto the interface.
  1581. *
  1582. * RETURNS: OK, or ERROR if the packet could not be transmitted.
  1583. */
  1585. LOCAL STATUS nicEvbSend
  1586.     (
  1587.     NICEVB_END_DEVICE* pDrvCtrl,
  1588.     M_BLK* pMblk
  1589.     )
  1590.     {
  1591.     int status = OK;
  1593.     DRV_LOG(DRV_DEBUG_TX, "Begin nicEvbSend pDrvCtrl %p pMblk %pn", pDrvCtrl,
  1594.             pMblk, 0, 0, 0, 0);
  1596.     if ((END_FLAGS_GET(&pDrvCtrl->end) & (IFF_UP | IFF_RUNNING)) !=
  1597.         (IFF_UP | IFF_RUNNING))
  1598.         {
  1599.         DRV_LOG(DRV_DEBUG_TX, "Device is NOT UP and RUNNINGn", 0, 0,
  1600.                 0, 0, 0, 0);
  1601. if(!NIC_IS_IN_POLL_MODE())
  1602.         netMblkClChainFree (pMblk); /* free the given mBlk chain */
  1603.         errno = EINVAL;
  1604.         return (ERROR);
  1605.         }
  1607.     if(!NIC_IS_IN_POLL_MODE())
  1608.         {
  1609.         if (semTake (pDrvCtrl->dmaSem, 100) == ERROR) /* get DMA access */
  1610.             {
  1611.             DRV_LOG(DRV_DEBUG_TX, "nicTxStartup: can't obtain dmaSemn",
  1612.                       0, 0, 0, 0, 0, 0);
  1613.             semTake (pDrvCtrl->dmaSem, WAIT_FOREVER);
  1614.             }
  1615.         }
  1617.     /* update statistics */
  1618.     END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_UCAST, +1);
  1620. #ifdef NIC_INSTRUMENT
  1621.     nicTxNb++;
  1622. #endif
  1624.     /* send packet out over interface */
  1626.     if ((status = nicEvbTransmit (pDrvCtrl, pMblk, TRUE)) == ERROR)
  1627.         {
  1629.         DRV_LOG(DRV_DEBUG_TX, "FAILED nicEvbTransmitn", 0, 0, 0, 0, 0, 0);
  1630.         
  1631.         /* update statistics */
  1632.         END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_UCAST, +1);
  1634.         /* TODO update error count */
  1635.         }
  1637.     if(!NIC_IS_IN_POLL_MODE())
  1638. {
  1639.         semGive (pDrvCtrl->dmaSem);
  1641.      /* free the Mblk chain */
  1642.     
  1643.      netMblkClChainFree (pMblk);
  1644. }
  1646.     
  1647.     DRV_LOG(DRV_DEBUG_TX, "End nicEvbSend n", 0, 0, 0, 0, 0, 0);    
  1648.     
  1649.     return status;    
  1650.     }
  1655. /*******************************************************************************
  1656. *
  1657. * nicEvbTransmit - send data over the NIC network interface
  1658. *
  1659. * This routine transfers data to the NIC device via the remote DMA, and
  1660. * then signal for a transmission.
  1661. *
  1662. * RETURNS: OK, or ERROR if the transmitter signalled an error.
  1663. */
  1665. LOCAL STATUS nicEvbTransmit
  1666.     (
  1667.     NICEVB_END_DEVICE* pDrvCtrl,    
  1668.     M_BLK* pMblk,
  1669.     BOOL waitFlag
  1670.     )
  1671.     {
  1672.     NIC_DEVICE * pNic = pDrvCtrl->pNic;
  1673.     UINT8 cr;
  1674.     UINT8 isr;
  1675.     UINT8* pBuf;
  1676.     int status = OK;
  1677.     int count;
  1678.     int ix;
  1679.     int len;
  1680.     int tranxLen;
  1682.     /* find the length of the packet */    
  1683.     len = nicEvbMblkDataLenGet (pMblk);
  1684.     
  1685.     /* find the length of the packet */
  1686.     tranxLen = max (len, MINPKTSIZE);
  1687.     
  1688. #ifdef NIC_FASTER
  1689.     nicWriteReg(pNic, &pNic->Imr, 0, RPAGE0);   /* disable all interrupts */
  1690. #endif
  1692.     nicEvbWriteReg (pNic, &pNic->Rbcr0, 0x10, RPAGE0);
  1693.     nicEvbWriteCr (pNic, RREAD);
  1695.     nicEvbWriteReg (pNic, &pNic->Rbcr0, (tranxLen & 0x00ff), RPAGE0);
  1696.     nicEvbWriteReg (pNic, &pNic->Rbcr1, (tranxLen & 0xff00) >> 8, RPAGE0);
  1697.     nicEvbWriteReg (pNic, &pNic->Rsar0, 0x00, RPAGE0);
  1698.     nicEvbWriteReg (pNic, &pNic->Rsar1, 0x00, RPAGE0);
  1699.     nicEvbWriteCr (pNic, RWRITE);
  1700.     
  1701.     count = 0;
  1703.     while (pMblk != NULL)
  1704.         {
  1705.         pBuf = (char *)pMblk->mBlkHdr.mData;
  1706.         len  = pMblk->mBlkHdr.mLen;
  1708. for (ix = 0 ; ix < len; ix++)
  1709.     { 
  1710.     count++;
  1711.     nicEvbWritePort (*pBuf++);
  1712.     }
  1713.         pMblk = pMblk->mBlkHdr.mNext;
  1714.         }
  1715.     
  1716.     for (; count < tranxLen; count ++) /* pad out if too short */
  1717. nicEvbWritePort (0);
  1719.     nicEvbWriteReg (pNic, &pNic->Tpsr, 0x00, RPAGE0);
  1720.     nicEvbWriteReg (pNic, &pNic->Tbcr0, (tranxLen & 0x000000ff), RPAGE0);
  1721.     nicEvbWriteReg (pNic, &pNic->Tbcr1, ((tranxLen & 0x0000ff00) >> 8), RPAGE0);
  1723.     cr = nicEvbReadReg (pNic, &pNic->Cr, RPAGE0);
  1724.     nicEvbWriteReg(pNic, &pNic->Isr, (PTX | TXE), RPAGE0);
  1725.     nicEvbWriteCr (pNic, TXP | (cr & (RWRITE | RREAD))); /* start Tx */
  1727.     count = 0;
  1728.     if (waitFlag) /* wait for Tx to end ? */
  1729. {
  1730.         while (count++ < NIC_TRANS_TIMEOUT) /* only poll a few times */
  1731.     {
  1732.             isr = nicEvbReadReg (pNic, &pNic->Isr, RPAGE0);
  1734.     if (isr & TXE) /* error encountered */
  1735.         {
  1736.                 DRV_LOG(DRV_DEBUG_TX, "ERROR in Transmitionn", 
  1737.                           0, 0, 0, 0, 0, 0);                                
  1738.                 status = ERROR;
  1739.         break;
  1740.         }
  1742.     if (isr & PTX) /* Tx done */
  1743.                 {
  1744.                 DRV_LOG(DRV_DEBUG_TX, "Transmit Donen", 
  1745.                           0, 0, 0, 0, 0, 0);                
  1746.         break;
  1747.                 }
  1748.             }
  1750.         if (count >= NIC_TRANS_TIMEOUT) /* error ? */
  1751.     {
  1752.             status = ERROR;
  1753. #ifdef NIC_INSTRUMENT
  1754.     nicTxTimeout++;
  1755. #endif
  1757.             DRV_LOG(DRV_DEBUG_LOAD, "nicTransmit TRANS_TIMEOUT %dn",
  1758.                     nicTxTimeout,0,0,0,0,0);
  1759.     }
  1760.         }
  1762. #ifdef NIC_FASTER
  1763.     nicEvbWriteReg(pNic, &pNic->Imr, PRXE | OVWE, RPAGE0); /* re-enable intr. */
  1764. #endif
  1765.     return (status);
  1766.     }
  1768. /*******************************************************************************
  1769. *
  1770. * nicEvbMblkDataLenGet - gets the total len of the given Mblk chain packet
  1771. *
  1772. * RETURNS: length of the packet.
  1773. *
  1774. */
  1775. LOCAL int nicEvbMblkDataLenGet
  1776.     (
  1777.     M_BLK* pMblk
  1778.     )
  1779.     {
  1780.     int nPktChainLen = 0;
  1782.     while (pMblk != NULL)
  1783.         {
  1784.         nPktChainLen += pMblk->mBlkHdr.mLen;
  1785.         pMblk = pMblk->mBlkHdr.mNext;
  1786.         }
  1787.         
  1788.     return (nPktChainLen);
  1789.     }
  1792. /*******************************************************************************
  1793. *
  1794. * nicEnetAddrGet - get the Ethernet address.
  1795. *
  1796. * Get ethernet address from the BSP.
  1797. *
  1798. * RETURNS: N/A.
  1799. */
  1801. LOCAL void nicEvbEnetAddrGet
  1802.     (
  1803.     NICEVB_END_DEVICE* pDrvCtrl,
  1804.     char* pAddress
  1805.     )
  1806.     {
  1807.     UINT8 enetAdrs[6];
  1808.     UINT8 count;
  1810.     if (sysEnetAddrGet (pDrvCtrl->unit, enetAdrs) != ERROR )
  1811.         {
  1812.         for (count=0; count<6; count++)
  1813.             pAddress[count] = enetAdrs[5-count];
  1814.         }
  1815.     }
  1818. /*******************************************************************************
  1819. *
  1820. * nicEvbWritePort - write to the DMA port
  1821. *
  1822. * RETURNS: N/A.
  1823. */
  1825. LOCAL void nicEvbWritePort
  1826.     (
  1827.     UINT8 value
  1828.     )
  1829.     {
  1830. #ifndef NIC_FASTER
  1831.     int level = intLock ();
  1832. #endif
  1834.     do 
  1835. {
  1836. *(volatile char *) NIC_PORT = value;
  1837.         }
  1838.     while (!((*(volatile UINT8 *) NIC_DMA) & ACC_MASK));
  1839. #ifndef NIC_FASTER
  1840.     intUnlock (level);
  1841. #endif
  1842.     }    
  1843.     
  1844. /*******************************************************************************
  1845. *
  1846. * nicIoctl - the driver's I/O control routine
  1847. *
  1848. * Perform device-specific commands.
  1849. *
  1850. * RETURNS: 0, or EINVAL if the command 'cmd' is not supported.
  1851. */
  1853. LOCAL int nicEvbIoctl
  1854.     (
  1855.     NICEVB_END_DEVICE* pDrvCtrl,
  1856.     int cmd,
  1857.     caddr_t data    
  1858.     )
  1859.     {
  1860.     int error = 0;
  1862.     DRV_LOG (DRV_DEBUG_LOAD, "nicEvbIoctl Command %dn", cmd, 2, 3, 4, 5, 6);
  1863.     
  1864.     switch (cmd)
  1865. {
  1866.         case EIOCSADDR:
  1867.     if (data == NULL)
  1868. return (EINVAL);
  1869.             bcopy ((char *)data, (char *)END_HADDR(&pDrvCtrl->end),
  1870.    END_HADDR_LEN(&pDrvCtrl->end));
  1871.             nicEvbConfig (pDrvCtrl); /* HELP  Will it work? */
  1872.             break;
  1874.         case EIOCGADDR:
  1875.     if (data == NULL)
  1876. return (EINVAL);
  1877.             bcopy ((char *)END_HADDR(&pDrvCtrl->end), (char *)data,
  1878.     END_HADDR_LEN(&pDrvCtrl->end));
  1879.             break;
  1881.         case EIOCSFLAGS:/* no driver-dependent flags */
  1882.             break;
  1884.         case EIOCGFLAGS:
  1885.     *(int *)data = END_FLAGS_GET(&pDrvCtrl->end);
  1886.             break;
  1888.         case EIOCMULTIADD:                   /* move to mux */
  1889.             error = nicEvbMCastAddrAdd (pDrvCtrl, (char *)data);
  1890.             break;
  1892.         case EIOCMULTIDEL:                   /* move to mux */
  1893.             error = nicEvbMCastAddrDel (pDrvCtrl, (char *)data);
  1894.             break;
  1896.         case EIOCMULTIGET:                   /* move to mux */
  1897.             error = nicEvbMCastAddrGet (pDrvCtrl, (MULTI_TABLE *)data);
  1898.             break;
  1900.         case EIOCPOLLSTART:                  /* move to mux */
  1901.             error = nicEvbPollStart (pDrvCtrl);
  1902.             break;
  1904.         case EIOCPOLLSTOP:                   /* move to mux */
  1905.             error = nicEvbPollStop (pDrvCtrl);
  1906.             break;            
  1908.         case EIOCGMIB2:
  1909.             if (data == NULL)
  1910.                 return (EINVAL);
  1911.             bcopy((char *)&pDrvCtrl->end.mib2Tbl, (char *)data,
  1912.                   sizeof(pDrvCtrl->end.mib2Tbl));
  1913.             break;
  1915.         default:
  1916.             error = EINVAL;
  1917. }
  1918.     return (error);
  1919.     } 
  1922. /*******************************************************************************
  1923. *
  1924. * nicEvbStop - stop the device
  1925. *
  1926. * This function calls BSP functions to disconnect interrupts and stop
  1927. * the device from operating in interrupt mode.
  1928. *
  1929. * RETURNS: OK or ERROR
  1930. */
  1932. LOCAL STATUS nicEvbStop
  1933.     (
  1934.     NICEVB_END_DEVICE* pDrvCtrl
  1935.     )
  1936.     {
  1937.     STATUS result = OK;
  1938.     NIC_DEVICE* pNic = pDrvCtrl->pNic;    
  1940.     /* Stop the device. */
  1941.     nicEvbWriteReg(pNic, &pNic->Imr, 0, RPAGE0);  /* disable all interrupts */
  1943.     SYS_INT_DISCONNECT (pDrvCtrl, nicEvbInt, (int)pDrvCtrl, &result);
  1945.     if (result == ERROR)
  1946. {
  1947. DRV_LOG (DRV_DEBUG_LOAD, "Could not diconnect interrupt!n",
  1948.                  1, 2, 3, 4, 5, 6);
  1949. }
  1951.     return (result);
  1952.     }
  1954. /******************************************************************************
  1955. *
  1956. * nicEvbUnload - unload a driver from the system
  1957. *
  1958. * This function first brings down the device, and then frees any
  1959. * stuff that was allocated by the driver in the load function.
  1960. */
  1962. LOCAL STATUS nicEvbUnload
  1963.     (
  1964.     NICEVB_END_DEVICE* pDrvCtrl
  1965.     )
  1966.     {
  1967.     if (pDrvCtrl != NULL)
  1968.         {
  1969.         END_OBJECT_UNLOAD (&pDrvCtrl->end);
  1971.         /* free cluster memory */
  1972.         if (pDrvCtrl->pRxCluster != NULL)
  1973.             free (pDrvCtrl->pRxCluster);
  1974.         }
  1975.     return (OK);
  1976.     }
  1980. /*******************************************************************************
  1981. *
  1982. * nicEvbMCastAddrAdd - add a multicast address
  1983. *
  1984. *
  1985. * RETURNS: OK on success, ERROR otherwise.
  1986. */
  1988. LOCAL STATUS nicEvbMCastAddrAdd
  1989.     (
  1990.     NICEVB_END_DEVICE * pDrvCtrl,
  1991.     char * pAddr
  1992.     )
  1993.     {
  1994.     int retVal;
  1996.     DRV_LOG (DRV_DEBUG_IOCTL, "MCastAddrAddn", 0, 0, 0, 0, 0, 0);
  1998.     retVal = etherMultiAdd (&pDrvCtrl->end.multiList, pAddr);
  2000.     if (retVal == ENETRESET)
  2001.         nicEvbAddrFilterSet (pDrvCtrl, pAddr, TRUE);
  2003.     return OK; /*((retVal == OK) ? OK : ERROR);*/
  2004.     }
  2006. /*******************************************************************************
  2007. *
  2008. * nicEvbMCastAddrDel - remove a multicast address
  2009. *
  2010. *
  2011. * RETURNS: OK on success, ERROR otherwise.
  2012. */
  2014. LOCAL STATUS nicEvbMCastAddrDel
  2015.     (
  2016.     NICEVB_END_DEVICE * pDrvCtrl,
  2017.     char * pAddr
  2018.     )
  2019.     {
  2020.     int retVal;
  2022.     DRV_LOG (DRV_DEBUG_IOCTL, "MCastAddrDeln", 0, 0, 0, 0, 0, 0);
  2024.     retVal = etherMultiDel (&pDrvCtrl->end.multiList, pAddr);
  2026.     if (retVal == ENETRESET)
  2027.         nicEvbAddrFilterSet (pDrvCtrl, pAddr, FALSE);
  2029.     return OK; /*((retVal == OK) ? OK : ERROR);*/
  2030.     }
  2033. /*******************************************************************************
  2034. *
  2035. * nicEvbMCastAddrGet - retreive current multicast address list
  2036. *
  2037. *
  2038. * RETURNS: OK on success; otherwise ERROR.
  2039. */
  2041. LOCAL STATUS nicEvbMCastAddrGet
  2042.     (
  2043.     NICEVB_END_DEVICE * pDrvCtrl,
  2044.     MULTI_TABLE *pTable
  2045.     )
  2046.     {
  2047.     DRV_LOG (DRV_DEBUG_IOCTL, "MCastAddrGetn", 0, 0, 0, 0, 0, 0);
  2049.     return (etherMultiGet (&pDrvCtrl->end.multiList, pTable));
  2050.     }
  2053. /*(FIXED)*/
  2055. /*******************************************************************************
  2056. *
  2057. * nicEvbPollStart - starting polling mode
  2058. *
  2059. * RETURNS: OK, always.
  2060. */
  2062. LOCAL STATUS nicEvbPollStart
  2063.     (
  2064.     NICEVB_END_DEVICE * pDrvCtrl
  2065.     )
  2066.     {
  2067.     int intLevel;
  2068.     NIC_DEVICE* pNic = pDrvCtrl->pNic; /* address of NIC chip */
  2070.     DRV_LOG (DRV_DEBUG_POLL, "S ", 0, 0, 0, 0, 0, 0);
  2072.     intLevel = intLock();
  2074.     /* disable all interrupts */
  2075.     nicEvbWriteReg (pNic, &pNic->Imr, 0x00, RPAGE0);
  2076.     DRV_FLAGS_SET(NIC_FLAG_POLL);
  2078.     intUnlock (intLevel);
  2080.     return (OK);    
  2081.     }
  2083. /*******************************************************************************
  2084. *
  2085. * nicEvbPollStop - stop polling mode
  2086. *
  2087. * RETURNS: OK, always.
  2088. */
  2090. LOCAL STATUS nicEvbPollStop
  2091.     (
  2092.     NICEVB_END_DEVICE * pDrvCtrl
  2093.     )
  2094.     {
  2095.     NIC_DEVICE* pNic = pDrvCtrl->pNic; /* address of NIC chip */
  2096.     int intLevel;
  2098.     intLevel = intLock();
  2100.     nicEvbWriteReg (pNic, &pNic->Imr, PRXE | OVWE, RPAGE0); /* enable int */
  2101.     DRV_FLAGS_CLR(NIC_FLAG_POLL);
  2103.     DRV_LOG (DRV_DEBUG_POLL, "s", 0, 0, 0, 0, 0, 0);
  2104.     
  2105.     intUnlock (intLevel);
  2107.     return (OK);
  2108.     }
  2110. /*******************************************************************************
  2111. *
  2112. * nicEvbPollSend - send a packet in polled mode
  2113. *
  2114. * RETURNS: OK on success, EAGAIN on failure
  2115. */
  2117. LOCAL STATUS nicEvbPollSend
  2118.     (
  2119.     NICEVB_END_DEVICE* pDrvCtrl,
  2120.     M_BLK* pMblk
  2121.     )
  2122.     {
  2123.     return (nicEvbSend (pDrvCtrl, pMblk));
  2124.     }
  2126. /*******************************************************************************
  2127. *
  2128. * nicEvbPollReceive - get a packet in polled mode
  2129. *
  2130. * RETURNS: OK on success, EAGAIN on failure.
  2131. */
  2133. LOCAL STATUS nicEvbPollReceive
  2134.     (
  2135.     NICEVB_END_DEVICE* pDrvCtrl,
  2136.     M_BLK* pMblk
  2137.     )
  2138.     {
  2139.     STATUS nRetValue = OK;
  2140.     NIC_CLUSTER pCluster;
  2141.     int len;
  2142.     
  2143.     DRV_LOG (DRV_DEBUG_POLL, "Start Poll Read!n", 1, 2, 3, 4, 5, 6);
  2144.     if ((pCluster = nicEvbReadFrame (pDrvCtrl)) == NULL)
  2145.         nRetValue = EAGAIN;
  2146.     else
  2147.         {
  2148.         NIC_RX_FRAME* pRx = (NIC_RX_FRAME*)pCluster;
  2149.         
  2150.         len = pRx->rxHdr.cntL + (pRx->rxHdr.cntH << 8) - NIC_ETH_CRC_LEN;
  2151.     
  2152. pMblk->mBlkHdr.mFlags |= M_PKTHDR; /* set the packet header */
  2153. pMblk->mBlkHdr.mLen = len;    /* set the data len */
  2154. pMblk->mBlkPktHdr.len = len;    /* set the total len */
  2156.         NIC_FRAME_DATA_ADDR_GET(pCluster);
  2158.         bcopy (pCluster, (char *)pMblk->mBlkHdr.mData, len);
  2159.         netClFree (pDrvCtrl->end.pNetPool, (char*)pRx);
  2160.         
  2161.         }
  2162.     
  2163.     DRV_LOG (DRV_DEBUG_POLL, "End Poll Read!n", 1, 2, 3, 4, 5, 6);        
  2164.     return nRetValue;
  2165.     }
  2168. /*******************************************************************************
  2169. *
  2170. * nicEvbHashIndex - compute the hash index for an ethernet address
  2171. *
  2172. * RETURNS: hash index for an ethernet address.
  2173. */
  2175. LOCAL int nicEvbHashIndex
  2176.     (
  2177.     char * eAddr
  2178.     )
  2179.     {
  2180.     UINT8 eAddrByte;
  2181.     int index;                       /* hash index - return value */
  2182.     int byte;                        /* loop - counter */
  2183.     int bit;                         /* loop - counter */
  2184.     UINT crc = 0xffffffff;
  2185.     UINT8 msb;
  2187.     for (byte=0; byte<6; byte++)
  2188.         {
  2189.         eAddrByte = eAddr[byte];
  2191.         for (bit=0; bit<8; bit++)
  2192.             {
  2193.             msb = crc >> 31;
  2194.             crc <<= 1;
  2195.             if (msb ^ (eAddrByte & 0x1))
  2196.                 {
  2197.                 crc ^= NIC_CRC_POLY;
  2198.                 crc |= 0x1;
  2199.                 }
  2200.             eAddrByte >>= 1;
  2201.             }
  2202.         }
  2204.     /* Just want the 6 most significant bits. */
  2205.     
  2206.     index = crc >> 26 ;
  2208.     return index;
  2209.     }
  2210.  
  2212. /******************************************************************************
  2213. *
  2214. * nicEvbAddrFilterSet - set the address filter for multicast addresses
  2215. *
  2216. * This routine goes through all of the multicast addresses on the list
  2217. * of addresses (added with the MCastAddrAdd() routine) and sets the
  2218. * device's filter correctly.
  2219. *
  2220. * NOMANUAL
  2221. */
  2223. LOCAL void nicEvbAddrFilterSet
  2224.     (
  2225.     NICEVB_END_DEVICE *pDrvCtrl,
  2226.     char* pAddr,
  2227.     BOOL bSet
  2228.     )
  2229.     {
  2231.     UINT8 nHashIndex;
  2234.     /* get hash index for the address */
  2235.     nHashIndex = nicEvbHashIndex (pAddr);
  2237.     /* Turn on the corresponding bit in the filter. */
  2238.     nicEvbMARSet (pDrvCtrl, nHashIndex, bSet);
  2240.     }
  2242. /*******************************************************************************
  2243. *
  2244. * nicEvbMARSet - sets/resets the MAR for the specified hash index
  2245. *
  2246. * This routine sets/resets the MAR bit for the specified hash index
  2247. *
  2248. * RETURNS: OK or ERROR.
  2249. */
  2250. LOCAL void nicEvbMARSet
  2251.     (
  2252.     NICEVB_END_DEVICE* pDrvCtrl,    
  2253.     UINT8 index, /* hash index */
  2254.     BOOL bSet /* Set/Reset */
  2255.     )
  2256.     {
  2257.     UINT8 nRegOffset = index;
  2258.     UINT8 nBitPosition = index;
  2259.     UINT8 nBitMask = (UINT8)0x01;
  2260.     UINT8 nValue;
  2261.     char* pMAR = (char*)pDrvCtrl->pNic;
  2262.     
  2263.     /* Finde register and bit position */
  2264.     nBitPosition = nBitPosition & 0x07;  /* 3 LSB bits */
  2265.     nRegOffset >>= 3;      /* next 3 bits */
  2266.     nBitMask <<= nBitPosition;
  2267.     pMAR += NIC_IR_MAR0 + nRegOffset;
  2269.     /* set the bit in bit array*/
  2270.     nValue = nicEvbReadReg (pDrvCtrl->pNic, pMAR, RPAGE1);
  2272.     DRV_LOG (DRV_DEBUG_LOAD, "Hash Index:%d MAR Offset:%d value:%dn",
  2273.              index, nRegOffset, nValue, 4, 5, 6);
  2274.     
  2275.     if (bSet)
  2276.         {
  2277.         nValue |= nBitMask; /* set */
  2278.         }
  2279.     else
  2280.         {
  2281.         nBitMask = ~nBitMask; /* reset */
  2282.         nValue &= nBitMask;        
  2283.         }
  2284.     
  2285.     nicEvbWriteReg (pDrvCtrl->pNic, pMAR, nValue, RPAGE1);
  2286.     
  2287.     DRV_LOG (DRV_DEBUG_LOAD, "Hash Index:%d MAR Offset:%d value:%dn",
  2288.              index, nRegOffset, nValue, 4, 5, 6);
  2289.     
  2290.     }
  2292. /* (OLD) */
  2297. /*******************************************************************************
  2298. *
  2299. * nicReset - reset of interface
  2300. *
  2301. * This routine performs a software reset of the ST-NIC device.
  2302. *
  2303. * RETURNS: N/A.
  2304. *
  2305. * NOMANUAL
  2306. */
  2308. LOCAL void nicEvbReset
  2309.     (
  2310.     NICEVB_END_DEVICE* pDrvCtrl
  2311.     )
  2312.     {
  2314.     NIC_DEVICE * pNic = pDrvCtrl->pNic;
  2316.     nicEvbWriteCr (pNic, STP | ABORT | RPAGE0);
  2318.     taskDelay (2); /* wait at least 1.6 mSec */
  2319.     }