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

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

VxWorks

开发平台：

C/C++

elt3c509End.c：源码内容
  1. /* elt3c509End.c - END  network interface driver  for 3COM 3C509*/
  3. /* Copyright 1984-2001 Wind River Systems, Inc. */
  5. #include "copyright_wrs.h"
  7. /*
  8. modification history
  9. --------------------
  10. 01j,17jun02,dmh  increased delay loop in elt3c509EepromRead SPR# 78830
  11. 01i,28aug00,stv  corrected the handling of EIOCSFLAGS ioctl (SPR# 29423).
  12. 01h,02aug00,jkf  Added statistics definitions to this file, SPR#26952.
  13. 01g,11jun00,ham  removed reference to etherLib.
  14. 01f,27jan00,dat  fixed use of NULL, removed warnings
  15. 01e,01dec99,stv  freed mBlk chain before returning ERROR (SPR #28492).
  16. 01d,29mar99,dat  SPR 26119, documentation, usage of .bS/.bE
  17. 01c,10mar99,sbs  added checking for non-zero value of nRxFrames.
  18. 01b,06dec98,ms_  remove comment about "assumptions stated below", which we
  19.                  think
  20. is leftover from the template lance driver.
  21. 01a,28sep98,snk  written by mBedded Innovations Inc.
  22. */
  24. /*
  25. DESCRIPTION
  26. This module implements the 3COM 3C509 EtherLink III Ethernet network 
  27. interface driver.
  28. This driver is designed to be moderately generic.  Thus, it operates 
  29. unmodified across the range of architectures and targets supported by 
  30. VxWorks.  To achieve this, the driver load routine requires an input 
  31. string consisting of several target-specific values.  The driver also 
  32. requires some external support routines.  These target-specific values 
  33. and the external support routines are described below.  
  35. BOARD LAYOUT
  36. This device is on-board.  No jumpering diagram is necessary.
  38. EXTERNAL INTERFACE
  39. The only external interface is the elt3c509Load() routine, which expects
  40. the <initString> parameter as input.  This parameter passes in a 
  41. colon-delimited string of the format:
  43. <unit>:<port>:<intVector>:<intLevel>:<attachementType>:<nRxFrames>
  45. The elt3c509Load() function uses strtok() to parse the string.
  47. TARGET-SPECIFIC PARAMETERS
  48. .IP <unit>
  49. A convenient holdover from the former model.  This parameter is used only
  50. in the string name for the driver.
  51. .IP <intVector>
  52. Configures the ELT device to generate hardware interrupts
  53. for various events within the device. Thus, it contains
  54. an interrupt handler routine.  The driver calls intConnect() to connect
  55. its interrupt handler to the interrupt vector generated as a result of
  56. the ELT interrupt.
  57. .IP <intLevel>
  58. This parameter is passed to an external support routine, sysEltIntEnable(),
  59. which is described below in "External Support Requirements." This routine 
  60. is called during as part of driver's initialization.  It handles any 
  61. board-specific operations required to allow the servicing of a ELT 
  62. interrupt on targets that use additional interrupt controller devices to 
  63. help organize and service the various interrupt sources.  This parameter 
  64. makes it possible for this driver to avoid all board-specific knowledge of 
  65. such devices.  
  66. .IP <attachmentType>
  67. This parameter is used to select the transceiver hardware attachment. 
  68. This is then used by the elt3c509BoardInit() routine to activate the 
  69. selected attachment. elt3c509BoardInit() is called as a part of the driver's
  70. initialization.
  71. .IP <nRxFrames>
  72. This parameter is used as number of receive frames by the driver.
  74. EXTERNAL SUPPORT REQUIREMENTS
  75. This driver requires several external support functions, defined as macros:
  76. .CS
  77.     SYS_INT_CONNECT(pDrvCtrl, routine, arg)
  78.     SYS_INT_DISCONNECT (pDrvCtrl, routine, arg)
  79.     SYS_INT_ENABLE(pDrvCtrl)
  80.     SYS_INT_DISABLE(pDrvCtrl)
  81.     SYS_OUT_BYTE(pDrvCtrl, reg, data)
  82.     SYS_IN_BYTE(pDrvCtrl, reg, data)
  83.     SYS_OUT_WORD(pDrvCtrl, reg, data)
  84.     SYS_IN_WORD(pDrvCtrl, reg, data)
  85.     SYS_OUT_WORD_STRING(pDrvCtrl, reg, pData, len)
  86.     SYS_IN_WORD_STRING(pDrvCtrl, reg, pData, len)
  87.     
  88.     sysEltIntEnable(pDrvCtrl->intLevel) 
  89.     sysEltIntDisable(pDrvCtrl->intLevel) 
  90. .CE
  92. There are default values in the source code for these macros.  They presume
  93. IO-mapped accesses to the device registers and the normal intConnect(),
  94. and intEnable() BSP functions.  The first argument to each is the device
  95. controller structure. Thus, each has access back to all the device-specific
  96. information.  Having the pointer in the macro facilitates the addition 
  97. of new features to this driver.
  99. The macros SYS_INT_CONNECT, SYS_INT_DISCONNECT, and SYS_INT_ENABLE allow
  100. the driver to be customized for BSPs that use special versions of these
  101. routines.
  103. The macro SYS_INT_CONNECT is used to connect the interrupt handler to
  104. the appropriate vector.  By default it is the routine intConnect().
  106. The macro SYS_INT_DISCONNECT is used to disconnect the interrupt handler prior
  107. to unloading the module.  By default this is a dummy routine that
  108. returns OK.
  110. The macro SYS_INT_ENABLE is used to enable the interrupt level for the
  111. end device.  It is called once during initialization.  It calls an
  112. external board level routine sysEltIntEnable(). 
  114. The macro SYS_INT_DISABLE is used to disable the interrupt level for the
  115. end device.  It is called during stop.  It calls an
  116. external board level routine sysEltIntDisable(). 
  118. SYSTEM RESOURCE USAGE
  119. When implemented, this driver requires the following system resources:
  121.     - one interrupt vector
  122.     - 9720 bytes of text
  123.     - 88 bytes in the initialized data section (data)
  124.     - 0 bytes of bss
  126. The driver requires 1520 bytes of preallocation for Transmit Buffer and 
  127. 1520*nRxFrames of receive buffers. The default value of nRxFrames is 64
  128. therefore total pre-allocation is (64 + 1)*1520.
  130. TUNING HINTS
  131. nRxFrames parameter can be used for tuning no of receive frames to be used
  132. for handling packet receive. More no. of these could help receiving more 
  133. loaning in case of massive reception.
  135. INTERNAL
  136. This driver is END compliant. It supports Multicasting and Poll mode Send and
  137. Receive capabilities. The initialization calls elt3c509BoardInit(), which 
  138. initializes the ELT3C509 chip, and elt3c509MemInit() routine which initializes
  139. memory allocation for Tx and Rx functionality. One mblk chain is allocated for 
  140. storing Tx frame and nRxFrame(64) mblk chainss are allocated for Rx frames.
  141. When a receive interrupt is received, netJobAdd() is called to schedule
  142. elt3c509HandlePktsRcv() routine for handling reception of the packets. This 
  143. routine empties the FIFO in a mblk chain and loops for more packets.
  144. The cluster is then passed up to the Receive routine of the upper layer.
  146. To transmit a packet, contents of mblk are copied into the TxFrame which is
  147. used to fill the FIFO of the chip. Transmit complete interrupt is used to 
  148. check for status of the transmission.
  150. When Polling mode is enabled, both for Tx and Rx together, elt3c509PollRcv()
  151. routine gets the packet out of the FIFO, copies into the mblk. For Tx in 
  152. Poll mode, elt3c509PollSend(0 routine is called by the upper layer, the data
  153. is copied into the TxFrame from the mblk and sent out. The interrupt is 
  154. disabled for transmit complete.
  156. Multicast addresses are handled by setting/resetting the RX_F_MULTICAST bit
  157. in the chip. When an address is added, the bit is set. When an address is 
  158. removed and the address list is empty, the bit is reset.
  160. INCLUDES:
  161. end.h endLib.h etherMultiLib.h elt3c509End.h
  163. SEE ALSO: muxLib, endLib
  164. .I "Writing an Enhanced Network Driver"
  165. */
  167. /* includes */
  169. #include "vxWorks.h"
  170. #include "wdLib.h"
  171. #include "stdlib.h"
  172. #include "taskLib.h"
  173. #include "logLib.h"
  174. #include "intLib.h"
  175. #include "netLib.h"
  176. #include "stdio.h"
  177. #include "stdlib.h"
  178. #include "sysLib.h"
  179. #include "iv.h"
  180. #include "memLib.h"
  181. #include "semLib.h"
  182. #include "cacheLib.h"
  183. #include "sys/ioctl.h"
  184. #include "etherMultiLib.h" /* multicast stuff. */
  185. #include "end.h" /* Common END structures. */
  186. #include "endLib.h"
  187. #include "lstLib.h" /* Needed to maintain protocol list. */
  188. #include "netBufLib.h"
  189. #include "muxLib.h"
  190. #include "m2Lib.h"
  191. #include "drv/end/elt3c509End.h"
  193. /* statistic macro's */
  195. #define collisions      elt3c509Stats[0]
  196. #define crcs            elt3c509Stats[1]
  197. #define aligns          elt3c509Stats[2]
  198. #define rxnobuffers     elt3c509Stats[3]
  199. #define rxoverruns      elt3c509Stats[4]
  200. #define disabled        elt3c509Stats[5]
  201. #define deferring       elt3c509Stats[6]
  202. #define txunderruns     elt3c509Stats[7]
  203. #define aborts          elt3c509Stats[8]
  204. #define outofwindow     elt3c509Stats[9]
  205. #define heartbeats      elt3c509Stats[10]
  206. #define badPacket       elt3c509Stats[11]
  207. #define shortPacket     elt3c509Stats[12]
  208. #define txnoerror       elt3c509Stats[13]
  209. #define rxnoerror       elt3c509Stats[14]
  210. #define txerror         elt3c509Stats[15]
  211. #define rxerror         elt3c509Stats[16]
  212. #define overwrite       elt3c509Stats[17]
  213. #define wrapped         elt3c509Stats[18]
  214. #define interrupts      elt3c509Stats[19]
  215. #define elt3c509_reset  elt3c509Stats[20]
  216. #define strayint        elt3c509Stats[21]
  217. #define multcollisions  elt3c509Stats[22]
  218. #define latecollisions  elt3c509Stats[23]
  219. #define nocarriers      elt3c509Stats[24]
  220. #define jabbers         elt3c509Stats[25]
  221. #define txoverruns      elt3c509Stats[26]
  222. #define rxunderruns     elt3c509Stats[27]
  223. #define rxearly         elt3c509Stats[28]
  224. #ifdef ELT_TIMING       
  225. #define timerUpdates    elt3c509Stats[29]
  226. #define timerOverflow   elt3c509Stats[30]
  227. #define timerInvalid    elt3c509Stats[31]
  228. #define maxRxLatency    elt3c509Stats[32]
  229. #define minRxLatency    elt3c509Stats[33]
  230. #define maxIntLatency   elt3c509Stats[34]
  231. #define taskQRxOuts     elt3c509Stats[35]
  232. #define maxRxTaskQ      elt3c509Stats[36]  
  233. #define taskQTxOuts     elt3c509Stats[37]  
  234. #define maxTxTaskQ      elt3c509Stats[38]  
  235. #endif /* ELT_TIMING */ 
  237. /* Cache macros */
  239. #define ELT3C509_CACHE_INVALIDATE(address, len) 
  240.         CACHE_DRV_INVALIDATE (&pDrvCtrl->cacheFuncs, (address), (len))
  242. #define ELT3C509_CACHE_PHYS_TO_VIRT(address) 
  243.         CACHE_DRV_PHYS_TO_VIRT (&pDrvCtrl->cacheFuncs, (address))
  245. #define ELT3C509_CACHE_VIRT_TO_PHYS(address) 
  246.         CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, (address))
  248. /*
  249.  * Default macro definitions for BSP interface.
  250.  * These macros can be redefined in a wrapper file, to generate
  251.  * a new module with an optimized interface.
  252.  */
  254. /* Macro to connect interrupt handler to vector */
  256. #ifndef SYS_INT_CONNECT
  257. #   define SYS_INT_CONNECT(pDrvCtrl,rtn,arg,pResult) 
  258. { 
  259. *pResult = intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (pDrvCtrl->ivec), 
  260.      rtn, (int)arg); 
  261. }
  262. #endif
  264. /* Macro to disconnect interrupt handler from vector */
  266. #ifndef SYS_INT_DISCONNECT
  267. #   define SYS_INT_DISCONNECT(pDrvCtrl,rtn,arg,pResult) 
  268. { 
  269. *pResult = OK;  
  270. }
  271. #endif
  273. /* Macro to enable the appropriate interrupt level */
  275. #ifndef SYS_INT_ENABLE
  276. #   define SYS_INT_ENABLE(pDrvCtrl) 
  277. { 
  278. IMPORT void sysEltIntEnable(); 
  279. sysEltIntEnable (pDrvCtrl->intLevel); 
  280. }
  281. #endif
  283. /* Macro to disable the appropriate interrupt level */
  285. #ifndef SYS_INT_DISABLE
  286. #   define SYS_INT_DISABLE(pDrvCtrl) 
  287. { 
  288. IMPORT void sysEltIntDisable (); 
  289. sysEltIntDisable (pDrvCtrl->intLevel); 
  290. }
  291. #endif
  293. /*
  294.  * Macros to do a byte access to the chip. Uses
  295.  * sysOutByte() and sysInByte().
  296.  */
  298. #ifndef SYS_OUT_BYTE
  299. #   define SYS_OUT_BYTE(pDrvCtrl,addr,value) 
  300. { 
  301.         sysOutByte((addr), (value)); 
  302. }
  303. #endif
  305. #ifndef SYS_IN_BYTE
  306. #   define SYS_IN_BYTE(pDrvCtrl,addr,data) 
  307.         { 
  308.         (data) = sysInByte((addr)); 
  309.         }
  310. #endif 
  311. /*
  312.  * Macros to do a word access to the chip. Uses
  313.  * sysOutWord() and sysInWord().
  314.  */
  316. #ifndef SYS_OUT_WORD
  317. #   define SYS_OUT_WORD(pDrvCtrl,addr,value) 
  318. { 
  319.         sysOutWord((addr), (value)); 
  320. }
  321. #endif
  323. #ifndef SYS_IN_WORD
  324. #   define SYS_IN_WORD(pDrvCtrl,addr,data) 
  325.         { 
  326.         (data) = sysInWord((addr)); 
  327.         }
  328. #endif 
  330. #ifndef SYS_IN_WORD_STRING
  331. #define SYS_IN_WORD_STRING(pDrvCtrl, reg, pData, len) 
  332. { 
  333.         sysInWordString ((reg), (pData),(len)); 
  334. }
  335. #endif
  337. #ifndef SYS_OUT_WORD_STRING
  338. #define SYS_OUT_WORD_STRING(pDrvCtrl, reg, pData, len) 
  339. { 
  340.         sysOutWordString ((reg),(pData), (len)); 
  341. }
  342. #endif
  346. /* A shortcut for getting the hardware address from the MIB II stuff. */
  348. #define END_HADDR(pEnd)
  349. ((pEnd)->mib2Tbl.ifPhysAddress.phyAddress)
  351. #define END_HADDR_LEN(pEnd) 
  352. ((pEnd)->mib2Tbl.ifPhysAddress.addrLength)
  355. #define VOID_TO_DRVCTRL(pVoid,pDrvCtrl) ((pDrvCtrl)=(ELT3C509_DEVICE *)(pVoid))
  357. /* externs */
  358. IMPORT int endMultiLstCnt (END_OBJ *);
  361. M_CL_CONFIG elt3c509MclConfig =  /* network mbuf configuration table */
  362.     {
  363.     /* 
  364.     no. mBlks no. clBlks memArea memSize
  365.     ----------- ---------- ------- -------
  366.     */
  367.     0,  0,  NULL,  0
  368.     };
  370. CL_DESC elt3c509ClDescTbl [] =  /* network cluster pool configuration table */
  371.     {
  372.     /* 
  373.     clusterSize num memArea memSize
  374.     ----------- ---- ------- -------
  375.     */
  376.     {ELT3C509_BUFSIZ, 0, NULL, 0}
  377.     }; 
  379. int elt3c509ClDescTblNumEnt = (NELEMENTS(elt3c509ClDescTbl));
  381. /* DEBUG MACROS */
  383. #undef DRV_DEBUG
  384. #ifdef DRV_DEBUG
  386. int  elt3c509Debug = 0x0f;  /* Turn it off initially. */
  387. NET_POOL * pEltPool;
  389. #define ENDLOGMSG(x) 
  390. if (elt3c509Debug) 
  391.     { 
  392.     logMsg x; 
  393.     }
  394. #else
  395. #define ENDLOGMSG(x)
  396. #endif /* DRV_DEBUG */
  398. /* forward static functions */
  400.       STATUS elt3c509Parse (ELT3C509_DEVICE *, char *);
  401. LOCAL STATUS elt3c509Start (void * pEnd);
  402. LOCAL STATUS elt3c509Stop (void * pEnd);
  403. LOCAL STATUS elt3c509Unload (void * pEnd);
  404. LOCAL int elt3c509Ioctl (void * pEnd, int cmd, caddr_t data);
  405. LOCAL STATUS elt3c509Send (void * pEnd, M_BLK_ID pBuf);
  406. LOCAL STATUS elt3c509MCastAdd (void * pEnd, char * pAddress);
  407. LOCAL STATUS elt3c509MCastDel (void * pEnd, char * pAddress);
  408. LOCAL STATUS elt3c509MCastGet (void * pEnd, MULTI_TABLE * pTable);
  409. LOCAL STATUS elt3c509PollSend (void * pEnd, M_BLK_ID pBuf);
  410. LOCAL STATUS elt3c509PollRcv (void * pEnd, M_BLK_ID pBuf);
  411. LOCAL void elt3c509Reset (ELT3C509_DEVICE * pDrvCtrl);
  412. LOCAL void elt3c509Int (ELT3C509_DEVICE * pDrvCtrl);
  413. LOCAL void elt3c509HandlePktsRcv (ELT3C509_DEVICE * pDrvCtrl);
  414. LOCAL STATUS    elt3c509BoardInit (ELT3C509_DEVICE * pDrvCtrl);
  415. LOCAL void elt3c509Config (ELT3C509_DEVICE * pDrvCtrl);
  416. LOCAL STATUS elt3c509PollStart (ELT3C509_DEVICE * pDrvCtrl);
  417. LOCAL STATUS elt3c509PollStop (ELT3C509_DEVICE * pDrvCtrl);
  418. LOCAL STATUS elt3c509MemInit (ELT3C509_DEVICE * pDrvCtrl);
  419. LOCAL void elt3c509IntDisable (ELT3C509_DEVICE * pDrvCtrl);
  420. LOCAL void elt3c509IntEnable (ELT3C509_DEVICE * pDrvCtrl);
  421. LOCAL void elt3c509RxStart (ELT3C509_DEVICE * pDrvCtrl);
  422. LOCAL void elt3c509TxStart (ELT3C509_DEVICE * pDrvCtrl);
  423. LOCAL STATUS elt3c509Activate (ELT3C509_DEVICE * pDrvCtrl);
  424. LOCAL void elt3c509IdCommand (int idPort);
  425. LOCAL UINT16 elt3c509IdEepromRead (int address);
  426. LOCAL int elt3c509EepromRead (int port, int offset);
  427. LOCAL void  elt3c509IntMaskSet (ELT3C509_DEVICE * pDrvCtrl, int maskBits);
  428. LOCAL void  elt3c509StatFlush (ELT3C509_DEVICE * pDrvCtrl);
  430. /* LOCALS */
  432. /*
  433.  * Declare our function table.  This is static across all driver
  434.  * instances.
  435.  */
  437. LOCAL NET_FUNCS elt3c509FuncTable =
  438.     {
  439.     (FUNCPTR)elt3c509Start,     /* Function to start the device. */
  440.     (FUNCPTR)elt3c509Stop, /* Function to stop the device. */
  441.     (FUNCPTR)elt3c509Unload, /* Unloading function for the driver. */
  442.     (FUNCPTR)elt3c509Ioctl, /* Ioctl function for the driver. */
  443.     (FUNCPTR)elt3c509Send, /* Send function for the driver. */
  444.     (FUNCPTR)elt3c509MCastAdd, /* Multicast address add function for the */
  445. /* driver. */
  446.     (FUNCPTR)elt3c509MCastDel, /* Multicast address delete function for */
  447. /* the driver. */
  448.     (FUNCPTR)elt3c509MCastGet, /* Multicast table retrieve function for */
  449. /* the driver. */
  450.     (FUNCPTR)elt3c509PollSend, /* Polling send function for the driver. */
  451.     (FUNCPTR)elt3c509PollRcv, /* Polling receive function for the driver. */
  452.     endEtherAddressForm,        /* Put address info into a packet.  */
  453.     endEtherPacketDataGet,      /* Get a pointer to packet data. */
  454.     endEtherPacketAddrGet       /* Get packet addresses. */
  455.     };
  457. /*******************************************************************************
  458. *
  459. * elt3c509Load - initialize the driver and device
  460. *
  461. * This routine initializes the driver and the device to the operational state.
  462. * All of the device-specific parameters are passed in <initString>, which
  463. * expects a string of the following format:
  464. *
  465. * <unit>:<port>:<intVector>:<intLevel>:<attachementType>:<noRxFrames>
  466. *
  467. * This routine can be called in two modes. If it is called with an empty but
  468. * allocated string, it places the name of this device (that is, "elt") into 
  469. * the <initString> and returns 0.
  470. *
  471. * If the string is allocated and not empty, the routine attempts to load
  472. * the driver using the values specified in the string.
  473. *
  474. * RETURNS: An END object pointer, or NULL on error, or 0 and the name of the
  475. * device if the <initString> was NULL.
  476. */
  478. END_OBJ * elt3c509Load
  479.     (
  480.     char * initString /* String to be parsed by the driver. */
  481.     )
  482.     {
  483.     ELT3C509_DEVICE *  pDrvCtrl;
  484.     int    productID;
  485.     short *  pAddr;
  487.     ENDLOGMSG (("Loading elt3c...n", 1, 2, 3, 4, 5, 6));
  489.     if (initString == NULL)
  490.         return (NULL);
  491.     
  492.     if (initString [0] == 0)
  493.         {
  494.         bcopy ((char *)ELT3C509_DEV_NAME, initString, ELT3C509_DEV_NAME_LEN);
  495.         return (0);
  496.         }
  498.     /* allocate the device structure */
  500.     pDrvCtrl = (ELT3C509_DEVICE *)calloc (sizeof (ELT3C509_DEVICE), 1);
  501.     if (pDrvCtrl == NULL)
  502. goto errorExit;
  504.     /* parse the init string, filling in the device structure */
  506.     if (elt3c509Parse (pDrvCtrl, initString) == ERROR)
  507. goto errorExit;
  509.     /* initialize the END and MIB2 parts of the structure */
  511.     /*
  512.      * The M2 element must come from m2Lib.h 
  513.      * 
  514.      */
  515.     
  516.     if (END_OBJ_INIT (&pDrvCtrl->endObj, (DEV_OBJ *)pDrvCtrl,
  517.                       ELT3C509_DEV_NAME,
  518.                       pDrvCtrl->unit, &elt3c509FuncTable,
  519.                       "3COM 3c509 EtherLink III Endhanced Network Driver.")
  520.         == ERROR)
  521.         goto errorExit;
  523.     productID = elt3c509EepromRead (pDrvCtrl->port, EE_A_PRODUCT_ID);
  524.     if (productID == ELT_PRODUCTID_3C589)
  525. {
  526.         pAddr = (short *)pDrvCtrl->enetAddr;
  527. *pAddr++ = htons (elt3c509EepromRead
  528.                           (pDrvCtrl->port, EE_A_OEM_NODE_0));
  529. *pAddr++ = htons (elt3c509EepromRead
  530.                           (pDrvCtrl->port, EE_A_OEM_NODE_1));
  531. *pAddr++ = htons (elt3c509EepromRead
  532.                       (pDrvCtrl->port, EE_A_OEM_NODE_2));
  534. SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND,
  535.                     SELECT_WINDOW | WIN_CONFIG);
  536. SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ADDRESS_CONFIG,
  537.                     elt3c509EepromRead (pDrvCtrl->port, EE_A_ADDRESS));
  538. SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + RESOURCE_CONFIG,
  539.                     elt3c509EepromRead (pDrvCtrl->port,EE_A_RESOURCE));
  540. }
  541.     else
  542.         {
  543.         if (elt3c509Activate (pDrvCtrl) != OK)
  544.             return (NULL);
  545.         }
  547.     if (END_MIB_INIT (&pDrvCtrl->endObj, M2_ifType_ethernet_csmacd,
  548.                       &pDrvCtrl->enetAddr[0], 6, ETHERMTU, ELT3C509_SPEED)
  549.          == ERROR)
  550. goto errorExit;
  552.      
  553.     /* Initialize the Board here */
  554.     
  555.     if (elt3c509BoardInit (pDrvCtrl) == ERROR)
  556. goto errorExit;
  558.     /* Perform memory allocation/distribution */
  560.     if (elt3c509MemInit (pDrvCtrl) == ERROR)
  561. goto errorExit;
  563.     
  564.     /* set the flags to indicate readiness */
  566.     END_OBJ_READY (&pDrvCtrl->endObj, IFF_NOTRAILERS | IFF_BROADCAST
  567.                    | IFF_MULTICAST | IFF_UP | IFF_RUNNING);
  568.     
  569.     pDrvCtrl->rxFilter = RX_F_NORMAL;
  571.     /* configure the device */
  573.     elt3c509Config (pDrvCtrl);
  575.     ENDLOGMSG (("Done loading end...", 1, 2, 3, 4, 5, 6));
  577.     return (&pDrvCtrl->endObj);
  579. errorExit:
  580.     if (pDrvCtrl != NULL)
  581. free ((char *)pDrvCtrl);
  583.     return NULL;
  584.     }
  586. /*******************************************************************************
  587. *
  588. * elt3c509Parse - parse the init string
  589. *
  590. * Parse the input string.  Fill in values in the driver control structure.
  591. *
  592. * The initialization string format is:
  593. * .CS
  594. *     <unit>:<port>:<intVector>:<intLevel>:<attachementType>:<noRxFrames>
  595. * .CE
  596. * .IP <unit>
  597. * Device unit number, a small integer.
  598. * .IP <port>
  599. * base I/O address
  600. * .IP <intVector>
  601. * Interrupt vector number (used with sysIntConnect)
  602. * .IP <intLevel>
  603. * Interrupt level
  604. * .IP <attachmentType>
  605. * type of Ethernet connector
  606. * .IP <nRxFrames>
  607. * no. of Rx Frames in integer format
  608. * .LP
  609. *
  610. * RETURNS: OK or ERROR for invalid arguments.
  611. */
  613. STATUS elt3c509Parse
  614.     (
  615.     ELT3C509_DEVICE *  pDrvCtrl, /* device pointer */
  616.     char *  initString /* initialization info string */
  617.     )
  618.     {
  619.     char * tok;
  620.     char * holder = NULL;
  621.     
  622.     /* unit number. */
  624.     tok = strtok_r (initString, ":", &holder);
  625.     if (tok == NULL)
  626. return ERROR;
  627.     pDrvCtrl->unit = atoi (tok);
  629.     /* port number */
  631.     tok = strtok_r (NULL, ":", &holder);
  632.     if (tok == NULL)
  633. return ERROR;
  634.     pDrvCtrl->port = strtoul (tok, NULL, 16);
  635.     
  636.     /* interrupt vector. */
  638.     tok = strtok_r (NULL, ":", &holder);
  639.     if (tok == NULL)
  640. return ERROR;
  641.     pDrvCtrl->ivec = strtoul (tok, NULL, 16);
  643.     /* interrupt level. */
  645.     tok = strtok_r (NULL, ":", &holder);
  646.     if (tok == NULL)
  647. return ERROR;
  648.     pDrvCtrl->intLevel = strtoul (tok, NULL, 16);
  650.     /* attachment Type */
  652.     tok = strtok_r (NULL, ":", &holder);
  653.     if (tok == NULL)
  654. return ERROR;
  655.     pDrvCtrl->attachment = atoi (tok);
  657.     /* no. of Rx Frames */
  658.     tok = strtok_r (NULL, ":", &holder);
  659.     if (tok == NULL)
  660.         return ERROR;
  661.     pDrvCtrl->nRxFrames = atoi (tok);
  662.     
  663.     ENDLOGMSG (("Processed all arugmentsn", 1, 2, 3, 4, 5, 6));
  665.     return OK;
  666.     }
  668. /*******************************************************************************
  669. *
  670. * elt3c509BoardInit - Initialise the device
  671. *
  672. * This function prepares the board for operation
  673. *
  674. * RETURNS: OK or ERROR
  675. *
  676. */
  678. LOCAL STATUS elt3c509BoardInit
  679.     (
  680.     ELT3C509_DEVICE * pDrvCtrl /* device to be initialized */
  681.     )
  682.     {
  683.     int  port;
  684.     int  index;
  685.     UINT16  transceiver;
  686.     UINT16  mediaStatus;
  688.     port = pDrvCtrl->port;
  690.     END_FLAGS_CLR (&pDrvCtrl->endObj, IFF_UP | IFF_RUNNING);
  692.     elt3c509IntDisable (pDrvCtrl);   /* make it OK to change register window */
  694.     SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND,
  695.                   (SELECT_WINDOW | WIN_ADDRESS));
  697.     for (index = 0; index < EA_SIZE; index++)
  698.         SYS_OUT_BYTE (pDrvCtrl, port + index, pDrvCtrl->enetAddr [index]);
  700.     /* Select the transceiver hardware (attachment) then do whatever is
  701.      * necessary to activate the selected attachment.
  702.      * A truly complete implementation would probably check to see
  703.      * if the selected attachment were present.
  704.      */
  706.     SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND,
  707.                   (SELECT_WINDOW | WIN_CONFIG));
  708.     SYS_IN_WORD (pDrvCtrl, port + ADDRESS_CONFIG, transceiver);
  709.     if (pDrvCtrl->attachment == ATTACHMENT_DEFAULT)
  710.         {
  711.         switch (transceiver & AC_XCVR_MASK)
  712.             {
  713.             case AC_XCVR_TPE:
  714.                 pDrvCtrl->attachment = ATTACHMENT_RJ45;
  715.                 break;
  716.             case AC_XCVR_BNC:
  717.                 pDrvCtrl->attachment = ATTACHMENT_BNC;
  718.                 break;
  719.             case AC_XCVR_AUI:
  720.                 pDrvCtrl->attachment = ATTACHMENT_AUI;
  721.                 break;
  722.             default:    /* there's only one other value; it's "reserved" */
  723.                 pDrvCtrl->attachment = ATTACHMENT_AUI;  /* good enough */
  724.                 break;
  725.             }
  726.         }
  728.     /* Now set the selected attachment type, even if it was already selected */
  730.     transceiver &= ~AC_XCVR_MASK;
  731.     switch (pDrvCtrl->attachment)
  732.         {
  733.         case ATTACHMENT_RJ45:
  734.             SYS_OUT_WORD (pDrvCtrl, port + ADDRESS_CONFIG,
  735.                           (transceiver | AC_XCVR_TPE));
  736.             SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND,
  737.                           (SELECT_WINDOW | WIN_DIAGNOSTIC));
  738.             SYS_IN_BYTE (pDrvCtrl, port + MEDIA_STATUS, mediaStatus);
  739.             SYS_OUT_BYTE (pDrvCtrl, port + MEDIA_STATUS,
  740.                           mediaStatus |
  741.                           MT_S_JABBER_ENABLE |
  742.                           MT_S_LINK_BEAT_ENABLE);
  743.             break;
  744.         case ATTACHMENT_BNC:
  745.             SYS_OUT_WORD (pDrvCtrl, port + ADDRESS_CONFIG,
  746.                           transceiver | AC_XCVR_BNC);
  747.             SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND, START_COAX);
  748.             break;
  749.             
  750.         case ATTACHMENT_AUI:
  751.         default:
  752.             SYS_OUT_WORD (pDrvCtrl, port + ADDRESS_CONFIG,
  753.                           transceiver | AC_XCVR_AUI);
  754.             break;
  755.         }
  757.     /*
  758.      * Define the set of status bits that could cause interrupts.
  759.      * There is no interrupt cause indicator separate from the board status.
  760.      * To keep the ISR from seeing status conditions we didn't want to be
  761.      * interrrupted for, we must mask the STATUS off, not the interrupt.
  762.      * This prevents the condition from interrupting and also prevents
  763.      * the ISR from seeing the condition even if it is true.
  764.      * The interrupt mask is set only once to the set of all conditions
  765.      * we might want to be interrupted by; the status mask is set and
  766.      * cleared according to which conditions we want at any particular
  767.      * time.  The intMask field in the control structure
  768.      * is named for its effect; it is really used in the status mask
  769.      * command (3Com calls it the read zero mask).
  770.      */
  772.     /* enable the status bits we currently want to cause interrupts */
  774.     elt3c509IntMaskSet (pDrvCtrl, ADAPTER_FAILURE | TX_COMPLETE |
  775.                         RX_COMPLETE | RX_EARLY | UPDATE_STATS);
  777.     /* enable the collection of statistics */
  779.     SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND, STATS_ENABLE);
  781.     /* enable the hardware to generate interrupt requests */
  783.     SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND,
  784.                   SELECT_WINDOW | WIN_CONFIG);
  785.     SYS_OUT_WORD (pDrvCtrl, port + CONFIG_CONTROL, CC_ENABLE);
  787.     SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND,
  788.                   SELECT_WINDOW | WIN_OPERATING);
  790.     elt3c509IntEnable (pDrvCtrl);
  792.     elt3c509RxStart (pDrvCtrl);
  793.     elt3c509TxStart (pDrvCtrl);
  794.     return (OK);
  795.     }
  797. /*******************************************************************************
  798. *
  799. * elt3c509MemInit - initialize memory for the chip
  800. *
  801. * This routine is highly specific to the device.  
  802. *
  803. * RETURNS: OK or ERROR.
  804. */
  806. LOCAL STATUS elt3c509MemInit
  807.     (
  808.     ELT3C509_DEVICE *  pDrvCtrl /* device to be initialized */
  809.     )
  810.     {
  811.     if ((pDrvCtrl->endObj.pNetPool = malloc (sizeof(NET_POOL))) == NULL)
  812.         return (ERROR);
  814. #ifdef DRV_DEBUG    
  815.     pEltPool = pDrvCtrl->endObj.pNetPool;
  816. #endif    
  818.     /* check if the value of nRxFrames is valid */
  820.     pDrvCtrl->nRxFrames = pDrvCtrl->nRxFrames ? 
  821.                           pDrvCtrl->nRxFrames : DEF_NUM_RX_FRAMES; 
  823.     /* assign static cluster config/desc structures to unit specific structures
  824.      * This is done to enable multiple units to operate.
  825.      */
  827.     pDrvCtrl->endClDesc = elt3c509ClDescTbl [0];
  828.     pDrvCtrl->endClConfig = elt3c509MclConfig;
  829.     
  830.     pDrvCtrl->endClDesc.clNum = pDrvCtrl->nRxFrames  + 1;
  831.     pDrvCtrl->endClConfig.mBlkNum  = (2 * pDrvCtrl->endClDesc.clNum);
  832.     pDrvCtrl->endClConfig.clBlkNum = pDrvCtrl->endClDesc.clNum;
  834.     /* Calculate the total memory for all the M-Blks and CL-Blks. */
  836.     pDrvCtrl->endClConfig.memSize = (pDrvCtrl->endClConfig.mBlkNum *
  837.                                      (MSIZE + sizeof (long))) +
  838.                              (pDrvCtrl->endClConfig.clBlkNum *
  839.                                      (CL_BLK_SZ + sizeof(long)));
  841.     if ((pDrvCtrl->endClConfig.memArea =
  842.          (char *) memalign (sizeof(long), pDrvCtrl->endClConfig.memSize))
  843.         == NULL)
  844.         {
  845.         return (ERROR);
  846.         }
  847.     
  848.     /* Calculate the memory size of all the clusters. */
  850.     pDrvCtrl->endClDesc.memSize = ((pDrvCtrl->endClDesc.clNum *
  851.                                     (ELT3C509_BUFSIZ + 8)) +
  852.                                    sizeof(int));
  854.     /* Allocate the memory for the clusters from cache safe memory. */
  856.     pDrvCtrl->endClDesc.memArea =
  857.         (char *) memalign (sizeof(long), pDrvCtrl->endClDesc.memSize);
  859.     if (pDrvCtrl->endClDesc.memArea == NULL)
  860.         {
  861.         ENDLOGMSG(("system memory unavailablen", 1,2,3,4,5,6));
  862.         return (ERROR);
  863.         }
  865.     pDrvCtrl->cacheFuncs = cacheNullFuncs;
  867.     /* Initialize the memory pool. */
  869.     if (netPoolInit (pDrvCtrl->endObj.pNetPool, &pDrvCtrl->endClConfig,
  870.                      &pDrvCtrl->endClDesc, elt3c509ClDescTblNumEnt, NULL)
  871.         == ERROR)
  872.         {
  873.         ENDLOGMSG (("Could not init bufferingn",1,2,3,4,5,6));
  874.         return (ERROR);
  875.         }
  877.     /* Get Cluster POOL ID here */
  879.     pDrvCtrl->pClPoolId = clPoolIdGet (pDrvCtrl->endObj.pNetPool,
  880.                                        ELT3C509_BUFSIZ, FALSE);
  882.     /* allocate one cluster for the transmit frame */
  884.     pDrvCtrl->pTxCluster = (char *)netClusterGet (pDrvCtrl->endObj.pNetPool,
  885.                                                   pDrvCtrl->pClPoolId);
  887.     ENDLOGMSG (("Memory setup completen",1,2,3,4,5,6));
  889.     return OK;
  890.     }
  892. /*******************************************************************************
  893. *
  894. * elt3c509Start - start the device
  895. *
  896. * This function calls BSP functions to connect interrupts and start the
  897. * device running in interrupt mode.
  898. *
  899. * RETURNS: OK or ERROR
  900. *
  901. */
  903. LOCAL STATUS elt3c509Start
  904.     (
  905.     void * pEnd /* device to be started */
  906.     )
  907.     {
  908.     STATUS  result;
  909.     ELT3C509_DEVICE *  pDrvCtrl;
  911.     VOID_TO_DRVCTRL (pEnd, pDrvCtrl);
  912.     
  913.     SYS_INT_CONNECT (pDrvCtrl, elt3c509Int, (int)pDrvCtrl, &result);
  914.     if (result == ERROR)
  915. return ERROR;
  917.     ENDLOGMSG (("Interrupt connected.n", 1, 2, 3, 4, 5, 6));
  919.     SYS_INT_ENABLE (pDrvCtrl);
  921.     ENDLOGMSG (("interrupt enabled.n", 1, 2, 3, 4, 5, 6));
  923.     return (OK);
  924.     }
  926. /*******************************************************************************
  927. *
  928. * elt3c509Stop - stop the device
  929. *
  930. * This function calls BSP functions to disconnect interrupts and stop
  931. * the device from operating in interrupt mode.
  932. *
  933. * RETURNS: OK or ERROR.
  934. */
  936. LOCAL STATUS elt3c509Stop
  937.     (
  938.     void * pEnd /* device to be stopped */
  939.     )
  940.     {
  941.     STATUS  result = OK;
  942.     ELT3C509_DEVICE *  pDrvCtrl;
  944.     VOID_TO_DRVCTRL (pEnd, pDrvCtrl);
  946.     elt3c509Reset(pDrvCtrl);
  948.     SYS_INT_DISCONNECT (pDrvCtrl, elt3c509Int, (int)pDrvCtrl, &result);
  950.     if (result == ERROR)
  951. {
  952. ENDLOGMSG (("Could not diconnect interrupt!n", 1, 2, 3, 4, 5, 6));
  953. }
  955.     SYS_INT_DISABLE (pDrvCtrl);
  957.     END_FLAGS_CLR (&pDrvCtrl->endObj, IFF_UP | IFF_RUNNING);
  959.     return (result);
  960.     }
  963. /******************************************************************************
  964. *
  965. * elt3c509Unload - unload a driver from the system
  966. *
  967. * This function first brings down the device, and then frees any
  968. * stuff that was allocated by the driver in the load function.
  969. *
  970. * RETURNS: OK or ERROR.
  971. */
  973. LOCAL STATUS elt3c509Unload
  974.     (
  975.     void * pEnd /* device to be unloaded */
  976.     )
  977.     {
  978.     ELT3C509_DEVICE * pDrvCtrl;
  980.     VOID_TO_DRVCTRL (pEnd, pDrvCtrl);
  981.     
  982.     END_OBJECT_UNLOAD (&pDrvCtrl->endObj);
  984.     if (pDrvCtrl->endClDesc.memArea != NULL)
  985.         free (pDrvCtrl->endClDesc.memArea);
  987.     if (pDrvCtrl->endClConfig.memArea != NULL)
  988.         free ( pDrvCtrl->endClConfig.memArea);
  989.     
  990.     if (pDrvCtrl->endObj.pNetPool != NULL)
  991.         free (pDrvCtrl->endObj.pNetPool);
  992.     
  993.     return (OK);
  994.     }
  996. /*******************************************************************************
  997. *
  998. * elt3c509Ioctl - the driver I/O control routine
  999. *
  1000. * Process an ioctl request.
  1001. *
  1002. * RETURNS: A command specific response, OK or ERROR or EINVAL.
  1003. */
  1005. LOCAL int elt3c509Ioctl
  1006.     (
  1007.     void *  pEnd,           /* device  ptr*/
  1008.     int  cmd, /* ioctl command code */
  1009.     caddr_t  data /* command argument */
  1010.     )
  1011.     {
  1012.     int  error = 0;
  1013.     long  value;
  1014.     ELT3C509_DEVICE *  pDrvCtrl;
  1016.     VOID_TO_DRVCTRL (pEnd, pDrvCtrl);
  1018.     switch (cmd)
  1019.         {
  1020.         case EIOCSADDR:
  1021.     if (data == NULL)
  1022. return (EINVAL);
  1023.             bcopy ((char *)data, (char *)END_HADDR(&pDrvCtrl->endObj),
  1024.    END_HADDR_LEN(&pDrvCtrl->endObj));
  1025.             break;
  1027.         case EIOCGADDR:
  1028.     if (data == NULL)
  1029. return (EINVAL);
  1030.             bcopy ((char *)END_HADDR(&pDrvCtrl->endObj), (char *)data,
  1031.     END_HADDR_LEN(&pDrvCtrl->endObj));
  1032.             break;
  1034.         case EIOCSFLAGS:
  1035.     value = (long)data;
  1036.     if (value < 0)
  1037. {
  1038. value = -value;
  1039. value--;
  1040. END_FLAGS_CLR (&pDrvCtrl->endObj, value);
  1041. }
  1042.     else
  1043. {
  1044. END_FLAGS_SET (&pDrvCtrl->endObj, value);
  1045. }
  1046.     elt3c509Config (pDrvCtrl);
  1047.             break;
  1049.         case EIOCGFLAGS:
  1050.     *(int *)data = END_FLAGS_GET(&pDrvCtrl->endObj);
  1051.             break;
  1053. case EIOCPOLLSTART:
  1054.     error = elt3c509PollStart(pDrvCtrl);
  1055.     break;
  1056.  
  1057. case EIOCPOLLSTOP:
  1058.     error = elt3c509PollStop(pDrvCtrl);
  1059.       break;
  1061.         case EIOCGMIB2:
  1062.             if (data == NULL)
  1063.                 return (EINVAL);
  1064.             bcopy((char *)&pDrvCtrl->endObj.mib2Tbl, (char *)data,
  1065.                   sizeof(pDrvCtrl->endObj.mib2Tbl));
  1066.             break;
  1068.         case EIOCGFBUF:
  1069.             return (EINVAL); /* no scatter gather supported for the chip */
  1070.             break;
  1072.         case EIOCGMWIDTH:
  1073.             if (data == NULL)
  1074.                 return (EINVAL);
  1075.             break;
  1077.         case EIOCGHDRLEN:
  1078.             if (data == NULL)
  1079.                 return (EINVAL);
  1080.             *(int *)data = EH_SIZE;
  1081.             break;
  1083.         default:
  1084.             error = EINVAL;
  1085.         }
  1087.     return (error);
  1088.     }
  1090. /*******************************************************************************
  1091. *
  1092. * elt3c509Send - the driver send routine
  1093. *
  1094. * This routine takes a M_BLK_ID sends off the data in the M_BLK_ID.
  1095. * The buffer must already have the addressing information properly installed
  1096. * in it.  This is done by a higher layer.
  1097. *
  1098. * RETURNS: OK or END_ERR_BLOCK or ERROR.
  1099. */
  1101. LOCAL STATUS elt3c509Send
  1102.     (
  1103.     void  *  pEnd, /* device ptr */
  1104.     M_BLK_ID  pMblk /* data to send */
  1105.     )
  1106.     {
  1107.     int len;
  1108.     int * pLenMask;
  1109.     char * pBuf;
  1110.     int intLevel;
  1111.     ELT3C509_DEVICE *  pDrvCtrl;
  1112.     UINT16 tempData;
  1114.     VOID_TO_DRVCTRL (pEnd, pDrvCtrl);
  1116.     /* change this drv flag set */
  1118.     if (pDrvCtrl->flags & ELT3C_POLLING)
  1119.         { 
  1120.         netMblkClChainFree (pMblk); /* free the given mBlk chain */
  1121.         errno = EINVAL;
  1122.         return (ERROR);
  1123.         }
  1124.         
  1125.     /* check if transmitter ready */
  1127.     SYS_IN_WORD (pDrvCtrl, pDrvCtrl->port + TX_FREE_BYTES, tempData);
  1128.     if (tempData >= TX_IDLE_COUNT)
  1129.         {
  1130.         pBuf = pDrvCtrl->pTxCluster;  /* pointer to the transmit cluster */
  1132.         pLenMask = (UINT32 *)pBuf;
  1133.         
  1134.         /* allow space for the preamble the trasmit buffer is 1520 */
  1136.         pBuf += sizeof(UINT32);
  1138.         len = netMblkToBufCopy (pMblk, pBuf, NULL);
  1140.         /* free the mblk chain */
  1141.         
  1142.         netMblkClChainFree (pMblk);
  1144.         len = max(len, ETHERSMALL); /* set the packet size */
  1146.         *pLenMask = len | TX_F_INTERRUPT; /* set the preamble */
  1148.         len = (len + TX_F_PREAMBLE_SIZE + 3) & TX_F_DWORD_MASK;
  1150.         /* place a transmit request */
  1152.         SYS_OUT_WORD_STRING (pDrvCtrl, pDrvCtrl->port + DATA_REGISTER, 
  1153.                              (short *)pLenMask, len / 2);
  1154.         }
  1155.     else
  1156.         {
  1157.         intLevel = intLock();
  1158. pDrvCtrl->txBlocked = TRUE;
  1159.         intUnlock (intLevel);
  1160.         ENDLOGMSG(("Error in Send, not enough TxFreeBytesn",1,2,3,4,5,6));
  1161.         return (END_ERR_BLOCK);
  1162.         }
  1163.     
  1164.     /* Bump the statistic counter. */
  1166.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_UCAST, +1);
  1168.     ENDLOGMSG (("Send completen",1,2,3,4,5,6));
  1169.     return (OK);
  1170.     }
  1172. /*****************************************************************************
  1173. *
  1174. * elt3c509MCastAdd - add a multicast address for the device
  1175. *
  1176. * This routine adds a multicast address to whatever the driver
  1177. * is already listening for.  It then resets the address filter.
  1178. *
  1179. * RETURNS: OK or ERROR.
  1180. */
  1182. LOCAL STATUS elt3c509MCastAdd
  1183.     (
  1184.     void  *  pEnd,         /* device pointer */
  1185.     char *  pAddress /* new address to add */
  1186.     )
  1187.     {
  1188.     int  error;
  1189.     ELT3C509_DEVICE *  pDrvCtrl;
  1191.     VOID_TO_DRVCTRL (pEnd, pDrvCtrl);
  1193.     if ((error = etherMultiAdd (&pDrvCtrl->endObj.multiList,
  1194. pAddress)) == ENETRESET)
  1195. elt3c509Config (pDrvCtrl);
  1197.     return (OK);
  1198.     }
  1200. /*****************************************************************************
  1201. *
  1202. * elt3c509MCastDel - delete a multicast address for the device
  1203. *
  1204. * This routine removes a multicast address from whatever the driver
  1205. * is listening for.  It then resets the address filter.
  1206. *
  1207. * RETURNS: OK or ERROR.
  1208. */
  1210. LOCAL STATUS elt3c509MCastDel
  1211.     (
  1212.     void  *  pEnd,         /* device pointer */
  1213.     char *  pAddress /* address to be deleted */
  1214.     )
  1215.     {
  1216.     int  error;
  1217.     ELT3C509_DEVICE *  pDrvCtrl;
  1219.     VOID_TO_DRVCTRL (pEnd, pDrvCtrl);
  1220.     if ((error = etherMultiDel (&pDrvCtrl->endObj.multiList,
  1221.      (char *)pAddress)) == ENETRESET)
  1222. elt3c509Config (pDrvCtrl);
  1224.     return (OK);
  1225.     }
  1227. /*****************************************************************************
  1228. *
  1229. * elt3c509MCastGet - get the multicast address list for the device
  1230. *
  1231. * This routine gets the multicast list of whatever the driver
  1232. * is already listening for.
  1233. *
  1234. * RETURNS: OK or ERROR.
  1235. */
  1237. LOCAL STATUS elt3c509MCastGet
  1238.     (
  1239.     void  *  pEnd,         /* device pointer */
  1240.     MULTI_TABLE *  pTable /* address table to be filled in */
  1241.     )
  1242.     {
  1243.     ELT3C509_DEVICE * pDrvCtrl;
  1245.     VOID_TO_DRVCTRL (pEnd, pDrvCtrl);
  1246.     return (etherMultiGet (&pDrvCtrl->endObj.multiList, pTable));
  1247.     }
  1249. /*******************************************************************************
  1250. *
  1251. * elt3c509Int - handle controller interrupt
  1252. *
  1253. * This routine is called at interrupt level in response to an interrupt from
  1254. * the controller.
  1255. *
  1256. * RETURNS: N/A.
  1257. */
  1259. LOCAL void elt3c509Int
  1260.     (
  1261.     ELT3C509_DEVICE * pDrvCtrl /* interrupting device */
  1262.     )
  1263.     {
  1264.     UINT16  status;
  1265.     UINT16  statusDiag;
  1266.     UINT8   statusTx;
  1267.     int     port;
  1268.     BOOL    needTxStart = FALSE;
  1270.     port = pDrvCtrl->port;
  1272.     ENDLOGMSG (("Got an interrupt!n", 1, 2, 3, 4, 5, 6));
  1274. #ifdef ELT_TIMING
  1275.     {
  1276.     int time;
  1277.     SYS_IN_BYTE (pDrvCtrl, pDrvCtrl->port + TIMER, time);
  1279.     if (time> pDrvCtrl->elt3c509Stat.maxIntLatency)
  1280.         pDrvCtrl->elt3c509Stat.maxIntLatency = time; 
  1281.     if (pDrvCtrl->interruptTime == -1)
  1282.         pDrvCtrl->interruptTime = time;
  1283.     else if (pDrvCtrl->interruptTime >= 0)
  1284.         pDrvCtrl->interruptTime = -1;
  1285.     }
  1286. #endif /* ELT_TIMING */
  1288.     SYS_IN_BYTE (pDrvCtrl, pDrvCtrl->port + ELT3C509_STATUS, status);
  1289.     status &= 0x00ff;
  1291.     if ((status & INTERRUPT_LATCH) == 0)
  1292.         {
  1293.         ++pDrvCtrl->elt3c509Stat.strayint;
  1294.         return;
  1295.         }
  1296.     else
  1297.         ++pDrvCtrl->elt3c509Stat.interrupts;
  1300.     /* Handle adapter failure first in case other conditions mask it */
  1302.     if ((status & ADAPTER_FAILURE) != 0)
  1303.         {
  1304.         SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND,
  1305.                       SELECT_WINDOW | WIN_DIAGNOSTIC);
  1306.         SYS_IN_WORD (pDrvCtrl, port + FIFO_DIAGNOSTIC, statusDiag);
  1307.         SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND,
  1308.                       SELECT_WINDOW | WIN_OPERATING);
  1310.         if ((statusDiag & FD_TX_OVERRUN) != 0)
  1311.             {
  1312.             ++pDrvCtrl->elt3c509Stat.txoverruns;
  1313.             SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND, TX_RESET);
  1314.             elt3c509TxStart (pDrvCtrl);
  1315.             }
  1317.         if ((status & FD_RX_UNDERRUN) != 0)
  1318.             {
  1319.             ++pDrvCtrl->elt3c509Stat.rxunderruns;
  1320.             SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND, RX_RESET);
  1321.             elt3c509RxStart (pDrvCtrl);
  1322.             }
  1323.         }
  1325.     if (status & (RX_COMPLETE | RX_EARLY))
  1326.         {
  1327.         if ((status & RX_EARLY) != 0)
  1328.             ++pDrvCtrl->elt3c509Stat.rxearly;
  1330.         if (netJobAdd ((FUNCPTR)elt3c509HandlePktsRcv, (int) pDrvCtrl,
  1331.                        0, 0, 0, 0) == OK)
  1332.             {
  1333.             pDrvCtrl->intMask &= ~(RX_COMPLETE | RX_EARLY);
  1334.                 
  1335. #ifdef ELT_TIMING
  1336.             if((int)++pDrvCtrl->elt3c509Stat.taskQRxOuts >
  1337.                (int)pDrvCtrl->elt3c509Stat.maxRxTaskQ)
  1338.                 {
  1339.                 pDrvCtrl->elt3c509Stat.maxRxTaskQ =
  1340.                     pDrvCtrl->elt3c509Stat.taskQRxOuts;
  1341.                 }
  1342. #endif /* ELT_TIMING */
  1343.             }
  1344.         else
  1345.             logMsg ("elt: netJobAdd (elt3c509HandlePktsRcv) failedn",
  1346.                     0, 0, 0, 0, 0, 0);
  1347.         }
  1348.     
  1349.     /* Handle transmitter interrupts */
  1351.     if ((status & TX_COMPLETE) != 0)
  1352.         {
  1353.         SYS_IN_BYTE (pDrvCtrl, port+TX_STATUS, statusTx);
  1354.         if ((statusTx & TX_S_COMPLETE) != 0)
  1355.             {
  1356.             SYS_OUT_BYTE (pDrvCtrl,port + TX_STATUS, 0); /* clear old status */
  1358.             /*
  1359.              * other errors are tabulated by reading the statistics registers
  1360.              */
  1362.             if ((statusTx & TX_S_MAX_COLL) != 0)
  1363.                 END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_ERRS, +16);
  1364.             if ((statusTx & TX_S_JABBER) != 0)
  1365.                 END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_ERRS, +1);
  1367.             if ((statusTx & (TX_S_JABBER | TX_S_MAX_COLL | TX_S_UNDERRUN))
  1368.                 != 0)
  1369.                 {
  1370.                 needTxStart = TRUE;                 /* restart transmitter */
  1372.                 /* packet not sent */
  1374.                 END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_ERRS, +1);
  1375.                 END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_UCAST, -1);
  1376.                 }
  1377.             if ((statusTx & (TX_S_JABBER | TX_S_UNDERRUN)) != 0)
  1378.                 {
  1379.                 /* Must reset transmitter; this clears the tx FIFO */
  1381.                 SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND, TX_RESET);
  1382.                 }
  1383.             }
  1385.         if (needTxStart)                            /* check flag */
  1386.             elt3c509TxStart (pDrvCtrl);
  1388.         if (pDrvCtrl->txBlocked)
  1389.             {
  1390.             pDrvCtrl->txBlocked = FALSE;
  1392.             /* restart the transmit flow */
  1394.             netJobAdd ((FUNCPTR) muxTxRestart, (int) &pDrvCtrl->endObj, 0, 0,
  1395.                        0, 0);
  1396. #ifdef ELT_TIMING
  1397.             if ((int)++pDrvCtrl->elt3c509Stat.taskQTxOuts >
  1398.                  (int)pDrvCtrl->elt3c509Stat.maxTxTaskQ)
  1399.                 pDrvCtrl->elt3c509Stat.maxTxTaskQ =
  1400.                     pDrvCtrl->elt3c509Stat.taskQTxOuts;
  1401. #endif /* ELT_TIMING */
  1402.             }
  1403.         }
  1405.     /* Handle update statistics interrupt */
  1407.     if ((status & UPDATE_STATS) != 0)
  1408.         elt3c509StatFlush (pDrvCtrl);
  1410.     /* mask and ack the events we've just handled or queued handlers for */
  1412.     SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND,
  1413.                   MASK_STATUS | pDrvCtrl->intMask);
  1414.     SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND,
  1415.                   ACK_INTERRUPT | status);
  1416.     sysBusIntAck (pDrvCtrl->intLevel);
  1417.     }
  1419. /*******************************************************************************
  1420. *
  1421. * elt3c509HandlePktsRcv - task level interrupt service for input packets
  1422. *
  1423. * This routine is called at task level indirectly by the interrupt
  1424. * service routine to do any message received processing.
  1425. *
  1426. * RETURNS: N/A.
  1427. */
  1429. LOCAL void elt3c509HandlePktsRcv
  1430.     (
  1431.     ELT3C509_DEVICE * pDrvCtrl /* interrupting device */
  1432.     )
  1433.     {
  1434.     M_BLK_ID  pMblk; /* pointer to the mBlk */
  1435.     CL_BLK_ID pClBlk; /* pointer to the clBlk */
  1436.     char * pCluster; /* pointer to the cluster */
  1437.     int     port; /* IO port to read */
  1438.     STATUS       result = OK;    /* Tracks result of Cluster Alloc */
  1440.     port = pDrvCtrl->port;
  1441.     
  1442.     /* loop for more frames */
  1444.     while (TRUE)
  1445.         {
  1446.         /* get a cluster */
  1448.         pCluster = netClusterGet (pDrvCtrl->endObj.pNetPool,
  1449.                                   pDrvCtrl->pClPoolId);
  1450.         if (pCluster == NULL)
  1451.             {
  1452.             ENDLOGMSG (("Cannot loan!n", 1, 2, 3, 4, 5, 6));
  1453.             ++pDrvCtrl->elt3c509Stat.rxnobuffers;
  1454.             END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1455.     result = ERROR;
  1456.             break;
  1457.             }
  1459.         /* get a cluster block */
  1461.         if ((pClBlk = netClBlkGet (pDrvCtrl->endObj.pNetPool, M_DONTWAIT)) ==
  1462.             NULL)
  1463.             {
  1464.             netClFree (pDrvCtrl->endObj.pNetPool, pCluster);
  1465.             ENDLOGMSG (("Out of Cluster Blocks!n", 1, 2, 3, 4, 5, 6));
  1466.             END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1467.     result = ERROR;
  1468.             break;
  1469.             }
  1470.     
  1471.         /* get an mBlk */
  1473.         if ((pMblk = mBlkGet (pDrvCtrl->endObj.pNetPool, M_DONTWAIT, MT_DATA))
  1474.             == NULL)
  1475.             {
  1476.             netClBlkFree (pDrvCtrl->endObj.pNetPool, pClBlk); 
  1477.             netClFree (pDrvCtrl->endObj.pNetPool, pCluster);
  1478.             ENDLOGMSG (("Out of M Blocks!n", 1, 2, 3, 4, 5, 6));
  1479.             END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1480.     result = ERROR;
  1481.             break;
  1482.             }
  1484.         /* Join the cluster to the MBlock */
  1486.         netClBlkJoin (pClBlk, pCluster, ELT3C509_BUFSIZ, NULL, 0, 0, 0);
  1487.         netMblkClJoin (pMblk, pClBlk);
  1488.         
  1489.         if (elt3c509PollRcv ((void *)pDrvCtrl, pMblk) == OK)
  1490.             {
  1491.             END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_UCAST, +1);
  1492.             ENDLOGMSG (("Calling upper layer's recv rtnn", 1, 2, 3, 4, 5, 6));
  1494.             /* Call the upper layer's receive routine. */
  1496.             END_RCV_RTN_CALL (&pDrvCtrl->endObj, pMblk);
  1497.             }
  1498.         else
  1499.             {
  1500.             ENDLOGMSG (("EAGAINn", 1, 2, 3, 4, 5, 6));
  1501.             netMblkClFree (pMblk);
  1502.     result = ERROR;
  1503.             break;
  1504.             }
  1505.         }
  1506.     
  1507.     /* Discard the packet in the FIFO here of there was an error */
  1509.     if (result == ERROR)
  1510. {
  1511. /* discard packet */
  1512.         SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND, RX_DISCARD);
  1513. }
  1514.      /* enable the recv interrupt */
  1516.     elt3c509IntMaskSet (pDrvCtrl, (RX_COMPLETE | RX_EARLY));
  1517.     }
  1519. /*******************************************************************************
  1520. *
  1521. * elt3c509PollRcv - routine to receive a packet in polled mode.
  1522. *
  1523. * This routine is called by a user to try and get a packet from the
  1524. * device.
  1525. *
  1526. * RETURNS: EGAIN or OK
  1527. */
  1529. LOCAL STATUS elt3c509PollRcv
  1530.     (
  1531.     void  *  pEnd, /* device pointer */
  1532.     M_BLK_ID  pMblk /* pointer to the mBlk chain */
  1533.     )
  1534.     {
  1535.     UINT16  statusRx;
  1536.     UINT16  statusRxNew;
  1537.     UINT16  length;
  1538.     int     port;
  1539.     int ix = 0;
  1540.     int       status = OK;
  1541.     ELT3C509_DEVICE *  pDrvCtrl;
  1543.     VOID_TO_DRVCTRL (pEnd, pDrvCtrl);
  1545.     port = pDrvCtrl->port;
  1546.     
  1547.     SYS_IN_WORD (pDrvCtrl, port + RX_STATUS, statusRx);
  1548.     
  1549.     if (statusRx & RX_S_INCOMPLETE) /* incomplete */
  1550.         {
  1551.         if (statusRx == RX_S_INCOMPLETE) /* no bytes available */
  1552.             {
  1553.             ENDLOGMSG (("no more packetsn", 1, 2, 3, 4, 5, 6));
  1554.             return (EAGAIN);
  1555.             }
  1557.         while (ix < 10000)
  1558.             {
  1559.             SYS_IN_WORD (pDrvCtrl, port + RX_STATUS, statusRxNew);
  1560.             if (statusRx == statusRxNew)
  1561.                 {
  1562.                 break;
  1563.                 }
  1564.             else
  1565.                 {
  1566.                 statusRx = statusRxNew;
  1567.                 ix++;
  1568.                 }
  1569.             }
  1570.         
  1571.         if (statusRx & RX_S_INCOMPLETE)
  1572.             {
  1573.             END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1574.             ENDLOGMSG (("status quon", 1, 2, 3, 4, 5, 6));
  1575.             status = EAGAIN;
  1576.             goto PollRcvErrHandle;
  1577.             }
  1578.         }
  1580.     /* Check for errors in completed packet */
  1582.     if (statusRx & RX_S_ERROR)
  1583.         {
  1584.         switch (statusRx & RX_S_CODE_MASK)
  1585.             {
  1586.             case RX_S_OVERRUN: /* handled by statistics registers */
  1587.                 break;
  1588.             case RX_S_RUNT:
  1589.                 ++pDrvCtrl->elt3c509Stat.shortPacket;
  1590.                 break;
  1591.             case RX_S_ALIGN:
  1592.                 ++pDrvCtrl->elt3c509Stat.aligns;
  1593.                 break;
  1594.             case RX_S_CRC:
  1595.                 ++pDrvCtrl->elt3c509Stat.crcs;
  1596.                 break;
  1597.             case RX_S_OVERSIZE:
  1598.                 ++pDrvCtrl->elt3c509Stat.badPacket;
  1599.                 break;
  1600.             default: /* no other codes are defined */
  1601.                 break;
  1602.             }
  1603.         END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1604.         ENDLOGMSG (("recv errorn", 1, 2, 3, 4, 5, 6));
  1605.         status = EAGAIN;
  1606.         goto PollRcvErrHandle;
  1607.         }
  1610.     /* length of the buffer in the FIFO */
  1612.     length = statusRx & RX_S_CNT_MASK;
  1614.     /* discard packet if received frame is bigger than MAX_FRAME_SIZE */
  1616.     if (length > MAX_FRAME_SIZE)
  1617.         {
  1618.         ENDLOGMSG (("pktlen>MAX_FRAME_SIZEn", 1, 2, 3, 4, 5, 6));
  1619.         END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1620.         status = EAGAIN;
  1621.         goto PollRcvErrHandle;
  1622.         }
  1624.     /* if given mBlk does not have enough space */
  1626.     if ((!(pMblk->mBlkHdr.mFlags & M_EXT)) || (pMblk->pClBlk->clSize < length))
  1627. {
  1628.         ENDLOGMSG (("PRX bad mblk len:%d flags:%dn", pMblk->mBlkHdr.mLen,
  1629.                    pMblk->mBlkHdr.mFlags, 3, 4, 5, 6));
  1630.         END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1631.         status = EAGAIN;
  1632.         goto PollRcvErrHandle;
  1633. }
  1635.     /* read the packet from the FIFO into the cluster */
  1636.     
  1637.     SYS_IN_WORD_STRING (pDrvCtrl, port + DATA_REGISTER, 
  1638. (short *) pMblk->mBlkHdr.mData, (length + 1) / 2);
  1640.     /* update the mBlk fields */
  1642.     pMblk->mBlkHdr.mLen   = length;
  1643.     pMblk->mBlkHdr.mFlags |= M_PKTHDR;
  1644.     pMblk->mBlkPktHdr.len = length;
  1646.     status = OK;
  1647.     
  1648.     PollRcvErrHandle:
  1649.      {
  1650. /* discard packet */
  1651.         SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND, RX_DISCARD);
  1653.         /* wait for command to finish */
  1655.         statusRxNew = ERROR;
  1656.         while ((statusRxNew & COMMAND_IN_PROGRESS) != 0)
  1657.             {
  1658.             SYS_IN_WORD (pDrvCtrl, port + ELT3C509_STATUS, statusRxNew);
  1659.             }
  1660.         }
  1662.     return (status);
  1663.     }
  1665. /******************************************************************************
  1666. *
  1667. * elt3c509Config - reconfigure the interface under us.
  1668. *
  1669. * Reconfigure the interface setting promiscuous mode, and changing the
  1670. * multicast interface list.
  1671. *
  1672. * RETURNS: N/A.
  1673. */
  1675. LOCAL void elt3c509Config
  1676.     (
  1677.     ELT3C509_DEVICE * pDrvCtrl /* device to be re-configured */
  1678.     )
  1679.     {
  1680.     /* Set promiscuous mode if it's asked for. */
  1682.     if (END_FLAGS_GET (&pDrvCtrl->endObj) & IFF_PROMISC)
  1683. {
  1684. ENDLOGMSG (("Setting promiscuous mode on!n", 1, 2, 3, 4, 5, 6));
  1685.         pDrvCtrl->rxFilter |= RX_F_PROMISCUOUS;
  1686.         SYS_OUT_WORD(pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND,
  1687.                      SET_RX_FILTER | pDrvCtrl->rxFilter);
  1688. }
  1689.     else
  1690. {
  1691. ENDLOGMSG (("Setting promiscuous mode off!n", 1, 2, 3, 4, 5, 6));
  1692.         pDrvCtrl->rxFilter &= ~RX_F_PROMISCUOUS;
  1693.         SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND,
  1694.                       SET_RX_FILTER | pDrvCtrl->rxFilter);
  1695. }
  1697.     /* Set up address filter for multicasting. 
  1698.      * Multicast bit is set if the address list has one or more entries
  1699.      * Multicasting is disabled if the address list is empty
  1700.      */
  1702.     if (END_MULTI_LST_CNT (&pDrvCtrl->endObj) > 0 ||
  1703.              (END_FLAGS_GET (&pDrvCtrl->endObj) & IFF_MULTICAST))
  1704. {
  1705. ENDLOGMSG (("Setting multicast mode on!n", 1, 2, 3, 4, 5, 6));
  1706.         pDrvCtrl->rxFilter |= RX_F_MULTICAST;
  1707.         SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND,
  1708.                       SET_RX_FILTER | pDrvCtrl->rxFilter);
  1709. }
  1710.     else
  1711. {
  1712. ENDLOGMSG (("Setting multcast mode off!n", 1, 2, 3, 4, 5, 6));
  1713.         pDrvCtrl->rxFilter &= ~RX_F_MULTICAST;
  1714.         SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND,
  1715.                       SET_RX_FILTER | pDrvCtrl->rxFilter);
  1716. }
  1718.     return;
  1719.     }
  1721. /*******************************************************************************
  1722. *
  1723. * elt3c509PollSend - routine to send a packet in polled mode.
  1724. *
  1725. * This routine is called by a user to try and send a packet on the
  1726. * device.
  1727. *
  1728. * RETURNS: OK upon success.  EAGAIN if device is busy.
  1729. */
  1731. LOCAL STATUS elt3c509PollSend
  1732.     (
  1733.     void  *  pEnd,         /* device pointer */
  1734.     M_BLK_ID  pMblk /* packet to send */
  1735.     )
  1736.     {
  1737.     int len;
  1738.     int * pLenMask;
  1739.     char * pBuf;
  1740.     ELT3C509_DEVICE *  pDrvCtrl;
  1741.     UINT16 txStatus;
  1743.     VOID_TO_DRVCTRL (pEnd, pDrvCtrl);
  1745.     SYS_IN_WORD (pDrvCtrl, pDrvCtrl->port + TX_FREE_BYTES, txStatus);
  1747.     if (txStatus >= TX_IDLE_COUNT)
  1748.         {
  1749.         pBuf = pDrvCtrl->pTxCluster;  /* pointer to the transmit cluster */
  1751.         pLenMask = (UINT32 *)pBuf;
  1752.         
  1753.         /* allow space for the preamble the trasmit buffer is 1520 */
  1755.         pBuf += sizeof(UINT32);
  1757.         len = netMblkToBufCopy(pMblk, pBuf, NULL);
  1759.         len = max(len, ETHERSMALL); /* set the packet size */
  1761.         *pLenMask = len | TX_F_INTERRUPT; /* set the preamble */
  1763.         len = (len + TX_F_PREAMBLE_SIZE + 3) & TX_F_DWORD_MASK;
  1765.         /* place a transmit request */
  1767.         SYS_OUT_WORD_STRING (pDrvCtrl, pDrvCtrl->port + DATA_REGISTER, 
  1768. (short *)pLenMask, len / 2);
  1770.         /* read the tranmsit status */
  1771.         SYS_IN_BYTE (pDrvCtrl, pDrvCtrl->port + TX_STATUS, txStatus);
  1773.         /* wait until tramit is complete */
  1774.         while (!(txStatus & TX_S_COMPLETE))
  1775.             {
  1776.             SYS_IN_BYTE (pDrvCtrl, pDrvCtrl->port + TX_STATUS, txStatus);
  1777.             }
  1779. /* clear old status */
  1780.         SYS_OUT_BYTE (pDrvCtrl, pDrvCtrl->port + TX_STATUS, 0);
  1781.         }
  1782.     else
  1783.         {
  1784.         ENDLOGMSG(("Error in Send, not enough TxFreeBytesn",1,2,3,4,5,6));
  1785.         return (EAGAIN);
  1786.         }
  1787.     
  1788.     /* Bump the statistic counter. */
  1790.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_UCAST, +1);
  1792.     ENDLOGMSG (("Poll Send completen",1,2,3,4,5,6));
  1793.     return (OK);
  1794.     }
  1796. /*******************************************************************************
  1797. *
  1798. * elt3c509PollStart - start polled mode operations
  1799. *
  1800. * This function starts polled mode operation.
  1801. *
  1802. * The device interrupts are disabled, the current mode flag is switched
  1803. * to indicate Polled mode and the device is reconfigured.
  1804. *
  1805. * RETURNS: OK or ERROR.
  1806. */
  1808. LOCAL STATUS elt3c509PollStart
  1809.     (
  1810.     ELT3C509_DEVICE * pDrvCtrl /* device to be polled */
  1811.     )
  1812.     {
  1813.     int         oldLevel;
  1814.     
  1815.     oldLevel = intLock ();          /* disable ints during update */
  1817.     pDrvCtrl->flags |= ELT3C_POLLING;
  1819.     intUnlock (oldLevel);   /* now elt3c509Int won't get confused */
  1821.     elt3c509IntDisable (pDrvCtrl);
  1823.     ENDLOGMSG (("STARTEDn", 1, 2, 3, 4, 5, 6));
  1825.     elt3c509Config (pDrvCtrl); /* reconfigure device */
  1827.     return (OK);
  1828.     }
  1830. /*******************************************************************************
  1831. *
  1832. * elt3c509PollStop - stop polled mode operations
  1833. *
  1834. * This function terminates polled mode operation.  The device returns to
  1835. * interrupt mode.
  1836. *
  1837. * The device interrupts are enabled, the current mode flag is switched
  1838. * to indicate interrupt mode and the device is then reconfigured for
  1839. * interrupt operation.
  1840. *
  1841. * RETURNS: OK or ERROR.
  1842. */
  1844. LOCAL STATUS elt3c509PollStop
  1845.     (
  1846.     ELT3C509_DEVICE * pDrvCtrl /* device structure */
  1847.     )
  1848.     {
  1849.     int         oldLevel;
  1851.     oldLevel = intLock (); /* disable ints during register updates */
  1853.     pDrvCtrl->flags &= ~ELT3C_POLLING;
  1855.     intUnlock (oldLevel);
  1857.     elt3c509IntEnable (pDrvCtrl);
  1859.     elt3c509Config (pDrvCtrl);
  1861.     ENDLOGMSG (("STOPPEDn", 1, 2, 3, 4, 5, 6));
  1863.     return (OK);
  1864.     }
  1867. /*******************************************************************************
  1868. *
  1869. * elt3c509IntEnable - enable board to cause interrupts
  1870. *
  1871. * Because the board has maskable status, this routine can simply set the
  1872. * mask to all ones.  We set all the bits symbolically; the effect is the
  1873. * same.  Note that the interrupt latch is not maskable; if none of the other
  1874. * mask bits are set, no interrupts will occur at all.  Only those interrupts
  1875. * whose status bits are enabled will actually occur.  Note that the "intMask"
  1876. * field in the device control structure is really the status mask.
  1877. *
  1878. * RETURNS: N/A.
  1879. */
  1881. LOCAL void elt3c509IntEnable
  1882.     (
  1883.     ELT3C509_DEVICE * pDrvCtrl /* device structure */
  1884.     )
  1885.     {
  1886.     UINT16  status;
  1888.     SYS_IN_BYTE (pDrvCtrl, pDrvCtrl->port + ELT3C509_STATUS, status);
  1889.     status &= 0x00ff;
  1890.     SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND,
  1891.                   ACK_INTERRUPT | status);
  1892.     SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND, MASK_INTERRUPT |
  1893.                   ADAPTER_FAILURE | TX_COMPLETE | TX_AVAILABLE | RX_COMPLETE |
  1894.                   RX_EARLY | INTERRUPT_REQ | UPDATE_STATS);
  1895.     }
  1897. /*******************************************************************************
  1898. *
  1899. * elt3c509IntDisable - prevent board from causing interrupts
  1900. *
  1901. * This routine simply sets all the interrupt mask bits to zero.
  1902. * It is intended for guarding board-critical sections.
  1903. *
  1904. * RETURNS: N/A.
  1905. */
  1907. LOCAL void elt3c509IntDisable
  1908.     (
  1909.     ELT3C509_DEVICE * pDrvCtrl /* device structure */
  1910.     )
  1911.     {
  1912.     UINT16  status;
  1914.     SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND,
  1915.                   MASK_INTERRUPT | 0);
  1916.     SYS_IN_BYTE (pDrvCtrl, pDrvCtrl->port + ELT3C509_STATUS, status);
  1917.     status &= 0x00ff;
  1918.     SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND,
  1919.                   ACK_INTERRUPT | status);
  1920.     }
  1922. /*******************************************************************************
  1923. *
  1924. * elt3c509TxStart - turn on board's transmit function
  1925. *
  1926. * RETURNS: N/A.
  1927. */
  1929. LOCAL void elt3c509TxStart
  1930.     (
  1931.     ELT3C509_DEVICE *  pDrvCtrl /* device structure */
  1932.     )
  1933.     {
  1934.     SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND, TX_ENABLE);
  1935.     }
  1937. /*******************************************************************************
  1938. *
  1939. * elt3c509RxStart - enable board to start receiving
  1940. *
  1941. * RETURNS: N/A.
  1942. */
  1944. LOCAL void elt3c509RxStart
  1945.     (
  1946.     ELT3C509_DEVICE *  pDrvCtrl /* device structure */
  1947.     )
  1948.     {
  1949.     SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND,
  1950.                   SET_RX_FILTER | pDrvCtrl->rxFilter);
  1951.     SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND, RX_ENABLE);
  1952.     }
  1954. /*******************************************************************************
  1955. *
  1956. * elt3c509Reset - reset the elt3c509 interface
  1957. *
  1958. * Mark interface as inactive and reset the adapter.
  1959. *
  1960. * RETURNS: N/A.
  1961. */
  1963. LOCAL void elt3c509Reset
  1964.     (
  1965.     ELT3C509_DEVICE * pDrvCtrl /* device structure */
  1966.     )
  1967.     {
  1968.     elt3c509IntDisable (pDrvCtrl); /* prevent device from interrupting */
  1969.     SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND, RX_RESET);
  1970.     SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND, TX_RESET);
  1971.     }
  1973. /*******************************************************************************
  1974. *
  1975. * elt3c509StatFlush - flush the board's statistics registers to statistics
  1976. * block Called when the board reports that its statistics registers are getting
  1977. * full, or when someone wants to see the current statistics (to fully update
  1978. * the statistics block).
  1979. *
  1980. * Note that reading a statistics register zeroes it in the hardware.
  1981. * Note also that zeroing all the registers is necessary and sufficient
  1982. * to clear the interrupt condition.
  1983. *
  1984. * Must be called with board or system interrupts disabled.
  1985. *
  1986. * RETURNS: N/A.
  1987. */
  1989. LOCAL void elt3c509StatFlush
  1990.     (
  1991.     ELT3C509_DEVICE * pDrvCtrl /* device structure */
  1992.     )
  1993.     {
  1994.     int         port;
  1995.     UINT16 tempCounter;
  1997.     port = pDrvCtrl->port;
  1999.     SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND,
  2000.                   SELECT_WINDOW | WIN_STATISTICS);
  2001.     SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND, STATS_DISABLE);
  2003.     SYS_IN_BYTE (pDrvCtrl, port+CARRIER_LOSTS, tempCounter);
  2004.     pDrvCtrl->elt3c509Stat.nocarriers += tempCounter & 0x0f;
  2006.     SYS_IN_BYTE (pDrvCtrl, port+SQE_FAILURES, tempCounter);
  2007.     pDrvCtrl->elt3c509Stat.heartbeats += tempCounter & 0x0f;
  2009.     SYS_IN_BYTE (pDrvCtrl, port+MULT_COLLISIONS, tempCounter);
  2010.     pDrvCtrl->elt3c509Stat.multcollisions += tempCounter & 0x3f;
  2012.     SYS_IN_BYTE (pDrvCtrl, port+ONE_COLLISIONS, tempCounter);
  2013.     pDrvCtrl->elt3c509Stat.collisions +=  tempCounter & 0x3f;
  2015.     SYS_IN_BYTE (pDrvCtrl, port+LATE_COLLISIONS, tempCounter);
  2016.     pDrvCtrl->elt3c509Stat.latecollisions += tempCounter;
  2018.     SYS_IN_BYTE (pDrvCtrl, port+RECV_OVERRUNS, tempCounter);
  2019.     pDrvCtrl->elt3c509Stat.rxoverruns += tempCounter;
  2021.     SYS_IN_BYTE (pDrvCtrl, port+GOOD_TRANSMITS, tempCounter);
  2022.     pDrvCtrl->elt3c509Stat.txnoerror += tempCounter;
  2024.     SYS_IN_BYTE (pDrvCtrl, port+GOOD_RECEIVES, tempCounter);
  2025.     pDrvCtrl->elt3c509Stat.rxnoerror += tempCounter;
  2027.     SYS_IN_BYTE (pDrvCtrl, port+TX_DEFERRALS, tempCounter);
  2028.     pDrvCtrl->elt3c509Stat.deferring += tempCounter;
  2030.     /* Must read all the registers to be sure to clear the interrupt */
  2032.     SYS_IN_WORD (pDrvCtrl, port + BYTES_RECEIVED, tempCounter);
  2033.     SYS_IN_WORD (pDrvCtrl, port + BYTES_TRANSMITTED, tempCounter);
  2035.     SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND, STATS_ENABLE);
  2036.     SYS_OUT_WORD (pDrvCtrl, port + ELT3C509_COMMAND,
  2037.                   SELECT_WINDOW | WIN_OPERATING);
  2038.     }
  2040. /*******************************************************************************
  2041. *
  2042. * elt3c509IntMaskSet - enable specific status conditions to cause interrupts
  2043. *
  2044. * Sets bit(s) in the intMask field of the device control structure and in
  2045. * the board's "read zero mask" where a one bit enables the corresponding
  2046. * status condition to be read and to cause an interrupt.
  2047. *
  2048. * RETURNS: N/A.
  2049. */
  2051. LOCAL void elt3c509IntMaskSet
  2052.     (
  2053.     ELT3C509_DEVICE *  pDrvCtrl, /* device structure */
  2054.     int  maskBits /* mask bits */
  2055.     )
  2056.     {
  2057.     elt3c509IntDisable (pDrvCtrl);
  2059.     pDrvCtrl->intMask |= maskBits;
  2060.     SYS_OUT_WORD (pDrvCtrl, pDrvCtrl->port + ELT3C509_COMMAND,
  2061.                   MASK_STATUS | pDrvCtrl->intMask);
  2063.     elt3c509IntEnable (pDrvCtrl);
  2064.     }
  2066. /*******************************************************************************
  2067. *
  2068. * elt3c509Activate - attempt to activate the adapter with given address
  2069. *
  2070. * The 3Com 3C509 ISA adapter does not enable itself at power-on.  This is
  2071. * left to the driver, which presumably knows which board it wants.  This
  2072. * we do know, from the port field in the driver control structure.
  2073. *
  2074. * As a helpful side effect, this routine stores the OEM Ethernet address
  2075. * of the selected adapter into the driver control structure.
  2076. *
  2077. * Note that this procedure will activate only one board of the given I/O
  2078. * address; this is presumably designed in by 3Com as a helpful feature.
  2079. *
  2080. * RETURNS: OK or ERROR.
  2081. */
  2083. LOCAL STATUS elt3c509Activate
  2084.     (
  2085.     ELT3C509_DEVICE * pDrvCtrl
  2086.     )
  2087.     {
  2088.     int  adapterPort;    /* I/O address of adapter we're to look for */
  2089.     int  selectedPort;   /* I/O address of adapter we've found */
  2090.     int  addressConfig;  /* adapter's address configuration register */
  2091.     int  resourceConfig; /* adapter's resource configuration register */
  2092.     char  nodeAddress [EA_SIZE];
  2093.     STATUS  status = OK;  /* presume OK, change if there's a problem */
  2095.     adapterPort = pDrvCtrl->port;
  2097.     elt3c509IdCommand (ID_PORT);             /* wake up all adapters */
  2098.     SYS_OUT_BYTE (pDrvCtrl, ID_PORT, ID_SET_TAG);   /* clear all tags */
  2100.     /* first see if there's a 3Com 3C5xx board out there at all */
  2102.     if (elt3c509IdEepromRead (EE_A_MANUFACTURER) != MANUFACTURER_ID)
  2103.         return (ERROR);
  2105.     /* Identify adapters one by one until we find the right one;
  2106.      * as we eliminate adapters, we tag them so they don't participate
  2107.      * in the next round of contention eliminations.  Along the way,
  2108.      * as part of the adapter contention process, we read out the
  2109.      * station address and resource configuration.
  2110.      */
  2112.     do
  2113.         {
  2114.         elt3c509IdCommand (ID_PORT);         /* prepare for contention */
  2116.         /* Now read all untagged adapters' addresses from EEPROM
  2117.          * a bit at a time.  Tagged adapters ignore the reads therefore
  2118.          * won't be found; we find the next untagged adapter.
  2119.          */
  2121.         * (UINT16 *) &nodeAddress [0] = elt3c509IdEepromRead (EE_A_OEM_NODE_0);
  2122.         * (UINT16 *) &nodeAddress [2] = elt3c509IdEepromRead (EE_A_OEM_NODE_1);
  2123.         * (UINT16 *) &nodeAddress [4] = elt3c509IdEepromRead (EE_A_OEM_NODE_2);
  2124.         resourceConfig = elt3c509IdEepromRead (EE_A_RESOURCE);
  2125.         addressConfig = elt3c509IdEepromRead (EE_A_ADDRESS);
  2126.         if ((addressConfig & AC_IO_BASE_MASK) == AC_IO_BASE_EISA)
  2127.             {
  2129.             /* the EISA base address is the last possible one; if we hit
  2130.              * this value without finding the adapter we want, we're done.
  2131.              */
  2133.             status = ERROR;
  2134.             break;
  2135.             }
  2136.         selectedPort = (addressConfig & AC_IO_BASE_MASK) * AC_IO_BASE_FACTOR +
  2137.                        AC_IO_BASE_ZERO;
  2139.         ENDLOGMSG (("elt: activate: adapter at 0x%04xn", selectedPort, 2, 3,
  2140.                     4, 5, 6));
  2142.         /* tag this adapter so if we don't want it it won't contend again */
  2144.         SYS_OUT_BYTE (pDrvCtrl, ID_PORT, ID_SET_TAG + 1);
  2145.         }
  2146.     while (selectedPort != adapterPort);
  2148.     if (status != ERROR)
  2149.         {
  2150.         SYS_OUT_BYTE (pDrvCtrl, ID_PORT, ID_ACTIVATE);
  2151.         uswab (nodeAddress, (char *)pDrvCtrl->enetAddr, EA_SIZE);
  2152.         }
  2154.     return (status);
  2155.     }
  2157. /*******************************************************************************
  2158. *
  2159. * elt3c509IdCommand - put all adapters into ID command state
  2160. *
  2161. * This procedure synchronizes the ID state machines of all installed 3Com
  2162. * adapters in preparation for contending among them.
  2163. *
  2164. * RETURNS: N/A.
  2165. */
  2167. LOCAL void elt3c509IdCommand
  2168.     (
  2169.     int idPort          /* I/O address to use as ID port (1x0 hex) */
  2170.     )
  2171.     {
  2172.     int  idValue;        /* data read or written to ID port */
  2173.     int  count;
  2175.     /* We should guard this routine since the ID procedure touches
  2176.      * all unactivated adapters.  In fact the first three writes should
  2177.      * be guarded against any possible intervening write to any port
  2178.      * 0x100, 0x110, 0x120, ... , 0x1f0.
  2179.      */
  2181.     SYS_OUT_BYTE (pDrvCtrl, idPort, ID_RESET); /* select the ID port */
  2182.     
  2183.     /* put adapters in ID-WAIT state */
  2184.     
  2185.     SYS_OUT_BYTE (pDrvCtrl, idPort, ID_RESET);
  2187.     idValue = ID_SEQUENCE_INITIAL;
  2188.     for (count = ID_SEQUENCE_LENGTH; count > 0; count--)
  2189.         {
  2190.         SYS_OUT_BYTE (pDrvCtrl, idPort, idValue);
  2191.         idValue <<= 1;
  2192.         if ((idValue & ID_CARRY_BIT) != 0)
  2193.             idValue ^= ID_POLYNOMIAL;
  2194.         }
  2195.     }
  2197. /*******************************************************************************
  2198. *
  2199. * elt3c509EepromRead - read one 16-bit adapter EEPROM register.
  2200. *
  2201. * RETURNS: Value from an offset of the EEPROM.
  2202. */
  2204. LOCAL int elt3c509EepromRead
  2205.     (
  2206.     int  port,
  2207.     int  offset
  2208.     )
  2210.     {
  2211.     int  ix;
  2212.     UINT16 epromStatus;
  2214.     SYS_OUT_WORD (NULL, port + EEPROM_CONTROL, 0x80 + offset);
  2216.     /* wait 162 us minimum */
  2218.     for (ix = 0; ix < 400; ix++)
  2219. sysDelay ();
  2220.     
  2221.     SYS_IN_WORD (NULL, port + EEPROM_DATA, epromStatus);
  2222.     return (epromStatus);
  2223.     }
  2226. /*******************************************************************************
  2227. *
  2228. * elt3c509IdEepromRead - read one 16-bit adapter EEPROM register
  2229. *
  2230. * Read an EEPROM register bitwise by way of the ID port.  Used for adapter
  2231. * contention process and to find out what's in the EEPROM.  Addresses are
  2232. * masked to a valid size; invalid addresses are simply truncated.
  2233. *
  2234. * RETURNS: Value from an offset of Eeprom.
  2235. */
  2237. LOCAL UINT16 elt3c509IdEepromRead
  2238.     (
  2239.     int address                         /* EEPROM register address */
  2240.     )
  2241.     {
  2242.     int  bitCount;
  2243.     UINT16  value;
  2244.     UINT16 tempVal;
  2246.     SYS_OUT_BYTE (NULL, ID_PORT, ID_EEPROM_READ | (address & ID_EEPROM_MASK));
  2247.     taskDelay (2);                      /* must wait for 162 uS read cycle */
  2248.     value = 0;
  2249.     for (bitCount = ID_REGISTER_SIZE; bitCount > 0; bitCount--)
  2250.         {
  2251.         value <<= 1;
  2252.         SYS_IN_BYTE (NULL, ID_PORT, tempVal);
  2253. value |= (tempVal & 1);
  2254.         }
  2255.     return (value);
  2256.     }
  2258. #ifdef DRV_DEBUG
  2259. /*******************************************************************************
  2260. *
  2261. * elt3c509Show - display statistics for the 3C509 `elt' network interface
  2262. *
  2263. * This routine displays statistics about the `elt' Ethernet network interface.
  2264. * It has two parameters: 
  2265. * .iP <unit>
  2266. * interface unit; should be 0.
  2267. * .iP <zap>
  2268. * if 1, all collected statistics are cleared to zero.
  2269. * .LP
  2270. *
  2271. * NOMANUAL
  2272. *
  2273. * RETURNS: N/A
  2274. */
  2276. void elt3c509Show 
  2277.     (
  2278.     ELT3C509_DEVICE *  pDrvCtrl, /* device structure */
  2279.     BOOL  zap     /* 1 = zero totals */
  2280.     )
  2281.     {
  2282.     FAST int ix;
  2284.     LOCAL char *e_message [] = {
  2285.         "collisions",
  2286.         "crcs",
  2287.         "aligns",
  2288.         "rx no buffers",
  2289.         "rx over-runs",
  2290.         "disabled",
  2291.         "deferring",
  2292.         "tx under-run",
  2293.         "aborts",
  2294.         "out-of-window",
  2295.         "heart-beats",
  2296.         "bad-packet",
  2297.         "short-packet",
  2298.         "tx-no-error",
  2299.         "rx-no-error",
  2300.         "tx-error",
  2301.         "rx-error",
  2302.         "over-write",
  2303.         "wrapped",
  2304.         "interrupts",
  2305.         "reset",
  2306.         "stray-int",
  2307.         "multiple-collisions",
  2308.         "late-collisions",
  2309.         "no-carriers",
  2310.         "jabbers",
  2311.         "tx over-run",
  2312.         "rx under-run",
  2313. #ifdef ELT_TIMING
  2314.         "rx early",
  2315.         "timer updates",
  2316.         "timer overflows",
  2317.         "timer invalids",
  2318.         "max rx latency",
  2319.         "min rx latency",
  2320.         "max int latency",
  2321.         "current outstanding net rx tasks",
  2322.         "max outstanding rx net tasks",
  2323.         "current outstanding net tx tasks",
  2324.         "max outstanding tx net tasks"
  2325. #else
  2326.         "rx early"
  2327. #endif /* ELT_TIMING */
  2328. };
  2330.     /* Disable board interrupts because elt3c509StatFlush()
  2331.      * changes reg. window
  2332.      */
  2334.     elt3c509IntDisable (pDrvCtrl);
  2335.     elt3c509StatFlush (pDrvCtrl);            /* get the latest statistics */
  2336.     elt3c509IntEnable (pDrvCtrl);
  2338.     for (ix = 0; ix < NELEMENTS(e_message); ix++)
  2339.         {
  2340.         printf ("    %-30.30s  %4dn", e_message [ix],
  2341.                 pDrvCtrl->elt3c509Stat.stat [ix]);
  2342.         if (zap)
  2343.             pDrvCtrl->elt3c509Stat.stat [ix] = 0;
  2344.         }
  2345.     }
  2346. #endif /* DRV_DEBUG */