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

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

VxWorks

开发平台：

C/C++

if_nicEvb.c：源码内容
  1. /* if_nicEvb.c - National Semiconductor ST-NIC Chip network interface driver */
  3. /* Copyright 1984-1997 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 03i,05may97,tam  re-work driver to improve reliability and performances:
  10.                  modified receive interrupt processing and error handling,
  11.                  fixed bug in nicTxStartup(), added function nicPagePtrUpdate()
  12.  and nicResetDelay().
  13. 03h,21apr97,mkw  reset count to 0 before timeout check in nicTransmit and
  14.  set TRANS_TIMOUT value to 400.
  15. 03g,18apr97,mkw  Fixed nicTransmit to use count value.
  16. 03g,15jul97,spm  added ARP request to SIOCSIFADDR ioctl handler
  17. 03f,05mar97,map  added sysEnetAddrGet() call to fetch MAC address (SPR# 7745)
  18. 03f,07apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  19. 03e,10dec96,tpr  removed intEnable() prototype. Defined in intLib.h now.
  20. 03d,18sep96,p_m  added SYNC definition for CPUs other than PPC
  21. 03c,08aug96,tam  added code to synchronize i/o acess in nicWritePort().
  22. 03b,03mar96,tam  replaced sysIntEnablePIC by intEnable().
  23. 03a,02feb96,dzb  re-worked many parts of driver. implemented Rx buffer-loaning.
  24.                  fixed nicRestart to recover gracefully from DMA overflow.
  25.  re-worked Tx code to send directly from mbuf chain.
  26.  changed to turn off Rx interrupts, instead of an active flag.
  27.  fixed nicRead() to flush extra DMA-byte on Rx error.
  28. 02d,11jul95,amp  used intLock(), implemented nicEnetAddrGet(), cleanup.
  29. 02c,29jun95,caf  changed name to "nicEvb".
  30. 02b,27jun95,amp  improved reliability.
  31. 02a,16jun95,amp  modified if_nic.c for EVB403.
  32. 01z,11aug93,jmm  Changed ioctl.h and socket.h to sys/ioctl.h and sys/socket.h
  33. 01y,19feb93,jdi  documentation cleanup.
  34. 01x,15oct92,rfs  Added documentation.
  35. 01w,02oct92,rfs  Made multiple attach calls per unit return OK.
  36. 01v,09sep92,gae  documentation tweaks.
  37. 01u,02sep92,ajm  added conditional compilation for __STDC__ (DEC)
  38. 01t,18aug92,rfs  Revised to follow style of other drivers.
  39.                  Added cache support.  Reworked OVW error recovery.
  40. 01s,23jun92,ajm  fixed ansi warnings for pktBufRead calls
  41.                  went back and fixed all 68k ansi warnings
  42. 01r,26may92,rrr  the tree shuffle
  43.                  -changed includes to have absolute path from h/
  44. 01q,26may92,ajm  got rid of HOST_DEC def's (new compiler)
  45.                  updated copyright
  46. 01p,10oct91,rfs  modified pktBufRead() & pktBufWrite() to return if len is zero
  47. 01o,04oct91,rrr  passed through the ansification filter
  48.                  -changed functions to ansi style
  49.                  -changed includes to have absolute path from h/
  50.                  -changed VOID to void
  51.                  -changed copyright notice
  52. 01n,28sep91,ajm  ifdef'd HOST_DEC for compiler problem
  53. 01m,02Aug91,rfs  cleanup of transmit design, int handler, NIC command register
  54.                  was being handled incorrectly, DMA operations required
  55.                  semaphoring and error checking, changed names, deleted
  56.                  nicdelay(), deleted excessive include files. Provided correct
  57.                  OVW recovery.  Your basic rewrite.
  58. 01l,01may91,elh  fixed transmit buffering problems, added changes from
  59.                  heurikon, removed DMAState, XmtByteCount.
  60. 01k,20sep90,dab  made nicInit() return int.
  61. 01j,10aug90,dnw  added forward declarations of void routines.
  62.                  added include of if_subr.h.
  63. 01i,11jul90,hjb  removed code that uses gotIp.  made nicRead() a void function.
  64.                  changed references to do_protocol() to use
  65.                  do_protocol_with_type().
  66. 01h,19apr90,hjb  deleted param.h, de-linted.
  67. 01g,18mar90,hjb  reduction of redundant code and addition of cluster support.
  68.                  added error recording (TXE, RXE), removed unnecessary
  69.                  error handler which didn't do anything.  delinted.
  70. 01f,18sep89,cwp  added multiple transmit buffer support
  71. 01e,14sep89,dab  changed iv68k.h to iv.h.
  72. 01d,15jun89,cwp  fixed ring buffer overflow and transmit errors.
  73. 01c,04apr89,cwp  first working version.
  74. 01b,25feb89,cwp  added changes from unix driver.
  75. 01a,12jan89,cwp  written.
  76. */
  78. /*
  79. This module implements the National Semiconductor 83902A ST-NIC Ethernet
  80. network interface driver.
  82. This driver is non-generic and is for use on the IBM EVB403 board.  
  83. Only unit number zero is supported.  The driver must be given several 
  84. target-specific parameters.  These parameters, and the mechanisms 
  85. used to communicate them to the driver, are detailed below.
  87. BOARD LAYOUT
  88. This device is on-board.  No jumpering diagram is necessary.
  90. EXTERNAL INTERFACE
  91. This driver provides the standard external interface with the following
  92. exceptions.  All initialization is performed within the attach routine; there
  93. is no separate initialization routine.  Therefore, in the global interface
  94. structure, the function pointer to the initialization routine is NULL.
  96. The only user-callable routine is nicEvbattach(), which publishes the `nicEvb'
  97. interface and initializes the driver and device.
  99. TARGET-SPECIFIC PARAMETERS
  100. .iP "device I/O address"
  101. This parameter is passed to the driver by nicEvbattach().
  102. It specifies the base address of the device's I/O register
  103. set.
  104. .iP "interrupt vector"
  105. This parameter is passed to the driver by nicEvbattach().
  106. It specifies the interrupt vector to be used by the driver
  107. to service an interrupt from the ST-NIC device.  The driver will connect
  108. the interrupt handler to this vector by calling intConnect().
  109. .iP "device restart/reset delay"
  110. The global variable nicRestartDelay (UINT32), defined in this file, 
  111. should be initialized in the BSP sysHwInit() routine. nicRestartDelay is 
  112. used only with PowerPC platform and is equal to the number of time base 
  113. increments which makes for 1.6 msec. This corresponds to the delay necessary 
  114. to respect when restarting or resetting the device.
  115. .LP
  117. EXTERNAL SUPPORT REQUIREMENTS
  119. The driver requires the following support functions:
  121. .iP "STATUS sysEnetAddrGet (int unit, UINT8 * addr)" "" 9 -1
  122. The driver expects this routine to provide the six-byte Ethernet hardware
  123. address that will be used by <unit>.  This routine must copy the six-byte
  124. address to the space provided by <addr>.  This routine is expected to return
  125. OK on success, or ERROR.  The driver calls this routine, during device
  126. initialization, from the nicEnetAddrGet() routine.
  127. .LP
  129. SYSTEM RESOURCE USAGE
  130. When implemented, this driver requires the following system resources:
  132.     - one mutual exclusion semaphore
  133.     - one interrupt vector
  135. SEE ALSO: ifLib
  136. */
  138. /* includes */
  140. #include "vxWorks.h"
  141. #include "iv.h"
  142. #include "stdlib.h"
  143. #include "intLib.h"
  144. #include "netLib.h"
  146. #ifdef NIC_DEBUG
  147. #include "logLib.h"
  148. #endif
  150. #include "taskLib.h"
  151. #include "logLib.h"
  152. #include "net/mbuf.h"
  153. #include "sys/ioctl.h"
  154. #include "errno.h"
  155. #include "net/if.h"
  156. #include "net/unixLib.h"
  157. #include "net/if_subr.h"
  158. #include "netinet/in_var.h"
  159. #include "netinet/if_ether.h"
  160. #include "etherLib.h"
  161. #include "semLib.h"
  162. #include "drv/netif/netifDev.h"
  163. #include "drv/netif/if_nicEvb.h"
  164. #include "vxLib.h"
  165. #include "private/funcBindP.h"
  167. /* defines */
  169. #if (CPU_FAMILY == PPC)
  170. #define NIC_USE_PPCTIMEBASE
  171. #else   /* CPU_FAMILY == PPC */
  172. #undef NIC_USE_PPCTIMEBASE
  173. #endif /* CPU_FAMILY == PPC */
  175. #define MAX_UNITS 1 /* max number of units supported */
  176. #define TRANS_TIMEOUT 400 /* times to poll for end of Tx */
  177. #define L_POOL           0x4 /* Rx loan buffers in pool */
  179. /* debug macros */
  181. #undef NIC_INSTRUMENT /* instrument the driver */
  182. #undef NIC_DEBUG /* log debug messages */
  184. /* 
  185.  * NIC_FASTER, if defined, improved the driver throuput, however the driver
  186.  * seems to be less reliable. Left undefined for now.
  187.  */
  189. #undef NIC_FASTER /* improve throuput but less stable */
  191. /* typedefs */
  193. typedef struct mbuf MBUF;
  194. typedef struct arpcom IDR; /* Interface Data Record wrapper */
  195. typedef struct ifnet IFNET; /* real Interface Data Record */
  196. typedef struct sockaddr SOCK;
  197. typedef struct ether_header ETH_HDR;
  199. typedef struct rx_hdr
  200.     {
  201.     UINT8 status; /* status of packet */
  202.     UINT8 nextRxPage; /* page next pkt starts at */
  203.     UINT8 cntL; /* low byte of frame length */
  204.     UINT8 cntH; /* high byte of frame length */
  205.     } RX_HDR;
  207. #define RX_HDR_SIZ sizeof(RX_HDR)
  209. typedef struct rx_frame
  210.     {
  211.     UINT16 pad1;
  212.     RX_HDR rxHdr; /* receive status header */
  213.     ETH_HDR enetHdr; /* ethernet header */
  214.     UINT8 data [ETHERMTU];/* frame data */
  215.     UINT32 fcs; /* frame check sequence */
  216.     UINT8 refCnt; /* loaner reference count */
  217.     UINT8 pad2;
  218.     } RX_FRAME;
  220. #define RX_FRAME_SIZ sizeof(RX_FRAME)
  222. typedef struct drv_ctrl /* driver control structure */
  223.     {
  224.     IDR                 idr; /* interface data record */
  225.     BOOL                attached; /* indicates unit is attached */
  226.     int                 nicIntVec; /* interrupt vector */
  227.     SEM_ID              dmaSem; /* exclusive use of remote DMA */
  228.     UINT8 nextPkt; /* NIC buf page for next pkt */
  229.     NIC_DEVICE * nicAddr; /* address of NIC chip */
  230.     RX_FRAME * pRxFrame; /* Rx frame memory */
  231.     RX_FRAME * lPool [L_POOL]; /* Rx loaner pool */
  232.     int lIndex; /* Rx loaner pool index */
  233.     } DRV_CTRL;
  235. /* globals */
  237. UINT32  nicRestartDelay = 30000;/* number of time base ticks to wait for */
  238. /* when resetting the chip */
  239. #ifdef NIC_INSTRUMENT
  240. UINT32 nicRestartNb = 0; /* number of restart due to ring overflow */
  241. UINT32 nicIntNb = 0; /* number of receive interrupt */
  242. UINT32 nicLen = 0; /* lenght of the current received packet */
  243. UINT32 nicHdrStat = 0; /* status byte of the current received packet */
  244. UINT32 nicNextPage = 0; /* page pointer to the next received packet */
  245. UINT32 nicCurrentPage = 0; /* start page of the current packet */
  246. UINT32 nicTxNb = 0; /* number of transmitted packets */
  247. UINT32 nicTxTimeout = 0; /* number of transmit time-out */
  248. UINT32 nicInitNb = 0; /* number of time device is re-initialized */
  249. #endif
  251. IMPORT STATUS sysEnetAddrGet (int unit, UINT8 * addr);
  253. /* locals */
  255. LOCAL DRV_CTRL drvCtrl [MAX_UNITS];
  257. /* forward declarations */
  259. #ifdef __STDC__
  261. LOCAL void nicReset (int unit);
  262. LOCAL void nicIntr (int unit);
  263. LOCAL void nicRestart (DRV_CTRL *pDrvCtrl, UINT8 cr);
  264. LOCAL void nicHandleInt (DRV_CTRL *pDrvCtrl);
  265. LOCAL BOOL nicRead (DRV_CTRL *pDrvCtrl);
  266. #ifdef BSD43_DRIVER
  267. LOCAL int nicOutput (IDR *pIDR, MBUF *pMbuf, SOCK *pDest);
  268. #endif
  269. LOCAL int nicIoctl (IDR *pIDR, int cmd, caddr_t data);
  270. LOCAL void nicEnetAddrGet (int unit);
  271. LOCAL void nicConfig (int unit);
  272. LOCAL STATUS nicPktBufRead (DRV_CTRL *pDrvCtrl, UINT32 nicBufAddr,
  273.     UINT32 len, char *pData);
  274. LOCAL void nicWriteCr (NIC_DEVICE *pNic, UINT8 value);
  275. LOCAL void nicWriteReg (NIC_DEVICE *pNic, volatile UINT8 *pReg,
  276.     UINT8 value, UINT8 page);
  277. LOCAL UINT8 nicReadReg (NIC_DEVICE *pNic, volatile UINT8 *pReg, char page);
  278. LOCAL STATUS nicTransmit (DRV_CTRL *pDrvCtrl, MBUF *pMbuf, int len,
  279.     BOOL waitFlag);
  280. LOCAL void nicWritePort (UINT8 value);
  281. LOCAL STATUS nicReceive (DRV_CTRL *pDrvCtrl, UINT32 nicBufAddr, char *pData,
  282.     int len);
  283. #ifdef BSD43_DRIVER
  284. LOCAL STATUS nicTxStartup(int unit);
  285. #else
  286. LOCAL STATUS nicTxStartup(DRV_CTRL *pDrvCtrl);
  287. #endif
  288. LOCAL UINT8 nicReadPort (void);
  289. LOCAL void nicLoanFree (DRV_CTRL *pDrvCtrl, RX_FRAME *pRx);
  290. LOCAL BOOL nicPagePtrUpdate (DRV_CTRL * pDrvCtrl);
  291. LOCAL void nicResetDelay (void);
  293. #else  /* __STDC__ */
  295. LOCAL void nicReset ();
  296. LOCAL void nicIntr ();
  297. LOCAL void nicRestart ();
  298. LOCAL void nicHandleInt ();
  299. LOCAL BOOL nicRead ();
  300. LOCAL int nicOutput ();
  301. LOCAL int nicIoctl ();
  302. LOCAL void nicEnetAddrGet ();
  303. LOCAL void nicConfig ();
  304. LOCAL STATUS nicPktBufRead ();
  305. LOCAL void nicWriteCr ();
  306. LOCAL void nicWriteReg ();
  307. LOCAL UINT8 nicReadReg ();
  308. LOCAL STATUS nicTransmit ();
  309. LOCAL void nicWritePort ();
  310. LOCAL STATUS nicReceive ();
  311. LOCAL STATUS nicTxStartup();
  312. LOCAL UINT8 nicReadPort ();
  313. LOCAL void nicNicFree ();
  314. LOCAL BOOL nicPagePtrUpdate ();
  315. LOCAL void nicResetDelay () ;
  317. #endif  /* __STDC__ */
  319. /*******************************************************************************
  320. *
  321. * nicEvbattach - publish and initialize the `nicEvb' network interface driver
  322. *
  323. * This routine publishes the `nicEvb' interface by filling in a network
  324. * interface record and adding this record to the system list.  It also
  325. * initializes the driver and the device to the operational state.
  326. *
  327. * RETURNS: OK, or ERROR if the receive buffer memory could not be allocated.
  328. */
  330. STATUS nicEvbattach
  331.     (
  332.     int unit, /* unit number */
  333.     NIC_DEVICE * pNic, /* address of NIC chip */
  334.     int ivec /* interrupt vector to use */
  335.     )
  336.     {
  337.     DRV_CTRL * pDrvCtrl; /* driver control struct */
  338.     RX_FRAME * pPool; /* receive memory pool */
  339.     int ix; /* counter */
  341.     if (unit < 0 || unit >= MAX_UNITS) /* sanity check the unit number */
  342.         return (ERROR);
  344.     pDrvCtrl = &drvCtrl [unit];
  346.     if (pDrvCtrl->attached) /* ensure single invocation */
  347.         return (OK);
  349.     if ((pPool = (RX_FRAME *) malloc ((L_POOL + 1) * RX_FRAME_SIZ)) == NULL)
  350.         return (ERROR);
  352.     for (ix = 0; ix < L_POOL; ix++) /* assign addresses of Rx pool */
  353. pDrvCtrl->lPool [ix] = pPool++;
  355.     pDrvCtrl->lIndex = L_POOL; /* initialize loaner pool index */
  356.     pDrvCtrl->pRxFrame = pPool; /* link in primary buffer */
  357.     pDrvCtrl->nicAddr = pNic; /* save NIC address */
  358.     pDrvCtrl->nicIntVec = ivec; /* save int vector number */
  359.     pDrvCtrl->nextPkt = CURR; /* reset to initial value */
  361.     pDrvCtrl->dmaSem = semMCreate (SEM_Q_PRIORITY);
  363.     /* publish the interface data record */
  365. #ifdef BSD43_DRIVER
  366.     ether_attach (&pDrvCtrl->idr.ac_if, unit, "nicEvb", (FUNCPTR) NULL,
  367.         (FUNCPTR) nicIoctl, (FUNCPTR) nicOutput, (FUNCPTR) nicReset);
  368. #else
  369.     ether_attach (
  370.                  &pDrvCtrl->idr.ac_if, 
  371.                  unit, 
  372.                  "nicEvb", 
  373.                  (FUNCPTR) NULL,
  374.                  (FUNCPTR) nicIoctl, 
  375.                  (FUNCPTR) ether_output, 
  376.                  (FUNCPTR) nicReset
  377.                  );
  378.     pDrvCtrl->idr.ac_if.if_start = (FUNCPTR)nicTxStartup;
  379. #endif
  380.  
  381.     /* connect the interrupt handler */
  383.     (void) intConnect (INUM_TO_IVEC (ivec), nicIntr, 0); 
  384.     intEnable (ivec); 
  386.     nicConfig (unit); /* configure the device */
  388.     /* raise the interface flags */
  390.     pDrvCtrl->idr.ac_if.if_flags |= IFF_UP | IFF_RUNNING | IFF_NOTRAILERS;
  392.     pDrvCtrl->attached = TRUE;
  394.     return (OK);
  395.     }
  397. /*******************************************************************************
  398. *
  399. * nicReset - reset of interface
  400. *
  401. * This routine performs a software reset of the ST-NIC device.
  402. *
  403. * RETURNS: N/A.
  404. *
  405. * NOMANUAL
  406. */
  408. void nicReset
  409.     (
  410.     int unit /* device unit to reset */
  411.     )
  412.     {
  413.     DRV_CTRL * pDrvCtrl = &drvCtrl [unit];
  414.     NIC_DEVICE * pNic = pDrvCtrl->nicAddr;
  416.     pDrvCtrl->idr.ac_if.if_flags = 0;
  417.     nicWriteCr (pNic, STP | ABORT | RPAGE0);
  419.     taskDelay (2); /* wait at least 1.6 mSec */
  420.     }
  422. /*******************************************************************************
  423. *
  424. * nicIntr - The driver's interrupt handler
  425. *
  426. * This function clears the cause of the device interrupt(s) and then acts
  427. * on the individual possible causes.  The primary goal of this routine is to
  428. * minimize the time spent in it.  This is accomplished by deferring processing
  429. * to the netTask via the netJobAdd() function.
  430. *
  431. * Note that in case the receiver overruns, we promptly mark the interface as
  432. * "down" and leave error handling to task-level.   This is in case netTask
  433. * is in the midst of DMA activity, we must allow it to complete.  The receive
  434. * handler will give up when it discovers the interface is down, which will
  435. * then allow netTask to run our OVW handler.  This provides a nice orderly
  436. * error recovery.
  437. *
  438. * RETURNS: N/A.
  439. */
  441. LOCAL void nicIntr
  442.     (
  443.     int unit
  444.     )
  445.     {
  446.     DRV_CTRL * pDrvCtrl = &drvCtrl [unit];
  447.     NIC_DEVICE * pNic = pDrvCtrl->nicAddr; /* NIC registers */
  448.     UINT8 isr; /* copy of ISR */
  449.     UINT8 cr; /* copy of CR */
  451. #ifdef NIC_INSTRUMENT
  452.     nicIntNb++;
  453. #endif
  454.     isr = nicReadReg(pNic, &pNic->Isr, RPAGE0);
  455.     nicWriteReg(pNic, &pNic->Isr, isr, RPAGE0);
  457.     /* handle receiver overrun */
  459.     if  ((isr & OVW) && (pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING)))
  460. {
  461. cr = nicReadReg (pNic, &pNic->Cr, RPAGE0);
  463. nicWriteReg(pNic, &pNic->Imr, 0, RPAGE0); /* disable all interrupts */
  465.         pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
  467. netJobAdd ((FUNCPTR) nicRestart, (int) pDrvCtrl, cr, 0, 0, 0);
  468.         return;
  469. }
  471.     /* handle packet received */
  473.     if  ((isr & PRX) && (pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING)))
  474. netJobAdd ((FUNCPTR) nicHandleInt, (int) pDrvCtrl, 0, 0, 0, 0);
  475.     }
  477. /*******************************************************************************
  478. *
  479. * nicRestart - restart chip after receive ring buffer overflow
  480. *
  481. * This routine is the task-level handler that deals with a receive DMA
  482. * overflow condition.  It gets access to the remote DMA, cleans up NIC
  483. * registers, empties the receive ring buffers, and then resends any
  484. * packet that was in the midst of transmission when the overflow hit.
  485. *
  486. * RETURNS: N/A.
  487. */
  489. LOCAL void nicRestart
  490.     (
  491.     DRV_CTRL * pDrvCtrl,
  492.     UINT8 cr
  493.     )
  494.     {
  495.     NIC_DEVICE * pNic = pDrvCtrl->nicAddr; /* NIC registers */
  496.     BOOL resend = FALSE;
  498. #ifdef NIC_INSTRUMENT
  499.     nicRestartNb++;
  500. #endif
  501.     nicWriteCr (pNic, STP);
  503.     nicResetDelay (); /* wait at least 1.6 mSec */
  505.     if (semTake(pDrvCtrl->dmaSem, 100) == ERROR)
  506. {
  507. #ifdef NIC_DEBUG
  508. if (_func_logMsg != NULL)
  509.     _func_logMsg ("nicRestart: can't obtain dmaSemn", 0, 0, 0, 0, 0,0);
  511. #endif
  512.         semTake (pDrvCtrl->dmaSem, WAIT_FOREVER);
  513.         }
  515.     nicWriteReg (pNic, &pNic->Rbcr0, 0, RPAGE0);
  516.     nicWriteReg (pNic, &pNic->Rbcr1, 0, RPAGE0);
  518.     if ((cr & TXP) && (!(nicReadReg (pNic, &pNic->Isr, RPAGE0) & (TXE | PTX))))
  519. resend = TRUE;
  521.     nicWriteReg (pNic, &pNic->Tcr, MODE1, RPAGE0);
  522.     nicWriteCr (pNic, RPAGE0 | ABORT | STA); /* back to page 0 */
  524.     pDrvCtrl->idr.ac_if.if_flags |= IFF_UP | IFF_RUNNING | IFF_NOTRAILERS;
  526.     while (nicRead (pDrvCtrl))
  527. ;
  529.     nicWriteReg(pNic, &pNic->Isr, OVW, RPAGE0);
  530.     nicWriteReg (pNic, &pNic->Tcr, MODE0, RPAGE0);
  532.     if (resend)
  533.         nicWriteCr (pNic, RPAGE0 | STA | TXP | ABORT);
  535.     semGive(pDrvCtrl->dmaSem);
  537.     nicWriteReg (pNic, &pNic->Imr, PRXE | OVWE, RPAGE0);
  538.     }
  540. /*******************************************************************************
  541. *
  542. * nicHandleInt - deferred receive interrupt handler
  543. *
  544. * This function handles the received frames from the device.  It runs in the
  545. * context of the netTask, which was triggered by a received packet interrupt.
  546. * Actual processing of the packet is done by calling nicRead().
  547. *
  548. * RETURNS: N/A.
  549. */
  551. LOCAL void nicHandleInt
  552.     (
  553.     DRV_CTRL * pDrvCtrl
  554.     )
  555.     {
  556.     /* empties the receive ring buffer of its packets */
  558.     while (nicRead (pDrvCtrl));
  559.     }
  561. /*******************************************************************************
  562. *
  563. * nicRead - read a packet off the interface ring buffer
  564. *
  565. * nicRead copies packets from local memory into an mbuf and hands it to
  566. * the next higher layer (IP or etherInputHook).
  567. *
  568. * RETURNS: TRUE, or FALSE if the packet reception encountered errors.
  569. */
  571. LOCAL BOOL nicRead
  572.     (
  573.     DRV_CTRL * pDrvCtrl
  574.     )
  575.     {
  576.     NIC_DEVICE * pNic = pDrvCtrl->nicAddr;/* NIC registers */
  577.     RX_FRAME * pRx = pDrvCtrl->pRxFrame;/* free Rx buffer */
  578.     MBUF * pMbuf = NULL;
  579.     UINT32 len; /* len of Rx pkt */
  580. #ifdef BSD43_DRIVER
  581.     UINT16 type; /* packet type - saved */
  582. #endif
  583.     int cur;
  585.     if (!(pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING)) ||
  586.         (pDrvCtrl->nextPkt == (cur = nicReadReg (pNic, &pNic->Curr, RPAGE1))))
  587. return (FALSE);
  589.     /*
  590.      * OK, there is work to be done.
  591.      * First we copy the NIC receive status header from the NIC buffer
  592.      * into our local area. This is done so that we can obtain the length
  593.      * of the packet before copying out the rest of it. Note that the length
  594.      * field in the NIC header includes the Ethernet header, the data, and
  595.      * the 4 byte FCS field.
  596.      */
  598.     if (nicPktBufRead (pDrvCtrl, pDrvCtrl->nextPkt << 8, (RX_HDR_SIZ),
  599. (char *) &pRx->rxHdr) == ERROR)
  600.         {
  601. #ifdef NIC_DEBUG
  602. if (_func_logMsg != NULL)
  603.     _func_logMsg("nicRead could not read packet headern",0,0,0,0,0,0);
  604. #endif
  605. return (FALSE);
  606. }
  608.     len = pRx->rxHdr.cntL + (pRx->rxHdr.cntH << 8) - 4 /* FCS */;
  610.     /* valid frame checks */
  612.     /*
  613.      * NOTE: if the packet's receive status byte indicates an error
  614.      * the packet is discarded and the receive page pointers are updated to
  615.      * point to the next packet.
  616.      */
  618. #ifdef NIC_INSTRUMENT
  619.     nicLen = len;
  620.     nicHdrStat = pRx->rxHdr.status;
  621.     nicNextPage = pRx->rxHdr.nextRxPage;
  622.     nicCurrentPage = cur;
  623. #endif
  625.     if ((len < 60) || (len > 1514) || ((pRx->rxHdr.status & ~PHY) != PRX))
  626. {
  627. pDrvCtrl->idr.ac_if.if_ierrors++;
  629. #ifdef NIC_DEBUG
  630. if (_func_logMsg != NULL)
  631.     _func_logMsg ("nicRead receive error: statusHeader=0x%x nextRxPage=%d currentPage=%d len=%d IntNb=%dn",pRx->rxHdr.status, pRx->rxHdr.nextRxPage, cur,len,nicIntNb);
  632. #endif  
  633. if (nicPagePtrUpdate (pDrvCtrl))
  634.     return (TRUE);
  635. else
  636.     return (FALSE);
  637. }
  639.     /* copy Ethernet packet section of the frame */
  641.     if (nicPktBufRead(pDrvCtrl, (pDrvCtrl->nextPkt << 8) + RX_HDR_SIZ, len,
  642. (char *) &pRx->enetHdr) == ERROR)
  643. {
  644. #ifdef NIC_DEBUG
  645. if (_func_logMsg != NULL)
  646.     _func_logMsg ("nicRead: Could not read packet datan",0,0,0,0,0,0);
  647. #endif
  648. if (nicPagePtrUpdate(pDrvCtrl))
  649.     return (TRUE);
  650. else
  651.     return (FALSE);
  652. }
  654.     /* update ring buffer/page pointers */
  656.     if (!nicPagePtrUpdate (pDrvCtrl))
  657. {
  658. return (FALSE);
  659. }
  660.     pDrvCtrl->idr.ac_if.if_ipackets++;
  663.     if ((etherInputHookRtn != NULL) && /* call hook if installed */
  664.         ((* etherInputHookRtn) (&pDrvCtrl->idr.ac_if, (char *) &pRx->enetHdr,
  665.         len)))
  666.         return (TRUE);
  668.     len -= sizeof (ETH_HDR);            /* now equals length of data only */
  669. #ifdef BSD43_DRIVER
  670.     type = pRx->enetHdr.ether_type; /* build_cluster trashes type field */
  671. #endif
  673.     if ((pDrvCtrl->lIndex) && (USE_CLUSTER (len))) /* use loaning ? */
  674. {
  675. pRx->refCnt = 0;
  676.         pMbuf = build_cluster (pRx->data, len, &pDrvCtrl->idr, MC_NIC_EVB,
  677.             &pRx->refCnt, nicLoanFree, (int) pDrvCtrl, (int) pRx, 0);
  678. }
  680.     if (pMbuf != NULL) /* loaning worked ? */
  681.         pDrvCtrl->pRxFrame = pDrvCtrl->lPool [--pDrvCtrl->lIndex];
  682.     else
  683.         {
  684.         pMbuf = copy_to_mbufs (pRx->data, len, 0, &pDrvCtrl->idr.ac_if);
  685.         if (pMbuf == NULL)
  686.             {
  687.             pDrvCtrl->idr.ac_if.if_ierrors++;
  688.             return (TRUE);
  689.             }
  690.         }
  692. #ifdef BSD43_DRIVER
  693.     do_protocol_with_type (type, pMbuf, &pDrvCtrl->idr, len); /* up to IP */
  694. #else
  695.     do_protocol (&pRx->enetHdr, pMbuf, &pDrvCtrl->idr, len);
  696. #endif
  698.     return (TRUE);
  699.     }
  701. #ifdef BSD43_DRIVER
  702. /*******************************************************************************
  703. *
  704. * nicOutput - the driver's output routine
  705. *
  706. * RETURNS: N/A.
  707. */
  709. LOCAL int nicOutput
  710.     (
  711.     IDR  * pIDR,
  712.     MBUF * pMbuf,
  713.     SOCK * pDest
  714.     )
  715.     {
  716.     return ether_output ((IFNET *) pIDR, pMbuf, pDest, (FUNCPTR) nicTxStartup,
  717. pIDR);
  718.     }
  719. #endif
  721. /*******************************************************************************
  722. *
  723. * nicTxStartup - the driver's actual output routine
  724. *
  725. * This routine accepts outgoing packets from the if_snd queue, and then 
  726. * gains exclusive access to the DMA (through a mutex semaphore),
  727. * then calls nicTransmit() to send the packet out onto the interface.
  728. *
  729. * RETURNS: OK, or ERROR if the packet could not be transmitted.
  730. */
  732. #ifdef BSD43_DRIVER
  733. LOCAL STATUS nicTxStartup
  734.     (
  735.     int unit
  736.     )
  737.     {
  738.     DRV_CTRL *  pDrvCtrl = &drvCtrl [unit];
  739. #else
  740. LOCAL STATUS nicTxStartup
  741.     (
  742.     DRV_CTRL *  pDrvCtrl
  743.     )
  744.     {
  745. #endif
  746.     MBUF * pMbuf;
  747.     MBUF * mbuf;
  748.     int status = OK;
  749.     int length = 0;
  751.     while (pDrvCtrl->idr.ac_if.if_snd.ifq_head)
  752. {
  753.         IF_DEQUEUE (&pDrvCtrl->idr.ac_if.if_snd, pMbuf);/* dequeue a packet */
  755.         if ((pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING)) !=
  756.             (IFF_UP | IFF_RUNNING))
  757.             return (ERROR);
  759.         if (semTake (pDrvCtrl->dmaSem, 100) == ERROR) /* get DMA access */
  760.             {
  761.     if (_func_logMsg != NULL)
  762. _func_logMsg("nicTxStartup: can't obtain dmaSemn",0,0,0,0,0,0);
  763.             semTake (pDrvCtrl->dmaSem, WAIT_FOREVER);
  764.             }
  766. for (mbuf = pMbuf; mbuf != NULL; mbuf = mbuf->m_next)
  767.     length += mbuf->m_len; /* find length of chain */
  769.         if (length == 0)
  770.     {
  771.     m_freem (pMbuf); /* empty mbuf chain */
  772.     semGive (pDrvCtrl->dmaSem);
  773.     continue;
  774.     }
  776. #ifndef BSD43_DRIVER    /* BSD 4.4 ether_output() doesn't bump statistic */
  777.         pDrvCtrl->idr.ac_if.if_opackets++;
  778. #endif
  779. #ifdef NIC_INSTRUMENT
  780. nicTxNb++;
  781. #endif
  783. /* send packet out over interface */
  785.         if ( (status = nicTransmit (pDrvCtrl, pMbuf, length, TRUE)) == ERROR)
  786.             {
  787.             pDrvCtrl->idr.ac_if.if_opackets--;
  788.             pDrvCtrl->idr.ac_if.if_oerrors++;
  789.             }
  791.         semGive (pDrvCtrl->dmaSem);
  792. }
  794.     return status;
  795.     }
  797. /*******************************************************************************
  798. *
  799. * nicIoctl - the driver's I/O control routine
  800. *
  801. * Perform device-specific commands.
  802. *
  803. * RETURNS: 0, or EINVAL if the command 'cmd' is not supported.
  804. */
  806. LOCAL int nicIoctl
  807.     (
  808.     IDR * pIDR,
  809.     int cmd, /* command to execute */
  810.     caddr_t data /* command-specific data */
  811.     )
  812.     {
  813.     int error = 0;
  814.     int s = splimp ();
  816.     switch (cmd)
  817. {
  818.         case SIOCSIFADDR:
  819.             ((struct arpcom *)pIDR)->ac_ipaddr = IA_SIN (data)->sin_addr;
  820.             arpwhohas (pIDR, &IA_SIN (data)->sin_addr);
  821.             break;
  823.         case SIOCSIFFLAGS: /* no driver-dependent flags */
  824.             break;
  826.         default:
  827.             error = EINVAL;
  828. }
  830.     splx (s);
  831.     return (error);
  832.     }
  834. /*******************************************************************************
  835. *
  836. * nicEnetAddrGet - get the Ethernet address.
  837. *
  838. * Get ethernet address from the BSP.
  839. *
  840. * RETURNS: N/A.
  841. */
  843. LOCAL void nicEnetAddrGet
  844.     (
  845.     int unit
  846.     )
  847.     {
  848.     DRV_CTRL * pDrvCtrl = & drvCtrl [unit];
  849.     UINT8 enetAdrs[6];
  850.     UINT8 count;
  852.     sysEnetAddrGet (unit, enetAdrs);
  853.     for (count=0; count<6; count++)
  854.         pDrvCtrl->idr.ac_enaddr[count] = enetAdrs[5-count];
  855.         
  856.     }
  858. /*******************************************************************************
  859. *
  860. * nicConfig - configure the NIC chip and program address
  861. *
  862. * This routine follows the algorythm in the ST-NIC manual for enabling
  863. * a NIC device on an active network.  Essentially, this routine initializes
  864. * the NIC device.
  865. *
  866. * RETURNS: N/A.
  867. */
  869. LOCAL void nicConfig
  870.     (
  871.     int unit
  872.     )
  873.     {
  874.     DRV_CTRL * pDrvCtrl = &drvCtrl [unit];
  875.     NIC_DEVICE * pNic= pDrvCtrl->nicAddr;
  876.     
  877.     nicWriteCr (pNic, RPAGE0 | STP | ABORT);
  879.     nicResetDelay ();
  881.     nicWriteReg (pNic, &pNic->Dcr, NOTLS | FIFO8, RPAGE0);
  883.     /* clear remote DMA byte count registers */
  885.     nicWriteReg (pNic, &pNic->Rbcr0, 0, RPAGE0);             
  886.     nicWriteReg (pNic, &pNic->Rbcr1, 0, RPAGE0);
  888.     /* accept broadcast, but not runt or multicast */
  890.     nicWriteReg (pNic, &pNic->Rcr, AB, RPAGE0);         
  891.     nicWriteReg (pNic, &pNic->Tcr, MODE1, RPAGE0); /* int loopback mode */
  893.     nicWriteReg (pNic, &pNic->Pstart, PSTART, RPAGE0);
  894.     nicWriteReg (pNic, &pNic->Pstop, PSTOP, RPAGE0);
  895.     nicWriteReg (pNic, &pNic->Bnry, BNRY, RPAGE0);
  897.     nicWriteReg (pNic, &pNic->Isr, 0xff, RPAGE0); /* clr pending ints */
  898.     nicWriteReg (pNic, &pNic->Imr, PRXE | OVWE, RPAGE0); /* enable int */
  900.     nicEnetAddrGet (unit); /* get enet address */
  902.     /* set up page 1 registers */
  904.     nicWriteReg (pNic, &pNic->Par0, pDrvCtrl->idr.ac_enaddr [0], RPAGE1);
  905.     nicWriteReg (pNic, &pNic->Par1, pDrvCtrl->idr.ac_enaddr [1], RPAGE1);
  906.     nicWriteReg (pNic, &pNic->Par2, pDrvCtrl->idr.ac_enaddr [2], RPAGE1);
  907.     nicWriteReg (pNic, &pNic->Par3, pDrvCtrl->idr.ac_enaddr [3], RPAGE1);
  908.     nicWriteReg (pNic, &pNic->Par4, pDrvCtrl->idr.ac_enaddr [4], RPAGE1);
  909.     nicWriteReg (pNic, &pNic->Par5, pDrvCtrl->idr.ac_enaddr [5], RPAGE1);
  910.     nicWriteReg (pNic, &pNic->nic_pg1.mar0, 0xff, RPAGE1);
  911.     nicWriteReg (pNic, &pNic->nic_pg1.mar1, 0xff, RPAGE1);
  912.     nicWriteReg (pNic, &pNic->nic_pg1.mar2, 0xff, RPAGE1);
  913.     nicWriteReg (pNic, &pNic->nic_pg1.mar3, 0xff, RPAGE1);
  914.     nicWriteReg (pNic, &pNic->nic_pg1.mar4, 0xff, RPAGE1);
  915.     nicWriteReg (pNic, &pNic->nic_pg1.mar5, 0xff, RPAGE1);
  916.     nicWriteReg (pNic, &pNic->nic_pg1.mar6, 0xff, RPAGE1);
  917.     nicWriteReg (pNic, &pNic->nic_pg1.mar7, 0xff, RPAGE1);
  918.     nicWriteReg (pNic, &pNic->Curr, CURR, RPAGE1);
  920.     nicWriteCr (pNic, RPAGE0 | ABORT | STA); /* back to page 0 */
  921.     nicWriteReg (pNic, &pNic->Tcr, MODE0, RPAGE0); /* Tx normal mode */
  922.     }
  924. /*******************************************************************************
  925. *
  926. * nicPktBufRead - read data from the NIC receive ring buffer
  927. *
  928. * This routine gets exclusive access to the remote DMA, and calls
  929. * nicReceive() to get data from the NIC's receive ring buffer.
  930. *
  931. * RETURNS: OK, or ERROR if obtaining the requested bytes encountered an error.
  932. */
  934. LOCAL STATUS nicPktBufRead
  935.     (
  936.     DRV_CTRL * pDrvCtrl,
  937.     UINT32 nicBufAddr,
  938.     UINT32 len,
  939.     char * pData
  940.     )
  941.     {
  942.     STATUS status = OK;
  944.     /* avoid starting DMA if device is down to to fatal error */
  946.     if ((pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING)) !=
  947.         (IFF_UP | IFF_RUNNING))
  948.         return (ERROR);
  950.     if (semTake (pDrvCtrl->dmaSem, 100) == ERROR) /* get DMA */
  951. {
  952. if (_func_logMsg != NULL)
  953.     _func_logMsg ("nicPktBufRead: can't obtain dmaSemn",0,0,0,0,0,0);
  954.         semTake (pDrvCtrl->dmaSem, WAIT_FOREVER);
  955. }
  957.     status = nicReceive (pDrvCtrl, nicBufAddr, pData, len); /* goto ring */
  958.     semGive(pDrvCtrl->dmaSem);
  960.     return (status);
  961.     }
  963. /*******************************************************************************
  964. *
  965. * nicWriteCr - write to the NIC command register
  966. *
  967. * RETURNS: N/A.
  968. */
  970. LOCAL void nicWriteCr
  971.     (
  972.     NIC_DEVICE *pNic,
  973.     UINT8 value
  974.     )
  975.     {
  976.     int level = intLock ();
  978.     do {
  979.         pNic->Cr = value;
  980.         } while (!((*(volatile UINT8 *)NIC_DMA) & ACC_MASK));
  982.     intUnlock (level);
  983.     }
  985. /*******************************************************************************
  986. *
  987. * nicWriteReg - write to a NIC register
  988. *
  989. * RETURNS: N/A.
  990. */
  992. LOCAL void nicWriteReg 
  993.     (
  994.     NIC_DEVICE * pNic,
  995.     volatile UINT8 * pReg,
  996.     UINT8 value,
  997.     UINT8 page
  998.     )
  999.     {
  1000.     volatile UINT8 * nicDma = (volatile UINT8 *) NIC_DMA;
  1001.     UINT8 cr;
  1002.     int level = intLock ();
  1004.     do {
  1005. cr = pNic->Cr;
  1006. } while (!((*nicDma) & ACC_MASK));
  1008.     if ((cr & PBMASK) != page)
  1009. do {
  1010.     pNic->Cr = (cr & 0x3f) | page;
  1011.     } while (!((*nicDma) & ACC_MASK));
  1013.     do {
  1014. *pReg = value;
  1015. } while (!((*nicDma) & ACC_MASK));
  1017.     intUnlock (level);
  1018.     }
  1020. /*******************************************************************************
  1021. *
  1022. * nicReadReg - read from a NIC register
  1023. *
  1024. * RETURNS: the register value.
  1025. */
  1027. LOCAL UINT8 nicReadReg 
  1028.     (
  1029.     NIC_DEVICE * pNic,
  1030.     volatile UINT8 * pReg,
  1031.     char page
  1032.     )
  1033.     {
  1034.     volatile UINT8 * nicDma = (volatile UINT8 *) NIC_DMA;
  1035.     UINT8 cr;
  1036.     int level = intLock ();
  1038.     do {
  1039. cr = pNic->Cr;
  1040. } while (!((*nicDma) & ACC_MASK));
  1042.     if ((cr & PBMASK) != page)
  1043. do {
  1044.     pNic->Cr = (cr & 0x3f) | page;
  1045.     } while (!((*nicDma) & ACC_MASK));
  1047.     do {
  1048. cr = *pReg;
  1049. } while (!((*nicDma) & ACC_MASK));
  1051.     intUnlock (level);
  1052.     return (cr);
  1053.     }
  1055. /*******************************************************************************
  1056. *
  1057. * nicWritePort - write to the DMA port
  1058. *
  1059. * RETURNS: N/A.
  1060. */
  1062. LOCAL void nicWritePort
  1063.     (
  1064.     UINT8 value
  1065.     )
  1066.     {
  1067. #ifndef NIC_FASTER
  1068.     int level = intLock ();
  1069. #endif
  1071.     do 
  1072. {
  1073. *(volatile char *) NIC_PORT = value;
  1074.         }
  1075.     while (!((*(volatile UINT8 *) NIC_DMA) & ACC_MASK));
  1076. #ifndef NIC_FASTER
  1077.     intUnlock (level);
  1078. #endif
  1079.     }
  1081. /*******************************************************************************
  1082. *
  1083. * nicReadPort - read from the DMA port
  1084. *
  1085. * RETURNS: the DMA port value.
  1086. */
  1088. LOCAL UINT8 nicReadPort (void)
  1089.     {
  1090.     UINT8 value;
  1091. #ifndef NIC_FASTER
  1092.     int level = intLock ();
  1093. #endif
  1095.     do
  1096. {
  1097. value = *(volatile UINT8 *) NIC_PORT;
  1098.         }
  1099.     while (!((*(volatile UINT8 *) NIC_DMA) & ACC_MASK));
  1101. #ifndef NIC_FASTER
  1102.     intUnlock (level);
  1103. #endif
  1104.     return (value);
  1105.     }
  1107. /*******************************************************************************
  1108. *
  1109. * nicTransmit - send data over the NIC network interface
  1110. *
  1111. * This routine transfers data to the NIC device via the remote DMA, and
  1112. * then signal for a transmission.
  1113. *
  1114. * RETURNS: OK, or ERROR if the transmitter signalled an error.
  1115. */
  1117. LOCAL STATUS nicTransmit
  1118.     (
  1119.     DRV_CTRL * pDrvCtrl,
  1120.     MBUF * pMbuf,
  1121.     int len,
  1122.     BOOL waitFlag
  1123.     )
  1124.     {
  1125.     NIC_DEVICE * pNic = pDrvCtrl->nicAddr;
  1126.     UINT8 cr;
  1127.     UINT8 isr;
  1128.     UINT8 * buf;
  1129.     int status = OK;
  1130.     int count;
  1131.     int ix;
  1132.     int tranxLen = max (len, MINPKTSIZE);
  1134. #ifdef NIC_FASTER
  1135.     nicWriteReg(pNic, &pNic->Imr, 0, RPAGE0);   /* disable all interrupts */
  1136. #endif
  1138.     nicWriteReg (pNic, &pNic->Rbcr0, 0x10, RPAGE0);
  1139.     nicWriteCr (pNic, RREAD);
  1141.     nicWriteReg (pNic, &pNic->Rbcr0, (tranxLen & 0x00ff), RPAGE0);
  1142.     nicWriteReg (pNic, &pNic->Rbcr1, (tranxLen & 0xff00) >> 8, RPAGE0);
  1143.     nicWriteReg (pNic, &pNic->Rsar0, 0x00, RPAGE0);
  1144.     nicWriteReg (pNic, &pNic->Rsar1, 0x00, RPAGE0);
  1145.     nicWriteCr (pNic, RWRITE);
  1146.     count = 0;
  1147.     for (; pMbuf != NULL; pMbuf = m_free (pMbuf))
  1148. for (ix = 0, buf = mtod (pMbuf, UINT8 *); ix < pMbuf->m_len; ix++)
  1149.     { 
  1150.     count++;
  1151.     nicWritePort (*buf++);
  1152.     }
  1154.     for (; count < tranxLen; count ++) /* pad out if too short */
  1155. nicWritePort (0);
  1157.     nicWriteReg (pNic, &pNic->Tpsr, 0x00, RPAGE0);
  1158.     nicWriteReg (pNic, &pNic->Tbcr0, (tranxLen & 0x000000ff), RPAGE0);
  1159.     nicWriteReg (pNic, &pNic->Tbcr1, ((tranxLen & 0x0000ff00) >> 8), RPAGE0);
  1161.     cr = nicReadReg (pNic, &pNic->Cr, RPAGE0);
  1162.     nicWriteReg(pNic, &pNic->Isr, (PTX | TXE), RPAGE0);
  1163.     nicWriteCr (pNic, TXP | (cr & (RWRITE | RREAD))); /* start Tx */
  1165.     count = 0;
  1166.     if (waitFlag) /* wait for Tx to end ? */
  1167. {
  1168.         while (count++ < TRANS_TIMEOUT) /* only poll a few times */
  1169.     {
  1170.             isr = nicReadReg (pNic, &pNic->Isr, RPAGE0);
  1172.     if (isr & TXE) /* error encountered */
  1173.         {
  1174.                 status = ERROR;
  1175.         break;
  1176.         }
  1178.     if (isr & PTX) /* Tx done */
  1179.         break;
  1180.             }
  1182.         if (count >= TRANS_TIMEOUT) /* error ? */
  1183.     {
  1184.             status = ERROR;
  1185. #ifdef NIC_INSTRUMENT
  1186.     nicTxTimeout++;
  1187. #endif
  1188. #ifdef NIC_DEBUG
  1189.     if (_func_logMsg != NULL)
  1190. _func_logMsg("nicTransmit TRANS_TIMEOUT %dn",
  1191.      nicTxTimeout,0,0,0,0,0);
  1192. #endif
  1193.     }
  1194.         }
  1196. #ifdef NIC_FASTER
  1197.     nicWriteReg(pNic, &pNic->Imr, PRXE | OVWE, RPAGE0); /* re-enable intr. */
  1198. #endif
  1199.     return (status);
  1200.     }
  1202. /*******************************************************************************
  1203. *
  1204. * nicReceive - receive data from the NIC network interface
  1205. *
  1206. * This routine transfers data from the NIC device ring buffers via the
  1207. * remote DMA.
  1208. *
  1209. * RETURNS: OK, always.
  1210. */
  1212. LOCAL STATUS nicReceive 
  1213.     (
  1214.     DRV_CTRL * pDrvCtrl,
  1215.     UINT32 nicBufAddr, 
  1216.     char * pData, 
  1217.     int len
  1218.     )
  1219.     {
  1220.     NIC_DEVICE * pNic = pDrvCtrl->nicAddr;
  1221.     int residual;
  1222.     int dmaCnt;
  1223.     int ix;
  1225. #ifdef NIC_FASTER
  1226.     nicWriteReg(pNic, &pNic->Imr, 0, RPAGE0); /* disable all interrupts */
  1227. #endif
  1228.     if ((nicBufAddr + len) < (PSTOP * PACKET_SIZE))
  1229. {
  1230. nicWriteReg (pNic, &pNic->Rbcr0, (len & 0xff), RPAGE0);
  1231. nicWriteReg (pNic, &pNic->Rbcr1, ((len & 0xff00) >> 8), RPAGE0);
  1232. nicWriteReg (pNic, &pNic->Rsar0, (nicBufAddr & 0xff), RPAGE0);
  1233. nicWriteReg (pNic, &pNic->Rsar1, (((nicBufAddr & 0xff00)>> 8)), RPAGE0);
  1234. nicWriteCr (pNic, RREAD);
  1236. for (ix = 0; ix < len; ix ++)
  1237.     *pData++ = nicReadPort ();
  1238. }
  1239.     else
  1240. {
  1241. residual = (nicBufAddr + len) - (PSTOP * PACKET_SIZE);
  1242. dmaCnt = len - residual;
  1244. nicWriteReg (pNic, &pNic->Rbcr0, (dmaCnt & 0xff), RPAGE0);
  1245. nicWriteReg (pNic, &pNic->Rbcr1, ((dmaCnt & 0xff00) >> 8), RPAGE0);
  1246. nicWriteReg (pNic, &pNic->Rsar0, (nicBufAddr & 0xff), RPAGE0);
  1247. nicWriteReg (pNic, &pNic->Rsar1, (((nicBufAddr & 0xff00)>> 8)), RPAGE0);
  1248. nicWriteCr (pNic, RREAD);
  1250. for (ix = 0; ix < dmaCnt; ix++)
  1251.     *pData++ = nicReadPort ();
  1253. nicWriteReg (pNic, &pNic->Rbcr0, (residual & 0xff), RPAGE0);
  1254. nicWriteReg (pNic, &pNic->Rbcr1, ((residual & 0xff00) >> 8), RPAGE0);
  1255. nicWriteReg (pNic, &pNic->Rsar0, 0x00, RPAGE0);
  1256. nicWriteReg (pNic, &pNic->Rsar1, PSTART, RPAGE0);
  1257. nicWriteCr (pNic, RREAD);
  1259. for (ix = 0; ix < residual; ix++)
  1260.     *pData++ = nicReadPort ();
  1261. }
  1263. #ifdef NIC_FASTER
  1264.     nicWriteReg(pNic, &pNic->Imr, PRXE | OVWE, RPAGE0); /* re-enable intr. */
  1265. #endif
  1266.     return (OK);
  1267.     } 
  1269. /*******************************************************************************
  1270. *
  1271. * nicLoanFree - return a buffer to the Rx loaner pool
  1272. *
  1273. * RETURNS: N/A.
  1274. */
  1276. LOCAL void nicLoanFree
  1277.     (
  1278.     DRV_CTRL * pDrvCtrl,
  1279.     RX_FRAME * pRx
  1280.     )
  1281.     {
  1282.     pDrvCtrl->lPool [pDrvCtrl->lIndex++] = pRx;
  1283.     }
  1285. /*******************************************************************************
  1286. *
  1287. * nicPagePtrUpdate - updates receive buffer/page pointers
  1288. *
  1289. * This routine updates the receive buffer/page pointer and the receive
  1290. * boundary register (BNRY). The chip is re-initialized if the receive next 
  1291. * packet pointer recorded in the current packet header is out of range.
  1292. *
  1293. * RETURNS: TRUE, or FALSE if next packet pointer is out of range.
  1294. */
  1295.  
  1296. LOCAL BOOL nicPagePtrUpdate
  1297.     (
  1298.     DRV_CTRL *          pDrvCtrl
  1299.     )
  1300.     {
  1301.     RX_FRAME *          pRx = pDrvCtrl->pRxFrame;/* free Rx buffer */
  1302.     NIC_DEVICE *        pNic= pDrvCtrl->nicAddr;
  1304.     /* update ring buffer/page pointers */
  1306.     if ((pRx->rxHdr.nextRxPage < PSTART)||(pRx->rxHdr.nextRxPage >= PSTOP))
  1307.         {
  1308. #ifdef NIC_DEBUG
  1309.         if (_func_logMsg != NULL)
  1310.     _func_logMsg ("nicPagePtrUpdate: statusHeader=0x%x nextRxPage=%d IntNb=%dn",pRx->rxHdr.status, pRx->rxHdr.nextRxPage, nicIntNb, 0,0);
  1311. #endif
  1312. #ifdef NIC_INSTRUMENT
  1313.      nicInitNb++;
  1314. #endif
  1315.         pDrvCtrl->idr.ac_if.if_ierrors++;
  1317. /* restart the chip - we should never end up here - */
  1319.      nicConfig (0);
  1320.      pDrvCtrl->nextPkt = CURR;
  1321.      pDrvCtrl->idr.ac_if.if_flags |= IFF_UP | IFF_RUNNING | IFF_NOTRAILERS;
  1323.         return (FALSE);
  1324.         }
  1326.     /* updates the Boundary pointer register (BNRY) */
  1328.     if ((pDrvCtrl->nextPkt = pRx->rxHdr.nextRxPage) == PSTART)
  1329.         nicWriteReg (pNic, &pNic->Bnry, PSTOP - 1, RPAGE0);
  1330.     else
  1331.         nicWriteReg (pNic, &pNic->Bnry, pDrvCtrl->nextPkt - 1, RPAGE0);
  1333.     return (TRUE);
  1334.     }
  1336. /*******************************************************************************
  1337. *
  1338. * nicResetDelay - performs the delay required before resetting the chip 
  1339. *
  1340. * This routine performs a 1.6 ms delay for PowerPC architecture if 
  1341. * using the internal PPC time base (the number of time base increment to
  1342. * count for 1.6 msec is defined by the value nicRestartDelay which must 
  1343. * be set in the BSP), or waits for one system clock tick otherwise.
  1344. *
  1345. * RETURNS: N/A.
  1346. */
  1347.  
  1348. LOCAL void nicResetDelay (void)
  1349.     {
  1350. #ifdef  NIC_USE_PPCTIMEBASE
  1351.     UINT32 tbu1, tbu2;
  1352.     UINT32 tbl1, tbl2;
  1353. #endif
  1355. #ifdef  NIC_USE_PPCTIMEBASE
  1356.     vxTimeBaseGet (&tbu1, &tbl1);
  1357.     while (1)  {
  1358.         vxTimeBaseGet (&tbu2, &tbl2);
  1359.         if ((tbu2-tbu1) != 0)
  1360.             vxTimeBaseGet (&tbu1, &tbl1);
  1361.         else
  1362.     if ((tbl2 - tbl1) > nicRestartDelay)
  1363.              break;
  1364.         }
  1365. #else
  1366.     taskDelay (1);                      /* wait at least 1.6 mSec */
  1367. #endif
  1368.     }