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

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

Windows CE

开发平台：

Windows_Unix

socket.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) 2001. Samsung Electronics, co. ltd  All rights reserved.
  8. Module Name:  
  10.    socket.c
  11.    
  12. Abstract:  
  14. Rev:
  15. 2002.04.22 : add S3C2410 specific initialization codes (by Seung-han, Lim)
  16. 2001.12.21 : Bug Fixup (kwangyoon LEE, kwangyoon@samsung.com)
  17. 2001.12.12 : add S3C2400 Specific codes (kwangyoon LEE, kwangyoon@samsung.com)
  19. Notes: 
  20. --*/
  22. #include <windows.h>
  23. #include <types.h>
  24. #include <cardserv.h>
  25. #include <sockserv.h>
  26. #include <sockpd.h>
  27. #include <memory.h>
  28. //#include <pc.h>
  30. #include "S2440.H"
  31. #include "pd6710.h"
  34. //#define FORCE_POLLING 1
  36. //
  37. // CEPC PCMCIA Socket Services Socket APIs:
  38. //    PDCardInquireSocket
  39. //    PDCardGetSocket
  40. //    PDCardSetSocket
  41. //    PDCardInquireAdapter
  42. //
  44. #define NUM_SOCKETS 1
  45. #define NUM_POWER_ENTRIES 4
  46. #define VCC_DEFAULT_INDEX 2
  50. //
  51. // @doc DRIVERS
  52. //
  54. PDCARD_ADAPTER_INFO v_AdapterInfo = {
  55. 1, // memory granularity (for production platforms, this should be 1)
  56. 0, // adapter capabilities
  57. 8, // cache line size in 32-bit words
  58. NUM_POWER_ENTRIES
  59. };
  61. PDCARD_POWER_ENTRY v_PowerEntries[NUM_POWER_ENTRIES] = {
  62. { 0,    PWR_SUPPLY_VCC | PWR_SUPPLY_VPP1 | PWR_SUPPLY_VPP2 },
  63. { 33,   PWR_SUPPLY_VCC },
  64. { 50,   PWR_SUPPLY_VCC | PWR_SUPPLY_VPP1 | PWR_SUPPLY_VPP2 },
  65. { 120,  PWR_SUPPLY_VPP1 | PWR_SUPPLY_VPP2 }
  66. };
  68. PDCARD_SOCKET_STATE v_SockState[NUM_SOCKETS] = {
  69. {
  70. SOCK_CAP_IO,
  71. #ifdef FORCE_POLLING
  72. EVENT_MASK_BATTERY_DEAD|EVENT_MASK_BATTERY_LOW|
  73. #else
  74. EVENT_MASK_BATTERY_DEAD|EVENT_MASK_BATTERY_LOW|EVENT_MASK_CARD_DETECT|
  75. #endif
  76.         EVENT_MASK_WRITE_PROTECT, // status change interrupt mask
  77. 0, // present socket state
  78. 0, // control and indicators
  79. 0, // interface type
  80. 0, // Vcc
  81. 0, // Vpp1
  82. 0 // Vpp2
  83. },
  84. };
  86. //volatile PUCHAR g_PCICIndex;
  87. //volatile PUCHAR g_PCICData;
  88. //CRITICAL_SECTION g_PCIC_Crit;
  89. extern volatile PUCHAR g_PCICIndex;
  90. extern volatile PUCHAR g_PCICData;
  91. extern CRITICAL_SECTION g_PCIC_Crit;
  93. extern DWORD g_Irq; // PCMCIA IRQ set in init.c
  95. //extern volatile int BackupFlag;
  96. //extern void PD_DataBackup();
  97. extern void PD_DataRestore();
  99. //
  100. // Set the socket controller registers to initial state with no card inserted.
  101. //
  102. VOID InitSocketNoCard(UINT32 uSocket, BOOL bUserMode)
  103. {
  104. UCHAR tmp;
  105. UINT32 status; 
  106. UINT32 i; 
  107. UINT32 first, last;
  108. PDCARD_WINDOW_STATE WinState;
  110. DEBUGMSG (1,(TEXT("++InitSocketNoCard #%xnr"), uSocket));
  111. //RETAILMSG(1, (TEXT("PDD:SOCKET.C:InitSocketNoCard()rn")));
  113. PCICIndex(uSocket, REG_POWER_CONTROL);
  114. PCICDataWrite(PWR_AUTO_POWER);
  116. // PD6710 specific code to enable management interrupt(routed to -INTR)
  118. tmp = CFG_CARD_DETECT_ENABLE;
  119. PCICIndex(uSocket, REG_STATUS_CHANGE_INT_CONFIG);
  120. PCICDataWrite(tmp);
  122. // Enable Manage Interrupt
  123. PCICIndex(0, REG_INTERRUPT_AND_GENERAL_CONTROL);
  124. tmp = PCICDataRead();
  125. tmp |= INT_ENABLE_MANAGE_INT;
  126. PCICDataWrite(tmp);
  128. //
  129. // Disable the I/O windows
  130. //
  131. first = (uSocket == 0) ? SOCKET0_FIRST_IO_WINDOW : SOCKET1_FIRST_IO_WINDOW;
  132. last = first + 2;
  133. for (i = first; i < last; i++) 
  134. {
  135. status = PDCardGetWindow(i, &WinState);
  136. if (status == CERR_SUCCESS) 
  137. {
  138. WinState.fState &= ~WIN_STATE_ENABLED;
  139. WinState.uOffset = 0;
  140. // set the high bit in the window index if we are in kernel-mode
  141. PDCardSetWindow(bUserMode ? i : (i|ADP_STATE_KERNEL_MODE), &WinState);
  142. }
  143. }
  144. DEBUGMSG (1,(TEXT("--InitSocketNoCardnr")));
  145. }
  147. //
  148. // PDCardGetSocket
  149. //
  150. // @func    STATUS | PDCardGetSocket | Get the socket state of the specified socket.
  151. // @rdesc   Returns one of the CERR_* return codes in cardserv.h.
  152. //
  153. // @comm    This function reads the specified socket's state and returns it in
  154. //          the PDCARD_SOCKET_STATE structure.
  155. //
  156. STATUS
  157. PDCardGetSocket(UINT32 uSocket, // @parm Socket number (first socket is 0)
  158. PPDCARD_SOCKET_STATE pState) // @parm Pointer to PDCARD_SOCKET_STATE structure
  159. {
  160. UINT8 tmp;
  161. PPDCARD_SOCKET_STATE pPDDState;
  163. DEBUGMSG(1,(TEXT("+++PDCardGetSocketrn")));
  164. if (uSocket >= NUM_SOCKETS) 
  165. {
  166. return CERR_BAD_SOCKET;
  167. }
  169. pPDDState = &v_SockState[uSocket];
  170.     
  171. EnterCriticalSection(&g_PCIC_Crit);
  173. pPDDState->fNotifyEvents = 0;        // Start off with nothing
  175. //
  176. // First acknowledge any status change interrupts
  177. //
  178. PCICIndex(uSocket, REG_CARD_STATUS_CHANGE);
  179. tmp = PCICDataRead();
  181. DEBUGMSG(ZONE_PDD, (TEXT("PDCardGetSocket(%d) REG_CARD_STATUS_CHANGE(0x%x) = 0x%xrn"),
  182.      uSocket, REG_CARD_STATUS_CHANGE, tmp));
  184. //
  185. // Figure out the socket state
  186. //
  187. PCICIndex(uSocket, REG_INTERFACE_STATUS);
  188. tmp = PCICDataRead();
  190. if ((tmp & (STS_CD1|STS_CD2)) == (STS_CD1|STS_CD2)) 
  191. {
  192. pPDDState->fNotifyEvents |= EVENT_MASK_CARD_DETECT;
  193. } else {
  194. InitSocketNoCard(uSocket, FALSE);
  195. goto pcgs_exit;
  196. }
  198. #ifdef NOT_IMPLEMENTED
  199. switch (tmp & (STS_BVD1|STS_BVD2)) 
  200. {
  201. case STS_BVD1:
  202. pPDDState->fNotifyEvents |= EVENT_MASK_BATTERY_LOW;
  203. DEBUGMSG(ZONE_PDD, (TEXT("PDCardGetSocket(%d) BATTERY_LOWrn"), uSocket));
  204. break;
  206. case STS_BVD2:
  207. case 0:
  208. DEBUGMSG(ZONE_PDD, (TEXT("PDCardGetSocket(%d) BATTERY_DEADrn"), uSocket));
  209. pPDDState->fNotifyEvents |= EVENT_MASK_BATTERY_DEAD;
  210. break;
  211. }
  212. #endif NOT_IMPLEMENTED
  214. if (tmp & STS_WRITE_PROTECT) 
  215. {
  216. DEBUGMSG(ZONE_PDD, (TEXT("PDCardGetSocket(%d) WRITE_PROTECTrn"), uSocket));
  217. pPDDState->fNotifyEvents |= EVENT_MASK_WRITE_PROTECT;
  218. }
  221. if (tmp & STS_CARD_READY) 
  222. {
  223. DEBUGMSG(ZONE_PDD, (TEXT("PDCardGetSocket(%d) CARD_READYrn"), uSocket));
  224. pPDDState->fNotifyEvents |= EVENT_MASK_CARD_READY;
  225. }
  227. DEBUGMSG(1,(TEXT("---PDCardGetSocketrn")));
  229. pcgs_exit:
  230. memcpy(pState, pPDDState, sizeof(PDCARD_SOCKET_STATE));
  231. LeaveCriticalSection(&g_PCIC_Crit);
  232. return CERR_SUCCESS;
  233. }   // PDDCardGetSocket
  236. //
  237. // PDCardSetSocket
  238. //
  239. // @func    STATUS | PDCardSetSocket | Set the socket state of the specified socket.
  240. // @rdesc   Returns one of the CERR_* return codes in cardserv.h.
  241. //
  242. // @comm    This function sets the specified socket's state and adjusts the socket
  243. //          controller appropriately.
  244. //          PDCardGetSocketState will usually be called first and adjustments will
  245. //          be made to the PDCARD_SOCKET_STATE structure before PDCardSetSocketState
  246. //          is called.  This avoids duplicated socket state on different layers and
  247. //          it avoids unintentionally setting socket parameters.
  248. //
  249. // @xref <f PDCardGetSocketState>
  250. //
  251. STATUS
  252. PDCardSetSocket(UINT32 uSocket, // @parm Socket number (first socket is 0)
  253. PPDCARD_SOCKET_STATE pState) // @parm Pointer to PDCARD_SOCKET_STATE structure
  254. {
  255. UINT8 tmp, intctl;
  256. PPDCARD_SOCKET_STATE pPDDState;
  257. STATUS ret;
  258. int t;
  260. DEBUGMSG(1, (TEXT("PDCardSetSocket(%d) enteredrn"), uSocket));
  262. if (uSocket >= NUM_SOCKETS) 
  263. {
  264. ret = CERR_BAD_SOCKET;
  265. goto pcss_fail;
  266. }
  268. //
  269. // Check socket power level indexes
  270. //
  271. if ((pState->fVcc & SOCK_VCC_LEVEL_MASK) >= NUM_POWER_ENTRIES ||
  272. !(v_PowerEntries[pState->fVcc & SOCK_VCC_LEVEL_MASK].fSupply & PWR_SUPPLY_VCC)) 
  273. {
  274. ret = CERR_BAD_VCC;
  275. goto pcss_fail;
  276. }
  277. if (pState->uVpp1 >= NUM_POWER_ENTRIES || pState->uVpp2 >= NUM_POWER_ENTRIES ||
  278. !(v_PowerEntries[pState->uVpp1].fSupply & PWR_SUPPLY_VPP1) ||
  279. !(v_PowerEntries[pState->uVpp2].fSupply & PWR_SUPPLY_VPP2)) 
  280. {
  281. ret = CERR_BAD_VPP;
  282. goto pcss_fail;
  283. }
  285. EnterCriticalSection(&g_PCIC_Crit);
  287. PCICIndex(uSocket, REG_INTERFACE_STATUS);
  288. tmp = PCICDataRead();
  290. if ((tmp & (STS_CD1|STS_CD2)) != (STS_CD1|STS_CD2)) 
  291. {
  292. DEBUGMSG(ZONE_PDD, (TEXT("PDCardSetSocket(%d) No card insertedrn"), uSocket));
  293. InitSocketNoCard(uSocket, FALSE);
  294. goto pcss_exit;
  295. }
  297. pPDDState = &v_SockState[uSocket];
  299. //
  300. // Set the status change interrupt sources
  301. //
  302. #if 1
  303. tmp = (UCHAR)(g_Irq << 4); // CFG_MANAGEMENT_IRQ_BIT* bits will be set
  304. #else
  305. tmp =0;
  306. #endif
  308. if (pState->fInterruptEvents & EVENT_MASK_CARD_DETECT) 
  309. {
  310. tmp |= CFG_CARD_DETECT_ENABLE;
  311. }
  312. if (pState->fInterruptEvents & EVENT_MASK_BATTERY_DEAD) 
  313. {
  314. tmp |= CFG_BATTERY_DEAD_ENABLE;
  315. }
  316. if (pState->fInterruptEvents & EVENT_MASK_BATTERY_LOW) 
  317. {
  318. tmp |= CFG_BATTERY_WARNING_ENABLE;
  319. }
  320. if (pState->fIREQRouting & SOCK_IREQ_ENABLE) 
  321. {
  322. // tmp |= CFG_READY_ENABLE;
  323. } 
  324. PCICIndex(uSocket, REG_STATUS_CHANGE_INT_CONFIG);
  325. PCICDataWrite(tmp);
  326. DEBUGMSG(ZONE_PDD, (TEXT("PDCardSetSocket(%d) REG_STATUS_CHANGE_INT_CONFIG(0x%x) = 0x%xrn"),
  327. uSocket, REG_STATUS_CHANGE_INT_CONFIG, tmp));
  329. #if 1
  330. // PD6710 specific code to enable management interrupt(routed to -INTR)
  331. PCICIndex(0, REG_INTERRUPT_AND_GENERAL_CONTROL);
  332. tmp = PCICDataRead();
  333. tmp |= INT_ENABLE_MANAGE_INT;
  334. PCICDataWrite(tmp);
  335. #endif
  337. //
  338. // Enable or disable IREQ interrupts
  339. //
  340. PCICIndex(uSocket, REG_INTERRUPT_AND_GENERAL_CONTROL);
  341. tmp = PCICDataRead();
  342. tmp &= (UCHAR)~g_Irq; // Turn off INT_IRQ_BIT* bits
  343. if (pState->fIREQRouting & SOCK_IREQ_ENABLE) 
  344. {
  345. DEBUGMSG(1, (TEXT("Enable IREQ interrupts #%xrn"), g_Irq));
  346. tmp |= ((UCHAR)g_Irq)|INT_CARD_NOT_RESET; // Turn on INT_IRQ_BIT* bits
  347. } else {
  348. tmp |= INT_CARD_NOT_RESET;
  349. }
  350. PCICDataWrite(tmp);
  352. DEBUGMSG(1, (TEXT("PDCardSetSocket voltage = %drn"),
  353. v_PowerEntries[pState->fVcc & SOCK_VCC_LEVEL_MASK].uPowerLevel));
  354. // ignore Vpp 
  355. if ((pState->fVcc & SOCK_VCC_LEVEL_MASK) != (pPDDState->fVcc & SOCK_VCC_LEVEL_MASK)) 
  356. {
  357. //
  358. // Set socket power as requested.
  359. //
  360. switch (v_PowerEntries[pState->fVcc & SOCK_VCC_LEVEL_MASK].uPowerLevel) 
  361. {
  362. case 0:
  363. PCICIndex(uSocket, REG_POWER_CONTROL);
  364. PCICDataWrite(0);
  365. goto pcss_exit; // this is what it used to do so I won't change it
  366. case 33:
  367. PCICIndex(uSocket, 0x16);//REG_MISC_CONTROL_1);
  368. PCICDataWrite(0x02);  // enable 3.3V
  369. DEBUGMSG(1, (TEXT("set to 3.3Vrn")));
  370. break;
  371. case 50:
  372. PCICIndex(uSocket, 0x16);//REG_MISC_CONTROL_1);
  373. if (PCICDataRead() & 0x01) // i.e., if we detect a 5V card:
  374. {
  375. PCICDataWrite(0x00);  // disable 3.3V (i.e., use 5V)
  376. DEBUGMSG(1, (TEXT("set to 5Vrn")));
  377. }
  378. else
  379. {
  380. // this is a 3.3V ONLY card and mustn't be powered at 5V
  381. // so ignore the command; we'd assert here save that card
  382. // services will attempt to apply 5V to read the CIS.
  383. PCICDataWrite(0x02);  // enable 3.3V
  384.   DEBUGMSG(1, (TEXT("set to 3.3V[5V]rn")));
  385. }
  386. break;
  387. default:
  388. ASSERT(0); // this ought to have been caught above
  389. }
  391. // LKY 2001.12
  392. Sleep(100);
  394. //
  395. // Assert RESET
  396. //
  397. PCICIndex(uSocket, REG_INTERRUPT_AND_GENERAL_CONTROL);
  398. intctl = PCICDataRead();
  399. PCICDataWrite((UINT8)(intctl & ~ INT_CARD_NOT_RESET));
  401. Sleep(20);
  403. PCICIndex(uSocket, REG_POWER_CONTROL);
  405. PCICDataWrite(PWR_OUTPUT_ENABLE | PWR_AUTO_POWER | PWR_VPP2_BIT0 | PWR_VPP1_BIT0);
  406. //
  407. // Power the socket
  408. //
  409. PCICIndex(uSocket, REG_POWER_CONTROL);
  410. PCICDataWrite(PWR_OUTPUT_ENABLE | PWR_AUTO_POWER | PWR_VCC_POWER | PWR_VPP2_BIT0 | PWR_VPP1_BIT0);
  412. Sleep(20);
  414. //
  415. // Deassert RESET
  416. //
  417. PCICIndex(uSocket, REG_INTERRUPT_AND_GENERAL_CONTROL);
  418. intctl = PCICDataRead();
  419. PCICDataWrite((UINT8)(intctl | INT_CARD_NOT_RESET));
  421. Sleep(20);
  422.     
  423. //
  424. // Allow the card 2 seconds to assert RDY
  425. //
  426. PCICIndex(uSocket, REG_INTERFACE_STATUS);
  427. for (t = 0; t < PCMCIA_MAX_RDY_WAIT_TIME; t += PCMCIA_RDY_POLL_INT) 
  428. {
  429. tmp = PCICDataRead();
  430. if (tmp & STS_CARD_READY) 
  431. {
  432. DEBUGMSG(ZONE_PDD, (TEXT("PDCardSetSocket: Card in socket %d RDY after %dmsrn"),
  433. uSocket, t));
  434. break;
  435. }
  436. Sleep(PCMCIA_RDY_POLL_INT);
  437. }
  439. if (t >= PCMCIA_MAX_RDY_WAIT_TIME) 
  440. {
  441. DEBUGMSG(ZONE_PDD, (TEXT("PDCardSetSocket: CARD IN SOCKET %d NOT RDY AFTER %dmsrn"),
  442. uSocket, t));
  443. }
  445. // LKY 2001.12    
  446. Sleep(300); // necessary for CF cards?
  448. }
  450. if (pState->fIREQRouting & SOCK_IREQ_ENABLE) 
  451. DumpSocketRegisters(uSocket);
  453. *pPDDState = *pState;
  455. pcss_exit:
  456. #ifdef DEBUG
  457. DeltaSocketRegisters(uSocket);
  458. #endif
  459. LeaveCriticalSection(&g_PCIC_Crit);
  460. return CERR_SUCCESS;
  462. pcss_fail:
  463. DEBUGMSG(ZONE_PDD, (TEXT("PDCardSetSocket(%d) returning %drn"), uSocket, ret));
  464. return ret;
  465. }   // PDCardSetSocket
  468. //
  469. // PDCardInquireAdapter
  470. //
  471. // @func    STATUS | PDCardInquireAdapter | Returns the socket controller's characteristics
  472. //                                          and capabilities.
  473. // @rdesc   Returns one of the CERR_* return codes in cardserv.h.
  474. //
  475. STATUS
  476. PDCardInquireAdapter( PPDCARD_ADAPTER_INFO pAdapterInfo ) // @parm Pointer to PDCARD_ADAPTER_INFO structure.
  477. {
  478. if (pAdapterInfo->uPowerEntries < NUM_POWER_ENTRIES) 
  479. {
  480. pAdapterInfo->uPowerEntries = NUM_POWER_ENTRIES;
  481. return CERR_BAD_ARG_LENGTH;
  482. }
  484. // Copy the adapter info
  485. memcpy(pAdapterInfo, &v_AdapterInfo, sizeof(PDCARD_ADAPTER_INFO));
  486. pAdapterInfo = (PPDCARD_ADAPTER_INFO)(((UINT)pAdapterInfo) + sizeof(PDCARD_ADAPTER_INFO));
  488. // Copy the power entries at the end
  489. memcpy(pAdapterInfo, &v_PowerEntries, sizeof(v_PowerEntries));
  490. return CERR_SUCCESS;
  491. }
  493. //
  494. // Set up socket's initial window registers and interrupts
  495. //
  496. VOID
  497. InitSocket( UINT32 uSocket )
  498. {
  499. PDCARD_WINDOW_STATE WinState;
  500. PDCARD_SOCKET_STATE SockState;
  501. UINT32 status; 
  502. UINT32 i; 
  503. UINT32 first, last;
  505. DEBUGMSG(1, (TEXT(":::PCMCIA:InitSocketrn")));
  507. //
  508. // Set the socket to detect status change events
  509. //
  510. SockState = v_SockState[uSocket];
  511. SockState.fInterruptEvents = EVENT_MASK_CARD_DETECT|
  512.                                  EVENT_MASK_CARD_LOCK|
  513.                                  EVENT_MASK_BATTERY_LOW|
  514.                                  EVENT_MASK_BATTERY_DEAD|
  515.                                  EVENT_MASK_WRITE_PROTECT;
  516. #if 0
  517. SockState.fInterfaceType = CFG_IFACE_MEMORY;
  518. SockState.fIREQRouting = 0;
  519. #else
  520. SockState.fInterfaceType = CFG_IFACE_MEMORY_IO; // IO/MEM Interface, 2000.4.26, LKY
  521. SockState.fIREQRouting = 1;  // IRQRouting enabled, 2000.4.26, LKY
  522. #endif
  524. SockState.fVcc = VCC_DEFAULT_INDEX;
  525. PDCardSetSocket(uSocket, &SockState);
  527. //
  528. // Initially enable only the memory windows
  529. //
  530. first = (uSocket == 0) ? 0 : SOCKET1_FIRST_MEMORY_WINDOW;
  531. last = first + SOCKET1_FIRST_MEMORY_WINDOW;
  532. for (i = first; i < last; i++) 
  533. {
  534. status = PDCardGetWindow(i, &WinState);
  535. if (status == CERR_SUCCESS) 
  536. {
  537. WinState.fState |= WIN_STATE_ATTRIBUTE|WIN_STATE_ENABLED;
  538. PDCardSetWindow(i, &WinState);
  539. }
  540. }
  541. }   // InitSocket
  543. //
  544. // PDCardResetSocket
  545. //
  546. // @func    STATUS | PDCardResetSocket | Resets the specified socket.
  547. // @rdesc   Returns one of the CERR_* return codes in cardserv.h.
  548. //
  549. STATUS
  550. PDCardResetSocket( UINT32 uSocket ) // @parm Socket number (first socket is 0)
  551. {
  552. UINT8 tmp;
  553. UINT8 intctl;
  554. UINT32 t; 
  556. DEBUGMSG(1, (TEXT("++PDCardResetSocketrn")));
  558. if (uSocket >= NUM_SOCKETS) 
  559. {
  560. return CERR_BAD_SOCKET;
  561. }
  563. EnterCriticalSection(&g_PCIC_Crit);
  565. PCICIndex(uSocket, REG_INTERFACE_STATUS);
  566. tmp = PCICDataRead();
  568. //
  569. // Power off the socket
  570. //
  571. PCICIndex(uSocket, REG_POWER_CONTROL);
  572. PCICDataWrite(0);
  574. if ((tmp & (STS_CD1|STS_CD2)) != (STS_CD1|STS_CD2)) 
  575. {
  576. //
  577. // Leave it powered off if no card in it.
  578. //
  579. InitSocketNoCard(uSocket, FALSE);
  580. LeaveCriticalSection(&g_PCIC_Crit);
  581. return CERR_NO_CARD;
  582. }
  584. //
  585. // Tri-state outputs for 310ms
  586. //
  587. Sleep(310);
  589. //
  590. // Assert RESET
  591. //
  592. PCICIndex(uSocket, REG_INTERRUPT_AND_GENERAL_CONTROL);
  593. intctl = PCICDataRead();
  594. PCICDataWrite(0);
  596. //
  597. // Power the socket
  598. //
  599. PCICIndex(uSocket, REG_POWER_CONTROL);
  600. PCICDataWrite(PWR_OUTPUT_ENABLE|PWR_AUTO_POWER|PWR_VCC_POWER);
  602. Sleep(20);
  604. //
  605. // Deassert RESET
  606. //
  607. PCICIndex(uSocket, REG_INTERRUPT_AND_GENERAL_CONTROL);
  608. PCICDataWrite(INT_CARD_NOT_RESET);
  610. //
  611. // Allow 20ms for card to assert RDY
  612. //
  613. Sleep(20);
  615. //
  616. // Allow the card 2 seconds to assert RDY
  617. //
  618. PCICIndex(uSocket, REG_INTERFACE_STATUS);
  619. for (t = 0; t < PCMCIA_MAX_RDY_WAIT_TIME; t += PCMCIA_RDY_POLL_INT) 
  620. {
  621. tmp = PCICDataRead();
  622. if (tmp & STS_CARD_READY) 
  623. {
  624. DEBUGMSG(ZONE_PDD, (TEXT("PDCardResetSocket: Card in socket %d RDY after %dmsrn"),uSocket, t));
  625. break;
  626. }
  627. Sleep(PCMCIA_RDY_POLL_INT);
  628. }
  630. if (t >= PCMCIA_MAX_RDY_WAIT_TIME) 
  631. {
  632. DEBUGMSG(ZONE_PDD, (TEXT("PDCardResetSocket: CARD IN SOCKET %d NOT RDY AFTER %dmsrn"),uSocket, t));
  633. }
  635. InitSocket(uSocket);
  637. // LKY 2001.12
  638. Sleep(20);
  640. PCICIndex(uSocket, REG_INTERRUPT_AND_GENERAL_CONTROL);
  641. intctl |= INT_CARD_NOT_RESET;
  642. PCICDataWrite(intctl);
  644. // LKY 2001.12
  645. Sleep(20);
  647. #if 0
  648. // Enable Manage Interrupt
  649. PCICIndex(0, REG_INTERRUPT_AND_GENERAL_CONTROL);
  650. intctl = PCICDataRead();
  651. intctl |= INT_ENABLE_MANAGE_INT;
  652. PCICDataWrite(intctl);
  653. #endif
  655. LeaveCriticalSection(&g_PCIC_Crit);
  656.     
  657. DEBUGMSG(1, (TEXT("--PDCardResetSocketrn")));
  658.     
  659. return CERR_SUCCESS;
  660. }   // PDCardResetSocket
  662. //
  663. // PDCardGetAdapter
  664. //
  665. // @func    STATUS | PDCardGetAdapter | Returns power save mode status and capabilities
  666. // @rdesc   Returns one of the CERR_* return codes in cardserv.h
  667. //
  669. STATUS
  670. PDCardGetAdapter( UINT32 uSocket,
  671. PPDCARD_ADAPTER_STATE pState     )
  672. {
  674. UINT8 tmp;
  675. BOOL bUserMode;
  677. if (uSocket >= NUM_SOCKETS) 
  678. {
  679. return CERR_BAD_SOCKET;
  680. }
  682. if (pState == NULL) 
  683. {
  684. return CERR_BAD_ARGS;
  685. }
  687. bUserMode = (*pState & ADP_STATE_KERNEL_MODE) ? FALSE : TRUE;
  689. DEBUGMSG(1, (TEXT("PDCardGetAdapter enteredrn")));
  691. *pState = 0;
  692. if (bUserMode) 
  693. {
  694. EnterCriticalSection(&g_PCIC_Crit);
  695. }
  697. PCICIndex(uSocket, REG_POWER_CONTROL);
  698. tmp = PCICDataRead();
  699. if (!(tmp & PWR_OUTPUT_ENABLE)) 
  700. {
  701. *pState |= ADP_STATE_POWERDOWN;
  702. }
  704. if (bUserMode) 
  705. {
  706. LeaveCriticalSection(&g_PCIC_Crit);
  707. }
  709. DEBUGMSG(1, (TEXT("PDCardGetAdapter donern")));
  710. return CERR_SUCCESS;
  712. }
  715. //
  716. // PDCardSetAdapter
  717. //
  718. // @func    STATUS | PDCardSetAdapter | Sets power save mode status and capabilities
  719. // @rdesc   Returns one of the CERR_* return codes in cardserv.h
  720. //
  721. STATUS
  722. PDCardSetAdapter( UINT32 uSocket,
  723. PPDCARD_ADAPTER_STATE pState )
  724. {
  725. BOOL bUserMode;
  726. // UINT32 bSoc;
  728. if (uSocket >= NUM_SOCKETS) 
  729. {
  730. return CERR_BAD_SOCKET;
  731. }
  733. if (pState == NULL) 
  734. {
  735. return CERR_BAD_ARGS;
  736. }
  738. bUserMode = (*pState & ADP_STATE_KERNEL_MODE) ? FALSE : TRUE;
  740. DEBUGMSG(1, (TEXT("PDCardSetAdapter enteredrn")));
  742. if (bUserMode) 
  743. {
  744. EnterCriticalSection(&g_PCIC_Crit);
  745. }
  747. //
  748. // The socket controller will automatically power up when a card is inserted
  749. // by shlim
  750. // if (*pState & (ADP_STATE_POWERDOWN|ADP_STATE_POWEROFF)) 
  751. if (*pState & (ADP_STATE_POWEROFF | ADP_STATE_POWERDOWN)) 
  752. {
  753. //RETAILMSG(1, (TEXT("---- (ADP_STATE_POWEROFF | ADP_STATE_POWERDOWN)rn")));
  754. // Power down the socket
  755. //RETAILMSG(1, (TEXT("PD_DataRestore()rn")));
  756. PD_DataRestore();
  757. InitSocketNoCard(uSocket, bUserMode);
  758. }else {
  759. //RETAILMSG(1, (TEXT("---! (ADP_STATE_POWEROFF | ADP_STATE_POWERDOWN)rn")));
  760. //
  761. // Power up the socket
  762. //
  763. //RETAILMSG(1, (TEXT("PD_DataBackup()rn")));
  764. //PD_DataBackup();
  765. //InitSocketNoCard(uSocket, bUserMode);
  766. }
  768. if (bUserMode) 
  769. {
  770. LeaveCriticalSection(&g_PCIC_Crit);
  771. }
  773. return CERR_SUCCESS;
  774. }