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>
28 struct of_flash_list {
34 struct mtd_info *cmtd;
35 int list_size; /* number of elements in of_flash_list */
36 struct of_flash_list list[0];
39 static int of_flash_remove(struct platform_device *dev)
41 struct of_flash *info;
44 info = dev_get_drvdata(&dev->dev);
47 dev_set_drvdata(&dev->dev, NULL);
50 mtd_device_unregister(info->cmtd);
51 if (info->cmtd != info->list[0].mtd)
52 mtd_concat_destroy(info->cmtd);
55 for (i = 0; i < info->list_size; i++)
56 if (info->list[i].mtd)
57 map_destroy(info->list[i].mtd);
62 static const char * const rom_probe_types[] = {
63 "cfi_probe", "jedec_probe", "map_rom" };
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,
71 struct device_node *dp = dev->dev.of_node;
76 dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" "
79 of_probe = of_get_property(dp, "probe-type", NULL);
81 for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) {
82 mtd = do_map_probe(rom_probe_types[i], map);
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);
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);
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
103 static const char * const part_probe_types_def[] = {
104 "cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL };
106 static const char * const *of_get_probes(struct device_node *dp)
114 cp = of_get_property(dp, "linux,part-probe", &cplen);
116 return part_probe_types_def;
119 for (l = 0; l != cplen; l++)
123 res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL);
137 static void of_free_probes(const char * const *probes)
139 if (probes != part_probe_types_def)
143 static const struct of_device_id of_flash_match[];
144 static int of_flash_probe(struct platform_device *dev)
146 const char * const *part_probe_types;
147 const struct of_device_id *match;
148 struct device_node *dp = dev->dev.of_node;
150 struct of_flash *info;
151 const char *probe_type;
158 struct mtd_info **mtd_list = NULL;
159 resource_size_t res_size;
160 struct mtd_part_parser_data ppdata;
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 (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;
237 simple_map_init(&info->list[i].map);
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.
248 info->list[i].map.phys = NO_XIP;
251 info->list[i].mtd = do_map_probe(probe_type,
254 info->list[i].mtd = obsolete_probe(dev,
258 /* Fall back to mapping region as ROM */
259 if (!info->list[i].mtd) {
261 "do_map_probe() failed for type %s\n",
264 info->list[i].mtd = do_map_probe("map_rom",
267 mtd_list[i] = info->list[i].mtd;
270 if (!info->list[i].mtd) {
271 dev_err(&dev->dev, "do_map_probe() failed\n");
276 info->list[i].mtd->dev.parent = &dev->dev;
281 if (info->list_size == 1) {
282 info->cmtd = info->list[0].mtd;
283 } else if (info->list_size > 1) {
285 * We detected multiple devices. Concatenate them together.
287 info->cmtd = mtd_concat_create(mtd_list, info->list_size,
288 dev_name(&dev->dev));
290 if (info->cmtd == NULL)
297 part_probe_types = of_get_probes(dp);
298 if (!part_probe_types) {
302 mtd_device_parse_register(info->cmtd, part_probe_types, &ppdata,
304 of_free_probes(part_probe_types);
313 of_flash_remove(dev);
318 static const struct of_device_id of_flash_match[] = {
320 .compatible = "cfi-flash",
321 .data = (void *)"cfi_probe",
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
331 .compatible = "jedec-flash",
332 .data = (void *)"jedec_probe",
335 .compatible = "mtd-ram",
336 .data = (void *)"map_ram",
339 .compatible = "mtd-rom",
340 .data = (void *)"map_rom",
344 .compatible = "direct-mapped"
348 MODULE_DEVICE_TABLE(of, of_flash_match);
350 static struct platform_driver of_flash_driver = {
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");