1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/string.h>
14#include <linux/platform_device.h>
15#include <linux/of_device.h>
16#include <linux/of_irq.h>
17#include <linux/module.h>
18#include <linux/init.h>
19#include <linux/dma-mapping.h>
20#include <linux/bootmem.h>
21#include <linux/err.h>
22#include <linux/slab.h>
23#include <linux/pm_runtime.h>
24#include <linux/idr.h>
25#include <linux/acpi.h>
26#include <linux/clk/clk-conf.h>
27#include <linux/limits.h>
28
29#include "base.h"
30#include "power/power.h"
31
32
33static DEFINE_IDA(platform_devid_ida);
34
35struct device platform_bus = {
36 .init_name = "platform",
37};
38EXPORT_SYMBOL_GPL(platform_bus);
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55void __weak arch_setup_pdev_archdata(struct platform_device *pdev)
56{
57}
58
59
60
61
62
63
64
65struct resource *platform_get_resource(struct platform_device *dev,
66 unsigned int type, unsigned int num)
67{
68 int i;
69
70 for (i = 0; i < dev->num_resources; i++) {
71 struct resource *r = &dev->resource[i];
72
73 if (type == resource_type(r) && num-- == 0)
74 return r;
75 }
76 return NULL;
77}
78EXPORT_SYMBOL_GPL(platform_get_resource);
79
80
81
82
83
84
85int platform_get_irq(struct platform_device *dev, unsigned int num)
86{
87#ifdef CONFIG_SPARC
88
89 if (!dev || num >= dev->archdata.num_irqs)
90 return -ENXIO;
91 return dev->archdata.irqs[num];
92#else
93 struct resource *r;
94 if (IS_ENABLED(CONFIG_OF_IRQ) && dev->dev.of_node) {
95 int ret;
96
97 ret = of_irq_get(dev->dev.of_node, num);
98 if (ret >= 0 || ret == -EPROBE_DEFER)
99 return ret;
100 }
101
102 r = platform_get_resource(dev, IORESOURCE_IRQ, num);
103
104 return r ? r->start : -ENXIO;
105#endif
106}
107EXPORT_SYMBOL_GPL(platform_get_irq);
108
109
110
111
112
113
114
115struct resource *platform_get_resource_byname(struct platform_device *dev,
116 unsigned int type,
117 const char *name)
118{
119 int i;
120
121 for (i = 0; i < dev->num_resources; i++) {
122 struct resource *r = &dev->resource[i];
123
124 if (unlikely(!r->name))
125 continue;
126
127 if (type == resource_type(r) && !strcmp(r->name, name))
128 return r;
129 }
130 return NULL;
131}
132EXPORT_SYMBOL_GPL(platform_get_resource_byname);
133
134
135
136
137
138
139int platform_get_irq_byname(struct platform_device *dev, const char *name)
140{
141 struct resource *r;
142
143 if (IS_ENABLED(CONFIG_OF_IRQ) && dev->dev.of_node) {
144 int ret;
145
146 ret = of_irq_get_byname(dev->dev.of_node, name);
147 if (ret >= 0 || ret == -EPROBE_DEFER)
148 return ret;
149 }
150
151 r = platform_get_resource_byname(dev, IORESOURCE_IRQ, name);
152 return r ? r->start : -ENXIO;
153}
154EXPORT_SYMBOL_GPL(platform_get_irq_byname);
155
156
157
158
159
160
161int platform_add_devices(struct platform_device **devs, int num)
162{
163 int i, ret = 0;
164
165 for (i = 0; i < num; i++) {
166 ret = platform_device_register(devs[i]);
167 if (ret) {
168 while (--i >= 0)
169 platform_device_unregister(devs[i]);
170 break;
171 }
172 }
173
174 return ret;
175}
176EXPORT_SYMBOL_GPL(platform_add_devices);
177
178struct platform_object {
179 struct platform_device pdev;
180 char name[];
181};
182
183
184
185
186
187
188
189
190void platform_device_put(struct platform_device *pdev)
191{
192 if (pdev)
193 put_device(&pdev->dev);
194}
195EXPORT_SYMBOL_GPL(platform_device_put);
196
197static void platform_device_release(struct device *dev)
198{
199 struct platform_object *pa = container_of(dev, struct platform_object,
200 pdev.dev);
201
202 of_device_node_put(&pa->pdev.dev);
203 kfree(pa->pdev.dev.platform_data);
204 kfree(pa->pdev.mfd_cell);
205 kfree(pa->pdev.resource);
206 kfree(pa->pdev.driver_override);
207 kfree(pa);
208}
209
210
211
212
213
214
215
216
217
218struct platform_device *platform_device_alloc(const char *name, int id)
219{
220 struct platform_object *pa;
221
222 pa = kzalloc(sizeof(*pa) + strlen(name) + 1, GFP_KERNEL);
223 if (pa) {
224 strcpy(pa->name, name);
225 pa->pdev.name = pa->name;
226 pa->pdev.id = id;
227 device_initialize(&pa->pdev.dev);
228 pa->pdev.dev.release = platform_device_release;
229 arch_setup_pdev_archdata(&pa->pdev);
230 }
231
232 return pa ? &pa->pdev : NULL;
233}
234EXPORT_SYMBOL_GPL(platform_device_alloc);
235
236
237
238
239
240
241
242
243
244
245
246int platform_device_add_resources(struct platform_device *pdev,
247 const struct resource *res, unsigned int num)
248{
249 struct resource *r = NULL;
250
251 if (res) {
252 r = kmemdup(res, sizeof(struct resource) * num, GFP_KERNEL);
253 if (!r)
254 return -ENOMEM;
255 }
256
257 kfree(pdev->resource);
258 pdev->resource = r;
259 pdev->num_resources = num;
260 return 0;
261}
262EXPORT_SYMBOL_GPL(platform_device_add_resources);
263
264
265
266
267
268
269
270
271
272
273
274int platform_device_add_data(struct platform_device *pdev, const void *data,
275 size_t size)
276{
277 void *d = NULL;
278
279 if (data) {
280 d = kmemdup(data, size, GFP_KERNEL);
281 if (!d)
282 return -ENOMEM;
283 }
284
285 kfree(pdev->dev.platform_data);
286 pdev->dev.platform_data = d;
287 return 0;
288}
289EXPORT_SYMBOL_GPL(platform_device_add_data);
290
291
292
293
294
295
296
297
298int platform_device_add(struct platform_device *pdev)
299{
300 int i, ret;
301
302 if (!pdev)
303 return -EINVAL;
304
305 if (!pdev->dev.parent)
306 pdev->dev.parent = &platform_bus;
307
308 pdev->dev.bus = &platform_bus_type;
309
310 switch (pdev->id) {
311 default:
312 dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
313 break;
314 case PLATFORM_DEVID_NONE:
315 dev_set_name(&pdev->dev, "%s", pdev->name);
316 break;
317 case PLATFORM_DEVID_AUTO:
318
319
320
321
322
323 ret = ida_simple_get(&platform_devid_ida, 0, 0, GFP_KERNEL);
324 if (ret < 0)
325 goto err_out;
326 pdev->id = ret;
327 pdev->id_auto = true;
328 dev_set_name(&pdev->dev, "%s.%d.auto", pdev->name, pdev->id);
329 break;
330 }
331
332 for (i = 0; i < pdev->num_resources; i++) {
333 struct resource *p, *r = &pdev->resource[i];
334
335 if (r->name == NULL)
336 r->name = dev_name(&pdev->dev);
337
338 p = r->parent;
339 if (!p) {
340 if (resource_type(r) == IORESOURCE_MEM)
341 p = &iomem_resource;
342 else if (resource_type(r) == IORESOURCE_IO)
343 p = &ioport_resource;
344 }
345
346 if (p && insert_resource(p, r)) {
347 dev_err(&pdev->dev, "failed to claim resource %d\n", i);
348 ret = -EBUSY;
349 goto failed;
350 }
351 }
352
353 pr_debug("Registering platform device '%s'. Parent at %s\n",
354 dev_name(&pdev->dev), dev_name(pdev->dev.parent));
355
356 ret = device_add(&pdev->dev);
357 if (ret == 0)
358 return ret;
359
360 failed:
361 if (pdev->id_auto) {
362 ida_simple_remove(&platform_devid_ida, pdev->id);
363 pdev->id = PLATFORM_DEVID_AUTO;
364 }
365
366 while (--i >= 0) {
367 struct resource *r = &pdev->resource[i];
368 unsigned long type = resource_type(r);
369
370 if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
371 release_resource(r);
372 }
373
374 err_out:
375 return ret;
376}
377EXPORT_SYMBOL_GPL(platform_device_add);
378
379
380
381
382
383
384
385
386
387void platform_device_del(struct platform_device *pdev)
388{
389 int i;
390
391 if (pdev) {
392 device_del(&pdev->dev);
393
394 if (pdev->id_auto) {
395 ida_simple_remove(&platform_devid_ida, pdev->id);
396 pdev->id = PLATFORM_DEVID_AUTO;
397 }
398
399 for (i = 0; i < pdev->num_resources; i++) {
400 struct resource *r = &pdev->resource[i];
401 unsigned long type = resource_type(r);
402
403 if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
404 release_resource(r);
405 }
406 }
407}
408EXPORT_SYMBOL_GPL(platform_device_del);
409
410
411
412
413
414int platform_device_register(struct platform_device *pdev)
415{
416 device_initialize(&pdev->dev);
417 arch_setup_pdev_archdata(pdev);
418 return platform_device_add(pdev);
419}
420EXPORT_SYMBOL_GPL(platform_device_register);
421
422
423
424
425
426
427
428
429
430void platform_device_unregister(struct platform_device *pdev)
431{
432 platform_device_del(pdev);
433 platform_device_put(pdev);
434}
435EXPORT_SYMBOL_GPL(platform_device_unregister);
436
437
438
439
440
441
442
443
444
445struct platform_device *platform_device_register_full(
446 const struct platform_device_info *pdevinfo)
447{
448 int ret = -ENOMEM;
449 struct platform_device *pdev;
450
451 pdev = platform_device_alloc(pdevinfo->name, pdevinfo->id);
452 if (!pdev)
453 goto err_alloc;
454
455 pdev->dev.parent = pdevinfo->parent;
456 ACPI_COMPANION_SET(&pdev->dev, pdevinfo->acpi_node.companion);
457
458 if (pdevinfo->dma_mask) {
459
460
461
462
463
464
465 pdev->dev.dma_mask =
466 kmalloc(sizeof(*pdev->dev.dma_mask), GFP_KERNEL);
467 if (!pdev->dev.dma_mask)
468 goto err;
469
470 *pdev->dev.dma_mask = pdevinfo->dma_mask;
471 pdev->dev.coherent_dma_mask = pdevinfo->dma_mask;
472 }
473
474 ret = platform_device_add_resources(pdev,
475 pdevinfo->res, pdevinfo->num_res);
476 if (ret)
477 goto err;
478
479 ret = platform_device_add_data(pdev,
480 pdevinfo->data, pdevinfo->size_data);
481 if (ret)
482 goto err;
483
484 ret = platform_device_add(pdev);
485 if (ret) {
486err:
487 ACPI_COMPANION_SET(&pdev->dev, NULL);
488 kfree(pdev->dev.dma_mask);
489
490err_alloc:
491 platform_device_put(pdev);
492 return ERR_PTR(ret);
493 }
494
495 return pdev;
496}
497EXPORT_SYMBOL_GPL(platform_device_register_full);
498
499static int platform_drv_probe(struct device *_dev)
500{
501 struct platform_driver *drv = to_platform_driver(_dev->driver);
502 struct platform_device *dev = to_platform_device(_dev);
503 int ret;
504
505 ret = of_clk_set_defaults(_dev->of_node, false);
506 if (ret < 0)
507 return ret;
508
509 acpi_dev_pm_attach(_dev, true);
510
511 ret = drv->probe(dev);
512 if (ret)
513 acpi_dev_pm_detach(_dev, true);
514
515 if (drv->prevent_deferred_probe && ret == -EPROBE_DEFER) {
516 dev_warn(_dev, "probe deferral not supported\n");
517 ret = -ENXIO;
518 }
519
520 return ret;
521}
522
523static int platform_drv_probe_fail(struct device *_dev)
524{
525 return -ENXIO;
526}
527
528static int platform_drv_remove(struct device *_dev)
529{
530 struct platform_driver *drv = to_platform_driver(_dev->driver);
531 struct platform_device *dev = to_platform_device(_dev);
532 int ret;
533
534 ret = drv->remove(dev);
535 acpi_dev_pm_detach(_dev, true);
536
537 return ret;
538}
539
540static void platform_drv_shutdown(struct device *_dev)
541{
542 struct platform_driver *drv = to_platform_driver(_dev->driver);
543 struct platform_device *dev = to_platform_device(_dev);
544
545 drv->shutdown(dev);
546 acpi_dev_pm_detach(_dev, true);
547}
548
549
550
551
552
553
554int __platform_driver_register(struct platform_driver *drv,
555 struct module *owner)
556{
557 drv->driver.owner = owner;
558 drv->driver.bus = &platform_bus_type;
559 if (drv->probe)
560 drv->driver.probe = platform_drv_probe;
561 if (drv->remove)
562 drv->driver.remove = platform_drv_remove;
563 if (drv->shutdown)
564 drv->driver.shutdown = platform_drv_shutdown;
565
566 return driver_register(&drv->driver);
567}
568EXPORT_SYMBOL_GPL(__platform_driver_register);
569
570
571
572
573
574void platform_driver_unregister(struct platform_driver *drv)
575{
576 driver_unregister(&drv->driver);
577}
578EXPORT_SYMBOL_GPL(platform_driver_unregister);
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599int __init_or_module platform_driver_probe(struct platform_driver *drv,
600 int (*probe)(struct platform_device *))
601{
602 int retval, code;
603
604
605
606
607
608 drv->prevent_deferred_probe = true;
609
610
611 drv->driver.suppress_bind_attrs = true;
612
613
614 drv->probe = probe;
615 retval = code = platform_driver_register(drv);
616
617
618
619
620
621
622
623 spin_lock(&drv->driver.bus->p->klist_drivers.k_lock);
624 drv->probe = NULL;
625 if (code == 0 && list_empty(&drv->driver.p->klist_devices.k_list))
626 retval = -ENODEV;
627 drv->driver.probe = platform_drv_probe_fail;
628 spin_unlock(&drv->driver.bus->p->klist_drivers.k_lock);
629
630 if (code != retval)
631 platform_driver_unregister(drv);
632 return retval;
633}
634EXPORT_SYMBOL_GPL(platform_driver_probe);
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650struct platform_device * __init_or_module platform_create_bundle(
651 struct platform_driver *driver,
652 int (*probe)(struct platform_device *),
653 struct resource *res, unsigned int n_res,
654 const void *data, size_t size)
655{
656 struct platform_device *pdev;
657 int error;
658
659 pdev = platform_device_alloc(driver->driver.name, -1);
660 if (!pdev) {
661 error = -ENOMEM;
662 goto err_out;
663 }
664
665 error = platform_device_add_resources(pdev, res, n_res);
666 if (error)
667 goto err_pdev_put;
668
669 error = platform_device_add_data(pdev, data, size);
670 if (error)
671 goto err_pdev_put;
672
673 error = platform_device_add(pdev);
674 if (error)
675 goto err_pdev_put;
676
677 error = platform_driver_probe(driver, probe);
678 if (error)
679 goto err_pdev_del;
680
681 return pdev;
682
683err_pdev_del:
684 platform_device_del(pdev);
685err_pdev_put:
686 platform_device_put(pdev);
687err_out:
688 return ERR_PTR(error);
689}
690EXPORT_SYMBOL_GPL(platform_create_bundle);
691
692
693
694
695
696
697
698static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
699 char *buf)
700{
701 struct platform_device *pdev = to_platform_device(dev);
702 int len;
703
704 len = of_device_get_modalias(dev, buf, PAGE_SIZE -1);
705 if (len != -ENODEV)
706 return len;
707
708 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
709 if (len != -ENODEV)
710 return len;
711
712 len = snprintf(buf, PAGE_SIZE, "platform:%s\n", pdev->name);
713
714 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
715}
716static DEVICE_ATTR_RO(modalias);
717
718static ssize_t driver_override_store(struct device *dev,
719 struct device_attribute *attr,
720 const char *buf, size_t count)
721{
722 struct platform_device *pdev = to_platform_device(dev);
723 char *driver_override, *old = pdev->driver_override, *cp;
724
725 if (count > PATH_MAX)
726 return -EINVAL;
727
728 driver_override = kstrndup(buf, count, GFP_KERNEL);
729 if (!driver_override)
730 return -ENOMEM;
731
732 cp = strchr(driver_override, '\n');
733 if (cp)
734 *cp = '\0';
735
736 if (strlen(driver_override)) {
737 pdev->driver_override = driver_override;
738 } else {
739 kfree(driver_override);
740 pdev->driver_override = NULL;
741 }
742
743 kfree(old);
744
745 return count;
746}
747
748static ssize_t driver_override_show(struct device *dev,
749 struct device_attribute *attr, char *buf)
750{
751 struct platform_device *pdev = to_platform_device(dev);
752
753 return sprintf(buf, "%s\n", pdev->driver_override);
754}
755static DEVICE_ATTR_RW(driver_override);
756
757
758static struct attribute *platform_dev_attrs[] = {
759 &dev_attr_modalias.attr,
760 &dev_attr_driver_override.attr,
761 NULL,
762};
763ATTRIBUTE_GROUPS(platform_dev);
764
765static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
766{
767 struct platform_device *pdev = to_platform_device(dev);
768 int rc;
769
770
771 rc = of_device_uevent_modalias(dev, env);
772 if (rc != -ENODEV)
773 return rc;
774
775 rc = acpi_device_uevent_modalias(dev, env);
776 if (rc != -ENODEV)
777 return rc;
778
779 add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX,
780 pdev->name);
781 return 0;
782}
783
784static const struct platform_device_id *platform_match_id(
785 const struct platform_device_id *id,
786 struct platform_device *pdev)
787{
788 while (id->name[0]) {
789 if (strcmp(pdev->name, id->name) == 0) {
790 pdev->id_entry = id;
791 return id;
792 }
793 id++;
794 }
795 return NULL;
796}
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811static int platform_match(struct device *dev, struct device_driver *drv)
812{
813 struct platform_device *pdev = to_platform_device(dev);
814 struct platform_driver *pdrv = to_platform_driver(drv);
815
816
817 if (pdev->driver_override)
818 return !strcmp(pdev->driver_override, drv->name);
819
820
821 if (of_driver_match_device(dev, drv))
822 return 1;
823
824
825 if (acpi_driver_match_device(dev, drv))
826 return 1;
827
828
829 if (pdrv->id_table)
830 return platform_match_id(pdrv->id_table, pdev) != NULL;
831
832
833 return (strcmp(pdev->name, drv->name) == 0);
834}
835
836#ifdef CONFIG_PM_SLEEP
837
838static int platform_legacy_suspend(struct device *dev, pm_message_t mesg)
839{
840 struct platform_driver *pdrv = to_platform_driver(dev->driver);
841 struct platform_device *pdev = to_platform_device(dev);
842 int ret = 0;
843
844 if (dev->driver && pdrv->suspend)
845 ret = pdrv->suspend(pdev, mesg);
846
847 return ret;
848}
849
850static int platform_legacy_resume(struct device *dev)
851{
852 struct platform_driver *pdrv = to_platform_driver(dev->driver);
853 struct platform_device *pdev = to_platform_device(dev);
854 int ret = 0;
855
856 if (dev->driver && pdrv->resume)
857 ret = pdrv->resume(pdev);
858
859 return ret;
860}
861
862#endif
863
864#ifdef CONFIG_SUSPEND
865
866int platform_pm_suspend(struct device *dev)
867{
868 struct device_driver *drv = dev->driver;
869 int ret = 0;
870
871 if (!drv)
872 return 0;
873
874 if (drv->pm) {
875 if (drv->pm->suspend)
876 ret = drv->pm->suspend(dev);
877 } else {
878 ret = platform_legacy_suspend(dev, PMSG_SUSPEND);
879 }
880
881 return ret;
882}
883
884int platform_pm_resume(struct device *dev)
885{
886 struct device_driver *drv = dev->driver;
887 int ret = 0;
888
889 if (!drv)
890 return 0;
891
892 if (drv->pm) {
893 if (drv->pm->resume)
894 ret = drv->pm->resume(dev);
895 } else {
896 ret = platform_legacy_resume(dev);
897 }
898
899 return ret;
900}
901
902#endif
903
904#ifdef CONFIG_HIBERNATE_CALLBACKS
905
906int platform_pm_freeze(struct device *dev)
907{
908 struct device_driver *drv = dev->driver;
909 int ret = 0;
910
911 if (!drv)
912 return 0;
913
914 if (drv->pm) {
915 if (drv->pm->freeze)
916 ret = drv->pm->freeze(dev);
917 } else {
918 ret = platform_legacy_suspend(dev, PMSG_FREEZE);
919 }
920
921 return ret;
922}
923
924int platform_pm_thaw(struct device *dev)
925{
926 struct device_driver *drv = dev->driver;
927 int ret = 0;
928
929 if (!drv)
930 return 0;
931
932 if (drv->pm) {
933 if (drv->pm->thaw)
934 ret = drv->pm->thaw(dev);
935 } else {
936 ret = platform_legacy_resume(dev);
937 }
938
939 return ret;
940}
941
942int platform_pm_poweroff(struct device *dev)
943{
944 struct device_driver *drv = dev->driver;
945 int ret = 0;
946
947 if (!drv)
948 return 0;
949
950 if (drv->pm) {
951 if (drv->pm->poweroff)
952 ret = drv->pm->poweroff(dev);
953 } else {
954 ret = platform_legacy_suspend(dev, PMSG_HIBERNATE);
955 }
956
957 return ret;
958}
959
960int platform_pm_restore(struct device *dev)
961{
962 struct device_driver *drv = dev->driver;
963 int ret = 0;
964
965 if (!drv)
966 return 0;
967
968 if (drv->pm) {
969 if (drv->pm->restore)
970 ret = drv->pm->restore(dev);
971 } else {
972 ret = platform_legacy_resume(dev);
973 }
974
975 return ret;
976}
977
978#endif
979
980static const struct dev_pm_ops platform_dev_pm_ops = {
981 .runtime_suspend = pm_generic_runtime_suspend,
982 .runtime_resume = pm_generic_runtime_resume,
983 USE_PLATFORM_PM_SLEEP_OPS
984};
985
986struct bus_type platform_bus_type = {
987 .name = "platform",
988 .dev_groups = platform_dev_groups,
989 .match = platform_match,
990 .uevent = platform_uevent,
991 .pm = &platform_dev_pm_ops,
992};
993EXPORT_SYMBOL_GPL(platform_bus_type);
994
995int __init platform_bus_init(void)
996{
997 int error;
998
999 early_platform_cleanup();
1000
1001 error = device_register(&platform_bus);
1002 if (error)
1003 return error;
1004 error = bus_register(&platform_bus_type);
1005 if (error)
1006 device_unregister(&platform_bus);
1007 return error;
1008}
1009
1010#ifndef ARCH_HAS_DMA_GET_REQUIRED_MASK
1011u64 dma_get_required_mask(struct device *dev)
1012{
1013 u32 low_totalram = ((max_pfn - 1) << PAGE_SHIFT);
1014 u32 high_totalram = ((max_pfn - 1) >> (32 - PAGE_SHIFT));
1015 u64 mask;
1016
1017 if (!high_totalram) {
1018
1019 low_totalram = (1 << (fls(low_totalram) - 1));
1020 low_totalram += low_totalram - 1;
1021 mask = low_totalram;
1022 } else {
1023 high_totalram = (1 << (fls(high_totalram) - 1));
1024 high_totalram += high_totalram - 1;
1025 mask = (((u64)high_totalram) << 32) + 0xffffffff;
1026 }
1027 return mask;
1028}
1029EXPORT_SYMBOL_GPL(dma_get_required_mask);
1030#endif
1031
1032static __initdata LIST_HEAD(early_platform_driver_list);
1033static __initdata LIST_HEAD(early_platform_device_list);
1034
1035
1036
1037
1038
1039
1040
1041
1042int __init early_platform_driver_register(struct early_platform_driver *epdrv,
1043 char *buf)
1044{
1045 char *tmp;
1046 int n;
1047
1048
1049
1050
1051 if (!epdrv->list.next) {
1052 INIT_LIST_HEAD(&epdrv->list);
1053 list_add_tail(&epdrv->list, &early_platform_driver_list);
1054 }
1055
1056
1057
1058
1059
1060 n = strlen(epdrv->pdrv->driver.name);
1061 if (buf && !strncmp(buf, epdrv->pdrv->driver.name, n)) {
1062 list_move(&epdrv->list, &early_platform_driver_list);
1063
1064
1065 if (buf[n] == '\0' || buf[n] == ',')
1066 epdrv->requested_id = -1;
1067 else {
1068 epdrv->requested_id = simple_strtoul(&buf[n + 1],
1069 &tmp, 10);
1070
1071 if (buf[n] != '.' || (tmp == &buf[n + 1])) {
1072 epdrv->requested_id = EARLY_PLATFORM_ID_ERROR;
1073 n = 0;
1074 } else
1075 n += strcspn(&buf[n + 1], ",") + 1;
1076 }
1077
1078 if (buf[n] == ',')
1079 n++;
1080
1081 if (epdrv->bufsize) {
1082 memcpy(epdrv->buffer, &buf[n],
1083 min_t(int, epdrv->bufsize, strlen(&buf[n]) + 1));
1084 epdrv->buffer[epdrv->bufsize - 1] = '\0';
1085 }
1086 }
1087
1088 return 0;
1089}
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099void __init early_platform_add_devices(struct platform_device **devs, int num)
1100{
1101 struct device *dev;
1102 int i;
1103
1104
1105 for (i = 0; i < num; i++) {
1106 dev = &devs[i]->dev;
1107
1108 if (!dev->devres_head.next) {
1109 pm_runtime_early_init(dev);
1110 INIT_LIST_HEAD(&dev->devres_head);
1111 list_add_tail(&dev->devres_head,
1112 &early_platform_device_list);
1113 }
1114 }
1115}
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125void __init early_platform_driver_register_all(char *class_str)
1126{
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141 parse_early_options(class_str);
1142}
1143
1144
1145
1146
1147
1148
1149static struct platform_device * __init
1150early_platform_match(struct early_platform_driver *epdrv, int id)
1151{
1152 struct platform_device *pd;
1153
1154 list_for_each_entry(pd, &early_platform_device_list, dev.devres_head)
1155 if (platform_match(&pd->dev, &epdrv->pdrv->driver))
1156 if (pd->id == id)
1157 return pd;
1158
1159 return NULL;
1160}
1161
1162
1163
1164
1165
1166
1167static int __init early_platform_left(struct early_platform_driver *epdrv,
1168 int id)
1169{
1170 struct platform_device *pd;
1171
1172 list_for_each_entry(pd, &early_platform_device_list, dev.devres_head)
1173 if (platform_match(&pd->dev, &epdrv->pdrv->driver))
1174 if (pd->id >= id)
1175 return 1;
1176
1177 return 0;
1178}
1179
1180
1181
1182
1183
1184
1185
1186static int __init early_platform_driver_probe_id(char *class_str,
1187 int id,
1188 int nr_probe)
1189{
1190 struct early_platform_driver *epdrv;
1191 struct platform_device *match;
1192 int match_id;
1193 int n = 0;
1194 int left = 0;
1195
1196 list_for_each_entry(epdrv, &early_platform_driver_list, list) {
1197
1198 if (strcmp(class_str, epdrv->class_str))
1199 continue;
1200
1201 if (id == -2) {
1202 match_id = epdrv->requested_id;
1203 left = 1;
1204
1205 } else {
1206 match_id = id;
1207 left += early_platform_left(epdrv, id);
1208
1209
1210 switch (epdrv->requested_id) {
1211 case EARLY_PLATFORM_ID_ERROR:
1212 case EARLY_PLATFORM_ID_UNSET:
1213 break;
1214 default:
1215 if (epdrv->requested_id == id)
1216 match_id = EARLY_PLATFORM_ID_UNSET;
1217 }
1218 }
1219
1220 switch (match_id) {
1221 case EARLY_PLATFORM_ID_ERROR:
1222 pr_warn("%s: unable to parse %s parameter\n",
1223 class_str, epdrv->pdrv->driver.name);
1224
1225 case EARLY_PLATFORM_ID_UNSET:
1226 match = NULL;
1227 break;
1228 default:
1229 match = early_platform_match(epdrv, match_id);
1230 }
1231
1232 if (match) {
1233
1234
1235
1236
1237
1238 if (!match->dev.init_name && slab_is_available()) {
1239 if (match->id != -1)
1240 match->dev.init_name =
1241 kasprintf(GFP_KERNEL, "%s.%d",
1242 match->name,
1243 match->id);
1244 else
1245 match->dev.init_name =
1246 kasprintf(GFP_KERNEL, "%s",
1247 match->name);
1248
1249 if (!match->dev.init_name)
1250 return -ENOMEM;
1251 }
1252
1253 if (epdrv->pdrv->probe(match))
1254 pr_warn("%s: unable to probe %s early.\n",
1255 class_str, match->name);
1256 else
1257 n++;
1258 }
1259
1260 if (n >= nr_probe)
1261 break;
1262 }
1263
1264 if (left)
1265 return n;
1266 else
1267 return -ENODEV;
1268}
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280int __init early_platform_driver_probe(char *class_str,
1281 int nr_probe,
1282 int user_only)
1283{
1284 int k, n, i;
1285
1286 n = 0;
1287 for (i = -2; n < nr_probe; i++) {
1288 k = early_platform_driver_probe_id(class_str, i, nr_probe - n);
1289
1290 if (k < 0)
1291 break;
1292
1293 n += k;
1294
1295 if (user_only)
1296 break;
1297 }
1298
1299 return n;
1300}
1301
1302
1303
1304
1305void __init early_platform_cleanup(void)
1306{
1307 struct platform_device *pd, *pd2;
1308
1309
1310 list_for_each_entry_safe(pd, pd2, &early_platform_device_list,
1311 dev.devres_head) {
1312 list_del(&pd->dev.devres_head);
1313 memset(&pd->dev.devres_head, 0, sizeof(pd->dev.devres_head));
1314 }
1315}
1316
1317