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

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

Windows CE

开发平台：

Windows_Unix

SER2440_SER.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_SER.C
  15. Abstract:  
  17. Notes: 
  18. --*/
  20. #define EXAMINE_BOOTARGS
  21. #define DEBUGMODE 0
  23. #include <windows.h>
  24. #include <types.h>
  25. #include <ceddk.h>
  26. #include <memory.h>
  27. #include <serhw.h>
  28. #include <ser16550.h>
  29. #include <hw16550.h>
  30. #include <nkintr.h>
  31. #include <devload.h>
  32. #include <windev.h>
  33. #include <notify.h>
  34. #include <pm.h>
  36. #include "S2440.h"
  38. #define USERDBG        1
  40. #ifdef EXAMINE_BOOTARGS
  41. #include <bootarg.h>
  42. #include <oalintr.h>
  43. #include <pc.h>
  44. #endif
  46. #include <ser2440.h>
  48. #undef ZONE_INIT
  49. #include <serdbg.h>
  51. static BOOL IRDA;
  53. #define BAUD_TABLE_SIZE 23
  54. static const
  55. PAIRS   BaudPairs[BAUD_TABLE_SIZE] =    {
  56. {50,        2307},
  57. {75,        1538},
  58. {110,       1049},
  59. {135,       858},
  60. {150,       769},
  61. {300,       384},
  62. {600,       192},
  63. {1200,      96},
  64. {1800,      64},
  65. {2000,      58},
  66. {2400,      48},
  67. {3600,      32},
  68. {4800,      24},
  69. {7200,      16},
  70. {9600,      12},
  71. {12800,     9},
  72. {14400,     8},
  73. {19200,     6},
  74. {23040,     5},
  75. {28800,     4},
  76. {38400,     3},
  77. {57600,     2},
  78. {115200,    1}
  79. };
  81. static const LOOKUP_TBL  BaudTable = {BAUD_TABLE_SIZE, (PAIRS *) BaudPairs};
  83. // Miscellaneous internal routines.
  84. PUCHAR
  85. static
  86. Ser_InternalMapRegisterAddresses(ULONG HWAddress, ULONG Size)
  87. {
  88. PUCHAR              ioPortBase; 
  89. ULONG               inIoSpace      = 1;
  90. PHYSICAL_ADDRESS    ioPhysicalBase = { HWAddress, 0};
  92. RETAILMSG(DEBUGMODE, (TEXT("+ Ser_InternalMapRegisterAddresses : HalTranslateBusAddressrn")));
  93. if ( HalTranslateBusAddress(Isa, 0, ioPhysicalBase, &inIoSpace, &ioPhysicalBase))
  94. {
  95. DEBUGMSG(1, (TEXT("Ser_InternalMapRegisterAddresses : HalTranslateBusAddress - OKrn")));
  96. if ( !inIoSpace )
  97. {
  98. DEBUGMSG(1, (TEXT("Ser_InternalMapRegisterAddresses : ! IO Spacern")));
  99. if ( (ioPortBase = (PUCHAR)MmMapIoSpace(ioPhysicalBase, Size, FALSE)) == NULL )
  100. {
  101. // We may as well not continue
  102. DEBUGMSG(ZONE_INIT | ZONE_ERROR, (TEXT("Error mapping I/O Portsrn")));
  103. return (NULL);
  104. }
  105. }
  106. else
  107. {
  108. DEBUGMSG(1, (TEXT("Ser_InternalMapRegisterAddresses : IO Spacern")));
  109. ioPortBase = (PUCHAR)ioPhysicalBase.LowPart;
  110. }
  111. }
  112. else
  113. {
  114. DEBUGMSG(ZONE_INIT | ZONE_ERROR, (TEXT("Error translating I/O Ports.rn")));
  115. return (NULL);
  116. }
  118. RETAILMSG(DEBUGMODE, (TEXT("- Ser_InternalMapRegisterAddresses : %drn"),ioPortBase ));
  119. return (ioPortBase);
  120. }
  122. static
  123. BOOL
  124. SerSetIRBaudRate(
  125. PSER_INFO   pHWHead,
  126. ULONG baud     // @parm     UINT16 what is the baud rate
  127. )
  128. {
  129. PS2440_UART_INFO   pHWHead2   = (PS2440_UART_INFO)pHWHead;
  131. RETAILMSG(DEBUGMODE, (TEXT("IRDA : +SerSetIRBaudRatern")));    
  132. DEBUGMSG (ZONE_INIT|1, (TEXT("Serial set IR Baud %drn"), baud));
  134. if ( (pHWHead2->s2440SerReg->rUCON & CS_MASK) == CS_PCLK )
  135. {
  136. RETAILMSG (1, (TEXT("USE CS_PCLKrn")));    
  137. OUTREG(pHWHead2,rUBRDIV,( (int)(S2440PCLK/16.0/baud) -1 ));
  138. }
  139. else // if  ( (pHWHead2->s2440SerReg->rUCON & CS_MASK) == CS_UCLK )
  140. {
  141. RETAILMSG (1, (TEXT("USE CS_UCLKrn")));    
  142. OUTREG(pHWHead2,rUBRDIV,( (int)(S2440UCLK/16.0/baud) -1 ));
  143. }
  145. RETAILMSG(DEBUGMODE, (TEXT("IRDA : -SerSetIRBaudRatern")));
  146. return (TRUE);
  147. }
  149. /*
  150.  *  NOTE : The caller should have set pHWHead->fIRMode.  It is not
  151.  * set here, since power on/off may need to temporarily disable
  152.  * the intefaces without actually overwriting the current recorded
  153.  * mode.
  154.  */
  155. static
  156. void
  157. SerSetOutputMode(
  158.                 PSER_INFO   pHWHead,
  159.                 BOOL UseIR,     // @parm     BOOL Should we use IR interface
  160.                 BOOL Use9Pin    // @parm     BOOL Should we use Wire interface
  161.                 )
  162. {
  163. // If you support IR, here you need to set the interface to either IR mode
  164. // or normal serial. Note that it is possible for both BOOls to
  165. // be false (i.e. power down), but never for both to be TRUE.
  167. PS2440_UART_INFO   pHWHead2   = (PS2440_UART_INFO)pHWHead;
  169. RETAILMSG (DEBUGMODE, (TEXT("+SerSetOutputModern")));
  171. if(UseIR)  
  172. SETREG(pHWHead2,rULCON,SER2440_IRMODE_MASK);   // Infra-red mode enable.
  173. else
  174. CLEARREG(pHWHead2,rULCON,SER2440_IRMODE_MASK);   // Infra-red mode enable.
  176. RETAILMSG(DEBUGMODE, (TEXT("-SerSetOutputModern")));
  177. }
  181. /*++
  182. *******************************************************************************
  183. Routine:
  185.     Ser_GetRegistryData
  187. Description:
  189.     Take the registry path provided to COM_Init and use it to find this 
  190.     requested comm port's DeviceArrayIndex, teh IOPort Base Address, and the
  191.    Interrupt number.
  192.    
  193. Arguments:
  195.     LPCTSTR regKeyPath the registry path passed in to COM_Init.
  197. Return Value:
  199.     -1 if there is an error.
  201. *******************************************************************************
  202. --*/
  203. BOOL
  204. Ser_GetRegistryData(PSER_INFO pHWHead, LPCTSTR regKeyPath)
  205. {
  206. #define GCI_BUFFER_SIZE 256   
  208. LONG    regError;
  209. HKEY    hKey;
  210. DWORD   dwDataSize = GCI_BUFFER_SIZE;
  212. RETAILMSG(DEBUGMODE, (TEXT("Try to open %srn"), regKeyPath));
  214. // We've been handed the name of a key in the registry that was generated
  215. // on the fly by device.exe.  We're going to open that key and pull from it
  216. // a value that is the name of this serial port's real key.  That key
  217. // will have the DeviceArrayIndex that we're trying to find.  
  218. hKey = OpenDeviceKey(regKeyPath);
  219. if ( hKey == NULL )
  220. {
  221. DEBUGMSG(ZONE_INIT | ZONE_ERROR,(TEXT("Failed to open device keyrn")));
  222. return ( FALSE );        
  223. }
  225. // Okay, we're finally ready to try and load our registry data.
  226. dwDataSize = PC_REG_DEVINDEX_VAL_LEN;
  227. regError = RegQueryValueEx(
  228. hKey, 
  229. PC_REG_DEVINDEX_VAL_NAME, 
  230. NULL, 
  231. NULL,
  232. (LPBYTE)(&pHWHead->dwDevIndex), 
  233. &dwDataSize);
  235. if ( regError == ERROR_SUCCESS )
  236. {
  237. dwDataSize = PC_REG_IRQ_VAL_LEN;
  238. regError = RegQueryValueEx(
  239. hKey, 
  240. PC_REG_IRQ_VAL_NAME, 
  241. NULL, 
  242. NULL,
  243. (LPBYTE)(&pHWHead->dwIRQ), 
  244. &dwDataSize);
  245. }
  247. if ( regError == ERROR_SUCCESS )
  248. {
  249. dwDataSize = PC_REG_IOBASE_VAL_LEN;
  250. regError = RegQueryValueEx(
  251. hKey, 
  252. PC_REG_IOBASE_VAL_NAME, 
  253. NULL, 
  254. NULL,
  255. (LPBYTE)(&pHWHead->dwIOBase), 
  256. &dwDataSize);
  257. }
  259. if ( regError == ERROR_SUCCESS )
  260. {
  261. dwDataSize = PC_REG_IOLEN_VAL_LEN;
  262. regError = RegQueryValueEx(
  263. hKey, 
  264. PC_REG_IOLEN_VAL_NAME, 
  265. NULL, 
  266. NULL,
  267. (LPBYTE)(&pHWHead->dwIOLen), 
  268. &dwDataSize);
  269. }
  271. RegCloseKey (hKey);
  273. if ( regError != ERROR_SUCCESS )
  274. {
  275. RETAILMSG(DEBUGMODE, (TEXT("Failed to get serial registry values, Error 0x%Xrn"),regError));
  276. return ( FALSE );
  277. }
  279. RETAILMSG (DEBUGMODE,(TEXT("SerInit - Devindex %d, IRQ %d, IOB %X, IOLen %X rn"),
  280. pHWHead->dwDevIndex, pHWHead->dwIRQ, pHWHead->dwIOBase, pHWHead->dwIOLen));
  282. return ( TRUE ); 
  283. }
  287. /*
  288.  @doc OEM 
  289.  @func PVOID | SerInit | Initializes device identified by argument.
  290.  *  This routine sets information controlled by the user
  291.  *  such as Line control and baud rate. It can also initialize events and
  292.  *  interrupts, thereby indirectly managing initializing hardware buffers.
  293.  *  Exported only to driver, called only once per process.
  294.  *
  295.  @rdesc The return value is a PVOID to be passed back into the HW
  296.  dependent layer when HW functions are called.
  297.  */
  298. static
  299. PVOID
  300. SerInit(
  301. BOOL bIR,
  302.        ULONG   Identifier, // @parm Device identifier.
  303.        PVOID   pMddHead,   // @parm First argument to mdd callbacks.
  304.        PHWOBJ  pHWObj      // @parm Pointer to our own HW OBJ for this device
  305.        )
  306. {
  307. PSER_INFO pHWHead;
  309. #ifdef EXAMINE_BOOTARGS    
  310. PVOID *ppBootArgs     = NULL;  // Pointer to pointer to bootargs.
  311. PHYSICAL_ADDRESS PhysicalAddress = {0,0};
  312. #endif    
  314. // Note on defaults.  While the PC typcially considers COM1 to be at 
  315. // 3F8, irq4 and COM2 to be 2F8, irq3, NKPC uses COM1 internally for the
  316. // debugger.  So, when NK tells me to start "COM1" it really means the
  317. // first one that's available, which is what the PC calls COM2.  Confused?
  318. // The end result is that COM1 on NK is what the PC considers to be COM2.
  319. // But wait, there's more.  On a Puzzle, the debugger is on COM2 and the
  320. // COM1 for NK is ACTUALLY COM1.  So PCs need 2F8 for their port base
  321. // and Puzzles need 3F8.
  323. RETAILMSG(DEBUGMODE, (TEXT("SerInit - !!! rn")));
  325. // Allocate for our main data structure and one of it's fields.
  326. pHWHead = (PSER_INFO)LocalAlloc( LMEM_ZEROINIT|LMEM_FIXED, sizeof(SER_INFO) );
  327. if ( !pHWHead )
  328. return( NULL );
  330. if ( ! Ser_GetRegistryData(pHWHead, (LPCTSTR)Identifier) )
  331. {
  332. DEBUGMSG (ZONE_INIT|ZONE_ERROR, (TEXT("SerInit - Unable to read registry data.  Failing Init !!! rn")));
  333. goto ALLOCFAILED;
  334. }
  336. pHWHead->pBaseAddress = Ser_InternalMapRegisterAddresses(pHWHead->dwIOBase, pHWHead->dwIOLen);
  338. #ifdef EXAMINE_BOOTARGS        
  339. // Allocate a pointer to our bootargs since they may indicate that we don't have
  340. // access to the hardware resource.
  342. // First, map the bootargs pointer itself.  Note that I'm reading/writing
  343. // directly on the physical address.  I can do this since I know this is CEPC and 
  344. // know the adress is not in IO space.  For OEM platforms you would want to do
  345. // HalTranslateBusAddress first.
  346. PhysicalAddress.LowPart = BOOT_ARG_PTR_LOCATION & ~0x80000000;
  348. if ( ppBootArgs = MmMapIoSpace(PhysicalAddress, sizeof( PVOID ), TRUE ) )
  349. {
  350. DEBUGMSG (ZONE_INIT, (TEXT("SerInit - ppBootArgs (%X) at %Xrn"), PhysicalAddress.LowPart, ppBootArgs ));
  351. }
  352. else
  353. {
  354. DEBUGMSG (ZONE_INIT | ZONE_ERROR, (TEXT("SerInit - ppBootArgs failure at %Xrn"), PhysicalAddress.LowPart ));
  355. goto ALLOCFAILED;
  356. }
  358. // Now map the bootargs structure itself
  359. PhysicalAddress.LowPart = (DWORD) *ppBootArgs;
  360. if ( pHWHead->pBootArgs = MmMapIoSpace(PhysicalAddress, sizeof(BOOT_ARGS), TRUE ) )
  361. {
  362. DEBUGMSG (ZONE_INIT, (TEXT("SerInit - pBootArgs (%X) at %Xrn"), PhysicalAddress.LowPart, pHWHead->pBootArgs ));
  363. }
  364. else
  365. {
  366. DEBUGMSG (ZONE_INIT | ZONE_ERROR, (TEXT("SerInit - pBootArgs failure at %Xrn"), (DWORD)PhysicalAddress.LowPart));
  367. goto ALLOCFAILED;
  368. }
  370. // We no longer need ppBootArgs
  371. MmUnmapIoSpace( ppBootArgs, sizeof(PVOID) );
  372. #endif // EXAMINE_BOOTARGS
  374. pHWHead->pMddHead     = pMddHead;
  375. pHWHead->pHWObj = pHWObj;
  376. pHWHead->cOpenCount   = 0;
  378. RETAILMSG(DEBUGMODE,(TEXT("SerInit - IRQ %d = SYSINTR %drn"),
  379. pHWHead->dwIRQ, pHWHead->pHWObj->dwIntID));
  381. // Set up our Comm Properties data    
  382. pHWHead->CommProp.wPacketLength       = 0xffff;
  383. pHWHead->CommProp.wPacketVersion     = 0xffff;
  384. pHWHead->CommProp.dwServiceMask      = SP_SERIALCOMM;
  385. pHWHead->CommProp.dwReserved1         = 0;
  386. pHWHead->CommProp.dwMaxTxQueue        = 16;
  387. pHWHead->CommProp.dwMaxRxQueue        = 16;
  388. pHWHead->CommProp.dwMaxBaud       = BAUD_115200;
  389. pHWHead->CommProp.dwProvSubType      = PST_RS232;
  390. pHWHead->CommProp.dwProvCapabilities =
  391. PCF_DTRDSR | PCF_RLSD | PCF_RTSCTS |
  392. PCF_SETXCHAR |
  393. PCF_INTTIMEOUTS |
  394. PCF_PARITY_CHECK |
  395. PCF_SPECIALCHARS |
  396. PCF_TOTALTIMEOUTS |
  397. PCF_XONXOFF;
  398. pHWHead->CommProp.dwSettableBaud      =
  399. BAUD_075 | BAUD_110 | BAUD_150 | BAUD_300 | BAUD_600 |
  400. BAUD_1200 | BAUD_1800 | BAUD_2400 | BAUD_4800 |
  401. BAUD_7200 | BAUD_9600 | BAUD_14400 |
  402. BAUD_19200 | BAUD_38400 | BAUD_56K | BAUD_128K |
  403. BAUD_115200 | BAUD_57600 | BAUD_USER;
  404. pHWHead->CommProp.dwSettableParams    =
  405. SP_BAUD | SP_DATABITS | SP_HANDSHAKING | SP_PARITY |
  406. SP_PARITY_CHECK | SP_RLSD | SP_STOPBITS;
  407. pHWHead->CommProp.wSettableData       =
  408. DATABITS_5 | DATABITS_6 | DATABITS_7 | DATABITS_8;
  409. pHWHead->CommProp.wSettableStopParity =
  410. STOPBITS_10 | STOPBITS_20 |
  411. PARITY_NONE | PARITY_ODD | PARITY_EVEN | PARITY_SPACE |
  412. PARITY_MARK;
  414. pHWHead->fIRMode = bIR;
  415. pHWHead->s2440COM.UseIrDA = bIR;
  417. #ifdef EXAMINE_BOOTARGS
  418. // Don't actually init the hardware if it is being used for debugging
  419. if ( ((pHWHead->pBootArgs->ucComPort == 1) && (pHWHead->dwIOBase == COM1_BASE)) ||
  420. ((pHWHead->pBootArgs->ucComPort == 2) && (pHWHead->dwIOBase == COM2_BASE)) || 
  421. ((pHWHead->pBootArgs->ucComPort == 3) && (pHWHead->dwIOBase == COM3_BASE)) ||
  422. ((pHWHead->pBootArgs->ucComPort == 4) && (pHWHead->dwIOBase == COM4_BASE)) ) {
  423. DEBUGMSG (ZONE_INIT|ZONE_ERROR, (TEXT("rnSerInit - Skipping hardware init of debug portrnrn")));        
  424. } else
  425. #endif
  426. {
  427. DEBUGMSG (ZONE_INIT|USERDBG, (TEXT("SerInit - Init 16550 datarn")));
  428. SL_Init( pHWHead, pHWHead->pBaseAddress, 1,
  429. EvaluateEventFlag, pMddHead, (PLOOKUP_TBL)&BaudTable);
  430. DEBUGMSG (ZONE_INIT,
  431. (TEXT("SerInit - Disabling UART Powerrn")));
  432. SerSetOutputMode(pHWHead, FALSE, FALSE );    
  433. }
  435. return (pHWHead);
  437. ALLOCFAILED:
  438. if ( pHWHead->pBaseAddress )
  439. VirtualFree(pHWHead->pBaseAddress, 0, MEM_RELEASE);
  440. if ( ppBootArgs )
  441. MmUnmapIoSpace( ppBootArgs, sizeof( PVOID ) );
  442. if ( pHWHead->pBootArgs )
  443. MmUnmapIoSpace( pHWHead->pBootArgs, sizeof(BOOT_ARGS) );
  445. LocalFree(pHWHead);
  446. return (NULL);
  447. }
  450. PVOID
  451. SerInitSerial(
  452.        ULONG   Identifier, // @parm Device identifier.
  453.        PVOID   pMddHead,   // @parm First argument to mdd callbacks.
  454.        PHWOBJ  pHWObj      // @parm Pointer to our own HW OBJ for this device
  455. )
  456. {
  457. return (SerInit(FALSE, Identifier, pMddHead, pHWObj));
  458. }
  460. PVOID
  461. SerInitIR(
  462.        ULONG   Identifier, // @parm Device identifier.
  463.        PVOID   pMddHead,   // @parm First argument to mdd callbacks.
  464.        PHWOBJ  pHWObj      // @parm Pointer to our own HW OBJ for this device
  465. )
  466. {
  467. return (SerInit(TRUE, Identifier, pMddHead, pHWObj));
  468. }
  472. /*
  473.  @doc OEM
  474.  @func ULONG | SerClose | This routine closes the device identified by the PVOID returned by SerInit.
  475.  *  Not exported to users, only to driver.
  476.  *
  477.  @rdesc The return value is 0.
  478.  */
  479. static
  480. ULONG
  481. SerClose(
  482.         PVOID   pHead   // @parm PVOID returned by SerInit.
  483.         )
  484. {
  485. PSER_INFO   pHWHead = (PSER_INFO)pHead;
  486. ULONG  uTries;
  488. RETAILMSG (DEBUGMODE,(TEXT("+SerClosern")));
  489. if ( pHWHead->cOpenCount )
  490. {
  491. DEBUGMSG (ZONE_CLOSE, (TEXT("SerClose, closing devicern")));
  492. pHWHead->cOpenCount--;
  494. // while we are still transmitting, sleep.
  495. uTries = 0;
  496. while((pHWHead->s2440COM.s2440SerReg->rUFSTAT & SER2440_FIFOSTAT_MASK) & (uTries++ < 100)) // TxFifo not empty..
  497. {
  498. DEBUGMSG (ZONE_CLOSE, (TEXT("SerClose, TX in progress.rn")));            
  499. Sleep(10);
  500. }
  502. // When the device is closed, we power it down.
  503. DEBUGMSG (ZONE_CLOSE, (TEXT("SerClose - Powering down UARTrn")));
  504. pHWHead->fIRMode  = FALSE;
  505. SerSetOutputMode(pHWHead, FALSE, FALSE );
  507. DEBUGMSG (ZONE_CLOSE, (TEXT("SerClose - Calling SL_Closern")));
  508. SL_Close( pHWHead );
  509. }
  511. RETAILMSG(DEBUGMODE,(TEXT("-SerClosern")));
  512. return (0);
  513. }
  515. /*
  516.  @doc OEM 
  517.  @func PVOID | SerDeinit | Deinitializes device identified by argument.
  518.  *  This routine frees any memory allocated by SerInit.
  519.  *
  520.  */
  521. static
  522. BOOL
  523. SerDeinit(PVOID   pHead)   // @parm PVOID returned by SerInit.
  524. {
  525. PSER_INFO   pHWHead = (PSER_INFO)pHead;
  527. RETAILMSG(DEBUGMODE,(TEXT("SerDeinit rn")));
  528. if ( !pHWHead )
  529. return (FALSE);
  531. // Make sure device is closed before doing DeInit
  532. if ( pHWHead->cOpenCount )
  533. SerClose( pHead );
  535. SL_Deinit( pHead );
  537. if ( pHWHead->pBaseAddress )
  538. VirtualFree(pHWHead->pBaseAddress, 0, MEM_RELEASE);
  540. if ( pHWHead->pBootArgs )
  541. MmUnmapIoSpace( pHWHead->pBootArgs, sizeof(BOOT_ARGS) );
  543. // Free the HWObj
  544. LocalFree(pHWHead->pHWObj);
  546. // And now free the SER_INFO structure.
  547. LocalFree(pHWHead);
  549. return (TRUE);
  550. }
  552. /*
  553.  @doc OEM
  554.  @func VOID | SerGetCommProperties | Retrieves Comm Properties.
  555.  *
  556.  @rdesc None.
  557.  */
  558. static
  559. VOID
  560. SerGetCommProperties(
  561.                     PVOID   pHead,      // @parm PVOID returned by SerInit. 
  562.                     LPCOMMPROP  pCommProp   // @parm Pointer to receive COMMPROP structure. 
  563.                     )
  564. {
  565. PSER_INFO   pHWHead = (PSER_INFO)pHead;
  566. RETAILMSG(DEBUGMODE,(TEXT("+SerGetCommPropertiesrn")));
  567. *pCommProp = pHWHead->CommProp;
  568. return;
  569. }
  572. /*
  573.  @doc OEM
  574.  @func VOID | SerSetBaudRate |
  575.  * This routine sets the baud rate of the device.
  576.  *  Not exported to users, only to driver.
  577.  *
  578.  @rdesc None.
  579.  */
  580. static
  581. BOOL
  582. SerSetBaudRate(
  583.               PVOID   pHead,  // @parm     PVOID returned by SerInit
  584.               ULONG   BaudRate    // @parm     ULONG representing decimal baud rate.
  585.               )
  586. {
  587. PSER_INFO   pHWHead = (PSER_INFO)pHead;
  589. RETAILMSG(DEBUGMODE,(TEXT("IRDA : SerSetBaudRate rn")));
  590. // If we are running in IR mode, try to set the IR baud
  591. // first, since it supports a subset of the rates supported
  592. // by the UART.  If we fail setting the IR rate, then
  593. // return an error and leave the UART alone.
  594. if ( IRDA )
  595. {
  596. if ( ! SerSetIRBaudRate( pHWHead, BaudRate ) )
  597. {
  598. DEBUGMSG (ZONE_ERROR, 
  599. (TEXT("Unsupported IR BaudRatern")));
  600. // We should return an error, but vtbl doesn't expect one
  601. return (FALSE); 
  602. }
  603. }
  605. // Now set buadrate on the UART
  606. return ( SL_SetBaudRate( pHead, BaudRate ) );    
  607. }
  609. /*
  610.  @doc OEM
  611.  @func BOOL | SerPowerOff |
  612.  *  Called by driver to turn off power to serial port.
  613.  *  Not exported to users, only to driver.
  614.  *
  615.  @rdesc This routine returns a status.
  616.  */
  617. BOOL
  618. SerPowerOff(PVOID   pHead)       // @parm PVOID returned by SerInit.
  619. {
  620. PSER_INFO   pHWHead = (PSER_INFO)pHead;
  622. RETAILMSG(DEBUGMODE,(TEXT("SerPowerOffrn")));
  623. SerClose( pHWHead );
  624. // First, power down the UART
  625. SL_PowerOff( pHWHead );
  627. // And then disable our IR and 9 Pin interface
  628. SerSetOutputMode( pHWHead, FALSE, FALSE );
  630. return (TRUE);
  631. }
  633. /*
  634.  @doc OEM
  635.  @func BOOL | SerPowerOn |
  636.  *  Called by driver to turn on power to serial port.
  637.  *  Not exported to users, only to driver.
  638.  *
  639.  @rdesc This routine returns a status.
  640.  */
  641. BOOL
  642. SerPowerOn(PVOID   pHead)       // @parm PVOID returned by SerInit.
  643. {
  644. PSER_INFO   pHWHead = (PSER_INFO)pHead;
  646. RETAILMSG(DEBUGMODE,(TEXT("SerPowerOnrn")));
  647. // First, power up the UART
  648. SL_PowerOn( pHWHead );
  650. // And then enable our IR interface (if needed)
  651. SerSetOutputMode( pHWHead, pHWHead->fIRMode, !pHWHead->fIRMode );
  652. return (TRUE);
  653. }
  655. /*
  656.  @doc OEM
  657.  @func BOOL | SerEnableIR | This routine enables ir.
  658.  *  Not exported to users, only to driver.
  659.  *
  660.  @rdesc Returns TRUE if successful, FALSEotherwise.
  661.  */
  662. static
  663. BOOL
  664. SerEnableIR(
  665.            PVOID   pHead, // @parm PVOID returned by Serinit.
  666.            ULONG   BaudRate  // @parm PVOID returned by HWinit.
  667.            )
  668. {
  669. PSER_INFO   pHWHead = (PSER_INFO)pHead;
  671. RETAILMSG(DEBUGMODE,(TEXT("SerEnableIRrn")));
  672. pHWHead->fIRMode  = TRUE;
  673. SerSetOutputMode( pHWHead, pHWHead->fIRMode, !pHWHead->fIRMode );
  674. return (TRUE);
  675. }
  677. /*
  678.  @doc OEM
  679.  @func BOOL | SerDisableIR | This routine disable the ir.
  680.  *  Not exported to users, only to driver.
  681.  *
  682.  @rdesc Returns TRUE if successful, FALSEotherwise.
  683.  */
  684. static
  685. BOOL
  686. SerDisableIR(PVOID   pHead) // @parm PVOID returned by Serinit.
  687. {
  688. PSER_INFO   pHWHead = (PSER_INFO)pHead;
  690. RETAILMSG(DEBUGMODE,(TEXT("SerDisableIRrn")));
  691. pHWHead->fIRMode  = FALSE;
  692. SerSetOutputMode( pHWHead, pHWHead->fIRMode, !pHWHead->fIRMode );
  693. return (TRUE);
  694. }
  696. /*
  697.  @doc OEM
  698.  @func BOOL | SerEnableIR | This routine enables ir.
  699.  *  Not exported to users, only to driver.
  700.  *
  701.  @rdesc Returns TRUE if successful, FALSEotherwise.
  702.  */
  703. static
  704. BOOL
  705. SerEnableSerial(
  706.            PVOID   pHead, // @parm PVOID returned by Serinit.
  707.            ULONG   BaudRate  // @parm PVOID returned by HWinit.
  708.            )
  709. {
  710. PSER_INFO   pHWHead = (PSER_INFO)pHead;
  712. RETAILMSG(DEBUGMODE,(TEXT("SerEnableSerialrn")));
  713. pHWHead->fIRMode  = FALSE;
  714. SerSetOutputMode( pHWHead, pHWHead->fIRMode, !pHWHead->fIRMode );
  715. return (TRUE);
  716. }
  718. /*
  719.  @doc OEM
  720.  @func BOOL | SerDisableIR | This routine disable the ir.
  721.  *  Not exported to users, only to driver.
  722.  *
  723.  @rdesc Returns TRUE if successful, FALSEotherwise.
  724.  */
  725. static
  726. BOOL
  727. SerDisableSerial(PVOID   pHead) // @parm PVOID returned by Serinit.
  728. {
  729. PSER_INFO   pHWHead = (PSER_INFO)pHead;
  731. RETAILMSG(DEBUGMODE,(TEXT("SerDisableSerialrn")));
  733. pHWHead->fIRMode  = TRUE;
  734. SerSetOutputMode( pHWHead, pHWHead->fIRMode, !pHWHead->fIRMode );
  735. return (TRUE);
  736. }
  739. /*
  740.  @doc OEM
  741.  @func BOOL | SerOpen | This routine is called when the port is opened.
  742.  *  Not exported to users, only to driver.
  743.  *
  744.  @rdesc Returns TRUE if successful, FALSEotherwise.
  745.  */
  746. static
  747. BOOL
  748. SerOpen(PVOID   pHead) // @parm PVOID returned by Serinit.
  749. {
  750. PSER_INFO   pHWHead = (PSER_INFO)pHead;
  752. // Disallow multiple simultaneous opens
  753. if ( pHWHead->cOpenCount )
  754. return (FALSE);
  756. #ifdef EXAMINE_BOOTARGS
  757. RETAILMSG(DEBUGMODE, (TEXT("SerOpen - Bootargs ComPort %xrn"), pHWHead->pBootArgs->ucComPort));
  758. // If the port is in use as a debugger port, don't allow opens.
  759. if ( ((pHWHead->pBootArgs->ucComPort == 1) && (pHWHead->dwIOBase == COM1_BASE)) ||
  760. ((pHWHead->pBootArgs->ucComPort == 2) && (pHWHead->dwIOBase == COM2_BASE)) || 
  761. ((pHWHead->pBootArgs->ucComPort == 3) && (pHWHead->dwIOBase == COM3_BASE)) ||
  762. ((pHWHead->pBootArgs->ucComPort == 4) && (pHWHead->dwIOBase == COM4_BASE)) )
  763. {
  764. RETAILMSG (DEBUGMODE, (TEXT("SerOpen - Fail open of debug portrn")));        
  765. return (FALSE);        
  766. }
  767. #endif
  769. pHWHead->cOpenCount++;
  771. if ( pHWHead->fIRMode == TRUE )
  772. RETAILMSG(DEBUGMODE,(TEXT("Use IrDA rn")));
  773. else
  774. RETAILMSG(DEBUGMODE,(TEXT("Use Serail rn")));
  775. SerSetOutputMode(pHWHead, pHWHead->fIRMode, !pHWHead->fIRMode );  
  777. // NOTE: - If we wanted to support 16450s, we'll could dynamically
  778. // identify them here.
  780. // Init SER2440 info
  781. RETAILMSG(DEBUGMODE, (TEXT("SerOpen - Calling SL_Openrn")));
  782. SL_Open( pHWHead );
  783. RETAILMSG(DEBUGMODE, (TEXT("SerOpen - Return TRUErn")));
  785. return (TRUE);
  786. }
  788. const
  789. HW_VTBL IoVTbl = {
  790. SerInitSerial,
  791. SL_PostInit,
  792. SerDeinit,
  793. SerOpen,
  794. SerClose,
  795. SL_GetInterruptType,
  796. SL_RxIntr,
  797. SL_TxIntrEx,
  798. SL_ModemIntr,
  799. SL_LineIntr,
  800. SL_GetRxBufferSize,
  801. SerPowerOff,
  802. SerPowerOn,
  803. SL_ClearDTR,
  804. SL_SetDTR,
  805. SL_ClearRTS,
  806. SL_SetRTS,
  807. SerEnableSerial,
  808. SerDisableSerial,
  809. SL_ClearBreak,
  810. SL_SetBreak,
  811. SL_XmitComChar,
  812. SL_GetStatus,
  813. SL_Reset,
  814. SL_GetModemStatus,
  815. SerGetCommProperties,
  816. SL_PurgeComm,
  817. SL_SetDCB,
  818. SL_SetCommTimeouts,
  819. };
  820. extern const HW_VTBL SerCardIoVTbl;
  822. const
  823. HW_VTBL IrVTbl = {
  824. SerInitIR,
  825. SL_PostInit,
  826. SerDeinit,
  827. SerOpen,
  828. SerClose,
  829. SL_GetInterruptType,
  830. SL_RxIntr,
  831. SL_TxIntrEx,
  832. SL_ModemIntr,
  833. SL_LineIntr,
  834. SL_GetRxBufferSize,
  835. SerPowerOff,
  836. SerPowerOn,
  837. SL_ClearDTR,
  838. SL_SetDTR,
  839. SL_ClearRTS,
  840. SL_SetRTS,
  841. SerEnableIR,
  842. SerDisableIR,
  843. SL_ClearBreak,
  844. SL_SetBreak,
  845. SL_XmitComChar,
  846. SL_GetStatus,
  847. SL_Reset,
  848. SL_GetModemStatus,
  849. SerGetCommProperties,
  850. SL_PurgeComm,
  851. SL_SetDCB,
  852. SL_SetCommTimeouts,
  853. };
  854. extern const HW_VTBL SerCardIrVTbl;
  856. const HWOBJ IoObj = {
  857. THREAD_AT_INIT,
  858. SYSINTR_SERIAL,
  859. (PHW_VTBL) &IoVTbl
  860. };
  862. const HWOBJ IrObj = {
  863. THREAD_AT_INIT,
  864. SYSINTR_IR,
  865. (PHW_VTBL) &IrVTbl
  866. };
  868. typedef HWOBJ const *PCHWOBJ;
  870. const PCHWOBJ HWObjects[] = {
  871. &IoObj,
  872. &IrObj
  873. };
  875. // GetSerialObj : The purpose of this function is to allow multiple PDDs to be
  876. // linked with a single MDD creating a multiport driver.  In such a driver, the
  877. // MDD must be able to determine the correct vtbl and associated parameters for
  878. // each PDD.  Immediately prior to calling HWInit, the MDD calls GetSerialObject
  879. // to get the correct function pointers and parameters.
  880. //
  881. PHWOBJ
  882. GetSerialObject(DWORD DeviceArrayIndex)
  883. {
  884. PHWOBJ pSerObj;
  886. RETAILMSG(DEBUGMODE,(TEXT("IRDA : GetSerialObjectrn")));
  888. IRDA = DeviceArrayIndex;
  890. // Now return this structure to the MDD.
  891. if ( DeviceArrayIndex == 0 )
  892. pSerObj = (PHWOBJ)(&IoObj);
  893. else
  894. pSerObj = (PHWOBJ)(&IrObj);
  895. return (pSerObj);
  896. }