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
  72         kfree(info);
  73
  74         return 0;
  75 }
  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         static const char *rom_probe_types[]
  87                 = { "cfi_probe", "jedec_probe", "map_rom"};
  88         int i;
  89
  90         dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" "
  91                  "flash binding\n");
  92
  93         of_probe = of_get_property(dp, "probe-type", NULL);
  94         if (!of_probe) {
  95                 for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) {
  96                         mtd = do_map_probe(rom_probe_types[i], map);
  97                         if (mtd)
  98                                 return mtd;
  99                 }
 100                 return NULL;
 101         } else if (strcmp(of_probe, "CFI") == 0) {
 102                 return do_map_probe("cfi_probe", map);
 103         } else if (strcmp(of_probe, "JEDEC") == 0) {
 104                 return do_map_probe("jedec_probe", map);
 105         } else {
 106                 if (strcmp(of_probe, "ROM") != 0)
 107                         dev_warn(&dev->dev, "obsolete_probe: don't know probe "
 108                                  "type '%s', mapping as rom\n", of_probe);
 109                 return do_map_probe("mtd_rom", map);
 110         }
 111 }
 112
 113 /* When partitions are set we look for a linux,part-probe property which
 114    specifies the list of partition probers to use. If none is given then the
 115    default is use. These take precedence over other device tree
 116    information. */
 117 static const char *part_probe_types_def[] = { "cmdlinepart", "RedBoot",
 118                                         "ofpart", "ofoldpart", NULL };
 119 static const char **of_get_probes(struct device_node *dp)
 120 {
 121         const char *cp;
 122         int cplen;
 123         unsigned int l;
 124         unsigned int count;
 125         const char **res;
 126
 127         cp = of_get_property(dp, "linux,part-probe", &cplen);
 128         if (cp == NULL)
 129                 return part_probe_types_def;
 130
 131         count = 0;
 132         for (l = 0; l != cplen; l++)
 133                 if (cp[l] == 0)
 134                         count++;
 135
 136         res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL);
 137         count = 0;
 138         while (cplen > 0) {
 139                 res[count] = cp;
 140                 l = strlen(cp) + 1;
 141                 cp += l;
 142                 cplen -= l;
 143                 count++;
 144         }
 145         return res;
 146 }
 147
 148 static void of_free_probes(const char **probes)
 149 {
 150         if (probes != part_probe_types_def)
 151                 kfree(probes);
 152 }
 153
 154 static struct of_device_id of_flash_match[];
 155 static int of_flash_probe(struct platform_device *dev)
 156 {
 157         const char **part_probe_types;
 158         const struct of_device_id *match;
 159         struct device_node *dp = dev->dev.of_node;
 160         struct resource res;
 161         struct of_flash *info;
 162         const char *probe_type;
 163         const __be32 *width;
 164         int err;
 165         int i;
 166         int count;
 167         const __be32 *p;
 168         int reg_tuple_size;
 169         struct mtd_info **mtd_list = NULL;
 170         resource_size_t res_size;
 171         struct mtd_part_parser_data ppdata;
 172         bool map_indirect;
 173         const char *mtd_name;
 174
 175         match = of_match_device(of_flash_match, &dev->dev);
 176         if (!match)
 177                 return -EINVAL;
 178         probe_type = match->data;
 179
 180         reg_tuple_size = (of_n_addr_cells(dp) + of_n_size_cells(dp)) * sizeof(u32);
 181
 182         of_property_read_string(dp, "linux,mtd-name", &mtd_name);
 183
 184         /*
 185          * Get number of "reg" tuples. Scan for MTD devices on area's
 186          * described by each "reg" region. This makes it possible (including
 187          * the concat support) to support the Intel P30 48F4400 chips which
 188          * consists internally of 2 non-identical NOR chips on one die.
 189          */
 190         p = of_get_property(dp, "reg", &count);
 191         if (count % reg_tuple_size != 0) {
 192                 dev_err(&dev->dev, "Malformed reg property on %s\n",
 193                                 dev->dev.of_node->full_name);
 194                 err = -EINVAL;
 195                 goto err_flash_remove;
 196         }
 197         count /= reg_tuple_size;
 198
 199         map_indirect = of_property_read_bool(dp, "no-unaligned-direct-access");
 200
 201         err = -ENOMEM;
 202         info = kzalloc(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");