drivers/mtd/mtd_uboot.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2014
   4  * Heiko Schocher, DENX Software Engineering, hs@denx.de.
   5  */
   6 #include <common.h>
   7 #include <dm/device.h>
   8 #include <dm/uclass-internal.h>
   9 #include <jffs2/jffs2.h> /* LEGACY */
  10 #include <linux/mtd/mtd.h>
  11 #include <linux/mtd/partitions.h>
  12 #include <mtd.h>
  13
  14 #define MTD_NAME_MAX_LEN 20
  15
  16
  17 /**
  18  * mtd_search_alternate_name - Search an alternate name for @mtdname thanks to
  19  *                             the mtdids legacy environment variable.
  20  *
  21  * The mtdids string is a list of comma-separated 'dev_id=mtd_id' tupples.
  22  * Check if one of the mtd_id matches mtdname, in this case save dev_id in
  23  * altname.
  24  *
  25  * @mtdname: Current MTD device name
  26  * @altname: Alternate name to return
  27  * @max_len: Length of the alternate name buffer
  28  *
  29  * @return 0 on success, an error otherwise.
  30  */
  31 int mtd_search_alternate_name(const char *mtdname, char *altname,
  32                               unsigned int max_len)
  33 {
  34         const char *mtdids, *equal, *comma, *dev_id, *mtd_id;
  35         int dev_id_len, mtd_id_len;
  36
  37         mtdids = env_get("mtdids");
  38         if (!mtdids)
  39                 return -EINVAL;
  40
  41         do {
  42                 /* Find the '=' sign */
  43                 dev_id = mtdids;
  44                 equal = strchr(dev_id, '=');
  45                 if (!equal)
  46                         break;
  47                 dev_id_len = equal - mtdids;
  48                 mtd_id = equal + 1;
  49
  50                 /* Find the end of the tupple */
  51                 comma = strchr(mtdids, ',');
  52                 if (comma)
  53                         mtd_id_len = comma - mtd_id;
  54                 else
  55                         mtd_id_len = &mtdids[strlen(mtdids)] - mtd_id + 1;
  56
  57                 if (!dev_id_len || !mtd_id_len)
  58                         return -EINVAL;
  59
  60                 if (dev_id_len + 1 > max_len)
  61                         continue;
  62
  63                 /* Compare the name we search with the current mtd_id */
  64                 if (!strncmp(mtdname, mtd_id, mtd_id_len)) {
  65                         strncpy(altname, dev_id, dev_id_len);
  66                         altname[dev_id_len] = 0;
  67
  68                         return 0;
  69                 }
  70
  71                 /* Go to the next tupple */
  72                 mtdids = comma + 1;
  73         } while (comma);
  74
  75         return -EINVAL;
  76 }
  77
  78 #if IS_ENABLED(CONFIG_MTD)
  79 static void mtd_probe_uclass_mtd_devs(void)
  80 {
  81         struct udevice *dev;
  82         int idx = 0;
  83
  84         /* Probe devices with DM compliant drivers */
  85         while (!uclass_find_device(UCLASS_MTD, idx, &dev) && dev) {
  86                 mtd_probe(dev);
  87                 idx++;
  88         }
  89 }
  90 #else
  91 static void mtd_probe_uclass_mtd_devs(void) { }
  92 #endif
  93
  94 #if defined(CONFIG_MTD_PARTITIONS)
  95 extern void board_mtdparts_default(const char **mtdids,
  96                                    const char **mtdparts);
  97
  98 static const char *get_mtdids(void)
  99 {
 100         __maybe_unused const char *mtdparts = NULL;
 101         const char *mtdids = env_get("mtdids");
 102
 103         if (mtdids)
 104                 return mtdids;
 105
 106 #if defined(CONFIG_SYS_MTDPARTS_RUNTIME)
 107         board_mtdparts_default(&mtdids, &mtdparts);
 108 #elif defined(MTDIDS_DEFAULT)
 109         mtdids = MTDIDS_DEFAULT;
 110 #elif defined(CONFIG_MTDIDS_DEFAULT)
 111         mtdids = CONFIG_MTDIDS_DEFAULT;
 112 #endif
 113
 114         if (mtdids)
 115                 env_set("mtdids", mtdids);
 116
 117         return mtdids;
 118 }
 119
 120 #define MTDPARTS_MAXLEN         512
 121
 122 static const char *get_mtdparts(void)
 123 {
 124         __maybe_unused const char *mtdids = NULL;
 125         static char tmp_parts[MTDPARTS_MAXLEN];
 126         static bool use_defaults = true;
 127         const char *mtdparts = NULL;
 128
 129         if (gd->flags & GD_FLG_ENV_READY)
 130                 mtdparts = env_get("mtdparts");
 131         else if (env_get_f("mtdparts", tmp_parts, sizeof(tmp_parts)) != -1)
 132                 mtdparts = tmp_parts;
 133
 134         if (mtdparts || !use_defaults)
 135                 return mtdparts;
 136
 137 #if defined(CONFIG_SYS_MTDPARTS_RUNTIME)
 138         board_mtdparts_default(&mtdids, &mtdparts);
 139 #elif defined(MTDPARTS_DEFAULT)
 140         mtdparts = MTDPARTS_DEFAULT;
 141 #elif defined(CONFIG_MTDPARTS_DEFAULT)
 142         mtdparts = CONFIG_MTDPARTS_DEFAULT;
 143 #endif
 144
 145         if (mtdparts)
 146                 env_set("mtdparts", mtdparts);
 147
 148         use_defaults = false;
 149
 150         return mtdparts;
 151 }
 152
 153 int mtd_probe_devices(void)
 154 {
 155         static char *old_mtdparts;
 156         static char *old_mtdids;
 157         const char *mtdparts = get_mtdparts();
 158         const char *mtdids = get_mtdids();
 159         bool remaining_partitions = true;
 160         struct mtd_info *mtd;
 161
 162         mtd_probe_uclass_mtd_devs();
 163
 164         /*
 165          * Check if mtdparts/mtdids changed or if the MTD dev list was updated
 166          * since last call, otherwise: exit
 167          */
 168         if ((!mtdparts && !old_mtdparts && !mtdids && !old_mtdids) ||
 169             (mtdparts && old_mtdparts && mtdids && old_mtdids &&
 170              !mtd_dev_list_updated() &&
 171              !strcmp(mtdparts, old_mtdparts) &&
 172              !strcmp(mtdids, old_mtdids)))
 173                 return 0;
 174
 175         /* Update the local copy of mtdparts */
 176         free(old_mtdparts);
 177         free(old_mtdids);
 178         old_mtdparts = strdup(mtdparts);
 179         old_mtdids = strdup(mtdids);
 180
 181         /* If at least one partition is still in use, do not delete anything */
 182         mtd_for_each_device(mtd) {
 183                 if (mtd->usecount) {
 184                         printf("Partition \"%s\" already in use, aborting\n",
 185                                mtd->name);
 186                         return -EACCES;
 187                 }
 188         }
 189
 190         /*
 191          * Everything looks clear, remove all partitions. It is not safe to
 192          * remove entries from the mtd_for_each_device loop as it uses idr
 193          * indexes and the partitions removal is done in bulk (all partitions of
 194          * one device at the same time), so break and iterate from start each
 195          * time a new partition is found and deleted.
 196          */
 197         while (remaining_partitions) {
 198                 remaining_partitions = false;
 199                 mtd_for_each_device(mtd) {
 200                         if (!mtd_is_partition(mtd) && mtd_has_partitions(mtd)) {
 201                                 del_mtd_partitions(mtd);
 202                                 remaining_partitions = true;
 203                                 break;
 204                         }
 205                 }
 206         }
 207
 208         /*
 209          * Call mtd_dev_list_updated() to clear updates generated by our own
 210          * parts removal loop.
 211          */
 212         mtd_dev_list_updated();
 213
 214         /* If either mtdparts or mtdids is empty, then exit */
 215         if (!mtdparts || !mtdids)
 216                 return 0;
 217
 218         /* Start the parsing by ignoring the extra 'mtdparts=' prefix, if any */
 219         if (strstr(mtdparts, "mtdparts="))
 220                 mtdparts += 9;
 221
 222         /* For each MTD device in mtdparts */
 223         while (mtdparts[0] != '\0') {
 224                 char mtd_name[MTD_NAME_MAX_LEN], *colon;
 225                 struct mtd_partition *parts;
 226                 int mtd_name_len, nparts;
 227                 int ret;
 228
 229                 colon = strchr(mtdparts, ':');
 230                 if (!colon) {
 231                         printf("Wrong mtdparts: %s\n", mtdparts);
 232                         return -EINVAL;
 233                 }
 234
 235                 mtd_name_len = colon - mtdparts;
 236                 strncpy(mtd_name, mtdparts, mtd_name_len);
 237                 mtd_name[mtd_name_len] = '\0';
 238                 /* Move the pointer forward (including the ':') */
 239                 mtdparts += mtd_name_len + 1;
 240                 mtd = get_mtd_device_nm(mtd_name);
 241                 if (IS_ERR_OR_NULL(mtd)) {
 242                         char linux_name[MTD_NAME_MAX_LEN];
 243
 244                         /*
 245                          * The MTD device named "mtd_name" does not exist. Try
 246                          * to find a correspondance with an MTD device having
 247                          * the same type and number as defined in the mtdids.
 248                          */
 249                         debug("No device named %s\n", mtd_name);
 250                         ret = mtd_search_alternate_name(mtd_name, linux_name,
 251                                                         MTD_NAME_MAX_LEN);
 252                         if (!ret)
 253                                 mtd = get_mtd_device_nm(linux_name);
 254
 255                         /*
 256                          * If no device could be found, move the mtdparts
 257                          * pointer forward until the next set of partitions.
 258                          */
 259                         if (ret || IS_ERR_OR_NULL(mtd)) {
 260                                 printf("Could not find a valid device for %s\n",
 261                                        mtd_name);
 262                                 mtdparts = strchr(mtdparts, ';');
 263                                 if (mtdparts)
 264                                         mtdparts++;
 265
 266                                 continue;
 267                         }
 268                 }
 269
 270                 /*
 271                  * Parse the MTD device partitions. It will update the mtdparts
 272                  * pointer, create an array of parts (that must be freed), and
 273                  * return the number of partition structures in the array.
 274                  */
 275                 ret = mtd_parse_partitions(mtd, &mtdparts, &parts, &nparts);
 276                 if (ret) {
 277                         printf("Could not parse device %s\n", mtd->name);
 278                         put_mtd_device(mtd);
 279                         return -EINVAL;
 280                 }
 281
 282                 if (!nparts)
 283                         continue;
 284
 285                 /* Create the new MTD partitions */
 286                 add_mtd_partitions(mtd, parts, nparts);
 287
 288                 /* Free the structures allocated during the parsing */
 289                 mtd_free_parsed_partitions(parts, nparts);
 290
 291                 put_mtd_device(mtd);
 292         }
 293
 294         /*
 295          * Call mtd_dev_list_updated() to clear updates generated by our own
 296          * parts registration loop.
 297          */
 298         mtd_dev_list_updated();
 299
 300         return 0;
 301 }
 302 #else
 303 int mtd_probe_devices(void)
 304 {
 305         mtd_probe_uclass_mtd_devs();
 306
 307         return 0;
 308 }
 309 #endif /* defined(CONFIG_MTD_PARTITIONS) */
 310
 311 /* Legacy */
 312
 313 static int get_part(const char *partname, int *idx, loff_t *off, loff_t *size,
 314                 loff_t *maxsize, int devtype)
 315 {
 316 #ifdef CONFIG_CMD_MTDPARTS
 317         struct mtd_device *dev;
 318         struct part_info *part;
 319         u8 pnum;
 320         int ret;
 321
 322         ret = mtdparts_init();
 323         if (ret)
 324                 return ret;
 325
 326         ret = find_dev_and_part(partname, &dev, &pnum, &part);
 327         if (ret)
 328                 return ret;
 329
 330         if (dev->id->type != devtype) {
 331                 printf("not same typ %d != %d\n", dev->id->type, devtype);
 332                 return -1;
 333         }
 334
 335         *off = part->offset;
 336         *size = part->size;
 337         *maxsize = part->size;
 338         *idx = dev->id->num;
 339
 340         return 0;
 341 #else
 342         puts("mtdparts support missing.\n");
 343         return -1;
 344 #endif
 345 }
 346
 347 int mtd_arg_off(const char *arg, int *idx, loff_t *off, loff_t *size,
 348                 loff_t *maxsize, int devtype, uint64_t chipsize)
 349 {
 350         if (!str2off(arg, off))
 351                 return get_part(arg, idx, off, size, maxsize, devtype);
 352
 353         if (*off >= chipsize) {
 354                 puts("Offset exceeds device limit\n");
 355                 return -1;
 356         }
 357
 358         *maxsize = chipsize - *off;
 359         *size = *maxsize;
 360         return 0;
 361 }
 362
 363 int mtd_arg_off_size(int argc, char *const argv[], int *idx, loff_t *off,
 364                      loff_t *size, loff_t *maxsize, int devtype,
 365                      uint64_t chipsize)
 366 {
 367         int ret;
 368
 369         if (argc == 0) {
 370                 *off = 0;
 371                 *size = chipsize;
 372                 *maxsize = *size;
 373                 goto print;
 374         }
 375
 376         ret = mtd_arg_off(argv[0], idx, off, size, maxsize, devtype,
 377                           chipsize);
 378         if (ret)
 379                 return ret;
 380
 381         if (argc == 1)
 382                 goto print;
 383
 384         if (!str2off(argv[1], size)) {
 385                 printf("'%s' is not a number\n", argv[1]);
 386                 return -1;
 387         }
 388
 389         if (*size > *maxsize) {
 390                 puts("Size exceeds partition or device limit\n");
 391                 return -1;
 392         }
 393
 394 print:
 395         printf("device %d ", *idx);
 396         if (*size == chipsize)
 397                 puts("whole chip\n");
 398         else
 399                 printf("offset 0x%llx, size 0x%llx\n",
 400                        (unsigned long long)*off, (unsigned long long)*size);
 401         return 0;
 402 }