usbprn.c

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

    USHORT usStatus = 0;

    DEBUGMSG( ZONE_USB_CONTROL, (TEXT(">GetPortStatus\n")));

    if ( !VALID_CONTEXT( pUsbPrn)  ) {
        DEBUGMSG( ZONE_ERR, (TEXT("Invalid parameter\n")));
    } else {

        ControlHeader.bmRequestType = USB_REQUEST_DEVICE_TO_HOST | USB_REQUEST_CLASS | USB_REQUEST_FOR_INTERFACE;
        ControlHeader.bRequest = 1;
        ControlHeader.wValue   = 0;
        ControlHeader.wIndex   = pUsbPrn->bInterfaceNumber;
        ControlHeader.wLength  = 1;

        dwErr = IssueVendorTransfer( pUsbPrn->UsbFuncs,
                                     pUsbPrn->hUsbDevice,
                                     DefaultTransferComplete,
                                     pUsbPrn->hEP0Event,
                                     (USB_IN_TRANSFER | USB_SHORT_TRANSFER_OK),
                                     &ControlHeader,
                                     &usStatus, 0,
                                     &dwBytesTransferred,
                                     pUsbPrn->UsbTimeouts.PortStatusTimeout,
                                     &dwUsbErr );

        if ( ERROR_SUCCESS != dwErr || USB_NO_ERROR != dwUsbErr) {
            DEBUGMSG( ZONE_ERR, (TEXT("IssueVendorTransfer ERROR:%d 0x%x\n"), dwErr, dwUsbErr));
            IoErrorHandler( pUsbPrn, NULL, 0, dwUsbErr);
        }
    }

    DEBUGMSG( ZONE_USB_CONTROL, (TEXT("<GetPortStatus:0x%x\n"), usStatus));

    return usStatus;
}


/*++
Class specific command:
   SOFT_RESET

Return: TRUE if successful, else FALSE.

Note: SoftReset currently only works on the Epson Stylus Color 740,
but times out on the HP Deskjet 810C. H/W problem on the HP?

--*/
BOOL
SoftReset( 
   PUSBPRN_CONTEXT pUsbPrn
   )
{
    USB_DEVICE_REQUEST ControlHeader;
    DWORD  dwBytesTransferred = 0;
    DWORD  dwUsbErr = USB_NO_ERROR;
    DWORD  dwErr = ERROR_SUCCESS;
    USHORT usStatus = 0;
    BOOL bRc = TRUE;

    DEBUGMSG( ZONE_USB_CONTROL, (TEXT(">SoftReset\n")));

    if ( !VALID_CONTEXT( pUsbPrn) ) {
        DEBUGMSG( ZONE_ERR, (TEXT("Invalid parameter\n")));
        bRc = FALSE;
   } else {

        ControlHeader.bmRequestType = USB_REQUEST_HOST_TO_DEVICE | USB_REQUEST_CLASS | USB_REQUEST_FOR_OTHER;
        ControlHeader.bRequest = 2;
        ControlHeader.wValue   = 0;
        ControlHeader.wIndex   = pUsbPrn->bInterfaceNumber;
        ControlHeader.wLength  = 0;

        dwErr = IssueVendorTransfer( pUsbPrn->UsbFuncs,
                                     pUsbPrn->hUsbDevice,
                                     DefaultTransferComplete,
                                     pUsbPrn->hEP0Event,
                                     (USB_OUT_TRANSFER | USB_SHORT_TRANSFER_OK),
                                     &ControlHeader,
                                     NULL, 0,
                                     &dwBytesTransferred,
                                     pUsbPrn->UsbTimeouts.SoftResetTimeout,
                                     &dwUsbErr );

        if ( ERROR_SUCCESS != dwErr || USB_NO_ERROR != dwUsbErr) {
            DEBUGMSG( ZONE_ERR, (TEXT("IssueVendorTransfer ERROR:%d 0x%x\n"), dwErr, dwUsbErr));
            IoErrorHandler( pUsbPrn, NULL, 0, dwUsbErr);
        }
    }

    DEBUGMSG( ZONE_USB_CONTROL, (TEXT("<SoftReset:%d\n"), bRc));

    return bRc;
}


//
// returns Win32 error
//
DWORD 
IoErrorHandler( 
   PUSBPRN_CONTEXT pUsbPrn,
   USB_PIPE        hPipe, // if NULL then uses default endpoint,
   UCHAR           bIndex,
   USB_ERROR       dwUsbErr
   )
{
   DWORD dwErr = ERROR_SUCCESS;

   DEBUGMSG(ZONE_ERR|ZONE_TRACE,(TEXT(">IoErrorHandler(%p, 0x%x)\n"), hPipe, dwUsbErr));

   if ( VALID_CONTEXT( pUsbPrn ) ) {

      switch (dwUsbErr) {

         case USB_STALL_ERROR:
            DEBUGMSG(ZONE_ERR,(TEXT("USB_STALL_ERROR\n")));
            if (hPipe) {
               //
               // reset the pipe in the USB stack
               //
               if (ResetPipe( pUsbPrn->UsbFuncs, hPipe, 0) )
                  //
                  // clear the stall on the device
                  //
                  dwErr = ClearOrSetFeature( pUsbPrn->UsbFuncs,
                                             pUsbPrn->hUsbDevice,
                                             DefaultTransferComplete,
                                             pUsbPrn->hEP0Event,
                                             USB_SEND_TO_ENDPOINT,
                                             USB_FEATURE_ENDPOINT_STALL,
                                             bIndex,
                                             1000,
                                             FALSE );
            } else {
               //
               // reset the default endpoint
               //
               dwErr = ResetDefaultEndpoint(pUsbPrn->UsbFuncs, pUsbPrn->hUsbDevice);
            
            }
            break;

         case USB_DEVICE_NOT_RESPONDING_ERROR:
            DEBUGMSG(ZONE_ERR,(TEXT("USB_DEVICE_NOT_RESPONDING_ERROR\n")));
            //
            // try a SoftReset
            //
            if ( !SoftReset(pUsbPrn) ) {
               //
               // If the device is not responding and we can not soft reset then assume it's dead.
               // WCE can't reset the port yet.
               //
               DEBUGMSG( ZONE_ERR, (TEXT("Dead device\n")));
            }
            break;

         default:
            DEBUGMSG(ZONE_ERR,(TEXT("Unhandled error: 0x%x\n"), dwUsbErr));
            break;
      }

   } else {
      dwErr = ERROR_INVALID_PARAMETER;
      DEBUGMSG(ZONE_ERR,(TEXT("Invalid Parameter\n")));
   }

   DEBUGMSG(ZONE_ERR|ZONE_TRACE,(TEXT("<IoErrorHandler:%d\n"), dwErr));

   return dwErr;
}


