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

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

VxWorks

开发平台：

C/C++

if_med.c：源码内容
  1. /* if_med.c - Matrix DB-ETH Ethernet network interface driver */
  3. /* "Copyright 1989, Matrix Corporation" */
  5. /* Copyright 1984-1997 Wind River Systems, Inc. */
  8. /*
  9. modification history
  10. --------------------
  11. 02m,15jul97,spm  removed driver initialization from ioctl support (SPR #8831); 
  12.                  cleaned up handling of promiscuous mode
  13. 02l,07apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  14. 02k,16dec96,dat  fixed SPR 3026, incorrect test in medNIC_AwaitStop. 
  15.  Removed compiler warnings.
  16. 02j,05may93,caf  tweaked for ansi.
  17. 02i,11aug93,jmm  Changed ioctl.h and socket.h to sys/ioctl.h and sys/socket.h
  18. 02h,09sep92,gae  documentation tweaks.
  19. 02g,26may92,rrr  the tree shuffle
  20.   -changed includes to have absolute path from h/
  21. 02f,04oct91,rrr  passed through the ansification filter
  22.                   -changed functions to ansi style
  23.   -changed includes to have absolute path from h/
  24.   -fixed #else and #endif
  25.   -changed VOID to void
  26.   -changed copyright notice
  27. 02e,20sep90,dab  made medInit() return int.
  28. 02d,10aug90,dnw  added include of if_subr.h.
  29. 02c,11jul90,hjb  changed references to do_protocol() to use
  30.  do_protocol_with_type().  de-linted.
  31. 02b,26jun90,hjb  upgrade to use cluster and if_subr routines;
  32.    +dab  integrated in the new distribution from Matrix.
  33. 02a,05may90,dab  cleanup of Matrix version 01t.
  34. 01a,25sep89,srm  written by modifying if_ln.c.
  35. */
  37. /*
  38. DESCRIPTION
  39. This module implements the
  40. Matrix DB-ETH Ethernet network interface driver.
  41. There is one user-callable routine: medattach().
  43. BOARD LAYOUT
  44. This device is onboard.  No jumpering diagram required.
  46. SEE ALSO: ifLib
  47. */
  49. #include "vxWorks.h"
  50. #include "net/mbuf.h"
  51. #include "net/protosw.h"
  52. #include "sys/ioctl.h"
  53. #include "sys/socket.h"
  54. #include "errno.h"
  55. #include "net/uio.h"
  56. #include "net/if.h"
  57. #include "net/route.h"
  58. #include "netinet/in.h"
  59. #include "netinet/in_systm.h"
  60. #include "netinet/ip.h"
  61. #include "netinet/ip_var.h"
  62. #include "netinet/in_var.h"
  63. #include "netinet/if_ether.h"
  64. #include "net/if_subr.h"
  65. #include "etherLib.h"
  66. #include "vme.h"
  67. #include "iv.h"
  68. #include "iosLib.h"
  69. #include "ioLib.h"
  70. #include "memLib.h"
  71. #include "net/systm.h"
  72. #include "sys/types.h"
  73. #include "drv/netif/if_med.h"
  74. #include "intLib.h"
  75. #include "logLib.h"
  76. #include "stdio.h"
  77. #include "sysLib.h"
  78. #include "netLib.h"
  79. #include "net/if_subr.h"
  81. IMPORT void   sysDbusEtherIntEnable ();
  82. IMPORT ULONG  tickGet ();
  85. #define  NIC_INTERRUPTS_HANDLED   (nic_PKT_RECV_NO_ERRORS 
  86.                                  | nic_PKT_RECV_ERROR     
  87.                                  | nic_PKT_XMIT_NO_ERRORS 
  88.                                  | nic_PKT_XMIT_ERROR     
  89.                                  | nic_RECV_BFR_OVF_WARN  
  90.                                  | nic_NET_STATS_CNTR_OVF)
  92. /* Actual arguments for medSetNIC_IMR() */
  94. #define  MASK_NONE               0
  95. #define  UNMASK_NONE             0
  97. /* DB-ETH addresses as seen from the CPU */
  99. #define  ETH_ADRS_PROM_ADRS    ((u_long)dbeth_ETH_ADDR_ROM           
  100.                                 + ((u_long)es->nicAddr & 0xfff00000))
  101. #define  NIC_XMIT_BFR_ADRS     ((u_long)dbeth_NIC_XMIT_BFR           
  102.                                 + ((u_long)es->nicAddr & 0xfff00000))
  103. #define  NIC_RECV_BFR_ADRS(R)  ((u_long)dbeth_NIC_RECV_BFR           
  104.                                 + ((u_long)es->nicAddr & 0xfff00000)    
  105.                                 + ((u_long)(R) << 8))
  106. #define  END_OF_RECV_BFR       ((u_long)dbeth_NIC_RECV_BFR_END       
  107.                                 + ((u_long)es->nicAddr & 0xfff00000))
  109. /* NIC register initial values */
  111. #define PSTART  (u_char) (dbeth_NIC_RECV_BFR >> 8)
  112. #define PSTOP   (u_char) ((dbeth_NIC_RECV_BFR + dbeth_NIC_RECV_BFR_SIZE) >> 8)
  113. #define BNRY    (u_char) (PSTART)
  114. #define CURR    (u_char) (BNRY + 1)
  116. /* kludge, to force compilation of IP interface code */
  118. #ifndef INET
  119. #define INET
  120. #endif /* INET */
  122. /* globals */
  124. u_int medLogCount = 50;  /* log every medLogCount number of errors */
  126. /* locals */
  128. LOCAL med_Stats_s       med_Stats;
  129. LOCAL struct med_softc *med_softc [NNIC];
  132. /* forward static functions */
  134. static void medRecv (struct med_softc *es, struct ether_header *eh, int len);
  135. static nic_RecvHdr_s *medGetRecvPacket (struct med_softc *es);
  136. static void medRecvIntrHandler (struct med_softc *es);
  137. static int medIoctl (struct ifnet *ifp, int cmd, caddr_t data);
  138. static void medXmitIntrHandler (struct med_softc *es, u_char xmitStatus);
  139. static void medIntr (int unit);
  140. static void medRecordRecvError (struct med_softc *es);
  141. static void medIntEnable (BOOL bEnable);
  142. static void medReset (int unit);
  143. static int medInit (int unit);
  144. static u_char bitReverse (u_char in);
  145. static void medEthAddrGet (int unit);
  146. static void medConfigNIC (int unit);
  147. #ifdef BSD43_DRIVER
  148. static int medOutput (struct ifnet *ifp, struct mbuf *m0, struct sockaddr
  149. *dst);
  150. static void medStartOutput (int unit);
  151. #else
  152. static void medStartOutput (struct med_softc *es);
  153. #endif
  154. static xmitBCB_s *medXmitBfrAlloc (struct med_softc *es);
  155. static STATUS medXmitPacket (struct med_softc *es, char *pPacket, u_short
  156. packetLen);
  157. static void medReadTallyCntrs (struct med_softc *es);
  158. static void medMoveWrappedPacket (struct med_softc *es, nic_RecvHdr_s
  159. *pRecvPacket, u_long pktSize);
  160. static void medSetNIC_IMR (struct med_softc *es, u_char unmaskBits, u_char
  161. maskBits);
  162. static void medNIC_AwaitStop (NIC_DEVICE *pNIC);
  163. static void medXmitBfrDealloc (xmitQCB_s *pXmitQCB);
  164. static STATUS medXmtrLock (lockID_t *pLock);
  165. static void medXmtrUnlock (lockID_t *pLock);
  168. /*******************************************************************************
  169. *
  170. * medattach - publish the interface, and initialize the driver and device
  171. *
  172. * The routine publishes `med' the interface by filling in a network interface
  173. * record and adding this record to the system list.  This routine also
  174. * initializes the driver and the device to the operational state.
  175. *
  176. * RETURNS: OK or ERROR
  177. */
  179. STATUS medattach
  180.     (
  181.     int unit,           /* unit number */
  182.     char *addr,         /* address of Dbus Ethernet board */
  183.     int ivec,           /* interrupt vector to connect to */
  184.     int ilevel          /* interrupt level */
  185.     )
  186.     {
  187.     FAST struct med_softc *es;
  188.     FAST NIC_DEVICE *pNicDev = (NIC_DEVICE *) (addr + (u_long) dbeth_NIC_ADDR);
  190.     /* allocate and initialize med descriptor (med_softc) */
  192.     if ((es = (struct med_softc *) calloc (1, sizeof (struct med_softc)))
  193.         == NULL)
  194.         {
  195.         printErr ("med%d: ERROR - malloc failed.n", es->es_if.if_unit);
  196. return (ERROR);
  197.         }
  199.     med_softc [unit] = es; /* set ptr to med descriptor in array */
  201.     /* allocate and initialize overflow buffer for wrapped receive packets */
  203.     if ((es->pOvfRecvBfr = (nic_RecvHdr_s *)calloc (1, OVERFLOW_BFR_SIZE)) == 0)
  204.         {
  205.         printErr ("med%d: ERROR - malloc failed.n", es->es_if.if_unit);
  206. return (ERROR);
  207.         }
  209.     es->bFirstInit  = TRUE;            /* Unit 'unit' not yet initialized */
  210.     es->nicAddr     = pNicDev;
  211.     es->nicIntLevel = ilevel;
  212.     es->nicIntVec   = ivec;
  214.     (void) intConnect (INUM_TO_IVEC (ivec), medIntr, unit);
  216.     medReset (unit);
  218. #ifdef BSD43_DRIVER
  219.     ether_attach ( (struct ifnet *)&es->es_if, unit, "med",
  220.   medInit, medIoctl, medOutput, (FUNCPTR) medReset);
  221. #else
  222.     ether_attach (
  223.                  &es->es_if,
  224.                  unit, 
  225.                  "med",
  226.  (FUNCPTR) medInit, 
  227.                  (FUNCPTR) medIoctl, 
  228.                  (FUNCPTR) ether_output, 
  229.                  (FUNCPTR) medReset
  230.                  );
  231.     es->es_if.if_start = (FUNCPTR)medStartOutput;
  232. #endif
  234.     medIntEnable (TRUE);      /* enable the DB-ETH interrupt */
  236.     medInit (unit);
  238.     return (OK);
  239.     }
  241. /*******************************************************************************
  242. *
  243. * medRecv - receive packet processing
  244. *
  245. * Process Ethernet receive completion:
  246. * If input error, just drop packet. (This is handled in medRecvIntrHandler.)
  247. * Otherwise purge input buffered data path and examine
  248. * packet to determine type.  If can't determine length
  249. * from type, then have to drop packet.  Otherwise decapsulate
  250. * packet based on type and pass to type-specific higher-level
  251. * input routine.
  252. */
  254. LOCAL void medRecv
  255.     (
  256.     FAST struct med_softc *es,
  257.     FAST struct ether_header *eh,   /* ether header followed by packet data */
  258.     int len
  259.     )
  260.     {
  261.     FAST struct mbuf       *m;
  262.     FAST u_char       *pData;
  263.     int                off;
  266.     es->es_if.if_ipackets++;
  268.     /* call input hook if any */
  270.     if (etherInputHookRtn != NULL &&
  271. (*etherInputHookRtn) (&es->es_if, (char *) eh, len))
  272. {
  273. return; /* input hook has already processed this packet */
  274. }
  276. #ifdef BSD43_DRIVER
  278.     /* This legacy code is not correct for the BSD 4.4 stack. It would
  279.      * also treat multicast addresses like alien packets, and not send
  280.      * them up the stack. The higher-level protocols in the new stack
  281.      * can handle these addresses, and will discard them if they do not
  282.      * match an existing multicast group.
  283.      */
  285.     /* do software filter if controller is in promiscuous mode */
  287.     if (es->bPromisc)
  288. {
  289. if ((bcmp ((char *) eh->ether_dhost, /* not our adrs? */
  290.      (char *) es->es_enaddr,
  291.      sizeof (eh->ether_dhost)) != 0) &&
  292.     (bcmp ((char *) eh->ether_dhost, /* not broadcast? */
  293.      (char *) etherbroadcastaddr,
  294.      sizeof (eh->ether_dhost)) != 0))
  295.     {
  296.     return; /* not for us */
  297.     }
  298. }
  299. #endif
  301.     if (len >= sizeof (struct ether_header))
  302.         len -= sizeof (struct ether_header);
  303.     else
  304.         len = 0;
  306.     pData = ((u_char *) eh) + (sizeof (struct ether_header));
  308. #ifdef BSD43_DRIVER
  309.     /*
  310.      * Deal with trailer protocol: if type is trailer
  311.      * get true type from first 16-bit word past data.
  312.      * Remember that type was trailer by setting off.
  313.      */
  315.     check_trailer (eh, pData, &len, &off, &es->es_if);
  317.     if (len == 0)
  318.         return; /* sanity */
  319. #endif
  321.     m = copy_to_mbufs (pData, len, off, (struct ifnet *) &es->es_if);
  323.     if (m == NULL)
  324.         {
  325.         es->es_if.if_ierrors++;
  326. return;
  327.         }
  329. #ifdef BSD43_DRIVER
  330.     do_protocol_with_type (eh->ether_type, m, &es->es_ac, len);
  331. #else
  332.     do_protocol (eh, m, &es->es_ac, len);
  333. #endif
  335.     return;
  336.     }
  338. /*******************************************************************************
  339. *
  340. * medGetRecvPacket - return the address of the next packet received
  341. *
  342. * If a packet is available in the NIC receive buffer, return its address.
  343. * Otherwise, return NULL.
  344. */
  346. LOCAL nic_RecvHdr_s *medGetRecvPacket
  347.     (
  348.     FAST struct med_softc  *es
  349.     )
  350.     {
  351.     FAST u_char          currNIC_WritePage;
  352.     FAST NIC_DEVICE     *pNIC = es->nicAddr;
  353.     FAST int             oldLevel;
  355.     /*
  356.      * Select NIC register page 1, and retrieve the CURR register,
  357.      * re-select NIC register page 0.
  358.      */
  360.     oldLevel = intLock();
  361.     pNIC->Cr = (u_char) (RPAGE1 | ABORT | STA);
  363.     currNIC_WritePage = pNIC->Curr;
  365.     pNIC->Cr = (u_char) (RPAGE0 | ABORT | STA);
  366.     intUnlock (oldLevel);
  368.     if (es->pktNextToRead == currNIC_WritePage)  /* No new packets. */
  369.         {
  370.         return ((nic_RecvHdr_s *) NULL);
  371.         }
  373.     return ((nic_RecvHdr_s *) NIC_RECV_BFR_ADRS (es->pktNextToRead));
  374.     }
  376. /*******************************************************************************
  377. *
  378. * medRecvIntrHandler - task level interrupt service for input packets
  379. *
  380. * This routine is called at task level indirectly by the interrupt
  381. * service routine to do any message received processing.
  382. */
  384. LOCAL void medRecvIntrHandler
  385.     (
  386.     FAST struct med_softc  *es
  387.     )
  388.     {
  389.     FAST nic_RecvHdr_s  *pRecvPacket;
  390.     FAST u_char          recvStatus;
  391.     FAST u_long          pktSize;
  392.     FAST NIC_DEVICE     *pNIC = es->nicAddr;
  394.     if (es->bRecvBfrOvfl)  /* Ignore packets on receive buffer overflow; */
  395.         return;            /* they all will be dropped.                  */
  397.     while (TRUE)
  398.         {
  399.         while ((pRecvPacket = medGetRecvPacket (es)) != (nic_RecvHdr_s *) NULL)
  400.             {
  401.             if (es->bRecvBfrOvfl)
  402.                 return;
  404.             recvStatus = pRecvPacket->recvStatus;
  405.             if  ((recvStatus & PRX) == nic_RECV_NO_ERROR)
  406.                 {
  407.                 pktSize = (u_long) pRecvPacket->byteCntL
  408.                         | (u_long) (pRecvPacket->byteCntH << 8);
  410.                 /*
  411.                  * If the packet is wrapped around in the receive buffer,
  412.                  * move it to a contiguous buffer.
  413.                  */
  415.                 if (((u_long) pRecvPacket + pktSize) > (u_long) END_OF_RECV_BFR)
  416.                     {
  417.                     medMoveWrappedPacket (es, pRecvPacket, pktSize);
  418.                     medRecv (es, &(es->pOvfRecvBfr->eh), (int) pktSize);
  419.                     }
  420.                 else
  421.                     medRecv (es, &(pRecvPacket->eh), (int) pktSize);
  423.                 es->pktNextToRead = pRecvPacket->nextPkt;
  425.                 /*
  426.                  * Ensure that the "boundry" register is maintained one page
  427.                  * behind the "current"  register.
  428.                  */
  430.                 if (es->pktNextToRead ==
  431.     ((u_char) ((u_short) dbeth_NIC_RECV_BFR) >> 8))
  432.     {
  433.                     pNIC->Bnry = PSTOP - 1;
  434.     }
  435.                 else
  436.                     pNIC->Bnry = es->pktNextToRead - 1;
  437.                 }
  438.             else
  439.                 {
  440.                 if ((recvStatus & DIS) == nic_RCVR_DISABLED)
  441.                    logMsg("med%d: receiver disabledn",
  442. es->es_if.if_unit, 0,0,0,0,0);
  444.                 if ((recvStatus & DFR) == nic_RCVR_DEFERRING)
  445.                    logMsg("med%d: receiver deferringn", 
  446. es->es_if.if_unit, 0,0,0,0,0);
  447.                 }
  449.             }   /* while ((pRecvPacket ... */
  451.         if (pNIC->Isr & PRX)           /* pending recv interrupt ?   */
  452.             {
  453.             pNIC->Isr = PRX;           /* clear interrupt flag       */
  454.             med_Stats.PRX_intrCount++; /* update statistics monitor  */
  455.             }
  456.         else if (pNIC->Isr & RXE)      /* pending recv error interrupt ? */
  457.             {
  458.             pNIC->Isr = RXE;           /* clear interrupt flag       */
  459.             medRecordRecvError (es);
  460.             }
  461.         else
  462.             {                          /* no recv interrupt          */
  463.             /* Re-enable PRX and RXE interrupts. */
  464.             medSetNIC_IMR (es,  nic_PKT_RECV_NO_ERRORS
  465.                               | nic_PKT_RECV_ERROR, MASK_NONE);
  466.             break; /* break from while (TRUE) */
  467.             }
  469.         }       /* while (TRUE)            */
  470.     }
  472. /*******************************************************************************
  473. *
  474. * medIoctl - process an ioctl request.
  475. */
  477. LOCAL int medIoctl
  478.     (
  479.     FAST struct ifnet *ifp,
  480.     int cmd,
  481.     caddr_t data
  482.     )
  483.     {
  484.     int  unit  = ifp->if_unit;
  485.     FAST struct med_softc *  es = med_softc [unit];
  486.     int  s     = splimp ();
  487.     int  error = 0;
  488.     short  flags;
  490.     switch (cmd)
  491. {
  492. case SIOCSIFADDR:
  493.             ((struct arpcom *)ifp)->ac_ipaddr = IA_SIN (data)->sin_addr;
  494.             arpwhohas (ifp, &IA_SIN (data)->sin_addr);
  495.     break;
  497. case SIOCGIFADDR:
  498.     bcopy((caddr_t) es->es_enaddr,
  499.   (caddr_t) ((struct ifreq *) data)->ifr_addr.sa_data, 6);
  500.     break;
  502. case SIOCGIFFLAGS:
  503.     *(short *) data = ifp->if_flags;
  504.     break;
  506. case SIOCSIFFLAGS:
  507.     {
  508.             flags = ifp->if_flags;
  510. #ifdef BSD43_DRIVER
  511.     if (ifp->if_flags & IFF_PROMISC)
  512.         es->bPromisc = TRUE;
  513.     else
  514.         es->bPromisc = FALSE;
  515. #endif
  516.     if (ifp->if_flags & IFF_UP)
  517.         flags |= (IFF_UP | IFF_RUNNING);
  518.     else
  519.         flags &= ~(IFF_UP | IFF_RUNNING);
  521.     ifp->if_flags = flags;
  522.     }
  523.     break;
  525. default:
  526.     error = EINVAL;
  527. }
  529.     splx (s);
  530.     return (error);
  531.     }
  533. /*******************************************************************************
  534. *
  535. * medXmitIntrHandler - handler for transmit interrupts
  536. *
  537. */
  539. LOCAL void medXmitIntrHandler
  540.     (
  541.     FAST struct med_softc *es,
  542.     FAST u_char xmitStatus
  543.     )
  544.     {
  545.     FAST xmitQCB_s  * pXmitQCB = &(es->xmitQCB);
  546.     FAST XBIdx_t      headPkt;
  548.     /*
  549.      * The following flags indicate packet transmission error:
  550.      *
  551.      *   ABT - excess collisions, transmission was aborted
  552.      *   FU  - NIC FIFO underrun, transmission was aborted (should never occur)
  553.      *
  554.      * Retransmit the packet.
  555.      *
  556.      * The following flags indicate a collision occurred but the packet
  557.      * was eventually transmitted.
  558.      *
  559.      *   CRS - carrier lost (lost due to a collision)
  560.      *   OWC - out-of-window-collision
  561.      *
  562.      */
  563.     if (xmitStatus & (ABT | FU))
  564.         {
  565.         es->es_if.if_oerrors++;            /* log transmit error */
  566.         if (xmitStatus & ABT)
  567.             {
  568.             med_Stats.excessColl++;        /* update statistics monitor */
  569.     logMsg("med%d: ERROR - excessive collisions, transmission abortedn"
  570.                    , es->es_if.if_unit, 0,0,0,0,0);
  571.             }
  572.         if (xmitStatus & FU)
  573.             {
  574.             med_Stats.FIFO_UdrRun++;       /* update statistics monitor */
  575.             logMsg("med%d: ERROR - NIC FIFO underrun, transmission abortedn",
  576.                    es->es_if.if_unit, 0,0,0,0,0);
  577.             }
  579.         headPkt = pXmitQCB->head;
  580.         if (medXmitPacket (es,
  581.                            pXmitQCB->xmitBCB [headPkt].pPktBfr,
  582.                            pXmitQCB->xmitBCB [headPkt].pktLen) == ERROR)
  583.             logMsg("med%d: ERROR - NIC transmitter active, should be off.n",
  584.                    es->es_if.if_unit, 0,0,0,0,0);
  585.         }
  586.     else  /* no transmission error */
  587.         {
  588.         if (xmitStatus & CRS)
  589.             med_Stats.carrierLost++;      /* update statistics monitor */
  591.         if (xmitStatus & OWC)
  592.             med_Stats.outOfWndColl++;     /* update statistics monitor */
  594.         es->es_if.if_opackets++;          /* log packet output      */
  596.         pXmitQCB->xmitBCB [pXmitQCB->head].bPktRdy = FALSE;
  597.         medXmitBfrDealloc (pXmitQCB);     /* could be a macro        */
  598.         headPkt = pXmitQCB->head;         /* new head index after buf dealloc */
  600.         if (pXmitQCB->xmitBCB [headPkt].bPktRdy)
  601.             {
  602.             if (medXmitPacket (es,
  603.                                pXmitQCB->xmitBCB [headPkt].pPktBfr,
  604.                                pXmitQCB->xmitBCB [headPkt].pktLen) == ERROR)
  605.                 logMsg("med%d: ERROR - NIC transmitter active, should be off.n"
  606.        , es->es_if.if_unit, 0,0,0,0,0);
  607.             }
  608.         else
  609.             {
  610.             medXmtrUnlock (&(pXmitQCB->lockNIC_Xmtr));
  611.             if (es->es_if.if_snd.ifq_head != NULL) /* if packet(s) on queue   */
  612. #ifdef BSD43_DRIVER
  613.                 netJobAdd ( (FUNCPTR)medStartOutput, es->es_if.if_unit,
  614.                            0, 0, 0, 0);
  615. #else
  616.                 netJobAdd ( (FUNCPTR)medStartOutput, (int)es, 0, 0, 0, 0);
  617. #endif
  618.             }
  619.         }
  620.     }
  622. /*******************************************************************************
  623. *
  624. * medIntr - top level DB-ETH interrupt service routine
  625. */
  627. LOCAL void medIntr
  628.     (
  629.     FAST int unit
  630.     )
  631.     {
  632.     FAST u_char            intrStatus;
  633.     FAST struct med_softc *es   = med_softc [unit];
  634.     FAST NIC_DEVICE       *pNIC = es->nicAddr;
  636.     med_Stats.intrCount++;
  638.     /* retrieve interrupt status */
  640.     intrStatus = pNIC->Isr;
  642.     if (intrStatus & OVW)              /* overflow warning, no recv buffers */
  643.         {
  644.         medSetNIC_IMR (es, UNMASK_NONE,  nic_RECV_BFR_OVF_WARN
  645.                                        | nic_PKT_RECV_NO_ERRORS
  646.                                        | nic_PKT_RECV_ERROR);
  648.         es->bRecvBfrOvfl = TRUE;           /* flag for medRecvIntrHandler() */
  649.         intrStatus &= ~(OVW | PRX | RXE);  /* ignore these interrupts */
  650.         logMsg ("med%d: receive buffer overflow, all buffers cleared.n",
  651. unit, 0,0,0,0,0);
  652.         med_Stats.OVW_intrCount++;         /* update statistics monitor */
  653.         (void) netJobAdd (medInit, unit, 0,0,0,0);
  654.         }
  656.     if (intrStatus & PRX)              /* packet reception, no error */
  657.         {
  658.         /*
  659.          * Handle packet reception interrupts (with and without errors)
  660.          * at task level, until none remaining.
  661.          * Mask further PRX (nic_PKT_RECV_NO_ERRORS) interrupts.
  662.          * Mask further RXE (nic_PKT_RECV_ERROR) interrupts.
  663.          */
  665.         medSetNIC_IMR (es, UNMASK_NONE,  nic_PKT_RECV_NO_ERRORS
  666.                                        | nic_PKT_RECV_ERROR);
  667.         pNIC->Isr = PRX;               /* clear interrupt flag */
  668.         med_Stats.PRX_intrCount++;     /* update statistics monitor */
  669.         (void) netJobAdd ((FUNCPTR)medRecvIntrHandler, (int)es, 0,0,0,0);
  670.         }
  672.     if (intrStatus & PTX)              /* packet transmission, not aborted */
  673.         {
  674.         pNIC->Isr = PTX;               /* clear interrupt flag */
  675.         med_Stats.PTX_intrCount++;     /* update statistics monitor */
  676.         medXmitIntrHandler(es, pNIC->Tsr);
  677.         }
  679.     if (intrStatus & TXE)              /* packet transmission aborted */
  680.         {
  681.         pNIC->Isr = TXE;               /* clear interrupt flag       */
  682.         med_Stats.TXE_intrCount++;     /* update statistics monitor  */
  683.         medXmitIntrHandler(es, pNIC->Tsr);
  684.         }
  686.     if (intrStatus & RXE)              /* packet received with error(s) */
  687.         {
  688.         pNIC->Isr = RXE;               /* clear interrupt flag       */
  689.         medRecordRecvError (es);
  690.         }
  692.     if (intrStatus & CNT)              /* tally counter MSB set      */
  693.         {
  694.         pNIC->Isr = CNT;               /* clear interrupt flag       */
  695.         med_Stats.CNT_intrCount++;     /* update statistics monitor  */
  696.         (void) netJobAdd ((FUNCPTR)medReadTallyCntrs, (int)es,0,0,0,0);
  697.         }
  698.     }
  700. /*******************************************************************************
  701. *
  702. * medRecordRecvError - record packet reception errors
  703. */
  705. LOCAL void medRecordRecvError
  706.     (
  707.     FAST struct med_softc *es
  708.     )
  709.     {
  710.     med_Stats.RXE_intrCount++;     /* update statistics monitor  */
  712.     /*
  713.      * Packets received with errors are not saved. Therefore,
  714.      * es->pktNextToRead is not updated.
  715.      */
  717.     es->es_if.if_ierrors++;
  719.     /* log every medLogCount errors */
  721.     if (medLogCount > 0 && (es->es_if.if_ierrors % medLogCount) == 0)
  722.         logMsg ("med%d: receive errorn",
  723. es->es_if.if_unit,0,0,0,0,0);
  724.     }
  726. /*******************************************************************************
  727. *
  728. * medIntEnable - enables/disables the DB-ETH interrupt
  729. *
  730. */
  732. LOCAL void medIntEnable
  733.     (
  734.     BOOL bEnable
  735.     )
  736.     {
  737.     int oldLevel;
  739.     /*
  740.      * In an attempt to avoid spurious interrupts
  741.      * on Dbus interrupt disable...
  742.      */
  744.     if (!bEnable)
  745.         {
  746.         oldLevel = intLock ();
  747.         sysDbusEtherIntEnable (bEnable);
  748.         intUnlock (oldLevel);
  749.         }
  750.     else
  751.         sysDbusEtherIntEnable (bEnable);
  752.     }
  754. /*******************************************************************************
  755. *
  756. * medReset - reset the interface
  757. *
  758. * Mark interface as inactive and reset the NIC.
  759. */
  761. LOCAL void medReset
  762.     (
  763.     int unit
  764.     )
  765.     {
  766.     struct med_softc  *es   = med_softc [unit];
  767.     NIC_DEVICE        *pNIC = es->nicAddr;
  769.     es->es_if.if_flags &= ~IFF_RUNNING;
  771.     /*
  772.      * The following sequence is required when disabling the NIC from
  773.      * an active network. (This sequence was derived from the DP8390
  774.      * Datasheet Addendum, dated December, 1988, section 2.1.)
  775.      */
  777.     pNIC->Cr = RPAGE0 | STP | ABORT;
  779.     /* clear remote DMA byte count registers */
  781.     pNIC->Rbcr0 = 0;
  782.     pNIC->Rbcr1 = 0;
  784.     /* if the NIC not yet stopped, wait for approximately 2ms */
  786.     if ((pNIC->Isr & RST) != nic_STOP_MODE)
  787.         medNIC_AwaitStop (pNIC);
  788.     }
  790. /*******************************************************************************
  791. *
  792. * medInit - initialize NIC.
  793. *
  794. * Restart the NIC chip and mark the interface as up.
  795. *
  796. */
  798. LOCAL int medInit
  799.     (
  800.     int unit
  801.     )
  802.     {
  803.     struct med_softc *es  = med_softc [unit];
  804.     struct ifnet     *ifp = &es->es_if;
  806.     medIntEnable (FALSE);     /* disable DB-ETH interrupt */
  807.     ifp->if_flags &= ~(IFF_UP | IFF_RUNNING | IFF_PROMISC);
  809.     /* stop all operations, reset the NIC */
  811.     medReset (unit);
  813.     /* Clear all driver statistics on first initialization, but
  814.      * not on subsequent calls of medInit(), e.g. after receive
  815.      * buffer overflow.
  816.      */
  818.     if (es->bFirstInit)
  819.         {
  820.         bzero((char *) &med_Stats, sizeof (med_Stats));
  821.         es->bFirstInit = FALSE;
  822.         }
  824.     /* configure and start NIC operations */
  826.     medConfigNIC (unit);
  828.     /* initialize the NIC IMR shadow register */
  830.     es->currentIMR = NIC_INTERRUPTS_HANDLED;
  832.     /* flag for medRecvIntrHandler(), no receive buffer overflow */
  834.     es->bRecvBfrOvfl = FALSE;
  836.     /*
  837.      * Initialize the "next-packet-to-read" pointer.
  838.      * The NIC's remote DMA capability is not supported by the DB-ETH.
  839.      * Therefore, the BNRY register is not maintained by the NIC, and
  840.      * it must be maintained by software. However, BNRY must never
  841.      * equal CURR.
  842.      *
  843.      * pktNextToRead: This page pointer is required to determine where
  844.      * to retrieve the next received packet.
  845.      */
  847.     es->pktNextToRead = CURR;
  849.     /*
  850.      * Initialize the xmitQCB and xmitBfrCB structures.
  851.      */
  852.     {
  853.     xmitQCB_s *pXmitQCB = &(es->xmitQCB);
  854.     int        idx;
  856.     pXmitQCB->head   = 0;
  857.     pXmitQCB->tail   = 0;
  858.     pXmitQCB->bEmpty = TRUE;
  859.     pXmitQCB->bFull  = FALSE;
  861.     for (idx = 0; idx < NUM_XMIT_BFRS; idx++)
  862.         {
  863.         pXmitQCB->xmitBCB [idx].bPktRdy = FALSE;
  864.         pXmitQCB->xmitBCB [idx].pPktBfr
  865.              = (char *) (NIC_XMIT_BFR_ADRS + XMIT_BFR_SIZE * idx);
  866.         }
  868.     for (idx = 1; idx < NUM_XMIT_BFRS; idx++)
  869.         pXmitQCB->xmitBCB [idx - 1].next = idx;
  871.     /*
  872.      * Close the ring. Assign the next index parameter of the last buffer
  873.      * control block to the index of the first buffer control block in
  874.      * the ring.
  875.      */
  876.     pXmitQCB->xmitBCB [NUM_XMIT_BFRS - 1].next = 0;
  878.     /* allow access to the NIC transmitter */
  880.     medXmtrUnlock (&(pXmitQCB->lockNIC_Xmtr));
  881.     }
  883.     ifp->if_flags |= (IFF_UP | IFF_RUNNING);
  885. #ifdef BSD43_DRIVER
  886.     if (es->bPromisc)
  887. ifp->if_flags |= (IFF_PROMISC);
  888. #endif
  890.     medIntEnable (TRUE);
  892.     return (0);
  893.     }
  895. /*******************************************************************************
  896. *
  897. * bitReverse - reverse the position of the bits in a byte
  898. *
  899. */
  901. LOCAL u_char  bitReverse
  902.     (
  903.    u_char in
  904.     )
  905.     {
  906.     int    bit;
  907.     u_char fromBitMask;
  908.     u_char toBitMask;
  909.     u_char out = 0;
  911.     fromBitMask = 0x01;
  912.     toBitMask   = 0x80;
  914.     for (bit = 0; bit < 8; bit++)
  915. {
  916.         if (in & fromBitMask)
  917.             out |= toBitMask;
  918.         fromBitMask = fromBitMask << 1;
  919.         toBitMask   = toBitMask   >> 1;
  920. }
  922.     return (out);
  923.     }
  925. /*******************************************************************************
  926. *
  927. * medEthAddrGet - Get hardwired ethernet address from DB-ETH.
  928. *
  929. * Read the ethernet address out of the ROM, one byte at a time.
  930. * put it in med_softc
  931. *
  932. * INTERNAL
  933. * The DB-ETH prototype boards have the 8 data lines reversed to the
  934. * Ethernet address PROM. Using the assigned Ethernet address (1st 3
  935. * octets), this function determines if the data lines are reversed on
  936. * the DB-ETH board it is controling and makes the appropriate
  937. * conversion if necessary. Note that this function will fail if each
  938. * of the 3 octets are made-up of nybbles which are mirror images of
  939. * each other. For example, the following bytes (in hex):
  940. * 00, 81, 66, 99, E7, ... The third octet assigned to Matrix Corp.
  941. * is 0x0b. This octet in PROM will be determine whether to reverse
  942. * the data values.
  943. */
  945. LOCAL void medEthAddrGet
  946.     (
  947.     int unit
  948.     )
  949.     {
  950.     u_char             octet;
  951.     u_int              octetSel;
  952.     BOOL               bReversed;
  953.     struct  med_softc *es = med_softc [unit];
  954.     u_char            *pEthOctet = (u_char *) (ETH_ADRS_PROM_ADRS);
  956.     /* XXX optimize by saving result in static variable then just test var. ? */
  958.     bReversed = FALSE;
  959.     if (*(pEthOctet + 2) != 0x0b)
  960.         bReversed = TRUE;
  962.     for (octetSel = 0; octetSel < 6; octetSel++ )
  963.         {
  964.         octet = *pEthOctet;
  965.         if (bReversed)
  966.             octet = bitReverse (octet);
  967.         es->es_enaddr [octetSel] = octet;
  968.         pEthOctet++;
  969.         }
  970.     }
  972. /*******************************************************************************
  973. *
  974. * medConfigNIC - Configure the NIC for operation
  975. *
  976. * INTERNAL
  977. * This NIC initialization/configuration sequence was derived from the
  978. * DP8390 Datasheet Addendum, dated December, 1988, section 2.0. This
  979. * configuration enables the NIC onto an active network.
  980. */
  982. LOCAL void medConfigNIC
  983.     (
  984.     int unit
  985.     )
  986.     {
  987.     struct med_softc  *es   = med_softc [unit];
  988.     NIC_DEVICE        *pNIC = es->nicAddr;
  990.     /* get Ethernet address from ROM */
  992.     medEthAddrGet (unit);
  994.     /* stop/abort all NIC operations */
  996.     pNIC->Cr  = RPAGE0 | STP | ABORT;
  997.     pNIC->Dcr = FT2 | BMS | BOS | WTS;
  999.     /* clear remote DMA byte count registers */
  1001.     pNIC->Rbcr0  = 0;
  1002.     pNIC->Rbcr1  = 0;
  1004.     /* accept broadcast, but not runt and multicast packets */
  1006.     pNIC->Rcr = AB;
  1008.     /* configure for internal loopback mode */
  1010.     pNIC->Tcr = MODE1;
  1012.     /* initialize receive buffer pointers */
  1014.     pNIC->Bnry   = BNRY;
  1015.     pNIC->Pstart = PSTART;
  1016.     pNIC->Pstop  = PSTOP;
  1018.     /* clear the interrupt status */
  1020.     pNIC->Isr = RST | RDC | CNT | OVW | TXE | RXE | PTX | PRX;
  1022.     /* enable selected interrupts */
  1024.     pNIC->Imr = NIC_INTERRUPTS_HANDLED;
  1026.     /* select NIC page 1 registers */
  1027.     pNIC->Cr  = RPAGE1 | STP | ABORT;
  1029.     /* initialize the physical address, e.g. the Ethernet address */
  1031.     pNIC->Par0 = es->es_enaddr [0];
  1032.     pNIC->Par1 = es->es_enaddr [1];
  1033.     pNIC->Par2 = es->es_enaddr [2];
  1034.     pNIC->Par3 = es->es_enaddr [3];
  1035.     pNIC->Par4 = es->es_enaddr [4];
  1036.     pNIC->Par5 = es->es_enaddr [5];
  1038.     /*
  1039.      * Initialize the multicast address registers.
  1040.      *    CURRENTLY NOT SUPPORTED
  1041.      */
  1043.     /* initialize the next packet receive buffer pointer */
  1045.     pNIC->Curr = CURR;
  1047.     /* start NIC */
  1049.     pNIC->Cr = RPAGE0 | STA | ABORT;
  1051.     /* enable packet transmission */
  1053.     pNIC->Tcr = nic_NORMAL_XMIT_CTRL;
  1054.     }
  1056. #ifdef BSD43_DRIVER
  1057. /*******************************************************************************
  1058. *
  1059. * medOutput -
  1060. *
  1061. * Ethernet output routine.
  1062. * Encapsulate a packet of type family for the local net.
  1063. * Use trailer local net encapsulation if enough data in first
  1064. * packet leaves a multiple of 512 bytes of data in remainder.
  1065. */
  1067. LOCAL int medOutput
  1068.     (
  1069.     FAST struct ifnet   *ifp,
  1070.     FAST struct mbuf    *m0,
  1071.     struct sockaddr     *dst
  1072.     )
  1073.     {
  1074.     return (ether_output (ifp, m0, dst, (FUNCPTR) medStartOutput,
  1075.   &med_softc [ifp->if_unit]->es_ac));
  1076.     }
  1077. #endif
  1079. /*******************************************************************************
  1080. *
  1081. * medStartOutput - start pending output
  1082. *
  1083. * Start output to NIC.
  1084. * Queue up all pending datagrams for which transmit buffers are available.
  1085. * It is very important that this routine be executed with splimp set.
  1086. * If this is not done, another task could allocate the same transmit buffer.
  1087. */
  1088. #ifdef BSD43_DRIVER
  1089. LOCAL void medStartOutput
  1090.     (
  1091.     int unit
  1092.     )
  1093.     {
  1094.     FAST struct med_softc *  es = med_softc [unit];
  1095. #else
  1096. LOCAL void medStartOutput
  1097.     (
  1098.     struct med_softc *  es
  1099.     )
  1100.     {
  1101. #endif
  1102.     FAST struct mbuf   *m;
  1103.     FAST char   *buf;
  1104.     int    len;
  1105.     FAST xmitBCB_s        *pXmitBCB;
  1106.     int    s = splimp ();
  1107.     FAST xmitQCB_s  * pXmitQCB = &(es->xmitQCB);
  1108.     FAST XBIdx_t      headPkt  = pXmitQCB->head;
  1110.     while (es->es_if.if_snd.ifq_head != NULL)
  1111.         {
  1112. /* there is something to send */
  1114.         if ((pXmitBCB = medXmitBfrAlloc (es)) == (xmitBCB_s *) NULL)
  1115.             {
  1116.             med_Stats.noXmitBfrs++;
  1117.             es->es_if.if_oerrors++;
  1118.     break; /* no transmit buffers available */
  1119.     }
  1121.         buf  = pXmitBCB->pPktBfr;
  1123. /* get message to send */
  1125. IF_DEQUEUE (&es->es_if.if_snd, m); /* get head of next mbuf chain */
  1126. copy_from_mbufs (buf, m, len);
  1128. len = max (ETHERSMALL, len);
  1130.         pXmitBCB->pktLen  = (u_short)len;
  1131.         pXmitBCB->bPktRdy = TRUE;
  1133. /* call output hook if any */
  1135. if (etherOutputHookRtn != NULL &&
  1136.      (* etherOutputHookRtn) (&es->es_if, buf, len))
  1137.             continue;
  1139.         if (medXmtrLock (&(pXmitQCB->lockNIC_Xmtr)) != ERROR)
  1140.             {
  1141.             /*
  1142.              * Start transmission of the next packet on the xmitQ
  1143.              * unless the transmit interrupt handler has already
  1144.              * transmitted it.
  1145.              *
  1146.              * Lock mechanism  pXmitQCB->lockNIC_Xmtr is unlocked by
  1147.              * the transmit interrupt handler when all packets on
  1148.              * the xmitQ have been transmitted.
  1149.              */
  1150.             if (pXmitQCB->xmitBCB [headPkt].bPktRdy)
  1151.                 {
  1152.                 if (medXmitPacket (es, pXmitQCB->xmitBCB [headPkt].pPktBfr,
  1153.                                    pXmitQCB->xmitBCB [headPkt].pktLen)
  1154.                     == ERROR)
  1155.                     {
  1156.                     logMsg ("med%d: ERROR - NIC transmitter active, should 
  1157.                              be off.n", es->es_if.if_unit, 0, 0, 0, 0, 0);
  1158.                     }
  1159.                 }
  1160.             else
  1161.                 medXmtrUnlock (&(pXmitQCB->lockNIC_Xmtr));
  1162.             }
  1163.         /* opackets statistic is incremented elsewhere after interrupt */
  1164.         }
  1165.     splx (s);
  1166.     }
  1168. /*******************************************************************************
  1169. *
  1170. * medXmitBfrAlloc - allocate a NIC transmit buffer
  1171. *
  1172. * RETURNS: address of the NIC transmit buffer or NULL if none available
  1173. */
  1175. LOCAL xmitBCB_s   *medXmitBfrAlloc
  1176.     (
  1177.     struct med_softc  *es
  1178.     )
  1179.     {
  1180.     FAST xmitQCB_s *pXmitQCB = &(es->xmitQCB);
  1181.     FAST xmitBCB_s *pTailXBCB;
  1182.     int             oldLevel;
  1184.     if (pXmitQCB->bFull)
  1185.         return (xmitBCB_s *)NULL;
  1187.     /* block interrupt service routine access to xmitQCB */
  1189.     oldLevel = intLock();
  1191.     pXmitQCB->bEmpty = FALSE;
  1192.     pTailXBCB        = &(pXmitQCB->xmitBCB [pXmitQCB->tail]);
  1193.     pXmitQCB->tail   = pTailXBCB->next;
  1194.     if (pXmitQCB->head == pXmitQCB->tail)
  1195.         pXmitQCB->bFull = TRUE;
  1197.     intUnlock (oldLevel);
  1198.     return (pTailXBCB);
  1199.     }
  1201. /*******************************************************************************
  1202. *
  1203. * medXmitPacket - NIC packet transmission
  1204. *
  1205. * RETURNS: ERROR if NIC transmitter busy, otherwise OK
  1206. */
  1208. LOCAL STATUS   medXmitPacket
  1209.     (
  1210.     struct med_softc *es,
  1211.     char *pPacket,
  1212.     u_short packetLen
  1213.     )
  1214.     {
  1215.     NIC_DEVICE *pNIC = es->nicAddr;
  1217. #if defined (med_SAVE_XMIT_PKTS)
  1218.     static char *pXmitPktSaveBfr = (char *) 0xffd10000;
  1220.     /* check for possible buffer overrun */
  1222.     if (((u_long) pXmitPktSaveBfr + 1600) > 0xffd20000)
  1223. pXmitPktSaveBfr = (char *) 0xffd10000;
  1225.     bcopy (pPacket, pXmitPktSaveBfr, (int) packetLen);
  1226.     pXmitPktSaveBfr = pXmitPktSaveBfr + packetLen;
  1227.     bcopy ("$$$$$$$$$$$$$$$$", pXmitPktSaveBfr, 16);
  1228.     pXmitPktSaveBfr = pXmitPktSaveBfr + 16;
  1229. #endif /* med_SAVE_XMIT_PKTS */
  1231.     if ((pNIC->Cr & TXP) == nic_XMTR_BUSY)
  1232.         return (ERROR);
  1234.     pNIC->Tpsr  = nic_CPU_TO_NIC_ADRS (pPacket);
  1235.     pNIC->Tbcr1 = (u_char) (packetLen >> 8);
  1236.     pNIC->Tbcr0 = (u_char) packetLen;
  1237.     pNIC->Cr    = STA | TXP | ABORT;
  1239.     return (OK);
  1240.     }
  1242. /*******************************************************************************
  1243. *
  1244. * medStatsGet - output to stdout the med statictics
  1245. *
  1246. * NOMANUAL
  1247. */
  1249. void medStatsGet
  1250.     (
  1251.     int unit
  1252.     )
  1253.     {
  1254.     struct med_softc *es = med_softc [unit];
  1256.     medReadTallyCntrs (es);
  1258.     printf("med Statistics:n");
  1259.     printf("   packets received            : %ldn", es->es_if.if_ipackets);
  1260.     printf("   input errors                : %ldn", es->es_if.if_ierrors);
  1261.     printf("   packets transmitted         : %ldn", es->es_if.if_opackets);
  1262.     printf("   output errors               : %ldn", es->es_if.if_oerrors);
  1263.     printf("   packets on send queue       : %dn", es->es_if.if_snd.ifq_len);
  1264.     printf("   packets dropped (not xmit)  : %dn", es->es_if.if_snd.ifq_drops);
  1265.     printf("   xmit bufs full, xmit delayed: %ldn", med_Stats.noXmitBfrs);
  1266.     printf("   NIC total interrupts        : %ldn", med_Stats.intrCount);
  1267.     printf("   NIC PRX interrupts          : %ldn", med_Stats.PRX_intrCount);
  1268.     printf("   NIC PTX interrupts          : %ldn", med_Stats.PTX_intrCount);
  1269.     printf("   NIC RXE interrupts          : %ldn", med_Stats.RXE_intrCount);
  1270.     printf("   NIC TXE interrupts          : %ldn", med_Stats.TXE_intrCount);
  1271.     printf("   NIC OVW interrupts          : %ldn", med_Stats.OVW_intrCount);
  1272.     printf("   NIC CNT interrupts          : %ldn", med_Stats.CNT_intrCount);
  1273.     printf("   carrier lost on xmit        : %ldn", med_Stats.carrierLost);
  1274.     printf("   out of window collision     : %ldn", med_Stats.outOfWndColl);
  1275.     printf("   FIFO underrun               : %ldn", med_Stats.FIFO_UdrRun);
  1276.     printf("   excess collision            : %ldn", med_Stats.excessColl);
  1277.     printf("   frame alignment             : %ldn", med_Stats.frameAlign);
  1278.     printf("   CRC mismatch                : %ldn", med_Stats.misMatchCRC);
  1279.     printf("   missed packet               : %ldn", med_Stats.missedPkt);
  1280.     }
  1282. /*******************************************************************************
  1283. *
  1284. * medReadTallyCntrs - update local counters from NIC tally counters
  1285. *
  1286. */
  1288. LOCAL void medReadTallyCntrs
  1289.     (
  1290.     FAST struct med_softc *es
  1291.     )
  1292.     {
  1293.     NIC_DEVICE *pNIC = es->nicAddr;
  1295.     med_Stats.frameAlign  += pNIC->FaeErr;
  1296.     med_Stats.misMatchCRC += pNIC->CrcErr;
  1297.     med_Stats.missedPkt   += pNIC->MspErr;
  1298.     }
  1300. /*******************************************************************************
  1301. *
  1302. * medMoveWrappedPacket - move a wrapped packet in the NIC receive buffer
  1303. *
  1304. */
  1306. LOCAL void medMoveWrappedPacket
  1307.     (
  1308.     FAST struct med_softc  *es, /* for END_OF_RECV_BFR, NIC_RECV_BFR_ADRS */
  1309.     FAST nic_RecvHdr_s *pRecvPacket,
  1310.     FAST u_long pktSize
  1311.     )
  1312.     {
  1313.     FAST int    byteCount;
  1314.     FAST char  *pOvfRecvBfrMiddle;
  1316.     /* copy from start of packet to end of NIC receive buffer */
  1318.     byteCount = (int) ((u_long) END_OF_RECV_BFR - (u_long) pRecvPacket);
  1319.     bcopy ((char *) pRecvPacket, (char *) (es->pOvfRecvBfr), byteCount);
  1321.     /*
  1322.      * Copy remainder of packet from the base address of the NIC
  1323.      * receive buffer to the current address in the buffer at
  1324.      * es->pOvfRecvBfr.
  1325.      */
  1327.     pOvfRecvBfrMiddle = (char *) ((u_long) (es->pOvfRecvBfr)
  1328. + (u_long) byteCount);
  1329.     byteCount = (int) pktSize - byteCount;
  1331.     bcopy ((char *) NIC_RECV_BFR_ADRS (0), pOvfRecvBfrMiddle, byteCount);
  1332.     }
  1334. /*******************************************************************************
  1335. *
  1336. * medSetNIC_IMR - mask/unmask interrupts in the NIC Interrupt Mask Register
  1337. *
  1338. * INTERNAL
  1339. * This NIC Interrupt Mask Register (IMR) is essentially write-only.
  1340. * The IMR in register page 2 cannot be accessed during normal
  1341. * operation.
  1342. */
  1344. LOCAL void medSetNIC_IMR
  1345.     (
  1346.     FAST struct med_softc *es,
  1347.     FAST u_char unmaskBits,
  1348.     FAST u_char maskBits
  1349.     )
  1350.     {
  1351.     FAST int          oldLevel;
  1352.     FAST NIC_DEVICE  *pNIC       = es->nicAddr;
  1353.     FAST u_char       currentIMR = es->currentIMR;
  1355.     oldLevel = intLock ();
  1357.     /*
  1358.      * This kludge is to ensure that the PRX and RXE interrupts are not
  1359.      * enabled (in task medRecvIntrHandler) after an OVW interrupt.
  1360.      */
  1362.     if (es->bRecvBfrOvfl)
  1363.         unmaskBits &= ~(nic_PKT_RECV_NO_ERRORS | nic_PKT_RECV_ERROR);
  1365.     currentIMR     = (currentIMR | unmaskBits) & (~maskBits);
  1366.     es->currentIMR = currentIMR;
  1367.     pNIC->Imr      = currentIMR;
  1369.     intUnlock (oldLevel);
  1370.     }
  1372. /*******************************************************************************
  1373. *
  1374. * medNIC_AwaitStop - busy-wait 2ms or until the NIC stops
  1375. */
  1377. LOCAL void medNIC_AwaitStop
  1378.     (
  1379.     FAST NIC_DEVICE *pNIC
  1380.     )
  1381.     {
  1382.     FAST int   ticksIn2ms;
  1383.     FAST ULONG tickStartCount = tickGet ();
  1385.     /*
  1386.      * Wait for NIC to complete current operation.
  1387.      * Determine the number of clock ticks in 2ms...
  1388.      * Divide the ticks/second value returned by sysClkRateGet ()
  1389.      * by 512. (Note that 512 is approximately 500. Thus, shifting
  1390.      * by 9 is as if multiplying by approximately 0.002)
  1391.      */
  1393.     ticksIn2ms = sysClkRateGet () >> 9;
  1394.     if (ticksIn2ms == 0)
  1395.         ticksIn2ms = 1;
  1397.     while ((pNIC->Isr & RST) != nic_STOP_MODE)
  1398.         if ((tickStartCount + ticksIn2ms) < tickGet ())
  1399.             break;
  1400.     }
  1402. /*******************************************************************************
  1403. *
  1404. * medXmitBfrDealloc - deallocate emptied transmit buffer(s)
  1405. *
  1406. * This routine must execute at interrupt level only.
  1407. */
  1408. LOCAL void medXmitBfrDealloc
  1409.     (
  1410.     FAST xmitQCB_s  *pXmitQCB
  1411.     )
  1412.     {
  1414.     if (pXmitQCB->bEmpty)
  1415.         {
  1416.         logMsg("med: ERROR - transmit buffer deallocation failed.n",
  1417. 0,0,0,0,0,0);
  1418.         return;
  1419.         }
  1421.     pXmitQCB->bFull = FALSE;
  1422.     pXmitQCB->head  = pXmitQCB->xmitBCB [pXmitQCB->head].next;
  1423.     if (pXmitQCB->head == pXmitQCB->tail)
  1424.         pXmitQCB->bEmpty = TRUE;
  1425.     }
  1427. /*******************************************************************************
  1428. *
  1429. * medXmtrLock - lock access to the NIC transmitter
  1430. *
  1431. * This function must only be invoked by tasks executing with splimp.
  1432. * Otherwise, a race condition is possible during the LOCKED test.
  1433. *
  1434. * RETURNS: ERROR if already locked, OK otherwise
  1435. */
  1436. LOCAL STATUS medXmtrLock
  1437.     (
  1438.     FAST lockID_t *pLock
  1439.     )
  1440.     {
  1441.     FAST int oldLevel;
  1443.     if (*pLock == LOCKED)
  1444.         return ERROR;
  1446.     oldLevel = intLock ();
  1447.     *pLock = LOCKED;
  1448.     intUnlock (oldLevel);
  1450.     return (OK);
  1451.     }
  1453. /*******************************************************************************
  1454. *
  1455. * medXmtrUnlock - unlock access to the NIC transmitter
  1456. *
  1457. */
  1458. LOCAL void medXmtrUnlock
  1459.     (
  1460.     FAST lockID_t *pLock
  1461.     )
  1462.     {
  1463.     *pLock = UNLOCKED;
  1464.     }