2 * Flash mappings described by the OF (or flattened) device tree
4 * Copyright (C) 2006 MontaVista Software Inc.
5 * Author: Vitaly Wool <vwool@ru.mvista.com>
7 * Revised to handle newer style flash binding by:
8 * Copyright (C) 2007 David Gibson, IBM Corporation.
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.
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>
24 #include <linux/of_address.h>
25 #include <linux/of_platform.h>
26 #include <linux/slab.h>
27 #include "physmap_of_versatile.h"
29 struct of_flash_list {
35 struct mtd_info *cmtd;
36 int list_size; /* number of elements in of_flash_list */
37 struct of_flash_list list[0];
40 static int of_flash_remove(struct platform_device *dev)
42 struct of_flash *info;
45 info = dev_get_drvdata(&dev->dev);
48 dev_set_drvdata(&dev->dev, NULL);
51 mtd_device_unregister(info->cmtd);
52 if (info->cmtd != info->list[0].mtd)
53 mtd_concat_destroy(info->cmtd);
56 for (i = 0; i < info->list_size; i++)
57 if (info->list[i].mtd)
58 map_destroy(info->list[i].mtd);
63 static const char * const rom_probe_types[] = {
64 "cfi_probe", "jedec_probe", "map_rom" };
66 /* Helper function to handle probing of the obsolete "direct-mapped"
67 * compatible binding, which has an extra "probe-type" property
68 * describing the type of flash probe necessary. */
69 static struct mtd_info *obsolete_probe(struct platform_device *dev,
72 struct device_node *dp = dev->dev.of_node;
77 dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" "
80 of_probe = of_get_property(dp, "probe-type", NULL);
82 for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) {
83 mtd = do_map_probe(rom_probe_types[i], map);
88 } else if (strcmp(of_probe, "CFI") == 0) {
89 return do_map_probe("cfi_probe", map);
90 } else if (strcmp(of_probe, "JEDEC") == 0) {
91 return do_map_probe("jedec_probe", map);
93 if (strcmp(of_probe, "ROM") != 0)
94 dev_warn(&dev->dev, "obsolete_probe: don't know probe "
95 "type '%s', mapping as rom\n", of_probe);
96 return do_map_probe("map_rom", map);
100 /* When partitions are set we look for a linux,part-probe property which
101 specifies the list of partition probers to use. If none is given then the
102 default is use. These take precedence over other device tree
104 static const char * const part_probe_types_def[] = {
105 "cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL };
107 static const char * const *of_get_probes(struct device_node *dp)
115 cp = of_get_property(dp, "linux,part-probe", &cplen);
117 return part_probe_types_def;
120 for (l = 0; l != cplen; l++)
124 res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL);
138 static void of_free_probes(const char * const *probes)
140 if (probes != part_probe_types_def)
144 static const struct of_device_id of_flash_match[];
145 static int of_flash_probe(struct platform_device *dev)
147 const char * const *part_probe_types;
148 const struct of_device_id *match;
149 struct device_node *dp = dev->dev.of_node;
151 struct of_flash *info;
152 const char *probe_type;
159 struct mtd_info **mtd_list = NULL;
160 resource_size_t res_size;
162 const char *mtd_name = NULL;
164 match = of_match_device(of_flash_match, &dev->dev);
167 probe_type = match->data;
169 reg_tuple_size = (of_n_addr_cells(dp) + of_n_size_cells(dp)) * sizeof(u32);
171 of_property_read_string(dp, "linux,mtd-name", &mtd_name);
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.
179 p = of_get_property(dp, "reg", &count);
180 if (!p || count % reg_tuple_size != 0) {
181 dev_err(&dev->dev, "Malformed reg property on %s\n",
182 dev->dev.of_node->full_name);
184 goto err_flash_remove;
186 count /= reg_tuple_size;
188 map_indirect = of_property_read_bool(dp, "no-unaligned-direct-access");
191 info = devm_kzalloc(&dev->dev,
192 sizeof(struct of_flash) +
193 sizeof(struct of_flash_list) * count, GFP_KERNEL);
195 goto err_flash_remove;
197 dev_set_drvdata(&dev->dev, info);
199 mtd_list = kzalloc(sizeof(*mtd_list) * count, GFP_KERNEL);
201 goto err_flash_remove;
203 for (i = 0; i < count; i++) {
205 if (of_address_to_resource(dp, i, &res)) {
207 * Continue with next register tuple if this
208 * one is not mappable
213 dev_dbg(&dev->dev, "of_flash device: %pR\n", &res);
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);
224 width = of_get_property(dp, "bank-width", NULL);
226 dev_err(&dev->dev, "Can't get bank width from device"
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 err = of_flash_probe_versatile(dev, dp, &info->list[i].map);
238 dev_err(&dev->dev, "Can't probe Versatile VPP\n");
242 simple_map_init(&info->list[i].map);
245 * On some platforms (e.g. MPC5200) a direct 1:1 mapping
246 * may cause problems with JFFS2 usage, as the local bus (LPB)
247 * doesn't support unaligned accesses as implemented in the
248 * JFFS2 code via memcpy(). By setting NO_XIP, the
249 * flash will not be exposed directly to the MTD users
250 * (e.g. JFFS2) any more.
253 info->list[i].map.phys = NO_XIP;
256 info->list[i].mtd = do_map_probe(probe_type,
259 info->list[i].mtd = obsolete_probe(dev,
263 /* Fall back to mapping region as ROM */
264 if (!info->list[i].mtd) {
266 "do_map_probe() failed for type %s\n",
269 info->list[i].mtd = do_map_probe("map_rom",
272 mtd_list[i] = info->list[i].mtd;
275 if (!info->list[i].mtd) {
276 dev_err(&dev->dev, "do_map_probe() failed\n");
281 info->list[i].mtd->dev.parent = &dev->dev;
286 if (info->list_size == 1) {
287 info->cmtd = info->list[0].mtd;
288 } else if (info->list_size > 1) {
290 * We detected multiple devices. Concatenate them together.
292 info->cmtd = mtd_concat_create(mtd_list, info->list_size,
293 dev_name(&dev->dev));
295 if (info->cmtd == NULL)
301 info->cmtd->dev.parent = &dev->dev;
302 mtd_set_of_node(info->cmtd, dp);
303 part_probe_types = of_get_probes(dp);
304 if (!part_probe_types) {
308 mtd_device_parse_register(info->cmtd, part_probe_types, NULL,
310 of_free_probes(part_probe_types);
319 of_flash_remove(dev);
324 static const struct of_device_id of_flash_match[] = {
326 .compatible = "cfi-flash",
327 .data = (void *)"cfi_probe",
330 /* FIXME: JEDEC chips can't be safely and reliably
331 * probed, although the mtd code gets it right in
332 * practice most of the time. We should use the
333 * vendor and device ids specified by the binding to
334 * bypass the heuristic probe code, but the mtd layer
335 * provides, at present, no interface for doing so
337 .compatible = "jedec-flash",
338 .data = (void *)"jedec_probe",
341 .compatible = "mtd-ram",
342 .data = (void *)"map_ram",
345 .compatible = "mtd-rom",
346 .data = (void *)"map_rom",
350 .compatible = "direct-mapped"
354 MODULE_DEVICE_TABLE(of, of_flash_match);
356 static struct platform_driver of_flash_driver = {
359 .of_match_table = of_flash_match,
361 .probe = of_flash_probe,
362 .remove = of_flash_remove,
365 module_platform_driver(of_flash_driver);
367 MODULE_LICENSE("GPL");
368 MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
369 MODULE_DESCRIPTION("Device tree based MTD map driver");