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