9a52e5cd7f5c625da189a43280381f3d7ade5788
[bertos.git] / drv / eeprom.c
1 /*!
2  * \file
3  * <!--
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.
6  * -->
7  *
8  * \brief Driver for the 24xx16 and 24xx256 I2C EEPROMS (implementation)
9  *
10  * \note This implementation is AVR specific.
11  *
12  * \version $Id$
13  * \author Stefano Fedrigo <aleph@develer.com>
14  * \author Bernardo Innocenti <bernie@develer.com>
15  */
16
17 /*#*
18  *#* $Log$
19  *#* Revision 1.16  2005/03/01 23:25:09  bernie
20  *#* Prune CVS log.
21  *#*
22  *#* Revision 1.11  2004/10/26 08:35:31  bernie
23  *#* Reset watchdog for long operations.
24  *#*
25  *#* Revision 1.10  2004/09/20 03:31:22  bernie
26  *#* Sanitize for C++.
27  *#*
28  *#* Revision 1.9  2004/09/14 21:03:46  bernie
29  *#* Use debug.h instead of kdebug.h.
30  *#*/
31
32 #include "eeprom.h"
33
34 #include <debug.h>
35 #include <config.h>  // CONFIG_EEPROM_VERIFY
36 #include <macros.h>  // MIN()
37 #include <drv/twi.h>
38 #include <drv/wdt.h>
39 #include <mware/byteorder.h> // cpu_to_be16()
40
41 #include <string.h>  // memset()
42
43
44 // Configuration sanity checks
45 #if !defined(CONFIG_EEPROM_VERIFY) || (CONFIG_EEPROM_VERIFY != 0 && CONFIG_EEPROM_VERIFY != 1)
46         #error CONFIG_EEPROM_VERIFY must be defined to either 0 or 1
47 #endif
48
49
50 /*!
51  * Copy \c count bytes from buffer \c buf to
52  * eeprom at address \c addr.
53  */
54 static bool eeprom_writeRaw(e2addr_t addr, const void *buf, size_t count)
55 {
56         bool result = true;
57         ASSERT(addr + count <= EEPROM_SIZE);
58
59         while (count && result)
60         {
61                 /*
62                  * Split write in multiple sequential mode operations that
63                  * don't cross page boundaries.
64                  */
65                 size_t size =
66                         MIN(count, (size_t)(EEPROM_BLKSIZE - (addr & (EEPROM_BLKSIZE - 1))));
67
68         #if CONFIG_EEPROM_TYPE == EEPROM_24XX16
69                 /*
70                  * The 24LC16 uses the slave address as a 3-bit
71                  * block address.
72                  */
73                 uint8_t blk_addr = (uint8_t)((addr >> 8) & 0x07);
74                 uint8_t blk_offs = (uint8_t)addr;
75
76                 result =
77                         twi_start_w(blk_addr)
78                         && twi_send(&blk_offs, sizeof blk_offs)
79                         && twi_send(buf, size);
80
81         #elif CONFIG_EEPROM_TYPE == EEPROM_24XX256
82
83                 // 24LC256 wants big-endian addresses
84                 uint16_t addr_be = cpu_to_be16(addr);
85
86                 result =
87                         twi_start_w(0)
88                         && twi_send((uint8_t *)&addr_be, sizeof addr_be)
89                         && twi_send(buf, size);
90
91         #else
92                 #error Unknown device type
93         #endif
94
95                 twi_stop();
96
97                 // DEBUG
98                 //kprintf("addr=%d, count=%d, size=%d, *#?=%d\n",
99                 //      addr, count, size,
100                 //      (EEPROM_BLKSIZE - (addr & (EEPROM_BLKSIZE - 1)))
101                 //);
102
103                 /* Update count and addr for next operation */
104                 count -= size;
105                 addr += size;
106                 buf = ((const char *)buf) + size;
107         }
108
109         if (!result)
110                 TRACEMSG("Write error!");
111         return result;
112 }
113
114
115 #if CONFIG_EEPROM_VERIFY
116 /*!
117  * Check that the contents of an EEPROM range
118  * match with a provided data buffer.
119  *
120  * \return true on success.
121  */
122 static bool eeprom_verify(e2addr_t addr, const void *buf, size_t count)
123 {
124         uint8_t verify_buf[16];
125         bool result = true;
126
127         while (count && result)
128         {
129                 /* Split read in smaller pieces */
130                 size_t size = MIN(count, sizeof verify_buf);
131
132                 /* Read back buffer */
133                 if (eeprom_read(addr, verify_buf, size))
134                 {
135                         if (memcmp(buf, verify_buf, size) != 0)
136                         {
137                                 TRACEMSG("Data mismatch!");
138                                 result = false;
139                         }
140                 }
141                 else
142                 {
143                         TRACEMSG("Read error!");
144                         result = false;
145                 }
146
147                 /* Update count and addr for next operation */
148                 count -= size;
149                 addr += size;
150                 buf = ((const char *)buf) + size;
151         }
152
153         return result;
154 }
155 #endif /* CONFIG_EEPROM_VERIFY */
156
157
158 bool eeprom_write(e2addr_t addr, const void *buf, size_t count)
159 {
160 #if CONFIG_EEPROM_VERIFY
161         int retries = 5;
162
163         while (retries--)
164                 if (eeprom_writeRaw(addr, buf, count)
165                                 && eeprom_verify(addr, buf, count))
166                         return true;
167
168         return false;
169
170 #else /* !CONFIG_EEPROM_VERIFY */
171         return eeprom_writeRaw(addr, buf, count);
172 #endif /* !CONFIG_EEPROM_VERIFY */
173 }
174
175
176 /*!
177  * Copy \c count bytes at address \c addr
178  * from eeprom to RAM to buffer \c buf.
179  *
180  * \return true on success.
181  */
182 bool eeprom_read(e2addr_t addr, void *buf, size_t count)
183 {
184         ASSERT(addr + count <= EEPROM_SIZE);
185
186 #if CONFIG_EEPROM_TYPE == EEPROM_24XX16
187         /*
188          * The 24LC16 uses the slave address as a 3-bit
189          * block address.
190          */
191         uint8_t blk_addr = (uint8_t)((addr >> 8) & 0x07);
192         uint8_t blk_offs = (uint8_t)addr;
193
194         bool res =
195                 twi_start_w(blk_addr)
196                 && twi_send(&blk_offs, sizeof blk_offs)
197                 && twi_start_r(blk_addr)
198                 && twi_recv(buf, count);
199
200 #elif CONFIG_EEPROM_TYPE == EEPROM_24XX256
201
202         // 24LC256 wants big-endian addresses
203         addr = cpu_to_be16(addr);
204
205         bool res =
206                 twi_start_w(0)
207                 && twi_send((uint8_t *)&addr, sizeof(addr))
208                 && twi_start_r(0)
209                 && twi_recv(buf, count);
210 #else
211         #error Unknown device type
212 #endif
213
214         twi_stop();
215
216         if (!res)
217                 TRACEMSG("Read error!");
218         return res;
219 }
220
221
222 /*!
223  * Write a single character \a c at address \a addr.
224  */
225 bool eeprom_write_char(e2addr_t addr, char c)
226 {
227         return eeprom_write(addr, &c, 1);
228 }
229
230
231 /*!
232  * Read a single character at address \a addr.
233  *
234  * \return the requested character or -1 in case of failure.
235  */
236 int eeprom_read_char(e2addr_t addr)
237 {
238         char c;
239
240         if (eeprom_read(addr, &c, 1))
241                 return c;
242         else
243                 return -1;
244 }
245
246
247 /*!
248  * Erase specified part of eeprom, writing 0xFF.
249  *
250  * \param addr   starting address
251  * \param count  length of block to erase
252  */
253 void eeprom_erase(e2addr_t addr, size_t count)
254 {
255         uint8_t buf[EEPROM_BLKSIZE];
256         memset(buf, 0xFF, sizeof buf);
257
258         // Clear all but struct hw_info at start of eeprom
259         while (count)
260         {
261                 // Long operation, reset watchdog
262                 wdt_reset();
263
264                 size_t size = MIN(count, sizeof buf);
265                 eeprom_write(addr, buf, size);
266                 addr += size;
267                 count -= size;
268         }
269 }
270
271
272 /*!
273  * Initialize TWI module.
274  */
275 void eeprom_init(void)
276 {
277         twi_init();
278 }
279
280
281 #ifdef _DEBUG
282
283 #include <string.h>
284
285 void eeprom_test(void)
286 {
287         static const char magic[14] = "Humpty Dumpty";
288         char buf[sizeof magic];
289         size_t i;
290
291         // Write something to EEPROM using unaligned sequential writes
292         for (i = 0; i < 42; ++i)
293         {
294                 wdt_reset();
295                 eeprom_write(i * sizeof magic, magic, sizeof magic);
296         }
297
298         // Read back with single-byte reads
299         for (i = 0; i < 42 * sizeof magic; ++i)
300         {
301                 wdt_reset();
302                 eeprom_read(i, buf, 1);
303                 kprintf("EEPROM byte read: %c (%d)\n", buf[0], buf[0]);
304                 ASSERT(buf[0] == magic[i % sizeof magic]);
305         }
306
307         // Read back again using sequential reads
308         for (i = 0; i < 42; ++i)
309         {
310                 wdt_reset();
311                 memset(buf, 0, sizeof buf);
312                 eeprom_read(i * sizeof magic, buf, sizeof magic);
313                 kprintf("EEPROM seq read @ 0x%x: '%s'\n", i * sizeof magic, buf);
314                 ASSERT(memcmp(buf, magic, sizeof magic) == 0);
315         }
316 }
317
318 #endif // _DEBUG