Merge tag 'driver-core-4.21-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git...
[sfrench/cifs-2.6.git] / drivers / base / platform.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * platform.c - platform 'pseudo' bus for legacy devices
4  *
5  * Copyright (c) 2002-3 Patrick Mochel
6  * Copyright (c) 2002-3 Open Source Development Labs
7  *
8  * Please see Documentation/driver-model/platform.txt for more
9  * information.
10  */
11
12 #include <linux/string.h>
13 #include <linux/platform_device.h>
14 #include <linux/of_device.h>
15 #include <linux/of_irq.h>
16 #include <linux/module.h>
17 #include <linux/init.h>
18 #include <linux/dma-mapping.h>
19 #include <linux/memblock.h>
20 #include <linux/err.h>
21 #include <linux/slab.h>
22 #include <linux/pm_runtime.h>
23 #include <linux/pm_domain.h>
24 #include <linux/idr.h>
25 #include <linux/acpi.h>
26 #include <linux/clk/clk-conf.h>
27 #include <linux/limits.h>
28 #include <linux/property.h>
29
30 #include "base.h"
31 #include "power/power.h"
32
33 /* For automatically allocated device IDs */
34 static DEFINE_IDA(platform_devid_ida);
35
36 struct device platform_bus = {
37         .init_name      = "platform",
38 };
39 EXPORT_SYMBOL_GPL(platform_bus);
40
41 /**
42  * arch_setup_pdev_archdata - Allow manipulation of archdata before its used
43  * @pdev: platform device
44  *
45  * This is called before platform_device_add() such that any pdev_archdata may
46  * be setup before the platform_notifier is called.  So if a user needs to
47  * manipulate any relevant information in the pdev_archdata they can do:
48  *
49  *      platform_device_alloc()
50  *      ... manipulate ...
51  *      platform_device_add()
52  *
53  * And if they don't care they can just call platform_device_register() and
54  * everything will just work out.
55  */
56 void __weak arch_setup_pdev_archdata(struct platform_device *pdev)
57 {
58 }
59
60 /**
61  * platform_get_resource - get a resource for a device
62  * @dev: platform device
63  * @type: resource type
64  * @num: resource index
65  */
66 struct resource *platform_get_resource(struct platform_device *dev,
67                                        unsigned int type, unsigned int num)
68 {
69         int i;
70
71         for (i = 0; i < dev->num_resources; i++) {
72                 struct resource *r = &dev->resource[i];
73
74                 if (type == resource_type(r) && num-- == 0)
75                         return r;
76         }
77         return NULL;
78 }
79 EXPORT_SYMBOL_GPL(platform_get_resource);
80
81 /**
82  * platform_get_irq - get an IRQ for a device
83  * @dev: platform device
84  * @num: IRQ number index
85  */
86 int platform_get_irq(struct platform_device *dev, unsigned int num)
87 {
88 #ifdef CONFIG_SPARC
89         /* sparc does not have irqs represented as IORESOURCE_IRQ resources */
90         if (!dev || num >= dev->archdata.num_irqs)
91                 return -ENXIO;
92         return dev->archdata.irqs[num];
93 #else
94         struct resource *r;
95         if (IS_ENABLED(CONFIG_OF_IRQ) && dev->dev.of_node) {
96                 int ret;
97
98                 ret = of_irq_get(dev->dev.of_node, num);
99                 if (ret > 0 || ret == -EPROBE_DEFER)
100                         return ret;
101         }
102
103         r = platform_get_resource(dev, IORESOURCE_IRQ, num);
104         if (has_acpi_companion(&dev->dev)) {
105                 if (r && r->flags & IORESOURCE_DISABLED) {
106                         int ret;
107
108                         ret = acpi_irq_get(ACPI_HANDLE(&dev->dev), num, r);
109                         if (ret)
110                                 return ret;
111                 }
112         }
113
114         /*
115          * The resources may pass trigger flags to the irqs that need
116          * to be set up. It so happens that the trigger flags for
117          * IORESOURCE_BITS correspond 1-to-1 to the IRQF_TRIGGER*
118          * settings.
119          */
120         if (r && r->flags & IORESOURCE_BITS) {
121                 struct irq_data *irqd;
122
123                 irqd = irq_get_irq_data(r->start);
124                 if (!irqd)
125                         return -ENXIO;
126                 irqd_set_trigger_type(irqd, r->flags & IORESOURCE_BITS);
127         }
128
129         return r ? r->start : -ENXIO;
130 #endif
131 }
132 EXPORT_SYMBOL_GPL(platform_get_irq);
133
134 /**
135  * platform_irq_count - Count the number of IRQs a platform device uses
136  * @dev: platform device
137  *
138  * Return: Number of IRQs a platform device uses or EPROBE_DEFER
139  */
140 int platform_irq_count(struct platform_device *dev)
141 {
142         int ret, nr = 0;
143
144         while ((ret = platform_get_irq(dev, nr)) >= 0)
145                 nr++;
146
147         if (ret == -EPROBE_DEFER)
148                 return ret;
149
150         return nr;
151 }
152 EXPORT_SYMBOL_GPL(platform_irq_count);
153
154 /**
155  * platform_get_resource_byname - get a resource for a device by name
156  * @dev: platform device
157  * @type: resource type
158  * @name: resource name
159  */
160 struct resource *platform_get_resource_byname(struct platform_device *dev,
161                                               unsigned int type,
162                                               const char *name)
163 {
164         int i;
165
166         for (i = 0; i < dev->num_resources; i++) {
167                 struct resource *r = &dev->resource[i];
168
169                 if (unlikely(!r->name))
170                         continue;
171
172                 if (type == resource_type(r) && !strcmp(r->name, name))
173                         return r;
174         }
175         return NULL;
176 }
177 EXPORT_SYMBOL_GPL(platform_get_resource_byname);
178
179 /**
180  * platform_get_irq_byname - get an IRQ for a device by name
181  * @dev: platform device
182  * @name: IRQ name
183  */
184 int platform_get_irq_byname(struct platform_device *dev, const char *name)
185 {
186         struct resource *r;
187
188         if (IS_ENABLED(CONFIG_OF_IRQ) && dev->dev.of_node) {
189                 int ret;
190
191                 ret = of_irq_get_byname(dev->dev.of_node, name);
192                 if (ret > 0 || ret == -EPROBE_DEFER)
193                         return ret;
194         }
195
196         r = platform_get_resource_byname(dev, IORESOURCE_IRQ, name);
197         return r ? r->start : -ENXIO;
198 }
199 EXPORT_SYMBOL_GPL(platform_get_irq_byname);
200
201 /**
202  * platform_add_devices - add a numbers of platform devices
203  * @devs: array of platform devices to add
204  * @num: number of platform devices in array
205  */
206 int platform_add_devices(struct platform_device **devs, int num)
207 {
208         int i, ret = 0;
209
210         for (i = 0; i < num; i++) {
211                 ret = platform_device_register(devs[i]);
212                 if (ret) {
213                         while (--i >= 0)
214                                 platform_device_unregister(devs[i]);
215                         break;
216                 }
217         }
218
219         return ret;
220 }
221 EXPORT_SYMBOL_GPL(platform_add_devices);
222
223 struct platform_object {
224         struct platform_device pdev;
225         char name[];
226 };
227
228 /**
229  * platform_device_put - destroy a platform device
230  * @pdev: platform device to free
231  *
232  * Free all memory associated with a platform device.  This function must
233  * _only_ be externally called in error cases.  All other usage is a bug.
234  */
235 void platform_device_put(struct platform_device *pdev)
236 {
237         if (!IS_ERR_OR_NULL(pdev))
238                 put_device(&pdev->dev);
239 }
240 EXPORT_SYMBOL_GPL(platform_device_put);
241
242 static void platform_device_release(struct device *dev)
243 {
244         struct platform_object *pa = container_of(dev, struct platform_object,
245                                                   pdev.dev);
246
247         of_device_node_put(&pa->pdev.dev);
248         kfree(pa->pdev.dev.platform_data);
249         kfree(pa->pdev.mfd_cell);
250         kfree(pa->pdev.resource);
251         kfree(pa->pdev.driver_override);
252         kfree(pa);
253 }
254
255 /**
256  * platform_device_alloc - create a platform device
257  * @name: base name of the device we're adding
258  * @id: instance id
259  *
260  * Create a platform device object which can have other objects attached
261  * to it, and which will have attached objects freed when it is released.
262  */
263 struct platform_device *platform_device_alloc(const char *name, int id)
264 {
265         struct platform_object *pa;
266
267         pa = kzalloc(sizeof(*pa) + strlen(name) + 1, GFP_KERNEL);
268         if (pa) {
269                 strcpy(pa->name, name);
270                 pa->pdev.name = pa->name;
271                 pa->pdev.id = id;
272                 device_initialize(&pa->pdev.dev);
273                 pa->pdev.dev.release = platform_device_release;
274                 arch_setup_pdev_archdata(&pa->pdev);
275         }
276
277         return pa ? &pa->pdev : NULL;
278 }
279 EXPORT_SYMBOL_GPL(platform_device_alloc);
280
281 /**
282  * platform_device_add_resources - add resources to a platform device
283  * @pdev: platform device allocated by platform_device_alloc to add resources to
284  * @res: set of resources that needs to be allocated for the device
285  * @num: number of resources
286  *
287  * Add a copy of the resources to the platform device.  The memory
288  * associated with the resources will be freed when the platform device is
289  * released.
290  */
291 int platform_device_add_resources(struct platform_device *pdev,
292                                   const struct resource *res, unsigned int num)
293 {
294         struct resource *r = NULL;
295
296         if (res) {
297                 r = kmemdup(res, sizeof(struct resource) * num, GFP_KERNEL);
298                 if (!r)
299                         return -ENOMEM;
300         }
301
302         kfree(pdev->resource);
303         pdev->resource = r;
304         pdev->num_resources = num;
305         return 0;
306 }
307 EXPORT_SYMBOL_GPL(platform_device_add_resources);
308
309 /**
310  * platform_device_add_data - add platform-specific data to a platform device
311  * @pdev: platform device allocated by platform_device_alloc to add resources to
312  * @data: platform specific data for this platform device
313  * @size: size of platform specific data
314  *
315  * Add a copy of platform specific data to the platform device's
316  * platform_data pointer.  The memory associated with the platform data
317  * will be freed when the platform device is released.
318  */
319 int platform_device_add_data(struct platform_device *pdev, const void *data,
320                              size_t size)
321 {
322         void *d = NULL;
323
324         if (data) {
325                 d = kmemdup(data, size, GFP_KERNEL);
326                 if (!d)
327                         return -ENOMEM;
328         }
329
330         kfree(pdev->dev.platform_data);
331         pdev->dev.platform_data = d;
332         return 0;
333 }
334 EXPORT_SYMBOL_GPL(platform_device_add_data);
335
336 /**
337  * platform_device_add_properties - add built-in properties to a platform device
338  * @pdev: platform device to add properties to
339  * @properties: null terminated array of properties to add
340  *
341  * The function will take deep copy of @properties and attach the copy to the
342  * platform device. The memory associated with properties will be freed when the
343  * platform device is released.
344  */
345 int platform_device_add_properties(struct platform_device *pdev,
346                                    const struct property_entry *properties)
347 {
348         return device_add_properties(&pdev->dev, properties);
349 }
350 EXPORT_SYMBOL_GPL(platform_device_add_properties);
351
352 /**
353  * platform_device_add - add a platform device to device hierarchy
354  * @pdev: platform device we're adding
355  *
356  * This is part 2 of platform_device_register(), though may be called
357  * separately _iff_ pdev was allocated by platform_device_alloc().
358  */
359 int platform_device_add(struct platform_device *pdev)
360 {
361         int i, ret;
362
363         if (!pdev)
364                 return -EINVAL;
365
366         if (!pdev->dev.parent)
367                 pdev->dev.parent = &platform_bus;
368
369         pdev->dev.bus = &platform_bus_type;
370
371         switch (pdev->id) {
372         default:
373                 dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);
374                 break;
375         case PLATFORM_DEVID_NONE:
376                 dev_set_name(&pdev->dev, "%s", pdev->name);
377                 break;
378         case PLATFORM_DEVID_AUTO:
379                 /*
380                  * Automatically allocated device ID. We mark it as such so
381                  * that we remember it must be freed, and we append a suffix
382                  * to avoid namespace collision with explicit IDs.
383                  */
384                 ret = ida_simple_get(&platform_devid_ida, 0, 0, GFP_KERNEL);
385                 if (ret < 0)
386                         goto err_out;
387                 pdev->id = ret;
388                 pdev->id_auto = true;
389                 dev_set_name(&pdev->dev, "%s.%d.auto", pdev->name, pdev->id);
390                 break;
391         }
392
393         for (i = 0; i < pdev->num_resources; i++) {
394                 struct resource *p, *r = &pdev->resource[i];
395
396                 if (r->name == NULL)
397                         r->name = dev_name(&pdev->dev);
398
399                 p = r->parent;
400                 if (!p) {
401                         if (resource_type(r) == IORESOURCE_MEM)
402                                 p = &iomem_resource;
403                         else if (resource_type(r) == IORESOURCE_IO)
404                                 p = &ioport_resource;
405                 }
406
407                 if (p && insert_resource(p, r)) {
408                         dev_err(&pdev->dev, "failed to claim resource %d: %pR\n", i, r);
409                         ret = -EBUSY;
410                         goto failed;
411                 }
412         }
413
414         pr_debug("Registering platform device '%s'. Parent at %s\n",
415                  dev_name(&pdev->dev), dev_name(pdev->dev.parent));
416
417         ret = device_add(&pdev->dev);
418         if (ret == 0)
419                 return ret;
420
421  failed:
422         if (pdev->id_auto) {
423                 ida_simple_remove(&platform_devid_ida, pdev->id);
424                 pdev->id = PLATFORM_DEVID_AUTO;
425         }
426
427         while (--i >= 0) {
428                 struct resource *r = &pdev->resource[i];
429                 if (r->parent)
430                         release_resource(r);
431         }
432
433  err_out:
434         return ret;
435 }
436 EXPORT_SYMBOL_GPL(platform_device_add);
437
438 /**
439  * platform_device_del - remove a platform-level device
440  * @pdev: platform device we're removing
441  *
442  * Note that this function will also release all memory- and port-based
443  * resources owned by the device (@dev->resource).  This function must
444  * _only_ be externally called in error cases.  All other usage is a bug.
445  */
446 void platform_device_del(struct platform_device *pdev)
447 {
448         int i;
449
450         if (!IS_ERR_OR_NULL(pdev)) {
451                 device_del(&pdev->dev);
452
453                 if (pdev->id_auto) {
454                         ida_simple_remove(&platform_devid_ida, pdev->id);
455                         pdev->id = PLATFORM_DEVID_AUTO;
456                 }
457
458                 for (i = 0; i < pdev->num_resources; i++) {
459                         struct resource *r = &pdev->resource[i];
460                         if (r->parent)
461                                 release_resource(r);
462                 }
463         }
464 }
465 EXPORT_SYMBOL_GPL(platform_device_del);
466
467 /**
468  * platform_device_register - add a platform-level device
469  * @pdev: platform device we're adding
470  */
471 int platform_device_register(struct platform_device *pdev)
472 {
473         device_initialize(&pdev->dev);
474         arch_setup_pdev_archdata(pdev);
475         return platform_device_add(pdev);
476 }
477 EXPORT_SYMBOL_GPL(platform_device_register);
478
479 /**
480  * platform_device_unregister - unregister a platform-level device
481  * @pdev: platform device we're unregistering
482  *
483  * Unregistration is done in 2 steps. First we release all resources
484  * and remove it from the subsystem, then we drop reference count by
485  * calling platform_device_put().
486  */
487 void platform_device_unregister(struct platform_device *pdev)
488 {
489         platform_device_del(pdev);
490         platform_device_put(pdev);
491 }
492 EXPORT_SYMBOL_GPL(platform_device_unregister);
493
494 /**
495  * platform_device_register_full - add a platform-level device with
496  * resources and platform-specific data
497  *
498  * @pdevinfo: data used to create device
499  *
500  * Returns &struct platform_device pointer on success, or ERR_PTR() on error.
501  */
502 struct platform_device *platform_device_register_full(
503                 const struct platform_device_info *pdevinfo)
504 {
505         int ret = -ENOMEM;
506         struct platform_device *pdev;
507
508         pdev = platform_device_alloc(pdevinfo->name, pdevinfo->id);
509         if (!pdev)
510                 goto err_alloc;
511
512         pdev->dev.parent = pdevinfo->parent;
513         pdev->dev.fwnode = pdevinfo->fwnode;
514
515         if (pdevinfo->dma_mask) {
516                 /*
517                  * This memory isn't freed when the device is put,
518                  * I don't have a nice idea for that though.  Conceptually
519                  * dma_mask in struct device should not be a pointer.
520                  * See http://thread.gmane.org/gmane.linux.kernel.pci/9081
521                  */
522                 pdev->dev.dma_mask =
523                         kmalloc(sizeof(*pdev->dev.dma_mask), GFP_KERNEL);
524                 if (!pdev->dev.dma_mask)
525                         goto err;
526
527                 *pdev->dev.dma_mask = pdevinfo->dma_mask;
528                 pdev->dev.coherent_dma_mask = pdevinfo->dma_mask;
529         }
530
531         ret = platform_device_add_resources(pdev,
532                         pdevinfo->res, pdevinfo->num_res);
533         if (ret)
534                 goto err;
535
536         ret = platform_device_add_data(pdev,
537                         pdevinfo->data, pdevinfo->size_data);
538         if (ret)
539                 goto err;
540
541         if (pdevinfo->properties) {
542                 ret = platform_device_add_properties(pdev,
543                                                      pdevinfo->properties);
544                 if (ret)
545                         goto err;
546         }
547
548         ret = platform_device_add(pdev);
549         if (ret) {
550 err:
551                 ACPI_COMPANION_SET(&pdev->dev, NULL);
552                 kfree(pdev->dev.dma_mask);
553
554 err_alloc:
555                 platform_device_put(pdev);
556                 return ERR_PTR(ret);
557         }
558
559         return pdev;
560 }
561 EXPORT_SYMBOL_GPL(platform_device_register_full);
562
563 static int platform_drv_probe(struct device *_dev)
564 {
565         struct platform_driver *drv = to_platform_driver(_dev->driver);
566         struct platform_device *dev = to_platform_device(_dev);
567         int ret;
568
569         ret = of_clk_set_defaults(_dev->of_node, false);
570         if (ret < 0)
571                 return ret;
572
573         ret = dev_pm_domain_attach(_dev, true);
574         if (ret)
575                 goto out;
576
577         if (drv->probe) {
578                 ret = drv->probe(dev);
579                 if (ret)
580                         dev_pm_domain_detach(_dev, true);
581         }
582
583 out:
584         if (drv->prevent_deferred_probe && ret == -EPROBE_DEFER) {
585                 dev_warn(_dev, "probe deferral not supported\n");
586                 ret = -ENXIO;
587         }
588
589         return ret;
590 }
591
592 static int platform_drv_probe_fail(struct device *_dev)
593 {
594         return -ENXIO;
595 }
596
597 static int platform_drv_remove(struct device *_dev)
598 {
599         struct platform_driver *drv = to_platform_driver(_dev->driver);
600         struct platform_device *dev = to_platform_device(_dev);
601         int ret = 0;
602
603         if (drv->remove)
604                 ret = drv->remove(dev);
605         dev_pm_domain_detach(_dev, true);
606
607         return ret;
608 }
609
610 static void platform_drv_shutdown(struct device *_dev)
611 {
612         struct platform_driver *drv = to_platform_driver(_dev->driver);
613         struct platform_device *dev = to_platform_device(_dev);
614
615         if (drv->shutdown)
616                 drv->shutdown(dev);
617 }
618
619 /**
620  * __platform_driver_register - register a driver for platform-level devices
621  * @drv: platform driver structure
622  * @owner: owning module/driver
623  */
624 int __platform_driver_register(struct platform_driver *drv,
625                                 struct module *owner)
626 {
627         drv->driver.owner = owner;
628         drv->driver.bus = &platform_bus_type;
629         drv->driver.probe = platform_drv_probe;
630         drv->driver.remove = platform_drv_remove;
631         drv->driver.shutdown = platform_drv_shutdown;
632
633         return driver_register(&drv->driver);
634 }
635 EXPORT_SYMBOL_GPL(__platform_driver_register);
636
637 /**
638  * platform_driver_unregister - unregister a driver for platform-level devices
639  * @drv: platform driver structure
640  */
641 void platform_driver_unregister(struct platform_driver *drv)
642 {
643         driver_unregister(&drv->driver);
644 }
645 EXPORT_SYMBOL_GPL(platform_driver_unregister);
646
647 /**
648  * __platform_driver_probe - register driver for non-hotpluggable device
649  * @drv: platform driver structure
650  * @probe: the driver probe routine, probably from an __init section
651  * @module: module which will be the owner of the driver
652  *
653  * Use this instead of platform_driver_register() when you know the device
654  * is not hotpluggable and has already been registered, and you want to
655  * remove its run-once probe() infrastructure from memory after the driver
656  * has bound to the device.
657  *
658  * One typical use for this would be with drivers for controllers integrated
659  * into system-on-chip processors, where the controller devices have been
660  * configured as part of board setup.
661  *
662  * Note that this is incompatible with deferred probing.
663  *
664  * Returns zero if the driver registered and bound to a device, else returns
665  * a negative error code and with the driver not registered.
666  */
667 int __init_or_module __platform_driver_probe(struct platform_driver *drv,
668                 int (*probe)(struct platform_device *), struct module *module)
669 {
670         int retval, code;
671
672         if (drv->driver.probe_type == PROBE_PREFER_ASYNCHRONOUS) {
673                 pr_err("%s: drivers registered with %s can not be probed asynchronously\n",
674                          drv->driver.name, __func__);
675                 return -EINVAL;
676         }
677
678         /*
679          * We have to run our probes synchronously because we check if
680          * we find any devices to bind to and exit with error if there
681          * are any.
682          */
683         drv->driver.probe_type = PROBE_FORCE_SYNCHRONOUS;
684
685         /*
686          * Prevent driver from requesting probe deferral to avoid further
687          * futile probe attempts.
688          */
689         drv->prevent_deferred_probe = true;
690
691         /* make sure driver won't have bind/unbind attributes */
692         drv->driver.suppress_bind_attrs = true;
693
694         /* temporary section violation during probe() */
695         drv->probe = probe;
696         retval = code = __platform_driver_register(drv, module);
697
698         /*
699          * Fixup that section violation, being paranoid about code scanning
700          * the list of drivers in order to probe new devices.  Check to see
701          * if the probe was successful, and make sure any forced probes of
702          * new devices fail.
703          */
704         spin_lock(&drv->driver.bus->p->klist_drivers.k_lock);
705         drv->probe = NULL;
706         if (code == 0 && list_empty(&drv->driver.p->klist_devices.k_list))
707                 retval = -ENODEV;
708         drv->driver.probe = platform_drv_probe_fail;
709         spin_unlock(&drv->driver.bus->p->klist_drivers.k_lock);
710
711         if (code != retval)
712                 platform_driver_unregister(drv);
713         return retval;
714 }
715 EXPORT_SYMBOL_GPL(__platform_driver_probe);
716
717 /**
718  * __platform_create_bundle - register driver and create corresponding device
719  * @driver: platform driver structure
720  * @probe: the driver probe routine, probably from an __init section
721  * @res: set of resources that needs to be allocated for the device
722  * @n_res: number of resources
723  * @data: platform specific data for this platform device
724  * @size: size of platform specific data
725  * @module: module which will be the owner of the driver
726  *
727  * Use this in legacy-style modules that probe hardware directly and
728  * register a single platform device and corresponding platform driver.
729  *
730  * Returns &struct platform_device pointer on success, or ERR_PTR() on error.
731  */
732 struct platform_device * __init_or_module __platform_create_bundle(
733                         struct platform_driver *driver,
734                         int (*probe)(struct platform_device *),
735                         struct resource *res, unsigned int n_res,
736                         const void *data, size_t size, struct module *module)
737 {
738         struct platform_device *pdev;
739         int error;
740
741         pdev = platform_device_alloc(driver->driver.name, -1);
742         if (!pdev) {
743                 error = -ENOMEM;
744                 goto err_out;
745         }
746
747         error = platform_device_add_resources(pdev, res, n_res);
748         if (error)
749                 goto err_pdev_put;
750
751         error = platform_device_add_data(pdev, data, size);
752         if (error)
753                 goto err_pdev_put;
754
755         error = platform_device_add(pdev);
756         if (error)
757                 goto err_pdev_put;
758
759         error = __platform_driver_probe(driver, probe, module);
760         if (error)
761                 goto err_pdev_del;
762
763         return pdev;
764
765 err_pdev_del:
766         platform_device_del(pdev);
767 err_pdev_put:
768         platform_device_put(pdev);
769 err_out:
770         return ERR_PTR(error);
771 }
772 EXPORT_SYMBOL_GPL(__platform_create_bundle);
773
774 /**
775  * __platform_register_drivers - register an array of platform drivers
776  * @drivers: an array of drivers to register
777  * @count: the number of drivers to register
778  * @owner: module owning the drivers
779  *
780  * Registers platform drivers specified by an array. On failure to register a
781  * driver, all previously registered drivers will be unregistered. Callers of
782  * this API should use platform_unregister_drivers() to unregister drivers in
783  * the reverse order.
784  *
785  * Returns: 0 on success or a negative error code on failure.
786  */
787 int __platform_register_drivers(struct platform_driver * const *drivers,
788                                 unsigned int count, struct module *owner)
789 {
790         unsigned int i;
791         int err;
792
793         for (i = 0; i < count; i++) {
794                 pr_debug("registering platform driver %ps\n", drivers[i]);
795
796                 err = __platform_driver_register(drivers[i], owner);
797                 if (err < 0) {
798                         pr_err("failed to register platform driver %ps: %d\n",
799                                drivers[i], err);
800                         goto error;
801                 }
802         }
803
804         return 0;
805
806 error:
807         while (i--) {
808                 pr_debug("unregistering platform driver %ps\n", drivers[i]);
809                 platform_driver_unregister(drivers[i]);
810         }
811
812         return err;
813 }
814 EXPORT_SYMBOL_GPL(__platform_register_drivers);
815
816 /**
817  * platform_unregister_drivers - unregister an array of platform drivers
818  * @drivers: an array of drivers to unregister
819  * @count: the number of drivers to unregister
820  *
821  * Unegisters platform drivers specified by an array. This is typically used
822  * to complement an earlier call to platform_register_drivers(). Drivers are
823  * unregistered in the reverse order in which they were registered.
824  */
825 void platform_unregister_drivers(struct platform_driver * const *drivers,
826                                  unsigned int count)
827 {
828         while (count--) {
829                 pr_debug("unregistering platform driver %ps\n", drivers[count]);
830                 platform_driver_unregister(drivers[count]);
831         }
832 }
833 EXPORT_SYMBOL_GPL(platform_unregister_drivers);
834
835 /* modalias support enables more hands-off userspace setup:
836  * (a) environment variable lets new-style hotplug events work once system is
837  *     fully running:  "modprobe $MODALIAS"
838  * (b) sysfs attribute lets new-style coldplug recover from hotplug events
839  *     mishandled before system is fully running:  "modprobe $(cat modalias)"
840  */
841 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
842                              char *buf)
843 {
844         struct platform_device  *pdev = to_platform_device(dev);
845         int len;
846
847         len = of_device_modalias(dev, buf, PAGE_SIZE);
848         if (len != -ENODEV)
849                 return len;
850
851         len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
852         if (len != -ENODEV)
853                 return len;
854
855         len = snprintf(buf, PAGE_SIZE, "platform:%s\n", pdev->name);
856
857         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
858 }
859 static DEVICE_ATTR_RO(modalias);
860
861 static ssize_t driver_override_store(struct device *dev,
862                                      struct device_attribute *attr,
863                                      const char *buf, size_t count)
864 {
865         struct platform_device *pdev = to_platform_device(dev);
866         char *driver_override, *old, *cp;
867
868         /* We need to keep extra room for a newline */
869         if (count >= (PAGE_SIZE - 1))
870                 return -EINVAL;
871
872         driver_override = kstrndup(buf, count, GFP_KERNEL);
873         if (!driver_override)
874                 return -ENOMEM;
875
876         cp = strchr(driver_override, '\n');
877         if (cp)
878                 *cp = '\0';
879
880         device_lock(dev);
881         old = pdev->driver_override;
882         if (strlen(driver_override)) {
883                 pdev->driver_override = driver_override;
884         } else {
885                 kfree(driver_override);
886                 pdev->driver_override = NULL;
887         }
888         device_unlock(dev);
889
890         kfree(old);
891
892         return count;
893 }
894
895 static ssize_t driver_override_show(struct device *dev,
896                                     struct device_attribute *attr, char *buf)
897 {
898         struct platform_device *pdev = to_platform_device(dev);
899         ssize_t len;
900
901         device_lock(dev);
902         len = sprintf(buf, "%s\n", pdev->driver_override);
903         device_unlock(dev);
904         return len;
905 }
906 static DEVICE_ATTR_RW(driver_override);
907
908
909 static struct attribute *platform_dev_attrs[] = {
910         &dev_attr_modalias.attr,
911         &dev_attr_driver_override.attr,
912         NULL,
913 };
914 ATTRIBUTE_GROUPS(platform_dev);
915
916 static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
917 {
918         struct platform_device  *pdev = to_platform_device(dev);
919         int rc;
920
921         /* Some devices have extra OF data and an OF-style MODALIAS */
922         rc = of_device_uevent_modalias(dev, env);
923         if (rc != -ENODEV)
924                 return rc;
925
926         rc = acpi_device_uevent_modalias(dev, env);
927         if (rc != -ENODEV)
928                 return rc;
929
930         add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX,
931                         pdev->name);
932         return 0;
933 }
934
935 static const struct platform_device_id *platform_match_id(
936                         const struct platform_device_id *id,
937                         struct platform_device *pdev)
938 {
939         while (id->name[0]) {
940                 if (strcmp(pdev->name, id->name) == 0) {
941                         pdev->id_entry = id;
942                         return id;
943                 }
944                 id++;
945         }
946         return NULL;
947 }
948
949 /**
950  * platform_match - bind platform device to platform driver.
951  * @dev: device.
952  * @drv: driver.
953  *
954  * Platform device IDs are assumed to be encoded like this:
955  * "<name><instance>", where <name> is a short description of the type of
956  * device, like "pci" or "floppy", and <instance> is the enumerated
957  * instance of the device, like '0' or '42'.  Driver IDs are simply
958  * "<name>".  So, extract the <name> from the platform_device structure,
959  * and compare it against the name of the driver. Return whether they match
960  * or not.
961  */
962 static int platform_match(struct device *dev, struct device_driver *drv)
963 {
964         struct platform_device *pdev = to_platform_device(dev);
965         struct platform_driver *pdrv = to_platform_driver(drv);
966
967         /* When driver_override is set, only bind to the matching driver */
968         if (pdev->driver_override)
969                 return !strcmp(pdev->driver_override, drv->name);
970
971         /* Attempt an OF style match first */
972         if (of_driver_match_device(dev, drv))
973                 return 1;
974
975         /* Then try ACPI style match */
976         if (acpi_driver_match_device(dev, drv))
977                 return 1;
978
979         /* Then try to match against the id table */
980         if (pdrv->id_table)
981                 return platform_match_id(pdrv->id_table, pdev) != NULL;
982
983         /* fall-back to driver name match */
984         return (strcmp(pdev->name, drv->name) == 0);
985 }
986
987 #ifdef CONFIG_PM_SLEEP
988
989 static int platform_legacy_suspend(struct device *dev, pm_message_t mesg)
990 {
991         struct platform_driver *pdrv = to_platform_driver(dev->driver);
992         struct platform_device *pdev = to_platform_device(dev);
993         int ret = 0;
994
995         if (dev->driver && pdrv->suspend)
996                 ret = pdrv->suspend(pdev, mesg);
997
998         return ret;
999 }
1000
1001 static int platform_legacy_resume(struct device *dev)
1002 {
1003         struct platform_driver *pdrv = to_platform_driver(dev->driver);
1004         struct platform_device *pdev = to_platform_device(dev);
1005         int ret = 0;
1006
1007         if (dev->driver && pdrv->resume)
1008                 ret = pdrv->resume(pdev);
1009
1010         return ret;
1011 }
1012
1013 #endif /* CONFIG_PM_SLEEP */
1014
1015 #ifdef CONFIG_SUSPEND
1016
1017 int platform_pm_suspend(struct device *dev)
1018 {
1019         struct device_driver *drv = dev->driver;
1020         int ret = 0;
1021
1022         if (!drv)
1023                 return 0;
1024
1025         if (drv->pm) {
1026                 if (drv->pm->suspend)
1027                         ret = drv->pm->suspend(dev);
1028         } else {
1029                 ret = platform_legacy_suspend(dev, PMSG_SUSPEND);
1030         }
1031
1032         return ret;
1033 }
1034
1035 int platform_pm_resume(struct device *dev)
1036 {
1037         struct device_driver *drv = dev->driver;
1038         int ret = 0;
1039
1040         if (!drv)
1041                 return 0;
1042
1043         if (drv->pm) {
1044                 if (drv->pm->resume)
1045                         ret = drv->pm->resume(dev);
1046         } else {
1047                 ret = platform_legacy_resume(dev);
1048         }
1049
1050         return ret;
1051 }
1052
1053 #endif /* CONFIG_SUSPEND */
1054
1055 #ifdef CONFIG_HIBERNATE_CALLBACKS
1056
1057 int platform_pm_freeze(struct device *dev)
1058 {
1059         struct device_driver *drv = dev->driver;
1060         int ret = 0;
1061
1062         if (!drv)
1063                 return 0;
1064
1065         if (drv->pm) {
1066                 if (drv->pm->freeze)
1067                         ret = drv->pm->freeze(dev);
1068         } else {
1069                 ret = platform_legacy_suspend(dev, PMSG_FREEZE);
1070         }
1071
1072         return ret;
1073 }
1074
1075 int platform_pm_thaw(struct device *dev)
1076 {
1077         struct device_driver *drv = dev->driver;
1078         int ret = 0;
1079
1080         if (!drv)
1081                 return 0;
1082
1083         if (drv->pm) {
1084                 if (drv->pm->thaw)
1085                         ret = drv->pm->thaw(dev);
1086         } else {
1087                 ret = platform_legacy_resume(dev);
1088         }
1089
1090         return ret;
1091 }
1092
1093 int platform_pm_poweroff(struct device *dev)
1094 {
1095         struct device_driver *drv = dev->driver;
1096         int ret = 0;
1097
1098         if (!drv)
1099                 return 0;
1100
1101         if (drv->pm) {
1102                 if (drv->pm->poweroff)
1103                         ret = drv->pm->poweroff(dev);
1104         } else {
1105                 ret = platform_legacy_suspend(dev, PMSG_HIBERNATE);
1106         }
1107
1108         return ret;
1109 }
1110
1111 int platform_pm_restore(struct device *dev)
1112 {
1113         struct device_driver *drv = dev->driver;
1114         int ret = 0;
1115
1116         if (!drv)
1117                 return 0;
1118
1119         if (drv->pm) {
1120                 if (drv->pm->restore)
1121                         ret = drv->pm->restore(dev);
1122         } else {
1123                 ret = platform_legacy_resume(dev);
1124         }
1125
1126         return ret;
1127 }
1128
1129 #endif /* CONFIG_HIBERNATE_CALLBACKS */
1130
1131 int platform_dma_configure(struct device *dev)
1132 {
1133         enum dev_dma_attr attr;
1134         int ret = 0;
1135
1136         if (dev->of_node) {
1137                 ret = of_dma_configure(dev, dev->of_node, true);
1138         } else if (has_acpi_companion(dev)) {
1139                 attr = acpi_get_dma_attr(to_acpi_device_node(dev->fwnode));
1140                 ret = acpi_dma_configure(dev, attr);
1141         }
1142
1143         return ret;
1144 }
1145
1146 static const struct dev_pm_ops platform_dev_pm_ops = {
1147         .runtime_suspend = pm_generic_runtime_suspend,
1148         .runtime_resume = pm_generic_runtime_resume,
1149         USE_PLATFORM_PM_SLEEP_OPS
1150 };
1151
1152 struct bus_type platform_bus_type = {
1153         .name           = "platform",
1154         .dev_groups     = platform_dev_groups,
1155         .match          = platform_match,
1156         .uevent         = platform_uevent,
1157         .dma_configure  = platform_dma_configure,
1158         .pm             = &platform_dev_pm_ops,
1159 };
1160 EXPORT_SYMBOL_GPL(platform_bus_type);
1161
1162 int __init platform_bus_init(void)
1163 {
1164         int error;
1165
1166         early_platform_cleanup();
1167
1168         error = device_register(&platform_bus);
1169         if (error) {
1170                 put_device(&platform_bus);
1171                 return error;
1172         }
1173         error =  bus_register(&platform_bus_type);
1174         if (error)
1175                 device_unregister(&platform_bus);
1176         of_platform_register_reconfig_notifier();
1177         return error;
1178 }
1179
1180 static __initdata LIST_HEAD(early_platform_driver_list);
1181 static __initdata LIST_HEAD(early_platform_device_list);
1182
1183 /**
1184  * early_platform_driver_register - register early platform driver
1185  * @epdrv: early_platform driver structure
1186  * @buf: string passed from early_param()
1187  *
1188  * Helper function for early_platform_init() / early_platform_init_buffer()
1189  */
1190 int __init early_platform_driver_register(struct early_platform_driver *epdrv,
1191                                           char *buf)
1192 {
1193         char *tmp;
1194         int n;
1195
1196         /* Simply add the driver to the end of the global list.
1197          * Drivers will by default be put on the list in compiled-in order.
1198          */
1199         if (!epdrv->list.next) {
1200                 INIT_LIST_HEAD(&epdrv->list);
1201                 list_add_tail(&epdrv->list, &early_platform_driver_list);
1202         }
1203
1204         /* If the user has specified device then make sure the driver
1205          * gets prioritized. The driver of the last device specified on
1206          * command line will be put first on the list.
1207          */
1208         n = strlen(epdrv->pdrv->driver.name);
1209         if (buf && !strncmp(buf, epdrv->pdrv->driver.name, n)) {
1210                 list_move(&epdrv->list, &early_platform_driver_list);
1211
1212                 /* Allow passing parameters after device name */
1213                 if (buf[n] == '\0' || buf[n] == ',')
1214                         epdrv->requested_id = -1;
1215                 else {
1216                         epdrv->requested_id = simple_strtoul(&buf[n + 1],
1217                                                              &tmp, 10);
1218
1219                         if (buf[n] != '.' || (tmp == &buf[n + 1])) {
1220                                 epdrv->requested_id = EARLY_PLATFORM_ID_ERROR;
1221                                 n = 0;
1222                         } else
1223                                 n += strcspn(&buf[n + 1], ",") + 1;
1224                 }
1225
1226                 if (buf[n] == ',')
1227                         n++;
1228
1229                 if (epdrv->bufsize) {
1230                         memcpy(epdrv->buffer, &buf[n],
1231                                min_t(int, epdrv->bufsize, strlen(&buf[n]) + 1));
1232                         epdrv->buffer[epdrv->bufsize - 1] = '\0';
1233                 }
1234         }
1235
1236         return 0;
1237 }
1238
1239 /**
1240  * early_platform_add_devices - adds a number of early platform devices
1241  * @devs: array of early platform devices to add
1242  * @num: number of early platform devices in array
1243  *
1244  * Used by early architecture code to register early platform devices and
1245  * their platform data.
1246  */
1247 void __init early_platform_add_devices(struct platform_device **devs, int num)
1248 {
1249         struct device *dev;
1250         int i;
1251
1252         /* simply add the devices to list */
1253         for (i = 0; i < num; i++) {
1254                 dev = &devs[i]->dev;
1255
1256                 if (!dev->devres_head.next) {
1257                         pm_runtime_early_init(dev);
1258                         INIT_LIST_HEAD(&dev->devres_head);
1259                         list_add_tail(&dev->devres_head,
1260                                       &early_platform_device_list);
1261                 }
1262         }
1263 }
1264
1265 /**
1266  * early_platform_driver_register_all - register early platform drivers
1267  * @class_str: string to identify early platform driver class
1268  *
1269  * Used by architecture code to register all early platform drivers
1270  * for a certain class. If omitted then only early platform drivers
1271  * with matching kernel command line class parameters will be registered.
1272  */
1273 void __init early_platform_driver_register_all(char *class_str)
1274 {
1275         /* The "class_str" parameter may or may not be present on the kernel
1276          * command line. If it is present then there may be more than one
1277          * matching parameter.
1278          *
1279          * Since we register our early platform drivers using early_param()
1280          * we need to make sure that they also get registered in the case
1281          * when the parameter is missing from the kernel command line.
1282          *
1283          * We use parse_early_options() to make sure the early_param() gets
1284          * called at least once. The early_param() may be called more than
1285          * once since the name of the preferred device may be specified on
1286          * the kernel command line. early_platform_driver_register() handles
1287          * this case for us.
1288          */
1289         parse_early_options(class_str);
1290 }
1291
1292 /**
1293  * early_platform_match - find early platform device matching driver
1294  * @epdrv: early platform driver structure
1295  * @id: id to match against
1296  */
1297 static struct platform_device * __init
1298 early_platform_match(struct early_platform_driver *epdrv, int id)
1299 {
1300         struct platform_device *pd;
1301
1302         list_for_each_entry(pd, &early_platform_device_list, dev.devres_head)
1303                 if (platform_match(&pd->dev, &epdrv->pdrv->driver))
1304                         if (pd->id == id)
1305                                 return pd;
1306
1307         return NULL;
1308 }
1309
1310 /**
1311  * early_platform_left - check if early platform driver has matching devices
1312  * @epdrv: early platform driver structure
1313  * @id: return true if id or above exists
1314  */
1315 static int __init early_platform_left(struct early_platform_driver *epdrv,
1316                                        int id)
1317 {
1318         struct platform_device *pd;
1319
1320         list_for_each_entry(pd, &early_platform_device_list, dev.devres_head)
1321                 if (platform_match(&pd->dev, &epdrv->pdrv->driver))
1322                         if (pd->id >= id)
1323                                 return 1;
1324
1325         return 0;
1326 }
1327
1328 /**
1329  * early_platform_driver_probe_id - probe drivers matching class_str and id
1330  * @class_str: string to identify early platform driver class
1331  * @id: id to match against
1332  * @nr_probe: number of platform devices to successfully probe before exiting
1333  */
1334 static int __init early_platform_driver_probe_id(char *class_str,
1335                                                  int id,
1336                                                  int nr_probe)
1337 {
1338         struct early_platform_driver *epdrv;
1339         struct platform_device *match;
1340         int match_id;
1341         int n = 0;
1342         int left = 0;
1343
1344         list_for_each_entry(epdrv, &early_platform_driver_list, list) {
1345                 /* only use drivers matching our class_str */
1346                 if (strcmp(class_str, epdrv->class_str))
1347                         continue;
1348
1349                 if (id == -2) {
1350                         match_id = epdrv->requested_id;
1351                         left = 1;
1352
1353                 } else {
1354                         match_id = id;
1355                         left += early_platform_left(epdrv, id);
1356
1357                         /* skip requested id */
1358                         switch (epdrv->requested_id) {
1359                         case EARLY_PLATFORM_ID_ERROR:
1360                         case EARLY_PLATFORM_ID_UNSET:
1361                                 break;
1362                         default:
1363                                 if (epdrv->requested_id == id)
1364                                         match_id = EARLY_PLATFORM_ID_UNSET;
1365                         }
1366                 }
1367
1368                 switch (match_id) {
1369                 case EARLY_PLATFORM_ID_ERROR:
1370                         pr_warn("%s: unable to parse %s parameter\n",
1371                                 class_str, epdrv->pdrv->driver.name);
1372                         /* fall-through */
1373                 case EARLY_PLATFORM_ID_UNSET:
1374                         match = NULL;
1375                         break;
1376                 default:
1377                         match = early_platform_match(epdrv, match_id);
1378                 }
1379
1380                 if (match) {
1381                         /*
1382                          * Set up a sensible init_name to enable
1383                          * dev_name() and others to be used before the
1384                          * rest of the driver core is initialized.
1385                          */
1386                         if (!match->dev.init_name && slab_is_available()) {
1387                                 if (match->id != -1)
1388                                         match->dev.init_name =
1389                                                 kasprintf(GFP_KERNEL, "%s.%d",
1390                                                           match->name,
1391                                                           match->id);
1392                                 else
1393                                         match->dev.init_name =
1394                                                 kasprintf(GFP_KERNEL, "%s",
1395                                                           match->name);
1396
1397                                 if (!match->dev.init_name)
1398                                         return -ENOMEM;
1399                         }
1400
1401                         if (epdrv->pdrv->probe(match))
1402                                 pr_warn("%s: unable to probe %s early.\n",
1403                                         class_str, match->name);
1404                         else
1405                                 n++;
1406                 }
1407
1408                 if (n >= nr_probe)
1409                         break;
1410         }
1411
1412         if (left)
1413                 return n;
1414         else
1415                 return -ENODEV;
1416 }
1417
1418 /**
1419  * early_platform_driver_probe - probe a class of registered drivers
1420  * @class_str: string to identify early platform driver class
1421  * @nr_probe: number of platform devices to successfully probe before exiting
1422  * @user_only: only probe user specified early platform devices
1423  *
1424  * Used by architecture code to probe registered early platform drivers
1425  * within a certain class. For probe to happen a registered early platform
1426  * device matching a registered early platform driver is needed.
1427  */
1428 int __init early_platform_driver_probe(char *class_str,
1429                                        int nr_probe,
1430                                        int user_only)
1431 {
1432         int k, n, i;
1433
1434         n = 0;
1435         for (i = -2; n < nr_probe; i++) {
1436                 k = early_platform_driver_probe_id(class_str, i, nr_probe - n);
1437
1438                 if (k < 0)
1439                         break;
1440
1441                 n += k;
1442
1443                 if (user_only)
1444                         break;
1445         }
1446
1447         return n;
1448 }
1449
1450 /**
1451  * early_platform_cleanup - clean up early platform code
1452  */
1453 void __init early_platform_cleanup(void)
1454 {
1455         struct platform_device *pd, *pd2;
1456
1457         /* clean up the devres list used to chain devices */
1458         list_for_each_entry_safe(pd, pd2, &early_platform_device_list,
1459                                  dev.devres_head) {
1460                 list_del(&pd->dev.devres_head);
1461                 memset(&pd->dev.devres_head, 0, sizeof(pd->dev.devres_head));
1462         }
1463 }
1464