1*83d290c5STom Rini // SPDX-License-Identifier: GPL-2.0+ 22e192b24SSimon Glass /* 32e192b24SSimon Glass * (C) Copyright 2002 42e192b24SSimon Glass * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 52e192b24SSimon Glass * 62e192b24SSimon Glass * (C) Copyright 2002 72e192b24SSimon Glass * Robert Schwebel, Pengutronix, <r.schwebel@pengutronix.de> 82e192b24SSimon Glass * 92e192b24SSimon Glass * (C) Copyright 2003 102e192b24SSimon Glass * Kai-Uwe Bloem, Auerswald GmbH & Co KG, <linux-development@auerswald.de> 112e192b24SSimon Glass * 122e192b24SSimon Glass * (C) Copyright 2005 132e192b24SSimon Glass * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 142e192b24SSimon Glass * 152e192b24SSimon Glass * Added support for reading flash partition table from environment. 162e192b24SSimon Glass * Parsing routines are based on driver/mtd/cmdline.c from the linux 2.4 172e192b24SSimon Glass * kernel tree. 182e192b24SSimon Glass * 192e192b24SSimon Glass * (C) Copyright 2008 202e192b24SSimon Glass * Harald Welte, OpenMoko, Inc., Harald Welte <laforge@openmoko.org> 212e192b24SSimon Glass * 222e192b24SSimon Glass * $Id: cmdlinepart.c,v 1.17 2004/11/26 11:18:47 lavinen Exp $ 232e192b24SSimon Glass * Copyright 2002 SYSGO Real-Time Solutions GmbH 242e192b24SSimon Glass */ 252e192b24SSimon Glass 262e192b24SSimon Glass /* 272e192b24SSimon Glass * Three environment variables are used by the parsing routines: 282e192b24SSimon Glass * 292e192b24SSimon Glass * 'partition' - keeps current partition identifier 302e192b24SSimon Glass * 312e192b24SSimon Glass * partition := <part-id> 322e192b24SSimon Glass * <part-id> := <dev-id>,part_num 332e192b24SSimon Glass * 342e192b24SSimon Glass * 352e192b24SSimon Glass * 'mtdids' - linux kernel mtd device id <-> u-boot device id mapping 362e192b24SSimon Glass * 372e192b24SSimon Glass * mtdids=<idmap>[,<idmap>,...] 382e192b24SSimon Glass * 392e192b24SSimon Glass * <idmap> := <dev-id>=<mtd-id> 402e192b24SSimon Glass * <dev-id> := 'nand'|'nor'|'onenand'<dev-num> 412e192b24SSimon Glass * <dev-num> := mtd device number, 0... 422e192b24SSimon Glass * <mtd-id> := unique device tag used by linux kernel to find mtd device (mtd->name) 432e192b24SSimon Glass * 442e192b24SSimon Glass * 452e192b24SSimon Glass * 'mtdparts' - partition list 462e192b24SSimon Glass * 472e192b24SSimon Glass * mtdparts=mtdparts=<mtd-def>[;<mtd-def>...] 482e192b24SSimon Glass * 492e192b24SSimon Glass * <mtd-def> := <mtd-id>:<part-def>[,<part-def>...] 502e192b24SSimon Glass * <mtd-id> := unique device tag used by linux kernel to find mtd device (mtd->name) 512e192b24SSimon Glass * <part-def> := <size>[@<offset>][<name>][<ro-flag>] 522e192b24SSimon Glass * <size> := standard linux memsize OR '-' to denote all remaining space 532e192b24SSimon Glass * <offset> := partition start offset within the device 542e192b24SSimon Glass * <name> := '(' NAME ')' 552e192b24SSimon Glass * <ro-flag> := when set to 'ro' makes partition read-only (not used, passed to kernel) 562e192b24SSimon Glass * 572e192b24SSimon Glass * Notes: 582e192b24SSimon Glass * - each <mtd-id> used in mtdparts must albo exist in 'mtddis' mapping 592e192b24SSimon Glass * - if the above variables are not set defaults for a given target are used 602e192b24SSimon Glass * 612e192b24SSimon Glass * Examples: 622e192b24SSimon Glass * 632e192b24SSimon Glass * 1 NOR Flash, with 1 single writable partition: 642e192b24SSimon Glass * mtdids=nor0=edb7312-nor 652e192b24SSimon Glass * mtdparts=mtdparts=edb7312-nor:- 662e192b24SSimon Glass * 672e192b24SSimon Glass * 1 NOR Flash with 2 partitions, 1 NAND with one 682e192b24SSimon Glass * mtdids=nor0=edb7312-nor,nand0=edb7312-nand 692e192b24SSimon Glass * mtdparts=mtdparts=edb7312-nor:256k(ARMboot)ro,-(root);edb7312-nand:-(home) 702e192b24SSimon Glass * 712e192b24SSimon Glass */ 722e192b24SSimon Glass 732e192b24SSimon Glass #include <common.h> 742e192b24SSimon Glass #include <command.h> 752e192b24SSimon Glass #include <malloc.h> 762e192b24SSimon Glass #include <jffs2/load_kernel.h> 772e192b24SSimon Glass #include <linux/list.h> 782e192b24SSimon Glass #include <linux/ctype.h> 792e192b24SSimon Glass #include <linux/err.h> 802e192b24SSimon Glass #include <linux/mtd/mtd.h> 812e192b24SSimon Glass 822e192b24SSimon Glass #if defined(CONFIG_CMD_NAND) 836ae3900aSMasahiro Yamada #include <linux/mtd/rawnand.h> 842e192b24SSimon Glass #include <nand.h> 852e192b24SSimon Glass #endif 862e192b24SSimon Glass 872e192b24SSimon Glass #if defined(CONFIG_CMD_ONENAND) 882e192b24SSimon Glass #include <linux/mtd/onenand.h> 892e192b24SSimon Glass #include <onenand_uboot.h> 902e192b24SSimon Glass #endif 912e192b24SSimon Glass 922e192b24SSimon Glass DECLARE_GLOBAL_DATA_PTR; 932e192b24SSimon Glass 942e192b24SSimon Glass /* special size referring to all the remaining space in a partition */ 952e192b24SSimon Glass #define SIZE_REMAINING (~0llu) 962e192b24SSimon Glass 972e192b24SSimon Glass /* special offset value, it is used when not provided by user 982e192b24SSimon Glass * 992e192b24SSimon Glass * this value is used temporarily during parsing, later such offests 1002e192b24SSimon Glass * are recalculated */ 1012e192b24SSimon Glass #define OFFSET_NOT_SPECIFIED (~0llu) 1022e192b24SSimon Glass 1032e192b24SSimon Glass /* minimum partition size */ 1042e192b24SSimon Glass #define MIN_PART_SIZE 4096 1052e192b24SSimon Glass 1062e192b24SSimon Glass /* this flag needs to be set in part_info struct mask_flags 1072e192b24SSimon Glass * field for read-only partitions */ 1082e192b24SSimon Glass #define MTD_WRITEABLE_CMD 1 1092e192b24SSimon Glass 1102e192b24SSimon Glass /* default values for mtdids and mtdparts variables */ 111af324436SLadislav Michl #if !defined(MTDIDS_DEFAULT) 1120269dfaeSMaxime Ripard #ifdef CONFIG_MTDIDS_DEFAULT 1130269dfaeSMaxime Ripard #define MTDIDS_DEFAULT CONFIG_MTDIDS_DEFAULT 1140269dfaeSMaxime Ripard #else 115af324436SLadislav Michl #define MTDIDS_DEFAULT NULL 1162e192b24SSimon Glass #endif 1170269dfaeSMaxime Ripard #endif 118af324436SLadislav Michl #if !defined(MTDPARTS_DEFAULT) 1190269dfaeSMaxime Ripard #ifdef CONFIG_MTDPARTS_DEFAULT 1200269dfaeSMaxime Ripard #define MTDPARTS_DEFAULT CONFIG_MTDPARTS_DEFAULT 1210269dfaeSMaxime Ripard #else 122af324436SLadislav Michl #define MTDPARTS_DEFAULT NULL 1232e192b24SSimon Glass #endif 1240269dfaeSMaxime Ripard #endif 125af324436SLadislav Michl #if defined(CONFIG_SYS_MTDPARTS_RUNTIME) 126af324436SLadislav Michl extern void board_mtdparts_default(const char **mtdids, const char **mtdparts); 127af324436SLadislav Michl #endif 128af324436SLadislav Michl static const char *mtdids_default = MTDIDS_DEFAULT; 129af324436SLadislav Michl static const char *mtdparts_default = MTDPARTS_DEFAULT; 1302e192b24SSimon Glass 1312e192b24SSimon Glass /* copies of last seen 'mtdids', 'mtdparts' and 'partition' env variables */ 1322e192b24SSimon Glass #define MTDIDS_MAXLEN 128 1332e192b24SSimon Glass #define MTDPARTS_MAXLEN 512 1342e192b24SSimon Glass #define PARTITION_MAXLEN 16 13554f1792cSTom Rini static char last_ids[MTDIDS_MAXLEN + 1]; 13654f1792cSTom Rini static char last_parts[MTDPARTS_MAXLEN + 1]; 13754f1792cSTom Rini static char last_partition[PARTITION_MAXLEN + 1]; 1382e192b24SSimon Glass 1392e192b24SSimon Glass /* low level jffs2 cache cleaning routine */ 1402e192b24SSimon Glass extern void jffs2_free_cache(struct part_info *part); 1412e192b24SSimon Glass 1422e192b24SSimon Glass /* mtdids mapping list, filled by parse_ids() */ 1432e192b24SSimon Glass static struct list_head mtdids; 1442e192b24SSimon Glass 1452e192b24SSimon Glass /* device/partition list, parse_cmdline() parses into here */ 1462e192b24SSimon Glass static struct list_head devices; 1472e192b24SSimon Glass 1482e192b24SSimon Glass /* current active device and partition number */ 1492e192b24SSimon Glass struct mtd_device *current_mtd_dev = NULL; 1502e192b24SSimon Glass u8 current_mtd_partnum = 0; 1512e192b24SSimon Glass 152f8f744a3SLadislav Michl u8 use_defaults; 153f8f744a3SLadislav Michl 1542e192b24SSimon Glass static struct part_info* mtd_part_info(struct mtd_device *dev, unsigned int part_num); 1552e192b24SSimon Glass 1562e192b24SSimon Glass /* command line only routines */ 1572e192b24SSimon Glass static struct mtdids* id_find_by_mtd_id(const char *mtd_id, unsigned int mtd_id_len); 1582e192b24SSimon Glass static int device_del(struct mtd_device *dev); 1592e192b24SSimon Glass 1602e192b24SSimon Glass /** 1612e192b24SSimon Glass * Parses a string into a number. The number stored at ptr is 1622e192b24SSimon Glass * potentially suffixed with K (for kilobytes, or 1024 bytes), 1632e192b24SSimon Glass * M (for megabytes, or 1048576 bytes), or G (for gigabytes, or 1642e192b24SSimon Glass * 1073741824). If the number is suffixed with K, M, or G, then 1652e192b24SSimon Glass * the return value is the number multiplied by one kilobyte, one 1662e192b24SSimon Glass * megabyte, or one gigabyte, respectively. 1672e192b24SSimon Glass * 1682e192b24SSimon Glass * @param ptr where parse begins 1692e192b24SSimon Glass * @param retptr output pointer to next char after parse completes (output) 1702e192b24SSimon Glass * @return resulting unsigned int 1712e192b24SSimon Glass */ 1722e192b24SSimon Glass static u64 memsize_parse (const char *const ptr, const char **retptr) 1732e192b24SSimon Glass { 1742e192b24SSimon Glass u64 ret = simple_strtoull(ptr, (char **)retptr, 0); 1752e192b24SSimon Glass 1762e192b24SSimon Glass switch (**retptr) { 1772e192b24SSimon Glass case 'G': 1782e192b24SSimon Glass case 'g': 1792e192b24SSimon Glass ret <<= 10; 1802e192b24SSimon Glass case 'M': 1812e192b24SSimon Glass case 'm': 1822e192b24SSimon Glass ret <<= 10; 1832e192b24SSimon Glass case 'K': 1842e192b24SSimon Glass case 'k': 1852e192b24SSimon Glass ret <<= 10; 1862e192b24SSimon Glass (*retptr)++; 1872e192b24SSimon Glass default: 1882e192b24SSimon Glass break; 1892e192b24SSimon Glass } 1902e192b24SSimon Glass 1912e192b24SSimon Glass return ret; 1922e192b24SSimon Glass } 1932e192b24SSimon Glass 1942e192b24SSimon Glass /** 1952e192b24SSimon Glass * Format string describing supplied size. This routine does the opposite job 1962e192b24SSimon Glass * to memsize_parse(). Size in bytes is converted to string and if possible 1972e192b24SSimon Glass * shortened by using k (kilobytes), m (megabytes) or g (gigabytes) suffix. 1982e192b24SSimon Glass * 1992e192b24SSimon Glass * Note, that this routine does not check for buffer overflow, it's the caller 2002e192b24SSimon Glass * who must assure enough space. 2012e192b24SSimon Glass * 2022e192b24SSimon Glass * @param buf output buffer 2032e192b24SSimon Glass * @param size size to be converted to string 2042e192b24SSimon Glass */ 2052e192b24SSimon Glass static void memsize_format(char *buf, u64 size) 2062e192b24SSimon Glass { 2072e192b24SSimon Glass #define SIZE_GB ((u32)1024*1024*1024) 2082e192b24SSimon Glass #define SIZE_MB ((u32)1024*1024) 2092e192b24SSimon Glass #define SIZE_KB ((u32)1024) 2102e192b24SSimon Glass 2112e192b24SSimon Glass if ((size % SIZE_GB) == 0) 2122e192b24SSimon Glass sprintf(buf, "%llug", size/SIZE_GB); 2132e192b24SSimon Glass else if ((size % SIZE_MB) == 0) 2142e192b24SSimon Glass sprintf(buf, "%llum", size/SIZE_MB); 2152e192b24SSimon Glass else if (size % SIZE_KB == 0) 2162e192b24SSimon Glass sprintf(buf, "%lluk", size/SIZE_KB); 2172e192b24SSimon Glass else 2182e192b24SSimon Glass sprintf(buf, "%llu", size); 2192e192b24SSimon Glass } 2202e192b24SSimon Glass 2212e192b24SSimon Glass /** 2222e192b24SSimon Glass * This routine does global indexing of all partitions. Resulting index for 2232e192b24SSimon Glass * current partition is saved in 'mtddevnum'. Current partition name in 2242e192b24SSimon Glass * 'mtddevname'. 2252e192b24SSimon Glass */ 2262e192b24SSimon Glass static void index_partitions(void) 2272e192b24SSimon Glass { 2282e192b24SSimon Glass u16 mtddevnum; 2292e192b24SSimon Glass struct part_info *part; 2302e192b24SSimon Glass struct list_head *dentry; 2312e192b24SSimon Glass struct mtd_device *dev; 2322e192b24SSimon Glass 2332e192b24SSimon Glass debug("--- index partitions ---\n"); 2342e192b24SSimon Glass 2352e192b24SSimon Glass if (current_mtd_dev) { 2362e192b24SSimon Glass mtddevnum = 0; 2372e192b24SSimon Glass list_for_each(dentry, &devices) { 2382e192b24SSimon Glass dev = list_entry(dentry, struct mtd_device, link); 2392e192b24SSimon Glass if (dev == current_mtd_dev) { 2402e192b24SSimon Glass mtddevnum += current_mtd_partnum; 241018f5303SSimon Glass env_set_ulong("mtddevnum", mtddevnum); 24254f1792cSTom Rini debug("=> mtddevnum %d,\n", mtddevnum); 2432e192b24SSimon Glass break; 2442e192b24SSimon Glass } 2452e192b24SSimon Glass mtddevnum += dev->num_parts; 2462e192b24SSimon Glass } 2472e192b24SSimon Glass 2482e192b24SSimon Glass part = mtd_part_info(current_mtd_dev, current_mtd_partnum); 24954f1792cSTom Rini if (part) { 250382bee57SSimon Glass env_set("mtddevname", part->name); 2512e192b24SSimon Glass 25254f1792cSTom Rini debug("=> mtddevname %s\n", part->name); 25354f1792cSTom Rini } else { 25454f1792cSTom Rini env_set("mtddevname", NULL); 25554f1792cSTom Rini 25654f1792cSTom Rini debug("=> mtddevname NULL\n"); 25754f1792cSTom Rini } 2582e192b24SSimon Glass } else { 259382bee57SSimon Glass env_set("mtddevnum", NULL); 260382bee57SSimon Glass env_set("mtddevname", NULL); 2612e192b24SSimon Glass 2622e192b24SSimon Glass debug("=> mtddevnum NULL\n=> mtddevname NULL\n"); 2632e192b24SSimon Glass } 2642e192b24SSimon Glass } 2652e192b24SSimon Glass 2662e192b24SSimon Glass /** 2672e192b24SSimon Glass * Save current device and partition in environment variable 'partition'. 2682e192b24SSimon Glass */ 2692e192b24SSimon Glass static void current_save(void) 2702e192b24SSimon Glass { 2712e192b24SSimon Glass char buf[16]; 2722e192b24SSimon Glass 2732e192b24SSimon Glass debug("--- current_save ---\n"); 2742e192b24SSimon Glass 2752e192b24SSimon Glass if (current_mtd_dev) { 2762e192b24SSimon Glass sprintf(buf, "%s%d,%d", MTD_DEV_TYPE(current_mtd_dev->id->type), 2772e192b24SSimon Glass current_mtd_dev->id->num, current_mtd_partnum); 2782e192b24SSimon Glass 279382bee57SSimon Glass env_set("partition", buf); 2802e192b24SSimon Glass strncpy(last_partition, buf, 16); 2812e192b24SSimon Glass 2822e192b24SSimon Glass debug("=> partition %s\n", buf); 2832e192b24SSimon Glass } else { 284382bee57SSimon Glass env_set("partition", NULL); 2852e192b24SSimon Glass last_partition[0] = '\0'; 2862e192b24SSimon Glass 2872e192b24SSimon Glass debug("=> partition NULL\n"); 2882e192b24SSimon Glass } 2892e192b24SSimon Glass index_partitions(); 2902e192b24SSimon Glass } 2912e192b24SSimon Glass 2922e192b24SSimon Glass 2932e192b24SSimon Glass /** 2942e192b24SSimon Glass * Produce a mtd_info given a type and num. 2952e192b24SSimon Glass * 2962e192b24SSimon Glass * @param type mtd type 2972e192b24SSimon Glass * @param num mtd number 2982e192b24SSimon Glass * @param mtd a pointer to an mtd_info instance (output) 2992e192b24SSimon Glass * @return 0 if device is valid, 1 otherwise 3002e192b24SSimon Glass */ 3012e192b24SSimon Glass static int get_mtd_info(u8 type, u8 num, struct mtd_info **mtd) 3022e192b24SSimon Glass { 3032e192b24SSimon Glass char mtd_dev[16]; 3042e192b24SSimon Glass 3052e192b24SSimon Glass sprintf(mtd_dev, "%s%d", MTD_DEV_TYPE(type), num); 3062e192b24SSimon Glass *mtd = get_mtd_device_nm(mtd_dev); 3072e192b24SSimon Glass if (IS_ERR(*mtd)) { 3082e192b24SSimon Glass printf("Device %s not found!\n", mtd_dev); 3092e192b24SSimon Glass return 1; 3102e192b24SSimon Glass } 3112e192b24SSimon Glass put_mtd_device(*mtd); 3122e192b24SSimon Glass 3132e192b24SSimon Glass return 0; 3142e192b24SSimon Glass } 3152e192b24SSimon Glass 3162e192b24SSimon Glass /** 3172e192b24SSimon Glass * Performs sanity check for supplied flash partition. 3182e192b24SSimon Glass * Table of existing MTD flash devices is searched and partition device 3192e192b24SSimon Glass * is located. Alignment with the granularity of nand erasesize is verified. 3202e192b24SSimon Glass * 3212e192b24SSimon Glass * @param id of the parent device 3222e192b24SSimon Glass * @param part partition to validate 3232e192b24SSimon Glass * @return 0 if partition is valid, 1 otherwise 3242e192b24SSimon Glass */ 3252e192b24SSimon Glass static int part_validate_eraseblock(struct mtdids *id, struct part_info *part) 3262e192b24SSimon Glass { 3272e192b24SSimon Glass struct mtd_info *mtd = NULL; 3282e192b24SSimon Glass int i, j; 3292e192b24SSimon Glass ulong start; 3302e192b24SSimon Glass u64 offset, size; 3312e192b24SSimon Glass 3322e192b24SSimon Glass if (get_mtd_info(id->type, id->num, &mtd)) 3332e192b24SSimon Glass return 1; 3342e192b24SSimon Glass 3352e192b24SSimon Glass part->sector_size = mtd->erasesize; 3362e192b24SSimon Glass 3372e192b24SSimon Glass if (!mtd->numeraseregions) { 3382e192b24SSimon Glass /* 3392e192b24SSimon Glass * Only one eraseregion (NAND, OneNAND or uniform NOR), 3402e192b24SSimon Glass * checking for alignment is easy here 3412e192b24SSimon Glass */ 3422e192b24SSimon Glass offset = part->offset; 3432e192b24SSimon Glass if (do_div(offset, mtd->erasesize)) { 3442e192b24SSimon Glass printf("%s%d: partition (%s) start offset" 3452e192b24SSimon Glass "alignment incorrect\n", 3462e192b24SSimon Glass MTD_DEV_TYPE(id->type), id->num, part->name); 3472e192b24SSimon Glass return 1; 3482e192b24SSimon Glass } 3492e192b24SSimon Glass 3502e192b24SSimon Glass size = part->size; 3512e192b24SSimon Glass if (do_div(size, mtd->erasesize)) { 3522e192b24SSimon Glass printf("%s%d: partition (%s) size alignment incorrect\n", 3532e192b24SSimon Glass MTD_DEV_TYPE(id->type), id->num, part->name); 3542e192b24SSimon Glass return 1; 3552e192b24SSimon Glass } 3562e192b24SSimon Glass } else { 3572e192b24SSimon Glass /* 3582e192b24SSimon Glass * Multiple eraseregions (non-uniform NOR), 3592e192b24SSimon Glass * checking for alignment is more complex here 3602e192b24SSimon Glass */ 3612e192b24SSimon Glass 3622e192b24SSimon Glass /* Check start alignment */ 3632e192b24SSimon Glass for (i = 0; i < mtd->numeraseregions; i++) { 3642e192b24SSimon Glass start = mtd->eraseregions[i].offset; 3652e192b24SSimon Glass for (j = 0; j < mtd->eraseregions[i].numblocks; j++) { 3662e192b24SSimon Glass if (part->offset == start) 3672e192b24SSimon Glass goto start_ok; 3682e192b24SSimon Glass start += mtd->eraseregions[i].erasesize; 3692e192b24SSimon Glass } 3702e192b24SSimon Glass } 3712e192b24SSimon Glass 3722e192b24SSimon Glass printf("%s%d: partition (%s) start offset alignment incorrect\n", 3732e192b24SSimon Glass MTD_DEV_TYPE(id->type), id->num, part->name); 3742e192b24SSimon Glass return 1; 3752e192b24SSimon Glass 3762e192b24SSimon Glass start_ok: 3772e192b24SSimon Glass 3782e192b24SSimon Glass /* Check end/size alignment */ 3792e192b24SSimon Glass for (i = 0; i < mtd->numeraseregions; i++) { 3802e192b24SSimon Glass start = mtd->eraseregions[i].offset; 3812e192b24SSimon Glass for (j = 0; j < mtd->eraseregions[i].numblocks; j++) { 3822e192b24SSimon Glass if ((part->offset + part->size) == start) 3832e192b24SSimon Glass goto end_ok; 3842e192b24SSimon Glass start += mtd->eraseregions[i].erasesize; 3852e192b24SSimon Glass } 3862e192b24SSimon Glass } 3872e192b24SSimon Glass /* Check last sector alignment */ 3882e192b24SSimon Glass if ((part->offset + part->size) == start) 3892e192b24SSimon Glass goto end_ok; 3902e192b24SSimon Glass 3912e192b24SSimon Glass printf("%s%d: partition (%s) size alignment incorrect\n", 3922e192b24SSimon Glass MTD_DEV_TYPE(id->type), id->num, part->name); 3932e192b24SSimon Glass return 1; 3942e192b24SSimon Glass 3952e192b24SSimon Glass end_ok: 3962e192b24SSimon Glass return 0; 3972e192b24SSimon Glass } 3982e192b24SSimon Glass 3992e192b24SSimon Glass return 0; 4002e192b24SSimon Glass } 4012e192b24SSimon Glass 4022e192b24SSimon Glass 4032e192b24SSimon Glass /** 4042e192b24SSimon Glass * Performs sanity check for supplied partition. Offset and size are 4052e192b24SSimon Glass * verified to be within valid range. Partition type is checked and 4062e192b24SSimon Glass * part_validate_eraseblock() is called with the argument of part. 4072e192b24SSimon Glass * 4082e192b24SSimon Glass * @param id of the parent device 4092e192b24SSimon Glass * @param part partition to validate 4102e192b24SSimon Glass * @return 0 if partition is valid, 1 otherwise 4112e192b24SSimon Glass */ 4122e192b24SSimon Glass static int part_validate(struct mtdids *id, struct part_info *part) 4132e192b24SSimon Glass { 4142e192b24SSimon Glass if (part->size == SIZE_REMAINING) 4152e192b24SSimon Glass part->size = id->size - part->offset; 4162e192b24SSimon Glass 4172e192b24SSimon Glass if (part->offset > id->size) { 4182e192b24SSimon Glass printf("%s: offset %08llx beyond flash size %08llx\n", 4192e192b24SSimon Glass id->mtd_id, part->offset, id->size); 4202e192b24SSimon Glass return 1; 4212e192b24SSimon Glass } 4222e192b24SSimon Glass 4232e192b24SSimon Glass if ((part->offset + part->size) <= part->offset) { 4242e192b24SSimon Glass printf("%s%d: partition (%s) size too big\n", 4252e192b24SSimon Glass MTD_DEV_TYPE(id->type), id->num, part->name); 4262e192b24SSimon Glass return 1; 4272e192b24SSimon Glass } 4282e192b24SSimon Glass 4292e192b24SSimon Glass if (part->offset + part->size > id->size) { 4302e192b24SSimon Glass printf("%s: partitioning exceeds flash size\n", id->mtd_id); 4312e192b24SSimon Glass return 1; 4322e192b24SSimon Glass } 4332e192b24SSimon Glass 4342e192b24SSimon Glass /* 4352e192b24SSimon Glass * Now we need to check if the partition starts and ends on 4362e192b24SSimon Glass * sector (eraseblock) regions 4372e192b24SSimon Glass */ 4382e192b24SSimon Glass return part_validate_eraseblock(id, part); 4392e192b24SSimon Glass } 4402e192b24SSimon Glass 4412e192b24SSimon Glass /** 4422e192b24SSimon Glass * Delete selected partition from the partition list of the specified device. 4432e192b24SSimon Glass * 4442e192b24SSimon Glass * @param dev device to delete partition from 4452e192b24SSimon Glass * @param part partition to delete 4462e192b24SSimon Glass * @return 0 on success, 1 otherwise 4472e192b24SSimon Glass */ 4482e192b24SSimon Glass static int part_del(struct mtd_device *dev, struct part_info *part) 4492e192b24SSimon Glass { 4502e192b24SSimon Glass u8 current_save_needed = 0; 4512e192b24SSimon Glass 4522e192b24SSimon Glass /* if there is only one partition, remove whole device */ 4532e192b24SSimon Glass if (dev->num_parts == 1) 4542e192b24SSimon Glass return device_del(dev); 4552e192b24SSimon Glass 4562e192b24SSimon Glass /* otherwise just delete this partition */ 4572e192b24SSimon Glass 4582e192b24SSimon Glass if (dev == current_mtd_dev) { 4592e192b24SSimon Glass /* we are modyfing partitions for the current device, 4602e192b24SSimon Glass * update current */ 4612e192b24SSimon Glass struct part_info *curr_pi; 4622e192b24SSimon Glass curr_pi = mtd_part_info(current_mtd_dev, current_mtd_partnum); 4632e192b24SSimon Glass 4642e192b24SSimon Glass if (curr_pi) { 4652e192b24SSimon Glass if (curr_pi == part) { 4662e192b24SSimon Glass printf("current partition deleted, resetting current to 0\n"); 4672e192b24SSimon Glass current_mtd_partnum = 0; 4682e192b24SSimon Glass } else if (part->offset <= curr_pi->offset) { 4692e192b24SSimon Glass current_mtd_partnum--; 4702e192b24SSimon Glass } 4712e192b24SSimon Glass current_save_needed = 1; 4722e192b24SSimon Glass } 4732e192b24SSimon Glass } 4742e192b24SSimon Glass 4752e192b24SSimon Glass list_del(&part->link); 4762e192b24SSimon Glass free(part); 4772e192b24SSimon Glass dev->num_parts--; 4782e192b24SSimon Glass 4792e192b24SSimon Glass if (current_save_needed > 0) 4802e192b24SSimon Glass current_save(); 4812e192b24SSimon Glass else 4822e192b24SSimon Glass index_partitions(); 4832e192b24SSimon Glass 4842e192b24SSimon Glass return 0; 4852e192b24SSimon Glass } 4862e192b24SSimon Glass 4872e192b24SSimon Glass /** 4882e192b24SSimon Glass * Delete all partitions from parts head list, free memory. 4892e192b24SSimon Glass * 4902e192b24SSimon Glass * @param head list of partitions to delete 4912e192b24SSimon Glass */ 4922e192b24SSimon Glass static void part_delall(struct list_head *head) 4932e192b24SSimon Glass { 4942e192b24SSimon Glass struct list_head *entry, *n; 4952e192b24SSimon Glass struct part_info *part_tmp; 4962e192b24SSimon Glass 4972e192b24SSimon Glass /* clean tmp_list and free allocated memory */ 4982e192b24SSimon Glass list_for_each_safe(entry, n, head) { 4992e192b24SSimon Glass part_tmp = list_entry(entry, struct part_info, link); 5002e192b24SSimon Glass 5012e192b24SSimon Glass list_del(entry); 5022e192b24SSimon Glass free(part_tmp); 5032e192b24SSimon Glass } 5042e192b24SSimon Glass } 5052e192b24SSimon Glass 5062e192b24SSimon Glass /** 5072e192b24SSimon Glass * Add new partition to the supplied partition list. Make sure partitions are 5082e192b24SSimon Glass * sorted by offset in ascending order. 5092e192b24SSimon Glass * 5102e192b24SSimon Glass * @param head list this partition is to be added to 5112e192b24SSimon Glass * @param new partition to be added 5122e192b24SSimon Glass */ 5132e192b24SSimon Glass static int part_sort_add(struct mtd_device *dev, struct part_info *part) 5142e192b24SSimon Glass { 5152e192b24SSimon Glass struct list_head *entry; 5162e192b24SSimon Glass struct part_info *new_pi, *curr_pi; 5172e192b24SSimon Glass 5182e192b24SSimon Glass /* link partition to parrent dev */ 5192e192b24SSimon Glass part->dev = dev; 5202e192b24SSimon Glass 5212e192b24SSimon Glass if (list_empty(&dev->parts)) { 5222e192b24SSimon Glass debug("part_sort_add: list empty\n"); 5232e192b24SSimon Glass list_add(&part->link, &dev->parts); 5242e192b24SSimon Glass dev->num_parts++; 5252e192b24SSimon Glass index_partitions(); 5262e192b24SSimon Glass return 0; 5272e192b24SSimon Glass } 5282e192b24SSimon Glass 5292e192b24SSimon Glass new_pi = list_entry(&part->link, struct part_info, link); 5302e192b24SSimon Glass 5312e192b24SSimon Glass /* get current partition info if we are updating current device */ 5322e192b24SSimon Glass curr_pi = NULL; 5332e192b24SSimon Glass if (dev == current_mtd_dev) 5342e192b24SSimon Glass curr_pi = mtd_part_info(current_mtd_dev, current_mtd_partnum); 5352e192b24SSimon Glass 5362e192b24SSimon Glass list_for_each(entry, &dev->parts) { 5372e192b24SSimon Glass struct part_info *pi; 5382e192b24SSimon Glass 5392e192b24SSimon Glass pi = list_entry(entry, struct part_info, link); 5402e192b24SSimon Glass 5412e192b24SSimon Glass /* be compliant with kernel cmdline, allow only one partition at offset zero */ 5422e192b24SSimon Glass if ((new_pi->offset == pi->offset) && (pi->offset == 0)) { 5432e192b24SSimon Glass printf("cannot add second partition at offset 0\n"); 5442e192b24SSimon Glass return 1; 5452e192b24SSimon Glass } 5462e192b24SSimon Glass 5472e192b24SSimon Glass if (new_pi->offset <= pi->offset) { 5482e192b24SSimon Glass list_add_tail(&part->link, entry); 5492e192b24SSimon Glass dev->num_parts++; 5502e192b24SSimon Glass 5512e192b24SSimon Glass if (curr_pi && (pi->offset <= curr_pi->offset)) { 5522e192b24SSimon Glass /* we are modyfing partitions for the current 5532e192b24SSimon Glass * device, update current */ 5542e192b24SSimon Glass current_mtd_partnum++; 5552e192b24SSimon Glass current_save(); 5562e192b24SSimon Glass } else { 5572e192b24SSimon Glass index_partitions(); 5582e192b24SSimon Glass } 5592e192b24SSimon Glass return 0; 5602e192b24SSimon Glass } 5612e192b24SSimon Glass } 5622e192b24SSimon Glass 5632e192b24SSimon Glass list_add_tail(&part->link, &dev->parts); 5642e192b24SSimon Glass dev->num_parts++; 5652e192b24SSimon Glass index_partitions(); 5662e192b24SSimon Glass return 0; 5672e192b24SSimon Glass } 5682e192b24SSimon Glass 5692e192b24SSimon Glass /** 5702e192b24SSimon Glass * Add provided partition to the partition list of a given device. 5712e192b24SSimon Glass * 5722e192b24SSimon Glass * @param dev device to which partition is added 5732e192b24SSimon Glass * @param part partition to be added 5742e192b24SSimon Glass * @return 0 on success, 1 otherwise 5752e192b24SSimon Glass */ 5762e192b24SSimon Glass static int part_add(struct mtd_device *dev, struct part_info *part) 5772e192b24SSimon Glass { 5782e192b24SSimon Glass /* verify alignment and size */ 5792e192b24SSimon Glass if (part_validate(dev->id, part) != 0) 5802e192b24SSimon Glass return 1; 5812e192b24SSimon Glass 5822e192b24SSimon Glass /* partition is ok, add it to the list */ 5832e192b24SSimon Glass if (part_sort_add(dev, part) != 0) 5842e192b24SSimon Glass return 1; 5852e192b24SSimon Glass 5862e192b24SSimon Glass return 0; 5872e192b24SSimon Glass } 5882e192b24SSimon Glass 5892e192b24SSimon Glass /** 5902e192b24SSimon Glass * Parse one partition definition, allocate memory and return pointer to this 5912e192b24SSimon Glass * location in retpart. 5922e192b24SSimon Glass * 5932e192b24SSimon Glass * @param partdef pointer to the partition definition string i.e. <part-def> 5942e192b24SSimon Glass * @param ret output pointer to next char after parse completes (output) 5952e192b24SSimon Glass * @param retpart pointer to the allocated partition (output) 5962e192b24SSimon Glass * @return 0 on success, 1 otherwise 5972e192b24SSimon Glass */ 5982e192b24SSimon Glass static int part_parse(const char *const partdef, const char **ret, struct part_info **retpart) 5992e192b24SSimon Glass { 6002e192b24SSimon Glass struct part_info *part; 6012e192b24SSimon Glass u64 size; 6022e192b24SSimon Glass u64 offset; 6032e192b24SSimon Glass const char *name; 6042e192b24SSimon Glass int name_len; 6052e192b24SSimon Glass unsigned int mask_flags; 6062e192b24SSimon Glass const char *p; 6072e192b24SSimon Glass 6082e192b24SSimon Glass p = partdef; 6092e192b24SSimon Glass *retpart = NULL; 6102e192b24SSimon Glass *ret = NULL; 6112e192b24SSimon Glass 6122e192b24SSimon Glass /* fetch the partition size */ 6132e192b24SSimon Glass if (*p == '-') { 6142e192b24SSimon Glass /* assign all remaining space to this partition */ 6152e192b24SSimon Glass debug("'-': remaining size assigned\n"); 6162e192b24SSimon Glass size = SIZE_REMAINING; 6172e192b24SSimon Glass p++; 6182e192b24SSimon Glass } else { 6192e192b24SSimon Glass size = memsize_parse(p, &p); 6202e192b24SSimon Glass if (size < MIN_PART_SIZE) { 6212e192b24SSimon Glass printf("partition size too small (%llx)\n", size); 6222e192b24SSimon Glass return 1; 6232e192b24SSimon Glass } 6242e192b24SSimon Glass } 6252e192b24SSimon Glass 6262e192b24SSimon Glass /* check for offset */ 6272e192b24SSimon Glass offset = OFFSET_NOT_SPECIFIED; 6282e192b24SSimon Glass if (*p == '@') { 6292e192b24SSimon Glass p++; 6302e192b24SSimon Glass offset = memsize_parse(p, &p); 6312e192b24SSimon Glass } 6322e192b24SSimon Glass 6332e192b24SSimon Glass /* now look for the name */ 6342e192b24SSimon Glass if (*p == '(') { 6352e192b24SSimon Glass name = ++p; 6362e192b24SSimon Glass if ((p = strchr(name, ')')) == NULL) { 6372e192b24SSimon Glass printf("no closing ) found in partition name\n"); 6382e192b24SSimon Glass return 1; 6392e192b24SSimon Glass } 6402e192b24SSimon Glass name_len = p - name + 1; 6412e192b24SSimon Glass if ((name_len - 1) == 0) { 6422e192b24SSimon Glass printf("empty partition name\n"); 6432e192b24SSimon Glass return 1; 6442e192b24SSimon Glass } 6452e192b24SSimon Glass p++; 6462e192b24SSimon Glass } else { 6472e192b24SSimon Glass /* 0x00000000@0x00000000 */ 6482e192b24SSimon Glass name_len = 22; 6492e192b24SSimon Glass name = NULL; 6502e192b24SSimon Glass } 6512e192b24SSimon Glass 6522e192b24SSimon Glass /* test for options */ 6532e192b24SSimon Glass mask_flags = 0; 6542e192b24SSimon Glass if (strncmp(p, "ro", 2) == 0) { 6552e192b24SSimon Glass mask_flags |= MTD_WRITEABLE_CMD; 6562e192b24SSimon Glass p += 2; 6572e192b24SSimon Glass } 6582e192b24SSimon Glass 6592e192b24SSimon Glass /* check for next partition definition */ 6602e192b24SSimon Glass if (*p == ',') { 6612e192b24SSimon Glass if (size == SIZE_REMAINING) { 6622e192b24SSimon Glass *ret = NULL; 6632e192b24SSimon Glass printf("no partitions allowed after a fill-up partition\n"); 6642e192b24SSimon Glass return 1; 6652e192b24SSimon Glass } 6662e192b24SSimon Glass *ret = ++p; 6672e192b24SSimon Glass } else if ((*p == ';') || (*p == '\0')) { 6682e192b24SSimon Glass *ret = p; 6692e192b24SSimon Glass } else { 6702e192b24SSimon Glass printf("unexpected character '%c' at the end of partition\n", *p); 6712e192b24SSimon Glass *ret = NULL; 6722e192b24SSimon Glass return 1; 6732e192b24SSimon Glass } 6742e192b24SSimon Glass 6752e192b24SSimon Glass /* allocate memory */ 6762e192b24SSimon Glass part = (struct part_info *)malloc(sizeof(struct part_info) + name_len); 6772e192b24SSimon Glass if (!part) { 6782e192b24SSimon Glass printf("out of memory\n"); 6792e192b24SSimon Glass return 1; 6802e192b24SSimon Glass } 6812e192b24SSimon Glass memset(part, 0, sizeof(struct part_info) + name_len); 6822e192b24SSimon Glass part->size = size; 6832e192b24SSimon Glass part->offset = offset; 6842e192b24SSimon Glass part->mask_flags = mask_flags; 6852e192b24SSimon Glass part->name = (char *)(part + 1); 6862e192b24SSimon Glass 6872e192b24SSimon Glass if (name) { 6882e192b24SSimon Glass /* copy user provided name */ 6892e192b24SSimon Glass strncpy(part->name, name, name_len - 1); 6902e192b24SSimon Glass part->auto_name = 0; 6912e192b24SSimon Glass } else { 6922e192b24SSimon Glass /* auto generated name in form of size@offset */ 6932e192b24SSimon Glass sprintf(part->name, "0x%08llx@0x%08llx", size, offset); 6942e192b24SSimon Glass part->auto_name = 1; 6952e192b24SSimon Glass } 6962e192b24SSimon Glass 6972e192b24SSimon Glass part->name[name_len - 1] = '\0'; 6982e192b24SSimon Glass INIT_LIST_HEAD(&part->link); 6992e192b24SSimon Glass 7002e192b24SSimon Glass debug("+ partition: name %-22s size 0x%08llx offset 0x%08llx mask flags %d\n", 7012e192b24SSimon Glass part->name, part->size, 7022e192b24SSimon Glass part->offset, part->mask_flags); 7032e192b24SSimon Glass 7042e192b24SSimon Glass *retpart = part; 7052e192b24SSimon Glass return 0; 7062e192b24SSimon Glass } 7072e192b24SSimon Glass 7082e192b24SSimon Glass /** 7092e192b24SSimon Glass * Check device number to be within valid range for given device type. 7102e192b24SSimon Glass * 7112e192b24SSimon Glass * @param type mtd type 7122e192b24SSimon Glass * @param num mtd number 7132e192b24SSimon Glass * @param size a pointer to the size of the mtd device (output) 7142e192b24SSimon Glass * @return 0 if device is valid, 1 otherwise 7152e192b24SSimon Glass */ 7162e192b24SSimon Glass static int mtd_device_validate(u8 type, u8 num, u64 *size) 7172e192b24SSimon Glass { 7182e192b24SSimon Glass struct mtd_info *mtd = NULL; 7192e192b24SSimon Glass 7202e192b24SSimon Glass if (get_mtd_info(type, num, &mtd)) 7212e192b24SSimon Glass return 1; 7222e192b24SSimon Glass 7232e192b24SSimon Glass *size = mtd->size; 7242e192b24SSimon Glass 7252e192b24SSimon Glass return 0; 7262e192b24SSimon Glass } 7272e192b24SSimon Glass 7282e192b24SSimon Glass /** 7292e192b24SSimon Glass * Delete all mtd devices from a supplied devices list, free memory allocated for 7302e192b24SSimon Glass * each device and delete all device partitions. 7312e192b24SSimon Glass * 7322e192b24SSimon Glass * @return 0 on success, 1 otherwise 7332e192b24SSimon Glass */ 7342e192b24SSimon Glass static int device_delall(struct list_head *head) 7352e192b24SSimon Glass { 7362e192b24SSimon Glass struct list_head *entry, *n; 7372e192b24SSimon Glass struct mtd_device *dev_tmp; 7382e192b24SSimon Glass 7392e192b24SSimon Glass /* clean devices list */ 7402e192b24SSimon Glass list_for_each_safe(entry, n, head) { 7412e192b24SSimon Glass dev_tmp = list_entry(entry, struct mtd_device, link); 7422e192b24SSimon Glass list_del(entry); 7432e192b24SSimon Glass part_delall(&dev_tmp->parts); 7442e192b24SSimon Glass free(dev_tmp); 7452e192b24SSimon Glass } 7462e192b24SSimon Glass INIT_LIST_HEAD(&devices); 7472e192b24SSimon Glass 7482e192b24SSimon Glass return 0; 7492e192b24SSimon Glass } 7502e192b24SSimon Glass 7512e192b24SSimon Glass /** 7522e192b24SSimon Glass * If provided device exists it's partitions are deleted, device is removed 7532e192b24SSimon Glass * from device list and device memory is freed. 7542e192b24SSimon Glass * 7552e192b24SSimon Glass * @param dev device to be deleted 7562e192b24SSimon Glass * @return 0 on success, 1 otherwise 7572e192b24SSimon Glass */ 7582e192b24SSimon Glass static int device_del(struct mtd_device *dev) 7592e192b24SSimon Glass { 7602e192b24SSimon Glass part_delall(&dev->parts); 7612e192b24SSimon Glass list_del(&dev->link); 7622e192b24SSimon Glass free(dev); 7632e192b24SSimon Glass 7642e192b24SSimon Glass if (dev == current_mtd_dev) { 7652e192b24SSimon Glass /* we just deleted current device */ 7662e192b24SSimon Glass if (list_empty(&devices)) { 7672e192b24SSimon Glass current_mtd_dev = NULL; 7682e192b24SSimon Glass } else { 7692e192b24SSimon Glass /* reset first partition from first dev from the 7702e192b24SSimon Glass * devices list as current */ 7712e192b24SSimon Glass current_mtd_dev = list_entry(devices.next, struct mtd_device, link); 7722e192b24SSimon Glass current_mtd_partnum = 0; 7732e192b24SSimon Glass } 7742e192b24SSimon Glass current_save(); 7752e192b24SSimon Glass return 0; 7762e192b24SSimon Glass } 7772e192b24SSimon Glass 7782e192b24SSimon Glass index_partitions(); 7792e192b24SSimon Glass return 0; 7802e192b24SSimon Glass } 7812e192b24SSimon Glass 7822e192b24SSimon Glass /** 7832e192b24SSimon Glass * Search global device list and return pointer to the device of type and num 7842e192b24SSimon Glass * specified. 7852e192b24SSimon Glass * 7862e192b24SSimon Glass * @param type device type 7872e192b24SSimon Glass * @param num device number 7882e192b24SSimon Glass * @return NULL if requested device does not exist 7892e192b24SSimon Glass */ 7902e192b24SSimon Glass struct mtd_device *device_find(u8 type, u8 num) 7912e192b24SSimon Glass { 7922e192b24SSimon Glass struct list_head *entry; 7932e192b24SSimon Glass struct mtd_device *dev_tmp; 7942e192b24SSimon Glass 7952e192b24SSimon Glass list_for_each(entry, &devices) { 7962e192b24SSimon Glass dev_tmp = list_entry(entry, struct mtd_device, link); 7972e192b24SSimon Glass 7982e192b24SSimon Glass if ((dev_tmp->id->type == type) && (dev_tmp->id->num == num)) 7992e192b24SSimon Glass return dev_tmp; 8002e192b24SSimon Glass } 8012e192b24SSimon Glass 8022e192b24SSimon Glass return NULL; 8032e192b24SSimon Glass } 8042e192b24SSimon Glass 8052e192b24SSimon Glass /** 8062e192b24SSimon Glass * Add specified device to the global device list. 8072e192b24SSimon Glass * 8082e192b24SSimon Glass * @param dev device to be added 8092e192b24SSimon Glass */ 8102e192b24SSimon Glass static void device_add(struct mtd_device *dev) 8112e192b24SSimon Glass { 8122e192b24SSimon Glass u8 current_save_needed = 0; 8132e192b24SSimon Glass 8142e192b24SSimon Glass if (list_empty(&devices)) { 8152e192b24SSimon Glass current_mtd_dev = dev; 8162e192b24SSimon Glass current_mtd_partnum = 0; 8172e192b24SSimon Glass current_save_needed = 1; 8182e192b24SSimon Glass } 8192e192b24SSimon Glass 8202e192b24SSimon Glass list_add_tail(&dev->link, &devices); 8212e192b24SSimon Glass 8222e192b24SSimon Glass if (current_save_needed > 0) 8232e192b24SSimon Glass current_save(); 8242e192b24SSimon Glass else 8252e192b24SSimon Glass index_partitions(); 8262e192b24SSimon Glass } 8272e192b24SSimon Glass 8282e192b24SSimon Glass /** 8292e192b24SSimon Glass * Parse device type, name and mtd-id. If syntax is ok allocate memory and 8302e192b24SSimon Glass * return pointer to the device structure. 8312e192b24SSimon Glass * 8322e192b24SSimon Glass * @param mtd_dev pointer to the device definition string i.e. <mtd-dev> 8332e192b24SSimon Glass * @param ret output pointer to next char after parse completes (output) 8342e192b24SSimon Glass * @param retdev pointer to the allocated device (output) 8352e192b24SSimon Glass * @return 0 on success, 1 otherwise 8362e192b24SSimon Glass */ 8372e192b24SSimon Glass static int device_parse(const char *const mtd_dev, const char **ret, struct mtd_device **retdev) 8382e192b24SSimon Glass { 8392e192b24SSimon Glass struct mtd_device *dev; 8402e192b24SSimon Glass struct part_info *part; 8412e192b24SSimon Glass struct mtdids *id; 8422e192b24SSimon Glass const char *mtd_id; 8432e192b24SSimon Glass unsigned int mtd_id_len; 8442e192b24SSimon Glass const char *p; 8452e192b24SSimon Glass const char *pend; 8462e192b24SSimon Glass LIST_HEAD(tmp_list); 8472e192b24SSimon Glass struct list_head *entry, *n; 8482e192b24SSimon Glass u16 num_parts; 8492e192b24SSimon Glass u64 offset; 8502e192b24SSimon Glass int err = 1; 8512e192b24SSimon Glass 8522e192b24SSimon Glass debug("===device_parse===\n"); 8532e192b24SSimon Glass 8542e192b24SSimon Glass assert(retdev); 8552e192b24SSimon Glass *retdev = NULL; 8562e192b24SSimon Glass 8572e192b24SSimon Glass if (ret) 8582e192b24SSimon Glass *ret = NULL; 8592e192b24SSimon Glass 8602e192b24SSimon Glass /* fetch <mtd-id> */ 8612e192b24SSimon Glass mtd_id = p = mtd_dev; 8622e192b24SSimon Glass if (!(p = strchr(mtd_id, ':'))) { 8632e192b24SSimon Glass printf("no <mtd-id> identifier\n"); 8642e192b24SSimon Glass return 1; 8652e192b24SSimon Glass } 8662e192b24SSimon Glass mtd_id_len = p - mtd_id + 1; 8672e192b24SSimon Glass p++; 8682e192b24SSimon Glass 8692e192b24SSimon Glass /* verify if we have a valid device specified */ 8702e192b24SSimon Glass if ((id = id_find_by_mtd_id(mtd_id, mtd_id_len - 1)) == NULL) { 8712e192b24SSimon Glass printf("invalid mtd device '%.*s'\n", mtd_id_len - 1, mtd_id); 8722e192b24SSimon Glass return 1; 8732e192b24SSimon Glass } 8742e192b24SSimon Glass 8752e192b24SSimon Glass pend = strchr(p, ';'); 8762e192b24SSimon Glass debug("dev type = %d (%s), dev num = %d, mtd-id = %s\n", 8772e192b24SSimon Glass id->type, MTD_DEV_TYPE(id->type), 8782e192b24SSimon Glass id->num, id->mtd_id); 8792e192b24SSimon Glass debug("parsing partitions %.*s\n", (int)(pend ? pend - p : strlen(p)), p); 8802e192b24SSimon Glass 8812e192b24SSimon Glass /* parse partitions */ 8822e192b24SSimon Glass num_parts = 0; 8832e192b24SSimon Glass 8842e192b24SSimon Glass offset = 0; 8852e192b24SSimon Glass if ((dev = device_find(id->type, id->num)) != NULL) { 8862e192b24SSimon Glass /* if device already exists start at the end of the last partition */ 8872e192b24SSimon Glass part = list_entry(dev->parts.prev, struct part_info, link); 8882e192b24SSimon Glass offset = part->offset + part->size; 8892e192b24SSimon Glass } 8902e192b24SSimon Glass 8912e192b24SSimon Glass while (p && (*p != '\0') && (*p != ';')) { 8922e192b24SSimon Glass err = 1; 8932e192b24SSimon Glass if ((part_parse(p, &p, &part) != 0) || (!part)) 8942e192b24SSimon Glass break; 8952e192b24SSimon Glass 8962e192b24SSimon Glass /* calculate offset when not specified */ 8972e192b24SSimon Glass if (part->offset == OFFSET_NOT_SPECIFIED) 8982e192b24SSimon Glass part->offset = offset; 8992e192b24SSimon Glass else 9002e192b24SSimon Glass offset = part->offset; 9012e192b24SSimon Glass 9022e192b24SSimon Glass /* verify alignment and size */ 9032e192b24SSimon Glass if (part_validate(id, part) != 0) 9042e192b24SSimon Glass break; 9052e192b24SSimon Glass 9062e192b24SSimon Glass offset += part->size; 9072e192b24SSimon Glass 9082e192b24SSimon Glass /* partition is ok, add it to the list */ 9092e192b24SSimon Glass list_add_tail(&part->link, &tmp_list); 9102e192b24SSimon Glass num_parts++; 9112e192b24SSimon Glass err = 0; 9122e192b24SSimon Glass } 9132e192b24SSimon Glass if (err == 1) { 9142e192b24SSimon Glass part_delall(&tmp_list); 9152e192b24SSimon Glass return 1; 9162e192b24SSimon Glass } 9172e192b24SSimon Glass 9182e192b24SSimon Glass debug("\ntotal partitions: %d\n", num_parts); 9192e192b24SSimon Glass 9202e192b24SSimon Glass /* check for next device presence */ 9212e192b24SSimon Glass if (p) { 9222e192b24SSimon Glass if (*p == ';') { 9232e192b24SSimon Glass if (ret) 9242e192b24SSimon Glass *ret = ++p; 9252e192b24SSimon Glass } else if (*p == '\0') { 9262e192b24SSimon Glass if (ret) 9272e192b24SSimon Glass *ret = p; 9282e192b24SSimon Glass } else { 9292e192b24SSimon Glass printf("unexpected character '%c' at the end of device\n", *p); 9302e192b24SSimon Glass if (ret) 9312e192b24SSimon Glass *ret = NULL; 9322e192b24SSimon Glass return 1; 9332e192b24SSimon Glass } 9342e192b24SSimon Glass } 9352e192b24SSimon Glass 9362e192b24SSimon Glass /* allocate memory for mtd_device structure */ 9372e192b24SSimon Glass if ((dev = (struct mtd_device *)malloc(sizeof(struct mtd_device))) == NULL) { 9382e192b24SSimon Glass printf("out of memory\n"); 9392e192b24SSimon Glass return 1; 9402e192b24SSimon Glass } 9412e192b24SSimon Glass memset(dev, 0, sizeof(struct mtd_device)); 9422e192b24SSimon Glass dev->id = id; 9432e192b24SSimon Glass dev->num_parts = 0; /* part_sort_add increments num_parts */ 9442e192b24SSimon Glass INIT_LIST_HEAD(&dev->parts); 9452e192b24SSimon Glass INIT_LIST_HEAD(&dev->link); 9462e192b24SSimon Glass 9472e192b24SSimon Glass /* move partitions from tmp_list to dev->parts */ 9482e192b24SSimon Glass list_for_each_safe(entry, n, &tmp_list) { 9492e192b24SSimon Glass part = list_entry(entry, struct part_info, link); 9502e192b24SSimon Glass list_del(entry); 9512e192b24SSimon Glass if (part_sort_add(dev, part) != 0) { 9522e192b24SSimon Glass device_del(dev); 9532e192b24SSimon Glass return 1; 9542e192b24SSimon Glass } 9552e192b24SSimon Glass } 9562e192b24SSimon Glass 9572e192b24SSimon Glass *retdev = dev; 9582e192b24SSimon Glass 9592e192b24SSimon Glass debug("===\n\n"); 9602e192b24SSimon Glass return 0; 9612e192b24SSimon Glass } 9622e192b24SSimon Glass 9632e192b24SSimon Glass /** 9642e192b24SSimon Glass * Initialize global device list. 9652e192b24SSimon Glass * 9662e192b24SSimon Glass * @return 0 on success, 1 otherwise 9672e192b24SSimon Glass */ 9682e192b24SSimon Glass static int mtd_devices_init(void) 9692e192b24SSimon Glass { 9702e192b24SSimon Glass last_parts[0] = '\0'; 9712e192b24SSimon Glass current_mtd_dev = NULL; 9722e192b24SSimon Glass current_save(); 9732e192b24SSimon Glass 9742e192b24SSimon Glass return device_delall(&devices); 9752e192b24SSimon Glass } 9762e192b24SSimon Glass 9772e192b24SSimon Glass /* 9782e192b24SSimon Glass * Search global mtdids list and find id of requested type and number. 9792e192b24SSimon Glass * 9802e192b24SSimon Glass * @return pointer to the id if it exists, NULL otherwise 9812e192b24SSimon Glass */ 9822e192b24SSimon Glass static struct mtdids* id_find(u8 type, u8 num) 9832e192b24SSimon Glass { 9842e192b24SSimon Glass struct list_head *entry; 9852e192b24SSimon Glass struct mtdids *id; 9862e192b24SSimon Glass 9872e192b24SSimon Glass list_for_each(entry, &mtdids) { 9882e192b24SSimon Glass id = list_entry(entry, struct mtdids, link); 9892e192b24SSimon Glass 9902e192b24SSimon Glass if ((id->type == type) && (id->num == num)) 9912e192b24SSimon Glass return id; 9922e192b24SSimon Glass } 9932e192b24SSimon Glass 9942e192b24SSimon Glass return NULL; 9952e192b24SSimon Glass } 9962e192b24SSimon Glass 9972e192b24SSimon Glass /** 9982e192b24SSimon Glass * Search global mtdids list and find id of a requested mtd_id. 9992e192b24SSimon Glass * 10002e192b24SSimon Glass * Note: first argument is not null terminated. 10012e192b24SSimon Glass * 10022e192b24SSimon Glass * @param mtd_id string containing requested mtd_id 10032e192b24SSimon Glass * @param mtd_id_len length of supplied mtd_id 10042e192b24SSimon Glass * @return pointer to the id if it exists, NULL otherwise 10052e192b24SSimon Glass */ 10062e192b24SSimon Glass static struct mtdids* id_find_by_mtd_id(const char *mtd_id, unsigned int mtd_id_len) 10072e192b24SSimon Glass { 10082e192b24SSimon Glass struct list_head *entry; 10092e192b24SSimon Glass struct mtdids *id; 10102e192b24SSimon Glass 10112e192b24SSimon Glass debug("--- id_find_by_mtd_id: '%.*s' (len = %d)\n", 10122e192b24SSimon Glass mtd_id_len, mtd_id, mtd_id_len); 10132e192b24SSimon Glass 10142e192b24SSimon Glass list_for_each(entry, &mtdids) { 10152e192b24SSimon Glass id = list_entry(entry, struct mtdids, link); 10162e192b24SSimon Glass 10172e192b24SSimon Glass debug("entry: '%s' (len = %zu)\n", 10182e192b24SSimon Glass id->mtd_id, strlen(id->mtd_id)); 10192e192b24SSimon Glass 10202e192b24SSimon Glass if (mtd_id_len != strlen(id->mtd_id)) 10212e192b24SSimon Glass continue; 10222e192b24SSimon Glass if (strncmp(id->mtd_id, mtd_id, mtd_id_len) == 0) 10232e192b24SSimon Glass return id; 10242e192b24SSimon Glass } 10252e192b24SSimon Glass 10262e192b24SSimon Glass return NULL; 10272e192b24SSimon Glass } 10282e192b24SSimon Glass 10292e192b24SSimon Glass /** 10302e192b24SSimon Glass * Parse device id string <dev-id> := 'nand'|'nor'|'onenand'<dev-num>, 10312e192b24SSimon Glass * return device type and number. 10322e192b24SSimon Glass * 10332e192b24SSimon Glass * @param id string describing device id 10342e192b24SSimon Glass * @param ret_id output pointer to next char after parse completes (output) 10352e192b24SSimon Glass * @param dev_type parsed device type (output) 10362e192b24SSimon Glass * @param dev_num parsed device number (output) 10372e192b24SSimon Glass * @return 0 on success, 1 otherwise 10382e192b24SSimon Glass */ 10392e192b24SSimon Glass int mtd_id_parse(const char *id, const char **ret_id, u8 *dev_type, 10402e192b24SSimon Glass u8 *dev_num) 10412e192b24SSimon Glass { 10422e192b24SSimon Glass const char *p = id; 10432e192b24SSimon Glass 10442e192b24SSimon Glass *dev_type = 0; 10452e192b24SSimon Glass if (strncmp(p, "nand", 4) == 0) { 10462e192b24SSimon Glass *dev_type = MTD_DEV_TYPE_NAND; 10472e192b24SSimon Glass p += 4; 10482e192b24SSimon Glass } else if (strncmp(p, "nor", 3) == 0) { 10492e192b24SSimon Glass *dev_type = MTD_DEV_TYPE_NOR; 10502e192b24SSimon Glass p += 3; 10512e192b24SSimon Glass } else if (strncmp(p, "onenand", 7) == 0) { 10522e192b24SSimon Glass *dev_type = MTD_DEV_TYPE_ONENAND; 10532e192b24SSimon Glass p += 7; 10542e192b24SSimon Glass } else { 10552e192b24SSimon Glass printf("incorrect device type in %s\n", id); 10562e192b24SSimon Glass return 1; 10572e192b24SSimon Glass } 10582e192b24SSimon Glass 10592e192b24SSimon Glass if (!isdigit(*p)) { 10602e192b24SSimon Glass printf("incorrect device number in %s\n", id); 10612e192b24SSimon Glass return 1; 10622e192b24SSimon Glass } 10632e192b24SSimon Glass 10642e192b24SSimon Glass *dev_num = simple_strtoul(p, (char **)&p, 0); 10652e192b24SSimon Glass if (ret_id) 10662e192b24SSimon Glass *ret_id = p; 10672e192b24SSimon Glass return 0; 10682e192b24SSimon Glass } 10692e192b24SSimon Glass 10702e192b24SSimon Glass /** 10712e192b24SSimon Glass * Process all devices and generate corresponding mtdparts string describing 10722e192b24SSimon Glass * all partitions on all devices. 10732e192b24SSimon Glass * 10742e192b24SSimon Glass * @param buf output buffer holding generated mtdparts string (output) 10752e192b24SSimon Glass * @param buflen buffer size 10762e192b24SSimon Glass * @return 0 on success, 1 otherwise 10772e192b24SSimon Glass */ 10782e192b24SSimon Glass static int generate_mtdparts(char *buf, u32 buflen) 10792e192b24SSimon Glass { 10802e192b24SSimon Glass struct list_head *pentry, *dentry; 10812e192b24SSimon Glass struct mtd_device *dev; 10822e192b24SSimon Glass struct part_info *part, *prev_part; 10832e192b24SSimon Glass char *p = buf; 10842e192b24SSimon Glass char tmpbuf[32]; 10852e192b24SSimon Glass u64 size, offset; 10862e192b24SSimon Glass u32 len, part_cnt; 10872e192b24SSimon Glass u32 maxlen = buflen - 1; 10882e192b24SSimon Glass 10892e192b24SSimon Glass debug("--- generate_mtdparts ---\n"); 10902e192b24SSimon Glass 10912e192b24SSimon Glass if (list_empty(&devices)) { 10922e192b24SSimon Glass buf[0] = '\0'; 10932e192b24SSimon Glass return 0; 10942e192b24SSimon Glass } 10952e192b24SSimon Glass 10962e192b24SSimon Glass strcpy(p, "mtdparts="); 10972e192b24SSimon Glass p += 9; 10982e192b24SSimon Glass 10992e192b24SSimon Glass list_for_each(dentry, &devices) { 11002e192b24SSimon Glass dev = list_entry(dentry, struct mtd_device, link); 11012e192b24SSimon Glass 11022e192b24SSimon Glass /* copy mtd_id */ 11032e192b24SSimon Glass len = strlen(dev->id->mtd_id) + 1; 11042e192b24SSimon Glass if (len > maxlen) 11052e192b24SSimon Glass goto cleanup; 11062e192b24SSimon Glass memcpy(p, dev->id->mtd_id, len - 1); 11072e192b24SSimon Glass p += len - 1; 11082e192b24SSimon Glass *(p++) = ':'; 11092e192b24SSimon Glass maxlen -= len; 11102e192b24SSimon Glass 11112e192b24SSimon Glass /* format partitions */ 11122e192b24SSimon Glass prev_part = NULL; 11132e192b24SSimon Glass part_cnt = 0; 11142e192b24SSimon Glass list_for_each(pentry, &dev->parts) { 11152e192b24SSimon Glass part = list_entry(pentry, struct part_info, link); 11162e192b24SSimon Glass size = part->size; 11172e192b24SSimon Glass offset = part->offset; 11182e192b24SSimon Glass part_cnt++; 11192e192b24SSimon Glass 11202e192b24SSimon Glass /* partition size */ 11212e192b24SSimon Glass memsize_format(tmpbuf, size); 11222e192b24SSimon Glass len = strlen(tmpbuf); 11232e192b24SSimon Glass if (len > maxlen) 11242e192b24SSimon Glass goto cleanup; 11252e192b24SSimon Glass memcpy(p, tmpbuf, len); 11262e192b24SSimon Glass p += len; 11272e192b24SSimon Glass maxlen -= len; 11282e192b24SSimon Glass 11292e192b24SSimon Glass 11302e192b24SSimon Glass /* add offset only when there is a gap between 11312e192b24SSimon Glass * partitions */ 11322e192b24SSimon Glass if ((!prev_part && (offset != 0)) || 11332e192b24SSimon Glass (prev_part && ((prev_part->offset + prev_part->size) != part->offset))) { 11342e192b24SSimon Glass 11352e192b24SSimon Glass memsize_format(tmpbuf, offset); 11362e192b24SSimon Glass len = strlen(tmpbuf) + 1; 11372e192b24SSimon Glass if (len > maxlen) 11382e192b24SSimon Glass goto cleanup; 11392e192b24SSimon Glass *(p++) = '@'; 11402e192b24SSimon Glass memcpy(p, tmpbuf, len - 1); 11412e192b24SSimon Glass p += len - 1; 11422e192b24SSimon Glass maxlen -= len; 11432e192b24SSimon Glass } 11442e192b24SSimon Glass 11452e192b24SSimon Glass /* copy name only if user supplied */ 11462e192b24SSimon Glass if(!part->auto_name) { 11472e192b24SSimon Glass len = strlen(part->name) + 2; 11482e192b24SSimon Glass if (len > maxlen) 11492e192b24SSimon Glass goto cleanup; 11502e192b24SSimon Glass 11512e192b24SSimon Glass *(p++) = '('; 11522e192b24SSimon Glass memcpy(p, part->name, len - 2); 11532e192b24SSimon Glass p += len - 2; 11542e192b24SSimon Glass *(p++) = ')'; 11552e192b24SSimon Glass maxlen -= len; 11562e192b24SSimon Glass } 11572e192b24SSimon Glass 11582e192b24SSimon Glass /* ro mask flag */ 11592e192b24SSimon Glass if (part->mask_flags && MTD_WRITEABLE_CMD) { 11602e192b24SSimon Glass len = 2; 11612e192b24SSimon Glass if (len > maxlen) 11622e192b24SSimon Glass goto cleanup; 11632e192b24SSimon Glass *(p++) = 'r'; 11642e192b24SSimon Glass *(p++) = 'o'; 11652e192b24SSimon Glass maxlen -= 2; 11662e192b24SSimon Glass } 11672e192b24SSimon Glass 11682e192b24SSimon Glass /* print ',' separator if there are other partitions 11692e192b24SSimon Glass * following */ 11702e192b24SSimon Glass if (dev->num_parts > part_cnt) { 11712e192b24SSimon Glass if (1 > maxlen) 11722e192b24SSimon Glass goto cleanup; 11732e192b24SSimon Glass *(p++) = ','; 11742e192b24SSimon Glass maxlen--; 11752e192b24SSimon Glass } 11762e192b24SSimon Glass prev_part = part; 11772e192b24SSimon Glass } 11782e192b24SSimon Glass /* print ';' separator if there are other devices following */ 11792e192b24SSimon Glass if (dentry->next != &devices) { 11802e192b24SSimon Glass if (1 > maxlen) 11812e192b24SSimon Glass goto cleanup; 11822e192b24SSimon Glass *(p++) = ';'; 11832e192b24SSimon Glass maxlen--; 11842e192b24SSimon Glass } 11852e192b24SSimon Glass } 11862e192b24SSimon Glass 11872e192b24SSimon Glass /* we still have at least one char left, as we decremented maxlen at 11882e192b24SSimon Glass * the begining */ 11892e192b24SSimon Glass *p = '\0'; 11902e192b24SSimon Glass 11912e192b24SSimon Glass return 0; 11922e192b24SSimon Glass 11932e192b24SSimon Glass cleanup: 11942e192b24SSimon Glass last_parts[0] = '\0'; 11952e192b24SSimon Glass return 1; 11962e192b24SSimon Glass } 11972e192b24SSimon Glass 11982e192b24SSimon Glass /** 11992e192b24SSimon Glass * Call generate_mtdparts to process all devices and generate corresponding 12002e192b24SSimon Glass * mtdparts string, save it in mtdparts environment variable. 12012e192b24SSimon Glass * 12022e192b24SSimon Glass * @param buf output buffer holding generated mtdparts string (output) 12032e192b24SSimon Glass * @param buflen buffer size 12042e192b24SSimon Glass * @return 0 on success, 1 otherwise 12052e192b24SSimon Glass */ 12062e192b24SSimon Glass static int generate_mtdparts_save(char *buf, u32 buflen) 12072e192b24SSimon Glass { 12082e192b24SSimon Glass int ret; 12092e192b24SSimon Glass 12102e192b24SSimon Glass ret = generate_mtdparts(buf, buflen); 12112e192b24SSimon Glass 12122e192b24SSimon Glass if ((buf[0] != '\0') && (ret == 0)) 1213382bee57SSimon Glass env_set("mtdparts", buf); 12142e192b24SSimon Glass else 1215382bee57SSimon Glass env_set("mtdparts", NULL); 12162e192b24SSimon Glass 12172e192b24SSimon Glass return ret; 12182e192b24SSimon Glass } 12192e192b24SSimon Glass 12202e192b24SSimon Glass #if defined(CONFIG_CMD_MTDPARTS_SHOW_NET_SIZES) 12212e192b24SSimon Glass /** 12222e192b24SSimon Glass * Get the net size (w/o bad blocks) of the given partition. 12232e192b24SSimon Glass * 12242e192b24SSimon Glass * @param mtd the mtd info 12252e192b24SSimon Glass * @param part the partition 12262e192b24SSimon Glass * @return the calculated net size of this partition 12272e192b24SSimon Glass */ 12282e192b24SSimon Glass static uint64_t net_part_size(struct mtd_info *mtd, struct part_info *part) 12292e192b24SSimon Glass { 12302e192b24SSimon Glass uint64_t i, net_size = 0; 12312e192b24SSimon Glass 12322e192b24SSimon Glass if (!mtd->block_isbad) 12332e192b24SSimon Glass return part->size; 12342e192b24SSimon Glass 12352e192b24SSimon Glass for (i = 0; i < part->size; i += mtd->erasesize) { 12362e192b24SSimon Glass if (!mtd->block_isbad(mtd, part->offset + i)) 12372e192b24SSimon Glass net_size += mtd->erasesize; 12382e192b24SSimon Glass } 12392e192b24SSimon Glass 12402e192b24SSimon Glass return net_size; 12412e192b24SSimon Glass } 12422e192b24SSimon Glass #endif 12432e192b24SSimon Glass 12442e192b24SSimon Glass static void print_partition_table(void) 12452e192b24SSimon Glass { 12462e192b24SSimon Glass struct list_head *dentry, *pentry; 12472e192b24SSimon Glass struct part_info *part; 12482e192b24SSimon Glass struct mtd_device *dev; 12492e192b24SSimon Glass int part_num; 12502e192b24SSimon Glass 12512e192b24SSimon Glass list_for_each(dentry, &devices) { 12522e192b24SSimon Glass dev = list_entry(dentry, struct mtd_device, link); 12532e192b24SSimon Glass /* list partitions for given device */ 12542e192b24SSimon Glass part_num = 0; 12552e192b24SSimon Glass #if defined(CONFIG_CMD_MTDPARTS_SHOW_NET_SIZES) 12562e192b24SSimon Glass struct mtd_info *mtd; 12572e192b24SSimon Glass 12582e192b24SSimon Glass if (get_mtd_info(dev->id->type, dev->id->num, &mtd)) 12592e192b24SSimon Glass return; 12602e192b24SSimon Glass 12612e192b24SSimon Glass printf("\ndevice %s%d <%s>, # parts = %d\n", 12622e192b24SSimon Glass MTD_DEV_TYPE(dev->id->type), dev->id->num, 12632e192b24SSimon Glass dev->id->mtd_id, dev->num_parts); 12642e192b24SSimon Glass printf(" #: name\t\tsize\t\tnet size\toffset\t\tmask_flags\n"); 12652e192b24SSimon Glass 12662e192b24SSimon Glass list_for_each(pentry, &dev->parts) { 12672e192b24SSimon Glass u32 net_size; 12682e192b24SSimon Glass char *size_note; 12692e192b24SSimon Glass 12702e192b24SSimon Glass part = list_entry(pentry, struct part_info, link); 12712e192b24SSimon Glass net_size = net_part_size(mtd, part); 12722e192b24SSimon Glass size_note = part->size == net_size ? " " : " (!)"; 12732e192b24SSimon Glass printf("%2d: %-20s0x%08x\t0x%08x%s\t0x%08x\t%d\n", 12742e192b24SSimon Glass part_num, part->name, part->size, 12752e192b24SSimon Glass net_size, size_note, part->offset, 12762e192b24SSimon Glass part->mask_flags); 12772e192b24SSimon Glass #else /* !defined(CONFIG_CMD_MTDPARTS_SHOW_NET_SIZES) */ 12782e192b24SSimon Glass printf("\ndevice %s%d <%s>, # parts = %d\n", 12792e192b24SSimon Glass MTD_DEV_TYPE(dev->id->type), dev->id->num, 12802e192b24SSimon Glass dev->id->mtd_id, dev->num_parts); 12812e192b24SSimon Glass printf(" #: name\t\tsize\t\toffset\t\tmask_flags\n"); 12822e192b24SSimon Glass 12832e192b24SSimon Glass list_for_each(pentry, &dev->parts) { 12842e192b24SSimon Glass part = list_entry(pentry, struct part_info, link); 12852e192b24SSimon Glass printf("%2d: %-20s0x%08llx\t0x%08llx\t%d\n", 12862e192b24SSimon Glass part_num, part->name, part->size, 12872e192b24SSimon Glass part->offset, part->mask_flags); 12882e192b24SSimon Glass #endif /* defined(CONFIG_CMD_MTDPARTS_SHOW_NET_SIZES) */ 12892e192b24SSimon Glass part_num++; 12902e192b24SSimon Glass } 12912e192b24SSimon Glass } 12922e192b24SSimon Glass 12932e192b24SSimon Glass if (list_empty(&devices)) 12942e192b24SSimon Glass printf("no partitions defined\n"); 12952e192b24SSimon Glass } 12962e192b24SSimon Glass 12972e192b24SSimon Glass /** 12982e192b24SSimon Glass * Format and print out a partition list for each device from global device 12992e192b24SSimon Glass * list. 13002e192b24SSimon Glass */ 13012e192b24SSimon Glass static void list_partitions(void) 13022e192b24SSimon Glass { 13032e192b24SSimon Glass struct part_info *part; 13042e192b24SSimon Glass 13052e192b24SSimon Glass debug("\n---list_partitions---\n"); 13062e192b24SSimon Glass print_partition_table(); 13072e192b24SSimon Glass 13082e192b24SSimon Glass /* current_mtd_dev is not NULL only when we have non empty device list */ 13092e192b24SSimon Glass if (current_mtd_dev) { 13102e192b24SSimon Glass part = mtd_part_info(current_mtd_dev, current_mtd_partnum); 13112e192b24SSimon Glass if (part) { 13122e192b24SSimon Glass printf("\nactive partition: %s%d,%d - (%s) 0x%08llx @ 0x%08llx\n", 13132e192b24SSimon Glass MTD_DEV_TYPE(current_mtd_dev->id->type), 13142e192b24SSimon Glass current_mtd_dev->id->num, current_mtd_partnum, 13152e192b24SSimon Glass part->name, part->size, part->offset); 13162e192b24SSimon Glass } else { 13172e192b24SSimon Glass printf("could not get current partition info\n\n"); 13182e192b24SSimon Glass } 13192e192b24SSimon Glass } 13202e192b24SSimon Glass 13212e192b24SSimon Glass printf("\ndefaults:\n"); 13222e192b24SSimon Glass printf("mtdids : %s\n", 13232e192b24SSimon Glass mtdids_default ? mtdids_default : "none"); 13242e192b24SSimon Glass /* 13252e192b24SSimon Glass * Using printf() here results in printbuffer overflow 13262e192b24SSimon Glass * if default mtdparts string is greater than console 13272e192b24SSimon Glass * printbuffer. Use puts() to prevent system crashes. 13282e192b24SSimon Glass */ 13292e192b24SSimon Glass puts("mtdparts: "); 13302e192b24SSimon Glass puts(mtdparts_default ? mtdparts_default : "none"); 13312e192b24SSimon Glass puts("\n"); 13322e192b24SSimon Glass } 13332e192b24SSimon Glass 13342e192b24SSimon Glass /** 13352e192b24SSimon Glass * Given partition identifier in form of <dev_type><dev_num>,<part_num> find 13362e192b24SSimon Glass * corresponding device and verify partition number. 13372e192b24SSimon Glass * 13382e192b24SSimon Glass * @param id string describing device and partition or partition name 13392e192b24SSimon Glass * @param dev pointer to the requested device (output) 13402e192b24SSimon Glass * @param part_num verified partition number (output) 13412e192b24SSimon Glass * @param part pointer to requested partition (output) 13422e192b24SSimon Glass * @return 0 on success, 1 otherwise 13432e192b24SSimon Glass */ 13442e192b24SSimon Glass int find_dev_and_part(const char *id, struct mtd_device **dev, 13452e192b24SSimon Glass u8 *part_num, struct part_info **part) 13462e192b24SSimon Glass { 13472e192b24SSimon Glass struct list_head *dentry, *pentry; 13482e192b24SSimon Glass u8 type, dnum, pnum; 13492e192b24SSimon Glass const char *p; 13502e192b24SSimon Glass 13512e192b24SSimon Glass debug("--- find_dev_and_part ---\nid = %s\n", id); 13522e192b24SSimon Glass 13532e192b24SSimon Glass list_for_each(dentry, &devices) { 13542e192b24SSimon Glass *part_num = 0; 13552e192b24SSimon Glass *dev = list_entry(dentry, struct mtd_device, link); 13562e192b24SSimon Glass list_for_each(pentry, &(*dev)->parts) { 13572e192b24SSimon Glass *part = list_entry(pentry, struct part_info, link); 13582e192b24SSimon Glass if (strcmp((*part)->name, id) == 0) 13592e192b24SSimon Glass return 0; 13602e192b24SSimon Glass (*part_num)++; 13612e192b24SSimon Glass } 13622e192b24SSimon Glass } 13632e192b24SSimon Glass 13642e192b24SSimon Glass p = id; 13652e192b24SSimon Glass *dev = NULL; 13662e192b24SSimon Glass *part = NULL; 13672e192b24SSimon Glass *part_num = 0; 13682e192b24SSimon Glass 13692e192b24SSimon Glass if (mtd_id_parse(p, &p, &type, &dnum) != 0) 13702e192b24SSimon Glass return 1; 13712e192b24SSimon Glass 13722e192b24SSimon Glass if ((*p++ != ',') || (*p == '\0')) { 13732e192b24SSimon Glass printf("no partition number specified\n"); 13742e192b24SSimon Glass return 1; 13752e192b24SSimon Glass } 13762e192b24SSimon Glass pnum = simple_strtoul(p, (char **)&p, 0); 13772e192b24SSimon Glass if (*p != '\0') { 13782e192b24SSimon Glass printf("unexpected trailing character '%c'\n", *p); 13792e192b24SSimon Glass return 1; 13802e192b24SSimon Glass } 13812e192b24SSimon Glass 13822e192b24SSimon Glass if ((*dev = device_find(type, dnum)) == NULL) { 13832e192b24SSimon Glass printf("no such device %s%d\n", MTD_DEV_TYPE(type), dnum); 13842e192b24SSimon Glass return 1; 13852e192b24SSimon Glass } 13862e192b24SSimon Glass 13872e192b24SSimon Glass if ((*part = mtd_part_info(*dev, pnum)) == NULL) { 13882e192b24SSimon Glass printf("no such partition\n"); 13892e192b24SSimon Glass *dev = NULL; 13902e192b24SSimon Glass return 1; 13912e192b24SSimon Glass } 13922e192b24SSimon Glass 13932e192b24SSimon Glass *part_num = pnum; 13942e192b24SSimon Glass 13952e192b24SSimon Glass return 0; 13962e192b24SSimon Glass } 13972e192b24SSimon Glass 13982e192b24SSimon Glass /** 13992e192b24SSimon Glass * Find and delete partition. For partition id format see find_dev_and_part(). 14002e192b24SSimon Glass * 14012e192b24SSimon Glass * @param id string describing device and partition 14022e192b24SSimon Glass * @return 0 on success, 1 otherwise 14032e192b24SSimon Glass */ 14042e192b24SSimon Glass static int delete_partition(const char *id) 14052e192b24SSimon Glass { 14062e192b24SSimon Glass u8 pnum; 14072e192b24SSimon Glass struct mtd_device *dev; 14082e192b24SSimon Glass struct part_info *part; 14092e192b24SSimon Glass 14102e192b24SSimon Glass if (find_dev_and_part(id, &dev, &pnum, &part) == 0) { 14112e192b24SSimon Glass 14122e192b24SSimon Glass debug("delete_partition: device = %s%d, partition %d = (%s) 0x%08llx@0x%08llx\n", 14132e192b24SSimon Glass MTD_DEV_TYPE(dev->id->type), dev->id->num, pnum, 14142e192b24SSimon Glass part->name, part->size, part->offset); 14152e192b24SSimon Glass 14162e192b24SSimon Glass if (part_del(dev, part) != 0) 14172e192b24SSimon Glass return 1; 14182e192b24SSimon Glass 14192e192b24SSimon Glass if (generate_mtdparts_save(last_parts, MTDPARTS_MAXLEN) != 0) { 14202e192b24SSimon Glass printf("generated mtdparts too long, resetting to null\n"); 14212e192b24SSimon Glass return 1; 14222e192b24SSimon Glass } 14232e192b24SSimon Glass return 0; 14242e192b24SSimon Glass } 14252e192b24SSimon Glass 14262e192b24SSimon Glass printf("partition %s not found\n", id); 14272e192b24SSimon Glass return 1; 14282e192b24SSimon Glass } 14292e192b24SSimon Glass 14302e192b24SSimon Glass #if defined(CONFIG_CMD_MTDPARTS_SPREAD) 14312e192b24SSimon Glass /** 14322e192b24SSimon Glass * Increase the size of the given partition so that it's net size is at least 14332e192b24SSimon Glass * as large as the size member and such that the next partition would start on a 14342e192b24SSimon Glass * good block if it were adjacent to this partition. 14352e192b24SSimon Glass * 14362e192b24SSimon Glass * @param mtd the mtd device 14372e192b24SSimon Glass * @param part the partition 14382e192b24SSimon Glass * @param next_offset pointer to the offset of the next partition after this 14392e192b24SSimon Glass * partition's size has been modified (output) 14402e192b24SSimon Glass */ 14412e192b24SSimon Glass static void spread_partition(struct mtd_info *mtd, struct part_info *part, 14422e192b24SSimon Glass uint64_t *next_offset) 14432e192b24SSimon Glass { 14442e192b24SSimon Glass uint64_t net_size, padding_size = 0; 14452e192b24SSimon Glass int truncated; 14462e192b24SSimon Glass 14472e192b24SSimon Glass mtd_get_len_incl_bad(mtd, part->offset, part->size, &net_size, 14482e192b24SSimon Glass &truncated); 14492e192b24SSimon Glass 14502e192b24SSimon Glass /* 14512e192b24SSimon Glass * Absorb bad blocks immediately following this 14522e192b24SSimon Glass * partition also into the partition, such that 14532e192b24SSimon Glass * the next partition starts with a good block. 14542e192b24SSimon Glass */ 14552e192b24SSimon Glass if (!truncated) { 14562e192b24SSimon Glass mtd_get_len_incl_bad(mtd, part->offset + net_size, 14572e192b24SSimon Glass mtd->erasesize, &padding_size, &truncated); 14582e192b24SSimon Glass if (truncated) 14592e192b24SSimon Glass padding_size = 0; 14602e192b24SSimon Glass else 14612e192b24SSimon Glass padding_size -= mtd->erasesize; 14622e192b24SSimon Glass } 14632e192b24SSimon Glass 14642e192b24SSimon Glass if (truncated) { 14652e192b24SSimon Glass printf("truncated partition %s to %lld bytes\n", part->name, 14662e192b24SSimon Glass (uint64_t) net_size + padding_size); 14672e192b24SSimon Glass } 14682e192b24SSimon Glass 14692e192b24SSimon Glass part->size = net_size + padding_size; 14702e192b24SSimon Glass *next_offset = part->offset + part->size; 14712e192b24SSimon Glass } 14722e192b24SSimon Glass 14732e192b24SSimon Glass /** 14742e192b24SSimon Glass * Adjust all of the partition sizes, such that all partitions are at least 14752e192b24SSimon Glass * as big as their mtdparts environment variable sizes and they each start 14762e192b24SSimon Glass * on a good block. 14772e192b24SSimon Glass * 14782e192b24SSimon Glass * @return 0 on success, 1 otherwise 14792e192b24SSimon Glass */ 14802e192b24SSimon Glass static int spread_partitions(void) 14812e192b24SSimon Glass { 14822e192b24SSimon Glass struct list_head *dentry, *pentry; 14832e192b24SSimon Glass struct mtd_device *dev; 14842e192b24SSimon Glass struct part_info *part; 14852e192b24SSimon Glass struct mtd_info *mtd; 14862e192b24SSimon Glass int part_num; 14872e192b24SSimon Glass uint64_t cur_offs; 14882e192b24SSimon Glass 14892e192b24SSimon Glass list_for_each(dentry, &devices) { 14902e192b24SSimon Glass dev = list_entry(dentry, struct mtd_device, link); 14912e192b24SSimon Glass 14922e192b24SSimon Glass if (get_mtd_info(dev->id->type, dev->id->num, &mtd)) 14932e192b24SSimon Glass return 1; 14942e192b24SSimon Glass 14952e192b24SSimon Glass part_num = 0; 14962e192b24SSimon Glass cur_offs = 0; 14972e192b24SSimon Glass list_for_each(pentry, &dev->parts) { 14982e192b24SSimon Glass part = list_entry(pentry, struct part_info, link); 14992e192b24SSimon Glass 15002e192b24SSimon Glass debug("spread_partitions: device = %s%d, partition %d =" 150159441ac3SSteve Rae " (%s) 0x%08llx@0x%08llx\n", 15022e192b24SSimon Glass MTD_DEV_TYPE(dev->id->type), dev->id->num, 15032e192b24SSimon Glass part_num, part->name, part->size, 15042e192b24SSimon Glass part->offset); 15052e192b24SSimon Glass 15062e192b24SSimon Glass if (cur_offs > part->offset) 15072e192b24SSimon Glass part->offset = cur_offs; 15082e192b24SSimon Glass 15092e192b24SSimon Glass spread_partition(mtd, part, &cur_offs); 15102e192b24SSimon Glass 15112e192b24SSimon Glass part_num++; 15122e192b24SSimon Glass } 15132e192b24SSimon Glass } 15142e192b24SSimon Glass 15152e192b24SSimon Glass index_partitions(); 15162e192b24SSimon Glass 15172e192b24SSimon Glass if (generate_mtdparts_save(last_parts, MTDPARTS_MAXLEN) != 0) { 15182e192b24SSimon Glass printf("generated mtdparts too long, resetting to null\n"); 15192e192b24SSimon Glass return 1; 15202e192b24SSimon Glass } 15212e192b24SSimon Glass return 0; 15222e192b24SSimon Glass } 15232e192b24SSimon Glass #endif /* CONFIG_CMD_MTDPARTS_SPREAD */ 15242e192b24SSimon Glass 15252e192b24SSimon Glass /** 15261c2a262aSLadislav Michl * The mtdparts variable tends to be long. If we need to access it 15271c2a262aSLadislav Michl * before the env is relocated, then we need to use our own stack 15281c2a262aSLadislav Michl * buffer. gd->env_buf will be too small. 15291c2a262aSLadislav Michl * 15301c2a262aSLadislav Michl * @param buf temporary buffer pointer MTDPARTS_MAXLEN long 15311c2a262aSLadislav Michl * @return mtdparts variable string, NULL if not found 15321c2a262aSLadislav Michl */ 1533723806ccSSimon Glass static const char *env_get_mtdparts(char *buf) 15341c2a262aSLadislav Michl { 15351c2a262aSLadislav Michl if (gd->flags & GD_FLG_ENV_READY) 153600caae6dSSimon Glass return env_get("mtdparts"); 153700caae6dSSimon Glass if (env_get_f("mtdparts", buf, MTDPARTS_MAXLEN) != -1) 15381c2a262aSLadislav Michl return buf; 15391c2a262aSLadislav Michl return NULL; 15401c2a262aSLadislav Michl } 15411c2a262aSLadislav Michl 15421c2a262aSLadislav Michl /** 15432e192b24SSimon Glass * Accept character string describing mtd partitions and call device_parse() 15442e192b24SSimon Glass * for each entry. Add created devices to the global devices list. 15452e192b24SSimon Glass * 15462e192b24SSimon Glass * @param mtdparts string specifing mtd partitions 15472e192b24SSimon Glass * @return 0 on success, 1 otherwise 15482e192b24SSimon Glass */ 15492e192b24SSimon Glass static int parse_mtdparts(const char *const mtdparts) 15502e192b24SSimon Glass { 155106a040a3SLadislav Michl const char *p; 15522e192b24SSimon Glass struct mtd_device *dev; 15532e192b24SSimon Glass int err = 1; 15542e192b24SSimon Glass char tmp_parts[MTDPARTS_MAXLEN]; 15552e192b24SSimon Glass 15561aca4d5aSLothar Waßmann debug("\n---parse_mtdparts---\nmtdparts = %s\n\n", mtdparts); 15572e192b24SSimon Glass 15582e192b24SSimon Glass /* delete all devices and partitions */ 15592e192b24SSimon Glass if (mtd_devices_init() != 0) { 15602e192b24SSimon Glass printf("could not initialise device list\n"); 15612e192b24SSimon Glass return err; 15622e192b24SSimon Glass } 15632e192b24SSimon Glass 15642e192b24SSimon Glass /* re-read 'mtdparts' variable, mtd_devices_init may be updating env */ 1565723806ccSSimon Glass p = env_get_mtdparts(tmp_parts); 156606a040a3SLadislav Michl if (!p) 156706a040a3SLadislav Michl p = mtdparts; 156806a040a3SLadislav Michl 15692e192b24SSimon Glass if (strncmp(p, "mtdparts=", 9) != 0) { 15702e192b24SSimon Glass printf("mtdparts variable doesn't start with 'mtdparts='\n"); 15712e192b24SSimon Glass return err; 15722e192b24SSimon Glass } 15732e192b24SSimon Glass p += 9; 15742e192b24SSimon Glass 157506a040a3SLadislav Michl while (*p != '\0') { 15762e192b24SSimon Glass err = 1; 15772e192b24SSimon Glass if ((device_parse(p, &p, &dev) != 0) || (!dev)) 15782e192b24SSimon Glass break; 15792e192b24SSimon Glass 15802e192b24SSimon Glass debug("+ device: %s\t%d\t%s\n", MTD_DEV_TYPE(dev->id->type), 15812e192b24SSimon Glass dev->id->num, dev->id->mtd_id); 15822e192b24SSimon Glass 15832e192b24SSimon Glass /* check if parsed device is already on the list */ 15842e192b24SSimon Glass if (device_find(dev->id->type, dev->id->num) != NULL) { 15852e192b24SSimon Glass printf("device %s%d redefined, please correct mtdparts variable\n", 15862e192b24SSimon Glass MTD_DEV_TYPE(dev->id->type), dev->id->num); 15872e192b24SSimon Glass break; 15882e192b24SSimon Glass } 15892e192b24SSimon Glass 15902e192b24SSimon Glass list_add_tail(&dev->link, &devices); 15912e192b24SSimon Glass err = 0; 15922e192b24SSimon Glass } 159354f1792cSTom Rini if (err == 1) { 159454f1792cSTom Rini free(dev); 15952e192b24SSimon Glass device_delall(&devices); 159654f1792cSTom Rini } 15972e192b24SSimon Glass 159806a040a3SLadislav Michl return err; 15992e192b24SSimon Glass } 16002e192b24SSimon Glass 16012e192b24SSimon Glass /** 16022e192b24SSimon Glass * Parse provided string describing mtdids mapping (see file header for mtdids 16032e192b24SSimon Glass * variable format). Allocate memory for each entry and add all found entries 16042e192b24SSimon Glass * to the global mtdids list. 16052e192b24SSimon Glass * 16062e192b24SSimon Glass * @param ids mapping string 16072e192b24SSimon Glass * @return 0 on success, 1 otherwise 16082e192b24SSimon Glass */ 16092e192b24SSimon Glass static int parse_mtdids(const char *const ids) 16102e192b24SSimon Glass { 16112e192b24SSimon Glass const char *p = ids; 16122e192b24SSimon Glass const char *mtd_id; 16132e192b24SSimon Glass int mtd_id_len; 16142e192b24SSimon Glass struct mtdids *id; 16152e192b24SSimon Glass struct list_head *entry, *n; 16162e192b24SSimon Glass struct mtdids *id_tmp; 16172e192b24SSimon Glass u8 type, num; 16182e192b24SSimon Glass u64 size; 16192e192b24SSimon Glass int ret = 1; 16202e192b24SSimon Glass 16212e192b24SSimon Glass debug("\n---parse_mtdids---\nmtdids = %s\n\n", ids); 16222e192b24SSimon Glass 16232e192b24SSimon Glass /* clean global mtdids list */ 16242e192b24SSimon Glass list_for_each_safe(entry, n, &mtdids) { 16252e192b24SSimon Glass id_tmp = list_entry(entry, struct mtdids, link); 16262e192b24SSimon Glass debug("mtdids del: %d %d\n", id_tmp->type, id_tmp->num); 16272e192b24SSimon Glass list_del(entry); 16282e192b24SSimon Glass free(id_tmp); 16292e192b24SSimon Glass } 16302e192b24SSimon Glass last_ids[0] = '\0'; 16312e192b24SSimon Glass INIT_LIST_HEAD(&mtdids); 16322e192b24SSimon Glass 16332e192b24SSimon Glass while(p && (*p != '\0')) { 16342e192b24SSimon Glass 16352e192b24SSimon Glass ret = 1; 16362e192b24SSimon Glass /* parse 'nor'|'nand'|'onenand'<dev-num> */ 16372e192b24SSimon Glass if (mtd_id_parse(p, &p, &type, &num) != 0) 16382e192b24SSimon Glass break; 16392e192b24SSimon Glass 16402e192b24SSimon Glass if (*p != '=') { 16412e192b24SSimon Glass printf("mtdids: incorrect <dev-num>\n"); 16422e192b24SSimon Glass break; 16432e192b24SSimon Glass } 16442e192b24SSimon Glass p++; 16452e192b24SSimon Glass 16462e192b24SSimon Glass /* check if requested device exists */ 16472e192b24SSimon Glass if (mtd_device_validate(type, num, &size) != 0) 16482e192b24SSimon Glass return 1; 16492e192b24SSimon Glass 16502e192b24SSimon Glass /* locate <mtd-id> */ 16512e192b24SSimon Glass mtd_id = p; 16522e192b24SSimon Glass if ((p = strchr(mtd_id, ',')) != NULL) { 16532e192b24SSimon Glass mtd_id_len = p - mtd_id + 1; 16542e192b24SSimon Glass p++; 16552e192b24SSimon Glass } else { 16562e192b24SSimon Glass mtd_id_len = strlen(mtd_id) + 1; 16572e192b24SSimon Glass } 16582e192b24SSimon Glass if (mtd_id_len == 0) { 16592e192b24SSimon Glass printf("mtdids: no <mtd-id> identifier\n"); 16602e192b24SSimon Glass break; 16612e192b24SSimon Glass } 16622e192b24SSimon Glass 16632e192b24SSimon Glass /* check if this id is already on the list */ 16642e192b24SSimon Glass int double_entry = 0; 16652e192b24SSimon Glass list_for_each(entry, &mtdids) { 16662e192b24SSimon Glass id_tmp = list_entry(entry, struct mtdids, link); 16672e192b24SSimon Glass if ((id_tmp->type == type) && (id_tmp->num == num)) { 16682e192b24SSimon Glass double_entry = 1; 16692e192b24SSimon Glass break; 16702e192b24SSimon Glass } 16712e192b24SSimon Glass } 16722e192b24SSimon Glass if (double_entry) { 16732e192b24SSimon Glass printf("device id %s%d redefined, please correct mtdids variable\n", 16742e192b24SSimon Glass MTD_DEV_TYPE(type), num); 16752e192b24SSimon Glass break; 16762e192b24SSimon Glass } 16772e192b24SSimon Glass 16782e192b24SSimon Glass /* allocate mtdids structure */ 16792e192b24SSimon Glass if (!(id = (struct mtdids *)malloc(sizeof(struct mtdids) + mtd_id_len))) { 16802e192b24SSimon Glass printf("out of memory\n"); 16812e192b24SSimon Glass break; 16822e192b24SSimon Glass } 16832e192b24SSimon Glass memset(id, 0, sizeof(struct mtdids) + mtd_id_len); 16842e192b24SSimon Glass id->num = num; 16852e192b24SSimon Glass id->type = type; 16862e192b24SSimon Glass id->size = size; 16872e192b24SSimon Glass id->mtd_id = (char *)(id + 1); 16882e192b24SSimon Glass strncpy(id->mtd_id, mtd_id, mtd_id_len - 1); 16892e192b24SSimon Glass id->mtd_id[mtd_id_len - 1] = '\0'; 16902e192b24SSimon Glass INIT_LIST_HEAD(&id->link); 16912e192b24SSimon Glass 16922e192b24SSimon Glass debug("+ id %s%d\t%16lld bytes\t%s\n", 16932e192b24SSimon Glass MTD_DEV_TYPE(id->type), id->num, 16942e192b24SSimon Glass id->size, id->mtd_id); 16952e192b24SSimon Glass 16962e192b24SSimon Glass list_add_tail(&id->link, &mtdids); 16972e192b24SSimon Glass ret = 0; 16982e192b24SSimon Glass } 16992e192b24SSimon Glass if (ret == 1) { 17002e192b24SSimon Glass /* clean mtdids list and free allocated memory */ 17012e192b24SSimon Glass list_for_each_safe(entry, n, &mtdids) { 17022e192b24SSimon Glass id_tmp = list_entry(entry, struct mtdids, link); 17032e192b24SSimon Glass list_del(entry); 17042e192b24SSimon Glass free(id_tmp); 17052e192b24SSimon Glass } 17062e192b24SSimon Glass return 1; 17072e192b24SSimon Glass } 17082e192b24SSimon Glass 17092e192b24SSimon Glass return 0; 17102e192b24SSimon Glass } 17112e192b24SSimon Glass 17121c2a262aSLadislav Michl 17132e192b24SSimon Glass /** 17142e192b24SSimon Glass * Parse and initialize global mtdids mapping and create global 17152e192b24SSimon Glass * device/partition list. 17162e192b24SSimon Glass * 17172e192b24SSimon Glass * @return 0 on success, 1 otherwise 17182e192b24SSimon Glass */ 17192e192b24SSimon Glass int mtdparts_init(void) 17202e192b24SSimon Glass { 17212e192b24SSimon Glass static int initialized = 0; 17222e192b24SSimon Glass const char *ids, *parts; 17232e192b24SSimon Glass const char *current_partition; 17242e192b24SSimon Glass int ids_changed; 1725bc028345STom Rini char tmp_ep[PARTITION_MAXLEN + 1]; 17262e192b24SSimon Glass char tmp_parts[MTDPARTS_MAXLEN]; 17272e192b24SSimon Glass 17282e192b24SSimon Glass debug("\n---mtdparts_init---\n"); 17292e192b24SSimon Glass if (!initialized) { 17302e192b24SSimon Glass INIT_LIST_HEAD(&mtdids); 17312e192b24SSimon Glass INIT_LIST_HEAD(&devices); 173254f1792cSTom Rini memset(last_ids, 0, sizeof(last_ids)); 173354f1792cSTom Rini memset(last_parts, 0, sizeof(last_parts)); 173454f1792cSTom Rini memset(last_partition, 0, sizeof(last_partition)); 1735af324436SLadislav Michl #if defined(CONFIG_SYS_MTDPARTS_RUNTIME) 1736af324436SLadislav Michl board_mtdparts_default(&mtdids_default, &mtdparts_default); 1737af324436SLadislav Michl #endif 1738f8f744a3SLadislav Michl use_defaults = 1; 17392e192b24SSimon Glass initialized = 1; 17402e192b24SSimon Glass } 17412e192b24SSimon Glass 17422e192b24SSimon Glass /* get variables */ 174300caae6dSSimon Glass ids = env_get("mtdids"); 1744723806ccSSimon Glass parts = env_get_mtdparts(tmp_parts); 174500caae6dSSimon Glass current_partition = env_get("partition"); 17462e192b24SSimon Glass 17472e192b24SSimon Glass /* save it for later parsing, cannot rely on current partition pointer 17482e192b24SSimon Glass * as 'partition' variable may be updated during init */ 1749bc028345STom Rini memset(tmp_parts, 0, sizeof(tmp_parts)); 17508b3cec7dSTom Rini memset(tmp_ep, 0, sizeof(tmp_ep)); 17512e192b24SSimon Glass if (current_partition) 17522e192b24SSimon Glass strncpy(tmp_ep, current_partition, PARTITION_MAXLEN); 17532e192b24SSimon Glass 17542e192b24SSimon Glass debug("last_ids : %s\n", last_ids); 17552e192b24SSimon Glass debug("env_ids : %s\n", ids); 17562e192b24SSimon Glass debug("last_parts: %s\n", last_parts); 17572e192b24SSimon Glass debug("env_parts : %s\n\n", parts); 17582e192b24SSimon Glass 17592e192b24SSimon Glass debug("last_partition : %s\n", last_partition); 17602e192b24SSimon Glass debug("env_partition : %s\n", current_partition); 17612e192b24SSimon Glass 17621cc0a9f4SRobert P. J. Day /* if mtdids variable is empty try to use defaults */ 17632e192b24SSimon Glass if (!ids) { 17642e192b24SSimon Glass if (mtdids_default) { 17652e192b24SSimon Glass debug("mtdids variable not defined, using default\n"); 17662e192b24SSimon Glass ids = mtdids_default; 1767382bee57SSimon Glass env_set("mtdids", (char *)ids); 17682e192b24SSimon Glass } else { 17692e192b24SSimon Glass printf("mtdids not defined, no default present\n"); 17702e192b24SSimon Glass return 1; 17712e192b24SSimon Glass } 17722e192b24SSimon Glass } 17732e192b24SSimon Glass if (strlen(ids) > MTDIDS_MAXLEN - 1) { 17742e192b24SSimon Glass printf("mtdids too long (> %d)\n", MTDIDS_MAXLEN); 17752e192b24SSimon Glass return 1; 17762e192b24SSimon Glass } 17772e192b24SSimon Glass 1778f8f744a3SLadislav Michl /* use defaults when mtdparts variable is not defined 1779f8f744a3SLadislav Michl * once mtdparts is saved environment, drop use_defaults flag */ 1780f8f744a3SLadislav Michl if (!parts) { 1781f8f744a3SLadislav Michl if (mtdparts_default && use_defaults) { 1782f8f744a3SLadislav Michl parts = mtdparts_default; 1783382bee57SSimon Glass if (env_set("mtdparts", (char *)parts) == 0) 1784f8f744a3SLadislav Michl use_defaults = 0; 1785f8f744a3SLadislav Michl } else 17862e192b24SSimon Glass printf("mtdparts variable not set, see 'help mtdparts'\n"); 1787f8f744a3SLadislav Michl } 17882e192b24SSimon Glass 17892e192b24SSimon Glass if (parts && (strlen(parts) > MTDPARTS_MAXLEN - 1)) { 17902e192b24SSimon Glass printf("mtdparts too long (> %d)\n", MTDPARTS_MAXLEN); 17912e192b24SSimon Glass return 1; 17922e192b24SSimon Glass } 17932e192b24SSimon Glass 17942e192b24SSimon Glass /* check if we have already parsed those mtdids */ 17952e192b24SSimon Glass if ((last_ids[0] != '\0') && (strcmp(last_ids, ids) == 0)) { 17962e192b24SSimon Glass ids_changed = 0; 17972e192b24SSimon Glass } else { 17982e192b24SSimon Glass ids_changed = 1; 17992e192b24SSimon Glass 18002e192b24SSimon Glass if (parse_mtdids(ids) != 0) { 18012e192b24SSimon Glass mtd_devices_init(); 18022e192b24SSimon Glass return 1; 18032e192b24SSimon Glass } 18042e192b24SSimon Glass 18052e192b24SSimon Glass /* ok it's good, save new ids */ 18062e192b24SSimon Glass strncpy(last_ids, ids, MTDIDS_MAXLEN); 18072e192b24SSimon Glass } 18082e192b24SSimon Glass 18092e192b24SSimon Glass /* parse partitions if either mtdparts or mtdids were updated */ 18102e192b24SSimon Glass if (parts && ((last_parts[0] == '\0') || ((strcmp(last_parts, parts) != 0)) || ids_changed)) { 18112e192b24SSimon Glass if (parse_mtdparts(parts) != 0) 18122e192b24SSimon Glass return 1; 18132e192b24SSimon Glass 18142e192b24SSimon Glass if (list_empty(&devices)) { 18152e192b24SSimon Glass printf("mtdparts_init: no valid partitions\n"); 18162e192b24SSimon Glass return 1; 18172e192b24SSimon Glass } 18182e192b24SSimon Glass 18192e192b24SSimon Glass /* ok it's good, save new parts */ 18202e192b24SSimon Glass strncpy(last_parts, parts, MTDPARTS_MAXLEN); 18212e192b24SSimon Glass 18222e192b24SSimon Glass /* reset first partition from first dev from the list as current */ 18232e192b24SSimon Glass current_mtd_dev = list_entry(devices.next, struct mtd_device, link); 18242e192b24SSimon Glass current_mtd_partnum = 0; 18252e192b24SSimon Glass current_save(); 18262e192b24SSimon Glass 18272e192b24SSimon Glass debug("mtdparts_init: current_mtd_dev = %s%d, current_mtd_partnum = %d\n", 18282e192b24SSimon Glass MTD_DEV_TYPE(current_mtd_dev->id->type), 18292e192b24SSimon Glass current_mtd_dev->id->num, current_mtd_partnum); 18302e192b24SSimon Glass } 18312e192b24SSimon Glass 18322e192b24SSimon Glass /* mtdparts variable was reset to NULL, delete all devices/partitions */ 18332e192b24SSimon Glass if (!parts && (last_parts[0] != '\0')) 18342e192b24SSimon Glass return mtd_devices_init(); 18352e192b24SSimon Glass 18362e192b24SSimon Glass /* do not process current partition if mtdparts variable is null */ 18372e192b24SSimon Glass if (!parts) 18382e192b24SSimon Glass return 0; 18392e192b24SSimon Glass 18402e192b24SSimon Glass /* is current partition set in environment? if so, use it */ 18412e192b24SSimon Glass if ((tmp_ep[0] != '\0') && (strcmp(tmp_ep, last_partition) != 0)) { 18422e192b24SSimon Glass struct part_info *p; 18432e192b24SSimon Glass struct mtd_device *cdev; 18442e192b24SSimon Glass u8 pnum; 18452e192b24SSimon Glass 18462e192b24SSimon Glass debug("--- getting current partition: %s\n", tmp_ep); 18472e192b24SSimon Glass 18482e192b24SSimon Glass if (find_dev_and_part(tmp_ep, &cdev, &pnum, &p) == 0) { 18492e192b24SSimon Glass current_mtd_dev = cdev; 18502e192b24SSimon Glass current_mtd_partnum = pnum; 18512e192b24SSimon Glass current_save(); 18522e192b24SSimon Glass } 185300caae6dSSimon Glass } else if (env_get("partition") == NULL) { 18542e192b24SSimon Glass debug("no partition variable set, setting...\n"); 18552e192b24SSimon Glass current_save(); 18562e192b24SSimon Glass } 18572e192b24SSimon Glass 18582e192b24SSimon Glass return 0; 18592e192b24SSimon Glass } 18602e192b24SSimon Glass 18612e192b24SSimon Glass /** 18622e192b24SSimon Glass * Return pointer to the partition of a requested number from a requested 18632e192b24SSimon Glass * device. 18642e192b24SSimon Glass * 18652e192b24SSimon Glass * @param dev device that is to be searched for a partition 18662e192b24SSimon Glass * @param part_num requested partition number 18672e192b24SSimon Glass * @return pointer to the part_info, NULL otherwise 18682e192b24SSimon Glass */ 18692e192b24SSimon Glass static struct part_info* mtd_part_info(struct mtd_device *dev, unsigned int part_num) 18702e192b24SSimon Glass { 18712e192b24SSimon Glass struct list_head *entry; 18722e192b24SSimon Glass struct part_info *part; 18732e192b24SSimon Glass int num; 18742e192b24SSimon Glass 18752e192b24SSimon Glass if (!dev) 18762e192b24SSimon Glass return NULL; 18772e192b24SSimon Glass 18782e192b24SSimon Glass debug("\n--- mtd_part_info: partition number %d for device %s%d (%s)\n", 18792e192b24SSimon Glass part_num, MTD_DEV_TYPE(dev->id->type), 18802e192b24SSimon Glass dev->id->num, dev->id->mtd_id); 18812e192b24SSimon Glass 18822e192b24SSimon Glass if (part_num >= dev->num_parts) { 18832e192b24SSimon Glass printf("invalid partition number %d for device %s%d (%s)\n", 18842e192b24SSimon Glass part_num, MTD_DEV_TYPE(dev->id->type), 18852e192b24SSimon Glass dev->id->num, dev->id->mtd_id); 18862e192b24SSimon Glass return NULL; 18872e192b24SSimon Glass } 18882e192b24SSimon Glass 18892e192b24SSimon Glass /* locate partition number, return it */ 18902e192b24SSimon Glass num = 0; 18912e192b24SSimon Glass list_for_each(entry, &dev->parts) { 18922e192b24SSimon Glass part = list_entry(entry, struct part_info, link); 18932e192b24SSimon Glass 18942e192b24SSimon Glass if (part_num == num++) { 18952e192b24SSimon Glass return part; 18962e192b24SSimon Glass } 18972e192b24SSimon Glass } 18982e192b24SSimon Glass 18992e192b24SSimon Glass return NULL; 19002e192b24SSimon Glass } 19012e192b24SSimon Glass 19022e192b24SSimon Glass /***************************************************/ 1903a187559eSBin Meng /* U-Boot commands */ 19042e192b24SSimon Glass /***************************************************/ 19052e192b24SSimon Glass /* command line only */ 19062e192b24SSimon Glass /** 19072e192b24SSimon Glass * Routine implementing u-boot chpart command. Sets new current partition based 19082e192b24SSimon Glass * on the user supplied partition id. For partition id format see find_dev_and_part(). 19092e192b24SSimon Glass * 19102e192b24SSimon Glass * @param cmdtp command internal data 19112e192b24SSimon Glass * @param flag command flag 19122e192b24SSimon Glass * @param argc number of arguments supplied to the command 19132e192b24SSimon Glass * @param argv arguments list 19142e192b24SSimon Glass * @return 0 on success, 1 otherwise 19152e192b24SSimon Glass */ 19162e192b24SSimon Glass static int do_chpart(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 19172e192b24SSimon Glass { 19182e192b24SSimon Glass /* command line only */ 19192e192b24SSimon Glass struct mtd_device *dev; 19202e192b24SSimon Glass struct part_info *part; 19212e192b24SSimon Glass u8 pnum; 19222e192b24SSimon Glass 19232e192b24SSimon Glass if (mtdparts_init() !=0) 19242e192b24SSimon Glass return 1; 19252e192b24SSimon Glass 19262e192b24SSimon Glass if (argc < 2) { 19272e192b24SSimon Glass printf("no partition id specified\n"); 19282e192b24SSimon Glass return 1; 19292e192b24SSimon Glass } 19302e192b24SSimon Glass 19312e192b24SSimon Glass if (find_dev_and_part(argv[1], &dev, &pnum, &part) != 0) 19322e192b24SSimon Glass return 1; 19332e192b24SSimon Glass 19342e192b24SSimon Glass current_mtd_dev = dev; 19352e192b24SSimon Glass current_mtd_partnum = pnum; 19362e192b24SSimon Glass current_save(); 19372e192b24SSimon Glass 19382e192b24SSimon Glass printf("partition changed to %s%d,%d\n", 19392e192b24SSimon Glass MTD_DEV_TYPE(dev->id->type), dev->id->num, pnum); 19402e192b24SSimon Glass 19412e192b24SSimon Glass return 0; 19422e192b24SSimon Glass } 19432e192b24SSimon Glass 19442e192b24SSimon Glass /** 19452e192b24SSimon Glass * Routine implementing u-boot mtdparts command. Initialize/update default global 19462e192b24SSimon Glass * partition list and process user partition request (list, add, del). 19472e192b24SSimon Glass * 19482e192b24SSimon Glass * @param cmdtp command internal data 19492e192b24SSimon Glass * @param flag command flag 19502e192b24SSimon Glass * @param argc number of arguments supplied to the command 19512e192b24SSimon Glass * @param argv arguments list 19522e192b24SSimon Glass * @return 0 on success, 1 otherwise 19532e192b24SSimon Glass */ 19542e192b24SSimon Glass static int do_mtdparts(cmd_tbl_t *cmdtp, int flag, int argc, 19552e192b24SSimon Glass char * const argv[]) 19562e192b24SSimon Glass { 19572e192b24SSimon Glass if (argc == 2) { 19582e192b24SSimon Glass if (strcmp(argv[1], "default") == 0) { 1959382bee57SSimon Glass env_set("mtdids", NULL); 1960382bee57SSimon Glass env_set("mtdparts", NULL); 1961382bee57SSimon Glass env_set("partition", NULL); 1962f8f744a3SLadislav Michl use_defaults = 1; 19632e192b24SSimon Glass 19642e192b24SSimon Glass mtdparts_init(); 19652e192b24SSimon Glass return 0; 19662e192b24SSimon Glass } else if (strcmp(argv[1], "delall") == 0) { 19672e192b24SSimon Glass /* this may be the first run, initialize lists if needed */ 19682e192b24SSimon Glass mtdparts_init(); 19692e192b24SSimon Glass 1970382bee57SSimon Glass env_set("mtdparts", NULL); 19712e192b24SSimon Glass 19722e192b24SSimon Glass /* mtd_devices_init() calls current_save() */ 19732e192b24SSimon Glass return mtd_devices_init(); 19742e192b24SSimon Glass } 19752e192b24SSimon Glass } 19762e192b24SSimon Glass 19772e192b24SSimon Glass /* make sure we are in sync with env variables */ 19782e192b24SSimon Glass if (mtdparts_init() != 0) 19792e192b24SSimon Glass return 1; 19802e192b24SSimon Glass 19812e192b24SSimon Glass if (argc == 1) { 19822e192b24SSimon Glass list_partitions(); 19832e192b24SSimon Glass return 0; 19842e192b24SSimon Glass } 19852e192b24SSimon Glass 19862e192b24SSimon Glass /* mtdparts add <mtd-dev> <size>[@<offset>] <name> [ro] */ 19872e192b24SSimon Glass if (((argc == 5) || (argc == 6)) && (strncmp(argv[1], "add", 3) == 0)) { 19882e192b24SSimon Glass #define PART_ADD_DESC_MAXLEN 64 19892e192b24SSimon Glass char tmpbuf[PART_ADD_DESC_MAXLEN]; 19902e192b24SSimon Glass #if defined(CONFIG_CMD_MTDPARTS_SPREAD) 19912e192b24SSimon Glass struct mtd_info *mtd; 19922e192b24SSimon Glass uint64_t next_offset; 19932e192b24SSimon Glass #endif 19942e192b24SSimon Glass u8 type, num, len; 19952e192b24SSimon Glass struct mtd_device *dev; 19962e192b24SSimon Glass struct mtd_device *dev_tmp; 19972e192b24SSimon Glass struct mtdids *id; 19982e192b24SSimon Glass struct part_info *p; 19992e192b24SSimon Glass 20002e192b24SSimon Glass if (mtd_id_parse(argv[2], NULL, &type, &num) != 0) 20012e192b24SSimon Glass return 1; 20022e192b24SSimon Glass 20032e192b24SSimon Glass if ((id = id_find(type, num)) == NULL) { 20042e192b24SSimon Glass printf("no such device %s defined in mtdids variable\n", argv[2]); 20052e192b24SSimon Glass return 1; 20062e192b24SSimon Glass } 20072e192b24SSimon Glass 20082e192b24SSimon Glass len = strlen(id->mtd_id) + 1; /* 'mtd_id:' */ 20092e192b24SSimon Glass len += strlen(argv[3]); /* size@offset */ 20102e192b24SSimon Glass len += strlen(argv[4]) + 2; /* '(' name ')' */ 20112e192b24SSimon Glass if (argv[5] && (strlen(argv[5]) == 2)) 20122e192b24SSimon Glass len += 2; /* 'ro' */ 20132e192b24SSimon Glass 20142e192b24SSimon Glass if (len >= PART_ADD_DESC_MAXLEN) { 20152e192b24SSimon Glass printf("too long partition description\n"); 20162e192b24SSimon Glass return 1; 20172e192b24SSimon Glass } 20182e192b24SSimon Glass sprintf(tmpbuf, "%s:%s(%s)%s", 20192e192b24SSimon Glass id->mtd_id, argv[3], argv[4], argv[5] ? argv[5] : ""); 20202e192b24SSimon Glass debug("add tmpbuf: %s\n", tmpbuf); 20212e192b24SSimon Glass 20222e192b24SSimon Glass if ((device_parse(tmpbuf, NULL, &dev) != 0) || (!dev)) 20232e192b24SSimon Glass return 1; 20242e192b24SSimon Glass 20252e192b24SSimon Glass debug("+ %s\t%d\t%s\n", MTD_DEV_TYPE(dev->id->type), 20262e192b24SSimon Glass dev->id->num, dev->id->mtd_id); 20272e192b24SSimon Glass 20282e192b24SSimon Glass p = list_entry(dev->parts.next, struct part_info, link); 20292e192b24SSimon Glass 20302e192b24SSimon Glass #if defined(CONFIG_CMD_MTDPARTS_SPREAD) 20312e192b24SSimon Glass if (get_mtd_info(dev->id->type, dev->id->num, &mtd)) 20322e192b24SSimon Glass return 1; 20332e192b24SSimon Glass 20342e192b24SSimon Glass if (!strcmp(&argv[1][3], ".spread")) { 20352e192b24SSimon Glass spread_partition(mtd, p, &next_offset); 203659441ac3SSteve Rae debug("increased %s to %llu bytes\n", p->name, p->size); 20372e192b24SSimon Glass } 20382e192b24SSimon Glass #endif 20392e192b24SSimon Glass 20402e192b24SSimon Glass dev_tmp = device_find(dev->id->type, dev->id->num); 20412e192b24SSimon Glass if (dev_tmp == NULL) { 20422e192b24SSimon Glass device_add(dev); 20432e192b24SSimon Glass } else if (part_add(dev_tmp, p) != 0) { 20442e192b24SSimon Glass /* merge new partition with existing ones*/ 20452e192b24SSimon Glass device_del(dev); 20462e192b24SSimon Glass return 1; 20472e192b24SSimon Glass } 20482e192b24SSimon Glass 20492e192b24SSimon Glass if (generate_mtdparts_save(last_parts, MTDPARTS_MAXLEN) != 0) { 20502e192b24SSimon Glass printf("generated mtdparts too long, resetting to null\n"); 20512e192b24SSimon Glass return 1; 20522e192b24SSimon Glass } 20532e192b24SSimon Glass 20542e192b24SSimon Glass return 0; 20552e192b24SSimon Glass } 20562e192b24SSimon Glass 20572e192b24SSimon Glass /* mtdparts del part-id */ 20582e192b24SSimon Glass if ((argc == 3) && (strcmp(argv[1], "del") == 0)) { 20592e192b24SSimon Glass debug("del: part-id = %s\n", argv[2]); 20602e192b24SSimon Glass 20612e192b24SSimon Glass return delete_partition(argv[2]); 20622e192b24SSimon Glass } 20632e192b24SSimon Glass 20642e192b24SSimon Glass #if defined(CONFIG_CMD_MTDPARTS_SPREAD) 20652e192b24SSimon Glass if ((argc == 2) && (strcmp(argv[1], "spread") == 0)) 20662e192b24SSimon Glass return spread_partitions(); 20672e192b24SSimon Glass #endif /* CONFIG_CMD_MTDPARTS_SPREAD */ 20682e192b24SSimon Glass 20692e192b24SSimon Glass return CMD_RET_USAGE; 20702e192b24SSimon Glass } 20712e192b24SSimon Glass 20722e192b24SSimon Glass /***************************************************/ 20732e192b24SSimon Glass U_BOOT_CMD( 20742e192b24SSimon Glass chpart, 2, 0, do_chpart, 20752e192b24SSimon Glass "change active partition", 20762e192b24SSimon Glass "part-id\n" 20772e192b24SSimon Glass " - change active partition (e.g. part-id = nand0,1)" 20782e192b24SSimon Glass ); 20792e192b24SSimon Glass 20802e192b24SSimon Glass #ifdef CONFIG_SYS_LONGHELP 20812e192b24SSimon Glass static char mtdparts_help_text[] = 20822e192b24SSimon Glass "\n" 20832e192b24SSimon Glass " - list partition table\n" 20842e192b24SSimon Glass "mtdparts delall\n" 20852e192b24SSimon Glass " - delete all partitions\n" 20862e192b24SSimon Glass "mtdparts del part-id\n" 20872e192b24SSimon Glass " - delete partition (e.g. part-id = nand0,1)\n" 20882e192b24SSimon Glass "mtdparts add <mtd-dev> <size>[@<offset>] [<name>] [ro]\n" 20892e192b24SSimon Glass " - add partition\n" 20902e192b24SSimon Glass #if defined(CONFIG_CMD_MTDPARTS_SPREAD) 20912e192b24SSimon Glass "mtdparts add.spread <mtd-dev> <size>[@<offset>] [<name>] [ro]\n" 20922e192b24SSimon Glass " - add partition, padding size by skipping bad blocks\n" 20932e192b24SSimon Glass #endif 20942e192b24SSimon Glass "mtdparts default\n" 20952e192b24SSimon Glass " - reset partition table to defaults\n" 20962e192b24SSimon Glass #if defined(CONFIG_CMD_MTDPARTS_SPREAD) 20972e192b24SSimon Glass "mtdparts spread\n" 20982e192b24SSimon Glass " - adjust the sizes of the partitions so they are\n" 20992e192b24SSimon Glass " at least as big as the mtdparts variable specifies\n" 21002e192b24SSimon Glass " and they each start on a good block\n\n" 21012e192b24SSimon Glass #else 21022e192b24SSimon Glass "\n" 21032e192b24SSimon Glass #endif /* CONFIG_CMD_MTDPARTS_SPREAD */ 21042e192b24SSimon Glass "-----\n\n" 21052e192b24SSimon Glass "this command uses three environment variables:\n\n" 21062e192b24SSimon Glass "'partition' - keeps current partition identifier\n\n" 21072e192b24SSimon Glass "partition := <part-id>\n" 21082e192b24SSimon Glass "<part-id> := <dev-id>,part_num\n\n" 21092e192b24SSimon Glass "'mtdids' - linux kernel mtd device id <-> u-boot device id mapping\n\n" 21102e192b24SSimon Glass "mtdids=<idmap>[,<idmap>,...]\n\n" 21112e192b24SSimon Glass "<idmap> := <dev-id>=<mtd-id>\n" 21122e192b24SSimon Glass "<dev-id> := 'nand'|'nor'|'onenand'<dev-num>\n" 21132e192b24SSimon Glass "<dev-num> := mtd device number, 0...\n" 21142e192b24SSimon Glass "<mtd-id> := unique device tag used by linux kernel to find mtd device (mtd->name)\n\n" 21152e192b24SSimon Glass "'mtdparts' - partition list\n\n" 21162e192b24SSimon Glass "mtdparts=mtdparts=<mtd-def>[;<mtd-def>...]\n\n" 21172e192b24SSimon Glass "<mtd-def> := <mtd-id>:<part-def>[,<part-def>...]\n" 21182e192b24SSimon Glass "<mtd-id> := unique device tag used by linux kernel to find mtd device (mtd->name)\n" 21192e192b24SSimon Glass "<part-def> := <size>[@<offset>][<name>][<ro-flag>]\n" 21202e192b24SSimon Glass "<size> := standard linux memsize OR '-' to denote all remaining space\n" 21212e192b24SSimon Glass "<offset> := partition start offset within the device\n" 21222e192b24SSimon Glass "<name> := '(' NAME ')'\n" 21232e192b24SSimon Glass "<ro-flag> := when set to 'ro' makes partition read-only (not used, passed to kernel)"; 21242e192b24SSimon Glass #endif 21252e192b24SSimon Glass 21262e192b24SSimon Glass U_BOOT_CMD( 21272e192b24SSimon Glass mtdparts, 6, 0, do_mtdparts, 21282e192b24SSimon Glass "define flash/nand partitions", mtdparts_help_text 21292e192b24SSimon Glass ); 21302e192b24SSimon Glass /***************************************************/ 2131