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

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

VxWorks

开发平台：

C/C++

if_eitp.c：源码内容
  1. /* if_eitp.c - Intel 82596 Ethernet network interface driver for the TP41V */
  3. /* Copyright 1989-1997 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 03f,03jul97,spm  added ARP request to SIOCSIFADDR ioctl handler
  10. 03e,07apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  11. 03d,11aug93,jmm  Changed ioctl.h and socket.h to sys/ioctl.h and sys/socket.h
  12. 03c,24mar93,jdi  documentation cleanup for 5.1.
  13. 03b,30nov92,rfs  Branched off custom version for TP41.
  14.                  Removed calls to sys596Init(), sys596IntAck().
  15.                  Replaced calls to sys596IntDisable() with intLock().
  16.                  Replaced calls to sys596IntEnable() with intUnlock().
  17.                  Removed dummy function eiChipReset().
  18. 03a,05oct92,rfs  Added documentation.
  19. 02z,02oct92,rfs  Made multiple attach calls per unit return OK, not ERROR.
  20. 02y,01oct92,rfs  Added 16 byte page alignment for SCP.
  21. 02x,28sep92,rfs  Modified the eiAction() routine to clear all events.  This
  22.                  makes the diagnostics pass, for some undocumented reason.
  23. 02w,09sep92,gae  documentation tweaks.
  24. 02v,11aug92,rfs  Slight change to memory carving.  Also fixed receive bug
  25.                  that was due to device manual incorrectly describing bit 7
  26.                  of config byte 10 and added error checks to RFDs.  Changed
  27.                  the device startup routine.
  28. 02u,26aug92,kdl  moved internal notes to file header (were just #ifdef'd out).
  29. 02t,19aug92,smb  changed systime.h to sys/times.h
  30. 02s,31jul92,dave Changed to new cacheLib.
  31. 02r,28jul92,rfs  Adapted to latest cache coherency model.
  32.                  Renamed driver control structure and moved it to bss.
  33.                  Combined the init() routine with the attach() routine and
  34.                  made attach() reject multiple invocations.  Rewrote the
  35.                  ioctl() routine to do the right stuff.  Reworked the action
  36.                  command routine and the primary command routine.  Other misc.
  37. 02q,16jul92,rfs  Moved driver specific items from header file to here,
  38.                  where they belong.
  39. 02p,16jul92,rfs  Moved internal comments to end of file, where they belong.
  40. 02o,03jul92,jwt  converted cacheClearEntry() calls to cacheClear() for 5.1.
  41. 02n,26jun92,rrr  make eiBusSnoop global again (needed by bsps)
  42. 02m,25jun92,rfs  backed out last mod; the manual is incorrect about the
  43.                  state of the bit that configures CRC inclusion
  44. 02l,25jun92,rfs  bug fix, changed a receive config parm that selects whether
  45.                  the CRC is included in the buffer
  46. 02k,23jun92,ajm  made eiChipReset global for tp41 BSP
  47. 02j,08jun92,ajm  modified so eiattach is only external function
  48.                  got rid of MEM_ROUND_UP macro now pulled in with vxWorks.h
  49.                  got rid of many ansi complaints
  50. 02i,26may92,rrr  the tree shuffle
  51.                  -changed includes to have absolute path from h/
  52. 02h,22feb92,wmd  added conditional compiles for 040, ansi fixes.
  53. 02g,07jan92,shl  made driver cache safe. added eiBusSnoop(). eliminated some
  54.                  ANSI warnings.
  55. 02f,12nov91,wmd  Added fix, courtesy of jrb-Intel, which added a watchdog to
  56.                  timeout any stalls due to hardware lockup and resets the
  57.                  82596.
  58. 02e,25oct91,rfs  Changed eiChipReset() to not depend on valid *es, and
  59.                  made it global for TP41 usage. Also eliminated ANSI
  60.                  warnings.
  61. 02d,04oct91,rrr  passed through the ansification filter
  62.                  -changed functions to ansi style
  63.                  -changed includes to have absolute path from h/
  64.                  -changed VOID to void
  65.                  -changed copyright notice
  66. 02c,15sep91,rfs  Bug fix. Eliminated lock condition when output queue full
  67.                  and out of TFDs. Added major comment to eiTxStartup. Also,
  68.                  major changes to eiChipReset() to make more robust. All
  69.                  instances of intLock()/intUnlock() changed to
  70.                  sys596IntDisable()/sys596IntEnable respectively. Statistic
  71.                  counters now being used, which required moderate changes to
  72.                  the transmit side design. More comments added.
  73. 02b,21aug91,rfs  changed method of obtaining Ethernet address.
  74. 02a,22jul91,jcf  completely rewritten to utilize simplified mode,
  75.             rfs  added big endian support, reworked buffer loaning.
  76. 01h,01may91,elh  fixed ethernet addressing problem, upgraded to 5.0,
  77.                  added buffer loanouts, fixed ifAddrSet bug by disabling
  78.                  interrupts in eiHardReset.
  79. 01g,28apr91,del  added #define of ETHER_HEADER_SIZE as workaround for
  80.                  gnu960 pading of struct ether_header.
  81. 01f,05jan91,gae  added global eiSCPSysConfig for board specific SCP parameters.
  82.                  moved CDELAY here from if_ei.h and renamed eichkcca.
  83. 01e,03jan91,gae  more cleanup and merged with Intel's fixes.
  84.                  Ethernet address (eiEnetAddr) is set in sysHwInit.
  85.                  cleaned up error printing & no carrier message always printed.
  86.                  changed printf's to printErr's (logMsg if at int level).
  87.                  made most routines local -- not available outside this module.
  88. 01d,31dec90,gae  removed 68K stuff.
  89. 01c,14dec90,elh  more cleanup.
  90. 01b,12dec90,elh  fixed buffer problems, cleaned up, added etherhooks.
  91. 01a,06feb90,djk  written
  92. */
  94. /*
  95. This module implements the Intel 82596 Ethernet network interface driver.
  97. This driver is a custom version of the generic `ei' driver, to support the
  98. Tadpole TP41V.   Use the information from manual page for if_ei, except for
  99. the following differences:
  100. .iP "" 4
  101. The name of the attach routine is eitpattach().  The arguments are the same.
  102. .iP
  103. The following external support routines are not required:  sys596Init(),
  104. sys596IntEnable(), sys596IntDisable(), and sys596IntAck().
  106. SEE ALSO: if_ei, ifLib,
  107. .I "Intel 82596 User's Manual"
  108. */
  110. #include "vxWorks.h"
  111. #include "wdLib.h"
  112. #include "iv.h"
  113. #include "vme.h"
  114. #include "net/mbuf.h"
  115. #include "net/protosw.h"
  116. #include "sys/socket.h"
  117. #include "sys/ioctl.h"
  118. #include "errno.h"
  119. #include "memLib.h"
  120. #include "intLib.h"
  121. #include "net/if.h"
  122. #include "net/route.h"
  124. #include "cacheLib.h"
  125. #include "logLib.h"
  126. #include "netLib.h"
  127. #include "stdio.h"
  128. #include "stdlib.h"
  129. #include "sysLib.h"
  131. #ifdef  INET
  132. #include "netinet/in.h"
  133. #include "netinet/in_systm.h"
  134. #include "netinet/in_var.h"
  135. #include "netinet/ip.h"
  136. #include "netinet/if_ether.h"
  137. #endif  /* INET */
  139. #include "etherLib.h"
  140. #include "net/systm.h"
  141. #include "sys/times.h"
  142. #include "drv/netif/if_ei.h"
  143. #include "net/if_subr.h"
  146. /***** LOCAL DEFINITIONS *****/
  148. #undef EI_DEBUG                             /* Compiles debug output */
  150. #define MAX_UNITS       4                   /* maximum units to support */
  151. #define DEF_NUM_TFDS    32                  /* default number of TFDs */
  152. #define DEF_NUM_RFDS    32                  /* default number of RFDs */
  153. #define MAX_RFDS_LOANED 8                   /* max RFDs that can be loaned */
  155. /* Typedefs for external structures that are not typedef'd in their .h files */
  157. typedef struct mbuf MBUF;
  158. typedef struct arpcom IDR;                  /* Interface Data Record wrapper */
  159. typedef struct ifnet IFNET;                 /* real Interface Data Record */
  160. typedef struct sockaddr SOCK;
  161. typedef struct ether_header ETH_HDR;
  163. /* The definition of our linked list management structure */
  165. typedef struct ei_list                       /* EI_LIST - 82596 queue head */
  166.     {
  167.     volatile EI_NODE *  head;       /* header of list */
  168.     volatile EI_NODE *  tail;       /* tail of list */
  169.     } EI_LIST;
  171. /* The definition of the driver control structure */
  173. typedef struct drv_ctrl
  174.     {
  175.     IDR                 idr;        /* interface data record */
  177.     BOOL                attached;   /* indicates attach() called */
  178.     char                *memBase;   /* 82596 memory pool base */
  179.     SCP                 *pScp;      /* SCP ptr */
  180.     ISCP                *pIscp;     /* ISCP ptr */
  181.     SCB                 *pScb;      /* SCB ptr */
  182.     CFD                 *pCfd;      /* synchronous command frame */
  183.     RFD                 *rfdPool;   /* RFD pool */
  184.     TFD                 *tfdPool;   /* TFD pool */
  185.     RFD                 *pFreeRfd;  /* first empty RFD in rxQueue */
  186.     volatile EI_LIST    rxQueue;    /* receive queue */
  187.     volatile EI_LIST    txQueue;    /* to be sent queue */
  188.     volatile EI_LIST    tfdQueue;   /* free transmit frame descriptors */
  189.     volatile EI_LIST    cblQueue;   /* actual chip transmit queue */
  190.     volatile EI_LIST    cleanQueue; /* queue of TFDs to cleanup */
  191.     volatile BOOL       rcvHandling;/* flag, indicates netTask active */
  192.     volatile BOOL       txCleaning; /* flag, indicates netTask active */
  193.     volatile BOOL       txIdle;     /* flag, indicates idle transmitter */
  194.     int                 nTFDs;      /* how many TFDs to create */
  195.     int                 nRFDs;      /* how many RFDs to create */
  196.     int                 nLoanRfds;  /* number of loanable RFDs left */
  197.     UINT8               sysbus;     /* SCP sysbus value */
  198.     int                 ivec;       /* interrupt vector */
  199.     CACHE_FUNCS         cacheFuncs; /* cache descriptor */
  200.     WDOG_ID             wid;        /* watchdog timer for transmit */
  201.     long                transLocks; /* count for transmit lockup failures */
  202.     } DRV_CTRL;
  204. #define DRV_CTRL_SIZ  sizeof(DRV_CTRL)
  207. /***** GLOBALS *****/
  209. /* Function declarations not in any header files */
  211. IMPORT STATUS sysEnetAddrGet (int unit, char addr[]);
  212. IMPORT void   sys596Port (int unit, int cmd, UINT32 addr);
  213. IMPORT void   sys596ChanAtn (int unit);
  216. /***** LOCALS *****/
  218. /* The array of driver control structs */
  220. LOCAL DRV_CTRL drvCtrl [MAX_UNITS];
  223. /* forward function declarations */
  225. static void eiReset (int unit);
  226. static int eiIoctl (IDR *pIDR, int cmd, caddr_t data);
  227. #ifdef BSD43_DRIVER
  228. static int eiOutput (IDR *pIDR, MBUF *pMbuf, SOCK *pDestAddr);
  229. static void eiTxStartup (int unit);
  230. #else
  231. static void eiTxStartup (DRV_CTRL *pDrvCtrl);
  232. #endif
  233. static void eiInt (DRV_CTRL *pDrvCtrl);
  234. static void eiTxCleanQ (DRV_CTRL *pDrvCtrl);
  235. static void eiHandleRecvInt (DRV_CTRL *pDrvCtrl);
  236. static STATUS eiReceive (DRV_CTRL *pDrvCtrl, RFD *pRfd);
  237. static void eiLoanFree (DRV_CTRL *pDrvCtrl, RFD *pRfd);
  238. static STATUS eiDiag (int unit);
  239. static void eiConfig (int unit);
  240. static void eiIASetup (int unit);
  241. static void eiRxStartup (DRV_CTRL *pDrvCtrl);
  242. static void eiAction (int unit, UINT16 action);
  243. static STATUS eiCommand (DRV_CTRL *pDrvCtrl, UINT16 cmd);
  244. static void eiTxQPut (DRV_CTRL *pDrvCtrl, TFD *pTfd);
  245. static void eiTxQFlush (DRV_CTRL *pDrvCtrl);
  246. static void eiRxQPut (DRV_CTRL *pDrvCtrl, RFD *pRfd);
  247. static RFD *eiRxQGet (DRV_CTRL *pDrvCtrl);
  248. static BOOL eiRxQFull (DRV_CTRL *pDrvCtrl);
  249. static void eiQInit (EI_LIST *pHead);
  250. static EI_NODE *eiQGet (EI_LIST *pQueue);
  251. static void eiQPut (int unit, EI_LIST *pQueue, EI_NODE *pNode);
  252. static STATUS eiDeviceStart (int unit);
  253. static void eiWatchDog(int unit);
  256. /*******************************************************************************
  257. *
  258. * eitpattach - publish the `ei' network interface for the TP41V and initialize the driver and device
  259. *
  260. * The routine publishes the `ei' interface by filling in a network interface
  261. * record and adding this record to the system list.  This routine also
  262. * initializes the driver and the device to the operational state.
  263. *
  264. * The 82596 shares a region of memory with the driver.  The caller of this
  265. * routine can specify the address of this memory region, or can specify that
  266. * the driver must obtain this memory region from the system resources.
  267. *
  268. * The <sysbus> parameter accepts values as described in the Intel manual
  269. * for the 82596.  A default number of transmit/receive frames of 32 can be
  270. * selected by passing zero in the parameters <nTfds> and <nRfds>.
  271. * In other cases, the number of frames selected should be greater than two.
  272. *
  273. * The <memBase> parameter is used to inform the driver about the shared
  274. * memory region.  If this parameter is set to the constant "NONE", then
  275. * eitpattach() will attempt to allocate the shared memory from the system.
  276. * Any other value for this parameter is interpreted as the address of the
  277. * shared memory region to be used.
  278. *
  279. * If the caller provides the shared memory region, then the driver assumes
  280. * that this region does not require cache coherency operations, nor does it
  281. * require conversions between virtual and physical addresses.
  282. *
  283. * If the caller indicates that this routine must allocate the shared memory
  284. * region, then this routine will use the routine cacheDmaMalloc() to obtain
  285. * some  non-cacheable memory.  The attributes of this memory will be checked,
  286. * and if the memory is not both read and write coherent, this routine will
  287. * abort and return ERROR.
  288. *
  289. * RETURNS: OK or ERROR.
  290. *
  291. * SEE ALSO: if_ei, ifLib,
  292. * .I "Intel 82596 User's Manual"
  293. */
  295. STATUS eitpattach
  296.     (
  297.     int         unit,              /* unit number */
  298.     int         ivec,              /* interrupt vector number */
  299.     UINT8       sysbus,            /* sysbus field of SCP */
  300.     char *      memBase,           /* address of memory pool or NONE */
  301.     int         nTfds,             /* no. of transmit frames (0 = default) */
  302.     int         nRfds              /* no. of receive frames (0 = default) */
  303.     )
  304.     {
  305.     DRV_CTRL    *pDrvCtrl;
  306.     UINT        size;                           /* temporary size holder */
  307.     UINT        sizeScp;
  308.     UINT        sizeIscp;
  309.     UINT        sizeScb;
  310.     UINT        sizeCfd;
  311. int intLevel;
  313.     static char *errMsg1 = "neiattach: could not obtain memoryn";
  314.     static char *errMsg2 = "neiattach: shared memory not cache coherentn";
  316.     sizeScp  = MEM_ROUND_UP (sizeof (SCP));
  317.     sizeIscp = MEM_ROUND_UP (sizeof (ISCP));
  318.     sizeScb  = MEM_ROUND_UP (sizeof (SCB));
  319.     sizeCfd  = MEM_ROUND_UP (sizeof (CFD));
  321.     /* Sanity check the unit number */
  323.     if (unit < 0 || unit >= MAX_UNITS)
  324.         return (ERROR);
  326.     /* Ensure single invocation per system life */
  328.     pDrvCtrl = & drvCtrl [unit];
  329.     if (pDrvCtrl->attached)
  330.         return (OK);
  332.     /* Determine number of Tx and Rx descriptors to use */
  334.     pDrvCtrl->nTFDs = nTfds ? nTfds : DEF_NUM_TFDS;
  335.     pDrvCtrl->nRFDs = nRfds ? nRfds : DEF_NUM_RFDS;
  337.     /* Publish the interface record */
  339. #ifdef BSD43_DRIVER
  340.     ether_attach ( (IFNET *)&pDrvCtrl->idr, unit, "eitp", (FUNCPTR)NULL,
  341.                    (FUNCPTR) eiIoctl, (FUNCPTR) eiOutput, (FUNCPTR) eiReset);
  342. #else
  343.     ether_attach    (
  344.                     &pDrvCtrl->idr.ac_if,
  345.                     unit,
  346.                     "eitp",
  347.                     (FUNCPTR) NULL,
  348.                     (FUNCPTR) eiIoctl,
  349.                     (FUNCPTR) ether_output,
  350.                     (FUNCPTR) eiReset
  351.                     );
  352.     pDrvCtrl->idr.ac_if.if_start = (FUNCPTR)eiTxStartup;
  353. #endif
  355.     /* calculate the total size of 82596 memory pool */
  357.     size =
  358.             16 +                                /* allow for alignment */
  359.             sizeScp +
  360.             sizeIscp +
  361.             sizeScb +
  362.             sizeCfd +                           /* synch'ed command frame */
  363.             (sizeof (RFD) * pDrvCtrl->nRFDs) +  /* pool of receive frames */
  364.             (sizeof (TFD) * pDrvCtrl->nTFDs);   /* pool of transmit frames */
  366.     /* Establish the memory area that we will share with the device.  If
  367.      * the caller has provided an area, then we assume it is non-cacheable
  368.      * and will not require the use of the special cache routines.
  369.      * If the caller did not provide an area, then we must obtain it from
  370.      * the system, using the cache savvy allocation routine.
  371.      */
  373.     switch ((int) memBase)
  374.         {
  375.         case NONE :                            /* we must obtain it */
  377.             /* this driver can't handle incoherent caches */
  379.             if (!CACHE_DMA_IS_WRITE_COHERENT () ||
  380.                 !CACHE_DMA_IS_READ_COHERENT ())
  381.                 {
  382.                 printf (errMsg2);
  383.                 goto error;
  384.                 }
  386.             pDrvCtrl->memBase = cacheDmaMalloc (size);
  388.             if (pDrvCtrl->memBase == NULL)    /* no memory available */
  389.                 {
  390.                 printf (errMsg1);
  391.                 goto error;
  392.                 }
  394.             pDrvCtrl->cacheFuncs = cacheDmaFuncs;
  395.             break;
  397.         default :                               /* the user provided an area */
  398.             pDrvCtrl->memBase = memBase;        /* use the provided address */
  399.             pDrvCtrl->cacheFuncs = cacheNullFuncs;
  400.             break;
  401.         }
  403.     /* Save other passed-in parameters */
  405.     pDrvCtrl->sysbus = sysbus;                  /* remember sysbus value */
  406.     pDrvCtrl->ivec = ivec;                      /* interrupt vector */
  408.     /* Carve up the shared memory region into the specific sections */
  410.     bzero ((char *) pDrvCtrl->memBase, size);
  411.     pDrvCtrl->pScp  = (SCP *)                /* align to first 16 byte page */
  412.                       ( ((u_long) pDrvCtrl->memBase + 0xf) & ~0xf );
  413.     pDrvCtrl->pIscp = (ISCP *)((int)pDrvCtrl->pScp   + sizeScp);
  414.     pDrvCtrl->pScb  = (SCB *) ((int)pDrvCtrl->pIscp  + sizeIscp);
  415.     pDrvCtrl->pCfd  = (CFD *) ((int)pDrvCtrl->pScb   + sizeScb);
  416.     pDrvCtrl->rfdPool   = (RFD *) ((int)pDrvCtrl->pCfd   + sizeCfd);
  417.     pDrvCtrl->tfdPool = (TFD *)
  418.             ((int)pDrvCtrl->rfdPool+ (sizeof (RFD) * pDrvCtrl->nRFDs));
  420.     /* Init the watchdog that will patrol for device lockups */
  422.     pDrvCtrl->transLocks = 0;
  423.     pDrvCtrl->wid = wdCreate ();                      /* create watchdog */
  424.     if (pDrvCtrl->wid == NULL)                        /* no resource */
  425.         goto error;
  427.     /* get our enet addr */
  429.     if (sysEnetAddrGet (unit, (char *)pDrvCtrl->idr.ac_enaddr) == ERROR)
  430.         goto error;
  432.     pDrvCtrl->rcvHandling   = FALSE;  /* netTask not running our receive job */
  433.     pDrvCtrl->txCleaning    = FALSE;  /* netTask not running our clean job */
  434.     pDrvCtrl->txIdle        = TRUE;         /* transmitter idle */
  435.     eiQInit ((EI_LIST *)&pDrvCtrl->rxQueue);    /* to be received queue */
  436.     eiQInit ((EI_LIST *)&pDrvCtrl->txQueue);    /* to be sent queue */
  437.     eiQInit ((EI_LIST *)&pDrvCtrl->tfdQueue);   /* free tfds to add to send q */
  438.     eiQInit ((EI_LIST *)&pDrvCtrl->cblQueue);   /* actively sending queue */
  439.     eiQInit ((EI_LIST *)&pDrvCtrl->cleanQueue); /* queue of TFDs to clean */
  442.     { /***** Perform device initialization *****/
  444.     /* Block local variables */
  446.     int ix;
  448.     /* Connect the interrupt handler */
  450.     if (intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (ivec), eiInt, (int)pDrvCtrl)
  451.         == ERROR)
  452.         goto error;
  454. /* Disable system interrupts (NOTE #1) */
  456. intLevel = intLock ();
  458.     /* Start the device */
  460.     if ( eiDeviceStart (unit) == ERROR )
  461.         goto error;
  463.     if ( eiDiag (unit) == ERROR )              /* run diagnostics */
  464. goto error;
  465.     eiConfig (unit);                           /* configure chip */
  466.     eiIASetup (unit);                          /* setup address */
  468.     for (ix = 0; ix < pDrvCtrl->nTFDs; ix ++)  /* tank up the free tfd queue */
  469.         {
  470.         eiQPut  (
  471.                 unit,
  472.                 (EI_LIST *) & pDrvCtrl->tfdQueue,
  473.                 (EI_NODE *) & pDrvCtrl->tfdPool [ix]
  474.                 );
  475.         }
  477.     pDrvCtrl->pFreeRfd  = NULL;                  /* first free RFD */
  478.     pDrvCtrl->nLoanRfds = MAX_RFDS_LOANED;       /* number of loanable RFD's */
  480.     for (ix = 0; ix < pDrvCtrl->nRFDs; ix ++)   /* tank up the receive queue */
  481.         eiRxQPut (pDrvCtrl, & pDrvCtrl->rfdPool [ix]);
  483. /* Re-enable system interrupts */
  485.     intUnlock (intLevel);
  487.     } /* End block */
  489.     /* Set our flag */
  491.     pDrvCtrl->attached = TRUE;
  493.     /* Set status flags in IDR */
  495.     pDrvCtrl->idr.ac_if.if_flags |= (IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);
  497.     /* Successful return */
  499.     return (OK);
  501.     /***** Handle error cases *****/
  503.     error:
  505.         {
  506. /* Re-enable system interrupts */
  508.      intUnlock (intLevel);
  510.         /* Release system memory */
  512.         if (((int) memBase == NONE) && ((int) pDrvCtrl->memBase != NULL))
  513.             cacheDmaFree (pDrvCtrl->memBase);
  515.         /* Release watchdog */
  517.         if (pDrvCtrl->wid != NULL)
  518.             wdDelete (pDrvCtrl->wid);
  520.         return (ERROR);
  521.         }
  522.     }
  524. /*******************************************************************************
  525. *
  526. * eiReset - reset the ei interface
  527. *
  528. * Mark interface as inactive and reset the chip.
  529. */
  531. static void eiReset
  532.     (
  533.     int unit
  534.     )
  535.     {
  536.     int intLevel;
  537.     DRV_CTRL *pDrvCtrl;
  539.     pDrvCtrl = & drvCtrl [unit];
  541.     if (pDrvCtrl->idr.ac_if.if_flags & IFF_RUNNING)
  542.         {
  544.         /* issue command to disable CU and RU */
  546.         intLevel = intLock ();
  547.         eiCommand (pDrvCtrl, SCB_C_CUABORT | SCB_C_RUABORT);
  548.         intUnlock (intLevel);
  549.         }
  551.     pDrvCtrl->idr.ac_if.if_flags = 0;
  552.     }
  554. /*******************************************************************************
  555. *
  556. * eiIoctl - interface ioctl procedure
  557. *
  558. * Process an interface ioctl request.
  559. */
  561. static int eiIoctl
  562.     (
  563.     IDR     *pIDR,
  564.     int     cmd,
  565.     caddr_t data
  566.     )
  567.     {
  568.     int error;
  570. #ifdef EI_DEBUG
  571.     printf ("ei: ioctl: pIDR=%x cmd=%x data=%xn", pIDR, cmd, data);
  572. #endif /* EI_DEBUG */
  574.     error = 0;
  576.     switch (cmd)
  577.         {
  578.         case SIOCSIFADDR:
  579.             ((struct arpcom *)pIDR)->ac_ipaddr = IA_SIN (data)->sin_addr;
  580.             arpwhohas (pIDR, &IA_SIN (data)->sin_addr);
  581.             break;
  583.         case SIOCSIFFLAGS:
  584.             /* Flags are set outside this module. No additional work to do. */
  585.             break;
  587.         default:
  588.             error = EINVAL;
  589.         }
  591.     return (error);
  592.     }
  594. #ifdef BSD43_DRIVER
  595. /*******************************************************************************
  596. *
  597. * eiOutput - interface output routine.
  598. *
  599. * This is the entry point for packets arriving from protocols above.  This
  600. * routine merely calls our specific output routines that eventually lead
  601. * to a transmit to the network.
  602. *
  603. * RETURNS: 0 or appropriate errno
  604. */
  606. static int eiOutput
  607.     (
  608.     IDR *    pIDR,
  609.     MBUF *     pMbuf,
  610.     SOCK * pDestAddr
  611.     )
  612.     {
  614. #ifdef EI_DEBUG
  615.     printf ("ei: output: pIDR=%x pMbuf=%x pDestAddr=%xn",
  616.             pIDR, pMbuf, pDestAddr);
  617. #endif /* EI_DEBUG */
  619.     return (ether_output ((IFNET *)pIDR, pMbuf, pDestAddr,
  620.             (FUNCPTR) eiTxStartup, pIDR));
  621.     }
  622. #endif
  624. /*******************************************************************************
  625. *
  626. * eiTxStartup - start output on the chip
  627. *
  628. * Looks for any action on the queue, and begins output if there is anything
  629. * there. This routine is called from several possible threads. Each will be
  630. * described below.
  631. *
  632. * The first, and most common thread, is when a user task requests the
  633. * transmission of data. Under BSD 4.3, this will cause eiOutput() to be 
  634. * called, which calls ether_output(), which will usually call this routine.
  635. * This routine will not be called if ether_output() finds that our interface 
  636. * output queue is full. In this case, the outgoing data will be thrown out.
  637. * BSD 4.4 uses a slightly different model in which the generic ether_output()
  638. * routine is called directly, followed by a call to this routine.
  639. *
  640. * The second, and most obscure thread, is when the reception of certain
  641. * packets causes an immediate (attempted) response. For example, ICMP echo
  642. * packets (ping), and ICMP "no listener on that port" notifications. All
  643. * functions in this driver that handle the reception side are executed in the
  644. * context of netTask(). Always. So, in the case being discussed, netTask() will
  645. * receive these certain packets, cause IP to be stimulated, and cause the
  646. * generation of a response to be sent. We then find ourselves following the
  647. * thread explained in the second example, with the important distinction that
  648. * the context is that of netTask().
  649. *
  650. * The third thread occurs when this routine runs out of TFDs and returns. If
  651. * this occurs when our output queue is not empty, this routine would typically
  652. * not get called again until new output was requested. Even worse, if the
  653. * output queue was also full, this routine would never get called again and
  654. * we would have a lock state. It DOES happen. To guard against this, the
  655. * transmit clean-up handler detects the out-of-TFDs state and calls this
  656. * function. The clean-up handler also runs from netTask.
  657. *
  658. * Note that this function is ALWAYS called between an splnet() and an splx().
  659. * This is true because netTask(), and ether_output() take care of
  660. * this when calling this function. Therefore, no calls to these spl functions
  661. * are needed anywhere in this output thread.
  662. */
  664. #ifdef BSD43_DRIVER
  665. static void eiTxStartup
  666.     (
  667.     int unit
  668.     )
  669.     {
  670.     DRV_CTRL * pDrvCtrl = & drvCtrl [unit];
  671. #else
  672. static void eiTxStartup
  673.     (
  674.     DRV_CTRL *  pDrvCtrl  /* driver control structure */
  675.     )
  676.     {
  677. #endif
  678.     MBUF * pMbuf;
  679.     int length;
  680.     TFD * pTfd;
  682.     /*
  683.      * Loop until there are no more packets ready to send or we
  684.      * have insufficient resources left to send another one.
  685.      */
  687.     while (pDrvCtrl->idr.ac_if.if_snd.ifq_head)
  688.         {
  689.         /* get free tfd */
  690.         pTfd = (TFD *) eiQGet ((EI_LIST *)&pDrvCtrl->tfdQueue);
  692.         if (pTfd == NULL)
  693.             break;                              /* out of TFD's */
  695.         IF_DEQUEUE (&pDrvCtrl->idr.ac_if.if_snd, pMbuf);  /* dequeue a packet */
  697.         copy_from_mbufs ((ETH_HDR *)pTfd->enetHdr, pMbuf, length);
  698.         length = max (ETHERSMALL, length);
  700.         if ((etherOutputHookRtn != NULL) &&
  701.             (* etherOutputHookRtn)
  702.             (&pDrvCtrl->idr, (ETH_HDR *)pTfd->enetHdr, length))
  703.             continue;
  705.         pTfd->count = length & ~0xc000;     /* fill in length */
  707.         eiTxQPut (pDrvCtrl, pTfd);
  708. #ifndef BSD43_DRIVER    /* BSD 4.4 ether_output() doesn't bump statistic. */
  709.         pDrvCtrl->idr.ac_if.if_opackets++;
  710. #endif
  711.         }
  712.     }
  714. /*******************************************************************************
  715. *
  716. * eiInt - entry point for handling interrupts from the 82596
  717. *
  718. * The interrupting events are acknowledged to the device, so that the device
  719. * will deassert its interrupt signal. The amount of work done here is kept
  720. * to a minimum; the bulk of the work is defered to the netTask. Several flags
  721. * are used here to synchronize with task level code and eliminate races.
  722. */
  724. static void eiInt
  725.     (
  726.     DRV_CTRL *pDrvCtrl
  727.     )
  728.     {
  729.     UINT16  event;
  730.     SCB *pScb;
  731.     int unit;
  732.     pScb = pDrvCtrl->pScb;
  733.     unit = pDrvCtrl->idr.ac_if.if_unit;
  735.     event = pScb->scbStatus & (SCB_S_CX | SCB_S_FR | SCB_S_CNA | SCB_S_RNR);
  737. #ifdef EI_DEBUG
  738.     logMsg ("ei: interrupt: event=%xn", event, 0, 0, 0, 0, 0);
  739. #endif /* EI_DEBUG */
  741.     eiCommand (pDrvCtrl, event);                        /* ack the events */
  743.     /* Handle transmitter interrupt */
  745.     if (event & SCB_S_CNA)                              /* reclaim tx tfds */
  746.         {
  748.         wdCancel(pDrvCtrl->wid);
  750.         if (pDrvCtrl->cleanQueue.head == NULL)      /* clean queue empty */
  751.             {
  752.             pDrvCtrl->cleanQueue.head = pDrvCtrl->cblQueue.head; /* new head */
  753.             pDrvCtrl->cleanQueue.tail = pDrvCtrl->cblQueue.tail; /* new tail */
  754.             }
  755.         else                                            /* concatenate queues */
  756.             {
  757.             pDrvCtrl->cleanQueue.tail->pNext =
  758.                         (EI_NODE*) pDrvCtrl->cblQueue.head;
  759.             pDrvCtrl->cleanQueue.tail = pDrvCtrl->cblQueue.tail;
  760.             }
  762.         if (!pDrvCtrl->txCleaning)                          /* not cleaning? */
  763.             {
  764.             pDrvCtrl->txCleaning = TRUE;                    /* set flag */
  765.             netJobAdd ((FUNCPTR) eiTxCleanQ, (int) pDrvCtrl, 0, 0, 0, 0);
  766.                             /* defer cleanup */
  767.             }
  769.         if (pDrvCtrl->txQueue.head != NULL)             /* anything to flush? */
  770.             eiTxQFlush (pDrvCtrl);                      /* flush the tx q */
  771.         else
  772.             pDrvCtrl->txIdle = TRUE;                    /* transmitter idle */
  773.         }
  775.     /* Handle receiver interrupt */
  777.     if ((event & SCB_S_FR) && !(pDrvCtrl->rcvHandling))
  778.         {
  779.         pDrvCtrl->rcvHandling = TRUE;
  780.         (void) netJobAdd ((FUNCPTR) eiHandleRecvInt, (int) pDrvCtrl,0, 0, 0, 0);         /* netTask processes */
  781.         }
  782.     }
  784. /*******************************************************************************
  785. *
  786. * eiTxCleanQ - checks errors in completed TFDs and moves TFDs to free queue
  787. *
  788. * This routine is executed by netTask. It "cleans" the TFDs on the clean-up
  789. * queue by checking each one for errors and then returning the TFD to the
  790. * "free TFD" queue. The startup routine is sometimes called here to eliminate
  791. * the lock-out case where the driver input queue is full but there are no
  792. * TFDs available.
  793. */
  795. static void eiTxCleanQ
  796.     (
  797.     DRV_CTRL *pDrvCtrl
  798.     )
  799.     {
  800.     TFD *pTfd;
  801.     BOOL needTxStart;
  802.     int unit;
  803. int intLevel;
  805.     unit = pDrvCtrl->idr.ac_if.if_unit;
  807.     do
  808.         {
  809.         pDrvCtrl->txCleaning = TRUE;
  811.         if (pDrvCtrl->tfdQueue.head == NULL)              /* tfd queue empty */
  812.             needTxStart = TRUE;                           /* set flag */
  813.         else
  814.             needTxStart = FALSE;
  816.         /* process transmitted frames */
  818.         while (1)
  819.             {
  821.             /* Get TFD. No ints allowed while manipulating this queue. */
  823. /* Disable system interrupts (NOTE #1) */
  825. intLevel = intLock ();
  827.             pTfd = (TFD*) eiQGet ((EI_LIST *)&pDrvCtrl->cleanQueue);
  829. /* Re-enable system interrupts */
  831.      intUnlock (intLevel);
  833.             if (pTfd == NULL)
  834.                 break;
  836.             pDrvCtrl->idr.ac_if.if_collisions +=         /* add any colls */
  837.                 (pTfd->status & CFD_S_RETRY) ? 16 :  /* excessive colls */
  838.                 (pTfd->status & CFD_S_COLL_MASK);    /* some colls */
  840.             if (!(pTfd->status & CFD_S_OK))          /* packet not sent */
  841.                 {
  842.                 pDrvCtrl->idr.ac_if.if_oerrors++;        /* incr err count */
  843.                 pDrvCtrl->idr.ac_if.if_opackets--;       /* decr sent count */
  844.                 }
  846.             /* return to tfdQ */
  847.             eiQPut (unit,(EI_LIST *)&pDrvCtrl->tfdQueue, (EI_NODE*)pTfd);
  848.             }
  850.         if (needTxStart)                                  /* check flag */
  851. #ifdef BSD43_DRIVER
  852.             eiTxStartup (unit);
  853. #else
  854.             eiTxStartup (pDrvCtrl);
  855. #endif
  857.         pDrvCtrl->txCleaning = FALSE;
  858.         }
  859.     while (pDrvCtrl->cleanQueue.head != NULL);            /* check again */
  860.     }
  862. /*******************************************************************************
  863. *
  864. * eiHandleRecvInt - task level interrupt service for input packets
  865. *
  866. * This routine is called at task level indirectly by the interrupt
  867. * service routine to do any message received processing.
  868. */
  870. static void eiHandleRecvInt
  871.     (
  872.     DRV_CTRL *pDrvCtrl
  873.     )
  874.     {
  875.     RFD *pRfd;
  877.     do
  878.         {
  879.         pDrvCtrl->rcvHandling = TRUE;             /* interlock with eiInt() */
  881.         while ((pRfd = eiRxQGet (pDrvCtrl)) != NULL)
  882.             if (eiReceive (pDrvCtrl, pRfd) == OK)
  883.                 eiRxQPut (pDrvCtrl, pRfd);
  885.         pDrvCtrl->rcvHandling = FALSE;            /* interlock with eiInt() */
  886.         }
  887.     while (eiRxQFull (pDrvCtrl));              /* make sure rx q still empty */
  888.     }
  890. /*******************************************************************************
  891. *
  892. * eiReceive - pass a received frame to the next layer up
  893. *
  894. * Strips the Ethernet header and passes the packet to the appropriate
  895. * protocol. The return value indicates if buffer loaning was used to hold
  896. * the data. A return value of OK means that loaning was not done, and it
  897. * is therefore 'ok' to return the RFD to the Rx queue. A return value of ERROR
  898. * means that buffer loaning was employed, and so the RFD is still in use and
  899. * should not be returned to the Rx queue. In this latter case, the RFD will
  900. * eventually be returned by the protocol, via a call to our eiLoanFree().
  901. */
  903. static STATUS eiReceive
  904.     (
  905.     DRV_CTRL *pDrvCtrl,
  906.     RFD *pRfd
  907.     )
  908.     {
  909.     ETH_HDR     *pEh;
  910.     u_char      *pData;
  911.     int         len;
  912. #ifdef BSD43_DRIVER
  913.     UINT16      etherType;
  914. #endif
  915.     MBUF        *m = NULL;
  916.     BOOL        rfdLoaned = FALSE;
  919.     /* Check packet for errors.  This should be completely unnecessary,
  920.      * but since Intel does not seem capable of explaining the exact
  921.      * functioning of the 'save bad frames' config bit, we will look for
  922.      * errors.
  923.      */
  925.     if  (
  926.         ( pRfd->status & ( RFD_S_OK | RFD_S_COMPLETE ) ) !=
  927.         ( RFD_S_OK | RFD_S_COMPLETE )
  928.         )
  929.         {
  930.         ++pDrvCtrl->idr.ac_if.if_ierrors;            /* bump error counter */
  931.         eiRxQPut (pDrvCtrl, pRfd);                   /* free the RFD */
  932.         return (ERROR);
  933.         }
  935.     /* Bump input packet counter. */
  937.     ++pDrvCtrl->idr.ac_if.if_ipackets;
  939.     len = pRfd->actualCnt & ~0xc000;        /* get frame length */
  940.     pEh = (ETH_HDR *)pRfd->enetHdr;         /* get ptr to ethernet header */
  942.     /* Service input hook */
  944.     if ( (etherInputHookRtn != NULL) )
  945.         {
  946.         if  ( (* etherInputHookRtn) (&pDrvCtrl->idr, (char *)pEh, len) )
  947.             {
  948.             eiRxQPut (pDrvCtrl, pRfd);                  /* free the RFD */
  949.             return (OK);
  950.             }
  951.         }
  953.     len -= EH_SIZE;
  954.     pData = (u_char *) pRfd->enetData;
  955. #ifdef BSD43_DRIVER
  956.     etherType = ntohs (pEh->ether_type);
  957. #endif
  959.     /* we can loan out receive frames from 82596 receive queue if:
  960.      *
  961.      * 1) the threshold of loanable frames has not been exceeded
  962.      * 2) size of the input ethernet frame is large enough to be used with
  963.      *    clustering.
  964.      */
  966.     if ((pDrvCtrl->nLoanRfds > 0) && (USE_CLUSTER (len)) &&
  967.         ((m = build_cluster (pData, len, &pDrvCtrl->idr, MC_EI, &pRfd->refCnt,
  968.                  eiLoanFree, (int) pDrvCtrl, (int) pRfd, NULL)) != NULL))
  969.         {
  970.         pDrvCtrl->nLoanRfds --;             /* one less to loan */
  971.         rfdLoaned = TRUE;               /* we loaned a frame */
  972.         }
  973.     else
  974.         m = copy_to_mbufs (pData, len, 0, &pDrvCtrl->idr);
  976.     if (m != NULL)
  977. #ifdef BSD43_DRIVER
  978.         do_protocol_with_type (etherType, m, &pDrvCtrl->idr, len);
  979. #else
  980.         do_protocol (pEh, m, &pDrvCtrl->idr, len);
  981. #endif
  982.     else
  983.         pDrvCtrl->idr.ac_if.if_ierrors++;       /* bump error counter */
  985.     return ((rfdLoaned) ? ERROR : OK);
  986.     }
  988. /*******************************************************************************
  989. *
  990. * eiLoanFree - return a loaned receive frame descriptor
  991. *
  992. * This routine is called by the protocol code when it has completed use of
  993. * an RFD that we loaned to it.
  994. */
  996. static void eiLoanFree
  997.     (
  998.     DRV_CTRL *pDrvCtrl,
  999.     RFD *pRfd
  1000.     )
  1001.     {
  1002.     eiRxQPut (pDrvCtrl, pRfd);
  1003.     pDrvCtrl->nLoanRfds ++;
  1004.     }
  1006. /*******************************************************************************
  1007. *
  1008. * eiDeviceStart - reset and start the device
  1009. *
  1010. * This routine assumes interrupts from the device have been disabled, and
  1011. * that the driver control structure has been initialized.
  1012. */
  1014. static STATUS eiDeviceStart
  1015.     (
  1016.     int unit                              /* physical unit number */
  1017.     )
  1018.     {
  1019.     void     *pTemp;
  1020.     DRV_CTRL *pDrvCtrl;
  1021.     SCP      *pScp;                       /* system config ptr */
  1022.     ISCP     *pIscp;                      /* intermediate system config ptr */
  1023.     SCB      *pScb;                       /* system control block ptr */
  1024. unsigned long loopy;
  1026.     /* Get pointers */
  1028.     pDrvCtrl = & drvCtrl [unit];
  1029.     pScp = pDrvCtrl->pScp;
  1030.     pIscp = pDrvCtrl->pIscp;
  1031.     pScb = pDrvCtrl->pScb;
  1033.     /* Issue the reset operation to the device */
  1035.     sys596Port (unit, PORT_RESET, NULL);
  1037.     /* Initialize the SCP */
  1039.     pScp->scpRsv1 =
  1040.     pScp->scpRsv2 =
  1041.     pScp->scpRsv3 = 0;
  1042.     pScp->scpSysbus = pDrvCtrl->sysbus;
  1044.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pIscp);
  1045.     LINK_WR (&pScp->pIscp, pTemp);              /* point SCP to ISCP */
  1047.     /* Initialize the ISCP */
  1049.     pIscp->iscpBusy = 1;
  1050.     pIscp->iscpRsv1 = 0;
  1052.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pScb);
  1053.     LINK_WR (&pIscp->pScb, pTemp);              /* point ISCP to SCB */
  1055.     /* Initialize the SCB */
  1057.     bzero ((char *)pScb, sizeof (SCB));
  1059.     /* Tell the device where the SCP is located */
  1061.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pScp);
  1062.     sys596Port (unit, PORT_NEWSCP, (UINT32) pTemp);
  1063.     sys596ChanAtn (unit);
  1065.     /*
  1066.      * The device will now read our SCP and ISCP. It will clear the busy
  1067.      * flag in the ISCP.
  1068.      */
  1070. /* Delay here for ample time.  Can not use taskDelay() because all
  1071.  * interrupts have been enabled, and thus no clock ticks.
  1072.  */
  1074. for ( loopy = 0x00100000; loopy--; )
  1075. ;
  1077.     if ( pIscp->iscpBusy == 1 )
  1078.         return (ERROR);
  1080.     return (OK);
  1081.     }
  1083. /*******************************************************************************
  1084. *
  1085. * eiDiag - format and issue a diagnostic command
  1086. */
  1088. static STATUS eiDiag
  1089.     (
  1090.     int unit
  1091.     )
  1092.     {
  1093.     DRV_CTRL *pDrvCtrl;
  1095.     pDrvCtrl = & drvCtrl [unit];
  1097.     bzero ((char *)pDrvCtrl->pCfd, sizeof (CFD));       /* zero command frame */
  1099.     eiAction (unit, CFD_C_DIAG);                /* run diagnostics */
  1101.     if (!(pDrvCtrl->pCfd->cfdStatus & CFD_S_OK))
  1102.         return (ERROR);
  1104. return (OK);
  1105.     }
  1107. /*******************************************************************************
  1108. *
  1109. * eiConfig - format and issue a config command
  1110. */
  1112. static void eiConfig
  1113.     (
  1114.     int unit
  1115.     )
  1116.     {
  1117.     DRV_CTRL *pDrvCtrl;
  1119.     pDrvCtrl = & drvCtrl [unit];
  1121.     bzero ((char *)pDrvCtrl->pCfd, sizeof (CFD));       /* zero command frame */
  1123.     /* Recommeded i82596 User's Manual configuration values.  Note that
  1124.      * the original manual, #296443-001, was full of errors.  Errors in the
  1125.      * description of the config bytes that I am aware of are noted below.
  1126.      * It is possible there are further errors.  Intel has replaced the
  1127.      * manual with #296853-001, which does correct some errors, but not all.
  1128.      */
  1130.     pDrvCtrl->pCfd->cfdConfig.ccByte8  = 0x8e;
  1131.     pDrvCtrl->pCfd->cfdConfig.ccByte9  = 0xc8;
  1133.     /* The manual is wrong about bit 7 in byte 10.
  1134.      * A '0' allows reception of bad packets.
  1135.      * A '1' causes rejection of bad packets.
  1136.      */
  1137.     pDrvCtrl->pCfd->cfdConfig.ccByte10 = 0xc0;
  1139.     pDrvCtrl->pCfd->cfdConfig.ccByte11 = 0x2e;      /* loopback, NSAI */
  1140.     pDrvCtrl->pCfd->cfdConfig.ccByte12 = 0x00;
  1141.     pDrvCtrl->pCfd->cfdConfig.ccByte13 = 0x60;
  1142.     pDrvCtrl->pCfd->cfdConfig.ccByte14 = 0x00;
  1143.     pDrvCtrl->pCfd->cfdConfig.ccByte15 = 0xf2;
  1144.     pDrvCtrl->pCfd->cfdConfig.ccByte16 = 0x00;      /* promiscuous off */
  1145.     pDrvCtrl->pCfd->cfdConfig.ccByte17 = 0x00;
  1146.     pDrvCtrl->pCfd->cfdConfig.ccByte18 = 0x40;
  1148.     /* The manual is wrong about 2 bits in byte 19.
  1149.      * Bit 5, multicast, a '1' disables.
  1150.      * Bit 2, include CRC, a '1' disables.
  1151.      */
  1152.     pDrvCtrl->pCfd->cfdConfig.ccByte19 = 0xff;
  1154.     pDrvCtrl->pCfd->cfdConfig.ccByte20 = 0x00;
  1155.     pDrvCtrl->pCfd->cfdConfig.ccByte21 = 0x3f;
  1158.     eiAction (unit, CFD_C_CONFIG);          /* configure the chip */
  1159.     }
  1161. /*******************************************************************************
  1162. *
  1163. * eiIASetup - format and issue an interface address command
  1164. */
  1166. static void eiIASetup
  1167.     (
  1168.     int unit
  1169.     )
  1170.     {
  1171.     DRV_CTRL *pDrvCtrl;
  1173.     pDrvCtrl = & drvCtrl [unit];
  1175.     bzero ((char *)pDrvCtrl->pCfd, sizeof (CFD));       /* zero command frame */
  1177.     bcopy   (
  1178.             (char *)pDrvCtrl->idr.ac_enaddr,
  1179.             (char *)pDrvCtrl->pCfd->cfdIASetup.ciAddress,
  1180.             6
  1181.             );
  1183.     eiAction (unit, CFD_C_IASETUP);         /* setup the address */
  1184.     }
  1186. /*******************************************************************************
  1187. *
  1188. * eiRxStartup - start up the Receive Unit
  1189. *
  1190. * Starts up the Receive Unit.  Assumes that the receive structures are set up.
  1191. */
  1193. static void eiRxStartup
  1194.     (
  1195.     DRV_CTRL *pDrvCtrl
  1196.     )
  1197.     {
  1198.     SCB *pScb = pDrvCtrl->pScb;
  1199.     void * pTemp;
  1200. int intLevel;
  1202.     if (pScb->scbStatus & SCB_S_RUREADY)        /* already running */
  1203.         return;
  1205.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pDrvCtrl->pFreeRfd);
  1206.     LINK_WR (&pScb->pRF, pTemp);            /* point to free Rfd */
  1208. /* Disable system interrupts (NOTE #1) */
  1210. intLevel = intLock ();
  1212.     if ((pScb->scbStatus & SCB_S_RUMASK) != SCB_S_RUIDLE)
  1213.         eiCommand (pDrvCtrl, SCB_C_RUABORT);            /* abort if not idle */
  1215.     eiCommand (pDrvCtrl, SCB_C_RUSTART);              /* start receive unit */
  1217. /* Re-enable system interrupts */
  1219.     intUnlock (intLevel);
  1221.     }
  1223. /*******************************************************************************
  1224. *
  1225. * eiAction - execute the specified action with the CFD pointed to in pDrvCtrl
  1226. *
  1227. * Do the command contained in the CFD synchronously, so that we know
  1228. * it's complete upon return.  This routine assumes that interrupts from the
  1229. * device have been disabled.
  1230. */
  1232. static void eiAction
  1233.     (
  1234.     int    unit,
  1235.     UINT16 action
  1236.     )
  1237.     {
  1238.     void     *pTemp;
  1239.     CFD      *pCfd;
  1240.     SCB      *pScb;
  1241.     DRV_CTRL *pDrvCtrl;
  1243.     pDrvCtrl = & drvCtrl [unit];
  1244.     pCfd = pDrvCtrl->pCfd;
  1245.     pScb = pDrvCtrl->pScb;
  1247.     while (1)                   /* wait for idle command unit */
  1248.         {
  1249.         if ((pScb->scbStatus & SCB_S_CUMASK) == SCB_S_CUIDLE)
  1250.             break;
  1251.         }
  1253.     { /* Prepare and issue the command to the device */
  1255.     /* fill in CFD */
  1257.     pCfd->cfdStatus  = 0;                       /* clear status */
  1258.     pCfd->cfdCommand = CFD_C_EL | action;       /* fill in action */
  1259.     LINK_WR (&pCfd->link, NULL);                /* terminate link */
  1261.     /* and the SCB */
  1263.     pScb->scbCommand =
  1264.                         SCB_S_CX |              /* ack any events */
  1265.                         SCB_S_FR |
  1266.                         SCB_S_CNA |
  1267.                         SCB_S_RNR |
  1268.                         SCB_C_CUSTART;          /* start command unit */
  1270.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pCfd);
  1271.     LINK_WR (&pScb->pCB, pTemp);                /* point chip at CFD */
  1273.     sys596ChanAtn (unit);               /* notify device of new command */
  1274.     }
  1276.     while (1)               /* wait for command acceptance and interrupt */
  1277.         {
  1278.         if ((pScb->scbCommand == 0) && (pScb->scbStatus & SCB_S_CNA))
  1279.             break;
  1280.         }
  1282.     /* Acknowledge the event to the device */
  1284.     pScb->scbCommand = (SCB_S_CX | SCB_S_CNA);
  1285.     sys596ChanAtn (unit);
  1287.     while (1)               /* wait for acknowledge acceptance */
  1288.         {
  1289.         if (pScb->scbCommand == 0)
  1290.             break;
  1291.         }
  1292.     }
  1294. /*******************************************************************************
  1295. *
  1296. * eiCommand - deliver a command to the 82596 via SCB
  1297. *
  1298. * This function causes the device to execute a command. It should be called
  1299. * with interrupts from the device disabled. An error status is returned if
  1300. * the command field does not return to zero, from a previous command, in a
  1301. * reasonable amount of time.
  1302. */
  1304. static STATUS eiCommand
  1305.     (
  1306.     DRV_CTRL *pDrvCtrl,
  1307.     UINT16    cmd
  1308.     )
  1309.     {
  1310.     SCB * pScb;
  1312.     pScb = pDrvCtrl->pScb;
  1314.     while (1)
  1315.         {
  1316.         if (pScb->scbCommand == 0)                  /* wait for cmd zero */
  1317.             break;
  1318.         }
  1320.     pScb->scbCommand = cmd;                     /* fill in command */
  1321.     sys596ChanAtn (pDrvCtrl->idr.ac_if.if_unit);    /* channel attention */
  1322.     return (OK);
  1323.     }
  1325. /*******************************************************************************
  1326. *
  1327. * eiTxQPut - place a transmit frame on the transmit queue
  1328. *
  1329. * The TFD has been filled in with the network pertinent data. This
  1330. * routine will enqueue the TFD for transmission and attempt to feed
  1331. * the queue to the device.
  1332. */
  1334. static void eiTxQPut
  1335.     (
  1336.     DRV_CTRL *pDrvCtrl,
  1337.     TFD *pTfd
  1338.     )
  1339.     {
  1340.     int unit;
  1341. int intLevel;
  1343.     unit = pDrvCtrl->idr.ac_if.if_unit;
  1345.     pTfd->status    = 0;                    /* fill in TFD fields */
  1346.     pTfd->command   = CFD_C_XMIT;           /* EL set later */
  1347.     pTfd->count     |= TFD_CNT_EOF;         /* data kept in frame */
  1348.     pTfd->reserved  = 0;                    /* must be zero */
  1350.     LINK_WR (& pTfd->lBufDesc, NULL);                /* TBDs not used */
  1352. /* Disable system interrupts (NOTE #1) */
  1354. intLevel = intLock ();
  1356.     /* enqueue the TFD */
  1357.     eiQPut (unit,(EI_LIST *)&pDrvCtrl->txQueue, (EI_NODE*)pTfd);
  1359.     if (pDrvCtrl->txIdle)                             /* transmitter idle */
  1360.         eiTxQFlush (pDrvCtrl);                        /* flush txQueue */
  1362. /* Re-enable system interrupts */
  1364.     intUnlock (intLevel);
  1365.     }
  1367. /*******************************************************************************
  1368. *
  1369. * eiTxQFlush - make cmd unit of device start processing cmds
  1370. *
  1371. * This routine flushes the contents of the txQ to the cblQ and starts the
  1372. * device transmitting the cblQ. Called only if transmit queue is not empty.
  1373. * Sometimes called from interrupt handler.
  1374. */
  1376. static void eiTxQFlush
  1377.     (
  1378.     DRV_CTRL *pDrvCtrl
  1379.     )
  1380.     {
  1381.     void * pTemp;
  1382.     extern int sysClkRateGet();     /* we call this */
  1384.     ((TFD*)pDrvCtrl->txQueue.tail)->command |= CFD_C_EL;  /* EL terminate q */
  1385.     pDrvCtrl->cblQueue.head = pDrvCtrl->txQueue.head;   /* remember cbl head */
  1386.     pDrvCtrl->cblQueue.tail = pDrvCtrl->txQueue.tail;   /* remember cbl tail */
  1387.     eiQInit ((EI_LIST *)&pDrvCtrl->txQueue);            /* tx queue now empty */
  1389.     pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs,
  1390.                                     pDrvCtrl->cblQueue.head);
  1391.     LINK_WR (&pDrvCtrl->pScb->pCB, pTemp);          /* point CU to head */
  1393.     pDrvCtrl->txIdle = FALSE;                   /* transmitter busy */
  1395.     /* start watchdog */
  1397.     wdStart (
  1398.             pDrvCtrl->wid,
  1399.             (int) (sysClkRateGet() >> 1),
  1400.             (FUNCPTR) eiWatchDog,
  1401.             pDrvCtrl->idr.ac_if.if_unit
  1402.             );
  1404.     /* start command unit */
  1406.     eiCommand (pDrvCtrl, SCB_C_CUSTART);
  1407.     }
  1409. /*******************************************************************************
  1410. *
  1411. * eiRxQPut - return a RFD to the receive queue for use by the device
  1412. */
  1414. static void eiRxQPut
  1415.     (
  1416.     DRV_CTRL *pDrvCtrl,
  1417.     RFD *pRfd
  1418.     )
  1419.     {
  1420.     int unit;
  1421.     RFD *pTail;
  1423.     unit = pDrvCtrl->idr.ac_if.if_unit;
  1425.     pRfd->status    = 0;                    /* clear status */
  1426.     pRfd->command   = CFD_C_EL;             /* new end of list */
  1427.     pRfd->actualCnt  = 0;                   /* clear actual count */
  1428.     pRfd->bufSize   = ETHERMTU + EH_SIZE;   /* fill in size */
  1429.     pRfd->refCnt    = 0;                    /* initialize ref cnt */
  1431.     LINK_WR (& pRfd->lBufDesc, 0xffffffff);         /* no RBD used */
  1433.     pTail = (RFD *) pDrvCtrl->rxQueue.tail;         /* remember tail */
  1435.     /* Put the RFD on the list */
  1437.     eiQPut (unit, (EI_LIST *) & pDrvCtrl->rxQueue, (EI_NODE *) pRfd);
  1439.     if (pTail != NULL)
  1440.         {
  1441.         pTail->command &= ~CFD_C_EL;        /* clear old tail EL */
  1443.         if (pTail->status & (CFD_S_COMPLETE | CFD_S_BUSY))
  1444.             {
  1445.             pDrvCtrl->pFreeRfd = pRfd;          /* link questionable */
  1446.             }
  1447.         else if (!(pDrvCtrl->pScb->scbStatus & SCB_S_RUREADY))
  1448.             /* receiver dormant */
  1449.             {
  1450.             eiRxStartup (pDrvCtrl);             /* start receive unit */
  1451.             }
  1452.         }
  1453.     else
  1454.         {
  1455.         pDrvCtrl->pFreeRfd = pRfd;              /* first free RFD */
  1456.         }
  1457.     }
  1459. /*******************************************************************************
  1460. *
  1461. * eiRxQGet - get a successfully received frame from the receive queue
  1462. *
  1463. * RETURNS: ptr to valid RFD, or NULL if none available
  1464. */
  1466. static RFD *eiRxQGet
  1467.     (
  1468.     DRV_CTRL *pDrvCtrl
  1469.     )
  1470.     {
  1471.     RFD *pRfd = NULL;
  1473.     if (eiRxQFull (pDrvCtrl))
  1474.         pRfd = (RFD *) eiQGet ((EI_LIST *)&pDrvCtrl->rxQueue);
  1476.     return (pRfd);
  1477.     }
  1479. /*******************************************************************************
  1480. *
  1481. * eiRxQFull - boolean function to determine fullness of receive queue
  1482. *
  1483. * RETURNS: TRUE if completely received frame is available, FALSE otherwise.
  1484. */
  1486. static BOOL eiRxQFull
  1487.     (
  1488.     DRV_CTRL *pDrvCtrl
  1489.     )
  1490.     {
  1491.     return ((pDrvCtrl->rxQueue.head != NULL) &&
  1492.         (((RFD*)pDrvCtrl->rxQueue.head)->status & CFD_S_COMPLETE));
  1493.     }
  1495. /*******************************************************************************
  1496. *
  1497. * eiQInit - initialize a singly linked node queue
  1498. */
  1500. static void eiQInit
  1501.     (
  1502.     EI_LIST *pQueue
  1503.     )
  1504.     {
  1505.     pQueue->head = pQueue->tail = NULL;         /* init head & tail */
  1506.     }
  1508. /*******************************************************************************
  1509. *
  1510. * eiQGet - get a node from the head of a node queue
  1511. *
  1512. * RETURNS: ptr to useable node, or NULL ptr if none available
  1513. */
  1515. static EI_NODE *eiQGet
  1516.     (
  1517.     EI_LIST *pQueue
  1518.     )
  1519.     {
  1520.     EI_NODE *pNode;
  1522.     if ((pNode = (EI_NODE *) pQueue->head) != NULL)     /* if list not empty */
  1523.         pQueue->head = pNode->pNext;                    /* advance ptr */
  1525.     return (pNode);
  1526.     }
  1528. /*******************************************************************************
  1529. *
  1530. * eiQPut - put a node on the tail of a node queue
  1531. */
  1533. static void eiQPut
  1534.     (
  1535.     int unit,
  1536.     EI_LIST *pQueue,
  1537.     EI_NODE *pNode
  1538.     )
  1539.     {
  1540.     void * pTemp;
  1541.     DRV_CTRL *pDrvCtrl;
  1543.     pDrvCtrl = & drvCtrl [unit];
  1545.     LINK_WR (&pNode->lNext, NULL);                    /* mark "end of list" */
  1546.     pNode->pNext = NULL;
  1548.     if (pQueue->head == NULL)                        /* if list empty */
  1549.         pQueue->tail = pQueue->head = pNode;         /* set both ptrs */
  1550.     else
  1551.         {
  1552.         pTemp = CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, pNode);
  1553.         LINK_WR (&pQueue->tail->lNext, pTemp);       /* link node on tail */
  1554.         pQueue->tail->pNext = pNode;
  1555.         pQueue->tail = pNode;                        /* update tail ptr */
  1556.         }
  1557.     }
  1559. /*******************************************************************************
  1560. *
  1561. * eiWatchDog - if the watchdog timer fired off, we've hung during a transmit
  1562. *
  1563. * Check the scb command to verify and if so, reinit.
  1564. */
  1566. static void eiWatchDog
  1567.     (
  1568.     int unit        /* unit number */
  1569.     )
  1571.     {
  1572.     DRV_CTRL *pDrvCtrl;
  1573.     SCB *pScb;
  1574.     pScb = pDrvCtrl->pScb;
  1576.     pDrvCtrl = & drvCtrl [unit];
  1578.     /* sanity check.
  1579.      * If the scb status indicates that CU (transmit) is active
  1580.      * It might make sense to loop through the cfd's to look for
  1581.      * a complete bit as a sanity check , but given that we are
  1582.      * here and that transmit was active, we will go ahead and do
  1583.      * a reset.
  1584.      */
  1586.     if (pScb->scbStatus & SCB_S_CUACTIVE)
  1587.         {
  1588.         pDrvCtrl->transLocks++;                     /* local failure count */
  1589.         pDrvCtrl->idr.ac_if.if_oerrors++;           /* incr err count */
  1590.         pDrvCtrl->idr.ac_if.if_opackets--;          /* decr sent count */
  1591.         }
  1592.     }
  1595. /* NOTES
  1596.  *
  1597.  * NOTE #1:
  1598.  * The TP41 has a major design oversite.  The interrupt pin from the
  1599.  * 82596 connects directly to the CPU.  Since the 82596 provides no way
  1600.  * to disable the device from generating interrupts, there is no way to
  1601.  * selectively disable the 82596 interrupt.  The only option is to disable
  1602.  * all interrupts in the system during critical code regions.
  1603.  */
  1606. /* END OF FILE */