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                 return cmd_usage(cmdtp);
 365
 366         s = strchr(argv[0], '.');
 367         if ((s != NULL) && (!strcmp(s, ".oob")))
 368                 oob = 1;
 369
 370         addr = (ulong)simple_strtoul(argv[1], NULL, 16);
 371
 372         printf("\nOneNAND read: ");
 373         if (arg_off_size(argc - 2, argv + 2, &ofs, &len) != 0)
 374                 return 1;
 375
 376         ret = onenand_block_read(ofs, len, &retlen, (u8 *)addr, oob);
 377
 378         printf(" %d bytes read: %s\n", retlen, ret ? "ERROR" : "OK");
 379
 380         return ret == 0 ? 0 : 1;
 381 }
 382
 383 static int do_onenand_write(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
 384 {
 385         ulong addr, ofs;
 386         size_t len;
 387         int ret = 0;
 388         size_t retlen = 0;
 389
 390         if (argc < 3)
 391                 return cmd_usage(cmdtp);
 392
 393         addr = (ulong)simple_strtoul(argv[1], NULL, 16);
 394
 395         printf("\nOneNAND write: ");
 396         if (arg_off_size(argc - 2, argv + 2, &ofs, &len) != 0)
 397                 return 1;
 398
 399         ret = onenand_block_write(ofs, len, &retlen, (u8 *)addr);
 400
 401         printf(" %d bytes written: %s\n", retlen, ret ? "ERROR" : "OK");
 402
 403         return ret == 0 ? 0 : 1;
 404 }
 405
 406 static int do_onenand_erase(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
 407 {
 408         ulong ofs;
 409         int ret = 0;
 410         size_t len;
 411         int force;
 412
 413         /*
 414          * Syntax is:
 415          *   0       1     2       3    4
 416          *   onenand erase [force] [off size]
 417          */
 418         argc--;
 419         argv++;
 420         if (argc)
 421         {
 422                 if (!strcmp("force", argv[0]))
 423                 {
 424                         force = 1;
 425                         argc--;
 426                         argv++;
 427                 }
 428         }
 429         printf("\nOneNAND erase: ");
 430
 431         /* skip first two or three arguments, look for offset and size */
 432         if (arg_off_size(argc, argv, &ofs, &len) != 0)
 433                 return 1;
 434
 435         ret = onenand_block_erase(ofs, len, force);
 436
 437         printf("%s\n", ret ? "ERROR" : "OK");
 438
 439         return ret == 0 ? 0 : 1;
 440 }
 441
 442 static int do_onenand_test(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
 443 {
 444         ulong ofs;
 445         int ret = 0;
 446         size_t len;
 447
 448         /*
 449          * Syntax is:
 450          *   0       1     2       3    4
 451          *   onenand test [force] [off size]
 452          */
 453
 454         printf("\nOneNAND test: ");
 455
 456         /* skip first two or three arguments, look for offset and size */
 457         if (arg_off_size(argc - 1, argv + 1, &ofs, &len) != 0)
 458                 return 1;
 459
 460         ret = onenand_block_test(ofs, len);
 461
 462         printf("%s\n", ret ? "ERROR" : "OK");
 463
 464         return ret == 0 ? 0 : 1;
 465 }
 466
 467 static int do_onenand_dump(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
 468 {
 469         ulong ofs;
 470         int ret = 0;
 471         char *s;
 472
 473         if (argc < 2)
 474                 return cmd_usage(cmdtp);
 475
 476         s = strchr(argv[0], '.');
 477         ofs = (int)simple_strtoul(argv[1], NULL, 16);
 478
 479         if (s != NULL && strcmp(s, ".oob") == 0)
 480                 ret = onenand_dump(mtd, ofs, 1);
 481         else
 482                 ret = onenand_dump(mtd, ofs, 0);
 483
 484         return ret == 0 ? 1 : 0;
 485 }
 486
 487 static int do_onenand_markbad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
 488 {
 489         int ret = 0;
 490         ulong addr;
 491
 492         argc -= 2;
 493         argv += 2;
 494
 495         if (argc <= 0)
 496                 return cmd_usage(cmdtp);
 497
 498         while (argc > 0) {
 499                 addr = simple_strtoul(*argv, NULL, 16);
 500
 501                 if (mtd->block_markbad(mtd, addr)) {
 502                         printf("block 0x%08lx NOT marked "
 503                                 "as bad! ERROR %d\n",
 504                                 addr, ret);
 505                         ret = 1;
 506                 } else {
 507                         printf("block 0x%08lx successfully "
 508                                 "marked as bad\n",
 509                                 addr);
 510                 }
 511                 --argc;
 512                 ++argv;
 513         }
 514         return ret;
 515 }
 516
 517 static cmd_tbl_t cmd_onenand_sub[] = {
 518         U_BOOT_CMD_MKENT(info, 1, 0, do_onenand_info, "", ""),
 519         U_BOOT_CMD_MKENT(bad, 1, 0, do_onenand_bad, "", ""),
 520         U_BOOT_CMD_MKENT(read, 4, 0, do_onenand_read, "", ""),
 521         U_BOOT_CMD_MKENT(write, 4, 0, do_onenand_write, "", ""),
 522         U_BOOT_CMD_MKENT(erase, 3, 0, do_onenand_erase, "", ""),
 523         U_BOOT_CMD_MKENT(test, 3, 0, do_onenand_test, "", ""),
 524         U_BOOT_CMD_MKENT(dump, 2, 0, do_onenand_dump, "", ""),
 525         U_BOOT_CMD_MKENT(markbad, CONFIG_SYS_MAXARGS, 0, do_onenand_markbad, "", ""),
 526 };
 527
 528 static int do_onenand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
 529 {
 530         cmd_tbl_t *c;
 531
 532         mtd = &onenand_mtd;
 533
 534         /* Strip off leading 'onenand' command argument */
 535         argc--;
 536         argv++;
 537
 538         c = find_cmd_tbl(argv[0], &cmd_onenand_sub[0], ARRAY_SIZE(cmd_onenand_sub));
 539
 540         if (c)
 541                 return c->cmd(cmdtp, flag, argc, argv);
 542         else
 543                 return cmd_usage(cmdtp);
 544 }
 545
 546 U_BOOT_CMD(
 547         onenand,        CONFIG_SYS_MAXARGS,     1,      do_onenand,
 548         "OneNAND sub-system",
 549         "info - show available OneNAND devices\n"
 550         "onenand bad - show bad blocks\n"
 551         "onenand read[.oob] addr off size\n"
 552         "onenand write addr off size\n"
 553         "    read/write 'size' bytes starting at offset 'off'\n"
 554         "    to/from memory address 'addr', skipping bad blocks.\n"
 555         "onenand erase [force] [off size] - erase 'size' bytes from\n"
 556         "onenand test [off size] - test 'size' bytes from\n"
 557         "    offset 'off' (entire device if not specified)\n"
 558         "onenand dump[.oob] off - dump page\n"
 559         "onenand markbad off [...] - mark bad block(s) at offset (UNSAFE)"
 560 );