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

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

VxWorks

开发平台：

C/C++

if_ei.c：源码内容
  1. /* if_ei.c - Intel 82596 Ethernet network interface driver */
  3. /* Copyright 1989-1997 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 03i,15jul97,spm  added ARP request to SIOCSIFADDR ioctl handler
  10. 03i,29aug97,dgp  doc: SPR 9184 - promiscuous mode not supported
  11. 03h,05feb97,dat  fixed wdog reset action to use netJobAdd(). SPR 7771
  12. 03j,07apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  13. 03i,12nov94,tmk  removed some IMPORTed function decs and included unixLib.h
  14. 03h,10oct94,caf  suppress buffer loaning for MIPS targets due to
  15.  problem with misaligned accesses.
  16. 03g,14oct93,wmd  Added initialization of pointer pDrvCtrl in eiWatchDog(),
  17.  SPR #2567.
  18. 03f,30sep93,wmd  Added changes to include timeout check of the receiver 
  19.  as done in the 5.0.6 release. Recreated eiInit() to allow
  20.  resetting the 596 if it locks up.
  21. 03e,11aug93,jmm  Changed ioctl.h and socket.h to sys/ioctl.h and sys/socket.h
  22. 03d,19feb93,jdi  documentation cleanup.
  23. 03c,15jan93,wmd  added setting of errno to S_ioslib_INVALID_ETHERNET_ADDRESS.
  24. 03b,11dec92,rfs  Removed dummy eiChipReset(), no longer needed for TP41.
  25. 03a,05oct92,rfs  Added documentation.
  26. 02z,02oct92,rfs  Made multiple attach calls per unit return OK, not ERROR.
  27. 02y,01oct92,rfs  Added 16 byte page alignment for SCP.
  28. 02x,28sep92,rfs  Modified the eiAction() routine to clear all events.  This
  29.                  makes the diagnostics pass, for some undocumented reason.
  30. 02w,09sep92,gae  documentation tweaks.
  31. 02v,11aug92,rfs  Slight change to memory carving.  Also fixed receive bug
  32.                  that was due to device manual incorrectly describing bit 7
  33.                  of config byte 10 and added error checks to RFDs.  Changed
  34.                  the device startup routine.
  35. 02u,26aug92,kdl  moved internal notes to file header (were just #ifdef'd out).
  36. 02t,19aug92,smb  changed systime.h to sys/times.h
  37. 02s,31jul92,dave Changed to new cacheLib.
  38. 02r,28jul92,rfs  Adapted to latest cache coherency model.
  39.                  Renamed driver control structure and moved it to bss.
  40.                  Combined the init() routine with the attach() routine and
  41.                  made attach() reject multiple invocations.  Rewrote the
  42.                  ioctl() routine to do the right stuff.  Reworked the action
  43.                  command routine and the primary command routine.  Other misc.
  44. 02q,16jul92,rfs  Moved driver specific items from header file to here,
  45.                  where they belong.
  46. 02p,16jul92,rfs  Moved internal comments to end of file, where they belong.
  47. 02o,03jul92,jwt  converted cacheClearEntry() calls to cacheClear() for 5.1.
  48. 02n,26jun92,rrr  make eiBusSnoop global again (needed by bsps)
  49. 02m,25jun92,rfs  backed out last mod; the manual is incorrect about the
  50.                  state of the bit that configures CRC inclusion
  51. 02l,25jun92,rfs  bug fix, changed a receive config parm that selects whether
  52.                  the CRC is included in the buffer
  53. 02k,23jun92,ajm  made eiChipReset global for tp41 BSP
  54. 02j,08jun92,ajm  modified so eiattach is only external function
  55.                  got rid of MEM_ROUND_UP macro now pulled in with vxWorks.h
  56.                  got rid of many ansi complaints
  57. 02i,26may92,rrr  the tree shuffle
  58.                  -changed includes to have absolute path from h/
  59. 02h,22feb92,wmd  added conditional compiles for 040, ansi fixes.
  60. 02g,07jan92,shl  made driver cache safe. added eiBusSnoop(). eliminated some
  61.                  ANSI warnings.
  62. 02f,12nov91,wmd  Added fix, courtesy of jrb-Intel, which added a watchdog to
  63.                  timeout any stalls due to hardware lockup and resets the
  64.                  82596.
  65. 02e,25oct91,rfs  Changed eiChipReset() to not depend on valid *es, and
  66.                  made it global for TP41 usage. Also eliminated ANSI
  67.                  warnings.
  68. 02d,04oct91,rrr  passed through the ansification filter
  69.                  -changed functions to ansi style
  70.                  -changed includes to have absolute path from h/
  71.                  -changed VOID to void
  72.                  -changed copyright notice
  73. 02c,15sep91,rfs  Bug fix. Eliminated lock condition when output queue full
  74.                  and out of TFDs. Added major comment to eiTxStartup. Also,
  75.                  major changes to eiChipReset() to make more robust. All
  76.                  instances of intLock()/intUnlock() changed to
  77.                  sys596IntDisable()/sys596IntEnable respectively. Statistic
  78.                  counters now being used, which required moderate changes to
  79.                  the transmit side design. More comments added.
  80. 02b,21aug91,rfs  changed method of obtaining Ethernet address.
  81. 02a,22jul91,jcf  completely rewritten to utilize simplified mode,
  82.             rfs  added big endian support, reworked buffer loaning.
  83. 01h,01may91,elh  fixed ethernet addressing problem, upgraded to 5.0,
  84.                  added buffer loanouts, fixed ifAddrSet bug by disabling
  85.                  interrupts in eiHardReset.
  86. 01g,28apr91,del  added #define of ETHER_HEADER_SIZE as workaround for
  87.                  gnu960 pading of struct ether_header.
  88. 01f,05jan91,gae  added global eiSCPSysConfig for board specific SCP parameters.
  89.                  moved CDELAY here from if_ei.h and renamed eichkcca.
  90. 01e,03jan91,gae  more cleanup and merged with Intel's fixes.
  91.                  Ethernet address (eiEnetAddr) is set in sysHwInit.
  92.                  cleaned up error printing & no carrier message always printed.
  93.                  changed printf's to printErr's (logMsg if at int level).
  94.                  made most routines local -- not available outside this module.
  95. 01d,31dec90,gae  removed 68K stuff.
  96. 01c,14dec90,elh  more cleanup.
  97. 01b,12dec90,elh  fixed buffer problems, cleaned up, added etherhooks.
  98. 01a,06feb90,djk  written
  99. */
  101. /*
  102. This module implements the Intel 82596 Ethernet network interface driver.
  104. This driver is designed to be moderately generic, operating unmodified
  105. across the range of architectures and targets supported by VxWorks.  
  106. To achieve this, this driver must be given several
  107. target-specific parameters, and some external support routines must be
  108. provided.  These parameters, and the mechanisms used to communicate them to the
  109. driver, are detailed below.
  111. This driver can run with the device configured in either
  112. big-endian or little-endian modes.  Error recovery code has been added to
  113. deal with some of the known errata in the A0 version of the device.  This
  114. driver supports up to four individual units per CPU.
  116. BOARD LAYOUT
  117. This device is on-board.  No jumpering diagram is necessary.
  119. EXTERNAL INTERFACE
  120. This driver provides the standard external interface with the following
  121. exceptions.  All initialization is performed within the attach routine;
  122. there is no separate initialization routine.  Therefore, in the global interface
  123. structure, the function pointer to the initialization routine is NULL.
  125. The only user-callable routine is eiattach(), which publishes the `ei'
  126. interface and initializes the driver and device.
  128. TARGET-SPECIFIC PARAMETERS
  129. .iP "the <sysbus> value"
  130. This parameter is passed to the driver by eiattach().
  132. The Intel 82596 requires this parameter during initialization.  This
  133. parameter tells the device about the system bus, hence the name "sysbus."
  134. To determine the correct value for a target, refer to the document
  135. .I "Intel 32-bit Local Area Network (LAN) Component User's Manual."
  136. .iP "interrupt vector"
  137. This parameter is passed to the driver by eiattach().
  139. The Intel 82596 generates hardware interrupts for various events within
  140. the device; thus it contains an interrupt handler routine.
  141. This driver calls intConnect() to connect its interrupt handler to the 
  142. interrupt vector generated as a result of the 82596 interrupt.
  143. .iP "shared memory address"
  144. This parameter is passed to the driver by eiattach().
  146. The Intel 82596 device is a DMA type device and typically shares
  147. access to some region of memory with the CPU.  This driver is designed
  148. for systems that directly share memory between the CPU and the 82596.
  150. This parameter can be used to specify an explicit memory region for use
  151. by the 82596.  This should be done on targets that restrict the 82596
  152. to a particular memory region.  The constant NONE can be used to indicate
  153. that there are no memory limitations, in which case, the driver 
  154. attempts to allocate the shared memory from the system space.
  155. .iP "number of Receive and Transmit Frame Descriptors"
  156. These parameters are passed to the driver by eiattach().
  158. The Intel 82596 accesses frame descriptors in memory for each frame
  159. transmitted or received.  The number of frame descriptors 
  160. at run-time can be configured using these parameters.
  161. .iP "Ethernet address"
  162. This parameter is obtained by a call to an external support routine.
  164. During initialization, the driver needs to know the Ethernet address for
  165. the Intel 82596 device.  The driver calls the external support routine,
  166. sysEnetAddrGet(), to obtain the Ethernet address.  For a description of
  167. sysEnetAddrGet(), see "External Support Requirements" below.
  168. .LP
  170. EXTERNAL SUPPORT REQUIREMENTS
  171. This driver requires seven external support functions:
  172. .iP "STATUS sysEnetAddrGet (int unit, char *pCopy)" "" 9 -1
  173. This routine provides the six-byte Ethernet address
  174. used by <unit>.  It must copy the six-byte address
  175. to the space provided by <pCopy>.  This routine 
  176. returns OK, or ERROR if it fails.  The driver calls this 
  177. routine, once per unit, using eiattach().
  178. .iP "STATUS sys596Init (int unit)"
  179. This routine performs any target-specific initialization
  180. required before the 82596 is initialized.  Typically, it is empty.  
  181. This routine must return OK, or ERROR if it fails.
  182. The driver calls this routine, once per unit, using eiattach().
  183. .iP "void sys596Port (int unit, int cmd, UINT32 addr)"
  184. This routine provides access to the special port
  185. function of the 82596.  It delivers the command and
  186. address arguments to the port of the specified unit.
  187. The driver calls this routine primarily during
  188. initialization, but may also call it during error
  189. recovery procedures.
  190. .iP "void sys596ChanAtn (int unit)"
  191. This routine provides the channel attention signal to
  192. the 82596, for the specified <unit>.  The driver calls
  193. this routine frequently throughout all phases of
  194. operation.
  195. .iP "void sys596IntEnable (int unit), void sys596IntDisable (int unit)"
  196. These routines enable or disable the interrupt from
  197. the 82596 for the specified <unit>.  Typically, this
  198. involves interrupt controller hardware, either
  199. internal or external to the CPU.  Since the 82596
  200. itself has no mechanism for controlling its interrupt
  201. activity, these routines are vital to the correct
  202. operation of the driver.  The driver calls these
  203. routines throughout normal operation to protect
  204. certain critical sections of code from interrupt
  205. handler intervention.
  206. .iP "void sys596IntAck (int unit)"
  207. This routine must perform any required interrupt acknowledgment 
  208. or clearing.  Typically, this involves an operation to some interrupt
  209. control hardware.  Note that the INT signal from the 82596
  210. behaves in an "edge-triggered" mode; therefore, this routine 
  211. typically clears a latch within the control circuitry.
  212. The driver calls this routine from the interrupt handler.
  213. .LP
  215. SYSTEM RESOURCE USAGE
  216. When implemented, this driver requires the following system resources:
  218.     - one mutual exclusion semaphore
  219.     - one interrupt vector
  220.     - one watchdog timer.
  221.     - 8 bytes in the initialized data section (data)
  222.     - 912 bytes in the uninitialized data section (BSS)
  224. The above data and BSS requirements are for the MC68020 architecture 
  225. and may vary for other architectures.  Code size (text) varies greatly between
  226. architectures and is therefore not quoted here.
  228. The driver uses cacheDmaMalloc() to allocate memory to share with the 82596.  
  229. The fixed-size pieces in this area total 160 bytes.  The variable-size 
  230. pieces in this area are affected by the configuration parameters specified 
  231. in the eiattach() call.  The size of one RFD (Receive Frame
  232. Descriptor) is 1536 bytes.  The size of one TFD (Transmit Frame Descriptor) 
  233. is 1534 bytes.  For more information about RFDs and TFDs, see the 
  234. .I "Intel 82596 User's Manual."
  236. The 82596 can be operated only if this shared memory region is non-cacheable
  237. or if the hardware implements bus snooping.  The driver cannot maintain
  238. cache coherency for the device because fields within the command
  239. structures are asynchronously modified by both the driver and the device,
  240. and these fields may share the same cache line.
  243. TUNING HINTS
  244. The only adjustable parameters are the number of TFDs and RFDs that will be
  245. created at run-time.  These parameters are given to the driver when eiattach()
  246. is called.  There is one TFD and one RFD associated with each transmitted
  247. frame and each received frame respectively.  For memory-limited applications,
  248. decreasing the number of TFDs and RFDs may be desirable.  Increasing the number
  249. of TFDs will provide no performance benefit after a certain point.
  250. Increasing the number of RFDs will provide more buffering before packets are
  251. dropped.  This can be useful if there are tasks running at a higher priority
  252. than the net task.
  254. CAVEAT
  255. This driver does not support promiscuous mode.
  257. SEE ALSO: ifLib,
  258. .I "Intel 82596 User's Manual,"
  259. .I "Intel 32-bit Local Area Network (LAN) Component User's Manual"
  260. */
  262. #include "vxWorks.h"
  263. #include "wdLib.h"
  264. #include "iv.h"
  265. #include "vme.h"
  266. #include "net/mbuf.h"
  267. #include "net/unixLib.h"
  268. #include "net/protosw.h"
  269. #include "sys/socket.h"
  270. #include "sys/ioctl.h"
  271. #include "errno.h"
  272. #include "memLib.h"
  273. #include "intLib.h"
  274. #include "net/if.h"
  275. #include "net/route.h"
  276. #include "iosLib.h"
  277. #include "errnoLib.h"
  279. #include "cacheLib.h"
  280. #include "logLib.h"
  281. #include "netLib.h"
  282. #include "stdio.h"
  283. #include "stdlib.h"
  284. #include "sysLib.h"
  286. #ifdef  INET
  287. #include "netinet/in.h"
  288. #include "netinet/in_systm.h"
  289. #include "netinet/in_var.h"
  290. #include "netinet/ip.h"
  291. #include "netinet/if_ether.h"
  292. #endif  /* INET */
  294. #include "etherLib.h"
  295. #include "net/systm.h"
  296. #include "sys/times.h"
  297. #include "drv/netif/if_ei.h"
  298. #include "net/if_subr.h"
  301. /***** LOCAL DEFINITIONS *****/
  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);
  386. /***** LOCALS *****/
  388. /* The array of driver control structs */
  390. LOCAL DRV_CTRL drvCtrl [MAX_UNITS];
  393. /* forward function declarations */
  395. static STATUS eiInit (int unit);
  396. static void eiReset (int unit);
  397. static int eiIoctl (IFNET *pIfNet, int cmd, caddr_t data);
  398. static void eiTxStartup (DRV_CTRL * pDrvCtrl);
  399. static void eiInt (DRV_CTRL *pDrvCtrl);
  400. static void eiTxCleanQ (DRV_CTRL *pDrvCtrl);
  401. static void eiHandleRecvInt (DRV_CTRL *pDrvCtrl);
  402. static STATUS eiReceive (DRV_CTRL *pDrvCtrl, RFD *pRfd);
  403. static void eiLoanFree (DRV_CTRL *pDrvCtrl, RFD *pRfd);
  404. static void eiDiag (int unit);
  405. static void eiConfig (int unit);
  406. static void eiIASetup (int unit);
  407. static void eiRxStartup (DRV_CTRL *pDrvCtrl);
  408. static void eiAction (int unit, UINT16 action);
  409. static STATUS eiCommand (DRV_CTRL *pDrvCtrl, UINT16 cmd);
  410. static void eiTxQPut (DRV_CTRL *pDrvCtrl, TFD *pTfd);
  411. static void eiTxQFlush (DRV_CTRL *pDrvCtrl);
  412. static void eiRxQPut (DRV_CTRL *pDrvCtrl, RFD *pRfd);
  413. static RFD *eiRxQGet (DRV_CTRL *pDrvCtrl);
  414. static BOOL eiRxQFull (DRV_CTRL *pDrvCtrl);
  415. static void eiQInit (EI_LIST *pHead);
  416. static EI_NODE *eiQGet (EI_LIST *pQueue);
  417. static void eiQPut (int unit, EI_LIST *pQueue, EI_NODE *pNode);
  418. static STATUS eiDeviceStart (int unit);
  419. static void eiWatchDog(int unit);
  421. /*******************************************************************************
  422. *
  423. * eiattach - publish the `ei' network interface and initialize the driver and device
  424. *
  425. * This routine publishes the `ei' interface by filling in a network interface
  426. * record and adding this record to the system list.  This routine also
  427. * initializes the driver and the device to the operational state.
  428. *
  429. * The 82596 shares a region of memory with the driver.  The caller of this
  430. * routine can specify the address of this memory region, or can specify that
  431. * the driver must obtain this memory region from the system resources.
  432. *
  433. * The <sysbus> parameter accepts values as described in the Intel manual
  434. * for the 82596.  A default number of transmit/receive frames of 32 can be
  435. * selected by passing zero in the parameters <nTfds> and <nRfds>.
  436. * In other cases, the number of frames selected should be greater than two.
  437. *
  438. * The <memBase> parameter is used to inform the driver about the shared
  439. * memory region.  If this parameter is set to the constant "NONE," then this
  440. * routine will attempt to allocate the shared memory from the system.  Any
  441. * other value for this parameter is interpreted by this routine as the address
  442. * of the shared memory region to be used.
  443. *
  444. * If the caller provides the shared memory region, then the driver assumes
  445. * that this region does not require cache coherency operations, nor does it
  446. * require conversions between virtual and physical addresses.
  447. *
  448. * If the caller indicates that this routine must allocate the shared memory
  449. * region, then this routine will use cacheDmaMalloc() to obtain
  450. * some  non-cacheable memory.  The attributes of this memory will be checked,
  451. * and if the memory is not both read and write coherent, this routine will
  452. * abort and return ERROR.
  453. *
  454. * RETURNS: OK or ERROR.
  455. *
  456. * SEE ALSO: ifLib,
  457. * .I "Intel 82596 User's Manual"
  458. */
  460. STATUS eiattach
  461.     (
  462.     int         unit,       /* unit number */
  463.     int         ivec,       /* interrupt vector number */
  464.     UINT8       sysbus,     /* sysbus field of SCP */
  465.     char *      memBase,    /* address of memory pool or NONE */
  466.     int         nTfds,      /* no. of transmit frames (0 = default) */
  467.     int         nRfds       /* no. of receive frames (0 = default) */
  468.     )
  469.     {
  470.     DRV_CTRL    *pDrvCtrl;
  471.     UINT        size;                           /* temporary size holder */
  472.     UINT        sizeScp;
  473.     UINT        sizeIscp;
  474.     UINT        sizeScb;
  475.     UINT        sizeCfd;
  476.     RFD *       pRfd;                   /* pointer to RFD's */
  477.     int         ix;
  479.     static char *errMsg1 = "neiattach: could not obtain memoryn";
  480.     static char *errMsg2 = "neiattach: shared memory not cache coherentn";
  482.     sizeScp  = MEM_ROUND_UP (sizeof (SCP));
  483.     sizeIscp = MEM_ROUND_UP (sizeof (ISCP));
  484.     sizeScb  = MEM_ROUND_UP (sizeof (SCB));
  485.     sizeCfd  = MEM_ROUND_UP (sizeof (CFD));
  487.     /* Sanity check the unit number */
  489.     if (unit < 0 || unit >= MAX_UNITS)
  490.         return (ERROR);
  492.     /* Ensure single invocation per system life */
  494.     pDrvCtrl = & drvCtrl [unit];
  495.     if (pDrvCtrl->attached)
  496.         return (OK);
  498.     /* Determine number of Tx and Rx descriptors to use */
  500.     pDrvCtrl->nTFDs = nTfds ? nTfds : DEF_NUM_TFDS;
  501.     pDrvCtrl->nRFDs = nRfds ? nRfds : DEF_NUM_RFDS;
  504.     /* calculate the total size of 82596 memory pool */
  506.     size =
  507.             16 +                                /* allow for alignment */
  508.             sizeScp +
  509.             sizeIscp +
  510.             sizeScb +
  511.             sizeCfd +                           /* synch'ed command frame */
  512.             (sizeof (RFD) * pDrvCtrl->nRFDs) +  /* pool of receive frames */
  513.             (sizeof (TFD) * pDrvCtrl->nTFDs);   /* pool of transmit frames */
  515.     /* Establish the memory area that we will share with the device.  If
  516.      * the caller has provided an area, then we assume it is non-cacheable
  517.      * and will not require the use of the special cache routines.
  518.      * If the caller did not provide an area, then we must obtain it from
  519.      * the system, using the cache savvy allocation routine.
  520.      */
  522.     switch ((int) memBase)
  523.         {
  524.         case NONE :                            /* we must obtain it */
  526.             /* this driver can't handle incoherent caches */
  528.             if (!CACHE_DMA_IS_WRITE_COHERENT () ||
  529.                 !CACHE_DMA_IS_READ_COHERENT ())
  530.                 {
  531.                 printf (errMsg2);
  532.                 goto error;
  533.                 }
  535.             pDrvCtrl->memBase = cacheDmaMalloc (size);
  537.             if (pDrvCtrl->memBase == NULL)    /* no memory available */
  538.                 {
  539.                 printf (errMsg1);
  540.                 goto error;
  541.                 }
  543.             pDrvCtrl->cacheFuncs = cacheDmaFuncs;
  544.             break;
  546.         default :                               /* the user provided an area */
  547.             pDrvCtrl->memBase = memBase;        /* use the provided address */
  548.             pDrvCtrl->cacheFuncs = cacheNullFuncs;
  549.             break;
  550.         }
  552.     /* Save other passed-in parameters */
  554.     pDrvCtrl->sysbus = sysbus;                  /* remember sysbus value */
  555.     pDrvCtrl->ivec = ivec;                      /* interrupt vector */
  557.     /* Carve up the shared memory region into the specific sections */
  559.     bzero ((char *) pDrvCtrl->memBase, size);
  560.     pDrvCtrl->pScp  = (SCP *)                /* align to first 16 byte page */
  561.                       ( ((u_long) pDrvCtrl->memBase + 0xf) & ~0xf );
  562.     pDrvCtrl->pIscp = (ISCP *)((int)pDrvCtrl->pScp   + sizeScp);
  563.     pDrvCtrl->pScb  = (SCB *) ((int)pDrvCtrl->pIscp  + sizeIscp);
  564.     pDrvCtrl->pCfd  = (CFD *) ((int)pDrvCtrl->pScb   + sizeScb);
  565.     pDrvCtrl->rfdPool   = (RFD *) ((int)pDrvCtrl->pCfd   + sizeCfd);
  566.     pDrvCtrl->tfdPool = (TFD *)
  567.             ((int)pDrvCtrl->rfdPool+ (sizeof (RFD) * pDrvCtrl->nRFDs));
  569.     for (ix = 0, pRfd = pDrvCtrl->rfdPool; ix < DEF_NUM_RFDS; ix++, pRfd++)
  570.         {
  571.         pRfd->refCnt = 0;                    /* initialize ref cnt */
  572.         }
  574.     /* Init the watchdog that will patrol for device lockups */
  575.  
  576.     pDrvCtrl->transLocks = 0;
  577.     pDrvCtrl->recvLocks = 0;
  578.     pDrvCtrl->wid = wdCreate ();                      /* create watchdog */
  579.     if (pDrvCtrl->wid == NULL)                        /* no resource */
  580.         goto error;
  581.     pDrvCtrl->wdInterval = sysClkRateGet() >> 1;
  583.     /* get our enet addr */
  585.     if (sysEnetAddrGet (unit, (char *)pDrvCtrl->idr.ac_enaddr) == ERROR)
  586. {
  587. errnoSet (S_iosLib_INVALID_ETHERNET_ADDRESS);
  588.         goto error;
  589. }
  591.     /* Publish the interface record */
  592.     ether_attach    (
  593.                     (IFNET *) & pDrvCtrl->idr,
  594.                     unit,
  595.                     "ei",
  596.                     (FUNCPTR) NULL,
  597.                     (FUNCPTR) eiIoctl,
  598.                     (FUNCPTR) ether_output, /* generic ether_output */
  599.                     (FUNCPTR) eiReset
  600.                     );
  602.     pDrvCtrl->idr.ac_if.if_start = (FUNCPTR)eiTxStartup;
  604.     /* initialize the unit */
  606.     if (eiInit (unit) == ERROR)
  607.         goto error;
  609.     /* Set our flag */
  611.     pDrvCtrl->attached = TRUE;
  613.     /* Set status flags in IDR */
  615.     pDrvCtrl->idr.ac_if.if_flags |= (IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);
  617.     /* Successful return */
  619.     return (OK);
  621.     /***** Handle error cases *****/
  623.     error:
  625.         {
  626.         /* Release system memory */
  628.         if (((int) memBase == NONE) && ((int) pDrvCtrl->memBase != NULL))
  629.             cacheDmaFree (pDrvCtrl->memBase);
  631.         /* Release watchdog */
  633.         if (pDrvCtrl->wid != NULL)
  634.             wdDelete (pDrvCtrl->wid);
  636.         return (ERROR);
  637.         }
  638.     }
  641. /*******************************************************************************
  642. *
  643. * eiInit - Initialize the interface.
  644. *
  645. * Initialization of interface; clear recorded pending operations.
  646. * Called at boot time and by eiWatchDog() if a reset is required.
  647. *
  648. * RETURNS: OK or ERROR
  649. */
  651. static STATUS eiInit 
  652.     (
  653.     int unit /* unit number */
  654.     )
  655.     {
  656.     DRV_CTRL    *pDrvCtrl = & drvCtrl [unit];
  658.     pDrvCtrl->rcvHandling   = FALSE;  /* netTask not running our receive job */
  659.     pDrvCtrl->txCleaning    = FALSE;  /* netTask not running our clean job */
  660.     pDrvCtrl->txIdle        = TRUE;         /* transmitter idle */
  661.     eiQInit ((EI_LIST *)&pDrvCtrl->rxQueue);    /* to be received queue */
  662.     eiQInit ((EI_LIST *)&pDrvCtrl->txQueue);    /* to be sent queue */
  663.     eiQInit ((EI_LIST *)&pDrvCtrl->tfdQueue);   /* free tfds to add to send q */
  664.     eiQInit ((EI_LIST *)&pDrvCtrl->cblQueue);   /* actively sending queue */
  665.     eiQInit ((EI_LIST *)&pDrvCtrl->cleanQueue); /* queue of TFDs to clean */
  667.     pDrvCtrl->wdTxTimeout = 0;
  668.     pDrvCtrl->wdRxTimeout = 0;
  671.     { /***** Perform device initialization *****/
  673.     /* Block local variables */
  675.     int ix;
  677.     sys596IntDisable (unit);            /* disable device interrupts */
  678.     (void) sys596Init (unit);           /* do board specific init */
  680.     /* Connect the interrupt handler */
  682.     if (intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (pDrvCtrl->ivec),
  683.     eiInt, (int)pDrvCtrl) == ERROR)
  684.         return (ERROR);
  686.     /* Start the device */
  688.     if ( eiDeviceStart (unit) == ERROR )
  689.         return (ERROR);
  691.     eiDiag (unit);                             /* run diagnostics */
  692.     eiConfig (unit);                           /* configure chip */
  693.     eiIASetup (unit);                          /* setup address */
  695.     for (ix = 0; ix < pDrvCtrl->nTFDs; ix ++)  /* tank up the free tfd queue */
  696.         {
  697.         eiQPut  (
  698.                 unit,
  699.                 (EI_LIST *) & pDrvCtrl->tfdQueue,
  700.                 (EI_NODE *) & pDrvCtrl->tfdPool [ix]
  701.                 );
  702.         }
  704.     pDrvCtrl->pFreeRfd  = NULL;                  /* first free RFD */
  705.     pDrvCtrl->nLoanRfds = MAX_RFDS_LOANED;       /* number of loanable RFD's */
  707.     for (ix = 0; ix < pDrvCtrl->nRFDs; ix ++)   /* tank up the receive queue */
  708. {
  709. if (pDrvCtrl->rfdPool[ix].refCnt == 0)
  710.         eiRxQPut (pDrvCtrl, & pDrvCtrl->rfdPool [ix]);
  711. }
  713.     sys596IntAck (unit);                     /* clear any pended dev ints */
  714.     sys596IntEnable (unit);                  /* enable interrupts at system */
  716.     } /* End block */
  718.     wdCancel(pDrvCtrl->wid);                  /* in case re-initializing */
  719.     wdStart(pDrvCtrl->wid, 
  720.     (int) pDrvCtrl->wdInterval, 
  721.     (FUNCPTR) eiWatchDog, 
  722.     pDrvCtrl->idr.ac_if.if_unit
  723.    );
  725.     return (OK);
  726.     }
  728. /*******************************************************************************
  729. *
  730. * eiReset - reset the ei interface
  731. *
  732. * Mark interface as inactive and reset the chip.
  733. */
  735. static void eiReset
  736.     (
  737.     int unit
  738.     )
  739.     {
  740.     DRV_CTRL *pDrvCtrl;
  742.     pDrvCtrl = & drvCtrl [unit];
  744.     pDrvCtrl->idr.ac_if.if_flags = 0;
  745.     sys596IntDisable (unit);                    /* disable ints from the dev */
  746.     sys596Port (unit, PORT_RESET, NULL);        /* reset the 596 chip */
  748.     }
  750. /*******************************************************************************
  751. *
  752. * eiIoctl - interface ioctl procedure
  753. *
  754. * Process an interface ioctl request.
  755. */
  757. static int eiIoctl
  758.     (
  759.     IFNET *  pIfNet,
  760.     int  cmd,
  761.     caddr_t  data
  762.     )
  763.     {
  764.     int error;
  766. #ifdef EI_DEBUG
  767.     printf ("ei: ioctl: pIDR=%x cmd=%x data=%xn", pIDR, cmd, data);
  768. #endif /* EI_DEBUG */
  770.     error = 0;
  772.     switch (cmd)
  773.         {
  774.         case SIOCSIFADDR:
  775.             ((struct arpcom *)pIfNet)->ac_ipaddr = IA_SIN (data)->sin_addr;
  776.             arpwhohas (pIfNet, &IA_SIN (data)->sin_addr);
  777.             break;
  779.         case SIOCSIFFLAGS:
  780.             /* Flags are set outside this module. No additional work to do. */
  781.             break;
  783.         default:
  784.             error = EINVAL;
  785.         }
  787.     return (error);
  788.     }
  790. /*******************************************************************************
  791. *
  792. * eiTxStartup - start output on the chip
  793. *
  794. * Looks for any action on the queue, and begins output if there is anything
  795. * there.  This routine is called from several possible threads.  Each will be
  796. * described below.
  797. *
  798. * The first, and most common thread, is when a user task requests the
  799. * transmission of data.  This will cause eiOutput() to be called, which will
  800. * cause ether_output() to be called, which will cause this routine to be
  801. * called (usually).  This routine will not be called if ether_output() finds
  802. * that our interface output queue is full.  In this case, the outgoing data
  803. * will be thrown out.
  804. *
  805. * The second, and most obscure thread, is when the reception of certain
  806. * packets causes an immediate (attempted) response.  For example, ICMP echo
  807. * packets (ping), and ICMP "no listener on that port" notifications.  All
  808. * functions in this driver that handle the reception side are executed in the
  809. * context of netTask().  Always.  So, in the case being discussed, netTask() 
  810. * will receive these certain packets, cause IP to be stimulated, and cause the
  811. * generation of a response to be sent.  We then find ourselves following the
  812. * thread explained in the second example, with the important distinction that
  813. * the context is that of netTask().
  814. *
  815. * The third thread occurs when this routine runs out of TFDs and returns.  If
  816. * this occurs when our output queue is not empty, this routine would typically
  817. * not get called again until new output was requested.  Even worse, if the
  818. * output queue was also full, this routine would never get called again and
  819. * we would have a lock state.  It DOES happen.  To guard against this, the
  820. * transmit clean-up handler detects the out-of-TFDs state and calls this
  821. * function.  The clean-up handler also runs from netTask.
  822. *
  823. * Note that this function is ALWAYS called between an splnet() and an splx().
  824. * This is true because netTask(), and ether_output() take care of
  825. * this when calling this function.  Therefore, no calls to these spl functions
  826. * are needed anywhere in this output thread.
  827. */
  829. void eiTxStartup
  830.     (
  831.     DRV_CTRL *pDrvCtrl
  832.     )
  833.     {
  834.     MBUF * pMbuf;
  835.     int length;
  836.     TFD * pTfd;
  838.     /*
  839.      * Loop until there are no more packets ready to send or we
  840.      * have insufficient resources left to send another one.
  841.      */
  842.     while (pDrvCtrl->idr.ac_if.if_snd.ifq_head)
  843.         {
  844.         IF_DEQUEUE (&pDrvCtrl->idr.ac_if.if_snd, pMbuf);  /* dequeue a packet */
  845.         /* get free tfd */
  846.         pTfd = (TFD *) eiQGet ((EI_LIST *)&pDrvCtrl->tfdQueue);
  848.         if (pTfd == NULL)
  849.     {
  850.     m_freem (pMbuf);
  851.             break;                              /* out of TFD's */
  852.     }
  854.         copy_from_mbufs ((ETH_HDR *)pTfd->enetHdr, pMbuf, length);
  855.         length = max (ETHERSMALL, length);
  857.         if ((etherOutputHookRtn != NULL) &&
  858.             (* etherOutputHookRtn)
  859.             (&pDrvCtrl->idr, (ETH_HDR *)pTfd->enetHdr, length))
  860.             continue;
  862.         pTfd->count = length & ~0xc000;     /* fill in length */
  864.         eiTxQPut (pDrvCtrl, pTfd);
  865.         }
  866.     }
  868. /*******************************************************************************
  869. *
  870. * eiInt - entry point for handling interrupts from the 82596
  871. *
  872. * The interrupting events are acknowledged to the device, so that the device
  873. * will deassert its interrupt signal.  The amount of work done here is kept
  874. * to a minimum; the bulk of the work is defered to the netTask.  Several flags
  875. * are used here to synchronize with task level code and eliminate races.
  876. */
  878. static void eiInt
  879.     (
  880.     DRV_CTRL *pDrvCtrl
  881.     )
  882.     {
  883.     UINT16  event;
  884.     SCB *pScb;
  885.     int unit;
  886.     pScb = pDrvCtrl->pScb;
  887.     unit = pDrvCtrl->idr.ac_if.if_unit;
  889.     event = pScb->scbStatus & (SCB_S_CX | SCB_S_FR | SCB_S_CNA | SCB_S_RNR);
  891. #ifdef EI_DEBUG
  892.     logMsg ("ei: interrupt: event=%xn", event, 0, 0, 0, 0, 0);
  893. #endif /* EI_DEBUG */
  895.     eiCommand (pDrvCtrl, event);                        /* ack the events */
  897.     sys596IntAck (unit);                                /* ack 596 interrupt */
  899.     /* Handle transmitter interrupt */
  901.     if (event & SCB_S_CNA)                              /* reclaim tx tfds */
  902.         {
  903.         pDrvCtrl->wdTxTimeout = 0;              /* reset timeout count */
  905.         if (pDrvCtrl->cleanQueue.head == NULL)      /* clean queue empty */
  906.             {
  907.             pDrvCtrl->cleanQueue.head = pDrvCtrl->cblQueue.head; /* new head */
  908.             pDrvCtrl->cleanQueue.tail = pDrvCtrl->cblQueue.tail; /* new tail */
  909.             }
  910.         else                                            /* concatenate queues */
  911.             {
  912.             pDrvCtrl->cleanQueue.tail->pNext =
  913.                         (EI_NODE*) pDrvCtrl->cblQueue.head;
  914.             pDrvCtrl->cleanQueue.tail = pDrvCtrl->cblQueue.tail;
  915.             }
  917.         if (!pDrvCtrl->txCleaning)                          /* not cleaning? */
  918.             {
  919.             pDrvCtrl->txCleaning = TRUE;                    /* set flag */
  920.             netJobAdd ((FUNCPTR) eiTxCleanQ, (int) pDrvCtrl, 0, 0, 0, 0);
  921.                             /* defer cleanup */
  922.             }
  924.         if (pDrvCtrl->txQueue.head != NULL)             /* anything to flush? */
  925.             eiTxQFlush (pDrvCtrl);                      /* flush the tx q */
  926.         else
  927.             pDrvCtrl->txIdle = TRUE;                    /* transmitter idle */
  928.         }
  930.     /* Handle receiver interrupt */
  932.     if (event & SCB_S_FR)
  933. {
  934. pDrvCtrl->wdRxTimeout = 0;                  /* reset timeout count */
  935. if (!(pDrvCtrl->rcvHandling))
  936.             {
  937.             pDrvCtrl->rcvHandling = TRUE;
  938.             (void) netJobAdd ((FUNCPTR) eiHandleRecvInt, (int) pDrvCtrl,0, 0, 0, 0);         /* netTask processes */
  939.     }
  940.         }
  941.     }
  943. /*******************************************************************************
  944. *
  945. * eiTxCleanQ - checks errors in completed TFDs and moves TFDs to free queue
  946. *
  947. * This routine is executed by netTask.  It "cleans" the TFDs on the clean-up
  948. * queue by checking each one for errors and then returning the TFD to the
  949. * "free TFD" queue.  The startup routine is sometimes called here to eliminate
  950. * the lock-out case where the driver input queue is full but there are no
  951. * TFDs available.
  952. */
  954. static void eiTxCleanQ
  955.     (
  956.     DRV_CTRL *pDrvCtrl
  957.     )
  958.     {
  959.     TFD *pTfd;
  960.     BOOL needTxStart;
  961.     int unit;
  963.     unit = pDrvCtrl->idr.ac_if.if_unit;
  965.     do
  966.         {
  967.         pDrvCtrl->txCleaning = TRUE;
  969.         if (pDrvCtrl->tfdQueue.head == NULL)              /* tfd queue empty */
  970.             needTxStart = TRUE;                           /* set flag */
  971.         else
  972.             needTxStart = FALSE;
  974.         /* process transmitted frames */
  976.         while (1)
  977.             {
  979.             /* Get TFD. No ints allowed while manipulating this queue. */
  981.             sys596IntDisable (unit);
  982.             pTfd = (TFD*) eiQGet ((EI_LIST *)&pDrvCtrl->cleanQueue);
  983.             sys596IntEnable (unit);
  984.             if (pTfd == NULL)
  985.                 break;
  987.             pDrvCtrl->idr.ac_if.if_collisions +=         /* add any colls */
  988.                 (pTfd->status & CFD_S_RETRY) ? 16 :  /* excessive colls */
  989.                 (pTfd->status & CFD_S_COLL_MASK);    /* some colls */
  991.             if (!(pTfd->status & CFD_S_OK))          /* packet not sent */
  992.                 {
  993.                 pDrvCtrl->idr.ac_if.if_oerrors++;        /* incr err count */
  994.                 pDrvCtrl->idr.ac_if.if_opackets--;       /* decr sent count */
  995.                 }
  997.             /* return to tfdQ */
  998.             eiQPut (unit,(EI_LIST *)&pDrvCtrl->tfdQueue, (EI_NODE*)pTfd);
  999.             }
  1001.         if (needTxStart)                                  /* check flag */
  1002.             eiTxStartup (pDrvCtrl);
  1004.         pDrvCtrl->txCleaning = FALSE;
  1005.         }
  1006.     while (pDrvCtrl->cleanQueue.head != NULL);            /* check again */
  1007.     }
  1009. /*******************************************************************************
  1010. *
  1011. * eiHandleRecvInt - task level interrupt service for input packets
  1012. *
  1013. * This routine is called at task level indirectly by the interrupt
  1014. * service routine to do any message received processing.
  1015. */
  1017. static void eiHandleRecvInt
  1018.     (
  1019.     DRV_CTRL *pDrvCtrl
  1020.     )
  1021.     {
  1022.     RFD *pRfd;
  1024.     do
  1025.         {
  1026.         pDrvCtrl->rcvHandling = TRUE;             /* interlock with eiInt() */
  1028.         while ((pRfd = eiRxQGet (pDrvCtrl)) != NULL)
  1029.             if (eiReceive (pDrvCtrl, pRfd) == OK)
  1030.                 eiRxQPut (pDrvCtrl, pRfd);
  1032.         pDrvCtrl->rcvHandling = FALSE;            /* interlock with eiInt() */
  1033.         }
  1034.     while (eiRxQFull (pDrvCtrl));              /* make sure rx q still empty */
  1036.     }
  1038. /*******************************************************************************
  1039. *
  1040. * eiReceive - pass a received frame to the next layer up
  1041. *
  1042. * Strips the Ethernet header and passes the packet to the appropriate
  1043. * protocol.  The return value indicates if buffer loaning was used to hold
  1044. * the data.  A return value of OK means that loaning was not done, and it
  1045. * is therefore 'ok' to return the RFD to the Rx queue.  A return value of ERROR
  1046. * means that buffer loaning was employed, and so the RFD is still in use and
  1047. * should not be returned to the Rx queue.  In this latter case, the RFD will
  1048. * eventually be returned by the protocol, via a call to our eiLoanFree().
  1049. */
  1051. static STATUS eiReceive
  1052.     (
  1053.     DRV_CTRL *pDrvCtrl,
  1054.     RFD *pRfd
  1055.     )
  1056.     {
  1057.     ETH_HDR     *pEh;
  1058.     u_char      *pData;
  1059.     int         len;
  1060.     UINT16      etherType;
  1061.     MBUF        *m = NULL;
  1062.     BOOL        rfdLoaned = FALSE;
  1065.     /* Check packet for errors.  This should be completely unnecessary,
  1066.      * but since Intel does not seem capable of explaining the exact
  1067.      * functioning of the 'save bad frames' config bit, we will look for
  1068.      * errors.
  1069.      */
  1071.     if  (
  1072.         ( pRfd->status & ( RFD_S_OK | RFD_S_COMPLETE ) ) !=
  1073.         ( RFD_S_OK | RFD_S_COMPLETE )
  1074.         )
  1075.         {
  1076.         ++pDrvCtrl->idr.ac_if.if_ierrors;            /* bump error counter */
  1077.         eiRxQPut (pDrvCtrl, pRfd);                   /* free the RFD */
  1078.         return (ERROR);
  1079.         }
  1081.     /* Bump input packet counter. */
  1083.     ++pDrvCtrl->idr.ac_if.if_ipackets;
  1085.     len = pRfd->actualCnt & ~0xc000;        /* get frame length */
  1086.     pEh = (ETH_HDR *)pRfd->enetHdr;         /* get ptr to ethernet header */
  1088.     /* Service input hook */
  1090.     if ( (etherInputHookRtn != NULL) )
  1091.         {
  1092.         if  ( (* etherInputHookRtn) (&pDrvCtrl->idr, (char *)pEh, len) )
  1093.             {
  1094.             eiRxQPut (pDrvCtrl, pRfd);                  /* free the RFD */
  1095.             return (OK);
  1096.             }
  1097.         }
  1099.     len -= EH_SIZE;
  1100.     pData = (u_char *) pRfd->enetData;
  1101.     etherType = ntohs (pEh->ether_type);
  1103.     /* we can loan out receive frames from 82596 receive queue if:
  1104.      *
  1105.      * 1) the threshold of loanable frames has not been exceeded
  1106.      * 2) size of the input ethernet frame is large enough to be used with
  1107.      *    clustering.
  1108.      */
  1109.     if ((pDrvCtrl->nLoanRfds > 0) && 
  1110.         ((m = build_cluster (pData, len, &pDrvCtrl->idr, MC_EI, &pRfd->refCnt,
  1111.                  eiLoanFree, (int) pDrvCtrl, (int) pRfd, NULL)) != NULL))
  1112.         {
  1113.         pDrvCtrl->nLoanRfds --;             /* one less to loan */
  1114.         rfdLoaned = TRUE;               /* we loaned a frame */
  1115.         }
  1116.     else 
  1117.         m = copy_to_mbufs (pData, len, 0, &pDrvCtrl->idr);
  1119.     if (m != NULL)
  1120. #ifdef BSD43_DRIVER
  1121.         do_protocol_with_type (etherType, m, &pDrvCtrl->idr, len);
  1122. #else
  1123.         do_protocol (pEh, m, &pDrvCtrl->idr, len);
  1124. #endif 
  1125.     else
  1126.         pDrvCtrl->idr.ac_if.if_ierrors++;
  1127.         
  1128.     return ((rfdLoaned) ? ERROR : OK);
  1129.     }
  1131. /*******************************************************************************
  1132. *
  1133. * eiLoanFree - return a loaned receive frame descriptor
  1134. *
  1135. * This routine is called by the protocol code when it has completed use of
  1136. * an RFD that we loaned to it.
  1137. */
  1139. static void eiLoanFree
  1140.     (
  1141.     DRV_CTRL *pDrvCtrl,
  1142.     RFD *pRfd
  1143.     )
  1144.     {
  1145.     eiRxQPut (pDrvCtrl, pRfd);
  1146.     pDrvCtrl->nLoanRfds ++;
  1147.     }
  1149. /*******************************************************************************
  1150. *
  1151. * eiDeviceStart - reset and start the device
  1152. *
  1153. * This routine assumes interrupts from the device have been disabled, and
  1154. * that the driver control structure has been initialized.
  1155. */
  1157. static STATUS eiDeviceStart
  1158.     (
  1159.     int unit                              /* physical unit number */
  1160.     )
  1161.     {
  1162.     void     *pTemp;
  1163.     DRV_CTRL *pDrvCtrl;
  1164.     SCP      *pScp;                       /* system config ptr */
  1165.     ISCP     *pIscp;                      /* intermediate system config ptr */
  1166.     SCB      *pScb;                       /* system control block ptr */
  1168.     /* Get pointers */
  1170.     pDrvCtrl = & drvCtrl [unit];
  1171.     pScp = pDrvCtrl->pScp;
  1172.     pIscp = pDrvCtrl->pIscp;
  1173.     pScb = pDrvCtrl->pScb;
  1175.     /* Issue the reset operation to the device */
  1177.     sys596Port (unit, PORT_RESET, NULL);
  1179.     /* Initialize the SCP */
  1181.     pScp->scpRsv1 =
  1182.     pScp->scpRsv2 =
  1183.     pScp->scpRsv3 = 0;
  1184.     pScp->scpSysbus = pDrvCtrl->sysbus;
  1186.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pIscp);
  1187.     LINK_WR (&pScp->pIscp, pTemp);              /* point SCP to ISCP */
  1189.     /* Initialize the ISCP */
  1191.     pIscp->iscpBusy = 1;
  1192.     pIscp->iscpRsv1 = 0;
  1194.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pScb);
  1195.     LINK_WR (&pIscp->pScb, pTemp);              /* point ISCP to SCB */
  1197.     /* Initialize the SCB */
  1199.     bzero ((char *)pScb, sizeof (SCB));
  1201.     /* Tell the device where the SCP is located */
  1203.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pScp);
  1204.     sys596Port (unit, PORT_NEWSCP, (UINT32) pTemp);
  1205.     sys596ChanAtn (unit);
  1207.     /*
  1208.      * The device will now read our SCP and ISCP. It will clear the busy
  1209.      * flag in the ISCP.
  1210.      */
  1212.     taskDelay (50);
  1213.     if ( pIscp->iscpBusy == 1 )
  1214.         {
  1215.         printf ("nei: device did not initializen");
  1216.         return (ERROR);
  1217.         }
  1219.     return (OK);
  1220.     }
  1222. /*******************************************************************************
  1223. *
  1224. * eiDiag - format and issue a diagnostic command
  1225. */
  1227. static void eiDiag
  1228.     (
  1229.     int unit
  1230.     )
  1231.     {
  1232.     DRV_CTRL *pDrvCtrl;
  1234.     pDrvCtrl = & drvCtrl [unit];
  1236.     bzero ((char *)pDrvCtrl->pCfd, sizeof (CFD));       /* zero command frame */
  1238.     eiAction (unit, CFD_C_DIAG);                /* run diagnostics */
  1240.     if (!(pDrvCtrl->pCfd->cfdStatus & CFD_S_OK))
  1241.         printErr ("eiDiag: i82596 diagnostics failed.n");
  1242.     }
  1244. /*******************************************************************************
  1245. *
  1246. * eiConfig - format and issue a config command
  1247. */
  1249. static void eiConfig
  1250.     (
  1251.     int unit
  1252.     )
  1253.     {
  1254.     DRV_CTRL *pDrvCtrl;
  1256.     pDrvCtrl = & drvCtrl [unit];
  1258.     bzero ((char *)pDrvCtrl->pCfd, sizeof (CFD));       /* zero command frame */
  1260.     /* Recommeded i82596 User's Manual configuration values.  Note that
  1261.      * the original manual, #296443-001, was full of errors.  Errors in the
  1262.      * description of the config bytes that I am aware of are noted below.
  1263.      * It is possible there are further errors.  Intel has replaced the
  1264.      * manual with #296853-001, which does correct some errors, but not all.
  1265.      */
  1267.     pDrvCtrl->pCfd->cfdConfig.ccByte8  = 0x8e;
  1268.     pDrvCtrl->pCfd->cfdConfig.ccByte9  = 0xc8;
  1270.     /* The manual is wrong about bit 7 in byte 10.
  1271.      * A '0' allows reception of bad packets.
  1272.      * A '1' causes rejection of bad packets.
  1273.      */
  1274.     pDrvCtrl->pCfd->cfdConfig.ccByte10 = 0xc0;
  1276.     pDrvCtrl->pCfd->cfdConfig.ccByte11 = 0x2e;      /* loopback, NSAI */
  1277.     pDrvCtrl->pCfd->cfdConfig.ccByte12 = 0x00;
  1278.     pDrvCtrl->pCfd->cfdConfig.ccByte13 = 0x60;
  1279.     pDrvCtrl->pCfd->cfdConfig.ccByte14 = 0x00;
  1280.     pDrvCtrl->pCfd->cfdConfig.ccByte15 = 0xf2;
  1281.     pDrvCtrl->pCfd->cfdConfig.ccByte16 = 0x00;      /* promiscuous off */
  1282.     pDrvCtrl->pCfd->cfdConfig.ccByte17 = 0x00;
  1283.     pDrvCtrl->pCfd->cfdConfig.ccByte18 = 0x40;
  1285.     /* The manual is wrong about 2 bits in byte 19.
  1286.      * Bit 5, multicast, a '1' disables.
  1287.      * Bit 2, include CRC, a '1' disables.
  1288.      */
  1289.     pDrvCtrl->pCfd->cfdConfig.ccByte19 = 0xff;
  1291.     pDrvCtrl->pCfd->cfdConfig.ccByte20 = 0x00;
  1292.     pDrvCtrl->pCfd->cfdConfig.ccByte21 = 0x3f;
  1295.     eiAction (unit, CFD_C_CONFIG);          /* configure the chip */
  1296.     }
  1298. /*******************************************************************************
  1299. *
  1300. * eiIASetup - format and issue an interface address command
  1301. */
  1303. static void eiIASetup
  1304.     (
  1305.     int unit
  1306.     )
  1307.     {
  1308.     DRV_CTRL *pDrvCtrl;
  1310.     pDrvCtrl = & drvCtrl [unit];
  1312.     bzero ((char *)pDrvCtrl->pCfd, sizeof (CFD));       /* zero command frame */
  1314.     bcopy   (
  1315.             (char *)pDrvCtrl->idr.ac_enaddr,
  1316.             (char *)pDrvCtrl->pCfd->cfdIASetup.ciAddress,
  1317.             6
  1318.             );
  1320.     eiAction (unit, CFD_C_IASETUP);         /* setup the address */
  1321.     }
  1323. /*******************************************************************************
  1324. *
  1325. * eiRxStartup - start up the Receive Unit
  1326. *
  1327. * Starts up the Receive Unit.  Assumes that the receive structures are set up.
  1328. */
  1330. static void eiRxStartup
  1331.     (
  1332.     DRV_CTRL *pDrvCtrl
  1333.     )
  1334.     {
  1335.     SCB *pScb = pDrvCtrl->pScb;
  1336.     void * pTemp;
  1338.     if (pScb->scbStatus & SCB_S_RUREADY)        /* already running */
  1339.         return;
  1341.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pDrvCtrl->pFreeRfd);
  1342.     LINK_WR (&pScb->pRF, pTemp);            /* point to free Rfd */
  1344.     sys596IntDisable (pDrvCtrl->idr.ac_if.if_unit);
  1346.     if ((pScb->scbStatus & SCB_S_RUMASK) != SCB_S_RUIDLE)
  1347.         eiCommand (pDrvCtrl, SCB_C_RUABORT);            /* abort if not idle */
  1349.     eiCommand (pDrvCtrl, SCB_C_RUSTART);              /* start receive unit */
  1350.     sys596IntEnable (pDrvCtrl->idr.ac_if.if_unit);
  1352.     }
  1354. /*******************************************************************************
  1355. *
  1356. * eiAction - execute the specified action with the CFD pointed to in pDrvCtrl
  1357. *
  1358. * Do the command contained in the CFD synchronously, so that we know
  1359. * it's complete upon return.  This routine assumes that interrupts from the
  1360. * device have been disabled.
  1361. */
  1363. static void eiAction
  1364.     (
  1365.     int    unit,
  1366.     UINT16 action
  1367.     )
  1368.     {
  1369.     void     *pTemp;
  1370.     CFD      *pCfd;
  1371.     SCB      *pScb;
  1372.     DRV_CTRL *pDrvCtrl;
  1374.     pDrvCtrl = & drvCtrl [unit];
  1375.     pCfd = pDrvCtrl->pCfd;
  1376.     pScb = pDrvCtrl->pScb;
  1378.     while (1)                   /* wait for idle command unit */
  1379.         {
  1380.         if ((pScb->scbStatus & SCB_S_CUMASK) == SCB_S_CUIDLE)
  1381.             break;
  1382.         }
  1384.     { /* Prepare and issue the command to the device */
  1386.     /* fill in CFD */
  1388.     pCfd->cfdStatus  = 0;                       /* clear status */
  1389.     pCfd->cfdCommand = CFD_C_EL | action;       /* fill in action */
  1390.     LINK_WR (&pCfd->link, NULL);                /* terminate link */
  1392.     /* and the SCB */
  1394.     pScb->scbCommand =
  1395.                         SCB_S_CX |              /* ack any events */
  1396.                         SCB_S_FR |
  1397.                         SCB_S_CNA |
  1398.                         SCB_S_RNR |
  1399.                         SCB_C_CUSTART;          /* start command unit */
  1401.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pCfd);
  1402.     LINK_WR (&pScb->pCB, pTemp);                /* point chip at CFD */
  1404.     sys596ChanAtn (unit);               /* notify device of new command */
  1405.     }
  1407.     while (1)               /* wait for command acceptance and interrupt */
  1408.         {
  1409.         if ((pScb->scbCommand == 0) && (pScb->scbStatus & SCB_S_CNA))
  1410.             break;
  1411.         }
  1413.     /* Acknowledge the event to the device */
  1415.     pScb->scbCommand = (SCB_S_CX | SCB_S_CNA);
  1416.     sys596ChanAtn (unit);
  1418.     while (1)               /* wait for acknowledge acceptance */
  1419.         {
  1420.         if (pScb->scbCommand == 0)
  1421.             break;
  1422.         }
  1423.     }
  1425. /*******************************************************************************
  1426. *
  1427. * eiCommand - deliver a command to the 82596 via SCB
  1428. *
  1429. * This function causes the device to execute a command.  It should be called
  1430. * with interrupts from the device disabled.  An error status is returned if
  1431. * the command field does not return to zero, from a previous command, in a
  1432. * reasonable amount of time.
  1433. */
  1435. static STATUS eiCommand
  1436.     (
  1437.     DRV_CTRL *pDrvCtrl,
  1438.     UINT16    cmd
  1439.     )
  1440.     {
  1441.     int loopy;
  1442.     SCB * pScb;
  1444.     pScb = pDrvCtrl->pScb;
  1446.     for (loopy = 0x8000; loopy--;)
  1447.         {
  1448.         if (pScb->scbCommand == 0)                  /* wait for cmd zero */
  1449.             break;
  1450.         }
  1452.     if (loopy > 0)
  1453.         {
  1454.         pScb->scbCommand = cmd;                     /* fill in command */
  1455.         sys596ChanAtn (pDrvCtrl->idr.ac_if.if_unit);    /* channel attention */
  1456.         return (OK);
  1457.         }
  1458.     else
  1459.         {
  1460.         logMsg("ei driver: command field frozenn", 0, 0, 0, 0, 0, 0);
  1461.         return (ERROR);
  1462.         }
  1463.     }
  1465. /*******************************************************************************
  1466. *
  1467. * eiTxQPut - place a transmit frame on the transmit queue
  1468. *
  1469. * The TFD has been filled in with the network pertinent data.  This
  1470. * routine will enqueue the TFD for transmission and attempt to feed
  1471. * the queue to the device.
  1472. */
  1474. static void eiTxQPut
  1475.     (
  1476.     DRV_CTRL *pDrvCtrl,
  1477.     TFD *pTfd
  1478.     )
  1479.     {
  1480.     int unit;
  1482.     unit = pDrvCtrl->idr.ac_if.if_unit;
  1484.     pTfd->status    = 0;                    /* fill in TFD fields */
  1485.     pTfd->command   = CFD_C_XMIT;           /* EL set later */
  1486.     pTfd->count     |= TFD_CNT_EOF;         /* data kept in frame */
  1487.     pTfd->reserved  = 0;                    /* must be zero */
  1489.     LINK_WR (& pTfd->lBufDesc, NULL);                /* TBDs not used */
  1491.     sys596IntDisable (pDrvCtrl->idr.ac_if.if_unit);  /* disable dev ints */
  1493.     /* enqueue the TFD */
  1494.     eiQPut (unit,(EI_LIST *)&pDrvCtrl->txQueue, (EI_NODE*)pTfd);
  1496.     if (pDrvCtrl->txIdle)                             /* transmitter idle */
  1497.         eiTxQFlush (pDrvCtrl);                        /* flush txQueue */
  1499.     sys596IntEnable (pDrvCtrl->idr.ac_if.if_unit);  /* enable dev ints */
  1500.     }
  1502. /*******************************************************************************
  1503. *
  1504. * eiTxQFlush - make cmd unit of device start processing cmds
  1505. *
  1506. * This routine flushes the contents of the txQ to the cblQ and starts the
  1507. * device transmitting the cblQ.  Called only if transmit queue is not empty.
  1508. * Sometimes called from interrupt handler.
  1509. */
  1511. static void eiTxQFlush
  1512.     (
  1513.     DRV_CTRL *pDrvCtrl
  1514.     )
  1515.     {
  1516.     void * pTemp;
  1517.     extern int sysClkRateGet();     /* we call this */
  1519.     ((TFD*)pDrvCtrl->txQueue.tail)->command |= CFD_C_EL;  /* EL terminate q */
  1520.     pDrvCtrl->cblQueue.head = pDrvCtrl->txQueue.head;   /* remember cbl head */
  1521.     pDrvCtrl->cblQueue.tail = pDrvCtrl->txQueue.tail;   /* remember cbl tail */
  1522.     eiQInit ((EI_LIST *)&pDrvCtrl->txQueue);            /* tx queue now empty */
  1524.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs,
  1525.                                     pDrvCtrl->cblQueue.head);
  1526.     LINK_WR (&pDrvCtrl->pScb->pCB, pTemp);          /* point CU to head */
  1528.     pDrvCtrl->txIdle = FALSE;                   /* transmitter busy */
  1530.     /* start command unit */
  1532.     eiCommand (pDrvCtrl, SCB_C_CUSTART);
  1533.     }
  1535. /*******************************************************************************
  1536. *
  1537. * eiRxQPut - return a RFD to the receive queue for use by the device
  1538. */
  1540. static void eiRxQPut
  1541.     (
  1542.     DRV_CTRL *pDrvCtrl,
  1543.     RFD *pRfd
  1544.     )
  1545.     {
  1546.     int unit;
  1547.     RFD *pTail;
  1549.     unit = pDrvCtrl->idr.ac_if.if_unit;
  1551.     pRfd->status    = 0;                    /* clear status */
  1552.     pRfd->command   = CFD_C_EL;             /* new end of list */
  1553.     pRfd->actualCnt  = 0;                   /* clear actual count */
  1554.     pRfd->bufSize   = ETHERMTU + EH_SIZE;   /* fill in size */
  1555.     pRfd->refCnt    = 0;                    /* initialize ref cnt */
  1557.     LINK_WR (& pRfd->lBufDesc, 0xffffffff);         /* no RBD used */
  1559.     pTail = (RFD *) pDrvCtrl->rxQueue.tail;         /* remember tail */
  1561.     /* Put the RFD on the list */
  1563.     eiQPut (unit, (EI_LIST *) & pDrvCtrl->rxQueue, (EI_NODE *) pRfd);
  1565.     if (pTail != NULL)
  1566.         {
  1567.         pDrvCtrl->wdRxTimeout = 0;          /* reset timeout count */
  1569.         pTail->command &= ~CFD_C_EL;        /* clear old tail EL */
  1571.         if (pTail->status & (CFD_S_COMPLETE | CFD_S_BUSY))
  1572.             {
  1573.             pDrvCtrl->pFreeRfd = pRfd;          /* link questionable */
  1574.             }
  1575.         else if (!(pDrvCtrl->pScb->scbStatus & SCB_S_RUREADY))
  1576.             /* receiver dormant */
  1577.             {
  1578.             eiRxStartup (pDrvCtrl);             /* start receive unit */
  1579.             }
  1580.         }
  1581.     else
  1582.         {
  1583.         pDrvCtrl->pFreeRfd = pRfd;              /* first free RFD */
  1584.         }
  1585.     }
  1587. /*******************************************************************************
  1588. *
  1589. * eiRxQGet - get a successfully received frame from the receive queue
  1590. *
  1591. * RETURNS: ptr to valid RFD, or NULL if none available
  1592. */
  1594. static RFD *eiRxQGet
  1595.     (
  1596.     DRV_CTRL *pDrvCtrl
  1597.     )
  1598.     {
  1599.     RFD *pRfd = NULL;
  1601.     if (eiRxQFull (pDrvCtrl))
  1602.         pRfd = (RFD *) eiQGet ((EI_LIST *)&pDrvCtrl->rxQueue);
  1604.     return (pRfd);
  1605.     }
  1607. /*******************************************************************************
  1608. *
  1609. * eiRxQFull - boolean function to determine fullness of receive queue
  1610. *
  1611. * RETURNS: TRUE if completely received frame is available, FALSE otherwise.
  1612. */
  1614. static BOOL eiRxQFull
  1615.     (
  1616.     DRV_CTRL *pDrvCtrl
  1617.     )
  1618.     {
  1619.     return ((pDrvCtrl->rxQueue.head != NULL) &&
  1620.         (((RFD*)pDrvCtrl->rxQueue.head)->status & CFD_S_COMPLETE));
  1621.     }
  1623. /*******************************************************************************
  1624. *
  1625. * eiQInit - initialize a singly linked node queue
  1626. */
  1628. static void eiQInit
  1629.     (
  1630.     EI_LIST *pQueue
  1631.     )
  1632.     {
  1633.     pQueue->head = pQueue->tail = NULL;         /* init head & tail */
  1634.     }
  1636. /*******************************************************************************
  1637. *
  1638. * eiQGet - get a node from the head of a node queue
  1639. *
  1640. * RETURNS: ptr to useable node, or NULL ptr if none available
  1641. */
  1643. static EI_NODE *eiQGet
  1644.     (
  1645.     EI_LIST *pQueue
  1646.     )
  1647.     {
  1648.     EI_NODE *pNode;
  1650.     if ((pNode = (EI_NODE *) pQueue->head) != NULL)     /* if list not empty */
  1651.         pQueue->head = pNode->pNext;                    /* advance ptr */
  1653.     return (pNode);
  1654.     }
  1656. /*******************************************************************************
  1657. *
  1658. * eiQPut - put a node on the tail of a node queue
  1659. */
  1661. static void eiQPut
  1662.     (
  1663.     int unit,
  1664.     EI_LIST *pQueue,
  1665.     EI_NODE *pNode
  1666.     )
  1667.     {
  1668.     void * pTemp;
  1669.     DRV_CTRL *pDrvCtrl;
  1671.     pDrvCtrl = & drvCtrl [unit];
  1673.     LINK_WR (&pNode->lNext, NULL);                    /* mark "end of list" */
  1674.     pNode->pNext = NULL;
  1676.     if (pQueue->head == NULL)                        /* if list empty */
  1677.         pQueue->tail = pQueue->head = pNode;         /* set both ptrs */
  1678.     else
  1679.         {
  1680.         pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pNode);
  1681.         LINK_WR (&pQueue->tail->lNext, pTemp);       /* link node on tail */
  1682.         pQueue->tail->pNext = pNode;
  1683.         pQueue->tail = pNode;                        /* update tail ptr */
  1684.         }
  1685.     }
  1687. /*******************************************************************************
  1688. *
  1689. * eiWatchDog - if the watchdog timer fired off, we've hung during a transmit
  1690. *
  1691. * Check the scb command to verify and if so, reinit.
  1692. */
  1694. static void eiWatchDog
  1695.     (
  1696.     int unit        /* unit number */
  1697.     )
  1699.     {
  1700.     DRV_CTRL *pDrvCtrl = &drvCtrl [unit];
  1701.     SCB *pScb;
  1702.     int reset = FALSE;
  1703.     pScb = pDrvCtrl->pScb;
  1706.     /* Test for transmit timeout.
  1707.      *
  1708.      * Timeout occurs if the scb status indicates that CU (transmit) 
  1709.      * remains active for EI_TX_TIMEOUT iterations of eiWatchDog.
  1710.      * It might make sense to loop through the cfd's to look for
  1711.      * a complete bit as a sanity check, but given that transmit
  1712.      * was active, we will go ahead and do a reset.
  1713.      */
  1714.     if ((pDrvCtrl->txIdle == FALSE)
  1715.         && (pScb->scbStatus & SCB_S_CUACTIVE))
  1716.         {
  1717.         if (++(pDrvCtrl->wdTxTimeout) > EI_TX_TIMEOUT)
  1718.             {
  1719.             pDrvCtrl->transLocks++;   /* failure count */
  1720.             pDrvCtrl->idr.ac_if.if_oerrors++;             /* incr err count */
  1721.             pDrvCtrl->idr.ac_if.if_opackets--;            /* decr sent count */
  1722.             reset = TRUE;
  1723.             }
  1724.         }
  1726.     /* Test for receive timeout.
  1727.      *
  1728.      * Timeout occurs if the scb status indicates that RU (receive) 
  1729.      * remains out of resources for EI_RX_TIMEOUT iterations of eiWatchDog.
  1730.      */
  1731.     if (pScb->scbStatus & SCB_S_RUNORSRC)
  1732.         {
  1733.         if (++(pDrvCtrl->wdRxTimeout) > EI_RX_TIMEOUT)
  1734.             {
  1735.             pDrvCtrl->recvLocks++;   /* failure count */
  1736.             reset = TRUE;
  1737.             }
  1738.         }
  1740.     /* reinitialize the unit or restart the watchdog */
  1742.     if (reset)
  1743. netJobAdd ((FUNCPTR) eiInit, unit, 0, 0, 0, 0);
  1744.     else
  1745.         wdStart (pDrvCtrl->wid, 
  1746. (int) pDrvCtrl->wdInterval, 
  1747. (FUNCPTR) eiWatchDog, 
  1748. unit);
  1749.     }
  1751. /******************************************************************************/
  1753. /* END OF FILE */