cmd/jffs2.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2002
   4  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   5  *
   6  * (C) Copyright 2002
   7  * Robert Schwebel, Pengutronix, <r.schwebel@pengutronix.de>
   8  *
   9  * (C) Copyright 2003
  10  * Kai-Uwe Bloem, Auerswald GmbH & Co KG, <linux-development@auerswald.de>
  11  *
  12  * (C) Copyright 2005
  13  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  14  *
  15  *   Added support for reading flash partition table from environment.
  16  *   Parsing routines are based on driver/mtd/cmdline.c from the linux 2.4
  17  *   kernel tree.
  18  *
  19  *   $Id: cmdlinepart.c,v 1.17 2004/11/26 11:18:47 lavinen Exp $
  20  *   Copyright 2002 SYSGO Real-Time Solutions GmbH
  21  */
  22
  23 /*
  24  * Three environment variables are used by the parsing routines:
  25  *
  26  * 'partition' - keeps current partition identifier
  27  *
  28  * partition  := <part-id>
  29  * <part-id>  := <dev-id>,part_num
  30  *
  31  *
  32  * 'mtdids' - linux kernel mtd device id <-> u-boot device id mapping
  33  *
  34  * mtdids=<idmap>[,<idmap>,...]
  35  *
  36  * <idmap>    := <dev-id>=<mtd-id>
  37  * <dev-id>   := 'nand'|'nor'|'onenand'<dev-num>
  38  * <dev-num>  := mtd device number, 0...
  39  * <mtd-id>   := unique device tag used by linux kernel to find mtd device (mtd->name)
  40  *
  41  *
  42  * 'mtdparts' - partition list
  43  *
  44  * mtdparts=mtdparts=<mtd-def>[;<mtd-def>...]
  45  *
  46  * <mtd-def>  := <mtd-id>:<part-def>[,<part-def>...]
  47  * <mtd-id>   := unique device tag used by linux kernel to find mtd device (mtd->name)
  48  * <part-def> := <size>[@<offset>][<name>][<ro-flag>]
  49  * <size>     := standard linux memsize OR '-' to denote all remaining space
  50  * <offset>   := partition start offset within the device
  51  * <name>     := '(' NAME ')'
  52  * <ro-flag>  := when set to 'ro' makes partition read-only (not used, passed to kernel)
  53  *
  54  * Notes:
  55  * - each <mtd-id> used in mtdparts must albo exist in 'mtddis' mapping
  56  * - if the above variables are not set defaults for a given target are used
  57  *
  58  * Examples:
  59  *
  60  * 1 NOR Flash, with 1 single writable partition:
  61  * mtdids=nor0=edb7312-nor
  62  * mtdparts=mtdparts=edb7312-nor:-
  63  *
  64  * 1 NOR Flash with 2 partitions, 1 NAND with one
  65  * mtdids=nor0=edb7312-nor,nand0=edb7312-nand
  66  * mtdparts=mtdparts=edb7312-nor:256k(ARMboot)ro,-(root);edb7312-nand:-(home)
  67  *
  68  */
  69
  70 /*
  71  * JFFS2/CRAMFS support
  72  */
  73 #include <common.h>
  74 #include <command.h>
  75 #include <env.h>
  76 #include <image.h>
  77 #include <malloc.h>
  78 #include <jffs2/jffs2.h>
  79 #include <linux/list.h>
  80 #include <linux/ctype.h>
  81 #include <cramfs/cramfs_fs.h>
  82
  83 #if defined(CONFIG_CMD_NAND)
  84 #include <linux/mtd/rawnand.h>
  85 #include <nand.h>
  86 #endif
  87
  88 #if defined(CONFIG_CMD_ONENAND)
  89 #include <linux/mtd/mtd.h>
  90 #include <linux/mtd/onenand.h>
  91 #include <onenand_uboot.h>
  92 #endif
  93
  94 /* enable/disable debugging messages */
  95 #define DEBUG_JFFS
  96 #undef  DEBUG_JFFS
  97
  98 #ifdef  DEBUG_JFFS
  99 # define DEBUGF(fmt, args...)   printf(fmt ,##args)
 100 #else
 101 # define DEBUGF(fmt, args...)
 102 #endif
 103
 104 /* special size referring to all the remaining space in a partition */
 105 #define SIZE_REMAINING          0xFFFFFFFF
 106
 107 /* special offset value, it is used when not provided by user
 108  *
 109  * this value is used temporarily during parsing, later such offests
 110  * are recalculated */
 111 #define OFFSET_NOT_SPECIFIED    0xFFFFFFFF
 112
 113 /* minimum partition size */
 114 #define MIN_PART_SIZE           4096
 115
 116 /* this flag needs to be set in part_info struct mask_flags
 117  * field for read-only partitions */
 118 #define MTD_WRITEABLE_CMD               1
 119
 120 /* current active device and partition number */
 121 #ifdef CONFIG_CMD_MTDPARTS
 122 /* Use the ones declared in cmd_mtdparts.c */
 123 extern struct mtd_device *current_mtd_dev;
 124 extern u8 current_mtd_partnum;
 125 #else
 126 /* Use local ones */
 127 struct mtd_device *current_mtd_dev = NULL;
 128 u8 current_mtd_partnum = 0;
 129 #endif
 130
 131 #if defined(CONFIG_CMD_CRAMFS)
 132 extern int cramfs_check (struct part_info *info);
 133 extern int cramfs_load (char *loadoffset, struct part_info *info, char *filename);
 134 extern int cramfs_ls (struct part_info *info, char *filename);
 135 extern int cramfs_info (struct part_info *info);
 136 #else
 137 /* defining empty macros for function names is ugly but avoids ifdef clutter
 138  * all over the code */
 139 #define cramfs_check(x)         (0)
 140 #define cramfs_load(x,y,z)      (-1)
 141 #define cramfs_ls(x,y)          (0)
 142 #define cramfs_info(x)          (0)
 143 #endif
 144
 145 #ifndef CONFIG_CMD_MTDPARTS
 146 /**
 147  * Check device number to be within valid range for given device type.
 148  *
 149  * @param dev device to validate
 150  * @return 0 if device is valid, 1 otherwise
 151  */
 152 static int mtd_device_validate(u8 type, u8 num, u32 *size)
 153 {
 154         if (type == MTD_DEV_TYPE_NOR) {
 155 #if defined(CONFIG_CMD_FLASH)
 156                 if (num < CONFIG_SYS_MAX_FLASH_BANKS) {
 157                         extern flash_info_t flash_info[];
 158                         *size = flash_info[num].size;
 159
 160                         return 0;
 161                 }
 162
 163                 printf("no such FLASH device: %s%d (valid range 0 ... %d\n",
 164                                 MTD_DEV_TYPE(type), num, CONFIG_SYS_MAX_FLASH_BANKS - 1);
 165 #else
 166                 printf("support for FLASH devices not present\n");
 167 #endif
 168         } else if (type == MTD_DEV_TYPE_NAND) {
 169 #if defined(CONFIG_JFFS2_NAND) && defined(CONFIG_CMD_NAND)
 170                 struct mtd_info *mtd = get_nand_dev_by_index(num);
 171                 if (mtd) {
 172                         *size = mtd->size;
 173                         return 0;
 174                 }
 175
 176                 printf("no such NAND device: %s%d (valid range 0 ... %d)\n",
 177                                 MTD_DEV_TYPE(type), num, CONFIG_SYS_MAX_NAND_DEVICE - 1);
 178 #else
 179                 printf("support for NAND devices not present\n");
 180 #endif
 181         } else if (type == MTD_DEV_TYPE_ONENAND) {
 182 #if defined(CONFIG_CMD_ONENAND)
 183                 *size = onenand_mtd.size;
 184                 return 0;
 185 #else
 186                 printf("support for OneNAND devices not present\n");
 187 #endif
 188         } else
 189                 printf("Unknown defice type %d\n", type);
 190
 191         return 1;
 192 }
 193
 194 /**
 195  * Parse device id string <dev-id> := 'nand'|'nor'|'onenand'<dev-num>,
 196  * return device type and number.
 197  *
 198  * @param id string describing device id
 199  * @param ret_id output pointer to next char after parse completes (output)
 200  * @param dev_type parsed device type (output)
 201  * @param dev_num parsed device number (output)
 202  * @return 0 on success, 1 otherwise
 203  */
 204 static int mtd_id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num)
 205 {
 206         const char *p = id;
 207
 208         *dev_type = 0;
 209         if (strncmp(p, "nand", 4) == 0) {
 210                 *dev_type = MTD_DEV_TYPE_NAND;
 211                 p += 4;
 212         } else if (strncmp(p, "nor", 3) == 0) {
 213                 *dev_type = MTD_DEV_TYPE_NOR;
 214                 p += 3;
 215         } else if (strncmp(p, "onenand", 7) == 0) {
 216                 *dev_type = MTD_DEV_TYPE_ONENAND;
 217                 p += 7;
 218         } else {
 219                 printf("incorrect device type in %s\n", id);
 220                 return 1;
 221         }
 222
 223         if (!isdigit(*p)) {
 224                 printf("incorrect device number in %s\n", id);
 225                 return 1;
 226         }
 227
 228         *dev_num = simple_strtoul(p, (char **)&p, 0);
 229         if (ret_id)
 230                 *ret_id = p;
 231         return 0;
 232 }
 233
 234 /*
 235  * 'Static' version of command line mtdparts_init() routine. Single partition on
 236  * a single device configuration.
 237  */
 238
 239 /**
 240  * Calculate sector size.
 241  *
 242  * @return sector size
 243  */
 244 static inline u32 get_part_sector_size_nand(struct mtdids *id)
 245 {
 246 #if defined(CONFIG_JFFS2_NAND) && defined(CONFIG_CMD_NAND)
 247         struct mtd_info *mtd;
 248
 249         mtd = get_nand_dev_by_index(id->num);
 250
 251         return mtd->erasesize;
 252 #else
 253         BUG();
 254         return 0;
 255 #endif
 256 }
 257
 258 static inline u32 get_part_sector_size_nor(struct mtdids *id, struct part_info *part)
 259 {
 260 #if defined(CONFIG_CMD_FLASH)
 261         extern flash_info_t flash_info[];
 262
 263         u32 end_phys, start_phys, sector_size = 0, size = 0;
 264         int i;
 265         flash_info_t *flash;
 266
 267         flash = &flash_info[id->num];
 268
 269         start_phys = flash->start[0] + part->offset;
 270         end_phys = start_phys + part->size - 1;
 271
 272         for (i = 0; i < flash->sector_count; i++) {
 273                 if (flash->start[i] >= end_phys)
 274                         break;
 275
 276                 if (flash->start[i] >= start_phys) {
 277                         if (i == flash->sector_count - 1) {
 278                                 size = flash->start[0] + flash->size - flash->start[i];
 279                         } else {
 280                                 size = flash->start[i+1] - flash->start[i];
 281                         }
 282
 283                         if (sector_size < size)
 284                                 sector_size = size;
 285                 }
 286         }
 287
 288         return sector_size;
 289 #else
 290         BUG();
 291         return 0;
 292 #endif
 293 }
 294
 295 static inline u32 get_part_sector_size_onenand(void)
 296 {
 297 #if defined(CONFIG_CMD_ONENAND)
 298         struct mtd_info *mtd;
 299
 300         mtd = &onenand_mtd;
 301
 302         return mtd->erasesize;
 303 #else
 304         BUG();
 305         return 0;
 306 #endif
 307 }
 308
 309 static inline u32 get_part_sector_size(struct mtdids *id, struct part_info *part)
 310 {
 311         if (id->type == MTD_DEV_TYPE_NAND)
 312                 return get_part_sector_size_nand(id);
 313         else if (id->type == MTD_DEV_TYPE_NOR)
 314                 return get_part_sector_size_nor(id, part);
 315         else if (id->type == MTD_DEV_TYPE_ONENAND)
 316                 return get_part_sector_size_onenand();
 317         else
 318                 DEBUGF("Error: Unknown device type.\n");
 319
 320         return 0;
 321 }
 322
 323 /**
 324  * Parse and initialize global mtdids mapping and create global
 325  * device/partition list.
 326  *
 327  * 'Static' version of command line mtdparts_init() routine. Single partition on
 328  * a single device configuration.
 329  *
 330  * @return 0 on success, 1 otherwise
 331  */
 332 int mtdparts_init(void)
 333 {
 334         static int initialized = 0;
 335         u32 size;
 336         char *dev_name;
 337
 338         DEBUGF("\n---mtdparts_init---\n");
 339         if (!initialized) {
 340                 struct mtdids *id;
 341                 struct part_info *part;
 342
 343                 initialized = 1;
 344                 current_mtd_dev = (struct mtd_device *)
 345                         malloc(sizeof(struct mtd_device) +
 346                                         sizeof(struct part_info) +
 347                                         sizeof(struct mtdids));
 348                 if (!current_mtd_dev) {
 349                         printf("out of memory\n");
 350                         return 1;
 351                 }
 352                 memset(current_mtd_dev, 0, sizeof(struct mtd_device) +
 353                        sizeof(struct part_info) + sizeof(struct mtdids));
 354
 355                 id = (struct mtdids *)(current_mtd_dev + 1);
 356                 part = (struct part_info *)(id + 1);
 357
 358                 /* id */
 359                 id->mtd_id = "single part";
 360
 361 #if defined(CONFIG_JFFS2_DEV)
 362                 dev_name = CONFIG_JFFS2_DEV;
 363 #else
 364                 dev_name = "nor0";
 365 #endif
 366
 367                 if ((mtd_id_parse(dev_name, NULL, &id->type, &id->num) != 0) ||
 368                                 (mtd_device_validate(id->type, id->num, &size) != 0)) {
 369                         printf("incorrect device: %s%d\n", MTD_DEV_TYPE(id->type), id->num);
 370                         free(current_mtd_dev);
 371                         return 1;
 372                 }
 373                 id->size = size;
 374                 INIT_LIST_HEAD(&id->link);
 375
 376                 DEBUGF("dev id: type = %d, num = %d, size = 0x%08lx, mtd_id = %s\n",
 377                                 id->type, id->num, id->size, id->mtd_id);
 378
 379                 /* partition */
 380                 part->name = "static";
 381                 part->auto_name = 0;
 382
 383 #if defined(CONFIG_JFFS2_PART_SIZE)
 384                 part->size = CONFIG_JFFS2_PART_SIZE;
 385 #else
 386                 part->size = SIZE_REMAINING;
 387 #endif
 388
 389 #if defined(CONFIG_JFFS2_PART_OFFSET)
 390                 part->offset = CONFIG_JFFS2_PART_OFFSET;
 391 #else
 392                 part->offset = 0x00000000;
 393 #endif
 394
 395                 part->dev = current_mtd_dev;
 396                 INIT_LIST_HEAD(&part->link);
 397
 398                 /* recalculate size if needed */
 399                 if (part->size == SIZE_REMAINING)
 400                         part->size = id->size - part->offset;
 401
 402                 part->sector_size = get_part_sector_size(id, part);
 403
 404                 DEBUGF("part  : name = %s, size = 0x%08lx, offset = 0x%08lx\n",
 405                                 part->name, part->size, part->offset);
 406
 407                 /* device */
 408                 current_mtd_dev->id = id;
 409                 INIT_LIST_HEAD(&current_mtd_dev->link);
 410                 current_mtd_dev->num_parts = 1;
 411                 INIT_LIST_HEAD(&current_mtd_dev->parts);
 412                 list_add(&part->link, &current_mtd_dev->parts);
 413         }
 414
 415         return 0;
 416 }
 417 #endif /* #ifndef CONFIG_CMD_MTDPARTS */
 418
 419 /**
 420  * Return pointer to the partition of a requested number from a requested
 421  * device.
 422  *
 423  * @param dev device that is to be searched for a partition
 424  * @param part_num requested partition number
 425  * @return pointer to the part_info, NULL otherwise
 426  */
 427 static struct part_info* jffs2_part_info(struct mtd_device *dev, unsigned int part_num)
 428 {
 429         struct list_head *entry;
 430         struct part_info *part;
 431         int num;
 432
 433         if (!dev)
 434                 return NULL;
 435
 436         DEBUGF("\n--- jffs2_part_info: partition number %d for device %s%d (%s)\n",
 437                         part_num, MTD_DEV_TYPE(dev->id->type),
 438                         dev->id->num, dev->id->mtd_id);
 439
 440         if (part_num >= dev->num_parts) {
 441                 printf("invalid partition number %d for device %s%d (%s)\n",
 442                                 part_num, MTD_DEV_TYPE(dev->id->type),
 443                                 dev->id->num, dev->id->mtd_id);
 444                 return NULL;
 445         }
 446
 447         /* locate partition number, return it */
 448         num = 0;
 449         list_for_each(entry, &dev->parts) {
 450                 part = list_entry(entry, struct part_info, link);
 451
 452                 if (part_num == num++) {
 453                         return part;
 454                 }
 455         }
 456
 457         return NULL;
 458 }
 459
 460 /***************************************************/
 461 /* U-Boot commands                                 */
 462 /***************************************************/
 463
 464 /**
 465  * Routine implementing fsload u-boot command. This routine tries to load
 466  * a requested file from jffs2/cramfs filesystem on a current partition.
 467  *
 468  * @param cmdtp command internal data
 469  * @param flag command flag
 470  * @param argc number of arguments supplied to the command
 471  * @param argv arguments list
 472  * @return 0 on success, 1 otherwise
 473  */
 474 int do_jffs2_fsload(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 475 {
 476         char *fsname;
 477         char *filename;
 478         int size;
 479         struct part_info *part;
 480         ulong offset = image_load_addr;
 481
 482         /* pre-set Boot file name */
 483         filename = env_get("bootfile");
 484         if (!filename)
 485                 filename = "uImage";
 486
 487         if (argc == 2) {
 488                 filename = argv[1];
 489         }
 490         if (argc == 3) {
 491                 offset = simple_strtoul(argv[1], NULL, 16);
 492                 image_load_addr = offset;
 493                 filename = argv[2];
 494         }
 495
 496         /* make sure we are in sync with env variables */
 497         if (mtdparts_init() !=0)
 498                 return 1;
 499
 500         if ((part = jffs2_part_info(current_mtd_dev, current_mtd_partnum))){
 501
 502                 /* check partition type for cramfs */
 503                 fsname = (cramfs_check(part) ? "CRAMFS" : "JFFS2");
 504                 printf("### %s loading '%s' to 0x%lx\n", fsname, filename, offset);
 505
 506                 if (cramfs_check(part)) {
 507                         size = cramfs_load ((char *) offset, part, filename);
 508                 } else {
 509                         /* if this is not cramfs assume jffs2 */
 510                         size = jffs2_1pass_load((char *)offset, part, filename);
 511                 }
 512
 513                 if (size > 0) {
 514                         printf("### %s load complete: %d bytes loaded to 0x%lx\n",
 515                                 fsname, size, offset);
 516                         env_set_hex("filesize", size);
 517                 } else {
 518                         printf("### %s LOAD ERROR<%x> for %s!\n", fsname, size, filename);
 519                 }
 520
 521                 return !(size > 0);
 522         }
 523         return 1;
 524 }
 525
 526 /**
 527  * Routine implementing u-boot ls command which lists content of a given
 528  * directory on a current partition.
 529  *
 530  * @param cmdtp command internal data
 531  * @param flag command flag
 532  * @param argc number of arguments supplied to the command
 533  * @param argv arguments list
 534  * @return 0 on success, 1 otherwise
 535  */
 536 int do_jffs2_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 537 {
 538         char *filename = "/";
 539         int ret;
 540         struct part_info *part;
 541
 542         if (argc == 2)
 543                 filename = argv[1];
 544
 545         /* make sure we are in sync with env variables */
 546         if (mtdparts_init() !=0)
 547                 return 1;
 548
 549         if ((part = jffs2_part_info(current_mtd_dev, current_mtd_partnum))){
 550
 551                 /* check partition type for cramfs */
 552                 if (cramfs_check(part)) {
 553                         ret = cramfs_ls (part, filename);
 554                 } else {
 555                         /* if this is not cramfs assume jffs2 */
 556                         ret = jffs2_1pass_ls(part, filename);
 557                 }
 558
 559                 return ret ? 0 : 1;
 560         }
 561         return 1;
 562 }
 563
 564 /**
 565  * Routine implementing u-boot fsinfo command. This routine prints out
 566  * miscellaneous filesystem informations/statistics.
 567  *
 568  * @param cmdtp command internal data
 569  * @param flag command flag
 570  * @param argc number of arguments supplied to the command
 571  * @param argv arguments list
 572  * @return 0 on success, 1 otherwise
 573  */
 574 int do_jffs2_fsinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 575 {
 576         struct part_info *part;
 577         char *fsname;
 578         int ret;
 579
 580         /* make sure we are in sync with env variables */
 581         if (mtdparts_init() !=0)
 582                 return 1;
 583
 584         if ((part = jffs2_part_info(current_mtd_dev, current_mtd_partnum))){
 585
 586                 /* check partition type for cramfs */
 587                 fsname = (cramfs_check(part) ? "CRAMFS" : "JFFS2");
 588                 printf("### filesystem type is %s\n", fsname);
 589
 590                 if (cramfs_check(part)) {
 591                         ret = cramfs_info (part);
 592                 } else {
 593                         /* if this is not cramfs assume jffs2 */
 594                         ret = jffs2_1pass_info(part);
 595                 }
 596
 597                 return ret ? 0 : 1;
 598         }
 599         return 1;
 600 }
 601
 602 /***************************************************/
 603 U_BOOT_CMD(
 604         fsload, 3,      0,      do_jffs2_fsload,
 605         "load binary file from a filesystem image",
 606         "[ off ] [ filename ]\n"
 607         "    - load binary file from flash bank\n"
 608         "      with offset 'off'"
 609 );
 610 U_BOOT_CMD(
 611         fsls,   2,      1,      do_jffs2_ls,
 612         "list files in a directory (default /)",
 613         "[ directory ]"
 614 );
 615
 616 U_BOOT_CMD(
 617         fsinfo, 1,      1,      do_jffs2_fsinfo,
 618         "print information about filesystems",
 619         ""
 620 );
 621 /***************************************************/