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

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

VxWorks

开发平台：

C/C++

if_qu.c：源码内容
  1. /* if_qu.c - Motorola MC68EN360 QUICC network interface driver */
  3. /* Copyright 1994-1997 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01k,31aug98,fle  doc : replaced simple quotes before 040 with 68 name to avoid
  10.                  bolded text problems
  11. 01j,18jul97,spm  removed incorrect attachment test from driver initialization
  12. 01i,15jul97,spm  removed driver initialization from ioctl support (SPR #8831)
  13. 01h,14jul97,vin  fixed SPR# 8919.
  14. 01g,15may97,map  fixed intr event ack (scce) handling (SPR# 8580).
  15. 01f,03jan97,vin  modified for BSD44.
  16. 01f,15may97,map  fixed intr event register ack [SPR# 8580]
  17. 01e,08jul94,dzb  Added promisc code into quIoctl() code.
  18. 01d,30jun94,dzb  removed relevant quIoctl() code (SPR #3437).
  19. 01c,21apr94,dzb  fixed quReset() so doesn't reset all IFF flags (SPR #3239).
  20. 01b,12nov93,dzb  fixed event race condition in quIntr() (SPR #2632).
  21. 01a,18sep93,dzb  written.
  22. */
  24. /*
  25. This module implements the Motorola MC68EN360 QUICC Ethernet network interface
  26. driver.
  28. This driver is designed to support the Ethernet mode of a SCC residing on the
  29. MC68EN360 processor chip.  It is generic in the sense that it does not care
  30. which SCC is being used, and it supports up to four individual units per board.
  31. To achieve this goal, the driver must be given several target-specific
  32. parameters, and some external support routines must be provided.  These
  33. parameters, and the mechanisms used to communicate them to the driver, are
  34. detailed below.
  36. This network interface driver does not include support for trailer protocols
  37. or data chaining.  However, buffer loaning has been implemented in an effort to
  38. boost performance. Support for four individual device units was designed
  39. into this driver.
  41. This driver maintains cache coherency by allocating buffer
  42. space using the cacheDmaMalloc() routine.  This is provided for boards that
  43. use the MC68EN360 in 68040 companion mode where it is attached to processors
  44. with data cache space.
  46. Due to a lack of suitable hardware, the multiple unit support and 68040
  47. companion mode support have not been tested.
  49. BOARD LAYOUT
  50. This device is on-chip.  No jumpering diagram is necessary.
  52. EXTERNAL INTERFACE
  53. This driver provides the standard external interface; the device unit is 
  54. attached by the quattach() routine, which uses quInit() to initialize the 
  55. driver.
  57. The only user-callable routine is quattach(), which publishes the `qu'
  58. interface and initializes the driver structures.
  60. TARGET-SPECIFIC PARAMETERS
  61. .iP "base address of MC68EN360 internal memory"
  62. This parameter is passed to the driver by quattach().
  64. This parameter indicates the address at which the MC68EN360 presents
  65. its internal memory (also known as the dual ported RAM base address).
  66. With this address, and the SCC number (see below), the driver is able to
  67. compute the location of the SCC parameter RAM and the SCC register map.
  68. This parameter should point to the internal memory of the QUICC chip
  69. where the SCC physically resides, which may not necessarily be the master
  70. QUICC on the target board.
  72. .iP "interrupt vector"
  73. This parameter is passed to the driver by quattach().
  75. This driver configures the MC68EN360 device to generate hardware interrupts
  76. for various events within the device.  Therefore, this driver contains
  77. an interrupt handler routine.  This driver will call the VxWorks system
  78. function intConnect() to connect its interrupt handler to the interrupt
  79. vector generated as a result of the MC68EN360 interrupt.
  81. .iP "SCC number used"
  82. This parameter is passed to the driver by quattach().
  84. This driver is written to support four individual device units.
  85. At the time that this driver was written, Motorola had released
  86. information stating that any of the SCCs on the MC68EN360 may be used
  87. in Ethernet mode.  Thus, the multiple units supported by this driver
  88. may reside on different MC68EN360 chips, or may be on different SCCs
  89. within a single MC68EN360.  This parameter is used to explicitly state
  90. which SCC is being used (SCC1 is most commonly used, thus this parameter
  91. most often equals "1").
  93. .iP "number of transmit and receive buffer descriptors"
  94. These parameters are passed to the driver by quattach().
  96. The number of transmit and receive buffer descriptors (BDs) used is
  97. configurable by the user upon attaching the driver.  Each buffer
  98. descriptor resides in 8 bytes of the MC68EN360's dual ported RAM space,
  99. and each one points to a 1520 byte buffer in regular RAM.  There must
  100. be a minimum of two transmit and two receive BDs, and there is no
  101. maximum, although over a certain amount will not speed up the driver and
  102. will waste valuable dual ported RAM space.  If this parameter is "NULL"
  103. a default value of "32" BDs will be used.
  105. .iP "offset of transmit and receive buffer descriptors"
  106. These parameters are passed to the driver by quattach().
  108. These parameters indicate the base location of the transmit and receive
  109. buffer descriptors (BDs).  They are offsets in bytes from the base address
  110. of MC68EN360 internal memory (see above).  Each BD takes up 8 bytes of
  111. dual ported RAM, and it is the user's responsibility to ensure that all
  112. specified BDs will fit within dual ported RAM.  This includes any other
  113. BDs the target board may be using, including other SCCs, SMCs, and the
  114. SPI device.  There is no default for these parameters; they must be
  115. provided by the user.
  117. .iP "base address of buffer pool"
  118. This parameter is passed to the driver by quattach().
  120. This parameter is used to notify the driver that space for the transmit
  121. and receive buffers need not be allocated, but should be taken from a
  122. cache-coherent private memory space provided by the user at the given
  123. address.  The user should be aware that memory used for buffers must be
  124. 4-byte aligned and non-cacheable.  All the buffers
  125. *must* fit in the given memory space; no checking will be performed.
  126. This includes all transmit and receive buffers (see above) and an
  127. additional 16 receive loaner buffers, unless the number of receive
  128. BDs is less than 16, in which case that number of loaner buffers will be
  129. used.  Each buffer is 1520 bytes.  If this parameter is "NONE", space
  130. for buffers will be obtained by calling cacheDmaMalloc() in quattach().
  131. .LP
  133. EXTERNAL SUPPORT REQUIREMENTS
  134. This driver requires three external support functions:
  135. .iP "STATUS sys360EnetEnable (int unit, UINT32 regBase)" "" 9 -1
  136. This routine is expected to perform any target specific functions required
  137. to enable the Ethernet controller.  These functions typically include
  138. enabling the Transmit Enable signal (TENA) and connecting the transmit
  139. and receive clocks to the SCC.
  140. The driver calls this routine, once per unit, from the quInit() routine.
  141. .iP "void sys360EnetDisable (int unit, UINT32 regBase)"
  142. This routine is expected to perform any target specific functions required
  143. to disable the Ethernet controller.  This usually involves disabling the
  144. Transmit Enable (TENA) signal.
  145. The driver calls this routine from the quReset() routine each time a unit
  146. is disabled.
  147. .iP "STATUS sys360EnetAddrGet (int unit, u_char * addr)"
  148. The driver expects this routine to provide the six byte Ethernet
  149. hardware address that will be used by this unit.  This routine must copy
  150. the six byte address to the space provided by <addr>.  This routine is
  151. expected to return OK on success, or ERROR.
  152. The driver calls this routine, once per unit, from the quInit() routine.
  153. .LP
  155. SYSTEM RESOURCE USAGE
  156. When implemented, this driver requires the following system resources:
  158.     - one mutual exclusion semaphore
  159.     - one interrupt vector
  160.     - 0 bytes in the initialized data section (data)
  161.     - 1272 bytes in the uninitialized data section (BSS)
  162.  
  163. The data and BSS sections are quoted for the CPU32 architecture and may vary
  164. for other architectures.  The code size (text) will varies greatly between
  165. architectures, and is therefore not quoted here.
  167. If the driver allocates the memory to share with the Ethernet device unit,
  168. it does so by calling the cacheDmaMalloc() routine.  For the default case
  169. of 32 transmit buffers, 32 receive buffers, and 16 loaner buffers, the total
  170. size requested is 121,600 bytes.  If a non-cacheable memory region is provided
  171. by the user, the size of this region should be this amount, unless the
  172. user has specified a different number of transmit or receive BDs.
  174. This driver can only operate if this memory region is non-cacheable,
  175. or if the hardware implements bus snooping.  The driver cannot maintain
  176. cache coherency for the device because the buffers are asynchronously
  177. modified by both the driver and the device, and these fields may share the
  178. same cache line.  Additionally, the MC68EN360 dual ported RAM must be
  179. declared as non-cacheable memory where applicable (e.g., when attached
  180. to a 68040 processor).
  182. SEE ALSO: ifLib,
  183. .I "Motorola MC68360 User's Manual"
  185. INTERNAL
  186. Future optimization: Transmit directly from mbufs/clusters instead of calling
  187.                      copy_from_mbufs(). Turn on transmit interrupts to know
  188.      when to call free routine.
  189. */
  191. /* includes */
  193. #include "vxWorks.h"
  194. #include "iv.h"
  195. #include "taskLib.h"
  196. #include "memLib.h"
  197. #include "ioctl.h"
  198. #include "etherLib.h"
  199. #include "net/mbuf.h"
  200. #include "net/protosw.h"
  201. #include "socket.h"
  202. #include "errno.h"
  203. #include "net/if.h"
  204. #include "net/unixLib.h"
  205. #include "net/route.h"
  206. #include "netinet/in.h"
  207. #include "netinet/in_systm.h"
  208. #include "netinet/in_var.h"
  209. #include "netinet/ip.h"
  210. #include "netinet/if_ether.h"
  211. #include "net/if_subr.h"
  212. #include "cacheLib.h"
  213. #include "stdio.h"
  214. #include "intLib.h"
  215. #include "logLib.h"
  216. #include "netLib.h"
  217. #include "drv/netif/netifDev.h"
  218. #include "drv/multi/m68360.h"
  220. /* defines */
  222. #define MAX_UNITS 4 /* max qu units */
  223. #define ENET_ADDR_SIZE 0x6 /* size of Ethernet src/dest addresses */
  224. #define TX_BD_MIN 2 /* minimum number of Tx buffer descriptors */
  225. #define RX_BD_MIN 2 /* minimum number of Rx buffer descriptors */
  226. #define TX_BD_DEFAULT 0x20 /* default number of Tx buffer descriptors */
  227. #define RX_BD_DEFAULT 0x20 /* default number of Rx buffer descriptors */
  228. #define FRAME_MAX 0x05ee /* maximum frame size */
  229. #define FRAME_MAX_AL 0x05f0 /* maximum frame size, 4 byte alligned */
  230. #define FRAME_MIN 0x0040 /* minimum frame size */
  231. #define L_POOL 0x10 /* number of Rx loaner buffers in pool */
  233. /* typedefs */
  235. typedef struct mbuf MBUF;
  236. typedef struct arpcom IDR; /* Interface Data Record */
  237. typedef struct ifnet IFNET;
  238. typedef struct sockaddr SOCK;
  239. typedef struct ether_header ETH_HDR; 
  241. typedef struct drv_ctrl /* DRV_CTRL */
  242.     {
  243.     IDR idr; /* Interface Data Record */
  244.     BOOL attached; /* indicates unit is attached */
  245.     BOOL initialized; /* indicates unit is initialized */
  246.     BOOL txStop; /* emergency stop output */
  247.     int nLoanRxBd; /* number of receive buffers left to loan */
  248.     u_char * lPool[L_POOL]; /* receive BD loaner pool */
  249.     UINT8 * pRefCnt[L_POOL];/* stack of reference count pointers */
  250.     UINT8 refCnt[L_POOL]; /* actual reference count values */
  251.     UINT32 regBase; /* register/DPR base address */
  252.     SCC_DEV ether; /* ETHERNET SCC device */
  253.     } DRV_CTRL;
  255. /* globals */
  257. IMPORT STATUS sys360EnetEnable  (int unit, UINT32 regBase); /* enable ctrl */
  258. IMPORT void   sys360EnetDisable (int unit, UINT32 regBase); /* disable ctrl */
  259. IMPORT STATUS sys360EnetAddrGet (int unit, u_char * addr);  /* get enet addr */
  261. /* locals */
  263. LOCAL DRV_CTRL drvCtrl[MAX_UNITS]; /* array of driver control */
  265. /* forward declarations */
  267. #ifdef __STDC__
  269. LOCAL STATUS    quInit (int unit);
  270. #ifdef BSD43_DRIVER
  271. LOCAL int       quOutput (IFNET * pIfNet, MBUF * pMbuf, SOCK * pSock);
  272. LOCAL void      quStartOutput (int unit);
  273. #else
  274. LOCAL void      quStartOutput (DRV_CTRL * pDrvCtrl); 
  275. #endif
  276. LOCAL int       quIoctl (IFNET * pIfNet, int cmd, caddr_t data);
  277. LOCAL void      quReset (int unit);
  278. LOCAL void      quIntr (int unit);
  279. LOCAL void quTxRestart (DRV_CTRL * pDrvCtrl);
  280. LOCAL void      quHandleInt (DRV_CTRL * pDrvCtrl);
  281. LOCAL void      quRecv (DRV_CTRL * pDrvCtrl, SCC_BUF * pRxBd);
  282. LOCAL void      quLoanFree (DRV_CTRL * pDrvCtrl, u_char * pRxBuf, UINT8 * pRef);
  284. #else  /* __STDC__ */
  286. LOCAL STATUS    quInit ();
  287. LOCAL int       quOutput ();
  288. LOCAL void      quStartOutput ();
  289. LOCAL int       quIoctl ();
  290. LOCAL void      quReset ();
  291. LOCAL void      quIntr ();
  292. LOCAL void quTxRestart ();
  293. LOCAL void      quHandleInt ();
  294. LOCAL void      quRecv (); 
  295. LOCAL void      quLoanFree (); 
  297. #endif  /* __STDC__ */
  299. /*******************************************************************************
  300. *
  301. * quattach - publish the `qu' network interface and initialize driver structures
  302. *
  303. * The routine publishes the `qu' interface by filling in a network Interface
  304. * Data Record (IDR) and adding this record to the system list.
  305. *
  306. * The MC68EN360 shares a region of memory with the driver.  The caller of this
  307. * routine can specify the address of a non-cacheable memory region with
  308. * <bufBase>, or if this parameter is "NONE" the driver will obtain this
  309. * memory region from calls to cacheDmaMalloc().  Non-cacheable memory space
  310. * is important for cases where the MC68EN360 is operating in companion mode,
  311. * and is attached to a processor with cache memory.
  312. *
  313. * Once non-cacheable memory is obtained, this routine will divide up the
  314. * memory between the various buffer descriptors (BDs).  The number
  315. * of BDs can be specified by <txBdNum> and <rxBdNum>, or if "NULL", a
  316. * default value of 32 BDs will be used.  An additional number of buffers are
  317. * reserved as receive loaner buffers.  The number of loaner buffers is the
  318. * lesser of <rxBdNum> and a default number of 16.
  319. *
  320. * The user must specify the location of the transmit and receive BDs in
  321. * the 68EN360's dual ported RAM.  <txBdBase> and <rxBdBase> give the
  322. * offsets from <quAddr> for the base of the BD rings.  Each BD uses 8 bytes.
  323. * Care must be taken so that the specified locations for Ethernet BDs
  324. * do not conflict with other dual ported RAM structures. 
  325. *
  326. * Up to four individual device units are supported by this driver.  Device
  327. * units may reside on different MC68EN360 chips, or may be on different SCCs
  328. * within a single MC68EN360.  The <sccNum> parameter is used to explicitly
  329. * state which SCC is being used. SCC1 is most commonly used, thus this
  330. * parameter most often equals "1".
  331. * 
  332. * Before this routine returns, it calls quReset() to put the Ethernet
  333. * controller in a quiescent state, and connects up the interrupt vector
  334. * <ivec>.
  335. *
  336. * RETURNS: OK or ERROR.
  337. *
  338. * SEE ALSO: ifLib,
  339. * .I "Motorola MC68360 User's Manual"
  340. */
  342. STATUS quattach
  343.     (
  344.     int unit, /* unit number */
  345.     UINT32 quAddr, /* base address of QUICC chip internal mem */
  346.     int ivec, /* interrupt vector */
  347.     int sccNum, /* SCC number used */
  348.     int txBdNum, /* number of transmit buffer descriptors */
  349.     int rxBdNum, /* number of receive buffer descriptors */
  350.     UINT32 txBdBase, /* transmit buffer descriptor offset */
  351.     UINT32 rxBdBase, /* receive buffer descriptor offset */
  352.     UINT32 bufBase /* address of memory pool; NONE = malloc it */
  353.     )
  354.     {
  355.     DRV_CTRL * pDrvCtrl;
  356.     int counter;
  357.     int         scc = sccNum - 1;
  358.     int loanNum = L_POOL;
  359.     u_char * txBuf;
  360.     u_char * rxBuf;
  361.     u_char * loanBuf;
  362.      
  363.     if (unit < 0 || unit >= MAX_UNITS) /* sanity check the unit number */
  364.  return (ERROR);
  365.   
  366.     pDrvCtrl = & drvCtrl[unit];
  367.     
  368.     /* ensure single invocation */
  370.     if (pDrvCtrl->attached)
  371.         return (ERROR);
  373.     /* initialize flag(s) */
  375.     pDrvCtrl->initialized = FALSE;
  377.     /* do a quick check of input parameters */
  379.     if ((sccNum < 1) || (sccNum > 4))
  380. return (ERROR);
  382.     if (txBdBase == rxBdBase)
  383. return (ERROR);
  385.     /* publish the Interface Data Record */
  386. #ifdef BSD43_DRIVER
  387.     ether_attach (& pDrvCtrl->idr.ac_if, unit, "qu", (FUNCPTR) quInit,
  388.                   (FUNCPTR) quIoctl, (FUNCPTR) quOutput, (FUNCPTR) quReset);
  389. #else
  390.     ether_attach    (
  391.                     (IFNET *) & pDrvCtrl->idr,
  392.                     unit,
  393.                     "qu",
  394.                     (FUNCPTR) quInit,
  395.                     (FUNCPTR) quIoctl,
  396.                     (FUNCPTR) ether_output, /* generic ether_output */
  397.                     (FUNCPTR) quReset
  398.                     );
  400.     pDrvCtrl->idr.ac_if.if_start = (FUNCPTR) quStartOutput;
  401. #endif /* BSD43_DRIVER */
  403.     /* use default number of buffer descriptors if user did not specify */
  405.     if (txBdNum == NULL)
  406. txBdNum = TX_BD_DEFAULT;
  407.     if (rxBdNum == NULL)
  408. rxBdNum = RX_BD_DEFAULT;
  410.     /* must be at least two transmit and receive buffer descriptors */
  412.     txBdNum = max (TX_BD_MIN, txBdNum);
  413.     rxBdNum = max (RX_BD_MIN, rxBdNum);
  414.     loanNum = min (rxBdNum, loanNum); 
  416.     /* fill in driver control structure for <unit> */
  418.     pDrvCtrl->regBase         = quAddr;
  419.     pDrvCtrl->ether.sccNum    = sccNum;
  420.     pDrvCtrl->ether.txBdNum   = txBdNum;
  421.     pDrvCtrl->ether.rxBdNum   = rxBdNum;
  422.     pDrvCtrl->nLoanRxBd       = loanNum;
  423.     pDrvCtrl->ether.txBdBase  = (SCC_BUF *) (quAddr + (txBdBase & 0xfff));
  424.     pDrvCtrl->ether.rxBdBase  = (SCC_BUF *) (quAddr + (rxBdBase & 0xfff));
  425.     pDrvCtrl->ether.txBufSize = FRAME_MAX_AL;
  426.     pDrvCtrl->ether.rxBufSize = FRAME_MAX_AL;
  428.     /* derive SCC dependent variables */
  430.     pDrvCtrl->ether.pScc    = (SCC *) ((UINT32) M360_DPR_SCC1(quAddr) +
  431.                                        (scc * 0x100));
  432.     pDrvCtrl->ether.pSccReg = (SCC_REG *) ((UINT32) M360_CPM_GSMR_L1(quAddr) +
  433.                                            (scc * 0x20));
  434.     pDrvCtrl->ether.intMask = CPIC_CIXR_SCC4 << (3 - scc);
  435.     
  436.     /* set up Rx and Tx buffers */
  438.     if (bufBase == NONE)
  439. {
  440.         /* allocate memory pools */
  442. txBuf = cacheDmaMalloc (txBdNum * pDrvCtrl->ether.txBufSize);
  443.         if (txBuf == NULL)
  444.     return (ERROR);
  446. rxBuf = cacheDmaMalloc (rxBdNum * pDrvCtrl->ether.rxBufSize);
  447.         if (rxBuf == NULL)
  448.     {
  449.     free (txBuf);
  450.     return (ERROR);
  451.     }
  453.         loanBuf = cacheDmaMalloc (loanNum * pDrvCtrl->ether.rxBufSize);
  454. if (loanBuf == NULL)
  455.             pDrvCtrl->nLoanRxBd = 0;
  456.         }
  457.     else
  458. {
  459. /* use passed in address as memory pool - assume OK */
  461. txBuf   = (u_char *) bufBase;
  462. rxBuf   = (u_char *) (txBuf + (txBdNum * pDrvCtrl->ether.txBufSize));
  463. loanBuf = (u_char *) (rxBuf + (rxBdNum * pDrvCtrl->ether.rxBufSize));
  464. }
  466.     /* assign buffer addresses */
  468.     for (counter = 0; counter < txBdNum; counter++)
  469.         pDrvCtrl->ether.txBdBase[counter].dataPointer = (txBuf + (counter *
  470.     pDrvCtrl->ether.txBufSize));
  472.     for (counter = 0; counter < rxBdNum; counter++)
  473.         pDrvCtrl->ether.rxBdBase[counter].dataPointer = (rxBuf + (counter *
  474.     pDrvCtrl->ether.rxBufSize));
  476.     for (counter = 0; counter < pDrvCtrl->nLoanRxBd; counter++)
  477.         {
  478.         pDrvCtrl->lPool[counter] = (loanBuf + (counter *
  479.     pDrvCtrl->ether.rxBufSize));
  480.         pDrvCtrl->refCnt[counter] = 0;
  481. pDrvCtrl->pRefCnt[counter] = & pDrvCtrl->refCnt[counter];
  482.         }
  484.     /* reset the chip */
  486.     quReset (unit);
  488.     /* connect the interrupt handler quIntr() */
  490.     if (intConnect (INUM_TO_IVEC (ivec), (VOIDFUNCPTR) quIntr, unit) == ERROR)
  491.         return (ERROR);
  493.     quInit (unit);
  495.     /* mark driver as attached */
  497.     pDrvCtrl->attached = TRUE;
  499.     return (OK);
  500.     }
  502. /*******************************************************************************
  503. *
  504. * quInit - network interface initialization routine
  505. *
  506. * This routine marks the interface as down, then configures and initializes
  507. * the chip.   It sets up the transmit and receive buffer descriptor (BD)
  508. * rings, initializes registers, and enables interrupts.  Finally, it marks
  509. * the interface as up and running.  It does not touch the receive loaner
  510. * buffer stack.
  511. *
  512. * This routine is called from the driver attach routine at boot time.
  513. *
  514. * The complement of this rotuine is quReset().  Once a unit is reset by
  515. * quReset(), it may be re-initialized to a running state by this routine.
  516. *
  517. * RETURNS: OK if successful, otherwise ERROR.
  518. */
  520. LOCAL STATUS quInit
  521.     (
  522.     int unit /* unit number */
  523.     )
  524.     {
  525.     DRV_CTRL * pDrvCtrl;
  526.     u_char enetAddr[ENET_ADDR_SIZE];
  527.     int counter;
  529.     /* sanity check the unit number */
  531.     if (unit < 0 || unit >= MAX_UNITS)
  532.  return (ERROR);
  533.   
  534.     pDrvCtrl = & drvCtrl[unit];
  536.     /* ensure single invocation */
  538.     if (pDrvCtrl->initialized)
  539.         return (OK);
  541.     /* mark the device as down */
  542.  
  543.     pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
  545.     /* initialize flag(s) */
  547.     pDrvCtrl->txStop = FALSE;
  549.     /* set up transmit buffer descriptors */
  551.     pDrvCtrl->ether.pScc->param.tbase = (UINT16)
  552. ((UINT32) pDrvCtrl->ether.txBdBase & 0xfff);
  553.     pDrvCtrl->ether.pScc->param.tbptr = (UINT16)
  554. ((UINT32) pDrvCtrl->ether.txBdBase & 0xfff);
  556.     pDrvCtrl->ether.txBdNext  = 0;
  558.     /* initialize each transmit buffer descriptor */
  559.      
  560.     for (counter = 0; counter < pDrvCtrl->ether.txBdNum; counter++)
  561.         pDrvCtrl->ether.txBdBase[counter].statusMode = SCC_ETHER_TX_BD_I |
  562.                                                        SCC_ETHER_TX_BD_PAD |
  563.                                                        SCC_ETHER_TX_BD_L |
  564.                                                        SCC_ETHER_TX_BD_TC;
  566.     /* set the last BD to wrap to the first */
  568.     pDrvCtrl->ether.txBdBase[(counter - 1)].statusMode |= SCC_ETHER_TX_BD_W;
  570.     /* set up receive buffer descriptors */
  572.     pDrvCtrl->ether.pScc->param.rbase = (UINT16)
  573. ((UINT32) pDrvCtrl->ether.rxBdBase & 0xfff);
  574.     pDrvCtrl->ether.pScc->param.rbptr = (UINT16)
  575. ((UINT32) pDrvCtrl->ether.rxBdBase & 0xfff);
  577.     pDrvCtrl->ether.rxBdNext  = 0;
  579.     /* initialize each receive buffer descriptor */
  581.     for (counter = 0; counter < pDrvCtrl->ether.rxBdNum; counter++)
  582.         pDrvCtrl->ether.rxBdBase[counter].statusMode = SCC_ETHER_RX_BD_I |
  583.                 SCC_ETHER_RX_BD_E;
  585.     /* set the last BD to wrap to the first */
  587.     pDrvCtrl->ether.rxBdBase[(counter - 1)].statusMode |= SCC_ETHER_RX_BD_W;
  589.     /* set SCC attributes to Ethernet mode */
  590.  
  591.     pDrvCtrl->ether.pSccReg->gsmrl    = SCC_GSMRL_ETHERNET | SCC_GSMRL_TPP_10 |
  592.                                         SCC_GSMRL_TPL_48   | SCC_GSMRL_TCI;
  593.     pDrvCtrl->ether.pSccReg->gsmrh    = 0x0;
  595.     pDrvCtrl->ether.pSccReg->psmr     = SCC_ETHER_PSMR_CRC |
  596. SCC_ETHER_PSMR_NIB_22;
  597.  
  598.     if (pDrvCtrl->idr.ac_if.if_flags & IFF_PROMISC)
  599.         pDrvCtrl->ether.pSccReg->psmr |= SCC_ETHER_PSMR_PRO;
  600.  
  601.     pDrvCtrl->ether.pSccReg->dsr      = 0xd555;
  602.     pDrvCtrl->ether.pScc->param.rfcr  = 0x18;      /* supervisor data access */
  603.     pDrvCtrl->ether.pScc->param.tfcr  = 0x18;      /* supervisor data access */
  604.     pDrvCtrl->ether.pScc->param.mrblr = FRAME_MAX_AL;  /* max rx buffer size */
  606.     /* initialize parameter the SCC RAM */
  607.  
  608.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->c_pres = 0xffffffff;
  609.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->c_mask = 0xdebb20e3;
  610.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->crcec = 0x00000000;
  611.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->alec = 0x00000000;
  612.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->disfc = 0x00000000;
  613.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->pads = 0x8888;
  614.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->ret_lim = 0x000f;
  615.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->mflr = FRAME_MAX;
  616.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->minflr = FRAME_MIN;
  617.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->maxd1 = FRAME_MAX;
  618.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->maxd2 = FRAME_MAX;
  619.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr1 = 0x0000;
  620.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr2 = 0x0000;
  621.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr3 = 0x0000;
  622.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr4 = 0x0000;
  623.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->p_per = 0x0000;
  624.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->iaddr1 = 0x0000;
  625.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->iaddr2 = 0x0000;
  626.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->iaddr3 = 0x0000;
  627.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->iaddr4 = 0x0000;
  628.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->taddr_h = 0x0000;
  629.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->taddr_m = 0x0000;
  630.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->taddr_l = 0x0000;
  632.     /* set the hardware Ethernet address of the board */
  634.     if (sys360EnetAddrGet (unit, (u_char *) & enetAddr) == ERROR)
  635. return (ERROR);
  637.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->paddr1_h =
  638.         (enetAddr[5] << 8) + enetAddr[4];
  639.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->paddr1_m =
  640.         (enetAddr[3] << 8) + enetAddr[2];
  641.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->paddr1_l =
  642.         (enetAddr[1] << 8) + enetAddr[0];
  644.     bcopy ((char *) enetAddr, (char *) pDrvCtrl->idr.ac_enaddr, ENET_ADDR_SIZE);
  646.     /* enable Ethernet interrupts */
  648.     pDrvCtrl->ether.pSccReg->scce = 0xffff; /* clr events */
  650.     pDrvCtrl->ether.pSccReg->sccm = SCC_ETHER_SCCX_RXF | SCC_ETHER_SCCX_TXE;
  652.     *M360_CPM_CIMR(pDrvCtrl->regBase) |= pDrvCtrl->ether.intMask;
  654.     /* call the BSP to do any other initialization (e.g., connecting clocks) */
  656.     if (sys360EnetEnable (unit, pDrvCtrl->regBase) == ERROR)
  657. return (ERROR);
  659.     /* raise the interface flags - mark the device as up */
  660.  
  661.     pDrvCtrl->idr.ac_if.if_flags |= IFF_UP | IFF_RUNNING | IFF_NOTRAILERS;
  663.     /* mark driver as initialized */
  665.     pDrvCtrl->initialized = TRUE;
  667.     /* enable the transmitter */
  669.     pDrvCtrl->ether.pSccReg->gsmrl |= SCC_GSMRL_ENT;
  671.     /* issue the restart transmitter command to the CP */
  673.     while (*M360_CPM_CR(pDrvCtrl->regBase) & CPM_CR_FLG);
  674.     *M360_CPM_CR(pDrvCtrl->regBase) = ((pDrvCtrl->ether.sccNum - 1) << 6) |
  675.                                       CPM_CR_SCC_RESTART | CPM_CR_FLG;
  676.     while (*M360_CPM_CR(pDrvCtrl->regBase) & CPM_CR_FLG);
  678.     /* enable the receiver */
  680.     pDrvCtrl->ether.pSccReg->gsmrl |= SCC_GSMRL_ENR;
  682.     return (OK);
  683.     }
  684. #ifdef BSD43_DRIVER
  685. /*******************************************************************************
  686. *
  687. * quOutput - network interface output routine
  688. *
  689. * This routine simply calls ether_output(). ether_output() resolves 
  690. * the hardware addresses and calls quStartOutput() with the unit number
  691. * passed as an argument.
  692. *
  693. * RETURNS: OK if successful, otherwise errno.
  694. */
  696. LOCAL int quOutput
  697.     (
  698.     IFNET * pIfNet, /* pointer to IFNET structure */
  699.     MBUF * pMbuf, /* mbuf chain for output */
  700.     SOCK * pSock /* sock ptr for destination */  
  701.     )
  702.     {
  703.     DRV_CTRL * pDrvCtrl = & drvCtrl[pIfNet->if_unit];
  705.     return (ether_output (pIfNet, pMbuf, pSock, (FUNCPTR) quStartOutput,
  706.     & pDrvCtrl->idr));
  707.     }
  709. /*******************************************************************************
  710. *
  711. * quStartOutput - output packet to network interface device
  712. *
  713. * quStartOutput() takes a packet from the network interface output queue,
  714. * copies the mbuf chain into an interface buffer, and sends the packet over
  715. * the interface.  etherOutputHookRtns are supported.
  716. *
  717. * Collision stats are collected in this routine from previously sent BDs.
  718. * These BDs will not be examined until after the transmitter has cycled the
  719. * ring, coming upon the BD after it has been sent. Thus, collision stat
  720. * collection will be delayed a full cycle through the Tx ring.
  721. *
  722. * This routine is called from several possible threads.  Each one will be
  723. * described below.
  724. *
  725. * The first, and most common thread, is when a user task requests the
  726. * transmission of data. This will cause quOutput() to be called, which calls
  727. * ether_output(), which usually calls this routine. This routine will not be
  728. * called if ether_output() finds that our interface output queue is full.
  729. * In this case, the outgoing data will be thrown out (very rare case).
  730. *
  731. * The second thread is when a transmitter error occurs that causes a
  732. * TXE event interrupt.  This happens for the following errors: transmitter
  733. * underrun, retry limit reached, late collision, and heartbeat error.
  734. * The ISR sets the txStop flag to stop the transmitter until the errors are
  735. * serviced. These events require a RESTART command of the transmitter, which
  736. * occurs in the quTxRestart() routine.  After the transmitter is restarted,
  737. * quTxRestart() does a netJobAdd of quStartOutput() to send any packets
  738. * left in the interface output queue.  Thus, the second thread executes
  739. * in the context of netTask().
  740. *
  741. * The third, and most unlikely, thread occurs when this routine is executing
  742. * and it runs out of free Tx BDs.  In this case, this routine turns on
  743. * transmit interrupt and exits.  When the next BD is actually sent, an interrupt
  744. * occurs.  The ISR does a netJobAdd of quStartOutput() to continue sending
  745. * packets left in the interface output queue.  Once again, we find ourselves
  746. * executing in the context of netTask().
  747. *
  748. * RETURNS: N/A
  749. */
  751. LOCAL void quStartOutput
  752.     (
  753.     int unit /* unit number */
  754.     )
  755.     {
  756.     DRV_CTRL * pDrvCtrl = & drvCtrl[unit];
  757. #else /* BSD43_DRIVER */
  758. LOCAL void quStartOutput
  759.     (
  760.     DRV_CTRL * pDrvCtrl /* unit number */
  761.     )
  762.     {
  763. #endif /* BSD43_DRIVER */
  764.     MBUF * pMbuf; /* mbuf pointer */
  765.     int length;
  766.     SCC_BUF * pTxBd;
  767.     u_char * pad;
  769.     /*
  770.      * Loop until:
  771.      *     a) there are no more packets ready to send
  772.      *     b) we have insufficient resources left to send another one
  773.      *     c) a fatal transmitter error occurred, thus txStop was set
  774.      */
  776.     while (!pDrvCtrl->txStop && (pDrvCtrl->idr.ac_if.if_snd.ifq_head != NULL))
  777.         {
  778. pTxBd = & pDrvCtrl->ether.txBdBase[pDrvCtrl->ether.txBdNext];
  780. /* check if a transmit buffer descriptor is available */
  782.         if (pTxBd->statusMode & SCC_ETHER_TX_BD_R)
  783.     {
  784.     /* if no BD available, enable interrupt to see when one is free */
  786.             pDrvCtrl->ether.pSccReg->scce  = SCC_ETHER_SCCX_TXB;
  787.             pDrvCtrl->ether.pSccReg->sccm |= SCC_ETHER_SCCX_TXB;
  788.     break;
  789.     }
  791.         IF_DEQUEUE (& pDrvCtrl->idr.ac_if.if_snd, pMbuf); /* dequeue a packet */
  793.         copy_from_mbufs (pTxBd->dataPointer,pMbuf,length);
  795.         /* QUICC padding mechanism in Rev A is buggy - do in software */
  797.         if (length < FRAME_MIN)
  798.             {
  799.             pad = pTxBd->dataPointer + length;
  800.             for (; length != FRAME_MIN; length++, pad++)
  801.                 *pad = 0x88;
  802.             }
  804.         /* call hook if one is connected */
  806.         if ((etherOutputHookRtn == NULL) || ((* etherOutputHookRtn)
  807.     (& pDrvCtrl->idr.ac_if, pTxBd->dataPointer, length) == 0))
  808.             {
  809.     /* add in collision stats from previously sent BDs */
  811.             pDrvCtrl->idr.ac_if.if_collisions += ((pTxBd->statusMode &
  812.           SCC_ETHER_TX_BD_RC) >> 2);
  814.     /* if hook did not grab the frame, send packet */
  816.             pTxBd->dataLength = length;
  817.             if (pTxBd->statusMode & SCC_ETHER_TX_BD_W)
  818.                 pTxBd->statusMode = SCC_ETHER_TX_BD_I | SCC_ETHER_TX_BD_PAD |
  819.                                     SCC_ETHER_TX_BD_L | SCC_ETHER_TX_BD_TC  |
  820.                                     SCC_ETHER_TX_BD_W | SCC_ETHER_TX_BD_R;
  821.     else
  822.                 pTxBd->statusMode = SCC_ETHER_TX_BD_I | SCC_ETHER_TX_BD_PAD |
  823.                                     SCC_ETHER_TX_BD_L | SCC_ETHER_TX_BD_TC  |
  824.                                     SCC_ETHER_TX_BD_R;
  826.             /* incr BD count */
  828.     pDrvCtrl->ether.txBdNext = (pDrvCtrl->ether.txBdNext + 1) %
  829.         pDrvCtrl->ether.txBdNum;
  830.             }
  831.         }
  832.     }
  834. /*******************************************************************************
  835. *
  836. * quIoctl - network interface control routine
  837. *
  838. * This routine implements the network interface control functions.
  839. * It handles SIOCSIFADDR and SIOCSIFFLAGS commands.
  840. *
  841. * RETURNS: OK if successful, otherwise EINVAL.
  842. */
  844. LOCAL int quIoctl
  845.     (
  846.     IFNET * pIfNet, /* pointer to IFNET structure */
  847.     int cmd, /* command to process */
  848.     caddr_t data /* pointer to data */ 
  849.     )
  850.     {
  851.     DRV_CTRL * pDrvCtrl = & drvCtrl[pIfNet->if_unit];
  852.     int         error   = 0;            /* error value */
  853.     int         s       = splimp ();    /* sem not taken in calling functions */
  855.     switch (cmd)
  856.         {
  857.         case SIOCSIFADDR:       /* set interface address */
  858.             ((struct arpcom *)pIfNet)->ac_ipaddr = IA_SIN (data)->sin_addr;
  859.             arpwhohas ((struct arpcom *)pIfNet, &IA_SIN (data)->sin_addr);
  860.             break;
  861.     
  862.         case SIOCSIFFLAGS:
  863.             /* set promiscuous bit according to flags */
  865.     if (pDrvCtrl->idr.ac_if.if_flags & IFF_PROMISC)
  866.                 pDrvCtrl->ether.pSccReg->psmr |= SCC_ETHER_PSMR_PRO;
  867.             else
  868.                 pDrvCtrl->ether.pSccReg->psmr &= ~SCC_ETHER_PSMR_PRO;
  870.             break;
  872.         default:
  873.             error = EINVAL;
  874.         }
  876.     splx (s);
  877.     return (error);
  878.     }
  880. /*******************************************************************************
  881. *
  882. * quReset - network interface reset routine
  883. *
  884. * This routine marks the interface as down and resets the device.  This
  885. * includes disabling interrupts, stopping the transmitter and receiver,
  886. * and calling sys360EnetDisable() to do any target specific disabling.
  887. *
  888. * The complement of this rotuine is quInit().  Once a unit is reset in this
  889. * routine, it may be re-initialized to a running state by quInit().
  890. *
  891. * RETURNS: N/A
  892. */
  894. LOCAL void quReset
  895.     (
  896.     int unit /* unit number */
  897.     )
  898.     {
  899.     DRV_CTRL * pDrvCtrl;
  900.     int counter = 0xffff;
  902.     if (unit < 0 || unit >= MAX_UNITS) /* sanity check the unit number */
  903.         return;
  904.   
  905.     pDrvCtrl = & drvCtrl[unit];
  907.     /* disable the SCC interrupts */
  909.     *M360_CPM_CIMR(pDrvCtrl->regBase) &= ~pDrvCtrl->ether.intMask;
  911.     /* issue the CP graceful stop command to the transmitter if necessary */
  913.     if (pDrvCtrl->ether.pSccReg->gsmrl & SCC_GSMRL_ENT)
  914. {
  915.         while (*M360_CPM_CR(pDrvCtrl->regBase) & CPM_CR_FLG);
  916.         *M360_CPM_CR(pDrvCtrl->regBase) = ((pDrvCtrl->ether.sccNum - 1) << 6) |
  917.                                           CPM_CR_SCC_GRSTOP | CPM_CR_FLG;
  918.         while (*M360_CPM_CR(pDrvCtrl->regBase) & CPM_CR_FLG);
  920.         /* wait for graceful stop to register */
  922.         while ((counter--) && (!(pDrvCtrl->ether.pSccReg->scce &
  923.          SCC_ETHER_SCCX_GRA)));
  924. }
  926.     /* disable the SCC receiver and transmitter */
  928.     pDrvCtrl->ether.pSccReg->gsmrl &= ~(SCC_GSMRL_ENR | SCC_GSMRL_ENT);
  930.     /* call the BSP to do any other disabling (e.g., *TENA) */
  932.     sys360EnetDisable (unit, pDrvCtrl->regBase);
  934.     /* mark the driver as down */
  936.     pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
  938.     /* mark the driver as no longer initialized */
  940.     pDrvCtrl->initialized = FALSE;
  941.     }
  943. /*******************************************************************************
  944. *
  945. * quIntr - network interface interrupt handler
  946. *
  947. * This routine gets called at interrupt level. It handles work that 
  948. * requires minimal processing. Interrupt processing that is more 
  949. * extensive gets handled at task level. The network task, netTask(), is 
  950. * provided for this function. Routines get added to the netTask() work 
  951. * queue via the netJobAdd() command.
  952. *
  953. * RETURNS: N/A
  954. */
  956. LOCAL void quIntr
  957.     (
  958.     int unit /* unit number */
  959.     )
  960.     {
  961.     DRV_CTRL * pDrvCtrl = & drvCtrl[unit];
  962.     BOOL rxHandle = FALSE;
  963.     BOOL txbHandle = FALSE;
  965.     /* check for spurious interrupt -> attached & initialized ? */
  967.     if ((!pDrvCtrl->attached) || (!pDrvCtrl->initialized))
  968. {
  969.         pDrvCtrl->ether.pSccReg->scce = 0xffff;
  971.         *M360_CPM_CISR(pDrvCtrl->regBase) = pDrvCtrl->ether.intMask;
  972. return;
  973. }
  975.     /* handle receive events */
  977.     if ((pDrvCtrl->ether.pSccReg->sccm & SCC_ETHER_SCCX_RXF) &&
  978.         (pDrvCtrl->ether.pSccReg->scce & SCC_ETHER_SCCX_RXF))
  979. {
  980.         (void) netJobAdd ((FUNCPTR) quHandleInt, (int) pDrvCtrl, 0, 0, 0, 0); 
  982. /* turn off receive interrupts for now - quHandleInt turns back on */
  984.         pDrvCtrl->ether.pSccReg->sccm &= ~SCC_ETHER_SCCX_RXF;
  985. rxHandle = TRUE;
  986.         }
  988.     /* check for output errors */
  990.     if (pDrvCtrl->ether.pSccReg->scce & SCC_ETHER_SCCX_TXE)
  991. {
  992. /* NOTE: HBC error not supported -> always RESTART Tx here */
  994.         (void) netJobAdd ((FUNCPTR) quTxRestart, (int) pDrvCtrl, 0, 0, 0, 0);
  996. pDrvCtrl->txStop = TRUE;
  997. }
  999.     /* handle transmitter events - BD full condition -> ever happen ? */
  1001.     if ((pDrvCtrl->ether.pSccReg->sccm & SCC_ETHER_SCCX_TXB) &&
  1002.         (pDrvCtrl->ether.pSccReg->scce & SCC_ETHER_SCCX_TXB))
  1003. {
  1004. #ifdef BSD43_DRIVER
  1005.         (void) netJobAdd ((FUNCPTR) quStartOutput, unit, 0, 0, 0, 0); 
  1006. #else
  1007.         (void) netJobAdd ((FUNCPTR) quStartOutput, (int)pDrvCtrl, 0, 0, 0, 0); 
  1008. #endif /* BSD43_DRIVER */
  1010.         pDrvCtrl->ether.pSccReg->sccm &= ~SCC_ETHER_SCCX_TXB;
  1011. txbHandle = TRUE;
  1012. }
  1014.     /* check for input busy condition */
  1016.     if (pDrvCtrl->ether.pSccReg->scce & SCC_ETHER_SCCX_BSY)
  1017. {
  1018.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_BSY; 
  1020.         /* count discarded frames as errors */
  1022.         pDrvCtrl->idr.ac_if.if_ierrors +=
  1023.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->disfc;
  1024. ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->disfc = 0;
  1025. }
  1027.     /* acknowledge all other interrupts - ignore events */
  1029.     pDrvCtrl->ether.pSccReg->scce = (pDrvCtrl->ether.pSccReg->scce &
  1030.     ~(SCC_ETHER_SCCX_RXF |
  1031.       SCC_ETHER_SCCX_TXE |
  1032.       SCC_ETHER_SCCX_TXB |
  1033.       SCC_ETHER_SCCX_BSY));
  1035.     /* acknowledge interrupts */
  1037.     if (rxHandle)
  1038.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_RXF; 
  1039.     if (pDrvCtrl->txStop)
  1040.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_TXE; 
  1041.     if (txbHandle)
  1042.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_TXB; 
  1044.     *M360_CPM_CISR(pDrvCtrl->regBase) = pDrvCtrl->ether.intMask;
  1045.     }
  1047. /*******************************************************************************
  1048. *
  1049. * quTxRestart - issue RESTART Tx command to the CP
  1050. *
  1051. * This routine issues a RESTART transmitter command to the CP.  It is
  1052. * executed by netTask (quIntr() did a netJobAdd).  quIntr() cannot do
  1053. * a RESTART directly because the CPM flag must be taken before a command
  1054. * can be written.  After a restart, a netJobAdd of quStartOutput() is
  1055. * performed in order to send any packets remaining in the interface output
  1056. * queue.
  1057. *
  1058. * RETURNS: N/A
  1059. */
  1061. LOCAL void quTxRestart
  1062.     (
  1063.     DRV_CTRL * pDrvCtrl /* pointer to DRV_CTRL structure */
  1064.     )
  1065.     {
  1066.     /* update error counter */
  1068.     pDrvCtrl->idr.ac_if.if_oerrors++;
  1070.     /* restart transmitter */
  1072.     while (*M360_CPM_CR(pDrvCtrl->regBase) & CPM_CR_FLG);
  1073.     *M360_CPM_CR(pDrvCtrl->regBase) = ((pDrvCtrl->ether.sccNum - 1) << 6) |
  1074.                                       CPM_CR_SCC_RESTART | CPM_CR_FLG;
  1075.     while (*M360_CPM_CR(pDrvCtrl->regBase) & CPM_CR_FLG);
  1077.     /* restart transmit routine */
  1079.     pDrvCtrl->txStop = FALSE;
  1080. #ifdef  BSD43_DRIVER
  1081.     (void) netJobAdd ((FUNCPTR) quStartOutput, pDrvCtrl->idr.ac_if.if_unit,
  1082.       0, 0, 0, 0); 
  1083. #else
  1084.     (void) netJobAdd ((FUNCPTR) quStartOutput, (int)pDrvCtrl, 0, 0, 0, 0); 
  1085. #endif /* BSD43_DRIVER */
  1087.     }
  1089. /*******************************************************************************
  1090. *
  1091. * quHandleInt - task-level interrupt handler
  1092. *
  1093. * This is the task-level interrupt handler, which is called from 
  1094. * netTask(). quHandleInt() gets input frames from the device and then calls 
  1095. * quRecv() to process each frame.  quRecv() only gets called if no error
  1096. * stats were reported in the buffer descriptor.  Data chaining is not
  1097. * supported.
  1098. *
  1099. * This routine should be called with SCC receive interrupts masked so that
  1100. * more netJobAdds of this routine are not performed by quIntr().
  1101. * Receive interrupts are turned back on by this routine before exiting.
  1102. *
  1103. * RETURNS: N/A
  1104. */
  1106. LOCAL void quHandleInt
  1107.     (
  1108.     DRV_CTRL * pDrvCtrl /* pointer to DRV_CTRL structure */
  1109.     )
  1110.     {
  1111.     SCC_BUF * pRxBd = & pDrvCtrl->ether.rxBdBase[pDrvCtrl->ether.rxBdNext];
  1113.     while (!(pRxBd->statusMode & SCC_ETHER_RX_BD_E))
  1114.         {
  1115.         /* data chaining is not supported  - check all error conditions */
  1117.         if (((pRxBd->statusMode & (SCC_ETHER_RX_BD_F  | SCC_ETHER_RX_BD_L))
  1118.                        == (SCC_ETHER_RX_BD_F  | SCC_ETHER_RX_BD_L))
  1119.                       && !(pRxBd->statusMode & (SCC_ETHER_RX_BD_CL |
  1120.                    SCC_ETHER_RX_BD_OV | SCC_ETHER_RX_BD_CR |
  1121.    SCC_ETHER_RX_BD_SH | SCC_ETHER_RX_BD_NO |
  1122.    SCC_ETHER_RX_BD_LG)))
  1123.             quRecv (pDrvCtrl, pRxBd);
  1124.         else
  1125.             pDrvCtrl->idr.ac_if.if_ierrors++;
  1127.         /* reset buffer descriptor as empty */
  1129. if (pRxBd->statusMode & SCC_ETHER_RX_BD_W)
  1130.             pRxBd->statusMode = SCC_ETHER_RX_BD_E | SCC_ETHER_RX_BD_I |
  1131.                                 SCC_ETHER_RX_BD_W;
  1132.         else
  1133.             pRxBd->statusMode = SCC_ETHER_RX_BD_E | SCC_ETHER_RX_BD_I;
  1135.         /* incr BD count */
  1137.         pDrvCtrl->ether.rxBdNext = (pDrvCtrl->ether.rxBdNext + 1) %
  1138.     pDrvCtrl->ether.rxBdNum;
  1140.         pRxBd = & pDrvCtrl->ether.rxBdBase[pDrvCtrl->ether.rxBdNext];
  1142.         /* clear Rx events */
  1144.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_RXF;
  1145.         }
  1147.     /* re-enable Rx interrupts */
  1149.     pDrvCtrl->ether.pSccReg->sccm |= SCC_ETHER_SCCX_RXF;
  1150.     }
  1152. /*******************************************************************************
  1153. *
  1154. * quRecv - process an input frame
  1155. *
  1156. * This routine processes an input frame, then passes it up to the higher 
  1157. * level in a form it expects.  Buffer loaning, promiscuous mode, and
  1158. * etherInputHookRtns are all supported.  Trailer protocols is not supported.
  1159. *
  1160. * RETURNS: N/A
  1161. */
  1163. LOCAL void quRecv
  1164.     (
  1165.     DRV_CTRL * pDrvCtrl, /* pointer to DRV_CTRL structure */
  1166.     SCC_BUF * pRxBd /* receive buffer descriptor */
  1167.     )
  1168.     { 
  1169.     FAST ETH_HDR * pEtherHdr; /* pointer to the ethernet header */
  1170.     MBUF * pMbuf = NULL; /* MBUF pointer */
  1171.     u_char * pData;
  1172.     int length;
  1173. #ifdef BSD43_DRIVER
  1174.     UINT16 type;
  1175. #endif /* BSD43_DRIVER */
  1177.     /* call hook if one is connected */
  1179.     if ((etherInputHookRtn != NULL) && ((*etherInputHookRtn)
  1180. (& pDrvCtrl->idr.ac_if, pRxBd->dataPointer, pRxBd->dataLength) != 0))
  1181.         return; 
  1183.     /* filter frame if controller is in promiscuous mode - M bit is buggy */
  1185.     if (pDrvCtrl->ether.pSccReg->psmr & SCC_ETHER_PSMR_PRO)
  1186. {
  1187. if ((bcmp ((char *) ((ETH_HDR *) pRxBd->dataPointer)->ether_dhost,
  1188.      (char *) pDrvCtrl->idr.ac_enaddr, ENET_ADDR_SIZE)) &&
  1189.     (bcmp ((char *) ((ETH_HDR *) pRxBd->dataPointer)->ether_dhost,
  1190.      (char *) etherbroadcastaddr, ENET_ADDR_SIZE)))
  1191.            return;
  1192. }
  1194.     /* adjust length to data only */
  1196.     length = pRxBd->dataLength - SIZEOF_ETHERHEADER;
  1197.     if (length <= 0)
  1198. { 
  1199.         pDrvCtrl->idr.ac_if.if_ierrors++;
  1200. return;
  1201. }
  1203.     /* point to ethernet header */
  1204.     
  1205.     pEtherHdr = (ETH_HDR *) pRxBd->dataPointer; 
  1207.     /* point to data */
  1208.     
  1209.     pData = (u_char *)pEtherHdr + SIZEOF_ETHERHEADER;
  1211. #ifdef BSD43_DRIVER
  1212.     /* save type - build_cluster trashes the type field */
  1214.     type = ((ETH_HDR *) pRxBd->dataPointer)->ether_type;
  1215. #endif /* BSD43_DRIVER */
  1216.     
  1217.     /* OK to loan out buffer ? -> build a mbuf cluster */
  1219.     if ((pDrvCtrl->nLoanRxBd > 0) && (USE_CLUSTER (length)))
  1220. pMbuf = build_cluster (
  1221.                 pData,
  1222.                                length,
  1223.                                & pDrvCtrl->idr.ac_if,
  1224.                                MC_QU,
  1225.                                pDrvCtrl->pRefCnt [(pDrvCtrl->nLoanRxBd - 1)],
  1226.                                (FUNCPTR)quLoanFree,
  1227.                                (int) pDrvCtrl,
  1228.                                (int) pRxBd->dataPointer,
  1229.                                (int) pDrvCtrl->pRefCnt [(pDrvCtrl->nLoanRxBd -
  1230.                                                          1)]
  1231.                                );
  1233.     /* if buffer was successfully turned into mbuf cluster */
  1235.     if (pMbuf != NULL)
  1236. pRxBd->dataPointer = pDrvCtrl->lPool[--pDrvCtrl->nLoanRxBd];
  1237.     else
  1238.         {
  1239. /* else do same ol' copy to mbuf */
  1241.         pMbuf = copy_to_mbufs (pData, length, 0, & pDrvCtrl->idr.ac_if);
  1242.         if (pMbuf == NULL)
  1243.     {
  1244.             pDrvCtrl->idr.ac_if.if_ierrors++;
  1245.             return;
  1246.     }
  1247.         }
  1249.     /* send up to protocol */
  1250. #ifdef BSD43_DRIVER
  1251.     do_protocol_with_type (type, pMbuf, & pDrvCtrl->idr, length);
  1252. #else
  1253.     do_protocol (pEtherHdr, pMbuf, &pDrvCtrl->idr, length);
  1254. #endif
  1256.     /* bump input packet counter */
  1258.     pDrvCtrl->idr.ac_if.if_ipackets++;
  1259.     }
  1261. /*******************************************************************************
  1262. *
  1263. * quLoanFree - return the given buffer to loaner pool
  1264. *
  1265. * This routine returns <pRxBuf> to the pool of available loaner buffers.
  1266. * It also returns <pRef> to the pool of available loaner reference counters,
  1267. * then zeroes the reference count.
  1268. *
  1269. * RETURNS: N/A
  1270. */
  1272. LOCAL void quLoanFree
  1273.     (
  1274.     DRV_CTRL * pDrvCtrl,
  1275.     u_char * pRxBuf,
  1276.     UINT8 * pRef
  1277.     )
  1278.     {
  1279.     /* return loaned buffer to pool */
  1281.     pDrvCtrl->lPool[pDrvCtrl->nLoanRxBd] = pRxBuf;
  1283.     /* return loaned reference count to pool */
  1285.     pDrvCtrl->pRefCnt[pDrvCtrl->nLoanRxBd++] = pRef;
  1287.     /* reset reference count - should have been done from above, but... */
  1289.     *pRef = 0;
  1290.     }