Revision 5:eebd06a7ddf0, committed 2014-03-26

Comitter:

jakowisp

Date:

Wed Mar 26 07:45:40 2014 +0000

Parent:

4:a4423c624fed

Commit message:

Setup the library to use both AHBSRAM0 and AHBSRAM1.

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBMSD_RAM.cpp	Wed Mar 26 07:45:40 2014 +0000
@@ -0,0 +1,90 @@
+/** This library is based on the USBMSD_SD library.
+ *  Modifications for using RAM were made by avnisha
+ *  Only modifications doen by Dwayne Dilbeck were to remove the SD functions, and change the RAM location to the Ethernet RAM 
+ */
+
+
+#include "USBMSD_RAM.h"
+#include "mbed_debug.h"
+
+#define SD_COMMAND_TIMEOUT 5000
+#define SD_DBG             0
+#define BLOCKS  32
+#define FS  BLOCKS*512
+
+LocalFileSystem local("local"); 
+
+char    s0[FS] __attribute__((section("AHBSRAM1")));
+char    s1[FS] __attribute__((section("AHBSRAM0")));
+int     status = 1;
+
+USBMSD_RAM::USBMSD_RAM(PinName mosi, PinName miso, PinName sclk, PinName cs) :
+    _spi(mosi, miso, sclk), _cs(cs) {
+    _cs = 1;
+    
+    printf("cons\n");
+    connect();
+}
+
+int USBMSD_RAM::disk_initialize() { 
+
+    printf("ini\n");
+    status--;
+    return 0;
+}
+
+int USBMSD_RAM::disk_write(const uint8_t *buffer, uint64_t block_number) {
+
+//
+// find the correct block and write
+//
+    int offset;
+    int i;
+    char *s;
+    
+    //printf("write\n");
+    if (block_number > (BLOCKS -1)) return 1;
+    offset = 512 * block_number;   
+    if (block_number < FS)
+        s=(char *)&s0;
+    else
+        s=(char *)&s1;
+    for (i = 0; i < 512; i++) {
+        s[offset + i] = buffer[i];  
+    }
+    return 0;
+}
+
+int USBMSD_RAM::disk_read(uint8_t *buffer, uint64_t block_number) {
+
+    int offset;
+    int i;
+    char *s;
+    
+    //printf("read\n");
+    if (block_number > (BLOCKS -1)) return 1;
+    offset = 512 * block_number;   
+    if (block_number < FS)
+        s=(char *)&s0;
+    else
+        s=(char *)&s1;
+    for (i = 0; i < 512; i++) {
+        buffer[i] = s[offset + i];  
+    }
+    return 0;
+}
+
+int USBMSD_RAM::disk_status() { 
+    printf("status\n");
+    return status; 
+}
+
+
+int USBMSD_RAM::disk_sync() { printf("sync\n"); return 0; }
+uint64_t USBMSD_RAM::disk_size() { 
+   printf("size\n"); 
+   printf("Location s0 : %x\n", &s0);
+   printf("Location s1 : %x\n", &s1);
+   return 2*FS;
+}
+uint64_t USBMSD_RAM::disk_sectors() { printf("sectors\n"); return BLOCKS; }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBMSD_RAM.h	Wed Mar 26 07:45:40 2014 +0000
@@ -0,0 +1,87 @@
+/* mbed USBMSD_RAM Library, for providing file access to SD cards
+ * Copyright (c) 2008-2010, sford
+ *
+ * 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.
+ */
+
+#ifndef USBMSD_RAM_H
+#define USBMSD_RAM_H
+
+#include "mbed.h"
+#include "USBMSD.h"
+
+/** Use the SDcard as mass storage device using the USBMSD class
+ *
+ * @code
+ * #include "mbed.h"
+ * #include "USBMSD_RAM.h"
+ *
+ * USBMSD_RAM sd(p5, p6, p7, p8);
+ *
+ * int main() {
+ *   while(1);
+ * }
+ *
+ * @endcode
+ */
+class USBMSD_RAM : public USBMSD {
+public:
+
+    /** Create the File System for accessing an SD Card using SPI
+     *
+     * @param mosi SPI mosi pin connected to SD Card
+     * @param miso SPI miso pin conencted to SD Card
+     * @param sclk SPI sclk pin connected to SD Card
+     * @param cs   DigitalOut pin used as SD Card chip select
+     * @param name The name used to access the virtual filesystem
+     */
+    USBMSD_RAM(PinName mosi, PinName miso, PinName sclk, PinName cs);
+    virtual int disk_initialize();
+    virtual int disk_status();
+    virtual int disk_read(uint8_t * buffer, uint64_t block_number);
+    virtual int disk_write(const uint8_t * buffer, uint64_t block_number);
+    virtual int disk_sync();
+    virtual uint64_t disk_sectors();
+    
+//virtual uint64_t disk_size(){return _sectors*512;};
+    virtual uint64_t disk_size();
+
+protected:
+
+    int _cmd(int cmd, int arg);
+    int _cmdx(int cmd, int arg);
+    int _cmd8();
+    int _cmd58();
+    int initialise_card();
+    int initialise_card_v1();
+    int initialise_card_v2();
+    
+    int _read(uint8_t * buffer, uint32_t length);
+    int _write(const uint8_t *buffer, uint32_t length);
+    uint64_t _sd_sectors();
+    uint64_t _sectors;
+    
+    uint8_t _status;
+    
+    SPI _spi;
+    DigitalOut _cs;
+    int cdv;
+};
+
+#endif

--- a/USBMSD_SD.cpp	Wed Mar 26 07:01:02 2014 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,570 +0,0 @@
-
-#ifdef OLD
-/* mbed Microcontroller Library
- * Copyright (c) 2006-2012 ARM Limited
- *
- * 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.
- */
-/* Introduction
- * ------------
- * SD and MMC cards support a number of interfaces, but common to them all
- * is one based on SPI. This is the one I'm implmenting because it means
- * it is much more portable even though not so performant, and we already
- * have the mbed SPI Interface!
- *
- * The main reference I'm using is Chapter 7, "SPI Mode" of:
- *  http://www.sdcard.org/developers/tech/sdcard/pls/Simplified_Physical_Layer_Spec.pdf
- *
- * SPI Startup
- * -----------
- * The SD card powers up in SD mode. The SPI interface mode is selected by
- * asserting CS low and sending the reset command (CMD0). The card will
- * respond with a (R1) response.
- *
- * CMD8 is optionally sent to determine the voltage range supported, and
- * indirectly determine whether it is a version 1.x SD/non-SD card or
- * version 2.x. I'll just ignore this for now.
- *
- * ACMD41 is repeatedly issued to initialise the card, until "in idle"
- * (bit 0) of the R1 response goes to '0', indicating it is initialised.
- *
- * You should also indicate whether the host supports High Capicity cards,
- * and check whether the card is high capacity - i'll also ignore this
- *
- * SPI Protocol
- * ------------
- * The SD SPI protocol is based on transactions made up of 8-bit words, with
- * the host starting every bus transaction by asserting the CS signal low. The
- * card always responds to commands, data blocks and errors.
- *
- * The protocol supports a CRC, but by default it is off (except for the
- * first reset CMD0, where the CRC can just be pre-calculated, and CMD8)
- * I'll leave the CRC off I think!
- *
- * Standard capacity cards have variable data block sizes, whereas High
- * Capacity cards fix the size of data block to 512 bytes. I'll therefore
- * just always use the Standard Capacity cards with a block size of 512 bytes.
- * This is set with CMD16.
- *
- * You can read and write single blocks (CMD17, CMD25) or multiple blocks
- * (CMD18, CMD25). For simplicity, I'll just use single block accesses. When
- * the card gets a read command, it responds with a response token, and then
- * a data token or an error.
- *
- * SPI Command Format
- * ------------------
- * Commands are 6-bytes long, containing the command, 32-bit argument, and CRC.
- *
- * +---------------+------------+------------+-----------+----------+--------------+
- * | 01 | cmd[5:0] | arg[31:24] | arg[23:16] | arg[15:8] | arg[7:0] | crc[6:0] | 1 |
- * +---------------+------------+------------+-----------+----------+--------------+
- *
- * As I'm not using CRC, I can fix that byte to what is needed for CMD0 (0x95)
- *
- * All Application Specific commands shall be preceded with APP_CMD (CMD55).
- *
- * SPI Response Format
- * -------------------
- * The main response format (R1) is a status byte (normally zero). Key flags:
- *  idle - 1 if the card is in an idle state/initialising
- *  cmd  - 1 if an illegal command code was detected
- *
- *    +-------------------------------------------------+
- * R1 | 0 | arg | addr | seq | crc | cmd | erase | idle |
- *    +-------------------------------------------------+
- *
- * R1b is the same, except it is followed by a busy signal (zeros) until
- * the first non-zero byte when it is ready again.
- *
- * Data Response Token
- * -------------------
- * Every data block written to the card is acknowledged by a byte
- * response token
- *
- * +----------------------+
- * | xxx | 0 | status | 1 |
- * +----------------------+
- *              010 - OK!
- *              101 - CRC Error
- *              110 - Write Error
- *
- * Single Block Read and Write
- * ---------------------------
- *
- * Block transfers have a byte header, followed by the data, followed
- * by a 16-bit CRC. In our case, the data will always be 512 bytes.
- *
- * +------+---------+---------+- -  - -+---------+-----------+----------+
- * | 0xFE | data[0] | data[1] |        | data[n] | crc[15:8] | crc[7:0] |
- * +------+---------+---------+- -  - -+---------+-----------+----------+
- */
-#include "USBMSD_SD.h"
-#include "mbed_debug.h"
-
-#define SD_COMMAND_TIMEOUT 5000
-
-#define SD_DBG             0
-
-USBMSD_SD::USBMSD_SD(PinName mosi, PinName miso, PinName sclk, PinName cs) :
-    _spi(mosi, miso, sclk), _cs(cs) {
-    _cs = 1;
-    
-    //no init
-    _status = 0x01;
-    
-    connect();
-}
-
-#define R1_IDLE_STATE           (1 << 0)
-#define R1_ERASE_RESET          (1 << 1)
-#define R1_ILLEGAL_COMMAND      (1 << 2)
-#define R1_COM_CRC_ERROR        (1 << 3)
-#define R1_ERASE_SEQUENCE_ERROR (1 << 4)
-#define R1_ADDRESS_ERROR        (1 << 5)
-#define R1_PARAMETER_ERROR      (1 << 6)
-
-// Types
-//  - v1.x Standard Capacity
-//  - v2.x Standard Capacity
-//  - v2.x High Capacity
-//  - Not recognised as an SD Card
-#define SDCARD_FAIL 0
-#define SDCARD_V1   1
-#define SDCARD_V2   2
-#define SDCARD_V2HC 3
-
-int USBMSD_SD::initialise_card() {
-    // Set to 100kHz for initialisation, and clock card with cs = 1
-    _spi.frequency(100000);
-    _cs = 1;
-    for (int i = 0; i < 16; i++) {
-        _spi.write(0xFF);
-    }
-    // send CMD0, should return with all zeros except IDLE STATE set (bit 0)
-    if (_cmd(0, 0) != R1_IDLE_STATE) {
-        debug("No disk, or could not put SD card in to SPI idle state\n");
-        return SDCARD_FAIL;
-    }
-    
-    // send CMD8 to determine whther it is ver 2.x
-    int r = _cmd8();
-    if (r == R1_IDLE_STATE) {
-        return initialise_card_v2();
-    } else if (r == (R1_IDLE_STATE | R1_ILLEGAL_COMMAND)) {
-        return initialise_card_v1();
-    } else {
-        debug("Not in idle state after sending CMD8 (not an SD card?)\n");
-        return SDCARD_FAIL;
-    }
-}
-
-int USBMSD_SD::initialise_card_v1() {
-    for (int i = 0; i < SD_COMMAND_TIMEOUT; i++) {
-        _cmd(55, 0);
-        if (_cmd(41, 0) == 0) {
-            cdv = 512;
-            debug_if(SD_DBG, "\n\rInit: SEDCARD_V1\n\r");
-            return SDCARD_V1;
-        }
-    }
-    
-    debug("Timeout waiting for v1.x card\n");
-    return SDCARD_FAIL;
-}
-
-int USBMSD_SD::initialise_card_v2() {
-    for (int i = 0; i < SD_COMMAND_TIMEOUT; i++) {
-        wait_ms(50);
-        _cmd58();
-        _cmd(55, 0);
-        if (_cmd(41, 0x40000000) == 0) {
-            _cmd58();
-            debug_if(SD_DBG, "\n\rInit: SDCARD_V2\n\r");
-            cdv = 1;
-            return SDCARD_V2;
-        }
-    }
-    
-    debug("Timeout waiting for v2.x card\n");
-    return SDCARD_FAIL;
-}
-
-int USBMSD_SD::disk_initialize() {
-    int i = initialise_card();
-    debug_if(SD_DBG, "init card = %d\n", i);
-    _sectors = _sd_sectors();
-    
-    // Set block length to 512 (CMD16)
-    if (_cmd(16, 512) != 0) {
-        debug("Set 512-byte block timed out\n");
-        return 1;
-    }
-    
-    _spi.frequency(5000000); // Set to 5MHz for data transfer
-    
-    // OK
-    _status = 0x00;
-    
-    return 0;
-}
-
-int USBMSD_SD::disk_write(const uint8_t *buffer, uint64_t block_number) {
-    // set write address for single block (CMD24)
-    if (_cmd(24, block_number * cdv) != 0) {
-        return 1;
-    }
-    
-    // send the data block
-    _write(buffer, 512);
-    return 0;
-}
-
-int USBMSD_SD::disk_read(uint8_t *buffer, uint64_t block_number) {
-    // set read address for single block (CMD17)
-    if (_cmd(17, block_number * cdv) != 0) {
-        return 1;
-    }
-    
-    // receive the data
-    _read(buffer, 512);
-    return 0;
-}
-
-int USBMSD_SD::disk_status() { return _status; }
-int USBMSD_SD::disk_sync() { return 0; }
-uint64_t USBMSD_SD::disk_sectors() { return _sectors; }
-
-
-// PRIVATE FUNCTIONS
-int USBMSD_SD::_cmd(int cmd, int arg) {
-    _cs = 0;
-    
-    // send a command
-    _spi.write(0x40 | cmd);
-    _spi.write(arg >> 24);
-    _spi.write(arg >> 16);
-    _spi.write(arg >> 8);
-    _spi.write(arg >> 0);
-    _spi.write(0x95);
-    
-    // wait for the repsonse (response[7] == 0)
-    for (int i = 0; i < SD_COMMAND_TIMEOUT; i++) {
-        int response = _spi.write(0xFF);
-        if (!(response & 0x80)) {
-            _cs = 1;
-            _spi.write(0xFF);
-            return response;
-        }
-    }
-    _cs = 1;
-    _spi.write(0xFF);
-    return -1; // timeout
-}
-int USBMSD_SD::_cmdx(int cmd, int arg) {
-    _cs = 0;
-    
-    // send a command
-    _spi.write(0x40 | cmd);
-    _spi.write(arg >> 24);
-    _spi.write(arg >> 16);
-    _spi.write(arg >> 8);
-    _spi.write(arg >> 0);
-    _spi.write(0x95);
-    
-    // wait for the repsonse (response[7] == 0)
-    for (int i = 0; i < SD_COMMAND_TIMEOUT; i++) {
-        int response = _spi.write(0xFF);
-        if (!(response & 0x80)) {
-            return response;
-        }
-    }
-    _cs = 1;
-    _spi.write(0xFF);
-    return -1; // timeout
-}
-
-
-int USBMSD_SD::_cmd58() {
-    _cs = 0;
-    int arg = 0;
-    
-    // send a command
-    _spi.write(0x40 | 58);
-    _spi.write(arg >> 24);
-    _spi.write(arg >> 16);
-    _spi.write(arg >> 8);
-    _spi.write(arg >> 0);
-    _spi.write(0x95);
-    
-    // wait for the repsonse (response[7] == 0)
-    for (int i = 0; i < SD_COMMAND_TIMEOUT; i++) {
-        int response = _spi.write(0xFF);
-        if (!(response & 0x80)) {
-            int ocr = _spi.write(0xFF) << 24;
-            ocr |= _spi.write(0xFF) << 16;
-            ocr |= _spi.write(0xFF) << 8;
-            ocr |= _spi.write(0xFF) << 0;
-            _cs = 1;
-            _spi.write(0xFF);
-            return response;
-        }
-    }
-    _cs = 1;
-    _spi.write(0xFF);
-    return -1; // timeout
-}
-
-int USBMSD_SD::_cmd8() {
-    _cs = 0;
-    
-    // send a command
-    _spi.write(0x40 | 8); // CMD8
-    _spi.write(0x00);     // reserved
-    _spi.write(0x00);     // reserved
-    _spi.write(0x01);     // 3.3v
-    _spi.write(0xAA);     // check pattern
-    _spi.write(0x87);     // crc
-    
-    // wait for the repsonse (response[7] == 0)
-    for (int i = 0; i < SD_COMMAND_TIMEOUT * 1000; i++) {
-        char response[5];
-        response[0] = _spi.write(0xFF);
-        if (!(response[0] & 0x80)) {
-            for (int j = 1; j < 5; j++) {
-                response[i] = _spi.write(0xFF);
-            }
-            _cs = 1;
-            _spi.write(0xFF);
-            return response[0];
-        }
-    }
-    _cs = 1;
-    _spi.write(0xFF);
-    return -1; // timeout
-}
-
-int USBMSD_SD::_read(uint8_t *buffer, uint32_t length) {
-    _cs = 0;
-    
-    // read until start byte (0xFF)
-    while (_spi.write(0xFF) != 0xFE);
-    
-    // read data
-    for (int i = 0; i < length; i++) {
-        buffer[i] = _spi.write(0xFF);
-    }
-    _spi.write(0xFF); // checksum
-    _spi.write(0xFF);
-    
-    _cs = 1;
-    _spi.write(0xFF);
-    return 0;
-}
-
-int USBMSD_SD::_write(const uint8_t*buffer, uint32_t length) {
-    _cs = 0;
-    
-    // indicate start of block
-    _spi.write(0xFE);
-    
-    // write the data
-    for (int i = 0; i < length; i++) {
-        _spi.write(buffer[i]);
-    }
-    
-    // write the checksum
-    _spi.write(0xFF);
-    _spi.write(0xFF);
-    
-    // check the response token
-    if ((_spi.write(0xFF) & 0x1F) != 0x05) {
-        _cs = 1;
-        _spi.write(0xFF);
-        return 1;
-    }
-    
-    // wait for write to finish
-    while (_spi.write(0xFF) == 0);
-    
-    _cs = 1;
-    _spi.write(0xFF);
-    return 0;
-}
-
-static uint32_t ext_bits(unsigned char *data, int msb, int lsb) {
-    uint32_t bits = 0;
-    uint32_t size = 1 + msb - lsb;
-    for (int i = 0; i < size; i++) {
-        uint32_t position = lsb + i;
-        uint32_t byte = 15 - (position >> 3);
-        uint32_t bit = position & 0x7;
-        uint32_t value = (data[byte] >> bit) & 1;
-        bits |= value << i;
-    }
-    return bits;
-}
-
-uint64_t USBMSD_SD::_sd_sectors() {
-    uint32_t c_size, c_size_mult, read_bl_len;
-    uint32_t block_len, mult, blocknr, capacity;
-    uint32_t hc_c_size;
-    uint64_t blocks;
-    
-    // CMD9, Response R2 (R1 byte + 16-byte block read)
-    if (_cmdx(9, 0) != 0) {
-        debug("Didn't get a response from the disk\n");
-        return 0;
-    }
-    
-    uint8_t csd[16];
-    if (_read(csd, 16) != 0) {
-        debug("Couldn't read csd response from disk\n");
-        return 0;
-    }
-    
-    // csd_structure : csd[127:126]
-    // c_size        : csd[73:62]
-    // c_size_mult   : csd[49:47]
-    // read_bl_len   : csd[83:80] - the *maximum* read block length
-    
-    int csd_structure = ext_bits(csd, 127, 126);
-    
-    switch (csd_structure) {
-        case 0:
-            cdv = 512;
-            c_size = ext_bits(csd, 73, 62);
-            c_size_mult = ext_bits(csd, 49, 47);
-            read_bl_len = ext_bits(csd, 83, 80);
-            
-            block_len = 1 << read_bl_len;
-            mult = 1 << (c_size_mult + 2);
-            blocknr = (c_size + 1) * mult;
-            capacity = blocknr * block_len;
-            blocks = capacity / 512;
-            debug_if(SD_DBG, "\n\rSDCard\n\rc_size: %d \n\rcapacity: %ld \n\rsectors: %lld\n\r", c_size, capacity, blocks);
-            break;
-        
-        case 1:
-            cdv = 1;
-            hc_c_size = ext_bits(csd, 63, 48);
-            blocks = (hc_c_size+1)*1024;
-            debug_if(SD_DBG, "\n\rSDHC Card \n\rhc_c_size: %d\n\rcapacity: %lld \n\rsectors: %lld\n\r", hc_c_size, blocks*512, blocks);
-            break;
-        
-        default:
-            debug("CSD struct unsupported\r\n");
-            return 0;
-    };
-    return blocks;
-}
-
-#endif
-
-
-#define NEW
-#ifdef NEW
-
-#ifdef FOO
-You have to inherit from USBMSD and define ALL the following pure virtual functions:
-virtual int disk_read(uint8_t * data, uint64_t block): function to read a block
-virtual int disk_write(const uint8_t * data, uint64_t block): function to write a block
-virtual int disk_initialize(): function to initialize the memory
-virtual uint64_t disk_sectors(): return the number of blocks
-virtual uint64_t disk_size(): return the memory size
-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)
-All functions names are compatible with the fat filesystem library. So you can imagine using your own class with USBMSD and the fat filesystem library in the same program. Just be careful because there are two different parts which will access the sd card. You can do a master/slave system using disk_status().
-Once these functions defined, you can call connect() (at the end of the constructor of your class for instance) of USBMSD to connect your mass storage device. connect() will first call disk_status() to test the status of the disk. If disk_status() returns 1 (disk not initialized), then disk_initialize() is called. After this step, connect() will collect information such as the number of blocks and the memory size.
-#endif
-
-#include "USBMSD_SD.h"
-#include "mbed_debug.h"
-
-#define SD_COMMAND_TIMEOUT 5000
-#define SD_DBG             0
-#define BLOCKS  32
-#define FS  BLOCKS*512
-
-LocalFileSystem local("local"); 
-
-char    s[FS] __attribute__((section("AHBSRAM1")));
-int     status = 1;
-
-USBMSD_SD::USBMSD_SD(PinName mosi, PinName miso, PinName sclk, PinName cs) :
-    _spi(mosi, miso, sclk), _cs(cs) {
-    _cs = 1;
-    
-    printf("cons\n");
-    connect();
-}
-
-int USBMSD_SD::disk_initialize() { 
-
-    printf("ini\n");
-    status--;
-    return 0;
-}
-
-int USBMSD_SD::disk_write(const uint8_t *buffer, uint64_t block_number) {
-
-//
-// find the correct block and write
-//
-    int offset;
-    int i;
-    
-    //printf("write\n");
-    if (block_number > (BLOCKS -1)) return 1;
-    offset = 512 * block_number;   
-    for (i = 0; i < 512; i++) {
-        s[offset + i] = buffer[i];  
-    }
-    return 0;
-}
-
-int USBMSD_SD::disk_read(uint8_t *buffer, uint64_t block_number) {
-
-    int offset;
-    int i;
-    
-    //printf("read\n");
-    if (block_number > (BLOCKS -1)) return 1;
-    offset = 512 * block_number;   
-    for (i = 0; i < 512; i++) {
-        buffer[i] = s[offset + i];  
-    }
-    return 0;
-}
-
-int USBMSD_SD::disk_status() { 
-    printf("status\n");
-    return status; 
-}
-
-
-int USBMSD_SD::disk_sync() { printf("sync\n"); return 0; }
-uint64_t USBMSD_SD::disk_size() { 
-   printf("size\n"); 
-   printf("Location: %x\n", &s);
-   return FS;
-}
-uint64_t USBMSD_SD::disk_sectors() { printf("sectors\n"); return BLOCKS; }
-
-
-
-#endif
\ No newline at end of file

