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

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

VxWorks

开发平台：

C/C++

motCpmEnd.c：源码内容
  1. /* motCpmEnd.c - END style Motorola MC68EN360/MPC800 network interface driver */
  3. /* Copyright 1997-2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 02e,11apr02,rcs  increased clusters, mBlks, clBlks and ring size (SPR# 75471)
  10. 02d,01aug00,stv  allocated END_CTRL structure from heap (SPR# 32775).
  11. 02c,20jun00,stv  fixed the setting of maxd1 & maxd2 registers (SPR# 31197).  
  12. 02b,11jun00,ham  removed reference to etherLib.
  13. 02a,26may00,stv  fixed the packet data length in motCpmEndPollReceive() routine,
  14.  (SPR 31218).
  15. 01z,27jan00,dat  fixed use of NULL
  16. 01y,01dec99,stv  freed mBlk chain before returning ERROR (SPR #28492).
  17. 01x,29mar99,dat  SPR 26119, documentation, usage of .bS/.bE
  18. 01w,26nov98,dbt  removed splimp() and splx() calls in motCmpEndIoctl
  19.  (SPR #23528). Added a missing netMblkClChainFree() call.
  20. 01v,22sep98,dat  added Didier's fix for system-mode transitions. (SPR 22325)
  21.  removed warnings.
  22. 01u,09sep98,n_s  removed promiscous mode filter from motCpmEndPollReceive (). 
  23.                  spr 21143.
  24. 01t,28aug98,dat  chg'd all names from motCmp to motCpm.
  25. 01s,21aug98,n_s  removed promiscous mode filter from motCmpRecv (). spr 21143.
  26. 01r,30jun98,cn   changed include file motCmpEnd.h to motCpmEnd.h
  27. 01q,22jun98,cn   added support for PPC800-series Ethernet Controller.
  28. 01p,11dec97,kbw  making man page edits
  29. 01o,08dec97,gnn  END code review fixes.
  30. 01n,19oct97,vin  moved swapping of loaned buffer before END_RCV_RTN_CALL
  31. 01m,17oct97,vin  removed extra free.
  32. 01l,07oct97,vin  MTU size to ETHER_MTU.
  33. 01k,03oct97,gnn  fixed SPR 8988, memory leak
  34. 01j,25sep97,gnn  SENS beta feedback fixes
  35. 01i,24sep97,vin  added clBlk related calls
  36. 01h,03sep97,gnn  fixed a crashing bug under heavy load
  37. 01g,25aug97,gnn  changes due to new netPool routines.
  38. 01f,22aug97,gnn  changes due to new buffering scheme.
  39. 01e,12aug97,gnn  changes necessitated by MUX/END update.
  40. 01d,15may97,map  fixed intr event ack (scce) handling (SPR# 8580).
  41. 01c,18apr97,gnn  fixed a bug in the receive code.
  42. 01b,09apr97,gnn  updated buffer handling code to follow new MUX level
  43.                  requirements.
  44. 01a,15feb97,dbt  modified if_qu.c to END style.
  45. */
  47. /*
  48. This module implements the Motorola MC68EN360 QUICC as well as the MPC821 and
  49. MPC860 Power-QUICC Ethernet Enhanced network interface driver.
  51. All the above mentioned microprocessors feature a number of Serial 
  52. Communication Controllers (SCC) that support different serial protocols
  53. including IEEE 802.3 and Ethernet CSMA-CD. As a result, when the Ethernet
  54. mode of a SCC is selected, by properly programming its general Mode Register
  55. (GSMR), they can implement the full set of media access control and channel
  56. interface functions those protocol require. However, while the MC68EN360 
  57. QUICC and the MPC860 Power-QUICC support up to four SCCs per unit, the 
  58. MPC821 only includes two on-chip SCCs.
  60. This driver is designed to support the Ethernet mode of a SCC residing on the
  61. CPM processor core, no matter which among the MC68EN360 QUICC or any of the 
  62. PPC800 Series. In fact, the major differences among these processors, as far
  63. as the driver is concerned, are to be found in the mapping of the internal 
  64. Dual-Port RAM. The driver is generic in the sense that it does not care
  65. which SCC is being used. In addition, it poses no constraint on the number 
  66. of individual units that may be used per board. However, this number should
  67. be specified in the bsp through the macro MAX_SCC_CHANNELS. The default value
  68. for this macro in the driver is 4.
  70. To achieve these goals, the driver requires several target-specific values
  71. provided as an input string to the load routine. It also requires some 
  72. external support routines.  These target-specific values and the external 
  73. support routines are described below.
  75. This network interface driver does not include support for trailer protocols
  76. or data chaining.  However, buffer loaning has been implemented in an effort 
  77. to boost performance. 
  79. This driver maintains cache coherency by allocating buffer space using 
  80. the cacheDmaMalloc() routine.  This is provided for boards whose host
  81. processor use data cache space, e.g. the MPC800 Series. Altough the 
  82. MC68EN360 does not have cache memory, it may be used in a particular 
  83. configuration: 'MC68EN360 in 040 companion mode' where that is attached
  84. to processors that may cache memory. However, due to a lack of suitable 
  85. hardware, the multiple unit support and '040 companion mode support have 
  86. not been tested.
  88. BOARD LAYOUT
  89. This device is on-chip.  No jumpering diagram is necessary.
  91. EXTERNAL INTERFACE
  92. This driver provides the standard END external interface.  The only external 
  93. interface is the motCpmEndLoad() routine.  The parameters are passed 
  94. into the motCpmEndLoad() function as a single colon-delimited string.
  95. The motCpmEndLoad() function uses strtok() to parse the string, which it 
  96. expects to be of the following format:
  98. <unit>:<motCpmAddr>:<ivec>:<sccNum>:<txBdNum>:<rxBdNum>:
  99. <txBdBase>: <rxBdBase>:<bufBase> 
  101. TARGET-SPECIFIC PARAMETERS
  103. .IP <unit>
  104. A convenient holdover from the former model.  This parameter is used only
  105. in the string name for the driver.
  107. .IP <motCpmAddr>
  108. Indicates the address at which the host processor presents its internal 
  109. memory (also known as the dual ported RAM base address). With this address, 
  110. and the SCC number (see below), the driver is able to compute the location 
  111. of the SCC parameter RAM and the SCC register map, and, ultimately, to 
  112. program the SCC for proper operations. This parameter should point to the 
  113. internal memory of the processor where the SCC physically resides. This 
  114. location might not necessarily be the Dual-Port RAM of the microprocessor 
  115. configured as master on the target board.
  117. .IP <ivec>
  118. This driver configures the host processor to generate hardware interrupts
  119. for various events within the device. The interrupt-vector offset
  120. parameter is used to connect the driver's ISR to the interrupt through
  121. a call to the VxWorks system function intConnect().
  123. .IP <sccNum>
  124. This driver is written to support multiple individual device units.
  125. Thus, the multiple units supported by this driver can reside on different 
  126. chips or on different SCCs within a single host processor. This parameter 
  127. is used to explicitly state which SCC is being used (SCC1 is most commonly 
  128. used, thus this parameter most often equals "1").
  130. .IP "<txBdNum> and <rxBdNum>"
  131. Specify the number of transmit and receive buffer descriptors (BDs). 
  132. Each buffer descriptor resides in 8 bytes of the processor's dual-ported 
  133. RAM space, and each one points to a 1520 byte buffer in regular RAM.  
  134. There must be a minimum of two transmit and two receive BDs. There is 
  135. no maximum, although more than a certain amount does not speed up the 
  136. driver and wastes valuable dual-ported RAM space. If any of these parameters
  137. is "NULL", a default value of "32" BDs is used.
  139. .IP "<txBdBase> and <rxBdBase>"
  140. Indicate the base location of the transmit and receive buffer descriptors 
  141. (BDs). They are offsets, in bytes, from the base address of the host
  142. processor's internal memory (see above). Each BD takes up 8 bytes of
  143. dual-ported RAM, and it is the user's responsibility to ensure that all
  144. specified BDs fit within dual-ported RAM. This includes any other
  145. BDs the target board might be using, including other SCCs, SMCs, and the
  146. SPI device. There is no default for these parameters.  They must be
  147. provided by the user.
  149. .IP <bufBase> 
  150. Tells the driver that space for the transmit and receive buffers need not 
  151. be allocated but should be taken from a cache-coherent private memory space 
  152. provided by the user at the given address.  The user should be aware that 
  153. memory used for buffers must be 4-byte aligned and non-cacheable.  All the 
  154. buffers must fit in the given memory space.  No checking is performed.  
  155. This includes all transmit and receive buffers (see above).  Each buffer 
  156. is 1520 bytes.  If this parameter is "NONE", space for buffers is obtained 
  157. by calling cacheDmaMalloc() in motCpmEndLoad().
  158. .LP
  160. EXTERNAL SUPPORT REQUIREMENTS
  161. This driver requires three external support functions:
  162. .IP sysXxxEnetEnable()
  163. .LP
  164. This is either sys360EnetEnable() or sysCpmEnetEnable(), based on the 
  165. actual host processor being used. See below for the actual prototypes.
  166. This routine is expected to handle any target-specific functions needed 
  167. to enable the Ethernet controller. These functions typically include 
  168. enabling the Transmit Enable signal (TENA) and connecting the transmit 
  169. and receive clocks to the SCC. This routine is expected to return OK on 
  170. success, or ERROR. The driver calls this routine, once per unit, from the 
  171. motCpmEndLoad() routine.
  172. .IP sysXxxEnetDisable()
  173. .LP
  174. This is either sys360EnetDisable() or sysCpmEnetDisable(), based on the 
  175. actual host processor being used. See below for the actual prototypes.
  176. This routine is expected to handle any target-specific functions required 
  177. to disable the Ethernet controller. This usually involves disabling the 
  178. Transmit Enable (TENA) signal.  This routine is expected to return OK on 
  179. success, or ERROR. The driver calls this routine from the motCpmEndStop() 
  180. routine each time a unit is disabled.
  181. .IP sysXxxEnetAddrGet()
  182. .LP
  183. This is either sys360EnetAddrGet() or sysCpmEnetAddrGet(), based on the 
  184. actual host processor being used. See below for the actual prototypes.
  185. The driver expects this routine to provide the six-byte Ethernet hardware 
  186. address that is used by this unit.  This routine must copy the six-byte 
  187. address to the space provided by <addr>.  This routine is expected to 
  188. return OK on success, or ERROR.  The driver calls this routine, once per 
  189. unit, from the motCpmEndLoad() routine.
  190. .LP
  191. In the case of the CPU32, the prototypes of the above mentioned support
  192. routines are as follows:
  193. .CS
  194.     STATUS sys360EnetEnable (int unit, UINT32 regBase)
  195.     void sys360EnetDisable (int unit, UINT32 regBase)
  196.     STATUS sys360EnetAddrGet (int unit, u_char * addr)
  197. .CE
  198. .LP
  199. In the case of the PPC860, the prototypes of the above mentioned support
  200. routines are as follows:
  201. .CS
  202.     STATUS sysCpmEnetEnable (int unit)
  203.     void sysCpmEnetDisable (int unit)
  204.     STATUS sysCpmEnetAddrGet (int unit, UINT8 * addr)
  205. .CE
  206. .LP
  208. SYSTEM RESOURCE USAGE
  209. When implemented, this driver requires the following system resources:
  211.     - one mutual exclusion semaphore
  212.     - one interrupt vector
  213.     - 0 bytes in the initialized data section (data)
  214.     - 1272 bytes in the uninitialized data section (BSS)
  215.  
  216. The data and BSS sections are quoted for the CPU32 architecture and could
  217. vary for other architectures.  The code size (text) varies greatly between
  218. architectures, and is therefore not quoted here.
  220. If the driver allocates the memory to share with the Ethernet device unit,
  221. it does so by calling the cacheDmaMalloc() routine.  For the default case
  222. of 32 transmit buffers, 32 receive buffers, and 16 loaner buffers (this is not
  223. configurable), the total size requested is 121,600 bytes.  If a non-cacheable 
  224. memory region is provided by the user, the size of this region should be this 
  225. amount, unless the user has specified a different number of transmit or 
  226. receive BDs.
  228. This driver can operate only if this memory region is non-cacheable
  229. or if the hardware implements bus snooping.  The driver cannot maintain
  230. cache coherency for the device because the buffers are asynchronously
  231. modified by both the driver and the device, and these fields might share 
  232. the same cache line.  Additionally, the chip's dual-ported RAM must be
  233. declared as non-cacheable memory where applicable (for example, when attached
  234. to a 68040 processor). For more information, see the
  235. .I "Motorola MC68EN360 User's Manual",
  236. .I "Motorola MPC860 User's Manual",
  237. .I "Motorola MPC821 User's Manual"
  239. INTERNAL
  240. This driver contains conditional compilation switch DEBUG.
  241. If defined, adds debug output routines.  Output is further
  242. selectable at run-time via the motCpmDebug global variable.
  243. */
  245. /* includes */
  247. #include "vxWorks.h"
  248. #include "iv.h"
  249. #include "taskLib.h"
  250. #include "memLib.h"
  251. #include "ioctl.h"
  252. #include "net/mbuf.h"
  253. #include "net/protosw.h"
  254. #include "socket.h"
  255. #include "errno.h"
  256. #include "errnoLib.h"
  257. #include "net/unixLib.h"
  258. #include "net/route.h"
  259. #include "net/if_subr.h"
  260. #include "cacheLib.h"
  261. #include "stdio.h"
  262. #include "intLib.h"
  263. #include "logLib.h"
  264. #include "netLib.h"
  265. #include "iosLib.h"
  266. #include "drv/netif/netifDev.h"
  268. #include "drv/end/motCpmEnd.h"
  270. #include "net/if.h"
  271. #include "netinet/in.h"
  272. #include "netinet/in_systm.h"
  273. #include "netinet/in_var.h"
  274. #include "netinet/ip.h"
  275. #include "netinet/if_ether.h"
  276. #include "etherMultiLib.h"
  277. #include "end.h"
  278. #include "semLib.h"
  280. #undef END_MACROS
  282. #include "endLib.h"
  283. #include "lstLib.h"
  284. #include "netBufLib.h"
  286. /* defines */
  288. #define ENET_ADDR_SIZE 0x6 /* size of Ethernet src/dest addresses */
  289. #define TX_BD_MIN 2 /* minimum number of Tx buffer descriptors */
  290. #define TX_BD_MAX 128 /* maximum number of Tx buffer descriptors */
  291. #define RX_BD_MIN 2 /* minimum number of Rx buffer descriptors */
  292. #define TX_BD_DEFAULT 0x40 /* default number of Tx buffer descriptors */
  293. #define RX_BD_DEFAULT 0x40 /* default number of Rx buffer descriptors */
  294. #define FRAME_MAX 0x05ee /* maximum frame size */
  295. #define FRAME_MAX_AL 0x05f0 /* maximum frame size, 4 byte alligned */
  296. #define FRAME_MIN 0x0040 /* minimum frame size */
  297. #define LENGTH_MIN_FBUF 9 /* min. size of the first buffer in a frame */
  298. #define SPEED 10000000/* ethernet speed */
  299. #define L_POOL 0x80 /* number of Rx loaner buffers in pool */
  301. /* A shortcut for getting the hardware address from the MIB II stuff. */
  303. #define END_HADDR(pEnd) 
  304. ((pEnd)->mib2Tbl.ifPhysAddress.phyAddress)
  306. #define END_HADDR_LEN(pEnd) 
  307. ((pEnd)->mib2Tbl.ifPhysAddress.addrLength)
  309. #ifndef SYS_INT_CONNECT
  310. #define SYS_INT_CONNECT(pFunc, arg, pRet)                              
  311. {                                                                           
  312. *pRet = (intConnect) (INUM_TO_IVEC (pDrvCtrl->ivec),     
  313.       (pFunc), (int) (arg));                              
  314. }
  315. #endif /* SYS_INT_CONNECT */
  317. #define MOT_CPM_DEBUG /* debug support */
  319. int motCpmDebug = 0;
  321. #ifdef MOT_CPM_DEBUG
  322. #define MOTCPMLOGMSG(x) 
  323. if (motCpmDebug) 
  324.     { 
  325.     logMsg x; 
  326.     }
  327. #else
  328. #define MOTCPMLOGMSG(x)
  329. #endif /* MOT_CPM_DEBUG */
  331. /* typedefs */
  333. /* Ethernet header */
  335. typedef struct free_args
  336.     {
  337.     void* arg1;
  338.     void* arg2;
  339.     } FREE_ARGS;
  341. typedef struct end_ctrl /* END_CTRL */
  342.     {
  343.     END_OBJ endObject; /* base class */
  344.     UINT32 regBase; /* register/DPR base address */
  345.     SCC_ETHER_DEV ether; /* ETHERNET SCC device */
  346.     int txBdIndexC; /* current tx buffer descriptor index */
  347.     UINT32 bufBase; /* address of memory pool; */
  348. /* NONE = malloc it */
  349.     int unit; /* unit number */
  350.     int ivec; /* interrupt vector */
  351.     BOOL polling; /* polling mode */
  352.     BOOL txCleaning; /* cleaning queue */
  353.     u_char * txBuf; /* transmit buffer */
  354.     u_char * rxBuf; /* receive buffer */
  355.     u_char *            txPoolBuf;      /* pool send buffer */
  356.     BOOL txStop; /* emergency stop output */
  357.     FUNCPTR freeRtn[TX_BD_MAX]; /* Array of free routines. */
  358.     FREE_ARGS freeData[TX_BD_MAX]; /* Array of free arguments */
  359.     CL_POOL_ID   pClPoolId;      /* for the free routines. */
  360.     BOOL txBlocked; /* flag for implementing flow control */
  361.     } END_CTRL;
  363. typedef struct {
  364.     int unit; /* unit number */
  365.     UINT32  motCpmAddr; /* base address of processor internal mem */
  366.     int ivec; /* interrupt vector */
  367.     int sccNum; /* Serial Communication Controler number */
  368.     int txBdNum; /* number of transmit buffer descriptors */
  369.     int rxBdNum; /* number of receive buffer descriptors */
  370.     UINT32 txBdBase; /* transmit buffer descriptor offset */
  371.     UINT32 rxBdBase; /* receive buffer descriptor offset */
  372.     UINT32 bufBase; /* address of memory pool; NONE = malloc it */
  373.     } END_PARM;
  375. /* globals */
  377. /* locals */
  379. M_CL_CONFIG motMclBlkConfig =  /* network mbuf configuration table */
  380.     {
  381.     /* 
  382.     no. mBlks no. clBlks memArea memSize
  383.     ----------- ---------- ------- -------
  384.     */
  385.     0,  0,  NULL,  0
  386.     };
  388. CL_DESC motClDescTbl [] =  /* network cluster pool configuration table */
  389.     {
  390.     /* 
  391.     clusterSize num memArea memSize
  392.     ----------- ---- ------- -------
  393.     */
  394.     {FRAME_MAX_AL, 0, NULL, 0}
  395.     }; 
  397. int motClDescTblNumEnt = (NELEMENTS(motClDescTbl));
  399. NET_POOL motCpmNetPool;
  401. /* forward declarations */
  403. #ifdef __STDC__
  405. LOCAL STATUS    motCpmInitParse (END_PARM *pEndParm, char *initString);
  406. LOCAL STATUS    motCpmInitMem (END_CTRL *pDrvCtrl);
  407. LOCAL void motCpmRecv (END_CTRL *pDrvCtrl, SCC_BUF * pRxBd);
  408. LOCAL void      motCpmIntr (END_CTRL *pDrvCtrl);
  409. LOCAL void  motCpmReset (END_CTRL * pDrvCtrl);
  410. LOCAL void  motCpmMCastFilterSet (END_CTRL * pDrvCtrl, char * pAddress);
  411. LOCAL void  motCpmMCastConfig (END_CTRL * pDrvCtrl);
  412. LOCAL void  motCpmTxRestart (END_CTRL * pDrvCtrl);
  413. LOCAL void  motCpmHandleInt (END_CTRL * pDrvCtrl);
  414. LOCAL void  motCpmCleanTxBdQueue (END_CTRL * pDrvCtrl);
  415. LOCAL STATUS  motCpmRestart (END_CTRL * pDrvCtrl);
  416. LOCAL void motCpmCleanRxBd (END_CTRL * pDrvCtrl, SCC_BUF * pRxBd);
  419. /* END Specific interfaces. */
  421. END_OBJ *       motCpmEndLoad (char *initString);
  422. LOCAL STATUS    motCpmEndStart(END_CTRL *pDrvCtrl);
  423. LOCAL int       motCpmEndIoctl (END_CTRL *pDrvCtrl, int cmd, caddr_t data);
  424. LOCAL STATUS    motCpmEndSend (END_CTRL *pDrvCtrl, M_BLK_ID pBuf);
  425. LOCAL STATUS    motCpmEndMCastAddrAdd (END_CTRL *pDrvCtrl, char* pAddress);
  426. LOCAL STATUS    motCpmEndMCastAddrDel (END_CTRL *pDrvCtrl, char* pAddress);
  427. LOCAL STATUS    motCpmEndMCastAddrGet (END_CTRL *pDrvCtrl,
  428. MULTI_TABLE *pTable);
  429. LOCAL STATUS    motCpmEndPollSend (END_CTRL *pDrvCtrl, M_BLK_ID pBuf);
  430. LOCAL STATUS    motCpmEndPollReceive (END_CTRL *pDrvCtrl, M_BLK_ID pBuf);
  431. LOCAL STATUS    motCpmEndPollStart (END_CTRL *pDrvCtrl);
  432. LOCAL STATUS    motCpmEndPollStop (END_CTRL *pDrvCtrl);
  433. LOCAL STATUS  motCpmEndUnload (END_CTRL *pDrvCtrl);
  434. LOCAL STATUS  motCpmEndStop (END_CTRL *pDrvCtrl);
  436. #else  /* __STDC__ */
  438. LOCAL STATUS    motCpmInitParse ();
  439. LOCAL STATUS    motCpmInitMem ();
  440. LOCAL void motCpmRecv ();
  441. LOCAL void      motCpmIntr ();
  442. LOCAL void  motCpmReset ();
  443. LOCAL void  motCpmMCastFilterSet ();
  444. LOCAL void  motCpmMCastConfig ();
  445. LOCAL void  motCpmTxRestart ();
  446. LOCAL void  motCpmHandleInt ();
  447. LOCAL void  motCpmCleanTxBdQueue ();
  448. LOCAL STATUS  motCpmRestart ();
  449. LOCAL void motCpmCleanRxBd ();
  451. /* END Specific interfaces. */
  453. END_OBJ *       motCpmEndLoad ();
  454. LOCAL STATUS    motCpmEndStart ();
  455. LOCAL int       motCpmEndIoctl ();
  456. LOCAL STATUS    motCpmEndSend ();
  457. LOCAL STATUS    motCpmEndMCastAddrAdd ();
  458. LOCAL STATUS    motCpmEndMCastAddrDel ();
  459. LOCAL STATUS    motCpmEndMCastAddrGet ();
  460. LOCAL STATUS    motCpmEndPollSend ();
  461. LOCAL STATUS    motCpmEndPollReceive ();
  462. LOCAL STATUS    motCpmEndPollStart ();
  463. LOCAL STATUS    motCpmEndPollStop ();
  464. LOCAL STATUS  motCpmEndUnload ();
  465. LOCAL STATUS  motCpmEndStop ();
  467. #endif  /* __STDC__ */
  469. /*
  470.  * Define the device function table.  This is static across all driver
  471.  * instances.
  472.  */
  474. LOCAL NET_FUNCS netFuncs =
  475.     {
  476.     (FUNCPTR)motCpmEndStart, /* start func. */
  477.     (FUNCPTR)motCpmEndStop, /* stop func. */
  478.     (FUNCPTR)motCpmEndUnload, /* unload func. */
  479.     (FUNCPTR)motCpmEndIoctl, /* ioctl func. */
  480.     (FUNCPTR)motCpmEndSend, /* send func. */
  481.     (FUNCPTR)motCpmEndMCastAddrAdd, /* multicast add func. */
  482.     (FUNCPTR)motCpmEndMCastAddrDel, /* multicast delete func. */
  483.     (FUNCPTR)motCpmEndMCastAddrGet, /* multicast get fun. */
  484.     (FUNCPTR)motCpmEndPollSend, /* polling send func. */
  485.     (FUNCPTR)motCpmEndPollReceive, /* polling receive func.  */
  486.     endEtherAddressForm,           /* Put address info into a packet.  */
  487.     endEtherPacketDataGet,         /* Get a pointer to packet data. */
  488.     endEtherPacketAddrGet          /* Get packet addresses. */
  489.     };
  491. /*******************************************************************************
  492. *
  493. * motCpmEndLoad - initialize the driver and device
  494. *
  495. * This routine initializes the driver and the device to the operational state.
  496. * All of the device specific parameters are passed in the <initString>, which
  497. * is of the following format:
  498. *
  499. * <unit>:<motCpmAddr>:<ivec>:<sccNum>:<txBdNum>:<rxBdNum>:<txBdBase>:<rxBdBase>:<bufBase> 
  500. * 
  501. * The parameters of this string are individually described in the 'motCpmEnd' 
  502. * man page.
  503. *
  504. * The SCC shares a region of memory with the driver.  The caller of 
  505. * this routine can specify the address of a non-cacheable memory region with
  506. * <bufBase>.  Or, if this parameter is "NONE", the driver obtains this
  507. * memory region by making calls to cacheDmaMalloc().  Non-cacheable memory 
  508. * space is important whenever the host processor uses cache memory.
  509. * This is also the case when the MC68EN360 is operating in companion
  510. * mode and is attached to a processor with cache memory.
  511. *
  512. * After non-cacheable memory is obtained, this routine divides up the
  513. * memory between the various buffer descriptors (BDs).  The number
  514. * of BDs can be specified by <txBdNum> and <rxBdNum>, or if "NULL", a
  515. * default value of 32 BDs will be used.  An additional number of buffers are
  516. * reserved as receive loaner buffers.  The number of loaner buffers is
  517. * a default number of 16.
  518. *
  519. * The user must specify the location of the transmit and receive BDs in
  520. * the processor's dual ported RAM.  <txBdBase> and <rxBdBase> give the
  521. * offsets from <motCpmAddr> for the base of the BD rings.  Each BD uses 
  522. * 8 bytes. Care must be taken so that the specified locations for Ethernet 
  523. * BDs do not conflict with other dual ported RAM structures.
  524. *
  525. * Multiple individual device units are supported by this driver.  Device
  526. * units can reside on different chips, or could be on different SCCs
  527. * within a single processor. The <sccNum> parameter is used to explicitly
  528. * state which SCC is being used. SCC1 is most commonly used, thus this
  529. * parameter most often equals "1".
  530. *
  531. * Before this routine returns, it connects up the interrupt vector <ivec>.
  532. *
  533. * RETURNS: An END object pointer or NULL on error.
  534. *
  535. * SEE ALSO:
  536. * .I "Motorola MC68EN360 User's Manual",
  537. * .I "Motorola MPC860 User's Manual",
  538. * .I "Motorola MPC821 User's Manual"
  539. */
  541. END_OBJ *motCpmEndLoad
  542.     (
  543.     char *      initString      /* parameter string */
  544.     )
  545.     {
  546.     END_PARM    endParm;        /* parameters from initString */
  547.     END_CTRL    *pDrvCtrl; /* pointer to END_CTRL structure */
  548.     int         scc;
  549.     UINT32 motCpmAddr;
  550.     u_char enetAddr[ENET_ADDR_SIZE];
  551.     int         retVal;
  553.     MOTCPMLOGMSG(("motCpmEndLoad n", 0, 0, 0, 0, 0, 0));
  555.     if (initString == NULL)
  556.         return (NULL);
  557.     
  558.     if (initString[0] == 0)
  559.         {
  560.         bcopy((char *)MOT_DEV_NAME, initString, MOT_DEV_NAME_LEN);
  561.         return (0);
  562.         }
  564.     /* Parse InitString */
  566.     if (motCpmInitParse (&endParm, initString) == ERROR)
  567. return (NULL);
  569.     /* Sanity check -- unit number */
  571.     if (endParm.unit < 0 || endParm.unit >= MAX_SCC_CHANNELS)
  572. return (NULL);
  574.     /* Sanity check -- scc number */
  576.     if ((endParm.sccNum < 1) || (endParm.sccNum > 4))
  577. return (NULL);
  579.     if (endParm.txBdBase == endParm.rxBdBase)
  580. return (NULL);
  582.     /* allocate the device structure */
  584.     pDrvCtrl = (END_CTRL *)calloc (sizeof(END_CTRL), 1);
  586.     if (pDrvCtrl == NULL)
  587. {
  588. MOTCPMLOGMSG(("motCpmEndLoad : Failed to allocate control structuren", 
  589.        0, 0, 0, 0, 0, 0));
  590. return (NULL);
  591. }
  593.     /* Check if we are already attached */
  595.     if (pDrvCtrl->endObject.attached == TRUE)
  596. return (&pDrvCtrl->endObject);
  598.     /* use default number of buffer descriptors if user did not specify */
  600.     if (endParm.txBdNum == 0)
  601. endParm.txBdNum = TX_BD_DEFAULT;
  602.     if (endParm.rxBdNum == 0)
  603.      endParm.rxBdNum = RX_BD_DEFAULT;
  605.     /* must be at least two transmit and receive buffer descriptors */
  607.     endParm.txBdNum = max (TX_BD_MIN, endParm.txBdNum);
  608.     endParm.rxBdNum = max (RX_BD_MIN, endParm.rxBdNum);
  610.     /* Initialize parameters */
  612.     pDrvCtrl->regBase = endParm.motCpmAddr;
  613.     pDrvCtrl->bufBase = endParm.bufBase;
  614.     pDrvCtrl->unit = endParm.unit;
  615.     pDrvCtrl->ivec = endParm.ivec;
  616.     pDrvCtrl->ether.sccNum = endParm.sccNum;
  617.     pDrvCtrl->ether.txBdNum = endParm.txBdNum;
  618.     pDrvCtrl->ether.rxBdNum = endParm.rxBdNum;
  619.     pDrvCtrl->ether.txBdBase = (SCC_BUF *) (endParm.motCpmAddr + 
  620. (endParm.txBdBase & 0xffff));
  621.     pDrvCtrl->ether.rxBdBase = (SCC_BUF *) (endParm.motCpmAddr + 
  622. (endParm.rxBdBase & 0xffff));
  623.     pDrvCtrl->ether.txBufSize = FRAME_MAX_AL;
  624.     pDrvCtrl->ether.rxBufSize = FRAME_MAX_AL;
  625.     pDrvCtrl->txBdIndexC = 0;
  627.     /* derive SCC dependent variables */
  629.     scc = pDrvCtrl->ether.sccNum - 1;
  631.     motCpmAddr = pDrvCtrl->regBase;
  633.     pDrvCtrl->ether.pScc    = (SCC *) ((UINT32) CPM_DPR_SCC1(motCpmAddr) +
  634.        (scc * 0x100));
  635.     pDrvCtrl->ether.pSccReg = (SCC_REG *) 
  636. ((UINT32) CPM_GSMR_L1(motCpmAddr) + (
  637.  scc * 0x20));
  638.     pDrvCtrl->ether.intMask = CPM_CIMR_SCC4 << (3 - scc);
  640.     /* endObject initializations */
  642.     if (END_OBJ_INIT (&pDrvCtrl->endObject, (void *)pDrvCtrl, MOT_DEV_NAME,
  643.                       pDrvCtrl->unit, &netFuncs,
  644.                       END_OBJ_STRING) == ERROR)
  645. return (NULL);
  647.     /* memory initialization */
  649.     if (motCpmInitMem (pDrvCtrl) == ERROR)
  650. return (NULL);
  652.     /* reset the chip */
  654.     motCpmReset (pDrvCtrl);
  656.     /* connect the interrupt handler motCpmIntr() */
  658.     SYS_INT_CONNECT ((VOIDFUNCPTR) motCpmIntr, 
  659.      (int) pDrvCtrl, &retVal);
  660.     if (retVal == ERROR)
  661.         return (NULL);
  662.  
  663.     /* Get our enet addr */
  665.     SYS_ENET_ADDR_GET (enetAddr);
  667.     MOTCPMLOGMSG(("motCpmEndLoad ADDR: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x n", 
  668. (int) enetAddr[0], (int) enetAddr[1], (int) enetAddr[2], 
  669. (int) enetAddr[3], (int) enetAddr[4], (int) enetAddr[5]));
  671.     /* Initialize MIB2 entries */
  673.     if (END_MIB_INIT (&pDrvCtrl->endObject, M2_ifType_ethernet_csmacd,
  674.                       enetAddr, 6, ETHERMTU,
  675. SPEED) == ERROR)
  676. return (NULL);
  678.     /* Mark the device ready */
  679.     /* IFF_SCAT is not defined by default */
  681.     END_OBJ_READY (&pDrvCtrl->endObject,
  682.  IFF_NOTRAILERS | IFF_BROADCAST | IFF_MULTICAST);
  684.     /* Successful return */
  686.     return (&pDrvCtrl->endObject);
  687.     }
  689. /*******************************************************************************
  690. *
  691. * motCpmInitParse - parse parameter values from initString
  692. *
  693. * Parse the input string.  Fill in values in the driver control structure.
  694. *
  695. * The initialization string format is:
  696. * .CS
  697. *    "unit:motCpmAddr:ivec:sccNum:txBdNum:rxBdNum:txBdBase:rxBdBase:bufBase"
  698. * .CE
  699. *
  700. * .IP <unit>
  701. * Device unit number, a small integer.
  702. * .IP <motCpmAddr>
  703. * base address of processor internal mem 
  704. * .IP <ivec>
  705. * Interrupt vector number
  706. * .IP <sccNum>
  707. * SCC number used.
  708. * .IP <txBdNum>
  709. * number of transmit buffer descriptors; NULL = default
  710. * .IP <rxBdNum>
  711. * number of receive buffer descriptors; NULL = default
  712. * .IP <txBdBase>
  713. * transmit buffer descriptor offset
  714. * .IP <rxBdBase>
  715. * receive buffer descriptor offset
  716. * .IP <bufBase>
  717. * address of memory pool; NONE = malloc it
  718. * .LP
  719. *
  720. * RETURNS: OK or ERROR for invalid arguments.
  721. */
  723. LOCAL STATUS motCpmInitParse
  724.     (
  725.     END_PARM    *pEndParm, /* structure to fill in with parameters */
  726.     char        *initString /* init string */
  727.     )
  728.     {
  729.     char *      tok;            /* an initString token */
  730.     char * holder=NULL;    /* points to initString fragment beyond tok */
  731.     char *  initStringBuff;
  733.     initStringBuff = malloc(strlen(initString) + 1);
  734.     if (initStringBuff == NULL)
  735.         return (ERROR);
  737.     strcpy (initStringBuff, initString);
  739.     tok = strtok_r(initStringBuff, ":", &holder);
  740.     if (tok == NULL)
  741.         {
  742.         free(initStringBuff);
  743. return ERROR;
  744.         }
  745.     pEndParm->unit = atoi(tok);
  747.     tok = strtok_r(NULL, ":", &holder);
  748.     if (tok == NULL)
  749.         {
  750.         free(initStringBuff);
  751. return ERROR;
  752.         }
  753.     pEndParm->motCpmAddr = strtoul (tok, NULL, 16);
  755.     tok = strtok_r(NULL, ":", &holder);
  756.     if (tok == NULL)
  757.         {
  758.         free(initStringBuff);
  759. return ERROR;
  760.         }
  761.     pEndParm->ivec = strtoul (tok, NULL, 16);
  763.     tok = strtok_r(NULL, ":", &holder);
  764.     if (tok == NULL)
  765.         {
  766.         free(initStringBuff);
  767. return ERROR;
  768.         }
  769.     pEndParm->sccNum = atoi (tok);
  771.     tok = strtok_r(NULL, ":", &holder);
  772.     if (tok == NULL)
  773.         {
  774.         free(initStringBuff);
  775. return ERROR;
  776.         }
  777.     pEndParm->txBdNum = strtoul (tok, NULL, 16);
  779.     tok = strtok_r(NULL, ":", &holder);
  780.     if (tok == NULL)
  781.         {
  782.         free(initStringBuff);
  783. return ERROR;
  784.         }
  785.     pEndParm->rxBdNum = strtoul (tok, NULL, 16);
  787.     tok = strtok_r(NULL, ":", &holder);
  788.     if (tok == NULL)
  789.         {
  790.         free(initStringBuff);
  791. return ERROR;
  792.         }
  793.     pEndParm->txBdBase = strtoul (tok, NULL, 16);
  795.     tok = strtok_r(NULL, ":", &holder);
  796.     if (tok == NULL)
  797.         {
  798.         free(initStringBuff);
  799. return ERROR;
  800.         }
  801.     pEndParm->rxBdBase = strtoul (tok, NULL, 16);
  803.     tok = strtok_r(NULL, ":", &holder);
  804.     if (tok == NULL)
  805.         {
  806.         free(initStringBuff);
  807. return ERROR;
  808.         }
  809.     pEndParm->bufBase = strtoul (tok, NULL, 16);
  811.     MOTCPMLOGMSG(("unit = %d, motCpmAddr = 0x%x, ivec = 0x%x, sccNum = 0x%xn",
  812. pEndParm->unit, pEndParm->motCpmAddr, pEndParm->ivec, 
  813. pEndParm->sccNum, 0, 0));
  814.     MOTCPMLOGMSG(("txBdNum = 0x%x, rxBdNum = 0x%x, txBdBase = 0x%xn",
  815. pEndParm->txBdNum, pEndParm->rxBdNum, pEndParm->txBdBase, 
  816. 0, 0, 0));
  817.     MOTCPMLOGMSG(("rxBdBase  = 0x%x, bufBase = %dn", pEndParm->rxBdBase, 
  818. pEndParm->bufBase, 0, 0, 0, 0));
  820.     free(initStringBuff);
  821.     return OK;
  822.     }
  824. /*******************************************************************************
  825. *
  826. * motCpmInitMem - initialize memory 
  827. *
  828. * Using data in the control structure, setup and initialize the memory
  829. * areas needed.  If the memory address is not already specified, then allocate
  830. * cache safe memory.
  831. *
  832. * RETURNS: OK or ERROR.
  833. *
  834. */
  836. LOCAL STATUS motCpmInitMem
  837.     (
  838.     END_CTRL * pDrvCtrl /* pointer to END_CTRL structure */
  839.     )
  840.     {
  841.     int counter;
  842.     FUNCPTR  allocFunc;
  843.     void * pData;
  844.     char* pTmpBuf;
  845.     int numBuf;
  847.     /* Set up the structures to allow us to free data after sending it. */
  849.     for (counter = 0; counter < pDrvCtrl->ether.txBdNum; counter++)
  850. {
  851. pDrvCtrl->freeRtn[counter] = NULL;
  852. pDrvCtrl->freeData[counter].arg1 = NULL;
  853. pDrvCtrl->freeData[counter].arg2 = NULL;
  854. }
  856.     if (pDrvCtrl->bufBase == NONE)
  857. {
  858. /* We must allocate memory for buffer descriptors */
  860. pData = NULL;
  861. allocFunc = (FUNCPTR) cacheDmaMalloc;
  862. }
  863.     else
  864. {
  865. /* Memory for buffer descriptors is already allocated */
  867. pData = (void *) pDrvCtrl->bufBase;
  868. allocFunc = NULL;
  869. }
  871.     /* 
  872.      * calculate the number of buffers we need :
  873.      * receive buffers + transmit buffers + loaner buffers (= L_POOL)
  874.      */
  876.     numBuf = pDrvCtrl->ether.rxBdNum + pDrvCtrl->ether.txBdNum + L_POOL;
  878.     /* Use the MUX's memory manager to get our buffers. */
  880.     pDrvCtrl->endObject.pNetPool = &motCpmNetPool;
  882.     motClDescTbl[0].clNum  = numBuf;
  883.     motClDescTbl[0].memSize  = (numBuf * (FRAME_MAX_AL + sizeof (long)));
  885.     motMclBlkConfig.mBlkNum  = 5 * numBuf;
  886.     motMclBlkConfig.clBlkNum  = 5 * numBuf;
  887.     motMclBlkConfig.memSize  = ((motMclBlkConfig.mBlkNum *
  888.                                     (MSIZE + sizeof (long))) +
  889.                                    (motMclBlkConfig.clBlkNum *
  890.                                     (CL_BLK_SZ + sizeof (long))));
  892.     if ((motMclBlkConfig.memArea = (char *) memalign (sizeof (long),
  893.                                                       motMclBlkConfig.memSize))
  894.         == NULL)
  895.         return (ERROR);
  897.     motClDescTbl[0].memArea = (char *) cacheDmaMalloc(motClDescTbl[0].memSize);
  898.     if (motClDescTbl[0].memArea == NULL)
  899.         {
  900.         MOTCPMLOGMSG (( "system memory unavailablen", 1, 2, 3, 4, 5, 6));
  901.         return (ERROR);
  902.         }
  904.     if (netPoolInit(pDrvCtrl->endObject.pNetPool, &motMclBlkConfig,
  905.                     &motClDescTbl[0], motClDescTblNumEnt, NULL) == ERROR)
  906.                     
  907.         {
  908.         MOTCPMLOGMSG(("Could not init bufferingn", 1, 2, 3, 4, 5, 6));
  909.         return (ERROR);
  910.         }
  911.     /* Store the cluster pool id as others need it later. */
  912.     pDrvCtrl->pClPoolId = clPoolIdGet(pDrvCtrl->endObject.pNetPool,
  913.                                       FRAME_MAX_AL, FALSE);
  914.     for (counter = 0; counter < pDrvCtrl->ether.rxBdNum; counter++)
  915. {
  916.         if ((pTmpBuf = (char *)netClusterGet(pDrvCtrl->endObject.pNetPool,
  917.                                              pDrvCtrl->pClPoolId)) == NULL)
  918.             {
  919.             return (ERROR);
  920.             }
  922.         pDrvCtrl->ether.rxBdBase[counter].dataPointer = (u_char *) pTmpBuf;
  923. }
  924.    
  925.     pDrvCtrl->txPoolBuf = netClusterGet (pDrvCtrl->endObject.pNetPool, 
  926.                                          pDrvCtrl->pClPoolId);
  928.  
  929.     return (OK);
  930.     }
  932. /*******************************************************************************
  933. *
  934. * motCpmEndStart - start the device 
  935. *
  936. * This function initializes the device and calls BSP functions to connect
  937. * interrupts and start the device running in interrupt mode.
  938. *
  939. * The complement of this routine is motCpmEndStop().  Once a unit is reset by
  940. * motCpmEndStop(), it may be re-initialized to a running state by this routine.
  941. * 
  942. * RETURNS: OK if successful, otherwise ERROR.
  943. */
  945. LOCAL STATUS motCpmEndStart
  946.     (
  947.     END_CTRL * pDrvCtrl /* pointer to END_CTRL structure */
  948.     )
  949.     {
  950.     int counter;
  951.     u_char * enetAddr;
  952.     ETHER_MULTI * pCurr;
  954.     MOTCPMLOGMSG(("motCpmEndStart n", 0, 0, 0, 0, 0, 0));
  956.     /* initialize flag(s) */
  958.     pDrvCtrl->polling = FALSE;
  959.     pDrvCtrl->txStop = FALSE;
  960.     pDrvCtrl->txCleaning = FALSE;
  961.     pDrvCtrl->txBlocked = FALSE;
  963.     /* set up transmit buffer descriptors */
  965.     pDrvCtrl->ether.pScc->param.tbase = (UINT16)
  966. ((UINT32) pDrvCtrl->ether.txBdBase & 0xffff);
  967.     pDrvCtrl->ether.pScc->param.tbptr = (UINT16)
  968. ((UINT32) pDrvCtrl->ether.txBdBase & 0xffff);
  970.     pDrvCtrl->ether.txBdNext  = 0;
  972.     /* initialize each transmit buffer descriptor */
  973.      
  974.     for (counter = 0; counter < pDrvCtrl->ether.txBdNum; counter++)
  975.         pDrvCtrl->ether.txBdBase[counter].statusMode = SCC_ETHER_TX_BD_I |
  976.                                                        SCC_ETHER_TX_BD_PAD |
  977.                                                        SCC_ETHER_TX_BD_L |
  978.                                                        SCC_ETHER_TX_BD_TC;
  980.     /* set the last BD to wrap to the first */
  982.     pDrvCtrl->ether.txBdBase[(counter - 1)].statusMode |= SCC_ETHER_TX_BD_W;
  984.     /* set up receive buffer descriptors */
  986.     pDrvCtrl->ether.pScc->param.rbase = (UINT16)
  987. ((UINT32) pDrvCtrl->ether.rxBdBase & 0xffff);
  988.     pDrvCtrl->ether.pScc->param.rbptr = (UINT16)
  989. ((UINT32) pDrvCtrl->ether.rxBdBase & 0xffff);
  991.     pDrvCtrl->ether.rxBdNext  = 0;
  993.     /* initialize each receive buffer descriptor */
  995.     for (counter = 0; counter < pDrvCtrl->ether.rxBdNum; counter++)
  996.         pDrvCtrl->ether.rxBdBase[counter].statusMode = SCC_ETHER_RX_BD_I |
  997.                 SCC_ETHER_RX_BD_E;
  999.     /* set the last BD to wrap to the first */
  1001.     pDrvCtrl->ether.rxBdBase[(counter - 1)].statusMode |= SCC_ETHER_RX_BD_W;
  1003.     /* set SCC attributes to Ethernet mode */
  1004.  
  1005.     pDrvCtrl->ether.pSccReg->gsmrl    = SCC_GSMRL_ETHERNET | SCC_GSMRL_TPP_10 |
  1006.                                         SCC_GSMRL_TPL_48   | SCC_GSMRL_TCI;
  1007.     pDrvCtrl->ether.pSccReg->gsmrh    = 0x0;
  1009.     pDrvCtrl->ether.pSccReg->psmr     = SCC_ETHER_PSMR_CRC |
  1010. SCC_ETHER_PSMR_NIB_22;
  1012.     if (END_FLAGS_GET(&pDrvCtrl->endObject) & IFF_PROMISC)
  1013.         pDrvCtrl->ether.pSccReg->psmr |= SCC_ETHER_PSMR_PRO;
  1014.  
  1015.     pDrvCtrl->ether.pSccReg->dsr      = 0xd555;
  1016.     pDrvCtrl->ether.pScc->param.rfcr  = 0x18;      /* supervisor data access */
  1017.     pDrvCtrl->ether.pScc->param.tfcr  = 0x18;      /* supervisor data access */
  1018.     pDrvCtrl->ether.pScc->param.mrblr = FRAME_MAX_AL;  /* max rx buffer size */
  1020.     /* initialize parameter the SCC RAM */
  1021.  
  1022.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->c_pres = 0xffffffff;
  1023.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->c_mask = 0xdebb20e3;
  1024.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->crcec = 0x00000000;
  1025.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->alec = 0x00000000;
  1026.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->disfc = 0x00000000;
  1027.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->pads = 0x8888;
  1028.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->ret_lim = 0x000f;
  1029.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->mflr = FRAME_MAX;
  1030.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->minflr = FRAME_MIN;
  1031.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->maxd1 = FRAME_MAX_AL;
  1032.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->maxd2 = FRAME_MAX_AL;
  1033.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr1 = 0x0000;
  1034.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr2 = 0x0000;
  1035.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr3 = 0x0000;
  1036.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr4 = 0x0000;
  1037.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->p_per = 0x0000;
  1038.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->iaddr1 = 0x0000;
  1039.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->iaddr2 = 0x0000;
  1040.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->iaddr3 = 0x0000;
  1041.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->iaddr4 = 0x0000;
  1042.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->taddr_h = 0x0000;
  1043.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->taddr_m = 0x0000;
  1044.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->taddr_l = 0x0000;
  1046.     /* set the hardware Ethernet address of the board */
  1048.     enetAddr = END_HADDR(&pDrvCtrl->endObject);
  1050.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->paddr1_h =
  1051.         (enetAddr[5] << 8) + enetAddr[4];
  1052.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->paddr1_m =
  1053.         (enetAddr[3] << 8) + enetAddr[2];
  1054.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->paddr1_l =
  1055.         (enetAddr[1] << 8) + enetAddr[0];
  1057.     /* Set the multicast addresses */
  1059.     for (pCurr = END_MULTI_LST_FIRST(&pDrvCtrl->endObject); pCurr != NULL;
  1060. pCurr = (ETHER_MULTI *)lstNext(&pCurr->node))
  1061. {
  1062. /* add multicast address */
  1064. motCpmMCastFilterSet (pDrvCtrl, pCurr->addr);
  1065. }
  1067.     /* enable Ethernet interrupts */
  1069.     pDrvCtrl->ether.pSccReg->scce = 0xffff; /* clr events */
  1071.     /* allow receive and transmit errors interrupts */
  1073.     pDrvCtrl->ether.pSccReg->sccm = SCC_ETHER_SCCX_RXF | SCC_ETHER_SCCX_TXE |
  1074.     SCC_ETHER_SCCX_TXB;
  1076.     *CPM_CIMR(pDrvCtrl->regBase) |= pDrvCtrl->ether.intMask;
  1078.     /* call the BSP to do any other initialization (e.g., connecting clocks) */
  1080.     SYS_ENET_ENABLE;
  1082.     /* raise the interface flags - mark the device as up */
  1084.     END_FLAGS_SET (&pDrvCtrl->endObject, IFF_UP | IFF_RUNNING);
  1086.     /* enable the transmitter */
  1088.     pDrvCtrl->ether.pSccReg->gsmrl |= SCC_GSMRL_ENT;
  1090.     /* issue the restart transmitter command to the CP */
  1092.     while (*CPM_CPCR(pDrvCtrl->regBase) & CPM_CR_FLG);
  1093.     *CPM_CPCR(pDrvCtrl->regBase) = ((pDrvCtrl->ether.sccNum - 1) << 6) |
  1094.                                       CPM_CR_SCC_RESTART | CPM_CR_FLG;
  1095.     while (*CPM_CPCR(pDrvCtrl->regBase) & CPM_CR_FLG);
  1097.     /* enable the receiver */
  1099.     pDrvCtrl->ether.pSccReg->gsmrl |= SCC_GSMRL_ENR;
  1101.     return (OK);
  1102.     }
  1104. /*******************************************************************************
  1105. *
  1106. * motCpmEndStop - stop the device 
  1107. *
  1108. * This routine marks the interface as down and resets the device.  This
  1109. * includes disabling interrupts, stopping the transmitter and receiver,
  1110. * and calling the bsp-specific LAN disable routine to do any target 
  1111. * specific disabling.
  1112. *
  1113. * The complement of this routine is motCpmEndStart().  Once a unit is 
  1114. * stop in this routine, it may be re-initialized to a running state by 
  1115. * motCpmEndStart().
  1116. *
  1117. * RETURNS: OK or ERROR.
  1118. */
  1120. LOCAL STATUS motCpmEndStop
  1121.     (
  1122.     END_CTRL * pDrvCtrl /* pointer to END_CTRL structure */
  1123.     )
  1124.     {
  1125.     /* mark the driver as down */
  1127.     END_FLAGS_CLR (&pDrvCtrl->endObject, IFF_UP | IFF_RUNNING);
  1129.     /* Reset the device */
  1131.     motCpmReset (pDrvCtrl);
  1133.     return (OK);
  1134.     }
  1136. /******************************************************************************
  1137. *
  1138. * motCpmEndUnload - unload a driver from the system
  1139. *
  1140. * This function first brings down the device, and then frees any
  1141. * stuff that was allocated by the driver in the load function.
  1142. *
  1143. * RETURN : OK or ERROR
  1144. */
  1146. LOCAL STATUS motCpmEndUnload
  1147.     (
  1148.     END_CTRL *pDrvCtrl /* pointer to END_CTRL structure */
  1149.     )
  1150.     {
  1151.     END_OBJECT_UNLOAD (&pDrvCtrl->endObject);
  1153.     return (OK);
  1154.     }
  1156. /*******************************************************************************
  1157. *
  1158. * motCpmEndSend - output packet to network interface device
  1159. *
  1160. * This routine() takes a M_BLK_ID and sends off the data in the M_BLK_ID.
  1161. * The buffer must already have the addressing information properly installed
  1162. * in it. This is done by a higher layer. The last arguments are a free
  1163. * routine to be called when the device is done with the buffer and a pointer
  1164. * to the argument to pass to the free routine.
  1165. *
  1166. * muxSend() calls this routine each time it wants to send a packet.
  1167. * Errors are detected at interrupt level.
  1168. *
  1169. * RETURNS: OK or ERROR.
  1170. */
  1172. LOCAL STATUS motCpmEndSend
  1173.     (
  1174.     END_CTRL *pDrvCtrl, /* pointer to END_CTRL structure */
  1175.     M_BLK_ID    pMblk /* Data to send */
  1176.     )
  1177.     {
  1178.     int length;
  1179.     SCC_BUF * pTxBd;
  1180.     u_char * pad;
  1181.     char *         pBuf;
  1182.     int  oldLevel;
  1183.     int                 s;
  1184.     
  1185.     MOTCPMLOGMSG(("motCpmEndSend n", 0, 0, 0, 0, 0, 0));
  1187.     if (pDrvCtrl->txBlocked)
  1188.         return (END_ERR_BLOCK);
  1189.     
  1190.     if (pDrvCtrl->polling)
  1191. { 
  1192.         netMblkClChainFree (pMblk); /* free the given mBlk chain */
  1193.         errno = EINVAL;
  1194.         return (ERROR);
  1195.         }
  1197.     /* gain exclusive access to the transmitter */
  1199.     END_TX_SEM_TAKE (&pDrvCtrl->endObject, WAIT_FOREVER);
  1201.     /* get a free transmit frame descriptor */
  1202.     
  1203.     pTxBd = & pDrvCtrl->ether.txBdBase[pDrvCtrl->ether.txBdNext];
  1204.     
  1205.     /* check if a transmit buffer descriptor is available */
  1206.     
  1207.     if ((pTxBd->statusMode & SCC_ETHER_TX_BD_R) || 
  1208.         (((pDrvCtrl->ether.txBdNext + 1) % pDrvCtrl->ether.txBdNum) 
  1209.          == pDrvCtrl->txBdIndexC))
  1210.         {
  1211.         END_TX_SEM_GIVE (&pDrvCtrl->endObject);
  1212.         s = intLock();
  1213.         pDrvCtrl->txBlocked = TRUE;
  1214.         intUnlock(s);
  1215.         return (END_ERR_BLOCK);
  1216.         }
  1217.     
  1218.     /* fill the transmit frame descriptor */
  1219.     
  1220.     pBuf = netClusterGet(pDrvCtrl->endObject.pNetPool, pDrvCtrl->pClPoolId);
  1222.     if (pBuf == NULL)
  1223.         {
  1224.         END_TX_SEM_GIVE (&pDrvCtrl->endObject);
  1225. netMblkClChainFree(pMblk);
  1226.         return (ERROR);
  1227.         }
  1229.     length = netMblkToBufCopy (pMblk, (char *)pBuf, NULL);
  1230.     netMblkClChainFree(pMblk); 
  1232.     pTxBd->dataPointer = (u_char *) pBuf;
  1233.     
  1234.     /* padding mechanism in Rev A is buggy - do in software */
  1235.     
  1236.     if (length < FRAME_MIN)
  1237.         {
  1238.         pad = pTxBd->dataPointer + length;
  1239.         for (; length != FRAME_MIN; length++, pad++)
  1240.             *pad = 0x88;
  1241.         }
  1242.     
  1243.     pTxBd->dataLength = length;
  1244.     
  1245.     oldLevel = intLock (); /* disable ints during update */
  1246.     
  1247.     if (pTxBd->statusMode & SCC_ETHER_TX_BD_W)
  1248.         pTxBd->statusMode = SCC_ETHER_TX_BD_I | SCC_ETHER_TX_BD_PAD |
  1249.             SCC_ETHER_TX_BD_L | SCC_ETHER_TX_BD_TC  |
  1250.             SCC_ETHER_TX_BD_W | SCC_ETHER_TX_BD_R;
  1251.     else
  1252.         pTxBd->statusMode = SCC_ETHER_TX_BD_I | SCC_ETHER_TX_BD_PAD |
  1253.             SCC_ETHER_TX_BD_L | SCC_ETHER_TX_BD_TC  |
  1254.             SCC_ETHER_TX_BD_R;
  1255.     
  1256.     pDrvCtrl->freeRtn[pDrvCtrl->ether.txBdNext] = (FUNCPTR) netClFree;
  1257.     pDrvCtrl->freeData[pDrvCtrl->ether.txBdNext].arg1 =
  1258.         pDrvCtrl->endObject.pNetPool;
  1259.     pDrvCtrl->freeData[pDrvCtrl->ether.txBdNext].arg2 = pBuf;
  1261.     /* incr BD count */
  1262.     
  1263.     pDrvCtrl->ether.txBdNext = (pDrvCtrl->ether.txBdNext + 1) %
  1264.         pDrvCtrl->ether.txBdNum;
  1265.     
  1266.     /* Unlock interrupts */
  1267.     
  1268.     intUnlock (oldLevel);
  1270.     /* release semaphore */
  1272.     END_TX_SEM_GIVE (&pDrvCtrl->endObject);
  1274.     /* Bump the statistic counter. */
  1276.     END_ERR_ADD (&pDrvCtrl->endObject, MIB2_OUT_UCAST, +1);
  1278.     return (OK);
  1279.     }
  1281. /*******************************************************************************
  1282. *
  1283. * motCpmEndIoctl - network interface control routine
  1284. *
  1285. * This routine implements the network interface control functions.
  1286. * It handles EIOCSIFADDR, EIOCGADDR, EIOCSFLAGS, EIOCGFLAGS,
  1287. * EIOCPOLLSTART, EIOCPOLLSTOP, EIOCGMIB2 and EIOCGFBUF commands.
  1288. *
  1289. * RETURNS: OK if successful, otherwise EINVAL.
  1290. */
  1292. LOCAL int motCpmEndIoctl
  1293.     (
  1294.     END_CTRL * pDrvCtrl, /* pointer to END_CTRL structure */
  1295.     int cmd, /* command to process */
  1296.     caddr_t data /* pointer to data */ 
  1297.     )
  1298.     {
  1299.     int         error   = 0;            /* error value */
  1300.     long  value;
  1301.     END_OBJ * pEndObj = &pDrvCtrl->endObject;
  1303.     MOTCPMLOGMSG(("motCpmEndIoctl with command = 0x%x n", cmd, 0, 0, 0, 0, 0));
  1305.     switch (cmd)
  1306.         {
  1307. case EIOCSADDR:
  1308.     if (data == NULL)
  1309.      error = EINVAL;
  1310.     bcopy ((char *)data, (char *)END_HADDR(pEndObj),
  1311. END_HADDR_LEN(pEndObj));
  1312.     break;
  1314.         case EIOCGADDR:
  1315.     if (data == NULL)
  1316.      error = EINVAL;
  1317.      else
  1318.       bcopy ((char *)END_HADDR(pEndObj), (char *)data,
  1319.   END_HADDR_LEN(pEndObj));
  1320.    break;
  1321.    
  1322. case EIOCSFLAGS:
  1323.     value = (long) data;
  1324.     if (value < 0)
  1325. {
  1326. value = -value;
  1327. value--;
  1328. END_FLAGS_CLR (pEndObj, value);
  1329. }
  1330.     else
  1331. END_FLAGS_SET (pEndObj, value);
  1333.     /* set promisc bit off flags */
  1335.     if (END_FLAGS_GET(pEndObj) & IFF_PROMISC)
  1336. pDrvCtrl->ether.pSccReg->psmr |= SCC_ETHER_PSMR_PRO;
  1337.     else
  1338. pDrvCtrl->ether.pSccReg->psmr &= ~SCC_ETHER_PSMR_PRO;
  1339.     break;
  1341. case EIOCGFLAGS:
  1342.     if (data == NULL)
  1343. error = EINVAL;
  1344.     else
  1345.      *(int *)data = END_FLAGS_GET(pEndObj);
  1346.     break;
  1348. case EIOCPOLLSTART:
  1349.     error = motCpmEndPollStart (pDrvCtrl);
  1350.     break;
  1352. case EIOCPOLLSTOP:
  1353.     error = motCpmEndPollStop (pDrvCtrl);
  1354.     break;
  1356. case EIOCGMIB2:
  1357.     if (data == NULL)
  1358.      error = EINVAL;
  1359.     else
  1360. bcopy((char *)&pDrvCtrl->endObject.mib2Tbl, (char *)data,
  1361. sizeof(pDrvCtrl->endObject.mib2Tbl));
  1362.     break;
  1364.         case EIOCGFBUF:
  1365.     if (data == NULL)
  1366. error =  EINVAL;
  1367.     else
  1368. *(int *)data = LENGTH_MIN_FBUF;
  1369.     break;
  1371.         default:
  1372.             error = EINVAL;
  1373.         }
  1375.     return (error);
  1376.     }
  1378. /*******************************************************************************
  1379. *
  1380. * motCpmEndMCastAddrAdd - add a multicast address for the device
  1381. *
  1382. * This routine adds a multicast address to whatever the driver
  1383. * is already listening for. 
  1384. *
  1385. * To add an address in the processor group address hash filter, we use
  1386. * the SET GROUP ADDRESS command. This command can be executed at any 
  1387. * time, regadless of whether the Ethernet channel is enabled.
  1388. *
  1389. * RETURNS : OK or ERROR
  1390. */
  1392. LOCAL STATUS motCpmEndMCastAddrAdd
  1393.     (
  1394.     END_CTRL *  pDrvCtrl, /* pointer to END_CTRL structure */
  1395.     char *      pAddr /* Address to add to the table. */
  1396.     )
  1397.     {
  1398.     STATUS error;
  1400.     MOTCPMLOGMSG(("motCpmEndMCastAddrAdd %x:%x:%x:%x:%x:%x n", 
  1401.  pAddr[5], pAddr[4], pAddr[3], 
  1402.  pAddr[2], pAddr[1], pAddr[0]));
  1404.     error = etherMultiAdd (&pDrvCtrl->endObject.multiList, pAddr);
  1406.     if (error == ENETRESET)
  1407. {
  1408. pDrvCtrl->endObject.nMulti++;
  1410. /* Set the multicast address */
  1412. motCpmMCastFilterSet (pDrvCtrl, pAddr);
  1414. error = OK;
  1415. }
  1417.     return ((error == OK) ? OK : ERROR);
  1418.     }
  1420. /*******************************************************************************
  1421. *
  1422. * motCpmEndMCastAddrDel - delete a multicast address for the device
  1423. *
  1424. * This routine deletes a multicast address from the current list of
  1425. * multicast addresses.
  1426. *
  1427. * RETURNS : OK or ERROR
  1428. */
  1430. LOCAL STATUS motCpmEndMCastAddrDel
  1431.     (
  1432.     END_CTRL *  pDrvCtrl, /* pointer to END_CTRL structure */
  1433.     char *      pAddr /* Address to delete from the table. */
  1434.     )
  1435.     {
  1436.     STATUS error;
  1438.     MOTCPMLOGMSG(("motCpmEndMCastDel %x:%x:%x:%x:%x:%x n", 
  1439.  pAddr[5], pAddr[4], pAddr[3], 
  1440.  pAddr[2], pAddr[1], pAddr[0]));
  1442.     error = etherMultiDel (&pDrvCtrl->endObject.multiList, pAddr);
  1444.     if (error == ENETRESET)
  1445. {
  1446. pDrvCtrl->endObject.nMulti--;
  1447. motCpmMCastConfig (pDrvCtrl);
  1448. error = OK;
  1449. }
  1451.     return ((error == OK) ? OK : ERROR);
  1452.     }
  1454. /*******************************************************************************
  1455. *
  1456. * motCpmEndMCastAddrGet - get the current multicast address list
  1457. *
  1458. * This routine returns the current multicast address list in <pTable>
  1459. *
  1460. */
  1462. LOCAL STATUS motCpmEndMCastAddrGet
  1463.     (
  1464.     END_CTRL *  pDrvCtrl, /* pointer to END_CTRL structure */
  1465.     MULTI_TABLE *pTable /* table to fill in with addresses */
  1466.     )
  1467.     {
  1468.     MOTCPMLOGMSG(("motCpmEndMCastAddrGet n", 0, 0, 0, 0, 0, 0));
  1470.     return (etherMultiGet (&pDrvCtrl->endObject.multiList, pTable));
  1471.     }
  1473. /*******************************************************************************
  1474. *
  1475. * motCpmEndPollStart - start polling mode
  1476. *
  1477. * This routine starts polling mode by disabling ethernet interrupts and
  1478. * setting the polling flag in the END_CTRL stucture.
  1479. *
  1480. * It is necessary to empty transmit queue before entering polling mode
  1481. * because M_BLK_ID free routine used in interrupt mode could be unusable 
  1482. * in this mode (could use kernel calls). 
  1483. *
  1484. * RETURNS: OK or ERROR if already in polling mode.
  1485. */
  1487. LOCAL STATUS motCpmEndPollStart
  1488.     (
  1489.     END_CTRL    *pDrvCtrl /* pointer to END_CTRL structure */
  1490.     )
  1491.     {
  1492.     int  intLevel;
  1493.     int txBdIndex;
  1494.     SCC_BUF * pTxBd;
  1496.     MOTCPMLOGMSG(("motCpmEndPollStart n", 0, 0, 0, 0, 0, 0));
  1498.     /* Lock interrupts */
  1500.     intLevel = intLock();
  1502.     /* clean transmit queue */
  1504.     txBdIndex = pDrvCtrl->txBdIndexC;
  1506.     while (txBdIndex != pDrvCtrl->ether.txBdNext)
  1507. {
  1508. pTxBd = & pDrvCtrl->ether.txBdBase[txBdIndex];
  1510. /* Spin until frame buffer is sent */
  1512. while (pTxBd->statusMode & SCC_ETHER_TX_BD_R)
  1513.     ;
  1515. /* Check for transmit errors */
  1517. if (pTxBd->statusMode & (SCC_ETHER_TX_BD_RL | SCC_ETHER_TX_BD_UN |
  1518.   SCC_ETHER_TX_BD_CSL | SCC_ETHER_TX_BD_LC))
  1519.     {
  1520.     /* An error has occured, restart the transmitter */
  1522.     pDrvCtrl->txStop = TRUE;
  1524.     motCpmTxRestart (pDrvCtrl);
  1525.     }
  1527. /* increment txBdIndex */
  1529. txBdIndex = (txBdIndex + 1) % pDrvCtrl->ether.txBdNum;
  1530. }
  1531.     
  1532.     /* free all transmit buffer and update transmit queue */
  1534.     motCpmCleanTxBdQueue (pDrvCtrl);
  1536.     /* Now, transmit queue is empty. We can enter polling mode. */
  1537.     /* mask off the receive and transmit interrupts */
  1538.     
  1539.     pDrvCtrl->ether.pSccReg->sccm = 0;
  1541.     /* Set the polling flag */
  1543.     pDrvCtrl->polling = TRUE;
  1545.     /* Unlock interrupts */
  1547.     intUnlock (intLevel);
  1549.     return (OK);
  1550.     }
  1552. /*******************************************************************************
  1553. *
  1554. * motCpmEndPollStop - stop polling mode
  1555. *
  1556. * This routine stops polling mode by enabling ethernet interrupts and
  1557. * resetting the polling flag in the END_CTRL structure.
  1558. *
  1559. * RETURNS: OK always
  1560. */
  1562. LOCAL STATUS motCpmEndPollStop
  1563.     (
  1564.     END_CTRL    *pDrvCtrl /* pointer to END_CTRL structure */
  1565.     )
  1566.     {
  1567.     int         intLevel;
  1569.     MOTCPMLOGMSG(("motCpmEndPollStop n", 0, 0, 0, 0, 0, 0));
  1571.     /* lock interrupt  */
  1573.     intLevel = intLock();
  1575.     /* reset the SCC's interrupt status bit */
  1577.     *CPM_CISR(pDrvCtrl->regBase) = pDrvCtrl->ether.intMask;
  1579.     /* enable this SCC's interrupt */
  1581.     *CPM_CIMR(pDrvCtrl->regBase) |= pDrvCtrl->ether.intMask;
  1583.     /* reset the status bits */
  1585.     pDrvCtrl->ether.pSccReg->scce = 0xffff;
  1587.     /* enables the receive and transmit interrupts */
  1589.     pDrvCtrl->ether.pSccReg->sccm = SCC_ETHER_SCCX_RXF | SCC_ETHER_SCCX_TXE |
  1590.     SCC_ETHER_SCCX_TXB;
  1592.     /* reset the polling flag */
  1594.     pDrvCtrl->polling = FALSE;
  1596.     /* unlock interrupt  */
  1598.     intUnlock (intLevel);
  1600.     return (OK);
  1601.     }
  1603. /******************************************************************************
  1604. *
  1605. * motCpmEndPollSend - transmit a packet in polled mode
  1606. *
  1607. * This routine is called by a user to try and send a packet on the
  1608. * device. It sends a packet directly on the network from the caller without
  1609. * going through the normal processes of queuing a pacet on an output queue
  1610. * and the waiting for the device to decide to transmit it.
  1611. *
  1612. * If it detects a transmission error, the restart command is issued.
  1613. *
  1614. * These routine should not call any kernel functions.
  1615. *
  1616. * RETURNS: OK or EAGAIN
  1617. */
  1619. LOCAL STATUS motCpmEndPollSend
  1620.     (
  1621.     END_CTRL    *pDrvCtrl, /* pointer to END_CTRL structure */
  1622.     M_BLK_ID    pMblk /* data to send */
  1623.     )
  1624.     {
  1625.     int length;
  1626.     SCC_BUF * pTxBd;
  1627.     u_char * pad;
  1628.     char * pBuf;
  1630.     MOTCPMLOGMSG(("motCpmEndPollSend n", 0, 0, 0, 0, 0, 0));
  1632.     if (pDrvCtrl->txStop)
  1633. return (ERROR);
  1635.     /* get a free transmit frame descriptor */
  1637.     pTxBd = & pDrvCtrl->ether.txBdBase[pDrvCtrl->ether.txBdNext];
  1639.     /* check if a transmit buffer descriptor is available */
  1641.     if ((pTxBd->statusMode & SCC_ETHER_TX_BD_R) ||
  1642. (((pDrvCtrl->ether.txBdNext + 1) % pDrvCtrl->ether.txBdNum)
  1643. == pDrvCtrl->txBdIndexC))
  1644. {
  1645. return (EAGAIN);
  1646. }
  1648.     /* fill the transmit frame descriptor */
  1649.     
  1650.     pBuf = pDrvCtrl->txPoolBuf;   
  1651.  
  1652.     length = netMblkToBufCopy (pMblk, (char *)pBuf, NULL);
  1654.     pTxBd->dataPointer = (u_char *) pBuf;
  1656.     /* padding mechanism in Rev A is buggy - do in software */
  1658.     if (length < FRAME_MIN)
  1659. {
  1660. pad = pTxBd->dataPointer + length;
  1661. for (; length != FRAME_MIN; length++, pad++)
  1662.     *pad = 0x88;
  1663. }
  1665.     pTxBd->dataLength = length;
  1667.     if (pTxBd->statusMode & SCC_ETHER_TX_BD_W)
  1668. pTxBd->statusMode = SCC_ETHER_TX_BD_I | SCC_ETHER_TX_BD_PAD |
  1669.     SCC_ETHER_TX_BD_L | SCC_ETHER_TX_BD_TC  |
  1670.     SCC_ETHER_TX_BD_W | SCC_ETHER_TX_BD_R;
  1671.     else
  1672. pTxBd->statusMode = SCC_ETHER_TX_BD_I | SCC_ETHER_TX_BD_PAD |
  1673.     SCC_ETHER_TX_BD_L | SCC_ETHER_TX_BD_TC  |
  1674.     SCC_ETHER_TX_BD_R;
  1676.     /* incr BD count */
  1678.     pDrvCtrl->ether.txBdNext = (pDrvCtrl->ether.txBdNext + 1) %
  1679. pDrvCtrl->ether.txBdNum;
  1681.     /* Bump the statistic counter. */
  1683.     END_ERR_ADD (&pDrvCtrl->endObject, MIB2_OUT_UCAST, +1);
  1685.     /*
  1686.      * Spin until we've sent it.
  1687.      */
  1689.     while (pTxBd->statusMode & SCC_ETHER_TX_BD_R)
  1690. ;
  1692.     if (pTxBd->statusMode & (SCC_ETHER_TX_BD_RL | SCC_ETHER_TX_BD_UN |
  1693.     SCC_ETHER_TX_BD_CSL | SCC_ETHER_TX_BD_LC))
  1694. {
  1695. /* An error has occured, restart the transmitter */
  1697. pDrvCtrl->txStop = TRUE;
  1699. motCpmTxRestart (pDrvCtrl);
  1700. }
  1702.     /* 
  1703.      * we are allow to do this because transmit queue is empty when we
  1704.      * start polling mode.
  1705.      */
  1707.     pDrvCtrl->txBdIndexC = pDrvCtrl->ether.txBdNext;
  1709.     return (OK);
  1710.     }
  1712. /*******************************************************************************
  1713. *
  1714. * motCpmEndPollReceive - receive a packet in polled mode
  1715. *
  1716. * This routine is called by a user to try and get a packet from the
  1717. * device. It returns EAGAIN if no packet is available. The caller must
  1718. * supply a M_BLK_ID with enough space to contain the receiving packet. If
  1719. * enough buffer is not available then EAGAIN is returned.
  1720. *
  1721. * These routine should not call any kernel functions.
  1722. *
  1723. * RETURNS: OK or EAGAIN
  1724. */
  1726. LOCAL STATUS motCpmEndPollReceive
  1727.     (
  1728.     END_CTRL    *pDrvCtrl, /* pointer to END_CTRL structure */
  1729.     M_BLK_ID    pMblk
  1730.     )
  1731.     {
  1732.     SCC_BUF * pRxBd = & pDrvCtrl->ether.rxBdBase[pDrvCtrl->ether.rxBdNext];
  1733.     int length;
  1734.     int status = EAGAIN;
  1736.     MOTCPMLOGMSG(("motCpmEndPollReceive n", 0, 0, 0, 0, 0, 0));
  1738.     /* if we have not received packets, leave immediatly */
  1740.     if (pRxBd->statusMode & SCC_ETHER_RX_BD_E)
  1741. return (EAGAIN);
  1743.     /* check packets for errors */
  1745.     if (((pRxBd->statusMode & (SCC_ETHER_RX_BD_F  | SCC_ETHER_RX_BD_L))
  1746.    == (SCC_ETHER_RX_BD_F  | SCC_ETHER_RX_BD_L))
  1747.        && !(pRxBd->statusMode & (SCC_ETHER_RX_BD_CL |
  1748. SCC_ETHER_RX_BD_OV | SCC_ETHER_RX_BD_CR |
  1749. SCC_ETHER_RX_BD_SH | SCC_ETHER_RX_BD_NO |
  1750. SCC_ETHER_RX_BD_LG)))
  1751. {
  1752. /* adjust length to data only */
  1754. length = pRxBd->dataLength - 4;
  1756. if ((length - SIZEOF_ETHERHEADER) <= 0)
  1757.     {
  1758.     /* bump input error packet counter */
  1760.     END_ERR_ADD (&pDrvCtrl->endObject, MIB2_IN_ERRS, +1);
  1761.     goto cleanRxBd;
  1762.     }
  1764. /* 
  1765.  * Upper layer provides the buffer.
  1766.          * If buffer is not large enough, we return.
  1767.  */
  1769. /* copy data */
  1771.         if ((pMblk->mBlkHdr.mLen < length) ||
  1772.             (!(pMblk->mBlkHdr.mFlags & M_EXT)))
  1773.             {
  1774.             goto cleanRxBd;
  1775.             }
  1776.         
  1777. bcopy ((char *) pRxBd->dataPointer, (char *)pMblk->mBlkHdr.mData,
  1778.                length);
  1779. pMblk->mBlkHdr.mLen = length;
  1780. pMblk->mBlkPktHdr.len = length;
  1781. pMblk->mBlkHdr.mFlags |= M_PKTHDR;
  1783. /* bump input packet counter */
  1785. END_ERR_ADD (&pDrvCtrl->endObject, MIB2_IN_UCAST, +1);
  1787. status = OK;
  1788. }
  1789.     else
  1790. {
  1791. /* bump input error packet counter */
  1793. END_ERR_ADD (&pDrvCtrl->endObject, MIB2_IN_ERRS, +1);
  1794. }
  1796. cleanRxBd:
  1797.     motCpmCleanRxBd (pDrvCtrl, pRxBd); /* reset buffer descriptor as empty */
  1799.     return (status);
  1800.     }
  1802. /*******************************************************************************
  1803. *
  1804. * motCpmIntr - network interface interrupt handler
  1805. *
  1806. * This routine gets called at interrupt level. It handles work that 
  1807. * requires minimal processing. Interrupt processing that is more 
  1808. * extensive gets handled at task level. The network task, netTask(), is 
  1809. * provided for this function. Routines get added to the netTask() work 
  1810. * queue via the netJobAdd() command.
  1811. *
  1812. * RETURNS: N/A
  1813. */
  1815. LOCAL void motCpmIntr
  1816.     (
  1817.     END_CTRL * pDrvCtrl /* pointer to END_CTRL structure */
  1818.     )
  1819.     {
  1820.     BOOL rxHandle = FALSE;
  1821.     BOOL txbHandle = FALSE;
  1822.     
  1823.     /* check for spurious interrupt -> initialized ? */
  1825.     if (!pDrvCtrl->endObject.attached)
  1826. {
  1827.         pDrvCtrl->ether.pSccReg->scce = 0xffff;
  1829.         *CPM_CISR(pDrvCtrl->regBase) = pDrvCtrl->ether.intMask;
  1830. return;
  1831. }
  1833.     /* handle receive events */
  1835.     if ((pDrvCtrl->ether.pSccReg->sccm & SCC_ETHER_SCCX_RXF) &&
  1836.         (pDrvCtrl->ether.pSccReg->scce & SCC_ETHER_SCCX_RXF))
  1837. {
  1838.         (void) netJobAdd ((FUNCPTR) motCpmHandleInt, (int) pDrvCtrl, 
  1839.   0, 0, 0, 0); 
  1841. /* turn off receive interrupts for now - motCpmHandleIt turns back on */
  1843.         pDrvCtrl->ether.pSccReg->sccm &= ~SCC_ETHER_SCCX_RXF;
  1844. rxHandle = TRUE;
  1845.         }
  1847.     /* check for output errors */
  1849.     if (pDrvCtrl->ether.pSccReg->scce & SCC_ETHER_SCCX_TXE)
  1850. {
  1851. /* clean the transmit buffer descriptor queue */
  1852. /* NOTE: HBC error not supported -> always RESTART Tx here */
  1854.         (void) netJobAdd ((FUNCPTR) motCpmTxRestart, (int) pDrvCtrl, 
  1855.   0, 0, 0, 0);
  1856. pDrvCtrl->txStop = TRUE;
  1857. }
  1859.     /* handle transmitter events - BD full condition -> ever happen ? */
  1861.     if ((pDrvCtrl->ether.pSccReg->sccm & SCC_ETHER_SCCX_TXB) &&
  1862.         (pDrvCtrl->ether.pSccReg->scce & SCC_ETHER_SCCX_TXB))
  1863. {
  1864. txbHandle = TRUE;
  1865. }
  1867.     /* check for input busy condition */
  1869.     if (pDrvCtrl->ether.pSccReg->scce & SCC_ETHER_SCCX_BSY)
  1870.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_BSY; 
  1872.     /* acknowledge all other interrupts - ignore events */
  1874.     pDrvCtrl->ether.pSccReg->scce = (pDrvCtrl->ether.pSccReg->scce &
  1875.     ~(SCC_ETHER_SCCX_RXF |
  1876.       SCC_ETHER_SCCX_TXE |
  1877.       SCC_ETHER_SCCX_TXB |
  1878.       SCC_ETHER_SCCX_BSY));
  1880.     /* 
  1881.      * clean the transmit buffer descriptor queue if we have 
  1882.      * received a transmit interrupt and if we are not already
  1883.      * cleaning this transmit queue.
  1884.      */
  1886.     if ((pDrvCtrl->txStop || txbHandle) && !pDrvCtrl->txCleaning)
  1887.         {
  1888.      motCpmCleanTxBdQueue (pDrvCtrl);
  1889.         if (pDrvCtrl->txBlocked)
  1890.             {
  1891.             pDrvCtrl->txBlocked = FALSE;
  1892.             (void) netJobAdd ((FUNCPTR) muxTxRestart,
  1893.                               (int)&pDrvCtrl->endObject,
  1894.                               0, 0, 0, 0);
  1895.             }
  1896.         }
  1898.     /* acknowledge interrupts */
  1900.     if (rxHandle)
  1901.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_RXF; 
  1902.     if (pDrvCtrl->txStop)
  1903.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_TXE; 
  1904.     if (txbHandle)
  1905.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_TXB; 
  1907.     *CPM_CISR(pDrvCtrl->regBase) = pDrvCtrl->ether.intMask;
  1909.     }
  1911. /*******************************************************************************
  1912. *
  1913. * motCpmMCastFilterSet - set the group addres filter for a multicast addresse.
  1914. *
  1915. * To add an address in the processor group address hash filter, we use
  1916. * the SET GROUP ADDRESS command. This command can be executed at any 
  1917. * time, regadless of whether the Ethernet channel is enabled.
  1918. *
  1919. * RETURNS : N/A 
  1920. *
  1921. */
  1923. LOCAL void motCpmMCastFilterSet
  1924.     (
  1925.     END_CTRL *  pDrvCtrl, /* pointer to END_CTRL structure */
  1926.     char *      pAddress        /* Address to delete from the table. */
  1927.     )
  1928.     {
  1929.     MOTCPMLOGMSG(("motCpmMCastFilterSet n", 0, 0, 0, 0, 0, 0));
  1931.     /* add multicast address */
  1933.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->taddr_h =
  1934. (pAddress[5] << 8) + pAddress[4];
  1935.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->taddr_m =
  1936. (pAddress[3] << 8) + pAddress[2];
  1937.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->taddr_l =
  1938. (pAddress[1] << 8) + pAddress[0];
  1940.     /* issue the set group address command to the CP */
  1942.     while (*CPM_CPCR(pDrvCtrl->regBase) & CPM_CR_FLG);
  1944.     *CPM_CPCR(pDrvCtrl->regBase) = ((pDrvCtrl->ether.sccNum - 1) << 6) |
  1945.        CPM_CR_SCC_SET_GROUP |
  1946.        CPM_CR_FLG;
  1948.     while (*CPM_CPCR(pDrvCtrl->regBase) & CPM_CR_FLG);
  1949.     }
  1951. /*******************************************************************************
  1952. *
  1953. * motCpmMCastConfig - reconfigure the interface under us.
  1954. *
  1955. * Reconfigure the interface changing the multicast interface list.
  1956. *
  1957. * In order to delete an address from the hash tabke, the Ethernet channel
  1958. * should be disabled, the hash table registers should be cleared, and 
  1959. * the SET GROUP ADDRESS command must be executed for the remaining 
  1960. * desired addresses. This is required because the hash table may have mapped
  1961. * multiple addresses to the same hash table bit.
  1962. *
  1963. * RETURNS : N/A 
  1964. */
  1966. LOCAL void motCpmMCastConfig
  1967.     (
  1968.     END_CTRL *  pDrvCtrl /* pointer to END_CTRL structure */
  1969.     )
  1970.     {
  1971.     ETHER_MULTI * pCurr;
  1973.     MOTCPMLOGMSG(("motCpmMCastConfig n",0,0,0,0,0,0));
  1975.     /* disable the ethernet channel */
  1977.     motCpmReset (pDrvCtrl);
  1979.     /* clear hash table group registers */
  1981.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr1     = 0x0000;
  1982.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr2     = 0x0000;
  1983.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr3     = 0x0000;
  1984.     ((SCC_ETHER_PROTO *)pDrvCtrl->ether.pScc->prot)->gaddr4     = 0x0000;
  1986.     /* restore remaining addresses */
  1988.     for (pCurr = END_MULTI_LST_FIRST(&pDrvCtrl->endObject); pCurr != NULL;
  1989. pCurr = (ETHER_MULTI *)lstNext(&pCurr->node))
  1990. {
  1991. /* add multicast address */
  1992. motCpmMCastFilterSet (pDrvCtrl, pCurr->addr);
  1993. }
  1995.     /* restart the ethernet channel */
  1997.     motCpmRestart (pDrvCtrl);
  1998.     }
  2000. /*******************************************************************************
  2001. *
  2002. * motCpmRestart - network interface restart routine
  2003. *
  2004. * This routine restarts the device.  This includes enabling interrupts, 
  2005. * starting the transmitter and receiver, and calling the bsp-specific
  2006. * LAN enable routine to do any target specific enabling.
  2007. *
  2008. * This routine follows the instructions in MC68EN360/MPC821 Users's Manual :
  2009. * "Disabling the SCCs on the Fly"
  2010. *
  2011. * The complement of this routine is motCpmReset().  Once a unit is reset by
  2012. * motCpmReset(), it may be re-initialized to a running state by this routine.
  2013. *
  2014. * RETURNS: N/A
  2015. */
  2017. LOCAL STATUS motCpmRestart
  2018.     (
  2019.     END_CTRL *  pDrvCtrl /* pointer to END_CTRL structure */
  2020.     )
  2021.     {
  2022.     /* enable Ethernet interrupts */
  2024.     *CPM_CIMR(pDrvCtrl->regBase) |= pDrvCtrl->ether.intMask;
  2026.     /* call the BSP to do any other initialization (e.g., connecting clocks) */
  2028.     SYS_ENET_ENABLE;
  2030.     /* enable the transmitter */
  2032.     pDrvCtrl->ether.pSccReg->gsmrl |= SCC_GSMRL_ENT;
  2034.     /* issue the restart transmitter command to the CP */
  2036.     while (*CPM_CPCR(pDrvCtrl->regBase) & CPM_CR_FLG);
  2037.     *CPM_CPCR(pDrvCtrl->regBase) = ((pDrvCtrl->ether.sccNum - 1) << 6) |
  2038.       CPM_CR_SCC_RESTART |
  2039.       CPM_CR_FLG;
  2040.     while (*CPM_CPCR(pDrvCtrl->regBase) & CPM_CR_FLG);
  2042.     /* issue the enter hunt mode command to the CP */
  2044.     while (*CPM_CPCR(pDrvCtrl->regBase) & CPM_CR_FLG);
  2045.     *CPM_CPCR(pDrvCtrl->regBase) = ((pDrvCtrl->ether.sccNum - 1) << 6) |
  2046.       CPM_CR_SCC_HUNT |
  2047.       CPM_CR_FLG;
  2048.     while (*CPM_CPCR(pDrvCtrl->regBase) & CPM_CR_FLG);
  2050.     /* enable the receiver */
  2052.     pDrvCtrl->ether.pSccReg->gsmrl |= SCC_GSMRL_ENR;
  2054.     return (OK);
  2055.     }
  2057. /*******************************************************************************
  2058. *
  2059. * motCpmReset - network interface reset routine
  2060. *
  2061. * This routine resets the device.  This includes disabling interrupts, 
  2062. * stopping the transmitter and receiver, and calling the bsp-specific
  2063. * LAN disable routine to do any target specific disabling.
  2064. *
  2065. * This routine follows the instructions in MC68EN360/MPC821 Users's Manual :
  2066. * "Disabling the SCCs on the Fly"
  2067. *
  2068. * The complements of this routine are motCpmEndStart() and motCpmRestart().  
  2069. * Once a unit is reset in this routine, it may be re-started with parameters
  2070. * reinitialized with motCpmEndStart() or re-started with current parameteres 
  2071. * with  motCpmRestart().
  2072. *
  2073. * RETURNS: N/A
  2074. */
  2076. LOCAL void motCpmReset
  2077.     (
  2078.     END_CTRL *  pDrvCtrl /* pointer to END_CTRL structure */
  2079.     )
  2080.     {
  2081.     int counter = 0xffff;
  2083.     /* disable the SCC interrupts */
  2085.     *CPM_CIMR(pDrvCtrl->regBase) &= ~pDrvCtrl->ether.intMask;
  2087.     /* issue the CP graceful stop command to the transmitter if necessary */
  2089.     if (pDrvCtrl->ether.pSccReg->gsmrl & SCC_GSMRL_ENT)
  2090. {
  2091.         while (*CPM_CPCR(pDrvCtrl->regBase) & CPM_CR_FLG);
  2092.         *CPM_CPCR(pDrvCtrl->regBase) = ((pDrvCtrl->ether.sccNum - 1) << 6) |
  2093.                                           CPM_CR_SCC_GRSTOP | CPM_CR_FLG;
  2094.         while (*CPM_CPCR(pDrvCtrl->regBase) & CPM_CR_FLG);
  2096.         /* wait for graceful stop to register */
  2098.         while ((counter--) && (!(pDrvCtrl->ether.pSccReg->scce &
  2099.          SCC_ETHER_SCCX_GRA)));
  2100. }
  2102.     /* disable the SCC receiver and transmitter */
  2104.     pDrvCtrl->ether.pSccReg->gsmrl &= ~(SCC_GSMRL_ENR | SCC_GSMRL_ENT);
  2106.     /* call the BSP to do any other disabling (e.g., *TENA) */
  2108.     SYS_ENET_DISABLE;
  2110.     }
  2112. /*******************************************************************************
  2113. *
  2114. * motCpmTxRestart - issue RESTART Tx command to the CP
  2115. *
  2116. * This routine issues a RESTART transmitter command to the CP.  It is
  2117. * executed by netTask (motCpmIntr() did a netJobAdd).  motCpmIntr() cannot do
  2118. * a RESTART directly because the CPM flag must be taken before a command
  2119. * can be written.  
  2120. *
  2121. * RETURNS: N/A
  2122. */
  2124. LOCAL void motCpmTxRestart
  2125.     (
  2126.     END_CTRL * pDrvCtrl /* pointer to END_CTRL structure */
  2127.     )
  2128.     {
  2130.     MOTCPMLOGMSG(("motCpmTxRestart n", 0, 0, 0, 0, 0, 0));
  2132.     /* update error counter */
  2134.     END_ERR_ADD (&pDrvCtrl->endObject, MIB2_OUT_ERRS, +1);
  2135.     END_ERR_ADD (&pDrvCtrl->endObject, MIB2_OUT_UCAST, -1);
  2137.     /* restart transmitter */
  2139.     while (*CPM_CPCR(pDrvCtrl->regBase) & CPM_CR_FLG);
  2140.     *CPM_CPCR(pDrvCtrl->regBase) = ((pDrvCtrl->ether.sccNum - 1) << 6) |
  2141.                                       CPM_CR_SCC_RESTART | CPM_CR_FLG;
  2142.     while (*CPM_CPCR(pDrvCtrl->regBase) & CPM_CR_FLG);
  2144.     pDrvCtrl->txStop = FALSE;
  2145.     }
  2147. /*******************************************************************************
  2148. *
  2149. * motCpmHandleInt - task-level interrupt handler
  2150. *
  2151. * This is the task-level interrupt handler, which is called from 
  2152. * netTask(). motCpmIntr() gets input frames from the device and then calls 
  2153. * motCpmIntr() to process each frame. motCpmIntr() only gets called if no error
  2154. * stats were reported in the buffer descriptor.  Data chaining is not
  2155. * supported.
  2156. *
  2157. * This routine should be called with SCC receive interrupts masked so that
  2158. * more netJobAdds of this routine are not performed by motCpmIntr().
  2159. * Receive interrupts are turned back on by this routine before exiting.
  2160. *
  2161. * RETURNS: N/A
  2162. */
  2164. LOCAL void motCpmHandleInt
  2165.     (
  2166.     END_CTRL * pDrvCtrl /* pointer to END_CTRL structure */
  2167.     )
  2168.     {
  2169.     SCC_BUF * pRxBd = & pDrvCtrl->ether.rxBdBase[pDrvCtrl->ether.rxBdNext];
  2171.     while (!(pRxBd->statusMode & SCC_ETHER_RX_BD_E))
  2172.         {
  2173.         /* data chaining is not supported  - check all error conditions */
  2175.         if (((pRxBd->statusMode & (SCC_ETHER_RX_BD_F  | SCC_ETHER_RX_BD_L))
  2176.                        == (SCC_ETHER_RX_BD_F  | SCC_ETHER_RX_BD_L))
  2177.                       && !(pRxBd->statusMode & (SCC_ETHER_RX_BD_CL |
  2178.                    SCC_ETHER_RX_BD_OV | SCC_ETHER_RX_BD_CR |
  2179.    SCC_ETHER_RX_BD_SH | SCC_ETHER_RX_BD_NO |
  2180.    SCC_ETHER_RX_BD_LG)))
  2181.             motCpmRecv (pDrvCtrl, pRxBd);
  2182.         else
  2183.     {
  2184.             END_ERR_ADD (&pDrvCtrl->endObject, MIB2_IN_ERRS, +1);
  2186.     /* reset buffer descriptor as empty */
  2188.     motCpmCleanRxBd (pDrvCtrl, pRxBd);
  2189.     }
  2191.         /* update receive buffer descriptor pointer */
  2193.         pRxBd = & pDrvCtrl->ether.rxBdBase[pDrvCtrl->ether.rxBdNext];
  2195.         /* clear Rx events */
  2197.         pDrvCtrl->ether.pSccReg->scce = SCC_ETHER_SCCX_RXF;
  2198.         }
  2200.     /* re-enable Rx interrupts */
  2202.     pDrvCtrl->ether.pSccReg->sccm |= SCC_ETHER_SCCX_RXF;
  2203.     }
  2205. /*******************************************************************************
  2206. *
  2207. * motCpmRecv - process an input frame
  2208. *
  2209. * This routine processes an input frame, then passes it up to the higher 
  2210. * level in a form it expects.  Buffer loaning, promiscuous mode are all 
  2211. * supported.  Trailer protocols is not supported.
  2212. *
  2213. * RETURNS: N/A
  2214. */
  2216. LOCAL void motCpmRecv
  2217.     (
  2218.     END_CTRL * pDrvCtrl, /* pointer to END_CTRL structure */
  2219.     SCC_BUF * pRxBd /* receive buffer descriptor */
  2220.     )
  2221.     { 
  2222.     M_BLK_ID pMblk;
  2223.     CL_BLK_ID pClBlk;
  2224.     char * pNewCluster;
  2226.     if (((pRxBd->dataLength - 4) - SIZEOF_ETHERHEADER) <= 0)
  2227. { 
  2228.         END_ERR_ADD (&pDrvCtrl->endObject, MIB2_IN_ERRS, +1);
  2229. motCpmCleanRxBd (pDrvCtrl, pRxBd);/* reset buffer descriptor as empty */
  2230. return;
  2231. }
  2233.     pNewCluster = netClusterGet (pDrvCtrl->endObject.pNetPool,
  2234.                                  pDrvCtrl->pClPoolId);
  2236.     if (pNewCluster == NULL)
  2237.         {
  2238.         END_ERR_ADD (&pDrvCtrl->endObject, MIB2_IN_ERRS, +1);
  2239. motCpmCleanRxBd (pDrvCtrl, pRxBd);/* reset buffer descriptor as empty */
  2240. return;
  2241.         }
  2243.     if ((pMblk = mBlkGet(pDrvCtrl->endObject.pNetPool,
  2244.                          M_DONTWAIT, MT_DATA)) == NULL)
  2245.         {
  2246.         netClFree (pDrvCtrl->endObject.pNetPool, (UCHAR *)pNewCluster);
  2247. END_ERR_ADD (&pDrvCtrl->endObject, MIB2_IN_ERRS, +1);
  2248. motCpmCleanRxBd (pDrvCtrl, pRxBd);/* reset buffer descriptor as empty */
  2249.         return;
  2250.         }
  2252.     if ((pClBlk = clBlkGet (pDrvCtrl->endObject.pNetPool, M_DONTWAIT))
  2253.         == NULL)
  2254.         {
  2255.         netMblkFree (pDrvCtrl->endObject.pNetPool, pMblk); 
  2256.         netClFree (pDrvCtrl->endObject.pNetPool, (UCHAR *)pNewCluster);
  2257. END_ERR_ADD (&pDrvCtrl->endObject, MIB2_IN_ERRS, +1);
  2258. motCpmCleanRxBd (pDrvCtrl, pRxBd);/* reset buffer descriptor as empty */
  2259.         return;
  2260.         }
  2262.     /* join the cluster block to the data buffer */
  2264.     netClBlkJoin (pClBlk, (char *) pRxBd->dataPointer, pRxBd->dataLength - 4,
  2265.                   NULL, 0, 0, 0);
  2267.     /* join the mBlk and cluster Block */
  2269.     netMblkClJoin (pMblk, pClBlk);
  2271.     /* intialize the mBlk */
  2273.     pMblk->mBlkHdr.mLen  = pRxBd->dataLength - 4;
  2274.     pMblk->mBlkHdr.mFlags  |= M_PKTHDR;
  2275.     pMblk->mBlkPktHdr.len  = pMblk->mBlkHdr.mLen;
  2277.     /* update receive buffer descriptor data pointer */
  2279.     pRxBd->dataPointer = (UCHAR *) pNewCluster;
  2281.     /* 
  2282.      * Reset buffer descriptor as empty
  2283.      * It is neccessary to do this before sending up the packet to the
  2284.      * protocol in case we switch to system mode. 
  2285.      */
  2287.     motCpmCleanRxBd (pDrvCtrl, pRxBd);
  2289.     /* send up to protocol */
  2291.     END_RCV_RTN_CALL (&pDrvCtrl->endObject, pMblk);
  2293.     /* bump input packet counter */
  2295.     END_ERR_ADD (&pDrvCtrl->endObject, MIB2_IN_UCAST, +1);
  2296.     }
  2298. /*******************************************************************************
  2299. *
  2300. * motCpmCleanRxBd - reset receive buffer descriptor as empty
  2301. *
  2302. * This routine resets receive buffer descriptor as empty
  2303. *
  2304. * RETURNS: N/A
  2305. */
  2307. LOCAL void motCpmCleanRxBd
  2308.     (
  2309.     END_CTRL * pDrvCtrl, /* pointer to END_CTRL structure */
  2310.     SCC_BUF * pRxBd /* receive buffer descriptor */
  2311.     )
  2312.     {
  2313.     /* reset buffer descriptor as empty */
  2315.     if (pRxBd->statusMode & SCC_ETHER_RX_BD_W)
  2316. pRxBd->statusMode = SCC_ETHER_RX_BD_E | SCC_ETHER_RX_BD_I |
  2317.     SCC_ETHER_RX_BD_W;
  2318.     else
  2319. pRxBd->statusMode = SCC_ETHER_RX_BD_E | SCC_ETHER_RX_BD_I;
  2321.     /* incr BD count */
  2323.     pDrvCtrl->ether.rxBdNext = (pDrvCtrl->ether.rxBdNext + 1) %
  2324. pDrvCtrl->ether.rxBdNum;
  2325.     }
  2327. /*******************************************************************************
  2328. *
  2329. * motCpmCleanTxBdQueue - clean the transmit buffer descriptor queue
  2330. *
  2331. * This routine cleans the transmit buffer queue. It doesn't look for 
  2332. * transmission errors, this is done at interrupt level in motCpmIntr.
  2333. *
  2334. * RETURNS: N/A
  2335. *
  2336. */
  2338. LOCAL void motCpmCleanTxBdQueue
  2339.     (
  2340.     END_CTRL *  pDrvCtrl /* pointer to END_CTRL structure */
  2341.     )
  2342.     {
  2343.     SCC_BUF *  pTxBd;
  2344.     int oldLevel;
  2346.     MOTCPMLOGMSG(("motCpmCleanTxBdQueue n", 0, 0, 0, 0, 0, 0));
  2348.     pDrvCtrl->txCleaning = TRUE;
  2350.     while (pDrvCtrl->txBdIndexC != pDrvCtrl->ether.txBdNext)
  2351. {
  2352. pTxBd = & pDrvCtrl->ether.txBdBase[pDrvCtrl->txBdIndexC];
  2354. /* if the data buffer has not been transmitted, don't touch it */
  2356. if (pTxBd->statusMode & SCC_ETHER_TX_BD_R)
  2357.     break;
  2359. oldLevel = intLock();
  2361. if (pDrvCtrl->freeRtn[pDrvCtrl->txBdIndexC] != NULL)
  2362.     {
  2363.     pDrvCtrl->freeRtn[pDrvCtrl->txBdIndexC]
  2364.     (pDrvCtrl->freeData[pDrvCtrl->txBdIndexC].arg1,
  2365.      pDrvCtrl->freeData[pDrvCtrl->txBdIndexC].arg2);
  2366.     pDrvCtrl->freeRtn[pDrvCtrl->txBdIndexC] = NULL;
  2367.     pDrvCtrl->freeData[pDrvCtrl->txBdIndexC].arg1 = NULL;
  2368.     pDrvCtrl->freeData[pDrvCtrl->txBdIndexC].arg2 = NULL;
  2369.     }
  2371. intUnlock(oldLevel);
  2373. /* incr txBdIndexC */
  2375. pDrvCtrl->txBdIndexC = (pDrvCtrl->txBdIndexC + 1) %
  2376.        pDrvCtrl->ether.txBdNum;
  2377. }
  2379.     pDrvCtrl->txCleaning = FALSE;
  2380.     }
  2382. /* END OF FILE */