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

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

VxWorks

开发平台：

C/C++

if_esmc.c：源码内容
  1. /* if_esmc.c - Ampro Ethernet2 SMC-91c9x Ethernet network interface driver */
  3. /* Copyright 1984-1997 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01d,15jul97,spm  removed driver initialization from ioctl support (SPR #8831)
  10. 01c,15may97,spm  reverted to bcopy routines for mbufs in BSD 4.4
  11. 01b,07apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  12. 01a,07may96,hdn  written.
  13. */
  15. /*
  16. DESCRIPTION
  17. This module implements the Ampro Ethernet2 SMC-91c9x Ethernet network
  18. interface driver.
  20. CONFIGURATION
  21. The W3 and W4 jumper should be set for IO address and IRQ.
  22. The defined I/O address and IRQ in config.h must match the one stored
  23. in EEROM and the jumper setting. 
  25. BOARD LAYOUT
  26. The diagram below shows the relevant jumpers for VxWorks configuration.
  28. .bS
  29.         ___________________________________
  30.         |             * * * *             |
  31.         |  ______                         |
  32.         |  |    |                         |
  33.         |  | U1 | W1  W3                  |
  34.         |  |PROM| X   "                   |
  35.         |  |    | .   -                   |
  36.         |  |    |     -                   |
  37.         |  |    |     -                   |
  38.         |  |____|                         |
  39.         |                                 |
  40.         |                W4               |
  41.         |                "                |
  42.         |                "                |
  43.         |                -                |
  44.         |                -                |
  45.         |_________________________________|    
  47.       W1:  Boot PROM Size
  48.       W3:  IO-address, IRQ, Media
  49.       W4:  IRQ Group Selection
  50. .bE
  52. EXTERNAL INTERFACE
  53. The only user-callable routines are esmcattach():
  54. .iP esmcattach() 14
  55. publishes the `esmc' interface and initializes the driver and device.
  56. .LP
  57. The last parameter of esmcattach(), <mode>, is a receive mode.
  58. If it is 0, a packet is received in the interrupt level.  If it is 1,
  59. a packet is received in the task level.  Receiving packets in the interrupt
  60. level requires about 10K bytes of memory, but minimize a risk of dropping 
  61. packets.  Receiving packets in the task level doesn't require extra
  62. memory, but might have a risk of dropping packets.
  64. INTERNAL
  65. A driver implementation for this board faces two conflicting network
  66. interface design goals:  (1) minimizing the time spent at interrupt level,
  67. and (2) servicing the board's input without dropping packets.
  68. Receive overrun affects significantly for the performance.  It depends
  69. on CPU power and network traffic of your hardware and software.
  70. And also it depends on the memory size of the chip, 91cxx series.
  71. Importance of performance penalty for dropping packets by the receive
  72. overrun and time spent at the interrupt level is different for each person.  
  73. So there is a configurable flag to decide a receive mode which is the
  74. last parameter of esmcattach() function.
  76. */
  78. #include "vxWorks.h"
  79. #include "net/mbuf.h"
  80. #include "net/protosw.h"
  81. #include "net/unixLib.h"
  82. #include "ioctl.h"
  83. #include "socket.h"
  84. #include "errnoLib.h"
  85. #include "net/uio.h"
  86. #include "net/if.h"
  87. #include "net/route.h"
  88. #include "netinet/in.h"
  89. #include "netinet/in_systm.h"
  90. #include "netinet/ip.h"
  91. #include "netinet/ip_var.h"
  92. #include "netinet/in_var.h"
  93. #include "netinet/if_ether.h"
  94. #include "etherLib.h"
  95. #include "vme.h"
  96. #include "iv.h"
  97. #include "iosLib.h"
  98. #include "ioLib.h"
  99. #include "memLib.h"
  100. #include "net/systm.h"
  101. #include "net/if_subr.h"
  102. #include "sysLib.h"
  103. #include "vxLib.h"
  104. #include "stdio.h"
  105. #include "intLib.h"
  106. #include "logLib.h"
  107. #include "string.h"
  108. #include "netLib.h"
  109. #include "stdlib.h"
  110. #include "semLib.h"
  111. #include "cacheLib.h"
  112. #include "tickLib.h"
  113. #include "drv/netif/if_esmc.h"
  115. #undef ESMC_DEBUG    /* define to include debug messages */
  117. #define NESMC 2 /* max number of ESMC controllers */
  118. #define ESMC_SHOW TRUE /* show routine */
  119. #define ESMC_USE_LONG TRUE /* use long word IO access */
  120. #define ATTACHMENT_DEFAULT      0       /* use card as configured */
  121. #define ATTACHMENT_AUI          1       /* AUI  (thick, DIX, DB-15) */
  122. #define ATTACHMENT_BNC          2       /* BNC  (thin, 10BASE-2) */
  123. #define ATTACHMENT_RJ45         3       /* RJ-45 (twisted pair, TPE, 10BASE-T)*/
  124. #define RX_MODE_INTERRUPT 0 /* receive in interrupt level */
  125. #define RX_MODE_TASK 1 /* receive in task level */
  128. /* globals */
  131. /* locals */
  133. LOCAL ESMC_SOFTC esmc_softc [NESMC];
  134. LOCAL char * pName[12] =
  135.     {
  136.     NULL,       NULL,       NULL, "SMC91C90/91C92",
  137.     "SMC91C94", "SMC91C95", NULL, "SMC91C100", 
  138.     NULL,       NULL,       NULL, NULL
  139.     };  
  142. /* forward static functions */
  144. LOCAL int    esmcInit (int unit);
  145. LOCAL void   esmcReset (int unit);
  146. LOCAL int    esmcIoctl (struct ifnet *ifp, int cmd, caddr_t data);
  147. #ifdef BSD43_DRIVER
  148. LOCAL int    esmcOutput (struct ifnet *ifp, struct mbuf *m0, 
  149.  struct sockaddr *dst);
  150. #endif
  151. LOCAL void   esmcIntr (int unit);
  152. LOCAL void   esmcGet (int unit);
  153. LOCAL void   esmcGetInt (int unit);
  154. LOCAL void   esmcGetTask (int unit);
  155. #ifdef BSD43_DRIVER
  156. LOCAL void   esmcPut (int unit);
  157. #else
  158. LOCAL void   esmcPut (ESMC_SOFTC *sc);
  159. #endif
  160. LOCAL STATUS esmcChipInit (int unit);
  161. LOCAL void   esmcChipReset (int unit);
  164. /*******************************************************************************
  165. *
  166. * esmcattach - publish the `esmc' network interface and initialize the driver.
  167. *
  168. * This routine attaches an `esmc' Ethernet interface to the network if the
  169. * device exists.  It makes the interface available by filling in the network
  170. * interface record.  The system will initialize the interface when it is ready
  171. * to accept packets.
  172. *
  173. * RETURNS: OK or ERROR.
  174. *
  175. * SEE ALSO: ifLib, netShow
  176. */
  178. STATUS esmcattach 
  179.     (
  180.     int unit,           /* unit number */
  181.     int ioAddr,         /* address of esmc's shared memory */
  182.     int intVec,         /* interrupt vector to connect to */
  183.     int intLevel,       /* interrupt level */
  184.     int config, /* 0: Autodetect  1: AUI  2: BNC  3: RJ45 */
  185.     int mode /* 0: rx in interrupt   1: rx in task(netTask) */
  186.     )
  187.     {
  188.     FAST ESMC_SOFTC *sc = &esmc_softc[unit];
  190.     if ((UINT)unit >= NESMC)
  191. {
  192.         errnoSet (S_iosLib_CONTROLLER_NOT_PRESENT);
  193. return (ERROR);
  194. }
  196.     sc->ioAddr = ioAddr;
  197.     sc->intVec = intVec;
  198.     sc->intLevel = intLevel;
  199.     sc->config = config;
  200.     sc->flags = 0;
  201.     sc->mode = mode;
  202.     sc->pBuft = (char *)(((u_int)sc->buft + 3) & ~0x03);
  204.     if (sc->mode == RX_MODE_INTERRUPT) /* RX int */
  205. {
  206.         sc->bufi = malloc (ESMC_BUFSIZE_INT + 8);
  207.         sc->pBufi = (char *)(((u_int)sc->bufi + 3) & ~0x03);
  208.         sc->pStart = sc->pBufi; /* start pointer */
  209.         sc->pEnd = sc->pBufi + ESMC_BUFSIZE_INT; /* end pointer */
  210.         sc->pIn = sc->pBufi; /* input pointer */
  211.         sc->pOut = sc->pBufi; /* output pointer */
  212.         sc->indexIn = 0; /* input index */
  213.         sc->indexOut = 0; /* output index */
  214.         sc->nIndex = ESMC_INDEXES; /* indexes */
  216.         if (sc->bufi == NULL)
  217.     return (ERROR);
  219.         bzero (sc->pBufi, ESMC_BUFSIZE_INT);
  220. }
  222.     semBInit (&sc->esmcSyncSem, SEM_Q_FIFO, SEM_EMPTY);
  224.     (void) intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (intVec), 
  225.        (VOIDFUNCPTR)esmcIntr, unit);
  227. #ifdef BSD43_DRIVER
  228.     ether_attach (&sc->es_if, unit, "esmc", (FUNCPTR)esmcInit, 
  229.   (FUNCPTR)esmcIoctl, (FUNCPTR)esmcOutput, (FUNCPTR)esmcReset);
  230. #else
  231.     ether_attach (
  232.                  &sc->es_if, 
  233.                  unit, 
  234.                  "esmc", 
  235.                  (FUNCPTR)esmcInit, 
  236.          (FUNCPTR)esmcIoctl, 
  237.                  (FUNCPTR)ether_output, 
  238.                  (FUNCPTR)esmcReset
  239.                  );
  240.     sc->es_if.if_start = (FUNCPTR)esmcPut;
  241. #endif
  243.     esmcInit (unit);
  245.     return (OK);
  246.     }
  247. /*******************************************************************************
  248. *
  249. * esmcReset - reset the interface
  250. *
  251. * RETURNS: N/A
  252. */
  254. LOCAL void esmcReset 
  255.     (
  256.     int unit 
  257.     )
  258.     {
  259.     FAST ESMC_SOFTC *sc   = &esmc_softc [unit];
  260.     int s = splnet ();
  262.     sysIntDisablePIC (sc->intLevel);
  263.     sc->es_if.if_flags = 0;
  265.     splx (s);
  266.     }
  267. /*******************************************************************************
  268. *
  269. * esmcInit - initialize esmc
  270. *
  271. * Restart the link level software on the board and mark the interface up.
  272. *
  273. * RETURNS: 0
  274. */
  276. LOCAL int esmcInit 
  277.     (
  278.     int unit 
  279.     )
  280.     {
  281.     FAST ESMC_SOFTC *sc = &esmc_softc[unit];
  282.     int s = splnet ();
  284.     esmcChipInit (unit);
  285.     sysIntEnablePIC (sc->intLevel);
  286.     sc->es_if.if_flags |= IFF_UP|IFF_RUNNING; /* open for business*/
  288.     splx (s);
  289.     return (0);
  290.     }
  292. #ifdef BSD43_DRIVER
  293. /*******************************************************************************
  294. *
  295. * esmcOutput - ethernet output routine
  296. *
  297. * Encapsulate a packet of type family for the local net.
  298. * Use trailer local net encapsulation if enough data in first
  299. * packet leaves a multiple of 512 bytes of data in remainder.
  300. * If destination is this address or broadcast, send packet to
  301. * loop device to kludge around the fact that 3com interfaces can't
  302. * talk to themselves.
  303. *
  304. * RETURNS:  OK if successful, otherwise errno.
  305. */
  307. LOCAL int esmcOutput 
  308.     (
  309.     struct ifnet *ifp,
  310.     struct mbuf *m0,
  311.     struct sockaddr *dst 
  312.     )
  313.     {
  314.     return (ether_output (ifp, m0, dst, (FUNCPTR)esmcPut,
  315.   &esmc_softc [ifp->if_unit].es_ac));
  316.     }
  317. #endif
  319. /*******************************************************************************
  320. *
  321. * esmcIoctl - ioctl for interface
  322. *
  323. * RETURNS: OK if successful, otherwise errno.
  324. */
  326. LOCAL int esmcIoctl 
  327.     (
  328.     FAST struct ifnet *ifp,
  329.     int cmd,
  330.     caddr_t data 
  331.     )
  332.     {
  333.     FAST ESMC_SOFTC *sc = &esmc_softc[ifp->if_unit];
  334.     int status = OK;
  335.     int s = splimp();
  336.     short flags;
  338.     switch (cmd)
  339. {
  340. case SIOCSIFADDR:
  341.             ((struct arpcom *)ifp)->ac_ipaddr = IA_SIN (data)->sin_addr;
  342.             arpwhohas (ifp, &IA_SIN (data)->sin_addr);
  343.     break;
  345. case SIOCSIFFLAGS:
  346.             flags = ifp->if_flags;
  348.     if (ifp->if_flags & IFF_UP)
  349.                 ifp->if_flags = flags | (IFF_UP|IFF_RUNNING);
  350.             else
  351.                 ifp->if_flags = flags & ~(IFF_UP|IFF_RUNNING);
  352.     break;
  354. default:
  355.     status = EINVAL;
  356. }
  358.     splx (s);
  359.     return (status);
  360.     }
  362. /*******************************************************************************
  363. *
  364. * esmcIntr - Ethernet interface interrupt
  365. *
  366. * Hand off reading of packets from the interface to task level.
  367. *
  368. * RETURNS: N/A
  369. */
  371. LOCAL void esmcIntr 
  372.     (
  373.     int unit 
  374.     )
  375.     {
  376.     FAST ESMC_SOFTC *sc = &esmc_softc[unit];
  377.     FAST int ioaddr     = sc->ioAddr;
  378.     int timeout         = ESMC_INTR_TIMEOUT;
  379.     u_short bank;
  380.     u_short pointerSave;
  381.     u_short statusTx;
  382.     u_short statusCard;
  383.     u_short packetFail;
  384.     u_char packetSave;
  385.     u_char mask;
  386.     u_char status;
  388.     sc->interrupt++;
  389.     bank = sysInWord (ioaddr + ESMC_BANK_SELECT); /* save bank */
  390.     ESMC_SWITCH_BANK (2);
  391.     mask = sysInByte (ioaddr + ESMC_INT_MASK); /* save mask */
  393.     while ((status = sysInByte (ioaddr + ESMC_INT_STAT) & mask) && (timeout--))
  394. {
  395. if (status & ESMC_INT_RCV) /* RX done */
  396.     {
  397.             sc->intRcv++;
  398.     if (sc->mode == RX_MODE_INTERRUPT) /* RX in int */
  399. {
  400. esmcGetInt (unit);
  401.         if ((sc->flags & ESMC_RXING) == 0)
  402.     {
  403.     sc->flags |= ESMC_RXING;
  404.     (void) netJobAdd ((FUNCPTR)esmcGetTask, unit, 0, 0, 0, 0);
  405.     }
  406. }
  407.     else if ((sc->flags & ESMC_RXING) == 0) /* RX in task */
  408. {
  409. sc->flags |= ESMC_RXING;
  410. (void) netJobAdd ((FUNCPTR)esmcGet, unit, 0, 0, 0, 0);
  411. }
  412.     }
  414. if (status & ESMC_INT_TX) /* TX error */
  415.     {
  416.             sc->es_if.if_oerrors++;
  417.             sc->es_if.if_opackets--;
  418.             sc->intTx++;
  419.          pointerSave = sysInWord (ioaddr + ESMC_PTR); /* save pointer */
  420.     packetSave  = sysInByte (ioaddr + ESMC_PNR); /* save packet */
  422.     packetFail  = sysInWord (ioaddr + ESMC_FIFO) & 0x7f;
  423.     sysOutByte (ioaddr + ESMC_PNR, packetFail);
  424.     sysOutWord (ioaddr + ESMC_PTR, ESMC_PTR_AUTOINC | ESMC_PTR_READ);
  425.     statusTx = sysInWord (ioaddr + ESMC_DATA_1);
  426.     if (statusTx & ESMC_TS_LOST_CARR)
  427. sc->lostCarr++;
  428.     if (statusTx & ESMC_TS_LATCOL)
  429. sc->es_if.if_collisions++;
  430.     
  431.     sysOutWord (ioaddr + ESMC_MMU, ESMC_MMU_TX_RELEASE); /* release */
  432.     sysOutByte (ioaddr + ESMC_INT_ACK, ESMC_INT_TX);  /* int ack */
  433.     ESMC_SWITCH_BANK (0);
  434.     sysOutWord (ioaddr + ESMC_TCR, 
  435. sysInWord (ioaddr + ESMC_TCR) | ESMC_TCR_TXEN);
  436.     ESMC_SWITCH_BANK (2);
  438.     sysOutByte (ioaddr + ESMC_PNR, packetSave);  /* restore packet */
  439.             sysOutWord (ioaddr + ESMC_PTR, pointerSave); /* restore pointer */
  440.     }
  442. if (status & ESMC_INT_TX_EMPTY) /* TX done */
  443.     {
  444.             sc->intTxempty++;
  445.     sysOutByte (ioaddr + ESMC_INT_ACK, ESMC_INT_TX_EMPTY); /* int ack */
  447.     ESMC_SWITCH_BANK (0);
  448.     statusCard = sysInWord (ioaddr + ESMC_COUNTER);
  449.          ESMC_SWITCH_BANK (2);
  450.     sc->es_if.if_collisions += statusCard & 0x0f;
  451.     statusCard >>= 4;
  452.     sc->es_if.if_collisions += statusCard & 0x0f;
  454.     mask &= ~ESMC_INT_TX_EMPTY;
  455.     if (sc->es_if.if_snd.ifq_head != NULL)
  456. #ifdef BSD43_DRIVER
  457. (void) netJobAdd ((FUNCPTR)esmcPut, unit, 0, 0, 0, 0);
  458. #else
  459. (void) netJobAdd ((FUNCPTR)esmcPut, (int)sc, 0, 0, 0, 0);
  460. #endif
  461.     }
  463. if (status & ESMC_INT_ALLOC) /* ALLOC done */
  464.     {
  465.             sc->intAlloc++;
  466.     mask &= ~ESMC_INT_ALLOC;
  467.     semGive (&sc->esmcSyncSem);
  468.     }
  470. if (status & ESMC_INT_RX_OVRN) /* RX over run */
  471.     {
  472.             sc->es_if.if_ierrors++;
  473.             sc->intOverrun++;
  474.             sysOutByte (ioaddr + ESMC_INT_ACK, ESMC_INT_RX_OVRN); /* int ack */
  475.     if (sc->mode == RX_MODE_INTERRUPT) /* RX in int */
  476. {
  477. esmcGetInt (unit);
  478.         if ((sc->flags & ESMC_RXING) == 0)
  479.     {
  480.     sc->flags |= ESMC_RXING;
  481.     (void) netJobAdd ((FUNCPTR)esmcGetTask, unit, 0, 0, 0, 0);
  482.     }
  483. }
  484.     else if ((sc->flags & ESMC_RXING) == 0) /* RX in task */
  485. {
  486. sc->flags |= ESMC_RXING;
  487. (void) netJobAdd ((FUNCPTR)esmcGet, unit, 0, 0, 0, 0);
  488. }
  489.     }
  491. if (status & ESMC_INT_EPH) /* EPH */
  492.             sc->intEph++;
  494. if (status & ESMC_INT_ERCV) /* early receive */
  495.             sc->intErcv++;
  496. }
  497.     
  498.     sysOutByte (ioaddr + ESMC_INT_MASK, mask); /* restore the mask */
  499.     ESMC_SWITCH_BANK (bank); /* restore the bank */
  501.     return;
  502.     }
  503. /*******************************************************************************
  504. *
  505. * esmcGet - read a packet off the interface(Task Level: netTask)
  506. *
  507. * Copy packets from a RING into an mbuf and hand it to the next higher layer.
  508. *
  509. * RETURNS: N/A
  510. */
  512. LOCAL void esmcGet 
  513.     (
  514.     int unit
  515.     )
  516.     {
  517.     FAST ESMC_SOFTC *sc = &esmc_softc[unit];
  518.     FAST int ioaddr     = sc->ioAddr;
  519.     FAST struct ether_header *eh;
  520.     FAST struct mbuf *m;
  521.     int off;
  522.     int len;
  523.     u_short packetNo;
  524.     u_short statusRx;
  525.     u_char * pData;
  526.     u_char mask;
  528.     ESMC_SWITCH_BANK (2);
  529.     mask = sysInByte (ioaddr + ESMC_INT_MASK); /* save mask */
  531. unlucky:
  532.     while (((packetNo = sysInWord (ioaddr + ESMC_FIFO)) & ESMC_FP_RXEMPTY) == 0)
  533. {
  534.         sysOutByte (ioaddr + ESMC_INT_MASK, 0); /* lock INT */
  536. sysOutWord (ioaddr + ESMC_PTR, 
  537.     ESMC_PTR_READ | ESMC_PTR_RCV | ESMC_PTR_AUTOINC);
  539. statusRx = sysInWord (ioaddr + ESMC_DATA_1); /* status */
  540. len  = sysInWord (ioaddr + ESMC_DATA_1); /* byte count */
  541. len  = (len & 0x07ff) - 6; /* subtract extra */
  543. if (statusRx & ESMC_RS_ERROR_MASK)
  544.     {
  545.     ++sc->es_if.if_ierrors;
  546.     while (sysInWord (ioaddr + ESMC_MMU) & 0x0001) /* check busy bit */
  547. ;
  548.     sysOutWord (ioaddr + ESMC_MMU, ESMC_MMU_RX_RELEASE); /* release */
  549.             sysOutByte (ioaddr + ESMC_INT_MASK, mask); /* unlock INT */
  550.     }
  551. else
  552.     {
  553. #if ESMC_USE_LONG
  554.     sysInLongString (ioaddr + ESMC_DATA_1, (long *)sc->pBuft, len >> 2);
  555.     if (len & 0x02)
  556.         *(short *)&sc->pBuft[len & ~0x03] = 
  557.                               sysInWord (ioaddr + ESMC_DATA_1);
  558.     *(short *)&sc->pBuft[len & ~0x01] = 
  559.                               sysInWord (ioaddr + ESMC_DATA_1);
  560. #else
  561.     sysInWordString (ioaddr + ESMC_DATA_1, (short *)sc->pBuft,
  562.              (len>>1) + 1);
  563. #endif /* ESMC_USE_LONG */
  565.     if (statusRx & ESMC_RS_ODDFRM)
  566. len++;
  567.     while (sysInWord (ioaddr + ESMC_MMU) & 0x0001) /* check busy bit */
  568. ;
  569.     sysOutWord (ioaddr + ESMC_MMU, ESMC_MMU_RX_RELEASE); /* release */
  570.             sysOutByte (ioaddr + ESMC_INT_MASK, mask); /* unlock INT */
  572. #ifdef ESMC_DEBUG
  573.     {
  574.     int ix;
  575.     int iy;
  576.     printf ("packet=0x%x, status=0x%x, len=%dn", 
  577.     (packetNo >> 8) & 0x1f, statusRx, len);
  578.     for (iy = 0; iy < 8; iy++)
  579.         {
  580.                 for (ix = 0; ix < 16; ix++)
  581.             printf ("%2.2x ", (u_char)sc->pBuft[iy * 16 + ix]);
  582.         printf ("n");
  583.         }
  584.     }
  585. #endif /* ESMC_DEBUG */
  587.             sc->es_if.if_ipackets++;        /* bump statistic */
  589.     eh = (struct ether_header *)(sc->pBuft);
  591.             /* call input hook if any */
  593.             if ((etherInputHookRtn != NULL) &&
  594.         (* etherInputHookRtn) (&sc->es_if, (char *) eh, len))
  595.         {
  596.         continue;
  597.         }
  599.             if (len >= SIZEOF_ETHERHEADER)
  600.                 len -= SIZEOF_ETHERHEADER;
  601.             else
  602.                 {
  603.                 sc->es_if.if_ierrors++;         /* bump error statistic */
  604.         continue;
  605.                 }
  607.             pData = ((unsigned char *) eh) + SIZEOF_ETHERHEADER;
  609. #ifdef BSD43_DRIVER
  610.             check_trailer (eh, pData, &len, &off, &sc->es_if);
  612.             /* copy data from the ring buffer to mbuf a long-word at a time */
  614.             m = bcopy_to_mbufs (pData, len, off, (struct ifnet *)&sc->es_if, 2);
  616.             if (m == NULL)
  617.                 {
  618.                 sc->es_if.if_ierrors++;        /* bump error statistic */
  619.         continue;
  620.                 }
  622.             do_protocol_with_type (eh->ether_type, m, &sc->es_ac, len);
  623. #else
  624.             /* copy data from the ring buffer to mbuf */
  626.             m = bcopy_to_mbufs (pData, len, off, (struct ifnet *)&sc->es_if, 2);
  628.             if (m == NULL)
  629.                 {
  630.                 sc->es_if.if_ierrors++;        /* bump error statistic */
  631.         continue;
  632.                 }
  634.             do_protocol (eh, m, &sc->es_ac, len);
  635. #endif
  636.     }
  637.         }
  639.     sc->flags &= ~ESMC_RXING;
  641.     /* go back if we got an interrupt and a new packet */
  643.     if ((sysInByte (ioaddr + ESMC_INT_STAT) & (ESMC_INT_RCV | ESMC_INT_RX_OVRN))
  644.  || (((sysInWord (ioaddr + ESMC_FIFO)) & ESMC_FP_RXEMPTY) == 0))
  645. goto unlucky;
  646.     }
  648. /*******************************************************************************
  649. *
  650. * esmcGetInt - read a packet off the interface(Interrupt Level)
  651. *
  652. * Copy packets from a RING into an mbuf and hand it to the next higher layer.
  653. *
  654. * RETURNS: N/A
  655. */
  657. LOCAL void esmcGetInt 
  658.     (
  659.     int unit
  660.     )
  661.     {
  662.     FAST ESMC_SOFTC *sc = &esmc_softc[unit];
  663.     FAST int ioaddr     = sc->ioAddr;
  664.     int len;
  665.     int bufLen;
  666.     u_short statusRx;
  667.     u_short packetNo;
  670.     if ((sc->pIn > sc->pOut) && ((sc->pEnd - sc->pIn) < ESMC_BUFSIZE))
  671. sc->pIn = sc->pStart;
  673.     if (((sc->pOut > sc->pIn) && ((sc->pOut - sc->pIn) < ESMC_BUFSIZE)) ||
  674.         (sc->packetLen[sc->indexIn] != 0))
  675. return;
  677.     while (((packetNo = sysInWord (ioaddr + ESMC_FIFO)) & ESMC_FP_RXEMPTY) == 0)
  678. {
  679. sysOutWord (ioaddr + ESMC_PTR, 
  680.     ESMC_PTR_READ | ESMC_PTR_RCV | ESMC_PTR_AUTOINC);
  682. statusRx = sysInWord (ioaddr + ESMC_DATA_1); /* status */
  683. len  = sysInWord (ioaddr + ESMC_DATA_1); /* byte count */
  684. len  = (len & 0x07ff) - 6; /* subtract extra */
  686. if (statusRx & ESMC_RS_ERROR_MASK)
  687.     {
  688.     ++sc->es_if.if_ierrors;
  689.     while (sysInWord (ioaddr + ESMC_MMU) & 0x0001) /* check busy bit */
  690. ;
  691.     sysOutWord (ioaddr + ESMC_MMU, ESMC_MMU_RX_RELEASE); /* release */
  692.     }
  693. else
  694.     {
  695. #if ESMC_USE_LONG
  696.     sysInLongString (ioaddr + ESMC_DATA_1, (long *)sc->pIn, len >> 2);
  697.     if (len & 0x02)
  698.         *(short *)&sc->pIn[len & ~0x03] = 
  699.       sysInWord (ioaddr + ESMC_DATA_1);
  700.     *(short *)&sc->pIn[len & ~0x01] = sysInWord (ioaddr + ESMC_DATA_1);
  701. #else
  702.     sysInWordString (ioaddr + ESMC_DATA_1, (short *)sc->pIn, 
  703.      (len>>1) + 1);
  704. #endif /* ESMC_USE_LONG */
  706.     if (statusRx & ESMC_RS_ODDFRM)
  707. len++;
  708.     while (sysInWord (ioaddr + ESMC_MMU) & 0x0001) /* check busy bit */
  709. ;
  710.     sysOutWord (ioaddr + ESMC_MMU, ESMC_MMU_RX_RELEASE); /* release */
  712.     if (len & 0x01) /* buffer length */
  713. bufLen = len + 1;
  714.     else
  715. bufLen = len + 2;
  716.     sc->packetAddr[sc->indexIn] = sc->pIn; /* packet address */
  717.     sc->packetLen[sc->indexIn] = len; /* packet length */
  718.     sc->pIn += bufLen; /* increment */
  719.     sc->indexIn = (sc->indexIn + 1) % sc->nIndex;
  721.             if ((sc->pIn > sc->pOut) && ((sc->pEnd - sc->pIn) < ESMC_BUFSIZE))
  722.         sc->pIn = sc->pStart; /* wrap around */
  724.             if (((sc->pOut > sc->pIn) && ((sc->pOut - sc->pIn) < ESMC_BUFSIZE))
  725. || (sc->packetLen[sc->indexIn] != 0)) /* no space */
  726.         break;
  727.     }
  728.         }
  729.     }
  731. /*******************************************************************************
  732. *
  733. * esmcGetTask - read a packet off the interface(Task Level)
  734. *
  735. * Copy packets from a RING into an mbuf and hand it to the next higher layer.
  736. *
  737. * RETURNS: N/A
  738. */
  740. LOCAL void esmcGetTask 
  741.     (
  742.     int unit
  743.     )
  744.     {
  745.     FAST ESMC_SOFTC *sc = &esmc_softc[unit];
  746.     FAST struct ether_header *eh;
  747.     FAST struct mbuf *m;
  748.     int off;
  749.     int len;
  750.     int bufLen;
  751.     u_char * pData;
  753.     while ((len = sc->packetLen[sc->indexOut]) != 0)
  754. {
  755. eh = (struct ether_header *)(sc->packetAddr[sc->indexOut]);
  757.         sc->es_if.if_ipackets++;        /* bump statistic */
  759.         /* call input hook if any */
  761.         if ((etherInputHookRtn != NULL) &&
  762.     (* etherInputHookRtn) (&sc->es_if, (char *) eh, len))
  763.     continue;
  765.         if (len >= SIZEOF_ETHERHEADER)
  766.             len -= SIZEOF_ETHERHEADER;
  767.         else
  768.             {
  769.             sc->es_if.if_ierrors++;         /* bump error statistic */
  770.     continue;
  771.             }
  773.         pData = ((unsigned char *) eh) + SIZEOF_ETHERHEADER;
  775. #ifdef BSD43_DRIVER
  776.         check_trailer (eh, pData, &len, &off, &sc->es_if);
  778.         /* copy data from the ring buffer to mbuf a long-word at a time */
  780.         m = bcopy_to_mbufs (pData, len, off, (struct ifnet *)&sc->es_if, 2);
  782.         if (m == NULL)
  783.             {
  784.             sc->es_if.if_ierrors++;         /* bump error statistic */
  785.     continue;
  786.             }
  788.         do_protocol_with_type (eh->ether_type, m, &sc->es_ac, len);
  789. #else
  790.         /* copy data from the ring buffer to mbuf */
  792.         m = bcopy_to_mbufs (pData, len, off, (struct ifnet *)&sc->es_if, 2);
  794.         if (m == NULL)
  795.             {
  796.             sc->es_if.if_ierrors++;         /* bump error statistic */
  797.     continue;
  798.             }
  800.         do_protocol (eh, m, &sc->es_ac, len);
  801. #endif
  803. if (len & 0x01) /* buffer length */
  804.     bufLen = len + 1;
  805. else
  806.     bufLen = len + 2;
  807. sc->pOut = sc->packetAddr[sc->indexOut] + bufLen;
  808. sc->packetLen[sc->indexOut] = 0; /* mark it empty */
  809. sc->indexOut = (sc->indexOut + 1) % sc->nIndex; /* increment */
  810. }
  812.     sc->flags &= ~ESMC_RXING;
  813.     }
  815. /*******************************************************************************
  816. *
  817. * esmcPut - copy a packet to the interface.
  818. *
  819. * Copy from mbuf chain to transmitter buffer in shared memory.
  820. *
  821. * RETURNS: N/A
  822. */
  824. #ifdef BSD43_DRIVER
  825. LOCAL void esmcPut 
  826.     (
  827.     int unit
  828.     )
  829.     {
  830.     FAST ESMC_SOFTC *sc = &esmc_softc [unit];
  831. #else
  832. LOCAL void esmcPut 
  833.     (
  834.     ESMC_SOFTC *sc
  835.     )
  836.     {
  837. #endif
  839.     FAST int ioaddr     = sc->ioAddr;
  840.     FAST struct mbuf *m;
  841.     int timeout         = ESMC_ALLOC_TIMEOUT;
  842.     int len;
  843.     int pages;
  844.     u_char mask;
  845.     u_char packetNo;
  846.     int s = splnet ();
  848.     if (sc->es_if.if_snd.ifq_head != NULL)
  849. {
  850. IF_DEQUEUE (&sc->es_if.if_snd, m);
  852. copy_from_mbufs (sc->pBuft, m, len);
  853. len = max (ETHERSMALL, len);
  855. /* call output hook if any */
  857. if ((etherOutputHookRtn != NULL) &&
  858.     (* etherOutputHookRtn) (&sc->es_if, sc->pBuft, len))
  859.     {
  860.     goto donePut;
  861.     }
  863. #ifndef BSD43_DRIVER
  864.         sc->es_if.if_opackets++;        /* bump statistic. */
  865. #endif
  867. /* allocate transmit memory and transmit */
  869. pages = len / 256;
  870. ESMC_SWITCH_BANK (2);
  871. mask = sysInByte (ioaddr + ESMC_INT_MASK); /* save mask */
  873. sysOutWord (ioaddr + ESMC_MMU, ESMC_MMU_ALLOC | pages); /* alloc mem */
  874. while (((sysInByte (ioaddr + ESMC_INT_STAT) & ESMC_INT_ALLOC) == 0) &&
  875.        (--timeout))
  876.     ;
  877. if (timeout == 0) /* take sem & wait */
  878.     {
  879.     sysOutByte (ioaddr + ESMC_INT_MASK, mask | ESMC_INT_ALLOC);
  880.     if (semTake (&sc->esmcSyncSem, sysClkRateGet () >> 2) == ERROR)
  881. {
  882.         sc->allocTimeout++;
  883.         goto donePut;
  884.         }
  885.     }
  887. if ((packetNo = sysInByte (ioaddr + ESMC_ARR)) & 0x80) /* check it */
  888.     {
  889.     sc->allocFailed++;
  890.     goto donePut;
  891.     }
  893. #ifdef ESMC_DEBUG
  894. {
  895. int ix;
  896. int iy;
  897. printf ("pages=0x%x, packetNo=0x%x, len=%dn", pages, packetNo, len);
  898. for (iy = 0; iy < 8; iy++)
  899.     {
  900.             for (ix = 0; ix < 16; ix++)
  901.         printf ("%2.2x ", (u_char)sc->pBuft[iy * 16 + ix]);
  902.     printf ("n");
  903.     }
  904. }
  905. #endif /* ESMC_DEBUG */
  907. sysOutByte (ioaddr + ESMC_INT_MASK, 0); /* lock INT */
  908. sysOutByte (ioaddr + ESMC_PNR, packetNo); /* set the tx packet */
  909. sysOutWord (ioaddr + ESMC_PTR, ESMC_PTR_AUTOINC); /* set the pointer */
  911. #if ESMC_USE_LONG
  912. sysOutLong (ioaddr + ESMC_DATA_1, (len + 6) << 16); /* status, count */
  913. sysOutLongString (ioaddr + ESMC_DATA_1, (long *)sc->pBuft, len >> 2);
  914. if (len & 0x02)
  915.     sysOutWord (ioaddr + ESMC_DATA_1, *(short *)&sc->pBuft[len & ~0x03]);
  916. #else
  917. sysOutWord (ioaddr + ESMC_DATA_1, 0); /* status */
  918. sysOutWord (ioaddr + ESMC_DATA_1, (len + 6)); /* byte count */
  919. sysOutWordString (ioaddr + ESMC_DATA_1, (short *)sc->pBuft, len >> 1);
  920. #endif /* ESMC_USE_LONG */
  922. if (len & 0x01) /* odd byte count */
  923.     {
  924.     sysOutByte (ioaddr + ESMC_DATA_1, sc->pBuft[len - 1]);
  925.     sysOutByte (ioaddr + ESMC_DATA_1, 0x20);
  926.     }
  927. else /* even byte count */
  928.     sysOutWord (ioaddr + ESMC_DATA_1, 0);
  930. sysOutWord (ioaddr + ESMC_MMU, ESMC_MMU_ENQUEUE); /* send it */
  931. sysOutByte (ioaddr + ESMC_INT_MASK, 
  932.     mask | ESMC_INT_TX | ESMC_INT_TX_EMPTY);
  933. }
  935. donePut:
  936.     splx (s);
  937.     }
  938. /*******************************************************************************
  939. *
  940. * esmcChipInit - initialize SMC91c9x chip
  941. *
  942. * RETURNS: N/A
  943. */
  945. LOCAL STATUS esmcChipInit 
  946.     (
  947.     int unit
  948.     )
  949.     {
  950.     FAST ESMC_SOFTC *sc = &esmc_softc[unit];
  951.     FAST int ioaddr     = sc->ioAddr;
  952.     int memSize;
  953.     int ix;
  954.     u_short bank;
  955.     u_short config;
  956.     u_short addr;
  957.     u_short memInfo;
  958.     u_short memConfig;
  959.     char revision;
  960.     char * pRevision;
  962.     sysOutWord (ioaddr + ESMC_BANK_SELECT, 0x00);
  963.     bank = sysInWord (ioaddr + ESMC_BANK_SELECT);
  964.     if ((bank & 0xff00) != 0x3300)
  965. {
  966. #ifdef ESMC_DEBUG
  967.         printf ("esmc: error - bank select 0x%xn", bank & 0xff00);
  968. #endif
  969. return (ERROR);
  970.         }
  972.     ESMC_SWITCH_BANK (1);
  973.     addr = sysInWord (ioaddr + ESMC_BASE);
  974.     if (ioaddr != ((addr >> 3) & 0x3e0))
  975. {
  976. #ifdef ESMC_DEBUG
  977.         printf ("esmc: error - ioaddr=0x%xn", (addr >> 3) & 0x3e0);
  978. #endif
  979. return (ERROR);
  980.         }
  981.     
  982.     ESMC_SWITCH_BANK (3);
  983.     revision = sysInByte (ioaddr + ESMC_REVISION);
  984.     if ((pRevision = pName[(revision >> 4) & 0x0f]) == NULL)
  985. {
  986. #ifdef ESMC_DEBUG
  987.         printf ("esmc: error - revision=0x%xn", (revision >> 4) & 0x0f);
  988. #endif
  989. return (ERROR);
  990.         }
  991.     
  992.     ESMC_SWITCH_BANK (0);
  993.     memInfo = sysInWord (ioaddr + ESMC_MIR);
  994.     memConfig = sysInWord (ioaddr + ESMC_MCR);
  995.     memSize = (memConfig >> 9) & 0x07;
  996.     memSize *= (memInfo & 0xff) * 256;
  998.     esmcChipReset (unit); /* reset the chip */
  1000.     ESMC_SWITCH_BANK (1);
  1001.     config = sysInWord (ioaddr + ESMC_CONFIG);
  1002.     if (sc->config == ATTACHMENT_DEFAULT) /* EEPROM */
  1003. {
  1004. if (config & ESMC_CFG_AUI_SELECT) /* EEPROM - AUI */
  1005.     sc->config = ATTACHMENT_AUI;
  1006. else /* EEPROM - RJ45 */
  1007.     {
  1008.     sc->config = ATTACHMENT_RJ45;
  1009.     sysOutByte (ioaddr + ESMC_CONFIG, config);
  1010.     }
  1011. }
  1012.     else if (sc->config == ATTACHMENT_AUI) /* AUI */
  1013. sysOutByte (ioaddr + ESMC_CONFIG, config | ESMC_CFG_AUI_SELECT);
  1014.     else if (sc->config == ATTACHMENT_RJ45) /* RJ45 */
  1015. sysOutByte (ioaddr + ESMC_CONFIG, config & ~ESMC_CFG_AUI_SELECT);
  1016.     
  1017.     for (ix = 0; ix < 6; ix++) /* ethernet addres */
  1018. sc->es_enaddr[ix] = sysInByte (ioaddr + ESMC_ADDR_0 + ix);
  1019.     
  1020.     ESMC_SWITCH_BANK (0);
  1021.     sysOutWord (ioaddr + ESMC_MCR, 0x0006);   /* 1532 bytes */ 
  1022.     sysOutWord (ioaddr + ESMC_TCR, ESMC_TCR_PAD | ESMC_TCR_TXEN); /* TXenable */
  1023.     sysOutWord (ioaddr + ESMC_RCR, ESMC_RCR_RXEN); /* RX enable */
  1025.     ESMC_SWITCH_BANK (2); /* int enable */
  1026.     sysOutByte (ioaddr + ESMC_INT_MASK, ESMC_INT_RX_OVRN | ESMC_INT_RCV); 
  1028. #if ESMC_DEBUG
  1029.     printf ("ESMC: %s(rev=%d) at %#3x IRQ=%d IF=%s MEM=%d ",
  1030.     pRevision, revision & 0x0f, ioaddr, sc->intLevel,
  1031.     (sc->config == 1)? "TP" : "AUI", memSize);
  1032.     printf ("(");
  1033.     for (ix = 0; ix < 5; ix++)
  1034. printf ("%2.2x:", (u_char)sc->es_enaddr[ix]);
  1035.     printf ("%2.2x)n", (u_char)sc->es_enaddr[ix]);
  1036. #endif /* ESMC_DEBUG */
  1038.     return (OK);
  1039.     }
  1040. /*******************************************************************************
  1041. *
  1042. * esmcChipReset - reset SMC91c9x chip
  1043. *
  1044. * RETURNS: N/A
  1045. */
  1047. LOCAL void esmcChipReset 
  1048.     (
  1049.     int unit
  1050.     )
  1051.     {
  1052.     FAST ESMC_SOFTC *sc = &esmc_softc[unit];
  1053.     FAST int ioaddr     = sc->ioAddr;
  1055.     ESMC_SWITCH_BANK (2);
  1056.     sysOutByte (ioaddr + ESMC_INT_MASK, 0); /* lock INT */
  1058.     ESMC_SWITCH_BANK (0);
  1059.     sysOutWord (ioaddr + ESMC_RCR, ESMC_RCR_EPH_RST); /* software reset */
  1060.     taskDelay (sysClkRateGet () >> 3);
  1062.     sysOutWord (ioaddr + ESMC_RCR, 0x0000); /* RX disable */
  1063.     sysOutWord (ioaddr + ESMC_TCR, 0x0000); /* TX disable */
  1065.     ESMC_SWITCH_BANK (1);
  1066.     sysOutWord (ioaddr + ESMC_CONTROL,  /* TX auto release */
  1067. sysInWord (ioaddr + ESMC_CONTROL) | ESMC_CTL_AUTO_RELEASE);
  1069.     ESMC_SWITCH_BANK (2);
  1070.     sysOutWord (ioaddr + ESMC_MMU, ESMC_MMU_RESET); /* MMU reset */
  1071.     taskDelay (sysClkRateGet () >> 3);
  1072.     }
  1074. #if ESMC_SHOW
  1075. /*******************************************************************************
  1076. *
  1077. * esmcShow - display statistics for the `esmc' network interface
  1078. *
  1079. * This routine displays statistics about the `esmc' Ethernet network interface.
  1080. * It has two parameters:
  1081. * .iP <unit>
  1082. * interface unit; should be 0.
  1083. * .iP <zap>
  1084. * if 1, all collected statistics are cleared to zero.
  1085. * .LP
  1086. *
  1087. * RETURNS: N/A
  1088. */
  1090. void esmcShow 
  1091.     (
  1092.     int unit,   /* interface unit */
  1093.     BOOL zap    /* zero totals */
  1094.     )
  1095.     {
  1096.     FAST ESMC_SOFTC *sc = &esmc_softc[unit];
  1097.     FAST int ioaddr     = sc->ioAddr;
  1098.     FAST u_int * pUint  = &sc->interrupt;
  1099.     FAST int ix;
  1100.     u_short bank;
  1101.     u_char mask;
  1102.     static char *pMessage [] =
  1103. {
  1104. "interrupt",
  1105. "interrupt rcv",
  1106. "interrupt tx",
  1107. "interrupt txempty",
  1108. "interrupt alloc",
  1109. "interrupt overrun",
  1110. "interrupt eph",
  1111. "interrupt ercv",
  1112. "lost carr",
  1113. "alloc timeout",
  1114. "alloc failed",
  1115. };
  1117.     printf ("esmc: ioAddr=0x%x intLevel=0x%xn", sc->ioAddr, sc->intLevel);
  1118.     for (ix = 0; ix < NELEMENTS(pMessage); ix++)
  1119. {
  1120. printf ("    %-30.30s  %4dn", pMessage[ix], pUint[ix]);
  1121. if (zap)
  1122.     pUint[ix] = 0;
  1123. }
  1124.     printf ("    %-30.30s  0x%2xn", "flags", sc->flags);
  1126.     bank = sysInWord (ioaddr + ESMC_BANK_SELECT);
  1127.     ESMC_SWITCH_BANK (2);
  1128.     mask = sysInByte (ioaddr + ESMC_INT_MASK);
  1129.     sysOutByte (ioaddr + ESMC_INT_MASK, 0); /* lock INT */
  1131.     ESMC_SWITCH_BANK (0);
  1132.     printf ("bank0-TCR:        0x%xn", sysInWord (ioaddr + ESMC_TCR));
  1133.     printf ("bank0-EPH:        0x%xn", sysInWord (ioaddr + ESMC_EPH));
  1134.     printf ("bank0-RCR:        0x%xn", sysInWord (ioaddr + ESMC_RCR));
  1135.     printf ("bank0-COUNTER:    0x%xn", sysInWord (ioaddr + ESMC_COUNTER));
  1136.     printf ("bank0-MIR:        0x%xn", sysInWord (ioaddr + ESMC_MIR));
  1137.     printf ("bank0-MCR:        0x%xn", sysInWord (ioaddr + ESMC_MCR));
  1138.     ESMC_SWITCH_BANK (1);
  1139.     printf ("bank1-CONFIG:     0x%xn", sysInWord (ioaddr + ESMC_CONFIG));
  1140.     printf ("bank1-CONTROL:    0x%xn", sysInWord (ioaddr + ESMC_CONTROL));
  1141.     ESMC_SWITCH_BANK (2);
  1142.     printf ("bank2-MMU:        0x%xn", sysInWord (ioaddr + ESMC_MMU));
  1143.     printf ("bank2-PNR:        0x%xn", sysInByte (ioaddr + ESMC_PNR));
  1144.     printf ("bank2-ARR:        0x%xn", sysInByte (ioaddr + ESMC_ARR));
  1145.     printf ("bank2-FIFO:       0x%xn", sysInWord (ioaddr + ESMC_FIFO));
  1146.     printf ("bank2-PTR:        0x%xn", sysInWord (ioaddr + ESMC_PTR));
  1147.     printf ("bank2-INT_STAT:   0x%xn", sysInByte (ioaddr + ESMC_INT_STAT));
  1148.     printf ("bank2-INT_MASK:   0x%xn", mask);
  1149.     ESMC_SWITCH_BANK (3);
  1150.     printf ("bank3-MGMT:       0x%xn", sysInWord (ioaddr + ESMC_MGMT));
  1151.     printf ("bank3-REVISION:   0x%xn", sysInWord (ioaddr + ESMC_REVISION));
  1152.     printf ("bank3-ERCV:       0x%xn", sysInWord (ioaddr + ESMC_ERCV));
  1154.     ESMC_SWITCH_BANK (bank);
  1155.     sysOutByte (ioaddr + ESMC_INT_MASK, mask); /* unlock INT */
  1156.     }
  1157. #endif /* ESMC_SHOW */