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