cmd/mtd.c

   1 // SPDX-License-Identifier:  GPL-2.0+
   2 /*
   3  * mtd.c
   4  *
   5  * Generic command to handle basic operations on any memory device.
   6  *
   7  * Copyright: Bootlin, 2018
   8  * Author: Miquèl Raynal <miquel.raynal@bootlin.com>
   9  */
  10
  11 #include <command.h>
  12 #include <common.h>
  13 #include <console.h>
  14 #include <malloc.h>
  15 #include <mapmem.h>
  16 #include <mtd.h>
  17
  18 #include <linux/ctype.h>
  19
  20 static struct mtd_info *get_mtd_by_name(const char *name)
  21 {
  22         struct mtd_info *mtd;
  23
  24         mtd_probe_devices();
  25
  26         mtd = get_mtd_device_nm(name);
  27         if (IS_ERR_OR_NULL(mtd))
  28                 printf("MTD device %s not found, ret %ld\n", name,
  29                        PTR_ERR(mtd));
  30
  31         return mtd;
  32 }
  33
  34 static uint mtd_len_to_pages(struct mtd_info *mtd, u64 len)
  35 {
  36         do_div(len, mtd->writesize);
  37
  38         return len;
  39 }
  40
  41 static bool mtd_is_aligned_with_min_io_size(struct mtd_info *mtd, u64 size)
  42 {
  43         return !do_div(size, mtd->writesize);
  44 }
  45
  46 static bool mtd_is_aligned_with_block_size(struct mtd_info *mtd, u64 size)
  47 {
  48         return !do_div(size, mtd->erasesize);
  49 }
  50
  51 static void mtd_dump_buf(const u8 *buf, uint len, uint offset)
  52 {
  53         int i, j;
  54
  55         for (i = 0; i < len; ) {
  56                 printf("0x%08x:\t", offset + i);
  57                 for (j = 0; j < 8; j++)
  58                         printf("%02x ", buf[i + j]);
  59                 printf(" ");
  60                 i += 8;
  61                 for (j = 0; j < 8; j++)
  62                         printf("%02x ", buf[i + j]);
  63                 printf("\n");
  64                 i += 8;
  65         }
  66 }
  67
  68 static void mtd_dump_device_buf(struct mtd_info *mtd, u64 start_off,
  69                                 const u8 *buf, u64 len, bool woob)
  70 {
  71         bool has_pages = mtd->type == MTD_NANDFLASH ||
  72                 mtd->type == MTD_MLCNANDFLASH;
  73         int npages = mtd_len_to_pages(mtd, len);
  74         uint page;
  75
  76         if (has_pages) {
  77                 for (page = 0; page < npages; page++) {
  78                         u64 data_off = page * mtd->writesize;
  79
  80                         printf("\nDump %d data bytes from 0x%08llx:\n",
  81                                mtd->writesize, start_off + data_off);
  82                         mtd_dump_buf(&buf[data_off],
  83                                      mtd->writesize, start_off + data_off);
  84
  85                         if (woob) {
  86                                 u64 oob_off = page * mtd->oobsize;
  87
  88                                 printf("Dump %d OOB bytes from page at 0x%08llx:\n",
  89                                        mtd->oobsize, start_off + data_off);
  90                                 mtd_dump_buf(&buf[len + oob_off],
  91                                              mtd->oobsize, 0);
  92                         }
  93                 }
  94         } else {
  95                 printf("\nDump %lld data bytes from 0x%llx:\n",
  96                        len, start_off);
  97                 mtd_dump_buf(buf, len, start_off);
  98         }
  99 }
 100
 101 static void mtd_show_parts(struct mtd_info *mtd, int level)
 102 {
 103         struct mtd_info *part;
 104         int i;
 105
 106         list_for_each_entry(part, &mtd->partitions, node) {
 107                 for (i = 0; i < level; i++)
 108                         printf("\t");
 109                 printf("  - 0x%012llx-0x%012llx : \"%s\"\n",
 110                        part->offset, part->offset + part->size, part->name);
 111
 112                 mtd_show_parts(part, level + 1);
 113         }
 114 }
 115
 116 static void mtd_show_device(struct mtd_info *mtd)
 117 {
 118         /* Device */
 119         printf("* %s\n", mtd->name);
 120 #if defined(CONFIG_DM)
 121         if (mtd->dev) {
 122                 printf("  - device: %s\n", mtd->dev->name);
 123                 printf("  - parent: %s\n", mtd->dev->parent->name);
 124                 printf("  - driver: %s\n", mtd->dev->driver->name);
 125         }
 126 #endif
 127
 128         /* MTD device information */
 129         printf("  - type: ");
 130         switch (mtd->type) {
 131         case MTD_RAM:
 132                 printf("RAM\n");
 133                 break;
 134         case MTD_ROM:
 135                 printf("ROM\n");
 136                 break;
 137         case MTD_NORFLASH:
 138                 printf("NOR flash\n");
 139                 break;
 140         case MTD_NANDFLASH:
 141                 printf("NAND flash\n");
 142                 break;
 143         case MTD_DATAFLASH:
 144                 printf("Data flash\n");
 145                 break;
 146         case MTD_UBIVOLUME:
 147                 printf("UBI volume\n");
 148                 break;
 149         case MTD_MLCNANDFLASH:
 150                 printf("MLC NAND flash\n");
 151                 break;
 152         case MTD_ABSENT:
 153         default:
 154                 printf("Unknown\n");
 155                 break;
 156         }
 157
 158         printf("  - block size: 0x%x bytes\n", mtd->erasesize);
 159         printf("  - min I/O: 0x%x bytes\n", mtd->writesize);
 160
 161         if (mtd->oobsize) {
 162                 printf("  - OOB size: %u bytes\n", mtd->oobsize);
 163                 printf("  - OOB available: %u bytes\n", mtd->oobavail);
 164         }
 165
 166         if (mtd->ecc_strength) {
 167                 printf("  - ECC strength: %u bits\n", mtd->ecc_strength);
 168                 printf("  - ECC step size: %u bytes\n", mtd->ecc_step_size);
 169                 printf("  - bitflip threshold: %u bits\n",
 170                        mtd->bitflip_threshold);
 171         }
 172
 173         printf("  - 0x%012llx-0x%012llx : \"%s\"\n",
 174                mtd->offset, mtd->offset + mtd->size, mtd->name);
 175
 176         /* MTD partitions, if any */
 177         mtd_show_parts(mtd, 1);
 178 }
 179
 180 /* Logic taken from fs/ubifs/recovery.c:is_empty() */
 181 static bool mtd_oob_write_is_empty(struct mtd_oob_ops *op)
 182 {
 183         int i;
 184
 185         for (i = 0; i < op->len; i++)
 186                 if (op->datbuf[i] != 0xff)
 187                         return false;
 188
 189         for (i = 0; i < op->ooblen; i++)
 190                 if (op->oobbuf[i] != 0xff)
 191                         return false;
 192
 193         return true;
 194 }
 195
 196 static int do_mtd_list(cmd_tbl_t *cmdtp, int flag, int argc,
 197                        char * const argv[])
 198 {
 199         struct mtd_info *mtd;
 200         int dev_nb = 0;
 201
 202         /* Ensure all devices (and their partitions) are probed */
 203         mtd_probe_devices();
 204
 205         printf("List of MTD devices:\n");
 206         mtd_for_each_device(mtd) {
 207                 if (!mtd_is_partition(mtd))
 208                         mtd_show_device(mtd);
 209
 210                 dev_nb++;
 211         }
 212
 213         if (!dev_nb) {
 214                 printf("No MTD device found\n");
 215                 return CMD_RET_FAILURE;
 216         }
 217
 218         return CMD_RET_SUCCESS;
 219 }
 220
 221 static int mtd_special_write_oob(struct mtd_info *mtd, u64 off,
 222                                  struct mtd_oob_ops *io_op,
 223                                  bool write_empty_pages, bool woob)
 224 {
 225         int ret = 0;
 226
 227         /*
 228          * By default, do not write an empty page.
 229          * Skip it by simulating a successful write.
 230          */
 231         if (!write_empty_pages && mtd_oob_write_is_empty(io_op)) {
 232                 io_op->retlen = mtd->writesize;
 233                 io_op->oobretlen = woob ? mtd->oobsize : 0;
 234         } else {
 235                 ret = mtd_write_oob(mtd, off, io_op);
 236         }
 237
 238         return ret;
 239 }
 240
 241 static int do_mtd_io(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 242 {
 243         bool dump, read, raw, woob, write_empty_pages, has_pages = false;
 244         u64 start_off, off, len, remaining, default_len;
 245         struct mtd_oob_ops io_op = {};
 246         uint user_addr = 0, npages;
 247         const char *cmd = argv[0];
 248         struct mtd_info *mtd;
 249         u32 oob_len;
 250         u8 *buf;
 251         int ret;
 252
 253         if (argc < 2)
 254                 return CMD_RET_USAGE;
 255
 256         mtd = get_mtd_by_name(argv[1]);
 257         if (IS_ERR_OR_NULL(mtd))
 258                 return CMD_RET_FAILURE;
 259
 260         if (mtd->type == MTD_NANDFLASH || mtd->type == MTD_MLCNANDFLASH)
 261                 has_pages = true;
 262
 263         dump = !strncmp(cmd, "dump", 4);
 264         read = dump || !strncmp(cmd, "read", 4);
 265         raw = strstr(cmd, ".raw");
 266         woob = strstr(cmd, ".oob");
 267         write_empty_pages = !has_pages || strstr(cmd, ".dontskipff");
 268
 269         argc -= 2;
 270         argv += 2;
 271
 272         if (!dump) {
 273                 if (!argc) {
 274                         ret = CMD_RET_USAGE;
 275                         goto out_put_mtd;
 276                 }
 277
 278                 user_addr = simple_strtoul(argv[0], NULL, 16);
 279                 argc--;
 280                 argv++;
 281         }
 282
 283         start_off = argc > 0 ? simple_strtoul(argv[0], NULL, 16) : 0;
 284         if (!mtd_is_aligned_with_min_io_size(mtd, start_off)) {
 285                 printf("Offset not aligned with a page (0x%x)\n",
 286                        mtd->writesize);
 287                 ret = CMD_RET_FAILURE;
 288                 goto out_put_mtd;
 289         }
 290
 291         default_len = dump ? mtd->writesize : mtd->size;
 292         len = argc > 1 ? simple_strtoul(argv[1], NULL, 16) : default_len;
 293         if (!mtd_is_aligned_with_min_io_size(mtd, len)) {
 294                 len = round_up(len, mtd->writesize);
 295                 printf("Size not on a page boundary (0x%x), rounding to 0x%llx\n",
 296                        mtd->writesize, len);
 297         }
 298
 299         remaining = len;
 300         npages = mtd_len_to_pages(mtd, len);
 301         oob_len = woob ? npages * mtd->oobsize : 0;
 302
 303         if (dump)
 304                 buf = kmalloc(len + oob_len, GFP_KERNEL);
 305         else
 306                 buf = map_sysmem(user_addr, 0);
 307
 308         if (!buf) {
 309                 printf("Could not map/allocate the user buffer\n");
 310                 ret = CMD_RET_FAILURE;
 311                 goto out_put_mtd;
 312         }
 313
 314         if (has_pages)
 315                 printf("%s %lld byte(s) (%d page(s)) at offset 0x%08llx%s%s%s\n",
 316                        read ? "Reading" : "Writing", len, npages, start_off,
 317                        raw ? " [raw]" : "", woob ? " [oob]" : "",
 318                        !read && write_empty_pages ? " [dontskipff]" : "");
 319         else
 320                 printf("%s %lld byte(s) at offset 0x%08llx\n",
 321                        read ? "Reading" : "Writing", len, start_off);
 322
 323         io_op.mode = raw ? MTD_OPS_RAW : MTD_OPS_AUTO_OOB;
 324         io_op.len = has_pages ? mtd->writesize : len;
 325         io_op.ooblen = woob ? mtd->oobsize : 0;
 326         io_op.datbuf = buf;
 327         io_op.oobbuf = woob ? &buf[len] : NULL;
 328
 329         /* Search for the first good block after the given offset */
 330         off = start_off;
 331         while (mtd_block_isbad(mtd, off))
 332                 off += mtd->erasesize;
 333
 334         /* Loop over the pages to do the actual read/write */
 335         while (remaining) {
 336                 /* Skip the block if it is bad */
 337                 if (mtd_is_aligned_with_block_size(mtd, off) &&
 338                     mtd_block_isbad(mtd, off)) {
 339                         off += mtd->erasesize;
 340                         continue;
 341                 }
 342
 343                 if (read)
 344                         ret = mtd_read_oob(mtd, off, &io_op);
 345                 else
 346                         ret = mtd_special_write_oob(mtd, off, &io_op,
 347                                                     write_empty_pages, woob);
 348
 349                 if (ret) {
 350                         printf("Failure while %s at offset 0x%llx\n",
 351                                read ? "reading" : "writing", off);
 352                         break;
 353                 }
 354
 355                 off += io_op.retlen;
 356                 remaining -= io_op.retlen;
 357                 io_op.datbuf += io_op.retlen;
 358                 io_op.oobbuf += io_op.oobretlen;
 359         }
 360
 361         if (!ret && dump)
 362                 mtd_dump_device_buf(mtd, start_off, buf, len, woob);
 363
 364         if (dump)
 365                 kfree(buf);
 366         else
 367                 unmap_sysmem(buf);
 368
 369         if (ret) {
 370                 printf("%s on %s failed with error %d\n",
 371                        read ? "Read" : "Write", mtd->name, ret);
 372                 ret = CMD_RET_FAILURE;
 373         } else {
 374                 ret = CMD_RET_SUCCESS;
 375         }
 376
 377 out_put_mtd:
 378         put_mtd_device(mtd);
 379
 380         return ret;
 381 }
 382
 383 static int do_mtd_erase(cmd_tbl_t *cmdtp, int flag, int argc,
 384                         char * const argv[])
 385 {
 386         struct erase_info erase_op = {};
 387         struct mtd_info *mtd;
 388         u64 off, len;
 389         bool scrub;
 390         int ret;
 391
 392         if (argc < 2)
 393                 return CMD_RET_USAGE;
 394
 395         mtd = get_mtd_by_name(argv[1]);
 396         if (IS_ERR_OR_NULL(mtd))
 397                 return CMD_RET_FAILURE;
 398
 399         scrub = strstr(argv[0], ".dontskipbad");
 400
 401         argc -= 2;
 402         argv += 2;
 403
 404         off = argc > 0 ? simple_strtoul(argv[0], NULL, 16) : 0;
 405         len = argc > 1 ? simple_strtoul(argv[1], NULL, 16) : mtd->size;
 406
 407         if (!mtd_is_aligned_with_block_size(mtd, off)) {
 408                 printf("Offset not aligned with a block (0x%x)\n",
 409                        mtd->erasesize);
 410                 ret = CMD_RET_FAILURE;
 411                 goto out_put_mtd;
 412         }
 413
 414         if (!mtd_is_aligned_with_block_size(mtd, len)) {
 415                 printf("Size not a multiple of a block (0x%x)\n",
 416                        mtd->erasesize);
 417                 ret = CMD_RET_FAILURE;
 418                 goto out_put_mtd;
 419         }
 420
 421         printf("Erasing 0x%08llx ... 0x%08llx (%d eraseblock(s))\n",
 422                off, off + len - 1, mtd_div_by_eb(len, mtd));
 423
 424         erase_op.mtd = mtd;
 425         erase_op.addr = off;
 426         erase_op.len = len;
 427         erase_op.scrub = scrub;
 428
 429         while (erase_op.len) {
 430                 ret = mtd_erase(mtd, &erase_op);
 431
 432                 /* Abort if its not a bad block error */
 433                 if (ret != -EIO)
 434                         break;
 435
 436                 printf("Skipping bad block at 0x%08llx\n", erase_op.fail_addr);
 437
 438                 /* Skip bad block and continue behind it */
 439                 erase_op.len -= erase_op.fail_addr - erase_op.addr;
 440                 erase_op.len -= mtd->erasesize;
 441                 erase_op.addr = erase_op.fail_addr + mtd->erasesize;
 442         }
 443
 444         if (ret && ret != -EIO)
 445                 ret = CMD_RET_FAILURE;
 446         else
 447                 ret = CMD_RET_SUCCESS;
 448
 449 out_put_mtd:
 450         put_mtd_device(mtd);
 451
 452         return ret;
 453 }
 454
 455 static int do_mtd_bad(cmd_tbl_t *cmdtp, int flag, int argc,
 456                       char * const argv[])
 457 {
 458         struct mtd_info *mtd;
 459         loff_t off;
 460
 461         if (argc < 2)
 462                 return CMD_RET_USAGE;
 463
 464         mtd = get_mtd_by_name(argv[1]);
 465         if (IS_ERR_OR_NULL(mtd))
 466                 return CMD_RET_FAILURE;
 467
 468         if (!mtd_can_have_bb(mtd)) {
 469                 printf("Only NAND-based devices can have bad blocks\n");
 470                 goto out_put_mtd;
 471         }
 472
 473         printf("MTD device %s bad blocks list:\n", mtd->name);
 474         for (off = 0; off < mtd->size; off += mtd->erasesize) {
 475                 if (mtd_block_isbad(mtd, off))
 476                         printf("\t0x%08llx\n", off);
 477         }
 478
 479 out_put_mtd:
 480         put_mtd_device(mtd);
 481
 482         return CMD_RET_SUCCESS;
 483 }
 484
 485 #ifdef CONFIG_AUTO_COMPLETE
 486 static int mtd_name_complete(int argc, char * const argv[], char last_char,
 487                              int maxv, char *cmdv[])
 488 {
 489         int len = 0, n_found = 0;
 490         struct mtd_info *mtd;
 491
 492         argc--;
 493         argv++;
 494
 495         if (argc > 1 ||
 496             (argc == 1 && (last_char == '\0' || isblank(last_char))))
 497                 return 0;
 498
 499         if (argc)
 500                 len = strlen(argv[0]);
 501
 502         mtd_for_each_device(mtd) {
 503                 if (argc &&
 504                     (len > strlen(mtd->name) ||
 505                      strncmp(argv[0], mtd->name, len)))
 506                         continue;
 507
 508                 if (n_found >= maxv - 2) {
 509                         cmdv[n_found++] = "...";
 510                         break;
 511                 }
 512
 513                 cmdv[n_found++] = mtd->name;
 514         }
 515
 516         cmdv[n_found] = NULL;
 517
 518         return n_found;
 519 }
 520 #endif /* CONFIG_AUTO_COMPLETE */
 521
 522 #ifdef CONFIG_SYS_LONGHELP
 523 static char mtd_help_text[] =
 524         "- generic operations on memory technology devices\n\n"
 525         "mtd list\n"
 526         "mtd read[.raw][.oob]                  <name> <addr> [<off> [<size>]]\n"
 527         "mtd dump[.raw][.oob]                  <name>        [<off> [<size>]]\n"
 528         "mtd write[.raw][.oob][.dontskipff]    <name> <addr> [<off> [<size>]]\n"
 529         "mtd erase[.dontskipbad]               <name>        [<off> [<size>]]\n"
 530         "\n"
 531         "Specific functions:\n"
 532         "mtd bad                               <name>\n"
 533         "\n"
 534         "With:\n"
 535         "\t<name>: NAND partition/chip name\n"
 536         "\t<addr>: user address from/to which data will be retrieved/stored\n"
 537         "\t<off>: offset in <name> in bytes (default: start of the part)\n"
 538         "\t\t* must be block-aligned for erase\n"
 539         "\t\t* must be page-aligned otherwise\n"
 540         "\t<size>: length of the operation in bytes (default: the entire device)\n"
 541         "\t\t* must be a multiple of a block for erase\n"
 542         "\t\t* must be a multiple of a page otherwise (special case: default is a page with dump)\n"
 543         "\n"
 544         "The .dontskipff option forces writing empty pages, don't use it if unsure.\n";
 545 #endif
 546
 547 U_BOOT_CMD_WITH_SUBCMDS(mtd, "MTD utils", mtd_help_text,
 548                 U_BOOT_SUBCMD_MKENT(list, 1, 1, do_mtd_list),
 549                 U_BOOT_SUBCMD_MKENT_COMPLETE(read, 5, 0, do_mtd_io,
 550                                              mtd_name_complete),
 551                 U_BOOT_SUBCMD_MKENT_COMPLETE(write, 5, 0, do_mtd_io,
 552                                              mtd_name_complete),
 553                 U_BOOT_SUBCMD_MKENT_COMPLETE(dump, 4, 0, do_mtd_io,
 554                                              mtd_name_complete),
 555                 U_BOOT_SUBCMD_MKENT_COMPLETE(erase, 4, 0, do_mtd_erase,
 556                                              mtd_name_complete),
 557                 U_BOOT_SUBCMD_MKENT_COMPLETE(bad, 2, 1, do_mtd_bad,
 558                                              mtd_name_complete));