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

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

VxWorks

开发平台：

C/C++

if_dcFast.c：源码内容
  1.  /* if_dcFast.c - DEC 21040 PCI Ethernet LAN network interface driver */
  3. /* Copyright 1984-1995 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01e,06mar96,rcp  added support for the DEC21140 100Mbit Controller
  10. 01d,05sep95,vin  added filter Frame setup, added PROMISCOUS MODE to ioctl,
  11.  changed all ln references to dc, added flag DC_MULTICAST_FLAG.
  12. 01c,05apr95,vin  added AUI/10BASE-T dynamic configuration support. 
  13. 01b,31mar95,caf  changed name from "dcPci" to "dc".
  14. 01a,03mar95,vin  written.
  15. */
  17. /* FROM ROB PERSONS - Motorola Computer Group (March 06, 1996)
  18. The comments below describe the primary operation and configuration of
  19. the DEC 21X40 driver.  Differences between the two DEC parts will be 
  20. outlined in this section and how the original driver was modified to
  21. accomodate the differences.
  23. The DEC21140 is very similar to the original DEC21040 but it also has the
  24. ability to operate on networks at 100-Mb/s along with 10-Mb/s.  The
  25. physical interface is no longer part of the chip so configuration of
  26. the CSR registers which control the AUI and TP interfaces is no longer
  27. applicable.  This part now provides 100-Mb/s MII/SYM 10-Mb/s Serial
  28. intefaces which are then converted to the appropriate external interface
  29. with some additional hardware.  Most of the driver will be uneffected
  30. by the new part.  
  32. In the early stages of the driver initialization, the driver will
  33. use the Configuration ID Register (CFID) to determine which of the
  34. two parts is to be used.  A global flag will indicate which device
  35. is in use and its state will be used along with the driver modifications
  36. to accomodate the DEC21140. 
  38. The Status Register (CSR5) has three bits which have different behavior.
  39. Bit 12 (Link Fail Status) and Bit 10 (AUI/TP Status) are no longer used
  40. by the DEC21140.  Bit 11 in the DEC21040 indicates a Full-Duplex Short
  41. Frame was Received which in the DEC21140 it indicates the General Purpose
  42. Timer(GPT)  has expired.  The GPT is a new feature with the DEC21140.  Bit 
  43. 11 is currently not used in the drive and there are no plans on adding support 
  44. for the GPT so at this time it will be ignored.
  46. The Operating Mode Register (CSR6) is significantly different.  Many of the
  47. bits reflect the difference in the MII/SYM interface for the 100-Mb/s 
  48. interface.  To make the driver as flexible as possible, logic will be added 
  49. to the dcattach function to allow for the configuration of all these 
  50. control bits at driver configuration.  The following modes will be added:
  52. DEC21140 Flag - This flag indicates the driver will be operating with
  53.   a DEC21140 chip and not the DEC21040.
  54. 100Mb/s Mode - This flag will be used to set a bits in the CSR6 for the
  55.   DEC21140.  The Transmit Threshold Mode and Heartbeat Disable
  56.   bits will be effect.
  57. Scramble Mode  - The scrambler function is active and the MII/SYM port 
  58.           transmits and received scrambled symbols.
  59. PCS Function - The PCS functions are active and MII/SYM port operates
  60.   in symbol mode.  All MII/SYM port cont andol signals are 
  61.   generated internally bits will be effect.
  62. Port Select - When selected the MII/SYM mode is active.  All 100-Mb/s
  63.   modes require this.
  64. Full Duplex Mode- When selected the Lance Chip Operates in Full Duplex Mode.
  65.   It is important that the can operate in Full Duplex mode
  66.   as well. 
  67. Int Loopback    - An additional mode was added for doing internal loopback.
  68. Ext Loopback    - An additional mode was added for doing external loopback.
  69. HB Enable - An additional mode was added for testing, enableing heartb.
  71. If none of these mode bits are selected, the DEC21140 will default to the
  72. MII interface with transmit FIFO thresholds appropriate for 10-Mb/s.
  74. Additional code will be added to deal with the different Serial ROM interface.
  75. The DEC21140 now has a new interface to access a R/W ROM part to store ethernet
  76. addresses.  The dcEnetAddrGet will be modified to add the proper logic to
  77. read the DEC21140 Serial ROM interface.  No logic will be added to reprogram
  78. the value.  It turns out the DEC PMC 520-AA only stores the last 2 bytes of the
  79. ethernet address in the ROM.  The driver will make the assumption that the
  80. VENDOR ID portion extends to from 0-3 where bytes 0-2 are the manufacturers
  81. assigned values and byte 3 is assigned by DEC for the class of products.
  83. The remaining Host to Controller interface is identical and should not be 
  84. effected by the new part.
  86. */
  90. /*
  91. This module implements the DEC 21040-PCI Ethernet 32 bit network interface
  92. driver.
  94. The DEC 21040-PCI ethernet controller is inherently little endian because
  95. the chip is designed to operate on a PCI bus which is a little endian
  96. bus. The software interface to the driver is divided into three parts.
  97. The first part is the PCI configuration registers and their set up. 
  98. This part is done at the BSP level in the various BSPs which use this
  99. driver. The second and third part are dealt in the driver. The second
  100. part of the interface comprises of the I/O control registers and their
  101. programming. The third part of the interface comprises of the descriptors
  102. and the buffers. 
  104. This driver is designed to be moderately generic, operating unmodified
  105. across the range of architectures and targets supported by VxWorks.  To
  106. achieve this, the driver must be given several target-specific parameters,
  107. and some external support routines must be provided.  These parameters,
  108. and the mechanisms used to communicate them to the driver, are detailed
  109. below.  If any of the assumptions stated below are not true for your
  110. particular hardware, this driver will probably not function correctly with
  111. it.
  113. This driver supports upto 4 lance units per CPU.  The driver can be
  114. configured to support big-endian or little-endian architectures.  It
  115. contains error recovery code to handle known device errata related to DMA
  116. activity.
  118. This driver configures the 10BASE-T interface by default and waits for
  119. two seconds to check the status of the link. If the link status is fail
  120. then it configures the AUI interface. 
  122. Big endian processors can be connected to the PCI bus through some controllers
  123. which take care of hardware byte swapping. In such cases all the registers 
  124. which the chip DMA s to have to be swapped and written to, so that when the
  125. hardware swaps the accesses, the chip would see them correctly. The chip still
  126. has to be programmed to operated in little endian mode as it is on the PCI bus.
  127. If the cpu board hardware automatically swaps all the accesses to and from the
  128. PCI bus, then input and output byte stream need not be swapped. 
  130. BOARD LAYOUT
  131. This device is on-board.  No jumpering diagram is necessary.
  133. EXTERNAL INTERFACE
  134. This driver provides the standard external interface with the following
  135. exceptions.  All initialization is performed within the attach routine;
  136. there is no separate initialization routine.  Therefore, in the global interface
  137. structure, the function pointer to the initialization routine is NULL.
  139. The only user-callable routine is dcattach(), which publishes the `dc'
  140. interface and initializes the driver and device.
  142. TARGET-SPECIFIC PARAMETERS
  143. .iP "bus mode"
  144. This parameter is a global variable that can be modified at run-time.
  146. The LAN control register #0 determines the bus mode of the device,
  147. allowing the support of big-endian and little-endian architectures.
  148. This parameter, defined as "ULONG dcCSR0Bmr", is the value that will
  149. be placed into LANCE control register #0. The default is mode is little
  150. Endian.
  151. For information about changing this parameter, see the manual
  152. .I "DEC  Local Area Network Controller DEC21040 or DEC21140 for PCI."
  154. .iP "base address of device registers"
  155. This parameter is passed to the driver by dcattach().
  157. .iP "interrupt vector"
  158. This parameter is passed to the driver by dcattach().
  160. This driver configures the LANCE device to generate hardware interrupts
  161. for various events within the device; thus it contains
  162. an interrupt handler routine.  The driver calls intConnect() to connect 
  163. its interrupt handler to the interrupt vector generated as a result of 
  164. the LANCE interrupt.
  166. .iP "interrupt level"
  167. This parameter is passed to the driver by dcattach().
  169. Some targets use additional interrupt controller devices to help organize
  170. and service the various interrupt sources.  This driver avoids all
  171. board-specific knowledge of such devices.  During the driver's
  172. initialization, the external routine sysLanIntEnable() is called to
  173. perform any board-specific operations required to allow the servicing of a
  174. LANCE interrupt.  For a description of sysLanIntEnable(), see "External
  175. Support Requirements" below.
  177. This parameter is passed to the external routine.
  179. .iP "shared memory address"
  180. This parameter is passed to the driver by dcattach().
  182. The LANCE device is a DMA type of device and typically shares access to
  183. some region of memory with the CPU.  This driver is designed for systems
  184. that directly share memory between the CPU and the LANCE.  It
  185. assumes that this shared memory is directly available to it
  186. without any arbitration or timing concerns.
  188. This parameter can be used to specify an explicit memory region for use
  189. by the LANCE.  This should be done on hardware that restricts the LANCE
  190. to a particular memory region.  The constant NONE can be used to indicate
  191. that there are no memory limitations, in which case, the driver 
  192. attempts to allocate the shared memory from the system space.
  194. .iP "shared memory size"
  195. This parameter is passed to the driver by dcattach().
  197. This parameter can be used to explicitly limit the amount of shared
  198. memory (bytes) this driver will use.  The constant NONE can be used to
  199. indicate no specific size limitation.  This parameter is used only if
  200. a specific memory region is provided to the driver.
  202. .iP "shared memory width"
  203. This parameter is passed to the driver by dcattach().
  205. Some target hardware that restricts the shared memory region to a
  206. specific location also restricts the access width to this region by
  207. the CPU.  On these targets, performing an access of an invalid width
  208. will cause a bus error.
  210. This parameter can be used to specify the number of bytes of access
  211. width to be used by the driver during access to the shared memory.
  212. The constant NONE can be used to indicate no restrictions.
  214. Current internal support for this mechanism is not robust; implementation 
  215. may not work on all targets requiring these restrictions.
  217. .iP "shared memory buffer size"
  218. This parameter is passed to the driver by dcattach().
  220. The driver and LANCE device exchange network data in buffers.  This
  221. parameter permits the size of these individual buffers to be limited.
  222. A value of zero indicates that the default buffer size should be used.
  223. The default buffer size is large enough to hold a maximum-size Ethernet
  224. packet.
  226. .iP "pci Memory base"
  227. This parameter is passed to the driver by dcattach(). This parameter
  228. gives the base address of the main memory on the PCI bus. 
  230. .iP "dcOpMode"
  231. This parameter is passed to the driver by dcattach(). This parameter
  232. gives the mode of initialization of the device. The mode flags for both
  233. the DEC21040 and DEC21140 interfaces are listed below.  
  235. DC_PROMISCUOUS_FLAG     0x01 
  236. DC_MULTICAST_FLAG 0x02
  238. The mode flags specific to the DEC21140 interface are listed below.
  240. DC_100_MB_FLAG          0X04
  241. DC_21140_FLAG           0x08
  242. DC_SCRAMBLER_FLAG       0X10
  243. DC_PCS_FLAG             0x20
  244. DC_PS_FLAG              0x40
  246. The Full Duplex Mode was added to the driver.
  247. DC_FULLDUPLEX_FLAG      0x80
  249. Loopback mode flags
  250. DC_ILOOPB_FLAG          0x100 
  251. DC_ELOOPB_FLAG          0x200
  252. DC_HBE_FLAG         0x400
  255. .iP "Ethernet address"
  256. This is obtained by the driver by reading an ethernet ROM register 
  257. interfaced with the device.
  259. .LP
  261. EXTERNAL SUPPORT REQUIREMENTS
  262. This driver requires one external support function:
  263. .iP "void sysLanIntEnable (int level)" "" 9 -1
  264. This routine provides a target-specific enable of the interrupt for
  265. the LANCE device.  Typically, this involves interrupt controller hardware,
  266. either internal or external to the CPU.
  268. This routine is called once, from the dcattach() routine.
  269. .LP
  271. SEE ALSO: ifLib, 
  272. .I "DECchip 21040 or 21140 Ethernet LAN Controller for PCI."
  273. */
  275. #include "vxWorks.h"
  276. #include "stdlib.h"
  277. #include "taskLib.h"
  278. #include "logLib.h"
  279. #include "intLib.h"
  280. #include "netLib.h"
  281. #include "stdio.h"
  282. #include "stdlib.h"
  283. #include "sysLib.h"
  284. #include "iv.h"
  285. #include "memLib.h"
  286. #include "cacheLib.h"
  287. #include "sys/ioctl.h"
  288. #include "etherLib.h"
  290. #ifndef DOC             /* don't include when building documentation */
  291. #include "net/mbuf.h"
  292. #endif  /* DOC */
  294. #include "net/protosw.h"
  295. #include "sys/socket.h"
  296. #include "errno.h"
  298. #include "net/if.h"
  299. #include "net/route.h"
  301. #include "netinet/in.h"
  302. #include "netinet/in_systm.h"
  303. #include "netinet/in_var.h"
  304. #include "netinet/ip.h"
  305. #include "netinet/if_ether.h"
  306. #include "net/if_subr.h"
  307. #include "semLib.h"
  309. #include "drv/netif/if_dcFast.h" /* device description header */
  311. /* defines */
  313. #define DC_BUFSIZ      (ETHERMTU + SIZEOF_ETHERHEADER + 6)
  314. #define MAX_UNITS       4 /* maximum units supported */
  315. #define DC_L_POOL 0x10 /* number of Rx loaner buffers in pool */
  316. #define LOOP_PER_NS 4
  317. #define DELAY(count) {
  318. volatile int cx = 0;
  319. for (cx = 0; cx < (count); cx++);
  320. }
  321. #define NSDELAY(nsec) {
  322. volatile int nx = 0;
  323. volatile int loop = (int)(nsec*LOOP_PER_NS);
  324. for (nx = 0; nx < loop; nx++);
  325. }
  326. /* RCP: Added DEC Part Check */
  327. #define DEC21140(x)  ((x & DC_21140_FLAG) && (x != NONE)) 
  328. /*
  329.  * If DC_KICKSTART_TX is TRUE the transmitter is kick-started to force a
  330.  * read of the transmit descriptors, otherwise the internal polling (1.6msec)
  331.  * will initiate a read of the descriptors.  This should be FALSE is there
  332.  * is any chance of memory latency or chip accesses detaining the LANCE DMA,
  333.  * which results in a transmitter UFLO error.  This can be changed with the
  334.  * global dcKickStartTx below.
  335.  */
  337. #define DC_KICKSTART_TX TRUE
  339. /* Cache macros */
  341. #define DC_CACHE_INVALIDATE(address, len) 
  342.         CACHE_DRV_INVALIDATE (&pDrvCtrl->cacheFuncs, (address), (len))
  344. #define DC_CACHE_VIRT_TO_PHYS(address) 
  345.         CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, (address))
  347. #define DC_CACHE_PHYS_TO_VIRT(address) 
  348.         CACHE_DRV_PHYS_TO_VIRT (&pDrvCtrl->cacheFuncs, (address))
  350. /* memory to PCI address translation macros */
  352. #define PCI_TO_MEM_PHYS(pciAdrs) 
  353. ((pciAdrs) - (pDrvCtrl->pciMemBase))
  355. #define MEM_TO_PCI_PHYS(memAdrs) 
  356. ((memAdrs) + (pDrvCtrl->pciMemBase))
  358. /* Typedefs for external structures that are not typedef'd in their .h files */
  360. typedef struct mbuf MBUF;
  361. typedef struct arpcom IDR;                  /* Interface Data Record wrapper */
  362. typedef struct ifnet IFNET;                 /* real Interface Data Record */
  363. typedef struct sockaddr SOCK;
  365. /* The definition of the driver control structure */
  367. typedef struct drv_ctrl
  368.     {
  369.     IDR idr; /* Interface Data Record */
  370.     int dcNumRds; /* RMD ring size */
  371.     int rxIndex;                /* index into RMD ring */
  372.     DC_RDE * rxRing; /* RMD ring */
  373.     int dcNumTds; /* TMD ring size */
  374.     int txIndex; /* index into TMD ring */
  375.     int txDiIndex; /* disposal index into TMD ring */
  376.     DC_TDE * txRing; /* TMD ring */
  377.     BOOL        attached;               /* indicates unit is attached */
  378.     SEM_ID      TxSem;                  /* transmitter semaphore */
  379.     ULONG dcOpMode; /* mode of operation */
  380.     int         ivec;                   /* interrupt vector */
  381.     int         ilevel;                 /* interrupt level */
  382.     ULONG devAdrs;                /* device structure address */
  383.     ULONG pciMemBase; /* memory base as seen from PCI*/
  384.     int         memWidth;               /* width of data port */
  385.     CACHE_FUNCS cacheFuncs;             /* cache function pointers */
  386.     int nLoanRx; /* number of Rx buffers left to loan */
  387.     char *lPool[DC_L_POOL]; /* receive loaner pool ptrs */
  388.     UINT8 *pRefCnt[DC_L_POOL]; /* stack of reference count pointers */
  389.     UINT8 refCnt[DC_L_POOL]; /* actual reference count values */
  390.     ULONG * pFltrFrm; /* pointer to setup filter frame */
  391.     } DRV_CTRL;
  393. #define DRV_CTRL_SIZ sizeof(DRV_CTRL)
  394. #define RMD_SIZ sizeof(DC_RDE)
  395. #define TMD_SIZ sizeof(DC_TDE)
  397. /* globals */
  399. /*  RCP: Reference Removed for new function
  400. IMPORT void sysLanIntEnable ();
  401. */
  402. IMPORT BOOL arpresolve ();
  403. /*
  404. IMPORT unsigned char dcEnetAddr []; *//* Ethernet address to load into lance */
  407. BOOL  dcKickStartTx  = DC_KICKSTART_TX;
  408. ULONG dcCSR0Bmr = 0;
  410. /* locals */
  412. LOCAL DRV_CTRL  drvCtrl [MAX_UNITS]; /* array of driver control structs */
  414. LOCAL int dcNumRds  = NUM_RDS; /* number of ring descriptors */
  415. LOCAL int dcNumTds  = NUM_TDS; /* number of xmit descriptors */
  416. LOCAL int  dcLPool = DC_L_POOL;
  418. /* forward static functions */
  420. LOCAL void  dcReset (int unit);
  421. LOCAL void  dcInt (DRV_CTRL *pDrvCtrl);
  422. LOCAL void  dcHandleRecvInt (DRV_CTRL *pDrvCtrl);
  423. LOCAL STATUS  dcRecv (DRV_CTRL *pDrvCtrl, DC_RDE *rmd);
  424. LOCAL int  dcOutput (IDR *ifp, MBUF *m0, SOCK *dst);
  425. LOCAL int  dcIoctl (IDR *ifp, int cmd, caddr_t data);
  426. LOCAL int  dcChipReset (DRV_CTRL *pDrvCtrl);
  427. LOCAL DC_RDE * dcGetFullRMD (DRV_CTRL *pDrvCtrl);
  428. LOCAL void dcAuiTpInit (ULONG devAdrs);
  429. LOCAL void  dcCsrWrite (ULONG devAdrs, int reg, ULONG value);
  430. LOCAL ULONG  dcCsrRead (ULONG devAdrs, int reg);
  431. LOCAL void  dcRestart (int unit);
  432. LOCAL STATUS  dcEnetAddrGet (ULONG devAdrs, char * enetAdrs, int len);
  433. LOCAL STATUS  dc21140EnetAddrGet (ULONG devAdrs, char * enetAdrs, int len);
  434. LOCAL BOOL  convertDestAddr (IDR * pIDR, SOCK * pDestSktAddr,
  435.  char * pDestEnetAddr, u_short * pPacketType,
  436.  MBUF * pMbuf);
  437. LOCAL void  dcLoanFree (DRV_CTRL *pDrvCtrl, char *pRxBuf, UINT8 *pRef);
  438. LOCAL int dcFltrFrmSetup (DRV_CTRL * pDrvCtrl, char * pPhysAdrsTbl, 
  439. int tblLen);
  440. LOCAL int dcFltrFrmXmit (DRV_CTRL * pDrvCtrl, char * pPhysAdrsTbl,
  441.        int tblLen);
  444. #ifdef DC_DEBUG
  445. void dcCsrShow (ULONG devAdrs);
  446. #endif /* DC_DEBUG */
  448. /* RCP: Add utilities to read entries in Serial ROM for DEC21140 */
  449. USHORT dcReadRom (ULONG devAdrs, UCHAR lineCnt);
  450. int dcViewRom (ULONG devAdrs, UCHAR lineCnt, int cnt);
  452. /* RCP: Temporary reference of new global symbol */
  453. LOCAL STATUS sysLanIntEnable (int Level);
  455. /*******************************************************************************
  456. *
  457. * dcattach - publish the `dc' network interface.
  458. *
  459. * This routine publishes the `dc' interface by filling in a network interface
  460. * record and adding this record to the system list.  This routine also
  461. * initializes the driver and the device to the operational state.
  462. *
  463. * The <unit> parameter is used to specify the device unit to initialize.
  464. *
  465. * The <devAdrs> is used to specify the I/O address base of the device.
  466. *
  467. * The <ivec> parameter is used to specify the interrupt vector associated
  468. * with the device interrupt.
  469. *
  470. * The <ilevel> parater is used to specify the level of the interrupt which
  471. * the device would use.
  472. *
  473. * The <memAdrs> parameter can be used to specify the location of the
  474. * memory that will be shared between the driver and the device.  The value
  475. * NONE is used to indicate that the driver should obtain the memory.
  476. *
  477. * The <memSize> parameter is valid only if the <memAdrs> parameter is not
  478. * set to NONE, in which case <memSize> indicates the size of the
  479. * provided memory region.
  480. *
  481. * The <memWidth> parameter sets the memory pool's data port width (in bytes);
  482. * if it is NONE, any data width is used.
  483. *
  484. * The <pciMemBase> parameter defines the main memory base as seen from PCI bus.
  485. * 
  486. * The <dcOpMode> parameter defines the mode in which the device should be
  487. * operational.
  488. *
  489. * RCP:  Added for DEC21140 Serial ROM
  490. *
  491. * BUGS
  492. * To zero out LANCE data structures, this routine uses bzero(), which
  493. * ignores the <memWidth> specification and uses any size data access to
  494. * write to memory.
  495. *
  496. * RETURNS: OK or ERROR.
  497. */
  499. STATUS dcattach
  500.     (
  501.     int unit, /* unit number */
  502.     ULONG devAdrs, /* LANCE I/O address */
  503.     int ivec, /* interrupt vector */
  504.     int ilevel, /* interrupt level */
  505.     char * memAdrs, /* address of memory pool (-1 = malloc it) */
  506.     ULONG memSize, /* only used if memory pool is NOT malloc()'d */
  507.     int memWidth, /* byte-width of data (-1 = any width) */
  508.     ULONG pciMemBase, /* main memory base as seen from PCI bus */
  509.     int dcOpMode /* mode of operation */
  510.     )
  511.     {
  512.     DRV_CTRL * pDrvCtrl; /* pointer to drvctrl */
  513.     unsigned int sz; /* temporary size holder */
  514.     char * pShMem; /* start of the LANCE memory pool */
  515.     char * buf; /* temp buffer pointer */
  516.     void * pTemp; /* temp pointer */
  517.     DC_RDE * rmd; /* pointer to rcv descriptor */
  518.     DC_TDE * tmd; /* pointer to xmit descriptor */
  519.     int ix; /* counter */
  520. /* RCP: Added temporary value */
  521.     ULONG uTemp; /* temporary storage */
  522.     
  523.     /* Sanity check the unit number */
  525.     if (unit < 0 || unit >= MAX_UNITS)
  526.         return (ERROR);
  528.     /* Ensure single invocation per system life */
  530.     pDrvCtrl = & drvCtrl [unit];
  532.     if (pDrvCtrl->attached)
  533.         return (OK);
  535.     pDrvCtrl->ivec = ivec; /* interrupt vector */
  536.     pDrvCtrl->ilevel = ilevel; /* interrupt level */
  537.     pDrvCtrl->devAdrs = devAdrs; /* LANCE I/O address */
  538.     pDrvCtrl->pciMemBase  = pciMemBase; /* pci memory base */
  539.     pDrvCtrl->memWidth  = memWidth; /* memory width */
  540.     pDrvCtrl->dcOpMode = dcOpMode; /* mode of operation */
  542.     /* Publish the interface data record */
  544.     ether_attach (
  545.   & pDrvCtrl->idr.ac_if,
  546.   unit,
  547.   "dc",
  548.   (FUNCPTR) NULL,
  549.   (FUNCPTR) dcIoctl,
  550.   (FUNCPTR) dcOutput,
  551.   (FUNCPTR) dcReset
  552.  );
  554.     /* Create the transmit semaphore. */
  556.     if ((pDrvCtrl->TxSem = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE |
  557.        SEM_INVERSION_SAFE)) == NULL)
  558.         {
  559.         printf ("dc: error creating transmitter semaphoren");
  560.         return (ERROR);
  561.         }
  563.     /* Establish size of shared memory region we require */
  564.     
  565.     if ((int) memAdrs != NONE)  /* specified memory pool */
  566. {
  567. sz  = (memSize - (RMD_SIZ + TMD_SIZ + (dcLPool * DC_BUFSIZ) + 
  568.   FLTR_FRM_SIZE))
  569.       / ((2 * DC_BUFSIZ) + RMD_SIZ + TMD_SIZ);
  570. dcNumRds = max (sz, MIN_RDS);
  571. dcNumTds = max (sz, MIN_TDS);
  572. }
  574.     /* add it all up - allow for alignment adjustment */
  576.     sz = ((dcNumRds + 1) * RMD_SIZ) + (dcNumRds * DC_BUFSIZ) +
  577.  ((dcNumTds + 1) * TMD_SIZ) + (dcNumTds * DC_BUFSIZ) + 
  578.  (DC_BUFSIZ * dcLPool) + FLTR_FRM_SIZE;
  580.     /* Establish a region of shared memory */
  582.     /* OK. We now know how much shared memory we need.  If the caller
  583.      * provides a specific memory region, we check to see if the provided
  584.      * region is large enough for our needs.  If the caller did not
  585.      * provide a specific region, then we attempt to allocate the memory
  586.      * from the system, using the cache aware allocation system call.
  587.      */
  589.     switch ( (int) memAdrs )
  590.         {
  591.         default :       /* caller provided memory */
  592.             if ( memSize < sz )     /* not enough space */
  593.                 {
  594.                 printf ( "dc: not enough memory providedn" );
  595.                 return ( ERROR );
  596.                 }
  597.             pShMem = memAdrs;             /* set the beginning of pool */
  599.             /* assume pool is cache coherent, copy null structure */
  601.             pDrvCtrl->cacheFuncs = cacheNullFuncs;
  603.             break;
  605.         case NONE :     /* get our own memory */
  607.             /* Because the structures that are shared between the device
  608.              * and the driver may share cache lines, the possibility exists
  609.              * that the driver could flush a cache line for a structure and
  610.              * wipe out an asynchronous change by the device to a neighboring
  611.              * structure. Therefore, this driver cannot operate with memory
  612.              * that is not write coherent.  We check for the availability of
  613.              * such memory here, and abort if the system did not give us what
  614.              * we need.
  615.              */
  617.             if (!CACHE_DMA_IS_WRITE_COHERENT ())
  618.                 {
  619.                 printf ( "dc: device requires cache coherent memoryn" );
  620.                 return (ERROR);
  621.                 }
  623.             pShMem = (char *) cacheDmaMalloc ( sz );
  625.             if ((int)pShMem == NULL)
  626.                 {
  627.                 printf ( "dc: system memory unavailablen" );
  628.                 return (ERROR);
  629.                 }
  631.             /* copy the DMA structure */
  633.             pDrvCtrl->cacheFuncs = cacheDmaFuncs;
  635.             break;
  636.         }
  638.     if (intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC(ivec),dcInt,(int)pDrvCtrl)
  639.         == ERROR)
  640.         return (ERROR);
  642.     /*                        Turkey Carving
  643.      *                        --------------
  644.      *
  645.      *                          LOW MEMORY
  646.      *             |-------------------------------------|
  647.      *             |         The Rx descriptors          |
  648.      *             | (dcNumRds * sizeof (DC_RDE))        |
  649.      *             |-------------------------------------|
  650.      *             |          The receive buffers        |
  651.      *             |       (DC_BUFSIZ * dcNumRds)        |
  652.      *             |-------------------------------------|
  653.      *             |         The Rx loaner pool          |
  654.      *             |        (DC_BUFSIZ * dcLPool)        |
  655.      *             |-------------------------------------|
  656.      *             |         The Tx descriptors          |
  657.      *             | (dcNumTds *  sizeof (DC_TDE))       |
  658.      *             |-------------------------------------|
  659.      *             |           The transmit buffers      |
  660.      *             |       (DC_BUFSIZ * dcNumTds)        |
  661.      *             |-------------------------------------|
  662.      *             |           Setup Filter Frame        |
  663.      *             |           (FLTR_FRM_SIZE)           |
  664.      *             |-------------------------------------|
  665.      */
  667.     /* zero the shared memory */
  669.     bzero ( (char *) pShMem, (int) sz );
  671.     /* carve Rx memory structure */
  673.     pDrvCtrl->rxRing = (DC_RDE *) (((int)pShMem + 0x03) & ~0x03); /* wd align */
  674.     pDrvCtrl->dcNumRds = dcNumRds; /* receive ring size */
  675.     pDrvCtrl->rxIndex = 0;
  677.     /* Set up the Rx descriptors */
  679.     rmd = pDrvCtrl->rxRing;                      /* receive ring */
  680.     buf = (char *)(rmd + pDrvCtrl->dcNumRds);
  681.     for (ix = 0; ix < pDrvCtrl->dcNumRds; ix++, rmd++, buf += DC_BUFSIZ)
  682.         {
  683.         pTemp = DC_CACHE_VIRT_TO_PHYS (buf); /* convert to PCI  phys addr */
  684. pTemp = (void *)(MEM_TO_PCI_PHYS((ULONG)pTemp));
  685. rmd->rDesc2 = PCISWAP((ULONG)pTemp); /* buffer address 1 */
  686. rmd->rDesc3 = 0; /* no second buffer */
  688. /* buffer size */
  689. rmd->rDesc1 = PCISWAP(RDESC1_RBS1_VAL(DC_BUFSIZ) | 
  690.       RDESC1_RBS2_VAL(0));
  692. if (ix == (pDrvCtrl->dcNumRds - 1)) /* if its is last one */
  693.     rmd->rDesc1 |= PCISWAP(RDESC1_RER); /* end of receive ring */
  695. rmd->rDesc0 = PCISWAP(RDESC0_OWN); /* give ownership to lance */
  696.         }
  698.     /* setup Rx loaner pool */
  700.     pDrvCtrl->nLoanRx = dcLPool;
  701.     for (ix = 0; ix < dcLPool; ix++, buf += DC_BUFSIZ)
  702. {
  703.         pDrvCtrl->lPool[ix] = buf;
  704.         pDrvCtrl->refCnt[ix] = 0;
  705.         pDrvCtrl->pRefCnt[ix] = & pDrvCtrl->refCnt[ix];
  706. }
  708.     /* carve Tx memory structure */
  710.     pDrvCtrl->txRing = (DC_TDE *) (((int)buf + 0x03) & ~0x03); /* word align */
  711.     pDrvCtrl->dcNumTds = dcNumTds; /* transmit ring size */
  712.     pDrvCtrl->txIndex = 0;
  713.     pDrvCtrl->txDiIndex = 0;
  715.     /* Setup the Tx descriptors */
  717.     tmd = pDrvCtrl->txRing;                 /* transmit ring */
  718.     buf = (char *)(tmd + pDrvCtrl->dcNumTds);
  719.     for (ix = 0; ix < pDrvCtrl->dcNumTds; ix++, tmd++, buf += DC_BUFSIZ)
  720.         {
  721.         pTemp = DC_CACHE_VIRT_TO_PHYS (buf); /* convert to PCI phys addr */
  722. pTemp = (void *)(MEM_TO_PCI_PHYS((ULONG)pTemp));
  723. tmd->tDesc2 = PCISWAP((ULONG)pTemp); /* buffer address 1 */
  724. tmd->tDesc3 = 0; /* no second buffer */
  726. tmd->tDesc1 = PCISWAP((TDESC1_TBS1_PUT(0) |
  727.        TDESC1_TBS2_PUT(0) |
  728.        TDESC1_IC   |  /* intrpt on xmit */
  729.        TDESC1_LS          | /* last segment */
  730.        TDESC1_FS)); /* first segment */
  732. if (ix == (pDrvCtrl->dcNumTds - 1)) /* if its is last one */
  733.     tmd->tDesc1 |= PCISWAP(TDESC1_TER); /* end of Xmit ring */
  735. tmd->tDesc0 = 0 ; /* clear status */
  736.         }
  738.     /* carve Setup Filter Frame buffer */
  739.     
  740.     pDrvCtrl->pFltrFrm = (ULONG *)(((int)buf + 0x03) & ~0x03); /* word align */
  741.     buf += FLTR_FRM_SIZE;
  743.     /* Flush the write pipe */
  745.     CACHE_PIPE_FLUSH ();
  747.     /* Device Initialization */
  749.     dcChipReset (pDrvCtrl); /* reset the chip */
  751.     pTemp = DC_CACHE_VIRT_TO_PHYS (pDrvCtrl->rxRing);
  752.     pTemp = (void *)(MEM_TO_PCI_PHYS((ULONG)pTemp));
  754.     dcCsrWrite (devAdrs, CSR3, ((ULONG)pTemp)); /* recv descriptor */
  756.     pTemp = DC_CACHE_VIRT_TO_PHYS (pDrvCtrl->txRing);
  757.     pTemp = (void *)(MEM_TO_PCI_PHYS((ULONG)pTemp));
  759.     dcCsrWrite (devAdrs, CSR4, ((ULONG)pTemp)); /* xmit descriptor */
  761.     /* get the ethernet address */
  763. /* RCP: If DEC21140 make an alternate call */
  764.     if (!DEC21140(pDrvCtrl->dcOpMode))
  765.     {
  766.        if (dcEnetAddrGet (devAdrs, (char *) pDrvCtrl->idr.ac_enaddr, 6) != OK)
  767.    logMsg ("dc: error reading ethernet romn", 0,0,0,0,0,0);
  768.     }
  769.     else
  770. /* Get the ethernet address for the DEC21140 */
  771.     {
  772.        if (dc21140EnetAddrGet (devAdrs, (char *) pDrvCtrl->idr.ac_enaddr, 6) 
  773.    != OK)
  774.    logMsg ("dc21140: error reading ethernet romn", 0,0,0,0,0,0);
  775.     }
  777. /* RCP: Check to see if Full Duplex mode set */
  778.     if ((pDrvCtrl->dcOpMode & DC_FULLDUPLEX_FLAG) && 
  779. (pDrvCtrl->dcOpMode != NONE))
  780.      dcCsrWrite (devAdrs, CSR6, (dcCsrRead(devAdrs, CSR6) | CSR6_FD));
  782. /* RCP: DEC21040 Specific Setup */
  783.     if (!DEC21140(pDrvCtrl->dcOpMode))
  784.     {
  785.         dcAuiTpInit (devAdrs); /* configure AUI or 10BASE-T */
  786. /* RCP: Added initialization of CSR6 to turn off Promiscuous and Multicast */
  787. dcCsrWrite (devAdrs, CSR6, 0x0);
  788.     }
  789.     else
  790.     {
  791. /* RCP: DEC21140 Setup - these modes must be set before start Xmitter */
  793. /* Default to 10BT */
  794.      uTemp = dcCsrRead(devAdrs, CSR6);
  795.         uTemp = uTemp | CSR6_TTM | CSR6_BIT25;
  797. /* Now verify the parameters passed to configure the interface further */
  798.     if ((pDrvCtrl->dcOpMode & DC_100_MB_FLAG) &&
  799.     (pDrvCtrl->dcOpMode != NONE))
  800. {
  802. /* Hard Coded values from SROM offset to start 100MB testing.  The actual code should
  803.    be imbellished to handle the configuration for other possible interfaces other then
  804.    100BaseTx.  This information will be stored in the DC21140 Info Leaf of the SROM.
  805.    In the case of the DEC520-AA PMC, the starting offset for the DEC21140 Info Leaf
  806.    is 0x41.  This location contains some basic capabilities of the interface and the
  807.    initial state of CSR12.  Also there is a block count for the total number of interfaces
  808.    supported by the interface card.  For testing the default values for the SYM_SCR 
  809.    (100MBaseTx) port will be used.  The information for this interface starts in offset
  810.    0x49. The configuration for Full Duplex starts in offset 0x4D.  Potentially the driver
  811.    could be altered to do some autosensing and configuration, but for now arguments will
  812.    be passed to the driver to configure it.
  814. */
  815.    dcCsrWrite (devAdrs, CSR12, INIT_CSR12);
  816.    dcCsrWrite (devAdrs, CSR12, SYM_MODE);
  817.    
  818.        if ((pDrvCtrl->dcOpMode & DC_HBE_FLAG) &&
  819. (pDrvCtrl->dcOpMode != NONE))
  820. uTemp = (uTemp & ~CSR6_TTM) | CSR6_PS;
  821.    else
  822. uTemp = (uTemp & ~CSR6_TTM) | CSR6_PS | CSR6_HBD ;
  824.    uTemp = uTemp | (((pDrvCtrl->dcOpMode & DC_SCRAMBLER_FLAG) &&
  825.   (pDrvCtrl->dcOpMode != NONE)) ? CSR6_SCR : 0) |
  826.   (((pDrvCtrl->dcOpMode & DC_PCS_FLAG) &&
  827.   (pDrvCtrl->dcOpMode != NONE)) ? CSR6_PCS : 0);
  828. }
  830. dcCsrWrite (devAdrs, CSR6, uTemp);
  831.     }
  833. /* RCP: End of DEC21140 Code Addition */
  835.     /* clear the status register */
  837.     dcCsrWrite (devAdrs, CSR5, 0xffffffff);
  839.     /* set the operating mode to start Xmitter only */
  841. /* RCP: Modify this call to accomodate DEC21140 , add the Setting of Bit 25*/
  842.     dcCsrWrite (devAdrs, CSR6, 
  843.        (dcCsrRead (devAdrs, CSR6) |  CSR6_ST | CSR6_BIT25));
  845. /* RCP: Added Loopback modes */
  847.     if ((pDrvCtrl->dcOpMode & DC_ILOOPB_FLAG) &&
  848. (pDrvCtrl->dcOpMode != NONE))
  850. /* RCP: Internal loopback selected */
  851.      dcCsrWrite (devAdrs, CSR6, (dcCsrRead(devAdrs, CSR6) | CSR6_OM_ILB));
  852.     else
  854.      if ((pDrvCtrl->dcOpMode & DC_ELOOPB_FLAG) &&
  855.     (pDrvCtrl->dcOpMode != NONE))
  856. /* RCP: External loopback selected */
  857.    dcCsrWrite (devAdrs, CSR6, (dcCsrRead(devAdrs, CSR6) | CSR6_OM_ELB));
  859.     /* Xmit a Filter Setup Frame */
  861.     dcFltrFrmXmit (pDrvCtrl, (char *) pDrvCtrl->idr.ac_enaddr, 1);
  863.     /* set operating mode any additional operational mode set by user */
  865.     dcCsrWrite (devAdrs, CSR6, (dcCsrRead(devAdrs, CSR6) | 
  866.                                CSR6_SR                   | /* start receiver */
  867.            (((pDrvCtrl->dcOpMode & DC_MULTICAST_FLAG) &&
  868.  (pDrvCtrl->dcOpMode != NONE)) ? CSR6_PM: 0) |
  869.            (((pDrvCtrl->dcOpMode & DC_PROMISCUOUS_FLAG) &&
  870.  (pDrvCtrl->dcOpMode != NONE)) ? CSR6_PR: 0)
  871.       )); 
  873.     /* set up the interrupts */
  875. /* RCP: Modified to accomodate DEC21140 */
  876.     if (!DEC21140(pDrvCtrl->dcOpMode))
  877.      dcCsrWrite (devAdrs, CSR7, (
  878.        CSR7_NIM | /* normal interrupt mask */
  879.        CSR7_RIM | /* rcv  interrupt mask */
  880.        CSR7_TIM | /* xmit interrupt mask */
  881.        CSR7_TUM | /* xmit buff unavailble mask */
  882.        CSR7_AIM | /* abnormal interrupt mask */
  883.        CSR7_SEM | /* system error mask */
  884.        CSR7_LFM | /* link fail mask */
  885.        CSR7_RUM /* rcv buff unavailable mask */
  886.        ));
  887. /* RCP: Removed CSR7_LFM for DEC21140 */
  888.     else
  889.      dcCsrWrite (devAdrs, CSR7, (
  890.        CSR7_NIM | /* normal interrupt mask */
  891.        CSR7_RIM | /* rcv  interrupt mask */
  892.        CSR7_TIM | /* xmit interrupt mask */
  893.        CSR7_TUM | /* xmit buff unavailble mask */
  894.        CSR7_AIM | /* abnormal interrupt mask */
  895.        CSR7_SEM | /* system error mask */
  896.        CSR7_RUM /* rcv buff unavailable mask */
  897.        ));
  899.     sysLanIntEnable (ilevel);                   /* enable LANCE interrupts */
  902.     pDrvCtrl->idr.ac_if.if_flags |= (IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);
  904.     /* Set our flag */
  906.     pDrvCtrl->attached = TRUE;
  908.     return (OK);
  909.     }
  911. /*******************************************************************************
  912. *
  913. * dcReset - reset the interface
  914. *
  915. * Mark interface as inactive & reset the chip
  916. */
  918. LOCAL void dcReset
  919.     (
  920.     int unit
  921.     )
  922.     {
  923.     DRV_CTRL *pDrvCtrl = & drvCtrl [unit];
  925.     pDrvCtrl->idr.ac_if.if_flags = 0;
  926.     dcChipReset (pDrvCtrl);                           /* reset LANCE */
  927.     }
  929. /*******************************************************************************
  930. *
  931. * dcInt - handle controller interrupt
  932. *
  933. * This routine is called at interrupt level in response to an interrupt from
  934. * the controller.
  935. */
  937. LOCAL void dcInt
  938.     (
  939.     DRV_CTRL * pDrvCtrl /* pointer to device control struct */
  940.     )
  941.     {
  942.     DC_TDE * tmd; /* pointer to Xmit ring descriptor */
  943.     ULONG stat; /* status register */
  944.     ULONG devAdrs; /* device address */
  946.     devAdrs = pDrvCtrl->devAdrs;
  948.     /* Read the device status register */
  950.     stat = dcCsrRead(devAdrs, CSR5);
  952.     /* clear the interrupts */
  954.     dcCsrWrite(devAdrs, CSR5, stat);
  956.     /* If false interrupt, return. */
  958.     if ( ! (stat & (CSR5_NIS | CSR5_AIS)) )
  959.         return;
  961.     /* Check for system error */
  963.     if (stat & CSR5_SE)
  964.         {
  965.         ++pDrvCtrl->idr.ac_if.if_ierrors;
  967.         /* restart chip on fatal error */
  969. pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
  971. (void) netJobAdd (
  972.  (FUNCPTR)dcRestart,
  973.  pDrvCtrl->idr.ac_if.if_unit,
  974.  0,0,0,0
  975.  );
  976. return;
  977.         }
  979.     /* Have netTask handle any input packets */
  981.     if ((stat & CSR5_RI) && (!(stat & CSR5_RPS)))
  982.         {
  983. (void) netJobAdd (
  984.  (FUNCPTR)dcHandleRecvInt,
  985.  (int)pDrvCtrl,
  986.  0,0,0,0
  987.  );
  988. /* disable the Rx intr, re-enable in dcHandleRecvInt() */
  990. dcCsrWrite(devAdrs, CSR7, (stat & ~CSR7_RIM));
  991.         }
  993.     /*
  994.      * Did LANCE update any of the TMD's?
  995.      * If not then don't bother continuing with transmitter stuff
  996.      */
  998.     if (!(stat & CSR5_TI))
  999.         return;
  1001.     while (pDrvCtrl->txDiIndex != pDrvCtrl->txIndex)
  1002.         {
  1003.         /* disposal has not caught up */
  1005.         tmd = pDrvCtrl->txRing + pDrvCtrl->txDiIndex;
  1007.         /* if the buffer is still owned by LANCE, don't touch it */
  1009.         DC_CACHE_INVALIDATE (tmd, TMD_SIZ);
  1010.         if (tmd->tDesc0 & PCISWAP(TDESC0_OWN))
  1011.             break;
  1013.         /* now bump the tmd disposal index pointer around the ring */
  1015.         pDrvCtrl->txDiIndex = (pDrvCtrl->txDiIndex + 1) % pDrvCtrl->dcNumTds;
  1017.         /*
  1018.          * TDESC0.ES is an "OR" of LC, NC, UF, EC.
  1019.          * here for error conditions.
  1020.          */
  1022.         if (tmd->tDesc0 & PCISWAP(TDESC0_ES))
  1023.             {
  1025.             pDrvCtrl->idr.ac_if.if_oerrors++;     /* output error */
  1026.             pDrvCtrl->idr.ac_if.if_opackets--;
  1028.             /* If error was due to excess collisions, bump the collision
  1029.              * counter.
  1030.              */
  1031.             if (tmd->tDesc0 & PCISWAP(TDESC0_EC))
  1032.                 pDrvCtrl->idr.ac_if.if_collisions += 16;
  1034.     /* bump the collision counter if late collision */
  1036.             if (tmd->tDesc0 & PCISWAP(TDESC0_LC))
  1037.                 pDrvCtrl->idr.ac_if.if_collisions++;
  1039.             /* check for no carrier */
  1041.             if (tmd->tDesc0 & PCISWAP(TDESC0_NC | TDESC0_LO | TDESC0_LF))
  1042.                 logMsg ("dc%d: no carriern",
  1043.                     pDrvCtrl->idr.ac_if.if_unit, 0,0,0,0,0);
  1045.             /* Restart chip on fatal errors.
  1046.              * The following code handles the situation where the transmitter
  1047.              * shuts down due to an underflow error.  This is a situation that
  1048.              * will occur if the DMA cannot keep up with the transmitter.
  1049.              * It will occur if the LANCE is being held off from DMA access
  1050.              * for too long or due to significant memory latency.  DRAM
  1051.              * refresh or slow memory could influence this.  Many
  1052.              * implementation use a dedicated LANCE buffer.  This can be
  1053.              * static RAM to eliminate refresh conflicts; or dual-port RAM
  1054.              * so that the LANCE can have free run of this memory during its
  1055.              * DMA transfers.
  1056.              */
  1058.             if (tmd->tDesc0 & PCISWAP(TDESC0_UF))
  1059.                 {
  1060.                 pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
  1061.                 (void) netJobAdd (
  1062.                                  (FUNCPTR)dcRestart,
  1063.                                  pDrvCtrl->idr.ac_if.if_unit,
  1064.                                  0,0,0,0
  1065.                                  );
  1066.                 return;
  1067.                 }
  1068.             }
  1069. tmd->tDesc0 = 0; /* clear all error & stat stuff */
  1070.         }
  1072.     /* Flush the write pipe */
  1074.     CACHE_PIPE_FLUSH ();
  1076.     }
  1078. /*******************************************************************************
  1079. *
  1080. * dcHandleRecvInt - task level interrupt service for input packets
  1081. *
  1082. * This routine is called at task level indirectly by the interrupt
  1083. * service routine to do any message received processing.
  1084. */
  1086. LOCAL void dcHandleRecvInt
  1087.     (
  1088.     DRV_CTRL * pDrvCtrl /* pointer to device control struct */
  1089.     )
  1090.     {
  1091.     DC_RDE * rmd; /* pointer to Rx ring descriptor */
  1093.     while ((rmd = dcGetFullRMD (pDrvCtrl)) != NULL)
  1094.      dcRecv (pDrvCtrl, rmd);
  1096.     /* re-enable the Rx interrupt */
  1098.     dcCsrWrite (pDrvCtrl->devAdrs, CSR7, (dcCsrRead (pDrvCtrl->devAdrs, CSR7) |
  1099.   CSR7_RIM));
  1100.     }
  1102. /*******************************************************************************
  1103. *
  1104. * dcGetFullRMD - get next received message RMD
  1105. *
  1106. * Returns ptr to next Rx desc to process, or NULL if none ready.
  1107. */
  1109. LOCAL DC_RDE * dcGetFullRMD
  1110.     (
  1111.     DRV_CTRL * pDrvCtrl /* pointer to device control struct */
  1112.     )
  1113.     {
  1114.     DC_RDE * rmd; /* pointer to Rx ring descriptor */
  1116.     /* Refuse to do anything if flags are down */
  1118.     if  (
  1119.         (pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING) ) !=
  1120.         (IFF_UP | IFF_RUNNING)
  1121.         )
  1122.         return ((DC_RDE *) NULL);
  1125.     rmd = pDrvCtrl->rxRing + pDrvCtrl->rxIndex;       /* form ptr to Rx desc */
  1127.     DC_CACHE_INVALIDATE (rmd, RMD_SIZ);
  1130.     if ((rmd->rDesc0 & PCISWAP(RDESC0_OWN)) == 0)
  1131.         return (rmd);
  1132.     else
  1133.         return ((DC_RDE *) NULL);
  1134.     }
  1136. /*******************************************************************************
  1137. *
  1138. * dcRecv - process the next incoming packet
  1139. *
  1140. */
  1143. LOCAL STATUS dcRecv
  1144.     (
  1145.     DRV_CTRL * pDrvCtrl, /* pointer to device control struct */
  1146.     DC_RDE * rmd /* pointer to Rx ring descriptor */
  1147.     )
  1148.     {
  1149.     ENET_HDR * pEnetHdr; /* pointer to ethernet header */
  1150.     MBUF * pMbuf = NULL; /* pointer to mbuf */
  1151.     u_long pPhys;
  1152.     UCHAR * pData; /* pointer to data */
  1153.     int len; /* length */
  1154.     USHORT ether_type; /* ether packet type */
  1156.     /* Packet must be checked for errors. */
  1158.     if  (rmd->rDesc0 & PCISWAP(RDESC0_ES)) /* If error flag */
  1159.         {
  1160. /* error can occur on overflow, crc error, collision, 
  1161.  * frame too long, runt frame or length error
  1162.  */
  1163.         ++pDrvCtrl->idr.ac_if.if_ierrors;       /* bump error stat */
  1164.         goto cleanRXD;                          /* skip to clean up */
  1165.         }
  1167.     ++pDrvCtrl->idr.ac_if.if_ipackets; /* bump statistic */
  1169.     len = RDESC0_FL_GET(PCISWAP(rmd->rDesc0)); /* frame length */
  1171.     len -= 4;  /* Frame length includes CRC in it so subtract it */
  1173.     /* Get pointer to packet */
  1175.     pEnetHdr = DC_CACHE_PHYS_TO_VIRT(PCI_TO_MEM_PHYS(PCISWAP(rmd->rDesc2)));
  1177.     DC_CACHE_INVALIDATE (pEnetHdr, len);   /* make the packet data coherent */
  1180.     /* call input hook if any */
  1182.     if ((etherInputHookRtn == NULL) || ((*etherInputHookRtn)
  1183.        (& pDrvCtrl->idr.ac_if, (char *) pEnetHdr, len)) == 0)
  1184.         {
  1185.         /* Adjust length to size of data only */
  1187.         len -= SIZEOF_ETHERHEADER;
  1189.         /* Get pointer to packet data */
  1191.         pData = ((u_char *) pEnetHdr) + SIZEOF_ETHERHEADER;
  1193.         ether_type = ntohs ( pEnetHdr->type );
  1195.         /* OK to loan out buffer ? -> build an mbuf cluster */
  1196.     
  1197. if ((pDrvCtrl->nLoanRx > 0) && (USE_CLUSTER (len))
  1198.     &&
  1199.     ((pMbuf = build_cluster (pData, len, & pDrvCtrl->idr, MC_LANCE,
  1200.      pDrvCtrl->pRefCnt [(pDrvCtrl->nLoanRx - 1)], dcLoanFree,
  1201.      (int) pDrvCtrl, (int) pEnetHdr,
  1202.      (int) pDrvCtrl->pRefCnt [(pDrvCtrl->nLoanRx - 1)])) != NULL))
  1203.     {
  1204.             pPhys = (u_long) DC_CACHE_VIRT_TO_PHYS(MEM_TO_PCI_PHYS(
  1205.     (pDrvCtrl->lPool[--pDrvCtrl->nLoanRx])));
  1206.     rmd->rDesc2 = PCISWAP(pPhys);
  1207.     }
  1208.         else
  1209.             {
  1210.             if ((pMbuf = bcopy_to_mbufs (pData, len, 0, & pDrvCtrl->idr.ac_if,
  1211.                 pDrvCtrl->memWidth)) == NULL)
  1212. {
  1213.                 ++pDrvCtrl->idr.ac_if.if_ierrors; /* bump error stat */
  1214.                 goto cleanRXD;
  1215. }
  1216.             }
  1218.         /* send on up... */
  1220.         do_protocol_with_type (ether_type, pMbuf, & pDrvCtrl->idr, len);
  1222. /* RCP: This is a redundant increment of incoming packets, removed from original driver */
  1223. /*        ++pDrvCtrl->idr.ac_if.if_ipackets;*/ /* bump statistic */
  1225.         }
  1227.     /* Done with descriptor, clean up and give it to the device. */
  1229.     cleanRXD:
  1231.     /* clear status bits and give ownership to device */
  1233.     rmd->rDesc0 = PCISWAP(RDESC0_OWN);
  1235.     /* Flush the write pipe */
  1237.     CACHE_PIPE_FLUSH ();
  1239.     /* Advance our management index */
  1241.     pDrvCtrl->rxIndex = (pDrvCtrl->rxIndex + 1) % pDrvCtrl->dcNumRds;
  1243.     return (OK);
  1244.     }
  1246. /*******************************************************************************
  1247. *
  1248. * dcOutput - the driver output routine
  1249. *
  1250. */
  1252. LOCAL int dcOutput
  1253.     (
  1254.     IDR  * pIDR, /* pointer to interface data record */
  1255.     MBUF * pMbuf, /* pointer to mbuf */
  1256.     SOCK * pDest /* pointer to destination sock */
  1257.     )
  1258.     {
  1259.     char  destEnetAddr [6]; /* space for enet addr */
  1260.     USHORT packetType; /* type field for the packet */
  1261.     DRV_CTRL * pDrvCtrl; /* pointer to device control struct */
  1262.     DC_TDE * tmd; /* pointer to Tx ring descriptor */
  1263.     char * buf; /* pointer to buffer */
  1264.     int len; /* length */
  1266.     /* Check ifnet flags. Return error if incorrect. */
  1268.     if  (
  1269.         (pIDR->ac_if.if_flags & (IFF_UP | IFF_RUNNING)) !=
  1270.         (IFF_UP | IFF_RUNNING)
  1271.         )
  1272.         return (ENETDOWN);
  1274.     /* Attempt to convert socket addr into enet addr and packet type.
  1275.      * Note that if ARP resolution of the address is required, the ARP
  1276.      * module will call our routine again to transmit the ARP request
  1277.      * packet.  This means we may actually call ourselves recursively!
  1278.      */
  1280.     if (convertDestAddr (pIDR,pDest, destEnetAddr, &packetType, pMbuf) == FALSE)
  1281.         return (OK);    /* I KNOW returning OK is stupid, but it is correct */
  1283.     /* Get driver control pointer */
  1285.     pDrvCtrl = & drvCtrl [pIDR->ac_if.if_unit];
  1287.     /* Obtain exclusive access to transmitter.  This is necessary because
  1288.      * certain events can cause netTask to run a job that attempts to transmit
  1289.      * a packet.  We can only allow one task here at a time.
  1290.      */
  1292.     semTake (pDrvCtrl->TxSem, WAIT_FOREVER);
  1294.     /* See if next TXD is available */
  1296.     tmd = pDrvCtrl->txRing + pDrvCtrl->txIndex;
  1298.     DC_CACHE_INVALIDATE (tmd, TMD_SIZ);
  1300.     if  (
  1301.         ((tmd->tDesc0 & PCISWAP(TDESC0_OWN)) != 0) ||
  1302.         (
  1303.         ((pDrvCtrl->txIndex + 1) % pDrvCtrl->dcNumTds) == pDrvCtrl->txDiIndex
  1304. )
  1305.         )
  1306.         {
  1307.         m_freem (pMbuf);            /* Discard data */
  1308.         goto outputDone;
  1309.         }
  1311.     /* Get pointer to transmit buffer */
  1313.     buf = (char *)DC_CACHE_PHYS_TO_VIRT(PCI_TO_MEM_PHYS(PCISWAP(tmd->tDesc2)));
  1315.     /* Copy packet from MBUFs to our transmit buffer.  MBUFs are
  1316.      * transparently freed.
  1317.      */
  1318.     bcopy_from_mbufs ((buf + SIZEOF_ETHERHEADER), pMbuf, len,
  1319.       pDrvCtrl->memWidth);
  1321.     /* Fill in the Ethernet header */
  1323.     bcopy (destEnetAddr, buf, 6);
  1324.     bcopy ( (char *) pIDR->ac_enaddr, (buf + 6), 6);
  1325.     ((ENET_HDR *)buf)->type = packetType;
  1327.     tmd->tDesc0 = 0; /* clear buffer error status */
  1328.     tmd->tDesc1 &= PCISWAP(~TDESC1_TBS1_MSK);
  1329.     tmd->tDesc1 |= PCISWAP(TDESC1_TBS1_PUT(max (ETHERSMALL, 
  1330. (len + SIZEOF_ETHERHEADER))));
  1331.     tmd->tDesc0 = PCISWAP(TDESC0_OWN);  /* give ownership to device */
  1333.     CACHE_PIPE_FLUSH (); /* Flush the write pipe */
  1335.     /* Advance our management index */
  1337.     pDrvCtrl->txIndex = (pDrvCtrl->txIndex + 1) % pDrvCtrl->dcNumTds;
  1338.     
  1339.     if (dcKickStartTx)
  1340.      dcCsrWrite(pDrvCtrl->devAdrs, CSR1, CSR1_TPD); /* xmit poll demand */
  1342.     /* Bump the statistic counter. */
  1344.     pIDR->ac_if.if_opackets++;
  1346.     outputDone:
  1348.     /* Release exclusive access. */
  1350.     semGive (pDrvCtrl->TxSem);
  1352.     return (OK);
  1354.     }
  1356. /*******************************************************************************
  1357. *
  1358. * dcIoctl - the driver I/O control routine
  1359. *
  1360. * Process an ioctl request.
  1361. */
  1363. LOCAL int dcIoctl
  1364.     (
  1365.     IDR  * ifp, /* pointer interface data record */
  1366.     int cmd, /* command */
  1367.     caddr_t data /* data */
  1368.     )
  1369.     {
  1370.     int  error = 0;
  1371.     DRV_CTRL *  pDrvCtrl = (DRV_CTRL *)ifp; /* pointer to device */
  1373.     switch (cmd)
  1374.         {
  1375.         case SIOCSIFADDR:
  1376.             ifp->ac_ipaddr = IA_SIN (data)->sin_addr;
  1377.             break;
  1379.         case SIOCSIFFLAGS:
  1380.             /* No further work to be done */
  1381.             break;
  1383.         case IFF_PROMISC: /* set device in promiscuous mode */
  1384.     dcCsrWrite (pDrvCtrl->devAdrs, CSR6, 
  1385. (dcCsrRead(pDrvCtrl->devAdrs, CSR6) | CSR6_PR));
  1386.     break;
  1388.         default:
  1389.             error = EINVAL;
  1390.         }
  1392.     return (error);
  1393.     }
  1395. /*******************************************************************************
  1396. *
  1397. * dcChipReset - hardware reset of chip (stop it)
  1398. */
  1400. LOCAL int dcChipReset
  1401.     (
  1402.     DRV_CTRL * pDrvCtrl /* pointer to device control structure */
  1403.     )
  1404.     {
  1405.     ULONG   devAdrs = pDrvCtrl->devAdrs; /* device base address */
  1406.     ULONG ix; /* index */
  1408.     dcCsrWrite(devAdrs, CSR6, 0); /* stop rcvr & xmitter */
  1410.     dcCsrWrite(devAdrs, CSR7, 0); /* mask interrupts */
  1411.     
  1412.     dcCsrWrite(devAdrs, CSR0, CSR0_SWR);
  1414.     /* Wait Loop, Loop for at least 50 PCI cycles according to chip spec */
  1416.     for (ix = 0; ix < 0x1000; ix++)
  1417. ;
  1419.     /* any additional bus mode | give xmit & rcv process equal priority */
  1421.     dcCsrWrite (devAdrs, CSR0, dcCSR0Bmr | CSR0_BAR);
  1423.     for (ix = 0; ix < 0x1000; ix++) /* loop for some cycles */
  1424. ;
  1426.     return (OK);
  1427.     }
  1429. /*******************************************************************************
  1430. *
  1431. * dcAuiTpInit - initialize either AUI or 10BASE-T connection
  1432. *
  1433. * This function configures 10BASE-T interface. If the link pass state is 
  1434. * not achieved within two seconds then the AUI interface is initialized.
  1435. */
  1437. LOCAL void dcAuiTpInit
  1438.     (
  1439.     ULONG       devAdrs        /* device base I/O address */
  1440.     )
  1441.     {
  1443.     /* reset the SIA registers */
  1445.     dcCsrWrite (devAdrs, CSR13, 0);
  1446.     dcCsrWrite (devAdrs, CSR14, 0);
  1447.     dcCsrWrite (devAdrs, CSR15, 0);
  1449.     /* configure for the 10BASE-T */
  1451.     dcCsrWrite (devAdrs, CSR13, CSR13_CAC_CSR); /* 10BT auto configuration */
  1453.     taskDelay (sysClkRateGet() * 2); /* 2 second delay */
  1455.     if (dcCsrRead (devAdrs, CSR12) & (CSR12_LKF | CSR12_NCR))
  1456. {
  1457. /* 10BASE-T not connected initialize interface for AUI */
  1459. dcCsrWrite (devAdrs, CSR13, 0); /* reset SIA registers */
  1460. dcCsrWrite (devAdrs, CSR14, 0);
  1461. dcCsrWrite (devAdrs, CSR15, 0);
  1463. /* AUI auto configuration */
  1464. dcCsrWrite (devAdrs, CSR13, (CSR13_AUI_TP | CSR13_CAC_CSR));
  1465. }
  1466.     }
  1468. /*******************************************************************************
  1469. *
  1470. * dcCsrWrite - select and write a CSR register
  1471. *
  1472. */
  1473. LOCAL void dcCsrWrite
  1474.     (
  1475.     ULONG  devAdrs, /* device address base */
  1476.     int  reg, /* register to select */
  1477.     ULONG  value /* value to write */
  1478.     )
  1479.     {
  1480.     ULONG * csrReg;
  1482.     csrReg = (ULONG *)(devAdrs + (reg * DECPCI_REG_OFFSET));
  1484.     /* write val to CSR */
  1486.     *(csrReg) = PCISWAP(value);
  1487.     }
  1489. /*******************************************************************************
  1490. *
  1491. * dcCsrRead - select and read a CSR register
  1492. *
  1493. */
  1495. LOCAL ULONG dcCsrRead
  1496.     (
  1497.     ULONG devAdrs, /* device address base */
  1498.     int reg /* register to select */
  1499.     )
  1500.     {
  1501.     ULONG * csrReg; /* csr register */
  1502.     ULONG csrData; /* data in csr register */
  1504.     csrReg = (ULONG *)(devAdrs + (reg * DECPCI_REG_OFFSET));
  1506.     csrData = *csrReg;
  1508.     /* get contents of CSR */
  1510.     return ( PCISWAP(csrData));
  1511.     }
  1513. /*******************************************************************************
  1514. *
  1515. * dcRestart - restart the device after a fatal error
  1516. *
  1517. * This routine takes care of all the messy details of a restart.  The device
  1518. * is reset and re-initialized.  The driver state is re-synchronized.
  1519. */
  1521. LOCAL void dcRestart
  1522.     (
  1523.     int  unit /* unit to restart */
  1524.     )
  1525.     {
  1526.     ULONG status; /* status register */
  1527.     int ix; /* index variable */
  1528.     DC_RDE * rmd; /* pointer to receive descriptor */
  1529.     DC_TDE * tmd; /* pointer to Xmit descriptor */
  1530.     DRV_CTRL * pDrvCtrl = & drvCtrl [unit];
  1532.     rmd = pDrvCtrl->rxRing;      /* receive ring */
  1533.     tmd = pDrvCtrl->txRing;      /* transmit ring */
  1535.     pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING );
  1536.     fprintf (stderr, "Fatal Error. DEC Ethernet Chip Restartedn");
  1538.     status = dcCsrRead(pDrvCtrl->devAdrs, CSR6);
  1539.     dcCsrWrite (pDrvCtrl->devAdrs, CSR6, 0); /* reset mode register */
  1541.     for (ix = 0; ix < pDrvCtrl->dcNumRds; ix++, rmd++)
  1542.         {
  1543. /* buffer size */
  1544. rmd->rDesc1 = PCISWAP(RDESC1_RBS1_VAL(DC_BUFSIZ) | 
  1545.       RDESC1_RBS2_VAL(0));
  1547. if (ix == (pDrvCtrl->dcNumRds - 1)) /* if its is last one */
  1548. rmd->rDesc1 |= PCISWAP(RDESC1_RER); /* end of receive ring */
  1550. rmd->rDesc0 = PCISWAP(RDESC0_OWN); /* give ownership to lance */
  1551.         }
  1553.     for (ix = 0; ix < pDrvCtrl->dcNumTds; ix++, tmd++)
  1554.         {
  1555. tmd->tDesc1 = PCISWAP((TDESC1_TBS1_PUT(0) |
  1556.        TDESC1_TBS2_PUT(0) |
  1557.        TDESC1_IC   |  /* intrpt on xmit */
  1558.        TDESC1_LS          | /* last segment */
  1559.        TDESC1_FS)); /* first segment */
  1561. if (ix == (pDrvCtrl->dcNumTds - 1)) /* if its is last one */
  1562.     tmd->tDesc1 |= PCISWAP(TDESC1_TER); /* end of Xmit ring */
  1564. tmd->tDesc0 = 0 ; /* clear status */
  1565.         }
  1567.     /* clear the status register */
  1569.     dcCsrWrite (pDrvCtrl->devAdrs, CSR5, 0xffffffff);
  1571.     dcCsrWrite (pDrvCtrl->devAdrs, CSR6, status); /* restore mode */
  1573.     pDrvCtrl->idr.ac_if.if_flags |= (IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);
  1575.     }
  1577. /*******************************************************************************
  1578. *
  1579. * dcLoanFree - return the given buffer to loaner pool
  1580. *
  1581. * This routine returns <pRxBuf> to the pool of available loaner buffers.
  1582. * It also returns <pRef> to the pool of available loaner reference counters,
  1583. * then zeroes the reference count.
  1584. *
  1585. * RETURNS: N/A
  1586. */
  1587.  
  1588. LOCAL void dcLoanFree
  1589.     (
  1590.     DRV_CTRL * pDrvCtrl, /* pointer to device control structure */
  1591.     char * pRxBuf, /* pointer to receive buffer to free */
  1592.     UINT8 * pRef /* pointer to reference count */
  1593.     )
  1594.     {
  1595.     /* return loaned buffer to pool */
  1596.  
  1597.     pDrvCtrl->lPool[pDrvCtrl->nLoanRx] = pRxBuf;
  1598.  
  1599.     /* return loaned reference count to pool */
  1600.  
  1601.     pDrvCtrl->pRefCnt[pDrvCtrl->nLoanRx++] = pRef;
  1603.     /* reset reference count - should have been done from above, but... */
  1604.  
  1605.     *pRef = 0;
  1606.     }
  1608. /*******************************************************************************
  1609. *
  1610. * dcEnetAddrGet - gets the ethernet address from the ROM register.
  1611. *
  1612. * This routine gets the ethernet address from the ROM register.
  1613. * This routine returns the ethernet address into the pointer supplied to it.
  1614. * 
  1615. * RETURNS: OK/ERROR
  1616. */
  1618. LOCAL STATUS dcEnetAddrGet
  1619.     (
  1620.     ULONG devAdrs, /* device base I/O address */
  1621.     char *  enetAdrs, /* pointer to the ethernet address */ 
  1622.     int len /* number of bytes to read */
  1623.     )
  1624.     {
  1625.     FAST ULONG csr9Value; /* register to hold CSR9 */
  1626.     int ix; /* index register */
  1627.     BOOL eRomReady = FALSE; /* ethernet ROM register state */
  1629.     dcCsrWrite (devAdrs, CSR9, 0); /* reset rom pointer */
  1631.     while (len > 0)
  1632. {
  1633. for (ix = 0; ix < 10; ix++) /* try at least 10 times */
  1634.     {
  1635.     if ((csr9Value = dcCsrRead (devAdrs, CSR9)) & CSR9_DNV)
  1636. {
  1637. eRomReady = FALSE;
  1638.      DELAY(500);
  1639. }
  1640.     else
  1641. {
  1642. *enetAdrs++ = (UCHAR) csr9Value;
  1643. len--;
  1644. eRomReady = TRUE;
  1645. break;
  1646. }
  1647.     }
  1648. }
  1650.     if (!eRomReady)
  1651.      return (ERROR);
  1652.     else
  1653. return (OK);
  1654.     }
  1656. /*******************************************************************************
  1657. *
  1658. * RCP : New utility for DEC21140
  1659. * dc21140EnetAddrGet - gets the ethernet address from the ROM register 
  1660. *
  1661. * This routine gets the last two bytes of the ethernet address from the ROM
  1662. * register and concantenates this value to the predefined values for DEC PMCs..
  1663. * This routine returns the ethernet address into the pointer supplied to it.
  1664. *
  1665. * The procedure could be expanded in the future to allow for modification of
  1666. * Ethernet addresses in the serial ROM.  It will have to be modified to
  1667. * accomodate the differences in the onboard 100Mb/s ethernet on future 
  1668. * Motorola products.
  1669. * 
  1670. * RETURNS: OK/ERROR
  1671. */
  1673. LOCAL STATUS dc21140EnetAddrGet
  1674.     (
  1675.     ULONG devAdrs, /* device base I/O address */
  1676.     char *  enetAdrs, /* pointer to the ethernet address */ 
  1677.     int len /* number of bytes to read */
  1678.     )
  1679.     {
  1680.     int i,ix, /* index register */
  1681.      tmpInt; /* temporary int */
  1682.     union mixed
  1683.     {
  1684.      char Char[4]; /* temporary 2 by char */
  1685. USHORT Short[2]; /* temporary USHORT */
  1686. ULONG   Long; /* temporay ULONG */
  1687.     } tmp;
  1689.     for (i = DEC_PMC_POS, ix = 0; i<(3+DEC_PMC_POS); i++, ix++)
  1690.     {
  1691.      if ((tmp.Short[0] = dcReadRom (devAdrs, i)) == ERROR)
  1692.    return (ERROR);
  1693. enetAdrs[ix++] = tmp.Char[1];
  1694. enetAdrs[ix] = tmp.Char[0];
  1695.     }
  1696.     tmpInt = -1;
  1697.     return (OK);
  1698.     }
  1701. /*******************************************************************************
  1702. *
  1703. * dcFltrFrmXmit - Transmit the setup filter frame.
  1704. *
  1705. * This routine transmits the setup filter frame.
  1706. * The setup frame is not transmitted actually over the wire. The setup frame
  1707. * which is transmitted is 192 bytes. The tranmitter should be in an on state
  1708. * before this function is called. This call has been coded so that the 
  1709. * setup frame can be transmitted after the chip is done with the 
  1710. * intialization taking into consideration for adding multicast support.
  1711. * 
  1712. * RETURNS: OK/ERROR
  1713. */
  1715. LOCAL int dcFltrFrmXmit
  1716.     (
  1717.     DRV_CTRL * pDrvCtrl,  /* pointer to device control structure */
  1718.     char *  pPhysAdrsTbl,  /* pointer to physical address table */ 
  1719.     int  tblLen /* size of the physical address table */
  1720.     )
  1721.     {
  1722.     DC_TDE * tmd; /* pointer to Tx ring descriptor */
  1723.     ULONG *  pBuff; /* pointer to the Xmit buffer */
  1724.     int status = OK; /* intialize status as OK */
  1725.     ULONG csr7Val; /* value in CSR7 */
  1727.     semTake (pDrvCtrl->TxSem, WAIT_FOREVER);
  1729.     if (dcFltrFrmSetup (pDrvCtrl, pPhysAdrsTbl, tblLen) != OK)
  1730. {
  1731. status = ERROR; /* not able to set up filter frame */
  1732. goto setupDone; /* set up done */
  1733. }
  1735.     /* See if next TXD is available */
  1737.     tmd = pDrvCtrl->txRing + pDrvCtrl->txIndex;
  1739.     DC_CACHE_INVALIDATE (tmd, TMD_SIZ);
  1741.     if  (
  1742.         ((tmd->tDesc0 & PCISWAP(TDESC0_OWN)) != 0) ||
  1743.         (
  1744.         ((pDrvCtrl->txIndex + 1) % pDrvCtrl->dcNumTds) == pDrvCtrl->txDiIndex
  1745. )
  1746.         )
  1747. {
  1748. status = ERROR; /* not able to set up filter frame */
  1749. goto setupDone; /* set up done */
  1750. }
  1752.     /* Get pointer to transmit buffer */
  1754.     pBuff = DC_CACHE_PHYS_TO_VIRT(PCI_TO_MEM_PHYS(PCISWAP(tmd->tDesc2)));
  1756.     /* copy into Xmit buffer */
  1758.     bcopyLongs ((char *)pDrvCtrl->pFltrFrm, (char *)pBuff, 
  1759. FLTR_FRM_SIZE_ULONGS);
  1761.     tmd->tDesc0 = 0; /* clear buffer error status */
  1762.     tmd->tDesc1 |= PCISWAP(TDESC1_SET); /* frame type as set up */
  1763.     tmd->tDesc1 &= PCISWAP(~TDESC1_TBS1_MSK);
  1764.     tmd->tDesc1 |= PCISWAP(TDESC1_TBS1_PUT(FLTR_FRM_SIZE));
  1765.     tmd->tDesc0 = PCISWAP(TDESC0_OWN);  /* give ownership to device */
  1767.     CACHE_PIPE_FLUSH (); /* Flush the write pipe */
  1769.     /* Advance our management index */
  1771.     pDrvCtrl->txIndex = (pDrvCtrl->txIndex + 1) % pDrvCtrl->dcNumTds;
  1772.     pDrvCtrl->txDiIndex = (pDrvCtrl->txDiIndex + 1) % pDrvCtrl->dcNumTds;
  1774.     csr7Val = dcCsrRead (pDrvCtrl->devAdrs, CSR7);
  1776.     dcCsrWrite(pDrvCtrl->devAdrs, CSR7, 0); /* mask interrupts */
  1777.     
  1778.     if (dcKickStartTx)
  1779.      dcCsrWrite(pDrvCtrl->devAdrs, CSR1, CSR1_TPD); /* xmit poll demand */
  1781.     /* wait for the own bit to change */
  1783.     while (tmd->tDesc0 & PCISWAP (TDESC0_OWN))
  1784. ;
  1786.     tmd->tDesc0 = 0; /* clear status bits */
  1787.     tmd->tDesc1 &= PCISWAP(~TDESC1_SET);
  1789.     dcCsrWrite(pDrvCtrl->devAdrs, CSR7, csr7Val); /* restore value */
  1791.     setupDone:
  1793.     /* Release exclusive access. */
  1795.     semGive (pDrvCtrl->TxSem);
  1797.     return (status);
  1798.     }
  1800. /*******************************************************************************
  1801. *
  1802. * dcFltrFrmSetup - set up the filter frame.
  1803. *
  1804. * This routine sets up the filter frame to filter the physical addresses
  1805. * on the incoming frames. The setup filter frame buffer is 192 bytes. This
  1806. * setup frame needs to be transmitted before transmitting and receiving 
  1807. * any frames. 
  1808. * 
  1809. * RETURNS: OK/ERROR
  1810. */
  1812. LOCAL int dcFltrFrmSetup
  1813.     (
  1814.     DRV_CTRL * pDrvCtrl,  /* pointer to device control structure */
  1815.     char *  pPhysAdrsTbl,  /* pointer to physical address table */ 
  1816.     int  tblLen /* size of the physical address table */
  1817.     )
  1818.     {
  1819.     int ix; /* index variable */
  1820.     int jx;  /* inner index variable */
  1821.     ULONG * pFltrFrm; /* pointer to the filter frame */
  1822.     USHORT * pPhysAddrs; /* pointer to the physical addresses */
  1824.     if (tblLen > FLTR_FRM_ADRS_NUM)
  1825. return (ERROR);
  1827.     pFltrFrm = pDrvCtrl->pFltrFrm;
  1829.     for (ix = 0; ix < FLTR_FRM_SIZE_ULONGS; ix++)
  1830. *pFltrFrm++ = FLTR_FRM_DEF_ADRS;
  1832.     pFltrFrm = pDrvCtrl->pFltrFrm;
  1833.     pPhysAddrs = (USHORT *) (pPhysAdrsTbl);
  1835.     for (ix = 0; ix < tblLen; ix++)
  1836. {
  1837. for (jx = 0; jx < (FLTR_FRM_ADRS_SIZE/sizeof (USHORT)); jx++)
  1838.     {
  1839. #if (_BYTE_ORDER == _BIG_ENDIAN)
  1840.     *pFltrFrm =  (*pPhysAddrs << 16);
  1841. #else
  1842.     *pFltrFrm = ((LSB(*pPhysAddrs) << 8) | MSB(*pPhysAddrs));
  1843. #endif
  1844.     pPhysAddrs++;
  1845.     pFltrFrm++;
  1846.     }
  1847. }
  1848.     return (OK);
  1849.     }
  1851. #include "sys/socket.h"
  1853. /*******************************************************************************
  1854. *
  1855. * convertDestAddr - converts socket addr into enet addr and packet type
  1856. *
  1857. */
  1859. LOCAL BOOL convertDestAddr
  1860.     (
  1861.     IDR *pIDR,                          /* ptr to i/f data record */
  1862.     SOCK *pDestSktAddr,                 /* ptr to a generic sock addr */
  1863.     char *pDestEnetAddr,                /* where to write enet addr */
  1864.     u_short *pPacketType,               /* where to write packet type */
  1865.     MBUF *pMbuf                         /* ptr to mbuf data */
  1866.     )
  1867.     {
  1869.     /***** Internet family *****/
  1871.     {
  1872.     struct in_addr destIPAddr;              /* not used */
  1873.     int trailers;                           /* not supported */
  1875.      if (pDestSktAddr->sa_family == AF_INET)
  1876.         {
  1877.         *pPacketType = ETHERTYPE_IP;            /* stuff packet type */
  1878.         destIPAddr = ((struct sockaddr_in *) pDestSktAddr)->sin_addr;
  1880.         if (!arpresolve (pIDR, pMbuf, &destIPAddr, pDestEnetAddr, &trailers))
  1881.             return (FALSE);     /* if not yet resolved */
  1883.         return (TRUE);
  1884.         }
  1885.     }
  1888.     /***** Generic family *****/
  1890.     {
  1891.     ENET_HDR *pEnetHdr;
  1893.     if (pDestSktAddr->sa_family == AF_UNSPEC)
  1894.         {
  1895.         pEnetHdr = (ENET_HDR *) pDestSktAddr->sa_data;      /* ptr to hdr */
  1896.         bcopy (pEnetHdr->dst, pDestEnetAddr, 6);            /* copy dst addr */
  1897.         *pPacketType = pEnetHdr->type;                      /* copy type */
  1898.         return (TRUE);
  1899.         }
  1900.     }
  1903.     /* Unsupported family */
  1905.     return (FALSE);
  1907.     } /* End of convertDestAddr() */
  1909. /* END OF FILE */
  1912. /*******************************************************************************
  1913. *
  1914. * RCP : New utility for DEC21140
  1915. * dcReadRom - reads an specified entry in the Serial ROM 
  1916. *
  1917. * This routine uses the line number passed to the function and returns
  1918. * the two bytes of information that is associated with it.  This will later
  1919. * be used by the dc21140GetEthernetAdr function.  It can also be used to 
  1920. * review the ROM contents itself.
  1921. *
  1922. * The function must first send some initial bit paterns to the CSR9 which 
  1923. * contains the Serial ROM Control bits.  Then the line index into the ROM
  1924. * will be evaluated bit by bit to program the ROM.  The 2 bytes of data
  1925. * will be extracted and processed into a normal pair of bytes. 
  1926. * 
  1927. * RETURNS: Short Value in ROM/ERROR
  1928. */
  1930. #define BASE CSR9_SSR_FLAG|CSR9_SWO_FLAG
  1932. USHORT dcReadRom
  1933.     (
  1934.     ULONG devAdrs, /* device base I/O address */
  1935.     UCHAR lineCnt  /* Serial ROM line Number */ 
  1936.     )
  1937.     {
  1938.     int ix,  /* index register */
  1939.      intCnt; /* address loop count */
  1940.     USHORT tmpShort;
  1941.     ULONG tmpLong; 
  1943. /* Is the line offset valid, and if so, how large is it */
  1945.     if (lineCnt > SROM_SIZE || lineCnt < 0)
  1946.     {
  1947. printf ("dcReadRom FAILED, bad lineCntn");
  1948.      return (ERROR);
  1949.     }
  1950.     if (lineCnt < 64)
  1951.     {
  1952. intCnt = 6;
  1953. lineCnt = lineCnt << 2;  /* Prepare lineCnt for processing */
  1954.     }
  1955.     else
  1956. intCnt = 8;
  1958. /* Command the Serial ROM to the correct Line */
  1960. /* Preamble of Command */
  1961.     dcCsrWrite (devAdrs, CSR9, 0x00000000|BASE); /* Command 1 */
  1962.     NSDELAY (30);
  1964.     dcCsrWrite (devAdrs, CSR9, 0x00000001|BASE); /* Command 2 */
  1965.     NSDELAY (50);
  1966.     dcCsrWrite (devAdrs, CSR9, 0x00000003|BASE); /* Command 3 */
  1967.     NSDELAY (250);
  1968.     dcCsrWrite (devAdrs, CSR9, 0x00000001|BASE); /* Command 4 */
  1969.     NSDELAY (100);
  1972. /* Command Phase */
  1974.     dcCsrWrite (devAdrs, CSR9, 0x00000005|BASE); /* Command 5 */
  1975.     NSDELAY (150);
  1976.     dcCsrWrite (devAdrs, CSR9, 0x00000007|BASE); /* Command 6 */
  1977.     NSDELAY (250);
  1978.     dcCsrWrite (devAdrs, CSR9, 0x00000005|BASE); /* Command 7 */
  1979.     NSDELAY (250);
  1980.     dcCsrWrite (devAdrs, CSR9, 0x00000007|BASE); /* Command 8 */
  1981.     NSDELAY (250);
  1982.     dcCsrWrite (devAdrs, CSR9, 0x00000005|BASE); /* Command 9 */
  1983.     NSDELAY (100);
  1984.     dcCsrWrite (devAdrs, CSR9, 0x00000001|BASE); /* Command 10 */
  1985.     NSDELAY (150);
  1986.     dcCsrWrite (devAdrs, CSR9, 0x00000003|BASE); /* Command 11 */
  1987.     NSDELAY (250);
  1988.     dcCsrWrite (devAdrs, CSR9, 0x00000001|BASE); /* Command 12 */
  1989.     NSDELAY (100);
  1990.     
  1991. /* Address Phase */
  1993.     for (ix=0; ix < intCnt; ix++)
  1994.     {
  1995. tmpLong = (lineCnt & 0x80)>>5; /* Extract and move bit to bit 3)
  1996. /* Write the command */
  1997.      dcCsrWrite (devAdrs, CSR9, tmpLong | 0x00000001|BASE);/* Command 13 */
  1998.      NSDELAY (150);
  1999.      dcCsrWrite (devAdrs, CSR9, tmpLong | 0x00000003|BASE);/* Command 14 */
  2000.      NSDELAY (250);
  2001.      dcCsrWrite (devAdrs, CSR9, tmpLong | 0x00000001|BASE);/* Command 15 */
  2002.      NSDELAY (100);
  2004. lineCnt = lineCnt<<1;  /* Adjust significant address bit */
  2005.     }
  2007.      NSDELAY (150);
  2009. /* Data Phase */
  2011.     tmpShort =0;
  2012.     for (ix=15; ix >= 0; ix--)
  2013.     {
  2014. /* Write the command */
  2015.      dcCsrWrite (devAdrs, CSR9, 0x00000003|BASE); /* Command 16 */
  2016.      NSDELAY (100);
  2017. /* Extract the data */
  2018.      tmpShort |= (((dcCsrRead (devAdrs, CSR9) & 0x00000008)>>3)
  2019.    <<ix);  /* Command 17 */
  2020.      NSDELAY (150);
  2021.      dcCsrWrite (devAdrs, CSR9, 0x00000001|BASE); /* Command 18 */
  2022.      NSDELAY (250);
  2024.     }
  2026. /* Finish up command */
  2027.     dcCsrWrite (devAdrs, CSR9, 0x00000000); /* Command 19 */
  2028.     NSDELAY (100);
  2030.     return (tmpShort);
  2031.     }
  2033. /* RCP: Function to read all of serial rom and store the data in the
  2034.         data structure passed to the function.  The count value will
  2035.         indicate how much of the serial rom to read.  The routine with also
  2036.         swap the the bytes as the come in. */
  2038. void dcReadAllRom
  2039.     (
  2040.     ULONG devAdrs, /* device base I/O address */
  2041.     UCHAR *buffer, /* destination bufferr */ 
  2042.     int cnt             /* Amount to extract in bytes */
  2043.     )
  2044.     {
  2046.     USHORT total, index;
  2047.     union tmp_type {
  2048.         USHORT Short;
  2049.      char   Byte [2]; /* temporary 2 by char */
  2050.     } tmp;
  2052.     total = 0;
  2053.     for (index=0, total=0; total < cnt/2; index+=2, total++)
  2054.     {
  2055. tmp.Short = dcReadRom (devAdrs, total);
  2056. buffer[index]=tmp.Byte[1];
  2057. buffer[index+1]=tmp.Byte[0];
  2058.     }
  2059.     }
  2061. #ifdef DC_DEBUG
  2063. int dcViewRom
  2064.     (
  2065.     ULONG devAdrs, /* device base I/O address */
  2066.     UCHAR lineCnt, /* Serial ROM line Number */ 
  2067.     int cnt             /* Amount to display */
  2068.     )
  2069.     {
  2071.     USHORT total;
  2072.     union tmp_type {
  2073.         USHORT Short;
  2074.      char   Byte [2]; /* temporary 2 by char */
  2075.     } tmp;
  2078.     if (lineCnt/2 < 0 || lineCnt/2 > SROM_SIZE)
  2079. return (ERROR);
  2081.     total = 0;
  2082.     while (lineCnt/2 < SROM_SIZE && cnt > 0)
  2083.     {
  2084. if (!(total%16))
  2085.    printf ("nValues for line %2d =>0x  ", total);
  2086. tmp.Short = dcReadRom (devAdrs, lineCnt);
  2087. printf ("%4x ",tmp.Short);
  2088. lineCnt++ ;
  2089. total +=2;
  2090. cnt -=2;
  2091.     }
  2092.     printf ("n");
  2093.     return (total);
  2094.     }
  2097. void dcCsrShow
  2098.     (
  2099.     ULONG devAdrs
  2100.     )
  2101.     {
  2102.     printf ("n");
  2103.     printf ("CSR0t 0x%xn", dcCsrRead(devAdrs, CSR0));
  2104.     printf ("CSR1t 0x%xn", dcCsrRead(devAdrs, CSR1));
  2105.     printf ("CSR2t 0x%xn", dcCsrRead(devAdrs, CSR2));
  2106.     printf ("CSR3t 0x%xn", dcCsrRead(devAdrs, CSR3));
  2107.     printf ("CSR4t 0x%xn", dcCsrRead(devAdrs, CSR4));
  2108.     printf ("CSR5t 0x%xn", dcCsrRead(devAdrs, CSR5));
  2109.     printf ("CSR6t 0x%xn", dcCsrRead(devAdrs, CSR6));
  2110.     printf ("CSR7t 0x%xn", dcCsrRead(devAdrs, CSR7));
  2111.     printf ("CSR8t 0x%xn", dcCsrRead(devAdrs, CSR8));
  2112.     printf ("CSR9t 0x%xn", dcCsrRead(devAdrs, CSR9));
  2113.     printf ("CSR10t 0x%xn", dcCsrRead(devAdrs, CSR10));
  2114.     printf ("CSR11t 0x%xn", dcCsrRead(devAdrs, CSR11));
  2115.     printf ("CSR12t 0x%xn", dcCsrRead(devAdrs, CSR12));
  2116.     printf ("CSR13t 0x%xn", dcCsrRead(devAdrs, CSR13));
  2117.     printf ("CSR14t 0x%xn", dcCsrRead(devAdrs, CSR14));
  2118.     printf ("CSR15t 0x%xn", dcCsrRead(devAdrs, CSR15));
  2120.     }
  2121. #endif /* DC_DEBUG */
  2123. /*  RCP:  New Versions of code that will be added to the BSP later. */
  2124. /******************************************************************************
  2125. *
  2126. * sysLanIntEnable - enable the LAN interrupt
  2127. *
  2128. * This routine enables interrupts at a specified level for the on-board
  2129. * LAN chip.  LAN interrupts are controlled by the IBC chip.
  2130. * The LANCE chip on this board is on the PCI bus. The PCI interrupts should
  2131. * be routed through the IBC to the processor. LANCE chip asserts PCI IRQ0
  2132. * which has to be routed through IBC to generate ISA IRQ10. This routing 
  2133. * done through programming the PCI route registers in the IBC chip.
  2134. *
  2135. * RETURNS: OK, always.
  2136. *
  2137. * SEE ALSO: sysLanIntDisable()
  2138. */
  2140. LOCAL STATUS sysLanIntEnable
  2141.     (
  2142.      int intLevel  /* interrupt level to enable */
  2143.     )
  2144.     {
  2145.     sysIntEnablePIC (intLevel);
  2146.     return (OK);
  2147.     }