mtd: physmap_of: add a hook for Gemini flash probing
[linux-2.6-microblaze.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/device.h>
19 #include <linux/mtd/mtd.h>
20 #include <linux/mtd/map.h>
21 #include <linux/mtd/partitions.h>
22 #include <linux/mtd/concat.h>
23 #include <linux/of.h>
24 #include <linux/of_address.h>
25 #include <linux/of_platform.h>
26 #include <linux/slab.h>
27 #include "physmap_of_gemini.h"
28 #include "physmap_of_versatile.h"
29
30 struct of_flash_list {
31         struct mtd_info *mtd;
32         struct map_info map;
33         struct resource *res;
34 };
35
36 struct of_flash {
37         struct mtd_info         *cmtd;
38         int list_size; /* number of elements in of_flash_list */
39         struct of_flash_list    list[0];
40 };
41
42 static int of_flash_remove(struct platform_device *dev)
43 {
44         struct of_flash *info;
45         int i;
46
47         info = dev_get_drvdata(&dev->dev);
48         if (!info)
49                 return 0;
50         dev_set_drvdata(&dev->dev, NULL);
51
52         if (info->cmtd) {
53                 mtd_device_unregister(info->cmtd);
54                 if (info->cmtd != info->list[0].mtd)
55                         mtd_concat_destroy(info->cmtd);
56         }
57
58         for (i = 0; i < info->list_size; i++) {
59                 if (info->list[i].mtd)
60                         map_destroy(info->list[i].mtd);
61
62                 if (info->list[i].map.virt)
63                         iounmap(info->list[i].map.virt);
64
65                 if (info->list[i].res) {
66                         release_resource(info->list[i].res);
67                         kfree(info->list[i].res);
68                 }
69         }
70         return 0;
71 }
72
73 static const char * const rom_probe_types[] = {
74         "cfi_probe", "jedec_probe", "map_rom" };
75
76 /* Helper function to handle probing of the obsolete "direct-mapped"
77  * compatible binding, which has an extra "probe-type" property
78  * describing the type of flash probe necessary. */
79 static struct mtd_info *obsolete_probe(struct platform_device *dev,
80                                        struct map_info *map)
81 {
82         struct device_node *dp = dev->dev.of_node;
83         const char *of_probe;
84         struct mtd_info *mtd;
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("map_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 * const part_probe_types_def[] = {
115         "cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL };
116
117 static const char * const *of_get_probes(struct device_node *dp)
118 {
119         const char *cp;
120         int cplen;
121         unsigned int l;
122         unsigned int count;
123         const char **res;
124
125         cp = of_get_property(dp, "linux,part-probe", &cplen);
126         if (cp == NULL)
127                 return part_probe_types_def;
128
129         count = 0;
130         for (l = 0; l != cplen; l++)
131                 if (cp[l] == 0)
132                         count++;
133
134         res = kzalloc((count + 1)*sizeof(*res), GFP_KERNEL);
135         if (!res)
136                 return NULL;
137         count = 0;
138         while (cplen > 0) {
139                 res[count] = cp;
140                 l = strlen(cp) + 1;
141                 cp += l;
142                 cplen -= l;
143                 count++;
144         }
145         return res;
146 }
147
148 static void of_free_probes(const char * const *probes)
149 {
150         if (probes != part_probe_types_def)
151                 kfree(probes);
152 }
153
154 static const struct of_device_id of_flash_match[];
155 static int of_flash_probe(struct platform_device *dev)
156 {
157         const char * const *part_probe_types;
158         const struct of_device_id *match;
159         struct device_node *dp = dev->dev.of_node;
160         struct resource res;
161         struct of_flash *info;
162         const char *probe_type;
163         const __be32 *width;
164         int err;
165         int i;
166         int count;
167         const __be32 *p;
168         int reg_tuple_size;
169         struct mtd_info **mtd_list = NULL;
170         resource_size_t res_size;
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 (!p || 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 = of_flash_probe_gemini(dev, dp, &info->list[i].map);
247                 if (err)
248                         return err;
249                 err = of_flash_probe_versatile(dev, dp, &info->list[i].map);
250                 if (err)
251                         return err;
252
253                 err = -ENOMEM;
254                 info->list[i].map.virt = ioremap(info->list[i].map.phys,
255                                                  info->list[i].map.size);
256                 if (!info->list[i].map.virt) {
257                         dev_err(&dev->dev, "Failed to ioremap() flash"
258                                 " region\n");
259                         goto err_out;
260                 }
261
262                 simple_map_init(&info->list[i].map);
263
264                 /*
265                  * On some platforms (e.g. MPC5200) a direct 1:1 mapping
266                  * may cause problems with JFFS2 usage, as the local bus (LPB)
267                  * doesn't support unaligned accesses as implemented in the
268                  * JFFS2 code via memcpy(). By setting NO_XIP, the
269                  * flash will not be exposed directly to the MTD users
270                  * (e.g. JFFS2) any more.
271                  */
272                 if (map_indirect)
273                         info->list[i].map.phys = NO_XIP;
274
275                 if (probe_type) {
276                         info->list[i].mtd = do_map_probe(probe_type,
277                                                          &info->list[i].map);
278                 } else {
279                         info->list[i].mtd = obsolete_probe(dev,
280                                                            &info->list[i].map);
281                 }
282
283                 /* Fall back to mapping region as ROM */
284                 if (!info->list[i].mtd) {
285                         dev_warn(&dev->dev,
286                                 "do_map_probe() failed for type %s\n",
287                                  probe_type);
288
289                         info->list[i].mtd = do_map_probe("map_rom",
290                                                          &info->list[i].map);
291                 }
292                 mtd_list[i] = info->list[i].mtd;
293
294                 err = -ENXIO;
295                 if (!info->list[i].mtd) {
296                         dev_err(&dev->dev, "do_map_probe() failed\n");
297                         goto err_out;
298                 } else {
299                         info->list_size++;
300                 }
301                 info->list[i].mtd->dev.parent = &dev->dev;
302         }
303
304         err = 0;
305         info->cmtd = NULL;
306         if (info->list_size == 1) {
307                 info->cmtd = info->list[0].mtd;
308         } else if (info->list_size > 1) {
309                 /*
310                  * We detected multiple devices. Concatenate them together.
311                  */
312                 info->cmtd = mtd_concat_create(mtd_list, info->list_size,
313                                                dev_name(&dev->dev));
314         }
315         if (info->cmtd == NULL)
316                 err = -ENXIO;
317
318         if (err)
319                 goto err_out;
320
321         info->cmtd->dev.parent = &dev->dev;
322         mtd_set_of_node(info->cmtd, dp);
323         part_probe_types = of_get_probes(dp);
324         if (!part_probe_types) {
325                 err = -ENOMEM;
326                 goto err_out;
327         }
328         mtd_device_parse_register(info->cmtd, part_probe_types, NULL,
329                         NULL, 0);
330         of_free_probes(part_probe_types);
331
332         kfree(mtd_list);
333
334         return 0;
335
336 err_out:
337         kfree(mtd_list);
338 err_flash_remove:
339         of_flash_remove(dev);
340
341         return err;
342 }
343
344 static const struct of_device_id of_flash_match[] = {
345         {
346                 .compatible     = "cfi-flash",
347                 .data           = (void *)"cfi_probe",
348         },
349         {
350                 /* FIXME: JEDEC chips can't be safely and reliably
351                  * probed, although the mtd code gets it right in
352                  * practice most of the time.  We should use the
353                  * vendor and device ids specified by the binding to
354                  * bypass the heuristic probe code, but the mtd layer
355                  * provides, at present, no interface for doing so
356                  * :(. */
357                 .compatible     = "jedec-flash",
358                 .data           = (void *)"jedec_probe",
359         },
360         {
361                 .compatible     = "mtd-ram",
362                 .data           = (void *)"map_ram",
363         },
364         {
365                 .compatible     = "mtd-rom",
366                 .data           = (void *)"map_rom",
367         },
368         {
369                 .type           = "rom",
370                 .compatible     = "direct-mapped"
371         },
372         { },
373 };
374 MODULE_DEVICE_TABLE(of, of_flash_match);
375
376 static struct platform_driver of_flash_driver = {
377         .driver = {
378                 .name = "of-flash",
379                 .of_match_table = of_flash_match,
380         },
381         .probe          = of_flash_probe,
382         .remove         = of_flash_remove,
383 };
384
385 module_platform_driver(of_flash_driver);
386
387 MODULE_LICENSE("GPL");
388 MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
389 MODULE_DESCRIPTION("Device tree based MTD map driver");