arduino-esp32-custom-lwip-ppp-enabled/cores/esp32/USBMSC.cpp

// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "USBMSC.h"

#if CONFIG_TINYUSB_MSC_ENABLED

#include "esp32-hal-tinyusb.h"

extern "C" uint16_t tusb_msc_load_descriptor(uint8_t * dst, uint8_t * itf)
{
    uint8_t str_index = tinyusb_add_string_descriptor("TinyUSB MSC");
    uint8_t ep_num = tinyusb_get_free_duplex_endpoint();
    TU_VERIFY (ep_num != 0);
    uint8_t descriptor[TUD_MSC_DESC_LEN] = {
        // Interface number, string index, EP Out & EP In address, EP size
        TUD_MSC_DESCRIPTOR(*itf, str_index, ep_num, (uint8_t)(0x80 | ep_num), 64)
    };
    *itf+=1;
    memcpy(dst, descriptor, TUD_MSC_DESC_LEN);
    return TUD_MSC_DESC_LEN;
}

typedef struct {
    bool media_present;
    uint8_t vendor_id[8];
    uint8_t product_id[16];
    uint8_t product_rev[4];
    uint16_t block_size;
    uint32_t block_count;
    bool (*start_stop)(uint8_t power_condition, bool start, bool load_eject);
    int32_t (*read)(uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize);
    int32_t (*write)(uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize);
} msc_lun_t;

static const uint8_t MSC_MAX_LUN = 3;
static uint8_t MSC_ACTIVE_LUN = 0;
static msc_lun_t msc_luns[MSC_MAX_LUN];

static void cplstr(void *dst, const void * src, size_t max_len){
    if(!src || !dst || !max_len){
        return;
    }
    size_t l = strlen((const char *)src);
    if(l > max_len){
        l = max_len;
    }
    memcpy(dst, src, l);
}

// Invoked when received GET_MAX_LUN request, required for multiple LUNs implementation
uint8_t tud_msc_get_maxlun_cb(void)
{
    log_v("%u", MSC_ACTIVE_LUN);
    return MSC_ACTIVE_LUN;
}

// Invoked when received SCSI_CMD_INQUIRY
// Application fill vendor id, product id and revision with string up to 8, 16, 4 characters respectively
void tud_msc_inquiry_cb(uint8_t lun, uint8_t vendor_id[8], uint8_t product_id[16], uint8_t product_rev[4])
{
    log_v("[%u]", lun);
    cplstr(vendor_id  , msc_luns[lun].vendor_id, 8);
    cplstr(product_id , msc_luns[lun].product_id, 16);
    cplstr(product_rev, msc_luns[lun].product_rev, 4);
}

// Invoked when received Test Unit Ready command.
// return true allowing host to read/write this LUN e.g SD card inserted
bool tud_msc_test_unit_ready_cb(uint8_t lun)
{
    log_v("[%u]: %u", lun, msc_luns[lun].media_present);
    return msc_luns[lun].media_present; // RAM disk is always ready
}

// Invoked when received SCSI_CMD_READ_CAPACITY_10 and SCSI_CMD_READ_FORMAT_CAPACITY to determine the disk size
// Application update block count and block size
void tud_msc_capacity_cb(uint8_t lun, uint32_t* block_count, uint16_t* block_size)
{
    log_v("[%u]", lun);
    if(!msc_luns[lun].media_present){
        *block_count = 0;
        *block_size  = 0;
        return;
    }

    *block_count = msc_luns[lun].block_count;
    *block_size  = msc_luns[lun].block_size;
}

// Invoked when received Start Stop Unit command
// - Start = 0 : stopped power mode, if load_eject = 1 : unload disk storage
// - Start = 1 : active mode, if load_eject = 1 : load disk storage
bool tud_msc_start_stop_cb(uint8_t lun, uint8_t power_condition, bool start, bool load_eject)
{
    log_v("[%u] power: %u, start: %u, eject: %u", lun, power_condition, start, load_eject);
    if(msc_luns[lun].start_stop){
        return msc_luns[lun].start_stop(power_condition, start, load_eject);
    }
    return true;
}

// Callback invoked when received READ10 command.
// Copy disk's data to buffer (up to bufsize) and return number of copied bytes.
int32_t tud_msc_read10_cb(uint8_t lun, uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize)
{
    log_v("[%u], lba: %u, offset: %u, bufsize: %u", lun, lba, offset, bufsize);
    if(!msc_luns[lun].media_present){
        return 0;
    }
    if(msc_luns[lun].read){
        return msc_luns[lun].read(lba, offset, buffer, bufsize);
    }
    return 0;
}

