/** * @brief USBD_CDC_ReceivePacket * prepare OUT Endpoint for reception * @param pdev: device instance * @retval status */ uint8_t USBD_CDC_ReceivePacket(USBD_HandleTypeDef *pdev) { USBD_CDC_HandleTypeDef *hcdc = pdev->pClassData; /* Suspend or Resume USB Out process */ if(pdev->pClassData != NULL) { if(pdev->dev_speed == USBD_SPEED_HIGH ) { /* Prepare Out endpoint to receive next packet */ USBD_LL_PrepareReceive(pdev, CDC_OUT_EP, hcdc->RxBuffer, CDC_DATA_HS_OUT_PACKET_SIZE); } else { /* Prepare Out endpoint to receive next packet */ USBD_LL_PrepareReceive(pdev, CDC_OUT_EP, hcdc->RxBuffer, CDC_DATA_FS_OUT_PACKET_SIZE); } return USBD_OK; } else { return USBD_FAIL; } }
// Handle write process // input: // pdev - pointer to the USB device handle // lun - logical unit number static int8_t SCSI_ProcessWrite(USBD_HandleTypeDef *pdev, uint8_t lun) { USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassData; uint32_t len; len = MIN(hmsc->scsi_blk_len,MSC_MEDIA_PACKET); if (((USBD_StorageTypeDef *)pdev->pUserData)->Write(lun,hmsc->bot_data,hmsc->scsi_blk_addr / hmsc->scsi_blk_size,len / hmsc->scsi_blk_size) < 0) { SCSI_SenseCode(pdev,lun,HARDWARE_ERROR,WRITE_FAULT); return -1; } hmsc->scsi_blk_addr += len; hmsc->scsi_blk_len -= len; // case 12 : Ho = Do hmsc->csw.dDataResidue -= len; if (hmsc->scsi_blk_len == 0) { MSC_BOT_SendCSW(pdev,USBD_CSW_CMD_PASSED); } else { // Prepare endpoint to receive next packet USBD_LL_PrepareReceive(pdev,MSC_EPOUT_ADDR,hmsc->bot_data,MIN(hmsc->scsi_blk_len,MSC_MEDIA_PACKET)); } return 0; }
/** * @brief USBD_CDC_ReceivePacket * prepare OUT Endpoint for reception * @param pdev: device instance * @retval status */ uint8_t USBD_CDC_ReceivePacket(USBD_HandleTypeDef *pdev, uint8_t endpoint_pair) { USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData; /* Suspend or Resume USB Out process */ if(pdev->pClassData != NULL) { // Select Endpoint USBD_CDC_EP_HandleTypeDef* hEP_Rx; uint8_t out_ep; if (endpoint_pair == CDC_OUT_EP) { hEP_Rx = &hcdc->CDC_Rx; out_ep = CDC_OUT_EP; } else if (endpoint_pair == ODRIVE_OUT_EP) { hEP_Rx = &hcdc->ODRIVE_Rx; out_ep = ODRIVE_OUT_EP; } else { return USBD_FAIL; } /* Prepare Out endpoint to receive next packet */ USBD_LL_PrepareReceive(pdev, out_ep, hEP_Rx->Buffer, pdev->dev_speed == USBD_SPEED_HIGH ? CDC_DATA_HS_OUT_PACKET_SIZE : CDC_DATA_FS_OUT_PACKET_SIZE); return USBD_OK; } else { return USBD_FAIL; } }
uint8_t USBD_HID_DataOut_impl (USBD_HandleTypeDef *pdev, uint8_t epnum, uint8_t* buffer) { // only the data hid endpoint will receive data if (epnum == 2) { // prepare receiving the next chunk (masked time) USBD_LL_PrepareReceive(pdev, HID_EPOUT_ADDR , HID_EPOUT_SIZE); // avoid troubles when an apdu has not been replied yet if (G_io_apdu_media == IO_APDU_MEDIA_NONE) { // add to the hid transport switch(io_usb_hid_receive(io_usb_send_apdu_data, buffer, io_seproxyhal_get_ep_rx_size(HID_EPOUT_ADDR))) { default: break; case IO_USB_APDU_RECEIVED: G_io_apdu_media = IO_APDU_MEDIA_USB_HID; // for application code G_io_apdu_state = APDU_USB_HID; // for next call to io_exchange G_io_apdu_length = G_io_usb_hid_total_length; break; } } } return USBD_OK; }
uint8_t* USBD_HID_GetReportDescriptor_impl(uint16_t* len) { switch (USBD_Device.request.wIndex&0xFF) { case 0: // very dirty work due to lack of callback when USB_HID_Init is called USBD_LL_OpenEP(&USBD_Device, 0x81, USBD_EP_TYPE_INTR, 8); USBD_LL_OpenEP(&USBD_Device, 0x01, USBD_EP_TYPE_INTR, 8); /* Prepare Out endpoint to receive 1st packet */ USBD_LL_PrepareReceive(&USBD_Device, 0x01, 8); *len = sizeof(HID_ReportDesc_kbd); return (uint8_t*)HID_ReportDesc_kbd; case 1: *len = sizeof(HID_ReportDesc); return (uint8_t*)HID_ReportDesc; } *len = 0; return 0; }
/** * @brief USBD_CtlReceiveStatus * receive zero lzngth packet on the ctl pipe * @param pdev: device instance * @retval status */ USBD_StatusTypeDef USBD_CtlReceiveStatus(USBD_HandleTypeDef *pdev) { /* Set EP0 State */ pdev->ep0_state = USBD_EP0_STATUS_OUT; /* Start the transfer */ USBD_LL_PrepareReceive(pdev, 0, NULL, 0); return USBD_OK; }
static uint8_t USBD_CDC_ReceivePacket(USBD_HandleTypeDef *pdev, unsigned index) { USBD_StatusTypeDef outcome; outcome = USBD_LL_PrepareReceive(pdev, parameters[index].data_out_ep, (uint8_t *)context[index].OutboundBuffer, CDC_DATA_OUT_MAX_PACKET_SIZE); context[index].OutboundTransferNeedsRenewal = (USBD_OK != outcome); /* set if the HAL was busy so that we know to retry it */ return outcome; }
/** * @brief USBD_CtlPrepareRx * receive data on the ctl pipe * @param pdev: device instance * @param buff: pointer to data buffer * @param len: length of data to be received * @retval status */ USBD_StatusTypeDef USBD_CtlPrepareRx(USBD_HandleTypeDef *pdev, uint8_t *pbuf, uint16_t len) { /* Set EP0 State */ pdev->ep0_state = USBD_EP0_DATA_OUT; pdev->ep_out[0].total_length = len; pdev->ep_out[0].rem_length = len; /* Start the transfer */ USBD_LL_PrepareReceive(pdev, 0, pbuf, len); return USBD_OK; }
/** * @brief USBD_CtlContinueRx * continue receive data on the ctl pipe * @param pdev: device instance * @param buff: pointer to data buffer * @param len: length of data to be received * @retval status */ USBD_StatusTypeDef USBD_CtlContinueRx (USBD_HandleTypeDef *pdev, uint8_t *pbuf, uint16_t len) { USBD_LL_PrepareReceive (pdev, 0, pbuf, len); return USBD_OK; }
/** * @brief USBD_CDC_HID_Init * Initialize the CDC interface * @param pdev: device instance * @param cfgidx: Configuration index * @retval status */ static uint8_t USBD_CDC_HID_Init (USBD_HandleTypeDef *pdev, uint8_t cfgidx) { pdev->pClassData = &cdc_hid; USBD_CDC_HID_HandleTypeDef *handle = (USBD_CDC_HID_HandleTypeDef*) pdev->pClassData; NOT_USED(cfgidx); uint8_t ret = 0; /* Open EP IN */ USBD_LL_OpenEP(pdev, CDC_IN_EP, USBD_EP_TYPE_BULK, CDC_DATA_FS_IN_PACKET_SIZE); /* Open EP OUT */ USBD_LL_OpenEP(pdev, CDC_OUT_EP, USBD_EP_TYPE_BULK, CDC_DATA_FS_OUT_PACKET_SIZE); /* Open Command IN EP */ USBD_LL_OpenEP(pdev, CDC_CMD_EP, USBD_EP_TYPE_INTR, CDC_CMD_PACKET_SIZE); /* Init Xfer states */ handle->cdcState = CDC_IDLE; /* Prepare Out endpoint to receive next packet */ USBD_LL_PrepareReceive(pdev, CDC_OUT_EP, handle->cdcRX, CDC_DATA_FS_OUT_PACKET_SIZE); #ifdef USE_USB_HID unsigned int reportSize = 0; handle->hidReportDesc = USB_GetHIDReportDesc(&reportSize); handle->hidReportDescSize = (uint16_t)reportSize; /* Open HID EP IN - even if we're not using it */ USBD_LL_OpenEP(pdev, HID_IN_EP, USBD_EP_TYPE_INTR, HID_DATA_IN_PACKET_SIZE); handle->hidState = HID_IDLE; #endif return ret; }
/** * @brief MSC_BOT_Reset * Reset the BOT Machine * @param pdev: device instance * @retval None */ void MSC_BOT_Reset (USBD_HandleTypeDef *pdev) { USBD_MSC_BOT_HandleTypeDef *hmsc = pdev->pClassData; hmsc->bot_state = USBD_BOT_IDLE; hmsc->bot_status = USBD_BOT_STATUS_RECOVERY; /* Prapare EP to Receive First BOT Cmd */ USBD_LL_PrepareReceive (pdev, MSC_EPOUT_ADDR, (uint8_t *)&hmsc->cbw, USBD_BOT_CBW_LENGTH); }
// Process SCSI WRITE10 command // input: // pdev - pointer to the USB device handle // lun - logical unit number // params - pointer to the buffer with command parameters static int8_t SCSI_Write10(USBD_HandleTypeDef *pdev, uint8_t lun, uint8_t *params) { USBD_MSC_BOT_HandleTypeDef *hmsc = (USBD_MSC_BOT_HandleTypeDef *)pdev->pClassData; if (hmsc->bot_state == USBD_BOT_IDLE) { // case 8 : Hi <> Do if (hmsc->cbw.bmFlags & 0x80) { SCSI_SenseCode(pdev,hmsc->cbw.bLUN,ILLEGAL_REQUEST,INVALID_CDB); return -1; } // Check whether media is ready if (((USBD_StorageTypeDef *)pdev->pUserData)->IsReady(lun) != 0) { SCSI_SenseCode(pdev,lun,NOT_READY,MEDIUM_NOT_PRESENT); return -1; } // Check if media is write-protected if (((USBD_StorageTypeDef *)pdev->pUserData)->IsWriteProtected(lun) != 0) { SCSI_SenseCode(pdev,lun,NOT_READY,WRITE_PROTECTED); return -1; } hmsc->scsi_blk_addr = (params[2] << 24) | (params[3] << 16) | (params[4] << 8) | params[5]; hmsc->scsi_blk_len = (params[7] << 8) | params[8]; // Check if LBA address is in the right range if (SCSI_CheckAddressRange(pdev,lun,hmsc->scsi_blk_addr,hmsc->scsi_blk_len) < 0) return -1; hmsc->scsi_blk_addr *= hmsc->scsi_blk_size; hmsc->scsi_blk_len *= hmsc->scsi_blk_size; // cases 3,11,13 : Hn,Ho <> D0 if (hmsc->cbw.dDataLength != hmsc->scsi_blk_len) { SCSI_SenseCode(pdev,hmsc->cbw.bLUN,ILLEGAL_REQUEST,INVALID_CDB); return -1; } // Prepare endpoint to receive first data packet hmsc->bot_state = USBD_BOT_DATA_OUT; USBD_LL_PrepareReceive(pdev,MSC_EPOUT_ADDR,hmsc->bot_data,MIN(hmsc->scsi_blk_len,MSC_MEDIA_PACKET)); } else { // Write Process ongoing return SCSI_ProcessWrite(pdev,lun); } return 0; }
/** * @brief USBD_AUDIO_DataOut * handle data OUT Stage * @param pdev: device instance * @param epnum: endpoint index * @retval status */ static uint8_t USBD_AUDIO_DataOut (USBD_HandleTypeDef *pdev, uint8_t epnum) { USBD_AUDIO_HandleTypeDef *haudio; haudio = (USBD_AUDIO_HandleTypeDef*) pdev->pClassData; if (epnum == AUDIO_OUT_EP) { /* Increment the Buffer pointer or roll it back when all buffers are full */ haudio->wr_ptr += AUDIO_OUT_PACKET; if (haudio->wr_ptr == AUDIO_TOTAL_BUF_SIZE) {/* All buffers are full: roll back */ haudio->wr_ptr = 0; if(haudio->offset == AUDIO_OFFSET_UNKNOWN) { ((USBD_AUDIO_ItfTypeDef *)pdev->pUserData)->AudioCmd(&haudio->buffer[0], AUDIO_TOTAL_BUF_SIZE/2, AUDIO_CMD_START); haudio->offset = AUDIO_OFFSET_NONE; } } if(haudio->rd_enable == 0) { if (haudio->wr_ptr == (AUDIO_TOTAL_BUF_SIZE / 2)) { haudio->rd_enable = 1; } } /* Prepare Out endpoint to receive next audio packet */ USBD_LL_PrepareReceive(pdev, AUDIO_OUT_EP, &haudio->buffer[haudio->wr_ptr], AUDIO_OUT_PACKET); } return USBD_OK; }
static void MSC_BOT_Abort (USBD_HandleTypeDef *pdev) { USBD_MSC_BOT_HandleTypeDef *hmsc = &((usbd_cdc_msc_hid_state_t*)pdev->pClassData)->MSC_BOT_ClassData; if ((hmsc->cbw.bmFlags == 0) && (hmsc->cbw.dDataLength != 0) && (hmsc->bot_status == USBD_BOT_STATUS_NORMAL) ) { USBD_LL_StallEP(pdev, MSC_OUT_EP ); } USBD_LL_StallEP(pdev, MSC_IN_EP); if(hmsc->bot_status == USBD_BOT_STATUS_ERROR) { USBD_LL_PrepareReceive (pdev, MSC_OUT_EP, (uint8_t *)&hmsc->cbw, USBD_BOT_CBW_LENGTH); } }
static void MSC_BOT_Abort (USBD_HandleTypeDef *pdev) { USBD_MSC_BOT_HandleTypeDef *hmsc = pdev->pClassData; if ((hmsc->cbw.bmFlags == 0) && (hmsc->cbw.dDataLength != 0) && (hmsc->bot_status == USBD_BOT_STATUS_NORMAL) ) { USBD_LL_StallEP(pdev, MSC_EPOUT_ADDR ); } USBD_LL_StallEP(pdev, MSC_EPIN_ADDR); if(hmsc->bot_status == USBD_BOT_STATUS_ERROR) { USBD_LL_PrepareReceive (pdev, MSC_EPOUT_ADDR, (uint8_t *)&hmsc->cbw, USBD_BOT_CBW_LENGTH); } }
/** * @brief USBD_AUDIO_Init * Initialize the AUDIO interface * @param pdev: device instance * @param cfgidx: Configuration index * @retval status */ static uint8_t USBD_AUDIO_Init (USBD_HandleTypeDef *pdev, uint8_t cfgidx) { USBD_AUDIO_HandleTypeDef *haudio; /* Open EP OUT */ USBD_LL_OpenEP(pdev, AUDIO_OUT_EP, USBD_EP_TYPE_ISOC, AUDIO_OUT_PACKET); /* Allocate Audio structure */ pdev->pClassData = USBD_malloc(sizeof (USBD_AUDIO_HandleTypeDef)); if(pdev->pClassData == NULL) { return USBD_FAIL; } else { haudio = (USBD_AUDIO_HandleTypeDef*) pdev->pClassData; haudio->alt_setting = 0; haudio->offset = AUDIO_OFFSET_UNKNOWN; haudio->wr_ptr = 0; haudio->rd_ptr = 0; haudio->rd_enable = 0; /* Initialize the Audio output Hardware layer */ if (((USBD_AUDIO_ItfTypeDef *)pdev->pUserData)->Init(USBD_AUDIO_FREQ, AUDIO_DEFAULT_VOLUME, 0) != USBD_OK) { return USBD_FAIL; } /* Prepare Out endpoint to receive 1st packet */ USBD_LL_PrepareReceive(pdev, AUDIO_OUT_EP, haudio->buffer, AUDIO_OUT_PACKET); } return USBD_OK; }
/** * @brief MSC_BOT_SendCSW * Send the Command Status Wrapper * @param pdev: device instance * @param status : CSW status * @retval None */ void MSC_BOT_SendCSW (USBD_HandleTypeDef *pdev, uint8_t CSW_Status) { USBD_MSC_BOT_HandleTypeDef *hmsc = pdev->pClassData; hmsc->csw.dSignature = USBD_BOT_CSW_SIGNATURE; hmsc->csw.bStatus = CSW_Status; hmsc->bot_state = USBD_BOT_IDLE; USBD_LL_Transmit (pdev, MSC_EPIN_ADDR, (uint8_t *)&hmsc->csw, USBD_BOT_CSW_LENGTH); /* Prapare EP to Receive next Cmd */ USBD_LL_PrepareReceive (pdev, MSC_EPOUT_ADDR, (uint8_t *)&hmsc->cbw, USBD_BOT_CBW_LENGTH); }
/** * @brief MSC_BOT_Init * Initialize the BOT Process * @param pdev: device instance * @retval None */ void MSC_BOT_Init (USBD_HandleTypeDef *pdev) { USBD_MSC_BOT_HandleTypeDef *hmsc = &((usbd_cdc_msc_hid_state_t*)pdev->pClassData)->MSC_BOT_ClassData; hmsc->bot_state = USBD_BOT_IDLE; hmsc->bot_status = USBD_BOT_STATUS_NORMAL; hmsc->scsi_sense_tail = 0; hmsc->scsi_sense_head = 0; hmsc->bdev_ops->Init(0); USBD_LL_FlushEP(pdev, MSC_OUT_EP); USBD_LL_FlushEP(pdev, MSC_IN_EP); /* Prapare EP to Receive First BOT Cmd */ USBD_LL_PrepareReceive (pdev, MSC_OUT_EP, (uint8_t *)&hmsc->cbw, USBD_BOT_CBW_LENGTH); }
/** * @brief MSC_BOT_Init * Initialize the BOT Process * @param pdev: device instance * @retval None */ void MSC_BOT_Init (USBD_HandleTypeDef *pdev) { USBD_MSC_BOT_HandleTypeDef *hmsc = pdev->pClassData; hmsc->bot_state = USBD_BOT_IDLE; hmsc->bot_status = USBD_BOT_STATUS_NORMAL; hmsc->scsi_sense_tail = 0; hmsc->scsi_sense_head = 0; ((USBD_StorageTypeDef *)pdev->pUserData)->Init(0); USBD_LL_FlushEP(pdev, MSC_EPOUT_ADDR); USBD_LL_FlushEP(pdev, MSC_EPIN_ADDR); /* Prapare EP to Receive First BOT Cmd */ USBD_LL_PrepareReceive (pdev, MSC_EPOUT_ADDR, (uint8_t *)&hmsc->cbw, USBD_BOT_CBW_LENGTH); }
/** * @brief USBD_RAW_Init * Initialize the TEMPLATE interface * @param pdev: device instance * @param cfgidx: Configuration index * @retval status */ static uint8_t USBD_RAW_Init (USBD_HandleTypeDef *pdev, uint8_t cfgidx) { /* Open EP OUT */ USBD_LL_OpenEP(pdev, RAW_EPOUT_ADDR, USBD_EP_TYPE_BULK, RAW_EP_SIZE); /* Open EP IN */ USBD_LL_OpenEP(pdev, RAW_EPIN_ADDR, USBD_EP_TYPE_BULK, RAW_EP_SIZE); //Prepare to receive a packet USBD_LL_PrepareReceive(pdev,RAW_EPOUT_ADDR,rx_raw_packet,RAW_EP_SIZE); return USBD_OK; }
/** * @brief USBD_RAW_DataOut * Data received on non-control Out endpoint (receive a packet from pc) * handle data OUT Stage * @param pdev: device instance * @param epnum: endpoint index * @retval status */ static uint8_t USBD_RAW_DataOut (USBD_HandleTypeDef *pdev, uint8_t epnum) { uint16_t size = USBD_LL_GetRxDataSize(pdev,epnum); //Before add, check if not buffer overflow if((rx_raw_FrameLen+size) > SIZE_FRAME){ rx_raw_FrameLen = 0; //if buffer overflow restart at 0 } //Copy packet at the end of Frame buffer memcpy (rx_raw_Frame+rx_raw_FrameLen,rx_raw_packet,size); rx_raw_FrameLen +=size; //last packet because packet lenght < packet max process trame if(size < RAW_EP_SIZE){ //process command in the main loop to decrease the heap // startProcessCommand = 1; processCommand(); }else{ // initiate next USB packet transfer,we don't have received full trame USBD_LL_PrepareReceive(&hUsbDeviceFS,RAW_EPOUT_ADDR,rx_raw_packet,RAW_EP_SIZE); } return USBD_OK; }
/** * @brief USBD_CUSTOM_HID_Init * Initialize the CUSTOM_HID interface * @param pdev: device instance * @param cfgidx: Configuration index * @retval status */ static uint8_t USBD_CUSTOM_HID_Init (USBD_HandleTypeDef *pdev, uint8_t cfgidx) { uint8_t ret = 0; USBD_CUSTOM_HID_HandleTypeDef *hhid; /* Open EP IN */ USBD_LL_OpenEP(pdev, CUSTOM_HID_EPIN_ADDR, USBD_EP_TYPE_INTR, CUSTOM_HID_EPIN_SIZE); /* Open EP OUT */ USBD_LL_OpenEP(pdev, CUSTOM_HID_EPOUT_ADDR, USBD_EP_TYPE_INTR, CUSTOM_HID_EPOUT_SIZE); pdev->pClassData = USBD_malloc(sizeof (USBD_CUSTOM_HID_HandleTypeDef)); if(pdev->pClassData == NULL) { ret = 1; } else { hhid = (USBD_CUSTOM_HID_HandleTypeDef*) pdev->pClassData; hhid->state = CUSTOM_HID_IDLE; ((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData)->Init(); /* Prepare Out endpoint to receive 1st packet */ USBD_LL_PrepareReceive(pdev, CUSTOM_HID_EPOUT_ADDR, hhid->Report_buf, USBD_CUSTOMHID_OUTREPORT_BUF_SIZE); } return ret; }
/** * @brief USBD_DataInStage * Handle data in stage * @param pdev: device instance * @param epnum: endpoint index * @retval status */ USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev ,uint8_t epnum, uint8_t *pdata) { USBD_EndpointTypeDef *pep; if(epnum == 0) { pep = &pdev->ep_in[0]; if ( pdev->ep0_state == USBD_EP0_DATA_IN) { if(pep->rem_length > pep->maxpacket) { pep->rem_length -= pep->maxpacket; USBD_CtlContinueSendData (pdev, pdata, pep->rem_length); /* Prepare endpoint for premature end of transfer */ USBD_LL_PrepareReceive (pdev, 0, NULL, 0); } else { /* last packet is MPS multiple, so send ZLP packet */ if((pep->total_length % pep->maxpacket == 0) && (pep->total_length >= pep->maxpacket) && (pep->total_length < pdev->ep0_data_len )) { USBD_CtlContinueSendData(pdev , NULL, 0); pdev->ep0_data_len = 0; /* Prepare endpoint for premature end of transfer */ USBD_LL_PrepareReceive (pdev, 0, NULL, 0); } else { if((pdev->pClass->EP0_TxSent != NULL)&& (pdev->dev_state == USBD_STATE_CONFIGURED)) { pdev->pClass->EP0_TxSent(pdev); } USBD_CtlReceiveStatus(pdev); } } } if (pdev->dev_test_mode == 1) { USBD_RunTestMode(pdev); pdev->dev_test_mode = 0; } } else if((pdev->pClass->DataIn != NULL)&& (pdev->dev_state == USBD_STATE_CONFIGURED)) { pdev->pClass->DataIn(pdev, epnum); } return USBD_OK; }
static int8_t SCSI_Write10 (USBD_HandleTypeDef *pdev, uint8_t lun , uint8_t *params) { USBD_MSC_BOT_HandleTypeDef *hmsc = pdev->pClassData; if (hmsc->bot_state == USBD_BOT_IDLE) /* Idle */ { /* case 8 : Hi <> Do */ if ((hmsc->cbw.bmFlags & 0x80) == 0x80) { SCSI_SenseCode(pdev, hmsc->cbw.bLUN, ILLEGAL_REQUEST, INVALID_CDB); return -1; } /* Check whether Media is ready */ if(((USBD_StorageTypeDef *)pdev->pUserData)->IsReady(lun) !=0 ) { SCSI_SenseCode(pdev, lun, NOT_READY, MEDIUM_NOT_PRESENT); return -1; } /* Check If media is write-protected */ if(((USBD_StorageTypeDef *)pdev->pUserData)->IsWriteProtected(lun) !=0 ) { SCSI_SenseCode(pdev, lun, NOT_READY, WRITE_PROTECTED); return -1; } hmsc->scsi_blk_addr_in_blks = (params[2] << 24) | \ (params[3] << 16) | \ (params[4] << 8) | \ params[5]; hmsc->scsi_blk_len = (params[7] << 8) | \ params[8]; /* check if LBA address is in the right range */ if(SCSI_CheckAddressRange(pdev, lun, hmsc->scsi_blk_addr_in_blks, hmsc->scsi_blk_len) < 0) { return -1; /* error */ } hmsc->scsi_blk_len *= hmsc->scsi_blk_size; /* cases 3,11,13 : Hn,Ho <> D0 */ if (hmsc->cbw.dDataLength != hmsc->scsi_blk_len) { SCSI_SenseCode(pdev, hmsc->cbw.bLUN, ILLEGAL_REQUEST, INVALID_CDB); return -1; } /* Prepare EP to receive first data packet */ hmsc->bot_state = USBD_BOT_DATA_OUT; USBD_LL_PrepareReceive (pdev, MSC_OUT_EP, hmsc->bot_data, MIN (hmsc->scsi_blk_len, MSC_MEDIA_PACKET)); } else /* Write Process ongoing */ { return SCSI_ProcessWrite(pdev, lun); } return 0; }
void endProcessCommandAllowReceiveAgain(){ rx_raw_FrameLen=0; // initiate next USB packet transfer, to append to existing data in buffer USBD_LL_PrepareReceive(&hUsbDeviceFS,RAW_EPOUT_ADDR,rx_raw_packet,RAW_EP_SIZE); }
/** * @brief USBD_CDC_Init * Initilaize the CDC interface * @param pdev: device instance * @param cfgidx: Configuration index * @retval status */ static uint8_t USBD_CDC_Init (USBD_HandleTypeDef *pdev, uint8_t cfgidx) { uint8_t ret = 0; USBD_CDC_HandleTypeDef *hcdc; if(pdev->dev_speed == USBD_SPEED_HIGH ) { /* Open EP IN */ USBD_LL_OpenEP(pdev, CDC_IN_EP, USBD_EP_TYPE_BULK, CDC_DATA_HS_IN_PACKET_SIZE); /* Open EP OUT */ USBD_LL_OpenEP(pdev, CDC_OUT_EP, USBD_EP_TYPE_BULK, CDC_DATA_HS_OUT_PACKET_SIZE); } else { /* Open EP IN */ USBD_LL_OpenEP(pdev, CDC_IN_EP, USBD_EP_TYPE_BULK, CDC_DATA_FS_IN_PACKET_SIZE); /* Open EP OUT */ USBD_LL_OpenEP(pdev, CDC_OUT_EP, USBD_EP_TYPE_BULK, CDC_DATA_FS_OUT_PACKET_SIZE); } /* Open Command IN EP */ USBD_LL_OpenEP(pdev, CDC_CMD_EP, USBD_EP_TYPE_INTR, CDC_CMD_PACKET_SIZE); pdev->pClassData = USBD_malloc(sizeof (USBD_CDC_HandleTypeDef)); if(pdev->pClassData == NULL) { ret = 1; } else { hcdc = pdev->pClassData; /* Init physical Interface components */ ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Init(); /* Init Xfer states */ hcdc->TxState =0; hcdc->RxState =0; if(pdev->dev_speed == USBD_SPEED_HIGH ) { /* Prepare Out endpoint to receive next packet */ USBD_LL_PrepareReceive(pdev, CDC_OUT_EP, hcdc->RxBuffer, CDC_DATA_HS_OUT_PACKET_SIZE); } else { /* Prepare Out endpoint to receive next packet */ USBD_LL_PrepareReceive(pdev, CDC_OUT_EP, hcdc->RxBuffer, CDC_DATA_FS_OUT_PACKET_SIZE); } } return ret; }