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/init.h>
19 #include <linux/device.h>
20 #include <linux/mtd/mtd.h>
21 #include <linux/mtd/map.h>
22 #include <linux/mtd/partitions.h>
23 #include <linux/mtd/concat.h>
25 #include <linux/of_address.h>
26 #include <linux/of_platform.h>
27 #include <linux/slab.h>
29 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);
51 if (info->cmtd != info->list[0].mtd) {
52 mtd_device_unregister(info->cmtd);
53 mtd_concat_destroy(info->cmtd);
57 mtd_device_unregister(info->cmtd);
59 for (i = 0; i < info->list_size; i++) {
60 if (info->list[i].mtd)
61 map_destroy(info->list[i].mtd);
63 if (info->list[i].map.virt)
64 iounmap(info->list[i].map.virt);
66 if (info->list[i].res) {
67 release_resource(info->list[i].res);
68 kfree(info->list[i].res);
74 /* Helper function to handle probing of the obsolete "direct-mapped"
75 * compatible binding, which has an extra "probe-type" property
76 * describing the type of flash probe necessary. */
77 static struct mtd_info *obsolete_probe(struct platform_device *dev,
80 struct device_node *dp = dev->dev.of_node;
83 static const char *rom_probe_types[]
84 = { "cfi_probe", "jedec_probe", "map_rom"};
87 dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" "
90 of_probe = of_get_property(dp, "probe-type", NULL);
92 for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) {
93 mtd = do_map_probe(rom_probe_types[i], map);
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);
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("mtd_rom", map);
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
114 static const char *part_probe_types_def[] = { "cmdlinepart", "RedBoot",
115 "ofpart", "ofoldpart", NULL };
116 static const char **of_get_probes(struct device_node *dp)
124 cp = of_get_property(dp, "linux,part-probe", &cplen);
126 return part_probe_types_def;
129 for (l = 0; l != cplen; l++)
133 res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL);
145 static void of_free_probes(const char **probes)
147 if (probes != part_probe_types_def)
151 static struct of_device_id of_flash_match[];
152 static int of_flash_probe(struct platform_device *dev)
154 const char **part_probe_types;
155 const struct of_device_id *match;
156 struct device_node *dp = dev->dev.of_node;
158 struct of_flash *info;
159 const char *probe_type;
166 struct mtd_info **mtd_list = NULL;
167 resource_size_t res_size;
168 struct mtd_part_parser_data ppdata;
170 const char *mtd_name = NULL;
172 match = of_match_device(of_flash_match, &dev->dev);
175 probe_type = match->data;
177 reg_tuple_size = (of_n_addr_cells(dp) + of_n_size_cells(dp)) * sizeof(u32);
179 of_property_read_string(dp, "linux,mtd-name", &mtd_name);
182 * Get number of "reg" tuples. Scan for MTD devices on area's
183 * described by each "reg" region. This makes it possible (including
184 * the concat support) to support the Intel P30 48F4400 chips which
185 * consists internally of 2 non-identical NOR chips on one die.
187 p = of_get_property(dp, "reg", &count);
188 if (count % reg_tuple_size != 0) {
189 dev_err(&dev->dev, "Malformed reg property on %s\n",
190 dev->dev.of_node->full_name);
192 goto err_flash_remove;
194 count /= reg_tuple_size;
196 map_indirect = of_property_read_bool(dp, "no-unaligned-direct-access");
199 info = devm_kzalloc(&dev->dev,
200 sizeof(struct of_flash) +
201 sizeof(struct of_flash_list) * count, GFP_KERNEL);
203 goto err_flash_remove;
205 dev_set_drvdata(&dev->dev, info);
207 mtd_list = kzalloc(sizeof(*mtd_list) * count, GFP_KERNEL);
209 goto err_flash_remove;
211 for (i = 0; i < count; i++) {
213 if (of_address_to_resource(dp, i, &res)) {
215 * Continue with next register tuple if this
216 * one is not mappable
221 dev_dbg(&dev->dev, "of_flash device: %pR\n", &res);
224 res_size = resource_size(&res);
225 info->list[i].res = request_mem_region(res.start, res_size,
226 dev_name(&dev->dev));
227 if (!info->list[i].res)
231 width = of_get_property(dp, "bank-width", NULL);
233 dev_err(&dev->dev, "Can't get bank width from device"
238 info->list[i].map.name = mtd_name ?: dev_name(&dev->dev);
239 info->list[i].map.phys = res.start;
240 info->list[i].map.size = res_size;
241 info->list[i].map.bankwidth = be32_to_cpup(width);
242 info->list[i].map.device_node = dp;
245 info->list[i].map.virt = ioremap(info->list[i].map.phys,
246 info->list[i].map.size);
247 if (!info->list[i].map.virt) {
248 dev_err(&dev->dev, "Failed to ioremap() flash"
253 simple_map_init(&info->list[i].map);
256 * On some platforms (e.g. MPC5200) a direct 1:1 mapping
257 * may cause problems with JFFS2 usage, as the local bus (LPB)
258 * doesn't support unaligned accesses as implemented in the
259 * JFFS2 code via memcpy(). By setting NO_XIP, the
260 * flash will not be exposed directly to the MTD users
261 * (e.g. JFFS2) any more.
264 info->list[i].map.phys = NO_XIP;
267 info->list[i].mtd = do_map_probe(probe_type,
270 info->list[i].mtd = obsolete_probe(dev,
273 mtd_list[i] = info->list[i].mtd;
276 if (!info->list[i].mtd) {
277 dev_err(&dev->dev, "do_map_probe() failed\n");
282 info->list[i].mtd->owner = THIS_MODULE;
283 info->list[i].mtd->dev.parent = &dev->dev;
288 if (info->list_size == 1) {
289 info->cmtd = info->list[0].mtd;
290 } else if (info->list_size > 1) {
292 * We detected multiple devices. Concatenate them together.
294 info->cmtd = mtd_concat_create(mtd_list, info->list_size,
295 dev_name(&dev->dev));
297 if (info->cmtd == NULL)
304 part_probe_types = of_get_probes(dp);
305 mtd_device_parse_register(info->cmtd, part_probe_types, &ppdata,
307 of_free_probes(part_probe_types);
316 of_flash_remove(dev);
321 static struct of_device_id of_flash_match[] = {
323 .compatible = "cfi-flash",
324 .data = (void *)"cfi_probe",
327 /* FIXME: JEDEC chips can't be safely and reliably
328 * probed, although the mtd code gets it right in
329 * practice most of the time. We should use the
330 * vendor and device ids specified by the binding to
331 * bypass the heuristic probe code, but the mtd layer
332 * provides, at present, no interface for doing so
334 .compatible = "jedec-flash",
335 .data = (void *)"jedec_probe",
338 .compatible = "mtd-ram",
339 .data = (void *)"map_ram",
343 .compatible = "direct-mapped"
347 MODULE_DEVICE_TABLE(of, of_flash_match);
349 static struct platform_driver of_flash_driver = {
352 .owner = THIS_MODULE,
353 .of_match_table = of_flash_match,
355 .probe = of_flash_probe,
356 .remove = of_flash_remove,
359 module_platform_driver(of_flash_driver);
361 MODULE_LICENSE("GPL");
362 MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
363 MODULE_DESCRIPTION("Device tree based MTD map driver");