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 #ifdef CONFIG_MTD_PARTITIONS
38 struct mtd_partition *parts;
40 int list_size; /* number of elements in of_flash_list */
41 struct of_flash_list list[0];
44 #ifdef CONFIG_MTD_PARTITIONS
45 #define OF_FLASH_PARTS(info) ((info)->parts)
47 static int parse_obsolete_partitions(struct platform_device *dev,
48 struct of_flash *info,
49 struct device_node *dp)
51 int i, plen, nr_parts;
57 part = of_get_property(dp, "partitions", &plen);
59 return 0; /* No partitions found */
61 dev_warn(&dev->dev, "Device tree uses obsolete partition map binding\n");
63 nr_parts = plen / sizeof(part[0]);
65 info->parts = kzalloc(nr_parts * sizeof(*info->parts), GFP_KERNEL);
69 names = of_get_property(dp, "partition-names", &plen);
71 for (i = 0; i < nr_parts; i++) {
72 info->parts[i].offset = be32_to_cpu(part->offset);
73 info->parts[i].size = be32_to_cpu(part->len) & ~1;
74 if (be32_to_cpu(part->len) & 1) /* bit 0 set signifies read only partition */
75 info->parts[i].mask_flags = MTD_WRITEABLE;
77 if (names && (plen > 0)) {
78 int len = strlen(names) + 1;
80 info->parts[i].name = (char *)names;
84 info->parts[i].name = "unnamed";
92 #else /* MTD_PARTITIONS */
93 #define OF_FLASH_PARTS(info) (0)
94 #define parse_partitions(info, dev) (0)
95 #endif /* MTD_PARTITIONS */
97 static int of_flash_remove(struct platform_device *dev)
99 struct of_flash *info;
102 info = dev_get_drvdata(&dev->dev);
105 dev_set_drvdata(&dev->dev, NULL);
107 if (info->cmtd != info->list[0].mtd) {
108 del_mtd_device(info->cmtd);
109 mtd_concat_destroy(info->cmtd);
113 if (OF_FLASH_PARTS(info)) {
114 del_mtd_partitions(info->cmtd);
115 kfree(OF_FLASH_PARTS(info));
117 del_mtd_device(info->cmtd);
121 for (i = 0; i < info->list_size; i++) {
122 if (info->list[i].mtd)
123 map_destroy(info->list[i].mtd);
125 if (info->list[i].map.virt)
126 iounmap(info->list[i].map.virt);
128 if (info->list[i].res) {
129 release_resource(info->list[i].res);
130 kfree(info->list[i].res);
139 /* Helper function to handle probing of the obsolete "direct-mapped"
140 * compatible binding, which has an extra "probe-type" property
141 * describing the type of flash probe necessary. */
142 static struct mtd_info * __devinit obsolete_probe(struct platform_device *dev,
143 struct map_info *map)
145 struct device_node *dp = dev->dev.of_node;
146 const char *of_probe;
147 struct mtd_info *mtd;
148 static const char *rom_probe_types[]
149 = { "cfi_probe", "jedec_probe", "map_rom"};
152 dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" "
155 of_probe = of_get_property(dp, "probe-type", NULL);
157 for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) {
158 mtd = do_map_probe(rom_probe_types[i], map);
163 } else if (strcmp(of_probe, "CFI") == 0) {
164 return do_map_probe("cfi_probe", map);
165 } else if (strcmp(of_probe, "JEDEC") == 0) {
166 return do_map_probe("jedec_probe", map);
168 if (strcmp(of_probe, "ROM") != 0)
169 dev_warn(&dev->dev, "obsolete_probe: don't know probe "
170 "type '%s', mapping as rom\n", of_probe);
171 return do_map_probe("mtd_rom", map);
175 #ifdef CONFIG_MTD_PARTITIONS
176 /* When partitions are set we look for a linux,part-probe property which
177 specifies the list of partition probers to use. If none is given then the
178 default is use. These take precedence over other device tree
180 static const char *part_probe_types_def[] = { "cmdlinepart", "RedBoot", NULL };
181 static const char ** __devinit of_get_probes(struct device_node *dp)
189 cp = of_get_property(dp, "linux,part-probe", &cplen);
191 return part_probe_types_def;
194 for (l = 0; l != cplen; l++)
198 res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL);
210 static void __devinit of_free_probes(const char **probes)
212 if (probes != part_probe_types_def)
217 static struct of_device_id of_flash_match[];
218 static int __devinit of_flash_probe(struct platform_device *dev)
220 #ifdef CONFIG_MTD_PARTITIONS
221 const char **part_probe_types;
223 const struct of_device_id *match;
224 struct device_node *dp = dev->dev.of_node;
226 struct of_flash *info;
227 const char *probe_type;
234 struct mtd_info **mtd_list = NULL;
235 resource_size_t res_size;
237 match = of_match_device(of_flash_match, &dev->dev);
240 probe_type = match->data;
242 reg_tuple_size = (of_n_addr_cells(dp) + of_n_size_cells(dp)) * sizeof(u32);
245 * Get number of "reg" tuples. Scan for MTD devices on area's
246 * described by each "reg" region. This makes it possible (including
247 * the concat support) to support the Intel P30 48F4400 chips which
248 * consists internally of 2 non-identical NOR chips on one die.
250 p = of_get_property(dp, "reg", &count);
251 if (count % reg_tuple_size != 0) {
252 dev_err(&dev->dev, "Malformed reg property on %s\n",
253 dev->dev.of_node->full_name);
255 goto err_flash_remove;
257 count /= reg_tuple_size;
260 info = kzalloc(sizeof(struct of_flash) +
261 sizeof(struct of_flash_list) * count, GFP_KERNEL);
263 goto err_flash_remove;
265 dev_set_drvdata(&dev->dev, info);
267 mtd_list = kzalloc(sizeof(*mtd_list) * count, GFP_KERNEL);
269 goto err_flash_remove;
271 for (i = 0; i < count; i++) {
273 if (of_address_to_resource(dp, i, &res)) {
275 * Continue with next register tuple if this
276 * one is not mappable
281 dev_dbg(&dev->dev, "of_flash device: %pR\n", &res);
284 res_size = resource_size(&res);
285 info->list[i].res = request_mem_region(res.start, res_size,
286 dev_name(&dev->dev));
287 if (!info->list[i].res)
291 width = of_get_property(dp, "bank-width", NULL);
293 dev_err(&dev->dev, "Can't get bank width from device"
298 info->list[i].map.name = dev_name(&dev->dev);
299 info->list[i].map.phys = res.start;
300 info->list[i].map.size = res_size;
301 info->list[i].map.bankwidth = be32_to_cpup(width);
304 info->list[i].map.virt = ioremap(info->list[i].map.phys,
305 info->list[i].map.size);
306 if (!info->list[i].map.virt) {
307 dev_err(&dev->dev, "Failed to ioremap() flash"
312 simple_map_init(&info->list[i].map);
315 info->list[i].mtd = do_map_probe(probe_type,
318 info->list[i].mtd = obsolete_probe(dev,
321 mtd_list[i] = info->list[i].mtd;
324 if (!info->list[i].mtd) {
325 dev_err(&dev->dev, "do_map_probe() failed\n");
330 info->list[i].mtd->owner = THIS_MODULE;
331 info->list[i].mtd->dev.parent = &dev->dev;
335 if (info->list_size == 1) {
336 info->cmtd = info->list[0].mtd;
337 } else if (info->list_size > 1) {
339 * We detected multiple devices. Concatenate them together.
341 info->cmtd = mtd_concat_create(mtd_list, info->list_size,
342 dev_name(&dev->dev));
343 if (info->cmtd == NULL)
349 #ifdef CONFIG_MTD_PARTITIONS
350 part_probe_types = of_get_probes(dp);
351 err = parse_mtd_partitions(info->cmtd, part_probe_types,
354 of_free_probes(part_probe_types);
357 of_free_probes(part_probe_types);
359 #ifdef CONFIG_MTD_OF_PARTS
361 err = of_mtd_parse_partitions(&dev->dev, dp, &info->parts);
368 err = parse_obsolete_partitions(dev, info, dp);
374 add_mtd_partitions(info->cmtd, info->parts, err);
377 add_mtd_device(info->cmtd);
386 of_flash_remove(dev);
391 static struct of_device_id of_flash_match[] = {
393 .compatible = "cfi-flash",
394 .data = (void *)"cfi_probe",
397 /* FIXME: JEDEC chips can't be safely and reliably
398 * probed, although the mtd code gets it right in
399 * practice most of the time. We should use the
400 * vendor and device ids specified by the binding to
401 * bypass the heuristic probe code, but the mtd layer
402 * provides, at present, no interface for doing so
404 .compatible = "jedec-flash",
405 .data = (void *)"jedec_probe",
408 .compatible = "mtd-ram",
409 .data = (void *)"map_ram",
413 .compatible = "direct-mapped"
417 MODULE_DEVICE_TABLE(of, of_flash_match);
419 static struct platform_driver of_flash_driver = {
422 .owner = THIS_MODULE,
423 .of_match_table = of_flash_match,
425 .probe = of_flash_probe,
426 .remove = of_flash_remove,
429 static int __init of_flash_init(void)
431 return platform_driver_register(&of_flash_driver);
434 static void __exit of_flash_exit(void)
436 platform_driver_unregister(&of_flash_driver);
439 module_init(of_flash_init);
440 module_exit(of_flash_exit);
442 MODULE_LICENSE("GPL");
443 MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
444 MODULE_DESCRIPTION("Device tree based MTD map driver");