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

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

VxWorks

开发平台：

C/C++

if_elt.c：源码内容
  1. /* if_elt.c - 3Com 3C509 Ethernet network interface driver */
  3. /* Copyright 1993-1998 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01o,24sep98,dat  SPR 21261, discard packets only when complete.
  10. 01n,15jul97,spm  changed ioctl handler: added ARP request to SIOCSIFADDR and 
  11.                  cleaned up SIOCSIFFLAGS
  12. 01m,17mar97,hdn  added codes to load values in EEPROM to the address config
  13.  register and resource config register. 
  14. 01m,07apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  15. 01l,06mar96,hdn  supported PCMCIA EtherLink III card.
  16. 01k,14jun95,hdn  removed function declarations defined in sysLib.h.
  17. 01j,01feb95,jdi  doc cleanup.
  18. 01i,12nov94,tmk  removed some IMPORTed function decs and included unixLib.h
  19. 01h,28wed94,hdn  fixed a bug for RX incomplete packet.
  20.  cleaned up, eltFailure(), eltRxDrain(), eltTxCleanup().
  21. 01g,10apr94,hdn  made warm start work by clearing the interrupt latch bit.
  22. 01f,20feb94,bcs  add attachment (connector) type selection in eltattach(),
  23.                  relegate receive-in-net-task to compile-time selection
  24. 01e,07feb94,bcs  fix excessive transmit (and/or receive) net job queuing,
  25.                  add counters (as "ELT_TIMING") for netJobAdd() calls,
  26.                  remove rxInNetTask argument to eltattach(), update comments
  27. 01d,23jan94,bcs  call eltTxCleanup() and eltStatFlush() from interrupt handler,
  28.                  remove receive threshold (not obviously helping), add
  29.                  receive and interrupt timing statistics, fix comments
  30. 01c,16jan94,bcs  eliminated receive task (didn't help enough), consolidated
  31.                  packet receive routine into eltRxDrain, simplified transmit
  32.                  to handle only one packet at a time but 10% slower
  33. 01b,30dec93,bcs  fixed adapter failure int. handling, broke up attach routine
  34.                  added statistics capture
  35. 01a,10dec93,bcs  written
  36. */
  38. /*
  39. DESCRIPTION
  40. This module implements the 3Com 3C509 network adapter driver.
  42. The 3C509 (EtherLink(rg III) is not well-suited for use in real-time systems.
  43. Its meager on-board buffering (4K total; 2K transmit, 2K receive) forces the
  44. host processor to service the board at a high priority.  3Com makes a virtue
  45. of this necessity by adding fancy lookahead support and adding the label
  46. "Parallel Tasking" to the outside of the box.  Using 3Com's drivers, this board
  47. will look good in benchmarks that measure raw link speed.
  48. The board is greatly simplified by using the host CPU as a DMA controller.
  51. BOARD LAYOUT
  52. This device is soft-configured by a DOS-hosted program supplied by the
  53. manufacturer.  No jumpering diagram is required.
  56. EXTERNAL INTERFACE
  57. This driver provides the standard external interface with the following
  58. exceptions.  All initialization is performed within the attach routine and
  59. there is no separate initialization routine.  Thus, in the global interface
  60. structure, the function pointer to the initialization routine is NULL.
  62. There are two user-callable routines:
  63. .iP eltattach() 14
  64. publishes the `elt' interface and initializes the driver and device.
  65. .iP eltShow()
  66. displays statistics that are collected in the interrupt handler.
  67. .LP
  68. See the manual entries for these routines for more detail.
  71. SYSTEM RESOURCE USAGE
  72.     - one mutual exclusion semaphore
  73.     - one interrupt vector
  74.     - 16 bytes in the uninitialized data section (bss)
  75.     - 180 bytes (plus overhead) of malloc'ed memory per unit
  76.     - 1530 bytes (plus overhead) of malloc'ed memory per frame buffer,
  77.         minimum 5 frame buffers.
  80. SHORTCUTS
  81. The EISA and MCA versions of the board are not supported.
  83. Attachment selection assumes the board is in power-on reset state; a warm
  84. restart will not clear the old attachment selection out of the hardware,
  85. and certain new selections may not clear it either.  For example, if RJ45
  86. was selected, the system is warm-booted, and AUI is selected, the RJ45
  87. connector is still functional.
  89. Attachment type selection is not validated against the board's capabilities,
  90. even though there is a register that describes which connectors exist.
  92. The loaned buffer cluster type is MC_EI; no new type is defined yet.
  94. Although it seems possible to put the transmitter into a non-functioning
  95. state, it is not obvious either how to do this or how to detect the resulting
  96. state.  There is therefore no transmit watchdog timer.
  98. No use is made of the tuning features of the board; it is possible that
  99. proper dynamic tuning would reduce or eliminate the receive overruns
  100. that occur when receiving under task control (instead of in the ISR).
  103. TUNING HINTS
  104. More receive buffers (than the default 20) could help by allowing more
  105. loaning in cases of massive reception; four per receiving TCP connection plus
  106. four extras should be considered a minimum.
  109. INTERNAL
  110. A driver implementation for this board faces two conflicting network
  111. interface design goals:  (1) minimizing the time spent at interrupt level,
  112. and (2) servicing the board's input without dropping packets.  This
  113. implementation can be switched at run-time to meet either goal.
  115. Received data is drained from the board's FIFO in the interrupt handler.
  116. Many common TCP/IP occurrences, such as filling a 4K TCP window or
  117. fragmenting a 4K packet, can cause data to arrive faster than it can be
  118. drained at the task level.  This causes receive overruns and if the data
  119. stream continues for very long, the resulting retries may cause the transmitter
  120. to give up completely.
  122. One possible compromise has been tried and discarded: to receive at the
  123. task level in a high-priority task.  It turns out that the worst-case
  124. task-switching latency is too great to prevent the board from overrunning
  125. its receive FIFO often enough to be unacceptable.  Another possible compromise
  126. is to add code to switch between task-level and interrupt-level reception
  127. as necessary depending on the packet arrival rate.  Yet another possibility
  128. is to use the receive threshold feature of the board to receive a packet
  129. in chunks rather than all-or-nothing could make the interrupt-level reception
  130. more palatable in some applications; the threshold would be advanced by perhaps
  131. 200 bytes per interrupt until the whole packet has been read.
  133. The timing measurements represent an attempt to understand why the receiver
  134. performance is what it is, both interrupt-level and task-level.  The most
  135. important statistics are "timer overflows" and "max rx latency", where
  136. overflow is a latency greater than 255 timer ticks.  "Timer invalids" are
  137. not in themselves bad; it means that another interrupt (presumably transmit)
  138. occurred before the receiver was serviced and caused the timer to be reset
  139. (this is a hardware feature).
  142. SEE ALSO: ifLib
  143. */
  145. #define ELT_TIMING                          /* Compiles rx timing measurement */
  147. #include "vxWorks.h"
  148. #include "wdLib.h"
  149. #include "iv.h"
  150. #include "vme.h"
  151. #include "net/mbuf.h"
  152. #include "net/protosw.h"
  153. #include "socket.h"
  154. #include "ioctl.h"
  155. #include "errno.h"
  156. #include "memLib.h"
  157. #include "intLib.h"
  158. #include "net/if.h"
  159. #include "net/unixLib.h"
  160. #include "net/route.h"
  161. #include "iosLib.h"
  162. #include "errnoLib.h"
  164. #include "cacheLib.h"
  165. #include "logLib.h"
  166. #include "netLib.h"
  167. #include "stdio.h"
  168. #include "stdlib.h"
  169. #include "sysLib.h"
  171. #ifdef  INET
  172. #include "netinet/in.h"
  173. #include "netinet/in_systm.h"
  174. #include "netinet/in_var.h"
  175. #include "netinet/ip.h"
  176. #include "netinet/if_ether.h"
  177. #endif  /* INET */
  179. #include "etherLib.h"
  180. #include "net/systm.h"
  181. #include "sys/times.h"
  182. #include "net/if_subr.h"
  183. #include "drv/netif/if_elt.h"
  186. /* defines */
  188. #undef ELT_DEBUG                             /* Compiles debug output */
  190. #define MAX_UNITS 4 /* maximum units to support */
  191. #define DEF_NUM_RX_FRAMES 20 /* default number of rx buffers */
  192. #define MIN_NUM_RX_FRAMES 4 /* number we reserve from loaning */
  194. #define PARTIAL_TRANSFER_MASK   0xfffe  /* when pulling partial frames out */
  195.                                         /* of receive FIFO, transfer even */
  196.                                         /* words only */
  198. /* These should be in a common file but which one? */
  199. /* Ethernet attachment type selections */
  201. #define ATTACHMENT_DEFAULT      0       /* use card as configured */
  202. #define ATTACHMENT_AUI          1       /* AUI  (thick, DIX, DB-15) */
  203. #define ATTACHMENT_BNC          2       /* BNC  (thin, 10BASE-2) */
  204. #define ATTACHMENT_RJ45         3       /* RJ-45 (twisted pair, TPE, 10BASE-T)*/
  206. #define ELT_PRODUCTID_3C589 0x9058 /* product ID for PCMCIA 3C589 */
  209. /* globals */
  211. ELT_CTRL * pEltCtrl [MAX_UNITS];
  214. /* locals */
  218. /* forward function declarations */
  220. LOCAL void eltBoardInit (int unit);
  221. LOCAL STATUS eltMemoryInit (int unit);
  222. LOCAL void eltReset (int unit);
  223. LOCAL int eltIoctl (IDR * pIDR, int cmd, caddr_t data);
  224. #ifdef BSD43_DRIVER
  225. LOCAL int eltOutput (IDR * pIDR, MBUF * pMbuf, SOCK * pDestAddr);
  226. LOCAL void eltTxOutputStart (int unit);
  227. #else
  228. LOCAL void eltTxOutputStart (ELT_CTRL * pDrvCtrl);
  229. #endif
  230. LOCAL void eltInt (ELT_CTRL * pDrvCtrl);
  231. LOCAL void eltTxFlush (ELT_CTRL * pDrvCtrl, BOOL netJob);
  233. LOCAL void eltRxDeliver (ELT_CTRL * pDrvCtrl);
  234. LOCAL void eltLoanFree (ELT_CTRL * pDrvCtrl, ELT_FRAME * pFrame);
  235. LOCAL void eltRxFree (ELT_CTRL * pDrvCtrl, ELT_FRAME * pFrame);
  236. LOCAL void eltStatFlush (ELT_CTRL * pDrvCtrl);
  237. LOCAL void eltIntMaskSet (ELT_CTRL * pDrvCtrl, int maskBits);
  238. LOCAL void eltIntDisable (ELT_CTRL * pDrvCtrl);
  239. LOCAL void eltIntEnable (ELT_CTRL * pDrvCtrl);
  240. LOCAL void eltRxStart (ELT_CTRL * pDrvCtrl);
  241. LOCAL void eltTxStart (ELT_CTRL * pDrvCtrl);
  242. LOCAL STATUS eltActivate (ELT_CTRL * pDrvCtrl);
  243. LOCAL void eltIdCommand (int idPort);
  244. LOCAL UINT16 eltIdEepromRead (int address);
  245. LOCAL int eltEepromRead (int port, int offset);
  248. /*******************************************************************************
  249. *
  250. * eltEepromRead - read one 16-bit adapter EEPROM register.
  251. *
  252. * RETURNS: Value from an offset of the EEPROM.
  253. */
  255. LOCAL int eltEepromRead
  256.     (
  257.     int port,
  258.     int offset
  259.     )
  261.     {
  262.     int ix;
  264.     sysOutWord (port + EEPROM_CONTROL, 0x80 + offset);
  266.     /* wait 162 us minimum */
  268.     for (ix = 0; ix < 300; ix++)
  269. sysDelay ();
  270.     
  271.     return (sysInWord (port + EEPROM_DATA));
  272.     }
  274. /*******************************************************************************
  275. *
  276. * eltattach - publish the `elt' interface and initialize the driver and device
  277. *
  278. * The routine publishes the `elt' interface by filling in a network interface
  279. * record and adding this record to the system list.  This routine also
  280. * initializes the driver and the device to the operational state.
  281. *
  282. * RETURNS: OK or ERROR.
  283. *
  284. * SEE ALSO: ifLib
  285. */
  287. STATUS eltattach
  288.     (
  289.     int         unit,                   /* unit number */
  290.     int         port,                   /* base I/O address */
  291.     int         ivec,                   /* interrupt vector number */
  292.     int         intLevel,               /* interrupt level */
  293.     int         nRxFrames,              /* # of receive frames (0=default) */
  294.     int         attachment,             /* Ethernet connector to use */
  295.     char *ifName /* interface name */
  296.     )
  297.     {
  298.     ELT_CTRL *  pDrvCtrl;
  299.     int productID;
  300.     short *p;
  302.     /* Sanity check the unit number */
  304.     if (unit < 0 || unit >= MAX_UNITS)
  305.         return (ERROR);
  307.     /* allocate this unit's control structure the first time attach is called */
  309.     if (pEltCtrl [unit] == NULL)
  310.         {
  311.         pEltCtrl [unit] = malloc (sizeof (ELT_CTRL));
  312.         if (pEltCtrl [unit] == NULL)
  313.             return (ERROR);
  314.         bzero ( (char *) pEltCtrl [unit], sizeof (ELT_CTRL));
  315.         }
  317.     /* Ensure single invocation per system life */
  319.     pDrvCtrl = pEltCtrl [unit];
  320.     if (pDrvCtrl->attached)
  321.         return (OK);
  323.     /* it would be a good idea to validate these parameters.... */
  325.     pDrvCtrl->intLevel = intLevel; /* PC IRQ number */
  326.     pDrvCtrl->ivec = ivec; /* interrupt vector */
  328.     /* Determine which attachment is desired */
  330.     switch (attachment)
  331.         {
  332.         case ATTACHMENT_DEFAULT:
  333.         case ATTACHMENT_AUI:
  334.         case ATTACHMENT_BNC:
  335.         case ATTACHMENT_RJ45:
  336.             pDrvCtrl->attachment = attachment;
  337.             break;
  338.         default:
  339.             return (ERROR);             /* unknown value */
  340.         }
  342.     /* Find and activate the adapter */
  344.     pDrvCtrl->port = port;
  345.     productID = eltEepromRead (pDrvCtrl->port, EE_A_PRODUCT_ID);
  346.     if (productID == ELT_PRODUCTID_3C589)
  347. {
  348.         p = (short *)pDrvCtrl->idr.ac_enaddr;
  349. *p++ = htons (eltEepromRead (port, EE_A_OEM_NODE_0));
  350. *p++ = htons (eltEepromRead (port, EE_A_OEM_NODE_1));
  351. *p++ = htons (eltEepromRead (port, EE_A_OEM_NODE_2));
  352. sysOutWord (port + ELT_COMMAND, SELECT_WINDOW | WIN_CONFIG);
  353. sysOutWord (port + ADDRESS_CONFIG, eltEepromRead (port, EE_A_ADDRESS));
  354. sysOutWord (port + RESOURCE_CONFIG, eltEepromRead (port,EE_A_RESOURCE));
  355. }
  356.     else
  357.         if (eltActivate (pDrvCtrl) != OK)
  358.             return (ERROR);
  360.     eltBoardInit (unit);
  362.     /* Determine number of Rx descriptors to use */
  364.     pDrvCtrl->nRxFrames = nRxFrames ? nRxFrames : DEF_NUM_RX_FRAMES;
  366.     /* Publish the interface record */
  368.     if (strncmp (ifName, "pcmcia", 6) != 0)
  369. ifName = "elt";
  371. #ifdef BSD43_DRIVER
  372.     ether_attach    ( (IFNET *) & pDrvCtrl->idr, unit, ifName, (FUNCPTR) NULL,
  373.                     (FUNCPTR) eltIoctl, (FUNCPTR) eltOutput, (FUNCPTR) eltReset
  374.                     );
  375. #else
  376.     ether_attach    ( 
  377.                     (IFNET *) & pDrvCtrl->idr, 
  378.                     unit, 
  379.                     ifName, 
  380.                     (FUNCPTR) NULL,
  381.                     (FUNCPTR) eltIoctl, 
  382.                     (FUNCPTR) ether_output, 
  383.                     (FUNCPTR) eltReset
  384.                     );
  385.     pDrvCtrl->idr.ac_if.if_start = (FUNCPTR)eltTxOutputStart;
  386. #endif
  388.     if (eltMemoryInit (unit) != OK)
  389.         return (ERROR);
  391.     /* keep operating registers in window except in critical sections */
  393.     sysOutWord (port + ELT_COMMAND, SELECT_WINDOW | WIN_OPERATING);
  395.     /* Connect the interrupt handler */
  397.     if (intConnect ( (VOIDFUNCPTR *)INUM_TO_IVEC (pDrvCtrl->ivec),
  398.                     eltInt, (int)pDrvCtrl) == ERROR)
  399.         return (ERROR);
  400.     sysIntEnablePIC (intLevel);
  401.     eltIntEnable (pDrvCtrl);
  403.     /* Set our flag */
  405.     pDrvCtrl->attached = TRUE;
  407.     /* Set status flags in IDR */
  409.     pDrvCtrl->idr.ac_if.if_flags |= (IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);
  411.     /* Successful return */
  413.     return (OK);
  414.     }
  416. /*******************************************************************************
  417. *
  418. * eltBoardInit - prepare the board for operation
  419. *
  420. */
  422. static void eltBoardInit
  423.     (
  424.     int unit
  425.     )
  426.     {
  427.     ELT_CTRL * pDrvCtrl;
  428.     int port;
  429.     int index;
  430.     UINT16 transceiver;
  432.     pDrvCtrl = pEltCtrl [unit];
  433.     port = pDrvCtrl->port;
  435.     eltIntDisable (pDrvCtrl);   /* make it OK to change register window */
  437.     sysOutWord (port + ELT_COMMAND, SELECT_WINDOW | WIN_ADDRESS);
  438.     for (index = 0; index < EA_SIZE; index++)
  439.         sysOutByte (port + index, pDrvCtrl->idr.ac_enaddr [index]);
  441.     /* Select the transceiver hardware (attachment) then do whatever is
  442.      * necessary to activate the selected attachment.
  443.      * A truly complete implementation would probably check to see
  444.      * if the selected attachment were present.
  445.      */
  447.     sysOutWord (port + ELT_COMMAND, SELECT_WINDOW | WIN_CONFIG);
  448.     transceiver = sysInWord (port + ADDRESS_CONFIG);
  449.     if (pDrvCtrl->attachment == ATTACHMENT_DEFAULT)
  450.         {
  451.         switch (transceiver & AC_XCVR_MASK)
  452.             {
  453.             case AC_XCVR_TPE:
  454.                 pDrvCtrl->attachment = ATTACHMENT_RJ45;
  455.                 break;
  456.             case AC_XCVR_BNC:
  457.                 pDrvCtrl->attachment = ATTACHMENT_BNC;
  458.                 break;
  459.             case AC_XCVR_AUI:
  460.                 pDrvCtrl->attachment = ATTACHMENT_AUI;
  461.                 break;
  462.             default:    /* there's only one other value; it's "reserved" */
  463.                 pDrvCtrl->attachment = ATTACHMENT_AUI;  /* good enough */
  464.                 break;
  465.             }
  466.         }
  468.     /* Now set the selected attachment type, even if it was already selected */
  470.     transceiver &= ~AC_XCVR_MASK;
  471.     switch (pDrvCtrl->attachment)
  472.         {
  473.         case ATTACHMENT_RJ45:
  474.             sysOutWord (port + ADDRESS_CONFIG, transceiver | AC_XCVR_TPE);
  475.             sysOutWord (port + ELT_COMMAND, SELECT_WINDOW | WIN_DIAGNOSTIC);
  476.             sysOutByte (port + MEDIA_STATUS,
  477.                         sysInByte (port + MEDIA_STATUS) |
  478.                         MT_S_JABBER_ENABLE | MT_S_LINK_BEAT_ENABLE);
  479.             break;
  480.         case ATTACHMENT_BNC:
  481.             sysOutWord (port + ADDRESS_CONFIG, transceiver | AC_XCVR_BNC);
  482.             sysOutWord (port + ELT_COMMAND, START_COAX);
  483.             break;
  484.         case ATTACHMENT_AUI:
  485.         default:
  486.             sysOutWord (port + ADDRESS_CONFIG, transceiver | AC_XCVR_AUI);
  487.             break;
  488.         }
  490.     /* enable normal Ethernet address recognition */
  492.     pDrvCtrl->rxFilter = RX_F_NORMAL;
  494.     /*
  495.      * Define the set of status bits that could cause interrupts.
  496.      * There is no interrupt cause indicator separate from the board status.
  497.      * To keep the ISR from seeing status conditions we didn't want to be
  498.      * interrrupted for, we must mask the STATUS off, not the interrupt.
  499.      * This prevents the condition from interrupting and also prevents
  500.      * the ISR from seeing the condition even if it is true.
  501.      * The interrupt mask is set only once to the set of all conditions
  502.      * we might want to be interrupted by; the status mask is set and
  503.      * cleared according to which conditions we want at any particular
  504.      * time.  The intMask field in the control structure
  505.      * is named for its effect; it is really used in the status mask
  506.      * command (3Com calls it the read zero mask).
  507.      */
  509.     /* enable the status bits we currently want to cause interrupts */
  511.     eltIntMaskSet (pDrvCtrl, ADAPTER_FAILURE | TX_COMPLETE |
  512.                              RX_COMPLETE | RX_EARLY | UPDATE_STATS);
  514.     /* enable the collection of statistics */
  516.     sysOutWord (port + ELT_COMMAND, STATS_ENABLE);
  518.     /* enable the hardware to generate interrupt requests */
  520.     sysOutWord (port + ELT_COMMAND, SELECT_WINDOW | WIN_CONFIG);
  521.     sysOutWord (port + CONFIG_CONTROL, CC_ENABLE);
  523.     sysOutWord (port + ELT_COMMAND, SELECT_WINDOW | WIN_OPERATING);
  525.     eltIntEnable (pDrvCtrl);
  527.     eltRxStart (pDrvCtrl);
  528.     eltTxStart (pDrvCtrl);
  529.     }
  531. /*******************************************************************************
  532. *
  533. * eltMemoryInit - initialize memory structures
  534. *
  535. * The only thing we allocate from system meory besides the driver control
  536. * structure is the frame buffer pool.  Here we malloc it as one big region
  537. * and divide it up into receive and transmit buffers.
  538. */
  540. static STATUS eltMemoryInit
  541.     (
  542.     int unit
  543.     )
  544.     {
  545.     ELT_CTRL * pDrvCtrl;
  546.     ELT_FRAME * pFrame;
  547.     int         index;
  549.     pDrvCtrl = pEltCtrl [unit];
  551.     /* Initialize our data structures */
  553.     pDrvCtrl->pFrameArea = malloc ( (1 + pDrvCtrl->nRxFrames)
  554.                                     * sizeof (ELT_FRAME));
  555.     if (pDrvCtrl->pFrameArea == NULL)
  556.         return (ERROR);
  558.     pFrame = pDrvCtrl->pFrameArea;
  559.     pDrvCtrl->pTxFrame = pFrame++;              /* first allocate tx frame */
  561.     pDrvCtrl->pRxHead = pFrame;                 /* first rx frame */
  562.     for (index = pDrvCtrl->nRxFrames; index > 0; index--)
  563.         {
  564.         pFrame->count = 0;
  565.         pFrame->nextByte = pFrame->header;
  566.         pFrame->length = 0;
  567.         pFrame->lNext = pFrame + 1;
  568.         pFrame++;
  569.         }
  570.     pDrvCtrl->pRxTail = pFrame - 1;             /* last rx frame */
  571.     pDrvCtrl->pRxTail->lNext = NULL;
  573.     pDrvCtrl->pRxCurrent = pDrvCtrl->pRxHead;
  574.     pDrvCtrl->nLoanFrames = pDrvCtrl->nRxFrames - MIN_NUM_RX_FRAMES;
  576.     return (OK);
  577.     }
  579. /*******************************************************************************
  580. *
  581. * eltReset - reset the elt interface
  582. *
  583. * Mark interface as inactive and reset the adapter.
  584. */
  586. static void eltReset
  587.     (
  588.     int unit
  589.     )
  590.     {
  591.     ELT_CTRL * pDrvCtrl;
  593.     pDrvCtrl = pEltCtrl [unit];
  595.     eltIntDisable (pDrvCtrl);           /* prevent device from interrupting */
  596.     sysOutWord (pDrvCtrl->port + ELT_COMMAND, RX_RESET);
  597.     sysOutWord (pDrvCtrl->port + ELT_COMMAND, TX_RESET);
  599.     }
  601. /*******************************************************************************
  602. *
  603. * eltIoctl - interface ioctl procedure
  604. *
  605. * Process an interface ioctl request.
  606. */
  608. static int eltIoctl
  609.     (
  610.     IDR     *pIDR,
  611.     int     cmd,
  612.     caddr_t data
  613.     )
  614.     {
  615.     int unit;
  616.     ELT_CTRL * pDrvCtrl;
  617.     int error;
  619. #ifdef ELT_DEBUG
  620.     printf ("elt: ioctl: pIDR=%x cmd=%x data=%xn", pIDR, cmd, data);
  621. #endif /* ELT_DEBUG */
  623.     unit = pIDR->ac_if.if_unit;
  624.     pDrvCtrl = pEltCtrl [unit];
  625.     error = 0;
  627.     switch (cmd)
  628.         {
  629.         case SIOCSIFADDR:
  630.             ((struct arpcom *)pIDR)->ac_ipaddr = IA_SIN (data)->sin_addr;
  631.             arpwhohas (pIDR, &IA_SIN (data)->sin_addr);
  632.             break;
  634.         case SIOCSIFFLAGS:
  636.             /* Set promiscuous mode according to current interface flags */
  638.             pDrvCtrl->rxFilter = ( (pIDR->ac_if.if_flags & IFF_PROMISC) != 0) ?
  639.                                    RX_F_PROMISCUOUS : RX_F_NORMAL;
  640.             sysOutWord (pDrvCtrl->port + ELT_COMMAND,
  641.                         SET_RX_FILTER | pDrvCtrl->rxFilter);
  642.             break;
  644.         default:
  645.             error = EINVAL;
  646.         }
  648.     return (error);
  649.     }
  651. #ifdef BSD43_DRIVER
  652. /*******************************************************************************
  653. *
  654. * eltOutput - interface output routine.
  655. *
  656. * This is the entry point for packets arriving from protocols above.  This
  657. * routine merely calls our specific output routines that eventually lead
  658. * to a transmit to the network.
  659. *
  660. * RETURNS: 0 or appropriate errno
  661. */
  663. static int eltOutput
  664.     (
  665.     IDR *    pIDR,
  666.     MBUF *     pMbuf,
  667.     SOCK * pDestAddr
  668.     )
  669.     {
  671. #ifdef ELT_DEBUG
  672.     printf ("elt: output: pIDR=%x pMbuf=%x pDestAddr=%xn",
  673.             pIDR, pMbuf, pDestAddr);
  674. #endif /* ELT_DEBUG */
  676.     return (ether_output ( (IFNET *)pIDR, pMbuf, pDestAddr,
  677.             (FUNCPTR) eltTxOutputStart, pIDR));
  678.     }
  679. #endif
  681. /*******************************************************************************
  682. *
  683. * eltTxOutputStart - start output on the board
  684. *
  685. * This routine is called from ether_output() when a new packet is enqueued
  686. * in the interface mbuf queue.
  687. *
  688. * Note that this function is ALWAYS called between an splnet() and an splx().
  689. * This is true because netTask(), and ether_output() take care of
  690. * this when calling this function. Therefore, no calls to these spl functions
  691. * are needed anywhere in this output thread.
  692. */
  694. #ifdef BSD43_DRIVER
  695. static void eltTxOutputStart
  696.     (
  697.     int unit
  698.     )
  699.     {
  700.     ELT_CTRL * pDrvCtrl;
  702.     pDrvCtrl = pEltCtrl [unit];
  703. #else
  704. static void eltTxOutputStart
  705.     (
  706.     ELT_CTRL * pDrvCtrl
  707.     )
  708.     {
  709. #endif
  710.     if (sysInWord (pDrvCtrl->port + TX_FREE_BYTES) >= TX_IDLE_COUNT)
  711.         {
  712. #ifdef ELT_TIMING
  714.         /* pretend we queued eltTxFlush, to keep the counts straight */
  716.         if ( (int)++pDrvCtrl->eltStat.taskQTxOuts >
  717.              (int)pDrvCtrl->eltStat.maxTxTaskQ)
  718.             pDrvCtrl->eltStat.maxTxTaskQ = pDrvCtrl->eltStat.taskQTxOuts;
  719. #endif /* ELT_TIMING */
  720.         eltTxFlush (pDrvCtrl, FALSE);   /* not called via netJobAdd() */
  721.         }
  722.     }
  724. /*******************************************************************************
  725. *
  726. * eltInt - entry point for handling interrupts from the EtherLink III
  727. *
  728. * Most of the board's interrupting conditions must be actually handled to
  729. * clear the interrupting condition; the ACK command does nothing for them.
  730. * Where we defer handling to the task level, we mask the status conditions
  731. * to prevent a repeated interrupt.  This works everywhere except when there
  732. * are received packets waiting to be delivered to the protocols; this is
  733. * synchronized by a flag.
  734. *
  735. * Note that the board manual says to acknowledge the board interrupts before
  736. * acknowledging the processor interrupt, presumably because of level-sensitive
  737. * logic somewhere.
  738. */
  740. static void eltInt
  741.     (
  742.     ELT_CTRL * pDrvCtrl
  743.     )
  744.     {
  745.     UINT16 status;
  746.     UINT16 statusDiag;
  747.     UINT16 statusRx;
  748.     UINT16 statusRxNew;
  749.     UINT8  statusTx;
  750.     UINT16 length;
  751.     int    ix = 0;
  752.     int    port = pDrvCtrl->port;
  753.     BOOL   needTxStart = FALSE;
  754.     volatile ELT_FRAME * pFrame;
  755.     STATUS result;
  757. #ifdef ELT_TIMING
  758.     {
  759.         int time = (int) sysInByte (pDrvCtrl->port + TIMER);
  761.         if (time> pDrvCtrl->eltStat.maxIntLatency)
  762.             pDrvCtrl->eltStat.maxIntLatency = time; 
  763.         if (pDrvCtrl->interruptTime == -1)
  764.             pDrvCtrl->interruptTime = time;
  765.         else if (pDrvCtrl->interruptTime >= 0)
  766.             pDrvCtrl->interruptTime = -1;
  767.     }
  768. #endif /* ELT_TIMING */
  770.     status = sysInByte (pDrvCtrl->port + ELT_STATUS) & 0x00ff;
  772.     if ( (status & INTERRUPT_LATCH) == 0)
  773.         {
  774.         ++pDrvCtrl->eltStat.strayint;
  775.         return;
  776.         }
  777.     else
  778.         ++pDrvCtrl->eltStat.interrupts;
  780.     /* Handle adapter failure first in case other conditions mask it */
  782.     if ( (status & ADAPTER_FAILURE) != 0)
  783.         {
  784.         sysOutWord (port + ELT_COMMAND, SELECT_WINDOW | WIN_DIAGNOSTIC);
  785.         statusDiag = sysInWord (port + FIFO_DIAGNOSTIC);
  786.         sysOutWord (port + ELT_COMMAND, SELECT_WINDOW | WIN_OPERATING);
  788.         if ( (statusDiag & FD_TX_OVERRUN) != 0)
  789.             {
  790.             ++pDrvCtrl->eltStat.txoverruns;
  791.             sysOutWord (port + ELT_COMMAND, TX_RESET);
  792.             eltTxStart (pDrvCtrl);
  793.             }
  795.         if ( (status & FD_RX_UNDERRUN) != 0)
  796.             {
  797.             ++pDrvCtrl->eltStat.rxunderruns;
  798.             sysOutWord (port + ELT_COMMAND, RX_RESET);
  799.             eltRxStart (pDrvCtrl);
  800.             }
  801.         }
  804.     /* Handle receive complete interrupt */
  806.     if ( (status & (RX_COMPLETE | RX_EARLY)) != 0)
  807.         {
  809.         if ( (status & RX_EARLY) != 0)
  810.             ++pDrvCtrl->eltStat.rxearly;
  811.         if (pDrvCtrl->pRxCurrent == NULL)
  812.             ++pDrvCtrl->eltStat.rxnobuffers;
  814. #ifdef ELT_TIMING
  815.         {
  816.         int timeNow;
  817.         int timeDelta;
  819.         if (pDrvCtrl->interruptTime >= 0)
  820.             {
  821.             timeNow = (int)sysInByte (port + TIMER);
  822.             if (timeNow == 0xff)
  823.                 ++pDrvCtrl->eltStat.timerOverflow;
  824.             else
  825.                 {
  826.                 ++pDrvCtrl->eltStat.timerUpdates;
  827.                 timeDelta = timeNow - pDrvCtrl->interruptTime;
  828.                 if (timeDelta > pDrvCtrl->eltStat.maxRxLatency)
  829.                     pDrvCtrl->eltStat.maxRxLatency = timeDelta; 
  830.                 if ( (pDrvCtrl->eltStat.minRxLatency == 0) ||
  831.                     (timeDelta < pDrvCtrl->eltStat.minRxLatency))
  832.                     pDrvCtrl->eltStat.minRxLatency = timeDelta;
  833.                 }
  834.             }
  835.         else if (pDrvCtrl->interruptTime == -1)
  836.             ++pDrvCtrl->eltStat.timerInvalid;
  837.         pDrvCtrl->interruptTime = -2;
  838.         }
  839. #endif /* ELT_TIMING */
  841.         while ( (pFrame = pDrvCtrl->pRxCurrent) != NULL)
  842.             {
  843.             statusRx = sysInWord(port + RX_STATUS);
  845.             if (statusRx & RX_S_INCOMPLETE) /* incomplete */
  846.         {
  847.                 if (statusRx == RX_S_INCOMPLETE) /* no bytes available */
  848.     break;
  850.                 while ((statusRx != (statusRxNew = sysInWord(port + RX_STATUS)))
  851.        && (ix < 10000))
  852.     {
  853.     statusRx = statusRxNew;   
  854.     ix++; /* XXX */
  855.     }
  856.         }
  858. #ifdef ELT_DEBUG
  859.             logMsg ("eltInt: statusRx=%04x ix=%dn", statusRx, ix, 0, 0, 0, 0);
  860. #endif /* ELT_DEBUG */
  861.     
  862.             /* Copy the FIFO data into the buffer */
  864.             length = statusRx & RX_S_CNT_MASK;
  866.             /* Prevent buffer overflow.
  867.              * should we discard the packet? that's hard to do safely here.
  868.      * so truncate packet
  869.      */
  871.             if ( (pFrame->count + length) > MAX_FRAME_SIZE)
  872.                 length = MAX_FRAME_SIZE - pFrame->count;
  874.             /* transfer only an even number of bytes to leave the pointer
  875.              * on an even boundary until we reach the end of the frame
  876.              */
  878.             if ( (statusRx & RX_S_INCOMPLETE) != 0)
  879.                 length &= PARTIAL_TRANSFER_MASK;
  881.             sysInWordString (port + DATA_REGISTER, (short *) pFrame->nextByte,
  882.                              (length + 1) / 2);
  883.             pFrame->count += length;
  884.             pFrame->nextByte += length;
  886.     /* partial packet, wait for complete packet */
  888.             if ( (statusRx & RX_S_INCOMPLETE) != 0)
  889.                 break;
  891.     /*
  892.      * Packet is now complete. Use 'Discard' command to complete the 
  893.      * transfer
  894.      */
  896.             sysOutWord (port + ELT_COMMAND, RX_DISCARD); /* discard packet */
  897.             while ( (sysInWord (port + ELT_STATUS) & COMMAND_IN_PROGRESS) != 0)
  898.                 ;                           /* wait for command to finish */
  900.             /* Check for errors in completed packet */
  902.             if ( (statusRx & RX_S_ERROR) != 0)
  903.                 {
  904.                 switch (statusRx & RX_S_CODE_MASK)
  905.                     {
  906.                     case RX_S_OVERRUN: /* handled by statistics registers */
  907.                         break;
  908.                     case RX_S_RUNT:
  909.                         ++pDrvCtrl->eltStat.shortPacket;
  910.                         break;
  911.                     case RX_S_ALIGN:
  912.                         ++pDrvCtrl->eltStat.aligns;
  913.                         break;
  914.                     case RX_S_CRC:
  915.                         ++pDrvCtrl->eltStat.crcs;
  916.                         break;
  917.                     case RX_S_OVERSIZE:
  918.                         ++pDrvCtrl->eltStat.badPacket;
  919.                         break;
  920.                     default: /* no other codes are defined */
  921.                         break;
  922.                     }
  923.                 ++pDrvCtrl->eltStat.rxerror;
  925.                 ++pDrvCtrl->idr.ac_if.if_ierrors;   /* bump error counter */
  926.                 pFrame->count = 0;
  927.                 pFrame->nextByte = pFrame->header;
  928.                 pFrame->length = 0;
  929.                 continue;
  930.                 }
  932.             /* Got a complete packet, count it. */
  934.             ++pDrvCtrl->idr.ac_if.if_ipackets;
  936.             pFrame->length = statusRx;
  937.             pDrvCtrl->pRxCurrent = pDrvCtrl->pRxCurrent->lNext;
  938.             }
  939. #ifdef ELT_TIMING
  940.         pDrvCtrl->interruptTime = -1;
  941. #endif /* ELT_TIMING */
  943.         /* receive no more for now */
  945.         if (pDrvCtrl->pRxCurrent == NULL)
  946.             pDrvCtrl->intMask &= ~(RX_COMPLETE | RX_EARLY);
  948.         if (!pDrvCtrl->rxHandling && (pDrvCtrl->pRxHead->length != 0))
  949.             {
  950.             result = netJobAdd ( (FUNCPTR) eltRxDeliver, (int) pDrvCtrl,
  951.                                  0, 0, 0, 0);
  952. #ifdef ELT_DEBUG
  953.             if (result == ERROR)
  954.                 logMsg ("elt: netJobAdd (eltRxDeliver) failedn",
  955.                         0, 0, 0, 0, 0, 0);
  956. #endif /* ELT_DEBUG */
  958. #ifdef ELT_TIMING
  959.             if (result != ERROR)
  960.                 if ( (int)++pDrvCtrl->eltStat.taskQRxOuts >
  961.                           (int)pDrvCtrl->eltStat.maxRxTaskQ)
  962.                      pDrvCtrl->eltStat.maxRxTaskQ = 
  963.                               pDrvCtrl->eltStat.taskQRxOuts;
  964. #endif /* ELT_TIMING */
  965.             pDrvCtrl->rxHandling = TRUE;
  966.             }
  967.         }
  970.     /* Handle transmitter interrupts */
  972.     if ( (status & TX_COMPLETE) != 0)
  973.         {
  974.         if ( ( (statusTx = sysInByte (port + TX_STATUS)) & TX_S_COMPLETE) != 0)
  975.             {
  976.             sysOutByte (port + TX_STATUS, 0);       /* clear old status */
  978.             /* other errors are tabulated by reading the statistics registers */
  980.             if ( (statusTx & TX_S_MAX_COLL) != 0)
  981.                 pDrvCtrl->idr.ac_if.if_collisions += 16;
  982.             if ( (statusTx & TX_S_JABBER) != 0)
  983.                 ++pDrvCtrl->eltStat.jabbers;
  984.             
  985.             if ((statusTx & (TX_S_JABBER | TX_S_MAX_COLL | TX_S_UNDERRUN)) != 0)
  986.                 {
  987.                 needTxStart = TRUE;                 /* restart transmitter */
  989.                 /* packet not sent */
  991.                 pDrvCtrl->idr.ac_if.if_oerrors++;   /* incr err count */
  992.                 pDrvCtrl->idr.ac_if.if_opackets--;  /* decr sent count */
  993.                 }
  994.             if ( (statusTx & (TX_S_JABBER | TX_S_UNDERRUN)) != 0)
  995.                 {
  997.                 /* Must reset transmitter; this clears the tx FIFO */
  999.                 sysOutWord (port + ELT_COMMAND, TX_RESET);
  1000.                 }
  1001.             }
  1003.         if (needTxStart)                            /* check flag */
  1004.             eltTxStart (pDrvCtrl);
  1006.         if (pDrvCtrl->idr.ac_if.if_snd.ifq_head != NULL)
  1007.             {
  1008.             if (!pDrvCtrl->txHandling)
  1009.                 {
  1010.                 if (netJobAdd ( (FUNCPTR) eltTxFlush, (int) pDrvCtrl, (int) TRUE,
  1011.                                 0, 0, 0) == ERROR)
  1012.                     {
  1013. #ifdef ELT_DEBUG
  1014.                     logMsg ("elt: netJobAdd (eltTxFlush) failedn",
  1015.                             0, 0, 0, 0, 0, 0);
  1016. #endif /* ELT_DEBUG */
  1017.                     }
  1018.                 else
  1019.                     pDrvCtrl->txHandling = TRUE;
  1020. #ifdef ELT_TIMING
  1021.                 if ( (int)++pDrvCtrl->eltStat.taskQTxOuts >
  1022.                      (int)pDrvCtrl->eltStat.maxTxTaskQ)
  1023.                     pDrvCtrl->eltStat.maxTxTaskQ = pDrvCtrl->eltStat.taskQTxOuts;
  1024. #endif /* ELT_TIMING */
  1025.                 }
  1026.             }
  1027.         }
  1030.     /* Handle update statistics interrupt */
  1032.     if ( (status & UPDATE_STATS) != 0)
  1033.         eltStatFlush (pDrvCtrl);
  1036.     /* mask and ack the events we've just handled or queued handlers for */
  1038.     sysOutWord (pDrvCtrl->port + ELT_COMMAND, MASK_STATUS | pDrvCtrl->intMask);
  1039.     sysOutWord (pDrvCtrl->port + ELT_COMMAND, ACK_INTERRUPT | status);
  1040.     sysBusIntAck (pDrvCtrl->intLevel);
  1041.     }
  1043. /*******************************************************************************
  1044. *
  1045. * eltTxFlush - transmit a packet from the output queue
  1046. *
  1047. * This routine, if the transmitter is currently idle, and if there is a
  1048. * packet in the output queue, dequeues a packet and transmits it.  The
  1049. * next transmit activity will be a completion interrupt, which will cause
  1050. * this routine to be scheduled again if there is a packet in the output
  1051. * queue.
  1052. */
  1054. static void eltTxFlush
  1055.     (
  1056.     ELT_CTRL *  pDrvCtrl,
  1057.     BOOL        netJob
  1058.     )
  1059.     {
  1060.     int port;
  1061.     ELT_FRAME * pFrame;
  1062.     UINT16 outputCount;
  1063.     MBUF * m;
  1065.     port = pDrvCtrl->port;
  1066.     pFrame = pDrvCtrl->pTxFrame;
  1068.     do
  1069.         {
  1070.         if (netJob)
  1071.             pDrvCtrl->txHandling = TRUE;
  1073.         /* Don't dequeue if currently sending */
  1075.         while ( (sysInWord (pDrvCtrl->port + TX_FREE_BYTES) >= TX_IDLE_COUNT) &&
  1076.                 (pDrvCtrl->idr.ac_if.if_snd.ifq_head != NULL))
  1077.             {
  1079.             IF_DEQUEUE (&pDrvCtrl->idr.ac_if.if_snd, m);
  1081.             copy_from_mbufs (pFrame->header, m, outputCount);
  1083.             outputCount = max (ETHERSMALL, outputCount);
  1085.             if ( (etherOutputHookRtn != NULL) &&
  1086.                  (* etherOutputHookRtn)
  1087.                  (&pDrvCtrl->idr, pFrame->header, outputCount))
  1088.                 continue;
  1090.             pFrame->length = outputCount | TX_F_INTERRUPT;
  1091.             outputCount = (outputCount + TX_F_PREAMBLE_SIZE + 3) &
  1092.                           TX_F_DWORD_MASK;
  1094.             sysOutWordString (port + DATA_REGISTER, (short *) & pFrame->length,
  1095.                               outputCount / 2);
  1097.             /* Bump the statistic counter. */
  1098. #ifdef ELT_DEBUG
  1099.             printf ("Packet sent.n");
  1100.             fflush (stdout);
  1101. #endif /* ELT_DEBUG */
  1103. #ifndef BSD43_DRIVER
  1104.             pDrvCtrl->idr.ac_if.if_opackets++;
  1105. #endif
  1107.             break;                      /* ISR must call eltTxCleanup() */
  1108.             }
  1109.         if (netJob)
  1110.             pDrvCtrl->txHandling = FALSE;
  1111.         }
  1112.     while ( (sysInWord (pDrvCtrl->port + TX_FREE_BYTES) >= TX_IDLE_COUNT) &&
  1113.             (pDrvCtrl->idr.ac_if.if_snd.ifq_head != NULL));
  1114. #ifdef ELT_TIMING
  1115.     --pDrvCtrl->eltStat.taskQTxOuts;
  1116. #endif /* ELT_TIMING */
  1117.     }
  1119. /*******************************************************************************
  1120. *
  1121. * eltRxDeliver - pass received frames to the next layer up
  1122. *
  1123. * Strips the Ethernet header and passes the packet to the appropriate
  1124. * protocol.  If there are enough received frame buffers, the packet may
  1125. * be passed to the protocol in the frame buffer.
  1126. * In this latter case, the frame buffer will
  1127. * eventually be returned by the protocol, via a call to our eltLoanFree().
  1128. */
  1130. static void eltRxDeliver
  1131.     (
  1132.     ELT_CTRL * pDrvCtrl
  1133.     )
  1134.     {
  1135.     volatile ELT_FRAME * pFrame;
  1136.     UINT16      length;
  1137.     struct ether_header *   pEh;
  1138.     u_char *    pData;
  1139.     UINT16      etherType;
  1140.     MBUF *      pMbuf;
  1142. #ifdef ELT_DEBUG
  1143.     printf ("Elt: Handling received packet.n");
  1144.     fflush (stdout);
  1145. #endif /* ELT_DEBUG */
  1147.     do
  1148.         {
  1149.         pDrvCtrl->rxHandling = TRUE;
  1150.         while ( ( (pFrame = pDrvCtrl->pRxHead) != NULL) &&
  1151.                 (pFrame->length != 0))
  1152.             {
  1153.             pDrvCtrl->pRxHead = pFrame->lNext;
  1155.             length = pFrame->count - EH_SIZE;
  1156.             pEh = (struct ether_header *)pFrame->header;
  1157.             pData = (u_char *) pFrame->data;
  1158.             etherType = ntohs (pEh->ether_type);
  1160.             /* Service input hook */
  1162.             if (etherInputHookRtn != NULL)
  1163.                 {
  1164.                 if ( (* etherInputHookRtn) (&pDrvCtrl->idr, (char *)pEh,
  1165.                                             length) )
  1166.                     {
  1167.                     eltRxFree (pDrvCtrl, (ELT_FRAME *)pFrame);
  1168.                     continue;
  1169.                     }
  1170.                 }
  1172. #ifdef ELT_DEBUG
  1173.         printf ("elt: rxDeliver: frame at %08lx, type %04x, length %d, count %dn",
  1174.                 (long) pFrame, etherType, pFrame->length, pFrame->count);
  1175. #endif /* ELT_DEBUG */
  1177.             /* we can loan out receive frames from our pool if:
  1178.              *
  1179.              * 1) we have enough (nLoanFrames > 0) and
  1180.              * 2) size of the input ethernet frame is large enough to be used
  1181.              *    with clustering.
  1182.              */
  1184.             pFrame->refCnt = 0;
  1186.             if ( (pDrvCtrl->nLoanFrames > 0) && (USE_CLUSTER (length)) &&
  1187.                  ( (pMbuf = build_cluster (pData, length, &pDrvCtrl->idr, MC_EI,
  1188.                                      &pFrame->refCnt, eltLoanFree,
  1189.                                      (int) pDrvCtrl,
  1190.                                      (int) pFrame, NULL)) != NULL))
  1191.                 {
  1192.                 pDrvCtrl->nLoanFrames -= 1;             /* one less to loan */
  1193.                 }
  1194.             else
  1195.                 {
  1196.                 pMbuf = copy_to_mbufs (pData, length, 0, &pDrvCtrl->idr);
  1197.                 eltRxFree (pDrvCtrl, (ELT_FRAME *)pFrame);
  1198.                 }
  1200.             /* deliver mbufs to protocol */
  1202. #ifdef BSD43_DRIVER
  1203.             if (pMbuf != NULL)
  1204.                 do_protocol_with_type (etherType, pMbuf, &pDrvCtrl->idr,length);
  1205. #else
  1206.             if (pMbuf != NULL)
  1207.                 do_protocol (pEh, pMbuf, &pDrvCtrl->idr, length);
  1208. #endif
  1209.             else
  1210.                 ++pDrvCtrl->idr.ac_if.if_ierrors;
  1211.             }
  1212.         pDrvCtrl->rxHandling = FALSE;   /* allow self to be rescheduled */
  1213.         }
  1214.     while ( ( (pFrame = pDrvCtrl->pRxHead) != NULL) && (pFrame->length != 0));
  1215. #ifdef ELT_TIMING
  1216.     --pDrvCtrl->eltStat.taskQRxOuts;
  1217. #endif /* ELT_TIMING */
  1218.     }
  1220. /*******************************************************************************
  1221. *
  1222. * eltLoanFree - return a loaned receive frame buffer
  1223. *
  1224. * This routine is called by the protocol code when it has completed use of
  1225. * a frame buffer that we loaned to it.
  1226. */
  1228. static void eltLoanFree
  1229.     (
  1230.     ELT_CTRL * pDrvCtrl,
  1231.     ELT_FRAME * pFrame
  1232.     )
  1233.     {
  1234.     eltRxFree (pDrvCtrl, pFrame);
  1236.     pDrvCtrl->nLoanFrames += 1;         /* one more to loan */
  1238.     }
  1240. /*******************************************************************************
  1241. *
  1242. * eltRxFree - free a received frame buffer
  1243. *
  1244. * Reinitialize necessary fields in the frame structure and link it to the
  1245. * tail of the free frames list.  If there was no current frame (the receive
  1246. * routine had run out of empty buffers), make this the current frame and
  1247. * unmask receive interrupts in case they were waiting for a buffer.
  1248. */
  1250. static void eltRxFree
  1251.     (
  1252.     ELT_CTRL * pDrvCtrl,
  1253.     ELT_FRAME * pFrame
  1254.     )
  1255.     {
  1256.     pFrame->lNext = NULL;
  1257.     pFrame->count = 0;
  1258.     pFrame->nextByte = pFrame->header;
  1259.     pFrame->length = 0;
  1261.     eltIntDisable (pDrvCtrl);
  1263.     if (pDrvCtrl->pRxHead == NULL)
  1264.         pDrvCtrl->pRxHead = pFrame;
  1265.     else
  1266.         pDrvCtrl->pRxTail->lNext = pFrame;
  1267.     pDrvCtrl->pRxTail = pFrame;
  1269.     if (pDrvCtrl->pRxCurrent == NULL)
  1270.         {
  1271.         pDrvCtrl->pRxCurrent = pFrame;
  1273.         eltIntMaskSet (pDrvCtrl, RX_COMPLETE | RX_EARLY);
  1274.         }
  1276.     eltIntEnable (pDrvCtrl);
  1277.     }
  1279. /*******************************************************************************
  1280. *
  1281. * eltStatFlush - flush the board's statistics registers to statistics block
  1282. *
  1283. * Called when the board reports that its statistics registers are getting
  1284. * full, or when someone wants to see the current statistics (to fully update
  1285. * the statistics block).
  1286. *
  1287. * Note that reading a statistics register zeroes it in the hardware.
  1288. * Note also that zeroing all the registers is necessary and sufficient
  1289. * to clear the interrupt condition.
  1290. *
  1291. * Must be called with board or system interrupts disabled.
  1292. */
  1294. static void eltStatFlush
  1295.     (
  1296.     ELT_CTRL * pDrvCtrl
  1297.     )
  1298.     {
  1299.     int         port;
  1301.     port = pDrvCtrl->port;
  1303.     sysOutWord (port + ELT_COMMAND, SELECT_WINDOW | WIN_STATISTICS);
  1304.     sysOutWord (port + ELT_COMMAND, STATS_DISABLE);
  1306.     pDrvCtrl->eltStat.nocarriers +=     sysInByte (port + CARRIER_LOSTS) & 0x0f;
  1307.     pDrvCtrl->eltStat.heartbeats +=     sysInByte (port + SQE_FAILURES) & 0x0f;
  1308.     pDrvCtrl->eltStat.multcollisions += sysInByte (port + MULT_COLLISIONS)
  1309.                                         & 0x3f;
  1310.     pDrvCtrl->eltStat.collisions +=     sysInByte (port + ONE_COLLISIONS)
  1311.                                         & 0x3f;
  1312.     pDrvCtrl->eltStat.latecollisions += sysInByte (port + LATE_COLLISIONS);
  1313.     pDrvCtrl->eltStat.rxoverruns +=     sysInByte (port + RECV_OVERRUNS);
  1314.     pDrvCtrl->eltStat.txnoerror +=      sysInByte (port + GOOD_TRANSMITS);
  1315.     pDrvCtrl->eltStat.rxnoerror +=      sysInByte (port + GOOD_RECEIVES);
  1316.     pDrvCtrl->eltStat.deferring +=      sysInByte (port + TX_DEFERRALS);
  1318.     /* Must read all the registers to be sure to clear the interrupt */
  1320.     (void) sysInWord (port + BYTES_RECEIVED);
  1321.     (void) sysInWord (port + BYTES_TRANSMITTED);
  1323.     sysOutWord (port + ELT_COMMAND, STATS_ENABLE);
  1324.     sysOutWord (port + ELT_COMMAND, SELECT_WINDOW | WIN_OPERATING);
  1325.     }
  1327. /*******************************************************************************
  1328. *
  1329. * eltIntMaskSet - enable specific status conditions to cause interrupts
  1330. *
  1331. * Sets bit(s) in the intMask field of the device control structure and in
  1332. * the board's "read zero mask" where a one bit enables the corresponding
  1333. * status condition to be read and to cause an interrupt.
  1334. */
  1336. static void eltIntMaskSet
  1337.     (
  1338.     ELT_CTRL * pDrvCtrl,
  1339.     int maskBits
  1340.     )
  1341.     {
  1342.     eltIntDisable (pDrvCtrl);
  1344.     pDrvCtrl->intMask |= maskBits;
  1345.     sysOutWord (pDrvCtrl->port + ELT_COMMAND, MASK_STATUS | pDrvCtrl->intMask);
  1347.     eltIntEnable (pDrvCtrl);
  1348.     }
  1350. /*******************************************************************************
  1351. *
  1352. * eltIntEnable - enable board to cause interrupts
  1353. *
  1354. * Because the board has maskable status, this routine can simply set the
  1355. * mask to all ones.  We set all the bits symbolically; the effect is the
  1356. * same.  Note that the interrupt latch is not maskable; if none of the other
  1357. * mask bits are set, no interrupts will occur at all.  Only those interrupts
  1358. * whose status bits are enabled will actually occur.  Note that the "intMask"
  1359. * field in the device control structure is really the status mask.
  1360. */
  1362. static void eltIntEnable
  1363.     (
  1364.     ELT_CTRL * pDrvCtrl
  1365.     )
  1366.     {
  1367.     UINT16  status;
  1369.     status = sysInByte (pDrvCtrl->port + ELT_STATUS) & 0x00ff;
  1370.     sysOutWord (pDrvCtrl->port + ELT_COMMAND, ACK_INTERRUPT | status);
  1371.     sysOutWord (pDrvCtrl->port + ELT_COMMAND, MASK_INTERRUPT |
  1372.                 ADAPTER_FAILURE | TX_COMPLETE | TX_AVAILABLE | RX_COMPLETE |
  1373.                 RX_EARLY | INTERRUPT_REQ | UPDATE_STATS);
  1374.     }
  1376. /*******************************************************************************
  1377. *
  1378. * eltIntDisable - prevent board from causing interrupts
  1379. *
  1380. * This routine simply sets all the interrupt mask bits to zero.
  1381. * It is intended for guarding board-critical sections.
  1382. */
  1384. static void eltIntDisable
  1385.     (
  1386.     ELT_CTRL * pDrvCtrl
  1387.     )
  1388.     {
  1389.     UINT16  status;
  1391.     sysOutWord (pDrvCtrl->port + ELT_COMMAND, MASK_INTERRUPT | 0);
  1392.     status = sysInByte (pDrvCtrl->port + ELT_STATUS) & 0x00ff;
  1393.     sysOutWord (pDrvCtrl->port + ELT_COMMAND, ACK_INTERRUPT | status);
  1394.     }
  1396. /*******************************************************************************
  1397. *
  1398. * eltTxStart - turn on board's transmit function
  1399. */
  1401. static void eltTxStart
  1402.     (
  1403.     ELT_CTRL *  pDrvCtrl
  1404.     )
  1405.     {
  1406.     sysOutWord (pDrvCtrl->port + ELT_COMMAND, TX_ENABLE);
  1407.     }
  1409. /*******************************************************************************
  1410. *
  1411. * eltRxStart - enable board to start receiving
  1412. */
  1414. static void eltRxStart
  1415.     (
  1416.     ELT_CTRL *  pDrvCtrl
  1417.     )
  1418.     {
  1419.     sysOutWord (pDrvCtrl->port + ELT_COMMAND, SET_RX_FILTER |
  1420.                                               pDrvCtrl->rxFilter);
  1421.     sysOutWord (pDrvCtrl->port + ELT_COMMAND, RX_ENABLE);
  1422.     }
  1424. /*******************************************************************************
  1425. *
  1426. * eltActivate - attempt to find and activate the adapter with given address
  1427. *
  1428. * The 3Com 3C509 ISA adapter does not enable itself at power-on.  This is
  1429. * left to the driver, which presumably knows which board it wants.  This
  1430. * we do know, from the port field in the driver control structure.
  1431. *
  1432. * As a helpful side effect, this routine stores the OEM Ethernet address
  1433. * of the selected adapter into the driver control structure.
  1434. *
  1435. * Note that this procedure will activate only one board of the given I/O
  1436. * address; this is presumably designed in by 3Com as a helpful feature.
  1437. */
  1439. static STATUS eltActivate
  1440.     (
  1441.     ELT_CTRL * pDrvCtrl
  1442.     )
  1443.     {
  1444.     int adapterPort;    /* I/O address of adapter we're to look for */
  1445.     int selectedPort;   /* I/O address of adapter we've found */
  1446.     int addressConfig;  /* adapter's address configuration register */
  1447.     int resourceConfig; /* adapter's resource configuration register */
  1448.     char nodeAddress [EA_SIZE];
  1449.     STATUS status = OK; /* presume OK, change if there's a problem */
  1451.     adapterPort = pDrvCtrl->port;
  1453.     eltIdCommand (ID_PORT);             /* wake up all adapters */
  1454.     sysOutByte (ID_PORT, ID_SET_TAG);   /* clear all tags */
  1456.     /* first see if there's a 3Com 3C5xx board out there at all */
  1458.     if (eltIdEepromRead (EE_A_MANUFACTURER) != MANUFACTURER_ID)
  1459.         return (ERROR);
  1461.     /* Identify adapters one by one until we find the right one;
  1462.      * as we eliminate adapters, we tag them so they don't participate
  1463.      * in the next round of contention eliminations.  Along the way,
  1464.      * as part of the adapter contention process, we read out the
  1465.      * station address and resource configuration.
  1466.      */
  1468.     do
  1469.         {
  1470.         eltIdCommand (ID_PORT);         /* prepare for contention */
  1472.         /* Now read all untagged adapters' addresses from EEPROM
  1473.          * a bit at a time.  Tagged adapters ignore the reads therefore
  1474.          * won't be found; we find the next untagged adapter.
  1475.          */
  1477.         * (UINT16 *) &nodeAddress [0] = eltIdEepromRead (EE_A_OEM_NODE_0);
  1478.         * (UINT16 *) &nodeAddress [2] = eltIdEepromRead (EE_A_OEM_NODE_1);
  1479.         * (UINT16 *) &nodeAddress [4] = eltIdEepromRead (EE_A_OEM_NODE_2);
  1480.         resourceConfig = eltIdEepromRead (EE_A_RESOURCE);
  1481.         addressConfig = eltIdEepromRead (EE_A_ADDRESS);
  1482.         if ( (addressConfig & AC_IO_BASE_MASK) == AC_IO_BASE_EISA)
  1483.             {
  1485.             /* the EISA base address is the last possible one; if we hit
  1486.              * this value without finding the adapter we want, we're done.
  1487.              */
  1489.             status = ERROR;
  1490.             break;
  1491.             }
  1492.         selectedPort = (addressConfig & AC_IO_BASE_MASK) * AC_IO_BASE_FACTOR +
  1493.                        AC_IO_BASE_ZERO;
  1495. #ifdef ELT_DEBUG
  1496.         printf ("elt: activate: adapter at 0x%04xn", selectedPort);
  1497. #endif /* ELT_DEBUG */
  1499.         /* tag this adapter so if we don't want it it won't contend again */
  1501.         sysOutByte (ID_PORT, ID_SET_TAG + 1);
  1502.         }
  1503.     while (selectedPort != adapterPort);
  1505.     if (status != ERROR)
  1506.         {
  1507.         sysOutByte (ID_PORT, ID_ACTIVATE);
  1508.         uswab (nodeAddress, (char *)pDrvCtrl->idr.ac_enaddr, EA_SIZE);
  1509.         }
  1511.     return (status);
  1512.     }
  1514. /*******************************************************************************
  1515. *
  1516. * eltIdCommand - put all adapters into ID command state
  1517. *
  1518. * This procedure synchronizes the ID state machines of all installed 3Com
  1519. * adapters in preparation for contending among them.
  1520. */
  1522. static void eltIdCommand
  1523.     (
  1524.     int idPort          /* I/O address to use as ID port (1x0 hex) */
  1525.     )
  1526.     {
  1527.     int idValue;        /* data read or written to ID port */
  1528.     int count;
  1530.     /* We should guard this routine since the ID procedure touches
  1531.      * all unactivated adapters.  In fact the first three writes should
  1532.      * be guarded against any possible intervening write to any port
  1533.      * 0x100, 0x110, 0x120, ... , 0x1f0.
  1534.      */
  1536.     sysOutByte (idPort, ID_RESET);      /* select the ID port */
  1537.     sysOutByte (idPort, ID_RESET);      /* put adapters in ID-WAIT state */
  1538.     idValue = ID_SEQUENCE_INITIAL;
  1539.     for (count = ID_SEQUENCE_LENGTH; count > 0; count--)
  1540.         {
  1541.         sysOutByte (idPort, idValue);
  1542.         idValue <<= 1;
  1543.         if ( (idValue & ID_CARRY_BIT) != 0)
  1544.             idValue ^= ID_POLYNOMIAL;
  1545.         }
  1546.     }
  1548. /*******************************************************************************
  1549. *
  1550. * eltIdEepromRead - read one 16-bit adapter EEPROM register
  1551. *
  1552. * Read an EEPROM register bitwise by way of the ID port.  Used for adapter
  1553. * contention process and to find out what's in the EEPROM.  Addresses are
  1554. * masked to a valid size; invalid addresses are simply truncated.
  1555. */
  1557. static UINT16 eltIdEepromRead
  1558.     (
  1559.     int address                         /* EEPROM register address */
  1560.     )
  1561.     {
  1562.     int bitCount;
  1563.     UINT16 value;
  1565.     sysOutByte (ID_PORT, ID_EEPROM_READ | (address & ID_EEPROM_MASK));
  1566.     taskDelay (2);                      /* must wait for 162 uS read cycle */
  1567.     value = 0;
  1568.     for (bitCount = ID_REGISTER_SIZE; bitCount > 0; bitCount--)
  1569.         {
  1570.         value <<= 1;
  1571.         value |= sysInByte (ID_PORT) & 1;
  1572.         }
  1573.     return (value);
  1574.     }
  1576. /*******************************************************************************
  1577. *
  1578. * eltShow - display statistics for the 3C509 `elt' network interface
  1579. *
  1580. * This routine displays statistics about the `elt' Ethernet network interface.
  1581. * It has two parameters: 
  1582. * .iP <unit>
  1583. * interface unit; should be 0.
  1584. * .iP <zap>
  1585. * if 1, all collected statistics are cleared to zero.
  1586. * .LP
  1587. *
  1588. * RETURNS: N/A
  1589. */
  1591. void eltShow 
  1592.     (
  1593.     int unit,   /* interface unit */
  1594.     BOOL zap    /* 1 = zero totals */
  1595.     )
  1596.     {
  1597.     ELT_CTRL * pDrvCtrl;
  1598.     FAST int ix;
  1599.     static char *e_message [] = {
  1600.         "collisions",
  1601.         "crcs",
  1602.         "aligns",
  1603.         "rx no buffers",
  1604.         "rx over-runs",
  1605.         "disabled",
  1606.         "deferring",
  1607.         "tx under-run",
  1608.         "aborts",
  1609.         "out-of-window",
  1610.         "heart-beats",
  1611.         "bad-packet",
  1612.         "short-packet",
  1613.         "tx-no-error",
  1614.         "rx-no-error",
  1615.         "tx-error",
  1616.         "rx-error",
  1617.         "over-write",
  1618.         "wrapped",
  1619.         "interrupts",
  1620.         "reset",
  1621.         "stray-int",
  1622.         "multiple-collisions",
  1623.         "late-collisions",
  1624.         "no-carriers",
  1625.         "jabbers",
  1626.         "tx over-run",
  1627.         "rx under-run",
  1628. #ifdef ELT_TIMING
  1629.         "rx early",
  1630.         "timer updates",
  1631.         "timer overflows",
  1632.         "timer invalids",
  1633.         "max rx latency",
  1634.         "min rx latency",
  1635.         "max int latency",
  1636.         "current outstanding net rx tasks",
  1637.         "max outstanding rx net tasks",
  1638.         "current outstanding net tx tasks",
  1639.         "max outstanding tx net tasks"
  1640. #else
  1641.         "rx early"
  1642. #endif /* ELT_TIMING */
  1643. };
  1645.     pDrvCtrl = pEltCtrl [unit];
  1647.     /* Disable board interrupts because eltStatFlush() changes reg. window */
  1649.     eltIntDisable (pDrvCtrl);
  1650.     eltStatFlush (pDrvCtrl);            /* get the latest statistics */
  1651.     eltIntEnable (pDrvCtrl);
  1653.     for (ix = 0; ix < NELEMENTS(e_message); ix++)
  1654.         {
  1655.         printf ("    %-30.30s  %4dn", e_message [ix],
  1656.                 pDrvCtrl->eltStat.stat [ix]);
  1657.         if (zap)
  1658.             pDrvCtrl->eltStat.stat [ix] = 0;
  1659.         }
  1660.     }