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/mtd/concat.h>
24 #include <linux/of.h>
25 #include <linux/of_address.h>
26 #include <linux/of_platform.h>
27 #include <linux/slab.h>
28
29 struct of_flash_list {
30 struct mtd_info *mtd;
31 struct map_info map;
32 struct resource *res;
33 };
34
35 struct of_flash {
36 struct mtd_info *cmtd;
37 int list_size; /* number of elements in of_flash_list */
38 struct of_flash_list list[0];
39 };
40
of_flash_remove(struct platform_device * dev)41 static int of_flash_remove(struct platform_device *dev)
42 {
43 struct of_flash *info;
44 int i;
45
46 info = dev_get_drvdata(&dev->dev);
47 if (!info)
48 return 0;
49 dev_set_drvdata(&dev->dev, NULL);
50
51 if (info->cmtd != info->list[0].mtd) {
52 mtd_device_unregister(info->cmtd);
53 mtd_concat_destroy(info->cmtd);
54 }
55
56 if (info->cmtd)
57 mtd_device_unregister(info->cmtd);
58
59 for (i = 0; i < info->list_size; i++) {
60 if (info->list[i].mtd)
61 map_destroy(info->list[i].mtd);
62
63 if (info->list[i].map.virt)
64 iounmap(info->list[i].map.virt);
65
66 if (info->list[i].res) {
67 release_resource(info->list[i].res);
68 kfree(info->list[i].res);
69 }
70 }
71 return 0;
72 }
73
74 static const char * const rom_probe_types[] = {
75 "cfi_probe", "jedec_probe", "map_rom" };
76
77 /* Helper function to handle probing of the obsolete "direct-mapped"
78 * compatible binding, which has an extra "probe-type" property
79 * describing the type of flash probe necessary. */
obsolete_probe(struct platform_device * dev,struct map_info * map)80 static struct mtd_info *obsolete_probe(struct platform_device *dev,
81 struct map_info *map)
82 {
83 struct device_node *dp = dev->dev.of_node;
84 const char *of_probe;
85 struct mtd_info *mtd;
86 int i;
87
88 dev_warn(&dev->dev, "Device tree uses obsolete \"direct-mapped\" "
89 "flash binding\n");
90
91 of_probe = of_get_property(dp, "probe-type", NULL);
92 if (!of_probe) {
93 for (i = 0; i < ARRAY_SIZE(rom_probe_types); i++) {
94 mtd = do_map_probe(rom_probe_types[i], map);
95 if (mtd)
96 return mtd;
97 }
98 return NULL;
99 } else if (strcmp(of_probe, "CFI") == 0) {
100 return do_map_probe("cfi_probe", map);
101 } else if (strcmp(of_probe, "JEDEC") == 0) {
102 return do_map_probe("jedec_probe", map);
103 } else {
104 if (strcmp(of_probe, "ROM") != 0)
105 dev_warn(&dev->dev, "obsolete_probe: don't know probe "
106 "type '%s', mapping as rom\n", of_probe);
107 return do_map_probe("mtd_rom", map);
108 }
109 }
110
111 /* When partitions are set we look for a linux,part-probe property which
112 specifies the list of partition probers to use. If none is given then the
113 default is use. These take precedence over other device tree
114 information. */
115 static const char * const part_probe_types_def[] = {
116 "cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL };
117
of_get_probes(struct device_node * dp)118 static const char * const *of_get_probes(struct device_node *dp)
119 {
120 const char *cp;
121 int cplen;
122 unsigned int l;
123 unsigned int count;
124 const char **res;
125
126 cp = of_get_property(dp, "linux,part-probe", &cplen);
127 if (cp == NULL)
128 return part_probe_types_def;
129
130 count = 0;
131 for (l = 0; l != cplen; l++)
132 if (cp[l] == 0)
133 count++;
134
135 res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL);
136 count = 0;
137 while (cplen > 0) {
138 res[count] = cp;
139 l = strlen(cp) + 1;
140 cp += l;
141 cplen -= l;
142 count++;
143 }
144 return res;
145 }
146
of_free_probes(const char * const * probes)147 static void of_free_probes(const char * const *probes)
148 {
149 if (probes != part_probe_types_def)
150 kfree(probes);
151 }
152
153 static struct of_device_id of_flash_match[];
of_flash_probe(struct platform_device * dev)154 static int of_flash_probe(struct platform_device *dev)
155 {
156 const char * const *part_probe_types;
157 const struct of_device_id *match;
158 struct device_node *dp = dev->dev.of_node;
159 struct resource res;
160 struct of_flash *info;
161 const char *probe_type;
162 const __be32 *width;
163 int err;
164 int i;
165 int count;
166 const __be32 *p;
167 int reg_tuple_size;
168 struct mtd_info **mtd_list = NULL;
169 resource_size_t res_size;
170 struct mtd_part_parser_data ppdata;
171 bool map_indirect;
172 const char *mtd_name = NULL;
173
174 match = of_match_device(of_flash_match, &dev->dev);
175 if (!match)
176 return -EINVAL;
177 probe_type = match->data;
178
179 reg_tuple_size = (of_n_addr_cells(dp) + of_n_size_cells(dp)) * sizeof(u32);
180
181 of_property_read_string(dp, "linux,mtd-name", &mtd_name);
182
183 /*
184 * Get number of "reg" tuples. Scan for MTD devices on area's
185 * described by each "reg" region. This makes it possible (including
186 * the concat support) to support the Intel P30 48F4400 chips which
187 * consists internally of 2 non-identical NOR chips on one die.
188 */
189 p = of_get_property(dp, "reg", &count);
190 if (count % reg_tuple_size != 0) {
191 dev_err(&dev->dev, "Malformed reg property on %s\n",
192 dev->dev.of_node->full_name);
193 err = -EINVAL;
194 goto err_flash_remove;
195 }
196 count /= reg_tuple_size;
197
198 map_indirect = of_property_read_bool(dp, "no-unaligned-direct-access");
199
200 err = -ENOMEM;
201 info = devm_kzalloc(&dev->dev,
202 sizeof(struct of_flash) +
203 sizeof(struct of_flash_list) * count, GFP_KERNEL);
204 if (!info)
205 goto err_flash_remove;
206
207 dev_set_drvdata(&dev->dev, info);
208
209 mtd_list = kzalloc(sizeof(*mtd_list) * count, GFP_KERNEL);
210 if (!mtd_list)
211 goto err_flash_remove;
212
213 for (i = 0; i < count; i++) {
214 err = -ENXIO;
215 if (of_address_to_resource(dp, i, &res)) {
216 /*
217 * Continue with next register tuple if this
218 * one is not mappable
219 */
220 continue;
221 }
222
223 dev_dbg(&dev->dev, "of_flash device: %pR\n", &res);
224
225 err = -EBUSY;
226 res_size = resource_size(&res);
227 info->list[i].res = request_mem_region(res.start, res_size,
228 dev_name(&dev->dev));
229 if (!info->list[i].res)
230 goto err_out;
231
232 err = -ENXIO;
233 width = of_get_property(dp, "bank-width", NULL);
234 if (!width) {
235 dev_err(&dev->dev, "Can't get bank width from device"
236 " tree\n");
237 goto err_out;
238 }
239
240 info->list[i].map.name = mtd_name ?: dev_name(&dev->dev);
241 info->list[i].map.phys = res.start;
242 info->list[i].map.size = res_size;
243 info->list[i].map.bankwidth = be32_to_cpup(width);
244 info->list[i].map.device_node = dp;
245
246 err = -ENOMEM;
247 info->list[i].map.virt = ioremap(info->list[i].map.phys,
248 info->list[i].map.size);
249 if (!info->list[i].map.virt) {
250 dev_err(&dev->dev, "Failed to ioremap() flash"
251 " region\n");
252 goto err_out;
253 }
254
255 simple_map_init(&info->list[i].map);
256
257 /*
258 * On some platforms (e.g. MPC5200) a direct 1:1 mapping
259 * may cause problems with JFFS2 usage, as the local bus (LPB)
260 * doesn't support unaligned accesses as implemented in the
261 * JFFS2 code via memcpy(). By setting NO_XIP, the
262 * flash will not be exposed directly to the MTD users
263 * (e.g. JFFS2) any more.
264 */
265 if (map_indirect)
266 info->list[i].map.phys = NO_XIP;
267
268 if (probe_type) {
269 info->list[i].mtd = do_map_probe(probe_type,
270 &info->list[i].map);
271 } else {
272 info->list[i].mtd = obsolete_probe(dev,
273 &info->list[i].map);
274 }
275 mtd_list[i] = info->list[i].mtd;
276
277 err = -ENXIO;
278 if (!info->list[i].mtd) {
279 dev_err(&dev->dev, "do_map_probe() failed\n");
280 goto err_out;
281 } else {
282 info->list_size++;
283 }
284 info->list[i].mtd->owner = THIS_MODULE;
285 info->list[i].mtd->dev.parent = &dev->dev;
286 }
287
288 err = 0;
289 info->cmtd = NULL;
290 if (info->list_size == 1) {
291 info->cmtd = info->list[0].mtd;
292 } else if (info->list_size > 1) {
293 /*
294 * We detected multiple devices. Concatenate them together.
295 */
296 info->cmtd = mtd_concat_create(mtd_list, info->list_size,
297 dev_name(&dev->dev));
298 }
299 if (info->cmtd == NULL)
300 err = -ENXIO;
301
302 if (err)
303 goto err_out;
304
305 ppdata.of_node = dp;
306 part_probe_types = of_get_probes(dp);
307 mtd_device_parse_register(info->cmtd, part_probe_types, &ppdata,
308 NULL, 0);
309 of_free_probes(part_probe_types);
310
311 kfree(mtd_list);
312
313 return 0;
314
315 err_out:
316 kfree(mtd_list);
317 err_flash_remove:
318 of_flash_remove(dev);
319
320 return err;
321 }
322
323 static struct of_device_id of_flash_match[] = {
324 {
325 .compatible = "cfi-flash",
326 .data = (void *)"cfi_probe",
327 },
328 {
329 /* FIXME: JEDEC chips can't be safely and reliably
330 * probed, although the mtd code gets it right in
331 * practice most of the time. We should use the
332 * vendor and device ids specified by the binding to
333 * bypass the heuristic probe code, but the mtd layer
334 * provides, at present, no interface for doing so
335 * :(. */
336 .compatible = "jedec-flash",
337 .data = (void *)"jedec_probe",
338 },
339 {
340 .compatible = "mtd-ram",
341 .data = (void *)"map_ram",
342 },
343 {
344 .type = "rom",
345 .compatible = "direct-mapped"
346 },
347 { },
348 };
349 MODULE_DEVICE_TABLE(of, of_flash_match);
350
351 static struct platform_driver of_flash_driver = {
352 .driver = {
353 .name = "of-flash",
354 .owner = THIS_MODULE,
355 .of_match_table = of_flash_match,
356 },
357 .probe = of_flash_probe,
358 .remove = of_flash_remove,
359 };
360
361 module_platform_driver(of_flash_driver);
362
363 MODULE_LICENSE("GPL");
364 MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
365 MODULE_DESCRIPTION("Device tree based MTD map driver");
366