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

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

VxWorks

开发平台：

C/C++

sh7615End.c：源码内容
  1. /* sh7615End.c - sh7615End END  network interface driver */
  3. /* Copyright 1984-2001 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01l,28mar02,h_k  added muxError() at failing of netClusterGet() and
  10.                  netClBlkGet(). moved E-DMAC Receive Request enable to
  11.                  sh7615EndRcvIntHandle() from sh7615EndInt(). added setting
  12.                  depth of FIFO. changed clNum and mBlkNum. (SPR #74021)
  13. 01k,02nov01,zl   corrected NULL usage.
  14. 01j,19oct01,zl   documentation fixes. Removed sh7615EndIASetup().
  15. 01i,09may01,zl   detect link status change, add restart routine.
  16. 01h,05may01,zl   made interrupt handling more efficient and robust.
  17. 01g,30apr01,zl   detect and set full duplex mode.
  18. 01f,09nov00,rsh  missing #ifdef
  19. 01e,02nov00,frf  Read and Write functions to a PHY registers:
  20.                        dp83843RegRead, dp83843RegWrite, dp83843RegPrint.
  21. 01d,10oct00,zl   got polled mode working. Code Cleanup.
  22. 01c,27sep00,rsh  add cache support.
  23. 01b,26sep00,rsh  remove bsp option to provide shared memory since this chip.
  24.                  doesn't provide special memory.
  25. 01a,16aug00,rsh  written based on dec21x40End.c
  26. */
  28. /*
  29. DESCRIPTION
  31. This module implements an network interface driver for the Hitachi SH7615
  32. on-chip Ethernet controller (EtherC) and EtherNet COntroller Direct Memory 
  33. Access Controller (E-DMAC). The EtherC is fully compliant with the IEEE 802.3
  34. 10Base-T and 100Base-T specifications. Hardware support of the Media 
  35. Independent Interface (MII) is off-chip.
  37. The Ethernet controller is connected to dedicated transmit and receive 
  38. Ethernet DMACs (E-DMACs) in the SH7615, and carries out high-speed data
  39. transfer to and from memory. The operation of the E-DMAC is controlled with
  40. the transmit and receive descriptor rings. The start address of the
  41. descriptors is set in the RDLAR and TDLAR registers, so they can reside
  42. anywhwere. The descriptors must reside on boundaries that are multiple
  43. of their size (16, 32, or 64 bytes).
  46. EXTERNAL INTERFACE
  47.  
  48. The driver provides the standard external interface, sh7615EndLoad(), which
  49. takes a string of colon-separated parameters. The parameters should be 
  50. specified in hexadecimal, optionally preceeded by "0x" or a minus sign "-".
  52. The parameter string is parsed using strtok_r() and each parameter is
  53. converted from a string representation to binary by a call to
  54. strtoul(parameter, NULL, 16).
  56. The format of the parameter string is:
  58. "<ivec>:<ilevel>:<numRds>:<numTds>:<phyDefMode>:<userFlags>"
  60. TARGET-SPECIFIC PARAMETERS
  62. .IP <ivec>
  63. This is the interrupt vector number of the hardware interrupt generated by
  64. this Ethernet device.  The driver uses intConnect() to attach an interrupt
  65. handler for this interrupt.
  67. .IP <ilevel>
  68. This parameter defines the level of the hardware interrupt.
  70. .IP <numRds>
  71. The number of receive descriptors to use.  This controls how much data
  72. the device can absorb under load.  If this is specified as NONE (-1), 
  73. the default of 32 is used.
  75. .IP <numTds>
  76. The number of transmit descriptors to use.  This controls how much data
  77. the device can absorb under load.  If this is specified as NONE (-1) then
  78. the default of 64 is used.
  80. .IP <phyDefMode>
  81. This parameter specifies the operating mode that will be set up
  82. by the default physical layer initialization routine in case all
  83. the attempts made to establish a valid link failed. If that happens,
  84. the first PHY that matches the specified abilities will be chosen to
  85. work in that mode, and the physical link will not be tested.
  87. .IP <userFlags>
  88. This field enables the user to give some degree of customization to the
  89. driver.
  90. Bit [0-3] reserved for receive FIFO depth and bit [4-7] reserved for transmit
  91. FIFO depth. The actual FIFO size is 256 times + 256 the set value for each
  92. FIFO. The max FIFO depth is 512 bytes for SH7615 (i.e. 0x1 for receive FIFO,
  93. 0x10 for transmit FIFO) and 2048 bytes for SH7616 (i.e. 0x7 for receive FIFO,
  94. 0x70 for transmit FIFO).
  96. The macros SYS_INT_CONNECT, SYS_INT_DISCONNECT, and SYS_INT_ENABLE allow
  97. the driver to be customized for BSPs that use special versions of these
  98. routines.
  100. The macro SYS_INT_CONNECT is used to connect the interrupt handler to
  101. the appropriate vector.  By default it is the routine intConnect().
  103. The macro SYS_INT_DISCONNECT is used to disconnect the interrupt handler prior
  104. to unloading the module.  By default this is a dummy routine that
  105. returns OK.
  107. The macro SYS_INT_ENABLE is used to enable the interrupt level for the
  108. end device.  It is called once during initialization.  By default this is
  109. the routine sysLanIntEnable(), defined in the module sysLib.o.
  111. The macro SYS_ENET_ADDR_GET is used to get the ethernet address (MAC)
  112. for the device.  The single argument to this routine is the SH7615END_DRV_CTRL
  113. pointer.  By default this routine copies the ethernet address stored in
  114. the global variable sysTemplateEnetAddr into the SH7615END_DRV_CTRL structure.
  116. SEE ALSO: muxLib, endLib
  117. .I "Writing and Enhanced Network Driver"
  118. .I "SH7615 Hardware Manual"
  119. */
  121. /* includes */
  123. #include "vxWorks.h"
  124. #include "stdlib.h"
  125. #include "cacheLib.h"
  126. #include "intLib.h"
  127. #include "end.h" /* Common END structures. */
  128. #include "endLib.h"
  129. #include "lstLib.h" /* Needed to maintain protocol list. */
  130. #include "wdLib.h"
  131. #include "iv.h"
  132. #include "semLib.h"
  133. #include "etherLib.h"
  134. #include "logLib.h"
  135. #include "netLib.h"
  136. #include "stdio.h"
  137. #include "sysLib.h"
  138. #include "errno.h"
  139. #include "errnoLib.h"
  140. #include "memLib.h"
  141. #include "iosLib.h"
  142. #undef ETHER_MAP_IP_MULTICAST
  143. #include "etherMultiLib.h" /* multicast stuff. */
  145. #include "net/mbuf.h"
  146. #include "net/unixLib.h"
  147. #include "net/protosw.h"
  148. #include "net/systm.h"
  149. #include "net/if_subr.h"
  150. #include "net/route.h"
  152. #include "sys/socket.h"
  153. #include "sys/ioctl.h"
  154. #include "sys/times.h"
  156. #include "drv/end/sh7615End.h"
  158. /* defines */
  160. #define INCLUDE_PHY
  162. #define DRV_CTRL SH7615END_DRV_CTRL
  163. #define SH7615END_DEV_NAME "shend"
  164. #define SH7615END_DEV_NAME_LEN 6
  165. #define SH7615END_BUFSIZ (ETHERMTU + ENET_HDR_REAL_SIZ + 6 +     
  166.     SH7615END_BD_ALIGN)
  167. #define SH7615END_SPEED 10000000 /* 10Mbs */
  168.     
  169. /* DRV_CTRL flags */
  170. #define SH7615END_INV_TBD_NUM   0x02  /* invalid numTds provided */
  171. #define SH7615END_INV_RBD_NUM   0x04  /* invalid numRds provided */
  172. #define SH7615END_POLLING       0x08  /* Poll mode, io mode */
  173. #define SH7615END_PROMISC       0x20  /* Promiscuous, rx mode */
  174. #define SH7615END_MCAST         0x40  /* Multicast, rx mode */
  175. #define SH7615END_FD            0x80  /* full duplex mode */
  177. /*
  178.  * Default macro definitions for BSP interface.
  179.  * These macros can be redefined in a wrapper file, to generate
  180.  * a new module with an optimized interface.
  181.  */
  183. #ifndef SYS_INT_CONNECT
  184. #define SYS_INT_CONNECT(pDrvCtrl,rtn,arg,pResult)                       
  185.     {                                                                   
  186.     *pResult = intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (pDrvCtrl->ivec),
  187.                              rtn, (int)arg);                            
  188.     }
  189. #endif /* SYS_INT_CONNECT */
  190.  
  191. #ifndef SYS_INT_DISCONNECT
  192. #define SYS_INT_DISCONNECT(pDrvCtrl,rtn,arg,pResult)                    
  193.     {                                                                   
  194.     *pResult = OK;                                                      
  195.     }
  196. #endif /* SYS_INT_DISCONNECT */
  198. #ifndef SYS_INT_ENABLE
  199. #define SYS_INT_ENABLE(pDrvCtrl)                                        
  200.     {                                                                   
  201.     IMPORT void sysLanIntEnable();                                      
  202.     sysLanIntEnable (pDrvCtrl->ilevel);                                 
  203.     }
  204. #endif /* SYS_INT_ENABLE */
  205.  
  206. #ifndef SYS_INT_DISABLE
  207. #define SYS_INT_DISABLE(pDrvCtrl)                                       
  208.     {                                                                   
  209.     IMPORT STATUS sysLanIntDisable();                                   
  210.     sysLanIntDisable(pDrvCtrl->ilevel);                                 
  211.     }
  212. #endif /*SYS_INT_DISABLE*/
  214. #define NET_BUF_ALLOC()                                                 
  215.     netClusterGet (pDrvCtrl->end.pNetPool, pDrvCtrl->pClPoolId)
  217. #define NET_TO_SH7615END_BUF(netBuf)                                    
  218.     (((UINT32) (netBuf) + SH7615END_BD_ALIGN - 1)                       
  219.       & ~(SH7615END_BD_ALIGN - 1))
  220.  
  221. #define NET_BUF_FREE(pBuf)                                              
  222.     netClFree (pDrvCtrl->end.pNetPool, pBuf)
  223.  
  224. #define NET_MBLK_ALLOC()                                                
  225.     mBlkGet (pDrvCtrl->end.pNetPool, M_DONTWAIT, MT_DATA)
  226.  
  227. #define NET_MBLK_FREE(pMblk)                                            
  228.     netMblkFree (pDrvCtrl->end.pNetPool, (M_BLK_ID)pMblk)
  229.  
  230. #define NET_CL_BLK_ALLOC()                                              
  231.     clBlkGet (pDrvCtrl->end.pNetPool, M_DONTWAIT)
  232.  
  233. #define NET_CL_BLK_FREE(pClblk)                                         
  234.     clBlkFree (pDrvCtrl->end.pNetPool, (CL_BLK_ID)pClBlk)
  235.  
  236. #define NET_MBLK_BUF_FREE(pMblk)                                        
  237.     netMblkClFree ((M_BLK_ID)pMblk)
  238.   
  239. #define NET_MBLK_CL_JOIN(pMblk, pClBlk)                                 
  240.     netMblkClJoin ((pMblk), (pClBlk))
  241.  
  242. #define NET_CL_BLK_JOIN(pClBlk, pBuf, len)                              
  243.     netClBlkJoin ((pClBlk), (pBuf), (len), NULL, 0, 0, 0)
  245. #ifndef SYS_ENET_ADDR_GET
  246. #define SYS_ENET_ADDR_GET(pDrvCtrl, pAddress)                           
  247.     {                                                                   
  248.     IMPORT STATUS sysEnetAddrGet (int, char*);                          
  249.     sysEnetAddrGet (pDrvCtrl->unit, pAddress);                          
  250.     }
  251. #endif /* SYS_ENET_ADDR_GET */
  253. #define SH7615END_REG_READ(regAddr, value)                              
  254.     ((value) = (* (volatile UINT32 *) (regAddr)))
  255.  
  256. #define SH7615END_REG_WRITE(regAddr, value)                             
  257.     ((* (volatile UINT32 *) (regAddr)) = ((UINT32) value))
  259. #define SH7615END_BIT_SET(reg, val)                                     
  260.     {                                                                   
  261.     UINT32 temp = 0;                                                    
  262.     SH7615END_REG_READ(reg, temp);                                      
  263.     SH7615END_REG_WRITE((reg), temp | (val));                           
  264.     }
  265.    
  266. #define SH7615END_BIT_CLR(reg, val)                                     
  267.     {                                                                   
  268.     UINT32 temp = 0;                                                    
  269.     SH7615END_REG_READ(reg, temp);                                      
  270.     SH7615END_REG_WRITE((reg), temp & ~(val));                          
  271.     }
  273. /* DRV_CTRL flags access macros */
  275. #define DRV_FLAGS_SET(setBits)                                          
  276.     (pDrvCtrl->flags |= (setBits))
  277.  
  278. #define DRV_FLAGS_ISSET(setBits)                                        
  279.     (pDrvCtrl->flags & (setBits))
  280.  
  281. #define DRV_FLAGS_CLR(clrBits)                                          
  282.     (pDrvCtrl->flags &= ~(clrBits))
  283.  
  284. #define DRV_FLAGS_GET()                                                 
  285.     (pDrvCtrl->flags)
  287. #define END_FLAGS_ISSET(pEnd, setBits)                                  
  288.     ((pEnd)->flags & (setBits))
  290. /* A shortcut for getting the hardware address from the MIB II stuff. */
  292. #define END_HADDR(pEnd)                                                 
  293.     ((pEnd)->mib2Tbl.ifPhysAddress.phyAddress)
  295. #define END_HADDR_LEN(pEnd)                                             
  296.     ((pEnd)->mib2Tbl.ifPhysAddress.addrLength)
  298. /* Cache related macros */
  300. #define SH7615END_CACHE_FLUSH(address, len)                             
  301.     cacheFlush(DATA_CACHE, (address), (len))
  302.  
  303. #define SH7615END_CACHE_INVALIDATE(address, len)                        
  304.     cacheInvalidate (DATA_CACHE, (address), (len))
  306. /* DEBUG MACROS */
  308. #ifdef DRV_DEBUG
  310. #undef  LOCAL
  311. #define LOCAL
  313. #define DRV_DEBUG_OFF 0x0000
  314. #define DRV_DEBUG_RX 0x0001
  315. #define DRV_DEBUG_TX 0x0002
  316. #define DRV_DEBUG_INT 0x0004
  317. #define DRV_DEBUG_POLL (DRV_DEBUG_POLL_RX | DRV_DEBUG_POLL_TX)
  318. #define DRV_DEBUG_POLL_RX 0x0008
  319. #define DRV_DEBUG_POLL_TX 0x0010
  320. #define DRV_DEBUG_LOAD 0x0020
  321. #define DRV_DEBUG_IOCTL 0x0040
  322. #define DRV_DEBUG_POLL_REDIR 0x10000
  323. #define DRV_DEBUG_LOG_NVRAM 0x20000
  324. #define DRV_DEBUG_PHY 0x40000
  325.      
  326. int sh7615EndDebug = 0x40000;
  328. int sh7615EndRfcof = 0;
  329. int sh7615EndEci = 0;
  330. int sh7615EndTc = 0;
  331. int sh7615EndTde = 0;
  332. int sh7615EndTfuf = 0;
  333. int sh7615EndFr = 0;
  334. int sh7615EndRde = 0;
  335. int sh7615EndRfof = 0;
  336. int sh7615EndItf = 0;
  337. int sh7615EndCnd = 0;
  338. int sh7615EndDlc = 0;
  339. int sh7615EndCd = 0;
  340. int sh7615EndTro = 0;
  341. int sh7615EndRmaf = 0;
  342. int sh7615EndRrf = 0;
  343. int sh7615EndRtlf = 0;
  344. int sh7615EndRtsf = 0;
  345. int sh7615EndPre = 0;
  346. int sh7615EndCerf = 0;
  347. int sh7615EndTfe = 0;
  349. /* globals for easy access */
  351. CL_POOL_ID  sh7615ClPool;
  352. NET_POOL_ID sh7615NetPoolId;
  353. DRV_CTRL *  pShEnd;
  355. #define DRV_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)                        
  356. if (sh7615EndDebug & FLG)                                        
  357.             logMsg(X0, X1, X2, X3, X4, X5, X6);
  359. #define DRV_PRINT(FLG,X)                                                
  360. if (sh7615EndDebug & FLG) printf X;
  362. #else /*DRV_DEBUG*/
  364. #define DRV_LOG(DBG_SW, X0, X1, X2, X3, X4, X5, X6)
  365. #define DRV_PRINT(DBG_SW,X)
  367. #endif /*DRV_DEBUG*/
  370. /* LOCALS */
  372. /* forward static functions */
  374. LOCAL void sh7615EndReset (DRV_CTRL *pDrvCtrl);    
  375. LOCAL void sh7615EndInt (DRV_CTRL *pDrvCtrl);
  376. LOCAL void sh7615EndRcvIntHandle (DRV_CTRL *pDrvCtrl);
  377. LOCAL STATUS sh7615EndRecv (DRV_CTRL *pDrvCtrl, SH7615_RD * pRxD );
  378. LOCAL void sh7615EndConfig (DRV_CTRL *pDrvCtrl);
  379. LOCAL void  sh7615EndModeSet (DRV_CTRL *pDrvCtrl);
  381. LOCAL STATUS sh7615EndParse (DRV_CTRL * pDrvCtrl, char * initString); 
  382. LOCAL STATUS sh7615EndMemInit (DRV_CTRL * pDrvCtrl);
  383. LOCAL void      sh7615EnetAddrGet (DRV_CTRL* pDrvCtrl, char* addr);
  385. LOCAL SH7615_RD * sh7615EndRxDGet (DRV_CTRL *pDrvCtrl);
  386. LOCAL SH7615_TD * sh7615EndTxDGet (DRV_CTRL *pDrvCtrl);
  387. LOCAL void      sh7615EndTxRingClean (DRV_CTRL *pDrvCtrl);
  388. LOCAL void      sh7615EndRestart (DRV_CTRL *pDrvCtrl);
  390. #ifdef INCLUDE_PHY
  391. LOCAL void  dp83843SingleBitWrite (int bitVal);
  392. #if 0  /* currently not used */
  393. LOCAL void  dp83843RegWrite (UINT16 regAddr, UINT16 regData);
  394. #endif
  395. LOCAL UINT16 dp83843RegRead (UINT16 regAddr);
  396. #endif
  398. /* END Specific interfaces. */
  400. END_OBJ*  sh7615EndLoad (char* initString);
  401. LOCAL STATUS sh7615EndUnload (DRV_CTRL* pDrvCtrl);
  402. LOCAL STATUS sh7615EndStart (DRV_CTRL* pDrvCtrl);
  403. LOCAL STATUS sh7615EndStop (DRV_CTRL* pDrvCtrl);
  404. LOCAL STATUS sh7615EndIoctl (DRV_CTRL* pDrvCtrl, int cmd, caddr_t data);
  405. LOCAL STATUS    sh7615EndSend (DRV_CTRL *pDrvCtrl, M_BLK *pMblk);
  406. LOCAL STATUS    sh7615EndMCastAddrAdd (DRV_CTRL *pDrvCtrl, char* pAddress);
  407. LOCAL STATUS    sh7615EndMCastAddrDel (DRV_CTRL *pDrvCtrl, char* pAddress);
  408. LOCAL STATUS    sh7615EndMCastAddrGet (DRV_CTRL *pDrvCtrl,
  409.                                        MULTI_TABLE *pTable);
  410. LOCAL STATUS    sh7615EndPollSend (DRV_CTRL *pDrvCtrl, M_BLK *pMblk);
  411. LOCAL STATUS    sh7615EndPollReceive (DRV_CTRL *pDrvCtrl, M_BLK *pMblk);
  412. LOCAL STATUS    sh7615EndPollStart (DRV_CTRL *pDrvCtrl);
  413. LOCAL STATUS    sh7615EndPollStop (DRV_CTRL *pDrvCtrl);
  415. /*
  416.  * Declare our function table.  This is static across all driver
  417.  * instances.
  418.  */
  420. LOCAL NET_FUNCS sh7615EndFuncTable =
  421.     {
  422.     (FUNCPTR) sh7615EndStart, /* Function to start the device. */
  423.     (FUNCPTR) sh7615EndStop, /* Function to stop the device. */
  424.     (FUNCPTR) sh7615EndUnload, /* Unloading function for the driver. */
  425.     (FUNCPTR) sh7615EndIoctl, /* Ioctl function for the driver. */
  426.     (FUNCPTR) sh7615EndSend,            /* send func. */
  427.     (FUNCPTR) sh7615EndMCastAddrAdd,    /* multicast add func. */
  428.     (FUNCPTR) sh7615EndMCastAddrDel,    /* multicast delete func. */
  429.     (FUNCPTR) sh7615EndMCastAddrGet,    /* multicast get fun. */
  430.     (FUNCPTR) sh7615EndPollSend,        /* polling send func. */
  431.     (FUNCPTR) sh7615EndPollReceive,     /* polling receive func. */
  432.     endEtherAddressForm,         /* put address info into a NET_BUFFER */
  433.     (FUNCPTR) endEtherPacketDataGet,  /* get pointer to data in NET_BUFFER */
  434.     (FUNCPTR) endEtherPacketAddrGet  /* Get packet addresses. */
  435.     };
  437. /*******************************************************************************
  438. *
  439. * sh7615EndLoad - initialize the driver and device
  440. *
  441. * This routine initializes the driver and the device to the operational state.
  442. * All of the device specific parameters are passed in the initString.
  443. *
  444. * The string contains the target specific parameters like this:
  445. *  "ivec:ilevel:numRds:numTds:phyDefMode:userFlags"
  446. *
  447. * RETURNS: An END object pointer or NULL on error.
  448. */
  450. END_OBJ* sh7615EndLoad
  451.     (
  452.     char * initString /* String to be parsed by the driver. */
  453.     )
  454.     {
  455.     DRV_CTRL * pDrvCtrl;
  457.     DRV_LOG (DRV_DEBUG_LOAD, "Loading sh7615End...n", 1, 2, 3, 4, 5, 6);
  459.     if (initString == NULL)
  460.         return (NULL);
  461.  
  462.     if (initString[0] == EOS)
  463.         {
  464.         bcopy((char *)SH7615END_DEV_NAME, initString, SH7615END_DEV_NAME_LEN);
  465.         return (0);
  466.         }
  468.     /* Allocate a control structure for this device */
  469.     pDrvCtrl = (DRV_CTRL *)calloc (sizeof (DRV_CTRL), 1);
  471.     if (pDrvCtrl == NULL)
  472.         {
  473.         printf ("%s - Failed to allocate control structuren",
  474.                 SH7615END_DEV_NAME );
  475.         return (NULL);
  476.         }
  478.     /* parse the init string, filling in the device structure */
  480.     if (sh7615EndParse (pDrvCtrl, initString) == ERROR)
  481.         goto errorExit;
  483.     /* Ask the BSP to provide the ethernet address. */
  485.     sh7615EnetAddrGet (pDrvCtrl, (char*) &(pDrvCtrl->enetAddr));
  487.     DRV_LOG (DRV_DEBUG_LOAD, "ENET Addr: %x:%x:%x:%x:%x:%x n",
  488.              pDrvCtrl->enetAddr[0], pDrvCtrl->enetAddr[1],
  489.              pDrvCtrl->enetAddr[2], pDrvCtrl->enetAddr[3],
  490.              pDrvCtrl->enetAddr[4], pDrvCtrl->enetAddr[5]);
  492.     /* initialize some flags */
  493.  
  494.     pDrvCtrl->loaded = TRUE;
  496.     /* initialize the END and MIB2 parts of the structure */
  498.     /*
  499.      * The M2 element must come from m2Lib.h 
  500.      * This sh7615End is set up for a DIX type ethernet device.
  501.      */
  502.     
  503.     if (END_OBJ_INIT (&pDrvCtrl->end, (DEV_OBJ *)pDrvCtrl, SH7615END_DEV_NAME, 
  504.                       pDrvCtrl->unit, &sh7615EndFuncTable,
  505.                       "Hitachi SH7615 Enhanced Network Driver.") == ERROR
  506.      || END_MIB_INIT (&pDrvCtrl->end, M2_ifType_ethernet_csmacd,
  507.                       &pDrvCtrl->enetAddr[0], 6, ETHERMTU, SH7615END_SPEED)
  508.     == ERROR)
  509.         goto errorExit;
  511.     pDrvCtrl->flags = 0; 
  513.     /* Perform memory allocation/distribution */
  515.     if (sh7615EndMemInit (pDrvCtrl) == ERROR)
  516. goto errorExit;
  518.     /* set the End flags to indicate readiness */
  520.     END_OBJ_READY (&pDrvCtrl->end, 
  521.                          (IFF_NOTRAILERS | IFF_MULTICAST | IFF_BROADCAST));
  523.     DRV_LOG (DRV_DEBUG_LOAD, "Done loading sh7615end...", 1, 2, 3, 4, 5, 6);
  525. #ifdef DRV_DEBUG
  526.     pShEnd = pDrvCtrl;
  527. #endif     
  528.     
  529.     return (&pDrvCtrl->end);
  531. errorExit:
  532.     sh7615EndUnload (pDrvCtrl); 
  533.     free ((char *)pDrvCtrl);
  534.     return NULL;
  535.     }
  537. /******************************************************************************
  538. *
  539. * sh7615EndUnload - unload a driver from the system
  540. *
  541. * This function first brings down the device, and then frees any
  542. * stuff that was allocated by the driver in the load function.
  543. *
  544. * RETURNS: OK or ERROR.
  545. */
  547. LOCAL STATUS sh7615EndUnload
  548.     (
  549.     DRV_CTRL* pDrvCtrl /* device to be unloaded */
  550.     )
  551.     {
  552.  
  553.     DRV_LOG (DRV_DEBUG_LOAD, "EndUnloadn", 0, 0, 0, 0, 0, 0);
  555.     if (pDrvCtrl == NULL)
  556.         return (ERROR);
  557.  
  558.     pDrvCtrl->loaded = FALSE;
  559.  
  560.     END_OBJECT_UNLOAD (&pDrvCtrl->end);
  562.     /* free allocated shared memory */
  564.     if (pDrvCtrl->memBase != NULL)
  565. cacheDmaFree (pDrvCtrl->memBase);
  567.     /* free allocated memory if necessary */
  568.  
  569.     if ((pDrvCtrl->pMBlkArea) != NULL)
  570.         free (pDrvCtrl->pMBlkArea);
  572.     /* REVISIT - what about clusters? */
  574.     cfree ((char *) pDrvCtrl);
  576.     return (OK);
  577.     }
  580. /*******************************************************************************
  581. *
  582. * sh7615EndParse - parse the init string
  583. *
  584. * Parse the input string.  Fill in values in the driver control structure.
  585. *
  586. * The muxLib.o module automatically prepends the unit number to the user's
  587. * initialization string from the BSP (configNet.h).
  588. *
  589. *
  590. * RETURNS: OK or ERROR for invalid arguments.
  591. */
  593. LOCAL STATUS sh7615EndParse
  594.     (
  595.     DRV_CTRL * pDrvCtrl, /* device pointer */
  596.     char * initString /* information string */
  597.     )
  598.     {
  599.     char* tok;
  600.     char* pHolder = NULL;
  602.     /* Parse the initString */
  604.     /* Unit number. (from muxLib.o) */
  606.     tok = strtok_r (initString, ":", &pHolder);
  607.     if (tok == NULL)
  608. return ERROR;
  609.     pDrvCtrl->unit = atoi (tok);
  611.     /* Get various driver configuration values */
  613.     tok = strtok_r (NULL, ":", &pHolder);
  614.     if (tok == NULL)
  615. return ERROR;
  616.     pDrvCtrl->ivec = atoi (tok);
  618.     tok = strtok_r (NULL, ":", &pHolder);
  619.     if (tok == NULL)
  620. return ERROR;
  621.     pDrvCtrl->ilevel = atoi (tok);
  623.     tok = strtok_r (NULL, ":", &pHolder);
  624.     if (tok == NULL)
  625.         return ERROR;
  626.     pDrvCtrl->numTds = strtoul (tok, NULL, 16);
  627.  
  628.     tok = strtok_r (NULL, ":", &pHolder);
  629.     if (tok == NULL)
  630.         return ERROR;
  631.     pDrvCtrl->numRds = strtoul (tok, NULL, 16);
  633.     /* PHY options (phyDefMode) currently not used */
  635.     tok = strtok_r (NULL, ":", &pHolder);
  636.     if (tok == NULL)
  637.         return ERROR;
  639.     tok = strtok_r (NULL, ":", &pHolder);
  640.     if (tok == NULL)
  641.         return ERROR;
  642.     pDrvCtrl->userFlags = strtoul (tok, NULL, 16);
  644.     /* Use default values for invalid settings */
  646.     if (!pDrvCtrl->numTds || pDrvCtrl->numTds <= 2)
  647.         {
  648.         DRV_FLAGS_SET (SH7615END_INV_TBD_NUM);
  649.         pDrvCtrl->numTds = SH7615END_TBD_DEF_NUM;
  650.         }
  651.  
  652.     if (!pDrvCtrl->numRds || pDrvCtrl->numRds <= 2)
  653.         {
  654.         DRV_FLAGS_SET (SH7615END_INV_RBD_NUM);
  655.         pDrvCtrl->numRds = SH7615END_RBD_DEF_NUM;
  656.         }
  658.     DRV_LOG (DRV_DEBUG_LOAD, "Processed all arugmentsn", 1, 2, 3, 4, 5, 6);
  660.     return OK;
  661.     }
  663. /*******************************************************************************
  664. *
  665. * sh7615EndMemInit - initialize memory for the chip
  666. *
  667. * This routine sets up memory required by the driver. It is highly specific 
  668. * to the device.
  669. *
  670. * RETURNS: OK or ERROR.
  671. */
  673. LOCAL STATUS sh7615EndMemInit
  674.     (
  675.     DRV_CTRL * pDrvCtrl /* device to be initialized */
  676.     )
  677.     {
  678.     SH7615_RD * pRxD;
  679.     SH7615_TD * pTxD;
  680.     char * pBuf;
  681.     int ix;
  682.     int sz;
  683.     M_CL_CONFIG mclBlkConfig = {0, 0, NULL, 0};
  684.                                         /* cluster blocks configuration */
  685.     CL_DESC     clDesc = {SH7615END_BUFSIZ, 0, NULL, 0};
  686.                                         /* cluster blocks config table */
  688.     /* Establish size of shared memory region we require */
  689.  
  690.     DRV_LOG (DRV_DEBUG_LOAD, "MemInit n", 0, 0, 0, 0, 0, 0);
  692.     /* Establish a region of shared memory - allow for 16 byte align */
  694.     sz = (((pDrvCtrl->numRds + 1) * SH7615END_RBD_SZ) +
  695.           ((pDrvCtrl->numTds + 1) * SH7615END_TBD_SZ));
  697.     /* this driver can't handle write incoherent caches */
  698.  
  699.     if (!CACHE_DMA_IS_WRITE_COHERENT ())
  700.         {
  701.         DRV_LOG (DRV_DEBUG_LOAD, "sh7615EndMemInit: shared
  702.                                    memory not cache coherentn",
  703.                                    1, 2, 3, 4, 5, 6);
  704.         return (ERROR);
  705.         }
  707.     /* cacheDmaMalloc returns CACHE_ALIGN_SIZE aligned and rounded
  708.      * non-cacheable buffer. So, there is no need to flush and invalidate
  709.      * descriptor buffers in this driver.
  710.      */
  712.     pDrvCtrl->memBase = (char *) cacheDmaMalloc (sz);
  714.     if (pDrvCtrl->memBase == NULL)
  715.        {
  716.         DRV_LOG (DRV_DEBUG_LOAD, "%s%d - system memory unavailablen",
  717.                  (int)SH7615END_DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  718.         return (ERROR);
  719.         }
  721.     pDrvCtrl->memSize = sz;
  723.     /* zero the shared memory */
  725.     bzero (pDrvCtrl->memBase, (int) pDrvCtrl->memSize);
  727.     /* ensure 16 byte alignment - device requirement */
  729.     pDrvCtrl->rxRing = (SH7615_RD *) NET_TO_SH7615END_BUF (pDrvCtrl->memBase);
  731.     /* carve Tx memory structure */
  733.     pDrvCtrl->txRing = (SH7615_TD *) (pDrvCtrl->rxRing + pDrvCtrl->numRds);
  735.     /* Initialize net buffer pool for tx/rx buffers */
  737.     clDesc.clNum    = pDrvCtrl->numRds + pDrvCtrl->numTds + NUM_LOAN;
  738.     mclBlkConfig.mBlkNum  = pDrvCtrl->numRds * 4;
  739.     mclBlkConfig.clBlkNum = clDesc.clNum;
  741.     mclBlkConfig.memSize = mclBlkConfig.mBlkNum * (MSIZE + sizeof (long)) +
  742.                            mclBlkConfig.clBlkNum * (CL_BLK_SZ + sizeof(long));
  744.     mclBlkConfig.memArea = (char *) memalign (MBLK_ALIGNMENT, 
  745.       mclBlkConfig.memSize);
  747.     if (mclBlkConfig.memArea == NULL)
  748. return (ERROR);
  750.     /* store the pointer to the mBlock area */
  752.     pDrvCtrl->pMBlkArea = mclBlkConfig.memArea;
  753.     pDrvCtrl->mBlkSize = mclBlkConfig.memSize;
  755.     /* Calculate the memory size of all the clusters. */
  757.     clDesc.clSize = SH7615END_BUFSIZ;
  759.     clDesc.memSize = clDesc.clNum * (clDesc.clSize + sizeof(int));
  761.     clDesc.memArea = (char *) memalign (CL_ALIGNMENT, clDesc.memSize);
  763.     if (clDesc.memArea == NULL)
  764.         {
  765.         DRV_LOG (DRV_DEBUG_LOAD, "system memory unavailablen",
  766.                      1, 2, 3, 4, 5, 6);
  767.         return (ERROR);
  768.         }
  770.     /* store the pointer to the clBlock area - for show purposes */
  771.  
  772.     pDrvCtrl->pClBlkArea = clDesc.memArea;
  773.     pDrvCtrl->clBlkSize = clDesc.memSize;
  775.     /* Allocate and initialize the memory pool. */
  776.     
  777.     if ((pDrvCtrl->end.pNetPool = malloc (sizeof(NET_POOL))) == NULL)
  778.         return (ERROR);
  780.     if (netPoolInit(pDrvCtrl->end.pNetPool, &mclBlkConfig,
  781.                     &clDesc, 1, NULL) == ERROR)
  782.         {
  783.         DRV_LOG (DRV_DEBUG_LOAD, "Could not initialize net poolsn",
  784. 1, 2, 3, 4, 5, 6);
  785.         return (ERROR);
  786.         }
  788.     /* Save the cluster pool id */
  790.     pDrvCtrl->pClPoolId = netClPoolIdGet (pDrvCtrl->end.pNetPool,
  791.   SH7615END_BUFSIZ, FALSE);
  792.     if (pDrvCtrl->pClPoolId == NULL)
  793.         return (ERROR);
  795. #ifdef DRV_DEBUG
  796.     sh7615NetPoolId = pDrvCtrl->end.pNetPool;
  797.     sh7615ClPool  = pDrvCtrl->pClPoolId;
  798. #endif
  800.     /* Clear all indices */
  801.     pDrvCtrl->rxIndex=0;
  802.     pDrvCtrl->txIndex=0;
  803.     pDrvCtrl->txDiIndex=0;
  805.     pDrvCtrl->txCleaning = FALSE;
  806.     pDrvCtrl->rxHandling = FALSE;
  807.     pDrvCtrl->txBlocked = FALSE;
  809.     /* Setup the receive ring */
  811.     pRxD = pDrvCtrl->rxRing;
  813.     for (ix = 0; ix < pDrvCtrl->numRds; ix++, pRxD++)
  814.         {
  815.         pBuf = NET_BUF_ALLOC();
  817.         if (pBuf == NULL)
  818.             {
  819.     pDrvCtrl->lastError.errCode = END_ERR_NO_BUF;
  820.     muxError (&pDrvCtrl->end, &pDrvCtrl->lastError);
  821.             DRV_LOG (DRV_DEBUG_LOAD, "Could not get a buffern",
  822.                      1, 2, 3, 4, 5, 6);
  823.             return (ERROR);
  824.             }
  826.         pRxD->rDesc0 = RD0_OWN;                      /* chip owns the buffer */
  827.         pRxD->rDesc1 = SH7615END_BUFSIZ << 16;       /* max frame size */
  828.         pRxD->rDesc2 = NET_TO_SH7615END_BUF (pBuf);  /* buffer address */
  829.         pRxD->rDesc3 = (UINT32) pBuf;                /* The real cluster address */
  830.  
  831.         if (ix == (pDrvCtrl->numRds - 1))    /* if its is last one */
  832.             pRxD->rDesc0 |= RD0_RDL;         /* end of receive ring */
  833.         }
  835.     /* Setup the transmit ring */
  837.     pTxD = pDrvCtrl->txRing;
  839.     for (ix = 0; ix < pDrvCtrl->numTds; ix++, pTxD++)
  840.         {
  841.         /* empty -- no buffers at this time -- owner is host */
  843.         pTxD->tDesc0 = 0;
  844.         pTxD->tDesc1 = 0;
  845.         pTxD->tDesc2 = 0;
  846.         pTxD->tDesc3 = 0;
  847.  
  848.         if (ix == (pDrvCtrl->numTds - 1))    /* if its is last one */
  849.             pTxD->tDesc0 |= TD0_TDL;         /* end of transmit ring */
  850.         }
  852.     DRV_LOG (DRV_DEBUG_LOAD, "Memory setup completen", 1, 2, 3, 4, 5, 6);
  854.     return OK;
  855.     }
  857. /***************************************************************************
  858. *
  859. * sh7615EndRestart - restart the device
  860. *
  861. * Restarts the device after cleaning up the transmit and receive queues. This
  862. * routine should be called only after sh7615EndStop().
  863. *
  864. * RETURNS: OK or ERROR
  865. */
  866. LOCAL void sh7615EndRestart
  867.     (
  868.     DRV_CTRL *pDrvCtrl
  869.     )
  870.     {
  871.     SH7615_TD  *pTxD = pDrvCtrl->txRing;
  872.     FREE_BUF *pFreeBuf = pDrvCtrl->freeBuf;
  873.     SH7615_RD *pRxD;
  874.     int count;
  875.     
  876.     DRV_LOG (DRV_DEBUG_LOAD, "%s%d - restarting device.n",
  877.             (int)SH7615END_DEV_NAME, pDrvCtrl->unit, 0, 0, 0, 0);
  878.     
  879.     /* cleanup the tx and rx queues */
  881.     sh7615EndTxRingClean (pDrvCtrl);
  883.     while ((pRxD = sh7615EndRxDGet (pDrvCtrl)) != NULL)
  884. sh7615EndRecv (pDrvCtrl, pRxD);
  886.     /* drop rest of the queued tx packets */
  888.     for (count=pDrvCtrl->numTds; count > 0; count--, pTxD++, pFreeBuf++)
  889.         {
  890. /* Free buffers */
  892.         if (pFreeBuf->pClBuf != NULL)
  893.             {
  894.             NET_BUF_FREE(pFreeBuf->pClBuf);
  895.             pFreeBuf->pClBuf = NULL;
  896.             }
  898. /* These never had the chance to be sent */
  900.         if (pTxD->tDesc0 & TD0_OWN)
  901.             {
  902.             END_OBJ     *pEndObj = &pDrvCtrl->end;
  903.  
  904.             END_ERR_ADD (pEndObj, MIB2_OUT_ERRS, +1);
  905.             END_ERR_ADD (pEndObj, MIB2_OUT_UCAST, -1);
  906.             }
  908. /* Mark descriptors free */
  909. #if 0
  910. pTxD->tDesc0 &= TD0_CLEAR_ERRORS_N_STATS;
  911. #else
  912. /* Mark descriptors free */
  914.         pTxD->tDesc0 = 0;
  915.         pTxD->tDesc1 = 0;
  916.         pTxD->tDesc2 = 0;
  917.         pTxD->tDesc3 = 0;
  918.  
  919.         if (count == 1) /* if it is last one */
  920.             pTxD->tDesc0 |= TD0_TDL; /* end of transmit ring */
  921. #endif
  922.         }
  924.     /* Start the device */
  926.     sh7615EndStart (pDrvCtrl);
  927.     }
  930. /*******************************************************************************
  931. *
  932. * sh7615EndStart - start the device
  933. *
  934. * This function calls BSP functions to connect interrupts and start the
  935. * device running in interrupt mode. The driver must have already been loaded 
  936. * with the sh7615EndLoad() routine.
  937. *
  938. * RETURNS: OK or ERROR
  939. *
  940. */
  942. LOCAL STATUS sh7615EndStart
  943.     (
  944.     DRV_CTRL * pDrvCtrl /* device ID */
  945.     )
  946.     {
  947.     STATUS  result;
  949.     DRV_LOG (DRV_DEBUG_LOAD, "Starting shend n", 0, 0, 0, 0, 0, 0);
  951.     /* must have been loaded */
  952.  
  953.     if (!pDrvCtrl->loaded)
  954.         return (ERROR);
  956.     /* Reset the device */
  957.     sh7615EndReset (pDrvCtrl);
  959.     /* Clear all indices */
  960.     pDrvCtrl->rxIndex = 0;
  961.     pDrvCtrl->txIndex = 0;
  962.     pDrvCtrl->txDiIndex = 0;
  963.  
  964.     pDrvCtrl->txCleaning = FALSE;
  965.     pDrvCtrl->rxHandling = FALSE;
  966.     pDrvCtrl->txBlocked = FALSE;
  968.     /* Configure and start the device */
  970.     sh7615EndConfig (pDrvCtrl);
  972.     /* Connect the interrupt handler */
  974.     SYS_INT_CONNECT (pDrvCtrl, sh7615EndInt, (int)pDrvCtrl, &result);
  976.     if (result == ERROR)
  977. return ERROR;
  979.     /* mark the interface -- up */
  981.     END_FLAGS_SET (&pDrvCtrl->end, (IFF_UP | IFF_RUNNING));
  983.     /* Enable LAN interrupts */
  985.     SYS_INT_ENABLE (pDrvCtrl); 
  987.     return (OK);
  988.     }
  991. /*******************************************************************************
  992. *
  993. * sh7615EndStop - stop the device
  994. *
  995. * This function calls BSP functions to disconnect interrupts and stop
  996. * the device from operating in interrupt mode.
  997. *
  998. * RETURNS: OK or ERROR.
  999. */
  1001. LOCAL STATUS sh7615EndStop
  1002.     (
  1003.     DRV_CTRL * pDrvCtrl /* device to be stopped */
  1004.     )
  1005.     {
  1006.     STATUS  result = OK;
  1008.     /* mark the interface -- down */
  1010.     END_FLAGS_CLR (&pDrvCtrl->end, IFF_UP | IFF_RUNNING);
  1012.     /* stop transmit and receive */
  1014.     SH7615END_BIT_CLR(ETHERC_ECMR, ECMR_TE);    
  1015.     SH7615END_BIT_CLR(ETHERC_ECMR, ECMR_RE);   
  1016.  
  1017.     /* Disable LAN interrupts */
  1019.     SYS_INT_DISABLE (pDrvCtrl);
  1021.     SYS_INT_DISCONNECT (pDrvCtrl, sh7615EndInt, (int)pDrvCtrl, &result);
  1023.     return (result);
  1024.     }
  1027. /*******************************************************************************
  1028. *
  1029. * sh7615EndInt - handle controller interrupt
  1030. *
  1031. * This routine is called at interrupt level in response to an interrupt from
  1032. * the controller.
  1033. *
  1034. * RETURNS: N/A.
  1035. */
  1037. LOCAL void sh7615EndInt
  1038.     (
  1039.     DRV_CTRL * pDrvCtrl /* interrupting device */
  1040.     )
  1041.     {
  1042.     UINT32 status;
  1044.     /* Read the device status register */
  1046.     SH7615END_REG_READ (E_DMAC_EESR, status);
  1048.     /* if not one of our interrupts, exit */
  1050.     if ((status & pDrvCtrl->intrMask) == 0)
  1051.         {
  1052.         return;
  1053.         }
  1055.     /*
  1056.      * read is not destructive, so, lets clear the sources by writing
  1057.      * the status back. This is safe to do since writing a 0 value does
  1058.      * not clear the bit. New sources may have come in, but they'll be
  1059.      * latched into the interrupt controller and caught when we exit here.
  1060.      */
  1062.     SH7615END_REG_WRITE (E_DMAC_EESR, status);
  1064.     /* Handle link status change */
  1066.     if ((status & EESR_ECI) != 0)
  1067. {
  1068. UINT32 ecsr;
  1069. SH7615END_REG_READ (ETHERC_ECSR, ecsr);
  1070. SH7615END_REG_WRITE (ETHERC_ECSR, ecsr);
  1071. if ((ecsr & ECSR_LCHNG) != 0)
  1072.     {
  1073.             DRV_LOG (DRV_DEBUG_INT, "%s%d - link status changen",
  1074.                      (int)SH7615END_DEV_NAME, pDrvCtrl->unit, 0, 0, 0, 0);
  1075.     
  1076.     sh7615EndStop (pDrvCtrl);
  1077.     netJobAdd ((FUNCPTR)sh7615EndRestart, (int)pDrvCtrl, 0, 0, 0, 0);
  1078.     return;
  1079.     }
  1080. }
  1082.     /* Handle received packets */
  1083.     
  1084.     if ((status & EESR_FR) && (!pDrvCtrl->rxHandling)) 
  1085.         {
  1086.         /* DRV_LOG (DRV_DEBUG_INT, "Recieve Int!! n", 0, 0, 0, 0, 0, 0); */
  1088.         if (netJobAdd ((FUNCPTR)sh7615EndRcvIntHandle, 
  1089.                        (int)pDrvCtrl, 0, 0, 0, 0) == OK)
  1090.             {
  1091.             /*
  1092.      * prevent additional scheduling of task level recv handling due
  1093.              * to new recv ints that may have been latched since we entered
  1094.              * here.
  1095.              */
  1097.             pDrvCtrl->rxHandling = TRUE;
  1099.             /*
  1100.      * disable Rx ints - we've already got a handler scheduled so
  1101.              * no need to come in here again. Note, that we may already have
  1102.              * latched a recv int since we entered here and cleared the status
  1103.              * bits above. the rxHandling will ensure that guy schedules no
  1104.              * no more jobs.
  1105.              */
  1107.             SH7615END_BIT_CLR (E_DMAC_EESIPR, EESIPR_FRIP);
  1108.             }
  1109.         }
  1111. #ifdef DRV_DEBUG
  1112.     if (status & EESR_RFCOF)
  1113.         sh7615EndRfcof++;
  1114.     if (status & EESR_ECI)
  1115.         sh7615EndEci++;
  1116.     if (status & EESR_TC)
  1117.         sh7615EndTc++;
  1118.     if (status & EESR_TDE)
  1119.         sh7615EndTde++;
  1120.     if (status & EESR_TFUF)
  1121.         sh7615EndTfuf++;
  1122.     if (status & EESR_FR)
  1123.         sh7615EndFr++;
  1124.     if (status & EESR_RDE)
  1125.         sh7615EndRde++;
  1126.     if (status & EESR_RFOF)
  1127.         sh7615EndRfof++;
  1128.     if (status & EESR_ITF)
  1129.         sh7615EndItf++;
  1130.     if (status & EESR_CND)
  1131.         sh7615EndCnd++;
  1132.     if (status & EESR_DLC)
  1133.         sh7615EndDlc++;
  1134.     if (status & EESR_CD)
  1135.         sh7615EndCd++;
  1136.     if (status & EESR_TRO)
  1137.         sh7615EndTro++;
  1138.     if (status & EESR_RMAF)
  1139.         sh7615EndRmaf++;
  1140.     if (status & EESR_RRF)
  1141.         sh7615EndRrf++;
  1142.     if (status & EESR_RTLF)
  1143.         sh7615EndRtlf++;
  1144.     if (status & EESR_RTSF)
  1145.         sh7615EndRtsf++;
  1146.     if (status & EESR_PRE)
  1147.         sh7615EndPre++;
  1148.     if (status & EESR_CERF)
  1149.         sh7615EndCerf++;
  1150. #endif
  1152.     /* Cleanup TxRing */
  1153.  
  1154.     if ((status & EESR_TC) && (!pDrvCtrl->txCleaning))
  1155. {
  1156. DRV_LOG (DRV_DEBUG_INT, "Cleanup TxRing from Int() n", 0, 0, 0, 0, 0, 0);
  1158. pDrvCtrl->txCleaning = TRUE;
  1159.  
  1160. netJobAdd ((FUNCPTR)sh7615EndTxRingClean, (int)pDrvCtrl, 0, 0, 0, 0);
  1161. }
  1163.     if (pDrvCtrl->txBlocked)
  1164. {
  1165. pDrvCtrl->txBlocked = FALSE;
  1166. netJobAdd ((FUNCPTR)muxTxRestart, (int)&pDrvCtrl->end, 0, 0, 0, 0);
  1167. }
  1169.     }
  1172. /*******************************************************************************
  1173. *
  1174. * sh7615EndRxDGet - get next receive descriptor
  1175. *
  1176. * Get next receive descriptor.  Returns NULL if none are ready.
  1177. *
  1178. * RETURNS: ptr to next packet, or NULL if none ready.
  1179. */
  1181. LOCAL SH7615_RD * sh7615EndRxDGet
  1182.     (
  1183.     DRV_CTRL * pDrvCtrl /* device structure */
  1184.     )
  1185.     {
  1186.     SH7615_RD * pRxD = pDrvCtrl->rxRing + pDrvCtrl->rxIndex;
  1187.  
  1188.     /* check if the descriptor is owned by the chip. The chip will clear
  1189.      * this bit once it has completed writing to the buffer.
  1190.      */
  1192.     if (pRxD->rDesc0 & RD0_OWN)
  1193.         return NULL;
  1195.     return pRxD;
  1196.     }
  1199. /*******************************************************************************
  1200. *
  1201. * sh7615EndTxDGet - get an available transmit descriptor
  1202. *
  1203. * Get next transmit descriptor.  Returns NULL if none are ready.
  1204. *
  1205. * RETURNS: an available transmit descriptor, otherwise NULL.
  1206. */
  1207.  
  1208. LOCAL SH7615_TD * sh7615EndTxDGet
  1209.     (
  1210.     DRV_CTRL * pDrvCtrl
  1211.     )
  1212.     {
  1213.     SH7615_TD * pTxD = pDrvCtrl->txRing + pDrvCtrl->txIndex;
  1214.  
  1215.     /* check if this descriptor is owned by the chip or is out of bounds */
  1216.     if ((pTxD->tDesc0 & TD0_OWN) ||
  1217.         (((pDrvCtrl->txIndex + 1) % pDrvCtrl->numTds) == pDrvCtrl->txDiIndex))
  1218.         return (NULL);
  1219.  
  1220.     return pTxD;
  1221.     }
  1223. /*******************************************************************************
  1224. *
  1225. * sh7615EndTxRingClean - clean up processed tx descriptors
  1226. *
  1227. * This routine processes the transmit queue, freeing all transmitted
  1228. * descriptors.
  1229. *
  1230. * RETURNS: None
  1231. */
  1232. LOCAL void sh7615EndTxRingClean
  1233.     (
  1234.     DRV_CTRL * pDrvCtrl
  1235.     )
  1236.     {
  1237.     SH7615_TD * pTxD;
  1239.     pDrvCtrl->txCleaning = TRUE;
  1240.  
  1241.     while (pDrvCtrl->txDiIndex != pDrvCtrl->txIndex)
  1242.         {
  1243.         pTxD = pDrvCtrl->txRing + pDrvCtrl->txDiIndex;
  1244.  
  1245. /* All handled, break from the loop */
  1247.         if (pTxD->tDesc0 & TD0_OWN)
  1248.             break;
  1249.  
  1250.         /* free the buffer */
  1251.  
  1252.         if (pDrvCtrl->freeBuf[pDrvCtrl->txDiIndex].pClBuf != NULL)
  1253.             {
  1254.             NET_BUF_FREE(pDrvCtrl->freeBuf[pDrvCtrl->txDiIndex].pClBuf);
  1255.             pDrvCtrl->freeBuf[pDrvCtrl->txDiIndex].pClBuf = NULL;
  1256.             }
  1257.  
  1258.         pDrvCtrl->txDiIndex =  (pDrvCtrl->txDiIndex + 1) % pDrvCtrl->numTds;
  1260.         /* count collisions */
  1261. #if 0
  1262.         if (! (pTxD->tDesc0 & TD0_CD))
  1263.             END_ERR_ADD (pEndObj, MIB2_COLLISIONS,
  1264.                          SH7615END_REG_READ (ETHERC_CDCR));
  1265. #endif
  1266.  
  1267.         if (pTxD->tDesc0 & TD0_TFE)
  1268.             {
  1269.             END_OBJ     *pEndObj = &pDrvCtrl->end;
  1270.  
  1271.             END_ERR_ADD (pEndObj, MIB2_OUT_ERRS, +1);
  1272.             END_ERR_ADD (pEndObj, MIB2_OUT_UCAST, -1);
  1273.  
  1274. #ifdef DRV_DEBUG
  1275.             /* check for no carrier */
  1276.             if (pTxD->tDesc0 & (TD0_CND | TD0_DLC))
  1277.                 {
  1278.                 logMsg ("%s%d - no carriern",
  1279.                         (int)SH7615END_DEV_NAME, pDrvCtrl->unit, 0, 0, 0, 0);
  1280.                 }
  1281.     sh7615EndTfe++;
  1282. #endif /* DRV_DEBUG */
  1283.             }
  1285.         /* clear errors and stats but don't touch TDL bit */
  1286.  
  1287.         pTxD->tDesc0 &= TD0_CLEAR_ERRORS_N_STATS;
  1288.         }
  1289.  
  1290.     pDrvCtrl->txCleaning = FALSE;
  1291.  
  1292.     return;
  1293.     }
  1296. /*******************************************************************************
  1297. *
  1298. * sh7615EndRecv - process the next incoming packet
  1299. *
  1300. * Handle one incoming packet.  The packet is checked for errors.
  1301. *
  1302. * RETURNS: N/A.
  1303. */
  1305. LOCAL STATUS sh7615EndRecv
  1306.     (
  1307.     DRV_CTRL *  pDrvCtrl, /* device structure */
  1308.     SH7615_RD * pRxD  /* packet to process */
  1309.     )
  1310.     {
  1311.     END_OBJ *   pEndObj = &pDrvCtrl->end;
  1312.     M_BLK_ID  pMblk;
  1313.     CL_BLK_ID pClBlk;
  1314.     char*       pNewCluster;
  1315.     int         len;
  1317.     /* check for errors */
  1319.     if (pRxD->rDesc0 & RD0_RFE)
  1320.         {
  1321.         DRV_LOG (DRV_DEBUG_RX, "Receive with error RD0 = 0x%08x n", 
  1322.  pRxD->rDesc0, 2, 3, 4, 5, 6);
  1323.         END_ERR_ADD (pEndObj, MIB2_IN_ERRS, +1);
  1324.         goto cleanRxD;
  1325.         }
  1327.     DRV_LOG (DRV_DEBUG_RX, "Receive start n", 1, 2, 3, 4, 5, 6);
  1329.     /*
  1330.      * We implicitly are loaning here, if copying is necessary this
  1331.      * step may be skipped, but the data must be copied before being
  1332.      * passed up to the protocols.
  1333.      */
  1334.     
  1335.     pNewCluster = NET_BUF_ALLOC ();
  1337.     if (pNewCluster == NULL)
  1338.         {
  1339. pDrvCtrl->lastError.errCode = END_ERR_NO_BUF;
  1340. muxError (&pDrvCtrl->end, &pDrvCtrl->lastError);
  1341. DRV_LOG (DRV_DEBUG_RX, "Cannot loan!n", 1, 2, 3, 4, 5, 6);
  1342. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1344. goto cleanRxD;
  1345.         }
  1347.     /* Grab a cluster block to marry to the cluster we received. */
  1349.     if ((pClBlk = netClBlkGet (pDrvCtrl->end.pNetPool, M_DONTWAIT)) == NULL)
  1350.         {
  1351. pDrvCtrl->lastError.errCode = END_ERR_NO_BUF;
  1352. muxError (&pDrvCtrl->end, &pDrvCtrl->lastError);
  1353.         NET_BUF_FREE (pNewCluster);
  1354. DRV_LOG (DRV_DEBUG_RX, "Out of Cluster Blocks!n", 1, 2, 3, 4, 5, 6);
  1355. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1356. goto cleanRxD;
  1357.         }
  1358.     
  1359.     /*
  1360.      * OK we've got a spare, let's get an M_BLK_ID and marry it to the
  1361.      * one in the ring.
  1362.      */
  1364.     if ((pMblk = mBlkGet (pDrvCtrl->end.pNetPool, M_DONTWAIT, MT_DATA)) == NULL)
  1365.         {
  1366.         netClBlkFree (pDrvCtrl->end.pNetPool, pClBlk); 
  1367.         NET_BUF_FREE (pNewCluster);
  1368. DRV_LOG (DRV_DEBUG_RX, "Out of M Blocks!n", 1, 2, 3, 4, 5, 6);
  1369. END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1370. goto cleanRxD;
  1371.         }
  1373.     END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_UCAST, +1);
  1375.     len = SH7615END_FRAME_LEN_GET (pRxD->rDesc1); 
  1377.     /*
  1378.      * Invalidate cache and copy to ensure 4 byte alignment of IP header.
  1379.      * This is required by the IP network stack.
  1380.      */ 
  1382.     SH7615END_CACHE_INVALIDATE ((char *) (pRxD->rDesc2), len);
  1384.     len = (len + 1) & 0xfffffffe;
  1386.     bcopy((char*)pRxD->rDesc2,(char*)pRxD->rDesc2+2,len);
  1388.     /* Join the cluster to the MBlock */
  1390.     netClBlkJoin (pClBlk, (char *) (pRxD->rDesc3), SH7615END_BUFSIZ, NULL, 
  1391.   0, 0, 0);
  1392.     netMblkClJoin (pMblk, pClBlk);
  1394.     pMblk->mBlkHdr.mFlags |= M_PKTHDR;
  1395.     pMblk->mBlkHdr.mLen = len;
  1396.     pMblk->mBlkHdr.mData = (char *) (pRxD->rDesc2 + 2);
  1397.     pMblk->mBlkPktHdr.len  = pMblk->mBlkHdr.mLen;
  1399.     /* save the new True data buffer address for freeing later */
  1400.  
  1401.     pRxD->rDesc3 = (UINT32) pNewCluster;
  1403.     /* Install new data buffer - force 16 byte alignment */
  1405.     pRxD->rDesc2 = NET_TO_SH7615END_BUF (pNewCluster);
  1407.     /* mark the descriptor ready to receive, preserve the RDL bit */
  1408.  
  1409.     pRxD->rDesc0 = (pRxD->rDesc0 & RD0_RDL) | RD0_OWN;
  1410.  
  1411.     /* advance management index */
  1412.  
  1413.     pDrvCtrl->rxIndex = (pDrvCtrl->rxIndex + 1) % pDrvCtrl->numRds;
  1414.  
  1415.     /* Call the upper layer's receive routine. */
  1417.     DRV_LOG (DRV_DEBUG_RX, "Calling upper layer!n", 1, 2, 3, 4, 5, 6);
  1419.     END_RCV_RTN_CALL(&pDrvCtrl->end, pMblk);
  1421.     return (OK);
  1423. cleanRxD:
  1425.     /* mark the descriptor ready to receive - make sure to preserve the RDL bit */
  1427.     pRxD->rDesc0 = (pRxD->rDesc0 & RD0_RDL) | RD0_OWN;
  1428.  
  1429.     /* advance management index */
  1430.  
  1431.     pDrvCtrl->rxIndex = (pDrvCtrl->rxIndex + 1) % pDrvCtrl->numRds;
  1433.     return (OK);
  1434.     }
  1436. /*******************************************************************************
  1437. *
  1438. * sh7615EndRcvIntHandle - task level interrupt service for input packets
  1439. *
  1440. * This routine is called at task level indirectly by the interrupt
  1441. * service routine to do any message received processing.
  1442. *
  1443. * RETURNS: N/A.
  1444. */
  1446. LOCAL void sh7615EndRcvIntHandle
  1447.     (
  1448.     DRV_CTRL *pDrvCtrl /* interrupting device */
  1449.     )
  1450.     {
  1451.     SH7615_RD *pRxD;
  1453.     pDrvCtrl->rxHandling = TRUE; /* interlock with sh7615EndInt() */
  1455.     while ((pRxD = sh7615EndRxDGet (pDrvCtrl)) != NULL)
  1456. sh7615EndRecv (pDrvCtrl, pRxD);
  1458.     pDrvCtrl->rxHandling = FALSE; /* interlock with sh7615EndInt() */
  1460.     /* Make sure the Receive Request is still ON */
  1462.     SH7615END_REG_WRITE(E_DMAC_EDRRR, EDRRR_RR);
  1464.     /* enable receive interrupt */
  1466.     SH7615END_BIT_SET (E_DMAC_EESIPR, EESIPR_FRIP);
  1467.     }
  1469. /*******************************************************************************
  1470. *
  1471. * sh7615EndSend - transmit an ethernet packet
  1472. *
  1473. * This routine takes a M_BLK_ID sends off the data in the M_BLK_ID.
  1474. * The buffer must already have the addressing information properly installed
  1475. * in it.  This is done by a higher layer.  The last arguments are a free
  1476. * routine to be called when the device is done with the buffer and a pointer
  1477. * to the argument to pass to the free routine.
  1478. *
  1479. * RETURNS: OK on success; and ERROR otherwise.
  1480. */
  1481.  
  1482. LOCAL STATUS sh7615EndSend
  1483.     (
  1484.     DRV_CTRL * pDrvCtrl,
  1485.     M_BLK * pMblk
  1486.     )
  1487.     {
  1488.     SH7615_TD * pTxD;
  1489.     char *      pBuf;
  1490.     int         len;
  1492.     DRV_LOG (DRV_DEBUG_TX, "EndSendn", 1, 2, 3, 4, 5, 6);
  1494.     /* Gain exclusive access to transmit */
  1496.     END_TX_SEM_TAKE (&pDrvCtrl->end, WAIT_FOREVER);
  1497.  
  1498.     /* Get the next TXD */
  1500.     pTxD = sh7615EndTxDGet (pDrvCtrl);
  1502.     if (pTxD == NULL)
  1503.         {
  1504.         DRV_LOG (DRV_DEBUG_TX, "No available TxD-s n", 1, 2, 3, 4, 5, 6);
  1505.         END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_ERRS, +1);
  1506.         END_TX_SEM_GIVE (&pDrvCtrl->end);
  1507.  
  1508.         if (!pDrvCtrl->txCleaning && !pDrvCtrl->txBlocked)
  1509.             sh7615EndTxRingClean (pDrvCtrl);
  1510.  
  1511.         pDrvCtrl->txBlocked = TRUE;        /* transmitter not ready */
  1512.  
  1513.         return (END_ERR_BLOCK); /* just return without freeing mBlk chain */
  1514.         }
  1515.  
  1516.     pBuf = NET_BUF_ALLOC();
  1518.     if (pBuf == NULL)
  1519.         {
  1520. pDrvCtrl->lastError.errCode = END_ERR_NO_BUF;
  1521. muxError (&pDrvCtrl->end, &pDrvCtrl->lastError);
  1522.         DRV_LOG (DRV_DEBUG_TX, "No available TxBufs n", 1, 2, 3, 4, 5, 6);
  1523.         END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_ERRS, +1);
  1524.         END_TX_SEM_GIVE (&pDrvCtrl->end);
  1525.  
  1526.         if (!pDrvCtrl->txCleaning && !pDrvCtrl->txBlocked)
  1527.             sh7615EndTxRingClean (pDrvCtrl);
  1528.  
  1529.         pDrvCtrl->txBlocked = TRUE;        /* transmitter not ready */
  1530.         return (END_ERR_BLOCK); /* just return without freeing mBlk chain */
  1531.         }
  1533.     /*
  1534.      * Store the buf info. Do this before adjusting alignment below 
  1535.      * so that the netBufFree will work correctly later.
  1536.      */
  1537.  
  1538.     pDrvCtrl->freeBuf[pDrvCtrl->txIndex].pClBuf = pBuf;
  1539.  
  1540.     /* force 16 byte alignment of send buffer */
  1542.     (UINT32) pBuf = NET_TO_SH7615END_BUF (pBuf);
  1543.  
  1544.     /* Now copy data to 16 byte aligned location in pBuf and free Mblk */
  1546.     len = netMblkToBufCopy (pMblk, pBuf, NULL);
  1547.     len = max (ETHERSMALL, len);
  1549.     netMblkClChainFree (pMblk);
  1551.     /* flush the cache, if necessary */
  1552.  
  1553.     SH7615END_CACHE_FLUSH (pBuf, len);
  1555.     /* initialize the transmit descriptor -- preserve TD0_TDL bit */
  1557.     pTxD->tDesc0  = ((pTxD->tDesc0 & TD0_TDL) | (TD0_OWN | TD0_TFP));
  1558.     pTxD->tDesc1 = SH7615END_TBS_PUT(len);
  1559.     pTxD->tDesc2 = (UINT32) pBuf;
  1560.     pTxD->tDesc3 = 0;
  1562.     /* Advance our management index */
  1563.     pDrvCtrl->txIndex = (pDrvCtrl->txIndex + 1) % pDrvCtrl->numTds;
  1565.     SH7615END_REG_WRITE(E_DMAC_EDTRR, EDTRR_TR);  /* Transmit request */
  1567.     END_TX_SEM_GIVE (&pDrvCtrl->end);
  1568.  
  1569.     /* update statistics */
  1570.     END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_UCAST, +1);
  1571.  
  1572.     return (OK);
  1573.     }
  1575. /*******************************************************************************
  1576. *
  1577. * sh7615EndPollStart - starting polling mode
  1578. *
  1579. * This routine starts polling mode by disabling ethernet interrupts and
  1580. * setting the polling flag in the END_CTRL stucture.
  1581. *
  1582. * RETURNS: OK, always.
  1583. */
  1584.  
  1585. LOCAL STATUS sh7615EndPollStart
  1586.     (
  1587.     DRV_CTRL *  pDrvCtrl
  1588.     )
  1589.     {
  1590.     int         intLevel;
  1591.  
  1592.     DRV_LOG (DRV_DEBUG_POLL, "PollStartn", 1, 2, 3, 4, 5, 6);
  1593.  
  1594.     intLevel = intLock();
  1595.  
  1596.     /* Disable system interrupts */
  1598.     SYS_INT_DISABLE (pDrvCtrl);
  1599.  
  1600.     /* mask interrupts */
  1602.     SH7615END_BIT_CLR(E_DMAC_EESIPR, pDrvCtrl->intrMask);
  1603.  
  1604.     DRV_FLAGS_SET (SH7615END_POLLING);
  1605.  
  1606.     intUnlock (intLevel);
  1607.  
  1608.     return (OK);
  1609.     }
  1611. /*******************************************************************************
  1612. *
  1613. * sh7615EndPollStop - stop polling mode
  1614. *
  1615. * This function terminates polled mode operation.  The device returns to
  1616. * interrupt mode.
  1617. *
  1618. * The device interrupts are enabled, the current mode flag is switched
  1619. * to indicate interrupt mode and the device is then reconfigured for
  1620. * interrupt operation.
  1621. *
  1622. * RETURNS: OK, always.
  1623. */
  1624.  
  1625. LOCAL STATUS sh7615EndPollStop
  1626.     (
  1627.     DRV_CTRL *  pDrvCtrl
  1628.     )
  1629.     {
  1630.     int intLevel;
  1632.     DRV_LOG (DRV_DEBUG_POLL, "PollStopn", 1, 2, 3, 4, 5, 6);
  1634.     intLevel = intLock();
  1635.  
  1636.     DRV_FLAGS_CLR (SH7615END_POLLING);
  1638.     /* Enable chip interrupts */
  1640.     SH7615END_REG_WRITE(E_DMAC_EESIPR, pDrvCtrl->intrMask);
  1641.  
  1642.     /* Enable system interrupts */
  1644.     SYS_INT_ENABLE (pDrvCtrl);
  1646.     intUnlock (intLevel);
  1647.  
  1648.     DRV_LOG (DRV_DEBUG_POLL, "sn", 1, 2, 3, 4, 5, 6);
  1649.  
  1650.     return (OK);
  1651.     }
  1653. /*******************************************************************************
  1654. *
  1655. * sh7615EndPollSend - send a packet in polled mode
  1656. *
  1657. * This routine is called by a user to try and send a packet on the
  1658. * device.
  1659. *
  1660. * RETURNS: OK on success, EAGAIN on failure
  1661. */
  1662.  
  1663. LOCAL STATUS sh7615EndPollSend
  1664.     (
  1665.     DRV_CTRL * pDrvCtrl,
  1666.     M_BLK * pMblk
  1667.     )
  1668.     {
  1669.     SH7615_TD * pTxD;
  1670.     char * pBuf;
  1671.     char * pBufAligned;
  1672.     int len;
  1673.  
  1674.     DRV_LOG (DRV_DEBUG_POLL, "PollSendn", 1, 2, 3, 4, 5, 6);
  1676.     pTxD = sh7615EndTxDGet (pDrvCtrl);
  1678.     pBuf = NET_BUF_ALLOC ();
  1679.  
  1680.     if ((pTxD == NULL) || (pBuf == NULL))
  1681.         {
  1682. pDrvCtrl->lastError.errCode = END_ERR_NO_BUF;
  1683. muxError (&pDrvCtrl->end, &pDrvCtrl->lastError);
  1684.         sh7615EndTxRingClean (pDrvCtrl);
  1685.         if (pBuf)  NET_BUF_FREE (pBuf);
  1686.         return (EAGAIN);
  1687.         }
  1690.     /* force 16 byte alignment of send buffer */
  1691.  
  1692.     (UINT32) pBufAligned = NET_TO_SH7615END_BUF (pBuf);
  1693.  
  1694.     /* copy the MBLK */
  1696.     len = netMblkToBufCopy (pMblk, pBufAligned, NULL);
  1697.     len = max (ETHERSMALL, len);
  1699.     /* flush the cache, if necessary */
  1700.  
  1701.     SH7615END_CACHE_FLUSH (pBufAligned, len);
  1702.  
  1703.     pTxD->tDesc0 = ((pTxD->tDesc0 & TD0_TDL) | (TD0_OWN | TD0_TFP));
  1704.     pTxD->tDesc1 = SH7615END_TBS_PUT(len);
  1705.     pTxD->tDesc2 = (UINT32) pBufAligned;
  1706.     pTxD->tDesc3 = 0;
  1707.  
  1708.     /* Advance our management index */
  1709.     pDrvCtrl->txIndex = (pDrvCtrl->txIndex + 1) % pDrvCtrl->numTds;
  1710.  
  1711.     /* Transmit request */
  1712.     SH7615END_REG_WRITE(E_DMAC_EDTRR, EDTRR_TR);  
  1714.     /* The buffer does not belong to us; Spin until it can be freed */
  1716.     while (pTxD->tDesc0 & TD0_OWN)
  1717.         ;
  1719.     NET_BUF_FREE (pBuf);
  1720.  
  1721.     /* Try again on transmit errors */
  1723.     if (pTxD->tDesc0 & TD0_TFE)
  1724.         return (EAGAIN);
  1726.     return (EAGAIN);
  1727.     }
  1729. /*******************************************************************************
  1730. *
  1731. * sh7615EndPollReceive - get a packet in polled mode
  1732. *
  1733. * This routine is called by a user to try and get a packet from the
  1734. * device.
  1735. *
  1736. * RETURNS: OK on success, EAGAIN on failure.
  1737. */
  1738.  
  1739. LOCAL STATUS sh7615EndPollReceive
  1740.     (
  1741.     DRV_CTRL    *pDrvCtrl,
  1742.     M_BLK       *pMblk
  1743.     )
  1744.     {
  1745.     SH7615_RD  *pRxD;
  1746.     char        *pRxBuf;
  1747.     int         len;
  1748.     BOOL        gotOne=FALSE;
  1749.  
  1750.     DRV_LOG (DRV_DEBUG_POLL, "PollReceiven", 1, 2, 3, 4, 5, 6);
  1752.     if ((pMblk->mBlkHdr.mFlags & M_EXT) != M_EXT)
  1753.         return (EAGAIN);
  1755.     while (((pRxD = sh7615EndRxDGet (pDrvCtrl)) != NULL) && !gotOne)
  1756.         {
  1757.         /* Check if the packet was received OK */
  1759.         if (pRxD->rDesc0 & RD0_RFE)
  1760.             {
  1761.             /* Update the error statistics and discard the packet */
  1762.             END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  1763.             }
  1764.         else
  1765.             {
  1766.             len = SH7615END_FRAME_LEN_GET (pRxD->rDesc1);
  1768.             if ((len <= pMblk->mBlkHdr.mLen) && (len >= ETHERSMALL))
  1769.                 {
  1770.                 gotOne = TRUE;
  1771.                 END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_UCAST, +1);
  1772.  
  1773.                 pMblk->mBlkHdr.mFlags |= M_PKTHDR; /* set the packet header */
  1774.                 pMblk->mBlkHdr.mLen = len;         /* set the data len */
  1775.                 pMblk->mBlkPktHdr.len = len;       /* set the total len */
  1776.  
  1777. /* cache invalidate to prepare for the copy */
  1779.                 pRxBuf = (char *) pRxD->rDesc2;
  1780.                 SH7615END_CACHE_INVALIDATE (pRxBuf, len);
  1782.                 /* bump the buffer mData by 2 to ensure alignment */
  1784.                 pMblk->mBlkHdr.mData +=2;
  1785.                 bcopy (pRxBuf, (char *)pMblk->mBlkHdr.mData, len);
  1786.                 }
  1787.             }
  1789.         /* mark the descriptor ready to receive - preserve the RDL bit */
  1790.  
  1791.         pRxD->rDesc0 = (pRxD->rDesc0 & RD0_RDL) | RD0_OWN;
  1792.  
  1793.         pDrvCtrl->rxIndex = (pDrvCtrl->rxIndex + 1) % pDrvCtrl->numRds;
  1794.         }
  1796.     return (gotOne ? OK : EAGAIN);
  1797.     }
  1799. /*******************************************************************************
  1800. *
  1801. * sh7615EndIoctl - the driver I/O control routine
  1802. *
  1803. * Process an ioctl request.
  1804. *
  1805. * This routine implements the network interface control functions.
  1806. * It handles EIOCSADDR, EIOCGADDR, EIOCSFLAGS, EIOCGFLAGS, EIOCMULTIADD,
  1807. * EIOCMULTIDEL, EIOCMULTIGET, EIOCPOLLSTART, EIOCPOLLSTOP, EIOCGMIB2 commands.
  1808. *
  1809. * RETURNS: A command specific response, usually OK or ERROR.
  1810. */
  1812. LOCAL STATUS sh7615EndIoctl
  1813.     (
  1814.     DRV_CTRL * pDrvCtrl, /* device receiving command */
  1815.     int cmd, /* ioctl command code */
  1816.     caddr_t  data /* command argument */
  1817.     )
  1818.     {
  1819.     int  error = 0;
  1820.     long  value;
  1821.     int         savedFlags;
  1822.     END_OBJ *   pEndObj=&pDrvCtrl->end;
  1824.     DRV_LOG (DRV_DEBUG_IOCTL, "Ioctl unit=0x%x cmd=%d data=0x%xn",
  1825.      pDrvCtrl->unit, cmd, (int)data, 4, 5, 6);
  1827.     switch (cmd)
  1828.         {
  1829.         case EIOCSADDR:
  1830.     if (data == NULL)
  1831. return (EINVAL);
  1832.             bcopy ((char *)data, (char *)END_HADDR(pEndObj),
  1833.    END_HADDR_LEN(pEndObj));
  1835.             break;
  1837.         case EIOCGADDR:
  1838.     if (data == NULL)
  1839. return (EINVAL);
  1840.             bcopy ((char *)END_HADDR(pEndObj), (char *)data,
  1841.     END_HADDR_LEN(pEndObj));
  1843.             break;
  1845.         case EIOCSFLAGS:
  1846.     value = (long)data;
  1847.     if (value < 0)
  1848. {
  1849. value = -value;
  1850.                 value--;
  1851. END_FLAGS_CLR (pEndObj, value);
  1852. }
  1853.     else
  1854. {
  1855. END_FLAGS_SET (pEndObj, value);
  1856. }
  1858.             /* handle IIF_PROMISC and IFF_ALLMULTI */
  1859.  
  1860.             savedFlags = DRV_FLAGS_GET();
  1861.             if (END_FLAGS_ISSET (pEndObj, IFF_PROMISC))
  1862.                 DRV_FLAGS_SET (SH7615END_PROMISC);
  1863.             else
  1864.                 DRV_FLAGS_CLR (SH7615END_PROMISC);
  1865.  
  1866.             if (END_FLAGS_GET(pEndObj) & (IFF_MULTICAST | IFF_ALLMULTI))
  1867.                 DRV_FLAGS_SET (SH7615END_MCAST);
  1868.             else
  1869.                 DRV_FLAGS_CLR (SH7615END_MCAST);
  1870.  
  1871.             DRV_LOG (DRV_DEBUG_IOCTL,
  1872.                        "EIOCSFLAGS!! endFlags=0x%x savedFlags=0x%x newFlags=0x%xn",
  1873.                         END_FLAGS_GET(pEndObj), savedFlags, DRV_FLAGS_GET(), 4, 5, 6);
  1874.  
  1875.             if ((DRV_FLAGS_GET() != savedFlags) &&
  1876.                 (END_FLAGS_GET(pEndObj) & IFF_UP))
  1877.                 sh7615EndModeSet (pDrvCtrl);
  1879.             break;
  1881.         case EIOCGFLAGS:
  1882.             DRV_LOG (DRV_DEBUG_IOCTL, "EIOCGFLAGS IOCTL: 0x%x: 0x%xn",
  1883.                     pEndObj->flags, *(long *)data, 0, 0, 0, 0);
  1884.  
  1885.             if (data == NULL)
  1886.                 error = EINVAL;
  1887.             else
  1888.                 *(long *)data = END_FLAGS_GET(pEndObj);
  1889.  
  1890.             break;
  1892.         case EIOCMULTIADD:
  1893.             DRV_LOG (DRV_DEBUG_IOCTL, "IOCTL EIOCMULTIADDn", 1, 2, 3, 4, 5, 6);
  1894.             error = sh7615EndMCastAddrAdd (pDrvCtrl, (char *)data);
  1895.             break;
  1896.  
  1897.         case EIOCMULTIDEL:
  1898.             DRV_LOG (DRV_DEBUG_IOCTL, "IOCTL EIOCMULTIDELn", 1, 2, 3, 4, 5, 6);
  1899.             error = sh7615EndMCastAddrDel (pDrvCtrl, (char *)data);
  1900.             break;
  1901.  
  1902.         case EIOCMULTIGET:
  1903.             DRV_LOG (DRV_DEBUG_IOCTL, "IOCTL EIOCMULTIGETn", 1, 2, 3, 4, 5, 6);
  1904.             error = sh7615EndMCastAddrGet (pDrvCtrl, (MULTI_TABLE *)data);
  1905.             break;
  1907.         case EIOCPOLLSTART:
  1908.             DRV_LOG (DRV_DEBUG_IOCTL, "IOCTL EIOCPOLLSTARTn", 1, 2, 3, 4, 5, 6);
  1909.             sh7615EndPollStart (pDrvCtrl);
  1910.             break;
  1911.  
  1912.         case EIOCPOLLSTOP:
  1913.             DRV_LOG (DRV_DEBUG_IOCTL, "IOCTL EIOCPOLLSTOPn", 1, 2, 3, 4, 5, 6);
  1914.             sh7615EndPollStop (pDrvCtrl);
  1915.             break;
  1917.         case EIOCGMIB2:
  1918.             if (data == NULL)
  1919.                 error=EINVAL;
  1920.             else
  1921.                 bcopy((char *)&pEndObj->mib2Tbl, (char *)data,
  1922.                       sizeof(pEndObj->mib2Tbl));
  1923.             DRV_LOG (DRV_DEBUG_IOCTL, "IOCTL EIOCGMIB2n", 1, 2, 3, 4, 5, 6);
  1924.             break;
  1925.  
  1926.         default:
  1927.             error = EINVAL;
  1928.         }
  1930.     return (error);
  1931.     }
  1933. /*******************************************************************************
  1934. *
  1935. * sh7615EndModeSet - promiscuous & multicast operation 
  1936. *
  1937. * This routine enables promiscuous and duplex mode if corresponding flags 
  1938. * are set.
  1939. *
  1940. * RETURNS: N/A
  1941. */
  1942.  
  1943. LOCAL void sh7615EndModeSet
  1944.     (
  1945.     DRV_CTRL    *pDrvCtrl
  1946.     )
  1947.     {
  1948.     /* NOTE - manual says mode should not be changed while
  1949.        Rx/Tx is enabled. To modify mode settings, first issue
  1950.        software reset */
  1952.     /* Set promiscuous mode if necessary */
  1954.     if (DRV_FLAGS_ISSET (SH7615END_PROMISC))
  1955. SH7615END_BIT_SET (ETHERC_ECMR, ECMR_PRM);
  1957.     /* Set duplex mode if necessary */
  1959.     if (DRV_FLAGS_ISSET (SH7615END_FD))
  1960. SH7615END_BIT_SET(ETHERC_ECMR, ECMR_DM);
  1961.     }
  1962.  
  1964. /******************************************************************************
  1965. *
  1966. * sh7615EndConfig - reconfigure the interface under us.
  1967. *
  1968. * Reconfigure the interface setting promiscuous mode, and changing the
  1969. * multicast interface list.
  1970. *
  1971. * RETURNS: N/A.
  1972. */
  1974. LOCAL void sh7615EndConfig
  1975.     (
  1976.     DRV_CTRL *pDrvCtrl /* device to be re-configured */
  1977.     )
  1978.     {
  1979.     UCHAR* pEnetAddr = pDrvCtrl->enetAddr;
  1980.     UINT32 MACAddr = 0;
  1982.     DRV_LOG (DRV_DEBUG_LOAD, "Configuring shendn", 0, 0, 0, 0, 0, 0);
  1984.     /* initialize the dp83843 Physical interface device */
  1986. #ifdef INCLUDE_PHY
  1987.     /* Check full duplex mode */
  1989.     DRV_FLAGS_CLR (SH7615END_FD);
  1990.     if (dp83843RegRead(PHYSTS) & 0x0004)
  1991. {
  1992. DRV_FLAGS_SET (SH7615END_FD);
  1993. }
  1994. #define PFC_PACR ((volatile UINT16 *)0xfffffc80)
  1995.     *PFC_PACR = *PFC_PACR | (UINT16) 0x0004; /* LINKSTA pin */
  1997. #endif
  1999.     /* set depth of FIFO */
  2001.     SH7615END_REG_WRITE(E_DMAC_FDR, ((pDrvCtrl->userFlags & 0x70) << 4) |
  2002.      (pDrvCtrl->userFlags & 0x7));
  2004.     /* Write start of receive and transmit rings */
  2006.     SH7615END_REG_WRITE(E_DMAC_RDLAR, (UINT32)pDrvCtrl->rxRing);
  2007.     SH7615END_REG_WRITE(E_DMAC_TDLAR, (UINT32)pDrvCtrl->txRing);
  2009.     /* set MAC Address */
  2011.     MACAddr  = (UINT32)pEnetAddr[0] << 24;
  2012.     MACAddr |= (UINT32)pEnetAddr[1] << 16;
  2013.     MACAddr |= (UINT32)pEnetAddr[2] << 8;
  2014.     MACAddr |= (UINT32)pEnetAddr[3];
  2015.     SH7615END_REG_WRITE(ETHERC_MAHR, MACAddr);
  2017.     MACAddr  = (UINT32)pEnetAddr[4] << 8;
  2018.     MACAddr |= (UINT32)pEnetAddr[5];
  2019.     SH7615END_REG_WRITE(ETHERC_MALR, MACAddr);
  2021.     /* set receive frame length register - specifies max receiveable length */
  2023.     SH7615END_REG_WRITE(ETHERC_RFLR, 0x5F0); /* 1520 bytes */
  2024.  
  2025.     /* clear any pending interrupts */
  2027.     SH7615END_REG_WRITE(ETHERC_ECSR, ECSR_CLEAR);
  2028.     SH7615END_REG_WRITE(E_DMAC_EESR, EESR_CLEAR);
  2029.  
  2030.     /* set operating mode and start the receiver */
  2032.     sh7615EndModeSet (pDrvCtrl);
  2034.     /* start the transmitter, receiver */
  2036.     SH7615END_REG_WRITE(E_DMAC_RCR, RCR_RNC); /* continuous mode */ 
  2037.     SH7615END_REG_WRITE(E_DMAC_EDRRR, EDRRR_RR); /* Receive request */
  2038.     SH7615END_BIT_SET(ETHERC_ECMR, ECMR_TE);
  2039.     SH7615END_BIT_SET(ETHERC_ECMR, ECMR_RE);
  2041.     /* set up the interrupt mask */
  2043.     pDrvCtrl->intrMask = EESIPR_FRIP | EESIPR_TCIP | EESIPR_ECIIP;
  2045.     /* enable interrupts at the device */
  2047.     SH7615END_REG_WRITE(E_DMAC_EESIPR, pDrvCtrl->intrMask);
  2048.     SH7615END_REG_WRITE(ETHERC_ECSIPR, ECSIPR_LCHNGIP);
  2050.     return;
  2051.     }
  2054. /*******************************************************************************
  2055. *
  2056. * sh7615EndMCastAddrAdd - add a multicast address
  2057. *
  2058. * This routine adds a multicast address to whatever the driver
  2059. * is already listening for.
  2060. *
  2061. * RETURNS: OK on success, ERROR otherwise.
  2062. */
  2063.  
  2064. LOCAL STATUS sh7615EndMCastAddrAdd
  2065.     (
  2066.     DRV_CTRL *  pDrvCtrl,
  2067.     char *      pAddr
  2068.     )
  2069.     {
  2070.     int retVal;
  2071.  
  2072.     DRV_LOG (DRV_DEBUG_IOCTL, "MCastAddrAddn", 0, 0, 0, 0, 0, 0);
  2073.  
  2074.     retVal = etherMultiAdd (&pDrvCtrl->end.multiList, pAddr);
  2075.  
  2076.     if (retVal == ENETRESET)
  2077.         sh7615EndConfig (pDrvCtrl);
  2078.  
  2079.     return (OK);
  2080.     }
  2082. /*******************************************************************************
  2083. *
  2084. * sh7615EndMCastAddrDel - remove a multicast address
  2085. *
  2086. * This routine deletes a multicast address from the current list of
  2087. * multicast addresses.
  2088. *
  2089. * RETURNS: OK on success, ERROR otherwise.
  2090. */
  2091.  
  2092. LOCAL STATUS sh7615EndMCastAddrDel
  2093.     (
  2094.     DRV_CTRL *  pDrvCtrl,
  2095.     char *      pAddr
  2096.     )
  2097.     {
  2098.     int retVal;
  2099.  
  2100.     DRV_LOG (DRV_DEBUG_IOCTL, "MCastAddrDeln", 0, 0, 0, 0, 0, 0);
  2101.  
  2102.     retVal = etherMultiDel (&pDrvCtrl->end.multiList, pAddr);
  2103.  
  2104.     if (retVal == ENETRESET)
  2105.         sh7615EndConfig (pDrvCtrl);
  2106.  
  2107.     return (OK);
  2108.     }
  2110. /*******************************************************************************
  2111. *
  2112. * sh7615EndMCastAddrGet - retreive current multicast address list
  2113. *
  2114. * This routine returns the current multicast address list in <pTable>
  2115. *
  2116. * RETURNS: OK on success; otherwise ERROR.
  2117. */
  2118.  
  2119. LOCAL STATUS sh7615EndMCastAddrGet
  2120.     (
  2121.     DRV_CTRL *  pDrvCtrl,
  2122.     MULTI_TABLE *pTable
  2123.     )
  2124.     {
  2125.     DRV_LOG (DRV_DEBUG_IOCTL, "MCastAddrGetn", 0, 0, 0, 0, 0, 0);
  2126.  
  2127.     return (etherMultiGet (&pDrvCtrl->end.multiList, pTable));
  2128.     }
  2130. /*******************************************************************************
  2131. *
  2132. * sh7615EnetAddrGet - get the Ethernet address.
  2133. *
  2134. * This routine gets the ethernet address by calling the appropriate
  2135. * BSP routine.
  2136. *
  2137. * RETURNS: N/A.
  2138. */
  2139.  
  2140. LOCAL void sh7615EnetAddrGet
  2141.     (
  2142.     DRV_CTRL *  pDrvCtrl,
  2143.     char * addr
  2144.     )
  2145.     {
  2146.     int i;
  2147.     char bytes[6];
  2148.   
  2149.     SYS_ENET_ADDR_GET (pDrvCtrl, bytes);
  2150.  
  2151.     /* For big endian we need to swap byte order */
  2153.     for (i=0; i<6; i++)
  2154. *addr++ = bytes[5-i];
  2155.     }
  2157. /*******************************************************************************
  2158. *
  2159. * sh7615EndReset - reset device
  2160. *
  2161. * This routines issues a software reset of the SH7615 on-chip EDMAC.
  2162. *
  2163. * RETURNS: N/A.
  2164. */
  2166. LOCAL void sh7615EndReset
  2167.     (
  2168.     DRV_CTRL *pDrvCtrl
  2169.     )
  2170.     {
  2171.     /*
  2172.      * Note - this also sets Tx/Rx descriptor length to 16 bytes, which is
  2173.      * what we want.
  2174.      *
  2175.      * This should reset all internal registers to the initial values.
  2176.      * Both the etherC AND the E-DMAC regs are reset.
  2177.      * Consequently, all interrupts should be masked.
  2178.      */
  2180.     SH7615END_REG_WRITE (E_DMAC_EDMR, EDMR_SWR);
  2181.     }
  2183. #ifdef DRV_DEBUG
  2185. /*******************************************************************************
  2186. *
  2187. * sh7615EndRegDump - reads all ETHERC and EDMAC registers and print the value
  2188. *
  2189. * This routine reads all the registers of the SH7615 on-chip ETHERC and EDMAC.
  2190. * Only for debug purpose.
  2191. *
  2192. * RETURNS: N/A.
  2193. *
  2194. * NOMANUAL
  2195. */
  2197. void sh7615EndRegDump()
  2198.     {
  2199.     UINT32 value;
  2201.     SH7615END_REG_READ(E_DMAC_EDMR, value);
  2202.     logMsg ("E_DMAC_EDMR:   0x%xn", value, 0, 0, 0, 0, 0);
  2203.     SH7615END_REG_READ(E_DMAC_EDTRR, value);
  2204.     logMsg ("E_DMAC_EDTRR:  0x%xn", value, 0, 0, 0, 0, 0);
  2205.     SH7615END_REG_READ(E_DMAC_EDRRR, value);
  2206.     logMsg ("E_DMAC_EDRRR:  0x%xn", value, 0, 0, 0, 0, 0);
  2207.     SH7615END_REG_READ(E_DMAC_TDLAR, value);
  2208.     logMsg ("E_DMAC_TDLAR:  0x%xn", value, 0, 0, 0, 0, 0);
  2209.     SH7615END_REG_READ(E_DMAC_RDLAR, value);
  2210.     logMsg ("E_DMAC_RDLAR:  0x%xn", value, 0, 0, 0, 0, 0);
  2211.     SH7615END_REG_READ(E_DMAC_EESR, value);
  2212.     logMsg ("E_DMAC_EESR:   0x%xn", value, 0, 0, 0, 0, 0);
  2213.     SH7615END_REG_READ(E_DMAC_EESIPR, value);
  2214.     logMsg ("E_DMAC_EESIPR: 0x%xn", value, 0, 0, 0, 0, 0);
  2215.     SH7615END_REG_READ(E_DMAC_TRSCER, value);
  2216.     logMsg ("E_DMAC_TRSCER: 0x%xn", value, 0, 0, 0, 0, 0);
  2217.     SH7615END_REG_READ(E_DMAC_RMFCR, value);
  2218.     logMsg ("E_DMAC_RMFCR:  0x%xn", value, 0, 0, 0, 0, 0);
  2219.     SH7615END_REG_READ(E_DMAC_TFTR, value);
  2220.     logMsg ("E_DMAC_TFTR:   0x%xn", value, 0, 0, 0, 0, 0);
  2221.     SH7615END_REG_READ(E_DMAC_FDR, value);
  2222.     logMsg ("E_DMAC_FDR:    0x%xn", value, 0, 0, 0, 0, 0);
  2223.     SH7615END_REG_READ(E_DMAC_RCR, value);
  2224.     logMsg ("E_DMAC_RCR:    0x%xn", value, 0, 0, 0, 0, 0);
  2225.     SH7615END_REG_READ(E_DMAC_EDOCR, value);
  2226.     logMsg ("E_DMAC_EDOCR:  0x%xn", value, 0, 0, 0, 0, 0);
  2228.     SH7615END_REG_READ(ETHERC_ECMR, value);
  2229.     logMsg ("ETHERC_ECMR:   0x%xn", value, 0, 0, 0, 0, 0);
  2230.     SH7615END_REG_READ(ETHERC_ECSR, value);
  2231.     logMsg ("ETHERC_ECSR:   0x%xn", value, 0, 0, 0, 0, 0);
  2232.     SH7615END_REG_READ(ETHERC_ECSIPR, value);
  2233.     logMsg ("ETHERC_ECSIPR: 0x%xn", value, 0, 0, 0, 0, 0);
  2234.     SH7615END_REG_READ(ETHERC_PIR, value);
  2235.     logMsg ("ETHERC_PIR:    0x%xn", value, 0, 0, 0, 0, 0);
  2236.     SH7615END_REG_READ(ETHERC_MAHR, value);
  2237.     logMsg ("ETHERC_MAHR:   0x%xn", value, 0, 0, 0, 0, 0);
  2238.     SH7615END_REG_READ(ETHERC_MALR, value);
  2239.     logMsg ("ETHERC_MALR:   0x%xn", value, 0, 0, 0, 0, 0);
  2240.     SH7615END_REG_READ(ETHERC_RFLR, value);
  2241.     logMsg ("ETHERC_RFLR:   0x%xn", value, 0, 0, 0, 0, 0);
  2242.     SH7615END_REG_READ(ETHERC_PSR, value);
  2243.     logMsg ("ETHERC_PSR:    0x%xn", value, 0, 0, 0, 0, 0);
  2244.     SH7615END_REG_READ(ETHERC_TROCR, value);
  2245.     logMsg ("ETHERC_TROCR:  0x%xn", value, 0, 0, 0, 0, 0);
  2246.     SH7615END_REG_READ(ETHERC_CDCR, value);
  2247.     logMsg ("ETHERC_CDCR:   0x%xn", value, 0, 0, 0, 0, 0);
  2248.     SH7615END_REG_READ(ETHERC_LCCR, value);
  2249.     logMsg ("ETHERC_LCCR:   0x%xn", value, 0, 0, 0, 0, 0);
  2250.     SH7615END_REG_READ(ETHERC_CNDCR, value);
  2251.     logMsg ("ETHERC_CNDCR:  0x%xn", value, 0, 0, 0, 0, 0);
  2252.     SH7615END_REG_READ(ETHERC_IFLCR, value);
  2253.     logMsg ("ETHERC_IFLCR:  0x%xn", value, 0, 0, 0, 0, 0);
  2254.     SH7615END_REG_READ(ETHERC_CEFCR, value);
  2255.     logMsg ("ETHERC_CEFCR:  0x%xn", value, 0, 0, 0, 0, 0);
  2256.     SH7615END_REG_READ(ETHERC_FRECR, value);
  2257.     logMsg ("ETHERC_FRECR:  0x%xn", value, 0, 0, 0, 0, 0);
  2258.     SH7615END_REG_READ(ETHERC_TSFRCR, value);
  2259.     logMsg ("ETHERC_TSFRCR: 0x%xn", value, 0, 0, 0, 0, 0);
  2260.     SH7615END_REG_READ(ETHERC_TLFRCR, value);
  2261.     logMsg ("ETHERC_TLFRCR: 0x%xn", value, 0, 0, 0, 0, 0);
  2262.     SH7615END_REG_READ(ETHERC_RFCR, value);
  2263.     logMsg ("ETHERC_RFCR:   0x%xn", value, 0, 0, 0, 0, 0);
  2264.     SH7615END_REG_READ(ETHERC_MAFCR, value);
  2265.     logMsg ("ETHERC_MAFCR:  0x%xn", value, 0, 0, 0, 0, 0);
  2266.     }
  2267. #endif  /* DRV_DEBUG */
  2270. #ifdef INCLUDE_PHY
  2272. /*******************************************************************************
  2273. *
  2274. * dp83843SingleBitRead - reads a single bit value from the dp83843
  2275. *
  2276. * This routine reads a single bit value from the dp83843 via the etherc's PHY
  2277. * Interface Register (PIR). 
  2278. *
  2279. * RETURNS: N/A.
  2280. */
  2282. LOCAL UINT16 dp83843SingleBitRead (void)
  2283.     {
  2284.     UINT32 data;
  2286.     /* lead clock and data direction is read */
  2288.     SH7615END_REG_WRITE (ETHERC_PIR, ~PIR_MMD & PIR_MDC);         
  2290.     /* read data */
  2292.     SH7615END_REG_READ (ETHERC_PIR, data);
  2294.     /* 
  2295.      * NOTE - I assume this should be a write for the trailing clock,
  2296.      * but the doc is confusing, saying "MII control register read"
  2297.      */
  2299.     SH7615END_REG_WRITE (ETHERC_PIR, 0x0);         
  2301.     /* shift data */
  2303.     if (data & PIR_MDI)
  2304.         return 1;
  2305.     else 
  2306.         return 0;
  2307.     }
  2309. /*******************************************************************************
  2310. *
  2311. * dp83843SingleBitWrite - writes a single bit value to the dp83843
  2312. *
  2313. * This routine writes a single bit value to the dp83843 via the etherc's PHY
  2314. * Interface Register (PIR). The dp83843 is programmed one bit at a time.
  2315. *
  2316. * RETURNS: N/A.
  2317. */
  2319. LOCAL void dp83843SingleBitWrite 
  2320.     (
  2321.     int bitVal
  2322.     )
  2323.     {
  2324.     UINT32 data;
  2325.     UINT32 leadClock;
  2326.     UINT32 trailClock;
  2328.     if (bitVal)
  2329.         data = PIR_MDO | PIR_MMD;
  2330.     else
  2331.         data = PIR_MMD;
  2333.     leadClock  = data | PIR_MDC;
  2334.     trailClock = data; 
  2336.     /* Set data and write direction */
  2338.     SH7615END_REG_WRITE (ETHERC_PIR, (PIR_MMD & ~PIR_MDC) | (bitVal << 2) ); 
  2340.     /* Provide the clock leading and trailing pulses to latch on */
  2342.     SH7615END_REG_WRITE (ETHERC_PIR,  PIR_MMD | PIR_MDC | (bitVal << 2) );   
  2344.     SH7615END_REG_WRITE (ETHERC_PIR,  (PIR_MMD & ~PIR_MDC) | (bitVal << 2)); 
  2345.     }
  2348. /*******************************************************************************
  2349. *
  2350. * dp83843GetPackt - compose a frame format for the PHY
  2351. *
  2352. * This routine composes a frame format for the PHY chip according to
  2353. * the following scheme:
  2354. * 
  2355. *   <idle><ST><OP><AAAAA><RRRRR><TA>
  2356. * 
  2357. * where:
  2358. * ST: start command (01)
  2359. * OP: operation code (01: write, 10: read)
  2360. * AAAAA: address of the PHY chip.
  2361. * RRRRR: register of the PHY chip.
  2362. * TA: turnaround (10: write, Z0: read)
  2363. *
  2364. * Example write sequence to ANAR (address offset == 0x4)
  2365. *
  2366. *      5       0       9       2      this routine returns: 0x5092
  2367. *    _____   _____   _____   _____  
  2368. *   |     | |     | |     | |     |
  2369. *   0 1 0 1 0 0 0 0 1 0 0 1 0 0 1 0
  2370. *   | | | | |       | |       | | |
  2371. *    -   -   -------   -------   -
  2372. *    s   o    phy       reg      T
  2373. *    t   p   addr      addr      A
  2374. *    a        1         0x4
  2375. *    r   w
  2376. *    t   r
  2377. *
  2378. * This routine returns a 16-bit pattern. Note: the <idle> at the
  2379. * beginning is not included. For reading, the TA field is irrelevant.
  2380. *
  2381. * RETURNS: the frame packet.
  2382. */
  2384. LOCAL UINT16 dp83843GetPackt
  2385.     (
  2386.     UCHAR phyAddr, /* Address of the PHY in the transaction */
  2387.     UCHAR phyReg, /* Register interested in the transaction */
  2388.     BOOL writePck /* frame for writing if true */
  2389.     )
  2390.     {
  2391.     UINT16 value = 0;
  2393.     /* start command */
  2394.     value |= ((0x0001 & 0x0003) << 14); 
  2395.     
  2396.     /* Operation command */
  2397.     if( writePck )
  2398. value |= ((0x0001 & 0x0003) << 12); /* write command */
  2399.     else
  2400. value |= ((0x0002 & 0x0003) << 12); /* read command */
  2402.     /* Address of the PHY chip */
  2403.     value |= ((phyAddr & 0x001f) << 7);
  2405.     /* Register */
  2406.     value |= ((phyReg & 0x001f) << 2);
  2408.     /* turnaround */
  2409.     if( writePck )
  2410. value |= 0x0002; /* write operation only */
  2411.     else
  2412. value |= 0x0000;
  2414.     return value;
  2415.     }
  2417. #if 0    /* Not used currently */
  2418. /*******************************************************************************
  2419. *
  2420. * dp83843RegWrite - writes a dp83843 register
  2421. *
  2422. * This routine writes a UINT16 value to a dp83843 register via the etherc's PHY
  2423. * Interface Register (PIR). dp83843 registers are all 16bit.
  2424. *
  2425. * RETURNS: N/A.
  2426. *
  2427. * NOMANUAL
  2428. */
  2429.  
  2430. LOCAL void dp83843RegWrite
  2431.     (
  2432.     UINT16 regAddr,
  2433.     UINT16 regData 
  2434.     )
  2435.     {
  2436.     int i;
  2437.     UINT16 pckFrame;
  2439.     pckFrame = dp83843GetPackt(PHY_ADDR, regAddr, TRUE);
  2440.     
  2441.     /* this preamble step may not be necessary - BMSR's bit 6 has default
  2442.        value of 1 which means the device is supposed to be able to operate
  2443.        without the preamble. However, it does still need 32 bits after a
  2444.        reset.
  2445.      */
  2447.     for(i=0; i<32; i++)
  2448.         dp83843SingleBitWrite(1);    /* preamble is 32 1's */
  2450.     for(i=0; i<16; i++)              /* start, opcode, devAddrr, regAddr and turn */
  2451.         {
  2452.         if((pckFrame & 0x8000)==0x8000)
  2453.             dp83843SingleBitWrite(1);
  2454.         else
  2455.             dp83843SingleBitWrite(0);
  2456.  
  2457.         pckFrame = pckFrame << 1;
  2458.         }
  2461.     for(i=0; i<16; i++)              /* regdata */
  2462.         {
  2463.         if((regData & 0x8000)==0x8000)
  2464.     {
  2465.             dp83843SingleBitWrite(1);
  2466.     }
  2467.         else
  2468.     {
  2469.             dp83843SingleBitWrite(0);
  2470.     }
  2471.  
  2472.         regData = regData << 1;
  2473.         }
  2476.     /* independent bus release */
  2478.     SH7615END_REG_WRITE (ETHERC_PIR,  ~PIR_MDC & ~PIR_MMD );     
  2479.     
  2480.     }
  2481. #endif
  2483. /*******************************************************************************
  2484. *
  2485. * dp83843RegRead - reads a dp83843 register
  2486. *
  2487. * This routine reads a UINT16 register from a dp83843 via the etherc's PHY
  2488. * Interface Register (PIR). dp83843 registers are all 16bit.
  2489. *
  2490. * RETURNS: value read.
  2491. */
  2493. LOCAL UINT16 dp83843RegRead
  2494.     (
  2495.     UINT16 regAddr /* register to be read */
  2496.     )
  2497.     {
  2498.     int i;
  2499.     UINT16 value = 0;
  2500.     UINT16 data;
  2501.     UINT16 pckFrame;
  2503.     pckFrame = dp83843GetPackt(PHY_ADDR, regAddr, FALSE);
  2505.     /* 
  2506.      * NOTE: this preamble step may not be necessary - BMSR's bit 6 has 
  2507.      * default value of 1 which means the device is supposed to be able to
  2508.      * operate without the preamble. However, it does still need 32 bits 
  2509.      * after a reset.
  2510.      */
  2512.     for(i = 0; i < 32; i++)
  2513.         {
  2514.         dp83843SingleBitWrite(1);    /* preamble is 32 1's */
  2515. }
  2516.     
  2517.      /* 
  2518.       * NOTE - ought to hard code in the start, opcode and devAddr here and
  2519.       * only pass in the regAddr offset as defined in the doc. This would
  2520.       * make the macro defs in sh7615End.h more understandable. Then, they
  2521.       * would just be the simple offsets as opposed to containing the start
  2522.       * opcode and devAddr also.
  2523.       */
  2525.     /* write the start, opcode, devAddr and regAddr. Note - this is only 14 bits */
  2527.     for(i = 0; i < 14; i++)            
  2528.         {
  2529.         if( (pckFrame & 0x8000) == 0x8000 )
  2530.             {
  2531.             dp83843SingleBitWrite(1);
  2532.             }
  2533.         else
  2534.             {
  2535.             dp83843SingleBitWrite(0);
  2536.             }
  2537.  
  2538.         pckFrame = pckFrame << 1;
  2539.         }
  2541.     /* release the bus */
  2543.     SH7615END_REG_WRITE (ETHERC_PIR, 0);
  2544.     SH7615END_REG_WRITE (ETHERC_PIR, PIR_MDC);
  2545.     SH7615END_REG_WRITE (ETHERC_PIR, 0);
  2547.     /* read bit 0 of TA */
  2548.     
  2549.     if( dp83843SingleBitRead() == 1 )
  2550. DRV_LOG(DRV_DEBUG_PHY,"dp83843RegRead: Last bit of TA fild is Set!n",
  2551.   1,2,3,4,5,6);
  2553.     /* read data */
  2555.     for(i = 15; i >= 0; i--) 
  2556.         {
  2557.         data = dp83843SingleBitRead();
  2558.         value |= (data << i);
  2559.         }
  2561.     return value;
  2562.     }
  2564. #ifdef DRV_DEBUG
  2566. /*******************************************************************************
  2567. *
  2568. * dp83843RegDump - reads all the dp83843 registers and print the value
  2569. *
  2570. * This routine reads all the registers of a dp83843 via the etherc's PHY
  2571. * Interface Register (PIR) and prints the values. Only for debug purpose.
  2572. *
  2573. * RETURNS: N/A.
  2574. *
  2575. * NOMANUAL
  2576. */
  2578. void dp83843RegDump (void)
  2579.     {
  2581.     DRV_LOG(DRV_DEBUG_PHY,"nn PHY CHIP Registers:nn",1,2,3,4,5,6)
  2583.     DRV_LOG(DRV_DEBUG_PHY,"BMCR:tt%04xn",
  2584.       dp83843RegRead(BMCR),2,3,4,5,6);
  2585.     DRV_LOG(DRV_DEBUG_PHY,"BMSR:tt%04xn",
  2586.       dp83843RegRead(BMSR),2,3,4,5,6);
  2587.     DRV_LOG(DRV_DEBUG_PHY,"PHYIDR1:tt%04xn",
  2588.       dp83843RegRead(PHYIDR1),2,3,4,5,6);
  2589.     DRV_LOG(DRV_DEBUG_PHY,"PHYIDR2:tt%04xn",
  2590.       dp83843RegRead(PHYIDR2),2,3,4,5,6);
  2591.     DRV_LOG(DRV_DEBUG_PHY,"ANAR:tt%04xn",
  2592.       dp83843RegRead(ANAR),2,3,4,5,6);
  2593.     DRV_LOG(DRV_DEBUG_PHY,"ANLPAR:tt%04xn",
  2594.       dp83843RegRead(ANLPAR),2,3,4,5,6);
  2595.     DRV_LOG(DRV_DEBUG_PHY,"ANER:tt%04xn",
  2596.       dp83843RegRead(ANER),2,3,4,5,6);
  2597.     DRV_LOG(DRV_DEBUG_PHY,"ANNPTR:tt%04xn",
  2598.       dp83843RegRead(ANNPTR),2,3,4,5,6);
  2599.     DRV_LOG(DRV_DEBUG_PHY,"PHYSTS:tt%04xn",
  2600.       dp83843RegRead(PHYSTS),2,3,4,5,6);
  2601.     DRV_LOG(DRV_DEBUG_PHY,"MIPSCR:tt%04xn",
  2602.       dp83843RegRead(MIPSCR),2,3,4,5,6);
  2603.     DRV_LOG(DRV_DEBUG_PHY,"MIPGSR:tt%04xn",
  2604.       dp83843RegRead(MIPGSR),2,3,4,5,6);
  2605.     DRV_LOG(DRV_DEBUG_PHY,"DCR:tt%04xn",
  2606.       dp83843RegRead(DCR),2,3,4,5,6);
  2607.     DRV_LOG(DRV_DEBUG_PHY,"FCSCR:tt%04xn",
  2608.       dp83843RegRead(FCSCR),2,3,4,5,6);
  2609.     DRV_LOG(DRV_DEBUG_PHY,"RECR:tt%04xn",
  2610.       dp83843RegRead(RECR),2,3,4,5,6);
  2611.     DRV_LOG(DRV_DEBUG_PHY,"PCSR:tt%04xn",
  2612.       dp83843RegRead(PCSR),2,3,4,5,6);
  2613.     DRV_LOG(DRV_DEBUG_PHY,"LBR:tt%04xn",
  2614.       dp83843RegRead(LBR),2,3,4,5,6);
  2615.     DRV_LOG(DRV_DEBUG_PHY,"BTSCR:tt%04xn",
  2616.       dp83843RegRead(BTSCR),2,3,4,5,6);
  2617.     DRV_LOG(DRV_DEBUG_PHY,"PHYCTL:tt%04xn",
  2618.       dp83843RegRead(PHYCTRL),2,3,4,5,6);
  2619.     }
  2621. #endif /* DRV_DEBUG */
  2623. #endif /* INCLUDE_PHY */