1 // SPDX-License-Identifier: GPL-2.0
3 * platform.c - platform 'pseudo' bus for legacy devices
5 * Copyright (c) 2002-3 Patrick Mochel
6 * Copyright (c) 2002-3 Open Source Development Labs
8 * Please see Documentation/driver-api/driver-model/platform.rst for more
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 #include <linux/kmemleak.h>
30 #include <linux/types.h>
33 #include "power/power.h"
35 /* For automatically allocated device IDs */
36 static DEFINE_IDA(platform_devid_ida);
38 struct device platform_bus = {
39 .init_name = "platform",
41 EXPORT_SYMBOL_GPL(platform_bus);
44 * platform_get_resource - get a resource for a device
45 * @dev: platform device
46 * @type: resource type
47 * @num: resource index
49 struct resource *platform_get_resource(struct platform_device *dev,
50 unsigned int type, unsigned int num)
54 for (i = 0; i < dev->num_resources; i++) {
55 struct resource *r = &dev->resource[i];
57 if (type == resource_type(r) && num-- == 0)
62 EXPORT_SYMBOL_GPL(platform_get_resource);
64 #ifdef CONFIG_HAS_IOMEM
66 * devm_platform_get_and_ioremap_resource - call devm_ioremap_resource() for a
67 * platform device and get resource
69 * @pdev: platform device to use both for memory resource lookup as well as
71 * @index: resource index
72 * @res: optional output parameter to store a pointer to the obtained resource.
75 devm_platform_get_and_ioremap_resource(struct platform_device *pdev,
76 unsigned int index, struct resource **res)
80 r = platform_get_resource(pdev, IORESOURCE_MEM, index);
83 return devm_ioremap_resource(&pdev->dev, r);
85 EXPORT_SYMBOL_GPL(devm_platform_get_and_ioremap_resource);
88 * devm_platform_ioremap_resource - call devm_ioremap_resource() for a platform
91 * @pdev: platform device to use both for memory resource lookup as well as
93 * @index: resource index
95 void __iomem *devm_platform_ioremap_resource(struct platform_device *pdev,
98 return devm_platform_get_and_ioremap_resource(pdev, index, NULL);
100 EXPORT_SYMBOL_GPL(devm_platform_ioremap_resource);
103 * devm_platform_ioremap_resource_wc - write-combined variant of
104 * devm_platform_ioremap_resource()
106 * @pdev: platform device to use both for memory resource lookup as well as
107 * resource management
108 * @index: resource index
110 void __iomem *devm_platform_ioremap_resource_wc(struct platform_device *pdev,
113 struct resource *res;
115 res = platform_get_resource(pdev, IORESOURCE_MEM, index);
116 return devm_ioremap_resource_wc(&pdev->dev, res);
120 * devm_platform_ioremap_resource_byname - call devm_ioremap_resource for
121 * a platform device, retrieve the
124 * @pdev: platform device to use both for memory resource lookup as well as
125 * resource management
126 * @name: name of the resource
129 devm_platform_ioremap_resource_byname(struct platform_device *pdev,
132 struct resource *res;
134 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
135 return devm_ioremap_resource(&pdev->dev, res);
137 EXPORT_SYMBOL_GPL(devm_platform_ioremap_resource_byname);
138 #endif /* CONFIG_HAS_IOMEM */
141 * platform_get_irq_optional - get an optional IRQ for a device
142 * @dev: platform device
143 * @num: IRQ number index
145 * Gets an IRQ for a platform device. Device drivers should check the return
146 * value for errors so as to not pass a negative integer value to the
147 * request_irq() APIs. This is the same as platform_get_irq(), except that it
148 * does not print an error message if an IRQ can not be obtained.
152 * int irq = platform_get_irq_optional(pdev, 0);
156 * Return: non-zero IRQ number on success, negative error number on failure.
158 int platform_get_irq_optional(struct platform_device *dev, unsigned int num)
162 /* sparc does not have irqs represented as IORESOURCE_IRQ resources */
163 if (!dev || num >= dev->archdata.num_irqs)
165 ret = dev->archdata.irqs[num];
170 if (IS_ENABLED(CONFIG_OF_IRQ) && dev->dev.of_node) {
171 ret = of_irq_get(dev->dev.of_node, num);
172 if (ret > 0 || ret == -EPROBE_DEFER)
176 r = platform_get_resource(dev, IORESOURCE_IRQ, num);
177 if (has_acpi_companion(&dev->dev)) {
178 if (r && r->flags & IORESOURCE_DISABLED) {
179 ret = acpi_irq_get(ACPI_HANDLE(&dev->dev), num, r);
186 * The resources may pass trigger flags to the irqs that need
187 * to be set up. It so happens that the trigger flags for
188 * IORESOURCE_BITS correspond 1-to-1 to the IRQF_TRIGGER*
191 if (r && r->flags & IORESOURCE_BITS) {
192 struct irq_data *irqd;
194 irqd = irq_get_irq_data(r->start);
199 irqd_set_trigger_type(irqd, r->flags & IORESOURCE_BITS);
208 * For the index 0 interrupt, allow falling back to GpioInt
209 * resources. While a device could have both Interrupt and GpioInt
210 * resources, making this fallback ambiguous, in many common cases
211 * the device will only expose one IRQ, and this fallback
212 * allows a common code path across either kind of resource.
214 if (num == 0 && has_acpi_companion(&dev->dev)) {
215 ret = acpi_dev_gpio_irq_get(ACPI_COMPANION(&dev->dev), num);
216 /* Our callers expect -ENXIO for missing IRQs. */
217 if (ret >= 0 || ret == -EPROBE_DEFER)
224 WARN(ret == 0, "0 is an invalid IRQ number\n");
227 EXPORT_SYMBOL_GPL(platform_get_irq_optional);
230 * platform_get_irq - get an IRQ for a device
231 * @dev: platform device
232 * @num: IRQ number index
234 * Gets an IRQ for a platform device and prints an error message if finding the
235 * IRQ fails. Device drivers should check the return value for errors so as to
236 * not pass a negative integer value to the request_irq() APIs.
240 * int irq = platform_get_irq(pdev, 0);
244 * Return: non-zero IRQ number on success, negative error number on failure.
246 int platform_get_irq(struct platform_device *dev, unsigned int num)
250 ret = platform_get_irq_optional(dev, num);
251 if (ret < 0 && ret != -EPROBE_DEFER)
252 dev_err(&dev->dev, "IRQ index %u not found\n", num);
256 EXPORT_SYMBOL_GPL(platform_get_irq);
259 * platform_irq_count - Count the number of IRQs a platform device uses
260 * @dev: platform device
262 * Return: Number of IRQs a platform device uses or EPROBE_DEFER
264 int platform_irq_count(struct platform_device *dev)
268 while ((ret = platform_get_irq_optional(dev, nr)) >= 0)
271 if (ret == -EPROBE_DEFER)
276 EXPORT_SYMBOL_GPL(platform_irq_count);
279 * platform_get_resource_byname - get a resource for a device by name
280 * @dev: platform device
281 * @type: resource type
282 * @name: resource name
284 struct resource *platform_get_resource_byname(struct platform_device *dev,
290 for (i = 0; i < dev->num_resources; i++) {
291 struct resource *r = &dev->resource[i];
293 if (unlikely(!r->name))
296 if (type == resource_type(r) && !strcmp(r->name, name))
301 EXPORT_SYMBOL_GPL(platform_get_resource_byname);
303 static int __platform_get_irq_byname(struct platform_device *dev,
309 if (IS_ENABLED(CONFIG_OF_IRQ) && dev->dev.of_node) {
310 ret = of_irq_get_byname(dev->dev.of_node, name);
311 if (ret > 0 || ret == -EPROBE_DEFER)
315 r = platform_get_resource_byname(dev, IORESOURCE_IRQ, name);
317 WARN(r->start == 0, "0 is an invalid IRQ number\n");
325 * platform_get_irq_byname - get an IRQ for a device by name
326 * @dev: platform device
329 * Get an IRQ like platform_get_irq(), but then by name rather then by index.
331 * Return: non-zero IRQ number on success, negative error number on failure.
333 int platform_get_irq_byname(struct platform_device *dev, const char *name)
337 ret = __platform_get_irq_byname(dev, name);
338 if (ret < 0 && ret != -EPROBE_DEFER)
339 dev_err(&dev->dev, "IRQ %s not found\n", name);
343 EXPORT_SYMBOL_GPL(platform_get_irq_byname);
346 * platform_get_irq_byname_optional - get an optional IRQ for a device by name
347 * @dev: platform device
350 * Get an optional IRQ by name like platform_get_irq_byname(). Except that it
351 * does not print an error message if an IRQ can not be obtained.
353 * Return: non-zero IRQ number on success, negative error number on failure.
355 int platform_get_irq_byname_optional(struct platform_device *dev,
358 return __platform_get_irq_byname(dev, name);
360 EXPORT_SYMBOL_GPL(platform_get_irq_byname_optional);
363 * platform_add_devices - add a numbers of platform devices
364 * @devs: array of platform devices to add
365 * @num: number of platform devices in array
367 int platform_add_devices(struct platform_device **devs, int num)
371 for (i = 0; i < num; i++) {
372 ret = platform_device_register(devs[i]);
375 platform_device_unregister(devs[i]);
382 EXPORT_SYMBOL_GPL(platform_add_devices);
384 struct platform_object {
385 struct platform_device pdev;
390 * Set up default DMA mask for platform devices if the they weren't
391 * previously set by the architecture / DT.
393 static void setup_pdev_dma_masks(struct platform_device *pdev)
395 pdev->dev.dma_parms = &pdev->dma_parms;
397 if (!pdev->dev.coherent_dma_mask)
398 pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
399 if (!pdev->dev.dma_mask) {
400 pdev->platform_dma_mask = DMA_BIT_MASK(32);
401 pdev->dev.dma_mask = &pdev->platform_dma_mask;
406 * platform_device_put - destroy a platform device
407 * @pdev: platform device to free
409 * Free all memory associated with a platform device. This function must
410 * _only_ be externally called in error cases. All other usage is a bug.
412 void platform_device_put(struct platform_device *pdev)
414 if (!IS_ERR_OR_NULL(pdev))
415 put_device(&pdev->dev);
417 EXPORT_SYMBOL_GPL(platform_device_put);
419 static void platform_device_release(struct device *dev)
421 struct platform_object *pa = container_of(dev, struct platform_object,
424 of_device_node_put(&pa->pdev.dev);
425 kfree(pa->pdev.dev.platform_data);
426 kfree(pa->pdev.mfd_cell);
427 kfree(pa->pdev.resource);
428 kfree(pa->pdev.driver_override);
433 * platform_device_alloc - create a platform device
434 * @name: base name of the device we're adding
437 * Create a platform device object which can have other objects attached
438 * to it, and which will have attached objects freed when it is released.
440 struct platform_device *platform_device_alloc(const char *name, int id)
442 struct platform_object *pa;
444 pa = kzalloc(sizeof(*pa) + strlen(name) + 1, GFP_KERNEL);
446 strcpy(pa->name, name);
447 pa->pdev.name = pa->name;
449 device_initialize(&pa->pdev.dev);
450 pa->pdev.dev.release = platform_device_release;
451 setup_pdev_dma_masks(&pa->pdev);
454 return pa ? &pa->pdev : NULL;
456 EXPORT_SYMBOL_GPL(platform_device_alloc);
459 * platform_device_add_resources - add resources to a platform device
460 * @pdev: platform device allocated by platform_device_alloc to add resources to
461 * @res: set of resources that needs to be allocated for the device
462 * @num: number of resources
464 * Add a copy of the resources to the platform device. The memory
465 * associated with the resources will be freed when the platform device is
468 int platform_device_add_resources(struct platform_device *pdev,
469 const struct resource *res, unsigned int num)
471 struct resource *r = NULL;
474 r = kmemdup(res, sizeof(struct resource) * num, GFP_KERNEL);
479 kfree(pdev->resource);
481 pdev->num_resources = num;
484 EXPORT_SYMBOL_GPL(platform_device_add_resources);
487 * platform_device_add_data - add platform-specific data to a platform device
488 * @pdev: platform device allocated by platform_device_alloc to add resources to
489 * @data: platform specific data for this platform device
490 * @size: size of platform specific data
492 * Add a copy of platform specific data to the platform device's
493 * platform_data pointer. The memory associated with the platform data
494 * will be freed when the platform device is released.
496 int platform_device_add_data(struct platform_device *pdev, const void *data,
502 d = kmemdup(data, size, GFP_KERNEL);
507 kfree(pdev->dev.platform_data);
508 pdev->dev.platform_data = d;
511 EXPORT_SYMBOL_GPL(platform_device_add_data);
514 * platform_device_add_properties - add built-in properties to a platform device
515 * @pdev: platform device to add properties to
516 * @properties: null terminated array of properties to add
518 * The function will take deep copy of @properties and attach the copy to the
519 * platform device. The memory associated with properties will be freed when the
520 * platform device is released.
522 int platform_device_add_properties(struct platform_device *pdev,
523 const struct property_entry *properties)
525 return device_add_properties(&pdev->dev, properties);
527 EXPORT_SYMBOL_GPL(platform_device_add_properties);
530 * platform_device_add - add a platform device to device hierarchy
531 * @pdev: platform device we're adding
533 * This is part 2 of platform_device_register(), though may be called
534 * separately _iff_ pdev was allocated by platform_device_alloc().
536 int platform_device_add(struct platform_device *pdev)
544 if (!pdev->dev.parent)
545 pdev->dev.parent = &platform_bus;
547 pdev->dev.bus = &platform_bus_type;
551 dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
553 case PLATFORM_DEVID_NONE:
554 dev_set_name(&pdev->dev, "%s", pdev->name);
556 case PLATFORM_DEVID_AUTO:
558 * Automatically allocated device ID. We mark it as such so
559 * that we remember it must be freed, and we append a suffix
560 * to avoid namespace collision with explicit IDs.
562 ret = ida_simple_get(&platform_devid_ida, 0, 0, GFP_KERNEL);
566 pdev->id_auto = true;
567 dev_set_name(&pdev->dev, "%s.%d.auto", pdev->name, pdev->id);
571 for (i = 0; i < pdev->num_resources; i++) {
572 struct resource *p, *r = &pdev->resource[i];
575 r->name = dev_name(&pdev->dev);
579 if (resource_type(r) == IORESOURCE_MEM)
581 else if (resource_type(r) == IORESOURCE_IO)
582 p = &ioport_resource;
586 ret = insert_resource(p, r);
588 dev_err(&pdev->dev, "failed to claim resource %d: %pR\n", i, r);
594 pr_debug("Registering platform device '%s'. Parent at %s\n",
595 dev_name(&pdev->dev), dev_name(pdev->dev.parent));
597 ret = device_add(&pdev->dev);
603 ida_simple_remove(&platform_devid_ida, pdev->id);
604 pdev->id = PLATFORM_DEVID_AUTO;
608 struct resource *r = &pdev->resource[i];
616 EXPORT_SYMBOL_GPL(platform_device_add);
619 * platform_device_del - remove a platform-level device
620 * @pdev: platform device we're removing
622 * Note that this function will also release all memory- and port-based
623 * resources owned by the device (@dev->resource). This function must
624 * _only_ be externally called in error cases. All other usage is a bug.
626 void platform_device_del(struct platform_device *pdev)
630 if (!IS_ERR_OR_NULL(pdev)) {
631 device_del(&pdev->dev);
634 ida_simple_remove(&platform_devid_ida, pdev->id);
635 pdev->id = PLATFORM_DEVID_AUTO;
638 for (i = 0; i < pdev->num_resources; i++) {
639 struct resource *r = &pdev->resource[i];
645 EXPORT_SYMBOL_GPL(platform_device_del);
648 * platform_device_register - add a platform-level device
649 * @pdev: platform device we're adding
651 int platform_device_register(struct platform_device *pdev)
653 device_initialize(&pdev->dev);
654 setup_pdev_dma_masks(pdev);
655 return platform_device_add(pdev);
657 EXPORT_SYMBOL_GPL(platform_device_register);
660 * platform_device_unregister - unregister a platform-level device
661 * @pdev: platform device we're unregistering
663 * Unregistration is done in 2 steps. First we release all resources
664 * and remove it from the subsystem, then we drop reference count by
665 * calling platform_device_put().
667 void platform_device_unregister(struct platform_device *pdev)
669 platform_device_del(pdev);
670 platform_device_put(pdev);
672 EXPORT_SYMBOL_GPL(platform_device_unregister);
675 * platform_device_register_full - add a platform-level device with
676 * resources and platform-specific data
678 * @pdevinfo: data used to create device
680 * Returns &struct platform_device pointer on success, or ERR_PTR() on error.
682 struct platform_device *platform_device_register_full(
683 const struct platform_device_info *pdevinfo)
686 struct platform_device *pdev;
688 pdev = platform_device_alloc(pdevinfo->name, pdevinfo->id);
690 return ERR_PTR(-ENOMEM);
692 pdev->dev.parent = pdevinfo->parent;
693 pdev->dev.fwnode = pdevinfo->fwnode;
694 pdev->dev.of_node = of_node_get(to_of_node(pdev->dev.fwnode));
695 pdev->dev.of_node_reused = pdevinfo->of_node_reused;
697 if (pdevinfo->dma_mask) {
698 pdev->platform_dma_mask = pdevinfo->dma_mask;
699 pdev->dev.dma_mask = &pdev->platform_dma_mask;
700 pdev->dev.coherent_dma_mask = pdevinfo->dma_mask;
703 ret = platform_device_add_resources(pdev,
704 pdevinfo->res, pdevinfo->num_res);
708 ret = platform_device_add_data(pdev,
709 pdevinfo->data, pdevinfo->size_data);
713 if (pdevinfo->properties) {
714 ret = platform_device_add_properties(pdev,
715 pdevinfo->properties);
720 ret = platform_device_add(pdev);
723 ACPI_COMPANION_SET(&pdev->dev, NULL);
724 platform_device_put(pdev);
730 EXPORT_SYMBOL_GPL(platform_device_register_full);
732 static int platform_drv_probe(struct device *_dev)
734 struct platform_driver *drv = to_platform_driver(_dev->driver);
735 struct platform_device *dev = to_platform_device(_dev);
738 ret = of_clk_set_defaults(_dev->of_node, false);
742 ret = dev_pm_domain_attach(_dev, true);
747 ret = drv->probe(dev);
749 dev_pm_domain_detach(_dev, true);
753 if (drv->prevent_deferred_probe && ret == -EPROBE_DEFER) {
754 dev_warn(_dev, "probe deferral not supported\n");
761 static int platform_drv_probe_fail(struct device *_dev)
766 static int platform_drv_remove(struct device *_dev)
768 struct platform_driver *drv = to_platform_driver(_dev->driver);
769 struct platform_device *dev = to_platform_device(_dev);
773 ret = drv->remove(dev);
774 dev_pm_domain_detach(_dev, true);
779 static void platform_drv_shutdown(struct device *_dev)
781 struct platform_driver *drv = to_platform_driver(_dev->driver);
782 struct platform_device *dev = to_platform_device(_dev);
789 * __platform_driver_register - register a driver for platform-level devices
790 * @drv: platform driver structure
791 * @owner: owning module/driver
793 int __platform_driver_register(struct platform_driver *drv,
794 struct module *owner)
796 drv->driver.owner = owner;
797 drv->driver.bus = &platform_bus_type;
798 drv->driver.probe = platform_drv_probe;
799 drv->driver.remove = platform_drv_remove;
800 drv->driver.shutdown = platform_drv_shutdown;
802 return driver_register(&drv->driver);
804 EXPORT_SYMBOL_GPL(__platform_driver_register);
807 * platform_driver_unregister - unregister a driver for platform-level devices
808 * @drv: platform driver structure
810 void platform_driver_unregister(struct platform_driver *drv)
812 driver_unregister(&drv->driver);
814 EXPORT_SYMBOL_GPL(platform_driver_unregister);
817 * __platform_driver_probe - register driver for non-hotpluggable device
818 * @drv: platform driver structure
819 * @probe: the driver probe routine, probably from an __init section
820 * @module: module which will be the owner of the driver
822 * Use this instead of platform_driver_register() when you know the device
823 * is not hotpluggable and has already been registered, and you want to
824 * remove its run-once probe() infrastructure from memory after the driver
825 * has bound to the device.
827 * One typical use for this would be with drivers for controllers integrated
828 * into system-on-chip processors, where the controller devices have been
829 * configured as part of board setup.
831 * Note that this is incompatible with deferred probing.
833 * Returns zero if the driver registered and bound to a device, else returns
834 * a negative error code and with the driver not registered.
836 int __init_or_module __platform_driver_probe(struct platform_driver *drv,
837 int (*probe)(struct platform_device *), struct module *module)
841 if (drv->driver.probe_type == PROBE_PREFER_ASYNCHRONOUS) {
842 pr_err("%s: drivers registered with %s can not be probed asynchronously\n",
843 drv->driver.name, __func__);
848 * We have to run our probes synchronously because we check if
849 * we find any devices to bind to and exit with error if there
852 drv->driver.probe_type = PROBE_FORCE_SYNCHRONOUS;
855 * Prevent driver from requesting probe deferral to avoid further
856 * futile probe attempts.
858 drv->prevent_deferred_probe = true;
860 /* make sure driver won't have bind/unbind attributes */
861 drv->driver.suppress_bind_attrs = true;
863 /* temporary section violation during probe() */
865 retval = code = __platform_driver_register(drv, module);
870 * Fixup that section violation, being paranoid about code scanning
871 * the list of drivers in order to probe new devices. Check to see
872 * if the probe was successful, and make sure any forced probes of
875 spin_lock(&drv->driver.bus->p->klist_drivers.k_lock);
877 if (code == 0 && list_empty(&drv->driver.p->klist_devices.k_list))
879 drv->driver.probe = platform_drv_probe_fail;
880 spin_unlock(&drv->driver.bus->p->klist_drivers.k_lock);
883 platform_driver_unregister(drv);
886 EXPORT_SYMBOL_GPL(__platform_driver_probe);
889 * __platform_create_bundle - register driver and create corresponding device
890 * @driver: platform driver structure
891 * @probe: the driver probe routine, probably from an __init section
892 * @res: set of resources that needs to be allocated for the device
893 * @n_res: number of resources
894 * @data: platform specific data for this platform device
895 * @size: size of platform specific data
896 * @module: module which will be the owner of the driver
898 * Use this in legacy-style modules that probe hardware directly and
899 * register a single platform device and corresponding platform driver.
901 * Returns &struct platform_device pointer on success, or ERR_PTR() on error.
903 struct platform_device * __init_or_module __platform_create_bundle(
904 struct platform_driver *driver,
905 int (*probe)(struct platform_device *),
906 struct resource *res, unsigned int n_res,
907 const void *data, size_t size, struct module *module)
909 struct platform_device *pdev;
912 pdev = platform_device_alloc(driver->driver.name, -1);
918 error = platform_device_add_resources(pdev, res, n_res);
922 error = platform_device_add_data(pdev, data, size);
926 error = platform_device_add(pdev);
930 error = __platform_driver_probe(driver, probe, module);
937 platform_device_del(pdev);
939 platform_device_put(pdev);
941 return ERR_PTR(error);
943 EXPORT_SYMBOL_GPL(__platform_create_bundle);
946 * __platform_register_drivers - register an array of platform drivers
947 * @drivers: an array of drivers to register
948 * @count: the number of drivers to register
949 * @owner: module owning the drivers
951 * Registers platform drivers specified by an array. On failure to register a
952 * driver, all previously registered drivers will be unregistered. Callers of
953 * this API should use platform_unregister_drivers() to unregister drivers in
956 * Returns: 0 on success or a negative error code on failure.
958 int __platform_register_drivers(struct platform_driver * const *drivers,
959 unsigned int count, struct module *owner)
964 for (i = 0; i < count; i++) {
965 pr_debug("registering platform driver %ps\n", drivers[i]);
967 err = __platform_driver_register(drivers[i], owner);
969 pr_err("failed to register platform driver %ps: %d\n",
979 pr_debug("unregistering platform driver %ps\n", drivers[i]);
980 platform_driver_unregister(drivers[i]);
985 EXPORT_SYMBOL_GPL(__platform_register_drivers);
988 * platform_unregister_drivers - unregister an array of platform drivers
989 * @drivers: an array of drivers to unregister
990 * @count: the number of drivers to unregister
992 * Unregisters platform drivers specified by an array. This is typically used
993 * to complement an earlier call to platform_register_drivers(). Drivers are
994 * unregistered in the reverse order in which they were registered.
996 void platform_unregister_drivers(struct platform_driver * const *drivers,
1000 pr_debug("unregistering platform driver %ps\n", drivers[count]);
1001 platform_driver_unregister(drivers[count]);
1004 EXPORT_SYMBOL_GPL(platform_unregister_drivers);
1006 /* modalias support enables more hands-off userspace setup:
1007 * (a) environment variable lets new-style hotplug events work once system is
1008 * fully running: "modprobe $MODALIAS"
1009 * (b) sysfs attribute lets new-style coldplug recover from hotplug events
1010 * mishandled before system is fully running: "modprobe $(cat modalias)"
1012 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
1015 struct platform_device *pdev = to_platform_device(dev);
1018 len = of_device_modalias(dev, buf, PAGE_SIZE);
1022 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
1026 len = snprintf(buf, PAGE_SIZE, "platform:%s\n", pdev->name);
1028 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
1030 static DEVICE_ATTR_RO(modalias);
1032 static ssize_t driver_override_store(struct device *dev,
1033 struct device_attribute *attr,
1034 const char *buf, size_t count)
1036 struct platform_device *pdev = to_platform_device(dev);
1037 char *driver_override, *old, *cp;
1039 /* We need to keep extra room for a newline */
1040 if (count >= (PAGE_SIZE - 1))
1043 driver_override = kstrndup(buf, count, GFP_KERNEL);
1044 if (!driver_override)
1047 cp = strchr(driver_override, '\n');
1052 old = pdev->driver_override;
1053 if (strlen(driver_override)) {
1054 pdev->driver_override = driver_override;
1056 kfree(driver_override);
1057 pdev->driver_override = NULL;
1066 static ssize_t driver_override_show(struct device *dev,
1067 struct device_attribute *attr, char *buf)
1069 struct platform_device *pdev = to_platform_device(dev);
1073 len = sprintf(buf, "%s\n", pdev->driver_override);
1077 static DEVICE_ATTR_RW(driver_override);
1080 static struct attribute *platform_dev_attrs[] = {
1081 &dev_attr_modalias.attr,
1082 &dev_attr_driver_override.attr,
1085 ATTRIBUTE_GROUPS(platform_dev);
1087 static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
1089 struct platform_device *pdev = to_platform_device(dev);
1092 /* Some devices have extra OF data and an OF-style MODALIAS */
1093 rc = of_device_uevent_modalias(dev, env);
1097 rc = acpi_device_uevent_modalias(dev, env);
1101 add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX,
1106 static const struct platform_device_id *platform_match_id(
1107 const struct platform_device_id *id,
1108 struct platform_device *pdev)
1110 while (id->name[0]) {
1111 if (strcmp(pdev->name, id->name) == 0) {
1112 pdev->id_entry = id;
1121 * platform_match - bind platform device to platform driver.
1125 * Platform device IDs are assumed to be encoded like this:
1126 * "<name><instance>", where <name> is a short description of the type of
1127 * device, like "pci" or "floppy", and <instance> is the enumerated
1128 * instance of the device, like '0' or '42'. Driver IDs are simply
1129 * "<name>". So, extract the <name> from the platform_device structure,
1130 * and compare it against the name of the driver. Return whether they match
1133 static int platform_match(struct device *dev, struct device_driver *drv)
1135 struct platform_device *pdev = to_platform_device(dev);
1136 struct platform_driver *pdrv = to_platform_driver(drv);
1138 /* When driver_override is set, only bind to the matching driver */
1139 if (pdev->driver_override)
1140 return !strcmp(pdev->driver_override, drv->name);
1142 /* Attempt an OF style match first */
1143 if (of_driver_match_device(dev, drv))
1146 /* Then try ACPI style match */
1147 if (acpi_driver_match_device(dev, drv))
1150 /* Then try to match against the id table */
1152 return platform_match_id(pdrv->id_table, pdev) != NULL;
1154 /* fall-back to driver name match */
1155 return (strcmp(pdev->name, drv->name) == 0);
1158 #ifdef CONFIG_PM_SLEEP
1160 static int platform_legacy_suspend(struct device *dev, pm_message_t mesg)
1162 struct platform_driver *pdrv = to_platform_driver(dev->driver);
1163 struct platform_device *pdev = to_platform_device(dev);
1166 if (dev->driver && pdrv->suspend)
1167 ret = pdrv->suspend(pdev, mesg);
1172 static int platform_legacy_resume(struct device *dev)
1174 struct platform_driver *pdrv = to_platform_driver(dev->driver);
1175 struct platform_device *pdev = to_platform_device(dev);
1178 if (dev->driver && pdrv->resume)
1179 ret = pdrv->resume(pdev);
1184 #endif /* CONFIG_PM_SLEEP */
1186 #ifdef CONFIG_SUSPEND
1188 int platform_pm_suspend(struct device *dev)
1190 struct device_driver *drv = dev->driver;
1197 if (drv->pm->suspend)
1198 ret = drv->pm->suspend(dev);
1200 ret = platform_legacy_suspend(dev, PMSG_SUSPEND);
1206 int platform_pm_resume(struct device *dev)
1208 struct device_driver *drv = dev->driver;
1215 if (drv->pm->resume)
1216 ret = drv->pm->resume(dev);
1218 ret = platform_legacy_resume(dev);
1224 #endif /* CONFIG_SUSPEND */
1226 #ifdef CONFIG_HIBERNATE_CALLBACKS
1228 int platform_pm_freeze(struct device *dev)
1230 struct device_driver *drv = dev->driver;
1237 if (drv->pm->freeze)
1238 ret = drv->pm->freeze(dev);
1240 ret = platform_legacy_suspend(dev, PMSG_FREEZE);
1246 int platform_pm_thaw(struct device *dev)
1248 struct device_driver *drv = dev->driver;
1256 ret = drv->pm->thaw(dev);
1258 ret = platform_legacy_resume(dev);
1264 int platform_pm_poweroff(struct device *dev)
1266 struct device_driver *drv = dev->driver;
1273 if (drv->pm->poweroff)
1274 ret = drv->pm->poweroff(dev);
1276 ret = platform_legacy_suspend(dev, PMSG_HIBERNATE);
1282 int platform_pm_restore(struct device *dev)
1284 struct device_driver *drv = dev->driver;
1291 if (drv->pm->restore)
1292 ret = drv->pm->restore(dev);
1294 ret = platform_legacy_resume(dev);
1300 #endif /* CONFIG_HIBERNATE_CALLBACKS */
1302 int platform_dma_configure(struct device *dev)
1304 enum dev_dma_attr attr;
1308 ret = of_dma_configure(dev, dev->of_node, true);
1309 } else if (has_acpi_companion(dev)) {
1310 attr = acpi_get_dma_attr(to_acpi_device_node(dev->fwnode));
1311 ret = acpi_dma_configure(dev, attr);
1317 static const struct dev_pm_ops platform_dev_pm_ops = {
1318 .runtime_suspend = pm_generic_runtime_suspend,
1319 .runtime_resume = pm_generic_runtime_resume,
1320 USE_PLATFORM_PM_SLEEP_OPS
1323 struct bus_type platform_bus_type = {
1325 .dev_groups = platform_dev_groups,
1326 .match = platform_match,
1327 .uevent = platform_uevent,
1328 .dma_configure = platform_dma_configure,
1329 .pm = &platform_dev_pm_ops,
1331 EXPORT_SYMBOL_GPL(platform_bus_type);
1333 static inline int __platform_match(struct device *dev, const void *drv)
1335 return platform_match(dev, (struct device_driver *)drv);
1339 * platform_find_device_by_driver - Find a platform device with a given
1341 * @start: The device to start the search from.
1342 * @drv: The device driver to look for.
1344 struct device *platform_find_device_by_driver(struct device *start,
1345 const struct device_driver *drv)
1347 return bus_find_device(&platform_bus_type, start, drv,
1350 EXPORT_SYMBOL_GPL(platform_find_device_by_driver);
1352 void __weak __init early_platform_cleanup(void) { }
1354 int __init platform_bus_init(void)
1358 early_platform_cleanup();
1360 error = device_register(&platform_bus);
1362 put_device(&platform_bus);
1365 error = bus_register(&platform_bus_type);
1367 device_unregister(&platform_bus);
1368 of_platform_register_reconfig_notifier();