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