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

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

VxWorks

开发平台：

C/C++

if_lnPci.c：源码内容
  1. /* if_lnPci.c - AMD Am79C970 PCnet-PCI Ethernet network interface driver */
  3. /* Copyright 1984-2001 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01j,19oct01,dat  Documentation formatting
  10. 01i,17oct00,spm  merged from version 01j of tor2_0_x branch (base version 01h):
  11.                  removed obsolete ether_attach prototype
  12. 01h,26aug98,sut  Renamed lnCSR_3B to lnPciCSR_3B DOC required
  13. 01g,15jul97,spm  added ARP request to SIOCSIFADDR ioctl handler
  14. 01f,19may97,spm  removed compiler warnings and unused function lnBcrRead()
  15. 01e,15may97,spm  reverted to bcopy routines for mbufs in BSD 4.4
  16. 01d,13may97,map  made ethernet addr copy, and ether packet type endian safe;
  17.                  reinit BCNT for Rx descriptors  [SPR# 8431]
  18. 01c,28apr97,map  added lnRestart functionality [SPR# 8223]
  19. 01b,01apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  20. 01a,11jan95,vin  written from 02q of if_ln.c with minimal clean up.
  21. */
  23. /*
  24. This module implements the Advanced Micro Devices Am79C970 PCnet-PCI
  25. Ethernet 32 bit network interface driver.
  27. The PCnet-PCI ethernet controller is inherently little endian because
  28. the chip is designed to operate on a PCI bus which is a little endian
  29. bus. The software interface to the driver is divided into three parts.
  30. The first part is the PCI configuration registers and their set up. 
  31. This part is done at the BSP level in the various BSPs which use this
  32. driver. The second and third part are dealt in the driver. The second
  33. part of the interface comprises of the I/O control registers and their
  34. programming. The third part of the interface comprises of the descriptors
  35. and the buffers. 
  37. This driver is designed to be moderately generic, operating unmodified
  38. across the range of architectures and targets supported by VxWorks.  To
  39. achieve this, the driver must be given several target-specific parameters,
  40. and some external support routines must be provided.  These parameters,
  41. and the mechanisms used to communicate them to the driver, are detailed
  42. below.  If any of the assumptions stated below are not true for your
  43. particular hardware, this driver will probably not function correctly with
  44. it.
  46. This driver supports only one LANCE unit per CPU.  The driver can be
  47. configured to support big-endian or little-endian architectures.  It
  49. contains error recovery code to handle known device errata related to DMA
  50. activity. 
  52. Big endian processors can be connected to the PCI bus through some controllers
  53. which take care of hardware byte swapping. In such cases all the registers 
  54. which the chip DMA s to have to be swapped and written to, so that when the
  55. hardware swaps the accesses, the chip would see them correctly. The chip still
  56. has to be programmed to operated in little endian mode as it is on the PCI bus.
  57. If the cpu board hardware automatically swaps all the accesses to and from the
  58. PCI bus, then input and output byte stream need not be swapped. 
  60. BOARD LAYOUT
  61. This device is on-board.  No jumpering diagram is necessary.
  63. EXTERNAL INTERFACE
  64. This driver provides the standard external interface with the following
  65. exceptions.  All initialization is performed within the attach routine;
  66. there is no separate initialization routine.  Therefore, in the global interface
  67. structure, the function pointer to the initialization routine is NULL.
  69. The only user-callable routine is lnPciattach(), which publishes the `lnPci'
  70. interface and initializes the driver and device.
  72. TARGET-SPECIFIC PARAMETERS
  73. .iP "bus mode"
  74. This parameter is a global variable that can be modified at run-time.
  76. The LANCE control register #3 determines the bus mode of the device,
  77. allowing the support of big-endian and little-endian architectures.
  78. This parameter, defined as "u_long lnPciCSR_3B", is the value that will
  79. be placed into LANCE control register #3.  The default value supports
  80. Motorola-type buses.  For information about changing this parameter, see 
  81. the manual
  82. .I "Advanced Micro Devices Local Area Network Controller Am79C970 (PCnet-PCI)."
  84. .iP "base address of device registers"
  85. This parameter is passed to the driver by lnPciattach().  It 
  86. indicates to the driver where to find the RDP register.
  88. The LANCE presents two registers to the external interface, the RDP (register
  89. data port) and RAP (register address port) registers.  This driver assumes 
  90. that these two registers occupy two unique addresses in a memory space
  91. that is directly accessible by the CPU executing this driver.  The driver
  92. assumes that the RDP register is mapped at a lower address than the RAP
  93. register; the RDP register is therefore considered the "base address."
  95. .iP "interrupt vector"
  96. This parameter is passed to the driver by lnPciattach().
  98. This driver configures the LANCE device to generate hardware interrupts
  99. for various events within the device; thus it contains
  100. an interrupt handler routine.  The driver calls intConnect() to connect 
  101. its interrupt handler to the interrupt vector generated as a result of 
  102. the LANCE interrupt.
  104. .iP "interrupt level"
  105. This parameter is passed to the driver by lnPciattach().
  107. Some targets use additional interrupt controller devices to help organize and
  108. service the various interrupt sources.  This driver avoids all board-specific
  109. knowledge of such devices.  During the driver's initialization, the external
  110. routine sysLanIntEnable() is called to perform any board-specific operations
  111. required to turn on LANCE interrupt generation. A similar routine,
  112. sysLanIntDisable(), is called by the driver before a LANCE reset to perform
  113. board-specific operations required to turn off LANCE interrupt generation.
  114. For a description of sysLanIntEnable(), and sysLanIntDisable(), see "External
  115. Support Requirements" below.
  117. This parameter is passed to the external routine.
  119. .iP "shared memory address"
  120. This parameter is passed to the driver by lnPciattach().
  122. The LANCE device is a DMA type of device and typically shares access to
  123. some region of memory with the CPU.  This driver is designed for systems
  124. that directly share memory between the CPU and the LANCE.  It
  125. assumes that this shared memory is directly available to it
  126. without any arbitration or timing concerns.
  128. This parameter can be used to specify an explicit memory region for use
  129. by the LANCE.  This should be done on hardware that restricts the LANCE
  130. to a particular memory region.  The constant NONE can be used to indicate
  131. that there are no memory limitations, in which case, the driver 
  132. attempts to allocate the shared memory from the system space.
  134. .iP "shared memory size"
  135. This parameter is passed to the driver by lnPciattach().
  137. This parameter can be used to explicitly limit the amount of shared
  138. memory (bytes) this driver will use.  The constant NONE can be used to
  139. indicate no specific size limitation.  This parameter is used only if
  140. a specific memory region is provided to the driver.
  142. .iP "shared memory width"
  143. This parameter is passed to the driver by lnPciattach().
  145. Some target hardware that restricts the shared memory region to a
  146. specific location also restricts the access width to this region by
  147. the CPU.  On these targets, performing an access of an invalid width
  148. will cause a bus error.
  150. This parameter can be used to specify the number of bytes of access
  151. width to be used by the driver during access to the shared memory.
  152. The constant NONE can be used to indicate no restrictions.
  154. Current internal support for this mechanism is not robust; implementation 
  155. may not work on all targets requiring these restrictions.
  157. .iP "shared memory buffer size"
  158. This parameter is passed to the driver by lnPciattach().
  160. The driver and LANCE device exchange network data in buffers.  This
  161. parameter permits the size of these individual buffers to be limited.
  162. A value of zero indicates that the default buffer size should be used.
  163. The default buffer size is large enough to hold a maximum-size Ethernet
  164. packet.
  166. Use of this parameter should be rare.  Network performance
  167. will be affected, since the target will no longer be able to receive
  168. all valid packet sizes.
  170. .iP "Ethernet address"
  171. This parameter is obtained directly from a global memory location.
  173. During initialization, the driver needs to know the Ethernet address for
  174. the LANCE device.  The driver assumes that this address is available in
  175. a global, six-byte character array, lnEnetAddr[].  This array is
  176. typically created and stuffed by the BSP code.
  177. .LP
  179. EXTERNAL SUPPORT REQUIREMENTS
  180. This driver requires one external support function:
  181. .iP "void sysLanIntEnable (int level)" "" 9 -1
  183. This routine provides a target-specific enable of the interrupt for the LANCE
  184. device.  Typically, this involves programming an interrupt controller
  185. hardware, either internal or external to the CPU.
  187. This routine is called during chip initialization, at startup and each LANCE
  188. device reset.
  190. .iP "void sysLanIntDisable (int level)" "" 9 -1
  192. This routine provides a target-specific disable of the interrupt for the LANCE
  193. device.  Typically, this involves programming an interrupt controller
  194. hardware, either internal or external to the CPU.
  196. This routine is called before a LANCE device reset.
  198. .LP
  200. SYSTEM RESOURCE USAGE
  201. When implemented, this driver requires the following system resources:
  203.     - one mutual exclusion semaphore
  204.     - one interrupt vector
  205.     - 24 bytes in the initialized data section (data)
  206.     - 208 bytes in the uninitialized data section (BSS)
  208. The above data and BSS requirements are for the MC68020 architecture 
  209. and may vary for other architectures.  Code size (text) varies greatly between
  210. architectures and is therefore not quoted here.
  212. If the driver is not given a specific region of memory via the lnPciattach()
  213. routine, then it calls cacheDmaMalloc() to allocate the memory to be shared 
  214. with the LANCE.  The size requested is 80,542 bytes.  If a memory region
  215. is provided to the driver, the size of this region is adjustable to suit
  216. user needs.
  218. The LANCE can only be operated if the shared memory region is write-coherent
  219. with the data cache.  The driver cannot maintain cache coherency
  220. for the device for data that is written by the driver because fields
  221. within the shared structures are asynchronously modified by both the driver
  222. and the device, and these fields may share the same cache line.
  224. SEE ALSO: ifLib, 
  225. .I "Advanced Micro Devices PCnet-PCI Ethernet Controller for PCI."
  226. */
  228. #include "vxWorks.h"
  229. #include "stdlib.h"
  230. #include "taskLib.h"
  231. #include "logLib.h"
  232. #include "intLib.h"
  233. #include "netLib.h"
  234. #include "stdio.h"
  235. #include "stdlib.h"
  236. #include "sysLib.h"
  237. #include "iv.h"
  238. #include "memLib.h"
  239. #include "cacheLib.h"
  240. #include "sys/ioctl.h"
  241. #include "etherLib.h"
  243. #ifndef DOC             /* don't include when building documentation */
  244. #include "net/mbuf.h"
  245. #endif  /* DOC */
  247. #include "net/protosw.h"
  248. #include "sys/socket.h"
  249. #include "errno.h"
  251. #include "net/if.h"
  252. #include "net/route.h"
  254. #include "netinet/in.h"
  255. #include "netinet/in_systm.h"
  256. #include "netinet/in_var.h"
  257. #include "netinet/ip.h"
  258. #include "netinet/if_ether.h"
  259. #include "net/if_subr.h"
  260. #include "semLib.h"
  262. #include "drv/netif/if_lnPci.h" /* device description header */
  265. /***** LOCAL DEFINITIONS *****/
  267. /* descriptor size */
  268. #define RMD_SIZ  sizeof(ln_rmd)
  269. #define TMD_SIZ  sizeof(ln_tmd)
  271. /* Configuration items */
  273. #define LN_MIN_FIRST_DATA_CHAIN 96      /* min size of 1st buf in data-chain */
  274. #define LN_MAX_MDS              128     /* max number of [r|t]md's for LANCE */
  276. #define LN_BUFSIZ      (ETHERMTU + ENET_HDR_REAL_SIZ + 6)
  278. #define LN_RMD_RLEN     5       /* ring size as a power of 2 -- 32 RMD's */
  279. #define LN_TMD_TLEN     5       /* same for transmit ring    -- 32 TMD's */
  281. #define MAX_UNITS       1       /* maximum units supported */
  283. /*
  284.  * If LN_KICKSTART_TX is TRUE the transmitter is kick-started to force a
  285.  * read of the transmit descriptors, otherwise the internal polling (1.6msec)
  286.  * will initiate a read of the descriptors.  This should be FALSE is there
  287.  * is any chance of memory latency or chip accesses detaining the LANCE DMA,
  288.  * which results in a transmitter UFLO error.  This can be changed with the
  289.  * global lnKickStartTx below.
  290.  */
  292. #define LN_KICKSTART_TX TRUE
  294. /* Cache macros */
  296. #define LN_CACHE_INVALIDATE(address, len) 
  297.         CACHE_DRV_INVALIDATE (&pDrvCtrl->cacheFuncs, (address), (len))
  299. #define LN_CACHE_VIRT_TO_PHYS(address) 
  300.         CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, (address))
  302. #define LN_CACHE_PHYS_TO_VIRT(address) 
  303.         CACHE_DRV_PHYS_TO_VIRT (&pDrvCtrl->cacheFuncs, (address))
  305. /* memory to PCI address translation macros */
  307. #define PCI_TO_MEM_PHYS(pciAdrs) 
  308. ((pciAdrs) - (pDrvCtrl->pciMemBase))
  310. #define MEM_TO_PCI_PHYS(memAdrs) 
  311. ((memAdrs) + (pDrvCtrl->pciMemBase))
  313. /* Typedefs for external structures that are not typedef'd in their .h files */
  315. typedef struct mbuf MBUF;
  316. typedef struct arpcom IDR;                  /* Interface Data Record wrapper */
  317. typedef struct ifnet IFNET;                 /* real Interface Data Record */
  318. typedef struct sockaddr SOCK;
  320. #ifdef BSD43_DRIVER
  322. /* The Ethernet header */
  324. typedef struct enet_hdr
  325.     {
  326.     char dst [6];
  327.     char src [6];
  328.     u_short type;
  329.     } ENET_HDR;
  331. #define ENET_HDR_SIZ        sizeof(ENET_HDR)
  333. #endif            /* BSD43_DRIVER */
  335. #define ENET_HDR_REAL_SIZ   14
  337. /* The definition of the driver control structure */
  339. typedef struct drv_ctrl
  340.     {
  341.     IDR         idr;                /* Interface Data Record */
  343.     ln_ib       *ib;                 /* ptr to Initialization Block */
  345.     struct
  346.         {
  347.         int     r_po2;                  /* RMD ring size as a power of 2! */
  348.         int     r_size;                 /* RMD ring size (power of 2!) */
  349.         int     r_index;                /* index into RMD ring */
  350.         ln_rmd  *r_ring;                /* RMD ring */
  351.         char    *r_bufs;                /* receive buffers base */
  352.         } rmd_ring;
  354.     struct
  355.         {
  356.         int     t_po2;                  /* TMD ring size as a power of 2! */
  357.         int     t_size;                 /* TMD ring size (power of 2!) */
  358.         int     t_index;                /* index into TMD ring */
  359.         int     d_index;                /* index into TMD ring */
  360.         ln_tmd  *t_ring;                /* TMD ring */
  361.         char    *t_bufs;                /* transmit buffers base */
  362.         } tmd_ring;
  364.     BOOL        attached;               /* indicates unit is attached */
  365.     SEM_ID      TxSem;                  /* transmitter semaphore */
  366.     u_char      flags;                  /* misc control flags */
  367.     int         ivec;                   /* interrupt vector */
  368.     int         ilevel;                 /* interrupt level */
  369.     LN_DEVICE   *devAdrs;               /* device structure address */
  370.     char        *memBase;               /* LANCE memory pool base */
  371.     int         memWidth;               /* width of data port */
  372.     ULONG pciMemBase; /* memory base as seen from PCI*/
  373.     int         bufSize;                /* size of buffer in the LANCE ring */
  374.     CACHE_FUNCS cacheFuncs;             /* cache function pointers */
  376.     } DRV_CTRL;
  378. #define DRV_CTRL_SIZ    sizeof(DRV_CTRL)
  380. /* Definitions for the flags field */
  382. #define LS_PROMISCUOUS_FLAG     0x1
  383. #define LS_MEM_ALLOC_FLAG       0x2
  384. #define LS_PAD_USED_FLAG        0x4
  385. #define LS_RCV_HANDLING_FLAG    0x8
  386. #define LS_START_OUTPUT_FLAG    0x10
  388. /* Shorthand structure references */
  390. #define rpo2         rmd_ring.r_po2
  391. #define rsize        rmd_ring.r_size
  392. #define rindex       rmd_ring.r_index
  393. #define rring        rmd_ring.r_ring
  395. #define tpo2         tmd_ring.t_po2
  396. #define tsize        tmd_ring.t_size
  397. #define tindex       tmd_ring.t_index
  398. #define dindex       tmd_ring.d_index
  399. #define tring        tmd_ring.t_ring
  402. /***** GLOBALS *****/
  404. IMPORT unsigned char lnEnetAddr []; /* Ethernet address to load into lance */
  406. ULONG lnPciCSR_3B = 0 ;    /* allows external setting of bus modes */
  408. void panic ();
  409. void sysLanIntEnable (int ilevel);
  410. void sysLanIntDisable (int ilevel);
  411. BOOL arpresolve ();
  414. /***** LOCALS *****/
  416. static int lnTsize = LN_TMD_TLEN;    /* deflt xmit ring size as power of 2 */
  417. static int lnRsize = LN_RMD_RLEN;    /* deflt recv ring size as power of 2 */
  418. static BOOL lnKickStartTx = LN_KICKSTART_TX;
  421. /* The array of driver control structures */
  423. static DRV_CTRL  drvCtrl [MAX_UNITS];
  425. /* initial word offsets from LANCE base address to access these registers */
  427. static u_int CSROffset = 0;
  428. static u_int RAPOffset = 1;
  429. static u_int BDPOffset = 3;
  431. /* forward static functions */
  433. static void  lnReset (int unit);
  434. static void  lnInt (DRV_CTRL *pDrvCtrl);
  435. static void  lnHandleRecvInt (DRV_CTRL *pDrvCtrl);
  436. static STATUS  lnRecv (DRV_CTRL *pDrvCtrl, ln_rmd *rmd);
  437. #ifdef BSD43_DRIVER
  438. static int  lnOutput (IDR *ifp, MBUF *m0, SOCK *dst);
  439. #else
  440. LOCAL  void  lnPciStartOutput (DRV_CTRL *  pDrvCtrl);
  441. #endif /* BSD43_DRIVER */
  442. static int  lnIoctl (IDR *ifp, int cmd, caddr_t data);
  443. static int  lnChipReset (DRV_CTRL *pDrvCtrl);
  444. static ln_rmd * lnGetFullRMD (DRV_CTRL *pDrvCtrl);
  445. static void  lnCsrWrite (DRV_CTRL * pDrvCtrl, int reg, ULONG value);
  446. static ULONG  lnCsrRead (DRV_CTRL * pDrvCtrl, int reg);
  447. static void  lnBcrWrite (DRV_CTRL * pDrvCtrl, int reg, ULONG value);
  448. static STATUS   lnRestartSetup (DRV_CTRL *pDrvCtrl);
  449. static void     lnRestart (DRV_CTRL *pDrvCtrl);
  450. #ifdef BSD43_DRIVER
  451. static BOOL  convertDestAddr (IDR *pIDR, SOCK *pDestSktAddr,
  452.                                  char *pDestEnetAddr, u_short *pPacketType,
  453.                                  MBUF *pMbuf);
  454. #endif
  456. /*******************************************************************************
  457. *
  458. * lnPciattach - publish the `lnPci' network interface and initialize the driver and device
  459. *
  460. * This routine publishes the `ln' interface by filling in a network interface
  461. * record and adding this record to the system list.  This routine also
  462. * initializes the driver and the device to the operational state.
  463. *
  464. * The <memAdrs> parameter can be used to specify the location of the
  465. * memory that will be shared between the driver and the device.  The value
  466. * NONE is used to indicate that the driver should obtain the memory.
  467. *
  468. * The <memSize> parameter is valid only if the <memAdrs> parameter is not
  469. * set to NONE, in which case <memSize> indicates the size of the
  470. * provided memory region.
  471. *
  472. * The <memWidth> parameter sets the memory pool's data port width (in bytes);
  473. * if it is NONE, any data width is used.
  474. *
  475. * BUGS
  476. * To zero out LANCE data structures, this routine uses bzero(), which
  477. * ignores the <memWidth> specification and uses any size data access to
  478. * write to memory.
  479. *
  480. * RETURNS: OK or ERROR.
  481. */
  483. STATUS lnPciattach
  484.     (
  485.     int unit, /* unit number */
  486.     char * devAdrs, /* LANCE I/O address */
  487.     int ivec, /* interrupt vector */
  488.     int ilevel, /* interrupt level */
  489.     char * memAdrs, /* address of memory pool (-1 = malloc it) */
  490.     ULONG memSize, /* used if memory pool is NOT malloc()'d */
  491.     int memWidth, /* byte-width of data (-1 = any width)     */
  492.     ULONG     pciMemBase, /* memory base as seen from PCI*/
  493.     int spare2 /* not used */
  494.     )
  495.     {
  496.     DRV_CTRL     *pDrvCtrl;
  497.     unsigned int sz;           /* temporary size holder */
  498.     char         *pTurkey;     /* start of the LANCE memory pool */
  501.     /* Sanity check the unit number */
  503.     if (unit < 0 || unit >= MAX_UNITS)
  504.         return (ERROR);
  506.     /* Ensure single invocation per system life */
  508.     pDrvCtrl = & drvCtrl [unit];
  510.     if (pDrvCtrl->attached)
  511.         return (OK);
  513.     /* Publish the interface data record */
  515. #ifdef BSD43_DRIVER
  516.     ether_attach (& pDrvCtrl->idr.ac_if, unit, "lnPci", (FUNCPTR) NULL,
  517.                   (FUNCPTR) lnIoctl, (FUNCPTR) lnOutput, (FUNCPTR) lnReset);
  518. #else
  519.     ether_attach    (
  520.                     &pDrvCtrl->idr.ac_if,
  521.                     unit,
  522.                     "lnPci",
  523.                     (FUNCPTR) NULL,
  524.                     (FUNCPTR) lnIoctl,
  525.                     (FUNCPTR) ether_output,  /* generic output for Ethernet */
  526.                     (FUNCPTR) lnReset
  527.                     );
  529.     pDrvCtrl->idr.ac_if.if_start = (FUNCPTR)lnPciStartOutput;
  531. #endif
  533.     /* Create the transmit semaphore. */
  535.     pDrvCtrl->TxSem = semMCreate    (
  536.                                     SEM_Q_PRIORITY |
  537.                                     SEM_DELETE_SAFE |
  538.                                     SEM_INVERSION_SAFE
  539.                                     );
  541.     if (pDrvCtrl->TxSem == NULL)
  542.         {
  543.         printf ("lnPci: error creating transmitter semaphoren");
  544.         return (ERROR);
  545.         }
  548.     { /***** Establish size of shared memory region we require *****/
  550.     if ((int) memAdrs != NONE)  /* specified memory pool */
  551.         {
  552.         /*
  553.          * With a specified memory pool we want to maximize
  554.          * lnRsize and lnTsize
  555.          */
  557.         sz = (memSize - (RMD_SIZ + TMD_SIZ + sizeof (ln_ib)))
  558.                / ((2 * LN_BUFSIZ) + RMD_SIZ + TMD_SIZ);
  560.         sz >>= 1;               /* adjust for roundoff */
  562.         for (lnRsize = 0; sz != 0; lnRsize++, sz >>= 1)
  563.             ;
  565.         lnTsize = lnRsize;      /* lnTsize = lnRsize for convenience */
  566.         }
  568.     /* limit ring sizes to reasonable values */
  570.     if (lnRsize < 2)
  571.         lnRsize = 2;            /* 4 buffers is reasonable min */
  573.     if (lnRsize > 7)
  574.         lnRsize = 7;            /* 128 buffers is max for chip */
  576.     /* limit ring sizes to reasonable values */
  578.     if (lnTsize < 2)
  579.         lnTsize = 2;            /* 4 buffers is reasonable min */
  581.     if (lnTsize > 7)
  582.         lnTsize = 7;            /* 128 buffers is max for chip */
  585.     /* Add it all up */
  587.     sz = (sizeof (ln_ib)) +
  588.          ( ((1 << lnRsize) + 1) * RMD_SIZ ) +
  589.          (LN_BUFSIZ << lnRsize) +
  590.          ( ((1 << lnTsize) + 1) * TMD_SIZ ) +
  591.          (LN_BUFSIZ << lnTsize) +
  592.          6;                        /* allow for alignment adjustment */
  593.     }
  596.     { /***** Establish a region of shared memory *****/
  598.     /* OK. We now know how much shared memory we need.  If the caller
  599.      * provides a specific memory region, we check to see if the provided
  600.      * region is large enough for our needs.  If the caller did not
  601.      * provide a specific region, then we attempt to allocate the memory
  602.      * from the system, using the cache aware allocation system call.
  603.      */
  605.     switch ( (int) memAdrs )
  606.         {
  607.         default :       /* caller provided memory */
  608.             if ( memSize < sz )     /* not enough space */
  609.                 {
  610.                 printf ( "lnPci: not enough memory providedn" );
  611.                 return ( ERROR );
  612.                 }
  613.             pTurkey = memAdrs;             /* set the beginning of pool */
  615.             /* assume pool is cache coherent, copy null structure */
  617.             pDrvCtrl->cacheFuncs = cacheNullFuncs;
  619.             break;
  621.         case NONE :     /* get our own memory */
  623.             /* Because the structures that are shared between the device
  624.              * and the driver may share cache lines, the possibility exists
  625.              * that the driver could flush a cache line for a structure and
  626.              * wipe out an asynchronous change by the device to a neighboring
  627.              * structure. Therefore, this driver cannot operate with memory
  628.              * that is not write coherent.  We check for the availability of
  629.              * such memory here, and abort if the system did not give us what
  630.              * we need.
  631.              */
  633.             if (!CACHE_DMA_IS_WRITE_COHERENT ())
  634.                 {
  635.                 printf ( "lnPci: device requires cache coherent memoryn" );
  636.                 return (ERROR);
  637.                 }
  639.             pTurkey = (char *) cacheDmaMalloc ( sz );
  641.             if ((int)pTurkey == NULL)
  642.                 {
  643.                 printf ( "lnPci: system memory unavailablen" );
  644.                 return (ERROR);
  645.                 }
  647.             /* copy the DMA structure */
  649.             pDrvCtrl->cacheFuncs = cacheDmaFuncs;
  651.             break;
  652.         }
  653.     }
  655.     /*                        Turkey Carving
  656.      *                        --------------
  657.      *
  658.      *                          LOW MEMORY
  659.      *
  660.      *             |-------------------------------------|
  661.      *             |       The initialization block      |
  662.      *             |         (sizeof (ln_ib))            |
  663.      *             |-------------------------------------|
  664.      *             |         The Rx descriptors          |
  665.      *             | (1 << lnRsize) * sizeof (ln_rmd)|
  666.      *             |-------------------------------------|
  667.      *             |          The receive buffers        |
  668.      *             |       (LN_BUFSIZ << lnRsize)        |
  669.      *             |-------------------------------------|
  670.      *             |         The Tx descriptors          |
  671.      *             | (1 << lnTsize) * sizeof (ln_tmd)|
  672.      *             |-------------------------------------|
  673.      *             |           The transmit buffers      |
  674.      *             |       (LN_BUFSIZ << lnTsize)        |
  675.      *             |-------------------------------------|
  676.      */
  678.     /* Save some things */
  680.     pDrvCtrl->memBase  = (char *)((ULONG)pTurkey & 0xff000000);
  681.     pDrvCtrl->memWidth = memWidth;
  682.     pDrvCtrl->bufSize = LN_BUFSIZ;
  683.     pDrvCtrl->pciMemBase  = pciMemBase; /* pci memory base */
  685.     if ((int) memAdrs == NONE)
  686.         pDrvCtrl->flags |= LS_MEM_ALLOC_FLAG;
  688.     { /***** Carve up the turkey *****/
  690.     /* First let's clean the whole turkey */
  692.     bzero ( (char *) pTurkey, (int) sz );
  694.     /* carve out initialization block */
  696.     pDrvCtrl->ib = (ln_ib *)pTurkey;
  697.     sz = sizeof (ln_ib);                /* size of initialization block */
  699.     /* carve out receive message descriptor (RMD) ring structure */
  701.     pDrvCtrl->rpo2 = lnRsize;              /* remember for lnConfig */
  702.     pDrvCtrl->rsize = (1 << lnRsize);      /* receive ring size */
  704.     /* make it 16 byte aligned */
  706.     pDrvCtrl->rring = (ln_rmd *) (((int)pDrvCtrl->ib + sz + 0x0f) & ~0x0f);
  708.     sz = (1 << lnRsize) * RMD_SIZ;
  710.     pDrvCtrl->rmd_ring.r_bufs = (char *)((int)pDrvCtrl->rring + sz);
  712.     sz = (LN_BUFSIZ << lnRsize);   /* room for all the receive buffers */
  714.     /* carve out transmit message descriptor (TMD) ring structure */
  716.     pDrvCtrl->tpo2 = lnTsize;              /* remember for lnConfig */
  717.     pDrvCtrl->tsize = (1 << lnTsize);      /* transmit ring size */
  719.     pDrvCtrl->tring = (ln_tmd *) (((int)pDrvCtrl->rmd_ring.r_bufs + sz + 0x0f)
  720.   & ~0x0f);
  722.     sz = (1 << lnTsize) * TMD_SIZ;
  724.     /* carve out transmit buffer space */
  726.     pDrvCtrl->tmd_ring.t_bufs = (char *)((int)pDrvCtrl->tring + sz);
  727.     }
  730.     /* Save some values */
  732.     pDrvCtrl->ivec       = ivec;                 /* interrupt vector */
  733.     pDrvCtrl->ilevel     = ilevel;               /* interrupt level */
  734.     pDrvCtrl->devAdrs    = (LN_DEVICE *)devAdrs; /* LANCE I/O address */
  736.     /* Obtain our Ethernet address and save it */
  738.     bcopy ((char *) lnEnetAddr, (char *)pDrvCtrl->idr.ac_enaddr, 6);
  740.     /***** Device Initializations *****/
  742.     if (lnChipReset (pDrvCtrl) == ERROR) /* reset lance device */
  743.      {
  744.         logMsg ("lnPci: Device failed to resetn", 0,0,0,0,0,0);
  745.   return (ERROR);
  746. }
  748.     if (intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC(ivec),lnInt,(int)pDrvCtrl)
  749.         == ERROR)
  750.         return (ERROR);
  752.     if (lnRestartSetup (pDrvCtrl) == ERROR)
  753.         return (ERROR);
  755.     pDrvCtrl->attached = TRUE;
  757.     return (OK);
  758.     }
  760. /*******************************************************************************
  761. *
  762. * lnReset - reset the interface
  763. *
  764. * Mark interface as inactive & reset the chip
  765. */
  767. static void lnReset
  768.     (
  769.     int unit
  770.     )
  771.     {
  772.     DRV_CTRL *pDrvCtrl = & drvCtrl [unit];
  774.     pDrvCtrl->idr.ac_if.if_flags = 0;
  775.     lnChipReset (pDrvCtrl);                           /* reset LANCE */
  776.     }
  778. /*******************************************************************************
  779. *
  780. * lnInt - handle controller interrupt
  781. *
  782. * This routine is called at interrupt level in response to an interrupt from
  783. * the controller.
  784. */
  786. static void lnInt
  787.     (
  788.     DRV_CTRL  *pDrvCtrl
  789.     )
  790.     {
  791.     ln_tmd         *tmd;
  792.     int            *pDindex;
  793.     int            *pTindex;
  794.     int            *pTsize;
  795.     ln_tmd         *pTring;
  796.     ULONG    stat;
  799.     /* Read the device status register */
  801.     stat = lnCsrRead (pDrvCtrl, 0);
  803.     /* If false interrupt, return. */
  805.     if ( ! (stat & CSR0_INTR) )
  806.         return;
  808.     /*
  809.      * enable interrupts, clear receive and/or transmit interrupts, and clear
  810.      * any errors that may be set.
  811.      */
  813.     lnCsrWrite (pDrvCtrl, 0, ((stat &
  814.             (CSR0_BABL|CSR0_CERR|CSR0_MISS|CSR0_MERR|
  815.              CSR0_RINT|CSR0_TINT|CSR0_IDON)) | CSR0_INEA));
  817.     /* Check for errors */
  819.     if (stat & (CSR0_BABL | CSR0_MISS | CSR0_MERR))
  820.         {
  821.         ++pDrvCtrl->idr.ac_if.if_ierrors;
  823.         /* restart chip on fatal error */
  825.         if (stat & CSR0_MERR)        /* memory error */
  826.             {
  827.             pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
  828.             (void) netJobAdd (
  829.                              (FUNCPTR)lnRestart,
  830.                              pDrvCtrl->idr.ac_if.if_unit,
  831.                              0,0,0,0
  832.                              );
  833.             }
  834.         }
  836.     /* Have netTask handle any input packets */
  838.     if ((stat & CSR0_RINT) && (stat & CSR0_RXON))
  839.         {
  840.         if ( ! (pDrvCtrl->flags & LS_RCV_HANDLING_FLAG) )
  841.             {
  842.             pDrvCtrl->flags |= LS_RCV_HANDLING_FLAG;
  843.             (void) netJobAdd (
  844.                              (FUNCPTR)lnHandleRecvInt,
  845.                              (int)pDrvCtrl,
  846.                              0,0,0,0
  847.                              );
  848.             }
  849.         }
  851.     /*
  852.      * Did LANCE update any of the TMD's?
  853.      * If not then don't bother continuing with transmitter stuff
  854.      */
  856.     if (!(stat & CSR0_TINT))
  857.         return;
  859.     pDindex = &pDrvCtrl->dindex;
  860.     pTindex = &pDrvCtrl->tindex;
  861.     pTsize  = &pDrvCtrl->tsize;
  862.     pTring  = pDrvCtrl->tring;
  864.     while (*pDindex != *pTindex)
  865.         {
  866.         /* disposal has not caught up */
  868.         tmd = pTring + *pDindex;
  870.         /* if the buffer is still owned by LANCE, don't touch it */
  872.         LN_CACHE_INVALIDATE (tmd, TMD_SIZ);
  874.         if (PCISWAP(tmd->tbuf_tmd1) & TMD1_OWN)
  875.             break;
  877.         /*
  878.          * tbuf_err (TMD1.ERR) is an "OR" of LCOL, LCAR, UFLO or RTRY.
  879.          * Note that BUFF is not indicated in TMD1.ERR.
  880.          * We should therefore check both tbuf_err and tbuf_buff
  881.          * here for error conditions.
  882.          */
  884.         if ((PCISWAP(tmd->tbuf_tmd1) & TMD1_ERR) || 
  885.     (PCISWAP(tmd->tbuf_tmd2) & TMD2_BUFF))
  886.             {
  888.             pDrvCtrl->idr.ac_if.if_oerrors++;     /* output error */
  889.             pDrvCtrl->idr.ac_if.if_opackets--;
  891.             /* If error was due to excess collisions, bump the collision
  892.              * counter.  The LANCE does not keep an individual counter of
  893.              * collisions, so in this driver, the collision statistic is not
  894.              * an accurate count of total collisions.
  895.              */
  897.             if (PCISWAP(tmd->tbuf_tmd2) & TMD2_RTRY)
  898.                 pDrvCtrl->idr.ac_if.if_collisions++;
  900.             /* check for no carrier */
  902.             if (PCISWAP(tmd->tbuf_tmd2) & TMD2_LCAR)
  903.                 logMsg ("ln%d: no carriern",
  904.                     pDrvCtrl->idr.ac_if.if_unit, 0,0,0,0,0);
  906.             /* Restart chip on fatal errors.
  907.              * The following code handles the situation where the transmitter
  908.              * shuts down due to an underflow error.  This is a situation that
  909.              * will occur if the DMA cannot keep up with the transmitter.
  910.              * It will occur if the LANCE is being held off from DMA access
  911.              * for too long or due to significant memory latency.  DRAM
  912.              * refresh or slow memory could influence this.  Many
  913.              * implementation use a dedicated LANCE buffer.  This can be
  914.              * static RAM to eliminate refresh conflicts; or dual-port RAM
  915.              * so that the LANCE can have free run of this memory during its
  916.              * DMA transfers.
  917.              */
  919.             if ((PCISWAP(tmd->tbuf_tmd2) & TMD2_BUFF) || 
  920. (PCISWAP(tmd->tbuf_tmd2) & TMD2_UFLO))
  921.                 {
  922.                 pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
  923.                 (void) netJobAdd (
  924.                                  (FUNCPTR)lnRestart,
  925.                                  pDrvCtrl->idr.ac_if.if_unit,
  926.                                  0,0,0,0
  927.                                  );
  928.                 return;
  929.                 }
  930.             }
  932.         tmd->tbuf_tmd1 = 0; /* clear tmd1 */
  933.         tmd->tbuf_tmd2 = 0; /* clear all error & stat stuff */
  935.         /* now bump the tmd disposal index pointer around the ring */
  937.         *pDindex = (*pDindex + 1) & (*pTsize - 1);
  938.         }
  940.     /* Flush the write pipe */
  942.     CACHE_PIPE_FLUSH ();
  944.     }
  946. /*******************************************************************************
  947. *
  948. * lnHandleRecvInt - task level interrupt service for input packets
  949. *
  950. * This routine is called at task level indirectly by the interrupt
  951. * service routine to do any message received processing.
  952. */
  954. static void lnHandleRecvInt
  955.     (
  956.     DRV_CTRL *pDrvCtrl
  957.     )
  958.     {
  959.     ln_rmd *rmd;
  961.     do
  962.         {
  963.         pDrvCtrl->flags |= LS_RCV_HANDLING_FLAG;
  965.         while ((rmd = lnGetFullRMD (pDrvCtrl)) != NULL)
  966.             lnRecv (pDrvCtrl, rmd);
  968.         /*
  969.          * There is a RACE right here.  The ISR could add a receive packet
  970.          * and check the boolean below, and decide to exit.  Thus the
  971.          * packet could be dropped if we don't double check before we
  972.          * return.
  973.          */
  975.         pDrvCtrl->flags &= ~LS_RCV_HANDLING_FLAG;
  976.         }
  977.     while (lnGetFullRMD (pDrvCtrl) != NULL);
  978.     /* this double check solves the RACE */
  979.     }
  981. /*******************************************************************************
  982. *
  983. * lnGetFullRMD - get next received message RMD
  984. *
  985. * Returns ptr to next Rx desc to process, or NULL if none ready.
  986. */
  988. static ln_rmd *lnGetFullRMD
  989.     (
  990.     DRV_CTRL  *pDrvCtrl
  991.     )
  992.     {
  993.     ln_rmd   *rmd;
  995.     /* Refuse to do anything if flags are down */
  997.     if  (
  998.         (pDrvCtrl->idr.ac_if.if_flags & (IFF_UP | IFF_RUNNING) ) !=
  999.         (IFF_UP | IFF_RUNNING)
  1000.         )
  1001.         return ((ln_rmd *) NULL);
  1003.     rmd = pDrvCtrl->rring + pDrvCtrl->rindex;       /* form ptr to Rx desc */
  1005.     LN_CACHE_INVALIDATE (rmd, RMD_SIZ);
  1007.     if ((PCISWAP(rmd->rbuf_rmd1) & RMD1_OWN) == 0)
  1008.         return (rmd);
  1009.     else
  1010.         return ((ln_rmd *) NULL);
  1011.     }
  1013. /*******************************************************************************
  1014. *
  1015. * lnRecv - process the next incoming packet
  1016. *
  1017. */
  1019. static STATUS lnRecv
  1020.     (
  1021.     DRV_CTRL *pDrvCtrl,
  1022.     ln_rmd *rmd
  1023.     )
  1024.     {
  1025.     struct ether_header *  pEnetHdr;
  1026.     MBUF        *pMbuf;
  1027.     u_char      *pData;
  1028.     int         len;
  1029.     u_short     ether_type;
  1030.     BOOL        hookAte;
  1033.     /* Packet must be checked for errors. */
  1035.     if  (
  1036.         /* If error flag */
  1037.         (PCISWAP(rmd->rbuf_rmd1) & (RMD1_ERR | RMD1_FRAM)) ||
  1039.         /* OR if packet is not completely in one buffer */
  1040.         (
  1041.         (PCISWAP(rmd->rbuf_rmd1) & (RMD1_STP | RMD1_ENP) ) !=
  1042.         (RMD1_STP | RMD1_ENP)
  1043.         )
  1045.         )
  1046.         {
  1047.         ++pDrvCtrl->idr.ac_if.if_ierrors;       /* bump error stat */
  1048.         goto cleanRXD;                          /* skip to clean up */
  1049.         }
  1051.     len = PCISWAP(rmd->rbuf_mcnt) & RMD2_MCNT_MSK; /* get packet length */
  1053.     /* Get pointer to packet */
  1055.     pEnetHdr = (struct ether_header *)
  1056.                 (pDrvCtrl->rmd_ring.r_bufs + (pDrvCtrl->rindex * LN_BUFSIZ));
  1057.     LN_CACHE_INVALIDATE (pEnetHdr, len);   /* make the packet data coherent */
  1059.     ++pDrvCtrl->idr.ac_if.if_ipackets; /* bump statistic */
  1061.     /* call input hook if any */
  1063.     hookAte = FALSE;
  1064.     if  (etherInputHookRtn != NULL)
  1065.         {
  1066.         if  (
  1067.             (* etherInputHookRtn) (&pDrvCtrl->idr.ac_if, (char *)pEnetHdr, len)
  1068.             )
  1069.             hookAte = TRUE;
  1070.         }
  1072.     /* Normal path; send packet upstairs */
  1074.     if (hookAte == FALSE)
  1075.         {
  1076.         /* Adjust length to size of data only */
  1078.         len -= ENET_HDR_REAL_SIZ;
  1080.         /* Get pointer to packet data */
  1082.         pData = ((u_char *) pEnetHdr) + ENET_HDR_REAL_SIZ;
  1084.         ether_type = ntohs ( pEnetHdr->ether_type );
  1086. #ifdef BSD43_DRIVER
  1088.         /* Copy packet data into MBUFs, using the specified width */
  1090.         pMbuf = bcopy_to_mbufs (pData, len, 0, (IFNET *) & pDrvCtrl->idr.ac_if,
  1091.                             pDrvCtrl->memWidth);
  1093.         if (pMbuf != NULL)
  1094.             do_protocol_with_type (ether_type, pMbuf, & pDrvCtrl->idr, len);
  1095.         else
  1096.             ++pDrvCtrl->idr.ac_if.if_ierrors;    /* bump error statistic */
  1097. #else
  1098.         pMbuf = bcopy_to_mbufs (pData, len, 0, &pDrvCtrl->idr.ac_if, 
  1099.                                 pDrvCtrl->memWidth);
  1100.         if (pMbuf != NULL)
  1101.             do_protocol (pEnetHdr, pMbuf, &pDrvCtrl->idr, len);
  1102.         else
  1103.             ++pDrvCtrl->idr.ac_if.if_ierrors;    /* bump error statistic */
  1104. #endif
  1105.         }
  1107.     /* Done with descriptor, clean up and give it to the device. */
  1109.     cleanRXD:
  1110.     /* reset statistics counters and message byte count */
  1111.     rmd->rbuf_mcnt = 0;
  1113.     /* reset status bits, reinitialize buffer size, and give device ownership */
  1114.     rmd->rbuf_rmd1 = PCISWAP((RMD1_BCNT_MSK & - (pDrvCtrl->bufSize)) |
  1115.                               RMD1_CNST | RMD1_OWN);
  1117.     /* Flush the write pipe */
  1119.     CACHE_PIPE_FLUSH ();
  1121.     /* Advance our management index */
  1123.     pDrvCtrl->rindex = (pDrvCtrl->rindex + 1) & (pDrvCtrl->rsize - 1);
  1125.     return (OK);
  1126.     }
  1128. #ifdef BSD43_DRIVER
  1130. /*******************************************************************************
  1131. *
  1132. * lnOutput - the driver output routine
  1133. *
  1134. */
  1136. static int lnOutput
  1137.     (
  1138.     IDR  *pIDR,
  1139.     MBUF *pMbuf,
  1140.     SOCK *pDest
  1141.     )
  1142.     {
  1143.     char destEnetAddr [6];                  /* space for enet addr */
  1144.     u_short packetType;                     /* type field for the packet */
  1145.     DRV_CTRL    *pDrvCtrl;
  1146.     ln_tmd      *tmd;
  1147.     char        *buf;
  1148.     int         len;
  1149.     int         oldLevel;
  1151.     /* Check ifnet flags. Return error if incorrect. */
  1153.     if  (
  1154.         (pIDR->ac_if.if_flags & (IFF_UP | IFF_RUNNING)) !=
  1155.         (IFF_UP | IFF_RUNNING)
  1156.         )
  1157.         return (ENETDOWN);
  1159.     /* Attempt to convert socket addr into enet addr and packet type.
  1160.      * Note that if ARP resolution of the address is required, the ARP
  1161.      * module will call our routine again to transmit the ARP request
  1162.      * packet.  This means we may actually call ourselves recursively!
  1163.      */
  1165.     if (convertDestAddr (pIDR,pDest, destEnetAddr, &packetType, pMbuf) == FALSE)
  1166.         return (OK);    /* I KNOW returning OK is stupid, but it is correct */
  1168.     /* Get driver control pointer */
  1170.     pDrvCtrl = & drvCtrl [pIDR->ac_if.if_unit];
  1172.     /* Obtain exclusive access to transmitter.  This is necessary because
  1173.      * certain events can cause netTask to run a job that attempts to transmit
  1174.      * a packet.  We can only allow one task here at a time.
  1175.      */
  1177.     semTake (pDrvCtrl->TxSem, WAIT_FOREVER);
  1179.     pDrvCtrl->flags |= LS_START_OUTPUT_FLAG;
  1181.     /* See if next TXD is available */
  1183.     tmd = pDrvCtrl->tring + pDrvCtrl->tindex;
  1185.     LN_CACHE_INVALIDATE (tmd, TMD_SIZ);
  1187.     if  (
  1188.         ((PCISWAP(tmd->tbuf_tmd1) & TMD1_OWN) != 0) ||
  1189.         (
  1190.         ((pDrvCtrl->tindex + 1) & (pDrvCtrl->tsize - 1)) ==
  1191.         pDrvCtrl->dindex
  1192.         )
  1193.         )
  1194.         {
  1195.         m_freem (pMbuf);            /* Discard data */
  1196.         pIDR->ac_if.if_oerrors++;
  1197.         goto outputDone;
  1198.         }
  1200.     /* Get pointer to transmit buffer */
  1202.     buf = (char *)
  1203.         (pDrvCtrl->tmd_ring.t_bufs + (pDrvCtrl->tindex * LN_BUFSIZ));
  1205.     /* Fill in the Ethernet header */
  1207.     bcopy (destEnetAddr, buf, 6);
  1208.     bcopy ( (char *) pIDR->ac_enaddr, (buf + 6), 6);
  1209.     ((ENET_HDR *)buf)->type = htons (packetType);
  1211.     /* Copy packet from MBUFs to our transmit buffer.  MBUFs are
  1212.      * transparently freed.
  1213.      */
  1215.     bcopy_from_mbufs    (
  1216.                         (buf + ENET_HDR_REAL_SIZ),
  1217.                         pMbuf,
  1218.                         len,                            /* stuffed by macro */
  1219.                         pDrvCtrl->memWidth
  1220.                         );
  1222.     /* Ensure we send a legal size frame. */
  1224.     len += ENET_HDR_REAL_SIZ;
  1225.     len = max (ETHERSMALL, len);
  1227.     /* place a transmit request */
  1229.     oldLevel = intLock ();          /* disable ints during update */
  1231.     tmd->tbuf_tmd3 = 0;                     /* clear buffer error status */
  1233.     /* negative message byte count */
  1234.     tmd->tbuf_tmd1 &= PCISWAP(~TMD1_BCNT_MSK);
  1235.     tmd->tbuf_tmd1 |= PCISWAP((TMD1_CNST | TMD1_BCNT_MSK) & -len);
  1237.     tmd->tbuf_tmd1 |= PCISWAP(TMD1_ENP);    /* buffer is end of packet */
  1238.     tmd->tbuf_tmd1 |= PCISWAP(TMD1_STP);    /* buffer is start of packet */
  1239.     tmd->tbuf_tmd1 &= PCISWAP(~TMD1_DEF);   /* clear status bit */
  1240.     tmd->tbuf_tmd1 &= PCISWAP(~TMD1_MORE);
  1241.     tmd->tbuf_tmd1 &= PCISWAP(~TMD1_ERR);
  1242.     tmd->tbuf_tmd1 |= PCISWAP(TMD1_OWN);
  1244.     /* Flush the write pipe */
  1246.     CACHE_PIPE_FLUSH ();
  1248.     intUnlock (oldLevel);   /* now lnInt won't get confused */
  1250.     /* Advance our management index */
  1252.     pDrvCtrl->tindex = (pDrvCtrl->tindex + 1) & (pDrvCtrl->tsize - 1);
  1254.     /* kick start the transmitter, if selected */
  1256.     if (lnKickStartTx)
  1257.         lnCsrWrite (pDrvCtrl, 0, (CSR0_INEA | CSR0_TDMD));
  1259.     pDrvCtrl->flags &= ~LS_START_OUTPUT_FLAG;
  1261.     /* Bump the statistic counter. */
  1263.     pIDR->ac_if.if_opackets++;
  1265.     outputDone:
  1267.     /* Release exclusive access. */
  1269.     semGive (pDrvCtrl->TxSem);
  1271.     return (OK);
  1273.     }
  1275. #else           /* BSD43_DRIVER */
  1277. /*******************************************************************************
  1278. *
  1279. * lnPciStartOutput - the driver output routine
  1280. *
  1281. */
  1283. LOCAL void lnPciStartOutput
  1284.     (
  1285.     DRV_CTRL *  pDrvCtrl        /* pointer to driver control structure */
  1286.     )
  1287.     {
  1288.     struct mbuf * pMbuf;
  1289.     ln_tmd      *tmd;
  1290.     char        *buf;
  1291.     int         len;
  1292.     int         oldLevel;
  1294.     pDrvCtrl->flags |= LS_START_OUTPUT_FLAG;        /* ??? */
  1296.     /* See if next TXD is available */
  1298.    while (pDrvCtrl->idr.ac_if.if_snd.ifq_head)
  1299.         {
  1300.         /* Dequeue a packet from the transmit queue. */
  1301.   
  1302.         IF_DEQUEUE (&pDrvCtrl->idr.ac_if.if_snd, pMbuf);
  1304.         tmd = pDrvCtrl->tring + pDrvCtrl->tindex;
  1306.         LN_CACHE_INVALIDATE (tmd, TMD_SIZ);
  1308.         if ( ( (PCISWAP(tmd->tbuf_tmd1) & TMD1_OWN) != 0) ||
  1309.               ( ( (pDrvCtrl->tindex + 1) & (pDrvCtrl->tsize - 1)) ==
  1310.                                                            pDrvCtrl->dindex))
  1311.             {
  1312.             m_freem (pMbuf);
  1313.             pDrvCtrl->idr.ac_if.if_oerrors++;
  1314.             break;
  1315.             }
  1317.         /* Get pointer to transmit buffer */
  1319.         buf = (char *)
  1320.             (pDrvCtrl->tmd_ring.t_bufs + (pDrvCtrl->tindex * LN_BUFSIZ));
  1322.         /* Copy packet from MBUFs to transmit buffer. */
  1324.         bcopy_from_mbufs (buf, pMbuf, len, pDrvCtrl->memWidth);
  1326.         /* Ensure we send a legal size frame. */
  1328.         len = max (ETHERSMALL, len);
  1330.         /* place a transmit request */
  1332.         oldLevel = intLock ();          /* disable ints during update */
  1334.         tmd->tbuf_tmd3 = 0;             /* clear buffer error status */
  1336.         /* negative message byte count */
  1338.         tmd->tbuf_tmd1 &= PCISWAP(~TMD1_BCNT_MSK);
  1339.         tmd->tbuf_tmd1 |= PCISWAP((TMD1_CNST | TMD1_BCNT_MSK) & -len);
  1341.         tmd->tbuf_tmd1 |= PCISWAP(TMD1_ENP);    /* buffer is end of packet */
  1342.         tmd->tbuf_tmd1 |= PCISWAP(TMD1_STP);    /* buffer is start of packet */
  1343.         tmd->tbuf_tmd1 &= PCISWAP(~TMD1_DEF);   /* clear status bit */
  1344.         tmd->tbuf_tmd1 &= PCISWAP(~TMD1_MORE);
  1345.         tmd->tbuf_tmd1 &= PCISWAP(~TMD1_ERR);
  1346.         tmd->tbuf_tmd1 |= PCISWAP(TMD1_OWN);
  1348.         /* Flush the write pipe */
  1350.         CACHE_PIPE_FLUSH ();
  1352.         intUnlock (oldLevel);   /* now lnInt won't get confused */
  1354.         /* Advance our management index */
  1356.         pDrvCtrl->tindex = (pDrvCtrl->tindex + 1) & (pDrvCtrl->tsize - 1);
  1358.         /* kick start the transmitter, if selected */
  1360.         if (lnKickStartTx)
  1361.             lnCsrWrite (pDrvCtrl, 0, (CSR0_INEA | CSR0_TDMD));
  1363.         pDrvCtrl->flags &= ~LS_START_OUTPUT_FLAG;
  1365.         /* Bump the statistic counter. */
  1367.         pDrvCtrl->idr.ac_if.if_opackets++;   /* bump the statistic counter. */
  1368.         }
  1369.     return;
  1370.     }
  1372. #endif
  1374. /*******************************************************************************
  1375. *
  1376. * lnIoctl - the driver I/O control routine
  1377. *
  1378. * Process an ioctl request.
  1379. */
  1381. static int lnIoctl
  1382.     (
  1383.     IDR  *ifp,
  1384.     int            cmd,
  1385.     caddr_t        data
  1386.     )
  1387.     {
  1388.     int error = 0;
  1390.     switch (cmd)
  1391.         {
  1392.         case SIOCSIFADDR:
  1393.            ((struct arpcom *)ifp)->ac_ipaddr = IA_SIN (data)->sin_addr;
  1394.             arpwhohas (ifp, &IA_SIN (data)->sin_addr);
  1395.             break;
  1397.         case SIOCSIFFLAGS:
  1398.             /* No further work to be done */
  1399.             break;
  1401.         default:
  1402.             error = EINVAL;
  1403.         }
  1405.     return (error);
  1406.     }
  1408. /*******************************************************************************
  1409. *
  1410. * lnChipReset - hardware reset of chip (stop it)
  1411. */
  1413. static int lnChipReset
  1414.     (
  1415.     DRV_CTRL  *pDrvCtrl
  1416.     )
  1417.     {
  1418.     ULONG * dv = (ULONG *)pDrvCtrl->devAdrs;
  1420.     /* Enable 32 bit access by doing a 32 bit write */
  1422.     * (dv) = 0;
  1424.     lnCsrWrite (pDrvCtrl, CSR(0), CSR0_STOP);
  1426.     lnBcrWrite (pDrvCtrl, BCR(20), BCR20_SWSTYLE_PCNET);
  1428.     return (OK);
  1429.     }
  1431. /*******************************************************************************
  1432. *
  1433. * lnCsrWrite - select and write a CSR register
  1434. *
  1435. */
  1437. static void lnCsrWrite
  1438.     (
  1439.     DRV_CTRL *  pDrvCtrl, /* driver control */
  1440.     int  reg, /* register to select */
  1441.     ULONG  value /* value to write */
  1442.     )
  1443.     {
  1444.     ULONG *dv = (ULONG *)pDrvCtrl->devAdrs;
  1446.     /* select CSR */
  1448.     *(dv+RAPOffset) = PCISWAP(((ULONG)reg & 0x000000FF));
  1450.     /* write val to CSR */
  1452.     *(dv+CSROffset) = PCISWAP(((ULONG)value & 0x0000FFFF));
  1453.     }
  1455. /*******************************************************************************
  1456. *
  1457. * lnCsrRead - select and read a CSR register
  1458. *
  1459. */
  1461. static ULONG lnCsrRead
  1462.     (
  1463.     DRV_CTRL * pDrvCtrl, /* driver control */
  1464.     int reg /* register to select */
  1465.     )
  1466.     {
  1467.     ULONG *dv = (ULONG *)pDrvCtrl->devAdrs;
  1469.     *(dv+RAPOffset) = PCISWAP(((ULONG)reg & 0x000000FF)); /* select CSR */
  1471.     /* get contents of CSR */
  1473.     return ( PCISWAP(*(dv+CSROffset)) & (0x0000FFFF));
  1474.     }
  1476. /*******************************************************************************
  1477. *
  1478. * lnBcrWrite - select and write a CSR register
  1479. *
  1480. */
  1482. static void lnBcrWrite
  1483.     (
  1484.     DRV_CTRL *  pDrvCtrl, /* driver control */
  1485.     int  reg, /* register to select */
  1486.     ULONG  value /* value to write */
  1487.     )
  1488.     {
  1489.     ULONG *dv = (ULONG *)pDrvCtrl->devAdrs;
  1491.     /* select CSR */
  1493.     *(dv+RAPOffset) = PCISWAP(((ULONG)reg & 0x000000FF));
  1495.     /* write val to BCR */
  1497.     *(dv+BDPOffset) = PCISWAP(((ULONG)value & 0x0000FFFF));
  1498.     }
  1500. /******************************************************************************
  1501. *
  1502. * lnRestartSetup - setup memory descriptors and turn on chip
  1503. *
  1504. * Initializes all the shared memory structures and turns on the chip.
  1505. */
  1507. LOCAL STATUS lnRestartSetup
  1508.     (
  1509.     DRV_CTRL *pDrvCtrl
  1510.     )
  1511.     {
  1512.     ULONG       stat = 0;
  1513.     char        *buf;
  1514.     int         loopy;
  1515.     int         timeoutCount = 0;
  1516.     ln_ib       *ib;
  1517.     ln_rmd      *rmd;
  1518.     ln_tmd      *tmd;
  1519.     void        *pTemp;
  1522.     /* Set up the Rx descriptors */
  1524.     rmd = pDrvCtrl->rring;                      /* receive ring */
  1525.     buf = pDrvCtrl->rmd_ring.r_bufs;
  1526.     for (loopy = 0; loopy < pDrvCtrl->rsize; loopy++)
  1527.       {
  1528.         pTemp = LN_CACHE_VIRT_TO_PHYS (buf);     /* convert to physical addr */
  1529.         pTemp = (void *)(MEM_TO_PCI_PHYS((ULONG)pTemp));
  1530.         rmd->rbuf_adr = PCISWAP((ULONG) pTemp); /* bits 31:00 of buf addr */
  1531.         rmd->rbuf_rmd1 = 0;
  1532.         /* neg of buffer byte count */
  1533.         rmd->rbuf_rmd1 = PCISWAP((RMD1_BCNT_MSK & -(pDrvCtrl->bufSize)) | 
  1534.                                   RMD1_CNST);
  1535.         rmd->rbuf_mcnt = 0;                     /* no message byte count yet */
  1536.         rmd->rbuf_rmd1 |= PCISWAP(RMD1_OWN);    /* buffer now owned by LANCE */
  1537.         rmd++;                                  /* step to next descriptor */
  1538.         buf += (pDrvCtrl->bufSize);             /* step to the next buffer */
  1539.       }
  1541.     pDrvCtrl->rindex = 0;
  1544.     /* Setup the Tx descriptors */
  1546.     tmd = pDrvCtrl->tring;                 /* transmit ring */
  1547.     buf = pDrvCtrl->tmd_ring.t_bufs;
  1549.     for (loopy = 0; loopy < pDrvCtrl->tsize; loopy++)
  1550.       {
  1551.         pTemp = LN_CACHE_VIRT_TO_PHYS (buf);     /* convert to physical addr */
  1552.         pTemp = (void *)(MEM_TO_PCI_PHYS((ULONG)pTemp));
  1553.         tmd->tbuf_adr = PCISWAP((ULONG) pTemp); /* bits 31:00 of buf addr */
  1554.         tmd->tbuf_tmd1 = PCISWAP(TMD1_CNST);    /* no message byte count yet */
  1555.         tmd->tbuf_tmd2 = 0;                     /* no error status yet */
  1556.         tmd->tbuf_tmd1 |= PCISWAP(TMD1_ENP);    /* buffer is end of packet */
  1557.         tmd->tbuf_tmd1 |= PCISWAP(TMD1_STP);    /* buffer is start of packet */
  1558.         tmd++;                                  /* step to next descriptor */
  1559.         buf += (pDrvCtrl->bufSize);             /* step to next buffer */
  1560.       }
  1562.     pDrvCtrl->tindex =
  1563.         pDrvCtrl->dindex = 0;
  1565.     /* Setup the initialization block */
  1567.     ib = pDrvCtrl->ib;
  1568.     ib->lnIBMode = 0;       /* chip will be in normal receive mode */
  1570. #if (_BYTE_ORDER == _BIG_ENDIAN)
  1571.     bcopy ((char *)pDrvCtrl->idr.ac_enaddr, ib->lnIBPadr, 6);
  1572. #else
  1573.     swab ((char *)pDrvCtrl->idr.ac_enaddr, ib->lnIBPadr, 4);
  1574.     swab ((char *)&pDrvCtrl->idr.ac_enaddr[4], &ib->lnIBPadr[6], 2);
  1575. #endif /* _BYTE_ORDER == _BIG_ENDIAN */
  1577.     pTemp = LN_CACHE_VIRT_TO_PHYS ( pDrvCtrl->rring ); /* point to Rx ring */
  1578.     pTemp = (void *)(MEM_TO_PCI_PHYS((ULONG)pTemp));
  1579.     ib->lnIBRdra = PCISWAP((ULONG)pTemp);
  1580.     ib->lnIBMode |=  PCISWAP((IB_MODE_RLEN_MSK & (pDrvCtrl->rpo2 << 20)));
  1582.     pTemp = LN_CACHE_VIRT_TO_PHYS ( pDrvCtrl->tring ); /* point to Tx ring */
  1583.     pTemp = (void *)(MEM_TO_PCI_PHYS((ULONG)pTemp));
  1584.     ib->lnIBTdra = PCISWAP((ULONG)pTemp);
  1585.     ib->lnIBMode |= PCISWAP((IB_MODE_TLEN_MSK & (pDrvCtrl->tpo2 << 28)));
  1587.     /* Flush the write pipe */
  1589.     CACHE_PIPE_FLUSH ();
  1592.     lnCsrWrite (pDrvCtrl, 0, CSR0_STOP);        /* set the stop bit */
  1594.     /* set the bus mode to little endian */
  1596.     lnCsrWrite (pDrvCtrl, 3, lnPciCSR_3B);
  1598.     /* Point the device to the initialization block */
  1600.     pTemp = LN_CACHE_VIRT_TO_PHYS ( pDrvCtrl->ib );
  1601.     pTemp = (void *)(MEM_TO_PCI_PHYS((ULONG)pTemp));
  1602.     lnCsrWrite (pDrvCtrl, 2, (((ULONG)pTemp >> 16) & 0x0000ffff));
  1603.     lnCsrWrite (pDrvCtrl, 1, ((ULONG)pTemp & 0x0000ffff));
  1604.     lnCsrWrite (pDrvCtrl, 0, CSR0_INIT);            /* init chip (read IB) */
  1606.     while (((stat = lnCsrRead (pDrvCtrl, 0)) & (CSR0_IDON | CSR0_ERR)) == 0)
  1607.       {
  1608.         if (timeoutCount++ > 0x10000) break;
  1609.         taskDelay(100);
  1610.       }
  1612.     if ((stat & CSR0_ERR) == CSR0_ERR)
  1613.       {
  1614.         if ((stat & CSR0_MERR)  == CSR0_MERR)
  1615.   {
  1616.             logMsg ("lnPci: Lance memory error while initialization:t0x%xn",
  1617.                     stat, 0,0,0,0,0);
  1618.   }
  1619.         else
  1620.   {
  1621.             logMsg ("lnPci: Lance error while initialization:t0x%xn",
  1622.                     stat, 0,0,0,0,0);
  1623.   }
  1624.       }
  1626.     /* log chip initialization failure */
  1628.     if ( (stat & CSR0_ERR) || (timeoutCount >= 0x10000) )
  1629.       {
  1630.         logMsg ("lnPci%d: Device initialization failedn",
  1631.                     pDrvCtrl->idr.ac_if.if_unit, 0,0,0,0,0);
  1632.         return (ERROR);
  1633.       }
  1635.     /* Device is initialized.  Start transmitter and receiver.  The device
  1636.      * RAP register is left selecting CSR 0.
  1637.      */
  1639.     lnCsrWrite(pDrvCtrl, 0, CSR0_IDON | CSR0_INEA | CSR0_STRT);
  1641.     sysLanIntEnable (pDrvCtrl->ilevel);           /* enable LANCE interrupts */
  1642.  
  1643.     pDrvCtrl->idr.ac_if.if_flags |= (IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);
  1645.     return (OK);
  1646.     }
  1648. /*******************************************************************************
  1649. *
  1650. * lnRestart - restart the device after a fatal error
  1651. *
  1652. * This routine takes care of all the messy details of a restart.  The device
  1653. * is reset and re-initialized.  The driver state is re-synchronized.
  1654. */
  1656. static void lnRestart
  1657.     (
  1658.     DRV_CTRL *pDrvCtrl
  1659.     )
  1660.     {
  1661.     printf ("lnPci: device resetn");
  1663.     if (lnChipReset (pDrvCtrl) == ERROR)        /* reset lance device */
  1664.         {
  1665.         logMsg ("lnPci: Device failed to resetn", 0,0,0,0,0,0);
  1666.         return;
  1667.         }
  1669.     lnRestartSetup (pDrvCtrl);
  1671.     return;
  1672.     }
  1674. #ifdef BSD43_DRIVER
  1676. #include "sys/socket.h"
  1678. /*******************************************************************************
  1679. *
  1680. * convertDestAddr - converts socket addr into enet addr and packet type
  1681. *
  1682. */
  1684. static BOOL convertDestAddr
  1685.     (
  1686.     IDR *pIDR,                          /* ptr to i/f data record */
  1687.     SOCK *pDestSktAddr,                 /* ptr to a generic sock addr */
  1688.     char *pDestEnetAddr,                /* where to write enet addr */
  1689.     u_short *pPacketType,               /* where to write packet type */
  1690.     MBUF *pMbuf                         /* ptr to mbuf data */
  1691.     )
  1692.     {
  1694.     /***** Internet family *****/
  1696.     {
  1697.     struct in_addr destIPAddr;              /* not used */
  1698.     int trailers;                           /* not supported */
  1700.      if (pDestSktAddr->sa_family == AF_INET)
  1701.         {
  1702.         *pPacketType = ETHERTYPE_IP;            /* stuff packet type */
  1703.         destIPAddr = ((struct sockaddr_in *) pDestSktAddr)->sin_addr;
  1705.         if (!arpresolve (pIDR, pMbuf, &destIPAddr, pDestEnetAddr, &trailers))
  1706.             return (FALSE);     /* if not yet resolved */
  1708.         return (TRUE);
  1709.         }
  1710.     }
  1713.     /***** Generic family *****/
  1715.     {
  1716.     ENET_HDR *pEnetHdr;
  1718.     if (pDestSktAddr->sa_family == AF_UNSPEC)
  1719.         {
  1720.         pEnetHdr = (ENET_HDR *) pDestSktAddr->sa_data;      /* ptr to hdr */
  1721.         bcopy (pEnetHdr->dst, pDestEnetAddr, 6);            /* copy dst addr */
  1722.         *pPacketType = pEnetHdr->type;                      /* copy type */
  1723.         return (TRUE);
  1724.         }
  1725.     }
  1728.     /* Unsupported family */
  1730.     return (FALSE);
  1732.     } /* End of convertDestAddr() */
  1734. /* END OF FILE */
  1736. #endif