usbcam.c

三星2440 cpu WINCE 5.00板级支持包

   pUsbCam = GetContextFromReg( ActivePath );
   if(pUsbCam == NULL)
   {
      RETAILMSG(1,(TEXT("CAM_Init:GetContextFromReg return NULL")));
	return NULL; 
   }
	//reset the camera through USB
	fzc3xx.initialize(pUsbCam);
	//initialize the camera through USB.

	//create the thread and configure the camera.
	fzc3xx.configure(pUsbCam);
	fzc3xx.start(pUsbCam);
	InitInterruptThread(pUsbCam);
}
PUSBCAM_CONTEXT CAM_Open(PUSBCAM_CONTEXT Context,DWORD AccessCode,DWORD ShareMode)
{

	   PUSBCAM_CONTEXT pUsbCam = Context;
   BOOL bRc = TRUE;
	RETAILMSG(1,(TEXT("CAMERA: CAM_Open\r\n")));

   UNREFERENCED_PARAMETER(ShareMode);
   UNREFERENCED_PARAMETER(AccessCode);

   DEBUGMSG(ZONE_LPT_INIT,(TEXT(">LPT_Open(0x%x, 0x%x, 0x%x)\n"),pUsbPrn, AccessCode, ShareMode));

   if ( VALID_CONTEXT( pUsbCam ) ) {

      EnterCriticalSection(&pUsbCam->Lock);

        if ( !pUsbCam->Flags.Open &&
           !pUsbCam->Flags.UnloadPending ) {

            pUsbCam->Flags.Open = TRUE;

         ResetEvent( pUsbCam->hCloseEvent ); // non-signaled
        } else {
            DEBUGMSG( ZONE_ERR,(TEXT("LPT_Open: ERROR_ACCESS_DENIED\n")));
            SetLastError(ERROR_ACCESS_DENIED);
            bRc = FALSE;
        }
	
      LeaveCriticalSection(&pUsbCam->Lock);

   } else {
      DEBUGMSG( ZONE_ERR,(TEXT("LPT_Open: ERROR_FILE_NOT_FOUND\n")));
        SetLastError(ERROR_FILE_NOT_FOUND);
      bRc = FALSE;
    }

   DEBUGMSG(ZONE_LPT_INIT,(TEXT("<LPT_Open:%d\n"), bRc ));

   return (bRc ? pUsbCam : NULL);

	return TRUE;
}
void CAM_PowerDown(DWORD hDeviceContext)
{

}
void CAM_PowerUp(DWORD hDeviceContext)
{

}
DWORD CAM_Read(PUSBCAM_CONTEXT pUsbCam,LPVOID pBuffer,DWORD BufferLength)
{
   DWORD dwTimeout;
   DWORD dwBytesTransferred = 0;
   DWORD dwErr = ERROR_SUCCESS;
   DWORD dwUsbErr = USB_NO_ERROR;

   DEBUGMSG(ZONE_LPT_READ,(TEXT(">LPT_Read(0x%x, %d)\n"),pBuffer, BufferLength));

   if ( ACCEPT_IO( pUsbCam ) ) {

      if ( pBuffer && BufferLength ) {

         EnterCriticalSection( &pUsbCam->Lock );

         dwTimeout = BufferLength * pUsbCam->Timeouts.ReadTotalTimeoutMultiplier +
                     pUsbCam->Timeouts.ReadTotalTimeoutConstant;

         if (!dwTimeout) {
            dwTimeout = INFINITE;
         }

         DEBUGMSG(ZONE_LPT_READ, (TEXT("LPT_Read timeout due in %d msec\n"), dwTimeout));

         dwErr = IssueIsochTransfer( pUsbCam->UsbFuncs,
                                    pUsbCam->BulkIn.hPipe,
                                    DefaultTransferComplete,    // Callback
                                    pUsbCam->BulkIn.hEvent,     // Context
                                    (USB_IN_TRANSFER | USB_SHORT_TRANSFER_OK|USB_START_ISOCH_ASAP), // Flags
                                    frame_count,
                                    1,
                                    pBuffer, 0,
                                    BufferLength,
                                   &dwBytesTransferred,
                                    dwTimeout,
                                   &dwUsbErr );

         if ( ERROR_SUCCESS != dwErr || USB_NO_ERROR != dwUsbErr) {
            DEBUGMSG( ZONE_ERR, (TEXT("IssueBulkTransfer error:%d, 0x%x\n"), dwErr, dwUsbErr));
          //  IoErrorHandler( pUsbCam, pUsbCam->BulkOut.hPipe, pUsbCam->BulkOut.bIndex, dwUsbErr);
         }

         LeaveCriticalSection( &pUsbCam->Lock );

      } else {
         DEBUGMSG( ZONE_ERR,(TEXT("LPT_Read: ERROR_INVALID_PARAMETER\n")));
           SetLastError(ERROR_INVALID_PARAMETER );
       }


   } else {
      DEBUGMSG( ZONE_ERR,(TEXT("CAM_Read: ERROR_INVALID_HANDLE\n")));
        SetLastError(ERROR_INVALID_HANDLE);
    }

   DEBUGMSG(ZONE_LPT_READ,(TEXT("<CAM_Read:%d\n"), dwBytesTransferred));

   return dwBytesTransferred;
}
DWORD CAM_Seek(DWORD hOpenContext,long Amout,DWORD Type)
{

}
DWORD CAM_Write(DWORD hOpenContext,LPCVOID pSourceBytes,DWORD NumberOfBytes)
{

}
BOOL
SetUsbInterface(
   PUSBCAM_CONTEXT  pUsbCam,
   LPCUSB_INTERFACE UsbInterface
   )
{
   USB_TRANSFER hTransfer;
   BOOL bRc = FALSE;
   DWORD dwIndex;

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

   if ( !VALID_CONTEXT( pUsbCam ) || !UsbInterface ) {
      DEBUGMSG( ZONE_ERR, (TEXT("Invalid parameter\n")));
      return FALSE;
   }

   hTransfer = pUsbCam->UsbFuncs->lpSetInterface( pUsbCam->hUsbDevice,
                                                  NULL,
                                                  NULL,
                                                  0, // synchronous
                                                  UsbInterface->Descriptor.bInterfaceNumber,
                                                  UsbInterface->Descriptor.bAlternateSetting );

   if ( !hTransfer ) {
      DEBUGMSG( ZONE_ERR, (TEXT("SetUsbInterface error:%d\n"), GetLastError() ));
      return FALSE;
   }

   //
   // now parse the endpoints
   //
    for ( dwIndex = 0; dwIndex < UsbInterface->Descriptor.bNumEndpoints; dwIndex++) {
    
      LPCUSB_ENDPOINT pEndpoint;
      
      pEndpoint = UsbInterface->lpEndpoints + dwIndex;

      DUMP_USB_ENDPOINT_DESCRIPTOR(pEndpoint->Descriptor);

    // 
    // Printer Class supports 1 mandatory Bulk OUT and 1 optional Bulk IN
    // 
    if ( USB_ENDPOINT_DIRECTION_OUT( pEndpoint->Descriptor.bEndpointAddress ) ) {
            if ( NULL == pUsbCam->BulkOut.hPipe  &&
              (pEndpoint->Descriptor.bmAttributes & USB_ENDPOINT_TYPE_MASK) == USB_ENDPOINT_TYPE_BULK) {
               //
               // create the Bulk OUT pipe
               //
               pUsbCam->BulkOut.hPipe = pUsbCam->UsbFuncs->lpOpenPipe( pUsbCam->hUsbDevice,
                                                                  &pEndpoint->Descriptor );
               if ( !pUsbCam->BulkOut.hPipe ) {
                  DEBUGMSG( ZONE_ERR, (TEXT("OpenPipe error:%d\n"), GetLastError() ));
                  bRc = FALSE;
                  TEST_TRAP();
                  break;
               }

               //
               // setup any endpoint specific timers, buffers, context, etc.
               //
               pUsbCam->BulkOut.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL);
               if ( !pUsbCam->BulkOut.hEvent ) {
                  DEBUGMSG( ZONE_ERR, (TEXT("CreateEvent error:%d\n"), GetLastError() ));
                  bRc = FALSE;
                  TEST_TRAP();
                  break;
               }

               pUsbCam->BulkOut.bIndex = pEndpoint->Descriptor.bEndpointAddress;
         }

        } else if (USB_ENDPOINT_DIRECTION_IN( pEndpoint->Descriptor.bEndpointAddress ) ) {
         if ( NULL == pUsbCam->BulkIn.hPipe && 
                                (pEndpoint->Descriptor.bmAttributes & USB_ENDPOINT_TYPE_MASK) == USB_ENDPOINT_TYPE_BULK) {
               //
               // create the Bulk IN pipe
               //
               pUsbCam->BulkIn.hPipe = pUsbCam->UsbFuncs->lpOpenPipe( pUsbCam->hUsbDevice,
                                                                 &pEndpoint->Descriptor );
               if ( !pUsbCam->BulkIn.hPipe ) {
                  DEBUGMSG( ZONE_ERR, (TEXT("OpenPipe error: %d\n"), GetLastError() ));
                  bRc = FALSE;
                  TEST_TRAP();
                  break;
               }

               //
               // setup any endpoint specific timers, buffers, context, etc.
               //
               pUsbCam->BulkIn.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL);
               if ( !pUsbCam->BulkIn.hEvent ) {
                  DEBUGMSG( ZONE_ERR, (TEXT("CreateEvent error:%d\n"), GetLastError() ));
                  bRc = FALSE;
                  TEST_TRAP();
                  break;
               }

               pUsbCam->BulkIn.bIndex = pEndpoint->Descriptor.bEndpointAddress;
            }
        
      } else {
         DEBUGMSG( ZONE_WARN, (TEXT("Unsupported Endpoint:0x%x\n"), pEndpoint->Descriptor.bEndpointAddress));
      }
    }

   //
   // did we find our endpoints?
   //
       
     bRc = (pUsbCam->BulkOut.hPipe && pUsbCam->BulkIn.hPipe) ? TRUE : FALSE;

   CloseTransferHandle(pUsbCam->UsbFuncs, hTransfer);

   //
   // if we failed to find all of our endpoints then cleanup will occur later
   //

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

    return (bRc);
}

