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

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

VxWorks

开发平台：

C/C++

if_seeq.c：源码内容
  1. /* if_seeq.c - Seeq 8005 Ethernet network interface driver */
  3. /* Copyright 1984-1996 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01a,21apr96,mem  written, based on other drivers.
  10. */
  12. /*
  13. This module implements the Seeq 8005 Ethernet network interface
  14. driver.
  16. This driver was originally developed for the Motorola IDP ethernet
  17. card.
  19. At this time, the driver makes the following assumptions:
  20.   - A 16-bit path to the SEEQ chip is available.
  22. This driver is designed to be moderately generic, operating unmodified
  23. across the range of architectures and targets supported by VxWorks.
  24. To achieve this, the driver must be given several target-specific
  25. parameters, and some external support routines must be provided.
  26. These parameters, and the mechanisms used to communicate them to the
  27. driver, are detailed below.  If any of the assumptions stated below
  28. are not true for your particular hardware, this driver will probably
  29. not function correctly with it.
  31. BOARD LAYOUT
  32. We have yet to see documentation on the jumpers, so don't change them.
  34. EXTERNAL INTERFACE
  35. This driver provides the standard external interface with the
  36. following exceptions.  All initialization is performed within the
  37. attach routine; there is no separate initialization routine.
  38. Therefore, in the global interface structure, the function pointer to
  39. the initialization routine is NULL.
  41. The only user-callable routine is seeqattach(), which publishes the
  42. `seeq' interface and initializes the driver and device.
  44. TARGET-SPECIFIC PARAMETERS
  45. .iP "base address of device registers"
  46. This parameter is passed to the driver by seeqattach().  It indicates
  47. to the driver where to find the device registers.
  49. .iP "interrupt vector"
  50. This parameter is passed to the driver by seeqattach().
  52. .iP "interrupt level"
  53. This parameter is passed to the driver by seeqattach().
  55. .iP "Ethernet address"
  56. This parameter is obtained directly from a global memory location.
  58. During initialization, the driver needs to know the Ethernet address for
  59. the SEEQ device.  The driver assumes that this address is available in
  60. a global, six-byte character array, seeqEnetAddr[].  This array is
  61. typically created and stuffed by the BSP code.
  62. .LP
  64. SYSTEM RESOURCE USAGE
  65. When implemented, this driver requires the following system resources:
  67.     - one interrupt vector
  68.     - one watchdog timer
  69.     - 12 bytes in the initialized data section (data)
  70.     - 4264 bytes in the uninitialized data section (BSS)
  71.     - 4096 bytes of allocated buffer space.
  73. The above data and BSS requirements are for the MCF5200 architecture
  74. and may vary for other architectures.  Code size (text) varies greatly
  75. between architectures and is therefore not quoted here.
  77. SEE ALSO: ifLib, 
  78. .I "SEEQ 8005 Advanced Ethernet Data Link Controller"
  79. */
  81. /* includes */
  83. #include "vxWorks.h"
  84. #include "stdlib.h"
  85. #include "taskLib.h"
  86. #include "logLib.h"
  87. #include "intLib.h"
  88. #include "netLib.h"
  89. #include "stdio.h"
  90. #include "stdlib.h"
  91. #include "sysLib.h"
  92. #include "wdLib.h"
  93. #include "iv.h"
  94. #include "memLib.h"
  95. #include "sys/ioctl.h"
  96. #include "etherLib.h"
  98. #ifndef DOC             /* don't include when building documentation */
  99. #include "net/mbuf.h"
  100. #endif  /* DOC */
  102. #include "net/protosw.h"
  103. #include "sys/socket.h"
  104. #include "errno.h"
  105. #include "net/if.h"
  106. #include "net/route.h"
  107. #include "netinet/in.h"
  108. #include "netinet/in_systm.h"
  109. #include "netinet/in_var.h"
  110. #include "netinet/ip.h"
  111. #include "netinet/if_ether.h"
  112. #include "net/if_subr.h"
  113. #include "semLib.h"
  114. /*HELP#include "drv/netif/if_seeq.h"            /* device description header */
  115. #include "if_seeq.h"            /* device description header */
  117. /* defines */
  119. #define DEBUG
  121. #define MAX_UNITS 1 /* maximum units supported */
  122. #define SEEQ_TX_OUTSTANDING 1 /* seeqTransmit outstanding */
  123. #define SEEQ_RX_OUTSTANDING 2 /* seeqReceive outstanding */
  125. /* Offset to LSB */
  126. #if _BYTE_ORDER == _BIG_ENDIAN
  127. #define SEEQ_LSB_OFFSET 1 /* offset to LSB */
  128. #define SEEQ_MSB_SHIFT 8 /* shift to MSB */
  129. #define SEEQ_CFG2_BSWAP  SEEQ_CONF2_BYTE_SWAP /* config2 bswap bit */
  130. #else /* _BYTE_ORDER == _BIG_ENDIAN */
  131. #define SEEQ_LSB_OFFSET 0 /* offset to LSB */
  132. #define SEEQ_MSB_SHIFT 0 /* shift to MSB */
  133. #define SEEQ_CFG2_BSWAP  0 /* config2 bswap bit */
  134. #endif /* _BYTE_ORDER == _BIG_ENDIAN */
  136. /* How much free space is in the TX buffer */
  137. #define TX_SPACE(pDrv) 
  138. (((pDrv)->txNext < (pDrv)->txCurr) 
  139.  ? ((pDrv)->txCurr - (pDrv)->txNext) 
  140.  : ((((pDrv)->tea + 1) << 8) - ((pDrv)->txNext - (pDrv)->txCurr)))
  142. /* typedefs */
  144. typedef struct mbuf MBUF;
  145. typedef struct arpcom IDR;                  /* Interface Data Record wrapper */
  146. typedef struct ifnet IFNET;                 /* real Interface Data Record */
  147. typedef struct sockaddr SOCK;
  148. typedef struct ex_msg EX_MSG;               /* an EXOS message */
  150. /* The definition of the driver control structure */
  152. typedef struct drv_ctrl /* DRV_CTRL */
  153.     {
  154.     IDR idr; /* Interface Data Record */
  156.     int unit; /* unit # */
  157.     BOOL attached; /* indicates unit is attached */
  158.     int flags; /* misc flags */
  159.     int inum; /* interrupt number */
  160.     int ilevel; /* interrupt level */
  161.     SEEQ_DEVICE *devAdrs; /* device structure address */
  163.     WDOG_ID watchDog; /* watchDog for waiting for chip */
  164.     BOOL expired; /* flag watchDog has expired */
  166.     USHORT rea; /* receive end area */
  167.     UINT rxNext; /* local buffer pointer for next packet */
  168.     UCHAR *rxBuf; /* receive buffer */
  170.     int txCount; /* # packets waiting to transmit */
  171.     USHORT tea; /* transmit end area */
  172.     UINT txEnd; /* end of tx area */
  173.     UINT txCurr; /* end of current xmit packet */
  174.     UINT txNext; /* local buffer pointer for next packet */
  175.     UCHAR *txBuf; /* transmit buffer */
  176.     int txLow; /* count of TX low reports */
  177.     } DRV_CTRL;
  179. #define DRV_CTRL_SIZ    sizeof(DRV_CTRL)
  181. /* globals */
  183. IMPORT UCHAR seeqEnetAddr []; /* Ethernet address to load */
  185. #ifdef DEBUG
  186. BOOL seeqDebug = 0;
  187. #endif
  189. int seeqIntCnt = 0;
  190. int seeqTimeoutCnt = 0;
  192. /* locals */
  194. LOCAL DRV_CTRL  drvCtrl [MAX_UNITS];
  196. /* forward declarations */
  198. IMPORT void ether_attach ();
  200. void seeqChipReset (int unit);
  201. void seeqRxReset (int unit);
  202. void seeqTxReset (int unit);
  203. void seeqInt (int unit);
  205. LOCAL void seeqReset (int unit);
  206. LOCAL void seeqReceive (int unit);
  207. LOCAL void seeqTransmit (int unit);
  208. LOCAL void seeqStart (int unit);
  210. LOCAL int seeqOutput (IDR *ifp, MBUF *m0, SOCK *dst);
  211. LOCAL int seeqIoctl (IDR *ifp, int cmd, caddr_t data);
  212. LOCAL void seeqTimeout (DRV_CTRL *pDrvCtrl);
  213. LOCAL STATUS seeqFlushFIFO (DRV_CTRL *pDrvCtrl);
  214. LOCAL STATUS seeqSetDMARead (DRV_CTRL *pDrvCtrl, USHORT addr);
  215. LOCAL STATUS seeqSetDMAWrite (DRV_CTRL *pDrvCtrl, USHORT addr);
  217. #ifndef SEEQ_READ
  218. #define SEEQ_READ(reg) 
  219. *(USHORT *)(reg)
  220. #endif
  222. #ifndef SEEQ_READ_BYTE
  223. #define SEEQ_READ_BYTE(reg) 
  224. *((volatile UCHAR *)(reg))
  225. #endif
  227. #ifndef SEEQ_WRITE
  228. #define SEEQ_WRITE(reg,data) 
  229. *(USHORT *)(reg) = (USHORT)data
  230. #endif
  232. #ifndef SEEQ_WRITE_BYTE
  233. #define SEEQ_WRITE_BYTE(reg,data) 
  234. *(volatile UCHAR *)(reg) = (UCHAR)data
  235. #endif
  237. /******************************************************************************
  238. *
  239. * seeqattach - publish the `seeq' network interface and initialize
  240. * the driver and device
  241. *
  242. * This routine publishes the `seeq' interface by filling in a network
  243. * interface record and adding this record to the system list.  This
  244. * routine also initializes the driver and the device to the operational
  245. * state.
  246. *
  247. * RETURNS: OK or ERROR.
  248. */
  250. STATUS seeqattach
  251.     (
  252.     int       unit, /* unit number */
  253.     char     *devAdrs, /* SEEQ I/O address */
  254.     int       inum, /* interrupt number */
  255.     int       ilevel /* interrupt level */
  256.     )
  257.     {
  258.     DRV_CTRL *pDrvCtrl;
  260.     /* Sanity check the unit number */
  261.     if (unit < 0 || unit >= MAX_UNITS)
  262. return (ERROR);
  264.     /* Ensure single invocation per system life */
  265.     pDrvCtrl = & drvCtrl [unit];
  266.     if (pDrvCtrl->attached)
  267. return (OK);
  269.     if ((pDrvCtrl->watchDog = wdCreate()) == NULL)
  270. return (ERROR);
  271.     if (!(pDrvCtrl->txBuf = (UCHAR *) malloc (2048)))
  272. {
  273. wdDelete (pDrvCtrl->watchDog);
  274. return (ERROR);
  275. }
  276.     if (!(pDrvCtrl->rxBuf = (UCHAR *) malloc (2048)))
  277. {
  278. wdDelete (pDrvCtrl->watchDog);
  279. free (pDrvCtrl->rxBuf);
  280. return (ERROR);
  281. }
  283.     /* Publish the interface data record */
  284.     ether_attach (&pDrvCtrl->idr.ac_if, unit, "seeq",
  285.   (FUNCPTR) NULL, (FUNCPTR) seeqIoctl,
  286.   (FUNCPTR) seeqOutput, (FUNCPTR) seeqReset);
  288.     /* Save some values */
  289.     pDrvCtrl->inum  = inum;  /* interrupt vector */
  290.     pDrvCtrl->ilevel  = ilevel;  /* interrupt level */
  291.     pDrvCtrl->devAdrs  = (SEEQ_DEVICE *)devAdrs; /* SEEQ I/O address */
  293.     /* Obtain our Ethernet address and save it */
  294.     bcopy ((char *) seeqEnetAddr, (char *) pDrvCtrl->idr.ac_enaddr, 6);
  296.     if (intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC(inum), seeqInt, unit) == ERROR)
  297. return (ERROR);
  299.     /* Reset the device */
  300.     seeqChipReset (pDrvCtrl->unit);
  302.     /* The interface is now up. */
  303.     pDrvCtrl->idr.ac_if.if_flags |= (IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);
  305.     /* Set our flag */
  306.     pDrvCtrl->attached = TRUE;
  308.     /*
  309.      * Enable the receiver, enable TX & RX interrupts,
  310.      * ack any pending interrupts.
  311.      */
  313.     SEEQ_WRITE (pDrvCtrl->devAdrs->pCmd,
  314. SEEQ_CMD_RX_ON  | SEEQ_CMD_RX_EN
  315. | SEEQ_CMD_TX_OFF | SEEQ_CMD_TX_EN
  316. | SEEQ_CMD_ALL_ACK);
  318.     return (OK);
  319.     }
  321. /******************************************************************************
  322. *
  323. * seeqTimeout - note that the watchdog timer has expired.
  324. *
  325. * NOMANUAL
  326. */
  327. LOCAL void seeqTimeout
  328.     (
  329.     DRV_CTRL  *pDrvCtrl
  330.     )
  331.     {
  332. #ifdef DEBUG
  333.     if (seeqDebug)
  334. logMsg ("seeqTimeout(%x)n", (int) pDrvCtrl, 0, 0, 0, 0, 0);
  335. #endif
  336.     ++seeqTimeoutCnt;
  337.     pDrvCtrl->expired = TRUE;
  338.     }
  340. /******************************************************************************
  341. *
  342. * seeqFlushFIFO - Wait for the seeq DMA FIFO to flush
  343. *
  344. * NOMANUAL
  345. */
  346. LOCAL STATUS seeqFlushFIFO
  347.     (
  348.     DRV_CTRL  *pDrvCtrl
  349.     )
  350.     {
  351.     SEEQ_DEVICE *pDev = pDrvCtrl->devAdrs;
  353.     pDrvCtrl->expired = FALSE;
  354.     wdStart (pDrvCtrl->watchDog, 2 * sysClkRateGet(),
  355.      (FUNCPTR) seeqTimeout, (int) pDrvCtrl);
  357.     /* flush the FIFO */
  359.     while (!(SEEQ_READ(pDev->pStat) & SEEQ_STAT_FIFO_EMPTY)
  360.        && !pDrvCtrl->expired)
  361. taskDelay(1);
  363.     wdCancel (pDrvCtrl->watchDog);
  365.     if (pDrvCtrl->expired)
  366. return (ERROR);
  368.     return (OK);
  369.     }
  371. /******************************************************************************
  372. *
  373. * seeqSetDMARead - Setup the FIFO for reading
  374. *
  375. * NOMANUAL
  376. */
  377. LOCAL STATUS seeqSetDMARead
  378.     (
  379.     DRV_CTRL  *pDrvCtrl,
  380.     USHORT    addr
  381.     )
  382.     {
  383.     SEEQ_DEVICE *pDev = pDrvCtrl->devAdrs;
  385.     /* Point into local buffer memory */
  387.     SEEQ_WRITE (pDev->pCfg1, ((SEEQ_READ(pDev->pCfg1) & 0xfff0)
  388. | SEEQ_CONF1_LBUFFER));
  389.     
  390.     /* Wait for FIFO ready if in write direction */
  392.     if (!(SEEQ_READ(pDev->pCmd) & SEEQ_STAT_FIFO_DIR))
  393. if (seeqFlushFIFO (pDrvCtrl) != OK)
  394.     return (ERROR);
  396.     /* Set DMA address */
  398.     SEEQ_WRITE (pDev->pDma, addr);
  400.     /* Set direction to read */
  402.     SEEQ_WRITE (pDev->pCmd, ((SEEQ_READ(pDev->pStat) & SEEQ_STAT_CMD_MASK)
  403. | SEEQ_CMD_FIFO_READ) );
  405.     pDrvCtrl->expired = FALSE;
  406.     wdStart (pDrvCtrl->watchDog, 2 * sysClkRateGet(),
  407.      (FUNCPTR) seeqTimeout, (int) pDrvCtrl);
  409.     /* Wait for ready */
  411.     while (!(SEEQ_READ(pDev->pStat) & SEEQ_STAT_BUF_INT) && !pDrvCtrl->expired)
  412. taskDelay(1);
  414.     wdCancel (pDrvCtrl->watchDog);
  416.     /* ack buffer window interrupt */
  418.     SEEQ_WRITE (pDev->pCmd, ((SEEQ_READ(pDev->pStat) & SEEQ_STAT_CMD_MASK)
  419.     | SEEQ_CMD_BUF_ACK));
  421.     if (pDrvCtrl->expired)
  422. return (ERROR);
  424.     return (OK);
  425.     }
  427. /******************************************************************************
  428. *
  429. * seeqSetDMAWrite - Setup the FIFO for writing.
  430. *
  431. * NOMANUAL
  432. */
  433. LOCAL STATUS seeqSetDMAWrite
  434.     (
  435.     DRV_CTRL  *pDrvCtrl,
  436.     USHORT    addr
  437.     )
  438.     {
  439.     SEEQ_DEVICE *pDev = pDrvCtrl->devAdrs;
  441.     /* Point into local buffer memory */
  443.     SEEQ_WRITE (pDev->pCfg1,  ((SEEQ_READ(pDev->pCfg1) & 0xfff0)
  444. | SEEQ_CONF1_LBUFFER));
  445.     
  446.     
  447.     /* If already in write mode, wait until buffer writing is complete. */
  449.     if (SEEQ_READ(pDev->pCmd) & SEEQ_STAT_FIFO_DIR)
  450. {
  451. /* read direction */
  453. SEEQ_WRITE (pDev->pCmd, ((SEEQ_READ(pDev->pStat) & SEEQ_STAT_CMD_MASK)
  454.     | SEEQ_CMD_FIFO_WRITE) );
  455. }
  456.     else
  457. {
  458. /* write direction: wait until buffer writing is complete. */
  460. if (seeqFlushFIFO (pDrvCtrl) != OK)
  461.     return (ERROR);
  462. }
  464.     /* Set DMA address */
  466.     SEEQ_WRITE (pDev->pDma, addr);
  468.     return (OK);
  469.     }
  472. /******************************************************************************
  473. *
  474. * seeqChipReset - hardware reset of chip (stop it)
  475. *
  476. * NOMANUAL
  477. */
  479. void seeqChipReset
  480.     (
  481.     int unit
  482.     )
  483.     {
  484.     int i;
  485.     int oldLevel;
  486.     DRV_CTRL *pDrvCtrl = &drvCtrl[unit];
  487.     SEEQ_DEVICE *pDev;
  488.     volatile UCHAR *bwind;
  490.     /* Sanity check the unit number */
  492.     if (unit < 0 || unit >= MAX_UNITS)
  493. return;
  495. #ifdef DEBUG
  496.     if (seeqDebug)
  497. logMsg ("seeqChipReset(%d)n", unit, 0, 0, 0, 0, 0);
  498. #endif
  500.     pDrvCtrl->flags = 0;
  501.     pDrvCtrl->txCount = 0;
  503.     /* Reset the chip */
  505.     pDev = pDrvCtrl->devAdrs;
  506.     SEEQ_WRITE (pDev->pCfg1, 0);
  507.     SEEQ_WRITE (pDev->pCfg2, SEEQ_CONF2_RESET);
  509.     /* Delay at least 4us */
  511.     taskDelay (1);
  513.     /* Check status register for 0x5800 */
  515.     if (SEEQ_READ(pDev->pStat) != 0x5800)
  516. {
  517. logMsg ("seeq: probe at 0x%x failed, got 0x%04xn",
  518. (int) pDrvCtrl->devAdrs->pCmd, SEEQ_READ(pDev->pStat),
  519. 0, 0, 0, 0);
  520. }
  522.     /* lock interrupts */
  524.     oldLevel = intLock ();
  526.     /* Program the interrupt vector */
  528.     SEEQ_WRITE (pDev->pCfg1, ((SEEQ_READ(pDev->pCfg1) & 0xfff0)
  529. | SEEQ_CONF1_IVEC));
  530.     SEEQ_WRITE (pDev->pBwind, pDrvCtrl->inum);
  532.     /* Program station addr 0 w/ our e-net addr */
  534.     /* Turn Tx, Rx and DMA off, then ack any interrupts */
  536.     SEEQ_WRITE (pDev->pCmd, (SEEQ_CMD_FIFO_WRITE | SEEQ_CMD_ALL_OFF));
  537.     SEEQ_WRITE (pDev->pCmd, (SEEQ_CMD_FIFO_WRITE | SEEQ_CMD_ALL_OFF
  538.     | SEEQ_CMD_ALL_ACK));
  540.     /* Select address 0 */
  542.     SEEQ_WRITE (pDev->pCfg1, ((SEEQ_READ(pDev->pCfg1) & 0xfff0) | 0));
  544.     /* Get byte pointer to buffer window */
  545.     bwind = ((volatile UCHAR *) pDev->pBwind) + SEEQ_LSB_OFFSET;
  547.     /* Program the ethernet address */
  549.     for (i = 0; i < 6; ++i)
  550. SEEQ_WRITE_BYTE (bwind, ((UCHAR *)pDrvCtrl->idr.ac_enaddr)[i]);
  552.     /*
  553.      * Configure the local memory buffer to allow half of the
  554.      * space for transmit and half for receive.
  555.      */
  557.     pDrvCtrl->tea = 0x7f;
  558.     pDrvCtrl->rea = 0xffff;
  559.     pDrvCtrl->rxNext = (pDrvCtrl->tea + 1) << 8;
  560.     pDrvCtrl->txEnd = ((pDrvCtrl->tea + 1) << 8) - 1;
  561.     pDrvCtrl->txNext = 0;
  562.     pDrvCtrl->txCurr = 0;
  563.     pDrvCtrl->txLow = 0;
  565.     SEEQ_WRITE(pDev->pCfg1, (*pDev->pCfg1 & 0xfff0) | SEEQ_CONF1_TXEND);
  566.     SEEQ_WRITE(pDev->pBwind, pDrvCtrl->tea);
  567.     SEEQ_WRITE(pDev->pTxptr, pDrvCtrl->txNext);
  568.     SEEQ_WRITE(pDev->pRxptr, pDrvCtrl->rxNext);
  569.     SEEQ_WRITE(pDev->pRxend, pDrvCtrl->rea);
  571.     /*
  572.      * Config1 register setup:
  573.      *
  574.      * Specific Addr 0: Enabled
  575.      * Specific Addr 1: Disabled
  576.      * Specific Addr 2: Disabled
  577.      * Specific Addr 3: Disabled
  578.      * Specific Addr 4: Disabled
  579.      * Specific Addr 5: Disabled
  580.      * DMA Burst Length: 1 byte
  581.      * DMA Burst Interval: continuous
  582.      * MatchMode: Specific Addresses + Broadcast Addr
  583.      */
  585.     *pDev->pCfg1 = SEEQ_CONF1_ADDR0_EN
  586. | SEEQ_CONF1_RX_SPEC_BROAD
  587. | SEEQ_CONF1_DMA_BURST_INTERVAL_0;
  589.     /*
  590.      * Config2 register setup:
  591.      *
  592.      * select byte swapping, or not. Yes for BIG_ENDIAN
  593.      * AutoUpdate REA:  Disabled.
  594.      * Receive While Transmitting: Enabled.
  595.      * CRC ErrorEnable: CRC Error packets not accepted.
  596.      * Dribble Error Enable: Dribble packets not accepted.
  597.      * Pass Long/Short Enable: Neither long or short packets accepted.
  598.      * Preamble Select:  Std 802.3 64 bit preamble selected.
  599.      * RecCRC: CRC is stripped from incoming packets.
  600.      * XmitNoCRC: Outgoing packets have CRC appended.
  601.      * Loopback:  Loopback disabled.
  602.      * CTRLO: CTRL0 pin is low.
  603.      * RESET: Not asserted.
  604.      */
  606.     SEEQ_WRITE (pDev->pCfg2, SEEQ_CFG2_BSWAP);
  608.     /*
  609.      * Configure for RX and TX off and interrupts disabled.
  610.      * Ack any pending interrupts.
  611.      */
  613.     SEEQ_WRITE (pDev->pCmd, (SEEQ_CMD_RX_OFF | SEEQ_CMD_TX_OFF
  614.     | SEEQ_CMD_ALL_ACK));
  616.     intUnlock (oldLevel);
  617.     }
  619. /******************************************************************************
  620. *
  621. * seeqTxReset - Reset the TX
  622. *
  623. * NOMANUAL
  624. */
  626. void seeqTxReset
  627.     (
  628.     int unit
  629.     )
  630.     {
  631.     int oldLevel;
  632.     DRV_CTRL *pDrvCtrl = &drvCtrl[unit];
  633.     SEEQ_DEVICE *pDev;
  635.     /* Sanity check the unit number */
  637.     if (unit < 0 || unit >= MAX_UNITS)
  638. return;
  640. #ifdef DEBUG
  641.     if (seeqDebug)
  642. logMsg ("seeqTxReset(%d)n", unit, 0, 0, 0, 0, 0);
  643. #endif
  645.     pDev = pDrvCtrl->devAdrs;
  646.     oldLevel = intLock ();
  648.     /* Report an error */
  650.     ++pDrvCtrl->idr.ac_if.if_oerrors;
  652.     /* Recover - disable the TX */
  654.     SEEQ_WRITE (pDev->pCmd, ((SEEQ_READ(pDev->pStat) & SEEQ_STAT_CMD_MASK)
  655.     | SEEQ_CMD_TX_OFF));
  656.     pDrvCtrl->txNext = 0;
  657.     pDrvCtrl->txCurr = 0;
  658.     pDrvCtrl->txCount = 0;
  659.     SEEQ_WRITE (pDev->pTxptr, 0);
  661.     /* Ack the buffer and TX interrupts */
  663.     SEEQ_WRITE (pDev->pCmd, ((SEEQ_READ(pDev->pStat) & SEEQ_STAT_CMD_MASK)
  664.     | SEEQ_CMD_TX_ACK | SEEQ_CMD_BUF_ACK));
  666.     intUnlock (oldLevel);
  667.     }
  669. /******************************************************************************
  670. *
  671. * seeqRxReset - Reset the RX
  672. *
  673. * NOMANUAL
  674. */
  676. void seeqRxReset
  677.     (
  678.     int unit
  679.     )
  680.     {
  681.     int oldLevel;
  682.     DRV_CTRL *pDrvCtrl = &drvCtrl[unit];
  683.     SEEQ_DEVICE *pDev;
  685.     /* Sanity check the unit number */
  687.     if (unit < 0 || unit >= MAX_UNITS)
  688. return;
  690. #ifdef DEBUG
  691.     if (seeqDebug)
  692. logMsg ("seeqRxReset(%d)n", unit, 0, 0, 0, 0, 0);
  693. #endif
  695.     pDev = pDrvCtrl->devAdrs;
  696.     oldLevel = intLock ();
  698.     /* Report an error */
  700.     ++pDrvCtrl->idr.ac_if.if_ierrors;
  702.     /* Recover - disable the RX */
  704.     SEEQ_WRITE (pDev->pCmd, ((SEEQ_READ(pDev->pStat) & SEEQ_STAT_CMD_MASK)
  705.     | SEEQ_CMD_RX_OFF));
  706.     pDrvCtrl->rxNext = (pDrvCtrl->tea + 1) << 8;
  708.     SEEQ_WRITE (pDev->pRxptr, pDrvCtrl->rxNext);
  710.     /* Ack the buffer and RX interrupts */
  712.     SEEQ_WRITE (pDev->pCmd, ((SEEQ_READ(pDev->pStat) & SEEQ_STAT_CMD_MASK)
  713.     | SEEQ_CMD_RX_ACK | SEEQ_CMD_BUF_ACK
  714.     | SEEQ_CMD_RX_ON ));
  716.     intUnlock (oldLevel);
  717.     }
  719. /******************************************************************************
  720. *
  721. * seeqReset - reset the interface
  722. *
  723. * Mark interface as inactive & reset the chip
  724. *
  725. * NOMANUAL
  726. */
  728. LOCAL void seeqReset
  729.     (
  730.     int unit
  731.     )
  732.     {
  733.     int oldLevel;
  734.     DRV_CTRL *pDrvCtrl = &drvCtrl[unit];
  736.     /* Sanity check the unit number */
  738.     if (unit < 0 || unit >= MAX_UNITS)
  739. return;
  741.     oldLevel = intLock ();
  743.     /* Reset the chip */
  745.     SEEQ_WRITE (pDrvCtrl->devAdrs->pCfg1, 0);
  746.     SEEQ_WRITE (pDrvCtrl->devAdrs->pCfg2, SEEQ_CONF2_RESET);
  748.     /* Mark the interface as down */
  750.     pDrvCtrl->idr.ac_if.if_flags = 0;
  752.     intUnlock (oldLevel);
  753.     }
  755. /******************************************************************************
  756. *
  757. * seeqReceive - handle receiving packets.
  758. *
  759. * NOMANUAL
  760. */
  761. LOCAL void seeqReceive
  762.     (
  763.     int unit
  764.     )
  765.     {
  766.     USHORT nextFrame;
  767.     USHORT headerStatus;
  768.     int pktByteCnt = 0;
  769.     DRV_CTRL *pDrvCtrl = &drvCtrl[unit];
  770.     SEEQ_DEVICE *pDev = pDrvCtrl->devAdrs;
  772.     /* If interface was shutdown, abort service request */
  774.     if (!(pDrvCtrl->idr.ac_if.if_flags & IFF_UP))
  775. {
  776. pDrvCtrl->flags &= ~SEEQ_RX_OUTSTANDING;
  777. return;
  778. }
  780.     if (!(pDrvCtrl->flags & SEEQ_RX_OUTSTANDING))
  781. {
  782. #ifdef DEBUG
  783. if (seeqDebug)
  784.     logMsg ("seeq: no RX request outstandingn",
  785.     0, 0, 0, 0, 0, 0);
  786. #endif
  787. return;
  788. }
  789.     pDrvCtrl->flags &= ~SEEQ_RX_OUTSTANDING;
  791.     do
  792. {
  793. int i;
  794. USHORT frameStatus;
  795. USHORT frameLength;
  796. USHORT tmp;
  798. if (seeqSetDMARead(pDrvCtrl, pDrvCtrl->rxNext) != OK)
  799.     {
  800.     /* re-queue for later processing. */
  801. #ifdef DEBUG
  802.     if (seeqDebug)
  803. logMsg ("RX: Set DMA failedn", 0, 0, 0, 0, 0, 0);
  804. #endif
  805.     seeqRxReset (pDrvCtrl->unit);
  806.     pDrvCtrl->flags |= SEEQ_RX_OUTSTANDING;
  807.     netJobAdd ((FUNCPTR) seeqReceive, unit, 0, 0, 0, 0);
  808.     break;
  809.     }
  810. nextFrame = SEEQ_READ (pDev->pBwind);
  812. /* Get the header and frame status */
  814. tmp = SEEQ_READ (pDev->pBwind);
  815. headerStatus = tmp >> 8;
  816. frameStatus = tmp & 0x00ff;
  818. /*
  819.  * Stop under any of the following conditions:
  820.  *   The packet isn't done
  821.  *   The next packet is this packet (looped back).
  822.  */
  824. if (!(frameStatus & SEEQ_RX_PSTAT_DONE)
  825.     || (nextFrame == pDrvCtrl->rxNext))
  826.     break;
  828. if (nextFrame < pDrvCtrl->rxNext)
  829.     {
  830.     /* The receiver wrapped around */
  831.     frameLength = (pDrvCtrl->rea+1) - pDrvCtrl->rxNext - 4
  832. + (nextFrame - (int)((pDrvCtrl->tea + 1)<<8));
  833.     }
  834. else
  835.     {
  836.     /* The frame is sequential, not wrapped */
  837.     frameLength = nextFrame - pDrvCtrl->rxNext - 4;
  838.     }
  840. /* account for space consumed in the buffer. */
  842. pktByteCnt += frameLength + 4;
  843. if (pktByteCnt > 0x8000)
  844.     {
  845. #ifdef DEBUG
  846.     if (seeqDebug)
  847. logMsg ("RX packet overflowsn", 0, 0, 0, 0, 0, 0);
  848. #endif
  849.     seeqRxReset (pDrvCtrl->unit);
  850.     break;
  851.     }
  852. #ifdef DEBUG
  853. if (seeqDebug)
  854.     logMsg ("RX pkt: @ 0x%04x Frame 0x%02x Header 0x%02x len %4d nxt 0x%04xn",
  855.     pDrvCtrl->rxNext, frameStatus, headerStatus,
  856.     frameLength, nextFrame, 0);
  857. #endif
  858. if (frameStatus != SEEQ_RX_PSTAT_DONE)
  859.     {
  861.     /* one of the errors */
  863.     if (frameStatus & SEEQ_RX_PSTAT_OVERSIZE)
  864. ++pDrvCtrl->idr.ac_if.if_ierrors;
  865.     if (frameStatus & SEEQ_RX_PSTAT_CRC)
  866. ++pDrvCtrl->idr.ac_if.if_ierrors;
  867.     if (frameStatus & SEEQ_RX_PSTAT_DRIBBLE)
  868. ++pDrvCtrl->idr.ac_if.if_ierrors;
  869.     if (frameStatus & SEEQ_RX_PSTAT_SHORT)
  870. ++pDrvCtrl->idr.ac_if.if_ierrors;
  871.     }
  872. else
  873.     {
  874.     ETH_HDR *pHdr = (ETH_HDR *) pDrvCtrl->rxBuf;
  875.     char *bufp = (char *) pDrvCtrl->rxBuf;
  877.     /* Read in the entire packet */
  879.     for (i = 0; i < frameLength/2; ++i)
  880. {
  881. ((USHORT *) bufp)[i] = SEEQ_READ (pDev->pBwind);
  882. }
  884.     /* Get the last odd byte */
  886.     if (frameLength & 1)
  887. {
  888. bufp[frameLength-1] = SEEQ_READ_BYTE (pDev->pBwind);
  889. }
  891.     /* call input hook if any */
  893.     if ((etherInputHookRtn == NULL)
  894. || !(*etherInputHookRtn) (&pDrvCtrl->idr.ac_if,
  895.   bufp, frameLength))
  896. {
  897. MBUF *pMbuf;
  899. bufp += SIZEOF_ETHERHEADER;
  900. frameLength -= SIZEOF_ETHERHEADER;
  901. pMbuf = copy_to_mbufs (bufp, frameLength, 0,
  902.        (IFNET *) &pDrvCtrl->idr.ac_if);
  903. if (pMbuf != NULL)
  904.     {
  905.     do_protocol_with_type (ntohs (pHdr->ether_type), pMbuf,
  906.    &pDrvCtrl->idr, frameLength);
  907.     pDrvCtrl->idr.ac_if.if_ipackets++;
  908.     }
  909. }
  910.     }
  912. /* adjust circular buffer */
  914. pDrvCtrl->rxNext = nextFrame;
  915. SEEQ_WRITE (pDev->pRxend, (nextFrame >> 8));
  917. } while (headerStatus & SEEQ_RX_HSTAT_CHAIN);
  918.     }
  920. /******************************************************************************
  921. *
  922. * seeqTransmit - handle transmitted packets.
  923. *
  924. * NOMANUAL
  925. */
  926. LOCAL void seeqTransmit
  927.     (
  928.     int unit
  929.     )
  930.     {
  931.     int pktCount;
  932.     DRV_CTRL *pDrvCtrl = &drvCtrl[unit];
  933.     SEEQ_DEVICE *pDev = pDrvCtrl->devAdrs;
  934.     BOOL resetTx = FALSE;
  936. #ifdef DEBUG
  937.     if (seeqDebug)
  938. logMsg ("TX Cnt %d Curr 0x%04x Next 0x%04x Space 0x%04xn",
  939. pDrvCtrl->txCount, pDrvCtrl->txCurr,
  940. pDrvCtrl->txNext, TX_SPACE(pDrvCtrl),
  941. 0, 0);
  942. #endif
  943.     /* If interface was shutdown, abort service request */
  945.     if (!(pDrvCtrl->idr.ac_if.if_flags & IFF_UP))
  946. {
  947. pDrvCtrl->flags &= ~SEEQ_TX_OUTSTANDING;
  948. return;
  949. }
  951.     if (!(pDrvCtrl->flags & SEEQ_TX_OUTSTANDING))
  952. {
  953. #ifdef DEBUG
  954. if (seeqDebug)
  955.     logMsg ("seeq: no TX request outstandingn",
  956.     0, 0, 0, 0, 0, 0);
  957. #endif
  958. return;
  959. }
  960.     pDrvCtrl->flags &= ~SEEQ_TX_OUTSTANDING;
  962.     pktCount = pDrvCtrl->txCount;
  963.     if (!pDrvCtrl->txCount)
  964. {
  965. #ifdef DEBUG
  966. if (seeqDebug)
  967.     logMsg ("seeq: no xmit curr 0x%04x next 0x%04x space 0x%04xn",
  968.     pDrvCtrl->txCurr, pDrvCtrl->txNext, TX_SPACE(pDrvCtrl),
  969.     0, 0, 0);
  970. #endif
  971. return;
  972. }
  974.     /* Now process the packets */
  976.     while (1)
  977. {
  978. USHORT tmp;
  979. USHORT nextFrame;
  980. USHORT frameCommand;
  981. USHORT frameStatus;
  983. if (seeqSetDMARead(pDrvCtrl, pDrvCtrl->txCurr) != OK)
  984.     {
  985.     /* re-queue for later processing. */
  987. #ifdef DEBUG
  988.     if (seeqDebug)
  989. logMsg ("TX: Set DMA failedn", 0, 0, 0, 0, 0, 0);
  990. #endif
  991.     seeqTxReset (pDrvCtrl->unit);
  992.     pDrvCtrl->flags |= SEEQ_TX_OUTSTANDING;
  993.     netJobAdd ((FUNCPTR) seeqTransmit, unit, 0, 0, 0, 0);
  994.     break;
  995.     }
  997. /* Move curr to the end of the last transmitted packet */
  999. nextFrame = SEEQ_READ (pDev->pBwind);
  1001. /* get the frame status and command */
  1003. tmp = SEEQ_READ (pDev->pBwind);
  1004. frameCommand = tmp >> 8;
  1005. frameStatus = tmp & 0x00ff;
  1007. #ifdef DEBUG
  1008. if (seeqDebug)
  1009.     logMsg ("TX @ 0x%04x command %02x status 0x%02x next 0x%04xn",
  1010.     pDrvCtrl->txCurr, frameCommand, frameStatus, nextFrame,
  1011.     0, 0);
  1012. #endif
  1013. /*
  1014.  * At this point, we should be at a valid TX header since
  1015.  * txCount > 0.
  1016.  */
  1018. if (nextFrame > pDrvCtrl->txEnd)
  1019.     {
  1020. #ifdef DEBUG
  1021.     if (seeqDebug)
  1022. logMsg ("TX: bad next pointern", 0, 0, 0, 0, 0, 0);
  1023. #endif
  1024.     resetTx = TRUE;
  1025.     }
  1026. if (!(frameCommand & SEEQ_TX_CMD_XMIT))
  1027.     {
  1028. #ifdef DEBUG
  1029.     if (seeqDebug)
  1030. logMsg ("TX: not an xmit headern", 0, 0, 0, 0, 0, 0);
  1031. #endif
  1032.     resetTx = TRUE;
  1033.     }
  1034. if (!(frameCommand & SEEQ_TX_CMD_CHAIN))
  1035.     {
  1036. #ifdef DEBUG
  1037.     if (seeqDebug)
  1038. logMsg ("TX: ran off endn", 0, 0, 0, 0, 0, 0);
  1039. #endif
  1040.     resetTx = TRUE;
  1041.     }
  1042. if (!(frameCommand & SEEQ_TX_CMD_DATA))
  1043.     {
  1044. #ifdef DEBUG
  1045.     if (seeqDebug)
  1046. logMsg ("TX: no data in packetn", 0, 0, 0, 0, 0, 0);
  1047. #endif
  1048.     resetTx = TRUE;
  1049.     }
  1051. if (resetTx)
  1052.     {
  1053. #ifdef DEBUG
  1054.     if (seeqDebug)
  1055. logMsg ("TX: reset cnt %d curr 0x%04x cmd %02x stat 0x%02x next 0x%04xn",
  1056. pDrvCtrl->txCount, pDrvCtrl->txCurr, frameCommand,
  1057. frameStatus, nextFrame, 0);
  1058. #endif
  1059.     seeqTxReset (pDrvCtrl->unit);
  1060.     break;
  1061.     }
  1063. /* If not done, stop processing. */
  1065. if (!(frameStatus & SEEQ_TX_PSTAT_DONE))
  1066.     break;
  1068. /* Check for error status. */
  1069. if (frameStatus & SEEQ_TX_PSTAT_BABBLE)
  1070.     ++pDrvCtrl->idr.ac_if.if_oerrors;
  1071. if (frameStatus & SEEQ_TX_PSTAT_COLL16)
  1072.     pDrvCtrl->idr.ac_if.if_collisions += 16;
  1073. else if (frameStatus & SEEQ_TX_PSTAT_COLL)
  1074.     ++pDrvCtrl->idr.ac_if.if_collisions;
  1076. /* Move past this packet. */
  1077. pDrvCtrl->txCurr = nextFrame;
  1079. /* Exit if all packets accounted for. */
  1080. if (!--pDrvCtrl->txCount)
  1081.     break;
  1082. }
  1084.     /* If packets where waiting on the queue for free space, re-start */
  1086.     if (((pktCount != pDrvCtrl->txCount) || resetTx)
  1087. && (pDrvCtrl->idr.ac_if.if_snd.ifq_head != NULL))
  1088. (void)netJobAdd ((FUNCPTR) seeqStart, unit, 0, 0, 0, 0);
  1089.     }
  1091. /******************************************************************************
  1092. *
  1093. * seeqInt - handle controller interrupt
  1094. *
  1095. * This routine is called at interrupt level in response to an interrupt from
  1096. * the controller.  All of the real work is handled at task level through
  1097. * netJobAdd.
  1098. *
  1099. * NOMANUAL
  1100. */
  1102. void seeqInt
  1103.     (
  1104.     int unit
  1105.     )
  1106.     {
  1107.     USHORT status;
  1108.     DRV_CTRL *pDrvCtrl = &drvCtrl[unit];
  1109.     SEEQ_DEVICE *pDev = pDrvCtrl->devAdrs;
  1111.     ++seeqIntCnt;
  1112.     status = SEEQ_READ (pDev->pStat);
  1113.     SEEQ_WRITE (pDev->pCmd, ((SEEQ_READ(pDev->pStat) & SEEQ_STAT_CMD_MASK) | SEEQ_CMD_ALL_ACK));
  1115.     if (pDrvCtrl->idr.ac_if.if_flags & IFF_UP)
  1116. {
  1118. /* Make sure only one TX and RX request is outstanding at a time. */
  1120. if ((status & SEEQ_STAT_RX_INT)
  1121.     && !(pDrvCtrl->flags & SEEQ_RX_OUTSTANDING))
  1122.     {
  1123.     pDrvCtrl->flags |= SEEQ_RX_OUTSTANDING;
  1124.     netJobAdd ((FUNCPTR) seeqReceive, unit, 0, 0, 0, 0);
  1125.     }
  1127. if ((status & SEEQ_STAT_TX_INT)
  1128.     && !(pDrvCtrl->flags & SEEQ_TX_OUTSTANDING))
  1129.     {
  1130.     pDrvCtrl->flags |= SEEQ_TX_OUTSTANDING;
  1131.     netJobAdd ((FUNCPTR) seeqTransmit, unit, 0, 0, 0, 0);
  1132.     }
  1133. }
  1134.     }
  1136. /******************************************************************************
  1137. *
  1138. * seeqOutput - the driver output routine
  1139. *
  1140. * NOMANUAL
  1141. */
  1143. LOCAL int seeqOutput
  1144.     (
  1145.     IDR  *pIDR,
  1146.     MBUF *pMbuf,
  1147.     SOCK *pDest
  1148.     )
  1149.     {
  1150.     return ether_output ((IFNET*)pIDR, pMbuf, pDest,
  1151.  (FUNCPTR) seeqStart, pIDR);
  1152.     }
  1154. /******************************************************************************
  1155. *
  1156. * seeqStart - start outputing a packet.
  1157. *
  1158. * Get another datagram to send off of the interface queue,
  1159. * and map it to the interface before starting the output.
  1160. * This routine is called by seeqOutput().
  1161. *
  1162. * NOMANUAL
  1163. */
  1165. LOCAL void seeqStart
  1166.     (
  1167.     int unit
  1168.     )
  1169.     {
  1170.     DRV_CTRL *pDrvCtrl = &drvCtrl[unit];
  1171.     SEEQ_DEVICE *pDev = pDrvCtrl->devAdrs;
  1172.     int space;
  1173.     int s;
  1175.     s = splnet ();
  1177.     space = TX_SPACE(pDrvCtrl);
  1178.     if (space < (ETHERMTU + 8))
  1179. {
  1180. #ifdef DEBUG
  1181. if (seeqDebug)
  1182.     logMsg ("TX: low space %4d: flags %d curr 0x%04x next 0x%04xn",
  1183.     space, pDrvCtrl->flags, pDrvCtrl->txCurr, pDrvCtrl->txNext,
  1184.     0, 0);
  1185. #endif
  1187. /* May have dropped a TX interrupt */
  1189. if (pDrvCtrl->txLow++ > 2)
  1190.     {
  1191.     pDrvCtrl->txLow = 0;
  1192.     seeqTxReset (pDrvCtrl->unit);
  1193.     }
  1194. else if (!(pDrvCtrl->flags & SEEQ_TX_OUTSTANDING))
  1195.     {
  1196.     pDrvCtrl->flags |= SEEQ_TX_OUTSTANDING;
  1197.     netJobAdd ((FUNCPTR) seeqTransmit, unit, 0, 0, 0, 0);
  1198.     }
  1199. }
  1201.     /* Only start if we have at least enough room */
  1203.     if ((space >= ETHERMTU + 8)
  1204. && pDrvCtrl->idr.ac_if.if_snd.ifq_head != NULL)
  1205. {
  1206. MBUF *pMbuf;
  1207. int len;
  1208. UCHAR *buf;
  1209. USHORT txNext;
  1210. BOOL error = FALSE;
  1212. pDrvCtrl->txLow = 0;
  1214. IF_DEQUEUE(&pDrvCtrl->idr.ac_if.if_snd, pMbuf);
  1216. /* copy packet to write buffer */
  1218. copy_from_mbufs (pDrvCtrl->txBuf, pMbuf, len);
  1219. buf = (UCHAR *) pDrvCtrl->txBuf;
  1221. /* After this point, if there's a problem with the chip, the
  1222.    packet is lost. */
  1224. /* Adjust length to ensure minimum packet size */
  1226. len = max (ETHERSMALL, len);
  1228. ++pDrvCtrl->txCount;
  1229. #ifdef DEBUG
  1230. if (seeqDebug > 1)
  1231.     {
  1232.     int i;
  1233.     char *ptr;
  1234.     static char lbuf[4096];
  1236.     sprintf(lbuf, "TX %4d:", len);
  1237.     ptr = lbuf + strlen(lbuf);
  1238.     for (i = 0; i < len; ++i, ptr += 3)
  1239. sprintf(ptr , " %02x", buf[i]);
  1240.     logMsg ("%sn", (int) lbuf, 0, 0, 0, 0, 0);
  1241.     }
  1242. #endif
  1243. /* Compute where the next packet will go */
  1245. txNext = pDrvCtrl->txNext + len + 4;
  1246. if (txNext > pDrvCtrl->txEnd)
  1247.     txNext -= (pDrvCtrl->txEnd + 1);
  1248. #ifdef DEBUG
  1249. if (seeqDebug)
  1250.     logMsg ("TX pkt: @ %04x len %4d space %5d next %04xn",
  1251.     pDrvCtrl->txNext, len, TX_SPACE(pDrvCtrl), txNext,
  1252.     0, 0);
  1253. #endif
  1254. /* place a transmit request (while TX possibly running) */
  1256. /* Setup for writing */
  1258. if (seeqSetDMAWrite(pDrvCtrl, pDrvCtrl->txNext) != OK)
  1259.     error = TRUE;
  1261. if (error == FALSE)
  1262.     {
  1263.     /* Write a dummy header, so TX will stop if it catches up. */
  1265.     SEEQ_WRITE (pDev->pBwind, 0);
  1266.     SEEQ_WRITE (pDev->pBwind, 0);
  1268.     /* Write out the packet, two bytes at a time */
  1270.     for ( ; len >= 2; len -= 2, buf += 2)
  1271. {
  1272. SEEQ_WRITE (pDev->pBwind, *(USHORT *)buf);
  1273. }
  1275.     if (len)
  1276. {
  1277. SEEQ_WRITE_BYTE (pDev->pBwind, *buf);
  1278. }
  1280.     /* Write dummy end header to stop chain */
  1282.     SEEQ_WRITE (pDev->pBwind, 0);
  1283.     SEEQ_WRITE (pDev->pBwind, 0);
  1285.     /* Flush FIFO and move back and write the real header */
  1287.     if (seeqSetDMAWrite (pDrvCtrl, pDrvCtrl->txNext) != OK)
  1288. error = TRUE;
  1289.     }
  1290. if (error == FALSE)
  1291.     {
  1292.     /* TX packet header: next pointer (2 bytes) */
  1294.     SEEQ_WRITE (pDev->pBwind, txNext);
  1296.     /* TX packet header: cmd and status bytes */
  1298.     SEEQ_WRITE (pDev->pBwind,
  1299. ((SEEQ_TX_CMD_SUCC_EN
  1300.  | SEEQ_TX_CMD_DATA
  1301.  | SEEQ_TX_CMD_CHAIN
  1302.  | SEEQ_TX_CMD_XMIT) << SEEQ_MSB_SHIFT));
  1304.     /* Flush FIFO */
  1306.     if (seeqFlushFIFO (pDrvCtrl) != OK)
  1307. error = TRUE;
  1308.     }
  1309. if (error == FALSE)
  1310.     {
  1311.     /* If TX has stopped, reload xmit pointer. */
  1313.     if (!(SEEQ_READ(pDev->pStat) & SEEQ_STAT_TX_ON))
  1314. {
  1315. SEEQ_WRITE (pDev->pTxptr, pDrvCtrl->txNext);
  1316. }
  1318.     /* Adjust pointer to next buffer */
  1320.     pDrvCtrl->txNext = txNext;
  1322.     /* Turn on Tx and ack the buffer interrupt */
  1324.     SEEQ_WRITE (pDev->pCmd,  
  1325. ((SEEQ_READ(pDev->pStat) & SEEQ_STAT_CMD_MASK)
  1326.  | SEEQ_CMD_TX_ON | SEEQ_CMD_BUF_ACK));
  1327.     }
  1328. if (error == TRUE)
  1329.     seeqTxReset (pDrvCtrl->unit);
  1330. }
  1331.     splx (s);
  1332.     }
  1334. /******************************************************************************
  1335. *
  1336. * seeqIoctl - the driver I/O control routine
  1337. *
  1338. * Process an ioctl request.
  1339. *
  1340. * NOMANUAL
  1341. */
  1343. LOCAL int seeqIoctl
  1344.     (
  1345.     IDR  *ifp,
  1346.     int            cmd,
  1347.     caddr_t        data
  1348.     )
  1349.     {
  1350.     int error = OK;
  1352.     switch (cmd)
  1353.         {
  1354.       case (int)SIOCSIFADDR:
  1355. ifp->ac_ipaddr = IA_SIN (data)->sin_addr;
  1356. break;
  1358.       case (int)SIOCSIFFLAGS:
  1359. /* No further work to be done */
  1360. break;
  1362.       default:
  1363. error = EINVAL;
  1364.         }
  1365.     return (error);
  1366.     }