This source file includes following definitions.
- physmap_flash_remove
- physmap_set_vpp
- physmap_set_addr_gpios
- physmap_addr_gpios_read
- physmap_addr_gpios_copy_from
- physmap_addr_gpios_write
- physmap_addr_gpios_copy_to
- physmap_addr_gpios_map_init
- physmap_addr_gpios_map_init
- of_get_part_probes
- of_select_probe_type
- physmap_flash_of_init
- physmap_flash_of_init
- physmap_flash_pdata_init
- physmap_flash_probe
- physmap_flash_shutdown
- physmap_init
- physmap_exit
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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)
111 physmap_data->set_vpp(pdev, 1);
112 } else {
113 if (--info->vpp_refcnt == 0)
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 info->gpio_values = ofs;
137 }
138
139 #define win_mask(order) (BIT(order) - 1)
140
141 static map_word physmap_addr_gpios_read(struct map_info *map,
142 unsigned long ofs)
143 {
144 struct platform_device *pdev;
145 struct physmap_flash_info *info;
146 map_word mw;
147 u16 word;
148
149 pdev = (struct platform_device *)map->map_priv_1;
150 info = platform_get_drvdata(pdev);
151 physmap_set_addr_gpios(info, ofs);
152
153 word = readw(map->virt + (ofs & win_mask(info->win_order)));
154 mw.x[0] = word;
155 return mw;
156 }
157
158 static void physmap_addr_gpios_copy_from(struct map_info *map, void *buf,
159 unsigned long ofs, ssize_t len)
160 {
161 struct platform_device *pdev;
162 struct physmap_flash_info *info;
163
164 pdev = (struct platform_device *)map->map_priv_1;
165 info = platform_get_drvdata(pdev);
166
167 while (len) {
168 unsigned int winofs = ofs & win_mask(info->win_order);
169 unsigned int chunklen = min_t(unsigned int, len,
170 BIT(info->win_order) - winofs);
171
172 physmap_set_addr_gpios(info, ofs);
173 memcpy_fromio(buf, map->virt + winofs, chunklen);
174 len -= chunklen;
175 buf += chunklen;
176 ofs += chunklen;
177 }
178 }
179
180 static void physmap_addr_gpios_write(struct map_info *map, map_word mw,
181 unsigned long ofs)
182 {
183 struct platform_device *pdev;
184 struct physmap_flash_info *info;
185 u16 word;
186
187 pdev = (struct platform_device *)map->map_priv_1;
188 info = platform_get_drvdata(pdev);
189 physmap_set_addr_gpios(info, ofs);
190
191 word = mw.x[0];
192 writew(word, map->virt + (ofs & win_mask(info->win_order)));
193 }
194
195 static void physmap_addr_gpios_copy_to(struct map_info *map, unsigned long ofs,
196 const void *buf, ssize_t len)
197 {
198 struct platform_device *pdev;
199 struct physmap_flash_info *info;
200
201 pdev = (struct platform_device *)map->map_priv_1;
202 info = platform_get_drvdata(pdev);
203
204 while (len) {
205 unsigned int winofs = ofs & win_mask(info->win_order);
206 unsigned int chunklen = min_t(unsigned int, len,
207 BIT(info->win_order) - winofs);
208
209 physmap_set_addr_gpios(info, ofs);
210 memcpy_toio(map->virt + winofs, buf, chunklen);
211 len -= chunklen;
212 buf += chunklen;
213 ofs += chunklen;
214 }
215 }
216
217 static int physmap_addr_gpios_map_init(struct map_info *map)
218 {
219 map->phys = NO_XIP;
220 map->read = physmap_addr_gpios_read;
221 map->copy_from = physmap_addr_gpios_copy_from;
222 map->write = physmap_addr_gpios_write;
223 map->copy_to = physmap_addr_gpios_copy_to;
224
225 return 0;
226 }
227 #else
228 static int physmap_addr_gpios_map_init(struct map_info *map)
229 {
230 return -ENOTSUPP;
231 }
232 #endif
233
234 #if IS_ENABLED(CONFIG_MTD_PHYSMAP_OF)
235 static const struct of_device_id of_flash_match[] = {
236 {
237 .compatible = "cfi-flash",
238 .data = "cfi_probe",
239 },
240 {
241
242
243
244
245
246
247
248
249
250 .compatible = "jedec-flash",
251 .data = "jedec_probe",
252 },
253 {
254 .compatible = "mtd-ram",
255 .data = "map_ram",
256 },
257 {
258 .compatible = "mtd-rom",
259 .data = "map_rom",
260 },
261 {
262 .type = "rom",
263 .compatible = "direct-mapped"
264 },
265 { },
266 };
267 MODULE_DEVICE_TABLE(of, of_flash_match);
268
269 static const char * const of_default_part_probes[] = {
270 "cmdlinepart", "RedBoot", "ofpart", "ofoldpart", NULL
271 };
272
273 static const char * const *of_get_part_probes(struct platform_device *dev)
274 {
275 struct device_node *dp = dev->dev.of_node;
276 const char **res;
277 int count;
278
279 count = of_property_count_strings(dp, "linux,part-probe");
280 if (count < 0)
281 return of_default_part_probes;
282
283 res = devm_kcalloc(&dev->dev, count + 1, sizeof(*res), GFP_KERNEL);
284 if (!res)
285 return NULL;
286
287 count = of_property_read_string_array(dp, "linux,part-probe", res,
288 count);
289 if (count < 0)
290 return NULL;
291
292 return res;
293 }
294
295 static const char *of_select_probe_type(struct platform_device *dev)
296 {
297 struct device_node *dp = dev->dev.of_node;
298 const struct of_device_id *match;
299 const char *probe_type;
300
301 match = of_match_device(of_flash_match, &dev->dev);
302 probe_type = match->data;
303 if (probe_type)
304 return probe_type;
305
306 dev_warn(&dev->dev,
307 "Device tree uses obsolete \"direct-mapped\" flash binding\n");
308
309 of_property_read_string(dp, "probe-type", &probe_type);
310 if (!probe_type)
311 return NULL;
312
313 if (!strcmp(probe_type, "CFI")) {
314 probe_type = "cfi_probe";
315 } else if (!strcmp(probe_type, "JEDEC")) {
316 probe_type = "jedec_probe";
317 } else if (!strcmp(probe_type, "ROM")) {
318 probe_type = "map_rom";
319 } else {
320 dev_warn(&dev->dev,
321 "obsolete_probe: don't know probe type '%s', mapping as rom\n",
322 probe_type);
323 probe_type = "map_rom";
324 }
325
326 return probe_type;
327 }
328
329 static int physmap_flash_of_init(struct platform_device *dev)
330 {
331 struct physmap_flash_info *info = platform_get_drvdata(dev);
332 struct device_node *dp = dev->dev.of_node;
333 const char *mtd_name = NULL;
334 int err, swap = 0;
335 bool map_indirect;
336 unsigned int i;
337 u32 bankwidth;
338
339 if (!dp)
340 return -EINVAL;
341
342 info->probe_type = of_select_probe_type(dev);
343
344 info->part_types = of_get_part_probes(dev);
345 if (!info->part_types)
346 return -ENOMEM;
347
348 of_property_read_string(dp, "linux,mtd-name", &mtd_name);
349
350 map_indirect = of_property_read_bool(dp, "no-unaligned-direct-access");
351
352 err = of_property_read_u32(dp, "bank-width", &bankwidth);
353 if (err) {
354 dev_err(&dev->dev, "Can't get bank width from device tree\n");
355 return err;
356 }
357
358 if (of_property_read_bool(dp, "big-endian"))
359 swap = CFI_BIG_ENDIAN;
360 else if (of_property_read_bool(dp, "little-endian"))
361 swap = CFI_LITTLE_ENDIAN;
362
363 for (i = 0; i < info->nmaps; i++) {
364 info->maps[i].name = mtd_name;
365 info->maps[i].swap = swap;
366 info->maps[i].bankwidth = bankwidth;
367 info->maps[i].device_node = dp;
368
369 err = of_flash_probe_gemini(dev, dp, &info->maps[i]);
370 if (err)
371 return err;
372
373 err = of_flash_probe_versatile(dev, dp, &info->maps[i]);
374 if (err)
375 return err;
376
377
378
379
380
381
382
383
384
385 if (map_indirect)
386 info->maps[i].phys = NO_XIP;
387 }
388
389 return 0;
390 }
391 #else
392 #define of_flash_match NULL
393
394 static int physmap_flash_of_init(struct platform_device *dev)
395 {
396 return -ENOTSUPP;
397 }
398 #endif
399
400 static const char * const rom_probe_types[] = {
401 "cfi_probe", "jedec_probe", "qinfo_probe", "map_rom",
402 };
403
404 static const char * const part_probe_types[] = {
405 "cmdlinepart", "RedBoot", "afs", NULL
406 };
407
408 static int physmap_flash_pdata_init(struct platform_device *dev)
409 {
410 struct physmap_flash_info *info = platform_get_drvdata(dev);
411 struct physmap_flash_data *physmap_data;
412 unsigned int i;
413 int err;
414
415 physmap_data = dev_get_platdata(&dev->dev);
416 if (!physmap_data)
417 return -EINVAL;
418
419 info->probe_type = physmap_data->probe_type;
420 info->part_types = physmap_data->part_probe_types ? : part_probe_types;
421 info->parts = physmap_data->parts;
422 info->nparts = physmap_data->nr_parts;
423
424 if (physmap_data->init) {
425 err = physmap_data->init(dev);
426 if (err)
427 return err;
428 }
429
430 for (i = 0; i < info->nmaps; i++) {
431 info->maps[i].bankwidth = physmap_data->width;
432 info->maps[i].pfow_base = physmap_data->pfow_base;
433 info->maps[i].set_vpp = physmap_set_vpp;
434 }
435
436 return 0;
437 }
438
439 static int physmap_flash_probe(struct platform_device *dev)
440 {
441 struct physmap_flash_info *info;
442 int err = 0;
443 int i;
444
445 if (!dev->dev.of_node && !dev_get_platdata(&dev->dev))
446 return -EINVAL;
447
448 info = devm_kzalloc(&dev->dev, sizeof(*info), GFP_KERNEL);
449 if (!info)
450 return -ENOMEM;
451
452 while (platform_get_resource(dev, IORESOURCE_MEM, info->nmaps))
453 info->nmaps++;
454
455 if (!info->nmaps)
456 return -ENODEV;
457
458 info->maps = devm_kzalloc(&dev->dev,
459 sizeof(*info->maps) * info->nmaps,
460 GFP_KERNEL);
461 if (!info->maps)
462 return -ENOMEM;
463
464 info->mtds = devm_kzalloc(&dev->dev,
465 sizeof(*info->mtds) * info->nmaps,
466 GFP_KERNEL);
467 if (!info->mtds)
468 return -ENOMEM;
469
470 platform_set_drvdata(dev, info);
471
472 info->gpios = devm_gpiod_get_array_optional(&dev->dev, "addr",
473 GPIOD_OUT_LOW);
474 if (IS_ERR(info->gpios))
475 return PTR_ERR(info->gpios);
476
477 if (info->gpios && info->nmaps > 1) {
478 dev_err(&dev->dev, "addr-gpios only supported for nmaps == 1\n");
479 return -EINVAL;
480 }
481
482 if (dev->dev.of_node)
483 err = physmap_flash_of_init(dev);
484 else
485 err = physmap_flash_pdata_init(dev);
486
487 if (err)
488 return err;
489
490 for (i = 0; i < info->nmaps; i++) {
491 struct resource *res;
492
493 res = platform_get_resource(dev, IORESOURCE_MEM, i);
494 info->maps[i].virt = devm_ioremap_resource(&dev->dev, res);
495 if (IS_ERR(info->maps[i].virt)) {
496 err = PTR_ERR(info->maps[i].virt);
497 goto err_out;
498 }
499
500 dev_notice(&dev->dev, "physmap platform flash device: %pR\n",
501 res);
502
503 info->maps[i].name = dev_name(&dev->dev);
504
505 if (!info->maps[i].phys)
506 info->maps[i].phys = res->start;
507
508 info->win_order = get_bitmask_order(resource_size(res)) - 1;
509 info->maps[i].size = BIT(info->win_order +
510 (info->gpios ?
511 info->gpios->ndescs : 0));
512
513 info->maps[i].map_priv_1 = (unsigned long)dev;
514
515 if (info->gpios) {
516 err = physmap_addr_gpios_map_init(&info->maps[i]);
517 if (err)
518 goto err_out;
519 }
520
521 #ifdef CONFIG_MTD_COMPLEX_MAPPINGS
522
523
524
525
526
527 if (!info->maps[i].read)
528 simple_map_init(&info->maps[i]);
529 #else
530 simple_map_init(&info->maps[i]);
531 #endif
532
533 if (info->probe_type) {
534 info->mtds[i] = do_map_probe(info->probe_type,
535 &info->maps[i]);
536 } else {
537 int j;
538
539 for (j = 0; j < ARRAY_SIZE(rom_probe_types); j++) {
540 info->mtds[i] = do_map_probe(rom_probe_types[j],
541 &info->maps[i]);
542 if (info->mtds[i])
543 break;
544 }
545 }
546
547 if (!info->mtds[i]) {
548 dev_err(&dev->dev, "map_probe failed\n");
549 err = -ENXIO;
550 goto err_out;
551 }
552 info->mtds[i]->dev.parent = &dev->dev;
553 }
554
555 if (info->nmaps == 1) {
556 info->cmtd = info->mtds[0];
557 } else {
558
559
560
561 info->cmtd = mtd_concat_create(info->mtds, info->nmaps,
562 dev_name(&dev->dev));
563 if (!info->cmtd)
564 err = -ENXIO;
565 }
566 if (err)
567 goto err_out;
568
569 spin_lock_init(&info->vpp_lock);
570
571 mtd_set_of_node(info->cmtd, dev->dev.of_node);
572 err = mtd_device_parse_register(info->cmtd, info->part_types, NULL,
573 info->parts, info->nparts);
574 if (err)
575 goto err_out;
576
577 return 0;
578
579 err_out:
580 physmap_flash_remove(dev);
581 return err;
582 }
583
584 #ifdef CONFIG_PM
585 static void physmap_flash_shutdown(struct platform_device *dev)
586 {
587 struct physmap_flash_info *info = platform_get_drvdata(dev);
588 int i;
589
590 for (i = 0; i < info->nmaps && info->mtds[i]; i++)
591 if (mtd_suspend(info->mtds[i]) == 0)
592 mtd_resume(info->mtds[i]);
593 }
594 #else
595 #define physmap_flash_shutdown NULL
596 #endif
597
598 static struct platform_driver physmap_flash_driver = {
599 .probe = physmap_flash_probe,
600 .remove = physmap_flash_remove,
601 .shutdown = physmap_flash_shutdown,
602 .driver = {
603 .name = "physmap-flash",
604 .of_match_table = of_flash_match,
605 },
606 };
607
608 #ifdef CONFIG_MTD_PHYSMAP_COMPAT
609 static struct physmap_flash_data physmap_flash_data = {
610 .width = CONFIG_MTD_PHYSMAP_BANKWIDTH,
611 };
612
613 static struct resource physmap_flash_resource = {
614 .start = CONFIG_MTD_PHYSMAP_START,
615 .end = CONFIG_MTD_PHYSMAP_START + CONFIG_MTD_PHYSMAP_LEN - 1,
616 .flags = IORESOURCE_MEM,
617 };
618
619 static struct platform_device physmap_flash = {
620 .name = "physmap-flash",
621 .id = 0,
622 .dev = {
623 .platform_data = &physmap_flash_data,
624 },
625 .num_resources = 1,
626 .resource = &physmap_flash_resource,
627 };
628 #endif
629
630 static int __init physmap_init(void)
631 {
632 int err;
633
634 err = platform_driver_register(&physmap_flash_driver);
635 #ifdef CONFIG_MTD_PHYSMAP_COMPAT
636 if (err == 0) {
637 err = platform_device_register(&physmap_flash);
638 if (err)
639 platform_driver_unregister(&physmap_flash_driver);
640 }
641 #endif
642
643 return err;
644 }
645
646 static void __exit physmap_exit(void)
647 {
648 #ifdef CONFIG_MTD_PHYSMAP_COMPAT
649 platform_device_unregister(&physmap_flash);
650 #endif
651 platform_driver_unregister(&physmap_flash_driver);
652 }
653
654 module_init(physmap_init);
655 module_exit(physmap_exit);
656
657 MODULE_LICENSE("GPL");
658 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
659 MODULE_AUTHOR("Vitaly Wool <vwool@ru.mvista.com>");
660 MODULE_AUTHOR("Mike Frysinger <vapier@gentoo.org>");
661 MODULE_DESCRIPTION("Generic configurable MTD map driver");
662
663
664 #ifndef CONFIG_MTD_PHYSMAP_COMPAT
665
666 MODULE_ALIAS("platform:physmap-flash");
667 #endif