USBMSD.h

/*
 * Copyright (c) 2018-2019, Arm Limited and affiliates.
 * SPDX-License-Identifier: Apache-2.0
 *
 * 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.
 */
 
#ifndef USBMSD_H
#define USBMSD_H
 
/* These headers are included for child class. */
#include "USBDescriptor.h"
#include "USBDevice_Types.h"
#include "platform/Callback.h"
#include "usb/internal/PolledQueue.h"
#include "usb/internal/Task.h"
#include "BlockDevice.h"
#include "rtos/Mutex.h"
 
#include "USBDevice.h"
 
/**
 * \defgroup drivers_USBMSD USBMSD class
 * \ingroup drivers-public-api-usb
 * @{
 */
 
/**
 * USBMSD class: generic class in order to use all kinds of blocks storage chip
 *
 * Introduction
 *
 * USBMSD implements the MSD protocol. It permits to access a block device (flash, SD Card,...)
 * from a computer over USB.
 *
 * @code
 * #include "mbed.h"
 * #include "SDBlockDevice.h"
 * #include "USBMSD.h"
 *
 * SDBlockDevice sd(PTE3, PTE1, PTE2, PTE4);
 * USBMSD usb(&sd);
 *
 * int main() {
 *
 *     while(true) {
 *         usb.process();
 *     }
 *
 *     return 0;
 * }
 * @endcode
 */
class USBMSD: public USBDevice {
public:
 
    /**
    * Constructor
    *
    * This creates a new USBMSD object with the given block device. Connect must be called
    * for the block device to connect.
    *
    * @param bd BlockDevice to mount as a USB drive
    * @param connect_blocking true to perform a blocking connect, false to start in a disconnected state
    * @param vendor_id Your vendor_id
    * @param product_id Your product_id
    * @param product_release Your preoduct_release
    */
    USBMSD(mbed::BlockDevice *bd, bool connect_blocking = true, uint16_t vendor_id = 0x0703, uint16_t product_id = 0x0104, uint16_t product_release = 0x0001);
 
    /**
    * Fully featured constructor
    *
    * Construct this object with the supplied USBPhy and parameters. The user
    * this object is responsible for calling connect() or init().
    *
    * @note Derived classes must use this constructor and call init() or
    * connect() themselves. Derived classes should also call deinit() in
    * their destructor. This ensures that no interrupts can occur when the
    * object is partially constructed or destroyed.
    *
    * @param phy USB phy to use
    * @param bd BlockDevice to mount as a USB drive
    * @param vendor_id Your vendor_id
    * @param product_id Your product_id
    * @param product_release Your preoduct_release
    */
    USBMSD(USBPhy *phy, mbed::BlockDevice *bd, uint16_t vendor_id, uint16_t product_id, uint16_t product_release);
 
    /**
     * Destroy this object
     *
     * Any classes which inherit from this class must call disconnect
     * before this destructor runs.
     */
    virtual ~USBMSD();
 
    /**
    * Connect the USB MSD device.
    *
    * @returns true if successful
    */
    bool connect();
 
    /**
    * Disconnect the USB MSD device.
    */
    void disconnect();
 
    /**
    * Perform USB processing
    */
    void process();
 
    /**
     * Called when USBMSD needs to perform processing
     *
     * @param cb Callback called when USBMSD needs process() to be called
     */
    void attach(mbed::Callback<void()> cb);
 
    /**
    * Check if MSD device was removed/unmounted on the host side.
    *
    * @returns true if device was removed/unmounted on the host side
    */
    bool media_removed();
 
protected:
 
    /*
    * read one or more blocks on a storage chip
    *
    * @param data pointer where will be stored read data
    * @param block starting block number
    * @param count number of blocks to read
    * @returns 0 if successful
    */
    virtual int disk_read(uint8_t *data, uint64_t block, uint8_t count);
 
    /*
    * write one or more blocks on a storage chip
    *
    * @param data data to write
    * @param block starting block number
    * @param count number of blocks to write
    * @returns 0 if successful
    */
    virtual int disk_write(const uint8_t *data, uint64_t block, uint8_t count);
 
    /*
    * Disk initilization
    */
    virtual int disk_initialize();
 
