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

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

VxWorks

开发平台：

C/C++

if_elc.c：源码内容
  1. /* if_elc.c - SMC 8013WC Ethernet network interface driver */
  3. /* Copyright 1984-1999 Wind River Systems, Inc. */
  5. #include "copyright_wrs.h"
  7. /*
  8. modification history
  9. --------------------
  10. 02b,11jan99,aeg  fixed multiple semaphore inits in elcattach ().
  11. 02a,15jul97,spm  removed driver initialization from ioctl support (SPR #8831)
  12. 01z,15may97,spm  reverted to bcopy routines for mbufs in BSD 4.4
  13. 01y,07apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  14. 01x,14jun95,hdn  removed function declarations defined in sysLib.h.
  15. 01w,01feb95,jdi  doc cleanup; made elcShow() NOMANUAL.
  16. 01v,29nov94,hdn  added a semaphore in ultraPut().
  17. 01u,12nov94,tmk  removed some IMPORTed function decs and included unixLib.h
  18. 01t,03oct94,hdn  implemented two transmit buffers.
  19.  enabled getting OUT2 bit of IRR in EEROM.
  20.  deleted while loop in ultraPut().
  21. 01s,03dec93,hdn  added documentation.
  22. 01r,29nov93,hdn  removed netJobAdd (elcPut, ..) in elcIntr().
  23. 01q,28nov93,hdn  changed NELC to 1.
  24. 01p,24nov93,hdn  removed TXING and txreq flags.
  25.  added checking TXP bit before the transmission. 
  26. 01o,23nov93,hdn  removed cacheInvalidate(). 
  27. 01n,22nov93,hdn  added elcdetach () for the warm start.
  28. 01m,15nov93,hdn  added support for Thin Ethernet(10Base2, BNC)
  29. 01l,05nov93,hdn  added cacheFlush() and cacheInvalidate().
  30. 01k,04nov93,hdn  cleaned up.
  31. 01j,03nov93,hdn  made RAM size 16Kbytes. cleaned up.
  32. 01i,05sep93,hdn  added sysIntEnablePIC ().
  33. 01h,02sep93,hdn  added macros about PIC.
  34. 01g,11aug93,hdn  changed a way of setting a handler for stray interrupt IRQ7.
  35. 01f,23jun93,hdn  made address, irq software configuarable.
  36. 01e,17jun93,hdn  updated to 5.1.
  37. 01d,28may93,hdn  deleted a zero wait bit. fixed a race condition.
  38. 01c,23apr93,hdn  fixed a bug which appears when a packet is wrapped.
  39.  fixed a stray interrupt 15.
  40.  moved a interrupt masking to the top of elcGet.
  41. 01b,03jan93,hdn  fixed bugs and cleaned up.
  42. 01a,09jun92,hdn  written.
  43. */
  45. /*
  46. DESCRIPTION
  47. This module implements the SMC 8013WC network interface driver.
  49. BOARD LAYOUT
  50. The W1 jumper should be set in position SOFT.
  51. The W2 jumper should be set in position NONE/SOFT.
  53. CONFIGURATION
  54. The I/O address, RAM address, RAM size, and IRQ levels are defined in config.h.
  55. The I/O address must match the one stored in EEROM.  The configuration 
  56. software supplied by the manufacturer should be used to set the I/O address. 
  58. IRQ levels 2,3,4,5,7,9,10,11,15 are supported.  Thick Ethernet (AUI) and
  59. Thin Ethernet (BNC) are configurable by changing the macro CONFIG_ELC
  60. in config.h.
  62. EXTERNAL INTERFACE
  63. The only user-callable routines are elcattach() and elcShow():
  64. .iP elcattach() 14
  65. publishes the `elc' interface and initializes the driver and device.
  66. .iP elcShow()
  67. displays statistics that are collected in the interrupt handler.
  68. .LP
  69. */
  71. #include "vxWorks.h"
  72. #include "net/mbuf.h"
  73. #include "net/protosw.h"
  74. #include "net/unixLib.h"
  75. #include "ioctl.h"
  76. #include "socket.h"
  77. #include "errnoLib.h"
  78. #include "net/uio.h"
  79. #include "net/if.h"
  80. #include "net/route.h"
  81. #include "netinet/in.h"
  82. #include "netinet/in_systm.h"
  83. #include "netinet/ip.h"
  84. #include "netinet/ip_var.h"
  85. #include "netinet/in_var.h"
  86. #include "netinet/if_ether.h"
  87. #include "etherLib.h"
  88. #include "vme.h"
  89. #include "iv.h"
  90. #include "iosLib.h"
  91. #include "ioLib.h"
  92. #include "memLib.h"
  93. #include "net/systm.h"
  94. #include "net/if_subr.h"
  95. #include "sysLib.h"
  96. #include "vxLib.h"
  97. #include "stdio.h"
  98. #include "intLib.h"
  99. #include "logLib.h"
  100. #include "string.h"
  101. #include "netLib.h"
  102. #include "stdlib.h"
  103. #include "semLib.h"
  104. #include "cacheLib.h"
  105. #include "drv/intrCtl/i8259a.h"
  106. #include "drv/netif/if_elc.h"
  108. /*
  109.  * Ethernet software status per interface.
  110.  *
  111.  * Each interface is referenced by a network interface structure,
  112.  * es_if, which the routing code uses to locate the interface.
  113.  * This structure contains the output queue for the interface, its address, ...
  114.  */
  116. #define NELC 1 /* max number of ELC controllers */
  118. LOCAL ELC_SOFTC elc_softc [NELC];
  119. LOCAL IRQ_TABLE irqTable [] =
  120.     {
  121.     {0xff,  0xff}, /* IRQ0  not supported  */
  122.     {0xff,  0xff}, /* IRQ1  not supported  */
  123.     {0x0,   0x0}, /* IRQ2   */
  124.     {0x0,   0x1}, /* IRQ3   */
  125.     {0x1,   0x3}, /* IRQ4   */
  126.     {0x0,   0x2}, /* IRQ5   */
  127.     {0xff,  0xff}, /* IRQ6  not supported  */
  128.     {0x0,   0x3}, /* IRQ7   */
  129.     {0xff,  0xff}, /* IRQ8  not supported  */
  130.     {0x0,   0x0}, /* IRQ9   */
  131.     {0x1,   0x0}, /* IRQ10  */
  132.     {0x1,   0x1}, /* IRQ11  */
  133.     {0xff,  0xff}, /* IRQ12 not supported  */
  134.     {0xff,  0xff}, /* IRQ13 not supported  */
  135.     {0xff,  0xff}, /* IRQ14 not supported  */
  136.     {0x1,   0x2}, /* IRQ15  */
  137.     {0, 0},
  138.     };
  139. LOCAL BOOL elcAttached = FALSE;
  140. LOCAL SEMAPHORE elcSyncSem; /* syncronization semaphore */
  143. /* forward static functions */
  145. static void elcreset (int unit);
  146. static int elcinit (int unit);
  147. static void elcintr (int unit);
  148. static int elcioctl (struct ifnet *ifp, int cmd, caddr_t data);
  149. #ifdef BSD43_DRIVER
  150. static int elcoutput (struct ifnet *ifp, struct mbuf *m0, struct sockaddr
  151. *dst);
  152. #endif
  153. static void elcGet (int unit);
  154. #ifdef BSD43_DRIVER
  155. static void elcPut (int unit);
  156. #else
  157. static void elcPut (ELC_SOFTC *sc);
  158. #endif
  159. static void elcReset (int unit);
  160. static void elcGetAddr (int unit);
  161. static void bicInit (int unit);
  162. static void elcInit (int unit);
  163. static UCHAR elcGetCurr (int unit);
  164.        void elcShow (int unit, BOOL zap);
  165.        void elcdetach (int unit);
  168. /*******************************************************************************
  169. *
  170. * elcattach - publish the `elc' network interface and initialize the driver and device
  171. *
  172. * This routine attaches an `elc' Ethernet interface to the network if the
  173. * device exists.  It makes the interface available by filling in the network
  174. * interface record.  The system will initialize the interface when it is
  175. * ready to accept packets.
  176. *
  177. * RETURNS: OK or ERROR.
  178. *
  179. * SEE ALSO: ifLib, netShow
  180. */
  182. STATUS elcattach 
  183.     (
  184.     int unit,           /* unit number */
  185.     int ioAddr,         /* address of elc's shared memory */
  186.     int ivec,           /* interrupt vector to connect to */
  187.     int ilevel,         /* interrupt level */
  188.     int memAddr,        /* address of elc's shared memory */
  189.     int memSize,        /* size of elc's shared memory */
  190.     int config /* 0: RJ45 + AUI(Thick)  1: RJ45 + BNC(Thin) */
  191.     )
  192.     {
  193.     FAST ELC_SOFTC *sc = &elc_softc[unit];
  195.     if ((UINT)unit >= NELC)
  196. {
  197. errnoSet (S_iosLib_CONTROLLER_NOT_PRESENT);
  198. return (ERROR);
  199. }
  201.     sc->bicAddr = ioAddr;
  202.     sc->elcAddr = ioAddr + 0x10;
  203.     sc->memAddr = memAddr;
  204.     sc->memSize = memSize;
  205.     if (ilevel == 0  || ilevel == 1  || ilevel == 6 || ilevel == 8 ||
  206. ilevel == 12 || ilevel == 13 || ilevel == 14)
  207. ilevel = 3;                     /* default is IRQ3 */
  208.     sc->intLevel = ilevel;
  209.     sc->intVec = ivec;
  210.     sc->config = config;
  211.     sc->transmitPage[0] = SMC8013WC_TSTART0;
  212.     sc->transmitPage[1] = SMC8013WC_TSTART1;
  213.     sc->transmitCnt = 0;
  215.     /* synchronization semaphore must be initialized only once */
  217.     if (!elcAttached)
  218. semBInit (&elcSyncSem, SEM_Q_FIFO, SEM_FULL);
  220.     bicInit (unit); /* initialize BIC */
  222.     elcInit (unit); /* initialize ELC */
  224.     elcGetAddr (unit); /* get ethernet address */
  226.     (void) intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (ivec), (VOIDFUNCPTR)elcintr, unit);
  228.     /* enable interrupt */
  230.     sysOutByte (ELC_INTMASK (sc->elcAddr), 
  231. IM_OVWE | IM_TXEE | IM_PTXE | IM_PRXE);
  233.     sysIntEnablePIC (ilevel);
  235. #ifdef BSD43_DRIVER
  236.     ether_attach (&sc->es_if, unit, "elc", (FUNCPTR)elcinit, (FUNCPTR)elcioctl,
  237.   (FUNCPTR)elcoutput, (FUNCPTR)elcreset);
  238. #else
  239.     ether_attach (
  240.                  &sc->es_if, 
  241.                  unit, 
  242.                  "elc", 
  243.                  (FUNCPTR)elcinit, 
  244.                  (FUNCPTR)elcioctl,
  245.  (FUNCPTR)ether_output, 
  246.                  (FUNCPTR)elcreset
  247.                  );
  248.     sc->es_if.if_start = (FUNCPTR)elcPut;
  249. #endif
  251.     elcinit (unit);
  253.     elcAttached = TRUE;
  255.     return (OK);
  256.     }
  258. /*******************************************************************************
  259. *
  260. * elcreset - reset the interface
  261. */
  263. LOCAL void elcreset 
  264.     (
  265.     int unit 
  266.     )
  267.     {
  268.     elcReset (unit);
  269.     }
  271. /*******************************************************************************
  272. *
  273. * elcinit - initialize elc
  274. *
  275. * Restart the link level software on the board and mark the interface up.
  276. *
  277. * RETURNS: 0
  278. */
  280. LOCAL int elcinit 
  281.     (
  282.     int unit 
  283.     )
  284.     {
  285.     FAST ELC_SOFTC *sc = &elc_softc[unit];
  287.     sc->es_if.if_flags |= IFF_UP|IFF_RUNNING; /* open for business*/
  289.     return (0);
  290.     }
  292. /*******************************************************************************
  293. *
  294. * elcintr - Ethernet interface interrupt
  295. *
  296. * Hand off reading of packets from the interface to task level.
  297. */
  299. LOCAL void elcintr 
  300.     (
  301.     int unit 
  302.     )
  303.     {
  304.     FAST ELC_SOFTC *sc = &elc_softc[unit];
  306.     sc->elcStat.interrupts++;
  307.     sysBusIntAck (sc->intLevel); /* acknowledge int */
  309.     /* acknowledge interrupt, get Transmit/Receive status */
  311.     sc->istat = sysInByte (ELC_INTSTAT (sc->elcAddr));
  312.     sysOutByte (ELC_INTSTAT (sc->elcAddr), sc->istat);
  313.     sc->tstat = sysInByte (ELC_TSTAT (sc->elcAddr));
  314.     sc->rstat = sysInByte (ELC_RSTAT (sc->elcAddr));
  316.     /* get xxxCount Reg that is cleared after read access */
  318.     sc->elcStat.collisions += sysInByte (ELC_COLCNT (sc->elcAddr));
  319.     sc->elcStat.aligns += sysInByte (ELC_ALICNT (sc->elcAddr));
  320.     sc->elcStat.crcs += sysInByte (ELC_CRCCNT (sc->elcAddr));
  321.     sc->elcStat.missed += sysInByte (ELC_MPCNT (sc->elcAddr));
  324.     if (sc->istat & ISTAT_OVW) /* Receive buffer ring overwrite */
  325. {
  326.         sysOutByte (ELC_BOUND(sc->elcAddr), sysInByte (ELC_BOUND(sc->elcAddr)));
  327. sc->elcStat.overwrite++;
  328.         sc->es_if.if_ierrors++;
  329. }
  330.     if (sc->istat & ISTAT_RXE) /* Receive-error */
  331. {
  332.         sc->es_if.if_ierrors++;
  333. sc->elcStat.rerror++;
  334. if (sc->rstat & RSTAT_OVER)
  335.     sc->elcStat.overruns++;
  336. if (sc->rstat & RSTAT_DIS)
  337.     sc->elcStat.disabled++;
  338. if (sc->rstat & RSTAT_DFR)
  339.     sc->elcStat.deferring++;
  340. }
  341.     if (sc->istat & ISTAT_PRX) /* Receive */
  342. {
  343.         sc->current = elcGetCurr (unit);
  344. if ((sc->flags & RXING) == 0)
  345.     {
  346.             sc->flags |= RXING;
  347.     (void) netJobAdd ((FUNCPTR)elcGet, unit, 0,0,0,0);
  348.     }
  349. if (sc->rstat & RSTAT_PRX)
  350.     sc->elcStat.rnoerror++;
  351. }
  353.     if (sc->istat & (ISTAT_TXE | ISTAT_PTX)) /* Transmit-error, Transmit */
  354. {
  355. semGive (&elcSyncSem);
  356.         if (sc->istat & ISTAT_TXE)
  357.             {
  358.             sc->es_if.if_oerrors++;
  359.             sc->es_if.if_opackets--;
  360.     sc->elcStat.terror++;
  361.             }
  362. if (sc->tstat & TSTAT_ABORT)
  363.     {
  364.     sc->elcStat.aborts++;
  365.     sc->elcStat.collisions += 16;
  366.     }
  367. if (sc->tstat & TSTAT_UNDER)
  368.     sc->elcStat.underruns++;
  369. if (sc->tstat & TSTAT_CDH)
  370.     sc->elcStat.heartbeats++;
  371. if (sc->tstat & TSTAT_OWC)
  372.     sc->elcStat.outofwindow++;
  373. if (sc->tstat & TSTAT_PTX)
  374.     sc->elcStat.tnoerror++;
  375. }
  376.     }
  378. /*******************************************************************************
  379. *
  380. * elcGet - read a packet off the interface
  381. *
  382. * Copy packets from a RING into an mbuf and hand it to the next higher layer.
  383. */
  385. LOCAL void elcGet 
  386.     (
  387.     int unit
  388.     )
  389.     {
  390.     FAST ELC_SOFTC *sc = &elc_softc[unit];
  391.     FAST ELC_HEADER *pH;
  392.     FAST struct ether_header *eh;
  393.     FAST struct mbuf *m;
  394.     int len;
  395. #ifdef BSD43_DRIVER
  396.     int off;
  397. #endif
  398.     int ix = 0;
  399.     USHORT wrapSize;
  400.     USHORT packetSize;
  401.     char *pSrc;
  402.     char *pDst;
  403.     UCHAR *pData;
  404.     UCHAR uppByteCnt;
  406. unlucky:
  407.     ix = 0;
  409.     while ((sc->next != sc->current) && (ix++ < SMC8013WC_PSTOP))
  410. {
  411. /* Invalidate cache */
  413.         cacheDrvInvalidate (&cacheDmaFuncs, 
  414.             (UCHAR *)(sc->memAddr + (SMC8013WC_PSTART << 8)),
  415.             (sc->memSize - (SMC8013WC_PSTART << 8)));
  417. pH = (ELC_HEADER *)(sc->memAddr + 
  418.    (((UINT)sc->next << 8) & 0x0000ffff));
  420. /* sanity check */
  422. if ((pH->next < SMC8013WC_PSTART) || (pH->next >= SMC8013WC_PSTOP))
  423.     {
  424.     sc->elcStat.badPacket++;
  425.     pH->next = sc->next + sc->uppByteCnt + 1;
  426.     if (pH->next >= SMC8013WC_PSTOP)
  427. pH->next = SMC8013WC_PSTART + (pH->next - SMC8013WC_PSTOP);
  428.     }
  430. if (*(USHORT *)(&pH->lowByteCnt) < 64)
  431.     {
  432.     sc->elcStat.shortPacket++;
  433.     goto doneGet;
  434.     }
  436.         sc->es_if.if_ipackets++;        /* bump statistic */
  438. /* get uppByteCnt from pH->next because of the bug of a chip */
  440. if (pH->next > sc->next)
  441.     {
  442.     wrapSize = 0;
  443.     uppByteCnt = pH->next - sc->next;
  444.     }
  445. else
  446.     {
  447.     wrapSize = (SMC8013WC_PSTOP - sc->next) << 8;
  448.     uppByteCnt = (SMC8013WC_PSTOP - sc->next) + 
  449.  (pH->next - SMC8013WC_PSTART);
  450.     }
  451. if (pH->lowByteCnt > 0xfc)
  452.     uppByteCnt -= 2;
  453. else
  454.     uppByteCnt -= 1;
  455. packetSize = (uppByteCnt << 8) | pH->lowByteCnt;
  456. pH->uppByteCnt = uppByteCnt;
  457. if (wrapSize > packetSize)
  458.     wrapSize = 0;
  460. /* copy separated frame to a temporary buffer */
  462. if (wrapSize)
  463.     {
  464.     sc->elcStat.wrapped++;
  465.     pSrc = (char *)pH;
  466.     pDst = (char *)sc->receiveBuf;
  467.     bcopy (pSrc, pDst, wrapSize);
  468.     pSrc = (char *)(sc->memAddr + (SMC8013WC_PSTART << 8));
  469.     pDst += wrapSize;
  470.     len = packetSize - wrapSize;
  471.     if (len)
  472. bcopy (pSrc, pDst, len);
  473.     }
  475.         len = packetSize - 4; /* remove CRCs 4 bytes */
  477.         if (wrapSize)
  478.     eh = (struct ether_header *)((UINT)sc->receiveBuf + 
  479. sizeof (ELC_HEADER));
  480.         else
  481.     eh = (struct ether_header *)((UINT)pH + sizeof (ELC_HEADER));
  483.         /* call input hook if any */
  485.         if ((etherInputHookRtn != NULL) &&
  486.     (* etherInputHookRtn) (&sc->es_if, (char *) eh, len))
  487.     {
  488.     goto doneGet;
  489.     }
  491.         if (len >= SIZEOF_ETHERHEADER)
  492.             len -= SIZEOF_ETHERHEADER;
  493.         else
  494.             {
  495.             sc->es_if.if_ierrors++;         /* bump error statistic */
  496.     goto doneGet;
  497.             }
  499.         pData = ((unsigned char *) eh) + SIZEOF_ETHERHEADER;
  501. #ifdef BSD43_DRIVER
  502.         check_trailer (eh, pData, &len, &off, &sc->es_if);
  504.         /* copy data from the ring buffer to mbuf a long-word at a time */
  505.         
  506.         m = bcopy_to_mbufs (pData, len, off, (struct ifnet *) &sc->es_if, 2);
  508.         if (m == NULL)
  509.             {
  510.             sc->es_if.if_ierrors++;         /* bump error statistic */
  511.     goto doneGet;
  512.             }
  514.         do_protocol_with_type (eh->ether_type, m, &sc->es_ac, len);
  515. #else
  517.         /* copy data from the ring buffer to mbuf a long-word at a time */
  519.         m = bcopy_to_mbufs (pData, len, 0, (struct ifnet *) &sc->es_if, 2);
  521.         if (m == NULL)
  522.             {
  523.             sc->es_if.if_ierrors++;         /* bump error statistic */
  524.             goto doneGet;
  525.             }
  527.         do_protocol (eh, m, &sc->es_ac, len);
  528. #endif
  530. doneGet:
  531. sc->next = pH->next;
  532. sc->uppByteCnt = pH->uppByteCnt;
  534. }
  536.     /* update BOUND Register */
  538.     if (sc->next <= SMC8013WC_PSTART)
  539. sysOutByte (ELC_BOUND (sc->elcAddr), SMC8013WC_PSTOP - 1);
  540.     else
  541. sysOutByte (ELC_BOUND (sc->elcAddr), sc->next - 1);
  543.     sc->flags &= ~RXING;
  545.     /* go back if we received an interrupt and a new packet */
  547.     if (sc->next != sc->current)
  548. goto unlucky;
  549.     }
  551. #ifdef BSD43_DRIVER
  552. /*******************************************************************************
  553. *
  554. * elcoutput - ethernet output routine
  555. *
  556. * Encapsulate a packet of type family for the local net.
  557. * Use trailer local net encapsulation if enough data in first
  558. * packet leaves a multiple of 512 bytes of data in remainder.
  559. * If destination is this address or broadcast, send packet to
  560. * loop device to kludge around the fact that 3com interfaces can't
  561. * talk to themselves.
  562. *
  563. * RETURNS: ?
  564. */
  566. LOCAL int elcoutput 
  567.     (
  568.     struct ifnet *ifp,
  569.     struct mbuf *m0,
  570.     struct sockaddr *dst 
  571.     )
  572.     {
  573.     return (ether_output (ifp, m0, dst, (FUNCPTR)elcPut,
  574.   &elc_softc [ifp->if_unit].es_ac));
  575.     }
  576. #endif
  578. /*******************************************************************************
  579. *
  580. * elcPut - copy a packet to the interface.
  581. *
  582. * Copy from mbuf chain to transmitter buffer in shared memory.
  583. *
  584. */
  586. #ifdef BSD43_DRIVER
  587. LOCAL void elcPut 
  588.     (
  589.     int unit
  590.     )
  591.     {
  592.     FAST ELC_SOFTC *sc   = &elc_softc [unit];
  593. #else
  594. LOCAL void elcPut 
  595.     (
  596.     ELC_SOFTC *sc
  597.     )
  598.     {
  599. #endif
  600.     FAST struct mbuf *m;
  601.     FAST int len;
  602.     UINT transmitPage = sc->transmitPage[sc->transmitCnt & 1];
  603.     UCHAR *pBuf = (UCHAR *)(sc->memAddr + (transmitPage << 8));
  604. #ifdef BSD43_DRIVER
  605.     int s = splnet ();
  607.     if (sc->es_if.if_snd.ifq_head != NULL)
  608. #else
  609.     while (sc->es_if.if_snd.ifq_head != NULL)
  610. #endif
  611. {
  612. semTake (&elcSyncSem, sysClkRateGet());
  614. IF_DEQUEUE (&sc->es_if.if_snd, m);
  616. copy_from_mbufs (pBuf, m, len);
  617. len = max (ETHERSMALL, len);
  619. cacheDrvFlush (&cacheDmaFuncs, pBuf, len);
  621. /* call output hook if any */
  623. if ((etherOutputHookRtn != NULL) &&
  624.     (* etherOutputHookRtn) (&sc->es_if, pBuf, len))
  625. #ifdef BSD43_DRIVER
  626.     goto donePut;
  627. #else
  628.             continue;
  629. #endif
  631. /* kick Transmitter */
  633.         sysOutByte (ELC_INTMASK (sc->elcAddr), 0x00);
  634. sysOutByte (ELC_TSTART (sc->elcAddr), transmitPage);
  635. sysOutByte (ELC_TCNTH (sc->elcAddr), len >> 8);
  636. sysOutByte (ELC_TCNTL (sc->elcAddr), len & 0xff);
  637. sysOutByte (ELC_CMD (sc->elcAddr), CMD_TXP);
  638. sc->transmitCnt++;
  639.         sysOutByte (ELC_INTMASK (sc->elcAddr), 
  640.     IM_OVWE | IM_TXEE | IM_PTXE | IM_PRXE);
  641. #ifndef BSD43_DRIVER
  642.         sc->es_if.if_opackets++;
  643. #endif
  644. }
  646. #ifdef BSD43_DRIVER
  647. donePut:
  648.     splx (s);
  649. #endif
  650.     }
  652. /*******************************************************************************
  653. *
  654. * elcReset - reset the chip
  655. *
  656. * Reset the chip.
  657. *
  658. */
  660. LOCAL void elcReset 
  661.     (
  662.     int unit
  663.     )
  664.     {
  665.     FAST ELC_SOFTC *sc   = &elc_softc [unit];
  666.     int s = splnet ();
  668.     /* mask interrupt */
  669.     sysOutByte (ELC_INTMASK (sc->elcAddr), 0x00);
  671.     bicInit (unit);
  672.     elcInit (unit);
  674.     /* unmask interrupt */
  675.     sysOutByte (ELC_INTMASK (sc->elcAddr), 
  676. IM_OVWE | IM_TXEE | IM_PTXE | IM_PRXE);
  678.     sc->elcStat.reset++;
  679.     splx (s);
  680.     }
  682. /*******************************************************************************
  683. *
  684. * elcioctl - ioctl for interface
  685. *
  686. * RETURNS: ?
  687. */
  689. LOCAL int elcioctl 
  690.     (
  691.     FAST struct ifnet *ifp,
  692.     int cmd,
  693.     caddr_t data 
  694.     )
  695.     {
  696.     int error = 0;
  697.     int s;
  699.     s = splimp();
  701.     switch (cmd)
  702. {
  703. case SIOCSIFADDR:
  704.             ((struct arpcom *)ifp)->ac_ipaddr = IA_SIN (data)->sin_addr;
  705.             arpwhohas (ifp, &IA_SIN (data)->sin_addr);
  706.     break;
  708. case SIOCSIFFLAGS:
  709.             /* Handled outside module - nothing more to do. */
  710.     break;
  712. default:
  713.     error = EINVAL;
  714. }
  716.     splx (s);
  717.     return (error);
  718.     }
  720. /*******************************************************************************
  721. *
  722. * bicInit - initialize SMC83c584 BIC (Bus Interface Controller)
  723. *
  724. * RETURNS: N/A
  725. *
  726. * NOMANUAL
  727. */
  729. LOCAL void bicInit 
  730.     (
  731.     int unit
  732.     )
  733.     {
  734.     FAST ELC_SOFTC *sc = &elc_softc[unit];
  735.     IRQ_TABLE *p = &irqTable[sc->intLevel];
  736.     char laar = (sc->memAddr & 0xf80000) >> 19;
  737.     char msr  = (sc->memAddr & 0x07e000) >> 13;
  738.     char iar  = (sc->bicAddr & 0xe000) >> 8 | (sc->bicAddr & 0x03e0) >> 5;
  739.     char irr;
  740.     char icr;
  741.     char eeromIrr;
  743.     /* get IRQ level bits */
  745.     if (p->ir2 == 0xff)
  746.         p = &irqTable[3]; /* default is IRQ3 */
  748.     irr  = p->ir01 << 5;
  749.     icr  = p->ir2 << 2;
  751.     /* Reset and Recall */
  753.     sysOutByte (BIC_MSR (sc->bicAddr), MSR_RST);
  754.     sysOutByte (BIC_MSR (sc->bicAddr), 0);
  755.     taskDelay (sysClkRateGet () >> 2);
  756.     sysOutByte (BIC_ICR (sc->bicAddr), ICR_RLA | ICR_RX7);
  757.     while (sysInByte (BIC_ICR (sc->bicAddr)) & (ICR_RLA | ICR_RX7))
  758. ;
  760.     /* get values set by EEROM */
  762.     eeromIrr = sysInByte (BIC_IRR (sc->bicAddr));
  764.     /* Memory Select Reg: Enable, 0x??000. */
  766.     sysOutByte (BIC_MSR (sc->bicAddr), MSR_MEN | msr);
  768.     /* Interface Config Reg: 16Kbytes, 16Bit. */
  770.     sysOutByte (BIC_ICR (sc->bicAddr), ICR_BIT16 | icr);
  772.     /* IO Address Reg: 0x??0 */
  774.     sysOutByte (BIC_IAR (sc->bicAddr), iar);
  776.     /* BIOS ROM Address Reg: Disable */
  778.     sysOutByte (BIC_BIO (sc->bicAddr), 0x00);
  780.     /* Interrupt Request Reg: Enable, IRQ? */
  782.     if (sc->config == 1)
  783.         sysOutByte (BIC_IRR (sc->bicAddr), IRR_IEN | irr | IRR_OUT1);
  784.     else if (sc->config == 2)
  785.         sysOutByte (BIC_IRR (sc->bicAddr), IRR_IEN | irr | IRR_OUT1 | IRR_OUT2);
  786.     else
  787.         sysOutByte (BIC_IRR (sc->bicAddr), IRR_IEN | irr | IRR_OUT1 |
  788.     (eeromIrr & 0x0e));
  790.     /* LA Address Reg: 16Bit-memory, 16Bit-lan, 0x??000 */
  792.     sysOutByte (BIC_LAAR (sc->bicAddr), LAAR_M16EN | LAAR_L16EN | laar);
  794.     }
  796. /*******************************************************************************
  797. *
  798. * elcInit - initialize SMC83c690 ELC (Ethernet LAN Controller)
  799. *
  800. * RETURNS: N/A
  801. *
  802. * NOMANUAL
  803. */
  805. LOCAL void elcInit 
  806.     (
  807.     int unit
  808.     )
  809.     {
  810.     FAST ELC_SOFTC *sc          = &elc_softc[unit];
  812.     /* 1. program Command Register for page 0 */
  814.     sysOutByte (ELC_CMD (sc->elcAddr), CMD_CMD5 | CMD_STP);
  815.     while ((sysInByte (ELC_INTSTAT (sc->elcAddr)) & ISTAT_RST) != ISTAT_RST)
  816. ;
  818.     /* 2. initialize Data Configuration Register */
  820.     sysOutByte (ELC_DCON (sc->elcAddr), DCON_BSIZE1 | DCON_BUS16 | 0x08);
  822.     /* 3. clear Remote Byte Count Register */
  824.     sysOutByte (ELC_RBCR0 (sc->elcAddr), 0x00);
  825.     sysOutByte (ELC_RBCR1 (sc->elcAddr), 0x00);
  827.     /* 4. initialize Receive Configuration Register */
  829.     sysOutByte (ELC_RCON (sc->elcAddr), 0x04);
  831.     /* 5. place the ELC in LOOPBACK mode 1 or 2 */
  833.     sysOutByte (ELC_TCON (sc->elcAddr), TCON_LB1);
  835.     /* 6. initialize Receive Buffer Ring */
  837.     sysOutByte (ELC_RSTART (sc->elcAddr), SMC8013WC_PSTART);
  838.     sysOutByte (ELC_RSTOP (sc->elcAddr), SMC8013WC_PSTOP);
  839.     sysOutByte (ELC_BOUND (sc->elcAddr), SMC8013WC_PSTART);
  841.     /* 7. clear Interrupt Status Register */
  843.     sysOutByte (ELC_INTSTAT (sc->elcAddr), 0xff);
  845.     /* 8. initialize Interrupt Mask Register */
  847.     sysOutByte (ELC_INTMASK (sc->elcAddr), 0x00);
  849.     /* 9. program Command Register for page 1 */
  851.     sysOutByte (ELC_CMD (sc->elcAddr), CMD_PS0 | CMD_STP);
  852.     sysOutByte (ELC_STA0 (sc->elcAddr), sysInByte (BIC_LAR0 (sc->bicAddr)));
  853.     sysOutByte (ELC_STA1 (sc->elcAddr), sysInByte (BIC_LAR1 (sc->bicAddr)));
  854.     sysOutByte (ELC_STA2 (sc->elcAddr), sysInByte (BIC_LAR2 (sc->bicAddr)));
  855.     sysOutByte (ELC_STA3 (sc->elcAddr), sysInByte (BIC_LAR3 (sc->bicAddr)));
  856.     sysOutByte (ELC_STA4 (sc->elcAddr), sysInByte (BIC_LAR4 (sc->bicAddr)));
  857.     sysOutByte (ELC_STA5 (sc->elcAddr), sysInByte (BIC_LAR5 (sc->bicAddr)));
  858.     sysOutByte (ELC_MAR0 (sc->elcAddr), 0);
  859.     sysOutByte (ELC_MAR1 (sc->elcAddr), 0);
  860.     sysOutByte (ELC_MAR2 (sc->elcAddr), 0);
  861.     sysOutByte (ELC_MAR3 (sc->elcAddr), 0);
  862.     sysOutByte (ELC_MAR4 (sc->elcAddr), 0);
  863.     sysOutByte (ELC_MAR5 (sc->elcAddr), 0);
  864.     sysOutByte (ELC_MAR6 (sc->elcAddr), 0);
  865.     sysOutByte (ELC_MAR7 (sc->elcAddr), 0);
  866.     sc->next = SMC8013WC_PSTART + 1;
  867.     sysOutByte (ELC_CURR (sc->elcAddr), sc->next);
  869.     sysOutByte (ELC_CMD (sc->elcAddr), CMD_PS1 | CMD_STP);
  870.     sysOutByte (ELC_ENH (sc->elcAddr), 0x00); /* 0 wait states */
  871.     sysOutByte (ELC_BLOCK (sc->elcAddr), 0x00); /* 0x00xxxx */
  873.     /* 10. put the ELC in START mode */
  875.     sysOutByte (ELC_CMD (sc->elcAddr), CMD_STA);
  877.     /* 11. initialize Transmit Configuration Register */
  879.     sysOutByte (ELC_TCON (sc->elcAddr), 0x00);
  881.     }
  883. /*******************************************************************************
  884. *
  885. * elcGetAddr - get hardwired ethernet address.
  886. *
  887. * Read the ethernet address off the board, one byte at a time.
  888. *
  889. */
  891. LOCAL void elcGetAddr 
  892.     (
  893.     int unit 
  894.     )
  895.     {
  896.     FAST ELC_SOFTC *sc          = &elc_softc[unit];
  897.     UCHAR *pAddr = (UCHAR *)sc->es_enaddr;
  899.     *pAddr++ = sysInByte (BIC_LAR0 (sc->bicAddr));
  900.     *pAddr++ = sysInByte (BIC_LAR1 (sc->bicAddr));
  901.     *pAddr++ = sysInByte (BIC_LAR2 (sc->bicAddr));
  902.     *pAddr++ = sysInByte (BIC_LAR3 (sc->bicAddr));
  903.     *pAddr++ = sysInByte (BIC_LAR4 (sc->bicAddr));
  904.     *pAddr   = sysInByte (BIC_LAR5 (sc->bicAddr));
  905.     }
  907. /*******************************************************************************
  908. *
  909. * elcGetCurr - get current page
  910. *
  911. * RETURNS: current page that ELC is working on
  912. *
  913. * NOMANUAL
  914. */
  916. LOCAL UCHAR elcGetCurr 
  917.     (
  918.     int unit
  919.     )
  920.     {
  921.     FAST ELC_SOFTC *sc          = &elc_softc[unit];
  922.     UCHAR curr;
  924.     /* get CURR register */
  926.     sysOutByte (ELC_CMD (sc->elcAddr), CMD_PS0);
  927.     curr = sysInByte (ELC_CURR (sc->elcAddr));
  928.     sysOutByte (ELC_CMD (sc->elcAddr), 0);
  930.     return (curr);
  931.     }
  933. /*******************************************************************************
  934. *
  935. * elcShow - display statistics for the SMC 8013WC `elc' network interface
  936. *
  937. * This routine displays statistics about the `elc' Ethernet network interface.
  938. * It has two parameters: 
  939. * .iP <unit>
  940. * interface unit; should be 0.
  941. * .iP <zap>
  942. * if 1, all collected statistics are cleared to zero.
  943. * .LP
  944. *
  945. * RETURNS: N/A
  946. */
  948. void elcShow 
  949.     (
  950.     int unit,   /* interface unit */
  951.     BOOL zap    /* 1 = zero totals */
  952.     )
  953.     {
  954.     FAST ELC_SOFTC *sc          = &elc_softc[unit];
  955.     FAST int ix;
  956.     static char *e_message [] = {
  957. "collisions",
  958. "crcs",
  959. "aligns",
  960. "missed",
  961. "over-runs",
  962. "disabled",
  963. "deferring",
  964. "under-run",
  965. "aborts",
  966. "out-of-window",
  967. "heart-beats",
  968. "bad-packet",
  969. "short-packet",
  970. "t-no-error",
  971. "r-no-error",
  972. "t-error",
  973. "r-error",
  974. "over-write",
  975. "wrapped",
  976. "interrupts",
  977. "reset",
  978. "stray-int"};
  980.     for (ix = 0; ix < NELEMENTS(e_message); ix++)
  981. {
  982. printf ("    %-30.30s  %4dn", e_message [ix], sc->elcStat.stat [ix]);
  983. if (zap)
  984.     sc->elcStat.stat [ix] = 0;
  985. }
  986.     printf ("    %-30.30s  0x%2xn", "flags", sc->flags);
  987.     }
  989. /*******************************************************************************
  990. *
  991. * elcdetach - detach the card from the bus.
  992. *
  993. * Dettach the card from the bus for reset.
  994. *
  995. * RETURNS: N/A
  996. *
  997. * NOMANUAL
  998. */
  1000. void elcdetach 
  1001.     (
  1002.     int unit
  1003.     )
  1004.     {
  1005.     FAST ELC_SOFTC *sc = &elc_softc[unit];
  1007.     if (elcAttached)
  1008. {
  1009.         sysOutByte (ELC_INTMASK (sc->elcAddr), 0x00);
  1010.         sysOutByte (ELC_CMD (sc->elcAddr), CMD_CMD5 | CMD_STP);
  1011.         while ((sysInByte (ELC_INTSTAT (sc->elcAddr)) & ISTAT_RST) != ISTAT_RST)
  1012.     ;
  1013.         sysOutByte (ELC_RCON (sc->elcAddr), 0x00);
  1014.         sysOutByte (ELC_TCON (sc->elcAddr), TCON_LB1);
  1015.         sysIntDisablePIC (sc->intLevel);
  1016.         sysOutByte (BIC_MSR (sc->bicAddr), MSR_RST);
  1017.         taskDelay (sysClkRateGet () >> 1);
  1018.         sysOutByte (BIC_MSR (sc->bicAddr), 0x00);
  1019.         taskDelay (sysClkRateGet () >> 1);
  1020. }
  1021.     }