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