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

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

Windows CE

开发平台：

Windows_Unix

sc2440_usb_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) 2001. Samsung Electronics, co. ltd  All rights reserved.
  8. Module Name:  
  10. Abstract:
  12. S3C2440 USB function(ACTIVE SYNC) device driver (Wrapper layer)
  14. rev:
  15. 2003.3.19 : updated for USB-DMA (purnnamu)
  16. 2002.5.7 : Add to s3c2410_code (Seung-han, Lim)
  17. 2002.1.22 : First release/no error recovery (kwangyoon LEE, kwangyoon@samsung.com)
  19. Notes: 
  20. */
  22. #include <windows.h>
  23. #include <types.h>
  24. #include <ceddk.h>
  25. #include <memory.h>
  26. #include <notify.h>
  27. #include <serhw.h>
  28. #include "S2440.h"
  29. #include <SC2440_usb_hw.h>
  30. #include <SC2440_usb_ser.h>
  31. #include <nkintr.h>
  32. #include <oalintr.h>
  33. #include <devload.h>
  34. #include <windev.h>
  35. #undef ZONE_INIT
  36. #include <serdbg.h>
  37. #include <celog.h> 
  38. #include <drv_glob.h> //:-)
  42. extern VOID SerialEventHandler(PVOID pHead);
  44. extern void msWait(unsigned msVal);
  46. extern volatile USBD_GLOBALS *usbdShMem; //:-)
  49. __inline static VOID
  50. SignalRemoval( PSER_INFO pHWHead )
  51. {
  52. pHWHead->ModemStatus &= ~MS_RLSD_ON;
  53. EvaluateEventFlag(pHWHead->pMddHead, EV_RLSD);
  54. }
  57. static
  58. DWORD WINAPI SerEventThread(PSER_INFO pHWHead)
  59. {
  60. ULONG WaitReturn;
  61. static HWND fgp=NULL, prev_fgp = NULL; 
  62. static HWND dialog_hwnd = NULL;
  63. static ULONG firstplug = 0, toretry = 0;
  64. static PROCESS_INFORMATION pi_usbcnect, pi_repllog;
  66. DEBUGMSG(1, (TEXT("++SerEventThreadrn")));
  67. DEBUGMSG(1, (TEXT("Spinning in dispatch thread %Xnr"), pHWHead));
  69. while (!pHWHead->pDispatchThread)
  70. Sleep(20);
  72. while (!pHWHead->KillRxThread) {
  73. DEBUGMSG (1, (TEXT("Event %X, Index %d, Int %drn"), 
  74. pHWHead->hSerialEvent,
  75. pHWHead->dwDevIndex,
  76. pHWHead->pHWObj->dwIntID ));
  78. // Ugly.  We don't get an interrupt when we are unplugged from the
  79. // bus, but we'd like to know when that happens.  So we use a timeout
  80. // on our interrupt wait.  This effectively allows me to poll the SOF
  81. // status, and if SOFs stop arriving, I'll assume we have been
  82. // disconnected from the bus.  Wait is last, allowing us to essentially
  83. // spoof one interrupt right at startup.
  85. // Only poll if we are opened and active.  Otherwise no one cares
  87. #ifdef POLL_FOR_DISCONNECT
  88. if (pHWHead->cOpenCount && pHWHead->dConfIdx)
  89. {
  90. // DEBUGMSG(1, (TEXT("waitforsingleobject in uprn")));
  91.       
  92. WaitReturn = WaitForSingleObject(pHWHead->hSerialEvent, SC2440_USB_POLL_RATE);
  93. // DEBUGMSG(1, (TEXT("waitforsingleobject inrn")));
  94. }
  95. else
  96. #endif        
  97. {
  98.    //DEBUGMSG(1, (TEXT("waitforsingleobject out uprn"))); 
  99.        WaitReturn = WaitForSingleObject(pHWHead->hSerialEvent, INFINITE);
  101. /*
  102.        DEBUGMSG(1, (TEXT("waitforsingleobject outrn")));  
  104.    if (WaitReturn == WAIT_ABANDONED)
  105.    {
  106. DEBUGMSG(1, (TEXT("WAIT_ABANDONEDrn")));
  107. }
  109. if (WaitReturn == WAIT_OBJECT_0)
  110. {
  111. DEBUGMSG(1, (TEXT("WAIT_OBJECT_0rn")));
  112. }
  114. if (WaitReturn == WAIT_TIMEOUT)
  115. {
  116. DEBUGMSG(1, (TEXT("WAIT_TIMEOUTrn")));
  117. }
  119. if (WaitReturn == WAIT_FAILED)
  120. {
  121. DEBUGMSG(1, (TEXT("WAIT_FAILEDrn")));
  122. }
  123. */
  124. }
  126. SerialEventHandler(pHWHead->pMddHead);
  127. InterruptDone(pHWHead->pHWObj->dwIntID);
  128. }
  130. DEBUGMSG (1, (TEXT("--SerEventThread %x exitingrn"), pHWHead));
  132. return (0);
  133. }
  135. static
  136. BOOL StartEventThread(PSER_INFO pHWHead)
  137. {
  138.     
  139. // Initialize the interrupt to be associated with the hSerialEvent
  140. // event. If this call fails, then another process has registered 
  141. // for the interrupt, so fail the init and set the hSerialEvent to NULL.
  142. DEBUGMSG(1, (TEXT("Initializing interrupt 0x%X, 0x%Xnr"),
  143. pHWHead->pHWObj->dwIntID, pHWHead->hSerialEvent));
  145. if (!InterruptInitialize(pHWHead->pHWObj->dwIntID, pHWHead->hSerialEvent, 0, 0)) 
  146. {
  148. DEBUGMSG(1, (TEXT("Error initializing interruptnr")));
  150. return (FALSE);
  151. }
  153. InterruptDone(pHWHead->pHWObj->dwIntID);
  154.     
  155. // Now set up the dispatch thread 
  156. pHWHead->KillRxThread = 0;
  158. DEBUGMSG(1, (TEXT("Spinning thread%Xnr"), pHWHead));
  160. pHWHead->pDispatchThread = CreateThread(NULL,0, SerEventThread,
  161. pHWHead, 0,NULL);
  162. if (pHWHead->pDispatchThread == NULL) 
  163. {
  164. DEBUGMSG(1, (TEXT("Error creating Event thread (%d)nr"), GetLastError()));
  165. return (FALSE);
  166. }
  168. DEBUGMSG (1, (TEXT("Created Event thread %Xrn"), pHWHead->pDispatchThread));
  169. DEBUGMSG (1, (TEXT("About to set priorityrn")));
  171. CeSetThreadPriority(pHWHead->pDispatchThread, DEFAULT_THREAD_PRIO);
  172.                           
  173. DEBUGMSG (1, (TEXT("Back from setting priorityrn")));
  175. return (TRUE);
  176. }
  178. /***************************************************************
  179.  @doc OEM
  180.  @func VOID | SerSetBaudRate |
  181.  * This routine sets the baud rate of the device.
  182.  *  Not exported to users, only to driver.
  183.  *
  184.  @rdesc None.
  185.  ****************************************************************/
  186. static
  187. BOOL SerSetBaudRate( PVOID pHead, // @parm PVOID returned by SerInit
  188.      ULONG BaudRate ) // @parm ULONG representing decimal baud rate.
  189. {
  190. PSER_INFO   pHWHead = (PSER_INFO)pHead;
  192. DEBUGMSG(1, (TEXT("SerSetBaudRatern")));
  194. // Baudrate is meaningless.  Just be agreeable and say we did it.
  195. return (TRUE);    
  196. }
  198. /****************************************************************
  199. @doc INTERNAL
  201. @func VOID | SerUSB_InternalMapRegisterAddresses |
  202. This routine maps the ASIC registers. 
  203. It's an artifact of this
  204. implementation.
  206. @rdesc None.
  207. ****************************************************************/
  208. static
  209. void SerUSBInternalMapRegisterAddresses( PSER_INFO   pHWHead )
  210. {
  211. PUCHAR  pVMem;
  212. BOOL    bMapReturn;
  213. ULONG   err = 0;
  214.   
  215. DEBUGMSG(1, (TEXT("++SerUSBInternalMapRegisterAddressesrn")));
  217. // Map CSR registers.
  218. pVMem = (PUCHAR)VirtualAlloc(0, PAGE_SIZE*2, MEM_RESERVE, PAGE_NOACCESS);
  220. if (pVMem) 
  221. {
  222. DEBUGMSG(1, (TEXT("VirtualAlloc Succeededrn")));
  224. bMapReturn = VirtualCopy( pVMem,
  225.   (LPVOID)pHWHead->dwIOBase,
  226.   PAGE_SIZE,
  227.   PAGE_READWRITE | PAGE_NOCACHE );
  228. if (!bMapReturn) 
  229. {
  230. err = GetLastError();
  231. DEBUGMSG(1, (TEXT("Virtual Copy: Serial SPACE FAILEDrn")));
  232. }
  234. pVMem = (BYTE *)pVMem;
  235. pHWHead->pUSBCtrlAddr=(volatile struct udcreg *)((BYTE *)pVMem + 0x140); // offset
  237. bMapReturn = VirtualCopy( pVMem+PAGE_SIZE,
  238.   (LPVOID)IOP_BASE,
  239.   PAGE_SIZE,
  240.   PAGE_READWRITE | PAGE_NOCACHE );
  241. if (!bMapReturn) 
  242. {
  243. err = GetLastError();
  244. DEBUGMSG(1, (TEXT("Virtual Copy: IOP SPACE FAILEDrn")));
  245. }
  247. pHWHead->pIrqCtrlAddr=(volatile IOPreg *)(pVMem+PAGE_SIZE);
  249. bMapReturn = VirtualCopy( pVMem+PAGE_SIZE,
  250.   (LPVOID)CLKPWR_BASE,
  251.   PAGE_SIZE,
  252.   PAGE_READWRITE | PAGE_NOCACHE );
  253. if (!bMapReturn) 
  254. {
  255. err = GetLastError();
  256. DEBUGMSG(1, (TEXT("Virtual Copy: CLKPWR SPACE FAILEDrn")));
  257. }
  259. pHWHead->pCLKPWR = (volatile CLKPWRreg *)(pVMem+PAGE_SIZE);
  261. } else {
  262.      DEBUGMSG(1, (TEXT("Virtual Alloc: FAILEDrn")));
  263. }
  264.   
  265. DEBUGMSG(1, (TEXT("VirtualCopy Succeeded, pVMem:%xrn"), pVMem));
  267. DEBUGMSG(1, (TEXT("--SerUSBInternalMapRegisterAddressesrn")));
  268. }
  270. static
  271. BOOL SerSetIRBaudRate( PSER_INFO pHWHead, ULONG baud ) // @parm baud rate - ignored
  272. {
  273. DEBUGMSG(1, (TEXT("Serial set IR Baud %drn"), baud));
  275. // We don't support IR
  276. return (FALSE);
  277. }
  281. /*******************************************************************************
  282. Routine:
  284.     Ser_GetRegistryData
  286. Description:
  288.     Take the registry path provided to COM_Init and use it to find this 
  289.     requested comm port's DeviceArrayIndex, the IOPort Base Address, and the
  290.     Interrupt number.
  291.    
  292. Arguments:
  294.     LPCTSTR regKeyPath the registry path passed in to COM_Init.
  296. Return Value:
  298.     -1 if there is an error.
  300. ******************************************************************************/
  302. static
  303. BOOL Ser_GetRegistryData(PSER_INFO pHWHead, LPCTSTR regKeyPath)
  304. {
  305. #define GCI_BUFFER_SIZE 256   
  307. LONG    regError;
  308. HKEY    hKey;
  309. TCHAR   devKeyPath[GCI_BUFFER_SIZE];
  310. DWORD   dwDataSize = GCI_BUFFER_SIZE;
  312. DEBUGMSG(1,
  313. (TEXT("Ser_GetRegistryData Try to open %srn"),regKeyPath));
  315.   // We've been handed the name of a key in the registry that was generated
  316.   // on the fly by device.exe.  We're going to open that key and pull from it
  317.   // a value that is the name of this serial port's real key.  That key
  318.   // will have the DeviceArrayIndex that we're trying to find.  
  320. regError = RegOpenKeyEx(HKEY_LOCAL_MACHINE, 
  321. regKeyPath,
  322. 0, 
  323. KEY_ALL_ACCESS, 
  324. &hKey);
  326. if (regError != ERROR_SUCCESS) 
  327. {
  328. DEBUGMSG(1,(TEXT("Failed to open %s, Error 0x%Xrn"),regKeyPath,regError));
  329. return (FALSE);                
  330. }
  332. regError = RegQueryValueEx( hKey, 
  333.     DEVLOAD_DEVKEY_VALNAME,
  334.     NULL, 
  335.     NULL, 
  336.     (LPBYTE)devKeyPath,
  337.     &dwDataSize);
  339. // We're done with that registry key, so close it.
  340. RegCloseKey (hKey);
  342. if (regError != ERROR_SUCCESS) 
  343. {
  344. DEBUGMSG(1, (TEXT("Failed to find data at %s\%s, Error 0x%Xrn"), 
  345. regKeyPath, DEVLOAD_DEVKEY_VALNAME, regError));
  346. return (FALSE);                
  347. }
  349. DEBUGMSG(1, (TEXT("Try to open %srn"), devKeyPath));
  351. regError = RegOpenKeyEx(HKEY_LOCAL_MACHINE, 
  352. devKeyPath, 
  353. 0,
  354. KEY_ALL_ACCESS, 
  355. &hKey);
  357. if (regError != ERROR_SUCCESS) 
  358. {
  359. DEBUGMSG(1,(TEXT("Failed to open %s, Error 0x%Xrn"), devKeyPath, regError));
  360. return (FALSE);        
  361. }
  363. // Okay, we're finally ready to try and load our registry data.
  364. dwDataSize = SC2440USB_REG_DEVINDEX_VAL_LEN;
  366. regError   = RegQueryValueEx(hKey, 
  367.      SC2440USB_REG_DEVINDEX_VAL_NAME, 
  368.      NULL, 
  369.      NULL,
  370.      (LPBYTE)(&pHWHead->dwDevIndex), 
  371.      &dwDataSize);
  373. if (regError == ERROR_SUCCESS) 
  374. {
  375. dwDataSize = SC2440USB_REG_IRQ_VAL_LEN;
  377. regError = RegQueryValueEx( hKey, 
  378.     SC2440USB_REG_IRQ_VAL_NAME, 
  379.     NULL, 
  380.     NULL,
  381.     (LPBYTE)(&pHWHead->dwIRQ), 
  382.     &dwDataSize );
  383. }
  385. if (regError == ERROR_SUCCESS) 
  386. {
  387. dwDataSize = SC2440USB_REG_IOBASE_VAL_LEN;
  389. regError = RegQueryValueEx( hKey, 
  390.     SC2440USB_REG_IOBASE_VAL_NAME, 
  391.     NULL, 
  392.     NULL,
  393.     (LPBYTE)(&pHWHead->dwIOBase), 
  394.     &dwDataSize);
  395. }
  397. if (regError == ERROR_SUCCESS) 
  398. {
  399. dwDataSize = SC2440USB_REG_IOLEN_VAL_LEN;
  401. regError = RegQueryValueEx( hKey, 
  402.     SC2440USB_REG_IOLEN_VAL_NAME, 
  403.     NULL, 
  404.     NULL,
  405.     (LPBYTE)(&pHWHead->dwIOLen), 
  406.     &dwDataSize);
  407. }
  409. RegCloseKey (hKey);
  411. if (regError != ERROR_SUCCESS) 
  412. {
  413. DEBUGMSG(1,(TEXT("Failed to get serial registry values, Error 0x%Xrn"),
  414. regError));
  415. return (FALSE);
  416. }
  418. DEBUGMSG(1,(TEXT("SerInit - Devindex %d, IRQ %d, IOB %X, IOLen %X rn"),
  419. pHWHead->dwDevIndex,
  420. pHWHead->dwIRQ,
  421. pHWHead->dwIOBase,
  422. pHWHead->dwIOLen));
  424. return (TRUE); 
  425. }
  429. /*************************************************************************
  430.  @doc OEM 
  431.  @func PVOID | SerInit | Initializes device identified by argument.
  432.  *  This routine sets information controlled by the user
  433.  *  such as Line control and baud rate. It can also initialize events and
  434.  *  interrupts, thereby indirectly managing initializing hardware buffers.
  435.  *  Exported only to driver, called only once per process.
  436.  *
  437.  @rdesc The return value is a PVOID to be passed back into the HW
  438.  dependent layer when HW functions are called.
  439.  ************************************************************************/
  440. static
  441. PVOID SerInit( ULONG   Identifier, // @parm Device identifier.
  442.                PVOID   pMddHead,   // @parm First argument to mdd callbacks.
  443.        PHWOBJ  pHWObj )    // @parm Pointer to our own HW OBJ for this device
  445. {
  446. PSER_INFO pHWHead;
  447. PHYSICAL_ADDRESS PhysicalAddress = {0,0};
  449. #ifdef DEBUG
  450. dpCurSettings.ulZoneMask = 0;
  451. #endif
  453. DEBUGMSG (1, (TEXT("++SerInit %Xrn"), pMddHead ));
  455. // Allocate for our main data structure and one of it's fields.
  456. pHWHead = (PSER_INFO)LocalAlloc( LPTR, sizeof(SER_INFO) );
  457. if ( !pHWHead )
  458. goto ALLOCFAILED;
  460. if (!Ser_GetRegistryData(pHWHead, (LPCTSTR)Identifier)) 
  461. {
  462. DEBUGMSG (1,(TEXT("SerInit - Unable to read registry data. Failing Init !!! rn")));
  463. goto ALLOCFAILED;
  464. }
  466. // Create our interrupt event.
  467. pHWHead->hSerialEvent = CreateEvent(0,FALSE,FALSE,NULL);
  469. // Initialize our critical sections
  470. InitializeCriticalSection(&(pHWHead->TransmitCritSec));
  471. InitializeCriticalSection(&(pHWHead->HwRegCritSec));
  473. SerUSBInternalMapRegisterAddresses(pHWHead);
  474. if(!InitUsbdDriverGlobals())  //:-)
  475. goto ALLOCFAILED;
  476. if(!UsbdAllocateVm())  //:-)
  477. goto ALLOCFAILED;
  480. pHWHead->pMddHead = pMddHead;
  481. pHWHead->cOpenCount = 0;
  482. pHWHead->pHWObj = pHWObj;
  483. pHWHead->wSOFStableCnt = 0; 
  484.     
  485. // Set up our Comm Properties data    
  486. pHWHead->CommProp.wPacketLength      = 0xffff;
  487. pHWHead->CommProp.wPacketVersion     = 0xffff;
  488. pHWHead->CommProp.dwServiceMask      = SP_SERIALCOMM;
  489. pHWHead->CommProp.dwReserved1        = 0;
  490. pHWHead->CommProp.dwMaxTxQueue       = 64;
  491. pHWHead->CommProp.dwMaxRxQueue       = 64;
  492. pHWHead->CommProp.dwMaxBaud          = BAUD_115200;
  493. pHWHead->CommProp.dwProvSubType      = PST_RS232;
  494. pHWHead->CommProp.dwProvCapabilities =  PCF_RLSD | 
  495. PCF_SETXCHAR |
  496. PCF_INTTIMEOUTS |
  497. PCF_SPECIALCHARS |
  498. PCF_TOTALTIMEOUTS |
  499. PCF_XONXOFF;
  500. pHWHead->CommProp.dwSettableBaud      = BAUD_075 | BAUD_110 | BAUD_150 | 
  501. BAUD_300 | BAUD_600 |
  502. BAUD_1200 | BAUD_1800 | 
  503. BAUD_2400 | BAUD_4800 |
  504. BAUD_7200 | BAUD_9600 | BAUD_14400 |
  505. BAUD_19200 | BAUD_38400 | 
  506. BAUD_56K | BAUD_128K |
  507. BAUD_115200 | BAUD_57600 | BAUD_USER;
  508. pHWHead->CommProp.dwSettableParams    = SP_BAUD | SP_RLSD ;
  509. pHWHead->CommProp.wSettableData       = DATABITS_8;
  510. pHWHead->CommProp.wSettableStopParity = STOPBITS_10 | STOPBITS_20 |
  511. PARITY_NONE | PARITY_ODD | 
  512. PARITY_EVEN | PARITY_SPACE |
  513. PARITY_MARK;
  515. pHWHead->fIRMode  = FALSE;   // Select wired by default
  517.     pHWHead->State = IDLE;
  518.     
  519. // Here is where we do any actual init for the hardware.  In the case of
  520. // USB function, we mostly just validate the hardware and then enable
  521.   // interrupts.  When we detect the presence of the bus, GetIntr will take
  522. // care of identify us to the host and kicking things off.
  524. SC2440_USB_Init(pHWHead);
  526. DEBUGMSG (1, (TEXT("--SerInit - %Xrn"), pHWHead ));
  528. return (pHWHead);
  530. ALLOCFAILED:
  531. // Unmap any memory areas that we may have mapped.
  532. if ( pHWHead->pUSBCtrlAddr)
  533. VirtualFree((PVOID)pHWHead->pUSBCtrlAddr, 0, MEM_RELEASE);
  535. if ( pHWHead->pIrqCtrlAddr)
  536. VirtualFree((PVOID)pHWHead->pIrqCtrlAddr, 0, MEM_RELEASE);
  538. if ( pHWHead->pCLKPWR)
  539. VirtualFree((PVOID)pHWHead->pCLKPWR, 0, MEM_RELEASE);
  541. LocalFree(pHWHead);
  543. // Free any critical sections we have allocated
  544. DeleteCriticalSection(&(pHWHead->TransmitCritSec));
  545. DeleteCriticalSection(&(pHWHead->HwRegCritSec));
  547. // And free the context data structure
  548. LocalFree(pHWHead);
  550. DEBUGMSG (1,(TEXT("--SerInit - %Xrn"), pHWHead ));
  552. return (NULL);
  553. }
  555. /*************************************************************************
  556.  @doc OEM 
  557.  @func PVOID | SerPostInit | Performs final hardware initialization.
  558.  ************************************************************************/
  559. static
  560. BOOL SerPostInit(PVOID   pHead)   // @parm PVOID returned by SerInit.
  561. {
  562. PSER_INFO pHWHead = (PSER_INFO)pHead;
  564. DEBUGMSG(1, (TEXT("+++SerPostInitrn")));
  566. // We use a PDD specific thread, rather than the default thread provided
  567. // by the MDD.
  568. StartEventThread( pHWHead );
  570. // Enable interrupts after thread is started - DAL
  571. // ....
  573. return TRUE;
  574. }
  576. /*************************************************************************
  577.  @doc OEM 
  578.  @func PVOID | SerDeinit | Deinitializes device identified by argument.
  579.  *  This routine frees any memory allocated by SerInit.
  580.  ************************************************************************/
  581. static
  582. BOOL SerDeinit(PVOID   pHead)   // @parm PVOID returned by SerInit.
  583. {
  584. PSER_INFO pHWHead = (PSER_INFO)pHead;
  586. DEBUGMSG(1, (TEXT("+SerDeinitrn")));
  588. // Disable interrupts
  589. // ...
  591. if ( !pHWHead )
  592. return (FALSE);
  594. // Make sure device is closed before doing DeInit
  595. if ( pHWHead->cOpenCount )
  596. SerClose( pHead );
  598. if ( pHWHead->pUSBCtrlAddr)
  599. VirtualFree((PVOID)pHWHead->pUSBCtrlAddr, 0, MEM_RELEASE);
  601. if ( pHWHead->pIrqCtrlAddr)
  602. VirtualFree((PVOID)pHWHead->pIrqCtrlAddr, 0, MEM_RELEASE);
  604. if ( pHWHead->pCLKPWR)
  605. VirtualFree((PVOID)pHWHead->pCLKPWR, 0, MEM_RELEASE);
  607. UsbdDeallocateVm(); //:-)
  609. // Free any critical sections we have allocated
  610. DeleteCriticalSection(&(pHWHead->TransmitCritSec));
  611. DeleteCriticalSection(&(pHWHead->HwRegCritSec));
  613. // Free the HWObj allocated in GetSerialObject
  614. LocalFree(pHWHead->pHWObj);
  616. LocalFree(pHWHead);
  618. DEBUGMSG(1, (TEXT("-SerDeinitrn")));
  620. return (TRUE);
  621. }
  623. /*************************************************************************
  624.  @doc OEM
  625.  @func BOOL | SerOpen | This routine is called when the port is opened.
  626.  *  Not exported to users, only to driver.
  627.  *
  628.  @rdesc Returns TRUE if successful, FALSEotherwise.
  629.  ************************************************************************/
  630. static
  631. BOOL SerOpen(PVOID   pHead) /*@parm PVOID returned by Serinit. */
  632. {
  633. PSER_INFO pHWHead = (PSER_INFO)pHead;
  635. DEBUGMSG(1,
  636. (TEXT("SerOpen+rn")));
  638. // Disallow multiple simultaneous opens
  639. if (pHWHead->cOpenCount)
  640. return (FALSE);
  641.     
  642. pHWHead->cOpenCount++;
  644. #ifdef POLL_FOR_DISCONNECT
  645. // Yuck.  We want to poll for detaches when the device is open.
  646. // But right now, the IST is in a wait infinite.  Spoof an interrupt
  647. // to let him know we have been opened and he needs to start polling.
  648. SetEvent(pHWHead->hSerialEvent);
  649. #endif
  651. return (TRUE);
  652. }
  654. /*************************************************************************
  655.  @doc OEM
  656.  @func ULONG | SerClose | This routine closes the device identified by the 
  657.  *  PVOID returned by SerInit.
  658.  *  Not exported to users, only to driver.
  659.  *
  660.  @rdesc The return value is 0.
  661.  ************************************************************************/
  662. static
  663. ULONG SerClose(PVOID   pHead)   // @parm PVOID returned by SerInit.
  664. {
  665. PSER_INFO pHWHead = (PSER_INFO)pHead;
  667. DEBUGMSG (1, (TEXT("++SerClosern")));
  669. if (pHWHead->cOpenCount) 
  670. {
  671. DEBUGMSG (1, (TEXT("SerClose, closing devicern")));
  672. pHWHead->cOpenCount--;
  674. #ifdef TODO
  675. // Do we need something similar on USB???
  676. // while we are still transmitting, sleep.
  677. uTries = 0;
  679. while ( ((pHWHead->ser16550.IER = READ_PORT_UCHAR(pHWHead->ser16550.pIER)) 
  680. & SERIAL_IER_THR) && // indicates TX in progress
  681. (uTries++ < 100) &&     // safety net
  682. // indicates FIFO not yet empty
  683. !(pHWHead->ser16550.LSR & SERIAL_LSR_TEMT)) 
  684. {
  686. DEBUGMSG(1, (TEXT("SerClose, TX in progress, IER 0x%X, LSR 0x%Xrn"),
  687. *pHWHead->ser16550.pIER, pHWHead->ser16550.LSR));
  688. Sleep(10);
  689. }
  690. #endif
  692. // TODO - When the device is closed, should power it down or somehow try to
  693. // let the desktop know that we aren't doing anything with any data that it
  694. // might be sending our way..
  695.     
  696. // Mask interrupts? - No, we wont see any more traffic - MBE.
  697. //pHWHead->pIrqCtrlAddr->icmr.sp0 = 0;
  698. }
  700. DEBUGMSG(1,(TEXT("--SerClosern")));
  702. return (0);
  703. }
  705. /*************************************************************************
  706.  @doc OEM
  707.  @func ULONG | SerRxIntr | This routine gets several characters from the 
  708. hardware receive buffer and puts them in a buffer provided via the se-
  709. cond argument. It returns the number of bytes lost to overrun.
  711.  @rdesc The return value indicates the number of overruns detected.
  712. The actual number of dropped characters may be higher.
  713. **************************************************************************/
  714. static
  715. ULONG SerRxIntr(PVOID pHead,                // @parm Pointer to hardware head
  716. PUCHAR pRxBuffer,           // @parm Pointer to receive buffer
  717. ULONG *pBufflen )           // @parm In = max bytes to read, out = bytes read
  718. {
  719. PSER_INFO   pHWHead  = (PSER_INFO)pHead;
  720. ULONG       RetVal  = 0;
  721. ULONG       TargetRoom  = *pBufflen;
  722. BOOL        fRXFlag  = FALSE;
  723. BOOL        fReplaceparityErrors = FALSE;
  724. BOOL        fNull;
  725. UCHAR       cEvtChar;
  726. PUCHAR      pRxOrig  = pRxBuffer;
  728. DEBUGMSG(1, (TEXT("++SerRxIntr %drn"), *pBufflen));
  730. cEvtChar = pHWHead->dcb.EvtChar;
  731. fNull  = pHWHead->dcb.fNull;
  733. if( pHWHead->dcb.fErrorChar && pHWHead->dcb.fParity )
  734. fReplaceparityErrors = TRUE;
  735.   
  736. // Protect the following from collision on hardware registers.
  737. // In particular, we can't let anyone else do SC2440_USB_ accesses between
  738. // time we set the read address and time we do the actual read in 
  739. // the loop below.
  740. EnterCriticalSection(&(pHWHead->HwRegCritSec));
  742. fRXFlag = SC2440_USB_RxIntHandler(pHWHead, pRxBuffer, pBufflen);
  744. LeaveCriticalSection(&(pHWHead->HwRegCritSec));
  746. // if we saw one (or more) EVT chars, then generate an event
  747. if( fRXFlag )
  748. EvaluateEventFlag( pHWHead->pMddHead, EV_RXFLAG );
  750. #ifdef DEBUG
  751. if( ZONE_RXDATA )
  752. CELOGDATA(1, CELID_RAW_UCHAR, pRxOrig, (WORD)*pBufflen, 1, CELZONE_MISC);
  753. #endif
  755. DEBUGMSG(1, (TEXT("--SerRxIntr - rx %d, drop %d.rn"),
  756. *pBufflen,
  757. pHWHead->DroppedBytes));
  759. RetVal       = pHWHead->DroppedBytes;
  760. pHWHead->DroppedBytes = 0;
  762. return RetVal;
  763. }
  765. /*************************************************************************
  766. @doc OEM
  767. @func PVOID | SerGetRxStart | This routine returns the start of the 
  768. hardware receive buffer.  See SerGetRxBufferSize.
  769.  
  770. @rdesc The return value is a pointer to the start of the device 
  771. receive buffer.
  772. *************************************************************************/ 
  773. static
  774. PVOID SerGetRxStart( PVOID   pHead ) // @parm PVOID returned by Serinit.
  775. {
  776. DEBUGMSG(1, (TEXT("SerGetRxStartrn")));   
  778. return  NULL;
  779. }
  781. /*************************************************************************
  782. @doc OEM
  783. @func ULONG | SerGetInterruptType | This function is called
  784. by the MDD whenever an interrupt occurs.  The return code
  785. is then checked by the MDD to determine which of the four
  786. interrupt handling routines are to be called.
  788. @rdesc This routine returns a bitmask indicating which interrupts
  789. are currently pending.
  790. *************************************************************************/ 
  791. static
  792. INTERRUPT_TYPE SerGetInterruptType( PVOID pHead ) // Pointer to hardware head
  793. {
  794. PSER_INFO pHWHead = (PSER_INFO)pHead;
  795. INTERRUPT_TYPE interrupts=0;
  796.     
  797. DEBUGMSG(1, (TEXT("++SerGetInterruptType 0x%Xrn"), pHead));
  799. interrupts = SC2440_USB_GetInterruptType(pHWHead);
  801. if (INTR_LINE & interrupts)
  802. {
  803. pHWHead->dConfIdx = 0;
  804. SignalRemoval(pHWHead);
  805. }
  807. #ifdef POLL_FOR_DISCONNECT
  809. //interrupts = HW_GetInterruptType(pHWHead);
  811. //RETAILMSG(1, (TEXT("interrupts = 0x%xrn"), interrupts));
  813. if (interrupts) 
  814. {
  815. pHWHead->wSOFStableCnt = 0;
  816. //RETAILMSG(1, (TEXT("pHWHead->wSOFStableCnt = 0x%xrn"), pHWHead->wSOFStableCnt));
  817. } 
  818. else if (pHWHead->dConfIdx && (pHWHead->wPrevSOF == pHWHead->wSOF))
  819. {
  820. if (++pHWHead->wSOFStableCnt > SOF_STABLE_MAX)
  821. {
  822. //RETAILMSG(1, (TEXT("DCD Dropped due to: wSOFStableCnt: %urn"), pHWHead->wSOFStableCnt));
  823. pHWHead->dConfIdx = 0;
  824. SignalRemoval(pHWHead);
  825. }
  826. }
  828. #endif
  830. DEBUGMSG (1, (TEXT("--SerGetInterruptType 0x%X, 0x%Xrn"),
  831. pHead, interrupts));
  832. return interrupts;
  833. }
  835. /*************************************************************************
  836. @doc OEM
  837. @func ULONG | SerModemIntr | This routine is called from the MDD
  838. whenever INTR_MODEM is returned by SerGetInterruptType.
  840. @rdesc None
  841. *************************************************************************/
  842. static
  843. VOID SerModemIntr( PVOID pHead )               // Hardware Head
  844. {
  845. PSER_INFO pHWHead = (PSER_INFO)pHead;
  846. DWORD dwModemStatus;
  848. dwModemStatus = pHWHead->ModemStatus;
  850. DEBUGMSG(1, (TEXT("+++SerModemIntrrn")));  
  851.     
  852. SC2440_USB_DoEndpoint0(pHWHead, &dwModemStatus);
  854. if ( pHWHead->dConfIdx ) 
  855. {
  856. if ( pHWHead->cOpenCount) 
  857. {
  858. // If open, notify app of any control line changes.
  859. DEBUGMSG(1, (TEXT("Modem Status %2.2X <> %2.2Xrn"),
  860. pHWHead->ModemStatus, dwModemStatus));
  862. if( (pHWHead->ModemStatus & MS_DSR_ON) != (dwModemStatus & MS_DSR_ON) )
  863. EvaluateEventFlag(pHWHead->pMddHead, EV_DSR);
  865. if( (pHWHead->ModemStatus & MS_CTS_ON) != (dwModemStatus & MS_CTS_ON) )
  866. EvaluateEventFlag(pHWHead->pMddHead, EV_CTS);
  868. if( (pHWHead->ModemStatus & MS_RLSD_ON) != (dwModemStatus & MS_RLSD_ON) )
  869. EvaluateEventFlag(pHWHead->pMddHead, EV_RLSD);
  871. } else {
  872. // If RLSD transitioned to active, we need to generate event.
  873. if( (dwModemStatus & MS_RLSD_ON) && !(pHWHead->ModemStatus & MS_RLSD_ON) ) 
  874. {
  876. if ( IsAPIReady(SH_WMGR) ) 
  877. {
  878. CeEventHasOccurred (NOTIFICATION_EVENT_RS232_DETECTED, NULL);
  879. }
  880. DEBUGMSG (0, (TEXT("Indicated RS232 Cable Eventrn")));
  881. }
  882. }
  883.    }
  884.    pHWHead->ModemStatus = dwModemStatus;
  886. DEBUGMSG(1, (TEXT("---SerModemIntrrn")));   
  887. }
  889. /*************************************************************************
  890. @doc OEM
  891. @func ULONG | SerLineIntr | This routine is called from the MDD
  892. whenever INTR_LINE is returned by SerGetInterruptType.
  894. @rdesc None
  895. *************************************************************************/
  896. static
  897. VOID SerLineIntr( PVOID pHead )               // Hardware Head
  898. {
  899. PSER_INFO pHWHead = (PSER_INFO)pHead;
  901. DEBUGMSG(1, (TEXT("SerLineIntrrn")));
  903.   // USB serial doesn't have a concept of anything like the LSR.
  904. // But since a bus reset is what we sort of equate to DCD, I use
  905. // this routine to handle USB reset conditions.
  907. // Note that by the time we get here with an SC2440_USB , we are actually
  908. //plugged back into the bus. I added some polling code to try and detect
  909. // detaches sooner
  910. SC2440_USB_LineIntHandler(pHWHead);  // Re-initialize the hardware    
  911. }
  913. /*************************************************************************
  914. @doc OEM
  915. @func ULONG | SerGetRxBufferSize | This function returns
  916. the size of the hardware buffer passed to the interrupt
  917. initialize function.  It would be used only for devices
  918. which share a buffer between the MDD/PDD and an ISR.
  920. @rdesc This routine always returns 0 for 16550 UARTS.
  921. **************************************************************************/
  922. static
  923. ULONG SerGetRxBufferSize( PVOID pHead )
  924. {
  925. DEBUGMSG(1, (TEXT("SerGetRxBufferSizern")));  
  926. return 10280;
  927. }
  929. /*************************************************************************
  930. @doc OEM
  931. @func ULONG | SerTXIntr | This routine is called from the new MDD
  932. whenever INTR_TX is returned by SerGetInterruptType.  It is 
  933. responsible for loading up the TX FIFO with next block of data.
  935. @rdesc None
  936. **************************************************************************/
  937. static
  938. VOID SerTxIntr( PVOID pHead,            // Hardware Head
  939. PUCHAR pTxBuffer,       // @parm Pointer to receive buffer
  940. ULONG *pBuffLen ) // @parm In = max bytes to transmit,
  941.             //       out = bytes transmitted
  942. {
  943. PSER_INFO pHWHead = (PSER_INFO)pHead;
  945. DEBUGMSG(1, (TEXT("SerTxIntr+rn")));
  947. pHWHead->CommErrors &= ~CE_TXFULL;
  949. SC2440_USB_TxIntHandler(pHWHead, pTxBuffer, pBuffLen);
  951. DEBUGMSG(1, (TEXT("SerTxIntr-, %d bytesrn"), *pBuffLen));  
  952. }
  954. /*************************************************************************
  955. @doc OEM
  956. @func BOOL | SerPowerOff | Called by driver to turn off power to 
  957. serial port.
  958. Not exported to users, only to driver.
  959.  
  960. @rdesc This routine returns a status.
  961.  ************************************************************************/
  962. static
  963. BOOL SerPowerOff( PVOID   pHead )      // @parm PVOID returned by SerInit.
  964. {
  965. PSER_INFO pHWHead = (PSER_INFO)pHead;
  966. pHWHead->cOpenCount = 0;
  968. //RETAILMSG(1,(TEXT("USB : SerPowerOff rn")));
  970. /*
  971. if ( pHWHead->cOpenCount )
  972. {
  973. EvaluateEventFlag( pHWHead->pMddHead, EV_RXFLAG );
  974. }
  976. return (TRUE);
  977. */
  978.     return HW_PowerOff(pHead);
  980. }
  982. /*************************************************************************
  983. @doc OEM
  984. @func BOOL | SerPowerOn | 
  985. Called by driver to turn on power to serial port.
  986. Not exported to users, only to driver.
  987.  
  988. @rdesc This routine returns a status.
  989.  ************************************************************************/
  990. static
  991. BOOL SerPowerOn( PVOID   pHead )      // @parm PVOID returned by SerInit.
  992. {
  993. PSER_INFO pHWHead = (PSER_INFO)pHead;
  995. //RETAILMSG(1,(TEXT("USB : SerPowerOn rn")));
  997.     return HW_PowerOn(pHead);
  998. }
  1000. /*************************************************************************
  1001. @doc OEM
  1002. @func void | SerClearDtr | This routine clears DTR.
  1004. @rdesc None.
  1005. **************************************************************************/
  1006. static
  1007. VOID SerClearDTR( PVOID   pHead ) // @parm PVOID returned by HWinit.
  1008. {
  1009. DEBUGMSG(1, (TEXT("SerClearDTR, 0x%Xrn"), pHead));
  1011. // We don't support DTR emulation.
  1012. }
  1014. /*************************************************************************
  1015. @doc OEM
  1016. @func VOID | SerSetDTR | This routine sets DTR.
  1017.  
  1018. @rdesc None.
  1019. **************************************************************************/
  1020. static
  1021. VOID SerSetDTR( PVOID   pHead ) // @parm PVOID returned by HWinit.
  1022. {    
  1023. DEBUGMSG(1, (TEXT("SerSetDTR, 0x%Xrn"), pHead));
  1025. // We don't support DTR emulation.
  1026. }
  1028. /*************************************************************************
  1029. @doc OEM
  1030. @func VOID | SerClearRTS | This routine clears RTS.
  1031.  
  1032. @rdesc None.
  1033. **************************************************************************/
  1034. static
  1035. VOID SerClearRTS( PVOID   pHead ) // @parm PVOID returned by HWinit.
  1036. {
  1037. DEBUGMSG(1, (TEXT("SerClearRTS, 0x%Xrn"), pHead));
  1039. // We don't support RTS emulation.
  1040. }
  1042. /*************************************************************************
  1043. @doc OEM
  1044. @func VOID | SerSetRTS | This routine sets RTS.
  1046. @rdesc None.
  1047. **************************************************************************/
  1048. static
  1049. VOID SerSetRTS( PVOID   pHead ) // @parm PVOID returned by HWinit.
  1050. {
  1051. DEBUGMSG(1, (TEXT("SerSetRTS, 0x%Xrn"), pHead));
  1053. // We don't support RTS emulation.
  1054. }
  1056. /*************************************************************************
  1057. @doc OEM
  1058. @func BOOL | SerEnableIR | This routine enables ir.
  1059. Not exported to users, only to driver.
  1061. @rdesc Returns TRUE if successful, FALSEotherwise.
  1062. **************************************************************************/
  1063. static
  1064. BOOL SerEnableIR( PVOID   pHead, // @parm PVOID returned by Serinit.
  1065.   ULONG   BaudRate ) // @parm PVOID returned by HWinit.
  1066. {
  1067. PSER_INFO pHWHead = (PSER_INFO)pHead;
  1069. DEBUGMSG(1, (TEXT("SerEnableIR, 0x%Xrn"), pHead));
  1071. // We don't support an IR mode, so fail.
  1072. return (FALSE);
  1073. }
  1075. /*************************************************************************
  1076. @doc OEM
  1077. @func BOOL | SerDisableIR | This routine disable the ir.
  1078. Not exported to users, only to driver.
  1079.  
  1080. @rdesc Returns TRUE if successful, FALSEotherwise.
  1081. **************************************************************************/
  1082. static
  1083. BOOL SerDisableIR( PVOID   pHead ) // @parm PVOID returned by Serinit. 
  1084. {
  1085. PSER_INFO pHWHead = (PSER_INFO)pHead;
  1087. DEBUGMSG(1, (TEXT("SerDisableIR, 0x%Xrn"), pHead));
  1089. // We don't support an IR mode.  But don't fail, in case
  1090. // someone calls this redundantly to ensure that we are
  1091. // in wired mode, which is what we support.
  1092. return (TRUE);
  1093. }
  1095. /*************************************************************************
  1096. @doc OEM
  1097. @func VOID | SerClearBreak | This routine clears break.
  1098.  
  1099. @rdesc None.
  1100. *************************************************************************/ 
  1101. static
  1102. VOID SerClearBreak( PVOID   pHead ) // @parm PVOID returned by HWinit.
  1103. {
  1104. DEBUGMSG(1, (TEXT("SerClearBreak, 0x%Xrn"), pHead));
  1106. // We don't have a concept of break over USB serial
  1107. }
  1109. /*************************************************************************
  1110. @doc OEM
  1111. @func VOID | SerSetBreak | This routine sets break.
  1113. @rdesc None.
  1114. *************************************************************************/
  1115. static
  1116. VOID SerSetBreak( PVOID   pHead ) // @parm PVOID returned by HWinit.
  1117. {
  1118. DEBUGMSG(1, (TEXT("SerSetBreak, 0x%Xrn"), pHead));
  1120. // We don't have a concept of break over USB serial
  1121. }
  1123. /*************************************************************************
  1124. @doc OEM
  1125. @func BOOL | SerXmitComChar | Transmit a char immediately
  1126.  
  1127. @rdesc TRUE if succesful
  1128. *************************************************************************/
  1129. static
  1130. BOOL SerXmitComChar( PVOID   pHead,     // @parm PVOID returned by HWInit.
  1131.      UCHAR   ComChar )  // @parm Character to transmit. 
  1132. {
  1133. PSER_INFO pHWHead = (PSER_INFO)pHead;
  1134.     
  1135. DEBUGMSG(1, (TEXT("+SerXmitComChar 0x%Xrn"), pHead));
  1137. // Get critical section, then transmit when buffer empties
  1138. DEBUGMSG(1, (TEXT("XmitComChar wait for CritSec %x.rn"),
  1139. &(pHWHead->TransmitCritSec)));
  1141. EnterCriticalSection(&(pHWHead->TransmitCritSec));
  1143. DEBUGMSG(1, (TEXT("XmitComChar got CritSec %x.rn"),
  1144. &(pHWHead->TransmitCritSec)));
  1145. try
  1146.     {
  1148. // TODO - We need to wait for the current transmit to finish and
  1149. // then sneak this data in ahead of whatever else is queued.
  1150. #ifdef TODO
  1151. while( TRUE )  // We know THR will eventually empty
  1152. {
  1153. // Write the character if we can
  1154. ReadLSR( pHWHead );
  1155. if( pHWHead->LSR & SERIAL_LSR_THRE ) 
  1156. {
  1157. OUTB(pHWHead, pData, ComChar);
  1158. DEBUGMSG(1, (TEXT("XmitComChar wrote x%Xrn"), ComChar));
  1159. break;
  1160. }
  1162. // If we couldn't write the data yet, then wait for a
  1163. // TXINTR to come in and try it again.
  1164.             
  1165. // Enable xmit intr.
  1166. OUTB(pHWHead, pIER, IER_NORMAL_INTS | SERIAL_IER_THR);
  1167. // Wait until the txintr has signalled.
  1168. DEBUGMSG(1, (TEXT("XmitComChar WaitIntr x%Xrn"),
  1169. pHWHead->FlushDone));
  1170. WaitForSingleObject(pHWHead->FlushDone, (ULONG)1000);
  1171. }
  1172. #else
  1173. DEBUGMSG (0, (TEXT("!!! SerXmitComChar 0x%X not implementedrn"),
  1174.    pHead));
  1175. #endif        
  1176. }
  1177. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
  1178. EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) 
  1179. {
  1180. // Just exit
  1181. }
  1182.     
  1183. LeaveCriticalSection(&(pHWHead->TransmitCritSec));
  1185. DEBUGMSG(1, (TEXT("XmitComChar released CritSec %x.rn"),
  1186. &(pHWHead->TransmitCritSec)));
  1187.     
  1188. DEBUGMSG(1, (TEXT("-SerXmitComChar 0x%Xrn"), pHead));
  1189.     
  1190. return TRUE;
  1191. }
  1192.         
  1194. /*************************************************************************
  1195. @doc OEM
  1196. @func ULONG | SerGetStatus | This structure is called by the MDD
  1197. to retrieve the contents of a COMSTAT structure.
  1199. @rdesc The return is a ULONG, representing success (0) or failure (-1).
  1200. *************************************************************************/
  1201. static
  1202. ULONG SerGetStatus( PVOID pHead, // @parm PVOID returned by HWInit.
  1203. LPCOMSTAT lpStat )// Pointer to LPCOMMSTAT to hold status.
  1204. {
  1205. PSER_INFO pHWHead  = (PSER_INFO)pHead;
  1206. ULONG RetVal  = pHWHead->CommErrors;
  1207.     
  1208. DEBUGMSG(1, (TEXT("++SerGetStatus 0x%Xrn"), pHead));
  1210. pHWHead->CommErrors = 0; // Clear old errors each time
  1212. // We don't emulate any of this, so always return a fixed result.
  1213. if (lpStat) 
  1214. {
  1215. // TODO - Make sure we return reasonable results here.
  1216. pHWHead->Status.fCtsHold = 0;
  1217. pHWHead->Status.fDsrHold = 0;
  1218. pHWHead->Status.cbInQue  = 0;
  1219. pHWHead->Status.cbOutQue = 0;
  1220. }
  1221. else
  1222. RetVal = (ULONG)-1;
  1224. DEBUGMSG(1, (TEXT("--SerGetStatus 0x%Xrn"), pHead));
  1226. return RetVal;
  1227. }
  1229. /*************************************************************************
  1230. @doc OEM
  1231. @func ULONG | SerReset | Perform any operations associated
  1232. with a device reset
  1234. @rdesc None.
  1235. *************************************************************************/
  1236. static
  1237. VOID SerReset( PVOID   pHead ) // @parm PVOID returned by HWInit.
  1238. {
  1239. PSER_INFO pHWHead = (PSER_INFO)pHead;
  1241. DEBUGMSG(1, (TEXT("++SerReset 0x%Xrn"), pHead));
  1243. memset(&pHWHead->Status, 0, sizeof(COMSTAT));
  1245. // TODO - Is there anything special we need to do here.
  1246.     
  1247. DEBUGMSG(1, (TEXT("--SerReset 0x%Xrn"), pHead));
  1248. }
  1250. /*************************************************************************
  1251. @doc OEM
  1252. @func VOID | SerGetModemStatus | Retrieves modem status.
  1254. @rdesc None.
  1255. *************************************************************************/
  1256. static
  1257. VOID SerGetModemStatus( PVOID   pHead,        // @parm PVOID returned by HWInit.
  1258. PULONG  pModemStatus ) // @parm PULONG passed in by user.
  1259. {
  1260. PSER_INFO pHWHead = (PSER_INFO)pHead;
  1261.     
  1262. DEBUGMSG(1, (TEXT("++SerGetModemStatus 0x%Xrn"), pHead));
  1264. *pModemStatus = pHWHead->ModemStatus;
  1266. DEBUGMSG (0, (TEXT("--SerGetModemStatus 0x%X (stat x%X) rn"),
  1267. pHead,
  1268. *pModemStatus));
  1269. return;
  1270. }
  1272. /*************************************************************************
  1273. @doc OEM
  1274. @func VOID | SerGetCommProperties | Retrieves Comm Properties.
  1275.  
  1276. @rdesc None.
  1277. *************************************************************************/
  1278. static
  1279. VOID SerGetCommProperties( 
  1280. PVOID   pHead, // @parm PVOID returned by SerInit. 
  1281. LPCOMMPROP  pCommProp ) // @parm Pointer to receive COMMPROP structure. 
  1282. {
  1283. PSER_INFO pHWHead = (PSER_INFO)pHead;
  1285. DEBUGMSG(1, (TEXT("SerGetCommProperties 0x%Xrn"), pHead));
  1287. *pCommProp = pHWHead->CommProp;
  1288. return;
  1289. }
  1291. /*************************************************************************
  1292. @doc OEM
  1293. @func VOID | SerPurgeComm | Purge RX and/or TX
  1294.  
  1295. @rdesc None.
  1296. *************************************************************************/
  1297. static
  1298. VOID SerPurgeComm( PVOID   pHead,  // @parm PVOID returned by HWInit.
  1299.    DWORD   fdwAction )  // @parm Action to take. 
  1300. {
  1301. PSER_INFO pHWHead = (PSER_INFO)pHead;
  1302.     
  1303. DEBUGMSG(1, (TEXT("++SerPurgeComm 0x%Xrn"), pHead));
  1305. EnterCriticalSection(&(pHWHead->HwRegCritSec));
  1307. if ( (fdwAction & PURGE_TXCLEAR) || (fdwAction & PURGE_TXABORT) ) 
  1308. {
  1309. // Abort any pending TX data.  The MDD takes care of aborting
  1310. // data pended in the driver.  All I can do to stop an IN that
  1311. // has already been queued is to Un-Arm this endpoint, causing
  1312. // subsequent INs to get naked.  If the IN transfer has started, 
  1313. // its not clear I can stop it in progress.
  1314. // In addition to NAKing host, clearing ARM tells TxIntr that he
  1315. // can use the buffer for the next write that comes down.
  1317. #if TODO
  1318. ucECR = SC2440_USB_Read(pHWHead, EP1AControl);
  1319. ucECR &= 0xFE;   // Clear the ARM bit.
  1321. SC2440_USB_Write(pHWHead, EP1AControl, ucECR );
  1322. #endif
  1323. }
  1325. if ( (fdwAction & PURGE_RXCLEAR) || (fdwAction & PURGE_RXABORT) ) {
  1326. #if TODO
  1327. // Abort any pending RX data.
  1328. SC2440_USB_Write(pHWHead, IntStatus, 0x04 );   // Clear the EP2 interrupt
  1329. SC2440_USB_Write(pHWHead, EP2AControl, 0x03);  // Reenable the endpoint
  1330. #endif
  1331. }
  1332.     
  1333. LeaveCriticalSection(&(pHWHead->HwRegCritSec));
  1335. DEBUGMSG(1,
  1336. (TEXT("--SerPurgeComm 0x%Xrn"), pHead));
  1337. return;
  1338. }
  1340. /************************************************************************
  1341. @doc OEM
  1342. @func BOOL | SerSetDCB | Sets new values for DCB.  This
  1343. routine gets a DCB from the MDD.  It must then compare
  1344. this to the current DCB, and if any fields have changed take
  1345. appropriate action.
  1346.  
  1347. @rdesc BOOL
  1348. ************************************************************************/
  1349. static
  1350. BOOL SerSetDCB( PVOID   pHead,     // @parm PVOID returned by HWInit.
  1351. LPDCB   lpDCB )     // @parm    Pointer to DCB structure
  1352. {
  1353. PSER_INFO pHWHead = (PSER_INFO)pHead;
  1354. BOOL bRet;
  1355.     
  1356. DEBUGMSG(1, (TEXT("++SerSetDCB 0x%Xrn"), pHead));
  1358. bRet = TRUE;
  1360. // If the device is open, scan for changes and do whatever
  1361. // is needed for the changed fields.  if the device isn't
  1362. // open yet, just save the DCB for later use by the open.
  1363. if( pHWHead->OpenCount ) 
  1364. {
  1365. #ifdef TODO
  1366. // We don't really support any of this.  Ignore for now
  1367. // Note, fparity just says whether we should check
  1368. // receive parity.  And the 16550 won't let us NOT
  1369. // check parity if we generate it.  So this field
  1370. // has no effect on the hardware.
  1371.     
  1372. if ( lpDCB->BaudRate != pHWHead->dcb.BaudRate ) 
  1373. {
  1374. bRet = SerSetBaudRate( pHWHead, lpDCB->BaudRate );
  1375. }
  1376.     
  1377. if ( bRet && (lpDCB->ByteSize != pHWHead->dcb.ByteSize )) 
  1378. {
  1379. bRet = SerSetByteSize( pHWHead, lpDCB->ByteSize );
  1380. }
  1381.     
  1382. if ( bRet && (lpDCB->Parity != pHWHead->dcb.Parity )) 
  1383. {
  1384. bRet = SerSetParity( pHWHead, lpDCB->Parity );
  1385. }
  1386.     
  1387. if ( bRet && (lpDCB->StopBits != pHWHead->dcb.StopBits )) 
  1388. {
  1389. bRet = SerSetStopBits( pHWHead, lpDCB->StopBits );
  1390. }
  1392. // Don't worry about fOutxCtsFlow.  It is a flag which
  1393. // will be examined every time we load the TX buffer.
  1394. // No special action required here.
  1395. #endif         
  1396. }
  1397.     
  1398. if (bRet) 
  1399. {
  1400. // Now that we have done the right thing, store this DCB
  1401. pHWHead->dcb = *lpDCB;
  1402. }
  1404. DEBUGMSG(1, (TEXT("--SerSetDCB 0x%Xrn"), pHead));
  1406. return bRet;
  1407. }
  1409. /*************************************************************************
  1410. @doc OEM
  1411. @func BOOL | SerSetCommTimeouts | Sets new values for the
  1412. CommTimeouts structure. routine gets a DCB from the MDD.  It
  1413. must then compare this to the current DCB, and if any fields
  1414. have changed take appropriate action.
  1416. @rdesc ULONG
  1417. *************************************************************************/
  1418. static
  1419. ULONG SerSetCommTimeouts( 
  1420. PVOID   pHead,   // @parm PVOID returned by HWInit.
  1421. LPCOMMTIMEOUTS   lpCommTimeouts ) // @parm Pointer to CommTimeout structure
  1422. {
  1423. PSER_INFO pHWHead = (PSER_INFO)pHead;
  1424. ULONG retval      = 0;
  1425.     
  1426. DEBUGMSG(1, (TEXT("++SerSetCommTimeout 0x%Xrn"), pHead));
  1428. // OK, first check for any changes and act upon them
  1429. if( lpCommTimeouts->WriteTotalTimeoutMultiplier !=
  1430. pHWHead->CommTimeouts.WriteTotalTimeoutMultiplier )
  1431. {
  1433. }
  1434.     
  1435. // Now that we have done the right thing, store this DCB
  1436. pHWHead->CommTimeouts = *lpCommTimeouts;
  1438. DEBUGMSG(1, (TEXT("--SerSetCommTimeout 0x%Xrn"), pHead));
  1440. return retval;
  1441. }
  1443. /*************************************************************************
  1444.     @doc OEM
  1445.     @func    BOOL | SerIoctl | Device IO control routine.  
  1446.     @parm DWORD | dwOpenData | value returned from COM_Open call
  1447.     @parm DWORD | dwCode | io control code to be performed
  1448.     @parm PBYTE | pBufIn | input data to the device
  1449.     @parm DWORD | dwLenIn | number of bytes being passed in
  1450.     @parm PBYTE | pBufOut | output data from the device
  1451.     @parm DWORD | dwLenOut |maximum number of bytes to receive from device
  1452.     @parm PDWORD | pdwActualOut | actual number of bytes received from device
  1454.     @rdesc        Returns TRUE for success, FALSE for failure
  1456.     @remark  The MDD will pass any unrecognized IOCTLs through to this function.
  1457. *************************************************************************/
  1458. static
  1459. BOOL SerIoctl(PVOID pHead, DWORD dwCode,PBYTE pBufIn,DWORD dwLenIn,
  1460.          PBYTE pBufOut,DWORD dwLenOut,PDWORD pdwActualOut)
  1461. {
  1462. PSER_INFO pHWHead = (PSER_INFO)pHead;
  1463.   BOOL RetVal = TRUE;
  1465. DEBUGMSG(1, (TEXT("++SerIoctl 0x%Xrn"), pHead));
  1467. switch (dwCode) 
  1468. {
  1469. // Currently, no defined IOCTLs
  1470. default:
  1471. RetVal = FALSE;
  1473. DEBUGMSG(1, (TEXT(" Unsupported ioctl 0x%Xrn"), dwCode));
  1474. break;            
  1475. }
  1477. DEBUGMSG(1, (TEXT("--SerIoctl 0x%Xrn"), pHead));
  1479. return(RetVal);
  1480. }
  1482. const
  1483. HW_VTBL IoVTbl = {
  1484.     SerInit,
  1485.     SerPostInit,
  1486.     SerDeinit,
  1487.     SerOpen,
  1488.     SerClose,
  1489.     SerGetInterruptType,
  1490.     SerRxIntr,
  1491.     SerTxIntr,
  1492.     SerModemIntr,
  1493.     SerLineIntr,
  1494.     SerGetRxBufferSize,
  1495.     SerPowerOff,
  1496.     SerPowerOn,
  1497.     SerClearDTR,
  1498.     SerSetDTR,
  1499.     SerClearRTS,
  1500.     SerSetRTS,
  1501.     SerEnableIR,
  1502.     SerDisableIR,
  1503.     SerClearBreak,
  1504.     SerSetBreak,
  1505.     SerXmitComChar,
  1506.     SerGetStatus,
  1507.     SerReset,
  1508.     SerGetModemStatus,
  1509.     SerGetCommProperties,
  1510.     SerPurgeComm,
  1511.     SerSetDCB,
  1512.     SerSetCommTimeouts,
  1513.     SerIoctl};
  1515. extern const HW_VTBL SerCardIoVTbl;
  1517. PHWOBJ
  1518. GetSerialObject( DWORD DeviceArrayIndex )
  1519. {
  1520. PHWOBJ pSerObj;
  1522. // We do not have a statically allocated array of HWObjs.  Instead, we 
  1523. // allocate a new HWObj for each instance of the driver.  The MDD will 
  1524. // always call GetSerialObj/HWInit/HWDeinit in that order, so we can do 
  1525. // the alloc here and do any subsequent free in HWDeInit.
  1526.   
  1527. // Allocate space for the HWOBJ.
  1528. pSerObj = (PHWOBJ)LocalAlloc( LPTR, sizeof(HWOBJ) );
  1529. if ( !pSerObj )
  1530. return (NULL);
  1532. // Fill in the HWObj structure that we just allocated.
  1533. pSerObj->BindFlags = THREAD_IN_PDD;      // We take care of our own IST
  1534. pSerObj->dwIntID = SYSINTR_USBD;   // SysIntr 
  1535. pSerObj->pFuncTbl = (HW_VTBL *) &IoVTbl; // Return pointer to functions
  1537. // Now return this structure to the MDD.
  1538. return (pSerObj);
  1539. }