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

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

VxWorks

开发平台：

C/C++

if_fei.c：源码内容
  1. /* if_fei.c - Intel 82557 Ethernet network interface driver */
  3. /* Copyright 1998 Wind River Systems, Inc. */
  5. #include "copyright_wrs.h"
  7. /*
  8. modification history
  9. --------------------
  10. 01q,28apr99,dat  Merge from 2_0_0
  11. 01s,09mar99,cn   added support for shared PCI interrupts (SPR# 24379).
  12. 01r,14dec98,n_s  fixed feiInit to properly set promiscuous mode. spr 24000.
  13. 01q,16oct98,cn   changed default to be BSD44_DRIVER, as 01o did not do it.
  14.  Suppressed warning in feiIoctl() (SPR# 21880).
  15. 01p,30sep98,cn   moved call to I82557_INT_DISABLE after sys557Init() 
  16.  (SPR# 21879). Also suppressed some warnings (SPR# 21880).
  17. 01o,16apr98,dat  changed default to be BSD44_DRIVER
  18. 01n,14apr98,sbs  added global variable feiIntConnect.
  19.                  changed SYS_PCI_INT_CONNECT to SYS_INT_CONNECT.
  20.                  added documentation on how to use feiIntConnect.
  21. 01m,18mar98,dat  changed default to be BSD43_DRIVER. fixed compatibility
  22. 01l,12mar98,sbs  changed intConnect() to SYS_PCI_INT_CONNECT.
  23. 01k,15jul97,spm  removed driver initialization from ioctl support (SPR #8831)
  24. 01j,25apr97,gnn  added multicast by turning on promiscous mode.
  25. 01i,03mar97,myz  fixed spr 7663
  26. 01h,07apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  27. 01h,10dec96,jdi  doc: correct statement about # of external support functions.
  28. 01g,20nov96,myz  doc: removed the document for the sys557Intxxx functions
  29. 01f,20nov96,myz  correct the DOC problem in feiDumpPrint and feiErrCounterDump
  30. 01e,20nov96,jdi  doc: mangen fixes and general cleanup.
  31. 01d,20nov96,hdn  removed CSR_ADDR_GET() and ENET_ADDR_GET().
  32. 01c,25oct96,myz  added system memory interface and MDI control 
  33. 01b,10oct96,dzb  clean-up and bug fixes.
  34. 01a,31aug96,dzb  written, based on v03g of src/drv/netif/if_ei.c.
  35. */
  37. /*
  38. This module implements the Intel 82557 Ethernet network interface driver.
  40. This driver is designed to be moderately generic, operating unmodified
  41. across the entire range of architectures and targets supported by VxWorks.
  42. This driver must be given several target-specific parameters, and some
  43. external support routines must be provided.  These parameters, and the
  44. mechanisms used to communicate them to the driver, are detailed below.
  46. This driver supports up to four individual units.
  48. EXTERNAL INTERFACE
  49. The user-callable routine is feiattach(), which publishes the `fei'
  50. interface and performs some initialization.
  52. After calling feiattach() to publish the interface, an initialization
  53. routine must be called to bring the device up to an operational state.
  54. The initialization routine is not a user-callable routine; upper layers
  55. call it when the interface flag is set to `UP', or when the interface's
  56. IP address is set.
  58. There is a global variable 'feiIntConnect' which specifies the interrupt
  59. connect routine to be used depending on the BSP. This is by default set 
  60. to intConnect() and the user can override this to use any other interrupt 
  61. connect routine ( say pciIntConnect() ) in sysHwInit() or any device 
  62. specific initialization routine called in sysHwInit().
  64. TARGET-SPECIFIC PARAMETERS
  65. .iP "shared memory address"
  66. This parameter is passed to the driver via feiattach().
  68. The Intel 82557 device is a DMA-type device and typically shares
  69. access to some region of memory with the CPU.  This driver is designed
  70. for systems that directly share memory between the CPU and the 82557.
  72. This parameter can be used to specify an explicit memory region for use
  73. by the 82557.  This should be done on targets that restrict the 82557
  74. to a particular memory region.  The constant `NONE' can be used to indicate
  75. that there are no memory limitations, in which case the driver
  76. attempts to allocate the shared memory from the system space.
  77. .iP "number of Command, Receive, and Loanable-Receive Frame Descriptors"
  78. These parameters are passed to the driver via feiattach().
  80. The Intel 82557 accesses frame descriptors (and their associated buffers)
  81. in memory for each frame transmitted or received.  The number of frame
  82. descriptors can be configured at run-time using these parameters.
  83. .iP "Ethernet address"
  84. This parameter is obtained by a call to an external support routine.
  85. .LP
  87. EXTERNAL SUPPORT REQUIREMENTS
  88. This driver requires the following external support function:
  89. .CS
  90.     STATUS sys557Init (int unit, BOARD_INFO *pBoard)
  91. .CE
  92. This routine performs any target-specific initialization
  93. required before the 82557 device is initialized by the driver.
  94. The driver calls this routine every time it wants to [re]initialize
  95. the device.  This routine returns OK, or ERROR if it fails.
  97. SYSTEM RESOURCE USAGE
  98. The driver uses cacheDmaMalloc() to allocate memory to share with the 82557.
  99. The size of this area is affected by the configuration parameters specified
  100. in the feiattach() call.  The size of one RFD (Receive Frame Descriptor) is
  101. is the same as one CFD (Command Frame Descriptor): 1536 bytes.  For more
  102. information about RFDs and CFDs, see the
  103. .I "Intel 82557 User's Manual."
  105. Either the shared memory region must be non-cacheable, or else
  106. the hardware must implement bus snooping.  The driver cannot maintain
  107. cache coherency for the device because fields within the command
  108. structures are asynchronously modified by both the driver and the device,
  109. and these fields may share the same cache line.
  111. Additionally, this version of the driver does not handle virtual-to-physical
  112. or physical-to-virtual memory mapping.
  114. TUNING HINTS
  115. The only adjustable parameters are the number of Frame Descriptors that will be
  116. created at run-time.  These parameters are given to the driver when feiattach()
  117. is called.  There is one CFD and one RFD associated with each transmitted
  118. frame and each received frame, respectively.  For memory-limited applications,
  119. decreasing the number of CFDs and RFDs may be desirable.  Increasing the number
  120. of CFDs will provide no performance benefit after a certain point.
  121. Increasing the number of RFDs will provide more buffering before packets are
  122. dropped.  This can be useful if there are tasks running at a higher priority
  123. than the net task.
  125. SEE ALSO: ifLib,
  126. .I "Intel 82557 User's Manual"
  127. */
  130. #include "vxWorks.h"
  131. #include "wdLib.h"
  132. #include "sockLib.h"
  133. #include "memLib.h"
  134. #include "intLib.h"
  135. #include "iosLib.h"
  136. #include "errnoLib.h"
  137. #include "cacheLib.h"
  138. #include "netLib.h"
  139. #include "stdio.h"
  140. #include "stdlib.h"
  141. #include "string.h"
  142. #include "ioctl.h"
  143. #include "net/if.h"
  144. #include "netinet/in.h"
  145. #include "netinet/in_var.h"
  146. #include "net/unixLib.h"
  147. #include "net/if_subr.h"
  148. #include "iv.h"
  149. #include "sysLib.h"
  150. #include "etherLib.h"
  151. #include "vxLib.h"
  152. #include "logLib.h"
  153. #include "taskLib.h"
  154. #include "drv/netif/netifDev.h"
  155. #include "drv/netif/if_fei.h"
  156. #include "drv/pci/pciIntLib.h"
  158. /* defines */
  160. /* Change default to BSD44_DRIVER */
  161.  
  162. #ifndef BSD43_DRIVER
  163. #ifndef BSD44_DRIVER
  164. #   define BSD44_DRIVER
  165. #endif /* BSD44_DRIVER */
  166. #endif /* BSD43_DRIVER */
  167. #undef FEI_DEBUG /* turns on debug output */
  169. #ifdef  FEI_DEBUG
  170. #undef  LOCAL
  171. #define LOCAL
  172. LOCAL BOOL feiDebug = 1;
  173. #endif  /* FEI_DEBUG */
  175. #define FEI_ACTION_TMO 1 /* action command timeout in seconds */
  176. #define FEI_SCB_TMO 1 /* SCB command timeout in seconds */
  177. #define FEI_INIT_TMO 1 /* 557 init timeout in seconds */
  178. #define FEI_TX_RESTART_TMO      1       /* tx restart watchdog timeout */
  179. #define TCB_TX_THRESH 0x10 /* Tx threshold value */
  181. #define BOARD_INT_ENABLE(unit) if ((int)pDrvCtrl->board.intEnable) 
  182. (*pDrvCtrl->board.intEnable)(unit)
  183. #define BOARD_INT_DISABLE(unit) if ((int)pDrvCtrl->board.intDisable) 
  184. (*pDrvCtrl->board.intDisable)(unit)
  185. #define BOARD_INT_ACK(unit) if ((int)pDrvCtrl->board.intAck) 
  186. (*pDrvCtrl->board.intAck)(unit)
  187. #define LOCAL_TO_SYS_ADDR(unit,localAddr) ((int)pDrvCtrl->board.sysLocalToBus? 
  188. (*pDrvCtrl->board.sysLocalToBus)(unit,localAddr):localAddr)
  189. #define SYS_TO_LOCAL_ADDR(unit,sysAddr) ((int)pDrvCtrl->board.sysBusToLocal? 
  190.         (*pDrvCtrl->board.sysBusToLocal)(unit,sysAddr):sysAddr)
  191. #define SYS_INT_CONNECT(vector, routine, parameter) (feiIntConnect 
  192.         ((VOIDFUNCPTR *) vector, routine, (int) parameter)) 
  194. #define I82557_INT_ENABLE pDrvCtrl->pCSR->scbCommand = 0
  195. #define I82557_INT_DISABLE  pDrvCtrl->pCSR->scbCommand = SCB_C_M
  197. /* typedefs */
  199. typedef struct mbuf MBUF;
  200. typedef struct arpcom IDR;
  201. typedef struct ifnet IFNET;
  202. typedef struct sockaddr SOCK;
  204. typedef struct drv_ctrl /* DRV_CTRL */
  205.     {
  206.     IDR idr; /* interface data record */
  207.     BOOL attached; /* interface has been attached */
  208.     CSR * pCSR; /* Control/Status Register ptr */
  209.     CFD * pCFD; /* current Command Frame Descriptor */
  210.     RFD * pRFD; /* current Receive Frame Descriptor */
  211.     RFD * pRFDL; /* first loanable RFD */
  212.  
  213.     WDOG_ID             txRestart;      /* tx restart watchdog */
  214.     BOOL rxHandle; /* rx handler scheduled */
  215.     BOOL                txStall;        /* tx handler stalled - no CFDs */
  217.     /* Board specific routines to manupalate this device */
  218.     BOARD_INFO board;
  220.     } DRV_CTRL;
  222. /* globals */
  224. FUNCPTR feiIntConnect = (FUNCPTR) intConnect; 
  225. IMPORT STATUS sys557Init (int unit, BOARD_INFO *pBoard);
  227. /* locals */
  229. LOCAL DRV_CTRL drvCtrl [FEI_MAX_UNITS];
  230. LOCAL int feiClkRate = 0;
  232. /* forward declarations */
  234. LOCAL STATUS feiInit (int unit);
  235. LOCAL void feiReset (int unit);
  236. LOCAL int feiIoctl (IFNET *pIfNet, int cmd, caddr_t data);
  237. #ifdef BSD43_DRIVER
  238. LOCAL int feiOutput (IDR *pIDR, MBUF *pMbuf, SOCK *pDestAddr);
  239. LOCAL void feiTxStartup (int unit);
  240. #else
  241. LOCAL void feiTxStartup (DRV_CTRL *pDrvCtrl);
  242. #endif
  243. LOCAL void      feiTxRestart (int unit);
  244. LOCAL void feiInt (DRV_CTRL *pDrvCtrl);
  245. LOCAL void feiHandleRecvInt (DRV_CTRL *pDrvCtrl);
  246. LOCAL STATUS feiReceive (DRV_CTRL *pDrvCtrl, RFD *pRfd);
  247. LOCAL void feiLoanFree (DRV_CTRL *pDrvCtrl, RFD *pRfd);
  248. LOCAL STATUS feiNOP (int unit);
  249. LOCAL STATUS feiDiag (int unit);
  250. LOCAL STATUS feiConfig (int unit);
  251. LOCAL STATUS feiIASetup (int unit);
  252. LOCAL UINT16 feiAction (int unit, UINT16 action);
  253. LOCAL STATUS feiSCBCommand (DRV_CTRL *pDrvCtrl, UINT8 cmd, BOOL addrValid,
  254.     UINT32 *addr);
  256. #ifdef  FEI_DEBUG
  257. LOCAL STATUS feiErrCounterDump ( int unit, UINT32 *memAddr);
  258. LOCAL STATUS feiDumpPrint (int unit);
  259. #endif /* FEI_DEBUG */
  261. static int feiMDIWrite ( int unit, int regAddr, int phyAddr, UINT16 writeData);
  262. static int feiMDIRead ( int unit, int regAddr, int phyAddr, UINT16 *retVal);
  263. static int feiPhyInit (int unit);
  264. static int feiMDIPhyConfig ( int unit, int phyAddr);
  265. static int feiMDIPhyLinkSet ( int unit, int phyAddr);
  268. /*******************************************************************************
  269. *
  270. * feiattach - publish the `fei' network interface
  271. *
  272. * This routine publishes the `fei' interface by filling in a network interface
  273. * record and adding the record to the system list.
  274. *
  275. * The 82557 shares a region of main memory with the CPU.  The caller of this
  276. * routine can specify the address of this shared memory region through the
  277. * <memBase> parameter; if <memBase> is set to the constant `NONE', the
  278. * driver will allocate the shared memory region.
  279. *
  280. * If the caller provides the shared memory region, the driver assumes
  281. * that this region does not require cache coherency operations.
  282. *
  283. * If the caller indicates that feiattach() must allocate the shared memory
  284. * region, feiattach() will use cacheDmaMalloc() to obtain a block
  285. * of non-cacheable memory.  The attributes of this memory will be checked,
  286. * and if the memory is not both read and write coherent, feiattach() will
  287. * abort and return ERROR.
  288. *
  289. * A default number of 32 command (transmit) and 32 receive frames can be
  290. * selected by passing zero in the parameters <nCFD> and <nRFD>, respectively.
  291. * If <nCFD> or <nRFD> is used to select the number of frames, the values
  292. * should be greater than two.
  293. *
  294. * A default number of 8 loanable receive frames can be selected by passing
  295. * zero in the parameters <nRFDLoan>, else set <nRFDLoan> to the desired
  296. * number of loanable receive frames.  If <nRFDLoan> is set to -1, no
  297. * loanable receive frames will be allocated/used.
  298. *
  299. * RETURNS: OK, or ERROR if the driver could not be published and initialized.
  300. *
  301. * SEE ALSO: ifLib,
  302. * .I "Intel 82557 User's Manual"
  303. */
  305. STATUS feiattach
  306.     (
  307.     int unit, /* unit number */
  308.     char * memBase, /* address of shared memory (NONE = malloc) */
  309.     int         nCFD,           /* command frames (0 = default) */
  310.     int         nRFD,           /* receive frames (0 = default) */
  311.     int         nRFDLoan        /* loanable rx frames (0 = default, -1 = 0) */
  312.     )
  314.     {
  315.     DRV_CTRL * pDrvCtrl; /* driver control structure pointer */
  316.     WDOG_ID     txWd = NULL;            /* tx restart watchdog */
  317.     CFD * pCFD; /* pointer to CFDs */
  318.     RFD * pRFD; /* pointer to RFDs */
  319.     UINT32 size; /* temporary size holder */
  320.     UINT32 sizeCFD = ROUND_UP (sizeof (CFD), 4);
  321.     UINT32 sizeRFD = ROUND_UP (sizeof (RFD), 4);
  322.     int ix; /* counter */
  323.     char  bucket[2];
  324.     BOOL        memAlloc = FALSE;
  326.     /* sanity check the unit number */
  328.     if (unit < 0 || unit >= FEI_MAX_UNITS)
  329.         return (ERROR);
  331.     pDrvCtrl = &drvCtrl [unit];
  332.     if (pDrvCtrl->attached) /* already attached ? */
  333.         return (ERROR);
  335.     /* initialize the default parameter for the Physical medium layer control*/
  336.     /* user has his chance to override in the BSP, just be CAREFUL */
  337.     pDrvCtrl->board.phyAddr  = 1;
  338.     pDrvCtrl->board.phySpeed = PHY_AUTO_SPEED;
  339.     pDrvCtrl->board.phyDpx   = PHY_AUTO_DPX;
  340.     pDrvCtrl->board.others   = 0;
  341.     pDrvCtrl->board.tcbTxThresh = TCB_TX_THRESH;
  342.     
  343.     /* callout to perform adapter init */
  345.     if (sys557Init (unit, &pDrvCtrl->board) == ERROR)
  346.         return (ERROR);
  348.     /* get CSR address from PCI config space base register */
  350.     if ((int)(pDrvCtrl->pCSR = (CSR *)pDrvCtrl->board.baseAddr) == NULL)
  351.         return (ERROR);
  353.     /* probe for memory-mapped CSR */
  355.     if (vxMemProbe ((char *) &pDrvCtrl->pCSR->scbStatus, VX_READ, 2,
  356. &bucket[0]) != OK)
  357.         {
  358.         printf ("feiattach(): need MMU mapping for address 0x%xn", (UINT32)
  359.     pDrvCtrl->pCSR);
  360. return (ERROR);
  361. }
  363.     I82557_INT_DISABLE; 
  365.     /* initialize the Physical medium layer */
  366.     if (feiPhyInit(unit) != OK)
  367. {
  368. printf("LINK FAILS, Check line connectionn");
  369. }
  371.     if (feiClkRate == 0)
  372. feiClkRate = sysClkRateGet ();
  374.     /* determine number of Command and Receive Frame descriptors to use */
  376.     nCFD     = nCFD ? nCFD : FEI_CFD_DEF;
  377.     nRFD     = nRFD ? nRFD : FEI_RFD_DEF;
  378.     nRFDLoan = nRFDLoan ? nRFDLoan : FEI_RFD_LOAN;
  379.     if (nRFDLoan == -1)
  380.         nRFDLoan = 0;
  382.     /* publish the interface record */
  384. #ifdef BSD43_DRIVER
  385.     ether_attach ((IFNET *) & pDrvCtrl->idr, unit, "fei", (FUNCPTR) feiInit,
  386.         (FUNCPTR) feiIoctl, (FUNCPTR) feiOutput, (FUNCPTR) feiReset);
  387. #else
  388.     ether_attach (
  389.                  (IFNET *) & pDrvCtrl->idr, 
  390.                  unit, 
  391.                  "fei", 
  392.                  (FUNCPTR) feiInit,
  393.                  (FUNCPTR) feiIoctl, 
  394.                  (FUNCPTR) ether_output,
  395.                  (FUNCPTR) feiReset
  396.                  );
  398.     pDrvCtrl->idr.ac_if.if_start = (FUNCPTR)feiTxStartup;
  399. #endif
  401.     /* calculate the total size of 82557 memory pool */
  403.     size = (sizeRFD * (nRFD + nRFDLoan)) + (sizeCFD * nCFD);
  405.     /*
  406.      * Establish the memory area that we will share with the device.  If
  407.      * the caller has provided an area, then we assume it is non-cacheable.
  408.      * If the caller did not provide an area, then we must obtain it from
  409.      * the system, using the cache savvy allocation routine.
  410.      */
  412.     if (memBase == (char *) NONE) /* allocate on our own */
  413. {
  414.         /* this driver doesn't handle incoherent caches */
  416.         if (!CACHE_DMA_IS_WRITE_COHERENT () || !CACHE_DMA_IS_READ_COHERENT ())
  417.             {
  418.             printf ("feiattach: shared memory not cache coherentn");
  419.             goto error;
  420.             }
  422.         if ((memBase = cacheDmaMalloc (size)) == NULL)
  423.             {
  424.             printf ("feiattach: could not obtain memoryn");
  425.             goto error;
  426.             }
  428.         memAlloc = TRUE;
  429.         }
  431.     bzero (memBase, size);              /* zero out entire region */
  433.     /* carve up the shared-memory region */
  435.     /*
  436.      * N.B.
  437.      * We are setting up the CFD list as a ring of TxCBs, tied off with a
  438.      * CFD_C_SUSP as frames are copied into the data buffers.  The
  439.      * susp/resume model is used because the links to the next CFDs do
  440.      * not change -- it is a fixed ring.  Also note that if a CFD is needed
  441.      * for anything else (e.g., DIAG, NOP, DUMP, CONFIG, or IASETUP comands),
  442.      * then the commands will use the current CFD in the list.  After the
  443.      * command is complete, it will be set back to a TxCB by feiAction().
  444.      */
  446.     /* First ready CFD pointer */
  447.     pDrvCtrl->pCFD = pCFD = (CFD *) memBase;
  449.     /* initialize the CFD ring */
  450.     for (ix = 0; ix < nCFD; ix++, pCFD++)
  451. {
  452. pCFD->cfdStatus = CFD_S_COMPLETE | CFD_S_OK;  
  454.         /* System bus address to link field */
  455. LINK_WR (&pCFD->link, 
  456.             LOCAL_TO_SYS_ADDR(unit,((UINT32) pCFD + sizeCFD)) );
  458. /* Previous CFD pointer */
  459.         pCFD->pPrev = (CFD *) ((UINT32) pCFD - sizeCFD);
  461. LINK_WR (&pCFD->cfdTcb.pTBD, 0xffffffff); /* no TBDs used */
  462. pCFD->cfdTcb.txThresh = pDrvCtrl->board.tcbTxThresh;
  463. pCFD->cfdTcb.tbdNum = 0;
  464. }
  465.     pCFD--;
  466.     LINK_WR (&pCFD->link, LOCAL_TO_SYS_ADDR(unit,(UINT32)pDrvCtrl->pCFD) )
  467.         ; /* tie end of CFD ring, use system bus address */
  468.     pDrvCtrl->pCFD->pPrev = pCFD;
  470.     /*
  471.      * N.B.
  472.      * Use RFD_C_EL to tie the end of the RBD ring, and not RFD_C_SUSP
  473.      * This is because we want the option of inserting a new RFD into
  474.      * the ring on the fly (i.e., via an SCB_RUSTART command).  Why would
  475.      * we do this?  Buffer loaning....  A suspend/resume reception model
  476.      * will not allow us to do this, so we must use an idle/start model.
  477.      */
  479.     /* first ready RFD pointer */
  480.     pDrvCtrl->pRFD = pRFD = (RFD *) ((UINT32) pCFD + sizeCFD);
  482.     /*initialize the RFD ring,some of the fields will be done later in feiInit*/
  483.     for (ix = 0; ix < nRFD; ix++, pRFD++)
  484. {
  485. /* system bus address to link field */
  486. LINK_WR (&pRFD->link,
  487.             LOCAL_TO_SYS_ADDR(unit, ((UINT32) pRFD + sizeRFD)) );
  489.         /* previous RFD pointer */
  490.         pRFD->pPrev = (RFD *) ((UINT32) pRFD - sizeRFD);
  491. LINK_WR (&pRFD->pRBD, 0xffffffff); /* no RBDs used */
  492. pRFD->bufSize = ETHERMTU + EH_SIZE;
  493. pRFD->refCnt = 0;
  494.         pRFD->actualCnt = 0;
  495.         }
  496.     pRFD--;
  497.     LINK_WR (&pRFD->link,LOCAL_TO_SYS_ADDR(unit,(UINT32)pDrvCtrl->pRFD) )
  498.         ; /* tie end of RFD ring, use system bus address */
  499.     pDrvCtrl->pRFD->pPrev = pRFD;
  501.     /* initialize the RFD loanable buffers  */
  502.     pDrvCtrl->pRFDL = NULL;
  503.     pRFD++;
  504.     for (ix = 0; ix < nRFDLoan; ix++, pRFD++)
  505. {
  506. pRFD->rfdStatus = 0;
  507. pRFD->rfdCommand = 0;
  508. LINK_WR (&pRFD->pRBD, 0xffffffff); /* no RBDs used */
  509. pRFD->bufSize = ETHERMTU + EH_SIZE;
  510. pRFD->refCnt = 0;
  511. pRFD->actualCnt = 0;
  512.         pRFD->pPrev = pDrvCtrl->pRFDL;          /* link into head of list */
  513.         pDrvCtrl->pRFDL = pRFD;
  514.         }
  516.     if ((pDrvCtrl->txRestart = txWd = wdCreate ()) == NULL)
  517.         goto error;
  519.     feiReset (unit); /* reset the chip */
  521.     /* CU and RU should be idle following feiReset() */
  523.     if (feiSCBCommand (pDrvCtrl, SCB_C_CULDBASE, TRUE, 0x0) == ERROR)
  524.         goto error;
  526.     if (feiSCBCommand (pDrvCtrl, SCB_C_RULDBASE, TRUE, 0x0) == ERROR)
  527.         goto error;
  529.      /* connect the interrupt handler */
  531.     if (pDrvCtrl->board.vector)
  532.         {
  533.         if (SYS_INT_CONNECT(INUM_TO_IVEC (pDrvCtrl->board.vector), 
  534.                                 feiInt, pDrvCtrl) == ERROR)
  535.             goto error;
  536.         }
  538.     /* get our ethernet hardware address */
  540.     bcopy ((char *)pDrvCtrl->board.enetAddr, (char *) pDrvCtrl->idr.ac_enaddr, 
  541.    sizeof (pDrvCtrl->board.enetAddr));
  543.     if (feiDiag (unit) == ERROR) /* run diagnostics */
  544. goto error;
  546.     if (feiIASetup (unit) == ERROR) /* setup address */
  547. goto error;
  549.     if (feiConfig (unit) == ERROR) /* configure chip */
  550. goto error;
  552.     pDrvCtrl->rxHandle = FALSE;
  553.     pDrvCtrl->txStall = FALSE;
  554.     pDrvCtrl->attached = TRUE;
  556.     if (feiInit (unit) == ERROR)
  557.         goto error;
  558.  
  559.     return (OK);
  561. error: /* error cleanup */
  562.         {
  563.         if (memAlloc)
  564.             cacheDmaFree (memBase);
  566.         if (txWd)
  567.             wdDelete (txWd);
  569.         return (ERROR);
  570.         }
  571.     }
  573. /*******************************************************************************
  574. *
  575. * feiInit - initialize the 82557 device
  576. *
  577. * This routine initializes the 82557 device and brings it up to an operational
  578. * state.  The driver must have already been attached with the feiattach()
  579. * routine.
  580. *
  581. * This routine is called at boot time and by feiWatchDog() if a reset is
  582. * required.
  583. *
  584. * RETURNS: OK, or ERROR if the device could not be initialized.
  585. */
  587. LOCAL STATUS feiInit 
  588.     (
  589.     int unit /* unit number */
  590.     )
  591.     {
  592.     DRV_CTRL *  pDrvCtrl = &drvCtrl [unit];
  593.     RFD *       pRFD;
  594.     UINT16      event;
  595.     int         ix;
  597.     if (!pDrvCtrl->attached)            /* must have been attached */
  598.         return (ERROR);
  600.     /* wait for the receive handler to catch up to the [reset] 557 */
  602.     for (ix = (FEI_INIT_TMO * feiClkRate); --ix;)
  603.         {
  604.         if (!pDrvCtrl->rxHandle)
  605.             break;
  607.         taskDelay (1);
  608.         }
  610.     if (!ix)
  611.         return (ERROR);
  613.     /* initiailize RFD ring */
  615.     pRFD = pDrvCtrl->pRFD;
  617.     do {
  618.         pRFD->rfdStatus = 0;
  619.         pRFD->rfdCommand = 0;
  620.         pRFD = (RFD *) SYS_TO_LOCAL_ADDR(unit,(UINT32)LINK_RD (&pRFD->link));
  621.         } while (pRFD != pDrvCtrl->pRFD);
  623.     pRFD->pPrev->rfdCommand = RFD_C_EL;
  625.     if (feiNOP (unit) == ERROR)         /* put CU into suspended state */
  626.         return (ERROR);
  628.     event = pDrvCtrl->pCSR->scbStatus;  /* save int events */
  629.     pDrvCtrl->pCSR->scbStatus = event;
  631.     BOARD_INT_ACK(unit);   /* acknowledge interrupts */
  633.     I82557_INT_ENABLE;
  634.     BOARD_INT_ENABLE(unit);         /* enable interrupts at system */
  636.     /* mark the interface as up */
  638. #ifdef BSD43_DRIVER
  639.     pDrvCtrl->idr.ac_if.if_flags |= (IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);
  640. #else
  641.     pDrvCtrl->idr.ac_if.if_flags |= (IFF_MULTICAST| IFF_UP | IFF_RUNNING
  642.     | IFF_NOTRAILERS);
  643. #endif
  645.     /* startup the receiver */
  647.     if (feiSCBCommand (pDrvCtrl, SCB_C_RUSTART, TRUE,
  648.         (UINT32 *)LOCAL_TO_SYS_ADDR(unit, (UINT32) pRFD) ) == ERROR)
  649.         return (ERROR);
  651.     return (OK);
  652.     }
  654. /*******************************************************************************
  655. *
  656. * feiReset - reset the `fei' interface
  657. *
  658. * This routine marks the interface as inactive and resets the chip.  It brings
  659. * down the interface to a non-operational state.  To bring the interface back
  660. * up, feiInit() must be called.
  661. *
  662. * RETURNS: N/A
  663. */
  665. LOCAL void feiReset
  666.     (
  667.     int unit /* unit number of interface */
  668.     )
  669.     {
  670.     DRV_CTRL * pDrvCtrl = &drvCtrl [unit];
  672.     BOARD_INT_DISABLE(unit);     /* disable system interrupt */
  674.     I82557_INT_DISABLE;          /* disable chip interrupt   */
  676.     /* mark the interface as down */
  678.     pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
  680.     /* issue a selective reset to the 82557 chip */
  682.     PORT_WR (&pDrvCtrl->pCSR->port, FEI_PORT_SELRESET);
  684.     taskDelay (2); /* wait for the reset... */
  685.     }
  687. /*******************************************************************************
  688. *
  689. * feiIoctl - interface control request routine
  690. *
  691. * This routine processes the interface's ioctl() request.
  692. *
  693. * RETURNS: OK, or EINVAL if <cmd> is not recognized.
  694. */
  696. LOCAL int feiIoctl
  697.     (
  698.     IFNET * pIfNet, /* interface to act upon */
  699.     int cmd, /* command to process */
  700.     caddr_t data /* command-specific data */
  701.     )
  702.     {
  703.     DRV_CTRL *  pDrvCtrl = & drvCtrl [pIfNet->if_unit];
  704.     int retVal = OK;
  705.     int s = splimp (); /* not taken in some calling funcs */
  707.     switch (cmd)
  708.         {
  709.         case SIOCSIFADDR: /* set interface address */
  710. #ifdef BSD43_DRIVER
  711.             retVal = set_if_addr (pIfNet, data, pDrvCtrl->idr.ac_enaddr);
  712. #else
  713.             ((struct arpcom *)pIfNet)->ac_ipaddr = IA_SIN (data)->sin_addr;
  714.             arpwhohas ((struct arpcom *) pIfNet, &IA_SIN (data)->sin_addr);
  715. #endif
  716.             break;
  718.         case SIOCSIFFLAGS: /* set interface flags */
  719.             break;
  721. #ifdef BSD44_DRIVER
  722.         case SIOCADDMULTI:
  723.         case SIOCDELMULTI:
  724.             pDrvCtrl->idr.ac_if.if_flags |= IFF_PROMISC;
  725.             retVal = OK;
  726.             break;
  727. #endif
  728.             
  729.         default:
  730.             retVal = EINVAL;
  731.         }
  733.     splx (s);
  734.     return (retVal);
  735.     }
  737. #ifdef BSD43_DRIVER
  738. /*******************************************************************************
  739. *
  740. * feiOutput - interface output routine
  741. *
  742. * This routine simply calls ether_output().  ether_output() resolves
  743. * the hardware addresses and calls feiTxStartup() with the unit number
  744. * passed as an argument.
  745. *
  746. * RETURNS: OK if successful, otherwise `errno'.
  747. */
  749. LOCAL int feiOutput
  750.     (
  751.     IDR * pIDR,
  752.     MBUF * pMbuf,
  753.     SOCK * pDestAddr
  754.     )
  755.     {
  756.     return (ether_output ((IFNET *) pIDR, pMbuf, pDestAddr,
  757. (FUNCPTR) feiTxStartup, pIDR));
  758.     }
  759. #endif
  761. /*******************************************************************************
  762. *
  763. * feiTxStartup - transmit frames on the device
  764. *
  765. * Look for packets on the IP output queue; output frames if there is anything
  766. * there.
  767. *
  768. * This routine is called from several possible threads.  Each will be described
  769. * below.
  770. *
  771. * The first (and most common thread) is when a user task requests the
  772. * transmission of data.  Under BSD 4.3, this will cause feiOutput() to be  
  773. * called, which will cause ether_output() to be called, which will cause this 
  774. * routine to be called (usually). This routine will not be called if  
  775. * ether_output() finds that our interface output queue is full.  In this case, 
  776. * the outgoing data will be thrown out. BSD 4.4 uses a slight different model
  777. * in which the generic ether_output() is called directly, followed by a call 
  778. * to this routine.
  779. *
  780. * The second, and most obscure thread, is when the reception of certain
  781. * packets causes an immediate (attempted) response.  For example, ICMP echo
  782. * packets (ping), and ICMP "no listener on that port" notifications.  All
  783. * functions in this driver that handle the reception side are executed in the
  784. * context of netTask().  Always.  So, in the case being discussed, netTask()
  785. * will receive these certain packets, cause IP to be stimulated, and cause the
  786. * generation of a response to be sent.  We then find ourselves following the
  787. * first thread explained above, with the important distinction that the
  788. * context is that of netTask().
  789. *
  790. * The third thread occurs when this routine runs out of CFDs and returns.  If
  791. * this occurs when our output queue is not empty, this routine would typically
  792. * not get called again until new output was requested.  Even worse, if the
  793. * output queue was also full, this routine would never get called again and
  794. * we would have a lock state.  It DOES happen.  To guard against this,
  795. * we turn on a watchdog timer to scedule us again after an appropriate timeout.
  796. *
  797. * Note that this function is ALWAYS called between an splnet() and an splx().
  798. * This is true because netTask(), and ether_output() take care of
  799. * this when calling this function.  Therefore, no calls to these spl functions
  800. * are needed anywhere in this output thread.  Thus, mutual exclusion is
  801. * guaranteed.
  802. *
  803. * RETURNS: N/A
  804. */
  806. LOCAL void feiTxStartup
  807.     (
  808. #ifdef BSD43_DRIVER
  809.     int unit
  810. #else
  811.     DRV_CTRL *  pDrvCtrl 
  812. #endif
  813.     )
  814.     {
  815. #ifdef BSD43_DRIVER
  816.     DRV_CTRL * pDrvCtrl = &drvCtrl [unit];
  817. #else
  818.     int unit = pDrvCtrl->idr.ac_if.if_unit;
  819. #endif
  820.     CFD *pCFD = pDrvCtrl->pCFD;
  821.     CFD *pCFDNext;
  822.     MBUF * pMbuf;
  823.     int length;
  824.     int status = OK;
  826.     /* loop until no more tx packets or we are out of tx resources */
  828.     while (pDrvCtrl->idr.ac_if.if_snd.ifq_head)
  829.         {
  830.         pCFDNext = (CFD *) SYS_TO_LOCAL_ADDR(unit,(UINT32)LINK_RD(&pCFD->link));
  832.         if (!(pCFDNext->cfdStatus & CFD_S_COMPLETE)) /* next CFD free ? */
  833.             {
  834.             pDrvCtrl->txStall = TRUE;
  836.             wdStart (pDrvCtrl->txRestart, FEI_TX_RESTART_TMO * feiClkRate,
  837.                 (FUNCPTR) feiTxRestart, unit);
  839.             break;
  840.             }
  842.         if (pDrvCtrl->txStall)
  843.             wdCancel (pDrvCtrl->txRestart);
  845.         IF_DEQUEUE (&pDrvCtrl->idr.ac_if.if_snd, pMbuf); /* dequeue a packet */
  847.         copy_from_mbufs (pCFD->cfdTcb.enetHdr, pMbuf, length);
  849.         length = max (ETHERSMALL, length); /* short frames are padded */
  851.         if ((etherOutputHookRtn != NULL) && (*etherOutputHookRtn)
  852.             (&pDrvCtrl->idr, pCFD->cfdTcb.enetHdr, length))
  853.             continue; /* hook routine ate packet */
  855. /* get frame ready for transmission */
  857.         pCFD->cfdTcb.count = (length & 0x3fff) | TCB_CNT_EOF;
  858. pCFD->cfdStatus = 0;
  859. pCFD->cfdCommand = CFD_C_XMIT | CFD_C_SUSP;
  860. pCFD->pPrev->cfdCommand &= ~CFD_C_SUSP; /* hook frame into CBL */
  862. /* undates the first ready RFD pointer */
  863. pDrvCtrl->pCFD =
  864.     (CFD *)SYS_TO_LOCAL_ADDR(unit,(UINT32)LINK_RD(&pCFD->link) );
  866.         /* Bump the statistic counter. */
  868.         pDrvCtrl->idr.ac_if.if_opackets++;
  870. /* resume CU operation ? (check suspended, not sent yet, cmd return) */
  872. if (((pDrvCtrl->pCSR->scbStatus & SCB_S_CUMASK) == SCB_S_CUSUSP) &&
  873.     (pCFD->cfdStatus == 0) )
  874.     {
  875.     status =feiSCBCommand (pDrvCtrl, SCB_C_CURESUME, FALSE, 0);
  877.     if (status == ERROR)
  878.         break;
  879.             }
  882.         }
  883.         /* make sure the last CFD is  transmitted */            
  884.         if (pCFD->cfdStatus == 0)
  885.             feiSCBCommand (pDrvCtrl, SCB_C_CURESUME, FALSE, 0);
  886.     }
  888. /*******************************************************************************
  889. *
  890. * feiTxRestart - reschedule transmit processing
  891. *
  892. * Reschedule transmit processing because we previously had no available
  893. * CFDs.
  894. *
  895. * RETURNS: N/A
  896. */
  898. LOCAL void feiTxRestart
  899.     (
  900.     int         unit
  901.     )
  902.     {
  903.     DRV_CTRL *  pDrvCtrl = &drvCtrl [unit];
  905.     pDrvCtrl->txStall = FALSE;
  906. #ifdef BSD43_DRIVER
  907.     (void) netJobAdd ((FUNCPTR) feiTxStartup, unit, 0, 0, 0, 0);
  908. #else
  909.     (void) netJobAdd ((FUNCPTR) feiTxStartup, (int)pDrvCtrl, 0, 0, 0, 0);
  910. #endif
  911.     }
  913. /*******************************************************************************
  914. *
  915. * feiInt - entry point for handling interrupts from the 82557
  916. *
  917. * The interrupting events are acknowledged to the device, so that the device
  918. * will de-assert its interrupt signal.  The amount of work done here is kept
  919. * to a minimum; the bulk of the work is defered to the netTask.
  920. *
  921. * RETURNS: N/A
  922. */
  924. LOCAL void feiInt
  925.     (
  926.     DRV_CTRL * pDrvCtrl
  927.     )
  928.     {
  929.     UINT16 event;
  930.     int unit = pDrvCtrl->idr.ac_if.if_unit;
  932.     event = pDrvCtrl->pCSR->scbStatus; /* save int events */
  934.     if ((event & SCB_S_STATMASK) == 0)
  935.         {
  936.         /* This device was not the cause of the shared int */
  937.  
  938.         return; 
  939.         }
  940.  
  941.     /* clear chip level interrupt pending */
  942.     pDrvCtrl->pCSR->scbStatus = (event&SCB_S_STATMASK); 
  944.     /* board level interrupt acknowledge */
  945.     BOARD_INT_ACK(unit);
  947. #ifdef FEI_DEBUG
  948.     if (feiDebug)
  949.         logMsg ("feiInt: event 0x%x, scbStatus 0x%xn", event, 
  950.      pDrvCtrl->pCSR->scbStatus, 0, 0, 0, 0);
  951. #endif /* FEI_DEBUG */
  953.     /* handle receive interrupts */
  955.     if ( (event & SCB_S_FR) && !(pDrvCtrl->pCSR->scbCommand & SCB_C_M)) 
  956. {
  957.         I82557_INT_DISABLE;
  958.         pDrvCtrl->rxHandle = TRUE;
  960.         (void) netJobAdd ((FUNCPTR) feiHandleRecvInt, (int) pDrvCtrl,
  961.             0, 0, 0, 0);
  962.         }
  963.     }
  964.     
  965. /*******************************************************************************
  966. *
  967. * feiHandleRecvInt - service task-level interrupts for receive frames
  968. *
  969. * This routine is run in netTask's context.  The ISR scheduled
  970. * this routine so that it could handle receive packets at task level.
  971. *
  972. * RETURNS: N/A
  973. */
  975. LOCAL void feiHandleRecvInt
  976.     (
  977.     DRV_CTRL * pDrvCtrl
  978.     )
  979.     {
  980.     RFD * pRFD = pDrvCtrl->pRFD;
  981.     RFD * pRFDNew;
  982.     int unit = pDrvCtrl->idr.ac_if.if_unit;
  984.     while (pRFD->rfdStatus & RFD_S_COMPLETE)   /* while packets to process */
  985.         {
  987.         pDrvCtrl->rxHandle = TRUE;             /* interlock with eiInt() */
  988. if (!(pRFD->rfdStatus & RFD_S_OK))
  989.     pDrvCtrl->idr.ac_if.if_ierrors++;
  990. else
  991.     {
  992.     if (feiReceive (pDrvCtrl, pRFD) == ERROR)
  993. {
  995. /* buffer loaning was done */
  997.                 pRFDNew = pDrvCtrl->pRFDL;
  998.                 pDrvCtrl->pRFDL = pRFDNew->pPrev;
  1000. LINK_WR (&pRFD->pPrev->link, 
  1001.     LOCAL_TO_SYS_ADDR(unit,(UINT32)pRFDNew));
  1003. LINK_WR (&pRFDNew->link, LINK_RD (&pRFD->link));
  1004. pRFDNew->pPrev = pRFD->pPrev;
  1005. pRFD = (RFD *) SYS_TO_LOCAL_ADDR(unit,
  1006.     (UINT32)LINK_RD (&pRFD->link));
  1008. pRFD->pPrev = pRFDNew;
  1009. pRFD = pRFDNew;
  1010. }
  1011.     }
  1013.         pRFD->rfdStatus = 0;
  1014.         pRFD->rfdCommand = RFD_C_EL;            /* chip can have it.... */
  1015. pRFD->pPrev->rfdCommand &= ~RFD_C_EL;   /* hook frame into CBL */
  1017.         pRFD = (RFD *) SYS_TO_LOCAL_ADDR(unit,(UINT32)LINK_RD (&pRFD->link) )
  1018.             ;   /* bump to next RFD in ring */
  1020.         pDrvCtrl->pCSR->scbStatus &= (SCB_S_FR | SCB_S_RNR);
  1021.         }
  1023.     pDrvCtrl->pRFD = pRFD;                      /* keep track of current RFD */
  1025.     /* kick receiver (if needed) */
  1027.     if ((pDrvCtrl->pCSR->scbStatus & SCB_S_RUMASK) != SCB_S_RURDY)
  1028.         {
  1029.         if (feiSCBCommand (pDrvCtrl, SCB_C_RUSTART, TRUE, 
  1030.                     (UINT32 *)LOCAL_TO_SYS_ADDR(unit, (UINT32)pRFD)) == ERROR)
  1031.             {
  1032.     pDrvCtrl->rxHandle = FALSE;
  1033.             return;
  1034.     }
  1036.         while ((pDrvCtrl->pCSR->scbCommand)&SCB_C_RUMASK)
  1037.             ;      /* wait for RUSTART accept */
  1038.         }
  1040.     pDrvCtrl->rxHandle = FALSE;
  1042.     /* re-enable receiver interrupts */
  1043.     I82557_INT_ENABLE;
  1044.     }
  1046. /*******************************************************************************
  1047. *
  1048. * feiReceive - pass a received frame to the next layer up
  1049. *
  1050. * Strips the Ethernet header and passes the packet to the appropriate
  1051. * protocol.  The return value indicates if buffer loaning was used to hold
  1052. * the data.  A return value of OK means that loaning was not done.
  1053. *
  1054. * RETURNS: OK, or ERROR if buffer-loaning the RFD.
  1055. */
  1057. LOCAL STATUS feiReceive
  1058.     (
  1059.     DRV_CTRL * pDrvCtrl,
  1060.     RFD * pRFD
  1061.     )
  1062.     {
  1063.     struct ether_header * pEh;
  1064.     u_char * pData;
  1065.     int len;
  1066.     UINT16 etherType;
  1067.     MBUF * pMbuf = NULL;
  1068.     STATUS retVal = OK;
  1070.     len = pRFD->actualCnt & 0x3fff; /* get frame length */
  1071.     pEh = (struct ether_header *)pRFD->enetHdr; /* get ptr to ethernet header */
  1073.     pDrvCtrl->idr.ac_if.if_ipackets++;          /* bump statistic */
  1075.     /* call hook routine if one is connected */
  1077.     if ((etherInputHookRtn != NULL) && ((*etherInputHookRtn)
  1078. (& pDrvCtrl->idr.ac_if, (char *) pEh, len)))
  1079.         return (OK);
  1081.     len -= EH_SIZE;
  1082.     if (len <= 0)
  1083. {
  1084. pDrvCtrl->idr.ac_if.if_ierrors++;           /* bump error stat */
  1085.         pDrvCtrl->idr.ac_if.if_ipackets--;          /* fix statistic */
  1086. return (OK);
  1087. }
  1089.     pData = (u_char *) pRFD->enetData;
  1090.     etherType = ntohs (pEh->ether_type);
  1092.     if ((pDrvCtrl->pRFDL != NULL) && (USE_CLUSTER (len)) &&
  1093.         ((pMbuf = build_cluster (pData, len, (struct ifnet *) &pDrvCtrl->idr, 
  1094.  MC_FEI, &pRFD->refCnt, (FUNCPTR) feiLoanFree, 
  1095.  (int) pDrvCtrl, (int) pRFD, NULL)) 
  1096.  != NULL))
  1097.         retVal = ERROR; /* we loaned a frame */
  1098.     else
  1099.         pMbuf = copy_to_mbufs (pData, len, 0, 
  1100.        (struct ifnet *) &pDrvCtrl->idr);
  1102.     if (pMbuf != NULL)
  1103. {
  1104. #ifdef BSD43_DRIVER
  1105.         do_protocol_with_type (etherType, pMbuf, &pDrvCtrl->idr, len);
  1106. #else
  1107.         do_protocol (pEh, pMbuf, &pDrvCtrl->idr, len);
  1108. #endif
  1109. }
  1110.     else
  1111. {
  1112. pDrvCtrl->idr.ac_if.if_ierrors++;           /* bump error stat */
  1113.         pDrvCtrl->idr.ac_if.if_ipackets--;          /* fix statistic */
  1114. }
  1116.     return (retVal);
  1117.     }
  1119. /*******************************************************************************
  1120. *
  1121. * feiLoanFree - return a loaned receive frame descriptor
  1122. *
  1123. * This routine is called by the protocol code when it has completed use of
  1124. * an RFD that we loaned to it.
  1125. *
  1126. * RETURNS: N/A
  1127. */
  1129. LOCAL void feiLoanFree
  1130.     (
  1131.     DRV_CTRL * pDrvCtrl,
  1132.     RFD * pRFD
  1133.     )
  1134.     {
  1135.     pRFD->refCnt = 0; /* should already be zero... */
  1137.     pRFD->pPrev = pDrvCtrl->pRFDL;
  1138.     pDrvCtrl->pRFDL = pRFD;
  1139.     }
  1141. /*******************************************************************************
  1142. *
  1143. * feiNOP - format and issue a NOP command
  1144. *
  1145. * RETURNS: OK, or ERROR if the NOP command failed.
  1146. */
  1148. LOCAL STATUS feiNOP
  1149.     (
  1150.     int unit
  1151.     )
  1152.     {
  1153.     if (!(feiAction (unit, CFD_C_NOP) & CFD_S_OK))
  1154. return (ERROR);
  1156.     return (OK);
  1157.     }
  1159. /*******************************************************************************
  1160. *
  1161. * feiDiag - format and issue a diagnostic command
  1162. *
  1163. * RETURNS: OK, or ERROR if the diagnostic command failed.
  1164. */
  1166. LOCAL STATUS feiDiag
  1167.     (
  1168.     int unit
  1169.     )
  1170.     {
  1171.     UINT16 stat;
  1173.     if (((stat = feiAction (unit, CFD_C_DIAG)) &
  1174.         (CFD_S_OK | CFD_S_DIAG_F)) != CFD_S_OK)
  1175.         {
  1176. #ifdef  FEI_DEBUG
  1177.         if (feiDebug)
  1178.             printf ("if_fei.c: 82557 diagnostics failed, cfdStatus 0x%xn",
  1179.                 stat);
  1180. #endif  /* FEI_DEBUG */
  1181.         return (ERROR);
  1182.         }
  1184.     return (OK);
  1185.     }
  1187. /*******************************************************************************
  1188. *
  1189. * feiConfig - format and issue a config command
  1190. *
  1191. * RETURNS: OK, or ERROR if the config command failed.
  1192. */
  1194. LOCAL STATUS feiConfig
  1195.     (
  1196.     int unit
  1197.     )
  1198.     {
  1199.     DRV_CTRL * pDrvCtrl = & drvCtrl [unit];
  1200.     CFD * pCFD = pDrvCtrl->pCFD;
  1202.     /* set to config values recommeded by the i82557 User's Manual */
  1204.     pCFD->cfdConfig.ccByte0  = 0x16;
  1205.     pCFD->cfdConfig.ccByte1  = 0x88;  /* 0x08;  */
  1206.     pCFD->cfdConfig.ccByte2  = 0x00;
  1207.     pCFD->cfdConfig.ccByte3  = 0x00;
  1208.     pCFD->cfdConfig.ccByte4  = 0x00;   /* 0x00; */
  1209.     pCFD->cfdConfig.ccByte5  = 0x00;   /* 0x80; */
  1210.     pCFD->cfdConfig.ccByte6  = 0x38;   /* save bad frame,no TNO 0x3a; */
  1211.     pCFD->cfdConfig.ccByte7  = 0x03;   
  1212.     pCFD->cfdConfig.ccByte8  = 0x01; /* MII operation */
  1213.     pCFD->cfdConfig.ccByte9  = 0x00;
  1214.     pCFD->cfdConfig.ccByte10 = 0x2e;
  1215.     pCFD->cfdConfig.ccByte11 = 0x00;    
  1216.     pCFD->cfdConfig.ccByte12 = 0x60;
  1217.     pCFD->cfdConfig.ccByte13 = 0x00;
  1218.     pCFD->cfdConfig.ccByte14 = 0xf2;
  1219.     if (pDrvCtrl->idr.ac_if.if_flags & IFF_PROMISC)
  1220.         pCFD->cfdConfig.ccByte15 = 0x49;     /* 0x49;  */
  1221.     else
  1222.         pCFD->cfdConfig.ccByte15 = 0x48;     /* 0x49 PROMISC;  */
  1223.     pCFD->cfdConfig.ccByte16 = 0x00;
  1224.     pCFD->cfdConfig.ccByte17 = 0x40;
  1225.     pCFD->cfdConfig.ccByte18 = 0xf2;
  1226. if (pDrvCtrl->board.phyDpx != PHY_HALF_DPX)
  1227.     pCFD->cfdConfig.ccByte19 = 0x80;
  1228. else
  1229.     pCFD->cfdConfig.ccByte19 = 0x00; /*c0 force full deplex    0x80;   */
  1231.     pCFD->cfdConfig.ccByte20 = 0x3f;
  1232.     pCFD->cfdConfig.ccByte21 = 0x05;
  1234.     if (!(feiAction (unit, CFD_C_CONFIG) & CFD_S_OK))
  1235. return (ERROR);
  1237.     return (OK);
  1238.     }
  1240. /*******************************************************************************
  1241. *
  1242. * feiIASetup - format and issue an interface address command
  1243. *
  1244. * RETURNS: OK, or ERROR if the address command failed.
  1245. */
  1247. LOCAL STATUS feiIASetup
  1248.     (
  1249.     int unit
  1250.     )
  1251.     {
  1252.     DRV_CTRL * pDrvCtrl = & drvCtrl [unit];
  1254.     bcopy ((char *) pDrvCtrl->idr.ac_enaddr,
  1255. (char *) pDrvCtrl->pCFD->cfdIASetup.ciAddress, 6);
  1257.     if (!(feiAction (unit, CFD_C_IASETUP) & CFD_S_OK))
  1258. return (ERROR);
  1260.     return (OK);
  1261.     }
  1263. /*******************************************************************************
  1264. *
  1265. * feiAction - execute the specified action command
  1266. *
  1267. * This routine executes the specified action
  1268. *
  1269. * We do the command contained in the CFD synchronously, so that we know
  1270. * it's complete upon return.
  1271. *
  1272. * RETURNS: The status return of the action command, or 0 on failure.
  1273. */
  1275. LOCAL UINT16 feiAction
  1276.     (
  1277.     int unit,
  1278.     UINT16 action
  1279.     )
  1280.     {
  1281.     DRV_CTRL * pDrvCtrl = & drvCtrl [unit];
  1282.     CFD * pCFD = pDrvCtrl->pCFD;
  1283.     UINT16 retVal = 0;
  1284.     int ix;
  1285.     UINT8       state;
  1287.     if (!(pCFD->cfdStatus & CFD_S_COMPLETE)) /* next CFD free ? */
  1288. return (0);
  1290.     /* fill in CFD */
  1292.     pCFD->cfdStatus = 0; /* clear status */
  1293.     pCFD->cfdCommand = action | CFD_C_SUSP; /* fill in action */
  1294.     pCFD->pPrev->cfdCommand &= ~CFD_C_SUSP; /* hook into CBL */
  1296.     pDrvCtrl->pCFD = (CFD *) SYS_TO_LOCAL_ADDR(unit,
  1297. (UINT32)LINK_RD(&pCFD->link) ); /* bump current CFD */
  1300.     /* check CU operation -- kick if needed */
  1302.     if ((((state = pDrvCtrl->pCSR->scbStatus) & SCB_S_CUMASK) != SCB_S_CUACTIVE)
  1303.         && (pCFD->cfdStatus == 0))
  1304.         {
  1305.         if (state == SCB_S_CUIDLE)
  1306.             {
  1307.             if (feiSCBCommand (pDrvCtrl, SCB_C_CUSTART, TRUE,
  1308.                 (UINT32 *) LOCAL_TO_SYS_ADDR(unit,(UINT32)pCFD) ) == ERROR)
  1309.                 {
  1310. #ifdef  FEI_DEBUG
  1311.                 if (feiDebug)
  1312.                     printf ("feiAction: feiSCBCommand failedn");
  1313. #endif  /* FEI_DEBUG */
  1314.                 goto errorAction;
  1315.                 }
  1316.             }
  1317.         else
  1318.             {
  1319.             if (feiSCBCommand (pDrvCtrl, SCB_C_CURESUME, FALSE, 0x0) == ERROR)
  1320.                 {
  1321. #ifdef  FEI_DEBUG
  1322.                 if (feiDebug)
  1323.                     printf ("feiAction: feiSCBCommand failedn");
  1324. #endif  /* FEI_DEBUG */
  1325.                 goto errorAction;
  1326.                 }
  1327.             }
  1328.         }
  1330.     /* wait for command to complete */
  1332.     for (ix = (FEI_ACTION_TMO * feiClkRate); --ix;)
  1333. {
  1334.         if ((retVal = pCFD->cfdStatus) & CFD_S_COMPLETE)
  1335.             break;
  1337. taskDelay (1);
  1338.         }
  1340.     if (!ix)
  1341. {
  1342. #ifdef FEI_DEBUG
  1343.          printf ("feiAction: command 0x%x, CFD status 0x%xn", action,
  1344.      pCFD->cfdStatus);
  1345. #endif /* FEI_DEBUG */
  1347.         retVal = 0;
  1348.         goto errorAction;
  1349. }
  1351.     /* put CFD back to a TxCB - mirrors feiattach() */
  1353. errorAction:
  1355.     pCFD->cfdStatus = CFD_S_COMPLETE | CFD_S_OK;
  1356.     LINK_WR (&pCFD->cfdTcb.pTBD, 0xffffffff); /* no TBDs used */
  1357.     pCFD->cfdTcb.txThresh = pDrvCtrl->board.tcbTxThresh;
  1358.     pCFD->cfdTcb.tbdNum = 0;
  1360.     return (retVal);
  1361.     }
  1363. /*******************************************************************************
  1364. *
  1365. * feiSCBCommand - deliver a command to the 82557 via the SCB
  1366. *
  1367. * This function causes the device to execute a command. An error status is
  1368. * returned if the command field does not return to zero, from a previous
  1369. * command, in a reasonable amount of time.
  1370. *
  1371. * RETURNS: OK, or ERROR if the command field appears to be frozen.
  1372. */
  1374. LOCAL STATUS feiSCBCommand
  1375.     (
  1376.     DRV_CTRL * pDrvCtrl,
  1377.     UINT8 cmd,
  1378.     BOOL addrValid,
  1379.     UINT32 * addr
  1380.     )
  1381.     {
  1382.     int ix;
  1384.     for (ix = 0x8000; --ix;)
  1385. {
  1386. if ((pDrvCtrl->pCSR->scbCommand & SCB_CR_MASK) == 0)
  1387.     break;
  1389.         }
  1391.     if (!ix)
  1392. {
  1393. #ifdef  FEI_DEBUG
  1394.         if (feiDebug)
  1395.             printf ("feiSCBCommand: command 0x%x failed, scb 0x%xn", cmd,
  1396.                 pDrvCtrl->pCSR->scbCommand);
  1397. #endif  /* FEI_DEBUG */
  1398.         return (ERROR);
  1399.         }
  1401.     if (addrValid) /* optionally fill the GP */
  1402. LINK_WR (&pDrvCtrl->pCSR->scbGP, addr);
  1404.     pDrvCtrl->pCSR->scbCommand |= cmd; /* write SCB command byte */
  1405.     return (OK);
  1406.     }
  1408. #ifdef  FEI_DEBUG
  1409. /*******************************************************************************
  1410. *
  1411. * feiDumpPrint - Display statistical counters
  1412. *
  1413. * This routine displays i82557 statistical counters
  1414. *
  1415. * RETURNS: OK, or ERROR if the DUMP command failed.
  1416. */
  1418. LOCAL STATUS feiDumpPrint
  1419.     (
  1420.     int         unit
  1421.     )
  1422.     {
  1423.     UINT32      dumpArray [18];
  1424.     UINT32 *    pDump;
  1425.     STATUS status = OK;
  1427.     /* dump area must be long-word allign */
  1429.     pDump = (UINT32 *) (((UINT32) dumpArray + 4) & 0xfffffffc);
  1431.     status = feiErrCounterDump(unit,pDump); 
  1433.     printf ("n");
  1434.     printf ("Tx good frames:             %dn", *pDump++);
  1435.     printf ("Tx MAXCOL errors:           %dn", *pDump++);
  1436.     printf ("Tx LATECOL errors:          %dn", *pDump++);
  1437.     printf ("Tx underrun errors:         %dn", *pDump++);
  1438.     printf ("Tx lost CRS errors:         %dn", *pDump++);
  1439.     printf ("Tx deferred:                %dn", *pDump++);
  1440.     printf ("Tx single collisions:       %dn", *pDump++);
  1441.     printf ("Tx multiple collisions:     %dn", *pDump++);
  1442.     printf ("Tx total collisions:        %dn", *pDump++);
  1443.     printf ("Rx good frames:             %dn", *pDump++);
  1444.     printf ("Rx CRC errors:              %dn", *pDump++);
  1445.     printf ("Rx allignment errors:       %dn", *pDump++);
  1446.     printf ("Rx resource errors:         %dn", *pDump++);
  1447.     printf ("Rx overrun errors:          %dn", *pDump++);
  1448.     printf ("Rx collision detect errors: %dn", *pDump++);
  1449.     printf ("Rx short frame errors:      %dn", *pDump++);
  1451.     return (status);
  1452.     }
  1455. /*****************************************************************************
  1456. *
  1457. * feiErrCounterDump - dump statistical counters 
  1458. *
  1459. * This routine dumps statistical counters for the purpose of debugging and
  1460. * tuning the 82557.
  1461. *
  1462. * The <memAddr> parameter is the pointer to an array of 68 bytes in the
  1463. * local memory.  This memory region must be allocated before this routine is
  1464. * called.  The memory space must also be DWORD (4 bytes) aligned.  When the
  1465. * last DWORD (4 bytes) is written to a value, 0xa007, it indicates the dump
  1466. * command has completed.  To determine the meaning of each statistical
  1467. * counter, see the Intel 82557 manual.
  1468. *
  1469. * RETURNS: OK or ERROR.
  1470. */
  1472. LOCAL STATUS feiErrCounterDump 
  1473.     (
  1474.     int unit,
  1475.     UINT32 *memAddr
  1476.     )
  1478.     {
  1479.     DRV_CTRL *  pDrvCtrl = &drvCtrl [unit];
  1480.     STATUS status = OK;
  1481.     int i; 
  1482.     int         s = splimp ();   /* block network access to 82557 resource */
  1484.     memAddr[16]=0;    /* make sure the last DWORD is 0 */
  1486.     /* tells the 82557 where to write dump data */
  1487.     if (feiSCBCommand (pDrvCtrl, SCB_C_CULDDUMP, TRUE,
  1488.     (UINT32 *) LOCAL_TO_SYS_ADDR(unit,(UINT32)memAddr) ) == ERROR)
  1489.         status = ERROR;
  1491.     /* issue the dump and reset counter command */
  1492.     if (feiSCBCommand (pDrvCtrl, SCB_C_CUDUMPRST,FALSE,(UINT32)0) == ERROR)
  1493. status = ERROR;
  1494.     
  1495.     splx (s);   /* release 82557 resource to network */
  1497.     /* waits for it done */ 
  1498.     for (i=0;i<60;i++)
  1499. {
  1500. if (memAddr[16] == (UINT32)0xa007)
  1501.     break;
  1502.         taskDelay(2);
  1503. }
  1505.     if (i==60)
  1506. status = ERROR;
  1508.     return (status);
  1509.     }
  1510. #endif  /* FEI_DEBUG */
  1512. /****************************************************************************
  1513. *
  1514. * feiMDIRead - read the MDI register
  1515. *
  1516. * This routine reads the specific register in the PHY device
  1517. * Valid PHY address is 0-31
  1518. *
  1519. * RETURNS: OK or ERROR.
  1520. *
  1521. */
  1523. static int feiMDIRead 
  1524.     (
  1525.     int unit,
  1526.     int regAddr,
  1527.     int phyAddr,
  1528.     UINT16 *retVal
  1529.     )
  1531.     {
  1533.     DRV_CTRL *  pDrvCtrl = &drvCtrl [unit];
  1534.     int i;
  1535.     UINT32 mdrValue;
  1536.     volatile UINT32 *mdiReg = (volatile UINT32 *)&pDrvCtrl->pCSR->mdiCR;
  1537.    
  1538.     mdrValue = ((regAddr<<16) | (phyAddr << 21) | (MDI_READ<<26) );
  1539.    
  1540.     /* write to MDI */
  1541.     *mdiReg = mdrValue;
  1543.     taskDelay(2);    /* wait for a while */
  1545.     /* check if it's done */
  1546.     for (i=0;i<40;i++)
  1547.         {
  1548.         if ( (*mdiReg) & (1<<28) )
  1549.             break;
  1550.         taskDelay(1);
  1551.         }
  1553.      if (i==40)
  1554.          return (ERROR);
  1556.      *retVal = (UINT16)((*mdiReg)&0xffff);
  1557.      return(OK);
  1559.      } 
  1561. /**************************************************************************
  1562. *
  1563. * feiMDIWrite - write to the MDI register
  1564. *
  1565. * This routine writes the specific register in the PHY device
  1566. * Valid PHY address is 0-31
  1567. *
  1568. * RETURNS: OK or ERROR.
  1569. */
  1571. static int feiMDIWrite
  1572.     (
  1573.     int unit,
  1574.     int regAddr,
  1575.     int phyAddr,
  1576.     UINT16 writeData 
  1577.     )
  1579.     {
  1581.     DRV_CTRL *  pDrvCtrl = &drvCtrl [unit];
  1582.     int i;
  1583.     UINT32 mdrValue;
  1584.     volatile UINT32 *mdrReg = (volatile UINT32 *)&pDrvCtrl->pCSR->mdiCR;
  1585.   
  1586.     mdrValue = ((regAddr<<16) | (phyAddr << 21) | (MDI_WRITE<<26) | writeData );
  1587.    
  1588.     /* write to M */
  1589.     *mdrReg = mdrValue;
  1591.     taskDelay(2);    /* wait for a while */
  1594.     /* check if it's done */
  1595.     for (i=0;i<40;i++)
  1596.         {
  1597.         if ( (*mdrReg) & (1<<28) )
  1598.             break;
  1599.         taskDelay(1);
  1600.         }
  1602.      if (i==40)
  1603.          return (ERROR);
  1605.      return(OK);
  1606.      }
  1609. /****************************************************************************
  1610. *
  1611. * feiMDIPhyLinkSet - detect and set the link for the PHY device
  1612. *
  1613. * This routine first checks if the link has been established.  If not, it
  1614. * isolates the other one, and tries to establish the link.  PHY device 0 is
  1615. * always at PHY address 0.  PHY 1 can be at 1-31 PHY addresses.
  1616. *
  1617. * RETURNS: OK or ERROR.
  1618. *
  1619. */
  1621. static int feiMDIPhyLinkSet
  1622.     (
  1623.     int unit,
  1624.     int phyAddr
  1625.     )
  1627.     {
  1628.     UINT16 ctlReg;
  1629.     UINT16 statusReg;
  1630.     int isoDev,i;
  1632.     /* read control register */
  1633.     feiMDIRead (unit, MDI_CTRL_REG, phyAddr, &ctlReg);
  1635.     /* read again */
  1636.     feiMDIRead (unit, MDI_CTRL_REG, phyAddr, &ctlReg);
  1638.     /* check if the PHY is there */
  1639.     if (ctlReg == (UINT16)0xffff)
  1640.         return (ERROR);   /* no PHY present */
  1642. #if 0
  1643.     /* CR RESET will cause link down */
  1644.     feiMDIWrite (unit,MDI_CTRL_REG,phyAddr,MDI_CR_RESET); 
  1645.     taskDelay(4);
  1646. #endif
  1648.     /* The PHY is there, read status register  */
  1649.     feiMDIRead (unit, MDI_STATUS_REG, phyAddr,&statusReg);
  1651.     /* in case the status bit is the latched bit */
  1652.     if ( !(statusReg & MDI_SR_LINK_STATUS))
  1653.         feiMDIRead (unit, MDI_STATUS_REG, phyAddr, &statusReg);
  1655.     if (statusReg & MDI_SR_LINK_STATUS)
  1656.         return (OK);  /* Device found and link OK */
  1658.     /* no link is established, let's configure it */
  1659.     
  1660.     /* isolates the other PHY */
  1661.     isoDev = (phyAddr)?0:1;
  1662.     feiMDIWrite (unit,MDI_CTRL_REG,isoDev,MDI_CR_ISOLATE);
  1664.     /* wait for a while */
  1665.     taskDelay (2);
  1667.     /* enable the PHY device we try to configure */
  1668.     feiMDIWrite (unit,MDI_CTRL_REG,phyAddr,MDI_CR_SELECT);
  1670.     taskDelay (2); /* wait for a while for command take effect */
  1672.     /* restart the auto negotiation process, execute anyways even if
  1673.      * it has no such capability.
  1674.      */
  1675.     feiMDIWrite (unit,MDI_CTRL_REG,phyAddr,MDI_CR_RESTART | MDI_CR_SELECT);
  1677.     /* wait for auto-negotiation to complete */
  1678.     for (i=0;i<80;i++)
  1679.         {
  1680.         /* read the status register */
  1681.         feiMDIRead (unit, MDI_STATUS_REG, phyAddr, &statusReg);
  1682.         feiMDIRead (unit, MDI_STATUS_REG, phyAddr, &statusReg);
  1683.    
  1684.         if (statusReg & (MDI_SR_AUTO_NEG | MDI_SR_REMOTE_FAULT) )
  1685.             break;
  1687.         taskDelay (2);
  1689. if (!(statusReg & MDI_SR_AUTO_SELECT) )
  1690.     break;  /* no such capability */
  1691.         }
  1693.     /* Read the status register */
  1694.     feiMDIRead (unit, MDI_STATUS_REG, phyAddr, &statusReg);
  1696.     /* some of the status bits require to clear a latch */
  1697.     if ( !(statusReg & MDI_SR_LINK_STATUS))
  1698.         feiMDIRead (unit, MDI_STATUS_REG, phyAddr, &statusReg);
  1700.     if (statusReg & MDI_SR_LINK_STATUS)
  1701.         return (OK);  /* Link configure done and successful */
  1702.         
  1703.     return (PHY_LINK_ERROR);   /* device is there, cann't establish link */
  1704.     }
  1706. /***************************************************************************
  1707. *
  1708. * feiMDIPhyConfig - configure the PHY device
  1709. *
  1710. * This routine configures the PHY device according to the parameters
  1711. * specified by users or the default value.
  1712. *
  1713. * RETURNS: OK or ERROR.
  1714. *
  1715. */
  1717. static int feiMDIPhyConfig 
  1718.     (
  1719.     int unit,
  1720.     int phyAddr
  1721.     )
  1723.     {
  1724.     DRV_CTRL *  pDrvCtrl = &drvCtrl [unit];
  1725.     UINT16 ctlReg = 0;
  1726.     int fullDpx=FALSE;
  1727.     int autoSelect =FALSE;
  1728.     UINT16 statusReg;
  1729.     int status,i;
  1731.     /* find out what capabilities the device have */
  1733.     /*  read status register  */
  1734.     feiMDIRead (unit, MDI_STATUS_REG, phyAddr,&statusReg);
  1736.     /* some of the status bits require to read twice */
  1737.     feiMDIRead (unit, MDI_STATUS_REG, phyAddr, &statusReg);
  1739.     /* The device at least has to have the half duplex and 10mb speed */
  1740.     if (statusReg & (MDI_SR_10T_FULL_DPX | MDI_SR_TX_FULL_DPX) )
  1741.         fullDpx = TRUE;
  1743.     if (statusReg & MDI_SR_AUTO_SELECT)
  1744.         autoSelect = TRUE;
  1746. #ifdef FEI_DEBUG 
  1747.     logMsg ("status REG = %x !!!! n",statusReg,0,0,0,0,0);
  1748. #endif /* FEI_DEBUG */
  1750.     if (pDrvCtrl->board.phyDpx == PHY_FULL_DPX && fullDpx == TRUE)
  1751.         ctlReg |= MDI_CR_FDX;
  1753.     if (pDrvCtrl->board.phySpeed == PHY_100MBS)
  1754.         ctlReg |= MDI_CR_100;
  1756.     if (pDrvCtrl->board.phySpeed == PHY_AUTO_SPEED || 
  1757.        pDrvCtrl->board.phyDpx == PHY_AUTO_DPX )
  1758.         {
  1759. if (autoSelect != TRUE)
  1760.     {
  1761.     /* set back to default */
  1762.     pDrvCtrl->board.phySpeed = PHY_10MBS;
  1763.     pDrvCtrl->board.phyDpx = PHY_HALF_DPX;
  1764.     ctlReg |= (PHY_10MBS | PHY_HALF_DPX);
  1765.     }
  1766.     else
  1767.                 ctlReg |= (MDI_CR_SELECT|MDI_CR_RESTART);
  1768.          }
  1770.     /* or other possible board level selection */
  1771.     ctlReg |= pDrvCtrl->board.others;
  1773.     /* configure the PHY */
  1774.     feiMDIWrite (unit,MDI_CTRL_REG,phyAddr,ctlReg);
  1775.    
  1776.     taskDelay (2);   /* wait for a while */
  1778.     if (! (ctlReg & MDI_CR_RESTART) )
  1779.         return (OK);
  1781.     /* we are here if the restart auto negotiation is selected */
  1782. #ifdef FEI_DEBUG
  1783.     logMsg ("auto NEGOTIATION STARTS !!!! n",0,0,0,0,0,0);
  1784. #endif /* FEI_DEBUG */
  1786.     /* wait for it done */
  1787.     for (status = PHY_AUTO_FAIL,i=0;i<80;i++)
  1788.        {
  1789.        /*  read status register, some bits have the latch,first read clears */
  1790.        feiMDIRead (unit, MDI_STATUS_REG, phyAddr,&statusReg);
  1791.        feiMDIRead (unit, MDI_STATUS_REG, phyAddr, &statusReg);
  1793.        if (statusReg & MDI_SR_AUTO_NEG)
  1794.            {
  1795.            status = OK;  /* auto negotiation completed */
  1796.            break;
  1797.            }
  1799.        if (statusReg & MDI_SR_REMOTE_FAULT)
  1800.            {
  1801.            status = PHY_AUTO_FAIL;  /* auto negotiation fails */
  1802.            break;
  1803.            }
  1804.         }
  1805.               
  1806.       return (status);
  1807.       } 
  1809. /**************************************************************************
  1810. *
  1811. * feiPhyInit - initialize and configure the PHY device if there is one
  1812. *
  1813. * This routine initialize and configure the PHY device if there is one.
  1814. *
  1815. * RETURNS: OK or ERROR.
  1816. *
  1817. */
  1819. static int feiPhyInit
  1820.     (
  1821.     int unit
  1822.     )
  1824.     {
  1825.     int status;
  1826.     int phyDevice;
  1827.     DRV_CTRL *  pDrvCtrl = &drvCtrl [unit];
  1829.     if (pDrvCtrl->board.phyAddr > 31)
  1830.         return (OK);  /* not a MII interface,no need to initialize PHY */
  1832.      /* configure the Physical layer medium if it's MII interface */
  1833.      /* starts with logical PHY 1 */
  1835.      phyDevice = pDrvCtrl->board.phyAddr?pDrvCtrl->board.phyAddr:1;
  1837.      status = feiMDIPhyLinkSet(unit,phyDevice);
  1839.      if (status != OK)
  1840.          {
  1841.          phyDevice = 0;
  1842.          status = feiMDIPhyLinkSet(unit,phyDevice);
  1843.          }
  1845.      if (status != OK)
  1846.  {
  1847.          printf ("LINK_FAIL error, check the line connection !!!n");
  1848.          return (status);
  1849.          }
  1851.      /* we are here if a valid link is established */
  1852.      status = feiMDIPhyConfig (unit,phyDevice); 
  1854.      if (status == PHY_AUTO_FAIL)
  1855.          {
  1856.          /* force default speed and duplex */
  1857.          pDrvCtrl->board.phySpeed = PHY_10MBS;
  1858.          pDrvCtrl->board.phyDpx = PHY_HALF_DPX; 
  1859.          pDrvCtrl->board.others = 0;
  1861.          /* and configure it again */
  1862.          status = feiMDIPhyConfig (unit,phyDevice);  
  1863.          }
  1865.      return (status);
  1866.      }