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

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

VxWorks

开发平台：

C/C++

if_eidve.c：源码内容
  1. /* if_eidve.c - Intel 82596 Ethernet network interface driver for DVE-SH7XXX */
  3. /* Copyright 1989-1997 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 03k,03mar99,jmb  Implement 2-byte alignment shift for RFD's, similar to
  10.                  offset shift in ei82596End.c
  11. 03j,15dec98,jmb  Bring driver up to BSD 4.4 for SENS compatibility.
  12. 03i,24apr97,hk   added DVE-SH7XXX support.
  13. 03h,05feb97,dat  fixed wdog reset action to use netJobAdd(). SPR 7771
  14. 03g,13aug96,dat  fixed wdog timer restart. SPR 6958
  15. 03g,12nov94,tmk  removed some IMPORTed function decs and included unixLib.h
  16. 03h,10oct94,caf  suppress buffer loaning for MIPS targets due to
  17.  problem with misaligned accesses.
  18. 03g,14oct93,wmd  Added initialization of pointer pDrvCtrl in eiWatchDog(),
  19.  SPR #2567.
  20. 03f,30sep93,wmd  Added changes to include timeout check of the receiver 
  21.  as done in the 5.0.6 release. Recreated eiInit() to allow
  22.  resetting the 596 if it locks up.
  23. 03e,11aug93,jmm  Changed ioctl.h and socket.h to sys/ioctl.h and sys/socket.h
  24. 03d,19feb93,jdi  documentation cleanup.
  25. 03c,15jan93,wmd  added setting of errno to S_ioslib_INVALID_ETHERNET_ADDRESS.
  26. 03b,11dec92,rfs  Removed dummy eiChipReset(), no longer needed for TP41.
  27. 03a,05oct92,rfs  Added documentation.
  28. 02z,02oct92,rfs  Made multiple attach calls per unit return OK, not ERROR.
  29. 02y,01oct92,rfs  Added 16 byte page alignment for SCP.
  30. 02x,28sep92,rfs  Modified the eiAction() routine to clear all events.  This
  31.                  makes the diagnostics pass, for some undocumented reason.
  32. 02w,09sep92,gae  documentation tweaks.
  33. 02v,11aug92,rfs  Slight change to memory carving.  Also fixed receive bug
  34.                  that was due to device manual incorrectly describing bit 7
  35.                  of config byte 10 and added error checks to RFDs.  Changed
  36.                  the device startup routine.
  37. 02u,26aug92,kdl  moved internal notes to file header (were just #ifdef'd out).
  38. 02t,19aug92,smb  changed systime.h to sys/times.h
  39. 02s,31jul92,dave Changed to new cacheLib.
  40. 02r,28jul92,rfs  Adapted to latest cache coherency model.
  41.                  Renamed driver control structure and moved it to bss.
  42.                  Combined the init() routine with the attach() routine and
  43.                  made attach() reject multiple invocations.  Rewrote the
  44.                  ioctl() routine to do the right stuff.  Reworked the action
  45.                  command routine and the primary command routine.  Other misc.
  46. 02q,16jul92,rfs  Moved driver specific items from header file to here,
  47.                  where they belong.
  48. 02p,16jul92,rfs  Moved internal comments to end of file, where they belong.
  49. 02o,03jul92,jwt  converted cacheClearEntry() calls to cacheClear() for 5.1.
  50. 02n,26jun92,rrr  make eiBusSnoop global again (needed by bsps)
  51. 02m,25jun92,rfs  backed out last mod; the manual is incorrect about the
  52.                  state of the bit that configures CRC inclusion
  53. 02l,25jun92,rfs  bug fix, changed a receive config parm that selects whether
  54.                  the CRC is included in the buffer
  55. 02k,23jun92,ajm  made eiChipReset global for tp41 BSP
  56. 02j,08jun92,ajm  modified so eiattach is only external function
  57.                  got rid of MEM_ROUND_UP macro now pulled in with vxWorks.h
  58.                  got rid of many ansi complaints
  59. 02i,26may92,rrr  the tree shuffle
  60.                  -changed includes to have absolute path from h/
  61. 02h,22feb92,wmd  added conditional compiles for 040, ansi fixes.
  62. 02g,07jan92,shl  made driver cache safe. added eiBusSnoop(). eliminated some
  63.                  ANSI warnings.
  64. 02f,12nov91,wmd  Added fix, courtesy of jrb-Intel, which added a watchdog to
  65.                  timeout any stalls due to hardware lockup and resets the
  66.                  82596.
  67. 02e,25oct91,rfs  Changed eiChipReset() to not depend on valid *es, and
  68.                  made it global for TP41 usage. Also eliminated ANSI
  69.                  warnings.
  70. 02d,04oct91,rrr  passed through the ansification filter
  71.                  -changed functions to ansi style
  72.                  -changed includes to have absolute path from h/
  73.                  -changed VOID to void
  74.                  -changed copyright notice
  75. 02c,15sep91,rfs  Bug fix. Eliminated lock condition when output queue full
  76.                  and out of TFDs. Added major comment to eiTxStartup. Also,
  77.                  major changes to eiChipReset() to make more robust. All
  78.                  instances of intLock()/intUnlock() changed to
  79.                  sys596IntDisable()/sys596IntEnable respectively. Statistic
  80.                  counters now being used, which required moderate changes to
  81.                  the transmit side design. More comments added.
  82. 02b,21aug91,rfs  changed method of obtaining Ethernet address.
  83. 02a,22jul91,jcf  completely rewritten to utilize simplified mode,
  84.             rfs  added big endian support, reworked buffer loaning.
  85. 01h,01may91,elh  fixed ethernet addressing problem, upgraded to 5.0,
  86.                  added buffer loanouts, fixed ifAddrSet bug by disabling
  87.                  interrupts in eiHardReset.
  88. 01g,28apr91,del  added #define of ETHER_HEADER_SIZE as workaround for
  89.                  gnu960 pading of struct ether_header.
  90. 01f,05jan91,gae  added global eiSCPSysConfig for board specific SCP parameters.
  91.                  moved CDELAY here from if_ei.h and renamed eichkcca.
  92. 01e,03jan91,gae  more cleanup and merged with Intel's fixes.
  93.                  Ethernet address (eiEnetAddr) is set in sysHwInit.
  94.                  cleaned up error printing & no carrier message always printed.
  95.                  changed printf's to printErr's (logMsg if at int level).
  96.                  made most routines local -- not available outside this module.
  97. 01d,31dec90,gae  removed 68K stuff.
  98. 01c,14dec90,elh  more cleanup.
  99. 01b,12dec90,elh  fixed buffer problems, cleaned up, added etherhooks.
  100. 01a,06feb90,djk  written
  101. */
  103. /*
  104. This module implements the Intel 82596 Ethernet network interface driver.
  106. This driver is designed to be moderately generic, operating unmodified
  107. across the range of architectures and targets supported by VxWorks.  
  108. To achieve this, this driver must be given several
  109. target-specific parameters, and some external support routines must be
  110. provided.  These parameters, and the mechanisms used to communicate them to the
  111. driver, are detailed below.
  113. This driver can run with the device configured in either
  114. big-endian or little-endian modes.  Error recovery code has been added to
  115. deal with some of the known errata in the A0 version of the device.  This
  116. driver supports up to four individual units per CPU.
  118. BOARD LAYOUT
  119. This device is on-board.  No jumpering diagram is necessary.
  121. EXTERNAL INTERFACE
  122. This driver provides the standard external interface with the following
  123. exceptions.  All initialization is performed within the attach routine;
  124. there is no separate initialization routine.  Therefore, in the global interface
  125. structure, the function pointer to the initialization routine is NULL.
  127. The only user-callable routine is eiattach(), which publishes the `ei'
  128. interface and initializes the driver and device.
  130. TARGET-SPECIFIC PARAMETERS
  131. .iP "the <sysbus> value"
  132. This parameter is passed to the driver by eiattach().
  134. The Intel 82596 requires this parameter during initialization.  This
  135. parameter tells the device about the system bus, hence the name "sysbus."
  136. To determine the correct value for a target, refer to the document
  137. .I "Intel 32-bit Local Area Network (LAN) Component User's Manual."
  138. .iP "interrupt vector"
  139. This parameter is passed to the driver by eiattach().
  141. The Intel 82596 generates hardware interrupts for various events within
  142. the device; thus it contains an interrupt handler routine.
  143. This driver calls intConnect() to connect its interrupt handler to the 
  144. interrupt vector generated as a result of the 82596 interrupt.
  145. .iP "shared memory address"
  146. This parameter is passed to the driver by eiattach().
  148. The Intel 82596 device is a DMA type device and typically shares
  149. access to some region of memory with the CPU.  This driver is designed
  150. for systems that directly share memory between the CPU and the 82596.
  152. This parameter can be used to specify an explicit memory region for use
  153. by the 82596.  This should be done on targets that restrict the 82596
  154. to a particular memory region.  The constant NONE can be used to indicate
  155. that there are no memory limitations, in which case, the driver 
  156. attempts to allocate the shared memory from the system space.
  157. .iP "number of Receive and Transmit Frame Descriptors"
  158. These parameters are passed to the driver by eiattach().
  160. The Intel 82596 accesses frame descriptors in memory for each frame
  161. transmitted or received.  The number of frame descriptors 
  162. at run-time can be configured using these parameters.
  163. .iP "Ethernet address"
  164. This parameter is obtained by a call to an external support routine.
  166. During initialization, the driver needs to know the Ethernet address for
  167. the Intel 82596 device.  The driver calls the external support routine,
  168. sysEnetAddrGet(), to obtain the Ethernet address.  For a description of
  169. sysEnetAddrGet(), see "External Support Requirements" below.
  170. .LP
  172. EXTERNAL SUPPORT REQUIREMENTS
  173. This driver requires seven external support functions:
  174. .iP "STATUS sysEnetAddrGet (int unit, char *pCopy)" "" 9 -1
  175. This routine provides the six-byte Ethernet address
  176. used by <unit>.  It must copy the six-byte address
  177. to the space provided by <pCopy>.  This routine 
  178. returns OK, or ERROR if it fails.  The driver calls this 
  179. routine, once per unit, using eiattach().
  180. .iP "STATUS sys596Init (int unit)"
  181. This routine performs any target-specific initialization
  182. required before the 82596 is initialized.  Typically, it is empty.  
  183. This routine must return OK, or ERROR if it fails.
  184. The driver calls this routine, once per unit, using eiattach().
  185. .iP "void sys596Port (int unit, int cmd, UINT32 addr)"
  186. This routine provides access to the special port
  187. function of the 82596.  It delivers the command and
  188. address arguments to the port of the specified unit.
  189. The driver calls this routine primarily during
  190. initialization, but may also call it during error
  191. recovery procedures.
  192. .iP "void sys596ChanAtn (int unit)"
  193. This routine provides the channel attention signal to
  194. the 82596, for the specified <unit>.  The driver calls
  195. this routine frequently throughout all phases of
  196. operation.
  197. .iP "void sys596IntEnable (int unit), void sys596IntDisable (int unit)"
  198. These routines enable or disable the interrupt from
  199. the 82596 for the specified <unit>.  Typically, this
  200. involves interrupt controller hardware, either
  201. internal or external to the CPU.  Since the 82596
  202. itself has no mechanism for controlling its interrupt
  203. activity, these routines are vital to the correct
  204. operation of the driver.  The driver calls these
  205. routines throughout normal operation to protect
  206. certain critical sections of code from interrupt
  207. handler intervention.
  208. .iP "void sys596IntAck (int unit)"
  209. This routine must perform any required interrupt acknowledgment 
  210. or clearing.  Typically, this involves an operation to some interrupt
  211. control hardware.  Note that the INT signal from the 82596
  212. behaves in an "edge-triggered" mode; therefore, this routine 
  213. typically clears a latch within the control circuitry.
  214. The driver calls this routine from the interrupt handler.
  215. .LP
  217. SYSTEM RESOURCE USAGE
  218. When implemented, this driver requires the following system resources:
  220.     - one mutual exclusion semaphore
  221.     - one interrupt vector
  222.     - one watchdog timer.
  223.     - 8 bytes in the initialized data section (data)
  224.     - 912 bytes in the uninitialized data section (BSS)
  226. The above data and BSS requirements are for the MC68020 architecture 
  227. and may vary for other architectures.  Code size (text) varies greatly between
  228. architectures and is therefore not quoted here.
  230. The driver uses cacheDmaMalloc() to allocate memory to share with the 82596.  
  231. The fixed-size pieces in this area total 160 bytes.  The variable-size 
  232. pieces in this area are affected by the configuration parameters specified 
  233. in the eiattach() call.  The size of one RFD (Receive Frame
  234. Descriptor) is 1536 bytes.  The size of one TFD (Transmit Frame Descriptor) 
  235. is 1534 bytes.  For more information about RFDs and TFDs, see the 
  236. .I "Intel 82596 User's Manual."
  238. The 82596 can be operated only if this shared memory region is non-cacheable
  239. or if the hardware implements bus snooping.  The driver cannot maintain
  240. cache coherency for the device because fields within the command
  241. structures are asynchronously modified by both the driver and the device,
  242. and these fields may share the same cache line.
  245. TUNING HINTS
  246. The only adjustable parameters are the number of TFDs and RFDs that will be
  247. created at run-time.  These parameters are given to the driver when eiattach()
  248. is called.  There is one TFD and one RFD associated with each transmitted
  249. frame and each received frame respectively.  For memory-limited applications,
  250. decreasing the number of TFDs and RFDs may be desirable.  Increasing the number
  251. of TFDs will provide no performance benefit after a certain point.
  252. Increasing the number of RFDs will provide more buffering before packets are
  253. dropped.  This can be useful if there are tasks running at a higher priority
  254. than the net task.
  256. SEE ALSO: ifLib,
  257. .I "Intel 82596 User's Manual,"
  258. .I "Intel 32-bit Local Area Network (LAN) Component User's Manual"
  259. */
  261. #include "vxWorks.h"
  262. #include "wdLib.h"
  263. #include "iv.h"
  264. #include "vme.h"
  265. #include "net/mbuf.h"
  266. #include "net/unixLib.h"
  267. #include "net/protosw.h"
  268. #include "sys/socket.h"
  269. #include "sys/ioctl.h"
  270. #include "errno.h"
  271. #include "memLib.h"
  272. #include "intLib.h"
  273. #include "net/if.h"
  274. #include "net/route.h"
  275. #include "iosLib.h"
  276. #include "errnoLib.h"
  278. #include "cacheLib.h"
  279. #include "logLib.h"
  280. #include "netLib.h"
  281. #include "stdio.h"
  282. #include "stdlib.h"
  283. #include "sysLib.h"
  285. #ifdef  INET
  286. #include "netinet/in.h"
  287. #include "netinet/in_systm.h"
  288. #include "netinet/in_var.h"
  289. #include "netinet/ip.h"
  290. #include "netinet/if_ether.h"
  291. #endif  /* INET */
  293. #include "etherLib.h"
  294. #include "net/systm.h"
  295. #include "sys/times.h"
  296. #include "drv/netif/if_ei.h"
  297. #include "net/if_subr.h"
  300. /***** LOCAL DEFINITIONS *****/
  302. #define DMA_MEMORY_IS_DUALPORTED /* DVE-SH7XXX specific */
  303. #undef EI_DEBUG                             /* Compiles debug output */
  305. #define MAX_UNITS       4                   /* maximum units to support */
  306. #define DEF_NUM_TFDS    32                  /* default number of TFDs */
  307. #define DEF_NUM_RFDS    32                  /* default number of RFDs */
  309. #if     (CPU_FAMILY == MIPS)
  310. #define MAX_RFDS_LOANED 0                   /* suppress buffer loaning */
  311. #else
  312. #define MAX_RFDS_LOANED 8                   /* max RFDs that can be loaned */
  313. #endif  /* (CPU_FAMILY == MIPS) */
  315. /* Typedefs for external structures that are not typedef'd in their .h files */
  317. typedef struct mbuf MBUF;
  318. typedef struct arpcom IDR;                  /* Interface Data Record wrapper */
  319. typedef struct ifnet IFNET;                 /* real Interface Data Record */
  320. typedef struct sockaddr SOCK;
  321. typedef struct ether_header ETH_HDR;
  323. /* The definition of our linked list management structure */
  325. typedef struct ei_list                       /* EI_LIST - 82596 queue head */
  326.     {
  327.     volatile EI_NODE *  head;       /* header of list */
  328.     volatile EI_NODE *  tail;       /* tail of list */
  329.     } EI_LIST;
  331. /* The definition of the driver control structure */
  333. typedef struct drv_ctrl
  334.     {
  335.     IDR                 idr;        /* interface data record */
  337.     BOOL                attached;   /* indicates attach() called */
  338.     char                *memBase;   /* 82596 memory pool base */
  339.     SCP                 *pScp;      /* SCP ptr */
  340.     ISCP                *pIscp;     /* ISCP ptr */
  341.     SCB                 *pScb;      /* SCB ptr */
  342.     CFD                 *pCfd;      /* synchronous command frame */
  343.     RFD                 *rfdPool;   /* RFD pool */
  344.     TFD                 *tfdPool;   /* TFD pool */
  345.     RFD                 *pFreeRfd;  /* first empty RFD in rxQueue */
  346.     volatile EI_LIST    rxQueue;    /* receive queue */
  347.     volatile EI_LIST    txQueue;    /* to be sent queue */
  348.     volatile EI_LIST    tfdQueue;   /* free transmit frame descriptors */
  349.     volatile EI_LIST    cblQueue;   /* actual chip transmit queue */
  350.     volatile EI_LIST    cleanQueue; /* queue of TFDs to cleanup */
  351.     volatile BOOL       rcvHandling;/* flag, indicates netTask active */
  352.     volatile BOOL       txCleaning; /* flag, indicates netTask active */
  353.     volatile BOOL       txIdle;     /* flag, indicates idle transmitter */
  354.     int                 nTFDs;      /* how many TFDs to create */
  355.     int                 nRFDs;      /* how many RFDs to create */
  356.     int                 nLoanRfds;  /* number of loanable RFDs left */
  357.     UINT8               sysbus;     /* SCP sysbus value */
  358.     int                 ivec;       /* interrupt vector */
  359.     CACHE_FUNCS         cacheFuncs; /* cache descriptor */
  360.     WDOG_ID             wid;        /* watchdog timer for transmit */
  361.     int                 wdInterval; /* ticks between eiWatchDog runs */
  362.     long recvLocks;  /* count for receive lockup failures */
  363.     long                transLocks; /* count for transmit lockup failures */
  364.     volatile char wdTxTimeout;/* watchdog runs with transmit hung */
  365.     volatile char wdRxTimeout;/* watchdog runs with receive hung */
  366.     } DRV_CTRL;
  368. #define DRV_CTRL_SIZ  sizeof(DRV_CTRL)
  369. #define EI_RX_TIMEOUT 3         /* # watchdog runs for receive timeout */
  370. #define EI_TX_TIMEOUT 2         /* # watchdog runs for transmit timeout */
  373. /***** GLOBALS *****/
  375. /* Function declarations not in any header files */
  377. IMPORT STATUS sysEnetAddrGet (int unit, char addr[]);
  378. IMPORT STATUS sys596Init (int unit);
  379. IMPORT STATUS sys596IntAck (int unit);
  380. IMPORT STATUS sys596IntEnable (int unit);
  381. IMPORT void   sys596IntDisable (int unit);
  382. IMPORT void   sys596Port (int unit, int cmd, UINT32 addr);
  383. IMPORT void   sys596ChanAtn (int unit);
  385. #ifdef DMA_MEMORY_IS_DUALPORTED
  386. IMPORT void *sysDmaVirtToPhys (void * address);
  387. IMPORT void *sysDmaPhysToVirt (void * address);
  388. #endif /* DMA_MEMORY_IS_DUALPORTED */
  391. /***** LOCALS *****/
  393. /* The array of driver control structs */
  395. LOCAL DRV_CTRL drvCtrl [MAX_UNITS];
  398. /* forward function declarations */
  400. static STATUS eiInit (int unit);
  401. static void eiReset (int unit);
  402. static int eiIoctl (IFNET *pIfNet, int cmd, caddr_t data);
  403. static void eiTxStartup (DRV_CTRL * pDrvCtrl);
  404. static void eiInt (DRV_CTRL *pDrvCtrl);
  405. static void eiTxCleanQ (DRV_CTRL *pDrvCtrl);
  406. static void eiHandleRecvInt (DRV_CTRL *pDrvCtrl);
  407. static STATUS eiReceive (DRV_CTRL *pDrvCtrl, RFD *pRfd);
  408. static void eiLoanFree (DRV_CTRL *pDrvCtrl, RFD *pRfd);
  409. static void eiDiag (int unit);
  410. static void eiConfig (int unit);
  411. static void eiIASetup (int unit);
  412. static void eiRxStartup (DRV_CTRL *pDrvCtrl);
  413. static void eiAction (int unit, UINT16 action);
  414. static STATUS eiCommand (DRV_CTRL *pDrvCtrl, UINT16 cmd);
  415. static void eiTxQPut (DRV_CTRL *pDrvCtrl, TFD *pTfd);
  416. static void eiTxQFlush (DRV_CTRL *pDrvCtrl);
  417. static void eiRxQPut (DRV_CTRL *pDrvCtrl, RFD *pRfd);
  418. static RFD *eiRxQGet (DRV_CTRL *pDrvCtrl);
  419. static BOOL eiRxQFull (DRV_CTRL *pDrvCtrl);
  420. static void eiQInit (EI_LIST *pHead);
  421. static EI_NODE *eiQGet (EI_LIST *pQueue);
  422. static void eiQPut (int unit, EI_LIST *pQueue, EI_NODE *pNode);
  423. static STATUS eiDeviceStart (int unit);
  424. static void eiWatchDog(int unit);
  426. /*******************************************************************************
  427. *
  428. * eiattach - publish the `ei' network interface and initialize the driver and device
  429. *
  430. * This routine publishes the `ei' interface by filling in a network interface
  431. * record and adding this record to the system list.  This routine also
  432. * initializes the driver and the device to the operational state.
  433. *
  434. * The 82596 shares a region of memory with the driver.  The caller of this
  435. * routine can specify the address of this memory region, or can specify that
  436. * the driver must obtain this memory region from the system resources.
  437. *
  438. * The <sysbus> parameter accepts values as described in the Intel manual
  439. * for the 82596.  A default number of transmit/receive frames of 32 can be
  440. * selected by passing zero in the parameters <nTfds> and <nRfds>.
  441. * In other cases, the number of frames selected should be greater than two.
  442. *
  443. * The <memBase> parameter is used to inform the driver about the shared
  444. * memory region.  If this parameter is set to the constant "NONE," then this
  445. * routine will attempt to allocate the shared memory from the system.  Any
  446. * other value for this parameter is interpreted by this routine as the address
  447. * of the shared memory region to be used.
  448. *
  449. * If the caller provides the shared memory region, then the driver assumes
  450. * that this region does not require cache coherency operations, nor does it
  451. * require conversions between virtual and physical addresses.
  452. *
  453. * If the caller indicates that this routine must allocate the shared memory
  454. * region, then this routine will use cacheDmaMalloc() to obtain
  455. * some  non-cacheable memory.  The attributes of this memory will be checked,
  456. * and if the memory is not both read and write coherent, this routine will
  457. * abort and return ERROR.
  458. *
  459. * RETURNS: OK or ERROR.
  460. *
  461. * SEE ALSO: ifLib,
  462. * .I "Intel 82596 User's Manual"
  463. */
  465. STATUS eidveattach
  466.     (
  467.     int         unit,       /* unit number */
  468.     int         ivec,       /* interrupt vector number */
  469.     UINT8       sysbus,     /* sysbus field of SCP */
  470.     char *      memBase,    /* address of memory pool or NONE */
  471.     int         nTfds,      /* no. of transmit frames (0 = default) */
  472.     int         nRfds       /* no. of receive frames (0 = default) */
  473.     )
  474.     {
  475.     DRV_CTRL    *pDrvCtrl;
  476.     UINT        size;                           /* temporary size holder */
  477.     UINT        sizeScp;
  478.     UINT        sizeIscp;
  479.     UINT        sizeScb;
  480.     UINT        sizeCfd;
  481.     RFD *       pRfd;                   /* pointer to RFD's */
  482.     int         ix;
  484.     static char *errMsg1 = "neidveattach: could not obtain memoryn";
  485.     static char *errMsg2 = "neidveattach: shared memory not cache coherentn";
  487.     sizeScp  = MEM_ROUND_UP (sizeof (SCP));
  488.     sizeIscp = MEM_ROUND_UP (sizeof (ISCP));
  489.     sizeScb  = MEM_ROUND_UP (sizeof (SCB));
  490.     sizeCfd  = MEM_ROUND_UP (sizeof (CFD));
  492.     /* Sanity check the unit number */
  494.     if (unit < 0 || unit >= MAX_UNITS)
  495.         return (ERROR);
  497.     /* Ensure single invocation per system life */
  499.     pDrvCtrl = & drvCtrl [unit];
  500.     if (pDrvCtrl->attached)
  501.         return (OK);
  503.     /* Determine number of Tx and Rx descriptors to use */
  505.     pDrvCtrl->nTFDs = nTfds ? nTfds : DEF_NUM_TFDS;
  506.     pDrvCtrl->nRFDs = nRfds ? nRfds : DEF_NUM_RFDS;
  508.     /* calculate the total size of 82596 memory pool */
  510.     size =
  511.             24 +                                /* allow for alignment */
  512.             sizeScp +
  513.             sizeIscp +
  514.             sizeScb +
  515.             sizeCfd +                           /* synch'ed command frame */
  516.             (sizeof (RFD) * pDrvCtrl->nRFDs) +  /* pool of receive frames */
  517.             (sizeof (TFD) * pDrvCtrl->nTFDs);   /* pool of transmit frames */
  519.     /* Establish the memory area that we will share with the device.  If
  520.      * the caller has provided an area, then we assume it is non-cacheable
  521.      * and will not require the use of the special cache routines.
  522.      * If the caller did not provide an area, then we must obtain it from
  523.      * the system, using the cache savvy allocation routine.
  524.      */
  526.     switch ((int) memBase)
  527.         {
  528.         case NONE :                            /* we must obtain it */
  530.             /* this driver can't handle incoherent caches */
  532.             if (!CACHE_DMA_IS_WRITE_COHERENT () ||
  533.                 !CACHE_DMA_IS_READ_COHERENT ())
  534.                 {
  535.                 printf (errMsg2);
  536.                 goto error;
  537.                 }
  539.             pDrvCtrl->memBase = cacheDmaMalloc (size);
  541.             if (pDrvCtrl->memBase == NULL)    /* no memory available */
  542.                 {
  543.                 printf (errMsg1);
  544.                 goto error;
  545.                 }
  547. #ifndef DMA_MEMORY_IS_DUALPORTED
  548.             pDrvCtrl->cacheFuncs = cacheDmaFuncs;
  549. #endif /* DMA_MEMORY_IS_DUALPORTED */
  550.             break;
  552.         default :                               /* the user provided an area */
  553.             pDrvCtrl->memBase = memBase;        /* use the provided address */
  554. #ifndef DMA_MEMORY_IS_DUALPORTED
  555.             pDrvCtrl->cacheFuncs = cacheNullFuncs;
  556. #else
  557.     printf ("neidveattach: allocate 0x%x bytes from address 0x%x... ",
  558. size, (UINT)(pDrvCtrl->memBase));
  559. #endif /* DMA_MEMORY_IS_DUALPORTED */
  560.             break;
  561.         }
  563. #ifdef DMA_MEMORY_IS_DUALPORTED
  564. pDrvCtrl->cacheFuncs.flushRtn      = NULL;
  565. pDrvCtrl->cacheFuncs.invalidateRtn = NULL;
  566. pDrvCtrl->cacheFuncs.virtToPhysRtn = (FUNCPTR)sysDmaVirtToPhys;
  567. pDrvCtrl->cacheFuncs.physToVirtRtn = (FUNCPTR)sysDmaPhysToVirt;
  568. #endif /* DMA_MEMORY_IS_DUALPORTED */
  570.     /* Save other passed-in parameters */
  572.     pDrvCtrl->sysbus = sysbus;                  /* remember sysbus value */
  573.     pDrvCtrl->ivec = ivec;                      /* interrupt vector */
  575.     /* Carve up the shared memory region into the specific sections */
  577.     bzero ((char *) pDrvCtrl->memBase, size);
  578.     pDrvCtrl->pScp  = (SCP *)                /* align to first 16 byte page */
  579.                       ( ((u_long) pDrvCtrl->memBase + 0xf) & ~0xf );
  580.     pDrvCtrl->pIscp = (ISCP *)((int)pDrvCtrl->pScp   + sizeScp);
  581.     pDrvCtrl->pScb  = (SCB *) ((int)pDrvCtrl->pIscp  + sizeIscp);
  582.     pDrvCtrl->pCfd  = (CFD *) ((int)pDrvCtrl->pScb   + sizeScb);
  583.     /*
  584.      * Align the RFD pool on a 2-byte boundary.  This causes the IP
  585.      * header to be aligned on a 4-byte boundary and enables the protocol
  586.      * layer (ip_input) to access long fields without getting a bus error.
  587.      */
  588.     pDrvCtrl->rfdPool = (RFD *) 
  589.         (MEM_ROUND_UP (((int)pDrvCtrl->pCfd + sizeCfd)) + 2);
  590.     pDrvCtrl->tfdPool = (TFD *) /* TFD is OK on a 4-byte boundary */
  591.       MEM_ROUND_UP ((int)pDrvCtrl->rfdPool+ (sizeof (RFD) * pDrvCtrl->nRFDs));
  593.     for (ix = 0, pRfd = pDrvCtrl->rfdPool; ix < DEF_NUM_RFDS; ix++, pRfd++)
  594.         {
  595.         pRfd->refCnt = 0;                    /* initialize ref cnt */
  596.         }
  598.     /* Init the watchdog that will patrol for device lockups */
  599.  
  600.     pDrvCtrl->transLocks = 0;
  601.     pDrvCtrl->recvLocks = 0;
  602.     pDrvCtrl->wid = wdCreate ();                      /* create watchdog */
  603.     if (pDrvCtrl->wid == NULL)                        /* no resource */
  604.         goto error;
  605.     pDrvCtrl->wdInterval = sysClkRateGet() >> 1;
  607.     /* get our enet addr */
  609.     if (sysEnetAddrGet (unit, (char *)pDrvCtrl->idr.ac_enaddr) == ERROR)
  610. {
  611. errnoSet (S_iosLib_INVALID_ETHERNET_ADDRESS);
  612.         goto error;
  613. }
  615.     /* Publish the interface record */
  616.     ether_attach    (
  617.                     (IFNET *) & pDrvCtrl->idr,
  618.                     unit,
  619.                     "ei",
  620.                     (FUNCPTR) NULL,
  621.                     (FUNCPTR) eiIoctl,
  622.                     (FUNCPTR) ether_output,
  623.                     (FUNCPTR) eiReset
  624.                     );
  626.     pDrvCtrl->idr.ac_if.if_start = (FUNCPTR) eiTxStartup;
  628.     /* initialize the unit */
  630.     if (eiInit (unit) == ERROR)
  631.         goto error;
  633.     /* Set our flag */
  635.     pDrvCtrl->attached = TRUE;
  637.     /* Set status flags in IDR */
  639.     pDrvCtrl->idr.ac_if.if_flags |= (IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);
  641.     /* Successful return */
  643.     return (OK);
  645.     /***** Handle error cases *****/
  647.     error:
  649.         {
  650.         /* Release system memory */
  652.         if (((int) memBase == NONE) && ((int) pDrvCtrl->memBase != NULL))
  653.             cacheDmaFree (pDrvCtrl->memBase);
  655.         /* Release watchdog */
  657.         if (pDrvCtrl->wid != NULL)
  658.             wdDelete (pDrvCtrl->wid);
  660.         return (ERROR);
  661.         }
  662.     }
  665. /*******************************************************************************
  666. *
  667. * eiInit - Initialize the interface.
  668. *
  669. * Initialization of interface; clear recorded pending operations.
  670. * Called at boot time and by eiWatchDog() if a reset is required.
  671. *
  672. * RETURNS: OK or ERROR
  673. */
  675. static STATUS eiInit 
  676.     (
  677.     int unit /* unit number */
  678.     )
  679.     {
  680.     DRV_CTRL    *pDrvCtrl = & drvCtrl [unit];
  682.     pDrvCtrl->rcvHandling   = FALSE;  /* netTask not running our receive job */
  683.     pDrvCtrl->txCleaning    = FALSE;  /* netTask not running our clean job */
  684.     pDrvCtrl->txIdle        = TRUE;         /* transmitter idle */
  685.     eiQInit ((EI_LIST *)&pDrvCtrl->rxQueue);    /* to be received queue */
  686.     eiQInit ((EI_LIST *)&pDrvCtrl->txQueue);    /* to be sent queue */
  687.     eiQInit ((EI_LIST *)&pDrvCtrl->tfdQueue);   /* free tfds to add to send q */
  688.     eiQInit ((EI_LIST *)&pDrvCtrl->cblQueue);   /* actively sending queue */
  689.     eiQInit ((EI_LIST *)&pDrvCtrl->cleanQueue); /* queue of TFDs to clean */
  691.     pDrvCtrl->wdTxTimeout = 0;
  692.     pDrvCtrl->wdRxTimeout = 0;
  695.     { /***** Perform device initialization *****/
  697.     /* Block local variables */
  699.     int ix;
  701.     sys596IntDisable (unit);            /* disable device interrupts */
  702.     (void) sys596Init (unit);           /* do board specific init */
  704.     /* Connect the interrupt handler */
  706.     if (intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (pDrvCtrl->ivec),
  707.     eiInt, (int)pDrvCtrl) == ERROR)
  708.         return (ERROR);
  710.     /* Start the device */
  712.     if ( eiDeviceStart (unit) == ERROR )
  713.         return (ERROR);
  715.     eiDiag (unit);                             /* run diagnostics */
  716.     eiConfig (unit);                           /* configure chip */
  717.     eiIASetup (unit);                          /* setup address */
  719.     for (ix = 0; ix < pDrvCtrl->nTFDs; ix ++)  /* tank up the free tfd queue */
  720.         {
  721.         eiQPut  (
  722.                 unit,
  723.                 (EI_LIST *) & pDrvCtrl->tfdQueue,
  724.                 (EI_NODE *) & pDrvCtrl->tfdPool [ix]
  725.                 );
  726.         }
  728.     pDrvCtrl->pFreeRfd  = NULL;                  /* first free RFD */
  729.     pDrvCtrl->nLoanRfds = MAX_RFDS_LOANED;       /* number of loanable RFD's */
  731.     for (ix = 0; ix < pDrvCtrl->nRFDs; ix ++)   /* tank up the receive queue */
  732. {
  733. if (pDrvCtrl->rfdPool[ix].refCnt == 0)
  734.         eiRxQPut (pDrvCtrl, & pDrvCtrl->rfdPool [ix]);
  735. }
  737.     sys596IntAck (unit);                     /* clear any pended dev ints */
  738.     sys596IntEnable (unit);                  /* enable interrupts at system */
  740.     } /* End block */
  742.     wdCancel(pDrvCtrl->wid);                  /* in case re-initializing */
  743.     wdStart(pDrvCtrl->wid, 
  744.     (int) pDrvCtrl->wdInterval, 
  745.     (FUNCPTR) eiWatchDog, 
  746.     pDrvCtrl->idr.ac_if.if_unit
  747.    );
  749.     return (OK);
  750.     }
  752. /*******************************************************************************
  753. *
  754. * eiReset - reset the ei interface
  755. *
  756. * Mark interface as inactive and reset the chip.
  757. */
  759. static void eiReset
  760.     (
  761.     int unit
  762.     )
  763.     {
  764.     DRV_CTRL *pDrvCtrl;
  766.     pDrvCtrl = & drvCtrl [unit];
  768.     pDrvCtrl->idr.ac_if.if_flags = 0;
  769.     sys596IntDisable (unit);                    /* disable ints from the dev */
  770.     sys596Port (unit, PORT_RESET, NULL);        /* reset the 596 chip */
  772.     }
  774. /*******************************************************************************
  775. *
  776. * eiIoctl - interface ioctl procedure
  777. *
  778. * Process an interface ioctl request.
  779. */
  781. static int eiIoctl
  782.     (
  783.     IFNET  *pIfNet,
  784.     int     cmd,
  785.     caddr_t data
  786.     )
  787.     {
  788.     int error;
  790. #ifdef EI_DEBUG
  791.     printf ("ei: ioctl: pIDR=%x cmd=%x data=%xn", pIDR, cmd, data);
  792. #endif /* EI_DEBUG */
  794.     error = 0;
  796.     switch (cmd)
  797.         {
  798.         case SIOCSIFADDR:
  799.             ((struct arpcom *)pIfNet)->ac_ipaddr = IA_SIN (data)->sin_addr;
  800.             arpwhohas (pIfNet, &IA_SIN (data)->sin_addr);
  801.             break;
  803.         case SIOCSIFFLAGS:
  804.             /* Flags are set outside this module. No additional work to do. */
  805.             break;
  807.         default:
  808.             error = EINVAL;
  809.         }
  811.     return (error);
  812.     }
  814. /*******************************************************************************
  815. *
  816. * eiTxStartup - start output on the chip
  817. *
  818. * Looks for any action on the queue, and begins output if there is anything
  819. * there.  This routine is called from several possible threads.  Each will be
  820. * described below.
  821. *
  822. * The first, and most common thread, is when a user task requests the
  823. * transmission of data.  This will cause eiOutput() to be called, which will
  824. * cause ether_output() to be called, which will cause this routine to be
  825. * called (usually).  This routine will not be called if ether_output() finds
  826. * that our interface output queue is full.  In this case, the outgoing data
  827. * will be thrown out.
  828. *
  829. * The second, and most obscure thread, is when the reception of certain
  830. * packets causes an immediate (attempted) response.  For example, ICMP echo
  831. * packets (ping), and ICMP "no listener on that port" notifications.  All
  832. * functions in this driver that handle the reception side are executed in the
  833. * context of netTask().  Always.  So, in the case being discussed, netTask() 
  834. * will receive these certain packets, cause IP to be stimulated, and cause the
  835. * generation of a response to be sent.  We then find ourselves following the
  836. * thread explained in the second example, with the important distinction that
  837. * the context is that of netTask().
  838. *
  839. * The third thread occurs when this routine runs out of TFDs and returns.  If
  840. * this occurs when our output queue is not empty, this routine would typically
  841. * not get called again until new output was requested.  Even worse, if the
  842. * output queue was also full, this routine would never get called again and
  843. * we would have a lock state.  It DOES happen.  To guard against this, the
  844. * transmit clean-up handler detects the out-of-TFDs state and calls this
  845. * function.  The clean-up handler also runs from netTask.
  846. *
  847. * Note that this function is ALWAYS called between an splnet() and an splx().
  848. * This is true because netTask(), and ether_output() take care of
  849. * this when calling this function.  Therefore, no calls to these spl functions
  850. * are needed anywhere in this output thread.
  851. */
  853. void eiTxStartup
  854.     (
  855.     DRV_CTRL * pDrvCtrl
  856.     )
  857.     {
  858.     MBUF * pMbuf;
  859.     int length;
  860.     TFD * pTfd;
  862.     /*
  863.      * Loop until there are no more packets ready to send or we
  864.      * have insufficient resources left to send another one.
  865.      */
  867.     while (pDrvCtrl->idr.ac_if.if_snd.ifq_head)
  868.         {
  869.         IF_DEQUEUE (&pDrvCtrl->idr.ac_if.if_snd, pMbuf);  /* dequeue a packet */
  870.         /* get free tfd */
  871.         pTfd = (TFD *) eiQGet ((EI_LIST *)&pDrvCtrl->tfdQueue);
  873.         if (pTfd == NULL)
  874.             {
  875.             m_freem (pMbuf);
  876.             break;                              /* out of TFD's */
  877.             }
  879.         copy_from_mbufs ((ETH_HDR *)pTfd->enetHdr, pMbuf, length);
  880.         length = max (ETHERSMALL, length);
  882.         if ((etherOutputHookRtn != NULL) &&
  883.             (* etherOutputHookRtn)
  884.             (&pDrvCtrl->idr, (ETH_HDR *)pTfd->enetHdr, length))
  885.             continue;
  887.         pTfd->count = length & ~0xc000;     /* fill in length */
  889.         eiTxQPut (pDrvCtrl, pTfd);
  890.         }
  891.     }
  893. /*******************************************************************************
  894. *
  895. * eiInt - entry point for handling interrupts from the 82596
  896. *
  897. * The interrupting events are acknowledged to the device, so that the device
  898. * will deassert its interrupt signal.  The amount of work done here is kept
  899. * to a minimum; the bulk of the work is defered to the netTask.  Several flags
  900. * are used here to synchronize with task level code and eliminate races.
  901. */
  903. static void eiInt
  904.     (
  905.     DRV_CTRL *pDrvCtrl
  906.     )
  907.     {
  908.     UINT16  event;
  909.     SCB *pScb;
  910.     int unit;
  911.     pScb = pDrvCtrl->pScb;
  912.     unit = pDrvCtrl->idr.ac_if.if_unit;
  914.     event = pScb->scbStatus & (SCB_S_CX | SCB_S_FR | SCB_S_CNA | SCB_S_RNR);
  916. #ifdef EI_DEBUG
  917.     logMsg ("ei: interrupt: event=%xn", event, 0, 0, 0, 0, 0);
  918. #endif /* EI_DEBUG */
  920.     eiCommand (pDrvCtrl, event);                        /* ack the events */
  922.     sys596IntAck (unit);                                /* ack 596 interrupt */
  924.     /* Handle transmitter interrupt */
  926.     if (event & SCB_S_CNA)                              /* reclaim tx tfds */
  927.         {
  928.         pDrvCtrl->wdTxTimeout = 0;              /* reset timeout count */
  930.         if (pDrvCtrl->cleanQueue.head == NULL)      /* clean queue empty */
  931.             {
  932.             pDrvCtrl->cleanQueue.head = pDrvCtrl->cblQueue.head; /* new head */
  933.             pDrvCtrl->cleanQueue.tail = pDrvCtrl->cblQueue.tail; /* new tail */
  934.             }
  935.         else                                            /* concatenate queues */
  936.             {
  937.             LINK_WR ( (EI_LINK * ) &(pDrvCtrl->cleanQueue.tail->pNext),
  938.                         (void*) pDrvCtrl->cblQueue.head); 
  939.             pDrvCtrl->cleanQueue.tail = pDrvCtrl->cblQueue.tail;
  940.             }
  942.         if (!pDrvCtrl->txCleaning)                          /* not cleaning? */
  943.             {
  944.             pDrvCtrl->txCleaning = TRUE;                    /* set flag */
  945.             netJobAdd ((FUNCPTR) eiTxCleanQ, (int) pDrvCtrl, 0, 0, 0, 0);
  946.                             /* defer cleanup */
  947.             }
  949.         if (pDrvCtrl->txQueue.head != NULL)             /* anything to flush? */
  950.             eiTxQFlush (pDrvCtrl);                      /* flush the tx q */
  951.         else
  952.             pDrvCtrl->txIdle = TRUE;                    /* transmitter idle */
  953.         }
  955.     /* Handle receiver interrupt */
  957.     if (event & SCB_S_FR)
  958. {
  959. pDrvCtrl->wdRxTimeout = 0;                  /* reset timeout count */
  960. if (!(pDrvCtrl->rcvHandling))
  961.             {
  962.             pDrvCtrl->rcvHandling = TRUE;
  963.             (void) netJobAdd ((FUNCPTR) eiHandleRecvInt, (int) pDrvCtrl,0, 0, 0, 0);         /* netTask processes */
  964.     }
  965.         }
  966.     }
  968. /*******************************************************************************
  969. *
  970. * eiTxCleanQ - checks errors in completed TFDs and moves TFDs to free queue
  971. *
  972. * This routine is executed by netTask.  It "cleans" the TFDs on the clean-up
  973. * queue by checking each one for errors and then returning the TFD to the
  974. * "free TFD" queue.  The startup routine is sometimes called here to eliminate
  975. * the lock-out case where the driver input queue is full but there are no
  976. * TFDs available.
  977. */
  979. static void eiTxCleanQ
  980.     (
  981.     DRV_CTRL *pDrvCtrl
  982.     )
  983.     {
  984.     TFD *pTfd;
  985.     BOOL needTxStart;
  986.     int unit;
  988.     unit = pDrvCtrl->idr.ac_if.if_unit;
  990.     do
  991.         {
  992.         pDrvCtrl->txCleaning = TRUE;
  994.         if (pDrvCtrl->tfdQueue.head == NULL)              /* tfd queue empty */
  995.             needTxStart = TRUE;                           /* set flag */
  996.         else
  997.             needTxStart = FALSE;
  999.         /* process transmitted frames */
  1001.         while (1)
  1002.             {
  1004.             /* Get TFD. No ints allowed while manipulating this queue. */
  1006.             sys596IntDisable (unit);
  1007.             pTfd = (TFD*) eiQGet ((EI_LIST *)&pDrvCtrl->cleanQueue);
  1008.             sys596IntEnable (unit);
  1009.             if (pTfd == NULL)
  1010.                 break;
  1012.             pDrvCtrl->idr.ac_if.if_collisions +=         /* add any colls */
  1013.                 (pTfd->status & CFD_S_RETRY) ? 16 :  /* excessive colls */
  1014.                 (pTfd->status & CFD_S_COLL_MASK);    /* some colls */
  1016.             if (!(pTfd->status & CFD_S_OK))          /* packet not sent */
  1017.                 {
  1018.                 pDrvCtrl->idr.ac_if.if_oerrors++;        /* incr err count */
  1019.                 pDrvCtrl->idr.ac_if.if_opackets--;       /* decr sent count */
  1020.                 }
  1022.             /* return to tfdQ */
  1023.             eiQPut (unit,(EI_LIST *)&pDrvCtrl->tfdQueue, (EI_NODE*)pTfd);
  1024.             }
  1026.         if (needTxStart)                                  /* check flag */
  1027.             eiTxStartup (pDrvCtrl);
  1029.         pDrvCtrl->txCleaning = FALSE;
  1030.         }
  1031.     while (pDrvCtrl->cleanQueue.head != NULL);            /* check again */
  1032.     }
  1034. /*******************************************************************************
  1035. *
  1036. * eiHandleRecvInt - task level interrupt service for input packets
  1037. *
  1038. * This routine is called at task level indirectly by the interrupt
  1039. * service routine to do any message received processing.
  1040. */
  1042. static void eiHandleRecvInt
  1043.     (
  1044.     DRV_CTRL *pDrvCtrl
  1045.     )
  1046.     {
  1047.     RFD *pRfd;
  1049.     do
  1050.         {
  1051.         pDrvCtrl->rcvHandling = TRUE;             /* interlock with eiInt() */
  1053.         while ((pRfd = eiRxQGet (pDrvCtrl)) != NULL)
  1054.             if (eiReceive (pDrvCtrl, pRfd) == OK)
  1055.                 eiRxQPut (pDrvCtrl, pRfd);
  1057.         pDrvCtrl->rcvHandling = FALSE;            /* interlock with eiInt() */
  1058.         }
  1059.     while (eiRxQFull (pDrvCtrl));              /* make sure rx q still empty */
  1060.     }
  1062. /*******************************************************************************
  1063. *
  1064. * eiReceive - pass a received frame to the next layer up
  1065. *
  1066. * Strips the Ethernet header and passes the packet to the appropriate
  1067. * protocol.  The return value indicates if buffer loaning was used to hold
  1068. * the data.  A return value of OK means that loaning was not done, and it
  1069. * is therefore 'ok' to return the RFD to the Rx queue.  A return value of ERROR
  1070. * means that buffer loaning was employed, and so the RFD is still in use and
  1071. * should not be returned to the Rx queue.  In this latter case, the RFD will
  1072. * eventually be returned by the protocol, via a call to our eiLoanFree().
  1073. */
  1075. static STATUS eiReceive
  1076.     (
  1077.     DRV_CTRL *pDrvCtrl,
  1078.     RFD *pRfd
  1079.     )
  1080.     {
  1081.     ETH_HDR     *pEh;
  1082.     u_char      *pData;
  1083.     int         len;
  1084.     UINT16      etherType;
  1085.     MBUF        *m = NULL;
  1086.     BOOL        rfdLoaned = FALSE;
  1089.     /* Check packet for errors.  This should be completely unnecessary,
  1090.      * but since Intel does not seem capable of explaining the exact
  1091.      * functioning of the 'save bad frames' config bit, we will look for
  1092.      * errors.
  1093.      */
  1095.     if  (
  1096.         ( pRfd->status & ( RFD_S_OK | RFD_S_COMPLETE ) ) !=
  1097.         ( RFD_S_OK | RFD_S_COMPLETE )
  1098.         )
  1099.         {
  1100.         ++pDrvCtrl->idr.ac_if.if_ierrors;            /* bump error counter */
  1101.         eiRxQPut (pDrvCtrl, pRfd);                   /* free the RFD */
  1102.         return (ERROR);
  1103.         }
  1105.     /* Bump input packet counter. */
  1107.     ++pDrvCtrl->idr.ac_if.if_ipackets;
  1109.     len = pRfd->actualCnt & ~0xc000;        /* get frame length */
  1110.     pEh = (ETH_HDR *)pRfd->enetHdr;         /* get ptr to ethernet header */
  1112.     /* Service input hook */
  1114.     if ( (etherInputHookRtn != NULL) )
  1115.         {
  1116.         if  ( (* etherInputHookRtn) (&pDrvCtrl->idr, (char *)pEh, len) )
  1117.             {
  1118.             eiRxQPut (pDrvCtrl, pRfd);                  /* free the RFD */
  1119.             return (OK);
  1120.             }
  1121.         }
  1123.     len -= EH_SIZE;
  1124.     pData = (u_char *) pRfd->enetData;
  1125.     etherType = ntohs (pEh->ether_type);
  1127.     /* we can loan out receive frames from 82596 receive queue if:
  1128.      *
  1129.      * 1) the threshold of loanable frames has not been exceeded
  1130.      * 2) size of the input ethernet frame is large enough to be used with
  1131.      *    clustering.
  1132.      */
  1134.     if ((pDrvCtrl->nLoanRfds > 0) &&
  1135.         ((m = build_cluster (pData, len, &pDrvCtrl->idr, MC_EI, &pRfd->refCnt,
  1136.                  eiLoanFree, (int) pDrvCtrl, (int) pRfd, NULL)) != NULL))
  1137.         {
  1138.         pDrvCtrl->nLoanRfds --;             /* one less to loan */
  1139.         rfdLoaned = TRUE;               /* we loaned a frame */
  1140.         }
  1141.     else
  1142.         m = copy_to_mbufs (pData, len, 0, &pDrvCtrl->idr);
  1144.     if (m != NULL)
  1145. #ifdef BSD43_DRIVER
  1146.         do_protocol_with_type (etherType, m, &pDrvCtrl->idr, len);
  1147. #else
  1148.         do_protocol (pEh, m, &pDrvCtrl->idr, len);
  1149. #endif
  1151.     return ((rfdLoaned) ? ERROR : OK);
  1152.     }
  1154. /*******************************************************************************
  1155. *
  1156. * eiLoanFree - return a loaned receive frame descriptor
  1157. *
  1158. * This routine is called by the protocol code when it has completed use of
  1159. * an RFD that we loaned to it.
  1160. */
  1162. static void eiLoanFree
  1163.     (
  1164.     DRV_CTRL *pDrvCtrl,
  1165.     RFD *pRfd
  1166.     )
  1167.     {
  1168.     eiRxQPut (pDrvCtrl, pRfd);
  1169.     pDrvCtrl->nLoanRfds ++;
  1170.     }
  1172. /*******************************************************************************
  1173. *
  1174. * eiDeviceStart - reset and start the device
  1175. *
  1176. * This routine assumes interrupts from the device have been disabled, and
  1177. * that the driver control structure has been initialized.
  1178. */
  1180. static STATUS eiDeviceStart
  1181.     (
  1182.     int unit                              /* physical unit number */
  1183.     )
  1184.     {
  1185.     void     *pTemp;
  1186.     DRV_CTRL *pDrvCtrl;
  1187.     SCP      *pScp;                       /* system config ptr */
  1188.     ISCP     *pIscp;                      /* intermediate system config ptr */
  1189.     SCB      *pScb;                       /* system control block ptr */
  1191.     /* Get pointers */
  1193.     pDrvCtrl = & drvCtrl [unit];
  1194.     pScp = pDrvCtrl->pScp;
  1195.     pIscp = pDrvCtrl->pIscp;
  1196.     pScb = pDrvCtrl->pScb;
  1198.     /* Issue the reset operation to the device */
  1200.     sys596Port (unit, PORT_RESET, NULL);
  1202.     /* Initialize the SCP */
  1204.     pScp->scpRsv1 =
  1205.     pScp->scpRsv2 =
  1206.     pScp->scpRsv3 = 0;
  1207.     pScp->scpSysbus = pDrvCtrl->sysbus;
  1209.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pIscp);
  1210.     LINK_WR (&pScp->pIscp, pTemp);              /* point SCP to ISCP */
  1212.     /* Initialize the ISCP */
  1214.     pIscp->iscpBusy = 1;
  1215.     pIscp->iscpRsv1 = 0;
  1217.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pScb);
  1218.     LINK_WR (&pIscp->pScb, pTemp);              /* point ISCP to SCB */
  1220.     /* Initialize the SCB */
  1222.     bzero ((char *)pScb, sizeof (SCB));
  1224.     /* Tell the device where the SCP is located */
  1226.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pScp);
  1227.     sys596Port (unit, PORT_NEWSCP, (UINT32) pTemp);
  1228.     sys596ChanAtn (unit);
  1230.     /*
  1231.      * The device will now read our SCP and ISCP. It will clear the busy
  1232.      * flag in the ISCP.
  1233.      */
  1235.     taskDelay (50);
  1236.     if ( pIscp->iscpBusy == 1 )
  1237.         {
  1238.         printf ("nei: device did not initializen");
  1239.         return (ERROR);
  1240.         }
  1242.     return (OK);
  1243.     }
  1245. /*******************************************************************************
  1246. *
  1247. * eiDiag - format and issue a diagnostic command
  1248. */
  1250. static void eiDiag
  1251.     (
  1252.     int unit
  1253.     )
  1254.     {
  1255.     DRV_CTRL *pDrvCtrl;
  1257.     pDrvCtrl = & drvCtrl [unit];
  1259.     bzero ((char *)pDrvCtrl->pCfd, sizeof (CFD));       /* zero command frame */
  1261.     eiAction (unit, CFD_C_DIAG);                /* run diagnostics */
  1263.     if (!(pDrvCtrl->pCfd->cfdStatus & CFD_S_OK))
  1264.         printErr ("eiDiag: i82596 diagnostics failed.n");
  1265.     }
  1267. /*******************************************************************************
  1268. *
  1269. * eiConfig - format and issue a config command
  1270. */
  1272. static void eiConfig
  1273.     (
  1274.     int unit
  1275.     )
  1276.     {
  1277.     DRV_CTRL *pDrvCtrl;
  1279.     pDrvCtrl = & drvCtrl [unit];
  1281.     bzero ((char *)pDrvCtrl->pCfd, sizeof (CFD));       /* zero command frame */
  1283.     /* Recommeded i82596 User's Manual configuration values.  Note that
  1284.      * the original manual, #296443-001, was full of errors.  Errors in the
  1285.      * description of the config bytes that I am aware of are noted below.
  1286.      * It is possible there are further errors.  Intel has replaced the
  1287.      * manual with #296853-001, which does correct some errors, but not all.
  1288.      */
  1290.     pDrvCtrl->pCfd->cfdConfig.ccByte8  = 0x8e;
  1291.     pDrvCtrl->pCfd->cfdConfig.ccByte9  = 0xc8;
  1293.     /* The manual is wrong about bit 7 in byte 10.
  1294.      * A '0' allows reception of bad packets.
  1295.      * A '1' causes rejection of bad packets.
  1296.      */
  1297.     pDrvCtrl->pCfd->cfdConfig.ccByte10 = 0xc0;
  1299.     pDrvCtrl->pCfd->cfdConfig.ccByte11 = 0x2e;      /* loopback, NSAI */
  1300.     pDrvCtrl->pCfd->cfdConfig.ccByte12 = 0x00;
  1301.     pDrvCtrl->pCfd->cfdConfig.ccByte13 = 0x60;
  1302.     pDrvCtrl->pCfd->cfdConfig.ccByte14 = 0x00;
  1303.     pDrvCtrl->pCfd->cfdConfig.ccByte15 = 0xf2;
  1304.     pDrvCtrl->pCfd->cfdConfig.ccByte16 = 0x00;      /* promiscuous off */
  1305.     pDrvCtrl->pCfd->cfdConfig.ccByte17 = 0x00;
  1306.     pDrvCtrl->pCfd->cfdConfig.ccByte18 = 0x40;
  1308.     /* The manual is wrong about 2 bits in byte 19.
  1309.      * Bit 5, multicast, a '1' disables.
  1310.      * Bit 2, include CRC, a '1' disables.
  1311.      */
  1312.     pDrvCtrl->pCfd->cfdConfig.ccByte19 = 0xff;
  1314.     pDrvCtrl->pCfd->cfdConfig.ccByte20 = 0x00;
  1315.     pDrvCtrl->pCfd->cfdConfig.ccByte21 = 0x3f;
  1318.     eiAction (unit, CFD_C_CONFIG);          /* configure the chip */
  1319.     }
  1321. /*******************************************************************************
  1322. *
  1323. * eiIASetup - format and issue an interface address command
  1324. */
  1326. static void eiIASetup
  1327.     (
  1328.     int unit
  1329.     )
  1330.     {
  1331.     DRV_CTRL *pDrvCtrl;
  1333.     pDrvCtrl = & drvCtrl [unit];
  1335.     bzero ((char *)pDrvCtrl->pCfd, sizeof (CFD));       /* zero command frame */
  1337.     bcopy   (
  1338.             (char *)pDrvCtrl->idr.ac_enaddr,
  1339.             (char *)pDrvCtrl->pCfd->cfdIASetup.ciAddress,
  1340.             6
  1341.             );
  1343.     eiAction (unit, CFD_C_IASETUP);         /* setup the address */
  1344.     }
  1346. /*******************************************************************************
  1347. *
  1348. * eiRxStartup - start up the Receive Unit
  1349. *
  1350. * Starts up the Receive Unit.  Assumes that the receive structures are set up.
  1351. */
  1353. static void eiRxStartup
  1354.     (
  1355.     DRV_CTRL *pDrvCtrl
  1356.     )
  1357.     {
  1358.     SCB *pScb = pDrvCtrl->pScb;
  1359.     void * pTemp;
  1361.     if (pScb->scbStatus & SCB_S_RUREADY)        /* already running */
  1362.         return;
  1364.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pDrvCtrl->pFreeRfd);
  1365.     LINK_WR (&pScb->pRF, pTemp);            /* point to free Rfd */
  1367.     sys596IntDisable (pDrvCtrl->idr.ac_if.if_unit);
  1369.     if ((pScb->scbStatus & SCB_S_RUMASK) != SCB_S_RUIDLE)
  1370.         eiCommand (pDrvCtrl, SCB_C_RUABORT);            /* abort if not idle */
  1372.     eiCommand (pDrvCtrl, SCB_C_RUSTART);              /* start receive unit */
  1373.     sys596IntEnable (pDrvCtrl->idr.ac_if.if_unit);
  1375.     }
  1377. /*******************************************************************************
  1378. *
  1379. * eiAction - execute the specified action with the CFD pointed to in pDrvCtrl
  1380. *
  1381. * Do the command contained in the CFD synchronously, so that we know
  1382. * it's complete upon return.  This routine assumes that interrupts from the
  1383. * device have been disabled.
  1384. */
  1386. static void eiAction
  1387.     (
  1388.     int    unit,
  1389.     UINT16 action
  1390.     )
  1391.     {
  1392.     void     *pTemp;
  1393.     CFD      *pCfd;
  1394.     SCB      *pScb;
  1395.     DRV_CTRL *pDrvCtrl;
  1397.     pDrvCtrl = & drvCtrl [unit];
  1398.     pCfd = pDrvCtrl->pCfd;
  1399.     pScb = pDrvCtrl->pScb;
  1401.     while (1)                   /* wait for idle command unit */
  1402.         {
  1403.         if ((pScb->scbStatus & SCB_S_CUMASK) == SCB_S_CUIDLE)
  1404.             break;
  1405.         }
  1407.     { /* Prepare and issue the command to the device */
  1409.     /* fill in CFD */
  1411.     pCfd->cfdStatus  = 0;                       /* clear status */
  1412.     pCfd->cfdCommand = CFD_C_EL | action;       /* fill in action */
  1413.     LINK_WR (&pCfd->link, NULL);                /* terminate link */
  1415.     /* and the SCB */
  1417.     pScb->scbCommand =
  1418.                         SCB_S_CX |              /* ack any events */
  1419.                         SCB_S_FR |
  1420.                         SCB_S_CNA |
  1421.                         SCB_S_RNR |
  1422.                         SCB_C_CUSTART;          /* start command unit */
  1424.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pCfd);
  1425.     LINK_WR (&pScb->pCB, pTemp);                /* point chip at CFD */
  1427.     sys596ChanAtn (unit);               /* notify device of new command */
  1428.     }
  1430.     while (1)               /* wait for command acceptance and interrupt */
  1431.         {
  1432.         if ((pScb->scbCommand == 0) && (pScb->scbStatus & SCB_S_CNA))
  1433.             break;
  1434.         }
  1436.     /* Acknowledge the event to the device */
  1438.     pScb->scbCommand = (SCB_S_CX | SCB_S_CNA);
  1439.     sys596ChanAtn (unit);
  1441.     while (1)               /* wait for acknowledge acceptance */
  1442.         {
  1443.         if (pScb->scbCommand == 0)
  1444.             break;
  1445.         }
  1446.     }
  1448. /*******************************************************************************
  1449. *
  1450. * eiCommand - deliver a command to the 82596 via SCB
  1451. *
  1452. * This function causes the device to execute a command.  It should be called
  1453. * with interrupts from the device disabled.  An error status is returned if
  1454. * the command field does not return to zero, from a previous command, in a
  1455. * reasonable amount of time.
  1456. */
  1458. static STATUS eiCommand
  1459.     (
  1460.     DRV_CTRL *pDrvCtrl,
  1461.     UINT16    cmd
  1462.     )
  1463.     {
  1464.     int loopy;
  1465.     SCB * pScb;
  1467.     pScb = pDrvCtrl->pScb;
  1469.     for (loopy = 0x8000; loopy--;)
  1470.         {
  1471.         if (pScb->scbCommand == 0)                  /* wait for cmd zero */
  1472.             break;
  1473.         }
  1475.     if (loopy > 0)
  1476.         {
  1477.         pScb->scbCommand = cmd;                     /* fill in command */
  1478.         sys596ChanAtn (pDrvCtrl->idr.ac_if.if_unit);    /* channel attention */
  1479.         return (OK);
  1480.         }
  1481.     else
  1482.         {
  1483.         logMsg("ei driver: command field frozenn", 0, 0, 0, 0, 0, 0);
  1484.         return (ERROR);
  1485.         }
  1486.     }
  1488. /*******************************************************************************
  1489. *
  1490. * eiTxQPut - place a transmit frame on the transmit queue
  1491. *
  1492. * The TFD has been filled in with the network pertinent data.  This
  1493. * routine will enqueue the TFD for transmission and attempt to feed
  1494. * the queue to the device.
  1495. */
  1497. static void eiTxQPut
  1498.     (
  1499.     DRV_CTRL *pDrvCtrl,
  1500.     TFD *pTfd
  1501.     )
  1502.     {
  1503.     int unit;
  1505.     unit = pDrvCtrl->idr.ac_if.if_unit;
  1507.     pTfd->status    = 0;                    /* fill in TFD fields */
  1508.     pTfd->command   = CFD_C_XMIT;           /* EL set later */
  1509.     pTfd->count     |= TFD_CNT_EOF;         /* data kept in frame */
  1510.     pTfd->reserved  = 0;                    /* must be zero */
  1512.     LINK_WR (& pTfd->lBufDesc, NULL);                /* TBDs not used */
  1514.     sys596IntDisable (pDrvCtrl->idr.ac_if.if_unit);  /* disable dev ints */
  1516.     /* enqueue the TFD */
  1517.     eiQPut (unit,(EI_LIST *)&pDrvCtrl->txQueue, (EI_NODE*)pTfd);
  1519.     if (pDrvCtrl->txIdle)                             /* transmitter idle */
  1520.         eiTxQFlush (pDrvCtrl);                        /* flush txQueue */
  1522.     sys596IntEnable (pDrvCtrl->idr.ac_if.if_unit);  /* enable dev ints */
  1523.     }
  1525. /*******************************************************************************
  1526. *
  1527. * eiTxQFlush - make cmd unit of device start processing cmds
  1528. *
  1529. * This routine flushes the contents of the txQ to the cblQ and starts the
  1530. * device transmitting the cblQ.  Called only if transmit queue is not empty.
  1531. * Sometimes called from interrupt handler.
  1532. */
  1534. static void eiTxQFlush
  1535.     (
  1536.     DRV_CTRL *pDrvCtrl
  1537.     )
  1538.     {
  1539.     void * pTemp;
  1540.     extern int sysClkRateGet();     /* we call this */
  1542.     ((TFD*)pDrvCtrl->txQueue.tail)->command |= CFD_C_EL;  /* EL terminate q */
  1543.     pDrvCtrl->cblQueue.head = pDrvCtrl->txQueue.head;   /* remember cbl head */
  1544.     pDrvCtrl->cblQueue.tail = pDrvCtrl->txQueue.tail;   /* remember cbl tail */
  1545.     eiQInit ((EI_LIST *)&pDrvCtrl->txQueue);            /* tx queue now empty */
  1547.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs,
  1548.                                     pDrvCtrl->cblQueue.head);
  1549.     LINK_WR (&pDrvCtrl->pScb->pCB, pTemp);          /* point CU to head */
  1551.     pDrvCtrl->txIdle = FALSE;                   /* transmitter busy */
  1553.     /* start command unit */
  1555.     eiCommand (pDrvCtrl, SCB_C_CUSTART);
  1556.     }
  1558. /*******************************************************************************
  1559. *
  1560. * eiRxQPut - return a RFD to the receive queue for use by the device
  1561. */
  1563. static void eiRxQPut
  1564.     (
  1565.     DRV_CTRL *pDrvCtrl,
  1566.     RFD *pRfd
  1567.     )
  1568.     {
  1569.     int unit;
  1570.     RFD *pTail;
  1572.     unit = pDrvCtrl->idr.ac_if.if_unit;
  1574.     pRfd->status    = 0;                    /* clear status */
  1575.     pRfd->command   = CFD_C_EL;             /* new end of list */
  1576.     pRfd->actualCnt  = 0;                   /* clear actual count */
  1577.     pRfd->bufSize   = ETHERMTU + EH_SIZE;   /* fill in size */
  1578.     pRfd->refCnt    = 0;                    /* initialize ref cnt */
  1580.     LINK_WR (& pRfd->lBufDesc, 0xffffffff);         /* no RBD used */
  1582.     pTail = (RFD *) pDrvCtrl->rxQueue.tail;         /* remember tail */
  1584.     /* Put the RFD on the list */
  1586.     eiQPut (unit, (EI_LIST *) & pDrvCtrl->rxQueue, (EI_NODE *) pRfd);
  1588.     if (pTail != NULL)
  1589.         {
  1590.         pDrvCtrl->wdRxTimeout = 0;          /* reset timeout count */
  1592.         pTail->command &= ~CFD_C_EL;        /* clear old tail EL */
  1594.         if (pTail->status & (CFD_S_COMPLETE | CFD_S_BUSY))
  1595.             {
  1596.             pDrvCtrl->pFreeRfd = pRfd;          /* link questionable */
  1597.             }
  1598.         else if (!(pDrvCtrl->pScb->scbStatus & SCB_S_RUREADY))
  1599.             /* receiver dormant */
  1600.             {
  1601.             eiRxStartup (pDrvCtrl);             /* start receive unit */
  1602.             }
  1603.         }
  1604.     else
  1605.         {
  1606.         pDrvCtrl->pFreeRfd = pRfd;              /* first free RFD */
  1607.         }
  1608.     }
  1610. /*******************************************************************************
  1611. *
  1612. * eiRxQGet - get a successfully received frame from the receive queue
  1613. *
  1614. * RETURNS: ptr to valid RFD, or NULL if none available
  1615. */
  1617. static RFD *eiRxQGet
  1618.     (
  1619.     DRV_CTRL *pDrvCtrl
  1620.     )
  1621.     {
  1622.     RFD *pRfd = NULL;
  1624.     if (eiRxQFull (pDrvCtrl))
  1625.         pRfd = (RFD *) eiQGet ((EI_LIST *)&pDrvCtrl->rxQueue);
  1627.     return (pRfd);
  1628.     }
  1630. /*******************************************************************************
  1631. *
  1632. * eiRxQFull - boolean function to determine fullness of receive queue
  1633. *
  1634. * RETURNS: TRUE if completely received frame is available, FALSE otherwise.
  1635. */
  1637. static BOOL eiRxQFull
  1638.     (
  1639.     DRV_CTRL *pDrvCtrl
  1640.     )
  1641.     {
  1642.     return ((pDrvCtrl->rxQueue.head != NULL) &&
  1643.         (((RFD*)pDrvCtrl->rxQueue.head)->status & CFD_S_COMPLETE));
  1644.     }
  1646. /*******************************************************************************
  1647. *
  1648. * eiQInit - initialize a singly linked node queue
  1649. */
  1651. static void eiQInit
  1652.     (
  1653.     EI_LIST *pQueue
  1654.     )
  1655.     {
  1656.     pQueue->head = pQueue->tail = NULL;         /* init head & tail */
  1657.     }
  1659. /*******************************************************************************
  1660. *
  1661. * eiQGet - get a node from the head of a node queue
  1662. *
  1663. * RETURNS: ptr to useable node, or NULL ptr if none available
  1664. */
  1666. static EI_NODE *eiQGet
  1667.     (
  1668.     EI_LIST *pQueue
  1669.     )
  1670.     {
  1671.     EI_NODE *pNode;
  1673.     if ((pNode = (EI_NODE *) pQueue->head) != NULL)     /* if list not empty */
  1674.         pQueue->head = (EI_NODE *) LINK_RD ( (EI_LINK *) &pNode->pNext);    /* advance ptr */
  1676.     return (pNode);
  1677.     }
  1679. /*******************************************************************************
  1680. *
  1681. * eiQPut - put a node on the tail of a node queue
  1682. */
  1684. static void eiQPut
  1685.     (
  1686.     int unit,
  1687.     EI_LIST *pQueue,
  1688.     EI_NODE *pNode
  1689.     )
  1690.     {
  1691.     void * pTemp;
  1692.     DRV_CTRL *pDrvCtrl;
  1694.     pDrvCtrl = & drvCtrl [unit];
  1696.     LINK_WR (&pNode->lNext, NULL);                    /* mark "end of list" */
  1697.     LINK_WR ((EI_LINK *) &pNode->pNext, NULL);
  1699.     if (pQueue->head == NULL)                        /* if list empty */
  1700.         pQueue->tail = pQueue->head = pNode;         /* set both ptrs */
  1701.     else
  1702.         {
  1703.         pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pNode);
  1704.         LINK_WR (&pQueue->tail->lNext, pTemp);       /* link node on tail */
  1705.         LINK_WR ((EI_LINK *) & pQueue->tail->pNext, pNode);
  1706.         pQueue->tail = pNode;                        /* update tail ptr */
  1707.         }
  1708.     }
  1710. /*******************************************************************************
  1711. *
  1712. * eiWatchDog - if the watchdog timer fired off, we've hung during a transmit
  1713. *
  1714. * Check the scb command to verify and if so, reinit.
  1715. */
  1717. static void eiWatchDog
  1718.     (
  1719.     int unit        /* unit number */
  1720.     )
  1722.     {
  1723.     DRV_CTRL *pDrvCtrl = &drvCtrl [unit];
  1724.     SCB *pScb;
  1725.     int reset = FALSE;
  1726.     pScb = pDrvCtrl->pScb;
  1729.     /* Test for transmit timeout.
  1730.      *
  1731.      * Timeout occurs if the scb status indicates that CU (transmit) 
  1732.      * remains active for EI_TX_TIMEOUT iterations of eiWatchDog.
  1733.      * It might make sense to loop through the cfd's to look for
  1734.      * a complete bit as a sanity check, but given that transmit
  1735.      * was active, we will go ahead and do a reset.
  1736.      */
  1737.     if ((pDrvCtrl->txIdle == FALSE)
  1738.         && (pScb->scbStatus & SCB_S_CUACTIVE))
  1739.         {
  1740.         if (++(pDrvCtrl->wdTxTimeout) > EI_TX_TIMEOUT)
  1741.             {
  1742.             pDrvCtrl->transLocks++;   /* failure count */
  1743.             pDrvCtrl->idr.ac_if.if_oerrors++;             /* incr err count */
  1744.             pDrvCtrl->idr.ac_if.if_opackets--;            /* decr sent count */
  1745.             reset = TRUE;
  1746.             }
  1747.         }
  1749.     /* Test for receive timeout.
  1750.      *
  1751.      * Timeout occurs if the scb status indicates that RU (receive) 
  1752.      * remains out of resources for EI_RX_TIMEOUT iterations of eiWatchDog.
  1753.      */
  1754.     if (pScb->scbStatus & SCB_S_RUNORSRC)
  1755.         {
  1756.         if (++(pDrvCtrl->wdRxTimeout) > EI_RX_TIMEOUT)
  1757.             {
  1758.             pDrvCtrl->recvLocks++;   /* failure count */
  1759.             reset = TRUE;
  1760.             }
  1761.         }
  1763.     /* reinitialize the unit or restart the watchdog */
  1765.     if (reset)
  1766. netJobAdd ((FUNCPTR) eiInit, unit, 0, 0, 0, 0);
  1767.     else
  1768.         wdStart (pDrvCtrl->wid, 
  1769. (int) pDrvCtrl->wdInterval, 
  1770. (FUNCPTR) eiWatchDog, 
  1771. unit);
  1772.     }
  1774. /******************************************************************************/
  1776. /* END OF FILE */