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

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

VxWorks

开发平台：

C/C++

ns83902End.c：源码内容
  1. /* ns83902End.c - National Semiconductor DP83902A ST-NIC */ 
  3. /* Copyright 1998-2002 Wind River Systems, Inc. */
  4. /* Copyright 1998-2000 Hitachi ULSI Systems Co.,LTD.,All Rights Reserved */
  6. /*
  7. modification history
  8. --------------------
  9. 01j,24apr02,h_k  changed dummy read to read from pDrvCtrl->ioPort (SPR #74019).
  10. 01i,25mar02,h_k  changed overrun handling to be done in ISR and transmit
  11.                  buffer taking from a static data (SPR #74019).
  12. 01h,14jan02,dat  Removing warnings from Diab compiler
  13. 01g,10oct01,dat  SPR 70829, driver used fp register - fixed., removed warnings,
  14.  fixed casts for netClFree, fixed macros
  15. 01f,03oct00,zl   ns83902Send() frees the Mblk chain in non-polled mode only.
  16. 01e,23may00,zl   minor code cleanup.
  17. 01d,29apr00,zl   redone TX interrupts, register read/write.
  18. 01c,21apr00,zl   call netMblkClChainFree only if TX succeeds, use TX interrupts
  19.                   instead of polling.
  20. 01b,10apr00,zl   renamed file to ns83902End.c
  21. 01a,20sep99,zl   written based on nicMsEnd.c and nicEvbEnd.c
  22. */
  24. /*
  26. This module implements the National Semiconductor dp83902A ST-NIC Ethernet
  27. network interface driver.
  29. This driver is moderately generic.  The driver must be given several 
  30. target-specific parameters.  These parameters, and the mechanisms used 
  31. to communicate them to the driver, are detailed below.
  33. The driver supports big-endian or little-endian architectures.
  35. EXTERNAL INTERFACE
  37. The only external interface is the ns83902EndLoad() routine, which expects
  38. the <initString> parameter as input.  This parameter passes in a 
  39. colon-delimited string of the format:
  41.  "<baseAdrs>:<intVec>:<intLvl>:<dmaPort>:<bufSize>:<options>"
  43. The ns83902EndLoad() function uses strtok() to parse the string.
  45. TARGET-SPECIFIC PARAMETERS
  47. .IP "unit"
  49. A convenient holdover from the former model.  This parameter is used only
  50. in the string name for the driver.
  52. .IP "baseAdrs"
  54. Base address at which the NIC hardware device registers are located.
  56. .IP "vecNum"
  58. This is the interrupt vector number of the hardware interrupt generated by
  59. this Ethernet device.
  61. .IP "intLvl"
  63. This parameter defines the level of the hardware interrupt.
  65. .IP "dmaPort"
  67. Address of the DMA port used to transfer data to the host CPU.
  69. .IP "bufSize"
  71. Size of the NIC buffer memory in bytes.
  73. .IP "options"
  75. Target specific options:
  76.     bit0 - wide (0: byte, 1: word)
  77.     bit1 - register interval (0: 1byte, 1: 2 bytes)
  79. EXTERNAL SUPPORT REQUIREMENTS
  81. This driver requires four external support functions, and provides a hook
  82. function:
  84. .iP "void sysLanIntEnable (int level)" "" 9 -1
  86. This routine provides a target-specific interface for enabling Ethernet device
  87. interrupts at a specified interrupt level.
  89. .iP "void sysLanIntDisable (void)" "" 9 -1
  91. This routine provides a target-specific interface for disabling Ethernet device
  92. interrupts.
  94. .iP "STATUS sysEnetAddrGet (int unit, char *enetAdrs)" "" 9 -1
  96. This routine provides a target-specific interface for accessing a device
  97. Ethernet address.
  99. .iP "sysNs83902DelayCount" "" 9 -1
  101. This variable is used to introduce at least a 4 bus cycle (BSCK) delay between
  102. successive NIC chip selects.
  105. SYSTEM RESOURCE USAGE
  107. This driver requires the following system resources:
  109.     - one mutual exclusion semaphore
  110.     - one interrupt vector
  112. SEE ALSO: muxLib,
  113. .I "DP83902A ST-NIC Serial Interface Controller for Twisted Pair"
  115. */
  117. /* configurations */
  119. #undef NS83902_INSTRUMENT /* instrument the driver */
  120. #undef NS83902_DEBUG /* log debug messages */
  122. /* includes */
  124. #include "vxWorks.h"
  125. #include "iv.h"
  126. #include "vme.h"
  127. #include "net/mbuf.h"
  128. #include "net/unixLib.h"
  129. #include "net/protosw.h"
  130. #include "sys/socket.h"
  131. #include "sys/ioctl.h"
  132. #include "errno.h"
  133. #include "memLib.h"
  134. #include "intLib.h"
  135. #include "net/route.h"
  136. #include "iosLib.h"
  137. #include "errnoLib.h"
  138. #include "logLib.h"
  140. #include "cacheLib.h"
  141. #include "netLib.h"
  142. #include "stdio.h"
  143. #include "stdlib.h"
  144. #include "sysLib.h"
  146. #include "etherLib.h"
  147. #include "net/systm.h"
  148. #include "sys/times.h"
  149. #include "net/if_subr.h"
  151. #include  "drv/end/ns83902End.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"
  161. /* defines */
  163. #define NS83902_DEV_NAME "nic"
  164. #define NS83902_DEV_NAME_LEN 4
  165. #define NS83902_EADR_LEN 6
  166. #define NS83902_SPEED 10000000 /* 10Mbps or 100Mbps */
  167. #define NS83902_CRC_POLY 0x04c11db7
  169. #define IMR_DISABLE 0
  170. #define IMR_ENABLE (IMR_PRXE | IMR_OVWE | IMR_PTXE | IMR_TXEE)
  171. #define IMR_RX_DISABLE (IMR_OVWE | IMR_PTXE | IMR_TXEE)
  173. /* debug macros */
  175. #ifdef NS83902_DEBUG
  177. #ifdef LOCAL
  178. #undef LOCAL
  179. #define LOCAL
  180. #endif
  182. #define NS83902_DEBUG_OFF 0x0000
  183. #define NS83902_DEBUG_RX 0x0001
  184. #define NS83902_DEBUG_TX 0x0002
  185. #define NS83902_DEBUG_INT 0x0004
  186. #define NS83902_DEBUG_POLL (NS83902_DEBUG_POLL_RX | NS83902_DEBUG_POLL_TX)
  187. #define NS83902_DEBUG_POLL_RX 0x0008
  188. #define NS83902_DEBUG_POLL_TX 0x0010
  189. #define NS83902_DEBUG_LOAD 0x0020
  190. #define NS83902_DEBUG_IOCTL 0x0040
  191. #define NS83902_DEBUG_POLL_REDIR 0x10000
  192. #define NS83902_DEBUG_LOG_NVRAM 0x20000
  193. #define NS83902_DEBUG_MB 0x40000
  194. #define NS83902_DEBUG_TMP 0x80000
  196. int ns83902Debug = NS83902_DEBUG_OFF;
  198. NET_POOL   ns83902NetPool; /* global for easy access of end.pNetPool */
  199. void *     ns83902EndDevice; /* global for easy access of the device */
  200. CL_POOL_ID ns83902ClPoolId; /* global for easy access to cluster pool */
  201. SEM_ID     ns83902DmaSemId; /* global for easy access to sem ID */
  203. #define DRV_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)
  204.     if (ns83902Debug & FLG)
  205. logMsg(X0, X1, X2, X3, X4, X5, X6);
  207. #else /* NS83902_DEBUG */
  209. #define DRV_LOG(DBG_SW, X0, X1, X2, X3, X4, X5, X6)
  211. #endif /* NS83902_DEBUG */
  214. /*
  215.  * Default macro definitions for BSP interface.
  216.  * These macros can be redefined in a wrapper file, to generate
  217.  * a new module with an optimized interface.
  218.  */
  220. #ifndef SYS_INT_CONNECT
  221. #define SYS_INT_CONNECT(pDrvCtrl,rtn,arg,pResult) 
  222.     do {
  223.     *pResult = intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (pDrvCtrl->ivec),
  224.      rtn, (int)arg); 
  225.     } while (0)
  226. #endif /* SYS_INT_CONNECT */
  228. #ifndef SYS_INT_DISCONNECT
  229. #define SYS_INT_DISCONNECT(pDrvCtrl,rtn,arg,pResult) 
  230.     do { 
  231.     *pResult = OK; 
  232.     } while (0)
  233. #endif /* SYS_INT_DISCONNECT */
  235. #ifndef SYS_INT_ENABLE
  236. #define SYS_INT_ENABLE(pDrvCtrl) 
  237.     do { 
  238.     IMPORT void sysLanIntEnable(int);      
  239.     sysLanIntEnable (pDrvCtrl->ilevel);
  240.     } while (0)
  241. #endif /* SYS_INT_ENABLE */
  243. #ifndef SYS_INT_DISABLE
  244. #define SYS_INT_DISABLE(pDrvCtrl)                                       
  245.     do {                                                                
  246.     IMPORT STATUS sysLanIntDisable(int);
  247.     sysLanIntDisable(pDrvCtrl->ilevel);
  248.     } while (0)
  249. #endif /*SYS_INT_DISABLE*/
  251. #ifndef SYS_ENET_ADDR_GET
  252. #define SYS_ENET_ADDR_GET(pDrvCtrl, pAddress) 
  253.     do { 
  254.     IMPORT STATUS sysEnetAddrGet (int, char*);
  255.     sysEnetAddrGet (pDrvCtrl->unit, pAddress); 
  256.     } while (0)
  257. #endif /* SYS_ENET_ADDR_GET */
  259. #ifndef SYS_NS83902_DELAY
  260. #define SYS_NS83902_DELAY() 
  261.     do {
  262.     IMPORT UINT32 sysNs83902DelayCount; 
  263.     volatile UINT32 cx = 0;
  264.     for (cx = 0; cx < sysNs83902DelayCount; cx++)
  265. /* spin */ ;  
  266.     } while (0)
  267. #endif /* SYS_NS83902_DELAY */
  269. #ifndef SYS_MS_DELAY
  270. #define SYS_MS_DELAY(delay)
  271.     do {
  272.     IMPORT void sysMsDelay (UINT);
  273.     sysMsDelay (delay);
  274.     } while (0)
  275. #endif /* SYS_MS_DELAY */
  277. #ifndef SYS_IN_SHORT
  278. #define SYS_IN_SHORT(pDrvCtrl,addr,data) 
  279.     do { 
  280.     ((data) = *((volatile USHORT *)(addr))); 
  281.     } while (0)
  282. #endif /* SYS_IN_SHORT*/
  284. #ifndef SYS_OUT_SHORT
  285. #define SYS_OUT_SHORT(pDrvCtrl,addr,value) 
  286.     do { 
  287.     *((volatile USHORT *)(addr)) = (value); 
  288.     } while (0)
  289. #endif /* SYS_OUT_SHORT */
  291. #ifndef SYS_IN_BYTE
  292. #define SYS_IN_BYTE(pDrvCtrl, addr, data) 
  293.     do { 
  294.     ((data) = *((volatile UCHAR *)(addr))); 
  295.     } while (0)
  296. #endif /* SYS_IN_BYTE */
  298. #ifndef SYS_OUT_BYTE
  299. #define SYS_OUT_BYTE(pDrvCtrl, addr, value) 
  300.     do { 
  301.     *((volatile UCHAR *)(addr)) = (value); 
  302.     } while (0)
  303. #endif /* SYS_OUT_BYTE */
  305. /* Setting/Getting on-chip registers */
  307. #define NS83902_CR_GET(pDrvCtrl, value)
  308.     do {
  309.     SYS_IN_BYTE ((pDrvCtrl),
  310.  ((pDrvCtrl)->pNic + 
  311.  (NS83902_CR) * (pDrvCtrl)->regInterval), 
  312.  (value));
  313.     SYS_NS83902_DELAY(); 
  314.     } while (0)
  316. #define NS83902_CR_SET(pDrvCtrl, value)
  317.     do { 
  318.     SYS_OUT_BYTE ((pDrvCtrl),
  319.   ((pDrvCtrl)->pNic + 
  320.   (NS83902_CR) * (pDrvCtrl)->regInterval), 
  321.   (value));
  322.     SYS_NS83902_DELAY(); 
  323.     } while (0)
  325. #define NS83902_REG_GET(pDrvCtrl, reg, value, page) 
  326.     (value = ns83902RegRead (pDrvCtrl, reg, page))
  328. #define NS83902_REG_SET(pDrvCtrl, reg, value, page)
  329.     (ns83902RegSet (pDrvCtrl, reg, value, page))
  332. /* Macros for dealing with flags */
  334. #define DRV_FLAGS_SET(setBits)                                          
  335.     (pDrvCtrl->flags |= (setBits))
  337. #define DRV_FLAGS_ISSET(setBits)                                        
  338.     (pDrvCtrl->flags & (setBits))
  340. #define DRV_FLAGS_CLR(clrBits)                                          
  341.     (pDrvCtrl->flags &= ~(clrBits))
  343. #define DRV_FLAGS_GET()                                                 
  344.     (pDrvCtrl->flags)
  346. #define NS83902_IS_IN_POLL_MODE()
  347.     ((DRV_FLAGS_GET() & NS83902_FLAG_POLL) == NS83902_FLAG_POLL)
  349. #define NS83902_SEM_TAKE(pDrvCtrl, timeout)
  350.     semTake ((pDrvCtrl)->endObj.txSem, timeout)
  352. #define NS83902_SEM_GIVE(pDrvCtrl)
  353.     semGive((pDrvCtrl)->endObj.txSem)
  355. /* A shortcut for getting the hardware address from the MIB II stuff. */
  357. #define END_HADDR(pEnd)
  358.     ((pEnd)->mib2Tbl.ifPhysAddress.phyAddress)
  360. #define END_HADDR_LEN(pEnd) 
  361.     ((pEnd)->mib2Tbl.ifPhysAddress.addrLength)
  363. #define END_FLAGS_ISSET(pEnd, setBits) 
  364.     ((pEnd)->flags & (setBits))
  367. /*
  368.  * Macros for read and write descriptors.
  369.  *
  370.  */
  372. #define NS83902_RX_BUF_SZ sizeof(NS83902_RX_FRAME)
  373. #define NS83902_RX_HDR_SZ sizeof(NS83902_RX_HDR)
  374. #define NS83902_ETH_CRC_LEN 4
  376. /* typedefs */
  378. typedef struct rx_hdr
  379.     {
  380. #if (_BYTE_ORDER == _BIG_ENDIAN)
  381.     UINT8 nextRxPage; /* page next pkt starts at */
  382.     UINT8 status; /* status of packet */
  383. #else
  384.     UINT8 status; /* status of packet */
  385.     UINT8 nextRxPage; /* page next pkt starts at */
  386. #endif
  387.     UINT16       count;          /* frame length */
  388.     } NS83902_RX_HDR;
  391. typedef struct rx_frame
  392.     {
  393.     UINT16 pad1;
  394.     NS83902_RX_HDR rxHdr; /* receive status header */
  395.     ENET_HDR enetHdr; /* ethernet header */
  396.     UINT8 data[ETHERMTU]; /* frame data */
  397.     } NS83902_RX_FRAME;
  399. typedef char* NS83902_CLUSTER;
  401. typedef struct ns83902_end_device /* driver control structure */
  402.     {
  403.     END_OBJ endObj; /* The class we inherit from. */
  404.     END_ERR lastError; /* Last error passed to muxError */
  405.     int unit; /* unit number */
  406.     int rringSize; /* RMD ring size */
  407.     UCHAR enetAddr[NS83902_EADR_LEN]; /* ethernet address */
  408.     char* pNic; /* address of NIC chip */
  409.     char* ioPort; /* port address of remote DMA */
  410.     NS83902_CLUSTER pCluster; /* Rx frame memory */
  411.     CL_POOL_ID pClPoolId; /* cluster pool */
  412.     int regInterval; /* address diff of adjacent regs */
  413.     BOOL wide; /* I/O port is 16 bit (when TRUE) */
  414.     int          ivec; /* interrupt vector */
  415.     int ilevel; /* interrupt level */
  416.     UINT8 regPage; /* current register page */
  417.     UINT8 txStartPage; /* ptr to Tx start buffer */
  418.     UINT8 rxStartPage; /* ptr to Rx start buffer */
  419.     UINT8 rxStopPage; /* ptr to Rx stop buffer */
  420.     UINT8 nextPage; /* ptr to next page */
  421.     NS83902_DRV_FLAG flags; /* device specific flags */
  422.     BOOL rxHandling; /* rcv task is scheduled */
  423.     BOOL txBlocked; /* to implement flow control */
  424.     BOOL rxOvw; /* overwrite warning */
  425.     BOOL txResend; /* resend need at overwrite */
  426.     } NS83902_END_DEVICE;
  428. /* network buffers configuration */
  430. M_CL_CONFIG ns83902MclBlkConfig =  /* network mbuf configuration table */
  431.     {
  432.     /* 
  433.     no. mBlks no. clBlks memArea memSize
  434.     --------- ---------- ------- -------
  435.     */
  436.     0,  0,  NULL,  0
  437.     };
  439. CL_DESC ns83902ClDescTbl [] = /* cluster pool configuration table */
  440.     {
  441.     /* 
  442.     clSize num memArea memSize
  443.     ------ ---- ------- -------
  444.     */
  445.     {0, 0, NULL, 0}
  446.     }; 
  448. int ns83902ClDescTblNumEnt = (NELEMENTS(ns83902ClDescTbl));
  451. /* globals */
  453. #ifdef NS83902_INSTRUMENT
  454. UINT32  ns83902TxTimeout = 0;   /* number of transmit time-out */
  455. UINT32  ns83902TxError = 0;     /* number of transmit errors */
  456. UINT32 ns83902RestartNb = 0; /* number of restart due to ring overflow */
  457. UINT32 ns83902InitNb = 0; /* number of time device is re-initialized */
  458. UINT32 ns83902TxNb = 0; /* number of transmitted packets */
  459. UINT32 ns83902IntNb = 0; /* number of receive interrupt */
  460. UINT32 ns83902Len = 0; /* lenght of the current received packet */
  461. UINT32 ns83902HdrStat = 0; /* status byte of the current received packet */
  462. UINT32 ns83902NextPage = 0; /* page pointer to the next received packet */
  463. UINT32 ns83902CurrentPage = 0; /* start page of the current packet */
  464. #endif
  466. /* forward declarations */
  468. LOCAL void  ns83902MARSet (NS83902_END_DEVICE* pDrvCtrl, UINT8 index, 
  469.        BOOL bSet);
  470. LOCAL STATUS  ns83902AddrFilterSet (NS83902_END_DEVICE *pDrvCtrl, 
  471.       char* pAddr, BOOL bSet);
  472. LOCAL int ns83902HashIndex (char* eAddr);
  473. LOCAL void ns83902Int (NS83902_END_DEVICE* pDrvCtrl);
  474. LOCAL void ns83902Restart (NS83902_END_DEVICE *pDrvCtrl, UINT8 cr);
  475. LOCAL void ns83902HandleInt (NS83902_END_DEVICE *pDrvCtrl);
  476. LOCAL void ns83902Recv (NS83902_END_DEVICE *pDrvCtrl,
  477.      NS83902_CLUSTER pCluster);
  478. LOCAL NS83902_CLUSTER ns83902ReadFrame (NS83902_END_DEVICE* pDrvCtrl);
  479. LOCAL void  ns83902Config (NS83902_END_DEVICE* pDrvCtrl);
  480. LOCAL STATUS ns83902PktBufRead (NS83902_END_DEVICE *pDrvCtrl, UINT32
  481.                                   ns83902BufAddr, UINT32 len, char *pData);
  482. LOCAL STATUS ns83902Transmit (NS83902_END_DEVICE *pDrvCtrl, M_BLK* pMblk);
  483. LOCAL void ns83902ReadPort (NS83902_END_DEVICE* pDrvCtrl, 
  484.  char *pBuf, int len);
  485. LOCAL void  ns83902WritePort (NS83902_END_DEVICE* pDrvCtrl, 
  486.   char *pBuf, int len);
  487. LOCAL STATUS  ns83902InitParse (NS83902_END_DEVICE* pDrvCtrl, 
  488.   char * initString);
  489. LOCAL STATUS  ns83902InitMem (NS83902_END_DEVICE* pDrvCtrl);
  490. LOCAL void ns83902EnetAddrGet (NS83902_END_DEVICE* pDrvCtrl, char* addr);
  491. LOCAL void  ns83902RegSet (NS83902_END_DEVICE* pDrvCtrl, int reg, 
  492.        int value, int page);
  493. LOCAL UINT8  ns83902RegRead (NS83902_END_DEVICE* pDrvCtrl, int reg, 
  494.        int page);
  497. /* END Specific interfaces. */
  499. END_OBJ * ns83902EndLoad (char *initString);
  500. LOCAL STATUS ns83902Unload (NS83902_END_DEVICE* pDrvCtrl);
  501. LOCAL STATUS ns83902Start (NS83902_END_DEVICE* pDrvCtrl);
  502. LOCAL STATUS ns83902Stop (NS83902_END_DEVICE* pDrvCtrl);
  503. LOCAL int ns83902Ioctl (NS83902_END_DEVICE* pDrvCtrl, int cmd, 
  504.       caddr_t data);
  505. LOCAL STATUS ns83902Send (NS83902_END_DEVICE* pDrvCtrl, M_BLK *pMblk);
  508. LOCAL STATUS ns83902MCastAddrAdd (NS83902_END_DEVICE *pDrvCtrl, 
  509.      char* pAddress);
  510. LOCAL STATUS ns83902MCastAddrDel (NS83902_END_DEVICE *pDrvCtrl, 
  511.      char* pAddress);
  512. LOCAL STATUS ns83902MCastAddrGet (NS83902_END_DEVICE *pDrvCtrl, 
  513.                                      MULTI_TABLE *pTable);
  514. LOCAL STATUS ns83902PollSend (NS83902_END_DEVICE *pDrvCtrl, M_BLK *pMblk);
  515. LOCAL STATUS ns83902PollReceive (NS83902_END_DEVICE *pDrvCtrl, M_BLK *pMblk);
  516. LOCAL STATUS ns83902PollStart (NS83902_END_DEVICE *pDrvCtrl);
  517. LOCAL STATUS ns83902PollStop (NS83902_END_DEVICE *pDrvCtrl);
  520. /*
  521.  * Declare our function table.  This is static across all driver
  522.  * instances.
  523.  */
  524. LOCAL NET_FUNCS ns83902FuncTable =
  525.     {
  526.     (FUNCPTR)ns83902Start, /* Function to start the device. */
  527.     (FUNCPTR)ns83902Stop, /* Function to stop the device. */
  528.     (FUNCPTR)ns83902Unload, /* Unloading function */
  529.     (FUNCPTR)ns83902Ioctl, /* Ioctl function */
  530.     (FUNCPTR)ns83902Send, /* Send function */
  531.     (FUNCPTR)ns83902MCastAddrAdd, /* Multicast address add */
  532.     (FUNCPTR)ns83902MCastAddrDel, /* Multicast address delete */
  533.     (FUNCPTR)ns83902MCastAddrGet, /* Multicast table retrieve */
  534.     (FUNCPTR)ns83902PollSend, /* Polling send function  */
  535.     (FUNCPTR)ns83902PollReceive, /* Polling receive function */
  536.     endEtherAddressForm, /* Put address info into a packet.  */
  537.     endEtherPacketDataGet, /* Get a pointer to packet data. */
  538.     endEtherPacketAddrGet, /* Get packet addresses. */
  539.     NULL /* Bind function */
  540.     };
  542. /******************************************************************************
  543. *
  544. * ns83902EndLoad - initialize the driver and device
  545. *
  546. * This routine initializes the driver and the device to the operational state.
  547. * All of the device-specific parameters are passed in <initString>.
  548. * This routine can be called in two modes. If it is called with an empty but
  549. * allocated string, it places the name of this device (that is, "ln") into 
  550. * the <initString> and returns 0.
  551. *
  552. * If the string is allocated and not empty, the routine attempts to load
  553. * the driver using the values specified in the string.
  554. *
  555. * RETURNS: An END object pointer, or NULL on error, or 0 and the name of the
  556. * device if the <initString> was NULL.
  557. */
  559. END_OBJ* ns83902EndLoad
  560.     (
  561.     char* initString /* string to be parsed */
  562.     )
  563.     {
  564.     NS83902_END_DEVICE *pDrvCtrl;
  566.     DRV_LOG (NS83902_DEBUG_LOAD, "Loading ns83902End...n", 1, 2, 3, 4, 5, 6);
  568.     if (initString == NULL)
  569.         return (NULL);
  570.     
  571.     if (initString[0] == '')
  572.         {
  573.         bcopy((char *)NS83902_DEV_NAME, initString, NS83902_DEV_NAME_LEN);
  574.         return (0);
  575.         }
  576.     
  577.     /* allocate the device structure */
  579.     pDrvCtrl = (NS83902_END_DEVICE *)calloc (sizeof (NS83902_END_DEVICE), 1);
  580.     if (pDrvCtrl == NULL)
  581. goto errorExit;
  583.     /* parse the init string, filling in the device structure */
  585.     if (ns83902InitParse (pDrvCtrl, initString) == ERROR)
  586. goto errorExit;
  587.     
  588.     /* Have the BSP hand us our address. */
  590.     ns83902EnetAddrGet (pDrvCtrl, (char*) &(pDrvCtrl->enetAddr));
  592.     DRV_LOG (NS83902_DEBUG_LOAD, "ENET Addr: %x:%x:%x:%x:%x:%x n",
  593.              pDrvCtrl->enetAddr[0], pDrvCtrl->enetAddr[1], 
  594.      pDrvCtrl->enetAddr[2], pDrvCtrl->enetAddr[3], 
  595.      pDrvCtrl->enetAddr[4], pDrvCtrl->enetAddr[5]);
  597.     /* initialize the END and MIB2 parts of the structure */
  599.     if (END_OBJ_INIT (&pDrvCtrl->endObj, (DEV_OBJ *)pDrvCtrl, NS83902_DEV_NAME,
  600.     pDrvCtrl->unit, &ns83902FuncTable,
  601.                       "ST-NIC Enhanced Network Driver") == ERROR
  602.      || END_MIB_INIT (&pDrvCtrl->endObj, M2_ifType_ethernet_csmacd,
  603.                       &pDrvCtrl->enetAddr[0], NS83902_EADR_LEN, ETHERMTU,
  604.                       NS83902_SPEED)
  605.     == ERROR)
  606. goto errorExit;
  608.     /* set buffer address; reserve 8 pages for TX */
  610.     pDrvCtrl->txStartPage = 0;
  611.     pDrvCtrl->rxStartPage = pDrvCtrl->txStartPage + 8;
  612.     pDrvCtrl->nextPage    = pDrvCtrl->rxStartPage;
  614.     /* size of the whole ring */
  616.     pDrvCtrl->rringSize = pDrvCtrl->rxStopPage - pDrvCtrl->rxStartPage + 1;
  618.     /* Perform memory allocation */
  620.     if (ns83902InitMem (pDrvCtrl) == ERROR)
  621. {
  622. DRV_LOG (NS83902_DEBUG_LOAD, "Error in InitMem...n", 1, 2, 3, 4, 5, 6);
  623. goto errorExit;
  624. }
  626.     /* set the flags to indicate readiness */
  628.     END_OBJ_READY (&pDrvCtrl->endObj,
  629.                    IFF_NOTRAILERS | IFF_MULTICAST | IFF_BROADCAST);
  630.     
  631.     DRV_LOG (NS83902_DEBUG_LOAD, "Done loading ns83902End...n", 1, 2, 3, 4, 5, 6);
  634.     /* save the device address */
  636. #ifdef NS83902_DEBUG
  637.     ns83902EndDevice = pDrvCtrl;
  638.     ns83902DmaSemId  = pDrvCtrl->endObj.txSem;
  639. #endif
  641.     return (&pDrvCtrl->endObj);
  643. errorExit:
  645.     ns83902Unload (pDrvCtrl);
  646.     return NULL;
  647.     }
  649. /*******************************************************************************
  650. *
  651. * ns83902InitParse - parse the initialization string
  652. *
  653. * Parse the input string and fill in values in the driver control structure.
  654. *
  655. * RETURNS: OK, or ERROR if any arguments are invalid.
  656. */
  658. LOCAL STATUS ns83902InitParse
  659.     (
  660.     NS83902_END_DEVICE * pDrvCtrl,
  661.     char * initString
  662.     )
  663.     {
  664.     char * tok;
  665.     char * pHolder = NULL;
  666.     long address;
  667.     UINT8 options;
  668.     
  669.     /* Parse the initString */
  671.     /* Unit number. */
  673.     tok = strtok_r (initString, ":", &pHolder);
  674.     if (tok == NULL)
  675. return ERROR;
  676.     pDrvCtrl->unit = atoi (tok);
  678.     /* NIC address. */
  679.     
  680.     tok = strtok_r (NULL, ":", &pHolder);
  681.     if (tok == NULL)
  682. return ERROR;
  683.     address = strtoul (tok, NULL, 16);
  684.     pDrvCtrl->pNic = (char*) address;
  686.     /* Interrupt vector. */
  688.     tok = strtok_r (NULL, ":", &pHolder);
  689.     if (tok == NULL)
  690. return ERROR;
  691.     pDrvCtrl->ivec = atoi (tok);
  693.     /* Interrupt level. */
  695.     tok = strtok_r (NULL, ":", &pHolder);
  696.     if (tok == NULL)
  697. return ERROR;
  698.     pDrvCtrl->ilevel = atoi (tok);
  700.     /* Remote DMA I/O address. */
  702.     tok = strtok_r (NULL, ":", &pHolder);
  703.     if (tok == NULL)
  704. return ERROR;
  705.     pDrvCtrl->ioPort = (char *) strtoul (tok, NULL, 16);
  707.     /* Get ring buffer size in pages */
  709.     tok = strtok_r (NULL, ":", &pHolder);
  710.     if (tok == NULL)
  711. return ERROR;
  712.     pDrvCtrl->rxStopPage = strtoul (tok, NULL, 16) / NS83902_PAGE_SIZE;
  714.     /* Get target options */
  716.     tok = strtok_r (NULL, ":", &pHolder);
  717.     if (tok == NULL)
  718. return ERROR;
  719.     options = strtoul (tok, NULL, 16);
  720.     pDrvCtrl->wide = options & NS83902_WIDE_MASK;
  721.     pDrvCtrl->regInterval = 1 << ((options & NS83902_INTERVAL_MASK) >> 1);
  723.     DRV_LOG (NS83902_DEBUG_LOAD, "Processed all arugmentsn", 1, 2, 3, 4, 5, 6);
  725.     DRV_LOG (NS83902_DEBUG_LOAD, "Address %p Lvl %u Vec %d Port %p Ring %p n",
  726.                (int)pDrvCtrl->pNic, pDrvCtrl->ilevel, pDrvCtrl->ivec, 
  727.        (int)pDrvCtrl->ioPort, pDrvCtrl->rxStopPage, 6);    
  729.     DRV_LOG (NS83902_DEBUG_LOAD, "Transfer width: %s n", 
  730.                (int)(pDrvCtrl->wide ? "word":"byte"), 2, 3, 4, 5, 6);
  732.     DRV_LOG (NS83902_DEBUG_LOAD, "Register interval: %d n", 
  733.        pDrvCtrl->regInterval, 2, 3, 4, 5, 6);
  735.     return OK;
  736.     }
  738. /*******************************************************************************
  739. *
  740. * ns83902InitMem - initialize memory for NIC chip
  741. *
  742. * Using data in the control structure, setup and initialize the memory
  743. * areas needed.  If the memory address is not already specified, then allocate
  744. * cache safe memory.
  745. *
  746. * RETURNS: OK or ERROR.
  747. */
  749. LOCAL STATUS ns83902InitMem
  750.     (
  751.     NS83902_END_DEVICE * pDrvCtrl /* device to be initialized */
  752.     )
  753.     {
  754.     /* allocate netpool */
  756.     if ((pDrvCtrl->endObj.pNetPool = malloc (sizeof(NET_POOL))) == NULL)
  757.         return (ERROR);
  759.     /* Set number of M-Blks and CL-Blks*/
  761.     ns83902MclBlkConfig.mBlkNum = pDrvCtrl->rringSize;
  762.     ns83902MclBlkConfig.clBlkNum= pDrvCtrl->rringSize / 2;
  763.     ns83902ClDescTbl[0].clNum = ns83902MclBlkConfig.clBlkNum;
  765.     /* Calculate the total memory for all the M-Blks and CL-Blks. */
  767.     ns83902MclBlkConfig.memSize = ns83902MclBlkConfig.mBlkNum * 
  768.    (MSIZE + sizeof (long)) +
  769.   ns83902MclBlkConfig.clBlkNum * 
  770.    (CL_BLK_SZ + sizeof(long));
  772.     /* allocate memory for M-Blks and CL-Blks */
  774.     ns83902MclBlkConfig.memArea = (char *) memalign (sizeof(long),
  775.    ns83902MclBlkConfig.memSize);
  777.     if (ns83902MclBlkConfig.memArea == NULL)
  778. return (ERROR);
  779.     
  780.     /* Calculate the memory size of all the clusters. */
  782.     ns83902ClDescTbl[0].clSize  = NS83902_RX_BUF_SZ;
  783.     ns83902ClDescTbl[0].memSize = sizeof(long) + ns83902ClDescTbl[0].clNum * 
  784.   (ns83902ClDescTbl[0].clSize + 8);
  786.     /* Allocate memory for clusters */
  788.     ns83902ClDescTbl[0].memArea = (char *) memalign (sizeof(long),
  789.    ns83902ClDescTbl[0].memSize);
  790.    
  791.     if (ns83902ClDescTbl[0].memArea == NULL)
  792. {
  793. DRV_LOG (NS83902_DEBUG_LOAD, "system memory unavailablen", 
  794.  1, 2, 3, 4, 5, 6);
  795. return (ERROR);
  796. }
  798.     /* Save clusters start address for later use */
  800.     pDrvCtrl->pCluster = (NS83902_CLUSTER) ns83902ClDescTbl[0].memArea;
  802.     /* Initialize the net buffer pool with buffers */
  804.     if (netPoolInit (pDrvCtrl->endObj.pNetPool, &ns83902MclBlkConfig, 
  805.      &ns83902ClDescTbl[0], ns83902ClDescTblNumEnt, NULL) == ERROR)
  806. {
  807. DRV_LOG (NS83902_DEBUG_LOAD, "Could not init bufferingn",
  808.  1, 2, 3, 4, 5, 6);
  809. return (ERROR);
  810. }
  811.     
  812.     /* Store the cluster pool id as others need it later. */
  814.     pDrvCtrl->pClPoolId = netClPoolIdGet (pDrvCtrl->endObj.pNetPool, 
  815.   NS83902_RX_BUF_SZ, FALSE);
  816.     if (pDrvCtrl->pClPoolId  == NULL)
  817. return (ERROR);
  819. #ifdef NS83902_DEBUG
  820.     ns83902NetPool = *pDrvCtrl->endObj.pNetPool;
  821.     ns83902ClPoolId = pDrvCtrl->pClPoolId;
  822. #endif
  824.     return (OK);
  825.     }
  827. /*******************************************************************************
  828. *
  829. * ns83902Start - start the device
  830. *
  831. * This function calls BSP functions to connect interrupts and start the
  832. * device running in interrupt mode.
  833. *
  834. * RETURNS: OK or ERROR
  835. *
  836. */
  838. LOCAL STATUS ns83902Start
  839.     (
  840.     NS83902_END_DEVICE *pDrvCtrl
  841.     )
  842.     {
  843.     STATUS result;
  845.     /* Clear statuses */
  847.     pDrvCtrl->rxHandling = FALSE;
  848.     pDrvCtrl->txBlocked = FALSE;
  849.     pDrvCtrl->rxOvw = FALSE;
  850.     pDrvCtrl->txResend = FALSE;
  851.     
  852.     /* reset the device */
  854.     NS83902_REG_SET (pDrvCtrl, NS83902_CR, CR_STP | CR_ABORT, CR_RPAGE0);
  856.     /* connect interrupt handler */
  858.     SYS_INT_CONNECT (pDrvCtrl, ns83902Int, (int)pDrvCtrl, &result);
  860.     if (result == ERROR)
  861. return ERROR;
  863.     DRV_LOG (NS83902_DEBUG_LOAD, "Interrupt connected.n", 1, 2, 3, 4, 5, 6);
  865.     /* device config */
  867.     ns83902Config (pDrvCtrl);
  869.     /* mark the interface -- up */
  871.     END_FLAGS_SET (&pDrvCtrl->endObj, (IFF_UP | IFF_RUNNING));
  872.     
  873.     SYS_INT_ENABLE (pDrvCtrl);
  875.     DRV_LOG (NS83902_DEBUG_LOAD, "interrupt enabled.n", 1, 2, 3, 4, 5, 6);
  877.     return (OK);
  878.     }
  880. /*******************************************************************************
  881. *
  882. * ns83902Config - configure the NIC chip and program address
  883. *
  884. * This routine follows the algorythm in the ST-NIC manual for enabling
  885. * a NIC device on an active network.  Essentially, this routine initializes
  886. * the NIC device.
  887. *
  888. * RETURNS: N/A.
  889. */
  891. LOCAL void ns83902Config
  892.     (
  893.     NS83902_END_DEVICE * pDrvCtrl /* device to be configured */    
  894.     )
  895.     {
  896.     UCHAR* pEnetAddr = pDrvCtrl->enetAddr;
  897.     UCHAR dcr;
  899.     /* Page 0 */
  901.     NS83902_REG_SET (pDrvCtrl, NS83902_CR, CR_STP | CR_ABORT, CR_RPAGE0);
  903.     /* Enable broadcast, Endian, Word Size */
  905. #if (_BYTE_ORDER == _BIG_ENDIAN)
  906.     dcr = DCR_NOTLS | DCR_FIFO8 | DCR_BOS;
  907. #else
  908.     dcr = DCR_NOTLS | DCR_FIFO8;
  909. #endif
  911.     if (pDrvCtrl->wide == TRUE)  
  912. dcr |= DCR_WTS;
  913.     NS83902_REG_SET (pDrvCtrl, NS83902_DCR, dcr, CR_RPAGE0);
  915.     /* Clear the remote byte count reg. */
  917.     NS83902_REG_SET (pDrvCtrl, NS83902_RBCR0, 0, CR_RPAGE0);
  918.     NS83902_REG_SET (pDrvCtrl, NS83902_RBCR1, 0, CR_RPAGE0);
  920.     /* Set to monitor and loopback mode */
  922.     NS83902_REG_SET (pDrvCtrl, NS83902_RCR, RCR_MON, CR_RPAGE0);
  923.     NS83902_REG_SET (pDrvCtrl, NS83902_TCR, TCR_MODE1, CR_RPAGE0);
  925.     /* Accept Broadcast */
  927.     NS83902_REG_SET (pDrvCtrl, NS83902_RCR, (RCR_AB | RCR_AM), CR_RPAGE0);
  929.     /* Set the transmit page and receive page */
  931.     NS83902_REG_SET (pDrvCtrl, NS83902_PSTART, pDrvCtrl->rxStartPage, CR_RPAGE0);
  932.     NS83902_REG_SET (pDrvCtrl, NS83902_PSTOP, pDrvCtrl->rxStopPage, CR_RPAGE0);
  933.     NS83902_REG_SET (pDrvCtrl, NS83902_TPSR, pDrvCtrl->txStartPage, CR_RPAGE0);
  934.     NS83902_REG_SET (pDrvCtrl, NS83902_BNRY, pDrvCtrl->rxStopPage - 1, CR_RPAGE0);
  936.     /* Clear the pending interrupts and mask. */
  938.     NS83902_REG_SET (pDrvCtrl, NS83902_ISR, 0xff, CR_RPAGE0);
  939.     NS83902_REG_SET (pDrvCtrl, NS83902_IMR, IMR_DISABLE, CR_RPAGE0);
  941.     /* set MAC Address */
  943.     NS83902_REG_SET (pDrvCtrl, NS83902_PAR0, pEnetAddr [0], CR_RPAGE1);
  944.     NS83902_REG_SET (pDrvCtrl, NS83902_PAR1, pEnetAddr [1], CR_RPAGE1);
  945.     NS83902_REG_SET (pDrvCtrl, NS83902_PAR2, pEnetAddr [2], CR_RPAGE1);
  946.     NS83902_REG_SET (pDrvCtrl, NS83902_PAR3, pEnetAddr [3], CR_RPAGE1);
  947.     NS83902_REG_SET (pDrvCtrl, NS83902_PAR4, pEnetAddr [4], CR_RPAGE1);
  948.     NS83902_REG_SET (pDrvCtrl, NS83902_PAR5, pEnetAddr [5], CR_RPAGE1);
  950.     /* Initialize the multicast list to accept all. */
  952.     NS83902_REG_SET (pDrvCtrl, NS83902_MAR0, 0x00, CR_RPAGE1);
  953.     NS83902_REG_SET (pDrvCtrl, NS83902_MAR1, 0x00, CR_RPAGE1);
  954.     NS83902_REG_SET (pDrvCtrl, NS83902_MAR2, 0x00, CR_RPAGE1);
  955.     NS83902_REG_SET (pDrvCtrl, NS83902_MAR3, 0x00, CR_RPAGE1);
  956.     NS83902_REG_SET (pDrvCtrl, NS83902_MAR4, 0x00, CR_RPAGE1);
  957.     NS83902_REG_SET (pDrvCtrl, NS83902_MAR5, 0x00, CR_RPAGE1);
  958.     NS83902_REG_SET (pDrvCtrl, NS83902_MAR6, 0x00, CR_RPAGE1);
  959.     NS83902_REG_SET (pDrvCtrl, NS83902_MAR7, 0x00, CR_RPAGE1);
  961.     NS83902_REG_SET (pDrvCtrl, NS83902_CURR, pDrvCtrl->rxStartPage, CR_RPAGE1);
  963.     /* Page 0 */
  965.     NS83902_REG_SET (pDrvCtrl, NS83902_CR, CR_STP | CR_ABORT, CR_RPAGE0);
  967.     /* set the interrupt mask */
  969.     NS83902_REG_SET (pDrvCtrl, NS83902_IMR, IMR_ENABLE, CR_RPAGE0);
  971.     /* Start */
  973.     NS83902_REG_SET (pDrvCtrl, NS83902_CR, CR_ABORT | CR_STA, CR_RPAGE0);
  974.     NS83902_REG_SET (pDrvCtrl, NS83902_TCR, TCR_MODE0, CR_RPAGE0);
  975.     }
  977. /*******************************************************************************
  978. *
  979. * ns83902EnetAddrGet - get the Ethernet address.
  980. *
  981. * Get ethernet address from the BSP.
  982. *
  983. * RETURNS: N/A.
  984. */
  986. LOCAL void ns83902EnetAddrGet
  987.     (
  988.     NS83902_END_DEVICE* pDrvCtrl, 
  989.     char* addr
  990.     )
  991.     {
  993. #if _BYTE_ORDER == _BIG_ENDIAN
  994.     /* For big endian we need to swap byte order */
  996.     int i;
  997.     char  bytes[6];
  999.     SYS_ENET_ADDR_GET (pDrvCtrl, bytes);
  1001.     for (i=0; i<6; i++)
  1002. *addr++ = bytes[5-i];
  1004. #else  /* _BYTE_ORDER == _LITTLE_ENDIAN  */
  1006.     /* Little endian is in correct order */
  1008.     SYS_ENET_ADDR_GET (pDrvCtrl, addr);
  1010. #endif /* _BYTE_ORDER == _BIG_ENDIAN */
  1011.     }
  1013. /*******************************************************************************
  1014. *
  1015. * ns83902WritePort - write to the DMA port
  1016. *
  1017. * RETURNS: N/A.
  1018. */
  1020. LOCAL void ns83902WritePort
  1021.     (
  1022.     NS83902_END_DEVICE* pDrvCtrl,    
  1023.     char * pBuf,
  1024.     int len
  1025.     )
  1026.     {
  1027.     int ix;
  1028.     UINT16 *  pWide;
  1030.     if (pDrvCtrl->wide == TRUE)
  1031. {
  1032. len = (++len) >> 1;
  1033. pWide = (UINT16 *) pBuf;
  1034. for (ix = 0 ; ix < len; ix++)
  1035.     {
  1036.     SYS_OUT_SHORT (pDrvCtrl, pDrvCtrl->ioPort, *pWide++);
  1037.     SYS_NS83902_DELAY();
  1038.     }
  1039. }
  1040.     else
  1041. {
  1042. for (ix = 0 ; ix < len; ix++)
  1043.     {
  1044.     SYS_OUT_BYTE (pDrvCtrl, pDrvCtrl->ioPort, *pBuf++);
  1045.     SYS_NS83902_DELAY();
  1046.     }
  1047. }
  1048.     }    
  1050. /*******************************************************************************
  1051. *
  1052. * ns83902ReadPort - read the DMA port
  1053. *
  1054. * RETURNS: N/A.
  1055. */
  1057. LOCAL void ns83902ReadPort
  1058.     (
  1059.     NS83902_END_DEVICE* pDrvCtrl,    
  1060.     char * pBuf,
  1061.     int len
  1062.     )
  1063.     {
  1064.     int  ix;
  1065.     UINT16 *  pWide;
  1067.     if (pDrvCtrl->wide == TRUE)
  1068. {
  1069. len = (++len) >> 1;
  1070. pWide = (UINT16 *) pBuf;
  1071. for (ix = 0 ; ix < len; ix++)
  1072.     {
  1073.     SYS_IN_SHORT (pDrvCtrl, pDrvCtrl->ioPort, *pWide++);
  1074.     }
  1075. }
  1076.     else
  1077. {
  1078. for (ix = 0 ; ix < len; ix++)
  1079.     {
  1080.     SYS_IN_BYTE (pDrvCtrl, pDrvCtrl->ioPort, *pBuf++);
  1081.     }
  1082. }
  1083.     }    
  1085. /*******************************************************************************
  1086. *
  1087. * ns83902PktBufRead - read data from the NIC receive ring buffer
  1088. *
  1089. * This routine gets exclusive access to the remote DMA, and gets data from 
  1090. * the NIC's receive ring buffer.
  1091. *
  1092. * RETURNS: OK, or ERROR if obtaining the requested bytes encountered an error.
  1093. */
  1095. LOCAL STATUS ns83902PktBufRead
  1096.     (
  1097.     NS83902_END_DEVICE* pDrvCtrl,
  1098.     UINT32 ns83902BufAddr,
  1099.     UINT32 len,
  1100.     char* pData
  1101.     )
  1102.     {
  1103.     /* Exclusive DMA access */
  1105.     if (!NS83902_IS_IN_POLL_MODE())
  1106. NS83902_SEM_TAKE (pDrvCtrl, WAIT_FOREVER);
  1108.     DRV_LOG (NS83902_DEBUG_RX, 
  1109.      "ns83902Receive: ns83902BufAddr:%u pData:%p len:%dn",
  1110.              ns83902BufAddr, (int)pData, len, 4, 5, 6);        
  1111.     
  1112.     /* Set up remote read DMA transfer */
  1114.     NS83902_REG_SET (pDrvCtrl, NS83902_RBCR0, LSB(len), CR_RPAGE0);
  1115.     NS83902_REG_SET (pDrvCtrl, NS83902_RBCR1, MSB(len), CR_RPAGE0);
  1116.     NS83902_REG_SET (pDrvCtrl, NS83902_RSAR0, LSB(ns83902BufAddr), CR_RPAGE0);
  1117.     NS83902_REG_SET (pDrvCtrl, NS83902_RSAR1, MSB(ns83902BufAddr), CR_RPAGE0);
  1119.     NS83902_REG_SET (pDrvCtrl, NS83902_CR, CR_RREAD, CR_RPAGE0);
  1121.     /* Get data through DMA port */
  1123.     ns83902ReadPort (pDrvCtrl, pData, len);
  1125.     if (!NS83902_IS_IN_POLL_MODE())
  1126. NS83902_SEM_GIVE (pDrvCtrl);
  1128.     return (OK);
  1129.     }
  1131. /*******************************************************************************
  1132. *
  1133. * ns83902ReadFrame - read a packet off the interface ring buffer into a cluster
  1134. *
  1135. * Allocates a new cluster from the cluster pool, and reads the frame from the
  1136. * device into the cluster.
  1137. *
  1138. * RETURNS: a cluster or NULL if any error
  1139. */
  1140. LOCAL NS83902_CLUSTER ns83902ReadFrame
  1141.     (
  1142.     NS83902_END_DEVICE* pDrvCtrl
  1143.     )
  1144.     {
  1145.     NS83902_RX_FRAME* pRx;
  1146.     NS83902_CLUSTER pRetCluster = NULL;
  1147.     UINT32 frameAddress;
  1148.     UINT16 len; /* len of Rx pkt */
  1149.     UINT8 bnry;
  1150.     UINT8 rsr;
  1151.     UINT8 cur;
  1153.     /* Check receive status */
  1155.     NS83902_REG_GET (pDrvCtrl, NS83902_RSR, rsr, CR_RPAGE0);
  1157.     if ((rsr & RSR_PRX) != RSR_PRX)
  1158.         return (pRetCluster);
  1160.     NS83902_REG_GET (pDrvCtrl, NS83902_CURR, cur, CR_RPAGE1);
  1162.     if (!(END_FLAGS_GET(&pDrvCtrl->endObj) & (IFF_UP | IFF_RUNNING)) ||
  1163.         (pDrvCtrl->nextPage == cur))
  1164.         return (pRetCluster);
  1166.     DRV_LOG (NS83902_DEBUG_RX, "Start Read!n", 1, 2, 3, 4, 5, 6);
  1168.     /*
  1169.      * There is work to be done.
  1170.      * First we copy the NIC receive status header from the NIC buffer
  1171.      * into our local area. This is done so that we can obtain the length
  1172.      * of the packet before copying out the rest of it. Note that the length
  1173.      * field in the NIC header includes the Ethernet header, the data, and
  1174.      * the 4 byte FCS field.
  1175.      */
  1177.     /* Get a cluster */
  1179.     if ((pRx = (NS83902_RX_FRAME*) netClusterGet (pDrvCtrl->endObj.pNetPool,
  1180.                                            pDrvCtrl->pClPoolId)) == NULL)
  1181.         {
  1182. pDrvCtrl->lastError.errCode = END_ERR_NO_BUF;
  1183. muxError (&pDrvCtrl->endObj, &pDrvCtrl->lastError);
  1184.         DRV_LOG (NS83902_DEBUG_RX, "Cannot loan!n", 1, 2, 3, 4, 5, 6);
  1185.         END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1186.         return (pRetCluster);
  1187.         }
  1188.     
  1189.     /* read header */
  1191.     DRV_LOG (NS83902_DEBUG_RX, "ns83902PktBufRead : Reading Headern", 
  1192.      1, 2, 3, 4, 5, 6);
  1194.     if (ns83902PktBufRead (pDrvCtrl, pDrvCtrl->nextPage << 8,
  1195.                           (NS83902_RX_HDR_SZ), (char *) &pRx->rxHdr) == ERROR)
  1196.         {
  1197.         DRV_LOG (NS83902_DEBUG_RX,
  1198.                  "ns83902PktBufRead could not read packet headern",
  1199.                  0, 0, 0, 0, 0, 0);
  1200. netClFree (pDrvCtrl->endObj.pNetPool, (UCHAR *)pRx);
  1202.         return (pRetCluster);
  1203.         }
  1205.     /* Calculate real length */
  1207.     len = pRx->rxHdr.count;
  1208. #if (_BYTE_ORDER == _BIG_ENDIAN)
  1209.     len = ((len >> 8) & 0x00ff) + ((len << 8) & 0xff00) - NS83902_ETH_CRC_LEN;
  1210. #else
  1211.     len = len - NS83902_ETH_CRC_LEN;
  1212. #endif
  1214.     /* write back value to rxHdr */
  1216.     pRx->rxHdr.count = len;
  1218.     /* Current frame address and next page */
  1220.     frameAddress = (pDrvCtrl->nextPage << 8) + NS83902_RX_HDR_SZ;
  1221.     pDrvCtrl->nextPage = pRx->rxHdr.nextRxPage;
  1222.    
  1223.     /* valid frame checks */
  1225. #ifdef NS83902_INSTRUMENT
  1226.     ns83902Len = len;
  1227.     ns83902HdrStat = pRx->rxHdr.status;
  1228.     ns83902NextPage = pRx->rxHdr.nextRxPage;
  1229.     ns83902CurrentPage = cur;
  1230. #endif
  1232.     /* check for critical error; should never happen */
  1234.     if (pDrvCtrl->nextPage < pDrvCtrl->rxStartPage || 
  1235. pDrvCtrl->nextPage >= pDrvCtrl->rxStopPage )
  1236. {
  1237. /* Can't recover, restart */
  1239. #ifdef NS83902_INSTRUMENT
  1240.      ns83902InitNb++;
  1241. #endif
  1243. ns83902Config (pDrvCtrl);
  1245. pDrvCtrl->nextPage = pDrvCtrl->rxStartPage;
  1247. /* mark the interface up */
  1249. END_FLAGS_SET (&pDrvCtrl->endObj,
  1250. (IFF_UP | IFF_RUNNING | IFF_MULTICAST | IFF_BROADCAST));
  1252. netClFree (pDrvCtrl->endObj.pNetPool, (UCHAR *)pRx);
  1253. return (pRetCluster);
  1254. }
  1256.     /*
  1257.      * If the packet's receive status byte indicates an error the packet is 
  1258.      * discarded and the receive page pointers are updated to point to the 
  1259.      * next packet.
  1260.      */
  1262.     if ((len < 60) || (len > 1514) || 
  1263. ((pRx->rxHdr.status & ~RSR_PHY) != RSR_PRX))
  1264. {
  1265.         DRV_LOG (NS83902_DEBUG_RX,
  1266.                  "ns83902Rcv receive error: statusHeader=0x%x nextRxPage=%d 
  1267.                            currentPage=%d len=%d IntNb=%dn",
  1268.                  pRx->rxHdr.status, pRx->rxHdr.nextRxPage, cur, len,
  1269.  ns83902IntNb, 0);
  1270.         
  1271.         END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1273. /* update boundary pointer */
  1275. if (pDrvCtrl->nextPage == pDrvCtrl->rxStartPage)
  1276.     bnry = pDrvCtrl->rxStopPage;
  1277. else
  1278.     bnry = pDrvCtrl->nextPage - 1;
  1280. NS83902_REG_SET (pDrvCtrl, NS83902_BNRY, bnry, CR_RPAGE0);
  1282. netClFree (pDrvCtrl->endObj.pNetPool, (UCHAR *)pRx);
  1284. return (pRetCluster);
  1285. }
  1287.     /* copy Ethernet packet section of the frame */
  1288.     
  1289.     DRV_LOG (NS83902_DEBUG_RX, "ns83902PktBufRead : Reading Framen",
  1290.      1, 2, 3, 4, 5, 6);
  1291.     
  1292.     if (ns83902PktBufRead (pDrvCtrl, frameAddress, len,
  1293.    (char *) &pRx->enetHdr) == ERROR)
  1294. {
  1295. DRV_LOG (NS83902_DEBUG_RX, "ns83902Recv: Could not read packet datan",
  1296.  1, 2, 3, 4, 5, 6);
  1298. END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1300. netClFree (pDrvCtrl->endObj.pNetPool, (UCHAR *)pRx);
  1301. }
  1302.     else
  1303. {
  1304. /* Successfully got a frame */
  1306. pRetCluster = (NS83902_CLUSTER) pRx;
  1308. END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_UCAST, +1);
  1309. }
  1311.     /* update boundary pointer */
  1313.     if (pDrvCtrl->nextPage == pDrvCtrl->rxStartPage)
  1314. bnry = pDrvCtrl->rxStopPage;
  1315.     else
  1316. bnry = pDrvCtrl->nextPage - 1;
  1318.     NS83902_REG_SET (pDrvCtrl, NS83902_BNRY, bnry, CR_RPAGE0);
  1320.     DRV_LOG (NS83902_DEBUG_RX, "End Read!n", 1, 2, 3, 4, 5, 6);
  1322.     return (pRetCluster);
  1323.     }
  1325. /*******************************************************************************
  1326. *
  1327. * ns83902Recv - read a packet off the interface ring buffer
  1328. *
  1329. * ns83902Recv copies packets from local memory into an mbuf and hands it to
  1330. * the next higher layer (IP or etherInputHook).
  1331. *
  1332. * RETURNS: TRUE, or FALSE if the packet reception encountered errors.
  1333. */
  1335. LOCAL void ns83902Recv
  1336.     (
  1337.     NS83902_END_DEVICE* pDrvCtrl,
  1338.     NS83902_CLUSTER pCluster
  1339.     )
  1340.     {
  1341.     NS83902_RX_FRAME* pRx = (NS83902_RX_FRAME*) pCluster;    
  1342.     CL_BLK_ID pClBlk;
  1343.     M_BLK_ID pMblk;
  1344.     UINT32 len = pRx->rxHdr.count;
  1347.     /* Process frame received */
  1349.     if ((pClBlk = netClBlkGet (pDrvCtrl->endObj.pNetPool, M_DONTWAIT)) == NULL)
  1350.         {
  1351. pDrvCtrl->lastError.errCode = END_ERR_NO_BUF;
  1352. muxError (&pDrvCtrl->endObj, &pDrvCtrl->lastError);
  1353.         DRV_LOG (NS83902_DEBUG_RX, "Out of Cluster Blocks!n", 1, 2, 3, 4, 5, 6);
  1354.         netClFree (pDrvCtrl->endObj.pNetPool, (UCHAR *)pCluster);        
  1355.         END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1356.         goto cleanRXD;
  1357.         }
  1359.     /*
  1360.      * OK we've got a spare, let's get an M_BLK_ID and marry it to the
  1361.      * one in the ring.
  1362.      */
  1364.     if ((pMblk = mBlkGet (pDrvCtrl->endObj.pNetPool, M_DONTWAIT, MT_DATA)) ==
  1365.         NULL)
  1366.         {
  1367.         netClBlkFree (pDrvCtrl->endObj.pNetPool, pClBlk);
  1368.         netClFree (pDrvCtrl->endObj.pNetPool, (UCHAR *)pCluster);
  1369.         DRV_LOG (NS83902_DEBUG_MB, "Out of M Blocks!n", 1, 2, 3, 4, 5, 6);
  1370.         END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1371.         goto cleanRXD;
  1372.         }
  1374.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_UCAST, +1);
  1376.     /* Join the cluster to the MBlock */
  1378.     netClBlkJoin (pClBlk, (char*)pCluster, len, NULL, 0, 0, 0);
  1379.     netMblkClJoin (pMblk, pClBlk);
  1381.     pMblk->mBlkHdr.mData  = (char *)&pRx->enetHdr;
  1382.     pMblk->mBlkHdr.mFlags  |= M_PKTHDR; /* set the packet header */
  1383.     pMblk->mBlkHdr.mLen = len; /* set the data len */
  1384.     pMblk->mBlkPktHdr.len  = len; /* set the total len */
  1386.     /* Call the upper layer's receive routine. */
  1388.     END_RCV_RTN_CALL (&pDrvCtrl->endObj, pMblk);
  1390. cleanRXD:
  1392.     return;
  1393.     }
  1395. /*******************************************************************************
  1396. *
  1397. * ns83902Restart - restart chip after receive ring buffer overflow
  1398. *
  1399. * This routine is called from an isr handler that deals with a receive DMA
  1400. * overflow condition.  It gets access to the remote DMA, cleans up NIC
  1401. * registers and defers work to task context to empty the receive ring buffers.
  1402. *
  1403. * RETURNS: N/A.
  1404. */
  1406. LOCAL void ns83902Restart
  1407.     (
  1408.     NS83902_END_DEVICE* pDrvCtrl,
  1409.     UINT8 cr
  1410.     )
  1411.     {
  1412.     UINT8 isr;
  1414. #ifdef NS83902_INSTRUMENT
  1415.     ns83902RestartNb++;
  1416. #endif
  1418.     /* Buffer ring overflow algorithm */
  1420.     NS83902_REG_SET (pDrvCtrl, NS83902_CR, CR_STP | CR_ABORT, CR_RPAGE0);
  1422.     /* wait at least 1.6 mSec */
  1424.     SYS_MS_DELAY (2);
  1426.     /* Remove packets from buffer */
  1428.     NS83902_REG_SET (pDrvCtrl, NS83902_RBCR0, 0, CR_RPAGE0);
  1429.     NS83902_REG_SET (pDrvCtrl, NS83902_RBCR1, 0, CR_RPAGE0);
  1431.     NS83902_REG_GET (pDrvCtrl, NS83902_ISR, isr, CR_RPAGE0);
  1432.     if ((cr & CR_TXP) && (!(isr & (ISR_TXE | ISR_PTX))))
  1433.      pDrvCtrl->txResend = TRUE;
  1435.     NS83902_REG_SET (pDrvCtrl, NS83902_TCR, TCR_MODE1, CR_RPAGE0);
  1436.     NS83902_REG_SET (pDrvCtrl, NS83902_CR, CR_ABORT | CR_STA, CR_RPAGE0);
  1438.     END_FLAGS_SET (&pDrvCtrl->endObj, IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);
  1440.     pDrvCtrl->rxOvw = TRUE;
  1442.     if (pDrvCtrl->rxHandling == FALSE)
  1443. {
  1444. pDrvCtrl->rxHandling = TRUE;
  1445. netJobAdd ((FUNCPTR) ns83902HandleInt, (int) pDrvCtrl, 0, 0, 0, 0);
  1446. }
  1448.     }
  1450. /*******************************************************************************
  1451. *
  1452. * ns83902HandleInt - deferred receive interrupt handler
  1453. *
  1454. * This function handles the received frames from the device.  It runs in the
  1455. * context of the netTask, which was triggered by a received packet interrupt.
  1456. * It resends any packet that was in the midst of transmission when the overflow
  1457. * hit.
  1458. * Actual processing of the packet is done by calling ns83902Recv().
  1459. *
  1460. * RETURNS: N/A.
  1461. */
  1463. LOCAL void ns83902HandleInt
  1464.     (
  1465.     NS83902_END_DEVICE* pDrvCtrl    
  1466.     )
  1467.     {
  1468.     NS83902_CLUSTER pCluster;
  1470.     /* empties the receive ring buffer of its packets */
  1472.     pDrvCtrl->rxHandling = TRUE;
  1474.     while ((pCluster =  ns83902ReadFrame (pDrvCtrl)) != NULL)
  1475. ns83902Recv (pDrvCtrl, pCluster);
  1477.     pDrvCtrl->rxHandling = FALSE;
  1479.     if (pDrvCtrl->rxOvw == TRUE)
  1480. {
  1481. /* Reset overflow bit */
  1482. NS83902_REG_SET (pDrvCtrl, NS83902_ISR, ISR_OVW, CR_RPAGE0);
  1483. NS83902_REG_SET (pDrvCtrl, NS83902_TCR, TCR_MODE0, CR_RPAGE0);
  1485. /* If resend needed, issue transmit command */
  1486. if (pDrvCtrl->txResend == TRUE)
  1487.     {
  1488.     NS83902_REG_SET (pDrvCtrl, NS83902_CR, CR_STA | CR_TXP | CR_ABORT,
  1489.      CR_RPAGE0);
  1490.     pDrvCtrl->txResend = FALSE;
  1491.     }
  1493. pDrvCtrl->rxOvw = FALSE;
  1494. }
  1496.     /* Re-enable interrupts */
  1498.     NS83902_REG_SET (pDrvCtrl, NS83902_IMR, IMR_ENABLE, CR_RPAGE0);
  1499.     }
  1501. /*******************************************************************************
  1502. *
  1503. * ns83902Int - The driver's interrupt handler
  1504. *
  1505. * This function clears the cause of the device interrupt(s) and then acts
  1506. * on the individual possible causes.  The primary goal of this routine is to
  1507. * minimize the time spent in it.  This is accomplished by deferring processing
  1508. * to the netTask via the netJobAdd() function.
  1509. *
  1510. * Note that in case the receiver overruns, we promptly mark the interface as
  1511. * "down" and leave error handling to task-level.   This is in case netTask
  1512. * is in the midst of DMA activity, we must allow it to complete.  The receive
  1513. * handler will give up when it discovers the interface is down, which will
  1514. * then allow netTask to run our OVW handler.  This provides orderly error 
  1515. * recovery.
  1516. *
  1517. * RETURNS: N/A.
  1518. */
  1520. LOCAL void ns83902Int
  1521.     (
  1522.     NS83902_END_DEVICE* pDrvCtrl
  1523.     )
  1524.     {
  1525.     UINT8 isr; /* copy of NS83902_ISR */
  1526.     UINT8 cr; /* copy of NS83902_CR */
  1528.     /* Check if interface is up and running */
  1530.     if ((END_FLAGS_GET(&pDrvCtrl->endObj) & (IFF_UP | IFF_RUNNING)) !=
  1531.         (IFF_UP | IFF_RUNNING))
  1532. return;
  1534. #ifdef NS83902_INSTRUMENT
  1535.     ns83902IntNb++;
  1536. #endif
  1538.     DRV_LOG (NS83902_DEBUG_INT, "Inside INTn", 1, 2, 3, 4, 5, 6);
  1540.     /* Read and clear ISR */
  1541.     
  1542.     NS83902_REG_GET (pDrvCtrl, NS83902_ISR, isr, CR_RPAGE0);
  1543.     NS83902_REG_SET (pDrvCtrl, NS83902_ISR, isr, CR_RPAGE0);
  1545.     /* handle transmit interrupts */
  1547.     if (isr & (ISR_PTX | ISR_TXE))
  1548. {
  1549. UINT8 tsr;
  1551. NS83902_REG_GET (pDrvCtrl, NS83902_TSR, tsr, CR_RPAGE0);
  1553. DRV_LOG (NS83902_DEBUG_TX, "ns83902Tx Interrupt TSR=%d n", tsr,
  1554.  2, 3, 4, 5, 6);
  1556. if ((tsr & TSR_PTX) == 0)
  1557.     {
  1558.     /* PTX zero, something went wrong */
  1560.     if (tsr & TSR_ABT)
  1561. {
  1562. #ifdef NS83902_INSTRUMENT
  1563. ns83902TxTimeout++;
  1564. #endif
  1565. DRV_LOG (NS83902_DEBUG_TX, "ns83902Transmit Aborted n",
  1566.  1, 2, 3, 4, 5, 6);
  1567. }
  1568.     if (tsr & TSR_FU)
  1569. {
  1570. DRV_LOG (NS83902_DEBUG_TX, "ns83902Transmit FIFO Underrun n",
  1571.      1, 2, 3, 4, 5, 6);
  1572. }
  1574.     /* Notify upper layers about the error */
  1576.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_ERRS, +1);
  1577.     pDrvCtrl->lastError.errCode = END_ERR_WARN;
  1578.     pDrvCtrl->lastError.pMesg = "Transmit error";
  1579.     netJobAdd ((FUNCPTR) muxError, (int) &pDrvCtrl->endObj,
  1580.        (int) &pDrvCtrl->lastError, 0, 0, 0);
  1582.     DRV_LOG (NS83902_DEBUG_TX, "ns83902Transmit Errorn", 0, 0, 0, 0, 0, 0);
  1583.     
  1584. #ifdef NS83902_INSTRUMENT
  1585.     ns83902TxError++;
  1586. #endif
  1587.     }
  1589. if (tsr & TSR_CRS)
  1590.     {
  1591.     DRV_LOG (NS83902_DEBUG_TX, "%s%d - no carriern", (int)NS83902_DEV_NAME,
  1592.      pDrvCtrl->unit, 3, 4, 5, 6);
  1593.     }
  1595. #if 0   /* no collision statistics for END drivers? */
  1596. if (tsr & TSR_COL)
  1597.     {
  1598.     UINT8 ncr;
  1599.     NS83902_REG_GET (pDrvCtrl, NS83902_NCR, ncr, CR_RPAGE0);
  1600.     END_ERR_ADD (pEndObj, MIB2_COLLISIONS, ncr);
  1601.     }
  1602. #endif
  1604. if (pDrvCtrl->txBlocked == TRUE)
  1605.     {
  1606.     pDrvCtrl->txBlocked = FALSE;
  1607.     netJobAdd ((FUNCPTR)muxTxRestart, (int)&pDrvCtrl->endObj, 0, 0, 0, 0);
  1608.     }
  1609. }
  1611.     /* handle receiver overrun */
  1613.     if (isr & ISR_OVW)
  1614. {
  1615. /* disable interrupts */
  1617. NS83902_REG_SET (pDrvCtrl, NS83902_IMR, IMR_DISABLE, CR_RPAGE0);
  1619. NS83902_CR_GET (pDrvCtrl, cr);
  1621.         /* mark the interface down */
  1623.         END_FLAGS_CLR (&pDrvCtrl->endObj, IFF_UP | IFF_RUNNING);
  1624.         
  1625. ns83902Restart (pDrvCtrl, cr);
  1626.         return;
  1627. }
  1629.     /* handle packet received */
  1631.     if (isr & ISR_PRX)
  1632.         if (pDrvCtrl->rxHandling == FALSE)
  1633.             {
  1634.             pDrvCtrl->rxHandling = TRUE;
  1636.     /* disable receive interrupts and defer work to task context */
  1638.     NS83902_REG_SET (pDrvCtrl, NS83902_IMR, IMR_RX_DISABLE, CR_RPAGE0);
  1639.     netJobAdd ((FUNCPTR) ns83902HandleInt, (int) pDrvCtrl, 0, 0, 0, 0);
  1640.             }
  1641.     }
  1643. /*******************************************************************************
  1644. *
  1645. * ns83902Send - the driver's actual output routine
  1646. *
  1647. * This routine accepts outgoing packets from the snd queue, and then 
  1648. * gains exclusive access to the DMA (through a mutex semaphore),
  1649. * then calls ns83902Transmit() to send the packet out onto the interface.
  1650. *
  1651. * RETURNS: OK, or ERROR if the packet could not be transmitted.
  1652. */
  1654. LOCAL STATUS ns83902Send
  1655.     (
  1656.     NS83902_END_DEVICE* pDrvCtrl,
  1657.     M_BLK* pMblk
  1658.     )
  1659.     {
  1660.     int status;
  1662.     DRV_LOG (NS83902_DEBUG_TX, "Begin ns83902Send pDrvCtrl %p pMblk %pn", 
  1663.      (int)pDrvCtrl, (int)pMblk, 3, 4, 5, 6);
  1665.     if ((END_FLAGS_GET(&pDrvCtrl->endObj) & (IFF_UP | IFF_RUNNING)) !=
  1666.         (IFF_UP | IFF_RUNNING))
  1667.         {
  1668.         DRV_LOG (NS83902_DEBUG_TX, "Device is NOT UP and RUNNINGn",
  1669.                  1, 2, 3, 4, 5, 6);
  1670.         return (ERROR);
  1671.         }
  1673.     /* send packet out over interface */
  1675.     if ((status = ns83902Transmit (pDrvCtrl, pMblk)) == OK)
  1676.         {
  1677. /* Success, free the Mblk chain */
  1679. if (!NS83902_IS_IN_POLL_MODE())
  1680.     netMblkClChainFree (pMblk);
  1682.         END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_UCAST, +1);
  1683. }
  1684.     else
  1685.         {
  1686.         DRV_LOG (NS83902_DEBUG_TX, "FAILED ns83902Transmitn", 0, 0, 0, 0, 0, 0);
  1687.         
  1688.         /* update statistics */
  1690.         END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_ERRS, +1);
  1692. #ifdef NS83902_INSTRUMENT
  1693. ns83902TxError++;
  1694. #endif
  1695.         }
  1697.     DRV_LOG (NS83902_DEBUG_TX, "End ns83902Send n", 0, 0, 0, 0, 0, 0);
  1699. #ifdef NS83902_INSTRUMENT
  1700.     ns83902TxNb++;
  1701. #endif
  1703.     return status;    
  1704.     }
  1706. /*******************************************************************************
  1707. *
  1708. * ns83902Transmit - send data over the NIC network interface
  1709. *
  1710. * This routine transfers data to the NIC device via the remote DMA, and
  1711. * then signal for a transmission.
  1712. *
  1713. * RETURNS: OK, or ERROR if the transmitter signalled an error.
  1714. */
  1716. LOCAL STATUS ns83902Transmit
  1717.     (
  1718.     NS83902_END_DEVICE* pDrvCtrl,    
  1719.     M_BLK* pMblk
  1720.     )
  1721.     {
  1722.     int status = OK;
  1723.     int txLen = 0;
  1724.     UINT8 cr;
  1725.     LOCAL UINT8 txData[ETHERMTU + ENET_HDR_REAL_SIZ];
  1726.     int cnt;
  1727.     USHORT dummyRead;
  1729.     /* Get exclusive access to DMA */
  1731.     if (!NS83902_IS_IN_POLL_MODE())
  1732. NS83902_SEM_TAKE (pDrvCtrl, WAIT_FOREVER);
  1734.     txLen = netMblkToBufCopy (pMblk, txData, NULL);
  1735.     txLen = max (txLen, ETHERSMALL);
  1737.     /* Check if we are ready to transmit */
  1738.     
  1739.     NS83902_CR_GET (pDrvCtrl, cr);
  1741.     if (cr & CR_TXP)
  1742. {
  1743. DRV_LOG (NS83902_DEBUG_TX, "ns83902Transmit: waiting for TX_IN_PROGRESSn",
  1744.  1, 2, 3, 4, 5, 6);
  1746. /* Wait for end of TX */
  1748. cnt = 100; /* timeout 100 mSec */
  1749. while ((cr & CR_TXP) && (cnt-- > 0))
  1750.     {
  1751.     SYS_MS_DELAY (1);
  1752.     NS83902_CR_GET (pDrvCtrl, cr);
  1753.     }
  1754. }
  1756.     /* If still not ready, bail */
  1758.     NS83902_CR_GET (pDrvCtrl, cr);
  1759.     if (cr & CR_TXP)
  1760. {
  1761.         DRV_LOG (NS83902_DEBUG_TX, "Not Ready to transmit!n", 1, 2, 3, 4, 5, 6);
  1763. pDrvCtrl->txBlocked = TRUE; /* transmitter not ready */
  1765. if (!NS83902_IS_IN_POLL_MODE())
  1766.     NS83902_SEM_GIVE (pDrvCtrl);
  1768.         return (END_ERR_BLOCK);
  1769. }
  1771.     /* Dummy read with RBCR > 1 before (see DP83902 manual) */
  1773.     NS83902_REG_SET (pDrvCtrl, NS83902_RBCR0, 2, CR_RPAGE0);
  1774.     NS83902_REG_SET (pDrvCtrl, NS83902_RBCR1, 0, CR_RPAGE0);
  1775.     NS83902_REG_SET (pDrvCtrl, NS83902_RSAR0, 0, CR_RPAGE0);
  1776.     NS83902_REG_SET (pDrvCtrl, NS83902_RSAR1, LSB(pDrvCtrl->txStartPage),
  1777.      CR_RPAGE0);
  1779.     NS83902_REG_SET (pDrvCtrl, NS83902_CR, CR_RREAD, CR_RPAGE0);
  1781.     if (pDrvCtrl->wide == TRUE)
  1782. {
  1783. SYS_IN_SHORT (pDrvCtrl, pDrvCtrl->ioPort, dummyRead);
  1784. }
  1785.     else
  1786. {
  1787. SYS_IN_BYTE (pDrvCtrl, pDrvCtrl->ioPort, dummyRead);
  1788. SYS_IN_BYTE (pDrvCtrl, pDrvCtrl->ioPort, dummyRead);
  1789. }
  1791.     /* Set up remote DMA transfer */
  1793.     NS83902_REG_SET (pDrvCtrl, NS83902_RSAR0, 0, CR_RPAGE0);
  1794.     NS83902_REG_SET (pDrvCtrl, NS83902_RSAR1, LSB(pDrvCtrl->txStartPage), 
  1795.      CR_RPAGE0);
  1796.     NS83902_REG_SET (pDrvCtrl, NS83902_RBCR0, LSB(txLen), CR_RPAGE0);
  1797.     NS83902_REG_SET (pDrvCtrl, NS83902_RBCR1, MSB(txLen), CR_RPAGE0);
  1799.     /* Start remote DMA transfer */
  1801.     NS83902_REG_SET (pDrvCtrl, NS83902_CR, CR_RWRITE, CR_RPAGE0);
  1803.     /* write data to the DMA port */
  1805.     ns83902WritePort (pDrvCtrl, txData, txLen);
  1807.     /* Se up local DMA */
  1809.     NS83902_REG_SET (pDrvCtrl, NS83902_TPSR, pDrvCtrl->txStartPage, CR_RPAGE0);
  1810.     NS83902_REG_SET (pDrvCtrl, NS83902_TBCR0, LSB(txLen), CR_RPAGE0);
  1811.     NS83902_REG_SET (pDrvCtrl, NS83902_TBCR1, MSB(txLen), CR_RPAGE0);
  1813.     DRV_LOG (NS83902_DEBUG_TX, "Sending %d bytes from %p n", txLen,
  1814.      (int)txData, 3, 4, 5, 6);   
  1816.     /* Start transmission while preserving DMA command bits */
  1818.     NS83902_CR_GET (pDrvCtrl, cr);
  1819.     NS83902_REG_SET (pDrvCtrl, NS83902_CR, 
  1820.      CR_TXP | (cr & (CR_RWRITE | CR_RREAD | CR_ABORT)),
  1821.      CR_RPAGE0);
  1823.     /* Release Semaphore */
  1824.     
  1825.     if (!NS83902_IS_IN_POLL_MODE())
  1826. {
  1827. NS83902_SEM_GIVE (pDrvCtrl);
  1828. }
  1829.     else
  1830. {
  1831. UINT8 tsr;
  1832. UINT8 isr;
  1834. FOREVER
  1835.     {
  1836.     NS83902_REG_GET (pDrvCtrl, NS83902_ISR, isr, CR_RPAGE0);
  1837.     if ((isr & (ISR_PTX | ISR_TXE)) != 0)
  1838. break;
  1839.          }
  1841. /* Check for errors */
  1843. NS83902_REG_GET (pDrvCtrl, NS83902_TSR, tsr, CR_RPAGE0);
  1845. if ((tsr & TSR_PTX) == 0)
  1846.     {
  1847.     /* PTX zero, something went wrong */
  1849.     status = ERROR;
  1851.     if (tsr & TSR_ABT)
  1852. {
  1853. #ifdef NS83902_INSTRUMENT
  1854. ns83902TxTimeout++;
  1855. #endif
  1856. DRV_LOG (NS83902_DEBUG_TX, "ns83902Transmit Aborted n",
  1857.  1, 2, 3, 4, 5, 6);
  1858. }
  1860.     if (tsr & TSR_FU)
  1861. {
  1862. DRV_LOG (NS83902_DEBUG_TX, "ns83902Transmit FIFO Underrun n",
  1863.  1, 2, 3, 4, 5, 6);
  1864. }
  1865.     }
  1867. if (tsr & TSR_CRS)
  1868.     {
  1869.     logMsg ("%s%d - no carriern", (int)NS83902_DEV_NAME, pDrvCtrl->unit, 
  1870.     3, 4, 5, 6);
  1871.     }
  1873. #if 0   /* no collision statistics for END drivers? */
  1874. if (tsr & TSR_COL)
  1875.     {
  1876.     UINT8 ncr;
  1877.     NS83902_REG_GET (pDrvCtrl, NS83902_NCR, ncr, CR_RPAGE0);
  1878.     END_ERR_ADD (pEndObj, MIB2_COLLISIONS, ncr);
  1879.     }
  1880. #endif
  1882. /* Clear transmit flags in ISR */
  1884. NS83902_REG_SET (pDrvCtrl, NS83902_ISR, (ISR_PTX | ISR_TXE), CR_RPAGE0);
  1885. }
  1887.     return (status);
  1888.     }
  1890. /*******************************************************************************
  1891. *
  1892. * ns83902Ioctl - the driver's I/O control routine
  1893. *
  1894. * Perform device-specific commands.
  1895. *
  1896. * RETURNS: 0, or EINVAL if the command 'cmd' is not supported.
  1897. */
  1899. LOCAL int ns83902Ioctl
  1900.     (
  1901.     NS83902_END_DEVICE* pDrvCtrl,
  1902.     int cmd,
  1903.     caddr_t data    
  1904.     )
  1905.     {
  1906.     int  error = 0;
  1907.     long value;
  1908.     int saveFlags;
  1910.     DRV_LOG (NS83902_DEBUG_LOAD, "ns83902Ioctl Command %dn",
  1911.     cmd, 2, 3, 4, 5, 6);
  1912.     
  1913.     switch ((UINT)cmd)
  1914. {
  1915.         case EIOCSADDR:
  1916.     if (data == NULL)
  1917. return (EINVAL);
  1918.             bcopy ((char *)data, (char *)END_HADDR(&pDrvCtrl->endObj),
  1919.    END_HADDR_LEN(&pDrvCtrl->endObj));
  1920.             ns83902Config (pDrvCtrl); /* HELP  Will it work? */
  1921.             break;
  1923.         case EIOCGADDR:
  1924.     if (data == NULL)
  1925. return (EINVAL);
  1926.             bcopy ((char *)END_HADDR(&pDrvCtrl->endObj), (char *)data,
  1927.     END_HADDR_LEN(&pDrvCtrl->endObj));
  1928.             break;
  1930.         case EIOCSFLAGS:
  1931.     value = (long) data;
  1932.     if( value < 0 )
  1933. {
  1934. value = -value;
  1935. value--;
  1936. END_FLAGS_CLR (&pDrvCtrl->endObj, value);
  1937. }
  1938.     else
  1939. {
  1940. END_FLAGS_SET (&pDrvCtrl->endObj, value);
  1941. }
  1943.     saveFlags = DRV_FLAGS_GET();
  1945.     if (DRV_FLAGS_GET() != saveFlags && 
  1946.            (END_FLAGS_GET(&pDrvCtrl->endObj) & IFF_UP))
  1947. {
  1948. END_FLAGS_CLR (&pDrvCtrl->endObj, IFF_UP | IFF_RUNNING);
  1949. ns83902Config( pDrvCtrl );
  1950. }
  1951.             break;
  1953.         case EIOCGFLAGS:
  1954.     if (data == NULL)
  1955. error = EINVAL;
  1956.     else
  1957. *(int *)data = END_FLAGS_GET(&pDrvCtrl->endObj);
  1958.     break;
  1960.         case EIOCMULTIADD:                   /* move to mux */
  1961.             error = ns83902MCastAddrAdd (pDrvCtrl, (char *)data);
  1962.             break;
  1964.         case EIOCMULTIDEL:                   /* move to mux */
  1965.             error = ns83902MCastAddrDel (pDrvCtrl, (char *)data);
  1966.             break;
  1968.         case EIOCMULTIGET:                   /* move to mux */
  1969.             error = ns83902MCastAddrGet (pDrvCtrl, (MULTI_TABLE *)data);
  1970.             break;
  1972.         case EIOCPOLLSTART:                  /* move to mux */
  1973.             error = ns83902PollStart (pDrvCtrl);
  1974.             break;
  1976.         case EIOCPOLLSTOP:                   /* move to mux */
  1977.             error = ns83902PollStop (pDrvCtrl);
  1978.             break;            
  1980.         case EIOCGMIB2:
  1981.             if (data == NULL)
  1982.                 return (EINVAL);
  1983.             bcopy((char *)&pDrvCtrl->endObj.mib2Tbl, (char *)data,
  1984.                   sizeof(pDrvCtrl->endObj.mib2Tbl));
  1985.             break;
  1987.         default:
  1988.             error = EINVAL;
  1989. }
  1990.     return (error);
  1991.     } 
  1993. /*******************************************************************************
  1994. *
  1995. * ns83902Stop - stop the device
  1996. *
  1997. * This function calls BSP functions to disconnect interrupts and stop
  1998. * the device from operating in interrupt mode.
  1999. *
  2000. * RETURNS: OK or ERROR
  2001. */
  2003. LOCAL STATUS ns83902Stop
  2004.     (
  2005.     NS83902_END_DEVICE* pDrvCtrl
  2006.     )
  2007.     {
  2008.     STATUS result = OK;
  2010.     END_FLAGS_CLR (&pDrvCtrl->endObj,IFF_UP | IFF_RUNNING );
  2012.     /* Stop the device. */
  2014.     NS83902_REG_SET (pDrvCtrl, NS83902_CR, CR_STP | CR_ABORT, CR_RPAGE0);
  2016.     /* disable all interrupts */
  2018.     NS83902_REG_SET (pDrvCtrl, NS83902_IMR, IMR_DISABLE, CR_RPAGE0);
  2020.     /* Disable LAN interrupts */
  2022.     SYS_INT_DISABLE (pDrvCtrl);
  2024.     /* disconnect interrupt */
  2026.     SYS_INT_DISCONNECT (pDrvCtrl, ns83902Int, (int)pDrvCtrl, &result);
  2028.     if (result == ERROR)
  2029. {
  2030. DRV_LOG (NS83902_DEBUG_TMP, "Could not diconnect interrupt!n",
  2031.                  1, 2, 3, 4, 5, 6);
  2032. }
  2034.     return (result);
  2035.     }
  2037. /******************************************************************************
  2038. *
  2039. * ns83902Unload - unload a driver from the system
  2040. *
  2041. * This function first brings down the device, and then frees any
  2042. * stuff that was allocated by the driver in the load function.
  2043. */
  2045. LOCAL STATUS ns83902Unload
  2046.     (
  2047.     NS83902_END_DEVICE* pDrvCtrl
  2048.     )
  2049.     {
  2050.     if (pDrvCtrl != NULL)
  2051.         {
  2052.         END_OBJECT_UNLOAD (&pDrvCtrl->endObj);
  2054.         /* free resources */
  2056.         if (pDrvCtrl->pCluster != NULL)
  2057.             free (pDrvCtrl->pCluster);
  2058.         }
  2060.     return (OK);
  2061.     }
  2063. /*******************************************************************************
  2064. *
  2065. * ns83902MCastAddrAdd - add a multicast address
  2066. *
  2067. *
  2068. * RETURNS: OK on success, ERROR otherwise.
  2069. */
  2071. LOCAL STATUS ns83902MCastAddrAdd
  2072.     (
  2073.     NS83902_END_DEVICE* pDrvCtrl,
  2074.     char * pAddr
  2075.     )
  2076.     {
  2077.     int retVal;
  2079.     DRV_LOG (NS83902_DEBUG_IOCTL, "MCastAddrAddn", 0, 0, 0, 0, 0, 0);
  2081.     retVal = etherMultiAdd (&pDrvCtrl->endObj.multiList, pAddr);
  2083.     if (retVal == ENETRESET)
  2084.         return ns83902AddrFilterSet (pDrvCtrl, pAddr, TRUE);
  2086.     return ((retVal == OK) ? OK : ERROR);
  2087.     }
  2089. /*******************************************************************************
  2090. *
  2091. * ns83902MCastAddrDel - remove a multicast address
  2092. *
  2093. *
  2094. * RETURNS: OK on success, ERROR otherwise.
  2095. */
  2097. LOCAL STATUS ns83902MCastAddrDel
  2098.     (
  2099.     NS83902_END_DEVICE* pDrvCtrl,
  2100.     char * pAddr
  2101.     )
  2102.     {
  2103.     int  retVal;
  2105.     DRV_LOG (NS83902_DEBUG_IOCTL, "MCastAddrDeln", 0, 0, 0, 0, 0, 0);
  2107.     retVal = etherMultiDel (&pDrvCtrl->endObj.multiList, pAddr);
  2109.     if (retVal == ENETRESET)
  2110.         return ns83902AddrFilterSet (pDrvCtrl, pAddr, FALSE);
  2112.     return ((retVal == OK) ? OK : ERROR);
  2113.     }
  2115. /*******************************************************************************
  2116. *
  2117. * ns83902MCastAddrGet - retreive current multicast address list
  2118. *
  2119. *
  2120. * RETURNS: OK on success; otherwise ERROR.
  2121. */
  2123. LOCAL STATUS ns83902MCastAddrGet
  2124.     (
  2125.     NS83902_END_DEVICE* pDrvCtrl,
  2126.     MULTI_TABLE * pTable
  2127.     )
  2128.     {
  2129.     DRV_LOG (NS83902_DEBUG_IOCTL, "MCastAddrGetn", 0, 0, 0, 0, 0, 0);
  2131.     return (etherMultiGet (&pDrvCtrl->endObj.multiList, pTable));
  2132.     }
  2134. /*******************************************************************************
  2135. *
  2136. * ns83902PollStart - starting polling mode
  2137. *
  2138. * RETURNS: OK, always.
  2139. */
  2141. LOCAL STATUS ns83902PollStart
  2142.     (
  2143.     NS83902_END_DEVICE* pDrvCtrl
  2144.     )
  2145.     {
  2146.     int intLevel;
  2148.     DRV_LOG (NS83902_DEBUG_POLL, "S ", 0, 0, 0, 0, 0, 0);
  2150.     intLevel = intLock();
  2152.     /* disable all interrupts */
  2154.     NS83902_REG_SET (pDrvCtrl, NS83902_IMR, IMR_DISABLE, CR_RPAGE0);
  2155.     DRV_FLAGS_SET (NS83902_FLAG_POLL);
  2157.     intUnlock (intLevel);
  2159.     return (OK);    
  2160.     }
  2162. /*******************************************************************************
  2163. *
  2164. * ns83902PollStop - stop polling mode
  2165. *
  2166. * RETURNS: OK, always.
  2167. */
  2169. LOCAL STATUS ns83902PollStop
  2170.     (
  2171.     NS83902_END_DEVICE* pDrvCtrl
  2172.     )
  2173.     {
  2174.     int intLevel;
  2176.     intLevel = intLock();
  2178.     /* enable interrupts */
  2180.     NS83902_REG_SET (pDrvCtrl, NS83902_IMR, IMR_ENABLE, CR_RPAGE0);
  2181.     DRV_FLAGS_CLR(NS83902_FLAG_POLL);
  2183.     DRV_LOG (NS83902_DEBUG_POLL, "s", 0, 0, 0, 0, 0, 0);
  2184.     
  2185.     intUnlock (intLevel);
  2187.     return (OK);
  2188.     }
  2190. /*******************************************************************************
  2191. *
  2192. * ns83902PollSend - send a packet in polled mode
  2193. *
  2194. * RETURNS: OK on success, EAGAIN on failure
  2195. */
  2197. LOCAL STATUS ns83902PollSend
  2198.     (
  2199.     NS83902_END_DEVICE* pDrvCtrl,
  2200.     M_BLK* pMblk
  2201.     )
  2202.     {
  2203.     return (ns83902Send (pDrvCtrl, pMblk));
  2204.     }
  2206. /*******************************************************************************
  2207. *
  2208. * ns83902PollReceive - get a packet in polled mode
  2209. *
  2210. * RETURNS: OK on success, EAGAIN on failure.
  2211. */
  2213. LOCAL STATUS ns83902PollReceive
  2214.     (
  2215.     NS83902_END_DEVICE* pDrvCtrl,
  2216.     M_BLK* pMblk
  2217.     )
  2218.     {
  2219.     STATUS nRetValue = OK;
  2220.     NS83902_CLUSTER pCluster;
  2221.     int len;
  2222.     
  2223.     DRV_LOG (NS83902_DEBUG_POLL, "Start Poll Read!n", 1, 2, 3, 4, 5, 6);
  2225.     if ((pCluster = ns83902ReadFrame (pDrvCtrl)) == NULL)
  2226.         nRetValue = EAGAIN;
  2227.     else
  2228.         {
  2229.         NS83902_RX_FRAME* pRx = (NS83902_RX_FRAME*)pCluster;
  2230.         
  2231.         len = pRx->rxHdr.count;
  2232.     
  2233. pMblk->mBlkHdr.mFlags |= M_PKTHDR; /* set the packet header */
  2234. pMblk->mBlkHdr.mLen = len;    /* set the data len */
  2235. pMblk->mBlkPktHdr.len = len;    /* set the total len */
  2236. pMblk->mBlkHdr.mData += 2;
  2238.         bcopy ((char *)&pRx->enetHdr, (char *)pMblk->mBlkHdr.mData, len);
  2239.         netClFree (pDrvCtrl->endObj.pNetPool, (UCHAR *)pRx);
  2240.         }
  2241.     
  2242.     DRV_LOG (NS83902_DEBUG_POLL, "End Poll Read!n", 1, 2, 3, 4, 5, 6);        
  2243.     return nRetValue;
  2244.     }
  2246. /*******************************************************************************
  2247. *
  2248. * ns83902HashIndex - compute the hash index for an ethernet address
  2249. *
  2250. * RETURNS: hash index for an ethernet address.
  2251. */
  2253. LOCAL int ns83902HashIndex
  2254.     (
  2255.     char * eAddr
  2256.     )
  2257.     {
  2258.     UINT8 eAddrByte;
  2259.     int index;                       /* hash index - return value */
  2260.     int byte;                        /* loop - counter */
  2261.     int bit;                         /* loop - counter */
  2262.     UINT crc = 0xffffffff;
  2263.     UINT8 msb;
  2265.     for (byte=0; byte<6; byte++)
  2266.         {
  2267.         eAddrByte = eAddr[byte];
  2269.         for (bit=0; bit<8; bit++)
  2270.             {
  2271.             msb = crc >> 31;
  2272.             crc <<= 1;
  2273.             if (msb ^ (eAddrByte & 0x1))
  2274.                 {
  2275.                 crc ^= NS83902_CRC_POLY;
  2276.                 crc |= 0x1;
  2277.                 }
  2278.             eAddrByte >>= 1;
  2279.             }
  2280.         }
  2282.     /* Just want the 6 most significant bits. */
  2283.     
  2284.     index = crc >> 26 ;
  2286.     return index;
  2287.     }
  2289. /******************************************************************************
  2290. *
  2291. * ns83902AddrFilterSet - set the address filter for multicast addresses
  2292. *
  2293. * This routine goes through all of the multicast addresses on the list
  2294. * of addresses (added with the MCastAddrAdd() routine) and sets the
  2295. * device's filter correctly.
  2296. *
  2297. * NOMANUAL
  2298. */
  2300. LOCAL STATUS ns83902AddrFilterSet
  2301.     (
  2302.     NS83902_END_DEVICE* pDrvCtrl,
  2303.     char* pAddr,
  2304.     BOOL bSet
  2305.     )
  2306.     {
  2308.     UINT8 nHashIndex;
  2310.     /* get hash index for the address */
  2312.     nHashIndex = ns83902HashIndex (pAddr);
  2314.     /* Turn on the corresponding bit in the filter. */
  2316.     ns83902MARSet (pDrvCtrl, nHashIndex, bSet);
  2318.     return OK;
  2319.     }
  2321. /*******************************************************************************
  2322. *
  2323. * ns83902MARSet - sets/resets the MAR for the specified hash index
  2324. *
  2325. * This routine sets/resets the MAR bit for the specified hash index
  2326. *
  2327. * RETURNS: OK or ERROR.
  2328. */
  2330. LOCAL void ns83902MARSet
  2331.     (
  2332.     NS83902_END_DEVICE* pDrvCtrl,    
  2333.     UINT8 index, /* hash index */
  2334.     BOOL bSet /* Set/Reset */
  2335.     )
  2336.     {
  2337.     UINT8 nRegOffset = index;
  2338.     UINT8 nBitPosition = index;
  2339.     UINT8 nBitMask = (UINT8)0x01;
  2340.     UINT8 nValue;
  2341.     
  2342.     /* Find register and bit position */
  2344.     nBitPosition = nBitPosition & 0x07; /* 3 LSB bits */
  2345.     nBitMask <<= nBitPosition;
  2346.     nRegOffset >>= 3;       /* next 3 bits */
  2348.     /* set the bit in bit array*/
  2350.     NS83902_REG_GET (pDrvCtrl, NS83902_MAR0 + nRegOffset, nValue, CR_RPAGE1);
  2352.     DRV_LOG (NS83902_DEBUG_LOAD, "Hash Index:%d MAR Offset:%d value:%dn",
  2353.              index, nRegOffset, nValue, 4, 5, 6);
  2354.     
  2355.     if (bSet)
  2356.         {
  2357.         nValue |= nBitMask; /* set */
  2358.         }
  2359.     else
  2360.         {
  2361.         nBitMask = ~nBitMask; /* reset */
  2362.         nValue &= nBitMask;        
  2363.         }
  2364.     
  2365.     NS83902_REG_SET (pDrvCtrl, NS83902_MAR0 + nRegOffset, nValue, CR_RPAGE1);
  2366.     
  2367.     DRV_LOG (NS83902_DEBUG_LOAD, "Hash Index:%d MAR Offset:%d value:%dn",
  2368.              index, nRegOffset, nValue, 4, 5, 6);
  2369.     }
  2371. /*******************************************************************************
  2372. *
  2373. * ns83902RegRead - read the current value of a NIC register
  2374. *
  2375. * This routine reads the register values of a NIC register
  2376. *
  2377. * RETURNS: register value.
  2378. */
  2380. LOCAL UINT8 ns83902RegRead
  2381.     (
  2382.     NS83902_END_DEVICE* pDrvCtrl,
  2383.     int  reg,
  2384.     int  page
  2385.     )
  2386.     {
  2387.     UINT8  value;
  2388.     int  oldLevel = intLock();
  2390.     if ((pDrvCtrl)->regPage != (page))
  2391. {
  2392. /* Set the register page */
  2393. UINT8 cr;
  2394. (pDrvCtrl)->regPage = (page);
  2395. NS83902_CR_GET ((pDrvCtrl), cr);
  2396. NS83902_CR_SET ((pDrvCtrl), (cr & !CR_PAGE_MASK) | (page));
  2397. }
  2398.     SYS_IN_BYTE (pDrvCtrl, pDrvCtrl->pNic + reg * pDrvCtrl->regInterval,value);
  2399.     SYS_NS83902_DELAY();
  2401.     intUnlock (oldLevel);
  2402.     return (value);
  2403.     }
  2404.  
  2405. /*******************************************************************************
  2406. *
  2407. * ns83902RegSet - set a NIC register
  2408. *
  2409. * This routine reads and displays the register values of the NIC registers
  2410. *
  2411. * RETURNS: N/A.
  2412. */
  2414. LOCAL void ns83902RegSet
  2415.     (
  2416.     NS83902_END_DEVICE* pDrvCtrl,
  2417.     int reg,
  2418.     int value,
  2419.     int page
  2420.     )
  2421.     {
  2422.     int  oldLevel = intLock();
  2424.     if (pDrvCtrl->regPage != page)
  2425. {
  2426. /* Set the page */
  2427. UINT8 cr;
  2428. pDrvCtrl->regPage = page;
  2429. NS83902_CR_GET (pDrvCtrl, cr);
  2430. NS83902_CR_SET (pDrvCtrl, ((cr & !CR_PAGE_MASK) | page));
  2431. }
  2432.     SYS_OUT_BYTE (pDrvCtrl, pDrvCtrl->pNic + reg * pDrvCtrl->regInterval, value);
  2433.     SYS_NS83902_DELAY();
  2435.     intUnlock (oldLevel);
  2436.     }
  2439. #ifdef NS83902_DEBUG
  2440. /*******************************************************************************
  2441. *
  2442. * ns83902RegShow - prints the current value of the NIC registers
  2443. *
  2444. * This routine reads and displays the register values of the NIC registers
  2445. *
  2446. * RETURNS: N/A.
  2447. */
  2449. void ns83902RegShow 
  2450.     (
  2451.     NS83902_END_DEVICE* pDrvCtrl
  2452.     )
  2453.     {
  2454.     UINT8  value;
  2456.     NS83902_CR_GET (pDrvCtrl, value);
  2457.     printf ("CR:    0x%x n", value);
  2458.     NS83902_REG_GET (pDrvCtrl, NS83902_CLDA0, value, CR_RPAGE0);
  2459.     printf ("CLDA0: 0x%x n", value);
  2460.     NS83902_REG_GET (pDrvCtrl, NS83902_CLDA1, value, CR_RPAGE0);
  2461.     printf ("CLDA1: 0x%x n", value);
  2462.     NS83902_REG_GET (pDrvCtrl, NS83902_BNRY, value, CR_RPAGE0);
  2463.     printf ("BNRY:  0x%x n", value);
  2464.     NS83902_REG_GET (pDrvCtrl, NS83902_TSR, value, CR_RPAGE0);
  2465.     printf ("TSR:   0x%x n", value);
  2466.     NS83902_REG_GET (pDrvCtrl, NS83902_ISR, value, CR_RPAGE0);
  2467.     printf ("ISR:   0x%x n", value);
  2468.     NS83902_REG_GET (pDrvCtrl, NS83902_CRDA0, value, CR_RPAGE0);
  2469.     printf ("CRDA0: 0x%x n", value);
  2470.     NS83902_REG_GET (pDrvCtrl, NS83902_CRDA1, value, CR_RPAGE0);
  2471.     printf ("CRDA1: 0x%x n", value);
  2472.     NS83902_REG_GET (pDrvCtrl, NS83902_RSR, value, CR_RPAGE0);
  2473.     printf ("RSR:   0x%x n", value);
  2474.     }
  2476. #endif