/* * Todo replace this call by Asynchronous/Non Blocking * */ int ANDROID_read(t_AndroidInstance handle, t_u8* const buff/*out*/, const int len/*in*/) { t_u16 i, nbdata; t_u32 ulBytes; t_USBHANDROIDInstance *pANDROIDDevice; // Get a pointer to the device instance data from the handle. pANDROIDDevice = (t_USBHANDROIDInstance *)handle; if(pANDROIDDevice != NULL) { /* * TODO use asynchronous transfer maybe to have better performance ... */ /* if(rx_data_available == 0) { ulBytes = USBHCDPipeSchedule(g_USBHANDROIDDevice.ulBulkInPipe, (unsigned char*)buff, len); rx_data_available = len; } ulBytes = USBHCDPipeReadNonBlocking(g_USBHANDROIDDevice.ulBulkInPipe, (unsigned char*)buff, len); rx_data_available = rx_data_available - ulBytes; */ /* Workaround code to ensure data are received and are not equal to 0. * because USBHCDPipeRead() sometimes return size >0 (when timeout) even if there is no new data. * */ for(i=0; i<len; i++) { buff[i] = 0; } nbdata = 0; ulBytes = USBHCDPipeRead(pANDROIDDevice->ulBulkInPipe, (unsigned char*)buff, len); for(i=0; i<len; i++) { if(buff[i] != 0) nbdata++; } // Data have not changed assume no data received if(nbdata == 0) ulBytes = 0; } else { /* Error invalid handle */ ulBytes = 0; } return ulBytes; }
//***************************************************************************** // //! This function is used to issue SCSI commands via USB. //! //! \param ulInPipe is the USB IN pipe to use for this command. //! \param ulOutPipe is the USB OUT pipe to use for this command. //! \param pSCSICmd is the SCSI command structure to send. //! \param pucData is pointer to the command data to be sent. //! \param pulSize is the number of bytes is the number of bytes expected or //! sent by the command. //! //! This internal function is used to handle SCSI commands sent by other //! functions. It serves as a layer between the SCSI command and the USB //! interface being used to send the command. The \e pSCSI parameter contains //! the SCSI command to send. For commands that expect data back, the //! \e pucData is the buffer to store the data into and \e pulSize is used to //! store the amount of data to request as well as used to indicate how many //! bytes were filled into the \e pucData buffer on return. For commands that //! are sending data, \e pucData is the data to be sent and \e pulSize is the //! number of bytes to send. //! //! \return This function returns the SCSI status from the command. The value //! will be either \b SCSI_CMD_STATUS_PASS or \b SCSI_CMD_STATUS_FAIL. // //***************************************************************************** static unsigned long USBHSCSISendCommand(unsigned long ulInPipe, unsigned long ulOutPipe, tMSCCBW *pSCSICmd, unsigned char *pucData, unsigned long *pulSize) { tMSCCSW CmdStatus; unsigned long ulBytes; // // Initialize the command status. // CmdStatus.dCSWSignature = 0; CmdStatus.dCSWTag = 0; CmdStatus.bCSWStatus = SCSI_CMD_STATUS_FAIL; // // Set the CBW signature and tag. // pSCSICmd->dCBWSignature = CBW_SIGNATURE; pSCSICmd->dCBWTag = CBW_TAG_VALUE; // // Set the size of the data to be returned by the device. // pSCSICmd->dCBWDataTransferLength = *pulSize; // // Send the command. // ulBytes = USBHCDPipeWrite(ulOutPipe, (unsigned char*)pSCSICmd, sizeof(tMSCCBW)); // // If no bytes went out then the command failed. // if(ulBytes == 0) { return(SCSI_CMD_STATUS_FAIL); } // // Only request data if there is data to request. // if(pSCSICmd->dCBWDataTransferLength != 0) { // // See if this is a read or a write. // if(pSCSICmd->bmCBWFlags & CBWFLAGS_DIR_IN) { // // Read the data back. // *pulSize = USBHCDPipeRead(ulInPipe, pucData, *pulSize); } else { // // Write the data out. // *pulSize = USBHCDPipeWrite(ulOutPipe, pucData, *pulSize); } } // // Get the status of the command. // ulBytes = USBHCDPipeRead(ulInPipe, (unsigned char *)&CmdStatus, sizeof(tMSCCSW)); // // If the status was invalid or did not have the correct signature then // indicate a failure. // if((ulBytes == 0) || (CmdStatus.dCSWSignature != CSW_SIGNATURE) || (CmdStatus.dCSWTag != CBW_TAG_VALUE)) { return(SCSI_CMD_STATUS_FAIL); } // // Return the status. // return((unsigned long)CmdStatus.bCSWStatus); }
//***************************************************************************** // //! This function is used to issue SCSI commands via USB. //! //! \param ui32InPipe is the USB IN pipe to use for this command. //! \param ui32OutPipe is the USB OUT pipe to use for this command. //! \param psSCSICmd is the SCSI command structure to send. //! \param pui8Data is pointer to the command data to be sent. //! \param pui32Size is the number of bytes is the number of bytes expected or //! sent by the command. //! //! This internal function is used to handle SCSI commands sent by other //! functions. It serves as a layer between the SCSI command and the USB //! interface being used to send the command. The \e pSCSI parameter contains //! the SCSI command to send. For commands that expect data back, the //! \e pui8Data is the buffer to store the data into and \e pui32Size is used //! to store the amount of data to request as well as used to indicate how many //! bytes were filled into the \e pui8Data buffer on return. For commands that //! are sending data, \e pui8Data is the data to be sent and \e pui32Size is //! the number of bytes to send. //! //! \return This function returns the SCSI status from the command. The value //! will be either \b SCSI_CMD_STATUS_PASS or \b SCSI_CMD_STATUS_FAIL. // //***************************************************************************** static uint32_t USBHSCSISendCommand(uint32_t ui32InPipe, uint32_t ui32OutPipe, tMSCCBW *psSCSICmd, uint8_t *pui8Data, uint32_t *pui32Size) { tMSCCSW sCmdStatus; uint32_t ui32Bytes; // // Initialize the command status. // writeusb32_t(&(sCmdStatus.dCSWSignature), 0); writeusb32_t(&(sCmdStatus.dCSWTag), 0); sCmdStatus.bCSWStatus = SCSI_CMD_STATUS_FAIL; // // Set the CBW signature and tag. // writeusb32_t(&(psSCSICmd->dCBWSignature), CBW_SIGNATURE); writeusb32_t(&(psSCSICmd->dCBWTag), CBW_TAG_VALUE); // // Set the size of the data to be returned by the device. // writeusb32_t(&(psSCSICmd->dCBWDataTransferLength), *pui32Size); // // Send the command. // ui32Bytes = USBHCDPipeWrite(ui32OutPipe, (uint8_t*)psSCSICmd, sizeof(tMSCCBW)); // // If no bytes went out then the command failed. // if(ui32Bytes == 0) { return(SCSI_CMD_STATUS_FAIL); } // // Only request data if there is data to request. // if(readusb32_t(&(psSCSICmd->dCBWDataTransferLength)) != 0) { // // See if this is a read or a write. // if(psSCSICmd->bmCBWFlags & CBWFLAGS_DIR_IN) { // // Read the data back. // *pui32Size = USBHCDPipeRead(ui32InPipe, pui8Data, *pui32Size); } else { // // Write the data out. // *pui32Size = USBHCDPipeWrite(ui32OutPipe, pui8Data, *pui32Size); } } // // Get the status of the command. // ui32Bytes = USBHCDPipeRead(ui32InPipe, (uint8_t *)&sCmdStatus, sizeof(tMSCCSW)); // // If the status was invalid or did not have the correct signature then // indicate a failure. // if((ui32Bytes == 0) || (readusb32_t(&(sCmdStatus.dCSWSignature)) != CSW_SIGNATURE) || (readusb32_t(&(sCmdStatus.dCSWTag)) != CBW_TAG_VALUE)) { return(SCSI_CMD_STATUS_FAIL); } // // Return the status. // return((uint32_t)sCmdStatus.bCSWStatus); }