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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
cs8900.c
资源名称：SMDK2440.rar　[点击查看]
上传用户：qiulin1960
上传日期：2013-10-16
资源大小：2844k
文件大小：11k
源码类别：

Windows CE

开发平台：

Windows_Unix

cs8900.c：源码内容
  1. /*++
  2. THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  3. ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  4. THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  5. PARTICULAR PURPOSE.
  6. Copyright (c) 1995-1998  Microsoft Corporation
  8. Module Name:
  10.     cs8900.c
  12. Abstract:
  14.     Card-specific functions for the NDIS 3.0 CS8900 driver.
  15.     
  16. Updates:
  18. 2003.10.24 jylee changes on interrupt registration for NDIS
  21. --*/
  23. #include "precomp.h"
  25. // CS8900 signature read from PacketPage Pointer port at reset
  26. #define CS8900_SIGNATURE                0x3000
  27. // CS8900 EISA number
  28. #define CS8900_EISA_NUMBER              0x630e
  29. // CS8900 product ID
  30. #define CS8900_PRDCT_ID                 0x0000
  31. #define CS8900_PRDCT_ID_MASK            0xe0ff
  33. #define PKTPG_EISA_NUMBER               0x0000
  34. #define PKTPG_PRDCT_ID_CODE             0x0002
  36. volatile unsigned char *EthCommand;
  37. volatile INTreg *v_pINTRegs;
  38. volatile IOPreg *v_pIOPRegs;
  39. volatile MEMreg *v_pMEMRegs;
  41. unsigned short GetD_SlowIO(unsigned long regaddrs)
  42. {
  43. return (*(volatile unsigned short *)regaddrs);
  44. }
  46. void SetD_SlowIO(unsigned long regaddrs, unsigned short regvalue)
  47. {
  48. *(volatile unsigned short *)regaddrs = regvalue;
  49. }
  51. //Read data from a PacketPage register.
  52. unsigned short CS8900ReadRegister(unsigned short offset)
  53. {
  54. writeIoPort(IO_PACKET_PAGE_POINTER, offset);
  55. return readIoPort(IO_PACKET_PAGE_DATA_0);
  56. }
  58. // Write data to a PacketPage register.
  59. void CS8900WriteRegister(unsigned short offset, unsigned short data)
  60. {
  61. writeIoPort(IO_PACKET_PAGE_POINTER, offset);
  62. writeIoPort(IO_PACKET_PAGE_DATA_0, data);
  63. }
  65. int findCS(void)
  66. {
  67. unsigned short sg;
  69. /* Check the signature. */
  70. if ((sg = readIoPort(IO_PACKET_PAGE_POINTER)) != CS8900_SIGNATURE)
  71. {
  72. DEBUGMSG(1, (TEXT("Signature Error %xn"), sg));
  73. // return FALSE;
  74. }
  76. /* Check the EISA registration number. */
  77. if (CS8900ReadRegister(PKTPG_EISA_NUMBER) != CS8900_EISA_NUMBER)
  78. {
  79. DEBUGMSG(1, (TEXT("Eisa Number Errorn")));
  80. return FALSE;
  81. }
  83. /* Check the Product ID. */
  84. if ((CS8900ReadRegister(PKTPG_PRDCT_ID_CODE) & CS8900_PRDCT_ID_MASK)
  85. != CS8900_PRDCT_ID)
  86. {
  87. DEBUGMSG(1, (TEXT("Product ID Errorn")));
  88. return FALSE;
  89. }
  91. DEBUGMSG(1, (TEXT("Product ID = %xn"), CS8900ReadRegister(PKTPG_PRDCT_ID_CODE)));
  94. return TRUE;
  95. }
  97. //Reset CS8900 chip.
  98. #define MAX_COUNT 0x100000
  99. int resetCS(void)
  100. {
  101. int i;
  102. unsigned short dummy;
  104.     /* Issue a reset command to the chip */
  105.     CS8900WriteRegister(PKTPG_SELF_CTL, SELF_CTL_RESET);
  107.     /* Delay for 125 micro-seconds */
  108. Sleep(10);
  110.     /* Transition SBHE to switch chip from 8-bit to 16-bit */
  112. #if 0
  113. *(volatile unsigned char *)&EthCommand[IO_PACKET_PAGE_POINTER];
  114. *(volatile unsigned char *)&EthCommand[IO_PACKET_PAGE_POINTER+1];
  115. *(volatile unsigned char *)&EthCommand[IO_PACKET_PAGE_POINTER];
  116. *(volatile unsigned char *)&EthCommand[IO_PACKET_PAGE_POINTER+1];
  117. #endif
  119.     /* Wait until initialization is done */
  120. Sleep(100);
  122. /* Wait until INITD bit of SelfST register is set. */
  123. i = 0;
  124. while (((dummy = CS8900ReadRegister(PKTPG_SELF_ST)) &
  125. SELF_ST_INITD) == 0)
  126. {
  127. if (++i > MAX_COUNT)
  128. {
  129. DEBUGMSG(1, (TEXT("resetCs8900 failed 1n")));
  130. return FALSE;
  131. }
  132. }
  134. /* Wait until SIBUSY bit of SelfST register is cleared. */
  135. i = 0;
  136. while (((dummy = CS8900ReadRegister(PKTPG_SELF_ST)) &
  137. SELF_ST_SIBUSY) != 0)
  138. {
  139. if (++i > MAX_COUNT)
  140. {
  141. DEBUGMSG(1, (TEXT("resetCs8900 failed 2n")));
  142. return FALSE;
  143. }
  144. }
  146. return TRUE;
  147. }
  149. void initIrq(void)
  150. {
  151. unsigned short rdata;
  153. // interrupt enabling....
  155. CS8900WriteRegister(PKTPG_INTERRUPT_NUMBER, INTERRUPT_NUMBER);
  157. rdata = CS8900ReadRegister(PKTPG_BUS_CTL) | BUS_CTL_ENABLE_IRQ;
  158. CS8900WriteRegister(PKTPG_BUS_CTL, rdata);
  160. rdata = CS8900ReadRegister(PKTPG_LINE_CTL) | LINE_CTL_RX_ON | LINE_CTL_TX_ON;
  162. CS8900WriteRegister(PKTPG_LINE_CTL, rdata);
  163. }
  166. //Initialize CS8900 chip.
  167. int initCS()
  168. {
  169. CS8900WriteRegister(PKTPG_LINE_CTL, LINE_CTL_10_BASE_T);
  171. CS8900WriteRegister(PKTPG_RX_CFG, RX_CFG_RX_OK_I_E);
  173. CS8900WriteRegister(PKTPG_RX_CTL,
  174. RX_CTL_RX_OK_A | RX_CTL_IND_ADDR_A |
  175. RX_CTL_BROADCAST_A);
  177. CS8900WriteRegister(PKTPG_TX_CFG, 0); 
  179. CS8900WriteRegister(PKTPG_BUF_CFG, 0); 
  181. CS8900WriteRegister(PKTPG_INDIVISUAL_ADDR, 0x3322);
  182. CS8900WriteRegister(PKTPG_INDIVISUAL_ADDR + 2, 0x5544);
  183. CS8900WriteRegister(PKTPG_INDIVISUAL_ADDR + 4, 0x0F66);
  185. initIrq();
  187. return TRUE;
  188. }
  190. int CSInit()
  191. {
  192. // Find CS8900 chip. 
  193. if (findCS() == FALSE)
  194. return FALSE;
  196. DEBUGMSG(1, (TEXT("Find CS8900 OKrn")));
  198. /* Reset CS8900 chip. */
  199. if (resetCS() == FALSE)
  200. return FALSE;
  202. DEBUGMSG(1, (TEXT("reset CS8900 OKrn")));
  204. /* Initialize CS8900 chip. */
  205. if (initCS() == FALSE)
  206. return FALSE;
  208. DEBUGMSG(1, (TEXT("CS8900 init OKrn")));
  210. return TRUE;
  211. }
  215. #pragma NDIS_PAGEABLE_FUNCTION(CS8900Initialize)
  217. BOOLEAN
  218. CS8900Initialize(
  219.     IN PCS8900_ADAPTER Adapter
  220.     )
  222. /*++
  224. Routine Description:
  226.     Initializes the card into a running state.
  228. Arguments:
  230.     Adapter - pointer to the adapter block.
  232. Return Value:
  234.     TRUE, if all goes well, else FALSE.
  236. --*/
  238. {
  240. DWORD rdata;
  243. EthCommand = (unsigned char *)ioPacketPage;
  245. if (CSInit() == FALSE)
  246. return FALSE;
  248. v_pIOPRegs = VirtualAlloc(0, sizeof(IOPreg), MEM_RESERVE, PAGE_NOACCESS);
  249. if (v_pIOPRegs == NULL) 
  250. {
  251.     DEBUGMSG (1,(TEXT("[CS8900] v_pIOPRegs is not allocatednr")));
  252. return FALSE;
  253. }
  254. if (!VirtualCopy((PVOID)v_pIOPRegs, (PVOID)IOP_BASE, sizeof(IOPreg), PAGE_READWRITE|PAGE_NOCACHE)) {
  255.     DEBUGMSG (1,(TEXT("[CS8900] v_pIOPRegs is not mappednr")));
  256. goto cs8900_fail;
  257. }
  258. DEBUGMSG (1,(TEXT("[CS8900] v_pIOPRegs is mapped to %xnr"), v_pIOPRegs));
  260. v_pINTRegs = VirtualAlloc(0, sizeof(INTreg), MEM_RESERVE, PAGE_NOACCESS);
  261. if (v_pINTRegs== NULL) 
  262. {
  263.     DEBUGMSG (1,(TEXT("[CS8900] v_pINTRegs is not allocatednr")));
  264. goto cs8900_fail;
  265. }
  266. if (!VirtualCopy((PVOID)v_pINTRegs, (PVOID)INT_BASE, sizeof(INTreg), PAGE_READWRITE|PAGE_NOCACHE)) {
  267.     DEBUGMSG (1,(TEXT("[CS8900] v_pINTRegs is not mappednr")));
  268. goto cs8900_fail;
  269. }
  270. DEBUGMSG (1,(TEXT("[CS8900] v_pINTRegs is mapped to %xnr"), v_pINTRegs));
  272. v_pMEMRegs = VirtualAlloc(0,sizeof(MEMreg), MEM_RESERVE,PAGE_NOACCESS);
  273. if(v_pMEMRegs == NULL) 
  274. {
  275.     DEBUGMSG (1,(TEXT("[CS8900] v_pMEMRegs is not allocatednr")));
  276. goto cs8900_fail;
  277. }
  278. if(!VirtualCopy((PVOID)v_pMEMRegs,(PVOID)MEMCTRL_BASE,sizeof(MEMreg), PAGE_READWRITE|PAGE_NOCACHE)) {
  279.     DEBUGMSG (1,(TEXT("[CS8900] v_pMEMRegs is not mappednr")));
  280.     goto cs8900_fail;
  281. }    
  282. DEBUGMSG (1,(TEXT("[CS8900] v_pMEMRegs is mapped to %xnr"), v_pMEMRegs));
  284.     // nGCS3=nUB/nLB(nSBHE),nWAIT,16-bit
  285.     v_pMEMRegs->rBWSCON = (v_pMEMRegs->rBWSCON&~(0xf<<12))|(0xd<<12);
  287.     // BANK3 access timing
  288. v_pMEMRegs->rBANKCON3=((CS8900_Tacs<<13)+(CS8900_Tcos<<11)+(CS8900_Tacc<<8)+(CS8900_Tcoh<<6)
  289. +(CS8900_Tah<<4)+(CS8900_Tacp<<2)+(CS8900_PMC));
  290. if (CSInit() == FALSE)
  291. goto cs8900_fail;
  293. rdata  = v_pIOPRegs->rGPGCON;
  294. rdata &= ~(3 << 2);
  295. rdata |=  (2 << 2);
  296. v_pIOPRegs->rGPGCON = rdata; /* External Interrupt #9 Enable */
  298. #if 1
  299. rdata  = v_pIOPRegs->rEXTINT1;
  300. rdata &= ~(7 << 4);
  301. rdata |=  (4 << 4);
  302. v_pIOPRegs->rEXTINT1 = rdata; /* High Level Triggered Mode */
  303. #else
  304. rdata  = v_pIOPRegs->rEXTINT1;
  305. rdata &= ~(7 << 4);
  306. rdata |=  (1 << 4);
  307. v_pIOPRegs->rEXTINT1 = rdata; /* Rising Edge Detect Mode */
  308. #endif
  310. DEBUGMSG(1, (TEXT("[CS8900] rGPGCON = %xrn"), v_pIOPRegs->rGPGCON));
  311. DEBUGMSG(1, (TEXT("[CS8900] rEXTINT1 = %xrn"), v_pIOPRegs->rEXTINT1));
  313. return TRUE;
  315. cs8900_fail:
  316.     if (v_pIOPRegs) {
  317.         VirtualFree((PVOID)v_pIOPRegs, 0, MEM_RELEASE);
  318.     }
  319.     if (v_pINTRegs) {
  320.         VirtualFree((PVOID)v_pINTRegs, 0, MEM_RELEASE);
  321.     }
  322.     if (v_pMEMRegs) {
  323.         VirtualFree((PVOID)v_pMEMRegs, 0, MEM_RELEASE);
  324.     }
  325. return FALSE;
  326. }
  328. #pragma NDIS_PAGEABLE_FUNCTION(CS8900ReadEthernetAddress)
  330. BOOLEAN CS8900ReadEthernetAddress(
  331.     IN PCS8900_ADAPTER Adapter
  332. )
  334. /*++
  336. Routine Description:
  338.     Reads in the Ethernet address from the CS8900 Chip...
  340. Arguments:
  342.     Adapter - pointer to the adapter block.
  344. Return Value:
  346.     The address is stored in Adapter->PermanentAddress, and StationAddress if it
  347.     is currently zero.
  349. --*/
  351. {
  352. Adapter->PermanentAddress[0] = 0x22;
  353. Adapter->PermanentAddress[1] = 0x33;
  354. Adapter->PermanentAddress[2] = 0x44;
  355. Adapter->PermanentAddress[3] = 0x55;
  356. Adapter->PermanentAddress[4] = 0x66;
  357. Adapter->PermanentAddress[5] = 0x0F;
  358.       
  359. DEBUGMSG(1,
  360.         (TEXT("CS8900: PermanentAddress [ %02x-%02x-%02x-%02x-%02x-%02x ]rn"),
  361.             Adapter->PermanentAddress[0],
  362.             Adapter->PermanentAddress[1],
  363.             Adapter->PermanentAddress[2],
  364.             Adapter->PermanentAddress[3],
  365.             Adapter->PermanentAddress[4],
  366.             Adapter->PermanentAddress[5]));
  368.     //
  369.     // Use the burned in address as the station address, unless the
  370.     // registry specified an override value.
  371.     //
  372.     if ((Adapter->StationAddress[0] == 0x00) &&
  373.         (Adapter->StationAddress[1] == 0x00) &&
  374.         (Adapter->StationAddress[2] == 0x00) &&
  375.         (Adapter->StationAddress[3] == 0x00) &&
  376.         (Adapter->StationAddress[4] == 0x00) &&
  377.         (Adapter->StationAddress[5] == 0x00)
  378.     )
  379.     {
  380.      DEBUGMSG(1, (TEXT("CS8900: StationAddress Modified!...rn")));
  381.         Adapter->StationAddress[0] = Adapter->PermanentAddress[0];
  382.         Adapter->StationAddress[1] = Adapter->PermanentAddress[1];
  383.         Adapter->StationAddress[2] = Adapter->PermanentAddress[2];
  384.         Adapter->StationAddress[3] = Adapter->PermanentAddress[3];
  385.         Adapter->StationAddress[4] = Adapter->PermanentAddress[4];
  386.         Adapter->StationAddress[5] = Adapter->PermanentAddress[5];
  387.     }
  389.     return(TRUE);
  390. }
  392. unsigned short CS8900RequestTransmit
  393. (
  394. UINT PacketLength
  395. )
  396. {
  397. // Request that the transmit be started after all data has been copied
  398. writeIoPort(IO_TX_CMD, TX_CMD_START_ALL);
  399. writeIoPort(IO_TX_LENGTH, (unsigned short)PacketLength);
  401. // Return the BusStatus register which indicates success of the request
  402. return CS8900ReadRegister(PKTPG_BUS_ST);
  403. }
  405. void CS8900CopyTxFrame
  406. (
  407. PCHAR pPacket,
  408. UINT PacketLength
  409.     )
  410. {
  411. UINT  i;
  412. PWORD pMsg;
  413. WORD PacketType, PacketOper;
  415. pMsg = (PWORD)pPacket;
  417. PacketType = *(pMsg + 6);
  418. PacketOper = *(pMsg + 10);
  420. if (PacketType == 0x0608)
  421. {
  422. if (PacketOper == 0x0100)
  423. DEBUGMSG(1, (TEXT("[CS8900] Send ARP Request Packetrn")));
  424. else if (PacketOper == 0x0200)
  425. DEBUGMSG(1, (TEXT("[CS8900] Send ARP Response Packetrn")));
  426. else if (PacketOper == 0x0300)
  427. DEBUGMSG(1, (TEXT("[CS8900] Send RARP Request Packetrn")));
  428. else if (PacketOper == 0x0400)
  429. DEBUGMSG(1, (TEXT("[CS8900] Send RARP Response Packetrn")));
  430. else
  431. DEBUGMSG(1, (TEXT("[CS8900] Send Unknown ARP Packetrn")));
  432. }
  433. else if (PacketType == 0x0008)
  434. DEBUGMSG(1, (TEXT("[CS8900] Send IP Packetrn")));
  436. for (i = 0 ; i < (PacketLength + 1) / 2; i++)
  437. {
  438. writeIoPort(IO_RX_TX_DATA_0, *pMsg);
  439. pMsg++;
  440. }
  441. }