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

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

VxWorks

开发平台：

C/C++

if_cpm.c：源码内容
  1. /* if_cpm.c - Motorola CPM core network interface driver */
  3. /* Copyright 1996-1998 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01f,13apr98,map  modified SCC_DEV to SCC_ETHER_DEV.
  10. 01e,15jul97,spm  removed driver initialization from ioctl support (SPR #8831);
  11.                  corrected wait in reset routine; 
  12.                  changed interrupt handler to match if_qu driver
  13. 01d,07apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  14. 01c,06nov96,dgp  doc: final formatting
  15. 01b,06aug96,dat  fixed scce register handling, and interrupt service rtn
  16. 01a,09may96,dzb  derived from v01e of src/drv/netif/if_qu.c.
  17. */
  19. /*
  20. DESCRIPTION
  21. This module implements the driver for the Motorola CPM core Ethernet network
  22. interface used in the M68EN360 and PPC800-series communications controllers.
  24. The driver is designed to support the Ethernet mode of an SCC residing on the
  25. CPM processor core.  It is generic in the sense that it does not care
  26. which SCC is being used, and it supports up to four individual units per board.
  28. The driver must be given several target-specific parameters, and some external
  29. support routines must be provided.  These parameters, and the mechanisms used
  30. to communicate them to the driver, are detailed below.
  32. This network interface driver does not include support for trailer protocols
  33. or data chaining.  However, buffer loaning has been implemented in an effort to
  34. boost performance. This driver provides support for four individual device 
  35. units.
  37. This driver maintains cache coherency by allocating buffer space using the
  38. cacheDmaMalloc() routine.  It is assumed that cache-safe memory is returned;
  39. this driver does not perform cache flushing and invalidating.
  41. BOARD LAYOUT
  42. This device is on-chip.  No jumpering diagram is necessary.
  44. EXTERNAL INTERFACE
  45. This driver presents the standard WRS network driver API: the device
  46. unit must be attached and initialized with the cpmattach() routine.
  48. The only user-callable routine is cpmattach(), which publishes the `cpm'
  49. interface and initializes the driver structures.
  51. TARGET-SPECIFIC PARAMETERS
  52. These parameters are passed to the driver via cpmattach().
  54. .iP "address of SCC parameter RAM"
  55. This parameter is the address of the parameter RAM used to control the
  56. SCC.  Through this address, and the address of the SCC
  57. registers (see below), different network interface units are able to use
  58. different SCCs without conflict.  This parameter points to the internal
  59. memory of the chip where the SCC physically resides, which may not necessarily
  60. be the master chip on the target board.
  61. .iP "address of SCC registers"
  62. This parameter is the address of the registers used to control the
  63. SCC.  Through this address, and the address of the SCC
  64. parameter RAM (see above), different network interface units are able to use
  65. different SCCs without conflict.  This parameter points to the internal
  66. memory of the chip where the SCC physically resides, which may not necessarily
  67. be the master chip on the target board.
  68. .iP "interrupt-vector offset"
  69. This driver configures the SCC to generate hardware interrupts
  70. for various events within the device.  The interrupt-vector offset
  71. parameter is used to connect the driver's ISR to the interrupt through
  72. a call to intConnect().
  73. .iP "address of transmit and receive buffer descriptors"
  74. These parameters indicate the base locations of the transmit and receive
  75. buffer descriptor (BD) rings.  Each BD takes up 8 bytes of
  76. dual-ported RAM, and it is the user's responsibility to ensure that all
  77. specified BDs will fit within dual-ported RAM.  This includes any other
  78. BDs the target board may be using, including other SCCs, SMCs, and the
  79. SPI device.  There is no default for these parameters; they must be
  80. provided by the user.
  81. .iP "number of transmit and receive buffer descriptors"
  82. The number of transmit and receive buffer descriptors (BDs) used is
  83. configurable by the user upon attaching the driver.  Each buffer
  84. descriptor resides in 8 bytes of the chip's dual-ported RAM space,
  85. and each one points to a 1520-byte buffer in regular RAM.  There must
  86. be a minimum of two transmit and two receive BDs.  There is no maximum
  87. number of buffers, but there is a limit to how much the driver speed increases
  88. as more buffers are added, and dual-ported RAM space is at a premium.
  89. If this parameter is "NULL", a default value of 32 BDs is used.
  90. .iP "base address of buffer pool"
  91. This parameter is used to notify the driver that space for the transmit
  92. and receive buffers need not be allocated, but should be taken from a
  93. cache-coherent private memory space provided by the user at the given
  94. address.  The user should be aware that memory used for buffers must be
  95. 4-byte aligned and non-cacheable.  All the buffers
  96. must fit in the given memory space; no checking is performed.
  97. This includes all transmit and receive buffers (see above) and an
  98. additional 16 receive loaner buffers.  If the number of receive
  99. BDs is less than 16, that number of loaner buffers is
  100. used.  Each buffer is 1520 bytes.  If this parameter is "NONE," space
  101. for buffers is obtained by calling cacheDmaMalloc() in cpmattach().
  102. .LP
  104. EXTERNAL SUPPORT REQUIREMENTS
  105. This driver requires seven external support functions:
  107. .iP "STATUS sysCpmEnetEnable (int unit)" "" 9 -1
  108. This routine is expected to perform any target-specific functions required
  109. to enable the Ethernet controller.  These functions typically include
  110. enabling the Transmit Enable signal (TENA) and connecting the transmit
  111. and receive clocks to the SCC.
  112. The driver calls this routine, once per unit, from the cpmInit() routine.
  113. .iP "void sysCpmEnetDisable (int unit)"
  114. This routine is expected to perform any target-specific functions required
  115. to disable the Ethernet controller.  This usually involves disabling the
  116. Transmit Enable (TENA) signal.
  117. The driver calls this routine from the cpmReset() routine each time a unit
  118. is disabled.
  119. .iP "STATUS sysCpmEnetCommand (int unit, UINT16 command)"
  120. This routine is expected to issue a command to the Ethernet interface
  121. controller.  The driver calls this routine to perform basic commands,
  122. such as restarting the transmitter and stopping reception.
  123. .iP "void sysCpmEnetIntEnable (int unit)"
  124. This routine is expected to enable the interrupt for the Ethernet interface
  125. specified by <unit>.
  126. .iP "void sysCpmEnetIntDisable (int unit)"
  127. This routine is expected to disable the interrupt for the Ethernet interface
  128. specified by <unit>.
  129. .iP "void sysCpmEnetIntClear (int unit)"
  130. This routine is expected to clear the interrupt for the Ethernet interface
  131. specified by <unit>.
  132. .iP "STATUS sysCpmEnetAddrGet (int unit, UINT8 * addr)"
  133. The driver expects this routine to provide the 6-byte Ethernet
  134. hardware address that will be used by <unit>.  This routine must copy
  135. the 6-byte address to the space provided by <addr>.  This routine is
  136. expected to return OK on success, or ERROR.
  137. The driver calls this routine, once per unit, from the cpmInit() routine.
  138. .LP
  140. SYSTEM RESOURCE USAGE
  141. This driver requires the following system resources:
  143.     - one mutual exclusion semaphore
  144.     - one interrupt vector
  145.     - 0 bytes in the initialized data section (data)
  146.     - 1272 bytes in the uninitialized data section (BSS)
  147.  
  148. The data and BSS sections are quoted for the CPU32 architecture and may vary
  149. for other architectures.  The code size (text) varies greatly between
  150. architectures, and is therefore not quoted here.
  152. If the driver allocates the memory shared with the Ethernet device unit,
  153. it does so by calling the cacheDmaMalloc() routine.  For the default case
  154. of 32 transmit buffers, 32 receive buffers, and 16 loaner buffers, the total
  155. size requested is 121,600 bytes.  If a non-cacheable memory region is provided
  156. by the user, the size of this region should be this amount, unless the
  157. user has specified a different number of transmit or receive BDs.
  159. This driver can operate only if the shared memory region is non-cacheable,
  160. or if the hardware implements bus snooping.  The driver cannot maintain
  161. cache coherency for the device because the buffers are asynchronously
  162. modified by both the driver and the device, and these fields may share the
  163. same cache line.  Additionally, the chip's dual ported RAM must be
  164. declared as non-cacheable memory where applicable.
  166. SEE ALSO: ifLib,
  167. .I "Motorola MC68EN360 User's Manual",
  168. .I "Motorola MPC860 User's Manual",
  169. .I "Motorola MPC821 User's Manual"
  171. INTERNAL
  172. */
  174. /* includes */
  176. #include "vxWorks.h"
  177. #include "iv.h"
  178. #include "taskLib.h"
  179. #include "memLib.h"
  180. #include "ioctl.h"
  181. #include "etherLib.h"
  182. #include "net/mbuf.h"
  183. #include "net/protosw.h"
  184. #include "socket.h"
  185. #include "errno.h"
  186. #include "net/if.h"
  187. #include "net/unixLib.h"
  188. #include "net/route.h"
  189. #include "netinet/in.h"
  190. #include "netinet/in_systm.h"
  191. #include "netinet/in_var.h"
  192. #include "netinet/ip.h"
  193. #include "netinet/if_ether.h"
  194. #include "net/if_subr.h"
  195. #include "cacheLib.h"
  196. #include "stdio.h"
  197. #include "intLib.h"
  198. #include "netLib.h"
  199. #include "drv/netif/netifDev.h"
  200. #include "drv/netif/if_cpm.h"
  202. /* defines */
  204. #define MAX_UNITS 4 /* max cpm units */
  205. #define ENET_ADDR_SIZE 0x6 /* size of Ethernet src/dest addresses */
  206. #define TX_BD_MIN 2 /* minimum number of Tx buffer descriptors */
  207. #define RX_BD_MIN 2 /* minimum number of Rx buffer descriptors */
  208. #define TX_BD_DEFAULT 0x20 /* default number of Tx buffer descriptors */
  209. #define RX_BD_DEFAULT 0x20 /* default number of Rx buffer descriptors */
  210. #define FRAME_MAX 0x05ee /* maximum frame size */
  211. #define FRAME_MAX_AL 0x05f0 /* maximum frame size, 4 byte alligned */
  212. #define FRAME_MIN 0x0040 /* minimum frame size */
  213. #define L_POOL 0x10 /* number of Rx loaner buffers in pool */
  215. /* typedefs */
  217. typedef struct mbuf MBUF;
  218. typedef struct arpcom IDR; /* Interface Data Record */
  219. typedef struct ifnet IFNET;
  220. typedef struct sockaddr SOCK;
  222. typedef struct drv_ctrl /* DRV_CTRL */
  223.     {
  224.     IDR idr; /* Interface Data Record */
  225.     BOOL attached; /* indicates unit is attached */
  226.     BOOL txStop; /* emergency stop output */
  227.     int nLoanRxBd; /* number of receive buffers left to loan */
  228.     UINT8 * lPool[L_POOL]; /* receive BD loaner pool */
  229.     UINT8 * pRefCnt[L_POOL];/* stack of reference count pointers */
  230.     UINT8 refCnt[L_POOL]; /* actual reference count values */
  231.     SCC_ETHER_DEV ether; /* Ethernet SCC device */
  232.     } DRV_CTRL;
  234. /* globals */
  236. IMPORT STATUS sysCpmEnetEnable  (int unit);
  237. IMPORT void   sysCpmEnetDisable (int unit);
  238. IMPORT STATUS sysCpmEnetAddrGet (int unit, UINT8 * addr);
  239. IMPORT STATUS sysCpmEnetCommand (int unit, UINT16 command);
  240. IMPORT void   sysCpmEnetIntEnable (int unit);
  241. IMPORT void   sysCpmEnetIntDisable (int unit);
  242. IMPORT void   sysCpmEnetIntClear (int unit);
  244. /* locals */
  246. LOCAL DRV_CTRL drvCtrl[MAX_UNITS]; /* array of driver control */
  248. /* forward declarations */
  250. #ifdef __STDC__
  252. LOCAL STATUS    cpmInit (int unit);
  253. #ifdef BSD43_DRIVER
  254. LOCAL int       cpmOutput (IFNET * pIfNet, MBUF * pMbuf, SOCK * pSock);
  255. LOCAL void      cpmStartOutput (int unit);
  256. #else
  257. LOCAL void      cpmStartOutput (DRV_CTRL * pDrvCtrl);
  258. #endif
  259. LOCAL int       cpmIoctl (IFNET * pIfNet, int cmd, caddr_t data);
  260. LOCAL STATUS    cpmReset (int unit);
  261. LOCAL void      cpmIntr (int unit);
  262. LOCAL void cpmTxRestart (int unit);
  263. LOCAL void      cpmHandleInt (DRV_CTRL * pDrvCtrl);
  264. LOCAL void      cpmRecv (DRV_CTRL * pDrvCtrl, SCC_BUF * pRxBd);
  265. LOCAL void      cpmLoanFree (DRV_CTRL * pDrvCtrl, UINT8 * pRxBuf, UINT8 * pRef);
  267. #else  /* __STDC__ */
  269. LOCAL STATUS    cpmInit ();
  270. LOCAL int       cpmOutput ();
  271. LOCAL void      cpmStartOutput ();
  272. LOCAL int       cpmIoctl ();
  273. LOCAL STATUS    cpmReset ();
  274. LOCAL void      cpmIntr ();
  275. LOCAL void cpmTxRestart ();
  276. LOCAL void      cpmHandleInt ();
  277. LOCAL void      cpmRecv (); 
  278. LOCAL void      cpmLoanFree (); 
  280. #endif  /* __STDC__ */
  282. /*******************************************************************************
  283. *
  284. * cpmattach - publish the `cpm' network interface and initialize the driver
  285. *
  286. * The routine publishes the `cpm' interface by filling in a network Interface
  287. * Data Record (IDR) and adding this record to the system's interface list.
  288. *
  289. * The SCC shares a region of memory with the driver.  The caller of this
  290. * routine can specify the address of a shared, non-cacheable memory region
  291. * with <bufBase>.  If this parameter is NONE, the driver obtains this
  292. * memory region by calling cacheDmaMalloc().  Non-cacheable memory space
  293. * is important for cases where the SCC is operating with a processor
  294. * that has a data cache.
  295. *
  296. * Once non-cacheable memory is obtained, this routine divides up the
  297. * memory between the various buffer descriptors (BDs).  The number
  298. * of BDs can be specified by <txBdNum> and <rxBdNum>, or if NULL, a
  299. * default value of 32 BDs will be used.  Additional buffers are
  300. * reserved as receive loaner buffers.  The number of loaner buffers is the
  301. * lesser of <rxBdNum> and a default value of 16.
  302. *
  303. * The user must specify the location of the transmit and receive BDs in
  304. * the CPU's dual-ported RAM.  <txBdBase> and <rxBdBase> give the
  305. * base address of the BD rings.  Each BD uses 8 bytes. Care must be taken so
  306. * that the specified locations for Ethernet BDs do not conflict with other
  307. * dual-ported RAM structures. 
  308. *
  309. * Up to four individual device units are supported by this driver.  Device
  310. * units may reside on different processor chips, or may be on different SCCs
  311. * within a single CPU.
  312. * 
  313. * Before this routine returns, it calls cpmReset() and cpmInit() to 
  314. * configure the Ethernet controller, and connects the interrupt vector <ivec>.
  315. *
  316. * RETURNS: OK or ERROR.
  317. *
  318. * SEE ALSO: ifLib,
  319. * .I "Motorola MC68360 User's Manual",
  320. * .I "Motorola MPC821 and MPC860 User's Manual"
  321. */
  323. STATUS cpmattach
  324.     (
  325.     int unit, /* unit number */
  326.     SCC * pScc, /* address of SCC parameter RAM */
  327.     SCC_REG * pSccReg, /* address of SCC registers */
  328.     VOIDFUNCPTR * ivec, /* interrupt vector offset */
  329.     SCC_BUF * txBdBase, /* transmit buffer descriptor base address */
  330.     SCC_BUF * rxBdBase, /* receive buffer descriptor base address */
  331.     int txBdNum, /* number of transmit buffer descriptors */
  332.     int rxBdNum, /* number of receive buffer descriptors */
  333.     UINT8 * bufBase /* address of memory pool; NONE = malloc it */
  334.     )
  335.     {
  336.     DRV_CTRL * pDrvCtrl;
  337.     int counter;
  338.     int loanNum = L_POOL;
  339.     UINT8 * txBuf;
  340.     UINT8 * rxBuf;
  341.     UINT8 * loanBuf;
  342.      
  343.     if (unit < 0 || unit >= MAX_UNITS) /* sanity check the unit number */
  344.  return (ERROR);
  345.   
  346.     pDrvCtrl = & drvCtrl[unit];
  347.     
  348.     /* ensure single invocation */
  350.     if (pDrvCtrl->attached)
  351.         return (ERROR);
  353.     /* do a quick check of input parameters */
  355.     if (txBdBase == rxBdBase)
  356. return (ERROR);
  358.     /* publish the Interface Data Record */
  360. #ifdef BSD43_DRIVER
  361.     ether_attach (& pDrvCtrl->idr.ac_if, unit, "cpm", (FUNCPTR) cpmInit,
  362.                   (FUNCPTR) cpmIoctl, (FUNCPTR) cpmOutput, (FUNCPTR) cpmReset);
  363. #else
  364.     ether_attach (
  365.                  &pDrvCtrl->idr.ac_if, 
  366.                  unit, 
  367.                  "cpm", 
  368.                  (FUNCPTR) cpmInit,
  369.                  (FUNCPTR) cpmIoctl, 
  370.                  (FUNCPTR) ether_output, 
  371.                  (FUNCPTR) cpmReset
  372.                  );
  373.     pDrvCtrl->idr.ac_if.if_start = (FUNCPTR)cpmStartOutput;
  374. #endif
  376.     /* use default number of buffer descriptors if user did not specify */
  378.     if (txBdNum == NULL)
  379. txBdNum = TX_BD_DEFAULT;
  380.     if (rxBdNum == NULL)
  381. rxBdNum = RX_BD_DEFAULT;
  383.     /* must be at least two transmit and receive buffer descriptors */
  385.     txBdNum = max (TX_BD_MIN, txBdNum);
  386.     rxBdNum = max (RX_BD_MIN, rxBdNum);
  387.     loanNum = min (rxBdNum, loanNum); 
  389.     /* fill in driver control structure for <unit> */
  391.     pDrvCtrl->nLoanRxBd       = loanNum;
  392.     pDrvCtrl->ether.txBdNum   = txBdNum;
  393.     pDrvCtrl->ether.rxBdNum   = rxBdNum;
  394.     pDrvCtrl->ether.txBdBase  = txBdBase;
  395.     pDrvCtrl->ether.rxBdBase  = rxBdBase;
  396.     pDrvCtrl->ether.txBufSize = FRAME_MAX_AL;
  397.     pDrvCtrl->ether.rxBufSize = FRAME_MAX_AL;
  398.     pDrvCtrl->ether.pScc      = pScc;
  399.     pDrvCtrl->ether.pSccReg   = pSccReg;
  400.     
  401.     /* set up Rx and Tx buffers */
  403.     if (bufBase == (UINT8 *) NONE)
  404. {
  405.         /* allocate memory pools */
  407. txBuf = cacheDmaMalloc (txBdNum * pDrvCtrl->ether.txBufSize);
  408.         if (txBuf == NULL)
  409.     return (ERROR);
  411. rxBuf = cacheDmaMalloc (rxBdNum * pDrvCtrl->ether.rxBufSize);
  412.         if (rxBuf == NULL)
  413.     {
  414.     free (txBuf);
  415.     return (ERROR);
  416.     }
  418.         loanBuf = cacheDmaMalloc (loanNum * pDrvCtrl->ether.rxBufSize);
  419. if (loanBuf == NULL)
  420.             pDrvCtrl->nLoanRxBd = 0;
  421.         }
  422.     else
  423. {
  424. /* use passed in address as memory pool - assume OK */
  426. txBuf   = bufBase;
  427. rxBuf   = (UINT8 *) (txBuf + (txBdNum * pDrvCtrl->ether.txBufSize));
  428. loanBuf = (UINT8 *) (rxBuf + (rxBdNum * pDrvCtrl->ether.rxBufSize));
  429. }
  431.     /* assign buffer addresses */
  433.     for (counter = 0; counter < txBdNum; counter++)
  434.         pDrvCtrl->ether.txBdBase[counter].dataPointer = (txBuf + (counter *
  435.     pDrvCtrl->ether.txBufSize));
  437.     for (counter = 0; counter < rxBdNum; counter++)
  438.         pDrvCtrl->ether.rxBdBase[counter].dataPointer = (rxBuf + (counter *
  439.     pDrvCtrl->ether.rxBufSize));
  441.     for (counter = 0; counter < pDrvCtrl->nLoanRxBd; counter++)
  442.         {
  443.         pDrvCtrl->lPool[counter] = (loanBuf + (counter *
  444.     pDrvCtrl->ether.rxBufSize));
  445.         pDrvCtrl->refCnt[counter] = 0;
  446. pDrvCtrl->pRefCnt[counter] = & pDrvCtrl->refCnt[counter];
  447.         }
  449.     /* reset the chip */
  451.     if (cpmReset (unit) == ERROR)
  452.         return (ERROR);
  454.     /* connect the interrupt handler cpmIntr() */
  456.     if (intConnect (ivec, (VOIDFUNCPTR) cpmIntr, unit) == ERROR)
  457.         return (ERROR);
  459.     /* Initialize and start controller */
  461.     cpmInit (unit);
  463.     /* mark driver as attached */
  465.     pDrvCtrl->attached = TRUE;
  467.     return (OK);
  468.     }
  470. /*******************************************************************************
  471. *
  472. * cpmInit - network interface initialization routine
  473. *
  474. * This routine marks the interface as down, then configures and initializes
  475. * the chip.  It sets up the transmit and receive buffer descriptor (BD)
  476. * rings, initializes registers, and enables interrupts.  Finally, it marks
  477. * the interface as up and running.  It does not touch the receive loaner
  478. * buffer stack.
  479. *
  480. * The complement of this routine is cpmReset().  Once a unit is reset by
  481. * cpmReset(), it may be re-initialized to a running state by this routine.
  482. *
  483. * RETURNS: OK if successful, otherwise ERROR.
  484. */
  486. LOCAL STATUS cpmInit
  487.     (
  488.     int unit /* unit number */
  489.     )
  490.     {
  491.     DRV_CTRL * pDrvCtrl;
  492.     UINT8 enetAddr[ENET_ADDR_SIZE];
  493.     int counter;
  495.     /* sanity check the unit number */
  497.     if (unit < 0 || unit >= MAX_UNITS)
  498.  return (ERROR);
  500.     pDrvCtrl = & drvCtrl[unit];
  502.     /* mark the device as down */
  503.  
  504.     pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
  506.     /* initialize flag(s) */
  508.     pDrvCtrl->txStop = FALSE;
  510.     /* set up transmit buffer descriptors */
  512.     pDrvCtrl->ether.pScc->param.tbase = (UINT16)
  513. ((UINT32) pDrvCtrl->ether.txBdBase & 0xfff);
  514.     pDrvCtrl->ether.pScc->param.tbptr = (UINT16)
  515. ((UINT32) pDrvCtrl->ether.txBdBase & 0xfff);
  517.     pDrvCtrl->ether.txBdNext  = 0;
  519.     /* initialize each transmit buffer descriptor */
  520.      
  521.     for (counter = 0; counter < pDrvCtrl->ether.txBdNum; counter++)
  522.         pDrvCtrl->ether.txBdBase[counter].statusMode = SCC_ETHER_TX_BD_I |
  523.                                                        SCC_ETHER_TX_BD_PAD |
  524.                                                        SCC_ETHER_TX_BD_L |
  525.                                                        SCC_ETHER_TX_BD_TC;
  527.     /* set the last BD to wrap to the first */
  529.     pDrvCtrl->ether.txBdBase[(counter - 1)].statusMode |= SCC_ETHER_TX_BD_W;
  531.     /* set up receive buffer descriptors */
  533.     pDrvCtrl->ether.pScc->param.rbase = (UINT16)
  534. ((UINT32) pDrvCtrl->ether.rxBdBase & 0xfff);
  535.     pDrvCtrl->ether.pScc->param.rbptr = (UINT16)
  536. ((UINT32) pDrvCtrl->ether.rxBdBase & 0xfff);
  538.     pDrvCtrl->ether.rxBdNext  = 0;
  540.     /* initialize each receive buffer descriptor */
  542.     for (counter = 0; counter < pDrvCtrl->ether.rxBdNum; counter++)
  543.         pDrvCtrl->ether.rxBdBase[counter].statusMode = SCC_ETHER_RX_BD_I |
  544.                 SCC_ETHER_RX_BD_E;
  546.     /* set the last BD to wrap to the first */
  548.     pDrvCtrl->ether.rxBdBase[(counter - 1)].statusMode |= SCC_ETHER_RX_BD_W;
  550.     /* set SCC attributes to Ethernet mode */
  551.  
  552.     pDrvCtrl->ether.pSccReg->gsmrl    = SCC_GSMRL_ETHERNET | SCC_GSMRL_TPP_10 |
  553.                                         SCC_GSMRL_TPL_48   | SCC_GSMRL_TCI;
  554.     pDrvCtrl->ether.pSccReg->gsmrh    = 0x0;
  556.     pDrvCtrl->ether.pSccReg->psmr     = SCC_ETHER_PSMR_CRC |
  557. SCC_ETHER_PSMR_NIB_22;
  558.  
  559.     if (pDrvCtrl->idr.ac_if.if_flags & IFF_PROMISC)
  560.         pDrvCtrl->ether.pSccReg->psmr |= SCC_ETHER_PSMR_PRO;
  561.  
  562.     pDrvCtrl->ether.pSccReg->dsr      = 0xd555;
  563.     pDrvCtrl->ether.pScc->param.rfcr  = 0x18;      /* supervisor data access */
  564.     pDrvCtrl->ether.pScc->param.tfcr  = 0x18;      /* supervisor data access */
  565.     pDrvCtrl->ether.pScc->param.mrblr = FRAME_MAX_AL;  /* max rx buffer size */
  567.     /* initialize parameter the SCC RAM */
  568.  
  569.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->c_pres = 0xffffffff;
  570.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->c_mask = 0xdebb20e3;
  571.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->crcec = 0x00000000;
  572.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->alec = 0x00000000;
  573.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->disfc = 0x00000000;
  574.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->pads = 0x8888;
  575.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->ret_lim = 0x000f;
  576.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->mflr = FRAME_MAX;
  577.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->minflr = FRAME_MIN;
  578.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->maxd1 = FRAME_MAX;
  579.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->maxd2 = FRAME_MAX;
  580.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr1 = 0x0000;
  581.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr2 = 0x0000;
  582.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr3 = 0x0000;
  583.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr4 = 0x0000;
  584.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->p_per = 0x0000;
  585.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->iaddr1 = 0x0000;
  586.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->iaddr2 = 0x0000;
  587.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->iaddr3 = 0x0000;
  588.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->iaddr4 = 0x0000;
  589.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->taddr_h = 0x0000;
  590.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->taddr_m = 0x0000;
  591.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->taddr_l = 0x0000;
  593.     /* set the hardware Ethernet address of the board */
  595.     if (sysCpmEnetAddrGet (unit, (UINT8 *) & enetAddr) == ERROR)
  596. return (ERROR);
  598.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->paddr1_h =
  599.         (enetAddr[5] << 8) + enetAddr[4];
  600.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->paddr1_m =
  601.         (enetAddr[3] << 8) + enetAddr[2];
  602.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->paddr1_l =
  603.         (enetAddr[1] << 8) + enetAddr[0];
  605.     bcopy ((char *) enetAddr, (char *) pDrvCtrl->idr.ac_enaddr, ENET_ADDR_SIZE);
  607.     /* enable Ethernet interrupts */
  609.     pDrvCtrl->ether.pSccReg->scce = 0xffff; /* clr events */
  611.     pDrvCtrl->ether.pSccReg->sccm = SCC_ETHER_SCCX_RXF | SCC_ETHER_SCCX_TXE;
  613.     sysCpmEnetIntEnable (unit); /* unmask interrupts */
  615.     /* call the BSP to do any other initialization (e.g., connecting clocks) */
  617.     if (sysCpmEnetEnable (unit) == ERROR)
  618. return (ERROR);
  620.     /* raise the interface flags - mark the device as up */
  621.  
  622.     pDrvCtrl->idr.ac_if.if_flags |= IFF_UP | IFF_RUNNING | IFF_NOTRAILERS;
  624.     /* enable the transmitter */
  626.     pDrvCtrl->ether.pSccReg->gsmrl |= SCC_GSMRL_ENT;
  628.     /* issue the restart transmitter command to the CP */
  630.     (void) sysCpmEnetCommand (unit, CPM_CR_SCC_RESTART);
  632.     /* enable the receiver */
  634.     pDrvCtrl->ether.pSccReg->gsmrl |= SCC_GSMRL_ENR;
  636.     return (OK);
  637.     }
  639. #ifdef BSD43_DRIVER
  640. /*******************************************************************************
  641. *
  642. * cpmOutput - network interface output routine
  643. *
  644. * This routine simply calls ether_output(). ether_output() resolves 
  645. * the hardware addresses and calls cpmStartOutput() with the unit number
  646. * passed as an argument.
  647. *
  648. * RETURNS: OK if successful, otherwise errno.
  649. */
  651. LOCAL int cpmOutput
  652.     (
  653.     IFNET * pIfNet, /* pointer to IFNET structure */
  654.     MBUF * pMbuf, /* mbuf chain for output */
  655.     SOCK * pSock /* sock ptr for destination */  
  656.     )
  657.     {
  658.     DRV_CTRL * pDrvCtrl = & drvCtrl[pIfNet->if_unit];
  660.     return (ether_output (pIfNet, pMbuf, pSock, (FUNCPTR) cpmStartOutput,
  661.     & pDrvCtrl->idr));
  662.     }
  663. #endif
  665. /*******************************************************************************
  666. *
  667. * cpmStartOutput - output packet to network interface device
  668. *
  669. * cpmStartOutput() takes a packet from the network interface output queue,
  670. * copies the mbuf chain into an interface buffer, and sends the packet over
  671. * the interface.  etherOutputHookRtns are supported.
  672. *
  673. * Collision stats are collected in this routine from previously sent BDs.
  674. * These BDs will not be examined until after the transmitter has cycled the
  675. * ring, coming upon the BD after it has been sent. Thus, collision stat
  676. * collection will be delayed a full cycle through the Tx ring.
  677. *
  678. * This routine is called from several possible threads.  Each one will be
  679. * described below.
  680. *
  681. * The first, and most common thread, is when a user task requests the
  682. * transmission of data. Under BSD 4.3, this will cause cpmOutput() to be
  683. * called, which calls ether_output(), which usually calls this routine. 
  684. * This routine will not be called if ether_output() finds that our interface
  685. * output queue is full. In this very rare case, the outgoing data will be 
  686. * thrown out. BSD 4.4 uses a slightly different model in which the generic
  687. * ether_output() routine is called directly, followed by a call to this
  688. * routine.
  689. *
  690. * The second thread is when a transmitter error occurs that causes a
  691. * TXE event interrupt.  This happens for the following errors: transmitter
  692. * underrun, retry limit reached, late collision, and heartbeat error.
  693. * The ISR sets the txStop flag to stop the transmitter until the errors are
  694. * serviced. These events require a RESTART command of the transmitter, which
  695. * occurs in the cpmTxRestart() routine.  After the transmitter is restarted,
  696. * cpmTxRestart() does a netJobAdd of cpmStartOutput() to send any packets
  697. * left in the interface output queue.  Thus, the second thread executes
  698. * in the context of netTask().
  699. *
  700. * The third, and most unlikely, thread occurs when this routine is executing
  701. * and it runs out of free Tx BDs.  In this case, this routine turns on
  702. * transmit interrupt and exits.  When the next BD is actually sent, an interrupt
  703. * occurs.  The ISR does a netJobAdd of cpmStartOutput() to continue sending
  704. * packets left in the interface output queue.  Once again, we find ourselves
  705. * executing in the context of netTask().
  706. *
  707. * RETURNS: N/A
  708. */
  710. #ifdef BSD43_DRIVER
  711. LOCAL void cpmStartOutput
  712.     (
  713.     int unit /* unit number */
  714.     )
  715.     {
  716.     DRV_CTRL * pDrvCtrl = & drvCtrl[unit];
  717. #else
  718. LOCAL void cpmStartOutput
  719.     (
  720.     DRV_CTRL *  pDrvCtrl /* driver control structure */
  721.     )
  722.     {
  723. #endif
  724.     MBUF * pMbuf; /* mbuf pointer */
  725.     int length;
  726.     SCC_BUF * pTxBd;
  727.     UINT8 * pad;
  729.     /*
  730.      * Loop until:
  731.      *     a) there are no more packets ready to send
  732.      *     b) we have insufficient resources left to send another one
  733.      *     c) a fatal transmitter error occurred, thus txStop was set
  734.      */
  736.     while (!pDrvCtrl->txStop && (pDrvCtrl->idr.ac_if.if_snd.ifq_head != NULL))
  737.         {
  738. pTxBd = & pDrvCtrl->ether.txBdBase[pDrvCtrl->ether.txBdNext];
  740. /* check if a transmit buffer descriptor is available */
  742.         if (pTxBd->statusMode & SCC_ETHER_TX_BD_R)
  743.     {
  744.     /* if no BD available, enable interrupt to see when one is free */
  746.             pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_TXB;
  747.             pDrvCtrl->ether.pSccReg->sccm |= SCC_ETHER_SCCX_TXB;
  748.     break;
  749.     }
  751.         IF_DEQUEUE (& pDrvCtrl->idr.ac_if.if_snd, pMbuf); /* dequeue a packet */
  753.         copy_from_mbufs (pTxBd->dataPointer, pMbuf, length);
  755.         /* padding mechanism in Rev A is buggy - do in software */
  757.         if (length < FRAME_MIN)
  758.             {
  759.             pad = pTxBd->dataPointer + length;
  760.             for (; length != FRAME_MIN; length++, pad++)
  761.                 *pad = 0x88;
  762.             }
  764.         /* call hook if one is connected */
  766.         if ((etherOutputHookRtn == NULL) || ((* etherOutputHookRtn)
  767.     (& pDrvCtrl->idr.ac_if, pTxBd->dataPointer, length) == 0))
  768.             {
  769.     /* add in collision stats from previously sent BDs */
  771.             pDrvCtrl->idr.ac_if.if_collisions += ((pTxBd->statusMode &
  772.           SCC_ETHER_TX_BD_RC) >> 2);
  774.     /* if hook did not grab the frame, send packet */
  776.             pTxBd->dataLength = length;
  777.             if (pTxBd->statusMode & SCC_ETHER_TX_BD_W)
  778.                 pTxBd->statusMode = SCC_ETHER_TX_BD_I | SCC_ETHER_TX_BD_PAD |
  779.                                     SCC_ETHER_TX_BD_L | SCC_ETHER_TX_BD_TC  |
  780.                                     SCC_ETHER_TX_BD_W | SCC_ETHER_TX_BD_R;
  781.     else
  782.                 pTxBd->statusMode = SCC_ETHER_TX_BD_I | SCC_ETHER_TX_BD_PAD |
  783.                                     SCC_ETHER_TX_BD_L | SCC_ETHER_TX_BD_TC  |
  784.                                     SCC_ETHER_TX_BD_R;
  786.             /* incr BD count */
  788.     pDrvCtrl->ether.txBdNext = (pDrvCtrl->ether.txBdNext + 1) %
  789.         pDrvCtrl->ether.txBdNum;
  791. #ifndef BSD43_DRIVER    /* BSD 4.4 ether_output() doesn't bump statistic. */
  792.             pDrvCtrl->idr.ac_if.if_opackets++;
  793. #endif
  794.             }
  795.         }
  796.     }
  798. /*******************************************************************************
  799. *
  800. * cpmIoctl - network interface control routine
  801. *
  802. * This routine implements the network interface control functions.
  803. * It handles SIOCSIFADDR and SIOCSIFFLAGS commands.
  804. *
  805. * RETURNS: OK if successful, otherwise EINVAL.
  806. */
  808. LOCAL int cpmIoctl
  809.     (
  810.     IFNET * pIfNet, /* pointer to IFNET structure */
  811.     int cmd, /* command to process */
  812.     caddr_t data /* pointer to data */ 
  813.     )
  814.     {
  815.     DRV_CTRL * pDrvCtrl = & drvCtrl[pIfNet->if_unit];
  816.     int         error   = 0;            /* error value */
  817.     int         s       = splimp ();    /* sem not taken in calling functions */
  819.     switch (cmd)
  820.         {
  821.         case SIOCSIFADDR:       /* set interface address */
  822.             ((struct arpcom *)pIfNet)->ac_ipaddr = IA_SIN (data)->sin_addr;
  823.             arpwhohas (pIfNet, &IA_SIN (data)->sin_addr);
  824.             break;
  825.     
  826.         case SIOCSIFFLAGS:
  827.     /* set promiscuous bit according to flags */
  829.     if (pDrvCtrl->idr.ac_if.if_flags & IFF_PROMISC)
  830.                 pDrvCtrl->ether.pSccReg->psmr |= SCC_ETHER_PSMR_PRO;
  831.             else
  832.                 pDrvCtrl->ether.pSccReg->psmr &= ~SCC_ETHER_PSMR_PRO;
  834.             break;
  836.         default:
  837.             error = EINVAL;
  838.         }
  840.     splx (s);
  841.     return (error);
  842.     }
  844. /*******************************************************************************
  845. *
  846. * cpmReset - network interface reset routine
  847. *
  848. * This routine marks the interface as down and resets the device.  This
  849. * includes disabling interrupts, stopping the transmitter and receiver,
  850. * and calling sysCpmEnetDisable() to do any target specific disabling.
  851. *
  852. * The complement of this rotuine is cpmInit().  Once a unit is reset in this
  853. * routine, it may be re-initialized to a running state by cpmInit().
  854. *
  855. * RETURNS: N/A
  856. */
  858. LOCAL STATUS cpmReset
  859.     (
  860.     int unit /* unit number */
  861.     )
  862.     {
  863.     DRV_CTRL * pDrvCtrl;
  865.     if (unit < 0 || unit >= MAX_UNITS) /* sanity check the unit number */
  866.         return (ERROR);
  868.     pDrvCtrl = & drvCtrl[unit];
  870.     sysCpmEnetIntDisable (unit); /* disable the SCC interrupts */
  872.     /* issue the CP graceful stop command to the transmitter if necessary */
  874.     if (pDrvCtrl->ether.pSccReg->gsmrl & SCC_GSMRL_ENT)
  875. {
  876. (void) sysCpmEnetCommand (unit, CPM_CR_SCC_GRSTOP);
  878.         /* wait for graceful stop to register */
  880.         /* wait for graceful stop to register */
  882.         taskDelay (sysClkRateGet ());
  884.         if (!(pDrvCtrl->ether.pSccReg->scce & SCC_ETHER_SCCX_GRA))
  885.             return (ERROR);     /* Stop not registered. */
  886. }
  888.     /* disable the SCC receiver and transmitter */
  890.     pDrvCtrl->ether.pSccReg->gsmrl &= ~(SCC_GSMRL_ENR | SCC_GSMRL_ENT);
  892.     /* call the BSP to do any other disabling (e.g., *TENA) */
  894.     sysCpmEnetDisable (unit);
  896.     /* mark the driver as down */
  898.     pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
  900.     return (OK);
  901.     }
  903. /*******************************************************************************
  904. *
  905. * cpmIntr - network interface interrupt handler
  906. *
  907. * This routine gets called at interrupt level. It handles work that 
  908. * requires minimal processing. Interrupt processing that is more 
  909. * extensive gets handled at task level. The network task, netTask(), is 
  910. * provided for this function. Routines get added to the netTask() work 
  911. * queue via the netJobAdd() command.
  912. *
  913. * RETURNS: N/A
  914. */
  916. LOCAL void cpmIntr
  917.     (
  918.     int unit /* unit number */
  919.     )
  920.     {
  921.     DRV_CTRL * pDrvCtrl = & drvCtrl[unit];
  922.     BOOL rxHandle = FALSE;
  923.     BOOL txHandle = FALSE;
  925.     int events;
  928.     /* identify and acknowledge all interrupt events */
  930.     events = (pDrvCtrl->ether.pSccReg->scce & pDrvCtrl->ether.pSccReg->sccm);
  932.     /* check for spurious interrupt */
  934.     if (!pDrvCtrl->attached)
  935. {
  936.         pDrvCtrl->ether.pSccReg->scce = 0xffff;
  938. sysCpmEnetIntClear (unit);
  940. return;
  941. }
  943.     /* handle receive events */
  945.     if (events & SCC_ETHER_SCCX_RXF)
  946. {
  947.         (void) netJobAdd ((FUNCPTR) cpmHandleInt, (int) pDrvCtrl, 0, 0, 0, 0); 
  949. /* turn off receive interrupts for now - cpmHandleInt turns back on */
  951.         pDrvCtrl->ether.pSccReg->sccm &= ~SCC_ETHER_SCCX_RXF;
  952.         rxHandle = TRUE;
  953.         }
  955.     /* check for output errors */
  957.     if (pDrvCtrl->ether.pSccReg->scce & SCC_ETHER_SCCX_TXE)
  958. {
  959. /* NOTE: HBC error not supported -> always RESTART Tx here */
  961.         (void) netJobAdd ((FUNCPTR) cpmTxRestart, unit, 0, 0, 0, 0);
  963. pDrvCtrl->txStop = TRUE;
  964. }
  966.     /* handle transmitter events - BD full condition -> ever happen ? */
  968.     if (events & SCC_ETHER_SCCX_TXB)
  969. {
  970. #ifdef BSD43_DRIVER
  971.         (void) netJobAdd ((FUNCPTR) cpmStartOutput, unit, 0, 0, 0, 0); 
  972. #else
  973.         (void) netJobAdd ((FUNCPTR) cpmStartOutput, (int)pDrvCtrl, 0, 0, 0, 0); 
  974. #endif
  975.         pDrvCtrl->ether.pSccReg->sccm &= ~SCC_ETHER_SCCX_TXB;
  976. }
  978.     /* check for input busy condition, we don't enable this interrupt
  979.        but we check for it with each interrupt. */
  981.     if (pDrvCtrl->ether.pSccReg->scce & SCC_ETHER_SCCX_BSY)
  982. {
  983.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_BSY; 
  985.         /* count discarded frames as errors */
  987.         pDrvCtrl->idr.ac_if.if_ierrors +=
  988.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->disfc;
  989. ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->disfc = 0;
  990. }
  992.     /* ignore and reset all other events */
  994.     pDrvCtrl->ether.pSccReg->scce = (pDrvCtrl->ether.pSccReg->scce &
  995.                                      ~(SCC_ETHER_SCCX_RXF |
  996.        SCC_ETHER_SCCX_TXE |
  997.        SCC_ETHER_SCCX_TXB |
  998.        SCC_ETHER_SCCX_BSY));
  1000.     if (rxHandle)
  1001.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_RXF;
  1002.     if (pDrvCtrl->txStop)
  1003.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_TXE;
  1004.     if (txHandle)
  1005.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_TXB;
  1007.     sysCpmEnetIntClear (unit);
  1008.     }
  1010. /*******************************************************************************
  1011. *
  1012. * cpmTxRestart - issue RESTART Tx command to the CP
  1013. *
  1014. * This routine issues a RESTART transmitter command to the CP.  It is
  1015. * executed by netTask (cpmIntr() did a netJobAdd).  cpmIntr() cannot do
  1016. * a RESTART directly because the CPM flag must be taken before a command
  1017. * can be written.  After a restart, a netJobAdd of cpmStartOutput() is
  1018. * performed in order to send any packets remaining in the interface output
  1019. * queue.
  1020. *
  1021. * RETURNS: N/A
  1022. */
  1024. LOCAL void cpmTxRestart
  1025.     (
  1026.     int unit /* unit number */
  1027.     )
  1028.     {
  1029.     DRV_CTRL * pDrvCtrl = & drvCtrl[unit];
  1031.     /* update error counter */
  1033.     pDrvCtrl->idr.ac_if.if_oerrors++;
  1035.     /* correct packet counter */
  1037.     pDrvCtrl->idr.ac_if.if_opackets--;
  1039.     /* restart the transmitter */
  1041.     (void) sysCpmEnetCommand (unit, CPM_CR_SCC_RESTART);
  1043.     /* restart transmit routine */
  1045.     pDrvCtrl->txStop = FALSE;
  1046. #ifdef BSD43_DRIVER
  1047.     (void) netJobAdd ((FUNCPTR) cpmStartOutput, unit, 0, 0, 0, 0); 
  1048. #else
  1049.     (void) netJobAdd ((FUNCPTR) cpmStartOutput, (int)pDrvCtrl, 0, 0, 0, 0); 
  1050. #endif
  1051.     }
  1053. /*******************************************************************************
  1054. *
  1055. * cpmHandleInt - task-level interrupt handler
  1056. *
  1057. * This is the task-level interrupt handler, which is called from 
  1058. * netTask(). cpmHandleInt() gets input frames from the device and then calls 
  1059. * cpmRecv() to process each frame.  cpmRecv() only gets called if no error
  1060. * stats were reported in the buffer descriptor.  Data chaining is not
  1061. * supported.
  1062. *
  1063. * This routine should be called with SCC receive interrupts masked so that
  1064. * more netJobAdds of this routine are not performed by cpmIntr().
  1065. * Receive interrupts are turned back on by this routine before exiting.
  1066. *
  1067. * RETURNS: N/A
  1068. */
  1070. LOCAL void cpmHandleInt
  1071.     (
  1072.     DRV_CTRL * pDrvCtrl /* pointer to DRV_CTRL structure */
  1073.     )
  1074.     {
  1075.     SCC_BUF * pRxBd = & pDrvCtrl->ether.rxBdBase[pDrvCtrl->ether.rxBdNext];
  1077.     while (!(pRxBd->statusMode & SCC_ETHER_RX_BD_E))
  1078.         {
  1079.         /* data chaining is not supported - check all error conditions */
  1081.         if (((pRxBd->statusMode & (SCC_ETHER_RX_BD_F  | SCC_ETHER_RX_BD_L))
  1082.                        == (SCC_ETHER_RX_BD_F  | SCC_ETHER_RX_BD_L))
  1083.                       && !(pRxBd->statusMode & (SCC_ETHER_RX_BD_CL |
  1084.                    SCC_ETHER_RX_BD_OV | SCC_ETHER_RX_BD_CR |
  1085.    SCC_ETHER_RX_BD_SH | SCC_ETHER_RX_BD_NO |
  1086.    SCC_ETHER_RX_BD_LG)))
  1087.             cpmRecv (pDrvCtrl, pRxBd);
  1088.         else
  1089.             pDrvCtrl->idr.ac_if.if_ierrors++;
  1091.         /* reset buffer descriptor as empty */
  1093. if (pRxBd->statusMode & SCC_ETHER_RX_BD_W)
  1094.             pRxBd->statusMode = SCC_ETHER_RX_BD_E | SCC_ETHER_RX_BD_I |
  1095.                                 SCC_ETHER_RX_BD_W;
  1096.         else
  1097.             pRxBd->statusMode = SCC_ETHER_RX_BD_E | SCC_ETHER_RX_BD_I;
  1099.         /* incr BD count */
  1101.         pDrvCtrl->ether.rxBdNext = (pDrvCtrl->ether.rxBdNext + 1) %
  1102.     pDrvCtrl->ether.rxBdNum;
  1104.         pRxBd = & pDrvCtrl->ether.rxBdBase[pDrvCtrl->ether.rxBdNext];
  1106.         /* clear Rx events */
  1108.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_RXF;
  1109.         }
  1111.     /* re-enable Rx interrupts */
  1113.     pDrvCtrl->ether.pSccReg->sccm |= SCC_ETHER_SCCX_RXF;
  1114.     }
  1116. /*******************************************************************************
  1117. *
  1118. * cpmRecv - process an input frame
  1119. *
  1120. * This routine processes an input frame, then passes it up to the higher 
  1121. * level in a form it expects.  Buffer loaning, promiscuous mode, and
  1122. * etherInputHookRtns are all supported.  Trailer protocols is not supported.
  1123. *
  1124. * RETURNS: N/A
  1125. */
  1127. LOCAL void cpmRecv
  1128.     (
  1129.     DRV_CTRL * pDrvCtrl, /* pointer to DRV_CTRL structure */
  1130.     SCC_BUF * pRxBd /* receive buffer descriptor */
  1131.     )
  1132.     { 
  1133.     MBUF * pMbuf = NULL; /* MBUF pointer */
  1134.     UINT8 * pData;
  1135.     int length;
  1136. #ifdef BSD43_DRIVER
  1137.     UINT16 type;
  1138. #endif
  1139.     struct ether_header *  pEh; 
  1141.     /* bump input packet counter */
  1143.     pDrvCtrl->idr.ac_if.if_ipackets++;
  1145.     /* call hook if one is connected */
  1147.     if ((etherInputHookRtn != NULL) && ((*etherInputHookRtn)
  1148. (& pDrvCtrl->idr.ac_if, pRxBd->dataPointer, pRxBd->dataLength) != 0))
  1149.         return; 
  1151.     /* get Ethernet header */
  1153.     pEh = (struct ether_header *) pRxBd->dataPointer;
  1155.     /* filter frame if controller is in promiscuous mode - M bit is buggy */
  1157.     if (pDrvCtrl->ether.pSccReg->psmr & SCC_ETHER_PSMR_PRO)
  1158. {
  1159. if ((bcmp ( (char *) pEh->ether_dhost,
  1160.                     (char *) pDrvCtrl->idr.ac_enaddr, ENET_ADDR_SIZE)) &&
  1161.     (bcmp ((char *) pEh->ether_dhost,
  1162.      (char *) etherbroadcastaddr, ENET_ADDR_SIZE)))
  1163.            return;
  1164. }
  1166.     /* adjust length to data only */
  1168.     length = pRxBd->dataLength - SIZEOF_ETHERHEADER;
  1170.     if (length <= 0)
  1171. { 
  1172.         pDrvCtrl->idr.ac_if.if_ierrors++;
  1173. return;
  1174. }
  1176.     /* point to data */
  1178.     pData = ((char *)pEh) + SIZEOF_ETHERHEADER;
  1180. #ifdef BSD43_DRIVER
  1181.     /* save type - build_cluster trashes the type field */
  1183.     type = pEh->ether_type;
  1184. #endif
  1186.     /* OK to loan out buffer ? -> build a mbuf cluster */
  1188.     if ((pDrvCtrl->nLoanRxBd > 0) && (USE_CLUSTER (length)))
  1189. pMbuf = build_cluster (pData, length, & pDrvCtrl->idr, MC_CPM,
  1190.     pDrvCtrl->pRefCnt[(pDrvCtrl->nLoanRxBd - 1)], cpmLoanFree,
  1191.     (int) pDrvCtrl, (int) pEh,
  1192.             (int) pDrvCtrl->pRefCnt[(pDrvCtrl->nLoanRxBd - 1)]);
  1194.     /* if buffer was successfully turned into mbuf cluster */
  1196.     if (pMbuf != NULL)
  1197. pRxBd->dataPointer = pDrvCtrl->lPool[--pDrvCtrl->nLoanRxBd];
  1198.     else
  1199.         {
  1200. /* else do same ol' copy to mbuf */
  1202.         pMbuf = copy_to_mbufs (pData, length, 0, & pDrvCtrl->idr.ac_if);
  1204.         if (pMbuf == NULL)
  1205.     {
  1206.             pDrvCtrl->idr.ac_if.if_ierrors++;
  1207.             return;
  1208.     }
  1209.         }
  1211.     /* send up to protocol */
  1213. #ifdef BSD43_DRIVER
  1214.     do_protocol_with_type (type, pMbuf, & pDrvCtrl->idr, length);
  1215. #else
  1216.     do_protocol (pEh, pMbuf, & pDrvCtrl->idr, length);
  1217. #endif
  1218.     }
  1220. /*******************************************************************************
  1221. *
  1222. * cpmLoanFree - return the given buffer to loaner pool
  1223. *
  1224. * This routine returns <pRxBuf> to the pool of available loaner buffers.
  1225. * It also returns <pRef> to the pool of available loaner reference counters,
  1226. * then zeroes the reference count.
  1227. *
  1228. * RETURNS: N/A
  1229. */
  1231. LOCAL void cpmLoanFree
  1232.     (
  1233.     DRV_CTRL * pDrvCtrl,
  1234.     UINT8 * pRxBuf,
  1235.     UINT8 * pRef
  1236.     )
  1237.     {
  1238.     /* return loaned buffer to pool */
  1240.     pDrvCtrl->lPool[pDrvCtrl->nLoanRxBd] = pRxBuf;
  1242.     /* return loaned reference count to pool */
  1244.     pDrvCtrl->pRefCnt[pDrvCtrl->nLoanRxBd++] = pRef;
  1246.     /* reset reference count - should have been done from above, but... */
  1248.     *pRef = 0;
  1249.     }