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

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

Windows CE

开发平台：

Windows_Unix

SER2440_HW.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-2000 Microsoft Corporation.  All rights reserved.
  7. Copyright (c) 2001-2002 SAMSUNG Electronics Corporation.  All rights reserved.
  9. Author hmseo@sec.samsung.com (SAMSUNG Electronics)
  11. Module Name:  
  13. ser2440_hw.c
  15. Abstract:  
  17.     This file implements the standard device specific functions for a S3C2440
  18.     based serial device.
  20. Functions:
  21. SER_RegAlloc
  22. SER_VirtualAlloc
  23. SER_VirtualFree
  24. ReadLSR
  25. ReadMSR
  26. ShowSerialRegisters
  27. ClearPendingInts
  28. S2440_SetIrDAIOP
  29. S2440_SetSerialIOP
  30. S2440_SetIOP
  31. SL_Open
  32. SL_Close
  33. SL_Init
  34. SL_PostInit
  35. SL_Deinit
  36. SL_ClearDTR
  37. SL_SetDTR
  38. SL_ClearRTS
  39. SL_SetRTS
  40. SL_ClearBreak
  41. SL_SetBreak
  42. SetBaudRate
  43. SL_SetBaudRate
  44. SL_SetByteSize
  45. SL_SetParity
  46. SL_SetStopBits
  47. SL_GetRxBufferSize
  48. SL_GetRxStart
  49. SL_GetInterruptType
  50. SL_RxIntr
  51. SL_PutBytes
  52. SL_TxIntr
  53. SL_TxIntrEx
  54. SL_LineIntr
  55. SL_OtherIntr
  56. SL_ModemIntr
  57. SL_GetStatus
  58. SL_Reset
  59. SL_GetModemStatus
  60. SL_PurgeComm
  61. SL_XmitComChar
  62. SL_PowerOff
  63. SL_PowerOn
  64. SL_SetDCB
  65. SL_SetCommTimeouts
  66. SL_Ioctl
  68. --*/
  70. #define DEBUGMODE 0
  71. #define ZONE_FUNCTION 1
  72. #define USERDBG 1
  73. #define ZONE_WRITE 1
  75. #include <windows.h>
  76. #include <types.h>
  77. #include <ceddk.h>
  78. #include <memory.h>
  79. #include <serhw.h>
  80. #include <ser16550.h>
  81. #include <hw16550.h>
  82. #include <nkintr.h>
  83. #include <devload.h>
  84. #include <windev.h>
  85. #include <notify.h>
  87. #include <pm.h>
  88. #include <excpt.h>
  90. #include "pmplatform.h"
  91. #include "S2440.h"
  92. #include "ser2440.h"
  94. #define PUBLIC
  95. #define PRIVATE static
  97. PRIVATE volatile IOPreg   * v_pIOPregs;
  98. PRIVATE volatile UART0reg * v_pUART0regs;
  99. PRIVATE volatile UART1reg * v_pUART1regs;
  100. PRIVATE volatile UART2reg * v_pUART2regs;
  101. PRIVATE volatile INTreg   * v_pINTregs;
  102. PRIVATE volatile PWMreg   * v_pPWMregs;
  104. VOID SER_VirtualFree(VOID);
  105. BOOL SER_VirtualAlloc(VOID);
  107. VOID ReadLSR(PVOID pHead);
  108. VOID ReadMSR(PVOID pHead);
  110. BOOL SL_SetByteSize(PVOID pHead, ULONG ByteSize);
  111. BOOL SL_SetStopBits(PVOID pHead, ULONG StopBits);
  112. BOOL SL_SetParity(PVOID pHead, ULONG Parity);
  113. BOOL SerPowerOn(PVOID   pHead);
  114. BOOL SerPowerOff(PVOID   pHead);
  116. #define EXCEPTION_ACCESS_VIOLATION STATUS_ACCESS_VIOLATION 
  118. PRIVATE PVOID
  119. SER_RegAlloc(PVOID addr, INT sz)
  120. {
  121. PVOID reg;
  123. reg = (PVOID)VirtualAlloc(0, sz, MEM_RESERVE, PAGE_NOACCESS);
  125. if (reg)
  126. {
  127. if (!VirtualCopy(reg, addr, sz, PAGE_READWRITE | PAGE_NOCACHE )) 
  128. {
  129. VirtualFree(reg, sz, MEM_RELEASE);
  130. reg = NULL;
  131. }
  132. }
  134. return reg;
  135. }
  138. PRIVATE BOOL
  139. SER_VirtualAlloc(VOID)
  140. {
  141. BOOL r = FALSE;
  143.     RETAILMSG(DEBUGMODE,(TEXT("::: SER_VirtualAlloc()rn")));
  145. do
  146. {
  147. v_pIOPregs = (volatile IOPreg *)SER_RegAlloc((PVOID)IOP_BASE, sizeof(IOPreg));
  148. if (v_pIOPregs == NULL) 
  149. {
  150. ERRORMSG(1,(TEXT("For IOPreg: VirtualAlloc failed!rn")));
  151. break;
  152. }
  154. v_pUART0regs = (volatile UART0reg *)SER_RegAlloc((PVOID)UART0_BASE, sizeof(UART0reg));
  155. if (v_pUART0regs == NULL) 
  156. {
  157.      ERRORMSG(1,(TEXT("For UART0reg: VirtualAlloc failed!rn")));
  158.     break;
  159. }
  161. v_pUART1regs = (volatile UART1reg *)SER_RegAlloc((PVOID)UART1_BASE, sizeof(UART1reg));
  162. if (v_pUART1regs == NULL) 
  163. {
  164.      ERRORMSG(1,(TEXT("For UART1reg: VirtualAlloc failed!rn")));
  165.     break;
  166. }
  168. v_pUART2regs = (volatile UART2reg *)SER_RegAlloc((PVOID)UART2_BASE, sizeof(UART2reg));
  169. if (v_pUART2regs == NULL) 
  170. {
  171.      ERRORMSG(1,(TEXT("For UART2reg: VirtualAlloc failed!rn")));
  172.     break;
  173. }
  175. v_pINTregs = (volatile INTreg *)SER_RegAlloc((PVOID)INT_BASE, sizeof(INTreg));
  176. if (v_pINTregs == NULL) 
  177. {
  178.      ERRORMSG(1,(TEXT("For INTregs: VirtualAlloc failed!rn")));
  179.     break;
  180. }
  182. v_pPWMregs = (volatile PWMreg *)SER_RegAlloc((PVOID)PWM_BASE, sizeof(PWMreg));
  183. if (v_pPWMregs == NULL) 
  184. {
  185.      ERRORMSG(1,(TEXT("For PWMregs: VirtualAlloc failed!rn")));
  186.     break;
  187. }
  189. r = TRUE;
  190. } while (0);
  192. if (!r)
  193. {
  194. SER_VirtualFree();
  196. RETAILMSG(DEBUGMODE,(TEXT("::: SER_VirtualAlloc() - Failrn")));
  197. }
  198. else
  199. {
  200. RETAILMSG(DEBUGMODE,(TEXT("::: SER_VirtualAlloc() - Successrn")));
  201. }
  204. return r;
  205. }
  207. PRIVATE void
  208. SER_VirtualFree(VOID)
  209. {
  210.     RETAILMSG(DEBUGMODE,(TEXT("::: SER_VirtualFree()rn")));
  212. if (v_pIOPregs)
  213.     {
  214.         VirtualFree((PVOID)v_pIOPregs, sizeof(IOPreg), MEM_RELEASE);
  215.         v_pIOPregs = NULL;
  216.     }
  217.     if (v_pUART0regs)
  218.     {   
  219.         VirtualFree((PVOID)v_pUART0regs, sizeof(UART0reg), MEM_RELEASE);
  220.         v_pUART0regs = NULL;
  221.     } 
  222.     if (v_pUART1regs)
  223.     {   
  224.         VirtualFree((PVOID)v_pUART1regs, sizeof(UART1reg), MEM_RELEASE);
  225.         v_pUART1regs = NULL;
  226.     } 
  227.     if (v_pUART2regs)
  228.     {   
  229.         VirtualFree((PVOID)v_pUART2regs, sizeof(UART2reg), MEM_RELEASE);
  230.         v_pUART2regs = NULL;
  231.     } 
  232.     if (v_pINTregs)
  233.     {   
  234.         VirtualFree((PVOID)v_pINTregs, sizeof(INTreg), MEM_RELEASE);
  235.         v_pINTregs = NULL;
  236.     } 
  237.     if (v_pPWMregs)
  238.     {   
  239.         VirtualFree((PVOID)v_pPWMregs, sizeof(INTreg), MEM_RELEASE);
  240.         v_pPWMregs = NULL;
  241.     } 
  242. }
  244. //
  245. // Reading the LSR clears most of its bits.  So, we provide this wrapper,
  246. // which reads the register, records any interesting values, and
  247. // stores the current LSR contents in the shadow register.
  248. //
  249. //__inline
  250. VOID
  251. ReadLSR(PVOID pHead)
  252. {
  253. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  254. ULONG LineEvents             = 0;
  255. ULONG LineStatus             = 0;
  256. UCHAR tmp;
  258. pHWHead->CommErrors = 0; // Clear old errors each time
  260. RETAILMSG(DEBUGMODE, (TEXT("ReadLSR rn")));
  262. try 
  263. {
  264. LineStatus = INREG(pHWHead,rUERSTAT);
  265. RETAILMSG(DEBUGMODE,  (TEXT("Line Status Register : 0x%xrn"), LineStatus));
  266. }
  268. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  269. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) 
  270. {
  271. // pHWHead->LSR = SERIAL_LSR_THRE;
  272. }
  274. if ( LineStatus & (COM2440_LSR_OE | COM2440_LSR_PE | COM2440_LSR_FE))
  275. {
  276. // Note: Its not wise to do debug msgs in here since they will
  277. // pretty much guarantee that the FIFO gets overrun.
  278. if ( LineStatus & COM2440_LSR_OE )
  279. {
  280. // When overrun error occurs, S2440 rURXH must be read.
  281. tmp = *(pHWHead->pUFRXH);
  282. pHWHead->DroppedBytes++;
  283. pHWHead->CommErrors |= CE_OVERRUN;
  284. LineEvents |= EV_ERR;
  285. }
  287. if ( LineStatus & COM2440_LSR_PE )
  288. {
  289. pHWHead->CommErrors |= CE_RXPARITY;
  290. LineEvents |= EV_ERR;
  291. }
  293. if ( LineStatus & COM2440_LSR_FE )
  294. {
  295. pHWHead->CommErrors |= CE_FRAME;
  296. LineEvents |= EV_ERR;
  297. }
  298. }
  300. if ( LineStatus & COM2440_LSR_BI )
  301. LineEvents |= EV_BREAK;
  303. // Let WaitCommEvent know about this error
  304. if ( LineEvents )
  305. pHWHead->EventCallback( pHWHead->pMddHead, LineEvents );
  306. }
  308. //
  309. // Reading the MSR clears many of its bits.  So, we provide this wrapper,
  310. // which reads the register, records any interesting values, and
  311. // stores the current MSR contents in the shadow register.
  312. // Note that we always have DDCD and DCTS enabled, so if someone
  313. // wants to keep an eye on these lines, its OK to simply read the
  314. // shadow register, since if the value changes, the interrupt
  315. // will cause the shadow to be updated.
  316. //
  317. //__inline
  318. VOID
  319. ReadMSR(PVOID pHead)
  320. {
  321. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  322. ULONG Events = 0;
  323. ULONG msr, msr_DSR;
  325. RETAILMSG(DEBUGMODE, (TEXT("ReadMSR rn")));
  326. try 
  327. {
  328. // read nCTS status
  329. msr = INREG(pHWHead,rUMSTAT);
  330. RETAILMSG(DEBUGMODE,  (TEXT("Modem Status Register : 0x%xrn"), msr));
  332. // read nDSR status 
  333. // - As you know this routine is valid only at the SMDK2440 board.
  334. if ( !pHWHead->UseIrDA )
  335. {
  336. if(*(pHWHead->rDSRport) & (1<<(pHWHead->DsrPortNum))) // Low active
  337.     msr_DSR = 0;
  338. else
  339.     msr_DSR = 1;
  340. }
  341. }
  343. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  344. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  345. {
  346. msr = 0;
  347. }
  349.     // Save the MSR value in a shadow
  350.     pHWHead->MSR = msr;
  352. // For changes, we use callback to evaluate the event
  353. if (msr & COM2440_MSR_DCTS)  // Delta CTS (SERIAL_MSR_DCTS)
  354. {
  355. Events |= EV_CTS;
  356. pHWHead->vUMSTAT |= COM2440_MSR_DCTS;
  357. } 
  359. if(msr & COM2440_MSR_CTS) 
  360. pHWHead->vUMSTAT |= COM2440_MSR_CTS;
  361. else
  362. pHWHead->vUMSTAT &= ~COM2440_MSR_CTS;
  364. // S2440 does not support Delta DSR status by H/W,
  365. // so we have to check this by S/W.
  366. //
  367. // if(DSR : High->Low) - became active
  368. if (msr_DSR) // S2440 Evaluation Board bidged these two pins.
  369. {
  370. if(!(pHWHead->vUMSTAT & COM2440_MSR_DSR))
  371. {
  372. pHWHead->vUMSTAT |= COM2440_MSR_DDSR;
  373. Events |= EV_DSR;
  374. Events |= EV_RLSD;  // DCD
  375. }    // there is a change... H->L(became active)
  376. else
  377. pHWHead->vUMSTAT &= ~COM2440_MSR_DDSR;
  378. pHWHead->vUMSTAT |= COM2440_MSR_DSR;
  379. }
  380. // if(DSR : Low->High) - became in-active
  381. else
  382. {
  383. if((pHWHead->vUMSTAT & COM2440_MSR_DSR))
  384. {
  385. pHWHead->vUMSTAT |= COM2440_MSR_DDSR;
  386. Events |= EV_DSR;
  387. Events |= EV_RLSD;  // DCD
  388. }   // there is a change... L->H (became inactive)
  389. else
  390. pHWHead->vUMSTAT &= ~COM2440_MSR_DDSR;
  391. pHWHead->vUMSTAT &= ~COM2440_MSR_DSR;
  392. }
  394. RETAILMSG(DEBUGMODE,  (TEXT("ReadMSR Events:0x%xrn"), Events));
  395. RETAILMSG(DEBUGMODE,  (TEXT("ReadMSR MSR:0x%xrn"), msr));
  396. RETAILMSG(DEBUGMODE,  (TEXT("ReadMSR MSR_DSR:0x%xrn"), msr_DSR));   
  398. if ( Events )
  399. pHWHead->EventCallback( pHWHead->pMddHead, Events );
  400. }
  402. VOID
  403. ShowSerialRegisters(PVOID  pHead)
  404. {
  405. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  407. RETAILMSG(1, (TEXT("InterruptType : 0x%X, 0x%X, 0x%X, 0x%Xrn"), 
  408. *(pHWHead->UART_INTMASK), 
  409. *(pHWHead->UART_INTSUBMASK),  
  410. *(pHWHead->UART_INTSRCPND), 
  411. *(pHWHead->UART_INTSUBSRCPND)));
  412. RETAILMSG(1,  (TEXT("rULCON: 0x%x "), pHWHead->s2440SerReg->rULCON));
  413. RETAILMSG(1,  (TEXT("rUCON: 0x%x "), pHWHead->s2440SerReg->rUCON));
  414. RETAILMSG(1,  (TEXT("rUFCON: 0x%x "), pHWHead->s2440SerReg->rUFCON));
  415. RETAILMSG(1,  (TEXT("rUMCON: 0x%x "), pHWHead->s2440SerReg->rUMCON));
  416. RETAILMSG(1,  (TEXT("rUERSTAT: 0x%x "), pHWHead->s2440SerReg->rUERSTAT));
  417. RETAILMSG(1,  (TEXT("rUFSTAT: 0x%x "), pHWHead->s2440SerReg->rUFSTAT));
  418. RETAILMSG(1,  (TEXT("rUMSTAT: 0x%x "), pHWHead->s2440SerReg->rUMSTAT));
  419. RETAILMSG(1,  (TEXT("rUTXH: 0x%x "), pHWHead->s2440SerReg->rUTXH));
  420. RETAILMSG(1,  (TEXT("rURXH: 0x%x "), pHWHead->s2440SerReg->rURXH));
  421. RETAILMSG(1,  (TEXT("rUBRDIV: 0x%xrn"), pHWHead->s2440SerReg->rUBRDIV));
  422. RETAILMSG(1,  (TEXT("pHWHead->vUMSTAT: 0x%x rn"), pHWHead->vUMSTAT));
  423. RETAILMSG(1,  (TEXT("pHWHead->CTSFlowOff: 0x%x rnrn"), pHWHead->CTSFlowOff));
  424. }
  426. #define BAUD_TABLE_SIZE 23
  427. static const
  428. PAIRS    LS_BaudPairs[BAUD_TABLE_SIZE] =
  429. {
  430. {50,        2307},
  431. {75,        1538},
  432. {110,       1049},
  433. {135,        858},
  434. {150,        769},
  435. {300,        384},
  436. {600,        192},
  437. {1200,        96},
  438. {1800,        64},
  439. {2000,        58},
  440. {2400,        48},
  441. {3600,        32},
  442. {4800,        24},
  443. {7200,        16},
  444. {9600,        12},
  445. {12800,        9},
  446. {14400,        8},
  447. {19200,        6},
  448. {23040,        5},
  449. {28800,        4},
  450. {38400,        3},
  451. {57600,        2},
  452. {115200,       1}
  453. };
  455. static const
  456. LOOKUP_TBL  LS_BaudTable = {BAUD_TABLE_SIZE, (PAIRS *) LS_BaudPairs};
  458. // Routine to clear any pending interrupts.  Called from Init and PostInit
  459. // to make sure we atart out in a known state.
  460. VOID
  461. ClearPendingInts(PVOID   pHead) // @parm PVOID returned by HWinit.
  462. {
  463. PS2440_UART_INFO pHWHead = (PS2440_UART_INFO)pHead;
  464. UINT32 tmpReg;
  466. EnterCriticalSection(&(pHWHead->RegCritSec));
  468. RETAILMSG(DEBUGMODE,(TEXT("ClearPendingInts rn")));
  469. try
  470. {
  471. SETREG(pHWHead,rUFCON,0x6);    // tx, rx fifo reset
  472. ClearSubINTPnd(pHWHead, pHWHead->bTxINT | pHWHead->bRxINT | pHWHead->bErrINT);
  473. ClearINTPnd(pHWHead, pHWHead->bINT);
  474. tmpReg = INREG(pHWHead,rUERSTAT);
  475. }
  477. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  478. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  479. {
  480. RETAILMSG(1,(TEXT("SL_PostInit, 0x%X - ERRORrn"), pHWHead));
  481. // Just fall through & release CritSec
  482. }
  484. LeaveCriticalSection(&(pHWHead->RegCritSec));
  485. }
  487. // Routine to set some 2440 IO Ports.
  488. VOID
  489. S2440_SetIrDAIOP(PVOID   pHead) // @parm points to device head
  490. {
  491. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  492. RETAILMSG(DEBUGMODE, (TEXT("S2440_SetIrDAIOP rn")));
  494. EnterCriticalSection(&(pHWHead->RegCritSec));
  496. // by jylee 2003.04.15
  497. v_pIOPregs->rGPBCON &= ~(0x3<<2); // clear GPBCON for GPB1 (nIRDAEN)
  498. v_pIOPregs->rGPBCON |=  (0x1<<2); // set GPBCON for GPB1 output
  499. v_pIOPregs->rGPBUP  |=  (0x1<<1); // set GPB1 pullup disable (external pullup)
  500. v_pIOPregs->rGPBDAT &= ~(0x1<<1); // set GPB1 signal low 
  501. v_pIOPregs->rGPHCON &= ~(0x3<<12 | 0x3<<14); // clear uart 2 - rx, tx
  502. v_pIOPregs->rGPHCON |=  (0x2<<12 | 0x2<<14); 
  503. v_pIOPregs->rGPHUP  |=  0xc0;
  505. LeaveCriticalSection(&(pHWHead->RegCritSec));
  506. }
  508. S2440_SetSerialIOP(PVOID   pHead) // @parm points to device head
  509. {
  510. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  512. RETAILMSG(DEBUGMODE, (TEXT("S2440_SetSerialIOP rn")));
  514. EnterCriticalSection(&(pHWHead->RegCritSec));
  515. v_pIOPregs->rGPHCON &= ~(0x3<<0 | 0x3<<2 | 0x3<<4 | 0x3<<6); // clear uart 0 - rx, tx
  516. v_pIOPregs->rGPHCON |= (0x2<<4 | 0x2<<6); 
  517. v_pIOPregs->rGPDCON &= ~(0x3<<0 | 0x3<<2);
  518. v_pIOPregs->rGPDCON |= (0x1<<0 | 0x0<<2);
  519. #if USE_AFC
  520. // set nRTS to GPO mode
  521. // for software flow-control
  522. v_pIOPregs->rGPHCON |= (0x2<<0 | 0x1<<2 );
  523. #else
  524. v_pIOPregs->rGPHCON |= (0x2<<0 | 0x2<<2 );
  525. #endif
  527. /*
  528. In the SMDK2440 board, if IRDA is enabled, following values are ignored.
  529. */
  530. #if 0 // Board version is not 0.17
  531. v_pIOPregs->rGPHUP  |= 0xc3;
  532. pHWHead->rDTRport = (volatile unsigned int *)&(v_pIOPregs->rGPHDAT);
  533. pHWHead->rDSRport = (volatile unsigned int *)&(v_pIOPregs->rGPHDAT);
  534. pHWHead->DtrPortNum = 6;
  535. pHWHead->DsrPortNum = 7;
  536. #endif
  538. v_pIOPregs->rGPDUP  |= 0x3;
  539. pHWHead->rDTRport = (volatile unsigned int *)&(v_pIOPregs->rGPDDAT);
  540. pHWHead->rDSRport = (volatile unsigned int *)&(v_pIOPregs->rGPDDAT);
  541. pHWHead->DtrPortNum = 0;
  542. pHWHead->DsrPortNum = 1;
  544. #if USE_AFC    
  545.   pHWHead->rCTSport = (volatile unsigned int *)&(v_pIOPregs->rGPHDAT);
  546. pHWHead->rRTSport = (volatile unsigned int *)&(v_pIOPregs->rGPHDAT);
  547. pHWHead->CtsPortNum = 0;
  548. pHWHead->RtsPortNum = 1;
  549. #endif
  551. LeaveCriticalSection(&(pHWHead->RegCritSec));
  552. }
  554. VOID
  555. S2440_SetIOP(PVOID   pHead) // @parm points to device head
  556. {
  557. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  559. if ( pHWHead->UseIrDA )
  560. {
  561. RETAILMSG(DEBUGMODE, (TEXT("S2440_SetIOP : IRDArn")));
  562. S2440_SetIrDAIOP(pHWHead);
  563. }
  564. else
  565. {
  566. RETAILMSG(DEBUGMODE, (TEXT("S2440_SetIOP : SERIALrn")));
  567. S2440_SetSerialIOP(pHWHead);
  568. }
  569. }
  572. //
  573. /////////////////// Start of exported entrypoints ////////////////
  574. //
  575. //
  576. // @doc OEM 
  577. // @func PVOID | SL_Open | Configures 16550 for default behaviour.
  578. //
  579. VOID
  580. SL_Open(PVOID   pHead) // @parm PVOID returned by HWinit.
  581. {
  582. PS2440_UART_INFO pHWHead = (PS2440_UART_INFO)pHead;
  584. RETAILMSG(1, (TEXT("SL_Open 0x%X (%d opens)rn"), pHead, pHWHead->OpenCount));
  585. // If the device is already open, all we do is increment count
  586. if ( pHWHead->OpenCount++ )
  587. {
  588. RETAILMSG(1, (TEXT("SL_Open 0x%X (%d opens)rn"), pHead, pHWHead->OpenCount));
  589. return ;
  590. }
  592. pHWHead->DroppedBytes = 0;
  593. pHWHead->CTSFlowOff   = FALSE;  // Not flowed off yet
  594. pHWHead->DSRFlowOff   = FALSE;  // Not flowed off yet
  595. pHWHead->CommErrors   = 0;
  596. pHWHead->ModemStatus  = 0;
  597. pHWHead->ConSetup     = 6;
  598. pHWHead->vUMSTAT      = 0;
  599. pHWHead->fSW_EnTxINT  = FALSE;
  601. EnterCriticalSection(&(pHWHead->RegCritSec));
  602. try
  603. {
  604. S2440_SetIOP(pHead);
  606. // Get defaults from the DCB structure
  607. SL_SetBaudRate( pHead, pHWHead->dcb.BaudRate );
  608. SL_SetByteSize( pHead, pHWHead->dcb.ByteSize );
  609. SL_SetStopBits( pHead, pHWHead->dcb.StopBits );
  610. SL_SetParity(pHead, pHWHead->dcb.Parity );
  612. // UART Control, Modem, Fifo register setting.
  613. OUTREG(pHWHead,rUCON,0x2c5);   //Clock selection=PCLK, tx=level,rx=pulse,enable timeout int.,
  614. //enable rx error int., Tx int, Rx int
  615. OUTREG(pHWHead,rUFCON,0x6);    // Reset FIFO
  617. if (pHWHead->UseIrDA) 
  618. {
  619. OUTREG(pHWHead,rUFCON,0x41);   //FIFO enable : tx-4bytes, rx-4bytes
  620. OUTREG(pHWHead,rUMCON,0x00);   //Disable auto flow control.
  621. }
  622. else 
  623. {
  624. #if USE_AFC
  625. // by shin.0212.
  626. OUTREG(pHWHead,rUFCON,0x61);   //FIFO enable : tx-4bytes, rx-12bytes
  627. OUTREG(pHWHead,rUMCON,0x10);   //Enable auto flow control.  
  628. #else
  629. OUTREG(pHWHead,rUFCON,0x41);   //FIFO enable : tx-4bytes, rx-4bytes
  630. OUTREG(pHWHead,rUMCON,0x00);   //Disable auto flow control.
  631. #endif
  632. }
  634. if ( pHWHead->UseIrDA )
  635. SETREG(pHWHead,rULCON,SER2440_IRMODE_MASK);   // Infra-red mode enable.
  637. ClearPendingInts( pHWHead );
  639. EnINT(pHWHead, pHWHead->bINT);
  640. EnSubINT(pHWHead, pHWHead->bRxINT);
  642. // For CE 3.0, we are still supporting
  643. // the old style MDDs, and they don't call our PostInit, which
  644. // needs to happen sometime prior to this.  So for now, we go ahead
  645. // ahead and clear out interrupts one last time.  In 4.0, we can
  646. // kill the old serial MDD and assume that everyone uses the new
  647. // MDD and calls post init.  
  649. SL_PostInit(pHWHead);
  650. ReadLSR(pHWHead);
  651. }
  652. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  653. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  654. {
  655. // Just get out of here.
  656. }
  658. LeaveCriticalSection(&(pHWHead->RegCritSec));
  659. }
  661. //
  662. // @doc OEM 
  663. // @func PVOID | SL_Close | Does nothing except keep track of the
  664. // open count so that other routines know what to do.
  665. //
  666. VOID
  667. SL_Close(PVOID   pHead) // @parm PVOID returned by HWinit.
  668. {
  669. PS2440_UART_INFO pHWHead = (PS2440_UART_INFO)pHead;
  671. RETAILMSG(1, (TEXT("SL_Close rn")));
  672. if ( pHWHead->OpenCount ) pHWHead->OpenCount--;
  674. EnterCriticalSection(&(pHWHead->RegCritSec));
  675. try
  676. {
  677. SL_ClearRTS( pHWHead );
  678. OUTREG(pHWHead,rUMSTAT,0x0);
  680. // Disable all interrupts and clear MCR.
  681. DisEnSubINT(pHWHead, pHWHead->bRxINT);
  682. pHWHead->fSW_EnTxINT = FALSE;
  684. // This routhine for auto detect.
  685. S2440_SetIrDAIOP(pHead);
  686. }
  687. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  688. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  689. {
  690. // Just get out of here.
  691. }
  693. LeaveCriticalSection(&(pHWHead->RegCritSec));
  694. }
  696. //
  697. // @doc OEM 
  698. // @func PVOID | SL_Init | Initializes 16550 device head.  
  699. //
  701. VOID
  702. SL_Init(
  703.        PVOID   pHead, // @parm points to device head
  704.        PUCHAR  pRegBase, // Pointer to 16550 register base
  705.        UINT8   RegStride, // Stride amongst the 16550 registers
  706.        EVENT_FUNC EventCallback, // This callback exists in MDD
  707.        PVOID   pMddHead,   // This is the first parm to callback
  708.        PLOOKUP_TBL   pBaudTable  // BaudRate Table
  709.        )
  710. {
  711. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  713. RETAILMSG(DEBUGMODE, (TEXT("SL_Init : IRDA = %d rn"), pHWHead->UseIrDA));
  715. SER_VirtualAlloc();
  717. if ( pHWHead->UseIrDA )
  718. {
  719. pHWHead->bINT = BIT_UART2;
  720. pHWHead->bTxINT = INTSUB_TXD2;
  721. pHWHead->bRxINT = INTSUB_RXD2;
  722. pHWHead->bErrINT = INTSUB_ERR2;
  723. pHWHead->s2440SerReg = (S2440_UART_REG *)v_pUART2regs;
  724. pRegBase = (PUCHAR)pHWHead->s2440SerReg;
  725. }
  726. else
  727. {
  728. pHWHead->bINT = BIT_UART0;
  729. pHWHead->bTxINT = INTSUB_TXD0;
  730. pHWHead->bRxINT = INTSUB_RXD0;
  731. pHWHead->bErrINT = INTSUB_ERR0;
  732. pHWHead->s2440SerReg = (S2440_UART_REG *)v_pUART0regs;
  733. pRegBase = (PUCHAR)pHWHead->s2440SerReg;
  734. }
  736. pHWHead->UART_INTMASK = (volatile unsigned int *)&(v_pINTregs->rINTMSK);
  737. pHWHead->UART_INTSUBMASK = (volatile unsigned int *)&(v_pINTregs->rINTSUBMSK);
  738. pHWHead->UART_INTPND = (volatile unsigned int *)&(v_pINTregs->rINTPND);
  739. pHWHead->UART_INTSRCPND = (volatile unsigned int *)&(v_pINTregs->rSRCPND);
  740. pHWHead->UART_INTSUBSRCPND = (volatile unsigned int *)&(v_pINTregs->rSUBSRCPND);
  741. pHWHead->vUMSTAT = 0;
  743. if ( pHWHead->UseIrDA )
  744. {
  745. pHWHead->pUFTXH = (volatile unsigned char *)&(v_pUART2regs->rUTXH);
  746. pHWHead->pUFRXH = (volatile unsigned char *)&(v_pUART2regs->rURXH);    
  747. }
  748. else
  749. {
  750. pHWHead->pUFTXH = (volatile unsigned char *)&(v_pUART0regs->rUTXH);
  751. pHWHead->pUFRXH = (volatile unsigned char *)&(v_pUART0regs->rURXH);    
  752. }
  754. RETAILMSG(DEBUGMODE, (TEXT("+ S2440_SetIrDAIOP rn")));
  755. S2440_SetIrDAIOP(pHead);
  756. RETAILMSG(DEBUGMODE, (TEXT("- S2440_SetIrDAIOP rn")));
  758. // Store info for callback function
  759. pHWHead->EventCallback = EventCallback;
  760. pHWHead->pMddHead = pMddHead;
  762. // Now set up remaining fields
  763. if ( pBaudTable != NULL )
  764. pHWHead->pBaudTable = (LOOKUP_TBL *) pBaudTable;
  765. else
  766. pHWHead->pBaudTable = (LOOKUP_TBL *) &LS_BaudTable;
  767. pHWHead->FlushDone      = CreateEvent(0, FALSE, FALSE, NULL);
  769. pHWHead->OpenCount = 0;
  771. // Don't allow any interrupts till PostInit.
  772. DisEnINT(pHWHead, pHWHead->bINT);
  773. DisEnSubINT(pHWHead, pHWHead->bTxINT | pHWHead->bRxINT | pHWHead->bErrINT);
  775. pHWHead->fSW_EnTxINT = FALSE;
  776. pHWHead->RxDiscard = FALSE;
  778. InitializeCriticalSection(&(pHWHead->TransmitCritSec));
  779. InitializeCriticalSection(&(pHWHead->RegCritSec));
  781. // Clear any interrupts which may be pending.  Normally only
  782. // happens if we were warm reset.
  783. ClearPendingInts( pHWHead );
  784. }
  786. //
  787. // @doc OEM
  788. // @func void | SL_PostInit | This routine takes care of final initialization.
  789. //
  790. // @rdesc None.
  791. //
  792. BOOL
  793. SL_PostInit(PVOID   pHead) // @parm PVOID returned by HWinit.
  794. {
  795. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  797. RETAILMSG(DEBUGMODE, (TEXT("SL_PostInit rn")));
  798. // Since we are just a library which might get used for 
  799. // builtin ports which init at boot, or by PCMCIA ports
  800. // which init at Open, we can't do anything too fancy.
  801. // Lets just make sure we cancel any pending interrupts so
  802. // that if we are being used with an edge triggered PIC, he
  803. // will see an edge after the MDD hooks the interrupt.
  804. ClearPendingInts( pHWHead );
  805. return(TRUE);
  806. }
  808. //
  809. // @doc OEM 
  810. // @func PVOID | SL_Deinit | De-initializes 16550 device head.  
  811. //
  812. VOID
  813. SL_Deinit(PVOID   pHead) // @parm points to device head
  814. {
  815. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  817. RETAILMSG(DEBUGMODE, (TEXT("SL_Deinit rn")));
  818. DeleteCriticalSection(&(pHWHead->TransmitCritSec));
  819. DeleteCriticalSection(&(pHWHead->RegCritSec));
  821. // Free the flushdone event
  822. if ( pHWHead->FlushDone )
  823.     CloseHandle( pHWHead->FlushDone );
  825. SER_VirtualFree();
  826. }
  828. //
  829. // @doc OEM
  830. // @func void | SL_ClearDtr | This routine clears DTR.
  831. //
  832. // @rdesc None.
  833. //
  834. VOID
  835. SL_ClearDTR(PVOID   pHead) // @parm PVOID returned by HWinit.
  836. {
  837. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  839. RETAILMSG(DEBUGMODE, (TEXT("+SL_ClearDTR, 0x%Xrn"), pHead));
  840. RETAILMSG(DEBUGMODE, (TEXT("UseIrDA, %drn"), pHWHead->UseIrDA));
  842. EnterCriticalSection(&(pHWHead->RegCritSec));
  844. try
  845. {
  846. // Low active pin.
  847. if ( !pHWHead->UseIrDA )
  848. *(pHWHead->rDTRport) |= (1<<(pHWHead->DtrPortNum));
  849. }
  851. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  852. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  853. {
  854. // Just exit
  855. }
  857. LeaveCriticalSection(&(pHWHead->RegCritSec));
  859. RETAILMSG(DEBUGMODE, (TEXT("-SL_ClearDTR, 0x%Xrn"), pHead));
  860. }
  862. //
  863. // @doc OEM
  864. // @func VOID | SL_SetDTR | This routine sets DTR.
  865. // 
  866. // @rdesc None.
  867. //
  868. VOID
  869. SL_SetDTR(PVOID   pHead) // @parm PVOID returned by HWinit.
  870. {    
  871. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  873. RETAILMSG(DEBUGMODE, (TEXT("+SL_SetDTR, 0x%Xrn"), pHead));
  875. EnterCriticalSection(&(pHWHead->RegCritSec));
  877. try
  878. {
  879. // Low active
  880. if ( !pHWHead->UseIrDA )
  881. *(pHWHead->rDTRport) &= ~(1<<(pHWHead->DtrPortNum));
  882. }
  884. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  885. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  886. {
  887. // Just exit
  888. }
  890. LeaveCriticalSection(&(pHWHead->RegCritSec));
  892. RETAILMSG(DEBUGMODE, (TEXT("-SL_SetDTR, 0x%Xrn"), pHead));
  893. }
  895. //
  896. // @doc OEM
  897. // @func VOID | SL_ClearRTS | This routine clears RTS.
  898. // 
  899. // @rdesc None.
  900. // 
  901. VOID
  902. SL_ClearRTS(PVOID   pHead) // @parm PVOID returned by HWinit.
  903. {
  905. #if 0 // by shin
  906. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  908. RETAILMSG(0, (TEXT("+SL_ClearRTS, 0x%Xrn"), pHead));
  910. EnterCriticalSection(&(pHWHead->RegCritSec));
  912. try
  913. {
  914. CLEARREG(pHWHead, rUMCON, SER2440_RTS);
  915. }
  917. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  918. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  919. {
  920. // Just exit
  921. }
  923. LeaveCriticalSection(&(pHWHead->RegCritSec));
  925. RETAILMSG(DEBUGMODE, (TEXT("-SL_ClearRTS, 0x%Xrn"), pHead));
  927. #else
  929. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  931. RETAILMSG(DEBUGMODE, (TEXT("+SL_ClearRTS, 0x%Xrn"), pHead));
  933. if ( !pHWHead->UseIrDA )
  934. {
  935. #if USE_AFC
  936. // by 0212.
  937. *(pHWHead->rRTSport) |= (1<<(pHWHead->RtsPortNum));
  938. #else
  939. EnterCriticalSection(&(pHWHead->RegCritSec));
  940. try
  941. {
  942. CLEARREG(pHWHead, rUMCON, SER2440_RTS);
  943. }
  945. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  946. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  947. {
  948. // Just exit
  949. }
  951. LeaveCriticalSection(&(pHWHead->RegCritSec));
  952. #endif
  953. }
  955. RETAILMSG(DEBUGMODE, (TEXT("-SL_ClearRTS, 0x%Xrn"), pHead));
  956. #endif
  957. }
  959. //
  960. // @doc OEM
  961. // @func VOID | SL_SetRTS | This routine sets RTS.
  962. // 
  963. // @rdesc None.
  964. //
  965. VOID
  966. SL_SetRTS(PVOID   pHead) // @parm PVOID returned by HWinit.
  967. {
  968. #if 0
  969. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  971. RETAILMSG(0, (TEXT("+SL_SetRTS, 0x%Xrn"), pHead));
  972. EnterCriticalSection(&(pHWHead->RegCritSec));
  973. try
  974. {
  975. SETREG(pHWHead, rUMCON, SER2440_RTS);
  976. }
  978. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  979. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  980. {
  981. // Just exit
  982. }
  984. LeaveCriticalSection(&(pHWHead->RegCritSec));
  986. RETAILMSG(DEBUGMODE, (TEXT("-SL_SetRTS, 0x%Xrn"), pHead));
  987. #else
  988. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  990. RETAILMSG(DEBUGMODE, (TEXT("+SL_SetRTS, 0x%Xrn"), pHead));
  992. if ( !pHWHead->UseIrDA )
  993. {
  994. #if USE_AFC
  995. // by .0212.
  996. *(pHWHead->rRTSport) &= ~(1<<(pHWHead->RtsPortNum));
  997. #else
  998. EnterCriticalSection(&(pHWHead->RegCritSec));
  999. try
  1000. {
  1001. SETREG(pHWHead, rUMCON, SER2440_RTS);
  1002. }
  1004. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  1005. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  1006. {
  1007. // Just exit
  1008. }
  1010. LeaveCriticalSection(&(pHWHead->RegCritSec));
  1011. #endif
  1012. }
  1013. RETAILMSG(DEBUGMODE, (TEXT("-SL_SetRTS, 0x%Xrn"), pHead));
  1014. #endif
  1015. }
  1017. //
  1018. // @doc OEM
  1019. // @func VOID | SL_ClearBreak | This routine clears break.
  1020. // 
  1021. // @rdesc None.
  1022. // 
  1023. VOID
  1024. SL_ClearBreak(PVOID   pHead) // @parm PVOID returned by HWinit.
  1025. {
  1026. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  1028. RETAILMSG(DEBUGMODE,  (TEXT("SL_ClearBreak:rn"))); 
  1029. // S2440 does not need to clear break signal, for cleared by automatic.
  1030. }
  1032. //
  1033. // @doc OEM
  1034. // @func VOID | SL_SetBreak | This routine sets break.
  1035. // 
  1036. // @rdesc None.
  1037. //
  1038. VOID
  1039. SL_SetBreak(PVOID   pHead) // @parm PVOID returned by HWinit.
  1040. {
  1041. PS2440_UART_INFO    pHWHead = (PS2440_UART_INFO)pHead;
  1043. RETAILMSG(DEBUGMODE, (TEXT("+SL_SetBreak, 0x%Xrn"), pHead));
  1044. EnterCriticalSection(&(pHWHead->RegCritSec));
  1045. try
  1046. {
  1047. SETREG(pHWHead,rUCON,BS_SEND);
  1048. }
  1050. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  1051. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  1052. {
  1053. // Just exit
  1054. }
  1056. LeaveCriticalSection(&(pHWHead->RegCritSec));
  1058. RETAILMSG(DEBUGMODE, (TEXT("-SL_SetBreak, 0x%Xrn"), pHead));
  1059. }
  1061. //
  1062. // SetBaudRate
  1063. //
  1064. // Internal function.  The only real reason for splitting this out
  1065. // is so that we can call it from PowerOn and still allow SL_SetBaud
  1066. // to do debug messages, acquire critical sections, etc.
  1067. //
  1068. BOOL
  1069. SetBaudRate(PVOID   pHead, ULONG   BaudRate)
  1070. {
  1071. PS2440_UART_INFO    pHWHead = (PS2440_UART_INFO)pHead;
  1073. ClearPendingInts( pHWHead );
  1075. RETAILMSG(1, (TEXT("SetBaudRate -> %drn"), BaudRate));
  1077. if ( (pHWHead->s2440SerReg->rUCON & CS_MASK) == CS_PCLK )
  1078. {
  1079. // if ( BaudRate == 115200 || BaudRate == 38400 )
  1080. // OUTREG(pHWHead,rUBRDIV,( (int)(S2440PCLK/16.0/BaudRate)));
  1081. // else
  1082. OUTREG(pHWHead,rUBRDIV,( (int)(S2440PCLK/16.0/BaudRate) -1 ));
  1083. }
  1084. else // if  ( (pHWHead2->s2440SerReg->rUCON & CS_MASK) == CS_UCLK )
  1085. OUTREG(pHWHead,rUBRDIV,( (int)(S2440UCLK/16.0/BaudRate) -1 ));
  1087. return( TRUE );
  1088. }
  1090. //
  1091. // @doc OEM
  1092. // @func BOOL | SL_SetBaudRate |
  1093. //  This routine sets the baud rate of the device.
  1094. //
  1095. // @rdesc None.
  1096. //
  1097. BOOL
  1098. SL_SetBaudRate(
  1099.               PVOID   pHead,    // @parm     PVOID returned by HWInit
  1100.               ULONG   BaudRate    // @parm     ULONG representing decimal baud rate.
  1101.               )
  1102. {
  1103. BOOL fRet;
  1104. PS2440_UART_INFO    pHWHead = (PS2440_UART_INFO)pHead;
  1106. RETAILMSG (DEBUGMODE, (TEXT("+SL_SetbaudRate 0x%X, %drn"), pHead, BaudRate));
  1108. try
  1109. {
  1110. // Enter critical section before calling function, since
  1111. // we can't make sys calls inside SetBaudRate
  1112. EnterCriticalSection(&(pHWHead->RegCritSec));
  1113. fRet = SetBaudRate(pHead, BaudRate);
  1114. LeaveCriticalSection(&(pHWHead->RegCritSec));
  1115. }
  1117. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  1118. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  1119. {
  1120. return( FALSE );
  1121. }
  1123. if ( fRet )
  1124. {
  1125. pHWHead->dcb.BaudRate = BaudRate;
  1127. RETAILMSG(DEBUGMODE, (TEXT("-SL_SetbaudRate 0x%X (%d Baud)rn"), pHead, BaudRate));
  1128. return( TRUE );
  1129. }
  1130. else
  1131. {
  1132. RETAILMSG(DEBUGMODE, (TEXT("-SL_SetbaudRate - Error setting %d, failing to %drn"), BaudRate, pHWHead->dcb.BaudRate));
  1133. return( FALSE );
  1134. }
  1135. }
  1137. //
  1138. // @doc OEM
  1139. // @func BOOL | SL_SetByteSize |
  1140. //  This routine sets the WordSize of the device.
  1141. //
  1142. // @rdesc None.
  1143. //
  1144. BOOL
  1145. SL_SetByteSize(
  1146.               PVOID   pHead,        // @parm     PVOID returned by HWInit
  1147.               ULONG   ByteSize    // @parm     ULONG ByteSize field from DCB.
  1148.               )
  1149. {
  1150. PS2440_UART_INFO    pHWHead = (PS2440_UART_INFO)pHead;
  1151. UINT32 lcr;
  1152. BOOL bRet;
  1154. RETAILMSG(DEBUGMODE,(TEXT("+SL_SetByteSize 0x%X, 0x%Xrn"), pHead, ByteSize));
  1156. bRet = TRUE;
  1158. EnterCriticalSection(&(pHWHead->RegCritSec));
  1160. try {      
  1161. lcr = (UINT32)INREG(pHWHead,rULCON);
  1162. lcr &= ~SER2440_DATABIT_MASK;
  1164. switch ( ByteSize )
  1165. {
  1166. case 5:
  1167. lcr |= 0;//SERIAL_5_DATA;
  1168. break;
  1169. case 6:
  1170. lcr |= 1;//SERIAL_6_DATA;
  1171. break;
  1172. case 7:
  1173. lcr |= 2;//SERIAL_7_DATA;
  1174. break;
  1175. case 8:
  1176. lcr |= 3;//SERIAL_8_DATA;
  1177. break;
  1178. default:
  1179. bRet = FALSE;
  1180. break;
  1181. }
  1183. if (bRet)
  1184. {
  1185. OUTREG(pHWHead,rULCON,lcr); 
  1186. }
  1187. }
  1189. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  1190. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  1191. {
  1192. bRet = FALSE;
  1193. }
  1195. LeaveCriticalSection(&(pHWHead->RegCritSec));
  1197. RETAILMSG(DEBUGMODE,(TEXT("-SL_SetByteSize 0x%Xrn"), pHead));
  1199. return(bRet);
  1200. }
  1202. //
  1203. // @doc OEM
  1204. // @func BOOL | SL_SetParity |
  1205. //  This routine sets the parity of the device.
  1206. //
  1207. // @rdesc None.
  1208. //
  1209. BOOL
  1210. SL_SetParity(
  1211.             PVOID   pHead,    // @parm     PVOID returned by HWInit
  1212.             ULONG   Parity    // @parm     ULONG parity field from DCB.
  1213.             )
  1214. {
  1215. PS2440_UART_INFO    pHWHead = (PS2440_UART_INFO)pHead;
  1217. UINT32 lcr;
  1218. BOOL bRet;
  1220. RETAILMSG(DEBUGMODE,(TEXT("+SL_SetParity 0x%X, 0x%Xrn"), pHead, Parity));
  1222. bRet = TRUE;
  1224. EnterCriticalSection(&(pHWHead->RegCritSec));
  1226. try
  1227. {
  1228. lcr = (UINT32)INREG(pHWHead,rULCON);      
  1229. lcr &= ~SER2440_PARITY_MASK;
  1231. switch ( Parity )
  1232. {
  1233. case ODDPARITY:
  1234. lcr |= 0x20;//SERIAL_ODD_PARITY;
  1235. break;
  1237. case EVENPARITY:
  1238. lcr |= 0x28;//SERIAL_EVEN_PARITY;
  1239. break;
  1241. case MARKPARITY:
  1242. lcr |= 0x30;//SERIAL_MARK_PARITY;
  1243. break;
  1245. case SPACEPARITY:
  1246. lcr |= 0x38;//SERIAL_SPACE_PARITY;
  1247. break;
  1249. case NOPARITY:
  1250. lcr |= 0;//SERIAL_NONE_PARITY;
  1251. break;
  1253. default:
  1254. bRet = FALSE;
  1255. break;
  1256. }
  1257. if (bRet)
  1258. {
  1259. OUTREG(pHWHead,rULCON,lcr) ;
  1260. }
  1261. }
  1263. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  1264. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  1265. {
  1266. bRet = FALSE;
  1267. }
  1269. LeaveCriticalSection(&(pHWHead->RegCritSec));
  1271. RETAILMSG(DEBUGMODE, (TEXT("-SL_SetParity 0x%Xrn"), pHead));
  1273. return(bRet);
  1274. }
  1275. //
  1276. // @doc OEM
  1277. // @func VOID | SL_SetStopBits |
  1278. //  This routine sets the Stop Bits for the device.
  1279. //
  1280. // @rdesc None.
  1281. //
  1282. BOOL
  1283. SL_SetStopBits(
  1284.               PVOID   pHead,      // @parm     PVOID returned by HWInit
  1285.               ULONG   StopBits  // @parm     ULONG StopBits field from DCB.
  1286.               )
  1287. {
  1288. PS2440_UART_INFO    pHWHead = (PS2440_UART_INFO)pHead;
  1290. UINT32 lcr;
  1291. BOOL bRet;
  1293. RETAILMSG (DEBUGMODE,(TEXT("+SL_SetStopBits 0x%X, 0x%Xrn"), pHead, StopBits));
  1295. bRet = TRUE;
  1297. EnterCriticalSection(&(pHWHead->RegCritSec));
  1299. try
  1300. {
  1301. lcr = INREG(pHWHead,rULCON);
  1302. lcr &= ~SER2440_STOPBIT_MASK;
  1304. // Note that 1.5 stop bits only works if the word size
  1305. // is 5 bits.  Any other xmit word size will cause the
  1306. // 1.5 stop bit setting to generate 2 stop bits.        
  1307. switch ( StopBits )
  1308. {
  1309. case ONESTOPBIT :
  1310. lcr |= 0;//SERIAL_1_STOP ;
  1311. break;
  1313. case ONE5STOPBITS :
  1314. //lcr |= SERIAL_1_5_STOP ;
  1315. //break;
  1317. case TWOSTOPBITS :
  1318. lcr |= 4;//SERIAL_2_STOP ;
  1319. break;
  1321. default:
  1322. bRet = FALSE;
  1323. break;
  1324. }
  1326. if (bRet)
  1327. {
  1328. OUTREG(pHWHead,rULCON,lcr);
  1329. }
  1330. }
  1331. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  1332. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  1333. {
  1334. bRet = FALSE;
  1335. }
  1337. LeaveCriticalSection(&(pHWHead->RegCritSec));
  1339. RETAILMSG(DEBUGMODE,(TEXT("-SL_SetStopBits 0x%Xrn"), pHead));
  1341. return(bRet);
  1342. }
  1344. //
  1345. // @doc OEM
  1346. // @func ULONG | SL_GetRxBufferSize | This function returns
  1347. // the size of the hardware buffer passed to the interrupt
  1348. // initialize function.  It would be used only for devices
  1349. // which share a buffer between the MDD/PDD and an ISR.
  1350. //
  1351. // 
  1352. // @rdesc This routine always returns 0 for 16550 UARTS.
  1353. // 
  1354. ULONG
  1355. SL_GetRxBufferSize(PVOID pHead)
  1356. {
  1357. RETAILMSG(DEBUGMODE, (TEXT("SL_GetRxBufferSize rn")));
  1358. return(0);
  1359. }
  1361. //
  1362. // @doc OEM
  1363. // @func PVOID | SC_GetRxStart | This routine returns the start of the hardware
  1364. // receive buffer.  See SL_GetRxBufferSize.
  1365. // 
  1366. // @rdesc The return value is a pointer to the start of the device receive buffer.
  1367. // 
  1368. PVOID
  1369. SL_GetRxStart(PVOID   pHead) // @parm PVOID returned by SC_init.
  1370. {
  1371. RETAILMSG(DEBUGMODE, (TEXT("SL_GetRxStart rn")));
  1372. return(NULL);
  1373. }
  1375. //
  1376. // @doc OEM
  1377. // @func ULONG | SL_GetInterruptType | This function is called
  1378. //   by the MDD whenever an interrupt occurs.  The return code
  1379. //   is then checked by the MDD to determine which of the four
  1380. //   interrupt handling routines are to be called.
  1381. // 
  1382. // @rdesc This routine returns a bitmask indicating which interrupts
  1383. //   are currently pending.
  1384. // 
  1385. INTERRUPT_TYPE
  1386. SL_GetInterruptType(PVOID pHead) // Pointer to hardware head
  1387. {
  1388. PS2440_UART_INFO    pHWHead = (PS2440_UART_INFO)pHead;
  1389. INTERRUPT_TYPE interrupts;
  1390. ULONG IntPndVal=0;
  1391. ULONG IntSubPndVal=0;
  1393. try
  1394. {
  1395. IntPndVal = *(pHWHead->UART_INTSRCPND);
  1396. IntSubPndVal = *(pHWHead->UART_INTSUBSRCPND);
  1397. }
  1399. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  1400. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  1401. {
  1402. RETAILMSG(DEBUGMODE, (TEXT("ACCESS VIOLATION ERROR rn")));
  1403. IntPndVal = SER2440_INT_INVALID; // simulate no interrupt
  1404. }
  1406. RETAILMSG(DEBUGMODE, (TEXT("SL_GetInterruptType : 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%Xrn"),
  1407. *(pHWHead->UART_INTMASK),
  1408. *(pHWHead->UART_INTSUBMASK),
  1409. *(pHWHead->UART_INTSRCPND),
  1410. *(pHWHead->UART_INTSUBSRCPND),
  1411. ~(*(pHWHead->UART_INTSUBMASK)) & *(pHWHead->UART_INTSUBSRCPND),
  1412. pHWHead->fSW_EnTxINT));
  1414. if ( IntPndVal & (pHWHead->bINT) )
  1415. {
  1416. if ( IntSubPndVal == SER2440_INT_INVALID )
  1417. {      
  1418. RETAILMSG (DEBUGMODE, (TEXT("SL_GetInterruptType: SER2440_INT_INVALIDrn")));
  1419. interrupts = INTR_NONE;
  1420. }
  1421. else if(IntSubPndVal & (pHWHead->bErrINT) )
  1422. {
  1423. RETAILMSG (DEBUGMODE, (TEXT("SL_GetInterruptType: INTR_LINErn")));
  1424. interrupts = INTR_LINE;  // Error status
  1425. }
  1426. else if((IntSubPndVal & (pHWHead->bTxINT)) && pHWHead->fSW_EnTxINT )
  1427. {
  1428. RETAILMSG (DEBUGMODE, (TEXT("SL_GetInterruptType: INTR_TXrn")));
  1429. interrupts = INTR_TX;
  1430. }
  1431. else if(IntSubPndVal & (pHWHead->bRxINT) )
  1432. {
  1433. RETAILMSG (DEBUGMODE, (TEXT("SL_GetInterruptType: INTR_RXrn")));
  1434. interrupts = INTR_RX;    // Received valid data.
  1435. }
  1436. else 
  1437. {
  1438. interrupts = INTR_NONE;  // No interrupts pending, vector is useless
  1439. ClearINTPnd(pHWHead, pHWHead->bINT);
  1440. }
  1441. }
  1442. else
  1443. {
  1444. RETAILMSG (DEBUGMODE, (TEXT("SL_GetInterruptType: INTR_NONE(pHWHead->bINT)rn")));
  1445. interrupts = INTR_NONE;  // No interrupts pending, vector is useless
  1446. }
  1448. return(interrupts);
  1449. }
  1452. // @doc OEM
  1453. // @func ULONG | SL_RxIntr | This routine gets several characters from the hardware
  1454. //   receive buffer and puts them in a buffer provided via the second argument.
  1455. //   It returns the number of bytes lost to overrun.
  1456. // 
  1457. // @rdesc The return value indicates the number of overruns detected.
  1458. //   The actual number of dropped characters may be higher.
  1459. //
  1460. ULONG
  1461. SL_RxIntr(
  1462.          PVOID pHead,                // @parm Pointer to hardware head
  1463.          PUCHAR pRxBuffer,           // @parm Pointer to receive buffer
  1464.          ULONG *pBufflen             // @parm In = max bytes to read, out = bytes read
  1465.          )
  1466. {
  1467. PS2440_UART_INFO   pHWHead    = (PS2440_UART_INFO)pHead;
  1469. ULONG RetVal               = 0;
  1470. ULONG TargetRoom           = *pBufflen;
  1471. UCHAR cEvtChar, cRXChar;
  1472. ULONG rFifoStat, RxFifoCnt, RxDataReady, nRxIntSrc;
  1473. BOOL fRXFlag              = FALSE;
  1474. BOOL fReplaceparityErrors = FALSE;
  1475. BOOL fNull;
  1477. *pBufflen = 0;
  1478. nRxIntSrc = pHWHead->bRxINT;
  1480. RETAILMSG(DEBUGMODE, (TEXT("SL_RxIntr rn")));
  1481. // LAM - I have local copies of some DCB elements since I don't
  1482. // want to keep dereferencing inside my read loop and there are too
  1483. // many of them to trust the compiler.
  1484. cEvtChar = pHWHead->dcb.EvtChar;
  1485. fNull = pHWHead->dcb.fNull;
  1486. if ( pHWHead->dcb.fErrorChar && pHWHead->dcb.fParity )
  1487. fReplaceparityErrors = TRUE;
  1489. try
  1490. {
  1491. // S2440 UART Rx strategy is different from SER16550..
  1492. rFifoStat = INREG(pHWHead,rUFSTAT);
  1493. RxFifoCnt = rFifoStat & 0x3f;
  1495. if((rFifoStat & (1<<6))||(RxFifoCnt > 0))
  1496. RxDataReady = 1;
  1497. else
  1498. RxDataReady = 0;
  1500. while ( TargetRoom && RxDataReady)
  1501. {
  1502. // If the line is unstable, we may check the error status...
  1503. // But now, I ignore it....
  1504. // ReadLSR( pHWHead );
  1506. // Read the byte
  1507. cRXChar = *(pHWHead->pUFRXH);
  1508. RETAILMSG(DEBUGMODE, (TEXT("SL_RxIntr : cRXChar = 0x%x rn"), cRXChar));
  1510. // But we may want to discard it
  1511. if ( pHWHead->dcb.fDsrSensitivity &&
  1512. (! (pHWHead->vUMSTAT & COM2440_MSR_DSR)) )
  1513. {
  1514. // Do nothing - byte gets discarded
  1515. RETAILMSG (1, (TEXT("Dropping byte because DSR is lowrn")));
  1516. }
  1517. else if (!cRXChar && fNull)
  1518. {
  1519. // Do nothing - byte gets discarded
  1520. RETAILMSG (1, (TEXT("Dropping NULL byte due to fNullrn")));
  1521. }
  1522. else
  1523. {
  1524. // Do character replacement if parity error detected.
  1525. // See if we need to generate an EV_RXFLAG for the received char.
  1526. if ( cRXChar == cEvtChar )
  1527. fRXFlag = TRUE;
  1528.  
  1529. // Finally, we can get byte, update status and save.
  1530. if (!pHWHead->RxDiscard )
  1531. {
  1532. *pRxBuffer++ = cRXChar;
  1533. (*pBufflen)++;
  1534. }
  1535. else
  1536. {
  1537. RETAILMSG (1,(TEXT("SL_RXIntr : Dropping byte because now Txingrn")));
  1538. }
  1540. --TargetRoom;
  1542. rFifoStat = INREG(pHWHead,rUFSTAT);
  1543. RxFifoCnt = rFifoStat & 0x3f;
  1545. if((rFifoStat & (1<<6))||(RxFifoCnt > 0))
  1546. RxDataReady = 1;
  1547. else
  1548. RxDataReady = 0;
  1549. }
  1550. }
  1552. //Clear interrupt pending bit
  1553. ClearSubINTPnd(pHWHead, nRxIntSrc);
  1554. if ( *(pHWHead->UART_INTSUBSRCPND) & ( pHWHead->bRxINT | pHWHead->bErrINT ) )
  1555. {
  1556. RETAILMSG (DEBUGMODE, (TEXT("*(pHWHead->UART_INTSUBSRCPND) = %x rn"), *(pHWHead->UART_INTSUBSRCPND)));
  1557. RETAILMSG (DEBUGMODE, (TEXT("Do Not Clear bINT rn")));
  1558. }
  1559. else
  1560. {
  1561. ClearINTPnd(pHWHead, pHWHead->bINT);
  1562. }
  1563. EnINT(pHWHead, pHWHead->bINT);
  1564. EnSubINT(pHWHead, nRxIntSrc);
  1565. if ( !pHWHead->UseIrDA )
  1566. {
  1567. #if USE_AFC
  1568. // Assert nRTS
  1569. *(pHWHead->rRTSport) &= ~(1<<(pHWHead->RtsPortNum));
  1570. #endif
  1571. }
  1572. }
  1573. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  1574. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  1575. {
  1576. // just exit
  1577. }
  1579. // if we saw one (or more) EVT chars, then generate an event
  1580. if ( fRXFlag )
  1581. pHWHead->EventCallback( pHWHead->pMddHead, EV_RXFLAG );
  1583. if ( pHWHead->DroppedBytes )
  1584. {
  1585. RETAILMSG (DEBUGMODE, (TEXT("Rx drop %d.rn"), pHWHead->DroppedBytes));
  1586. }
  1587.     
  1588. RetVal = pHWHead->DroppedBytes;
  1589. pHWHead->DroppedBytes = 0;
  1590. return(RetVal);
  1591. }
  1593. // @doc OEM
  1594. // @func ULONG | SL_PutBytes | This routine is called from the MDD
  1595. //   in order to write a stream of data to the device. (Obselete)
  1596. // 
  1597. // @rdesc Always returns 0
  1598. //
  1599. ULONG
  1600. SL_PutBytes(
  1601.            PVOID   pHead,        // @parm    PVOID returned by HWInit.
  1602.            PUCHAR  pSrc,        // @parm    Pointer to bytes to be sent.
  1603.            ULONG   NumberOfBytes,  // @parm    Number of bytes to be sent.
  1604.            PULONG  pBytesSent        // @parm    Pointer to actual number of bytes put.
  1605.            )
  1606. {
  1607. PS2440_UART_INFO   pHWHead    = (PS2440_UART_INFO)pHead;
  1608. RETAILMSG(1,(TEXT("This routine is called by old MDDrn")));
  1609. return(0);
  1610. }
  1612. //
  1613. // @doc OEM
  1614. // @func ULONG | SL_TXIntr | This routine is called from the old MDD
  1615. //   whenever INTR_TX is returned by SL_GetInterruptType (Obselete)
  1616. // 
  1617. // @rdesc None
  1618. //
  1619. VOID
  1620. SL_TxIntr(PVOID pHead) // Hardware Head
  1621. {
  1622.     PS2440_UART_INFO   pHWHead    = (PS2440_UART_INFO)pHead;
  1623.     RETAILMSG(1, (TEXT("SL_TxIntr(From old MDD)n")));
  1624. }
  1626. //
  1627. // @doc OEM
  1628. // @func ULONG | SL_TXIntrEx | This routine is called from the new MDD
  1629. //   whenever INTR_TX is returned by SL_GetInterruptType
  1630. // 
  1631. // @rdesc None
  1632. //
  1633. VOID
  1634. SL_TxIntrEx(
  1635.            PVOID pHead,                // Hardware Head
  1636.            PUCHAR pTxBuffer,          // @parm Pointer to receive buffer
  1637.            ULONG *pBufflen            // @parm In = max bytes to transmit, out = bytes transmitted
  1638.            )
  1639. {
  1640. PS2440_UART_INFO   pHWHead    = (PS2440_UART_INFO)pHead;
  1642. UCHAR byteCount;
  1643. ULONG NumberOfBytes = *pBufflen;
  1644. ULONG rFifoStat, TxFifoCnt;
  1645. unsigned int FifoModeReg;
  1646.    
  1647. RETAILMSG(DEBUGMODE, (TEXT("SL_TxIntrEx rn")));
  1648. // We may be done sending.  If so, just disable the TX interrupts and return to the MDD.  
  1649. if( ! *pBufflen )
  1650. {
  1651. DisEnINT(pHWHead, pHWHead->bINT);
  1652. DisEnSubINT(pHWHead, pHWHead->bTxINT);
  1653. pHWHead->fSW_EnTxINT = FALSE;
  1655. ClearINTPnd(pHWHead, pHWHead->bINT);
  1656. return;
  1657. }
  1658.     
  1659. *pBufflen = 0;  // In case we don't send anything below.
  1661. // Disable xmit intr.  Most 16550s will keep hammering
  1662. // us with xmit interrupts if we don't turn them off
  1663. // Whoever gets the FlushDone will then need to turn
  1664. // TX Ints back on if needed.
  1665. EnterCriticalSection(&(pHWHead->RegCritSec));
  1666. try
  1667. {
  1668. // Need to signal FlushDone for XmitComChar
  1669. PulseEvent(pHWHead->FlushDone);
  1671. pHWHead->CommErrors &= ~CE_TXFULL;
  1673. #if 0
  1674.         // If CTS flow control is desired, check cts. If clear, don't send,
  1675.         // but loop.  When CTS comes back on, the OtherInt routine will
  1676.         // detect this and re-enable TX interrupts (causing Flushdone).
  1677.         // For finest granularity, we would check this in the loop below,
  1678.         // but for speed, I check it here (up to 8 xmit characters before
  1679.         // we actually flow off.
  1680.         if ( pHWHead->dcb.fOutxCtsFlow )
  1681. {
  1682.             // ReadMSR( pHWHead );
  1683.             // We don't need to explicitly read the MSR, since we always enable
  1684.             // IER_MS, which ensures that we will get an interrupt and read
  1685.             // the MSR whenever CTS, DSR, TERI, or DCD change.
  1687.             if (! (pHWHead->MSR & SERIAL_MSR_CTS) )
  1688. {
  1689.                 unsigned char byte;
  1690.                 RETAILMSG (DEBUGMODE, (TEXT("SL_TxIntrEx, flowed off via CTSn") ) );
  1691.                 pHWHead->CTSFlowOff = TRUE;  // Record flowed off state
  1693.                 // We could return a positive value here, which would
  1694.                 // cause the MDD to periodically check the flow control
  1695.                 // status.  However, we don't need to since we know that
  1696.                 // the DCTS interrupt will cause the MDD to call us, and we
  1697.                 // will subsequently fake a TX interrupt to the MDD, causing
  1698.                 // him to call back into PutBytes.
  1699. DisEnINT(pHWHead, pHWHead->bINT);
  1700. DisEnSubINT(pHWHead, pHWHead->bTxINT);
  1701. pHWHead->fSW_EnTxINT = FALSE;
  1703. ClearINTPnd(pHWHead, pHWHead->bINT);
  1705.                 LeaveCriticalSection(&(pHWHead->RegCritSec));
  1706.                 return;
  1707.             }
  1708. }
  1709. #endif
  1710. }
  1712. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  1713. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  1714. {
  1715. // Do nothing.  The worst case is that this was a fluke,
  1716. // and a TX Intr will come right back at us and we will
  1717. // resume transmission.
  1718. }
  1720. LeaveCriticalSection(&(pHWHead->RegCritSec));
  1722. //  OK, now lets actually transmit some data.
  1723. EnterCriticalSection(&(pHWHead->TransmitCritSec));
  1724. EnterCriticalSection(&(pHWHead->RegCritSec));
  1726. FifoModeReg = INREG(pHWHead, rUFCON);
  1728. try
  1729. {
  1730. rFifoStat = INREG(pHWHead,rUFSTAT);
  1731. TxFifoCnt = ((rFifoStat & SER2440_FIFOCNT_MASK_TX) >> 8);
  1733. if (pHWHead->UseIrDA)
  1734. {
  1735. // IR is half-duplex.
  1736. pHWHead->RxDiscard = TRUE;
  1737. DisEnSubINT(pHWHead, pHWHead->bRxINT);
  1738. }
  1740. if (!(rFifoStat & SER2440_FIFOFULL_TX) && (TxFifoCnt <= (SER2440_FIFO_DEPTH_TX-1)))
  1741. {
  1742. byteCount = (unsigned char)(SER2440_FIFO_DEPTH_TX-TxFifoCnt);
  1743. RETAILMSG(DEBUGMODE, (TEXT("SL_TxIntrEx : %d rn"), NumberOfBytes));
  1744. for ( *pBufflen=0; NumberOfBytes && byteCount; NumberOfBytes--, byteCount-- )
  1745. {
  1746. unsigned int i, tmpreg;
  1747. *(pHWHead->pUFTXH) = *pTxBuffer;
  1748. RETAILMSG(DEBUGMODE, (TEXT("SL_TxInt - *pTxBuffer = 0x%x rn"), *pTxBuffer));
  1749. if (FifoModeReg&0x1) // FIFO Mode enabled.
  1750. {
  1751. for ( i = 0; i < 600000; i++ )
  1752. {
  1753. tmpreg = INREG(pHWHead, rUFSTAT);
  1754. //tmpreg & (1<<14) == 1  ->  Fifo full -> waiting...
  1755. //tmpreg & 0x3f00 == 0 -> There is no data to send -> break loop.
  1757. if ( (tmpreg & (1<<14)) == (1<<14) )
  1758. {
  1759. continue;
  1760. }
  1761. else break;
  1762. }
  1763. if ( i == 600000 ) // Time Out Error
  1764. {
  1765. RETAILMSG (1, (TEXT("SL_TxInt : Error : i = %d rn"), i));
  1766. }
  1767. }
  1768. else // FIFO Mode disabled.
  1769. {
  1770. for ( i = 0; i < 600000; i++ )
  1771. {
  1772. tmpreg = INREG(pHWHead, rUTRSTAT);
  1773. if ( tmpreg & 0x2 ) break;
  1774. }
  1775. if ( i == 600000 )
  1776. {
  1777. RETAILMSG (1, (TEXT("SL_TxInt : Error : i = %d rn"), i));
  1778. }
  1779. }
  1781. ++pTxBuffer;
  1782. (*pBufflen)++;
  1783. //irda test...
  1784. //RETAILMSG (1,(TEXT("T ")));
  1785. }
  1786. if (pHWHead->UseIrDA )
  1787. {
  1788. if (FifoModeReg&0x1) // FIFO Mode enabled.
  1789. {
  1790. unsigned int cnt = 0;
  1791. for ( ;; )
  1792. {
  1793. unsigned int tmpreg;
  1794. tmpreg = INREG(pHWHead, rUFSTAT);
  1796. if ( (tmpreg & 0x3f00) == 0) break; // waitint to empty the tx buffer empty...
  1797. if ( cnt++ > 600000 )
  1798. {
  1799. RETAILMSG(DEBUGMODE, (TEXT("SL_TxInt : Reset TX FIFO :  tmpreg = %x rn"), tmpreg));
  1800. SETREG(pHWHead,rUFCON,0x4);    // tx, rx fifo reset
  1801. break;
  1802. }
  1803. }
  1804. RETAILMSG(DEBUGMODE, (TEXT("SL_TxInt : Exit for loop rn")));
  1805. }
  1806. }
  1807. }
  1808. else
  1809. {
  1810. RETAILMSG (1, (TEXT("SL_TxIntrEx: Not Send - rFifoStat[0x%x] TxFifoCnt[0x%x]rn"),
  1811. rFifoStat, TxFifoCnt));
  1812. }
  1814. if (pHWHead->UseIrDA )
  1815. {
  1816. // IR is half-duplex.
  1817. ClearPendingInts( pHWHead );
  1818. EnSubINT(pHWHead, pHWHead->bRxINT);
  1819. pHWHead->RxDiscard = FALSE;
  1820. }
  1822. // Enable xmit intr. We need to do this no matter what, 
  1823. // since the MDD relies on one final interrupt before
  1824. // returning to the application. 
  1825. // ClearPendingInts( pHWHead );
  1827. // Clear TX interrupt pending bit.
  1828. ClearSubINTPnd(pHWHead, pHWHead->bTxINT);
  1829. if ( !(GetSubINTStatus(pHWHead) & pHWHead->bRxINT) )  ClearINTPnd(pHWHead, pHWHead->bINT);
  1831. EnINT(pHWHead, pHWHead->bINT);
  1832. EnSubINT(pHWHead, pHWHead->bTxINT);
  1833. pHWHead->fSW_EnTxINT = TRUE;  // FALSE;
  1834. }
  1835. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  1836. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  1837. {
  1838. // Hmm, not sure what would cause this.  Lets just tell
  1839. // the MDD to go away until we get another TX
  1840. // interrupt.
  1841. }
  1843. LeaveCriticalSection(&(pHWHead->RegCritSec));
  1844. LeaveCriticalSection(&(pHWHead->TransmitCritSec));
  1845. return;
  1846. }
  1848. //
  1849. // @doc OEM
  1850. // @func ULONG | SL_LineIntr | This routine is called from the MDD
  1851. //   whenever INTR_LINE is returned by SL_GetInterruptType.
  1852. // 
  1853. // @rdesc None
  1854. //
  1855. VOID
  1856. SL_LineIntr(PVOID pHead) // Hardware Head
  1857. {
  1858. PS2440_UART_INFO   pHWHead    = (PS2440_UART_INFO)pHead;
  1860. RETAILMSG(DEBUGMODE,(TEXT("INTR_LINE rn")));
  1862. SL_ModemIntr( pHWHead );
  1863. ReadLSR( pHWHead );
  1865. ClearSubINTPnd(pHWHead, pHWHead->bErrINT);
  1866. if ( !(GetSubINTStatus(pHWHead) & pHWHead->bRxINT) ) 
  1867. ClearINTPnd(pHWHead, pHWHead->bINT);
  1869. EnINT(pHWHead, pHWHead->bINT);
  1870. EnSubINT(pHWHead, pHWHead->bErrINT);
  1871. }
  1873. //
  1874. // @doc OEM
  1875. // @func ULONG | SL_OtherIntr | This routine is called from the MDD
  1876. //   whenever INTR_MODEM is returned by SL_GetInterruptType.
  1877. // 
  1878. // @rdesc None
  1879. //
  1880. VOID
  1881. SL_OtherIntr(PVOID pHead) // Hardware Head
  1882. {
  1883.     PS2440_UART_INFO   pHWHead    = (PS2440_UART_INFO)pHead;
  1885.     // S2440 does not have modem interrupt.
  1887.     RETAILMSG(DEBUGMODE,(TEXT("+SL_OtherIntr rn")));
  1889.     ReadMSR( pHWHead );
  1891.     EnterCriticalSection(&(pHWHead->RegCritSec));
  1892.     try
  1893. {
  1894.         // If we are currently flowed off via CTS or DSR, then
  1895.         // we better signal the TX thread when one of them changes
  1896.         // so that TX can resume sending.
  1897.         if ( pHWHead->DSRFlowOff && (pHWHead->vUMSTAT & COM2440_MSR_DSR))
  1898. {
  1899.             RETAILMSG (DEBUGMODE, (TEXT("**********************PutBytes, flowed on via DSRn") ) );
  1900.             pHWHead->DSRFlowOff = FALSE;
  1901.             // DSR is set, so go ahead and resume sending            
  1902.             EnINT(pHWHead, pHWHead->bINT);
  1903.             EnSubINT(pHWHead, pHWHead->bTxINT | pHWHead->bRxINT | pHWHead->bErrINT);
  1904.             pHWHead->fSW_EnTxINT = TRUE;
  1905.             // Then simulate a TX intr to get things moving
  1906.             pHWHead->AddTXIntr = TRUE;
  1907.         }
  1908.         if ( pHWHead->CTSFlowOff && (pHWHead->vUMSTAT & COM2440_MSR_CTS))
  1909. {
  1910.             RETAILMSG(DEBUGMODE, (TEXT("***********************PutBytes, flowed on via CTSn") ) );
  1911.             pHWHead->CTSFlowOff = FALSE;
  1912.             // CTS is set, so go ahead and resume sending
  1913.             EnINT(pHWHead, pHWHead->bINT);
  1914.             EnSubINT(pHWHead, pHWHead->bTxINT | pHWHead->bRxINT | pHWHead->bErrINT);
  1915.             pHWHead->fSW_EnTxINT = TRUE;
  1916.             // Then simulate a TX intr to get things moving
  1917.             pHWHead->AddTXIntr = TRUE;
  1918.         }
  1919.         
  1920.     }
  1921.     except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  1922.             EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
  1923.         // Just exit
  1924.     }
  1926.     LeaveCriticalSection(&(pHWHead->RegCritSec));
  1928.     RETAILMSG(DEBUGMODE,(TEXT("-SL_OtherIntr 0x%Xrn"), pHead));
  1930. }
  1933. //
  1934. // @doc OEM
  1935. // @func ULONG | SL_OtherIntr | This routine is called from the MDD
  1936. //   whenever INTR_MODEM is returned by SL_GetInterruptType.
  1937. // 
  1938. // @rdesc None
  1939. //
  1940. VOID
  1941. SL_ModemIntr(PVOID pHead) // Hardware Head
  1942. {
  1943. PS2440_UART_INFO   pHWHead    = (PS2440_UART_INFO)pHead;
  1944. INTERRUPT_TYPE      it = INTR_NONE;
  1945. ULONG               win32status = 0;
  1947. RETAILMSG (1, (TEXT("SL_ModemIntr - pHWHead->OpenCount %d rn"), pHWHead->OpenCount));
  1948. if ( !pHWHead->OpenCount )
  1949. {
  1950. // We want to indicate a cable event.
  1951. RETAILMSG(1, (TEXT("!pHWHead->OpenCount : 0x%Xrn"), pHWHead->OpenCount));
  1953. if ( IsAPIReady(SH_WMGR))
  1954. {
  1955. RETAILMSG(1, (TEXT("IsAPIReady(SH_WMGR) == truern")));
  1956. CeEventHasOccurred (NOTIFICATION_EVENT_RS232_DETECTED,NULL);
  1957. RETAILMSG(1, (TEXT("Indicating RS232 Cable Eventrn")));
  1958. RETAILMSG(1, (TEXT("Event occurred : NOTIFICATION_EVENT_RS232_DETECTEDrn")));
  1959. }
  1960. }
  1961. else
  1962. {
  1963. RETAILMSG(1,(TEXT("+SL_ModemIntr 0x%Xrn"), pHead));
  1964. SL_OtherIntr(pHead);
  1965. }
  1966. }
  1968. //  
  1969. // @doc OEM
  1970. // @func    ULONG | SL_GetStatus | This structure is called by the MDD
  1971. //   to retrieve the contents of a COMSTAT structure.
  1972. //
  1973. // @rdesc    The return is a ULONG, representing success (0) or failure (-1).
  1974. //
  1975. ULONG
  1976. SL_GetStatus(
  1977.             PVOID    pHead,    // @parm PVOID returned by HWInit.
  1978.             LPCOMSTAT    lpStat    // Pointer to LPCOMMSTAT to hold status.
  1979.             )
  1980. {
  1981.     PS2440_UART_INFO pHWHead = (PS2440_UART_INFO)pHead;
  1982.     ULONG      RetVal  = pHWHead->CommErrors;
  1984. RETAILMSG(1, (TEXT("+SL_GetStatus 0x%Xrn"), pHead));
  1985. pHWHead->CommErrors = 0; // Clear old errors each time
  1987.     if ( lpStat )
  1988. {
  1989. try
  1990. {
  1991.             if (pHWHead->CTSFlowOff)
  1992.                 pHWHead->Status.fCtsHold = 1;
  1993.             else
  1994.                 pHWHead->Status.fCtsHold = 0;
  1996.             if (pHWHead->DSRFlowOff)
  1997.                 pHWHead->Status.fDsrHold = 1;
  1998.             else
  1999.                 pHWHead->Status.fDsrHold = 0;
  2001.             // NOTE - I think what they really want to know here is
  2002.             // the amount of data in the MDD buffer, not the amount
  2003.             // in the UART itself.  Just set to 0 for now since the
  2004.             // MDD doesn't take care of this.
  2005.             pHWHead->Status.cbInQue  = 0;
  2006.             pHWHead->Status.cbOutQue = 0;
  2008.             memcpy(lpStat, &(pHWHead->Status), sizeof(COMSTAT));
  2009.         }
  2010.         except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  2011.                 EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  2012. {
  2013.             RetVal = (ULONG)-1;
  2014.         }        
  2015.     } 
  2016. else
  2017.         RetVal = (ULONG)-1;
  2019.     DEBUGMSG (ZONE_FUNCTION|USERDBG,
  2020.               (TEXT("-SL_GetStatus 0x%Xrn"), pHead));
  2021.     return(RetVal);
  2022. }
  2024. //
  2025. // @doc OEM
  2026. // @func    ULONG | SL_Reset | Perform any operations associated
  2027. //   with a device reset
  2028. //
  2029. // @rdesc    None.
  2030. //
  2031. VOID
  2032. SL_Reset(PVOID   pHead) // @parm PVOID returned by HWInit.
  2033. {
  2034. PS2440_UART_INFO pHWHead = (PS2440_UART_INFO)pHead;
  2036. RETAILMSG(DEBUGMODE,(TEXT("+SL_Reset 0x%Xrn"), pHead));
  2038. memset(&pHWHead->Status, 0, sizeof(COMSTAT));
  2040. EnterCriticalSection(&(pHWHead->RegCritSec));
  2041. try
  2042. {
  2043. DisEnINT(pHWHead, pHWHead->bINT);
  2044. DisEnSubINT(pHWHead, pHWHead->bTxINT);
  2045. // if ( GetSubINTStatus(pHWHead) )
  2046. pHWHead->fSW_EnTxINT = FALSE;
  2047. pHWHead->RxDiscard = FALSE;
  2048. }
  2050. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  2051. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  2052. {
  2053. // Do nothing
  2054. }
  2056. LeaveCriticalSection(&(pHWHead->RegCritSec));
  2058. DEBUGMSG (ZONE_FUNCTION, (TEXT("-SL_Reset 0x%Xrn"), pHead));
  2059. }
  2061. //
  2062. // @doc OEM
  2063. // @func    VOID | SL_GetModemStatus | Retrieves modem status.
  2064. //
  2065. // @rdesc    None.
  2066. //
  2067. VOID
  2068. SL_GetModemStatus(
  2069.                  PVOID   pHead,        // @parm PVOID returned by HWInit.
  2070.                  PULONG  pModemStatus    // @parm PULONG passed in by user.
  2071.                  )
  2072. {
  2073. PS2440_UART_INFO pHWHead = (PS2440_UART_INFO)pHead;
  2074. UINT8 ubModemStatus;
  2076. RETAILMSG(DEBUGMODE,  (TEXT("SL_GetModemStatus:rn")));
  2078. ReadMSR( pHWHead );
  2079. ubModemStatus = (unsigned char)pHWHead->vUMSTAT;
  2080. RETAILMSG(DEBUGMODE,  (TEXT("SL_GetModemStatus: ubModemStatus = 0x%xrn"), ubModemStatus));
  2082. if ( ubModemStatus & COM2440_MSR_CTS )
  2083. *pModemStatus |= MS_CTS_ON;
  2085. if ( ubModemStatus & COM2440_MSR_DSR )
  2086. {
  2087. *pModemStatus |= MS_DSR_ON;
  2088. *pModemStatus |= MS_RLSD_ON;
  2089. }
  2091. RETAILMSG(DEBUGMODE,(TEXT("-SL_GetModemStatus 0x%X (stat x%X) rn"), pHead, *pModemStatus));
  2092. return;
  2093. }
  2095. //
  2096. // @doc OEM
  2097. // @func    VOID | SL_PurgeComm | Purge RX and/or TX
  2098. // 
  2099. // @rdesc    None.
  2100. //
  2102. VOID
  2103. SL_PurgeComm(
  2104.             PVOID   pHead,        // @parm PVOID returned by HWInit.
  2105.             DWORD   fdwAction        // @parm Action to take. 
  2106.             )
  2107. {
  2108. PS2440_UART_INFO pHWHead = (PS2440_UART_INFO)pHead;
  2110. RETAILMSG(DEBUGMODE,(TEXT("+SL_PurgeComm 0x%Xrn"), fdwAction));
  2111. return;
  2112. }
  2114. //
  2115. // @doc OEM
  2116. // @func    BOOL | SL_XmitComChar | Transmit a char immediately
  2117. // 
  2118. // @rdesc    TRUE if succesful
  2119. //
  2120. BOOL
  2121. SL_XmitComChar(
  2122.               PVOID   pHead,    // @parm PVOID returned by HWInit.
  2123.               UCHAR   ComChar   // @parm Character to transmit. 
  2124.               )
  2125. {
  2126. PS2440_UART_INFO pHWHead = (PS2440_UART_INFO)pHead;
  2127. ULONG       rFifoStat, TxFifoCnt; 
  2129. RETAILMSG (DEBUGMODE,(TEXT("+SL_XmitComChar 0x%Xrn"), pHead));
  2130. // Get critical section, then transmit when buffer empties
  2131. RETAILMSG(DEBUGMODE, (TEXT("XmitComChar wait for CritSec %x.rn"),&(pHWHead->TransmitCritSec)));
  2132. EnterCriticalSection(&(pHWHead->TransmitCritSec));
  2133. RETAILMSG(DEBUGMODE, (TEXT("XmitComChar got CritSec %x.rn"),&(pHWHead->TransmitCritSec)));
  2134. try
  2135. {
  2136. while ( TRUE ) // We know THR will eventually empty
  2137. {
  2138. EnterCriticalSection(&(pHWHead->RegCritSec));
  2140. // Write the character if we can
  2141. rFifoStat = INREG(pHWHead,rUFSTAT);
  2142. TxFifoCnt = (rFifoStat & SER2440_FIFOCNT_MASK_TX) >> 8;
  2144. if (!(rFifoStat & SER2440_FIFOFULL_TX) && (TxFifoCnt < (SER2440_FIFO_DEPTH_TX-1)))
  2145. {
  2146. // FIFO is empty, send this character
  2147. //OUTB(pHWHead, pData, ComChar);
  2148. OUTREG(pHWHead,rUTXH,ComChar);
  2149. // Make sure we release the register critical section
  2150. LeaveCriticalSection(&(pHWHead->RegCritSec));
  2152. RETAILMSG(DEBUGMODE, (TEXT("XmitComChar wrote x%Xrn"),ComChar));
  2153. break;
  2154. }
  2156. // If we couldn't write the data yet, then wait for a
  2157. // TXINTR to come in and try it again.
  2159. // Enable xmit intr.
  2160. EnINT(pHWHead, pHWHead->bINT);
  2161. EnSubINT(pHWHead, pHWHead->bTxINT | pHWHead->bRxINT | pHWHead->bErrINT);
  2162. pHWHead->fSW_EnTxINT = TRUE;
  2163. LeaveCriticalSection(&(pHWHead->RegCritSec));
  2165. // Wait until the txintr has signalled.
  2166. DEBUGMSG (ZONE_WRITE, (TEXT("XmitComChar WaitIntr x%Xrn"),
  2167. pHWHead->FlushDone));
  2168. WaitForSingleObject(pHWHead->FlushDone, (ULONG)1000);
  2169. }
  2170. }
  2171. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  2172. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
  2173. {
  2174. // Make sure we release the register critical section
  2175. LeaveCriticalSection(&(pHWHead->RegCritSec));
  2176. }
  2178. LeaveCriticalSection(&(pHWHead->TransmitCritSec));
  2180. DEBUGMSG (ZONE_WRITE, (TEXT("XmitComChar released CritSec %x.rn"), &(pHWHead->TransmitCritSec)));
  2182. DEBUGMSG (ZONE_FUNCTION, (TEXT("-SL_XmitComChar 0x%Xrn"), pHead));
  2184. return(TRUE);
  2185. }
  2187. //
  2188. // @doc OEM
  2189. // @func    BOOL | SL_PowerOff | Perform powerdown sequence.
  2190. // 
  2191. // @rdesc    TRUE if succesful
  2192. //
  2193. VOID
  2194. SL_PowerOff(PVOID   pHead) // @parm    PVOID returned by HWInit.
  2195. {
  2196. PS2440_UART_INFO   pHWHead   = (PS2440_UART_INFO)pHead;
  2198. RETAILMSG(0, (TEXT("SL_PowerOff rn")));
  2200. if ( !pHWHead->UseIrDA )
  2201. {
  2202. // DeAssert DTR
  2203. *(pHWHead->rDTRport) |= (1<<(pHWHead->DtrPortNum));
  2205. // DeAssert RTS
  2206. #if USE_AFC
  2207. *(pHWHead->rRTSport) |= (1<<(pHWHead->RtsPortNum));
  2208. #else
  2209. CLEARREG(pHWHead, rUMCON, SER2440_RTS);
  2210. #endif
  2211. }
  2213. pHWHead->sULCON = INREG(pHWHead, rULCON);
  2214. pHWHead->sUCON  = INREG(pHWHead, rUCON);
  2215. pHWHead->sUMCON = INREG(pHWHead, rUMCON);
  2216. pHWHead->sUFCON = INREG(pHWHead, rUFCON);        
  2217. pHWHead->sINTstat = (*(pHWHead->UART_INTSUBMASK) & (pHWHead->bTxINT | pHWHead->bRxINT));
  2218. }
  2220. //
  2221. // @doc OEM
  2222. // @func    BOOL | SL_PowerOn | Perform poweron sequence.
  2223. // 
  2224. // @rdesc    TRUE if succesful
  2225. //
  2226. VOID
  2227. SL_PowerOn(PVOID   pHead) // @parm    PVOID returned by HWInit.
  2228. {
  2229. PS2440_UART_INFO pHWHead = (PS2440_UART_INFO)pHead;
  2231. // Restore any registers that we need
  2232. RETAILMSG(DEBUGMODE, (TEXT("SL_PowerOn rn")));
  2234. if ( !pHWHead->UseIrDA )
  2235. {
  2236. // Assert DTR
  2237. *(pHWHead->rDTRport) &= ~(1<<(pHWHead->DtrPortNum));
  2239. // Assert RTS
  2240. #if USE_AFC
  2241. *(pHWHead->rRTSport) &= ~(1<<(pHWHead->RtsPortNum));
  2242. #else
  2243. SETREG(pHWHead, rUMCON, SER2440_RTS);
  2244. #endif
  2245. }
  2247. // In power handler context, so don't try to do a critical section
  2248. OUTREG(pHWHead, rULCON, pHWHead->sULCON); 
  2249. OUTREG(pHWHead, rUCON,  pHWHead->sUCON); 
  2250. OUTREG(pHWHead, rUMCON, pHWHead->sUMCON); 
  2251. OUTREG(pHWHead, rUFCON, pHWHead->sUFCON); 
  2253. if((pHWHead->sINTstat) & (pHWHead->bTxINT))
  2254. {
  2255. EnINT(pHWHead, pHWHead->bINT);
  2256. EnSubINT(pHWHead, pHWHead->bTxINT);
  2257. pHWHead->fSW_EnTxINT = TRUE;
  2258. pHWHead->RxDiscard = FALSE;
  2259. }
  2261. if((pHWHead->sINTstat) & (pHWHead->bRxINT))
  2262. {
  2263. EnINT(pHWHead, pHWHead->bINT);
  2264. EnSubINT(pHWHead, pHWHead->bRxINT);
  2265. }
  2267. // And we didn't save the Divisor Reg, so set baud rate
  2268. // But don't call SL_SetBaud, since it does DebugMsg.
  2269. // Call our internal function instead.  Can't acquire
  2270. // the RegCritSec, but shouldn't really need to since
  2271. // we are in power context.
  2272. SetBaudRate( pHWHead, pHWHead->dcb.BaudRate );
  2274. return;
  2276. pHWHead->EventCallback( pHWHead->pMddHead, EV_POWER );
  2278. }
  2280. //
  2281. // @doc OEM
  2282. // @func    BOOL | SL_SetDCB | Sets new values for DCB.  This
  2283. // routine gets a DCB from the MDD.  It must then compare
  2284. // this to the current DCB, and if any fields have changed take
  2285. // appropriate action.
  2286. // 
  2287. // @rdesc    BOOL
  2288. //
  2289. BOOL
  2290. SL_SetDCB(
  2291.          PVOID   pHead,        // @parm    PVOID returned by HWInit.
  2292.          LPDCB   lpDCB       // @parm    Pointer to DCB structure
  2293.          )
  2294. {
  2295. PS2440_UART_INFO pHWHead = (PS2440_UART_INFO)pHead;
  2296. BOOL bRet;
  2298. bRet = TRUE;
  2300. RETAILMSG(DEBUGMODE,(TEXT("SL_SetDCB : BaudRate is %drn"), lpDCB->BaudRate));
  2301. RETAILMSG(DEBUGMODE,(TEXT("SL_SetDCB : Set ByteSize is %drn"), lpDCB->ByteSize));
  2302. RETAILMSG(DEBUGMODE,(TEXT("SL_SetDCB : Set Parity is %drn"), lpDCB->Parity));
  2303. RETAILMSG(DEBUGMODE,(TEXT("SL_SetDCB : Set StopBits is %drn"), lpDCB->StopBits));
  2305. // If the device is open, scan for changes and do whatever
  2306. // is needed for the changed fields.  if the device isn't
  2307. // open yet, just save the DCB for later use by the open.
  2308. if ( pHWHead->OpenCount )
  2309. {
  2310. // Note, fparity just says whether we should check
  2311. // receive parity.  And the 16550 won't let us NOT
  2312. // check parity if we generate it.  So this field
  2313. // has no effect on the hardware.
  2315. if ( lpDCB->BaudRate != pHWHead->dcb.BaudRate )
  2316. {
  2317. RETAILMSG(DEBUGMODE,(TEXT("SL_SetDCB : Set BaudRate to %drn"), lpDCB->BaudRate));
  2318. bRet = SL_SetBaudRate( pHWHead, lpDCB->BaudRate );
  2319. }
  2321. if ( bRet && (lpDCB->ByteSize != pHWHead->dcb.ByteSize ))
  2322. {
  2323. RETAILMSG(DEBUGMODE,(TEXT("SL_SetDCB : Set ByteSize to %drn"), lpDCB->ByteSize));
  2324. bRet = SL_SetByteSize( pHWHead, lpDCB->ByteSize );
  2325. }
  2327. if ( bRet && (lpDCB->Parity != pHWHead->dcb.Parity ))
  2328. {
  2329. RETAILMSG(DEBUGMODE,(TEXT("SL_SetDCB : Set Parity to %drn"), lpDCB->Parity));
  2330. bRet = SL_SetParity( pHWHead, lpDCB->Parity );
  2331. }
  2333. if ( bRet && (lpDCB->StopBits != pHWHead->dcb.StopBits ))
  2334. {
  2335. RETAILMSG(DEBUGMODE,(TEXT("SL_SetDCB : Set StopBits to %drn"), lpDCB->StopBits));
  2336. bRet = SL_SetStopBits( pHWHead, lpDCB->StopBits );
  2337. }
  2339. // Don't worry about fOutxCtsFlow.  It is a flag which
  2340. // will be examined every time we load the TX buffer.
  2341. // No special action required here.
  2342. }
  2344. if (bRet)
  2345. {
  2346. // Now that we have done the right thing, store this DCB
  2347. pHWHead->dcb = *lpDCB;
  2348. }
  2350. RETAILMSG(DEBUGMODE,(TEXT("-SL_SetDCB 0x%Xrn"), pHead));
  2352. return(bRet);
  2353. }
  2355. //
  2356. // @doc OEM
  2357. // @func    BOOL | SL_SetCommTimeouts | Sets new values for the
  2358. // CommTimeouts structure. routine gets a DCB from the MDD.  It
  2359. // must then compare this to the current DCB, and if any fields
  2360. // have changed take appropriate action.
  2361. // 
  2362. // @rdesc    ULONG
  2363. //
  2364. ULONG
  2365. SL_SetCommTimeouts(
  2366.                   PVOID   pHead,        // @parm    PVOID returned by HWInit.
  2367.                   LPCOMMTIMEOUTS   lpCommTimeouts // @parm Pointer to CommTimeout structure
  2368.                   )
  2369. {
  2370. PS2440_UART_INFO pHWHead = (PS2440_UART_INFO)pHead;
  2371. ULONG retval = 0;
  2373. RETAILMSG(DEBUGMODE,(TEXT("+SL_SetCommTimeout 0x%Xrn"), pHead));
  2374. // ShowSerialRegisters(pHead);
  2376. // OK, first check for any changes and act upon them
  2377. if ( lpCommTimeouts->WriteTotalTimeoutMultiplier !=
  2378. pHWHead->CommTimeouts.WriteTotalTimeoutMultiplier )
  2379. {
  2381. }
  2383. // Now that we have done the right thing, store this DCB
  2384. pHWHead->CommTimeouts = *lpCommTimeouts;
  2386. RETAILMSG(DEBUGMODE,(TEXT("-SL_SetCommTimeout 0x%Xrn"), pHead));
  2388. return(retval);
  2389. }
  2393. //
  2394. //  @doc OEM
  2395. //  @func    BOOL | SL_Ioctl | Device IO control routine.  
  2396. //  @parm DWORD | dwOpenData | value returned from COM_Open call
  2397. //    @parm DWORD | dwCode | io control code to be performed
  2398. //    @parm PBYTE | pBufIn | input data to the device
  2399. //    @parm DWORD | dwLenIn | number of bytes being passed in
  2400. //    @parm PBYTE | pBufOut | output data from the device
  2401. //    @parm DWORD | dwLenOut |maximum number of bytes to receive from device
  2402. //    @parm PDWORD | pdwActualOut | actual number of bytes received from device
  2403. //
  2404. //    @rdesc        Returns TRUE for success, FALSE for failure
  2405. //
  2406. //  @remark  The MDD will pass any unrecognized IOCTLs through to this function.
  2407. //
  2408. BOOL
  2409. SL_Ioctl(PVOID pHead, DWORD dwCode,PBYTE pBufIn,DWORD dwLenIn,
  2410.          PBYTE pBufOut,DWORD dwLenOut,PDWORD pdwActualOut)
  2411. {
  2412. //    PSER_INFO pHWHead = (PSER_INFO)pHead;
  2413. PS2440_UART_INFO pHWHead = (PS2440_UART_INFO)pHead;
  2414.     DWORD dwErr = ERROR_SUCCESS;    
  2415.     BOOL  bRc = TRUE;
  2416.     
  2417.     switch (dwCode)
  2418. {
  2419.         //
  2420.         // Power Management
  2421.         //
  2422.         case IOCTL_POWER_CAPABILITIES: 
  2423.         {
  2424.             PPOWER_CAPABILITIES ppc;
  2425.             
  2426.             if ( !pdwActualOut || !pBufOut || (dwLenOut < sizeof(POWER_CAPABILITIES)))
  2427. {
  2428.                 bRc = FALSE;
  2429.                 dwErr = ERROR_INVALID_PARAMETER;
  2430.                 break;
  2431.             }
  2432.             
  2433.             ppc = (PPOWER_CAPABILITIES)pBufOut;
  2434.             
  2435.             memset(ppc, 0, sizeof(POWER_CAPABILITIES));
  2438. // ppc->DeviceDx = 0x11; // support D0, D4
  2439. ppc->DeviceDx = 0x11; // support D0-D2, D4 (no D3)
  2441.             // no wake
  2442.             // no inrush
  2444.             // Report our power consumption in uAmps rather than mWatts. 
  2445.             ppc->Flags = POWER_CAP_PREFIX_MICRO | POWER_CAP_UNIT_AMPS;
  2446.             
  2447.             // (UART @ 1.2 mA + IR Transmitter LED ON  @ 32 mA) = 33.2 mA = 33200 uA @ 200 MHz
  2448.             //                  IR Transmitter LED OFF @ 1.5 nA
  2449.             ppc->Power[D0] = 33200;
  2450.             
  2451.             *pdwActualOut = sizeof(POWER_CAPABILITIES);
  2452.         } 
  2453. break;
  2455.         case IOCTL_POWER_SET: 
  2456.         {
  2457.             CEDEVICE_POWER_STATE NewDx;
  2458.             
  2459.             if ( !pdwActualOut || !pBufOut || (dwLenOut < sizeof(CEDEVICE_POWER_STATE)))
  2460. {
  2461.                 bRc = FALSE;
  2462.                 dwErr = ERROR_INVALID_PARAMETER;
  2463.                 break;
  2464.             }
  2465.             
  2466.             NewDx = *(PCEDEVICE_POWER_STATE)pBufOut;
  2468.             if ( VALID_DX(NewDx))
  2469. {
  2470.                 // grab the CS since the normal Xxx_PowerXxx can not.
  2471.                 EnterCriticalSection( &pHWHead->RegCritSec );
  2473.                 switch ( NewDx )
  2474. {
  2475.                     case D0:
  2476.                         SerPowerOn(pHead);
  2477.                         break;
  2479.                     default:
  2480.                         SerPowerOff(pHead);
  2481.                         break;
  2482.                 }
  2484.                 // return our Dx
  2485.                 *(PCEDEVICE_POWER_STATE)pBufOut = pHWHead->Dx;
  2486.                     
  2487.                 RETAILMSG(1, (TEXT("IrDA: IOCTL_POWER_SET: D%u => D%u rn"),
  2488.                     NewDx, pHWHead->Dx));
  2489.                 
  2490.                 LeaveCriticalSection( &pHWHead->RegCritSec );
  2491.                 
  2492.                 *pdwActualOut = sizeof(CEDEVICE_POWER_STATE);
  2493.             }
  2494. else
  2495. {
  2496.                 bRc = FALSE;
  2497.                 dwErr = ERROR_INVALID_PARAMETER;
  2498.             }
  2499.             
  2500.         } 
  2501. break;
  2503.         case IOCTL_POWER_GET: 
  2504.             if ( !pdwActualOut || !pBufOut || (dwLenOut < sizeof(CEDEVICE_POWER_STATE)))
  2505. {
  2506.                 bRc = FALSE;
  2507.                 dwErr = ERROR_INVALID_PARAMETER;
  2508.                 break;
  2509.             }
  2511.             *(PCEDEVICE_POWER_STATE)pBufOut = pHWHead->Dx;
  2513.             DEBUGMSG(1, (TEXT("IrDA: IOCTL_POWER_GET: D%u rn"), pHWHead->Dx));
  2515.             *pdwActualOut = sizeof(CEDEVICE_POWER_STATE);
  2516.             
  2517. break;
  2519.         default:
  2520.             bRc = FALSE;
  2521.             DEBUGMSG (ZONE_FUNCTION, (TEXT(" Unsupported ioctl 0x%Xrn"), dwCode));
  2522.             break;            
  2523.     }
  2524.     
  2525.     return(bRc);
  2526. }