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