// Callback invoked when received WRITE10 command.
// Process data in buffer to disk's storage and return number of written bytes
int32_t tud_msc_write10_cb(uint8_t lun, uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize)
{
    log_v("[%u], lba: %u, offset: %u, bufsize: %u", lun, lba, offset, bufsize);
    if(!msc_luns[lun].media_present){
        return 0;
    }
    if(msc_luns[lun].write){
        return msc_luns[lun].write(lba, offset, buffer, bufsize);
    }
    return 0;
}

// Callback invoked when received an SCSI command not in built-in list below
// - READ_CAPACITY10, READ_FORMAT_CAPACITY, INQUIRY, MODE_SENSE6, REQUEST_SENSE
// - READ10 and WRITE10 has their own callbacks
int32_t tud_msc_scsi_cb (uint8_t lun, uint8_t const scsi_cmd[16], void* buffer, uint16_t bufsize)
{
    // read10 & write10 has their own callback and MUST not be handled here
    log_v("[%u] cmd: %u, bufsize: %u", lun, scsi_cmd[0], bufsize);

    void const* response = NULL;
    uint16_t resplen = 0;

    // most scsi handled is input
    bool in_xfer = true;
    
    if(!msc_luns[lun].media_present){
        return -1;
    }

    switch (scsi_cmd[0]) {
        case SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
            // Host is about to read/write etc ... better not to disconnect disk
            resplen = 0;
            break;

        default:
            // Set Sense = Invalid Command Operation
            tud_msc_set_sense(lun, SCSI_SENSE_ILLEGAL_REQUEST, 0x20, 0x00);

            // negative means error -> tinyusb could stall and/or response with failed status
            resplen = -1;
            break;
    }

    // return resplen must not larger than bufsize
    if (resplen > bufsize) resplen = bufsize;

    if (response && (resplen > 0)) {
        if (in_xfer) {
            memcpy(buffer, response, resplen);
        } else {
            // SCSI output
        }
    }

    return resplen;
}

USBMSC::USBMSC(){
    if(MSC_ACTIVE_LUN < MSC_MAX_LUN){
        _lun = MSC_ACTIVE_LUN;
        MSC_ACTIVE_LUN++;
        msc_luns[_lun].media_present = false;
        msc_luns[_lun].vendor_id[0] = 0;
        msc_luns[_lun].product_id[0] = 0;
        msc_luns[_lun].product_rev[0] = 0;
        msc_luns[_lun].block_size = 0;
        msc_luns[_lun].block_count = 0;
        msc_luns[_lun].start_stop = NULL;
        msc_luns[_lun].read = NULL;
        msc_luns[_lun].write = NULL;
    }
    if(_lun == 0){
        tinyusb_enable_interface(USB_INTERFACE_MSC, TUD_MSC_DESC_LEN, tusb_msc_load_descriptor);
    }
}

USBMSC::~USBMSC(){
  end();
}

bool USBMSC::begin(uint32_t block_count, uint16_t block_size){
    msc_luns[_lun].block_size = block_size;
    msc_luns[_lun].block_count = block_count;
    if(!msc_luns[_lun].block_size || !msc_luns[_lun].block_count || !msc_luns[_lun].read || !msc_luns[_lun].write){
        return false;
    }
    return true;
}

void USBMSC::end(){
    msc_luns[_lun].media_present = false;
    msc_luns[_lun].vendor_id[0] = 0;
    msc_luns[_lun].product_id[0] = 0;
    msc_luns[_lun].product_rev[0] = 0;
    msc_luns[_lun].block_size = 0;
    msc_luns[_lun].block_count = 0;
    msc_luns[_lun].start_stop = NULL;
    msc_luns[_lun].read = NULL;
    msc_luns[_lun].write = NULL;
}

void USBMSC::vendorID(const char * vid){
    cplstr(msc_luns[_lun].vendor_id, vid, 8);
}

void USBMSC::productID(const char * pid){
    cplstr(msc_luns[_lun].product_id, pid, 16);
}

void USBMSC::productRevision(const char * rev){
    cplstr(msc_luns[_lun].product_rev, rev, 4);
}

void USBMSC::onStartStop(msc_start_stop_cb cb){
    msc_luns[_lun].start_stop = cb;
}

void USBMSC::onRead(msc_read_cb cb){
    msc_luns[_lun].read = cb;
}

void USBMSC::onWrite(msc_write_cb cb){
    msc_luns[_lun].write = cb;
}

void USBMSC::mediaPresent(bool media_present){
    msc_luns[_lun].media_present = media_present;
}

#endif /* CONFIG_TINYUSB_MSC_ENABLED */