ppc4xx: Enable "ecctest" command on t3corp
[platform/kernel/u-boot.git] / common / cmd_onenand.c
1 /*
2  *  U-Boot command for OneNAND support
3  *
4  *  Copyright (C) 2005-2008 Samsung Electronics
5  *  Kyungmin Park <kyungmin.park@samsung.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11
12 #include <common.h>
13 #include <command.h>
14 #include <malloc.h>
15
16 #include <linux/mtd/compat.h>
17 #include <linux/mtd/mtd.h>
18 #include <linux/mtd/onenand.h>
19
20 #include <asm/io.h>
21
22 static struct mtd_info *mtd;
23
24 static loff_t next_ofs;
25 static loff_t skip_ofs;
26
27 static inline int str2long(char *p, ulong *num)
28 {
29         char *endptr;
30
31         *num = simple_strtoul(p, &endptr, 16);
32         return (*p != '\0' && *endptr == '\0') ? 1 : 0;
33 }
34
35 static int arg_off_size(int argc, char * const argv[], ulong *off, size_t *size)
36 {
37         if (argc >= 1) {
38                 if (!(str2long(argv[0], off))) {
39                         printf("'%s' is not a number\n", argv[0]);
40                         return -1;
41                 }
42         } else {
43                 *off = 0;
44         }
45
46         if (argc >= 2) {
47                 if (!(str2long(argv[1], (ulong *)size))) {
48                         printf("'%s' is not a number\n", argv[1]);
49                         return -1;
50                 }
51         } else {
52                 *size = mtd->size - *off;
53         }
54
55         if ((*off + *size) > mtd->size) {
56                 printf("total chip size (0x%llx) exceeded!\n", mtd->size);
57                 return -1;
58         }
59
60         if (*size == mtd->size)
61                 puts("whole chip\n");
62         else
63                 printf("offset 0x%lx, size 0x%x\n", *off, *size);
64
65         return 0;
66 }
67
68 static int onenand_block_read(loff_t from, size_t len,
69                               size_t *retlen, u_char *buf, int oob)
70 {
71         struct onenand_chip *this = mtd->priv;
72         int blocks = (int) len >> this->erase_shift;
73         int blocksize = (1 << this->erase_shift);
74         loff_t ofs = from;
75         struct mtd_oob_ops ops = {
76                 .retlen         = 0,
77         };
78         int ret;
79
80         if (oob)
81                 ops.ooblen = blocksize;
82         else
83                 ops.len = blocksize;
84
85         while (blocks) {
86                 ret = mtd->block_isbad(mtd, ofs);
87                 if (ret) {
88                         printk("Bad blocks %d at 0x%x\n",
89                                (u32)(ofs >> this->erase_shift), (u32)ofs);
90                         ofs += blocksize;
91                         continue;
92                 }
93
94                 if (oob)
95                         ops.oobbuf = buf;
96                 else
97                         ops.datbuf = buf;
98
99                 ops.retlen = 0;
100                 ret = mtd->read_oob(mtd, ofs, &ops);
101                 if (ret) {
102                         printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
103                         ofs += blocksize;
104                         continue;
105                 }
106                 ofs += blocksize;
107                 buf += blocksize;
108                 blocks--;
109                 *retlen += ops.retlen;
110         }
111
112         return 0;
113 }
114
115 static int onenand_block_write(loff_t to, size_t len,
116                                size_t *retlen, const u_char * buf)
117 {
118         struct onenand_chip *this = mtd->priv;
119         int blocks = len >> this->erase_shift;
120         int blocksize = (1 << this->erase_shift);
121         loff_t ofs;
122         size_t _retlen = 0;
123         int ret;
124
125         if (to == next_ofs) {
126                 next_ofs = to + len;
127                 to += skip_ofs;
128         } else {
129                 next_ofs = to + len;
130                 skip_ofs = 0;
131         }
132         ofs = to;
133
134         while (blocks) {
135                 ret = mtd->block_isbad(mtd, ofs);
136                 if (ret) {
137                         printk("Bad blocks %d at 0x%x\n",
138                                (u32)(ofs >> this->erase_shift), (u32)ofs);
139                         skip_ofs += blocksize;
140                         goto next;
141                 }
142
143                 ret = mtd->write(mtd, ofs, blocksize, &_retlen, buf);
144                 if (ret) {
145                         printk("Write failed 0x%x, %d", (u32)ofs, ret);
146                         skip_ofs += blocksize;
147                         goto next;
148                 }
149
150                 buf += blocksize;
151                 blocks--;
152                 *retlen += _retlen;
153 next:
154                 ofs += blocksize;
155         }
156
157         return 0;
158 }
159
160 static int onenand_block_erase(u32 start, u32 size, int force)
161 {
162         struct onenand_chip *this = mtd->priv;
163         struct erase_info instr = {
164                 .callback       = NULL,
165         };
166         loff_t ofs;
167         int ret;
168         int blocksize = 1 << this->erase_shift;
169
170         for (ofs = start; ofs < (start + size); ofs += blocksize) {
171                 ret = mtd->block_isbad(mtd, ofs);
172                 if (ret && !force) {
173                         printf("Skip erase bad block %d at 0x%x\n",
174                                (u32)(ofs >> this->erase_shift), (u32)ofs);
175                         continue;
176                 }
177
178                 instr.addr = ofs;
179                 instr.len = blocksize;
180                 instr.priv = force;
181                 instr.mtd = mtd;
182                 ret = mtd->erase(mtd, &instr);
183                 if (ret) {
184                         printf("erase failed block %d at 0x%x\n",
185                                (u32)(ofs >> this->erase_shift), (u32)ofs);
186                         continue;
187                 }
188         }
189
190         return 0;
191 }
192
193 static int onenand_block_test(u32 start, u32 size)
194 {
195         struct onenand_chip *this = mtd->priv;
196         struct erase_info instr = {
197                 .callback       = NULL,
198                 .priv           = 0,
199         };
200
201         int blocks;
202         loff_t ofs;
203         int blocksize = 1 << this->erase_shift;
204         int start_block, end_block;
205         size_t retlen;
206         u_char *buf;
207         u_char *verify_buf;
208         int ret;
209
210         buf = malloc(blocksize);
211         if (!buf) {
212                 printf("Not enough malloc space available!\n");
213                 return -1;
214         }
215
216         verify_buf = malloc(blocksize);
217         if (!verify_buf) {
218                 printf("Not enough malloc space available!\n");
219                 return -1;
220         }
221
222         start_block = start >> this->erase_shift;
223         end_block = (start + size) >> this->erase_shift;
224
225         /* Protect boot-loader from badblock testing */
226         if (start_block < 2)
227                 start_block = 2;
228
229         if (end_block > (mtd->size >> this->erase_shift))
230                 end_block = mtd->size >> this->erase_shift;
231
232         blocks = start_block;
233         ofs = start;
234         while (blocks < end_block) {
235                 printf("\rTesting block %d at 0x%x", (u32)(ofs >> this->erase_shift), (u32)ofs);
236
237                 ret = mtd->block_isbad(mtd, ofs);
238                 if (ret) {
239                         printf("Skip erase bad block %d at 0x%x\n",
240                                (u32)(ofs >> this->erase_shift), (u32)ofs);
241                         goto next;
242                 }
243
244                 instr.addr = ofs;
245                 instr.len = blocksize;
246                 ret = mtd->erase(mtd, &instr);
247                 if (ret) {
248                         printk("Erase failed 0x%x, %d\n", (u32)ofs, ret);
249                         goto next;
250                 }
251
252                 ret = mtd->write(mtd, ofs, blocksize, &retlen, buf);
253                 if (ret) {
254                         printk("Write failed 0x%x, %d\n", (u32)ofs, ret);
255                         goto next;
256                 }
257
258                 ret = mtd->read(mtd, ofs, blocksize, &retlen, verify_buf);
259                 if (ret) {
260                         printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
261                         goto next;
262                 }
263
264                 if (memcmp(buf, verify_buf, blocksize))
265                         printk("\nRead/Write test failed at 0x%x\n", (u32)ofs);
266
267 next:
268                 ofs += blocksize;
269                 blocks++;
270         }
271         printf("...Done\n");
272
273         free(buf);
274         free(verify_buf);
275
276         return 0;
277 }
278
279 static int onenand_dump(struct mtd_info *mtd, ulong off, int only_oob)
280 {
281         int i;
282         u_char *datbuf, *oobbuf, *p;
283         struct mtd_oob_ops ops;
284         loff_t addr;
285
286         datbuf = malloc(mtd->writesize + mtd->oobsize);
287         oobbuf = malloc(mtd->oobsize);
288         if (!datbuf || !oobbuf) {
289                 puts("No memory for page buffer\n");
290                 return 1;
291         }
292         off &= ~(mtd->writesize - 1);
293         addr = (loff_t) off;
294         memset(&ops, 0, sizeof(ops));
295         ops.datbuf = datbuf;
296         ops.oobbuf = oobbuf; /* must exist, but oob data will be appended to ops.datbuf */
297         ops.len = mtd->writesize;
298         ops.ooblen = mtd->oobsize;
299         ops.retlen = 0;
300         i = mtd->read_oob(mtd, addr, &ops);
301         if (i < 0) {
302                 printf("Error (%d) reading page %08lx\n", i, off);
303                 free(datbuf);
304                 free(oobbuf);
305                 return 1;
306         }
307         printf("Page %08lx dump:\n", off);
308         i = mtd->writesize >> 4;
309         p = datbuf;
310
311         while (i--) {
312                 if (!only_oob)
313                         printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
314                                "  %02x %02x %02x %02x %02x %02x %02x %02x\n",
315                                p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
316                                p[8], p[9], p[10], p[11], p[12], p[13], p[14],
317                                p[15]);
318                 p += 16;
319         }
320         puts("OOB:\n");
321         i = mtd->oobsize >> 3;
322         while (i--) {
323                 printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
324                        p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
325                 p += 8;
326         }
327         free(datbuf);
328         free(oobbuf);
329
330         return 0;
331 }
332
333 static int do_onenand_info(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
334 {
335         printf("%s\n", mtd->name);
336         return 0;
337 }
338
339 static int do_onenand_bad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
340 {
341         ulong ofs;
342
343         mtd = &onenand_mtd;
344         /* Currently only one OneNAND device is supported */
345         printf("\nDevice %d bad blocks:\n", 0);
346         for (ofs = 0; ofs < mtd->size; ofs += mtd->erasesize) {
347                 if (mtd->block_isbad(mtd, ofs))
348                         printf("  %08x\n", (u32)ofs);
349         }
350
351         return 0;
352 }
353
354 static int do_onenand_read(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
355 {
356         char *s;
357         int oob = 0;
358         ulong addr, ofs;
359         size_t len;
360         int ret = 0;
361         size_t retlen = 0;
362
363         if (argc < 3)
364         {
365                 cmd_usage(cmdtp);
366                 return 1;
367         }
368
369         s = strchr(argv[0], '.');
370         if ((s != NULL) && (!strcmp(s, ".oob")))
371                 oob = 1;
372
373         addr = (ulong)simple_strtoul(argv[1], NULL, 16);
374
375         printf("\nOneNAND read: ");
376         if (arg_off_size(argc - 2, argv + 2, &ofs, &len) != 0)
377                 return 1;
378
379         ret = onenand_block_read(ofs, len, &retlen, (u8 *)addr, oob);
380
381         printf(" %d bytes read: %s\n", retlen, ret ? "ERROR" : "OK");
382
383         return ret == 0 ? 0 : 1;
384 }
385
386 static int do_onenand_write(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
387 {
388         ulong addr, ofs;
389         size_t len;
390         int ret = 0;
391         size_t retlen = 0;
392
393         if (argc < 3)
394         {
395                 cmd_usage(cmdtp);
396                 return 1;
397         }
398
399         addr = (ulong)simple_strtoul(argv[1], NULL, 16);
400
401         printf("\nOneNAND write: ");
402         if (arg_off_size(argc - 2, argv + 2, &ofs, &len) != 0)
403                 return 1;
404
405         ret = onenand_block_write(ofs, len, &retlen, (u8 *)addr);
406
407         printf(" %d bytes written: %s\n", retlen, ret ? "ERROR" : "OK");
408
409         return ret == 0 ? 0 : 1;
410 }
411
412 static int do_onenand_erase(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
413 {
414         ulong ofs;
415         int ret = 0;
416         size_t len;
417         int force;
418
419         /*
420          * Syntax is:
421          *   0       1     2       3    4
422          *   onenand erase [force] [off size]
423          */
424         argc--;
425         argv++;
426         if (argc)
427         {
428                 if (!strcmp("force", argv[0]))
429                 {
430                         force = 1;
431                         argc--;
432                         argv++;
433                 }
434         }
435         printf("\nOneNAND erase: ");
436
437         /* skip first two or three arguments, look for offset and size */
438         if (arg_off_size(argc, argv, &ofs, &len) != 0)
439                 return 1;
440
441         ret = onenand_block_erase(ofs, len, force);
442
443         printf("%s\n", ret ? "ERROR" : "OK");
444
445         return ret == 0 ? 0 : 1;
446 }
447
448 static int do_onenand_test(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
449 {
450         ulong ofs;
451         int ret = 0;
452         size_t len;
453
454         /*
455          * Syntax is:
456          *   0       1     2       3    4
457          *   onenand test [force] [off size]
458          */
459
460         printf("\nOneNAND test: ");
461
462         /* skip first two or three arguments, look for offset and size */
463         if (arg_off_size(argc - 1, argv + 1, &ofs, &len) != 0)
464                 return 1;
465
466         ret = onenand_block_test(ofs, len);
467
468         printf("%s\n", ret ? "ERROR" : "OK");
469
470         return ret == 0 ? 0 : 1;
471 }
472
473 static int do_onenand_dump(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
474 {
475         ulong ofs;
476         int ret = 0;
477         char *s;
478
479         if (argc < 2)
480         {
481                 cmd_usage(cmdtp);
482                 return 1;
483         }
484
485         s = strchr(argv[0], '.');
486         ofs = (int)simple_strtoul(argv[1], NULL, 16);
487
488         if (s != NULL && strcmp(s, ".oob") == 0)
489                 ret = onenand_dump(mtd, ofs, 1);
490         else
491                 ret = onenand_dump(mtd, ofs, 0);
492
493         return ret == 0 ? 1 : 0;
494 }
495
496 static int do_onenand_markbad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
497 {
498         int ret = 0;
499         ulong addr;
500
501         argc -= 2;
502         argv += 2;
503
504         if (argc <= 0)
505         {
506                 cmd_usage(cmdtp);
507                 return 1;
508         }
509
510         while (argc > 0) {
511                 addr = simple_strtoul(*argv, NULL, 16);
512
513                 if (mtd->block_markbad(mtd, addr)) {
514                         printf("block 0x%08lx NOT marked "
515                                 "as bad! ERROR %d\n",
516                                 addr, ret);
517                         ret = 1;
518                 } else {
519                         printf("block 0x%08lx successfully "
520                                 "marked as bad\n",
521                                 addr);
522                 }
523                 --argc;
524                 ++argv;
525         }
526         return ret;
527 }
528
529 static cmd_tbl_t cmd_onenand_sub[] = {
530         U_BOOT_CMD_MKENT(info, 1, 0, do_onenand_info, "", ""),
531         U_BOOT_CMD_MKENT(bad, 1, 0, do_onenand_bad, "", ""),
532         U_BOOT_CMD_MKENT(read, 4, 0, do_onenand_read, "", ""),
533         U_BOOT_CMD_MKENT(write, 4, 0, do_onenand_write, "", ""),
534         U_BOOT_CMD_MKENT(erase, 3, 0, do_onenand_erase, "", ""),
535         U_BOOT_CMD_MKENT(test, 3, 0, do_onenand_test, "", ""),
536         U_BOOT_CMD_MKENT(dump, 2, 0, do_onenand_dump, "", ""),
537         U_BOOT_CMD_MKENT(markbad, CONFIG_SYS_MAXARGS, 0, do_onenand_markbad, "", ""),
538 };
539
540 static int do_onenand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
541 {
542         cmd_tbl_t *c;
543
544         mtd = &onenand_mtd;
545
546         /* Strip off leading 'onenand' command argument */
547         argc--;
548         argv++;
549
550         c = find_cmd_tbl(argv[0], &cmd_onenand_sub[0], ARRAY_SIZE(cmd_onenand_sub));
551
552         if (c) {
553                 return  c->cmd(cmdtp, flag, argc, argv);
554         } else {
555                 cmd_usage(cmdtp);
556                 return 1;
557         }
558 }
559
560 U_BOOT_CMD(
561         onenand,        CONFIG_SYS_MAXARGS,     1,      do_onenand,
562         "OneNAND sub-system",
563         "info - show available OneNAND devices\n"
564         "onenand bad - show bad blocks\n"
565         "onenand read[.oob] addr off size\n"
566         "onenand write addr off size\n"
567         "    read/write 'size' bytes starting at offset 'off'\n"
568         "    to/from memory address 'addr', skipping bad blocks.\n"
569         "onenand erase [force] [off size] - erase 'size' bytes from\n"
570         "onenand test [off size] - test 'size' bytes from\n"
571         "    offset 'off' (entire device if not specified)\n"
572         "onenand dump[.oob] off - dump page\n"
573         "onenand markbad off [...] - mark bad block(s) at offset (UNSAFE)"
574 );