/* * The Mass Storage protocol state machine in this file is based on mbed's * implementation. We augment it by adding Zephyr's USB transport and Storage * APIs. * * Copyright (c) 2010-2011 mbed.org, MIT License * Copyright (c) 2016 Intel Corporation. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /** * @file * @brief Mass Storage device class driver * * Driver for USB Mass Storage device class driver */ #include #include #include #include #include #include #include #include #include LOG_MODULE_REGISTER(usb_msc, CONFIG_USB_MASS_STORAGE_LOG_LEVEL); /* MSC Subclass and Protocol Codes */ #define SCSI_TRANSPARENT_SUBCLASS 0x06 #define BULK_ONLY_TRANSPORT_PROTOCOL 0x50 /* MSC Request Codes for Bulk-Only Transport */ #define MSC_REQUEST_GET_MAX_LUN 0xFE #define MSC_REQUEST_RESET 0xFF /* MSC Command Block Wrapper (CBW) Signature */ #define CBW_Signature 0x43425355 /* MSC Command Block Wrapper Flags */ #define CBW_DIRECTION_DATA_IN 0x80 /* MSC Bulk-Only Command Block Wrapper (CBW) */ struct CBW { uint32_t Signature; uint32_t Tag; uint32_t DataLength; uint8_t Flags; uint8_t LUN; uint8_t CBLength; uint8_t CB[16]; } __packed; /* MSC Command Status Wrapper (CBW) Signature */ #define CSW_Signature 0x53425355 /* MSC Command Block Status Values */ #define CSW_STATUS_CMD_PASSED 0x00 #define CSW_STATUS_CMD_FAILED 0x01 #define CSW_STATUS_PHASE_ERROR 0x02 /* MSC Bulk-Only Command Status Wrapper (CSW) */ struct CSW { uint32_t Signature; uint32_t Tag; uint32_t DataResidue; uint8_t Status; } __packed; /* SCSI transparent command set used by MSC */ #define TEST_UNIT_READY 0x00 #define REQUEST_SENSE 0x03 #define FORMAT_UNIT 0x04 #define INQUIRY 0x12 #define MODE_SELECT6 0x15 #define MODE_SENSE6 0x1A #define START_STOP_UNIT 0x1B #define MEDIA_REMOVAL 0x1E #define READ_FORMAT_CAPACITIES 0x23 #define READ_CAPACITY 0x25 #define READ10 0x28 #define WRITE10 0x2A #define VERIFY10 0x2F #define READ12 0xA8 #define WRITE12 0xAA #define MODE_SELECT10 0x55 #define MODE_SENSE10 0x5A /* max USB packet size */ #define MAX_PACKET CONFIG_MASS_STORAGE_BULK_EP_MPS #define BLOCK_SIZE 512 #define DISK_THREAD_PRIO -5 BUILD_ASSERT(MAX_PACKET <= BLOCK_SIZE); #define THREAD_OP_READ_QUEUED 1 #define THREAD_OP_WRITE_QUEUED 3 #define THREAD_OP_WRITE_DONE 4 #define MASS_STORAGE_IN_EP_ADDR 0x82 #define MASS_STORAGE_OUT_EP_ADDR 0x01 struct usb_mass_config { struct usb_if_descriptor if0; struct usb_ep_descriptor if0_in_ep; struct usb_ep_descriptor if0_out_ep; } __packed; USBD_CLASS_DESCR_DEFINE(primary, 0) struct usb_mass_config mass_cfg = { /* Interface descriptor */ .if0 = { .bLength = sizeof(struct usb_if_descriptor), .bDescriptorType = USB_DESC_INTERFACE, .bInterfaceNumber = 0, .bAlternateSetting = 0, .bNumEndpoints = 2, .bInterfaceClass = USB_BCC_MASS_STORAGE, .bInterfaceSubClass = SCSI_TRANSPARENT_SUBCLASS, .bInterfaceProtocol = BULK_ONLY_TRANSPORT_PROTOCOL, .iInterface = 0, }, /* First Endpoint IN */ .if0_in_ep = { .bLength = sizeof(struct usb_ep_descriptor), .bDescriptorType = USB_DESC_ENDPOINT, .bEndpointAddress = MASS_STORAGE_IN_EP_ADDR, .bmAttributes = USB_DC_EP_BULK, .wMaxPacketSize = sys_cpu_to_le16(CONFIG_MASS_STORAGE_BULK_EP_MPS), .bInterval = 0x00, }, /* Second Endpoint OUT */ .if0_out_ep = { .bLength = sizeof(struct usb_ep_descriptor), .bDescriptorType = USB_DESC_ENDPOINT, .bEndpointAddress = MASS_STORAGE_OUT_EP_ADDR, .bmAttributes = USB_DC_EP_BULK, .wMaxPacketSize = sys_cpu_to_le16(CONFIG_MASS_STORAGE_BULK_EP_MPS), .bInterval = 0x00, }, }; static volatile int thread_op; static K_KERNEL_STACK_DEFINE(mass_thread_stack, CONFIG_MASS_STORAGE_STACK_SIZE); static struct k_thread mass_thread_data; static struct k_sem disk_wait_sem; static volatile uint32_t defered_wr_sz; /* * Keep block buffer larger than BLOCK_SIZE for the case * the dCBWDataTransferLength is multiple of the BLOCK_SIZE and * the length of the transferred data is not aligned to the BLOCK_SIZE. * * Align for cases where the underlying disk access requires word-aligned * addresses. */ static uint8_t __aligned(4) page[BLOCK_SIZE + CONFIG_MASS_STORAGE_BULK_EP_MPS]; /* Initialized during mass_storage_init() */ static uint32_t block_count; static const char *disk_pdrv = CONFIG_MASS_STORAGE_DISK_NAME; #define MSD_OUT_EP_IDX 0 #define MSD_IN_EP_IDX 1 static void mass_storage_bulk_out(uint8_t ep, enum usb_dc_ep_cb_status_code ep_status); static void mass_storage_bulk_in(uint8_t ep, enum usb_dc_ep_cb_status_code ep_status); /* Describe EndPoints configuration */ static struct usb_ep_cfg_data mass_ep_data[] = { { .ep_cb = mass_storage_bulk_out, .ep_addr = MASS_STORAGE_OUT_EP_ADDR }, { .ep_cb = mass_storage_bulk_in, .ep_addr = MASS_STORAGE_IN_EP_ADDR } }; /* CSW Status */ enum Status { CSW_PASSED, CSW_FAILED, CSW_ERROR, }; /* MSC Bulk-only Stage */ enum Stage { MSC_READ_CBW, /* wait a CBW */ MSC_ERROR, /* error */ MSC_PROCESS_CBW, /* process a CBW request */ MSC_SEND_CSW, /* send a CSW */ MSC_WAIT_CSW /* wait that a CSW has been effectively sent */ }; /* state of the bulk-only state machine */ static enum Stage stage; /*current CBW*/ static struct CBW cbw; /*CSW which will be sent*/ static struct CSW csw; /*addr where will be read or written data*/ static uint32_t curr_lba; /*length of a reading or writing*/ static uint32_t length; /*offset into curr_lba for read/write*/ static uint16_t curr_offset; static uint8_t max_lun_count; /*memory OK (after a memoryVerify)*/ static bool memOK; #define INQ_VENDOR_ID_LEN 8 #define INQ_PRODUCT_ID_LEN 16 #define INQ_REVISION_LEN 4 struct dabc_inquiry_data { uint8_t head[8]; uint8_t t10_vid[INQ_VENDOR_ID_LEN]; uint8_t product_id[INQ_PRODUCT_ID_LEN]; uint8_t product_rev[INQ_REVISION_LEN]; } __packed; static const struct dabc_inquiry_data inq_rsp = { .head = {0x00, 0x80, 0x00, 0x01, 36 - 4, 0x80, 0x00, 0x00}, .t10_vid = CONFIG_MASS_STORAGE_INQ_VENDOR_ID, .product_id = CONFIG_MASS_STORAGE_INQ_PRODUCT_ID, .product_rev = CONFIG_MASS_STORAGE_INQ_REVISION, }; BUILD_ASSERT(sizeof(CONFIG_MASS_STORAGE_INQ_VENDOR_ID) == (INQ_VENDOR_ID_LEN + 1), "CONFIG_MASS_STORAGE_INQ_VENDOR_ID must be 8 characters (pad with spaces)"); BUILD_ASSERT(sizeof(CONFIG_MASS_STORAGE_INQ_PRODUCT_ID) == (INQ_PRODUCT_ID_LEN + 1), "CONFIG_MASS_STORAGE_INQ_PRODUCT_ID must be 16 characters (pad with spaces)"); BUILD_ASSERT(sizeof(CONFIG_MASS_STORAGE_INQ_REVISION) == (INQ_REVISION_LEN + 1), "CONFIG_MASS_STORAGE_INQ_REVISION must be 4 characters (pad with spaces)"); static void msd_state_machine_reset(void) { stage = MSC_READ_CBW; } static void msd_init(void) { (void)memset((void *)&cbw, 0, sizeof(struct CBW)); (void)memset((void *)&csw, 0, sizeof(struct CSW)); (void)memset(page, 0, sizeof(page)); curr_lba = 0U; length = 0U; curr_offset = 0U; } static void sendCSW(void) { csw.Signature = CSW_Signature; if (usb_write(mass_ep_data[MSD_IN_EP_IDX].ep_addr, (uint8_t *)&csw, sizeof(struct CSW), NULL) != 0) { LOG_ERR("usb write failure"); } stage = MSC_WAIT_CSW; } static void fail(void) { if (cbw.DataLength) { /* Stall data stage */ if ((cbw.Flags & 0x80) != 0U) { usb_ep_set_stall(mass_ep_data[MSD_IN_EP_IDX].ep_addr); } else { usb_ep_set_stall(mass_ep_data[MSD_OUT_EP_IDX].ep_addr); } } csw.Status = CSW_FAILED; sendCSW(); } static bool write(uint8_t *buf, uint16_t size) { if (size >= cbw.DataLength) { size = cbw.DataLength; } /* updating the State Machine , so that we send CSW when this * transfer is complete, ie when we get a bulk in callback */ stage = MSC_SEND_CSW; if (usb_write(mass_ep_data[MSD_IN_EP_IDX].ep_addr, buf, size, NULL)) { LOG_ERR("USB write failed"); return false; } csw.DataResidue -= size; csw.Status = CSW_PASSED; return true; } /** * @brief Handler called for Class requests not handled by the USB stack. * * @param pSetup Information about the request to execute. * @param len Size of the buffer. * @param data Buffer containing the request result. * * @return 0 on success, negative errno code on fail. */ static int mass_storage_class_handle_req(struct usb_setup_packet *setup, int32_t *len, uint8_t **data) { if (setup->wIndex != mass_cfg.if0.bInterfaceNumber || setup->wValue != 0) { LOG_ERR("Invalid setup parameters"); return -EINVAL; } if (usb_reqtype_is_to_device(setup)) { if (setup->bRequest == MSC_REQUEST_RESET && setup->wLength == 0) { LOG_DBG("MSC_REQUEST_RESET"); msd_state_machine_reset(); return 0; } } else { if (setup->bRequest == MSC_REQUEST_GET_MAX_LUN && setup->wLength == 1) { LOG_DBG("MSC_REQUEST_GET_MAX_LUN"); max_lun_count = 0U; *data = (uint8_t *)(&max_lun_count); *len = 1; return 0; } } LOG_WRN("Unsupported bmRequestType 0x%02x bRequest 0x%02x", setup->bmRequestType, setup->bRequest); return -ENOTSUP; } static void testUnitReady(void) { if (cbw.DataLength != 0U) { if ((cbw.Flags & 0x80) != 0U) { LOG_WRN("Stall IN endpoint"); usb_ep_set_stall(mass_ep_data[MSD_IN_EP_IDX].ep_addr); } else { LOG_WRN("Stall OUT endpoint"); usb_ep_set_stall(mass_ep_data[MSD_OUT_EP_IDX].ep_addr); } } csw.Status = CSW_PASSED; sendCSW(); } static bool requestSense(void) { uint8_t request_sense[] = { 0x70, 0x00, 0x05, /* Sense Key: illegal request */ 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x30, 0x01, 0x00, 0x00, 0x00, 0x00, }; return write(request_sense, sizeof(request_sense)); } static bool inquiryRequest(void) { return write((uint8_t *)&inq_rsp, sizeof(inq_rsp)); } static bool modeSense6(void) { uint8_t sense6[] = { 0x03, 0x00, 0x00, 0x00 }; return write(sense6, sizeof(sense6)); } static bool readFormatCapacity(void) { uint8_t capacity[] = { 0x00, 0x00, 0x00, 0x08, (uint8_t)((block_count >> 24) & 0xff), (uint8_t)((block_count >> 16) & 0xff), (uint8_t)((block_count >> 8) & 0xff), (uint8_t)((block_count >> 0) & 0xff), 0x02, (uint8_t)((BLOCK_SIZE >> 16) & 0xff), (uint8_t)((BLOCK_SIZE >> 8) & 0xff), (uint8_t)((BLOCK_SIZE >> 0) & 0xff), }; return write(capacity, sizeof(capacity)); } static bool readCapacity(void) { uint8_t capacity[8]; sys_put_be32(block_count - 1, &capacity[0]); sys_put_be32(BLOCK_SIZE, &capacity[4]); return write(capacity, sizeof(capacity)); } static void thread_memory_read_done(void) { uint32_t n = length; if (n > MAX_PACKET) { n = MAX_PACKET; } if (n > BLOCK_SIZE - curr_offset) { n = BLOCK_SIZE - curr_offset; } if (usb_write(mass_ep_data[MSD_IN_EP_IDX].ep_addr, &page[curr_offset], n, NULL) != 0) { LOG_ERR("Failed to write EP 0x%x", mass_ep_data[MSD_IN_EP_IDX].ep_addr); } curr_offset += n; if (curr_offset >= BLOCK_SIZE) { curr_offset -= BLOCK_SIZE; curr_lba += 1; } length -= n; csw.DataResidue -= n; if (!length || (stage != MSC_PROCESS_CBW)) { csw.Status = (stage == MSC_PROCESS_CBW) ? CSW_PASSED : CSW_FAILED; stage = (stage == MSC_PROCESS_CBW) ? MSC_SEND_CSW : stage; } } static void memoryRead(void) { if (curr_lba >= block_count) { LOG_WRN("Attempt to read past end of device: lba=%u", curr_lba); fail(); return; } if (!curr_offset) { /* we need a new block */ thread_op = THREAD_OP_READ_QUEUED; LOG_DBG("Signal thread for %u", curr_lba); k_sem_give(&disk_wait_sem); } else { thread_memory_read_done(); } } static bool check_cbw_data_length(void) { if (!cbw.DataLength) { LOG_WRN("Zero length in CBW"); csw.Status = CSW_FAILED; sendCSW(); return false; } return true; } static bool infoTransfer(void) { uint32_t n; if (!check_cbw_data_length()) { return false; } /* Logical Block Address of First Block */ n = sys_get_be32(&cbw.CB[2]); LOG_DBG("LBA (block) : 0x%x ", n); if (n >= block_count) { LOG_ERR("LBA out of range"); fail(); return false; } curr_lba = n; curr_offset = 0U; /* Number of Blocks to transfer */ switch (cbw.CB[0]) { case READ10: case WRITE10: case VERIFY10: n = sys_get_be16(&cbw.CB[7]); break; case READ12: case WRITE12: n = sys_get_be32(&cbw.CB[6]); break; } LOG_DBG("Size (block) : 0x%x ", n); length = n * BLOCK_SIZE; if (cbw.DataLength != length) { LOG_ERR("DataLength mismatch"); fail(); return false; } return true; } static void CBWDecode(uint8_t *buf, uint16_t size) { if (size != sizeof(cbw)) { LOG_ERR("size != sizeof(cbw)"); return; } memcpy((uint8_t *)&cbw, buf, size); if (cbw.Signature != CBW_Signature) { LOG_ERR("CBW Signature Mismatch"); return; } csw.Tag = cbw.Tag; csw.DataResidue = cbw.DataLength; if ((cbw.CBLength < 1) || (cbw.CBLength > 16) || (cbw.LUN != 0U)) { LOG_WRN("cbw.CBLength %d", cbw.CBLength); fail(); } else { switch (cbw.CB[0]) { case TEST_UNIT_READY: LOG_DBG(">> TUR"); testUnitReady(); break; case REQUEST_SENSE: LOG_DBG(">> REQ_SENSE"); if (check_cbw_data_length()) { requestSense(); } break; case INQUIRY: LOG_DBG(">> INQ"); if (check_cbw_data_length()) { inquiryRequest(); } break; case MODE_SENSE6: LOG_DBG(">> MODE_SENSE6"); if (check_cbw_data_length()) { modeSense6(); } break; case READ_FORMAT_CAPACITIES: LOG_DBG(">> READ_FORMAT_CAPACITY"); if (check_cbw_data_length()) { readFormatCapacity(); } break; case READ_CAPACITY: LOG_DBG(">> READ_CAPACITY"); if (check_cbw_data_length()) { readCapacity(); } break; case READ10: case READ12: LOG_DBG(">> READ"); if (infoTransfer()) { if ((cbw.Flags & 0x80)) { stage = MSC_PROCESS_CBW; memoryRead(); } else { usb_ep_set_stall( mass_ep_data[MSD_OUT_EP_IDX].ep_addr); LOG_WRN("Stall OUT endpoint"); csw.Status = CSW_ERROR; sendCSW(); } } break; case WRITE10: case WRITE12: LOG_DBG(">> WRITE"); if (infoTransfer()) { if (!(cbw.Flags & 0x80)) { stage = MSC_PROCESS_CBW; } else { usb_ep_set_stall( mass_ep_data[MSD_IN_EP_IDX].ep_addr); LOG_WRN("Stall IN endpoint"); csw.Status = CSW_ERROR; sendCSW(); } } break; case VERIFY10: LOG_DBG(">> VERIFY10"); if (!(cbw.CB[1] & 0x02)) { csw.Status = CSW_PASSED; sendCSW(); break; } if (infoTransfer()) { if (!(cbw.Flags & 0x80)) { stage = MSC_PROCESS_CBW; memOK = true; } else { usb_ep_set_stall( mass_ep_data[MSD_IN_EP_IDX].ep_addr); LOG_WRN("Stall IN endpoint"); csw.Status = CSW_ERROR; sendCSW(); } } break; case MEDIA_REMOVAL: LOG_DBG(">> MEDIA_REMOVAL"); csw.Status = CSW_PASSED; sendCSW(); break; default: LOG_WRN(">> default CB[0] %x", cbw.CB[0]); fail(); break; } /*switch(cbw.CB[0])*/ } /* else */ } static void memoryVerify(uint8_t *buf, uint16_t size) { uint32_t n; if (curr_lba >= block_count) { LOG_WRN("Attempt to read past end of device: lba=%u", curr_lba); fail(); return; } /* BUG: if a packet crosses block boundaries, we will probably fail. */ /* beginning of a new block -> load a whole block in RAM */ if (!curr_offset) { LOG_DBG("Disk READ sector %u", curr_lba); if (disk_access_read(disk_pdrv, page, curr_lba, 1)) { LOG_ERR("---- Disk Read Error %u", curr_lba); } } /* info are in RAM -> no need to re-read memory */ for (n = 0U; n < size; n++) { if (page[curr_offset + n] != buf[n]) { LOG_DBG("Mismatch sector %u offset %u", curr_lba, curr_offset + n); memOK = false; break; } } curr_offset += n; if (curr_offset >= BLOCK_SIZE) { curr_offset -= BLOCK_SIZE; curr_lba += 1; } length -= size; csw.DataResidue -= size; if (!length || (stage != MSC_PROCESS_CBW)) { csw.Status = (memOK && (stage == MSC_PROCESS_CBW)) ? CSW_PASSED : CSW_FAILED; sendCSW(); } } static void memoryWrite(uint8_t *buf, uint16_t size) { if (curr_lba >= block_count) { LOG_WRN("Attempt to write past end of device: lba=%u", curr_lba); fail(); return; } /* we fill an array in RAM of 1 block before writing it in memory */ for (int i = 0; i < size; i++) { page[curr_offset + i] = buf[i]; } /* if the array is filled, write it in memory */ if (curr_offset + size >= BLOCK_SIZE) { if (!(disk_access_status(disk_pdrv) & DISK_STATUS_WR_PROTECT)) { LOG_DBG("Disk WRITE Qd %u", curr_lba); thread_op = THREAD_OP_WRITE_QUEUED; /* write_queued */ defered_wr_sz = size; k_sem_give(&disk_wait_sem); return; } } curr_offset += size; length -= size; csw.DataResidue -= size; if ((!length) || (stage != MSC_PROCESS_CBW)) { csw.Status = (stage == MSC_ERROR) ? CSW_FAILED : CSW_PASSED; sendCSW(); } } static void mass_storage_bulk_out(uint8_t ep, enum usb_dc_ep_cb_status_code ep_status) { uint32_t bytes_read = 0U; uint8_t bo_buf[CONFIG_MASS_STORAGE_BULK_EP_MPS]; ARG_UNUSED(ep_status); usb_ep_read_wait(ep, bo_buf, CONFIG_MASS_STORAGE_BULK_EP_MPS, &bytes_read); switch (stage) { /*the device has to decode the CBW received*/ case MSC_READ_CBW: LOG_DBG("> BO - MSC_READ_CBW"); CBWDecode(bo_buf, bytes_read); break; /*the device has to receive data from the host*/ case MSC_PROCESS_CBW: switch (cbw.CB[0]) { case WRITE10: case WRITE12: /* LOG_DBG("> BO - PROC_CBW WR");*/ memoryWrite(bo_buf, bytes_read); break; case VERIFY10: LOG_DBG("> BO - PROC_CBW VER"); memoryVerify(bo_buf, bytes_read); break; default: LOG_ERR("> BO - PROC_CBW default <>"); break; } break; /*an error has occurred: stall endpoint and send CSW*/ default: LOG_WRN("Stall OUT endpoint, stage: %d", stage); usb_ep_set_stall(ep); csw.Status = CSW_ERROR; sendCSW(); break; } if (thread_op != THREAD_OP_WRITE_QUEUED) { usb_ep_read_continue(ep); } else { LOG_DBG("> BO not clearing NAKs yet"); } } static void thread_memory_write_done(void) { uint32_t size = defered_wr_sz; size_t overflowed_len = (curr_offset + size) - BLOCK_SIZE; if (BLOCK_SIZE > (curr_offset + size)) { overflowed_len = 0; } if (overflowed_len > 0) { memmove(page, &page[BLOCK_SIZE], overflowed_len); } curr_offset = overflowed_len; curr_lba += 1; length -= size; csw.DataResidue -= size; if (!length) { if (disk_access_ioctl(disk_pdrv, DISK_IOCTL_CTRL_SYNC, NULL)) { LOG_ERR("!! Disk cache sync error !!"); } } if ((!length) || (stage != MSC_PROCESS_CBW)) { csw.Status = (stage == MSC_ERROR) ? CSW_FAILED : CSW_PASSED; sendCSW(); } thread_op = THREAD_OP_WRITE_DONE; usb_ep_read_continue(mass_ep_data[MSD_OUT_EP_IDX].ep_addr); } /** * @brief EP Bulk IN handler, used to send data to the Host * * @param ep Endpoint address. * @param ep_status Endpoint status code. * * @return N/A. */ static void mass_storage_bulk_in(uint8_t ep, enum usb_dc_ep_cb_status_code ep_status) { ARG_UNUSED(ep_status); ARG_UNUSED(ep); switch (stage) { /*the device has to send data to the host*/ case MSC_PROCESS_CBW: switch (cbw.CB[0]) { case READ10: case READ12: /* LOG_DBG("< BI - PROC_CBW READ"); */ memoryRead(); break; default: LOG_ERR("< BI-PROC_CBW default <>"); break; } break; /*the device has to send a CSW*/ case MSC_SEND_CSW: LOG_DBG("< BI - MSC_SEND_CSW"); sendCSW(); break; /*the host has received the CSW -> we wait a CBW*/ case MSC_WAIT_CSW: LOG_DBG("< BI - MSC_WAIT_CSW"); stage = MSC_READ_CBW; break; /*an error has occurred*/ default: LOG_WRN("Stall IN endpoint, stage: %d", stage); usb_ep_set_stall(mass_ep_data[MSD_IN_EP_IDX].ep_addr); sendCSW(); break; } } /** * @brief Callback used to know the USB connection status * * @param status USB device status code. * * @return N/A. */ static void mass_storage_status_cb(struct usb_cfg_data *cfg, enum usb_dc_status_code status, const uint8_t *param) { ARG_UNUSED(param); ARG_UNUSED(cfg); /* Check the USB status and do needed action if required */ switch (status) { case USB_DC_ERROR: LOG_DBG("USB device error"); break; case USB_DC_RESET: LOG_DBG("USB device reset detected"); msd_state_machine_reset(); msd_init(); break; case USB_DC_CONNECTED: LOG_DBG("USB device connected"); break; case USB_DC_CONFIGURED: LOG_DBG("USB device configured"); break; case USB_DC_DISCONNECTED: LOG_DBG("USB device disconnected"); break; case USB_DC_SUSPEND: LOG_DBG("USB device suspended"); break; case USB_DC_RESUME: LOG_DBG("USB device resumed"); break; case USB_DC_INTERFACE: LOG_DBG("USB interface selected"); break; case USB_DC_SOF: break; case USB_DC_UNKNOWN: default: LOG_DBG("USB unknown state"); break; } } static void mass_interface_config(struct usb_desc_header *head, uint8_t bInterfaceNumber) { ARG_UNUSED(head); mass_cfg.if0.bInterfaceNumber = bInterfaceNumber; } /* Configuration of the Mass Storage Device send to the USB Driver */ USBD_DEFINE_CFG_DATA(mass_storage_config) = { .usb_device_description = NULL, .interface_config = mass_interface_config, .interface_descriptor = &mass_cfg.if0, .cb_usb_status = mass_storage_status_cb, .interface = { .class_handler = mass_storage_class_handle_req, .custom_handler = NULL, }, .num_endpoints = ARRAY_SIZE(mass_ep_data), .endpoint = mass_ep_data }; static void mass_thread_main(void *p1, void *p2, void *p3) { ARG_UNUSED(p1); ARG_UNUSED(p2); ARG_UNUSED(p3); while (1) { k_sem_take(&disk_wait_sem, K_FOREVER); LOG_DBG("sem %d", thread_op); switch (thread_op) { case THREAD_OP_READ_QUEUED: if (disk_access_read(disk_pdrv, page, curr_lba, 1)) { LOG_ERR("!! Disk Read Error %u !", curr_lba); } thread_memory_read_done(); break; case THREAD_OP_WRITE_QUEUED: if (disk_access_write(disk_pdrv, page, curr_lba, 1)) { LOG_ERR("!!!!! Disk Write Error %u !!!!!", curr_lba); } thread_memory_write_done(); break; default: LOG_ERR("XXXXXX thread_op %d ! XXXXX", thread_op); } } } /** * @brief Initialize USB mass storage setup * * This routine is called to reset the USB device controller chip to a * quiescent state. Also it initializes the backing storage and initializes * the mass storage protocol state. * * @param dev device struct. * * @return negative errno code on fatal failure, 0 otherwise */ static int mass_storage_init(void) { uint32_t block_size = 0U; if (disk_access_init(disk_pdrv) != 0) { LOG_ERR("Storage init ERROR !!!! - Aborting USB init"); return 0; } if (disk_access_ioctl(disk_pdrv, DISK_IOCTL_GET_SECTOR_COUNT, &block_count)) { LOG_ERR("Unable to get sector count - Aborting USB init"); return 0; } if (disk_access_ioctl(disk_pdrv, DISK_IOCTL_GET_SECTOR_SIZE, &block_size)) { LOG_ERR("Unable to get sector size - Aborting USB init"); return 0; } if (block_size != BLOCK_SIZE) { LOG_ERR("Block Size reported by the storage side is " "different from Mass Storage Class page Buffer - " "Aborting"); return 0; } LOG_INF("Sect Count %u", block_count); LOG_INF("Memory Size %llu", (uint64_t) block_count * BLOCK_SIZE); msd_state_machine_reset(); msd_init(); k_sem_init(&disk_wait_sem, 0, 1); /* Start a thread to offload disk ops */ k_thread_create(&mass_thread_data, mass_thread_stack, CONFIG_MASS_STORAGE_STACK_SIZE, mass_thread_main, NULL, NULL, NULL, DISK_THREAD_PRIO, 0, K_NO_WAIT); k_thread_name_set(&mass_thread_data, "usb_mass"); return 0; } SYS_INIT(mass_storage_init, APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEVICE);