1 /*
2 * Flash mappings described by the OF (or flattened) device tree
3 *
4 * Copyright (C) 2006 MontaVista Software Inc.
5 * Author: Vitaly Wool <vwool@ru.mvista.com>
6 *
7 * Revised to handle newer style flash binding by:
8 * Copyright (C) 2007 David Gibson, IBM Corporation.
9 *
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.
14 */
15
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/of.h>
24 #include <linux/of_platform.h>
25
26 struct of_flash {
27 struct mtd_info *mtd;
28 struct map_info map;
29 struct resource *res;
30 #ifdef CONFIG_MTD_PARTITIONS
31 struct mtd_partition *parts;
32 #endif
33 };
34
35 #ifdef CONFIG_MTD_PARTITIONS
36 #define OF_FLASH_PARTS(info) ((info)->parts)
37
38 static int parse_obsolete_partitions(struct of_device *dev,
39 struct of_flash *info,
40 struct device_node *dp)
41 {
42 int i, plen, nr_parts;
43 const struct {
44 u32 offset, len;
45 } *part;
46 const char *names;
47
48 part = of_get_property(dp, "partitions", &plen);
49 if (!part)
50 return 0; /* No partitions found */
51
52 dev_warn(&dev->dev, "Device tree uses obsolete partition map binding\n");
53
54 nr_parts = plen / sizeof(part[0]);
55
56 info->parts = kzalloc(nr_parts * sizeof(*info->parts), GFP_KERNEL);
57 if (!info->parts)
58 return -ENOMEM;
59
60 names = of_get_property(dp, "partition-names", &plen);
61
62 for (i = 0; i < nr_parts; i++) {
63 info->parts[i].offset = part->offset;
64 info->parts[i].size = part->len & ~1;
65 if (part->len & 1) /* bit 0 set signifies read only partition */
66 info->parts[i].mask_flags = MTD_WRITEABLE;
67
68 if (names && (plen > 0)) {
69 int len = strlen(names) + 1;
70
71 info->parts[i].name = (char *)names;
72 plen -= len;
73 names += len;
74 } else {
75 info->parts[i].name = "unnamed";
76 }
77
78 part++;
79 }
80
81 return nr_parts;
82 }
83 #else /* MTD_PARTITIONS */
84 #define OF_FLASH_PARTS(info) (0)
85 #define parse_partitions(info, dev) (0)
86 #endif /* MTD_PARTITIONS */
87
88 static int of_flash_remove(struct of_device *dev)
89 {
90 struct of_flash *info;
91
92 info = dev_get_drvdata(&dev->dev);
93 if (!info)
94 return 0;
95 dev_set_drvdata(&dev->dev, NULL);
96
97 if (info->mtd) {
98 if (OF_FLASH_PARTS(info)) {
99 del_mtd_partitions(info->mtd);
100 kfree(OF_FLASH_PARTS(info));
101 } else {
102 del_mtd_device(info->mtd);
103 }
104 map_destroy(info->mtd);
105 }
106
107 if (info->map.virt)
108 iounmap(info->map.virt);
109
110 if (info->res) {
111 release_resource(info->res);
112 kfree(info->res);
113 }
114
115 return 0;
116 }
117
118 /* Helper function to handle probing of the obsolete "direct-mapped"
119 * compatible binding, which has an extra "probe-type" property
120 * describing the type of flash probe necessary. */
121 static struct mtd_info * __devinit obsolete_probe(struct of_device *dev,
122 struct map_info *map)
123 {
124 struct device_node *dp = dev->node;
125 const char *of_probe;
126 struct mtd_info *mtd;
127 static const char *rom_probe_types[]
128 = { "cfi_probe", "jedec_probe", "map_rom"};
129 int i;
130
131 dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" "
132 "flash binding\n");
133
134 of_probe = of_get_property(dp, "probe-type", NULL);
135 if (!of_probe) {
136 for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) {
137 mtd = do_map_probe(rom_probe_types[i], map);
138 if (mtd)
139 return mtd;
140 }
141 return NULL;
142 } else if (strcmp(of_probe, "CFI") == 0) {
143 return do_map_probe("cfi_probe", map);
144 } else if (strcmp(of_probe, "JEDEC") == 0) {
145 return do_map_probe("jedec_probe", map);
146 } else {
147 if (strcmp(of_probe, "ROM") != 0)
148 dev_warn(&dev->dev, "obsolete_probe: don't know probe "
149 "type '%s', mapping as rom\n", of_probe);
150 return do_map_probe("mtd_rom", map);
151 }
152 }
153
154 static int __devinit of_flash_probe(struct of_device *dev,
155 const struct of_device_id *match)
156 {
157 #ifdef CONFIG_MTD_PARTITIONS
158 static const char *part_probe_types[]
159 = { "cmdlinepart", "RedBoot", NULL };
160 #endif
161 struct device_node *dp = dev->node;
162 struct resource res;
163 struct of_flash *info;
164 const char *probe_type = match->data;
165 const u32 *width;
166 int err;
167
168 err = -ENXIO;
169 if (of_address_to_resource(dp, 0, &res)) {
170 dev_err(&dev->dev, "Can't get IO address from device tree\n");
171 goto err_out;
172 }
173
174 dev_dbg(&dev->dev, "of_flash device: %.8llx-%.8llx\n",
175 (unsigned long long)res.start, (unsigned long long)res.end);
176
177 err = -ENOMEM;
178 info = kzalloc(sizeof(*info), GFP_KERNEL);
179 if (!info)
180 goto err_out;
181
182 dev_set_drvdata(&dev->dev, info);
183
184 err = -EBUSY;
185 info->res = request_mem_region(res.start, res.end - res.start + 1,
186 dev->dev.bus_id);
187 if (!info->res)
188 goto err_out;
189
190 err = -ENXIO;
191 width = of_get_property(dp, "bank-width", NULL);
192 if (!width) {
193 dev_err(&dev->dev, "Can't get bank width from device tree\n");
194 goto err_out;
195 }
196
197 info->map.name = dev->dev.bus_id;
198 info->map.phys = res.start;
199 info->map.size = res.end - res.start + 1;
200 info->map.bankwidth = *width;
201
202 err = -ENOMEM;
203 info->map.virt = ioremap(info->map.phys, info->map.size);
204 if (!info->map.virt) {
205 dev_err(&dev->dev, "Failed to ioremap() flash region\n");
206 goto err_out;
207 }
208
209 simple_map_init(&info->map);
210
211 if (probe_type)
212 info->mtd = do_map_probe(probe_type, &info->map);
213 else
214 info->mtd = obsolete_probe(dev, &info->map);
215
216 err = -ENXIO;
217 if (!info->mtd) {
218 dev_err(&dev->dev, "do_map_probe() failed\n");
219 goto err_out;
220 }
221 info->mtd->owner = THIS_MODULE;
222
223 #ifdef CONFIG_MTD_PARTITIONS
224 /* First look for RedBoot table or partitions on the command
225 * line, these take precedence over device tree information */
226 err = parse_mtd_partitions(info->mtd, part_probe_types,
227 &info->parts, 0);
228 if (err < 0)
229 return err;
230
231 #ifdef CONFIG_MTD_OF_PARTS
232 if (err == 0) {
233 err = of_mtd_parse_partitions(&dev->dev, info->mtd,
234 dp, &info->parts);
235 if (err < 0)
236 return err;
237 }
238 #endif
239
240 if (err == 0) {
241 err = parse_obsolete_partitions(dev, info, dp);
242 if (err < 0)
243 return err;
244 }
245
246 if (err > 0)
247 add_mtd_partitions(info->mtd, info->parts, err);
248 else
249 #endif
250 add_mtd_device(info->mtd);
251
252 return 0;
253
254 err_out:
255 of_flash_remove(dev);
256 return err;
257 }
258
259 static struct of_device_id of_flash_match[] = {
260 {
261 .compatible = "cfi-flash",
262 .data = (void *)"cfi_probe",
263 },
264 {
265 /* FIXME: JEDEC chips can't be safely and reliably
266 * probed, although the mtd code gets it right in
267 * practice most of the time. We should use the
268 * vendor and device ids specified by the binding to
269 * bypass the heuristic probe code, but the mtd layer
270 * provides, at present, no interface for doing so
271 * :(. */
272 .compatible = "jedec-flash",
273 .data = (void *)"jedec_probe",
274 },
275 {
276 .type = "rom",
277 .compatible = "direct-mapped"
278 },
279 { },
280 };
281 MODULE_DEVICE_TABLE(of, of_flash_match);
282
283 static struct of_platform_driver of_flash_driver = {
284 .name = "of-flash",
285 .match_table = of_flash_match,
286 .probe = of_flash_probe,
287 .remove = of_flash_remove,
288 };
289
290 static int __init of_flash_init(void)
291 {
292 return of_register_platform_driver(&of_flash_driver);
293 }
294
295 static void __exit of_flash_exit(void)
296 {
297 of_unregister_platform_driver(&of_flash_driver);
298 }
299
300 module_init(of_flash_init);
301 module_exit(of_flash_exit);
302
303 MODULE_LICENSE("GPL");
304 MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
305 MODULE_DESCRIPTION("Device tree based MTD map driver");
306
|
This page was automatically generated by the
LXR engine.
|