andy/tinyUSB
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

fix esp32 msc example

Browse Source
This commit is contained in:
hathach
2023-09-28 10:56:38 +07:00
parent 10abece264
commit 277852afc1
7 changed files with 151 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
examples/host/cdc_msc_hid_freertos/src/cdc_app.c
View File

@@ -31,9 +31,7 @@
// MACRO TYPEDEF CONSTANT ENUM DECLARATION // MACRO TYPEDEF CONSTANT ENUM DECLARATION
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// helper
//------------- IMPLEMENTATION -------------//
size_t get_console_inputs(uint8_t *buf, size_t bufsize) { size_t get_console_inputs(uint8_t *buf, size_t bufsize) {
size_t count = 0; size_t count = 0;
while (count < bufsize) { while (count < bufsize) {
@@ -47,6 +45,10 @@ size_t get_console_inputs(uint8_t *buf, size_t bufsize) {
return count; return count;
} }
void cdc_app_init(void) {
// nothing to do
}
void cdc_app_task(void* param) { void cdc_app_task(void* param) {
(void) param; (void) param;

4
examples/host/cdc_msc_hid_freertos/src/hid_app.c
View File

@@ -48,6 +48,10 @@ static void process_kbd_report(hid_keyboard_report_t const *report);
static void process_mouse_report(hid_mouse_report_t const *report); static void process_mouse_report(hid_mouse_report_t const *report);
static void process_generic_report(uint8_t dev_addr, uint8_t instance, uint8_t const *report, uint16_t len); static void process_generic_report(uint8_t dev_addr, uint8_t instance, uint8_t const *report, uint16_t len);
void hid_app_init(void) {
// nothing to do
}
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// TinyUSB Callbacks // TinyUSB Callbacks
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+

12
examples/host/cdc_msc_hid_freertos/src/main.c
View File

@@ -82,10 +82,15 @@ StaticTask_t cdc_taskdef;
TimerHandle_t blinky_tm; TimerHandle_t blinky_tm;
static void led_blinky_cb(TimerHandle_t xTimer); static void led_blinky_cb(TimerHandle_t xTimer);
static void usb_host_task(void* param); extern void cdc_app_init(void);
extern void hid_app_init(void);
extern void msc_app_init(void);
static void usb_host_task(void* param);
extern void cdc_app_task(void* param); extern void cdc_app_task(void* param);
/*------------- MAIN -------------*/ /*------------- MAIN -------------*/
int main(void) { int main(void) {
board_init(); board_init();
@@ -131,6 +136,10 @@ static void usb_host_task(void *param) {
board_init_after_tusb(); board_init_after_tusb();
} }
cdc_app_init();
hid_app_init();
msc_app_init();
// RTOS forever loop // RTOS forever loop
while (1) { while (1) {
// put this thread to waiting state until there is new events // put this thread to waiting state until there is new events
@@ -154,7 +163,6 @@ void tuh_umount_cb(uint8_t dev_addr) {
printf("A device with address %d is unmounted \r\n", dev_addr); printf("A device with address %d is unmounted \r\n", dev_addr);
} }
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// BLINKING TASK // BLINKING TASK
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+

8
examples/host/cdc_msc_hid_freertos/src/msc_app.c
View File

@@ -25,10 +25,12 @@
#include "tusb.h" #include "tusb.h"
#if CFG_TUH_MSC
static scsi_inquiry_resp_t inquiry_resp; static scsi_inquiry_resp_t inquiry_resp;
void msc_app_init(void) {
// nothing to do
}
bool inquiry_complete_cb(uint8_t dev_addr, tuh_msc_complete_data_t const *cb_data) { bool inquiry_complete_cb(uint8_t dev_addr, tuh_msc_complete_data_t const *cb_data) {
msc_cbw_t const *cbw = cb_data->cbw; msc_cbw_t const *cbw = cb_data->cbw;
msc_csw_t const *csw = cb_data->csw; msc_csw_t const *csw = cb_data->csw;
@@ -63,5 +65,3 @@ void tuh_msc_umount_cb(uint8_t dev_addr) {
(void) dev_addr; (void) dev_addr;
printf("A MassStorage device is unmounted\r\n"); printf("A MassStorage device is unmounted\r\n");
} }
#endif

177
src/class/msc/msc_host.c
View File

@@ -43,16 +43,14 @@
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// MACRO CONSTANT TYPEDEF // MACRO CONSTANT TYPEDEF
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
enum enum {
{
MSC_STAGE_IDLE = 0, MSC_STAGE_IDLE = 0,
MSC_STAGE_CMD, MSC_STAGE_CMD,
MSC_STAGE_DATA, MSC_STAGE_DATA,
MSC_STAGE_STATUS, MSC_STAGE_STATUS,
}; };
typedef struct typedef struct {
{
uint8_t itf_num; uint8_t itf_num;
uint8_t ep_in; uint8_t ep_in;
uint8_t ep_out; uint8_t ep_out;
@@ -75,7 +73,7 @@ typedef struct
CFG_TUH_MEM_ALIGN msc_cbw_t cbw; CFG_TUH_MEM_ALIGN msc_cbw_t cbw;
CFG_TUH_MEM_ALIGN msc_csw_t csw; CFG_TUH_MEM_ALIGN msc_csw_t csw;
}msch_interface_t; } msch_interface_t;
CFG_TUH_MEM_SECTION static msch_interface_t _msch_itf[CFG_TUH_DEVICE_MAX]; CFG_TUH_MEM_SECTION static msch_interface_t _msch_itf[CFG_TUH_DEVICE_MAX];
@@ -86,40 +84,34 @@ static uint8_t _msch_buffer[sizeof(scsi_inquiry_resp_t)];
// FIXME potential nul reference // FIXME potential nul reference
TU_ATTR_ALWAYS_INLINE TU_ATTR_ALWAYS_INLINE
static inline msch_interface_t* get_itf(uint8_t dev_addr) static inline msch_interface_t* get_itf(uint8_t dev_addr) {
{ return &_msch_itf[dev_addr - 1];
return &_msch_itf[dev_addr-1];
} }
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// PUBLIC API // PUBLIC API
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
uint8_t tuh_msc_get_maxlun(uint8_t dev_addr) uint8_t tuh_msc_get_maxlun(uint8_t dev_addr) {
{
msch_interface_t* p_msc = get_itf(dev_addr); msch_interface_t* p_msc = get_itf(dev_addr);
return p_msc->max_lun; return p_msc->max_lun;
} }
uint32_t tuh_msc_get_block_count(uint8_t dev_addr, uint8_t lun) uint32_t tuh_msc_get_block_count(uint8_t dev_addr, uint8_t lun) {
{
msch_interface_t* p_msc = get_itf(dev_addr); msch_interface_t* p_msc = get_itf(dev_addr);
return p_msc->capacity[lun].block_count; return p_msc->capacity[lun].block_count;
} }
uint32_t tuh_msc_get_block_size(uint8_t dev_addr, uint8_t lun) uint32_t tuh_msc_get_block_size(uint8_t dev_addr, uint8_t lun) {
{
msch_interface_t* p_msc = get_itf(dev_addr); msch_interface_t* p_msc = get_itf(dev_addr);
return p_msc->capacity[lun].block_size; return p_msc->capacity[lun].block_size;
} }
bool tuh_msc_mounted(uint8_t dev_addr) bool tuh_msc_mounted(uint8_t dev_addr) {
{
msch_interface_t* p_msc = get_itf(dev_addr); msch_interface_t* p_msc = get_itf(dev_addr);
return p_msc->mounted; return p_msc->mounted;
} }
bool tuh_msc_ready(uint8_t dev_addr) bool tuh_msc_ready(uint8_t dev_addr) {
{
msch_interface_t* p_msc = get_itf(dev_addr); msch_interface_t* p_msc = get_itf(dev_addr);
return p_msc->mounted && !usbh_edpt_busy(dev_addr, p_msc->ep_in) && !usbh_edpt_busy(dev_addr, p_msc->ep_out); return p_msc->mounted && !usbh_edpt_busy(dev_addr, p_msc->ep_in) && !usbh_edpt_busy(dev_addr, p_msc->ep_out);
} }
@@ -127,20 +119,20 @@ bool tuh_msc_ready(uint8_t dev_addr)
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// PUBLIC API: SCSI COMMAND // PUBLIC API: SCSI COMMAND
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
static inline void cbw_init(msc_cbw_t *cbw, uint8_t lun) static inline void cbw_init(msc_cbw_t* cbw, uint8_t lun) {
{
tu_memclr(cbw, sizeof(msc_cbw_t)); tu_memclr(cbw, sizeof(msc_cbw_t));
cbw->signature = MSC_CBW_SIGNATURE; cbw->signature = MSC_CBW_SIGNATURE;
cbw->tag = 0x54555342; // TUSB cbw->tag = 0x54555342; // TUSB
cbw->lun = lun; cbw->lun = lun;
} }
bool tuh_msc_scsi_command(uint8_t dev_addr, msc_cbw_t const* cbw, void* data, tuh_msc_complete_cb_t complete_cb, uintptr_t arg) bool tuh_msc_scsi_command(uint8_t daddr, msc_cbw_t const* cbw, void* data,
{ tuh_msc_complete_cb_t complete_cb, uintptr_t arg) {
msch_interface_t* p_msc = get_itf(dev_addr); msch_interface_t* p_msc = get_itf(daddr);
TU_VERIFY(p_msc->configured); TU_VERIFY(p_msc->configured);
// TODO claim endpoint // claim endpoint
TU_VERIFY(usbh_edpt_claim(daddr, p_msc->ep_out));
p_msc->cbw = *cbw; p_msc->cbw = *cbw;
p_msc->stage = MSC_STAGE_CMD; p_msc->stage = MSC_STAGE_CMD;
@@ -148,13 +140,16 @@ bool tuh_msc_scsi_command(uint8_t dev_addr, msc_cbw_t const* cbw, void* data, tu
p_msc->complete_cb = complete_cb; p_msc->complete_cb = complete_cb;
p_msc->complete_arg = arg; p_msc->complete_arg = arg;
TU_ASSERT(usbh_edpt_xfer(dev_addr, p_msc->ep_out, (uint8_t*) &p_msc->cbw, sizeof(msc_cbw_t))); if (!usbh_edpt_xfer(daddr, p_msc->ep_out, (uint8_t*) &p_msc->cbw, sizeof(msc_cbw_t))) {
usbh_edpt_release(daddr, p_msc->ep_out);
return false;
}
return true; return true;
} }
bool tuh_msc_read_capacity(uint8_t dev_addr, uint8_t lun, scsi_read_capacity10_resp_t* response, tuh_msc_complete_cb_t complete_cb, uintptr_t arg) bool tuh_msc_read_capacity(uint8_t dev_addr, uint8_t lun, scsi_read_capacity10_resp_t* response,
{ tuh_msc_complete_cb_t complete_cb, uintptr_t arg) {
msch_interface_t* p_msc = get_itf(dev_addr); msch_interface_t* p_msc = get_itf(dev_addr);
TU_VERIFY(p_msc->configured); TU_VERIFY(p_msc->configured);
@@ -169,8 +164,8 @@ bool tuh_msc_read_capacity(uint8_t dev_addr, uint8_t lun, scsi_read_capacity10_r
return tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb, arg); return tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb, arg);
} }
bool tuh_msc_inquiry(uint8_t dev_addr, uint8_t lun, scsi_inquiry_resp_t* response, tuh_msc_complete_cb_t complete_cb, uintptr_t arg) bool tuh_msc_inquiry(uint8_t dev_addr, uint8_t lun, scsi_inquiry_resp_t* response,
{ tuh_msc_complete_cb_t complete_cb, uintptr_t arg) {
msch_interface_t* p_msc = get_itf(dev_addr); msch_interface_t* p_msc = get_itf(dev_addr);
TU_VERIFY(p_msc->mounted); TU_VERIFY(p_msc->mounted);
@@ -181,8 +176,7 @@ bool tuh_msc_inquiry(uint8_t dev_addr, uint8_t lun, scsi_inquiry_resp_t* respons
cbw.dir = TUSB_DIR_IN_MASK; cbw.dir = TUSB_DIR_IN_MASK;
cbw.cmd_len = sizeof(scsi_inquiry_t); cbw.cmd_len = sizeof(scsi_inquiry_t);
scsi_inquiry_t const cmd_inquiry = scsi_inquiry_t const cmd_inquiry = {
{
.cmd_code = SCSI_CMD_INQUIRY, .cmd_code = SCSI_CMD_INQUIRY,
.alloc_length = sizeof(scsi_inquiry_resp_t) .alloc_length = sizeof(scsi_inquiry_resp_t)
}; };
@@ -191,8 +185,7 @@ bool tuh_msc_inquiry(uint8_t dev_addr, uint8_t lun, scsi_inquiry_resp_t* respons
return tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb, arg); return tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb, arg);
} }
bool tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun, tuh_msc_complete_cb_t complete_cb, uintptr_t arg) bool tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun, tuh_msc_complete_cb_t complete_cb, uintptr_t arg) {
{
msch_interface_t* p_msc = get_itf(dev_addr); msch_interface_t* p_msc = get_itf(dev_addr);
TU_VERIFY(p_msc->configured); TU_VERIFY(p_msc->configured);
@@ -208,8 +201,8 @@ bool tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun, tuh_msc_complete_cb_
return tuh_msc_scsi_command(dev_addr, &cbw, NULL, complete_cb, arg); return tuh_msc_scsi_command(dev_addr, &cbw, NULL, complete_cb, arg);
} }
bool tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, void *response, tuh_msc_complete_cb_t complete_cb, uintptr_t arg) bool tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, void* response,
{ tuh_msc_complete_cb_t complete_cb, uintptr_t arg) {
msc_cbw_t cbw; msc_cbw_t cbw;
cbw_init(&cbw, lun); cbw_init(&cbw, lun);
@@ -217,73 +210,64 @@ bool tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, void *response, tuh_ms
cbw.dir = TUSB_DIR_IN_MASK; cbw.dir = TUSB_DIR_IN_MASK;
cbw.cmd_len = sizeof(scsi_request_sense_t); cbw.cmd_len = sizeof(scsi_request_sense_t);
scsi_request_sense_t const cmd_request_sense = scsi_request_sense_t const cmd_request_sense = {
{
.cmd_code = SCSI_CMD_REQUEST_SENSE, .cmd_code = SCSI_CMD_REQUEST_SENSE,
.alloc_length = 18 .alloc_length = 18
}; };
memcpy(cbw.command, &cmd_request_sense, cbw.cmd_len); memcpy(cbw.command, &cmd_request_sense, cbw.cmd_len);
return tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb, arg); return tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb, arg);
} }
bool tuh_msc_read10(uint8_t dev_addr, uint8_t lun, void * buffer, uint32_t lba, uint16_t block_count, tuh_msc_complete_cb_t complete_cb, uintptr_t arg) bool tuh_msc_read10(uint8_t dev_addr, uint8_t lun, void* buffer, uint32_t lba, uint16_t block_count,
{ tuh_msc_complete_cb_t complete_cb, uintptr_t arg) {
msch_interface_t* p_msc = get_itf(dev_addr); msch_interface_t* p_msc = get_itf(dev_addr);
TU_VERIFY(p_msc->mounted); TU_VERIFY(p_msc->mounted);
msc_cbw_t cbw; msc_cbw_t cbw;
cbw_init(&cbw, lun); cbw_init(&cbw, lun);
cbw.total_bytes = block_count*p_msc->capacity[lun].block_size; cbw.total_bytes = block_count * p_msc->capacity[lun].block_size;
cbw.dir = TUSB_DIR_IN_MASK; cbw.dir = TUSB_DIR_IN_MASK;
cbw.cmd_len = sizeof(scsi_read10_t); cbw.cmd_len = sizeof(scsi_read10_t);
scsi_read10_t const cmd_read10 = scsi_read10_t const cmd_read10 = {
{
.cmd_code = SCSI_CMD_READ_10, .cmd_code = SCSI_CMD_READ_10,
.lba = tu_htonl(lba), .lba = tu_htonl(lba),
.block_count = tu_htons(block_count) .block_count = tu_htons(block_count)
}; };
memcpy(cbw.command, &cmd_read10, cbw.cmd_len); memcpy(cbw.command, &cmd_read10, cbw.cmd_len);
return tuh_msc_scsi_command(dev_addr, &cbw, buffer, complete_cb, arg); return tuh_msc_scsi_command(dev_addr, &cbw, buffer, complete_cb, arg);
} }
bool tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * buffer, uint32_t lba, uint16_t block_count, tuh_msc_complete_cb_t complete_cb, uintptr_t arg) bool tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const* buffer, uint32_t lba, uint16_t block_count,
{ tuh_msc_complete_cb_t complete_cb, uintptr_t arg) {
msch_interface_t* p_msc = get_itf(dev_addr); msch_interface_t* p_msc = get_itf(dev_addr);
TU_VERIFY(p_msc->mounted); TU_VERIFY(p_msc->mounted);
msc_cbw_t cbw; msc_cbw_t cbw;
cbw_init(&cbw, lun); cbw_init(&cbw, lun);
cbw.total_bytes = block_count*p_msc->capacity[lun].block_size; cbw.total_bytes = block_count * p_msc->capacity[lun].block_size;
cbw.dir = TUSB_DIR_OUT; cbw.dir = TUSB_DIR_OUT;
cbw.cmd_len = sizeof(scsi_write10_t); cbw.cmd_len = sizeof(scsi_write10_t);
scsi_write10_t const cmd_write10 = scsi_write10_t const cmd_write10 = {
{
.cmd_code = SCSI_CMD_WRITE_10, .cmd_code = SCSI_CMD_WRITE_10,
.lba = tu_htonl(lba), .lba = tu_htonl(lba),
.block_count = tu_htons(block_count) .block_count = tu_htons(block_count)
}; };
memcpy(cbw.command, &cmd_write10, cbw.cmd_len); memcpy(cbw.command, &cmd_write10, cbw.cmd_len);
return tuh_msc_scsi_command(dev_addr, &cbw, (void*)(uintptr_t) buffer, complete_cb, arg); return tuh_msc_scsi_command(dev_addr, &cbw, (void*) (uintptr_t) buffer, complete_cb, arg);
} }
#if 0 #if 0
// MSC interface Reset (not used now) // MSC interface Reset (not used now)
bool tuh_msc_reset(uint8_t dev_addr) bool tuh_msc_reset(uint8_t dev_addr) {
{ tusb_control_request_t const new_request = {
tusb_control_request_t const new_request = .bmRequestType_bit = {
{
.bmRequestType_bit =
{
.recipient = TUSB_REQ_RCPT_INTERFACE, .recipient = TUSB_REQ_RCPT_INTERFACE,
.type = TUSB_REQ_TYPE_CLASS, .type = TUSB_REQ_TYPE_CLASS,
.direction = TUSB_DIR_OUT .direction = TUSB_DIR_OUT
@@ -300,48 +284,41 @@ bool tuh_msc_reset(uint8_t dev_addr)
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// CLASS-USBH API // CLASS-USBH API
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
void msch_init(void) void msch_init(void) {
{
tu_memclr(_msch_itf, sizeof(_msch_itf)); tu_memclr(_msch_itf, sizeof(_msch_itf));
} }
void msch_close(uint8_t dev_addr) void msch_close(uint8_t dev_addr) {
{ TU_VERIFY(dev_addr <= CFG_TUH_DEVICE_MAX,);
TU_VERIFY(dev_addr <= CFG_TUH_DEVICE_MAX, );
msch_interface_t* p_msc = get_itf(dev_addr); msch_interface_t* p_msc = get_itf(dev_addr);
TU_VERIFY(p_msc->configured, ); TU_VERIFY(p_msc->configured,);
TU_LOG_DRV(" MSCh close addr = %d\r\n", dev_addr); TU_LOG_DRV(" MSCh close addr = %d\r\n", dev_addr);
// invoke Application Callback // invoke Application Callback
if (p_msc->mounted) { if (p_msc->mounted) {
if(tuh_msc_umount_cb) tuh_msc_umount_cb(dev_addr); if (tuh_msc_umount_cb) tuh_msc_umount_cb(dev_addr);
} }
tu_memclr(p_msc, sizeof(msch_interface_t)); tu_memclr(p_msc, sizeof(msch_interface_t));
} }
bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes) bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes) {
{
msch_interface_t* p_msc = get_itf(dev_addr); msch_interface_t* p_msc = get_itf(dev_addr);
msc_cbw_t const * cbw = &p_msc->cbw; msc_cbw_t const * cbw = &p_msc->cbw;
msc_csw_t * csw = &p_msc->csw; msc_csw_t * csw = &p_msc->csw;
switch (p_msc->stage) switch (p_msc->stage) {
{
case MSC_STAGE_CMD: case MSC_STAGE_CMD:
// Must be Command Block // Must be Command Block
TU_ASSERT(ep_addr == p_msc->ep_out && event == XFER_RESULT_SUCCESS && xferred_bytes == sizeof(msc_cbw_t)); TU_ASSERT(ep_addr == p_msc->ep_out && event == XFER_RESULT_SUCCESS && xferred_bytes == sizeof(msc_cbw_t));
if ( cbw->total_bytes && p_msc->buffer ) if (cbw->total_bytes && p_msc->buffer) {
{
// Data stage if any // Data stage if any
p_msc->stage = MSC_STAGE_DATA; p_msc->stage = MSC_STAGE_DATA;
uint8_t const ep_data = (cbw->dir & TUSB_DIR_IN_MASK) ? p_msc->ep_in : p_msc->ep_out; uint8_t const ep_data = (cbw->dir & TUSB_DIR_IN_MASK) ? p_msc->ep_in : p_msc->ep_out;
TU_ASSERT(usbh_edpt_xfer(dev_addr, ep_data, p_msc->buffer, (uint16_t) cbw->total_bytes)); TU_ASSERT(usbh_edpt_xfer(dev_addr, ep_data, p_msc->buffer, (uint16_t) cbw->total_bytes));
}else } else {
{
// Status stage // Status stage
p_msc->stage = MSC_STAGE_STATUS; p_msc->stage = MSC_STAGE_STATUS;
TU_ASSERT(usbh_edpt_xfer(dev_addr, p_msc->ep_in, (uint8_t*) &p_msc->csw, (uint16_t) sizeof(msc_csw_t))); TU_ASSERT(usbh_edpt_xfer(dev_addr, p_msc->ep_in, (uint8_t*) &p_msc->csw, (uint16_t) sizeof(msc_csw_t)));
@@ -358,10 +335,8 @@ bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
// SCSI op is complete // SCSI op is complete
p_msc->stage = MSC_STAGE_IDLE; p_msc->stage = MSC_STAGE_IDLE;
if (p_msc->complete_cb) if (p_msc->complete_cb) {
{ tuh_msc_complete_data_t const cb_data = {
tuh_msc_complete_data_t const cb_data =
{
.cbw = cbw, .cbw = cbw,
.csw = csw, .csw = csw,
.scsi_data = p_msc->buffer, .scsi_data = p_msc->buffer,
@@ -372,7 +347,8 @@ bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
break; break;
// unknown state // unknown state
default: break; default:
break;
} }
return true; return true;
@@ -381,39 +357,35 @@ bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// MSC Enumeration // MSC Enumeration
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
static void config_get_maxlun_complete(tuh_xfer_t* xfer);
static void config_get_maxlun_complete (tuh_xfer_t* xfer); static bool config_test_unit_ready_complete(uint8_t dev_addr, tuh_msc_complete_data_t const* cb_data);
static bool config_test_unit_ready_complete(uint8_t dev_addr, tuh_msc_complete_data_t const * cb_data);
static bool config_request_sense_complete(uint8_t dev_addr, tuh_msc_complete_data_t const* cb_data); static bool config_request_sense_complete(uint8_t dev_addr, tuh_msc_complete_data_t const* cb_data);
static bool config_read_capacity_complete(uint8_t dev_addr, tuh_msc_complete_data_t const* cb_data); static bool config_read_capacity_complete(uint8_t dev_addr, tuh_msc_complete_data_t const* cb_data);
bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *desc_itf, uint16_t max_len) bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const* desc_itf, uint16_t max_len) {
{
(void) rhport; (void) rhport;
TU_VERIFY (MSC_SUBCLASS_SCSI == desc_itf->bInterfaceSubClass && TU_VERIFY (MSC_SUBCLASS_SCSI == desc_itf->bInterfaceSubClass &&
MSC_PROTOCOL_BOT == desc_itf->bInterfaceProtocol); MSC_PROTOCOL_BOT == desc_itf->bInterfaceProtocol);
// msc driver length is fixed // msc driver length is fixed
uint16_t const drv_len = (uint16_t) (sizeof(tusb_desc_interface_t) + desc_itf->bNumEndpoints * sizeof(tusb_desc_endpoint_t)); uint16_t const drv_len = (uint16_t) (sizeof(tusb_desc_interface_t) +
desc_itf->bNumEndpoints * sizeof(tusb_desc_endpoint_t));
TU_ASSERT(drv_len <= max_len); TU_ASSERT(drv_len <= max_len);
msch_interface_t* p_msc = get_itf(dev_addr); msch_interface_t* p_msc = get_itf(dev_addr);
tusb_desc_endpoint_t const * ep_desc = (tusb_desc_endpoint_t const *) tu_desc_next(desc_itf); tusb_desc_endpoint_t const* ep_desc = (tusb_desc_endpoint_t const*) tu_desc_next(desc_itf);
for(uint32_t i=0; i<2; i++) for (uint32_t i = 0; i < 2; i++) {
{
TU_ASSERT(TUSB_DESC_ENDPOINT == ep_desc->bDescriptorType && TUSB_XFER_BULK == ep_desc->bmAttributes.xfer); TU_ASSERT(TUSB_DESC_ENDPOINT == ep_desc->bDescriptorType && TUSB_XFER_BULK == ep_desc->bmAttributes.xfer);
TU_ASSERT(tuh_edpt_open(dev_addr, ep_desc)); TU_ASSERT(tuh_edpt_open(dev_addr, ep_desc));
if ( tu_edpt_dir(ep_desc->bEndpointAddress) == TUSB_DIR_IN ) if (TUSB_DIR_IN == tu_edpt_dir(ep_desc->bEndpointAddress)) {
{
p_msc->ep_in = ep_desc->bEndpointAddress; p_msc->ep_in = ep_desc->bEndpointAddress;
}else } else {
{
p_msc->ep_out = ep_desc->bEndpointAddress; p_msc->ep_out = ep_desc->bEndpointAddress;
} }
ep_desc = (tusb_desc_endpoint_t const *) tu_desc_next(ep_desc); ep_desc = (tusb_desc_endpoint_t const*) tu_desc_next(ep_desc);
} }
p_msc->itf_num = desc_itf->bInterfaceNumber; p_msc->itf_num = desc_itf->bInterfaceNumber;
@@ -454,8 +426,7 @@ bool msch_set_config(uint8_t dev_addr, uint8_t itf_num) {
return true; return true;
} }
static void config_get_maxlun_complete (tuh_xfer_t* xfer) static void config_get_maxlun_complete(tuh_xfer_t* xfer) {
{
uint8_t const daddr = xfer->daddr; uint8_t const daddr = xfer->daddr;
msch_interface_t* p_msc = get_itf(daddr); msch_interface_t* p_msc = get_itf(daddr);
@@ -471,18 +442,16 @@ static void config_get_maxlun_complete (tuh_xfer_t* xfer)
tuh_msc_test_unit_ready(daddr, lun, config_test_unit_ready_complete, 0); tuh_msc_test_unit_ready(daddr, lun, config_test_unit_ready_complete, 0);
} }
static bool config_test_unit_ready_complete(uint8_t dev_addr, tuh_msc_complete_data_t const * cb_data) static bool config_test_unit_ready_complete(uint8_t dev_addr, tuh_msc_complete_data_t const* cb_data) {
{
msc_cbw_t const* cbw = cb_data->cbw; msc_cbw_t const* cbw = cb_data->cbw;
msc_csw_t const* csw = cb_data->csw; msc_csw_t const* csw = cb_data->csw;
if (csw->status == 0) if (csw->status == 0) {
{
// Unit is ready, read its capacity // Unit is ready, read its capacity
TU_LOG_DRV("SCSI Read Capacity\r\n"); TU_LOG_DRV("SCSI Read Capacity\r\n");
tuh_msc_read_capacity(dev_addr, cbw->lun, (scsi_read_capacity10_resp_t*) ((void*) _msch_buffer), config_read_capacity_complete, 0); tuh_msc_read_capacity(dev_addr, cbw->lun, (scsi_read_capacity10_resp_t*) ((void*) _msch_buffer),
}else config_read_capacity_complete, 0);
{ } else {
// Note: During enumeration, some device fails Test Unit Ready and require a few retries // Note: During enumeration, some device fails Test Unit Ready and require a few retries
// with Request Sense to start working !! // with Request Sense to start working !!
// TODO limit number of retries // TODO limit number of retries
@@ -493,8 +462,7 @@ static bool config_test_unit_ready_complete(uint8_t dev_addr, tuh_msc_complete_d
return true; return true;
} }
static bool config_request_sense_complete(uint8_t dev_addr, tuh_msc_complete_data_t const * cb_data) static bool config_request_sense_complete(uint8_t dev_addr, tuh_msc_complete_data_t const* cb_data) {
{
msc_cbw_t const* cbw = cb_data->cbw; msc_cbw_t const* cbw = cb_data->cbw;
msc_csw_t const* csw = cb_data->csw; msc_csw_t const* csw = cb_data->csw;
@@ -503,8 +471,7 @@ static bool config_request_sense_complete(uint8_t dev_addr, tuh_msc_complete_dat
return true; return true;
} }
static bool config_read_capacity_complete(uint8_t dev_addr, tuh_msc_complete_data_t const * cb_data) static bool config_read_capacity_complete(uint8_t dev_addr, tuh_msc_complete_data_t const* cb_data) {
{
msc_cbw_t const* cbw = cb_data->cbw; msc_cbw_t const* cbw = cb_data->cbw;
msc_csw_t const* csw = cb_data->csw; msc_csw_t const* csw = cb_data->csw;

8
src/class/msc/msc_host.h
View File

@@ -24,8 +24,8 @@
* This file is part of the TinyUSB stack. * This file is part of the TinyUSB stack.
*/ */
#ifndef _TUSB_MSC_HOST_H_ #ifndef TUSB_MSC_HOST_H_
#define _TUSB_MSC_HOST_H_ #define TUSB_MSC_HOST_H_
#include "msc.h" #include "msc.h"
@@ -73,7 +73,7 @@ uint32_t tuh_msc_get_block_size(uint8_t dev_addr, uint8_t lun);
// Perform a full SCSI command (cbw, data, csw) in non-blocking manner. // Perform a full SCSI command (cbw, data, csw) in non-blocking manner.
// Complete callback is invoked when SCSI op is complete. // Complete callback is invoked when SCSI op is complete.
// return true if success, false if there is already pending operation. // return true if success, false if there is already pending operation.
bool tuh_msc_scsi_command(uint8_t dev_addr, msc_cbw_t const* cbw, void* data, tuh_msc_complete_cb_t complete_cb, uintptr_t arg); bool tuh_msc_scsi_command(uint8_t daddr, msc_cbw_t const* cbw, void* data, tuh_msc_complete_cb_t complete_cb, uintptr_t arg);
// Perform SCSI Inquiry command // Perform SCSI Inquiry command
// Complete callback is invoked when SCSI op is complete. // Complete callback is invoked when SCSI op is complete.
@@ -123,4 +123,4 @@ bool msch_xfer_cb (uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, ui
} }
#endif #endif
#endif /* _TUSB_MSC_HOST_H_ */ #endif

22
src/host/usbh.c
View File

@@ -817,6 +817,7 @@ bool usbh_edpt_release(uint8_t dev_addr, uint8_t ep_addr)
} }
// Submit an transfer // Submit an transfer
// TODO call usbh_edpt_release if failed
bool usbh_edpt_xfer_with_callback(uint8_t dev_addr, uint8_t ep_addr, uint8_t * buffer, uint16_t total_bytes, bool usbh_edpt_xfer_with_callback(uint8_t dev_addr, uint8_t ep_addr, uint8_t * buffer, uint16_t total_bytes,
tuh_xfer_cb_t complete_cb, uintptr_t user_data) tuh_xfer_cb_t complete_cb, uintptr_t user_data)
{ {
@@ -1713,19 +1714,16 @@ static bool _parse_configuration_descriptor(uint8_t dev_addr, tusb_desc_configur
return true; return true;
} }
void usbh_driver_set_config_complete(uint8_t dev_addr, uint8_t itf_num) void usbh_driver_set_config_complete(uint8_t dev_addr, uint8_t itf_num) {
{
usbh_device_t* dev = get_device(dev_addr); usbh_device_t* dev = get_device(dev_addr);
for(itf_num++; itf_num < CFG_TUH_INTERFACE_MAX; itf_num++) for(itf_num++; itf_num < CFG_TUH_INTERFACE_MAX; itf_num++) {
{
// continue with next valid interface // continue with next valid interface
// IAD binding interface such as CDCs should return itf_num + 1 when complete // IAD binding interface such as CDCs should return itf_num + 1 when complete
// with usbh_driver_set_config_complete() // with usbh_driver_set_config_complete()
uint8_t const drv_id = dev->itf2drv[itf_num]; uint8_t const drv_id = dev->itf2drv[itf_num];
usbh_class_driver_t const * driver = get_driver(drv_id); usbh_class_driver_t const * driver = get_driver(drv_id);
if (driver) if (driver) {
{
TU_LOG_USBH("%s set config: itf = %u\r\n", driver->name, itf_num); TU_LOG_USBH("%s set config: itf = %u\r\n", driver->name, itf_num);
driver->set_config(dev_addr, itf_num); driver->set_config(dev_addr, itf_num);
break; break;
@@ -1733,23 +1731,19 @@ void usbh_driver_set_config_complete(uint8_t dev_addr, uint8_t itf_num)
} }
// all interface are configured // all interface are configured
if (itf_num == CFG_TUH_INTERFACE_MAX) if (itf_num == CFG_TUH_INTERFACE_MAX) {
{
enum_full_complete(); enum_full_complete();
if (is_hub_addr(dev_addr)) if (is_hub_addr(dev_addr)) {
{
TU_LOG(CFG_TUH_LOG_LEVEL, "HUB address = %u is mounted\r\n", dev_addr); TU_LOG(CFG_TUH_LOG_LEVEL, "HUB address = %u is mounted\r\n", dev_addr);
}else }else {
{
// Invoke callback if available // Invoke callback if available
if (tuh_mount_cb) tuh_mount_cb(dev_addr); if (tuh_mount_cb) tuh_mount_cb(dev_addr);
} }
} }
} }
static void enum_full_complete(void) static void enum_full_complete(void) {
{
// mark enumeration as complete // mark enumeration as complete
_dev0.enumerating = 0; _dev0.enumerating = 0;