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

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

VxWorks

开发平台：

C/C++

if_eex.c：源码内容
  1. /* if_eex.c - Intel EtherExpress 16 network interface driver */
  3. /* Copyright 1989-1997 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01k,15jul97,spm  added ARP request to SIOCSIFADDR ioctl handler
  10. 01j,07apr97,spm  corrected statistics counter for incoming packets
  11. 01i,17mar97,spm  upgraded to BSD 4.4 and corrected statistics counters.
  12. 01h,14jun95,hdn  removed function declarations defined in sysLib.h.
  13. 01g,01feb95,jdi  doc cleanup.
  14. 01f,17jan95,jag  only send connector select command if NOT auto-detect
  15. 01e,12nov94,tmk  removed some IMPORTed function decs and included unixLib.h
  16. 01d,20feb94,bcs  add attachment type selection, stub for auto-detect
  17. 01c,13dec93,bcs  rearranged initialization, fixed comments
  18. 01b,04dec93,bcs  made functional, added AL_LOC compile-time option
  19. 01a,28nov93,bcs  derived from if_ei.c (rev. 03c,15jan93)
  20. */
  22. /*
  23. DESCRIPTION
  24. This module implements the Intel EtherExpress 16 PC network interface card
  25. driver.  It is specific to that board as used in PC 386/486 hosts.
  26. This driver is written using the device's I/O registers exclusively.
  29. SIMPLIFYING ASSUMPTIONS
  30. This module assumes a little-endian host (80x86); thus, no endian
  31. adjustments are needed to manipulate the 82586 data structures (little-endian).
  33. The on-board memory is assumed to be sufficient; thus, no provision is made
  34. for additional buffering in system memory.
  36. The "frame descriptor" and "buffer descriptor" structures can be bound
  37. into permanent pairs by pointing each FD at a "chain" of one BD of MTU size.
  38. The 82586 receive algorithm fills exactly one BD for each FD; it looks to
  39. the NEXT FD in line for the next BD.
  41. The transmit and receive descriptor lists are permanently linked into
  42. circular queues partitioned into sublists designated by the EEX_LIST
  43. headers in the driver control structure.  Empty partitions have NULL pointer
  44. fields.  EL bits are set as needed to tell the 82586 where a partition ends.
  45. The lists are managed in strict FIFO fashion; thus the link fields are never
  46. modified, just ignored if a descriptor is at the end of a list partition.
  49. BOARD LAYOUT
  50. This device is soft-configured.  No jumpering diagram is required.
  53. EXTERNAL INTERFACE
  54. This driver provides the standard external interface with the following
  55. exceptions.  All initialization is performed within the attach routine and
  56. there is no separate initialization routine.  Therefore, in the global interface
  57. structure, the function pointer to the init() routine is NULL.
  59. There is one user-callable routine, eexattach().  For details on usage,
  60. see the manual entry for this routine.
  63. EXTERNAL SUPPORT REQUIREMENTS
  64. None.
  67. SYSTEM RESOURCE USAGE
  68.     - one mutual exclusion semaphore
  69.     - one interrupt vector
  70.     - one watchdog timer.
  71.     - 8 bytes in the initialized data section (data)
  72.     - 912 bytes in the uninitialized data section (bss)
  74. The data and bss sections are quoted for the MC68020 architecture and may vary
  75. for other architectures.  The code size (text) will vary widely between
  76. architectures, and is thus not quoted here.
  78. The device contains on-board buffer memory; no system memory is required
  79. for buffering.
  82. TUNING HINTS
  83. The only adjustable parameter is the number of TFDs to create in adapter buffer
  84. memory.  The total number of TFDs and RFDs is 21, given full-frame buffering
  85. and the sizes of the auxiliary structures.  eexattach() requires at least
  86. MIN_NUM_RFDS RFDs to exist.  More than ten TFDs is not sensible
  87. in typical circumstances.
  90. SEE ALSO: ifLib
  91. */
  93. #include "vxWorks.h"
  94. #include "wdLib.h"
  95. #include "iv.h"
  96. #include "vme.h"
  97. #include "net/mbuf.h"
  98. #include "net/protosw.h"
  99. #include "socket.h"
  100. #include "ioctl.h"
  101. #include "errno.h"
  102. #include "memLib.h"
  103. #include "intLib.h"
  104. #include "net/if.h"
  105. #include "net/route.h"
  106. #include "iosLib.h"
  107. #include "errnoLib.h"
  109. #include "cacheLib.h"
  110. #include "logLib.h"
  111. #include "netLib.h"
  112. #include "stdio.h"
  113. #include "stdlib.h"
  114. #include "sysLib.h"
  116. #ifdef  INET
  117. #include "netinet/in.h"
  118. #include "netinet/in_systm.h"
  119. #include "netinet/in_var.h"
  120. #include "netinet/ip.h"
  121. #include "netinet/if_ether.h"
  122. #endif  /* INET */
  124. #include "etherLib.h"
  125. #include "net/systm.h"
  126. #include "net/unixLib.h"
  127. #include "sys/times.h"
  128. #include "drv/netif/if_eex.h"
  129. #include "net/if_subr.h"
  132. /***** LOCAL DEFINITIONS *****/
  134. #undef EEX_DEBUG                             /* Compiles debug output */
  135. #undef EEX_DEBUG1  /* dhe 10/24/94 */
  137. #define MAX_UNITS       4                   /* maximum units to support */
  138. #define DEF_NUM_TFDS    8                   /* default number of TFDs */
  139. #define MIN_NUM_RFDS    4                   /* minimum number of RFDs */
  141. #define MAX_IRQ         15              /* Highest PC IRQ number */
  143. #define EEX_MEMSIZE     0x8000          /* Size of EtherExpress memory */
  144.                                         /* Production units are 32K */
  145. #define SCP_OFFSET      0xfff6          /* At top of 64K address space */
  146.                                         /* (aliased in a 32K board) */
  147. #define ISCP_OFFSET     0x0000          /* EtherExpress convention */
  148. #define SCB_OFFSET      0x0008          /* EtherExpress convention */
  149.                                         /* Supported by hardware feature */
  150. #define CFD_OFFSET      ( SCB_OFFSET + sizeof (SCB) )
  151. #define TFD_OFFSET      ( CFD_OFFSET + sizeof (CFD) )
  153. /* These should be in a common file but which one? */
  154. /* Ethernet attachment type selections */
  156. #define ATTACHMENT_DEFAULT      0       /* use card as configured */
  157. #define ATTACHMENT_AUI          1       /* AUI  (thick, DIX, DB-15) */
  158. #define ATTACHMENT_BNC          2       /* BNC  (thin, 10BASE-2) */
  159. #define ATTACHMENT_RJ45         3       /* RJ-45 (twisted pair, TPE, 10BASE-T)*/
  161. /* Typedefs for external structures that are not typedef'd in their .h files */
  163. typedef struct mbuf MBUF;
  164. typedef struct arpcom IDR;                  /* Interface Data Record wrapper */
  165. typedef struct ifnet IFNET;                 /* real Interface Data Record */
  166. typedef struct sockaddr SOCK;
  168. /* The definition of our linked list management structure */
  170. typedef struct eex_list                     /* EEX_LIST - 82586 queue head */
  171.     {
  172.     volatile EEX_SHORTLINK  head;       /* header of list */
  173.     volatile EEX_SHORTLINK  tail;       /* tail of list */
  174.     } EEX_LIST;
  176. /* Macro to follow TFRAME and RFRAME (TFD/RFD) lists */
  178. #define SUCC_FD(fd)     ( 
  179.                 sysOutWord (pDrvCtrl->port + RDPTR, (fd) + RF_LINK), 
  180.                 sysInWord (pDrvCtrl->port + DXREG) )
  182. /* The definition of the driver control structure */
  184. typedef struct drv_ctrl
  185.     {
  186.     IDR                 idr;        /* interface data record */
  188.     BOOL                attached;   /* indicates attach() called */
  189.     CFD                 *pCfd;      /* Scratch CFD to copy to board mem.*/
  190.     EEX_SHORTLINK       rfdBase;    /* RFD pool starts here */
  191.     EEX_SHORTLINK       lastFd;     /* last RFD dhe 10/26/94 */
  192.     volatile EEX_LIST   rxQueue;    /* receive queue */
  193.     volatile EEX_SHORTLINK freeRfd; /* first free receive frame */
  194.     volatile EEX_LIST   tfdQueue;   /* free transmit frame descriptors */
  195.     volatile EEX_LIST   txQueue;    /* to be sent queue */
  196.     volatile EEX_LIST   cblQueue;   /* actual chip transmit queue */
  197.     volatile EEX_LIST   cleanQueue; /* queue of TFDs to cleanup */
  198.     volatile BOOL       rcvHandling;/* flag, indicates netTask active */
  199.     volatile BOOL       txCleaning; /* flag, indicates netTask active */
  200.     volatile BOOL       txIdle;     /* flag, indicates idle transmitter */
  201.     int                 nTFDs;      /* how many TFDs to create */
  202.     int                 nRFDs;      /* how many RFDs to create */
  203.     int                 port;       /* base I/O port */
  204.     int                 ivec;       /* interrupt vector */
  205.     int                 intLevel;   /* interrupt number */
  206.     int                 irqCode;    /* encoded value written to IRQ port */
  207.     int                 attachment; /* connector type: BNC, AUI, or TPE */
  208.     UINT16              setup;      /* base, boot ROM, I/O, AUI/BNC, IRQ */
  209.     UINT16              tpeBit;     /* bit 0 = 1 && setup AUI bit = 0 for TPE */
  210.     MEM_SETUP           memSetup;   /* everything to set up memory mapping */
  211.     WDOG_ID             wid;        /* watchdog timer for transmit */
  212.     long                transLocks; /* count for transmit lockup failures */
  213.     } DRV_CTRL;
  215. #define DRV_CTRL_SIZ  sizeof(DRV_CTRL)
  218. /***** GLOBALS *****/
  221. /***** LOCALS *****/
  223. /* The array of driver control structs */
  225. LOCAL DRV_CTRL drvCtrl [MAX_UNITS];
  227. /* Encoded IRQ selection numbers for EtherExpress 16 IRQ Control port
  228.  * Entries correspond to PC IRQ numbers 0-15.  A zero entry means the
  229.  * corresponding IRQ cannot be used by the board; a non-zero entry is
  230.  * the value needed in the board's interrupt control register to program
  231.  * the board for the corresponding IRQ.
  232.  */
  234. LOCAL int irqTable [MAX_IRQ + 1] =
  235.     {
  236.     0, 0, 1, 2, 3, 4, 0, 0, 0, 1, 5, 6, 0, 0, 0, 0
  237.     };
  239. /* following are used only in netTask() context so can be common */
  241. LOCAL CFD       Cfd;                    /* expedient for code porting */
  242.                                         /* build commands here then copy */
  243.                                         /* to board memory */
  244. LOCAL char      buffer [FRAME_SIZE];    /* Copy frames through here */
  246. /* forward function declarations */
  248. static void eexReset (int unit);
  249. static int eexIoctl (IDR *pIDR, int cmd, caddr_t data);
  250. #ifdef BSD43_DRIVER
  251. static int eexOutput (IDR *pIDR, MBUF *pMbuf, SOCK *pDestAddr);
  252. static void eexTxStartup (int unit);
  253. #else
  254. static void eexTxStartup (DRV_CTRL *pDrvCtrl);
  255. #endif
  256. static void eexInt (DRV_CTRL *pDrvCtrl);
  257. static void eexTxCleanQ (DRV_CTRL *pDrvCtrl);
  258. static void eexHandleRecvInt (DRV_CTRL *pDrvCtrl);
  259. static STATUS eexReceive (DRV_CTRL *pDrvCtrl, EEX_SHORTLINK rfdOffset);
  260. static void eexDiag (int unit);
  261. static void eexConfig (int unit);
  262. static void eexIASetup (int unit);
  263. static void eexRxStartup (DRV_CTRL *pDrvCtrl);
  264. static void eexAction (int unit, UINT16 action);
  265. static STATUS eexCommand (DRV_CTRL *pDrvCtrl, UINT16 cmd);
  267. static void eexTxQPut (DRV_CTRL *pDrvCtrl, EEX_SHORTLINK tfdOffset);
  268. static void eexTxQFlush (DRV_CTRL *pDrvCtrl);
  269. static void eexRxQPut (DRV_CTRL *pDrvCtrl, EEX_SHORTLINK rfdOffset);
  270. static EEX_SHORTLINK eexRxQGet (DRV_CTRL *pDrvCtrl);
  271. static BOOL eexRxQFull (DRV_CTRL *pDrvCtrl);
  272. static void eexQInit (EEX_LIST *pHead);
  273. static EEX_SHORTLINK eexQGet (DRV_CTRL *pDrvCtrl, EEX_LIST *pQueue);
  274. static void eexQPut (DRV_CTRL *pDrvCtrl, EEX_LIST *pQueue, EEX_SHORTLINK pNode);
  275. static STATUS eexDeviceStart (int unit);
  276. static void eexWatchDog(int unit);
  277. static STATUS eexEnetAddrGet (DRV_CTRL *pDrvCtrl, char addr[]);
  278. static STATUS eex586Init (int unit);
  279. static void   eex586IntAck (int unit);
  280. static void   eex586IntEnable (int unit);
  281. static void   eex586IntDisable (int unit);
  282. static void   eex586SetReset (int unit);
  283. static void   eex586ClearReset (int unit);
  284. static void   eex586ChanAtn (DRV_CTRL *pDrvCtrl);
  285. static UINT16 eexReadEEPROM (DRV_CTRL *pDRvCtrl, UINT16 address);
  286. static void eexOutBitsEEPROM (int port, int count, UINT16 bits);
  287. static UINT16 eexInBitsEEPROM (int port, int count);
  288. static void   eexDelayEEPROM (void);
  290. static void DUMMY ()
  291. {}
  294. /*******************************************************************************
  295. *
  296. * eexattach - publish the `eex' network interface and initialize the driver and device
  297. *
  298. * The routine publishes the `eex' interface by filling in a network interface
  299. * record and adding this record to the system list.  This routine also
  300. * initializes the driver and the device to the operational state.
  301. *
  302. * RETURNS: OK or ERROR.
  303. *
  304. * SEE ALSO: ifLib
  305. */
  307. STATUS eexattach
  308.     (
  309.     int         unit,                   /* unit number */
  310.     int         port,                   /* base I/O address */
  311.     int         ivec,                   /* interrupt vector number */
  312.     int         ilevel,                 /* interrupt level */
  313.     int         nTfds,                  /* # of transmit frames (0=default) */
  314.     int         attachment              /* 0=default, 1=AUI, 2=BNC, 3=TPE */
  315.     )
  316.     {
  317.     DRV_CTRL    *pDrvCtrl;
  318.     long        size;                   /* temporary size holder */
  320.     /* Sanity check the unit number */
  322.     if (unit < 0 || unit >= MAX_UNITS)
  323.         return (ERROR);
  325.     /* Ensure single invocation per system life */
  327.     pDrvCtrl = & drvCtrl [unit];
  329. #ifdef EEX_DEBUG /* dhe 10/20/94 */
  330.     logMsg ("eex: eeattach: pDrvCtrl=%xn", pDrvCtrl, 0, 0, 0, 0, 0);
  331. #endif
  333.     if (pDrvCtrl->attached)
  334.         return (OK);
  336.     /* Check interrupt number for sanity and usability */
  337.     if (ilevel < 0 || ilevel > MAX_IRQ)
  338.         return (ERROR);
  340.     pDrvCtrl->intLevel = ilevel;
  341.     pDrvCtrl->irqCode = irqTable [ilevel];
  342.     if (pDrvCtrl->irqCode == 0)
  343.         return (ERROR);
  345.     /* Determine number of Tx and Rx descriptors to use */
  347.     pDrvCtrl->nTFDs = (nTfds != 0) ? nTfds : DEF_NUM_TFDS;
  349.     /* Determine which connector is desired */
  351.     switch (attachment)
  352.         {
  353.         case ATTACHMENT_DEFAULT:
  354.         case ATTACHMENT_AUI:
  355.         case ATTACHMENT_BNC:
  356.         case ATTACHMENT_RJ45:
  357.             pDrvCtrl->attachment = attachment;
  358.             break;
  359.         default:
  360.             return (ERROR);             /* unknown value */
  361.         }
  363.     /* Find and activate the adapter */
  364.     /* Publish the interface record */
  366. #ifdef BSD43_DRIVER
  367.     ether_attach    ( (IFNET *) & pDrvCtrl->idr, unit, "eex", (FUNCPTR) NULL,
  368.                      (FUNCPTR) eexIoctl, (FUNCPTR) eexOutput,
  369.                      (FUNCPTR) eexReset);
  370. #else
  371.     ether_attach    (
  372.                     (IFNET *) & pDrvCtrl->idr,
  373.                     unit,
  374.                     "eex",
  375.                     (FUNCPTR) NULL,
  376.                     (FUNCPTR) eexIoctl,
  377.                     (FUNCPTR) ether_output,
  378.                     (FUNCPTR) eexReset
  379.                     );
  380.     pDrvCtrl->idr.ac_if.if_start = (FUNCPTR)eexTxStartup;
  381. #endif
  383.     /* Calculate the total size of 82586 memory pool.
  384.      * Evaluate as a long so it can force nRFDs negative if way too many
  385.      * TFDs were asked for.
  386.      */
  388.     size =
  389.             sizeof (SCP) +
  390.             sizeof (ISCP) +
  391.             sizeof (SCB) +
  392.             sizeof (CFD) +                      /* synch'ed command frame */
  393.             (sizeof (TFRAME) * pDrvCtrl->nTFDs);   /* pool of transmit frames */
  394.     pDrvCtrl->nRFDs = ( (long)EEX_MEMSIZE - size ) / sizeof (RFRAME);
  396. #ifdef EEX_DEBUG /* dhe 10/20/94 */
  397.     logMsg ("eex: eeattach: nRFDS=%xn", pDrvCtrl->nRFDs, 0, 0, 0, 0, 0);
  398. #endif
  400.     if (pDrvCtrl->nRFDs < MIN_NUM_RFDS)
  401.         return (ERROR);
  403.     /* Save other passed-in parameters */
  405.     pDrvCtrl->port = port;                      /* base I/O address */
  406.     pDrvCtrl->ivec = ivec;                      /* interrupt vector */
  408.     pDrvCtrl->pCfd      = &Cfd;
  410.     /* Init the watchdog that will patrol for device lockups */
  412.     pDrvCtrl->transLocks = 0;
  413.     pDrvCtrl->wid = wdCreate ();                      /* create watchdog */
  414.     if (pDrvCtrl->wid == NULL)                        /* no resource */
  415.         goto error;
  417.     pDrvCtrl->rcvHandling   = FALSE;  /* netTask not running our receive job */
  418.     pDrvCtrl->txCleaning    = FALSE;  /* netTask not running our clean job */
  419.     pDrvCtrl->txIdle        = TRUE;         /* transmitter idle */
  421.     /* Perform device initialization */
  423.     if (eex586Init (unit) != OK)
  424.         goto error;
  426.     sysIntEnablePIC (ilevel);
  428.     /* Set our flag */
  430.     pDrvCtrl->attached = TRUE;
  432.     /* Set status flags in IDR */
  434.     pDrvCtrl->idr.ac_if.if_flags |= (IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);
  436.     /* Successful return */
  438.     return (OK);
  440.     /***** Handle error cases *****/
  442.     error:
  444.         {
  445.         /* Release watchdog */
  447.         if (pDrvCtrl->wid != NULL)
  448.             wdDelete (pDrvCtrl->wid);
  450.         return (ERROR);
  451.         }
  452.     }
  454. /*******************************************************************************
  455. *
  456. * eexReset - reset the eex interface
  457. *
  458. * Mark interface as inactive and reset the chip.
  459. */
  461. static void eexReset
  462.     (
  463.     int unit
  464.     )
  465.     {
  466.     DRV_CTRL *pDrvCtrl;
  468.     pDrvCtrl = & drvCtrl [unit];
  470.     pDrvCtrl->idr.ac_if.if_flags = 0;
  471.     eex586IntDisable (unit);                    /* disable ints from the dev */
  472.     eex586SetReset (unit);                      /* put the 586 chip in reset */
  474.     }
  476. /*******************************************************************************
  477. *
  478. * eexIoctl - interface ioctl procedure
  479. *
  480. * Process an interface ioctl request.
  481. */
  483. static int eexIoctl
  484.     (
  485.     IDR     *pIDR,
  486.     int     cmd,
  487.     caddr_t data
  488.     )
  489.     {
  490.     int error;
  492. #ifdef EEX_DEBUG
  493.     printf ("eex: ioctl: pIDR=%x cmd=%x data=%xn", pIDR, cmd, data);
  494. #endif /* EEX_DEBUG */
  496.     error = 0;
  498.     switch (cmd)
  499.         {
  500.         case SIOCSIFADDR:
  501.             ((struct arpcom *)pIDR)->ac_ipaddr = IA_SIN (data)->sin_addr;
  502.             arpwhohas (pIDR, &IA_SIN (data)->sin_addr);
  503.             break;
  505.         case SIOCSIFFLAGS:
  506.             /* Flags are set outside this module. No additional work to do. */
  507.             break;
  509.         default:
  510.             error = EINVAL;
  511.         }
  513.     return (error);
  514.     }
  516. #ifdef BSD43_DRIVER
  517. /*******************************************************************************
  518. *
  519. * eexOutput - interface output routine.
  520. *
  521. * This is the entry point for packets arriving from protocols above.  This
  522. * routine merely calls our specific output routines that eventually lead
  523. * to a transmit to the network.
  524. *
  525. * RETURNS: 0 or appropriate errno
  526. */
  528. static int eexOutput
  529.     (
  530.     IDR *    pIDR,
  531.     MBUF *     pMbuf,
  532.     SOCK * pDestAddr
  533.     )
  534.     {
  536. #ifdef EEX_DEBUG
  537.     printf ("eex: output: pIDR=%x pMbuf=%x pDestAddr=%xn",
  538.             pIDR, pMbuf, pDestAddr);
  539. #endif /* EEX_DEBUG */
  541.     return (ether_output ( (IFNET *)pIDR, pMbuf, pDestAddr,
  542.             (FUNCPTR) eexTxStartup, pIDR));
  543.     }
  544. #endif
  546. /*******************************************************************************
  547. *
  548. * eexTxStartup - start output on the chip
  549. *
  550. * Looks for any action on the queue, and begins output if there is anything
  551. * there. This routine is called from several possible threads. Each will be
  552. * described below.
  553. *
  554. * The first, and most common thread, is when a user task requests the
  555. * transmission of data. Under BSD 4.3, this will cause eexOutput() to be 
  556. * called, which will cause ether_output() to be called, which will cause 
  557. * this routine to be called (usually). This routine will not be called if 
  558. * ether_output() finds that our interface output queue is full. In this case, 
  559. * the outgoing data will be thrown out. BSD 4.4 uses a slightly different
  560. * model in which the generic ether_output() routine is called directly, 
  561. * followed by a call to this routine.
  562. *
  563. * The second, and most obscure thread, is when the reception of certain
  564. * packets causes an immediate (attempted) response. For example, ICMP echo
  565. * packets (ping), and ICMP "no listener on that port" notifications. All
  566. * functions in this driver that handle the reception side are executed in the
  567. * context of netTask(). Always. So, in the case being discussed, netTask() will
  568. * receive these certain packets, cause IP to be stimulated, and cause the
  569. * generation of a response to be sent. We then find ourselves following the
  570. * thread explained in the second example, with the important distinction that
  571. * the context is that of netTask().
  572. *
  573. * The third thread occurs when this routine runs out of TFDs and returns. If
  574. * this occurs when our output queue is not empty, this routine would typically
  575. * not get called again until new output was requested. Even worse, if the
  576. * output queue was also full, this routine would never get called again and
  577. * we would have a lock state. It DOES happen. To guard against this, the
  578. * transmit clean-up handler detects the out-of-TFDs state and calls this
  579. * function. The clean-up handler also runs from netTask.
  580. *
  581. * Note that this function is ALWAYS called between an splnet() and an splx().
  582. * This is true because netTask(), and ether_output() take care of
  583. * this when calling this function. Therefore, no calls to these spl functions
  584. * are needed anywhere in this output thread.
  585. */
  587. #ifdef BSD43_DRIVER
  588. static void eexTxStartup
  589.     (
  590.     int unit
  591.     )
  592.     {
  593.     DRV_CTRL * pDrvCtrl;
  595.     pDrvCtrl = & drvCtrl [unit];
  596. #else
  597. static void eexTxStartup
  598.     (
  599.     DRV_CTRL *  pDrvCtrl
  600.     )
  601.     {
  602. #endif
  603.     MBUF * pMbuf;
  604.     int length;
  605.     EEX_SHORTLINK tfdOffset;
  607.     /*
  608.      * Loop until there are no more packets ready to send or we
  609.      * have insufficient resources left to send another one.
  610.      */
  612.     while (pDrvCtrl->idr.ac_if.if_snd.ifq_head)
  613.         {
  614.         IF_DEQUEUE (&pDrvCtrl->idr.ac_if.if_snd, pMbuf);  /* dequeue a packet */
  616.         copy_from_mbufs (buffer, pMbuf, length);
  617.         length = max (ETHERSMALL, length);
  619.         if ( (etherOutputHookRtn != NULL) &&
  620.             (* etherOutputHookRtn)
  621.             (&pDrvCtrl->idr, buffer, length))
  622.             continue;
  624.         /* get free tfd */
  625.         tfdOffset = eexQGet (pDrvCtrl, (EEX_LIST *)&pDrvCtrl->tfdQueue);
  627.         if (tfdOffset == NULL)
  628.             break;                              /* out of TFD's */
  630.         /* copy header and data to contiguous board memory areas */
  632.         sysOutWord (pDrvCtrl->port + WRPTR, tfdOffset + TF_BUFFER);
  633.         sysOutWordString (pDrvCtrl->port + DXREG, (short *)buffer,
  634.                           (length + 1) / 2);
  635. #ifndef EEX_AL_LOC
  636.         length -= EH_SIZE;              /* compensate for header not in data */
  637. #endif  /* EEX_AL_LOC */
  638.         sysOutWord (pDrvCtrl->port + WRPTR, tfdOffset + TF_ACT_COUNT);
  639.         sysOutWord (pDrvCtrl->port + DXREG,
  640.                     (length & ACT_COUNT_MASK) | TBD_S_EOF);
  642. #ifndef EEX_AL_LOC
  643.         /* Move length/ethertype up to where 82586 expects it following dest. */
  645.         sysOutWord (pDrvCtrl->port + RDPTR, tfdOffset + TF_OLDLENGTH);
  646.         length = sysInWord (pDrvCtrl->port + DXREG);
  648.         /* separate read and write because both pointers increment */
  649.         /* on any access to DXREG */
  651.         sysOutWord (pDrvCtrl->port + WRPTR, tfdOffset + TF_NEWLENGTH);
  652.         sysOutWord (pDrvCtrl->port + DXREG, length);
  653. #endif  /* EEX_AL_LOC */
  655. #ifndef BSD43_DRIVER    /* BSD 4.4 ether_output() doesn't bump statistic. */
  656.         pDrvCtrl->idr.ac_if.if_opackets++;
  657. #endif
  659.         eexTxQPut (pDrvCtrl, tfdOffset);
  660.         }
  661.     }
  663. /*******************************************************************************
  664. *
  665. * eexInt - entry point for handling interrupts from the 82586
  666. *
  667. * The interrupting events are acknowledged to the device, so that the device
  668. * will deassert its interrupt signal. The amount of work done here is kept
  669. * to a minimum; the bulk of the work is defered to the netTask. Several flags
  670. * are used here to synchronize with task level code and eliminate races.
  671. */
  673. static void eexInt
  674.     (
  675.     DRV_CTRL *pDrvCtrl
  676.     )
  677.     {
  678.     UINT16  event;
  679.     int unit;
  681.     unit = pDrvCtrl->idr.ac_if.if_unit;
  682.     sysBusIntAck (pDrvCtrl->intLevel);
  684.     event = sysInWord (pDrvCtrl->port + SCB_STATUS) & (SCB_S_CX | SCB_S_FR | SCB_S_CNA | SCB_S_RNR);
  686. #ifdef EEX_DEBUG
  687.     logMsg ("eex: interrupt: event=%xn", event, 0, 0, 0, 0, 0);
  688. #endif /* EEX_DEBUG */
  690.     eexCommand (pDrvCtrl, event);                        /* ack the events */
  692.     eex586IntAck (unit);                                /* ack 586 interrupt */
  694.     /* Handle transmitter interrupt */
  696.     if (event & SCB_S_CNA)                              /* reclaim tx tfds */
  697.         {
  699.         wdCancel(pDrvCtrl->wid);                /* canus delenda est */
  701.         if (pDrvCtrl->cleanQueue.head == NULL)      /* clean queue empty */
  702.             {
  703.             pDrvCtrl->cleanQueue.head = pDrvCtrl->cblQueue.head; /* new head */
  704.             pDrvCtrl->cleanQueue.tail = pDrvCtrl->cblQueue.tail; /* new tail */
  705.             }
  706.         else                                            /* concatenate queues */
  707.             {
  708.             pDrvCtrl->cleanQueue.tail = pDrvCtrl->cblQueue.tail;
  709.             }
  711.         if (!pDrvCtrl->txCleaning)                          /* not cleaning? */
  712.             {
  713.             pDrvCtrl->txCleaning = TRUE;                    /* set flag */
  714.             netJobAdd ( (FUNCPTR) eexTxCleanQ, (int) pDrvCtrl, 0, 0, 0, 0);
  715.                             /* defer cleanup */
  716.             }
  718.         if (pDrvCtrl->txQueue.head != NULL)             /* anything to flush? */
  719.             eexTxQFlush (pDrvCtrl);                      /* flush the tx q */
  720.         else
  721.             pDrvCtrl->txIdle = TRUE;                    /* transmitter idle */
  722.         }
  724.     /* Handle receiver interrupt */
  726.     if ( (event & SCB_S_FR) && !(pDrvCtrl->rcvHandling))
  727.         {
  728.         pDrvCtrl->rcvHandling = TRUE;
  729.         (void) netJobAdd ( (FUNCPTR) eexHandleRecvInt, (int) pDrvCtrl,0, 0, 0, 0);         /* netTask processes */
  730.         }
  731.          
  733.     /* dhe 10/20/94 could lose some packets here */
  734.     if ( (event & SCB_S_RNR) && !(pDrvCtrl->rcvHandling))
  735.         eexRxStartup(pDrvCtrl);
  737.     } 
  739. /*******************************************************************************
  740. *
  741. * eexTxCleanQ - checks errors in completed TFDs and moves TFDs to free queue
  742. *
  743. * This routine is executed by netTask. It "cleans" the TFDs on the clean-up
  744. * queue by checking each one for errors and then returning the TFD to the
  745. * "free TFD" queue. The startup routine is sometimes called here to eliminate
  746. * the lock-out case where the driver input queue is full but there are no
  747. * TFDs available.
  748. */
  750. static void eexTxCleanQ
  751.     (
  752.     DRV_CTRL *pDrvCtrl
  753.     )
  754.     {
  755.     EEX_SHORTLINK tfdOffset;
  756.     UINT16 status;
  757.     BOOL needTxStart;
  758.     int unit;
  760.     unit = pDrvCtrl->idr.ac_if.if_unit;
  762.     do
  763.         {
  764.         pDrvCtrl->txCleaning = TRUE;
  766.         if (pDrvCtrl->tfdQueue.head == NULL)              /* tfd queue empty */
  767.             needTxStart = TRUE;                           /* set flag */
  768.         else
  769.             needTxStart = FALSE;
  771.         /* process transmitted frames */
  773.         while (1)
  774.             {
  776.             /* Get TFD. No ints allowed while manipulating this queue. */
  778.             eex586IntDisable (unit);
  779.             tfdOffset = eexQGet (pDrvCtrl, (EEX_LIST *)&pDrvCtrl->cleanQueue);
  780.             eex586IntEnable (unit);
  781.             if (tfdOffset == NULL)
  782.                 break;
  784.             sysOutWord (pDrvCtrl->port + RDPTR, tfdOffset);
  785.             status = sysInWord (pDrvCtrl->port + DXREG);
  787.             pDrvCtrl->idr.ac_if.if_collisions +=         /* add any colls */
  788.                 (status & CFD_S_RETRY) ? 16 :  /* excessive colls */
  789.                 (status & CFD_S_COLL_MASK);    /* some colls */
  791.             if (!(status & CFD_S_OK))          /* packet not sent */
  792.                 {
  793.                 pDrvCtrl->idr.ac_if.if_oerrors++;        /* incr err count */
  794.                 pDrvCtrl->idr.ac_if.if_opackets--;       /* decr sent count */
  795.                 }
  797.             /* return to tfdQ */
  798.             eexQPut (pDrvCtrl, (EEX_LIST *)&pDrvCtrl->tfdQueue, tfdOffset);
  799.             }
  801.         if (needTxStart)                                  /* check flag */
  802. #ifdef BSD43_DRIVER
  803.             eexTxStartup (unit);
  804. #else
  805.             eexTxStartup (pDrvCtrl);
  806. #endif
  807.         pDrvCtrl->txCleaning = FALSE;
  808.         }
  809.     while (pDrvCtrl->cleanQueue.head != NULL);            /* check again */
  810.     }
  812. /*******************************************************************************
  813. *
  814. * eexHandleRecvInt - task level interrupt service for input packets
  815. *
  816. * This routine is called at task level indirectly by the interrupt
  817. * service routine to do any message received processing.
  818. */
  820. static void eexHandleRecvInt
  821.     (
  822.     DRV_CTRL *pDrvCtrl
  823.     )
  824.     {
  825.     EEX_SHORTLINK rfdOffset;
  827.     do
  828.         {
  829.         pDrvCtrl->rcvHandling = TRUE;             /* interlock with eexInt() */
  831.         while ( (rfdOffset = eexRxQGet (pDrvCtrl)) != NULL)
  832.             (void) eexReceive (pDrvCtrl, rfdOffset);
  834.         pDrvCtrl->rcvHandling = FALSE;            /* interlock with eexInt() */
  835.         }
  836.     while (eexRxQFull (pDrvCtrl));              /* make sure rx q still empty */
  837.     }
  839. /*******************************************************************************
  840. *
  841. * eexReceive - pass a received frame to the next layer up
  842. *
  843. * Strips the Ethernet header and passes the packet to the appropriate
  844. * protocol.
  845. * Is responsible for proper disposition of frame buffer in all cases.
  846. */
  848. static STATUS eexReceive
  849.     (
  850.     DRV_CTRL *pDrvCtrl,
  851.     EEX_SHORTLINK rfdOffset
  852.     )
  853.     {
  854.     struct ether_header *  pEh;
  855.     u_char *  pData;
  856.     int         len;
  857. #ifdef BSD43_DRIVER
  858.     UINT16      etherType;
  859. #endif
  860.     MBUF *  m = NULL;
  861.     UINT16      status;
  864.     /* Check packet for errors.  This should be completely unnecessary,
  865.      * but since Intel does not seem capable of explaining the exact
  866.      * functioning of the 'save bad frames' config bit, we will look for
  867.      * errors.
  868.      */
  870.     sysOutWord (pDrvCtrl->port + RDPTR, rfdOffset);
  871.     status = sysInWord (pDrvCtrl->port + DXREG);
  873.     if  (
  874.         ( status & ( RFD_S_OK | RFD_S_COMPLETE ) ) !=
  875.         ( RFD_S_OK | RFD_S_COMPLETE )
  876.         )
  877.         {
  878.         ++pDrvCtrl->idr.ac_if.if_ierrors;            /* bump error counter */
  879. #ifdef EEX_DEBUG1 /* dhe 10/20/94 */
  880.     logMsg ("case 1: status=%x,offset=%xn", status, rfdOffset, 0, 0, 0, 0);
  881. #endif
  882.         eexRxQPut (pDrvCtrl, rfdOffset);             /* free the RFD */
  883.         return (ERROR);
  884.         }
  886.     /* get frame length */
  888.     sysOutWord (pDrvCtrl->port + RDPTR, rfdOffset + RF_ACT_COUNT);
  889.     len = sysInWord (pDrvCtrl->port + DXREG) & ACT_COUNT_MASK;
  890. #ifndef EEX_AL_LOC
  891.     len += EH_SIZE;
  892. #endif  /* EEX_AL_LOC */
  894.     sysOutWord (pDrvCtrl->port + RDPTR, rfdOffset + RF_BUFFER);
  895.     sysInWordString (pDrvCtrl->port + DXREG, (short *) buffer, (len + 1) / 2);
  896.     pEh = (struct ether_header *)buffer;    /* get ptr to ethernet header */
  898.     /* Bump input packet counter. */
  900.     ++pDrvCtrl->idr.ac_if.if_ipackets;
  902.     /* Service input hook */
  904.     if ( (etherInputHookRtn != NULL) )
  905.         {
  906.         if  ( (* etherInputHookRtn) (&pDrvCtrl->idr, (char *)pEh, len) )
  907.             {
  908. #ifdef EEX_DEBUG1 /* dhe 10/20/94 */
  909.     logMsg ("case 2: status=%x, offset=%xn", status, rfdOffset, 0, 0, 0, 0);
  910. #endif
  911.             eexRxQPut (pDrvCtrl, rfdOffset);             /* free the RFD */
  912.             return (OK);
  913.             }
  914.         }
  916.     len -= EH_SIZE;
  917.     pData = (u_char *) buffer + EH_SIZE;
  918. #ifdef BSD43_DRIVER
  919.     etherType = ntohs (pEh->ether_type);
  920. #endif
  922.     m = copy_to_mbufs (pData, len, 0, &pDrvCtrl->idr);
  924.     if (m != NULL)
  925. #ifdef BSD43_DRIVER
  926.         do_protocol_with_type (etherType, m, &pDrvCtrl->idr, len);
  927. #else
  928.         do_protocol (pEh, m, &pDrvCtrl->idr, len);
  929. #endif
  930.     else
  931.         ++pDrvCtrl->idr.ac_if.if_ierrors;    /* bump statistic */
  933. #ifdef EEX_DEBUG1 /* dhe 10/20/94 */
  934.     logMsg ("case 3: status=%x, offset=%xn", status, rfdOffset, 0, 0, 0, 0);
  935. #endif
  936.     eexRxQPut (pDrvCtrl, rfdOffset);             /* free the RFD */
  938.     return (OK);
  939.     }
  941. /*******************************************************************************
  942. *
  943. * eexDeviceStart - reset and start the device
  944. *
  945. * This routine assumes interrupts from the device have been disabled, and
  946. * that the driver control structure has been initialized.
  947. */
  949. static STATUS eexDeviceStart
  950.     (
  951.     int unit                              /* physical unit number */
  952.     )
  953.     {
  954.     DRV_CTRL *pDrvCtrl;
  956.     /* Get pointers */
  958.     pDrvCtrl = & drvCtrl [unit];
  960.     /* Ensure the 82586 is in its reset state */
  962.     eex586SetReset (unit);
  964.     /* Initialize the SCP */
  966.     sysOutWord (pDrvCtrl->port + WRPTR, SCP_OFFSET);
  967.     sysOutWord (pDrvCtrl->port + DXREG, 0);     /* sysbus is 16-bit */
  968.     sysOutWord (pDrvCtrl->port + DXREG, 0);
  969.     sysOutWord (pDrvCtrl->port + DXREG, 0);
  970.     sysOutWord (pDrvCtrl->port + DXREG, ISCP_OFFSET);
  971.     sysOutWord (pDrvCtrl->port + DXREG, 0);
  973.     /* Initialize the ISCP */
  975.     sysOutWord (pDrvCtrl->port + WRPTR, ISCP_OFFSET);
  976.     sysOutWord (pDrvCtrl->port + DXREG, 1);     /* Set ISCP busy bit */
  977.     sysOutWord (pDrvCtrl->port + DXREG, SCB_OFFSET);
  978.     sysOutWord (pDrvCtrl->port + DXREG, 0);     /* SCB is zero-based */
  979.     sysOutWord (pDrvCtrl->port + DXREG, 0);
  981.     /* Initialize the SCB */
  983.     /* WRPTR is at the SCB following ISCP initialization */
  984.     sysOutWord (pDrvCtrl->port + DXREG, 0);
  985.     sysOutWord (pDrvCtrl->port + DXREG, 0);
  986.     sysOutWord (pDrvCtrl->port + DXREG, 0);
  987.     sysOutWord (pDrvCtrl->port + DXREG, 0);
  988.     sysOutWord (pDrvCtrl->port + DXREG, 0);
  989.     sysOutWord (pDrvCtrl->port + DXREG, 0);
  990.     sysOutWord (pDrvCtrl->port + DXREG, 0);
  991.     sysOutWord (pDrvCtrl->port + DXREG, 0);
  993.     /* Tell the device to read the SCP */
  995.     eex586ClearReset (unit);
  996.     eex586ChanAtn (pDrvCtrl);
  998.     /*
  999.      * The device will now read our SCP and ISCP. It will clear the busy
  1000.      * flag in the ISCP.
  1001.      */
  1003.     taskDelay (50);
  1004.     sysOutWord (pDrvCtrl->port + RDPTR, ISCP_OFFSET);
  1005.     if ( sysInByte (pDrvCtrl->port + DXREG) == 1 )
  1006.         {
  1007.         printf ("neex: device did not initializen");
  1008.         return (ERROR);
  1009.         }
  1011.     return (OK);
  1012.     }
  1014. /*******************************************************************************
  1015. *
  1016. * eexDiag - format and issue a diagnostic command
  1017. */
  1019. static void eexDiag
  1020.     (
  1021.     int unit
  1022.     )
  1023.     {
  1024.     DRV_CTRL *pDrvCtrl;
  1026.     pDrvCtrl = & drvCtrl [unit];
  1028.     bzero ( (char *)pDrvCtrl->pCfd, sizeof (CFD));      /* zero command frame */
  1030.     eexAction (unit, CFD_C_DIAG);                /* run diagnostics */
  1032.     if (!(pDrvCtrl->pCfd->cfdStatus & CFD_S_OK))
  1033.         printErr ("eexDiag: i82586 diagnostics failed.n");
  1034.     }
  1036. /*******************************************************************************
  1037. *
  1038. * eexConfig - format and issue a config command
  1039. */
  1041. static void eexConfig
  1042.     (
  1043.     int unit
  1044.     )
  1045.     {
  1046.     DRV_CTRL *pDrvCtrl;
  1048.     pDrvCtrl = & drvCtrl [unit];
  1050.     bzero ( (char *)pDrvCtrl->pCfd, sizeof (CFD));      /* zero command frame */
  1052.     /* Recommended i82586 User's Manual configuration values. */
  1054.     pDrvCtrl->pCfd->cfdConfig.byteCount         = 12;
  1055.     pDrvCtrl->pCfd->cfdConfig.fifoLimit         = 0x08;
  1056.     pDrvCtrl->pCfd->cfdConfig.srdy_saveBad      = 0x40;
  1058. #ifdef  EEX_AL_LOC
  1059.     pDrvCtrl->pCfd->cfdConfig.addrLen_loopback  = 0x2e;
  1060. #else
  1061.     pDrvCtrl->pCfd->cfdConfig.addrLen_loopback  = 0x26;
  1062. #endif  /* EEX_AL_LOC */
  1063.     pDrvCtrl->pCfd->cfdConfig.backoff           = 0x00;
  1064.     pDrvCtrl->pCfd->cfdConfig.interframe        = 0x60;
  1065.     pDrvCtrl->pCfd->cfdConfig.slotTimeLow       = 0x00;
  1066.     pDrvCtrl->pCfd->cfdConfig.slotTimeHi_retry  = 0xf2;
  1067.     pDrvCtrl->pCfd->cfdConfig.promiscuous       = 0x00; /* promiscuous off */
  1068.     pDrvCtrl->pCfd->cfdConfig.carrier_collision = 0x00;
  1069.     pDrvCtrl->pCfd->cfdConfig.minFrame          = 0x40;
  1071.     eexAction (unit, CFD_C_CONFIG);          /* configure the chip */
  1072.     }
  1074. /*******************************************************************************
  1075. *
  1076. * eexIASetup - format and issue an interface address command
  1077. */
  1079. static void eexIASetup
  1080.     (
  1081.     int unit
  1082.     )
  1083.     {
  1084.     DRV_CTRL *pDrvCtrl;
  1086.     pDrvCtrl = & drvCtrl [unit];
  1088.     bzero ( (char *)pDrvCtrl->pCfd, sizeof (CFD));      /* zero command frame */
  1090.     bcopy   (
  1091.             (char *)pDrvCtrl->idr.ac_enaddr,
  1092.             (char *)pDrvCtrl->pCfd->cfdIASetup.ciAddress,
  1093.             6
  1094.             );
  1096.     eexAction (unit, CFD_C_IASETUP);         /* set up the address */
  1097.     }
  1099. /*******************************************************************************
  1100. *
  1101. * eexRxStartup - start up the Receive Unit
  1102. *
  1103. * Starts up the Receive Unit.  Assumes that the receive structures are set up.
  1104. */
  1106. static void eexRxStartup
  1107.     (
  1108.     DRV_CTRL *pDrvCtrl
  1109.     )
  1110.     {
  1112.     if (sysInWord (pDrvCtrl->port + SCB_STATUS) & SCB_S_RUREADY)
  1113.         /* already running */
  1114.         return;
  1116.     /* zero the status and EL bit of the current queue tail dhe 10/26/94 */
  1117.     sysOutWord(pDrvCtrl->port + WRPTR, pDrvCtrl->rxQueue.tail);
  1118.     sysOutWord(pDrvCtrl->port + DXREG, 0);
  1119.     sysOutWord(pDrvCtrl->port + DXREG, 0);
  1121.     /* set up head and tail to point to original list  dhe 10/26/94 */
  1122.     pDrvCtrl->rxQueue.head = pDrvCtrl->rfdBase;
  1123.     pDrvCtrl->rxQueue.tail = pDrvCtrl->lastFd;
  1125.     /* Point receive area to list of free frames */
  1126.     sysOutWord (pDrvCtrl->port + SCB_RFA, pDrvCtrl->freeRfd);
  1127.     
  1128.     /*
  1129.      * need to rebuild the rfd list here--copy code from initialization
  1130.      * routine.  set queue.head and queue.tail.
  1131.      */
  1134.     eex586IntDisable (pDrvCtrl->idr.ac_if.if_unit);
  1136.     if ( (sysInWord (pDrvCtrl->port + SCB_STATUS) & SCB_S_RUMASK)
  1137.         != SCB_S_RUIDLE)
  1138.         eexCommand (pDrvCtrl, SCB_C_RUABORT);            /* abort if not idle */
  1140.     eexCommand (pDrvCtrl, SCB_C_RUSTART);              /* start receive unit */
  1141.     eex586IntEnable (pDrvCtrl->idr.ac_if.if_unit);
  1143.     }
  1145. /*******************************************************************************
  1146. *
  1147. * eexAction - execute the specified action with the CFD pointed to in pDrvCtrl
  1148. *
  1149. * Do the command contained in the CFD synchronously, so that we know
  1150. * it's complete upon return.  This routine assumes that interrupts from the
  1151. * device have been disabled.
  1152. */
  1154. static void eexAction
  1155.     (
  1156.     int    unit,
  1157.     UINT16 action
  1158.     )
  1159.     {
  1160.     CFD      *pCfd;
  1161.     DRV_CTRL *pDrvCtrl;
  1163.     pDrvCtrl = & drvCtrl [unit];
  1164.     pCfd = pDrvCtrl->pCfd;      /* Building command in scratch area */
  1166.     while (1)                   /* wait for idle command unit */
  1167.         {
  1168.         if ( (sysInWord (pDrvCtrl->port + SCB_STATUS) & SCB_S_CUMASK)
  1169.             == SCB_S_CUIDLE)
  1170.             break;
  1171.         }
  1173.     { /* Prepare and issue the command to the device */
  1175.     /* fill in CFD */
  1177.     pCfd->cfdStatus  = 0;                       /* clear status */
  1178.     pCfd->cfdCommand = CFD_C_EL | action;       /* fill in action */
  1180.     /* and the SCB */
  1182.     sysOutWord (pDrvCtrl->port + SCB_COMMAND,
  1183.                         SCB_S_CX |              /* ack any events */
  1184.                         SCB_S_FR |
  1185.                         SCB_S_CNA |
  1186.                         SCB_S_RNR |
  1187.                         SCB_C_CUSTART);         /* start command unit */
  1189.     /* Point SCB to command area in board memory */
  1191.     sysOutWord (pDrvCtrl->port + SCB_CBL, CFD_OFFSET);
  1193.     /* Copy CFD to board memory */
  1195.     sysOutWord (pDrvCtrl->port + WRPTR, CFD_OFFSET);
  1196.     sysOutWordString (pDrvCtrl->port + DXREG, (short *) pCfd, sizeof (CFD) / 2);
  1198.     eex586ChanAtn (pDrvCtrl);               /* notify device of new command */
  1199.     }
  1201.     while (1)               /* wait for command acceptance and interrupt */
  1202.         {
  1203.         if ( (sysInWord (pDrvCtrl->port + SCB_COMMAND) == 0)
  1204.             && (sysInWord (pDrvCtrl->port + SCB_STATUS) & SCB_S_CNA))
  1205.             break;
  1206.         }
  1208.     /* Copy updated CFD back to system memory */
  1210.     sysOutWord (pDrvCtrl->port + RDPTR, CFD_OFFSET);
  1211.     sysInWordString (pDrvCtrl->port + DXREG, (short *) pCfd, sizeof (CFD) / 2);
  1213.     /* Acknowledge the event to the device */
  1215.     sysOutWord(pDrvCtrl->port + SCB_COMMAND, SCB_S_CX | SCB_S_CNA);
  1216.     eex586ChanAtn (pDrvCtrl);
  1218.     while (1)               /* wait for acknowledge acceptance */
  1219.         {
  1220.         if (sysInWord (pDrvCtrl->port + SCB_COMMAND) == 0)
  1221.             break;
  1222.         }
  1223.     }
  1225. /*******************************************************************************
  1226. *
  1227. * eexCommand - deliver a command to the 82586 via SCB
  1228. *
  1229. * This function causes the device to execute a command. It should be called
  1230. * with interrupts from the device disabled. An error status is returned if
  1231. * the command field does not return to zero, from a previous command, in a
  1232. * reasonable amount of time.
  1233. */
  1235. static STATUS eexCommand
  1236.     (
  1237.     DRV_CTRL *pDrvCtrl,
  1238.     UINT16    cmd
  1239.     )
  1240.     {
  1241.     int loopy;
  1243.     for (loopy = 0x8000; loopy--;)
  1244.         {
  1245.         /* wait for cmd zero */
  1246.         if (sysInWord (pDrvCtrl->port + SCB_COMMAND) == 0)
  1247.             break;
  1248.         }
  1250.     if (loopy > 0)
  1251.         {
  1252.         /* fill in command */
  1253.         sysOutWord (pDrvCtrl->port + SCB_COMMAND, cmd);
  1254.         eex586ChanAtn (pDrvCtrl);    /* channel attention */
  1255.         return (OK);
  1256.         }
  1257.     else
  1258.         {
  1259.         logMsg("eex driver: command field frozenn", 0, 0, 0, 0, 0, 0);
  1260.         return (ERROR);
  1261.         }
  1262.     }
  1264. /*******************************************************************************
  1265. *
  1266. * eexTxQPut - place a transmit frame on the transmit queue
  1267. *
  1268. * The TFD has been filled in with the network pertinent data. This
  1269. * routine will enqueue the TFD for transmission and attempt to feed
  1270. * the queue to the device.
  1271. */
  1273. static void eexTxQPut
  1274.     (
  1275.     DRV_CTRL *pDrvCtrl,
  1276.     EEX_SHORTLINK tfdOffset
  1277.     )
  1278.     {
  1279.     int unit;
  1281.     unit = pDrvCtrl->idr.ac_if.if_unit;
  1283.     eex586IntDisable (pDrvCtrl->idr.ac_if.if_unit);  /* disable dev ints */
  1285.     if (pDrvCtrl->txQueue.head != NULL)
  1286.         {
  1287.         /* Clear EL bit on previous tail frame */
  1289.         sysOutWord (pDrvCtrl->port + WRPTR,
  1290.                     pDrvCtrl->txQueue.tail + TF_COMMAND);
  1291.         sysOutWord (pDrvCtrl->port + DXREG, CFD_C_XMIT);
  1292.         }
  1293.         
  1294.     /* enqueue the TFD */
  1296.     eexQPut (pDrvCtrl, (EEX_LIST *)&pDrvCtrl->txQueue, tfdOffset);
  1298.     sysOutWord (pDrvCtrl->port + WRPTR, pDrvCtrl->txQueue.tail + TF_COMMAND);
  1299.     sysOutWord (pDrvCtrl->port + DXREG, CFD_C_XMIT | CFD_C_EL);
  1301.     if (pDrvCtrl->txIdle)                             /* transmitter idle */
  1302.         eexTxQFlush (pDrvCtrl);                        /* flush txQueue */
  1304.     eex586IntEnable (pDrvCtrl->idr.ac_if.if_unit);  /* enable dev ints */
  1305.     }
  1307. /*******************************************************************************
  1308. *
  1309. * eexTxQFlush - make cmd unit of device start processing cmds
  1310. *
  1311. * This routine flushes the contents of the txQ to the cblQ and starts the
  1312. * device transmitting the cblQ. Called only if transmit queue is not empty.
  1313. * Sometimes called from interrupt handler.
  1314. */
  1316. static void eexTxQFlush
  1317.     (
  1318.     DRV_CTRL *pDrvCtrl
  1319.     )
  1320.     {
  1321.     extern int sysClkRateGet();     /* we call this */
  1323.     pDrvCtrl->cblQueue.head = pDrvCtrl->txQueue.head;   /* remember cbl head */
  1324.     pDrvCtrl->cblQueue.tail = pDrvCtrl->txQueue.tail;   /* remember cbl tail */
  1325.     eexQInit ( (EEX_LIST *)&pDrvCtrl->txQueue);         /* tx queue now empty */
  1327.     sysOutWord(pDrvCtrl->port + SCB_CBL, pDrvCtrl->cblQueue.head);
  1329.     pDrvCtrl->txIdle = FALSE;                   /* transmitter busy */
  1331.     /* start watchdog */
  1333.     wdStart (
  1334.             pDrvCtrl->wid,
  1335.             (int) (sysClkRateGet() >> 1),
  1336.             (FUNCPTR) eexWatchDog,
  1337.             pDrvCtrl->idr.ac_if.if_unit
  1338.             );
  1340.     /* start command unit */
  1342.     eexCommand (pDrvCtrl, SCB_C_CUSTART);
  1343.     }
  1345. /*******************************************************************************
  1346. *
  1347. * eexRxQPut - return a RFD to the receive queue for use by the device
  1348. */
  1350. static void eexRxQPut
  1351.     (
  1352.     DRV_CTRL *pDrvCtrl,
  1353.     EEX_SHORTLINK rfdOffset
  1354.     )
  1355.     {
  1356.     EEX_SHORTLINK rxTail;
  1357.     UINT16 status;
  1358.     EEX_SHORTLINK rbdOffset;    /* dhe 10/24/94 */
  1361.     sysOutWord (pDrvCtrl->port + WRPTR, rfdOffset);
  1362.     sysOutWord (pDrvCtrl->port + DXREG, 0);     /* clear status */
  1363.     sysOutWord (pDrvCtrl->port + DXREG, CFD_C_EL); /* new end of list */
  1365.     /* dhe 10/24/94 get the buffer pointer */
  1366.     sysOutWord(pDrvCtrl->port + RDPTR, rfdOffset + RB_OFFSET);
  1367.     rbdOffset = sysInWord(pDrvCtrl->port + DXREG);
  1369.     /* dhe 10/24/94 TEST TEST zero the actual count of the buffer */
  1370.     sysOutWord(pDrvCtrl->port + WRPTR, rbdOffset);
  1371.     sysOutWord(pDrvCtrl->port + DXREG, 0);
  1374.     rxTail = pDrvCtrl->rxQueue.tail;         /* remember tail */
  1376.     /* Put the RFD on the list */
  1378.     eexQPut (pDrvCtrl, (EEX_LIST *) & pDrvCtrl->rxQueue, rfdOffset);
  1380.     if (rxTail != NULL)
  1381.         {
  1382.         sysOutWord (pDrvCtrl->port + WRPTR, rxTail + RF_COMMAND);
  1383.         sysOutWord (pDrvCtrl->port + DXREG, 0); /* clear old tail EL */
  1385.         sysOutWord (pDrvCtrl->port + RDPTR, rxTail);
  1386.         status = sysInWord (pDrvCtrl->port + DXREG);
  1387.         if (status & (CFD_S_COMPLETE | CFD_S_BUSY))
  1388.             {
  1389.             pDrvCtrl->freeRfd = rfdOffset;       /* link questionable */
  1390.             }
  1391.         else if (!(sysInWord (pDrvCtrl->port + SCB_STATUS) & SCB_S_RUREADY))
  1392.             /* receiver dormant */
  1393.             {
  1394.             eexRxStartup (pDrvCtrl);             /* start receive unit */
  1395.             }
  1396.         }
  1397.     else
  1398.         {
  1399.         pDrvCtrl->freeRfd = rfdOffset;           /* first free RFD */
  1400.         }
  1401.     }
  1403. /*******************************************************************************
  1404. *
  1405. * eexRxQGet - get a successfully received frame from the receive queue
  1406. *
  1407. * RETURNS: ptr to valid RFD, or NULL if none available
  1408. */
  1410. static EEX_SHORTLINK eexRxQGet
  1411.     (
  1412.     DRV_CTRL *pDrvCtrl
  1413.     )
  1414.     {
  1415.     EEX_SHORTLINK rfdOffset = NULL;
  1417.     if (eexRxQFull (pDrvCtrl))
  1418.         rfdOffset = eexQGet (pDrvCtrl, (EEX_LIST *)&pDrvCtrl->rxQueue);
  1420.     return (rfdOffset);
  1421.     }
  1423. /*******************************************************************************
  1424. *
  1425. * eexRxQFull - boolean function to determine fullness of receive queue
  1426. *
  1427. * RETURNS: TRUE if completely received frame is available, FALSE otherwise.
  1428. */
  1430. static BOOL eexRxQFull
  1431.     (
  1432.     DRV_CTRL *pDrvCtrl
  1433.     )
  1434.     {
  1436.     return (
  1437.         (pDrvCtrl->rxQueue.head != NULL) &&
  1438.         (
  1439.         sysOutWord (pDrvCtrl->port + RDPTR, pDrvCtrl->rxQueue.head),
  1440.         sysInWord (pDrvCtrl->port + DXREG) & CFD_S_COMPLETE
  1441.         )
  1442.         );
  1443.     }
  1445. /*******************************************************************************
  1446. *
  1447. * eexQInit - initialize a singly linked node queue
  1448. */
  1450. static void eexQInit
  1451.     (
  1452.     EEX_LIST *pQueue
  1453.     )
  1454.     {
  1455.     pQueue->head = pQueue->tail = NULL;         /* init head & tail */
  1456.     }
  1458. /*******************************************************************************
  1459. *
  1460. * eexQGet - get a node from the head of a node queue
  1461. *
  1462. * RETURNS: ptr to useable node, or NULL ptr if none available
  1463. * Since we never alter links, we are taking the last node when head==tail.
  1464. */
  1466. static EEX_SHORTLINK eexQGet
  1467.     (
  1468.     DRV_CTRL *pDrvCtrl,
  1469.     EEX_LIST *pQueue
  1470.     )
  1471.     {
  1472.     EEX_SHORTLINK pNode;
  1474.     if ( (pNode = (EEX_SHORTLINK) pQueue->head) != NULL) /* if list not empty */
  1475.         {
  1476.         if (pQueue->head == pQueue->tail)
  1477.             pQueue->head =                              /* list now empty */
  1478.             pQueue->tail = NULL;
  1479.         else
  1480.             pQueue->head = SUCC_FD (pNode);             /* advance ptr */
  1481.         }
  1483.     return (pNode);
  1484.     }
  1486. /*******************************************************************************
  1487. *
  1488. * eexQPut - put a node on the tail of a node queue
  1489. */
  1491. static void eexQPut
  1492.     (
  1493.     DRV_CTRL *pDrvCtrl,
  1494.     EEX_LIST *pQueue,
  1495.     EEX_SHORTLINK pNode
  1496.     )
  1497.     {
  1498.     /* assert (SUCC_FD (pQueue->tail) == pNode); */
  1500.     if (pQueue->head == NULL)                   /* if list empty */
  1501.         pQueue->head = pNode;                   /* new element is head */
  1503.     pQueue->tail = pNode;                       /* update tail ptr */
  1504.     }
  1506. /*******************************************************************************
  1507. *
  1508. * eexWatchDog - if the watchdog timer fired off, we've hung during a transmit
  1509. *
  1510. * Check the scb command to verify and if so, reinit.
  1511. */
  1513. static void eexWatchDog
  1514.     (
  1515.     int unit        /* unit number */
  1516.     )
  1518.     {
  1519.     DRV_CTRL *pDrvCtrl;
  1521.     pDrvCtrl = & drvCtrl [unit];
  1523.     /* sanity check.
  1524.      * If the scb status indicates that CU (transmit) is active
  1525.      * It might make sense to loop through the cfd's to look for
  1526.      * a complete bit as a sanity check , but given that we are
  1527.      * here and that transmit was active, we will go ahead and do
  1528.      * a reset.
  1529.      */
  1531.     if (sysInWord (pDrvCtrl->port + SCB_STATUS) & SCB_S_CUACTIVE)
  1532.         {
  1533.         pDrvCtrl->transLocks++;                     /* local failure count */
  1534.         pDrvCtrl->idr.ac_if.if_oerrors++;           /* incr err count */
  1535.         pDrvCtrl->idr.ac_if.if_opackets--;          /* decr sent count */
  1536.         DUMMY(unit);
  1537.         }
  1538.     }
  1540. /*******************************************************************************
  1541. *
  1542. * eex586Init - Initialize board features
  1543. *
  1544. * Does pretty much everything to initialize the 82586 and its memory
  1545. * structures, either in this routine or in called routines.
  1546. */
  1548. static STATUS eex586Init
  1549.     (
  1550.     int unit
  1551.     )
  1552.     {
  1553.     DRV_CTRL *pDrvCtrl;
  1554.     int ix;
  1555.     int port;
  1556.     EEX_SHORTLINK currentFd;
  1557.     /**** dhe 10/26/94 moved to global for reassigning during restart
  1558.     EEX_SHORTLINK lastFd;
  1559.     ****/
  1560.     int connValue;
  1562.     pDrvCtrl = & drvCtrl [unit];
  1564.     port = pDrvCtrl->port;
  1565.     eex586IntDisable (unit);            /* disable device interrupts */
  1567.     /* extract setup information from the board's EEPROM */
  1568.     /* Remember that readEEPROM() sets the 82586 reset condition. */
  1570.     pDrvCtrl->setup = eexReadEEPROM (pDrvCtrl, EEX_EEPROM_SETUP);
  1571.     pDrvCtrl->tpeBit = eexReadEEPROM (pDrvCtrl, EEX_EEPROM_TPE_BIT);
  1572.     pDrvCtrl->memSetup.wordView.memPage =
  1573.                 eexReadEEPROM (pDrvCtrl, EEX_EEPROM_MEMPAGE);
  1574.     pDrvCtrl->memSetup.wordView.memDecode =
  1575.                 eexReadEEPROM (pDrvCtrl, EEX_EEPROM_MEMDECODE);
  1577.     if (pDrvCtrl->attachment == ATTACHMENT_DEFAULT)
  1578.         if ( (pDrvCtrl->memSetup.wordView.memPage & MEMPAGE_AUTODETECT) != 0)
  1579.             {
  1581.             /* Here we would figure out which connector is in use;
  1582.              * "auto-detect" relies on software to do the actual detection.
  1583.              */
  1585.             }
  1586.         else
  1587.             {
  1588.             if ( (pDrvCtrl->setup & SETUP_BNC) == 0)
  1589.                 pDrvCtrl->attachment = ATTACHMENT_AUI;
  1590.             else if ( (pDrvCtrl->tpeBit & TPE_BIT) == 0)
  1591.                 pDrvCtrl->attachment = ATTACHMENT_BNC;
  1592.             else
  1593.                 pDrvCtrl->attachment = ATTACHMENT_RJ45;
  1594.             }
  1596.     /* Tell the board hardware which connector we're using */
  1598.     connValue = sysInByte (port + ECR1) & ~(CONN_INTEGRITY | CONN_TRANSCEIVER);
  1599.     switch (pDrvCtrl->attachment)
  1600.         {
  1601.         case ATTACHMENT_AUI:
  1602.             break;
  1603.         case ATTACHMENT_BNC:
  1604.             connValue |= CONN_TRANSCEIVER;
  1605.             break;
  1606.         case ATTACHMENT_RJ45:
  1607.             connValue |= CONN_TRANSCEIVER | CONN_INTEGRITY;
  1608.             break;
  1609.         }
  1611.     /* 17jan95  jag
  1612.      * Only send the connector selection command if the board is
  1613.      * NOT in "auto-detect" mode.  (If the board is in
  1614.      * "auto-detect" mode, another command might disrupt the
  1615.      * auto-detected mode).
  1616.      */
  1617.     if ( (pDrvCtrl->memSetup.wordView.memPage & MEMPAGE_AUTODETECT) == 0)
  1618.         sysOutByte (port + ECR1, connValue);
  1620.     /* get our enet addr */
  1622.     if (eexEnetAddrGet (pDrvCtrl, (char *)pDrvCtrl->idr.ac_enaddr) == ERROR)
  1623.         {
  1624.         errnoSet (S_iosLib_INVALID_ETHERNET_ADDRESS);
  1625.         return (ERROR);
  1626.         }
  1628.     /* Connect the interrupt handler */
  1630.     if (intConnect ( (VOIDFUNCPTR *)INUM_TO_IVEC (pDrvCtrl->ivec),
  1631.                     eexInt, (int)pDrvCtrl) == ERROR)
  1632.         return (ERROR);
  1634.     /* Start the device */
  1636.     if ( eexDeviceStart (unit) == ERROR )
  1637.         return (ERROR);
  1639.     eexDiag (unit);                             /* run diagnostics */
  1640.     eexConfig (unit);                           /* configure chip */
  1641.     eexIASetup (unit);                          /* set up address */
  1643.     /* Carve up the shared memory region into the specific sections */
  1645.     pDrvCtrl->rfdBase =
  1646.             (TFD_OFFSET + (sizeof (TFRAME) * pDrvCtrl->nTFDs));
  1648.     /* create the free tfd queue; nTFDs is non-zero */
  1650.     for (ix = 0, currentFd = TFD_OFFSET;
  1651.          ix < pDrvCtrl->nTFDs;
  1652.          ix ++, pDrvCtrl->lastFd = currentFd, currentFd += sizeof (TFRAME))
  1653.         {
  1655.         /* Initialize the TFD to link to next TFD, point to adjacent TBD */
  1657.         sysOutWord (port + WRPTR, currentFd);
  1658.         sysOutWord (port + DXREG, 0);                           /* status */
  1659.         sysOutWord (port + DXREG, CFD_C_XMIT);                  /* command */
  1660.         sysOutWord (port + DXREG, currentFd + sizeof (TFRAME)); /* TFD link */
  1661. #ifdef  EEX_AL_LOC
  1662.         sysOutWord (port + DXREG, currentFd + sizeof (TFD));    /* TBD ptr */
  1663. #else
  1664.         sysOutWord (port + DXREG, currentFd + sizeof (TFD) +
  1665.                                   FRAME_SIZE);                  /* TBD ptr */
  1666.         sysOutWord (port + WRPTR, currentFd + sizeof (TFD) +
  1667.                                   FRAME_SIZE);          /* point to TBD */
  1668. #endif  /* EEX_AL_LOC */
  1670.         /* Initialize the TBD following the above TFD */
  1672.         sysOutWord (port + DXREG, 0);                   /* status */
  1673.         sysOutWord (port + DXREG, 0xffff);              /* next TBD */
  1674. #ifdef  EEX_AL_LOC
  1675.         sysOutWord (port + DXREG,                       /* buffer address */
  1676.                     currentFd + sizeof (TFD) + sizeof (TBD));
  1677. #else
  1678.         sysOutWord (port + DXREG,                       /* buffer address */
  1679.                     currentFd + sizeof (TFD) + EH_SIZE);
  1680. #endif  /* EEX_AL_LOC */
  1681.         sysOutWord (port + DXREG, 0);                   /* buffer add. hi */
  1682.         }
  1684.     /* Fix the link field of the last TFD to point to the first */
  1686.     sysOutWord (port + WRPTR, pDrvCtrl->lastFd + TF_LINK);
  1687.     sysOutWord (port + DXREG, TFD_OFFSET);
  1689.     pDrvCtrl->tfdQueue.head = TFD_OFFSET;       /* Initialize queues */
  1690.     pDrvCtrl->tfdQueue.tail = pDrvCtrl->lastFd;
  1691.     eexQInit ( (EEX_LIST *)&pDrvCtrl->txQueue);    /* to be sent queue */
  1692.     eexQInit ( (EEX_LIST *)&pDrvCtrl->cblQueue);   /* actively sending queue */
  1693.     eexQInit ( (EEX_LIST *)&pDrvCtrl->cleanQueue); /* queue of TFDs to clean */
  1695.     /* create all the receive frame descriptors */
  1697.     for (ix = 0, currentFd = pDrvCtrl->rfdBase;
  1698.          ix < pDrvCtrl->nRFDs;
  1699.          ix ++, pDrvCtrl->lastFd = currentFd, currentFd += sizeof (RFRAME))
  1700.         {
  1702.         /* Initialize the RFD to link to next RFD, point to following RBD */
  1704.         sysOutWord (port + WRPTR, currentFd);
  1705.         sysOutWord (port + DXREG, 0);                           /* status */
  1706.         sysOutWord (port + DXREG, 0);                           /* command */
  1707.         sysOutWord (port + DXREG, currentFd + sizeof (RFRAME)); /* RFD link */
  1708. #ifdef  EEX_AL_LOC
  1709.         sysOutWord (port + DXREG, currentFd + sizeof (RFD));    /* RBD ptr */
  1710. #else
  1711.         sysOutWord (port + DXREG, currentFd + sizeof (RFD) +
  1712.                                   FRAME_SIZE);                  /* RBD ptr */
  1713.         sysOutWord (port + WRPTR, currentFd + sizeof (RFD) +
  1714.                                   FRAME_SIZE);          /* point to RBD */
  1715. #endif  /* EEX_AL_LOC */
  1717.         /* Initialize the RBD following the above RFD */
  1719.         sysOutWord (port + DXREG, 0);                   /* act. count */
  1720.         sysOutWord (port + DXREG, 0xffff);              /* next RBD */
  1721. #ifdef  EEX_AL_LOC
  1722.         sysOutWord (port + DXREG,                       /* buffer address */
  1723.                     currentFd + sizeof (RFD) + sizeof (RBD));
  1724. #else
  1725.         sysOutWord (port + DXREG,                       /* buffer address */
  1726.                     currentFd + sizeof (RFD) + EH_SIZE);
  1727. #endif  /* EEX_AL_LOC */
  1728.         sysOutWord (port + DXREG, 0);                   /* buffer add. hi */
  1729.         sysOutWord (port + DXREG, RBD_M_EL + FRAME_SIZE); /* buffer size */
  1730.         }
  1732.     /* Fix the link field of the last RFD to point to the first */
  1734.     sysOutWord (port + WRPTR, pDrvCtrl->lastFd + RF_LINK);
  1735.     sysOutWord (port + DXREG, pDrvCtrl->rfdBase);
  1737.     pDrvCtrl->rxQueue.head = pDrvCtrl->rfdBase; /* Initialize queue */
  1738.     pDrvCtrl->rxQueue.tail = pDrvCtrl->lastFd;
  1739.     pDrvCtrl->freeRfd = pDrvCtrl->rxQueue.head;
  1741.     eex586IntAck (unit);                     /* clear any pended dev ints */
  1742.     eex586IntEnable (unit);                  /* enable interrupts at system */
  1743.     eexRxStartup (pDrvCtrl);                 /* start receive unit */
  1745.     return (OK);
  1746.     }
  1748. /*******************************************************************************
  1749. *
  1750. * eexEnetAddrGet - get OEM Ethernet address from EtherExpress on-board EEPROM
  1751. *
  1752. * The "OEM" (i.e. not necessarily assigned by Intel) Ethernet address for the
  1753. * board is contained in words 2, 3, and 4 of the on-board EEPROM.  Note that
  1754. * EEPROM addresses are WORD not byte addresses!
  1755. * The byte swapping arises from the address being stored in big-endian byte
  1756. * order, apparently in approximation of the transmitted order (but the bits
  1757. * would have to be reversed for true transmitted bit order).
  1758. */
  1760. static STATUS eexEnetAddrGet
  1761.     (
  1762.     DRV_CTRL *pDrvCtrl,
  1763.     char addr[]
  1764.     )
  1766.     {
  1767.     UINT16 eepromAddress;
  1768.     char *dest = addr;
  1769.     UINT16 t;
  1771.     for (eepromAddress = EEX_EEPROM_EA_HIGH;
  1772.          eepromAddress >= EEX_EEPROM_EA_LOW;
  1773.          eepromAddress--)
  1774.         {
  1775.         t = eexReadEEPROM (pDrvCtrl, eepromAddress);
  1776.         *dest++ = t >> 8;
  1777.         *dest++ = t & 0xff;
  1778.         }
  1779.     
  1780.     return (OK);
  1781.     }
  1783. /*******************************************************************************
  1784. *
  1785. * eex586IntAck - acknowledge EtherExpress 16 interrupt
  1786. *
  1787. * The board hardware conatains an interrupt latch which is cleared by clearing
  1788. * the interrupt enable bit.  We presume we want the interrupts enabled so we
  1789. * re-enable the interrupt.
  1790. */
  1792. static void eex586IntAck
  1793.     (
  1794.     int unit
  1795.     )
  1796.     {
  1797.     eex586IntDisable (unit);
  1798.     eex586IntEnable (unit);
  1800.     }
  1802. /*******************************************************************************
  1803. *
  1804. * eex586IntDisable - disable EtherExpress 16 interrupt
  1805. *
  1806. * Prevent the board's 82586 from interrupting the system.
  1807. * As noted in IntAck above, the board has an interrupt latch which is cleared
  1808. * "with the disable-enable interrupt bit".  We will assume that after the
  1809. * moment of disabling, pending interrupts will be latched and honored when
  1810. * the interrupt is re-enabled.  There is no evidence to support this
  1811. * assumption, and it should be tested some day.
  1812. */
  1814. static void eex586IntDisable
  1815.     (
  1816.     int unit
  1817.     )
  1818.     {
  1819.     DRV_CTRL *pDrvCtrl;
  1821.     pDrvCtrl = & drvCtrl [unit];
  1823.     sysOutByte (pDrvCtrl->port + SEL_IRQ, pDrvCtrl->irqCode);
  1825.     }
  1827. /*******************************************************************************
  1828. *
  1829. * eex586IntEnable - enable EtherExpress 16 interrupt
  1830. *
  1831. * Allow the board's 82586 to interrupt the system.
  1832. */
  1834. static void eex586IntEnable
  1835.     (
  1836.     int unit
  1837.     )
  1838.     {
  1839.     DRV_CTRL *pDrvCtrl;
  1841.     pDrvCtrl = & drvCtrl [unit];
  1843.     sysOutByte (pDrvCtrl->port + SEL_IRQ, pDrvCtrl->irqCode | IRQ_ENB);
  1845.     }
  1847. /*******************************************************************************
  1848. *
  1849. * eex586SetReset - reset the EtherExpress 16's  82586 chip
  1850. *
  1851. * Set chip into reset state (and hold it there until released elsewhere).
  1852. */
  1854. static void eex586SetReset
  1855.     (
  1856.     int unit
  1857.     )
  1858.     {
  1859.     DRV_CTRL *pDrvCtrl;
  1861.     pDrvCtrl = & drvCtrl [unit];
  1863.     sysOutByte (pDrvCtrl->port + EE_CTRL, RESET_82586);
  1865.     }
  1867. /*******************************************************************************
  1868. *
  1869. * eex586ClearReset - remove the EtherExpress 16's 82586 chip from reset state
  1870. *
  1871. * Clear the bit holding the chip's reset line enabled, allowing the chip
  1872. * to follow its power-on initialization sequence.
  1873. */
  1875. static void eex586ClearReset
  1876.     (
  1877.     int unit
  1878.     )
  1879.     {
  1880.     DRV_CTRL *pDrvCtrl;
  1882.     pDrvCtrl = & drvCtrl [unit];
  1884.     /* All other bits in this register should be zero when chip runs */
  1885.     sysOutByte (pDrvCtrl->port + EE_CTRL, 0);
  1887.     }
  1889. /*******************************************************************************
  1890. *
  1891. * eex586ChanAtn - assert Channel Attention to the EtherExpress 16's  82586 chip
  1892. *
  1893. * Channel Attention tells the 82586 to examine its System Control Block
  1894. * for commands and acknowledgements.
  1895. * This could really be a macro.
  1896. */
  1898. static void eex586ChanAtn
  1899.     (
  1900.     DRV_CTRL *pDrvCtrl
  1901.     )
  1902.     {
  1904.     /* The act of writing to the port does the job; data is irrelevant */
  1905.     sysOutByte (pDrvCtrl->port + CA_CTRL, 0);
  1907.     }
  1909. /*******************************************************************************
  1910. *
  1911. * eexReadEEPROM - read one word from the on-board EEPROM
  1912. *
  1913. * Note that a necessary side effect of accessing the EEPROM is to set the
  1914. * RESET_82586 bit, because the 82586's bus signals must be disabled.
  1915. * Note that EEPROM addresses are WORD not byte addresses!
  1916. */
  1918. static UINT16 eexReadEEPROM
  1919.     (
  1920.     DRV_CTRL *pDrvCtrl,
  1921.     UINT16 address
  1922.     )
  1923.     {
  1924.     int port;
  1925.     UCHAR eeCtrl;               /* maintains current port contents */
  1926.     UINT16 value;
  1928.     port = pDrvCtrl->port + EE_CTRL;
  1929.     eeCtrl = sysInByte (port) & (EEPROM_CHIPSEL | RESET_82586);
  1930.     sysOutByte (port, eeCtrl | EEPROM_CHIPSEL);
  1932.     eexOutBitsEEPROM (port, 3, EEPROM_OP_READ);
  1933.     eexOutBitsEEPROM (port, 6, address);
  1934.     value = eexInBitsEEPROM (port, 16);
  1936.     eeCtrl &= EEPROM_CHIPSEL;           /* be certain chip select is clear */
  1937.     sysOutByte (port, eeCtrl);          /* also the data port */
  1938.     eexDelayEEPROM();                   /* data setup time */
  1939.     sysOutByte (port, eeCtrl | EEPROM_CLOCK);   /* clock with CS low? */
  1940.     eexDelayEEPROM();
  1941.     sysOutByte (port, eeCtrl);
  1942.     eexDelayEEPROM();
  1944.     return (value);
  1945.     }
  1947. /*******************************************************************************
  1948. *
  1949. * eexOutBitsEEPROM - send a bit string to the on-board EEPROM
  1950. *
  1951. * Shifts the righmost 'count' bits out, LEFTMOST first.
  1952. */
  1954. static void eexOutBitsEEPROM
  1955.     (
  1956.     int port,
  1957.     int count,
  1958.     UINT16 bits
  1959.     )
  1960.     {
  1961.     UCHAR eeCtrl;               /* maintains current port contents */
  1963.     bits <<= 16 - count;        /* left-justify the bit string */
  1964.     eeCtrl = sysInByte (port) & (EEPROM_CHIPSEL | RESET_82586);
  1966.     while (count--)
  1967.         {
  1968.         if (bits & 0x8000)
  1969.             eeCtrl |= EEPROM_OUTPUT;
  1970.         else
  1971.             eeCtrl &= ~EEPROM_OUTPUT;
  1973.         sysOutByte (port, eeCtrl);
  1974.         eexDelayEEPROM();                       /* data setup time */
  1975.         sysOutByte (port, eeCtrl | EEPROM_CLOCK);
  1976.         eexDelayEEPROM();
  1977.         sysOutByte (port, eeCtrl);
  1978.         eexDelayEEPROM();
  1979.         bits <<= 1;
  1980.         }
  1981.     sysOutByte (port, eeCtrl & ~EEPROM_OUTPUT); /* clear output bit */
  1982.     }
  1984. /*******************************************************************************
  1985. *
  1986. * eexInBitsEEPROM - receive a bit string from the on-board EEPROM
  1987. *
  1988. */
  1990. static UINT16 eexInBitsEEPROM
  1991.     (
  1992.     int port,
  1993.     int count
  1994.     )
  1995.     {
  1996.     UCHAR eeCtrl;               /* maintains current port contents */
  1997.     UINT16 value;               /* build result a bit at a time */
  1999.     eeCtrl = sysInByte (port) & (EEPROM_CHIPSEL | RESET_82586);
  2000.     value = 0;
  2002.     while (count--)
  2003.         {
  2004.         value <<= 1;
  2005.         sysOutByte (port, eeCtrl | EEPROM_CLOCK);
  2006.         eexDelayEEPROM();
  2007.         if (sysInByte (port) & EEPROM_INPUT)
  2008.             value |= 1;
  2009.         sysOutByte (port, eeCtrl);
  2010.         eexDelayEEPROM();
  2011.         }
  2012.     return (value);
  2013.     }
  2015. /*******************************************************************************
  2016. *
  2017. * eexDelayEEPROM - delay for EEPROM to recognize clock change
  2018. *
  2019. * Supposedly 4.0 microseconds for the Hyundai EEPROM.
  2020. */
  2022. static void eexDelayEEPROM
  2023.     (
  2024.     )
  2025.     {
  2026.     taskDelay (1);              /* gross overkill! */
  2027.     }
  2029. /******************************************************************************/
  2031. /* END OF FILE */