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