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

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

VxWorks

开发平台：

C/C++

mbcEnd.c：源码内容
  1. /* mbcEnd.c - Motorola 68302fads END network interface driver */
  3. /* Copyright 1996-2000 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01e,11jun00,ham  removed reference to etherLib.
  10. 01d,27jan00,dat  fixed use of NULL
  11. 01c,29mar99,dat  SPR 26119, documentation, usage of .bS/.bE
  12. 01b,13mar99,db   suppressed warnings. integrated driver(SPR #25386)
  13. 01a,28jan99,dra  written.
  14. */
  16. /*
  17. DESCRIPTION
  18. This is a driver for the Ethernet controller on the 68EN302 chip.  The device
  19. supports a 16-bit interface, data rates up to 10 Mbps, a dual-ported RAM, and
  20. transparent DMA.  The dual-ported RAM is used for a 64-entry CAM table, and a
  21. 128-entry buffer descriptor table.  The CAM table is used to set the Ethernet
  22. address of the Ethernet device or to program multicast addresses.  The buffer
  23. descriptor table is partitioned into fixed-size transmit and receive tables.
  24. The DMA operation is transparent and transfers data between the internal FIFOs
  25. and external buffers pointed to by the receive and transmit-buffer descriptors
  26. during transmits and receives.
  28. The driver requires that the memory used for transmit and receive buffers be
  29. allocated in cache-safe RAM area.  
  31. Up to 61 multicast addresses are supported.  Multicast addresses are
  32. supported by adding the multicast ethernet addresses to the address
  33. table in the ethernet part.  If more than 61 multicast addresses are
  34. desired, address hashing must be used (the address table holds 62
  35. entries at most). However, address hashing does not appear to work in
  36. this ethernet part.
  38. A glitch in the EN302 Rev 0.1 device causes the Ethernet transmitter to
  39. lock up from time to time. The driver uses a watchdog timer to reset the
  40. Ethernet device when the device runs out of transmit buffers and cannot
  41. recover within 20 clock ticks.
  43. BOARD LAYOUT
  44. This device is on-chip.  No jumpering diagram is necessary.  
  46. EXTERNAL INTERFACE
  47. The only external interface is the mbcEndLoad() routine, which expects
  48. the <initString> parameter as input.  This parameter passes in a 
  49. colon-delimited string of the format:
  51. unit:memAddr:ivec:txBdNum:rxBdNum:dmaParms:bufBase:offset
  53. TARGET-SPECIFIC PARAMETERS
  54. .IP <unit>
  55. A convenient holdover from the former model.  This parameter is used only
  56. in the string name for the driver.
  57. .IP <memAddr>
  58. This parameter is the base address of the Ethernet module. The driver
  59. addresses all other Ethernet device registers as offsets from this address.
  60. .IP <ivec>
  61. The interrupt vector to be used in connecting the interrupt handler.
  62. .IP <txBdNum>
  63. The number of transmit buffer descriptors to use.
  64. .IP <rxBdNum>
  65. The number of receive buffer descriptors to use.
  67. The number of transmit and receive buffer descriptors (BDs) used is
  68. configurable by the user while attaching the driver.  Each BD is 8
  69. bytes in size and resides in the chip's dual-ported memory, while its
  70. associated buffer, 1520 bytes in size, resides in cache-safe
  71. conventional RAM. A minimum of 2 receive and 2 transmit BDs should be
  72. allocated.  If this parameter is 0, a default of 32 BDs will be used.
  73. The maximum number of BDs depends on how the dual-ported BD RAM is
  74. partitioned.  The 128 BDs in the dual-ported BD RAM can partitioned
  75. into transmit and receive BD regions with 8, 16, 32, or 64 transmit
  76. BDs and corresponding 120, 112, 96, or 64 receive BDs.
  77. .IP <dmaParms>
  78. Ethernet DMA parameters.
  80. This parameter is used to specify the settings of burst limit, water-mark, and
  81. transmit early, which control the Ethernet DMA, and is used to set the EDMA
  82. register.
  83. .IP <bufBase>
  84. Base address of the buffer pool.
  86. This parameter is used to notify the driver that space for the
  87. transmit and receive buffers need not be allocated, but should be
  88. taken from a cache-coherent private memory space provided by the user
  89. at the given address.  The user should be aware that memory used for
  90. buffers must be 4-byte aligned and non-cacheable.  All the buffers
  91. must fit in the given memory space; no checking will be performed.
  92. Each buffer is 1520 bytes.  If this parameter is "NULL", space for
  93. buffers will be obtained by calling cacheDmaMalloc() in mbcMemInit().
  94. .IP <offset>
  95. Specifies the memory alignment offset.
  97. .LP
  99. EXTERNAL SUPPORT REQUIREMENTS
  100. This driver requires several external support functions, defined as macros:
  101. .CS
  102.     SYS_INT_CONNECT(pDrvCtrl, routine, arg)
  103.     SYS_INT_DISCONNECT (pDrvCtrl, routine, arg)
  104.     SYS_INT_ENABLE(pDrvCtrl)
  105.     SYS_OUT_SHORT(pDrvCtrl, reg, data)
  106.     SYS_IN_SHORT(pDrvCtrl, reg, pData)
  107. .CE
  109. There are default values in the source code for these macros.  They presume
  110. memory-mapped accesses to the device registers and the normal intConnect(),
  111. and intEnable() BSP functions.  The first argument to each is the device
  112. controller structure. Thus, each has access back to all the device-specific
  113. information.  Having the pointer in the macro facilitates the addition 
  114. of new features to this driver.
  116. SYSTEM RESOURCE USAGE
  117. The driver requires the following system resources:
  119.     - one watchdog timer
  120.     - one interrupt vector
  121.     - 52 bytes in the initialized data section (data)
  122.     - 0 bytes in the uninitialized data section (bss)
  124. The above data and BSS requirements are for the MC68000 architecture
  125. and can vary for other architectures.  Code size (text) varies greatly 
  126. between architectures and is therefore not quoted here.
  128. If the driver allocates the memory shared with the Ethernet device
  129. unit, it does so by calling the cacheDmaMalloc() routine.  For the
  130. default case of 32 transmit buffers, 32 receive buffers, the total
  131. size requested is roughly 100,000 bytes.  If a memory region is
  132. provided to the driver, the size of this region is adjustable to suit
  133. user needs.
  135. This driver can only operate if the shared memory region is non-cacheable,
  136. or if the hardware implements bus snooping.  The driver cannot maintain
  137. cache coherency for the device because the buffers are asynchronously
  138. modified by both the driver and the device, and these fields may share the
  139. same cache line.  Additionally, the chip's dual-ported RAM must be
  140. declared as non-cacheable memory where applicable.
  142. INCLUDES:
  143. end.h endLib.h etherMultiLib.h
  145. SEE ALSO: muxLib, endLib
  146. .I "Writing and Enhanced Network Driver"
  147. */
  149. /* includes */
  151. #include "vxWorks.h"
  152. #include "stdlib.h"
  153. #include "cacheLib.h"
  154. #include "intLib.h"
  155. #include "end.h" /* Common END structures. */
  156. #include "endLib.h"
  157. #include "lstLib.h" /* Needed to maintain protocol list. */
  158. #include "wdLib.h"
  159. #include "iv.h"
  160. #include "semLib.h"
  161. #include "logLib.h"
  162. #include "netLib.h"
  163. #include "stdio.h"
  164. #include "sysLib.h"
  165. #include "errno.h"
  166. #include "errnoLib.h"
  167. #include "memLib.h"
  168. #include "iosLib.h"
  169. #undef ETHER_MAP_IP_MULTICAST
  170. #include "etherMultiLib.h" /* multicast stuff. */
  172. #include "net/mbuf.h"
  173. #include "net/unixLib.h"
  174. #include "net/protosw.h"
  175. #include "net/systm.h"
  176. #include "net/if_subr.h"
  177. #include "net/route.h"
  179. #include "sys/socket.h"
  180. #include "sys/ioctl.h"
  181. #include "sys/times.h"
  182. #include "drv/end/mbcEnd.h"
  184. /* defines */
  186. #define FRAME_MAX 1518 /* maximum frame size */
  187. #define FRAME_MIN 64 /* minimum frame size */
  188. #define ENET_ADDR_SIZE 6 /* size of ethernet src/dst addresses */
  189. #define TX_BD_MIN 2 /* minimum number of Tx buffer descriptors */
  190. #define RX_BD_MIN 2 /* minimum number of Rx buffer descriptors */
  191. #define TX_BD_DEFAULT 0x20 /* default number of Tx buffer descriptors */
  192. #define RX_BD_DEFAULT 0x20 /* default number of Rx buffer descriptors */
  193. #define WD_TIMEOUT 20 /* number of clock ticks for reset timeout */
  195. #define MBC_BUFSIZ      (1520)
  196. #define MBC_MIN_FBUF (1520) /* min first buffer size */
  197. #define EH_SIZE (14)
  198. #define MBC_SPEED_10M 10000000 /* 10Mbs */
  199. #define MBC_SPEED MBC_SPEED_10M
  201. /* Cache macros */
  203. #define MBC_CACHE_INVALIDATE(address, len) 
  204.         CACHE_DRV_INVALIDATE (&pDrvCtrl->cacheFuncs, (address), (len))
  206. #define MBC_CACHE_PHYS_TO_VIRT(address) 
  207.         CACHE_DRV_PHYS_TO_VIRT (&pDrvCtrl->cacheFuncs, (address))
  209. #define MBC_CACHE_VIRT_TO_PHYS(address) 
  210.         CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, (address))
  212. /*
  213.  * Default macro definitions for BSP interface.
  214.  * These macros can be redefined in a wrapper file, to generate
  215.  * a new module with an optimized interface.
  216.  */
  218. /* Macro to connect interrupt handler to vector */
  220. #ifndef SYS_INT_CONNECT
  221. #define SYS_INT_CONNECT(pDrvCtrl,rtn,arg,pResult) 
  222.     { 
  223.     IMPORT STATUS sysIntConnect(); 
  224.     *pResult = intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC ((pDrvCtrl)->ivec), 
  225.    rtn, (int)(arg)); 
  226.     }
  227. #endif
  229. /* Macro to disconnect interrupt handler from vector */
  231. LOCAL void dummyIsr (void) { };
  233. #ifndef SYS_INT_DISCONNECT
  234. #define SYS_INT_DISCONNECT(pDrvCtrl,rtn,arg,pResult) 
  235.     { 
  236.     IMPORT STATUS intConnect(); 
  237.     *pResult = intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC ((pDrvCtrl)->ivec), 
  238.     dummyIsr, (int)(arg)); 
  239.     }
  240. #endif
  242. /* Macro to get the ethernet address from the BSP */
  244. #ifndef SYS_ENET_ADDR_GET
  245. #define SYS_ENET_ADDR_GET(pAddress) 
  246.     { 
  247.     sysEnetAddrGet (pDrvCtrl->unit, (char *) (pAddress)); 
  248.     }
  249. #endif /* SYS_ENET_ADDR_GET */
  251. /*
  252.  * Macros to do a short (UINT16) access to the chip. Default
  253.  * assumes a normal memory mapped device.
  254.  */
  256. #ifndef SYS_OUT_SHORT
  257. #define SYS_OUT_SHORT(pDrvCtrl, addr, value) 
  258. (*(volatile UINT16 *)((pDrvCtrl)->memAddr + (addr)) = (value))
  259. #endif
  261. #ifndef SYS_IN_SHORT
  262. #define SYS_IN_SHORT(pDrvCtrl, addr, pData) 
  263. (*(pData) = (*(volatile UINT16 *)((pDrvCtrl)->memAddr + (addr))))
  264. #endif
  266. #ifndef SYS_UPDATE_SHORT
  267. #define SYS_UPDATE_SHORT(pDrvCtrl, addr, val) 
  268. ((*(volatile UINT16 *)((pDrvCtrl)->memAddr + (addr))) |= (val))
  269. #endif
  271. #ifndef SYS_RESET_SHORT
  272. #define SYS_RESET_SHORT(pDrvCtrl, addr, val) 
  273. ((*(volatile UINT16 *)((pDrvCtrl)->memAddr + (addr))) &= ~(val))
  274. #endif
  275.     
  276. /* A shortcut for getting the hardware address from the MIB II stuff. */
  278. #define END_HADDR(pEnd)
  279. ((pEnd)->mib2Tbl.ifPhysAddress.phyAddress)
  281. #define END_HADDR_LEN(pEnd) 
  282. ((pEnd)->mib2Tbl.ifPhysAddress.addrLength)
  284. /* Definitions for the flags field */
  286. #define MBC_POLLING 0x1
  287. #define MBC_MEM_ALLOC_FLAG      0x2
  289. /* DEBUG MACROS */
  291. #undef DRV_DEBUG
  292. #ifdef DRV_DEBUG
  293. #define DRV_DEBUG_OFF 0x0000
  294. #define DRV_DEBUG_RX 0x0001
  295. #define DRV_DEBUG_TX 0x0002
  296. #define DRV_DEBUG_INT 0x0004
  297. #define DRV_DEBUG_POLL (DRV_DEBUG_POLL_RX | DRV_DEBUG_POLL_TX)
  298. #define DRV_DEBUG_POLL_RX 0x0008
  299. #define DRV_DEBUG_POLL_TX 0x0010
  300. #define DRV_DEBUG_LOAD 0x0020
  301. #define DRV_DEBUG_IOCTL 0x0040
  302. #define DRV_DEBUG_MULTI 0x0080
  303. #define DRV_DEBUG_ERROR 0x0100
  305. int mbcDebug = DRV_DEBUG_ERROR;
  307. #define DRV_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)
  308.     do
  309.         {
  310. if (mbcDebug & (FLG))
  311.     logMsg (X0, X1, X2, X3, X4, X5, X6);
  312. }
  313.     while (0)
  315. #define DRV_PRINT(FLG, X)
  316.     do
  317.         {
  318. if (mbcDebug & (FLG))
  319.     printf X;
  320. }
  321.     while (0)
  323. #else /* DRV_DEBUG */
  324.     
  325. #define DRV_LOG(FLG, X0, X1, X2, X3, X4, X5, X6) do {} while (0)
  326. #define DRV_PRINT(FLG, X) do {} while (0)
  327.     
  328. #endif /* DRV_DEBUG */
  330. /* typedefs */
  332. typedef struct free_args
  333.     {
  334.     void * arg1;
  335.     void * arg2;
  336.     } FREE_ARGS;
  337.         
  338. /* The definition of the driver control structure */
  339. typedef struct MBC_DEVICE
  340.     {
  341.     END_OBJ     end; /* The class we inherit from. */
  342.     int unit; /* unit number */
  343.     int         ivec;                   /* interrupt vector */
  344.     WDOG_ID wdId; /* watchdog id */
  345.     UCHAR * memAddr; /* address of mbc's shared memory */
  346.     int txBdNum; /* number of tx buffer descriptors */
  347.     int rxBdNum; /* number of rx buffer descriptors */
  348.     int dmaParms; /* DMA parameters */
  349.     int         offset; /* packet data offset */
  350.     UCHAR enetAddr[6]; /* ethernet address */    
  351.     ULONG flags; /* Our local flags. */
  352.     BOOL txBlocked; /* TX is blocked */
  353.     BOOL txCleaning; /* TX is being cleaned */
  354.     BOOL rxHandling; /* rcv task is scheduled */
  355.     char * bufBase; /* address of memory pool; */
  356.     int bdSize; /* buffer descriptor size */
  357.     MBC_BD * txBdBase; /* transmit BD array address */
  358.     MBC_BD * rxBdBase; /* receive BD array address */
  359.     int txBdNext; /* next transmit BD to fill */
  360.     int txClNext; /* next transmit BD to clean */
  361.     int rxBdNext; /* next receive BD to read */
  362.     int resetCounter; /* number of times the device reset */
  363.     CACHE_FUNCS cacheFuncs;             /* cache function pointers */
  364.     UCHAR mcastFilter[8]; /* multicast address mask */
  365.     FUNCPTR     freeRtn[128];           /* Array of free routines. */
  366.     struct free_args    freeData[128];  /* Array of free arguments */
  367.                                         /* to the free routines. */
  368.     CL_POOL_ID pClPoolId; /* cluster pool */
  369.     } MBC_DEVICE;
  371. /* globals */
  373. IMPORT STATUS sysEnetAddrGet (int unit, char * addr);
  374. IMPORT int endMultiLstCnt (END_OBJ * pEnd);
  377. /* locals */
  379. /* forward static functions */
  381. LOCAL void mbcReset (MBC_DEVICE * pDrvCtrl);
  382. LOCAL void mbcInt (MBC_DEVICE * pDrvCtrl);
  383. LOCAL void mbcHandleRcvInt (MBC_DEVICE * pDrvCtrl);
  384. LOCAL STATUS mbcRecv (MBC_DEVICE * pDrvCtrl, char * pData);
  385. LOCAL void mbcConfig (MBC_DEVICE * pDrvCtrl);
  386. LOCAL STATUS mbcInit (MBC_DEVICE * pDrvCtrl);
  387. LOCAL void mbcAddrFilterSet(MBC_DEVICE * pDrvCtrl);
  388. LOCAL void mbcScrubTRing (MBC_DEVICE * pDrvCtrl);
  389. LOCAL STATUS mbcPollStart (MBC_DEVICE * pDrvCtrl);
  390. LOCAL STATUS mbcPollStop (MBC_DEVICE * pDrvCtrl);
  391. LOCAL void mbcDeviceRestart(MBC_DEVICE * pDrvCtrl);
  392. LOCAL STATUS mbcParse (MBC_DEVICE * pDrvCtrl, char * initString);
  393. LOCAL STATUS mbcMemInit (MBC_DEVICE * pDrvCtrl);
  395. /* END Specific interfaces. */
  397. /* This is the only externally visible interface. */
  399. END_OBJ *  mbcEndLoad (char * initString);
  401. LOCAL STATUS mbcStart (void * pDrvCtrl);
  402. LOCAL STATUS mbcStop (void * pDrvCtrl);
  403. LOCAL STATUS mbcUnload (void * pDrvCtrl);
  404. LOCAL int mbcIoctl (void * pDrvCtrl, int cmd, caddr_t data);
  405. LOCAL STATUS mbcSend (void * pDrvCtrl, M_BLK_ID pBuf);
  406. LOCAL STATUS mbcMCastAdd (void * pDrvCtrl, char * pAddress);
  407. LOCAL STATUS mbcMCastDel (void * pDrvCtrl, char * pAddress);
  408. LOCAL STATUS mbcMCastGet (void * pDrvCtrl, MULTI_TABLE * pTable);
  409. LOCAL STATUS mbcPollSend (void * pDrvCtrl, M_BLK_ID pBuf);
  410. LOCAL STATUS mbcPollRcv (void * pDrvCtrl, M_BLK_ID pBuf);
  412. /*
  413.  * Declare our function table.  This is static across all driver
  414.  * instances.
  415.  */
  417. LOCAL NET_FUNCS mbcFuncTable =
  418.     {
  419.     (FUNCPTR) mbcStart,    /* Function to start the device. */
  420.     (FUNCPTR) mbcStop,    /* Function to stop the device. */
  421.     (FUNCPTR) mbcUnload,   /* Unloading function for the driver. */
  422.     (FUNCPTR) mbcIoctl,    /* Ioctl function for the driver. */
  423.     (FUNCPTR) mbcSend,    /* Send function for the driver. */
  424.     (FUNCPTR) mbcMCastAdd, /* Multicast add function for the  driver*/
  425.     (FUNCPTR) mbcMCastDel, /* Multicast delete function for driver */
  426.     (FUNCPTR) mbcMCastGet, /* Multicast retrieve function for driver*/
  427.     (FUNCPTR) mbcPollSend, /* Polling send function */
  428.     (FUNCPTR) mbcPollRcv,  /* Polling receive function */
  429.     endEtherAddressForm,   /* put address info into a NET_BUFFER */
  430.     endEtherPacketDataGet, /* get pointer to data in NET_BUFFER */
  431.     endEtherPacketAddrGet  /* Get packet addresses. */
  432.     };
  434. /******************************************************************************
  435. *
  436. * mbcEndLoad - initialize the driver and device
  437. *
  438. * This routine initializes the driver and the device to the operational state.
  439. * All of the device specific parameters are passed in the initString.
  440. *
  441. * The string contains the target specific parameters like this:
  442. *
  443. * "unit:memAddr:ivec:txBdNum:rxBdNum:dmaParms:bufBase:offset"
  444. * 
  445. * RETURNS: An END object pointer or NULL on error.
  446. */
  448. END_OBJ* mbcEndLoad
  449.     (
  450.     char * initString /* String to be parsed by the driver. */
  451.     )
  452.     {
  453.     MBC_DEVICE * pDrvCtrl;
  454.       
  455.     if (initString == NULL)
  456.         return (NULL);
  457.     
  458.     if (initString[0] == 0)
  459.         {
  460.         bcopy ((char *)DEV_NAME, initString, DEV_NAME_LEN);
  461.         return (NULL);
  462.         }
  463.  
  464.     DRV_LOG (DRV_DEBUG_LOAD, "Loading mbc...n", 1, 2, 3, 4, 5, 6);
  465.    
  466.     /* allocate the device structure */
  468.     pDrvCtrl = (MBC_DEVICE *) calloc (sizeof (MBC_DEVICE), 1);
  469.     if (pDrvCtrl == NULL)
  470. goto errorExit;
  471.           
  472.     /* parse the init string, filling in the device structure */
  474.     if (mbcParse (pDrvCtrl, initString) == ERROR)
  475. goto errorExit;
  477.     /* Ask the BSP to provide the ethernet address. */
  478.     
  479.     SYS_ENET_ADDR_GET (&pDrvCtrl->enetAddr);
  480.    
  481.     /* Allocate a watchdog timer */
  483.     pDrvCtrl->wdId = wdCreate ();
  484.     if (pDrvCtrl->wdId == NULL)
  485. goto errorExit;
  487.     /* initialize the END and MIB2 parts of the structure */
  489.     /*
  490.      * The M2 element must come from m2Lib.h 
  491.      * This mbcis set up for a DIX type ethernet device.
  492.      */
  493.     
  494.     if (END_OBJ_INIT (&pDrvCtrl->end, (DEV_OBJ *)pDrvCtrl, DEV_NAME,
  495.                       pDrvCtrl->unit, &mbcFuncTable,
  496.                       "END mbcDriver.") == ERROR)
  497. goto errorExit;
  498.     if (END_MIB_INIT (&pDrvCtrl->end, M2_ifType_ethernet_csmacd,
  499.                       &pDrvCtrl->enetAddr[0], 6, ETHERMTU,
  500.                       MBC_SPEED) == ERROR)
  501. goto errorExit;
  503.     /* Perform memory allocation/distribution */
  505.     if (mbcMemInit (pDrvCtrl) == ERROR)
  506. goto errorExit;
  508.     /* reset and reconfigure the device */
  510.     mbcReset (pDrvCtrl);
  511.     mbcInit (pDrvCtrl);
  512.     mbcConfig (pDrvCtrl);
  514.     /* set the flags to indicate readiness */
  516.     END_OBJ_READY (&pDrvCtrl->end,
  517.    IFF_UP | IFF_RUNNING | IFF_NOTRAILERS | IFF_BROADCAST
  518.    | IFF_MULTICAST);
  520.     DRV_LOG (DRV_DEBUG_RX, "%s%d: mbcEndLoad: offset=%dn",
  521.      (int) DEV_NAME, pDrvCtrl->unit, pDrvCtrl->offset, 0, 0, 0);
  523.     return (&pDrvCtrl->end);
  525. errorExit:
  526.     if (pDrvCtrl != NULL)
  527. {
  528. if (pDrvCtrl->wdId)
  529.     wdDelete (pDrvCtrl->wdId);
  530. free ((char *)pDrvCtrl);
  531. }
  533.     return (NULL);
  534.     }
  536. /******************************************************************************
  537. *
  538. * mbcParse - parse the init string
  539. *
  540. * Parse the input string.  Fill in values in the driver control structure.
  541. *
  542. * The initialization string format is:
  543. * .CS
  544. *    "unit:memAddr:ivec:txBdNum:rxBdNum:dmaParms:bufBase:offset"
  545. * .CE
  546. *
  547. * .IP <unit>
  548. * Device unit number, a small integer.
  549. * .IP <memAddr>
  550. * ethernet module base address.
  551. * .IP <ivec>
  552. * Interrupt vector number (used with sysIntConnect)
  553. * .IP <txBdNum>
  554. * transmit buffer descriptor
  555. * .IP <rxBdNum>
  556. * receive buffer descriptor
  557. * .IP <dmaParms>
  558. * dma parameters
  559. * .IP <bufBase>
  560. * address of memory pool
  561. * .IP <offset>
  562. * packet data offset 
  563. * .LP
  564. *
  565. * RETURNS: OK or ERROR for invalid arguments.
  566. */
  568. STATUS mbcParse
  569.     (
  570.     MBC_DEVICE * pDrvCtrl, /* device pointer */
  571.     char * initString /* information string */
  572.     )
  573.     {
  574.     char * tok;
  575.     char * pHolder = NULL;
  576.     
  577.     /* Parse the initString */
  579.     /* Unit number. */
  581.     tok = strtok_r (initString, ":", &pHolder);
  582.     if (tok == NULL)
  583. return (ERROR);
  584.     pDrvCtrl->unit = strtoul (tok, NULL, 16);
  586.     /* ethernet module base address */
  588.     tok = strtok_r (NULL, ":", &pHolder);
  589.     if (tok == NULL)
  590. return (ERROR);
  591.     pDrvCtrl->memAddr = (void *) strtoul (tok, NULL, 16);
  592.     
  593.     /* Interrupt vector. */
  595.     tok = strtok_r (NULL, ":", &pHolder);
  596.     if (tok == NULL)
  597. return (ERROR);
  598.     pDrvCtrl->ivec = strtoul (tok, NULL, 16);
  600.     /* number of transmit buffer descriptors */
  602.     tok = strtok_r (NULL, ":", &pHolder);
  603.     if (tok == NULL)
  604. return (ERROR);
  605.     pDrvCtrl->txBdNum = strtoul (tok, NULL, 16);
  607.     /* number of receive buffer descriptors */
  609.     tok = strtok_r (NULL, ":", &pHolder);
  610.     if (tok == NULL)
  611. return (ERROR);
  612.     pDrvCtrl->rxBdNum = strtoul (tok, NULL, 16);
  614.     /* DMA parameters */
  616.     tok = strtok_r (NULL, ":", &pHolder);
  617.     if (tok == NULL)
  618. return (ERROR);
  619.     pDrvCtrl->dmaParms = strtoul (tok, NULL, 16);
  621.     /* address of memory pool; NONE = malloc it */
  623.     tok = strtok_r (NULL, ":", &pHolder);
  624.     if (tok == NULL)
  625. return (ERROR);
  626.     pDrvCtrl->bufBase = (void *) strtoul (tok, NULL, 16);
  628.     /* packet data offset */
  630.     tok = strtok_r (NULL, ":", &pHolder);
  631.     if (tok == NULL)
  632. return (ERROR);
  633.     pDrvCtrl->offset = strtoul (tok, NULL, 16);
  635.     return (OK);
  636.     }
  638. /******************************************************************************
  639. *
  640. * mbcMemInit - initialize memory for the chip
  641. *
  642. * Allocates and initializes the memory pools for the mbc device.
  643. *
  644. * RETURNS: OK or ERROR.
  645. */
  647. STATUS mbcMemInit
  648.     (
  649.     MBC_DEVICE * pDrvCtrl /* device to be initialized */
  650.     )
  651.     {
  652.     MBC_BD * pBd;
  653.     int counter;
  654.     int bdSize;
  655.     int txBdMax;
  656.     int rxBdMax;
  657.     M_CL_CONFIG mbcMclBlkConfig;
  658.     CL_DESC mbcClDesc;
  660.     /* Setup the netPool */
  661.     
  662.     if ((pDrvCtrl->end.pNetPool = malloc (sizeof(NET_POOL))) == NULL)
  663.         return (ERROR);
  665.     /* Use default values if the parameters are NULL */
  667.     if (pDrvCtrl->txBdNum == 0)
  668.         pDrvCtrl->txBdNum = TX_BD_DEFAULT;
  669.     if (pDrvCtrl->rxBdNum == 0)
  670.         pDrvCtrl->rxBdNum = RX_BD_DEFAULT;
  672.     /* Use the default minimum value if the given value is smaller */
  674.     pDrvCtrl->txBdNum = max (TX_BD_MIN, pDrvCtrl->txBdNum);
  675.     pDrvCtrl->rxBdNum = max (RX_BD_MIN, pDrvCtrl->rxBdNum);
  676.     
  677.     /* Ensure that txBdNum, and rxBdNum are within range */
  678.     
  679.     if (pDrvCtrl->txBdNum > 64)
  680.         pDrvCtrl->txBdNum = 64;
  682.     for (bdSize = MBC_EDMA_BDS_8; bdSize <= MBC_EDMA_BDS_64; bdSize++) 
  683. {
  684. txBdMax = 1 << (bdSize + 3);   /* set txBdMax to (8, 16, 32, 64) */
  685.         rxBdMax = MBC_BD_MAX - txBdMax;
  686.         
  687.         if (pDrvCtrl->txBdNum <= txBdMax)
  688.             {
  689.             if (pDrvCtrl->rxBdNum > rxBdMax)
  690.                 pDrvCtrl->rxBdNum = rxBdMax;
  691.             break;
  692.             }
  693.         }
  695.     /* fill in the driver control parameters */
  696.     
  697.     pDrvCtrl->bdSize = bdSize;
  698.     pDrvCtrl->txBdBase = (MBC_BD *) ((int) pDrvCtrl->memAddr + MBC_EBD);
  699.     pDrvCtrl->rxBdBase = (MBC_BD *) ((int) pDrvCtrl->memAddr + MBC_EBD
  700.      + sizeof (MBC_BD) * (1 << (bdSize + 3)));
  701.     pDrvCtrl->txBdNext = 0;
  702.     pDrvCtrl->rxBdNext = 0;
  703.     pDrvCtrl->resetCounter = 0;
  705.     DRV_LOG (DRV_DEBUG_LOAD,
  706.      "%s%d: rxBdNum=%d txBdNum=%d rxBdBase=%x txBdBase=%xn",
  707.      (int) DEV_NAME, pDrvCtrl->unit,
  708.      pDrvCtrl->rxBdNum, pDrvCtrl->txBdNum,
  709.      (int) pDrvCtrl->rxBdBase, (int) pDrvCtrl->txBdBase);
  711.     mbcClDesc.clNum = 4 * (pDrvCtrl->rxBdNum + pDrvCtrl->txBdNum);
  712.     mbcClDesc.clSize = MEM_ROUND_UP (MBC_BUFSIZ + pDrvCtrl->offset);
  713.     mbcClDesc.memSize = (mbcClDesc.clNum * (mbcClDesc.clSize + 4)) + 4;
  715.     /* Calculate the total memory for all the M-Blks and CL-Blks. */
  717.     mbcMclBlkConfig.mBlkNum = mbcClDesc.clNum;
  718.     mbcMclBlkConfig.clBlkNum = mbcClDesc.clNum;
  719.     mbcMclBlkConfig.memSize =
  720.       (mbcMclBlkConfig.mBlkNum * (MSIZE + sizeof (long)))
  721.       + (mbcMclBlkConfig.clBlkNum * (CL_BLK_SZ + sizeof(long)));
  722.     mbcMclBlkConfig.memArea = (char *) memalign (sizeof(long),
  723.  mbcMclBlkConfig.memSize);
  724.     if (mbcMclBlkConfig.memArea == NULL)
  725. {
  726. free (pDrvCtrl->end.pNetPool);
  727. return (ERROR);
  728. }
  729.     
  730.     /* Allocate the memory for the clusters from cache safe memory. */
  731.     
  732.     if (pDrvCtrl->bufBase == NULL)
  733. {
  734. /* Get our own memory */
  735. pDrvCtrl->cacheFuncs = cacheDmaFuncs;
  736. pDrvCtrl->bufBase = (char *) cacheDmaMalloc (mbcClDesc.memSize);
  737. pDrvCtrl->flags |= MBC_MEM_ALLOC_FLAG;
  738. if (pDrvCtrl->bufBase == NULL)
  739.             {
  740.     DRV_LOG (DRV_DEBUG_LOAD | DRV_DEBUG_ERROR,
  741.      "%s%d: system memory unavailable (%d bytes)n",
  742.      (int) DEV_NAME, pDrvCtrl->unit, mbcClDesc.memSize,
  743.      4, 5, 6);
  744.     free (pDrvCtrl->end.pNetPool);
  745.     free (mbcMclBlkConfig.memArea);
  746.     return (ERROR);
  747.     }
  748. }
  749.     else
  750. {
  751. /* Caller provided memory */
  752. pDrvCtrl->cacheFuncs = cacheNullFuncs;
  753. }
  754.    
  755.     mbcClDesc.memArea = pDrvCtrl->bufBase;
  756.     
  757.     /* Initialize the memory pool. */
  759.     if (netPoolInit(pDrvCtrl->end.pNetPool, &mbcMclBlkConfig,
  760.                     &mbcClDesc, 1, NULL) == ERROR)
  761.         {
  762.         DRV_LOG (DRV_DEBUG_LOAD | DRV_DEBUG_ERROR,
  763.  "Could not init bufferingn",
  764.  1, 2, 3, 4, 5, 6);
  765. free (pDrvCtrl->end.pNetPool);
  766. free (mbcMclBlkConfig.memArea);
  767. if (pDrvCtrl->flags & MBC_MEM_ALLOC_FLAG)
  768.     cacheDmaFree (pDrvCtrl->bufBase);
  769. return (ERROR);
  770.         }
  772.     /*
  773.      * If you need clusters to store received packets into then get them
  774.      * here ahead of time.
  775.      */
  776.     pDrvCtrl->pClPoolId = netClPoolIdGet (pDrvCtrl->end.pNetPool,
  777.   MBC_BUFSIZ, FALSE);
  778.     if (pDrvCtrl->pClPoolId == NULL)
  779. {
  780. free (pDrvCtrl->end.pNetPool);
  781. free (mbcMclBlkConfig.memArea);
  782. if (pDrvCtrl->flags & MBC_MEM_ALLOC_FLAG)
  783.     cacheDmaFree (pDrvCtrl->bufBase);
  784. return (ERROR);
  785. }
  786.     
  787.     /* take the device out of reset state */
  789.     SYS_OUT_SHORT (pDrvCtrl, MBC_ECNTL, MBC_ECNTL_RES_OFF);
  791.     /* set up transmit buffer descriptors, setting 'wrap' bit on last */
  792.     
  793.     pDrvCtrl->txBdNext = 0;
  794.     pDrvCtrl->txClNext = 0;
  795.     pBd = pDrvCtrl->txBdBase;
  796.     for (counter = pDrvCtrl->txBdNum; counter; counter--, pBd++)
  797. {
  798.         pBd->statusMode = (MBC_TXBD_I | MBC_TXBD_L | MBC_TXBD_TC);
  799. pBd->dataPointer = NULL;
  800. }
  801.     pBd--;
  802.     pBd->statusMode |= MBC_TXBD_W;
  804.     /* set up the receive buffer descriptors, setting 'wrap' bit on last */
  806.     pDrvCtrl->rxBdNext = 0;
  807.     pBd = pDrvCtrl->rxBdBase;
  808.     for (counter = pDrvCtrl->rxBdNum; counter; counter--, pBd++)
  809. {
  810.         pBd->statusMode = MBC_RXBD_I;
  811. pBd->dataPointer = NULL;
  812. }
  813.     pBd--;
  814.     pBd->statusMode |= MBC_RXBD_W;
  816.     DRV_LOG (DRV_DEBUG_LOAD, "%s%d: Memory setup completen",
  817.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  818.       
  819.     return (OK);
  820.     }
  822. /******************************************************************************
  823. *
  824. * mbcInit - initialize the MBC network device
  825. * 
  826. * Mbc initializes registers, and enables interrupts.
  827. *
  828. * The complement of this routine is mbcReset().  Once a unit is reset by
  829. * mbcReset(), it may be re-initialized to a running state by this routine.
  830. *
  831. * RETURNS: OK or ERROR.
  832. *
  833. * SEE ALSO: mbcIoctl(), mbcReset()
  834. *
  835. */
  837. LOCAL STATUS mbcInit
  838.     (
  839.     MBC_DEVICE * pDrvCtrl
  840.     )
  841.     {
  842.     UINT16 regValue;
  843.     MBC_BD * pBd;
  844.     int counter;
  846.     DRV_LOG (DRV_DEBUG_LOAD, "%s%d: mbcInitn",
  847.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  849.     /* take the device out of reset state */
  851.     SYS_OUT_SHORT (pDrvCtrl, MBC_ECNTL, MBC_ECNTL_RES_OFF);
  853.     /*
  854.      * set up transmit buffer descriptors, setting 'wrap' bit on last.
  855.      * clean up any transmit buffers left behind.
  856.      */
  857.     
  858.     pDrvCtrl->txBdNext = 0;
  859.     pDrvCtrl->txClNext = 0;
  860.     pBd = pDrvCtrl->txBdBase;
  861.     for (counter = pDrvCtrl->txBdNum; counter; counter--, pBd++)
  862. {
  863. if ((pBd->dataPointer != NULL) && (pDrvCtrl->freeRtn[counter] != NULL))
  864.     pDrvCtrl->freeRtn[counter] (pDrvCtrl->freeData[counter].arg1,
  865. pDrvCtrl->freeData[counter].arg2); 
  866. pDrvCtrl->freeRtn[counter] = NULL;
  867. pDrvCtrl->freeData[counter].arg1 = NULL; 
  868. pDrvCtrl->freeData[counter].arg2 = NULL; 
  869. pBd->dataPointer = NULL;
  870.         pBd->statusMode = (MBC_TXBD_I | MBC_TXBD_L | MBC_TXBD_TC);
  871. }
  872.     pBd--;
  873.     pBd->statusMode |= MBC_TXBD_W;
  875.     /*
  876.      * set up the receive buffer descriptors, setting 'wrap' bit on last.
  877.      * Free up any old receive clusters left behind.
  878.      */
  880.     pDrvCtrl->rxBdNext = 0;
  881.     pBd = pDrvCtrl->rxBdBase;
  882.     for (counter = pDrvCtrl->rxBdNum; counter; counter--, pBd++)
  883. {
  884. char * pBuf;
  886. if (pBd->dataPointer != NULL)
  887.     netClFree (pDrvCtrl->end.pNetPool,
  888.        (pBd->dataPointer - pDrvCtrl->offset));
  889. pBuf = netClusterGet (pDrvCtrl->end.pNetPool, pDrvCtrl->pClPoolId);
  890. if (pBuf == NULL)
  891.     {
  892.             DRV_LOG (DRV_DEBUG_LOAD | DRV_DEBUG_ERROR,
  893.      "Could not get a buffern", 1, 2, 3, 4, 5, 6);
  894.             return (ERROR);
  895.     }
  896.         pBd->statusMode = (MBC_RXBD_E | MBC_RXBD_I);
  897. pBd->dataPointer = pBuf + pDrvCtrl->offset;
  898. }
  899.     pBd--;
  900.     pBd->statusMode |= MBC_RXBD_W;
  902.     /* set the interrupt vector number */
  904.     SYS_OUT_SHORT (pDrvCtrl, MBC_IVEC, pDrvCtrl->ivec);
  906.     /* set BD size and other DMA parameters */
  908.     regValue = pDrvCtrl->dmaParms | (pDrvCtrl->bdSize << MBC_EDMA_BDS_SHFT);
  909.     SYS_OUT_SHORT (pDrvCtrl, MBC_EDMA, regValue);
  911.     /*
  912.      * set the operating mode to, no internal loopback, no full duplex, and
  913.      * no hearbeat control.
  914.      */
  915.     
  916.     SYS_OUT_SHORT (pDrvCtrl, MBC_ECFG, 0);
  918.     /*
  919.      * set address control to, no hash enable, no index enable, no multicast,
  920.      * no physical address rejection.
  921.      */
  922.     
  923.     SYS_OUT_SHORT (pDrvCtrl, MBC_AR, 0x00);
  925.     /* set max receive frame size */
  927.     SYS_OUT_SHORT (pDrvCtrl, MBC_EMRBLR, FRAME_MAX);
  928.         
  929.     return (OK);
  930.     }
  932. /******************************************************************************
  933. *
  934. * mbcDeviceRestart - restart transmits
  935. *
  936. * This routine re-resets the Ethernet device. Since on a transmit lock
  937. * up, the transmitter can be restarted only by resetting the device, this
  938. * routine resets, and reinitializes the device.  The device reset counter will
  939. * be updated on each reset.
  940. *
  941. * RETURNS: N/A
  942. *
  943. * SEE ALSO: mbcInt(), mbcSend(), mbcPacketGet()
  944. *
  945. * NOMANUAL
  946. */
  948. LOCAL void mbcDeviceRestart
  949.     (
  950.     MBC_DEVICE * pDrvCtrl
  951.     )
  952.     {
  953.     mbcReset (pDrvCtrl);
  954.     mbcInit (pDrvCtrl);
  955.     }
  957. /******************************************************************************
  958. *
  959. * mbcConfig - reconfigure the interface under us.
  960. *
  961. * Reconfigure the interface setting promiscuous mode, and changing the
  962. * multicast interface list.
  963. *
  964. * RETURNS: N/A.
  965. *
  966. * NOMANUAL
  967. */
  969. LOCAL void mbcConfig
  970.     (
  971.     MBC_DEVICE * pDrvCtrl /* device to be re-configured */
  972.     )
  973.     {
  974.     int i;
  975.     int numMulti; /* Number of multicast addresses */
  976.     UINT16 regValue;
  978.     /* Determine the number of multicast addresses */
  980.     numMulti = END_MULTI_LST_CNT (&pDrvCtrl->end);
  982.     DRV_LOG (DRV_DEBUG_LOAD, "%s%d: mbcConfig: %d multicast addressesn",
  983.      (int) DEV_NAME, pDrvCtrl->unit, numMulti, 4, 5, 6);
  985.     /* install the ethernet address */
  986.     
  987.     bcopy ((char *) pDrvCtrl->enetAddr,
  988.            (char *) (pDrvCtrl->memAddr + MBC_ARTAB),
  989.            ENET_ADDR_SIZE);
  990.     
  991.     /*
  992.      * Setup address control w/o multicasting enabled, and write
  993.      * the entire address arrray.
  994.      */
  995.     
  996.     regValue = MBC_AR_MULTI_00;
  997.     if (END_FLAGS_GET(&pDrvCtrl->end) & IFF_PROMISC)
  998.         regValue |= MBC_AR_PROM;
  999.     SYS_OUT_SHORT (pDrvCtrl, MBC_AR, regValue);
  1001.     for (i = 1; i < MBC_ARTAB_SIZE; i++)
  1002.         {
  1003.         SYS_OUT_SHORT (pDrvCtrl, MBC_ARTAB + (i * 8), ~0);
  1004.         SYS_OUT_SHORT (pDrvCtrl, MBC_ARTAB + (i * 8) + 2, ~0);
  1005.         SYS_OUT_SHORT (pDrvCtrl, MBC_ARTAB + (i * 8) + 4, ~0);
  1006.         }
  1007.     
  1008.     /* Now install the multicast addresses or filter */
  1010.     if ((numMulti > 0) && (numMulti <= MBC_ARTAB_SIZE-1))
  1011. {
  1012. ETHER_MULTI * pCurr;
  1014. /* Install the multicast addresses directly in the table */
  1016. for (i = 1, pCurr = END_MULTI_LST_FIRST (&pDrvCtrl->end);
  1017.      pCurr != NULL;
  1018.      pCurr = END_MULTI_LST_NEXT(pCurr), ++i)
  1019.     {
  1020.     bcopy ((char *) &pCurr->addr,
  1021.    (char *) (pDrvCtrl->memAddr + MBC_ARTAB + i*8),
  1022.    ENET_ADDR_SIZE);
  1023.     }
  1024. }
  1025.     else if (numMulti > MBC_ARTAB_SIZE-1)
  1026. {
  1027. /* Setup the multicast filter */
  1029. mbcAddrFilterSet (pDrvCtrl);
  1031. DRV_LOG (DRV_DEBUG_LOAD | DRV_DEBUG_MULTI,
  1032.  "Multicast Filter 0-3 %02x:%02x:%02x:%02xn",
  1033.  pDrvCtrl->mcastFilter[0], pDrvCtrl->mcastFilter[1],
  1034.  pDrvCtrl->mcastFilter[2], pDrvCtrl->mcastFilter[3], 0, 0);
  1035. DRV_LOG (DRV_DEBUG_LOAD | DRV_DEBUG_MULTI,
  1036.  "Multicast Filter 4-7 %02x:%02x:%02x:%02xn",
  1037.  pDrvCtrl->mcastFilter[4], pDrvCtrl->mcastFilter[5],
  1038.  pDrvCtrl->mcastFilter[6], pDrvCtrl->mcastFilter[7], 0, 0);
  1040. /* Write out multicast filter */
  1042.         SYS_OUT_SHORT (pDrvCtrl, MBC_ARTAB + 0x01f0,
  1043.        (pDrvCtrl->mcastFilter[0] << 8)
  1044.        | pDrvCtrl->mcastFilter[1]);
  1045.         SYS_OUT_SHORT (pDrvCtrl, MBC_ARTAB + 0x01f2,
  1046.        (pDrvCtrl->mcastFilter[2] << 8)
  1047.        | pDrvCtrl->mcastFilter[3]);
  1048.         SYS_OUT_SHORT (pDrvCtrl, MBC_ARTAB + 0x01f8,
  1049.        (pDrvCtrl->mcastFilter[4] << 8)
  1050.        | pDrvCtrl->mcastFilter[5]);
  1051.         SYS_OUT_SHORT (pDrvCtrl, MBC_ARTAB + 0x01fa,
  1052.        (pDrvCtrl->mcastFilter[6] << 8)
  1053.        | pDrvCtrl->mcastFilter[7]);
  1055. /* Now enable multicast addressing */
  1057. SYS_IN_SHORT (pDrvCtrl, MBC_AR, &regValue);
  1058. regValue |= MBC_AR_HASH;
  1059. SYS_OUT_SHORT (pDrvCtrl, MBC_AR, regValue);
  1060. }
  1061.     }
  1063. /******************************************************************************
  1064. *
  1065. * mbcStart - start the device
  1066. *
  1067. * This function calls BSP functions to connect interrupts and start the
  1068. * device running in interrupt mode.
  1069. *
  1070. * RETURNS: OK or ERROR
  1071. *
  1072. * NOMANUAL
  1073. */
  1076. LOCAL STATUS mbcStart
  1077.     (
  1078.     void * pObj /* device ID */
  1079.     )
  1080.     {
  1081.     STATUS  result;
  1082.     MBC_DEVICE * pDrvCtrl = pObj; /* device to be started */
  1084.     DRV_LOG (DRV_DEBUG_LOAD, "%s%d: mbcStartn",
  1085.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1087.     SYS_INT_CONNECT (pDrvCtrl, mbcInt, (int)pDrvCtrl, &result);
  1088.     if (result == ERROR)
  1089. return (ERROR);
  1091.     DRV_LOG (DRV_DEBUG_LOAD, "Interrupt connected.n", 1, 2, 3, 4, 5, 6);
  1093.     /* enable interrupts - clear events and set mask */
  1095.     SYS_OUT_SHORT (pDrvCtrl, MBC_IEVNT, 0xffff);
  1096.     SYS_OUT_SHORT (pDrvCtrl, MBC_IMASK, MBC_IMASK_RXF | MBC_IMASK_EBE);
  1098.     /* enable the device */
  1100.     SYS_UPDATE_SHORT (pDrvCtrl, MBC_ECNTL, MBC_ECNTL_ENBL);
  1101.     
  1102.     DRV_LOG (DRV_DEBUG_LOAD, "interrupt enabled.n", 1, 2, 3, 4, 5, 6);
  1104.     return (OK);
  1105.     }
  1107. /******************************************************************************
  1108. *
  1109. * mbcInt - handle controller interrupt
  1110. *
  1111. * This routine is called at interrupt level in response to an interrupt from
  1112. * the controller.
  1113. *
  1114. * RETURNS: N/A.
  1115. */
  1117. LOCAL void mbcInt
  1118.     (
  1119.     MBC_DEVICE * pDrvCtrl /* interrupting device */
  1120.     )
  1121.     {
  1122.     UINT16  mask;
  1123.     UINT16  events;
  1125.     /* identify and acknowledge all interrupt events */
  1127.     SYS_IN_SHORT (pDrvCtrl, MBC_IEVNT, &events);
  1128.     SYS_IN_SHORT (pDrvCtrl, MBC_IMASK, &mask);
  1129.     events = (events & (mask | MBC_IMASK_BSY));
  1130.     SYS_OUT_SHORT (pDrvCtrl, MBC_IEVNT, events);
  1132.     DRV_LOG (DRV_DEBUG_INT,
  1133.      "%s%d: mbcInt events=%04x mask=%04xn",
  1134.      (int) DEV_NAME, pDrvCtrl->unit, events, mask, 0, 0);
  1136.     /* handle receive events */
  1138.     if (events & MBC_IEVNT_RXF)
  1139. {
  1140.         if (pDrvCtrl->rxHandling == FALSE)
  1141.             {
  1142.     pDrvCtrl->rxHandling = TRUE;
  1143.             netJobAdd ((FUNCPTR)mbcHandleRcvInt, (int)pDrvCtrl, 0, 0, 0, 0);
  1144.     }
  1145.         }
  1147.     /* handle transmitter events - BD full condition -> ever happen ? */
  1149.     if (events & MBC_IEVNT_TXF)
  1150. {
  1151. DRV_LOG (DRV_DEBUG_INT | DRV_DEBUG_ERROR,
  1152.  "%s%d: mbcInt: transmit fulln",
  1153.  (int) DEV_NAME, pDrvCtrl->unit, 0, 0, 0, 0);
  1154.      
  1155.         wdCancel (pDrvCtrl->wdId);
  1157. if (pDrvCtrl->txBlocked) /* cause a restart */
  1158.     {
  1159.     netJobAdd ((FUNCPTR)muxTxRestart, (int) &pDrvCtrl->end,
  1160.        0, 0, 0, 0);
  1161.     pDrvCtrl->txBlocked = FALSE;
  1162.     }
  1163. SYS_RESET_SHORT (pDrvCtrl, MBC_IMASK, MBC_IEVNT_TXF);
  1164. }
  1166.     /*
  1167.      * check for input busy condition, we don't enable this interrupt
  1168.      * but we check for it with each interrupt.
  1169.      */
  1171.     if (events & MBC_IEVNT_BSY)
  1172. {
  1173. DRV_LOG (DRV_DEBUG_INT | DRV_DEBUG_ERROR,
  1174.  "%s%d: mbcInt: input busyn",
  1175.  (int) DEV_NAME, pDrvCtrl->unit, 0, 0, 0, 0);
  1176.         /* count discarded frames as errors */
  1177. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1178. }
  1180.     /* restart the transmitter on a ethernet bus error */
  1181.     if (events & MBC_IEVNT_EBE)
  1182.         {
  1183. DRV_LOG (DRV_DEBUG_INT | DRV_DEBUG_ERROR,
  1184.  "%s%d: mbcInt: ethernet bus errorn",
  1185.  (int) DEV_NAME, pDrvCtrl->unit, 0, 0, 0, 0);
  1187. netJobAdd ((FUNCPTR)mbcDeviceRestart, (int) pDrvCtrl, 0, 0, 0, 0);
  1188. }
  1190.     if (!pDrvCtrl->txCleaning)
  1191.         {
  1192.         pDrvCtrl->txCleaning = TRUE;
  1193.         netJobAdd ((FUNCPTR)mbcScrubTRing, (int) pDrvCtrl, 0, 0, 0, 0);
  1194.         }
  1196.     /* ignore and reset all other events */
  1198.     SYS_OUT_SHORT (pDrvCtrl, MBC_IEVNT, ~mask);
  1199.     }
  1201. /******************************************************************************
  1202. *
  1203. * mbcScrubTRing - clean the transmit ring
  1204. *
  1205. * Cleans the transmit ring.
  1206. *
  1207. * RETURNS: N/A
  1208. *
  1209. * NOMANUAL
  1210. */
  1212. LOCAL void mbcScrubTRing
  1213.     (
  1214.     MBC_DEVICE * pDrvCtrl
  1215.     )
  1216.     {
  1217.     int oldLevel;
  1218.     volatile MBC_BD * pTxBd;
  1219.     
  1220.     pDrvCtrl->txCleaning = TRUE;
  1221.     pTxBd = &pDrvCtrl->txBdBase [pDrvCtrl->txClNext];
  1222.     while (pTxBd->dataPointer != NULL)
  1223.         {
  1224.         /* If the buffer is still owned by MBC, don't touch it */
  1226. if (pTxBd->statusMode & MBC_TXBD_R)
  1227.     break;
  1229.         oldLevel = intLock ();
  1230.         if (pDrvCtrl->freeRtn[pDrvCtrl->txClNext] != NULL)
  1231.             {
  1232.             pDrvCtrl->freeRtn[pDrvCtrl->txClNext]
  1233.       (pDrvCtrl->freeData[pDrvCtrl->txClNext].arg1,
  1234.        pDrvCtrl->freeData[pDrvCtrl->txClNext].arg2); 
  1235.             pDrvCtrl->freeRtn[pDrvCtrl->txClNext] = NULL;
  1236.             pDrvCtrl->freeData[pDrvCtrl->txClNext].arg1 = NULL; 
  1237.             pDrvCtrl->freeData[pDrvCtrl->txClNext].arg2 = NULL; 
  1238.             }
  1239.         
  1240. pTxBd->dataPointer = NULL;
  1241. pTxBd->statusMode &= ~MBC_TXBD_ERRS;
  1243.         /* now bump the disposal index pointer around the ring */
  1245. pDrvCtrl->txClNext = (pDrvCtrl->txClNext + 1) % pDrvCtrl->txBdNum;
  1246. pTxBd = &pDrvCtrl->txBdBase [pDrvCtrl->txClNext];
  1247.         intUnlock (oldLevel);
  1248.         }
  1249.     pDrvCtrl->txCleaning = FALSE;
  1250.     }
  1252. /******************************************************************************
  1253. *
  1254. * mbcSend - the driver send routine
  1255. *
  1256. * This routine takes a M_BLK_ID sends off the data in the M_BLK_ID.
  1257. * The buffer must already have the addressing information properly installed
  1258. * in it.  This is done by a higher layer.
  1259. *
  1260. * RETURNS: OK or ERROR.
  1261. */
  1263. LOCAL STATUS mbcSend
  1264.     (
  1265.     void * pObj, /* device ptr */
  1266.     M_BLK_ID pMblk /* data to send */
  1267.     )
  1268.     {
  1269.     int len;
  1270.     char * pBuf;
  1271.     char * pOrig;
  1272.     int oldLevel;
  1273.     MBC_DEVICE * pDrvCtrl = pObj;
  1274.     volatile MBC_BD * pTxBd;
  1275.     
  1276.     DRV_LOG (DRV_DEBUG_TX,
  1277.      "%s%d: mbcSend txBlocked=%d txCleaning=%dn",
  1278.      (int) DEV_NAME, pDrvCtrl->unit,
  1279.      pDrvCtrl->txBlocked, pDrvCtrl->txCleaning, 5, 6);
  1281.     /*
  1282.      * Obtain exclusive access to transmitter.  This is necessary because
  1283.      * we might have more than one stack transmitting at once.
  1284.      */
  1286.     if (!(pDrvCtrl->flags & MBC_POLLING))
  1287. END_TX_SEM_TAKE (&pDrvCtrl->end, WAIT_FOREVER);
  1289.     /* check if a transmit buffer descriptor is available */
  1291.     pTxBd = &pDrvCtrl->txBdBase [pDrvCtrl->txBdNext];
  1292.     if (pTxBd->statusMode & MBC_TXBD_R)
  1293. {
  1294. DRV_LOG (DRV_DEBUG_TX | DRV_DEBUG_ERROR,
  1295.  "%s%d: mbcSend: #%d still readyn",
  1296.  (int) DEV_NAME, pDrvCtrl->unit,
  1297.  pDrvCtrl->txBdNext, 4, 5, 6);
  1298. wdStart (pDrvCtrl->wdId, WD_TIMEOUT, (FUNCPTR) mbcDeviceRestart,
  1299.  (int) pDrvCtrl);
  1300. pDrvCtrl->txBlocked = TRUE;
  1301. SYS_UPDATE_SHORT (pDrvCtrl, MBC_IMASK, MBC_IEVNT_TXF);
  1302. if (!(pDrvCtrl->flags & MBC_POLLING))
  1303.     END_TX_SEM_GIVE (&pDrvCtrl->end);
  1304. return (END_ERR_BLOCK);
  1305. }
  1307.     if (pTxBd->dataPointer)
  1308. {
  1309. /* cleaning still needed, queue cleaning task */
  1311. DRV_LOG (DRV_DEBUG_TX | DRV_DEBUG_ERROR,
  1312.  "%s%d: mbcSend: #%d needs cleaning (cleaning=%d)n",
  1313.  (int) DEV_NAME, pDrvCtrl->unit,
  1314.   pDrvCtrl->txBdNext, pDrvCtrl->txCleaning, 5, 6);
  1315. pDrvCtrl->txBlocked = TRUE;
  1316. if (pDrvCtrl->txCleaning == FALSE)
  1317.     {
  1318.     pDrvCtrl->txCleaning = TRUE;
  1319.     netJobAdd ((FUNCPTR)mbcScrubTRing, (int) pDrvCtrl, 0, 0, 0, 0);
  1320.     }
  1321. if (!(pDrvCtrl->flags & MBC_POLLING))
  1322.     END_TX_SEM_GIVE (&pDrvCtrl->end);
  1323.         return (END_ERR_BLOCK);
  1324. }
  1326.     pOrig = pBuf = netClusterGet (pDrvCtrl->end.pNetPool, pDrvCtrl->pClPoolId);
  1327.     if (pBuf == NULL)
  1328.         {
  1329. DRV_LOG (DRV_DEBUG_TX | DRV_DEBUG_ERROR,
  1330.  "%s%d: mbcSend: out of clustersn",
  1331.  (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1332. if (!(pDrvCtrl->flags & MBC_POLLING))
  1333.     END_TX_SEM_GIVE (&pDrvCtrl->end);
  1334.         netMblkClChainFree (pMblk);
  1335.         return (ERROR);
  1336.         }
  1338.     pBuf += pDrvCtrl->offset;
  1339.     len = netMblkToBufCopy (pMblk, pBuf, NULL);
  1340.     netMblkClChainFree (pMblk); 
  1341.     len = max (len, ETHERSMALL);
  1343.     /* place a transmit request */
  1345.     if (!(pDrvCtrl->flags & MBC_POLLING))
  1346.         oldLevel = intLock ();
  1347.     
  1348.     pTxBd->dataPointer = pBuf;
  1349.     pTxBd->dataLength = len;
  1350.     pTxBd->statusMode &= ~(MBC_TXBD_ERRS|MBC_TXBD_RC);
  1351.     pTxBd->statusMode |= MBC_TXBD_R;
  1353.     /* Advance our management index, and register for cleaning */
  1355.     pDrvCtrl->txBdNext = (pDrvCtrl->txBdNext + 1) % pDrvCtrl->txBdNum;
  1357.     pDrvCtrl->freeRtn [pDrvCtrl->txBdNext] = (FUNCPTR) netClFree;
  1358.     pDrvCtrl->freeData [pDrvCtrl->txBdNext].arg1 = pDrvCtrl->end.pNetPool;
  1359.     pDrvCtrl->freeData [pDrvCtrl->txBdNext].arg2 = pOrig;
  1361.     if (!(pDrvCtrl->flags & MBC_POLLING))
  1362. {
  1363.         intUnlock (oldLevel);
  1364. END_TX_SEM_GIVE (&pDrvCtrl->end);
  1365. }
  1366.     
  1367.     /* Bump the statistic counter. */
  1369.     END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_UCAST, +1);
  1371.     return (OK);
  1372.     }
  1374. /******************************************************************************
  1375. *
  1376. * mbcPacketGet - get next received message
  1377. *
  1378. * Get next received message.  Returns NULL if none are
  1379. * ready.
  1380. *
  1381. * RETURNS: ptr to next packet, or NULL if none ready.
  1382. *
  1383. * NOMANUAL
  1384. */
  1386. char* mbcPacketGet
  1387.     (
  1388.     MBC_DEVICE * pDrvCtrl /* device structure */
  1389.     )
  1390.     {
  1391.     volatile MBC_BD * pRxBd;
  1392.     
  1393.     pRxBd = &pDrvCtrl->rxBdBase [pDrvCtrl->rxBdNext];
  1394.     
  1395.     while (!(pRxBd->statusMode & MBC_RXBD_E))
  1396.         {
  1397.         /* data chaining is not supported - check all error conditions */
  1399.         if (((pRxBd->statusMode & (MBC_RXBD_F  | MBC_RXBD_L))
  1400.                        == (MBC_RXBD_F  | MBC_RXBD_L)) &&
  1401.             !(pRxBd->statusMode & (MBC_RXBD_CL | MBC_RXBD_OV |
  1402.                                    MBC_RXBD_CR | MBC_RXBD_SH |
  1403.                                    MBC_RXBD_NO | MBC_RXBD_LG)))
  1404.     {
  1405.     return (pRxBd->dataPointer);
  1406.     }
  1408. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_UCAST, +1);
  1410. /*
  1411.  * Fix for errata #9 -- Device Errata, Feb 20, 1997.
  1412.  * Ethernet frames may be incorrectly received after a rx FIFO
  1413.  * overflow.
  1414.  */
  1415. if ((pRxBd->statusMode & MBC_RXBD_L)
  1416.     && !(pRxBd->statusMode & MBC_RXBD_F))
  1417.     {
  1418.     mbcDeviceRestart (pDrvCtrl);
  1419.     return (NULL);
  1420.     }
  1422.         /* reset buffer descriptor as empty */
  1424.         pRxBd->statusMode |= MBC_RXBD_E;
  1425.         
  1426.         /* Advance our management index */
  1428.         pDrvCtrl->rxBdNext = (pDrvCtrl->rxBdNext + 1) % pDrvCtrl->rxBdNum;
  1429.         pRxBd = &pDrvCtrl->rxBdBase [pDrvCtrl->rxBdNext];
  1430.         }
  1432.     return (NULL);
  1433.     }
  1435. /******************************************************************************
  1436. *
  1437. * mbcRecv - process the next incoming packet
  1438. *
  1439. * Handles one incoming packet.  The packet is checked for errors.
  1440. *
  1441. * RETURNS: OK.
  1442. *
  1443. * NOMANUAL
  1444. *
  1445. */
  1447. LOCAL STATUS mbcRecv
  1448.     (
  1449.     MBC_DEVICE * pDrvCtrl, /* device structure */
  1450.     char * pData /* packet to process */
  1451.     )
  1452.     {
  1453.     int len;
  1454.     M_BLK_ID pMblk;
  1455.     char * pNewCluster;
  1456.     char * pCluster;
  1457.     CL_BLK_ID pClBlk;
  1458.     volatile MBC_BD * pRxBd;
  1460.     pRxBd = &pDrvCtrl->rxBdBase [pDrvCtrl->rxBdNext];
  1462.     /*
  1463.      * We implicitly are loaning here, if copying is necessary this
  1464.      * step may be skipped, but the data must be copied before being
  1465.      * passed up to the protocols.
  1466.      */
  1467.     
  1468.     pNewCluster = netClusterGet (pDrvCtrl->end.pNetPool, pDrvCtrl->pClPoolId);
  1469.     if (pNewCluster == NULL)
  1470.         {
  1471. DRV_LOG (DRV_DEBUG_RX | DRV_DEBUG_ERROR,
  1472.  "%s%d: mbcRecv: out of clustersn",
  1473.  (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1474. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1475. goto cleanRXD;
  1476.         }
  1478.     /* Grab a cluster block to marry to the cluster we received. */
  1480.     pClBlk = netClBlkGet (pDrvCtrl->end.pNetPool, M_DONTWAIT);
  1481.     if (pClBlk == NULL)
  1482.         {
  1483. DRV_LOG (DRV_DEBUG_RX | DRV_DEBUG_ERROR,
  1484.  "%s%d: mbcRecv: out of cluster blocksn",
  1485.  (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1486.         netClFree (pDrvCtrl->end.pNetPool, pNewCluster);
  1487. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1488. goto cleanRXD;
  1489.         }
  1490.     
  1491.     /*
  1492.      * OK we've got a spare, let's get an M_BLK_ID and marry it to the
  1493.      * one in the ring.
  1494.      */
  1496.     pMblk = mBlkGet (pDrvCtrl->end.pNetPool, M_DONTWAIT, MT_DATA);
  1497.     if (pMblk == NULL)
  1498.         {
  1499. DRV_LOG (DRV_DEBUG_RX | DRV_DEBUG_ERROR,
  1500.  "%s%d: mbcRecv: out of M blocksn",
  1501.  (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1502.         netClBlkFree (pDrvCtrl->end.pNetPool, pClBlk); 
  1503.         netClFree (pDrvCtrl->end.pNetPool, pNewCluster);
  1504. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1505. goto cleanRXD;
  1506.         }
  1508.     DRV_LOG (DRV_DEBUG_RX,
  1509.      "%s%d: mbcRecv %d: dataLength=%d dataPointer=%x data=%xn",
  1510.      (int) DEV_NAME, pDrvCtrl->unit,
  1511.      pDrvCtrl->rxBdNext, pRxBd->dataLength,
  1512.      (int) pRxBd->dataPointer, (int) pData);
  1514.     /* Add one to our unicast data. */
  1516.     END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_UCAST, +1);
  1518.     len = pRxBd->dataLength;
  1519.     pCluster = pRxBd->dataPointer - pDrvCtrl->offset;
  1521.     /* Join the cluster to the MBlock */
  1523.     netClBlkJoin (pClBlk, pCluster, len, NULL, 0, 0, 0);
  1524.     netMblkClJoin (pMblk, pClBlk);
  1526.     pMblk->mBlkHdr.mData += pDrvCtrl->offset;
  1527.     pMblk->mBlkHdr.mLen = len;
  1528.     pMblk->mBlkHdr.mFlags |= M_PKTHDR;
  1529.     pMblk->mBlkPktHdr.len = len;
  1531.     /* make the packet data coherent */
  1533.     MBC_CACHE_INVALIDATE (pMblk->mBlkHdr.mData, len);
  1535.     /* Installed (adjusted) new cluster, and reset descriptor */
  1537.     pRxBd->dataPointer = pNewCluster + pDrvCtrl->offset;
  1538.     pRxBd->statusMode |= MBC_RXBD_E;
  1540.     /* Advance our management index */
  1542.     pDrvCtrl->rxBdNext = (pDrvCtrl->rxBdNext + 1) % pDrvCtrl->rxBdNum;
  1544. #ifdef DRV_DEBUG
  1545.     {
  1546.     char *pAddress = pCluster + pDrvCtrl->offset;
  1548.     if (pAddress[0] & 0x01)
  1549. DRV_LOG (DRV_DEBUG_RX | DRV_DEBUG_MULTI,
  1550.  "Recv Multicast %02x:%02x:%02x:%02x:%02x:%02xn",
  1551.  pAddress[0]&0xff, pAddress[1]&0xff, pAddress[2]&0xff,
  1552.  pAddress[3]&0xff, pAddress[4]&0xff, pAddress[5]&0xff);
  1553.     }
  1554. #endif
  1556.     /* Call the upper layer's receive routine. */
  1558.     END_RCV_RTN_CALL (&pDrvCtrl->end, pMblk);
  1560.     return (OK);
  1562. cleanRXD:
  1564.     /* Reset descriptor and advance management index */
  1566.     pRxBd->statusMode |= MBC_RXBD_E;
  1567.     pDrvCtrl->rxBdNext = (pDrvCtrl->rxBdNext + 1) % pDrvCtrl->rxBdNum;
  1569.     return (OK);
  1570.     }
  1572. /******************************************************************************
  1573. *
  1574. * mbcHandleRcvInt - task level interrupt service for input packets
  1575. *
  1576. * This routine is called at task level indirectly by the interrupt
  1577. * service routine to do any message received processing.
  1578. *
  1579. * The double loop is to protect against a race condition where the interrupt
  1580. * code see rxHandling as TRUE, but it is then turned off by task code.
  1581. * This race is not fatal, but does cause occassional delays until a second
  1582. * packet is received and then triggers the netTask to call this routine again.
  1583. *
  1584. * RETURNS: N/A.
  1585. */
  1587. LOCAL void mbcHandleRcvInt
  1588.     (
  1589.     MBC_DEVICE * pDrvCtrl /* interrupting device */
  1590.     )
  1591.     {
  1592.     char * pData;
  1594.     do
  1595.         {
  1596.         pDrvCtrl->rxHandling = TRUE;
  1598.         while ((pData = mbcPacketGet (pDrvCtrl)) != NULL)
  1599.             mbcRecv (pDrvCtrl, pData);
  1601.         pDrvCtrl->rxHandling = FALSE;
  1602.         }
  1603.     while (mbcPacketGet (pDrvCtrl) != NULL);
  1604.     }
  1606. /******************************************************************************
  1607. *
  1608. * mbcIoctl - the driver I/O control routine
  1609. *
  1610. * Process an ioctl request.
  1611. *
  1612. * RETURNS: A command specific response, usually OK or ERROR.
  1613. */
  1615. LOCAL int mbcIoctl
  1616.     (
  1617.     void * pObj, /* device receiving command */
  1618.     int cmd, /* ioctl command code */
  1619.     caddr_t data /* command argument */
  1620.     )
  1621.     {
  1622.     MBC_DEVICE * pDrvCtrl = pObj; /* device receiving command */
  1623.     int error = 0;
  1624.     long value;
  1626.     switch (cmd)
  1627.             {
  1628.         case EIOCSADDR:
  1629.     if (data == NULL)
  1630. return (EINVAL);
  1631.             bcopy ((char *)data, (char *)END_HADDR(&pDrvCtrl->end),
  1632.    END_HADDR_LEN(&pDrvCtrl->end));
  1633.             break;
  1635.         case EIOCGADDR:
  1636.     if (data == NULL)
  1637. return (EINVAL);
  1638.             bcopy ((char *)END_HADDR(&pDrvCtrl->end), (char *) data,
  1639.    END_HADDR_LEN(&pDrvCtrl->end));
  1640.             break;
  1642.         case EIOCSFLAGS:
  1643.     value = (long)data;
  1644.     if (value < 0)
  1645. {
  1646. value = -(value - 1);
  1647. END_FLAGS_CLR (&pDrvCtrl->end, value);
  1648. }
  1649.     else
  1650. {
  1651. END_FLAGS_SET (&pDrvCtrl->end, value);
  1652. }
  1653.     mbcConfig (pDrvCtrl);
  1654.             break;
  1656.         case EIOCGFLAGS:
  1657.     *(int *)data = END_FLAGS_GET(&pDrvCtrl->end);
  1658.             break;
  1660. case EIOCPOLLSTART: /* Begin polled operation */
  1661.     mbcPollStart (pDrvCtrl);
  1662.     break;
  1664. case EIOCPOLLSTOP: /* End polled operation */
  1665.     mbcPollStop (pDrvCtrl);
  1666.     break;
  1668.         case EIOCGMIB2: /* return MIB information */
  1669.             if (data == NULL)
  1670.                 return (EINVAL);
  1671.             bcopy ((char *)&pDrvCtrl->end.mib2Tbl, (char *) data,
  1672.    sizeof(pDrvCtrl->end.mib2Tbl));
  1673.             break;
  1674.     
  1675.         case EIOCGFBUF: /* return minimum First Buffer for chaining */
  1676.             if (data == NULL)
  1677.                 return (EINVAL);
  1678.             *(int *) data = MBC_MIN_FBUF;
  1679.             break;
  1680.     
  1681.         default:
  1682.             error = EINVAL;
  1683.         }
  1685.     return (error);
  1686.     }
  1688. /******************************************************************************
  1689. *
  1690. * mbcAddrFilterSet - set the address filter for multicast addresses
  1691. *
  1692. * This routine goes through all of the multicast addresses on the list
  1693. * of addresses (added with the endAddrAdd() routine) and sets the
  1694. * device's filter correctly.
  1695. *
  1696. * RETURNS: N/A.
  1697. */
  1699. void mbcAddrFilterSet
  1700.     (
  1701.     MBC_DEVICE * pDrvCtrl /* device to be updated */
  1702.     )
  1703.     {
  1704.     int len;
  1705.     int count;
  1706.     u_char c;
  1707.     u_char * pCp;
  1708.     u_long crc;
  1709.     ETHER_MULTI * pCurr;
  1710.     
  1711.     pDrvCtrl->mcastFilter[0] = 0x00;
  1712.     pDrvCtrl->mcastFilter[1] = 0x00;
  1713.     pDrvCtrl->mcastFilter[2] = 0x00;
  1714.     pDrvCtrl->mcastFilter[3] = 0x00;
  1715.     pDrvCtrl->mcastFilter[4] = 0x00;
  1716.     pDrvCtrl->mcastFilter[5] = 0x00;
  1717.     pDrvCtrl->mcastFilter[6] = 0x00;
  1718.     pDrvCtrl->mcastFilter[7] = 0x00;
  1720.     for (pCurr = END_MULTI_LST_FIRST (&pDrvCtrl->end);
  1721.  pCurr != NULL;
  1722.  pCurr = END_MULTI_LST_NEXT(pCurr))
  1723. {
  1724. /*
  1725.  * AUTODIN-II, adapted for ethernet (bit reversed),
  1726.  * taken from the ln7990End.c driver
  1727.  */
  1728. pCp = (unsigned char *)&pCurr->addr;
  1729. crc = 0xffffffff;
  1730. for (len = 6; --len >= 0;)
  1731.     {
  1732.     c = *pCp++;
  1733.     for (count = 0; count < 8; count++)
  1734. {
  1735. if ((c & 0x01) ^ (crc & 0x01))
  1736.     {
  1737.     crc >>= 1;
  1738.     crc = crc ^ 0xedb88320;
  1739.     }
  1740. else
  1741.     {
  1742.     crc >>= 1;
  1743.     }
  1744. c >>= 1;
  1745. }
  1746.     }
  1748. /* Just want the 6 most significant bits. */
  1749. crc = crc >> 26;
  1751. /* Turn on the corresponding bit in the filter. */
  1752. pDrvCtrl->mcastFilter [crc >> 3] |= (1 << (crc & 0x07));
  1753. }
  1754.     }
  1756. /******************************************************************************
  1757. *
  1758. * mbcPollRcv - routine to receive a packet in polled mode.
  1759. *
  1760. * This routine is called by a user to try and get a packet from the
  1761. * device.
  1762. *
  1763. * RETURNS: OK upon success.  EAGAIN is returned when no packet is available.
  1764. */
  1766. LOCAL STATUS mbcPollRcv
  1767.     (
  1768.     void *  pObj, /* device to be polled */
  1769.     M_BLK_ID pMblk /* ptr to buffer */
  1770.     )
  1771.     {
  1772.     int len;
  1773.     MBC_DEVICE * pDrvCtrl = pObj; /* device to be polled */
  1774.     volatile MBC_BD * pRxBd;
  1776.     pRxBd = &pDrvCtrl->rxBdBase [pDrvCtrl->rxBdNext];
  1777.     len = pRxBd->dataLength;
  1779.     /* If no packet is available return immediately */
  1781.     if (pRxBd->statusMode & MBC_RXBD_E)
  1782.         return (EAGAIN);
  1784.     /* Upper layer must provide a valid buffer. */
  1786.     if ((pMblk->mBlkHdr.mLen < len) || (!(pMblk->mBlkHdr.mFlags & M_EXT)))
  1787. {
  1788. DRV_LOG (DRV_DEBUG_POLL_RX, "%s%d: mbcPollRcv: rxBdNext=%d bad mblkn",
  1789.  (int) DEV_NAME, pDrvCtrl->unit, pDrvCtrl->rxBdNext, 4, 5, 6);
  1790. return (EAGAIN);
  1791. }
  1793.     /* Check packet and device for errors */
  1795.     if (((pRxBd->statusMode & (MBC_RXBD_F | MBC_RXBD_L))
  1796.  != (MBC_RXBD_F | MBC_RXBD_L))
  1797. || (pRxBd->statusMode & (MBC_RXBD_CL | MBC_RXBD_OV |
  1798.  MBC_RXBD_CR | MBC_RXBD_SH |
  1799.  MBC_RXBD_NO | MBC_RXBD_LG)))
  1800. {
  1801. /* packet has an error */
  1803. DRV_LOG (DRV_DEBUG_POLL_RX | DRV_DEBUG_ERROR,
  1804.  "%s%d: mbcPollRcv: rxBdNext=%d bad packet stat=%xn",
  1805.  (int) DEV_NAME, pDrvCtrl->unit, pDrvCtrl->rxBdNext,
  1806.  pRxBd->statusMode, 5, 6);
  1808. pRxBd->statusMode |= MBC_RXBD_E;
  1809. pDrvCtrl->rxBdNext = (pDrvCtrl->rxBdNext + 1) % pDrvCtrl->rxBdNum;
  1811.         return (EAGAIN);
  1812. }
  1814.     END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_UCAST, +1);
  1816.     pMblk->mBlkHdr.mData += pDrvCtrl->offset;
  1817.     bcopy (pRxBd->dataPointer, pMblk->mBlkHdr.mData, len);
  1818.     pMblk->mBlkHdr.mLen = len;
  1819.     pMblk->mBlkHdr.mFlags |= M_PKTHDR;
  1820.     pMblk->mBlkPktHdr.len = len;
  1822.     /* Done with packet, clean up and give it to the device. */
  1824.     pRxBd->statusMode |= MBC_RXBD_E;
  1825.     pDrvCtrl->rxBdNext = (pDrvCtrl->rxBdNext + 1) % pDrvCtrl->rxBdNum;
  1826.         
  1827.     DRV_LOG (DRV_DEBUG_POLL_RX,
  1828.      "%s%d: mbcPollRcv: rxBdNext=%d good packet len=%dn",
  1829.      (int) DEV_NAME, pDrvCtrl->unit, pDrvCtrl->rxBdNext,
  1830.      len, 5, 6);
  1832.     return (OK);
  1833.     }
  1835. /******************************************************************************
  1836. *
  1837. * mbcPollSend - routine to send a packet in polled mode.
  1838. *
  1839. * This routine is called by a user to try to send a packet on the
  1840. * device.
  1841. *
  1842. * RETURNS: OK upon success.  EAGAIN if device is busy.
  1843. */
  1845. LOCAL STATUS mbcPollSend
  1846.     (
  1847.     void *  pObj, /* device to be polled */
  1848.     M_BLK_ID    pMblk /* packet to send */
  1849.     )
  1850.     {
  1851.     char * pBuf = NULL;
  1852.     int len;
  1853.     int oldLevel;
  1854.     MBC_DEVICE * pDrvCtrl = pObj; /* device to be polled */
  1855.     volatile MBC_BD * pTxBd;
  1856.     
  1857.     /* test to see if TX is busy */
  1858.     
  1859.     pTxBd = &pDrvCtrl->txBdBase [pDrvCtrl->txBdNext];
  1860.     if (pTxBd->statusMode & MBC_TXBD_R)
  1861. {
  1862. DRV_LOG (DRV_DEBUG_POLL_TX | DRV_DEBUG_ERROR,
  1863.  "%s%d: mbcPollSend: no Tx desc. txBdNext=%dn",
  1864.  (int) DEV_NAME, pDrvCtrl->unit, pDrvCtrl->txBdNext, 4, 5, 6);
  1865. return (EAGAIN);
  1866. }
  1868.     /* Check if descriptor is clean */
  1870.     if (pTxBd->dataPointer)
  1871. {
  1872. DRV_LOG (DRV_DEBUG_POLL_TX | DRV_DEBUG_ERROR,
  1873.  "%s%d: mbcPollSend: needs cleaningn",
  1874.  (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1875. if (!pDrvCtrl->txCleaning == TRUE);
  1876.     netJobAdd ((FUNCPTR)mbcScrubTRing, (int) pDrvCtrl, 0, 0, 0, 0);
  1877. return (EAGAIN);
  1878. }
  1880.     /*
  1881.      * If packet is in a single block, we can transmit
  1882.      * directly from the M_BLK, otherwise we have to copy.
  1883.      */
  1884.     
  1885. #if 0 /* XXX */
  1886.     if (pMblk->mBlkHdr.mNext == NULL)
  1887.         {
  1888.         len = max (ETHERSMALL, pMblk->m_len);
  1889. pTxBd->dataPointer = pMblk->m_data;
  1890.         }
  1891.     else
  1892. #endif  /* 0 */
  1893.         {
  1894.         pBuf = netClusterGet (pDrvCtrl->end.pNetPool, pDrvCtrl->pClPoolId);
  1895.         if (pBuf == NULL)
  1896.     {
  1897.     DRV_LOG (DRV_DEBUG_POLL_TX | DRV_DEBUG_ERROR,
  1898.      "%s%d: mbcPollSend: no clustersn",
  1899.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1900.             return (EAGAIN);
  1901.     }
  1902.         len = netMblkToBufCopy (pMblk, pBuf, NULL);
  1903. pTxBd->dataPointer = pBuf;
  1904.         }
  1905.     
  1906.     DRV_LOG (DRV_DEBUG_POLL_TX, "%s%d: mbcPollSend: txBdNext=%d len=%dn",
  1907.      (int) DEV_NAME, pDrvCtrl->unit, pDrvCtrl->txBdNext, len, 5, 6);
  1909.     CACHE_PIPE_FLUSH ();
  1911.     /* Bump the statistic counter. */
  1913.     END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_UCAST, +1);
  1914.   
  1915.     /* Start transmission */
  1917.     oldLevel = intLock ();
  1918.     pTxBd->dataLength = len;
  1919.     pTxBd->statusMode &= ~(MBC_TXBD_ERRS|MBC_TXBD_RC);
  1920.     pTxBd->statusMode |= MBC_TXBD_R;
  1921.     intUnlock (oldLevel);
  1923.     /* Advance our management index. */
  1925.     pDrvCtrl->txBdNext = (pDrvCtrl->txBdNext + 1) % pDrvCtrl->txBdNum;
  1927.     /* Spin until packet has been sent. */
  1929.     while (pTxBd->statusMode & MBC_TXBD_R)
  1930. ;
  1932.     /* Manually clean descriptor. */
  1934.     pTxBd->dataPointer = NULL;
  1935.     pTxBd->statusMode &= ~MBC_TXBD_ERRS;
  1937.     /* Free allocated cluster (if any), and clean tx ring (if needed) */
  1939.     if (pBuf != NULL)
  1940.         netClFree (pDrvCtrl->end.pNetPool, pBuf);
  1941.     if (!pDrvCtrl->txCleaning)
  1942.         {
  1943.         pDrvCtrl->txCleaning = TRUE;
  1944.         mbcScrubTRing (pDrvCtrl);
  1945.         }
  1946.     
  1947.     return (OK);
  1948.     }
  1950. /******************************************************************************
  1951. *
  1952. * mbcMCastAdd - add a multicast address for the device
  1953. *
  1954. * This routine adds a multicast address to whatever the driver
  1955. * is already listening for.  It then resets the address filter.
  1956. *
  1957. * RETURNS: OK or ERROR.
  1958. */
  1960. LOCAL STATUS mbcMCastAdd
  1961.     (
  1962.     void * pObj, /* device pointer */
  1963.     char * pAddress /* new address to add */
  1964.     )
  1965.     {
  1966.     int error;
  1967.     MBC_DEVICE * pDrvCtrl = pObj; /* device pointer */
  1969.     DRV_LOG (DRV_DEBUG_LOAD | DRV_DEBUG_MULTI,
  1970.      "mbcMCastAdd %02x:%02x:%02x:%02x:%02x:%02xn",
  1971.      pAddress[0]&0xff, pAddress[1]&0xff, pAddress[2]&0xff,
  1972.      pAddress[3]&0xff, pAddress[4]&0xff, pAddress[5]&0xff);
  1974.     error = etherMultiAdd (&pDrvCtrl->end.multiList, pAddress);
  1975.     if (error == ENETRESET)
  1976. mbcConfig (pDrvCtrl);
  1978.     return (OK);
  1979.     }
  1981. /******************************************************************************
  1982. *
  1983. * mbcMCastDel - delete a multicast address for the device
  1984. *
  1985. * This routine removes a multicast address from whatever the driver
  1986. * is listening for.  It then resets the address filter.
  1987. *
  1988. * RETURNS: OK or ERROR.
  1989. */
  1991. LOCAL STATUS mbcMCastDel
  1992.     (
  1993.     void * pObj, /* device pointer */
  1994.     char * pAddress /* address to be deleted */
  1995.     )
  1996.     {
  1997.     int  error;
  1998.     MBC_DEVICE * pDrvCtrl = pObj; /* device pointer */
  2000.     DRV_LOG (DRV_DEBUG_LOAD | DRV_DEBUG_MULTI,
  2001.      "mbcMCastDel %02x:%02x:%02x:%02x:%02x:%02xn",
  2002.      pAddress[0]&0xff, pAddress[1]&0xff, pAddress[2]&0xff,
  2003.      pAddress[3]&0xff, pAddress[4]&0xff, pAddress[5]&0xff);
  2005.     error = etherMultiDel (&pDrvCtrl->end.multiList, pAddress);
  2006.     if (error == ENETRESET)
  2007. mbcConfig (pDrvCtrl);
  2009.     return (OK);
  2010.     }
  2012. /******************************************************************************
  2013. *
  2014. * mbcMCastGet - get the multicast address list for the device
  2015. *
  2016. * This routine gets the multicast list of whatever the driver
  2017. * is already listening for.
  2018. *
  2019. * RETURNS: OK or ERROR.
  2020. */
  2022. LOCAL STATUS mbcMCastGet
  2023.     (
  2024.     void * pObj, /* device pointer */
  2025.     MULTI_TABLE * pTable /* address table to be filled in */
  2026.     )
  2027.     {
  2028.     MBC_DEVICE * pDrvCtrl = pObj; /* device pointer */
  2030.     return (etherMultiGet (&pDrvCtrl->end.multiList, pTable));
  2031.     }
  2033. /******************************************************************************
  2034. *
  2035. * mbcStop - stop the device
  2036. *
  2037. * This function calls BSP functions to disconnect interrupts and stop
  2038. * the device from operating in interrupt mode.
  2039. *
  2040. * RETURNS: OK or ERROR.
  2041. */
  2043. LOCAL STATUS mbcStop
  2044.     (
  2045.     void * pObj /* device to be stopped */
  2046.     )
  2047.     {
  2048.     MBC_DEVICE * pDrvCtrl = pObj; /* device to be stopped */
  2049.     STATUS result = OK;
  2051.     /* stop/disable the device. */
  2052.     
  2053.     mbcReset (pDrvCtrl);
  2054.     
  2055.     SYS_INT_DISCONNECT (pDrvCtrl, mbcInt, (int)pDrvCtrl, &result);
  2057. #ifdef DRV_DEBUG
  2058.     if (result == ERROR)
  2059. {
  2060. DRV_LOG (DRV_DEBUG_LOAD | DRV_DEBUG_ERROR,
  2061.  "Could not disconnect interrupt!n",
  2062.  1, 2, 3, 4, 5, 6);
  2063. }
  2064. #endif /* DRV_DEBUG */
  2065.     return (result);
  2066.     }
  2068. /******************************************************************************
  2069. *
  2070. * mbcUnload - unload a driver from the system
  2071. *
  2072. * This function first brings down the device, and then frees any
  2073. * stuff that was allocated by the driver in the load function.
  2074. *
  2075. * RETURNS: OK.
  2076. */
  2078. LOCAL STATUS mbcUnload
  2079.     (
  2080.     void * pObj /* device to be unloaded */
  2081.     )
  2082.     {
  2083.     MBC_DEVICE * pDrvCtrl = pObj; /* device to be unloaded */
  2085.     END_OBJECT_UNLOAD (&pDrvCtrl->end);
  2086.     
  2087.     /* Free the shared DMA memory. */
  2089.     if (pDrvCtrl->flags & MBC_MEM_ALLOC_FLAG)
  2090. cacheDmaFree (pDrvCtrl->bufBase);
  2091.     
  2092.     return (OK);
  2093.     }
  2095. /******************************************************************************
  2096. *
  2097. * mbcPollStart - start polled mode operations
  2098. *
  2099. * RETURNS: OK.
  2100. */
  2102. LOCAL STATUS mbcPollStart
  2103.     (
  2104.     MBC_DEVICE * pDrvCtrl /* device to be polled */
  2105.     )
  2106.     {
  2107.     int oldLevel;
  2109.     DRV_LOG (DRV_DEBUG_POLL, "%s%d: ultraPollStartn",
  2110.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  2111.      
  2112.     oldLevel = intLock (); /* disable ints during update */
  2113.     SYS_OUT_SHORT (pDrvCtrl, MBC_IMASK, 0x00);
  2114.     pDrvCtrl->flags |= MBC_POLLING;
  2115.     intUnlock (oldLevel); /* now mbcInt won't get confused */
  2117.     return (OK);
  2118.     }
  2120. /******************************************************************************
  2121. *
  2122. * mbcPollStop - stop polled mode operations
  2123. *
  2124. * This function terminates polled mode operation.  The device returns to
  2125. * interrupt mode.
  2126. *
  2127. * The device interrupts are enabled, the current mode flag is switched
  2128. * to indicate interrupt mode and the device is then reconfigured for
  2129. * interrupt operation.
  2130. *
  2131. * RETURNS: OK or ERROR.
  2132. */
  2134. LOCAL STATUS mbcPollStop
  2135.     (
  2136.     MBC_DEVICE * pDrvCtrl /* device to be polled */
  2137.     )
  2138.     {
  2139.     int oldLevel;
  2141.     DRV_LOG (DRV_DEBUG_POLL, "%s%d: ultraPollStopn",
  2142.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  2143.      
  2144.     /* re-enable interrupts */
  2145.       
  2146.     oldLevel = intLock (); /* disable ints during register updates */
  2147.     SYS_OUT_SHORT (pDrvCtrl, MBC_IMASK, MBC_IMASK_RXF | MBC_IMASK_EBE);
  2148.     pDrvCtrl->flags &= ~MBC_POLLING;
  2149.     intUnlock (oldLevel);
  2151.     return (OK);
  2152.     }
  2154. /******************************************************************************
  2155. *
  2156. * mbcReset - reset device
  2157. *
  2158. * RETURNS: N/A.
  2159. *
  2160. * NOMANUAL
  2161. */
  2163. LOCAL void mbcReset
  2164.     (
  2165.     MBC_DEVICE * pDrvCtrl /* interrupting device */
  2166.     )
  2167.     {
  2168.     int counter = 0xffff;
  2169.     
  2170.     /* Disable interrupts */
  2171.     
  2172.     SYS_OUT_SHORT (pDrvCtrl, MBC_IMASK, 0x00);
  2174.     /* clear pending `graceful stop complete' event, and start one */
  2176.     SYS_OUT_SHORT (pDrvCtrl, MBC_IEVNT, MBC_IEVNT_GRA);
  2177.     SYS_OUT_SHORT (pDrvCtrl, MBC_ECNTL, MBC_ECNTL_GTS);
  2179.     /* wait for graceful stop to register */
  2181.     while (counter--)
  2182. {
  2183. USHORT event;
  2185. SYS_IN_SHORT (pDrvCtrl, MBC_IEVNT, &event);
  2186. if (event & MBC_IEVNT_GRA)
  2187.     break;
  2188. }
  2190.     /* disable the receiver and transmitter. */
  2192.     SYS_RESET_SHORT (pDrvCtrl, MBC_ECNTL, MBC_ECNTL_ENBL);
  2193.     
  2194.     pDrvCtrl->resetCounter++;
  2195.     }