firmware/drivers/eeprom_24cxx.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 by Miika Pekkarinen
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include "logf.h"
  21 #include "string.h"
  22 #include "inttypes.h"
  23
  24 #include "sw_i2c.h"
  25
  26 #include "eeprom_24cxx.h"
  27
  28 /* Use cache to speedup writing to the chip. */
  29 static char data_cache[EEPROM_SIZE];
  30 static uint8_t cached_bitfield[EEPROM_SIZE/8];
  31
  32 #define IS_CACHED(addr) (cached_bitfield[addr/8] & (1 << (addr % 8)))
  33 #define SET_CACHED(addr) (cached_bitfield[addr/8] |= 1 << (addr % 8))
  34
  35 void eeprom_24cxx_init(void)
  36 {
  37     sw_i2c_init();
  38     memset(cached_bitfield, 0, sizeof cached_bitfield);
  39 }
  40
  41 int eeprom_24cxx_read_byte(unsigned int address, char *c)
  42 {
  43     int ret;
  44     char byte;
  45     int count = 0;
  46
  47     if (address >= EEPROM_SIZE)
  48     {
  49         logf("EEPROM address: %d", address);
  50         return -9;
  51     }
  52
  53     /* Check from cache. */
  54     if (IS_CACHED(address))
  55     {
  56         logf("EEPROM RCached: %d", address);
  57         *c = data_cache[address];
  58         return 0;
  59     }
  60
  61     *c = 0;
  62     do
  63     {
  64         ret = sw_i2c_read(EEPROM_ADDR, address, &byte, 1);
  65     } while (ret < 0 && count++ < 200);
  66
  67     if (ret < 0)
  68     {
  69         logf("EEPROM RFail: %d/%d/%d", ret, address, count);
  70         return ret;
  71     }
  72
  73     if (count)
  74     {
  75         /* keep between {} as logf is whitespace in normal builds */
  76         logf("EEPROM rOK: %d retries", count);
  77     }
  78
  79     /* Cache the byte. */
  80     data_cache[address] = byte;
  81     SET_CACHED(address);
  82
  83     *c = byte;
  84     return 0;
  85 }
  86
  87 int eeprom_24cxx_write_byte(unsigned int address, char c)
  88 {
  89     int ret;
  90     int count = 0;
  91
  92     if (address >= EEPROM_SIZE)
  93     {
  94         logf("EEPROM address: %d", address);
  95         return -9;
  96     }
  97
  98     /* Check from cache. */
  99     if (IS_CACHED(address) && data_cache[address] == c)
 100     {
 101         logf("EEPROM WCached: %d", address);
 102         return 0;
 103     }
 104
 105     do
 106     {
 107         ret = sw_i2c_write(EEPROM_ADDR, address, &c, 1);
 108     } while (ret < 0 && count++ < 200) ;
 109
 110     if (ret < 0)
 111     {
 112         logf("EEPROM WFail: %d/%d", ret, address);
 113         return ret;
 114     }
 115
 116     if (count)
 117     {
 118         /* keep between {} as logf is whitespace in normal builds */
 119         logf("EEPROM wOK: %d retries", count);
 120     }
 121
 122     SET_CACHED(address);
 123     data_cache[address] = c;
 124
 125     return 0;
 126 }
 127
 128 int eeprom_24cxx_read(unsigned char address, void *dest, int length)
 129 {
 130     char *buf = (char *)dest;
 131     int ret = 0;
 132     int i;
 133
 134     for (i = 0; i < length; i++)
 135     {
 136         ret = eeprom_24cxx_read_byte(address+i, &buf[i]);
 137         if (ret < 0)
 138             return ret;
 139     }
 140
 141     return ret;
 142 }
 143
 144 int eeprom_24cxx_write(unsigned char address, const void *src, int length)
 145 {
 146     const char *buf = (const char *)src;
 147     int i;
 148
 149     for (i = 0; i < length; i++)
 150     {
 151         if (eeprom_24cxx_write_byte(address+i, buf[i]) < 0)
 152             return -1;
 153     }
 154
 155     return 0;
 156 }
 157