Add 'components/storage/blockdevice/COMPONENT_FLASHIAP/' from commit '8f1ac821f1c411986b8533cbf4878ea9b3fe5efb'

git-subtree-dir: components/storage/blockdevice/COMPONENT_FLASHIAP
git-subtree-mainline: 9a0844a
git-subtree-split: 8f1ac82

Author: Yossi Levy

components/storage/blockdevice/COMPONENT_FLASHIAP/.mbedignore

@@ -0,0 +1,2 @@
+util/*
+

components/storage/blockdevice/COMPONENT_FLASHIAP/FlashIAPBlockDevice.cpp

@@ -0,0 +1,227 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2016 ARM Limited
+ *
+ * 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.
+ */
+
+#ifdef DEVICE_FLASH
+
+#include "FlashIAPBlockDevice.h"
+#include "mbed_critical.h"
+
+#include "mbed.h"
+
+#include <inttypes.h>
+
+#define FLASHIAP_READ_SIZE 1
+
+// Debug available
+#ifndef FLASHIAP_DEBUG
+#define FLASHIAP_DEBUG      0
+#endif
+
+#if FLASHIAP_DEBUG
+#define DEBUG_PRINTF(...) printf(__VA_ARGS__)
+#else
+#define DEBUG_PRINTF(...)
+#endif
+
+FlashIAPBlockDevice::FlashIAPBlockDevice()
+    : _flash(), _base(0), _size(0), _is_initialized(false), _init_ref_count(0)
+{
+    DEBUG_PRINTF("FlashIAPBlockDevice: %" PRIX32 " %" PRIX32 "\r\n", address, size);
+}
+
+FlashIAPBlockDevice::FlashIAPBlockDevice(uint32_t address, uint32_t)
+    : _flash(), _base(0), _size(0), _is_initialized(false), _init_ref_count(0)
+{
+
+}
+
+FlashIAPBlockDevice::~FlashIAPBlockDevice()
+{
+    deinit();
+}
+
+int FlashIAPBlockDevice::init()
+{
+    DEBUG_PRINTF("init\r\n");
+
+    if (!_is_initialized) {
+        _init_ref_count = 0;
+    }
+
+    uint32_t val = core_util_atomic_incr_u32(&_init_ref_count, 1);
+
+    if (val != 1) {
+        return BD_ERROR_OK;
+    }
+
+    int ret = _flash.init();
+
+    if (ret) {
+        return ret;
+    }
+
+    _base = _flash.get_flash_start();
+    _size = _flash.get_flash_size();
+
+    _is_initialized = true;
+    return ret;
+}
+
+int FlashIAPBlockDevice::deinit()
+{
+    DEBUG_PRINTF("deinit\r\n");
+
+    if (!_is_initialized) {
+        _init_ref_count = 0;
+        return 0;
+    }
+
+    uint32_t val = core_util_atomic_decr_u32(&_init_ref_count, 1);
+
+    if (val) {
+        return 0;
+    }
+
+    _is_initialized = false;
+
+    return _flash.deinit();
+}
+
+int FlashIAPBlockDevice::read(void *buffer,
+                              bd_addr_t virtual_address,
+                              bd_size_t size)
+{
+    DEBUG_PRINTF("read: %" PRIX64 " %" PRIX64 "\r\n", virtual_address, size);
+
+    /* Default to error return code; success must be set explicitly. */
+    int result = BD_ERROR_DEVICE_ERROR;
+
+    /* Check that the address and size are properly aligned and fit. */
+    if (_is_initialized && is_valid_read(virtual_address, size)) {
+
+        /* Convert virtual address to the physical address for the device. */
+        bd_addr_t physical_address = _base + virtual_address;
+
+        /* Read data using the internal flash driver. */
+        result = _flash.read(buffer, physical_address, size);
+
+        DEBUG_PRINTF("physical: %" PRIX64 "\r\n", physical_address);
+    }
+
+    return result;
+}
+
+int FlashIAPBlockDevice::program(const void *buffer,
+                                 bd_addr_t virtual_address,
+                                 bd_size_t size)
+{
+    DEBUG_PRINTF("program: %" PRIX64 " %" PRIX64 "\r\n", virtual_address, size);
+
+    /* Default to error return code; success must be set explicitly. */
+    int result = BD_ERROR_DEVICE_ERROR;
+
+    /* Check that the address and size are properly aligned and fit. */
+    if (_is_initialized && is_valid_program(virtual_address, size)) {
+
+        /* Convert virtual address to the physical address for the device. */
+        bd_addr_t physical_address = _base + virtual_address;
+
+        /* Write data using the internal flash driver. */
+        result = _flash.program(buffer, physical_address, size);
+
+        DEBUG_PRINTF("physical: %" PRIX64 " %" PRIX64 "\r\n",
+                     physical_address,
+                     size);
+    }
+
+    return result;
+}
+
+int FlashIAPBlockDevice::erase(bd_addr_t virtual_address,
+                               bd_size_t size)
+{
+    DEBUG_PRINTF("erase: %" PRIX64 " %" PRIX64 "\r\n", virtual_address, size);
+
+    /* Default to error return code; success must be set explicitly. */
+    int result = BD_ERROR_DEVICE_ERROR;
+
+    /* Check that the address and size are properly aligned and fit. */
+    if (_is_initialized && is_valid_erase(virtual_address, size)) {
+
+        /* Convert virtual address to the physical address for the device. */
+        bd_addr_t physical_address = _base + virtual_address;
+
+        /* Erase sector */
+        result = _flash.erase(physical_address, size);
+    }
+
+    return result;
+}
+
+bd_size_t FlashIAPBlockDevice::get_read_size() const
+{
+    DEBUG_PRINTF("get_read_size: %d\r\n", FLASHIAP_READ_SIZE);
+
+    return FLASHIAP_READ_SIZE;
+}
+
+bd_size_t FlashIAPBlockDevice::get_program_size() const
+{
+    if (!_is_initialized) {
+        return 0;
+    }
+
+    uint32_t page_size = _flash.get_page_size();
+
+    DEBUG_PRINTF("get_program_size: %" PRIX32 "\r\n", page_size);
+
+    return page_size;
+}
+
+bd_size_t FlashIAPBlockDevice::get_erase_size() const
+{
+    if (!_is_initialized) {
+        return 0;
+    }
+
+    uint32_t erase_size = _flash.get_sector_size(_base);
+
+    DEBUG_PRINTF("get_erase_size: %" PRIX32 "\r\n", erase_size);
+
+    return erase_size;
+}
+
+bd_size_t FlashIAPBlockDevice::get_erase_size(bd_addr_t addr) const
+{
+    if (!_is_initialized) {
+        return 0;
+    }
+
+    uint32_t erase_size = _flash.get_sector_size(_base + addr);
+
+    DEBUG_PRINTF("get_erase_size: %" PRIX32 "\r\n", erase_size);
+
+    return erase_size;
+}
+
+bd_size_t FlashIAPBlockDevice::size() const
+{
+    DEBUG_PRINTF("size: %" PRIX64 "\r\n", _size);
+
+    return _size;
+}
+
+#endif /* DEVICE_FLASH */

