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

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

VxWorks

开发平台：

C/C++

if_dc.c：源码内容
  1. /* if_dc.c - DEC 21x4x Ethernet LAN network interface driver */
  3. /* Copyright 1984-1998 Wind River Systems, Inc. */
  4. /* Copyright 1996-1998 Motorola, Inc., All Rights Reserved */
  6. #include "copyright_wrs.h"
  8. /*
  9. modification history
  10. --------------------
  11. 01m,07apr98,dat  fixed man page generation.
  12. 01l,26nov97,map  added support for SENS stack.
  13. 01k,21nov97,map  update if_flags when DC_* flags are set [SPR# 9873]
  14. 01j,30oct97,map  Merged media-select changes from mtx603/dec21140/dec21140.c
  15.                  (ver 01s). Added macros for BSP interface and register access.
  16.                  Added MII interface routines.
  17. 01i,27oct97,map  Merged from mv2603/dec21140/dec21140.c (ver 01r) [SPR# 8176]
  18. 01h,24jun97,map  Fixed memory leaks. Added dropped frame counts [SPR# 8826]
  19. 01m,15dec97,map  use BSD macro to define BSD4[34]_DRIVER flag.
  20. 01l,26nov97,map  added support for SENS stack.
  21. 01k,21nov97,map  update if_flags when DC_* flags are set [SPR# 9873]
  22. 01j,30oct97,map  Merged media-select changes from mtx603/dec21140/dec21140.c
  23.                  (ver 01s). Added macros for BSP interface and register access.
  24.                  Added MII interface routines.
  25. 01i,27oct97,map  Merged from mv2603/dec21140/dec21140.c (ver 01r) [SPR# 8176]
  26. 01h,24jun97,map  Fixed memory leaks. Added dropped frame counts [SPR# 8826]
  27. 01g,06nov96,dgp  doc: final formatting
  28. 01f,01jul96,tam  moved code from dcInt to dcHandleRecvInt to reduce the amount
  29.  of code executed at interrupt level (spr #6070).
  30. 01e,19jun96,tam  added output etherhook to dcOutput (spr #6695).
  31. 01d,05sep95,vin  added filter Frame setup, added PROMISCOUS MODE to ioctl,
  32.  changed all ln references to dc, added flag DC_MULTICAST_FLAG.
  33. 01c,05apr95,vin  added AUI/10BASE-T dynamic configuration support. 
  34. 01b,31mar95,caf  changed name from "dcPci" to "dc".
  35. 01a,03mar95,vin  written.
  36. */
  38. /* 
  40. This module implements an ethernet interface driver for the DEC 21x4x family,
  41. and currently supports the following variants -- 21040, 21140, and 21140A.
  43. The DEC 21x4x PCI Ethernet controllers are inherently little-endian since they
  44. are designed for a little-endian PCI bus. While the 21040 only supports a
  45. 10Mps interface, other members of this family are dual-speed devices which
  46. support both 10 and 100 Mbps.
  48. This driver is designed to be moderately generic, operating unmodified across
  49. the range of architectures and targets supported by VxWorks; and on multiple
  50. versions of the dec21x4x family. To achieve this, the driver takes several
  51. parameters, and external support routines which are detailed below. Also
  52. stated below are assumptions made by the driver of the hardware, and if any of
  53. these assumptions are not true for your hardware, the driver will probably not
  54. function correctly.
  56. This driver supports up to 4 ethernet units per CPU, and can be
  57. configured for either big-endian or little-endian architectures.  It
  58. contains error-recovery code to handle known device errata related to DMA
  59. activity.
  61. On a dec21040, this driver configures the 10BASE-T interface by default and
  62. waits for two seconds to check the status of the link. If the link status is
  63. "fail," it then configures the AUI interface.
  65. The dec21140, and dec21140A devices support both 10 and 100Mbps and also a
  66. variety of MII and non-MII PHY interfaces. This driver reads a DEC version 2.0
  67. SROM device for PHY initialization information, and automatically configures
  68. an apropriate active PHY media.
  70. BOARD LAYOUT
  72. This device is on-board.  No jumpering diagram is necessary.
  74. EXTERNAL INTERFACE
  76. This driver provides the standard external interface with the following
  77. exceptions.  All initialization is performed within the attach routine;
  78. there is no separate initialization routine.  Therefore, in the global interface
  79. structure, the function pointer to the initialization routine is NULL.
  81. The only user-callable routine is dcattach(), which publishes the `dc'
  82. interface and initializes the driver and device.
  84. TARGET-SPECIFIC PARAMETERS
  86. .iP "bus mode"
  88. This parameter is a global variable that can be modified at run-time.
  90. The LAN control register #0 determines the bus mode of the device,
  91. allowing the support of big-endian and little-endian architectures.
  92. This parameter, defined as "ULONG dcCSR0Bmr", is the value that will
  93. be placed into device control register #0. The default is mode is little
  94. endian.
  96. For information about changing this parameter, see the manual
  98. .I "DEC  Local Area Network Controller DEC21040 or DEC21140 for PCI."
  100. .iP "base address of device registers"
  102. This parameter is passed to the driver by dcattach().
  104. .iP "interrupt vector"
  106. This parameter is passed to the driver by dcattach().
  108. This driver configures the device to generate hardware interrupts
  109. for various events within the device; thus it contains
  110. an interrupt handler routine.  The driver calls intConnect() to connect 
  111. its interrupt handler to the interrupt vector generated as a result of 
  112. the device interrupt.
  114. .iP "interrupt level"
  116. This parameter is passed to the driver by dcattach().
  118. Some targets use additional interrupt controller devices to help organize and
  119. service the various interrupt sources.  This driver avoids all board-specific
  120. knowledge of such devices.  During the driver's initialization, the external
  121. routine sysLanIntEnable() is called to perform any board-specific operations
  122. required to allow the servicing of a device interrupt.  For a description of
  123. sysLanIntEnable(), see "External Support Requirements" below.
  125. This parameter is passed to the external routine.
  127. .iP "shared memory address"
  129. This parameter is passed to the driver by dcattach().
  131. The DEC 21x4x device is a DMA type of device and typically shares access to
  132. some region of memory with the CPU.  This driver is designed for systems that
  133. directly share memory between the CPU and the DEC 21x4x.  It assumes that this
  134. shared memory is directly available to it without any arbitration or timing
  135. concerns.
  137. This parameter can be used to specify an explicit memory region for use by the
  138. DEC 21x4x device.  This should be done on hardware that restricts the DEC
  139. 21x4x device to a particular memory region.  The constant NONE can be used to
  140. indicate that there are no memory limitations, in which case, the driver
  141. attempts to allocate the shared memory from the system space.
  143. .iP "shared memory size"
  145. This parameter is passed to the driver by dcattach().
  147. This parameter can be used to explicitly limit the amount of shared
  148. memory (bytes) this driver will use.  The constant NONE can be used to
  149. indicate no specific size limitation.  This parameter is used only if
  150. a specific memory region is provided to the driver.
  152. .iP "shared memory width"
  154. This parameter is passed to the driver by dcattach().
  156. Some target hardware that restricts the shared memory region to a
  157. specific location also restricts the access width to this region by
  158. the CPU.  On these targets, performing an access of an invalid width
  159. will cause a bus error.
  161. This parameter can be used to specify the number of bytes of access
  162. width to be used by the driver during access to the shared memory.
  163. The constant NONE can be used to indicate no restrictions.
  165. Current internal support for this mechanism is not robust; implementation 
  166. may not work on all targets requiring these restrictions.
  168. .iP "shared memory buffer size"
  170. This parameter is passed to the driver by dcattach().
  172. The driver and DEC 21x4x device exchange network data in buffers.  This
  173. parameter permits the size of these individual buffers to be limited.
  174. A value of zero indicates that the default buffer size should be used.
  175. The default buffer size is large enough to hold a maximum-size Ethernet
  176. packet.
  178. .iP "pci Memory base"
  180. This parameter is passed to the driver by dcattach(). This parameter
  181. gives the base address of the main memory on the PCI bus. 
  183. .iP "dcOpMode"
  185. This parameter is passed to the driver by dcattach(). This parameter
  186. gives the mode of initialization of the device. The mode flags for both
  187. the DEC21040 and DEC21140 interfaces are listed below.  
  189. DC_PROMISCUOUS_FLAG     0x01 
  190. DC_MULTICAST_FLAG 0x02
  192. The mode flags specific to the DEC21140 interface are listed below.
  194. DC_100_MB_FLAG          0x04
  195. DC_21140_FLAG           0x08
  196. DC_SCRAMBLER_FLAG       0x10
  197. DC_PCS_FLAG             0x20
  198. DC_PS_FLAG              0x40
  200. DC_FULLDUPLEX_FLAG      0x10
  202. Loopback mode flags
  203. DC_ILOOPB_FLAG          0x100 
  204. DC_ELOOPB_FLAG          0x200
  205. DC_HBE_FLAG         0x400
  207. .iP "Ethernet address"
  209. This is obtained by the driver by reading an ethernet ROM register or the DEC
  210. serial ROM.
  212. .LP
  214. EXTERNAL SUPPORT REQUIREMENTS
  216. This driver requires one external support function:
  218. .iP "void sysLanIntEnable (int level)" "" 9 -1
  220. This routine provides a target-specific enable of the interrupt for the DEC
  221. 21x4x device.  Typically, this involves interrupt controller hardware, either
  222. internal or external to the CPU.
  224. This routine is called once via the macro SYS_INT_ENABLE().
  225. .LP
  227. INTERNAL
  229. This driver utilizes macros to access registers and certain BSP
  230. functionalities. These macros may be redefined in a wrapper file to generate a
  231. new driver module with a customized interface.
  233. .iP "SYS_INT_CONNECT"
  235. This macro is used to associate an interrupt handler to the device interrupt
  236. vector pDrvCtrl->ivec. An OK/ERROR status is returned via parameter `pResult'.
  238. .iP "SYS_INT_DISCONNECT"
  240. Currently, this macro is not used by the driver, but exists for future
  241. implementation and will be used to disconnect an interrupt handler from the
  242. device interrupt vector. An OK/ERROR status is returned via parameter, `pResult'.
  244. .iP "SYS_INT_ENABLE"
  246. This macro is used by the driver to enable device interrupts. Typically, this
  247. macro should call a BSP routine that will enable interrupts from this device.
  249. .iP "SYS_INT_DISABLE"
  251. This macro is called by the driver to disable device interrupts.
  253. .iP "DC_CSR_READ"
  255. This macro is used by the driver to read the device command status 
  256. registers. If not redefined, this macro calls the inbuilt driver function
  257. dcCsrRead().
  259. .iP "DC_CSR_WRITE"
  261. This macro is used by the driver to write to a device command status
  262. register. By default this macro calls the inbuilt driver funtion dcCsrWrite().
  264. .LP
  267. SEE ALSO: ifLib, 
  269. .I "DECchip 21040 or 21140 Ethernet LAN Controller for PCI."
  271. */
  273. #include "vxWorks.h"
  274. #include "stdlib.h"
  275. #include "taskLib.h"
  276. #include "logLib.h"
  277. #include "intLib.h"
  278. #include "netLib.h"
  279. #include "stdio.h"
  280. #include "stdlib.h"
  281. #include "sysLib.h"
  282. #include "iv.h"
  283. #include "memLib.h"
  284. #include "cacheLib.h"
  285. #include "sys/ioctl.h"
  286. #include "etherLib.h"
  288. #ifndef DOC             /* don't include when building documentation */
  289. #include "net/mbuf.h"
  290. #endif  /* DOC */
  292. #include "net/protosw.h"
  293. #include "sys/socket.h"
  294. #include "errno.h"
  296. #include "net/if.h"
  297. #include "net/route.h"
  299. #include "netinet/in.h"
  300. #include "netinet/in_systm.h"
  301. #include "netinet/in_var.h"
  302. #include "netinet/ip.h"
  303. #include "netinet/if_ether.h"
  304. #include "net/if_subr.h"
  305. #include "semLib.h"
  307. #include "drv/netif/if_dc.h"                 /* device description header */
  309. /* defines */
  311. #if (BSD == 44)
  312. #  define BSD44_DRIVER
  313. #else
  314. #  define BSD43_DRIVER
  315. #endif /* (BSD == 44) */
  317. #ifdef BSD43_DRIVER
  318. typedef struct enet_hdr
  319.     {
  320.     char dst [6];
  321.     char src [6];
  322.     USHORT type;
  323.     } ENET_HDR;
  324. #endif /* BSD43_DRIVER */
  326. #define ENET_HDR_SIZ        sizeof(ENET_HDR)
  327. #define ENET_HDR_REAL_SIZ   14
  329. #define DC_BUFSIZ      (ETHERMTU + SIZEOF_ETHERHEADER + 6)
  330. #define MAX_UNITS       4 /* maximum units supported */
  331. #define DC_L_POOL 0x10 /* number of Rx loaner buffers in pool */
  332. #define LOOP_PER_NS 4
  334. #define DELAY(count) {                                               
  335. volatile int cx = 0;                            
  336. for (cx = 0; cx < (count); cx++);               
  337. }
  339. #ifndef NSDELAY
  340. #define NSDELAY(nsec) {                                               
  341. volatile int nx = 0;                            
  342. volatile int loop = (int)(nsec*LOOP_PER_NS);    
  343. for (nx = 0; nx < loop; nx++);                  
  344. }
  345. #endif /* NSDELAY */
  347. #define DEC21140(x) (x & DC_21140_FLAG)
  349. /*
  350.  * If DC_KICKSTART_TX is TRUE the transmitter is kick-started to force a read
  351.  * of the transmit descriptors, otherwise the internal polling (1.6msec) will
  352.  * initiate a read of the descriptors.  This should be FALSE is there is any
  353.  * chance of memory latency or chip accesses detaining the DEC 21x4x DMA,
  354.  * which results in a transmitter UFLO error.  This can be changed with the
  355.  * global dcKickStartTx below.
  356.  */
  358. #define DC_KICKSTART_TX TRUE
  360. /* Cache macros */
  362. #define DC_CACHE_INVALIDATE(address, len)                               
  363.         CACHE_DRV_INVALIDATE (&pDrvCtrl->cacheFuncs, (address), (len))
  365. #define DC_CACHE_VIRT_TO_PHYS(address)                                  
  366.         CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, (address))
  368. #define DC_CACHE_PHYS_TO_VIRT(address)                                  
  369.         CACHE_DRV_PHYS_TO_VIRT (&pDrvCtrl->cacheFuncs, (address))
  371. /*
  372.  * Default macro definitions for BSP interface.
  373.  * These macros can be redefined in a wrapper file, to generate
  374.  * a new module with an optimized interface.
  375.  */
  376. #ifndef SYS_INT_CONNECT
  377. #define SYS_INT_CONNECT(pDrvCtrl, rtn, arg, pResult)                    
  378.     {                                                                   
  379.     *pResult = intConnect((VOIDFUNCPTR *)INUM_TO_IVEC (pDrvCtrl->ivec), 
  380.                           (rtn), (int) (arg));                          
  381.     }
  382. #endif /* SYS_INT_CONNECT */
  384. #ifndef SYS_INT_DISCONNECT
  385. #define SYS_INT_DISCONNECT(pDrvCtrl, rtn, arg, pResult)                 
  386.     {                                                                   
  387.     *pResult = OK;                                                      
  388.     }
  389. #endif /* SYS_INT_DISCONNECT */
  390.     
  391. #ifndef SYS_INT_ENABLE
  392. #define SYS_INT_ENABLE(pDrvCtrl)                                        
  393.     {                                                                   
  394.     IMPORT void sysLanIntEnable(int level);                             
  395.     sysLanIntEnable (pDrvCtrl->ilevel);                                 
  396.     }
  397. #endif /* SYS_INT_ENABLE */
  399. #ifndef SYS_INT_DISABLE
  400. #define SYS_INT_DISABLE(pDrvCtrl)                                       
  401.     {                                                                   
  402.     IMPORT void sysLanIntDisable(int level);                            
  403.     sysLanIntDisable (pDrvCtrl->ilevel);                                
  404.     }
  405. #endif /* SYS_INT_DISABLE */
  406.     
  407. /* memory to PCI address translation macros */
  409. #define PCI_TO_MEM_PHYS(pciAdrs)                                        
  410. ((pciAdrs) - (pDrvCtrl->pciMemBase))
  412. #define MEM_TO_PCI_PHYS(memAdrs)                                        
  413. ((memAdrs) + (pDrvCtrl->pciMemBase))
  415. #define DC_TD_INDEX_NEXT(pDrvCtrl)                                      
  416. (((pDrvCtrl)->txIndex + 1) % (pDrvCtrl)->dcNumTds)
  418. #define DC_TD_DINDEX_NEXT(pDrvCtrl)                                     
  419. (((pDrvCtrl)->txDiIndex + 1) % (pDrvCtrl)->dcNumTds)
  421. /*
  422.  * Default macro definitions for device register accesses:
  423.  * These macros can be redefined in a wrapper file, to generate
  424.  * a new module with an optimized interface.
  425.  */
  426. #ifndef DC_CSR_READ
  427. #define DC_CSR_READ(devAdrs, csrNum)                                    
  428.      dcCsrRead ((devAdrs), (csrNum))
  429. #endif /* DC_CSR_READ */
  431. #ifndef DC_CSR_WRITE
  432. #define DC_CSR_WRITE(devAdrs, csrNum, csrVal)                           
  433.      dcCsrWrite((devAdrs), (csrNum), (csrVal))
  434. #endif /* DC_CSR_WRITE */
  436. #define DC_CSR_UPDATE(devAdrs, csrNum, csrBits)                         
  437.      DC_CSR_WRITE((devAdrs), (csrNum),                               
  438.                      DC_CSR_READ((devAdrs), (csrNum)) | (csrBits))
  440. #define DC_CSR_RESET(devAdrs, csrNum, csrBits)                          
  441.      DC_CSR_WRITE((devAdrs), (csrNum),                               
  442.                      DC_CSR_READ((devAdrs), (csrNum)) & ~(csrBits))
  443.     
  444. #define DC_INT_ENABLE(devAdrs, X)                                       
  445. DC_CSR_UPDATE ((devAdrs), CSR7, (X))
  447. #define DC_INT_DISABLE(devAdrs, X)                                      
  448.      DC_CSR_RESET ((devAdrs), CSR7, (X))
  450. #define DC_SROM_WRITE(devAdrs, adrs, delay)                             
  451.      {                                                               
  452.         DC_CSR_WRITE ((devAdrs), CSR9, (adrs) | CSR9_SR | CSR9_WR);     
  453.         NSDELAY(delay);                                                 
  454.         }
  456. #define DC_SROM_READ(devAdrs)                                           
  457. ((DC_CSR_READ ((devAdrs), CSR9) & 0x08) >> 3)
  459. /* MII read/write access macros */
  460.     
  461. #define DC_MII_BIT_READ(devAdrs, pBData)                                        
  462.      {                                                                       
  463.         DC_CSR_WRITE ((devAdrs), CSR9, CSR9_MII_RD | CSR9_RD);                  
  464.         NSDELAY (100);                                                          
  465.         DC_CSR_WRITE ((devAdrs), CSR9, CSR9_MII_RD | CSR9_RD | CSR9_MDC);       
  466.         NSDELAY (100);                                                          
  467.         *(pBData) |= CSR9_MII_DBIT_RD (DC_CSR_READ ((devAdrs), CSR9));          
  468.      }
  470. #define DC_MII_BIT_WRITE(devAdrs, data)                                 
  471.      {                                                               
  472.         DC_CSR_WRITE ((devAdrs), CSR9, CSR9_MII_DBIT_WR(data) |         
  473.                       CSR9_MII_WR | CSR9_WR);                           
  474.         NSDELAY (100);                                                  
  475.         DC_CSR_WRITE ((devAdrs), CSR9, CSR9_MII_DBIT_WR(data) |         
  476.                       CSR9_MII_WR | CSR9_WR | CSR9_MDC);                
  477.         NSDELAY (100);                                                  
  478.         }
  480. #define DC_MII_RTRISTATE(devAdrs)                                       
  481. {                                                               
  482.         int retVal;                                                     
  483.         DC_MII_BIT_READ ((devAdrs), &retVal);                           
  484.         }
  486. #define DC_MII_WTRISTATE(devAdrs)                                       
  487. {                                                               
  488.         DC_MII_BIT_WRITE((devAdrs), 0x1);                               
  489.         DC_MII_BIT_WRITE((devAdrs), 0x0);                               
  490. }
  492. #define DC_MII_WRITE(devAdrs, data, bitCount)                           
  493.      {                                                               
  494.         int i=(bitCount);                                               
  495.                                                                         
  496.         while (i--)                                                     
  497.             DC_MII_BIT_WRITE ((devAdrs), ((data) >> i) & 0x1);          
  498.         }
  500. #define DC_MII_READ(devAdrs, pData, bitCount)                           
  501.      {                                                               
  502.         int i=(bitCount);                                               
  503.                                                                         
  504.         while (i--)                                                     
  505.             {                                                           
  506.             *(pData) <<= 1;                                             
  507.             DC_MII_BIT_READ ((devAdrs), (pData));                       
  508.             }                                                           
  509.         }
  511. #define BUILD_CLUSTER(pDrvCtrl, pEnetHdr, pData, len)                           
  512. build_cluster ((pData), (len), &(pDrvCtrl)->idr.ac_if, MC_LANCE,        
  513.                        (pDrvCtrl)->pRefCnt[(pDrvCtrl)->nLoanRx - 1],            
  514.                        (FUNCPTR) dcLoanFree, (int)(pDrvCtrl),                   
  515.                        (int) (pEnetHdr),                                        
  516.                        (int)(pDrvCtrl)->pRefCnt[(pDrvCtrl)->nLoanRx - 1])
  518. #ifdef BSD43_DRIVER
  519. #define DC_START_OUTPUT(pDrvCtrl)                                        
  520.      dcStartOutput (pDrvCtrl->idr.ac_if.if_unit)
  521. #else
  522. #define DC_START_OUTPUT(pDrvCtrl)                                        
  523.      dcStartOutput (pDrvCtrl)
  524. #endif
  525.     
  526. /* Typedefs for external structures that are not typedef'd in their .h files */
  528. typedef struct mbuf MBUF;
  529. typedef struct arpcom IDR;                  /* Interface Data Record wrapper */
  530. typedef struct ifnet IFNET;                 /* real Interface Data Record */
  531. typedef struct sockaddr SOCK;
  533. #ifdef DC_DEBUG
  534. typedef struct /* dc_stats */
  535.     {
  536.     /* Transmit Error Stats */
  537.     int txJbrTmo;
  538.     int txLostCarrier;
  539.     int txNoCarrier;
  540.     int txLateCollision;
  541.     int txExsCollision;
  542.     int txHeartBeatFail;
  543.     int txLinkFail;
  544.     int txUnderflow;
  545.     int txDeferred;
  546.     int txRetries;     
  547.     int txDropped;     
  548.     int txFlushCalled;
  549.     int txFlushNeeded;
  550.     int txFlushDone;   
  551.     int txQsizeMax;    
  552.     int txQsizeCur;    
  554.     /* Receive Error Stats */
  555.     int rxFiltrErr;  
  556.     int rxDescErr;   
  557.     int rxRuntFrm;   
  558.     int rxTooLong;   
  559.     int rxCollision; 
  560.     int rxDribbleBit;
  561.     int rxCrcErr;    
  562.     int rxOverflow;  
  563.     int rxMiiErr;    
  564.     int rxMissed;
  565.     int rxLatency;
  566.     int rxStart;
  567.     int rxStop;
  568.     } DC_STATS;
  569. #endif /* DC_DEBUG */
  571. /* The definition of the driver control structure */
  573. typedef struct /* drv_ctrl */
  574.     {
  575.     IDR idr; /* Interface Data Record */
  576.     int dcNumRds; /* RMD ring size */
  577.     int rxIndex;                /* index into RMD ring */
  578.     DC_RDE * rxRing; /* RMD ring */
  579.     int dcNumTds; /* TMD ring size */
  580.     int txIndex; /* index into TMD ring */
  581.     int txDiIndex; /* disposal index into TMD ring */
  582.     DC_TDE * txRing; /* TMD ring */
  583.     BOOL        attached;               /* indicates unit is attached */
  584.     BOOL txFlushScheduled;
  585.     int txCount;
  586.     SEM_ID      TxSem;                  /* transmitter semaphore */
  587.     ULONG dcOpMode; /* mode of operation */
  588.     int         ivec;                   /* interrupt vector */
  589.     int         ilevel;                 /* interrupt level */
  590.     ULONG devAdrs;                /* device structure address */
  591.     ULONG pciMemBase; /* memory base as seen from PCI*/
  592.     int         memWidth;               /* width of data port */
  593.     CACHE_FUNCS cacheFuncs;             /* cache function pointers */
  594.     int nLoanRx; /* number of Rx buffers left to loan */
  595.     char *lPool[DC_L_POOL]; /* receive loaner pool ptrs */
  596.     UINT8 *pRefCnt[DC_L_POOL]; /* stack of reference count pointers */
  597.     UINT8 refCnt[DC_L_POOL]; /* actual reference count values */
  598.     ULONG * pFltrFrm; /* pointer to setup filter frame */
  599.     MediaBlocksType dcMediaBlocks;      /* SROM Media Data */
  600. #ifdef DC_DEBUG
  601.     DC_STATS errStats;
  602. #endif /* DC_DEBUG */
  603.     } DRV_CTRL;
  605. #define DRV_CTRL_SIZ sizeof(DRV_CTRL)
  606. #define RMD_SIZ sizeof(DC_RDE)
  607. #define TMD_SIZ sizeof(DC_TDE)
  608. #define DC_FLUSH_RETRIES 5
  609. #define MAX_TX_RETRIES 2
  611. /* globals */
  613. #ifdef DC_DEBUG
  614. int dcCsrShow (int unit);
  615. int dcViewRom (ULONG devAdrs, UCHAR lineCnt, int cnt);
  616. #endif /* DC_DEBUG */
  618. ULONG dcCSR0Bmr = 0;
  619. BOOL  dcKickStartTx  = DC_KICKSTART_TX;
  621. /* locals */
  623. LOCAL DRV_CTRL  drvCtrl [MAX_UNITS]; /* array of driver control structs */
  624. LOCAL int dcNumRds  = NUM_RDS; /* number of ring descriptors */
  625. LOCAL int dcNumTds  = NUM_TDS; /* number of xmit descriptors */
  626. LOCAL int  dcLPool = DC_L_POOL;
  628. /* forward static functions */
  630. LOCAL void  dcReset (int unit);
  631. LOCAL void  dcInt (DRV_CTRL *pDrvCtrl);
  632. LOCAL void  dcHandleRecvInt (DRV_CTRL *pDrvCtrl);
  633. LOCAL void dcTxRingClean (DRV_CTRL *pDrvCtrl);
  634. LOCAL STATUS  dcRecv (DRV_CTRL *pDrvCtrl, DC_RDE *rmd);
  635. LOCAL void dcTxFlush (DRV_CTRL *pDrvCtrl);
  636. #ifdef BSD43_DRIVER
  637. LOCAL int  dcOutput (IDR *ifp, MBUF *m0, SOCK *dst);
  638. LOCAL void dcStartOutput (int unit);
  639. #else
  640. LOCAL void dcStartOutput (DRV_CTRL *pDrvCtrl);
  641. #endif /* BSD43_DRIVER */
  642. LOCAL int  dcIoctl (IDR *ifp, int cmd, caddr_t data);
  643. LOCAL int  dcChipReset (DRV_CTRL *pDrvCtrl);
  644. LOCAL DC_RDE * dcGetFullRMD (DRV_CTRL *pDrvCtrl);
  645. LOCAL void dc21040AuiTpInit (ULONG devAdrs);
  646. LOCAL void dc21140AuiMiiInit (DRV_CTRL *pDrvCtrl, 
  647.                                    ULONG devAdrs, UINT dcCSR6);
  648. LOCAL void      dcSelectMedia (DRV_CTRL *pDrvCtrl);
  649. LOCAL void  dcCsrWrite (ULONG devAdrs, int reg, ULONG value);
  650. LOCAL ULONG  dcCsrRead (ULONG devAdrs, int reg);
  651. LOCAL void  dcRestart (int unit);
  652. LOCAL STATUS  dcEnetAddrGet (ULONG devAdrs, char * enetAdrs, int len);
  653. LOCAL STATUS  dc21140EnetAddrGet (ULONG devAdrs, char * enetAdrs, int len);
  654. LOCAL void  dcLoanFree (DRV_CTRL *pDrvCtrl, char *pRxBuf, UINT8 *pRef);
  655. LOCAL int dcFltrFrmSetup (DRV_CTRL * pDrvCtrl, char * pPhysAdrsTbl, 
  656. int tblLen);
  657. LOCAL int dcFltrFrmXmit (DRV_CTRL *pDrvCtrl, char * pPhysAdrsTbl,
  658.        int tblLen);
  659. LOCAL USHORT dcMiiPhyRead (DRV_CTRL *pDrvCrl, UINT phyAdrs, UINT phyReg);
  660. LOCAL void dcMiiPhyWrite (DRV_CTRL *pDrvCtrl, UINT phyAdrs,
  661.                                UINT phyReg, USHORT data);
  662. LOCAL USHORT dcReadRom (ULONG devAdrs, UCHAR lineCnt);
  666. /*******************************************************************************
  667. *
  668. * dcInit - device initialization sequence
  669. *
  670. * RETURNS: N/A.
  671. */
  673. LOCAL void dcInit
  674.     (
  675.     ULONG devAdrs
  676.     )
  677.     {
  678.     char dummy_buffer[60];
  679.     DC_TDE tmd;
  681.     tmd.tDesc0 = 0x80000000;
  682.     tmd.tDesc1 = 0xe200003c;
  683.     tmd.tDesc2 = (ULONG)dummy_buffer;
  684.     tmd.tDesc3 = 0;
  686.     /* start xmit dummy packet, this will never go out to the physical bus */
  688.     DC_CSR_WRITE (devAdrs, CSR4, (ULONG)(&tmd));
  689.     DC_CSR_WRITE (devAdrs, CSR7, 0);
  690.     DC_CSR_WRITE (devAdrs, CSR6, 0x2642400);
  691.     DC_CSR_WRITE (devAdrs, CSR1, CSR1_TPD);      /* xmit poll demand */
  692.     DELAY(0x8000);
  694.     /*
  695.      * Reset the device while xmitting, it ensures the device will not hang
  696.      * up in its 1st xmit later on
  697.      */
  699.     DC_CSR_UPDATE (devAdrs, CSR0, CSR0_SWR);
  700.     }
  702. /*******************************************************************************
  703. *
  704. * dcattach - publish the `dc' network interface.
  705. *
  706. * This routine publishes the `dc' interface by filling in a network interface
  707. * record and adding this record to the system list.  This routine also
  708. * initializes the driver and the device to the operational state.
  709. *
  710. * The <unit> parameter is used to specify the device unit to initialize.
  711. *
  712. * The <devAdrs> is used to specify the I/O address base of the device.
  713. *
  714. * The <ivec> parameter is used to specify the interrupt vector associated
  715. * with the device interrupt.
  716. *
  717. * The <ilevel> parater is used to specify the level of the interrupt which
  718. * the device would use.
  719. *
  720. * The <memAdrs> parameter can be used to specify the location of the
  721. * memory that will be shared between the driver and the device.  The value
  722. * NONE is used to indicate that the driver should obtain the memory.
  723. *
  724. * The <memSize> parameter is valid only if the <memAdrs> parameter is not
  725. * set to NONE, in which case <memSize> indicates the size of the
  726. * provided memory region.
  727. *
  728. * The <memWidth> parameter sets the memory pool's data port width (in bytes);
  729. * if it is NONE, any data width is used.
  730. *
  731. * The <pciMemBase> parameter defines the main memory base as seen from PCI bus.
  732. * 
  733. * The <dcOpMode> parameter defines the mode in which the device should be
  734. * operational.
  735. *
  736. * BUGS
  737. *
  738. * To zero out DEC 21x4x data structures, this routine uses bzero(), which
  739. * ignores the <memWidth> specification and uses any size data access to write
  740. * to memory.
  741. *
  742. * RETURNS: OK or ERROR.
  743. */
  745. STATUS dcattach
  746.     (
  747.     int unit, /* unit number */
  748.     ULONG devAdrs, /* device I/O address */
  749.     int ivec, /* interrupt vector */
  750.     int ilevel, /* interrupt level */
  751.     char * memAdrs, /* address of memory pool (-1 = malloc it) */
  752.     ULONG memSize, /* only used if memory pool is NOT malloc()'d */
  753.     int memWidth, /* byte-width of data (-1 = any width) */
  754.     ULONG pciMemBase, /* main memory base as seen from PCI bus */
  755.     int dcOpMode /* mode of operation */
  756.     )
  757.     {
  758.     DRV_CTRL * pDrvCtrl; /* pointer to drvctrl */
  759.     unsigned int sz; /* temporary size holder */
  760.     char * pShMem; /* start of the device memory pool */
  761.     char * buf; /* temp buffer pointer */
  762.     void * pTemp; /* temp pointer */
  763.     DC_RDE * rmd; /* pointer to rcv descriptor */
  764.     DC_TDE * tmd; /* pointer to xmit descriptor */
  765.     int ix; /* counter */
  766.     ULONG uTemp; /* temporary storage */
  767.     int retVal;
  768.    
  769.     /* Sanity check the unit number */
  771.     if (unit < 0 || unit >= MAX_UNITS)
  772.         return (ERROR);
  774.     uTemp = 0;
  776.     /* Ensure single invocation per system life */
  778.     pDrvCtrl = & drvCtrl [unit];
  780.     if (pDrvCtrl->attached)
  781.         return (OK);
  783.     pDrvCtrl->ivec = ivec; /* interrupt vector */
  784.     pDrvCtrl->ilevel = ilevel; /* interrupt level */
  785.     pDrvCtrl->devAdrs = devAdrs; /* device I/O address */
  786.     pDrvCtrl->pciMemBase  = pciMemBase; /* pci memory base */
  787.     pDrvCtrl->memWidth  = memWidth; /* memory width */
  788.     pDrvCtrl->dcOpMode = (dcOpMode == NONE) ? 0 : dcOpMode; /* operation mode */
  790.     /* Publish the interface data record */
  792. #ifdef BSD43_DRIVER
  793.     ether_attach (
  794.   & pDrvCtrl->idr.ac_if,
  795.   unit,
  796.   "dc",
  797.   (FUNCPTR) NULL,
  798.   (FUNCPTR) dcIoctl,
  799.   (FUNCPTR) dcOutput,
  800.   (FUNCPTR) dcReset
  801.  );
  802. #else
  803.     ether_attach (
  804.                  (IFNET *) &pDrvCtrl->idr,
  805.                  unit,
  806.                  "dc",
  807.                  (FUNCPTR) NULL,
  808.                  (FUNCPTR) dcIoctl,
  809.                  (FUNCPTR) ether_output,
  810.                  (FUNCPTR) dcReset
  811.                  );
  813.      pDrvCtrl->idr.ac_if.if_start = (FUNCPTR) dcStartOutput;
  814. #endif /* BSD43_DRIVER */
  816. #ifdef DC_DEBUG
  817.     bzero ((char *)&pDrvCtrl->errStats, sizeof (DC_STATS));
  818. #endif /* DC_DEBUG */
  820.     dcInit(pDrvCtrl->devAdrs);
  822.     /* Create the transmit semaphore. */
  824.     if ((pDrvCtrl->TxSem = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE |
  825.        SEM_INVERSION_SAFE)) == NULL)
  826.         {
  827.         printf ("dc: error creating transmitter semaphoren");
  828.         return (ERROR);
  829.         }
  831.     /* Establish size of shared memory region we require */
  833.     if ((int) memAdrs != NONE)  /* specified memory pool */
  834. {
  835. sz  = ((memSize - FLTR_FRM_SIZE + RMD_SIZ + TMD_SIZ) /
  836.                ((3 * DC_BUFSIZ) + RMD_SIZ + TMD_SIZ));
  837. dcNumRds = max (sz, MIN_RDS);
  838. dcNumTds = max (sz, MIN_TDS);
  839.         dcLPool = min (dcNumRds, DC_L_POOL);
  840. }
  842.     /* add it all up - allow for alignment adjustment */
  844.     sz = ((dcNumRds + 1) * RMD_SIZ) + (dcNumRds * DC_BUFSIZ) +
  845.  ((dcNumTds + 1) * TMD_SIZ) + (dcNumTds * DC_BUFSIZ) + 
  846.  (DC_BUFSIZ * dcLPool) + FLTR_FRM_SIZE;
  848.     /* Establish a region of shared memory */
  850.     /*
  851.      * OK. We now know how much shared memory we need.  If the caller
  852.      * provides a specific memory region, we check to see if the provided
  853.      * region is large enough for our needs.  If the caller did not
  854.      * provide a specific region, then we attempt to allocate the memory
  855.      * from the system, using the cache aware allocation system call.
  856.      */
  858.     switch ((int) memAdrs)
  859.         {
  860.         default :       /* caller provided memory */
  861.             if (memSize < sz)     /* not enough space */
  862.                 {
  863.                 printf ("dc: not enough memory providedn");
  864.                 return (ERROR);
  865.                 }
  866.             else
  867.                 dcNumRds += (memSize - sz) / (DC_BUFSIZ + TMD_SIZ);
  869.             pShMem = memAdrs;             /* set the beginning of pool */
  871.             /* assume pool is cache coherent, copy null structure */
  873.             pDrvCtrl->cacheFuncs = cacheNullFuncs;
  875.             break;
  877.         case NONE :     /* get our own memory */
  879.             /*
  880.      * Because the structures that are shared between the device
  881.              * and the driver may share cache lines, the possibility exists
  882.              * that the driver could flush a cache line for a structure and
  883.              * wipe out an asynchronous change by the device to a neighboring
  884.              * structure. Therefore, this driver cannot operate with memory
  885.              * that is not write coherent.  We check for the availability of
  886.              * such memory here, and abort if the system did not give us what
  887.              * we need.
  888.              */
  890.             if (!CACHE_DMA_IS_WRITE_COHERENT ())
  891.                 {
  892.                 printf ("dc: device requires cache coherent memoryn");
  893.                 return (ERROR);
  894.                 }
  896.             pShMem = (char *) cacheDmaMalloc (sz);
  898.             if ((int)pShMem == NULL)
  899.                 {
  900.                 printf ("dc: system memory unavailablen");
  901.                 return (ERROR);
  902.                 }
  904.             /* copy the DMA structure */
  906.             pDrvCtrl->cacheFuncs = cacheDmaFuncs;
  908.             break;
  909.         }
  911.     SYS_INT_CONNECT(pDrvCtrl, dcInt, pDrvCtrl, &retVal);
  912.     if (retVal == ERROR)
  913.         return (ERROR);
  915.     /*           Turkey Carving
  916.      *           --------------
  917.      *
  918.      *             LOW MEMORY
  919.      * |-------------------------------------|
  920.      * |         The Rx descriptors          |
  921.      * | (dcNumRds * sizeof (DC_RDE))        |
  922.      * |-------------------------------------|
  923.      * |          The receive buffers        |
  924.      * |       (DC_BUFSIZ * dcNumRds)        |
  925.      * |-------------------------------------|
  926.      * |         The Rx loaner pool          |
  927.      * |        (DC_BUFSIZ * dcLPool)        |
  928.      * |-------------------------------------|
  929.      * |         The Tx descriptors          |
  930.      * | (dcNumTds *  sizeof (DC_TDE))       |
  931.      * |-------------------------------------|
  932.      * |           The transmit buffers      |
  933.      * |       (DC_BUFSIZ * dcNumTds)        |
  934.      * |-------------------------------------|
  935.      * |           Setup Filter Frame        |
  936.      * |           (FLTR_FRM_SIZE)           |
  937.      * |-------------------------------------|
  938.      */
  940.     /* zero the shared memory */
  942.     bzero ( (char *) pShMem, (int) sz );
  944.     /* carve Rx memory structure */
  946.     pDrvCtrl->rxRing = (DC_RDE *) (((int)pShMem + 0x03) & ~0x03); /* wd align */
  947.     pDrvCtrl->dcNumRds = dcNumRds; /* receive ring size */
  948.     pDrvCtrl->rxIndex = 0;
  950.     /* Set up the Rx descriptors */
  952.     rmd = pDrvCtrl->rxRing;                      /* receive ring */
  953.     buf = (char *)(rmd + pDrvCtrl->dcNumRds);
  954.     for (ix = 0; ix < pDrvCtrl->dcNumRds; ix++, rmd++, buf += DC_BUFSIZ)
  955.         {
  956.         pTemp = DC_CACHE_VIRT_TO_PHYS (buf); /* convert to PCI  phys addr */
  957. pTemp = (void *)(MEM_TO_PCI_PHYS((ULONG)pTemp));
  958. rmd->rDesc2 = PCISWAP((ULONG)pTemp); /* buffer address 1 */
  959. rmd->rDesc3 = 0; /* no second buffer */
  961. /* buffer size */
  963. rmd->rDesc1 = PCISWAP(RDESC1_RBS1_VAL(DC_BUFSIZ) | 
  964.       RDESC1_RBS2_VAL(0));
  966. if (ix == (pDrvCtrl->dcNumRds - 1)) /* if its is last one */
  967.          rmd->rDesc1 |= PCISWAP(RDESC1_RER); /* end of receive ring */
  969. rmd->rDesc0 = PCISWAP(RDESC0_OWN); /* give ownership to lance */
  970.         }
  972.     /* setup Rx loaner pool */
  974.     pDrvCtrl->nLoanRx = dcLPool;
  975.     for (ix = 0; ix < dcLPool; ix++, buf += DC_BUFSIZ)
  976. {
  977.         pDrvCtrl->lPool[ix] = buf;
  978.         pDrvCtrl->refCnt[ix] = 0;
  979.         pDrvCtrl->pRefCnt[ix] = & pDrvCtrl->refCnt[ix];
  980. }
  982.     /* carve Tx memory structure */
  984.     pDrvCtrl->txRing = (DC_TDE *) (((int)buf + 0x03) & ~0x03); /* word align */
  985.     pDrvCtrl->dcNumTds = dcNumTds; /* transmit ring size */
  986.     pDrvCtrl->txIndex = 0;
  987.     pDrvCtrl->txDiIndex = 0;
  989.     /* Setup the Tx descriptors */
  991.     tmd = pDrvCtrl->txRing;                 /* transmit ring */
  992.     buf = (char *)(tmd + pDrvCtrl->dcNumTds);
  993.     for (ix = 0; ix < pDrvCtrl->dcNumTds; ix++, tmd++, buf += DC_BUFSIZ)
  994.         {
  995.         pTemp = DC_CACHE_VIRT_TO_PHYS (buf); /* convert to PCI phys addr */
  996. pTemp = (void *)(MEM_TO_PCI_PHYS((ULONG)pTemp));
  997. tmd->tDesc2 = PCISWAP((ULONG)pTemp); /* buffer address 1 */
  998. tmd->tDesc3 = 0; /* no second buffer */
  1000. tmd->tDesc1 = PCISWAP((TDESC1_TBS1_PUT(0) |
  1001.        TDESC1_TBS2_PUT(0) |
  1002.        TDESC1_IC   |  /* intrpt on xmit */
  1003.        TDESC1_LS          | /* last segment */
  1004.        TDESC1_FS)); /* first segment */
  1006. if (ix == (pDrvCtrl->dcNumTds - 1)) /* if its is last one */
  1007.     tmd->tDesc1 |= PCISWAP(TDESC1_TER); /* end of Xmit ring */
  1009. tmd->tDesc0 = 0 ; /* clear status */
  1010.         }
  1012.     /* carve Setup Filter Frame buffer */
  1013.     
  1014.     pDrvCtrl->pFltrFrm = (ULONG *)(((int)buf + 0x03) & ~0x03); /* word align */
  1015.     buf += FLTR_FRM_SIZE;
  1017.     /* Flush the write pipe */
  1019.     CACHE_PIPE_FLUSH ();
  1021.     /* Device Initialization */
  1023.     dcChipReset (pDrvCtrl); /* reset the chip */
  1025.     pTemp = DC_CACHE_VIRT_TO_PHYS (pDrvCtrl->rxRing);
  1026.     pTemp = (void *)(MEM_TO_PCI_PHYS((ULONG)pTemp));
  1028.     DC_CSR_WRITE (devAdrs, CSR3, ((ULONG)pTemp)); /* recv descriptor */
  1030.     pTemp = DC_CACHE_VIRT_TO_PHYS (pDrvCtrl->txRing);
  1031.     pTemp = (void *)(MEM_TO_PCI_PHYS((ULONG)pTemp));
  1033.     DC_CSR_WRITE (devAdrs, CSR4, ((ULONG)pTemp)); /* xmit descriptor */
  1035.     /* get the ethernet address */
  1037.     if (!DEC21140(pDrvCtrl->dcOpMode))
  1038.      {
  1039.         if (dcEnetAddrGet (devAdrs, (char *) pDrvCtrl->idr.ac_enaddr, 6) != OK)
  1040.     logMsg ("dc: error reading ethernet romn", 0,0,0,0,0,0);
  1041.      }
  1042.     else
  1043.      {
  1044.         if (dc21140EnetAddrGet (devAdrs, (char *) pDrvCtrl->idr.ac_enaddr, 6) 
  1045.     != OK)
  1046.     logMsg ("dc21140: error reading ethernet romn", 0,0,0,0,0,0);
  1047.      }
  1049.     if (!DEC21140(pDrvCtrl->dcOpMode))
  1050.      {
  1051.         dc21040AuiTpInit (devAdrs); /* configure AUI or 10BASE-T */
  1052. DC_CSR_WRITE (devAdrs, CSR6, 0x0);
  1053.         pDrvCtrl->dcMediaBlocks.DontSwitch = 1;
  1054.      }
  1055.     else
  1056.      {
  1057. DC_CSR_WRITE (devAdrs, CSR6, 0x0);
  1058.         dc21140AuiMiiInit (pDrvCtrl, devAdrs, uTemp);
  1059.      }
  1061.     if ((pDrvCtrl->dcOpMode & DC_FULLDUPLEX_FLAG) && 
  1062. (pDrvCtrl->dcOpMode != NONE))
  1063.         DC_CSR_UPDATE (devAdrs, CSR6, CSR6_FD);
  1065.     /* clear the status register */
  1067.     DC_CSR_WRITE (devAdrs, CSR5, 0xffffffff);
  1069.     /* set the operating mode to start Xmitter only */
  1071.     DC_CSR_UPDATE (devAdrs, CSR6, (CSR6_ST | CSR6_BIT25));
  1073.     if ((pDrvCtrl->dcOpMode & DC_ILOOPB_FLAG) &&
  1074. (pDrvCtrl->dcOpMode != NONE))
  1075.         DC_CSR_UPDATE (devAdrs, CSR6, CSR6_OM_ILB);
  1076.     else if ((pDrvCtrl->dcOpMode & DC_ELOOPB_FLAG) &&
  1077.              (pDrvCtrl->dcOpMode != NONE))
  1078.         DC_CSR_UPDATE (devAdrs, CSR6, CSR6_OM_ELB);
  1080.     /* Xmit a Filter Setup Frame */
  1082.     dcFltrFrmXmit (pDrvCtrl, (char *) pDrvCtrl->idr.ac_enaddr, 1);
  1084.     /* start the receiver with multicast and promiscuous mode, if needed */
  1086.     DC_CSR_UPDATE (devAdrs, CSR6,
  1087.                    (CSR6_SR | 
  1088.                     ((pDrvCtrl->dcOpMode & DC_MULTICAST_FLAG) ? CSR6_PM: 0) |
  1089.                     ((pDrvCtrl->dcOpMode & DC_PROMISCUOUS_FLAG) ? CSR6_PR: 0)));
  1091.     /* set up the interrupts */
  1093.     if (!DEC21140(pDrvCtrl->dcOpMode))
  1094.      DC_CSR_WRITE (devAdrs, CSR7, (
  1095.        CSR7_NIM | /* normal interrupt mask */
  1096.        CSR7_AIM | /* abnormal interrupt mask */
  1097.        CSR7_SEM | /* system error mask */
  1098.        CSR7_RIM | /* rcv  interrupt mask */
  1099.        CSR7_RUM | /* rcv buff unavailable mask */
  1100.        CSR7_TUM  /* xmit buff unavailble mask */
  1101.        ));
  1102.     else
  1103.      DC_CSR_WRITE (devAdrs, CSR7, (
  1104.        CSR7_NIM | /* normal interrupt mask */
  1105.        CSR7_AIM | /* abnormal interrupt mask */
  1106.        CSR7_SEM | /* system error mask */
  1107.        CSR7_RIM | /* rcv  interrupt mask */
  1108.        CSR7_RUM | /* rcv buff unavailable mask */
  1109.        CSR7_TUM  /* xmit buff unavailble mask */
  1110.        ));
  1112.     SYS_INT_ENABLE (pDrvCtrl);
  1114.     pDrvCtrl->idr.ac_if.if_flags |= ((IFF_UP | IFF_RUNNING | IFF_NOTRAILERS) | 
  1115.                        ((dcOpMode & DC_PROMISCUOUS_FLAG) ? IFF_PROMISC : 0) | 
  1116.                        ((dcOpMode & DC_MULTICAST_FLAG) ? IFF_ALLMULTI : 0));
  1118.     /* Set our flag */
  1120.     pDrvCtrl->attached = TRUE;
  1121.     pDrvCtrl->txFlushScheduled = FALSE;
  1123.     return (OK);
  1124.     }
  1126. /*******************************************************************************
  1127. *
  1128. * dcReset - reset the interface
  1129. *
  1130. * Mark interface as inactive & reset the chip
  1131. */
  1133. LOCAL void dcReset
  1134.     (
  1135.     int unit
  1136.     )
  1137.     {
  1138.     DRV_CTRL *pDrvCtrl = & drvCtrl [unit];
  1140.     pDrvCtrl->idr.ac_if.if_flags = 0;
  1141.     dcChipReset (pDrvCtrl);                           /* reset device */
  1142.     }
  1144. /*******************************************************************************
  1145. *
  1146. * dcInt - handle controller interrupt
  1147. *
  1148. * This routine is called at interrupt level in response to an interrupt from
  1149. * the controller.
  1150. */
  1152. LOCAL void dcInt
  1153.     (
  1154.     DRV_CTRL * pDrvCtrl /* pointer to device control struct */
  1155.     )
  1156.     {
  1157.     ULONG stat; /* status register */
  1158.     ULONG devAdrs; /* device address */
  1160.     devAdrs = pDrvCtrl->devAdrs;
  1162.     /* Read the device status register */
  1164.     stat = DC_CSR_READ (devAdrs, CSR5);
  1166.     /* clear the interrupts */
  1168.     DC_CSR_WRITE (devAdrs, CSR5, stat);
  1169.     stat &= DC_CSR_READ (devAdrs, CSR7);
  1171.     /* If false interrupt, return. */
  1173.     if ( ! (stat & (CSR5_NIS | CSR5_AIS)) ) 
  1174.         return;
  1176.     /* Check for system error */
  1178.     if (stat & CSR5_SE)
  1179.         {
  1180.         ++pDrvCtrl->idr.ac_if.if_ierrors;
  1181.     
  1182.         /* restart chip on fatal error */
  1184.         pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
  1185.     
  1186.         netJobAdd ((FUNCPTR)dcRestart, pDrvCtrl->idr.ac_if.if_unit, 0,0,0,0);
  1187.         }
  1188.     
  1189.     /* Have netTask handle any input packets */
  1191.     if (stat & (CSR5_RI | CSR5_RU))
  1192.         {
  1193.         DC_INT_DISABLE (devAdrs, CSR7_RIM);
  1194.         netJobAdd ((FUNCPTR)dcHandleRecvInt, (int)pDrvCtrl, 0, 0, 0, 0);
  1195.         }
  1197.     if ((stat & CSR5_TU) && pDrvCtrl->idr.ac_if.if_snd.ifq_len &&
  1198.         (! pDrvCtrl->txFlushScheduled))
  1199.         {
  1200.         pDrvCtrl->txFlushScheduled = TRUE;
  1201.         netJobAdd ((FUNCPTR) dcTxFlush, (int) pDrvCtrl, 0, 0, 0, 0);
  1202.         }
  1204.     return;
  1205.     }
  1207. /*******************************************************************************
  1208. *
  1209. * dcHandleRecvInt - task level interrupt service for input packets
  1210. *
  1211. * This routine is called at task level indirectly by the interrupt
  1212. * service routine to do any message received processing.
  1213. */
  1215. LOCAL void dcHandleRecvInt
  1216.     (
  1217.     DRV_CTRL * pDrvCtrl /* pointer to device control struct */
  1218.     )
  1219.     {
  1220.     DC_RDE * rmd; /* pointer to Rx ring descriptor */
  1222.     while ((rmd = dcGetFullRMD (pDrvCtrl)) != NULL)
  1223.         dcRecv (pDrvCtrl, rmd);
  1225.     DC_INT_ENABLE (pDrvCtrl->devAdrs, CSR7_RIM);
  1227.     while ((rmd = dcGetFullRMD (pDrvCtrl)) != NULL)
  1228.         dcRecv (pDrvCtrl, rmd);
  1230. #ifdef DC_DEBUG
  1231.     pDrvCtrl->errStats.rxMissed += (DC_CSR_READ (pDrvCtrl->devAdrs, CSR8) &
  1232.                                     (CSR8_MFO | CSR8_MFC_MSK));
  1233. #endif /* DC_DEBUG */
  1235.     return;
  1236.     }
  1239. /*******************************************************************************
  1240. *
  1241. * dcTxRingClean - cleans up the transmit ring
  1242. *
  1243. * This routine is called at task level in the context of dcOutput() or
  1244. * tNetTask by dcTxFlush() to collect statistics, and mark "free" all
  1245. * descriptors consumed by the device.
  1246. */
  1248. LOCAL void dcTxRingClean
  1249.     (
  1250.     DRV_CTRL *pDrvCtrl
  1251.     )
  1252.     {
  1253.     DC_TDE *    tmd;            /* pointer to Xmit ring descriptor */
  1255.     while (pDrvCtrl->txDiIndex != pDrvCtrl->txIndex)
  1256.         {
  1257.         /* disposal has not caught up */
  1259.         tmd = pDrvCtrl->txRing + pDrvCtrl->txDiIndex;
  1261.         /* if the buffer is still owned by device, don't touch it */
  1263.         DC_CACHE_INVALIDATE (tmd, TMD_SIZ);
  1264.         if (tmd->tDesc0 & PCISWAP(TDESC0_OWN))
  1265.             break;
  1267.         /* now bump the tmd disposal index pointer around the ring */
  1269.         pDrvCtrl->txDiIndex = (pDrvCtrl->txDiIndex + 1) % pDrvCtrl->dcNumTds;
  1270.         pDrvCtrl->txCount--;
  1272. #ifdef DC_DEBUG
  1273.         {
  1274.         UINT tdesc0 = PCISWAP(tmd->tDesc0);
  1275.         DC_STATS * pErrStats = &pDrvCtrl->errStats;
  1277.         if (tdesc0 & TDESC0_TO)
  1278.             pErrStats->txJbrTmo++;
  1280.         if (tdesc0 & TDESC0_LO)
  1281.             pErrStats->txLostCarrier++;
  1283.         if (tdesc0 & TDESC0_NC)
  1284.             pErrStats->txNoCarrier++;
  1286.         if (tdesc0 & TDESC0_LC)
  1287.             pErrStats->txLateCollision++;
  1289.         if (tdesc0 & TDESC0_HF)
  1290.             pErrStats->txHeartBeatFail++;
  1292.         if (tdesc0 & TDESC0_LF)
  1293.             pErrStats->txLinkFail++;
  1295.         if (tdesc0 & TDESC0_UF)
  1296.             pErrStats->txUnderflow++;
  1298.         if (tdesc0 & TDESC0_DE)
  1299.             pErrStats->txDeferred++;
  1300.         }
  1301. #endif /* DC_DEBUG */
  1303.         /*
  1304.          * TDESC0_ES is an "OR" of LC, NC, UF, EC.
  1305.          * here for error conditions.
  1306.          */
  1308.         if (tmd->tDesc0 & PCISWAP(TDESC0_ES)) 
  1309.     {
  1310.             /* check for no carrier */
  1312. #if 0  /* HELP */
  1313.             if ((tmd->tDesc0 & PCISWAP(TDESC0_NC | TDESC0_LO | TDESC0_LF)) &&
  1314.                 (pDrvCtrl->dcMediaBlocks.DontSwitch == 0)) 
  1315. {
  1316. dcSelectMedia (pDrvCtrl);
  1317. return;
  1318. }
  1319.             pDrvCtrl->dcMediaBlocks.DontSwitch = 1;
  1320. #endif
  1322.             pDrvCtrl->idr.ac_if.if_oerrors++;     /* output error */
  1323.             pDrvCtrl->idr.ac_if.if_opackets--;
  1325.             /*
  1326.      * If error was due to excess collisions, bump the collision
  1327.              * counter.
  1328.              */
  1330.             if (tmd->tDesc0 & PCISWAP(TDESC0_EC)) 
  1331. pDrvCtrl->idr.ac_if.if_collisions += 16;
  1333.     /* bump the collision counter if late collision */
  1335.     if (tmd->tDesc0 & PCISWAP(TDESC0_LC)) 
  1336. pDrvCtrl->idr.ac_if.if_collisions++;
  1339.     /* check for no carrier */
  1340. #if 0 /* HELP */
  1341.     if (tmd->tDesc0 & PCISWAP(TDESC0_NC | TDESC0_LO | TDESC0_LF)) 
  1342. {
  1343. logMsg ("dc%d: no carriern",
  1344. pDrvCtrl->idr.ac_if.if_unit, 0,0,0,0,0);
  1345. dcSelectMedia (pDrvCtrl);
  1346. }
  1347. #endif
  1349.             /*
  1350.      * Restart chip on fatal errors.
  1351.              * The following code handles the situation where the transmitter
  1352.              * shuts down due to an underflow error.  This is a situation that
  1353.              * will occur if the DMA cannot keep up with the transmitter.
  1354.              * It will occur if the device is being held off from DMA access
  1355.              * for too long or due to significant memory latency.  DRAM
  1356.              * refresh or slow memory could influence this.  Many
  1357.              * implementation use a dedicated device buffer.  This can be
  1358.              * static RAM to eliminate refresh conflicts; or dual-port RAM
  1359.              * so that the device can have free run of this memory during its
  1360.              * DMA transfers.
  1361.              */
  1363.             if (tmd->tDesc0 & PCISWAP(TDESC0_UF))
  1364.                 {
  1365.                 pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
  1366.                 netJobAdd ((FUNCPTR)dcRestart, pDrvCtrl->idr.ac_if.if_unit,
  1367.                            0,0,0,0 );
  1368.                 return;
  1369.                 }
  1370.             }
  1371. tmd->tDesc0 = 0; /* clear all error & stat stuff */
  1372.         }
  1374.     /* Flush the write pipe */
  1376.     CACHE_PIPE_FLUSH ();
  1377.     }
  1379. /*******************************************************************************
  1380. *
  1381. * dcGetFullRMD - get next received message RMD
  1382. *
  1383. * Returns ptr to next Rx desc to process, or NULL if none ready.
  1384. */
  1386. LOCAL DC_RDE * dcGetFullRMD
  1387.     (
  1388.     DRV_CTRL * pDrvCtrl /* pointer to device control struct */
  1389.     )
  1390.     {
  1391.     DC_RDE * rmd; /* pointer to Rx ring descriptor */
  1393.     /* Refuse to do anything if flags are down */
  1395.     if  (
  1396.         (pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING) ) !=
  1397.         (IFF_UP | IFF_RUNNING)
  1398.         )
  1399.         return ((DC_RDE *) NULL);
  1402.     rmd = pDrvCtrl->rxRing + pDrvCtrl->rxIndex;       /* form ptr to Rx desc */
  1404.     DC_CACHE_INVALIDATE (rmd, RMD_SIZ);
  1406.     if ((rmd->rDesc0 & PCISWAP(RDESC0_OWN)) == 0)
  1407.         return (rmd);
  1408.     else
  1409.         return ((DC_RDE *) NULL);
  1410.     }
  1412. /*******************************************************************************
  1413. *
  1414. * dcRecv - process the next incoming packet
  1415. *
  1416. */
  1418. LOCAL STATUS dcRecv
  1419.     (
  1420.     DRV_CTRL * pDrvCtrl, /* pointer to device control struct */
  1421.     DC_RDE * rmd /* pointer to Rx ring descriptor */
  1422.     )
  1423.     {
  1424.     ENET_HDR * pEnetHdr; /* pointer to ethernet header */
  1425.     MBUF * pMbuf = NULL; /* pointer to mbuf */
  1426.     u_long pPhys;
  1427.     UCHAR * pData; /* pointer to data */
  1428.     int len; /* length */
  1429.     USHORT ether_type; /* ether packet type */
  1430. #ifdef DC_DEBUG
  1431.     UINT32 rdesc0; /* desc0 status word */
  1432. #endif /* DC_DEBUG */
  1435. #ifdef DC_DEBUG
  1436.     rdesc0 = rmd->rDesc0;
  1438.     if (rdesc0 & PCISWAP(0x40000000))
  1439.         pDrvCtrl->errStats.rxFiltrErr++;
  1440.     
  1441.     if (rdesc0 & PCISWAP(0x00004000))
  1442.         pDrvCtrl->errStats.rxDescErr++;
  1443.         
  1444.     if  (rdesc0 & PCISWAP(RDESC0_RF))
  1445.         pDrvCtrl->errStats.rxRuntFrm++;
  1447.     if  (rdesc0 & PCISWAP(RDESC0_TL))
  1448.         pDrvCtrl->errStats.rxTooLong++;
  1450.     if  (rdesc0 & PCISWAP(RDESC0_CS))
  1451.         pDrvCtrl->errStats.rxCollision++;
  1453.     if  (rdesc0 & PCISWAP(0x00000008))
  1454.         pDrvCtrl->errStats.rxMiiErr++;
  1456.     if  (rdesc0 & PCISWAP(RDESC0_DB))
  1457.         pDrvCtrl->errStats.rxDribbleBit++;
  1459.     if  (rdesc0 & PCISWAP(RDESC0_CE))
  1460.         pDrvCtrl->errStats.rxCrcErr++;
  1461. #endif /* DC_DEBUG */
  1463.     /* Discard if we have errors */
  1464.     if  (rmd->rDesc0 & PCISWAP(RDESC0_ES))
  1465.         {
  1466.         ++pDrvCtrl->idr.ac_if.if_ierrors;       /* bump error stat */
  1467.         goto cleanRXD;
  1468.         }
  1470.     /* Process clean packets */
  1471.     ++pDrvCtrl->idr.ac_if.if_ipackets; /* bump statistic */
  1473.     len = RDESC0_FL_GET(PCISWAP(rmd->rDesc0)); /* frame length */
  1475.     len -= 4;  /* Frame length includes CRC in it so subtract it */
  1477.     /* Get pointer to packet */
  1479.     pEnetHdr = DC_CACHE_PHYS_TO_VIRT(PCI_TO_MEM_PHYS(PCISWAP(rmd->rDesc2)));
  1481.     DC_CACHE_INVALIDATE (pEnetHdr, len);   /* make the packet data coherent */
  1483.     /* call input hook if any */
  1485.     if ((etherInputHookRtn == NULL) || ((*etherInputHookRtn)
  1486.        (& pDrvCtrl->idr.ac_if, (char *) pEnetHdr, len)) == 0)
  1487.         {
  1488.         /* Adjust length to size of data only */
  1490.         len -= SIZEOF_ETHERHEADER;
  1492.         /* Get pointer to packet data */
  1494.         pData = ((u_char *) pEnetHdr) + SIZEOF_ETHERHEADER;
  1496.         ether_type = ntohs ( pEnetHdr->type );
  1498.         /* OK to loan out buffer ? -> build an mbuf cluster */
  1499.     
  1500. if ((pDrvCtrl->nLoanRx > 0) && (USE_CLUSTER (len))
  1501.     && (pMbuf = BUILD_CLUSTER (pDrvCtrl, pEnetHdr, pData, len)))
  1502.     {
  1503.             pPhys = (u_long) DC_CACHE_VIRT_TO_PHYS(MEM_TO_PCI_PHYS(
  1504.     (pDrvCtrl->lPool[--pDrvCtrl->nLoanRx])));
  1505.     rmd->rDesc2 = PCISWAP(pPhys);
  1506.     }
  1507.         else
  1508.             {
  1509.             if ((pMbuf = bcopy_to_mbufs (pData, len, 0, & pDrvCtrl->idr.ac_if,
  1510.                 pDrvCtrl->memWidth)) == NULL)
  1511. {
  1512.                 ++pDrvCtrl->idr.ac_if.if_ierrors; /* bump error stat */
  1513.                 goto cleanRXD;
  1514. }
  1515.             }
  1517.         /* send on up... */
  1519.         do_protocol_with_type (ether_type, pMbuf, &pDrvCtrl->idr, len);
  1520.         }
  1522.     /* Done with descriptor, clean up and give it to the device. */
  1524. cleanRXD:
  1526.     /* clear status bits and give ownership to device */
  1528.     rmd->rDesc0 = PCISWAP(RDESC0_OWN);
  1530.     /* Flush the write pipe */
  1532.     CACHE_PIPE_FLUSH ();
  1534.     /* Advance our management index */
  1536.     pDrvCtrl->rxIndex = (pDrvCtrl->rxIndex + 1) % pDrvCtrl->dcNumRds;
  1538.     return (OK);
  1539.     }
  1541. #ifdef BSD43_DRIVER
  1542. /*******************************************************************************
  1543. *
  1544. * dcOutput - driver output routine
  1545. *
  1546. * This routine is called by the stack to transmit an mbuf.
  1547. * This routine is called by the stack to transmit an mbuf.
  1548. */
  1550. LOCAL int dcOutput
  1551.     (
  1552.     IDR  * pIDR, /* pointer to interface data record */
  1553.     MBUF * pMbuf, /* pointer to mbuf */
  1554.     SOCK * pDest /* pointer to destination sock */
  1555.     )
  1556.     {
  1557.     int  unit = ((IFNET *)pIDR)->if_unit;
  1558.     DRV_CTRL * pDrvCtrl = &drvCtrl[unit];
  1559.     int errorVal;
  1561.     errorVal =  ether_output ((IFNET *)pIDR, pMbuf, pDest,
  1562.                                (FUNCPTR) dcStartOutput, pIDR);
  1564.     if ((errorVal == ENOBUFS) && !pDrvCtrl->txFlushScheduled)
  1565.         {
  1566. #ifdef DC_DEBUG
  1567.         pDrvCtrl->errStats.txDropped++;
  1568. #endif /* DC_DEBUG */
  1569.         dcTxFlush (pDrvCtrl);
  1570.         }
  1571.     
  1572.     return (errorVal);
  1573.     }
  1574. #endif /* BSD43_DRIVER */
  1576. /*******************************************************************************
  1577. *
  1578. * dcTxFlush - flush enqueued transmit buffers
  1579. *
  1580. */
  1582. LOCAL void dcTxFlush
  1583.     (
  1584.     DRV_CTRL * pDrvCtrl
  1585.     )
  1586.     {
  1587.     int retry;
  1588.     int delayCount;
  1590. #ifdef DC_DEBUG
  1591.     pDrvCtrl->errStats.txFlushCalled++;
  1592.     if (pDrvCtrl->idr.ac_if.if_snd.ifq_len)
  1593.         pDrvCtrl->errStats.txFlushNeeded++;
  1594. #endif /* DC_DEBUG */
  1596.     retry = DC_FLUSH_RETRIES;
  1597.     while (pDrvCtrl->idr.ac_if.if_snd.ifq_len && retry)
  1598.         {
  1599.         dcTxRingClean (pDrvCtrl);
  1601.         if (DC_TD_INDEX_NEXT(pDrvCtrl) != pDrvCtrl->txDiIndex)
  1602.             DC_START_OUTPUT (pDrvCtrl);
  1603.         else
  1604.             {
  1605.             for (delayCount=1000; delayCount--;)
  1606.                 ;
  1607.             retry--;
  1608.             }
  1609.         }
  1611. #ifdef DC_DEBUG
  1612.     if (pDrvCtrl->idr.ac_if.if_snd.ifq_len == 0)
  1613.         pDrvCtrl->errStats.txFlushDone++;
  1614. #endif /* DC_DEBUG */
  1616.     pDrvCtrl->txFlushScheduled = FALSE;
  1617.     }
  1618.     
  1619. /*******************************************************************************
  1620. *
  1621. * dcStartOutput - send transmit buffers
  1622. *
  1623. */
  1625. LOCAL void dcStartOutput
  1626.     (
  1627. #   ifdef BSD43_DRIVER
  1628.     int unit
  1629. #   else
  1630.     DRV_CTRL * pDrvCtrl
  1631. #   endif /* BSD43_DRIVER */
  1632.     )
  1633.     {
  1634. #   ifdef BSD43_DRIVER    
  1635.     DRV_CTRL * pDrvCtrl = &drvCtrl[unit];
  1636. #   endif /* BSD43_DRIVER */    
  1638.     DC_TDE * pTxD;
  1639.     MBUF * pMbuf;
  1640.     char *  pTxdBuf;
  1641.     int bufLen;
  1642.     int retries;
  1644. #ifdef DC_DEBUG
  1645.     pDrvCtrl->errStats.txQsizeCur=pDrvCtrl->idr.ac_if.if_snd.ifq_len;
  1646. #endif /* DC_DEBUG */
  1647.     retries = MAX_TX_RETRIES;
  1648.     while (pDrvCtrl->idr.ac_if.if_snd.ifq_len && retries)
  1649.         {
  1650.         pTxD = pDrvCtrl->txRing + pDrvCtrl->txIndex;
  1652.         if  (((pTxD->tDesc0 & PCISWAP(TDESC0_OWN)) != 0) ||
  1653.              (DC_TD_INDEX_NEXT (pDrvCtrl) == pDrvCtrl->txDiIndex))
  1654.             {
  1655.             dcTxRingClean (pDrvCtrl);
  1656. #ifdef DC_DEBUG
  1657.             pDrvCtrl->errStats.txRetries++;
  1658. #endif /* DC_DEBUG */
  1659.             retries--;
  1660.             continue;
  1661.             }
  1662.         retries = MAX_TX_RETRIES;
  1663.         
  1664.         /* Get pointer to transmit buffer */
  1666.         pTxdBuf = (char *)DC_CACHE_PHYS_TO_VIRT(PCI_TO_MEM_PHYS(
  1667.          PCISWAP(pTxD->tDesc2)));
  1669.         IF_DEQUEUE (&pDrvCtrl->idr.ac_if.if_snd, pMbuf);
  1671.         /* copy stuff */
  1673.         bcopy_from_mbufs (pTxdBuf, pMbuf, bufLen, pDrvCtrl->memWidth);
  1675.         pTxD->tDesc0  = 0; /* clear buffer error status */
  1676.         pTxD->tDesc1 &= PCISWAP (~TDESC1_TBS1_MSK);
  1677.         pTxD->tDesc1 |= PCISWAP (TDESC1_TBS1_PUT(max (ETHERSMALL, bufLen)));
  1678.         pTxD->tDesc0  = PCISWAP (TDESC0_OWN);  /* give ownership to device */
  1680.         CACHE_PIPE_FLUSH (); /* Flush the write pipe */
  1682.         /* Advance our management index */
  1684.         pDrvCtrl->txIndex = DC_TD_INDEX_NEXT (pDrvCtrl);
  1686.         /* Kickstart transmit */
  1687.     
  1688.         if (dcKickStartTx)
  1689.             DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR1, CSR1_TPD);
  1691.         pDrvCtrl->txCount++;
  1692.         }
  1694.     /* Scrub the Tx ring */
  1695.     if (pDrvCtrl->txCount > (pDrvCtrl->dcNumTds/3))
  1696.         dcTxRingClean (pDrvCtrl);
  1698. #ifdef DC_DEBUG
  1699.     if (pDrvCtrl->errStats.txQsizeCur > pDrvCtrl->errStats.txQsizeMax)
  1700.         pDrvCtrl->errStats.txQsizeMax = pDrvCtrl->errStats.txQsizeCur;
  1701. #endif /* DC_DEBUG */
  1702.     }
  1705. /*******************************************************************************
  1706. *
  1707. * dcIoctl - the driver I/O control routine
  1708. *
  1709. * Process an ioctl request.
  1710. */
  1712. LOCAL int dcIoctl
  1713.     (
  1714.     IDR  * ifp, /* pointer interface data record */
  1715.     int cmd, /* command */
  1716.     caddr_t data /* data */
  1717.     )
  1718.     {
  1719.     int  error = 0;
  1720.     DRV_CTRL *  pDrvCtrl = (DRV_CTRL *)ifp; /* pointer to device */
  1722.     switch (cmd)
  1723.         {
  1724.         case SIOCSIFADDR:
  1725.             ifp->ac_ipaddr = IA_SIN (data)->sin_addr;
  1726.             break;
  1728.         case SIOCSIFFLAGS:
  1729.             /* No further work to be done */
  1730.             break;
  1732.         case IFF_PROMISC: /* set device in promiscuous mode */
  1733.     DC_CSR_UPDATE (pDrvCtrl->devAdrs, CSR6, CSR6_PR);
  1734.     break;
  1736.         default:
  1737.             error = EINVAL;
  1738.         }
  1740.     return (error);
  1741.     }
  1743. /*******************************************************************************
  1744. *
  1745. * dcChipReset - hardware reset of chip (stop it)
  1746. */
  1748. LOCAL int dcChipReset
  1749.     (
  1750.     DRV_CTRL * pDrvCtrl /* pointer to device control structure */
  1751.     )
  1752.     {
  1753.     ULONG   devAdrs = pDrvCtrl->devAdrs; /* device base address */
  1754.     ULONG ix; /* index */
  1756.     DC_CSR_WRITE (devAdrs, CSR6, 0); /* stop rcvr & xmitter */
  1758.     DC_CSR_WRITE (devAdrs, CSR7, 0); /* mask interrupts */
  1759.     
  1760.     DC_CSR_WRITE (devAdrs, CSR0, CSR0_SWR);
  1762.     /* Wait Loop, Loop for at least 50 PCI cycles according to chip spec */
  1764.     for (ix = 0; ix < 0x1000; ix++)
  1765. ;
  1767.     /* any additional bus mode | give xmit & rcv process equal priority */
  1768.     DC_CSR_WRITE (devAdrs, CSR0, (dcCSR0Bmr | CSR0_BAR | CSR0_RML |
  1769.                                 CSR0_CAL_32 | CSR0_PBL_32));
  1771.     for (ix = 0; ix < 0x1000; ix++) /* loop for some cycles */
  1772. ;
  1774.     return (OK);
  1775.     }
  1777. /*******************************************************************************
  1778. *
  1779. * dc21040AuiTpInit - initialize either AUI or 10BASE-T connection
  1780. *
  1781. * This function configures 10BASE-T interface. If the link pass state is 
  1782. * not achieved within two seconds then the AUI interface is initialized.
  1783. */
  1785. LOCAL void dc21040AuiTpInit
  1786.     (
  1787.     ULONG       devAdrs        /* device base I/O address */
  1788.     )
  1789.     {
  1791.     /* reset the SIA registers */
  1793.     DC_CSR_WRITE (devAdrs, CSR13, 0);
  1794.     DC_CSR_WRITE (devAdrs, CSR14, 0);
  1795.     DC_CSR_WRITE (devAdrs, CSR15, 0);
  1797.     /* configure for the 10BASE-T */
  1799.     DC_CSR_WRITE (devAdrs, CSR13, CSR13_CAC_CSR); /* 10BT auto configuration */
  1801.     taskDelay (sysClkRateGet() * 2); /* 2 second delay */
  1803.     if (DC_CSR_READ (devAdrs, CSR12) & (CSR12_LKF | CSR12_NCR))
  1804. {
  1805. /* 10BASE-T not connected initialize interface for AUI */
  1807. DC_CSR_WRITE (devAdrs, CSR13, 0); /* reset SIA registers */
  1808. DC_CSR_WRITE (devAdrs, CSR14, 0);
  1809. DC_CSR_WRITE (devAdrs, CSR15, 0);
  1811. /* AUI auto configuration */
  1813. DC_CSR_WRITE (devAdrs, CSR13, (CSR13_AUI_TP | CSR13_CAC_CSR));
  1814. }
  1815.     }
  1817. /*******************************************************************************
  1818. *
  1819. * dc21140SROMVersionGet - gets the SROM format version
  1820. *
  1821. * RETURNS: 0 - Undefined/Unknown; 1 - Version 1/A; 3 - Version 3.0
  1822. */
  1824. LOCAL UCHAR dc21140SROMVersionGet
  1825.     (
  1826.     ULONG devAdrs
  1827.     )
  1828.     {
  1829.     union SROMData
  1830. {
  1831.         char    Char[6];        /* temporary 6 x Char */
  1832.         USHORT  Short[2];       /* temporary USHORT */
  1833.         ULONG   Long;           /* temporay ULONG */
  1834.         } SROMData;
  1836.     /* Check if SROM is programmed. */
  1838.     SROMData.Short[0] = dcReadRom (devAdrs, 0);
  1839.     if (SROMData.Short[0] == 0xFFFF) 
  1840. {
  1841.         return (0);
  1842.      }
  1843.     SROMData.Short[0] = dcReadRom (devAdrs, 9);
  1844.     switch (SROMData.Char[1]) 
  1845. {
  1846.         case 1:
  1847.             return (1);
  1848.         case 3:
  1849.             return (3);
  1850.         default:
  1851.             break;
  1852.      }
  1853.     return (0);
  1854.     }
  1856. /*******************************************************************************
  1857. *
  1858. * dcSetDefaultMediaTypes - initialize Media info for blank SROMs.
  1859. *
  1860. *
  1861. */
  1863. LOCAL void dcSetDefaultMediaTypes
  1864.     (
  1865.     DRV_CTRL *pDrvCtrl
  1866.     ) 
  1867.     {
  1868.     pDrvCtrl->dcMediaBlocks.MediaFound = 3;
  1869.     pDrvCtrl->dcMediaBlocks.ActiveMedia = 0;
  1870.     pDrvCtrl->dcMediaBlocks.GPMask = 0x60;
  1872.     /* AUI */
  1874.     pDrvCtrl->dcMediaBlocks.MediaArray[0].ValCSR6 = CSR6_BIT25;
  1875.     pDrvCtrl->dcMediaBlocks.MediaArray[0].GPCount = 0;
  1877.     /* 10BaseT */
  1879.     pDrvCtrl->dcMediaBlocks.MediaArray[1].ValCSR6 = CSR6_PS | CSR6_BIT25;
  1880.     pDrvCtrl->dcMediaBlocks.MediaArray[1].GPCount = 1;
  1881.     pDrvCtrl->dcMediaBlocks.MediaArray[2].GPValue[0] = 0x40;
  1883.     /* 100BaseT4 */
  1885.     pDrvCtrl->dcMediaBlocks.MediaArray[2].ValCSR6 = CSR6_PS | CSR6_BIT25;
  1886.     pDrvCtrl->dcMediaBlocks.MediaArray[2].GPCount = 1;
  1887.     pDrvCtrl->dcMediaBlocks.MediaArray[2].GPValue[0] = 0x40;
  1888.     }
  1890. /*******************************************************************************
  1891. *
  1892. * dcDoCompactInfo - initialize Compact Media info for Version 3.0 SROMs.
  1893. *
  1894. */
  1896. LOCAL void dcDoCompactInfo 
  1897.     (
  1898.     DRV_CTRL *pDrvCtrl, 
  1899.     CompactFormat *pCompactData, 
  1900.     UINT *pCSR6, UINT MediaUnit
  1901.     )
  1902.     {
  1903.     pDrvCtrl->dcMediaBlocks.MediaArray[MediaUnit].GPCount = 1;
  1904.     pDrvCtrl->dcMediaBlocks.MediaArray[MediaUnit].GPValue[0] = 
  1905.      pCompactData->GPPortData;
  1907.     if (pCompactData->Command & 1)
  1908. *pCSR6 |= CSR6_PS;
  1910.     if (pCompactData->Command & 10)
  1911. *pCSR6 |= CSR6_TTM;
  1913.     if (pCompactData->Command & 20)
  1914. *pCSR6 |= CSR6_PCS;
  1916.     if (pCompactData->Command & 40)
  1917. *pCSR6 |= CSR6_SCR;
  1919.     return;
  1920.     }
  1922. /*******************************************************************************
  1923. *
  1924. * dc21140AuiMiiInit - initialize either AUI or MII connection
  1925. *
  1926. * This function configures 21140.  The SROM is used to set the chipset
  1927. * (DEC21140/PHY) if the SROM is configured.  The settings are tried and
  1928. * if there is no errors (link fail, no carrier, ...) the configuration
  1929. * is used.  If an error occurs, the next media info leaf is tried, etc.
  1930. * If the SROM is not programmed, or contains invalid data, a "generic"
  1931. * TP setting is used/tried and, if failure, the AUI port is used.
  1932. */
  1934. LOCAL void dc21140AuiMiiInit
  1935.     (
  1936.     DRV_CTRL *pDrvCtrl,
  1937.     ULONG devAdrs, 
  1938.     UINT dcCSR6
  1939.     )
  1940.     {
  1941.     union SROMData 
  1942. {
  1943.         char    Char[6];        /* temporary 6 x Char */
  1944.         USHORT  Short[2];       /* temporary USHORT */
  1945.         ULONG   Long;           /* temporay ULONG */
  1946.      } SROMData;
  1948.     UINT BlockCount = 0, 
  1949.          GPRLength  = 0,
  1950.          OldCSR6    = 0, 
  1951.          ii, jj;
  1952.     UCHAR *pTmp;
  1953.     InfoLeaf *dcInfoLeaf;
  1954.     InfoBlock *pInfoBlock;
  1955.     UCHAR SROMBuffer [128];
  1957.     pDrvCtrl->dcMediaBlocks.DontSwitch = 0;
  1958.     dcCSR6 = dcCSR6 | CSR6_BIT25;
  1959.     OldCSR6 = dcCSR6;
  1961.     /* Get SROM version */
  1963.     switch (dc21140SROMVersionGet (devAdrs)) 
  1964. {
  1966. /* Valid Version 3 format was found, try info leafs. */
  1968. case 3: 
  1969.     for ( ii = 0; ii < 64; ii++ ) 
  1970. {
  1971. SROMData.Short[0] = dcReadRom (devAdrs, ii);
  1972. SROMBuffer [ii*2] = SROMData.Char[1];
  1973. SROMBuffer [(ii*2)+1] = SROMData.Char[0];
  1974. }
  1975.     dcInfoLeaf = (InfoLeaf *)(&(SROMBuffer[SROMBuffer[27]])); 
  1976.     BlockCount = dcInfoLeaf->BlockCount;
  1977.     pInfoBlock = &dcInfoLeaf->dcInfoBlock;
  1978.     pDrvCtrl->dcMediaBlocks.MediaFound = BlockCount;
  1979.     pDrvCtrl->dcMediaBlocks.GPMask = dcInfoLeaf->GPControl;  
  1980.     for (ii = 0; ii < BlockCount; ii++) 
  1981. {
  1982. pTmp =  (UCHAR *)pInfoBlock;
  1983. if ( !(pInfoBlock->Compact.MediaCode & 0x80) ) 
  1984.     {
  1986.     /* Compact Format */
  1988.                     pDrvCtrl->dcMediaBlocks.MediaArray[0].GPCount = 0;
  1989.     dcDoCompactInfo(pDrvCtrl, &(pInfoBlock->Compact), 
  1990.     &dcCSR6, ii);
  1991.     pDrvCtrl->dcMediaBlocks.MediaArray[ii].ValCSR6 = dcCSR6;
  1992.     pTmp = &(pTmp[4]);
  1993.     }
  1994. else 
  1995.     {
  1997.     /* Extended Format */
  1999.     if (pInfoBlock->Extended0.Type) 
  2000. {
  2002. /* Block Type 1 */
  2004. dcCSR6 = dcCSR6 | CSR6_BIT25 | CSR6_PS;
  2006. /* Get General Purpose Data. */
  2008. GPRLength = pInfoBlock->Extended1.BlockData[1];
  2009. pDrvCtrl->dcMediaBlocks.MediaArray[ii].GPCount =
  2010. GPRLength;
  2011. for (jj = 0; jj < GPRLength; jj++) 
  2012.     {
  2013.     pDrvCtrl->dcMediaBlocks.MediaArray[ii].GPValue[jj] =
  2014.      pInfoBlock->Extended1.BlockData[jj+2];
  2015.     }
  2016. pDrvCtrl->dcMediaBlocks.MediaArray[ii].GPResetLen = 
  2017. pInfoBlock->Extended1.BlockData[GPRLength+2];
  2018. for (jj = 0; 
  2019.      jj < pDrvCtrl->dcMediaBlocks.MediaArray[ii].
  2020. GPResetLen; jj++) 
  2021.     {
  2022.     pDrvCtrl->dcMediaBlocks.MediaArray[ii].
  2023.      GPResetValue[jj] = 
  2024.      pInfoBlock->Extended1.
  2025.      BlockData[GPRLength+jj+3];
  2026.     }
  2027. }
  2028.     else 
  2029. {
  2031. /* Block Type 0 */
  2033. dcCSR6 = dcCSR6 | CSR6_TTM | CSR6_BIT25;
  2034. dcDoCompactInfo (pDrvCtrl,
  2035. (CompactFormat *)
  2036.     (pInfoBlock->Extended1.BlockData), 
  2037. &dcCSR6, ii);
  2038. }
  2039. pDrvCtrl->dcMediaBlocks.MediaArray[ii].ValCSR6 = dcCSR6;
  2040. pTmp = &(pTmp[(pInfoBlock->Extended0.Length & ~0x80)
  2041. + 1]);
  2042.     }
  2044. pDrvCtrl->dcMediaBlocks.ActiveMedia = 0;
  2045. dcCSR6 = OldCSR6;
  2046. pInfoBlock = (InfoBlock *)pTmp;
  2047. }
  2049.     pDrvCtrl->dcMediaBlocks.ActiveMedia = BlockCount - 1;
  2050.     dcSelectMedia (pDrvCtrl);
  2051.     break;
  2053. default:
  2055.     /* Invalid format was found, try MII then AUI. */
  2057.     dcSetDefaultMediaTypes (pDrvCtrl);
  2058.     pDrvCtrl->dcMediaBlocks.ActiveMedia = 1;
  2059.     dcSelectMedia (pDrvCtrl);
  2060.     break;
  2061. }
  2062.     return;
  2063.     }
  2065. /*******************************************************************************
  2066. *
  2067. * dcMiiPhyRead - read a PHY device register via MII
  2068. *
  2069. * RETURNS: the contents of a PHY device register.
  2070. */
  2072. LOCAL USHORT dcMiiPhyRead
  2073.     (
  2074.     DRV_CTRL *pDrvCtrl,
  2075.     UINT phyAdrs,                     /* PHY address to access */
  2076.     UINT phyReg                       /* PHY register to read */
  2077.     )
  2078.     {
  2079.     USHORT retVal=0;
  2080.     
  2081.     /* Write 34-bit preamble */
  2082.     DC_MII_WRITE (pDrvCtrl->devAdrs, MII_PREAMBLE, 32);
  2083.     DC_MII_WRITE (pDrvCtrl->devAdrs, MII_PREAMBLE, 2);
  2085.     /* start of frame + op-code nibble */
  2086.     DC_MII_WRITE (pDrvCtrl->devAdrs, MII_SOF | MII_RD, 4);
  2088.     /* device address */
  2089.     DC_MII_WRITE (pDrvCtrl->devAdrs, phyAdrs, 5);
  2090.     DC_MII_WRITE (pDrvCtrl->devAdrs, phyReg, 5);
  2092.     /* turn around */
  2093.     DC_MII_RTRISTATE (pDrvCtrl->devAdrs);
  2095.     /* read data */
  2096.     DC_MII_READ (pDrvCtrl->devAdrs, &retVal, 16);
  2098.     return (retVal);
  2099.     }
  2101. /*******************************************************************************
  2102. *
  2103. * dcMiiPhyWrite - write to a PHY device register via MII
  2104. *
  2105. * RETURNS: none
  2106. */
  2108. LOCAL void dcMiiPhyWrite
  2109.     (
  2110.     DRV_CTRL *pDrvCtrl,
  2111.     UINT phyAdrs,                     /* PHY address to access */
  2112.     UINT phyReg,                      /* PHY register to write */
  2113.     USHORT data                         /* Data to write */
  2114.     )
  2115.     {
  2116.     /* write 34-bit preamble */
  2117.     DC_MII_WRITE (pDrvCtrl->devAdrs, MII_PREAMBLE, 32);
  2118.     DC_MII_WRITE (pDrvCtrl->devAdrs, MII_PREAMBLE, 2);
  2120.     /* start of frame + op-code nibble */
  2121.     DC_MII_WRITE (pDrvCtrl->devAdrs, MII_SOF | MII_WR, 4);
  2123.     /* device address */
  2124.     DC_MII_WRITE (pDrvCtrl->devAdrs, phyAdrs, 5);
  2125.     DC_MII_WRITE (pDrvCtrl->devAdrs, phyReg, 5);
  2127.     /* turn around */
  2128.     DC_MII_WTRISTATE (pDrvCtrl->devAdrs);
  2130.     /* write data */
  2131.     DC_MII_WRITE (pDrvCtrl->devAdrs, data, 16);
  2132.     }
  2134. /*******************************************************************************
  2135. *
  2136. * dcSelectMedia - select the next media type supported.
  2137. *
  2138. * RETURNS: none
  2139. */
  2141. LOCAL void dcSelectMedia 
  2142.     (
  2143.     DRV_CTRL *pDrvCtrl
  2144.     )
  2145.     {
  2146.     UINT csr6val;
  2147.     UINT csr7val;
  2148.     UINT jj;
  2149.     UINT ix;
  2150.     UINT phyAddr;
  2151.     USHORT miiData;
  2152.     UINT linkTry = 0;
  2154.     if (pDrvCtrl->dcMediaBlocks.DontSwitch) 
  2155.      {
  2156.      return;
  2157.      }
  2159.     csr6val = DC_CSR_READ (pDrvCtrl->devAdrs, CSR6);
  2160.     csr7val = DC_CSR_READ (pDrvCtrl->devAdrs, CSR7); /* save CSR7 */
  2162.     /* Stop Receive/Transmit Processes */
  2164.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR6, (~(CSR6_ST|CSR6_SR) & csr6val)); 
  2165.     taskDelay (sysClkRateGet() * 1);
  2167.     if(pDrvCtrl->dcMediaBlocks.MediaArray[pDrvCtrl->
  2168. dcMediaBlocks.ActiveMedia].GPCount) 
  2169. {
  2170. for (jj=0; jj < pDrvCtrl->dcMediaBlocks.
  2171.     MediaArray[pDrvCtrl->dcMediaBlocks.ActiveMedia].GPResetLen; jj++) 
  2172.     {
  2173.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR12,
  2174. pDrvCtrl->dcMediaBlocks.
  2175. MediaArray[pDrvCtrl->dcMediaBlocks.ActiveMedia].
  2176. GPResetValue[jj]);
  2177.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR12, 
  2178. pDrvCtrl->dcMediaBlocks.GPMask | 0x100);
  2179.     for (ix = 0; ix < 0x1000; ix++)
  2180. ;
  2181.     }
  2182. for (jj=0; jj < pDrvCtrl->dcMediaBlocks.
  2183.     MediaArray[pDrvCtrl->dcMediaBlocks.
  2184.     ActiveMedia].GPCount; jj++) 
  2185.     {
  2186.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR12,
  2187. pDrvCtrl->dcMediaBlocks.
  2188. MediaArray[pDrvCtrl->
  2189. dcMediaBlocks.
  2190. ActiveMedia].
  2191. GPValue [jj]);
  2192.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR12, 
  2193. pDrvCtrl->dcMediaBlocks.GPMask | 0x100);
  2194.     for (ix = 0; ix < 0x1000; ix++)
  2195. ;
  2196.     }
  2197.         
  2198.             /* Find first PHY attached to DEC21140 */
  2200.             for (phyAddr = 0; phyAddr < DC_MAX_PHY; phyAddr++) 
  2201.                 {
  2202.                 miiData = dcMiiPhyRead(pDrvCtrl, phyAddr, MII_PHY_ID0);
  2203.                 if (miiData != 0xFFFF) /* Found PHY */
  2204.                     break;
  2205.                 }
  2207.             if (miiData != 0xFFFF)
  2208.                 {
  2209.                 linkTry=0;
  2210.                 miiData=0;
  2212.                 while ( !(miiData & MII_PHY_SR_LNK) &&
  2213.                         (linkTry < DC_MAX_LINK_TOUT))
  2214.                     {
  2215.                     taskDelay (sysClkRateGet() * 1); /* 1 second delay */
  2216.                     miiData = dcMiiPhyRead(pDrvCtrl, phyAddr, MII_PHY_SR);
  2217.                     linkTry++;
  2218.                     }
  2220.                 if (linkTry >= DC_MAX_LINK_TOUT)
  2221.                     {
  2222.                     /* Setup next media to try */
  2223.                     
  2224.                     if ((pDrvCtrl->dcMediaBlocks.ActiveMedia >= 
  2225.                 pDrvCtrl->dcMediaBlocks.MediaFound) ||
  2226.                 (pDrvCtrl->dcMediaBlocks.ActiveMedia == 0))
  2227.                         {
  2228.                         /*
  2229.                          * This is the last media supported.
  2230.                          * Leave chip programmed this way.
  2231.                          */
  2232.                 pDrvCtrl->dcMediaBlocks.DontSwitch = 1;
  2233.                         }
  2234.                     else
  2235.                         {
  2236.                         /* Attempt next media type */
  2237.                         
  2238.                         pDrvCtrl->dcMediaBlocks.ActiveMedia -= 1;
  2239.         dcSelectMedia (pDrvCtrl);
  2240.                         return;
  2241.                         }
  2242.                     }
  2243.                 }
  2244.             else /* don't know PHY type, delay 2 seconds */
  2245.                 {
  2246.                 taskDelay (sysClkRateGet() * 2); /* 2 second delay */
  2247.                 }
  2248.          }
  2250.     /*
  2251.      * Set Capture Effect Enable and Transmit Threshold to 160 by
  2252.      * default.
  2253.      */
  2255.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR6, pDrvCtrl->dcMediaBlocks.
  2256. MediaArray[pDrvCtrl->dcMediaBlocks.ActiveMedia].ValCSR6 | 
  2257. CSR6_THR_160 | CSR6_BIT25 | CSR6_CAE | 0x80000000);
  2259.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR0, 
  2260.         DC_CSR_READ (pDrvCtrl->devAdrs, CSR0) | CSR0_SWR);
  2262.     taskDelay (sysClkRateGet() * 1); /* 1 second delay */
  2264.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR0, 
  2265.         CSR0_BAR | CSR0_RML | CSR0_CAL_32 | CSR0_PBL_32);
  2267.     /*
  2268.      * Set Capture Effect Enable and Transmit Threshold to 160 by
  2269.      * default.
  2270.      */
  2272.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR6, pDrvCtrl->dcMediaBlocks.
  2273. MediaArray[pDrvCtrl->dcMediaBlocks.ActiveMedia].ValCSR6 | 
  2274. CSR6_THR_160 | CSR6_BIT25 | CSR6_CAE | 0x80000000);
  2276.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR7, csr7val);  /* restore CSR7 */
  2278.     /* Restore transmit and receiver process */
  2280.     csr6val &= (CSR6_SR | CSR6_ST);
  2281.     csr6val |= DC_CSR_READ (pDrvCtrl->devAdrs, CSR6);
  2282.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR6, csr6val);
  2284.     /* Setup next media to try */
  2286.     if ((pDrvCtrl->dcMediaBlocks.ActiveMedia >= 
  2287. pDrvCtrl->dcMediaBlocks.MediaFound) ||
  2288. (pDrvCtrl->dcMediaBlocks.ActiveMedia == 0))
  2289. pDrvCtrl->dcMediaBlocks.DontSwitch = 1;
  2291.     pDrvCtrl->dcMediaBlocks.ActiveMedia -= 1;
  2293.     return;
  2294.     }
  2296. /*******************************************************************************
  2297. *
  2298. * dcCsrWrite - select and write a CSR register
  2299. *
  2300. */
  2302. LOCAL void dcCsrWrite
  2303.     (
  2304.     ULONG  devAdrs, /* device address base */
  2305.     int  reg, /* register to select */
  2306.     ULONG  value /* value to write */
  2307.     )
  2308.     {
  2309.     ULONG * csrReg;
  2311.     csrReg = (ULONG *)(devAdrs + (reg * DECPCI_REG_OFFSET));
  2313.     /* write val to CSR */
  2315.     *(csrReg) = PCISWAP(value);
  2316.     }
  2318. /*******************************************************************************
  2319. *
  2320. * dcCsrRead - select and read a CSR register
  2321. *
  2322. */
  2324. LOCAL ULONG dcCsrRead
  2325.     (
  2326.     ULONG devAdrs, /* device address base */
  2327.     int reg /* register to select */
  2328.     )
  2329.     {
  2330.     ULONG * csrReg; /* csr register */
  2331.     ULONG csrData; /* data in csr register */
  2333.     csrReg = (ULONG *)(devAdrs + (reg * DECPCI_REG_OFFSET));
  2335.     csrData = *csrReg;
  2337.     /* get contents of CSR */
  2339.     return (PCISWAP(csrData));
  2340.     }
  2342. /*******************************************************************************
  2343. *
  2344. * dcRestart - restart the device after a fatal error
  2345. *
  2346. * This routine takes care of all the messy details of a restart.  The device
  2347. * is reset and re-initialized.  The driver state is re-synchronized.
  2348. */
  2350. LOCAL void dcRestart
  2351.     (
  2352.     int  unit /* unit to restart */
  2353.     )
  2354.     {
  2355.     ULONG status; /* status register */
  2356.     int ix; /* index variable */
  2357.     DC_RDE * rmd; /* pointer to receive descriptor */
  2358.     DC_TDE * tmd; /* pointer to Xmit descriptor */
  2359.     DRV_CTRL * pDrvCtrl = & drvCtrl [unit];
  2361.     rmd = pDrvCtrl->rxRing;      /* receive ring */
  2362.     tmd = pDrvCtrl->txRing;      /* transmit ring */
  2364.     pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING );
  2365.     logMsg ("dc%d -- Restartedn", unit,0,0,0,0,0);
  2367.     status = DC_CSR_READ (pDrvCtrl->devAdrs, CSR6);
  2368.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR6, 0); /* reset mode register */
  2370.     for (ix = 0; ix < pDrvCtrl->dcNumRds; ix++, rmd++)
  2371.         {
  2372. /* buffer size */
  2374. rmd->rDesc1 = PCISWAP(RDESC1_RBS1_VAL(DC_BUFSIZ) | 
  2375.       RDESC1_RBS2_VAL(0));
  2377. if (ix == (pDrvCtrl->dcNumRds - 1)) /* if its is last one */
  2378. rmd->rDesc1 |= PCISWAP(RDESC1_RER); /* end of receive ring */
  2380. rmd->rDesc0 = PCISWAP(RDESC0_OWN); /* give ownership to lance */
  2381.         }
  2383.     for (ix = 0; ix < pDrvCtrl->dcNumTds; ix++, tmd++)
  2384.         {
  2385. tmd->tDesc1 = PCISWAP((TDESC1_TBS1_PUT(0) |
  2386.        TDESC1_TBS2_PUT(0) |
  2387.        TDESC1_IC   |  /* intrpt on xmit */
  2388.        TDESC1_LS          | /* last segment */
  2389.        TDESC1_FS)); /* first segment */
  2391. if (ix == (pDrvCtrl->dcNumTds - 1)) /* if its is last one */
  2392.     tmd->tDesc1 |= PCISWAP(TDESC1_TER); /* end of Xmit ring */
  2394. tmd->tDesc0 = 0 ; /* clear status */
  2395.         }
  2397.     /* clear the status register */
  2399.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR5, 0xffffffff);
  2401.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR6, status); /* restore mode */
  2403.     pDrvCtrl->idr.ac_if.if_flags |= (IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);
  2404.     }
  2406. /*******************************************************************************
  2407. *
  2408. * dcLoanFree - return the given buffer to loaner pool
  2409. *
  2410. * This routine returns <pRxBuf> to the pool of available loaner buffers.
  2411. * It also returns <pRef> to the pool of available loaner reference counters,
  2412. * then zeroes the reference count.
  2413. *
  2414. * RETURNS: N/A
  2415. */
  2416.  
  2417. LOCAL void dcLoanFree
  2418.     (
  2419.     DRV_CTRL * pDrvCtrl, /* pointer to device control structure */
  2420.     char * pRxBuf, /* pointer to receive buffer to free */
  2421.     UINT8 * pRef /* pointer to reference count */
  2422.     )
  2423.     {
  2424.     /* return loaned buffer to pool */
  2425.  
  2426.     pDrvCtrl->lPool[pDrvCtrl->nLoanRx] = pRxBuf;
  2427.  
  2428.     /* return loaned reference count to pool */
  2429.  
  2430.     pDrvCtrl->pRefCnt[pDrvCtrl->nLoanRx++] = pRef;
  2432.     /* reset reference count - should have been done from above, but... */
  2433.  
  2434.     *pRef = 0;
  2435.     }
  2437. /*******************************************************************************
  2438. *
  2439. * dcEnetAddrGet - gets the ethernet address from the ROM register.
  2440. *
  2441. * This routine gets the ethernet address from the ROM register.
  2442. * This routine returns the ethernet address into the pointer supplied to it.
  2443. * 
  2444. * RETURNS: OK/ERROR
  2445. */
  2447. LOCAL STATUS dcEnetAddrGet
  2448.     (
  2449.     ULONG devAdrs, /* device base I/O address */
  2450.     char *  enetAdrs, /* pointer to the ethernet address */ 
  2451.     int len /* number of bytes to read */
  2452.     )
  2453.     {
  2454.     FAST ULONG csr9Value; /* register to hold CSR9 */
  2455.     int ix; /* index register */
  2456.     BOOL eRomReady = FALSE; /* ethernet ROM register state */
  2458.     DC_CSR_WRITE (devAdrs, CSR9, 0); /* reset rom pointer */
  2460.     while (len > 0)
  2461. {
  2462. for (ix = 0; ix < 10; ix++) /* try at least 10 times */
  2463.     {
  2464.     if ((csr9Value = DC_CSR_READ (devAdrs, CSR9)) & CSR9_040_DNVAL)
  2465. {
  2466. eRomReady = FALSE;
  2467.      DELAY(500);
  2468. }
  2469.     else
  2470. {
  2471. *enetAdrs++ = (UCHAR) csr9Value;
  2472. len--;
  2473. eRomReady = TRUE;
  2474. break;
  2475. }
  2476.        }
  2477.         
  2478.         if (!eRomReady)
  2479.             break;
  2480. }
  2482.     if (!eRomReady)
  2483.      return (ERROR);
  2484.     else
  2485. return (OK);
  2486.     }
  2488. /*******************************************************************************
  2489. *
  2490. * dc21140EnetAddrGet - gets the ethernet address from the ROM register 
  2491. *
  2492. * This routine gets the last two bytes of the ethernet address from the ROM
  2493. * register and concantenates this value to the predefined values for DEC PMCs..
  2494. * This routine returns the ethernet address into the pointer supplied to it.
  2495. *
  2496. * The procedure could be expanded in the future to allow for modification of
  2497. * Ethernet addresses in the serial ROM.  It will have to be modified to
  2498. * accomodate the differences in the onboard 100Mb/s ethernet on future 
  2499. * Motorola products.
  2500. * 
  2501. * RETURNS: OK/ERROR
  2502. */
  2504. LOCAL STATUS dc21140EnetAddrGet
  2505.     (
  2506.     ULONG devAdrs, /* device base I/O address */
  2507.     char *  enetAdrs, /* pointer to the ethernet address */ 
  2508.     int len /* number of bytes to read */
  2509.     )
  2510.     {
  2511.     int i; /* index register */
  2512.     int ix; /* index register */
  2513.     int tmpInt; /* temporary int */
  2514.     union SROMData
  2515. {
  2516. char Char[6]; /* temporary 6 x Char */
  2517. USHORT Short[2]; /* temporary USHORT */
  2518. ULONG   Long; /* temporay ULONG */
  2519. } SROMData;
  2521.     /* Check if SROM is programmed. */
  2523.     SROMData.Short[0] = dcReadRom (devAdrs, 0);
  2524.     if (SROMData.Short[0] == 0xFFFF) 
  2525. {
  2526. /* SROM is unprogrammed, get MAC address from NVRAM. */
  2528. sysNvRamGet ((char *)enetAdrs, 6, ((int) ((char *)(0x1f2c)) - 256));
  2529. return (OK);
  2530. }
  2531.     else 
  2532. {
  2533. /* Look for Legacy Format in ROM. */
  2535. SROMData.Short[0] = dcReadRom (devAdrs, 13);
  2536. if (SROMData.Short[0] == 0xAA55) 
  2537.     {
  2539.     /*
  2540.      * Read from location 0 in ROM.  MAC address appears at
  2541.      * location 0 in Legacy SROM formats.
  2542.      */
  2544.     tmpInt = 0;
  2545.     }
  2546. else 
  2547.     {
  2549.     /*
  2550.      * Read from location 20 in ROM.  MAC address appears at
  2551.      * location 20 (10 byte pairs) in both Version 1/A and 3.0 
  2552.      * SROM formats.
  2553.      */
  2555.     tmpInt = DEC_PMC_POS;
  2556.     }
  2557. for (i = tmpInt, ix = 0; i<(3+tmpInt); i++, ix++) 
  2558.     {
  2559.     if ((UINT)(SROMData.Short[0] = dcReadRom (devAdrs, i)) == ERROR) 
  2560. {
  2561. return (ERROR);
  2562. }
  2563.     enetAdrs[ix++] = SROMData.Char[1];
  2564.     enetAdrs[ix] = SROMData.Char[0];
  2565.     }
  2566. }
  2567.     tmpInt = -1;
  2568.     return (OK);
  2569.     }
  2571. /*******************************************************************************
  2572. *
  2573. * dcFltrFrmXmit - Transmit the setup filter frame.
  2574. *
  2575. * This routine transmits the setup filter frame.
  2576. * The setup frame is not transmitted actually over the wire. The setup frame
  2577. * which is transmitted is 192 bytes. The tranmitter should be in an on state
  2578. * before this function is called. This call has been coded so that the 
  2579. * setup frame can be transmitted after the chip is done with the 
  2580. * intialization taking into consideration for adding multicast support.
  2581. * 
  2582. * RETURNS: OK/ERROR
  2583. */
  2585. LOCAL int dcFltrFrmXmit
  2586.     (
  2587.     DRV_CTRL * pDrvCtrl,  /* pointer to device control structure */
  2588.     char *  pPhysAdrsTbl,  /* pointer to physical address table */ 
  2589.     int  tblLen /* size of the physical address table */
  2590.     )
  2591.     {
  2592.     DC_TDE * tmd; /* pointer to Tx ring descriptor */
  2593.     ULONG *  pBuff; /* pointer to the Xmit buffer */
  2594.     int status = OK; /* intialize status as OK */
  2595.     ULONG csr7Val; /* value in CSR7 */
  2597.     semTake (pDrvCtrl->TxSem, WAIT_FOREVER);
  2599.     if (dcFltrFrmSetup (pDrvCtrl, pPhysAdrsTbl, tblLen) != OK)
  2600. {
  2601. status = ERROR; /* not able to set up filter frame */
  2602. goto setupDone; /* set up done */
  2603. }
  2605.     /* See if next TXD is available */
  2607.     tmd = pDrvCtrl->txRing + pDrvCtrl->txIndex;
  2609.     DC_CACHE_INVALIDATE (tmd, TMD_SIZ);
  2611.     if  (
  2612.         ((tmd->tDesc0 & PCISWAP(TDESC0_OWN)) != 0) ||
  2613.         (
  2614.         ((pDrvCtrl->txIndex + 1) % pDrvCtrl->dcNumTds) == pDrvCtrl->txDiIndex
  2615. )
  2616.         )
  2617. {
  2618. status = ERROR; /* not able to set up filter frame */
  2619. goto setupDone; /* set up done */
  2620. }
  2622.     /* Get pointer to transmit buffer */
  2624.     pBuff = DC_CACHE_PHYS_TO_VIRT(PCI_TO_MEM_PHYS(PCISWAP(tmd->tDesc2)));
  2626.     /* copy into Xmit buffer */
  2628.     bcopyLongs ((char *)pDrvCtrl->pFltrFrm, (char *)pBuff, 
  2629. FLTR_FRM_SIZE_ULONGS);
  2631.     tmd->tDesc0 = 0; /* clear buffer error status */
  2632.     tmd->tDesc1 |= PCISWAP(TDESC1_SET); /* frame type as set up */
  2633.     tmd->tDesc1 &= PCISWAP(~TDESC1_TBS1_MSK);
  2634.     tmd->tDesc1 |= PCISWAP(TDESC1_TBS1_PUT(FLTR_FRM_SIZE));
  2635.     tmd->tDesc0 = PCISWAP(TDESC0_OWN);  /* give ownership to device */
  2637.     CACHE_PIPE_FLUSH (); /* Flush the write pipe */
  2639.     /* Advance our management index */
  2641.     pDrvCtrl->txIndex = (pDrvCtrl->txIndex + 1) % pDrvCtrl->dcNumTds;
  2642.     pDrvCtrl->txDiIndex = (pDrvCtrl->txDiIndex + 1) % pDrvCtrl->dcNumTds;
  2644.     csr7Val = DC_CSR_READ (pDrvCtrl->devAdrs, CSR7);
  2646.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR7, 0); /* mask interrupts */
  2647.     
  2648.     if (dcKickStartTx)
  2649.      DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR1, CSR1_TPD);   /* xmit poll demand */
  2651.     /* wait for the own bit to change */
  2653.     while (tmd->tDesc0 & PCISWAP (TDESC0_OWN))
  2654. /* do nothing */ ;
  2656.     tmd->tDesc0 = 0; /* clear status bits */
  2657.     tmd->tDesc1 &= PCISWAP(~TDESC1_SET);
  2659.     DC_CSR_WRITE (pDrvCtrl->devAdrs, CSR7, csr7Val); /* restore value */
  2661. setupDone:
  2663.     /* Release exclusive access. */
  2665.     semGive (pDrvCtrl->TxSem);
  2667.     return (status);
  2668.     }
  2670. /*******************************************************************************
  2671. *
  2672. * dcFltrFrmSetup - set up the filter frame.
  2673. *
  2674. * This routine sets up the filter frame to filter the physical addresses
  2675. * on the incoming frames. The setup filter frame buffer is 192 bytes. This
  2676. * setup frame needs to be transmitted before transmitting and receiving 
  2677. * any frames. 
  2678. * 
  2679. * RETURNS: OK/ERROR
  2680. */
  2682. LOCAL int dcFltrFrmSetup
  2683.     (
  2684.     DRV_CTRL * pDrvCtrl,  /* pointer to device control structure */
  2685.     char *  pPhysAdrsTbl,  /* pointer to physical address table */ 
  2686.     int  tblLen /* size of the physical address table */
  2687.     )
  2688.     {
  2689.     int ix; /* index variable */
  2690.     int jx;  /* inner index variable */
  2691.     ULONG * pFltrFrm; /* pointer to the filter frame */
  2692.     USHORT * pPhysAddrs; /* pointer to the physical addresses */
  2694.     if (tblLen > FLTR_FRM_ADRS_NUM)
  2695. return (ERROR);
  2697.     pFltrFrm = pDrvCtrl->pFltrFrm;
  2699.     for (ix = 0; ix < FLTR_FRM_SIZE_ULONGS; ix++)
  2700. *pFltrFrm++ = FLTR_FRM_DEF_ADRS;
  2702.     pFltrFrm = pDrvCtrl->pFltrFrm;
  2703.     pPhysAddrs = (USHORT *) (pPhysAdrsTbl);
  2705.     for (ix = 0; ix < tblLen; ix++)
  2706. {
  2707. for (jx = 0; jx < (FLTR_FRM_ADRS_SIZE/sizeof (USHORT)); jx++)
  2708.     {
  2709. #if (_BYTE_ORDER == _BIG_ENDIAN)
  2710.     *pFltrFrm =  (*pPhysAddrs << 16);
  2711. #else
  2712.     *pFltrFrm = ((LSB(*pPhysAddrs) << 8) | MSB(*pPhysAddrs));
  2713. #endif
  2714.     pPhysAddrs++;
  2715.     pFltrFrm++;
  2716.     }
  2717. }
  2718.     return (OK);
  2719.     }
  2721. /*******************************************************************************
  2722. *
  2723. * dcReadRom - reads an specified entry in the Serial ROM 
  2724. *
  2725. * This routine uses the line number passed to the function and returns
  2726. * the two bytes of information that is associated with it.  This will later
  2727. * be used by the dc21140GetEthernetAdr function.  It can also be used to 
  2728. * review the ROM contents itself.
  2729. *
  2730. * The function must first send some initial bit paterns to the CSR9 which 
  2731. * contains the Serial ROM Control bits.  Then the line index into the ROM
  2732. * will be evaluated bit by bit to program the ROM.  The 2 bytes of data
  2733. * will be extracted and processed into a normal pair of bytes. 
  2734. * 
  2735. * RETURNS: Short Value in ROM/ERROR
  2736. */
  2738. LOCAL USHORT dcReadRom
  2739.     (
  2740.     ULONG devAdrs, /* device base I/O address */
  2741.     UCHAR lineCnt  /* Serial ROM line Number */ 
  2742.     )
  2743.     {
  2744.     int ix; /* index register */
  2745.     int intCnt; /* address loop count */
  2746.     USHORT tmpShort;
  2747.     ULONG tmpLong; 
  2749.     /* Is the line offset valid, and if so, how large is it */
  2751.     if (lineCnt > SROM_SIZE)
  2752.      {
  2753. logMsg ("dcReadRom FAILED, bad lineCntn",0,0,0,0,0,0);
  2754.      return (ERROR);
  2755.      }
  2756.     if (lineCnt < 64)
  2757.      {
  2758. intCnt = 6;
  2759. lineCnt = lineCnt << 2;  /* Prepare lineCnt for processing */
  2760.      }
  2761.     else
  2762. intCnt = 8;
  2764.     /* Command the Serial ROM to the correct Line */
  2766.     /* Preamble of Command */
  2768.     DC_SROM_WRITE (devAdrs, 0x00000000, 30); /* Command 1 */
  2769.     DC_SROM_WRITE (devAdrs, 0x00000001, 50); /* Command 2 */
  2770.     DC_SROM_WRITE (devAdrs, 0x00000003, 250); /* Command 3 */
  2771.     DC_SROM_WRITE (devAdrs, 0x00000001, 100); /* Command 4 */
  2773.     /* Command Phase */
  2775.     DC_SROM_WRITE (devAdrs, 0x00000005, 150); /* Command 5 */
  2776.     DC_SROM_WRITE (devAdrs, 0x00000007, 250); /* Command 6 */
  2777.     DC_SROM_WRITE (devAdrs, 0x00000005, 250); /* Command 7 */
  2778.     DC_SROM_WRITE (devAdrs, 0x00000007, 250); /* Command 8 */
  2779.     DC_SROM_WRITE (devAdrs, 0x00000005, 100); /* Command 9 */
  2780.     DC_SROM_WRITE (devAdrs, 0x00000001, 150); /* Command 10 */
  2781.     DC_SROM_WRITE (devAdrs, 0x00000003, 250); /* Command 11 */
  2782.     DC_SROM_WRITE (devAdrs, 0x00000001, 100); /* Command 12 */
  2783.     
  2784.     /* Address Phase */
  2786.     for (ix = 0; ix < intCnt; ix++)
  2787.      {
  2788. tmpLong = (lineCnt & 0x80) >> 5; /* Extract and move bit to bit 3) */
  2790. /* Write the command */
  2792.      DC_SROM_WRITE (devAdrs, tmpLong | 0x00000001, 150);  /* Command 13 */
  2793.      DC_SROM_WRITE (devAdrs, tmpLong | 0x00000003, 250);  /* Command 14 */
  2794.      DC_SROM_WRITE (devAdrs, tmpLong | 0x00000001, 100);  /* Command 15 */
  2796. lineCnt <<= 1;  /* Adjust significant address bit */
  2797.      }
  2799.     NSDELAY (150);
  2801.     /* Data Phase */
  2803.     tmpShort =0;
  2804.     for (ix = 15; ix >= 0; ix--)
  2805.      {
  2806. /* Write the command */
  2808.      DC_SROM_WRITE (devAdrs, 0x00000003, 100); /* Command 16 */
  2810. /* Extract the data */
  2812.      tmpShort |= DC_SROM_READ (devAdrs) << ix;  /* Command 17 */
  2813.      NSDELAY (150);
  2814.         
  2815.      DC_SROM_WRITE (devAdrs, 0x00000001, 250); /* Command 18 */
  2816.      }
  2818.     /* Finish up command */
  2820.     DC_SROM_WRITE (devAdrs, 0x00000000, 100); /* Command 19 */
  2822.     return (tmpShort);
  2823.     }
  2825. /*******************************************************************************
  2826. * 
  2827. * dcReadAllRom - read entire serial rom
  2828. *
  2829. * Function to read all of serial rom and store the data in the
  2830. * data structure passed to the function.  The count value will
  2831. * indicate how much of the serial rom to read.  The routine with also
  2832. * swap the the bytes as the come in. 
  2833. *
  2834. * RETURNS: N/A.
  2835. */
  2837. void dcReadAllRom
  2838.     (
  2839.     ULONG devAdrs, /* device base I/O address */
  2840.     UCHAR *buffer, /* destination bufferr */ 
  2841.     int cnt             /* Amount to extract in bytes */
  2842.     )
  2843.     {
  2845.     USHORT total, index;
  2846.     union tmp_type {
  2847.         USHORT Short;
  2848.      char   Byte [2]; /* temporary 2 by char */
  2849.     } tmp;
  2851.     total = 0;
  2852.     for (index = 0, total = 0; total < cnt / 2; index += 2, total++)
  2853.      {
  2854. tmp.Short = dcReadRom (devAdrs, total);
  2855. buffer[index] = tmp.Byte[1];
  2856. buffer[index+1] = tmp.Byte[0];
  2857.      }
  2858.     }
  2860. #ifdef DC_DEBUG
  2862. /*******************************************************************************
  2863. *
  2864. * dcViewRom - display lines of serial ROM for dec21140
  2865. *
  2866. * RETURNS: Number of bytes displayed.
  2867. */
  2869. int dcViewRom
  2870.     (
  2871.     ULONG devAdrs, /* device base I/O address */
  2872.     UCHAR lineCnt, /* Serial ROM line Number */ 
  2873.     int cnt             /* Amount to display */
  2874.     )
  2875.     {
  2877.     USHORT total;
  2878.     union tmp_type 
  2879.      {
  2880.         USHORT Short;
  2881.      char   Byte [2]; /* temporary 2 by char */
  2882.      } tmp;
  2884.     if (((lineCnt / 2) < 0) || ((lineCnt / 2) > (UCHAR) SROM_SIZE))
  2885. return (ERROR);
  2887.     total = 0;
  2888.     while (((lineCnt / 2) < SROM_SIZE) && (cnt > 0))
  2889.      {
  2890. if (!(total % 16))
  2891.     printf ("nValues for line %2d =>0x  ", total);
  2892. tmp.Short = dcReadRom (devAdrs, lineCnt);
  2893. printf ("%4x ",tmp.Short);
  2894. lineCnt++ ;
  2895. total += 2;
  2896. cnt -= 2;
  2897. }
  2898.     printf ("n");
  2899.     return (total);
  2900.     }
  2903. /*******************************************************************************
  2904. *
  2905. * dcCsrShow - display dec 21040/21140 status registers 0 thru 15
  2906. *
  2907. * Display the 16 registers of the DEC 21140 device on the console.
  2908. * Each register is printed in hexadecimal format.
  2909. *
  2910. * RETURNS: N/A.
  2911. */
  2913. int dcCsrShow
  2914.     (
  2915.     int unit
  2916.     )
  2917.     {
  2918.     DRV_CTRL *pDrvCtrl;
  2919.     int devAdrs;
  2921.     if (unit > MAX_UNITS)
  2922.         return -1;
  2924.     pDrvCtrl = &drvCtrl[unit];
  2926.     if (!pDrvCtrl->attached)
  2927.         return -2;
  2929.     devAdrs=pDrvCtrl->devAdrs;
  2930.     
  2931.     printf ("dc%d Configuration Registers: n", unit);
  2932.     printf (" 0=0x%x, 1=0x%x, 2=0x%x, 3=0x%xn",
  2933.             (int) DC_CSR_READ (devAdrs, CSR0),
  2934.             (int) DC_CSR_READ (devAdrs, CSR1),
  2935.             (int) DC_CSR_READ (devAdrs, CSR2),
  2936.             (int) DC_CSR_READ (devAdrs, CSR3));
  2937.     printf (" 4=0x%x, 5=0x%x, 6=0x%x, 7=0x%xn",
  2938.             (int) DC_CSR_READ (devAdrs, CSR4),
  2939.             (int) DC_CSR_READ (devAdrs, CSR5),
  2940.             (int) DC_CSR_READ (devAdrs, CSR6),
  2941.             (int) DC_CSR_READ (devAdrs, CSR7));
  2942.     printf (" 8=0x%x, 9=0x%x, 10=0x%x, 11=0x%xn",
  2943.             (int) DC_CSR_READ (devAdrs, CSR8),
  2944.             (int) DC_CSR_READ (devAdrs, CSR9),
  2945.             (int) DC_CSR_READ (devAdrs, CSR10),
  2946.             (int) DC_CSR_READ (devAdrs, CSR11));
  2947.     printf (" 12=0x%x, 13=0x%x, 14=0x%x, 15=0x%xn",
  2948.             (int) DC_CSR_READ (devAdrs, CSR12),
  2949.             (int) DC_CSR_READ (devAdrs, CSR13),
  2950.             (int) DC_CSR_READ (devAdrs, CSR14),
  2951.             (int) DC_CSR_READ (devAdrs, CSR15));
  2952.     return 0;
  2953.     }
  2955. int dcShow
  2956.     (
  2957.     UINT unit
  2958.     )
  2959.     {
  2960.     DRV_CTRL *pDrvCtrl;
  2961.     DC_STATS *pErrStats;
  2963.     if (unit > MAX_UNITS)
  2964.         return -1;
  2966.     pDrvCtrl = &drvCtrl[unit];
  2968.     if (!pDrvCtrl->attached)
  2969.         return -2;
  2971.     pErrStats=&pDrvCtrl->errStats;
  2973.     printf ("dc%d: pDrvCtrl=0x%xn", unit, (int)pDrvCtrl);
  2974.     printf (" ivec=%d ilevel=%d devAdrs=0x%x pciMemBase=0x%x memWidth=%dn",
  2975.             (int) pDrvCtrl->ivec,
  2976.             (int) pDrvCtrl->ilevel,
  2977.             (int) pDrvCtrl->devAdrs,
  2978.             (int) pDrvCtrl->pciMemBase,
  2979.             (int) pDrvCtrl->memWidth);
  2980.     printf (" nTDs=%d nRDs=%d rxIndex=%d txIndex=%d nLoanRx=%dn",
  2981.             (int) pDrvCtrl->dcNumTds,
  2982.             (int) pDrvCtrl->dcNumRds,
  2983.             (int) pDrvCtrl->rxIndex,
  2984.             (int) pDrvCtrl->txIndex,
  2985.             (int) pDrvCtrl->nLoanRx);
  2986.     printf (" ipackets=%d, opackets=%d ierrors=%d oerrors=%d collisions=%dn",
  2987.             (int) pDrvCtrl->idr.ac_if.if_ipackets,
  2988.             (int) pDrvCtrl->idr.ac_if.if_opackets,
  2989.             (int) pDrvCtrl->idr.ac_if.if_ierrors,
  2990.             (int) pDrvCtrl->idr.ac_if.if_oerrors,
  2991.             (int) pDrvCtrl->idr.ac_if.if_collisions);
  2993.     printf (" len=%d maxQlen=%d drops=%d txIndex=%d txDiIndex=%dn",
  2994.             pDrvCtrl->idr.ac_if.if_snd.ifq_len,
  2995.             pDrvCtrl->idr.ac_if.if_snd.ifq_maxlen,
  2996.             pDrvCtrl->idr.ac_if.if_snd.ifq_drops,
  2997.             pDrvCtrl->txIndex,
  2998.             pDrvCtrl->txDiIndex);
  3000.     printf (" txstats: jbr=%d lostCarr=%d noCarr=%d lateColl=%d XsColl=%dn",
  3001.             pErrStats->txJbrTmo,
  3002.             pErrStats->txLostCarrier,
  3003.             pErrStats->txNoCarrier,
  3004.             pErrStats->txLateCollision,
  3005.             pErrStats->txExsCollision);
  3006.     
  3007.     printf ("          hbFail=%d lnkF=%d uflo=%d defr=%d retries=%dn",
  3008.             pErrStats->txHeartBeatFail,
  3009.             pErrStats->txLinkFail,
  3010.             pErrStats->txUnderflow,
  3011.             pErrStats->txDeferred,
  3012.             pErrStats->txRetries);
  3014.     printf ("          drops=%d fl=%d fl_need=%d fl_done=%d QMax=%d QCur=%dn",
  3015.             pErrStats->txDropped,     
  3016.             pErrStats->txFlushCalled,
  3017.             pErrStats->txFlushNeeded,
  3018.             pErrStats->txFlushDone, 
  3019.             pErrStats->txQsizeMax,   
  3020.             pErrStats->txQsizeCur);    
  3021.     
  3022.     printf (" rxstats: fltErr=%d DescErr=%d Runt=%d tooLng=%d Coll=%dn",
  3023.             pErrStats->rxFiltrErr, 
  3024.             pErrStats->rxDescErr,  
  3025.             pErrStats->rxRuntFrm,   
  3026.             pErrStats->rxTooLong,   
  3027.             pErrStats->rxCollision);
  3029.     printf ("          dribl=%d crc=%d ovflo=%d miiErr=%d miss=%d rxlatn=%dn",
  3030.             pErrStats->rxDribbleBit,
  3031.             pErrStats->rxCrcErr,
  3032.             pErrStats->rxOverflow,
  3033.             pErrStats->rxMiiErr,
  3034.             pErrStats->rxMissed,
  3035.             pErrStats->rxLatency);    
  3037.             
  3038.     return 0;
  3039.     }
  3041. void phyProbe
  3042.     (
  3043.     DRV_CTRL *pDrvCtrl
  3044.     )
  3045.     {
  3046.     int phyAdrs;
  3048.     for (phyAdrs=0; phyAdrs < DC_MAX_PHY; phyAdrs++)
  3049.         {
  3050.         printf ("%d = 0x%x ", phyAdrs,
  3051.                 dcMiiPhyRead (pDrvCtrl, phyAdrs, MII_PHY_ID0));
  3052.         }
  3053.     }
  3055. void phyShow
  3056.     (
  3057.     DRV_CTRL *pDrvCtrl,
  3058.     int phyNum
  3059.     )
  3060.     {
  3061.     int reg;
  3063.     printf ("CR=0x%x SR=0x%x IDO=0x%x ID1=0x%xn",
  3064.             dcMiiPhyRead (pDrvCtrl, phyNum, MII_PHY_CR),
  3065.             dcMiiPhyRead (pDrvCtrl, phyNum, MII_PHY_SR),
  3066.             dcMiiPhyRead (pDrvCtrl, phyNum, MII_PHY_ID0),
  3067.             dcMiiPhyRead (pDrvCtrl, phyNum, MII_PHY_ID1));
  3068.     printf ("ANA=0x%x ANLPA=0x%x ANE=0x%x ANP=0x%xn",
  3069.             dcMiiPhyRead (pDrvCtrl, phyNum, MII_PHY_ANA),
  3070.             dcMiiPhyRead (pDrvCtrl, phyNum, MII_PHY_ANLPA),
  3071.             dcMiiPhyRead (pDrvCtrl, phyNum, MII_PHY_ANE),
  3072.             dcMiiPhyRead (pDrvCtrl, phyNum, MII_PHY_ANP));
  3073.     }
  3075. #endif /* DC_DEBUG */