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

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

VxWorks

开发平台：

C/C++

if_fn.c：源码内容
  1. /* if_fn.c - Fujitsu MB86960 NICE Ethernet network interface driver */
  3. /* Copyright 1992-1997 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01v,15jul97,spm  added ARP request to SIOCSIFADDR ioctl handler
  10. 01u,07apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  11. 01t,02mar95,jdi  fixed line break in fnattach() title.
  12. 01s,05jul94,vin  removed spl calls, fixed collision control
  13. 01r,10may94,vin  fixed input parameter passed to etherInputHook
  14. 01q,04mar94,vin  added input & output hooks, removed explicit copying from
  15.  mbufs in the fnOutput(). Alternate scheme to detect 
  16.  transmit done implemented which negates the requirement for
  17.  processing the transmit done interrupt. 
  18. 01p,07jul93,rfs  Fixed SPR #2374.
  19. 01o,11aug93,jmm  Changed ioctl.h and socket.h to sys/ioctl.h and sys/socket.h
  20. 01n,19feb93,jdi  documentation cleanup.
  21. 01m,22oct92,rfs  Fixed SPR #1710.
  22. 01l,13oct92,rfs  Added documentation.
  23. 01k,02oct92,rfs  Made multiple attach calls return OK, not ERROR.
  24. 01j,09sep92,gae  documentation tweaks.
  25. 01i,31aug92,rfs  Free MBUFs on output if flags down.
  26. 01h,16jul92,rfs  Consolidated attach() and init().
  27. 01g,11jul92,jwt  incorporated JDI documentation cleanup; SPARC #ifdefs.
  28. 01f,16jun92,jwt  passed through the ansification filter
  29.                  -changed includes to have absolute path from h/
  30.                  -fixed #else and #endif
  31.                  -changed copyright notice
  32.                  -fixed path names for #include files.
  33. 01e,14may92,rfs  Added semaphore for transmitter access. Added one-time-only
  34.                  calling of the attach() and init() routines.  Reduced size
  35.                  of SRAM buffer.
  36. 01d,14apr92,rfs  Changed Rx to only look at "good packet" status bit.
  37.                  Changed all splnet() to splimp().
  38. 01c,25mar92,jwt  enhanced interrupt and cache support; cleanup.
  39. 01b,24mar92,rfs  Moved sysEnet* () support routines to the sysLib.
  40.                  Changed the attach and init routines to support new
  41.                  method of obtaining board specific parameters.
  42.                  Changed name of the NICE device header file.
  43.                  Changed the name of the support routines called to access
  44.                  ASI space.
  45. 01a,10mar92,rfs  Created from mule driver source.
  46. */
  48. /*
  49. This module implements the Fujitsu MB86960 NICE Ethernet network interface
  50. driver.
  52. This driver is non-generic and has only been run on the Fujitsu SPARClite
  53. Evaluation Board.  It currently supports only unit number zero.
  54. The driver must be given several target-specific parameters, and some external
  55. support routines must be provided.  These parameters, and the mechanisms used
  56. to communicate them to the driver, are detailed below.
  58. BOARD LAYOUT
  59. This device is on-board.  No jumpering diagram is necessary.
  61. EXTERNAL INTERFACE
  62. This driver provides the standard external interface with the following
  63. exceptions.  All initialization is performed within the attach routine;
  64. there is no separate initialization routine.  Therefore, in the global interface
  65. structure, the function pointer to the initialization routine is NULL.
  67. The only user-callable routine is fnattach(), which publishes the `fn'
  68. interface and initializes the driver and device.
  70. TARGET-SPECIFIC PARAMETERS
  71. External support routines provide all parameters:
  72. .iP "device I/O address"
  73. This parameter specifies the base address of the device's I/O register
  74. set.  This address is assumed to live in SPARClite alternate address
  75. space.
  76. .iP "interrupt vector"
  77. This parameter specifies the interrupt vector to be used by the driver
  78. to service an interrupt from the NICE device.  The driver will connect
  79. the interrupt handler to this vector by calling intConnect().
  80. .iP "Ethernet address"
  81. This parameter specifies the unique, six-byte address assigned to the
  82. VxWorks target on the Ethernet.
  83. .LP
  85. EXTERNAL SUPPORT REQUIREMENTS
  86. This driver requires five external support functions:
  87. .iP "char *sysEnetIOAddrGet (int unit)" "" 9 -1
  88. This routine returns the base address of the NICE
  89. control registers.  The driver calls this routine 
  90. once, using fnattach().
  91. .iP "int sysEnetVectGet (int unit)"
  92. This routine returns the interrupt vector number
  93. to be used to connect the driver's interrupt handler.
  94. The driver calls this routine once, using fnattach().
  95. .iP "STATUS sysEnetAddrGet (int unit, char *pCopy)"
  96. This routine provides the six-byte Ethernet address
  97. used by <unit>.  It must copy the six-byte
  98. address to the space provided by <pCopy>.  It 
  99. returns OK, or ERROR if it fails.
  100. The driver calls this routine once, using fnattach().
  101. .iP "void sysEnetIntEnable (int unit), void sysEnetIntDisable (int unit)"
  102. These routines enable or disable the interrupt from the NICE for the
  103. specified <unit>.  Typically, this involves interrupt controller hardware,
  104. either internal or external to the CPU.  The driver calls these 
  105. routines only during initialization, using fnattach().
  106. .LP
  108. SYSTEM RESOURCE USAGE
  109. When implemented, this driver requires the following system resources:
  111.     - one mutual exclusion semaphore
  112.     - one interrupt vector
  113.     - 3944 bytes in text section (text)
  114.     - 0 bytes in the initialized data section (data)
  115.     - 3152 bytes in the uninitialized data section (BSS)
  117. The above data and BSS requirements are for the SPARClite architecture and may
  118. vary for other architectures.  Code size (text) varies greatly between
  119. architectures and is therefore not quoted here.
  121. The NICE device maintains a private buffer for all packets transmitted and
  122. received.  Therefore, the driver does not require any system memory to share
  123. with the device.  This also eliminates all data cache coherency issues.
  125. SEE ALSO: ifLib
  126. */
  128. /* includes */
  130. #include "vxWorks.h"            /* direct references */
  131. #include "sys/types.h"          /* direct references */
  132. #include "sys/ioctl.h"          /* direct references */
  133. #include "sys/socket.h" /* direct references */
  134. #include "net/mbuf.h"           /* direct references */
  135. #include "net/if.h"             /* direct and indirect references */
  136. #include "net/if_subr.h"
  137. #include "netinet/in.h"         /* indirect references only */
  138. #include "netinet/in_systm.h"   /* indirect references only */
  139. #include "netinet/in_var.h"     /* direct references */
  140. #include "netinet/if_ether.h"   /* direct references */
  141. #include "iv.h"                 /* direct references */
  142. #include "errno.h"              /* direct references */
  143. #include "semLib.h"             /* direct references */
  144. #include "intLib.h"
  145. #include "logLib.h"
  146. #include "netLib.h"
  147. #include "etherLib.h"
  148. #include "stdio.h"
  149. #include "drv/netif/if_fn.h"    /* device description */
  151. /***** COMPILATION SWITCHES *****/
  153. #undef FN_DEBUG
  156. /* defines */
  158. #define MAX_UNITS 1 /* maximum units supported */ 
  159. #define DRV_CTRL_SIZ sizeof (DRV_CTRL)
  160. #define ENET_HDR_REAL_SIZ 14
  162. /* Pre-defined interrupt masks */
  164. #define NORM_INTRMASK    (DLCR3_RX_PKT | DLCR3_OVR_FLO) 
  165. #define NO_RX_INTRMASK   (DLCR3_OVR_FLO)
  167. /* Start transmission */
  169. #define KICK_TRANSMIT (BMR10_TMST | BMR11_MASK16 | BMR11_RST_TX16 
  170.  | BMR11_OPT_16_COLL | 0x0100) 
  172. /* typedefs */
  174. typedef struct arpcom IDR;
  176. typedef struct nice_ctrl /* Driver control structure */
  177.     {
  178.     IDR idr;  /* interface data record */
  179.     BOOL attached; /* indicates unit is attached */
  180.     char *pDev; /* ptr to the device registers */
  181.     int vector; /* vector number to use */
  182. #ifdef BSD43_DRIVER
  183.     SEM_ID TxSem; /* transmitter semaphore */
  184. #endif
  185.     } DRV_CTRL;
  187. /* shorthand for struct members */
  189. #define fn_if  idr.ac_if
  190. #define fn_enaddr  idr.ac_enaddr
  192. /* Debug support */
  194. #ifdef FN_DEBUG
  195. #define DEBUG_SPEC  (fnDebug & 0x01)        /* debug special routines */
  196. #define DEBUG_TX    (fnDebug & 0x02)        /* debug transmit routines */
  197. #define DEBUG_RX    (fnDebug & 0x04)        /* debug receive routines */
  198. #define DEBUG_INTR  (fnDebug & 0x08)        /* debug interrupt routines */
  199. #endif /* FN_DEBUG */
  201. /* globals */
  203. #ifdef FN_DEBUG
  204. int fnDebug;                    /* set this from shell to select debugging */
  205. #endif /* FN_DEBUG */
  208. /* External functions not defined in any header files.
  209.  * Some of these are the functions required of the BSP modules.
  210.  */
  212. extern char *   sysEnetIOAddrGet ();
  213. extern int      sysEnetVectGet ();
  214. extern STATUS   sysEnetAddrGet ();
  215. extern STATUS   sysEnetIntEnable ();
  216. extern STATUS   sysEnetIntDisable ();
  217. extern STATUS   sysEnetIntAck ();
  218. extern BOOL arpresolve ();
  220. /* External functions that access the alternate address space that the
  221.  * device lives in.
  222.  */
  224. #if (CPU_FAMILY == SPARC)
  225. extern u_short      sysAsiGeth();
  226. extern void         sysAsiSeth();
  227. #endif
  229. /* locals */
  231. /* driver control structures, one per unit */ 
  233. LOCAL DRV_CTRL drvCtrl [MAX_UNITS];  
  235. LOCAL int overFlowCnt; /* overFlow Count */
  236. LOCAL int rcvPktError; /* receive packet error */
  238. /* forward declarations */
  240. LOCAL int fnIoctl (struct ifnet * pIfnet, int cmd, char * pArgs);
  241. LOCAL int fnReset (int unit);
  242. #ifdef BSD43_DRIVER
  243. LOCAL int fnOutput (struct arpcom * pIDR, struct mbuf * pMbuf,
  244.   struct sockaddr * pDest);
  245. #else
  246. LOCAL int       fnTxStartup (DRV_CTRL *pDrvCtrl);
  247. #endif
  248. LOCAL void fnRxEvent (DRV_CTRL *pDrvCtrl);
  249. LOCAL BOOL fnRxMore (DRV_CTRL *pDrvCtrl);
  250. LOCAL STATUS fnRxProcessPkt (DRV_CTRL *pDrvCtrl);
  251. LOCAL void fnIntr (int unit);
  252. #ifdef BSD43_DRIVER
  253. LOCAL BOOL convertDestAddr (IDR *pIdr, struct sockaddr * pDestSktAddr, 
  254.  char * pDestEnetAddr, u_short * pPacketType,
  255.  struct mbuf * pMbuf);
  256. #endif
  258. /*******************************************************************************
  259. *
  260. * fnattach - publish the `fn' network interface and initialize the driver and device
  261. *
  262. * The routine publishes the `fn' interface by filling in a network interface
  263. * record and adding this record to the system list.  This routine also
  264. * initializes the driver and the device to the operational state.
  265. *
  266. * RETURNS: OK or ERROR.
  267. */
  269. STATUS fnattach
  270.     (
  271.     int unit /* unit number */
  272.     )
  273.     {
  274.     char * pDev; /* ptr to the device */
  275.     DRV_CTRL *  pDrvCtrl;
  277.     /* Sanity check the unit number */
  279.     if (unit < 0 || unit >= MAX_UNITS)
  280.         return (ERROR);
  282.     /* Ensure single invocation per system life */
  284.     pDrvCtrl = & drvCtrl [unit];
  285.     if (pDrvCtrl->attached)
  286.         return (OK);
  288.     /* Publish our existence as an available interface */
  290. #ifdef BSD43_DRIVER
  291.     ether_attach (&pDrvCtrl->fn_if, unit, "fn", NULL, fnIoctl, 
  292.                   fnOutput, fnReset);
  293. #else
  294.     ether_attach (
  295.                  &pDrvCtrl->fn_if, 
  296.                  unit,
  297.                  "fn",
  298.                  (FUNCPTR) NULL,
  299.                  (FUNCPTR) fnIoctl,
  300.                  (FUNCPTR) ether_output,
  301.                  (FUNCPTR) fnReset
  302.                  );
  303.     pDrvCtrl->fn_if.if_start = (FUNCPTR)fnTxStartup;
  304. #endif
  306. { /*   Driver initialization    */
  308. /* First obtain the board and unit specific info from the BSP. */
  310. pDev = sysEnetIOAddrGet (unit);
  311. if (pDev == NULL)
  312.     {
  313.     printf ("fn: error obtaining IO addrn");
  314.     return (ERROR);
  315.     }
  316. pDrvCtrl->pDev = pDev;                  /* save ptr in ctrl struct */
  318. pDrvCtrl->vector = sysEnetVectGet (unit);
  319. if (pDrvCtrl->vector == NULL)
  320.     {
  321.     printf ("fn: error obtaining interrupt vectorn");
  322.     return (ERROR);
  323.     }
  325. if (sysEnetAddrGet (unit, pDrvCtrl->fn_enaddr) == ERROR)
  326.     {
  327.     printf ("fn: error obtaining Ethernet addressn");
  328.     return (ERROR);
  329.     }
  331. #ifdef BSD43_DRIVER
  332. pDrvCtrl->TxSem = semMCreate    (
  333.  SEM_Q_PRIORITY |
  334.  SEM_DELETE_SAFE |
  335.  SEM_INVERSION_SAFE
  336. );
  338. if (pDrvCtrl->TxSem == NULL)
  339.     {
  340.     printf ("fn: error creating transmitter semaphoren");
  341.     return (ERROR);
  342.     }
  343. #endif
  345. /* Connect the interrupt routine. */
  347. intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (pDrvCtrl->vector), fnIntr, 
  348.     unit);
  350. } /* End block */
  352. { /*    device initialization    */
  354. /* Block local variables */
  356. u_short temp;                               /* scratch pad */
  358. /* initial setup of config register 1 */
  360. #if (CPU_FAMILY == SPARC)
  361. sysAsiSeth  (pDev + NICE_CONFIG,
  362.      DLCR6_DISABLE_DLC   |           /* resets things */
  363.      DLCR6_BIT_6         |           /* just do it */
  364.      DLCR6_SYS_BUS_16    |           /* use 16 bits */
  365.      DLCR6_BUF_BUS_16    |           /* use 16 bits */
  366.      DLCR6_TBS_4KB       |           /* Tx buf is 4kb */
  367.      DLCR6_BS_16KB       |           /* total buf is 16k */
  368.      DLCR7_CNF_NICE      |           /* normal NICE mode */
  369.      DLCR7_PWRDN_OFF     |           /* normal power mode */
  370.      DLCR7_BIT_4         |           /* just do it */
  371.      DLCR7_REG_BNK_DLC   |           /* map node ID regs */
  372.      DLCR7_ENDIAN_LITTLE             /* device is little */
  373.      );
  374. #endif
  376. /* Mask off all interrupts and clear all event flags. */
  378. #if (CPU_FAMILY == SPARC)
  379. sysAsiSeth (pDev + NICE_INTRMASK, 0);
  380. sysAsiSeth (pDev + NICE_STATUS, 0xffff);
  381. #endif
  383. /* Disable device interrupt at system level and clear any pended. */
  385. sysEnetIntDisable (unit);
  387. /* The secondary DLC register group is mapped in.  Set the node ID. */
  389. #if (CPU_FAMILY == SPARC)
  390. sysAsiSeth (pDev + NICE_ADDR1, ((u_short *) pDrvCtrl->fn_enaddr) [0]);
  391. sysAsiSeth (pDev + NICE_ADDR2, ((u_short *) pDrvCtrl->fn_enaddr) [1]);
  392. sysAsiSeth (pDev + NICE_ADDR3, ((u_short *) pDrvCtrl->fn_enaddr) [2]);
  393. #endif
  395. /* Change register map. Select buffer memory register group. */
  397. #if (CPU_FAMILY == SPARC)
  398. temp = sysAsiGeth (pDev + NICE_CONFIG);
  399. #endif
  401. temp &= ~DLCR7_REG_BNK; /* clear bank select bits */
  402. temp |= DLCR7_REG_BNK_BMR; /* add desired bits */
  404. #if (CPU_FAMILY == SPARC)
  405. sysAsiSeth (pDev + NICE_CONFIG, temp);
  406. #endif
  408. /* Setup the receiver and transmitter modes. */
  410. #if (CPU_FAMILY == SPARC)
  411. sysAsiSeth (pDev + NICE_MODE, DLCR4_LBC | DLCR5_BIT_2 | DLCR5_AF0);
  412. #endif
  414. /* Do the board specific interrupt enable for the device. */
  416. sysEnetIntEnable (unit);
  418. /* Enable specific interrupts. */
  420. #if (CPU_FAMILY == SPARC)
  421. sysAsiSeth (pDev + NICE_INTRMASK, NORM_INTRMASK);
  422. #endif
  424. /* Enable the DLC. */
  426. #if (CPU_FAMILY == SPARC)
  427. temp = sysAsiGeth (pDev + NICE_CONFIG);     /* get config reg */
  428. #endif
  430. temp &= ~DLCR6_DISABLE_DLC;                 /* clear the disable bit */
  432. #if (CPU_FAMILY == SPARC)
  433. sysAsiSeth (pDev + NICE_CONFIG, temp);      /* update config reg */
  435. /* set collision control drop packet after 16 collisions */
  437. sysAsiSeth (pDev + NICE_TRANSMIT, (BMR11_MASK16 | BMR11_RST_TX16
  438.    | BMR11_OPT_16_COLL));
  439. #endif
  440. } /* End block */
  442.     /* Set our interface flags. */
  444.     pDrvCtrl->idr.ac_if.if_flags |= (IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);
  446.     /* That's all */
  448.     pDrvCtrl->attached = TRUE;
  449.     return (OK);
  451.     } /* End of fnattach() */
  453. /*******************************************************************************
  454. *
  455. * fnIoctl - the driver I/O control routine
  456. *
  457. * This routine will process an ioctl request 
  458. *
  459. * RETURNS: 0 or errno
  460. */
  462. LOCAL int fnIoctl 
  463.     (
  464.     struct ifnet * pIfnet, /* ptr to our interface struct */
  465.     int cmd, /* the command code */
  466.     char * pArgs /* ptr to the command arguments */
  467.     )
  468.     {
  469.     int errno; /* hold error value or zero */
  470.     int   unit = pIfnet->if_unit;
  471.     DRV_CTRL *  pDrvCtrl = &drvCtrl[unit];
  473. #ifdef FN_DEBUG
  474.     if (DEBUG_SPEC)
  475.         printf  (
  476.                 "fn: ioctl: pIfnet=%x  cmd=%x  pArgs=%xn",
  477.                 pIfnet, cmd, pArgs
  478.                 );
  479. #endif /* FN_DEBUG */
  481.     errno = 0;                              /* assume no error */
  483.     switch (cmd)
  484.         {
  485.         case SIOCSIFADDR:                   /* set i/f address */
  487. #ifdef FN_DEBUG
  488.             if (DEBUG_SPEC)
  489.                 printf ("fn: ioctl: set addrn");
  490. #endif /* FN_DEBUG */
  492.             /* copy the INET address into our arpcom structure */
  494.             pDrvCtrl->idr.ac_ipaddr = IA_SIN (pArgs)->sin_addr;
  495.             arpwhohas (pIfnet, &IA_SIN (pArgs)->sin_addr);
  497.             break;
  499.         case SIOCGIFADDR:                   /* get i/f address */
  501. #ifdef FN_DEBUG
  502.             if (DEBUG_SPEC)
  503.                 printf ("fn: ioctl: get addrn");
  504. #endif /* FN_DEBUG */
  506.             bcopy   (
  507.                     (caddr_t) pDrvCtrl->fn_enaddr,
  508.                     (caddr_t) ((struct ifreq *)pArgs)->ifr_addr.sa_data,
  509.                     6
  510.                     );
  511.             break;
  513.         case SIOCSIFFLAGS:                  /* set i/f flags */
  515. #ifdef FN_DEBUG
  516.             if (DEBUG_SPEC)
  517.                 printf ("fn: ioctl: set flagsn");
  518. #endif /* FN_DEBUG */
  520.             break;
  522.         case SIOCGIFFLAGS:                  /* get i/f flags */
  524. #ifdef FN_DEBUG
  525.             if (DEBUG_SPEC)
  526.                 printf ("fn: ioctl: get flagsn");
  527. #endif /* FN_DEBUG */
  529.             *(short *)pArgs = pIfnet->if_flags;
  530.             break;
  532.         default :
  533.             errno = EINVAL;
  534.         }
  536.     return (errno);
  538.     } /* End of fnIoctl() */
  540. /*******************************************************************************
  541. *
  542. * fnReset - the driver reset routine
  543. *
  544. * This routine resets the device
  545. *
  546. * RETURNS: OK.
  547. */
  549. LOCAL int fnReset 
  550.     (
  551.     int unit
  552.     )
  553.     {
  555. #ifdef FN_DEBUG
  556.     if (DEBUG_SPEC)
  557.         printf ("fnResetn");
  558. #endif /* FN_DEBUG */
  560.     return (OK);
  562.     } /* End of fnReset() */
  564. #ifdef BSD43_DRIVER
  565. /*******************************************************************************
  566. *
  567. * fnOutput - The driver's output routine
  568. *
  569. * This routine is responsible for tranmitting packets over physical media.
  570. * The destination address is passed to this function as a pointer to a
  571. * generic socket address structure.  This address information is first
  572. * converted to the six byte destination address and type field that we
  573. * need to build a proper Ethernet frame.
  574. *
  575. * The data to be sent out is held in a chain of mbufs.  This function is
  576. * passed a pointer to the head mbuf.  The data in each mbuf fragment must
  577. * be copied to the device's packet buffer.
  578. *
  579. * RETURNS: OK, or ERROR
  580. */
  582. LOCAL int fnOutput 
  583.     (
  584.     struct arpcom * pIDR, /* ptr to our interface struct */
  585.     struct mbuf * pMbuf, /* ptr to the mbufs to send */
  586.     struct sockaddr * pDest /* ptr to dest socket addr */
  587.     )
  588.     {
  589.     char  destEnetAddr [6]; /* space for enet addr */
  590.     u_short packetType; /* type field for the packet */
  591.     int pktLen; /* total length of packet */
  592.     int dataLen; /* real length of data portion */
  593.     int loopy; /* loop counter */
  594.     char *nicePort; /* ptr to the nice buffer port */
  595.     u_short *pSource; /* ptr to source of data byte */
  596.     DRV_CTRL *  pDrvCtrl;  /* ptr to driver control structure */
  597.     static char privateBuf [ETHERMTU + ENET_HDR_REAL_SIZ];
  599. #ifdef FN_DEBUG
  600.     if (DEBUG_TX)
  601.         printf  (
  602.                 "fn: Tx: pIfnet=%x  pMbuf=%x  pDest=%xn",
  603.                 pIfnet, pMbuf, pDest
  604.                 );
  605. #endif /* FN_DEBUG */
  607.     /* Check ifnet flags. Return error if incorrect. */
  609.     if  (
  610.         (pIfnet->if_flags & (IFF_UP | IFF_RUNNING)) !=
  611.         (IFF_UP | IFF_RUNNING)
  612.         )
  613.         {
  614.         m_freem (pMbuf);
  615.         return (ENETDOWN);
  616.         }
  618.     /* Attempt to convert socket addr into enet addr and packet type.
  619.      * Note that if ARP resolution of the address is required, the ARP
  620.      * module will call our routine again to transmit the ARP request
  621.      * packet.  This means we may actually call ourselves recursively!
  622.      */
  624.     if (convertDestAddr (pIDR, pDest, destEnetAddr, &packetType, pMbuf) 
  625.            == FALSE)
  626.         return (OK);    /* I KNOW returning OK is stupid, but it is correct */
  628.     /* Get driver control pointer */
  630.     pDrvCtrl = &drvCtrl [pIDR->ac_if.if_unit];
  632.     /* get ptr to the buffer port */
  634.     nicePort = pDrvCtrl->pDev + NICE_PORT;
  636.     semTake (pDrvCtrl->TxSem, WAIT_FOREVER); /* take the xmit semaphore */
  638.     bcopy (destEnetAddr, privateBuf, 6);
  639.     bcopy ( (char *) pDrvCtrl->fn_enaddr, (privateBuf + 6), 6);
  640.     ((struct ether_header *)privateBuf)->ether_type = packetType;
  641.     dataLen = 0;
  642.     copy_from_mbufs ((privateBuf + ENET_HDR_REAL_SIZ),
  643.   pMbuf, 
  644.   dataLen);  /* stuffed by macro */
  646. #ifdef FN_DEBUG
  647.     if (DEBUG_TX)
  648.         printf ("fn: Tx: dataLen=%dn", dataLen);
  649. #endif /* FN_DEBUG */
  650.     
  651.     /* Ensure we send a legal size frame. */
  653.     dataLen += ENET_HDR_REAL_SIZ;
  654.     pktLen = max (ETHERSMALL, dataLen);
  656.     /* taking care of short packets, pad with 0s */
  658.     if (dataLen < ETHERSMALL)
  659. for (loopy = dataLen; loopy < pktLen; loopy++)
  660.             privateBuf [loopy] = 0;
  662.     /*
  663.      * Support for network interface hooks. Call output hook
  664.      * if any specified. If the routine returns non-zero, 
  665.      * assume the hook has taken care of the frame (don't send
  666.      * on interface). See etherLib for more information
  667.      */
  669.     if ((etherOutputHookRtn != NULL) && 
  670. (* etherOutputHookRtn) (&pDrvCtrl->fn_if, privateBuf, pktLen))
  671. goto outputDone; /* goto the end */
  673.     /* Tell the device the length; in little endian order */
  675. #if (CPU_FAMILY == SPARC)
  676.     sysAsiSeth  (nicePort,
  677.                 ((pktLen & 0xff00) >> 8) |
  678.                 ((pktLen & 0x00ff) << 8)
  679.                 );
  680. #endif
  681.     pSource = (u_short *) privateBuf;
  682.     for (loopy = pktLen; loopy > 0 ; loopy -= sizeof (u_short))
  683. {
  684. #if (CPU_FAMILY == SPARC)
  685.      sysAsiSeth (nicePort, *pSource);
  686. #endif
  687. pSource++;
  688. }
  690.     if (pktLen % sizeof (u_short)) /* packet size is odd */
  691. {
  692. unsigned short lastByte;
  693. lastByte = 0;
  694. ((char *) (&lastByte)) [0] = ((char *) (pSource)) [0];
  695. #if (CPU_FAMILY == SPARC)
  696.  sysAsiSeth (nicePort, lastByte);
  697. #endif
  698. }
  700.     /* See if transmitter is free and start it orelse  wait.  */
  702. #if (CPU_FAMILY == SPARC)
  703.     while ((sysAsiGeth (pDrvCtrl->pDev + NICE_TRANSMIT)) & (0x7f << 8))
  704.      ; /* loop until transmit count is 0 */
  706.     sysAsiSeth (pDrvCtrl->pDev + NICE_TRANSMIT, KICK_TRANSMIT);
  707. #endif
  709.     /* Bump the statistic counter. */
  711.     pDrvCtrl->fn_if.if_opackets++;
  713.     /* That's all. */
  714.     outputDone:
  716.     semGive (pDrvCtrl->TxSem);
  717.     return (0);
  718.     } /* End of fnOutput() */
  720. #else
  721. /*******************************************************************************
  722. *
  723. * fnTxStartup - kick start the transmitter after generic ether_output
  724. *
  725. * This routine is responsible for tranmitting packets over physical media.
  726. * The data to be sent out is held in a chain of mbufs. The data in each mbuf 
  727. * fragment must be copied to the device's packet buffer.
  728. *
  729. * RETURNS: OK, or ERROR
  730. */
  732. LOCAL int fnTxStartup
  733.     (
  734.     DRV_CTRL *  pDrvCtrl  /* pointer to driver control structure */
  735.     )
  736.     {
  737.     struct mbuf * pMbuf; /* ptr to the mbufs to send */
  738.     int pktLen; /* total length of packet */
  739.     int dataLen; /* real length of data portion */
  740.     int loopy; /* loop counter */
  741.     char *nicePort; /* ptr to the nice buffer port */
  742.     u_short *pSource; /* ptr to source of data byte */
  743.     static char privateBuf [ETHERMTU];
  745.     /* get ptr to the buffer port */
  747.     nicePort = pDrvCtrl->pDev + NICE_PORT;
  749.     while (pDrvCtrl->idr.ac_if.if_snd.ifq_head)
  750.         {
  751.         /* Dequeue a packet from the send queue. */
  753.         IF_DEQUEUE (&pDrvCtrl->idr.ac_if.if_snd, pMbuf);
  755.         /*
  756.          * This driver maintains transmit resources internally. The 
  757.          * CPU cannot retrieve or examine them.
  758.          */
  760.         copy_from_mbufs (privateBuf, pMbuf, dataLen);
  762. #ifdef FN_DEBUG
  763.         if (DEBUG_TX)
  764.             printf ("fn: Tx: dataLen=%dn", dataLen);
  765. #endif /* FN_DEBUG */
  766.     
  767.         /* Ensure we send a legal size frame. */
  769.         pktLen = max (ETHERSMALL, dataLen);
  771.         /* taking care of short packets, pad with 0s */
  773.         if (dataLen < ETHERSMALL)
  774.     for (loopy = dataLen; loopy < pktLen; loopy++)
  775.                privateBuf [loopy] = 0;
  777.         /*
  778.          * Support for network interface hooks. Call output hook
  779.          * if any specified. If the routine returns non-zero, 
  780.          * assume the hook has taken care of the frame (don't send
  781.          * on interface). See etherLib for more information
  782.          */
  784.         if ( (etherOutputHookRtn != NULL) && 
  785.      (* etherOutputHookRtn) (&pDrvCtrl->fn_if, privateBuf, pktLen))
  786.             continue;
  788.          /* Tell the device the length; in little endian order */
  790. #if (CPU_FAMILY == SPARC)
  791.         sysAsiSeth  (nicePort,
  792.                      ( (pktLen & 0xff00) >> 8) | ( (pktLen & 0x00ff) << 8));
  793. #endif
  794.         pSource = (u_short *)privateBuf;
  795.         for (loopy = pktLen; loopy > 0 ; loopy -= sizeof (u_short))
  796.     {
  797. #if (CPU_FAMILY == SPARC)
  798.          sysAsiSeth (nicePort, *pSource);
  799. #endif
  800.     pSource++;
  801.     }
  803.         if (pktLen % sizeof (u_short)) /* packet size is odd */
  804.     {
  805.     unsigned short lastByte;
  806.     lastByte = 0;
  807.     ( (char *) (&lastByte))[0] = ((char *) (pSource))[0];
  808. #if (CPU_FAMILY == SPARC)
  809.     sysAsiSeth (nicePort, lastByte);
  810. #endif
  811.     }
  813.         /* See if transmitter is free and start it orelse  wait.  */
  815. #if (CPU_FAMILY == SPARC)
  816.         while ( (sysAsiGeth (pDrvCtrl->pDev + NICE_TRANSMIT)) & (0x7f << 8))
  817.          ;  /* loop until transmit count is 0 */
  819.         sysAsiSeth (pDrvCtrl->pDev + NICE_TRANSMIT, KICK_TRANSMIT);
  820. #endif
  822.         /* Bump the statistic counter. */
  824.         pDrvCtrl->fn_if.if_opackets++;
  825.         }
  826.     return (0);
  827.     }
  828. #endif
  830. /*******************************************************************************
  831. *
  832. * fnRxEvent - process the receiver event from the device
  833. *
  834. * This routine is the top level receiver handler.  Runs as long as packets 
  835. * left in the buffer.
  836. *
  837. * RETURNS: N/A
  838. */
  840. LOCAL void fnRxEvent 
  841.     (
  842.     DRV_CTRL *  pDrvCtrl  /* pointer to driver control structure */
  843.     )
  844.     {
  845.     char * pDev; /* ptr to the device regs */
  847.     /* Check ifnet flags. Return if we're down, leaving interrupt disabled. */
  849.     if  (
  850.         (pDrvCtrl->fn_if.if_flags & (IFF_UP | IFF_RUNNING)) !=
  851.         (IFF_UP | IFF_RUNNING)
  852.         )
  853.         return;
  855.     pDev = pDrvCtrl->pDev;                      /* get ptr to device */
  857.     /* While more packets, process the packet. */
  859.     while ( fnRxMore (pDrvCtrl) )
  860. {
  861.         if (fnRxProcessPkt (pDrvCtrl) == ERROR)
  862.     {
  863.     rcvPktError++;  /* bump the recieve packet error counter */
  864.             break;
  865.     }
  866. }
  868.     /* Turn the receive interrupts on again. */
  870. #if (CPU_FAMILY == SPARC)
  871.     sysAsiSeth (pDev + NICE_INTRMASK, NORM_INTRMASK);
  872. #endif
  874.     } /* End of fnRxEvent() */
  876. /*******************************************************************************
  877. *
  878. * fnRxMore - indicates more packets in the buffer
  879. *
  880. * This routine indicates that there are more packets left in the buffer
  881. *
  882. * RETURNS: TRUE or FALSE
  883. */
  885. LOCAL BOOL fnRxMore 
  886.     (
  887.     DRV_CTRL *  pDrvCtrl  /* pointer to driver control structure */ 
  888.     )
  889.     {
  890.     u_short  mode;
  891.     char * pDev; /* ptr to the device regs */
  893.     pDev = pDrvCtrl->pDev; /* get ptr to device */
  895. #if (CPU_FAMILY == SPARC)
  896.     mode = sysAsiGeth (pDev + NICE_MODE);
  897. #endif
  899.     if (mode & DLCR5_BUF_EMPTY)
  900.         return (FALSE);
  901.     else
  902.         return (TRUE);
  904.     } /* End of fnRxMore() */
  906. /*******************************************************************************
  907. *
  908. * fnRxProcessPkt - process the next available packet
  909. *
  910. * RETURNS: OK, or ERROR.
  911. */
  913. LOCAL STATUS fnRxProcessPkt 
  914.     (
  915.     DRV_CTRL *  pDrvCtrl  /* pointer to driver control structure */
  916.     )
  917.     {
  918.     int loopy; /* loop counter */
  919.     int  dataLen; /* length of packet data */
  920.     char * pDev; /* ptr to the device regs */
  921.     u_short * pDest; /* ptr to destination */
  922.     struct mbuf * pMbuf; /* ptr to mbufs */
  923.     RX_HDR  rxHdr; /* an Rx pkt header */
  925.     /* allocate space for one received frame */
  927.     static struct rx_frame
  928.         {
  929.         struct ether_header enetHdr;            /* the Ethernet header */
  930.         char data [1500];                       /* the data field */
  931.         } rxFrame;
  934.     pDev = pDrvCtrl->pDev;                      /* get ptr to device */
  936.     /* Fill our local copy of the Rx header from the device's buffer. */
  938. #if (CPU_FAMILY == SPARC)
  939.     rxHdr.status = sysAsiGeth (pDev + NICE_PORT);
  940.     rxHdr.len    = sysAsiGeth (pDev + NICE_PORT);
  941. #endif
  942.     rxHdr.len    = ((rxHdr.len & 0xff00) >> 8) |            /* swap bytes */
  943.                     ((rxHdr.len & 0x00ff) << 8);
  945.     /* Clear the status bit for packet ready. */
  947. #if (CPU_FAMILY == SPARC)
  948.     sysAsiSeth (pDev + NICE_STATUS, DLCR1_RX_PKT);
  949. #endif
  951. #ifdef FN_DEBUG
  952.     if (DEBUG_RX)
  953.         printf  (
  954.                 "fn: Rx: status=%04x  len=%dn",
  955.                 rxHdr.status & 0xff00,  rxHdr.len
  956.                 );
  957. #endif /* FN_DEBUG */
  959.     /* Sanity check the packet info. */
  961.     if  (
  962.         (!(rxHdr.status & RX_HDR_STAT_GOOD))        ||
  963.         (rxHdr.len < 60)                            ||
  964.         (rxHdr.len > 1514)
  965.         )
  966.         {
  967.         printf  ("fn: Fatal error, invalid receiver header %04x %04xn",
  968.                 rxHdr.status, rxHdr.len);
  969.         pDrvCtrl->fn_if.if_ierrors++;                       /* bump errors */
  970.         pDrvCtrl->fn_if.if_flags &= ~(IFF_UP | IFF_RUNNING);   /* flags down */
  971.         return (ERROR);
  972.         }
  974.     /* Bump the statistic counter */
  976.     pDrvCtrl->fn_if.if_ipackets++;
  978.     /* Fill our frame buffer from the device's buffer. */
  980.     pDest = (u_short *) &rxFrame;                   /* stuff ptr */
  982.     for (loopy = rxHdr.len; loopy > 0; loopy -= sizeof (u_short))
  983. #if (CPU_FAMILY == SPARC)
  984.         *pDest++ = sysAsiGeth (pDev + NICE_PORT);
  985. #else
  986.         ;
  987. #endif
  989.     /*
  990.      * Support for network interface hooks. Call input hook if any
  991.      * specified. If the routine returns non-zero, assume the 
  992.      * hook has taken care of the frame. See etherLib in the Vxworks
  993.      * Reference Manual for more information.
  994.      */
  996.     if ((etherInputHookRtn != NULL) &&
  997. ((*etherInputHookRtn) (&pDrvCtrl->fn_if, (char *) &rxFrame , rxHdr.len) 
  998.  != 0))
  999.      return (OK);
  1001.     /* Copy our frame buffer into mbufs. */
  1003.     dataLen = rxHdr.len - ENET_HDR_REAL_SIZ;        /* obtain data length */
  1004.     pMbuf = copy_to_mbufs (rxFrame.data, dataLen, 0, &pDrvCtrl->fn_if);
  1006.     /* Give the mbufs to the upper layers */
  1008.     if (pMbuf != NULL)
  1009. #ifdef BSD43_DRIVER
  1010.         do_protocol_with_type   (
  1011.                                 rxFrame.enetHdr.type,   /* packet type */
  1012.                                 pMbuf,                  /* the mbufs */
  1013.                                 &pDrvCtrl->idr,  /* interface data record */
  1014.                                 dataLen                 /* length of data */
  1015.                                 );
  1016. #else
  1017.         do_protocol (&rxFrame.enetHdr, pMbuf, &pDrvCtrl->idr, dataLen);
  1018. #endif
  1019.     else
  1020.         pDrvCtrl->idr.ac_if.if_ierrors++;
  1022. #ifdef FN_DEBUG
  1023.     logMsg ("fn: Sent packet up.n", 0, 0,  0, 0, 0, 0);
  1024. #endif
  1025.     return (OK);
  1027.     } /* End of fnRxProcessPkt() */
  1029. /*******************************************************************************
  1030. *
  1031. * fnIntr - the driver interrupt handler routine
  1032. *
  1033. * This routine is called at interrupt level in response to an interrupt from
  1034. * the controller.
  1035. *
  1036. * RETURNS: N/A
  1037. */
  1039. LOCAL void fnIntr 
  1040.     (
  1041.     int unit /* unit number to service */
  1042.     )
  1043.     {
  1044.     char *pDev; /* ptr to the device regs */
  1045.     u_short event;
  1046.     u_short reg;
  1047.     DRV_CTRL *  pDrvCtrl;  /* ptr to driver control structure */
  1049.     pDrvCtrl = &drvCtrl [unit]; 
  1051.     pDev    = pDrvCtrl->pDev;
  1053. #if (CPU_FAMILY == SPARC)
  1054.     event   = sysAsiGeth (pDev + NICE_STATUS);      /* get intr status */
  1055.     reg     = sysAsiGeth (pDev + NICE_INTRMASK);    /* get current mask */
  1056. #endif
  1059. #ifdef FN_DEBUG
  1060.     if (DEBUG_INTR)
  1061.         logMsg ("fn: Intr: event=%04xn", event, 0, 0, 0, 0, 0);
  1062. #endif /* FN_DEBUG */
  1064.     /* Handle receiver overflow event. */
  1066.     if (event & DLCR1_OVR_FLO)
  1067. {
  1068. overFlowCnt++;  /* bump the counter */
  1069. #if (CPU_FAMILY == SPARC)
  1070.   sysAsiSeth (pDev + NICE_STATUS, DLCR1_OVR_FLO); 
  1071. #endif
  1072.   return; 
  1073. } 
  1075.     /* Handle the receiver event, only if it was enabled. */
  1077.     if ((reg & DLCR3_RX_PKT) && (event & DLCR1_RX_PKT))
  1078.         {
  1079. #if (CPU_FAMILY == SPARC)
  1080.         sysAsiSeth (pDev + NICE_INTRMASK, NO_RX_INTRMASK);  /* disable */
  1081. #endif
  1082.         netJobAdd ((FUNCPTR)fnRxEvent, (int)pDrvCtrl, 0,0,0,0);
  1083.         }
  1085.     /* ACK the interrupts */
  1087. #if (CPU_FAMILY == SPARC)
  1088.     sysAsiSeth (pDev + NICE_STATUS, event);
  1089. #endif
  1091.     } /* End of fnIntr() */
  1093. #ifdef BSD43_DRIVER
  1094. /*******************************************************************************
  1095. *
  1096. * convertDestAddr - converts socket addr into enet addr and packet type
  1097. *
  1098. * RETURNS: TRUE or FALSE
  1099. */
  1101. LOCAL BOOL convertDestAddr 
  1102.     (
  1103.     IDR *  pIDR,  /* ptr to interface data record */
  1104.     struct sockaddr * pDestSktAddr, /* ptr to a generic sock addr */
  1105.     char * pDestEnetAddr, /* where to write enet addr */
  1106.     u_short * pPacketType, /* where to write packet type */
  1107.     struct mbuf * pMbuf /* ptr to mbuf data */
  1108.     )
  1109.     {
  1111.     /***** Internet family *****/
  1113.     {
  1114.     struct in_addr destIPAddr; /* not used */
  1115.     int trailers; /* not supported */
  1117.     if (pDestSktAddr->sa_family == AF_INET)
  1118.         {
  1119.         *pPacketType = ETHERTYPE_IP;            /* stuff packet type */
  1120.         destIPAddr = ((struct sockaddr_in *) pDestSktAddr)->sin_addr;
  1121.  
  1122.         if (!arpresolve (pIDR, pMbuf, &destIPAddr, pDestEnetAddr, &trailers))
  1123.             return (FALSE);     /* if not yet resolved */
  1125.         return (TRUE);
  1126.         }
  1127.     }
  1129.     /***** Generic family *****/
  1131.     {
  1132.     struct ether_header * pEnetHdr;
  1134.     if (pDestSktAddr->sa_family == AF_UNSPEC)
  1135.         {
  1136.         pEnetHdr = (struct ether_header *) pDestSktAddr->sa_data;
  1137.         bcopy ( (char *)pEnetHdr->ether_dhost, pDestEnetAddr, 6);
  1138.         *pPacketType = pEnetHdr->ether_type;
  1139.         return (TRUE);
  1140.         }
  1141.     }
  1143.     /* Unsupported family */
  1144.     
  1145.     return (FALSE);
  1147.     }
  1148. #endif    /* BSD43_DRIVER */
  1150. /* END OF FILE */