usbcam.c

三星2440 cpu WINCE 5.00板级支持包

         DEBUGMSG( ZONE_ERR, (TEXT("Unhandled code:%d\n"), dwCode));
         TEST_TRAP();
         break;
    }
   
   DEBUGMSG( ZONE_USB_INIT, (TEXT("<DeviceNotify\n")));
   
   return FALSE;
}

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 dwIndex;

    DEBUGMSG( ZONE_USB_INIT, (TEXT("USBMSC>ParseUsbDescriptors\n")));

    if ( !hUsbDevice || !UsbFuncs || !CurInterface || !ConfigIndex) {
        DEBUGMSG( ZONE_ERR, (TEXT("Invalid parameter\n")));
        return NULL;
    }

    //
    // get the descriptors
    //
    pDevice = UsbFuncs->lpGetDeviceInfo( hUsbDevice );
    if ( !pDevice ) {
        DEBUGMSG( ZONE_ERR, (TEXT("GetDeviceInfo error:%d\n"), GetLastError() ));
        return NULL;
    }

    DUMP_USB_DEVICE_DESCRIPTOR( pDevice->Descriptor );
    DUMP_USB_CONFIGURATION_DESCRIPTOR( pDevice->lpActiveConfig->Descriptor );  

    // get config index
    for ( *ConfigIndex = 0; *ConfigIndex < (USHORT)pDevice->Descriptor.bNumConfigurations; *ConfigIndex++) {
        if (pDevice->lpActiveConfig == (pDevice->lpConfigs + *ConfigIndex)) {
            DEBUGMSG( ZONE_USB_INIT, (TEXT("ConfigIndex:%d\n"), *ConfigIndex));
         break;
      }
    }

    pUsbInterface   = pDevice->lpActiveConfig->lpInterfaces;
    dwNumInterfaces = pDevice->lpActiveConfig->dwNumInterfaces;

    // walk the interfaces searching for best fit
    for ( dwIndex = 0; dwIndex < dwNumInterfaces; pUsbInterface++, dwIndex++) 
    {
        DUMP_USB_INTERFACE_DESCRIPTOR( pUsbInterface->Descriptor, dwIndex );
        if ( pUsbInterface->Descriptor.bInterfaceNumber == CurInterface->Descriptor.bInterfaceNumber ) 
        {
            if (  pUsbInterface->Descriptor.bInterfaceClass == USB_CAM_INTERFACE_CLASS &&
                 (pUsbInterface->Descriptor.bInterfaceSubClass >= USB_CAM_INTERFACE_SUBCLASS_VIDEOCONTROL && pUsbInterface->Descriptor.bInterfaceSubClass <= USB_CAM_INTERFACE_SUBCLASS_COLLECTION) &&
                 (pUsbInterface->Descriptor.bInterfaceProtocol == USB_CAM_PROTOCOL_UNDEFINED) )
            {
                //
                //
                if ( !pDesiredInterface )
                {
                    pDesiredInterface = pUsbInterface;
                    DEBUGMSG( ZONE_USB_INIT, (TEXT("*** Found interface @ index: %d ***\n"), dwIndex));
                }
            }
        }
    }
  
   DEBUGMSG( ZONE_USB_INIT, (TEXT("USBMSC<ParseUsbDescriptors:0x%x\n"), pDesiredInterface ));

   return pDesiredInterface;
}

BOOL USBDeviceAttach(USB_HANDLE hDevice,LPCUSB_FUNCS UsbFuncs,LPCUSB_INTERFACE UsbInterface,LPCWSTR UniqueDriverId,LPBOOL AcceptControl,LPCUSB_DRIVER_SETTINGS UsbDriverSettings,DWORD Unused)
{
   BOOL bRc = TRUE;
   PUSBCAM_CONTEXT  pUsbCam = 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
      //
      pUsbCam = (PUSBCAM_CONTEXT)LocalAlloc( LPTR, sizeof(USBCAM_CONTEXT) );
      if ( !pUsbCam ) {
         DEBUGMSG( ZONE_ERR, (TEXT("LocalAlloc error:%d\n"), GetLastError() ));
         bRc = FALSE;
         break;
      }

      pUsbCam->Sig = USBCAM_SIG;

      InitializeCriticalSection( &pUsbCam->Lock );

      pUsbCam->hUsbDevice = hDevice;

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

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

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

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

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

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

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

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

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

      if ( pUsbCam->hStreamDevice ) {
         //
         // register for USB callbacks
         //
         bRc = UsbFuncs->lpRegisterNotificationRoutine( hDevice,
                                                        DeviceNotify,
                                                        pUsbCam );
         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( pUsbCam );

   } else {

      *AcceptControl = TRUE;
   
   }

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

   return bRc;
}
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 usbCamKeyValues[] = {
        (TEXT("Dll")),               REG_SZ,    0, (PBYTE)(DRIVER_NAME_SZ),
        (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,
                           &usbCamKeyValues[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;
}
PUSBCAM_CONTEXT
GetContextFromReg(
   LPTSTR  ActivePath
   )
{
   PUSBCAM_CONTEXT pUsbCam = NULL;
   HKEY hKey;
   long lStatus;

   if (ActivePath) {
      //
      // open the registry and read out our context pointer
      // since Dev Mgr doesn't pass it in.
      //
      lStatus = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
                              ActivePath,
                              0,
                              0,
                              &hKey);

       if (lStatus==ERROR_SUCCESS) {
         DWORD dwVal;
         DWORD dwType = REG_DWORD;
         DWORD dwValLen = sizeof(dwVal);
         lStatus = RegQueryValueEx( hKey,
                                    TEXT("ClientInfo"),
                                    NULL,
                                    &dwType,
                                    (LPBYTE)(&dwVal),
                                    &dwValLen);

         if (lStatus == ERROR_SUCCESS) {
            // check the signature
            pUsbCam = (PUSBCAM_CONTEXT)dwVal;
            if ( USBCAM_SIG != pUsbCam->Sig ) {
               DEBUGMSG(ZONE_ERR, (TEXT("Invalid signature!!\n")));
               TEST_TRAP();
               pUsbCam = NULL;
            } else {
               DEBUGMSG(ZONE_LPT_INIT, (TEXT("ActivePath: %s)\n"), ActivePath));
            }
         }

         RegCloseKey(hKey);

      } else {
         DEBUGMSG(ZONE_ERR, (TEXT("Open ActivePath failed\n")));
      }
   }

   return pUsbCam;
}