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         struct resource *res;
  34 };
  35
  36 struct of_flash {
  37         struct mtd_info         *cmtd;
  38         int list_size; /* number of elements in of_flash_list */
  39         struct of_flash_list    list[0];
  40 };
  41
  42 static int of_flash_remove(struct platform_device *dev)
  43 {
  44         struct of_flash *info;
  45         int i;
  46
  47         info = dev_get_drvdata(&dev->dev);
  48         if (!info)
  49                 return 0;
  50         dev_set_drvdata(&dev->dev, NULL);
  51
  52         if (info->cmtd) {
  53                 mtd_device_unregister(info->cmtd);
  54                 if (info->cmtd != info->list[0].mtd)
  55                         mtd_concat_destroy(info->cmtd);
  56         }
  57
  58         for (i = 0; i < info->list_size; i++) {
  59                 if (info->list[i].mtd)
  60                         map_destroy(info->list[i].mtd);
  61
  62                 if (info->list[i].map.virt)
  63                         iounmap(info->list[i].map.virt);
  64
  65                 if (info->list[i].res) {
  66                         release_resource(info->list[i].res);
  67                         kfree(info->list[i].res);
  68                 }
  69         }
  70         return 0;
  71 }
  72
  73 static const char * const rom_probe_types[] = {
  74         "cfi_probe", "jedec_probe", "map_rom" };
  75
  76 /* Helper function to handle probing of the obsolete "direct-mapped"
  77  * compatible binding, which has an extra "probe-type" property
  78  * describing the type of flash probe necessary. */
  79 static struct mtd_info *obsolete_probe(struct platform_device *dev,
  80                                        struct map_info *map)
  81 {
  82         struct device_node *dp = dev->dev.of_node;
  83         const char *of_probe;
  84         struct mtd_info *mtd;
  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("map_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 * const part_probe_types_def[] = {
 115         "cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL };
 116
 117 static const char * const *of_get_probes(struct device_node *dp)
 118 {
 119         const char *cp;
 120         int cplen;
 121         unsigned int l;
 122         unsigned int count;
 123         const char **res;
 124
 125         cp = of_get_property(dp, "linux,part-probe", &cplen);
 126         if (cp == NULL)
 127                 return part_probe_types_def;
 128
 129         count = 0;
 130         for (l = 0; l != cplen; l++)
 131                 if (cp[l] == 0)
 132                         count++;
 133
 134         res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL);
 135         if (!res)
 136                 return NULL;
 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 * const *probes)
 149 {
 150         if (probes != part_probe_types_def)
 151                 kfree(probes);
 152 }
 153
 154 static const struct of_device_id of_flash_match[];
 155 static int of_flash_probe(struct platform_device *dev)
 156 {
 157         const char * const *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         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 (!p || 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 = of_flash_probe_gemini(dev, dp, &info->list[i].map);
 247                 if (err)
 248                         return err;
 249                 err = of_flash_probe_versatile(dev, dp, &info->list[i].map);
 250                 if (err)
 251                         return err;
 252
 253                 err = -ENOMEM;
 254                 info->list[i].map.virt = ioremap(info->list[i].map.phys,
 255                                                  info->list[i].map.size);
 256                 if (!info->list[i].map.virt) {
 257                         dev_err(&dev->dev, "Failed to ioremap() flash"
 258                                 " region\n");
 259                         goto err_out;
 260                 }
 261
 262                 simple_map_init(&info->list[i].map);
 263
 264                 /*
 265                  * On some platforms (e.g. MPC5200) a direct 1:1 mapping
 266                  * may cause problems with JFFS2 usage, as the local bus (LPB)
 267                  * doesn't support unaligned accesses as implemented in the
 268                  * JFFS2 code via memcpy(). By setting NO_XIP, the
 269                  * flash will not be exposed directly to the MTD users
 270                  * (e.g. JFFS2) any more.
 271                  */
 272                 if (map_indirect)
 273                         info->list[i].map.phys = NO_XIP;
 274
 275                 if (probe_type) {
 276                         info->list[i].mtd = do_map_probe(probe_type,
 277                                                          &info->list[i].map);
 278                 } else {
 279                         info->list[i].mtd = obsolete_probe(dev,
 280                                                            &info->list[i].map);
 281                 }
 282
 283                 /* Fall back to mapping region as ROM */
 284                 if (!info->list[i].mtd) {
 285                         dev_warn(&dev->dev,
 286                                 "do_map_probe() failed for type %s\n",
 287                                  probe_type);
 288
 289                         info->list[i].mtd = do_map_probe("map_rom",
 290                                                          &info->list[i].map);
 291                 }
 292                 mtd_list[i] = info->list[i].mtd;
 293
 294                 err = -ENXIO;
 295                 if (!info->list[i].mtd) {
 296                         dev_err(&dev->dev, "do_map_probe() failed\n");
 297                         goto err_out;
 298                 } else {
 299                         info->list_size++;
 300                 }
 301                 info->list[i].mtd->dev.parent = &dev->dev;
 302         }
 303
 304         err = 0;
 305         info->cmtd = NULL;
 306         if (info->list_size == 1) {
 307                 info->cmtd = info->list[0].mtd;
 308         } else if (info->list_size > 1) {
 309                 /*
 310                  * We detected multiple devices. Concatenate them together.
 311                  */
 312                 info->cmtd = mtd_concat_create(mtd_list, info->list_size,
 313                                                dev_name(&dev->dev));
 314         }
 315         if (info->cmtd == NULL)
 316                 err = -ENXIO;
 317
 318         if (err)
 319                 goto err_out;
 320
 321         info->cmtd->dev.parent = &dev->dev;
 322         mtd_set_of_node(info->cmtd, dp);
 323         part_probe_types = of_get_probes(dp);
 324         if (!part_probe_types) {
 325                 err = -ENOMEM;
 326                 goto err_out;
 327         }
 328         mtd_device_parse_register(info->cmtd, part_probe_types, NULL,
 329                         NULL, 0);
 330         of_free_probes(part_probe_types);
 331
 332         kfree(mtd_list);
 333
 334         return 0;
 335
 336 err_out:
 337         kfree(mtd_list);
 338 err_flash_remove:
 339         of_flash_remove(dev);
 340
 341         return err;
 342 }
 343
 344 static const struct of_device_id of_flash_match[] = {
 345         {
 346                 .compatible     = "cfi-flash",
 347                 .data           = (void *)"cfi_probe",
 348         },
 349         {
 350                 /* FIXME: JEDEC chips can't be safely and reliably
 351                  * probed, although the mtd code gets it right in
 352                  * practice most of the time.  We should use the
 353                  * vendor and device ids specified by the binding to
 354                  * bypass the heuristic probe code, but the mtd layer
 355                  * provides, at present, no interface for doing so
 356                  * :(. */
 357                 .compatible     = "jedec-flash",
 358                 .data           = (void *)"jedec_probe",
 359         },
 360         {
 361                 .compatible     = "mtd-ram",
 362                 .data           = (void *)"map_ram",
 363         },
 364         {
 365                 .compatible     = "mtd-rom",
 366                 .data           = (void *)"map_rom",
 367         },
 368         {
 369                 .type           = "rom",
 370                 .compatible     = "direct-mapped"
 371         },
 372         { },
 373 };
 374 MODULE_DEVICE_TABLE(of, of_flash_match);
 375
 376 static struct platform_driver of_flash_driver = {
 377         .driver = {
 378                 .name = "of-flash",
 379                 .of_match_table = of_flash_match,
 380         },
 381         .probe          = of_flash_probe,
 382         .remove         = of_flash_remove,
 383 };
 384
 385 module_platform_driver(of_flash_driver);
 386
 387 MODULE_LICENSE("GPL");
 388 MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
 389 MODULE_DESCRIPTION("Device tree based MTD map driver");