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_gemini.h"
28 #include "physmap_of_versatile.h"
30 struct of_flash_list {
36 struct mtd_info *cmtd;
37 int list_size; /* number of elements in of_flash_list */
38 struct of_flash_list list[0];
41 static int of_flash_remove(struct platform_device *dev)
43 struct of_flash *info;
46 info = dev_get_drvdata(&dev->dev);
49 dev_set_drvdata(&dev->dev, NULL);
52 mtd_device_unregister(info->cmtd);
53 if (info->cmtd != info->list[0].mtd)
54 mtd_concat_destroy(info->cmtd);
57 for (i = 0; i < info->list_size; i++)
58 if (info->list[i].mtd)
59 map_destroy(info->list[i].mtd);
64 static const char * const rom_probe_types[] = {
65 "cfi_probe", "jedec_probe", "map_rom" };
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,
73 struct device_node *dp = dev->dev.of_node;
78 dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" "
81 of_probe = of_get_property(dp, "probe-type", NULL);
83 for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) {
84 mtd = do_map_probe(rom_probe_types[i], map);
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);
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);
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
105 static const char * const part_probe_types_def[] = {
106 "cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL };
108 static const char * const *of_get_probes(struct device_node *dp)
113 count = of_property_count_strings(dp, "linux,part-probe");
115 return part_probe_types_def;
117 res = kzalloc((count + 1) * sizeof(*res), GFP_KERNEL);
121 count = of_property_read_string_array(dp, "linux,part-probe", res,
129 static void of_free_probes(const char * const *probes)
131 if (probes != part_probe_types_def)
135 static const struct of_device_id of_flash_match[];
136 static int of_flash_probe(struct platform_device *dev)
138 const char * const *part_probe_types;
139 const struct of_device_id *match;
140 struct device_node *dp = dev->dev.of_node;
142 struct of_flash *info;
143 const char *probe_type;
150 struct mtd_info **mtd_list = NULL;
151 resource_size_t res_size;
153 const char *mtd_name = NULL;
155 match = of_match_device(of_flash_match, &dev->dev);
158 probe_type = match->data;
160 reg_tuple_size = (of_n_addr_cells(dp) + of_n_size_cells(dp)) * sizeof(u32);
162 of_property_read_string(dp, "linux,mtd-name", &mtd_name);
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.
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",
175 goto err_flash_remove;
177 count /= reg_tuple_size;
179 map_indirect = of_property_read_bool(dp, "no-unaligned-direct-access");
182 info = devm_kzalloc(&dev->dev,
183 sizeof(struct of_flash) +
184 sizeof(struct of_flash_list) * count, GFP_KERNEL);
186 goto err_flash_remove;
188 dev_set_drvdata(&dev->dev, info);
190 mtd_list = kzalloc(sizeof(*mtd_list) * count, GFP_KERNEL);
192 goto err_flash_remove;
194 for (i = 0; i < count; i++) {
196 if (of_address_to_resource(dp, i, &res)) {
198 * Continue with next register tuple if this
199 * one is not mappable
204 dev_dbg(&dev->dev, "of_flash device: %pR\n", &res);
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);
215 width = of_get_property(dp, "bank-width", NULL);
217 dev_err(&dev->dev, "Can't get bank width from device"
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;
228 err = of_flash_probe_gemini(dev, dp, &info->list[i].map);
231 err = of_flash_probe_versatile(dev, dp, &info->list[i].map);
235 simple_map_init(&info->list[i].map);
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.
246 info->list[i].map.phys = NO_XIP;
249 info->list[i].mtd = do_map_probe(probe_type,
252 info->list[i].mtd = obsolete_probe(dev,
256 /* Fall back to mapping region as ROM */
257 if (!info->list[i].mtd) {
259 "do_map_probe() failed for type %s\n",
262 info->list[i].mtd = do_map_probe("map_rom",
265 mtd_list[i] = info->list[i].mtd;
268 if (!info->list[i].mtd) {
269 dev_err(&dev->dev, "do_map_probe() failed\n");
274 info->list[i].mtd->dev.parent = &dev->dev;
279 if (info->list_size == 1) {
280 info->cmtd = info->list[0].mtd;
281 } else if (info->list_size > 1) {
283 * We detected multiple devices. Concatenate them together.
285 info->cmtd = mtd_concat_create(mtd_list, info->list_size,
286 dev_name(&dev->dev));
288 if (info->cmtd == NULL)
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) {
301 mtd_device_parse_register(info->cmtd, part_probe_types, NULL,
303 of_free_probes(part_probe_types);
312 of_flash_remove(dev);
317 static const struct of_device_id of_flash_match[] = {
319 .compatible = "cfi-flash",
320 .data = (void *)"cfi_probe",
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
330 .compatible = "jedec-flash",
331 .data = (void *)"jedec_probe",
334 .compatible = "mtd-ram",
335 .data = (void *)"map_ram",
338 .compatible = "mtd-rom",
339 .data = (void *)"map_rom",
343 .compatible = "direct-mapped"
347 MODULE_DEVICE_TABLE(of, of_flash_match);
349 static struct platform_driver of_flash_driver = {
352 .of_match_table = of_flash_match,
354 .probe = of_flash_probe,
355 .remove = of_flash_remove,
358 module_platform_driver(of_flash_driver);
360 MODULE_LICENSE("GPL");
361 MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
362 MODULE_DESCRIPTION("Device tree based MTD map driver");