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

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

VxWorks

开发平台：

C/C++

ln7990End.c：源码内容
  1. /* ln7990End.c - END style AMD 7990 LANCE Ethernet network interface driver */
  3. /* Copyright 1984-2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 02x,16jul02,rcs  aligned pRing and pTring before initializing fields. SPR#77322
  10. 02w,14jan02,dat  Removing warnings from Diab compiler
  11. 02v,11jun00,ham  removed reference to etherLib.
  12. 02u,27jan00,dat  fixed use of NULL
  13. 02t,04mar99,jkf  removed "+ 2" when setting pTring. added "+ 1" and 
  14.                  "* TMD_SIZ" to lnClDescTbl[0].memArea, ln7990InitMem(),
  15.                  for boards that hand over a memory pool SPR#22628.  
  16.                  changed ln7990ScrubTRing() to handle a receive packet.
  17.                  fixed the endMultiLstCnt implicit declaration warning.
  18. 02s,06oct98,n_s  correct error codes in ln7990Int.
  19. 02r,30sep98,n_s  removed check for RINT in PollReceive.
  20. 02q,23sep98,n_s  fixed ln7990Int to limit netJobAdd calls and handle overload
  21.                  cases.  spr # 22381.
  22. 02p,22sep98,n_s  fixed ln7990Int to call Restart from task level.
  23. 02o,21sep98,n_s  corrected handling of txSem in ln7990Send ().
  24. 02n,22sep98,dat  SPR 22325, System mode transition.
  25. 02m,17jul98,db   changed "holder" in ln7990InitParse from char ** to char *.
  26.  fixed references to "holder" in ln7990InitParse(spr #21464).
  27. 02l,12dec97,kbw  made man page edits
  28. 02k,11dec97,gnn  removed IFF_SCAT and IFF_LOAN.
  29. 02j,08dec97,gnn  END code review fixes
  30. 02i,25nov97,gnn  fixed spr#9620 polled mode receive
  31. 02h,27oct97,vin  fixed the offset problem in xxRecv() call.
  32. 02g,19oct97,vin  moved swapping of loaned buffer before END_RCV_RTN_CALL
  33. 02f,17oct97,vin  removed extra free.
  34. 02e,07oct97,vin  MIB MTU size to ETHER_MTU
  35. 02d,03oct97,gnn  added example error upcall code
  36. 02c,25sep97,gnn  fixed SPARC issues and cleaned up memory problems.
  37. 02b,03sep97,gnn  fixed a crashing bug under heavy load
  38. 02a,31aug97,vin  reimplemented txBlocked logic, moved the txBlocked variable 
  39.  into the drvCtrl structure.
  40. 01z,25aug97,gnn  changes due to new netPoolInit routine.
  41. 01y,22aug97,gnn  rewrote and fixed polled mode
  42. 01x,19aug97,gnn  changes due to new buffering scheme.
  43. 01w,12aug97,gnn  changes necessitated by MUX/END update.
  44. 01v,02jun97,gnn  implemented new Memory Width ioctl.
  45. 01u,20may97,spm  corrected memory alignment, added a real lnRestart function 
  46. 01t,17apr97,gnn  added offset load parameter.
  47. 01s,24feb97,gnn  Removed an unecessary step in the interrupt routine.
  48.                  Added code to properly pass back NET_BUFFER fields.
  49. 01r,05jan97,gnn  Turned IFF_SCAT off by default.
  50. 01q,03feb97,gnn  Changed the way in which muxBufAlloc is used.
  51.                  Added speed as an argument to MIB stuff.
  52. 01p,22jan97,gnn  Turned IFF_SCAT off by default.
  53. 01o,22jan97,gnn  Changed code to get the enet address from the BSP.
  54. 01n,21jan97,gnn  Added code to handle send side free routines.
  55.                  Added code to handle scatter/gather interface.
  56.                  Added code to better handle polled mode.
  57.                  Removed code that is common to all ENDs into endLib.c.
  58. 01m,06jan97,gnn  Fixed compilation errors and removed more non-driver stuff.
  59. 01l,23dec96,dat  added macros, added csr3B, enetAddr to init string,
  60. 01k,02dec96,gnn  forgot a break in the Ioctl.
  61. 01j,27nov96,gnn  added MIB 2 Ioctl.
  62. 01i,19nov96,gnn  Added IFF_BROADCAST to the flags.
  63. 01h,13nov96,dat  Restructured to isolate end/mib routines
  64. 01g,22oct96,gnn  Name changes to follow coding standards.
  65.                  static functions changed to LOCAL.
  66. 01f,22oct96,gnn  Removed all netVectors and replaced them with netBuffers.
  67.                  Did a significant code cleanup in preparation for going to
  68.                  a 32bit world with a 24 bit driver.
  69. 01e,23sep96,gnn  Cleanup of code.  Changed pointers to look like WRS
  70.  pointers and the like.
  71.  Made is so that the ln7990Config routine works
  72.  correctly to fill in the transmit and receive
  73.  descriptors' memory fields.
  74.  This version works with system level debugging or
  75.  buffer loaning but not with both.
  76. 01d,28aug96,gnn  Fixed argument parsing for pre-allocated memory.
  77.  Added more log messages to the load sequence.
  78. 01c,15aug96,gnn  Name changes to follow our coding standard.
  79. 01b,14aug96,gnn  Worked the documentation and other stuff over to
  80.  integrate into the new scheme of network drivers.
  81. 01a,22apr96,gnn  Copied if_ln driver and worked into the END scheme.
  82. */
  84. /*
  85. This module implements the Advanced Micro Devices Am7990 LANCE Ethernet network
  86. interface driver.  The driver can be configured to support big-endian or
  87. little-endian architectures, and it contains error recovery code to handle 
  88. known device errata related to DMA activity.
  90. This driver is designed to be moderately generic.  Thus, it operates 
  91. unmodified across the range of architectures and targets supported by 
  92. VxWorks.  To achieve this, the driver load routine requires an input 
  93. string consisting of several target-specific values.  The driver also 
  94. requires some external support routines.  These target-specific values 
  95. and the external support routines are described below.  If any of the 
  96. assumptions stated below are not true for your particular hardware, this 
  97. driver might not function correctly with that hardware.
  99. BOARD LAYOUT
  100. This device is on-board.  No jumpering diagram is necessary.
  102. EXTERNAL INTERFACE
  103. The only external interface is the ln7990EndLoad() routine, which expects
  104. the <initString> parameter as input.  This parameter passes in a 
  105. colon-delimited string of the format:
  107. <unit>:<CSR_reg_addr>:<RAP_reg_addr>:<int_vector>:<int_level>:<shmem_addr>:<shmem_size>:<shmem_width>:<offset>:<csr3B>
  109. The ln7990EndLoad() function uses strtok() to parse the string.
  111. TARGET-SPECIFIC PARAMETERS
  112. .IP <unit>
  113. A convenient holdover from the former model.  This parameter is used only
  114. in the string name for the driver.
  115. .IP <CSR_register_addr>
  116. Tells the driver where to find the CSR register.
  117. .IP <RAP_register_addr>
  118. Tells the driver where to find the RAP register.
  119. .IP <int_vector>
  120. Configures the LANCE device to generate hardware interrupts
  121. for various events within the device. Thus, it contains
  122. an interrupt handler routine.  The driver calls sysIntConnect() to connect
  123. its interrupt handler to the interrupt vector generated as a result of
  124. the LANCE interrupt.
  125. .IP <int_level>
  126. This parameter is passed to an external support routine, sysLanIntEnable(),
  127. which is described below in "External Support Requirements." This routine 
  128. is called during as part of driver's initialization.  It handles any 
  129. board-specific operations required to allow the servicing of a LANCE 
  130. interrupt on targets that use additional interrupt controller devices to 
  131. help organize and service the various interrupt sources.  This parameter 
  132. makes it possible for this driver to avoid all board-specific knowledge of 
  133. such devices.  
  134. .IP <shmem_addr>
  135. The LANCE device is a DMA type of device and typically shares access to
  136. some region of memory with the CPU.  This driver is designed for systems
  137. that directly share memory between the CPU and the LANCE.  It
  138. assumes that this shared memory is directly available to it
  139. without any arbitration or timing concerns.
  141. This parameter can be used to specify an explicit memory region for use
  142. by the LANCE.  This should be done on hardware that restricts the LANCE
  143. to a particular memory region.  The constant NONE can be used to indicate
  144. that there are no memory limitations, in which case, the driver
  145. attempts to allocate the shared memory from the system space.
  146. .IP <shmem_size>
  147. Use this parameter to explicitly limit the amount of shared memory (bytes) 
  148. that this driver uses.  Use "NONE" to indicate that there is no specific 
  149. size limitation.  This parameter is used only if a specific memory region 
  150. is provided to the driver.
  151. .IP <shmem_width>
  152. Some target hardware that restricts the shared memory region to a
  153. specific location also restricts the access width to this region by
  154. the CPU.  On such targets, performing an access of an invalid width
  155. causes a bus error.  Use this parameter to specify the number of bytes 
  156. on which data must be aligned if it is to be used by the driver during 
  157. access to the shared memory.  Use "NONE" to indicate that there are no 
  158. restrictions.  The support for this mechanism is not robust. Thus, its 
  159. current implementation might not work on all targets requiring these 
  160. restrictions.
  161. .IP <offset>
  162. Specifies the memory alignment offset.
  163. .IP <csr3B>
  164. Specifies the value that is placed into LANCE control register #3. This
  165. value determines the bus mode of the device and thus allows the support of
  166. big-endian and little-endian architectures.  The default value supports
  167. Motorola-type buses.  Normally this value is 0x4.  For SPARC CPUs, it is
  168. normally set to 0x7 to add the ACON and BCON control bits.  For more
  169. information on this register and the bus mode of the LANCE controller, see
  170. .I "Advanced Micro Devices Local Area Network Controller Am7990 (LANCE)."
  171. .LP
  173. EXTERNAL SUPPORT REQUIREMENTS
  174. This driver requires several external support functions, defined as macros:
  175. .CS
  176.     SYS_INT_CONNECT(pDrvCtrl, routine, arg)
  177.     SYS_INT_DISCONNECT (pDrvCtrl, routine, arg)
  178.     SYS_INT_ENABLE(pDrvCtrl)
  179.     SYS_OUT_SHORT(pDrvCtrl, reg, data)
  180.     SYS_IN_SHORT(pDrvCtrl, reg, pData)
  181. .CE
  183. There are default values in the source code for these macros.  They presume
  184. memory-mapped accesses to the device registers and the normal intConnect(),
  185. and intEnable() BSP functions.  The first argument to each is the device
  186. controller structure. Thus, each has access back to all the device-specific
  187. information.  Having the pointer in the macro facilitates the addition 
  188. of new features to this driver.
  190. SYSTEM RESOURCE USAGE
  191. When implemented, this driver requires the following system resources:
  193.     - one interrupt vector
  194.     - 68 bytes in the initialized data section (data) /@HELP@/
  195.     - 0 bytes of bss /@HELP@/
  197. The above data and BSS requirements are for the MC68020 architecture
  198. and can vary for other architectures.  Code size (text) varies greatly 
  199. between architectures and is therefore not quoted here.
  201. If the driver is not given a specific region of memory using the ln7990EndLoad()
  202. routine, then it calls cacheDmaMalloc() to allocate the memory to be shared
  203. with the LANCE.  The size requested is 80,542 bytes.  If a memory region
  204. is provided to the driver, the size of this region is adjustable to suit
  205. user needs.
  207. The LANCE can only be operated if the shared memory region is write-coherent
  208. with the data cache.  The driver cannot maintain cache coherency for data 
  209. that is written by the driver. That is because members within the shared 
  210. structures are asynchronously modified by both the driver and the device, 
  211. and these members might share the same cache line.
  213. SEE ALSO: muxLib,
  214. .I "Advanced Micro Devices Local Area Network Controller Am7990 (LANCE)"
  215. */
  217. #include "vxWorks.h"
  218. #include "wdLib.h"
  219. #include "stdlib.h"
  220. #include "taskLib.h"
  221. #include "logLib.h"
  222. #include "intLib.h"
  223. #include "netLib.h"
  224. #include "stdio.h"
  225. #include "stdlib.h"
  226. #include "sysLib.h"
  227. #include "iv.h"
  228. #include "memLib.h"
  229. #include "semLib.h"
  230. #include "cacheLib.h"
  231. #include "sys/ioctl.h"
  233. #ifndef DOC             /* don't include when building documentation */
  234. #include "net/mbuf.h"
  235. #endif  /* DOC */
  237. #include "net/protosw.h"
  238. #include "sys/socket.h"
  239. #include "errno.h"
  240. #include "net/if.h"
  241. #include "net/route.h"
  242. #include "netinet/in.h"
  243. #include "netinet/in_systm.h"
  244. #include "netinet/in_var.h"
  245. #include "netinet/ip.h"
  246. #include "netinet/if_ether.h"
  247. #include "net/if_subr.h"
  248. #include "m2Lib.h"
  249. #include "drv/end/ln7990EndCommon.h" /* Common defines. */
  250. #include "drv/end/ln7990End.h" /* device description header */
  251. #include "etherMultiLib.h" /* multicast stuff. */
  252. #include "end.h" /* Common END structures. */
  253. #include "netBufLib.h"
  254. #include "muxLib.h"
  256. #undef END_MACROS
  258. #include "endLib.h"
  259. #include "lstLib.h" /* Needed to maintain protocol list. */
  261. /***** LOCAL DEFINITIONS *****/
  263. #define DELAY(count) {                                               
  264. volatile int cx = 0;                            
  265. for (cx = 0; cx < (count); cx++);               
  266. }
  268. /* Configuration items */
  270. #define LN_BUFSIZ      (ETHERMTU + SIZEOF_ETHERHEADER + 6)
  271. #define LN_RMD_RLEN     5       /* ring size as a power of 2 -- 32 RMD's */
  272. #define LN_TMD_TLEN     5       /* same for transmit ring    -- 32 TMD's */
  273. #define LN_SPEED        10000000
  275. /* Naming items */
  276. #define LN_DEV_NAME "ln"
  277. #define LN_DEV_NAME_LEN 3
  279. /*
  280.  * If LN_KICKSTART_TX is TRUE the transmitter is kick-started to force a
  281.  * read of the transmit descriptors, otherwise the internal polling (1.6msec)
  282.  * will initiate a read of the descriptors.  This should be FALSE is there
  283.  * is any chance of memory latency or chip accesses detaining the LANCE DMA,
  284.  * which results in a transmitter UFLO error.  This can be changed with the
  285.  * global lnKickStartTx below.
  286.  */
  288. #define LN_KICKSTART_TX TRUE
  290. /* Cache macros */
  292. #define LN_CACHE_INVALIDATE(address, len) 
  293.         CACHE_DRV_INVALIDATE (&pDrvCtrl->cacheFuncs, (address), (len))
  295. #define LN_CACHE_PHYS_TO_VIRT(address) 
  296.         CACHE_DRV_PHYS_TO_VIRT (&pDrvCtrl->cacheFuncs, (address))
  298. #define LN_CACHE_VIRT_TO_PHYS(address) 
  299.         CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, (address))
  301. /*
  302.  * Default macro definitions for BSP interface.
  303.  * These macros can be redefined in a wrapper file, to generate
  304.  * a new module with an optimized interface.
  305.  */
  307. #ifndef SYS_INT_CONNECT
  308. #define SYS_INT_CONNECT(pDrvCtrl,rtn,arg,pResult) 
  309.     { 
  310.     IMPORT STATUS sysIntConnect(); 
  311.     *pResult = intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (pDrvCtrl->ivec), 
  312.      rtn, (int)arg); 
  313.     }
  314. #endif /*SYS_INT_CONNECT*/
  316. #ifndef SYS_INT_DISCONNECT
  317. #define SYS_INT_DISCONNECT(pDrvCtrl,rtn,arg,pResult) 
  318.     { 
  319.     *pResult = OK; /* HELP: need a real routine */ 
  320.     }
  321. #endif /*SYS_INT_DISCONNECT*/
  323. #ifndef SYS_INT_ENABLE
  324. #define SYS_INT_ENABLE(pDrvCtrl) 
  325.     { 
  326.     IMPORT void sysLanIntEnable(); 
  327.     sysLanIntEnable (pDrvCtrl->ilevel); 
  328.     }
  329. #endif /*SYS_INT_ENABLE*/
  331. #ifndef SYS_OUT_SHORT
  332. #define SYS_OUT_SHORT(pDrvCtrl,addr,value) 
  333.     { 
  334.     *(USHORT *)addr = value; 
  335.     }
  336. #endif /*SYS_OUT_SHORT*/
  338. #ifndef SYS_IN_SHORT
  339. #define SYS_IN_SHORT(pDrvCtrl,addr,pData) 
  340.     (*(USHORT *)pData = *(USHORT *)addr)
  341. #endif /*SYS_IN_SHORT*/
  343. #ifndef SYS_ENET_ADDR_GET
  344. #define SYS_ENET_ADDR_GET(pAddress) 
  345.     { 
  346.     IMPORT unsigned char lnEnetAddr[]; 
  347.     bcopy ((char *)lnEnetAddr, (char *)(pAddress), 6); 
  348.     }
  349. #endif /* SYS_ENET_ADDR_GET */
  351. /* A shortcut for getting the hardware address from the MIB II stuff. */
  352. #define END_HADDR(pEnd)
  353. ((pEnd)->mib2Tbl.ifPhysAddress.phyAddress)
  355. #define END_HADDR_LEN(pEnd) 
  356. ((pEnd)->mib2Tbl.ifPhysAddress.addrLength)
  358. #define END_FLAGS_ISSET(pEnd, setBits)                                  
  359.             ((pEnd)->flags & (setBits))
  361. typedef struct free_args
  362.     {
  363.     void* arg1;
  364.     void* arg2;
  365.     } FREE_ARGS;
  366.         
  367. /* The definition of the driver control structure */
  369. typedef struct ln_device
  370.     {
  371.     END_OBJ     end; /* The class we inherit from. */
  372.     ln_ib       *ib; /* ptr to Initialization Block */
  373.     int unit; /* unit number */
  374.     int rmdIndex; /* current RMD index */
  375.     int rringSize; /* RMD ring size */
  376.     int  rringLen;  /* RMD ring length (bytes) */
  377.     ln_rmd* pRring; /* RMD ring start */
  378.     int tmdIndex; /* current TMD index */
  379.     int tmdIndexC; /* current TMD index */
  380.     int tringSize; /* TMD ring size */
  381.     int  tringLen;               /* TMD ring length (bytes) */
  382.     ln_tmd* pTring; /* TMD ring start */
  383.     int         ivec;                   /* interrupt vector */
  384.     int         ilevel;                 /* interrupt level */
  385.     u_short* pCsr;               /* device register CSR */
  386.     u_short* pRap;               /* device register RAP */
  387.     char*       pShMem;                 /* real ptr to shared memory */
  388.     char*       memBase;                /* LANCE memory pool base */
  389.     char*       memAdrs;                /* LANCE memory pool base */
  390.     int         memSize;                /* LANCE memory pool size */
  391.     int         memWidth;               /* width of data port */
  392.     int         offset;
  393.     int         csr0Errs;               /* count of csr0 errors */
  394.     long flags; /* Our local flags. */
  395.     UCHAR enetAddr[6]; /* ethernet address */
  396.     USHORT csr3B;
  397.     CACHE_FUNCS cacheFuncs;             /* cache function pointers */
  398.     BOOL txBlocked;  /* transmit flow control */
  399.     BOOL        txCleaning;
  400.     FUNCPTR     freeRtn[128];           /* Array of free routines. */
  401.     struct free_args    freeData[128];          /* Array of free arguments */
  402.                                         /* the free routines. */
  403.     CL_POOL_ID  pClPoolId;
  404.     END_ERR     lastError;              /* Last error passed to muxError */
  405.     BOOL        errorHandling;          /* task level error handling */
  406.     u_short     errorStat;              /* error status */
  407.     } LN7990END_DEVICE;
  409. /* Definitions for the flags field */
  411. #define LS_PROMISCUOUS_FLAG     0x1
  412. #define LS_MEM_ALLOC_FLAG       0x2
  413. #define LS_PAD_USED_FLAG        0x4
  414. #define LS_RCV_HANDLING_FLAG    0x8
  415. #define LS_POLLING 0x20
  417. /* network buffers configuration */
  419. M_CL_CONFIG lnMclConfig =  /* mBlk configuration table */
  420.     {
  421.     0, 0, NULL, 0
  422.     };
  424. CL_DESC lnClDescTbl [] =  /* network cluster pool configuration table */
  425.     {
  426.     /* 
  427.     clusterSize num memArea memSize
  428.     ----------- ---- ------- -------
  429.     */
  430.     {LN_BUFSIZ, 0, NULL, 0}
  431.     }; 
  433. int lnClDescTblNumEnt = (NELEMENTS(lnClDescTbl));
  435. /***** DEBUG MACROS *****/
  437. #undef DRV_DEBUG
  439. #ifdef DRV_DEBUG
  440. #define DRV_DEBUG_OFF 0x0000
  441. #define DRV_DEBUG_RX 0x0001
  442. #define DRV_DEBUG_TX 0x0002
  443. #define DRV_DEBUG_INT 0x0004
  444. #define DRV_DEBUG_POLL (DRV_DEBUG_POLL_RX | DRV_DEBUG_POLL_TX)
  445. #define DRV_DEBUG_POLL_RX 0x0008
  446. #define DRV_DEBUG_POLL_TX 0x0010
  447. #define DRV_DEBUG_LOAD 0x0020
  448. #define DRV_DEBUG_IOCTL 0x0040
  449. #define DRV_DEBUG_POLL_REDIR 0x10000
  450. #define DRV_DEBUG_LOG_NVRAM 0x20000
  452. #ifdef LOCAL
  453. #undef LOCAL
  454. #endif /* LOCAL */
  456. #define LOCAL ;
  458. int ln7990Debug = DRV_DEBUG_OFF; /* Turn it off initially. */
  459. #include "nvLogLib.h"
  461. NET_POOL ln7990NetPool;
  463. #define DRV_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)                        
  464. if ((ln7990Debug & FLG)&&(FLG & DRV_DEBUG_POLL))                
  465.             nvLogMsg(X0, X1, X2, X3, X4, X5, X6);                       
  466.         else if (ln7990Debug & FLG)                                     
  467.             logMsg(X0, X1, X2, X3, X4, X5, X6);
  469. #define DRV_PRINT(FLG,X)                                                
  470. if (ln7990Debug & FLG) printf X;
  472. #else /*DRV_DEBUG*/
  474. #define DRV_LOG(DBG_SW, X0, X1, X2, X3, X4, X5, X6)
  475. #define DRV_PRINT(DBG_SW,X)
  477. #endif /*DRV_DEBUG*/
  479. /***** LOCALS *****/
  481. LOCAL int lnTsize = LN_TMD_TLEN;    /* deflt xmit ring size as power of 2 */
  482. LOCAL int lnRsize = LN_RMD_RLEN;    /* deflt recv ring size as power of 2 */
  483. LOCAL BOOL lnKickStartTx = LN_KICKSTART_TX;
  485. /* forward static functions */
  487. LOCAL void ln7990Reset (LN7990END_DEVICE *pDrvCtrl);
  488. LOCAL void ln7990Int (LN7990END_DEVICE *pDrvCtrl);
  489. LOCAL void ln7990HandleRecvInt (LN7990END_DEVICE *pDrvCtrl);
  490. LOCAL STATUS ln7990Recv (LN7990END_DEVICE *pDrvCtrl, ln_rmd *rmd);
  491. LOCAL ln_rmd * ln7990FullRMDGet (LN7990END_DEVICE *pDrvCtrl);
  492. LOCAL u_short ln7990Csr0Read (LN7990END_DEVICE * pDrvCtrl);
  493. LOCAL void ln7990CsrWrite (LN7990END_DEVICE * pDrvCtrl, int reg,
  494. u_short value);
  495. LOCAL void ln7990Restart (LN7990END_DEVICE *pDrvCtrl);
  496. LOCAL STATUS  ln7990RestartSetup (LN7990END_DEVICE *pDrvCtrl);
  497. LOCAL void ln7990Config (LN7990END_DEVICE *pDrvCtrl);
  498. LOCAL void ln7990AddrFilterSet (LN7990END_DEVICE *pDrvCtrl);
  499. LOCAL void ln7990ScrubTRing (LN7990END_DEVICE* pDrvCtrl);
  500. LOCAL void      ln7990HandleError (LN7990END_DEVICE  *pDrvCtrl);
  502. /* END Specific interfaces. */
  504. /* This is the only externally visible interface. */
  505. END_OBJ*  ln7990EndLoad (char* initString);
  507. LOCAL STATUS ln7990Start (LN7990END_DEVICE* pDrvCtrl);
  508. LOCAL STATUS ln7990Stop (LN7990END_DEVICE* pDrvCtrl);
  509. LOCAL STATUS ln7990Unload (LN7990END_DEVICE* pDrvCtrl);
  510. LOCAL int ln7990Ioctl (LN7990END_DEVICE* pDrvCtrl, int cmd, caddr_t data);
  511. LOCAL STATUS ln7990Send (LN7990END_DEVICE* pDrvCtrl, M_BLK_ID pBuf);
  512.   
  513. LOCAL STATUS ln7990MCastAddrAdd (LN7990END_DEVICE* pDrvCtrl, char* pAddress);
  514. LOCAL STATUS ln7990MCastAddrDel (LN7990END_DEVICE* pDrvCtrl, char* pAddress);
  515. LOCAL STATUS ln7990MCastAddrGet (LN7990END_DEVICE* pDrvCtrl,
  516.     MULTI_TABLE* pTable);
  517. LOCAL STATUS ln7990PollSend (LN7990END_DEVICE* pDrvCtrl, M_BLK_ID pBuf);
  518. LOCAL STATUS ln7990PollReceive (LN7990END_DEVICE* pDrvCtrl, M_BLK_ID pBuf);
  519. LOCAL STATUS ln7990PollStart (LN7990END_DEVICE* pDrvCtrl);
  520. LOCAL STATUS ln7990PollStop (LN7990END_DEVICE* pDrvCtrl);
  522. LOCAL STATUS ln7990InitParse ();
  523. LOCAL STATUS ln7990InitMem ();
  525. /*
  526.  * Declare our function table.  This is static across all driver
  527.  * instances.
  528.  */
  529. LOCAL NET_FUNCS lnFuncTable =
  530.     {
  531.     (FUNCPTR)ln7990Start, /* Function to start the device. */
  532.     (FUNCPTR)ln7990Stop, /* Function to stop the device. */
  533.     (FUNCPTR)ln7990Unload, /* Unloading function for the driver. */
  534.     (FUNCPTR)ln7990Ioctl, /* Ioctl function for the driver. */
  535.     (FUNCPTR)ln7990Send, /* Send function for the driver. */
  536.     (FUNCPTR)ln7990MCastAddrAdd,/* Multicast address add */
  537.     (FUNCPTR)ln7990MCastAddrDel,/* Multicast address delete */
  538.     (FUNCPTR)ln7990MCastAddrGet,/* Multicast table retrieve */
  539.     (FUNCPTR)ln7990PollSend, /* Polling send function for the driver. */
  540.     (FUNCPTR)ln7990PollReceive, /* Polling receive function for the driver. */
  541.     endEtherAddressForm,        /* Put address info into a packet.  */
  542.     endEtherPacketDataGet,      /* Get a pointer to packet data. */
  543.     endEtherPacketAddrGet       /* Get packet addresses. */
  544.     };
  546. /* external IMPORT's */
  548. #ifndef END_MACROS
  549. IMPORT int endMultiLstCnt (END_OBJ *);
  550. #endif
  553. /******************************************************************************
  554. *
  555. * ln7990EndLoad - initialize the driver and device
  556. *
  557. * This routine initializes the driver and the device to the operational state.
  558. * All of the device-specific parameters are passed in <initString>, which
  559. * expects a string of the following format:
  560. *
  561. * <unit>:<CSR_reg_addr>:<RAP_reg_addr>:<int_vector>:<int_level>:<shmem_addr>:
  562. * <shmem_size>:<shmem_width>
  563. *
  564. * This routine can be called in two modes. If it is called with an empty but
  565. * allocated string, it places the name of this device (that is, "ln") into 
  566. * the <initString> and returns 0.
  567. *
  568. * If the string is allocated and not empty, the routine attempts to load
  569. * the driver using the values specified in the string.
  570. *
  571. * RETURNS: An END object pointer, or NULL on error, or 0 and the name of the
  572. * device if the <initString> was NULL.
  573. */
  575. END_OBJ* ln7990EndLoad
  576.     (
  577.     char* initString /* string to be parse by the driver */
  578.     )
  579.     {
  580.     LN7990END_DEVICE  *pDrvCtrl;
  582.     DRV_LOG (DRV_DEBUG_LOAD, "Loading ln...n", 1, 2, 3, 4, 5, 6);
  584.     if (initString == NULL)
  585.         return (NULL);
  586.     
  587.     if (initString[0] == 0)
  588.         {
  589.         bcopy((char *)LN_DEV_NAME, initString, LN_DEV_NAME_LEN);
  590.         return (0);
  591.         }
  592.     
  593.     /* allocate the device structure */
  595.     pDrvCtrl = (LN7990END_DEVICE *)calloc (sizeof (LN7990END_DEVICE), 1);
  596.     if (pDrvCtrl == NULL)
  597. goto errorExit;
  599.     /* parse the init string, filling in the device structure */
  601.     if (ln7990InitParse (pDrvCtrl, initString) == ERROR)
  602. goto errorExit;
  604.     /* Have the BSP hand us our address. */
  606.     SYS_ENET_ADDR_GET(&(pDrvCtrl->enetAddr));
  608.     /* initialize the END and MIB2 parts of the structure */
  610.     if (END_OBJ_INIT (&pDrvCtrl->end, (DEV_OBJ *)pDrvCtrl, LN_DEV_NAME,
  611.     pDrvCtrl->unit, &lnFuncTable,
  612.                       "AMD 7990 Lance Enhanced Network Driver") == ERROR
  613.      || END_MIB_INIT (&pDrvCtrl->end, M2_ifType_ethernet_csmacd,
  614.                       &pDrvCtrl->enetAddr[0], 6, ETHERMTU,
  615.                       LN_SPEED)
  616.     == ERROR)
  617. goto errorExit;
  619.     /* Perform memory allocation */
  621.     if (ln7990InitMem (pDrvCtrl) == ERROR)
  622. goto errorExit;
  624.     /* Perform memory distribution and reset and reconfigure the device */
  626.     if (ln7990RestartSetup (pDrvCtrl) == ERROR)
  627.         goto errorExit;
  629.     /* set the flags to indicate readiness */
  631.     END_OBJ_READY (&pDrvCtrl->end,
  632.     IFF_UP | IFF_RUNNING | IFF_NOTRAILERS | IFF_BROADCAST
  633.     | IFF_MULTICAST | IFF_SIMPLEX);
  634.     
  635.     DRV_LOG (DRV_DEBUG_LOAD, "Done loading ln7990...n", 1, 2, 3, 4, 5, 6);
  637.     return (&pDrvCtrl->end);
  639. errorExit:
  640.     if (pDrvCtrl != NULL)
  641. free ((char *)pDrvCtrl);
  643.     return NULL;
  644.     }
  646. /*******************************************************************************
  647. *
  648. * ln7990InitParse - parse the initialization string
  649. *
  650. * Parse the input string.  Fill in values in the driver control structure.
  651. * The initialization string format is:
  652. * <unit>:<csrAdr>:<rapAdr>:<vecnum>:<intLvl>:<memAdrs>:<memSize>:<memWidth>:
  653. * <offset>:<csr3B>
  654. *
  655. * .IP <unit>
  656. * Device unit number, a small integer.
  657. * .IP <csrAdr>
  658. * Address of CSR0 register.
  659. * .IP <rapAdr>
  660. * Address of RAP register.
  661. * .IP <vecNum>
  662. * Interrupt vector number (used with sysIntConnect() ).
  663. * .IP <intLvl>
  664. * Interrupt level.
  665. * .IP <memAdrs>
  666. * Memory pool address or NONE.
  667. * .IP <memSize>
  668. * Memory pool size or zero.
  669. * .IP <memWidth>
  670. * Memory system size, 1, 2, or 4 bytes (optional).
  671. * .IP <offset>
  672. * Memory offset for alignment.
  673. * .IP <csr3B>
  674. * CSR register 3B control value, normally 0x4 or 0x7.
  675. *
  676. * RETURNS: OK, or ERROR if any arguments are invalid.
  677. */
  679. LOCAL STATUS ln7990InitParse
  680.     (
  681.     LN7990END_DEVICE * pDrvCtrl,
  682.     char * initString
  683.     )
  684.     {
  685.     char * tok;
  686.     char * pHolder = NULL;
  687.     long address;
  688.     
  689.     /* Parse the initString */
  691.     /* Unit number. */
  693.     tok = strtok_r (initString, ":", &pHolder);
  694.     if (tok == NULL)
  695. return ERROR;
  696.     pDrvCtrl->unit = atoi (tok);
  698.     /* CSR address. */
  699.     
  700.     tok = strtok_r (NULL, ":", &pHolder);
  701.     if (tok == NULL)
  702. return ERROR;
  703.     address = strtoul (tok, NULL, 16);
  704.     pDrvCtrl->pCsr = (UINT16 *)address;
  706.     /* RAP address. */
  708.     tok = strtok_r (NULL, ":", &pHolder);
  709.     if (tok == NULL)
  710. return ERROR;
  711.     address = strtoul (tok, NULL, 16);
  712.     pDrvCtrl->pRap = (UINT16 *)address;
  714.     /* Interrupt vector. */
  716.     tok = strtok_r (NULL, ":", &pHolder);
  717.     if (tok == NULL)
  718. return ERROR;
  719.     pDrvCtrl->ivec = atoi (tok);
  721.     /* Interrupt level. */
  722.     tok = strtok_r (NULL, ":", &pHolder);
  723.     if (tok == NULL)
  724. return ERROR;
  725.     pDrvCtrl->ilevel = atoi (tok);
  727.     /* Caller supplied memory address. */
  728.     tok = strtok_r (NULL, ":", &pHolder);
  729.     if (tok == NULL)
  730. return ERROR;
  731.     pDrvCtrl->memAdrs = (char *)strtoul (tok, NULL, 16);
  733.     /* Caller supplied memory size. */
  735.     tok = strtok_r (NULL, ":", &pHolder);
  736.     if (tok == NULL)
  737. return ERROR;
  738.     pDrvCtrl->memSize = strtoul (tok, NULL, 16);
  740.     /* Caller supplied memory width. */
  742.     tok = strtok_r (NULL, ":", &pHolder);
  743.     if (tok == NULL)
  744. return ERROR;
  745.     pDrvCtrl->memWidth = atoi (tok);
  747.     /* Caller supplied alignment offset. */
  748.     tok = strtok_r (NULL, ":", &pHolder);
  749.     if (tok == NULL)
  750. return ERROR;
  751.     pDrvCtrl->offset = atoi (tok);
  753.     /* Do we use csr3B? */
  755.     tok = strtok_r (NULL, ":", &pHolder);
  756.     if (tok == NULL)
  757. return ERROR;
  758.     pDrvCtrl->csr3B = atoi (tok);
  760.     DRV_LOG (DRV_DEBUG_LOAD, "Processed all arugmentsn", 1, 2, 3, 4, 5, 6);
  762.     return OK;
  763.     }
  765. /*******************************************************************************
  766. *
  767. * ln7990InitMem - initialize memory for Lance chip
  768. *
  769. * Using data in the control structure, setup and initialize the memory
  770. * areas needed.  If the memory address is not already specified, then allocate
  771. * cache safe memory.
  772. *
  773. * RETURNS: OK or ERROR.
  774. */
  776. LOCAL STATUS ln7990InitMem
  777.     (
  778.     LN7990END_DEVICE * pDrvCtrl /* device to be initialized */
  779.     )
  780.     {
  781.     UINT sz;            /* temporary size holder */
  782.     int  ix;
  783.     ln_rmd *  pRmd;
  784.     void *  pTemp;
  785.     char*  pTempBuf;
  787.     /***** Establish size of shared memory region we require *****/
  789.     if ((int) pDrvCtrl->memAdrs != NONE)  /* specified memory pool */
  790.         {
  791.         /*
  792.          * With a specified memory pool we want to maximize
  793.          * lnRsize and lnTsize
  794.          */
  796.         sz = (pDrvCtrl->memSize - (RMD_SIZ + TMD_SIZ + sizeof (ln_ib)))
  797.                / ((2 * LN_BUFSIZ) + RMD_SIZ + TMD_SIZ);
  799.         sz >>= 1;               /* adjust for roundoff */
  801.         for (lnRsize = 0; sz != 0; lnRsize++, sz >>= 1)
  802.             ;
  804.         lnTsize = lnRsize;      /* lnTsize = lnRsize for convenience */
  805.         }
  807.     /* limit ring sizes to reasonable values */
  809.     lnRsize = max (lnRsize, 2); /* 4 Rx buffers is reasonable min */
  810.     lnRsize = min (lnRsize, 7); /* 128 Rx buffers is max for chip */
  811.     lnTsize = max (lnTsize, 2); /* 4 Tx buffers is reasonable min */
  812.     lnTsize = min (lnTsize, 7); /* 128 Tx buffers is max for chip */
  814.     /* Add it all up */
  816.     sz = (((1 << lnRsize) + 1) * RMD_SIZ) +
  817.         (((1 << lnTsize) + 1) * TMD_SIZ) +  IB_SIZ + 28;
  820.     /***** Establish a region of shared memory *****/
  822.     /* OK. We now know how much shared memory we need.  If the caller
  823.      * provides a specific memory region, we check to see if the provided
  824.      * region is large enough for our needs.  If the caller did not
  825.      * provide a specific region, then we attempt to allocate the memory
  826.      * from the system, using the cache aware allocation system call.
  827.      */
  829.     switch ((int) pDrvCtrl->memAdrs)
  830.         {
  831.         default :       /* caller provided memory */
  832.             if (pDrvCtrl->memSize < sz)     /* not enough space */
  833.                 {
  834. DRV_LOG (DRV_DEBUG_LOAD, "ln7990: not enough memory providedn"
  835.                          "ln7990: need %ul got %dn",
  836.                          pDrvCtrl->memSize, sz, 3, 4, 5, 6);
  837.                 return (ERROR);
  838.                 }
  840.     /* set the beginning of pool */
  842.             pDrvCtrl->pShMem = pDrvCtrl->memAdrs;
  844.             /* assume pool is cache coherent, copy null structure */
  846.             pDrvCtrl->cacheFuncs = cacheNullFuncs;
  847.     DRV_LOG (DRV_DEBUG_LOAD, "Memory checks outn", 1, 2, 3, 4, 5, 6);
  848.             break;
  850.         case NONE :     /* get our own memory */
  852.             /* Because the structures that are shared between the device
  853.              * and the driver may share cache lines, the possibility exists
  854.              * that the driver could flush a cache line for a structure and
  855.              * wipe out an asynchronous change by the device to a neighboring
  856.              * structure. Therefore, this driver cannot operate with memory
  857.              * that is not write coherent.  We check for the availability of
  858.              * such memory here, and abort if the system did not give us what
  859.              * we need.
  860.              */
  862.             if (!CACHE_DMA_IS_WRITE_COHERENT ())
  863.                 {
  864.                 printf ("ln: device requires cache coherent memoryn");
  865.                 return (ERROR);
  866.                 }
  868.             pDrvCtrl->pShMem = (char *) cacheDmaMalloc (sz);
  870.             if (pDrvCtrl->pShMem == NULL)
  871.                 {
  872.                 printf ("ln: system memory unavailablen");
  873.                 return (ERROR);
  874.                 }
  876.             /* copy the DMA structure */
  878.             pDrvCtrl->cacheFuncs = cacheDmaFuncs;
  880.             break;
  881.         }
  883.     /*                        Turkey Carving
  884.      *                        --------------
  885.      *
  886.      *                          LOW MEMORY
  887.      *
  888.      *             |-------------------------------------|
  889.      *             |       The initialization block      |
  890.      *             |         (sizeof (ln_ib))            |
  891.      *             |-------------------------------------|
  892.      *             |         The Rx descriptors          |
  893.      *             | ((1 << lnRsize) + 1)*sizeof (ln_rmd)|
  894.      *             |-------------------------------------|
  895.      *             |         The Tx descriptors          |
  896.      *             | ((1 << lnTsize) + 1)*sizeof (ln_tmd)|
  897.      *             |-------------------------------------|
  898.      */
  900.     /* align */
  901.     pDrvCtrl->pShMem = (char *) ( ( (int)pDrvCtrl->pShMem + 3) & ~3);
  903.     /* Save some things */
  905.     pDrvCtrl->memBase  = (char *)((ULONG)pDrvCtrl->pShMem & 0xff000000);
  907.     if ((int) pDrvCtrl->memAdrs == NONE)
  908.         pDrvCtrl->flags |= LS_MEM_ALLOC_FLAG;
  910.     /* first let's clear memory */
  912.     bzero ((char *) pDrvCtrl->pShMem, (int) sz); /* HELP: deal with memWidth */
  914.     /* setup Rx memory pointers */
  916.     pDrvCtrl->pRring = (ln_rmd *) ((((int)pDrvCtrl->pShMem + IB_SIZ) + 7) &~7);
  917.     pDrvCtrl->rringLen  = lnRsize;
  918.     pDrvCtrl->rringSize = 1 << lnRsize;
  919.     pDrvCtrl->rmdIndex = 0;
  921.     /* setup Tx memory pointers. */
  923.     pDrvCtrl->pTring = (ln_tmd *) ((int)pDrvCtrl->pRring +
  924. ((1 << lnRsize) + 1) * RMD_SIZ);
  926.     pDrvCtrl->tringSize = 1 << lnTsize;
  927.     pDrvCtrl->tringLen  = lnTsize;
  928.     pDrvCtrl->tmdIndex = 0;
  929.     pDrvCtrl->tmdIndexC = 0;
  931.     /* Set up the structures to allow us to free data after sending it. */
  932.     
  933.     for (ix = 0; ix < pDrvCtrl->rringSize; ix++)
  934.         {
  935.         pDrvCtrl->freeRtn[ix] = NULL;
  936.         pDrvCtrl->freeData[ix].arg1 = NULL;
  937.         pDrvCtrl->freeData[ix].arg2 = NULL;
  938.         }
  940.     /*
  941.      * Allocate receive buffers from our own private pool.
  942.      */
  944.     if ((pDrvCtrl->end.pNetPool = malloc (sizeof(NET_POOL))) == NULL)
  945.         return (ERROR);
  947.     lnMclConfig.mBlkNum = pDrvCtrl->rringSize * 2;
  948.     lnClDescTbl[0].clNum = pDrvCtrl->rringSize *2;
  949.     lnMclConfig.clBlkNum = lnClDescTbl[0].clNum;
  951.     lnMclConfig.memSize = (lnMclConfig.mBlkNum * (MSIZE + sizeof (long))) +
  952.                           (lnMclConfig.clBlkNum * (CL_BLK_SZ + sizeof(long)));
  954.     if ((lnMclConfig.memArea = (char *) memalign (sizeof(long),
  955.                                                   lnMclConfig.memSize))
  956.         == NULL)
  957.         return (ERROR);
  958.     
  960.     lnClDescTbl[0].clNum = pDrvCtrl->rringSize *2;
  961.     
  962.     lnClDescTbl[0].memSize = (lnClDescTbl[0].clNum * (LN_BUFSIZ + 8))
  963.         + sizeof(int);
  965.     if ((int) pDrvCtrl->memAdrs != NONE) /* Do we hand over our own memory? */
  966.         {
  967.         lnClDescTbl[0].memArea = 
  968.                 (char *)(pDrvCtrl->pTring + (((1 << lnTsize) + 1) * TMD_SIZ));
  969.         }
  970.     else
  971.         {
  972.         lnClDescTbl[0].memArea =
  973.             (char *) cacheDmaMalloc (lnClDescTbl[0].memSize);
  974.         if (lnClDescTbl[0].memArea == NULL)
  975.             {
  976.             DRV_LOG(DRV_DEBUG_LOAD,
  977.                     "system memory unavailablen", 1, 2, 3, 4, 5, 6);
  978.             return (ERROR);
  979.             }
  980.         }
  981.     
  982.     if (netPoolInit(pDrvCtrl->end.pNetPool, &lnMclConfig,
  983.                     &lnClDescTbl[0], lnClDescTblNumEnt, NULL) == ERROR)
  984.         {
  985.         DRV_LOG (DRV_DEBUG_LOAD, "Could not init bufferingn",
  986.                  1, 2, 3, 4, 5, 6);
  987.         return (ERROR);
  988.         }
  989. #ifdef DRV_DEBUG
  990.     ln7990NetPool = *pDrvCtrl->end.pNetPool;
  991. #endif
  992.     /* Store the cluster pool id as others need it later. */
  993.     pDrvCtrl->pClPoolId = clPoolIdGet(pDrvCtrl->end.pNetPool,
  994.                                       LN_BUFSIZ, FALSE);
  996.     pRmd = pDrvCtrl->pRring;
  997.     for (ix = 0; ix < pDrvCtrl->rringSize; ix++, pRmd++)
  998.         {
  999.         if ((pTempBuf = (char *)netClusterGet(pDrvCtrl->end.pNetPool,
  1000.                                               pDrvCtrl->pClPoolId))
  1001.             == NULL)
  1002.             {
  1003.             DRV_LOG (DRV_DEBUG_LOAD, "Could not get a buffern",
  1004.                      1, 2, 3, 4, 5, 6);
  1005.             return (ERROR);
  1006.             }
  1007.         pTempBuf += pDrvCtrl->offset;
  1008.         LN_RMD_BUF_TO_ADDR (pRmd, pTemp, pTempBuf);
  1009.         }
  1011.     return OK;
  1012.     }
  1014. /*******************************************************************************
  1015. *
  1016. * ln7990Start - start the device
  1017. *
  1018. * This function calls BSP functions to connect interrupts and start the
  1019. * device running in interrupt mode.
  1020. *
  1021. * RETURNS: OK or ERROR
  1022. *
  1023. */
  1025. LOCAL STATUS ln7990Start
  1026.     (
  1027.     LN7990END_DEVICE *pDrvCtrl
  1028.     )
  1029.     {
  1030.     STATUS result;
  1032.     pDrvCtrl->txCleaning = FALSE;
  1033.     pDrvCtrl->txBlocked = FALSE;
  1034.     SYS_INT_CONNECT (pDrvCtrl, ln7990Int, (int)pDrvCtrl, &result);
  1035.     if (result == ERROR)
  1036. return ERROR;
  1038.     DRV_LOG (DRV_DEBUG_LOAD, "Interrupt connected.n", 1, 2, 3, 4, 5, 6);
  1040.     SYS_INT_ENABLE (pDrvCtrl);
  1042.     DRV_LOG (DRV_DEBUG_LOAD, "interrupt enabled.n", 1, 2, 3, 4, 5, 6);
  1044.     return (OK);
  1045.     }
  1047. /*******************************************************************************
  1048. *
  1049. * ln7990HandleError - handle controller interrupt errors
  1050. *
  1051. * This routine is called to process controller errors at a task level that 
  1052. * were detecected in interrupt context.
  1053. *
  1054. * RETURNS: N/A.
  1055. */
  1057. LOCAL void ln7990HandleError
  1058.     (
  1059.     LN7990END_DEVICE  *pDrvCtrl
  1060.     )
  1061.     {
  1062.     u_short stat;
  1064.     pDrvCtrl->errorHandling = FALSE;
  1065.     stat = pDrvCtrl->errorStat;
  1066.     pDrvCtrl->errorStat &= ~stat;
  1067.     
  1068.     if (stat & lncsr_MERR)
  1069. {
  1070. pDrvCtrl->lastError.errCode = END_ERR_RESET;
  1071. pDrvCtrl->lastError.pMesg = "Memory error.";
  1072. muxError (&pDrvCtrl->end, &pDrvCtrl->lastError);
  1073. }
  1075.     if (stat & lncsr_BABL)
  1076. {
  1077. pDrvCtrl->lastError.errCode = END_ERR_WARN;
  1078. pDrvCtrl->lastError.pMesg = "Babbling";
  1079. muxError (&pDrvCtrl->end, &pDrvCtrl->lastError);
  1080. }
  1082.     if (stat & lncsr_MISS)
  1083. {
  1084. pDrvCtrl->lastError.errCode = END_ERR_WARN;
  1085. pDrvCtrl->lastError.pMesg = "Missing";
  1086. muxError (&pDrvCtrl->end, &pDrvCtrl->lastError);
  1087. }
  1088.     
  1089.     return;
  1090.     }
  1092.     
  1094. /*******************************************************************************
  1095. *
  1096. * ln7990Int - handle controller interrupt
  1097. *
  1098. * This routine is called at interrupt level in response to an interrupt from
  1099. * the controller.
  1100. *
  1101. * RETURNS: N/A.
  1102. */
  1104. LOCAL void ln7990Int
  1105.     (
  1106.     LN7990END_DEVICE  *pDrvCtrl
  1107.     )
  1108.     {
  1109.     u_short        stat;
  1110.     ln_rmd         *pRmd;
  1112.    /* Read the device status register */
  1114.     stat = ln7990Csr0Read (pDrvCtrl);
  1116.     DRV_LOG (DRV_DEBUG_INT, "i=0x%x:n", stat, 2, 3, 4, 5, 6);
  1118.     /* If false interrupt, return. */
  1120.     if (!(stat & lncsr_INTR))
  1121. {
  1122. DRV_LOG (DRV_DEBUG_INT, "False interrupt.n", 1, 2, 3, 4, 5, 6);
  1123.         return;
  1124. }
  1126.     /*
  1127.      * enable interrupts, clear receive and/or transmit interrupts,
  1128.      * and clear any errors that may be set.
  1129.      */
  1130.     ln7990CsrWrite (pDrvCtrl, 0, ((stat &
  1131.     (lncsr_BABL|lncsr_CERR|lncsr_MISS|lncsr_MERR|
  1132.      lncsr_RINT|lncsr_TINT|lncsr_IDON)) | lncsr_INEA));
  1134.     /* Check for errors */
  1136.     if (stat & (lncsr_BABL | lncsr_MISS | lncsr_MERR))
  1137.         {
  1138.         ++pDrvCtrl->csr0Errs;
  1140. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1142. if (stat & lncsr_BABL)
  1143.     {
  1144.     pDrvCtrl->errorStat |= lncsr_BABL;
  1145.     if (!pDrvCtrl->errorHandling)
  1146. {
  1147. if (netJobAdd ((FUNCPTR) ln7990HandleError, (int) pDrvCtrl
  1148.        , 2, 3, 4, 5) == OK)
  1149.     {
  1150.     pDrvCtrl->errorHandling = TRUE;
  1151.     }
  1152. }
  1153.     DRV_LOG (DRV_DEBUG_INT, "Babblingn", 1, 2, 3, 4, 5, 6);
  1154.     }
  1155. if (stat & lncsr_MISS)
  1156.     {
  1157.     pDrvCtrl->errorStat |= lncsr_MISS;
  1158.     if (!pDrvCtrl->errorHandling)
  1159. {
  1160. if (netJobAdd ((FUNCPTR) ln7990HandleError, (int) pDrvCtrl
  1161.        , 2, 3, 4, 5) == OK)
  1162.     {
  1163.     pDrvCtrl->errorHandling = TRUE;
  1164.     }
  1165. }
  1166.     DRV_LOG (DRV_DEBUG_INT, "Missingn", 1, 2, 3, 4, 5, 6);
  1167.     }
  1168.         
  1169. /* restart chip on fatal error */
  1171.         if (stat & lncsr_MERR)        /* memory error */
  1172.             {
  1173.     pDrvCtrl->errorStat |= lncsr_MERR;
  1174.     if (!pDrvCtrl->errorHandling)
  1175. {
  1176. if (netJobAdd ((FUNCPTR) ln7990HandleError, (int) pDrvCtrl
  1177.        , 2, 3, 4, 5) == OK)
  1178.     {
  1179.     pDrvCtrl->errorHandling = TRUE;
  1180.     }
  1181. }
  1182.     DRV_LOG (DRV_DEBUG_INT, "Memory error, restarting.n",
  1183.                      1, 2, 3, 4, 5, 6);
  1184.             END_FLAGS_CLR (&pDrvCtrl->end, (IFF_UP | IFF_RUNNING));
  1186.     /* Only reset device if Restart will occur */
  1188.     if (netJobAdd ((FUNCPTR) ln7990Restart
  1189.    , (int) pDrvCtrl, 2, 3, 4, 5) == OK)
  1190. {
  1191. ln7990Reset (pDrvCtrl);
  1192. }
  1193.     return;
  1194.     }
  1195.         }
  1197.     /* Have netTask handle any input packets */
  1199.     pRmd =  pDrvCtrl->pRring + pDrvCtrl->rmdIndex;
  1200.     LN_CACHE_INVALIDATE (pRmd, RMD_SIZ);
  1202.     if (((stat & lncsr_RINT) && (stat & lncsr_RXON)) ||
  1203. LN_RMD_OWNED (pRmd) == 0)
  1204.         {
  1205.         DRV_LOG (DRV_DEBUG_INT, "r ", 1, 2, 3, 4, 5, 6);
  1206.         if (!(pDrvCtrl->flags & LS_RCV_HANDLING_FLAG))
  1207.             {
  1208.             if (netJobAdd ((FUNCPTR)ln7990HandleRecvInt, (int)pDrvCtrl,
  1209.                               0,0,0,0) == OK)
  1210. {
  1211. pDrvCtrl->flags |= LS_RCV_HANDLING_FLAG;
  1212. }
  1213.     }
  1214.         }
  1216.     /*
  1217.      * Did LANCE update any of the TMD's?
  1218.      * If not then don't bother continuing with transmitter stuff
  1219.      */
  1221.     if (!(stat & lncsr_TINT))
  1222. {
  1223.         return;
  1224. }
  1227.     DRV_LOG (DRV_DEBUG_INT, "t ", 1, 2, 3, 4, 5, 6);
  1228.     
  1229.     if (!pDrvCtrl->txCleaning)
  1230.         {
  1231.         pDrvCtrl->txCleaning = TRUE;
  1232.         netJobAdd ((FUNCPTR)ln7990ScrubTRing, (int) pDrvCtrl, 0, 0, 0, 0);
  1233.         }
  1234.     if (pDrvCtrl->txBlocked) /* cause a restart */
  1235.         {
  1236.         netJobAdd ((FUNCPTR)muxTxRestart, (int) &pDrvCtrl->end, 0, 0, 0, 0);
  1237.         pDrvCtrl->txBlocked = FALSE;
  1238.         }
  1240.     /* Flush the write pipe */
  1242.     CACHE_PIPE_FLUSH ();
  1243.     }
  1246. /*******************************************************************************
  1247. *
  1248. * ln7990HandleRecvInt - task level interrupt service for input packets
  1249. *
  1250. * This routine is called at task level indirectly by the interrupt
  1251. * service routine to do any message received processing.
  1252. *
  1253. * RETURNS: N/A.
  1254. */
  1256. LOCAL void ln7990HandleRecvInt
  1257.     (
  1258.     LN7990END_DEVICE *pDrvCtrl
  1259.     )
  1260.     {
  1261.     ln_rmd *pRmd;
  1263.     do
  1264.         {
  1265.         pDrvCtrl->flags |= LS_RCV_HANDLING_FLAG;
  1267.         while ((pRmd = ln7990FullRMDGet (pDrvCtrl)) != NULL)
  1268.             ln7990Recv (pDrvCtrl, pRmd);
  1270.         /*
  1271.          * There is a RACE right here.  The ISR could add a receive packet
  1272.          * and check the boolean below, and decide to exit.  Thus the
  1273.          * packet could be dropped if we don't double check before we
  1274.          * return.
  1275.          */
  1277.         pDrvCtrl->flags &= ~LS_RCV_HANDLING_FLAG;
  1278.         }
  1279.     while (ln7990FullRMDGet (pDrvCtrl) != NULL);
  1280.     /* this double check solves the RACE */
  1282.     }
  1284. /*******************************************************************************
  1285. *
  1286. * ln7990FullRMDGet - get next received message RMD
  1287. *
  1288. * Get next recevied message descriptor.  Returns NULL if none are
  1289. * ready.
  1290. *
  1291. * RETURNS: ptr to next Rx desc to process, or NULL if none ready.
  1292. */
  1294. LOCAL ln_rmd *ln7990FullRMDGet
  1295.     (
  1296.     LN7990END_DEVICE  *pDrvCtrl
  1297.     )
  1298.     {
  1299.     ln_rmd   *pRmd;
  1301.     pRmd = pDrvCtrl->pRring + pDrvCtrl->rmdIndex;  /* form ptr to Rx desc */
  1303.     LN_CACHE_INVALIDATE (pRmd, RMD_SIZ);
  1305.     if (LN_RMD_OWNED (pRmd) == 0)
  1306.         return (pRmd);
  1307.     else
  1308.         return ((ln_rmd *) NULL);
  1309.     }
  1312. /*******************************************************************************
  1313. *
  1314. * ln7990Recv - process the next incoming packet
  1315. *
  1316. * Handle one incoming packet.  The packet is checked for errors.
  1317. *
  1318. * RETURNS: N/A.
  1319. */
  1321. LOCAL STATUS ln7990Recv
  1322.     (
  1323.     LN7990END_DEVICE *pDrvCtrl,
  1324.     ln_rmd   *pRmd
  1325.     )
  1326.     {
  1327.     int         len;
  1328.     u_long phys;
  1329.     M_BLK_ID  pMblk;
  1330.     char*       pCluster;
  1331.     char*       pNewCluster;
  1332.     char*       pTemp;
  1333.     CL_BLK_ID pClBlk;
  1334.     /* Packet must be checked for errors. */
  1336.     /* If error flag */
  1337.     /* OR if packet is not completely in one buffer */
  1338.     if  (LN_RMD_ERR (pRmd))
  1339.         {
  1340. DRV_LOG (DRV_DEBUG_RX, "RMD error!n", 1, 2, 3, 4, 5, 6);
  1341. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1342. goto cleanRXD;
  1343.         }
  1345.     /* If we cannot get a buffer to loan then bail out. */
  1346.     pNewCluster = netClusterGet(pDrvCtrl->end.pNetPool, pDrvCtrl->pClPoolId);
  1348.     if (pNewCluster == NULL)
  1349.         {
  1350. DRV_LOG (DRV_DEBUG_RX, "Cannot loan!n", 1, 2, 3, 4, 5, 6);
  1351. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1352. goto cleanRXD;
  1353.         }
  1355.     if ((pClBlk = netClBlkGet (pDrvCtrl->end.pNetPool, M_DONTWAIT)) == NULL)
  1356.         {
  1357.         netClFree (pDrvCtrl->end.pNetPool, pNewCluster);
  1358. DRV_LOG (DRV_DEBUG_RX, "Out of Cluster Blocks!n", 1, 2, 3, 4, 5, 6);
  1359. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1360. goto cleanRXD;
  1361.         }
  1362.     
  1363.     /*
  1364.      * OK we've got a spare, let's get an M_BLK_ID and marry it to the
  1365.      * one in the ring.
  1366.      */
  1367.     if ((pMblk = mBlkGet(pDrvCtrl->end.pNetPool, M_DONTWAIT, MT_DATA)) == NULL)
  1368.         {
  1369.         netClBlkFree (pDrvCtrl->end.pNetPool, pClBlk); 
  1370.         netClFree (pDrvCtrl->end.pNetPool, pNewCluster);
  1371. DRV_LOG (DRV_DEBUG_RX, "Out of M Blocks!n", 1, 2, 3, 4, 5, 6);
  1372. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1373. goto cleanRXD;
  1374.         }
  1377.     END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_UCAST, +1);
  1378.     len = LN_PKT_LEN_GET (pRmd);            /* get packet length */
  1380.     /* Get pointer to packet */
  1382.     LN_RMD_TO_ADDR (pDrvCtrl->memBase , pRmd, phys);
  1384.     pCluster = LN_CACHE_PHYS_TO_VIRT (phys);
  1386.     pCluster -= pDrvCtrl->offset;
  1387.     
  1388.     /* Join the cluster to the MBlock */
  1389.     netClBlkJoin (pClBlk, pCluster, len, NULL, 0, 0, 0);
  1390.     netMblkClJoin (pMblk, pClBlk);
  1392.     /* make the packet data coherent */
  1393.     LN_CACHE_INVALIDATE (pMblk->mBlkHdr.mData, len);
  1395.     pMblk->mBlkHdr.mData += pDrvCtrl->offset;
  1396.     pMblk->mBlkHdr.mLen = len;
  1397.     pMblk->mBlkHdr.mFlags |= M_PKTHDR;
  1398.     pMblk->mBlkPktHdr.len = len;
  1401.     DRV_LOG (DRV_DEBUG_RX, "Calling upper layer!n", 1, 2, 3, 4, 5, 6);
  1403.     /* Deal with memory alignment. */
  1405.     pNewCluster += pDrvCtrl->offset;
  1407.     LN_RMD_BUF_TO_ADDR (pRmd, pTemp, pNewCluster);
  1409.     LN_CLEAN_RXD (pRmd);
  1411.     /* Flush the write pipe */
  1413.     CACHE_PIPE_FLUSH ();
  1415.     /* Advance our management index */
  1417.     pDrvCtrl->rmdIndex = (pDrvCtrl->rmdIndex + 1) & (pDrvCtrl->rringSize - 1);
  1419.     /* Call the upper layer's receive routine. */
  1421.     END_RCV_RTN_CALL(&pDrvCtrl->end, pMblk);
  1423.     return (OK);
  1425. cleanRXD:
  1427.     LN_CLEAN_RXD (pRmd);
  1429.     /* Flush the write pipe */
  1431.     CACHE_PIPE_FLUSH ();
  1433.     /* Advance our management index */
  1435.     pDrvCtrl->rmdIndex = (pDrvCtrl->rmdIndex + 1) & (pDrvCtrl->rringSize - 1);
  1437.     return (OK);
  1438.     }
  1440. /*******************************************************************************
  1441. *
  1442. * ln7990Send - the driver send routine
  1443. *
  1444. * This routine takes a M_BLK_ID sends off the data in the M_BLK_ID.
  1445. * The buffer must already have the addressing information properly installed
  1446. * in it.  This is done by a higher layer.  The last arguments are a free
  1447. * routine to be called when the device is done with the buffer and a pointer
  1448. * to the argument to pass to the free routine.  
  1449. *
  1450. * RETURNS: OK or ERROR.
  1451. */
  1453. LOCAL STATUS ln7990Send
  1454.     (
  1455.     LN7990END_DEVICE *pDrvCtrl, /* device ptr */
  1456.     M_BLK_ID pMblk /* data to send */
  1457.     )
  1458.     {
  1459.     ln_tmd* pTmd;
  1460.     int         len = 0;
  1461.     void*       pTemp;
  1462.     char*       pBuf;
  1463.     char*       pOrig;
  1464.     int         s;
  1465.     /*
  1466.      * Obtain exclusive access to transmitter.  This is necessary because
  1467.      * we might have more than one stack transmitting at once.
  1468.      */
  1470.     if (!(pDrvCtrl->flags & LS_POLLING))
  1471. END_TX_SEM_TAKE (&pDrvCtrl->end, WAIT_FOREVER);
  1473.     /*
  1474.      * Here we handle both simple and vector transmit in the same place.
  1475.      *
  1476.      */
  1478. #if 0
  1479.     {
  1480.     M_BLK_ID    pChunk;
  1481.     int         count;
  1483.     pChunk = pMblk;
  1484.     for (count = 0; pChunk != NULL && (pChunk->mBlkHdr.mData != 0);
  1485.          pChunk = pChunk->m_next, count++)
  1486.         {
  1488.         if (pChunk->mBlkHdr.mLen <= 0)
  1489.             {
  1490.             netMblkClFree(pChunk);
  1491.             continue;
  1492.             }
  1494.         pTmd = pDrvCtrl->pTring + pDrvCtrl->tmdIndex;
  1495.         
  1496.         LN_CACHE_INVALIDATE (pTmd, TMD_SIZ);
  1497.         
  1498.         if ((pTmd->tbuf_stat & lntmd1_OWN) ||
  1499.             (((pDrvCtrl->tmdIndex + 1) & (pDrvCtrl->tringSize - 1))
  1500.              == pDrvCtrl->tmdIndexC))
  1501.             {
  1502.             if (!(pDrvCtrl->flags & LS_POLLING))
  1503.                 END_TX_SEM_GIVE (&pDrvCtrl->end);
  1504.             /* Are we still on the first chunk? */
  1505.             if (count == 0)
  1506.                 netMblkClChainFree(pMblk);
  1507.             else /* Have to iteratively clean up. */
  1508.                 {
  1509.                 
  1510.                 }
  1511.             DRV_LOG (DRV_DEBUG_TX, "Out of TMDs!n", 1, 2, 3, 4, 5, 6);
  1512.             return (END_ERR_BLOCK);
  1513.             }
  1514.         len = pChunk->mBlkHdr.mLen;
  1515.         LN_TMD_BUF_TO_ADDR(pTmd, pTemp, pChunk->mBlkHdr.mData);
  1516.         pTmd->tbuf_err = 0;         /* clear buffer error status */
  1517.         pTmd->tbuf_bcnt = -len;     /* negative message byte count */
  1518.         
  1519.         if (count == 0)
  1520.             pTmd->tbuf_stat |=  lntmd1_STP;
  1521.         
  1522.         pTmd->tbuf_stat |= lntmd1_OWN;
  1524.         pDrvCtrl->freeRtn[pDrvCtrl->tmdIndex] = (FUNCPTR)netMblkClFree;
  1525.         pDrvCtrl->freeData[pDrvCtrl->tmdIndex].arg1 = pChunk;
  1526.         pDrvCtrl->freeData[pDrvCtrl->tmdIndex].arg2 = NULL;
  1528.         /* Advance our management index */
  1529.         pDrvCtrl->tmdIndex = (pDrvCtrl->tmdIndex + 1) & (pDrvCtrl->tringSize - 1);
  1530.         
  1531.         }
  1532.     
  1533.     /* On the final tmd we set the END bit as well as OWN. */
  1534.     pTmd->tbuf_stat |= lntmd1_OWN | lntmd1_ENP;
  1536.     /* If we only have one TMD for the packet then make sure of size. */
  1537.     if (count == 1)
  1538.         {
  1539.         len = max (len, ETHERSMALL);
  1540.         pTmd->tbuf_bcnt = -len;
  1541.         }
  1542.     
  1543.     }
  1544. #else
  1545.     pTmd = pDrvCtrl->pTring + pDrvCtrl->tmdIndex;
  1546.     
  1547.     LN_CACHE_INVALIDATE (pTmd, TMD_SIZ);
  1548.     
  1549.     if ((pTmd->tbuf_stat & lntmd1_OWN) ||
  1550.         (((pDrvCtrl->tmdIndex + 1) & (pDrvCtrl->tringSize - 1))
  1551.          == pDrvCtrl->tmdIndexC))
  1552.         {
  1553.         if (!(pDrvCtrl->flags & LS_POLLING))
  1554.             END_TX_SEM_GIVE (&pDrvCtrl->end);
  1555.         /* Are we still on the first chunk? */
  1556.         DRV_LOG (DRV_DEBUG_TX, "Out of TMDs!n", 1, 2, 3, 4, 5, 6);
  1557.         s = intLock();
  1558. pDrvCtrl->txBlocked = TRUE;
  1559.         intUnlock(s);
  1560.         return (END_ERR_BLOCK);
  1561.         }
  1563.     DRV_LOG (DRV_DEBUG_TX, "before cluster get %d %dn",
  1564.              (int) pDrvCtrl->end.pNetPool,
  1565.              (int) pDrvCtrl->pClPoolId, 3, 4, 5, 6);
  1566.     pOrig = pBuf = netClusterGet(pDrvCtrl->end.pNetPool, pDrvCtrl->pClPoolId);
  1567.     DRV_LOG (DRV_DEBUG_TX, "after cluster getn", 1, 2, 3, 4, 5, 6);
  1569.     if (pBuf == NULL)
  1570.         {
  1571. if (!(pDrvCtrl->flags & LS_POLLING))
  1572.     END_TX_SEM_GIVE (&pDrvCtrl->end);
  1573.         netMblkClChainFree(pMblk);
  1574.         return (ERROR);
  1575.         }
  1577.     pBuf += pDrvCtrl->offset;
  1578.     
  1579.     len = netMblkToBufCopy (pMblk, pBuf, NULL);
  1580.     netMblkClChainFree(pMblk); 
  1581.     LN_TMD_BUF_TO_ADDR(pTmd, pTemp, pBuf);
  1582.     len = max (len, ETHERSMALL);
  1583.     pTmd->tbuf_err = 0;         /* clear buffer error status */
  1584.     pTmd->tbuf_bcnt = -len;     /* negative message byte count */
  1585.         
  1586.     pTmd->tbuf_stat |=  lntmd1_STP | lntmd1_OWN | lntmd1_ENP;
  1587.     
  1588.     pDrvCtrl->freeRtn[pDrvCtrl->tmdIndex] = (FUNCPTR)netClFree;
  1589.     pDrvCtrl->freeData[pDrvCtrl->tmdIndex].arg1 = pDrvCtrl->end.pNetPool;
  1590.     pDrvCtrl->freeData[pDrvCtrl->tmdIndex].arg2 = pOrig;
  1592.     /* Advance our management index */
  1593.     pDrvCtrl->tmdIndex = (pDrvCtrl->tmdIndex + 1) & (pDrvCtrl->tringSize - 1);
  1594. #endif
  1595.     /* Flush the write pipe */
  1596.     
  1597.     CACHE_PIPE_FLUSH ();
  1598.     
  1599.     if (lnKickStartTx)
  1600.         {
  1601.         if (!(pDrvCtrl->flags & LS_POLLING))
  1602.     ln7990CsrWrite (pDrvCtrl, 0, (lncsr_INEA | lncsr_TDMD));
  1603. else
  1604.     ln7990CsrWrite (pDrvCtrl, 0, lncsr_TDMD);
  1605. }
  1606.     
  1607.     if (!(pDrvCtrl->flags & LS_POLLING))
  1608. END_TX_SEM_GIVE (&pDrvCtrl->end);
  1609.     
  1610.     /* Bump the statistic counter. */
  1611.     END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_UCAST, +1);
  1613.     return (OK);
  1615.     }
  1617. /*******************************************************************************
  1618. *
  1619. * ln7990Ioctl - the driver I/O control routine
  1620. *
  1621. * Process an ioctl request.
  1622. */
  1624. LOCAL int ln7990Ioctl
  1625.     (
  1626.     LN7990END_DEVICE *pDrvCtrl,
  1627.     int cmd,
  1628.     caddr_t data
  1629.     )
  1630.     {
  1631.     int error = 0;
  1632.     long value;
  1634.     switch ((UINT)cmd)
  1635.         {
  1636.         case EIOCSADDR:
  1637.     if (data == NULL)
  1638. return (EINVAL);
  1639.             bcopy ((char *)data, (char *)END_HADDR(&pDrvCtrl->end),
  1640.    END_HADDR_LEN(&pDrvCtrl->end));
  1641.             break;
  1643.         case EIOCGADDR:
  1644.     if (data == NULL)
  1645. return (EINVAL);
  1646.             bcopy ((char *)END_HADDR(&pDrvCtrl->end), (char *)data,
  1647.     END_HADDR_LEN(&pDrvCtrl->end));
  1648.             break;
  1650.         case EIOCSFLAGS:
  1651.     value = (long)data;
  1652.     if (value < 0)
  1653. {
  1654. value = -value;
  1655. value--; /* HELP: WHY ??? */
  1656. END_FLAGS_CLR (&pDrvCtrl->end, value);
  1657. }
  1658.     else
  1659. {
  1660. END_FLAGS_SET (&pDrvCtrl->end, value);
  1661. }
  1662.     ln7990Config (pDrvCtrl);
  1663.             break;
  1664.         case EIOCGFLAGS:
  1665.     *(int *)data = END_FLAGS_GET(&pDrvCtrl->end);
  1666.             break;
  1668. case EIOCPOLLSTART:
  1669.     error = ln7990PollStart (pDrvCtrl);
  1670.     break;
  1672. case EIOCPOLLSTOP:
  1673.     error = ln7990PollStop (pDrvCtrl);
  1674.     break;
  1676.         case EIOCGMIB2:
  1677.             if (data == NULL)
  1678.                 return (EINVAL);
  1679.             bcopy((char *)&pDrvCtrl->end.mib2Tbl, (char *)data,
  1680.                   sizeof(pDrvCtrl->end.mib2Tbl));
  1681.             break;
  1682.         case EIOCGFBUF:
  1683.             if (data == NULL)
  1684.                 return (EINVAL);
  1685.             *(int *)data = LN_MIN_FBUF;
  1686.             break;
  1687.         case EIOCGMWIDTH:
  1688.             if (data == NULL)
  1689.                 return (EINVAL);
  1690.             *(int *)data = pDrvCtrl->memWidth;
  1691.             break;
  1692.         case EIOCGHDRLEN:
  1693.             if (data == NULL)
  1694.                 return (EINVAL);
  1695.             *(int *)data = 14;
  1696.             break;
  1697.         default:
  1698.             error = EINVAL;
  1699.         }
  1700.     return (error);
  1701.     }
  1703. /*******************************************************************************
  1704. *
  1705. * ln7990Reset - hardware reset of chip (stop it)
  1706. */
  1708. LOCAL void ln7990Reset
  1709.     (
  1710.     LN7990END_DEVICE  *pDrvCtrl
  1711.     )
  1712.     {
  1713.     ln7990CsrWrite (pDrvCtrl, 0, lncsr_STOP);
  1714.     }
  1716. /*******************************************************************************
  1717. *
  1718. * ln7990Csr0Read - read CSR 0 register
  1719. *
  1720. * Assumes normal operation, where the RAP register has been left selecting
  1721. * CSR0.
  1722. */
  1724. LOCAL u_short ln7990Csr0Read
  1725.     (
  1726.     LN7990END_DEVICE * pDrvCtrl /* driver control */
  1727.     )
  1728.     {
  1729.     USHORT result;
  1731.     SYS_IN_SHORT (pDrvCtrl, pDrvCtrl->pCsr, &result);
  1733.     return (result); /* get contents of CSR */
  1734.     }
  1736. /*******************************************************************************
  1737. *
  1738. * ln7990CsrWrite - select and write a CSR register
  1739. *
  1740. */
  1742. LOCAL void ln7990CsrWrite
  1743.     (
  1744.     LN7990END_DEVICE * pDrvCtrl, /* driver control */
  1745.     int reg, /* register to select */
  1746.     u_short value /* value to write */
  1747.     )
  1748.     {
  1749.     int level;
  1751.     level = intLock ();
  1752.     SYS_OUT_SHORT (pDrvCtrl, pDrvCtrl->pRap, (u_short)reg);
  1753.     SYS_OUT_SHORT (pDrvCtrl, pDrvCtrl->pCsr, value);
  1754.     intUnlock (level);
  1755.     }
  1757. /*******************************************************************************
  1758. *
  1759. * ln7990RestartSetup - setup memory descriptors and turn on chip
  1760. *
  1761. * Initializes all the shared memory structures and turns on the chip.
  1762. */
  1764. LOCAL STATUS ln7990RestartSetup
  1765.     (
  1766.     LN7990END_DEVICE *pDrvCtrl
  1767.     )
  1768.     {
  1769.     int  rsize;
  1770.     int  tsize;
  1771.     void *  pTemp;
  1773.     /* reset the device */
  1775.     ln7990Reset (pDrvCtrl);
  1777.     /* setup Rx buffer descriptors  */
  1779.     rsize = pDrvCtrl->rringLen;
  1781.     /* 
  1782.      * setup Tx buffer descriptors  - 
  1783.      */
  1785.     tsize = pDrvCtrl->tringLen;
  1787.     /* setup the initialization block */
  1789.     pDrvCtrl->ib = (ln_ib *)pDrvCtrl->pShMem;
  1791.     /* HELP */
  1792.     swab ((char *) END_HADDR(&pDrvCtrl->end), pDrvCtrl->ib->lnIBPadr, 6);
  1794.     CACHE_PIPE_FLUSH ();
  1796.     pTemp = LN_CACHE_VIRT_TO_PHYS (pDrvCtrl->pRring);   /* point to Rx ring */
  1797.     LN_ADDR_TO_IB_RMD (pTemp, pDrvCtrl->ib, rsize);
  1799.     pTemp = LN_CACHE_VIRT_TO_PHYS (pDrvCtrl->pTring);   /* point to Tx ring */
  1800.     LN_ADDR_TO_IB_TMD (pTemp, pDrvCtrl->ib, tsize);
  1802.     DRV_LOG (DRV_DEBUG_LOAD, "Memory setup completen", 1, 2, 3, 4, 5, 6);
  1804.     /* reconfigure the device */
  1806.     ln7990Config (pDrvCtrl);
  1808.     return (OK); 
  1809.     }
  1810.      
  1811. /*******************************************************************************
  1812. *
  1813. * ln7990Restart - restart the device after a fatal error
  1814. *
  1815. * This routine takes care of all the messy details of a restart.  The device
  1816. * is reset and re-initialized.  The driver state is re-synchronized.
  1817. */
  1819. LOCAL void ln7990Restart
  1820.     (
  1821.     LN7990END_DEVICE *pDrvCtrl
  1822.     )
  1823.     {
  1824.     ln7990Reset (pDrvCtrl);
  1826.     ln7990RestartSetup (pDrvCtrl);
  1828.     /* set the flags to indicate readiness */
  1831.     END_OBJ_READY (&pDrvCtrl->end,
  1832.                     IFF_UP | IFF_RUNNING | IFF_NOTRAILERS | IFF_BROADCAST
  1833.                     | IFF_MULTICAST);
  1834.     }
  1836. /******************************************************************************
  1837. *
  1838. * ln7990Config - reconfigure the interface under us.
  1839. *
  1840. * Reconfigure the interface setting promiscuous mode, and changing the
  1841. * multicast interface list.
  1842. *
  1843. * NOMANUAL
  1844. */
  1846. LOCAL void ln7990Config
  1847.     (
  1848.     LN7990END_DEVICE *pDrvCtrl
  1849.     )
  1850.     {
  1851.     u_short stat;
  1852.     void* pTemp;
  1853.     int timeoutCount = 0;
  1854.     ln_rmd *pRmd;
  1855.     ln_tmd *pTmd;
  1856.     int ix;
  1858.     /* Set promiscuous mode if it's asked for. */
  1860.     if (END_FLAGS_GET(&pDrvCtrl->end) & IFF_PROMISC)
  1861.         {
  1862.         DRV_LOG (DRV_DEBUG_LOAD, "Setting promiscuous mode on!n",
  1863.                  1, 2, 3, 4, 5, 6);
  1864.         
  1865.         /* chip will be in promiscuous mode */
  1866.         
  1867.         pDrvCtrl->ib->lnIBMode = 0x8000;
  1868.         }
  1869.     else
  1870.         {
  1871.         DRV_LOG (DRV_DEBUG_LOAD, "Setting promiscuous mode off!n",
  1872.                  1, 2, 3, 4, 5, 6);
  1873.         pDrvCtrl->ib->lnIBMode = 0; /* chip will be in normal receive mode */
  1874.         }
  1875.     
  1876.     CACHE_PIPE_FLUSH ();
  1878.     ln7990CsrWrite (pDrvCtrl, 0, lncsr_STOP);     /* set the stop bit */
  1880.     /* Set up address filter for multicasting. */
  1882.     if (END_MULTI_LST_CNT(&pDrvCtrl->end) > 0)
  1883. {
  1884. ln7990AddrFilterSet (pDrvCtrl);
  1885. }
  1887.     ln7990CsrWrite (pDrvCtrl, 3, pDrvCtrl->csr3B);
  1889.     pRmd = pDrvCtrl->pRring;
  1890.     for (ix = 0; ix < pDrvCtrl->rringSize; ix++, pRmd++)
  1891.         {
  1892.         pRmd->rbuf_bcnt = -(LN_BUFSIZ); /* neg of buffer byte count */
  1893.         LN_CLEAN_RXD (pRmd);
  1894.         }
  1895.     pDrvCtrl->rmdIndex = 0;
  1896.     
  1897.     pTmd = pDrvCtrl->pTring;
  1898.     for (ix = 0; ix < pDrvCtrl->tringSize; ix++, pTmd++)
  1899.         {
  1900.         pTmd->tbuf_bcnt = 0; /* no message byte count yet */
  1901.         pTmd->tbuf_err = 0; /* no error status yet */
  1902.         LN_TMD_CLR_ERR (pTmd);
  1903.         }
  1904.     
  1905.     pDrvCtrl->tmdIndex = 0;
  1906.     pDrvCtrl->tmdIndexC = 0;
  1907.     
  1908.     /* Point the device to the initialization block */
  1910.     pTemp = LN_CACHE_VIRT_TO_PHYS (pDrvCtrl->ib);
  1911.     ln7990CsrWrite (pDrvCtrl, 2,
  1912.        (u_short)(((u_long)pTemp >> 16) & 0x000000ff));
  1913.     ln7990CsrWrite (pDrvCtrl, 1, (u_long) pTemp);
  1914.     ln7990CsrWrite (pDrvCtrl, 0, lncsr_INIT);    /* init chip (read IB) */
  1916.     /* hang until Initialization DONe, ERRor, or timeout */
  1918.     while (((stat = ln7990Csr0Read (pDrvCtrl)) &
  1919.     (lncsr_IDON | lncsr_ERR)) == 0)
  1920.         {
  1921.         if (timeoutCount++ > 0x10000)
  1922.     break;
  1923. DELAY (1000 * timeoutCount);
  1924.         }
  1926.     DRV_LOG (DRV_DEBUG_LOAD, "Timeoutcount %dn", timeoutCount,
  1927.              2, 3, 4, 5, 6);
  1929.     /* log chip initialization failure */
  1931.     if ((stat & lncsr_ERR) || (timeoutCount >= 0x10000))
  1932.         {
  1933. DRV_LOG (DRV_DEBUG_LOAD, "%s: Device initialization failedn",
  1934.                  (int)END_DEV_NAME(&pDrvCtrl->end), 0,0,0,0,0);
  1935.         return;
  1936.         }
  1938.     if (!(pDrvCtrl->flags & LS_POLLING))
  1939. {
  1940. ln7990CsrWrite (pDrvCtrl, 0, lncsr_INEA | lncsr_STRT);
  1941. }
  1942.     else
  1943. {
  1944. ln7990CsrWrite (pDrvCtrl, 0, lncsr_STRT);
  1945. }
  1946.     }
  1948. /******************************************************************************
  1949. *
  1950. * ln7990AddrFilterSet - set the address filter for multicast addresses
  1951. *
  1952. * This routine goes through all of the multicast addresses on the list
  1953. * of addresses (added with the ln7990AddrAdd() routine) and sets the
  1954. * device's filter correctly.
  1955. *
  1956. * NOMANUAL
  1957. */
  1959. LOCAL void ln7990AddrFilterSet
  1960.     (
  1961.     LN7990END_DEVICE *pDrvCtrl
  1962.     )
  1963.     {
  1965.     ETHER_MULTI* pCurr;
  1966.     ln_ib *pIb;
  1967.     u_char *pCp;
  1968.     u_char c;
  1969.     u_long crc;
  1970.     int len;
  1971.     int count;
  1973.     pIb = pDrvCtrl->ib;
  1975.     LN_ADDRF_CLEAR (pIb);
  1977.     pCurr = END_MULTI_LST_FIRST (&pDrvCtrl->end);
  1979.     while (pCurr != NULL)
  1980. {
  1981. /*
  1982.  * One would think, given the AM7990 document's polynomial
  1983.  * of 0x04c11db6, that this should be 0x6db88320 (the bit
  1984.  * reversal of the AMD value), but that is not right.  See
  1985.  * the BASIC listing: bit 0 (our bit 31) must then be set.
  1986.  */
  1988. pCp = (unsigned char *)&pCurr->addr;
  1989. crc = 0xffffffff;
  1990. for (len = 6; --len >= 0;)
  1991.     {
  1992.     c = *pCp++;
  1993.     for (count = 0; count < 8; count++)
  1994. {
  1995. if ((c & 0x01) ^ (crc & 0x01))
  1996.     {
  1997.     crc >>= 1;
  1998.     crc = crc ^ 0xedb88320;
  1999.     }
  2000. else
  2001.     {
  2002.     crc >>= 1;
  2003.     }
  2004. c >>= 1;
  2005. }
  2006.     }
  2008. /* Just want the 6 most significant bits. */
  2010. crc = crc >> 26;
  2012. /* Turn on the corresponding bit in the filter. */
  2014. LN_ADDRF_SET (pIb, crc);
  2016. pCurr = END_MULTI_LST_NEXT(pCurr);
  2017. }
  2018.     }
  2020. /*******************************************************************************
  2021. *
  2022. * ln7990PollReceive - routine to receive a packet in polled mode.
  2023. *
  2024. * This routine is called by a user to try and get a packet from the
  2025. * device.
  2026. */
  2028. LOCAL STATUS ln7990PollReceive
  2029.     (
  2030.     LN7990END_DEVICE *pDrvCtrl,
  2031.     M_BLK_ID pMblk
  2032.     )
  2033.     {
  2034.     ln_rmd *pRmd;
  2035.     u_short stat;
  2036.     u_long phys;
  2037.     char* pPacket;
  2038.     int len;
  2040.     DRV_LOG (DRV_DEBUG_POLL_RX, "PRX bn", 1, 2, 3, 4, 5, 6);
  2042.     /* Read the device status register */
  2044.     stat = ln7990Csr0Read (pDrvCtrl);
  2046.     /* Check for errors */
  2048.     if (stat & (lncsr_BABL | lncsr_MISS | lncsr_MERR))
  2049.         {
  2050.         ++pDrvCtrl->csr0Errs;
  2051.         DRV_LOG (DRV_DEBUG_POLL_RX, "PRX bad errorn", 1, 2, 3, 4, 5, 6);
  2052. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  2054.         /* restart chip on fatal error */
  2056.         if (stat & lncsr_MERR)        /* memory error */
  2057.             {
  2058.     END_FLAGS_CLR (&pDrvCtrl->end, (IFF_UP | IFF_RUNNING));
  2059.             DRV_LOG (DRV_DEBUG_POLL_RX, "PRX restartn", 1, 2, 3, 4, 5, 6);
  2060.             ln7990Restart (pDrvCtrl);
  2061.     return (EAGAIN);
  2062.             }
  2063.         }
  2065.     /*
  2066.      * clear receive interrupts, and clear any errors that may be set.
  2067.      */
  2069.     ln7990CsrWrite (pDrvCtrl, 0, ((stat &
  2070.             (lncsr_BABL|lncsr_CERR|lncsr_MISS|lncsr_MERR|
  2071.              lncsr_RINT))));
  2074.     /* Packet must be checked for errors. */
  2076.     pRmd = ln7990FullRMDGet (pDrvCtrl);
  2078.     if (pRmd == NULL)
  2079. {
  2080.         DRV_LOG (DRV_DEBUG_POLL_RX, "PRX no rmdn", 1, 2, 3, 4, 5, 6);
  2081. return (EAGAIN);
  2082. }
  2084.     if  (LN_RMD_ERR (pRmd))
  2085. {
  2086. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  2087.         DRV_LOG (DRV_DEBUG_POLL_RX, "PRX bad rmdn", 1, 2, 3, 4, 5, 6);
  2088. goto cleanRXD;
  2089. }
  2091.     END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_UCAST, +1);
  2092.     len = LN_PKT_LEN_GET (pRmd); /* get packet length */
  2094.     /* Get pointer to packet */
  2096.     LN_RMD_TO_ADDR (pDrvCtrl->memBase, pRmd, phys);
  2097.     pPacket = (char *) LN_CACHE_PHYS_TO_VIRT (phys);
  2098.     LN_CACHE_INVALIDATE (pPacket, len);   /* make the packet coherent */
  2100.     /* Upper layer provides the buffer. */
  2102.     if ((pMblk->mBlkHdr.mLen < len) || (!(pMblk->mBlkHdr.mFlags & M_EXT)))
  2103. {
  2104.         DRV_LOG (DRV_DEBUG_POLL_RX, "PRX bad mblk len:%d flags:%dn",
  2105.                  pMblk->mBlkHdr.mLen, pMblk->mBlkHdr.mFlags, 3, 4, 5, 6);
  2106. return (EAGAIN);
  2107. }
  2109.     pMblk->mBlkHdr.mData += pDrvCtrl->offset;
  2110.     bcopy (pPacket, pMblk->mBlkHdr.mData, len);
  2111.     pMblk->mBlkHdr.mLen = len;
  2112.     pMblk->mBlkHdr.mFlags |= M_PKTHDR;
  2113.     pMblk->mBlkPktHdr.len = len;
  2115.     /* Done with descriptor, clean up and give it to the device. */
  2116.     cleanRXD:
  2117.     LN_CLEAN_RXD (pRmd);
  2119.     /* Flush the write pipe */
  2121.     CACHE_PIPE_FLUSH ();
  2123.     /* Advance our management index */
  2125.     pDrvCtrl->rmdIndex = (pDrvCtrl->rmdIndex + 1) & (pDrvCtrl->rringSize - 1);
  2127.     DRV_LOG (DRV_DEBUG_POLL_RX, "PRX okn", 1, 2, 3, 4, 5, 6);
  2128.     return (OK);
  2131.     }
  2133. /*******************************************************************************
  2134. *
  2135. * ln7990PollSend - routine to send a packet in polled mode.
  2136. *
  2137. * This routine is called by a user to try and send a packet on the
  2138. * device.
  2139. */
  2141. LOCAL STATUS ln7990PollSend
  2142.     (
  2143.     LN7990END_DEVICE* pDrvCtrl,
  2144.     M_BLK_ID pMblk
  2145.     )
  2146.     {
  2147.     ln_tmd* pTmd;
  2148.     void*       pTemp;
  2149.     int         len;
  2150.     int         oldLevel;
  2151.     u_short stat;
  2152.     char*       pBuf = NULL;
  2153.     char*       pOrig = NULL;
  2154.     
  2155.     DRV_LOG (DRV_DEBUG_POLL_TX, "PTX bn", 1, 2, 3, 4, 5, 6);
  2157.     /* See if next TXD is available */
  2159.     pTmd = pDrvCtrl->pTring + pDrvCtrl->tmdIndex;
  2161.     LN_CACHE_INVALIDATE (pTmd, TMD_SIZ);
  2163.     if ((pTmd->tbuf_stat & lntmd1_OWN) || (((pDrvCtrl->tmdIndex + 1) &
  2164.         (pDrvCtrl->tringSize - 1)) == pDrvCtrl->tmdIndexC))
  2165.         {
  2166.         DRV_LOG (DRV_DEBUG_POLL_TX, "Out of tmds.n", 1, 2, 3, 4, 5, 6);
  2167.         if (!pDrvCtrl->txCleaning)
  2168.             netJobAdd ((FUNCPTR)ln7990ScrubTRing, (int) pDrvCtrl, 0, 0, 0, 0);
  2169.        return (EAGAIN);
  2170.         }
  2172.     /*
  2173.      * If we don't have alignment issues then we can transmit
  2174.      * directly from the M_BLK otherwise we have to copy.
  2175.      */
  2176.     
  2177.     if ((pDrvCtrl->offset == 0) && (pMblk->mBlkHdr.mNext == NULL))
  2178.         {
  2179.         len = max (ETHERSMALL, pMblk->m_len);
  2180.         LN_TMD_BUF_TO_ADDR(pTmd, pTemp, pMblk->m_data);
  2181.         DRV_LOG (DRV_DEBUG_POLL_TX, "offset == 0.n", 1, 2, 3, 4, 5, 6);
  2182.         }
  2183.     else
  2184.         {
  2185.         DRV_LOG (DRV_DEBUG_POLL_TX, "offset != 0.n", 1, 2, 3, 4, 5, 6);
  2186.         pOrig = pBuf = netClusterGet(pDrvCtrl->end.pNetPool,
  2187.                                      pDrvCtrl->pClPoolId);
  2188.         if (pBuf == NULL)
  2189.             {
  2190.             return (EAGAIN);
  2191.             }
  2192.         
  2193.         pBuf += pDrvCtrl->offset;
  2194.         
  2195.         len = netMblkToBufCopy (pMblk, pBuf, NULL);
  2196.         LN_TMD_BUF_TO_ADDR(pTmd, pTemp, pBuf);
  2197.         }
  2199.     len = max (len, ETHERSMALL);
  2201.     /* place a transmit request */
  2203.     oldLevel = intLock ();          /* disable ints during update */
  2205.     pTmd->tbuf_err = 0;                     /* clear buffer error status */
  2206.     pTmd->tbuf_bcnt = -len;                  /* negative message byte count */
  2207.     pTmd->tbuf_stat |= lntmd1_OWN | lntmd1_STP | lntmd1_ENP;
  2209.     /* Flush the write pipe */
  2211.     CACHE_PIPE_FLUSH ();
  2213.     intUnlock (oldLevel);   /* now ln7990Int won't get confused */
  2215.     /* Advance our management index */
  2217.     pDrvCtrl->tmdIndex = (pDrvCtrl->tmdIndex + 1) & (pDrvCtrl->tringSize - 1);
  2219.     /* kick start the transmitter, if selected */
  2221.     if (lnKickStartTx)
  2222. ln7990CsrWrite (pDrvCtrl, 0, lncsr_TDMD);
  2224.     /* Bump the statistic counter. */
  2226.     END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_UCAST, +1);
  2228.     /* Flush the write pipe */
  2230.     CACHE_PIPE_FLUSH ();
  2232.     /* Read the device status register */
  2234.     stat = ln7990Csr0Read (pDrvCtrl);
  2236.     /*
  2237.      * Spin until we think we've sent it.  SInce we're single threaded
  2238.      * now it must be us who talked.
  2239.      */
  2240.     while (!(stat & lncsr_TINT))
  2241.         {
  2242.         stat = ln7990Csr0Read (pDrvCtrl);
  2243.         }
  2245.     /*
  2246.      * We now believe taht this frame has been transmitted.  SInce we
  2247.      * may have allocated/copied it we need to free it an then shout
  2248.      * hey nonny hey.
  2249.      */
  2250.     if (pOrig != NULL)
  2251.         {
  2252.         DRV_LOG (DRV_DEBUG_POLL_TX, "pOrig != NULLn", 1, 2, 3, 4, 5, 6);
  2253.         netClFree(pDrvCtrl->end.pNetPool, pOrig);
  2254.         }
  2255.     
  2256.     if (!pDrvCtrl->txCleaning)
  2257.         {
  2258.         pDrvCtrl->txCleaning = TRUE;
  2259.         ln7990ScrubTRing (pDrvCtrl);
  2260.         }
  2261.     
  2262.     DRV_LOG (DRV_DEBUG_POLL_TX, "PTX en", 1, 2, 3, 4, 5, 6);
  2264.     return (OK);
  2265.     }
  2267. /*****************************************************************************
  2268. *
  2269. * ln7990MCastAddrAdd - add a multicast address for the device
  2270. *
  2271. * This routine adds a multicast address to whatever the driver
  2272. * is already listening for.  It then resets the address filter.
  2273. */
  2275. LOCAL STATUS ln7990MCastAddrAdd
  2276.     (
  2277.     LN7990END_DEVICE *pDrvCtrl,
  2278.     char* pAddress
  2279.     )
  2280.     {
  2282.     int error;
  2284.     if ((error = etherMultiAdd (&pDrvCtrl->end.multiList,
  2285. pAddress)) == ENETRESET)
  2286.     ln7990Config (pDrvCtrl);
  2288.     return (OK);
  2289.     }
  2291. /*****************************************************************************
  2292. *
  2293. * ln7990MCastAddrDel - delete a multicast address for the device
  2294. *
  2295. * This routine removes a multicast address from whatever the driver
  2296. * is listening for.  It then resets the address filter.
  2297. */
  2299. LOCAL STATUS ln7990MCastAddrDel
  2300.     (
  2301.     LN7990END_DEVICE* pDrvCtrl,
  2302.     char* pAddress
  2303.     )
  2304.     {
  2306.     int error;
  2308.     if ((error = etherMultiDel (&pDrvCtrl->end.multiList,
  2309.      (char *)pAddress)) == ENETRESET)
  2310.     ln7990Config (pDrvCtrl);
  2312.     return (OK);
  2313.     }
  2315. /*****************************************************************************
  2316. *
  2317. * ln7990MCastAddrGet - get the multicast address list for the device
  2318. *
  2319. * This routine gets the multicast list of whatever the driver
  2320. * is already listening for.
  2321. */
  2323. LOCAL STATUS ln7990MCastAddrGet
  2324.     (
  2325.     LN7990END_DEVICE* pDrvCtrl,
  2326.     MULTI_TABLE* pTable
  2327.     )
  2328.     {
  2330.     int error;
  2332.     error = etherMultiGet (&pDrvCtrl->end.multiList, pTable);
  2334.     return (error);
  2335.     }
  2337. /*******************************************************************************
  2338. *
  2339. * ln7990Stop - stop the device
  2340. *
  2341. * This function calls BSP functions to disconnect interrupts and stop
  2342. * the device from operating in interrupt mode.
  2343. *
  2344. * RETURNS: OK or ERROR
  2345. */
  2347. LOCAL STATUS ln7990Stop
  2348.     (
  2349.     LN7990END_DEVICE *pDrvCtrl
  2350.     )
  2351.     {
  2352.     STATUS result = OK;
  2354.     /* Stop the device. */
  2356.     ln7990CsrWrite (pDrvCtrl, 0, lncsr_STOP);      /* set the stop bit */
  2358.     SYS_INT_DISCONNECT (pDrvCtrl, ln7990Int, (int)pDrvCtrl, &result);
  2360.     if (result == ERROR)
  2361. {
  2362. DRV_LOG (DRV_DEBUG_LOAD, "Could not diconnect interrupt!n",
  2363.                  1, 2, 3, 4, 5, 6);
  2364. }
  2366.     return (result);
  2368.     }
  2370. /******************************************************************************
  2371. *
  2372. * ln7990Unload - unload a driver from the system
  2373. *
  2374. * This function first brings down the device, and then frees any
  2375. * stuff that was allocated by the driver in the load function.
  2376. */
  2378. LOCAL STATUS ln7990Unload
  2379.     (
  2380.     LN7990END_DEVICE* pDrvCtrl
  2381.     )
  2382.     {
  2383.     END_OBJECT_UNLOAD (&pDrvCtrl->end);
  2385.     /* Free the shared DMA memory. */
  2386.     if (pDrvCtrl->flags & LS_MEM_ALLOC_FLAG)
  2387. cacheDmaFree (pDrvCtrl->pShMem);
  2389.     return (OK);
  2390.     }
  2393. /*******************************************************************************
  2394. *
  2395. * ln7990PollStart - start polled mode operations
  2396. *
  2397. * RETURNS: OK or ERROR.
  2398. */
  2400. LOCAL STATUS ln7990PollStart
  2401.     (
  2402.     LN7990END_DEVICE* pDrvCtrl
  2403.     )
  2405.     {
  2406.     u_short        stat;
  2407.     int         oldLevel;
  2409.     /* Read the device status register */
  2411.     oldLevel = intLock ();          /* disable ints during update */
  2413.     stat = ln7990Csr0Read (pDrvCtrl);
  2415.     /* Rewrite the register minus the INEA bit to turn off interrupts */
  2417.     ln7990CsrWrite (pDrvCtrl, 0, ((stat &
  2418.     (lncsr_BABL|lncsr_CERR|lncsr_MISS|lncsr_MERR|
  2419.     lncsr_RINT|lncsr_TINT))));
  2421.     pDrvCtrl->flags |= LS_POLLING;
  2423.     intUnlock (oldLevel);   /* now ln7990Int won't get confused */
  2425.     DRV_LOG (DRV_DEBUG_POLL, "STARTEDn", 1, 2, 3, 4, 5, 6);
  2427.     ln7990Config (pDrvCtrl); /* reconfigure device */ 
  2429.     return (OK);
  2430.     }
  2432. /*******************************************************************************
  2433. *
  2434. * ln7990PollStop - stop polled mode operations
  2435. *
  2436. * RETURNS: OK or ERROR.
  2437. */
  2439. LOCAL STATUS ln7990PollStop
  2440.     (
  2441.     LN7990END_DEVICE* pDrvCtrl
  2442.     )
  2443.     {
  2445.     u_short        stat;
  2446.     int         oldLevel;
  2448.     oldLevel = intLock ();          /* disable ints during update */
  2450.     stat = ln7990Csr0Read (pDrvCtrl);
  2452.     /* Rewrite the register minus the INEA bit to turn off interrupts */
  2454.     ln7990CsrWrite (pDrvCtrl, 0, ((stat &
  2455.             (lncsr_BABL|lncsr_CERR|lncsr_MISS|lncsr_MERR|
  2456. lncsr_RINT|lncsr_TINT)) | lncsr_INEA));
  2459.     pDrvCtrl->flags &= ~LS_POLLING;
  2461.     intUnlock (oldLevel);   /* now ln7990Int won't get confused */
  2463.     DRV_LOG (DRV_DEBUG_POLL, "STOPPEDn", 1, 2, 3, 4, 5, 6);
  2465.     ln7990Config (pDrvCtrl); /* reconfigure device */
  2466.     
  2467.     return (OK);
  2468.     }
  2471. /******************************************************************************
  2472. *
  2473. * ln7990ScrubTRing - clean the transmit ring
  2474. *
  2475. * RETURNS: N/A
  2476. *
  2477. */
  2479. LOCAL void ln7990ScrubTRing
  2480.     (
  2481.     LN7990END_DEVICE* pDrvCtrl
  2482.     )
  2483.     {
  2485.     int         oldLevel;
  2486.     ln_tmd* pTmd;
  2487.     ln_rmd* pRmd;
  2488.     
  2489.     pDrvCtrl->txCleaning = TRUE;
  2491.     while (pDrvCtrl->tmdIndexC != pDrvCtrl->tmdIndex)
  2492.         {
  2494.         /* Handle one recv packet if exists */
  2495. if ((pRmd = ln7990FullRMDGet (pDrvCtrl)) != NULL)
  2496.     {
  2497.             LN_CACHE_INVALIDATE (pRmd, RMD_SIZ);
  2498.             ln7990Recv (pDrvCtrl, pRmd);
  2499.             }
  2501.         /* disposal has not caught up */
  2502.         pTmd = pDrvCtrl->pTring + pDrvCtrl->tmdIndexC;
  2504.         /* if the buffer is still owned by LANCE, don't touch it */
  2506.         LN_CACHE_INVALIDATE (pTmd, TMD_SIZ);
  2508.         if (SHMEM_RD (&pTmd->tbuf_stat) & TMD_OWN)
  2509.             break;
  2511.         oldLevel = intLock();
  2513.         if (pDrvCtrl->freeRtn[pDrvCtrl->tmdIndexC] != NULL)
  2514.             {
  2515.             pDrvCtrl->freeRtn[pDrvCtrl->tmdIndexC]
  2516.                 (pDrvCtrl->freeData[pDrvCtrl->tmdIndexC].arg1,
  2517.                  pDrvCtrl->freeData[pDrvCtrl->tmdIndexC].arg2); 
  2518.             pDrvCtrl->freeRtn[pDrvCtrl->tmdIndexC] = NULL;
  2519.             pDrvCtrl->freeData[pDrvCtrl->tmdIndexC].arg1 = NULL; 
  2520.             pDrvCtrl->freeData[pDrvCtrl->tmdIndexC].arg2 = NULL; 
  2521.             }
  2523.         intUnlock(oldLevel);
  2524.         
  2525.         /* now bump the tmd disposal index pointer around the ring */
  2527.         pDrvCtrl->tmdIndexC = (pDrvCtrl->tmdIndexC + 1) &
  2528.       (pDrvCtrl->tringSize - 1);
  2530.         /*
  2531.          * lntmd1_ERR is an "OR" of LCOL, LCAR, UFLO or RTRY.
  2532.          * Note that BUFF is not indicated in lntmd1_ERR.
  2533.          * We should therefore check both lntmd1_ERR and lntmd3_BUFF
  2534.          * here for error conditions.
  2535.          */
  2537.         if ((SHMEM_RD (&pTmd->tbuf_stat) & lntmd1_ERR) ||
  2538.     (SHMEM_RD (&pTmd->tbuf_err) & lntmd3_BUFF))
  2539.             {
  2540.     END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_ERRS, +1);
  2541.     END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_UCAST, -1);
  2543.             /*
  2544.      * If error was due to excess collisions, bump the collision
  2545.              * counter.  The LANCE does not keep an individual counter of
  2546.              * collisions, so in this driver, the collision statistic is not
  2547.              * an accurate count of total collisions.
  2548.              */
  2550.     /* assume DRTY bit not set */
  2551.             if (SHMEM_RD (&pTmd->tbuf_err) & lntmd3_RTRY)
  2552. END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_ERRS, +1);
  2554.             /* check for no carrier */
  2556.             if (SHMEM_RD (&pTmd->tbuf_err) & TMD_LCAR)
  2557. {
  2558. DRV_LOG (DRV_DEBUG_TX, "%s: no carriern",
  2559.                          (int)END_DEV_NAME(&pDrvCtrl->end), 0,0,0,0,0);
  2560. }
  2562.             /*
  2563.      * Restart chip on fatal errors.
  2564.              * The following code handles the situation where the transmitter
  2565.              * shuts down due to an underflow error.  This is a situation that
  2566.              * will occur if the DMA cannot keep up with the transmitter.
  2567.              * It will occur if the LANCE is being held off from DMA access
  2568.              * for too long or due to significant memory latency.  DRAM
  2569.              * refresh or slow memory could influence this.  Many
  2570.              * implementations use a dedicated LANCE buffer.  This can be
  2571.              * static RAM to eliminate refresh conflicts; or dual-port RAM
  2572.              * so that the LANCE can have free run of this memory during its
  2573.              * DMA transfers.
  2574.              */
  2576.             if ((SHMEM_RD (&pTmd->tbuf_err) & lntmd3_BUFF) ||
  2577. (SHMEM_RD (&pTmd->tbuf_err) & TMD_UFLO))
  2578.                 {
  2579.                 pDrvCtrl->end.flags &= ~(IFF_UP | IFF_RUNNING);
  2580. ln7990Restart (pDrvCtrl);
  2581.                 }
  2582.             }
  2584. LN_TMD_CLR_ERR (pTmd);
  2585.         }
  2586.     pDrvCtrl->txCleaning = FALSE;
  2587.     }