VOID
RemoveDeviceContext(
   PUSBCAM_CONTEXT pUsbCam
   )
{
   DEBUGMSG(ZONE_INIT,(TEXT(">RemoveDeviceContext(%p)\n"), pUsbPrn));

   if ( VALID_CONTEXT( pUsbCam ) ) {

      if ( pUsbCam->Flags.Open ) {
         DEBUGMSG(ZONE_ERR,(TEXT("RemoveDeviceContext on open device!\n")));
         TEST_TRAP();
         return;
      }

      if (pUsbCam->BulkIn.hPipe && pUsbCam->UsbFuncs) {
         pUsbCam->UsbFuncs->lpClosePipe(pUsbCam->BulkIn.hPipe);
      }
      
      if (pUsbCam->BulkIn.hEvent) {
         CloseHandle(pUsbCam->BulkIn.hEvent);
      }
      
      if (pUsbCam->BulkOut.hPipe && pUsbCam->UsbFuncs) {
         pUsbCam->UsbFuncs->lpClosePipe(pUsbCam->BulkOut.hPipe);
      }

      if (pUsbCam->hEP0Event) {
         CloseHandle(pUsbCam->hEP0Event);
      }

      if (pUsbCam->BulkOut.hEvent) {
         CloseHandle(pUsbCam->BulkOut.hEvent);
      }

      if (pUsbCam->hCloseEvent) {
         CloseHandle(pUsbCam->hCloseEvent);
      }
      
      if (&pUsbCam->Lock) {
         DeleteCriticalSection( &pUsbCam->Lock );
      }
      
      LocalFree(pUsbCam);
   
   } else {
      DEBUGMSG(ZONE_ERR,(TEXT("Invalid Parameter\n")));
   }

   DEBUGMSG(ZONE_INIT,(TEXT("<RemoveDeviceContext\n")));
   
   return;
}
BOOL WINAPI 
DeviceNotify(
   LPVOID lpvNotifyParameter,
   DWORD dwCode,
   LPDWORD * dwInfo1,
   LPDWORD * dwInfo2,
   LPDWORD * dwInfo3,
   LPDWORD * dwInfo4
   )
{
   PUSBCAM_CONTEXT pUsbCam = (PUSBCAM_CONTEXT )lpvNotifyParameter;
   DWORD dwWaitReturn;
   BOOL bRc;

    UNREFERENCED_PARAMETER(dwInfo1);
    UNREFERENCED_PARAMETER(dwInfo2);
    UNREFERENCED_PARAMETER(dwInfo3);
    UNREFERENCED_PARAMETER(dwInfo4);

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

   if ( !VALID_CONTEXT( pUsbCam ) ) {
      DEBUGMSG( ZONE_ERR, (TEXT("Invalid Context!\n")));
      return FALSE;
   }
   
   switch(dwCode) {

      case USB_CLOSE_DEVICE:
        DEBUGMSG( ZONE_USB_INIT, (TEXT("USB_CLOSE_DEVICE\n")));
        if (pUsbCam->Flags.Open) {
           //
           // When an app has an open handle to this device and then the user unplugs the USB cable
           // the driver will unload here. However, the app can a) hang on a removed handle, or
           // b) pass a call to a removed function, e.g., CloseHandle and cause an AV.
           // Set state to reject all I/O and wait for cleanup signal.
           //
           EnterCriticalSection( &pUsbCam->Lock );
           pUsbCam->Flags.Open = FALSE;
           pUsbCam->Flags.UnloadPending = TRUE;
           LeaveCriticalSection( &pUsbCam->Lock );

           DEBUGMSG( ZONE_USB_INIT, (TEXT("Waiting for CloseEvent...\n")));
           dwWaitReturn = WaitForSingleObject( pUsbCam->hCloseEvent, INFINITE );

           switch (dwWaitReturn) {

               case WAIT_OBJECT_0:
                  DEBUGMSG( ZONE_USB_INIT, (TEXT("...CloseEvent signalled\n")));
                  break;

               case WAIT_FAILED:
                  DEBUGMSG( ZONE_ERR, (TEXT("CloseEvent error:%d\n"), GetLastError()));
                  TEST_TRAP();
                  break;
               
               default:
                  DEBUGMSG( ZONE_ERR, (TEXT("Unhandled WaitReason:%d\n"), dwWaitReturn ));
                  TEST_TRAP();
                  break;
            }
        
           //
           // Warning: DeactivateDevice forces Device Manager to call our LPT_Deinit, which then
           // causes COREDLL!xxX_CloseHandle to AV when PRNPORT!PrinterSend calls CloseHandle(hPrinter).
           // So, give it a chance to clean up.
           //
           Sleep(1000);
        }

        DEBUGMSG( ZONE_USB_INIT, (TEXT("DeactivateDevice\n")));

        bRc = DeactivateDevice( pUsbCam->hStreamDevice );

        if ( !bRc ) {
            DEBUGMSG( ZONE_ERR, (TEXT("DeactivateDevice error: %d\n"), GetLastError() ));
            TEST_TRAP();
        }

        RemoveDeviceContext( pUsbCam );

        return TRUE;

      default: