Storage.h

00001 #pragma once
00002 #include "mbed.h"
00003 #include "FATFileSystem.h"
00004 #include "USBMSD.h"
00005 #include "USBMSD2.h"
00006 #include "StorageInterface.h"
00007 #include "mystring.h"
00008 
00009 class LocalStorage : public FATFileSystem {
00010 public:
00011     LocalStorage(StorageInterface* storage, const char* name = "local");
00012     virtual int disk_read(uint8_t * buffer, uint64_t sector) {
00013         return _storage->storage_read(buffer, sector);
00014     }
00015     virtual int disk_write(const uint8_t * buffer, uint64_t sector) {
00016         return _storage->storage_write(buffer, sector);
00017     }
00018     virtual uint64_t disk_sectors() {
00019         return _storage->storage_sectors();
00020     }
00021     static bool find(char* buf, size_t size, const char* dirname, const char* pat);
00022 
00023 private:
00024     StorageInterface* _storage;
00025     const char* _name;
00026 };
00027 
00028 class USBStorage : public USBMSD {
00029 public:
00030     USBStorage(StorageInterface* storage): _storage(storage) {
00031         connect();
00032     }
00033     virtual int disk_read(uint8_t * data, uint64_t block) {
00034         return _storage->storage_read(data, block);
00035     }
00036     virtual int disk_write(const uint8_t * data, uint64_t block) {
00037         return _storage->storage_write(data, block);
00038     }
00039     virtual int disk_initialize() { return 0; }
00040     virtual uint64_t disk_sectors() {
00041         return _storage->storage_sectors();
00042     }
00043     virtual int disk_status() { return 0; }
00044     virtual uint64_t disk_size() {
00045         return _storage->storage_size();
00046     }
00047 
00048 private:
00049     StorageInterface* _storage;
00050 };
00051 
00052 class USBStorage2 : public USBMSD2 {
00053 public:
00054     USBStorage2(StorageInterface* storage): _storage(storage) {
00055         init();
00056         connect();
00057     }
00058     void init() {
00059         block_flag = false;
00060         report_block_count = 0;
00061         report_initialize_count = 0;
00062         report_read_count = 0;
00063         report_write_count = 0;
00064         report_sectors_count = 0;
00065         report_status_count = 0;
00066         report_size_count = 0;
00067     }
00068     virtual int disk_read(uint8_t * data, uint64_t block) {
00069         if (block_flag) {
00070             report_block_count++;
00071             return 1;
00072         }
00073         report_read_count++;
00074         return _storage->storage_read(data, block);
00075     }
00076     virtual int disk_write(const uint8_t * data, uint64_t block) {
00077         if (block_flag) {
00078             report_block_count++;
00079             return 1;
00080         }
00081         report_write_count++;
00082         return _storage->storage_write(data, block);
00083     }
00084     virtual int disk_initialize() {
00085         report_initialize_count++;
00086         return 0;
00087     }
00088     virtual uint64_t disk_sectors() {
00089         report_sectors_count++;
00090         return _storage->storage_sectors();
00091     }
00092     virtual int disk_status() {
00093         report_status_count++;
00094         return 0;
00095     }
00096     virtual uint64_t disk_size() {
00097         report_size_count++;
00098         return _storage->storage_size();
00099     }
00100 
00101     bool block(bool flag) {
00102         if (block_flag != flag) {
00103             block_flag = flag;
00104             return true;
00105         }
00106         return false;
00107     }
00108     __IO bool block_flag;
00109     __IO int report_block_count;
00110     __IO int report_initialize_count;
00111     __IO int report_read_count;
00112     __IO int report_write_count;
00113     __IO int report_sectors_count;
00114     __IO int report_status_count;
00115     __IO int report_size_count;
00116 
00117 private:
00118     StorageInterface* _storage;
00119 };
00120