BOOL 
DllEntry(
   HANDLE hDllHandle,
   DWORD  dwReason,
   LPVOID lpreserved
   ) 
{
    UNREFERENCED_PARAMETER(hDllHandle);
    UNREFERENCED_PARAMETER(lpreserved);
    switch (dwReason) {

      case DLL_PROCESS_ATTACH:
           DEBUGREGISTER((HINSTANCE)hDllHandle);
	   DisableThreadLibraryCalls((HMODULE) hDllHandle);
           break;

      case DLL_PROCESS_DETACH:
           break;

      default:
        break;
    }
    return TRUE;
}


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

   if ( VALID_CONTEXT( pUsbPrn ) ) {

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

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

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

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

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

   DEBUGMSG(ZONE_INIT,(TEXT("<RemoveDeviceContext\n")));
   
   return;
}


#ifdef DEBUG
BOOL
UsbPrnTest(
   PUSBPRN_CONTEXT  pUsbPrn
   )
{
   BOOL bRc;
   USHORT usStatus;
   DWORD dwErr;

   #define BUF_SIZE 1024
   UCHAR buf[BUF_SIZE];
   DWORD dwLen;

   DEBUGMSG(ZONE_TRACE,(TEXT(">UsbPrnTest\n")));

   if ( !pUsbPrn ) {
      DEBUGMSG( ZONE_ERR, (TEXT("Invalid parameter\n")));
      return FALSE;
   }

   //
   // set stall on the BulkOut endpoint
   //
   dwErr = ClearOrSetFeature( pUsbPrn->UsbFuncs,
                              pUsbPrn->hUsbDevice,
                              DefaultTransferComplete,
                              pUsbPrn->hEP0Event,
                              USB_SEND_TO_ENDPOINT,
                              USB_FEATURE_ENDPOINT_STALL,
                              pUsbPrn->BulkOut.bIndex,
                              1000,
                              TRUE );
   
   if ( ERROR_SUCCESS != dwErr ) {
      DEBUGMSG( ZONE_ERR, (TEXT("SetFeature error:%d\n"), dwErr ));
   }
   
   //
   // clear it
   //
   dwErr = ClearOrSetFeature( pUsbPrn->UsbFuncs,
                              pUsbPrn->hUsbDevice,
                              DefaultTransferComplete,
                              pUsbPrn->hEP0Event,
                              USB_SEND_TO_ENDPOINT,
                              USB_FEATURE_ENDPOINT_STALL,
                              pUsbPrn->BulkOut.bIndex,
                              1000,
                              FALSE );
   
   if ( ERROR_SUCCESS != dwErr ) {
      DEBUGMSG( ZONE_ERR, (TEXT("ClearFeature error:%d\n"), dwErr ));
   }


   if (pUsbPrn->BulkIn.hPipe) {
       //
       // set stall on the BulkIn endpoint
       //
       dwErr = ClearOrSetFeature( pUsbPrn->UsbFuncs,
                                  pUsbPrn->hUsbDevice,
                                  DefaultTransferComplete,
                                  pUsbPrn->hEP0Event,
                                  USB_SEND_TO_ENDPOINT,
                                  USB_FEATURE_ENDPOINT_STALL,
                                  pUsbPrn->BulkIn.bIndex,
                                  1000,
                                  TRUE );
   
       if ( ERROR_SUCCESS != dwErr ) {
          DEBUGMSG( ZONE_ERR, (TEXT("SetFeature error:%d\n"), dwErr ));
       }
   
       //
       // clear it
       //
       dwErr = ClearOrSetFeature( pUsbPrn->UsbFuncs,
                                  pUsbPrn->hUsbDevice,
                                  DefaultTransferComplete,
                                  pUsbPrn->hEP0Event,
                                  USB_SEND_TO_ENDPOINT,
                                  USB_FEATURE_ENDPOINT_STALL,
                                  pUsbPrn->BulkIn.bIndex,
                                  1000,
                                  FALSE );
   
       if ( ERROR_SUCCESS != dwErr ) {
          DEBUGMSG( ZONE_ERR, (TEXT("ClearFeature error:%d\n"), dwErr ));
       }
   }



   //
   // run through class commands
   //
   bRc = SoftReset( pUsbPrn );
   usStatus = GetPortStatus( pUsbPrn );
   dwLen = GetDeviceId( pUsbPrn, buf, BUF_SIZE );

   DEBUGMSG(ZONE_TRACE,(TEXT("<UsbPrnTest\n")));

   return TRUE;
}
#endif

// EOF