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