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 #ifdef CONFIG_MTD_CONCAT
108 if (info->cmtd != info->list[0].mtd) {
109 del_mtd_device(info->cmtd);
110 mtd_concat_destroy(info->cmtd);
115 if (OF_FLASH_PARTS(info)) {
116 del_mtd_partitions(info->cmtd);
117 kfree(OF_FLASH_PARTS(info));
119 del_mtd_device(info->cmtd);
123 for (i = 0; i < info->list_size; i++) {
124 if (info->list[i].mtd)
125 map_destroy(info->list[i].mtd);
127 if (info->list[i].map.virt)
128 iounmap(info->list[i].map.virt);
130 if (info->list[i].res) {
131 release_resource(info->list[i].res);
132 kfree(info->list[i].res);
141 /* Helper function to handle probing of the obsolete "direct-mapped"
142 * compatible binding, which has an extra "probe-type" property
143 * describing the type of flash probe necessary. */
144 static struct mtd_info * __devinit obsolete_probe(struct platform_device *dev,
145 struct map_info *map)
147 struct device_node *dp = dev->dev.of_node;
148 const char *of_probe;
149 struct mtd_info *mtd;
150 static const char *rom_probe_types[]
151 = { "cfi_probe", "jedec_probe", "map_rom"};
154 dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" "
157 of_probe = of_get_property(dp, "probe-type", NULL);
159 for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) {
160 mtd = do_map_probe(rom_probe_types[i], map);
165 } else if (strcmp(of_probe, "CFI") == 0) {
166 return do_map_probe("cfi_probe", map);
167 } else if (strcmp(of_probe, "JEDEC") == 0) {
168 return do_map_probe("jedec_probe", map);
170 if (strcmp(of_probe, "ROM") != 0)
171 dev_warn(&dev->dev, "obsolete_probe: don't know probe "
172 "type '%s', mapping as rom\n", of_probe);
173 return do_map_probe("mtd_rom", map);
177 #ifdef CONFIG_MTD_PARTITIONS
178 /* When partitions are set we look for a linux,part-probe property which
179 specifies the list of partition probers to use. If none is given then the
180 default is use. These take precedence over other device tree
182 static const char *part_probe_types_def[] = { "cmdlinepart", "RedBoot", NULL };
183 static const char ** __devinit of_get_probes(struct device_node *dp)
191 cp = of_get_property(dp, "linux,part-probe", &cplen);
193 return part_probe_types_def;
196 for (l = 0; l != cplen; l++)
200 res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL);
212 static void __devinit of_free_probes(const char **probes)
214 if (probes != part_probe_types_def)
219 static int __devinit of_flash_probe(struct platform_device *dev,
220 const struct of_device_id *match)
222 #ifdef CONFIG_MTD_PARTITIONS
223 const char **part_probe_types;
225 struct device_node *dp = dev->dev.of_node;
227 struct of_flash *info;
228 const char *probe_type = match->data;
235 struct mtd_info **mtd_list = NULL;
236 resource_size_t res_size;
238 reg_tuple_size = (of_n_addr_cells(dp) + of_n_size_cells(dp)) * sizeof(u32);
241 * Get number of "reg" tuples. Scan for MTD devices on area's
242 * described by each "reg" region. This makes it possible (including
243 * the concat support) to support the Intel P30 48F4400 chips which
244 * consists internally of 2 non-identical NOR chips on one die.
246 p = of_get_property(dp, "reg", &count);
247 if (count % reg_tuple_size != 0) {
248 dev_err(&dev->dev, "Malformed reg property on %s\n",
249 dev->dev.of_node->full_name);
251 goto err_flash_remove;
253 count /= reg_tuple_size;
256 info = kzalloc(sizeof(struct of_flash) +
257 sizeof(struct of_flash_list) * count, GFP_KERNEL);
259 goto err_flash_remove;
261 dev_set_drvdata(&dev->dev, info);
263 mtd_list = kzalloc(sizeof(*mtd_list) * count, GFP_KERNEL);
265 goto err_flash_remove;
267 for (i = 0; i < count; i++) {
269 if (of_address_to_resource(dp, i, &res)) {
271 * Continue with next register tuple if this
272 * one is not mappable
277 dev_dbg(&dev->dev, "of_flash device: %.8llx-%.8llx\n",
278 (unsigned long long)res.start,
279 (unsigned long long)res.end);
282 res_size = resource_size(&res);
283 info->list[i].res = request_mem_region(res.start, res_size,
284 dev_name(&dev->dev));
285 if (!info->list[i].res)
289 width = of_get_property(dp, "bank-width", NULL);
291 dev_err(&dev->dev, "Can't get bank width from device"
296 info->list[i].map.name = dev_name(&dev->dev);
297 info->list[i].map.phys = res.start;
298 info->list[i].map.size = res_size;
299 info->list[i].map.bankwidth = be32_to_cpup(width);
302 info->list[i].map.virt = ioremap(info->list[i].map.phys,
303 info->list[i].map.size);
304 if (!info->list[i].map.virt) {
305 dev_err(&dev->dev, "Failed to ioremap() flash"
310 simple_map_init(&info->list[i].map);
313 info->list[i].mtd = do_map_probe(probe_type,
316 info->list[i].mtd = obsolete_probe(dev,
319 mtd_list[i] = info->list[i].mtd;
322 if (!info->list[i].mtd) {
323 dev_err(&dev->dev, "do_map_probe() failed\n");
328 info->list[i].mtd->owner = THIS_MODULE;
329 info->list[i].mtd->dev.parent = &dev->dev;
333 if (info->list_size == 1) {
334 info->cmtd = info->list[0].mtd;
335 } else if (info->list_size > 1) {
337 * We detected multiple devices. Concatenate them together.
339 #ifdef CONFIG_MTD_CONCAT
340 info->cmtd = mtd_concat_create(mtd_list, info->list_size,
341 dev_name(&dev->dev));
342 if (info->cmtd == NULL)
345 printk(KERN_ERR "physmap_of: multiple devices "
346 "found but MTD concat support disabled.\n");
353 #ifdef CONFIG_MTD_PARTITIONS
354 part_probe_types = of_get_probes(dp);
355 err = parse_mtd_partitions(info->cmtd, part_probe_types,
358 of_free_probes(part_probe_types);
361 of_free_probes(part_probe_types);
363 #ifdef CONFIG_MTD_OF_PARTS
365 err = of_mtd_parse_partitions(&dev->dev, dp, &info->parts);
372 err = parse_obsolete_partitions(dev, info, dp);
378 add_mtd_partitions(info->cmtd, info->parts, err);
381 add_mtd_device(info->cmtd);
390 of_flash_remove(dev);
395 static struct of_device_id of_flash_match[] = {
397 .compatible = "cfi-flash",
398 .data = (void *)"cfi_probe",
401 /* FIXME: JEDEC chips can't be safely and reliably
402 * probed, although the mtd code gets it right in
403 * practice most of the time. We should use the
404 * vendor and device ids specified by the binding to
405 * bypass the heuristic probe code, but the mtd layer
406 * provides, at present, no interface for doing so
408 .compatible = "jedec-flash",
409 .data = (void *)"jedec_probe",
412 .compatible = "mtd-ram",
413 .data = (void *)"map_ram",
417 .compatible = "direct-mapped"
421 MODULE_DEVICE_TABLE(of, of_flash_match);
423 static struct of_platform_driver of_flash_driver = {
426 .owner = THIS_MODULE,
427 .of_match_table = of_flash_match,
429 .probe = of_flash_probe,
430 .remove = of_flash_remove,
433 static int __init of_flash_init(void)
435 return of_register_platform_driver(&of_flash_driver);
438 static void __exit of_flash_exit(void)
440 of_unregister_platform_driver(&of_flash_driver);
443 module_init(of_flash_init);
444 module_exit(of_flash_exit);
446 MODULE_LICENSE("GPL");
447 MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
448 MODULE_DESCRIPTION("Device tree based MTD map driver");