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