Add new board specific commands for TQM5200/STK52XX
[platform/kernel/u-boot.git] / common / cmd_eeprom.c
1 /*
2  * (C) Copyright 2000, 2001
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * See file CREDITS for list of people who contributed to this
6  * project.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of
11  * the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21  * MA 02111-1307 USA
22  *
23  */
24
25 /*
26  * Support for read and write access to EEPROM like memory devices. This
27  * includes regular EEPROM as well as  FRAM (ferroelectic nonvolaile RAM).
28  * FRAM devices read and write data at bus speed. In particular, there is no
29  * write delay. Also, there is no limit imposed on the numer of bytes that can
30  * be transferred with a single read or write.
31  *
32  * Use the following configuration options to ensure no unneeded performance
33  * degradation (typical for EEPROM) is incured for FRAM memory:
34  *
35  * #define CFG_I2C_FRAM
36  * #undef CFG_EEPROM_PAGE_WRITE_DELAY_MS
37  *
38  */
39
40 #include <common.h>
41 #include <config.h>
42 #include <command.h>
43 #include <i2c.h>
44
45 #if (CONFIG_COMMANDS & CFG_CMD_EEPROM) || defined(CFG_ENV_IS_IN_EEPROM)
46
47 extern void eeprom_init  (void);
48 extern int  eeprom_read  (unsigned dev_addr, unsigned offset,
49                           uchar *buffer, unsigned cnt);
50 extern int  eeprom_write (unsigned dev_addr, unsigned offset,
51                           uchar *buffer, unsigned cnt);
52 #endif
53
54
55 #if defined(CFG_EEPROM_X40430)
56         /* Maximum number of times to poll for acknowledge after write */
57 #define MAX_ACKNOWLEDGE_POLLS   10
58 #endif
59
60 /* ------------------------------------------------------------------------- */
61
62 #if (CONFIG_COMMANDS & CFG_CMD_EEPROM)
63 int do_eeprom ( cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
64 {
65         const char *const fmt =
66                 "\nEEPROM @0x%lX %s: addr %08lx  off %04lx  count %ld ... ";
67
68 #if defined(CFG_I2C_MULTI_EEPROMS)
69         if (argc == 6) {
70                 ulong dev_addr = simple_strtoul (argv[2], NULL, 16);
71                 ulong addr = simple_strtoul (argv[3], NULL, 16);
72                 ulong off  = simple_strtoul (argv[4], NULL, 16);
73                 ulong cnt  = simple_strtoul (argv[5], NULL, 16);
74 #else
75         if (argc == 5) {
76                 ulong dev_addr = CFG_DEF_EEPROM_ADDR;
77                 ulong addr = simple_strtoul (argv[2], NULL, 16);
78                 ulong off  = simple_strtoul (argv[3], NULL, 16);
79                 ulong cnt  = simple_strtoul (argv[4], NULL, 16);
80 #endif /* CFG_I2C_MULTI_EEPROMS */
81
82 # ifndef CONFIG_SPI
83                 eeprom_init ();
84 # endif /* !CONFIG_SPI */
85
86                 if (strcmp (argv[1], "read") == 0) {
87                         int rcode;
88
89                         printf (fmt, dev_addr, argv[1], addr, off, cnt);
90
91                         rcode = eeprom_read (dev_addr, off, (uchar *) addr, cnt);
92
93                         puts ("done\n");
94                         return rcode;
95                 } else if (strcmp (argv[1], "write") == 0) {
96                         int rcode;
97
98                         printf (fmt, dev_addr, argv[1], addr, off, cnt);
99
100                         rcode = eeprom_write (dev_addr, off, (uchar *) addr, cnt);
101
102                         puts ("done\n");
103                         return rcode;
104                 }
105         }
106
107         printf ("Usage:\n%s\n", cmdtp->usage);
108         return 1;
109 }
110 #endif  /* CFG_CMD_EEPROM */
111
112 /*-----------------------------------------------------------------------
113  *
114  * for CFG_I2C_EEPROM_ADDR_LEN == 2 (16-bit EEPROM address) offset is
115  *   0x000nxxxx for EEPROM address selectors at n, offset xxxx in EEPROM.
116  *
117  * for CFG_I2C_EEPROM_ADDR_LEN == 1 (8-bit EEPROM page address) offset is
118  *   0x00000nxx for EEPROM address selectors and page number at n.
119  */
120
121 #if (CONFIG_COMMANDS & CFG_CMD_EEPROM) || defined(CFG_ENV_IS_IN_EEPROM)
122
123 #ifndef CONFIG_SPI
124 #if !defined(CFG_I2C_EEPROM_ADDR_LEN) || CFG_I2C_EEPROM_ADDR_LEN < 1 || CFG_I2C_EEPROM_ADDR_LEN > 2
125 #error CFG_I2C_EEPROM_ADDR_LEN must be 1 or 2
126 #endif
127 #endif
128
129 int eeprom_read (unsigned dev_addr, unsigned offset, uchar *buffer, unsigned cnt)
130 {
131         unsigned end = offset + cnt;
132         unsigned blk_off;
133         int rcode = 0;
134
135         /* Read data until done or would cross a page boundary.
136          * We must write the address again when changing pages
137          * because the next page may be in a different device.
138          */
139         while (offset < end) {
140                 unsigned alen, len;
141 #if !defined(CFG_I2C_FRAM)
142                 unsigned maxlen;
143 #endif
144
145 #if CFG_I2C_EEPROM_ADDR_LEN == 1 && !defined(CONFIG_SPI_X)
146                 uchar addr[2];
147
148                 blk_off = offset & 0xFF;        /* block offset */
149
150                 addr[0] = offset >> 8;          /* block number */
151                 addr[1] = blk_off;              /* block offset */
152                 alen    = 2;
153 #else
154                 uchar addr[3];
155
156                 blk_off = offset & 0xFF;        /* block offset */
157
158                 addr[0] = offset >> 16;         /* block number */
159                 addr[1] = offset >>  8;         /* upper address octet */
160                 addr[2] = blk_off;              /* lower address octet */
161                 alen    = 3;
162 #endif  /* CFG_I2C_EEPROM_ADDR_LEN, CONFIG_SPI_X */
163
164                 addr[0] |= dev_addr;            /* insert device address */
165
166                 len = end - offset;
167
168                 /*
169                  * For a FRAM device there is no limit on the number of the
170                  * bytes that can be ccessed with the single read or write
171                  * operation.
172                  */
173 #if !defined(CFG_I2C_FRAM)
174                 maxlen = 0x100 - blk_off;
175                 if (maxlen > I2C_RXTX_LEN)
176                         maxlen = I2C_RXTX_LEN;
177                 if (len > maxlen)
178                         len = maxlen;
179 #endif
180
181 #ifdef CONFIG_SPI
182                 spi_read (addr, alen, buffer, len);
183 #else
184                 if (i2c_read (addr[0], offset, alen-1, buffer, len) != 0)
185                         rcode = 1;
186 #endif
187                 buffer += len;
188                 offset += len;
189         }
190
191         return rcode;
192 }
193
194 /*-----------------------------------------------------------------------
195  *
196  * for CFG_I2C_EEPROM_ADDR_LEN == 2 (16-bit EEPROM address) offset is
197  *   0x000nxxxx for EEPROM address selectors at n, offset xxxx in EEPROM.
198  *
199  * for CFG_I2C_EEPROM_ADDR_LEN == 1 (8-bit EEPROM page address) offset is
200  *   0x00000nxx for EEPROM address selectors and page number at n.
201  */
202
203 int eeprom_write (unsigned dev_addr, unsigned offset, uchar *buffer, unsigned cnt)
204 {
205         unsigned end = offset + cnt;
206         unsigned blk_off;
207         int rcode = 0;
208
209 #if defined(CFG_EEPROM_X40430)
210         uchar   contr_r_addr[2];
211         uchar   addr_void[2];
212         uchar   contr_reg[2];
213         uchar   ctrl_reg_v;
214         int     i;
215 #endif
216
217         /* Write data until done or would cross a write page boundary.
218          * We must write the address again when changing pages
219          * because the address counter only increments within a page.
220          */
221
222         while (offset < end) {
223                 unsigned alen, len;
224 #if !defined(CFG_I2C_FRAM)
225                 unsigned maxlen;
226 #endif
227
228 #if CFG_I2C_EEPROM_ADDR_LEN == 1 && !defined(CONFIG_SPI_X)
229                 uchar addr[2];
230
231                 blk_off = offset & 0xFF;        /* block offset */
232
233                 addr[0] = offset >> 8;          /* block number */
234                 addr[1] = blk_off;              /* block offset */
235                 alen    = 2;
236 #else
237                 uchar addr[3];
238
239                 blk_off = offset & 0xFF;        /* block offset */
240
241                 addr[0] = offset >> 16;         /* block number */
242                 addr[1] = offset >>  8;         /* upper address octet */
243                 addr[2] = blk_off;              /* lower address octet */
244                 alen    = 3;
245 #endif  /* CFG_I2C_EEPROM_ADDR_LEN, CONFIG_SPI_X */
246
247                 addr[0] |= dev_addr;            /* insert device address */
248
249                 len = end - offset;
250
251                 /*
252                  * For a FRAM device there is no limit on the number of the
253                  * bytes that can be ccessed with the single read or write
254                  * operation.
255                  */
256 #if !defined(CFG_I2C_FRAM)
257
258 #if defined(CFG_EEPROM_PAGE_WRITE_BITS)
259
260 #define EEPROM_PAGE_SIZE        (1 << CFG_EEPROM_PAGE_WRITE_BITS)
261 #define EEPROM_PAGE_OFFSET(x)   ((x) & (EEPROM_PAGE_SIZE - 1))
262
263                 maxlen = EEPROM_PAGE_SIZE - EEPROM_PAGE_OFFSET(blk_off);
264 #else
265                 maxlen = 0x100 - blk_off;
266 #endif
267                 if (maxlen > I2C_RXTX_LEN)
268                         maxlen = I2C_RXTX_LEN;
269
270                 if (len > maxlen)
271                         len = maxlen;
272 #endif
273
274 #ifdef CONFIG_SPI
275                 spi_write (addr, alen, buffer, len);
276 #else
277 #if defined(CFG_EEPROM_X40430)
278                 /* Get the value of the control register.
279                  * Set current address (internal pointer in the x40430)
280                  * to 0x1ff.
281                  */
282                 contr_r_addr[0] = 9;
283                 contr_r_addr[1] = 0xff;
284                 addr_void[0]    = 0;
285                 addr_void[1]    = addr[1];
286 #ifdef CFG_I2C_EEPROM_ADDR
287                 contr_r_addr[0] |= CFG_I2C_EEPROM_ADDR;
288                 addr_void[0]    |= CFG_I2C_EEPROM_ADDR;
289 #endif
290                 contr_reg[0] = 0xff;
291                 if (i2c_read (contr_r_addr[0], contr_r_addr[1], 1, contr_reg, 1) != 0) {
292                         rcode = 1;
293                 }
294                 ctrl_reg_v = contr_reg[0];
295
296                 /* Are any of the eeprom blocks write protected?
297                  */
298                 if (ctrl_reg_v & 0x18) {
299                         ctrl_reg_v &= ~0x18;   /* reset block protect bits  */
300                         ctrl_reg_v |=  0x02;   /* set write enable latch    */
301                         ctrl_reg_v &= ~0x04;   /* clear RWEL                */
302
303                         /* Set write enable latch.
304                          */
305                         contr_reg[0] = 0x02;
306                         if (i2c_write (contr_r_addr[0], 0xff, 1, contr_reg, 1) != 0) {
307                                 rcode = 1;
308                         }
309
310                         /* Set register write enable latch.
311                          */
312                         contr_reg[0] = 0x06;
313                         if (i2c_write (contr_r_addr[0], 0xFF, 1, contr_reg, 1) != 0) {
314                                 rcode = 1;
315                         }
316
317                         /* Modify ctrl register.
318                          */
319                         contr_reg[0] = ctrl_reg_v;
320                         if (i2c_write (contr_r_addr[0], 0xFF, 1, contr_reg, 1) != 0) {
321                                 rcode = 1;
322                         }
323
324                         /* The write (above) is an operation on NV memory.
325                          * These can take some time (~5ms), and the device
326                          * will not respond to further I2C messages till
327                          * it's completed the write.
328                          * So poll device for an I2C acknowledge.
329                          * When we get one we know we can continue with other
330                          * operations.
331                          */
332                         contr_reg[0] = 0;
333                         for (i = 0; i < MAX_ACKNOWLEDGE_POLLS; i++) {
334                                 if (i2c_read (addr_void[0], addr_void[1], 1, contr_reg, 1) == 0)
335                                         break;  /* got ack */
336 #if defined(CFG_EEPROM_PAGE_WRITE_DELAY_MS)
337                                 udelay(CFG_EEPROM_PAGE_WRITE_DELAY_MS * 1000);
338 #endif
339                         }
340                         if (i == MAX_ACKNOWLEDGE_POLLS) {
341                                 puts ("EEPROM poll acknowledge failed\n");
342                                 rcode = 1;
343                         }
344                 }
345
346                 /* Is the write enable latch on?.
347                  */
348                 else if (!(ctrl_reg_v & 0x02)) {
349                         /* Set write enable latch.
350                          */
351                         contr_reg[0] = 0x02;
352                         if (i2c_write (contr_r_addr[0], 0xFF, 1, contr_reg, 1) != 0) {
353                                rcode = 1;
354                         }
355                 }
356                 /* Write is enabled ... now write eeprom value.
357                  */
358 #endif
359                 if (i2c_write (addr[0], offset, alen-1, buffer, len) != 0)
360                         rcode = 1;
361
362 #endif
363                 buffer += len;
364                 offset += len;
365
366 #if defined(CFG_EEPROM_PAGE_WRITE_DELAY_MS)
367                 udelay(CFG_EEPROM_PAGE_WRITE_DELAY_MS * 1000);
368 #endif
369         }
370         return rcode;
371 }
372
373 #ifndef CONFIG_SPI
374 int
375 eeprom_probe (unsigned dev_addr, unsigned offset)
376 {
377         unsigned char chip;
378
379         /* Probe the chip address
380          */
381 #if CFG_I2C_EEPROM_ADDR_LEN == 1 && !defined(CONFIG_SPI_X)
382         chip = offset >> 8;             /* block number */
383 #else
384         chip = offset >> 16;            /* block number */
385 #endif  /* CFG_I2C_EEPROM_ADDR_LEN, CONFIG_SPI_X */
386
387         chip |= dev_addr;               /* insert device address */
388
389         return (i2c_probe (chip));
390 }
391 #endif
392
393 /*-----------------------------------------------------------------------
394  * Set default values
395  */
396 #ifndef CFG_I2C_SPEED
397 #define CFG_I2C_SPEED   50000
398 #endif
399
400 #ifndef CFG_I2C_SLAVE
401 #define CFG_I2C_SLAVE   0xFE
402 #endif
403
404 void eeprom_init  (void)
405 {
406 #if defined(CONFIG_SPI)
407         spi_init_f ();
408 #endif
409 #if defined(CONFIG_HARD_I2C) || \
410     defined(CONFIG_SOFT_I2C)
411         i2c_init (CFG_I2C_SPEED, CFG_I2C_SLAVE);
412 #endif
413 }
414 /*-----------------------------------------------------------------------
415  */
416 #endif  /* CFG_CMD_EEPROM */
417 /***************************************************/
418
419 #if (CONFIG_COMMANDS & CFG_CMD_EEPROM)
420
421 #ifdef CFG_I2C_MULTI_EEPROMS
422 U_BOOT_CMD(
423         eeprom, 6,      1,      do_eeprom,
424         "eeprom  - EEPROM sub-system\n",
425         "read  devaddr addr off cnt\n"
426         "eeprom write devaddr addr off cnt\n"
427         "       - read/write `cnt' bytes from `devaddr` EEPROM at offset `off'\n"
428 );
429 #else /* One EEPROM */
430 U_BOOT_CMD(
431         eeprom, 5,      1,      do_eeprom,
432         "eeprom  - EEPROM sub-system\n",
433         "read  addr off cnt\n"
434         "eeprom write addr off cnt\n"
435         "       - read/write `cnt' bytes at EEPROM offset `off'\n"
436 );
437 #endif /* CFG_I2C_MULTI_EEPROMS */
438
439 #endif  /* CFG_CMD_EEPROM */