4 * Copyright 2003, 2004, 2005 Develer S.r.l. (http://www.develer.com/)
5 * This file is part of DevLib - See README.devlib for information.
8 * \brief Driver for the 24xx16 and 24xx256 I2C EEPROMS (implementation)
10 * \note This implementation is AVR specific.
13 * \author Stefano Fedrigo <aleph@develer.com>
14 * \author Bernardo Innocenti <bernie@develer.com>
19 *#* Revision 1.20 2006/07/19 12:56:25 bernie
20 *#* Convert to new Doxygen style.
22 *#* Revision 1.19 2006/03/20 17:49:50 bernie
23 *#* Make the TWI driver more generic to work with devices other than EEPROMS.
25 *#* Revision 1.18 2005/11/27 23:33:40 bernie
26 *#* Use appconfig.h instead of cfg/config.h.
28 *#* Revision 1.17 2005/04/11 19:10:27 bernie
29 *#* Include top-level headers from cfg/ subdir.
31 *#* Revision 1.16 2005/03/01 23:25:09 bernie
34 *#* Revision 1.11 2004/10/26 08:35:31 bernie
35 *#* Reset watchdog for long operations.
37 *#* Revision 1.10 2004/09/20 03:31:22 bernie
40 *#* Revision 1.9 2004/09/14 21:03:46 bernie
41 *#* Use debug.h instead of kdebug.h.
46 #include <cfg/debug.h>
47 #include <appconfig.h> // CONFIG_EEPROM_VERIFY
48 #include <cfg/macros.h> // MIN()
51 #include <mware/byteorder.h> // cpu_to_be16()
53 #include <string.h> // memset()
56 // Configuration sanity checks
57 #if !defined(CONFIG_EEPROM_VERIFY) || (CONFIG_EEPROM_VERIFY != 0 && CONFIG_EEPROM_VERIFY != 1)
58 #error CONFIG_EEPROM_VERIFY must be defined to either 0 or 1
64 #define EEPROM_ID 0xA0
67 * This macros form the correct slave address for EEPROMs
69 #define EEPROM_ADDR(x) (EEPROM_ID | (((uint8_t)(x)) << 1))
75 * Copy \c count bytes from buffer \c buf to
76 * eeprom at address \c addr.
78 static bool eeprom_writeRaw(e2addr_t addr, const void *buf, size_t count)
81 ASSERT(addr + count <= EEPROM_SIZE);
83 while (count && result)
86 * Split write in multiple sequential mode operations that
87 * don't cross page boundaries.
90 MIN(count, (size_t)(EEPROM_BLKSIZE - (addr & (EEPROM_BLKSIZE - 1))));
92 #if CONFIG_EEPROM_TYPE == EEPROM_24XX16
94 * The 24LC16 uses the slave address as a 3-bit
97 uint8_t blk_addr = (uint8_t)((addr >> 8) & 0x07);
98 uint8_t blk_offs = (uint8_t)addr;
101 twi_start_w(EEPROM_ADDR(blk_addr))
102 && twi_send(&blk_offs, sizeof blk_offs)
103 && twi_send(buf, size);
105 #elif CONFIG_EEPROM_TYPE == EEPROM_24XX256
107 // 24LC256 wants big-endian addresses
108 uint16_t addr_be = cpu_to_be16(addr);
111 twi_start_w(EEPROM_ID)
112 && twi_send((uint8_t *)&addr_be, sizeof addr_be)
113 && twi_send(buf, size);
116 #error Unknown device type
122 //kprintf("addr=%d, count=%d, size=%d, *#?=%d\n",
123 // addr, count, size,
124 // (EEPROM_BLKSIZE - (addr & (EEPROM_BLKSIZE - 1)))
127 /* Update count and addr for next operation */
130 buf = ((const char *)buf) + size;
134 TRACEMSG("Write error!");
139 #if CONFIG_EEPROM_VERIFY
141 * Check that the contents of an EEPROM range
142 * match with a provided data buffer.
144 * \return true on success.
146 static bool eeprom_verify(e2addr_t addr, const void *buf, size_t count)
148 uint8_t verify_buf[16];
151 while (count && result)
153 /* Split read in smaller pieces */
154 size_t size = MIN(count, sizeof verify_buf);
156 /* Read back buffer */
157 if (eeprom_read(addr, verify_buf, size))
159 if (memcmp(buf, verify_buf, size) != 0)
161 TRACEMSG("Data mismatch!");
167 TRACEMSG("Read error!");
171 /* Update count and addr for next operation */
174 buf = ((const char *)buf) + size;
179 #endif /* CONFIG_EEPROM_VERIFY */
182 bool eeprom_write(e2addr_t addr, const void *buf, size_t count)
184 #if CONFIG_EEPROM_VERIFY
188 if (eeprom_writeRaw(addr, buf, count)
189 && eeprom_verify(addr, buf, count))
194 #else /* !CONFIG_EEPROM_VERIFY */
195 return eeprom_writeRaw(addr, buf, count);
196 #endif /* !CONFIG_EEPROM_VERIFY */
201 * Copy \c count bytes at address \c addr
202 * from eeprom to RAM to buffer \c buf.
204 * \return true on success.
206 bool eeprom_read(e2addr_t addr, void *buf, size_t count)
208 ASSERT(addr + count <= EEPROM_SIZE);
210 #if CONFIG_EEPROM_TYPE == EEPROM_24XX16
212 * The 24LC16 uses the slave address as a 3-bit
215 uint8_t blk_addr = (uint8_t)((addr >> 8) & 0x07);
216 uint8_t blk_offs = (uint8_t)addr;
219 twi_start_w(EEPROM_ADDR(blk_addr))
220 && twi_send(&blk_offs, sizeof blk_offs)
221 && twi_start_r(EEPROM_ADDR(blk_addr))
222 && twi_recv(buf, count);
224 #elif CONFIG_EEPROM_TYPE == EEPROM_24XX256
226 // 24LC256 wants big-endian addresses
227 addr = cpu_to_be16(addr);
230 twi_start_w(EEPROM_ID)
231 && twi_send((uint8_t *)&addr, sizeof(addr))
232 && twi_start_r(EEPROM_ID)
233 && twi_recv(buf, count);
235 #error Unknown device type
241 TRACEMSG("Read error!");
247 * Write a single character \a c at address \a addr.
249 bool eeprom_write_char(e2addr_t addr, char c)
251 return eeprom_write(addr, &c, 1);
256 * Read a single character at address \a addr.
258 * \return the requested character or -1 in case of failure.
260 int eeprom_read_char(e2addr_t addr)
264 if (eeprom_read(addr, &c, 1))
272 * Erase specified part of eeprom, writing 0xFF.
274 * \param addr starting address
275 * \param count length of block to erase
277 void eeprom_erase(e2addr_t addr, size_t count)
279 uint8_t buf[EEPROM_BLKSIZE];
280 memset(buf, 0xFF, sizeof buf);
282 // Clear all but struct hw_info at start of eeprom
285 // Long operation, reset watchdog
288 size_t size = MIN(count, sizeof buf);
289 eeprom_write(addr, buf, size);
297 * Initialize TWI module.
299 void eeprom_init(void)
309 void eeprom_test(void)
311 static const char magic[14] = "Humpty Dumpty";
312 char buf[sizeof magic];
315 // Write something to EEPROM using unaligned sequential writes
316 for (i = 0; i < 42; ++i)
319 eeprom_write(i * sizeof magic, magic, sizeof magic);
322 // Read back with single-byte reads
323 for (i = 0; i < 42 * sizeof magic; ++i)
326 eeprom_read(i, buf, 1);
327 kprintf("EEPROM byte read: %c (%d)\n", buf[0], buf[0]);
328 ASSERT(buf[0] == magic[i % sizeof magic]);
331 // Read back again using sequential reads
332 for (i = 0; i < 42; ++i)
335 memset(buf, 0, sizeof buf);
336 eeprom_read(i * sizeof magic, buf, sizeof magic);
337 kprintf("EEPROM seq read @ 0x%x: '%s'\n", i * sizeof magic, buf);
338 ASSERT(memcmp(buf, magic, sizeof magic) == 0);