From c540080c960747a432b04ce5070ccea208f59bd7 Mon Sep 17 00:00:00 2001 From: sakimisu <1203593632@qq.com> Date: Wed, 21 Jun 2023 19:55:17 +0800 Subject: [PATCH] format class struct and global variable name --- class/dfu/usbd_dfu.c | 378 +++++++++++++++++------------------ class/msc/usbd_msc.c | 288 +++++++++++++------------- class/mtp/usbd_mtp.c | 2 +- class/printer/usbd_printer.c | 12 +- class/video/usbd_video.c | 124 ++++++------ class/wireless/usbd_rndis.c | 54 ++--- class/wireless/usbd_rndis.h | 2 + core/usbd_core.c | 360 ++++++++++++++++----------------- core/usbd_core.h | 3 - 9 files changed, 611 insertions(+), 612 deletions(-) diff --git a/class/dfu/usbd_dfu.c b/class/dfu/usbd_dfu.c index e22dfcaf..45714274 100644 --- a/class/dfu/usbd_dfu.c +++ b/class/dfu/usbd_dfu.c @@ -23,7 +23,7 @@ #define FLASH_ERASE_TIME 50 #endif -struct dfu_cfg_priv { +struct usbd_dfu_priv { struct dfu_info info; union { uint32_t d32[USBD_DFU_XFER_SIZE / 4U]; @@ -40,26 +40,26 @@ struct dfu_cfg_priv { uint8_t dev_state; uint8_t manif_state; uint8_t firmwar_flag; -} usbd_dfu_cfg; +} g_usbd_dfu; static void dfu_reset(void) { - memset(&usbd_dfu_cfg, 0, sizeof(usbd_dfu_cfg)); + memset(&g_usbd_dfu, 0, sizeof(g_usbd_dfu)); - usbd_dfu_cfg.alt_setting = 0U; - usbd_dfu_cfg.data_ptr = USBD_DFU_APP_DEFAULT_ADD; - usbd_dfu_cfg.wblock_num = 0U; - usbd_dfu_cfg.wlength = 0U; + g_usbd_dfu.alt_setting = 0U; + g_usbd_dfu.data_ptr = USBD_DFU_APP_DEFAULT_ADD; + g_usbd_dfu.wblock_num = 0U; + g_usbd_dfu.wlength = 0U; - usbd_dfu_cfg.manif_state = DFU_MANIFEST_COMPLETE; - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_IDLE; + g_usbd_dfu.manif_state = DFU_MANIFEST_COMPLETE; + g_usbd_dfu.dev_state = DFU_STATE_DFU_IDLE; - usbd_dfu_cfg.dev_status[0] = DFU_STATUS_OK; - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; - usbd_dfu_cfg.dev_status[4] = DFU_STATE_DFU_IDLE; - usbd_dfu_cfg.dev_status[5] = 0U; + g_usbd_dfu.dev_status[0] = DFU_STATUS_OK; + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; + g_usbd_dfu.dev_status[4] = DFU_STATE_DFU_IDLE; + g_usbd_dfu.dev_status[5] = 0U; } static uint16_t dfu_getstatus(uint32_t add, uint8_t cmd, uint8_t *buffer) @@ -84,21 +84,21 @@ static uint16_t dfu_getstatus(uint32_t add, uint8_t cmd, uint8_t *buffer) static void dfu_request_detach(void) { - if ((usbd_dfu_cfg.dev_state == DFU_STATE_DFU_IDLE) || - (usbd_dfu_cfg.dev_state == DFU_STATE_DFU_DNLOAD_SYNC) || - (usbd_dfu_cfg.dev_state == DFU_STATE_DFU_DNLOAD_IDLE) || - (usbd_dfu_cfg.dev_state == DFU_STATE_DFU_MANIFEST_SYNC) || - (usbd_dfu_cfg.dev_state == DFU_STATE_DFU_UPLOAD_IDLE)) { + if ((g_usbd_dfu.dev_state == DFU_STATE_DFU_IDLE) || + (g_usbd_dfu.dev_state == DFU_STATE_DFU_DNLOAD_SYNC) || + (g_usbd_dfu.dev_state == DFU_STATE_DFU_DNLOAD_IDLE) || + (g_usbd_dfu.dev_state == DFU_STATE_DFU_MANIFEST_SYNC) || + (g_usbd_dfu.dev_state == DFU_STATE_DFU_UPLOAD_IDLE)) { /* Update the state machine */ - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_IDLE; - usbd_dfu_cfg.dev_status[0] = DFU_STATUS_OK; - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; /*bwPollTimeout=0ms*/ - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; - usbd_dfu_cfg.dev_status[5] = 0U; /*iString*/ - usbd_dfu_cfg.wblock_num = 0U; - usbd_dfu_cfg.wlength = 0U; + g_usbd_dfu.dev_state = DFU_STATE_DFU_IDLE; + g_usbd_dfu.dev_status[0] = DFU_STATUS_OK; + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; /*bwPollTimeout=0ms*/ + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; + g_usbd_dfu.dev_status[5] = 0U; /*iString*/ + g_usbd_dfu.wblock_num = 0U; + g_usbd_dfu.wlength = 0U; } } @@ -109,62 +109,62 @@ static void dfu_request_upload(struct usb_setup_packet *setup, uint8_t **data, u uint8_t *phaddr; /* Data setup request */ if (req->wLength > 0U) { - if ((usbd_dfu_cfg.dev_state == DFU_STATE_DFU_IDLE) || (usbd_dfu_cfg.dev_state == DFU_STATE_DFU_UPLOAD_IDLE)) { + if ((g_usbd_dfu.dev_state == DFU_STATE_DFU_IDLE) || (g_usbd_dfu.dev_state == DFU_STATE_DFU_UPLOAD_IDLE)) { /* Update the global length and block number */ - usbd_dfu_cfg.wblock_num = req->wValue; - usbd_dfu_cfg.wlength = MIN(req->wLength, USBD_DFU_XFER_SIZE); + g_usbd_dfu.wblock_num = req->wValue; + g_usbd_dfu.wlength = MIN(req->wLength, USBD_DFU_XFER_SIZE); /* DFU Get Command */ - if (usbd_dfu_cfg.wblock_num == 0U) { + if (g_usbd_dfu.wblock_num == 0U) { /* Update the state machine */ - usbd_dfu_cfg.dev_state = (usbd_dfu_cfg.wlength > 3U) ? DFU_STATE_DFU_IDLE : DFU_STATE_DFU_UPLOAD_IDLE; + g_usbd_dfu.dev_state = (g_usbd_dfu.wlength > 3U) ? DFU_STATE_DFU_IDLE : DFU_STATE_DFU_UPLOAD_IDLE; - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; /* Store the values of all supported commands */ - usbd_dfu_cfg.buffer.d8[0] = DFU_CMD_GETCOMMANDS; - usbd_dfu_cfg.buffer.d8[1] = DFU_CMD_SETADDRESSPOINTER; - usbd_dfu_cfg.buffer.d8[2] = DFU_CMD_ERASE; + g_usbd_dfu.buffer.d8[0] = DFU_CMD_GETCOMMANDS; + g_usbd_dfu.buffer.d8[1] = DFU_CMD_SETADDRESSPOINTER; + g_usbd_dfu.buffer.d8[2] = DFU_CMD_ERASE; /* Send the status data over EP0 */ - memcpy(*data, usbd_dfu_cfg.buffer.d8, 3); + memcpy(*data, g_usbd_dfu.buffer.d8, 3); *len = 3; - } else if (usbd_dfu_cfg.wblock_num > 1U) { - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_UPLOAD_IDLE; + } else if (g_usbd_dfu.wblock_num > 1U) { + g_usbd_dfu.dev_state = DFU_STATE_DFU_UPLOAD_IDLE; - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; - addr = ((usbd_dfu_cfg.wblock_num - 2U) * USBD_DFU_XFER_SIZE) + usbd_dfu_cfg.data_ptr; + addr = ((g_usbd_dfu.wblock_num - 2U) * USBD_DFU_XFER_SIZE) + g_usbd_dfu.data_ptr; /* Return the physical address where data are stored */ - phaddr = dfu_read_flash((uint8_t *)addr, usbd_dfu_cfg.buffer.d8, usbd_dfu_cfg.wlength); + phaddr = dfu_read_flash((uint8_t *)addr, g_usbd_dfu.buffer.d8, g_usbd_dfu.wlength); /* Send the status data over EP0 */ - memcpy(*data, usbd_dfu_cfg.buffer.d8, usbd_dfu_cfg.wlength); - *len = usbd_dfu_cfg.wlength; - } else /* unsupported usbd_dfu_cfg.wblock_num */ + memcpy(*data, g_usbd_dfu.buffer.d8, g_usbd_dfu.wlength); + *len = g_usbd_dfu.wlength; + } else /* unsupported g_usbd_dfu.wblock_num */ { - usbd_dfu_cfg.dev_state = DFU_STATUS_ERR_STALLEDPKT; + g_usbd_dfu.dev_state = DFU_STATUS_ERR_STALLEDPKT; - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; /* Call the error management function (command will be NAKed */ - USB_LOG_ERR("Dfu_request_upload unsupported usbd_dfu_cfg.wblock_num\r\n"); + USB_LOG_ERR("Dfu_request_upload unsupported g_usbd_dfu.wblock_num\r\n"); } } /* Unsupported state */ else { - usbd_dfu_cfg.wlength = 0U; - usbd_dfu_cfg.wblock_num = 0U; + g_usbd_dfu.wlength = 0U; + g_usbd_dfu.wblock_num = 0U; /* Call the error management function (command will be NAKed */ USB_LOG_ERR("Dfu_request_upload unsupported state\r\n"); @@ -172,12 +172,12 @@ static void dfu_request_upload(struct usb_setup_packet *setup, uint8_t **data, u } /* No Data setup request */ else { - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_IDLE; + g_usbd_dfu.dev_state = DFU_STATE_DFU_IDLE; - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; } } @@ -186,19 +186,19 @@ static void dfu_request_dnload(struct usb_setup_packet *setup, uint8_t **data, u /* Data setup request */ struct usb_setup_packet *req = setup; if (req->wLength > 0U) { - if ((usbd_dfu_cfg.dev_state == DFU_STATE_DFU_IDLE) || (usbd_dfu_cfg.dev_state == DFU_STATE_DFU_DNLOAD_IDLE)) { + if ((g_usbd_dfu.dev_state == DFU_STATE_DFU_IDLE) || (g_usbd_dfu.dev_state == DFU_STATE_DFU_DNLOAD_IDLE)) { /* Update the global length and block number */ - usbd_dfu_cfg.wblock_num = req->wValue; - usbd_dfu_cfg.wlength = MIN(req->wLength, USBD_DFU_XFER_SIZE); + g_usbd_dfu.wblock_num = req->wValue; + g_usbd_dfu.wlength = MIN(req->wLength, USBD_DFU_XFER_SIZE); /* Update the state machine */ - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_DNLOAD_SYNC; - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; + g_usbd_dfu.dev_state = DFU_STATE_DFU_DNLOAD_SYNC; + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; /*!< Data has received complete */ - memcpy((uint8_t *)usbd_dfu_cfg.buffer.d8, (uint8_t *)*data, usbd_dfu_cfg.wlength); + memcpy((uint8_t *)g_usbd_dfu.buffer.d8, (uint8_t *)*data, g_usbd_dfu.wlength); /*!< Set flag = 1 Write the firmware to the flash in the next dfu_request_getstatus */ - usbd_dfu_cfg.firmwar_flag = 1; + g_usbd_dfu.firmwar_flag = 1; } /* Unsupported state */ else { @@ -208,16 +208,16 @@ static void dfu_request_dnload(struct usb_setup_packet *setup, uint8_t **data, u /* 0 Data DNLOAD request */ else { /* End of DNLOAD operation*/ - if ((usbd_dfu_cfg.dev_state == DFU_STATE_DFU_DNLOAD_IDLE) || (usbd_dfu_cfg.dev_state == DFU_STATE_DFU_IDLE)) { - usbd_dfu_cfg.manif_state = DFU_MANIFEST_IN_PROGRESS; - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_MANIFEST_SYNC; - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; + if ((g_usbd_dfu.dev_state == DFU_STATE_DFU_DNLOAD_IDLE) || (g_usbd_dfu.dev_state == DFU_STATE_DFU_IDLE)) { + g_usbd_dfu.manif_state = DFU_MANIFEST_IN_PROGRESS; + g_usbd_dfu.dev_state = DFU_STATE_DFU_MANIFEST_SYNC; + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; } else { /* Call the error management function (command will be NAKed */ - USB_LOG_ERR("Dfu_request_dnload End of DNLOAD operation but dev_state %02x \r\n", usbd_dfu_cfg.dev_state); + USB_LOG_ERR("Dfu_request_dnload End of DNLOAD operation but dev_state %02x \r\n", g_usbd_dfu.dev_state); } } } @@ -225,63 +225,63 @@ static void dfu_request_dnload(struct usb_setup_packet *setup, uint8_t **data, u static int8_t dfu_getstatus_special_handler(void) { uint32_t addr; - if (usbd_dfu_cfg.dev_state == DFU_STATE_DFU_DNLOAD_BUSY) { + if (g_usbd_dfu.dev_state == DFU_STATE_DFU_DNLOAD_BUSY) { /* Decode the Special Command */ - if (usbd_dfu_cfg.wblock_num == 0U) { - if (usbd_dfu_cfg.wlength == 1U) { - if (usbd_dfu_cfg.buffer.d8[0] == DFU_CMD_GETCOMMANDS) { + if (g_usbd_dfu.wblock_num == 0U) { + if (g_usbd_dfu.wlength == 1U) { + if (g_usbd_dfu.buffer.d8[0] == DFU_CMD_GETCOMMANDS) { /* Nothing to do */ } - } else if (usbd_dfu_cfg.wlength == 5U) { - if (usbd_dfu_cfg.buffer.d8[0] == DFU_CMD_SETADDRESSPOINTER) { - usbd_dfu_cfg.data_ptr = usbd_dfu_cfg.buffer.d8[1]; - usbd_dfu_cfg.data_ptr += (uint32_t)usbd_dfu_cfg.buffer.d8[2] << 8; - usbd_dfu_cfg.data_ptr += (uint32_t)usbd_dfu_cfg.buffer.d8[3] << 16; - usbd_dfu_cfg.data_ptr += (uint32_t)usbd_dfu_cfg.buffer.d8[4] << 24; - } else if (usbd_dfu_cfg.buffer.d8[0] == DFU_CMD_ERASE) { - usbd_dfu_cfg.data_ptr = usbd_dfu_cfg.buffer.d8[1]; - usbd_dfu_cfg.data_ptr += (uint32_t)usbd_dfu_cfg.buffer.d8[2] << 8; - usbd_dfu_cfg.data_ptr += (uint32_t)usbd_dfu_cfg.buffer.d8[3] << 16; - usbd_dfu_cfg.data_ptr += (uint32_t)usbd_dfu_cfg.buffer.d8[4] << 24; + } else if (g_usbd_dfu.wlength == 5U) { + if (g_usbd_dfu.buffer.d8[0] == DFU_CMD_SETADDRESSPOINTER) { + g_usbd_dfu.data_ptr = g_usbd_dfu.buffer.d8[1]; + g_usbd_dfu.data_ptr += (uint32_t)g_usbd_dfu.buffer.d8[2] << 8; + g_usbd_dfu.data_ptr += (uint32_t)g_usbd_dfu.buffer.d8[3] << 16; + g_usbd_dfu.data_ptr += (uint32_t)g_usbd_dfu.buffer.d8[4] << 24; + } else if (g_usbd_dfu.buffer.d8[0] == DFU_CMD_ERASE) { + g_usbd_dfu.data_ptr = g_usbd_dfu.buffer.d8[1]; + g_usbd_dfu.data_ptr += (uint32_t)g_usbd_dfu.buffer.d8[2] << 8; + g_usbd_dfu.data_ptr += (uint32_t)g_usbd_dfu.buffer.d8[3] << 16; + g_usbd_dfu.data_ptr += (uint32_t)g_usbd_dfu.buffer.d8[4] << 24; - USB_LOG_DBG("Erase start add %08x \r\n", usbd_dfu_cfg.data_ptr); + USB_LOG_DBG("Erase start add %08x \r\n", g_usbd_dfu.data_ptr); /*!< Erase */ - dfu_erase_flash(usbd_dfu_cfg.data_ptr); + dfu_erase_flash(g_usbd_dfu.data_ptr); } else { return -1; } } else { /* Reset the global length and block number */ - usbd_dfu_cfg.wlength = 0U; - usbd_dfu_cfg.wblock_num = 0U; + g_usbd_dfu.wlength = 0U; + g_usbd_dfu.wblock_num = 0U; /* Call the error management function (command will be NAKed) */ USB_LOG_ERR("Reset the global length and block number\r\n"); } } /* Regular Download Command */ else { - if (usbd_dfu_cfg.wblock_num > 1U) { + if (g_usbd_dfu.wblock_num > 1U) { /* Decode the required address */ - addr = ((usbd_dfu_cfg.wblock_num - 2U) * USBD_DFU_XFER_SIZE) + usbd_dfu_cfg.data_ptr; + addr = ((g_usbd_dfu.wblock_num - 2U) * USBD_DFU_XFER_SIZE) + g_usbd_dfu.data_ptr; /* Perform the write operation */ /* Write flash */ - USB_LOG_DBG("Write start add %08x length %d\r\n", addr, usbd_dfu_cfg.wlength); - dfu_write_flash(usbd_dfu_cfg.buffer.d8, (uint8_t *)addr, usbd_dfu_cfg.wlength); + USB_LOG_DBG("Write start add %08x length %d\r\n", addr, g_usbd_dfu.wlength); + dfu_write_flash(g_usbd_dfu.buffer.d8, (uint8_t *)addr, g_usbd_dfu.wlength); } } /* Reset the global length and block number */ - usbd_dfu_cfg.wlength = 0U; - usbd_dfu_cfg.wblock_num = 0U; + g_usbd_dfu.wlength = 0U; + g_usbd_dfu.wblock_num = 0U; /* Update the state machine */ - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_DNLOAD_SYNC; + g_usbd_dfu.dev_state = DFU_STATE_DFU_DNLOAD_SYNC; - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; } return 0; } @@ -289,77 +289,77 @@ static int8_t dfu_getstatus_special_handler(void) static void dfu_request_getstatus(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { /*!< Determine whether to leave DFU mode */ - if (usbd_dfu_cfg.manif_state == DFU_MANIFEST_IN_PROGRESS && - usbd_dfu_cfg.dev_state == DFU_STATE_DFU_MANIFEST_SYNC && - usbd_dfu_cfg.dev_status[1] == 0U && - usbd_dfu_cfg.dev_status[2] == 0U && - usbd_dfu_cfg.dev_status[3] == 0U && - usbd_dfu_cfg.dev_status[4] == usbd_dfu_cfg.dev_state) { - usbd_dfu_cfg.manif_state = DFU_MANIFEST_COMPLETE; + if (g_usbd_dfu.manif_state == DFU_MANIFEST_IN_PROGRESS && + g_usbd_dfu.dev_state == DFU_STATE_DFU_MANIFEST_SYNC && + g_usbd_dfu.dev_status[1] == 0U && + g_usbd_dfu.dev_status[2] == 0U && + g_usbd_dfu.dev_status[3] == 0U && + g_usbd_dfu.dev_status[4] == g_usbd_dfu.dev_state) { + g_usbd_dfu.manif_state = DFU_MANIFEST_COMPLETE; if ((0x0B & DFU_MANIFEST_MASK) != 0U) { - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_MANIFEST_SYNC; + g_usbd_dfu.dev_state = DFU_STATE_DFU_MANIFEST_SYNC; - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; return; } else { - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_MANIFEST_WAIT_RESET; + g_usbd_dfu.dev_state = DFU_STATE_DFU_MANIFEST_WAIT_RESET; - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; /* Generate system reset to allow jumping to the user code */ dfu_leave(); } } - switch (usbd_dfu_cfg.dev_state) { + switch (g_usbd_dfu.dev_state) { case DFU_STATE_DFU_DNLOAD_SYNC: - if (usbd_dfu_cfg.wlength != 0U) { - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_DNLOAD_BUSY; + if (g_usbd_dfu.wlength != 0U) { + g_usbd_dfu.dev_state = DFU_STATE_DFU_DNLOAD_BUSY; - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; - if ((usbd_dfu_cfg.wblock_num == 0U) && (usbd_dfu_cfg.buffer.d8[0] == DFU_CMD_ERASE)) { - dfu_getstatus(usbd_dfu_cfg.data_ptr, DFU_MEDIA_ERASE, usbd_dfu_cfg.dev_status); + if ((g_usbd_dfu.wblock_num == 0U) && (g_usbd_dfu.buffer.d8[0] == DFU_CMD_ERASE)) { + dfu_getstatus(g_usbd_dfu.data_ptr, DFU_MEDIA_ERASE, g_usbd_dfu.dev_status); } else { - dfu_getstatus(usbd_dfu_cfg.data_ptr, DFU_MEDIA_PROGRAM, usbd_dfu_cfg.dev_status); + dfu_getstatus(g_usbd_dfu.data_ptr, DFU_MEDIA_PROGRAM, g_usbd_dfu.dev_status); } - } else /* (usbd_dfu_cfg.wlength==0)*/ + } else /* (g_usbd_dfu.wlength==0)*/ { - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_DNLOAD_IDLE; + g_usbd_dfu.dev_state = DFU_STATE_DFU_DNLOAD_IDLE; - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; } break; case DFU_STATE_DFU_MANIFEST_SYNC: - if (usbd_dfu_cfg.manif_state == DFU_MANIFEST_IN_PROGRESS) { - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_MANIFEST; + if (g_usbd_dfu.manif_state == DFU_MANIFEST_IN_PROGRESS) { + g_usbd_dfu.dev_state = DFU_STATE_DFU_MANIFEST; - usbd_dfu_cfg.dev_status[1] = 1U; /*bwPollTimeout = 1ms*/ - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; + g_usbd_dfu.dev_status[1] = 1U; /*bwPollTimeout = 1ms*/ + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; } else { - if ((usbd_dfu_cfg.manif_state == DFU_MANIFEST_COMPLETE) && + if ((g_usbd_dfu.manif_state == DFU_MANIFEST_COMPLETE) && ((0x0B & DFU_MANIFEST_MASK) != 0U)) { - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_IDLE; + g_usbd_dfu.dev_state = DFU_STATE_DFU_IDLE; - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; } } break; @@ -369,62 +369,62 @@ static void dfu_request_getstatus(struct usb_setup_packet *setup, uint8_t **data } /* Send the status data over EP0 */ - memcpy(*data, usbd_dfu_cfg.dev_status, 6); + memcpy(*data, g_usbd_dfu.dev_status, 6); *len = 6; - if (usbd_dfu_cfg.firmwar_flag == 1) { + if (g_usbd_dfu.firmwar_flag == 1) { if (dfu_getstatus_special_handler() != 0) { USB_LOG_ERR("dfu_getstatus_special_handler error \r\n"); } - usbd_dfu_cfg.firmwar_flag = 0; + g_usbd_dfu.firmwar_flag = 0; } } static void dfu_request_clrstatus(void) { - if (usbd_dfu_cfg.dev_state == DFU_STATE_DFU_ERROR) { - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_IDLE; - usbd_dfu_cfg.dev_status[0] = DFU_STATUS_OK; /* bStatus */ - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; /* bwPollTimeout=0ms */ - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; /* bState */ - usbd_dfu_cfg.dev_status[5] = 0U; /* iString */ + if (g_usbd_dfu.dev_state == DFU_STATE_DFU_ERROR) { + g_usbd_dfu.dev_state = DFU_STATE_DFU_IDLE; + g_usbd_dfu.dev_status[0] = DFU_STATUS_OK; /* bStatus */ + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; /* bwPollTimeout=0ms */ + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; /* bState */ + g_usbd_dfu.dev_status[5] = 0U; /* iString */ } else { /* State Error */ - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_ERROR; - usbd_dfu_cfg.dev_status[0] = DFU_STATUS_ERR_UNKNOWN; /* bStatus */ - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; /* bwPollTimeout=0ms */ - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; /* bState */ - usbd_dfu_cfg.dev_status[5] = 0U; /* iString */ + g_usbd_dfu.dev_state = DFU_STATE_DFU_ERROR; + g_usbd_dfu.dev_status[0] = DFU_STATUS_ERR_UNKNOWN; /* bStatus */ + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; /* bwPollTimeout=0ms */ + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; /* bState */ + g_usbd_dfu.dev_status[5] = 0U; /* iString */ } } static void dfu_request_getstate(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { /* Return the current state of the DFU interface */ - (*data)[0] = usbd_dfu_cfg.dev_state; + (*data)[0] = g_usbd_dfu.dev_state; *len = 1; } void dfu_request_abort(void) { - if ((usbd_dfu_cfg.dev_state == DFU_STATE_DFU_IDLE) || - (usbd_dfu_cfg.dev_state == DFU_STATE_DFU_DNLOAD_SYNC) || - (usbd_dfu_cfg.dev_state == DFU_STATE_DFU_DNLOAD_IDLE) || - (usbd_dfu_cfg.dev_state == DFU_STATE_DFU_MANIFEST_SYNC) || - (usbd_dfu_cfg.dev_state == DFU_STATE_DFU_UPLOAD_IDLE)) { - usbd_dfu_cfg.dev_state = DFU_STATE_DFU_IDLE; - usbd_dfu_cfg.dev_status[0] = DFU_STATUS_OK; - usbd_dfu_cfg.dev_status[1] = 0U; - usbd_dfu_cfg.dev_status[2] = 0U; - usbd_dfu_cfg.dev_status[3] = 0U; /* bwPollTimeout=0ms */ - usbd_dfu_cfg.dev_status[4] = usbd_dfu_cfg.dev_state; - usbd_dfu_cfg.dev_status[5] = 0U; /* iString */ - usbd_dfu_cfg.wblock_num = 0U; - usbd_dfu_cfg.wlength = 0U; + if ((g_usbd_dfu.dev_state == DFU_STATE_DFU_IDLE) || + (g_usbd_dfu.dev_state == DFU_STATE_DFU_DNLOAD_SYNC) || + (g_usbd_dfu.dev_state == DFU_STATE_DFU_DNLOAD_IDLE) || + (g_usbd_dfu.dev_state == DFU_STATE_DFU_MANIFEST_SYNC) || + (g_usbd_dfu.dev_state == DFU_STATE_DFU_UPLOAD_IDLE)) { + g_usbd_dfu.dev_state = DFU_STATE_DFU_IDLE; + g_usbd_dfu.dev_status[0] = DFU_STATUS_OK; + g_usbd_dfu.dev_status[1] = 0U; + g_usbd_dfu.dev_status[2] = 0U; + g_usbd_dfu.dev_status[3] = 0U; /* bwPollTimeout=0ms */ + g_usbd_dfu.dev_status[4] = g_usbd_dfu.dev_state; + g_usbd_dfu.dev_status[5] = 0U; /* iString */ + g_usbd_dfu.wblock_num = 0U; + g_usbd_dfu.wlength = 0U; } } diff --git a/class/msc/usbd_msc.c b/class/msc/usbd_msc.c index cf249611..d68d83cc 100644 --- a/class/msc/usbd_msc.c +++ b/class/msc/usbd_msc.c @@ -23,7 +23,7 @@ enum Stage { }; /* Device data structure */ -USB_NOCACHE_RAM_SECTION struct usbd_msc_cfg_priv { +USB_NOCACHE_RAM_SECTION struct usbd_msc_priv { /* state of the bulk-only state machine */ enum Stage stage; USB_MEM_ALIGNX struct CBW cbw; @@ -39,13 +39,13 @@ USB_NOCACHE_RAM_SECTION struct usbd_msc_cfg_priv { uint16_t scsi_blk_size; uint32_t scsi_blk_nbr; - uint8_t block_buffer[CONFIG_USBDEV_MSC_BLOCK_SIZE]; -} usbd_msc_cfg; + USB_MEM_ALIGNX uint8_t block_buffer[CONFIG_USBDEV_MSC_BLOCK_SIZE]; +} g_usbd_msc; static void usbd_msc_reset(void) { - usbd_msc_cfg.stage = MSC_READ_CBW; - usbd_msc_cfg.readonly = false; + g_usbd_msc.stage = MSC_READ_CBW; + g_usbd_msc.readonly = false; } static int msc_storage_class_interface_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) @@ -60,7 +60,7 @@ static int msc_storage_class_interface_request_handler(struct usb_setup_packet * break; case MSC_REQUEST_GET_MAX_LUN: - (*data)[0] = usbd_msc_cfg.max_lun; + (*data)[0] = g_usbd_msc.max_lun; *len = 1; break; @@ -80,7 +80,7 @@ void msc_storage_notify_handler(uint8_t event, void *arg) break; case USBD_EVENT_CONFIGURED: USB_LOG_DBG("Start reading cbw\r\n"); - usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, (uint8_t *)&usbd_msc_cfg.cbw, USB_SIZEOF_MSC_CBW); + usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, (uint8_t *)&g_usbd_msc.cbw, USB_SIZEOF_MSC_CBW); break; default: @@ -90,40 +90,40 @@ void msc_storage_notify_handler(uint8_t event, void *arg) static void usbd_msc_bot_abort(void) { - if ((usbd_msc_cfg.cbw.bmFlags == 0) && (usbd_msc_cfg.cbw.dDataLength != 0)) { + if ((g_usbd_msc.cbw.bmFlags == 0) && (g_usbd_msc.cbw.dDataLength != 0)) { usbd_ep_set_stall(mass_ep_data[MSD_OUT_EP_IDX].ep_addr); } usbd_ep_set_stall(mass_ep_data[MSD_IN_EP_IDX].ep_addr); - usbd_ep_start_read(mass_ep_data[0].ep_addr, (uint8_t *)&usbd_msc_cfg.cbw, USB_SIZEOF_MSC_CBW); + usbd_ep_start_read(mass_ep_data[0].ep_addr, (uint8_t *)&g_usbd_msc.cbw, USB_SIZEOF_MSC_CBW); } static void usbd_msc_send_csw(uint8_t CSW_Status) { - usbd_msc_cfg.csw.dSignature = MSC_CSW_Signature; - usbd_msc_cfg.csw.bStatus = CSW_Status; + g_usbd_msc.csw.dSignature = MSC_CSW_Signature; + g_usbd_msc.csw.bStatus = CSW_Status; /* updating the State Machine , so that we wait CSW when this * transfer is complete, ie when we get a bulk in callback */ - usbd_msc_cfg.stage = MSC_WAIT_CSW; + g_usbd_msc.stage = MSC_WAIT_CSW; USB_LOG_DBG("Send csw\r\n"); - usbd_ep_start_write(mass_ep_data[MSD_IN_EP_IDX].ep_addr, (uint8_t *)&usbd_msc_cfg.csw, sizeof(struct CSW)); + usbd_ep_start_write(mass_ep_data[MSD_IN_EP_IDX].ep_addr, (uint8_t *)&g_usbd_msc.csw, sizeof(struct CSW)); } static void usbd_msc_send_info(uint8_t *buffer, uint8_t size) { - size = MIN(size, usbd_msc_cfg.cbw.dDataLength); + size = MIN(size, g_usbd_msc.cbw.dDataLength); /* updating the State Machine , so that we send CSW when this * transfer is complete, ie when we get a bulk in callback */ - usbd_msc_cfg.stage = MSC_SEND_CSW; + g_usbd_msc.stage = MSC_SEND_CSW; usbd_ep_start_write(mass_ep_data[MSD_IN_EP_IDX].ep_addr, buffer, size); - usbd_msc_cfg.csw.dDataResidue -= size; - usbd_msc_cfg.csw.bStatus = CSW_STATUS_CMD_PASSED; + g_usbd_msc.csw.dDataResidue -= size; + g_usbd_msc.csw.bStatus = CSW_STATUS_CMD_PASSED; } static bool SCSI_processWrite(uint32_t nbytes); @@ -139,9 +139,9 @@ static bool SCSI_processRead(void); */ static void SCSI_SetSenseData(uint32_t KCQ) { - usbd_msc_cfg.sKey = (uint8_t)(KCQ >> 16); - usbd_msc_cfg.ASC = (uint8_t)(KCQ >> 8); - usbd_msc_cfg.ASQ = (uint8_t)(KCQ); + g_usbd_msc.sKey = (uint8_t)(KCQ >> 16); + g_usbd_msc.ASC = (uint8_t)(KCQ >> 8); + g_usbd_msc.ASQ = (uint8_t)(KCQ); } /** @@ -151,7 +151,7 @@ static void SCSI_SetSenseData(uint32_t KCQ) static bool SCSI_testUnitReady(uint8_t **data, uint32_t *len) { - if (usbd_msc_cfg.cbw.dDataLength != 0U) { + if (g_usbd_msc.cbw.dDataLength != 0U) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } @@ -163,13 +163,13 @@ static bool SCSI_testUnitReady(uint8_t **data, uint32_t *len) static bool SCSI_requestSense(uint8_t **data, uint32_t *len) { uint8_t data_len = SCSIRESP_FIXEDSENSEDATA_SIZEOF; - if (usbd_msc_cfg.cbw.dDataLength == 0U) { + if (g_usbd_msc.cbw.dDataLength == 0U) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } - if (usbd_msc_cfg.cbw.CB[4] < SCSIRESP_FIXEDSENSEDATA_SIZEOF) { - data_len = usbd_msc_cfg.cbw.CB[4]; + if (g_usbd_msc.cbw.CB[4] < SCSIRESP_FIXEDSENSEDATA_SIZEOF) { + data_len = g_usbd_msc.cbw.CB[4]; } uint8_t request_sense[SCSIRESP_FIXEDSENSEDATA_SIZEOF] = { @@ -193,9 +193,9 @@ static bool SCSI_requestSense(uint8_t **data, uint32_t *len) 0x00, }; - request_sense[2] = usbd_msc_cfg.sKey; - request_sense[12] = usbd_msc_cfg.ASC; - request_sense[13] = usbd_msc_cfg.ASQ; + request_sense[2] = g_usbd_msc.sKey; + request_sense[12] = g_usbd_msc.ASC; + request_sense[13] = g_usbd_msc.ASQ; #if 0 request_sense[ 2] = 0x06; /* UNIT ATTENTION */ request_sense[12] = 0x28; /* Additional Sense Code: Not ready to ready transition */ @@ -269,16 +269,16 @@ static bool SCSI_inquiry(uint8_t **data, uint32_t *len) memcpy(&inquiry[16], CONFIG_USBDEV_MSC_PRODUCT_STRING, strlen(CONFIG_USBDEV_MSC_PRODUCT_STRING)); memcpy(&inquiry[32], CONFIG_USBDEV_MSC_VERSION_STRING, strlen(CONFIG_USBDEV_MSC_VERSION_STRING)); - if (usbd_msc_cfg.cbw.dDataLength == 0U) { + if (g_usbd_msc.cbw.dDataLength == 0U) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } - if ((usbd_msc_cfg.cbw.CB[1] & 0x01U) != 0U) { /* Evpd is set */ - if (usbd_msc_cfg.cbw.CB[2] == 0U) { /* Request for Supported Vital Product Data Pages*/ + if ((g_usbd_msc.cbw.CB[1] & 0x01U) != 0U) { /* Evpd is set */ + if (g_usbd_msc.cbw.CB[2] == 0U) { /* Request for Supported Vital Product Data Pages*/ data_len = 0x06; memcpy(*data, (uint8_t *)inquiry00, data_len); - } else if (usbd_msc_cfg.cbw.CB[2] == 0x80U) { /* Request for VPD page 0x80 Unit Serial Number */ + } else if (g_usbd_msc.cbw.CB[2] == 0x80U) { /* Request for VPD page 0x80 Unit Serial Number */ data_len = 0x08; memcpy(*data, (uint8_t *)inquiry80, data_len); } else { /* Request Not supported */ @@ -286,8 +286,8 @@ static bool SCSI_inquiry(uint8_t **data, uint32_t *len) return false; } } else { - if (usbd_msc_cfg.cbw.CB[4] < SCSIRESP_INQUIRY_SIZEOF) { - data_len = usbd_msc_cfg.cbw.CB[4]; + if (g_usbd_msc.cbw.CB[4] < SCSIRESP_INQUIRY_SIZEOF) { + data_len = g_usbd_msc.cbw.CB[4]; } memcpy(*data, (uint8_t *)inquiry, data_len); } @@ -298,18 +298,18 @@ static bool SCSI_inquiry(uint8_t **data, uint32_t *len) static bool SCSI_startStopUnit(uint8_t **data, uint32_t *len) { - if (usbd_msc_cfg.cbw.dDataLength != 0U) { + if (g_usbd_msc.cbw.dDataLength != 0U) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } - if ((usbd_msc_cfg.cbw.CB[4] & 0x3U) == 0x1U) /* START=1 */ + if ((g_usbd_msc.cbw.CB[4] & 0x3U) == 0x1U) /* START=1 */ { //SCSI_MEDIUM_UNLOCKED; - } else if ((usbd_msc_cfg.cbw.CB[4] & 0x3U) == 0x2U) /* START=0 and LOEJ Load Eject=1 */ + } else if ((g_usbd_msc.cbw.CB[4] & 0x3U) == 0x2U) /* START=0 and LOEJ Load Eject=1 */ { //SCSI_MEDIUM_EJECTED; - } else if ((usbd_msc_cfg.cbw.CB[4] & 0x3U) == 0x3U) /* START=1 and LOEJ Load Eject=1 */ + } else if ((g_usbd_msc.cbw.CB[4] & 0x3U) == 0x3U) /* START=1 and LOEJ Load Eject=1 */ { //SCSI_MEDIUM_UNLOCKED; } else { @@ -322,11 +322,11 @@ static bool SCSI_startStopUnit(uint8_t **data, uint32_t *len) static bool SCSI_preventAllowMediaRemoval(uint8_t **data, uint32_t *len) { - if (usbd_msc_cfg.cbw.dDataLength != 0U) { + if (g_usbd_msc.cbw.dDataLength != 0U) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } - if (usbd_msc_cfg.cbw.CB[4] == 0U) { + if (g_usbd_msc.cbw.CB[4] == 0U) { //SCSI_MEDIUM_UNLOCKED; } else { //SCSI_MEDIUM_LOCKED; @@ -339,17 +339,17 @@ static bool SCSI_preventAllowMediaRemoval(uint8_t **data, uint32_t *len) static bool SCSI_modeSense6(uint8_t **data, uint32_t *len) { uint8_t data_len = 4; - if (usbd_msc_cfg.cbw.dDataLength == 0U) { + if (g_usbd_msc.cbw.dDataLength == 0U) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } - if (usbd_msc_cfg.cbw.CB[4] < SCSIRESP_MODEPARAMETERHDR6_SIZEOF) { - data_len = usbd_msc_cfg.cbw.CB[4]; + if (g_usbd_msc.cbw.CB[4] < SCSIRESP_MODEPARAMETERHDR6_SIZEOF) { + data_len = g_usbd_msc.cbw.CB[4]; } uint8_t sense6[SCSIRESP_MODEPARAMETERHDR6_SIZEOF] = { 0x03, 0x00, 0x00, 0x00 }; - if (usbd_msc_cfg.readonly) { + if (g_usbd_msc.readonly) { sense6[2] = 0x80; } memcpy(*data, (uint8_t *)sense6, data_len); @@ -360,13 +360,13 @@ static bool SCSI_modeSense6(uint8_t **data, uint32_t *len) static bool SCSI_modeSense10(uint8_t **data, uint32_t *len) { uint8_t data_len = 27; - if (usbd_msc_cfg.cbw.dDataLength == 0U) { + if (g_usbd_msc.cbw.dDataLength == 0U) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } - if (usbd_msc_cfg.cbw.CB[8] < 27) { - data_len = usbd_msc_cfg.cbw.CB[8]; + if (g_usbd_msc.cbw.CB[8] < 27) { + data_len = g_usbd_msc.cbw.CB[8]; } uint8_t sense10[27] = { @@ -406,7 +406,7 @@ static bool SCSI_modeSense10(uint8_t **data, uint32_t *len) static bool SCSI_readFormatCapacity(uint8_t **data, uint32_t *len) { - if (usbd_msc_cfg.cbw.dDataLength == 0U) { + if (g_usbd_msc.cbw.dDataLength == 0U) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } @@ -415,15 +415,15 @@ static bool SCSI_readFormatCapacity(uint8_t **data, uint32_t *len) 0x00, 0x00, 0x08, /* Capacity List Length */ - (uint8_t)((usbd_msc_cfg.scsi_blk_nbr >> 24) & 0xff), - (uint8_t)((usbd_msc_cfg.scsi_blk_nbr >> 16) & 0xff), - (uint8_t)((usbd_msc_cfg.scsi_blk_nbr >> 8) & 0xff), - (uint8_t)((usbd_msc_cfg.scsi_blk_nbr >> 0) & 0xff), + (uint8_t)((g_usbd_msc.scsi_blk_nbr >> 24) & 0xff), + (uint8_t)((g_usbd_msc.scsi_blk_nbr >> 16) & 0xff), + (uint8_t)((g_usbd_msc.scsi_blk_nbr >> 8) & 0xff), + (uint8_t)((g_usbd_msc.scsi_blk_nbr >> 0) & 0xff), 0x02, /* Descriptor Code: Formatted Media */ 0x00, - (uint8_t)((usbd_msc_cfg.scsi_blk_size >> 8) & 0xff), - (uint8_t)((usbd_msc_cfg.scsi_blk_size >> 0) & 0xff), + (uint8_t)((g_usbd_msc.scsi_blk_size >> 8) & 0xff), + (uint8_t)((g_usbd_msc.scsi_blk_size >> 0) & 0xff), }; memcpy(*data, (uint8_t *)format_capacity, SCSIRESP_READFORMATCAPACITIES_SIZEOF); @@ -433,21 +433,21 @@ static bool SCSI_readFormatCapacity(uint8_t **data, uint32_t *len) static bool SCSI_readCapacity10(uint8_t **data, uint32_t *len) { - if (usbd_msc_cfg.cbw.dDataLength == 0U) { + if (g_usbd_msc.cbw.dDataLength == 0U) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } uint8_t capacity10[SCSIRESP_READCAPACITY10_SIZEOF] = { - (uint8_t)(((usbd_msc_cfg.scsi_blk_nbr - 1) >> 24) & 0xff), - (uint8_t)(((usbd_msc_cfg.scsi_blk_nbr - 1) >> 16) & 0xff), - (uint8_t)(((usbd_msc_cfg.scsi_blk_nbr - 1) >> 8) & 0xff), - (uint8_t)(((usbd_msc_cfg.scsi_blk_nbr - 1) >> 0) & 0xff), + (uint8_t)(((g_usbd_msc.scsi_blk_nbr - 1) >> 24) & 0xff), + (uint8_t)(((g_usbd_msc.scsi_blk_nbr - 1) >> 16) & 0xff), + (uint8_t)(((g_usbd_msc.scsi_blk_nbr - 1) >> 8) & 0xff), + (uint8_t)(((g_usbd_msc.scsi_blk_nbr - 1) >> 0) & 0xff), - (uint8_t)((usbd_msc_cfg.scsi_blk_size >> 24) & 0xff), - (uint8_t)((usbd_msc_cfg.scsi_blk_size >> 16) & 0xff), - (uint8_t)((usbd_msc_cfg.scsi_blk_size >> 8) & 0xff), - (uint8_t)((usbd_msc_cfg.scsi_blk_size >> 0) & 0xff), + (uint8_t)((g_usbd_msc.scsi_blk_size >> 24) & 0xff), + (uint8_t)((g_usbd_msc.scsi_blk_size >> 16) & 0xff), + (uint8_t)((g_usbd_msc.scsi_blk_size >> 8) & 0xff), + (uint8_t)((g_usbd_msc.scsi_blk_size >> 0) & 0xff), }; memcpy(*data, (uint8_t *)capacity10, SCSIRESP_READCAPACITY10_SIZEOF); @@ -457,113 +457,113 @@ static bool SCSI_readCapacity10(uint8_t **data, uint32_t *len) static bool SCSI_read10(uint8_t **data, uint32_t *len) { - if (((usbd_msc_cfg.cbw.bmFlags & 0x80U) != 0x80U) || (usbd_msc_cfg.cbw.dDataLength == 0U)) { + if (((g_usbd_msc.cbw.bmFlags & 0x80U) != 0x80U) || (g_usbd_msc.cbw.dDataLength == 0U)) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } - usbd_msc_cfg.start_sector = GET_BE32(&usbd_msc_cfg.cbw.CB[2]); /* Logical Block Address of First Block */ - USB_LOG_DBG("lba: 0x%04x\r\n", usbd_msc_cfg.start_sector); + g_usbd_msc.start_sector = GET_BE32(&g_usbd_msc.cbw.CB[2]); /* Logical Block Address of First Block */ + USB_LOG_DBG("lba: 0x%04x\r\n", g_usbd_msc.start_sector); - usbd_msc_cfg.nsectors = GET_BE16(&usbd_msc_cfg.cbw.CB[7]); /* Number of Blocks to transfer */ - USB_LOG_DBG("nsectors: 0x%02x\r\n", usbd_msc_cfg.nsectors); + g_usbd_msc.nsectors = GET_BE16(&g_usbd_msc.cbw.CB[7]); /* Number of Blocks to transfer */ + USB_LOG_DBG("nsectors: 0x%02x\r\n", g_usbd_msc.nsectors); - if ((usbd_msc_cfg.start_sector + usbd_msc_cfg.nsectors) > usbd_msc_cfg.scsi_blk_nbr) { + if ((g_usbd_msc.start_sector + g_usbd_msc.nsectors) > g_usbd_msc.scsi_blk_nbr) { SCSI_SetSenseData(SCSI_KCQIR_LBAOUTOFRANGE); USB_LOG_ERR("LBA out of range\r\n"); return false; } - if (usbd_msc_cfg.cbw.dDataLength != (usbd_msc_cfg.nsectors * usbd_msc_cfg.scsi_blk_size)) { + if (g_usbd_msc.cbw.dDataLength != (g_usbd_msc.nsectors * g_usbd_msc.scsi_blk_size)) { USB_LOG_ERR("scsi_blk_len does not match with dDataLength\r\n"); return false; } - usbd_msc_cfg.stage = MSC_DATA_IN; + g_usbd_msc.stage = MSC_DATA_IN; return SCSI_processRead(); } static bool SCSI_read12(uint8_t **data, uint32_t *len) { - if (((usbd_msc_cfg.cbw.bmFlags & 0x80U) != 0x80U) || (usbd_msc_cfg.cbw.dDataLength == 0U)) { + if (((g_usbd_msc.cbw.bmFlags & 0x80U) != 0x80U) || (g_usbd_msc.cbw.dDataLength == 0U)) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } - usbd_msc_cfg.start_sector = GET_BE32(&usbd_msc_cfg.cbw.CB[2]); /* Logical Block Address of First Block */ - USB_LOG_DBG("lba: 0x%04x\r\n", usbd_msc_cfg.start_sector); + g_usbd_msc.start_sector = GET_BE32(&g_usbd_msc.cbw.CB[2]); /* Logical Block Address of First Block */ + USB_LOG_DBG("lba: 0x%04x\r\n", g_usbd_msc.start_sector); - usbd_msc_cfg.nsectors = GET_BE32(&usbd_msc_cfg.cbw.CB[6]); /* Number of Blocks to transfer */ - USB_LOG_DBG("nsectors: 0x%02x\r\n", usbd_msc_cfg.nsectors); + g_usbd_msc.nsectors = GET_BE32(&g_usbd_msc.cbw.CB[6]); /* Number of Blocks to transfer */ + USB_LOG_DBG("nsectors: 0x%02x\r\n", g_usbd_msc.nsectors); - if ((usbd_msc_cfg.start_sector + usbd_msc_cfg.nsectors) > usbd_msc_cfg.scsi_blk_nbr) { + if ((g_usbd_msc.start_sector + g_usbd_msc.nsectors) > g_usbd_msc.scsi_blk_nbr) { SCSI_SetSenseData(SCSI_KCQIR_LBAOUTOFRANGE); USB_LOG_ERR("LBA out of range\r\n"); return false; } - if (usbd_msc_cfg.cbw.dDataLength != (usbd_msc_cfg.nsectors * usbd_msc_cfg.scsi_blk_size)) { + if (g_usbd_msc.cbw.dDataLength != (g_usbd_msc.nsectors * g_usbd_msc.scsi_blk_size)) { USB_LOG_ERR("scsi_blk_len does not match with dDataLength\r\n"); return false; } - usbd_msc_cfg.stage = MSC_DATA_IN; + g_usbd_msc.stage = MSC_DATA_IN; return SCSI_processRead(); } static bool SCSI_write10(uint8_t **data, uint32_t *len) { uint32_t data_len = 0; - if (((usbd_msc_cfg.cbw.bmFlags & 0x80U) != 0x00U) || (usbd_msc_cfg.cbw.dDataLength == 0U)) { + if (((g_usbd_msc.cbw.bmFlags & 0x80U) != 0x00U) || (g_usbd_msc.cbw.dDataLength == 0U)) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } - usbd_msc_cfg.start_sector = GET_BE32(&usbd_msc_cfg.cbw.CB[2]); /* Logical Block Address of First Block */ - USB_LOG_DBG("lba: 0x%04x\r\n", usbd_msc_cfg.start_sector); + g_usbd_msc.start_sector = GET_BE32(&g_usbd_msc.cbw.CB[2]); /* Logical Block Address of First Block */ + USB_LOG_DBG("lba: 0x%04x\r\n", g_usbd_msc.start_sector); - usbd_msc_cfg.nsectors = GET_BE16(&usbd_msc_cfg.cbw.CB[7]); /* Number of Blocks to transfer */ - USB_LOG_DBG("nsectors: 0x%02x\r\n", usbd_msc_cfg.nsectors); + g_usbd_msc.nsectors = GET_BE16(&g_usbd_msc.cbw.CB[7]); /* Number of Blocks to transfer */ + USB_LOG_DBG("nsectors: 0x%02x\r\n", g_usbd_msc.nsectors); - data_len = usbd_msc_cfg.nsectors * usbd_msc_cfg.scsi_blk_size; - if ((usbd_msc_cfg.start_sector + usbd_msc_cfg.nsectors) > usbd_msc_cfg.scsi_blk_nbr) { + data_len = g_usbd_msc.nsectors * g_usbd_msc.scsi_blk_size; + if ((g_usbd_msc.start_sector + g_usbd_msc.nsectors) > g_usbd_msc.scsi_blk_nbr) { USB_LOG_ERR("LBA out of range\r\n"); return false; } - if (usbd_msc_cfg.cbw.dDataLength != data_len) { + if (g_usbd_msc.cbw.dDataLength != data_len) { return false; } - usbd_msc_cfg.stage = MSC_DATA_OUT; + g_usbd_msc.stage = MSC_DATA_OUT; data_len = MIN(data_len, CONFIG_USBDEV_MSC_BLOCK_SIZE); - usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, usbd_msc_cfg.block_buffer, data_len); + usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, g_usbd_msc.block_buffer, data_len); return true; } static bool SCSI_write12(uint8_t **data, uint32_t *len) { uint32_t data_len = 0; - if (((usbd_msc_cfg.cbw.bmFlags & 0x80U) != 0x00U) || (usbd_msc_cfg.cbw.dDataLength == 0U)) { + if (((g_usbd_msc.cbw.bmFlags & 0x80U) != 0x00U) || (g_usbd_msc.cbw.dDataLength == 0U)) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } - usbd_msc_cfg.start_sector = GET_BE32(&usbd_msc_cfg.cbw.CB[2]); /* Logical Block Address of First Block */ - USB_LOG_DBG("lba: 0x%04x\r\n", usbd_msc_cfg.start_sector); + g_usbd_msc.start_sector = GET_BE32(&g_usbd_msc.cbw.CB[2]); /* Logical Block Address of First Block */ + USB_LOG_DBG("lba: 0x%04x\r\n", g_usbd_msc.start_sector); - usbd_msc_cfg.nsectors = GET_BE32(&usbd_msc_cfg.cbw.CB[6]); /* Number of Blocks to transfer */ - USB_LOG_DBG("nsectors: 0x%02x\r\n", usbd_msc_cfg.nsectors); + g_usbd_msc.nsectors = GET_BE32(&g_usbd_msc.cbw.CB[6]); /* Number of Blocks to transfer */ + USB_LOG_DBG("nsectors: 0x%02x\r\n", g_usbd_msc.nsectors); - data_len = usbd_msc_cfg.nsectors * usbd_msc_cfg.scsi_blk_size; - if ((usbd_msc_cfg.start_sector + usbd_msc_cfg.nsectors) > usbd_msc_cfg.scsi_blk_nbr) { + data_len = g_usbd_msc.nsectors * g_usbd_msc.scsi_blk_size; + if ((g_usbd_msc.start_sector + g_usbd_msc.nsectors) > g_usbd_msc.scsi_blk_nbr) { USB_LOG_ERR("LBA out of range\r\n"); return false; } - if (usbd_msc_cfg.cbw.dDataLength != data_len) { + if (g_usbd_msc.cbw.dDataLength != data_len) { return false; } - usbd_msc_cfg.stage = MSC_DATA_OUT; + g_usbd_msc.stage = MSC_DATA_OUT; data_len = MIN(data_len, CONFIG_USBDEV_MSC_BLOCK_SIZE); - usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, usbd_msc_cfg.block_buffer, data_len); + usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, g_usbd_msc.block_buffer, data_len); return true; } /* do not use verify to reduce code size */ @@ -574,41 +574,41 @@ static bool SCSI_verify10(uint8_t **data, uint32_t *len) uint32_t lba = 0; uint32_t blk_num = 0; - if ((usbd_msc_cfg.cbw.CB[1] & 0x02U) == 0x00U) { + if ((g_usbd_msc.cbw.CB[1] & 0x02U) == 0x00U) { return true; } - if (((usbd_msc_cfg.cbw.bmFlags & 0x80U) != 0x00U) || (usbd_msc_cfg.cbw.dDataLength == 0U)) { + if (((g_usbd_msc.cbw.bmFlags & 0x80U) != 0x00U) || (g_usbd_msc.cbw.dDataLength == 0U)) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } - if ((usbd_msc_cfg.cbw.CB[1] & 0x02U) == 0x02U) { + if ((g_usbd_msc.cbw.CB[1] & 0x02U) == 0x02U) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDFIELDINCBA); return false; /* Error, Verify Mode Not supported*/ } - lba = GET_BE32(&usbd_msc_cfg.cbw.CB[2]); + lba = GET_BE32(&g_usbd_msc.cbw.CB[2]); USB_LOG_DBG("lba: 0x%x\r\n", lba); - usbd_msc_cfg.scsi_blk_addr = lba * usbd_msc_cfg.scsi_blk_size; + g_usbd_msc.scsi_blk_addr = lba * g_usbd_msc.scsi_blk_size; /* Number of Blocks to transfer */ - blk_num = GET_BE16(&usbd_msc_cfg.cbw.CB[7]); + blk_num = GET_BE16(&g_usbd_msc.cbw.CB[7]); USB_LOG_DBG("num (block) : 0x%x\r\n", blk_num); - usbd_msc_cfg.scsi_blk_len = blk_num * usbd_msc_cfg.scsi_blk_size; + g_usbd_msc.scsi_blk_len = blk_num * g_usbd_msc.scsi_blk_size; - if ((lba + blk_num) > usbd_msc_cfg.scsi_blk_nbr) { + if ((lba + blk_num) > g_usbd_msc.scsi_blk_nbr) { USB_LOG_ERR("LBA out of range\r\n"); return false; } - if (usbd_msc_cfg.cbw.dDataLength != usbd_msc_cfg.scsi_blk_len) { + if (g_usbd_msc.cbw.dDataLength != g_usbd_msc.scsi_blk_len) { return false; } - usbd_msc_cfg.stage = MSC_DATA_OUT; + g_usbd_msc.stage = MSC_DATA_OUT; return true; } #endif @@ -617,23 +617,23 @@ static bool SCSI_processRead(void) { uint32_t transfer_len; - USB_LOG_DBG("read lba:%d\r\n", usbd_msc_cfg.start_sector); + USB_LOG_DBG("read lba:%d\r\n", g_usbd_msc.start_sector); - transfer_len = MIN(usbd_msc_cfg.nsectors * usbd_msc_cfg.scsi_blk_size, CONFIG_USBDEV_MSC_BLOCK_SIZE); + transfer_len = MIN(g_usbd_msc.nsectors * g_usbd_msc.scsi_blk_size, CONFIG_USBDEV_MSC_BLOCK_SIZE); - if (usbd_msc_sector_read(usbd_msc_cfg.start_sector, usbd_msc_cfg.block_buffer, transfer_len) != 0) { + if (usbd_msc_sector_read(g_usbd_msc.start_sector, g_usbd_msc.block_buffer, transfer_len) != 0) { SCSI_SetSenseData(SCSI_KCQHE_UREINRESERVEDAREA); return false; } - usbd_ep_start_write(mass_ep_data[MSD_IN_EP_IDX].ep_addr, usbd_msc_cfg.block_buffer, transfer_len); + usbd_ep_start_write(mass_ep_data[MSD_IN_EP_IDX].ep_addr, g_usbd_msc.block_buffer, transfer_len); - usbd_msc_cfg.start_sector += (transfer_len / usbd_msc_cfg.scsi_blk_size); - usbd_msc_cfg.nsectors -= (transfer_len / usbd_msc_cfg.scsi_blk_size); - usbd_msc_cfg.csw.dDataResidue -= transfer_len; + g_usbd_msc.start_sector += (transfer_len / g_usbd_msc.scsi_blk_size); + g_usbd_msc.nsectors -= (transfer_len / g_usbd_msc.scsi_blk_size); + g_usbd_msc.csw.dDataResidue -= transfer_len; - if (usbd_msc_cfg.nsectors == 0) { - usbd_msc_cfg.stage = MSC_SEND_CSW; + if (g_usbd_msc.nsectors == 0) { + g_usbd_msc.stage = MSC_SEND_CSW; } return true; @@ -642,22 +642,22 @@ static bool SCSI_processRead(void) static bool SCSI_processWrite(uint32_t nbytes) { uint32_t data_len = 0; - USB_LOG_DBG("write lba:%d\r\n", usbd_msc_cfg.start_sector); + USB_LOG_DBG("write lba:%d\r\n", g_usbd_msc.start_sector); - if (usbd_msc_sector_write(usbd_msc_cfg.start_sector, usbd_msc_cfg.block_buffer, nbytes) != 0) { + if (usbd_msc_sector_write(g_usbd_msc.start_sector, g_usbd_msc.block_buffer, nbytes) != 0) { SCSI_SetSenseData(SCSI_KCQHE_WRITEFAULT); return false; } - usbd_msc_cfg.start_sector += (nbytes / usbd_msc_cfg.scsi_blk_size); - usbd_msc_cfg.nsectors -= (nbytes / usbd_msc_cfg.scsi_blk_size); - usbd_msc_cfg.csw.dDataResidue -= nbytes; + g_usbd_msc.start_sector += (nbytes / g_usbd_msc.scsi_blk_size); + g_usbd_msc.nsectors -= (nbytes / g_usbd_msc.scsi_blk_size); + g_usbd_msc.csw.dDataResidue -= nbytes; - if (usbd_msc_cfg.nsectors == 0) { + if (g_usbd_msc.nsectors == 0) { usbd_msc_send_csw(CSW_STATUS_CMD_PASSED); } else { - data_len = MIN(usbd_msc_cfg.nsectors * usbd_msc_cfg.scsi_blk_size, CONFIG_USBDEV_MSC_BLOCK_SIZE); - usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, usbd_msc_cfg.block_buffer, data_len); + data_len = MIN(g_usbd_msc.nsectors * g_usbd_msc.scsi_blk_size, CONFIG_USBDEV_MSC_BLOCK_SIZE); + usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, g_usbd_msc.block_buffer, data_len); } return true; @@ -665,7 +665,7 @@ static bool SCSI_processWrite(uint32_t nbytes) static bool SCSI_CBWDecode(uint32_t nbytes) { - uint8_t *buf2send = usbd_msc_cfg.block_buffer; + uint8_t *buf2send = g_usbd_msc.block_buffer; uint32_t len2send = 0; bool ret = false; @@ -675,15 +675,15 @@ static bool SCSI_CBWDecode(uint32_t nbytes) return false; } - usbd_msc_cfg.csw.dTag = usbd_msc_cfg.cbw.dTag; - usbd_msc_cfg.csw.dDataResidue = usbd_msc_cfg.cbw.dDataLength; + g_usbd_msc.csw.dTag = g_usbd_msc.cbw.dTag; + g_usbd_msc.csw.dDataResidue = g_usbd_msc.cbw.dDataLength; - if ((usbd_msc_cfg.cbw.bLUN > 1) || (usbd_msc_cfg.cbw.dSignature != MSC_CBW_Signature) || (usbd_msc_cfg.cbw.bCBLength < 1) || (usbd_msc_cfg.cbw.bCBLength > 16)) { + if ((g_usbd_msc.cbw.bLUN > 1) || (g_usbd_msc.cbw.dSignature != MSC_CBW_Signature) || (g_usbd_msc.cbw.bCBLength < 1) || (g_usbd_msc.cbw.bCBLength > 16)) { SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); return false; } else { - USB_LOG_DBG("Decode CB:0x%02x\r\n", usbd_msc_cfg.cbw.CB[0]); - switch (usbd_msc_cfg.cbw.CB[0]) { + USB_LOG_DBG("Decode CB:0x%02x\r\n", g_usbd_msc.cbw.CB[0]); + switch (g_usbd_msc.cbw.CB[0]) { case SCSI_CMD_TESTUNITREADY: ret = SCSI_testUnitReady(&buf2send, &len2send); break; @@ -730,13 +730,13 @@ static bool SCSI_CBWDecode(uint32_t nbytes) default: SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); - USB_LOG_WRN("unsupported cmd:0x%02x\r\n", usbd_msc_cfg.cbw.CB[0]); + USB_LOG_WRN("unsupported cmd:0x%02x\r\n", g_usbd_msc.cbw.CB[0]); ret = false; break; } } if (ret) { - if (usbd_msc_cfg.stage == MSC_READ_CBW) { + if (g_usbd_msc.stage == MSC_READ_CBW) { if (len2send) { USB_LOG_DBG("Send info len:%d\r\n", len2send); usbd_msc_send_info(buf2send, len2send); @@ -750,16 +750,16 @@ static bool SCSI_CBWDecode(uint32_t nbytes) void mass_storage_bulk_out(uint8_t ep, uint32_t nbytes) { - switch (usbd_msc_cfg.stage) { + switch (g_usbd_msc.stage) { case MSC_READ_CBW: if (SCSI_CBWDecode(nbytes) == false) { - USB_LOG_ERR("Command:0x%02x decode err\r\n", usbd_msc_cfg.cbw.CB[0]); + USB_LOG_ERR("Command:0x%02x decode err\r\n", g_usbd_msc.cbw.CB[0]); usbd_msc_bot_abort(); return; } break; case MSC_DATA_OUT: - switch (usbd_msc_cfg.cbw.CB[0]) { + switch (g_usbd_msc.cbw.CB[0]) { case SCSI_CMD_WRITE10: case SCSI_CMD_WRITE12: if (SCSI_processWrite(nbytes) == false) { @@ -777,9 +777,9 @@ void mass_storage_bulk_out(uint8_t ep, uint32_t nbytes) void mass_storage_bulk_in(uint8_t ep, uint32_t nbytes) { - switch (usbd_msc_cfg.stage) { + switch (g_usbd_msc.stage) { case MSC_DATA_IN: - switch (usbd_msc_cfg.cbw.CB[0]) { + switch (g_usbd_msc.cbw.CB[0]) { case SCSI_CMD_READ10: case SCSI_CMD_READ12: if (SCSI_processRead() == false) { @@ -798,9 +798,9 @@ void mass_storage_bulk_in(uint8_t ep, uint32_t nbytes) /*the host has received the CSW*/ case MSC_WAIT_CSW: - usbd_msc_cfg.stage = MSC_READ_CBW; + g_usbd_msc.stage = MSC_READ_CBW; USB_LOG_DBG("Start reading cbw\r\n"); - usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, (uint8_t *)&usbd_msc_cfg.cbw, USB_SIZEOF_MSC_CBW); + usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, (uint8_t *)&g_usbd_msc.cbw, USB_SIZEOF_MSC_CBW); break; default: @@ -823,11 +823,11 @@ struct usbd_interface *usbd_msc_init_intf(struct usbd_interface *intf, const uin usbd_add_endpoint(&mass_ep_data[MSD_OUT_EP_IDX]); usbd_add_endpoint(&mass_ep_data[MSD_IN_EP_IDX]); - memset((uint8_t *)&usbd_msc_cfg, 0, sizeof(struct usbd_msc_cfg_priv)); + memset((uint8_t *)&g_usbd_msc, 0, sizeof(struct usbd_msc_priv)); - usbd_msc_get_cap(0, &usbd_msc_cfg.scsi_blk_nbr, &usbd_msc_cfg.scsi_blk_size); + usbd_msc_get_cap(0, &g_usbd_msc.scsi_blk_nbr, &g_usbd_msc.scsi_blk_size); - if (usbd_msc_cfg.scsi_blk_size > CONFIG_USBDEV_MSC_BLOCK_SIZE) { + if (g_usbd_msc.scsi_blk_size > CONFIG_USBDEV_MSC_BLOCK_SIZE) { USB_LOG_ERR("msc block buffer overflow\r\n"); return NULL; } @@ -837,5 +837,5 @@ struct usbd_interface *usbd_msc_init_intf(struct usbd_interface *intf, const uin void usbd_msc_set_readonly(bool readonly) { - usbd_msc_cfg.readonly = readonly; + g_usbd_msc.readonly = readonly; } \ No newline at end of file diff --git a/class/mtp/usbd_mtp.c b/class/mtp/usbd_mtp.c index adc3e526..0d1c55c0 100644 --- a/class/mtp/usbd_mtp.c +++ b/class/mtp/usbd_mtp.c @@ -16,7 +16,7 @@ enum Stage { MTP_WAIT_RESPONSE = 4, }; -USB_NOCACHE_RAM_SECTION struct usbd_mtp { +USB_NOCACHE_RAM_SECTION struct usbd_mtp_priv { USB_MEM_ALIGNX struct mtp_container_command con_command; USB_MEM_ALIGNX struct mtp_container_data con_data; USB_MEM_ALIGNX struct mtp_container_response con_response; diff --git a/class/printer/usbd_printer.c b/class/printer/usbd_printer.c index ba147425..32f1ffe4 100644 --- a/class/printer/usbd_printer.c +++ b/class/printer/usbd_printer.c @@ -6,11 +6,11 @@ #include "usbd_core.h" #include "usbd_printer.h" -struct printer_cfg_priv { +struct usbd_printer_priv { const uint8_t *device_id; uint8_t device_id_len; uint8_t port_status; -} usbd_printer_cfg; +} g_usbd_printer; static int printer_class_interface_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { @@ -20,8 +20,8 @@ static int printer_class_interface_request_handler(struct usb_setup_packet *setu switch (setup->bRequest) { case PRINTER_REQUEST_GET_DEVICE_ID: - memcpy(*data, usbd_printer_cfg.device_id, usbd_printer_cfg.device_id_len); - *len = usbd_printer_cfg.device_id_len; + memcpy(*data, g_usbd_printer.device_id, g_usbd_printer.device_id_len); + *len = g_usbd_printer.device_id_len; break; case PRINTER_REQUEST_GET_PORT_SATTUS: @@ -55,7 +55,7 @@ struct usbd_interface *usbd_printer_init_intf(struct usbd_interface *intf, const intf->vendor_handler = NULL; intf->notify_handler = printer_notify_handler; - usbd_printer_cfg.device_id = device_id; - usbd_printer_cfg.device_id_len = device_id_len; + g_usbd_printer.device_id = device_id; + g_usbd_printer.device_id_len = device_id_len; return intf; } diff --git a/class/video/usbd_video.c b/class/video/usbd_video.c index 62982d20..e8330627 100644 --- a/class/video/usbd_video.c +++ b/class/video/usbd_video.c @@ -12,17 +12,13 @@ struct video_entity_info { uint16_t wTerminalType; }; -struct usbd_video_cfg_priv { +struct usbd_video_priv { struct video_probe_and_commit_controls probe; struct video_probe_and_commit_controls commit; uint8_t power_mode; uint8_t error_code; struct video_entity_info info[3]; -} usbd_video_cfg = { - .info[0] = { .bDescriptorSubtype = VIDEO_VC_INPUT_TERMINAL_DESCRIPTOR_SUBTYPE, .bEntityId = 0x01, .wTerminalType = VIDEO_ITT_CAMERA }, - .info[1] = { .bDescriptorSubtype = VIDEO_VC_OUTPUT_TERMINAL_DESCRIPTOR_SUBTYPE, .bEntityId = 0x03, .wTerminalType = 0x00 }, - .info[2] = { .bDescriptorSubtype = VIDEO_VC_PROCESSING_UNIT_DESCRIPTOR_SUBTYPE, .bEntityId = 0x02, .wTerminalType = 0x00 }, -}; +} g_usbd_video; static int usbd_video_control_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { @@ -70,7 +66,7 @@ static int usbd_video_control_unit_terminal_request_handler(struct usb_setup_pac uint8_t control_selector = (uint8_t)(setup->wValue >> 8); for (uint8_t i = 0; i < 3; i++) { - struct video_entity_info *entity_info = &usbd_video_cfg.info[i]; + struct video_entity_info *entity_info = &g_usbd_video.info[i]; if (entity_info->bEntityId == entity_id) { switch (entity_info->bDescriptorSubtype) { case VIDEO_VC_HEADER_DESCRIPTOR_SUBTYPE: @@ -550,7 +546,7 @@ static int usbd_video_control_unit_terminal_request_handler(struct usb_setup_pac } break; default: - usbd_video_cfg.error_code = 0x06; + g_usbd_video.error_code = 0x06; USB_LOG_WRN("Unhandled Video Class control selector 0x%02x\r\n", control_selector); return -1; } @@ -576,10 +572,10 @@ static int usbd_video_stream_request_handler(struct usb_setup_packet *setup, uin case VIDEO_VS_PROBE_CONTROL: switch (setup->bRequest) { case VIDEO_REQUEST_SET_CUR: - //memcpy((uint8_t *)&usbd_video_cfg.probe, *data, setup->wLength); + //memcpy((uint8_t *)&g_usbd_video.probe, *data, setup->wLength); break; case VIDEO_REQUEST_GET_CUR: - memcpy(*data, (uint8_t *)&usbd_video_cfg.probe, setup->wLength); + memcpy(*data, (uint8_t *)&g_usbd_video.probe, setup->wLength); *len = sizeof(struct video_probe_and_commit_controls); break; @@ -587,7 +583,7 @@ static int usbd_video_stream_request_handler(struct usb_setup_packet *setup, uin case VIDEO_REQUEST_GET_MAX: case VIDEO_REQUEST_GET_RES: case VIDEO_REQUEST_GET_DEF: - memcpy(*data, (uint8_t *)&usbd_video_cfg.probe, setup->wLength); + memcpy(*data, (uint8_t *)&g_usbd_video.probe, setup->wLength); *len = sizeof(struct video_probe_and_commit_controls); break; case VIDEO_REQUEST_GET_LEN: @@ -608,17 +604,17 @@ static int usbd_video_stream_request_handler(struct usb_setup_packet *setup, uin case VIDEO_VS_COMMIT_CONTROL: switch (setup->bRequest) { case VIDEO_REQUEST_SET_CUR: - //memcpy((uint8_t *)&usbd_video_cfg.commit, *data, setup->wLength); + //memcpy((uint8_t *)&g_usbd_video.commit, *data, setup->wLength); break; case VIDEO_REQUEST_GET_CUR: - memcpy(*data, (uint8_t *)&usbd_video_cfg.commit, setup->wLength); + memcpy(*data, (uint8_t *)&g_usbd_video.commit, setup->wLength); *len = sizeof(struct video_probe_and_commit_controls); break; case VIDEO_REQUEST_GET_MIN: case VIDEO_REQUEST_GET_MAX: case VIDEO_REQUEST_GET_RES: case VIDEO_REQUEST_GET_DEF: - memcpy(*data, (uint8_t *)&usbd_video_cfg.commit, setup->wLength); + memcpy(*data, (uint8_t *)&g_usbd_video.commit, setup->wLength); *len = sizeof(struct video_probe_and_commit_controls); break; @@ -640,7 +636,7 @@ static int usbd_video_stream_request_handler(struct usb_setup_packet *setup, uin case VIDEO_VS_STREAM_ERROR_CODE_CONTROL: switch (setup->bRequest) { case VIDEO_REQUEST_GET_CUR: - (*data)[0] = usbd_video_cfg.error_code; + (*data)[0] = g_usbd_video.error_code; *len = 1; break; case VIDEO_REQUEST_GET_INFO: @@ -684,8 +680,8 @@ static void video_notify_handler(uint8_t event, void *arg) { switch (event) { case USBD_EVENT_RESET: - usbd_video_cfg.error_code = 0; - usbd_video_cfg.power_mode = 0; + g_usbd_video.error_code = 0; + g_usbd_video.power_mode = 0; break; case USBD_EVENT_SET_INTERFACE: { @@ -705,41 +701,41 @@ static void video_notify_handler(uint8_t event, void *arg) void usbd_video_probe_and_commit_controls_init(uint32_t dwFrameInterval, uint32_t dwMaxVideoFrameSize, uint32_t dwMaxPayloadTransferSize) { - usbd_video_cfg.probe.hintUnion.bmHint = 0x01; - usbd_video_cfg.probe.hintUnion1.bmHint = 0; - usbd_video_cfg.probe.bFormatIndex = 1; - usbd_video_cfg.probe.bFrameIndex = 1; - usbd_video_cfg.probe.dwFrameInterval = dwFrameInterval; - usbd_video_cfg.probe.wKeyFrameRate = 0; - usbd_video_cfg.probe.wPFrameRate = 0; - usbd_video_cfg.probe.wCompQuality = 0; - usbd_video_cfg.probe.wCompWindowSize = 0; - usbd_video_cfg.probe.wDelay = 0; - usbd_video_cfg.probe.dwMaxVideoFrameSize = dwMaxVideoFrameSize; - usbd_video_cfg.probe.dwMaxPayloadTransferSize = dwMaxPayloadTransferSize; - usbd_video_cfg.probe.dwClockFrequency = 0; - usbd_video_cfg.probe.bmFramingInfo = 0; - usbd_video_cfg.probe.bPreferedVersion = 0; - usbd_video_cfg.probe.bMinVersion = 0; - usbd_video_cfg.probe.bMaxVersion = 0; + g_usbd_video.probe.hintUnion.bmHint = 0x01; + g_usbd_video.probe.hintUnion1.bmHint = 0; + g_usbd_video.probe.bFormatIndex = 1; + g_usbd_video.probe.bFrameIndex = 1; + g_usbd_video.probe.dwFrameInterval = dwFrameInterval; + g_usbd_video.probe.wKeyFrameRate = 0; + g_usbd_video.probe.wPFrameRate = 0; + g_usbd_video.probe.wCompQuality = 0; + g_usbd_video.probe.wCompWindowSize = 0; + g_usbd_video.probe.wDelay = 0; + g_usbd_video.probe.dwMaxVideoFrameSize = dwMaxVideoFrameSize; + g_usbd_video.probe.dwMaxPayloadTransferSize = dwMaxPayloadTransferSize; + g_usbd_video.probe.dwClockFrequency = 0; + g_usbd_video.probe.bmFramingInfo = 0; + g_usbd_video.probe.bPreferedVersion = 0; + g_usbd_video.probe.bMinVersion = 0; + g_usbd_video.probe.bMaxVersion = 0; - usbd_video_cfg.commit.hintUnion.bmHint = 0x01; - usbd_video_cfg.commit.hintUnion1.bmHint = 0; - usbd_video_cfg.commit.bFormatIndex = 1; - usbd_video_cfg.commit.bFrameIndex = 1; - usbd_video_cfg.commit.dwFrameInterval = dwFrameInterval; - usbd_video_cfg.commit.wKeyFrameRate = 0; - usbd_video_cfg.commit.wPFrameRate = 0; - usbd_video_cfg.commit.wCompQuality = 0; - usbd_video_cfg.commit.wCompWindowSize = 0; - usbd_video_cfg.commit.wDelay = 0; - usbd_video_cfg.commit.dwMaxVideoFrameSize = dwMaxVideoFrameSize; - usbd_video_cfg.commit.dwMaxPayloadTransferSize = dwMaxPayloadTransferSize; - usbd_video_cfg.commit.dwClockFrequency = 0; - usbd_video_cfg.commit.bmFramingInfo = 0; - usbd_video_cfg.commit.bPreferedVersion = 0; - usbd_video_cfg.commit.bMinVersion = 0; - usbd_video_cfg.commit.bMaxVersion = 0; + g_usbd_video.commit.hintUnion.bmHint = 0x01; + g_usbd_video.commit.hintUnion1.bmHint = 0; + g_usbd_video.commit.bFormatIndex = 1; + g_usbd_video.commit.bFrameIndex = 1; + g_usbd_video.commit.dwFrameInterval = dwFrameInterval; + g_usbd_video.commit.wKeyFrameRate = 0; + g_usbd_video.commit.wPFrameRate = 0; + g_usbd_video.commit.wCompQuality = 0; + g_usbd_video.commit.wCompWindowSize = 0; + g_usbd_video.commit.wDelay = 0; + g_usbd_video.commit.dwMaxVideoFrameSize = dwMaxVideoFrameSize; + g_usbd_video.commit.dwMaxPayloadTransferSize = dwMaxPayloadTransferSize; + g_usbd_video.commit.dwClockFrequency = 0; + g_usbd_video.commit.bmFramingInfo = 0; + g_usbd_video.commit.bPreferedVersion = 0; + g_usbd_video.commit.bMinVersion = 0; + g_usbd_video.commit.bMaxVersion = 0; } struct usbd_interface *usbd_video_init_intf(struct usbd_interface *intf, @@ -752,6 +748,16 @@ struct usbd_interface *usbd_video_init_intf(struct usbd_interface *intf, intf->vendor_handler = NULL; intf->notify_handler = video_notify_handler; + g_usbd_video.info[0].bDescriptorSubtype = VIDEO_VC_INPUT_TERMINAL_DESCRIPTOR_SUBTYPE; + g_usbd_video.info[0].bEntityId = 0x01; + g_usbd_video.info[0].wTerminalType = VIDEO_ITT_CAMERA; + g_usbd_video.info[1].bDescriptorSubtype = VIDEO_VC_OUTPUT_TERMINAL_DESCRIPTOR_SUBTYPE; + g_usbd_video.info[1].bEntityId = 0x03; + g_usbd_video.info[1].wTerminalType = 0x00; + g_usbd_video.info[2].bDescriptorSubtype = VIDEO_VC_PROCESSING_UNIT_DESCRIPTOR_SUBTYPE; + g_usbd_video.info[2].bEntityId = 0x02; + g_usbd_video.info[2].wTerminalType = 0x00; + usbd_video_probe_and_commit_controls_init(dwFrameInterval, dwMaxVideoFrameSize, dwMaxPayloadTransferSize); return intf; } @@ -763,18 +769,18 @@ uint32_t usbd_video_mjpeg_payload_fill(uint8_t *input, uint32_t input_len, uint8 uint32_t picture_pos = 0; static uint8_t uvc_header[2] = { 0x02, 0x80 }; - packets = input_len / usbd_video_cfg.probe.dwMaxPayloadTransferSize + 1; - last_packet_size = input_len - ((packets - 1) * (usbd_video_cfg.probe.dwMaxPayloadTransferSize - 2)) + 2; + packets = input_len / g_usbd_video.probe.dwMaxPayloadTransferSize + 1; + last_packet_size = input_len - ((packets - 1) * (g_usbd_video.probe.dwMaxPayloadTransferSize - 2)) + 2; for (size_t i = 0; i < packets; i++) { - output[usbd_video_cfg.probe.dwMaxPayloadTransferSize * i] = uvc_header[0]; - output[usbd_video_cfg.probe.dwMaxPayloadTransferSize * i + 1] = uvc_header[1]; + output[g_usbd_video.probe.dwMaxPayloadTransferSize * i] = uvc_header[0]; + output[g_usbd_video.probe.dwMaxPayloadTransferSize * i + 1] = uvc_header[1]; if (i == (packets - 1)) { - memcpy(&output[2 + usbd_video_cfg.probe.dwMaxPayloadTransferSize * i], &input[picture_pos], last_packet_size - 2); - output[usbd_video_cfg.probe.dwMaxPayloadTransferSize * i + 1] |= (1 << 1); + memcpy(&output[2 + g_usbd_video.probe.dwMaxPayloadTransferSize * i], &input[picture_pos], last_packet_size - 2); + output[g_usbd_video.probe.dwMaxPayloadTransferSize * i + 1] |= (1 << 1); } else { - memcpy(&output[2 + usbd_video_cfg.probe.dwMaxPayloadTransferSize * i], &input[picture_pos], usbd_video_cfg.probe.dwMaxPayloadTransferSize - 2); - picture_pos += usbd_video_cfg.probe.dwMaxPayloadTransferSize - 2; + memcpy(&output[2 + g_usbd_video.probe.dwMaxPayloadTransferSize * i], &input[picture_pos], g_usbd_video.probe.dwMaxPayloadTransferSize - 2); + picture_pos += g_usbd_video.probe.dwMaxPayloadTransferSize - 2; } } uvc_header[1] ^= 1; diff --git a/class/wireless/usbd_rndis.c b/class/wireless/usbd_rndis.c index 5d89338c..482cc571 100644 --- a/class/wireless/usbd_rndis.c +++ b/class/wireless/usbd_rndis.c @@ -30,7 +30,7 @@ static struct usbd_endpoint rndis_ep_data[3]; #endif /* Device data structure */ -struct usbd_rndis_cfg_priv { +struct usbd_rndis_priv { uint32_t drv_version; uint32_t link_status; uint32_t speed; @@ -38,11 +38,7 @@ struct usbd_rndis_cfg_priv { usb_eth_stat_t eth_state; rndis_state_t init_state; uint8_t mac[6]; -} usbd_rndis_cfg = { .drv_version = 0x0001, - .link_status = NDIS_MEDIA_STATE_DISCONNECTED, - .speed = RNDIS_LINK_SPEED, - .init_state = rndis_uninitialized, - .mac = { 0x00, 0x00, 0x5E, 0x00, 0x53, 0x01 } }; +} g_usbd_rndis; USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t g_rndis_rx_buffer[CONFIG_USBDEV_RNDIS_ETH_MAX_FRAME_SIZE + 44]; USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t g_rndis_tx_buffer[CONFIG_USBDEV_RNDIS_ETH_MAX_FRAME_SIZE + 44]; @@ -174,7 +170,7 @@ static int rndis_init_cmd_handler(uint8_t *data, uint32_t len) resp->AfListOffset = 0; resp->AfListSize = 0; - usbd_rndis_cfg.init_state = rndis_initialized; + g_usbd_rndis.init_state = rndis_initialized; rndis_notify_rsp(); return 0; @@ -187,7 +183,7 @@ static int rndis_halt_cmd_handler(uint8_t *data, uint32_t len) resp = ((rndis_halt_msg_t *)rndis_encapsulated_resp_buffer); resp->MessageLength = 0; - usbd_rndis_cfg.init_state = rndis_uninitialized; + g_usbd_rndis.init_state = rndis_uninitialized; return 0; } @@ -241,7 +237,7 @@ static int rndis_query_cmd_handler(uint8_t *data, uint32_t len) break; case OID_802_3_CURRENT_ADDRESS: case OID_802_3_PERMANENT_ADDRESS: - RNDIS_INQUIRY_PUT(usbd_rndis_cfg.mac, 6); + RNDIS_INQUIRY_PUT(g_usbd_rndis.mac, 6); infomation_len = 6; break; case OID_GEN_PHYSICAL_MEDIUM: @@ -253,7 +249,7 @@ static int rndis_query_cmd_handler(uint8_t *data, uint32_t len) infomation_len = 4; break; case OID_GEN_CURRENT_PACKET_FILTER: - RNDIS_INQUIRY_PUT_LE32(usbd_rndis_cfg.net_filter); + RNDIS_INQUIRY_PUT_LE32(g_usbd_rndis.net_filter); infomation_len = 4; break; case OID_GEN_MAXIMUM_TOTAL_SIZE: @@ -261,7 +257,7 @@ static int rndis_query_cmd_handler(uint8_t *data, uint32_t len) infomation_len = 4; break; case OID_GEN_MEDIA_CONNECT_STATUS: - RNDIS_INQUIRY_PUT_LE32(usbd_rndis_cfg.link_status); + RNDIS_INQUIRY_PUT_LE32(g_usbd_rndis.link_status); infomation_len = 4; break; case OID_GEN_RNDIS_CONFIG_PARAMETER: @@ -301,19 +297,19 @@ static int rndis_query_cmd_handler(uint8_t *data, uint32_t len) infomation_len = 4; break; case OID_GEN_XMIT_OK: - RNDIS_INQUIRY_PUT_LE32(usbd_rndis_cfg.eth_state.txok); + RNDIS_INQUIRY_PUT_LE32(g_usbd_rndis.eth_state.txok); infomation_len = 4; break; case OID_GEN_RCV_OK: - RNDIS_INQUIRY_PUT_LE32(usbd_rndis_cfg.eth_state.rxok); + RNDIS_INQUIRY_PUT_LE32(g_usbd_rndis.eth_state.rxok); infomation_len = 4; break; case OID_GEN_RCV_ERROR: - RNDIS_INQUIRY_PUT_LE32(usbd_rndis_cfg.eth_state.rxbad); + RNDIS_INQUIRY_PUT_LE32(g_usbd_rndis.eth_state.rxbad); infomation_len = 4; break; case OID_GEN_XMIT_ERROR: - RNDIS_INQUIRY_PUT_LE32(usbd_rndis_cfg.eth_state.txbad); + RNDIS_INQUIRY_PUT_LE32(g_usbd_rndis.eth_state.txbad); infomation_len = 4; break; case OID_GEN_RCV_NO_BUFFER: @@ -354,7 +350,7 @@ static int rndis_set_cmd_handler(uint8_t *data, uint32_t len) param->ParameterValueOffset, param->ParameterValueLength); break; case OID_GEN_CURRENT_PACKET_FILTER: - if (cmd->InformationBufferLength < sizeof(usbd_rndis_cfg.net_filter)) { + if (cmd->InformationBufferLength < sizeof(g_usbd_rndis.net_filter)) { USB_LOG_WRN("PACKET_FILTER!\r\n"); resp->Status = RNDIS_STATUS_INVALID_DATA; } else { @@ -362,12 +358,12 @@ static int rndis_set_cmd_handler(uint8_t *data, uint32_t len) /* Parameter starts at offset buf_offset of the req_id field */ filter = (uint32_t *)((uint8_t *)&(cmd->RequestId) + cmd->InformationBufferOffset); - //usbd_rndis_cfg.net_filter = param->ParameterNameOffset; - usbd_rndis_cfg.net_filter = *(uint32_t *)filter; - if (usbd_rndis_cfg.net_filter) { - usbd_rndis_cfg.init_state = rndis_data_initialized; + //g_usbd_rndis.net_filter = param->ParameterNameOffset; + g_usbd_rndis.net_filter = *(uint32_t *)filter; + if (g_usbd_rndis.net_filter) { + g_usbd_rndis.init_state = rndis_data_initialized; } else { - usbd_rndis_cfg.init_state = rndis_initialized; + g_usbd_rndis.init_state = rndis_initialized; } } break; @@ -402,7 +398,7 @@ static int rndis_reset_cmd_handler(uint8_t *data, uint32_t len) resp->Status = RNDIS_STATUS_SUCCESS; resp->AddressingReset = 1; - usbd_rndis_cfg.init_state = rndis_uninitialized; + g_usbd_rndis.init_state = rndis_uninitialized; rndis_notify_rsp(); @@ -429,12 +425,12 @@ static void rndis_notify_handler(uint8_t event, void *arg) { switch (event) { case USBD_EVENT_RESET: - usbd_rndis_cfg.link_status = NDIS_MEDIA_STATE_DISCONNECTED; + g_usbd_rndis.link_status = NDIS_MEDIA_STATE_DISCONNECTED; break; case USBD_EVENT_CONFIGURED: g_rndis_rx_data_length = 0; g_rndis_tx_data_length = 0; - usbd_rndis_cfg.link_status = NDIS_MEDIA_STATE_CONNECTED; + g_usbd_rndis.link_status = NDIS_MEDIA_STATE_CONNECTED; usbd_ep_start_read(rndis_ep_data[RNDIS_OUT_EP_IDX].ep_addr, g_rndis_rx_buffer, sizeof(g_rndis_rx_buffer)); break; @@ -458,7 +454,7 @@ void rndis_bulk_out(uint8_t ep, uint32_t nbytes) g_rndis_rx_data_buffer += hdr->DataOffset + sizeof(rndis_generic_msg_t); g_rndis_rx_data_length = hdr->DataLength; - usbd_rndis_data_recv((uint8_t *)g_rndis_rx_data_buffer, g_rndis_rx_data_length); + usbd_rndis_data_recv_done(); } void rndis_bulk_in(uint8_t ep, uint32_t nbytes) @@ -506,7 +502,7 @@ int usbd_rndis_eth_tx(struct pbuf *p) uint8_t *buffer; rndis_data_packet_t *hdr; - if (usbd_rndis_cfg.link_status == NDIS_MEDIA_STATE_DISCONNECTED) { + if (g_usbd_rndis.link_status == NDIS_MEDIA_STATE_DISCONNECTED) { return 0; } @@ -543,7 +539,11 @@ struct usbd_interface *usbd_rndis_init_intf(struct usbd_interface *intf, const uint8_t in_ep, const uint8_t int_ep, uint8_t mac[6]) { - memcpy(usbd_rndis_cfg.mac, mac, 6); + memcpy(g_usbd_rndis.mac, mac, 6); + + g_usbd_rndis.drv_version = 0x0001; + g_usbd_rndis.link_status = NDIS_MEDIA_STATE_DISCONNECTED; + g_usbd_rndis.speed = RNDIS_LINK_SPEED; rndis_ep_data[RNDIS_OUT_EP_IDX].ep_addr = out_ep; rndis_ep_data[RNDIS_OUT_EP_IDX].ep_cb = rndis_bulk_out; diff --git a/class/wireless/usbd_rndis.h b/class/wireless/usbd_rndis.h index d9f9f646..8a9581f6 100644 --- a/class/wireless/usbd_rndis.h +++ b/class/wireless/usbd_rndis.h @@ -18,6 +18,8 @@ struct usbd_interface *usbd_rndis_init_intf(struct usbd_interface *intf, const uint8_t in_ep, const uint8_t int_ep, uint8_t mac[6]); +void usbd_rndis_data_recv_done(void); + #ifdef CONFIG_USBDEV_RNDIS_USING_LWIP struct pbuf *usbd_rndis_eth_rx(void); int usbd_rndis_eth_tx(struct pbuf *p); diff --git a/core/usbd_core.c b/core/usbd_core.c index 9fc05ec2..64a4ead5 100644 --- a/core/usbd_core.c +++ b/core/usbd_core.c @@ -32,7 +32,7 @@ struct usbd_tx_rx_msg { usbd_endpoint_callback cb; }; -USB_NOCACHE_RAM_SECTION struct usbd_core_cfg_priv { +USB_NOCACHE_RAM_SECTION struct usbd_core_priv { /** Setup packet */ USB_MEM_ALIGNX struct usb_setup_packet setup; /** Pointer to data buffer */ @@ -45,33 +45,31 @@ USB_NOCACHE_RAM_SECTION struct usbd_core_cfg_priv { bool zlp_flag; /** Pointer to registered descriptors */ #ifdef CONFIG_USBDEV_ADVANCE_DESC - struct usb_descriptor *descriptors; + const struct usb_descriptor *descriptors; #else const uint8_t *descriptors; #endif + struct usb_msosv1_descriptor *msosv1_desc; + struct usb_msosv2_descriptor *msosv2_desc; + struct usb_bos_descriptor *bos_desc; /* Buffer used for storing standard, class and vendor request data */ USB_MEM_ALIGNX uint8_t req_data[CONFIG_USBDEV_REQUEST_BUFFER_LEN]; - /** Variable to check whether the usb has been configured */ - bool configured; /** Currently selected configuration */ uint8_t configuration; uint8_t speed; #ifdef CONFIG_USBDEV_TEST_MODE bool test_mode; #endif + struct usbd_interface *intf[8]; uint8_t intf_offset; -} usbd_core_cfg; + + struct usbd_tx_rx_msg tx_msg[USB_EP_IN_NUM]; + struct usbd_tx_rx_msg rx_msg[USB_EP_OUT_NUM]; +} g_usbd_core; usb_slist_t usbd_intf_head = USB_SLIST_OBJECT_INIT(usbd_intf_head); -static struct usb_msosv1_descriptor *msosv1_desc; -static struct usb_msosv2_descriptor *msosv2_desc; -static struct usb_bos_descriptor *bos_desc; - -struct usbd_tx_rx_msg tx_msg[USB_EP_IN_NUM]; -struct usbd_tx_rx_msg rx_msg[USB_EP_OUT_NUM]; - #if defined(CONFIG_USBDEV_TX_THREAD) usb_osal_mq_t usbd_tx_mq; usb_osal_thread_t usbd_tx_thread; @@ -96,7 +94,7 @@ static void usbd_print_setup(struct usb_setup_packet *setup) static bool is_device_configured(void) { - return (usbd_core_cfg.configuration != 0); + return (g_usbd_core.configuration != 0); } /** @@ -171,24 +169,24 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l switch (type) { case USB_DESCRIPTOR_TYPE_DEVICE: - *data = (uint8_t *)usbd_core_cfg.descriptors->device_descriptor; - *len = usbd_core_cfg.descriptors->device_descriptor[0]; + *data = (uint8_t *)g_usbd_core.descriptors->device_descriptor; + *len = g_usbd_core.descriptors->device_descriptor[0]; break; case USB_DESCRIPTOR_TYPE_CONFIGURATION: - usbd_core_cfg.speed = usbd_get_port_speed(0); - if (usbd_core_cfg.speed == USB_SPEED_HIGH) { - if (usbd_core_cfg.descriptors->hs_config_descriptor) { - *data = (uint8_t *)usbd_core_cfg.descriptors->hs_config_descriptor; - *len = (usbd_core_cfg.descriptors->hs_config_descriptor[CONF_DESC_wTotalLength] | - (usbd_core_cfg.descriptors->hs_config_descriptor[CONF_DESC_wTotalLength + 1] << 8)); + g_usbd_core.speed = usbd_get_port_speed(0); + if (g_usbd_core.speed == USB_SPEED_HIGH) { + if (g_usbd_core.descriptors->hs_config_descriptor) { + *data = (uint8_t *)g_usbd_core.descriptors->hs_config_descriptor; + *len = (g_usbd_core.descriptors->hs_config_descriptor[CONF_DESC_wTotalLength] | + (g_usbd_core.descriptors->hs_config_descriptor[CONF_DESC_wTotalLength + 1] << 8)); } else { found = false; } } else { - if (usbd_core_cfg.descriptors->fs_config_descriptor) { - *data = (uint8_t *)usbd_core_cfg.descriptors->fs_config_descriptor; - *len = (usbd_core_cfg.descriptors->fs_config_descriptor[CONF_DESC_wTotalLength] | - (usbd_core_cfg.descriptors->fs_config_descriptor[CONF_DESC_wTotalLength + 1] << 8)); + if (g_usbd_core.descriptors->fs_config_descriptor) { + *data = (uint8_t *)g_usbd_core.descriptors->fs_config_descriptor; + *len = (g_usbd_core.descriptors->fs_config_descriptor[CONF_DESC_wTotalLength] | + (g_usbd_core.descriptors->fs_config_descriptor[CONF_DESC_wTotalLength + 1] << 8)); } else { found = false; } @@ -203,20 +201,20 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l (*data)[3] = 0x04; *len = 4; } else if (index == USB_OSDESC_STRING_DESC_INDEX) { - if (usbd_core_cfg.descriptors->msosv1_descriptor) { + if (g_usbd_core.descriptors->msosv1_descriptor) { USB_LOG_INFO("read MS OS 1.0 descriptor string\r\n"); - *data = usbd_core_cfg.descriptors->msosv1_descriptor->string; - *len = usbd_core_cfg.descriptors->msosv1_descriptor->string_len; + *data = g_usbd_core.descriptors->msosv1_descriptor->string; + *len = g_usbd_core.descriptors->msosv1_descriptor->string_len; } else { } } else { - if (usbd_core_cfg.descriptors->string_descriptor[index - 1]) { - str_len = strlen((const char *)usbd_core_cfg.descriptors->string_descriptor[index - 1]); + if (g_usbd_core.descriptors->string_descriptor[index - 1]) { + str_len = strlen((const char *)g_usbd_core.descriptors->string_descriptor[index - 1]); (*data)[0] = str_len * 2 + 2; (*data)[1] = 0x03; for (uint16_t i = 0; i < str_len; i++) { - (*data)[i * 2 + 2] = usbd_core_cfg.descriptors->string_descriptor[index - 1][i]; + (*data)[i * 2 + 2] = g_usbd_core.descriptors->string_descriptor[index - 1][i]; (*data)[i * 2 + 3] = 0; } @@ -227,28 +225,28 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l } break; case USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER: - if (usbd_core_cfg.descriptors->device_quality_descriptor) { - *data = (uint8_t *)usbd_core_cfg.descriptors->device_quality_descriptor; - *len = usbd_core_cfg.descriptors->device_quality_descriptor[0]; + if (g_usbd_core.descriptors->device_quality_descriptor) { + *data = (uint8_t *)g_usbd_core.descriptors->device_quality_descriptor; + *len = g_usbd_core.descriptors->device_quality_descriptor[0]; } else { found = false; } break; case USB_DESCRIPTOR_TYPE_OTHER_SPEED: - if (usbd_core_cfg.speed == USB_SPEED_HIGH) { - if (usbd_core_cfg.descriptors->fs_other_speed_descriptor) { - *data = (uint8_t *)usbd_core_cfg.descriptors->fs_other_speed_descriptor; - *len = (usbd_core_cfg.descriptors->fs_other_speed_descriptor[CONF_DESC_wTotalLength] | - (usbd_core_cfg.descriptors->fs_other_speed_descriptor[CONF_DESC_wTotalLength] << 8)); + if (g_usbd_core.speed == USB_SPEED_HIGH) { + if (g_usbd_core.descriptors->fs_other_speed_descriptor) { + *data = (uint8_t *)g_usbd_core.descriptors->fs_other_speed_descriptor; + *len = (g_usbd_core.descriptors->fs_other_speed_descriptor[CONF_DESC_wTotalLength] | + (g_usbd_core.descriptors->fs_other_speed_descriptor[CONF_DESC_wTotalLength] << 8)); } else { found = false; } } else { - if (usbd_core_cfg.descriptors->hs_other_speed_descriptor) { - *data = (uint8_t *)usbd_core_cfg.descriptors->hs_other_speed_descriptor; - *len = (usbd_core_cfg.descriptors->hs_other_speed_descriptor[CONF_DESC_wTotalLength] | - (usbd_core_cfg.descriptors->hs_other_speed_descriptor[CONF_DESC_wTotalLength] << 8)); + if (g_usbd_core.descriptors->hs_other_speed_descriptor) { + *data = (uint8_t *)g_usbd_core.descriptors->hs_other_speed_descriptor; + *len = (g_usbd_core.descriptors->hs_other_speed_descriptor[CONF_DESC_wTotalLength] | + (g_usbd_core.descriptors->hs_other_speed_descriptor[CONF_DESC_wTotalLength] << 8)); } else { found = false; } @@ -285,25 +283,25 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l if ((type == USB_DESCRIPTOR_TYPE_STRING) && (index == USB_OSDESC_STRING_DESC_INDEX)) { USB_LOG_INFO("read MS OS 2.0 descriptor string\r\n"); - if (!msosv1_desc) { + if (!g_usbd_core.msosv1_desc) { return false; } - //*data = (uint8_t *)msosv1_desc->string; - memcpy(*data, (uint8_t *)msosv1_desc->string, msosv1_desc->string_len); - *len = msosv1_desc->string_len; + //*data = (uint8_t *)g_usbd_core.msosv1_desc->string; + memcpy(*data, (uint8_t *)g_usbd_core.msosv1_desc->string, g_usbd_core.msosv1_desc->string_len); + *len = g_usbd_core.msosv1_desc->string_len; return true; } else if (type == USB_DESCRIPTOR_TYPE_BINARY_OBJECT_STORE) { USB_LOG_INFO("read BOS descriptor string\r\n"); - if (!bos_desc) { + if (!g_usbd_core.bos_desc) { return false; } - //*data = bos_desc->string; - memcpy(*data, (uint8_t *)bos_desc->string, bos_desc->string_len); - *len = bos_desc->string_len; + //*data = g_usbd_core.bos_desc->string; + memcpy(*data, (uint8_t *)g_usbd_core.bos_desc->string, g_usbd_core.bos_desc->string_len); + *len = g_usbd_core.bos_desc->string_len; return true; } /* @@ -319,7 +317,7 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l return false; } - p = (uint8_t *)usbd_core_cfg.descriptors; + p = (uint8_t *)g_usbd_core.descriptors; cur_index = 0U; @@ -351,7 +349,7 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l memcpy(*data, p, *len); } else { /* nothing found */ - USB_LOG_ERR("descriptor not found!\r\n", type, index); + USB_LOG_ERR("descriptor not found!\r\n", type, index); } return found; @@ -377,13 +375,13 @@ static bool usbd_set_configuration(uint8_t config_index, uint8_t alt_setting) bool found = false; uint8_t *p; #ifdef CONFIG_USBDEV_ADVANCE_DESC - if (usbd_core_cfg.speed == USB_SPEED_HIGH) { - p = (uint8_t *)usbd_core_cfg.descriptors->hs_config_descriptor; + if (g_usbd_core.speed == USB_SPEED_HIGH) { + p = (uint8_t *)g_usbd_core.descriptors->hs_config_descriptor; } else { - p = (uint8_t *)usbd_core_cfg.descriptors->fs_config_descriptor; + p = (uint8_t *)g_usbd_core.descriptors->fs_config_descriptor; } #else - p = (uint8_t *)usbd_core_cfg.descriptors; + p = (uint8_t *)g_usbd_core.descriptors; #endif /* configure endpoints for this configuration/altsetting */ while (p[DESC_bLength] != 0U) { @@ -441,13 +439,13 @@ static bool usbd_set_interface(uint8_t iface, uint8_t alt_setting) bool ret = false; uint8_t *p; #ifdef CONFIG_USBDEV_ADVANCE_DESC - if (usbd_core_cfg.speed == USB_SPEED_HIGH) { - p = (uint8_t *)usbd_core_cfg.descriptors->hs_config_descriptor; + if (g_usbd_core.speed == USB_SPEED_HIGH) { + p = (uint8_t *)g_usbd_core.descriptors->hs_config_descriptor; } else { - p = (uint8_t *)usbd_core_cfg.descriptors->fs_config_descriptor; + p = (uint8_t *)g_usbd_core.descriptors->fs_config_descriptor; } #else - p = (uint8_t *)usbd_core_cfg.descriptors; + p = (uint8_t *)g_usbd_core.descriptors; #endif USB_LOG_DBG("iface %u alt_setting %u\r\n", iface, alt_setting); @@ -526,7 +524,7 @@ static bool usbd_std_device_req_handler(struct usb_setup_packet *setup, uint8_t } } else if (value == USB_FEATURE_TEST_MODE) { #ifdef CONFIG_USBDEV_TEST_MODE - usbd_core_cfg.test_mode = true; + g_usbd_core.test_mode = true; usbd_execute_test_mode(setup); #endif } @@ -547,7 +545,7 @@ static bool usbd_std_device_req_handler(struct usb_setup_packet *setup, uint8_t break; case USB_REQUEST_GET_CONFIGURATION: - *data = (uint8_t *)&usbd_core_cfg.configuration; + *data = (uint8_t *)&g_usbd_core.configuration; *len = 1; break; @@ -557,8 +555,7 @@ static bool usbd_std_device_req_handler(struct usb_setup_packet *setup, uint8_t if (!usbd_set_configuration(value, 0)) { ret = false; } else { - usbd_core_cfg.configuration = value; - usbd_core_cfg.configured = true; + g_usbd_core.configuration = value; usbd_class_event_notify_handler(USBD_EVENT_CONFIGURED, NULL); usbd_event_handler(USBD_EVENT_CONFIGURED); } @@ -609,13 +606,11 @@ static bool usbd_std_interface_req_handler(struct usb_setup_packet *setup, case USB_REQUEST_GET_DESCRIPTOR: if (type == 0x22) { /* HID_DESCRIPTOR_TYPE_HID_REPORT */ USB_LOG_INFO("read hid report descriptor\r\n"); - usb_slist_t *i; - usb_slist_for_each(i, &usbd_intf_head) - { - struct usbd_interface *intf = usb_slist_entry(i, struct usbd_interface, list); + for (uint8_t i = 0; i < g_usbd_core.intf_offset; i++) { + struct usbd_interface *intf = g_usbd_core.intf[i]; - if (intf->intf_num == intf_num) { + if (intf && (intf->intf_num == intf_num)) { //*data = (uint8_t *)intf->hid_report_descriptor; memcpy(*data, intf->hid_report_descriptor, intf->hid_report_descriptor_len); *len = intf->hid_report_descriptor_len; @@ -761,22 +756,19 @@ static int usbd_standard_request_handler(struct usb_setup_packet *setup, uint8_t */ static int usbd_class_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { - usb_slist_t *i; if ((setup->bmRequestType & USB_REQUEST_RECIPIENT_MASK) == USB_REQUEST_RECIPIENT_INTERFACE) { - usb_slist_for_each(i, &usbd_intf_head) - { - struct usbd_interface *intf = usb_slist_entry(i, struct usbd_interface, list); + for (uint8_t i = 0; i < g_usbd_core.intf_offset; i++) { + struct usbd_interface *intf = g_usbd_core.intf[i]; - if (intf->class_interface_handler && (intf->intf_num == (setup->wIndex & 0xFF))) { + if (intf && intf->class_interface_handler && (intf->intf_num == (setup->wIndex & 0xFF))) { return intf->class_interface_handler(setup, data, len); } } } else if ((setup->bmRequestType & USB_REQUEST_RECIPIENT_MASK) == USB_REQUEST_RECIPIENT_ENDPOINT) { - usb_slist_for_each(i, &usbd_intf_head) - { - struct usbd_interface *intf = usb_slist_entry(i, struct usbd_interface, list); + for (uint8_t i = 0; i < g_usbd_core.intf_offset; i++) { + struct usbd_interface *intf = g_usbd_core.intf[i]; - if (intf->class_endpoint_handler) { + if (intf && intf->class_endpoint_handler) { return intf->class_endpoint_handler(setup, data, len); } } @@ -798,44 +790,44 @@ static int usbd_class_request_handler(struct usb_setup_packet *setup, uint8_t ** static int usbd_vendor_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { #ifdef CONFIG_USBDEV_ADVANCE_DESC - if (usbd_core_cfg.descriptors->msosv1_descriptor) { - if (setup->bRequest == usbd_core_cfg.descriptors->msosv1_descriptor->vendor_code) { + if (g_usbd_core.descriptors->msosv1_descriptor) { + if (setup->bRequest == g_usbd_core.descriptors->msosv1_descriptor->vendor_code) { switch (setup->wIndex) { case 0x04: USB_LOG_INFO("get Compat ID\r\n"); - *data = (uint8_t *)usbd_core_cfg.descriptors->msosv1_descriptor->compat_id; - *len = usbd_core_cfg.descriptors->msosv1_descriptor->compat_id_len; + *data = (uint8_t *)g_usbd_core.descriptors->msosv1_descriptor->compat_id; + *len = g_usbd_core.descriptors->msosv1_descriptor->compat_id_len; return 0; case 0x05: USB_LOG_INFO("get Compat id properties\r\n"); - *data = (uint8_t *)usbd_core_cfg.descriptors->msosv1_descriptor->comp_id_property; - *len = usbd_core_cfg.descriptors->msosv1_descriptor->comp_id_property_len; + *data = (uint8_t *)g_usbd_core.descriptors->msosv1_descriptor->comp_id_property; + *len = g_usbd_core.descriptors->msosv1_descriptor->comp_id_property_len; return 0; default: USB_LOG_ERR("unknown vendor code\r\n"); return -1; } } - } else if (usbd_core_cfg.descriptors->msosv2_descriptor) { - if (setup->bRequest == usbd_core_cfg.descriptors->msosv2_descriptor->vendor_code) { + } else if (g_usbd_core.descriptors->msosv2_descriptor) { + if (setup->bRequest == g_usbd_core.descriptors->msosv2_descriptor->vendor_code) { switch (setup->wIndex) { case WINUSB_REQUEST_GET_DESCRIPTOR_SET: USB_LOG_INFO("GET MS OS 2.0 Descriptor\r\n"); - *data = (uint8_t *)usbd_core_cfg.descriptors->msosv2_descriptor->compat_id; - *len = usbd_core_cfg.descriptors->msosv2_descriptor->compat_id_len; + *data = (uint8_t *)g_usbd_core.descriptors->msosv2_descriptor->compat_id; + *len = g_usbd_core.descriptors->msosv2_descriptor->compat_id_len; return 0; default: USB_LOG_ERR("unknown vendor code\r\n"); return -1; } } - } else if (usbd_core_cfg.descriptors->webusb_url_descriptor) { - if (setup->bRequest == usbd_core_cfg.descriptors->webusb_url_descriptor->vendor_code) { + } else if (g_usbd_core.descriptors->webusb_url_descriptor) { + if (setup->bRequest == g_usbd_core.descriptors->webusb_url_descriptor->vendor_code) { switch (setup->wIndex) { case WINUSB_REQUEST_GET_DESCRIPTOR_SET: USB_LOG_INFO("GET Webusb url Descriptor\r\n"); - *data = (uint8_t *)usbd_core_cfg.descriptors->webusb_url_descriptor->string; - *len = usbd_core_cfg.descriptors->webusb_url_descriptor->string_len; + *data = (uint8_t *)g_usbd_core.descriptors->webusb_url_descriptor->string; + *len = g_usbd_core.descriptors->webusb_url_descriptor->string_len; return 0; default: USB_LOG_ERR("unknown vendor code\r\n"); @@ -844,21 +836,21 @@ static int usbd_vendor_request_handler(struct usb_setup_packet *setup, uint8_t * } } #else - if (msosv1_desc) { - if (setup->bRequest == msosv1_desc->vendor_code) { + if (g_usbd_core.msosv1_desc) { + if (setup->bRequest == g_usbd_core.msosv1_desc->vendor_code) { switch (setup->wIndex) { case 0x04: USB_LOG_INFO("get Compat ID\r\n"); //*data = (uint8_t *)msosv1_desc->compat_id; - memcpy(*data, msosv1_desc->compat_id, msosv1_desc->compat_id_len); - *len = msosv1_desc->compat_id_len; + memcpy(*data, g_usbd_core.msosv1_desc->compat_id, g_usbd_core.msosv1_desc->compat_id_len); + *len = g_usbd_core.msosv1_desc->compat_id_len; return 0; case 0x05: USB_LOG_INFO("get Compat id properties\r\n"); //*data = (uint8_t *)msosv1_desc->comp_id_property; - memcpy(*data, msosv1_desc->comp_id_property, msosv1_desc->comp_id_property_len); - *len = msosv1_desc->comp_id_property_len; + memcpy(*data, g_usbd_core.msosv1_desc->comp_id_property, g_usbd_core.msosv1_desc->comp_id_property_len); + *len = g_usbd_core.msosv1_desc->comp_id_property_len; return 0; default: @@ -866,14 +858,14 @@ static int usbd_vendor_request_handler(struct usb_setup_packet *setup, uint8_t * return -1; } } - } else if (msosv2_desc) { - if (setup->bRequest == msosv2_desc->vendor_code) { + } else if (g_usbd_core.msosv2_desc) { + if (setup->bRequest == g_usbd_core.msosv2_desc->vendor_code) { switch (setup->wIndex) { case WINUSB_REQUEST_GET_DESCRIPTOR_SET: USB_LOG_INFO("GET MS OS 2.0 Descriptor\r\n"); //*data = (uint8_t *)msosv2_desc->compat_id; - memcpy(*data, msosv2_desc->compat_id, msosv2_desc->compat_id_len); - *len = msosv2_desc->compat_id_len; + memcpy(*data, g_usbd_core.msosv2_desc->compat_id, g_usbd_core.msosv2_desc->compat_id_len); + *len = g_usbd_core.msosv2_desc->compat_id_len; return 0; default: USB_LOG_ERR("unknown vendor code\r\n"); @@ -882,13 +874,10 @@ static int usbd_vendor_request_handler(struct usb_setup_packet *setup, uint8_t * } } #endif - usb_slist_t *i; + for (uint8_t i = 0; i < g_usbd_core.intf_offset; i++) { + struct usbd_interface *intf = g_usbd_core.intf[i]; - usb_slist_for_each(i, &usbd_intf_head) - { - struct usbd_interface *intf = usb_slist_entry(i, struct usbd_interface, list); - - if (intf->vendor_handler && !intf->vendor_handler(setup, data, len)) { + if (intf && intf->vendor_handler && (intf->vendor_handler(setup, data, len) == 0)) { return 0; } } @@ -910,11 +899,20 @@ static bool usbd_setup_request_handler(struct usb_setup_packet *setup, uint8_t * switch (setup->bmRequestType & USB_REQUEST_TYPE_MASK) { case USB_REQUEST_STANDARD: if (usbd_standard_request_handler(setup, data, len) < 0) { +#ifdef CONFIG_USBDEV_ADVANCE_DESC + if (g_usbd_core.speed == USB_SPEED_FULL) { + if ((setup->bRequest == 0x06) && (setup->wValue == 0x0600)) { + USB_LOG_WRN("Ignore DQD in fs\r\n"); /* Device Qualifier Descriptor */ + return false; + } + } +#else #ifndef CONFIG_USB_HS if ((setup->bRequest == 0x06) && (setup->wValue == 0x0600)) { USB_LOG_WRN("Ignore DQD in fs\r\n"); /* Device Qualifier Descriptor */ return false; } +#endif #endif USB_LOG_ERR("standard request error\r\n"); usbd_print_setup(setup); @@ -945,18 +943,16 @@ static bool usbd_setup_request_handler(struct usb_setup_packet *setup, uint8_t * static void usbd_class_event_notify_handler(uint8_t event, void *arg) { - usb_slist_t *i; - usb_slist_for_each(i, &usbd_intf_head) - { - struct usbd_interface *intf = usb_slist_entry(i, struct usbd_interface, list); + for (uint8_t i = 0; i < g_usbd_core.intf_offset; i++) { + struct usbd_interface *intf = g_usbd_core.intf[i]; if (arg) { struct usb_interface_descriptor *desc = (struct usb_interface_descriptor *)arg; - if (intf->notify_handler && (desc->bInterfaceNumber == (intf->intf_num))) { + if (intf && intf->notify_handler && (desc->bInterfaceNumber == (intf->intf_num))) { intf->notify_handler(event, arg); } } else { - if (intf->notify_handler) { + if (intf && intf->notify_handler) { intf->notify_handler(event, arg); } } @@ -986,11 +982,10 @@ void usbd_event_suspend_handler(void) void usbd_event_reset_handler(void) { usbd_set_address(0); - usbd_core_cfg.configured = 0; - usbd_core_cfg.configuration = 0; + g_usbd_core.configuration = 0; #ifdef CONFIG_USBDEV_TEST_MODE - usbd_core_cfg.test_mode = false; + g_usbd_core.test_mode = false; #endif struct usbd_endpoint_cfg ep0_cfg; @@ -1008,7 +1003,7 @@ void usbd_event_reset_handler(void) void usbd_event_ep0_setup_complete_handler(uint8_t *psetup) { - struct usb_setup_packet *setup = &usbd_core_cfg.setup; + struct usb_setup_packet *setup = &g_usbd_core.setup; memcpy(setup, psetup, 8); #ifdef CONFIG_USBDEV_SETUP_LOG_PRINT @@ -1022,65 +1017,65 @@ void usbd_event_ep0_setup_complete_handler(uint8_t *psetup) } } - usbd_core_cfg.ep0_data_buf = usbd_core_cfg.req_data; - usbd_core_cfg.ep0_data_buf_residue = setup->wLength; - usbd_core_cfg.ep0_data_buf_len = setup->wLength; - usbd_core_cfg.zlp_flag = false; + g_usbd_core.ep0_data_buf = g_usbd_core.req_data; + g_usbd_core.ep0_data_buf_residue = setup->wLength; + g_usbd_core.ep0_data_buf_len = setup->wLength; + g_usbd_core.zlp_flag = false; /* handle class request when all the data is received */ if (setup->wLength && ((setup->bmRequestType & USB_REQUEST_DIR_MASK) == USB_REQUEST_DIR_OUT)) { USB_LOG_DBG("Start reading %d bytes from ep0\r\n", setup->wLength); - usbd_ep_start_read(USB_CONTROL_OUT_EP0, usbd_core_cfg.ep0_data_buf, setup->wLength); + usbd_ep_start_read(USB_CONTROL_OUT_EP0, g_usbd_core.ep0_data_buf, setup->wLength); return; } /* Ask installed handler to process request */ - if (!usbd_setup_request_handler(setup, &usbd_core_cfg.ep0_data_buf, &usbd_core_cfg.ep0_data_buf_len)) { + if (!usbd_setup_request_handler(setup, &g_usbd_core.ep0_data_buf, &g_usbd_core.ep0_data_buf_len)) { usbd_ep_set_stall(USB_CONTROL_IN_EP0); return; } #ifdef CONFIG_USBDEV_TEST_MODE /* send status in test mode, so do not execute downward, just return */ - if (usbd_core_cfg.test_mode) { - usbd_core_cfg.test_mode = false; + if (g_usbd_core.test_mode) { + g_usbd_core.test_mode = false; return; } #endif /* Send smallest of requested and offered length */ - usbd_core_cfg.ep0_data_buf_residue = MIN(usbd_core_cfg.ep0_data_buf_len, setup->wLength); - if (usbd_core_cfg.ep0_data_buf_residue > CONFIG_USBDEV_REQUEST_BUFFER_LEN) { + g_usbd_core.ep0_data_buf_residue = MIN(g_usbd_core.ep0_data_buf_len, setup->wLength); + if (g_usbd_core.ep0_data_buf_residue > CONFIG_USBDEV_REQUEST_BUFFER_LEN) { USB_LOG_ERR("Request buffer too small\r\n"); return; } /* Send data or status to host */ - usbd_ep_start_write(USB_CONTROL_IN_EP0, usbd_core_cfg.ep0_data_buf, usbd_core_cfg.ep0_data_buf_residue); + usbd_ep_start_write(USB_CONTROL_IN_EP0, g_usbd_core.ep0_data_buf, g_usbd_core.ep0_data_buf_residue); /* * Set ZLP flag when host asks for a bigger length and the data size is * multiplier of USB_CTRL_EP_MPS, to indicate the transfer done after zlp * sent. */ - if ((setup->wLength > usbd_core_cfg.ep0_data_buf_len) && (!(usbd_core_cfg.ep0_data_buf_len % USB_CTRL_EP_MPS))) { - usbd_core_cfg.zlp_flag = true; + if ((setup->wLength > g_usbd_core.ep0_data_buf_len) && (!(g_usbd_core.ep0_data_buf_len % USB_CTRL_EP_MPS))) { + g_usbd_core.zlp_flag = true; USB_LOG_DBG("EP0 Set zlp\r\n"); } } void usbd_event_ep0_in_complete_handler(uint8_t ep, uint32_t nbytes) { - struct usb_setup_packet *setup = &usbd_core_cfg.setup; + struct usb_setup_packet *setup = &g_usbd_core.setup; - usbd_core_cfg.ep0_data_buf += nbytes; - usbd_core_cfg.ep0_data_buf_residue -= nbytes; + g_usbd_core.ep0_data_buf += nbytes; + g_usbd_core.ep0_data_buf_residue -= nbytes; - USB_LOG_DBG("EP0 send %d bytes, %d remained\r\n", nbytes, usbd_core_cfg.ep0_data_buf_residue); + USB_LOG_DBG("EP0 send %d bytes, %d remained\r\n", nbytes, g_usbd_core.ep0_data_buf_residue); - if (usbd_core_cfg.ep0_data_buf_residue != 0) { + if (g_usbd_core.ep0_data_buf_residue != 0) { /* Start sending the remain data */ - usbd_ep_start_write(USB_CONTROL_IN_EP0, usbd_core_cfg.ep0_data_buf, usbd_core_cfg.ep0_data_buf_residue); + usbd_ep_start_write(USB_CONTROL_IN_EP0, g_usbd_core.ep0_data_buf, g_usbd_core.ep0_data_buf_residue); } else { - if (usbd_core_cfg.zlp_flag == true) { - usbd_core_cfg.zlp_flag = false; + if (g_usbd_core.zlp_flag == true) { + g_usbd_core.zlp_flag = false; /* Send zlp to host */ USB_LOG_DBG("EP0 Send zlp\r\n"); usbd_ep_start_write(USB_CONTROL_IN_EP0, NULL, 0); @@ -1100,18 +1095,18 @@ void usbd_event_ep0_in_complete_handler(uint8_t ep, uint32_t nbytes) void usbd_event_ep0_out_complete_handler(uint8_t ep, uint32_t nbytes) { - struct usb_setup_packet *setup = &usbd_core_cfg.setup; + struct usb_setup_packet *setup = &g_usbd_core.setup; if (nbytes > 0) { - usbd_core_cfg.ep0_data_buf += nbytes; - usbd_core_cfg.ep0_data_buf_residue -= nbytes; + g_usbd_core.ep0_data_buf += nbytes; + g_usbd_core.ep0_data_buf_residue -= nbytes; - USB_LOG_DBG("EP0 recv %d bytes, %d remained\r\n", nbytes, usbd_core_cfg.ep0_data_buf_residue); + USB_LOG_DBG("EP0 recv %d bytes, %d remained\r\n", nbytes, g_usbd_core.ep0_data_buf_residue); - if (usbd_core_cfg.ep0_data_buf_residue == 0) { + if (g_usbd_core.ep0_data_buf_residue == 0) { /* Received all, send data to handler */ - usbd_core_cfg.ep0_data_buf = usbd_core_cfg.req_data; - if (!usbd_setup_request_handler(setup, &usbd_core_cfg.ep0_data_buf, &usbd_core_cfg.ep0_data_buf_len)) { + g_usbd_core.ep0_data_buf = g_usbd_core.req_data; + if (!usbd_setup_request_handler(setup, &g_usbd_core.ep0_data_buf, &g_usbd_core.ep0_data_buf_len)) { usbd_ep_set_stall(USB_CONTROL_IN_EP0); return; } @@ -1120,7 +1115,7 @@ void usbd_event_ep0_out_complete_handler(uint8_t ep, uint32_t nbytes) usbd_ep_start_write(USB_CONTROL_IN_EP0, NULL, 0); } else { /* Start reading the remain data */ - usbd_ep_start_read(USB_CONTROL_OUT_EP0, usbd_core_cfg.ep0_data_buf, usbd_core_cfg.ep0_data_buf_residue); + usbd_ep_start_read(USB_CONTROL_OUT_EP0, g_usbd_core.ep0_data_buf, g_usbd_core.ep0_data_buf_residue); } } else { /* Read out status completely, do nothing */ @@ -1131,24 +1126,24 @@ void usbd_event_ep0_out_complete_handler(uint8_t ep, uint32_t nbytes) void usbd_event_ep_in_complete_handler(uint8_t ep, uint32_t nbytes) { #ifndef CONFIG_USBDEV_TX_THREAD - if (tx_msg[ep & 0x7f].cb) { - tx_msg[ep & 0x7f].cb(ep, nbytes); + if (g_usbd_core.tx_msg[ep & 0x7f].cb) { + g_usbd_core.tx_msg[ep & 0x7f].cb(ep, nbytes); } #else - tx_msg[ep & 0x7f].nbytes = nbytes; - usb_osal_mq_send(usbd_tx_mq, (uintptr_t)&tx_msg[ep & 0x7f]); + g_usbd_core.tx_msg[ep & 0x7f].nbytes = nbytes; + usb_osal_mq_send(usbd_tx_mq, (uintptr_t)&g_usbd_core.tx_msg[ep & 0x7f]); #endif } void usbd_event_ep_out_complete_handler(uint8_t ep, uint32_t nbytes) { #ifndef CONFIG_USBDEV_RX_THREAD - if (rx_msg[ep & 0x7f].cb) { - rx_msg[ep & 0x7f].cb(ep, nbytes); + if (g_usbd_core.rx_msg[ep & 0x7f].cb) { + g_usbd_core.rx_msg[ep & 0x7f].cb(ep, nbytes); } #else - rx_msg[ep & 0x7f].nbytes = nbytes; - usb_osal_mq_send(usbd_rx_mq, (uintptr_t)&rx_msg[ep & 0x7f]); + g_usbd_core.rx_msg[ep & 0x7f].nbytes = nbytes; + usb_osal_mq_send(usbd_rx_mq, (uintptr_t)&g_usbd_core.rx_msg[ep & 0x7f]); #endif } @@ -1193,69 +1188,69 @@ static void usbdev_rx_thread(void *argument) #ifdef CONFIG_USBDEV_ADVANCE_DESC void usbd_desc_register(struct usb_descriptor *desc) { - memset(&usbd_core_cfg, 0, sizeof(struct usbd_core_cfg_priv)); + memset(&g_usbd_core, 0, sizeof(struct usbd_core_priv)); - usbd_core_cfg.descriptors = desc; - usbd_core_cfg.intf_offset = 0; + g_usbd_core.descriptors = desc; + g_usbd_core.intf_offset = 0; - tx_msg[0].ep = 0x80; - tx_msg[0].cb = usbd_event_ep0_in_complete_handler; - rx_msg[0].ep = 0x00; - rx_msg[0].cb = usbd_event_ep0_out_complete_handler; + g_usbd_core.tx_msg[0].ep = 0x80; + g_usbd_core.tx_msg[0].cb = usbd_event_ep0_in_complete_handler; + g_usbd_core.rx_msg[0].ep = 0x00; + g_usbd_core.rx_msg[0].cb = usbd_event_ep0_out_complete_handler; } #else void usbd_desc_register(const uint8_t *desc) { - memset(&usbd_core_cfg, 0, sizeof(struct usbd_core_cfg_priv)); + memset(&g_usbd_core, 0, sizeof(struct usbd_core_priv)); - usbd_core_cfg.descriptors = desc; - usbd_core_cfg.intf_offset = 0; + g_usbd_core.descriptors = desc; + g_usbd_core.intf_offset = 0; - tx_msg[0].ep = 0x80; - tx_msg[0].cb = usbd_event_ep0_in_complete_handler; - rx_msg[0].ep = 0x00; - rx_msg[0].cb = usbd_event_ep0_out_complete_handler; + g_usbd_core.tx_msg[0].ep = 0x80; + g_usbd_core.tx_msg[0].cb = usbd_event_ep0_in_complete_handler; + g_usbd_core.rx_msg[0].ep = 0x00; + g_usbd_core.rx_msg[0].cb = usbd_event_ep0_out_complete_handler; } /* Register MS OS Descriptors version 1 */ void usbd_msosv1_desc_register(struct usb_msosv1_descriptor *desc) { - msosv1_desc = desc; + g_usbd_core.msosv1_desc = desc; } /* Register MS OS Descriptors version 2 */ void usbd_msosv2_desc_register(struct usb_msosv2_descriptor *desc) { - msosv2_desc = desc; + g_usbd_core.msosv2_desc = desc; } void usbd_bos_desc_register(struct usb_bos_descriptor *desc) { - bos_desc = desc; + g_usbd_core.bos_desc = desc; } #endif void usbd_add_interface(struct usbd_interface *intf) { - intf->intf_num = usbd_core_cfg.intf_offset; - usb_slist_add_tail(&usbd_intf_head, &intf->list); - usbd_core_cfg.intf_offset++; + intf->intf_num = g_usbd_core.intf_offset; + g_usbd_core.intf[g_usbd_core.intf_offset] = intf; + g_usbd_core.intf_offset++; } void usbd_add_endpoint(struct usbd_endpoint *ep) { if (ep->ep_addr & 0x80) { - tx_msg[ep->ep_addr & 0x7f].ep = ep->ep_addr; - tx_msg[ep->ep_addr & 0x7f].cb = ep->ep_cb; + g_usbd_core.tx_msg[ep->ep_addr & 0x7f].ep = ep->ep_addr; + g_usbd_core.tx_msg[ep->ep_addr & 0x7f].cb = ep->ep_cb; } else { - rx_msg[ep->ep_addr & 0x7f].ep = ep->ep_addr; - rx_msg[ep->ep_addr & 0x7f].cb = ep->ep_cb; + g_usbd_core.rx_msg[ep->ep_addr & 0x7f].ep = ep->ep_addr; + g_usbd_core.rx_msg[ep->ep_addr & 0x7f].cb = ep->ep_cb; } } bool usb_device_is_configured(void) { - return usbd_core_cfg.configured; + return g_usbd_core.configuration; } int usbd_initialize(void) @@ -1285,8 +1280,7 @@ int usbd_initialize(void) int usbd_deinitialize(void) { - usbd_core_cfg.intf_offset = 0; - usb_slist_init(&usbd_intf_head); + g_usbd_core.intf_offset = 0; usb_dc_deinit(); #if defined(CONFIG_USBDEV_TX_THREAD) || defined(CONFIG_USBDEV_RX_THREAD) #endif diff --git a/core/usbd_core.h b/core/usbd_core.h index 3328cffe..561730e4 100644 --- a/core/usbd_core.h +++ b/core/usbd_core.h @@ -46,15 +46,12 @@ typedef int (*usbd_request_handler)(struct usb_setup_packet *setup, uint8_t **da typedef void (*usbd_endpoint_callback)(uint8_t ep, uint32_t nbytes); typedef void (*usbd_notify_handler)(uint8_t event, void *arg); -extern usb_slist_t usbd_intf_head; - struct usbd_endpoint { uint8_t ep_addr; usbd_endpoint_callback ep_cb; }; struct usbd_interface { - usb_slist_t list; usbd_request_handler class_interface_handler; usbd_request_handler class_endpoint_handler; usbd_request_handler vendor_handler;