usbprn.c

cayman提供的PXA270 wince下的bsp源码包

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
/*++

THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name: 
    usbprn.c

Abstract:
    USB Client Driver for Print Device Class.

Functions:

Notes: 

--*/

#include "usbprn.h"

#ifdef DEBUG
DBGPARAM dpCurSettings = {
    TEXT("USBPRN"), {
    TEXT("Errors"),    TEXT("Warnings"),  TEXT("Init"),        TEXT("Trace"),
    TEXT("LPT_INIT"),  TEXT("LPT_READ"),  TEXT("LPT_WRITE"),   TEXT("LPT_IOCTL"),
    TEXT("USB_PARSE"), TEXT("USB_INIT"),  TEXT("USB_CONTROL"), TEXT("USB_BULK"),
    TEXT("Undefined"), TEXT("Undefined"), TEXT("Undefined"),   TEXT("USBCLIENT")  
    },
     0x0003 // ZONE_WRN|ZONE_ERR
};
#endif  // DEBUG


BOOL WINAPI 
DeviceNotify(
   LPVOID lpvNotifyParameter,
   DWORD dwCode,
   LPDWORD * dwInfo1,
   LPDWORD * dwInfo2,
   LPDWORD * dwInfo3,
   LPDWORD * dwInfo4
   );

VOID
RemoveDeviceContext(
   PUSBPRN_CONTEXT pUsbPrn
   );


#ifdef DEBUG
BOOL
UsbPrnTest(
   PUSBPRN_CONTEXT  pUsbPrn
   );
#endif


BOOL 
USBInstallDriver(
   LPCWSTR szDriverLibFile 
   )
{
    HKEY  hKey = NULL;
    BOOL  bRc;

    const WCHAR wsUsbDeviceID[] = CLASS_NAME_SZ;
    WCHAR wsSubClassRegKey[sizeof(CLIENT_REGKEY_SZ)+16] = CLIENT_REGKEY_SZ;

    USB_DRIVER_SETTINGS usbDriverSettings = { DRIVER_SETTINGS };

    DWORD dwPortStatusTimeout = GET_PORT_STATUS_TIMEOUT;
    DWORD dwDeviceIdTimeout   = GET_DEVICE_ID_TIMEOUT;
    DWORD dwSoftResetTimeout  = SOFT_RESET_TIMEOUT;

    DWORD dwReadTimeoutMultiplier  = READ_TIMEOUT_MULTIPLIER;
    DWORD dwReadTimeoutConstant    = READ_TIMEOUT_CONSTANT;
    DWORD dwWriteTimeoutMultiplier = WRITE_TIMEOUT_MULTIPLIER;
    DWORD dwWriteTimeoutConstant   = WRITE_TIMEOUT_CONSTANT;

    REG_VALUE_DESCR usbPrnKeyValues[] = {
        (TEXT("Dll")),               REG_SZ,    0, (PBYTE)(DRIVER_NAME),
        (TEXT("Prefix")),            REG_SZ,    0, (PBYTE)(DEVICE_PREFIX),
        GET_PORT_STATUS_TIMEOUT_SZ,  REG_DWORD, 0, (PUCHAR)(&dwPortStatusTimeout),
        GET_DEVICE_ID_TIMEOUT_SZ,    REG_DWORD, 0, (PUCHAR)(&dwDeviceIdTimeout),
        SOFT_RESET_TIMEOUT_SZ,       REG_DWORD, 0, (PUCHAR)(&dwSoftResetTimeout),
        READ_TIMEOUT_MULTIPLIER_SZ,  REG_DWORD, 0, (PUCHAR)(&dwReadTimeoutMultiplier),
        READ_TIMEOUT_CONSTANT_SZ,    REG_DWORD, 0, (PUCHAR)(&dwReadTimeoutConstant),
        WRITE_TIMEOUT_MULTIPLIER_SZ, REG_DWORD, 0, (PUCHAR)(&dwWriteTimeoutMultiplier),
        WRITE_TIMEOUT_CONSTANT_SZ,   REG_DWORD, 0, (PUCHAR)(&dwWriteTimeoutConstant),
        NULL, 0, 0, NULL
    };

   DEBUGMSG( ZONE_USB_INIT, (TEXT(">USBInstallDriver(%s)\n"), szDriverLibFile ));
    
    //
   // register with USBD
   //   
   bRc = RegisterClientDriverID( wsUsbDeviceID );
   if ( !bRc ) {
      DEBUGMSG( ZONE_ERR, (TEXT("RegisterClientDriverID error:%d\n"), GetLastError()));
      return FALSE;
   }
        
   bRc = RegisterClientSettings( szDriverLibFile,
                                 wsUsbDeviceID, 
                                 NULL, 
                                 &usbDriverSettings );
   if ( !bRc ) {
      DEBUGMSG( ZONE_ERR, (TEXT("RegisterClientSettings error:%d\n"), GetLastError()));
      return FALSE;
   }

    //
    // Add our default values to the reg
    //
    if ( !GetSetKeyValues( wsSubClassRegKey,
                           &usbPrnKeyValues[0],
                           SET,
                           TRUE ) ) {
        DEBUGMSG( ZONE_ERR, (TEXT("GetSetKeyValues failed!\n")));
        TEST_TRAP();
    }
 
    DEBUGMSG( ZONE_USB_INIT, (TEXT("<USBInstallDriver:%d\n"), bRc ));

   return bRc;
}


