bertos/drv/eeprom.c

   1 /**
   2  * \file
   3  * <!--
   4  * This file is part of BeRTOS.
   5  *
   6  * Bertos is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  * As a special exception, you may use this file as part of a free software
  21  * library without restriction.  Specifically, if other files instantiate
  22  * templates or use macros or inline functions from this file, or you compile
  23  * this file and link it with other files to produce an executable, this
  24  * file does not by itself cause the resulting executable to be covered by
  25  * the GNU General Public License.  This exception does not however
  26  * invalidate any other reasons why the executable file might be covered by
  27  * the GNU General Public License.
  28  *
  29  * Copyright 2003, 2004, 2005, 2010 Develer S.r.l. (http://www.develer.com/)
  30  *
  31  * -->
  32  *
  33  * \brief Driver for the 24xx16 and 24xx256 I2C EEPROMS (implementation)
  34  *
  35  * \author Stefano Fedrigo <aleph@develer.com>
  36  * \author Bernie Innocenti <bernie@codewiz.org>
  37  */
  38
  39 #include "eeprom.h"
  40
  41 #include "cfg/cfg_i2c.h"
  42 #include "cfg/cfg_eeprom.h"
  43
  44 /* Define logging setting (for cfg/log.h module). */
  45 #define LOG_LEVEL         EEPROM_LOG_LEVEL
  46 #define LOG_FORMAT        EEPROM_LOG_FORMAT
  47 #include <cfg/log.h>
  48 #include <cfg/debug.h>
  49 #include <cfg/macros.h>  // MIN()
  50
  51 #include <cpu/attr.h>
  52
  53 #include <drv/i2c.h>
  54
  55 #include <string.h>  // memset()
  56
  57 /**
  58  * EEPROM ID code
  59  */
  60 #define EEPROM_ID  0xA0
  61
  62 /**
  63  * This macros form the correct slave address for EEPROMs
  64  */
  65 #define EEPROM_ADDR(x) (EEPROM_ID | (((uint8_t)((x) & 0x07)) << 1))
  66
  67
  68 /**
  69  * Array used to describe EEPROM memory devices currently supported.
  70  */
  71 static const EepromInfo mem_info[] =
  72 {
  73         {
  74                 /* 24XX08 */
  75                 .has_dev_addr = false,
  76                 .blk_size = 0x10,
  77                 .e2_size = 0x400,
  78         },
  79         {
  80                 /* 24XX16 */
  81                 .has_dev_addr = false,
  82                 .blk_size = 0x10,
  83                 .e2_size = 0x800,
  84         },
  85         {
  86                 /* 24XX256 */
  87                 .has_dev_addr = true,
  88                 .blk_size = 0x40,
  89                 .e2_size = 0x8000,
  90         },
  91         {
  92                 /* 24XX512 */
  93                 .has_dev_addr = true,
  94                 .blk_size = 0x80,
  95                 .e2_size = 0x10000,
  96         },
  97         {
  98                 /* 24XX1024 */
  99                 .has_dev_addr = true,
 100                 .blk_size = 0x100,
 101                 .e2_size = 0x20000,
 102         },
 103
 104         /* Add other memories here */
 105 };
 106
 107 STATIC_ASSERT(countof(mem_info) == EEPROM_CNT);
 108
 109 #define CHUNCK_SIZE     16
 110
 111 /**
 112  * Erase EEPROM.
 113  * \param eep is the Kblock context.
 114  * \param addr eeprom address where start to erase
 115  * \param size number of byte to erase
 116  */
 117 bool eeprom_erase(Eeprom *eep, e2addr_t addr, e2_size_t size)
 118 {
 119         uint8_t tmp[CHUNCK_SIZE] = { [0 ... (CHUNCK_SIZE - 1)] = 0xFF };
 120
 121         while (size)
 122         {
 123                 block_idx_t idx = addr / eep->blk.blk_size;
 124                 size_t offset = addr % eep->blk.blk_size;
 125                 size_t count = MIN(size, (e2_size_t)CHUNCK_SIZE);
 126                 size_t ret_len = eep->blk.priv.vt->writeDirect((KBlock *)eep, idx, tmp, offset, count);
 127                 size -= ret_len;
 128                 addr += ret_len;
 129
 130                 if (ret_len != count)
 131                         return false;
 132         }
 133         return true;
 134 }
 135
 136 /**
 137  * Verify EEPROM.
 138  * \param eep is the Kblock context.
 139  * \param addr eeprom address where start to verify.
 140  * \param buf buffer of data to compare with eeprom data read.
 141  * \param size number of byte to verify.
 142  */
 143 bool eeprom_verify(Eeprom *eep, e2addr_t addr, const void *buf, size_t size)
 144 {
 145     uint8_t verify_buf[CHUNCK_SIZE];
 146         while (size)
 147         {
 148                 block_idx_t idx = addr / eep->blk.blk_size;
 149                 size_t offset = addr % eep->blk.blk_size;
 150                 size_t count = MIN(size, (size_t)CHUNCK_SIZE);
 151
 152                 size_t ret_len = eep->blk.priv.vt->readDirect((KBlock *)eep, idx, verify_buf, offset, count);
 153
 154                 if (ret_len != count)
 155                 {
 156                         LOG_ERR("Verify read fail.\n");
 157                         return false;
 158                 }
 159
 160                 if (memcmp(buf, verify_buf, ret_len) != 0)
 161                 {
 162                         LOG_ERR("Data mismatch!\n");
 163                         return false;
 164                 }
 165
 166                 size -= ret_len;
 167                 addr += ret_len;
 168                 buf = ((const char *)buf) + ret_len;
 169         }
 170         return true;
 171 }
 172
 173
 174 static size_t eeprom_write(KBlock *blk, block_idx_t idx, const void *buf, size_t offset, size_t size)
 175 {
 176         Eeprom *eep = EEPROM_CAST_KBLOCK(blk);
 177         e2dev_addr_t dev_addr;
 178         uint8_t addr_buf[2];
 179         uint8_t addr_len;
 180         uint32_t abs_addr = blk->blk_size * idx + offset;
 181
 182         STATIC_ASSERT(countof(addr_buf) <= sizeof(e2addr_t));
 183
 184         /* clamp size to memory limit (otherwise may roll back) */
 185         ASSERT(idx < blk->priv.blk_start + blk->blk_cnt);
 186         size = MIN(size, blk->blk_size - offset);
 187
 188         if (mem_info[eep->type].has_dev_addr)
 189         {
 190                 dev_addr = eep->addr;
 191                 addr_len = 2;
 192         }
 193         else
 194         {
 195                 dev_addr = (e2dev_addr_t)((abs_addr >> 8) & 0x07);
 196                 addr_len = 1;
 197         }
 198
 199         if (mem_info[eep->type].has_dev_addr)
 200         {
 201                 addr_buf[0] = (abs_addr >> 8) & 0xFF;
 202                 addr_buf[1] = (abs_addr & 0xFF);
 203         }
 204         else
 205         {
 206                 dev_addr = (e2dev_addr_t)((abs_addr >> 8) & 0x07);
 207                 addr_buf[0] = (abs_addr & 0xFF);
 208         }
 209
 210         i2c_start_w(eep->i2c, EEPROM_ADDR(dev_addr),  addr_len + size, I2C_STOP);
 211         i2c_write(eep->i2c, addr_buf, addr_len);
 212         i2c_write(eep->i2c, buf, size);
 213
 214         if (i2c_error(eep->i2c))
 215                 return 0;
 216
 217         return size;
 218 }
 219
 220 static size_t eeprom_readDirect(struct KBlock *_blk, block_idx_t idx, void *_buf, size_t offset, size_t size)
 221 {
 222         Eeprom *blk = EEPROM_CAST_KBLOCK(_blk);
 223         uint8_t addr_buf[2];
 224         uint8_t addr_len;
 225         size_t rd_len = 0;
 226         uint8_t *buf = (uint8_t *)_buf;
 227         uint32_t abs_addr = mem_info[blk->type].blk_size * idx + offset;
 228
 229         STATIC_ASSERT(countof(addr_buf) <= sizeof(e2addr_t));
 230
 231         /* clamp size to memory limit (otherwise may roll back) */
 232         ASSERT(idx < blk->blk.priv.blk_start + blk->blk.blk_cnt);
 233         size = MIN(size, blk->blk.blk_size - offset);
 234
 235         e2dev_addr_t dev_addr;
 236         if (mem_info[blk->type].has_dev_addr)
 237         {
 238                 dev_addr = blk->addr;
 239                 addr_len = 2;
 240                 addr_buf[0] = (abs_addr >> 8) & 0xFF;
 241                 addr_buf[1] = (abs_addr & 0xFF);
 242         }
 243         else
 244         {
 245                 dev_addr = (e2dev_addr_t)((abs_addr >> 8) & 0x07);
 246                 addr_len = 1;
 247                 addr_buf[0] = (abs_addr & 0xFF);
 248         }
 249
 250
 251         i2c_start_w(blk->i2c, EEPROM_ADDR(dev_addr),  addr_len, I2C_NOSTOP);
 252         i2c_write(blk->i2c, addr_buf, addr_len);
 253
 254         i2c_start_r(blk->i2c, EEPROM_ADDR(dev_addr), size, I2C_STOP);
 255         i2c_read(blk->i2c, buf, size);
 256
 257         if (i2c_error(blk->i2c))
 258                    return rd_len;
 259
 260         rd_len += size;
 261
 262         return rd_len;
 263 }
 264
 265 static size_t eeprom_writeDirect(KBlock *blk, block_idx_t idx, const void *buf, size_t offset, size_t size)
 266 {
 267         Eeprom *eep = EEPROM_CAST_KBLOCK(blk);
 268         if (!eep->verify)
 269                 return eeprom_write(blk, idx, buf, offset, size);
 270         else
 271         {
 272                 int retries = 5;
 273                 while (retries--)
 274                 {
 275                         uint8_t verify_buf[CHUNCK_SIZE];
 276                         size_t wr_len = 0;
 277                         size_t len = 0;
 278                         while (size)
 279                         {
 280                                 /* Split read in smaller pieces */
 281                                 size_t count = MIN(size, (size_t)CHUNCK_SIZE);
 282                                 if ((wr_len = eeprom_write(blk, idx, buf, offset, count)) != 0)
 283                                 {
 284                                         if (eeprom_readDirect(blk, idx, verify_buf, offset, count) != wr_len)
 285                                         {
 286                                                 LOG_ERR("Verify read fail.\n");
 287                                                 return 0;
 288                                         }
 289                                         else if (memcmp(buf, verify_buf, wr_len) != 0)
 290                                         {
 291                                                 LOG_ERR("Data mismatch!\n");
 292                                                 continue;
 293                                         }
 294                                 }
 295                                 else
 296                                 {
 297                                         LOG_ERR("Write fail.\n");
 298                                         return 0;
 299                                 }
 300                                 size -= wr_len;
 301                                 len += wr_len;
 302                                 buf = ((const char *)buf) + wr_len;
 303                         }
 304                         return len;
 305                 }
 306         }
 307
 308         return 0;
 309 }
 310
 311 static int kblockEeprom_dummy(UNUSED_ARG(struct KBlock *,b))
 312 {
 313         return 0;
 314 }
 315
 316
 317 static const KBlockVTable eeprom_unbuffered_vt =
 318 {
 319         .readDirect = eeprom_readDirect,
 320         .writeDirect = eeprom_writeDirect,
 321
 322         .error = kblockEeprom_dummy,
 323         .clearerr = (kblock_clearerr_t)kblockEeprom_dummy,
 324 };
 325
 326 /**
 327  * Initialize EEPROM module.
 328  * \param eep is the Kblock context.
 329  * \param type is the eeprom device we want to initialize (\see EepromType)
 330  * \param i2c context for i2c channel
 331  * \param addr is the i2c devide address (usually pins A0, A1, A2).
 332  * \param verify enable the write check.
 333  */
 334 void eeprom_init_5(Eeprom *eep, I2c *i2c, EepromType type, e2dev_addr_t addr, bool verify)
 335 {
 336         ASSERT(type < EEPROM_CNT);
 337
 338         memset(eep, 0, sizeof(*eep));
 339         DB(eep->blk.priv.type = KBT_EEPROM);
 340
 341         eep->type = type;
 342         eep->addr = addr;
 343         eep->i2c = i2c;
 344         eep->verify = verify;
 345
 346         eep->blk.blk_size = mem_info[type].blk_size;
 347         eep->blk.blk_cnt = mem_info[type].e2_size / mem_info[type].blk_size;
 348         eep->blk.priv.flags |= KB_PARTIAL_WRITE;
 349         eep->blk.priv.vt = &eeprom_unbuffered_vt;
 350 }
 351
 352