components/storage/blockdevice/COMPONENT_FLASHIAP/FlashIAPBlockDevice.h

@@ -0,0 +1,128 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2016 ARM Limited
+ *
+ * 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 MBED_FLASHIAP_BLOCK_DEVICE_H
+#define MBED_FLASHIAP_BLOCK_DEVICE_H
+
+#ifdef DEVICE_FLASH
+
+#include "BlockDevice.h"
+#include <mbed.h>
+
+/** BlockDevice using the FlashIAP API
+ *
+ *  @code
+ *  #include "mbed.h"
+ *  #include "FlashIAPBlockDevice.h"
+ *
+ */
+class FlashIAPBlockDevice : public BlockDevice {
+public:
+    /** Creates a FlashIAPBlockDevice **/
+    FlashIAPBlockDevice();
+
+    MBED_DEPRECATED("Please use default constructor instead")
+    FlashIAPBlockDevice(uint32_t address, uint32_t size = 0);
+
+    virtual ~FlashIAPBlockDevice();
+
+    /** 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 write blocks to
+     *  @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
+     *  @note Must be a multiple of the read size
+     */
+    virtual bd_size_t get_program_size() const;
+
+    /** Get the size of a eraseable block
+     *
+     *  @return         Size of a eraseable block in bytes
+     *  @note Must be a multiple of the program size
+     */
+    virtual bd_size_t get_erase_size() const;
+
+    /** Get the size of an erasable block given address
+     *
+     *  @param addr     Address within the erasable block
+     *  @return         Size of an erasable block in bytes
+     *  @note Must be a multiple of the program size
+     */
+    virtual bd_size_t get_erase_size(bd_addr_t addr) const;
+
+    /** Get the total size of the underlying device
+     *
+     *  @return         Size of the underlying device in bytes
+     */
+    virtual bd_size_t size() const;
+
+private:
+    // Device configuration
+    FlashIAP _flash;
+    bd_addr_t _base;
+    bd_size_t _size;
+    bool _is_initialized;
+    uint32_t _init_ref_count;
+};
+
+#endif /* DEVICE_FLASH */
+#endif /* MBED_FLASHIAP_BLOCK_DEVICE_H */