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

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

VxWorks

开发平台：

C/C++

if_cs.c：源码内容
  1. /* if_cs.c - Crystal Semiconductor CS8900 network interface driver */
  3. /*
  4.  * Copyright 1996 Crystal Semiconductor Corp.
  5.  * Copyright 1984-1997 Wind River Systems, Inc.
  6.  */
  8. #include "copyright_wrs.h"
  10. /*
  11. modification history
  12. --------------------
  13. 01c,23feb98,vin  converted to BSD44 driver, merge from SENS
  14. 01b,13jun97,map  doc updates [SPR# 8138]
  15. 01a,16dec96,hdn  adapted.
  16. */
  18. /*
  19. DESCRIPTION
  21. This module implements a driver for a Crystal Semiconductor CS8900 Ethernet
  22. controller chip.
  24. The CS8900 is a single chip Ethernet controller with a direct ISA bus
  25. interface which can operate in either memory space or I/O space. It also
  26. supports a direct interface to a host DMA controller to transfer receive
  27. frames to host memory.  The device has a 4K RAM which is used for transmit,
  28. and receive buffers; a serial EEPROM interface; and both 10BASE-T/AUI port
  29. support.
  31. This driver is capable of supporting both memory mode and I/O mode operations
  32. of the chip. When configured for memory mode, the intenal RAM of the chip is
  33. mapped to a contiguous 4K address block, providing the CPU direct access to
  34. the internal registers and frame buffers. When configured for I/O mode, the
  35. internal registers are accessible through eight contiguous, 16-bit I/O ports.
  36. The driver also supports an interface to an EEPROM containing device
  37. configuration.
  39. While the DMA slave mode is supported by the device for receive frame
  40. transfers, this driver does not enable DMA.
  42. This network interface driver does not support output hook routines,
  43. because to do so requires that an image of the transmit packet be built in
  44. memory before the image is copied to the CS8900 chip.  It is much more
  45. efficient to copy the image directly from the mbuf chain to the CS8900 chip.
  46. However, this network interface driver does support input hook routines.
  48. CONFIGURATION
  49. The defined I/O address and IRQ in config.h must match the one stored
  50. in EEPROM by the vendor's DOS utility program.
  52. The I/O Address parameter is the only required csAttach() parameter.  If the
  53. CS8900 chip has a EEPROM attached, then the I/O Address parameter, passed to
  54. the csAttach() routine, must match the I/O address programmed into the EEPROM.
  55. If the CS8900 chip does not have a EEPROM attached, then the I/O Address
  56. parameter must be 0x300.
  58. The Interrupt Level parameter must have one of the following values:
  59.    0  - Get interrupt level from EEPROM
  60.    5  - IRQ 5
  61.    10 - IRQ 10
  62.    11 - IRQ 11
  63.    12 - IRQ 12
  65. If the Interrupt Vector parameter is zero, then the network interface driver
  66. derives the interrupt vector from the interrupt level if possible.  It is
  67. possible to derive the interrupt vector in an IBM PC compatible system.  This
  68. parameter is present for systems which are not IBM PC compatible.
  70. The Memory Address parameter specifies the base address of the CS8900 chip's
  71. memory buffer (PacketPage).  If the Memory Address parameter is not zero, then
  72. the CS8900 chip operates in memory mode at the specified address.  If the
  73. Memory Address parameter is zero, then the CS8900 chip operates in the mode
  74. specified by the EEPROM or the Configuration Flags parameter.
  76. The Media Type parameter must have one of the following values:
  77. .CS
  78.  0 - Get media type from EEPROM
  79.  1 - AUI  (Thick Cable)
  80.  2 - BNC  10Base2 (Thin Cable)
  81.  3 - RJ45 10BaseT (Twisted Pair)
  82. .CE
  84. The Configuration Flags parameter is usually passed to the csAttach() routine
  85. as zero and the Configuration Flags information is retrieved from the EEPROM.
  86. The bits in the Configuration Flags parameter are usually specified by a
  87. hardware engineer and not by the end user.  However, if the CS8900 chip does
  88. not have a EEPROM attached, then this information must be passed as a parameter
  89. to the csAttach() routine.  The Configuration Flags are:
  90. .CS
  91.  0x8000 - CS_CFGFLG_NOT_EEPROM    Don't get Config. Flags from the EEPROM
  92.  0x0001 - CS_CFGFLG_MEM_MODE      Use memory mode to access the chip
  93.  0x0002 - CS_CFGFLG_USE_SA        Use system addr to qualify MEMCS16 signal
  94.  0x0004 - CS_CFGFLG_IOCHRDY       Use IO Channel Ready signal to slow access
  95.  0x0008 - CS_CFGFLG_DCDC_POL      The DC/DC conv. enable pin is active high
  96.  0x0010 - CS_CFGFLG_FDX           10BaseT is full duplex
  97. .CE
  99. If configuration flag information is passed to the csAttach() routine, then the
  100. CS_CFGFLG_NOT_EEPROM flag should be set.  This ensures that the Configuration
  101. Flags parameter is not zero, even if all specified flags are zero.
  103. If the Memory Address parameter is not zero and the Configuration Flags
  104. parameter is zero, then the CS8900 network interface driver implicitly sets
  105. the CS_CFGFLG_MEM_MODE flag and the CS8900 chip operates in memory mode.
  106. However, if the Configuration Flags parameter is not zero, then the CS8900
  107. chip operates in memory mode only if the CS_CFGFLG_MEM_MODE flag is explicitly
  108. set.  If the Configuration Flags parameter in not zero and the
  109. CS_CFGFLG_MEM_MODE flag is not set, then the CS8900 chip operates in I/O mode.
  111. The Ethernet Address parameter is usually passed to the csAttach() routine as
  112. zero and the Ethernet address is retrieved from the EEPROM.  The Ethernet
  113. address (also called hardware address and individual address) is usually
  114. supplied by the adapter manufacturer and is stored in the EEPROM.  However, if
  115. the CS8900 chip does not have a EEPROM attached, then the Ethernet address must
  116. be passed as a parameter to the csAttach() routine.
  117. The Ethernet Address parameter, passed to the csAttach() routine, contains the
  118. address of a NULL terminated string.  The string consists of 6 hexadecimal
  119. numbers separated by colon characters.  Each hexadecimal number is in the range
  120. 00 - FF.  An example of this string is:
  121. .CS
  122.    "00:24:20:10:FF:2A"
  123. .CE
  125. BOARD LAYOUT
  126. This device is soft-configured.  No jumpering diagram is required.
  128. EXTERNAL INTERFACE
  129. The only user-callable routines are csAttach():
  130. .iP csAttach() 14
  131. publishes the `cs' interface and initializes the driver and device.
  132. .LP
  133. The network interface driver includes a show routine, called csShow(), which
  134. displays driver configuration and statistics information.  To invoke the show
  135. routine, type at the shell prompt:
  136. .CS
  137.         -> csShow
  138. .CE
  140. To reset the statistics to zero, type at the shell prompt:
  141. .CS
  142.         -> csShow 0, 1
  143. .CE
  145. Another routine that you may find useful is:
  146. .CS
  147.         -> ifShow "cs0"
  148. .CE
  150. EXTERNAL ROUTINES
  152. For debugging purposes, this driver calls logMsg() to print error and debugging
  153. information.  This will cause the logLib library to be linked with any image
  154. containing this driver.
  156. This driver needs the following macros defined for proper execution.  Each
  157. has a default definition that assumes a PC386/PC486 system and BSP.
  159. The macro CS_IN_BYTE(reg,pAddr) reads one byte from the I/O address 'reg',
  160. placing the result at address 'pAddr'.  There is no status result from this
  161. operation, we assume the operation completes normally, or a bus exception
  162. will occur.  By default, this macro assumes there is a BSP routine sysInByte()
  163. to perform the I/O operation.
  165. The macro CS_IN_WORD(reg,pAddr) read a short word (2 bytes) from the I/O
  166. address 'reg', storing the result at address 'pAddr'.  We assume this
  167. completes normally, or causes a bus exception.  The default declaration
  168. assumes a BSP routine sysInWord() to perform the operation.
  170. The macro CS_OUT_WORD(reg,data) writes a short word value 'data' at the
  171. I/O address 'reg'.  The default declaration assumes a BSP routine sysOutWord().
  173. The macro CS_INT_ENABLE(level, pResult) is used to enable the interrupt
  174. level passed as an argument to csAttach.  The default definition call the
  175. BSP routine sysIntEnablePIC(level).  The STATUS return value from the 
  176. actual routine is stored at 'pResult' for the driver to examine.
  178. The macro CS_INT_CONNECT(ivec,rtn,arg,pResult) macro is used to connect
  179. the driver interrupt routine to the vector provided as an argument to 
  180. csAttach (after translaction by INUM_TO_IVEC).  The default definition
  181. calls the cpu architecture routine intConnect().
  183. The macro CS_IRQ0_VECTOR(pAddr) is used to fetch the base vector for the
  184. interrupt level mechanism.  If the int vector argument to csAttach is zero,
  185. then the driver will compute a vector number by adding the interrupt level
  186. to the value returned by this macro.  If the user supplies a non-zero
  187. interrupt vector number, then this macro is not used.  The default definition
  188. of this macro fetches the base vector number from a global value
  189. called 'sysVectorIRQ0'.
  191. The macro CS_MSEC_DELAY(msec) is used to delay execution for a specified
  192. number of milliseconds.  The default definition uses taskDelay to suspend
  193. task for some number of clock ticks.  The resolution of the system clock
  194. is usually around 16 milliseconds (msecs), which is fairly coarse.
  195. */
  197. #include "vxWorks.h"
  198. #include "sysLib.h"
  199. #include "intLib.h"
  200. #include "logLib.h"
  201. #include "netLib.h"
  202. #include "etherLib.h"
  203. #include "stdio.h"
  204. #include "iv.h"
  205. #include "ioctl.h"
  206. #include "taskLib.h"
  207. #include "net/if_subr.h"
  208. #include "drv/netif/if_cs.h"
  211. /* defines */
  213. #define MAXUNITS    2 /* Maximum number of CS8900 chips */
  215. #ifndef CS_IN_BYTE /* read one byte from I/O space */
  216. #define CS_IN_BYTE(reg,pAddr) 
  217. (*(pAddr) = sysInByte(reg))
  218. #endif /*CS_IN_BYTE*/
  220. #ifndef CS_IN_WORD /* read a short (16bits) from I/O */
  221. #define CS_IN_WORD(reg,pAddr) 
  222. (*(pAddr) = sysInWord(reg))
  223. #endif /*CS_IN_WORD*/
  225. #ifndef CS_OUT_WORD /* write a short to I/O space */
  226. #define CS_OUT_WORD(reg,data) 
  227. (sysOutWord((reg),(data)))
  228. #endif /*CS_OUT_WORD*/
  230. #ifndef CS_INT_ENABLE /* enable interrupt level */
  231. #define CS_INT_ENABLE(level,pResult) 
  232. (*pResult = sysIntEnablePIC(level))
  233. #endif /*CS_INT_ENABLE*/
  235. #ifndef CS_INT_CONNECT /* connect routine to intr. vector */
  236. #define CS_INT_CONNECT(ivec,rtn,arg,pResult) 
  237. (*pResult = intConnect(ivec,rtn,arg))
  238. #endif /*CS_INT_CONNECT*/
  240. #ifndef CS_IRQ0_VECTOR /* get vector for intr. level 0 */
  241. #define CS_IRQ0_VECTOR(pAddr) 
  242. { 
  243. IMPORT UINT sysVectorIRQ0; 
  244. *pAddr = sysVectorIRQ0; 
  245. }
  246. #endif /*CS_IRQ0_VECTOR*/
  248. #ifndef CS_MSEC_DELAY /* delay for (x) milliseconds */
  249. #define CS_MSEC_DELAY(msec) 
  250. taskDelay ((((msec) * sysClkRateGet()) + sysClkRateGet() - 1)/ 1000);
  251. #endif /*CS_MSEC_DELAY*/
  253. /* typedefs */
  254. typedef struct ether_header ETH_HDR; 
  256. /* globals */
  259. /* locals */
  261. LOCAL CS_SOFTC cs_softc[MAXUNITS]; /* Instance global variables */
  264. /* prototypes */
  266. #if defined(__STDC__) || defined(__cplusplus)
  268.       STATUS csAttach (int unit, int ioAddr, int intVector,
  269.  int intLevel, int memAddr, int mediaType,
  270.  int configFlags, char *pEnetAddr);
  271.       void csShow (int unit, BOOL zap);
  272. LOCAL STATUS csInit (int unit);
  273. LOCAL void csReset (int unit);
  274. LOCAL void csIntr (int unit);
  275. LOCAL int csIoctl (struct ifnet *pIf, int command, char *pData);
  276. #ifdef BSD43_DRIVER
  277. LOCAL void csStartOutput (int unit);
  278. LOCAL int csOutput (struct ifnet *pIf, struct mbuf *pMbufChain,
  279.  SOCKADDR *pDst);
  280. #else
  281. LOCAL void csStartOutput (CS_SOFTC *pCs);
  282. #endif
  283. LOCAL STATUS csChipVerify (CS_SOFTC *pCs);
  284. LOCAL STATUS csChipReset (CS_SOFTC *pCs);
  285. LOCAL void csChipInit (CS_SOFTC *pCs);
  286. LOCAL void csIntrBuffer (CS_SOFTC *pCs, USHORT buffEvent);
  287. LOCAL void csIntrTx (CS_SOFTC *pCs, USHORT txEvent);
  288. LOCAL void csIntrRx (CS_SOFTC *pCs, USHORT rxEvent);
  289. LOCAL void csTxFrameCopy (CS_SOFTC *pCs, struct mbuf *pMbufChain);
  290. LOCAL void csRxFrameCopy (CS_SOFTC *pCs, CS_RXBUF *pRxBuff);
  291. LOCAL void csRxProcess (CS_SOFTC *pCs, CS_RXBUF *pRxBuff);
  292. LOCAL STATUS csRxBuffInit (CS_SOFTC *pCs);
  293. LOCAL CS_RXBUF *csRxBuffAlloc (CS_SOFTC *pCs);
  294. LOCAL void csRxBuffFree (CS_SOFTC *pCs, CS_RXBUF *pRxBuff);
  295. LOCAL USHORT csPacketPageR (CS_SOFTC *pCs, USHORT offset);
  296. LOCAL void csPacketPageW (CS_SOFTC *pCs, USHORT offset, USHORT value);
  297. LOCAL void csError (CS_SOFTC *pCs, char *pString);
  298. LOCAL STATUS csParmsGet (CS_SOFTC *pCs);
  299. LOCAL STATUS csParmsValidate (CS_SOFTC *pCs);
  300. LOCAL STATUS csEnetAddrGet (CS_SOFTC *pCs, char *pEnetAddr);
  301. LOCAL STATUS csEepromRead (CS_SOFTC *pCs, USHORT offset, USHORT *pValue);
  302. LOCAL char *csHexWord (char *pChar, USHORT *pWord);
  303. LOCAL char *csHexByte (char *pChar, UCHAR *pByte);
  305. #else  /* Not ANSI C or C++ */
  307.       STATUS csAttach ();
  308.       void csShow ();
  309. LOCAL STATUS csInit ();
  310. LOCAL void csReset ();
  311. LOCAL void csStartOutput ();
  312. LOCAL void csIntr ();
  313. LOCAL int csIoctl ();
  314. LOCAL int csOutput ();
  315. LOCAL STATUS csChipVerify ();
  316. LOCAL STATUS csChipReset ();
  317. LOCAL void csChipInit ();
  318. LOCAL void csIntrBuffer ();
  319. LOCAL void csIntrTx ();
  320. LOCAL void csIntrRx ();
  321. LOCAL void csTxFrameCopy ();
  322. LOCAL void csRxFrameCopy ();
  323. LOCAL void csRxProcess ();
  324. LOCAL STATUS csRxBuffInit ();
  325. LOCAL CS_RXBUF *csRxBuffAlloc ();
  326. LOCAL void csRxBuffFree ();
  327. LOCAL USHORT csPacketPageR ();
  328. LOCAL void csPacketPageW ();
  329. LOCAL void csError ();
  330. LOCAL STATUS csParmsGet ();
  331. LOCAL STATUS csParmsValidate ();
  332. LOCAL STATUS csEnetAddrGet ();
  333. LOCAL STATUS csEepromRead ();
  334. LOCAL char *csHexWord ();
  335. LOCAL char *csHexByte ();
  337. #endif  /* defined(__STDC__) || defined(__cplusplus) */
  340. /*******************************************************************************
  341. *
  342. * csAttach - publish the `cs' network interface and initialize the driver.
  343. *
  344. * This routine is a major entry point to this network interface driver and is
  345. * called only once per operating system reboot by the operating system startup
  346. * code.  This routine is called before the csInit() routine.
  347. *
  348. * This routine takes passed-in configuration parameters and parameters from
  349. * the EEPROM and fills in the instance global variables in the cs_softc
  350. * structure.  These variables are later used by the csChipInit() routine.
  351. *
  352. * This routine connects the interrupt handler, csIntr(), to the specified
  353. * interrupt vector, initializes the 8259 PIC and resets the CS8900 chip.
  354. *
  355. * Finally, this routine calls the ether_attach() routine, to fill in the ifnet
  356. * structure and attach this network interface driver to the system.  The
  357. * driver's main entry points (csInit(), csIoctl(), csOutput(), csReset()) are
  358. * made visable to the protocol stack.
  359. *
  360. * Refer to "man if_cs" for detailed description of the configuration flags.
  361. *
  362. * RETURNS: OK or ERROR.
  363. */
  365. STATUS csAttach
  366.     (
  367.     int unit, /* unit number */
  368.     int ioAddr, /* base IO address */
  369.     int intVector, /* interrupt vector, or zero */
  370.     int intLevel, /* interrupt level */
  371.     int memAddr, /* base memory address */
  372.     int mediaType, /* 0: Autodetect  1: AUI  2: BNC  3: RJ45 */
  373.     int configFlags, /* configuration flag */
  374.     char *pEnetAddr /* ethernet address */
  375.     )
  376.     {
  377.     FAST CS_SOFTC *pCs = &cs_softc[unit];
  378.     STATUS result;
  380.     if (unit >= MAXUNITS)
  381. {
  382. printf ("ncs%d - Invalid unit number (%d)n", unit, unit);
  383. return (ERROR);
  384. }
  386.     /* Save the passed-in parameters */
  388.     pCs->ioAddr      = ioAddr;
  389.     pCs->intLevel    = intLevel;
  390.     pCs->intVector   = intVector;
  391.     pCs->pPacketPage = (USHORT *)memAddr;
  392.     pCs->mediaType   = mediaType;
  393.     pCs->configFlags = configFlags;
  395.     /* Start out in IO mode */
  397.     pCs->inMemoryMode = FALSE;
  399.     /* Set counters to zero */
  401.     pCs->rxDepth    = 0;
  402.     pCs->maxRxDepth = 0;
  403.     pCs->maxTxDepth = 0;
  404.     pCs->loanCount  = 0;
  406.     /* Allocate the receive frame buffers */
  408.     if (csRxBuffInit (pCs) == ERROR)
  409. {
  410. printf ("ncs%d - Can not allocate receive buffersn", unit);
  411. return (ERROR);
  412. }
  414.     /* Verify that it is the correct chip */
  416.     if (csChipVerify (pCs) == ERROR)
  417. return (ERROR);
  419.     /* Get parameters, which were not specified, from the EEPROM */
  421.     if (csParmsGet (pCs) == ERROR)
  422. return (ERROR);
  424.     /* Verify that parameters are valid */
  426.     if (csParmsValidate (pCs) == ERROR)
  427. return (ERROR);
  429.     /* Get and store the Ethernet address */
  431.     if (csEnetAddrGet (pCs,pEnetAddr) == ERROR)
  432. return (ERROR);
  434.     /* If memory address was specified but configuration flags were not */
  436.     if (memAddr!=0 && configFlags==0)
  437. pCs->configFlags |= CS_CFGFLG_MEM_MODE;  /* Implictly set memory mode */
  439.     /* If the interrupt vector was not specified then derive it */
  441.     if (intVector == 0)
  442. {
  443. CS_IRQ0_VECTOR(&intVector);
  444. pCs->intVector = intVector + pCs->intLevel;
  445. }
  447.     /* Setup the interrupt handler and the IDT table entry */
  449.     CS_INT_CONNECT (INUM_TO_IVEC (pCs->intVector), csIntr, unit, &result);
  450.     if (result == ERROR)
  451. {
  452. printf ("ncs%d - Can not connect interruptn", unit);
  453. return (ERROR);
  454. }
  456.     /* Enable interrupt at the 8259 PIC */
  458.     CS_INT_ENABLE(pCs->intLevel, &result);
  459.     if (result == ERROR)
  460. {
  461. printf ("ncs%d - Can not enable interruptn", unit);
  462. return (ERROR);
  463. }
  465.     /* Reset the chip */
  467.     if (csChipReset (pCs) == ERROR)
  468. {
  469. printf ("ncs%d - Can not reset the chipn", unit);
  470. return (ERROR);
  471. }
  473.     /* Attach this network interface driver to the system */
  475. #ifdef BSD43_DRIVER
  476.     ether_attach (&pCs->arpCom.ac_if, unit, "cs", csInit, csIoctl, csOutput,
  477.   (FUNCPTR)csReset);
  478. #else
  479.     ether_attach    (
  480.                     &pCs->arpCom.ac_if,
  481.                     unit,
  482.                     "cs",
  483.                     (FUNCPTR) csInit,
  484.                     (FUNCPTR) csIoctl,
  485.                     (FUNCPTR) ether_output, /* generic ether_output */
  486.                     (FUNCPTR) csReset
  487.                     );
  489.     pCs->arpCom.ac_if.if_start = (FUNCPTR) csStartOutput; 
  490. #endif
  491.     return (OK);
  492.     }
  495. /*******************************************************************************
  496. *
  497. * csChipVerify - verifies that the chip is present and correct
  498. *
  499. * This routine verifies that the Ethernet chip is present and correct.
  500. *
  501. * RETURNS: OK or ERROR
  502. */
  504. LOCAL STATUS csChipVerify 
  505.     (
  506.     CS_SOFTC *pCs
  507.     )
  508.     {
  509.     USHORT eisaNumber = csPacketPageR (pCs, CS_PKTPG_EISA_NUM);
  511.     /* Verify that we can read from the chip */
  513.     if (eisaNumber == 0xFFFF)
  514. {
  515. printf ("ncs0 - Can't read from chip (I/O address correct?)n");
  516. return (ERROR);
  517. }
  518.     
  519.     /* Verify that the chip is a Crystal Semiconductor chip */
  521.     if (eisaNumber != CS_EISA_NUM_CRYSTAL)
  522. {
  523. printf ("ncs0 - Chip is not a Crystal Semiconductor chipn");
  524. return (ERROR);
  525. }
  527.     /* Verify that the chip is a CS8900 */
  529.     if ((csPacketPageR (pCs, CS_PKTPG_PRODUCT_ID) & CS_PROD_ID_MASK) !=
  530. CS_PROD_ID_CS8900)
  531. {
  532. printf ("ncs0 - Chip is not a CS8900n");
  533. return (ERROR);
  534. }
  536.     return (OK);
  537.     }
  539. /*******************************************************************************
  540. *
  541. * csParmsGet - gets parameters that were not specifed to csAttach()
  542. *
  543. * This routine gets parameters, that were not specifed to csAttach(),
  544. * from the EEPROM and puts them in the cs_softc structure.  If all the
  545. * parameters were specified to csAttach(), then this routine does
  546. * not attempt to read the EEPROM.
  547. *
  548. * RETURNS: N/A
  549. */
  551. LOCAL STATUS csParmsGet
  552.     (
  553.     CS_SOFTC *pCs
  554.     )
  555.     {
  556.     USHORT selfStatus;
  557.     USHORT isaConfig;
  558.     USHORT memBase;
  559.     USHORT adapterConfig;
  560.     USHORT xmitCtl;
  562.     /* If all of these parameters were specified */
  564.     if ((pCs->configFlags != 0) &&
  565. (pCs->pPacketPage != NULL) &&
  566. (pCs->intLevel != 0) &&
  567. (pCs->mediaType != 0))
  568. return (OK);  /* Don't need to get anything from the EEPROM */
  570.     /* Verify that the EEPROM is present and OK */
  572.     selfStatus = csPacketPageR (pCs, CS_PKTPG_SELF_ST);
  573.     if (!((selfStatus & CS_SELF_ST_EEP_PRES) &&
  574. (selfStatus & CS_SELF_ST_EEP_OK)))
  575. {
  576. printf ("ncs0 - EEPROM is missing or badn");
  577. return (ERROR);
  578. }
  580.     /* Get ISA configuration from the EEPROM */
  581.     if (csEepromRead (pCs, CS_EEPROM_ISA_CFG, &isaConfig) == ERROR)
  582. return (ERROR);
  584.     /* Get adapter configuration from the EEPROM */
  585.     if (csEepromRead (pCs, CS_EEPROM_ADPTR_CFG, &adapterConfig) == ERROR)
  586. return (ERROR);
  588.     /* Get transmission control from the EEPROM */
  589.     if (csEepromRead (pCs, CS_EEPROM_XMIT_CTL, &xmitCtl) == ERROR)
  590. return (ERROR);
  592.     /* If the configuration flags were not specified */
  593.     if (pCs->configFlags == 0)
  594. {
  595. /* Copy the memory mode flag */
  596. if (isaConfig & CS_ISA_CFG_MEM_MODE)
  597.     pCs->configFlags |= CS_CFGFLG_MEM_MODE;
  599. /* Copy the USE_SA flag */
  600. if (isaConfig & CS_ISA_CFG_USE_SA)
  601.     pCs->configFlags |= CS_CFGFLG_USE_SA;
  603. /* Copy the IO Channel Ready flag */
  604. if (isaConfig & CS_ISA_CFG_IOCHRDY)
  605.     pCs->configFlags |= CS_CFGFLG_IOCHRDY;
  607. /* Copy the DC/DC Polarity flag */
  608. if (adapterConfig & CS_ADPTR_CFG_DCDC_POL)
  609.     pCs->configFlags |= CS_CFGFLG_DCDC_POL;
  611. /* Copy the Full Duplex flag */
  612. if (xmitCtl & CS_XMIT_CTL_FDX)
  613.     pCs->configFlags |= CS_CFGFLG_FDX;
  614. }
  616.      /* If the PacketPage pointer was not specified */
  617.      if (pCs->pPacketPage == NULL)
  618.  {
  619.  /* If memory mode is enabled
  620.   *   Get the memory base address from EEPROM
  621.   *   Setup the PacketPage pointer
  622.   */
  623.  if (pCs->configFlags & CS_CFGFLG_MEM_MODE)
  624.      {
  625.      if (csEepromRead (pCs, CS_EEPROM_MEM_BASE, &memBase) == ERROR)
  626.  return (ERROR);
  628.       memBase &= CS_MEM_BASE_MASK;  /* Clear unused bits */
  630.       pCs->pPacketPage = (USHORT *)(((ULONG)memBase) << 8);
  631.       }
  632.  }
  634.     /* If the interrupt level was not specified
  635.      *   Get the interrupt level from the IsaConfig
  636.      */
  637.     if (pCs->intLevel == 0)
  638. {
  639. pCs->intLevel = isaConfig & CS_ISA_CFG_IRQ_MASK;
  640. if (pCs->intLevel == 3)
  641.     pCs->intLevel = 5;
  642. else
  643.     pCs->intLevel += 10;
  644. }
  646.     /* If the media type was not specified
  647.      *   Get the media type from the adapterConfig
  648.      */
  649.     if (pCs->mediaType == 0)
  650. {
  651. switch (adapterConfig & CS_ADPTR_CFG_MEDIA)
  652.     {
  653.     case CS_ADPTR_CFG_AUI:
  654. pCs->mediaType = CS_MEDIA_AUI;
  655. break;
  656.     case CS_ADPTR_CFG_10BASE2:
  657. pCs->mediaType = CS_MEDIA_10BASE2;
  658. break;
  659.     case CS_ADPTR_CFG_10BASET:
  660.     default:
  661. pCs->mediaType = CS_MEDIA_10BASET;
  662. break;
  663.     }
  664. }
  666.     return (OK);
  667.     }
  669. /*******************************************************************************
  670. *
  671. * csParmsValidate - validate the memory address, interrupt level and media type
  672. *
  673. * This routine verifies that the memory address, interrupt level and media
  674. * type are valid.  If any of these parameters are invalid, then and error
  675. * message is printed and ERROR is returned.
  676. *
  677. * RETURNS: OK or ERROR
  678. */
  680. LOCAL STATUS csParmsValidate
  681.     (
  682.     CS_SOFTC *pCs
  683.     )
  684.     {
  685.     int memAddr = (int)(pCs->pPacketPage);
  687.     if ((memAddr & 0x000FFF) != 0)
  688. {
  689. printf ("ncs0 - Memory address (0x%X) must start on a 4K boundryn",
  690.         memAddr);
  691. return (ERROR);
  692. }
  694.     if (memAddr > 0xFFF000)
  695. {
  696. printf ("ncs0 - Memory address (0x%X) is too largen", memAddr);
  697. return (ERROR);
  698. }
  700.     if (!(pCs->intLevel==5 || pCs->intLevel==10 || pCs->intLevel==11 ||
  701.   pCs->intLevel==12))
  702. {
  703. printf ("ncs0 - Interrupt level (%d) is invalidn", pCs->intLevel);
  704. return (ERROR);
  705. }
  707.     if (!(pCs->mediaType==CS_MEDIA_AUI || pCs->mediaType==CS_MEDIA_10BASE2 ||
  708.   pCs->mediaType==CS_MEDIA_10BASET))
  709. {
  710. printf ("ncs0 - Media type (%d) is invalidn", pCs->mediaType);
  711. return (ERROR);
  712. }
  714.     return (OK);
  715.     }
  717. /*******************************************************************************
  718. *
  719. * csEnetAddrGet - get the ethernet address from arguments or EEPROM
  720. *
  721. * If a pointer to an Ethernet address string was passed-in to the csAttach()
  722. * routine, then this routine coverts the address string to an Ethernet address
  723. * and saves it in the arpcom structure.  If an Ethernet address string was
  724. * not passed-in, then the Ethernet address is read from the EEPROM and saved
  725. * in the arpcom structure.
  726. *
  727. * RETURNS: OK or ERROR
  728. */
  730. LOCAL STATUS csEnetAddrGet
  731.     (
  732.     CS_SOFTC *pCs,
  733.     char *pEthernetAddr
  734.     )
  735.     {
  736.     USHORT selfStatus;
  737.     CS_IA *pIA = (CS_IA *)pCs->arpCom.ac_enaddr;
  739.     /* If the Ethernet address was not specified */
  740.     if (pEthernetAddr == NULL)
  741. {
  742. /* Verify that the EEPROM is present and OK */
  743. selfStatus = csPacketPageR (pCs, CS_PKTPG_SELF_ST);
  744. if (!((selfStatus & CS_SELF_ST_EEP_PRES) && 
  745.     (selfStatus & CS_SELF_ST_EEP_OK)))
  746.     {
  747.     printf ("ncs0 - EEPROM is missing or badn");
  748.     return (ERROR);
  749.     }
  751.        /* Get Ethernet address from the EEPROM */
  752.        if (csEepromRead (pCs, CS_EEPROM_IND_ADDR_H, &pIA->word[0]) == ERROR)
  753.    return (ERROR);
  754.        if (csEepromRead (pCs, CS_EEPROM_IND_ADDR_M, &pIA->word[1]) == ERROR)
  755.    return (ERROR);
  756.        if (csEepromRead (pCs, CS_EEPROM_IND_ADDR_L, &pIA->word[2]) == ERROR)
  757.    return (ERROR);
  758.        }
  759.     else  /* The Ethernet address was specified */
  760.        {
  761.        /* Convert and save the Ethernet address string */
  762.        pEthernetAddr = csHexWord (pEthernetAddr, &pIA->word[0]);
  763.        if (pEthernetAddr == NULL)
  764.    return (ERROR);
  765.        pEthernetAddr = csHexWord (pEthernetAddr, &pIA->word[1]);
  766.        if (pEthernetAddr == NULL)
  767.    return (ERROR);
  768.        pEthernetAddr = csHexWord (pEthernetAddr, &pIA->word[2]);
  769.        if (pEthernetAddr == NULL)
  770.    return (ERROR);
  771.        }
  773.     return (OK);
  774.     }
  776. /*******************************************************************************
  777. *
  778. * csHexWord - converts a sequence of hex characters to the 16-bit value
  779. *
  780. * This routine converts a sequence of hex characters to the 16-bit value
  781. * that they represent.  The address of the first hex character is passed
  782. * in the pChar parameter and the address just beyond the last hex
  783. * character is returned.  The 16-bit variable pointed to by the pWord
  784. * parameter is updated with the converted 16-bit value.  If an error
  785. * occurred then NULL is returned.
  786. *
  787. * RETURNS: address of next character
  788. */
  790. LOCAL char *csHexWord
  791.     (
  792.     char *pChar,
  793.     USHORT *pWord
  794.     )
  795.     {
  796.     union
  797. {
  798. USHORT word;
  799. UCHAR  byte[2];
  800. } value;
  802.     /* Get the value of the first hex byte */
  803.     pChar = csHexByte (pChar, &value.byte[0]);
  804.     if ((pChar != NULL) && (*pChar == 0))
  805. printf ("ncs0 - Ethernet address string too shortn");
  806.     if ((pChar == NULL) || (*pChar == 0))
  807. return (NULL);
  809.     /* Get the value of the second hex byte */
  810.     pChar = csHexByte (pChar, &value.byte[1]);
  811.     if (pChar == NULL)
  812. return (NULL);
  814.     /* Save value of the hex word */
  815.     *pWord = value.word;
  816.  
  817.     return (pChar);
  818.     }
  820. /*******************************************************************************
  821. *
  822. * csHexByte - converts a sequence of hex characters to the 8-bit value
  823. *
  824. * This routine converts a sequence of hex characters to the 8-bit value
  825. * that they represent.  There may be zero, one or two hex characters and
  826. * they may be optionally terminated with a colon or a zero byte.
  827. * The address of the first hex character is passed in the pChar parameter
  828. * and the address just beyond the last hex character is returned.
  829. * The 8-bit variable pointed to by the pByte parameter is updated with
  830. * the converted 8-bit value.  If an error occurred then NULL is returned.
  831. *
  832. * RETURNS: address of next character
  833. */
  835. LOCAL char *csHexByte
  836.     (
  837.     char *pChar,
  838.     UCHAR *pByte
  839.     )
  840.     {
  841.     int ix;
  843.     /* Inititalize the byte value to zero */
  844.     *pByte = 0;
  846.     /* Process two hex characters */
  847.     for (ix=0; ix<2; ix++, pChar++)
  848. {
  849. /* Stop early if find a colon or end of string */
  850. if ((*pChar == ':') || (*pChar == 0))
  851.     break;
  853. /* Convert the hex character to a value */
  854. if ((*pChar >= '0') && (*pChar <= '9'))
  855.     *pByte = (*pByte * 16) + *pChar - '0';
  856. else if ((*pChar >= 'a') && (*pChar <= 'f'))
  857.     *pByte = (*pByte * 16) + *pChar - 'a' + 10;
  858. else if ((*pChar >= 'A') && (*pChar <= 'F'))
  859.     *pByte = (*pByte * 16) + *pChar - 'A' + 10;
  860. else
  861.     {
  862.     printf ("ncs0 - Illegal character '%c' in Enet address stringn",
  863.             *pChar);
  864.     return (NULL);  /* Illegal character */
  865.     }
  866. }
  868.     /* Skip past terminating colon */
  869.     if (*pChar == ':')
  870. pChar++;
  872.     return (pChar);
  873.     }
  875. /*******************************************************************************
  876. *
  877. * csEepromRead - reads a word from the EEPROM
  878. *
  879. * This routine reads a word from the EEPROM at the specified offset.
  880. *
  881. * RETURNS: OK or ERROR
  882. */
  884. LOCAL STATUS csEepromRead
  885.     (
  886.     CS_SOFTC *pCs,
  887.     USHORT offset,
  888.     USHORT *pValue
  889.     )
  890.     {
  891.     int ix;
  893.     /* Ensure that the EEPROM is not busy */
  894.     for (ix=0; ix<CS_MAXLOOP; ix++)
  895. if (!(csPacketPageR (pCs, CS_PKTPG_SELF_ST) & CS_SELF_ST_SI_BUSY))
  896.     break;
  897.     if (ix == CS_MAXLOOP)
  898.        {
  899.        printf ("ncs0 - Can not read from EEPROMn");
  900.        return (ERROR);
  901.        }
  903.     /* Issue the command to read the offset within the EEPROM */
  904.     csPacketPageW (pCs, CS_PKTPG_EEPROM_CMD, offset | CS_EEPROM_CMD_READ);
  906.     /* Wait until the command is completed */
  907.     for (ix=0; ix<CS_MAXLOOP; ix++)
  908. if (!(csPacketPageR (pCs, CS_PKTPG_SELF_ST) & CS_SELF_ST_SI_BUSY))
  909.     break;
  910.     if (ix == CS_MAXLOOP)
  911. {
  912. printf ("ncs0 - Can not read from EEPROMn");
  913. return (ERROR);
  914. }
  916.     /* Get the EEPROM data from the EEPROM data register */
  917.     *pValue = csPacketPageR (pCs, CS_PKTPG_EEPROM_DATA);
  918.  
  919.     return (OK);
  920.     }
  922. /*******************************************************************************
  923. *
  924. * csInit - resets and then initializes the CS8900 chip
  925. *
  926. * This routine is a major entry point and is called to initialize this network
  927. * interface driver.  This routine may be called several times for each
  928. * operating system reboot to dynamically bring the network interface driver
  929. * to an up and running state.  This routine is called by the protocol stack,
  930. * the set_if_addr() routine, and the csIoctl() routine.
  931. *
  932. * RETURNS: OK or ERROR
  933. */
  935. LOCAL STATUS csInit
  936.     (
  937.     int unit
  938.     )
  939.     {
  940.     FAST CS_SOFTC *pCs = &cs_softc[unit];
  942.     if (unit >= MAXUNITS)
  943. return (ERROR);
  945.     /* Mark the interface as down */
  947.     pCs->arpCom.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
  949.     /* Enable debugging */
  950.     /* pCs->arpCom.ac_if.if_flags |= IFF_DEBUG; */
  952.     csError (pCs, "Initializing interface");
  954.     /* Reset the chip */
  956.     if (csChipReset (pCs) == ERROR)
  957. {
  958. csError (pCs, "Can not reset the chip");
  959. return (ERROR);
  960. }
  962.     /* Initialize the chip */
  964.     csChipInit (pCs);
  966.     /* Mark the interface as up and running */
  968.     pCs->arpCom.ac_if.if_flags |= (IFF_UP | IFF_RUNNING);
  970.     return (OK);
  971.     }
  973. /*******************************************************************************
  974. *
  975. * csReset - resets the CS8900 chip.
  976. *
  977. * This routine is a major entry point and is called by the protocol stack to
  978. * shut down this network interface driver.  This routine may be called several
  979. * times for each operating system reboot to dynamically bring the network
  980. * interface driver to a non-running state.
  981. *
  982. * RETURNS: N/A
  983. */
  985. LOCAL void csReset
  986.     (
  987.     int unit
  988.     )
  989.     {
  990.     FAST CS_SOFTC *pCs = &cs_softc[unit];
  992.     if (unit >= MAXUNITS)
  993. return;
  995.     csError (pCs, "Resetting interface");
  997.     /* Mark the interface as down */
  999.     pCs->arpCom.ac_if.if_flags &= ~IFF_RUNNING;
  1001.     /* Reset the chip */
  1003.     csChipReset (pCs);
  1004.     }
  1006. /*******************************************************************************
  1007. *
  1008. * csIoctl - ioctl for interface
  1009. *
  1010. * This routine is a major entry point and is called by the protocol stack to
  1011. * modify characteristics of this network interface driver.  There are many
  1012. * network interface ioctl commands, but this driver only supports two of them:
  1013. * Set Interface Address and Set Interface Flags.
  1014. *
  1015. * RETURNS: OK if successful, otherwise errno.
  1016. */
  1018. LOCAL int csIoctl
  1019.     (
  1020.     struct ifnet *pIf,
  1021.     int command,
  1022.     char *pData
  1023.     )
  1024.     {
  1025.     FAST CS_SOFTC *pCs = &cs_softc[pIf->if_unit];
  1026.     int result         = OK;  /* Assume everything will go OK */
  1027.     int state          = splnet();
  1029.     switch (command)
  1030. {
  1031. case SIOCSIFADDR:  /* Set interface address (IP address) */
  1032.     csError (pCs, "Ioctl: Set interface address");
  1033.     result = set_if_addr (pIf, pData, (UCHAR *)pCs->arpCom.ac_enaddr);
  1034.     /* Note: set_if_addr () calls csInit() */
  1035.     break;
  1036. case SIOCSIFFLAGS:  /* Set interface flags */
  1037.     csError (pCs, "Ioctl: Set interface flags");
  1038.     if (pIf->if_flags & IFF_UP)
  1039. {
  1040. /* Mark the interface as up and running */
  1041. pCs->arpCom.ac_if.if_flags |= (IFF_UP | IFF_RUNNING);
  1043. /* Initialize the interface */
  1044. csInit (pIf->if_unit);
  1045. }
  1046.     else  /* The interface is down */
  1047. {
  1048. /* Mark the interface as down */
  1049. pCs->arpCom.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
  1051. /* Reset the chip */
  1052. csChipReset (pCs);
  1053. }
  1054.     break;
  1055. default:
  1056.     result = EINVAL;  /* Invalid argument */
  1057.     break;
  1058. }
  1060.     splx (state);
  1062.     return (result);
  1063.     }
  1065. /*******************************************************************************
  1066. *
  1067. * csChipReset - resets the CS8900 chip
  1068. *
  1069. * This routine resets the CS8900 chip.
  1070. *
  1071. * RETURNS: OK or ERROR
  1072. */
  1074. LOCAL STATUS csChipReset 
  1075.     (
  1076.     CS_SOFTC *pCs
  1077.     )
  1078.     {
  1079.     int intState;
  1080.     int ix;
  1081.     UCHAR temp;
  1083.     /* Disable interrupts at the CPU so reset command is atomic */
  1085.     intState = intLock (); /* INT LOCK */
  1087.     /* We are now resetting the chip
  1088.      * A spurious interrupt is generated by the chip when it is reset.
  1089.      * This variable informs the interrupt handler to ignore this interrupt.
  1090.      */
  1091.     pCs->resetting = TRUE;
  1093.     /* Issue a reset command to the chip */
  1094.     csPacketPageW (pCs, CS_PKTPG_SELF_CTL, CS_SELF_CTL_RESET);
  1096.     /* Re-enable interrupts at the CPU */
  1097.     intUnlock (intState); /* INT UNLOCK */
  1099.     /* The chip is always in IO mode after a reset */
  1100.     pCs->inMemoryMode = FALSE;
  1102.     /* If transmission was in progress, it is not now */
  1103.     pCs->txInProgress = FALSE;
  1105.     /* Delay for 125 micro-seconds (one eighth of a second) */
  1107.     CS_MSEC_DELAY(125);
  1109.     /* Transition SBHE to switch chip from 8-bit to 16-bit */
  1111.     CS_IN_BYTE (pCs->ioAddr + CS_PORT_PKTPG_PTR, &temp);
  1112.     CS_IN_BYTE (pCs->ioAddr + CS_PORT_PKTPG_PTR + 1, &temp);
  1113.     CS_IN_BYTE (pCs->ioAddr + CS_PORT_PKTPG_PTR, &temp);
  1114.     CS_IN_BYTE (pCs->ioAddr + CS_PORT_PKTPG_PTR + 1, &temp);
  1116.     /* Wait until the EEPROM is not busy */
  1117.     for (ix=0; ix<CS_MAXLOOP; ix++)
  1118. if (!(csPacketPageR (pCs, CS_PKTPG_SELF_ST) & CS_SELF_ST_SI_BUSY))
  1119.     break;
  1120.     if (ix == CS_MAXLOOP)
  1121. return (ERROR);
  1123.     /* Wait until initialization is done */
  1124.     for (ix=0; ix<CS_MAXLOOP; ix++)
  1125. if (csPacketPageR (pCs, CS_PKTPG_SELF_ST) & CS_SELF_ST_INIT_DONE)
  1126.     break;
  1127.     if (ix == CS_MAXLOOP)
  1128. return (ERROR);
  1130.     /* Reset is no longer in progress */
  1132.     pCs->resetting = FALSE;
  1134.     return (OK);
  1135.     }
  1137. /*******************************************************************************
  1138. *
  1139. * csChipInit - initializes the CS8900 chip
  1140. *
  1141. * This routine uses the instance global variables in the cs_softc structure to
  1142. * initialize the CS8900 chip.
  1143. *
  1144. * RETURNS: N/A
  1145. */
  1147. LOCAL void csChipInit
  1148.     (
  1149.     CS_SOFTC *pCs
  1150.     )
  1151.     {
  1152.     USHORT busCtl;
  1153.     USHORT selfCtl;
  1154.     CS_IA  *pIA;
  1156.     /* If memory mode is enabled */
  1157.     if (pCs->configFlags & CS_CFGFLG_MEM_MODE)
  1158. {
  1159. /* If external logic is present for address decoding */
  1160. if (csPacketPageR (pCs, CS_PKTPG_SELF_ST) & CS_SELF_ST_EL_PRES)
  1161.     {
  1162.     /* Program the external logic to decode address bits SA20-SA23 */
  1163.     csPacketPageW (pCs, CS_PKTPG_EEPROM_CMD,
  1164.        ((UINT)(pCs->pPacketPage)>>20) | CS_EEPROM_CMD_ELSEL);
  1165.     }
  1167. /* Setup chip for memory mode */
  1168. csPacketPageW (pCs, CS_PKTPG_MEM_BASE, (UINT)(pCs->pPacketPage)&0xFFFF);
  1169. csPacketPageW (pCs, CS_PKTPG_MEM_BASE+2, (UINT)(pCs->pPacketPage)>>16);
  1170. busCtl = CS_BUS_CTL_MEM_MODE;
  1171. if (pCs->configFlags & CS_CFGFLG_USE_SA)
  1172.     busCtl |= CS_BUS_CTL_USE_SA;
  1173. csPacketPageW (pCs, CS_PKTPG_BUS_CTL, busCtl);
  1175. /* We are in memory mode now! */
  1176. pCs->inMemoryMode = TRUE;
  1177. }
  1179.     /* If IOCHRDY is enabled then clear the bit in the busCtl register */
  1180.     busCtl = csPacketPageR (pCs, CS_PKTPG_BUS_CTL);
  1181.     if (pCs->configFlags & CS_CFGFLG_IOCHRDY)
  1182. csPacketPageW (pCs, CS_PKTPG_BUS_CTL, busCtl & ~CS_BUS_CTL_IOCHRDY);
  1183.     else
  1184. csPacketPageW (pCs, CS_PKTPG_BUS_CTL, busCtl | CS_BUS_CTL_IOCHRDY);
  1186.     /* Set the Line Control register to match the media type */
  1187.     if (pCs->mediaType == CS_MEDIA_10BASET)
  1188. csPacketPageW (pCs, CS_PKTPG_LINE_CTL, CS_LINE_CTL_10BASET);
  1189.     else
  1190. csPacketPageW (pCs, CS_PKTPG_LINE_CTL, CS_LINE_CTL_AUI_ONLY);
  1192.     /* Set the BSTATUS/HC1 pin to be used as HC1 */
  1193.     /* HC1 is used to enable the DC/DC converter */
  1194.     selfCtl = CS_SELF_CTL_HC1E;
  1196.     /* If the media type is 10Base2 */
  1197.     if (pCs->mediaType == CS_MEDIA_10BASE2)
  1198. {
  1199. /* Enable the DC/DC converter
  1200.  * If the DC/DC converter has a low enable
  1201.  *   Set the HCB1 bit, which causes the HC1 pin to go low
  1202.  */
  1203. if ((pCs->configFlags & CS_CFGFLG_DCDC_POL) == 0)
  1204.     selfCtl |= CS_SELF_CTL_HCB1;
  1205. }
  1206.     else  /* Media type is 10BaseT or AUI */
  1207. {
  1208. /* Disable the DC/DC converter
  1209.  * If the DC/DC converter has a high enable
  1210.  *   Set the HCB1 bit, which causes the HC1 pin to go low
  1211.  */
  1212. if ((pCs->configFlags & CS_CFGFLG_DCDC_POL) != 0)
  1213.     selfCtl |= CS_SELF_CTL_HCB1;
  1214. }
  1215.     csPacketPageW (pCs, CS_PKTPG_SELF_CTL, selfCtl);
  1217.     /* If media type is 10BaseT */
  1218.     if (pCs->mediaType == CS_MEDIA_10BASET)
  1219. {
  1220. /* If full duplex mode then set the FDX bit in TestCtl register */
  1221. if (pCs->configFlags & CS_CFGFLG_FDX)
  1222.     csPacketPageW (pCs, CS_PKTPG_TEST_CTL, CS_TEST_CTL_FDX);
  1223. }
  1225.     /* Initialize the config and control registers */
  1226.     csPacketPageW (pCs, CS_PKTPG_RX_CFG, CS_RX_CFG_ALL_IE);
  1227.     csPacketPageW (pCs, CS_PKTPG_RX_CTL,
  1228.    CS_RX_CTL_RX_OK_A | CS_RX_CTL_IND_A | CS_RX_CTL_BCAST_A);
  1229.     csPacketPageW (pCs, CS_PKTPG_TX_CFG, CS_TX_CFG_ALL_IE);
  1230.     csPacketPageW (pCs, CS_PKTPG_BUF_CFG, CS_BUF_CFG_RX_MISS_IE);
  1232.     /* Put Ethernet address into the Individual Address register */
  1233.     pIA = (CS_IA *)pCs->arpCom.ac_enaddr;
  1234.     csPacketPageW (pCs, CS_PKTPG_IND_ADDR,   pIA->word[0]);
  1235.     csPacketPageW (pCs, CS_PKTPG_IND_ADDR+2, pIA->word[1]);
  1236.     csPacketPageW (pCs, CS_PKTPG_IND_ADDR+4, pIA->word[2]);
  1238.     /* Set the interrupt level in the chip */
  1239.     if (pCs->intLevel == 5)
  1240. csPacketPageW (pCs, CS_PKTPG_INT_NUM, 3);
  1241.     else
  1242. csPacketPageW (pCs, CS_PKTPG_INT_NUM, (pCs->intLevel) - 10);
  1244.     /* Enable reception and transmission of frames */
  1245.     csPacketPageW (pCs, CS_PKTPG_LINE_CTL,
  1246.     csPacketPageR (pCs, CS_PKTPG_LINE_CTL) |
  1247.    CS_LINE_CTL_RX_ON | CS_LINE_CTL_TX_ON);
  1249.     /* Enable interrupt at the chip */
  1250.     csPacketPageW (pCs, CS_PKTPG_BUS_CTL,
  1251.     csPacketPageR (pCs, CS_PKTPG_BUS_CTL) |
  1252.    CS_BUS_CTL_INT_ENBL);
  1253.     }
  1255. #ifdef BSD43_DRIVER
  1256. /*******************************************************************************
  1257. *
  1258. * csOutput - ethernet output routine
  1259. *
  1260. * This routine is a major entry point and is called by the protocol stack to
  1261. * transmit a packet across the LAN.  The packet data is passed to this routine
  1262. * in a chain of mbuf structures.
  1263. *
  1264. * This routine calls the ether_output() routine, which in turn calls the
  1265. * csStartOutput() routine.  The ether_output() routine resolves the destination
  1266. * IP address to it's Ethernet address, builds an Ethernet header and prepends
  1267. * the Ethernet header to the mbuf chain.  The mbuf chain is added to the end
  1268. * of the network interface driver's transmit queue.  If the network interface
  1269. * NOTRAILERS flag is clear (trailers enabled), then the ether_output() routine
  1270. * converts the packet data to the trailers format.  Finally, the ether_output()
  1271. * routine calls the csStartOutput() routine begin transmission of the packet.
  1272. *
  1273. * RETURNS: OK if successful, otherwise errno.
  1274. */
  1276. LOCAL int csOutput
  1277.     (
  1278.     struct ifnet *pIf,
  1279.     struct mbuf *pMbufChain,
  1280.     SOCKADDR *pDst
  1281.     )
  1282.     {
  1283.     FAST CS_SOFTC *pCs = &cs_softc[pIf->if_unit];
  1285.     return (ether_output (pIf, pMbufChain, pDst, (FUNCPTR)csStartOutput,
  1286.   &pCs->arpCom));
  1287.     }
  1289. /*******************************************************************************
  1290. *
  1291. * csStartOutput - copy a packet to the interface
  1292. *
  1293. * This routine is called to start the transmission of the packet at the head
  1294. * of the transmit queue.  This routine is called by the ether_output() routine
  1295. * when a new packet is added to the transmit queue and this routine is called
  1296. * by csIntrTx() via netTask() when a previous packet transmission is
  1297. * completed.  This routine is always executed at task time (never at interrupt
  1298. * time).
  1299. *
  1300. * Note: This network interface driver does not support output hook routines,
  1301. * because to do so requires that an image of the transmit packet be built in
  1302. * memory before the image is copied to the CS8900 chip.  It is much more
  1303. * efficient to copy the image directly from the mbuf chain to the CS8900 chip.
  1304. * However, this network interface driver does support input hook routines.
  1305. *
  1306. * RETURNS: N/A
  1307. */
  1309. LOCAL void csStartOutput
  1310.     (
  1311.     int unit
  1312.     )
  1313.     {
  1314.     FAST CS_SOFTC *pCs = &cs_softc[unit];
  1315. #else /* BSD43_DRIVER */
  1316. LOCAL void csStartOutput
  1317.     (
  1318.     CS_SOFTC * pCs /* pointer to control structure */
  1319.     )
  1320.     {
  1321. #endif /* BSD43_DRIVER */
  1322.     FAST struct mbuf *pMbuf;
  1323.     struct mbuf *pMbufChain;
  1324.     struct ifqueue *pTxQueue;
  1325.     USHORT busStatus;
  1326.     USHORT length;
  1327.     int intState;
  1329. #ifdef BSD43_DRIVER
  1330.     if (unit >= MAXUNITS)
  1331. return;
  1332. #endif /* BSD43_DRIVER */
  1334.     pTxQueue = &pCs->arpCom.ac_if.if_snd;
  1336.     /* Note the maximum depth of the transmit queue */
  1337.     if (pTxQueue->ifq_len > pCs->maxTxDepth)
  1338. pCs->maxTxDepth = pTxQueue->ifq_len;
  1340.     /* Don't interrupt a transmission in progress */
  1341.     if (pCs->txInProgress)
  1342. return;
  1344.     /* Disable interrupts at the CPU so disabling chip interrupt is atomic */
  1345.     intState = intLock (); /* INT LOCK */
  1347.     /* Disable interrupt at the chip so transmit sequence is not disturbed */
  1348.     csPacketPageW (pCs, CS_PKTPG_BUS_CTL,
  1349.     csPacketPageR (pCs, CS_PKTPG_BUS_CTL) &
  1350.    ~CS_BUS_CTL_INT_ENBL);
  1352.     /* Re-enable interrupts at the CPU */
  1353.     intUnlock (intState); /* INT UNLOCK */
  1355.     /* While there is still more to transmit */
  1356.     while (pTxQueue->ifq_head != NULL)
  1357. {
  1358. /* Dequeue an mbuf chain from the transmit queue */
  1359. IF_DEQUEUE (pTxQueue, pMbufChain);
  1361. /* Find the total length of the data to transmit */
  1362. length = 0;
  1363. for (pMbuf=pMbufChain; pMbuf!=NULL; pMbuf=pMbuf->m_next)
  1364.     length += pMbuf->m_len;
  1366. /* etherOutputHookRtn is not supported */
  1367.  
  1368. /* Request that the transmit be started after
  1369.  * all data has been copied
  1370.  */
  1371. if (pCs->inMemoryMode)
  1372.     {
  1373.     csPacketPageW (pCs, CS_PKTPG_TX_CMD, CS_TX_CMD_START_ALL);
  1374.     csPacketPageW (pCs, CS_PKTPG_TX_LENGTH, length);
  1375.     }
  1376. else  /* In IO mode */
  1377.     {
  1378.     CS_OUT_WORD (pCs->ioAddr + CS_PORT_TX_CMD, CS_TX_CMD_START_ALL);
  1379.     CS_OUT_WORD (pCs->ioAddr + CS_PORT_TX_LENGTH, length);
  1380.     }
  1382. /* Read the busStatus register which indicates success of the request */
  1383. busStatus = csPacketPageR (pCs, CS_PKTPG_BUS_ST);
  1385. /* If there was an error in the transmit bid */
  1386. if (busStatus & CS_BUS_ST_TX_BID_ERR)
  1387.     {
  1388.     csError (pCs, "Transmit bid error (too big)");
  1389.     /* Discard the bad mbuf chain */
  1390.     m_freem (pMbufChain);
  1391.     pCs->arpCom.ac_if.if_oerrors++;
  1392.     /* Loop up to transmit the next chain */
  1393.     }
  1394. else if (busStatus & CS_BUS_ST_RDY4TXNOW)
  1395.     {
  1396.     /* The chip is ready for transmission now */
  1397.     /* Copy the frame to the chip to start transmission */
  1398.     csTxFrameCopy (pCs, pMbufChain);
  1399.     /* Free the mbuf chain */
  1400.     m_freem (pMbufChain);
  1401.     /* Transmission is now in progress */
  1402.     pCs->txInProgress = TRUE;
  1403.     break;  /* Exit this routine */
  1404.     }
  1405. else
  1406.        csError (pCs, "Not ready for transmission now");
  1407. }
  1409.     /* Re-enable interrupt at the chip */
  1410.     csPacketPageW (pCs, CS_PKTPG_BUS_CTL, 
  1411.    csPacketPageR (pCs, CS_PKTPG_BUS_CTL) | CS_BUS_CTL_INT_ENBL);
  1412.     }
  1414. /*******************************************************************************
  1415. *
  1416. * csTxFrameCopy - copies the packet from a mbuf chain to the chip
  1417. *
  1418. * This routine copies the packet from a chain of mbufs to the chip.  When all
  1419. * the data has been copied, then the chip automatically begins transmitting
  1420. * the data.
  1421. *
  1422. * The reason why this "simple" copy routine is so long and complicated is
  1423. * because all reads and writes to the chip must be done as 16-bit words.
  1424. * If an mbuf has an odd number of bytes, then the last byte must be saved
  1425. * and combined with the first byte of the next mbuf.
  1426. *
  1427. * RETURNS: N/A
  1428. */
  1430. LOCAL void csTxFrameCopy
  1431.     (
  1432.     CS_SOFTC *pCs,
  1433.     struct mbuf *pMbufChain
  1434.     )
  1435.     {
  1436.     struct mbuf *pMbuf;
  1437.     FAST USHORT *pFrame;
  1438.     FAST USHORT *pBuff;
  1439.     FAST USHORT *pBuffLimit;
  1440.     FAST int txDataPort;
  1441.     UCHAR  *pStart;
  1442.     USHORT  length;
  1443.     BOOL haveExtraByte;
  1444.     union
  1445. {
  1446. UCHAR  byte[2];
  1447. USHORT word;
  1448. } straddle;
  1450.     /* Initialize frame pointer and data port address */
  1451.     pFrame = pCs->pPacketPage + (CS_PKTPG_TX_FRAME/2);
  1452.     txDataPort = pCs->ioAddr + CS_PORT_RXTX_DATA;
  1454.     haveExtraByte = FALSE;  /* Start out with no extra byte */
  1456.     /* Process the chain of mbufs */
  1457.     for (pMbuf=pMbufChain; pMbuf!=NULL; pMbuf=pMbuf->m_next)
  1458. {
  1459. /* Setup starting pointer and length */
  1460. pStart = mtod (pMbuf, UCHAR *);
  1461. length = pMbuf->m_len;
  1463. /* If there is an extra byte left over from the previous mbuf */
  1464. if (haveExtraByte)
  1465.     {
  1466.     /* Add the first byte from this mbuf to make a word */
  1467.     straddle.byte[1] = *pStart;
  1469.     /* Write the word which straddles the mbufs to the chip */
  1470.     if (pCs->inMemoryMode)
  1471. *pFrame++ = straddle.word;
  1472.     else
  1473. {
  1474. CS_OUT_WORD (txDataPort, straddle.word);
  1475. }
  1477.     /* Adjust starting pointer and length */
  1478.     pStart++;
  1479.     length--;
  1480.     }
  1482. /* Point pBuff to the correct starting point */
  1483. pBuff = (USHORT *)pStart;
  1484.  
  1485. /* If there are odd bytes remaining in the mbuf */
  1486. if (length & 1)
  1487.     {
  1488.     haveExtraByte = TRUE;
  1490.     /* Point pBuffLimit to the extra byte */
  1491.     pBuffLimit = (USHORT *)(pStart+length-1);
  1492.     }
  1493. else  /* There is an even number of bytes remaining */
  1494.     {
  1495.     haveExtraByte = FALSE;
  1497.     /* Point pBuffLimit to just beyond the last word */
  1498.     pBuffLimit = (USHORT *)(pStart+length);
  1499.     }
  1501. /* Copy the words in the mbuf to the chip */
  1502. if (pCs->inMemoryMode)
  1503.     while (pBuff < pBuffLimit)
  1504. *pFrame++ = *pBuff++;
  1505. else
  1506.     while (pBuff < pBuffLimit)
  1507. {
  1508. CS_OUT_WORD (txDataPort, *pBuff++);
  1509. }
  1511.         /* If there is an extra byte left over in this mbuf
  1512.  *   Save the extra byte for later
  1513.  */
  1514.         if (haveExtraByte)
  1515.     straddle.byte[0] = *(UCHAR *)pBuff;
  1516. }
  1518.     /* If there is an extra byte left over from the last mbuf */
  1519.     if (haveExtraByte)
  1520. {
  1521. /* Add a zero byte to make a word */
  1522. straddle.byte[1] = 0;
  1524. /* Write the last word to the chip */
  1525. if (pCs->inMemoryMode)
  1526.     *pFrame = straddle.word;
  1527. else
  1528.     {
  1529.     CS_OUT_WORD (txDataPort, straddle.word);
  1530.     }
  1531. }
  1532.     }
  1533.  
  1534. /*******************************************************************************
  1535. *
  1536. * csIntr - Ethernet interface interrupt
  1537. *
  1538. * This routine in the interrupt service routine.  This routine is called by
  1539. * assembly language wrapper code whenever the CS8900 chip generates and
  1540. * interrupt.  The wrapper code issues an EOI command intr. controller.
  1541. *
  1542. * This routine processes the events on the Interrupt Status Queue.  The events
  1543. * are read one at a time from the ISQ and the appropriate event handlers are
  1544. * called.  The ISQ is read until it is empty.  If the chip's interrupt request
  1545. * line is active, then reading a zero from the ISQ will deactivate the
  1546. * interrupt request line.
  1547. *
  1548. * RETURNS: N/A
  1549. */
  1551. LOCAL void csIntr
  1552.     (
  1553.     int unit
  1554.     )
  1555.     {
  1556.     FAST CS_SOFTC *pCs = &cs_softc[unit];
  1557.     USHORT event;
  1559.     if (unit >= MAXUNITS)
  1560. return;
  1562.     /* Ignore any interrupts that happen while the chip is being reset */
  1563.     if (pCs->resetting)
  1564. return;
  1566.     /* Read an event from the Interrupt Status Queue */
  1567.     if (pCs->inMemoryMode)
  1568. event = csPacketPageR (pCs, CS_PKTPG_ISQ);
  1569.     else
  1570. {
  1571. CS_IN_WORD (pCs->ioAddr + CS_PORT_ISQ, &event);
  1572. }
  1574.     /* Process all the events in the Interrupt Status Queue */
  1575.     while (event != 0)
  1576. {
  1577. /* Dispatch to an event handler based on the register number */
  1578. switch (event & CS_REG_NUM_MASK)
  1579.     {
  1580.     case CS_REG_NUM_RX_EVENT:
  1581. csIntrRx (pCs, event);
  1582. break;
  1583.     case CS_REG_NUM_TX_EVENT:
  1584. csIntrTx (pCs, event);
  1585. break;
  1586.     case CS_REG_NUM_BUF_EVENT:
  1587. csIntrBuffer (pCs, event);
  1588. break;
  1589.     default:
  1590. csError (pCs, "Unknown interrupt event");
  1591. break;
  1592.     }
  1594. /* Read another event from the Interrupt Status Queue */
  1595. if (pCs->inMemoryMode)
  1596.     event = csPacketPageR (pCs, CS_PKTPG_ISQ);
  1597. else
  1598.     {
  1599.     CS_IN_WORD (pCs->ioAddr + CS_PORT_ISQ, &event);
  1600.     }
  1601. }
  1602.     }
  1604. /*******************************************************************************
  1605. *
  1606. * csIntrBuffer - interrupt handler for the receive miss event
  1607. *
  1608. * The routine is called whenever an event occurs regarding the transmit and
  1609. * receive buffers within the CS8900 chip.  The only buffer event that could
  1610. * happen with this network interface driver is the receive miss event.  When
  1611. * there are no receive buffers available within the chip and a packet arrives
  1612. * from the LAN, then this interrupt is generated.  This routine simply
  1613. * increments the input error counter.
  1614. *
  1615. * RETURNS: N/A
  1616. */
  1618. LOCAL void csIntrBuffer 
  1619.     (
  1620.     CS_SOFTC *pCs,
  1621.     USHORT bufEvent
  1622.     )
  1623.     {
  1624.     struct ifnet *pIf = &pCs->arpCom.ac_if;
  1626.     if (bufEvent & CS_BUF_EVENT_RX_MISS)
  1627. {
  1628. /* Increment the input error count */
  1629. pIf->if_ierrors++;
  1630. csError (pCs, "Receive miss");
  1631. }
  1633.     if (bufEvent & CS_BUF_EVENT_SW_INT)
  1634. {
  1635. csError (pCs, "Software initiated interrupt");
  1636. }
  1637.     }
  1639. /*******************************************************************************
  1640. *
  1641. * csIntrTx - interrupt handler for the transmission
  1642. *
  1643. * This routine is called whenever the transmission of a packet has completed
  1644. * successfully or unsuccessfully.  If the transmission was not successful,
  1645. * then the output error count is incremented.  If collisions occured while
  1646. * sending the packet, then the number of collisions is added to the collision
  1647. * counter.  If there are more packets on the transmit queue, then the next
  1648. * packet is started at task time by calling csStartOutput() via netTask().
  1649. *
  1650. * RETURNS: N/A
  1651. */
  1653. LOCAL void csIntrTx
  1654.     (
  1655.     CS_SOFTC *pCs,
  1656.     USHORT txEvent
  1657.     )
  1658.     {
  1659.     struct ifnet *pIf = &pCs->arpCom.ac_if;
  1661.     /* If there were any errors transmitting this frame */
  1662.     if (txEvent & (CS_TX_EVENT_LOSS_CRS | CS_TX_EVENT_SQE_ERR 
  1663. | CS_TX_EVENT_OUT_WIN | CS_TX_EVENT_JABBER
  1664. | CS_TX_EVENT_16_COLL))
  1665. {
  1666. /* Increment the output error count */
  1667. pIf->if_oerrors++;
  1669. /* If debugging is enabled then log error messages */
  1670. if (pIf->if_flags & IFF_DEBUG)
  1671.     {
  1672.     if (txEvent & CS_TX_EVENT_LOSS_CRS)
  1673. csError (pCs, "Loss of carrier");
  1674.     if (txEvent & CS_TX_EVENT_SQE_ERR)
  1675. csError (pCs, "SQE error");
  1676.     if (txEvent & CS_TX_EVENT_OUT_WIN)
  1677. csError (pCs, "Out-of-window collision");
  1678.     if (txEvent & CS_TX_EVENT_JABBER)
  1679. csError (pCs, "Jabber");
  1680.     if (txEvent & CS_TX_EVENT_16_COLL)
  1681. csError (pCs, "16 collisions");
  1682.     }
  1683. }
  1685.     /* Add the number of collisions for this frame */
  1687.     if (txEvent & CS_TX_EVENT_16_COLL)
  1688. pIf->if_collisions += 16;
  1689.     else
  1690. pIf->if_collisions += ((txEvent & CS_TX_EVENT_COLL_MASK) >> 11);
  1692.     /* Transmission is no longer in progress */
  1694.     pCs->txInProgress = FALSE;
  1696.     /* If there is more to transmit
  1697.      *   Start the next transmission at task time
  1698.      */
  1699.     if (pIf->if_snd.ifq_head != NULL)
  1700. {
  1701. #ifdef BSD43_DRIVER
  1702. netJobAdd ((FUNCPTR)csStartOutput, pIf->if_unit, 0, 0, 0, 0);
  1703. #else /* BSD43_DRIVER */
  1704. netJobAdd ((FUNCPTR)csStartOutput, (int)pCs, 0, 0, 0, 0);
  1705. #endif /* BSD43_DRIVER */
  1706. }
  1707.     }
  1709. /*******************************************************************************
  1710. *
  1711. * csIntrRx - interrupt handler for the reception
  1712. *
  1713. * This routine is called whenever a packet is received at the chip.  If the
  1714. * packet is received with errors, then the input error count is incremented.
  1715. * If the packet is received OK, then the data is copied to an internal receive
  1716. * buffer and the csRxProcess() routine is called via netTask() to
  1717. * process the received packet at task time.
  1718. *
  1719. * RETURNS: N/A
  1720. */
  1722. LOCAL void csIntrRx
  1723.     (
  1724.     CS_SOFTC *pCs,
  1725.     USHORT rxEvent
  1726.     )
  1727.     {
  1728.     struct ifnet *pIf = &pCs->arpCom.ac_if;
  1729.     CS_RXBUF *pRxBuff;
  1731.     /* If the frame was not received OK */
  1732.     if (!(rxEvent & CS_RX_EVENT_RX_OK))
  1733.         {
  1734.         /* Increment the input error count */
  1735.         pIf->if_ierrors++;
  1737.         /* If debugging is enabled then log error messages */
  1738.         if (pIf->if_flags & IFF_DEBUG)
  1739.     {
  1740.     /* If an error bit is set */
  1741.     if (rxEvent != CS_REG_NUM_RX_EVENT)
  1742.         {
  1743.         if (rxEvent & CS_RX_EVENT_RUNT)
  1744.     csError (pCs, "Runt");
  1745.         if (rxEvent & CS_RX_EVENT_X_DATA)
  1746.     csError (pCs, "Extra data");
  1747.         if (rxEvent & CS_RX_EVENT_CRC_ERR)
  1748.     {
  1749.     if (rxEvent & CS_RX_EVENT_DRIBBLE)
  1750.         csError (pCs, "Alignment error");
  1751.     else
  1752.         csError (pCs, "CRC Error");
  1753.     }
  1754.         else if (rxEvent & CS_RX_EVENT_DRIBBLE)
  1755.     csError (pCs, "Dribble bits");
  1757.         /* Must read the length of all received frames */
  1758.         csPacketPageR (pCs, CS_PKTPG_RX_LENGTH);
  1760.         /* Skip the received frame */
  1761.         csPacketPageW (pCs, CS_PKTPG_RX_CFG,
  1762.        csPacketPageR (pCs,CS_PKTPG_RX_CFG)
  1763.     | CS_RX_CFG_SKIP);
  1764.         }
  1765.     else 
  1766.         csError (pCs, "Implied skip");
  1767.     }
  1768. return;
  1769. }
  1771.     /* Get a receive frame buffer */
  1772.     pRxBuff = csRxBuffAlloc (pCs);
  1773.     if (pRxBuff == NULL)  /* If no buffer available */
  1774. {
  1775. /* Increment the input error count */
  1776. pIf->if_ierrors++;
  1777. csError (pCs, "No receive buffer available");
  1778. /* Must read the length of all received frames */
  1779. csPacketPageR (pCs, CS_PKTPG_RX_LENGTH);
  1780. /* Skip the received frame */
  1781. csPacketPageW (pCs, CS_PKTPG_RX_CFG,
  1782.        csPacketPageR (pCs, CS_PKTPG_RX_CFG) | CS_RX_CFG_SKIP);
  1783. return;
  1784. }
  1786.     /* Copy the received frame from the chip to the buffer */
  1787.     csRxFrameCopy (pCs, pRxBuff);
  1789.     /* Process the received frame at task time */
  1790.     netJobAdd ((FUNCPTR)csRxProcess, (int)pCs, (int)pRxBuff, 0, 0, 0);
  1791.     }
  1793. /*******************************************************************************
  1794. *
  1795. * csRxFrameCopy - copies a received frame from the chip to a receive buffer
  1796. *
  1797. * This routine copies a received frame from the chip to a receive buffer.
  1798. *
  1799. * RETURNS: N/A
  1800. */
  1802. LOCAL void csRxFrameCopy
  1803.     (
  1804.     CS_SOFTC *pCs,
  1805.     CS_RXBUF *pRxBuff
  1806.     )
  1807.     {
  1808.     FAST USHORT *pFrame = pCs->pPacketPage + (CS_PKTPG_RX_LENGTH/2);
  1809.     FAST int rxDataPort = pCs->ioAddr + CS_PORT_RXTX_DATA;
  1810.     FAST USHORT *pBuff;
  1811.     FAST USHORT *pBuffLimit;
  1812.     USHORT temp;
  1814.     /* Get the length of the received frame */
  1815.     if (pCs->inMemoryMode)
  1816. {
  1817. pRxBuff->length = *pFrame++;
  1818. }
  1819.     else  /* In IO mode */
  1820. {
  1821. CS_IN_WORD (rxDataPort, &temp);  /* Discard RxStatus */
  1822. CS_IN_WORD (rxDataPort, &pRxBuff->length);
  1823. }
  1825.     /* Setup pointers to the buffer for copying */
  1826.     pBuff = (USHORT *)pRxBuff->data;
  1827.     pBuffLimit = pBuff + ((pRxBuff->length + 1)/2);
  1829.     /* Copy the frame from the chip to the buffer */
  1830.     if (pCs->inMemoryMode)
  1831. while (pBuff < pBuffLimit)
  1832.     *pBuff++ = *pFrame++;
  1833.     else
  1834. while (pBuff < pBuffLimit)
  1835.     {
  1836.     CS_IN_WORD (rxDataPort, pBuff);
  1837.     pBuff++;
  1838.     }
  1839.     }
  1841. /*******************************************************************************
  1842. *
  1843. * csRxProcess - processes a received packet in task level
  1844. *
  1845. * This routine processes a received packet.  The received packet was copied to
  1846. * a receive buffer at interrupt time and this routine processses the receive
  1847. * buffer at task time via netTask().
  1848. *  
  1849. * If a recieve hook routine is specified, then the packet is given to the
  1850. * hook routine for processing.  If the received packet does not use trailers
  1851. * and the packet is large, then a cluster mbuf is built that points to the
  1852. * receive buffer directly.  If a cluster mbuf is not used, then the packet
  1853. * is copied to an mbuf chain.  The cluster mbuf or mbuf chain is then passed
  1854. * up to the protocol stack.
  1855. *
  1856. * RETURNS: N/A
  1857. */
  1859. LOCAL void csRxProcess
  1860.     (
  1861.     CS_SOFTC *pCs,
  1862.     CS_RXBUF *pRxBuff
  1863.     )
  1864.     {
  1865.     struct ifnet *pIf = &pCs->arpCom.ac_if;
  1866.     struct mbuf *pMbufChain;
  1867.     ETH_HDR *pEtherHeader;
  1868.     UCHAR *pData;
  1869.     int dataLength;
  1870. #ifdef BSD43_DRIVER
  1871.     int trailerOffset;
  1872.     USHORT type;
  1873. #endif /* BSD43_DRIVER */
  1875.     /* If a hook routine is specified */
  1876.     if (etherInputHookRtn != NULL)
  1877. {
  1878. /* Call the hook routine */
  1879. if ((*etherInputHookRtn) (pIf, pRxBuff->data, pRxBuff->length) != 0)
  1880.     {
  1881.     /* The hook routine has handled the received frame */
  1882.     csRxBuffFree (pCs, pRxBuff);
  1883.     return;
  1884.     }
  1885. }
  1887.     /* Setup working variables */
  1888.     pEtherHeader = (ETH_HDR *)pRxBuff->data;
  1889.     pData = &pRxBuff->data[SIZEOF_ETHERHEADER];
  1890.     dataLength = pRxBuff->length - SIZEOF_ETHERHEADER;
  1892. #ifdef BSD43_DRIVER
  1893.     /* Check if the received frame uses trailers */
  1894.     check_trailer (pEtherHeader, pData, &dataLength, &trailerOffset, pIf);
  1896.     /* Save the type because build_cluster() will overwrite it */
  1897.     type = pEtherHeader->ether_type;
  1899.     /* If trailers are not used and there is enough data for clustering */
  1900.     if ((trailerOffset == 0) && USE_CLUSTER (dataLength))
  1901. #else /* BSD43_DRIVER */
  1902.     /* If trailers are not used and there is enough data for clustering */
  1903.     if (USE_CLUSTER (dataLength))
  1904. #endif /* BSD43_DRIVER */
  1905. {
  1906. /* Build a cluster mbuf that points to my receive buffer */
  1907. pMbufChain = build_cluster (pData, dataLength, pIf, CS_MC_LOANED,
  1908.  &pRxBuff->refCount, (FUNCPTR)csRxBuffFree , (int)pCs, (int)pRxBuff, 0);
  1909. if (pMbufChain != NULL)
  1910.     {
  1911.     pRxBuff->status = CS_RXBUF_LOANED;
  1912.     pCs->loanCount++;
  1913.     }
  1914. else
  1915.     csRxBuffFree (pCs, pRxBuff);
  1916. }
  1917.     else  /* Can not do clustering */
  1918. {
  1919. /* Copy the received data to a chain of mbufs */
  1920. #ifdef BSD43_DRIVER
  1921. pMbufChain = copy_to_mbufs (pData, dataLength, trailerOffset, pIf);
  1922. #else /* BSD43_DRIVER */
  1923. pMbufChain = copy_to_mbufs (pData, dataLength, 0, pIf);
  1924. #endif /* BSD43_DRIVER */
  1925. csRxBuffFree (pCs, pRxBuff);
  1926. }
  1928.     /* If could not get an mbuf */
  1929.     if (pMbufChain == NULL)
  1930. {
  1931. pIf->if_ierrors++;
  1932. csError (pCs, "No receive mbuf available");
  1933. return;
  1934. }
  1936.     /* Pass the mbuf chain up to the protocol stack */
  1937. #ifdef BSD43_DRIVER
  1938.     do_protocol_with_type (type, pMbufChain, &pCs->arpCom, dataLength);
  1939. #else /* BSD43_DRIVER */
  1940.     do_protocol (pEtherHeader, pMbufChain, &pCs->arpCom, dataLength);
  1941. #endif /* BSD43_DRIVER */
  1943.     /* Another packet successfully received! */
  1944.     pIf->if_ipackets++;
  1945.     }
  1947. /*******************************************************************************
  1948. *
  1949. * csRxBuffInit - initializes the receive buffers
  1950. *
  1951. * This routine initializes the network interface driver's collection of
  1952. * receive buffers.  The receive buffers are allocated from system memory
  1953. * and linked together in a linked list of free receive buffers.
  1954. *
  1955. * RETURNS: OK or ERROR
  1956. */
  1958. LOCAL STATUS csRxBuffInit
  1959.     (
  1960.     CS_SOFTC *pCs
  1961.     )
  1962.     {
  1963.     CS_RXBUF *pRxBuff;
  1964.     CS_RXBUF *pRxLast;
  1966.     /* Allocate the receive frame buffers */
  1967.     pCs->pFreeRxBuff = (CS_RXBUF *)malloc (sizeof(CS_RXBUF) * CS_RXBUFCOUNT);
  1968.     if (pCs->pFreeRxBuff == NULL)
  1969. return (ERROR);
  1971.     /* Link all the receive frame buffers together on the free list */
  1972.     pRxLast = pCs->pFreeRxBuff + CS_RXBUFCOUNT - 1;
  1973.     for (pRxBuff=pCs->pFreeRxBuff; pRxBuff<pRxLast; pRxBuff++)
  1974. {
  1975. pRxBuff->pNext  = pRxBuff + 1;
  1976. pRxBuff->status = CS_RXBUF_FREE;
  1977. }
  1978.     pRxLast->pNext  = NULL;
  1979.     pRxLast->status = CS_RXBUF_FREE;
  1981.     return (OK);
  1982.     }
  1984. /*******************************************************************************
  1985. *
  1986. * csRxBuffAlloc - removes a receive buffer from the free receive buffer list
  1987. *
  1988. * This routine removes a receive buffer from the free receive buffer list.
  1989. *
  1990. * RETURNS: pointer of the buffer
  1991. */
  1993. LOCAL CS_RXBUF *csRxBuffAlloc
  1994.     (
  1995.     CS_SOFTC *pCs
  1996.     )
  1997.     {
  1998.     CS_RXBUF *pRxBuff;
  2000.     if (pCs->pFreeRxBuff == NULL)
  2001. return (NULL);
  2003.     /* Remove a buffer from the free list */
  2004.     pRxBuff = pCs->pFreeRxBuff;
  2005.     pCs->pFreeRxBuff = pRxBuff->pNext;
  2006.     pRxBuff->pNext = NULL;
  2008.     /* Init the reference count to zero */
  2009.     pRxBuff->refCount = 0;
  2011.     /* The buffer is now allocated */
  2012.     pRxBuff->status = CS_RXBUF_ALLOCATED;
  2014.     /* Increment number of receive buffers currently in use */
  2015.     pCs->rxDepth++;
  2016.     if (pCs->rxDepth > pCs->maxRxDepth)
  2017. pCs->maxRxDepth = pCs->rxDepth;
  2019.     return (pRxBuff);
  2020.     }
  2022. /*******************************************************************************
  2023. *
  2024. * csRxBuffFree - returns an allocated receive buffer back to the free list
  2025. *
  2026. * This routine returns an allocated receive buffer back to the free list.
  2027. *
  2028. * RETURNS: N/A
  2029. */
  2031. LOCAL void csRxBuffFree
  2032.     (
  2033.     CS_SOFTC *pCs,
  2034.     CS_RXBUF *pRxBuff
  2035.     )
  2036.     {
  2037.     int intState = intLock(); /* INT LOCK (csRxBuffAlloc() won't interrupt) */
  2039.     /* Put the buffer at the head of the free list */
  2040.     pRxBuff->pNext = pCs->pFreeRxBuff;
  2041.     pCs->pFreeRxBuff = pRxBuff;
  2043.     /* The buffer is now free */
  2044.     pRxBuff->status = CS_RXBUF_FREE;
  2046.     /* Decrement the outstanding receive depth */
  2047.     pCs->rxDepth--;
  2049.     /* Re-enable interrupts at the CPU */
  2050.     intUnlock (intState); /* INT UNLOCK */
  2051.     }
  2053. /*******************************************************************************
  2054. *
  2055. * csPacketPageR - reads a word from the PacketPage
  2056. *
  2057. * This routine reads a word from the PacketPage at the specified offset.
  2058. *
  2059. * RETURNS: a word in the offset
  2060. */
  2062. LOCAL USHORT csPacketPageR
  2063.     (
  2064.     CS_SOFTC *pCs,
  2065.     USHORT offset
  2066.     )
  2067.     {
  2068.     if (pCs->inMemoryMode)
  2069. {
  2070. return (*((pCs->pPacketPage) + (offset/2)));
  2071. }
  2072.     else  /* In IO mode */
  2073. {
  2074. USHORT temp;
  2075. CS_OUT_WORD (pCs->ioAddr + CS_PORT_PKTPG_PTR, offset);
  2076. CS_IN_WORD (pCs->ioAddr + CS_PORT_PKTPG_DATA, &temp);
  2077. return (temp);
  2078. }
  2079.     }
  2081. /*******************************************************************************
  2082. *
  2083. * csPacketPageW - writes a value to the PacketPage
  2084. *
  2085. * This routine writes a value to the PacketPage at the specified offset.
  2086. *
  2087. * RETURNS: N/A
  2088. */
  2090. LOCAL void csPacketPageW
  2091.     (
  2092.     CS_SOFTC *pCs,
  2093.     USHORT offset,
  2094.     USHORT value
  2095.     )
  2096.     {
  2097.     if (pCs->inMemoryMode)
  2098. {
  2099. *((pCs->pPacketPage) + (offset/2)) = value;
  2100. }
  2101.     else  /* In IO mode */
  2102. {
  2103. CS_OUT_WORD (pCs->ioAddr + CS_PORT_PKTPG_PTR, offset);
  2104. CS_OUT_WORD (pCs->ioAddr + CS_PORT_PKTPG_DATA, value);
  2105. }
  2106.     }
  2108. /*******************************************************************************
  2109. *
  2110. * csError - logs a message to the logging task
  2111. *
  2112. * This routine logs a message to the logging task if debugging is enabled.
  2113. *
  2114. * RETURNS: N/A
  2115. */
  2117. LOCAL void csError
  2118.     (
  2119.     CS_SOFTC *pCs,
  2120.     char *pString
  2121.     )
  2122.     {
  2123.     /* If debugging is enabled */
  2124.     if (pCs->arpCom.ac_if.if_flags & IFF_DEBUG)
  2125. {
  2126. logMsg ("cs%d - %sn", pCs->arpCom.ac_if.if_unit, (int)pString, 
  2127. 0, 0, 0, 0);
  2128. }
  2129.     }
  2131. /*******************************************************************************
  2132. *
  2133. * csShow - shows statistics for the `cs' network interface
  2134. *
  2135. * This routine displays statistics about the `cs' Ethernet network interface.
  2136. * It has two parameters:
  2137. * .iP <unit>
  2138. * interface unit; should be 0.
  2139. * .iP <zap>
  2140. * if 1, all collected statistics are cleared to zero.
  2141. * .LP
  2142. *
  2143. * RETURNS: N/A
  2144. */
  2146. void csShow
  2147.     (
  2148.     int unit, /* interface unit */
  2149.     BOOL zap /* zero totals */
  2150.     )
  2151.     {
  2152.     FAST CS_SOFTC *pCs = &cs_softc[unit];
  2153.     struct ifnet *pIf  = &pCs->arpCom.ac_if;
  2155.     if (unit >= MAXUNITS)
  2156. {
  2157. printf ("cs%d - Invalid unit numbern", unit);
  2158. return;
  2159. }
  2161.     if (zap)
  2162. {
  2163. /* Reset all the statistics to zero */
  2164. pIf->if_ipackets   = 0;
  2165. pIf->if_opackets   = 0;
  2166. pIf->if_ierrors    = 0;
  2167. pIf->if_oerrors    = 0;
  2168. pIf->if_collisions = 0;
  2170. /* Reset counters to zero */
  2171. pCs->rxDepth    = 0;
  2172. pCs->maxRxDepth = 0;
  2173. pCs->maxTxDepth = 0;
  2174. pCs->loanCount  = 0;
  2175. }
  2177.     printf ("n");
  2178.     printf ("Show cs%d: ", unit);
  2179.     printf ("Crystal Semiconductor CS8900 Network Interface Drivern");
  2180.     printf ("I/O Address      : 0x%Xn", pCs->ioAddr);
  2181.     printf ("Interrupt Level  : %dn",   pCs->intLevel);
  2182.     printf ("Interrupt Vector : %dn",   pCs->intVector);
  2184.     printf ("Access Mode      : ");
  2185.     if (pCs->inMemoryMode)
  2186. {
  2187. printf ("Memory Moden");
  2188. printf ("Memory Address   : 0x%Xn", (int)pCs->pPacketPage);
  2189. }
  2190.     else 
  2191. printf ("I/O Moden");
  2193.     printf ("Media Type       : ");
  2194.     switch (pCs->mediaType)
  2195. {
  2196. case CS_MEDIA_AUI:
  2197.     printf ("AUIn");
  2198.     break;
  2199. case CS_MEDIA_10BASE2:
  2200.     printf ("10Base2n");
  2201.     break;
  2202. case CS_MEDIA_10BASET:
  2203.     if (pCs->configFlags & CS_CFGFLG_FDX)
  2204. printf ("10BaseT, FDXn");
  2205.     else
  2206. printf ("10BaseTn");
  2207.     break;
  2208. default:
  2209.     printf ("Unknownn");
  2210.     break;
  2211. }
  2213.     printf ("Interface Flags  : ");
  2214.     if (pIf->if_flags & IFF_UP)
  2215. printf ("UP");
  2216.     else 
  2217. printf ("DOWN");
  2218.     if (pIf->if_flags & IFF_RUNNING)
  2219. printf (", RUNNING");
  2220.     if (pIf->if_flags & IFF_BROADCAST)
  2221. printf (", BROADCAST");
  2222.     if (pIf->if_flags & IFF_DEBUG)
  2223. printf (", DEBUG");
  2224.     if (pIf->if_flags & IFF_LOOPBACK)
  2225. printf (", LOOPBACK");
  2226.     if (pIf->if_flags & IFF_POINTOPOINT)
  2227. printf (", POINTOPOINT");
  2228.     if (pIf->if_flags & IFF_NOTRAILERS)
  2229. printf (", NOTRAILERS");
  2230.     if (pIf->if_flags & IFF_NOARP)
  2231. printf (", NOARP");
  2232.     if (pIf->if_flags & IFF_PROMISC)
  2233. printf (", PROMISC");
  2234.     if (pIf->if_flags & IFF_ALLMULTI)
  2235. printf (", ALLMULTI");
  2236.     printf ("n");
  2238.     printf ("Input Packets    : %dn", pIf->if_ipackets);
  2239.     printf ("Output Packets   : %dn", pIf->if_opackets);
  2240.     printf ("Input Errors     : %dn", pIf->if_ierrors );
  2241.     printf ("Output Errors    : %dn", pIf->if_oerrors );
  2242.     printf ("Collisions       : %dn", pIf->if_collisions);
  2243.     printf ("Current Tx Depth : %dn", pIf->if_snd.ifq_len);
  2244.     printf ("Current Rx Depth : %dn", pCs->rxDepth);
  2245.     printf ("Maximum Tx Depth : %dn", pCs->maxTxDepth);
  2246.     printf ("Maximum Rx Depth : %dn", pCs->maxRxDepth);
  2247.     printf ("Loan Count       : %dn", pCs->loanCount);
  2249.     printf ("n");
  2250.     }