BOOL 
USBUnInstallDriver(
   VOID
   )
{
   BOOL bRc;
   const WCHAR wsUsbDeviceID[] = CLASS_NAME_SZ;
   USB_DRIVER_SETTINGS usbDriverSettings = { DRIVER_SETTINGS };

   DEBUGMSG( ZONE_USB_INIT, (TEXT(">USBUnInstallDriver\n")));

   bRc = UnRegisterClientSettings( wsUsbDeviceID,
                                   NULL,
                                   &usbDriverSettings );

   bRc = bRc & UnRegisterClientDriverID( wsUsbDeviceID );

   DEBUGMSG( ZONE_USB_INIT, (TEXT("<USBUnInstallDriver:%d\n"), bRc));

   return bRc;
}


BOOL
USBDeviceAttach(
   USB_HANDLE       hDevice,
   LPCUSB_FUNCS     UsbFuncs,      
   LPCUSB_INTERFACE UsbInterface,
   LPCWSTR          UniqueDriverId,   
   LPBOOL           AcceptControl,      
   LPCUSB_DRIVER_SETTINGS UsbDriverSettings,
   DWORD Unused
    )
{
   BOOL bRc = TRUE;
   PUSBPRN_CONTEXT  pUsbPrn = NULL;
   LPCUSB_INTERFACE pUsbInterface = NULL;
   ULONG ulConfigIndex = 0;

   WCHAR wsSubClassRegKey[sizeof(CLIENT_REGKEY_SZ)+16] = CLIENT_REGKEY_SZ;

   REG_VALUE_DESCR rdTimeouts[] = {
        GET_PORT_STATUS_TIMEOUT_SZ,  REG_DWORD, sizeof(DWORD), (PUCHAR)(NULL),
        GET_DEVICE_ID_TIMEOUT_SZ,    REG_DWORD, sizeof(DWORD), (PUCHAR)(NULL),
        SOFT_RESET_TIMEOUT_SZ,       REG_DWORD, sizeof(DWORD), (PUCHAR)(NULL),
        READ_TIMEOUT_MULTIPLIER_SZ,  REG_DWORD, sizeof(DWORD), (PUCHAR)(NULL),
        READ_TIMEOUT_CONSTANT_SZ,    REG_DWORD, sizeof(DWORD), (PUCHAR)(NULL),
        WRITE_TIMEOUT_MULTIPLIER_SZ, REG_DWORD, sizeof(DWORD), (PUCHAR)(NULL),
        WRITE_TIMEOUT_CONSTANT_SZ,   REG_DWORD, sizeof(DWORD), (PUCHAR)(NULL),
        NULL, 0, 0, NULL
   };

   UNREFERENCED_PARAMETER(UniqueDriverId);
   UNREFERENCED_PARAMETER(UsbDriverSettings);
   UNREFERENCED_PARAMETER(Unused);

   DEBUGMSG( ZONE_USB_INIT, (TEXT(">USBDeviceAttach(0x%x, %s)\n"), hDevice, UniqueDriverId));

   //
   // Determine if we control this USB peripheral...
   //
   *AcceptControl = FALSE;

   do {
      //
      // Parse USB Descriptors
      //
      pUsbInterface = ParseUsbDescriptors(hDevice, 
                                          UsbFuncs, 
                                          UsbInterface,
                                          (LPUSHORT)&ulConfigIndex );
      
      if ( !pUsbInterface ) {
         DEBUGMSG( ZONE_ERR, (TEXT("ParseUsbDescriptors failed!\n") ));
         bRc = FALSE;
         break;
      }

      //
      // we found a device & interface we control, so create our device context
      //
      pUsbPrn = (PUSBPRN_CONTEXT)LocalAlloc( LPTR, sizeof(USBPRN_CONTEXT) );
      if ( !pUsbPrn ) {
         DEBUGMSG( ZONE_ERR, (TEXT("LocalAlloc error:%d\n"), GetLastError() ));
         bRc = FALSE;
         break;
      }

      pUsbPrn->Sig = USB_PRN_SIG;

      InitializeCriticalSection( &pUsbPrn->Lock );

      pUsbPrn->hUsbDevice = hDevice;

      pUsbPrn->bInterfaceNumber = pUsbInterface->Descriptor.bInterfaceNumber;
      pUsbPrn->bInterfaceNumber = pUsbInterface->Descriptor.bAlternateSetting;
      pUsbPrn->ConfigIndex      = (USHORT)ulConfigIndex;

      pUsbPrn->UsbFuncs = UsbFuncs;
   
      pUsbPrn->Flags.Open = FALSE;
      pUsbPrn->Flags.UnloadPending = FALSE;

      // create endpoint 0 event
      pUsbPrn->hEP0Event = CreateEvent( NULL, MANUAL_RESET_EVENT, FALSE, NULL);
      if ( !pUsbPrn->hEP0Event ) {
          DEBUGMSG( ZONE_ERR, (TEXT("CreateEvent error:%d\n"), GetLastError() ));
          bRc = FALSE;
          break;
      }

      pUsbPrn->hCloseEvent = CreateEvent( NULL, AUTO_RESET_EVENT, FALSE, NULL);
      if ( !pUsbPrn->hCloseEvent ) {
         DEBUGMSG( ZONE_ERR, (TEXT("CreateEvent error:%d\n"), GetLastError() ));
         bRc = FALSE;
         break;
      }

      //
      // set the USB interface/pipes
      //
      bRc = SetUsbInterface( pUsbPrn, 
                             pUsbInterface );
      if ( !bRc ) {
         DEBUGMSG( ZONE_ERR, (TEXT("SetUsbInterface failed!\n")));
         break;
      }

        //
        // Read the timeout values from the registry
        //
        rdTimeouts[0].Data = (PUCHAR)(&pUsbPrn->UsbTimeouts.PortStatusTimeout);
        rdTimeouts[1].Data = (PUCHAR)(&pUsbPrn->UsbTimeouts.DeviceIdTimeout);
        rdTimeouts[2].Data = (PUCHAR)(&pUsbPrn->UsbTimeouts.SoftResetTimeout);

        rdTimeouts[3].Data = (PUCHAR)(&pUsbPrn->Timeouts.ReadTotalTimeoutMultiplier);
        rdTimeouts[4].Data = (PUCHAR)(&pUsbPrn->Timeouts.ReadTotalTimeoutConstant);
        rdTimeouts[5].Data = (PUCHAR)(&pUsbPrn->Timeouts.WriteTotalTimeoutMultiplier);
        rdTimeouts[6].Data = (PUCHAR)(&pUsbPrn->Timeouts.WriteTotalTimeoutConstant);
        
        if ( !GetSetKeyValues(wsSubClassRegKey,
                                  &rdTimeouts[0],
                                  GET, 
                                  FALSE) ) {
            //
            // use defaults
            //
            pUsbPrn->UsbTimeouts.PortStatusTimeout = GET_PORT_STATUS_TIMEOUT;
            pUsbPrn->UsbTimeouts.DeviceIdTimeout   = GET_DEVICE_ID_TIMEOUT;
            pUsbPrn->UsbTimeouts.SoftResetTimeout  = SOFT_RESET_TIMEOUT;

            pUsbPrn->Timeouts.ReadIntervalTimeout         = READ_TIMEOUT_INTERVAL; // not used
            pUsbPrn->Timeouts.ReadTotalTimeoutMultiplier  = READ_TIMEOUT_MULTIPLIER;
            pUsbPrn->Timeouts.ReadTotalTimeoutConstant    = READ_TIMEOUT_CONSTANT;
            pUsbPrn->Timeouts.WriteTotalTimeoutMultiplier = WRITE_TIMEOUT_MULTIPLIER;
            pUsbPrn->Timeouts.WriteTotalTimeoutConstant   = WRITE_TIMEOUT_CONSTANT;
      }

#ifdef DEBUG
      UsbPrnTest( pUsbPrn );
#endif

      //
      // kick start the stream driver interface
      //
      pUsbPrn->hStreamDevice = ActivateDevice( wsSubClassRegKey,
                                               (DWORD)pUsbPrn );

      if ( pUsbPrn->hStreamDevice ) {
         //
         // register for USB callbacks
         //
         bRc = UsbFuncs->lpRegisterNotificationRoutine( hDevice,
                                                        DeviceNotify,
                                                        pUsbPrn );
         if ( !bRc ) {
            DEBUGMSG( ZONE_ERR, (TEXT("RegisterNotificationRoutine error:%d\n"), GetLastError() ));
            break;
         }

      } else {
         //
         // the streams interface failed to init, no use starting.
         //
         DEBUGMSG( ZONE_ERR, (TEXT("ActivateDevice error:%d\n"), GetLastError() ));
         bRc = FALSE;
         break;
      }

   } while(0);

   if (!bRc) {
      //
      // If not our device, or error, then clean up
      //
      RemoveDeviceContext( pUsbPrn );

   } else {

      *AcceptControl = TRUE;
   
   }

   DEBUGMSG( ZONE_USB_INIT, (TEXT("<USBDeviceAttach:%d\n"), *AcceptControl ));

   return bRc;
}


LPCUSB_INTERFACE
ParseUsbDescriptors(
   USB_HANDLE       hUsbDevice,
   LPCUSB_FUNCS     UsbFuncs,
   LPCUSB_INTERFACE CurInterface,
   LPUSHORT         ConfigIndex
   )
{
   LPCUSB_DEVICE      pDevice;
   LPCUSB_INTERFACE   pUsbInterface;
   LPCUSB_INTERFACE   pDesiredInterface = NULL;
   
   DWORD dwNumInterfaces;
   DWORD bProtocol, dwIndex;