drivers/at24cxxx: implement read_page

Author: HendrikVE

drivers/at24cxxx/at24cxxx.c

@@ -69,7 +69,7 @@
 #endif
 
 static
-int _read(const at24cxxx_t *dev, uint32_t pos, void *data, size_t len)
+int _read_page(const at24cxxx_t *dev, uint32_t pos, void *data, size_t len)
 {
     int check;
     uint8_t polls = DEV_MAX_POLLS;
@@ -97,7 +97,31 @@ int _read(const at24cxxx_t *dev, uint32_t pos, void *data, size_t len)
         }
         xtimer_usleep(AT24CXXX_POLL_DELAY_US);
     }
+
     DEBUG("[at24cxxx] i2c_read_regs(): %d; polls: %d\n", check, polls);
+
+    return check;
+}
+
+static
+int _read(const at24cxxx_t *dev, uint32_t pos, void *data, size_t len)
+{
+    int check = 0;
+
+    while (len) {
+        size_t clen = MIN(len, DEV_PAGE_SIZE - MOD_POW2(pos, DEV_PAGE_SIZE));
+
+        check = _read_page(dev, pos, data, clen);
+
+        if (!check) {
+            len -= clen;
+            pos += clen;
+            data += clen;
+        }
+        else {
+            break;
+        }
+    }
     return check;
 }
 
@@ -107,25 +131,24 @@ int _write_page(const at24cxxx_t *dev, uint32_t pos, const void *data, size_t le
     int check;
     uint8_t polls = DEV_MAX_POLLS;
     uint8_t dev_addr;
-    uint16_t _pos;
     uint8_t flags = 0;
 
     if (DEV_EEPROM_SIZE > 2048) {
         /* 2 bytes word address length if more than 11 bits are
            used for addressing */
         /* append page address bits to device address (if any) */
         dev_addr  = (DEV_I2C_ADDR | ((pos & 0xFF0000) >> 16));
-        _pos = (pos & 0xFFFF);
+        pos &= 0xFFFF;
         flags = I2C_REG16;
     }
     else {
         /* append page address bits to device address (if any) */
         dev_addr = (DEV_I2C_ADDR | ((pos & 0xFF00) >> 8));
-        _pos = pos & 0xFF;
+        pos &= 0xFF;
     }
 
     while (-ENXIO == (check = i2c_write_regs(DEV_I2C_BUS, dev_addr,
-                                             _pos, data, len, flags))) {
+                                             pos, data, len, flags))) {
         if (--polls == 0) {
             break;
         }
@@ -225,6 +248,23 @@ int at24cxxx_read(const at24cxxx_t *dev, uint32_t pos, void *data,
     return check;
 }
 
+int at24cxxx_read_page(const at24cxxx_t *dev, uint32_t page, uint32_t offset, void *data, size_t len)
+{
+    int check;
+
+    assert(offset < DEV_PAGE_SIZE);
+
+    /* read no more than to the end of the current page to prevent wrap-around */
+    size_t remaining = DEV_PAGE_SIZE - offset;
+    len = MIN(len, remaining);
+
+    i2c_acquire(DEV_I2C_BUS);
+    check = _read_page(dev, page * DEV_PAGE_SIZE + offset, data, len);
+    i2c_release(DEV_I2C_BUS);
+
+    return check ? check : (int) len;
+}
+
 int at24cxxx_write_byte(const at24cxxx_t *dev, uint32_t pos, uint8_t data)
 {
     if (pos >= DEV_EEPROM_SIZE) {

drivers/at24cxxx/mtd/mtd.c

@@ -51,6 +51,11 @@ static int _mtd_at24cxxx_read(mtd_dev_t *mtd, void *dest, uint32_t addr,
     return at24cxxx_read(DEV(mtd), addr, dest, size) == AT24CXXX_OK ? 0 : -EIO;
 }
 
+static int _mtd_at24cxxx_read_page(mtd_dev_t *mtd, void *dest, uint32_t page, uint32_t offset, uint32_t size)
+{
+    return at24cxxx_read_page(DEV(mtd), page, offset, dest, size);
+}
+
 static int _mtd_at24cxxx_write(mtd_dev_t *mtd, const void *src, uint32_t addr,
                                uint32_t size)
 {
@@ -78,6 +83,7 @@ static int _mtd_at24cxxx_power(mtd_dev_t *mtd, enum mtd_power_state power)
 const mtd_desc_t mtd_at24cxxx_driver = {
     .init = _mtd_at24cxxx_init,
     .read = _mtd_at24cxxx_read,
+    .read_page = _mtd_at24cxxx_read_page,
     .write = _mtd_at24cxxx_write,
     .write_page = mtd_at24cxxx_write_page,
     .erase = _mtd_at24cxxx_erase,

drivers/include/at24cxxx.h

@@ -99,6 +99,22 @@ int at24cxxx_read_byte(const at24cxxx_t *dev, uint32_t pos, void *dest);
 int at24cxxx_read(const at24cxxx_t *dev, uint32_t pos, void *data,
                   size_t len);
 
+/**
+ * @brief Sequentially read @p len bytes from a given @p page.
+ *        The function will read up to the page boundary and then return
+ *        the number of bytes read up to that.
+ *
+ * @param[in] dev       AT24CXXX device handle
+ * @param[in] page      page of EEPROM memory
+ * @param[in] offset    offset from the start of the page, must be < page size
+ * @param[in] data      read buffer
+ * @param[in] len       requested length to be read
+ *
+ * @return    number of bytes read on success
+ * @return    error on failure
+ */
+int at24cxxx_read_page(const at24cxxx_t *dev, uint32_t page, uint32_t offset, void *data, size_t len);
+
 /**
  * @brief   Write a byte at a given position @p pos
  *