drivers/mtd/maps/physmap_of.c

   1 /*
   2  * Flash mappings described by the OF (or flattened) device tree
   3  *
   4  * Copyright (C) 2006 MontaVista Software Inc.
   5  * Author: Vitaly Wool <vwool@ru.mvista.com>
   6  *
   7  * Revised to handle newer style flash binding by:
   8  *   Copyright (C) 2007 David Gibson, IBM Corporation.
   9  *
  10  * This program is free software; you can redistribute  it and/or modify it
  11  * under  the terms of  the GNU General  Public License as published by the
  12  * Free Software Foundation;  either version 2 of the  License, or (at your
  13  * option) any later version.
  14  */
  15
  16 #include <linux/module.h>
  17 #include <linux/types.h>
  18 #include <linux/init.h>
  19 #include <linux/device.h>
  20 #include <linux/mtd/mtd.h>
  21 #include <linux/mtd/map.h>
  22 #include <linux/mtd/partitions.h>
  23 #include <linux/mtd/concat.h>
  24 #include <linux/of.h>
  25 #include <linux/of_address.h>
  26 #include <linux/of_platform.h>
  27 #include <linux/slab.h>
  28
  29 struct of_flash_list {
  30         struct mtd_info *mtd;
  31         struct map_info map;
  32         struct resource *res;
  33 };
  34
  35 struct of_flash {
  36         struct mtd_info         *cmtd;
  37 #ifdef CONFIG_MTD_PARTITIONS
  38         struct mtd_partition    *parts;
  39 #endif
  40         int list_size; /* number of elements in of_flash_list */
  41         struct of_flash_list    list[0];
  42 };
  43
  44 #ifdef CONFIG_MTD_PARTITIONS
  45 #define OF_FLASH_PARTS(info)    ((info)->parts)
  46
  47 static int parse_obsolete_partitions(struct platform_device *dev,
  48                                      struct of_flash *info,
  49                                      struct device_node *dp)
  50 {
  51         int i, plen, nr_parts;
  52         const struct {
  53                 __be32 offset, len;
  54         } *part;
  55         const char *names;
  56
  57         part = of_get_property(dp, "partitions", &plen);
  58         if (!part)
  59                 return 0; /* No partitions found */
  60
  61         dev_warn(&dev->dev, "Device tree uses obsolete partition map binding\n");
  62
  63         nr_parts = plen / sizeof(part[0]);
  64
  65         info->parts = kzalloc(nr_parts * sizeof(*info->parts), GFP_KERNEL);
  66         if (!info->parts)
  67                 return -ENOMEM;
  68
  69         names = of_get_property(dp, "partition-names", &plen);
  70
  71         for (i = 0; i < nr_parts; i++) {
  72                 info->parts[i].offset = be32_to_cpu(part->offset);
  73                 info->parts[i].size   = be32_to_cpu(part->len) & ~1;
  74                 if (be32_to_cpu(part->len) & 1) /* bit 0 set signifies read only partition */
  75                         info->parts[i].mask_flags = MTD_WRITEABLE;
  76
  77                 if (names && (plen > 0)) {
  78                         int len = strlen(names) + 1;
  79
  80                         info->parts[i].name = (char *)names;
  81                         plen -= len;
  82                         names += len;
  83                 } else {
  84                         info->parts[i].name = "unnamed";
  85                 }
  86
  87                 part++;
  88         }
  89
  90         return nr_parts;
  91 }
  92 #else /* MTD_PARTITIONS */
  93 #define OF_FLASH_PARTS(info)            (0)
  94 #define parse_partitions(info, dev)     (0)
  95 #endif /* MTD_PARTITIONS */
  96
  97 static int of_flash_remove(struct platform_device *dev)
  98 {
  99         struct of_flash *info;
 100         int i;
 101
 102         info = dev_get_drvdata(&dev->dev);
 103         if (!info)
 104                 return 0;
 105         dev_set_drvdata(&dev->dev, NULL);
 106
 107 #ifdef CONFIG_MTD_CONCAT
 108         if (info->cmtd != info->list[0].mtd) {
 109                 del_mtd_device(info->cmtd);
 110                 mtd_concat_destroy(info->cmtd);
 111         }
 112 #endif
 113
 114         if (info->cmtd) {
 115                 if (OF_FLASH_PARTS(info)) {
 116                         del_mtd_partitions(info->cmtd);
 117                         kfree(OF_FLASH_PARTS(info));
 118                 } else {
 119                         del_mtd_device(info->cmtd);
 120                 }
 121         }
 122
 123         for (i = 0; i < info->list_size; i++) {
 124                 if (info->list[i].mtd)
 125                         map_destroy(info->list[i].mtd);
 126
 127                 if (info->list[i].map.virt)
 128                         iounmap(info->list[i].map.virt);
 129
 130                 if (info->list[i].res) {
 131                         release_resource(info->list[i].res);
 132                         kfree(info->list[i].res);
 133                 }
 134         }
 135
 136         kfree(info);
 137
 138         return 0;
 139 }
 140
 141 /* Helper function to handle probing of the obsolete "direct-mapped"
 142  * compatible binding, which has an extra "probe-type" property
 143  * describing the type of flash probe necessary. */
 144 static struct mtd_info * __devinit obsolete_probe(struct platform_device *dev,
 145                                                   struct map_info *map)
 146 {
 147         struct device_node *dp = dev->dev.of_node;
 148         const char *of_probe;
 149         struct mtd_info *mtd;
 150         static const char *rom_probe_types[]
 151                 = { "cfi_probe", "jedec_probe", "map_rom"};
 152         int i;
 153
 154         dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" "
 155                  "flash binding\n");
 156
 157         of_probe = of_get_property(dp, "probe-type", NULL);
 158         if (!of_probe) {
 159                 for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) {
 160                         mtd = do_map_probe(rom_probe_types[i], map);
 161                         if (mtd)
 162                                 return mtd;
 163                 }
 164                 return NULL;
 165         } else if (strcmp(of_probe, "CFI") == 0) {
 166                 return do_map_probe("cfi_probe", map);
 167         } else if (strcmp(of_probe, "JEDEC") == 0) {
 168                 return do_map_probe("jedec_probe", map);
 169         } else {
 170                 if (strcmp(of_probe, "ROM") != 0)
 171                         dev_warn(&dev->dev, "obsolete_probe: don't know probe "
 172                                  "type '%s', mapping as rom\n", of_probe);
 173                 return do_map_probe("mtd_rom", map);
 174         }
 175 }
 176
 177 #ifdef CONFIG_MTD_PARTITIONS
 178 /* When partitions are set we look for a linux,part-probe property which
 179    specifies the list of partition probers to use. If none is given then the
 180    default is use. These take precedence over other device tree
 181    information. */
 182 static const char *part_probe_types_def[] = { "cmdlinepart", "RedBoot", NULL };
 183 static const char ** __devinit of_get_probes(struct device_node *dp)
 184 {
 185         const char *cp;
 186         int cplen;
 187         unsigned int l;
 188         unsigned int count;
 189         const char **res;
 190
 191         cp = of_get_property(dp, "linux,part-probe", &cplen);
 192         if (cp == NULL)
 193                 return part_probe_types_def;
 194
 195         count = 0;
 196         for (l = 0; l != cplen; l++)
 197                 if (cp[l] == 0)
 198                         count++;
 199
 200         res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL);
 201         count = 0;
 202         while (cplen > 0) {
 203                 res[count] = cp;
 204                 l = strlen(cp) + 1;
 205                 cp += l;
 206                 cplen -= l;
 207                 count++;
 208         }
 209         return res;
 210 }
 211
 212 static void __devinit of_free_probes(const char **probes)
 213 {
 214         if (probes != part_probe_types_def)
 215                 kfree(probes);
 216 }
 217 #endif
 218
 219 static int __devinit of_flash_probe(struct platform_device *dev)
 220 {
 221 #ifdef CONFIG_MTD_PARTITIONS
 222         const char **part_probe_types;
 223 #endif
 224         struct device_node *dp = dev->dev.of_node;
 225         struct resource res;
 226         struct of_flash *info;
 227         const char *probe_type;
 228         const __be32 *width;
 229         int err;
 230         int i;
 231         int count;
 232         const __be32 *p;
 233         int reg_tuple_size;
 234         struct mtd_info **mtd_list = NULL;
 235         resource_size_t res_size;
 236
 237         if (!dev->dev.of_match)
 238                 return -EINVAL;
 239         probe_type = dev->dev.of_match->data;
 240
 241         reg_tuple_size = (of_n_addr_cells(dp) + of_n_size_cells(dp)) * sizeof(u32);
 242
 243         /*
 244          * Get number of "reg" tuples. Scan for MTD devices on area's
 245          * described by each "reg" region. This makes it possible (including
 246          * the concat support) to support the Intel P30 48F4400 chips which
 247          * consists internally of 2 non-identical NOR chips on one die.
 248          */
 249         p = of_get_property(dp, "reg", &count);
 250         if (count % reg_tuple_size != 0) {
 251                 dev_err(&dev->dev, "Malformed reg property on %s\n",
 252                                 dev->dev.of_node->full_name);
 253                 err = -EINVAL;
 254                 goto err_flash_remove;
 255         }
 256         count /= reg_tuple_size;
 257
 258         err = -ENOMEM;
 259         info = kzalloc(sizeof(struct of_flash) +
 260                        sizeof(struct of_flash_list) * count, GFP_KERNEL);
 261         if (!info)
 262                 goto err_flash_remove;
 263
 264         dev_set_drvdata(&dev->dev, info);
 265
 266         mtd_list = kzalloc(sizeof(*mtd_list) * count, GFP_KERNEL);
 267         if (!mtd_list)
 268                 goto err_flash_remove;
 269
 270         for (i = 0; i < count; i++) {
 271                 err = -ENXIO;
 272                 if (of_address_to_resource(dp, i, &res)) {
 273                         /*
 274                          * Continue with next register tuple if this
 275                          * one is not mappable
 276                          */
 277                         continue;
 278                 }
 279
 280                 dev_dbg(&dev->dev, "of_flash device: %pR\n", &res);
 281
 282                 err = -EBUSY;
 283                 res_size = resource_size(&res);
 284                 info->list[i].res = request_mem_region(res.start, res_size,
 285                                                        dev_name(&dev->dev));
 286                 if (!info->list[i].res)
 287                         goto err_out;
 288
 289                 err = -ENXIO;
 290                 width = of_get_property(dp, "bank-width", NULL);
 291                 if (!width) {
 292                         dev_err(&dev->dev, "Can't get bank width from device"
 293                                 " tree\n");
 294                         goto err_out;
 295                 }
 296
 297                 info->list[i].map.name = dev_name(&dev->dev);
 298                 info->list[i].map.phys = res.start;
 299                 info->list[i].map.size = res_size;
 300                 info->list[i].map.bankwidth = be32_to_cpup(width);
 301
 302                 err = -ENOMEM;
 303                 info->list[i].map.virt = ioremap(info->list[i].map.phys,
 304                                                  info->list[i].map.size);
 305                 if (!info->list[i].map.virt) {
 306                         dev_err(&dev->dev, "Failed to ioremap() flash"
 307                                 " region\n");
 308                         goto err_out;
 309                 }
 310
 311                 simple_map_init(&info->list[i].map);
 312
 313                 if (probe_type) {
 314                         info->list[i].mtd = do_map_probe(probe_type,
 315                                                          &info->list[i].map);
 316                 } else {
 317                         info->list[i].mtd = obsolete_probe(dev,
 318                                                            &info->list[i].map);
 319                 }
 320                 mtd_list[i] = info->list[i].mtd;
 321
 322                 err = -ENXIO;
 323                 if (!info->list[i].mtd) {
 324                         dev_err(&dev->dev, "do_map_probe() failed\n");
 325                         goto err_out;
 326                 } else {
 327                         info->list_size++;
 328                 }
 329                 info->list[i].mtd->owner = THIS_MODULE;
 330                 info->list[i].mtd->dev.parent = &dev->dev;
 331         }
 332
 333         err = 0;
 334         if (info->list_size == 1) {
 335                 info->cmtd = info->list[0].mtd;
 336         } else if (info->list_size > 1) {
 337                 /*
 338                  * We detected multiple devices. Concatenate them together.
 339                  */
 340 #ifdef CONFIG_MTD_CONCAT
 341                 info->cmtd = mtd_concat_create(mtd_list, info->list_size,
 342                                                dev_name(&dev->dev));
 343                 if (info->cmtd == NULL)
 344                         err = -ENXIO;
 345 #else
 346                 printk(KERN_ERR "physmap_of: multiple devices "
 347                        "found but MTD concat support disabled.\n");
 348                 err = -ENXIO;
 349 #endif
 350         }
 351         if (err)
 352                 goto err_out;
 353
 354 #ifdef CONFIG_MTD_PARTITIONS
 355         part_probe_types = of_get_probes(dp);
 356         err = parse_mtd_partitions(info->cmtd, part_probe_types,
 357                                    &info->parts, 0);
 358         if (err < 0) {
 359                 of_free_probes(part_probe_types);
 360                 goto err_out;
 361         }
 362         of_free_probes(part_probe_types);
 363
 364 #ifdef CONFIG_MTD_OF_PARTS
 365         if (err == 0) {
 366                 err = of_mtd_parse_partitions(&dev->dev, dp, &info->parts);
 367                 if (err < 0)
 368                         goto err_out;
 369         }
 370 #endif
 371
 372         if (err == 0) {
 373                 err = parse_obsolete_partitions(dev, info, dp);
 374                 if (err < 0)
 375                         goto err_out;
 376         }
 377
 378         if (err > 0)
 379                 add_mtd_partitions(info->cmtd, info->parts, err);
 380         else
 381 #endif
 382                 add_mtd_device(info->cmtd);
 383
 384         kfree(mtd_list);
 385
 386         return 0;
 387
 388 err_out:
 389         kfree(mtd_list);
 390 err_flash_remove:
 391         of_flash_remove(dev);
 392
 393         return err;
 394 }
 395
 396 static struct of_device_id of_flash_match[] = {
 397         {
 398                 .compatible     = "cfi-flash",
 399                 .data           = (void *)"cfi_probe",
 400         },
 401         {
 402                 /* FIXME: JEDEC chips can't be safely and reliably
 403                  * probed, although the mtd code gets it right in
 404                  * practice most of the time.  We should use the
 405                  * vendor and device ids specified by the binding to
 406                  * bypass the heuristic probe code, but the mtd layer
 407                  * provides, at present, no interface for doing so
 408                  * :(. */
 409                 .compatible     = "jedec-flash",
 410                 .data           = (void *)"jedec_probe",
 411         },
 412         {
 413                 .compatible     = "mtd-ram",
 414                 .data           = (void *)"map_ram",
 415         },
 416         {
 417                 .type           = "rom",
 418                 .compatible     = "direct-mapped"
 419         },
 420         { },
 421 };
 422 MODULE_DEVICE_TABLE(of, of_flash_match);
 423
 424 static struct platform_driver of_flash_driver = {
 425         .driver = {
 426                 .name = "of-flash",
 427                 .owner = THIS_MODULE,
 428                 .of_match_table = of_flash_match,
 429         },
 430         .probe          = of_flash_probe,
 431         .remove         = of_flash_remove,
 432 };
 433
 434 static int __init of_flash_init(void)
 435 {
 436         return platform_driver_register(&of_flash_driver);
 437 }
 438
 439 static void __exit of_flash_exit(void)
 440 {
 441         platform_driver_unregister(&of_flash_driver);
 442 }
 443
 444 module_init(of_flash_init);
 445 module_exit(of_flash_exit);
 446
 447 MODULE_LICENSE("GPL");
 448 MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
 449 MODULE_DESCRIPTION("Device tree based MTD map driver");