re-enabling serial

[clinton/Smoothieware.git] / gcc4mbed / samples / MSTest / USBDevice / USBMSD / USBMSD.h

/* Copyright (c) 2010-2011 mbed.org, MIT License\r
*\r
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software\r
* and associated documentation files (the "Software"), to deal in the Software without\r
* restriction, including without limitation the rights to use, copy, modify, merge, publish,\r
* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the\r
* Software is furnished to do so, subject to the following conditions:\r
*\r
* The above copyright notice and this permission notice shall be included in all copies or\r
* substantial portions of the Software.\r
*\r
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING\r
* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\r
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
*/\r
\r
\r
#ifndef USBMSD_H\r
#define USBMSD_H\r
\r
/* These headers are included for child class. */\r
#include "USBEndpoints.h"\r
#include "USBDescriptor.h"\r
#include "USBDevice_Types.h"\r
\r
#include "USBDevice.h"\r
\r
#ifdef __GNUC__\r
    /* Packing for structs in GCC. */\r
    #define PACK_STRUCT_STRUCT __attribute__((packed))\r
    #define PACK_STRUCT_BEGIN\r
    #define PACK_STRUCT_END\r
#else /* !__GNUC__ */\r
    /* Packing for structs in ARM compiler. */\r
    #define PACK_STRUCT_STRUCT\r
    #define PACK_STRUCT_BEGIN __packed\r
    #define PACK_STRUCT_END\r
#endif /* __GNUC__ */\r
\r
/**\r
 * USBMSD class: generic class in order to use all kinds of blocks storage chip\r
 *\r
 * Introduction\r
 *\r
 * The USBMSD implements the MSD protocol. It permits to access a memory chip (flash, sdcard,...)\r
 * from a computer over USB. But this class doesn't work standalone, you need to subclass this class\r
 * and define virtual functions which are called in USBMSD.\r
 *\r
 * How to use this class with your chip ?\r
 *\r
 * You have to inherit and define some pure virtual functions (mandatory step):\r
 *   - virtual int disk_read(char * data, int block): function to read a block\r
 *   - virtual int disk_write(const char * data, int block): function to write a block\r
 *   - virtual int disk_initialize(): function to initialize the memory\r
 *   - virtual int disk_sectors(): return the number of blocks\r
 *   - virtual int disk_size(): return the memory size\r
 *   - virtual int disk_status(): return the status of the storage chip (0: OK, 1: not initialized, 2: no medium in the drive, 4: write protection)\r
 *\r
 * All functions names are compatible with the fat filesystem library. So you can imagine using your own class with\r
 * USBMSD and the fat filesystem library in the same program. Just be careful because there are two different parts which\r
 * will access the sd card. You can do a master/slave system using the disk_status method.\r
 *\r
 * Once these functions defined, you can call connect() (at the end of the constructor of your class for instance)\r
 * of USBMSD to connect your mass storage device. connect() will first call disk_status() to test the status of the disk.\r
 * If disk_status() returns 1 (disk not initialized), then disk_initialize() is called. After this step, connect() will collect information\r
 * such as the number of blocks and the memory size.\r
 */\r
