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

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

VxWorks

开发平台：

C/C++

if_ultra.c：源码内容
  1. /* if_ultra.c - SMC Elite Ultra Ethernet network interface driver */
  3. /* Copyright 1984-1999 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01u,11jan99,aeg  fixed multiple semaphore inits in ultraattach ().
  10. 01t,29jun98,dat  SPR 21211. fixes to Interrupt loop. 
  11. 01s,11jun98,hdn  fixed typo in ultraIntr().
  12. 01r,22apr98,hdn  set FINE16 bit in ultraInit(). 
  13.  added a loop to ack pending interrupts in untraIntr().
  14. 01q,15jul97,spm  removed driver initialization from ioctl support (SPR #8831)
  15. 01p,15may97,spm  reverted to bcopy routines for mbufs in BSD 4.4
  16. 01o,07apr97,spm  code cleanup and corrected counter for incoming packets
  17. 01n,17mar97,spm  upgraded to BSD 4.4 and corrected statistics counters.
  18. 01m,14jun95,hdn  removed function declarations defined in sysLib.h.
  19. 01l,01feb95,jdi  doc cleanup.
  20. 01k,29nov94,hdn  added a semaphore in ultraPut().
  21. 01j,12nov94,tmk  removed some IMPORTed function decs and included unixLib.h
  22. 01i,30sep94,hdn  implemented two transmit buffers.
  23.  enabled getting GPOUT and ZWSEN bit of GCR in EEROM.
  24.  deleted while loop in ultraPut().
  25. 01h,29nov93,hdn  disabled the interrupt in ultraPut().
  26.  removed netJobAdd (ultraPut, ..) in ultraIntr().
  27. 01g,28nov93,hdn  changed NULTRA to 1.
  28. 01f,23nov93,hdn  removed cacheInvalidate(). 
  29.  added checking TXP bit before the transmission. 
  30. 01e,22nov93,hdn  added elcdetach () for the warm start.
  31. 01d,15nov93,hdn  added support for Thin Ethernet(10Base2, BNC)
  32. 01c,05nov93,hdn  added cacheFlush() and cacheInvalidate().
  33. 01b,04nov93,hdn  cleaned up.
  34. 01a,30oct93,hdn  written.
  35. */
  37. /*
  38. DESCRIPTION
  39. This module implements the SMC Elite Ultra Ethernet network interface driver.
  41. This driver supports single transmission and multiple reception.  The
  42. Current register is a write pointer to the ring.  The Bound register is a
  43. read pointer from the ring.  This driver gets the Current register at the
  44. interrupt level and sets the Bound register at the task level.  The
  45. interrupt is never masked at the task level.
  47. CONFIGURATION
  48. The W1 jumper should be set in the position of "Software Configuration".
  49. The defined I/O address in config.h must match the one stored in EEROM. 
  50. The RAM address, the RAM size, and the IRQ level are defined in config.h. 
  51. IRQ levels 2,3,5,7,10,11,15 are supported.
  53. EXTERNAL INTERFACE
  54. The only user-callable routines are ultraattach() and ultraShow():
  55. .iP ultraattach() 14
  56. publishes the `ultra' interface and initializes the driver and device.
  57. .iP ultraShow()
  58. displays statistics that are collected in the interrupt handler.
  59. .LP
  60. */
  62. #include "vxWorks.h"
  63. #include "net/mbuf.h"
  64. #include "net/protosw.h"
  65. #include "net/unixLib.h"
  66. #include "ioctl.h"
  67. #include "socket.h"
  68. #include "errnoLib.h"
  69. #include "net/uio.h"
  70. #include "net/if.h"
  71. #include "net/route.h"
  72. #include "netinet/in.h"
  73. #include "netinet/in_systm.h"
  74. #include "netinet/ip.h"
  75. #include "netinet/ip_var.h"
  76. #include "netinet/in_var.h"
  77. #include "netinet/if_ether.h"
  78. #include "etherLib.h"
  79. #include "vme.h"
  80. #include "iv.h"
  81. #include "iosLib.h"
  82. #include "ioLib.h"
  83. #include "memLib.h"
  84. #include "net/systm.h"
  85. #include "net/if_subr.h"
  86. #include "sysLib.h"
  87. #include "vxLib.h"
  88. #include "stdio.h"
  89. #include "intLib.h"
  90. #include "logLib.h"
  91. #include "string.h"
  92. #include "netLib.h"
  93. #include "stdlib.h"
  94. #include "semLib.h"
  95. #include "cacheLib.h"
  96. #include "drv/netif/if_ultra.h"
  98. /* defines */
  100. #define NULTRA 1 /* max number of ULTRA controllers */
  102. /* typedefs */
  104. typedef struct ifnet IFNET;                 /* real Interface Data Record */
  106. /* globals */
  109. /* locals */
  111. LOCAL ULTRA_SOFTC ultra_softc [NULTRA];
  112. LOCAL IRQ_TABLE irqTable [] = 
  113.     {
  114.     { 2, 0x15},    { 2, 0x15},    { 2, 0x15},    { 3, 0x19},
  115.     { 3, 0x19},    { 5, 0x1d},    { 5, 0x1d},    { 7, 0x51},
  116.     { 7, 0x51},    { 7, 0x51},    {10, 0x55},    {11, 0x59},
  117.     {11, 0x59},    {11, 0x59},    {11, 0x59},    {15, 0x5d}
  118.     };
  119. LOCAL BOOL ultraAttached = FALSE;
  120. LOCAL SEMAPHORE  ultraSyncSem;           /* syncronization semaphore */
  123. /* forward static functions */
  125.        void ultraShow (int unit, BOOL zap);
  126.        void ultradetach (int unit);
  127. LOCAL  int  ultrainit (int unit);
  128. LOCAL  void ultrareset (int unit);
  129. LOCAL  int  ultraioctl (struct ifnet *ifp, int cmd, caddr_t data);
  130. #ifdef BSD43_DRIVER
  131. LOCAL  int  ultraoutput (struct ifnet *ifp, struct mbuf *m0, struct sockaddr
  132.  *dst);
  133. #endif
  134. LOCAL  void ultraInit (int unit);
  135. LOCAL  void ultraIntr (int unit);
  136. LOCAL  void ultraGet (int unit);
  137. #ifdef BSD43_DRIVER
  138. LOCAL  void ultraPut (int unit);
  139. #else
  140. LOCAL  void ultraPut  (ULTRA_SOFTC *sc);
  141. #endif
  143. /*******************************************************************************
  144. *
  145. * ultraattach - publish `ultra' interface and initialize device
  146. *
  147. * This routine attaches an `ultra' Ethernet interface to the network if the
  148. * device exists.  It makes the interface available by filling in the network
  149. * interface record.  The system will initialize the interface when it is ready
  150. * to accept packets.
  151. *
  152. * RETURNS: OK or ERROR.
  153. *
  154. * SEE ALSO: ifLib, netShow
  155. */
  157. STATUS ultraattach 
  158.     (
  159.     int unit,           /* unit number */
  160.     int ioAddr,         /* address of ultra's shared memory */
  161.     int ivec,           /* interrupt vector to connect to */
  162.     int ilevel,         /* interrupt level */
  163.     int memAddr,        /* address of ultra's shared memory */
  164.     int memSize,        /* size of ultra's shared memory */
  165.     int config /* 0: RJ45 + AUI(Thick)  1: RJ45 + BNC(Thin) */
  166.     )
  167.     {
  168.     FAST ULTRA_SOFTC *sc = &ultra_softc[unit];
  170.     if ((UINT)unit >= NULTRA)
  171. {
  172.         errnoSet (S_iosLib_CONTROLLER_NOT_PRESENT);
  173. return (ERROR);
  174. }
  176.     sc->ioAddr = ioAddr;
  177.     sc->memAddr = memAddr;
  178.     sc->memSize = memSize;
  179.     sc->intLevel = irqTable[ilevel].irq;
  180.     sc->intVec = ivec;
  181.     sc->config = config;
  182.     sc->transmitPage[0] = ULTRA_TSTART0;
  183.     sc->transmitPage[1] = ULTRA_TSTART1;
  184.     sc->transmitCnt = 0;
  186.     /* synchronization semaphore must be initialized only once */
  188.     if (!ultraAttached)
  189. semBInit (&ultraSyncSem, SEM_Q_FIFO, SEM_FULL);
  191.     (void) intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (ivec), 
  192.        (VOIDFUNCPTR)ultraIntr, unit);
  194. #ifdef BSD43_DRIVER
  195.     ether_attach (&sc->es_if, unit, "ultra", (FUNCPTR)ultrainit, 
  196.   (FUNCPTR)ultraioctl, (FUNCPTR)ultraoutput, (FUNCPTR)ultrareset);
  197. #else
  198.     ether_attach (
  199.                  (IFNET *) & sc->es_ac,
  200.                  unit,
  201.                  "ultra",
  202.                  (FUNCPTR) ultrainit,
  203.                  (FUNCPTR) ultraioctl,
  204.                  (FUNCPTR) ether_output,    /* generic ether_output */ 
  205.                  (FUNCPTR) ultrareset
  206.                  );
  207.     sc->es_if.if_start = (FUNCPTR) ultraPut;
  208. #endif 
  210.     ultrainit (unit);
  212.     ultraAttached = TRUE;
  214.     return (OK);
  215.     }
  217. /*******************************************************************************
  218. *
  219. * ultrareset - reset the interface
  220. *
  221. * RETURNS: N/A
  222. */
  224. LOCAL void ultrareset 
  225.     (
  226.     int unit  /* device unit number */
  227.     )
  228.     {
  229.     FAST ULTRA_SOFTC *sc   = &ultra_softc [unit];
  230.     int s = splnet ();
  232.     sc->stat.reset++;
  233.     sysIntDisablePIC (sc->intLevel);
  234.     sc->es_if.if_flags = 0;
  236.     splx (s);
  237.     }
  239. /*******************************************************************************
  240. *
  241. * ultrainit - initialize ultra
  242. *
  243. * Restart the link level software on the board and mark the interface up.
  244. *
  245. * RETURNS: 0
  246. */
  248. LOCAL int ultrainit 
  249.     (
  250.     int unit  /* device unit number */
  251.     )
  252.     {
  253.     FAST ULTRA_SOFTC *sc = &ultra_softc[unit];
  254.     int s = splnet ();
  256.     ultraInit (unit);
  257.     sysIntEnablePIC (sc->intLevel);
  258.     sc->es_if.if_flags |= IFF_UP|IFF_RUNNING; /* open for business*/
  260.     splx (s);
  261.     return (0);
  262.     }
  264. #ifdef BSD43_DRIVER
  265. /*******************************************************************************
  266. *
  267. * ultraoutput - ethernet output routine
  268. *
  269. * Encapsulate a packet of type family for the local net.
  270. * Use trailer local net encapsulation if enough data in first
  271. * packet leaves a multiple of 512 bytes of data in remainder.
  272. * If destination is this address or broadcast, send packet to
  273. * loop device to kludge around the fact that 3com interfaces can't
  274. * talk to themselves.
  275. *
  276. * RETURNS:  OK if successful, otherwise errno.
  277. */
  279. LOCAL int ultraoutput 
  280.     (
  281.     struct ifnet *ifp, /* device structure */
  282.     struct mbuf *m0, /* mbuf containing packet */
  283.     struct sockaddr *dst  /* destination address */
  284.     )
  285.     {
  286.     return (ether_output (ifp, m0, dst, (FUNCPTR)ultraPut,
  287.   &ultra_softc [ifp->if_unit].es_ac));
  288.     }
  289. #endif
  291. /*******************************************************************************
  292. *
  293. * ultraioctl - ioctl for interface
  294. *
  295. * RETURNS: OK if successful, otherwise errno.
  296. */
  298. LOCAL int ultraioctl 
  299.     (
  300.     FAST struct ifnet *ifp, /* device structure */
  301.     int cmd, /* ioctl cmd code */
  302.     caddr_t data  /* ioctl argument */
  303.     )
  304.     {
  305.     int status = OK;
  306.     int s = splimp();
  307.     short flags;
  309.     switch (cmd)
  310. {
  311. case SIOCSIFADDR:
  312.             ((struct arpcom *)ifp)->ac_ipaddr = IA_SIN (data)->sin_addr;
  313.             arpwhohas ((struct arpcom *)ifp, &IA_SIN (data)->sin_addr);
  314.     break;
  316. case SIOCSIFFLAGS:
  317.             flags = ifp->if_flags;
  319.     if (ifp->if_flags & IFF_UP)
  320.                 ifp->if_flags = flags | (IFF_UP | IFF_RUNNING);
  321.             else
  322.                 ifp->if_flags = flags & ~(IFF_UP|IFF_RUNNING);
  323.     break;
  325. default:
  326.     status = EINVAL;
  327. }
  329.     splx (s);
  330.     return (status);
  331.     }
  333. /*******************************************************************************
  334. *
  335. * ultraIntr - Ethernet interface interrupt
  336. *
  337. * Hand off reading of packets from the interface to task level.
  338. *
  339. * RETURNS: N/A
  340. */
  342. LOCAL void ultraIntr 
  343.     (
  344.     int unit  /* device unit number */
  345.     )
  346.     {
  347.     FAST ULTRA_SOFTC *sc = &ultra_softc[unit];
  348.     UCHAR istat;
  349.     int   nCnt = 0;
  351.     /* Acknowledge interrupt, get Transmit/Receive status */
  353.     sc->istat = 0;
  354.     do  {
  355.         istat = sysInByte (LAN_INTSTAT (sc->ioAddr));
  356.         sysOutByte (LAN_INTSTAT (sc->ioAddr), istat);
  357.         sc->istat |= istat;
  358.         nCnt ++;
  359.         }
  360.     while (istat != 0);
  361.     sc->tstat = sysInByte (LAN_TSTAT (sc->ioAddr));
  362.     sc->rstat = sysInByte (LAN_RSTAT (sc->ioAddr));
  364.     /* get xxxCount Reg that is cleared after read access */
  366.     sc->stat.interrupts++;
  367.     sc->stat.collisions += sysInByte (LAN_COLCNT (sc->ioAddr));
  368.     sc->stat.aligns += sysInByte (LAN_ALICNT (sc->ioAddr));
  369.     sc->stat.crcs += sysInByte (LAN_CRCCNT (sc->ioAddr));
  370.     sc->stat.missed += sysInByte (LAN_MPCNT (sc->ioAddr));
  372.     if (sc->istat & ISTAT_RXE) /* Receive-error */
  373. {
  374.         sc->es_if.if_ierrors++;
  375. sc->stat.rerror++;
  376. if (sc->rstat & RSTAT_OVER)
  377.     sc->stat.overruns++;
  378. if (sc->rstat & RSTAT_DIS)
  379.     sc->stat.disabled++;
  380. if (sc->rstat & RSTAT_DFR)
  381.     sc->stat.deferring++;
  382. }
  383.     if (sc->istat & (ISTAT_PRX | ISTAT_OVW)) /* Receive, Overwrite */
  384. {
  385.         if (sc->istat & ISTAT_OVW)
  386.             {
  387.     sc->stat.overwrite++;
  388.             sc->es_if.if_ierrors++;
  389.             }
  390.         sysOutByte (LAN_CMD (sc->ioAddr), CMD_PS0);
  391.         sc->current = sysInByte (LAN_CURR (sc->ioAddr));
  392.         sysOutByte (LAN_CMD (sc->ioAddr), 0);
  393. if ((sc->flags & RXING) == 0)
  394.     {
  395.             sc->flags |= RXING;
  396.     (void) netJobAdd ((FUNCPTR)ultraGet, unit, 0,0,0,0);
  397.     }
  398. if (sc->rstat & RSTAT_PRX)
  399.     sc->stat.rnoerror++;
  400. }
  401.     if (sc->istat & (ISTAT_TXE | ISTAT_PTX)) /* Transmit-error, Transmit */
  402. {
  403. semGive (&ultraSyncSem);
  405. #if FALSE  /* BEGIN TEST CODE */
  406. if (sc->es_if.if_snd.ifq_head != NULL)
  407.     {
  408. #ifdef BSD43_DRIVER
  409.     netJobAdd ((FUNCPTR) ultraPut, unit, 0,0,0,0);
  410. #else
  411.     netJobAdd ((FUNCPTR) ultraPut, (int)sc, 0,0,0,0);
  412. #endif
  413.     }
  414. #endif /* END TEST CODE */
  416.         if (sc->istat & ISTAT_TXE)
  417.             {
  418.     sc->stat.terror++;
  419.             sc->es_if.if_oerrors++;
  420.             sc->es_if.if_opackets--;
  421.             }
  422. if (sc->tstat & TSTAT_ABORT)
  423.     {
  424.     sc->stat.aborts++;
  425.     sc->stat.collisions += 16;
  426.     }
  427. if (sc->tstat & TSTAT_UNDER)
  428.     sc->stat.underruns++;
  429. if (sc->tstat & TSTAT_CDH)
  430.     sc->stat.heartbeats++;
  431. if (sc->tstat & TSTAT_OWC)
  432.     sc->stat.outofwindow++;
  433. if (sc->tstat & TSTAT_PTX)
  434.     sc->stat.tnoerror++;
  435. }
  436.     }
  438. /*******************************************************************************
  439. *
  440. * ultraGet - read a packet off the interface
  441. *
  442. * Copy packets from a RING into an mbuf and hand it to the next higher layer.
  443. *
  444. * RETURNS: N/A
  445. */
  447. LOCAL void ultraGet 
  448.     (
  449.     int unit /* device unit number */
  450.     )
  451.     {
  452.     FAST ULTRA_SOFTC *sc = &ultra_softc[unit];
  453.     FAST ULTRA_HEADER *pH;
  454.     FAST struct ether_header *eh;
  455.     FAST struct mbuf *m;
  456.     int len;
  457. #ifdef BSD43_DRIVER
  458.     int off;
  459. #endif
  460.     int ix;
  461.     USHORT wrapSize;
  462.     USHORT packetSize;
  463.     char *pSrc;
  464.     char *pDst;
  465.     UCHAR *pData;
  468. unlucky:
  469.     ix = 0;
  471.     while ((sc->next != sc->current) && (ix++ < ULTRA_PSTOP))
  472. {
  473. /* Invalidate cache */
  474.         cacheDrvInvalidate (&cacheDmaFuncs, 
  475.             (UCHAR *)(sc->memAddr + (ULTRA_PSTART << 8)),
  476.             (sc->memSize - (ULTRA_PSTART << 8)));
  478. pH = (ULTRA_HEADER *)(sc->memAddr + (sc->next << 8));
  480. /* sanity check */
  482. if ((pH->next < ULTRA_PSTART) || (pH->next >= ULTRA_PSTOP))
  483.     {
  484.     sc->stat.badPacket++;
  485.     pH->next = sc->next + sc->uppByteCnt + 1;
  486.     if (pH->next >= ULTRA_PSTOP)
  487. pH->next = ULTRA_PSTART + (pH->next - ULTRA_PSTOP);
  488.     }
  490. packetSize = *(USHORT *)(&pH->lowByteCnt);
  491. if (packetSize < (ULTRA_MIN_SIZE))
  492.     {
  493.     sc->stat.shortPacket++;
  494.     goto doneGet;
  495.     }
  496. if (packetSize > (ULTRA_MAX_SIZE))
  497.     {
  498.     sc->stat.longPacket++;
  499.     goto doneGet;
  500.     }
  502.         sc->es_if.if_ipackets++;        /* bump statistic */
  504. if (pH->next > sc->next)
  505.     wrapSize = 0;
  506. else
  507.     wrapSize = min (packetSize, ((ULTRA_PSTOP - sc->next) << 8));
  509. /* copy separated frame to a temporary buffer */
  511. if (wrapSize)
  512.     {
  513.     sc->stat.wrapped++;
  514.     pSrc = (char *)pH;
  515.     pDst = (char *)sc->receiveBuf;
  516.     bcopy (pSrc, pDst, wrapSize);
  517.     pSrc = (char *)(sc->memAddr + (ULTRA_PSTART << 8));
  518.     pDst += wrapSize;
  519.     len = packetSize - wrapSize;
  520.     if (len)
  521. bcopy (pSrc, pDst, len);
  522.     }
  524.         len = packetSize - 4; /* remove CRCs 4 bytes */
  526.         if (wrapSize)
  527.     eh = (struct ether_header *)((UINT)sc->receiveBuf + 
  528. sizeof (ULTRA_HEADER));
  529.         else
  530.     eh = (struct ether_header *)((UINT)pH + sizeof (ULTRA_HEADER));
  532.         /* call input hook if any */
  534.         if ((etherInputHookRtn != NULL) &&
  535.     (* etherInputHookRtn) (&sc->es_if, (char *) eh, len))
  536.     {
  537.     goto doneGet;
  538.     }
  540.         if (len >= SIZEOF_ETHERHEADER)
  541.             len -= SIZEOF_ETHERHEADER;
  542.         else
  543.     goto doneGet;
  545.         pData = ((unsigned char *) eh) + SIZEOF_ETHERHEADER;
  547. #ifdef BSD43_DRIVER
  548.         check_trailer (eh, pData, &len, &off, &sc->es_if);
  550.         /* copy data from the ring buffer to mbuf a long-word at a time */
  552.         m = bcopy_to_mbufs (pData, len, off, (struct ifnet *) &sc->es_if, 2);
  554.         if (m == NULL)
  555.             {
  556.             sc->es_if.if_ierrors++;         /* bump error statistic */
  557.     goto doneGet;
  558.             }
  560.         do_protocol_with_type (eh->ether_type, m, &sc->es_ac, len);
  561. #else
  563.         /* copy data from the ring buffer to mbuf a long-word at a time */
  565.         m = bcopy_to_mbufs (pData, len, 0, (struct ifnet *) &sc->es_if, 2);
  567.         if (m == NULL)
  568.             {
  569.             sc->es_if.if_ierrors++;         /* bump error statistic */
  570.     goto doneGet;
  571.             }
  573.         do_protocol (eh, m, &sc->es_ac, len);
  575. #endif
  577. doneGet:
  578. sc->next = pH->next;
  579. sc->uppByteCnt = pH->uppByteCnt;
  580. }
  582.     /* update BOUND Register */
  584.     if ((sc->next < ULTRA_PSTART) || (sc->next >= ULTRA_PSTOP))
  585. sysOutByte (LAN_BOUND (sc->ioAddr), ULTRA_PSTART);
  586.     else
  587. sysOutByte (LAN_BOUND (sc->ioAddr), sc->next);
  589.     sc->flags &= ~RXING;
  591.     /* go back if we received an interrupt and a new packet */
  593.     if (sc->next != sc->current)
  594. goto unlucky;
  595.     }
  597. /*******************************************************************************
  598. *
  599. * ultraPut - copy a packet to the interface.
  600. *
  601. * Copy from mbuf chain to transmitter buffer in shared memory.
  602. *
  603. * RETURNS: N/A
  604. */
  606. #ifdef BSD43_DRIVER
  607. LOCAL void ultraPut 
  608.     (
  609.     int unit /* device unit number */
  610.     )
  611.     {
  612.     FAST ULTRA_SOFTC *sc   = &ultra_softc [unit];
  613. #else
  614. LOCAL void ultraPut
  615.     (
  616.     ULTRA_SOFTC *sc /* device context */
  617.     )
  618.     {
  619. #endif
  620.     FAST struct mbuf *m;
  621.     FAST int len;
  622.     UINT transmitPage = sc->transmitPage[sc->transmitCnt & 1];
  623.     UCHAR *pBuf = (UCHAR *)(sc->memAddr + (transmitPage << 8));
  624. #ifdef BSD43_DRIVER
  625.     int s = splnet ();
  626. #endif
  628.     while (sc->es_if.if_snd.ifq_head != NULL)
  629. {
  630. semTake (&ultraSyncSem, sysClkRateGet ());
  632. IF_DEQUEUE (&sc->es_if.if_snd, m);
  634. if (m != NULL)
  635.     {
  636.     copy_from_mbufs (pBuf, m, len);
  637.     len = max (ETHERSMALL, len);
  639.     cacheDrvFlush (&cacheDmaFuncs, pBuf, len);
  641.     /* call output hook if any */
  643.     if ((etherOutputHookRtn != NULL) &&
  644. (* etherOutputHookRtn) (&sc->es_if, pBuf, len))
  645. continue;
  647.     /* kick Transmitter */
  649.     sysOutByte (LAN_INTMASK (sc->ioAddr), 0x00);
  650.     sysOutByte (LAN_TSTART (sc->ioAddr), transmitPage);
  651.     sysOutByte (LAN_TCNTH (sc->ioAddr), len >> 8);
  652.     sysOutByte (LAN_TCNTL (sc->ioAddr), len & 0xff);
  653.     sysOutByte (LAN_CMD (sc->ioAddr), CMD_TXP);
  654.     sc->transmitCnt++;
  655.     sysOutByte (LAN_INTMASK (sc->ioAddr), 
  656. IM_OVWE | IM_TXEE | IM_PTXE | IM_PRXE);
  657. #ifndef BSD43_DRIVER
  658.     sc->es_if.if_opackets++;
  659. #endif
  660.     }
  661. }
  663. #ifdef BSD43_DRIVER
  664.     splx (s);
  665. #endif
  666.     }
  668. /*******************************************************************************
  669. *
  670. * ultraInit - initialize Elite Ultra (Ethernet LAN Controller)
  671. *
  672. * RETURNS: N/A
  673. */
  675. LOCAL void ultraInit 
  676.     (
  677.     int unit /* device unit number */
  678.     )
  679.     {
  680.     FAST ULTRA_SOFTC *sc = &ultra_softc[unit];
  681.     UCHAR *pAddr  = (UCHAR *)sc->es_enaddr;
  682.     UCHAR memAddr;
  683.     UCHAR intLevel;
  684.     UCHAR ioAddr;
  685.     UCHAR eeromGcon;
  687.     /* mask interrupt */
  689.     sysOutByte (LAN_INTMASK (sc->ioAddr), 0x00);
  691.     /* reset */
  693.     sysOutByte (CTRL_CON (sc->ioAddr), CON_RESET);
  694.     sysOutByte (CTRL_CON (sc->ioAddr), 0x00);
  695.     sysOutByte (CTRL_HARD (sc->ioAddr), 0x08);
  696.     taskDelay (sysClkRateGet () >> 2);
  697.     sysOutByte (CTRL_CON (sc->ioAddr), CON_MENABLE);
  699.     /* get values set by EEROM */
  701.     sysOutByte (CTRL_HARD (sc->ioAddr), 0x80);
  702.     eeromGcon = sysInByte (CTRL_GCON(sc->ioAddr));
  704.     /* IO address, Memory address, Interrupt request */
  706.     memAddr = ((sc->memAddr & 0x1e000) >> 13) | ((sc->memAddr & 0x20000) >> 10);
  707.     intLevel = ((sc->intLevel & 0x03) << 2) | ((sc->intLevel & 0x04) << 6);
  708.     ioAddr = ((sc->ioAddr & 0xe000) >> 8) | ((sc->ioAddr & 0x01e0) >> 4);
  709.     sysOutByte (CTRL_HARD (sc->ioAddr), 0x80);
  710.     sysOutByte (CTRL_IOADDR (sc->ioAddr), ioAddr);
  711.     sysOutByte (CTRL_MEMADDR (sc->ioAddr), memAddr | 0x10);
  712.     if (sc->config == 1)
  713.         sysOutByte (CTRL_GCON (sc->ioAddr), irqTable[sc->intLevel].reg |
  714.     (eeromGcon & 0x20));
  715.     else if (sc->config == 2)
  716.         sysOutByte (CTRL_GCON (sc->ioAddr), irqTable[sc->intLevel].reg | 0x02 |
  717.     (eeromGcon & 0x20));
  718.     else
  719.         sysOutByte (CTRL_GCON (sc->ioAddr), irqTable[sc->intLevel].reg | 
  720.     (eeromGcon & 0x22));
  722.     /* set FINE16 bit in BIO register to get finer resolution for M16CS decode */
  724.     sysOutByte (CTRL_BIO (sc->ioAddr), sysInByte (CTRL_BIO (sc->ioAddr) | 0x80)); 
  725.     sysOutByte (CTRL_HARD (sc->ioAddr), 0x00);
  727.     /* 16 bit enable */
  729.     sysOutByte (CTRL_BIOS (sc->ioAddr), BIOS_M16EN);
  731.     /* program Command Register for page 0 */
  733.     sysOutByte (LAN_CMD (sc->ioAddr), CMD_STP);
  734.     while ((sysInByte (LAN_INTSTAT (sc->ioAddr)) & ISTAT_RST) != ISTAT_RST)
  735. ;
  737.     /* initialize Data Configuration Register */
  739.     sysOutByte (LAN_DCON (sc->ioAddr), DCON_BSIZE1 | DCON_BUS16);
  741.     /* initialize Receive Configuration Register */
  743.     sysOutByte (LAN_RCON (sc->ioAddr), 0x04);
  745.     /* place the Ultra in LOOPBACK mode 1 or 2 */
  747.     sysOutByte (LAN_TCON (sc->ioAddr), TCON_LB1);
  749.     /* initialize Receive Buffer Ring */
  751.     sysOutByte (LAN_RSTART (sc->ioAddr), ULTRA_PSTART);
  752.     sysOutByte (LAN_RSTOP (sc->ioAddr), ULTRA_PSTOP);
  753.     sysOutByte (LAN_BOUND (sc->ioAddr), ULTRA_PSTART);
  755.     /* clear Interrupt Status Register */
  757.     sysOutByte (LAN_INTSTAT (sc->ioAddr), 0xff);
  759.     /* initialize Interrupt Mask Register */
  761.     sysOutByte (LAN_INTMASK (sc->ioAddr), 0x00);
  763.     /* program Command Register for page 1 */
  765.     sysOutByte (LAN_CMD (sc->ioAddr), CMD_PS0 | CMD_STP);
  766.     sysOutByte (LAN_STA0 (sc->ioAddr), sysInByte (CTRL_LAN0 (sc->ioAddr)));
  767.     sysOutByte (LAN_STA1 (sc->ioAddr), sysInByte (CTRL_LAN1 (sc->ioAddr)));
  768.     sysOutByte (LAN_STA2 (sc->ioAddr), sysInByte (CTRL_LAN2 (sc->ioAddr)));
  769.     sysOutByte (LAN_STA3 (sc->ioAddr), sysInByte (CTRL_LAN3 (sc->ioAddr)));
  770.     sysOutByte (LAN_STA4 (sc->ioAddr), sysInByte (CTRL_LAN4 (sc->ioAddr)));
  771.     sysOutByte (LAN_STA5 (sc->ioAddr), sysInByte (CTRL_LAN5 (sc->ioAddr)));
  772.     *pAddr++ = sysInByte (CTRL_LAN0 (sc->ioAddr));
  773.     *pAddr++ = sysInByte (CTRL_LAN1 (sc->ioAddr));
  774.     *pAddr++ = sysInByte (CTRL_LAN2 (sc->ioAddr));
  775.     *pAddr++ = sysInByte (CTRL_LAN3 (sc->ioAddr));
  776.     *pAddr++ = sysInByte (CTRL_LAN4 (sc->ioAddr));
  777.     *pAddr   = sysInByte (CTRL_LAN5 (sc->ioAddr));
  778.     sysOutByte (LAN_MAR0 (sc->ioAddr), 0);
  779.     sysOutByte (LAN_MAR1 (sc->ioAddr), 0);
  780.     sysOutByte (LAN_MAR2 (sc->ioAddr), 0);
  781.     sysOutByte (LAN_MAR3 (sc->ioAddr), 0);
  782.     sysOutByte (LAN_MAR4 (sc->ioAddr), 0);
  783.     sysOutByte (LAN_MAR5 (sc->ioAddr), 0);
  784.     sysOutByte (LAN_MAR6 (sc->ioAddr), 0);
  785.     sysOutByte (LAN_MAR7 (sc->ioAddr), 0);
  786.     sc->next = ULTRA_PSTART + 1;
  787.     sysOutByte (LAN_CURR (sc->ioAddr), sc->next);
  789.     sysOutByte (LAN_CMD (sc->ioAddr), CMD_PS1 | CMD_STP);
  790.     sysOutByte (LAN_ENH (sc->ioAddr), 0x00); /* 0 wait states */
  792.     /* put the Ultra in START mode */
  794.     sysOutByte (LAN_CMD (sc->ioAddr), CMD_STA);
  796.     /* initialize Transmit Configuration Register */
  798.     sysOutByte (LAN_TCON (sc->ioAddr), 0x00);
  800.     /* enable interrupt */
  802.     sysOutByte (CTRL_INT (sc->ioAddr), INT_ENABLE);
  803.     sysOutByte (LAN_INTMASK (sc->ioAddr),
  804. IM_OVWE | IM_TXEE | IM_PTXE | IM_PRXE);
  805.     }
  807. /*******************************************************************************
  808. *
  809. * ultraShow - display statistics for the `ultra' network interface
  810. *
  811. * This routine displays statistics about the `elc' Ethernet network interface.
  812. * It has two parameters:
  813. * .iP <unit>
  814. * interface unit; should be 0.
  815. * .iP <zap>
  816. * if 1, all collected statistics are cleared to zero.
  817. * .LP
  818. *
  819. * RETURNS: N/A
  820. */
  822. void ultraShow 
  823.     (
  824.     int unit,   /* interface unit */
  825.     BOOL zap    /* zero totals */
  826.     )
  827.     {
  828.     FAST ULTRA_SOFTC *sc          = &ultra_softc[unit];
  829.     FAST int ix;
  830.     static char *e_message [] = {
  831. "collisions",
  832. "crcs",
  833. "aligns",
  834. "missed",
  835. "over-runs",
  836. "disabled",
  837. "deferring",
  838. "under-run",
  839. "aborts",
  840. "out-of-window",
  841. "heart-beats",
  842. "bad-packet",
  843. "short-packet",
  844. "long-packet",
  845. "t-no-error",
  846. "r-no-error",
  847. "t-error",
  848. "r-error",
  849. "over-write",
  850. "wrapped",
  851. "interrupts",
  852. "reset",
  853. "stray-int"};
  855.     printf ("ioAddr=0x%x memAddr=0x%x memSize=0x%x vector=0x%x level=0x%xn",
  856. sc->ioAddr, sc->memAddr, sc->memSize, sc->intVec, sc->intLevel);
  857.     for (ix = 0; ix < NELEMENTS(e_message); ix++)
  858. {
  859. printf ("    %-30.30s  %4dn", e_message [ix], sc->stat.stat [ix]);
  860. if (zap)
  861.     sc->stat.stat [ix] = 0;
  862. }
  863.     printf ("    %-30.30s  0x%2xn", "flags", sc->flags);
  864.     }
  866. /*******************************************************************************
  867. *
  868. * ultradetach - detach the card from the bus.
  869. *
  870. * Dettach the card from the bus for reset.
  871. *
  872. * RETURNS: N/A
  873. *
  874. * NOMANUAL
  875. */
  877. void ultradetach 
  878.     (
  879.     int unit /* device unit number */
  880.     )
  881.     {
  882.     FAST ULTRA_SOFTC *sc = &ultra_softc[unit];
  884.     if (ultraAttached)
  885. {
  886.         sysOutByte (LAN_INTMASK (sc->ioAddr), 0x00);
  887.         sysOutByte (LAN_CMD (sc->ioAddr), CMD_STP);
  888.         while ((sysInByte (LAN_INTSTAT (sc->ioAddr)) & ISTAT_RST) != ISTAT_RST)
  889.     ;
  890.         sysOutByte (LAN_RCON (sc->ioAddr), 0x00);
  891.         sysOutByte (LAN_TCON (sc->ioAddr), TCON_LB1);
  892.         sysIntDisablePIC (sc->intLevel);
  893.         sysOutByte (CTRL_CON (sc->ioAddr), CON_RESET);
  894.         taskDelay (sysClkRateGet () >> 1);
  895.         sysOutByte (CTRL_CON (sc->ioAddr), 0x00);
  896.         taskDelay (sysClkRateGet () >> 1);
  897. }
  898.     }