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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
cs8900aEnd.c
资源名称：s3c2410x_Bsp.rar　[点击查看]
上传用户：ske666
上传日期：2022-03-30
资源大小：371k
文件大小：53k
源码类别：

VxWorks

开发平台：

Objective-C

cs8900aEnd.c：源码内容
  1. /* cs8900aEnd.c - cs8900a Enhanced Network Driver (END) */
  3. /*
  4. DESCRIPTION
  6. TODO - Describe the chip being used completely, even if it provides more
  7. features than ethernet.
  9. TODO - Describe the device's full ethernet capabilities, even if this driver
  10. doesn't or can't utilize all of them.  Describe the features that the driver
  11. does implement and any restrictions on their use.
  13. TODO - Describe all macros that can be used to customize this driver.  All
  14. accesses to chip registers should be done through redefineable macros.
  15. In this example driver the macros cs8900a_OUT_SHORT and cs8900a_IN_SHORT
  16. are sample macros to read/write data to a mock device.  If a device
  17. communicates through formatted control blocks in shared memory, the
  18. accesses to those control blocks should also be through redefinable
  19. macros.
  21. TODO - The following information describes the procedure an end user would
  22. follow to integrate this new END device into a new BSP.  The procedure 
  23. needs to be well documented.
  25. This driver is easily customized for a BSP by modifying global pointers
  26. to routines.  The routine pointers are declared below.  The code below
  27. indicates the default values for each routine as well.  By modifying
  28. these global pointer values, the BSP can change the behaviour of the driver.
  30. .CS
  31.     IMPORT STATUS (*cs8900aIntConnectRtn)(int level, FUNCTPR pFunc, int arg);
  32.     IMPORT STATUS (*cs8900aIntDisconnectRtn)(int level, FUNCTPR pFunc, int arg);
  33.     IMPORT STATUS (*cs8900aIntEnableRtn) (int level);
  34.     IMPORT STATUS (*cs8900aEnetAddrGetRtn)(int unit, char *pResult);
  35.     IMPORT STATUS (*cs8900aOutShortRtn)(UINT addr, UINT value);
  36.     IMPORT STATUS (*cs8900aInShortRtn)(UINT addr, USHORT *pData);
  37.     
  38.     cs8900aIntConnectRtn = intConnect; /@ must not be NULL @/
  39.     cs8900aIntDisconnectRtn = NULL;
  40.     cs8900aIntEnableRtn = NULL;
  41.     cs8900aEndAddrGetRtn = NULL;
  42.     cs8900aOutShortRtn = NULL;
  43.     cs8900aInShortRtn = NULL;
  44. .CE
  46. Excecpt for cs8900aIntConnectRtn and cs8900aIntEnableRtn, a NULL value
  47. will result in the driver taking a default action.  For the int disconnect
  48. function the default action is to do nothing at all.  For the short in and out
  49. routines, the default is to assume memory mapped device registers and to
  50. access them directly.  The default ethernet address get routine
  51. provides an invalid ethernet address of all zeros (0:0:0:0:0:0).
  52. If the BSP is willing to accept these default values no action at all
  53. is needed.  To change the default value, the BSP should create an appropriate
  54. routine and set the address into the global value before first use.  This
  55. would normally be done at function sysHwInit2() time.
  57. For Tornado 3.0 you need to pay attention to virtual physical address
  58. translations which are important.  Use the cache lib macros to to
  59. proper VIRT_TO_PHYS translation as part of generating the physical DMA
  60. address for the device.  Avoid the use of PHYS_TO_VIRT translation as
  61. it can be very time consuming.  If at all possible, the driver should
  62. cache the virtual address of each data buffer used for DMA.
  64. Prior to VxWorks AE 1.1, the muxLib function muxDevUnload() did a free
  65. of the actual END_OBJ structure that was malloc'd during the driver
  66. load routine.  Starting with VxWorks AE 1.1, this behaviour can be
  67. changed.  If the second argument to END_OBJ_INIT points to the END_OBJ
  68. then muxLib will free it during muxDevUnload.  If not, then muxDevUnload
  69. will not free the allocated space.  Under this situation, it is assumed
  70. that the driver unload routine has free'd the space itself.  This preserves
  71. backward compatibility with older drivers that always specified the second
  72. argument to END_OBJ_INIT() as a pointer to the END_OBJ structure.  This
  73. cs8900a has been changed to use the new behaviour instead.
  75. INCLUDES:
  76. end.h endLib.h etherMultiLib.h
  78. SEE ALSO: muxLib, endLib
  79. .I "Writing and Enhanced Network Driver"
  80. */
  82. /* includes */
  83. #include "vxWorks.h"
  84. #include "stdlib.h"
  85. #include "cacheLib.h"
  86. #include "intLib.h"
  87. #include "end.h" /* Common END structures. */
  88. #include "endLib.h"
  89. #include "lstLib.h" /* Needed to maintain protocol list. */
  90. #include "iv.h"
  91. #include "semLib.h"
  92. #include "logLib.h"
  93. #include "netLib.h"
  94. #include "stdio.h"
  95. #include "sysLib.h"
  96. #include "errno.h"
  97. #include "errnoLib.h"
  98. #include "memLib.h"
  99. #include "iosLib.h"
  100. #undef ETHER_MAP_IP_MULTICAST
  101. #include "etherMultiLib.h" /* multicast stuff. */
  103. #include "net/mbuf.h"
  104. #include "net/unixLib.h"
  105. #include "net/protosw.h"
  106. #include "net/systm.h"
  107. #include "net/if_subr.h"
  108. #include "net/route.h"
  109. #include "netinet/if_ether.h"
  111. #include "sys/socket.h"
  112. #include "sys/ioctl.h"
  113. #include "sys/times.h"
  115. #include "string.h"
  117. /* addition. */
  119. #include "cs8900a.h"
  120. #include "s3c2410x.h"
  122. /* Maximum number of CS8900 chips */
  123. #define MAXUNITS    1
  125. /* read one byte from I/O space */
  126. #ifndef CS_IN_BYTE
  127. #define CS_IN_BYTE(reg,pAddr) (*(pAddr) = *((volatile UCHAR*)(reg)))
  128. #endif /*CS_IN_BYTE*/
  130. /* read a short (16bits) from I/O */
  131. #ifndef CS_IN_WORD
  132. #define CS_IN_WORD(reg,pAddr) (*((volatile USHORT*)(pAddr))) = *((volatile USHORT*)(reg)))
  133. #endif /*CS_IN_WORD*/
  135. /* write a short to I/O space */
  136. #ifndef CS_OUT_WORD
  137. #define CS_OUT_WORD(reg,data) (*((volatile USHORT*)(reg)) = data)
  138. #endif /*CS_OUT_WORD*/
  140. /* enable interrupt level */
  141. #ifndef CS_INT_ENABLE
  142. #define CS_INT_ENABLE(level,pResult) (*pResult = intEnable(level))
  143. #endif /*CS_INT_ENABLE*/
  145. /* connect routine to intr. vector */
  146. #ifndef CS_INT_CONNECT
  147. #define CS_INT_CONNECT(ivec,rtn,arg,pResult) (*pResult = intConnect(ivec,rtn,arg))
  148. #endif /*CS_INT_CONNECT*/
  150. IMPORT int endMultiLstCnt (END_OBJ* pEnd);
  152. /* defines */
  153. #define DRV_NAME "cs"
  154. #define DRV_NAME_LEN (sizeof(DRV_NAME) + 1)
  155. #define DRV_DESC "Cirrus Logic CS8900A END driver"
  156. #define DRV_DESC_LEN (sizeof(DRV_DESC) + 1)
  158. #define TASK_CS_INT_PRI (54)
  160. /* Configuration items */
  161. #ifndef ETHERMTU
  162. #define ETHERMTU (1500)
  163. #endif
  164. #define END_BUFSIZ (ETHERMTU + SIZEOF_ETHERHEADER + 6)
  165. #define EH_SIZE (14)
  166. #define END_SPEED_10M 10000000 /* 10Mbs */
  167. #define END_SPEED_100M 100000000 /* 100Mbs */
  168. #define END_SPEED END_SPEED_10M
  170. /*
  171.  * Default macro definitions for BSP interface.
  172.  * These macros can be redefined in a wrapper file, to generate
  173.  * a new module with an optimized interface.
  174.  */
  176. /* A shortcut for getting the hardware address from the MIB II stuff. */
  177. #define END_HADDR(pEnd) ((pEnd)->mib2Tbl.ifPhysAddress.phyAddress)
  179. #define END_HADDR_LEN(pEnd) ((pEnd)->mib2Tbl.ifPhysAddress.addrLength)
  182. /* typedefs */
  184. /* mac address mask */
  185. typedef struct struct_mac_address
  186. {
  187. USHORT i_g : 1;
  188. USHORT u_l : 1;
  189. USHORT val15_2 : 14;
  190. UINT val47_16;
  191. }STRUCT_MAC_ADDRESS;
  193. /* The definition of the driver control structure */
  194. typedef struct end_device{
  195. END_OBJ end; /* The class we inherit from. */
  196. int unit; /* unit number */
  197. int ivec; /* interrupt vector */
  198. int ilevel; /* interrupt level */
  199. char* pShMem; /* real ptr to shared memory */
  200. long flags; /* Our local flags. */
  201. USHORT enetAddr[3]; /* ethernet address */
  202. CACHE_FUNCS* pCacheFuncs; /* cache function pointers */
  203. FUNCPTR freeRtn[128]; /* Array of free routines. */
  204. /* struct free_args freeData[128];  Array of free arguments */
  205. /* the free routines. */
  206. CL_POOL_ID pClPoolId; /* cluster pool */
  207. BOOL rxHandling; /* rcv task is scheduled */
  209. /* chip */
  210. USHORT io_addr; /* The io base of the cs8900a. */
  211. UINT mem_addr; /* The mem base of the cs8900a. */
  212. USHORT chip_int_num; /* The cs8900a intrX(0..3) */
  213. USHORT chip_dma_num; /* The cs8900a dmaX(0..2) */
  214. UINT media_type; /* The media type in software. */
  215. BOOL in_memory_mode; /* The flag of mode.(io(false) or memory(true)) */
  216. BOOL resetting;
  217. UINT rx_depth;
  218. UINT max_rx_depth;
  219. UINT max_tx_depth;
  220. UINT loan_count;
  221. STRUCT_MAC_ADDRESS * p_mac_adr;
  222. }END_DEVICE;
  224. typedef struct self_pkg_buf
  225. {
  226. char * p_char;
  227. int len;
  228. }self_pkg_buf, * p_self_pkg_buf;
  230. /*
  231.  * This will only work if there is only a single unit, for multiple
  232.  * unit device drivers these should be integrated into the END_DEVICE
  233.  * structure.
  234.  */
  235. /* -------------------------------- no. mBlks no. clBlks memArea memSize */
  236. /* network mbuf configuration table --------- ---------- ------- ------- */
  237. M_CL_CONFIG cs8900aMclBlkConfig = { 0, 0, NULL, 0};
  239. /* ---------------------------------------- clusterSize num memArea memSize   */
  240. /* network cluster pool configuration table  ----------- --- ------- --------- */
  241. CL_DESC cs8900aClDescTbl [] =  {{ 0, 0, NULL, 0 }};
  243. int cs8900aClDescTblNumEnt = (NELEMENTS(cs8900aClDescTbl));
  245. /* Definitions for the flags field */
  246. #define cs8900a_PROMISCUOUS 0x1
  247. #define cs8900a_POLLING 0x2
  250. #define cs8900a_MIN_FBUF (1536) /* min first buffer size */
  252. /* DEBUG MACROS */
  253. #ifdef DEBUG
  254. #define LOGMSG(x,a,b,c,d,e,f) if(endDebug){logMsg(x,a,b,c,d,e,f);}
  255. #else
  256. #define LOGMSG(x,a,b,c,d,e,f)
  257. #endif /* ENDDEBUG */
  259. #undef DRV_DEBUG
  261. #ifdef DRV_DEBUG
  262. #define DRV_DEBUG_OFF 0x0000
  263. #define DRV_DEBUG_RX 0x0001
  264. #define DRV_DEBUG_TX 0x0002
  265. #define DRV_DEBUG_INT 0x0004
  266. #define DRV_DEBUG_POLL (DRV_DEBUG_POLL_RX | DRV_DEBUG_POLL_TX)
  267. #define DRV_DEBUG_POLL_RX 0x0008
  268. #define DRV_DEBUG_POLL_TX 0x0010
  269. #define DRV_DEBUG_LOAD 0x0020
  270. #define DRV_DEBUG_IOCTL 0x0040
  271. #define DRV_DEBUG_POLL_REDIR 0x10000
  272. #define DRV_DEBUG_LOG_NVRAM 0x20000
  273. int cs8900aDebug = 0x00;
  274. int     cs8900aTxInts = 0;
  275. #define DRV_LOG(FLG, X0, X1, X2, X3, X4, X5, X6) if(cs8900aDebug & FLG)logMsg(X0, X1, X2, X3, X4, X5, X6);
  276. #define DRV_PRINT(FLG,X) if(cs8900aDebug & FLG)printf X;
  277. #else /*DRV_DEBUG*/
  278. #define DRV_LOG(DBG_SW, X0, X1, X2, X3, X4, X5, X6)
  279. #define DRV_PRINT(DBG_SW,X)
  280. #endif /*DRV_DEBUG*/
  282. /* LOCALS */
  284. /* forward static functions */
  285. LOCAL void cs8900aReset(END_DEVICE *pDrvCtrl);
  286. LOCAL void cs8900aRecv(END_DEVICE * pDrvCtrl, char * pNewCluster, int len);
  287. LOCAL void cs8900aConfig(END_DEVICE *pDrvCtrl);
  289. /* END Specific interfaces. */
  291. /* This is the only externally visible interface. */
  292. END_OBJ*  cs8900aLoad(char* initString, void* p_v);
  294. LOCAL STATUS cs8900aStart(END_DEVICE* pDrvCtrl);
  295. LOCAL STATUS cs8900aStop(END_DEVICE* pDrvCtrl);
  296. LOCAL int cs8900aIoctl(END_DEVICE* pDrvCtrl, int cmd, caddr_t data);
  297. LOCAL STATUS cs8900aUnload(END_DEVICE* pDrvCtrl);
  298. LOCAL STATUS cs8900aSend(END_DEVICE* pDrvCtrl, M_BLK_ID pBuf);
  299. LOCAL void cs8900aInt(END_DEVICE* pDrvCtrl);
  301. LOCAL STATUS cs8900aMCastAdd(END_DEVICE* pDrvCtrl, char* pAddress);
  302. LOCAL STATUS cs8900aMCastDel(END_DEVICE* pDrvCtrl, char* pAddress);
  303. LOCAL STATUS cs8900aMCastGet(END_DEVICE* pDrvCtrl, MULTI_TABLE* pTable);
  304. LOCAL STATUS cs8900aPollStart(END_DEVICE* pDrvCtrl);
  305. LOCAL STATUS cs8900aPollStop(END_DEVICE* pDrvCtrl);
  306. LOCAL STATUS cs8900aPollSend(END_DEVICE* pDrvCtrl, M_BLK_ID pBuf);
  307. LOCAL STATUS cs8900aPollRcv(END_DEVICE* pDrvCtrl, M_BLK_ID pBuf);
  308. LOCAL void cs8900aAddrFilterSet(END_DEVICE *pDrvCtrl);
  310. LOCAL STATUS cs8900aMemInit();
  312. void cs_pp_w(END_DEVICE* pDrvCtrl, USHORT offset, USHORT value);
  313. USHORT cs_pp_r(END_DEVICE* pDrvCtrl, USHORT offset);
  314. void cs_chip_generate_interrupt(END_DEVICE * pDrvCtrl);
  315. int cs_chip_get_rx_miss_num(END_DEVICE * pDrvCtrl);
  316. int cs_chip_get_tx_col_num(END_DEVICE * pDrvCtrl);
  317. STATUS cs_chip_int_disable(END_DEVICE * pDrvCtrl);
  318. STATUS cs_chip_int_enable(END_DEVICE * pDrvCtrl);
  319. STATUS cs_chip_loop_set(END_DEVICE * pDrvCtrl, int val);
  320. void cs_chip_rx_frame_drop(END_DEVICE * pDrvCtrl, int num);
  321. STATUS cs_chip_select_rx_frame_type(END_DEVICE * pDrvCtrl, USHORT type_mask, int val);
  322. STATUS cs_chip_self_reset(END_DEVICE * pDrvCtrl);
  323. STATUS cs_chip_set_full_duplex(END_DEVICE * pDrvCtrl, int val);
  324. STATUS cs_chip_set_link_dep(END_DEVICE * pDrvCtrl, int val);
  325. STATUS cs_chip_set_tx_crc(END_DEVICE * pDrvCtrl, int val);
  326. STATUS cs_chip_to_mem_mode(END_DEVICE * pDrvCtrl, int flag);
  327. STATUS cs_chip_tx_force_terminate(END_DEVICE * pDrvCtrl, int val);
  328. STATUS cs_chip_send_frame(END_DEVICE * pDrvCtrl, USHORT * p_src_buf, int length);
  329. STATUS cs_soft_end_init(END_DEVICE * pDrvCtrl);
  330. int cs8900a_pin_enable(void);
  331. int cs8900a_pin_disable(void);
  332. STATUS cs_chip_event_enable(END_DEVICE * pDrvCtrl);
  333. STATUS mask32_change_bsp(int* dist32, int num, int len, int src);
  334. /*
  335.  * Declare our function table.  This is static across all device
  336.  * instances.
  337.  */
  339. STATUS endEtherPacketDataGet1(void *g,void *h)
  340. {
  341. printf("wowowowon");
  342. }
  343. LOCAL NET_FUNCS cs8900aFuncTable =
  344. {        
  345. (FUNCPTR) cs8900aStart, /* Function to start the device. */
  346. (FUNCPTR) cs8900aStop, /* Function to stop the device. */
  347. (FUNCPTR) cs8900aUnload, /* Unloading function for the driver. */
  348. (FUNCPTR) cs8900aIoctl, /* Ioctl function for the driver. */
  349. (FUNCPTR) cs8900aSend, /* Send function for the driver. */
  350. (FUNCPTR) cs8900aMCastAdd, /* Multicast add function for the driver. */
  351. (FUNCPTR) cs8900aMCastDel, /* Multicast delete function for the driver. */
  352. (FUNCPTR) cs8900aMCastGet, /* Multicast retrieve function for the driver. */
  353. (FUNCPTR) cs8900aPollSend, /* Polling send function */
  354. (FUNCPTR) cs8900aPollRcv, /* Polling receive function */
  355. endEtherAddressForm, /* put address info into a NET_BUFFER */
  356. endEtherPacketDataGet, /* get pointer to data in NET_BUFFER */
  357. endEtherPacketAddrGet    /* Get packet addresses. */
  358. };
  359. END_DEVICE * p_end_device;
  361. int display_net_event = 0;
  364. /*
  365.  * cs8900aLoad - initialize the driver and device
  366.  *
  367.  * This routine initializes the driver and the device to the operational state.
  368.  * All of the device specific parameters are passed in the initString.
  369.  *
  370.  * The string contains the target specific parameters like this:
  371.  *
  372.  * "register addr:int vector:int level:shmem addr:shmem size:shmem width"
  373.  *
  374.  * This routine can be called in two modes.  If it is called with an empty but
  375.  * allocated string, it places the name of this device into the <initString>
  376.  * and returns 0.
  377.  *
  378.  * If the string is allocated and not empty, the routine attempts to load
  379.  * the driver using the values specified in the string.
  380.  *
  381.  * RETURNS: An END object pointer, or NULL on error, or 0 and the name of the
  382.  * device if the <initString> was empty.
  383.  */
  385.  
  386.  /*typedef struct    BOOT_PARAMS */
  387.  
  388.  /*{*/
  389.  
  390.  /*char bootDev [BOOT_DEV_LEN];   boot device code */
  391.  
  392.  /*char hostName [BOOT_HOST_LEN];    name of host */
  393.  
  394.  /*char targetName [BOOT_HOST_LEN];   name of target */
  395.  
  396.  /*char ead [BOOT_ADDR_LEN];    ethernet internet addr */
  397.  
  398.  /*char bad [BOOT_ADDR_LEN];    backplane internet addr */
  399.  
  400.  /*char had [BOOT_ADDR_LEN];    host internet addr */
  401.  
  402.  /*char gad [BOOT_ADDR_LEN];    gateway internet addr */
  403.  
  404.  /*char bootFile [BOOT_FILE_LEN];     name of boot file */
  405.  
  406.  /*char startupScript [BOOT_FILE_LEN];   name of startup script file */
  407.  
  408.  /*char usr [BOOT_USR_LEN];    user name */
  409.  
  410.  /*char passwd [BOOT_PASSWORD_LEN]; password */
  411.  
  412.  /*char other [BOOT_OTHER_LEN];  available for applications */
  413.  
  414.  /*int procNum;   processor number */
  415.  
  416.  /*int unitNum;   network device unit number */
  417.  
  418.  /*int flags;     configuration flags */
  419.  
  420.  /*} BOOT_PARAMS;*/
  421.  
  422. END_OBJ* cs8900aLoad
  423. (
  424. char* initString, /* String to be parsed by the driver. */
  425. void* p_v
  426. )
  427. {
  428. END_DEVICE *pDrvCtrl;  
  430. DRV_LOG(DRV_DEBUG_LOAD, "Loading cs8900a...n", 1, 2, 3, 4, 5, 6);
  432. if(initString == NULL)
  433.         {
  434. DRV_LOG(DRV_DEBUG_LOAD, "cs8900aLoad: NULL initStrrn",0,0,0,0,0,0);
  435. return NULL;
  436. }
  437.     
  438. if(initString[0] == EOS)
  439. {
  440. bcopy((char *)DRV_NAME, initString, DRV_NAME_LEN);
  441. return NULL;
  442. }
  444. /* else initString is not blank, pass two ... */
  446. /* allocate the device structure */
  447. pDrvCtrl = (END_DEVICE*)calloc(1,sizeof(END_DEVICE));
  448. if(pDrvCtrl == NULL) goto errorExit;
  450. cs_soft_end_init(pDrvCtrl);
  452. /*
  453.  * initialize the END and MIB2 parts of the structure
  454.  * The M2 element must come from m2Lib.h
  455.  * This cs8900a is set up for a DIX type ethernet device.
  456.  */
  458. if( (END_OBJ_INIT(&pDrvCtrl->end, (DEV_OBJ*)pDrvCtrl, DRV_NAME, pDrvCtrl->unit,
  459. &cs8900aFuncTable,DRV_DESC) == ERROR)
  460. ||
  461. (END_MIB_INIT (&pDrvCtrl->end, M2_ifType_ethernet_csmacd,
  462. (UCHAR*)&(pDrvCtrl->enetAddr[0]), 6, ETHERMTU,END_SPEED) == ERROR))
  463. {
  464. goto errorExit;
  465. }
  468. /* Perform memory allocation/distribution */
  469. if(cs8900aMemInit(pDrvCtrl) == ERROR) goto errorExit;
  472. /* reset and reconfigure the device */
  473. cs8900aReset(pDrvCtrl);
  476. cs8900aConfig(pDrvCtrl);
  479. /* set the flags to indicate readiness */
  480. END_OBJ_READY(&pDrvCtrl->end, IFF_NOTRAILERS | IFF_BROADCAST | IFF_MULTICAST);
  482. DRV_LOG(DRV_DEBUG_LOAD, "Done loading cs8900a...", 1, 2, 3, 4, 5, 6);
  484. p_end_device = pDrvCtrl;
  486. pDrvCtrl->p_mac_adr = (void *)(pDrvCtrl->enetAddr);
  488. return (&(pDrvCtrl->end));
  490. errorExit:
  491. if(pDrvCtrl != NULL) free((char *)pDrvCtrl);
  493. p_end_device = NULL;
  495. return NULL;
  496. }
  498. /*
  499.  * cs8900aMemInit - initialize memory for the chip
  500.  *
  501.  * This routine is highly specific to the device.
  502.  *
  503.  * Design choices available:
  504.  *
  505.  * Use default system buffers, or create device specific buffer pools.
  506.  *
  507.  * Use contiguous buffers for device frame descriptors and the data, or
  508.  * use descriptor buffers separate from the data buffers.
  509.  *
  510.  * Use the same buffering scheme for Rx and Tx, or each side uses it's
  511.  * own buffering scheme.
  512.  *
  513.  * RETURNS: OK or ERROR.
  514.  */
  515. LOCAL STATUS cs8900aMemInit
  516. (
  517. END_DEVICE * pDrvCtrl /* device to be initialized */
  518. )
  519. {
  520. /* Set up an END netPool using netBufLib(1). */
  521. cs8900aMclBlkConfig.mBlkNum  = 128;
  522. cs8900aClDescTbl[0].clNum    = 128;
  523. cs8900aClDescTbl[0].clSize   = 2048;
  524. cs8900aMclBlkConfig.clBlkNum = cs8900aClDescTbl[0].clNum;
  526. /* Calculate the total memory for all the M-Blks and CL-Blks. */
  527. cs8900aMclBlkConfig.memSize = ((cs8900aMclBlkConfig.mBlkNum * (MSIZE + sizeof (long)))
  528.     +  (cs8900aMclBlkConfig.clBlkNum * (CL_BLK_SZ + sizeof(long))));
  530. /* allocate mbuf/Cluster blocks from normal memory */
  531. cs8900aMclBlkConfig.memArea = (char *)memalign(sizeof(long),cs8900aMclBlkConfig.memSize);
  532. if(cs8900aMclBlkConfig.memArea == NULL)return ERROR;
  534. /* Calculate the memory size of all the clusters. */
  535. cs8900aClDescTbl[0].memSize = (cs8900aClDescTbl[0].clNum * (cs8900aClDescTbl[0].clSize + 8));
  537. /* Allocate the memory for the clusters from cache safe memory. */
  538. cs8900aClDescTbl[0].memArea = (char*)cacheDmaMalloc(cs8900aClDescTbl[0].memSize);
  539. if(cs8900aClDescTbl[0].memArea == NULL)
  540. {
  541. DRV_LOG(DRV_DEBUG_LOAD, "system memory unavailablen", 1, 2, 3, 4, 5, 6);
  542. return ERROR;
  543. }
  545. /* TODO - allocate and initialize any shared memory areas */
  546. if((pDrvCtrl->end.pNetPool = malloc(sizeof(NET_POOL))) == NULL) return ERROR;
  548. /* Initialize the memory pool. */
  549. if(netPoolInit(
  550. pDrvCtrl->end.pNetPool,
  551. &cs8900aMclBlkConfig,
  552. &cs8900aClDescTbl[0],
  553. cs8900aClDescTblNumEnt,
  554. NULL) == ERROR)
  555.         {
  556. DRV_LOG(DRV_DEBUG_LOAD, "Could not init bufferingn", 1, 2, 3, 4, 5, 6);
  557. return ERROR;
  558. }
  560. DRV_LOG(DRV_DEBUG_LOAD, "Memory setup completen", 1, 2, 3, 4, 5, 6);
  562. return OK;
  563. }
  565. /*
  566.  * cs8900aStart - start the device
  567.  *
  568.  * This function calls BSP functions to connect interrupts and start the
  569.  * device running in interrupt mode.
  570.  *
  571.  * RETURNS: OK or ERROR
  572.  *
  573.  */
  574. LOCAL STATUS cs8900aStart
  575. (
  576. END_DEVICE* pDrvCtrl /* device ID */
  577. )
  578. {
  579. /* TODO  - start the device, enabling interrupts */
  581. /* enable pins for net interrupt. */
  582. cs8900a_pin_enable();
  584. /* clear any interrupt. */
  585. while(cs_pp_r(pDrvCtrl, CS_PKTPG_ISQ) != 0);
  587. cs_chip_int_enable(pDrvCtrl);
  589. /* install isr. */
  590. if(intConnect(INUM_TO_IVEC(pDrvCtrl->ivec), cs8900aInt, (int)pDrvCtrl) == ERROR)
  591. {
  592. return ERROR;
  593. }
  596. DRV_LOG(DRV_DEBUG_LOAD, "Interrupt connected.n", 1, 2, 3, 4, 5, 6);
  598. /* enable interrupt. */
  599. intEnable(pDrvCtrl->ilevel);
  601. DRV_LOG(DRV_DEBUG_LOAD, "interrupt enabled.n", 1, 2, 3, 4, 5, 6);
  609. END_FLAGS_SET(&pDrvCtrl->end, IFF_UP | IFF_RUNNING);
  611. return OK;
  612. }
  614. /*
  615.  * cs8900aInt - handle controller interrupt
  616.  *
  617.  * This routine is called at interrupt level in response to an interrupt from
  618.  * the controller.
  619.  *
  620.  * RETURNS: N/A.
  621.  */
  622. void cs8900aInt(END_DEVICE * pDrvCtrl)
  623. {
  624. USHORT stat = 0;
  625. int recv_len = 0;
  626. volatile char * p_char = NULL;
  627. /*volatile unsigned int * p_src = (volatile unsigned int *)(CS_CHIP_MEM_BASE + CS_PKTPG_RX_FRAME);*/
  628. volatile char * p_src = (char *)(CS_CHIP_MEM_BASE + CS_PKTPG_RX_FRAME);
  629. volatile char temp_char1, temp_char2;
  630. int i;
  632. DRV_LOG(DRV_DEBUG_INT, "Got an interrupt!n", 1, 2, 3, 4, 5, 6);
  634.     /*logMsg("cs8900aInt come here!!!n",0,0,0,0,0,0);*/
  636. while(1)
  637. {
  638. /* Read the device status register */
  639. stat = *((USHORT *)(CS_CHIP_MEM_BASE + CS_PKTPG_ISQ));
  640. if(stat == 0)
  641. {
  642. break;
  643. }
  644. else
  645. {
  646.     ;
  647. }
  649. switch(stat & CS_REG_NUM_MASK)
  650. {
  651. case CS_REG_NUM_RX_EVENT:
  652. if(CS_RX_EVENT_CRC_ERR & stat)
  653. {
  654. if(display_net_event) printf("recv-data CRC error!n");
  655. cs_chip_rx_frame_drop(pDrvCtrl, 1);
  656. *((volatile unsigned int *)(0x560000A4))=(*((volatile unsigned int *)(0x560000A4)))&(~(1<<9));
  657. break;
  658. }
  659. if(CS_RX_EVENT_RUNT & stat)
  660. {
  661. if(display_net_event) printf("error, recv-data too short!n");
  662. cs_chip_rx_frame_drop(pDrvCtrl, 1);
  663. *((volatile unsigned int *)(0x560000A4))=(*((volatile unsigned int *)(0x560000A4)))&(~(1<<9));
  664. break;
  665. }
  666. if(CS_RX_EVENT_X_DATA & stat)
  667. {
  668. if(display_net_event) printf("error, recv-data too long!n");
  669. cs_chip_rx_frame_drop(pDrvCtrl, 1);
  670. *((volatile unsigned int *)(0x560000A4))=(*((volatile unsigned int *)(0x560000A4)))&(~(1<<9));
  671. break;
  672. }
  673. if(CS_RX_EVENT_RX_OK & stat)
  674. {
  675. pDrvCtrl->rxHandling = TRUE;
  677. p_char = netClusterGet (pDrvCtrl->end.pNetPool, pDrvCtrl->end.pNetPool->clTbl[0]);
  679. if(p_char != NULL)
  680. {   
  682.     /*recv_len = *((USHORT *)(CS_CHIP_MEM_BASE + CS_PKTPG_RX_LENGTH));*/ 
  685. recv_len = cs_pp_r(pDrvCtrl, CS_PKTPG_RX_LENGTH);
  687. logMsg("recv_len =  %d n",recv_len,0,0,0,0,0);
  688. #if 0
  691.                     for(i = recv_len-2; i < recv_len;i+=2)
  692.                     {
  693.                         logMsg(" 0x%x n",*((USHORT *)(CS_CHIP_MEM_BASE + CS_PKTPG_RX_FRAME + i)),0,0,0,0,0);
  694.                     }
  698.                     logMsg("receive endn",0,0,0,0,0,0);
  700. bcopyBytes((char *)p_src, (char *)(p_char), recv_len);
  702. #endif
  704. /* The chip is ready for transmission now */
  705. /* Copy the frame to the chip to start transmission */
  706. #if 1
  707. for(i = 0; i < recv_len; i+=2)
  708. {
  709.     *((USHORT *)p_char+(i+2)/2) = *((USHORT *)(CS_CHIP_MEM_BASE + CS_PKTPG_RX_FRAME + i));
  710. /*printf(" : 0x%x",p_src_buf[count/2]);*/
  711. }
  712.  
  713. #endif
  715. //recv_len += 2;
  716. }
  718.  /*netJobAdd ((FUNCPTR)cs8900aRecv, (int)pDrvCtrl, (int)p_char,recv_len,0,0);*/ 
  719. netJobAdd ((FUNCPTR)cs8900aRecv, (END_DEVICE *)pDrvCtrl, (char*)p_char,recv_len,0,0);
  720. }
  721. break;
  722. case CS_REG_NUM_TX_EVENT:
  723. if(CS_TX_EVENT_JABBER & stat);
  724. if(CS_TX_EVENT_LOSS_CRS & stat);
  725. if(CS_TX_EVENT_OUT_WIN & stat);
  726. if(CS_TX_EVENT_SQE_ERR & stat);
  727. if(CS_TX_EVENT_TX_OK & stat)
  728. {logMsg("TX_OK!!!n",0,0,0,0,0,0);
  730.              *((volatile unsigned int *)(0x560000A4))=(*((volatile unsigned int *)(0x560000A4)))&(~(1<<9));
  732. if(display_net_event) printf("tx_okn");
  733. }
  734. break;
  735. case CS_REG_NUM_BUF_EVENT:
  736. *((volatile unsigned int *)(0x560000A4))=(*((volatile unsigned int *)(0x560000A4)))&(~(1<<9));
  737. break;
  738. case CS_REG_NUM_RX_MISS:
  739. if(display_net_event) printf("Warning, net-rx miss!n");
  740. *((volatile unsigned int *)(0x560000A4))=(*((volatile unsigned int *)(0x560000A4)))&(~(1<<9));
  741. break;
  742. case CS_REG_NUM_TX_COL:
  743. if(display_net_event) printf("Warning, net-tx collision!n");
  744. *((volatile unsigned int *)(0x560000A4))=(*((volatile unsigned int *)(0x560000A4)))&(~(1<<9));
  745. break;
  746. default:;
  747.     *((volatile unsigned int *)(0x560000A4))=(*((volatile unsigned int *)(0x560000A4)))&(~(1<<9));
  748. }
  749. }
  752. return ;
  753. }
  755. /*
  756.  * cs8900aRecv - process the next incoming packet
  757.  *
  758.  * Handle one incoming packet.  The packet is checked for errors.
  759.  *
  760.  * RETURNS: N/A.
  761.  */
  762. LOCAL void cs8900aRecv
  763. (
  764. END_DEVICE * pDrvCtrl, /* device structure */
  765. char* pNewCluster,
  766. int len
  767. )
  768. {
  769. char * temp_buf = NULL;
  770. int temp_count = 0;
  771. M_BLK_ID pMblk;
  772. CL_BLK_ID pClBlk;
  773. int i = 0;
  775. pDrvCtrl->rxHandling = TRUE;
  777. /* TODO - Packet must be checked for errors. */
  778. END_ERR_ADD(&pDrvCtrl->end, MIB2_IN_UCAST, +1);
  780. /*
  781.  * We implicitly are loaning here, if copying is necessary this
  782.  * step may be skipped, but the data must be copied before being
  783.  * passed up to the protocols.
  784.  */
  785. /* pDrvCtrl->pClPoolId); */
  787. /*logMsg("cs8900aRecv come here!!!n",0,0,0,0,0,0);*/
  789. if(pNewCluster == NULL)
  790.         {
  791. DRV_LOG(DRV_DEBUG_RX, "Cannot loan!n", 1, 2, 3, 4, 5, 6);
  792. END_ERR_ADD(&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  793. goto cleanRXD;
  794.         }
  796. /* Grab a cluster block to marry to the cluster we received. */
  797. if(((pClBlk = netClBlkGet(pDrvCtrl->end.pNetPool, M_DONTWAIT)) == NULL)
  798. ||(len <= 0))
  799. {
  800. netClFree(pDrvCtrl->end.pNetPool, (UCHAR *)pNewCluster);
  801. DRV_LOG(DRV_DEBUG_RX, "Out of Cluster Blocks!n", 1, 2, 3, 4, 5, 6);
  802. END_ERR_ADD(&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  803. goto cleanRXD;
  804. }
  806. if((pMblk = mBlkGet(pDrvCtrl->end.pNetPool, M_DONTWAIT, MT_DATA)) == NULL)
  807. {
  808. netClBlkFree(pDrvCtrl->end.pNetPool, pClBlk);
  809. netClFree(pDrvCtrl->end.pNetPool, (UCHAR *)pNewCluster);
  810. DRV_LOG(DRV_DEBUG_RX, "Out of M Blocks!n", 1, 2, 3, 4, 5, 6);
  811. END_ERR_ADD(&pDrvCtrl->end, MIB2_IN_ERRS, +1);
  812. goto cleanRXD;
  813. }
  815. /* Join the cluster to the MBlock */
  816. netClBlkJoin(pClBlk, pNewCluster, len, NULL, 0, 0, 0);
  817. netMblkClJoin(pMblk, pClBlk);
  819. /* TODO - Invalidate any RFD dma buffers */
  820. pMblk->mBlkHdr.mLen = len;
  821. pMblk->mBlkHdr.mFlags |= M_PKTHDR;
  822. pMblk->mBlkPktHdr.len = len;
  823. pMblk->mBlkHdr.mData += 2; //在截取出IP层数据后必须保证mData是字对齐，因为在IP层数据
  824.                            //截取后要进行数据类型的转换，而在这之前可以不要求mData
  825.                            //是字对齐，因为在MAC层数据中，不会进行数据结构类型的转换
  828. #if 0
  829.     printf("begin n");
  830. printf("len = %d n",len);
  831. for(i=0 ; i<len ;i++)
  832. {  
  833.     printf("  0x%x ",*((unsigned char*)pMblk->mBlkHdr.mData+i));
  834. /*printf("  0x%x ",*(pNewCluster+i));*/
  835. }
  836.     printf("n end n");
  837. #endif
  838. DRV_LOG(DRV_DEBUG_RX, "Calling upper layer!n", 1, 2, 3, 4, 5, 6);
  840. /* TODO - Done with processing, clean up and pass it up. */
  841. /* Call the upper layer's receive routine. */
  842. END_RCV_RTN_CALL(&pDrvCtrl->end, pMblk);
  844. *((volatile unsigned int *)(0x560000A4))=(*((volatile unsigned int *)(0x560000A4)))&(~(1<<9));
  846. cleanRXD:
  847. pDrvCtrl->rxHandling = FALSE;
  849. *((volatile unsigned int *)(0x560000A4))=(*((volatile unsigned int *)(0x560000A4)))&(~(1<<9));
  850. return;
  851. }
  853. /*
  854.  * cs8900aSend - the driver send routine
  855.  *
  856.  * This routine takes a M_BLK_ID sends off the data in the M_BLK_ID.
  857.  * The buffer must already have the addressing information properly installed
  858.  * in it.  This is done by a higher layer.  The last arguments are a free
  859.  * routine to be called when the device is done with the buffer and a pointer
  860.  * to the argument to pass to the free routine.
  861.  *
  862.  * RETURNS: OK, ERROR, or END_ERR_BLOCK.
  863.  */
  864. LOCAL STATUS cs8900aSend
  865. (
  866. END_DEVICE* pDrvCtrl, /* device ptr */
  867. M_BLK_ID pMblk /* data to send */
  868. )
  869. {
  870. static UCHAR p_src_buf[CS_CHIP_FRAME_BUF_SIZE];
  871. int old_level = 0;
  872. int length = 0;
  873. STATUS tx_status = ERROR;
  875.   if(pDrvCtrl->resetting) return END_ERR_BLOCK;
  877. if(!(pDrvCtrl->flags & cs8900a_POLLING))
  878. {
  879. END_TX_SEM_TAKE(&pDrvCtrl->end, WAIT_FOREVER);
  880. }
  882. /* Get data from Mblk to tx buffer. */
  883. length = netMblkToBufCopy(pMblk, (char*)p_src_buf, NULL);
  886. /* lock interrupt. */
  887. if(!(pDrvCtrl->flags & cs8900a_POLLING))
  888. {
  889. old_level = intLock();
  890. }
  892.   /* transmit it. */
  893. tx_status = cs_chip_send_frame(pDrvCtrl, (USHORT *)p_src_buf, length);
  895. /* unlock interrupt. */
  896. if(!(pDrvCtrl->flags & cs8900a_POLLING))
  897. {
  898. intUnlock (old_level);
  899. }
  901. if(!(pDrvCtrl->flags & cs8900a_POLLING))
  902. {
  903. END_TX_SEM_GIVE(&pDrvCtrl->end);
  904. }
  906. /* Bump the statistics counters. */
  907. END_ERR_ADD(&pDrvCtrl->end, MIB2_OUT_UCAST, +1);
  909. if(tx_status == ERROR)
  910. {
  911. /* transmit failed. */
  912. return END_ERR_BLOCK;
  913. }
  915. /*
  916.  * Cleanup.  If the driver copied the data from the mblks to a different
  917.  * buffer, then free the mblks now.  Otherwise, free the mblk chain
  918.  * after the device is finished with the TFD.
  919.  */
  920. netMblkClChainFree(pMblk);
  922. return OK;
  923. }
  925. /*
  926.  * cs8900aIoctl - the driver I/O control routine
  927.  *
  928.  * Process an ioctl request.
  929.  *
  930.  * RETURNS: A command specific response, usually OK or ERROR.
  931.  */
  932. LOCAL int cs8900aIoctl
  933. (
  934. END_DEVICE* pDrvCtrl, /* device receiving command */
  935. int cmd, /* ioctl command code */
  936. caddr_t data /* command argument */
  937. )
  938. {
  939. int error = 0;
  940. long value;
  942. switch((unsigned)cmd)
  943. {
  944. case EIOCSADDR: /* set MAC address */
  945. if (data == NULL) return EINVAL;
  946. bcopy ((char *)data, (char *)END_HADDR(&pDrvCtrl->end), END_HADDR_LEN(&pDrvCtrl->end));
  947. break;
  949. case EIOCGADDR: /* get MAC address */
  950. if(data == NULL) return EINVAL;
  951. bcopy((char *)END_HADDR(&pDrvCtrl->end), (char *)data, END_HADDR_LEN(&pDrvCtrl->end));
  952. break;
  954. case EIOCSFLAGS: /* set (or clear) flags */
  955. value = (long)data;
  956. if(value < 0)
  957. {
  958. value = -value;
  959. value--;
  960. END_FLAGS_CLR(&pDrvCtrl->end, value);
  961. }
  962. else
  963. {
  964. END_FLAGS_SET(&pDrvCtrl->end, value);
  965. }
  966. cs8900aConfig (pDrvCtrl);
  967. break;
  969. case EIOCGFLAGS: /* get flags */
  970. *(int *)data = END_FLAGS_GET(&pDrvCtrl->end);
  971. break;
  973. case EIOCPOLLSTART: /* Begin polled operation */
  974. cs8900aPollStart(pDrvCtrl);
  975. break;
  977. case EIOCPOLLSTOP: /* End polled operation */
  978. cs8900aPollStop(pDrvCtrl);
  979. break;
  981. case EIOCGMIB2233:
  982. case EIOCGMIB2: /* return MIB information */
  983. if(data == NULL) return EINVAL;
  984. bcopy((char *)&pDrvCtrl->end.mib2Tbl, (char *)data, sizeof(pDrvCtrl->end.mib2Tbl));
  985. break;
  987. case EIOCGFBUF: /* return minimum First Buffer for chaining */
  988. if(data == NULL) return EINVAL;
  989. *(int *)data = cs8900a_MIN_FBUF;
  990. break;
  992.         case EIOCGHDRLEN:
  993. if(data == NULL) return EINVAL;
  994. *(int *)data = EH_SIZE;
  995. break;
  997. default: /* unknown request */
  998. error = EINVAL;
  999. }
  1001. return error;
  1002. }
  1004. /*
  1005.  * cs8900aConfig - reconfigure the interface under us.
  1006.  *
  1007.  * Reconfigure the interface setting promiscuous mode, and changing the
  1008.  * multicast interface list.
  1009.  *
  1010.  * RETURNS: N/A.
  1011.  */
  1012. LOCAL void cs8900aConfig
  1013. (
  1014. END_DEVICE* pDrvCtrl /* device to be re-configured */
  1015. )
  1016. {
  1017. /* Set promiscuous mode if it's asked for. */
  1018. if(END_FLAGS_GET(&pDrvCtrl->end) & IFF_PROMISC)
  1019. {
  1020. DRV_LOG(DRV_DEBUG_IOCTL, "Setting promiscuous mode on!n", 1, 2, 3, 4, 5, 6);
  1021. }
  1022. else
  1023. {
  1024. DRV_LOG(DRV_DEBUG_IOCTL, "Setting promiscuous mode off!n", 1, 2, 3, 4, 5, 6);
  1025. }
  1027. /* Set up address filter for multicasting. */
  1028. if(END_MULTI_LST_CNT(&pDrvCtrl->end) > 0)
  1029. {
  1030. cs8900aAddrFilterSet(pDrvCtrl);
  1031. }
  1034. /* TODO - initialise the hardware according to flags */
  1035. cs_pp_w(pDrvCtrl, CS_PKTPG_IO_BASE, pDrvCtrl->io_addr); /* io base. */
  1037. cs_pp_w(pDrvCtrl, CS_PKTPG_MEM_BASE, (USHORT)((pDrvCtrl->mem_addr)&0xFFFF)); /* memory base.*/ 
  1038. cs_pp_w(pDrvCtrl, CS_PKTPG_MEM_BASE+2, (USHORT)((pDrvCtrl->mem_addr)>>16));
  1040. cs_pp_w(pDrvCtrl, CS_PKTPG_INT_NUM, pDrvCtrl->chip_int_num); /* interrupt pin. */
  1042. cs_pp_w(pDrvCtrl, CS_PKTPG_DMA_NUM, pDrvCtrl->chip_dma_num); /* Turn off the dma. */
  1044. cs_chip_to_mem_mode(pDrvCtrl, 1);
  1047. cs_chip_event_enable(pDrvCtrl);
  1049. /* receive style. */
  1050. cs_pp_w(pDrvCtrl,
  1051. CS_PKTPG_RX_CTL,
  1052. CS_RX_CTL_RX_OK_A | CS_RX_CTL_ALL_FRAME_A | CS_RX_CTL_BCAST_A | CS_RX_CTL_IND_A);
  1055. /* select 10baseT, and turn on rx/tx. */
  1056. cs_pp_w(pDrvCtrl,
  1057. CS_PKTPG_LINE_CTL,
  1058. CS_LINE_CTL_10BASET | CS_LINE_CTL_TX_ON | CS_LINE_CTL_RX_ON);
  1061. /* full duplex mode. */
  1062. cs_pp_w(pDrvCtrl,
  1063. CS_PKTPG_TEST_CTL,
  1064. CS_TEST_CTL_FDX | CS_TEST_CTL_DIS_LT);
  1066. /* led. */
  1067. cs_pp_w(pDrvCtrl, CS_PKTPG_SELF_CTL, 0);
  1069. return;
  1070. }
  1072. /*
  1073.  * cs8900aAddrFilterSet - set the address filter for multicast addresses
  1074.  *
  1075.  * This routine goes through all of the multicast addresses on the list
  1076.  * of addresses (added with the endAddrAdd() routine) and sets the
  1077.  * device's filter correctly.
  1078.  *
  1079.  * RETURNS: N/A.
  1080.  */
  1081. LOCAL void cs8900aAddrFilterSet
  1082. (
  1083. END_DEVICE* pDrvCtrl /* device to be updated */
  1084. )
  1085. {
  1086. ETHER_MULTI* pCurr;
  1088. pCurr = END_MULTI_LST_FIRST (&pDrvCtrl->end);
  1090. while(pCurr != NULL)
  1091. {
  1092. /* TODO - set up the multicast list */
  1093. pCurr = END_MULTI_LST_NEXT(pCurr);
  1094. }
  1096. /* TODO - update the device filter list */
  1098. /* Address Filter Register. */
  1099. cs_pp_w(pDrvCtrl, CS_PKTPG_IND_ADDR, pDrvCtrl->enetAddr[0]);
  1100. cs_pp_w(pDrvCtrl, CS_PKTPG_IND_ADDR+2, pDrvCtrl->enetAddr[1]);
  1101. cs_pp_w(pDrvCtrl, CS_PKTPG_IND_ADDR+4, pDrvCtrl->enetAddr[2]);
  1102. }
  1104. /*
  1105.  * cs8900aPollRcv - routine to receive a packet in polled mode.
  1106.  *
  1107.  * Polled mode operation takes place without any kernel or other OS
  1108.  * services available.  Use extreme care to insure that this code does not
  1109.  * call any kernel services.  Polled mode is only for WDB system mode use.
  1110.  * Kernel services, semaphores, tasks, etc, are not available during WDB
  1111.  * system mode.
  1112.  *
  1113.  * The WDB agent polls the device constantly looking for new data.  Typically
  1114.  * the device has a ring of RFDs to receive incoming packets.  This routine
  1115.  * examines the ring for any new data and copies it to the provided mblk.
  1116.  * The concern here is to keep the device supplied with empty buffers at all
  1117.  * time.
  1118.  *
  1119.  * RETURNS: OK upon success.  EAGAIN is returned when no packet is available.
  1120.  * A return of ERROR indicates a hardware fault or no support for polled mode
  1121.  * at all.
  1122.  */
  1124. LOCAL STATUS cs8900aPollRcv
  1125. (
  1126. END_DEVICE* pDrvCtrl, /* device to be polled */
  1127. M_BLK_ID pMblk /* ptr to buffer */
  1128. )
  1129. {
  1130. USHORT stat = 0;
  1131. int len = 0;
  1132. int i = 0;
  1134. /* Upper layer must provide a valid buffer. */
  1135. if((pMblk->mBlkHdr.mLen < len) || (!(pMblk->mBlkHdr.mFlags & M_EXT)))
  1136. {
  1137. return EAGAIN;
  1138. }
  1140. /* TODO - Invalidate any inbound RFD DMA buffers */
  1142. /* TODO - clear any status bits that may be set. */
  1143. stat = cs_pp_r(pDrvCtrl, CS_PKTPG_ISQ);
  1144. if(!(stat & CS_RX_EVENT_RX_OK)) return EAGAIN;
  1146. /* TODO - Check packet and device for errors */
  1148. /* Get packet and  length from device buffer/descriptor */
  1149. stat = cs_pp_r(pDrvCtrl, CS_PKTPG_RX_STATUS);
  1150. if(stat & CS_RX_EVENT_RX_OK)
  1151. {
  1152. len = cs_pp_r(pDrvCtrl, CS_PKTPG_RX_LENGTH);
  1154. /* TODO - Process device packet into net buffer */
  1155. /* bcopy(pPacket, pMblk->m_data, len); */
  1159. for(i = 0; i < (len / 2); i++)
  1160. {
  1161. ((USHORT *)(pMblk->m_data+2))[i] = 
  1162. cs_pp_r(pDrvCtrl, CS_PKTPG_RX_FRAME + (i * 2));
  1164. }
  1166.    
  1167. pMblk->mBlkHdr.mFlags |= M_PKTHDR; /* set the packet header */
  1168. pMblk->mBlkHdr.mLen = len+2; /* set the data len */
  1169. pMblk->mBlkPktHdr.len = len+2; /* set the total len */
  1171. }
  1173. /*
  1174.  * TODO - Done with this packet, clean up device. If needed
  1175.  * setup a new RFD/buffer for incoming packets
  1176.  */
  1180. return OK;
  1181. }
  1183. /*
  1184.  * cs8900aPollSend - routine to send a packet in polled mode.
  1185.  *
  1186.  * Polled mode operation takes place without any kernel or other OS
  1187.  * services available.  Use extreme care to insure that this code does not
  1188.  * call any kernel services.  Polled mode is only for WDB system mode use.
  1189.  * Kernel services, semaphores, tasks, etc, are not available during WDB
  1190.  * system mode.
  1191.  *
  1192.  * A typical implementation is to set aside a fixed buffer for polled send
  1193.  * operation.  Copy the mblk data to the buffer and pass the fixed buffer
  1194.  * to the device.  Performance is not a consideration for polled operations.
  1195.  *
  1196.  * An alternate implementation is a synchronous one.  The routine accepts
  1197.  * user data but does not return until the data has actually been sent.  If an
  1198.  * error occurs, the routine returns EAGAIN and the user will retry the request.
  1199.  *
  1200.  * If the device returns OK, then the data has been sent and the user may free
  1201.  * the associated mblk.  The driver never frees the mblk in polled mode.
  1202.  * The calling routine will free the mblk upon success.
  1203.  *
  1204.  * RETURNS: OK upon success.  EAGAIN if device is busy or no resources.
  1205.  * A return of ERROR indicates a hardware fault or no support for polled mode
  1206.  * at all.
  1207.  */
  1209. LOCAL STATUS cs8900aPollSend
  1210. (
  1211. END_DEVICE* pDrvCtrl, /* device to be polled */
  1212. M_BLK_ID pMblk /* packet to send */
  1213. )
  1214. {
  1215. static UCHAR p_src_buf[CS_CHIP_FRAME_BUF_SIZE];
  1216. int length = 0;
  1217. STATUS tx_status = ERROR;
  1219. /* reset? */
  1220.   if(pDrvCtrl->resetting)
  1221. {
  1222. return EAGAIN;
  1223. }
  1225. /* Get data from Mblk to tx buffer. */
  1226. length = netMblkToBufCopy(pMblk, p_src_buf, NULL);
  1228. /* transmit it. */
  1229. tx_status = cs_chip_send_frame(pDrvCtrl, (USHORT *)p_src_buf, length);
  1231. END_ERR_ADD(&pDrvCtrl->end, MIB2_OUT_UCAST, +1);
  1233. if(tx_status == ERROR)
  1234. {
  1235. return EAGAIN;
  1236. }
  1238. netMblkClChainFree(pMblk);
  1240. return OK;
  1241. }
  1243. /*
  1244.  * cs8900aMCastAdd - add a multicast address for the device
  1245.  *
  1246.  * This routine adds a multicast address to whatever the driver
  1247.  * is already listening for.  It then resets the address filter.
  1248.  *
  1249.  * RETURNS: OK or ERROR.
  1250.  */
  1252. LOCAL STATUS cs8900aMCastAdd
  1253. (
  1254. END_DEVICE* pDrvCtrl, /* device pointer */
  1255. char* pAddress /* new address to add */
  1256. )
  1257. {
  1258. int error;
  1260. if((error = etherMultiAdd(&pDrvCtrl->end.multiList, pAddress)) == ENETRESET)
  1261. {
  1262. cs8900aConfig(pDrvCtrl);
  1263. }
  1265. return OK;
  1266. }
  1268. /*
  1269.  * cs8900aMCastDel - delete a multicast address for the device
  1270.  *
  1271.  * This routine removes a multicast address from whatever the driver
  1272.  * is listening for.  It then resets the address filter.
  1273.  *
  1274.  * RETURNS: OK or ERROR.
  1275.  */
  1276. LOCAL STATUS cs8900aMCastDel
  1277. (
  1278. END_DEVICE* pDrvCtrl, /* device pointer */
  1279. char* pAddress /* address to be deleted */
  1280. )
  1281. {
  1282. int error;
  1284. if((error = etherMultiDel(&pDrvCtrl->end.multiList, (char*)pAddress)) == ENETRESET)
  1285. {
  1286. cs8900aConfig(pDrvCtrl);
  1287. }
  1289. return OK;
  1290. }
  1292. /*
  1293.  * cs8900aMCastGet - get the multicast address list for the device
  1294.  *
  1295.  * This routine gets the multicast list of whatever the driver
  1296.  * is already listening for.
  1297.  *
  1298.  * RETURNS: OK or ERROR.
  1299.  */
  1300. LOCAL STATUS cs8900aMCastGet
  1301. (
  1302. END_DEVICE* pDrvCtrl, /* device pointer */
  1303. MULTI_TABLE* pTable /* address table to be filled in */
  1304. )
  1305. {
  1306. return(etherMultiGet(&pDrvCtrl->end.multiList, pTable));
  1307. }
  1309. /*
  1310.  * cs8900aStop - stop the device
  1311.  *
  1312.  * This function calls BSP functions to disconnect interrupts and stop
  1313.  * the device from operating in interrupt mode.
  1314.  *
  1315.  * RETURNS: OK or ERROR.
  1316.  */
  1317. LOCAL STATUS cs8900aStop
  1318. (
  1319. END_DEVICE* pDrvCtrl /* device to be stopped */
  1320. )
  1321. {
  1322. END_FLAGS_CLR(&pDrvCtrl->end, IFF_UP | IFF_RUNNING);
  1324. /* TODO - stop/disable the device. */
  1325. if(intDisable(pDrvCtrl->ilevel) == ERROR)
  1326. {
  1327. DRV_LOG(DRV_DEBUG_LOAD, "Could not disconnect interrupt!n", 1, 2, 3, 4, 5, 6);
  1328. return ERROR;
  1329. }
  1331. /* disable the interrupt input pin of cs. */
  1332. cs8900a_pin_disable();
  1334. cs_chip_int_disable(pDrvCtrl);
  1336. return OK;
  1337. }
  1339. /*
  1340.  * cs8900aUnload - unload a driver from the system
  1341.  *
  1342.  * This function first brings down the device, and then frees any
  1343.  * stuff that was allocated by the driver in the load function.
  1344.  *
  1345.  * RETURNS: OK or ERROR.
  1346.  */
  1347. LOCAL STATUS cs8900aUnload
  1348. (
  1349. END_DEVICE* pDrvCtrl /* device to be unloaded */
  1350. )
  1351. {
  1352. if(pDrvCtrl == NULL) return ERROR;
  1354. END_OBJECT_UNLOAD(&pDrvCtrl->end);
  1356. /* stop it. */
  1357. cs8900aStop(pDrvCtrl);
  1359. /* reset it. */
  1360. cs8900aReset(pDrvCtrl);
  1362. /* TODO - Free any special allocated memory */
  1363. if(pDrvCtrl->end.pNetPool)
  1364. {
  1365. netPoolDelete(pDrvCtrl->end.pNetPool);
  1366. free(pDrvCtrl->end.pNetPool);
  1367. pDrvCtrl->end.pNetPool = (NET_POOL_ID)0;
  1368. }
  1370. if(cs8900aClDescTbl[0].memArea)
  1371. {
  1372. free(cs8900aClDescTbl[0].memArea);
  1373. cs8900aClDescTbl[0].memArea = (char *)0;
  1374. }
  1376. if(cs8900aMclBlkConfig.memArea)
  1377. {
  1378. free(cs8900aMclBlkConfig.memArea);
  1379. cs8900aMclBlkConfig.memArea = (char *)0;
  1380. }
  1382. /* New: free the END_OBJ structure allocated during cs8900aLoad() */
  1383. cfree((char *)pDrvCtrl);
  1384. pDrvCtrl = NULL;
  1386. return OK;
  1387. }
  1389. /*
  1390.  * cs8900aPollStart - start polled mode operations
  1391.  *
  1392.  * RETURNS: OK or ERROR.
  1393.  */
  1394. LOCAL STATUS cs8900aPollStart
  1395. (
  1396. END_DEVICE* pDrvCtrl /* device to be polled */
  1397. )
  1398. {
  1400. int oldLevel;
  1402. oldLevel = intLock();          /* disable ints during update */
  1404. /* TODO - turn off interrupts */
  1405. pDrvCtrl->flags |= cs8900a_POLLING;
  1407. intUnlock(oldLevel);   /* now cs8900aInt won't get confused */
  1409. DRV_LOG(DRV_DEBUG_POLL, "STARTEDn", 1, 2, 3, 4, 5, 6);
  1411. cs8900aConfig(pDrvCtrl); /* reconfigure device */
  1413. cs_chip_int_disable(pDrvCtrl);
  1415. return OK;
  1416. }
  1418. /*
  1419.  * cs8900aPollStop - stop polled mode operations
  1420.  *
  1421.  * This function terminates polled mode operation.  The device returns to
  1422.  * interrupt mode.
  1423.  *
  1424.  * The device interrupts are enabled, the current mode flag is switched
  1425.  * to indicate interrupt mode and the device is then reconfigured for
  1426.  * interrupt operation.
  1427.  *
  1428.  * RETURNS: OK or ERROR.
  1429.  */
  1430. LOCAL STATUS cs8900aPollStop
  1431. (
  1432. END_DEVICE* pDrvCtrl /* device to be polled */
  1433. )
  1434. {
  1436. int oldLevel;
  1438. oldLevel = intLock(); /* disable ints during register updates */
  1440. /* TODO - re-enable interrupts */
  1441. pDrvCtrl->flags &= ~cs8900a_POLLING;
  1443. intUnlock(oldLevel);
  1445. cs8900aConfig(pDrvCtrl);
  1447. DRV_LOG(DRV_DEBUG_POLL, "STOPPEDn", 1, 2, 3, 4, 5, 6);
  1449. return OK;
  1450. }
  1452. /*
  1453.  * cs8900aReset - reset device
  1454.  *
  1455.  * RETURNS: N/A.
  1456.  */
  1457. LOCAL void cs8900aReset
  1458. (
  1459. END_DEVICE* pDrvCtrl
  1460. )
  1461. {
  1462. int intState;
  1465. if(pDrvCtrl->unit != 0) return;
  1467. pDrvCtrl->resetting = TRUE;
  1469. /* chip reset. */
  1470. intState = intLock();
  1472. cs_chip_self_reset(pDrvCtrl);
  1475. intUnlock(intState);
  1478. /* TODO - reset all device counters/pointers, etc. */
  1479. cs_soft_end_init(pDrvCtrl);
  1482. pDrvCtrl->resetting = FALSE;
  1484. return;
  1485. }
  1487. /* Addition. */
  1489. /*
  1490.  * cs8900a_pin_enable - Enable the pin for the interrupt of cs8900a.
  1491.  * 
  1492.  * RETURNS: status(int).
  1493.  */
  1494. int cs8900a_pin_enable(void)/*GPGCON EINT9*/
  1495. {
  1496. mask32_change_bsp(
  1497. (int*)0x56000060, /* GPGCON of s3c2410x */
  1498. (int)2, /* start bit0 */
  1499. (int)2, /* change length 2, bit0..1 */
  1500. (int)2 /* Value is 2 for EINT0. */
  1501. );
  1502. mask32_change_bsp(
  1503. (int*)0x5600008C, /* EXTINT0 of s3c2410x */
  1504. (int)4, /* start bit0 */
  1505. (int)3, /* change length 3, bit0..2 */
  1506. (int)4 /* Value is 4, that rise edge triggered for EINT0. */
  1507. /* (int)1  Value is 1, that high level triggered for EINT0. */
  1508. );
  1509. mask32_change_bsp(
  1510. (int*)0x56000068, /* GPFUP of s3c2410x */
  1511. (int)1, /* start bit0 */
  1512. (int)1, /* change length 1, bit0 */
  1513. (int)1 /* Value is 1 for disable EINT0's pull-up. */
  1514. );
  1516. mask32_change_bsp(
  1517. (int*)0x560000A4, /* GPFUP of s3c2410x */
  1518. (int)9, /* start bit0 */
  1519. (int)1, /* change length 1, bit0 */
  1520. (int)0 /* Value is 1 for disable EINT0's pull-up. */
  1521. );
  1523. mask32_change_bsp(
  1524. (int*)0x560000A8, /* GPFUP of s3c2410x */
  1525. (int)9, /* start bit0 */
  1526. (int)1, /* change length 1, bit0 */
  1527. (int)1 /* Value is 1 for disable EINT0's pull-up. */
  1528. );
  1530. #if 0
  1531. mask32_change_bsp(
  1532. (int*)0x4A000008, /* GPFUP of s3c2410x */
  1533. (int)5, /* start bit0 */
  1534. (int)1, /* change length 1, bit0 */
  1535. (int)0 /* Value is 1 for disable EINT0's pull-up. */
  1536. );
  1540. mask32_change_bsp(
  1541. (int*)0x4A000000, /* GPFUP of s3c2410x */
  1542. (int)5, /* start bit0 */
  1543. (int)1, /* change length 1, bit0 */
  1544. (int)1 /* Value is 1 for disable EINT0's pull-up. */
  1545. );
  1548. mask32_change_bsp(
  1549. (int*)0x4A000010, /* GPFUP of s3c2410x */
  1550. (int)5, /* start bit0 */
  1551. (int)1, /* change length 1, bit0 */
  1552. (int)1 /* Value is 1 for disable EINT0's pull-up. */
  1553. );
  1555. #endif
  1557. return 0;
  1558. }
  1560. /*
  1561.  * cs8900a_pin_disable - Disable the pin for the interrupt of cs8900a.
  1562.  * 
  1563.  * RETURNS: status(int).
  1564.  */
  1565. int cs8900a_pin_disable(void)
  1566. {
  1567.     mask32_change_bsp(  
  1568.             (int*)0x56000060,   /* GPFCON of s3c2410x */  
  1569.             (int)2,         /* start bit0 */  
  1570.             (int)2,         /* change length 2, bit0..1 */  
  1571.             (int)0          /* Value is 0 for input. */  
  1572.             );  
  1573.     mask32_change_bsp(  
  1574.             (int*)0x5600008c,   /* EXTINT0 of s3c2410x */  
  1575.             (int)4,         /* start bit0 */  
  1576.             (int)3,         /* change length 3, bit0..2 */  
  1577.             (int)0          /* Value is 4, that low level triggered for EINT0. */  
  1578.             );  
  1579.     return 0;  
  1580. }
  1582. /*
  1583.  * cs_pp_r - reads a word from the PacketPage
  1584.  *
  1585.  * This routine reads a word from the PacketPage at the specified offset.
  1586.  *
  1587.  * RETURNS: a word in the offset
  1588.  */
  1590. USHORT cs_pp_r(END_DEVICE * pDrvCtrl, USHORT offset)
  1591. {
  1592. volatile USHORT temp_ushort = 0;
  1593. if(pDrvCtrl->in_memory_mode == TRUE)
  1594. {
  1595. /* in memory mode */
  1596. temp_ushort = *((volatile USHORT *)((pDrvCtrl->mem_addr) + CS_CHIP_MEM_BASE + offset));
  1597. return temp_ushort;
  1598. }
  1599. else
  1600. {
  1601. /* in io mode */
  1602. *((volatile USHORT *)((pDrvCtrl->io_addr) + CS_CHIP_IO_BASE + CS_PORT_PKTPG_PTR)) = offset;
  1603. temp_ushort = *((volatile USHORT *)((pDrvCtrl->io_addr) + CS_CHIP_IO_BASE + CS_PORT_PKTPG_DATA));
  1604. return temp_ushort;
  1605. }
  1606. }
  1608. /*
  1609.  * cs_pp_w - writes a value to the PacketPage
  1610.  *
  1611.  * This routine writes a value to the PacketPage at the specified offset.
  1612.  *
  1613.  * RETURNS: N/A
  1614.  */
  1616. void cs_pp_w(END_DEVICE * pDrvCtrl, USHORT offset, USHORT value)
  1617. {
  1618. if(pDrvCtrl->in_memory_mode == TRUE)
  1619. {
  1620. /* in memory mode */
  1621. *((volatile USHORT *)((pDrvCtrl->mem_addr) + CS_CHIP_MEM_BASE + offset)) = value;
  1622. }
  1623. else
  1624. {
  1625. /* in io mode */
  1626. *((volatile USHORT *)((pDrvCtrl->io_addr) + CS_CHIP_IO_BASE + CS_PORT_PKTPG_PTR)) = offset;
  1627. *((volatile USHORT *)((pDrvCtrl->io_addr) + CS_CHIP_IO_BASE + CS_PORT_PKTPG_DATA)) = value;
  1628. }
  1629. return;
  1630. }
  1633. /* add by phoenix                         左移位   修改位长 值  */
  1634. STATUS mask32_change_bsp(int* dist32, int num, int len, int src)
  1635. {
  1636. UINT32 tempUINT32;
  1638. tempUINT32 = *dist32;
  1640. if(len <= 0) return ERROR;
  1641. if((num+len) > 32) return ERROR;
  1643. tempUINT32 = ((tempUINT32&(~(((1<<len)-1)<<num)))|((src&((1<<len)-1))<<num));
  1645. *dist32 = tempUINT32;
  1647. return OK;
  1648. }
  1650. /* cs_chip_rx_frame_drop - delete some receive frame. */
  1651. void cs_chip_rx_frame_drop(END_DEVICE * pDrvCtrl, int num)
  1652. {
  1653. while(num--)
  1654. {
  1655. cs_pp_w(pDrvCtrl,CS_PKTPG_RX_CFG,
  1656. ((cs_pp_r(pDrvCtrl,CS_PKTPG_RX_CFG)) | CS_RX_CFG_SKIP));
  1657. }
  1659. return;
  1660. }
  1661. /* cs_generate_interrupt - generate a software interrupt for test. */
  1662. void cs_chip_generate_interrupt(END_DEVICE* pDrvCtrl)
  1663. {
  1664. cs_pp_w(pDrvCtrl,CS_PKTPG_BUF_CFG,
  1665. ((cs_pp_r(pDrvCtrl,CS_PKTPG_BUF_CFG)) | CS_BUF_CFG_SW_INT));
  1666. return;
  1667. }
  1668. /* cs_get_rx_miss_num - get the miss number of receive frames. */
  1669. int cs_chip_get_rx_miss_num(END_DEVICE* pDrvCtrl)
  1670. {
  1671. int temp_int;
  1672. temp_int = cs_pp_r(pDrvCtrl,CS_PKTPG_RX_MISS);
  1673. temp_int = (temp_int >> 6) & 0x03ff;
  1674. return temp_int;
  1675. }
  1676. /* cs_get_tx_col_num - get the collision number of transmit frames. */
  1677. int cs_chip_get_tx_col_num(END_DEVICE* pDrvCtrl)
  1678. {
  1679. int temp_int;
  1680. temp_int = cs_pp_r(pDrvCtrl,CS_PKTPG_TX_COL);
  1681. temp_int = (temp_int >> 6) & 0x03ff;
  1682. return temp_int;
  1683. }
  1684. /* cs_chip_to_mem_mode - set the cs to memory mode. */
  1685. STATUS cs_chip_to_mem_mode(END_DEVICE* pDrvCtrl, int flag)
  1686. {
  1687. pDrvCtrl->in_memory_mode = FALSE;
  1688. if(flag)
  1689. {
  1691. cs_pp_w(pDrvCtrl, CS_PKTPG_BUS_CTL,
  1692. cs_pp_r(pDrvCtrl, CS_PKTPG_BUS_CTL) | CS_BUS_CTL_MEM_MODE);
  1693. pDrvCtrl->in_memory_mode = TRUE;
  1694. }
  1695. else
  1696. {
  1698. cs_pp_w(pDrvCtrl, CS_PKTPG_BUS_CTL,
  1699. cs_pp_r(pDrvCtrl, CS_PKTPG_BUS_CTL) & (~CS_BUS_CTL_MEM_MODE));
  1701. pDrvCtrl->in_memory_mode = FALSE;
  1702. }
  1704. return OK;
  1705. }
  1707. /* cs_chip_self_reset - cs chip reset by software command. */
  1708. STATUS cs_chip_self_reset(END_DEVICE* pDrvCtrl)
  1709. {
  1710. const int reset_time = 5;
  1711. int wait_count = 0; 
  1713. if (cs_pp_r(pDrvCtrl,CS_PKTPG_EISA_NUM) != CS_EISA_NUM_CRYSTAL)
  1714. {
  1715. printf("CS_PKTPG_EISA_NUM Errorn");
  1717. }
  1719. if ((cs_pp_r(pDrvCtrl,CS_PKTPG_PRODUCT_ID) & 0xe0ff)!= 0x0000)
  1720. {
  1721. printf("Product ID Errorn");
  1723. }
  1726. /* do reset. */
  1727. cs_pp_w(pDrvCtrl, CS_PKTPG_SELF_CTL,
  1728. cs_pp_r(pDrvCtrl, CS_PKTPG_SELF_CTL) | CS_SELF_CTL_RESET);
  1730. /* wait for reset finish. */
  1731. while(!(cs_pp_r(pDrvCtrl, CS_PKTPG_SELF_ST) & CS_SELF_ST_INIT_DONE))
  1732. {
  1733. taskDelay(reset_time);
  1734. if((wait_count++) >= CS_MAXLOOP) return ERROR;
  1735. }
  1737. return OK;
  1738. }
  1740. /* cs_chip_int_enable - interrupt enable for cs chip. */
  1741. STATUS cs_chip_int_enable(END_DEVICE * pDrvCtrl)
  1742. {
  1743. /* set the master interrupt enable bit in cs chip. 0x0116 = 0x8017*/
  1744. cs_pp_w(pDrvCtrl,
  1745. CS_PKTPG_BUS_CTL, (cs_pp_r(pDrvCtrl, CS_PKTPG_BUS_CTL)) | CS_BUS_CTL_INT_ENBL);
  1747. return OK;
  1748. }
  1750. /* cs_chip_event_enable - interrupt enable for cs chip. */
  1751. STATUS cs_chip_event_enable(END_DEVICE * pDrvCtrl)
  1752. {
  1753. /* enable > data, < data, CRC_err, and Rx_OK interrupt. 0x0102 = 0x7103*/
  1754. cs_pp_w(pDrvCtrl,
  1755. CS_PKTPG_RX_CFG, (cs_pp_r(pDrvCtrl, CS_PKTPG_RX_CFG)) | CS_RX_CFG_ALL_IE);
  1757. /* enable all of the tx interrupt. 0x0106 = 0x8fc7*/
  1758. cs_pp_w(pDrvCtrl, CS_PKTPG_TX_CFG, CS_TX_CFG_ALL_IE);
  1760. /* enable Rx miss and Tx underrun interrupt. 0x010a = 0x070b*/
  1761. cs_pp_w(pDrvCtrl, CS_PKTPG_BUF_CFG,
  1762. CS_BUF_CFG_RX_MISS_IE | CS_BUF_CFG_TX_UNDR_IE | CS_BUF_CFG_RDY4TX_IE);
  1764. return OK;
  1765. }
  1767. /* cs_chip_int_disable - interrupt disable for cs chip. */
  1768. STATUS cs_chip_int_disable(END_DEVICE * pDrvCtrl)
  1769. {
  1770. /* clear the master interrupt enable bit in cs chip. */
  1771. cs_pp_w(pDrvCtrl,
  1772. CS_PKTPG_BUS_CTL, (cs_pp_r(pDrvCtrl, CS_PKTPG_BUS_CTL)) & (~CS_BUS_CTL_INT_ENBL));
  1774. return OK;
  1775. }
  1777. /* cs_chip_event_disable - interrupt disable for cs chip. */
  1778. STATUS cs_chip_event_disable(END_DEVICE * pDrvCtrl)
  1779. {
  1780. /* disable all of Rx interrupt. 0x0102 = ~0x7103*/
  1781. cs_pp_w(pDrvCtrl,
  1782. CS_PKTPG_RX_CFG, (cs_pp_r(pDrvCtrl, CS_PKTPG_RX_CFG)) & (~CS_RX_CFG_ALL_IE));
  1784. /* disable all of Tx interrupt. 0x0106 = 0x0007*/
  1785. cs_pp_w(pDrvCtrl, CS_PKTPG_TX_CFG, 0);
  1787. /* disable buffer interrupt. 0x010a = 0x0013*/
  1788. cs_pp_w(pDrvCtrl, CS_PKTPG_BUF_CFG, 0);
  1790. return OK;
  1791. }
  1792. /* cs_chip_select_rx_frame_type - select the receiver frame type. */
  1793. STATUS cs_chip_select_rx_frame_type(END_DEVICE * pDrvCtrl,USHORT type_mask,int val)
  1794. {
  1795. /* clear this bit. */
  1796. if(val == 0)
  1797. {
  1798. cs_pp_w(pDrvCtrl,
  1799. CS_PKTPG_RX_CTL, (cs_pp_r(pDrvCtrl, CS_PKTPG_RX_CTL)) & (~type_mask));
  1801. return OK;
  1802. }
  1804. /* set this bit. */
  1805. if(val == 1)
  1806. {
  1807. cs_pp_w(pDrvCtrl,
  1808. CS_PKTPG_RX_CTL, (cs_pp_r(pDrvCtrl, CS_PKTPG_RX_CTL)) | type_mask);
  1810. return OK;
  1811. }
  1813. return ERROR;
  1814. }
  1816. /* cs_chip_loop_set - on or off cs chip loop. */
  1817. STATUS cs_chip_loop_set(END_DEVICE * pDrvCtrl, int val)
  1818. {
  1819. if(val == 1)
  1820. {
  1821. cs_chip_set_full_duplex(pDrvCtrl, 1);
  1823. cs_pp_w(pDrvCtrl,
  1824. CS_PKTPG_TEST_CTL, (cs_pp_r(pDrvCtrl, CS_PKTPG_TEST_CTL))
  1825. | CS_TEST_CTL_ENDEC_LP | CS_TEST_CTL_FDX);
  1827. return OK;
  1828. }
  1830. if(val == 0)
  1831. {
  1832. cs_pp_w(pDrvCtrl,
  1833. CS_PKTPG_TEST_CTL, (cs_pp_r(pDrvCtrl, CS_PKTPG_TEST_CTL)) & (~CS_TEST_CTL_ENDEC_LP));
  1835. return OK;
  1836. }
  1838. return ERROR;
  1839. }
  1841. /* cs_chip_set_full_duplex - set cs rx/tx mode to full duplex or half duplex. */
  1842. STATUS cs_chip_set_full_duplex(END_DEVICE * pDrvCtrl, int val)
  1843. {
  1844. if(val == 1)
  1845. {
  1846. cs_pp_w(pDrvCtrl,
  1847. CS_PKTPG_TEST_CTL, (cs_pp_r(pDrvCtrl, CS_PKTPG_TEST_CTL)) | CS_TEST_CTL_FDX);
  1849. return OK;
  1850. }
  1852. if(val == 0)
  1853. {
  1854. cs_pp_w(pDrvCtrl,
  1855. CS_PKTPG_TEST_CTL, (cs_pp_r(pDrvCtrl, CS_PKTPG_TEST_CTL)) & (~CS_TEST_CTL_FDX));
  1857. return OK;
  1858. }
  1860. return ERROR;
  1861. }
  1863. /* cs_chip_set_link_dep - set cs run depend on link or independ. */
  1864. STATUS cs_chip_set_link_dep(END_DEVICE * pDrvCtrl, int val)
  1865. {
  1866. if(val == 1)
  1867. {
  1868. cs_pp_w(pDrvCtrl,
  1869. CS_PKTPG_TEST_CTL, (cs_pp_r(pDrvCtrl, CS_PKTPG_TEST_CTL)) | CS_TEST_CTL_DIS_LT);
  1871. return OK;
  1872. }
  1874. if(val == 0)
  1875. {
  1876. cs_pp_w(pDrvCtrl,
  1877. CS_PKTPG_TEST_CTL, (cs_pp_r(pDrvCtrl, CS_PKTPG_TEST_CTL)) & (~CS_TEST_CTL_DIS_LT));
  1879. return OK;
  1880. }
  1882. return ERROR;
  1883. }
  1885. /* cs_chip_tx_force_terminate - force terminate tx frame for cs chip. */
  1886. STATUS cs_chip_tx_force_terminate(END_DEVICE * pDrvCtrl,int val)
  1887. {
  1888. if(val == 1)
  1889. {
  1890. cs_pp_w(pDrvCtrl,
  1891. CS_PKTPG_TX_CMD, (cs_pp_r(pDrvCtrl, CS_PKTPG_TX_CMD)) | CS_TX_CMD_FORCE);
  1893. return OK;
  1894. }
  1896. if(val == 0)
  1897. {
  1898. cs_pp_w(pDrvCtrl,
  1899. CS_PKTPG_TX_CMD, (cs_pp_r(pDrvCtrl, CS_PKTPG_TX_CMD)) & (~CS_TX_CMD_FORCE));
  1901. return OK;
  1902. }
  1904. return ERROR;
  1905. }
  1907. /* cs_chip_set_tx_crc - on or off tx CRC. */
  1908. STATUS cs_chip_set_tx_crc(END_DEVICE * pDrvCtrl, int val)
  1909. {
  1910. if(val == 0)
  1911. {
  1912. cs_pp_w(pDrvCtrl,
  1913. CS_PKTPG_TX_CMD, (cs_pp_r(pDrvCtrl, CS_PKTPG_TX_CMD)) | CS_TX_CMD_NO_CRC);
  1915. return OK;
  1916. }
  1918. if(val == 1)
  1919. {
  1920. cs_pp_w(pDrvCtrl,
  1921. CS_PKTPG_TX_CMD, (cs_pp_r(pDrvCtrl, CS_PKTPG_TX_CMD)) & (~CS_TX_CMD_NO_CRC));
  1923. return OK;
  1924. }
  1926. return ERROR;
  1927. }
  1929. /* cs_chip_send_frame - send one frame to cs chip. */
  1930. STATUS cs_chip_send_frame(END_DEVICE * pDrvCtrl, USHORT * p_src_buf, int length)
  1931. {
  1932. USHORT bus_status = 0;
  1933. int count = 0;
  1934. int i;
  1935. unsigned char * p_src_buffer = (unsigned char *)p_src_buf;
  1937. if(length > 0)
  1938. {
  1939. /* Request that the transmit be started after all data has been copied */
  1940. *((USHORT *)(CS_CHIP_MEM_BASE + CS_PKTPG_TX_CMD)) = CS_TX_CMD_START_ALL+0x9;
  1942. /* TODO - initiate device transmit. */
  1943. *((USHORT *)(CS_CHIP_MEM_BASE + CS_PKTPG_TX_LENGTH)) = length;
  1945. /* Read the busStatus register which indicates success of the request */
  1946. bus_status = *((USHORT *)(CS_CHIP_MEM_BASE + CS_PKTPG_BUS_ST));
  1949. if((!(bus_status & CS_BUS_ST_TX_BID_ERR)) && (bus_status & CS_BUS_ST_RDY4TXNOW))
  1950. {
  1951.   
  1952.             /* The chip is ready for transmission now */
  1953. /* Copy the frame to the chip to start transmission */
  1954. for(count = 0; count < length; count+=2)
  1955. {
  1956. *((USHORT *)(CS_CHIP_MEM_BASE + CS_PKTPG_TX_FRAME + count)) = p_src_buf[count/2];
  1957. }
  1959. /*logMsg("transimite finish!!n",0,0,0,0,0,0);*/
  1961. return OK;
  1962. }
  1963. else
  1964. {
  1965.             logMsg("the chip tx buffer unuse!!n",0,0,0,0,0,0);
  1967. /* the chip tx buffer unuse. */
  1968. if(display_net_event)printf("Error, the tx buffer is invalid!!!n");
  1969. return ERROR;
  1970. }
  1971. }
  1972. else
  1973. {
  1974. /* null frame. */
  1975. if(display_net_event)printf("Error, the length of tx frame less 0!!!n");
  1976. return ERROR;
  1977. }
  1978. }
  1980. /* cs_soft_end_init - initialize the END_DEVICE. */
  1981. STATUS cs_soft_end_init(END_DEVICE * pDrvCtrl)
  1982. {
  1983. pDrvCtrl->chip_dma_num = CS_INIT_DMA_NUM;
  1985. pDrvCtrl->chip_int_num = CS_INIT_INT_NUM;
  1986. pDrvCtrl->ilevel = CS_INIT_VECT;
  1987. pDrvCtrl->ivec = CS_INIT_VECT;
  1989. pDrvCtrl->io_addr = CS_CHIP_IO_OFFSET;
  1990. pDrvCtrl->mem_addr = CS_CHIP_MEM_OFFSET;
  1992.     pDrvCtrl->enetAddr[2] = (USHORT)0x0F66;  
  1993.     pDrvCtrl->enetAddr[1] = (USHORT)0x5544;  
  1994.     pDrvCtrl->enetAddr[0] = (USHORT)0x3322;  
  1996. pDrvCtrl->media_type = CS_MEDIA_10BASET;
  1997. pDrvCtrl->in_memory_mode = FALSE;
  1998. pDrvCtrl->resetting = FALSE;
  2000. return OK;
  2001. }