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 * (C) Copyright 2008 20 * Harald Welte, OpenMoko, Inc., Harald Welte <laforge@openmoko.org> 21 * 22 * $Id: cmdlinepart.c,v 1.17 2004/11/26 11:18:47 lavinen Exp $ 23 * Copyright 2002 SYSGO Real-Time Solutions GmbH 24 */ 25 26/* 27 * Three environment variables are used by the parsing routines: 28 * 29 * 'partition' - keeps current partition identifier 30 * 31 * partition := <part-id> 32 * <part-id> := <dev-id>,part_num 33 * 34 * 35 * 'mtdids' - linux kernel mtd device id <-> u-boot device id mapping 36 * 37 * mtdids=<idmap>[,<idmap>,...] 38 * 39 * <idmap> := <dev-id>=<mtd-id> 40 * <dev-id> := 'nand'|'nor'|'onenand'|'spi-nand'<dev-num> 41 * <dev-num> := mtd device number, 0... 42 * <mtd-id> := unique device tag used by linux kernel to find mtd device (mtd->name) 43 * 44 * 45 * 'mtdparts' - partition list 46 * 47 * mtdparts=[mtdparts=]<mtd-def>[;<mtd-def>...] 48 * 49 * <mtd-def> := <mtd-id>:<part-def>[,<part-def>...] 50 * <mtd-id> := unique device tag used by linux kernel to find mtd device (mtd->name) 51 * <part-def> := <size>[@<offset>][<name>][<ro-flag>] 52 * <size> := standard linux memsize OR '-' to denote all remaining space 53 * <offset> := partition start offset within the device 54 * <name> := '(' NAME ')' 55 * <ro-flag> := when set to 'ro' makes partition read-only (not used, passed to kernel) 56 * 57 * Notes: 58 * - each <mtd-id> used in mtdparts must albo exist in 'mtddis' mapping 59 * - if the above variables are not set defaults for a given target are used 60 * 61 * Examples: 62 * 63 * 1 NOR Flash, with 1 single writable partition: 64 * mtdids=nor0=edb7312-nor 65 * mtdparts=[mtdparts=]edb7312-nor:- 66 * 67 * 1 NOR Flash with 2 partitions, 1 NAND with one 68 * mtdids=nor0=edb7312-nor,nand0=edb7312-nand 69 * mtdparts=[mtdparts=]edb7312-nor:256k(ARMboot)ro,-(root);edb7312-nand:-(home) 70 * 71 */ 72 73#include <common.h> 74#include <command.h> 75#include <env.h> 76#include <log.h> 77#include <malloc.h> 78#include <asm/global_data.h> 79#include <jffs2/load_kernel.h> 80#include <linux/list.h> 81#include <linux/ctype.h> 82#include <linux/err.h> 83#include <linux/mtd/mtd.h> 84 85#if defined(CONFIG_CMD_NAND) 86#include <linux/mtd/rawnand.h> 87#include <nand.h> 88#endif 89 90#if defined(CONFIG_CMD_ONENAND) 91#include <linux/mtd/onenand.h> 92#include <onenand_uboot.h> 93#endif 94 95DECLARE_GLOBAL_DATA_PTR; 96 97/* special size referring to all the remaining space in a partition */ 98#define SIZE_REMAINING (~0llu) 99 100/* special offset value, it is used when not provided by user 101 * 102 * this value is used temporarily during parsing, later such offests 103 * are recalculated */ 104#define OFFSET_NOT_SPECIFIED (~0llu) 105 106/* minimum partition size */ 107#define MIN_PART_SIZE 4096 108 109/* this flag needs to be set in part_info struct mask_flags 110 * field for read-only partitions */ 111#define MTD_WRITEABLE_CMD 1 112 113/* default values for mtdids and mtdparts variables */ 114#ifdef CONFIG_MTDIDS_DEFAULT 115#define MTDIDS_DEFAULT CONFIG_MTDIDS_DEFAULT 116#else 117#define MTDIDS_DEFAULT NULL 118#endif 119#ifdef CONFIG_MTDPARTS_DEFAULT 120#define MTDPARTS_DEFAULT CONFIG_MTDPARTS_DEFAULT 121#else 122#define MTDPARTS_DEFAULT NULL 123#endif 124 125#if defined(CONFIG_SYS_MTDPARTS_RUNTIME) 126extern void board_mtdparts_default(const char **mtdids, const char **mtdparts); 127#endif 128static const char *mtdids_default = MTDIDS_DEFAULT; 129static const char *mtdparts_default = MTDPARTS_DEFAULT; 130 131/* copies of last seen 'mtdids', 'mtdparts' and 'partition' env variables */ 132#define MTDIDS_MAXLEN 128 133#define MTDPARTS_MAXLEN 512 134#define PARTITION_MAXLEN 16 135static char last_ids[MTDIDS_MAXLEN + 1]; 136static char last_parts[MTDPARTS_MAXLEN + 1]; 137static char last_partition[PARTITION_MAXLEN + 1]; 138 139/* low level jffs2 cache cleaning routine */ 140extern void jffs2_free_cache(struct part_info *part); 141 142/* mtdids mapping list, filled by parse_ids() */ 143static struct list_head mtdids; 144 145/* device/partition list, parse_cmdline() parses into here */ 146static struct list_head devices; 147 148/* current active device and partition number */ 149struct mtd_device *current_mtd_dev = NULL; 150u8 current_mtd_partnum = 0; 151 152u8 use_defaults; 153 154static struct part_info* mtd_part_info(struct mtd_device *dev, unsigned int part_num); 155 156/* command line only routines */ 157static struct mtdids* id_find_by_mtd_id(const char *mtd_id, unsigned int mtd_id_len); 158static int device_del(struct mtd_device *dev); 159 160/** 161 * Parses a string into a number. The number stored at ptr is 162 * potentially suffixed with K (for kilobytes, or 1024 bytes), 163 * M (for megabytes, or 1048576 bytes), or G (for gigabytes, or 164 * 1073741824). If the number is suffixed with K, M, or G, then 165 * the return value is the number multiplied by one kilobyte, one 166 * megabyte, or one gigabyte, respectively. 167 * 168 * @param ptr where parse begins 169 * @param retptr output pointer to next char after parse completes (output) 170 * Return: resulting unsigned int 171 */ 172static u64 memsize_parse (const char *const ptr, const char **retptr) 173{ 174 u64 ret = simple_strtoull(ptr, (char **)retptr, 0); 175 176 switch (**retptr) { 177 case 'G': 178 case 'g': 179 ret <<= 10; 180 /* Fallthrough */ 181 case 'M': 182 case 'm': 183 ret <<= 10; 184 /* Fallthrough */ 185 case 'K': 186 case 'k': 187 ret <<= 10; 188 (*retptr)++; 189 /* Fallthrough */ 190 default: 191 break; 192 } 193 194 return ret; 195} 196 197/** 198 * Format string describing supplied size. This routine does the opposite job 199 * to memsize_parse(). Size in bytes is converted to string and if possible 200 * shortened by using k (kilobytes), m (megabytes) or g (gigabytes) suffix. 201 * 202 * Note, that this routine does not check for buffer overflow, it's the caller 203 * who must assure enough space. 204 * 205 * @param buf output buffer 206 * @param size size to be converted to string 207 */ 208static void memsize_format(char *buf, u64 size) 209{ 210#define SIZE_GB ((u32)1024*1024*1024) 211#define SIZE_MB ((u32)1024*1024) 212#define SIZE_KB ((u32)1024) 213 214 if ((size % SIZE_GB) == 0) 215 sprintf(buf, "%llug", size/SIZE_GB); 216 else if ((size % SIZE_MB) == 0) 217 sprintf(buf, "%llum", size/SIZE_MB); 218 else if (size % SIZE_KB == 0) 219 sprintf(buf, "%lluk", size/SIZE_KB); 220 else 221 sprintf(buf, "%llu", size); 222} 223 224/** 225 * This routine does global indexing of all partitions. Resulting index for 226 * current partition is saved in 'mtddevnum'. Current partition name in 227 * 'mtddevname'. 228 */ 229static void index_partitions(void) 230{ 231 u16 mtddevnum; 232 struct part_info *part; 233 struct list_head *dentry; 234 struct mtd_device *dev; 235 236 debug("--- index partitions ---\n"); 237 238 if (current_mtd_dev) { 239 mtddevnum = 0; 240 list_for_each(dentry, &devices) { 241 dev = list_entry(dentry, struct mtd_device, link); 242 if (dev == current_mtd_dev) { 243 mtddevnum += current_mtd_partnum; 244 env_set_ulong("mtddevnum", mtddevnum); 245 debug("=> mtddevnum %d,\n", mtddevnum); 246 break; 247 } 248 mtddevnum += dev->num_parts; 249 } 250 251 part = mtd_part_info(current_mtd_dev, current_mtd_partnum); 252 if (part) { 253 env_set("mtddevname", part->name); 254 255 debug("=> mtddevname %s\n", part->name); 256 } else { 257 env_set("mtddevname", NULL); 258 259 debug("=> mtddevname NULL\n"); 260 } 261 } else { 262 env_set("mtddevnum", NULL); 263 env_set("mtddevname", NULL); 264 265 debug("=> mtddevnum NULL\n=> mtddevname NULL\n"); 266 } 267} 268 269/** 270 * Save current device and partition in environment variable 'partition'. 271 */ 272static void current_save(void) 273{ 274 char buf[16]; 275 276 debug("--- current_save ---\n"); 277 278 if (current_mtd_dev) { 279 sprintf(buf, "%s%d,%d", MTD_DEV_TYPE(current_mtd_dev->id->type), 280 current_mtd_dev->id->num, current_mtd_partnum); 281 282 env_set("partition", buf); 283 strncpy(last_partition, buf, 16); 284 285 debug("=> partition %s\n", buf); 286 } else { 287 env_set("partition", NULL); 288 last_partition[0] = '\0'; 289 290 debug("=> partition NULL\n"); 291 } 292 index_partitions(); 293} 294 295 296/** 297 * Produce a mtd_info given a type and num. 298 * 299 * @param type mtd type 300 * @param num mtd number 301 * @param mtd a pointer to an mtd_info instance (output) 302 * Return: 0 if device is valid, 1 otherwise 303 */ 304static int get_mtd_info(u8 type, u8 num, struct mtd_info **mtd) 305{ 306 char mtd_dev[16]; 307 308 sprintf(mtd_dev, "%s%d", MTD_DEV_TYPE(type), num); 309 *mtd = get_mtd_device_nm(mtd_dev); 310 if (IS_ERR(*mtd)) { 311 printf("Device %s not found!\n", mtd_dev); 312 return 1; 313 } 314 put_mtd_device(*mtd); 315 316 return 0; 317} 318 319/** 320 * Performs sanity check for supplied flash partition. 321 * Table of existing MTD flash devices is searched and partition device 322 * is located. Alignment with the granularity of nand erasesize is verified. 323 * 324 * @param id of the parent device 325 * @param part partition to validate 326 * Return: 0 if partition is valid, 1 otherwise 327 */ 328static int part_validate_eraseblock(struct mtdids *id, struct part_info *part) 329{ 330 struct mtd_info *mtd = NULL; 331 int i, j; 332 ulong start; 333 u64 offset, size; 334 335 if (get_mtd_info(id->type, id->num, &mtd)) 336 return 1; 337 338 part->sector_size = mtd->erasesize; 339 340 if (!mtd->numeraseregions) { 341 /* 342 * Only one eraseregion (NAND, SPI-NAND, OneNAND or uniform NOR), 343 * checking for alignment is easy here 344 */ 345 offset = part->offset; 346 if (do_div(offset, mtd->erasesize)) { 347 printf("%s%d: partition (%s) start offset" 348 "alignment incorrect\n", 349 MTD_DEV_TYPE(id->type), id->num, part->name); 350 return 1; 351 } 352 353 size = part->size; 354 if (do_div(size, mtd->erasesize)) { 355 printf("%s%d: partition (%s) size alignment incorrect\n", 356 MTD_DEV_TYPE(id->type), id->num, part->name); 357 return 1; 358 } 359 } else { 360 /* 361 * Multiple eraseregions (non-uniform NOR), 362 * checking for alignment is more complex here 363 */ 364 365 /* Check start alignment */ 366 for (i = 0; i < mtd->numeraseregions; i++) { 367 start = mtd->eraseregions[i].offset; 368 for (j = 0; j < mtd->eraseregions[i].numblocks; j++) { 369 if (part->offset == start) 370 goto start_ok; 371 start += mtd->eraseregions[i].erasesize; 372 } 373 } 374 375 printf("%s%d: partition (%s) start offset alignment incorrect\n", 376 MTD_DEV_TYPE(id->type), id->num, part->name); 377 return 1; 378 379 start_ok: 380 381 /* Check end/size alignment */ 382 for (i = 0; i < mtd->numeraseregions; i++) { 383 start = mtd->eraseregions[i].offset; 384 for (j = 0; j < mtd->eraseregions[i].numblocks; j++) { 385 if ((part->offset + part->size) == start) 386 goto end_ok; 387 start += mtd->eraseregions[i].erasesize; 388 } 389 } 390 /* Check last sector alignment */ 391 if ((part->offset + part->size) == start) 392 goto end_ok; 393 394 printf("%s%d: partition (%s) size alignment incorrect\n", 395 MTD_DEV_TYPE(id->type), id->num, part->name); 396 return 1; 397 398 end_ok: 399 return 0; 400 } 401 402 return 0; 403} 404 405 406/** 407 * Performs sanity check for supplied partition. Offset and size are 408 * verified to be within valid range. Partition type is checked and 409 * part_validate_eraseblock() is called with the argument of part. 410 * 411 * @param id of the parent device 412 * @param part partition to validate 413 * Return: 0 if partition is valid, 1 otherwise 414 */ 415static int part_validate(struct mtdids *id, struct part_info *part) 416{ 417 if (part->size == SIZE_REMAINING) 418 part->size = id->size - part->offset; 419 420 if (part->offset > id->size) { 421 printf("%s: offset %08llx beyond flash size %08llx\n", 422 id->mtd_id, part->offset, id->size); 423 return 1; 424 } 425 426 if ((part->offset + part->size) <= part->offset) { 427 printf("%s%d: partition (%s) size too big\n", 428 MTD_DEV_TYPE(id->type), id->num, part->name); 429 return 1; 430 } 431 432 if (part->offset + part->size > id->size) { 433 printf("%s: partitioning exceeds flash size\n", id->mtd_id); 434 return 1; 435 } 436 437 /* 438 * Now we need to check if the partition starts and ends on 439 * sector (eraseblock) regions 440 */ 441 return part_validate_eraseblock(id, part); 442} 443 444/** 445 * Delete selected partition from the partition list of the specified device. 446 * 447 * @param dev device to delete partition from 448 * @param part partition to delete 449 * Return: 0 on success, 1 otherwise 450 */ 451static int part_del(struct mtd_device *dev, struct part_info *part) 452{ 453 u8 current_save_needed = 0; 454 455 /* if there is only one partition, remove whole device */ 456 if (dev->num_parts == 1) 457 return device_del(dev); 458 459 /* otherwise just delete this partition */ 460 461 if (dev == current_mtd_dev) { 462 /* we are modyfing partitions for the current device, 463 * update current */ 464 struct part_info *curr_pi; 465 curr_pi = mtd_part_info(current_mtd_dev, current_mtd_partnum); 466 467 if (curr_pi) { 468 if (curr_pi == part) { 469 printf("current partition deleted, resetting current to 0\n"); 470 current_mtd_partnum = 0; 471 } else if (part->offset <= curr_pi->offset) { 472 current_mtd_partnum--; 473 } 474 current_save_needed = 1; 475 } 476 } 477 478 list_del(&part->link); 479 free(part); 480 dev->num_parts--; 481 482 if (current_save_needed > 0) 483 current_save(); 484 else 485 index_partitions(); 486 487 return 0; 488} 489 490/** 491 * Delete all partitions from parts head list, free memory. 492 * 493 * @param head list of partitions to delete 494 */ 495static void part_delall(struct list_head *head) 496{ 497 struct list_head *entry, *n; 498 struct part_info *part_tmp; 499 500 /* clean tmp_list and free allocated memory */ 501 list_for_each_safe(entry, n, head) { 502 part_tmp = list_entry(entry, struct part_info, link); 503 504 list_del(entry); 505 free(part_tmp); 506 } 507} 508 509/** 510 * Add new partition to the supplied partition list. Make sure partitions are 511 * sorted by offset in ascending order. 512 * 513 * @param head list this partition is to be added to 514 * @param new partition to be added 515 */ 516static int part_sort_add(struct mtd_device *dev, struct part_info *part) 517{ 518 struct list_head *entry; 519 struct part_info *new_pi, *curr_pi; 520 521 /* link partition to parrent dev */ 522 part->dev = dev; 523 524 if (list_empty(&dev->parts)) { 525 debug("part_sort_add: list empty\n"); 526 list_add(&part->link, &dev->parts); 527 dev->num_parts++; 528 index_partitions(); 529 return 0; 530 } 531 532 new_pi = list_entry(&part->link, struct part_info, link); 533 534 /* get current partition info if we are updating current device */ 535 curr_pi = NULL; 536 if (dev == current_mtd_dev) 537 curr_pi = mtd_part_info(current_mtd_dev, current_mtd_partnum); 538 539 list_for_each(entry, &dev->parts) { 540 struct part_info *pi; 541 542 pi = list_entry(entry, struct part_info, link); 543 544 /* be compliant with kernel cmdline, allow only one partition at offset zero */ 545 if ((new_pi->offset == pi->offset) && (pi->offset == 0)) { 546 printf("cannot add second partition at offset 0\n"); 547 return 1; 548 } 549 550 if (new_pi->offset <= pi->offset) { 551 list_add_tail(&part->link, entry); 552 dev->num_parts++; 553 554 if (curr_pi && (pi->offset <= curr_pi->offset)) { 555 /* we are modyfing partitions for the current 556 * device, update current */ 557 current_mtd_partnum++; 558 current_save(); 559 } else { 560 index_partitions(); 561 } 562 return 0; 563 } 564 } 565 566 list_add_tail(&part->link, &dev->parts); 567 dev->num_parts++; 568 index_partitions(); 569 return 0; 570} 571 572/** 573 * Add provided partition to the partition list of a given device. 574 * 575 * @param dev device to which partition is added 576 * @param part partition to be added 577 * Return: 0 on success, 1 otherwise 578 */ 579static int part_add(struct mtd_device *dev, struct part_info *part) 580{ 581 /* verify alignment and size */ 582 if (part_validate(dev->id, part) != 0) 583 return 1; 584 585 /* partition is ok, add it to the list */ 586 if (part_sort_add(dev, part) != 0) 587 return 1; 588 589 return 0; 590} 591 592/** 593 * Parse one partition definition, allocate memory and return pointer to this 594 * location in retpart. 595 * 596 * @param partdef pointer to the partition definition string i.e. <part-def> 597 * @param ret output pointer to next char after parse completes (output) 598 * @param retpart pointer to the allocated partition (output) 599 * Return: 0 on success, 1 otherwise 600 */ 601static int part_parse(const char *const partdef, const char **ret, struct part_info **retpart) 602{ 603 struct part_info *part; 604 u64 size; 605 u64 offset; 606 const char *name; 607 int name_len; 608 unsigned int mask_flags; 609 const char *p; 610 611 p = partdef; 612 *retpart = NULL; 613 *ret = NULL; 614 615 /* fetch the partition size */ 616 if (*p == '-') { 617 /* assign all remaining space to this partition */ 618 debug("'-': remaining size assigned\n"); 619 size = SIZE_REMAINING; 620 p++; 621 } else { 622 size = memsize_parse(p, &p); 623 if (size < MIN_PART_SIZE) { 624 printf("partition size too small (%llx)\n", size); 625 return 1; 626 } 627 } 628 629 /* check for offset */ 630 offset = OFFSET_NOT_SPECIFIED; 631 if (*p == '@') { 632 p++; 633 offset = memsize_parse(p, &p); 634 } 635 636 /* now look for the name */ 637 if (*p == '(') { 638 name = ++p; 639 if ((p = strchr(name, ')')) == NULL) { 640 printf("no closing ) found in partition name\n"); 641 return 1; 642 } 643 name_len = p - name + 1; 644 if ((name_len - 1) == 0) { 645 printf("empty partition name\n"); 646 return 1; 647 } 648 p++; 649 } else { 650 /* 0x00000000@0x00000000 */ 651 name_len = 22; 652 name = NULL; 653 } 654 655 /* test for options */ 656 mask_flags = 0; 657 if (strncmp(p, "ro", 2) == 0) { 658 mask_flags |= MTD_WRITEABLE_CMD; 659 p += 2; 660 } 661 662 /* check for next partition definition */ 663 if (*p == ',') { 664 if (size == SIZE_REMAINING) { 665 *ret = NULL; 666 printf("no partitions allowed after a fill-up partition\n"); 667 return 1; 668 } 669 *ret = ++p; 670 } else if ((*p == ';') || (*p == '\0')) { 671 *ret = p; 672 } else { 673 printf("unexpected character '%c' at the end of partition\n", *p); 674 *ret = NULL; 675 return 1; 676 } 677 678 /* allocate memory */ 679 part = (struct part_info *)malloc(sizeof(struct part_info) + name_len); 680 if (!part) { 681 printf("out of memory\n"); 682 return 1; 683 } 684 memset(part, 0, sizeof(struct part_info) + name_len); 685 part->size = size; 686 part->offset = offset; 687 part->mask_flags = mask_flags; 688 part->name = (char *)(part + 1); 689 690 if (name) { 691 /* copy user provided name */ 692 strncpy(part->name, name, name_len - 1); 693 part->auto_name = 0; 694 } else { 695 /* auto generated name in form of size@offset */ 696 snprintf(part->name, name_len, "0x%08llx@0x%08llx", size, offset); 697 part->auto_name = 1; 698 } 699 700 part->name[name_len - 1] = '\0'; 701 INIT_LIST_HEAD(&part->link); 702 703 debug("+ partition: name %-22s size 0x%08llx offset 0x%08llx mask flags %d\n", 704 part->name, part->size, 705 part->offset, part->mask_flags); 706 707 *retpart = part; 708 return 0; 709} 710 711/** 712 * Check device number to be within valid range for given device type. 713 * 714 * @param type mtd type 715 * @param num mtd number 716 * @param size a pointer to the size of the mtd device (output) 717 * Return: 0 if device is valid, 1 otherwise 718 */ 719static int mtd_device_validate(u8 type, u8 num, u64 *size) 720{ 721 struct mtd_info *mtd = NULL; 722 723 if (get_mtd_info(type, num, &mtd)) 724 return 1; 725 726 *size = mtd->size; 727 728 return 0; 729} 730 731/** 732 * Delete all mtd devices from a supplied devices list, free memory allocated for 733 * each device and delete all device partitions. 734 * 735 * Return: 0 on success, 1 otherwise 736 */ 737static int device_delall(struct list_head *head) 738{ 739 struct list_head *entry, *n; 740 struct mtd_device *dev_tmp; 741 742 /* clean devices list */ 743 list_for_each_safe(entry, n, head) { 744 dev_tmp = list_entry(entry, struct mtd_device, link); 745 list_del(entry); 746 part_delall(&dev_tmp->parts); 747 free(dev_tmp); 748 } 749 INIT_LIST_HEAD(&devices); 750 751 return 0; 752} 753 754/** 755 * If provided device exists it's partitions are deleted, device is removed 756 * from device list and device memory is freed. 757 * 758 * @param dev device to be deleted 759 * Return: 0 on success, 1 otherwise 760 */ 761static int device_del(struct mtd_device *dev) 762{ 763 part_delall(&dev->parts); 764 list_del(&dev->link); 765 free(dev); 766 767 if (dev == current_mtd_dev) { 768 /* we just deleted current device */ 769 if (list_empty(&devices)) { 770 current_mtd_dev = NULL; 771 } else { 772 /* reset first partition from first dev from the 773 * devices list as current */ 774 current_mtd_dev = list_entry(devices.next, struct mtd_device, link); 775 current_mtd_partnum = 0; 776 } 777 current_save(); 778 return 0; 779 } 780 781 index_partitions(); 782 return 0; 783} 784 785/** 786 * Search global device list and return pointer to the device of type and num 787 * specified. 788 * 789 * @param type device type 790 * @param num device number 791 * Return: NULL if requested device does not exist 792 */ 793struct mtd_device *device_find(u8 type, u8 num) 794{ 795 struct list_head *entry; 796 struct mtd_device *dev_tmp; 797 798 list_for_each(entry, &devices) { 799 dev_tmp = list_entry(entry, struct mtd_device, link); 800 801 if ((dev_tmp->id->type == type) && (dev_tmp->id->num == num)) 802 return dev_tmp; 803 } 804 805 return NULL; 806} 807 808/** 809 * Add specified device to the global device list. 810 * 811 * @param dev device to be added 812 */ 813static void device_add(struct mtd_device *dev) 814{ 815 u8 current_save_needed = 0; 816 817 if (list_empty(&devices)) { 818 current_mtd_dev = dev; 819 current_mtd_partnum = 0; 820 current_save_needed = 1; 821 } 822 823 list_add_tail(&dev->link, &devices); 824 825 if (current_save_needed > 0) 826 current_save(); 827 else 828 index_partitions(); 829} 830 831/** 832 * Parse device type, name and mtd-id. If syntax is ok allocate memory and 833 * return pointer to the device structure. 834 * 835 * @param mtd_dev pointer to the device definition string i.e. <mtd-dev> 836 * @param ret output pointer to next char after parse completes (output) 837 * @param retdev pointer to the allocated device (output) 838 * Return: 0 on success, 1 otherwise 839 */ 840static int device_parse(const char *const mtd_dev, const char **ret, struct mtd_device **retdev) 841{ 842 struct mtd_device *dev; 843 struct part_info *part; 844 struct mtdids *id; 845 const char *mtd_id; 846 unsigned int mtd_id_len; 847 const char *p; 848 const char *pend; 849 LIST_HEAD(tmp_list); 850 struct list_head *entry, *n; 851 u16 num_parts; 852 u64 offset; 853 int err = 1; 854 855 debug("===device_parse===\n"); 856 857 assert(retdev); 858 *retdev = NULL; 859 860 if (ret) 861 *ret = NULL; 862 863 /* fetch <mtd-id> */ 864 mtd_id = p = mtd_dev; 865 if (!(p = strchr(mtd_id, ':'))) { 866 printf("no <mtd-id> identifier\n"); 867 return 1; 868 } 869 mtd_id_len = p - mtd_id + 1; 870 p++; 871 872 /* verify if we have a valid device specified */ 873 if ((id = id_find_by_mtd_id(mtd_id, mtd_id_len - 1)) == NULL) { 874 printf("invalid mtd device '%.*s'\n", mtd_id_len - 1, mtd_id); 875 return 1; 876 } 877 878 pend = strchr(p, ';'); 879 debug("dev type = %d (%s), dev num = %d, mtd-id = %s\n", 880 id->type, MTD_DEV_TYPE(id->type), 881 id->num, id->mtd_id); 882 debug("parsing partitions %.*s\n", (int)(pend ? pend - p : strlen(p)), p); 883 884 /* parse partitions */ 885 num_parts = 0; 886 887 offset = 0; 888 if ((dev = device_find(id->type, id->num)) != NULL) { 889 /* if device already exists start at the end of the last partition */ 890 part = list_entry(dev->parts.prev, struct part_info, link); 891 offset = part->offset + part->size; 892 } 893 894 while (p && (*p != '\0') && (*p != ';')) { 895 err = 1; 896 if ((part_parse(p, &p, &part) != 0) || (!part)) 897 break; 898 899 /* calculate offset when not specified */ 900 if (part->offset == OFFSET_NOT_SPECIFIED) 901 part->offset = offset; 902 else 903 offset = part->offset; 904 905 /* verify alignment and size */ 906 if (part_validate(id, part) != 0) 907 break; 908 909 offset += part->size; 910 911 /* partition is ok, add it to the list */ 912 list_add_tail(&part->link, &tmp_list); 913 num_parts++; 914 err = 0; 915 } 916 if (err == 1) { 917 part_delall(&tmp_list); 918 return 1; 919 } 920 921 debug("\ntotal partitions: %d\n", num_parts); 922 923 /* check for next device presence */ 924 if (p) { 925 if (*p == ';') { 926 if (ret) 927 *ret = ++p; 928 } else if (*p == '\0') { 929 if (ret) 930 *ret = p; 931 } else { 932 printf("unexpected character '%c' at the end of device\n", *p); 933 if (ret) 934 *ret = NULL; 935 return 1; 936 } 937 } 938 939 /* allocate memory for mtd_device structure */ 940 if ((dev = (struct mtd_device *)malloc(sizeof(struct mtd_device))) == NULL) { 941 printf("out of memory\n"); 942 return 1; 943 } 944 memset(dev, 0, sizeof(struct mtd_device)); 945 dev->id = id; 946 dev->num_parts = 0; /* part_sort_add increments num_parts */ 947 INIT_LIST_HEAD(&dev->parts); 948 INIT_LIST_HEAD(&dev->link); 949 950 /* move partitions from tmp_list to dev->parts */ 951 list_for_each_safe(entry, n, &tmp_list) { 952 part = list_entry(entry, struct part_info, link); 953 list_del(entry); 954 if (part_sort_add(dev, part) != 0) { 955 device_del(dev); 956 return 1; 957 } 958 } 959 960 *retdev = dev; 961 962 debug("===\n\n"); 963 return 0; 964} 965 966/** 967 * Initialize global device list. 968 * 969 * Return: 0 on success, 1 otherwise 970 */ 971static int mtd_devices_init(void) 972{ 973 last_parts[0] = '\0'; 974 current_mtd_dev = NULL; 975 current_save(); 976 977 return device_delall(&devices); 978} 979 980/* 981 * Search global mtdids list and find id of requested type and number. 982 * 983 * Return: pointer to the id if it exists, NULL otherwise 984 */ 985static struct mtdids* id_find(u8 type, u8 num) 986{ 987 struct list_head *entry; 988 struct mtdids *id; 989 990 list_for_each(entry, &mtdids) { 991 id = list_entry(entry, struct mtdids, link); 992 993 if ((id->type == type) && (id->num == num)) 994 return id; 995 } 996 997 return NULL; 998} 999 1000/** 1001 * Search global mtdids list and find id of a requested mtd_id. 1002 * 1003 * Note: first argument is not null terminated. 1004 * 1005 * @param mtd_id string containing requested mtd_id 1006 * @param mtd_id_len length of supplied mtd_id 1007 * Return: pointer to the id if it exists, NULL otherwise 1008 */ 1009static struct mtdids* id_find_by_mtd_id(const char *mtd_id, unsigned int mtd_id_len) 1010{ 1011 struct list_head *entry; 1012 struct mtdids *id; 1013 1014 debug("--- id_find_by_mtd_id: '%.*s' (len = %d)\n", 1015 mtd_id_len, mtd_id, mtd_id_len); 1016 1017 list_for_each(entry, &mtdids) { 1018 id = list_entry(entry, struct mtdids, link); 1019 1020 debug("entry: '%s' (len = %zu)\n", 1021 id->mtd_id, strlen(id->mtd_id)); 1022 1023 if (mtd_id_len != strlen(id->mtd_id)) 1024 continue; 1025 if (strncmp(id->mtd_id, mtd_id, mtd_id_len) == 0) 1026 return id; 1027 } 1028 1029 return NULL; 1030} 1031 1032/** 1033 * Parse device id string <dev-id> := 'nand'|'nor'|'onenand'|'spi-nand'<dev-num>, 1034 * return device type and number. 1035 * 1036 * @param id string describing device id 1037 * @param ret_id output pointer to next char after parse completes (output) 1038 * @param dev_type parsed device type (output) 1039 * @param dev_num parsed device number (output) 1040 * Return: 0 on success, 1 otherwise 1041 */ 1042int mtd_id_parse(const char *id, const char **ret_id, u8 *dev_type, 1043 u8 *dev_num) 1044{ 1045 const char *p = id; 1046 1047 *dev_type = 0; 1048 if (strncmp(p, "nand", 4) == 0) { 1049 *dev_type = MTD_DEV_TYPE_NAND; 1050 p += 4; 1051 } else if (strncmp(p, "nor", 3) == 0) { 1052 *dev_type = MTD_DEV_TYPE_NOR; 1053 p += 3; 1054 } else if (strncmp(p, "onenand", 7) == 0) { 1055 *dev_type = MTD_DEV_TYPE_ONENAND; 1056 p += 7; 1057 } else if (strncmp(p, "spi-nand", 8) == 0) { 1058 *dev_type = MTD_DEV_TYPE_SPINAND; 1059 p += 8; 1060 } else { 1061 printf("incorrect device type in %s\n", id); 1062 return 1; 1063 } 1064 1065 if (!isdigit(*p)) { 1066 printf("incorrect device number in %s\n", id); 1067 return 1; 1068 } 1069 1070 *dev_num = simple_strtoul(p, (char **)&p, 0); 1071 if (ret_id) 1072 *ret_id = p; 1073 return 0; 1074} 1075 1076/** 1077 * Process all devices and generate corresponding mtdparts string describing 1078 * all partitions on all devices. 1079 * 1080 * @param buf output buffer holding generated mtdparts string (output) 1081 * @param buflen buffer size 1082 * Return: 0 on success, 1 otherwise 1083 */ 1084static int generate_mtdparts(char *buf, u32 buflen) 1085{ 1086 struct list_head *pentry, *dentry; 1087 struct mtd_device *dev; 1088 struct part_info *part, *prev_part; 1089 char *p = buf; 1090 char tmpbuf[32]; 1091 u64 size, offset; 1092 u32 len, part_cnt; 1093 u32 maxlen = buflen - 1; 1094 1095 debug("--- generate_mtdparts ---\n"); 1096 1097 if (list_empty(&devices)) { 1098 buf[0] = '\0'; 1099 return 0; 1100 } 1101 1102 list_for_each(dentry, &devices) { 1103 dev = list_entry(dentry, struct mtd_device, link); 1104 1105 /* copy mtd_id */ 1106 len = strlen(dev->id->mtd_id) + 1; 1107 if (len > maxlen) 1108 goto cleanup; 1109 memcpy(p, dev->id->mtd_id, len - 1); 1110 p += len - 1; 1111 *(p++) = ':'; 1112 maxlen -= len; 1113 1114 /* format partitions */ 1115 prev_part = NULL; 1116 part_cnt = 0; 1117 list_for_each(pentry, &dev->parts) { 1118 part = list_entry(pentry, struct part_info, link); 1119 size = part->size; 1120 offset = part->offset; 1121 part_cnt++; 1122 1123 /* partition size */ 1124 memsize_format(tmpbuf, size); 1125 len = strlen(tmpbuf); 1126 if (len > maxlen) 1127 goto cleanup; 1128 memcpy(p, tmpbuf, len); 1129 p += len; 1130 maxlen -= len; 1131 1132 1133 /* add offset only when there is a gap between 1134 * partitions */ 1135 if ((!prev_part && (offset != 0)) || 1136 (prev_part && ((prev_part->offset + prev_part->size) != part->offset))) { 1137 1138 memsize_format(tmpbuf, offset); 1139 len = strlen(tmpbuf) + 1; 1140 if (len > maxlen) 1141 goto cleanup; 1142 *(p++) = '@'; 1143 memcpy(p, tmpbuf, len - 1); 1144 p += len - 1; 1145 maxlen -= len; 1146 } 1147 1148 /* copy name only if user supplied */ 1149 if(!part->auto_name) { 1150 len = strlen(part->name) + 2; 1151 if (len > maxlen) 1152 goto cleanup; 1153 1154 *(p++) = '('; 1155 memcpy(p, part->name, len - 2); 1156 p += len - 2; 1157 *(p++) = ')'; 1158 maxlen -= len; 1159 } 1160 1161 /* ro mask flag */ 1162 if (part->mask_flags && MTD_WRITEABLE_CMD) { 1163 len = 2; 1164 if (len > maxlen) 1165 goto cleanup; 1166 *(p++) = 'r'; 1167 *(p++) = 'o'; 1168 maxlen -= 2; 1169 } 1170 1171 /* print ',' separator if there are other partitions 1172 * following */ 1173 if (dev->num_parts > part_cnt) { 1174 if (1 > maxlen) 1175 goto cleanup; 1176 *(p++) = ','; 1177 maxlen--; 1178 } 1179 prev_part = part; 1180 } 1181 /* print ';' separator if there are other devices following */ 1182 if (dentry->next != &devices) { 1183 if (1 > maxlen) 1184 goto cleanup; 1185 *(p++) = ';'; 1186 maxlen--; 1187 } 1188 } 1189 1190 /* we still have at least one char left, as we decremented maxlen at 1191 * the begining */ 1192 *p = '\0'; 1193 1194 return 0; 1195 1196cleanup: 1197 last_parts[0] = '\0'; 1198 return 1; 1199} 1200 1201/** 1202 * Call generate_mtdparts to process all devices and generate corresponding 1203 * mtdparts string, save it in mtdparts environment variable. 1204 * 1205 * @param buf output buffer holding generated mtdparts string (output) 1206 * @param buflen buffer size 1207 * Return: 0 on success, 1 otherwise 1208 */ 1209static int generate_mtdparts_save(char *buf, u32 buflen) 1210{ 1211 int ret; 1212 1213 ret = generate_mtdparts(buf, buflen); 1214 1215 if ((buf[0] != '\0') && (ret == 0)) 1216 env_set("mtdparts", buf); 1217 else 1218 env_set("mtdparts", NULL); 1219 1220 return ret; 1221} 1222 1223#if defined(CONFIG_CMD_MTDPARTS_SHOW_NET_SIZES) 1224/** 1225 * Get the net size (w/o bad blocks) of the given partition. 1226 * 1227 * @param mtd the mtd info 1228 * @param part the partition 1229 * Return: the calculated net size of this partition 1230 */ 1231static uint64_t net_part_size(struct mtd_info *mtd, struct part_info *part) 1232{ 1233 uint64_t i, net_size = 0; 1234 1235 if (!mtd->_block_isbad) 1236 return part->size; 1237 1238 for (i = 0; i < part->size; i += mtd->erasesize) { 1239 if (!mtd->_block_isbad(mtd, part->offset + i)) 1240 net_size += mtd->erasesize; 1241 } 1242 1243 return net_size; 1244} 1245#endif 1246 1247static void print_partition_table(void) 1248{ 1249 struct list_head *dentry, *pentry; 1250 struct part_info *part; 1251 struct mtd_device *dev; 1252 int part_num; 1253 1254 list_for_each(dentry, &devices) { 1255 dev = list_entry(dentry, struct mtd_device, link); 1256 /* list partitions for given device */ 1257 part_num = 0; 1258#if defined(CONFIG_CMD_MTDPARTS_SHOW_NET_SIZES) 1259 struct mtd_info *mtd; 1260 1261 if (get_mtd_info(dev->id->type, dev->id->num, &mtd)) 1262 return; 1263 1264 printf("\ndevice %s%d <%s>, # parts = %d\n", 1265 MTD_DEV_TYPE(dev->id->type), dev->id->num, 1266 dev->id->mtd_id, dev->num_parts); 1267 printf(" #: name\t\tsize\t\tnet size\toffset\t\tmask_flags\n"); 1268 1269 list_for_each(pentry, &dev->parts) { 1270 u32 net_size; 1271 char *size_note; 1272 1273 part = list_entry(pentry, struct part_info, link); 1274 net_size = net_part_size(mtd, part); 1275 size_note = part->size == net_size ? " " : " (!)"; 1276 printf("%2d: %-20s0x%08llx\t0x%08x%s\t0x%08llx\t%d\n", 1277 part_num, part->name, part->size, 1278 net_size, size_note, part->offset, 1279 part->mask_flags); 1280#else /* !defined(CONFIG_CMD_MTDPARTS_SHOW_NET_SIZES) */ 1281 printf("\ndevice %s%d <%s>, # parts = %d\n", 1282 MTD_DEV_TYPE(dev->id->type), dev->id->num, 1283 dev->id->mtd_id, dev->num_parts); 1284 printf(" #: name\t\tsize\t\toffset\t\tmask_flags\n"); 1285 1286 list_for_each(pentry, &dev->parts) { 1287 part = list_entry(pentry, struct part_info, link); 1288 printf("%2d: %-20s0x%08llx\t0x%08llx\t%d\n", 1289 part_num, part->name, part->size, 1290 part->offset, part->mask_flags); 1291#endif /* defined(CONFIG_CMD_MTDPARTS_SHOW_NET_SIZES) */ 1292 part_num++; 1293 } 1294 } 1295 1296 if (list_empty(&devices)) 1297 printf("no partitions defined\n"); 1298} 1299 1300/** 1301 * Format and print out a partition list for each device from global device 1302 * list. 1303 */ 1304static void list_partitions(void) 1305{ 1306 struct part_info *part; 1307 1308 debug("\n---list_partitions---\n"); 1309 print_partition_table(); 1310 1311 /* current_mtd_dev is not NULL only when we have non empty device list */ 1312 if (current_mtd_dev) { 1313 part = mtd_part_info(current_mtd_dev, current_mtd_partnum); 1314 if (part) { 1315 printf("\nactive partition: %s%d,%d - (%s) 0x%08llx @ 0x%08llx\n", 1316 MTD_DEV_TYPE(current_mtd_dev->id->type), 1317 current_mtd_dev->id->num, current_mtd_partnum, 1318 part->name, part->size, part->offset); 1319 } else { 1320 printf("could not get current partition info\n\n"); 1321 } 1322 } 1323 1324 printf("\ndefaults:\n"); 1325 printf("mtdids : %s\n", 1326 mtdids_default ? mtdids_default : "none"); 1327 /* 1328 * Using printf() here results in printbuffer overflow 1329 * if default mtdparts string is greater than console 1330 * printbuffer. Use puts() to prevent system crashes. 1331 */ 1332 puts("mtdparts: "); 1333 puts(mtdparts_default ? mtdparts_default : "none"); 1334 puts("\n"); 1335} 1336 1337/** 1338 * Given partition identifier in form of <dev_type><dev_num>,<part_num> find 1339 * corresponding device and verify partition number. 1340 * 1341 * @param id string describing device and partition or partition name 1342 * @param dev pointer to the requested device (output) 1343 * @param part_num verified partition number (output) 1344 * @param part pointer to requested partition (output) 1345 * Return: 0 on success, 1 otherwise 1346 */ 1347int find_dev_and_part(const char *id, struct mtd_device **dev, 1348 u8 *part_num, struct part_info **part) 1349{ 1350 struct list_head *dentry, *pentry; 1351 u8 type, dnum, pnum; 1352 const char *p; 1353 1354 debug("--- find_dev_and_part ---\nid = %s\n", id); 1355 1356 list_for_each(dentry, &devices) { 1357 *part_num = 0; 1358 *dev = list_entry(dentry, struct mtd_device, link); 1359 list_for_each(pentry, &(*dev)->parts) { 1360 *part = list_entry(pentry, struct part_info, link); 1361 if (strcmp((*part)->name, id) == 0) 1362 return 0; 1363 (*part_num)++; 1364 } 1365 } 1366 1367 p = id; 1368 *dev = NULL; 1369 *part = NULL; 1370 *part_num = 0; 1371 1372 if (mtd_id_parse(p, &p, &type, &dnum) != 0) 1373 return 1; 1374 1375 if ((*p++ != ',') || (*p == '\0')) { 1376 printf("no partition number specified\n"); 1377 return 1; 1378 } 1379 pnum = simple_strtoul(p, (char **)&p, 0); 1380 if (*p != '\0') { 1381 printf("unexpected trailing character '%c'\n", *p); 1382 return 1; 1383 } 1384 1385 if ((*dev = device_find(type, dnum)) == NULL) { 1386 printf("no such device %s%d\n", MTD_DEV_TYPE(type), dnum); 1387 return 1; 1388 } 1389 1390 if ((*part = mtd_part_info(*dev, pnum)) == NULL) { 1391 printf("no such partition\n"); 1392 *dev = NULL; 1393 return 1; 1394 } 1395 1396 *part_num = pnum; 1397 1398 return 0; 1399} 1400 1401/** 1402 * Find and delete partition. For partition id format see find_dev_and_part(). 1403 * 1404 * @param id string describing device and partition 1405 * Return: 0 on success, 1 otherwise 1406 */ 1407static int delete_partition(const char *id) 1408{ 1409 u8 pnum; 1410 struct mtd_device *dev; 1411 struct part_info *part; 1412 1413 if (find_dev_and_part(id, &dev, &pnum, &part) == 0) { 1414 1415 debug("delete_partition: device = %s%d, partition %d = (%s) 0x%08llx@0x%08llx\n", 1416 MTD_DEV_TYPE(dev->id->type), dev->id->num, pnum, 1417 part->name, part->size, part->offset); 1418 1419 if (part_del(dev, part) != 0) 1420 return 1; 1421 1422 if (generate_mtdparts_save(last_parts, MTDPARTS_MAXLEN) != 0) { 1423 printf("generated mtdparts too long, resetting to null\n"); 1424 return 1; 1425 } 1426 return 0; 1427 } 1428 1429 printf("partition %s not found\n", id); 1430 return 1; 1431} 1432 1433#if defined(CONFIG_CMD_MTDPARTS_SPREAD) 1434/** 1435 * Increase the size of the given partition so that it's net size is at least 1436 * as large as the size member and such that the next partition would start on a 1437 * good block if it were adjacent to this partition. 1438 * 1439 * @param mtd the mtd device 1440 * @param part the partition 1441 * @param next_offset pointer to the offset of the next partition after this 1442 * partition's size has been modified (output) 1443 */ 1444static void spread_partition(struct mtd_info *mtd, struct part_info *part, 1445 uint64_t *next_offset) 1446{ 1447 uint64_t net_size, padding_size = 0; 1448 int truncated; 1449 1450 mtd_get_len_incl_bad(mtd, part->offset, part->size, &net_size, 1451 &truncated); 1452 1453 /* 1454 * Absorb bad blocks immediately following this 1455 * partition also into the partition, such that 1456 * the next partition starts with a good block. 1457 */ 1458 if (!truncated) { 1459 mtd_get_len_incl_bad(mtd, part->offset + net_size, 1460 mtd->erasesize, &padding_size, &truncated); 1461 if (truncated) 1462 padding_size = 0; 1463 else 1464 padding_size -= mtd->erasesize; 1465 } 1466 1467 if (truncated) { 1468 printf("truncated partition %s to %lld bytes\n", part->name, 1469 (uint64_t) net_size + padding_size); 1470 } 1471 1472 part->size = net_size + padding_size; 1473 *next_offset = part->offset + part->size; 1474} 1475 1476/** 1477 * Adjust all of the partition sizes, such that all partitions are at least 1478 * as big as their mtdparts environment variable sizes and they each start 1479 * on a good block. 1480 * 1481 * Return: 0 on success, 1 otherwise 1482 */ 1483static int spread_partitions(void) 1484{ 1485 struct list_head *dentry, *pentry; 1486 struct mtd_device *dev; 1487 struct part_info *part; 1488 struct mtd_info *mtd; 1489 int part_num; 1490 uint64_t cur_offs; 1491 1492 list_for_each(dentry, &devices) { 1493 dev = list_entry(dentry, struct mtd_device, link); 1494 1495 if (get_mtd_info(dev->id->type, dev->id->num, &mtd)) 1496 return 1; 1497 1498 part_num = 0; 1499 cur_offs = 0; 1500 list_for_each(pentry, &dev->parts) { 1501 part = list_entry(pentry, struct part_info, link); 1502 1503 debug("spread_partitions: device = %s%d, partition %d =" 1504 " (%s) 0x%08llx@0x%08llx\n", 1505 MTD_DEV_TYPE(dev->id->type), dev->id->num, 1506 part_num, part->name, part->size, 1507 part->offset); 1508 1509 if (cur_offs > part->offset) 1510 part->offset = cur_offs; 1511 1512 spread_partition(mtd, part, &cur_offs); 1513 1514 part_num++; 1515 } 1516 } 1517 1518 index_partitions(); 1519 1520 if (generate_mtdparts_save(last_parts, MTDPARTS_MAXLEN) != 0) { 1521 printf("generated mtdparts too long, resetting to null\n"); 1522 return 1; 1523 } 1524 return 0; 1525} 1526#endif /* CONFIG_CMD_MTDPARTS_SPREAD */ 1527 1528/** 1529 * The mtdparts variable tends to be long. If we need to access it 1530 * before the env is relocated, then we need to use our own stack 1531 * buffer. gd->env_buf will be too small. 1532 * 1533 * @param buf temporary buffer pointer MTDPARTS_MAXLEN long 1534 * Return: mtdparts variable string, NULL if not found 1535 */ 1536static const char *env_get_mtdparts(char *buf) 1537{ 1538 if (gd->flags & GD_FLG_ENV_READY) 1539 return env_get("mtdparts"); 1540 if (env_get_f("mtdparts", buf, MTDPARTS_MAXLEN) != -1) 1541 return buf; 1542 return NULL; 1543} 1544 1545/** 1546 * Accept character string describing mtd partitions and call device_parse() 1547 * for each entry. Add created devices to the global devices list. 1548 * 1549 * @param mtdparts string specifing mtd partitions 1550 * Return: 0 on success, 1 otherwise 1551 */ 1552static int parse_mtdparts(const char *const mtdparts) 1553{ 1554 const char *p; 1555 struct mtd_device *dev; 1556 int err = 1; 1557 char tmp_parts[MTDPARTS_MAXLEN]; 1558 1559 debug("\n---parse_mtdparts---\nmtdparts = %s\n\n", mtdparts); 1560 1561 /* delete all devices and partitions */ 1562 if (mtd_devices_init() != 0) { 1563 printf("could not initialise device list\n"); 1564 return err; 1565 } 1566 1567 /* re-read 'mtdparts' variable, mtd_devices_init may be updating env */ 1568 p = env_get_mtdparts(tmp_parts); 1569 if (!p) 1570 p = mtdparts; 1571 1572 /* Skip the useless prefix, if any */ 1573 if (strncmp(p, "mtdparts=", 9) == 0) 1574 p += 9; 1575 1576 while (*p != '\0') { 1577 err = 1; 1578 if ((device_parse(p, &p, &dev) != 0) || (!dev)) 1579 break; 1580 1581 debug("+ device: %s\t%d\t%s\n", MTD_DEV_TYPE(dev->id->type), 1582 dev->id->num, dev->id->mtd_id); 1583 1584 /* check if parsed device is already on the list */ 1585 if (device_find(dev->id->type, dev->id->num) != NULL) { 1586 printf("device %s%d redefined, please correct mtdparts variable\n", 1587 MTD_DEV_TYPE(dev->id->type), dev->id->num); 1588 break; 1589 } 1590 1591 list_add_tail(&dev->link, &devices); 1592 err = 0; 1593 } 1594 if (err == 1) { 1595 free(dev); 1596 device_delall(&devices); 1597 } 1598 1599 return err; 1600} 1601 1602/** 1603 * Parse provided string describing mtdids mapping (see file header for mtdids 1604 * variable format). Allocate memory for each entry and add all found entries 1605 * to the global mtdids list. 1606 * 1607 * @param ids mapping string 1608 * Return: 0 on success, 1 otherwise 1609 */ 1610static int parse_mtdids(const char *const ids) 1611{ 1612 const char *p = ids; 1613 const char *mtd_id; 1614 int mtd_id_len; 1615 struct mtdids *id; 1616 struct list_head *entry, *n; 1617 struct mtdids *id_tmp; 1618 u8 type, num; 1619 u64 size; 1620 int ret = 1; 1621 1622 debug("\n---parse_mtdids---\nmtdids = %s\n\n", ids); 1623 1624 /* clean global mtdids list */ 1625 list_for_each_safe(entry, n, &mtdids) { 1626 id_tmp = list_entry(entry, struct mtdids, link); 1627 debug("mtdids del: %d %d\n", id_tmp->type, id_tmp->num); 1628 list_del(entry); 1629 free(id_tmp); 1630 } 1631 last_ids[0] = '\0'; 1632 INIT_LIST_HEAD(&mtdids); 1633 1634 while(p && (*p != '\0')) { 1635 1636 ret = 1; 1637 /* parse 'nor'|'nand'|'onenand'|'spi-nand'<dev-num> */ 1638 if (mtd_id_parse(p, &p, &type, &num) != 0) 1639 break; 1640 1641 if (*p != '=') { 1642 printf("mtdids: incorrect <dev-num>\n"); 1643 break; 1644 } 1645 p++; 1646 1647 /* check if requested device exists */ 1648 if (mtd_device_validate(type, num, &size) != 0) 1649 return 1; 1650 1651 /* locate <mtd-id> */ 1652 mtd_id = p; 1653 if ((p = strchr(mtd_id, ',')) != NULL) { 1654 mtd_id_len = p - mtd_id + 1; 1655 p++; 1656 } else { 1657 mtd_id_len = strlen(mtd_id) + 1; 1658 } 1659 if (mtd_id_len == 0) { 1660 printf("mtdids: no <mtd-id> identifier\n"); 1661 break; 1662 } 1663 1664 /* check if this id is already on the list */ 1665 int double_entry = 0; 1666 list_for_each(entry, &mtdids) { 1667 id_tmp = list_entry(entry, struct mtdids, link); 1668 if ((id_tmp->type == type) && (id_tmp->num == num)) { 1669 double_entry = 1; 1670 break; 1671 } 1672 } 1673 if (double_entry) { 1674 printf("device id %s%d redefined, please correct mtdids variable\n", 1675 MTD_DEV_TYPE(type), num); 1676 break; 1677 } 1678 1679 /* allocate mtdids structure */ 1680 if (!(id = (struct mtdids *)malloc(sizeof(struct mtdids) + mtd_id_len))) { 1681 printf("out of memory\n"); 1682 break; 1683 } 1684 memset(id, 0, sizeof(struct mtdids) + mtd_id_len); 1685 id->num = num; 1686 id->type = type; 1687 id->size = size; 1688 id->mtd_id = (char *)(id + 1); 1689 strncpy(id->mtd_id, mtd_id, mtd_id_len - 1); 1690 id->mtd_id[mtd_id_len - 1] = '\0'; 1691 INIT_LIST_HEAD(&id->link); 1692 1693 debug("+ id %s%d\t%16lld bytes\t%s\n", 1694 MTD_DEV_TYPE(id->type), id->num, 1695 id->size, id->mtd_id); 1696 1697 list_add_tail(&id->link, &mtdids); 1698 ret = 0; 1699 } 1700 if (ret == 1) { 1701 /* clean mtdids list and free allocated memory */ 1702 list_for_each_safe(entry, n, &mtdids) { 1703 id_tmp = list_entry(entry, struct mtdids, link); 1704 list_del(entry); 1705 free(id_tmp); 1706 } 1707 return 1; 1708 } 1709 1710 return 0; 1711} 1712 1713 1714/** 1715 * Parse and initialize global mtdids mapping and create global 1716 * device/partition list. 1717 * 1718 * Return: 0 on success, 1 otherwise 1719 */ 1720int mtdparts_init(void) 1721{ 1722 static int initialized = 0; 1723 const char *ids, *parts; 1724 const char *current_partition; 1725 int ids_changed; 1726 char tmp_ep[PARTITION_MAXLEN + 1]; 1727 char tmp_parts[MTDPARTS_MAXLEN]; 1728 1729 debug("\n---mtdparts_init---\n"); 1730 if (!initialized) { 1731 INIT_LIST_HEAD(&mtdids); 1732 INIT_LIST_HEAD(&devices); 1733 memset(last_ids, 0, sizeof(last_ids)); 1734 memset(last_parts, 0, sizeof(last_parts)); 1735 memset(last_partition, 0, sizeof(last_partition)); 1736#if defined(CONFIG_SYS_MTDPARTS_RUNTIME) 1737 board_mtdparts_default(&mtdids_default, &mtdparts_default); 1738#endif 1739 use_defaults = 1; 1740 initialized = 1; 1741 } 1742 1743 /* get variables */ 1744 ids = env_get("mtdids"); 1745 parts = env_get_mtdparts(tmp_parts); 1746 current_partition = env_get("partition"); 1747 1748 /* save it for later parsing, cannot rely on current partition pointer 1749 * as 'partition' variable may be updated during init */ 1750 memset(tmp_parts, 0, sizeof(tmp_parts)); 1751 memset(tmp_ep, 0, sizeof(tmp_ep)); 1752 if (current_partition) 1753 strncpy(tmp_ep, current_partition, PARTITION_MAXLEN); 1754 1755 debug("last_ids : %s\n", last_ids); 1756 debug("env_ids : %s\n", ids); 1757 debug("last_parts: %s\n", last_parts); 1758 debug("env_parts : %s\n\n", parts); 1759 1760 debug("last_partition : %s\n", last_partition); 1761 debug("env_partition : %s\n", current_partition); 1762 1763 /* if mtdids variable is empty try to use defaults */ 1764 if (!ids) { 1765 if (mtdids_default) { 1766 debug("mtdids variable not defined, using default\n"); 1767 ids = mtdids_default; 1768 env_set("mtdids", (char *)ids); 1769 } else { 1770 printf("mtdids not defined, no default present\n"); 1771 return 1; 1772 } 1773 } 1774 if (strlen(ids) > MTDIDS_MAXLEN - 1) { 1775 printf("mtdids too long (> %d)\n", MTDIDS_MAXLEN); 1776 return 1; 1777 } 1778 1779 /* use defaults when mtdparts variable is not defined 1780 * once mtdparts is saved environment, drop use_defaults flag */ 1781 if (!parts) { 1782 if (mtdparts_default && use_defaults) { 1783 parts = mtdparts_default; 1784 if (env_set("mtdparts", (char *)parts) == 0) 1785 use_defaults = 0; 1786 } else 1787 printf("mtdparts variable not set, see 'help mtdparts'\n"); 1788 } 1789 1790 if (parts && (strlen(parts) > MTDPARTS_MAXLEN - 1)) { 1791 printf("mtdparts too long (> %d)\n", MTDPARTS_MAXLEN); 1792 return 1; 1793 } 1794 1795 /* check if we have already parsed those mtdids */ 1796 if ((last_ids[0] != '\0') && (strcmp(last_ids, ids) == 0)) { 1797 ids_changed = 0; 1798 } else { 1799 ids_changed = 1; 1800 1801 if (parse_mtdids(ids) != 0) { 1802 mtd_devices_init(); 1803 return 1; 1804 } 1805 1806 /* ok it's good, save new ids */ 1807 strncpy(last_ids, ids, MTDIDS_MAXLEN); 1808 } 1809 1810 /* parse partitions if either mtdparts or mtdids were updated */ 1811 if (parts && ((last_parts[0] == '\0') || ((strcmp(last_parts, parts) != 0)) || ids_changed)) { 1812 if (parse_mtdparts(parts) != 0) 1813 return 1; 1814 1815 if (list_empty(&devices)) { 1816 printf("mtdparts_init: no valid partitions\n"); 1817 return 1; 1818 } 1819 1820 /* ok it's good, save new parts */ 1821 strncpy(last_parts, parts, MTDPARTS_MAXLEN); 1822 1823 /* reset first partition from first dev from the list as current */ 1824 current_mtd_dev = list_entry(devices.next, struct mtd_device, link); 1825 current_mtd_partnum = 0; 1826 current_save(); 1827 1828 debug("mtdparts_init: current_mtd_dev = %s%d, current_mtd_partnum = %d\n", 1829 MTD_DEV_TYPE(current_mtd_dev->id->type), 1830 current_mtd_dev->id->num, current_mtd_partnum); 1831 } 1832 1833 /* mtdparts variable was reset to NULL, delete all devices/partitions */ 1834 if (!parts && (last_parts[0] != '\0')) 1835 return mtd_devices_init(); 1836 1837 /* do not process current partition if mtdparts variable is null */ 1838 if (!parts) 1839 return 0; 1840 1841 /* is current partition set in environment? if so, use it */ 1842 if ((tmp_ep[0] != '\0') && (strcmp(tmp_ep, last_partition) != 0)) { 1843 struct part_info *p; 1844 struct mtd_device *cdev; 1845 u8 pnum; 1846 1847 debug("--- getting current partition: %s\n", tmp_ep); 1848 1849 if (find_dev_and_part(tmp_ep, &cdev, &pnum, &p) == 0) { 1850 current_mtd_dev = cdev; 1851 current_mtd_partnum = pnum; 1852 current_save(); 1853 } 1854 } else if (env_get("partition") == NULL) { 1855 debug("no partition variable set, setting...\n"); 1856 current_save(); 1857 } 1858 1859 return 0; 1860} 1861 1862/** 1863 * Return pointer to the partition of a requested number from a requested 1864 * device. 1865 * 1866 * @param dev device that is to be searched for a partition 1867 * @param part_num requested partition number 1868 * Return: pointer to the part_info, NULL otherwise 1869 */ 1870static struct part_info* mtd_part_info(struct mtd_device *dev, unsigned int part_num) 1871{ 1872 struct list_head *entry; 1873 struct part_info *part; 1874 int num; 1875 1876 if (!dev) 1877 return NULL; 1878 1879 debug("\n--- mtd_part_info: partition number %d for device %s%d (%s)\n", 1880 part_num, MTD_DEV_TYPE(dev->id->type), 1881 dev->id->num, dev->id->mtd_id); 1882 1883 if (part_num >= dev->num_parts) { 1884 printf("invalid partition number %d for device %s%d (%s)\n", 1885 part_num, MTD_DEV_TYPE(dev->id->type), 1886 dev->id->num, dev->id->mtd_id); 1887 return NULL; 1888 } 1889 1890 /* locate partition number, return it */ 1891 num = 0; 1892 list_for_each(entry, &dev->parts) { 1893 part = list_entry(entry, struct part_info, link); 1894 1895 if (part_num == num++) { 1896 return part; 1897 } 1898 } 1899 1900 return NULL; 1901} 1902 1903/***************************************************/ 1904/* U-Boot commands */ 1905/***************************************************/ 1906/* command line only */ 1907/** 1908 * Routine implementing u-boot chpart command. Sets new current partition based 1909 * on the user supplied partition id. For partition id format see find_dev_and_part(). 1910 * 1911 * @param cmdtp command internal data 1912 * @param flag command flag 1913 * @param argc number of arguments supplied to the command 1914 * @param argv arguments list 1915 * Return: 0 on success, 1 otherwise 1916 */ 1917static int do_chpart(struct cmd_tbl *cmdtp, int flag, int argc, 1918 char *const argv[]) 1919{ 1920/* command line only */ 1921 struct mtd_device *dev; 1922 struct part_info *part; 1923 u8 pnum; 1924 1925 if (mtdparts_init() !=0) 1926 return 1; 1927 1928 if (argc < 2) { 1929 printf("no partition id specified\n"); 1930 return 1; 1931 } 1932 1933 if (find_dev_and_part(argv[1], &dev, &pnum, &part) != 0) 1934 return 1; 1935 1936 current_mtd_dev = dev; 1937 current_mtd_partnum = pnum; 1938 current_save(); 1939 1940 printf("partition changed to %s%d,%d\n", 1941 MTD_DEV_TYPE(dev->id->type), dev->id->num, pnum); 1942 1943 return 0; 1944} 1945 1946/** 1947 * Routine implementing u-boot mtdparts command. Initialize/update default global 1948 * partition list and process user partition request (list, add, del). 1949 * 1950 * @param cmdtp command internal data 1951 * @param flag command flag 1952 * @param argc number of arguments supplied to the command 1953 * @param argv arguments list 1954 * Return: 0 on success, 1 otherwise 1955 */ 1956static int do_mtdparts(struct cmd_tbl *cmdtp, int flag, int argc, 1957 char *const argv[]) 1958{ 1959 if (argc == 2) { 1960 if (strcmp(argv[1], "default") == 0) { 1961 env_set("mtdids", NULL); 1962 env_set("mtdparts", NULL); 1963 env_set("partition", NULL); 1964 use_defaults = 1; 1965 1966 mtdparts_init(); 1967 return 0; 1968 } else if (strcmp(argv[1], "delall") == 0) { 1969 /* this may be the first run, initialize lists if needed */ 1970 mtdparts_init(); 1971 1972 env_set("mtdparts", NULL); 1973 1974 /* mtd_devices_init() calls current_save() */ 1975 return mtd_devices_init(); 1976 } 1977 } 1978 1979 /* make sure we are in sync with env variables */ 1980 if (mtdparts_init() != 0) 1981 return 1; 1982 1983 if (argc == 1) { 1984 list_partitions(); 1985 return 0; 1986 } 1987 1988 /* mtdparts add <mtd-dev> <size>[@<offset>] <name> [ro] */ 1989 if (((argc == 5) || (argc == 6)) && (strncmp(argv[1], "add", 3) == 0)) { 1990#define PART_ADD_DESC_MAXLEN 64 1991 char tmpbuf[PART_ADD_DESC_MAXLEN]; 1992#if defined(CONFIG_CMD_MTDPARTS_SPREAD) 1993 struct mtd_info *mtd; 1994 uint64_t next_offset; 1995#endif 1996 u8 type, num, len; 1997 struct mtd_device *dev; 1998 struct mtd_device *dev_tmp; 1999 struct mtdids *id; 2000 struct part_info *p; 2001 2002 if (mtd_id_parse(argv[2], NULL, &type, &num) != 0) 2003 return 1; 2004 2005 if ((id = id_find(type, num)) == NULL) { 2006 printf("no such device %s defined in mtdids variable\n", argv[2]); 2007 return 1; 2008 } 2009 2010 len = strlen(id->mtd_id) + 1; /* 'mtd_id:' */ 2011 len += strlen(argv[3]); /* size@offset */ 2012 len += strlen(argv[4]) + 2; /* '(' name ')' */ 2013 if (argv[5] && (strlen(argv[5]) == 2)) 2014 len += 2; /* 'ro' */ 2015 2016 if (len >= PART_ADD_DESC_MAXLEN) { 2017 printf("too long partition description\n"); 2018 return 1; 2019 } 2020 sprintf(tmpbuf, "%s:%s(%s)%s", 2021 id->mtd_id, argv[3], argv[4], argv[5] ? argv[5] : ""); 2022 debug("add tmpbuf: %s\n", tmpbuf); 2023 2024 if ((device_parse(tmpbuf, NULL, &dev) != 0) || (!dev)) 2025 return 1; 2026 2027 debug("+ %s\t%d\t%s\n", MTD_DEV_TYPE(dev->id->type), 2028 dev->id->num, dev->id->mtd_id); 2029 2030 p = list_entry(dev->parts.next, struct part_info, link); 2031 2032#if defined(CONFIG_CMD_MTDPARTS_SPREAD) 2033 if (get_mtd_info(dev->id->type, dev->id->num, &mtd)) 2034 return 1; 2035 2036 if (!strcmp(&argv[1][3], ".spread")) { 2037 spread_partition(mtd, p, &next_offset); 2038 debug("increased %s to %llu bytes\n", p->name, p->size); 2039 } 2040#endif 2041 2042 dev_tmp = device_find(dev->id->type, dev->id->num); 2043 if (dev_tmp == NULL) { 2044 device_add(dev); 2045 } else if (part_add(dev_tmp, p) != 0) { 2046 /* merge new partition with existing ones*/ 2047 device_del(dev); 2048 return 1; 2049 } 2050 2051 if (generate_mtdparts_save(last_parts, MTDPARTS_MAXLEN) != 0) { 2052 printf("generated mtdparts too long, resetting to null\n"); 2053 return 1; 2054 } 2055 2056 return 0; 2057 } 2058 2059 /* mtdparts del part-id */ 2060 if ((argc == 3) && (strcmp(argv[1], "del") == 0)) { 2061 debug("del: part-id = %s\n", argv[2]); 2062 2063 return delete_partition(argv[2]); 2064 } 2065 2066#if defined(CONFIG_CMD_MTDPARTS_SPREAD) 2067 if ((argc == 2) && (strcmp(argv[1], "spread") == 0)) 2068 return spread_partitions(); 2069#endif /* CONFIG_CMD_MTDPARTS_SPREAD */ 2070 2071 return CMD_RET_USAGE; 2072} 2073 2074/***************************************************/ 2075U_BOOT_CMD( 2076 chpart, 2, 0, do_chpart, 2077 "change active partition of a MTD device", 2078 "part-id\n" 2079 " - change active partition (e.g. part-id = nand0,1) of a MTD device" 2080); 2081 2082U_BOOT_LONGHELP(mtdparts, 2083 "\n" 2084 " - list partition table\n" 2085 "mtdparts delall\n" 2086 " - delete all partitions\n" 2087 "mtdparts del part-id\n" 2088 " - delete partition (e.g. part-id = nand0,1)\n" 2089 "mtdparts add <mtd-dev> <size>[@<offset>] [<name>] [ro]\n" 2090 " - add partition\n" 2091#if defined(CONFIG_CMD_MTDPARTS_SPREAD) 2092 "mtdparts add.spread <mtd-dev> <size>[@<offset>] [<name>] [ro]\n" 2093 " - add partition, padding size by skipping bad blocks\n" 2094#endif 2095 "mtdparts default\n" 2096 " - reset partition table to defaults\n" 2097#if defined(CONFIG_CMD_MTDPARTS_SPREAD) 2098 "mtdparts spread\n" 2099 " - adjust the sizes of the partitions so they are\n" 2100 " at least as big as the mtdparts variable specifies\n" 2101 " and they each start on a good block\n\n" 2102#else 2103 "\n" 2104#endif /* CONFIG_CMD_MTDPARTS_SPREAD */ 2105 "-----\n\n" 2106 "this command uses three environment variables:\n\n" 2107 "'partition' - keeps current partition identifier\n\n" 2108 "partition := <part-id>\n" 2109 "<part-id> := <dev-id>,part_num\n\n" 2110 "'mtdids' - linux kernel mtd device id <-> u-boot device id mapping\n\n" 2111 "mtdids=<idmap>[,<idmap>,...]\n\n" 2112 "<idmap> := <dev-id>=<mtd-id>\n" 2113 "<dev-id> := 'nand'|'nor'|'onenand'|'spi-nand'<dev-num>\n" 2114 "<dev-num> := mtd device number, 0...\n" 2115 "<mtd-id> := unique device tag used by linux kernel to find mtd device (mtd->name)\n\n" 2116 "'mtdparts' - partition list\n\n" 2117 "mtdparts=mtdparts=<mtd-def>[;<mtd-def>...]\n\n" 2118 "<mtd-def> := <mtd-id>:<part-def>[,<part-def>...]\n" 2119 "<mtd-id> := unique device tag used by linux kernel to find mtd device (mtd->name)\n" 2120 "<part-def> := <size>[@<offset>][<name>][<ro-flag>]\n" 2121 "<size> := standard linux memsize OR '-' to denote all remaining space\n" 2122 "<offset> := partition start offset within the device\n" 2123 "<name> := '(' NAME ')'\n" 2124 "<ro-flag> := when set to 'ro' makes partition read-only (not used, passed to kernel)"); 2125 2126U_BOOT_CMD( 2127 mtdparts, 6, 0, do_mtdparts, 2128 "define flash/nand partitions", mtdparts_help_text 2129); 2130/***************************************************/ 2131