--- a/USBMSD_SD.h	Wed Mar 26 07:01:02 2014 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,87 +0,0 @@
-/* mbed USBMSD_SD Library, for providing file access to SD cards
- * Copyright (c) 2008-2010, sford
- *
- * 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.
- */
-
-#ifndef USBMSD_SD_H
-#define USBMSD_SD_H
-
-#include "mbed.h"
-#include "USBMSD.h"
-
-/** Use the SDcard as mass storage device using the USBMSD class
- *
- * @code
- * #include "mbed.h"
- * #include "USBMSD_SD.h"
- *
- * USBMSD_SD sd(p5, p6, p7, p8);
- *
- * int main() {
- *   while(1);
- * }
- *
- * @endcode
- */
-class USBMSD_SD : public USBMSD {
-public:
-
-    /** Create the File System for accessing an SD Card using SPI
-     *
-     * @param mosi SPI mosi pin connected to SD Card
-     * @param miso SPI miso pin conencted to SD Card
-     * @param sclk SPI sclk pin connected to SD Card
-     * @param cs   DigitalOut pin used as SD Card chip select
-     * @param name The name used to access the virtual filesystem
-     */
-    USBMSD_SD(PinName mosi, PinName miso, PinName sclk, PinName cs);
-    virtual int disk_initialize();
-    virtual int disk_status();
-    virtual int disk_read(uint8_t * buffer, uint64_t block_number);
-    virtual int disk_write(const uint8_t * buffer, uint64_t block_number);
-    virtual int disk_sync();
-    virtual uint64_t disk_sectors();
-    
-//virtual uint64_t disk_size(){return _sectors*512;};
-    virtual uint64_t disk_size();
-
-protected:
-
-    int _cmd(int cmd, int arg);
-    int _cmdx(int cmd, int arg);
-    int _cmd8();
-    int _cmd58();
-    int initialise_card();
-    int initialise_card_v1();
-    int initialise_card_v2();
-    
-    int _read(uint8_t * buffer, uint32_t length);
-    int _write(const uint8_t *buffer, uint32_t length);
-    uint64_t _sd_sectors();
-    uint64_t _sectors;
-    
-    uint8_t _status;
-    
-    SPI _spi;
-    DigitalOut _cs;
-    int cdv;
-};
-
-#endif