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

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

VxWorks

开发平台：

C/C++

auEnd.c：源码内容
  1. /* auEnd.c - END style Au MAC Ethernet driver */
  3. /* Copyright 1984-2002 Wind River Systems, Inc., and Cetia Inc. */
  5. #include "copyright_wrs.h"
  7. /*
  8.  * This file has been developed or significantly modified by the
  9.  * MIPS Center of Excellence Dedicated Engineering Staff.
  10.  * This notice is as per the MIPS Center of Excellence Master Partner
  11.  * Agreement, do not remove this notice without checking first with
  12.  * WR/Platforms MIPS Center of Excellence engineering management.
  13.  */
  15. /*
  16. modification history
  17. --------------------
  18. 01k,24jun02,zmm  Removed kernel calls from polling routines, Fix SPR 75773.
  19. 01j,14may02,zmm  Global au1000 name changes. SPR 77333.
  20. 01i,18apr02,zmm  Add muxError calls, if mBlkGet, netClBlkGet, or netClusterGet
  21.                  fails. Fix SPR 73756.
  22. 01h,04apr02,zmm  Move enabling the receiver from Reset to Config routine.
  23.                  Fix SPR 75126.
  24. 01g,15nov01,zmm  Supported auto-negotiation and cache coherency, 
  25.                  plus general cleanups. SPR 71884.
  26. 01f,11oct01,tlc  Change register names according to new revision of Au1000
  27.                  Databook.  General cleanup.
  28. 01e,21sep01,agf  add cluster alloc and MAC enable address to LOAD string
  29.                  generalize driver to work on MAC 0 or 1
  30. 01d,20sep01,agf  increase pCluster allocation, check Done bit prior to Tx load
  31. 01c,19jul01,zmm  Supported polling driver mode, and few interrupt mode fixes.
  32. 01b,19jun01,zmm  Fix race condition and Tx handling.
  33. 01a,17may01,mem  written.
  34. */
  36. /*
  37. DESCRIPTION  
  38. This module implements the Alchemey Semiconductor au on-chip
  39. ethernet MACs.
  41. The software interface to the driver is divided into three parts.
  42. The first part is the interrupt registers and their setup. This part
  43. is done at the BSP level in the various BSPs which use this driver. 
  44. The second and third part are addressed in the driver. The second part of
  45. the interface comprises of the I/O control registers and their
  46. programming. The third part of the interface comprises of the descriptors
  47. and the buffers. 
  49. This driver is designed to be moderately generic. Though it currently is
  50. implemented on one processor, in the future it may be added to other
  51. Alchemey product offerings. Thus, it would be desirable to use the same
  52. driver with no source level changes. To achieve this, the driver must be
  53. given several target-specific parameters, and some external support
  54. routines must be provided. These target-specific values and the external
  55. support routines are described below.
  57. This driver supports multiple units per CPU.  The driver can be
  58. configured to support big-endian or little-endian architectures.
  60. BOARD LAYOUT
  61. This device is on-board.  No jumpering diagram is necessary.
  63. EXTERNAL INTERFACE
  64. The only external interface is the auEndLoad() routine, which expects
  65. the <initString> parameter as input.  This parameter passes in a 
  66. colon-delimited string of the format:
  68. <unit>:<devMemAddr>:<devIoAddr>:<enableAddr>:<vecNum>:<intLvl>:<offset>
  69. :<qtyCluster>:<flags>
  71. The auEndLoad() function uses strtok() to parse the string.
  73. TARGET-SPECIFIC PARAMETERS
  74. .IP <unit>
  75. A convenient holdover from the former model.  This parameter is used only
  76. in the string name for the driver.
  78. .IP <devAddr>
  79. This parameter is the memory base address of the device registers in the
  80. memory map of the CPU. It indicates to the driver where to find the
  81. base MAC register.
  83. .IP <devIoAddr>
  84. This parameter in the base address of the device registers for the
  85. dedicated DMA channel for the MAC device.  It indicates to the driver
  86. where to find the DMA registers. 
  88. .IP <enableAddr>
  89. This parameter is the address MAC enable register. It is necessary to 
  90. specify selection between MAC 0 and MAC 1.
  92. .IP <vecNum>
  93. This parameter is the vector associated with the device interrupt.
  94. This driver configures the MAC device to generate hardware interrupts
  95. for various events within the device; thus it contains an interrupt handler
  96. routine.  The driver calls intConnect() via the macro SYS_INT_CONNECT()
  97. to connect its interrupt handler to the interrupt vector generated as a
  98. result of the MAC interrupt.
  100. .IP <intLvl>
  101. Some targets use additional interrupt controller devices to help organize
  102. and service the various interrupt sources.  This driver avoids all board-
  103. specific knowledge of such devices.  During the driver's initialization,
  104. the external routine sysLanAuIntEnable() is called to perform any
  105. board-specific operations required to allow the servicing of an interrupt.
  106. For a description of sysLanAuIntEnable(), see "External Support
  107. Requirements" below.
  109. .IP <offset>
  110. This parameter specifies the offset from which the packet has to be
  111. loaded from the begining of the device buffer. Normally this parameter is
  112. zero except for architectures which access long words only on aligned
  113. addresses. For these architectures the value of this offset should be 2.
  115. .IP <qtyCluster>
  116. This parameter is used to explicitly allocate the number of clusters that
  117. will be allocated. This allows the user to suit the stack to the amount of
  118. physical memory on the board.
  120. .IP <flags>
  121. This is parameter is reserved for future use. Its value should be zero.
  123. EXTERNAL SUPPORT REQUIREMENTS
  124. This driver requires several external support functions, defined as macros:
  125. .CS
  126.     SYS_INT_CONNECT(pDrvCtrl, routine, arg)
  127.     SYS_INT_DISCONNECT (pDrvCtrl, routine, arg)
  128.     SYS_INT_ENABLE(pDrvCtrl)
  129.     SYS_INT_DISABLE(pDrvCtrl)
  130.     SYS_OUT_BYTE(pDrvCtrl, reg, data)
  131.     SYS_IN_BYTE(pDrvCtrl, reg, data)
  132.     SYS_OUT_WORD(pDrvCtrl, reg, data)
  133.     SYS_IN_WORD(pDrvCtrl, reg, data)
  134.     SYS_OUT_LONG(pDrvCtrl, reg, data)
  135.     SYS_IN_LONG(pDrvCtrl, reg, data)
  136.     SYS_ENET_ADDR_GET(pDrvCtrl, pAddress)    
  137.     sysLanAuIntEnable(pDrvCtrl->intLevel) 
  138.     sysLanAuIntDisable(pDrvCtrl->intLevel) 
  139.     sysLanAuEnetAddrGet(pDrvCtrl, enetAdrs)
  140. .CE
  142. There are default values in the source code for these macros.  They presume
  143. memory mapped accesses to the device registers and the intConnect(), and
  144. intEnable() BSP functions.  The first argument to each is the device
  145. controller structure. Thus, each has access back to all the device-specific
  146. information.  Having the pointer in the macro facilitates the addition of new
  147. features to this driver.
  149. The macros SYS_INT_CONNECT, SYS_INT_DISCONNECT, SYS_INT_ENABLE and
  150. SYS_INT_DISABLE allow the driver to be customized for BSPs that use special
  151. versions of these routines.
  153. The macro SYS_INT_CONNECT is used to connect the interrupt handler to
  154. the appropriate vector.  By default it is the routine intConnect().
  156. The macro SYS_INT_DISCONNECT is used to disconnect the interrupt handler prior
  157. to unloading the module.  By default this routine is not implemented.
  159. The macro SYS_INT_ENABLE is used to enable the interrupt level for the
  160. end device.  It is called once during initialization.  It calls an
  161. external board level routine sysLanAuIntEnable(). 
  163. The macro SYS_INT_DISABLE is used to disable the interrupt level for the
  164. end device.  It is called during stop.  It calls an
  165. external board level routine sysLanAuIntDisable(). 
  167. The macro SYS_ENET_ADDR_GET is used get the ethernet hardware of the
  168. chip. This macro calls an external board level routine namely
  169. sysLanAuEnetAddrGet() to get the ethernet address.
  171. SYSTEM RESOURCE USAGE
  172. When implemented, this driver requires the following system resources:
  174.     - one mutual exclusion semaphore
  175.     - one interrupt vector
  176.     - 64 bytes in the initialized data section (data)
  177.     - 0 bytes in the uninitialized data section (BSS)
  179. The driver allocates clusters of size 1520 bytes for receive frames and
  180. and transmit frames.
  182. INCLUDES:
  183. end.h endLib.h etherMultiLib.h auEnd.h
  185. SEE ALSO: muxLib, endLib, netBufLib
  186. .I "Writing and Enhanced Network Driver"
  187. */
  189. #include "vxWorks.h"
  190. #include "wdLib.h"
  191. #include "stdlib.h"
  192. #include "taskLib.h"
  193. #include "logLib.h"
  194. #include "intLib.h"
  195. #include "netLib.h"
  196. #include "stdio.h"
  197. #include "stdlib.h"
  198. #include "sysLib.h"
  199. #include "iv.h"
  200. #include "memLib.h"
  201. #include "semLib.h"
  202. #include "cacheLib.h"
  203. #include "sys/ioctl.h"
  205. #ifndef DOC             /* don't include when building documentation */
  206. #include "net/mbuf.h"
  207. #endif  /* DOC */
  209. #include "net/protosw.h"
  210. #include "sys/socket.h"
  211. #include "errno.h"
  212. #include "net/if.h"
  213. #include "net/route.h"
  214. #include "netinet/in.h"
  215. #include "netinet/in_systm.h"
  216. #include "netinet/in_var.h"
  217. #include "netinet/ip.h"
  218. #include "netinet/if_ether.h"
  219. #include "net/if_subr.h"
  220. #include "m2Lib.h"
  221. #include "miiLib.h"
  223. #include "etherMultiLib.h"              /* multicast stuff. */
  224. #include "end.h"                        /* Common END structures. */
  225. #include "netBufLib.h"
  226. #include "muxLib.h"
  228. #undef END_MACROS
  230. #include "endLib.h"
  231. #include "lstLib.h"                     /* Needed to maintain protocol list. */
  232. #include "logLib.h"
  233. #include "drv/end/auEnd.h"
  234. #include "drv/multi/auLib.h"
  236. /* local defines */
  238. #define DRV_DEBUG /* temporary should be taken out */
  239. #undef DRV_DEBUG
  241. /* define the various levels of debugging if the DRV_DEBUG is defined */    
  243. #ifdef DRV_DEBUG
  244. #define DRV_DEBUG_OFF 0x0000
  245. #define DRV_DEBUG_RX 0x0001
  246. #define DRV_DEBUG_TX 0x0002
  247. #define DRV_DEBUG_INT 0x0004
  248. #define DRV_DEBUG_POLL (DRV_DEBUG_POLL_RX | DRV_DEBUG_POLL_TX)
  249. #define DRV_DEBUG_POLL_RX 0x0008
  250. #define DRV_DEBUG_POLL_TX 0x0010
  251. #define DRV_DEBUG_LOAD 0x0020
  252. #define DRV_DEBUG_LOAD2 0x0040
  253. #define DRV_DEBUG_IOCTL 0x0080
  254. #define DRV_DEBUG_RESET 0x0100
  255. #define DRV_DEBUG_MCAST 0x0200
  256. #define DRV_DEBUG_CSR 0x0400
  257. #define DRV_DEBUG_RX_PKT        0x0800
  258. #define DRV_DEBUG_POLL_REDIR 0x10000
  259. #define DRV_DEBUG_LOG_NVRAM 0x20000
  260. #define DRV_DEBUG_MII 0x40000
  261. #define DRV_DEBUG_ALL           0xfffff
  262. #endif /* DRV_DEBUG */
  264. /* MII macro */
  266. #define DRV_PHY_FLAGS_ISSET(setBits)                                    
  267.         (pDrvCtrl->miiPhyFlags & (setBits))
  269. /* Cache macros */
  271. #define AU_CACHE_VIRT_TO_PHYS(address) 
  272.         CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, (address))
  274. #define AU_CACHE_PHYS_TO_VIRT(address) 
  275.         CACHE_DRV_PHYS_TO_VIRT (&pDrvCtrl->cacheFuncs, (address))
  277. /*
  278.  * Default macro definitions for BSP interface.
  279.  * These macros can be redefined in a wrapper file, to generate
  280.  * a new module with an optimized interface.
  281.  */
  283. #ifndef SYS_INT_CONNECT
  284. #define SYS_INT_CONNECT(pDrvCtrl,rtn,arg,pResult)                       
  285.     {                                                                   
  286.     IMPORT STATUS intConnect();                                      
  287.     *pResult = intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (pDrvCtrl->ivec),
  288.                              (rtn), (int)(arg));                        
  289.     }
  290. #endif /*SYS_INT_CONNECT*/
  292. #ifndef SYS_INT_DISCONNECT
  293. #define SYS_INT_DISCONNECT(pDrvCtrl,rtn,arg,pResult)                    
  294.     {                                                                   
  295.     }
  296. #endif /*SYS_INT_DISCONNECT*/
  298. #ifndef SYS_INT_ENABLE
  299. #define SYS_INT_ENABLE(pDrvCtrl) 
  300.     { 
  301.     IMPORT STATUS sysLanAuIntEnable(); 
  302.     sysLanAuIntEnable (pDrvCtrl->ilevel); 
  303.     }
  304. #endif /* SYS_INT_ENABLE*/
  306. /* Macro to disable the appropriate interrupt level */
  308. #ifndef SYS_INT_DISABLE
  309. #define SYS_INT_DISABLE(pDrvCtrl) 
  310.     { 
  311.     IMPORT STATUS sysLanAuIntDisable (); 
  312.     sysLanAuIntDisable (pDrvCtrl->ilevel); 
  313.     }
  314. #endif /* SYS_INT_DISABLE */
  316. #ifndef SYS_ENET_ADDR_GET
  317. #define SYS_ENET_ADDR_GET(pDrvCtrl, pAddress) 
  318.     { 
  319.     IMPORT STATUS sysLanAuEnetAddrGet (AU_DRV_CTRL *pDrvCtrl, 
  320.                                      char * enetAdrs); 
  321.     sysLanAuEnetAddrGet (pDrvCtrl, pAddress); 
  322.     }
  323. #endif /* SYS_ENET_ADDR_GET */
  325. #ifndef SYS_WB_FLUSH
  326. #define SYS_WB_FLUSH() 
  327.     { 
  328.     IMPORT void sysWbFlush (void); 
  329.     sysWbFlush(); 
  330.     }
  331. #endif/* SYS_WB_FLUSH */
  333. /* A shortcut for getting the hardware address from the MIB II stuff. */
  335. #define END_HADDR(pEnd) 
  336.                 ((pEnd)->mib2Tbl.ifPhysAddress.phyAddress)
  338. #define END_HADDR_LEN(pEnd) 
  339.                 ((pEnd)->mib2Tbl.ifPhysAddress.addrLength)
  341. #define END_FLAGS_ISSET(pEnd, setBits) 
  342.             ((pEnd)->flags & (setBits))
  344. /* externs */
  346. IMPORT int endMultiLstCnt (END_OBJ *);
  348. #ifdef DRV_DEBUG /* if debugging driver */
  350. int         auDebug = (DRV_DEBUG_LOAD | DRV_DEBUG_TX | DRV_DEBUG_RX
  351.    | DRV_DEBUG_MII | DRV_DEBUG_INT);
  353. #define DRV_LOG(FLG, X0, X1, X2, X3, X4, X5, X6) 
  354.         if (auDebug & FLG) 
  355.             logMsg((char *)X0, (int)X1, (int)X2, (int)X3, (int)X4, 
  356.     (int)X5, (int)X6);
  358. #define DRV_PRINT(FLG,X) 
  359.         if (auDebug & FLG) printf X;
  361. #else /*DRV_DEBUG*/
  363. #define DRV_LOG(DBG_SW, X0, X1, X2, X3, X4, X5, X6)
  364. #define DRV_PRINT(DBG_SW,X)
  366. #endif /*DRV_DEBUG*/
  368. /* locals */
  370. #ifdef DRV_DEBUG
  371. AU_DRV_CTRL *  dbgDrvCtrl[2];
  372. #endif
  374. /* forward static functions */
  376. LOCAL int  auReset (AU_DRV_CTRL * pDrvCtrl);
  377. LOCAL void  auInt (AU_DRV_CTRL * pDrvCtrl);
  378. LOCAL void  auHandleInt (AU_DRV_CTRL * pDrvCtrl);
  379. LOCAL STATUS  auRecv (AU_DRV_CTRL * pDrvCtrl);
  380. LOCAL void  auRestart (AU_DRV_CTRL * pDrvCtrl);
  381. LOCAL STATUS  auRestartSetup (AU_DRV_CTRL * pDrvCtrl);
  382. LOCAL void  auAddrFilterSet (AU_DRV_CTRL * pDrvCtrl);
  383. LOCAL void auConfig (AU_DRV_CTRL * pDrvCtrl);
  384. LOCAL STATUS  auMemInit (AU_DRV_CTRL * pDrvCtrl);
  385. LOCAL void auTRingScrub (AU_DRV_CTRL * pDrvCtrl);
  387. LOCAL STATUS  auPhyPreInit  (AU_DRV_CTRL *pDrvCtrl);
  388. LOCAL STATUS  auMiiInit  (AU_DRV_CTRL *pDrvCtrl);
  390. LOCAL STATUS auMiiRead (AU_DRV_CTRL *pDrvCtrl, UINT8 phyAdrs,
  391.        UINT8 phyReg, UINT16 *pRetVal);
  392. LOCAL STATUS auMiiWrite (AU_DRV_CTRL *pDrvCtrl, UINT8 phyAdrs,
  393. UINT8 phyReg, USHORT data);
  394. LOCAL UINT8 auPhyFind (AU_DRV_CTRL *pDrvCtrl);
  396. /* END Specific interfaces. */
  398. LOCAL STATUS    auStart (AU_DRV_CTRL * pDrvCtrl);
  399. LOCAL STATUS    auStop (AU_DRV_CTRL * pDrvCtrl);
  400. LOCAL STATUS    auUnload (AU_DRV_CTRL * pDrvCtrl);
  401. LOCAL int       auIoctl (AU_DRV_CTRL * pDrvCtrl, int cmd, caddr_t data);
  402. LOCAL STATUS    auSend (AU_DRV_CTRL * pDrvCtrl, M_BLK_ID pBuf);
  403. LOCAL STATUS    auMCastAddrAdd (AU_DRV_CTRL* pDrvCtrl, char * pAddress);
  404. LOCAL STATUS    auMCastAddrDel (AU_DRV_CTRL * pDrvCtrl,
  405.                                    char * pAddress);
  406. LOCAL STATUS    auMCastAddrGet (AU_DRV_CTRL * pDrvCtrl,
  407.                                     MULTI_TABLE * pTable);
  408. LOCAL STATUS    auPollSend (AU_DRV_CTRL * pDrvCtrl, M_BLK_ID pBuf);
  409. LOCAL STATUS    auPollReceive (AU_DRV_CTRL * pDrvCtrl, M_BLK_ID pBuf);
  410. LOCAL STATUS    auPollStart (AU_DRV_CTRL * pDrvCtrl);
  411. LOCAL STATUS    auPollStop (AU_DRV_CTRL * pDrvCtrl);
  413. /*
  414.  * Declare our function table.  This is static across all driver
  415.  * instances.
  416.  */
  417. LOCAL NET_FUNCS auFuncTable =
  418.     {
  419.     (FUNCPTR) auStart,               /* Function to start the device.      */
  420.     (FUNCPTR) auStop,                /* Function to stop the device.       */
  421.     (FUNCPTR) auUnload,  /* Unloading function for the driver. */
  422.     (FUNCPTR) auIoctl,               /* Ioctl function for the driver.     */
  423.     (FUNCPTR) auSend,                /* Send function for the driver.      */
  424.     (FUNCPTR) auMCastAddrAdd,        /* Multicast address add              */
  425.     (FUNCPTR) auMCastAddrDel,  /* Multicast address delete           */
  426.     (FUNCPTR) auMCastAddrGet,  /* Multicast table retrieve           */
  427.     (FUNCPTR) auPollSend,            /* Polling send function              */
  428.     (FUNCPTR) auPollReceive,  /* Polling receive function           */
  429.     endEtherAddressForm,         /* Put address info into a packet.    */
  430.     endEtherPacketDataGet,       /* Get a pointer to packet data.      */
  431.     endEtherPacketAddrGet        /* Get packet addresses.              */
  432.     };
  434. /******************************************************************************
  435. *
  436. * auEndLoad - 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 <initString>, which
  440. * expects a string of the following format:
  441. *
  442. * <unit>:<devMemAddr>:<devIoAddr>:<enableAddr>:<vecNum>:<intLvl>:<offset>
  443. * :<qtyCluster>:<flags>
  444. *
  445. * This routine can be called in two modes. If it is called with an empty but
  446. * allocated string, it places the name of this device (that is, "au") into 
  447. * the <initString> and returns 0.
  448. *
  449. * If the string is allocated and not empty, the routine attempts to load
  450. * the driver using the values specified in the string.
  451. *
  452. * RETURNS: An END object pointer, or NULL on error, or 0 and the name of the
  453. * device if the <initString> was NULL.
  454. */
  456. END_OBJ * auEndLoad
  457.     (
  458.     char * initString            /* string to be parse by the driver */
  459.     )
  460.     {
  461.     AU_DRV_CTRL * pDrvCtrl;
  463.     DRV_LOG (DRV_DEBUG_LOAD, "Loading au...debug @ 0X%Xn",
  464.              (int)&auDebug, 2, 3, 4, 5, 6);
  466.     if (initString == NULL)
  467.         return (NULL);
  469.     if (initString [0] == 0)
  470.         {
  471.         bcopy ((char *)AU_DEV_NAME, initString, AU_DEV_NAME_LEN);
  472. DRV_LOG (DRV_DEBUG_LOAD, "Returning string...n", 1, 2, 3, 4, 5, 6);
  473.         return ((END_OBJ *)OK);
  474.         }
  476.     DRV_LOG (DRV_DEBUG_LOAD, "austring: [%s]n",
  477.     (int)initString, 2, 3, 4, 5, 6);
  479.     /* allocate the device structure */
  481.     pDrvCtrl = (AU_DRV_CTRL *)calloc (sizeof (AU_DRV_CTRL), 1);
  483.     if (pDrvCtrl == NULL)
  484.         goto errorExit;
  486.     DRV_LOG (DRV_DEBUG_LOAD, "DrvControl : 0x%Xn", (int)pDrvCtrl,
  487.              2, 3, 4, 5, 6);
  489.     /* parse the init string, filling in the device structure */
  491.     if (auInitParse (pDrvCtrl, initString) == ERROR)
  492. {
  493. DRV_LOG (DRV_DEBUG_LOAD, "Parse failed ...n", 1, 2, 3, 4, 5, 6);
  494.         goto errorExit;
  495. }
  497.     DRV_LOG (DRV_DEBUG_LOAD, "mac   addr %08x %08xn",
  498.      AU_MAC_ADDRESS_HIGH,
  499.      AU_MAC_ADDRESS_LOW, 0, 0, 0, 0);
  500.     DRV_LOG (DRV_DEBUG_LOAD, "multi addr %08x %08xn",
  501.      AU_MULTICAST_HASH_ADDRESS_HIGH,
  502.      AU_MULTICAST_HASH_ADDRESS_LOW, 0, 0, 0, 0);
  504.     /* Have the BSP hand us our address. */
  506.     SYS_ENET_ADDR_GET (pDrvCtrl, &(pDrvCtrl->enetAddr [0]));
  508.     /* initialize the END and MIB2 parts of the structure */
  510.     if (END_OBJ_INIT (&pDrvCtrl->endObj, (DEV_OBJ *)pDrvCtrl, AU_DEV_NAME,
  511.                       pDrvCtrl->unit, &auFuncTable,
  512.                       "Au MAC Enhanced Network Driver") == ERROR
  513.      || END_MIB_INIT (&pDrvCtrl->endObj, M2_ifType_ethernet_csmacd,
  514.                       &pDrvCtrl->enetAddr[0], 6, ETHERMTU,
  515.                       AU_SPEED)
  516.                     == ERROR)
  517.         goto errorExit;
  519.     DRV_LOG (DRV_DEBUG_LOAD, "END init done ...n", 1, 2, 3, 4, 5, 6);
  521.     /* Allocate PHY structure */
  523.     /* Perform memory allocation */
  525.     if (auMemInit (pDrvCtrl) == ERROR)
  526.         goto errorExit;
  528.     DRV_LOG (DRV_DEBUG_LOAD, "Malloc done ...n", 1, 2, 3, 4, 5, 6);
  530.     /* Perform memory distribution and reset and reconfigure the device */
  532.     if (auRestartSetup (pDrvCtrl) == ERROR)
  533.         goto errorExit;
  535.     DRV_LOG (DRV_DEBUG_LOAD, "Restart setup done ...n", 1, 2, 3, 4, 5, 6);
  537.     /* set the flags to indicate readiness */
  539.     END_OBJ_READY (&pDrvCtrl->endObj, IFF_NOTRAILERS | IFF_BROADCAST |
  540.                        IFF_MULTICAST | IFF_SIMPLEX);
  542.     DRV_LOG (DRV_DEBUG_LOAD, "Done loading au...n", 1, 2, 3, 4, 5, 6);
  544. #ifdef DRV_DEBUG
  545.     dbgDrvCtrl[pDrvCtrl->unit] = pDrvCtrl;
  546. #endif
  547.     
  548.     return (&pDrvCtrl->endObj);
  550. errorExit:
  551.     if (pDrvCtrl != NULL)
  552.         free ((char *)pDrvCtrl);
  554.     return ((END_OBJ *)NULL);
  555.     }
  557. /*******************************************************************************
  558. *
  559. * auInitParse - parse the initialization string
  560. *
  561. * Parse the input string. This routine is called from auEndLoad() which
  562. * intializes some values in the driver control structure with the values
  563. * passed in the intialization string.
  564. *
  565. * The initialization string format is:
  566. * <unit>:<devMemAddr>:<devIoAddr>:<vecNum>:<intLvl>:<offset>:<flags>
  567. *
  568. * .IP <unit>
  569. * Device unit number, a small integer.
  570. * .IP <devMemAddr>
  571. * Device register base memory address
  572. * .IP <devIoAddr>
  573. * I/O register base memory address
  574. * .IP <enableAddr>
  575. * Address of MAC enable register
  576. * .IP <vecNum>
  577. * Interrupt vector number.
  578. * .IP <intLvl>
  579. * Interrupt level.
  580. * .IP <offset>
  581. * Offset of starting of data in the device buffers.
  582. * .IP <qtyCluster>
  583. * Number of clusters to allocate
  584. * .IP <flags>
  585. * Device specific flags, for future use.
  586. *
  587. * RETURNS: OK, or ERROR if any arguments are invalid.
  588. */
  590. STATUS auInitParse
  591.     (
  592.     AU_DRV_CTRL * pDrvCtrl, /* pointer to the control structure */
  593.     char *  initString /* initialization string */
  594.     )
  595.     {
  596.     char*       tok;
  597.     char*       holder = NULL;
  599.     DRV_LOG (DRV_DEBUG_LOAD, "Parse starting ...n", 1, 2, 3, 4, 5, 6);
  601.     /* Parse the initString */
  603.     /* Unit number. */
  605.     tok = strtok_r (initString, ":", &holder);
  606.     if (tok == NULL)
  607.         return ERROR;
  609.     pDrvCtrl->unit = atoi (tok);
  611.     DRV_LOG (DRV_DEBUG_LOAD, "Unit : %d ...n", pDrvCtrl->unit, 2, 3, 4, 5, 6);
  613.     /* devAdrs address. */
  615.     tok = strtok_r (NULL, ":", &holder);
  616.     if (tok == NULL)
  617.         return ERROR;
  618.     pDrvCtrl->devAdrs = (UINT32) strtoul (tok, NULL, 16);
  620.     DRV_LOG (DRV_DEBUG_LOAD, "devAdrs : 0x%X ...n", pDrvCtrl->devAdrs,
  621.              2, 3, 4, 5, 6);
  623.     /* dmaAdrs address. */
  625.     tok = strtok_r (NULL, ":", &holder);
  626.     if (tok == NULL)
  627.         return ERROR;
  628.     pDrvCtrl->dmaAdrs = (UINT32) strtoul (tok, NULL, 16);
  630.     DRV_LOG (DRV_DEBUG_LOAD, "dmaAdrs : 0x%X ...n", pDrvCtrl->dmaAdrs,
  631.              2, 3, 4, 5, 6);
  633.     /* enableAdrs address. */
  635.     tok = strtok_r (NULL, ":", &holder);
  636.     if (tok == NULL)
  637.         return ERROR;
  638.     pDrvCtrl->enableAdrs = (UINT32) strtoul (tok, NULL, 16);
  640.     DRV_LOG (DRV_DEBUG_LOAD, "enableAdrs : 0x%X ...n", pDrvCtrl->enableAdrs,
  641.              2, 3, 4, 5, 6);
  643.     /* Interrupt vector. */
  645.     tok = strtok_r (NULL, ":", &holder);
  646.     if (tok == NULL)
  647.         return ERROR;
  648.     pDrvCtrl->ivec = atoi (tok);
  650.     DRV_LOG (DRV_DEBUG_LOAD, "ivec : 0x%X ...n", pDrvCtrl->ivec,
  651.              2, 3, 4, 5, 6);
  653.     /* Interrupt level. */
  655.     tok = strtok_r (NULL, ":", &holder);
  656.     if (tok == NULL)
  657.         return ERROR;
  658.     pDrvCtrl->ilevel = atoi (tok);
  659.     DRV_LOG (DRV_DEBUG_LOAD, "ilevel : 0x%X ...n", pDrvCtrl->ilevel,
  660.              2, 3, 4, 5, 6);
  662.     /* Caller supplied alignment offset. */
  664.     tok = strtok_r (NULL, ":", &holder);
  665.     if (tok == NULL)
  666. return ERROR;
  667.     pDrvCtrl->offset = atoi (tok);
  668.     DRV_LOG (DRV_DEBUG_LOAD, "Offset : 0x%X ...n", pDrvCtrl->offset,
  669.              2, 3, 4, 5, 6);
  671.     /* Caller supplied cluster qty */
  673.     tok = strtok_r (NULL, ":", &holder);
  674.     if (tok == NULL)
  675. return ERROR;
  676.     pDrvCtrl->clDesc.clNum    = atoi (tok);
  677.     DRV_LOG (DRV_DEBUG_LOAD, "Cluster Qty : 0x%X ...n", pDrvCtrl->clDesc.clNum,
  678.              2, 3, 4, 5, 6);
  680.     /* caller supplied flags */
  682.     tok = strtok_r (NULL, ":", &holder);
  683.     if (tok == NULL)
  684.         return ERROR;
  686.     pDrvCtrl->flags |= strtoul (tok, NULL, 16);
  687.     DRV_LOG (DRV_DEBUG_LOAD, "flags : 0x%X ...n", pDrvCtrl->flags,
  688.              2, 3, 4, 5, 6);
  690.     return (OK);
  691.     }
  693. /*******************************************************************************
  694. *
  695. * auMemInit - initialize memory.
  696. *
  697. * Using data in the control structure, setup and initialize the memory
  698. * areas needed.  If the memory address is not already specified, then allocate
  699. * cache safe memory.
  700. *
  701. * RETURNS: OK or ERROR.
  702. */
  704. LOCAL STATUS auMemInit
  705.     (
  706.     AU_DRV_CTRL * pDrvCtrl /* device to be initialized */
  707.     )
  708.     {
  709.     int         i;
  710.     char * pRxMem;
  711.     char * pTxMem;
  712.     UINT32      rxSize;
  713.     UINT32      txSize;
  714.     UINT32      bufPtr;
  716.     pDrvCtrl->rringSize = AU_N_RX_BUF;
  717.     pDrvCtrl->tringSize = AU_N_TX_BUF;
  718.     
  719.     rxSize = pDrvCtrl->rringSize * ROUND_UP(AU_DMA_BUFSIZ, 32) + 32;
  720.     pRxMem = (char *) cacheDmaMalloc (rxSize);
  721.     txSize = pDrvCtrl->tringSize * ROUND_UP(AU_DMA_BUFSIZ, 32) + 32;
  722.     pTxMem = (char *) cacheDmaMalloc (txSize);
  724.     if ((pRxMem == NULL) || (pTxMem == NULL))
  725. {
  726. printf ("au: system memory unavailablen");
  727. return (ERROR);
  728. }
  730.     pDrvCtrl->pRxMemBase = pRxMem;
  731.     pDrvCtrl->pTxMemBase = pTxMem;
  733.     /* copy the DMA structure */
  735.     pDrvCtrl->cacheFuncs = cacheDmaFuncs;
  737.     bufPtr = (UINT32)pRxMem;
  738.     for (i = 0; i < pDrvCtrl->rringSize; ++i)
  739. {
  740. pDrvCtrl->pRxMem[i] = (char *)ROUND_UP(bufPtr, 32);
  741. bufPtr += AU_DMA_BUFSIZ;
  742. }
  744.     bufPtr = (UINT32)pTxMem;
  745.     for (i = 0; i < pDrvCtrl->tringSize; ++i)
  746. {
  747. pDrvCtrl->pTxMem[i] = (char *)ROUND_UP(bufPtr, 32);
  748. bufPtr += AU_DMA_BUFSIZ;
  749. }
  751.     /* allocate pool structure for mblks, clBlk, and clusters */
  753.     if ((pDrvCtrl->endObj.pNetPool = malloc (sizeof(NET_POOL))) == NULL)
  754. return (ERROR);
  756.     /* number of clusters is passed in by the endLoadString 
  757.      * pDrvCtrl->clDesc.clNum    = pDrvCtrl->rringSize * 2;
  758.      */
  759.     pDrvCtrl->mClCfg.clBlkNum = pDrvCtrl->clDesc.clNum;
  760.     pDrvCtrl->mClCfg.mBlkNum  = pDrvCtrl->mClCfg.clBlkNum * 2;
  762.     /* total memory size for mBlks and clBlks */
  763.     
  764.     pDrvCtrl->mClCfg.memSize =
  765.         (pDrvCtrl->mClCfg.mBlkNum  *  (MSIZE + sizeof (long))) +
  766.         (pDrvCtrl->mClCfg.clBlkNum * (CL_BLK_SZ + sizeof (long)));
  768.     /* total memory for mBlks and clBlks */
  770.     if ((pDrvCtrl->mClCfg.memArea =
  771.          (char *) memalign (sizeof(long), pDrvCtrl->mClCfg.memSize)) == NULL)
  772.         return (ERROR);
  774.     /* total memory size for all clusters */
  776.     pDrvCtrl->clDesc.clSize  = AU_BUFSIZ;
  777.     pDrvCtrl->clDesc.memSize =
  778.         (pDrvCtrl->clDesc.clNum * (pDrvCtrl->clDesc.clSize + 8)) + sizeof(int);
  780.     /* Allocate cluster memory */
  782.     pDrvCtrl->clDesc.memArea = malloc (pDrvCtrl->clDesc.memSize);
  783.     if (pDrvCtrl->clDesc.memArea == NULL)
  784. {
  785. DRV_LOG(DRV_DEBUG_LOAD,
  786. "system memory unavailablen", 1, 2, 3, 4, 5, 6);
  787. return (ERROR);
  788. }
  790.     /* initialize the device net pool */
  791.     
  792.     if (netPoolInit (pDrvCtrl->endObj.pNetPool, &pDrvCtrl->mClCfg,
  793.                      &pDrvCtrl->clDesc, 1, NULL) == ERROR)
  794.         {
  795.         DRV_LOG (DRV_DEBUG_LOAD, "Could not init bufferingn",
  796.                  1, 2, 3, 4, 5, 6);
  797.         return (ERROR);
  798.         }
  799.     
  800.     /* Store the cluster pool id as others need it later. */
  802.     pDrvCtrl->pClPoolId = clPoolIdGet (pDrvCtrl->endObj.pNetPool,
  803.                                        AU_BUFSIZ, FALSE);
  805.     return (OK);
  806.     }
  808. /***************************************************************************
  809. *
  810. * auMiiInit - initialize the chip to use the MII interface
  811. *
  812. * This routine initializes the chip to use the MII interface.
  813. *
  814. * RETURNS: OK, or ERROR
  815. */
  816.  
  817. LOCAL STATUS auMiiInit
  818.     (
  819.     AU_DRV_CTRL *  pDrvCtrl       /* pointer to DRV_CTRL structure */
  820.     )
  821.     {
  822.     DRV_LOG (DRV_DEBUG_MII, "auMiiInitn",
  823.              0, 0, 0, 0, 0, 0);
  825.     /* initialize some fields in the PHY info structure */
  827.     if (auPhyPreInit (pDrvCtrl) != OK)
  828. {
  829. DRV_LOG (DRV_DEBUG_LOAD, ("Failed to pre-initialize PHYn"),
  830.   0, 0, 0, 0, 0, 0);
  831. return (ERROR);
  832. }
  834.     DRV_LOG (DRV_DEBUG_MII, "miiPhyInitn",
  835.              0, 0, 0, 0, 0, 0);
  836.     if (miiPhyInit (pDrvCtrl->pPhyInfo) != OK)
  837.         {
  838. DRV_LOG (DRV_DEBUG_LOAD, "Failed to initialise PHYn", 0,0,0,0,0,0);
  839. return (ERROR);
  840.         }
  842.     /* deal with full duplex mode and speed */
  844.     if (pDrvCtrl->pPhyInfo->phyFlags & MII_PHY_FD)
  845. {
  846.         AU_MAC_CONTROL |= AU_MAC_CONTROL_F;
  847. SYS_WB_FLUSH();
  848. DRV_LOG (DRV_DEBUG_LOAD, "In full duplex moden", 0,0,0,0,0,0);
  849. }
  850.     else
  851. {
  852. DRV_LOG (DRV_DEBUG_LOAD, "In half duplex moden", 0,0,0,0,0,0);
  853. }
  855.     if (pDrvCtrl->pPhyInfo->phyFlags & MII_PHY_100)
  856. {
  857. DRV_LOG (DRV_DEBUG_LOAD, "In 100Mbps moden", 0,0,0,0,0,0);
  858. }
  859.     else
  860. {
  861. DRV_LOG (DRV_DEBUG_LOAD, "In 10Mbps moden", 0,0,0,0,0,0);
  862. }
  864.     return (OK);
  865.     }
  867. /***************************************************************************
  868. *
  869. * auPhyPreInit - initialize some fields in the phy info structure
  870. *
  871. * This routine initializes some fields in the phy info structure,
  872. * for use of the phyInit() routine.
  873. *
  874. * RETURNS: OK, or ERROR if could not obtain memory.
  875. */
  876.  
  877. LOCAL STATUS auPhyPreInit
  878.     (
  879.     AU_DRV_CTRL *  pDrvCtrl /* pointer to DRV_CTRL structure */
  880.     )
  881.     {
  882.     PHY_INFO * pPhyInfo = NULL;
  883.     
  884.     DRV_LOG (DRV_DEBUG_MII, "auMiiPhyPreInitn",
  885.              0, 0, 0, 0, 0, 0);
  887.     /* set MII defaults */
  889.     pDrvCtrl->pMiiPhyTbl = NULL;
  890.     pDrvCtrl->miiPhyFlags = (AU_USR_MII_10MB | AU_USR_MII_HD |
  891.                             AU_USR_MII_100MB | AU_USR_MII_FD);
  893.     /* get memory for the phyInfo structure */
  894.  
  895.     if ((pDrvCtrl->pPhyInfo = calloc (sizeof (PHY_INFO), 1)) == NULL)
  896. return (ERROR);
  898.     pPhyInfo = pDrvCtrl->pPhyInfo;
  900.     /* set some default values */
  901.  
  902.     pDrvCtrl->pPhyInfo->pDrvCtrl = (void *) pDrvCtrl;
  903.  
  904.     pDrvCtrl->pPhyInfo->phyAnOrderTbl = pDrvCtrl->pMiiPhyTbl;
  906.     pDrvCtrl->pPhyInfo->phyAddr = auPhyFind (pDrvCtrl);
  908.     /* 
  909.      * in case of link failure, set a default mode for the PHY 
  910.      * if we intend to use a different media, this flag should 
  911.      * be cleared
  912.      */
  913.  
  914.     pDrvCtrl->pPhyInfo->phyFlags |= MII_PHY_DEF_SET;
  916.     pDrvCtrl->pPhyInfo->phyWriteRtn = (FUNCPTR) auMiiWrite;
  917.     pDrvCtrl->pPhyInfo->phyReadRtn = (FUNCPTR) auMiiRead;
  918.     pDrvCtrl->pPhyInfo->phyDelayRtn = (FUNCPTR) taskDelay;
  919.     pDrvCtrl->pPhyInfo->phyMaxDelay = MII_PHY_DEF_DELAY;
  920.     pDrvCtrl->pPhyInfo->phyDelayParm = 1;
  922.     /* in case the cable is not there, leave the PHY ready to auto-negotiate */
  924.     pDrvCtrl->pPhyInfo->phyDefMode = PHY_AN_ENABLE;
  926.     /* handle some user-to-physical flags */
  928.     if (!(DRV_PHY_FLAGS_ISSET (AU_USR_MII_NO_AN)))
  929.         MII_PHY_FLAGS_SET (MII_PHY_AUTO);
  930.     else
  931.         MII_PHY_FLAGS_CLEAR (MII_PHY_AUTO);
  933.     if (DRV_PHY_FLAGS_ISSET (AU_USR_MII_AN_TBL))
  934.         MII_PHY_FLAGS_SET (MII_PHY_TBL);
  935.     else
  936.         MII_PHY_FLAGS_CLEAR (MII_PHY_TBL);
  938.     if (DRV_PHY_FLAGS_ISSET (AU_USR_MII_100MB))
  939.         MII_PHY_FLAGS_SET (MII_PHY_100);
  940.     else
  941.         MII_PHY_FLAGS_CLEAR (MII_PHY_100);
  943.     if (DRV_PHY_FLAGS_ISSET (AU_USR_MII_FD))
  944.         MII_PHY_FLAGS_SET (MII_PHY_FD);
  945.     else
  946.         MII_PHY_FLAGS_CLEAR (MII_PHY_FD);
  948.     if (DRV_PHY_FLAGS_ISSET (AU_USR_MII_10MB))
  949.         MII_PHY_FLAGS_SET (MII_PHY_10);
  950.     else
  951.         MII_PHY_FLAGS_CLEAR (MII_PHY_10);
  953.     if (DRV_PHY_FLAGS_ISSET (AU_USR_MII_HD))
  954.         MII_PHY_FLAGS_SET (MII_PHY_HD);
  955.     else
  956.         MII_PHY_FLAGS_CLEAR (MII_PHY_HD);
  958.     if (DRV_PHY_FLAGS_ISSET (AU_USR_MII_BUS_MON))
  959.         MII_PHY_FLAGS_SET (MII_PHY_MONITOR);
  960.     else
  961.         MII_PHY_FLAGS_CLEAR (MII_PHY_MONITOR);
  963.     MII_PHY_FLAGS_SET (MII_PHY_PRE_INIT);
  964.  
  965.     DRV_LOG (DRV_DEBUG_LOAD, ("auPhyPreInit pPhyInfo = 0x%x read=0x%x
  966.        write=0x%x tbl=0x%x addr=0x%x
  967.        flags=0x%x n"),
  968.        (int) pDrvCtrl->pPhyInfo,
  969.        (int) pDrvCtrl->pPhyInfo->phyReadRtn,
  970.        (int) pDrvCtrl->pPhyInfo->phyWriteRtn,
  971.        (int) pDrvCtrl->pPhyInfo->phyAnOrderTbl,
  972.        (int) pDrvCtrl->pPhyInfo->phyAddr,
  973.        (int) pDrvCtrl->pPhyInfo->phyFlags);
  974.  
  975.     return (OK);
  976.     }
  978. /***************************************************************************
  979. * 
  980. * auMiiRead - read a PHY device register via MII
  981. * 
  982. * RETURNS: the contents of a PHY device register in retVal arg, OK always
  983. */
  984. LOCAL STATUS auMiiRead
  985.     (
  986.     AU_DRV_CTRL * pDrvCtrl,
  987.     UINT8 phyAdrs, /* PHY address to access */
  988.     UINT8 phyReg, /* PHY register to read */
  989.     UINT16 * pRetVal
  990.     )
  991.     {
  992.     int timeout;
  993.     
  994.     AU_MII_CONTROL = (phyAdrs << 11) | (phyReg << 6);
  996.     timeout = 20;
  997.     while (AU_MII_CONTROL & AU_MII_CONTROL_BUSY)
  998. {
  999. taskDelay (1);
  1000. if (--timeout == 0)
  1001.     {
  1002.     DRV_LOG (DRV_DEBUG_MII, "PHY access timeoutn",
  1003.      0, 0, 0, 0, 0, 0);
  1004.     return (ERROR);
  1005.     }
  1006. }
  1008.     *pRetVal = AU_MII_DATA;
  1009.     DRV_LOG (DRV_DEBUG_MII, "auMiiRead adr=%02x reg=%02x data=%04xn",
  1010.              phyAdrs, phyReg, *pRetVal, 0, 0, 0);
  1011.     return (OK);
  1012.     }
  1014. /***************************************************************************
  1015. *
  1016. * auMiiWrite - write to a PHY device register via MII
  1017. *
  1018. * RETURNS: OK or ERROR
  1019. */
  1021. LOCAL STATUS auMiiWrite
  1022.     (
  1023.     AU_DRV_CTRL * pDrvCtrl,
  1024.     UINT8 phyAdrs, /* PHY address to access */
  1025.     UINT8 phyReg, /* PHY register to write */
  1026.     UINT16 data /* Data to write */
  1027.     )
  1028.     {
  1029.     int timeout;
  1030.     
  1031.     DRV_LOG (DRV_DEBUG_MII, "auMiiWrite adr=%02x reg=%02x data=%04xn",
  1032.              phyAdrs, phyReg, data, 0, 0, 0);
  1034.     timeout = 20;
  1035.     while (AU_MII_CONTROL & AU_MII_CONTROL_BUSY)
  1036. {
  1037. taskDelay (1);
  1038. if (--timeout == 0)
  1039.     {
  1040.     DRV_LOG (DRV_DEBUG_MII, "PHY access timeoutn",
  1041.      0, 0, 0, 0, 0, 0);
  1042.     return (ERROR);
  1043.     }
  1044. }
  1046.     AU_MII_DATA = data;
  1047.     AU_MII_CONTROL = ((phyAdrs << 11) | (phyReg << 6)
  1048.   | AU_MII_CONTROL_WRITE);
  1050.     timeout = 20;
  1051.     while (AU_MII_CONTROL & AU_MII_CONTROL_BUSY)
  1052. {
  1053. taskDelay (1);
  1054. if (--timeout == 0)
  1055.     {
  1056.     DRV_LOG (DRV_DEBUG_MII, "PHY access timeoutn",
  1057.      0, 0, 0, 0, 0, 0);
  1058.     return (ERROR);
  1059.     }
  1060. }
  1062.     return (OK);
  1063.     }
  1065. /***************************************************************************
  1066. *
  1067. * auPhyFind - Find the first PHY.
  1068. *
  1069. * RETURNS: Address of PHY or 0xFF if not found.
  1070. */
  1072. LOCAL UINT8 auPhyFind
  1073.     (
  1074.     AU_DRV_CTRL *pDrvCtrl
  1075.     )
  1076.     {
  1077.     UINT16  miiData;
  1078.     UINT8   phyAddr;
  1080.     DRV_LOG (DRV_DEBUG_MII, "auMiiPhyFindn",
  1081.              0, 0, 0, 0, 0, 0);
  1083.     for (phyAddr = 0; phyAddr < (UINT8)AU_MAX_PHY; phyAddr++) 
  1084.         {
  1085.          auMiiRead (pDrvCtrl, phyAddr, MII_PHY_ID0, &miiData);
  1087.         /* Verify PHY address read */
  1089.         if ((miiData != 0xFFFF) && (miiData != 0)) /* Found PHY */
  1090.             {
  1091.     DRV_LOG (DRV_DEBUG_MII, "PHY @ %xn", phyAddr, 0,0,0,0,0);
  1092.             return (phyAddr);
  1093.             }
  1094.         }
  1096.     DRV_LOG (DRV_DEBUG_LOAD, "No PHY foundn", 0,0,0,0,0,0);
  1097.     return (0xFF);
  1098.     }
  1100. /*******************************************************************************
  1101. *
  1102. * auStart - start the device
  1103. *
  1104. * This function calls BSP functions to connect interrupts and start the
  1105. * device running in interrupt mode.
  1106. *
  1107. * RETURNS: OK or ERROR
  1108. */
  1110. LOCAL STATUS auStart
  1111.     (
  1112.     AU_DRV_CTRL *  pDrvCtrl /* device to be initialized */
  1113.     )
  1114.     {
  1115.     STATUS  result;
  1117.     pDrvCtrl->txCleaning = FALSE;
  1118.     pDrvCtrl->txBlocked  = FALSE;
  1120.     if (auMiiInit (pDrvCtrl) == ERROR)
  1121. return (ERROR);
  1123.     SYS_INT_CONNECT (pDrvCtrl, auInt, (int)pDrvCtrl, &result);
  1125.     if (result == ERROR)
  1126.         return ERROR;
  1128.     /* mark the interface as up */
  1130.     END_FLAGS_SET (&pDrvCtrl->endObj, (IFF_UP | IFF_RUNNING));
  1132.     DRV_LOG (DRV_DEBUG_LOAD, "Interrupt connected.n", 1, 2, 3, 4, 5, 6);
  1134.     SYS_INT_ENABLE (pDrvCtrl);
  1136.     DRV_LOG (DRV_DEBUG_LOAD, "interrupt enabled.n", 1, 2, 3, 4, 5, 6);
  1138.     return (OK);
  1139.     }
  1141. /*******************************************************************************
  1142. *
  1143. * auInt - handle controller interrupt
  1144. *
  1145. * This routine is called at interrupt level in response to an interrupt from
  1146. * the controller.
  1147. */
  1149. LOCAL void auInt
  1150.     (
  1151.     AU_DRV_CTRL *  pDrvCtrl /* device to be initialized */
  1152.     )
  1153.     {
  1154.     int i;
  1155.     int txDone = FALSE;
  1156.     int rxDone = FALSE;
  1158.     DRV_LOG (DRV_DEBUG_INT, "auInt control=%08x rising=%08x, req0 %08xn",
  1159.      AU_MAC_CONTROL, AU_INTC_RISING_EDGE_CLEAR(0),
  1160.      AU_INTC_REQUEST0_INT(0), 0, 0, 0);
  1162.     /* Acknowledge interrupt */
  1164.     SYS_INT_DISABLE(pDrvCtrl);
  1165.     SYS_WB_FLUSH();
  1167.     /* Examine receive buffers */
  1169.     for (i = 0; i < pDrvCtrl->rringSize; ++i)
  1170. {
  1171. if (AU_RX_ADDRESS(i) & (1 << 1))
  1172.     rxDone = TRUE;
  1173. }
  1175.     /* Examine transmit buffers */
  1177.     for (i = 0; i < pDrvCtrl->tringSize; ++i)
  1178. {
  1179. if (AU_TX_ADDRESS(i) & (1 << 1))
  1180.     txDone = TRUE;
  1181. }
  1183.     /* Have netTask handle all packets */
  1184.     if (rxDone || txDone)
  1185. {
  1186.         netJobAdd ((FUNCPTR)auHandleInt,(int)pDrvCtrl, 0, 0, 0, 0);
  1187. }
  1189.     if (pDrvCtrl->txBlocked)
  1190.         {
  1191.         pDrvCtrl->txBlocked = FALSE;
  1192.         netJobAdd ((FUNCPTR)muxTxRestart, (int)&pDrvCtrl->endObj, 0, 0, 0, 0);
  1193.         }
  1194.     }
  1196. /*******************************************************************************
  1197. *
  1198. * auHandleInt - task level interrupt service for all packets
  1199. *
  1200. * This routine is called at task level indirectly by the interrupt
  1201. * service routine to do any message received processing.
  1202. */
  1204. LOCAL void auHandleInt
  1205.     (
  1206.     AU_DRV_CTRL *  pDrvCtrl /* device to be initialized */
  1207.     )
  1208.     {
  1210. /*
  1211.  * Handle zero or more previously transmitted frames
  1212.  */
  1213. while (AU_TX_ADDRESS(pDrvCtrl->tmdLastIndex) & (1<<1))
  1214. {
  1215. AU_TX_ADDRESS(pDrvCtrl->tmdLastIndex) = 0;
  1216.      pDrvCtrl->tmdLastIndex = (pDrvCtrl->tmdLastIndex + 1) &
  1217.  (pDrvCtrl->tringSize - 1);
  1218. }
  1219. SYS_WB_FLUSH();
  1221. /*
  1222.  * Handle zero or more newly received frames
  1223.  */
  1224. while (AU_RX_ADDRESS(pDrvCtrl->rmdIndex) & (1<<1)) auRecv (pDrvCtrl);
  1226. /* 
  1227.  * Re-enable interrupts 
  1228.  */
  1229. SYS_INT_ENABLE(pDrvCtrl);
  1230. SYS_WB_FLUSH();
  1232.     }
  1234. /*******************************************************************************
  1235. *
  1236. * auRecv - process the next incoming packet
  1237. *
  1238. * RETURNS: OK/ERROR
  1239. */
  1241. LOCAL STATUS auRecv
  1242.     (
  1243.     AU_DRV_CTRL * pDrvCtrl /* device to be initialized */
  1244.     )
  1245.     {
  1246.     int len;
  1247.     M_BLK_ID pMblk;
  1248.     char * pCluster;
  1249.     char * pBuf;
  1250.     CL_BLK_ID pClBlk;
  1251.     UINT32 status;
  1252.     int rmdIndex;
  1254.     /* Extract packet particulators */
  1255. rmdIndex = pDrvCtrl->rmdIndex;
  1257.     status = AU_RX_STATUS(rmdIndex);
  1258.     len = AU_RX_STATUS (rmdIndex) & 0x3fff; /* get packet length */
  1259.     pBuf = pDrvCtrl->pRxMem[rmdIndex];
  1261.     DRV_LOG (DRV_DEBUG_RX, "auRecv index = %d status = %08x len=%dn",
  1262.      rmdIndex, status, len, 0, 0, 0);
  1263.     DRV_LOG (DRV_DEBUG_RX, "auRecv dst=%02x:%02x:%02x:%02x:%02x:%02xn",
  1264.      pBuf[0]&0xff, pBuf[1]&0xff, pBuf[2]&0xff,
  1265.      pBuf[3]&0xff, pBuf[4]&0xff, pBuf[5]&0xff);
  1266.     DRV_LOG (DRV_DEBUG_RX, "auRecv src=%02x:%02x:%02x:%02x:%02x:%02xn",
  1267.      pBuf[6]&0xff, pBuf[7]&0xff, pBuf[8]&0xff,
  1268.      pBuf[9]&0xff, pBuf[10]&0xff, pBuf[11]&0xff);
  1270.     /* If error flag OR if packet is not completely in one buffer */
  1272.     if (!len)
  1273. {
  1274. DRV_LOG (DRV_DEBUG_RX, "RMD error!n", 1, 2, 3, 4, 5, 6);
  1275. END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1276. goto cleanRXD; /* skip to clean up */
  1277. }
  1279.     /* If we cannot get a buffer to loan then bail out. */
  1281.     pCluster = netClusterGet (pDrvCtrl->endObj.pNetPool,
  1282.       pDrvCtrl->pClPoolId);
  1284.     if (pCluster == NULL)
  1285. {
  1286. DRV_LOG (DRV_DEBUG_RX, "Cannot loan!n", 1, 2, 3, 4, 5, 6);
  1287. END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1288.         pDrvCtrl->lastError.errCode = END_ERR_NO_BUF;
  1289.         muxError(&pDrvCtrl->endObj, &pDrvCtrl->lastError);
  1290. goto cleanRXD;
  1291. }
  1293.     if ((pClBlk = netClBlkGet (pDrvCtrl->endObj.pNetPool, M_DONTWAIT)) == NULL)
  1294. {
  1295. netClFree (pDrvCtrl->endObj.pNetPool, pCluster);
  1296. DRV_LOG (DRV_DEBUG_RX, "Out of Cluster Blocks!n", 1, 2, 3, 4, 5, 6);
  1297. END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1298.         pDrvCtrl->lastError.errCode = END_ERR_NO_BUF;
  1299.         muxError(&pDrvCtrl->endObj, &pDrvCtrl->lastError);
  1300. goto cleanRXD;
  1301. }
  1303.     /*
  1304.      * OK we've got a spare, let's get an M_BLK_ID and marry it to the
  1305.      * one in the ring.
  1306.      */
  1308.     if ((pMblk = mBlkGet(pDrvCtrl->endObj.pNetPool, M_DONTWAIT, MT_DATA))
  1309. == NULL)
  1310. {
  1311. netClBlkFree (pDrvCtrl->endObj.pNetPool, pClBlk);
  1312. netClFree (pDrvCtrl->endObj.pNetPool, pCluster);
  1313. DRV_LOG (DRV_DEBUG_RX, "Out of M Blocks!n", 1, 2, 3, 4, 5, 6);
  1314. END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1315.         pDrvCtrl->lastError.errCode = END_ERR_NO_BUF;
  1316.         muxError(&pDrvCtrl->endObj, &pDrvCtrl->lastError);
  1317. goto cleanRXD;
  1318. }
  1320.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_UCAST, +1);
  1322.     bcopy (pBuf, pCluster + pDrvCtrl->offset, len);
  1324.     /* Join the cluster to the MBlock */
  1326.     netClBlkJoin (pClBlk, pCluster, len, NULL, 0, 0, 0);
  1327.     netMblkClJoin (pMblk, pClBlk);
  1329.     pMblk->mBlkHdr.mData  += pDrvCtrl->offset;
  1330.     pMblk->mBlkHdr.mLen   = len;
  1331.     pMblk->mBlkHdr.mFlags |= M_PKTHDR;
  1332.     pMblk->mBlkPktHdr.len = len;
  1334.     AU_RX_STATUS(rmdIndex) = 0;
  1335.     AU_RX_ADDRESS(rmdIndex)
  1336.       = ((UINT32) AU_CACHE_VIRT_TO_PHYS(pDrvCtrl->pRxMem[rmdIndex])) | 1;
  1337. SYS_WB_FLUSH();
  1339.     /* Advance our management index */
  1340.     pDrvCtrl->rmdIndex = (pDrvCtrl->rmdIndex + 1) & (pDrvCtrl->rringSize - 1);
  1342.     DRV_LOG (DRV_DEBUG_RX, "auRecv clean index %d %08xn",
  1343.      rmdIndex, AU_RX_ADDRESS(rmdIndex) & 0x1f, 0, 0, 0, 0);
  1345.     /* Call the upper layer's receive routine. */
  1347.     END_RCV_RTN_CALL(&pDrvCtrl->endObj, pMblk);
  1349.     return (OK);
  1351. cleanRXD:
  1353.     /* Restore the receiver buffer */
  1355.     AU_RX_STATUS(rmdIndex) = 0;
  1356.     AU_RX_ADDRESS(rmdIndex)
  1357.       = ((UINT32) AU_CACHE_VIRT_TO_PHYS(pDrvCtrl->pRxMem[rmdIndex])) | 1;
  1358. SYS_WB_FLUSH();
  1361.     DRV_LOG (DRV_DEBUG_RX, "auRecv clean index %d %08xn",
  1362.      rmdIndex, AU_RX_ADDRESS(rmdIndex) & 0x1f, 0, 0, 0, 0);
  1364.     /* Advance our management index */
  1366.     pDrvCtrl->rmdIndex = (pDrvCtrl->rmdIndex + 1) & (pDrvCtrl->rringSize - 1);
  1368.     return (OK);
  1369.     }
  1371. /*******************************************************************************
  1372. *
  1373. * auSend - the driver send routine
  1374. *
  1375. * This routine takes a M_BLK_ID sends off the data in the M_BLK_ID.
  1376. * The buffer must already have the addressing information properly installed
  1377. * in it.  This is done by a higher layer.  The last arguments are a free
  1378. * routine to be called when the device is done with the buffer and a pointer
  1379. * to the argument to pass to the free routine.  
  1380. *
  1381. * RETURNS: OK or ERROR.
  1382. */
  1384. LOCAL STATUS auSend
  1385.     (
  1386.     AU_DRV_CTRL *  pDrvCtrl,  /* device to be initialized */
  1387.     M_BLK_ID  pMblk      /* data to send */
  1388.     )
  1389.     {
  1390.     char *        pBuf;
  1391.     int index;
  1392.     int          len = 0;
  1393. UINT32 addr;
  1395.     DRV_LOG (DRV_DEBUG_TX, "auSendn", 1, 2, 3, 4, 5, 6);
  1397.     /* check device mode */
  1399.     if (pDrvCtrl->flags & AU_POLLING)
  1400.         {
  1401.         netMblkClChainFree (pMblk);
  1402.         errno = EINVAL;
  1403.         return (ERROR);
  1404.         }
  1406.     /*
  1407.      * Obtain exclusive access to transmitter.  This is necessary because
  1408.      * we might have more than one stack transmitting at once.
  1409.      */
  1411.     END_TX_SEM_TAKE (&pDrvCtrl->endObj, WAIT_FOREVER);
  1413.     /* Advance our management index (first) */
  1415.     index = pDrvCtrl->tmdIndex;
  1417.     if (AU_TX_ADDRESS(index) & 0x03)
  1418. {
  1419.         /* Are we still on the first chunk? */
  1421.         DRV_LOG (DRV_DEBUG_TX, "Out of TMDs! addr=%08x astat=%08x stat=%08xn",
  1422.  AU_TX_ADDRESS(index) & ~0x1f,
  1423.  AU_TX_ADDRESS(index) & 0x1f,
  1424.  AU_TX_STATUS(index), 4, 5, 6);
  1425. #ifdef DRV_DEBUG
  1426. auDump (pDrvCtrl->unit);
  1427. #endif
  1428.         pDrvCtrl->txBlocked = TRUE;
  1429.         END_TX_SEM_GIVE (&pDrvCtrl->endObj);
  1430.         return (END_ERR_BLOCK);
  1431.         }
  1433.     pBuf = pDrvCtrl->pTxMem[index];
  1434.     DRV_LOG (DRV_DEBUG_TX, "pBuf = 0x%Xn", (int)pBuf, 2, 3, 4, 5, 6);
  1435.     if (pBuf == NULL)
  1436.         {
  1437.         pDrvCtrl->txBlocked = TRUE;
  1438.         END_TX_SEM_GIVE (&pDrvCtrl->endObj);
  1439.         return (END_ERR_BLOCK);
  1440.         }
  1442.     /* copy and release the packet */
  1443.     
  1444.     len = netMblkToBufCopy (pMblk, pBuf, NULL);
  1445.     netMblkClChainFree (pMblk);
  1447.     if (len < ETHERSMALL)
  1448. {
  1449. /* Pad to ETHERSMALL with zeros, required by H/W */
  1450. bzero (&pBuf[len], ETHERSMALL - len);
  1451. len = ETHERSMALL;
  1452. }
  1453.     addr  = ((UINT32)AU_CACHE_VIRT_TO_PHYS(pDrvCtrl->pTxMem[index]) | 1);
  1454. AU_TX_LENGTH(index) = len;
  1455. AU_TX_STATUS(index) = 0;
  1456.     AU_TX_ADDRESS(index) = addr;
  1457. SYS_WB_FLUSH();
  1459.     DRV_LOG (DRV_DEBUG_TX, "auSend: index %d len %dn",
  1460.              index, len, 3, 4, 5, 6);
  1462.     DRV_LOG (DRV_DEBUG_TX, "auSend dst=%02x:%02x:%02x:%02x:%02x:%02xn",
  1463.      pBuf[0]&0xff, pBuf[1]&0xff, pBuf[2]&0xff,
  1464.      pBuf[3]&0xff, pBuf[4]&0xff, pBuf[5]&0xff);
  1465.     DRV_LOG (DRV_DEBUG_TX, "auSend src=%02x:%02x:%02x:%02x:%02x:%02xn",
  1466.      pBuf[6]&0xff, pBuf[7]&0xff, pBuf[8]&0xff,
  1467.      pBuf[9]&0xff, pBuf[10]&0xff, pBuf[11]&0xff);
  1468.     
  1469.     /* Advance our management index */
  1471.     index = (pDrvCtrl->tmdIndex + 1) & (pDrvCtrl->tringSize - 1);
  1472.     pDrvCtrl->tmdIndex = index;
  1474.     /* Bump the statistic counter. */
  1476.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_UCAST, +1);
  1478.     END_TX_SEM_GIVE (&pDrvCtrl->endObj);
  1480.     DRV_LOG (DRV_DEBUG_TX, "auSend Donen", 1, 2, 3, 4, 5, 6);
  1482.     return (OK);
  1483.     }
  1485. /*******************************************************************************
  1486. *
  1487. * auIoctl - the driver I/O control routine
  1488. *
  1489. * Process an ioctl request.
  1490. *
  1491. * RETURNS OK or ERROR value
  1492. */
  1494. LOCAL int auIoctl
  1495.     (
  1496.     AU_DRV_CTRL *  pDrvCtrl, /* device to be initialized */
  1497.     int  cmd,   /* ioctl command to execute */
  1498.     caddr_t  data   /* data to get or set       */
  1499.     )
  1500.     {
  1501.     long  value;
  1502.     int  error = 0;
  1504.     switch (cmd)
  1505.         {
  1506.         case EIOCSADDR:
  1507.     if (data == NULL)
  1508. return (EINVAL);
  1509.             bcopy ((char *)data, (char *)END_HADDR(&pDrvCtrl->endObj),
  1510.    END_HADDR_LEN (&pDrvCtrl->endObj));
  1511.             break;
  1513.         case EIOCGADDR:
  1514.     if (data == NULL)
  1515. return (EINVAL);
  1516.             bcopy ((char *)END_HADDR (&pDrvCtrl->endObj), (char *)data,
  1517.     END_HADDR_LEN (&pDrvCtrl->endObj));
  1518.             break;
  1520.         case EIOCSFLAGS:
  1521.     value = (long)data;
  1522.             
  1523.     if (value < 0)
  1524. {
  1525. value = -value;
  1526. value--; /* HELP: WHY ??? */
  1527. END_FLAGS_CLR (&pDrvCtrl->endObj, value);
  1528. }
  1529.     else
  1530. {
  1531. END_FLAGS_SET (&pDrvCtrl->endObj, value);
  1532. }
  1533.     auConfig (pDrvCtrl);
  1534.             break;
  1535.         case EIOCGFLAGS:
  1536.     *(int *)data = END_FLAGS_GET (&pDrvCtrl->endObj);
  1537.             break;
  1539.         case EIOCMULTIADD:
  1540.             error = auMCastAddrAdd (pDrvCtrl, (char *) data);
  1541.             break;
  1543.         case EIOCMULTIDEL:
  1544.             error = auMCastAddrDel (pDrvCtrl, (char *) data);
  1545.             break;
  1547.         case EIOCMULTIGET:
  1548.             error = auMCastAddrGet (pDrvCtrl, (MULTI_TABLE *) data);
  1549.             break;
  1551. case EIOCPOLLSTART:
  1552.     error = auPollStart (pDrvCtrl);
  1553.     break;
  1555. case EIOCPOLLSTOP:
  1556.     error = auPollStop (pDrvCtrl);
  1557.     break;
  1559.         case EIOCGMIB2:
  1560.             if (data == NULL)
  1561.                 return (EINVAL);
  1562.             bcopy((char *)&pDrvCtrl->endObj.mib2Tbl, (char *)data,
  1563.                   sizeof(pDrvCtrl->endObj.mib2Tbl));
  1564.             break;
  1565.         case EIOCGFBUF:
  1566.             if (data == NULL)
  1567.                 return (EINVAL);
  1568.             *(int *)data = AU_MIN_FBUF;
  1569.             break;
  1570.         case EIOCGMWIDTH:
  1571.             if (data == NULL)
  1572.                 return (EINVAL);
  1573.             *(int *)data = 4;
  1574.             break;
  1575.         case EIOCGHDRLEN:
  1576.             if (data == NULL)
  1577.                 return (EINVAL);
  1578.             *(int *)data = 14;
  1579.             break;
  1580.         default:
  1581.             error = EINVAL;
  1582.         }
  1583.     return (error);
  1584.     }
  1586. /*******************************************************************************
  1587. *
  1588. * auReset - hardware reset of chip (stop it)
  1589. *
  1590. * This routine is responsible for resetting the device and switching into
  1591. * 32 bit mode.
  1592. *
  1593. * RETURNS: OK/ERROR
  1594. */
  1596. LOCAL int auReset
  1597.     (
  1598.     AU_DRV_CTRL *  pDrvCtrl /* device to be initialized */
  1599.     )
  1600.     {
  1601.     int i;
  1603.     DRV_LOG (DRV_DEBUG_LOAD, "auResetn", 1, 2, 3, 4, 5, 6);
  1605.     /* Reset MAC & DMA units */
  1606.     AU_MAC_ENABLE = 0;
  1608.     /* setup Rx memory pointers */
  1610.     pDrvCtrl->rmdIndex = 0;
  1611.     for (i = 0; i < pDrvCtrl->rringSize; ++i)
  1612.         {
  1613.         AU_RX_STATUS(i) = 0;
  1614.         AU_RX_ADDRESS(i) = 0;
  1615. }
  1617.     /* setup Tx memory pointers */
  1619.     pDrvCtrl->tmdIndex = 0;
  1620.     pDrvCtrl->tmdLastIndex = 0;
  1621.     for (i = 0; i < pDrvCtrl->tringSize; ++i)
  1622. {
  1623. AU_TX_STATUS(i) = 0;
  1624. AU_TX_LENGTH(i) = 0;
  1625. AU_TX_ADDRESS(i) = 0;
  1626. }
  1628. SYS_WB_FLUSH();
  1630.     return (OK);
  1631.     }
  1633. /*******************************************************************************
  1634. *
  1635. * auRestartSetup - setup memory descriptors and turn on chip
  1636. *
  1637. * This routine initializes all the shared memory structures and turns on
  1638. * the chip.
  1639. *
  1640. * RETURNS OK/ERROR
  1641. */
  1643. LOCAL STATUS auRestartSetup
  1644.     (
  1645.     AU_DRV_CTRL *  pDrvCtrl /* device to be initialized */
  1646.     )
  1647.     {  
  1648.     DRV_LOG (DRV_DEBUG_LOAD, "auRestartSetupn", 1, 2, 3, 4, 5, 6);
  1650.     /* reset the device */
  1652.     auReset (pDrvCtrl);
  1654.     DRV_LOG (DRV_DEBUG_LOAD, "Memory setup completen", 1, 2, 3, 4, 5, 6);
  1656.     /* reconfigure the device */
  1658.     auConfig (pDrvCtrl);
  1660.     return (OK);
  1661.     }
  1663. /*******************************************************************************
  1664. *
  1665. * auRestart - restart the device after a fatal error
  1666. *
  1667. * This routine takes care of all the messy details of a restart.  The device
  1668. * is reset and re-initialized.  The driver state is re-synchronized.
  1669. *
  1670. * RETURNS: N/A
  1671. */
  1673. LOCAL void auRestart
  1674.     (
  1675.     AU_DRV_CTRL *  pDrvCtrl /* device to be initialized */
  1676.     )
  1677.     {
  1678.     auRestartSetup (pDrvCtrl);
  1680.     /* set the flags to indicate readiness */
  1682.     END_OBJ_READY (&pDrvCtrl->endObj,
  1683.                     IFF_UP | IFF_RUNNING | IFF_NOTRAILERS | IFF_BROADCAST
  1684.                     | IFF_MULTICAST);
  1685.     }
  1687. /******************************************************************************
  1688. *
  1689. * auConfig - reconfigure the interface under us.
  1690. *
  1691. * Reconfigure the interface setting promiscuous mode, and changing the
  1692. * multicast interface list.
  1693. *
  1694. * RETURNS: N/A
  1695. */
  1697. LOCAL void auConfig
  1698.     (
  1699.     AU_DRV_CTRL *  pDrvCtrl /* device to be initialized */
  1700.     )
  1701.     {
  1702.     UCHAR * enetAddr;
  1703.     int i;
  1705.     DRV_LOG (DRV_DEBUG_LOAD, "auConfign", 1, 2, 3, 4, 5, 6);
  1707.     /* Set promiscuous mode if it's asked for. */
  1709.     if (END_FLAGS_GET (&pDrvCtrl->endObj) & IFF_PROMISC)
  1710.         {
  1711.         DRV_LOG (DRV_DEBUG_LOAD, "Setting promiscuous mode on!n",
  1712.                  1, 2, 3, 4, 5, 6);
  1714.         /* chip will be in promiscuous mode */
  1716.         pDrvCtrl->flags |= AU_PROMISCUOUS_FLAG; 
  1717.         }
  1718.     else
  1719.         {
  1720.         DRV_LOG (DRV_DEBUG_LOAD, "Setting promiscuous mode off!n",
  1721.                  1, 2, 3, 4, 5, 6);
  1723.         pDrvCtrl->flags &= ~AU_PROMISCUOUS_FLAG; 
  1724.         }
  1726.     /* Set up address filter for multicasting. */
  1728.     if (END_MULTI_LST_CNT (&pDrvCtrl->endObj) > 0)
  1729.         {
  1730.         auAddrFilterSet (pDrvCtrl);
  1731.         }
  1733.     /* Enable the MAC */
  1735.     AU_MAC_ENABLE = AU_MAC_ENABLE_CLOCKS_ONLY;
  1736.     SYS_WB_FLUSH();
  1737.     AU_MAC_ENABLE = AU_MAC_ENABLE_NORMAL & ~AU_MAC_ENABLE_TS;
  1738.     SYS_WB_FLUSH();
  1740.     /* Configure the MAC */
  1742. #if (_BYTE_ORDER == _BIG_ENDIAN)
  1743.     AU_MAC_CONTROL = AU_MAC_CONTROL_EM_BIG | AU_MAC_CONTROL_DO;
  1744. #else
  1745.     AU_MAC_CONTROL = AU_MAC_CONTROL_DO;
  1746. #endif
  1748.     enetAddr = pDrvCtrl->enetAddr;
  1749.     AU_MAC_ADDRESS_HIGH = (enetAddr[5] << 8) | enetAddr[4];
  1750.     AU_MAC_ADDRESS_LOW = ((enetAddr[3] << 24)
  1751.       | (enetAddr[2] << 16)
  1752.       | (enetAddr[1] << 8)
  1753.       | (enetAddr[0] << 0));
  1754.     DRV_LOG (DRV_DEBUG_LOAD, "mac   addr %08x %08xn",
  1755.      AU_MAC_ADDRESS_HIGH,
  1756.      AU_MAC_ADDRESS_LOW, 0, 0, 0, 0);
  1757.     DRV_LOG (DRV_DEBUG_LOAD, "multi addr %08x %08xn",
  1758.      AU_MULTICAST_HASH_ADDRESS_HIGH,
  1759.      AU_MULTICAST_HASH_ADDRESS_LOW, 0, 0, 0, 0);
  1761.     /* Configure MII */
  1763.     /* Setup RxD and TxD pointers */
  1765.     pDrvCtrl->rmdIndex = (AU_RX_ADDRESS(0) >> 2) & 0x03;
  1766.     pDrvCtrl->tmdIndex = (AU_TX_ADDRESS(0) >> 2) & 0x03;
  1767.     pDrvCtrl->tmdLastIndex = pDrvCtrl->tmdIndex;
  1769. #ifdef AU_PROMISCUOS_MODE
  1770.     /* Handle promiscuous mode */
  1771.     if (pDrvCtrl->flags & AU_PROMISCUOUS_FLAG)
  1772. AU_MAC_CONTROL |= AU_MAC_CONTROL_PR;
  1773. #endif
  1774.     for (i = 0; i < pDrvCtrl->rringSize; ++i)
  1775.         AU_RX_ADDRESS(i) 
  1776.           = ((UINT32) AU_CACHE_VIRT_TO_PHYS(pDrvCtrl->pRxMem[i])) | 1;
  1778.     /* Enable transmit and receive */
  1779.     AU_MAC_CONTROL |= AU_MAC_CONTROL_TE | AU_MAC_CONTROL_RE;
  1780.     SYS_WB_FLUSH();
  1781.     }
  1783. /******************************************************************************
  1784. *
  1785. * auAddrFilterSet - set the address filter for multicast addresses
  1786. *
  1787. * This routine goes through all of the multicast addresses on the list
  1788. * of addresses (added with the auAddrAdd() routine) and sets the
  1789. * device's filter correctly.
  1790. *
  1791. * RETURNS: N/A
  1792. */
  1794. LOCAL void auAddrFilterSet
  1795.     (
  1796.     AU_DRV_CTRL *  pDrvCtrl /* device to be initialized */
  1797.     )
  1798.     {
  1799.     ETHER_MULTI *  pCurr;
  1800.     UINT8 * pCp;
  1801.     UINT8  byte;
  1802.     UINT32  crc;
  1803.     int  len;
  1804.     int  count;
  1806.     pCurr = END_MULTI_LST_FIRST (&pDrvCtrl->endObj);
  1808.     while (pCurr != NULL)
  1809. {
  1810. pCp = (UINT8 *)&pCurr->addr;
  1812. crc = 0xffffffff;
  1814. for (len = AU_LA_LEN; --len >= 0;)
  1815.     {
  1816.     byte = *pCp++;
  1818.             for (count = 0; count < AU_LAF_LEN; count++)
  1819. {
  1820. if ((byte & 0x01) ^ (crc & 0x01))
  1821.     {
  1822.     crc >>= 1;
  1823.     crc = crc ^ AU_CRC_POLYNOMIAL;
  1824.     }
  1825. else
  1826.     {
  1827.     crc >>= 1;
  1828.     }
  1829. byte >>= 1;
  1830. }
  1831.     }
  1833. /* Just want the 6 most significant bits. */
  1835. crc = AU_CRC_TO_LAF_IX (crc);
  1837. pCurr = END_MULTI_LST_NEXT(pCurr);
  1838. }
  1839.     }
  1841. /*******************************************************************************
  1842. *
  1843. * auPollReceive - routine to receive a packet in polled mode.
  1844. *
  1845. * This routine is called by a user to try and get a packet from the
  1846. * device. This routine return OK if it is successful in getting the packet
  1847. *
  1848. * RETURNS: OK or EAGAIN.
  1849. */
  1851. LOCAL STATUS auPollReceive
  1852.     (
  1853.     AU_DRV_CTRL *  pDrvCtrl, /* device to be initialized */
  1854.     M_BLK_ID  pMblk
  1855.     )
  1856.     {
  1857.     int                 len;
  1858.     char *              pBuf;
  1859.     UINT32              status, ERROR_MASK=0x812bc000;
  1860.     int                 rmdIndex,oldLevel;
  1862.     DRV_LOG (DRV_DEBUG_POLL_RX, "PRX bn", 1, 2, 3, 4, 5, 6);
  1864.  /*
  1865.   * Handle zero or more newly received frames
  1866.   */
  1867. if (!(AU_RX_ADDRESS(pDrvCtrl->rmdIndex) & (1<<1)))
  1868.     {
  1869.     pDrvCtrl->rmdIndex = (pDrvCtrl->rmdIndex + 1) & (pDrvCtrl->rringSize - 1);
  1870.     /* goto cleanRx; */
  1871.     return (EAGAIN);
  1872.     }
  1874.     /* Extract packet particulators */
  1875.     rmdIndex = pDrvCtrl->rmdIndex;
  1876.     /* Read the device status register */
  1877.     status = AU_RX_STATUS(rmdIndex);
  1878.     len = AU_RX_STATUS (rmdIndex) & 0x3fff; /* get packet length */
  1879.     pBuf = pDrvCtrl->pRxMem[rmdIndex];
  1881.     if (status & (ERROR_MASK & ~0x0))
  1882.         {
  1883.         DRV_LOG (DRV_DEBUG_POLL_RX, "PRX bad errorn", 1, 2, 3, 4, 5, 6);
  1884. END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1886.         /* restart chip on fatal error */
  1887.         if (status & ERROR_MASK & 0x0)        /* memory error */
  1888.             {
  1889.     END_FLAGS_CLR (&pDrvCtrl->endObj, (IFF_UP | IFF_RUNNING)); 
  1890.             DRV_LOG (DRV_DEBUG_POLL_RX, "PRX restartn", 1, 2, 3, 4, 5, 6);
  1891.             auRestart (pDrvCtrl);
  1892.             return (EAGAIN);
  1893.             }
  1894.         /* goto cleanRx;  */
  1895.         goto cleanRx;
  1896.         }
  1898.     if (!len)
  1899.         {
  1900.         DRV_LOG (DRV_DEBUG_RX, "RMD error!n", 1, 2, 3, 4, 5, 6);
  1901.         END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1902.         goto cleanRx;                          /* skip to clean up */
  1903.         }
  1905.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_UCAST, +1);
  1907.     /* Upper layer provides the buffer. */
  1909.     if ((pMblk->mBlkHdr.mLen < len) || (!(pMblk->mBlkHdr.mFlags & M_EXT)))
  1910. {
  1911.         DRV_LOG (DRV_DEBUG_POLL_RX, "PRX bad mblk len:%d flags:%dn",
  1912.                  pMblk->mBlkHdr.mLen, pMblk->mBlkHdr.mFlags, 3, 4, 5, 6);
  1913. return (EAGAIN);
  1914. }
  1915.     pMblk->mBlkHdr.mData  += pDrvCtrl->offset;
  1916.     bcopy (pBuf, pMblk->mBlkHdr.mData, len);
  1918.     pMblk->mBlkHdr.mLen = len;
  1919.     pMblk->mBlkHdr.mFlags |= M_PKTHDR;
  1920.     pMblk->mBlkPktHdr.len = len;
  1922. cleanRx:
  1923.     /* Restore the receiver buffer */
  1925.     AU_RX_STATUS(rmdIndex) = 0;
  1926.     AU_RX_ADDRESS(rmdIndex)
  1927.       = ((UINT32) AU_CACHE_VIRT_TO_PHYS(pDrvCtrl->pRxMem[rmdIndex])) | 1;
  1928.     SYS_WB_FLUSH();
  1930.     DRV_LOG (DRV_DEBUG_RX, "auPollReceive clean index %d %08xn",
  1931.              rmdIndex, AU_RX_ADDRESS(rmdIndex) & 0x1f, 0, 0, 0, 0);
  1933.     /* Advance our management index */
  1934.     pDrvCtrl->rmdIndex = (pDrvCtrl->rmdIndex + 1) & (pDrvCtrl->rringSize - 1);
  1936.     DRV_LOG (DRV_DEBUG_POLL_RX, "PRX okn", 1, 2, 3, 4, 5, 6);
  1938.     return (OK);
  1939.     }
  1941. /*******************************************************************************
  1942. *
  1943. * auPollSend - routine to send a packet in polled mode.
  1944. *
  1945. * This routine is called by a user to try and send a packet on the
  1946. * device.
  1947. *
  1948. * RETURNS: OK or EAGAIN.
  1949. */
  1951. LOCAL STATUS auPollSend
  1952.     (
  1953.     AU_DRV_CTRL *  pDrvCtrl, /* device to be initialized */
  1954.     M_BLK_ID  pMblk
  1955.     )
  1956.     {
  1957.     char *        pBuf;
  1958.     int index;
  1959.     int          len = 0;
  1960.     int          oldLevel;
  1961.     UINT32 addr;
  1963.     DRV_LOG (DRV_DEBUG_POLL_TX, "PTX bn", 1, 2, 3, 4, 5, 6);
  1965.     /* Advance our management index (first) */
  1966.     index = pDrvCtrl->tmdIndex;
  1968.     if (AU_TX_ADDRESS(index) & 0x01) 
  1969.         {
  1970.         DRV_LOG (DRV_DEBUG_POLL_TX, "Out of tmds.n", 1, 2, 3, 4, 5, 6);
  1971.         
  1972.         if (!pDrvCtrl->txCleaning) 
  1973.     auTRingScrub (pDrvCtrl);
  1974. return (EAGAIN);
  1975.         }
  1977.     pBuf = pDrvCtrl->pTxMem[index];
  1978.     
  1979.     if (pBuf == NULL)
  1980.          return (EAGAIN);
  1982.     /* copy and release the packet */
  1983.     len = netMblkToBufCopy (pMblk, pBuf, NULL);
  1985.     if (len < ETHERSMALL)
  1986. {
  1987. /* Pad to ETHERSMALL with zeros, required by H/W */
  1988. bzero (&pBuf[len], ETHERSMALL - len);
  1989. len = ETHERSMALL;
  1990. }
  1992.     addr  = ((UINT32)AU_CACHE_VIRT_TO_PHYS(pDrvCtrl->pTxMem[index]) | 1);
  1993.     AU_TX_LENGTH(index) = len;
  1994.     AU_TX_STATUS(index) = 0;
  1995.     AU_TX_ADDRESS(index) = addr;
  1996.     SYS_WB_FLUSH();
  1998.     /* Bump the statistic counter. */
  2000.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_UCAST, +1);
  2002.     /* Spin until we think we've sent it.  */
  2003.     
  2004.     while (!(AU_TX_ADDRESS(index) & (1<<1)));
  2005.     AU_TX_ADDRESS(index) = 0;
  2006.     AU_TX_STATUS(index) = 0;
  2007.     AU_TX_LENGTH(index) = 0;
  2009.     SYS_WB_FLUSH();
  2010.     
  2011.     index = (pDrvCtrl->tmdIndex + 1) & (pDrvCtrl->tringSize - 1);
  2012.     pDrvCtrl->tmdIndex = index;
  2013.     pDrvCtrl->tmdLastIndex = (pDrvCtrl->tmdLastIndex + 1) &
  2014.                               (pDrvCtrl->tringSize - 1);
  2016.     DRV_LOG (DRV_DEBUG_POLL_TX, "PTX en", 1, 2, 3, 4, 5, 6);
  2018.     return (OK);
  2019.     }
  2021. /*****************************************************************************
  2022. *
  2023. * auMCastAddrAdd - add a multicast address for the device
  2024. *
  2025. * This routine adds a multicast address to whatever the driver
  2026. * is already listening for.  It then resets the address filter.
  2027. *
  2028. * RETURNS: OK
  2029. */
  2031. LOCAL STATUS auMCastAddrAdd
  2032.     (
  2033.     AU_DRV_CTRL *  pDrvCtrl, /* device to be initialized */
  2034.     char *  pAddress
  2035.     )
  2036.     {
  2037. #ifdef AU_END_MULTICAST
  2038.     int  error;
  2040.     if ((error = etherMultiAdd (&pDrvCtrl->endObj.multiList,
  2041. pAddress)) == ENETRESET)
  2042.     auConfig (pDrvCtrl);
  2043. #endif
  2044.     return (OK);
  2045.     }
  2047. /*****************************************************************************
  2048. *
  2049. * auMCastAddrDel - delete a multicast address for the device
  2050. *
  2051. * This routine removes a multicast address from whatever the driver
  2052. * is listening for.  It then resets the address filter.
  2053. *
  2054. * RETURNS: OK.
  2055. */
  2057. LOCAL STATUS auMCastAddrDel
  2058.     (
  2059.     AU_DRV_CTRL *  pDrvCtrl, /* device to be initialized */
  2060.     char *  pAddress
  2061.     )
  2062.     {
  2063. #if AU_END_MULTICAST
  2064.     int  error;
  2066.     if ((error = etherMultiDel (&pDrvCtrl->endObj.multiList,
  2067.      (char *)pAddress)) == ENETRESET)
  2068.     auConfig (pDrvCtrl);
  2069. #endif
  2070.     return (OK);
  2071.     }
  2073. /*****************************************************************************
  2074. *
  2075. * auMCastAddrGet - get the multicast address list for the device
  2076. *
  2077. * This routine gets the multicast list of whatever the driver
  2078. * is already listening for.
  2079. *
  2080. * RETURNS: OK/ERROR
  2081. */
  2083. LOCAL STATUS auMCastAddrGet
  2084.     (
  2085.     AU_DRV_CTRL *  pDrvCtrl, /* device to be initialized */
  2086.     MULTI_TABLE *  pTable
  2087.     )
  2088.     {
  2089.     int  error;
  2091.     error = etherMultiGet (&pDrvCtrl->endObj.multiList, pTable);
  2093.     return (error);
  2094.     }
  2096. /*******************************************************************************
  2097. *
  2098. * auStop - stop the device
  2099. *
  2100. * This function calls BSP functions to disconnect interrupts and stop
  2101. * the device from operating in interrupt mode.
  2102. *
  2103. * RETURNS: OK or ERROR
  2104. */
  2106. LOCAL STATUS auStop
  2107.     (
  2108.     AU_DRV_CTRL *  pDrvCtrl /* device to be initialized */
  2109.     )
  2110.     {
  2111.     STATUS  result = OK;
  2113.     /* Stop the device. */
  2115.     auReset (pDrvCtrl);
  2117.     SYS_INT_DISABLE (pDrvCtrl);
  2119.     /* mark the interface as down */
  2121.     END_FLAGS_CLR (&pDrvCtrl->endObj, (IFF_UP | IFF_RUNNING));
  2123.     /* disconnect the interrupt handler */
  2125.     SYS_INT_DISCONNECT (pDrvCtrl, auInt, (int)pDrvCtrl, &result);
  2127.     if (result == ERROR)
  2128. {
  2129. DRV_LOG (DRV_DEBUG_LOAD, "Could not disconnect interrupt!n",
  2130.                  1, 2, 3, 4, 5, 6);
  2131. }
  2133.     return (result);
  2134.     }
  2136. /******************************************************************************
  2137. *
  2138. * auUnload - unload a driver from the system
  2139. *
  2140. * This function first brings down the device, and then frees any
  2141. * stuff that was allocated by the driver in the load function. The controller
  2142. * structure should be free by who ever is calling this function.
  2143. *
  2144. * RETURNS: OK
  2145. */
  2147. LOCAL STATUS auUnload
  2148.     (
  2149.     AU_DRV_CTRL *  pDrvCtrl /* device to be initialized */
  2150.     )
  2151.     {
  2152.     END_OBJECT_UNLOAD (&pDrvCtrl->endObj);
  2154.     /* Free the shared DMA memory. */
  2156.     if (pDrvCtrl->pRxMem)
  2157. {
  2158. cacheDmaFree (pDrvCtrl->pRxMemBase);
  2159. pDrvCtrl->pRxMemBase = NULL;
  2160. }
  2161.     
  2162.     if (pDrvCtrl->pTxMem)
  2163. {
  2164. cacheDmaFree (pDrvCtrl->pTxMemBase);
  2165. pDrvCtrl->pTxMemBase = NULL;
  2166. }
  2168.     /* Free the shared DMA memory allocated for clusters */
  2169.     
  2170.     if (pDrvCtrl->flags & AU_MEM_ALLOC_FLAG)
  2171.         cacheDmaFree (pDrvCtrl->clDesc.memArea);
  2173.     /* Free the memory allocated for mBlks and clBlks */
  2174.     
  2175.     if (pDrvCtrl->mClCfg.memArea != NULL)
  2176.         free (pDrvCtrl->mClCfg.memArea);
  2178.     /* Free the memory allocated for driver pool structure */
  2180.     if (pDrvCtrl->endObj.pNetPool != NULL)
  2181.         free (pDrvCtrl->endObj.pNetPool);
  2183.     return (OK);
  2184.     }
  2187. /*******************************************************************************
  2188. *
  2189. * auPollStart - start polled mode operations
  2190. *
  2191. * RETURNS: OK or ERROR.
  2192. */
  2194. LOCAL STATUS auPollStart
  2195.     (
  2196.     AU_DRV_CTRL *  pDrvCtrl /* device to be initialized */
  2197.     )
  2198.     {
  2200.     SYS_INT_DISABLE(pDrvCtrl);
  2202.     pDrvCtrl->flags |= AU_POLLING;
  2204.     DRV_LOG (DRV_DEBUG_POLL, "POLL STARTEDn", 1, 2, 3, 4, 5, 6);
  2206.     return (OK);
  2207.     }
  2209. /*******************************************************************************
  2210. *
  2211. * auPollStop - stop polled mode operations
  2212. *
  2213. * RETURNS: OK or ERROR.
  2214. */
  2216. LOCAL STATUS auPollStop
  2217.     (
  2218.     AU_DRV_CTRL *  pDrvCtrl /* device to be initialized */
  2219.     )
  2220.     {
  2222.     SYS_INT_ENABLE(pDrvCtrl);
  2224.     pDrvCtrl->flags &= ~AU_POLLING;
  2226.     DRV_LOG (DRV_DEBUG_POLL, "STOPPEDn", 1, 2, 3, 4, 5, 6);
  2228.     return (OK);
  2229.     }
  2232. /******************************************************************************
  2233. *
  2234. * auTRingScrub - clean the transmit ring
  2235. *
  2236. * RETURNS: N/A
  2237. *
  2238. */
  2240. LOCAL void auTRingScrub
  2241.     (
  2242.     AU_DRV_CTRL *  pDrvCtrl /* device to be initialized */
  2243.     )
  2244.     {
  2245.     
  2246.     pDrvCtrl->txCleaning = TRUE;
  2247.     
  2248.     do
  2249.         {
  2250.         /* if the buffer is still owned by the MAC, don't touch it */
  2252. if (AU_TX_ADDRESS(pDrvCtrl->tmdLastIndex) & (1 << 1))
  2253.     break;
  2255. /* Clear the TX entry */
  2257.         DRV_LOG (DRV_DEBUG_TX, "auTRingScrub %dn",
  2258.  pDrvCtrl->tmdLastIndex, 0, 0, 0, 0, 0);
  2260. AU_TX_STATUS(pDrvCtrl->tmdLastIndex) = 0;
  2261. AU_TX_LENGTH(pDrvCtrl->tmdLastIndex) = 0;
  2262. AU_TX_ADDRESS(pDrvCtrl->tmdLastIndex) = 0;
  2264.         /* Increment the tmd disposal index pointer around the ring */
  2266.         pDrvCtrl->tmdLastIndex = (pDrvCtrl->tmdLastIndex + 1) &
  2267.       (pDrvCtrl->tringSize - 1);
  2268.         }
  2269.     while (pDrvCtrl->tmdLastIndex != pDrvCtrl->tmdIndex);
  2271.     pDrvCtrl->txCleaning = FALSE;
  2272.     }
  2274. /******************************************************************************
  2275. *
  2276. * auDump - display device status
  2277. *
  2278. */
  2280. void auDump
  2281.     (
  2282.     int unit
  2283.     )
  2284.     {
  2285. #ifdef DRV_DEBUG
  2286.     int i;
  2287.     AU_DRV_CTRL *  pDrvCtrl = dbgDrvCtrl[unit];
  2289.     /* Examine receive buffers */
  2291.     printf ("Rx index %d (rmdIndex=%d)n",
  2292.     (AU_RX_ADDRESS(0) >> 2) & 0x03,
  2293.     pDrvCtrl->rmdIndex);
  2294.     for (i = 0; i < pDrvCtrl->rringSize; ++i)
  2295. {
  2296. printf ("rx%d addr=%08x astat=%02x stat=%08x len=%dn", i,
  2297. AU_RX_ADDRESS(i) & ~0x1f,
  2298. AU_RX_ADDRESS(i) & 0x1f,
  2299. AU_RX_STATUS(i) & 0xffffc000,
  2300. AU_RX_STATUS(i) & 0x00003fff);
  2301.     printf ("receive %d donen", AU_RX_ADDRESS(i) & (1 << 1) ? 1 : 0);
  2302. }
  2304.     /* Examine transmit buffers */
  2306.     printf ("Tx index %dn",
  2307.     (AU_TX_ADDRESS(0) >> 2) & 0x03);
  2308.     for (i = 0; i < pDrvCtrl->tringSize; ++i)
  2309. {
  2310. printf ("tx%d addr=%08x astat=%02x stat=%08x len=%dn", i,
  2311. AU_TX_ADDRESS(i) & ~0x1f,
  2312. AU_TX_ADDRESS(i) & 0x1f,
  2313. AU_TX_STATUS(i),
  2314. AU_TX_LENGTH(i));
  2315.     printf ("transmit %d donen", AU_TX_ADDRESS(i) & (1 << 1) ? 1 : 0);
  2316. }
  2317. #endif
  2318.     }