I2CEEBlockDevice: Add paging to eight bit mode

boomer41 · boomer41 · commit 8d1978e05cef · 2020-02-17T20:22:18.000+01:00
diff --git a/components/storage/blockdevice/COMPONENT_I2CEE/I2CEEBlockDevice.cpp b/components/storage/blockdevice/COMPONENT_I2CEE/I2CEEBlockDevice.cpp
@@ -62,76 +62,96 @@ int I2CEEBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size)
     // Check the address and size fit onto the chip.
     MBED_ASSERT(is_valid_read(addr, size));
 
-    _i2c->start();
+    auto *charBuffer = reinterpret_cast<char *>(buffer);
 
-    if (!_i2c->write(_i2c_addr | 0)) {
-        return BD_ERROR_DEVICE_ERROR;
-    }
+    auto const handler = [&](const bd_addr_t &pagedStart, const bd_size_t &pagedLength, const uint8_t &page) -> int
+    {
+        _i2c->start();
 
-    if (!_address_is_eight_bit && !_i2c->write((char)(addr >> 8))) {
-        return BD_ERROR_DEVICE_ERROR;
-    }
+        auto const pagedDeviceAddress = get_paged_device_address(page);
 
-    if (!_i2c->write((char)(addr & 0xff))) {
-        return BD_ERROR_DEVICE_ERROR;
-    }
+        if (!_i2c->write(pagedDeviceAddress)) {
+            return BD_ERROR_DEVICE_ERROR;
+        }
 
-    _i2c->stop();
+        if (!_address_is_eight_bit && !_i2c->write((char)(pagedStart >> 8u))) {
+            return BD_ERROR_DEVICE_ERROR;
+        }
 
-    auto err = _sync();
-    if (err) {
-        return err;
-    }
+        if (!_i2c->write((char)(pagedStart & 0xffu))) {
+            return BD_ERROR_DEVICE_ERROR;
+        }
 
-    if (0 != _i2c->read(_i2c_addr, static_cast<char *>(buffer), size)) {
-        return BD_ERROR_DEVICE_ERROR;
-    }
+        _i2c->stop();
 
-    return 0;
+        auto err = _sync();
+        if (err) {
+            return err;
+        }
+
+        if (0 != _i2c->read(_i2c_addr, charBuffer, pagedLength)) {
+            return BD_ERROR_DEVICE_ERROR;
+        }
+
+        charBuffer += size;
+
+        return BD_ERROR_OK;
+    };
+
+    return do_paged(addr, size, handler);
 }
 
 int I2CEEBlockDevice::program(const void *buffer, bd_addr_t addr, bd_size_t size)
 {
     // Check the addr and size fit onto the chip.
     MBED_ASSERT(is_valid_program(addr, size));
 
-    // While we have some more data to write.
-    while (size > 0) {
-        uint32_t off = addr % _block;
-        uint32_t chunk = (off + size < _block) ? size : (_block - off);
+    auto const *charBuffer = reinterpret_cast<char const *>(buffer);
 
-        _i2c->start();
+    auto const handler = [&](const bd_addr_t &pagedStart, const bd_size_t &pagedLength, const uint8_t &page) -> int
+    {
+        // While we have some more data to write.
+        while (size > 0) {
+            uint32_t off = addr % _block;
+            uint32_t chunk = (off + size < _block) ? size : (_block - off);
 
-        if (!_i2c->write(_i2c_addr | 0)) {
-            return BD_ERROR_DEVICE_ERROR;
-        }
+            _i2c->start();
 
-        if (!_address_is_eight_bit && !_i2c->write((char)(addr >> 8))) {
-            return BD_ERROR_DEVICE_ERROR;
-        }
+            auto const pagedDeviceAddress = get_paged_device_address(page);
 
-        if (!_i2c->write((char)(addr & 0xff))) {
-            return BD_ERROR_DEVICE_ERROR;
-        }
+            if (!_i2c->write(pagedDeviceAddress)) {
+                return BD_ERROR_DEVICE_ERROR;
+            }
 
-        for (unsigned i = 0; i < chunk; i++) {
-            _i2c->write(static_cast<const char *>(buffer)[i]);
-        }
+            if (!_address_is_eight_bit && !_i2c->write((char)(pagedStart >> 8u))) {
+                return BD_ERROR_DEVICE_ERROR;
+            }
 
-        _i2c->stop();
+            if (!_i2c->write((char)(addr & 0xffu))) {
+                return BD_ERROR_DEVICE_ERROR;
+            }
 
-        int err = _sync();
+            for (unsigned i = 0; i < chunk; i++) {
+                _i2c->write(charBuffer[i]);
+            }
 
-        if (err) {
-            return err;
+            _i2c->stop();
+
+            int err = _sync();
+
+            if (err) {
+                return err;
+            }
+
+            addr += chunk;
+            size -= chunk;
+            charBuffer += chunk;
         }
 
-        addr += chunk;
-        size -= chunk;
-        buffer = static_cast<const char *>(buffer) + chunk;
-    }
+        return BD_ERROR_OK;
+    };
 
-    return 0;
+    return do_paged(addr, size, handler);
 }
 
 int I2CEEBlockDevice::erase(bd_addr_t addr, bd_size_t size)
@@ -180,3 +200,74 @@ const char *I2CEEBlockDevice::get_type() const
 {
     return "I2CEE";
 }
+
+int I2CEEBlockDevice::do_paged(const bd_addr_t &startAddress,
+                               const bd_size_t &length,
+                               const paged_handler &handler)
+{
+    // This helper is only used for eight bit mode.
+    if (!this->_address_is_eight_bit) {
+        return handler(startAddress, length, 0);
+    }
+
+    auto currentStartAddress = startAddress;
+
+    auto const pageSize = 256;
+    bd_size_t lengthDone = 0;
+    while (lengthDone != length)
+    {
+        /* Integer division => Round down */
+        uint8_t const currentPage = currentStartAddress / 256;
+        bd_addr_t const nextPageBegin = (currentPage + 1) * pageSize;
+        bd_addr_t const currentReadEndAddressExclusive = std::min(nextPageBegin, startAddress + length);
+        bd_size_t const currentLength = currentReadEndAddressExclusive - currentStartAddress;
+        bd_addr_t const pagedBegin = currentStartAddress - (currentPage * pageSize);
+
+        auto const handlerReturn = handler(pagedBegin, currentLength, currentPage);
+        if (handlerReturn != BD_ERROR_OK)
+        {
+            return handlerReturn;
+        }
+
+        currentStartAddress = currentReadEndAddressExclusive;
+        lengthDone += currentLength;
+    }
+
+    return BD_ERROR_OK;
+}
+
+uint8_t I2CEEBlockDevice::get_paged_device_address(const uint8_t &page)
+{
+    if (!this->_address_is_eight_bit)
+    {
+        return this->_i2c_addr;
+    }
+    else
+    {
+        // This method uses a dynamically created bit mask for the page given.
+        // This ensures compatibility with all sizes of ICs.
+        // E. g. the 512K variants have two user address bits and one page bit.
+        // We don't want to forcefully override the two user address bits.
+
+        // Create a mask to cover all bits required to set page
+        // i starts at one because the LSB is used for R/W in I2C
+        uint8_t i = 1;
+        uint8_t addressMask = 0;
+        auto p = page;
+        while (p != 0u)
+        {
+            addressMask |= (1u << i);
+            p >>= 1u;
+            i++;
+        }
+
+        uint8_t pagedDeviceAddress = this->_i2c_addr & static_cast<uint8_t>(~addressMask);
+        // Assert page < 0b111, because we don't have
+        // more bits for page encoding
+        // Don't actually write 0b111, this is a nonstandard extension.
+        MBED_ASSERT(page < 0x7);
+        pagedDeviceAddress |= static_cast<uint8_t>(page << 1u);
+
+        return pagedDeviceAddress;
+    }
+}
diff --git a/components/storage/blockdevice/COMPONENT_I2CEE/I2CEEBlockDevice.h b/components/storage/blockdevice/COMPONENT_I2CEE/I2CEEBlockDevice.h
@@ -66,8 +66,8 @@ class I2CEEBlockDevice : public BlockDevice {
      *  @param block                The page size of the device in bytes, defaults to 32bytes
      *  @param freq                 The frequency of the I2C bus, defaults to 400K.
      *  @param address_is_eight_bit Specifies whether the EEPROM device is using eight bit
-     *                              addresses instead of 16 bit addresses. This should not be needed
-     *                              unless dealing with very cheap devices.
+     *                              addresses instead of 16 bit addresses. This is used for example
+     *                              in AT24C series chips.
      */
     I2CEEBlockDevice(
         PinName sda, PinName scl, uint8_t address,
@@ -83,8 +83,8 @@ class I2CEEBlockDevice : public BlockDevice {
      *  @param block                The page size of the device in bytes, defaults to 32bytes
      *  @param freq                 The frequency of the I2C bus, defaults to 400K.
      *  @param address_is_eight_bit Specifies whether the EEPROM device is using eight bit
-     *                              addresses instead of 16 bit addresses. This should not be needed
-     *                              unless dealing with very cheap devices.
+     *                              addresses instead of 16 bit addresses. This is used for example
+     *                              in AT24C series chips.
      */
     I2CEEBlockDevice(
         mbed::I2C *i2c_obj, uint8_t address,
@@ -180,6 +180,33 @@ class I2CEEBlockDevice : public BlockDevice {
     bool _address_is_eight_bit;
 
     int _sync();
+
+    using paged_handler = std::function<int(const bd_addr_t &address, const bd_size_t &length, const uint8_t &page)>;
+
+    /**
+     * Executes a handler across page boundaries for eight bit mode.
+     * When eight bit mode is disabled, the function does not do paging at all.
+     * When eight bit mode is enabled, this function splits the requested
+     * address space into multiple pages when needed.
+     * This is required when a read or write must be done across multiple pages.
+     *
+     * @param startAddress The address to start
+     * @param length The requested length of the operation
+     * @param handler The handler to execute
+     * @return Returns 0 when all calls to handler() return 0. Otherwise the
+     *         error code from the first non-zero handler() call.
+     */
+    int do_paged(const bd_addr_t &startAddress, const bd_size_t &length, const paged_handler &handler);
+
+    /**
+     * Gets the device's I2C address with respect to the requested page.
+     * When eight bit mode is disabled, this function is a noop.
+     * When eight bit mode is enabled, it sets the bits required for this bit
+     * in the devices address. Other bits remain unchained.
+     * @param page The requested page
+     * @return The device's I2C address for that page
+     */
+    uint8_t get_paged_device_address(const uint8_t &page);
 };
 
 
