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

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

VxWorks

开发平台：

C/C++

if_nic.c：源码内容
  1. /* if_nic.c - National Semiconductor SNIC Chip (for HKV30) network interface driver */
  3. /* Copyright 1984-1997 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 02b,15jul97,spm  added ARP request to SIOCSIFADDR ioctl handler
  10. 02a,07apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  11. 01z,11aug93,jmm  Changed ioctl.h and socket.h to sys/ioctl.h and sys/socket.h
  12. 01y,19feb93,jdi  documentation cleanup.
  13. 01x,15oct92,rfs  Added documentation.
  14. 01w,02oct92,rfs  Made multiple attach calls per unit return OK.
  15. 01v,09sep92,gae  documentation tweaks.
  16. 01u,02sep92,ajm  added conditional compilation for __STDC__ (DEC)
  17. 01t,18aug92,rfs  Revised to follow style of other drivers.
  18.                  Added cache support.  Reworked OVW error recovery.
  19. 01s,23jun92,ajm  fixed ansi warnings for pktBufRead calls
  20.                  went back and fixed all 68k ansi warnings
  21. 01r,26may92,rrr  the tree shuffle
  22.                  -changed includes to have absolute path from h/
  23. 01q,26may92,ajm  got rid of HOST_DEC def's (new compiler)
  24.                  updated copyright
  25. 01p,10oct91,rfs  modified pktBufRead() & pktBufWrite() to return if len is zero
  26. 01o,04oct91,rrr  passed through the ansification filter
  27.                  -changed functions to ansi style
  28.                  -changed includes to have absolute path from h/
  29.                  -changed VOID to void
  30.                  -changed copyright notice
  31. 01n,28sep91,ajm  ifdef'd HOST_DEC for compiler problem
  32. 01m,02Aug91,rfs  cleanup of transmit design, int handler, NIC command register
  33.                  was being handled incorrectly, DMA operations required
  34.                  semaphoring and error checking, changed names, deleted
  35.                  nicdelay(), deleted excessive include files. Provided correct
  36.                  OVW recovery.  Your basic rewrite.
  37. 01l,01may91,elh  fixed transmit buffering problems, added changes from
  38.                  heurikon, removed DMAState, XmtByteCount.
  39. 01k,20sep90,dab  made nicInit() return int.
  40. 01j,10aug90,dnw  added forward declarations of void routines.
  41.                  added include of if_subr.h.
  42. 01i,11jul90,hjb  removed code that uses gotIp.  made nicRead() a void function.
  43.                  changed references to do_protocol() to use
  44.                  do_protocol_with_type().
  45. 01h,19apr90,hjb  deleted param.h, de-linted.
  46. 01g,18mar90,hjb  reduction of redundant code and addition of cluster support.
  47.                  added error recording (TXE, RXE), removed unnecessary
  48.                  error handler which didn't do anything.  delinted.
  49. 01f,18sep89,cwp  added multiple transmit buffer support
  50. 01e,14sep89,dab  changed iv68k.h to iv.h.
  51. 01d,15jun89,cwp  fixed ring buffer overflow and transmit errors.
  52. 01c,04apr89,cwp  first working version.
  53. 01b,25feb89,cwp  added changes from unix driver.
  54. 01a,12jan89,cwp  written.
  55. */
  57. /*
  58. This module implements the National Semiconductor 83901 SNIC Ethernet network 
  59. interface driver.
  61. This driver is non-generic and is for use on the Heurikon HKV30 board.  
  62. Only unit number zero is supported.  The driver must be given several 
  63. target-specific parameters.  These parameters, and the mechanisms 
  64. used to communicate them to the driver, are detailed below.
  66. BOARD LAYOUT
  67. This device is on-board.  No jumpering diagram is necessary.
  69. EXTERNAL INTERFACE
  70. This driver provides the standard external interface with the following
  71. exceptions.  All initialization is performed within the attach routine; there
  72. is no separate initialization routine.  Therefore, in the global interface
  73. structure, the function pointer to the initialization routine is NULL.
  75. The only user-callable routine is nicattach(), which publishes the `nic'
  76. interface and initializes the driver and device.
  78. TARGET-SPECIFIC PARAMETERS
  79. .iP "device I/O address"
  80. This parameter is passed to the driver by nicattach().
  81. It specifies the base address of the device's I/O register
  82. set.
  83. .iP "interrupt vector"
  84. This parameter is passed to the driver by nicattach().
  85. It specifies the interrupt vector to be used by the driver
  86. to service an interrupt from the SNIC device.  The driver will connect
  87. the interrupt handler to this vector by calling intConnect().
  88. .LP
  90. SYSTEM RESOURCE USAGE
  91. When implemented, this driver requires the following system resources:
  93.     - one mutual exclusion semaphore
  94.     - one interrupt vector
  95.     - 0 bytes in the initialized data section (data)
  96.     - 1702 bytes in the uninitialized data section (BSS)
  98. The above data and BSS requirements are for the MC68020 architecture 
  99. and may vary for other architectures.  Code size (text) varies greatly between
  100. architectures and is therefore not quoted here.
  102. The HKV30 provides a private buffer for all packets transmitted and received.
  103. Thus, the driver does not require any system memory to share with the
  104. device.  This also eliminates all data cache coherency issues.
  106. SEE ALSO: ifLib
  107. */
  109. #include "vxWorks.h"
  110. #include "iv.h"
  111. #include "stdlib.h"
  112. #include "intLib.h"
  113. #include "netLib.h"
  114. #include "net/mbuf.h"
  115. #include "sys/ioctl.h"
  116. #include "errno.h"
  117. #include "net/if.h"
  118. #include "net/unixLib.h"
  119. #include "net/if_subr.h"
  120. #include "netinet/in_var.h"
  121. #include "netinet/if_ether.h"
  122. #include "etherLib.h"
  123. #include "semLib.h"
  124. #include "cacheLib.h"
  125. #include "drv/netif/if_nic.h"
  126. #include "drv/dma/we32104.h"
  129. /***** LOCAL DEFINITIONS *****/
  131. #define MAX_UNITS      1                     /* max number of units supported */
  132. #define NIC_DCR_CS      DCR_CS_2                /* device #2 on DMAC PBUS */
  133. #define NIC_DCR_PA      0x60                    /* device addr on DMAC PBUS */
  135. /* Typedefs for external structures that are not typedef'd in their .h files */
  137. typedef struct mbuf MBUF;
  138. typedef struct arpcom IDR;                  /* Interface Data Record wrapper */
  139. typedef struct ifnet IFNET;                 /* real Interface Data Record */
  140. typedef struct sockaddr SOCK;
  141. typedef struct ether_header ETH_HDR;
  143. #ifdef BSD43_DRIVER
  144. #define ENET_HDR_REAL_SIZ   14
  145. #endif
  147. typedef struct rx_hdr
  148.     {
  149.     u_char status;                              /* status of packet */
  150.     u_char nextRxPage;                          /* page next pkt starts at */
  151.     u_char cntL;                                /* low byte of frame length */
  152.     u_char cntH;                                /* high byte of frame length */
  153.     } RX_HDR;
  154. #define RX_HDR_SIZ      sizeof(RX_HDR)
  156. typedef struct rx_frame
  157.     {
  158.     RX_HDR rxHdr;                               /* the receive status header */
  159.     ETH_HDR enetHdr;                            /* the Ethernet header */
  160.     u_char data [ETHERMTU];                     /* the data */
  161.     u_long fcs;
  162.     } RX_FRAME;
  163. #define RX_FRAME_SIZ        sizeof(RX_FRAME)
  165. typedef struct tx_desc
  166.     {
  167.     volatile BOOL ready;                        /* ready for transmission */
  168.     unsigned short addr;                        /* addr in NIC buffer */
  169.     unsigned short len;                         /* length of packet */
  170.     struct tx_desc *next;                       /* link to next descriptor */
  171.     } TX_DESC;
  172. #define TX_DESC_SIZ     sizeof(TX_DESC)
  174. /* The driver control structure. */
  176. typedef struct drv_ctrl
  177.     {
  178.     IDR                 idr;                /* interface data record */
  180.     BOOL                attached;           /* indicates unit is attached */
  181.     int                 nicIntVec;          /* interrupt vector */
  182.     SEM_ID              dmaSem;             /* exclusive use of DMA units */
  183.     u_char              NextPkt;            /* NIC buf page for next pkt */
  184.     volatile BOOL       dmaWait;            /* waiting for DMA completion */
  185.     volatile BOOL       taskRcvActive;      /* indicates netTask in use */
  186.     NIC_DEVICE          *nicAddr;           /* address of NIC chip */
  187.     volatile TX_DESC    *pTxActive;         /* ptr to Tx desc in use */
  188.     TX_DESC             *pTxNext;           /* ptr to next Tx desc to use */
  189.     TX_DESC             txDesc [MAXXMT];    /* array of Tx descriptors */
  190.     RX_FRAME            rxFrame;            /* storage for one Rx frame */
  191.     } DRV_CTRL;
  193. #define DRV_CTRL_SIZ       sizeof(DRV_CTRL)
  195. /* array of driver control structs, one per unit supported */
  196. LOCAL DRV_CTRL drvCtrl [MAX_UNITS];
  199. /* forward static functions */
  201. static void nicReset (int unit);
  202. static void nicIntr (int unit);
  203. static void nicRestart (int unit);
  204. static void nicHandleInt (DRV_CTRL *pDrvCtrl);
  205. static BOOL nicRead (DRV_CTRL *pDrvCtrl);
  206. #ifdef BSD43_DRIVER
  207. static int nicOutput (IDR *pIDR, MBUF *pMbuf, SOCK *pDest);
  208. #else
  209. static int nicTxStartup (DRV_CTRL *pDrvCtrl);
  210. #endif
  211. static int nicIoctl (IDR *pIDR, int cmd, caddr_t data);
  212. static void nicEnetAddrGet (int unit);
  213. static void nicConfig (int unit);
  214. static STATUS pktBufWrite (DRV_CTRL *pDrvCtrl, u_long nicBufAddr,
  215.                            u_long len, char *pData);
  216. static STATUS pktBufRead (DRV_CTRL *pDrvCtrl, u_long nicBufAddr,
  217.                           u_long len, char *pData);
  218. #ifdef BSD43_DRIVER
  219. static BOOL convertDestAddr (IDR *pIDR, SOCK *pDestSktAddr,
  220.                              char *pDestEnetAddr, u_short *pPacketType,
  221.                              MBUF *pMbuf);
  222. #endif
  225. /*******************************************************************************
  226. *
  227. * nicattach - publish the `nic' network interface and initialize the driver and device
  228. *
  229. * This routine publishes the `nic' interface by filling in a network interface
  230. * record and adding this record to the system list.  It also
  231. * initializes the driver and the device to the operational state.
  232. *
  233. * RETURNS: OK or ERROR.
  234. */
  236. STATUS nicattach
  237.     (
  238.     int unit,                                 /* unit number */
  239.     NIC_DEVICE *pNic,                         /* address of NIC chip */
  240.     int ivec                                  /* interrupt vector to use */
  241.     )
  242.     {
  243.     int         temp;
  244.     int         loopy;
  245.     WE32104     *pDmac;
  246.     DRV_CTRL    *pDrvCtrl;
  249.     /* Sanity check the unit number */
  251.     if (unit < 0 || unit >= MAX_UNITS)
  252.         return (ERROR);
  254.     /* Ensure single invocation per system life */
  256.     pDrvCtrl = & drvCtrl [unit];
  257.     if (pDrvCtrl->attached)
  258.         return (OK);
  260.     pDrvCtrl->dmaSem = semBCreate(SEM_Q_FIFO, SEM_FULL);
  261.     pDrvCtrl->nicAddr = pNic;
  262.     pDrvCtrl->nicIntVec = ivec;
  264.     /* Publish the interface data record */
  266. #ifdef BSD43_DRIVER
  267.     ether_attach    (
  268.                     &pDrvCtrl->idr.ac_if,
  269.                     unit,
  270.                     "nic",
  271.                     (FUNCPTR) NULL,
  272.                     (FUNCPTR) nicIoctl,
  273.                     (FUNCPTR) nicOutput,
  274.                     (FUNCPTR) nicReset
  275.                     );
  276. #else
  277.     ether_attach (
  278.                  &pDrvCtrl->idr.ac_if,
  279.                  unit,
  280.                  "nic",
  281.                  (FUNCPTR) NULL,
  282.                  (FUNCPTR) nicIoctl,
  283.                  (FUNCPTR) ether_output, 
  284.                  (FUNCPTR) nicReset
  285.                  );
  286.     pDrvCtrl->idr.ac_if.if_start = (FUNCPTR)nicTxStartup;
  287. #endif
  289.     /*
  290.      * Fill in the Tx descriptors.
  291.      * Note that the address in the NIC buffer must be on a 256 byte boundary,
  292.      * since only the upper 8 bits are fed to the device when telling it
  293.      * to transmit.
  294.      */
  296.     for (loopy = 0; loopy < MAXXMT; loopy++)
  297.         {
  298.         /* addr in NIC buf */
  299.         pDrvCtrl->txDesc[loopy].addr = XMTBUF + (loopy * 0x600);
  300.         /* point to next */
  301.         pDrvCtrl->txDesc[loopy].next = & pDrvCtrl->txDesc [loopy+1];
  302.         pDrvCtrl->txDesc[loopy].ready = FALSE;
  303.         }
  305.     pDrvCtrl->txDesc[MAXXMT-1].next = pDrvCtrl->txDesc;    /* point to first */
  307.     /* Connect the interrupt handler */
  309.     (void) intConnect (INUM_TO_IVEC (ivec), nicIntr, 0);
  311.     pDrvCtrl->pTxNext = pDrvCtrl->txDesc;          /* reset "next Tx" ptr */
  312.     pDrvCtrl->pTxActive = NULL;                    /* no active Tx desc */
  313.     pDrvCtrl->taskRcvActive = FALSE;               /* reset flag */
  314.     pDrvCtrl->NextPkt = CURR;                      /* reset to initial value */
  316.     /* The WE32104 controls all access to the peripheral buss. It allows the
  317.      * CPU "transparent" access to the devices on that buss. Before this
  318.      * access is allowed, the WE32104 must be told device control info. The
  319.      * following line sets up the channel 2 device control register to
  320.      * correctly access the NIC. These values are obtained from the HKV30
  321.      * manual.
  322.      */
  324.     pDmac = (WE32104 *) DMA_BASE;
  325.     pDmac->Ch2.DevControl = NIC_DCR_CS | NIC_DCR_PA;
  327.     pDmac->Mask = pDmac->Mask & ~MASK_CH2;      /* allow channel 2 requests */
  329.     temp = RESET_ON;                            /* Issue a hardware reset */
  330.     temp = RESET_OFF;                           /* release the reset */
  331.     temp = LED_OFF;                             /* the 'U' LED on XE module */
  333.     while (!(pNic->Isr & RST))                  /* wait for reset done */
  334.         ;
  336.     nicConfig (unit);                              /* configure the device */
  338.     /* Raise the interface flags */
  340.     pDrvCtrl->idr.ac_if.if_flags |= IFF_UP | IFF_RUNNING | IFF_NOTRAILERS;
  342.     /* Set our flag */
  344.     pDrvCtrl->attached = TRUE;
  346.     temp = LED_ON;                      /* turn XE module LED on */
  348.     return (OK);
  349.     }
  351. /*******************************************************************************
  352. *
  353. * nicReset - reset of interface
  354. */
  356. LOCAL void nicReset
  357.     (
  358.     int unit
  359.     )
  360.     {
  361.     int         temp;
  362.     DRV_CTRL    *pDrvCtrl;
  364.     pDrvCtrl = & drvCtrl [unit];
  365.     pDrvCtrl->idr.ac_if.if_flags = 0;
  366.     temp = RESET_ON;                            /* Issue a hardware reset */
  367.     temp = LED_OFF;                             /* the 'U' LED on XE module */
  369.     }
  371. /*******************************************************************************
  372. *
  373. * nicIntr - The driver's interrupt handler
  374. *
  375. * This function clears the cause of the device interrupt(s) and then acts
  376. * on the individual possible causes.  The primary goal of this routine is to
  377. * minimize the time spent in it.  This is accomplished by deferring processing
  378. * to the netTask via the netJobAdd() function.
  379. *
  380. * A secondary goal is to keep the transmitter working, if there are more
  381. * frames ready to be sent.  This is done examining flags set by the task level
  382. * code that indicates ready frames.  The transmitter is flagged as "idle" if
  383. * it appears that there are no frames ready to send.
  384. *
  385. * Note that in case the receiver overruns, we promptly mark the interface as
  386. * "down" and then leave only the RDC interrupt enabled.  This is in case netTask
  387. * is in the midst of DMA activity, we must allow it to complete.  The receive
  388. * handler will give up when it discovers the interface is down, which will
  389. * then allow netTask to run our OVW handler.  This provides a nice orderly
  390. * error recovery, even though the crummy NIC requires complete re-init.
  391. */
  393. LOCAL void nicIntr
  394.     (
  395.     int unit
  396.     )
  397.     {
  398.     DRV_CTRL *pDrvCtrl;
  399.     NIC_DEVICE *pNic;
  400.     TX_DESC *pTxDesc;
  401.     unsigned char isr;                            /* copy of ISR */
  402.     unsigned char tsr;                            /* copy of TSR */
  404.     pDrvCtrl = & drvCtrl [unit];
  405.     pNic = pDrvCtrl->nicAddr;
  407.     isr = pNic->Isr;                              /* copy the ISR */
  408.     pNic->Isr = isr;                              /* ACK all the ints */
  410.     /* handle receiver overrun */
  412.     if  (
  413.         (isr & OVW) &&
  414.         (pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING))
  415.         )
  416.         {
  417.         pNic->Imr = RDCE;                       /* disable all but RDC intrs */
  418.         pDrvCtrl->idr.ac_if.if_flags &=                 /* flag as down */
  419.             ~(IFF_UP | IFF_RUNNING | IFF_PROMISC);
  420.         /* Place our restart routine on the netTask queue */
  421.         netJobAdd ((FUNCPTR) nicRestart, unit, 0, 0, 0, 0);
  422.         return;                     /* no sense continuing */
  423.         }
  425.     /* handle packet Tx error */
  427.     if (isr & TXE)
  428.         {
  429.         pDrvCtrl->idr.ac_if.if_opackets--;
  430.         pDrvCtrl->idr.ac_if.if_oerrors++;
  431.         }
  433.     /* handle packet received */
  435.     if  ((isr & PRX) &&
  436.         (pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING)) &&
  437.         (!pDrvCtrl->taskRcvActive))
  438.         {
  439.         pDrvCtrl->taskRcvActive = TRUE;                 /* set flag */
  440.         /* defer to netTask */
  441.         netJobAdd ((FUNCPTR) nicHandleInt, (int) pDrvCtrl, 0, 0, 0, 0);
  442.         }
  444.     /* handle packet transmitted */
  446.     if  ((isr & PTX) &&
  447.         (pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING)) &&
  448.                                                 /* copy ptr, safety check it */
  449.         ((pTxDesc = (TX_DESC *) pDrvCtrl->pTxActive) != NULL))
  450.         {
  451.         tsr = pNic->Tsr;                          /* read Tx status reg */
  452.         pTxDesc->ready = FALSE;                   /* active pkt completed */
  454.         if (pTxDesc->next->ready)                 /* if next pkt ready to go */
  455.             {
  456.             pTxDesc = pTxDesc->next;              /* use next desc */
  457.             pDrvCtrl->pTxActive = pTxDesc;        /* update active ptr */
  458.             pNic->Tpsr = pTxDesc->addr >> 8;
  459.             pNic->Tbcr0 = pTxDesc->len & 0xff;
  460.             pNic->Tbcr1 = pTxDesc->len >> 8;
  462.             /* Start NIC transmitting. Note that since we could be doing
  463.              * a NIC remote DMA transfer at this time, we must maintain the
  464.              * state of these bits.
  465.              */
  466.             pNic->Cr = TXP | (pNic->Cr & (RREAD | RWRITE));
  467.             }
  468.         else
  469.             pDrvCtrl->pTxActive = NULL;             /* transmitter idle */
  471.         if (tsr & COL)                              /* collision */
  472.             pDrvCtrl->idr.ac_if.if_collisions++;
  473.         }
  475.     /* handle DMA complete */
  477.     if (isr & RDC)
  478.         pDrvCtrl->dmaWait = FALSE;                  /* clr the waiting flag */
  479.     }
  481. /*******************************************************************************
  482. *
  483. * nicRestart - restart the device after fatal error
  484. */
  486. LOCAL void nicRestart
  487.     (
  488.     int unit
  489.     )
  490.     {
  491.     int         temp;
  492.     int         loopy;
  493.     DRV_CTRL    *pDrvCtrl;
  494.     NIC_DEVICE  *pNic;                         /* address of device */
  496.     pDrvCtrl = & drvCtrl [unit];
  497.     pNic = pDrvCtrl->nicAddr;
  499.     /* The device has all interrupts disabled and the interface flags are down.
  500.      * Our job is to reset the device and our dynamic driver variables,
  501.      * bring the device back to life, and put the interface online.
  502.      */
  504.     temp = RESET_ON;                            /* Issue a hardware reset */
  505.     temp = RESET_OFF;                           /* release the reset */
  507.     /* Wait for device reset indication */
  509.     while ( ! (pNic->Isr & RST) )
  510.         ;
  512.     pNic->Cr = RPAGE0 | STP;                    /* select page 0 and stop */
  513.     pNic->Dcr = NOTLS | FIFO8;
  515.     pNic->Rbcr0 = 0;                /* clear remote DMA byte count registers */
  516.     pNic->Rbcr1 = 0;
  518.     for (loopy = 0; loopy < MAXXMT; loopy++)
  519.         pDrvCtrl->txDesc[loopy].ready = FALSE;
  521.     pDrvCtrl->pTxNext = pDrvCtrl->txDesc;          /* reset "next Tx" ptr */
  522.     pDrvCtrl->pTxActive = NULL;                    /* no active Tx desc */
  523.     pDrvCtrl->taskRcvActive = FALSE;               /* reset flag */
  524.     pDrvCtrl->NextPkt = CURR;                      /* reset to initial value */
  526.     pNic->Rcr = AB;         /* accept broadcast, but not runt or multicast */
  527.     pNic->Tcr = MODE1;                          /* internal loopback mode */
  529.     pNic->Pstart = PSTART;
  530.     pNic->Pstop  = PSTOP;
  531.     pNic->Bnry   = BNRY;
  533.     pNic->Cr   = RPAGE1;                        /* map in page 1 */
  534.     pNic->Par0 = pDrvCtrl->idr.ac_enaddr [0];
  535.     pNic->Par1 = pDrvCtrl->idr.ac_enaddr [1];
  536.     pNic->Par2 = pDrvCtrl->idr.ac_enaddr [2];
  537.     pNic->Par3 = pDrvCtrl->idr.ac_enaddr [3];
  538.     pNic->Par4 = pDrvCtrl->idr.ac_enaddr [4];
  539.     pNic->Par5 = pDrvCtrl->idr.ac_enaddr [5];
  540.     pNic->nic_pg1.mar0 = 0xff;
  541.     pNic->nic_pg1.mar1 = 0xff;
  542.     pNic->nic_pg1.mar2 = 0xff;
  543.     pNic->nic_pg1.mar3 = 0xff;
  544.     pNic->nic_pg1.mar4 = 0xff;
  545.     pNic->nic_pg1.mar5 = 0xff;
  546.     pNic->nic_pg1.mar6 = 0xff;
  547.     pNic->nic_pg1.mar7 = 0xff;
  548.     pNic->Curr = CURR;
  549.     pNic->Cr = RPAGE0;                          /* back to page 0 */
  551.     pNic->Tcr = MODE0;                          /* put Tx into normal mode */
  552.     pNic->Cr = STA;                             /* start the beast running */
  553.     pNic->Isr = 0xff;                           /* clr any pending ints */
  554.     pNic->Imr = PRXE|PTXE|TXEE|OVWE|RDCE;       /* enable these ints */
  556.     /* Raise the interface flags */
  558.     pDrvCtrl->idr.ac_if.if_flags |= IFF_UP | IFF_RUNNING | IFF_NOTRAILERS;
  560.     }
  562. /*******************************************************************************
  563. *
  564. * nicHandleInt - defered recv interrupt handler
  565. *
  566. * This function handles the received frames from the device.  It runs in the
  567. * context of the netTask, which was triggered by a received packet interrupt.
  568. */
  570. LOCAL void nicHandleInt
  571.     (
  572.     DRV_CTRL *pDrvCtrl
  573.     )
  574.     {
  576.     do
  577.         {
  578.         pDrvCtrl->taskRcvActive = TRUE;
  580.         while (nicRead (pDrvCtrl))            /* process a received frame */
  581.             ;
  583.         pDrvCtrl->taskRcvActive = FALSE;
  585.         } while (nicRead (pDrvCtrl));
  586.     }
  588. /*******************************************************************************
  589. *
  590. * nicRead - read a packet off the interface
  591. *
  592. * nicRead copies packets from local memory into an mbuf and hands it to
  593. * the next higher layer.
  594. */
  596. LOCAL BOOL nicRead
  597.     (
  598.     DRV_CTRL *pDrvCtrl
  599.     )
  600.     {
  601.     MBUF *m;
  602.     NIC_DEVICE *pNic;                      /* ptr to the NIC registers */
  603.     RX_FRAME *pRxFrame;                    /* ptr to our frame storage */
  604.     ETH_HDR *eh;                                /* ptr to enet hdr */
  605.     u_int len;                                  /* length of the enet pkt */
  606.     u_short curr;                               /* current page NIC using */
  607.     int oldLevel;
  609.     if (!(pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING)))
  610.         return (FALSE);
  612.     pNic = pDrvCtrl->nicAddr;
  613.     pRxFrame = &pDrvCtrl->rxFrame;
  614.     eh = &pRxFrame->enetHdr;
  616.     /*
  617.      * See if any unprocessed frames in NIC buffer. Unfortunately, there
  618.      * is no reliable way of doing this other than reading the CURR register.
  619.      * The NIC designers, in their infinite wisdom, put this register in
  620.      * page 1. To access page 1, we need to temporarily disable our interrupt
  621.      * handler.
  622.      */
  624.     oldLevel = intLock ();
  625.     pNic->Cr = RPAGE1;                              /* select page 1 */
  626.     curr = pNic->Curr;                              /* get current page */
  627.     pNic->Cr = RPAGE0;                              /* restore page 0 */
  628.     intUnlock (oldLevel);
  630.     if (pDrvCtrl->NextPkt == curr)             /* if NIC has not moved ahead */
  631.         return (FALSE);
  633.     pDrvCtrl->idr.ac_if.if_ipackets++;
  635.     /*
  636.      * OK, there is work to be done.
  637.      * First we copy the NIC receive status header from the NIC buffer
  638.      * into our local area. This is done so that we can obtain the length
  639.      * of the packet before copying out the rest of it. Note that the length
  640.      * field in the NIC header includes the Ethernet header, the data, and
  641.      * the 4 byte FCS field.
  642.      */
  644.     while   (
  645.             pktBufRead  (
  646.                         pDrvCtrl,
  647.                         pDrvCtrl->NextPkt << 8,
  648.                         RX_HDR_SIZ,
  649.                         (char *) pRxFrame
  650.                         )
  651.             == ERROR
  652.             )
  653.         ;
  655.     len = pRxFrame->rxHdr.cntL + (pRxFrame->rxHdr.cntH << 8) - 4 /* FCS */;
  657. #if 0   /* valid frame checks, for paranoia */
  658.     if  (
  659.         ((pRxFrame->rxHdr.status & ~PHY) != PRX) ||
  660.         (pRxFrame->rxHdr.nextRxPage < PSTART) ||
  661.         (pRxFrame->rxHdr.nextRxPage >= PSTOP) ||
  662.         (len < 60) || (len > 1514)
  663.         )
  664.         return (FALSE);
  665. #endif
  667.     /* copy Ethernet packet section of the frame */
  669.     while   (
  670.             pktBufRead  (
  671.                         pDrvCtrl,
  672.                         (pDrvCtrl->NextPkt << 8) + RX_HDR_SIZ,
  673.                         len,
  674.                         (char *) eh
  675.                         )
  676.             == ERROR
  677.             )
  678.         ;
  680.     /* done with frame in NIC buf, so update vars */
  682.     pDrvCtrl->NextPkt = pRxFrame->rxHdr.nextRxPage;/* where dev will use next */
  683.     pNic->Bnry = (pDrvCtrl->NextPkt == PSTART) ?   /* if dev is at beginning */
  684.                 (PSTOP - 1) :                     /* boundary is 1 before end */
  685.                 (pDrvCtrl->NextPkt - 1);           /* else it's 1 before next */
  687.     /* call input hook if any */
  689.     if (etherInputHookRtn != NULL)
  690.         if  ( (* etherInputHookRtn) (&pDrvCtrl->idr.ac_if, (char *)eh, len))
  691.             return (TRUE);
  693.     len -= sizeof (ETH_HDR);            /* now equals length of data only */
  695.     m = copy_to_mbufs   (
  696.                         pRxFrame->data,
  697.                         len,
  698.                         0,
  699.                         (IFNET *) & pDrvCtrl->idr.ac_if
  700.                         );
  702.     if (m != NULL)
  703. #ifdef BSD43_DRIVER
  704.         do_protocol_with_type (eh->ether_type, m, &pDrvCtrl->idr, len);
  705. #else
  706.         do_protocol (eh, m, &pDrvCtrl->idr, len);
  707. #endif
  708.     else
  709.         pDrvCtrl->idr.ac_if.if_ierrors++;
  711.     return (TRUE);
  712.     }
  714. #ifdef BSD43_DRIVER
  715. /*******************************************************************************
  716. *
  717. * nicOutput - the driver's output routine
  718. *
  719. * This function attempts to copy the data from the mbuf chain to the buffer
  720. * that NIC transmits from.  If successfull, and the NIC is not currently busy
  721. * transmitting, it then attempts to start the NIC transmitting.
  722. */
  724. LOCAL int nicOutput
  725.     (
  726.     IDR  *pIDR,
  727.     MBUF *pMbuf,
  728.     SOCK *pDest
  729.     )
  730.     {
  731.     int         unit;
  732.     int         oldLevel;
  733.     u_long      nicBufAddr;
  734.     MBUF        *pTempMbuf;
  735.     DRV_CTRL    *pDrvCtrl;
  736.     NIC_DEVICE  *pNic;
  737.     TX_DESC     *pTxNext;                   /* ptr to next desc to use */
  738.     ETH_HDR     enetHdr;                    /* space for the packet header */
  740.     /* init ptrs */
  742.     unit = pIDR->ac_if.if_unit;
  743.     pDrvCtrl = & drvCtrl [unit];
  744.     pNic = pDrvCtrl->nicAddr;          /* copy it, due to frequent use */
  747.     /* Check ifnet flags. Return error if incorrect. */
  749.     if  (
  750.         (pIDR->ac_if.if_flags & (IFF_UP | IFF_RUNNING)) !=
  751.         (IFF_UP | IFF_RUNNING)
  752.         )
  753.         {
  754.         m_freem (pMbuf);                /* release MBUFs */
  755.         return (ENETDOWN);
  756.         }
  758.     /* Attempt to convert socket addr into enet addr and packet type.
  759.      * Note that if ARP resolution of the address is required, the ARP
  760.      * module will call our routine again to transmit the ARP request
  761.      * packet.  This means we may actually call ourselves recursively!
  762.      */
  764.     if  (
  765.         convertDestAddr (
  766.                         pIDR,
  767.                         pDest,
  768.                         &enetHdr.ether_dhost,     /* fill our local header */
  769.                         &enetHdr.ether_type, /* fill our local header */
  770.                         pMbuf
  771.                         )
  772.         == FALSE
  773.         )
  774.         return (OK);
  776.     /* Get next transmit resource */
  778.     pTxNext = pDrvCtrl->pTxNext;        /* copy it, due to frequent use */
  779.     if (pTxNext->ready)                 /* if still in use */
  780.         {
  781.         m_freem (pMbuf);                /* release MBUFs */
  782.         return (ENETDOWN);
  783.         }
  785.     /* Fill in the source address of the Ethernet header */
  787.     bcopy ( (char *) pIDR->ac_enaddr, &enetHdr.ether_shost, 6 );
  789.     /* copy Ethernet header to NIC buffer */
  791.     nicBufAddr = pTxNext->addr;
  793.     while   (
  794.             pktBufWrite (
  795.                         pDrvCtrl,
  796.                         nicBufAddr,
  797.                         ENET_HDR_REAL_SIZ,
  798.                         (char *) & enetHdr
  799.                         )
  800.             == ERROR
  801.             )
  802.             ;
  804.     /* copy mbufs to NIC buffer */
  806.     pTempMbuf = pMbuf;                      /* copy head of MBUF chain */
  808.     for (
  809.         nicBufAddr += (u_long) ENET_HDR_REAL_SIZ;
  810.         pTempMbuf != NULL;
  811.         nicBufAddr += (u_long) pTempMbuf->m_len, pTempMbuf = pTempMbuf->m_next)
  812.         {
  813.         while
  814.             (
  815.             pktBufWrite (
  816.                         pDrvCtrl,
  817.                         nicBufAddr,
  818.                         pTempMbuf->m_len,
  819.                         mtod (pTempMbuf, caddr_t)
  820.                         )
  821.             == ERROR
  822.             )
  823.             ;
  824.         }
  826.     pTxNext->len = max (MINPKTSIZE, (nicBufAddr - pTxNext->addr));
  828.     m_freem (pMbuf);                       /* free the mbufs */
  830.     oldLevel = intLock ();                 /* keep our int handler out */
  832.     pTxNext->ready = TRUE;                 /* mark packet as "ready" */
  834.     if (pDrvCtrl->pTxActive == NULL)       /* if transmitter not active */
  835.         {
  836.         pDrvCtrl->pTxActive = pTxNext;           /* set active ptr */
  837.         pNic->Tpsr = pTxNext->addr >> 8;
  838.         pNic->Tbcr0 = pTxNext->len & 0xff;
  839.         pNic->Tbcr1 = pTxNext->len >> 8;
  840.         pNic->Cr = TXP;                    /* start NIC transmitting */
  841.         }
  843.     pDrvCtrl->pTxNext = pTxNext->next;     /* move ptr to next desc */
  845.     intUnlock (oldLevel);                  /* allow interrupts again */
  847.     /* Bump packet counter */
  849.     pIDR->ac_if.if_opackets++;
  851.     return (0);
  852.     }
  853. #else
  854. /*******************************************************************************
  855. *
  856. * nicTxStartup - the driver's output routine
  857. *
  858. * This function attempts to copy the data from the mbuf chain to the buffer
  859. * that NIC transmits from.  If successful, and the NIC is not currently busy
  860. * transmitting, it then attempts to start the NIC transmitting.
  861. */
  863. LOCAL int nicTxStartup
  864.     (
  865.     DRV_CTRL *  pDrvCtrl  /* pointer to driver control structure */
  866.     )
  867.     {
  868.     MBUF *  pMbuf;
  869.     int         oldLevel;
  870.     u_long      nicBufAddr;
  871.     MBUF        *pTempMbuf;
  872.     NIC_DEVICE  *pNic;
  873.     TX_DESC     *pTxNext;                   /* ptr to next desc to use */
  875.     pNic = pDrvCtrl->nicAddr;          /* copy it, due to frequent use */
  877.     /* Get next transmit resource */
  879.     while (pDrvCtrl->idr.ac_if.if_snd.ifq_head)
  880.         {
  881.         /* Dequeue a packet from the transmit queue. */
  882.  
  883.         IF_DEQUEUE (&pDrvCtrl->idr.ac_if.if_snd, pMbuf);
  885.         pTxNext = pDrvCtrl->pTxNext;        /* copy it, due to frequent use */
  886.         if (pTxNext->ready)                 /* if still in use */
  887.             {
  888.             m_freem (pMbuf);                /* release MBUFs */
  889.             pDrvCtrl->idr.ac_if.if_oerrors++;
  890.             break;
  891.             }
  893.         /* copy mbufs to NIC buffer */
  895.         pTempMbuf = pMbuf;                      /* copy head of MBUF chain */
  897.         nicBufAddr = pTxNext->addr;
  899.         while (pTempMbuf != NULL)
  900.             {
  901.             while (pktBufWrite (pDrvCtrl, nicBufAddr, pTempMbuf->m_len,
  902.                                 mtod (pTempMbuf, caddr_t))
  903.                    == ERROR)
  904.                 ;
  905.             nicBufAddr += (u_long) pTempMbuf->m_len;
  906.             pTempMbuf = pTempMbuf->m_next;
  907.             }
  909.         pTxNext->len = max (MINPKTSIZE, (nicBufAddr - pTxNext->addr));
  911.         m_freem (pMbuf);                       /* free the mbufs */
  913.         oldLevel = intLock ();                 /* keep our int handler out */
  915.         pTxNext->ready = TRUE;                 /* mark packet as "ready" */
  917.         if (pDrvCtrl->pTxActive == NULL)       /* if transmitter not active */
  918.             {
  919.             pDrvCtrl->pTxActive = pTxNext;           /* set active ptr */
  920.             pNic->Tpsr = pTxNext->addr >> 8;
  921.             pNic->Tbcr0 = pTxNext->len & 0xff;
  922.             pNic->Tbcr1 = pTxNext->len >> 8;
  923.             pNic->Cr = TXP;                    /* start NIC transmitting */
  924.             }
  926.         pDrvCtrl->pTxNext = pTxNext->next;     /* move ptr to next desc */
  928.         intUnlock (oldLevel);                  /* allow interrupts again */
  930.         /* Bump packet counter */
  932.         pDrvCtrl->idr.ac_if.if_opackets++;
  933.         }
  935.     return (0);
  936.     }
  937. #endif
  939. /*******************************************************************************
  940. *
  941. * nicIoctl - the driver's I/O control routine
  942. *
  943. */
  945. LOCAL int nicIoctl
  946.     (
  947.     IDR *pIDR,
  948.     int cmd,
  949.     caddr_t data
  950.     )
  951.     {
  952.     int error;
  954.     error = 0;
  956.     switch (cmd)
  957.         {
  958.         case SIOCSIFADDR:
  959.             ((struct arpcom *)pIDR)->ac_ipaddr = IA_SIN (data)->sin_addr;
  960.             arpwhohas (pIDR, &IA_SIN (data)->sin_addr);
  961.             break;
  963.         case SIOCSIFFLAGS:
  964.             /* Flags are set outside this module. No additional work to do. */
  965.             break;
  967.         default:
  968.             error = EINVAL;
  969.         }
  971.     return (error);
  972.     }
  974. /*******************************************************************************
  975. *
  976. * nicEnetAddrGet - get hardwired Ethernet address.
  977. *
  978. * Read the Ethernet address out of the ROM
  979. */
  981. LOCAL void nicEnetAddrGet
  982.     (
  983.     int unit
  984.     )
  985.     {
  986.     DRV_CTRL *pDrvCtrl = & drvCtrl [unit];
  987.     NIC_DEVICE *pNic = pDrvCtrl->nicAddr;
  988.     int i;
  990.     pNic->Rsar0 = 0;                            /* ID ROM starts at 0 */
  991.     pNic->Rsar1 = 0;
  992.     pNic->Rbcr0 = 6;                            /* length of enet addr */
  993.     pNic->Rbcr1 = 0;
  994.     pNic->Cr = RREAD;                           /* Start NIC Remote DMA */
  996.     for (i = 0; i < 6; i++)
  997.         {
  998.         while (pNic->Rsar0 == i)            /* wait for byte available */
  999.             ;
  1000.         pDrvCtrl->idr.ac_enaddr [i] = *NIC_BUF_PORT;  /* read byte from port */
  1001.         }
  1002.     }
  1004. /*******************************************************************************
  1005. *
  1006. * nicConfig - configure the NIC chip for Ethernet and program address
  1007. */
  1009. LOCAL void nicConfig
  1010.     (
  1011.     int unit
  1012.     )
  1013.     {
  1014.     DRV_CTRL *pDrvCtrl = & drvCtrl [unit];
  1015.     NIC_DEVICE *pNic = pDrvCtrl->nicAddr;
  1017.     pNic->Cr = RPAGE0 | STP;                    /* select page 0 and stop */
  1018.     pNic->Dcr = NOTLS | FIFO8;
  1020.     pNic->Rbcr0 = 0;                /* clear remote DMA byte count registers */
  1021.     pNic->Rbcr1 = 0;
  1023.     pNic->Rcr = AB;         /* accept broadcast, but not runt or multicast */
  1024.     pNic->Tcr = MODE1;                          /* internal loopback mode */
  1026.     pNic->Pstart = PSTART;
  1027.     pNic->Pstop  = PSTOP;
  1028.     pNic->Bnry   = BNRY;
  1030.     nicEnetAddrGet (unit);                      /* Get Ethernet address */
  1032.     /* set up page 1 registers */
  1034.     pNic->Cr   = RPAGE1;
  1035.     pNic->Par0 = pDrvCtrl->idr.ac_enaddr [0];
  1036.     pNic->Par1 = pDrvCtrl->idr.ac_enaddr [1];
  1037.     pNic->Par2 = pDrvCtrl->idr.ac_enaddr [2];
  1038.     pNic->Par3 = pDrvCtrl->idr.ac_enaddr [3];
  1039.     pNic->Par4 = pDrvCtrl->idr.ac_enaddr [4];
  1040.     pNic->Par5 = pDrvCtrl->idr.ac_enaddr [5];
  1041.     pNic->nic_pg1.mar0 = 0xff;
  1042.     pNic->nic_pg1.mar1 = 0xff;
  1043.     pNic->nic_pg1.mar2 = 0xff;
  1044.     pNic->nic_pg1.mar3 = 0xff;
  1045.     pNic->nic_pg1.mar4 = 0xff;
  1046.     pNic->nic_pg1.mar5 = 0xff;
  1047.     pNic->nic_pg1.mar6 = 0xff;
  1048.     pNic->nic_pg1.mar7 = 0xff;
  1049.     pNic->Curr = CURR;
  1051.     pNic->Cr = RPAGE0;                          /* back to page 0 */
  1052.     pNic->Tcr = MODE0;                          /* put Tx into normal mode */
  1053.     pNic->Cr = STA;                             /* start the beast running */
  1054.     pNic->Isr = 0xff;                           /* clr any pending ints */
  1055.     pNic->Imr = PRXE|PTXE|TXEE|OVWE|RDCE;       /* enable these ints */
  1057.     }
  1059. /*******************************************************************************
  1060. *
  1061. * pktBufWrite - write data to NIC buffer
  1062. */
  1064. LOCAL STATUS pktBufWrite
  1065.     (
  1066.     DRV_CTRL *pDrvCtrl,
  1067.     unsigned long nicBufAddr,
  1068.     unsigned long len,
  1069.     char *pData
  1070.     )
  1071.     {
  1072.     NIC_DEVICE *pNic;
  1073.     WE32104 *pDmac;
  1074.     STATUS status;
  1076.     if (len == 0)                                       /* nothing to do */
  1077.         return (OK);
  1079.     pNic = pDrvCtrl->nicAddr;
  1080.     pDmac = (WE32104 *) DMA_BASE;
  1082.     semTake(pDrvCtrl->dmaSem, WAIT_FOREVER);           /* obtain semaphore */
  1083.     pDrvCtrl->dmaWait = TRUE;                          /* set our flag */
  1085.     /* set up NIC remote DMA transfer */
  1087.     pNic->Rsar0 = nicBufAddr;
  1088.     pNic->Rsar1 = nicBufAddr >> 8;
  1089.     pNic->Rbcr0 = len;
  1090.     pNic->Rbcr1 = len >> 8;
  1092.     /* set up main DMAC transfer */
  1094.     cacheFlush (DATA_CACHE, pData, len);            /* ensure coherency */
  1095.     pDmac->Ch2.SourceAdd = (unsigned long) pData;
  1096.     pDmac->Ch2.TranCount = len;
  1097.     pDmac->Ch2.Mode = MODE_TT_MP | MODE_DS_LONG | MODE_BR;
  1099.     /* start both devices doing the transfer */
  1101.     pDmac->Ch2.StatCont = SCR_STR;
  1102.     pNic->Cr = RWRITE;
  1104.     /* wait for interrupt handler to clear our flag */
  1106.     while (pDrvCtrl->dmaWait)
  1107.         {
  1108.         if  (
  1109.             (pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING)) !=
  1110.             (IFF_UP | IFF_RUNNING)
  1111.             )
  1112.             {
  1113.             pDrvCtrl->dmaWait = FALSE;
  1114.             pDmac->Ch2.StatCont = SCR_SA;               /* abort */
  1115.             semGive(pDrvCtrl->dmaSem);                  /* release the sem */
  1116.             return (OK);                                /* this is correct */
  1117.             }
  1118.         }
  1120.     /* check for DMAC error */
  1122.     if(pDmac->Ch2.StatCont & SCR_ACT)
  1123.         {
  1124.         pDmac->Ch2.StatCont = SCR_SA;               /* abort */
  1125.         status = ERROR;
  1126.         }
  1127.     else
  1128.         status = OK;
  1130.     semGive(pDrvCtrl->dmaSem);
  1131.     return (status);
  1132.     }
  1134. /*******************************************************************************
  1135. *
  1136. * pktBufRead - read data from NIC buffer
  1137. */
  1139. LOCAL STATUS pktBufRead
  1140.     (
  1141.     DRV_CTRL *pDrvCtrl,
  1142.     unsigned long nicBufAddr,
  1143.     unsigned long len,
  1144.     char *pData
  1145.     )
  1146.     {
  1147.     NIC_DEVICE *pNic;
  1148.     WE32104 *pDmac;
  1149.     STATUS status;
  1151.     if (len == 0)                                       /* nothing to do */
  1152.         return (OK);
  1154.     /* Avoid starting DMA if device is down to to fatal error */
  1156.     if  (
  1157.         (pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING)) !=
  1158.         (IFF_UP | IFF_RUNNING)
  1159.         )
  1160.         return (OK);
  1162.     pNic = pDrvCtrl->nicAddr;
  1163.     pDmac = (WE32104 *) DMA_BASE;
  1165.     semTake(pDrvCtrl->dmaSem, WAIT_FOREVER);            /* obtain semaphore */
  1166.     pDrvCtrl->dmaWait = TRUE;                           /* set our flag */
  1168.     /* set up NIC remote DMA transfer */
  1170.     pNic->Rsar0 = nicBufAddr;
  1171.     pNic->Rsar1 = nicBufAddr >> 8;
  1172.     pNic->Rbcr0 = len;
  1173.     pNic->Rbcr1 = len >> 8;
  1175.     /* set up main DMAC transfer */
  1177.     pDmac->Ch2.DestAdd = (unsigned long) pData;
  1178.     pDmac->Ch2.TranCount = len;
  1179.     pDmac->Ch2.Mode = MODE_TT_PM | MODE_DS_LONG | MODE_BR;
  1181.     /* start both devices doing the transfer */
  1183.     pDmac->Ch2.StatCont = SCR_STR;
  1184.     pNic->Cr = RREAD;
  1186.     /* wait for interrupt handler to clear our flag */
  1188.     while (pDrvCtrl->dmaWait)
  1189.         {
  1190.         if  (
  1191.             (pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING)) !=
  1192.             (IFF_UP | IFF_RUNNING)
  1193.             )
  1194.             {
  1195.             pDrvCtrl->dmaWait = FALSE;
  1196.             pDmac->Ch2.StatCont = SCR_SA;               /* abort */
  1197.             semGive(pDrvCtrl->dmaSem);                  /* release the sem */
  1198.             return (OK);                                /* this is correct */
  1199.             }
  1200.         }
  1202.     /* check for DMAC error */
  1204.     if(pDmac->Ch2.StatCont & SCR_ACT)
  1205.         {
  1206.         pDmac->Ch2.StatCont = SCR_SA;               /* abort */
  1207.         status = ERROR;
  1208.         }
  1209.     else
  1210.         {
  1211.         cacheInvalidate (DATA_CACHE, pData, len);   /* ensure coherency */
  1212.         status = OK;
  1213.         }
  1215.     semGive(pDrvCtrl->dmaSem);
  1216.     return (status);
  1217.     }
  1219. #ifdef BSD43_DRIVER
  1220. #include "sys/socket.h"
  1222. /*******************************************************************************
  1223. *
  1224. * convertDestAddr - converts socket addr into enet addr and packet type
  1225. *
  1226. */
  1228. static BOOL convertDestAddr
  1229.     (
  1230.     IDR *pIDR,                          /* ptr to i/f data record */
  1231.     SOCK *pDestSktAddr,                 /* ptr to a generic sock addr */
  1232.     char *pDestEnetAddr,                /* where to write enet addr */
  1233.     u_short *pPacketType,               /* where to write packet type */
  1234.     MBUF *pMbuf                         /* ptr to mbuf data */
  1235.     )
  1236.     {
  1237. #ifdef __STDC__
  1238.     extern arpresolve   (               /* we call this */
  1239.                         IDR *,
  1240.                         MBUF *,
  1241.                         struct in_addr *,
  1242.                         char *,
  1243.                         int *
  1244.                         );
  1245. #else /* __STDC__ */
  1246.     extern arpresolve   ();
  1247. #endif /* __STDC__ */
  1249.     /***** Internet family *****/
  1251.     {
  1252.     struct in_addr destIPAddr;              /* not used */
  1253.     int trailers;                           /* not supported */
  1255.      if (pDestSktAddr->sa_family == AF_INET)
  1256.         {
  1257.         *pPacketType = ETHERTYPE_IP;            /* stuff packet type */
  1258.         destIPAddr = ((struct sockaddr_in *) pDestSktAddr)->sin_addr;
  1260.         if (!arpresolve (pIDR, pMbuf, &destIPAddr, pDestEnetAddr, &trailers))
  1261.             return (FALSE);     /* if not yet resolved */
  1263.         return (TRUE);
  1264.         }
  1265.     }
  1268.     /***** Generic family *****/
  1270.     {
  1271.     ETH_HDR *pEnetHdr;
  1273.     if (pDestSktAddr->sa_family == AF_UNSPEC)
  1274.         {
  1275.         pEnetHdr = (ETH_HDR *) pDestSktAddr->sa_data;      /* ptr to hdr */
  1276.         bcopy (pEnetHdr->dst, pDestEnetAddr, 6);            /* copy dst addr */
  1277.         *pPacketType = pEnetHdr->ether_type;                /* copy type */
  1278.         return (TRUE);
  1279.         }
  1280.     }
  1282.     /* Unsupported family */
  1284.     return (FALSE);
  1285.     }
  1286. #endif