LCOV - code coverage report
Current view: top level - drivers/pnp/pnpacpi - core.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 64 142 45.1 %
Date: 2022-04-01 13:59:58 Functions: 6 12 50.0 %
Branches: 37 132 28.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  * pnpacpi -- PnP ACPI driver
       4                 :            :  *
       5                 :            :  * Copyright (c) 2004 Matthieu Castet <castet.matthieu@free.fr>
       6                 :            :  * Copyright (c) 2004 Li Shaohua <shaohua.li@intel.com>
       7                 :            :  */
       8                 :            : 
       9                 :            : #include <linux/export.h>
      10                 :            : #include <linux/acpi.h>
      11                 :            : #include <linux/pnp.h>
      12                 :            : #include <linux/slab.h>
      13                 :            : #include <linux/mod_devicetable.h>
      14                 :            : 
      15                 :            : #include "../base.h"
      16                 :            : #include "pnpacpi.h"
      17                 :            : 
      18                 :            : static int num;
      19                 :            : 
      20                 :            : /*
      21                 :            :  * Compatible Device IDs
      22                 :            :  */
      23                 :            : #define TEST_HEX(c) \
      24                 :            :         if (!(('0' <= (c) && (c) <= '9') || ('A' <= (c) && (c) <= 'F'))) \
      25                 :            :                 return 0
      26                 :            : #define TEST_ALPHA(c) \
      27                 :            :         if (!('A' <= (c) && (c) <= 'Z')) \
      28                 :            :                 return 0
      29                 :        468 : static int __init ispnpidacpi(const char *id)
      30                 :            : {
      31         [ +  - ]:        468 :         TEST_ALPHA(id[0]);
      32         [ +  - ]:        468 :         TEST_ALPHA(id[1]);
      33         [ +  - ]:        468 :         TEST_ALPHA(id[2]);
      34         [ +  - ]:        468 :         TEST_HEX(id[3]);
      35         [ +  - ]:        468 :         TEST_HEX(id[4]);
      36         [ +  - ]:        468 :         TEST_HEX(id[5]);
      37         [ +  - ]:        468 :         TEST_HEX(id[6]);
      38         [ -  + ]:        468 :         if (id[7] != '\0')
      39                 :          0 :                 return 0;
      40                 :            :         return 1;
      41                 :            : }
      42                 :            : 
      43                 :          0 : static int pnpacpi_get_resources(struct pnp_dev *dev)
      44                 :            : {
      45         [ #  # ]:          0 :         pnp_dbg(&dev->dev, "get resources\n");
      46                 :          0 :         return pnpacpi_parse_allocated_resource(dev);
      47                 :            : }
      48                 :            : 
      49                 :          0 : static int pnpacpi_set_resources(struct pnp_dev *dev)
      50                 :            : {
      51                 :          0 :         struct acpi_device *acpi_dev;
      52                 :          0 :         acpi_handle handle;
      53                 :          0 :         int ret = 0;
      54                 :            : 
      55         [ #  # ]:          0 :         pnp_dbg(&dev->dev, "set resources\n");
      56                 :            : 
      57         [ #  # ]:          0 :         acpi_dev = ACPI_COMPANION(&dev->dev);
      58         [ #  # ]:          0 :         if (!acpi_dev) {
      59                 :            :                 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__);
      60                 :            :                 return -ENODEV;
      61                 :            :         }
      62                 :            : 
      63   [ #  #  #  # ]:          0 :         if (WARN_ON_ONCE(acpi_dev != dev->data))
      64                 :          0 :                 dev->data = acpi_dev;
      65                 :            : 
      66                 :          0 :         handle = acpi_dev->handle;
      67         [ #  # ]:          0 :         if (acpi_has_method(handle, METHOD_NAME__SRS)) {
      68                 :          0 :                 struct acpi_buffer buffer;
      69                 :            : 
      70                 :          0 :                 ret = pnpacpi_build_resource_template(dev, &buffer);
      71         [ #  # ]:          0 :                 if (ret)
      72                 :          0 :                         return ret;
      73                 :            : 
      74                 :          0 :                 ret = pnpacpi_encode_resources(dev, &buffer);
      75         [ #  # ]:          0 :                 if (!ret) {
      76                 :          0 :                         acpi_status status;
      77                 :            : 
      78                 :          0 :                         status = acpi_set_current_resources(handle, &buffer);
      79         [ #  # ]:          0 :                         if (ACPI_FAILURE(status))
      80                 :          0 :                                 ret = -EIO;
      81                 :            :                 }
      82                 :          0 :                 kfree(buffer.pointer);
      83                 :            :         }
      84   [ #  #  #  # ]:          0 :         if (!ret && acpi_device_power_manageable(acpi_dev))
      85                 :          0 :                 ret = acpi_device_set_power(acpi_dev, ACPI_STATE_D0);
      86                 :            : 
      87                 :            :         return ret;
      88                 :            : }
      89                 :            : 
      90                 :          0 : static int pnpacpi_disable_resources(struct pnp_dev *dev)
      91                 :            : {
      92                 :          0 :         struct acpi_device *acpi_dev;
      93                 :          0 :         acpi_status status;
      94                 :            : 
      95                 :          0 :         dev_dbg(&dev->dev, "disable resources\n");
      96                 :            : 
      97         [ #  # ]:          0 :         acpi_dev = ACPI_COMPANION(&dev->dev);
      98         [ #  # ]:          0 :         if (!acpi_dev) {
      99                 :            :                 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__);
     100                 :            :                 return 0;
     101                 :            :         }
     102                 :            : 
     103                 :            :         /* acpi_unregister_gsi(pnp_irq(dev, 0)); */
     104         [ #  # ]:          0 :         if (acpi_device_power_manageable(acpi_dev))
     105                 :          0 :                 acpi_device_set_power(acpi_dev, ACPI_STATE_D3_COLD);
     106                 :            : 
     107                 :            :         /* continue even if acpi_device_set_power() fails */
     108                 :          0 :         status = acpi_evaluate_object(acpi_dev->handle, "_DIS", NULL, NULL);
     109         [ #  # ]:          0 :         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND)
     110                 :          0 :                 return -ENODEV;
     111                 :            : 
     112                 :            :         return 0;
     113                 :            : }
     114                 :            : 
     115                 :            : #ifdef CONFIG_ACPI_SLEEP
     116                 :        468 : static bool pnpacpi_can_wakeup(struct pnp_dev *dev)
     117                 :            : {
     118         [ +  - ]:        468 :         struct acpi_device *acpi_dev = ACPI_COMPANION(&dev->dev);
     119                 :            : 
     120         [ +  - ]:        468 :         if (!acpi_dev) {
     121                 :            :                 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__);
     122                 :            :                 return false;
     123                 :            :         }
     124                 :            : 
     125                 :        468 :         return acpi_bus_can_wakeup(acpi_dev->handle);
     126                 :            : }
     127                 :            : 
     128                 :          0 : static int pnpacpi_suspend(struct pnp_dev *dev, pm_message_t state)
     129                 :            : {
     130         [ #  # ]:          0 :         struct acpi_device *acpi_dev = ACPI_COMPANION(&dev->dev);
     131                 :          0 :         int error = 0;
     132                 :            : 
     133         [ #  # ]:          0 :         if (!acpi_dev) {
     134                 :            :                 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__);
     135                 :            :                 return 0;
     136                 :            :         }
     137                 :            : 
     138         [ #  # ]:          0 :         if (device_can_wakeup(&dev->dev)) {
     139         [ #  # ]:          0 :                 error = acpi_pm_set_device_wakeup(&dev->dev,
     140                 :            :                                               device_may_wakeup(&dev->dev));
     141         [ #  # ]:          0 :                 if (error)
     142                 :            :                         return error;
     143                 :            :         }
     144                 :            : 
     145         [ #  # ]:          0 :         if (acpi_device_power_manageable(acpi_dev)) {
     146                 :          0 :                 int power_state = acpi_pm_device_sleep_state(&dev->dev, NULL,
     147                 :            :                                                         ACPI_STATE_D3_COLD);
     148         [ #  # ]:          0 :                 if (power_state < 0)
     149                 :          0 :                         power_state = (state.event == PM_EVENT_ON) ?
     150         [ #  # ]:          0 :                                         ACPI_STATE_D0 : ACPI_STATE_D3_COLD;
     151                 :            : 
     152                 :            :                 /*
     153                 :            :                  * acpi_device_set_power() can fail (keyboard port can't be
     154                 :            :                  * powered-down?), and in any case, our return value is ignored
     155                 :            :                  * by pnp_bus_suspend().  Hence we don't revert the wakeup
     156                 :            :                  * setting if the set_power fails.
     157                 :            :                  */
     158                 :          0 :                 error = acpi_device_set_power(acpi_dev, power_state);
     159                 :            :         }
     160                 :            : 
     161                 :            :         return error;
     162                 :            : }
     163                 :            : 
     164                 :          0 : static int pnpacpi_resume(struct pnp_dev *dev)
     165                 :            : {
     166         [ #  # ]:          0 :         struct acpi_device *acpi_dev = ACPI_COMPANION(&dev->dev);
     167                 :          0 :         int error = 0;
     168                 :            : 
     169         [ #  # ]:          0 :         if (!acpi_dev) {
     170                 :            :                 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__);
     171                 :            :                 return -ENODEV;
     172                 :            :         }
     173                 :            : 
     174   [ #  #  #  # ]:          0 :         if (device_may_wakeup(&dev->dev))
     175                 :          0 :                 acpi_pm_set_device_wakeup(&dev->dev, false);
     176                 :            : 
     177         [ #  # ]:          0 :         if (acpi_device_power_manageable(acpi_dev))
     178                 :          0 :                 error = acpi_device_set_power(acpi_dev, ACPI_STATE_D0);
     179                 :            : 
     180                 :            :         return error;
     181                 :            : }
     182                 :            : #endif
     183                 :            : 
     184                 :            : struct pnp_protocol pnpacpi_protocol = {
     185                 :            :         .name    = "Plug and Play ACPI",
     186                 :            :         .get     = pnpacpi_get_resources,
     187                 :            :         .set     = pnpacpi_set_resources,
     188                 :            :         .disable = pnpacpi_disable_resources,
     189                 :            : #ifdef CONFIG_ACPI_SLEEP
     190                 :            :         .can_wakeup = pnpacpi_can_wakeup,
     191                 :            :         .suspend = pnpacpi_suspend,
     192                 :            :         .resume = pnpacpi_resume,
     193                 :            : #endif
     194                 :            : };
     195                 :            : EXPORT_SYMBOL(pnpacpi_protocol);
     196                 :            : 
     197                 :        468 : static const char *__init pnpacpi_get_id(struct acpi_device *device)
     198                 :            : {
     199                 :        468 :         struct acpi_hardware_id *id;
     200                 :            : 
     201         [ +  - ]:        468 :         list_for_each_entry(id, &device->pnp.ids, list) {
     202         [ +  - ]:        468 :                 if (ispnpidacpi(id->id))
     203                 :        468 :                         return id->id;
     204                 :            :         }
     205                 :            : 
     206                 :            :         return NULL;
     207                 :            : }
     208                 :            : 
     209                 :        468 : static int __init pnpacpi_add_device(struct acpi_device *device)
     210                 :            : {
     211                 :        468 :         struct pnp_dev *dev;
     212                 :        468 :         const char *pnpid;
     213                 :        468 :         struct acpi_hardware_id *id;
     214                 :        468 :         int error;
     215                 :            : 
     216                 :            :         /* Skip devices that are already bound */
     217         [ +  - ]:        468 :         if (device->physical_node_count)
     218                 :            :                 return 0;
     219                 :            : 
     220                 :            :         /*
     221                 :            :          * If a PnPacpi device is not present , the device
     222                 :            :          * driver should not be loaded.
     223                 :            :          */
     224         [ +  - ]:        468 :         if (!acpi_has_method(device->handle, "_CRS"))
     225                 :            :                 return 0;
     226                 :            : 
     227                 :        468 :         pnpid = pnpacpi_get_id(device);
     228         [ +  - ]:        468 :         if (!pnpid)
     229                 :            :                 return 0;
     230                 :            : 
     231         [ +  - ]:        468 :         if (!device->status.present)
     232                 :            :                 return 0;
     233                 :            : 
     234                 :        468 :         dev = pnp_alloc_dev(&pnpacpi_protocol, num, pnpid);
     235         [ +  - ]:        468 :         if (!dev)
     236                 :            :                 return -ENOMEM;
     237                 :            : 
     238         [ +  - ]:        936 :         ACPI_COMPANION_SET(&dev->dev, device);
     239                 :        468 :         dev->data = device;
     240                 :            :         /* .enabled means the device can decode the resources */
     241                 :        468 :         dev->active = device->status.enabled;
     242         [ -  + ]:        468 :         if (acpi_has_method(device->handle, "_SRS"))
     243                 :          0 :                 dev->capabilities |= PNP_CONFIGURABLE;
     244                 :        468 :         dev->capabilities |= PNP_READ;
     245   [ +  +  -  + ]:        468 :         if (device->flags.dynamic_status && (dev->capabilities & PNP_CONFIGURABLE))
     246                 :          0 :                 dev->capabilities |= PNP_WRITE;
     247         [ -  + ]:        468 :         if (device->flags.removable)
     248                 :          0 :                 dev->capabilities |= PNP_REMOVABLE;
     249         [ -  + ]:        468 :         if (acpi_has_method(device->handle, "_DIS"))
     250                 :          0 :                 dev->capabilities |= PNP_DISABLE;
     251                 :            : 
     252         [ -  + ]:        468 :         if (strlen(acpi_device_name(device)))
     253                 :          0 :                 strncpy(dev->name, acpi_device_name(device), sizeof(dev->name));
     254                 :            :         else
     255                 :        468 :                 strncpy(dev->name, acpi_device_bid(device), sizeof(dev->name));
     256                 :            : 
     257         [ +  - ]:        468 :         if (dev->active)
     258                 :        468 :                 pnpacpi_parse_allocated_resource(dev);
     259                 :            : 
     260         [ -  + ]:        468 :         if (dev->capabilities & PNP_CONFIGURABLE)
     261                 :          0 :                 pnpacpi_parse_resource_option_data(dev);
     262                 :            : 
     263         [ +  + ]:        936 :         list_for_each_entry(id, &device->pnp.ids, list) {
     264         [ +  - ]:        468 :                 if (!strcmp(id->id, pnpid))
     265                 :        468 :                         continue;
     266         [ #  # ]:          0 :                 if (!ispnpidacpi(id->id))
     267                 :          0 :                         continue;
     268                 :          0 :                 pnp_add_id(dev, id->id);
     269                 :            :         }
     270                 :            : 
     271                 :            :         /* clear out the damaged flags */
     272         [ -  + ]:        468 :         if (!dev->active)
     273                 :          0 :                 pnp_init_resources(dev);
     274                 :            : 
     275                 :        468 :         error = pnp_add_device(dev);
     276         [ -  + ]:        468 :         if (error) {
     277                 :          0 :                 put_device(&dev->dev);
     278                 :          0 :                 return error;
     279                 :            :         }
     280                 :            : 
     281                 :        468 :         num++;
     282                 :            : 
     283                 :        468 :         return 0;
     284                 :            : }
     285                 :            : 
     286                 :       4212 : static acpi_status __init pnpacpi_add_device_handler(acpi_handle handle,
     287                 :            :                                                      u32 lvl, void *context,
     288                 :            :                                                      void **rv)
     289                 :            : {
     290                 :       4212 :         struct acpi_device *device;
     291                 :            : 
     292         [ +  - ]:       4212 :         if (acpi_bus_get_device(handle, &device))
     293                 :            :                 return AE_CTRL_DEPTH;
     294         [ +  + ]:       4212 :         if (acpi_is_pnp_device(device))
     295                 :        468 :                 pnpacpi_add_device(device);
     296                 :            :         return AE_OK;
     297                 :            : }
     298                 :            : 
     299                 :            : int pnpacpi_disabled __initdata;
     300                 :         78 : static int __init pnpacpi_init(void)
     301                 :            : {
     302   [ +  -  -  + ]:         78 :         if (acpi_disabled || pnpacpi_disabled) {
     303                 :          0 :                 printk(KERN_INFO "pnp: PnP ACPI: disabled\n");
     304                 :          0 :                 return 0;
     305                 :            :         }
     306                 :         78 :         printk(KERN_INFO "pnp: PnP ACPI init\n");
     307                 :         78 :         pnp_register_protocol(&pnpacpi_protocol);
     308                 :         78 :         acpi_get_devices(NULL, pnpacpi_add_device_handler, NULL, NULL);
     309                 :         78 :         printk(KERN_INFO "pnp: PnP ACPI: found %d devices\n", num);
     310                 :         78 :         pnp_platform_devices = 1;
     311                 :         78 :         return 0;
     312                 :            : }
     313                 :            : 
     314                 :            : fs_initcall(pnpacpi_init);
     315                 :            : 
     316                 :          0 : static int __init pnpacpi_setup(char *str)
     317                 :            : {
     318         [ #  # ]:          0 :         if (str == NULL)
     319                 :            :                 return 1;
     320         [ #  # ]:          0 :         if (!strncmp(str, "off", 3))
     321                 :          0 :                 pnpacpi_disabled = 1;
     322                 :            :         return 1;
     323                 :            : }
     324                 :            : 
     325                 :            : __setup("pnpacpi=", pnpacpi_setup);

Generated by: LCOV version 1.14