LCOV - code coverage report
Current view: top level - drivers/base - platform.c (source / functions) Hit Total Coverage
Test: landlock.info Lines: 192 477 40.3 %
Date: 2021-04-22 12:43:58 Functions: 20 50 40.0 %

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

Generated by: LCOV version 1.14