    /*
    * Return the number of blocks
    *
    * @returns number of blocks
    */
    virtual uint64_t disk_sectors();
 
    /*
    * Return memory size
    *
    * @returns memory size
    */
    virtual uint64_t disk_size();
 
    /*
    * To check the status of the storage chip
    *
    * @returns status: 0: OK, 1: disk not initialized, 2: no medium in the drive, 4: write protected
    */
    virtual int disk_status();
 
private:
 
    // MSC Bulk-only Stage
    enum Stage {
        READ_CBW,     // wait a CBW
        ERROR,        // error
        PROCESS_CBW,  // process a CBW request
        SEND_CSW,     // send a CSW
    };
 
    // Bulk-only CBW
    typedef MBED_PACKED(struct)
    {
        uint32_t Signature;
        uint32_t Tag;
        uint32_t DataLength;
        uint8_t  Flags;
        uint8_t  LUN;
        uint8_t  CBLength;
        uint8_t  CB[16];
    } CBW;
 
    // Bulk-only CSW
    typedef MBED_PACKED(struct)
    {
        uint32_t Signature;
        uint32_t Tag;
        uint32_t DataResidue;
        uint8_t  Status;
    } CSW;
 
    // If this class has been initialized
    bool _initialized;
 
    // If msd device has been unmounted by host
    volatile bool _media_removed;
 
    //state of the bulk-only state machine
    Stage _stage;
 
    // current CBW
    CBW _cbw;
 
    // CSW which will be sent
    CSW _csw;
 
    // addr where will be read or written data
    uint32_t _addr;
 
    // length of a reading or writing
    uint32_t _length;
 
    // memory OK (after a memoryVerify)
    bool _mem_ok;
 
    // cache in RAM before writing in memory. Useful also to read a block.
    uint8_t *_page;
 
    int _block_size;
    uint64_t _memory_size;
    uint64_t _block_count;
 
    // endpoints
    usb_ep_t _bulk_in;
    usb_ep_t _bulk_out;
    uint8_t _bulk_in_buf[64];
    uint8_t _bulk_out_buf[64];
    bool _out_ready;
    bool _in_ready;
    uint32_t _bulk_out_size;
 
    // Interrupt to thread deferral
    events::PolledQueue _queue;
    events::Task<void()> _in_task;
    events::Task<void()> _out_task;
    events::Task<void()> _reset_task;
    events::Task<void(const setup_packet_t *)> _control_task;
    events::Task<void()> _configure_task;
 
    mbed::BlockDevice *_bd;
    rtos::Mutex _mutex_init;
    rtos::Mutex _mutex;
 
    // space for config descriptor
    uint8_t _configuration_descriptor[32];
 
    virtual const uint8_t *string_iproduct_desc();
    virtual const uint8_t *string_iinterface_desc();
    virtual const uint8_t *configuration_desc(uint8_t index);
    virtual void callback_set_configuration(uint8_t configuration);
    virtual void callback_set_interface(uint16_t interface, uint8_t alternate);
    virtual void callback_state_change(DeviceState new_state);
    virtual void callback_request(const setup_packet_t *setup);
    virtual void callback_request_xfer_done(const setup_packet_t *setup, bool aborted);
 
    void _isr_out();
    void _isr_in();
 
    void _out();
    void _in();
    void _reset();
    void _control(const setup_packet_t *request);
    void _configure();
 
    void _init();
    void _process();
    void _write_next(uint8_t *data, uint32_t size);
    void _read_next();
 
    void CBWDecode(uint8_t *buf, uint16_t size);
    void sendCSW(void);
    bool inquiryRequest(void);
    bool write(uint8_t *buf, uint16_t size);
    bool readFormatCapacity();
    bool readCapacity(void);
    bool infoTransfer(void);
    void memoryRead(void);
    bool modeSense6(void);
    bool modeSense10(void);
    void testUnitReady(void);
    bool requestSense(void);
    void memoryVerify(uint8_t *buf, uint16_t size);
    void memoryWrite(uint8_t *buf, uint16_t size);
    void msd_reset();
    void fail();
};
 
/** @}*/
 
#endif