Commit | Line | Data |
---|---|---|
a2c2fe4b VW |
1 | /* |
2 | * Normal mappings of chips in physical memory for OF devices | |
3 | * | |
4 | * Copyright (C) 2006 MontaVista Software Inc. | |
5 | * Author: Vitaly Wool <vwool@ru.mvista.com> | |
6 | * | |
2099172d DG |
7 | * Revised to handle newer style flash binding by: |
8 | * Copyright (C) 2007 David Gibson, IBM Corporation. | |
9 | * | |
a2c2fe4b VW |
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/kernel.h> | |
19 | #include <linux/init.h> | |
20 | #include <linux/slab.h> | |
21 | #include <linux/device.h> | |
22 | #include <linux/mtd/mtd.h> | |
23 | #include <linux/mtd/map.h> | |
24 | #include <linux/mtd/partitions.h> | |
25 | #include <linux/mtd/physmap.h> | |
26 | #include <asm/io.h> | |
27 | #include <asm/prom.h> | |
28 | #include <asm/of_device.h> | |
29 | #include <asm/of_platform.h> | |
30 | ||
31 | struct physmap_flash_info { | |
32 | struct mtd_info *mtd; | |
33 | struct map_info map; | |
34 | struct resource *res; | |
35 | #ifdef CONFIG_MTD_PARTITIONS | |
a2c2fe4b VW |
36 | struct mtd_partition *parts; |
37 | #endif | |
38 | }; | |
39 | ||
a2c2fe4b | 40 | #ifdef CONFIG_MTD_PARTITIONS |
2099172d DG |
41 | static int parse_obsolete_partitions(struct of_device *dev, |
42 | struct physmap_flash_info *info, | |
43 | struct device_node *dp) | |
a2c2fe4b | 44 | { |
2099172d DG |
45 | int i, plen, nr_parts; |
46 | const struct { | |
47 | u32 offset, len; | |
48 | } *part; | |
49 | const char *names; | |
a2c2fe4b | 50 | |
2099172d DG |
51 | part = of_get_property(dp, "partitions", &plen); |
52 | if (!part) | |
53 | return -ENOENT; | |
a2c2fe4b | 54 | |
2099172d DG |
55 | dev_warn(&dev->dev, "Device tree uses obsolete partition map binding\n"); |
56 | ||
57 | nr_parts = plen / sizeof(part[0]); | |
58 | ||
59 | info->parts = kzalloc(nr_parts * sizeof(struct mtd_partition), GFP_KERNEL); | |
60 | if (!info->parts) { | |
a2c2fe4b | 61 | printk(KERN_ERR "Can't allocate the flash partition data!\n"); |
2099172d | 62 | return -ENOMEM; |
a2c2fe4b VW |
63 | } |
64 | ||
2099172d | 65 | names = of_get_property(dp, "partition-names", &plen); |
a2c2fe4b | 66 | |
2099172d DG |
67 | for (i = 0; i < nr_parts; i++) { |
68 | info->parts[i].offset = part->offset; | |
69 | info->parts[i].size = part->len & ~1; | |
70 | if (part->len & 1) /* bit 0 set signifies read only partition */ | |
71 | info->parts[i].mask_flags = MTD_WRITEABLE; | |
a2c2fe4b | 72 | |
2099172d DG |
73 | if (names && (plen > 0)) { |
74 | int len = strlen(names) + 1; | |
a2c2fe4b | 75 | |
2099172d | 76 | info->parts[i].name = (char *)names; |
a2c2fe4b | 77 | plen -= len; |
2099172d DG |
78 | names += len; |
79 | } else { | |
80 | info->parts[i].name = "unnamed"; | |
81 | } | |
82 | ||
83 | part++; | |
a2c2fe4b | 84 | } |
2099172d DG |
85 | |
86 | return nr_parts; | |
a2c2fe4b | 87 | } |
2099172d DG |
88 | |
89 | static int __devinit process_partitions(struct physmap_flash_info *info, | |
90 | struct of_device *dev) | |
91 | { | |
92 | const char *partname; | |
93 | static const char *part_probe_types[] | |
94 | = { "cmdlinepart", "RedBoot", NULL }; | |
95 | struct device_node *dp = dev->node, *pp; | |
96 | int nr_parts, i; | |
97 | ||
98 | /* First look for RedBoot table or partitions on the command | |
99 | * line, these take precedence over device tree information */ | |
100 | nr_parts = parse_mtd_partitions(info->mtd, part_probe_types, | |
101 | &info->parts, 0); | |
102 | if (nr_parts > 0) { | |
103 | add_mtd_partitions(info->mtd, info->parts, nr_parts); | |
104 | return 0; | |
105 | } | |
106 | ||
107 | /* First count the subnodes */ | |
108 | nr_parts = 0; | |
109 | for (pp = dp->child; pp; pp = pp->sibling) | |
110 | nr_parts++; | |
111 | ||
112 | if (nr_parts) { | |
113 | info->parts = kzalloc(nr_parts * sizeof(struct mtd_partition), | |
114 | GFP_KERNEL); | |
115 | if (!info->parts) { | |
116 | printk(KERN_ERR "Can't allocate the flash partition data!\n"); | |
117 | return -ENOMEM; | |
118 | } | |
119 | ||
120 | for (pp = dp->child, i = 0 ; pp; pp = pp->sibling, i++) { | |
121 | const u32 *reg; | |
122 | int len; | |
123 | ||
124 | reg = of_get_property(pp, "reg", &len); | |
125 | if (!reg || (len != 2*sizeof(u32))) { | |
126 | dev_err(&dev->dev, "Invalid 'reg' on %s\n", | |
127 | dp->full_name); | |
128 | kfree(info->parts); | |
129 | info->parts = NULL; | |
130 | return -EINVAL; | |
131 | } | |
132 | info->parts[i].offset = reg[0]; | |
133 | info->parts[i].size = reg[1]; | |
134 | ||
135 | partname = of_get_property(pp, "label", &len); | |
136 | if (!partname) | |
137 | partname = of_get_property(pp, "name", &len); | |
138 | info->parts[i].name = (char *)partname; | |
139 | ||
140 | if (of_get_property(pp, "read-only", &len)) | |
141 | info->parts[i].mask_flags = MTD_WRITEABLE; | |
142 | } | |
143 | } else { | |
144 | nr_parts = parse_obsolete_partitions(dev, info, dp); | |
8d9ae994 JB |
145 | if (nr_parts == -ENOENT) |
146 | nr_parts = 0; | |
2099172d DG |
147 | } |
148 | ||
149 | if (nr_parts < 0) | |
150 | return nr_parts; | |
151 | ||
152 | if (nr_parts > 0) | |
153 | add_mtd_partitions(info->mtd, info->parts, nr_parts); | |
154 | else | |
155 | add_mtd_device(info->mtd); | |
156 | ||
157 | return 0; | |
158 | } | |
159 | #else /* MTD_PARTITIONS */ | |
160 | static int __devinit process_partitions(struct physmap_flash_info *info, | |
161 | struct device_node *dev) | |
162 | { | |
163 | add_mtd_device(info->mtd); | |
164 | return 0; | |
165 | } | |
166 | #endif /* MTD_PARTITIONS */ | |
a2c2fe4b VW |
167 | |
168 | static int of_physmap_remove(struct of_device *dev) | |
169 | { | |
170 | struct physmap_flash_info *info; | |
171 | ||
172 | info = dev_get_drvdata(&dev->dev); | |
173 | if (info == NULL) | |
174 | return 0; | |
175 | dev_set_drvdata(&dev->dev, NULL); | |
176 | ||
177 | if (info->mtd != NULL) { | |
178 | #ifdef CONFIG_MTD_PARTITIONS | |
2099172d | 179 | if (info->parts) { |
a2c2fe4b VW |
180 | del_mtd_partitions(info->mtd); |
181 | kfree(info->parts); | |
182 | } else { | |
183 | del_mtd_device(info->mtd); | |
184 | } | |
185 | #else | |
186 | del_mtd_device(info->mtd); | |
187 | #endif | |
188 | map_destroy(info->mtd); | |
189 | } | |
190 | ||
191 | if (info->map.virt != NULL) | |
192 | iounmap(info->map.virt); | |
193 | ||
194 | if (info->res != NULL) { | |
195 | release_resource(info->res); | |
196 | kfree(info->res); | |
197 | } | |
198 | ||
199 | return 0; | |
200 | } | |
201 | ||
2099172d DG |
202 | /* Helper function to handle probing of the obsolete "direct-mapped" |
203 | * compatible binding, which has an extra "probe-type" property | |
204 | * describing the type of flash probe necessary. */ | |
205 | static struct mtd_info * __devinit obsolete_probe(struct of_device *dev, | |
206 | struct map_info *map) | |
207 | { | |
208 | struct device_node *dp = dev->node; | |
209 | const char *of_probe; | |
210 | struct mtd_info *mtd; | |
211 | static const char *rom_probe_types[] | |
212 | = { "cfi_probe", "jedec_probe", "map_rom"}; | |
213 | int i; | |
214 | ||
215 | dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" " | |
216 | "flash binding\n"); | |
217 | ||
218 | of_probe = of_get_property(dp, "probe-type", NULL); | |
219 | if (!of_probe) { | |
220 | for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) { | |
221 | mtd = do_map_probe(rom_probe_types[i], map); | |
222 | if (mtd) | |
223 | return mtd; | |
224 | } | |
225 | return NULL; | |
226 | } else if (strcmp(of_probe, "CFI") == 0) { | |
227 | return do_map_probe("cfi_probe", map); | |
228 | } else if (strcmp(of_probe, "JEDEC") == 0) { | |
229 | return do_map_probe("jedec_probe", map); | |
230 | } else { | |
231 | if (strcmp(of_probe, "ROM") != 0) | |
232 | dev_dbg(&dev->dev, "obsolete_probe: don't know probe type " | |
233 | "'%s', mapping as rom\n", of_probe); | |
234 | return do_map_probe("mtd_rom", map); | |
235 | } | |
236 | } | |
237 | ||
a2c2fe4b VW |
238 | static int __devinit of_physmap_probe(struct of_device *dev, const struct of_device_id *match) |
239 | { | |
240 | struct device_node *dp = dev->node; | |
241 | struct resource res; | |
242 | struct physmap_flash_info *info; | |
2099172d | 243 | const char *probe_type = (const char *)match->data; |
a2c2fe4b VW |
244 | const u32 *width; |
245 | int err; | |
246 | ||
a2c2fe4b VW |
247 | if (of_address_to_resource(dp, 0, &res)) { |
248 | dev_err(&dev->dev, "Can't get the flash mapping!\n"); | |
249 | err = -EINVAL; | |
250 | goto err_out; | |
251 | } | |
252 | ||
253 | dev_dbg(&dev->dev, "physmap flash device: %.8llx at %.8llx\n", | |
254 | (unsigned long long)res.end - res.start + 1, | |
255 | (unsigned long long)res.start); | |
256 | ||
257 | info = kzalloc(sizeof(struct physmap_flash_info), GFP_KERNEL); | |
258 | if (info == NULL) { | |
259 | err = -ENOMEM; | |
260 | goto err_out; | |
261 | } | |
262 | memset(info, 0, sizeof(*info)); | |
263 | ||
264 | dev_set_drvdata(&dev->dev, info); | |
265 | ||
266 | info->res = request_mem_region(res.start, res.end - res.start + 1, | |
267 | dev->dev.bus_id); | |
268 | if (info->res == NULL) { | |
269 | dev_err(&dev->dev, "Could not reserve memory region\n"); | |
270 | err = -ENOMEM; | |
271 | goto err_out; | |
272 | } | |
273 | ||
40cd3a45 | 274 | width = of_get_property(dp, "bank-width", NULL); |
a2c2fe4b VW |
275 | if (width == NULL) { |
276 | dev_err(&dev->dev, "Can't get the flash bank width!\n"); | |
277 | err = -EINVAL; | |
278 | goto err_out; | |
279 | } | |
280 | ||
281 | info->map.name = dev->dev.bus_id; | |
282 | info->map.phys = res.start; | |
283 | info->map.size = res.end - res.start + 1; | |
284 | info->map.bankwidth = *width; | |
285 | ||
286 | info->map.virt = ioremap(info->map.phys, info->map.size); | |
287 | if (info->map.virt == NULL) { | |
288 | dev_err(&dev->dev, "Failed to ioremap flash region\n"); | |
289 | err = EIO; | |
290 | goto err_out; | |
291 | } | |
292 | ||
293 | simple_map_init(&info->map); | |
294 | ||
2099172d DG |
295 | if (probe_type) |
296 | info->mtd = do_map_probe(probe_type, &info->map); | |
297 | else | |
298 | info->mtd = obsolete_probe(dev, &info->map); | |
299 | ||
a2c2fe4b VW |
300 | if (info->mtd == NULL) { |
301 | dev_err(&dev->dev, "map_probe failed\n"); | |
302 | err = -ENXIO; | |
303 | goto err_out; | |
304 | } | |
305 | info->mtd->owner = THIS_MODULE; | |
306 | ||
2099172d | 307 | return process_partitions(info, dev); |
a2c2fe4b VW |
308 | |
309 | err_out: | |
310 | of_physmap_remove(dev); | |
311 | return err; | |
312 | ||
313 | return 0; | |
314 | ||
315 | ||
316 | } | |
317 | ||
318 | static struct of_device_id of_physmap_match[] = { | |
2099172d DG |
319 | { |
320 | .compatible = "cfi-flash", | |
321 | .data = (void *)"cfi_probe", | |
322 | }, | |
323 | { | |
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 | |
330 | * :(. */ | |
331 | .compatible = "jedec-flash", | |
332 | .data = (void *)"jedec_probe", | |
333 | }, | |
a2c2fe4b VW |
334 | { |
335 | .type = "rom", | |
336 | .compatible = "direct-mapped" | |
337 | }, | |
338 | { }, | |
339 | }; | |
340 | ||
341 | MODULE_DEVICE_TABLE(of, of_physmap_match); | |
342 | ||
343 | ||
344 | static struct of_platform_driver of_physmap_flash_driver = { | |
345 | .name = "physmap-flash", | |
346 | .match_table = of_physmap_match, | |
347 | .probe = of_physmap_probe, | |
348 | .remove = of_physmap_remove, | |
349 | }; | |
350 | ||
351 | static int __init of_physmap_init(void) | |
352 | { | |
353 | return of_register_platform_driver(&of_physmap_flash_driver); | |
354 | } | |
355 | ||
356 | static void __exit of_physmap_exit(void) | |
357 | { | |
358 | of_unregister_platform_driver(&of_physmap_flash_driver); | |
359 | } | |
360 | ||
361 | module_init(of_physmap_init); | |
362 | module_exit(of_physmap_exit); | |
363 | ||
364 | MODULE_LICENSE("GPL"); | |
365 | MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>"); | |
366 | MODULE_DESCRIPTION("Configurable MTD map driver for OF"); |