Revision 0:3f8692709f00, committed 2017-12-14

Comitter:

Lightsource

Date:

Thu Dec 14 19:05:32 2017 +0000

Commit message:

Try to wrap the BSP SD-card functions for blockdevice class, although not functional yet.

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/BD_DISCO_F746NG.cpp	Thu Dec 14 19:05:32 2017 +0000
@@ -0,0 +1,124 @@
+#include "BD_DISCO_F746NG.h"
+
+
+BD_DISCO_F746NG::BD_DISCO_F746NG(bd_size_t block)
+    : _read_size(block), _program_size(block), _erase_size(block)
+    , _blocks(0)
+{
+    //MBED_ASSERT(_count * _erase_size == size);
+}
+
+BD_DISCO_F746NG::BD_DISCO_F746NG(bd_size_t read, bd_size_t program, bd_size_t erase)
+    : _read_size(read), _program_size(program), _erase_size(erase)
+    , _blocks(0)
+{
+    //MBED_ASSERT(_count * _erase_size == size);
+    Timeout = 100;
+}
+
+BD_DISCO_F746NG::~BD_DISCO_F746NG()
+{
+    BSP_SD_DeInit();
+    /*
+    if (_blocks) {
+        for (size_t i = 0; i < _count; i++) {
+            free(_blocks[i]);
+        }
+
+        delete[] _blocks;
+        _blocks = 0;
+    }
+    */
+}
+
+int BD_DISCO_F746NG::init()
+{
+    Timeout = 100;
+    bool result;
+
+    _SD_state = BSP_SD_Init();
+
+    if(_SD_state != MSD_OK){
+        if(_SD_state == MSD_ERROR_SD_NOT_PRESENT){
+            return BD_ERROR_DEVICE_ERROR;
+        } else {
+            return BD_ERROR_DEVICE_ERROR;
+        }
+    } else {  
+        BSP_SD_GetCardInfo(&_currentCardInfo);
+        //_blocksize = _currentCardInfo.BlockSize;
+        _blocksize = 512;
+        return BD_ERROR_OK;
+    }
+/*
+    if (!_blocks) {
+        _blocks = new uint8_t*[_count];
+        for (size_t i = 0; i < _count; i++) {
+            _blocks[i] = 0;
+        }
+    }
+*/
+// return BD_ERROR_OK;
+}
+
+int BD_DISCO_F746NG::deinit()
+{
+    return BSP_SD_DeInit();
+/*
+    MBED_ASSERT(_blocks != NULL);
+    // Memory is lazily cleaned up in destructor to allow
+    // data to live across de/reinitialization
+*/
+//    return BD_ERROR_OK;
+}
+
+bd_size_t BD_DISCO_F746NG::get_read_size() const
+{
+    //MBED_ASSERT(_blocks != NULL);
+    return _read_size;
+}
+
+bd_size_t BD_DISCO_F746NG::get_program_size() const
+{
+    //MBED_ASSERT(_blocks != NULL);
+    return _program_size;
+}
+
+bd_size_t BD_DISCO_F746NG::get_erase_size() const
+{
+    //MBED_ASSERT(_blocks != NULL);
+    return _erase_size;
+}
+
+bd_size_t BD_DISCO_F746NG::size() const
+{
+    //MBED_ASSERT(_blocks != NULL);
+    //return (_currentCardInfo.BlockNbr*2) * _blocksize;
+    return 128 * _blocksize;
+}
+
+int BD_DISCO_F746NG::read(void *b, bd_addr_t addr, bd_size_t size)
+{
+    int result;
+    uint32_t nblocks = (uint32_t)size / _blocksize;
+    result = BSP_SD_ReadBlocks((uint32_t *)b, (uint32_t)addr, nblocks, Timeout);
+    return result;
+}
+
+int BD_DISCO_F746NG::program(const void *b, bd_addr_t addr, bd_size_t size)
+{
+    int result;
+    uint32_t nblocks = (uint32_t)size / _blocksize;
+    result = BSP_SD_WriteBlocks((uint32_t *)b, (uint32_t)addr, nblocks, Timeout);
+    return result;
+}
+
+int BD_DISCO_F746NG::erase(bd_addr_t addr, bd_size_t size)
+{
+    int result;
+    uint32_t StartAddr = addr;
+    uint32_t EndAddr = StartAddr + size; 
+    result = BSP_SD_Erase(StartAddr, EndAddr);
+
+    return result;
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/BD_DISCO_F746NG.h	Thu Dec 14 19:05:32 2017 +0000
@@ -0,0 +1,97 @@
+#include "BlockDevice.h"
+#include "stm32746g_discovery_sd.h"
+#include "mbed.h"
+
+
+class BD_DISCO_F746NG : public BlockDevice
+{
+public:
+    BD_DISCO_F746NG(bd_size_t block=512);
+    /** Lifetime of the memory block device
+     *
+     * @param size      Size of the Block Device in bytes
+     * @param read      Minimum read size required in bytes
+     * @param program   Minimum program size required in bytes
+     * @param erase     Minimum erase size required in bytes
+     */
+    BD_DISCO_F746NG(bd_size_t read, bd_size_t program, bd_size_t erase);
+    virtual ~BD_DISCO_F746NG();
+
+    /** Initialize a block device
+     *
+     *  @return         0 on success or a negative error code on failure
+     */
+    virtual int init();
+
+    /** Deinitialize a block device
+     *
+     *  @return         0 on success or a negative error code on failure
+     */
+    virtual int deinit();
+
+    /** Read blocks from a block device
+     *
+     *  @param buffer   Buffer to read blocks into
+     *  @param addr     Address of block to begin reading from
+     *  @param size     Size to read in bytes, must be a multiple of read block size
+     *  @return         0 on success, negative error code on failure
+     */
+    virtual int read(void *buffer, bd_addr_t addr, bd_size_t size);
+
+    /** Program blocks to a block device
+     *
+     *  The blocks must have been erased prior to being programmed
+     *
+     *  @param buffer   Buffer of data to write to blocks
+     *  @param addr     Address of block to begin writing to
+     *  @param size     Size to write in bytes, must be a multiple of program block size
+     *  @return         0 on success, negative error code on failure
+     */
+    virtual int program(const void *buffer, bd_addr_t addr, bd_size_t size);
+
+    /** Erase blocks on a block device
+     *
+     *  The state of an erased block is undefined until it has been programmed
+     *
+     *  @param addr     Address of block to begin erasing
+     *  @param size     Size to erase in bytes, must be a multiple of erase block size
+     *  @return         0 on success, negative error code on failure
+     */
+    virtual int erase(bd_addr_t addr, bd_size_t size);
+
+    /** Get the size of a readable block
+     *
+     *  @return         Size of a readable block in bytes
+     */
+    virtual bd_size_t get_read_size() const;
+
+    /** Get the size of a programable block
+     *
+     *  @return         Size of a programable block in bytes
+     */
+    virtual bd_size_t get_program_size() const;
+
+    /** Get the size of a eraseable block
+     *
+     *  @return         Size of a eraseable block in bytes
+     */
+    virtual bd_size_t get_erase_size() const;
+
+    /** Get the total size of the underlying device
+     *
+     *  @return         Size of the underlying device in bytes
+     */
+    virtual bd_size_t size() const;
+
+private:
+    uint32_t Timeout; 
+    bd_size_t _read_size;
+    bd_size_t _program_size;
+    bd_size_t _erase_size;
+    bd_size_t _count;
+    bd_size_t _blocksize;
+    bd_size_t _size;
+    BSP_SD_CardInfo _currentCardInfo;
+    uint8_t _SD_state;
+    uint8_t **_blocks;
+};