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 *argv[], ulong *off, ssize_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, ssize_t len,
  69                               ssize_t *retlen, u_char *buf, int oob)
  70 {
  71         struct onenand_chip *this = mtd->priv;
  72         int blocksize = (1 << this->erase_shift);
  73         loff_t ofs = from;
  74         struct mtd_oob_ops ops = {
  75                 .retlen         = 0,
  76         };
  77         ssize_t thislen;
  78         int ret;
  79
  80         while (len > 0) {
  81                 thislen = min_t(ssize_t, len, blocksize);
  82                 thislen = ALIGN(thislen, mtd->writesize);
  83
  84                 ret = mtd->block_isbad(mtd, ofs);
  85                 if (ret) {
  86                         printk("Bad blocks %d at 0x%x\n",
  87                                (u32)(ofs >> this->erase_shift), (u32)ofs);
  88                         ofs += blocksize;
  89                         /* FIXME need to check how to handle the 'len' */
  90                         len -= blocksize;
  91                         continue;
  92                 }
  93
  94                 if (oob) {
  95                         ops.oobbuf = buf;
  96                         ops.ooblen = thislen;
  97                 } else {
  98                         ops.datbuf = buf;
  99                         ops.len = thislen;
 100                 }
 101
 102                 ops.retlen = 0;
 103                 ret = mtd->read_oob(mtd, ofs, &ops);
 104                 if (ret) {
 105                         printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
 106                         ofs += thislen;
 107                         continue;
 108                 }
 109                 ofs += thislen;
 110                 buf += thislen;
 111                 len -= thislen;
 112                 *retlen += ops.retlen;
 113         }
 114
 115         return 0;
 116 }
 117
 118 static int onenand_block_write(loff_t to, ssize_t len,
 119                                ssize_t *retlen, const u_char * buf)
 120 {
 121         struct onenand_chip *this = mtd->priv;
 122         int blocksize = (1 << this->erase_shift);
 123         struct mtd_oob_ops ops = {
 124                 .retlen         = 0,
 125                 .oobbuf         = NULL,
 126         };
 127         loff_t ofs;
 128         ssize_t thislen;
 129         int ret;
 130
 131         if (to == next_ofs) {
 132                 next_ofs = to + len;
 133                 to += skip_ofs;
 134         } else {
 135                 next_ofs = to + len;
 136                 skip_ofs = 0;
 137         }
 138         ofs = to;
 139
 140         while (len > 0) {
 141                 thislen = min_t(ssize_t, len, blocksize);
 142                 thislen = ALIGN(thislen, mtd->writesize);
 143
 144                 ret = mtd->block_isbad(mtd, ofs);
 145                 if (ret) {
 146                         printk("Bad blocks %d at 0x%x\n",
 147                                (u32)(ofs >> this->erase_shift), (u32)ofs);
 148                         skip_ofs += blocksize;
 149                         goto next;
 150                 }
 151
 152                 ops.datbuf = (u_char *) buf;
 153                 ops.len = thislen;
 154                 ops.retlen = 0;
 155                 ret = mtd->write_oob(mtd, ofs, &ops);
 156                 if (ret) {
 157                         printk("Write failed 0x%x, %d", (u32)ofs, ret);
 158                         skip_ofs += thislen;
 159                         goto next;
 160                 }
 161
 162                 buf += thislen;
 163                 len -= thislen;
 164                 *retlen += ops.retlen;
 165 next:
 166                 ofs += blocksize;
 167         }
 168
 169         return 0;
 170 }
 171
 172 static int onenand_block_erase(u32 start, u32 size, int force)
 173 {
 174         struct onenand_chip *this = mtd->priv;
 175         struct erase_info instr = {
 176                 .callback       = NULL,
 177         };
 178         loff_t ofs;
 179         int ret;
 180         int blocksize = 1 << this->erase_shift;
 181
 182         for (ofs = start; ofs < (start + size); ofs += blocksize) {
 183                 ret = mtd->block_isbad(mtd, ofs);
 184                 if (ret && !force) {
 185                         printf("Skip erase bad block %d at 0x%x\n",
 186                                (u32)(ofs >> this->erase_shift), (u32)ofs);
 187                         continue;
 188                 }
 189
 190                 instr.addr = ofs;
 191                 instr.len = blocksize;
 192                 instr.priv = force;
 193                 instr.mtd = mtd;
 194                 ret = mtd->erase(mtd, &instr);
 195                 if (ret) {
 196                         printf("erase failed block %d at 0x%x\n",
 197                                (u32)(ofs >> this->erase_shift), (u32)ofs);
 198                         continue;
 199                 }
 200         }
 201
 202         return 0;
 203 }
 204
 205 static int onenand_block_test(u32 start, u32 size)
 206 {
 207         struct onenand_chip *this = mtd->priv;
 208         struct erase_info instr = {
 209                 .callback       = NULL,
 210                 .priv           = 0,
 211         };
 212
 213         int blocks;
 214         loff_t ofs;
 215         int blocksize = 1 << this->erase_shift;
 216         int start_block, end_block;
 217         size_t retlen;
 218         u_char *buf;
 219         u_char *verify_buf;
 220         int ret;
 221
 222         buf = malloc(blocksize);
 223         if (!buf) {
 224                 printf("Not enough malloc space available!\n");
 225                 return -1;
 226         }
 227
 228         verify_buf = malloc(blocksize);
 229         if (!verify_buf) {
 230                 printf("Not enough malloc space available!\n");
 231                 return -1;
 232         }
 233
 234         start_block = start >> this->erase_shift;
 235         end_block = (start + size) >> this->erase_shift;
 236
 237         /* Protect boot-loader from badblock testing */
 238         if (start_block < 2)
 239                 start_block = 2;
 240
 241         if (end_block > (mtd->size >> this->erase_shift))
 242                 end_block = mtd->size >> this->erase_shift;
 243
 244         blocks = start_block;
 245         ofs = start_block << this->erase_shift;
 246         while (blocks < end_block) {
 247                 printf("\rTesting block %d at 0x%x", (u32)(ofs >> this->erase_shift), (u32)ofs);
 248
 249                 ret = mtd->block_isbad(mtd, ofs);
 250                 if (ret) {
 251                         printf("Skip erase bad block %d at 0x%x\n",
 252                                (u32)(ofs >> this->erase_shift), (u32)ofs);
 253                         goto next;
 254                 }
 255
 256                 instr.addr = ofs;
 257                 instr.len = blocksize;
 258                 ret = mtd->erase(mtd, &instr);
 259                 if (ret) {
 260                         printk("Erase failed 0x%x, %d\n", (u32)ofs, ret);
 261                         goto next;
 262                 }
 263
 264                 ret = mtd->write(mtd, ofs, blocksize, &retlen, buf);
 265                 if (ret) {
 266                         printk("Write failed 0x%x, %d\n", (u32)ofs, ret);
 267                         goto next;
 268                 }
 269
 270                 ret = mtd->read(mtd, ofs, blocksize, &retlen, verify_buf);
 271                 if (ret) {
 272                         printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
 273                         goto next;
 274                 }
 275
 276                 if (memcmp(buf, verify_buf, blocksize)) {
 277                         printk("\nRead/Write test failed at 0x%x\n", (u32)ofs);
 278                         break;
 279                 }
 280 next:
 281                 ofs += blocksize;
 282                 blocks++;
 283         }
 284         printf("...Done\n");
 285
 286         free(buf);
 287         free(verify_buf);
 288
 289         return 0;
 290 }
 291
 292 static int onenand_dump(struct mtd_info *mtd, ulong off, int only_oob)
 293 {
 294         int i;
 295         u_char *datbuf, *oobbuf, *p;
 296         struct mtd_oob_ops ops;
 297         loff_t addr;
 298
 299         datbuf = malloc(mtd->writesize + mtd->oobsize);
 300         oobbuf = malloc(mtd->oobsize);
 301         if (!datbuf || !oobbuf) {
 302                 puts("No memory for page buffer\n");
 303                 return 1;
 304         }
 305         off &= ~(mtd->writesize - 1);
 306         addr = (loff_t) off;
 307         memset(&ops, 0, sizeof(ops));
 308         ops.datbuf = datbuf;
 309         ops.oobbuf = oobbuf; /* must exist, but oob data will be appended to ops.datbuf */
 310         ops.len = mtd->writesize;
 311         ops.ooblen = mtd->oobsize;
 312         ops.retlen = 0;
 313         i = mtd->read_oob(mtd, addr, &ops);
 314         if (i < 0) {
 315                 printf("Error (%d) reading page %08lx\n", i, off);
 316                 free(datbuf);
 317                 free(oobbuf);
 318                 return 1;
 319         }
 320         printf("Page %08lx dump:\n", off);
 321         i = mtd->writesize >> 4;
 322         p = datbuf;
 323
 324         while (i--) {
 325                 if (!only_oob)
 326                         printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
 327                                "  %02x %02x %02x %02x %02x %02x %02x %02x\n",
 328                                p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
 329                                p[8], p[9], p[10], p[11], p[12], p[13], p[14],
 330                                p[15]);
 331                 p += 16;
 332         }
 333         puts("OOB:\n");
 334         p = oobbuf;
 335         i = mtd->oobsize >> 3;
 336         while (i--) {
 337                 printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
 338                        p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
 339                 p += 8;
 340         }
 341         free(datbuf);
 342         free(oobbuf);
 343
 344         return 0;
 345 }
 346
 347 int do_onenand(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
 348 {
 349         struct onenand_chip *this;
 350         int blocksize;
 351         ulong addr, ofs;
 352         ssize_t len, retlen = 0;
 353         int ret = 0;
 354         char *cmd, *s;
 355
 356         mtd = &onenand_mtd;
 357         this = mtd->priv;
 358         blocksize = (1 << this->erase_shift);
 359
 360         cmd = argv[1];
 361
 362         switch (argc) {
 363         case 0:
 364         case 1:
 365                 goto usage;
 366
 367         case 2:
 368                 if (strcmp(cmd, "info") == 0) {
 369                         printf("%s\n", mtd->name);
 370                         return 0;
 371                 }
 372
 373                 if (strcmp(cmd, "bad") == 0) {
 374                         /* Currently only one OneNAND device is supported */
 375                         printf("\nDevice %d bad blocks:\n", 0);
 376                         for (ofs = 0; ofs < mtd->size; ofs += mtd->erasesize) {
 377                                 if (mtd->block_isbad(mtd, ofs))
 378                                         printf("  %08x\n", (u32)ofs);
 379                         }
 380
 381                         return 0;
 382                 }
 383
 384         default:
 385                 /* At least 4 args */
 386
 387                 /*
 388                  * Syntax is:
 389                  *   0       1     2       3    4
 390                  *   onenand erase [force] [off size]
 391                  */
 392                 if ((strcmp(cmd, "erase") == 0) || (strcmp(cmd, "test") == 0)) {
 393                         int force = argc > 2 && !strcmp("force", argv[2]);
 394                         int o = force ? 3 : 2;
 395                         int erase;
 396
 397                         erase = strcmp(cmd, "erase") == 0; /* 1 = erase, 0 = test */
 398                         printf("\nOneNAND %s %s: ", erase ? "erase" : "test",
 399                                 force ? "force" : "");
 400
 401                         /* skip first two or three arguments, look for offset and size */
 402                         if (arg_off_size(argc - o, argv + o, &ofs, &len) != 0)
 403                                 return 1;
 404
 405                         if (erase)
 406                                 ret = onenand_block_erase(ofs, len, force);
 407                         else
 408                                 ret = onenand_block_test(ofs, len);
 409
 410                         printf("%s\n", ret ? "ERROR" : "OK");
 411
 412                         return ret == 0 ? 0 : 1;
 413                 }
 414
 415                 if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
 416                         int read;
 417                         int oob = 0;
 418
 419                         if (argc < 4)
 420                                 goto usage;
 421
 422                         addr = (ulong)simple_strtoul(argv[2], NULL, 16);
 423
 424                         read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
 425                         printf("\nOneNAND %s: ", read ? "read" : "write");
 426                         if (arg_off_size(argc - 3, argv + 3, &ofs, &len) != 0)
 427                                 return 1;
 428
 429                         s = strchr(cmd, '.');
 430                         if ((s != NULL) && (!strcmp(s, ".oob")))
 431                                 oob = 1;
 432
 433                         if (read) {
 434                                 ret = onenand_block_read(ofs, len, &retlen,
 435                                                          (u8 *)addr, oob);
 436                         } else {
 437                                 ret = onenand_block_write(ofs, len, &retlen,
 438                                                           (u8 *)addr);
 439                         }
 440
 441                         printf(" %d bytes %s: %s\n", retlen,
 442                                read ? "read" : "written", ret ? "ERROR" : "OK");
 443
 444                         return ret == 0 ? 0 : 1;
 445                 }
 446
 447                 if (strcmp(cmd, "markbad") == 0) {
 448                         argc -= 2;
 449                         argv += 2;
 450
 451                         if (argc <= 0)
 452                                 goto usage;
 453
 454                         while (argc > 0) {
 455                                 addr = simple_strtoul(*argv, NULL, 16);
 456
 457                                 if (mtd->block_markbad(mtd, addr)) {
 458                                         printf("block 0x%08lx NOT marked "
 459                                                 "as bad! ERROR %d\n",
 460                                                 addr, ret);
 461                                         ret = 1;
 462                                 } else {
 463                                         printf("block 0x%08lx successfully "
 464                                                 "marked as bad\n",
 465                                                 addr);
 466                                 }
 467                                 --argc;
 468                                 ++argv;
 469                         }
 470                         return ret;
 471                 }
 472
 473                 if (strncmp(cmd, "dump", 4) == 0) {
 474                         if (argc < 3)
 475                                 goto usage;
 476
 477                         s = strchr(cmd, '.');
 478                         ofs = (int)simple_strtoul(argv[2], NULL, 16);
 479
 480                         if (s != NULL && strcmp(s, ".oob") == 0)
 481                                 ret = onenand_dump(mtd, ofs, 1);
 482                         else
 483                                 ret = onenand_dump(mtd, ofs, 0);
 484
 485                         return ret == 0 ? 1 : 0;
 486                 }
 487
 488                 break;
 489         }
 490
 491         return 0;
 492
 493 usage:
 494         cmd_usage(cmdtp);
 495         return 1;
 496 }
 497
 498 U_BOOT_CMD(
 499         onenand,        CONFIG_SYS_MAXARGS,     1,      do_onenand,
 500         "OneNAND sub-system",
 501         "info - show available OneNAND devices\n"
 502         "onenand bad - show bad blocks\n"
 503         "onenand read[.oob] addr off size\n"
 504         "onenand write[.oob] addr off size\n"
 505         "    read/write 'size' bytes starting at offset 'off'\n"
 506         "    to/from memory address 'addr', skipping bad blocks.\n"
 507         "onenand erase [force] [off size] - erase 'size' bytes from\n"
 508         "onenand test [off size] - test 'size' bytes from\n"
 509         "    offset 'off' (entire device if not specified)\n"
 510         "onenand dump[.oob] off - dump page\n"
 511         "onenand markbad off [...] - mark bad block(s) at offset (UNSAFE)"
 512 );