?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dt-bindings: mtd: ingenic: Use standard ecc-engine property
[linux/fpc-iii.git] / drivers / mtd / maps / physmap-core.c
blobd9a3e4bebe5d8b94fea7fe983fc2db405dd729ae
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Normal mappings of chips in physical memory
4 *
5 * Copyright (C) 2003 MontaVista Software Inc.
6 * Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
7 *
8 * 031022 - [jsun] add run-time configure and partition setup
9 *
10 * Device tree support:
11 * Copyright (C) 2006 MontaVista Software Inc.
12 * Author: Vitaly Wool <vwool@ru.mvista.com>
13 *
14 * Revised to handle newer style flash binding by:
15 * Copyright (C) 2007 David Gibson, IBM Corporation.
16 *
17 * GPIO address extension:
18 * Handle the case where a flash device is mostly addressed using physical
19 * line and supplemented by GPIOs. This way you can hook up say a 8MiB flash
20 * to a 2MiB memory range and use the GPIOs to select a particular range.
21 *
22 * Copyright © 2000 Nicolas Pitre <nico@cam.org>
23 * Copyright © 2005-2009 Analog Devices Inc.
24 */
25
26 #include <linux/module.h>
27 #include <linux/types.h>
28 #include <linux/kernel.h>
29 #include <linux/init.h>
30 #include <linux/slab.h>
31 #include <linux/device.h>
32 #include <linux/platform_device.h>
33 #include <linux/mtd/mtd.h>
34 #include <linux/mtd/map.h>
35 #include <linux/mtd/partitions.h>
36 #include <linux/mtd/physmap.h>
37 #include <linux/mtd/concat.h>
38 #include <linux/mtd/cfi_endian.h>
39 #include <linux/io.h>
40 #include <linux/of_device.h>
41 #include <linux/gpio/consumer.h>
42
43 #include "physmap-gemini.h"
44 #include "physmap-versatile.h"
45
46 struct physmap_flash_info {
47 unsigned int nmaps;
48 struct mtd_info **mtds;
49 struct mtd_info *cmtd;
50 struct map_info *maps;
51 spinlock_t vpp_lock;
52 int vpp_refcnt;
53 const char *probe_type;
54 const char * const *part_types;
55 unsigned int nparts;
56 const struct mtd_partition *parts;
57 struct gpio_descs *gpios;
58 unsigned int gpio_values;
59 unsigned int win_order;
60 };
61
62 static int physmap_flash_remove(struct platform_device *dev)
63 {
64 struct physmap_flash_info *info;
65 struct physmap_flash_data *physmap_data;
66 int i, err;
67
68 info = platform_get_drvdata(dev);
69 if (!info)
70 return 0;
71
72 if (info->cmtd) {
73 err = mtd_device_unregister(info->cmtd);
74 if (err)
75 return err;
76
77 if (info->cmtd != info->mtds[0])
78 mtd_concat_destroy(info->cmtd);
79 }
80
81 for (i = 0; i < info->nmaps; i++) {
82 if (info->mtds[i])
83 map_destroy(info->mtds[i]);
84 }
85
86 physmap_data = dev_get_platdata(&dev->dev);
87 if (physmap_data && physmap_data->exit)
88 physmap_data->exit(dev);
89
90 return 0;
91 }
92
93 static void physmap_set_vpp(struct map_info *map, int state)
94 {
95 struct platform_device *pdev;
96 struct physmap_flash_data *physmap_data;
97 struct physmap_flash_info *info;
98 unsigned long flags;
99
100 pdev = (struct platform_device *)map->map_priv_1;
101 physmap_data = dev_get_platdata(&pdev->dev);
102
103 if (!physmap_data->set_vpp)
104 return;
105
106 info = platform_get_drvdata(pdev);
107
108 spin_lock_irqsave(&info->vpp_lock, flags);
109 if (state) {
110 if (++info->vpp_refcnt == 1) /* first nested 'on' */
111 physmap_data->set_vpp(pdev, 1);
112 } else {
113 if (--info->vpp_refcnt == 0) /* last nested 'off' */
114 physmap_data->set_vpp(pdev, 0);
115 }
116 spin_unlock_irqrestore(&info->vpp_lock, flags);
117 }
118
119 #if IS_ENABLED(CONFIG_MTD_PHYSMAP_GPIO_ADDR)
120 static void physmap_set_addr_gpios(struct physmap_flash_info *info,
121 unsigned long ofs)
122 {
123 unsigned int i;
124
125 ofs >>= info->win_order;
126 if (info->gpio_values == ofs)
127 return;
128
129 for (i = 0; i < info->gpios->ndescs; i++) {
130 if ((BIT(i) & ofs) == (BIT(i) & info->gpio_values))
131 continue;
132
133 gpiod_set_value(info->gpios->desc[i], !!(BIT(i) & ofs));
134 }
135 }
136
137 #define win_mask(order) (BIT(order) - 1)
138
139 static map_word physmap_addr_gpios_read(struct map_info *map,
140 unsigned long ofs)
141 {
142 struct platform_device *pdev;
143 struct physmap_flash_info *info;
144 map_word mw;
145 u16 word;
146
147 pdev = (struct platform_device *)map->map_priv_1;
148 info = platform_get_drvdata(pdev);
149 physmap_set_addr_gpios(info, ofs);
150
151 word = readw(map->virt + (ofs & win_mask(info->win_order)));
152 mw.x[0] = word;
153 return mw;
154 }
155
156 static void physmap_addr_gpios_copy_from(struct map_info *map, void *buf,
157 unsigned long ofs, ssize_t len)
158 {
159 struct platform_device *pdev;
160 struct physmap_flash_info *info;
161
162 pdev = (struct platform_device *)map->map_priv_1;
163 info = platform_get_drvdata(pdev);
164
165 while (len) {
166 unsigned int winofs = ofs & win_mask(info->win_order);
167 unsigned int chunklen = min_t(unsigned int, len,
168 BIT(info->win_order) - winofs);
169
170 physmap_set_addr_gpios(info, ofs);
171 memcpy_fromio(buf, map->virt + winofs, chunklen);
172 len -= chunklen;
173 buf += chunklen;
174 ofs += chunklen;
175 }
176 }
177
178 static void physmap_addr_gpios_write(struct map_info *map, map_word mw,
179 unsigned long ofs)
180 {
181 struct platform_device *pdev;
182 struct physmap_flash_info *info;
183 u16 word;
184
185 pdev = (struct platform_device *)map->map_priv_1;
186 info = platform_get_drvdata(pdev);
187 physmap_set_addr_gpios(info, ofs);
188
189 word = mw.x[0];
190 writew(word, map->virt + (ofs & win_mask(info->win_order)));
191 }
192
193 static void physmap_addr_gpios_copy_to(struct map_info *map, unsigned long ofs,
194 const void *buf, ssize_t len)
195 {
196 struct platform_device *pdev;
197 struct physmap_flash_info *info;
198
199 pdev = (struct platform_device *)map->map_priv_1;
200 info = platform_get_drvdata(pdev);
201
202 while (len) {
203 unsigned int winofs = ofs & win_mask(info->win_order);
204 unsigned int chunklen = min_t(unsigned int, len,
205 BIT(info->win_order) - winofs);
206
207 physmap_set_addr_gpios(info, ofs);
208 memcpy_toio(map->virt + winofs, buf, chunklen);
209 len -= chunklen;
210 buf += chunklen;
211 ofs += chunklen;
212 }
213 }
214
215 static int physmap_addr_gpios_map_init(struct map_info *map)
216 {
217 map->phys = NO_XIP;
218 map->read = physmap_addr_gpios_read;
219 map->copy_from = physmap_addr_gpios_copy_from;
220 map->write = physmap_addr_gpios_write;
221 map->copy_to = physmap_addr_gpios_copy_to;
222
223 return 0;
224 }
225 #else
226 static int physmap_addr_gpios_map_init(struct map_info *map)
227 {
228 return -ENOTSUPP;
229 }
230 #endif
231
232 #if IS_ENABLED(CONFIG_MTD_PHYSMAP_OF)
233 static const struct of_device_id of_flash_match[] = {
234 {
235 .compatible = "cfi-flash",
236 .data = "cfi_probe",
237 },
238 {
239 /*
240 * FIXME: JEDEC chips can't be safely and reliably
241 * probed, although the mtd code gets it right in
242 * practice most of the time. We should use the
243 * vendor and device ids specified by the binding to
244 * bypass the heuristic probe code, but the mtd layer
245 * provides, at present, no interface for doing so
246 * :(.
247 */
248 .compatible = "jedec-flash",
249 .data = "jedec_probe",
250 },
251 {
252 .compatible = "mtd-ram",
253 .data = "map_ram",
254 },
255 {
256 .compatible = "mtd-rom",
257 .data = "map_rom",
258 },
259 {
260 .type = "rom",
261 .compatible = "direct-mapped"
262 },
263 { /* sentinel */ },
264 };
265 MODULE_DEVICE_TABLE(of, of_flash_match);
266
267 static const char * const of_default_part_probes[] = {
268 "cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL
269 };
270
271 static const char * const *of_get_part_probes(struct platform_device *dev)
272 {
273 struct device_node *dp = dev->dev.of_node;
274 const char **res;
275 int count;
276
277 count = of_property_count_strings(dp, "linux,part-probe");
278 if (count < 0)
279 return of_default_part_probes;
280
281 res = devm_kcalloc(&dev->dev, count + 1, sizeof(*res), GFP_KERNEL);
282 if (!res)
283 return NULL;
284
285 count = of_property_read_string_array(dp, "linux,part-probe", res,
286 count);
287 if (count < 0)
288 return NULL;
289
290 return res;
291 }
292
293 static const char *of_select_probe_type(struct platform_device *dev)
294 {
295 struct device_node *dp = dev->dev.of_node;
296 const struct of_device_id *match;
297 const char *probe_type;
298
299 match = of_match_device(of_flash_match, &dev->dev);
300 probe_type = match->data;
301 if (probe_type)
302 return probe_type;
303
304 dev_warn(&dev->dev,
305 "Device tree uses obsolete \"direct-mapped\" flash binding\n");
306
307 of_property_read_string(dp, "probe-type", &probe_type);
308 if (!probe_type)
309 return NULL;
310
311 if (!strcmp(probe_type, "CFI")) {
312 probe_type = "cfi_probe";
313 } else if (!strcmp(probe_type, "JEDEC")) {
314 probe_type = "jedec_probe";
315 } else if (!strcmp(probe_type, "ROM")) {
316 probe_type = "map_rom";
317 } else {
318 dev_warn(&dev->dev,
319 "obsolete_probe: don't know probe type '%s', mapping as rom\n",
320 probe_type);
321 probe_type = "map_rom";
322 }
323
324 return probe_type;
325 }
326
327 static int physmap_flash_of_init(struct platform_device *dev)
328 {
329 struct physmap_flash_info *info = platform_get_drvdata(dev);
330 struct device_node *dp = dev->dev.of_node;
331 const char *mtd_name = NULL;
332 int err, swap = 0;
333 bool map_indirect;
334 unsigned int i;
335 u32 bankwidth;
336
337 if (!dp)
338 return -EINVAL;
339
340 info->probe_type = of_select_probe_type(dev);
341
342 info->part_types = of_get_part_probes(dev);
343 if (!info->part_types)
344 return -ENOMEM;
345
346 of_property_read_string(dp, "linux,mtd-name", &mtd_name);
347
348 map_indirect = of_property_read_bool(dp, "no-unaligned-direct-access");
349
350 err = of_property_read_u32(dp, "bank-width", &bankwidth);
351 if (err) {
352 dev_err(&dev->dev, "Can't get bank width from device tree\n");
353 return err;
354 }
355
356 if (of_property_read_bool(dp, "big-endian"))
357 swap = CFI_BIG_ENDIAN;
358 else if (of_property_read_bool(dp, "little-endian"))
359 swap = CFI_LITTLE_ENDIAN;
360
361 for (i = 0; i < info->nmaps; i++) {
362 info->maps[i].name = mtd_name;
363 info->maps[i].swap = swap;
364 info->maps[i].bankwidth = bankwidth;
365 info->maps[i].device_node = dp;
366
367 err = of_flash_probe_gemini(dev, dp, &info->maps[i]);
368 if (err)
369 return err;
370
371 err = of_flash_probe_versatile(dev, dp, &info->maps[i]);
372 if (err)
373 return err;
374
375 /*
376 * On some platforms (e.g. MPC5200) a direct 1:1 mapping
377 * may cause problems with JFFS2 usage, as the local bus (LPB)
378 * doesn't support unaligned accesses as implemented in the
379 * JFFS2 code via memcpy(). By setting NO_XIP, the
380 * flash will not be exposed directly to the MTD users
381 * (e.g. JFFS2) any more.
382 */
383 if (map_indirect)
384 info->maps[i].phys = NO_XIP;
385 }
386
387 return 0;
388 }
389 #else /* IS_ENABLED(CONFIG_MTD_PHYSMAP_OF) */
390 #define of_flash_match NULL
391
392 static int physmap_flash_of_init(struct platform_device *dev)
393 {
394 return -ENOTSUPP;
395 }
396 #endif /* IS_ENABLED(CONFIG_MTD_PHYSMAP_OF) */
397
398 static const char * const rom_probe_types[] = {
399 "cfi_probe", "jedec_probe", "qinfo_probe", "map_rom",
400 };
401
402 static const char * const part_probe_types[] = {
403 "cmdlinepart", "RedBoot", "afs", NULL
404 };
405
406 static int physmap_flash_pdata_init(struct platform_device *dev)
407 {
408 struct physmap_flash_info *info = platform_get_drvdata(dev);
409 struct physmap_flash_data *physmap_data;
410 unsigned int i;
411 int err;
412
413 physmap_data = dev_get_platdata(&dev->dev);
414 if (!physmap_data)
415 return -EINVAL;
416
417 info->probe_type = physmap_data->probe_type;
418 info->part_types = physmap_data->part_probe_types ? : part_probe_types;
419 info->parts = physmap_data->parts;
420 info->nparts = physmap_data->nr_parts;
421
422 if (physmap_data->init) {
423 err = physmap_data->init(dev);
424 if (err)
425 return err;
426 }
427
428 for (i = 0; i < info->nmaps; i++) {
429 info->maps[i].bankwidth = physmap_data->width;
430 info->maps[i].pfow_base = physmap_data->pfow_base;
431 info->maps[i].set_vpp = physmap_set_vpp;
432 }
433
434 return 0;
435 }
436
437 static int physmap_flash_probe(struct platform_device *dev)
438 {
439 struct physmap_flash_info *info;
440 int err = 0;
441 int i;
442
443 if (!dev->dev.of_node && !dev_get_platdata(&dev->dev))
444 return -EINVAL;
445
446 info = devm_kzalloc(&dev->dev, sizeof(*info), GFP_KERNEL);
447 if (!info)
448 return -ENOMEM;
449
450 while (platform_get_resource(dev, IORESOURCE_MEM, info->nmaps))
451 info->nmaps++;
452
453 if (!info->nmaps)
454 return -ENODEV;
455
456 info->maps = devm_kzalloc(&dev->dev,
457 sizeof(*info->maps) * info->nmaps,
458 GFP_KERNEL);
459 if (!info->maps)
460 return -ENOMEM;
461
462 info->mtds = devm_kzalloc(&dev->dev,
463 sizeof(*info->mtds) * info->nmaps,
464 GFP_KERNEL);
465 if (!info->mtds)
466 return -ENOMEM;
467
468 platform_set_drvdata(dev, info);
469
470 info->gpios = devm_gpiod_get_array_optional(&dev->dev, "addr",
471 GPIOD_OUT_LOW);
472 if (IS_ERR(info->gpios))
473 return PTR_ERR(info->gpios);
474
475 if (info->gpios && info->nmaps > 1) {
476 dev_err(&dev->dev, "addr-gpios only supported for nmaps == 1\n");
477 return -EINVAL;
478 }
479
480 if (dev->dev.of_node)
481 err = physmap_flash_of_init(dev);
482 else
483 err = physmap_flash_pdata_init(dev);
484
485 if (err)
486 return err;
487
488 for (i = 0; i < info->nmaps; i++) {
489 struct resource *res;
490
491 res = platform_get_resource(dev, IORESOURCE_MEM, i);
492 info->maps[i].virt = devm_ioremap_resource(&dev->dev, res);
493 if (IS_ERR(info->maps[i].virt)) {
494 err = PTR_ERR(info->maps[i].virt);
495 goto err_out;
496 }
497
498 dev_notice(&dev->dev, "physmap platform flash device: %pR\n",
499 res);
500
501 info->maps[i].name = dev_name(&dev->dev);
502
503 if (!info->maps[i].phys)
504 info->maps[i].phys = res->start;
505
506 info->win_order = get_bitmask_order(resource_size(res)) - 1;
507 info->maps[i].size = BIT(info->win_order +
508 (info->gpios ?
509 info->gpios->ndescs : 0));
510
511 info->maps[i].map_priv_1 = (unsigned long)dev;
512
513 if (info->gpios) {
514 err = physmap_addr_gpios_map_init(&info->maps[i]);
515 if (err)
516 goto err_out;
517 }
518
519 #ifdef CONFIG_MTD_COMPLEX_MAPPINGS
520 /*
521 * Only use the simple_map implementation if map hooks are not
522 * implemented. Since map->read() is mandatory checking for its
523 * presence is enough.
524 */
525 if (!info->maps[i].read)
526 simple_map_init(&info->maps[i]);
527 #else
528 simple_map_init(&info->maps[i]);
529 #endif
530
531 if (info->probe_type) {
532 info->mtds[i] = do_map_probe(info->probe_type,
533 &info->maps[i]);
534 } else {
535 int j;
536
537 for (j = 0; j < ARRAY_SIZE(rom_probe_types); j++) {
538 info->mtds[i] = do_map_probe(rom_probe_types[j],
539 &info->maps[i]);
540 if (info->mtds[i])
541 break;
542 }
543 }
544
545 if (!info->mtds[i]) {
546 dev_err(&dev->dev, "map_probe failed\n");
547 err = -ENXIO;
548 goto err_out;
549 }
550 info->mtds[i]->dev.parent = &dev->dev;
551 }
552
553 if (info->nmaps == 1) {
554 info->cmtd = info->mtds[0];
555 } else {
556 /*
557 * We detected multiple devices. Concatenate them together.
558 */
559 info->cmtd = mtd_concat_create(info->mtds, info->nmaps,
560 dev_name(&dev->dev));
561 if (!info->cmtd)
562 err = -ENXIO;
563 }
564 if (err)
565 goto err_out;
566
567 spin_lock_init(&info->vpp_lock);
568
569 mtd_set_of_node(info->cmtd, dev->dev.of_node);
570 err = mtd_device_parse_register(info->cmtd, info->part_types, NULL,
571 info->parts, info->nparts);
572 if (err)
573 goto err_out;
574
575 return 0;
576
577 err_out:
578 physmap_flash_remove(dev);
579 return err;
580 }
581
582 #ifdef CONFIG_PM
583 static void physmap_flash_shutdown(struct platform_device *dev)
584 {
585 struct physmap_flash_info *info = platform_get_drvdata(dev);
586 int i;
587
588 for (i = 0; i < info->nmaps && info->mtds[i]; i++)
589 if (mtd_suspend(info->mtds[i]) == 0)
590 mtd_resume(info->mtds[i]);
591 }
592 #else
593 #define physmap_flash_shutdown NULL
594 #endif
595
596 static struct platform_driver physmap_flash_driver = {
597 .probe = physmap_flash_probe,
598 .remove = physmap_flash_remove,
599 .shutdown = physmap_flash_shutdown,
600 .driver = {
601 .name = "physmap-flash",
602 .of_match_table = of_flash_match,
603 },
604 };
605
606 #ifdef CONFIG_MTD_PHYSMAP_COMPAT
607 static struct physmap_flash_data physmap_flash_data = {
608 .width = CONFIG_MTD_PHYSMAP_BANKWIDTH,
609 };
610
611 static struct resource physmap_flash_resource = {
612 .start = CONFIG_MTD_PHYSMAP_START,
613 .end = CONFIG_MTD_PHYSMAP_START + CONFIG_MTD_PHYSMAP_LEN - 1,
614 .flags = IORESOURCE_MEM,
615 };
616
617 static struct platform_device physmap_flash = {
618 .name = "physmap-flash",
619 .id = 0,
620 .dev = {
621 .platform_data = &physmap_flash_data,
622 },
623 .num_resources = 1,
624 .resource = &physmap_flash_resource,
625 };
626 #endif
627
628 static int __init physmap_init(void)
629 {
630 int err;
631
632 err = platform_driver_register(&physmap_flash_driver);
633 #ifdef CONFIG_MTD_PHYSMAP_COMPAT
634 if (err == 0) {
635 err = platform_device_register(&physmap_flash);
636 if (err)
637 platform_driver_unregister(&physmap_flash_driver);
638 }
639 #endif
640
641 return err;
642 }
643
644 static void __exit physmap_exit(void)
645 {
646 #ifdef CONFIG_MTD_PHYSMAP_COMPAT
647 platform_device_unregister(&physmap_flash);
648 #endif
649 platform_driver_unregister(&physmap_flash_driver);
650 }
651
652 module_init(physmap_init);
653 module_exit(physmap_exit);
654
655 MODULE_LICENSE("GPL");
656 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
657 MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
658 MODULE_AUTHOR("Mike Frysinger <vapier@gentoo.org>");
659 MODULE_DESCRIPTION("Generic configurable MTD map driver");
660
661 /* legacy platform drivers can't hotplug or coldplg */
662 #ifndef CONFIG_MTD_PHYSMAP_COMPAT
663 /* work with hotplug and coldplug */
664 MODULE_ALIAS("platform:physmap-flash");
665 #endif
Linux with added FPC-III support