4 * This file is part of BeRTOS.
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.
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.
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
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.
29 * Copyright 2003, 2004, 2005 Develer S.r.l. (http://www.develer.com/)
30 * This file is part of DevLib - See README.devlib for information.
33 * \brief Driver for the 24xx16 and 24xx256 I2C EEPROMS (implementation)
35 * \note This implementation is AVR specific.
38 * \author Stefano Fedrigo <aleph@develer.com>
39 * \author Bernardo Innocenti <bernie@develer.com>
44 *#* Revision 1.20 2006/07/19 12:56:25 bernie
45 *#* Convert to new Doxygen style.
47 *#* Revision 1.19 2006/03/20 17:49:50 bernie
48 *#* Make the TWI driver more generic to work with devices other than EEPROMS.
50 *#* Revision 1.18 2005/11/27 23:33:40 bernie
51 *#* Use appconfig.h instead of cfg/config.h.
53 *#* Revision 1.17 2005/04/11 19:10:27 bernie
54 *#* Include top-level headers from cfg/ subdir.
56 *#* Revision 1.16 2005/03/01 23:25:09 bernie
59 *#* Revision 1.11 2004/10/26 08:35:31 bernie
60 *#* Reset watchdog for long operations.
62 *#* Revision 1.10 2004/09/20 03:31:22 bernie
65 *#* Revision 1.9 2004/09/14 21:03:46 bernie
66 *#* Use debug.h instead of kdebug.h.
71 #include <cfg/debug.h>
72 #include <appconfig.h> // CONFIG_EEPROM_VERIFY
73 #include <cfg/macros.h> // MIN()
76 #include <mware/byteorder.h> // cpu_to_be16()
78 #include <string.h> // memset()
81 // Configuration sanity checks
82 #if !defined(CONFIG_EEPROM_VERIFY) || (CONFIG_EEPROM_VERIFY != 0 && CONFIG_EEPROM_VERIFY != 1)
83 #error CONFIG_EEPROM_VERIFY must be defined to either 0 or 1
89 #define EEPROM_ID 0xA0
92 * This macros form the correct slave address for EEPROMs
94 #define EEPROM_ADDR(x) (EEPROM_ID | (((uint8_t)(x)) << 1))
100 * Copy \c count bytes from buffer \c buf to
101 * eeprom at address \c addr.
103 static bool eeprom_writeRaw(e2addr_t addr, const void *buf, size_t count)
106 ASSERT(addr + count <= EEPROM_SIZE);
108 while (count && result)
111 * Split write in multiple sequential mode operations that
112 * don't cross page boundaries.
115 MIN(count, (size_t)(EEPROM_BLKSIZE - (addr & (EEPROM_BLKSIZE - 1))));
117 #if CONFIG_EEPROM_TYPE == EEPROM_24XX16
119 * The 24LC16 uses the slave address as a 3-bit
122 uint8_t blk_addr = (uint8_t)((addr >> 8) & 0x07);
123 uint8_t blk_offs = (uint8_t)addr;
126 twi_start_w(EEPROM_ADDR(blk_addr))
127 && twi_send(&blk_offs, sizeof blk_offs)
128 && twi_send(buf, size);
130 #elif CONFIG_EEPROM_TYPE == EEPROM_24XX256
132 // 24LC256 wants big-endian addresses
133 uint16_t addr_be = cpu_to_be16(addr);
136 twi_start_w(EEPROM_ID)
137 && twi_send((uint8_t *)&addr_be, sizeof addr_be)
138 && twi_send(buf, size);
141 #error Unknown device type
147 //kprintf("addr=%d, count=%d, size=%d, *#?=%d\n",
148 // addr, count, size,
149 // (EEPROM_BLKSIZE - (addr & (EEPROM_BLKSIZE - 1)))
152 /* Update count and addr for next operation */
155 buf = ((const char *)buf) + size;
159 TRACEMSG("Write error!");
164 #if CONFIG_EEPROM_VERIFY
166 * Check that the contents of an EEPROM range
167 * match with a provided data buffer.
169 * \return true on success.
171 static bool eeprom_verify(e2addr_t addr, const void *buf, size_t count)
173 uint8_t verify_buf[16];
176 while (count && result)
178 /* Split read in smaller pieces */
179 size_t size = MIN(count, sizeof verify_buf);
181 /* Read back buffer */
182 if (eeprom_read(addr, verify_buf, size))
184 if (memcmp(buf, verify_buf, size) != 0)
186 TRACEMSG("Data mismatch!");
192 TRACEMSG("Read error!");
196 /* Update count and addr for next operation */
199 buf = ((const char *)buf) + size;
204 #endif /* CONFIG_EEPROM_VERIFY */
207 bool eeprom_write(e2addr_t addr, const void *buf, size_t count)
209 #if CONFIG_EEPROM_VERIFY
213 if (eeprom_writeRaw(addr, buf, count)
214 && eeprom_verify(addr, buf, count))
219 #else /* !CONFIG_EEPROM_VERIFY */
220 return eeprom_writeRaw(addr, buf, count);
221 #endif /* !CONFIG_EEPROM_VERIFY */
226 * Copy \c count bytes at address \c addr
227 * from eeprom to RAM to buffer \c buf.
229 * \return true on success.
231 bool eeprom_read(e2addr_t addr, void *buf, size_t count)
233 ASSERT(addr + count <= EEPROM_SIZE);
235 #if CONFIG_EEPROM_TYPE == EEPROM_24XX16
237 * The 24LC16 uses the slave address as a 3-bit
240 uint8_t blk_addr = (uint8_t)((addr >> 8) & 0x07);
241 uint8_t blk_offs = (uint8_t)addr;
244 twi_start_w(EEPROM_ADDR(blk_addr))
245 && twi_send(&blk_offs, sizeof blk_offs)
246 && twi_start_r(EEPROM_ADDR(blk_addr))
247 && twi_recv(buf, count);
249 #elif CONFIG_EEPROM_TYPE == EEPROM_24XX256
251 // 24LC256 wants big-endian addresses
252 addr = cpu_to_be16(addr);
255 twi_start_w(EEPROM_ID)
256 && twi_send((uint8_t *)&addr, sizeof(addr))
257 && twi_start_r(EEPROM_ID)
258 && twi_recv(buf, count);
260 #error Unknown device type
266 TRACEMSG("Read error!");
272 * Write a single character \a c at address \a addr.
274 bool eeprom_write_char(e2addr_t addr, char c)
276 return eeprom_write(addr, &c, 1);
281 * Read a single character at address \a addr.
283 * \return the requested character or -1 in case of failure.
285 int eeprom_read_char(e2addr_t addr)
289 if (eeprom_read(addr, &c, 1))
297 * Erase specified part of eeprom, writing 0xFF.
299 * \param addr starting address
300 * \param count length of block to erase
302 void eeprom_erase(e2addr_t addr, size_t count)
304 uint8_t buf[EEPROM_BLKSIZE];
305 memset(buf, 0xFF, sizeof buf);
307 // Clear all but struct hw_info at start of eeprom
310 // Long operation, reset watchdog
313 size_t size = MIN(count, sizeof buf);
314 eeprom_write(addr, buf, size);
322 * Initialize TWI module.
324 void eeprom_init(void)
334 void eeprom_test(void)
336 static const char magic[14] = "Humpty Dumpty";
337 char buf[sizeof magic];
340 // Write something to EEPROM using unaligned sequential writes
341 for (i = 0; i < 42; ++i)
344 eeprom_write(i * sizeof magic, magic, sizeof magic);
347 // Read back with single-byte reads
348 for (i = 0; i < 42 * sizeof magic; ++i)
351 eeprom_read(i, buf, 1);
352 kprintf("EEPROM byte read: %c (%d)\n", buf[0], buf[0]);
353 ASSERT(buf[0] == magic[i % sizeof magic]);
356 // Read back again using sequential reads
357 for (i = 0; i < 42; ++i)
360 memset(buf, 0, sizeof buf);
361 eeprom_read(i * sizeof magic, buf, sizeof magic);
362 kprintf("EEPROM seq read @ 0x%x: '%s'\n", i * sizeof magic, buf);
363 ASSERT(memcmp(buf, magic, sizeof magic) == 0);