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

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

VxWorks

开发平台：

C/C++

if_enp.c：源码内容
  1. /* if_enp.c - CMC ENP 10/L Ethernet network interface driver */
  3. /* Copyright 1984-1997 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 03d,15jul97,spm  added ARP request to SIOCSIFADDR ioctl handler;
  10.                  added support for promiscuous mode to SIOCSIFFLAGS
  11. 03c,25apr97,gnn  added multicast by turning on promiscuous mode.
  12. 03b,07apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  13. 03a,16dec96,map  doc: fixed ENP-10/L jumper diagram [SPR# 3025]
  14. 02z,14oct93,wmd  Added htons() for pPacketType assignments (SPR #2060).
  15. 02y,11aug93,jmm  Changed ioctl.h and socket.h to sys/ioctl.h and sys/socket.h
  16. 02x,19feb93,jdi  documentation cleanup.
  17. 02w,02feb93,dzb  updated copyright.  removed HK68/V2F referrence (SPR #1876). 
  18. 02v,13oct92,rfs  Added documentation.
  19. 02u,16sep92,rfs  Reinstated interrupting of the ENP after putting outgoing
  20.                  packets on the transmit ring, even though the documentation
  21.                  is conflicting on this action, and some boards work fine
  22.                  without it.
  23. 02t,09sep92,gae  documentation tweaks.
  24. 02s,04sep92,ccc  added address modifier parameter to attach() routine.
  25. 02r,06aug92,rfs  Functional changes:
  26.                    Eliminated init() routine.  Added errno setting for all
  27.                    error cases in the attach() routine.  Added rejection of
  28.                    multiple attach() calls per unit.  Eliminated obsolete use
  29.                    of transmit output queue.  Moved driver control structures
  30.                    to BSS.  Corrected the ioctl() routine.  Added Tx semaphore.
  31.                    Added write pipe flushing.  Added rejection of work if the
  32.                    interface flags are down.  Revised Rx event handling.
  33.                  Cosmetic changes:
  34.                    Changed name of driver control structure, changed all
  35.                    references to it, changed name of all pointers to it.  Added
  36.                    many comments.  Typedef'd common structures and changed all
  37.                    usages to the new type.  General cleanup and convention
  38.                    adherence.
  39. 02q,27jul92,ccc  used sysBusToLocalAdrs() to compute bus address,
  40.                  fixed warnings.
  41. 02p,18jul92,smb  Changed errno.h to errnoLib.h.
  42. 02o,26may92,rrr  the tree shuffle
  43.                   -changed includes to have absolute path from h/
  44. 02n,05may92,wmd  changed LITTLE_ENDIAN to _LITTLE_ENDIAN, BYTE_ORDER to
  45.                  _BYTE_ORDER, cleaned up ansi warnings.
  46. 02m,15jan92,wmd  Added conditional to use ntohl for little Endian in enpput()
  47.                  and initialized pEnpDev->enp_mode with 0x8000 (960 only).
  48. 02l,17oct91,yao  added support for CPU32.
  49. 02k,04oct91,rrr  passed through the ansification filter
  50.                   -changed functions to ansi style
  51.                   -changed includes to have absolute path from h/
  52.                   -fixed #else and #endif
  53.                   -changed READ, WRITE UPDATE to O_RDONLY O_WRONLY O_RDWR
  54.                   -changed VOID to void
  55.                   -changed copyright notice
  56. 02j,22aug91,hdn  fixed bug in enpgetaddr.
  57. 02i,19jun91,km   some modifications for 960 -- not verified correct.
  58.                  +gae  compiled in enpShow; added enpDump for debug.
  59.                  fixed some usages of ENPDEVICE_OLD (for old CMC LINK-10 ROMs).
  60. 02h,29apr91,hdn  use SIZEOF_ETHERHEADER instead of sizeof(ether_header).
  61. 02g,10apr91,jdi  documentation cleanup; doc review by elh.
  62. 02f,25oct90,gae  made access of "lost carrier" 32-bit register be two 16-bit
  63.                  access -- some boards generate a bus error.
  64. 02e,20oct90,gae  added detection of "lost carrier"; added but ifdef'd out
  65.                  enpShow routine; cleanup.
  66. 02d,02oct90,hjb  de-linted.
  67. 02c,19sep90,dab  made enpinit() return int.  made bcopy_to_mbufs() call in
  68.                  enpread() to use width of 1 for 680[01]0 cpus.
  69. 02b,26aug90,hjb  added a hack to avoid prob caused when copying data from
  70.                  hkv2f a word at a time into ENP memory starting at an odd-byte
  71.                  boundary.
  72. 02a,10aug90,dnw  added forward declarations for void functions.
  73.                  added include of if_subr.h.
  74. 01z,11jul90,hjb  removed code that uses gotIp which is no longer necessary.
  75.                  made enpread() void.  changed references to do_protocol()
  76.                  to do_protocol_with_type().
  77. 01y,26jun90,hjb  copy_from_mbufs() & m_freem() fix; fixed enpattach() error msg
  78. 01x,07may90,hjb  changed bcopy_to_mbufs to copy 16 bits at a time.
  79. 01w,19apr90,hjb  deleted param.h, modifications for bcopy_from_mbufs().
  80. 01v,22mar90,hjb  changed copy_to_mbuf() to bcopy_to_mbuf() with argument
  81.                  bcopyBytes() to fix the problems associated with using
  82.                  ENP with hkv2f caused by bcopy'ing more than a byte at a time
  83.                  over VME.
  84. 01u,18mar90,hjb  reduction of redundant code and addition of cluster support.
  85. 01t,06aug89,gae  changed iv68k.h to iv.h.
  86. 01s,25may89,hjb  enpioctl() SIOCSIFFLAGS, check for IFF_UP before calling
  87.                  enpinit().
  88. 01r,24may89,rdc  enpintr no longer does netJobAdd if task level is
  89.                  already processing packets. (fixes netRing overflows)
  90.                  enpoutput now bumps if_opackets.
  91. 01q,17apr89,del  fixed comment in enpgetaddr.
  92. 01q,13apr89,del  fixed problem introduced by CMC when they changed to
  93.                  version 4.0 Link-10 roms.
  94. 01p,05aug88,dnw  fixed oversight in enpreset in 01o.
  95. 01o,04aug88,dnw  fixed bug causing occasional initialization failure.
  96.                  simplified reset.
  97. 01n,23jun88,rdc  added IFF_BROADCAST to if_flags.
  98. 01m,05jun88,dnw  changed enp_softc to array of ptrs to descriptors.
  99.                  increased NENP from 1 to 4.
  100. 01l,30may88,dnw  changed to v4 names.
  101. 01k,22feb88,jcf  made kernel independent.
  102. 01j,20feb88,dnw  cleanup, lint.
  103. 01i,10feb88,rdc  re-installed enpreset which i accidently trashed in 01g.
  104.                  optimized packet reception by calling ipintr only once
  105.                  for a bunch of packets.
  106. 01h,14jan88,jcf  extended maximum firmware initialization wait to 15 seconds
  107. 01g,05jan88,rdc  added include of systm.h
  108. 01f,20nov87,ecs  lint
  109.            &dnw  changed enpattach to take int vec num instead of vec adrs.
  110. 01e,19nov87,dnw  changed to program interrupt vector.
  111.                  changed initial wait loop to use vxMemProbe.
  112. 01d,08nov87,dnw  added output hook code.
  113.                  changed calling sequence to input hook.
  114. 01c,21oct87,ecs  delinted
  115. 01b,28aug87,dnw  removed unnecessary includes.
  116.                  added input hook code.
  117.                  clean up.
  118. 01a,21jul87,rdc  adapted from cmc's 4.2 driver.
  119. */
  121. /*
  122. This module implements the CMC ENP 10/L Ethernet network interface driver.
  124. This driver is designed to be moderately generic, operating unmodified 
  125. across the range of architectures and targets supported by VxWorks.
  126. To achieve this, the driver must be given several target-specific
  127. parameters.  These parameters, and the mechanisms used to communicate them
  128. to the driver, are detailed below.  This driver supports up to four
  129. individual units per CPU.
  132. BOARD LAYOUT
  133. The diagram below shows the relevant jumpers for VxWorks configuration.
  134. Default values are: I/O address 0x00de0000, Standard Addressing (A24),
  135. interrupt level 3.
  136. .bS
  137. ______________________________              _______________________________
  138. |             P1             |    ENP-10    |             P2              |
  139. |                            ----------------                             |
  140. |                   ::::X::                L                              |
  141. |                   INT LVL                L INT ACK                      |
  142. |                                          R                              |
  143. |                                                                         |
  144. |                                                                         |
  145. |                                                                         |
  146. |                                                                         |
  147. |                                                                         |
  148. |                                                                         |
  149. |                                                                         |
  150. |   "                                                                     |
  151. |   " IO ADRS                                                             |
  152. |   -                                            -------  -------         |
  153. |   "                                           |  ROM  ||  ROM  |        |
  154. |   "                                           |LINK-10||LINK-10|        |
  155. |   "                                           |       ||       |        |
  156. |   "                                           | HIGH  ||  LOW  |        |
  157. |                                               |  U4   ||  U3   |        |
  158. |                                                ---^---  ---^---         |
  159. |_________________________________________________________________________|
  160. .bE
  161. .bS
  162. ______________________________              _______________________________
  163. |             P1             |  ENP-10/L    |             P2              |
  164. |  JP17    JP16      JP15    ----------------                ----------   |
  165. |  X:XX=_: ::X::::   ::::X::          " JP14                |  ROM     |  |
  166. |          ADRS BITS INT LVL          " ADRS BITS (EXT)     > LINK-10  |  |
  167. |                                     "                     |  LOW  U63|  |
  168. |    JP12                             "                      ==========   |
  169. |  " STD/                             "                     |  ROM     |  |
  170. |  " EXT                              "                     > LINK-10  |  |
  171. |  "                                  "                     |  HIGH U62|  |
  172. |  "                                  "                      ----------   |
  173. |  -                                  _ JP13 TIMEOUT                      |
  174. |                                     " JP13 TIMEOUT*                     |
  175. |  "                                                                      |
  176. |  " INT ACK                                                              |
  177. |  - JP11                                                                 |
  178. |            _. JP7 SYSCLOCK                                              |
  179. |            ._ JP7 SYSCLOCK*                                             |
  180. |      ._ JP8                                                             |
  181. |                                                                         |
  182. |                                                                         |
  183. |                                                                         |
  184. |_________________________________________________________________________|
  185. .bE
  188. EXTERNAL INTERFACE
  189. This driver provides the standard external interface with the following
  190. exceptions.  All initialization is performed within the attach routine;
  191. there is no separate initialization routine.  Therefore, in the global interface
  192. structure, the function pointer to the initialization routine is NULL.
  194. The only user-callable routine is enpattach(), which publishes the `enp'
  195. interface and initializes the driver and device.
  197. TARGET-SPECIFIC PARAMETERS
  198. .iP "base VME address of ENP memory"
  199. This parameter is passed to the driver by enpattach().
  200. The ENP board presents an area of its memory to the VME bus.  This
  201. address is jumper selectable on the ENP.  This parameter is the same as
  202. the address selected on the ENP.
  203. .iP "VME address modifier code"
  204. This parameter is passed to the driver by enpattach().
  205. It specifies the AM (address modifier) code to use when the driver accesses
  206. the VME address space of the ENP board.
  207. .iP "interrupt vector"
  208. This parameter is passed to the driver by enpattach().
  209. It specifies the interrupt vector to be used by the driver
  210. to service an interrupt from the ENP board.  The driver will connect
  211. the interrupt handler to this vector by calling intConnect().
  212. .iP "interrupt level"
  213. This parameter is passed to the driver by enpattach().
  214. It specifies the interrupt level that is associated with the
  215. interrupt vector.  The driver enables the interrupt from the ENP by
  216. calling sysIntEnable() and passing this parameter.
  217. .LP
  219. SYSTEM RESOURCE USAGE
  220. When implemented, this driver requires the following system resources:
  222.     - one mutual exclusion semaphore
  223.     - one interrupt vector
  224.     - 76 bytes in the initialized data section (data)
  225.     - 808 bytes in the uninitialized data section (BSS)
  227. The above data and BSS requirements are for the MC68020 architecture 
  228. and may vary for other architectures.  Code size (text) varies greatly between
  229. architectures and is therefore not quoted here.
  231. The ENP board provides the buffers for all packets transmitted and received.
  232. Therefore, the driver does not require any system memory to share with the
  233. device.  This also eliminates all data cache coherency issues.
  235. SEE ALSO: ifLib
  236. */
  238. #include "vxWorks.h"
  239. #include "net/mbuf.h"
  240. #include "net/protosw.h"
  241. #include "sys/ioctl.h"
  242. #include "sys/socket.h"
  243. #include "errnoLib.h"
  244. #include "net/uio.h"
  245. #include "net/if.h"
  246. #include "net/route.h"
  247. #include "netinet/in.h"
  248. #include "netinet/in_systm.h"
  249. #include "netinet/ip.h"
  250. #include "netinet/ip_var.h"
  251. #include "netinet/in_var.h"
  252. #include "netinet/if_ether.h"
  253. #include "drv/netif/if_enp.h"
  254. #include "etherLib.h"
  255. #include "vme.h"
  256. #include "iv.h"
  257. #include "iosLib.h"
  258. #include "ioLib.h"
  259. #include "memLib.h"
  260. #include "net/systm.h"
  261. #include "net/if_subr.h"
  262. #include "sysLib.h"
  263. #include "vxLib.h"
  264. #include "stdio.h"
  265. #include "intLib.h"
  266. #include "logLib.h"
  267. #include "string.h"
  268. #include "netLib.h"
  269. #include "stdlib.h"
  270. #include "semLib.h"
  271. #include "cacheLib.h"
  274. /***** LOCAL DEFINITIONS *****/
  276. #undef ENP_DEBUG            /* define to display error/status messages */
  277. #define MAX_UNITS    4                  /* max units to support */
  279. /* Typedefs for external structures that are not typedef'd in their .h files */
  281. typedef struct mbuf MBUF;
  282. typedef struct arpcom IDR;                  /* Interface Data Record wrapper */
  283. typedef struct ifnet IFNET;                 /* real Interface Data Record */
  284. typedef struct sockaddr SOCK;
  286. #ifdef BSD43_DRIVER
  287. /* The Ethernet header */
  289. typedef struct enet_hdr
  290.     {
  291.     char dst [6];
  292.     char src [6];
  293.     u_short type;
  294.     } ENET_HDR;
  295. #endif
  297. #define ENET_HDR_SIZ        sizeof(ENET_HDR)
  298. #define ENET_HDR_REAL_SIZ   14
  300. /* The definition of the driver control structure */
  302. typedef struct drv_ctrl
  303.     {
  304.     IDR         idr;                    /* interface data record */
  306.     BOOL        attached;               /* TRUE if attach() has succeeded */
  307.     ENPDEVICE   *enpAddr;               /* VME address of board */
  308.     ENPSTAT     enpStat;                /* duplicate copy of ENP statisics */
  309.     ULONG       lostCarrier;            /* statistic counter */
  310.     int         enpIntLevel;            /* VME interrupt level */
  311.     int         enpIntVec;              /* VME interrupt vector */
  312.     BOOL        taskLevelActive;        /* netTask processing packets */
  313. #ifdef BSD43_DRIVER
  314.     SEM_ID      TxSem;                  /* transmitter semaphore */
  315. #endif
  316.     } DRV_CTRL;
  319. /***** LOCALS *****/
  321. /* The array of driver control structures, one per unit supported */
  323. LOCAL DRV_CTRL drvCtrl [MAX_UNITS];
  325. /*LOCAL*/ BOOL enpNewROM;       /* TRUE if LINK-10 v4.0 or higher */
  328. /***** FUNCTION DECLARATIONS *****/
  330. /* those not defined in header files */
  331. extern int splimp (void);
  332. extern void splx (int spl);
  334. /* forward static functions */
  336. static int enpIoctl (IDR *pIDR, int cmd, caddr_t data);
  337. #ifdef BSD43_DRIVER
  338. static int enpOutput (IDR *pIDR, MBUF *pMbuf, SOCK *dst);
  339. #else
  340. LOCAL void enpTxStartup (DRV_CTRL * pDrvCtrl);
  341. #endif
  342. static int enpringput (RING *rp, BCB *pBCB);
  343. static int enpringget (RING *rp);
  344. static void enpIntr (int unit);
  345. static void enpRxEvent (int unit);
  346. static void enpgetaddr (int unit);
  347. static BOOL enpringempty (RING *rp);
  348. #ifdef BSD43_DRIVER
  349. static BOOL convertDestAddr
  350.             (
  351.             IDR *pIDR,
  352.             SOCK *pDestSktAddr,
  353.             char *pDestEnetAddr,
  354.             u_short *pPacketType,
  355.             MBUF *pMbuf
  356.             );
  357. #endif
  358. static STATUS enpReset (int unit);
  359. static STATUS enpRxPktProcess (int unit);
  362. /*******************************************************************************
  363. *
  364. * enpattach - publish the `enp' network interface and initialize the driver and device
  365. *
  366. * This routine publishes the `enp' interface by filling in a network 
  367. * interface record and adding this record to the system list.  It also
  368. * initializes the driver and the device to the operational state.
  369. *
  370. * RETURNS: OK or ERROR.
  371. */
  373. STATUS enpattach
  374.     (
  375.     int unit,           /* unit number                     */
  376.     char *addr,         /* address of enp's shared memory  */
  377.     int ivec,           /* interrupt vector to connect to  */
  378.     int ilevel,         /* interrupt level                 */
  379.     int enpAddrAm       /* address VME address modifier */
  380.     )
  381.     {
  382.     int        delay;
  383.     short      status;
  384.     int        temp;
  385.     ENPDEVICE  *pEnpDev;
  386.     char       *enpBase;
  387.     DRV_CTRL   *pDrvCtrl;
  389. #ifdef ENP_DEBUG
  390.     printf ( "nenp: attach: unit=%d, addr=%x, ivec=%d, ilevel=%d, Am=%dn",
  391.              unit, addr, ivec, ilevel, enpAddrAm );
  392. #endif
  394.     /* Safety check unit number */
  396.     if (unit < 0 || unit >= MAX_UNITS)
  397.         {
  398.         errnoSet (S_iosLib_CONTROLLER_NOT_PRESENT);
  399.         return (ERROR);
  400.         }
  402.     /* Get pointer to our driver control structure */
  404.     pDrvCtrl = & drvCtrl [unit];
  406.     /* Check for multiple invocation per unit */
  408.     if (pDrvCtrl->attached)
  409.         return (OK);
  411.     /* Publish the interface data record */
  413. #ifdef BSD43_DRIVER
  414.     ether_attach    ( & pDrvCtrl->idr.ac_if, unit, "enp", (FUNCPTR) NULL,
  415.                       (FUNCPTR) enpIoctl, (FUNCPTR) enpOutput,
  416.                       (FUNCPTR) enpReset);
  417. #else
  418.     ether_attach ( 
  419.                  &pDrvCtrl->idr.ac_if, unit, 
  420.                  "enp", 
  421.                  (FUNCPTR)NULL,
  422.                  (FUNCPTR)enpIoctl, 
  423.                  (FUNCPTR)ether_output,
  424.                  (FUNCPTR)enpReset
  425.                  );
  426.     pDrvCtrl->idr.ac_if.if_start = (FUNCPTR)enpTxStartup;
  427. #endif
  429. #ifdef BSD43_DRIVER
  430.     /* Create the transmit semaphore. */
  432.     pDrvCtrl->TxSem = semMCreate    (
  433.                                     SEM_Q_PRIORITY |
  434.                                     SEM_DELETE_SAFE |
  435.                                     SEM_INVERSION_SAFE
  436.                                     );
  438.     if (pDrvCtrl->TxSem == NULL)
  439.         {
  440. #ifdef ENP_DEBUG
  441.         printf ("enp: error creating transmitter semaphoren");
  442. #endif
  443.         return (ERROR);
  444.         }
  445. #endif
  447.     /* Determine local address and AM codes to access the controller */
  449.     if (sysBusToLocalAdrs (enpAddrAm, addr, &enpBase) == ERROR)
  450.         {
  451.         errnoSet (EFAULT);
  452.         return (ERROR);
  453.         }
  455. #ifdef ENP_DEBUG
  456.     printf ( "enp: attach: local addr=%xn", enpBase );
  457. #endif
  459.     pEnpDev = (ENPDEVICE *) enpBase;
  460.     enpBase += 0x1000;  /* memory is offset from board base address */
  462.     /* Connect the interrupt handler */
  464.     (void) intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (ivec),
  465.                        (VOIDFUNCPTR)enpIntr, unit);
  467.     /* wait for kernel reset to finish */
  469.     delay = 15 * sysClkRateGet ();
  470.     while (1)
  471.         {
  473.         /* Test for response on the buss */
  475.         if  (
  476.             vxMemProbe  (
  477.                         (char *) & pEnpDev->enp_status,
  478.                         O_RDONLY,
  479.                         sizeof (short),
  480.                         (char *) & status
  481.                         )
  482.             == OK
  483.             )
  484.             {
  485.             /* Check status word */
  486.             if ( (ntohs (status) & STS_READY) != 0 )
  487.                 break;
  488.             }
  490.         /* Check for timeout */
  492.         if (--delay <= 0)
  493.             {
  494.             (void) errnoSet (S_iosLib_CONTROLLER_NOT_PRESENT);
  495.             return (ERROR);
  496.             }
  498.         taskDelay (sysClkRateGet() / 30);       /* 1/30th of a second */
  499.         }
  501.     /* start link level firmware */
  503.     pEnpDev->enp_intvector = htons (ivec);
  504.     temp = htonl ((u_long) enpBase);
  505.     WRITELONG (&pEnpDev->enp_base, temp);
  507. #if  CPU_FAMILY==I960
  508.     pEnpDev->enp_mode = htons (0x0080);
  509. #endif /* CPU_FAMILY==I960 */
  511.     pEnpDev->enp_go = htons (GOVAL);
  513.     CACHE_PIPE_FLUSH ();
  515.     /* wait for the link level firmware to finish initialization */
  517.     delay = 15 * sysClkRateGet ();
  518.     while ((ntohs (pEnpDev->enp_state) & S_ENPRUN) == 0)
  519.         {
  520.         if (--delay <= 0)
  521.             {
  522.             (void) errnoSet (S_ioLib_DEVICE_ERROR);
  523.             return (ERROR);
  524.             }
  526.         taskDelay (sysClkRateGet() / 30);       /* 1/30th of a second */
  527.         }
  529.     pDrvCtrl->enpAddr     = pEnpDev;
  530.     pDrvCtrl->enpIntLevel = ilevel;
  531.     pDrvCtrl->enpIntVec   = ivec;
  533.     enpgetaddr (unit);
  535.     (void) sysIntEnable (ilevel);
  537.     /* Raise the interface flags */
  539.     pDrvCtrl->idr.ac_if.if_flags |= IFF_UP | IFF_RUNNING | IFF_NOTRAILERS | IFF_MULTICAST;
  541.     /* Set our success indicator */
  543.     pDrvCtrl->attached = TRUE;
  545.     return (OK);
  546.     }
  548. /*******************************************************************************
  549. *
  550. * enpReset - reset the interface
  551. */
  553. LOCAL STATUS enpReset
  554.     (
  555.     int unit
  556.     )
  557.     {
  558.     DRV_CTRL *pDrvCtrl;
  559.     ENPDEVICE *pEnpDev;
  561. #ifdef ENP_DEBUG
  562.     printf ( "enp: reset: unit=%dn", unit );
  563. #endif
  565.     /* Safety check unit number */
  567.     if (unit < 0 || unit >= MAX_UNITS)
  568.         {
  569.         errnoSet (S_iosLib_CONTROLLER_NOT_PRESENT);
  570.         return (ERROR);
  571.         }
  573.     pDrvCtrl = & drvCtrl[unit];
  574.     pEnpDev = pDrvCtrl->enpAddr;
  575.     pDrvCtrl->idr.ac_if.if_flags = 0;
  576.     RESET_ENP (pEnpDev);
  578.     /* reset the status word that enpattach watches to know when enp is reset;
  579.      * this is necessary because the enp doesn't clear this status immediately
  580.      * on reset.  Re-initializing the enp after a reset (i.e. in VxWorks
  581.      * init after boot rom reset) could get fooled if we rely on enp to clear
  582.      * the READY bit in this status.
  583.      */
  584.     pEnpDev->enp_status = 0;
  586.     CACHE_PIPE_FLUSH ();
  588.     return (OK);
  589.     }
  591. /*******************************************************************************
  592. *
  593. * enpIntr - the driver's interrupt handler
  594. *
  595. * The ENP board will only interrupt us to notify us that there are packets
  596. * to be processed.  The processing of each packet is done by netTask.  This
  597. * routine simply queues our job for netTask.
  598. */
  600. LOCAL void enpIntr
  601.     (
  602.     int unit
  603.     )
  604.     {
  605.     DRV_CTRL *pDrvCtrl;
  607.     /* Safety check unit number */
  609.     if (unit < 0 || unit >= MAX_UNITS)
  610.         return;
  612.     pDrvCtrl = & drvCtrl [unit];
  613.     sysBusIntAck (pDrvCtrl->enpIntLevel);
  615.     if (!pDrvCtrl->taskLevelActive)
  616.         {
  617.         /* indicate that enpHandleInt is q'd */
  618.         pDrvCtrl->taskLevelActive = TRUE;
  619.         (void) netJobAdd ((FUNCPTR)enpRxEvent, unit, 0,0,0,0);
  620.         /* see comment in enpHandleInt */
  621.         }
  622.     }
  624. /*******************************************************************************
  625. *
  626. * enpRxEvent - handler for receive events
  627. */
  629. LOCAL void enpRxEvent
  630.     (
  631.     int unit
  632.     )
  633.     {
  634.     DRV_CTRL  *pDrvCtrl;
  635.     ENPDEVICE *pDev;
  638.     pDrvCtrl = & drvCtrl [unit];
  639.     pDev = pDrvCtrl->enpAddr;
  641.     splx (0);       /* Give up the spl semaphore taken for us by netTask. */
  643.     /* the following loop attempts to pull multiple buffers off of the
  644.      * input queue;  the boolean "taskLevelActive" is used to inform
  645.      * the interrupt level code that we're already processing input
  646.      * buffers, so there's no need to do a netJobAdd, thereby decreasing
  647.      * the possibility of a net task ring buffer overflow.
  648.      */
  650.     do
  651.         {
  652.         pDrvCtrl->taskLevelActive = TRUE;
  654.         while (!enpringempty ((RING*) &pDev->enp_tohost))
  655.             {
  656.             if ( enpRxPktProcess (unit) == ERROR )
  657.                 {
  658.                 pDrvCtrl->taskLevelActive = FALSE;
  659.                 splimp ();      /* Take the spl semaphore for netTask */
  660.                 return;
  661.                 }
  662.             }
  664.         pDrvCtrl->taskLevelActive = FALSE;
  666.         /* check once more after resetting taskLevelActive to avoid race */
  668.         }
  669.     while (!enpringempty ((RING*) &pDev->enp_tohost));
  671.     splimp ();      /* Take the spl semaphore for netTask */
  672.     }
  674. /*******************************************************************************
  675. *
  676. * enpRxPktProcess - process the next received packet
  677. *
  678. * Copy packets from a BCB into an mbuf and hand it to the next higher layer.
  679. */
  681. LOCAL STATUS enpRxPktProcess
  682.     (
  683.     int unit
  684.     )
  685.     {
  686.     int             len;
  687.     int             temp;
  688.     DRV_CTRL        *pDrvCtrl;
  689.     ENET_HDR        *pEnetHdr;
  690.     MBUF            *pMbuf;
  691.     BCB             *pBCB;
  692.     ENPDEVICE       *pDev;
  693.     unsigned char   *pData;
  696.     /* Get control pointers */
  698.     pDrvCtrl = & drvCtrl [unit];
  699.     pDev = pDrvCtrl->enpAddr;
  701.     /* Check ifnet flags. Return if incorrect. */
  703.     if  (
  704.         (pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING)) !=
  705.         (IFF_UP | IFF_RUNNING)
  706.         )
  707.         return (ERROR);
  709.     /* Get pointer to next packet */
  711.     pBCB = (BCB*) enpringget ((RING*) &pDev->enp_tohost);
  712.     if (pBCB == NULL)                     /* unlikely error */
  713.         return (ERROR);
  715.     /* Bump the incoming packet statistic */
  717.     pDrvCtrl->idr.ac_if.if_ipackets++;
  719.     /* Get length of packet */
  721.     len = ntohs (pBCB->b_msglen);
  723.     /* Get pointer to packet */
  725.     READLONG ((& pBCB->b_addr), &temp);
  726.     pEnetHdr = (ENET_HDR *) ntohl (temp);
  728.     /* call input hook if any */
  730.     if (etherInputHookRtn != NULL)
  731.         {
  732.         if  (
  733.             (*etherInputHookRtn) (& pDrvCtrl->idr.ac_if, (char *) pEnetHdr, len)
  734.             == 1
  735.             )
  736.             {
  737.             (void) enpringput ((RING *)&pDev->enp_enpfree, pBCB);
  738.             return (OK);
  739.             }
  740.         }
  742.     /* Adjust length; subtract size of header */
  744.     len -= ENET_HDR_REAL_SIZ;
  746.     /* Get pointer to data section of the packet */
  748.     pData = ((unsigned char *) pEnetHdr) + ENET_HDR_REAL_SIZ;
  750.     /* copy data from enp to mbuf a word at a time */
  752. #if (CPU == MC68000) || (CPU == MC68010) || (CPU == CPU32)
  753.     pMbuf = bcopy_to_mbufs (pData, len, 0, (IFNET *) &pDrvCtrl->idr.ac_if, 1);
  754. #else
  755.     pMbuf = bcopy_to_mbufs (pData, len, 0, (IFNET *) &pDrvCtrl->idr.ac_if, 2);
  756. #endif  /* (CPU == MC68000) || (CPU == MC68010) || (CPU == CPU32) */
  758.     if (pMbuf != NULL)
  759. #ifdef BSD43_DRIVER
  760.         do_protocol_with_type   (
  761.                                 ntohs (pEnetHdr->type),
  762.                                 pMbuf,
  763.                                 & pDrvCtrl->idr,
  764.                                 len
  765.                                 );
  766. #else
  767.         do_protocol (pEnetHdr, pMbuf, &pDrvCtrl->idr, len);
  768. #endif
  769.     else
  770.         ++pDrvCtrl->idr.ac_if.if_ierrors;       /* bump error stat */
  772.     (void) enpringput ((RING *)&pDev->enp_enpfree, pBCB);
  773.     return (OK);
  774.     }
  776. #ifdef BSD43_DRIVER
  777. /*******************************************************************************
  778. *
  779. * enpOutput - the driver's output routine
  780. *
  781. * The destination address is passed to this function as a pointer to a
  782. * generic socket address structure.  This address information is first
  783. * converted to the six byte destination address and type field that we
  784. * need to build a proper Ethernet frame.
  785. *
  786. * The data to be sent out is held in a chain of mbufs.  This function is
  787. * passed a pointer to the head mbuf.  The data in each mbuf fragment must
  788. * be copied to the device's packet buffer.
  789. */
  791. LOCAL STATUS enpOutput
  792.     (
  793.     IDR *pIDR,
  794.     MBUF *pMbuf,
  795.     SOCK *pDest
  796.     )
  797.     {
  798.     int         lostCarrier;
  799.     int         blen;
  800.     u_short     packetType;
  801.     u_char      *bufStart;
  802.     DRV_CTRL    *pDrvCtrl;
  803.     ENPDEVICE   *pDev;
  804.     MBUF        *pTempMbuf;
  805.     BCB         *pBCB;
  806.     u_char      *pBuf;
  807.     char        destEnetAddr [6];
  809. #ifdef ENP_DEBUG
  810.     printf ( "enp: output: pIDR=%x, pMbuf=%x, pDest=%xn",
  811.              pIDR, pMbuf, pDest );
  812. #endif
  814.     /* Check ifnet flags. Return error if incorrect. */
  816.     if  (
  817.         (pIDR->ac_if.if_flags & (IFF_UP | IFF_RUNNING)) !=
  818.         (IFF_UP | IFF_RUNNING)
  819.         )
  820.         return (ENETDOWN);
  822.     /* Attempt to convert socket addr into enet addr and packet type.
  823.      * Note that if ARP resolution of the address is required, the ARP
  824.      * module will call our routine again to transmit the ARP request
  825.      * packet.  This means we may actually call ourselves recursively!
  826.      */
  828.     if (convertDestAddr (pIDR,pDest, destEnetAddr, &packetType, pMbuf) == FALSE)
  829.         return (OK);    /* I KNOW returning OK is stupid, but it is correct */
  831.     /* Get driver control pointer */
  833.     pDrvCtrl = & drvCtrl [pIDR->ac_if.if_unit];
  834.     pDev = (ENPDEVICE *) pDrvCtrl->enpAddr;
  836.     /* Obtain exclusive access to transmitter.  This is necessary because
  837.      * certain events can cause netTask to run a job that attempts to transmit
  838.      * a packet.  We can only allow one task here at a time.
  839.      */
  841.     semTake (pDrvCtrl->TxSem, WAIT_FOREVER);
  843.     /* some boards (eg. iv3201a,hkv2f,mv133) get bus errors with 32bit access */
  844.     READLONG (&pDev->enp_stat.e_lost_carrier, &lostCarrier);
  845.     lostCarrier = ntohl (lostCarrier);
  847.     if (lostCarrier > pDrvCtrl->lostCarrier)
  848.         {
  849.         /* The test should probably be "not equal", however, roll-over
  850.          * will take a long time.  After reset pDrvCtrl->lostCarrier won't
  851.          * be in sync -- we should initialize (i.e. read) it elsewhere.
  852.          *
  853.          * Keep a separate count of lost carrier so statics don't
  854.          * get messed up.
  855.          */
  856.         pDrvCtrl->lostCarrier = lostCarrier;
  857. #ifdef ENP_DEBUG
  858.         logMsg  ("enp%d: lost carriern",
  859.                 pDrvCtrl->idr.ac_if.if_unit, 0, 0, 0, 0, 0);
  860. #endif
  861.         }
  863.     /* If no resource available, discard packet */
  865.     if (enpringempty ((RING *) &pDev->enp_hostfree))
  866.         {
  867.         semGive (pDrvCtrl->TxSem);          /* Release exclusive access. */
  868.         m_freem (pMbuf);
  869.         return (OK);
  870.         }
  872.     pBCB = (BCB *) enpringget ((RING *)&pDev->enp_hostfree);
  874.     /* Get pointer to buffer to fill with outgoing packet */
  876.     READLONG ((&pBCB->b_addr),  &bufStart);
  877.     bufStart = (u_char *) ntohl ((int)bufStart);
  879.     /* First fill in the Ethernet header */
  881.     pBuf = bufStart;
  882.     bcopyBytes (destEnetAddr, (char *) pBuf, 6);
  883.     pBuf += 6;
  884.     bcopyBytes ((char *) pDrvCtrl->idr.ac_enaddr, (char *) pBuf, 6);
  885.     pBuf += 6;
  886.     bcopyBytes ( (char *)&packetType, (char *) pBuf, 2);
  887.     pBuf += 2;
  889.     /* copy data from mbufs to enp a word at a time.
  890.      * most other netif drivers use copy_from_mbufs() to accomplish
  891.      * this task.  we're doing this manually here because we
  892.      * need to take care of a special case (hkv2f + ENP, see below).
  893.      */
  895.     pTempMbuf = pMbuf;                      /* copy ptr */
  897.     while (pTempMbuf != NULL)
  898.         {
  899.         /* if destination adrs starts at odd byte boundary
  900.          * copy a byte at a time.  copying a word from hkv2f into ENP memory
  901.          * starting at an odd byte causes problems.
  902.          */
  903.         if (((int) pBuf & 1) == 1)
  904.             bcopyBytes  (
  905.                         mtod (pTempMbuf, char *),
  906.                         (char *) pBuf,
  907.                         (int) pTempMbuf->m_len
  908.                         );
  909.         else
  910.             {
  911.             blen = pTempMbuf->m_len >> 1;
  913.             /* copy 2 bytes at a time */
  915.             bcopyWords (mtod (pTempMbuf, char *), (char *) pBuf, blen);
  917.             /* copy the remaining byte if any */
  919.             blen <<= 1;
  920.             if (blen != pTempMbuf->m_len)
  921.                 {
  922.                 *((char *) (pBuf + blen)) =
  923.                     *((char *) (mtod (pTempMbuf, char *) + blen));
  924.                 }
  925.             }
  927.         /* Move pointer ahead, and get next mbuf pointer */
  929.         pBuf += pTempMbuf->m_len;
  930.         pTempMbuf = pTempMbuf->m_next;
  931.         }
  933.     /* Done with mbufs, release them to system */
  935.     m_freem (pMbuf);
  937.     /* Set length of packet */
  939.     blen = max ( MINPKTSIZE, ((int) pBuf - (int) bufStart) );
  940.     pBCB->b_len = htons (blen);
  942.     /* Put the BCB on the outgoing ring, and if this is the only entry on
  943.      * the ring, generate an interrupt to the ENP by writing to the special
  944.      * location in the shared memory space.  Some boards require this
  945.      * interrupt, while others work fine without it, and still others perform
  946.      * a reset instead of the interrupt.  Go figure.
  947.      */
  949.     if ( enpringput ((RING *) & pDev->enp_toenp, pBCB) == 1 )
  950.         pDev->enp_iow.hst2enp_interrupt = ENPVAL;
  952.     /* Bump the statistic counter. */
  954.     pIDR->ac_if.if_opackets++;
  956.     /* Release exclusive access. */
  958.     semGive (pDrvCtrl->TxSem);
  960.     return (OK);
  961.     }
  962. #else
  963. /*******************************************************************************
  964. *
  965. * enpTxStartup - kick start the transmitter after generic ether_output
  966. *
  967. */
  969. LOCAL void enpTxStartup
  970.     (
  971.     DRV_CTRL * pDrvCtrl  /* pointer to driver control structure */
  972.     )
  973.     {
  974.     int         lostCarrier;
  975.     int         blen;
  976.     u_char      *bufStart;
  977.     ENPDEVICE   *pDev;
  978.     MBUF        *pTempMbuf;
  979.     BCB         *pBCB;
  980.     u_char      *pBuf;
  981.     MBUF * pMbuf;
  983.     pDev = (ENPDEVICE *) pDrvCtrl->enpAddr;
  985.     /* BSD 4.4 drivers already have exclusive access - no semaphore needed. */
  987.     /* some boards (eg. iv3201a,hkv2f,mv133) get bus errors with 32bit access */
  988.     READLONG (&pDev->enp_stat.e_lost_carrier, &lostCarrier);
  989.     lostCarrier = ntohl (lostCarrier);
  991.     if (lostCarrier > pDrvCtrl->lostCarrier)
  992.         {
  993.         /* The test should probably be "not equal", however, roll-over
  994.          * will take a long time.  After reset pDrvCtrl->lostCarrier won't
  995.          * be in sync -- we should initialize (i.e. read) it elsewhere.
  996.          *
  997.          * Keep a separate count of lost carrier so statics don't
  998.          * get messed up.
  999.          */
  1000.         pDrvCtrl->lostCarrier = lostCarrier;
  1001. #ifdef ENP_DEBUG
  1002.         logMsg  ("enp%d: lost carriern",
  1003.                 pDrvCtrl->idr.ac_if.if_unit, 0, 0, 0, 0, 0);
  1004. #endif
  1005.         }
  1007.     while (pDrvCtrl->idr.ac_if.if_snd.ifq_head)
  1008.         {
  1009.         IF_DEQUEUE (&pDrvCtrl->idr.ac_if.if_snd, pMbuf);
  1011.         /* If no resource available, discard packet */
  1013.         if (enpringempty ((RING *) &pDev->enp_hostfree))
  1014.             {
  1015.             if (pMbuf != NULL)
  1016.                 m_freem (pMbuf);
  1017.             break;
  1018.             }
  1020.         pBCB = (BCB *) enpringget ((RING *)&pDev->enp_hostfree);
  1022.         /* Get pointer to buffer to fill with outgoing packet */
  1024.         READLONG ((&pBCB->b_addr),  &bufStart);
  1025.         bufStart = (u_char *) ntohl ((int)bufStart);
  1026.         pBuf = bufStart;
  1028.         /* copy data from mbufs to enp a word at a time.
  1029.          * most other netif drivers use copy_from_mbufs() to accomplish
  1030.          * this task.  we're doing this manually here because we
  1031.          * need to take care of a special case (hkv2f + ENP, see below).
  1032.          */
  1034.         pTempMbuf = pMbuf;                      /* copy ptr */
  1036.         while (pTempMbuf != NULL)
  1037.             {
  1038.             /* if destination adrs starts at odd byte boundary
  1039.              * copy a byte at a time.  copying a word from hkv2f into ENP memory
  1040.              * starting at an odd byte causes problems.
  1041.              */
  1042.             if (((int) pBuf & 1) == 1)
  1043.                 bcopyBytes  (
  1044.                             mtod (pTempMbuf, char *),
  1045.                             (char *) pBuf,
  1046.                             (int) pTempMbuf->m_len
  1047.                             );
  1048.             else
  1049.                 {
  1050.                 blen = pTempMbuf->m_len >> 1;
  1052.                 /* copy 2 bytes at a time */
  1054.                 bcopyWords (mtod (pTempMbuf, char *), (char *) pBuf, blen);
  1056.                 /* copy the remaining byte if any */
  1058.                 blen <<= 1;
  1059.                 if (blen != pTempMbuf->m_len)
  1060.                     {
  1061.                     *((char *) (pBuf + blen)) =
  1062.                         *((char *) (mtod (pTempMbuf, char *) + blen));
  1063.                     }
  1064.                 }
  1066.             /* Move pointer ahead, and get next mbuf pointer */
  1068.             pBuf += pTempMbuf->m_len;
  1069.             pTempMbuf = pTempMbuf->m_next;
  1070.             }
  1072.         /* Done with mbufs, release them to system */
  1074.         m_freem (pMbuf);
  1076.         /* Set length of packet */
  1078.         blen = max ( MINPKTSIZE, ((int) pBuf - (int) bufStart) );
  1079.         pBCB->b_len = htons (blen);
  1081.         /* Put the BCB on the outgoing ring, and if this is the only entry on
  1082.          * the ring, generate an interrupt to the ENP by writing to the special
  1083.          * location in the shared memory space.  Some boards require this
  1084.          * interrupt, while others work fine without it, and still others 
  1085.          * perform a reset instead of the interrupt.  Go figure.
  1086.          */
  1088.         if ( enpringput ((RING *) & pDev->enp_toenp, pBCB) == 1 )
  1089.             pDev->enp_iow.hst2enp_interrupt = ENPVAL;
  1091.         /* Bump the statistic counter. */
  1093.         pDrvCtrl->idr.ac_if.if_opackets++;
  1094.         }
  1095.     return;
  1096.     }
  1097. #endif
  1099. /*******************************************************************************
  1100. *
  1101. * enpIoctl - ioctl for interface
  1102. *
  1103. * RETURNS: 0, or EINVAL
  1104. */
  1106. LOCAL int enpIoctl
  1107.     (
  1108.     IDR *pIDR,
  1109.     int cmd,
  1110.     caddr_t data
  1111.     )
  1112.     {
  1113.     int error;
  1114.     ENPDEVICE* pEnpDev;
  1115.     DRV_CTRL* pDrvCtrl;
  1116.     
  1117.     pDrvCtrl = & drvCtrl [pIDR->ac_if.if_unit];
  1119. #ifdef ENP_DEBUG
  1120.     printf ( "enp: ioctl: pIDR=%x, cmd=%x, data=%xn", pIDR, cmd, data );
  1121. #endif
  1123.     error = 0;
  1125.     switch (cmd)
  1126.         {
  1127.         case SIOCSIFADDR:
  1128.             ((struct arpcom *)pIDR)->ac_ipaddr = IA_SIN (data)->sin_addr;
  1129.             arpwhohas (pIDR, &IA_SIN (data)->sin_addr);
  1130.             break;
  1132.         case SIOCSIFFLAGS:
  1133.             /* set promiscuous bit according to flags */
  1135.             if (pDrvCtrl->idr.ac_if.if_flags & IFF_PROMISC) 
  1136.                 {
  1137.                 pEnpDev = pDrvCtrl->enpAddr;
  1138.                 pEnpDev->enp_mode |= 0x1000;
  1139.                 }
  1140.             else
  1141.                 {
  1142.                 pEnpDev = pDrvCtrl->enpAddr;
  1143.                 pEnpDev->enp_mode &= ~0x1000;
  1144.                 }   
  1145.             break;
  1147.             /* Just set the thing into promiscuous mode. */
  1148.         case SIOCADDMULTI:
  1149.         case SIOCDELMULTI:
  1150.             pEnpDev = pDrvCtrl->enpAddr;
  1151.             pEnpDev->enp_mode |= 0x1000;
  1152.             break;
  1153.         default:
  1154.             error = EINVAL;
  1155.         }
  1157.     return (error);
  1158.     }
  1160. /*******************************************************************************
  1161. *
  1162. * enpgetaddr - get hardwired ethernet address.
  1163. *
  1164. * Read the ethernet address off the board, one byte at a time.
  1165. *
  1166. * INTERNAL
  1167. * CMC changed the LINK-10 ROMs and did not make the change
  1168. * to ENPDEVICE backward compatable with v3.x.
  1169. * To determine the proper ENPDEVICE structure (or rather LINK-10
  1170. * revision) the Ethernet base address should be 0.
  1171. * If it is we assume that the LINK-10 PROMs are v4.0.
  1172. * This assumtion is based on the hope that the new LINK-10 ROMs will
  1173. * leave the RING32 buffers that were inserted in the ENPDEVICE structure
  1174. * set to 0 after a reset. This seems to work. (see if_enp.h for differences
  1175. * in the ENPDEVICE structure).
  1176. * The fields e_stat, and/or e_netaddr (AKA enp_stat and enp_addr) should
  1177. * are dependent on the ROM version.
  1178. */
  1180. LOCAL void enpgetaddr
  1181.     (
  1182.     int unit
  1183.     )
  1184.     {
  1185.     DRV_CTRL *pDrvCtrl          = & drvCtrl[unit];
  1186.     ENPDEVICE_OLD *oldaddr = (ENPDEVICE_OLD *) pDrvCtrl->enpAddr;
  1187.     ENPDEVICE     *addr    = pDrvCtrl->enpAddr;
  1188.     USHORT        *pChk    = (USHORT *) &oldaddr->enp_addr.e_baseaddr;
  1190.     /* check version of LINK-10 PROMs */
  1192.     enpNewROM = (*pChk == 0x00);        /* TRUE = new ROMs */
  1194.     if (enpNewROM)
  1195.         {
  1196.         bcopyBytes  (
  1197.                     (caddr_t) & addr->enp_addr.e_baseaddr,
  1198.                     (caddr_t) pDrvCtrl->idr.ac_enaddr,
  1199.                     sizeof (pDrvCtrl->idr.ac_enaddr)
  1200.                     );
  1201.         }
  1202.     else
  1203.         {
  1204.         /* CMC LINK-10 v4.0 PROMs */
  1205.         bcopyBytes  (
  1206.                     (caddr_t) & oldaddr->enp_addr.e_baseaddr,
  1207.                     (caddr_t) pDrvCtrl->idr.ac_enaddr,
  1208.                     sizeof (pDrvCtrl->idr.ac_enaddr)
  1209.                     );
  1210.         }
  1211.     }
  1213. /*******************************************************************************
  1214. *
  1215. * enpringempty - check for ring empty.
  1216. *
  1217. * RETURNS: TRUE or FALSE
  1218. */
  1220. LOCAL BOOL enpringempty
  1221.     (
  1222.     RING *rp
  1223.     )
  1224.     {
  1225.     return (rp->r_rdidx == rp->r_wrtidx);
  1226.     }
  1228. /*******************************************************************************
  1229. *
  1230. * enpringput - write to next ring location
  1231. *
  1232. * RETURNS: Number of entries left in ring or 0 if full.
  1233. */
  1235. LOCAL int enpringput
  1236.     (
  1237.     RING *rp,
  1238.     BCB *pBCB
  1239.     )
  1240.     {
  1241.     int idx;
  1242.     int wrtidx = ntohs (rp->r_wrtidx);
  1243.     int rdidx  = ntohs (rp->r_rdidx);
  1244.     int size   = ntohs (rp->r_size);
  1246.     idx = (wrtidx + 1) & (size-1);
  1248.     if (idx != rdidx)
  1249.         {
  1250.         pBCB = (BCB *) htonl ((u_long) pBCB);
  1251.         WRITELONG (&rp->r_slot[ wrtidx ], pBCB);
  1252.         rp->r_wrtidx = htons (idx);
  1254.         CACHE_PIPE_FLUSH ();
  1256.         if ((idx -= rdidx) < 0)
  1257.             idx += size;
  1259.         return (idx);                   /* num ring entries */
  1260.         }
  1262.     return (0);
  1263.     }
  1265. /*******************************************************************************
  1266. *
  1267. * enpringget - get the next item from a ring
  1268. *
  1269. * RETURNS: Pointer to next item or 0 if none.
  1270. */
  1272. LOCAL int enpringget
  1273.     (
  1274.     RING *rp
  1275.     )
  1276.     {
  1277.     int buf = 0;
  1278.     int wrtidx = ntohs (rp->r_wrtidx);
  1279.     int rdidx  = ntohs (rp->r_rdidx);
  1280.     int size   = ntohs (rp->r_size);
  1282.     if  (rdidx != wrtidx)
  1283.         {
  1284.         READLONG (&rp->r_slot [rdidx], &buf);
  1285.         buf = ntohl (buf);
  1286.         rp->r_rdidx = htons ((++rdidx) & (size-1));
  1287.         CACHE_PIPE_FLUSH ();
  1288.         }
  1290.     return (buf);
  1291.     }
  1293. /*******************************************************************************
  1294. *
  1295. * enpShow - show ENP-10 statistics
  1296. *
  1297. * INTERNAL
  1298. * This works only on some versions of the ENP 10/L onboard software
  1299. * e.g. LINK-10 4.0 is fine, 3.1 is not.
  1300. *
  1301. * RETURNS: 0
  1302. *
  1303. * NOMANUAL
  1304. */
  1306. STATUS enpShow
  1307.     (
  1308.     int unit,   /* interface unit */
  1309.     BOOL zap    /* zero totals */
  1310.     )
  1311.     {
  1312.     int             ix;
  1313.     int             status;
  1314.     DRV_CTRL        *pDrvCtrl;
  1315.     ENPDEVICE       *addr;
  1316.     ENPDEVICE_OLD   *oldaddr;
  1318.     static char *e_message [] =
  1319.         {
  1320.         "successful transmissions",
  1321.         "multiple retries on xmit",
  1322.         "single retries",
  1323.         "too many retries",
  1324.         "transmission delayed",
  1325.         "xmit data chaining failed",
  1326.         "transmit data fetch failed",
  1327.         "collision after xmit",
  1328.         "lost carrier",
  1329.         "xmit length > 1518",
  1330.         "transceiver mismatch",
  1331.         "xmit memory error",
  1332.         "good receptions",
  1333.         "no recv buff available",
  1334.         "checksum failed",
  1335.         "crc error AND data length != 0 mod 8",
  1336.         "rcv data chain failure",
  1337.         "receive data store failed",
  1338.         "rcv memory error"
  1339.         };
  1341.     /* Safety check unit number */
  1343.     if (unit < 0 || unit >= MAX_UNITS)
  1344.         {
  1345.         errnoSet (S_iosLib_CONTROLLER_NOT_PRESENT);
  1346.         return (ERROR);
  1347.         }
  1349.     pDrvCtrl = & drvCtrl [unit];
  1350.     addr     = pDrvCtrl->enpAddr;
  1351.     oldaddr  = (ENPDEVICE_OLD *) pDrvCtrl->enpAddr;
  1353.     printf ("enp%d (v%s):n", unit, (enpNewROM ? "4.x" : "3.x"));
  1355.     for (ix = 0; ix < NELEMENTS(e_message); ix++)
  1356.         {
  1357.         if (enpNewROM)
  1358.             {
  1359.             READLONG ((&addr->enp_stat.e_stat [ix]), &status);
  1360.             }
  1361.         else
  1362.             {
  1363.             READLONG ((&oldaddr->enp_stat.e_stat [ix]), &status);
  1364.             }
  1366.         status = ntohl (status);
  1367.         printf ("    %-30.30s  %4dn", e_message [ix],
  1368.                 status - pDrvCtrl->enpStat.e_stat [ix]);
  1369.         if (zap)
  1370.             pDrvCtrl->enpStat.e_stat [ix] = status;
  1371.         }
  1373.     return (OK);
  1374.     }
  1376. #if     FALSE
  1377. /*******************************************************************************
  1378. *
  1379. * enpDumpRing - dump particular ring
  1380. *
  1381. * RETURNS: N/A
  1382. */
  1384. LOCAL void enpDumpRing (rn, rp)
  1385.     char *rn;           /* ring name */
  1386.     RING32 *rp;         /* ring pointer */
  1388.     {
  1389.     int ix;
  1390.     int temp;
  1392.     printf ("    %s: rdidx = 0x%04.4x, wridx = 0x%04.4x, size = 0x%04.4xn",
  1393.         rn, ntohs (rp->r_rdidx), ntohs (rp->r_wrtidx), ntohs (rp->r_size));
  1395.     for (ix = 0; ix < 32;)
  1396.         {
  1397.         if ((ix % 6) == 0)
  1398.             printf ("      ");
  1400.         READLONG (&rp->r_slot[ix], &temp);
  1401.         printf ("%02.2d:%08.8x ", ix , ntohl (temp));
  1403.         if ((++ix % 6) == 0)
  1404.             printf ("n");
  1405.         }
  1406.     printf ("n");
  1407.     }
  1409. /*******************************************************************************
  1410. *
  1411. * enpDump - dump ring
  1412. *
  1413. * RETURNS: N/A
  1414. *
  1415. * NOMANUAL
  1416. */
  1418. void enpDump (unit, ring)
  1419.     int unit;           /* interface unit */
  1420.     BOOL ring;          /* true if dump ring structure */
  1421.     {
  1422.     DRV_CTRL *pDrvCtrl          = & drvCtrl[unit];
  1423.     ENPDEVICE *addr        = pDrvCtrl->enpAddr;
  1424.     ENPDEVICE_OLD *oldaddr = (ENPDEVICE_OLD *) pDrvCtrl->enpAddr;
  1425.     int temp;
  1427.     if (enpNewROM)
  1428.         {
  1429.         temp = ntohs (addr->enp_state);
  1430.         printf ("enp%d: is %sn", unit, temp & S_ENPRUN ? "running" : "down!");
  1432.         if ((temp & S_ENPRUN) == 0x0)
  1433.             return;
  1435.         printf ("    state = 0x%04.4x, mode  = 0x%04.4xn",
  1436.             ntohs (addr->enp_state), ntohs (addr->enp_mode) );
  1437.         READLONG (&addr->enp_base, &temp);
  1438.         printf ("    base  = 0x%08.8xn", ntohl (temp));
  1439.         printf ("    run   = 0x%04.4x, ivec  = 0x%04.4xnn",
  1440.             ntohs (addr->enp_enprun), ntohs (addr->enp_intvector));
  1442.         if (ring)
  1443.             {
  1444.             enpDumpRing ("toenp",    &addr->enp_toenp);
  1445.             enpDumpRing ("hostfree", &addr->enp_hostfree);
  1446.             enpDumpRing ("tohost",   &addr->enp_tohost);
  1447.             enpDumpRing ("enpfree",  &addr->enp_enpfree);
  1448.          /* enpDumpRing ("rcvdma",   &addr->enp_rcvdma); */
  1449.          /* enpDumpRing ("rcv_d",    &addr->enp_rvc_d); */
  1450.             }
  1451.         }
  1452.     else
  1453.         {
  1454.         temp = ntohs (oldaddr->enp_state);
  1455.         printf ("enp%d: is %sn", unit, temp & S_ENPRUN ? "running" : "down!");
  1457.         if ((temp & S_ENPRUN) == 0x0)
  1458.             return;
  1460.         printf ("    state = 0x%04.4x, mode  = 0x%04.4xn",
  1461.                 ntohs (oldaddr->enp_state), ntohs (oldaddr->enp_mode) );
  1462.         READLONG (&oldaddr->enp_base, &temp);
  1463.         printf ("    base  = 0x%08.8xn", ntohl (temp));
  1464.         printf ("    run   = 0x%04.4x, ivec  = 0x%04.4xnn",
  1465.                 ntohs (oldaddr->enp_enprun), ntohs (oldaddr->enp_intvector));
  1467.         if (ring)
  1468.             {
  1469.             enpDumpRing ("toenp",    &oldaddr->enp_toenp);
  1470.             enpDumpRing ("hostfree", &oldaddr->enp_hostfree);
  1471.             enpDumpRing ("tohost",   &oldaddr->enp_tohost);
  1472.             enpDumpRing ("enpfree",  &oldaddr->enp_enpfree);
  1473.             }
  1474.         }
  1475.     }
  1476. #endif  /* FALSE */
  1478. #ifdef BSD43_DRIVER
  1480. #include "sys/socket.h"
  1482. /*******************************************************************************
  1483. *
  1484. * convertDestAddr - converts socket addr into enet addr and packet type
  1485. *
  1486. */
  1488. static BOOL convertDestAddr
  1489.     (
  1490.     IDR *pIDR,                          /* ptr to i/f data record */
  1491.     SOCK *pDestSktAddr,                 /* ptr to a generic sock addr */
  1492.     char *pDestEnetAddr,                /* where to write enet addr */
  1493.     u_short *pPacketType,               /* where to write packet type */
  1494.     MBUF *pMbuf                         /* ptr to mbuf data */
  1495.     )
  1496.     {
  1497.     extern BOOL arpresolve();           /* we call this */
  1499.     /***** Internet family *****/
  1501.     {
  1502.     struct in_addr destIPAddr;              /* not used */
  1503.     int trailers;                           /* not supported */
  1505.      if (pDestSktAddr->sa_family == AF_INET)
  1506.         {
  1507.         *pPacketType = htons(ETHERTYPE_IP);            /* stuff packet type */
  1508.         destIPAddr = ((struct sockaddr_in *) pDestSktAddr)->sin_addr;
  1510.         if (!arpresolve (pIDR, pMbuf, &destIPAddr, pDestEnetAddr, &trailers))
  1511.             return (FALSE);     /* if not yet resolved */
  1513.         return (TRUE);
  1514.         }
  1515.     }
  1518.     /***** Generic family *****/
  1520.     {
  1521.     ENET_HDR *pEnetHdr;
  1523.     if (pDestSktAddr->sa_family == AF_UNSPEC)
  1524.         {
  1525.         pEnetHdr = (ENET_HDR *) pDestSktAddr->sa_data;      /* ptr to hdr */
  1526.         bcopy (pEnetHdr->dst, pDestEnetAddr, 6);            /* copy dst addr */
  1527.         *pPacketType = htons(pEnetHdr->type);                      /* copy type */
  1528.         return (TRUE);
  1529.         }
  1530.     }
  1533.     /* Unsupported family */
  1535.     return (FALSE);
  1537.     } /* End of convertDestAddr() */
  1538. #endif
  1540. /* END OF FILE */