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         int list_size; /* number of elements in of_flash_list */
  38         struct of_flash_list    list[0];
  39 };
  40
  41 static int of_flash_remove(struct platform_device *dev)
  42 {
  43         struct of_flash *info;
  44         int i;
  45
  46         info = dev_get_drvdata(&dev->dev);
  47         if (!info)
  48                 return 0;
  49         dev_set_drvdata(&dev->dev, NULL);
  50
  51         if (info->cmtd != info->list[0].mtd) {
  52                 mtd_device_unregister(info->cmtd);
  53                 mtd_concat_destroy(info->cmtd);
  54         }
  55
  56         if (info->cmtd)
  57                 mtd_device_unregister(info->cmtd);
  58
  59         for (i = 0; i < info->list_size; i++) {
  60                 if (info->list[i].mtd)
  61                         map_destroy(info->list[i].mtd);
  62
  63                 if (info->list[i].map.virt)
  64                         iounmap(info->list[i].map.virt);
  65
  66                 if (info->list[i].res) {
  67                         release_resource(info->list[i].res);
  68                         kfree(info->list[i].res);
  69                 }
  70         }
  71         return 0;
  72 }
  73
  74 static const char * const rom_probe_types[] = {
  75         "cfi_probe", "jedec_probe", "map_rom" };
  76
  77 /* Helper function to handle probing of the obsolete "direct-mapped"
  78  * compatible binding, which has an extra "probe-type" property
  79  * describing the type of flash probe necessary. */
  80 static struct mtd_info *obsolete_probe(struct platform_device *dev,
  81                                        struct map_info *map)
  82 {
  83         struct device_node *dp = dev->dev.of_node;
  84         const char *of_probe;
  85         struct mtd_info *mtd;
  86         int i;
  87
  88         dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" "
  89                  "flash binding\n");
  90
  91         of_probe = of_get_property(dp, "probe-type", NULL);
  92         if (!of_probe) {
  93                 for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) {
  94                         mtd = do_map_probe(rom_probe_types[i], map);
  95                         if (mtd)
  96                                 return mtd;
  97                 }
  98                 return NULL;
  99         } else if (strcmp(of_probe, "CFI") == 0) {
 100                 return do_map_probe("cfi_probe", map);
 101         } else if (strcmp(of_probe, "JEDEC") == 0) {
 102                 return do_map_probe("jedec_probe", map);
 103         } else {
 104                 if (strcmp(of_probe, "ROM") != 0)
 105                         dev_warn(&dev->dev, "obsolete_probe: don't know probe "
 106                                  "type '%s', mapping as rom\n", of_probe);
 107                 return do_map_probe("mtd_rom", map);
 108         }
 109 }
 110
 111 /* When partitions are set we look for a linux,part-probe property which
 112    specifies the list of partition probers to use. If none is given then the
 113    default is use. These take precedence over other device tree
 114    information. */
 115 static const char * const part_probe_types_def[] = {
 116         "cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL };
 117
 118 static const char * const *of_get_probes(struct device_node *dp)
 119 {
 120         const char *cp;
 121         int cplen;
 122         unsigned int l;
 123         unsigned int count;
 124         const char **res;
 125
 126         cp = of_get_property(dp, "linux,part-probe", &cplen);
 127         if (cp == NULL)
 128                 return part_probe_types_def;
 129
 130         count = 0;
 131         for (l = 0; l != cplen; l++)
 132                 if (cp[l] == 0)
 133                         count++;
 134
 135         res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL);
 136         count = 0;
 137         while (cplen > 0) {
 138                 res[count] = cp;
 139                 l = strlen(cp) + 1;
 140                 cp += l;
 141                 cplen -= l;
 142                 count++;
 143         }
 144         return res;
 145 }
 146
 147 static void of_free_probes(const char * const *probes)
 148 {
 149         if (probes != part_probe_types_def)
 150                 kfree(probes);
 151 }
 152
 153 static struct of_device_id of_flash_match[];
 154 static int of_flash_probe(struct platform_device *dev)
 155 {
 156         const char * const *part_probe_types;
 157         const struct of_device_id *match;
 158         struct device_node *dp = dev->dev.of_node;
 159         struct resource res;
 160         struct of_flash *info;
 161         const char *probe_type;
 162         const __be32 *width;
 163         int err;
 164         int i;
 165         int count;
 166         const __be32 *p;
 167         int reg_tuple_size;
 168         struct mtd_info **mtd_list = NULL;
 169         resource_size_t res_size;
 170         struct mtd_part_parser_data ppdata;
 171         bool map_indirect;
 172         const char *mtd_name = NULL;
 173
 174         match = of_match_device(of_flash_match, &dev->dev);
 175         if (!match)
 176                 return -EINVAL;
 177         probe_type = match->data;
 178
 179         reg_tuple_size = (of_n_addr_cells(dp) + of_n_size_cells(dp)) * sizeof(u32);
 180
 181         of_property_read_string(dp, "linux,mtd-name", &mtd_name);
 182
 183         /*
 184          * Get number of "reg" tuples. Scan for MTD devices on area's
 185          * described by each "reg" region. This makes it possible (including
 186          * the concat support) to support the Intel P30 48F4400 chips which
 187          * consists internally of 2 non-identical NOR chips on one die.
 188          */
 189         p = of_get_property(dp, "reg", &count);
 190         if (count % reg_tuple_size != 0) {
 191                 dev_err(&dev->dev, "Malformed reg property on %s\n",
 192                                 dev->dev.of_node->full_name);
 193                 err = -EINVAL;
 194                 goto err_flash_remove;
 195         }
 196         count /= reg_tuple_size;
 197
 198         map_indirect = of_property_read_bool(dp, "no-unaligned-direct-access");
 199
 200         err = -ENOMEM;
 201         info = devm_kzalloc(&dev->dev,
 202                             sizeof(struct of_flash) +
 203                             sizeof(struct of_flash_list) * count, GFP_KERNEL);
 204         if (!info)
 205                 goto err_flash_remove;
 206
 207         dev_set_drvdata(&dev->dev, info);
 208
 209         mtd_list = kzalloc(sizeof(*mtd_list) * count, GFP_KERNEL);
 210         if (!mtd_list)
 211                 goto err_flash_remove;
 212
 213         for (i = 0; i < count; i++) {
 214                 err = -ENXIO;
 215                 if (of_address_to_resource(dp, i, &res)) {
 216                         /*
 217                          * Continue with next register tuple if this
 218                          * one is not mappable
 219                          */
 220                         continue;
 221                 }
 222
 223                 dev_dbg(&dev->dev, "of_flash device: %pR\n", &res);
 224
 225                 err = -EBUSY;
 226                 res_size = resource_size(&res);
 227                 info->list[i].res = request_mem_region(res.start, res_size,
 228                                                        dev_name(&dev->dev));
 229                 if (!info->list[i].res)
 230                         goto err_out;
 231
 232                 err = -ENXIO;
 233                 width = of_get_property(dp, "bank-width", NULL);
 234                 if (!width) {
 235                         dev_err(&dev->dev, "Can't get bank width from device"
 236                                 " tree\n");
 237                         goto err_out;
 238                 }
 239
 240                 info->list[i].map.name = mtd_name ?: dev_name(&dev->dev);
 241                 info->list[i].map.phys = res.start;
 242                 info->list[i].map.size = res_size;
 243                 info->list[i].map.bankwidth = be32_to_cpup(width);
 244                 info->list[i].map.device_node = dp;
 245
 246                 err = -ENOMEM;
 247                 info->list[i].map.virt = ioremap(info->list[i].map.phys,
 248                                                  info->list[i].map.size);
 249                 if (!info->list[i].map.virt) {
 250                         dev_err(&dev->dev, "Failed to ioremap() flash"
 251                                 " region\n");
 252                         goto err_out;
 253                 }
 254
 255                 simple_map_init(&info->list[i].map);
 256
 257                 /*
 258                  * On some platforms (e.g. MPC5200) a direct 1:1 mapping
 259                  * may cause problems with JFFS2 usage, as the local bus (LPB)
 260                  * doesn't support unaligned accesses as implemented in the
 261                  * JFFS2 code via memcpy(). By setting NO_XIP, the
 262                  * flash will not be exposed directly to the MTD users
 263                  * (e.g. JFFS2) any more.
 264                  */
 265                 if (map_indirect)
 266                         info->list[i].map.phys = NO_XIP;
 267
 268                 if (probe_type) {
 269                         info->list[i].mtd = do_map_probe(probe_type,
 270                                                          &info->list[i].map);
 271                 } else {
 272                         info->list[i].mtd = obsolete_probe(dev,
 273                                                            &info->list[i].map);
 274                 }
 275                 mtd_list[i] = info->list[i].mtd;
 276
 277                 err = -ENXIO;
 278                 if (!info->list[i].mtd) {
 279                         dev_err(&dev->dev, "do_map_probe() failed\n");
 280                         goto err_out;
 281                 } else {
 282                         info->list_size++;
 283                 }
 284                 info->list[i].mtd->owner = THIS_MODULE;
 285                 info->list[i].mtd->dev.parent = &dev->dev;
 286         }
 287
 288         err = 0;
 289         info->cmtd = NULL;
 290         if (info->list_size == 1) {
 291                 info->cmtd = info->list[0].mtd;
 292         } else if (info->list_size > 1) {
 293                 /*
 294                  * We detected multiple devices. Concatenate them together.
 295                  */
 296                 info->cmtd = mtd_concat_create(mtd_list, info->list_size,
 297                                                dev_name(&dev->dev));
 298         }
 299         if (info->cmtd == NULL)
 300                 err = -ENXIO;
 301
 302         if (err)
 303                 goto err_out;
 304
 305         ppdata.of_node = dp;
 306         part_probe_types = of_get_probes(dp);
 307         mtd_device_parse_register(info->cmtd, part_probe_types, &ppdata,
 308                         NULL, 0);
 309         of_free_probes(part_probe_types);
 310
 311         kfree(mtd_list);
 312
 313         return 0;
 314
 315 err_out:
 316         kfree(mtd_list);
 317 err_flash_remove:
 318         of_flash_remove(dev);
 319
 320         return err;
 321 }
 322
 323 static struct of_device_id of_flash_match[] = {
 324         {
 325                 .compatible     = "cfi-flash",
 326                 .data           = (void *)"cfi_probe",
 327         },
 328         {
 329                 /* FIXME: JEDEC chips can't be safely and reliably
 330                  * probed, although the mtd code gets it right in
 331                  * practice most of the time.  We should use the
 332                  * vendor and device ids specified by the binding to
 333                  * bypass the heuristic probe code, but the mtd layer
 334                  * provides, at present, no interface for doing so
 335                  * :(. */
 336                 .compatible     = "jedec-flash",
 337                 .data           = (void *)"jedec_probe",
 338         },
 339         {
 340                 .compatible     = "mtd-ram",
 341                 .data           = (void *)"map_ram",
 342         },
 343         {
 344                 .type           = "rom",
 345                 .compatible     = "direct-mapped"
 346         },
 347         { },
 348 };
 349 MODULE_DEVICE_TABLE(of, of_flash_match);
 350
 351 static struct platform_driver of_flash_driver = {
 352         .driver = {
 353                 .name = "of-flash",
 354                 .owner = THIS_MODULE,
 355                 .of_match_table = of_flash_match,
 356         },
 357         .probe          = of_flash_probe,
 358         .remove         = of_flash_remove,
 359 };
 360
 361 module_platform_driver(of_flash_driver);
 362
 363 MODULE_LICENSE("GPL");
 364 MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
 365 MODULE_DESCRIPTION("Device tree based MTD map driver");