class USBMSD: public USBDevice {\r
public:\r
\r
    /**\r
    * Constructor\r
    *\r
    * @param vendor_id Your vendor_id\r
    * @param product_id Your product_id\r
    * @param product_release Your preoduct_release\r
    */\r
    USBMSD(uint16_t vendor_id = 0x0703, uint16_t product_id = 0x0104, uint16_t product_release = 0x0001);\r
\r
    /**\r
    * Connect the USB MSD device. Establish disk initialization before really connect the device.\r
    *\r
    * @returns true if successful\r
    */\r
    bool connect();\r
\r
\r
protected:\r
\r
    /*\r
    * read a block on a storage chip\r
    *\r
    * @param data pointer where will be stored read data\r
    * @param block block number\r
    * @returns 0 if successful\r
    */\r
    virtual int disk_read(char * data, int block) = 0;\r
\r
    /*\r
    * write a block on a storage chip\r
    *\r
    * @param data data to write\r
    * @param block block number\r
    * @returns 0 if successful\r
    */\r
    virtual int disk_write(const char * data, int block) = 0;\r
\r
    /*\r
    * Disk initilization\r
    */\r
    virtual int disk_initialize() = 0;\r
\r
    /*\r
    * Return the number of blocks\r
    *\r
    * @returns number of blocks\r
    */\r
    virtual int disk_sectors() = 0;\r
\r
    /*\r
    * Return memory size\r
    *\r
    * @returns memory size\r
    */\r
    virtual int disk_size() = 0;\r
\r
\r
    /*\r
    * To check the status of the storage chip\r
    *\r
    * @returns status: 0: OK, 1: disk not initialized, 2: no medium in the drive, 4: write protected\r
    */\r
    virtual int disk_status() = 0;\r
\r
    /*\r
    * Get string product descriptor\r
    *\r
    * @returns pointer to the string product descriptor\r
    */\r
    virtual uint8_t * stringIproductDesc();\r
\r
    /*\r
    * Get string interface descriptor\r
    *\r
    * @returns pointer to the string interface descriptor\r
    */\r
    virtual uint8_t * stringIinterfaceDesc();\r
\r
    /*\r
    * Get configuration descriptor\r
    *\r
    * @returns pointer to the configuration descriptor\r
    */\r
    virtual uint8_t * configurationDesc();\r
\r
    /*\r
    * Callback called when a packet is received\r
    */\r
    virtual bool EP2_OUT_callback();\r
\r
    /*\r
    * Callback called when a packet has been sent\r
    */\r
    virtual bool EP2_IN_callback();\r
\r
    /*\r
    * Set configuration of device. Add endpoints\r
    */\r
    virtual bool USBCallback_setConfiguration(uint8_t configuration);\r
\r
    /*\r
    * Callback called to process class specific requests\r
    */\r
    virtual bool USBCallback_request();\r
\r
\r
private:\r
\r
    // MSC Bulk-only Stage\r
    enum Stage {\r
        READ_CBW,     // wait a CBW\r
        ERROR,        // error\r
        PROCESS_CBW,  // process a CBW request\r
        SEND_CSW,     // send a CSW\r
        WAIT_CSW,     // wait that a CSW has been effectively sent\r
    };\r
\r
    // Bulk-only CBW\r
    typedef PACK_STRUCT_BEGIN struct {\r
        uint32_t Signature;\r
        uint32_t Tag;\r
        uint32_t DataLength;\r
        uint8_t  Flags;\r
        uint8_t  LUN;\r
        uint8_t  CBLength;\r
        uint8_t  CB[16];\r
    } PACK_STRUCT_STRUCT CBW;\r
\r
    // Bulk-only CSW\r
    typedef PACK_STRUCT_BEGIN struct {\r
        uint32_t Signature;\r
        uint32_t Tag;\r
        uint32_t DataResidue;\r
        uint8_t  Status;\r
    } PACK_STRUCT_STRUCT CSW;\r
\r
    //state of the bulk-only state machine\r
    Stage stage;\r
\r
    // current CBW\r
    CBW cbw;\r
\r
    // CSW which will be sent\r
    CSW csw;\r
\r
    // addr where will be read or written data\r
    uint32_t addr;\r
\r
    // length of a reading or writing\r
    uint32_t length;\r
\r
    // memory OK (after a memoryVerify)\r
    bool memOK;\r
\r
    // cache in RAM before writing in memory. Useful also to read a block.\r
    uint8_t * page;\r
\r
    int BlockSize;\r
    int MemorySize;\r
    int BlockCount;\r
\r
    void CBWDecode(uint8_t * buf, uint16_t size);\r
    void sendCSW (void);\r
    bool inquiryRequest (void);\r
    bool write (uint8_t * buf, uint16_t size);\r
    bool readFormatCapacity();\r
    bool readCapacity (void);\r
    bool infoTransfer (void);\r
    void memoryRead (void);\r
    bool modeSense6 (void);\r
    void testUnitReady (void);\r
    bool requestSense (void);\r
    void memoryVerify (uint8_t * buf, uint16_t size);\r
    void memoryWrite (uint8_t * buf, uint16_t size);\r
    void reset();\r
    void fail();\r
};\r
\r
#endif