LCOV - code coverage report
Current view: top level - drivers/acpi - scan.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 449 1070 42.0 %
Date: 2022-03-28 13:20:08 Functions: 44 84 52.4 %
Branches: 184 581 31.7 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * scan.c - support for transforming the ACPI namespace into individual objects
       4                 :            :  */
       5                 :            : 
       6                 :            : #include <linux/module.h>
       7                 :            : #include <linux/init.h>
       8                 :            : #include <linux/slab.h>
       9                 :            : #include <linux/kernel.h>
      10                 :            : #include <linux/acpi.h>
      11                 :            : #include <linux/acpi_iort.h>
      12                 :            : #include <linux/signal.h>
      13                 :            : #include <linux/kthread.h>
      14                 :            : #include <linux/dmi.h>
      15                 :            : #include <linux/nls.h>
      16                 :            : #include <linux/dma-mapping.h>
      17                 :            : #include <linux/platform_data/x86/apple.h>
      18                 :            : 
      19                 :            : #include <asm/pgtable.h>
      20                 :            : 
      21                 :            : #include "internal.h"
      22                 :            : 
      23                 :            : #define _COMPONENT              ACPI_BUS_COMPONENT
      24                 :            : ACPI_MODULE_NAME("scan");
      25                 :            : extern struct acpi_device *acpi_root;
      26                 :            : 
      27                 :            : #define ACPI_BUS_CLASS                  "system_bus"
      28                 :            : #define ACPI_BUS_HID                    "LNXSYBUS"
      29                 :            : #define ACPI_BUS_DEVICE_NAME            "System Bus"
      30                 :            : 
      31                 :            : #define ACPI_IS_ROOT_DEVICE(device)    (!(device)->parent)
      32                 :            : 
      33                 :            : #define INVALID_ACPI_HANDLE     ((acpi_handle)empty_zero_page)
      34                 :            : 
      35                 :            : static const char *dummy_hid = "device";
      36                 :            : 
      37                 :            : static LIST_HEAD(acpi_dep_list);
      38                 :            : static DEFINE_MUTEX(acpi_dep_list_lock);
      39                 :            : LIST_HEAD(acpi_bus_id_list);
      40                 :            : static DEFINE_MUTEX(acpi_scan_lock);
      41                 :            : static LIST_HEAD(acpi_scan_handlers_list);
      42                 :            : DEFINE_MUTEX(acpi_device_lock);
      43                 :            : LIST_HEAD(acpi_wakeup_device_list);
      44                 :            : static DEFINE_MUTEX(acpi_hp_context_lock);
      45                 :            : 
      46                 :            : /*
      47                 :            :  * The UART device described by the SPCR table is the only object which needs
      48                 :            :  * special-casing. Everything else is covered by ACPI namespace paths in STAO
      49                 :            :  * table.
      50                 :            :  */
      51                 :            : static u64 spcr_uart_addr;
      52                 :            : 
      53                 :            : struct acpi_dep_data {
      54                 :            :         struct list_head node;
      55                 :            :         acpi_handle master;
      56                 :            :         acpi_handle slave;
      57                 :            : };
      58                 :            : 
      59                 :          0 : void acpi_scan_lock_acquire(void)
      60                 :            : {
      61                 :          0 :         mutex_lock(&acpi_scan_lock);
      62                 :          0 : }
      63                 :            : EXPORT_SYMBOL_GPL(acpi_scan_lock_acquire);
      64                 :            : 
      65                 :          0 : void acpi_scan_lock_release(void)
      66                 :            : {
      67                 :          0 :         mutex_unlock(&acpi_scan_lock);
      68                 :          0 : }
      69                 :            : EXPORT_SYMBOL_GPL(acpi_scan_lock_release);
      70                 :            : 
      71                 :       1020 : void acpi_lock_hp_context(void)
      72                 :            : {
      73                 :       1020 :         mutex_lock(&acpi_hp_context_lock);
      74                 :       1020 : }
      75                 :            : 
      76                 :       1020 : void acpi_unlock_hp_context(void)
      77                 :            : {
      78                 :       1020 :         mutex_unlock(&acpi_hp_context_lock);
      79                 :       1020 : }
      80                 :            : 
      81                 :          0 : void acpi_initialize_hp_context(struct acpi_device *adev,
      82                 :            :                                 struct acpi_hotplug_context *hp,
      83                 :            :                                 int (*notify)(struct acpi_device *, u32),
      84                 :            :                                 void (*uevent)(struct acpi_device *, u32))
      85                 :            : {
      86                 :          0 :         acpi_lock_hp_context();
      87                 :          0 :         hp->notify = notify;
      88                 :          0 :         hp->uevent = uevent;
      89                 :          0 :         acpi_set_hp_context(adev, hp);
      90                 :          0 :         acpi_unlock_hp_context();
      91                 :          0 : }
      92                 :            : EXPORT_SYMBOL_GPL(acpi_initialize_hp_context);
      93                 :            : 
      94                 :        390 : int acpi_scan_add_handler(struct acpi_scan_handler *handler)
      95                 :            : {
      96         [ +  - ]:        300 :         if (!handler)
      97                 :            :                 return -EINVAL;
      98                 :            : 
      99                 :        360 :         list_add_tail(&handler->list_node, &acpi_scan_handlers_list);
     100                 :        300 :         return 0;
     101                 :            : }
     102                 :            : 
     103                 :         60 : int acpi_scan_add_handler_with_hotplug(struct acpi_scan_handler *handler,
     104                 :            :                                        const char *hotplug_profile_name)
     105                 :            : {
     106                 :         60 :         int error;
     107                 :            : 
     108         [ +  - ]:         60 :         error = acpi_scan_add_handler(handler);
     109                 :         60 :         if (error)
     110                 :            :                 return error;
     111                 :            : 
     112                 :         60 :         acpi_sysfs_add_hotplug_profile(&handler->hotplug, hotplug_profile_name);
     113                 :         60 :         return 0;
     114                 :            : }
     115                 :            : 
     116                 :          0 : bool acpi_scan_is_offline(struct acpi_device *adev, bool uevent)
     117                 :            : {
     118                 :          0 :         struct acpi_device_physical_node *pn;
     119                 :          0 :         bool offline = true;
     120                 :          0 :         char *envp[] = { "EVENT=offline", NULL };
     121                 :            : 
     122                 :            :         /*
     123                 :            :          * acpi_container_offline() calls this for all of the container's
     124                 :            :          * children under the container's physical_node_lock lock.
     125                 :            :          */
     126                 :          0 :         mutex_lock_nested(&adev->physical_node_lock, SINGLE_DEPTH_NESTING);
     127                 :            : 
     128         [ #  # ]:          0 :         list_for_each_entry(pn, &adev->physical_node_list, node)
     129   [ #  #  #  #  :          0 :                 if (device_supports_offline(pn->dev) && !pn->dev->offline) {
                   #  # ]
     130         [ #  # ]:          0 :                         if (uevent)
     131                 :          0 :                                 kobject_uevent_env(&pn->dev->kobj, KOBJ_CHANGE, envp);
     132                 :            : 
     133                 :            :                         offline = false;
     134                 :            :                         break;
     135                 :            :                 }
     136                 :            : 
     137                 :          0 :         mutex_unlock(&adev->physical_node_lock);
     138                 :          0 :         return offline;
     139                 :            : }
     140                 :            : 
     141                 :          0 : static acpi_status acpi_bus_offline(acpi_handle handle, u32 lvl, void *data,
     142                 :            :                                     void **ret_p)
     143                 :            : {
     144                 :          0 :         struct acpi_device *device = NULL;
     145                 :          0 :         struct acpi_device_physical_node *pn;
     146                 :          0 :         bool second_pass = (bool)data;
     147                 :          0 :         acpi_status status = AE_OK;
     148                 :            : 
     149         [ #  # ]:          0 :         if (acpi_bus_get_device(handle, &device))
     150                 :            :                 return AE_OK;
     151                 :            : 
     152   [ #  #  #  # ]:          0 :         if (device->handler && !device->handler->hotplug.enabled) {
     153                 :          0 :                 *ret_p = &device->dev;
     154                 :          0 :                 return AE_SUPPORT;
     155                 :            :         }
     156                 :            : 
     157                 :          0 :         mutex_lock(&device->physical_node_lock);
     158                 :            : 
     159         [ #  # ]:          0 :         list_for_each_entry(pn, &device->physical_node_list, node) {
     160                 :          0 :                 int ret;
     161                 :            : 
     162         [ #  # ]:          0 :                 if (second_pass) {
     163                 :            :                         /* Skip devices offlined by the first pass. */
     164         [ #  # ]:          0 :                         if (pn->put_online)
     165                 :          0 :                                 continue;
     166                 :            :                 } else {
     167                 :          0 :                         pn->put_online = false;
     168                 :            :                 }
     169                 :          0 :                 ret = device_offline(pn->dev);
     170         [ #  # ]:          0 :                 if (ret >= 0) {
     171                 :          0 :                         pn->put_online = !ret;
     172                 :            :                 } else {
     173                 :          0 :                         *ret_p = pn->dev;
     174         [ #  # ]:          0 :                         if (second_pass) {
     175                 :            :                                 status = AE_ERROR;
     176                 :            :                                 break;
     177                 :            :                         }
     178                 :            :                 }
     179                 :            :         }
     180                 :            : 
     181                 :          0 :         mutex_unlock(&device->physical_node_lock);
     182                 :            : 
     183                 :          0 :         return status;
     184                 :            : }
     185                 :            : 
     186                 :          0 : static acpi_status acpi_bus_online(acpi_handle handle, u32 lvl, void *data,
     187                 :            :                                    void **ret_p)
     188                 :            : {
     189                 :          0 :         struct acpi_device *device = NULL;
     190                 :          0 :         struct acpi_device_physical_node *pn;
     191                 :            : 
     192         [ #  # ]:          0 :         if (acpi_bus_get_device(handle, &device))
     193                 :            :                 return AE_OK;
     194                 :            : 
     195                 :          0 :         mutex_lock(&device->physical_node_lock);
     196                 :            : 
     197         [ #  # ]:          0 :         list_for_each_entry(pn, &device->physical_node_list, node)
     198         [ #  # ]:          0 :                 if (pn->put_online) {
     199                 :          0 :                         device_online(pn->dev);
     200                 :          0 :                         pn->put_online = false;
     201                 :            :                 }
     202                 :            : 
     203                 :          0 :         mutex_unlock(&device->physical_node_lock);
     204                 :            : 
     205                 :          0 :         return AE_OK;
     206                 :            : }
     207                 :            : 
     208                 :            : static int acpi_scan_try_to_offline(struct acpi_device *device)
     209                 :            : {
     210                 :            :         acpi_handle handle = device->handle;
     211                 :            :         struct device *errdev = NULL;
     212                 :            :         acpi_status status;
     213                 :            : 
     214                 :            :         /*
     215                 :            :          * Carry out two passes here and ignore errors in the first pass,
     216                 :            :          * because if the devices in question are memory blocks and
     217                 :            :          * CONFIG_MEMCG is set, one of the blocks may hold data structures
     218                 :            :          * that the other blocks depend on, but it is not known in advance which
     219                 :            :          * block holds them.
     220                 :            :          *
     221                 :            :          * If the first pass is successful, the second one isn't needed, though.
     222                 :            :          */
     223                 :            :         status = acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
     224                 :            :                                      NULL, acpi_bus_offline, (void *)false,
     225                 :            :                                      (void **)&errdev);
     226                 :            :         if (status == AE_SUPPORT) {
     227                 :            :                 dev_warn(errdev, "Offline disabled.\n");
     228                 :            :                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
     229                 :            :                                     acpi_bus_online, NULL, NULL, NULL);
     230                 :            :                 return -EPERM;
     231                 :            :         }
     232                 :            :         acpi_bus_offline(handle, 0, (void *)false, (void **)&errdev);
     233                 :            :         if (errdev) {
     234                 :            :                 errdev = NULL;
     235                 :            :                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
     236                 :            :                                     NULL, acpi_bus_offline, (void *)true,
     237                 :            :                                     (void **)&errdev);
     238                 :            :                 if (!errdev)
     239                 :            :                         acpi_bus_offline(handle, 0, (void *)true,
     240                 :            :                                          (void **)&errdev);
     241                 :            : 
     242                 :            :                 if (errdev) {
     243                 :            :                         dev_warn(errdev, "Offline failed.\n");
     244                 :            :                         acpi_bus_online(handle, 0, NULL, NULL);
     245                 :            :                         acpi_walk_namespace(ACPI_TYPE_ANY, handle,
     246                 :            :                                             ACPI_UINT32_MAX, acpi_bus_online,
     247                 :            :                                             NULL, NULL, NULL);
     248                 :            :                         return -EBUSY;
     249                 :            :                 }
     250                 :            :         }
     251                 :            :         return 0;
     252                 :            : }
     253                 :            : 
     254                 :          0 : static int acpi_scan_hot_remove(struct acpi_device *device)
     255                 :            : {
     256                 :          0 :         acpi_handle handle = device->handle;
     257                 :          0 :         unsigned long long sta;
     258                 :          0 :         acpi_status status;
     259                 :            : 
     260   [ #  #  #  # ]:          0 :         if (device->handler && device->handler->hotplug.demand_offline) {
     261         [ #  # ]:          0 :                 if (!acpi_scan_is_offline(device, true))
     262                 :            :                         return -EBUSY;
     263                 :            :         } else {
     264                 :          0 :                 int error = acpi_scan_try_to_offline(device);
     265         [ #  # ]:          0 :                 if (error)
     266                 :            :                         return error;
     267                 :            :         }
     268                 :            : 
     269                 :            :         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
     270                 :          0 :                 "Hot-removing device %s...\n", dev_name(&device->dev)));
     271                 :            : 
     272                 :          0 :         acpi_bus_trim(device);
     273                 :            : 
     274                 :          0 :         acpi_evaluate_lck(handle, 0);
     275                 :            :         /*
     276                 :            :          * TBD: _EJD support.
     277                 :            :          */
     278                 :          0 :         status = acpi_evaluate_ej0(handle);
     279         [ #  # ]:          0 :         if (status == AE_NOT_FOUND)
     280                 :            :                 return -ENODEV;
     281         [ #  # ]:          0 :         else if (ACPI_FAILURE(status))
     282                 :            :                 return -EIO;
     283                 :            : 
     284                 :            :         /*
     285                 :            :          * Verify if eject was indeed successful.  If not, log an error
     286                 :            :          * message.  No need to call _OST since _EJ0 call was made OK.
     287                 :            :          */
     288                 :          0 :         status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
     289         [ #  # ]:          0 :         if (ACPI_FAILURE(status)) {
     290                 :          0 :                 acpi_handle_warn(handle,
     291                 :            :                         "Status check after eject failed (0x%x)\n", status);
     292         [ #  # ]:          0 :         } else if (sta & ACPI_STA_DEVICE_ENABLED) {
     293                 :          0 :                 acpi_handle_warn(handle,
     294                 :            :                         "Eject incomplete - status 0x%llx\n", sta);
     295                 :            :         }
     296                 :            : 
     297                 :            :         return 0;
     298                 :            : }
     299                 :            : 
     300                 :          0 : static int acpi_scan_device_not_present(struct acpi_device *adev)
     301                 :            : {
     302   [ #  #  #  # ]:          0 :         if (!acpi_device_enumerated(adev)) {
     303                 :          0 :                 dev_warn(&adev->dev, "Still not present\n");
     304                 :          0 :                 return -EALREADY;
     305                 :            :         }
     306                 :          0 :         acpi_bus_trim(adev);
     307                 :          0 :         return 0;
     308                 :            : }
     309                 :            : 
     310                 :          0 : static int acpi_scan_device_check(struct acpi_device *adev)
     311                 :            : {
     312                 :          0 :         int error;
     313                 :            : 
     314                 :          0 :         acpi_bus_get_status(adev);
     315         [ #  # ]:          0 :         if (adev->status.present || adev->status.functional) {
     316                 :            :                 /*
     317                 :            :                  * This function is only called for device objects for which
     318                 :            :                  * matching scan handlers exist.  The only situation in which
     319                 :            :                  * the scan handler is not attached to this device object yet
     320                 :            :                  * is when the device has just appeared (either it wasn't
     321                 :            :                  * present at all before or it was removed and then added
     322                 :            :                  * again).
     323                 :            :                  */
     324         [ #  # ]:          0 :                 if (adev->handler) {
     325                 :          0 :                         dev_warn(&adev->dev, "Already enumerated\n");
     326                 :          0 :                         return -EALREADY;
     327                 :            :                 }
     328                 :          0 :                 error = acpi_bus_scan(adev->handle);
     329         [ #  # ]:          0 :                 if (error) {
     330                 :          0 :                         dev_warn(&adev->dev, "Namespace scan failure\n");
     331                 :          0 :                         return error;
     332                 :            :                 }
     333         [ #  # ]:          0 :                 if (!adev->handler) {
     334                 :          0 :                         dev_warn(&adev->dev, "Enumeration failure\n");
     335                 :          0 :                         error = -ENODEV;
     336                 :            :                 }
     337                 :            :         } else {
     338                 :          0 :                 error = acpi_scan_device_not_present(adev);
     339                 :            :         }
     340                 :            :         return error;
     341                 :            : }
     342                 :            : 
     343                 :          0 : static int acpi_scan_bus_check(struct acpi_device *adev)
     344                 :            : {
     345                 :          0 :         struct acpi_scan_handler *handler = adev->handler;
     346                 :          0 :         struct acpi_device *child;
     347                 :          0 :         int error;
     348                 :            : 
     349                 :          0 :         acpi_bus_get_status(adev);
     350         [ #  # ]:          0 :         if (!(adev->status.present || adev->status.functional)) {
     351                 :          0 :                 acpi_scan_device_not_present(adev);
     352                 :          0 :                 return 0;
     353                 :            :         }
     354   [ #  #  #  # ]:          0 :         if (handler && handler->hotplug.scan_dependent)
     355                 :          0 :                 return handler->hotplug.scan_dependent(adev);
     356                 :            : 
     357                 :          0 :         error = acpi_bus_scan(adev->handle);
     358         [ #  # ]:          0 :         if (error) {
     359                 :          0 :                 dev_warn(&adev->dev, "Namespace scan failure\n");
     360                 :          0 :                 return error;
     361                 :            :         }
     362         [ #  # ]:          0 :         list_for_each_entry(child, &adev->children, node) {
     363                 :          0 :                 error = acpi_scan_bus_check(child);
     364         [ #  # ]:          0 :                 if (error)
     365                 :          0 :                         return error;
     366                 :            :         }
     367                 :            :         return 0;
     368                 :            : }
     369                 :            : 
     370                 :          0 : static int acpi_generic_hotplug_event(struct acpi_device *adev, u32 type)
     371                 :            : {
     372   [ #  #  #  # ]:          0 :         switch (type) {
     373                 :          0 :         case ACPI_NOTIFY_BUS_CHECK:
     374                 :          0 :                 return acpi_scan_bus_check(adev);
     375                 :          0 :         case ACPI_NOTIFY_DEVICE_CHECK:
     376                 :          0 :                 return acpi_scan_device_check(adev);
     377                 :          0 :         case ACPI_NOTIFY_EJECT_REQUEST:
     378                 :            :         case ACPI_OST_EC_OSPM_EJECT:
     379   [ #  #  #  # ]:          0 :                 if (adev->handler && !adev->handler->hotplug.enabled) {
     380                 :          0 :                         dev_info(&adev->dev, "Eject disabled\n");
     381                 :          0 :                         return -EPERM;
     382                 :            :                 }
     383                 :          0 :                 acpi_evaluate_ost(adev->handle, ACPI_NOTIFY_EJECT_REQUEST,
     384                 :            :                                   ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
     385                 :          0 :                 return acpi_scan_hot_remove(adev);
     386                 :            :         }
     387                 :            :         return -EINVAL;
     388                 :            : }
     389                 :            : 
     390                 :          0 : void acpi_device_hotplug(struct acpi_device *adev, u32 src)
     391                 :            : {
     392                 :          0 :         u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
     393                 :          0 :         int error = -ENODEV;
     394                 :            : 
     395                 :          0 :         lock_device_hotplug();
     396                 :          0 :         mutex_lock(&acpi_scan_lock);
     397                 :            : 
     398                 :            :         /*
     399                 :            :          * The device object's ACPI handle cannot become invalid as long as we
     400                 :            :          * are holding acpi_scan_lock, but it might have become invalid before
     401                 :            :          * that lock was acquired.
     402                 :            :          */
     403         [ #  # ]:          0 :         if (adev->handle == INVALID_ACPI_HANDLE)
     404                 :          0 :                 goto err_out;
     405                 :            : 
     406         [ #  # ]:          0 :         if (adev->flags.is_dock_station) {
     407                 :          0 :                 error = dock_notify(adev, src);
     408         [ #  # ]:          0 :         } else if (adev->flags.hotplug_notify) {
     409                 :          0 :                 error = acpi_generic_hotplug_event(adev, src);
     410                 :            :         } else {
     411                 :          0 :                 int (*notify)(struct acpi_device *, u32);
     412                 :            : 
     413                 :          0 :                 acpi_lock_hp_context();
     414         [ #  # ]:          0 :                 notify = adev->hp ? adev->hp->notify : NULL;
     415                 :          0 :                 acpi_unlock_hp_context();
     416                 :            :                 /*
     417                 :            :                  * There may be additional notify handlers for device objects
     418                 :            :                  * without the .event() callback, so ignore them here.
     419                 :            :                  */
     420         [ #  # ]:          0 :                 if (notify)
     421                 :          0 :                         error = notify(adev, src);
     422                 :            :                 else
     423                 :          0 :                         goto out;
     424                 :            :         }
     425         [ #  # ]:          0 :         switch (error) {
     426                 :            :         case 0:
     427                 :            :                 ost_code = ACPI_OST_SC_SUCCESS;
     428                 :            :                 break;
     429                 :            :         case -EPERM:
     430                 :            :                 ost_code = ACPI_OST_SC_EJECT_NOT_SUPPORTED;
     431                 :            :                 break;
     432                 :            :         case -EBUSY:
     433                 :            :                 ost_code = ACPI_OST_SC_DEVICE_BUSY;
     434                 :            :                 break;
     435                 :            :         default:
     436                 :            :                 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
     437                 :            :                 break;
     438                 :            :         }
     439                 :            : 
     440                 :          0 :  err_out:
     441                 :          0 :         acpi_evaluate_ost(adev->handle, src, ost_code, NULL);
     442                 :            : 
     443                 :          0 :  out:
     444                 :          0 :         acpi_bus_put_acpi_device(adev);
     445                 :          0 :         mutex_unlock(&acpi_scan_lock);
     446                 :          0 :         unlock_device_hotplug();
     447                 :          0 : }
     448                 :            : 
     449                 :          0 : static void acpi_free_power_resources_lists(struct acpi_device *device)
     450                 :            : {
     451                 :          0 :         int i;
     452                 :            : 
     453         [ #  # ]:          0 :         if (device->wakeup.flags.valid)
     454                 :          0 :                 acpi_power_resources_list_free(&device->wakeup.resources);
     455                 :            : 
     456         [ #  # ]:          0 :         if (!device->power.flags.power_resources)
     457                 :            :                 return;
     458                 :            : 
     459         [ #  # ]:          0 :         for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
     460                 :          0 :                 struct acpi_device_power_state *ps = &device->power.states[i];
     461                 :          0 :                 acpi_power_resources_list_free(&ps->resources);
     462                 :            :         }
     463                 :            : }
     464                 :            : 
     465                 :          0 : static void acpi_device_release(struct device *dev)
     466                 :            : {
     467                 :          0 :         struct acpi_device *acpi_dev = to_acpi_device(dev);
     468                 :            : 
     469                 :          0 :         acpi_free_properties(acpi_dev);
     470                 :          0 :         acpi_free_pnp_ids(&acpi_dev->pnp);
     471                 :          0 :         acpi_free_power_resources_lists(acpi_dev);
     472                 :          0 :         kfree(acpi_dev);
     473                 :          0 : }
     474                 :            : 
     475                 :          0 : static void acpi_device_del(struct acpi_device *device)
     476                 :            : {
     477                 :          0 :         struct acpi_device_bus_id *acpi_device_bus_id;
     478                 :            : 
     479                 :          0 :         mutex_lock(&acpi_device_lock);
     480         [ #  # ]:          0 :         if (device->parent)
     481                 :          0 :                 list_del(&device->node);
     482                 :            : 
     483         [ #  # ]:          0 :         list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node)
     484         [ #  # ]:          0 :                 if (!strcmp(acpi_device_bus_id->bus_id,
     485                 :            :                             acpi_device_hid(device))) {
     486         [ #  # ]:          0 :                         if (acpi_device_bus_id->instance_no > 0)
     487                 :          0 :                                 acpi_device_bus_id->instance_no--;
     488                 :            :                         else {
     489                 :          0 :                                 list_del(&acpi_device_bus_id->node);
     490                 :          0 :                                 kfree(acpi_device_bus_id);
     491                 :            :                         }
     492                 :            :                         break;
     493                 :            :                 }
     494                 :            : 
     495                 :          0 :         list_del(&device->wakeup_list);
     496                 :          0 :         mutex_unlock(&acpi_device_lock);
     497                 :            : 
     498                 :          0 :         acpi_power_add_remove_device(device, false);
     499                 :          0 :         acpi_device_remove_files(device);
     500         [ #  # ]:          0 :         if (device->remove)
     501                 :          0 :                 device->remove(device);
     502                 :            : 
     503                 :          0 :         device_del(&device->dev);
     504                 :          0 : }
     505                 :            : 
     506                 :            : static BLOCKING_NOTIFIER_HEAD(acpi_reconfig_chain);
     507                 :            : 
     508                 :            : static LIST_HEAD(acpi_device_del_list);
     509                 :            : static DEFINE_MUTEX(acpi_device_del_lock);
     510                 :            : 
     511                 :          0 : static void acpi_device_del_work_fn(struct work_struct *work_not_used)
     512                 :            : {
     513                 :          0 :         for (;;) {
     514                 :          0 :                 struct acpi_device *adev;
     515                 :            : 
     516                 :          0 :                 mutex_lock(&acpi_device_del_lock);
     517                 :            : 
     518         [ #  # ]:          0 :                 if (list_empty(&acpi_device_del_list)) {
     519                 :          0 :                         mutex_unlock(&acpi_device_del_lock);
     520                 :          0 :                         break;
     521                 :            :                 }
     522                 :          0 :                 adev = list_first_entry(&acpi_device_del_list,
     523                 :            :                                         struct acpi_device, del_list);
     524                 :          0 :                 list_del(&adev->del_list);
     525                 :            : 
     526                 :          0 :                 mutex_unlock(&acpi_device_del_lock);
     527                 :            : 
     528                 :          0 :                 blocking_notifier_call_chain(&acpi_reconfig_chain,
     529                 :            :                                              ACPI_RECONFIG_DEVICE_REMOVE, adev);
     530                 :            : 
     531                 :          0 :                 acpi_device_del(adev);
     532                 :            :                 /*
     533                 :            :                  * Drop references to all power resources that might have been
     534                 :            :                  * used by the device.
     535                 :            :                  */
     536                 :          0 :                 acpi_power_transition(adev, ACPI_STATE_D3_COLD);
     537                 :          0 :                 put_device(&adev->dev);
     538                 :            :         }
     539                 :          0 : }
     540                 :            : 
     541                 :            : /**
     542                 :            :  * acpi_scan_drop_device - Drop an ACPI device object.
     543                 :            :  * @handle: Handle of an ACPI namespace node, not used.
     544                 :            :  * @context: Address of the ACPI device object to drop.
     545                 :            :  *
     546                 :            :  * This is invoked by acpi_ns_delete_node() during the removal of the ACPI
     547                 :            :  * namespace node the device object pointed to by @context is attached to.
     548                 :            :  *
     549                 :            :  * The unregistration is carried out asynchronously to avoid running
     550                 :            :  * acpi_device_del() under the ACPICA's namespace mutex and the list is used to
     551                 :            :  * ensure the correct ordering (the device objects must be unregistered in the
     552                 :            :  * same order in which the corresponding namespace nodes are deleted).
     553                 :            :  */
     554                 :          0 : static void acpi_scan_drop_device(acpi_handle handle, void *context)
     555                 :            : {
     556                 :          0 :         static DECLARE_WORK(work, acpi_device_del_work_fn);
     557                 :          0 :         struct acpi_device *adev = context;
     558                 :            : 
     559                 :          0 :         mutex_lock(&acpi_device_del_lock);
     560                 :            : 
     561                 :            :         /*
     562                 :            :          * Use the ACPI hotplug workqueue which is ordered, so this work item
     563                 :            :          * won't run after any hotplug work items submitted subsequently.  That
     564                 :            :          * prevents attempts to register device objects identical to those being
     565                 :            :          * deleted from happening concurrently (such attempts result from
     566                 :            :          * hotplug events handled via the ACPI hotplug workqueue).  It also will
     567                 :            :          * run after all of the work items submitted previosuly, which helps
     568                 :            :          * those work items to ensure that they are not accessing stale device
     569                 :            :          * objects.
     570                 :            :          */
     571         [ #  # ]:          0 :         if (list_empty(&acpi_device_del_list))
     572                 :          0 :                 acpi_queue_hotplug_work(&work);
     573                 :            : 
     574                 :          0 :         list_add_tail(&adev->del_list, &acpi_device_del_list);
     575                 :            :         /* Make acpi_ns_validate_handle() return NULL for this handle. */
     576                 :          0 :         adev->handle = INVALID_ACPI_HANDLE;
     577                 :            : 
     578                 :          0 :         mutex_unlock(&acpi_device_del_lock);
     579                 :          0 : }
     580                 :            : 
     581                 :      13644 : static int acpi_get_device_data(acpi_handle handle, struct acpi_device **device,
     582                 :            :                                 void (*callback)(void *))
     583                 :            : {
     584                 :      13644 :         acpi_status status;
     585                 :            : 
     586         [ +  - ]:      13644 :         if (!device)
     587                 :            :                 return -EINVAL;
     588                 :            : 
     589                 :      13644 :         status = acpi_get_data_full(handle, acpi_scan_drop_device,
     590                 :            :                                     (void **)device, callback);
     591   [ +  +  -  + ]:      13644 :         if (ACPI_FAILURE(status) || !*device) {
     592                 :            :                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
     593                 :       8880 :                                   handle));
     594                 :       8880 :                 return -ENODEV;
     595                 :            :         }
     596                 :            :         return 0;
     597                 :            : }
     598                 :            : 
     599                 :      13644 : int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
     600                 :            : {
     601                 :       3054 :         return acpi_get_device_data(handle, device, NULL);
     602                 :            : }
     603                 :            : EXPORT_SYMBOL(acpi_bus_get_device);
     604                 :            : 
     605                 :          0 : static void get_acpi_device(void *dev)
     606                 :            : {
     607         [ #  # ]:          0 :         if (dev)
     608                 :          0 :                 get_device(&((struct acpi_device *)dev)->dev);
     609                 :          0 : }
     610                 :            : 
     611                 :          0 : struct acpi_device *acpi_bus_get_acpi_device(acpi_handle handle)
     612                 :            : {
     613                 :          0 :         struct acpi_device *adev = NULL;
     614                 :            : 
     615                 :          0 :         acpi_get_device_data(handle, &adev, get_acpi_device);
     616                 :          0 :         return adev;
     617                 :            : }
     618                 :            : 
     619                 :          0 : void acpi_bus_put_acpi_device(struct acpi_device *adev)
     620                 :            : {
     621                 :          0 :         put_device(&adev->dev);
     622                 :          0 : }
     623                 :            : 
     624                 :       1740 : int acpi_device_add(struct acpi_device *device,
     625                 :            :                     void (*release)(struct device *))
     626                 :            : {
     627                 :       1740 :         int result;
     628                 :       1740 :         struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
     629                 :       1740 :         int found = 0;
     630                 :            : 
     631         [ +  + ]:       1740 :         if (device->handle) {
     632                 :       1710 :                 acpi_status status;
     633                 :            : 
     634                 :       1710 :                 status = acpi_attach_data(device->handle, acpi_scan_drop_device,
     635                 :            :                                           device);
     636         [ -  + ]:       1710 :                 if (ACPI_FAILURE(status)) {
     637                 :          0 :                         acpi_handle_err(device->handle,
     638                 :            :                                         "Unable to attach device data\n");
     639                 :          0 :                         return -ENODEV;
     640                 :            :                 }
     641                 :            :         }
     642                 :            : 
     643                 :            :         /*
     644                 :            :          * Linkage
     645                 :            :          * -------
     646                 :            :          * Link this device to its parent and siblings.
     647                 :            :          */
     648                 :       1740 :         INIT_LIST_HEAD(&device->children);
     649                 :       1740 :         INIT_LIST_HEAD(&device->node);
     650                 :       1740 :         INIT_LIST_HEAD(&device->wakeup_list);
     651                 :       1740 :         INIT_LIST_HEAD(&device->physical_node_list);
     652                 :       1740 :         INIT_LIST_HEAD(&device->del_list);
     653                 :       1740 :         mutex_init(&device->physical_node_lock);
     654                 :            : 
     655                 :       1740 :         new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
     656         [ -  + ]:       1740 :         if (!new_bus_id) {
     657                 :          0 :                 pr_err(PREFIX "Memory allocation error\n");
     658                 :          0 :                 result = -ENOMEM;
     659                 :          0 :                 goto err_detach;
     660                 :            :         }
     661                 :            : 
     662                 :       1740 :         mutex_lock(&acpi_device_lock);
     663                 :            :         /*
     664                 :            :          * Find suitable bus_id and instance number in acpi_bus_id_list
     665                 :            :          * If failed, create one and link it into acpi_bus_id_list
     666                 :            :          */
     667         [ +  + ]:      11250 :         list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
     668         [ +  + ]:      10740 :                 if (!strcmp(acpi_device_bus_id->bus_id,
     669                 :            :                             acpi_device_hid(device))) {
     670                 :       1230 :                         acpi_device_bus_id->instance_no++;
     671                 :       1230 :                         found = 1;
     672                 :       1230 :                         kfree(new_bus_id);
     673                 :       1230 :                         break;
     674                 :            :                 }
     675                 :            :         }
     676                 :       1230 :         if (!found) {
     677                 :        510 :                 acpi_device_bus_id = new_bus_id;
     678                 :       1020 :                 strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device));
     679                 :        510 :                 acpi_device_bus_id->instance_no = 0;
     680                 :        510 :                 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
     681                 :            :         }
     682                 :       1740 :         dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
     683                 :            : 
     684         [ +  + ]:       1740 :         if (device->parent)
     685                 :       1710 :                 list_add_tail(&device->node, &device->parent->children);
     686                 :            : 
     687         [ -  + ]:       1740 :         if (device->wakeup.flags.valid)
     688                 :          0 :                 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
     689                 :       1740 :         mutex_unlock(&acpi_device_lock);
     690                 :            : 
     691         [ +  + ]:       1740 :         if (device->parent)
     692                 :       1710 :                 device->dev.parent = &device->parent->dev;
     693                 :       1740 :         device->dev.bus = &acpi_bus_type;
     694                 :       1740 :         device->dev.release = release;
     695                 :       1740 :         result = device_add(&device->dev);
     696         [ -  + ]:       1740 :         if (result) {
     697                 :          0 :                 dev_err(&device->dev, "Error registering device\n");
     698                 :          0 :                 goto err;
     699                 :            :         }
     700                 :            : 
     701                 :       1740 :         result = acpi_device_setup_files(device);
     702         [ -  + ]:       1740 :         if (result)
     703         [ #  # ]:          0 :                 printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n",
     704                 :            :                        dev_name(&device->dev));
     705                 :            : 
     706                 :            :         return 0;
     707                 :            : 
     708                 :            :  err:
     709                 :          0 :         mutex_lock(&acpi_device_lock);
     710         [ #  # ]:          0 :         if (device->parent)
     711                 :          0 :                 list_del(&device->node);
     712                 :          0 :         list_del(&device->wakeup_list);
     713                 :          0 :         mutex_unlock(&acpi_device_lock);
     714                 :            : 
     715                 :          0 :  err_detach:
     716                 :          0 :         acpi_detach_data(device->handle, acpi_scan_drop_device);
     717                 :          0 :         return result;
     718                 :            : }
     719                 :            : 
     720                 :            : /* --------------------------------------------------------------------------
     721                 :            :                                  Device Enumeration
     722                 :            :    -------------------------------------------------------------------------- */
     723                 :       1740 : static struct acpi_device *acpi_bus_get_parent(acpi_handle handle)
     724                 :            : {
     725                 :       1740 :         struct acpi_device *device = NULL;
     726                 :       1740 :         acpi_status status;
     727                 :            : 
     728                 :            :         /*
     729                 :            :          * Fixed hardware devices do not appear in the namespace and do not
     730                 :            :          * have handles, but we fabricate acpi_devices for them, so we have
     731                 :            :          * to deal with them specially.
     732                 :            :          */
     733         [ +  + ]:       1740 :         if (!handle)
     734                 :         30 :                 return acpi_root;
     735                 :            : 
     736                 :       1710 :         do {
     737                 :       1710 :                 status = acpi_get_parent(handle, &handle);
     738         [ +  + ]:       1710 :                 if (ACPI_FAILURE(status))
     739         [ -  + ]:         30 :                         return status == AE_NULL_ENTRY ? NULL : acpi_root;
     740         [ -  + ]:       1680 :         } while (acpi_bus_get_device(handle, &device));
     741                 :       1680 :         return device;
     742                 :            : }
     743                 :            : 
     744                 :            : acpi_status
     745                 :       1710 : acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
     746                 :            : {
     747                 :       1710 :         acpi_status status;
     748                 :       1710 :         acpi_handle tmp;
     749                 :       1710 :         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
     750                 :       1710 :         union acpi_object *obj;
     751                 :            : 
     752                 :       1710 :         status = acpi_get_handle(handle, "_EJD", &tmp);
     753         [ -  + ]:       1710 :         if (ACPI_FAILURE(status))
     754                 :            :                 return status;
     755                 :            : 
     756                 :          0 :         status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
     757         [ #  # ]:          0 :         if (ACPI_SUCCESS(status)) {
     758                 :          0 :                 obj = buffer.pointer;
     759                 :          0 :                 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer,
     760                 :            :                                          ejd);
     761                 :          0 :                 kfree(buffer.pointer);
     762                 :            :         }
     763                 :            :         return status;
     764                 :            : }
     765                 :            : EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
     766                 :            : 
     767                 :          0 : static int acpi_bus_extract_wakeup_device_power_package(struct acpi_device *dev)
     768                 :            : {
     769                 :          0 :         acpi_handle handle = dev->handle;
     770                 :          0 :         struct acpi_device_wakeup *wakeup = &dev->wakeup;
     771                 :          0 :         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
     772                 :          0 :         union acpi_object *package = NULL;
     773                 :          0 :         union acpi_object *element = NULL;
     774                 :          0 :         acpi_status status;
     775                 :          0 :         int err = -ENODATA;
     776                 :            : 
     777                 :          0 :         INIT_LIST_HEAD(&wakeup->resources);
     778                 :            : 
     779                 :            :         /* _PRW */
     780                 :          0 :         status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer);
     781         [ #  # ]:          0 :         if (ACPI_FAILURE(status)) {
     782                 :          0 :                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
     783                 :          0 :                 return err;
     784                 :            :         }
     785                 :            : 
     786                 :          0 :         package = (union acpi_object *)buffer.pointer;
     787                 :            : 
     788   [ #  #  #  # ]:          0 :         if (!package || package->package.count < 2)
     789                 :          0 :                 goto out;
     790                 :            : 
     791                 :          0 :         element = &(package->package.elements[0]);
     792         [ #  # ]:          0 :         if (!element)
     793                 :          0 :                 goto out;
     794                 :            : 
     795         [ #  # ]:          0 :         if (element->type == ACPI_TYPE_PACKAGE) {
     796         [ #  # ]:          0 :                 if ((element->package.count < 2) ||
     797         [ #  # ]:          0 :                     (element->package.elements[0].type !=
     798                 :            :                      ACPI_TYPE_LOCAL_REFERENCE)
     799         [ #  # ]:          0 :                     || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
     800                 :          0 :                         goto out;
     801                 :            : 
     802                 :          0 :                 wakeup->gpe_device =
     803                 :          0 :                     element->package.elements[0].reference.handle;
     804                 :          0 :                 wakeup->gpe_number =
     805                 :          0 :                     (u32) element->package.elements[1].integer.value;
     806         [ #  # ]:          0 :         } else if (element->type == ACPI_TYPE_INTEGER) {
     807                 :          0 :                 wakeup->gpe_device = NULL;
     808                 :          0 :                 wakeup->gpe_number = element->integer.value;
     809                 :            :         } else {
     810                 :          0 :                 goto out;
     811                 :            :         }
     812                 :            : 
     813                 :          0 :         element = &(package->package.elements[1]);
     814         [ #  # ]:          0 :         if (element->type != ACPI_TYPE_INTEGER)
     815                 :          0 :                 goto out;
     816                 :            : 
     817                 :          0 :         wakeup->sleep_state = element->integer.value;
     818                 :            : 
     819                 :          0 :         err = acpi_extract_power_resources(package, 2, &wakeup->resources);
     820         [ #  # ]:          0 :         if (err)
     821                 :          0 :                 goto out;
     822                 :            : 
     823         [ #  # ]:          0 :         if (!list_empty(&wakeup->resources)) {
     824                 :          0 :                 int sleep_state;
     825                 :            : 
     826                 :          0 :                 err = acpi_power_wakeup_list_init(&wakeup->resources,
     827                 :            :                                                   &sleep_state);
     828         [ #  # ]:          0 :                 if (err) {
     829                 :          0 :                         acpi_handle_warn(handle, "Retrieving current states "
     830                 :            :                                          "of wakeup power resources failed\n");
     831                 :          0 :                         acpi_power_resources_list_free(&wakeup->resources);
     832                 :          0 :                         goto out;
     833                 :            :                 }
     834         [ #  # ]:          0 :                 if (sleep_state < wakeup->sleep_state) {
     835                 :          0 :                         acpi_handle_warn(handle, "Overriding _PRW sleep state "
     836                 :            :                                          "(S%d) by S%d from power resources\n",
     837                 :            :                                          (int)wakeup->sleep_state, sleep_state);
     838                 :          0 :                         wakeup->sleep_state = sleep_state;
     839                 :            :                 }
     840                 :            :         }
     841                 :            : 
     842                 :          0 :  out:
     843                 :          0 :         kfree(buffer.pointer);
     844                 :          0 :         return err;
     845                 :            : }
     846                 :            : 
     847                 :          0 : static bool acpi_wakeup_gpe_init(struct acpi_device *device)
     848                 :            : {
     849                 :          0 :         static const struct acpi_device_id button_device_ids[] = {
     850                 :            :                 {"PNP0C0C", 0},               /* Power button */
     851                 :            :                 {"PNP0C0D", 0},               /* Lid */
     852                 :            :                 {"PNP0C0E", 0},               /* Sleep button */
     853                 :            :                 {"", 0},
     854                 :            :         };
     855                 :          0 :         struct acpi_device_wakeup *wakeup = &device->wakeup;
     856                 :          0 :         acpi_status status;
     857                 :            : 
     858                 :          0 :         wakeup->flags.notifier_present = 0;
     859                 :            : 
     860                 :            :         /* Power button, Lid switch always enable wakeup */
     861         [ #  # ]:          0 :         if (!acpi_match_device_ids(device, button_device_ids)) {
     862         [ #  # ]:          0 :                 if (!acpi_match_device_ids(device, &button_device_ids[1])) {
     863                 :            :                         /* Do not use Lid/sleep button for S5 wakeup */
     864         [ #  # ]:          0 :                         if (wakeup->sleep_state == ACPI_STATE_S5)
     865                 :          0 :                                 wakeup->sleep_state = ACPI_STATE_S4;
     866                 :            :                 }
     867                 :          0 :                 acpi_mark_gpe_for_wake(wakeup->gpe_device, wakeup->gpe_number);
     868                 :          0 :                 device_set_wakeup_capable(&device->dev, true);
     869                 :          0 :                 return true;
     870                 :            :         }
     871                 :            : 
     872                 :          0 :         status = acpi_setup_gpe_for_wake(device->handle, wakeup->gpe_device,
     873                 :          0 :                                          wakeup->gpe_number);
     874                 :          0 :         return ACPI_SUCCESS(status);
     875                 :            : }
     876                 :            : 
     877                 :       1740 : static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
     878                 :            : {
     879                 :       1740 :         int err;
     880                 :            : 
     881                 :            :         /* Presence of _PRW indicates wake capable */
     882         [ -  + ]:       1740 :         if (!acpi_has_method(device->handle, "_PRW"))
     883                 :            :                 return;
     884                 :            : 
     885                 :          0 :         err = acpi_bus_extract_wakeup_device_power_package(device);
     886         [ #  # ]:          0 :         if (err) {
     887                 :          0 :                 dev_err(&device->dev, "_PRW evaluation error: %d\n", err);
     888                 :          0 :                 return;
     889                 :            :         }
     890                 :            : 
     891                 :          0 :         device->wakeup.flags.valid = acpi_wakeup_gpe_init(device);
     892                 :          0 :         device->wakeup.prepare_count = 0;
     893                 :            :         /*
     894                 :            :          * Call _PSW/_DSW object to disable its ability to wake the sleeping
     895                 :            :          * system for the ACPI device with the _PRW object.
     896                 :            :          * The _PSW object is deprecated in ACPI 3.0 and is replaced by _DSW.
     897                 :            :          * So it is necessary to call _DSW object first. Only when it is not
     898                 :            :          * present will the _PSW object used.
     899                 :            :          */
     900                 :          0 :         err = acpi_device_sleep_wake(device, 0, 0, 0);
     901                 :          0 :         if (err)
     902                 :            :                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
     903                 :            :                                 "error in _DSW or _PSW evaluation\n"));
     904                 :            : }
     905                 :            : 
     906                 :          0 : static void acpi_bus_init_power_state(struct acpi_device *device, int state)
     907                 :            : {
     908                 :          0 :         struct acpi_device_power_state *ps = &device->power.states[state];
     909                 :          0 :         char pathname[5] = { '_', 'P', 'R', '0' + state, '\0' };
     910                 :          0 :         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
     911                 :          0 :         acpi_status status;
     912                 :            : 
     913                 :          0 :         INIT_LIST_HEAD(&ps->resources);
     914                 :            : 
     915                 :            :         /* Evaluate "_PRx" to get referenced power resources */
     916                 :          0 :         status = acpi_evaluate_object(device->handle, pathname, NULL, &buffer);
     917         [ #  # ]:          0 :         if (ACPI_SUCCESS(status)) {
     918                 :          0 :                 union acpi_object *package = buffer.pointer;
     919                 :            : 
     920   [ #  #  #  # ]:          0 :                 if (buffer.length && package
     921         [ #  # ]:          0 :                     && package->type == ACPI_TYPE_PACKAGE
     922         [ #  # ]:          0 :                     && package->package.count) {
     923                 :          0 :                         int err = acpi_extract_power_resources(package, 0,
     924                 :            :                                                                &ps->resources);
     925         [ #  # ]:          0 :                         if (!err)
     926                 :          0 :                                 device->power.flags.power_resources = 1;
     927                 :            :                 }
     928                 :          0 :                 ACPI_FREE(buffer.pointer);
     929                 :            :         }
     930                 :            : 
     931                 :            :         /* Evaluate "_PSx" to see if we can do explicit sets */
     932                 :          0 :         pathname[2] = 'S';
     933         [ #  # ]:          0 :         if (acpi_has_method(device->handle, pathname))
     934                 :          0 :                 ps->flags.explicit_set = 1;
     935                 :            : 
     936                 :            :         /* State is valid if there are means to put the device into it. */
     937   [ #  #  #  # ]:          0 :         if (!list_empty(&ps->resources) || ps->flags.explicit_set)
     938                 :          0 :                 ps->flags.valid = 1;
     939                 :            : 
     940                 :          0 :         ps->power = -1;              /* Unknown - driver assigned */
     941                 :          0 :         ps->latency = -1;    /* Unknown - driver assigned */
     942                 :          0 : }
     943                 :            : 
     944                 :       1740 : static void acpi_bus_get_power_flags(struct acpi_device *device)
     945                 :            : {
     946                 :       1740 :         u32 i;
     947                 :            : 
     948                 :            :         /* Presence of _PS0|_PR0 indicates 'power manageable' */
     949   [ +  -  -  + ]:       3480 :         if (!acpi_has_method(device->handle, "_PS0") &&
     950                 :       1740 :             !acpi_has_method(device->handle, "_PR0"))
     951                 :            :                 return;
     952                 :            : 
     953                 :          0 :         device->flags.power_manageable = 1;
     954                 :            : 
     955                 :            :         /*
     956                 :            :          * Power Management Flags
     957                 :            :          */
     958         [ #  # ]:          0 :         if (acpi_has_method(device->handle, "_PSC"))
     959                 :          0 :                 device->power.flags.explicit_get = 1;
     960                 :            : 
     961         [ #  # ]:          0 :         if (acpi_has_method(device->handle, "_IRC"))
     962                 :          0 :                 device->power.flags.inrush_current = 1;
     963                 :            : 
     964         [ #  # ]:          0 :         if (acpi_has_method(device->handle, "_DSW"))
     965                 :          0 :                 device->power.flags.dsw_present = 1;
     966                 :            : 
     967                 :            :         /*
     968                 :            :          * Enumerate supported power management states
     969                 :            :          */
     970         [ #  # ]:          0 :         for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++)
     971                 :          0 :                 acpi_bus_init_power_state(device, i);
     972                 :            : 
     973         [ #  # ]:          0 :         INIT_LIST_HEAD(&device->power.states[ACPI_STATE_D3_COLD].resources);
     974         [ #  # ]:          0 :         if (!list_empty(&device->power.states[ACPI_STATE_D3_HOT].resources))
     975                 :          0 :                 device->power.states[ACPI_STATE_D3_COLD].flags.valid = 1;
     976                 :            : 
     977                 :            :         /* Set defaults for D0 and D3hot states (always valid) */
     978                 :          0 :         device->power.states[ACPI_STATE_D0].flags.valid = 1;
     979                 :          0 :         device->power.states[ACPI_STATE_D0].power = 100;
     980                 :          0 :         device->power.states[ACPI_STATE_D3_HOT].flags.valid = 1;
     981                 :            : 
     982         [ #  # ]:          0 :         if (acpi_bus_init_power(device))
     983                 :          0 :                 device->flags.power_manageable = 0;
     984                 :            : }
     985                 :            : 
     986                 :       1740 : static void acpi_bus_get_flags(struct acpi_device *device)
     987                 :            : {
     988                 :            :         /* Presence of _STA indicates 'dynamic_status' */
     989         [ +  + ]:       1740 :         if (acpi_has_method(device->handle, "_STA"))
     990                 :        450 :                 device->flags.dynamic_status = 1;
     991                 :            : 
     992                 :            :         /* Presence of _RMV indicates 'removable' */
     993         [ -  + ]:       1740 :         if (acpi_has_method(device->handle, "_RMV"))
     994                 :          0 :                 device->flags.removable = 1;
     995                 :            : 
     996                 :            :         /* Presence of _EJD|_EJ0 indicates 'ejectable' */
     997   [ +  -  +  + ]:       3480 :         if (acpi_has_method(device->handle, "_EJD") ||
     998                 :       1740 :             acpi_has_method(device->handle, "_EJ0"))
     999                 :        900 :                 device->flags.ejectable = 1;
    1000                 :       1740 : }
    1001                 :            : 
    1002                 :       1740 : static void acpi_device_get_busid(struct acpi_device *device)
    1003                 :            : {
    1004                 :       1740 :         char bus_id[5] = { '?', 0 };
    1005                 :       1740 :         struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
    1006                 :       1740 :         int i = 0;
    1007                 :            : 
    1008                 :            :         /*
    1009                 :            :          * Bus ID
    1010                 :            :          * ------
    1011                 :            :          * The device's Bus ID is simply the object name.
    1012                 :            :          * TBD: Shouldn't this value be unique (within the ACPI namespace)?
    1013                 :            :          */
    1014         [ +  + ]:       1740 :         if (ACPI_IS_ROOT_DEVICE(device)) {
    1015                 :         30 :                 strcpy(device->pnp.bus_id, "ACPI");
    1016                 :         30 :                 return;
    1017                 :            :         }
    1018                 :            : 
    1019   [ +  -  -  + ]:       1710 :         switch (device->device_type) {
    1020                 :         30 :         case ACPI_BUS_TYPE_POWER_BUTTON:
    1021                 :         30 :                 strcpy(device->pnp.bus_id, "PWRF");
    1022                 :         30 :                 break;
    1023                 :          0 :         case ACPI_BUS_TYPE_SLEEP_BUTTON:
    1024                 :          0 :                 strcpy(device->pnp.bus_id, "SLPF");
    1025                 :          0 :                 break;
    1026                 :          0 :         case ACPI_BUS_TYPE_ECDT_EC:
    1027                 :          0 :                 strcpy(device->pnp.bus_id, "ECDT");
    1028                 :          0 :                 break;
    1029                 :       1680 :         default:
    1030                 :       1680 :                 acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer);
    1031                 :            :                 /* Clean up trailing underscores (if any) */
    1032         [ +  - ]:       4500 :                 for (i = 3; i > 1; i--) {
    1033         [ +  + ]:       2820 :                         if (bus_id[i] == '_')
    1034                 :       1140 :                                 bus_id[i] = '\0';
    1035                 :            :                         else
    1036                 :            :                                 break;
    1037                 :            :                 }
    1038                 :       1680 :                 strcpy(device->pnp.bus_id, bus_id);
    1039                 :       1680 :                 break;
    1040                 :            :         }
    1041                 :            : }
    1042                 :            : 
    1043                 :            : /*
    1044                 :            :  * acpi_ata_match - see if an acpi object is an ATA device
    1045                 :            :  *
    1046                 :            :  * If an acpi object has one of the ACPI ATA methods defined,
    1047                 :            :  * then we can safely call it an ATA device.
    1048                 :            :  */
    1049                 :       3540 : bool acpi_ata_match(acpi_handle handle)
    1050                 :            : {
    1051         [ +  - ]:       7080 :         return acpi_has_method(handle, "_GTF") ||
    1052         [ +  - ]:       7080 :                acpi_has_method(handle, "_GTM") ||
    1053   [ +  -  -  + ]:      10620 :                acpi_has_method(handle, "_STM") ||
    1054                 :       3540 :                acpi_has_method(handle, "_SDD");
    1055                 :            : }
    1056                 :            : 
    1057                 :            : /*
    1058                 :            :  * acpi_bay_match - see if an acpi object is an ejectable driver bay
    1059                 :            :  *
    1060                 :            :  * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
    1061                 :            :  * then we can safely call it an ejectable drive bay
    1062                 :            :  */
    1063                 :       3360 : bool acpi_bay_match(acpi_handle handle)
    1064                 :            : {
    1065                 :       3360 :         acpi_handle phandle;
    1066                 :            : 
    1067         [ +  + ]:       3360 :         if (!acpi_has_method(handle, "_EJ0"))
    1068                 :            :                 return false;
    1069         [ +  - ]:       1770 :         if (acpi_ata_match(handle))
    1070                 :            :                 return true;
    1071         [ +  - ]:       1770 :         if (ACPI_FAILURE(acpi_get_parent(handle, &phandle)))
    1072                 :            :                 return false;
    1073                 :            : 
    1074                 :       1770 :         return acpi_ata_match(phandle);
    1075                 :            : }
    1076                 :            : 
    1077                 :       4320 : bool acpi_device_is_battery(struct acpi_device *adev)
    1078                 :            : {
    1079                 :       4320 :         struct acpi_hardware_id *hwid;
    1080                 :            : 
    1081         [ +  + ]:       5790 :         list_for_each_entry(hwid, &adev->pnp.ids, list)
    1082         [ +  - ]:       1470 :                 if (!strcmp("PNP0C0A", hwid->id))
    1083                 :            :                         return true;
    1084                 :            : 
    1085                 :            :         return false;
    1086                 :            : }
    1087                 :            : 
    1088                 :       1710 : static bool is_ejectable_bay(struct acpi_device *adev)
    1089                 :            : {
    1090                 :       1710 :         acpi_handle handle = adev->handle;
    1091                 :            : 
    1092   [ +  +  +  - ]:       1710 :         if (acpi_has_method(handle, "_EJ0") && acpi_device_is_battery(adev))
    1093                 :            :                 return true;
    1094                 :            : 
    1095                 :       1710 :         return acpi_bay_match(handle);
    1096                 :            : }
    1097                 :            : 
    1098                 :            : /*
    1099                 :            :  * acpi_dock_match - see if an acpi object has a _DCK method
    1100                 :            :  */
    1101                 :       3360 : bool acpi_dock_match(acpi_handle handle)
    1102                 :            : {
    1103                 :          0 :         return acpi_has_method(handle, "_DCK");
    1104                 :            : }
    1105                 :            : 
    1106                 :            : static acpi_status
    1107                 :          0 : acpi_backlight_cap_match(acpi_handle handle, u32 level, void *context,
    1108                 :            :                           void **return_value)
    1109                 :            : {
    1110                 :          0 :         long *cap = context;
    1111                 :            : 
    1112   [ #  #  #  # ]:          0 :         if (acpi_has_method(handle, "_BCM") &&
    1113                 :          0 :             acpi_has_method(handle, "_BCL")) {
    1114                 :            :                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found generic backlight "
    1115                 :          0 :                                   "support\n"));
    1116                 :          0 :                 *cap |= ACPI_VIDEO_BACKLIGHT;
    1117                 :            :                 /* We have backlight support, no need to scan further */
    1118                 :          0 :                 return AE_CTRL_TERMINATE;
    1119                 :            :         }
    1120                 :            :         return 0;
    1121                 :            : }
    1122                 :            : 
    1123                 :            : /* Returns true if the ACPI object is a video device which can be
    1124                 :            :  * handled by video.ko.
    1125                 :            :  * The device will get a Linux specific CID added in scan.c to
    1126                 :            :  * identify the device as an ACPI graphics device
    1127                 :            :  * Be aware that the graphics device may not be physically present
    1128                 :            :  * Use acpi_video_get_capabilities() to detect general ACPI video
    1129                 :            :  * capabilities of present cards
    1130                 :            :  */
    1131                 :       1650 : long acpi_is_video_device(acpi_handle handle)
    1132                 :            : {
    1133                 :       1650 :         long video_caps = 0;
    1134                 :            : 
    1135                 :            :         /* Is this device able to support video switching ? */
    1136   [ +  -  -  + ]:       1650 :         if (acpi_has_method(handle, "_DOD") || acpi_has_method(handle, "_DOS"))
    1137                 :          0 :                 video_caps |= ACPI_VIDEO_OUTPUT_SWITCHING;
    1138                 :            : 
    1139                 :            :         /* Is this device able to retrieve a video ROM ? */
    1140         [ -  + ]:       1650 :         if (acpi_has_method(handle, "_ROM"))
    1141                 :          0 :                 video_caps |= ACPI_VIDEO_ROM_AVAILABLE;
    1142                 :            : 
    1143                 :            :         /* Is this device able to configure which video head to be POSTed ? */
    1144   [ -  +  -  - ]:       1650 :         if (acpi_has_method(handle, "_VPO") &&
    1145         [ #  # ]:          0 :             acpi_has_method(handle, "_GPD") &&
    1146                 :          0 :             acpi_has_method(handle, "_SPD"))
    1147                 :          0 :                 video_caps |= ACPI_VIDEO_DEVICE_POSTING;
    1148                 :            : 
    1149                 :            :         /* Only check for backlight functionality if one of the above hit. */
    1150         [ -  + ]:       1650 :         if (video_caps)
    1151                 :          0 :                 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
    1152                 :            :                                     ACPI_UINT32_MAX, acpi_backlight_cap_match, NULL,
    1153                 :            :                                     &video_caps, NULL);
    1154                 :            : 
    1155                 :       1650 :         return video_caps;
    1156                 :            : }
    1157                 :            : EXPORT_SYMBOL(acpi_is_video_device);
    1158                 :            : 
    1159                 :      11340 : const char *acpi_device_hid(struct acpi_device *device)
    1160                 :            : {
    1161                 :      11340 :         struct acpi_hardware_id *hid;
    1162                 :            : 
    1163   [ -  +  +  +  :      11340 :         if (list_empty(&device->pnp.ids))
             +  +  -  - ]
    1164                 :       4080 :                 return dummy_hid;
    1165                 :            : 
    1166                 :       7260 :         hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
    1167                 :       7260 :         return hid->id;
    1168                 :            : }
    1169                 :            : EXPORT_SYMBOL(acpi_device_hid);
    1170                 :            : 
    1171                 :        750 : static void acpi_add_id(struct acpi_device_pnp *pnp, const char *dev_id)
    1172                 :            : {
    1173                 :        750 :         struct acpi_hardware_id *id;
    1174                 :            : 
    1175                 :        750 :         id = kmalloc(sizeof(*id), GFP_KERNEL);
    1176         [ +  - ]:        750 :         if (!id)
    1177                 :            :                 return;
    1178                 :            : 
    1179                 :        750 :         id->id = kstrdup_const(dev_id, GFP_KERNEL);
    1180         [ -  + ]:        750 :         if (!id->id) {
    1181                 :          0 :                 kfree(id);
    1182                 :          0 :                 return;
    1183                 :            :         }
    1184                 :            : 
    1185                 :        750 :         list_add_tail(&id->list, &pnp->ids);
    1186                 :        750 :         pnp->type.hardware_id = 1;
    1187                 :            : }
    1188                 :            : 
    1189                 :            : /*
    1190                 :            :  * Old IBM workstations have a DSDT bug wherein the SMBus object
    1191                 :            :  * lacks the SMBUS01 HID and the methods do not have the necessary "_"
    1192                 :            :  * prefix.  Work around this.
    1193                 :            :  */
    1194                 :       1650 : static bool acpi_ibm_smbus_match(acpi_handle handle)
    1195                 :            : {
    1196                 :       1650 :         char node_name[ACPI_PATH_SEGMENT_LENGTH];
    1197                 :       1650 :         struct acpi_buffer path = { sizeof(node_name), node_name };
    1198                 :            : 
    1199         [ -  + ]:       1650 :         if (!dmi_name_in_vendors("IBM"))
    1200                 :            :                 return false;
    1201                 :            : 
    1202                 :            :         /* Look for SMBS object */
    1203         [ #  # ]:          0 :         if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &path)) ||
    1204         [ #  # ]:          0 :             strcmp("SMBS", path.pointer))
    1205                 :            :                 return false;
    1206                 :            : 
    1207                 :            :         /* Does it have the necessary (but misnamed) methods? */
    1208   [ #  #  #  # ]:          0 :         if (acpi_has_method(handle, "SBI") &&
    1209         [ #  # ]:          0 :             acpi_has_method(handle, "SBR") &&
    1210                 :          0 :             acpi_has_method(handle, "SBW"))
    1211                 :          0 :                 return true;
    1212                 :            : 
    1213                 :            :         return false;
    1214                 :            : }
    1215                 :            : 
    1216                 :       1080 : static bool acpi_object_is_system_bus(acpi_handle handle)
    1217                 :            : {
    1218                 :       1080 :         acpi_handle tmp;
    1219                 :            : 
    1220         [ +  - ]:       1080 :         if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_SB", &tmp)) &&
    1221         [ +  + ]:       1080 :             tmp == handle)
    1222                 :            :                 return true;
    1223         [ +  - ]:       1050 :         if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_TZ", &tmp)) &&
    1224         [ +  + ]:       1050 :             tmp == handle)
    1225                 :         30 :                 return true;
    1226                 :            : 
    1227                 :            :         return false;
    1228                 :            : }
    1229                 :            : 
    1230                 :       1740 : static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp,
    1231                 :            :                                 int device_type)
    1232                 :            : {
    1233                 :       1740 :         acpi_status status;
    1234                 :       1740 :         struct acpi_device_info *info;
    1235                 :       1740 :         struct acpi_pnp_device_id_list *cid_list;
    1236                 :       1740 :         int i;
    1237                 :            : 
    1238   [ +  -  +  -  :       1740 :         switch (device_type) {
             +  -  -  - ]
    1239                 :       1680 :         case ACPI_BUS_TYPE_DEVICE:
    1240         [ +  + ]:       1680 :                 if (handle == ACPI_ROOT_OBJECT) {
    1241                 :         30 :                         acpi_add_id(pnp, ACPI_SYSTEM_HID);
    1242                 :         30 :                         break;
    1243                 :            :                 }
    1244                 :            : 
    1245                 :       1650 :                 status = acpi_get_object_info(handle, &info);
    1246         [ -  + ]:       1650 :                 if (ACPI_FAILURE(status)) {
    1247                 :          0 :                         pr_err(PREFIX "%s: Error reading device info\n",
    1248                 :            :                                         __func__);
    1249                 :          0 :                         return;
    1250                 :            :                 }
    1251                 :            : 
    1252         [ +  + ]:       1650 :                 if (info->valid & ACPI_VALID_HID) {
    1253                 :        570 :                         acpi_add_id(pnp, info->hardware_id.string);
    1254                 :        570 :                         pnp->type.platform_id = 1;
    1255                 :            :                 }
    1256         [ +  + ]:       1650 :                 if (info->valid & ACPI_VALID_CID) {
    1257                 :            :                         cid_list = &info->compatible_id_list;
    1258         [ +  + ]:         60 :                         for (i = 0; i < cid_list->count; i++)
    1259                 :         30 :                                 acpi_add_id(pnp, cid_list->ids[i].string);
    1260                 :            :                 }
    1261         [ +  + ]:       1650 :                 if (info->valid & ACPI_VALID_ADR) {
    1262                 :       1050 :                         pnp->bus_address = info->address;
    1263                 :       1050 :                         pnp->type.bus_address = 1;
    1264                 :            :                 }
    1265         [ +  + ]:       1650 :                 if (info->valid & ACPI_VALID_UID)
    1266                 :        360 :                         pnp->unique_id = kstrdup(info->unique_id.string,
    1267                 :            :                                                         GFP_KERNEL);
    1268         [ -  + ]:       1650 :                 if (info->valid & ACPI_VALID_CLS)
    1269                 :          0 :                         acpi_add_id(pnp, info->class_code.string);
    1270                 :            : 
    1271                 :       1650 :                 kfree(info);
    1272                 :            : 
    1273                 :            :                 /*
    1274                 :            :                  * Some devices don't reliably have _HIDs & _CIDs, so add
    1275                 :            :                  * synthetic HIDs to make sure drivers can find them.
    1276                 :            :                  */
    1277         [ -  + ]:       1650 :                 if (acpi_is_video_device(handle))
    1278                 :          0 :                         acpi_add_id(pnp, ACPI_VIDEO_HID);
    1279         [ -  + ]:       1650 :                 else if (acpi_bay_match(handle))
    1280                 :          0 :                         acpi_add_id(pnp, ACPI_BAY_HID);
    1281         [ -  + ]:       1650 :                 else if (acpi_dock_match(handle))
    1282                 :          0 :                         acpi_add_id(pnp, ACPI_DOCK_HID);
    1283         [ -  + ]:       1650 :                 else if (acpi_ibm_smbus_match(handle))
    1284                 :          0 :                         acpi_add_id(pnp, ACPI_SMBUS_IBM_HID);
    1285   [ +  +  +  + ]:       2730 :                 else if (list_empty(&pnp->ids) &&
    1286                 :       1080 :                          acpi_object_is_system_bus(handle)) {
    1287                 :            :                         /* \_SB, \_TZ, LNXSYBUS */
    1288                 :         60 :                         acpi_add_id(pnp, ACPI_BUS_HID);
    1289                 :         60 :                         strcpy(pnp->device_name, ACPI_BUS_DEVICE_NAME);
    1290                 :         60 :                         strcpy(pnp->device_class, ACPI_BUS_CLASS);
    1291                 :            :                 }
    1292                 :            : 
    1293                 :            :                 break;
    1294                 :          0 :         case ACPI_BUS_TYPE_POWER:
    1295                 :          0 :                 acpi_add_id(pnp, ACPI_POWER_HID);
    1296                 :          0 :                 break;
    1297                 :         30 :         case ACPI_BUS_TYPE_PROCESSOR:
    1298                 :         30 :                 acpi_add_id(pnp, ACPI_PROCESSOR_OBJECT_HID);
    1299                 :         30 :                 break;
    1300                 :          0 :         case ACPI_BUS_TYPE_THERMAL:
    1301                 :          0 :                 acpi_add_id(pnp, ACPI_THERMAL_HID);
    1302                 :          0 :                 break;
    1303                 :         30 :         case ACPI_BUS_TYPE_POWER_BUTTON:
    1304                 :         30 :                 acpi_add_id(pnp, ACPI_BUTTON_HID_POWERF);
    1305                 :         30 :                 break;
    1306                 :          0 :         case ACPI_BUS_TYPE_SLEEP_BUTTON:
    1307                 :          0 :                 acpi_add_id(pnp, ACPI_BUTTON_HID_SLEEPF);
    1308                 :          0 :                 break;
    1309                 :          0 :         case ACPI_BUS_TYPE_ECDT_EC:
    1310                 :          0 :                 acpi_add_id(pnp, ACPI_ECDT_HID);
    1311                 :          0 :                 break;
    1312                 :            :         }
    1313                 :       1740 : }
    1314                 :            : 
    1315                 :          0 : void acpi_free_pnp_ids(struct acpi_device_pnp *pnp)
    1316                 :            : {
    1317                 :          0 :         struct acpi_hardware_id *id, *tmp;
    1318                 :            : 
    1319         [ #  # ]:          0 :         list_for_each_entry_safe(id, tmp, &pnp->ids, list) {
    1320                 :          0 :                 kfree_const(id->id);
    1321                 :          0 :                 kfree(id);
    1322                 :            :         }
    1323                 :          0 :         kfree(pnp->unique_id);
    1324                 :          0 : }
    1325                 :            : 
    1326                 :            : /**
    1327                 :            :  * acpi_dma_supported - Check DMA support for the specified device.
    1328                 :            :  * @adev: The pointer to acpi device
    1329                 :            :  *
    1330                 :            :  * Return false if DMA is not supported. Otherwise, return true
    1331                 :            :  */
    1332                 :        210 : bool acpi_dma_supported(struct acpi_device *adev)
    1333                 :            : {
    1334         [ +  - ]:         60 :         if (!adev)
    1335                 :            :                 return false;
    1336                 :            : 
    1337                 :         60 :         if (adev->flags.cca_seen)
    1338                 :            :                 return true;
    1339                 :            : 
    1340                 :            :         /*
    1341                 :            :         * Per ACPI 6.0 sec 6.2.17, assume devices can do cache-coherent
    1342                 :            :         * DMA on "Intel platforms".  Presumably that includes all x86 and
    1343                 :            :         * ia64, and other arches will set CONFIG_ACPI_CCA_REQUIRED=y.
    1344                 :            :         */
    1345                 :            :         if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED))
    1346                 :            :                 return true;
    1347                 :            : 
    1348                 :            :         return false;
    1349                 :            : }
    1350                 :            : 
    1351                 :            : /**
    1352                 :            :  * acpi_get_dma_attr - Check the supported DMA attr for the specified device.
    1353                 :            :  * @adev: The pointer to acpi device
    1354                 :            :  *
    1355                 :            :  * Return enum dev_dma_attr.
    1356                 :            :  */
    1357                 :        150 : enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev)
    1358                 :            : {
    1359         [ +  - ]:        150 :         if (!acpi_dma_supported(adev))
    1360                 :            :                 return DEV_DMA_NOT_SUPPORTED;
    1361                 :            : 
    1362         [ -  + ]:        150 :         if (adev->flags.coherent_dma)
    1363                 :            :                 return DEV_DMA_COHERENT;
    1364                 :            :         else
    1365                 :          0 :                 return DEV_DMA_NON_COHERENT;
    1366                 :            : }
    1367                 :            : 
    1368                 :            : /**
    1369                 :            :  * acpi_dma_get_range() - Get device DMA parameters.
    1370                 :            :  *
    1371                 :            :  * @dev: device to configure
    1372                 :            :  * @dma_addr: pointer device DMA address result
    1373                 :            :  * @offset: pointer to the DMA offset result
    1374                 :            :  * @size: pointer to DMA range size result
    1375                 :            :  *
    1376                 :            :  * Evaluate DMA regions and return respectively DMA region start, offset
    1377                 :            :  * and size in dma_addr, offset and size on parsing success; it does not
    1378                 :            :  * update the passed in values on failure.
    1379                 :            :  *
    1380                 :            :  * Return 0 on success, < 0 on failure.
    1381                 :            :  */
    1382                 :          0 : int acpi_dma_get_range(struct device *dev, u64 *dma_addr, u64 *offset,
    1383                 :            :                        u64 *size)
    1384                 :            : {
    1385                 :          0 :         struct acpi_device *adev;
    1386                 :          0 :         LIST_HEAD(list);
    1387                 :          0 :         struct resource_entry *rentry;
    1388                 :          0 :         int ret;
    1389                 :          0 :         struct device *dma_dev = dev;
    1390                 :          0 :         u64 len, dma_start = U64_MAX, dma_end = 0, dma_offset = 0;
    1391                 :            : 
    1392                 :            :         /*
    1393                 :            :          * Walk the device tree chasing an ACPI companion with a _DMA
    1394                 :            :          * object while we go. Stop if we find a device with an ACPI
    1395                 :            :          * companion containing a _DMA method.
    1396                 :            :          */
    1397                 :          0 :         do {
    1398         [ #  # ]:          0 :                 adev = ACPI_COMPANION(dma_dev);
    1399   [ #  #  #  # ]:          0 :                 if (adev && acpi_has_method(adev->handle, METHOD_NAME__DMA))
    1400                 :            :                         break;
    1401                 :            : 
    1402                 :          0 :                 dma_dev = dma_dev->parent;
    1403         [ #  # ]:          0 :         } while (dma_dev);
    1404                 :            : 
    1405         [ #  # ]:          0 :         if (!dma_dev)
    1406                 :            :                 return -ENODEV;
    1407                 :            : 
    1408         [ #  # ]:          0 :         if (!acpi_has_method(adev->handle, METHOD_NAME__CRS)) {
    1409                 :          0 :                 acpi_handle_warn(adev->handle, "_DMA is valid only if _CRS is present\n");
    1410                 :          0 :                 return -EINVAL;
    1411                 :            :         }
    1412                 :            : 
    1413                 :          0 :         ret = acpi_dev_get_dma_resources(adev, &list);
    1414         [ #  # ]:          0 :         if (ret > 0) {
    1415         [ #  # ]:          0 :                 list_for_each_entry(rentry, &list, node) {
    1416   [ #  #  #  # ]:          0 :                         if (dma_offset && rentry->offset != dma_offset) {
    1417                 :          0 :                                 ret = -EINVAL;
    1418                 :          0 :                                 dev_warn(dma_dev, "Can't handle multiple windows with different offsets\n");
    1419                 :          0 :                                 goto out;
    1420                 :            :                         }
    1421                 :          0 :                         dma_offset = rentry->offset;
    1422                 :            : 
    1423                 :            :                         /* Take lower and upper limits */
    1424                 :          0 :                         if (rentry->res->start < dma_start)
    1425                 :            :                                 dma_start = rentry->res->start;
    1426                 :          0 :                         if (rentry->res->end > dma_end)
    1427                 :            :                                 dma_end = rentry->res->end;
    1428                 :            :                 }
    1429                 :            : 
    1430         [ #  # ]:          0 :                 if (dma_start >= dma_end) {
    1431                 :          0 :                         ret = -EINVAL;
    1432                 :          0 :                         dev_dbg(dma_dev, "Invalid DMA regions configuration\n");
    1433                 :          0 :                         goto out;
    1434                 :            :                 }
    1435                 :            : 
    1436                 :          0 :                 *dma_addr = dma_start - dma_offset;
    1437                 :          0 :                 len = dma_end - dma_start;
    1438                 :          0 :                 *size = max(len, len + 1);
    1439                 :          0 :                 *offset = dma_offset;
    1440                 :            :         }
    1441                 :          0 :  out:
    1442                 :          0 :         acpi_dev_free_resource_list(&list);
    1443                 :            : 
    1444                 :          0 :         return ret >= 0 ? 0 : ret;
    1445                 :            : }
    1446                 :            : 
    1447                 :            : /**
    1448                 :            :  * acpi_dma_configure - Set-up DMA configuration for the device.
    1449                 :            :  * @dev: The pointer to the device
    1450                 :            :  * @attr: device dma attributes
    1451                 :            :  */
    1452                 :        150 : int acpi_dma_configure(struct device *dev, enum dev_dma_attr attr)
    1453                 :            : {
    1454                 :        150 :         const struct iommu_ops *iommu;
    1455                 :        150 :         u64 dma_addr = 0, size = 0;
    1456                 :            : 
    1457         [ -  + ]:        150 :         if (attr == DEV_DMA_NOT_SUPPORTED) {
    1458                 :          0 :                 set_dma_ops(dev, &dma_dummy_ops);
    1459                 :          0 :                 return 0;
    1460                 :            :         }
    1461                 :            : 
    1462                 :            :         iort_dma_setup(dev, &dma_addr, &size);
    1463                 :            : 
    1464                 :            :         iommu = iort_iommu_configure(dev);
    1465                 :            :         if (PTR_ERR(iommu) == -EPROBE_DEFER)
    1466                 :            :                 return -EPROBE_DEFER;
    1467                 :            : 
    1468                 :            :         arch_setup_dma_ops(dev, dma_addr, size,
    1469                 :            :                                 iommu, attr == DEV_DMA_COHERENT);
    1470                 :            : 
    1471                 :            :         return 0;
    1472                 :            : }
    1473                 :            : EXPORT_SYMBOL_GPL(acpi_dma_configure);
    1474                 :            : 
    1475                 :       1740 : static void acpi_init_coherency(struct acpi_device *adev)
    1476                 :            : {
    1477                 :       1740 :         unsigned long long cca = 0;
    1478                 :       1740 :         acpi_status status;
    1479                 :       1740 :         struct acpi_device *parent = adev->parent;
    1480                 :            : 
    1481   [ +  +  -  + ]:       1740 :         if (parent && parent->flags.cca_seen) {
    1482                 :            :                 /*
    1483                 :            :                  * From ACPI spec, OSPM will ignore _CCA if an ancestor
    1484                 :            :                  * already saw one.
    1485                 :            :                  */
    1486                 :          0 :                 adev->flags.cca_seen = 1;
    1487                 :          0 :                 cca = parent->flags.coherent_dma;
    1488                 :            :         } else {
    1489                 :       1740 :                 status = acpi_evaluate_integer(adev->handle, "_CCA",
    1490                 :            :                                                NULL, &cca);
    1491         [ -  + ]:       1740 :                 if (ACPI_SUCCESS(status))
    1492                 :          0 :                         adev->flags.cca_seen = 1;
    1493                 :       1740 :                 else if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED))
    1494                 :            :                         /*
    1495                 :            :                          * If architecture does not specify that _CCA is
    1496                 :            :                          * required for DMA-able devices (e.g. x86),
    1497                 :            :                          * we default to _CCA=1.
    1498                 :            :                          */
    1499                 :       1740 :                         cca = 1;
    1500                 :            :                 else
    1501                 :            :                         acpi_handle_debug(adev->handle,
    1502                 :            :                                           "ACPI device is missing _CCA.\n");
    1503                 :            :         }
    1504                 :            : 
    1505                 :       1740 :         adev->flags.coherent_dma = cca;
    1506                 :       1740 : }
    1507                 :            : 
    1508                 :       1530 : static int acpi_check_serial_bus_slave(struct acpi_resource *ares, void *data)
    1509                 :            : {
    1510                 :       1530 :         bool *is_serial_bus_slave_p = data;
    1511                 :            : 
    1512         [ -  + ]:       1530 :         if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
    1513                 :            :                 return 1;
    1514                 :            : 
    1515                 :          0 :         *is_serial_bus_slave_p = true;
    1516                 :            : 
    1517                 :            :          /* no need to do more checking */
    1518                 :          0 :         return -1;
    1519                 :            : }
    1520                 :            : 
    1521                 :       1740 : static bool acpi_is_indirect_io_slave(struct acpi_device *device)
    1522                 :            : {
    1523                 :       1740 :         struct acpi_device *parent = device->parent;
    1524                 :       1740 :         static const struct acpi_device_id indirect_io_hosts[] = {
    1525                 :            :                 {"HISI0191", 0},
    1526                 :            :                 {}
    1527                 :            :         };
    1528                 :            : 
    1529         [ +  - ]:       1710 :         return parent && !acpi_match_device_ids(parent, indirect_io_hosts);
    1530                 :            : }
    1531                 :            : 
    1532                 :       1740 : static bool acpi_device_enumeration_by_parent(struct acpi_device *device)
    1533                 :            : {
    1534                 :       1740 :         struct list_head resource_list;
    1535                 :       1740 :         bool is_serial_bus_slave = false;
    1536                 :            :         /*
    1537                 :            :          * These devices have multiple I2cSerialBus resources and an i2c-client
    1538                 :            :          * must be instantiated for each, each with its own i2c_device_id.
    1539                 :            :          * Normally we only instantiate an i2c-client for the first resource,
    1540                 :            :          * using the ACPI HID as id. These special cases are handled by the
    1541                 :            :          * drivers/platform/x86/i2c-multi-instantiate.c driver, which knows
    1542                 :            :          * which i2c_device_id to use for each resource.
    1543                 :            :          */
    1544                 :       1740 :         static const struct acpi_device_id i2c_multi_instantiate_ids[] = {
    1545                 :            :                 {"BSG1160", },
    1546                 :            :                 {"BSG2150", },
    1547                 :            :                 {"INT33FE", },
    1548                 :            :                 {"INT3515", },
    1549                 :            :                 {}
    1550                 :            :         };
    1551                 :            : 
    1552   [ +  +  +  - ]:       3450 :         if (acpi_is_indirect_io_slave(device))
    1553                 :            :                 return true;
    1554                 :            : 
    1555                 :            :         /* Macs use device properties in lieu of _CRS resources */
    1556   [ -  +  -  - ]:       1740 :         if (x86_apple_machine &&
    1557         [ #  # ]:          0 :             (fwnode_property_present(&device->fwnode, "spiSclkPeriod") ||
    1558         [ #  # ]:          0 :              fwnode_property_present(&device->fwnode, "i2cAddress") ||
    1559                 :          0 :              fwnode_property_present(&device->fwnode, "baud")))
    1560                 :          0 :                 return true;
    1561                 :            : 
    1562                 :            :         /* Instantiate a pdev for the i2c-multi-instantiate drv to bind to */
    1563         [ +  - ]:       1740 :         if (!acpi_match_device_ids(device, i2c_multi_instantiate_ids))
    1564                 :            :                 return false;
    1565                 :            : 
    1566                 :       1740 :         INIT_LIST_HEAD(&resource_list);
    1567                 :       1740 :         acpi_dev_get_resources(device, &resource_list,
    1568                 :            :                                acpi_check_serial_bus_slave,
    1569                 :            :                                &is_serial_bus_slave);
    1570                 :       1740 :         acpi_dev_free_resource_list(&resource_list);
    1571                 :            : 
    1572                 :       1740 :         return is_serial_bus_slave;
    1573                 :            : }
    1574                 :            : 
    1575                 :       1740 : void acpi_init_device_object(struct acpi_device *device, acpi_handle handle,
    1576                 :            :                              int type, unsigned long long sta)
    1577                 :            : {
    1578                 :       1740 :         INIT_LIST_HEAD(&device->pnp.ids);
    1579                 :       1740 :         device->device_type = type;
    1580                 :       1740 :         device->handle = handle;
    1581                 :       1740 :         device->parent = acpi_bus_get_parent(handle);
    1582                 :       1740 :         device->fwnode.ops = &acpi_device_fwnode_ops;
    1583                 :       1740 :         acpi_set_device_status(device, sta);
    1584                 :       1740 :         acpi_device_get_busid(device);
    1585                 :       1740 :         acpi_set_pnp_ids(handle, &device->pnp, type);
    1586                 :       1740 :         acpi_init_properties(device);
    1587                 :       1740 :         acpi_bus_get_flags(device);
    1588                 :       1740 :         device->flags.match_driver = false;
    1589                 :       1740 :         device->flags.initialized = true;
    1590                 :       3480 :         device->flags.enumeration_by_parent =
    1591                 :       1740 :                 acpi_device_enumeration_by_parent(device);
    1592                 :       1740 :         acpi_device_clear_enumerated(device);
    1593                 :       1740 :         device_initialize(&device->dev);
    1594                 :       1740 :         dev_set_uevent_suppress(&device->dev, true);
    1595                 :       1740 :         acpi_init_coherency(device);
    1596                 :            :         /* Assume there are unmet deps until acpi_device_dep_initialize() runs */
    1597                 :       1740 :         device->dep_unmet = 1;
    1598                 :       1740 : }
    1599                 :            : 
    1600                 :       1740 : void acpi_device_add_finalize(struct acpi_device *device)
    1601                 :            : {
    1602                 :          0 :         dev_set_uevent_suppress(&device->dev, false);
    1603                 :       1740 :         kobject_uevent(&device->dev.kobj, KOBJ_ADD);
    1604                 :          0 : }
    1605                 :            : 
    1606                 :       1740 : static int acpi_add_single_object(struct acpi_device **child,
    1607                 :            :                                   acpi_handle handle, int type,
    1608                 :            :                                   unsigned long long sta)
    1609                 :            : {
    1610                 :       1740 :         int result;
    1611                 :       1740 :         struct acpi_device *device;
    1612                 :       1740 :         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
    1613                 :            : 
    1614                 :       1740 :         device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
    1615         [ -  + ]:       1740 :         if (!device) {
    1616                 :          0 :                 printk(KERN_ERR PREFIX "Memory allocation error\n");
    1617                 :          0 :                 return -ENOMEM;
    1618                 :            :         }
    1619                 :            : 
    1620                 :       1740 :         acpi_init_device_object(device, handle, type, sta);
    1621                 :            :         /*
    1622                 :            :          * For ACPI_BUS_TYPE_DEVICE getting the status is delayed till here so
    1623                 :            :          * that we can call acpi_bus_get_status() and use its quirk handling.
    1624                 :            :          * Note this must be done before the get power-/wakeup_dev-flags calls.
    1625                 :            :          */
    1626         [ +  + ]:       1740 :         if (type == ACPI_BUS_TYPE_DEVICE)
    1627         [ -  + ]:       1680 :                 if (acpi_bus_get_status(device) < 0)
    1628                 :          0 :                         acpi_set_device_status(device, 0);
    1629                 :            : 
    1630                 :       1740 :         acpi_bus_get_power_flags(device);
    1631                 :       1740 :         acpi_bus_get_wakeup_device_flags(device);
    1632                 :            : 
    1633                 :       1740 :         result = acpi_device_add(device, acpi_device_release);
    1634         [ -  + ]:       1740 :         if (result) {
    1635                 :          0 :                 acpi_device_release(&device->dev);
    1636                 :          0 :                 return result;
    1637                 :            :         }
    1638                 :            : 
    1639                 :       1740 :         acpi_power_add_remove_device(device, true);
    1640                 :       1740 :         acpi_device_add_finalize(device);
    1641                 :       1740 :         acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
    1642                 :            :         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Added %s [%s] parent %s\n",
    1643                 :            :                 dev_name(&device->dev), (char *) buffer.pointer,
    1644                 :       1740 :                 device->parent ? dev_name(&device->parent->dev) : "(null)"));
    1645                 :       1740 :         kfree(buffer.pointer);
    1646                 :       1740 :         *child = device;
    1647                 :       1740 :         return 0;
    1648                 :            : }
    1649                 :            : 
    1650                 :          0 : static acpi_status acpi_get_resource_memory(struct acpi_resource *ares,
    1651                 :            :                                             void *context)
    1652                 :            : {
    1653                 :          0 :         struct resource *res = context;
    1654                 :            : 
    1655         [ #  # ]:          0 :         if (acpi_dev_resource_memory(ares, res))
    1656                 :          0 :                 return AE_CTRL_TERMINATE;
    1657                 :            : 
    1658                 :            :         return AE_OK;
    1659                 :            : }
    1660                 :            : 
    1661                 :       1680 : static bool acpi_device_should_be_hidden(acpi_handle handle)
    1662                 :            : {
    1663                 :       1680 :         acpi_status status;
    1664                 :       1680 :         struct resource res;
    1665                 :            : 
    1666                 :            :         /* Check if it should ignore the UART device */
    1667   [ -  +  -  - ]:       1680 :         if (!(spcr_uart_addr && acpi_has_method(handle, METHOD_NAME__CRS)))
    1668                 :       1680 :                 return false;
    1669                 :            : 
    1670                 :            :         /*
    1671                 :            :          * The UART device described in SPCR table is assumed to have only one
    1672                 :            :          * memory resource present. So we only look for the first one here.
    1673                 :            :          */
    1674                 :          0 :         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
    1675                 :            :                                      acpi_get_resource_memory, &res);
    1676   [ #  #  #  # ]:          0 :         if (ACPI_FAILURE(status) || res.start != spcr_uart_addr)
    1677                 :            :                 return false;
    1678                 :            : 
    1679                 :          0 :         acpi_handle_info(handle, "The UART device @%pa in SPCR table will be hidden\n",
    1680                 :            :                          &res.start);
    1681                 :            : 
    1682                 :          0 :         return true;
    1683                 :            : }
    1684                 :            : 
    1685                 :       8880 : static int acpi_bus_type_and_status(acpi_handle handle, int *type,
    1686                 :            :                                     unsigned long long *sta)
    1687                 :            : {
    1688                 :       8880 :         acpi_status status;
    1689                 :       8880 :         acpi_object_type acpi_type;
    1690                 :            : 
    1691                 :       8880 :         status = acpi_get_type(handle, &acpi_type);
    1692         [ +  - ]:       8880 :         if (ACPI_FAILURE(status))
    1693                 :            :                 return -ENODEV;
    1694                 :            : 
    1695   [ +  +  -  -  :       8880 :         switch (acpi_type) {
                      + ]
    1696                 :       1680 :         case ACPI_TYPE_ANY:             /* for ACPI_ROOT_OBJECT */
    1697                 :            :         case ACPI_TYPE_DEVICE:
    1698         [ +  - ]:       1680 :                 if (acpi_device_should_be_hidden(handle))
    1699                 :            :                         return -ENODEV;
    1700                 :            : 
    1701                 :       1680 :                 *type = ACPI_BUS_TYPE_DEVICE;
    1702                 :            :                 /*
    1703                 :            :                  * acpi_add_single_object updates this once we've an acpi_device
    1704                 :            :                  * so that acpi_bus_get_status' quirk handling can be used.
    1705                 :            :                  */
    1706                 :       1680 :                 *sta = ACPI_STA_DEFAULT;
    1707                 :       1680 :                 break;
    1708                 :         30 :         case ACPI_TYPE_PROCESSOR:
    1709                 :         30 :                 *type = ACPI_BUS_TYPE_PROCESSOR;
    1710                 :         30 :                 status = acpi_bus_get_status_handle(handle, sta);
    1711         [ -  + ]:         30 :                 if (ACPI_FAILURE(status))
    1712                 :          0 :                         return -ENODEV;
    1713                 :            :                 break;
    1714                 :          0 :         case ACPI_TYPE_THERMAL:
    1715                 :          0 :                 *type = ACPI_BUS_TYPE_THERMAL;
    1716                 :          0 :                 *sta = ACPI_STA_DEFAULT;
    1717                 :          0 :                 break;
    1718                 :          0 :         case ACPI_TYPE_POWER:
    1719                 :          0 :                 *type = ACPI_BUS_TYPE_POWER;
    1720                 :          0 :                 *sta = ACPI_STA_DEFAULT;
    1721                 :          0 :                 break;
    1722                 :            :         default:
    1723                 :            :                 return -ENODEV;
    1724                 :            :         }
    1725                 :            : 
    1726                 :            :         return 0;
    1727                 :            : }
    1728                 :            : 
    1729                 :       6990 : bool acpi_device_is_present(const struct acpi_device *adev)
    1730                 :            : {
    1731                 :       6990 :         return adev->status.present || adev->status.functional;
    1732                 :            : }
    1733                 :            : 
    1734                 :            : static bool acpi_scan_handler_matching(struct acpi_scan_handler *handler,
    1735                 :            :                                        const char *idstr,
    1736                 :            :                                        const struct acpi_device_id **matchid)
    1737                 :            : {
    1738                 :            :         const struct acpi_device_id *devid;
    1739                 :            : 
    1740                 :            :         if (handler->match)
    1741                 :            :                 return handler->match(idstr, matchid);
    1742                 :            : 
    1743                 :            :         for (devid = handler->ids; devid->id[0]; devid++)
    1744                 :            :                 if (!strcmp((char *)devid->id, idstr)) {
    1745                 :            :                         if (matchid)
    1746                 :            :                                 *matchid = devid;
    1747                 :            : 
    1748                 :            :                         return true;
    1749                 :            :                 }
    1750                 :            : 
    1751                 :            :         return false;
    1752                 :            : }
    1753                 :            : 
    1754                 :       1350 : static struct acpi_scan_handler *acpi_scan_match_handler(const char *idstr,
    1755                 :            :                                         const struct acpi_device_id **matchid)
    1756                 :            : {
    1757                 :       1350 :         struct acpi_scan_handler *handler;
    1758                 :            : 
    1759         [ +  + ]:      11490 :         list_for_each_entry(handler, &acpi_scan_handlers_list, list_node)
    1760         [ +  + ]:      11190 :                 if (acpi_scan_handler_matching(handler, idstr, matchid))
    1761                 :       1050 :                         return handler;
    1762                 :            : 
    1763                 :            :         return NULL;
    1764                 :            : }
    1765                 :            : 
    1766                 :          0 : void acpi_scan_hotplug_enabled(struct acpi_hotplug_profile *hotplug, bool val)
    1767                 :            : {
    1768         [ #  # ]:          0 :         if (!!hotplug->enabled == !!val)
    1769                 :            :                 return;
    1770                 :            : 
    1771                 :          0 :         mutex_lock(&acpi_scan_lock);
    1772                 :            : 
    1773                 :          0 :         hotplug->enabled = val;
    1774                 :            : 
    1775                 :          0 :         mutex_unlock(&acpi_scan_lock);
    1776                 :            : }
    1777                 :            : 
    1778                 :       1710 : static void acpi_scan_init_hotplug(struct acpi_device *adev)
    1779                 :            : {
    1780                 :       1710 :         struct acpi_hardware_id *hwid;
    1781                 :            : 
    1782   [ +  -  -  + ]:       1710 :         if (acpi_dock_match(adev->handle) || is_ejectable_bay(adev)) {
    1783                 :          0 :                 acpi_dock_add(adev);
    1784                 :          0 :                 return;
    1785                 :            :         }
    1786         [ +  + ]:       1860 :         list_for_each_entry(hwid, &adev->pnp.ids, list) {
    1787                 :        690 :                 struct acpi_scan_handler *handler;
    1788                 :            : 
    1789                 :        690 :                 handler = acpi_scan_match_handler(hwid->id, NULL);
    1790         [ +  + ]:        690 :                 if (handler) {
    1791                 :        540 :                         adev->flags.hotplug_notify = true;
    1792                 :        540 :                         break;
    1793                 :            :                 }
    1794                 :            :         }
    1795                 :            : }
    1796                 :            : 
    1797                 :            : static void acpi_device_dep_initialize(struct acpi_device *adev)
    1798                 :            : {
    1799                 :            :         struct acpi_dep_data *dep;
    1800                 :            :         struct acpi_handle_list dep_devices;
    1801                 :            :         acpi_status status;
    1802                 :            :         int i;
    1803                 :            : 
    1804                 :            :         adev->dep_unmet = 0;
    1805                 :            : 
    1806                 :            :         if (!acpi_has_method(adev->handle, "_DEP"))
    1807                 :            :                 return;
    1808                 :            : 
    1809                 :            :         status = acpi_evaluate_reference(adev->handle, "_DEP", NULL,
    1810                 :            :                                         &dep_devices);
    1811                 :            :         if (ACPI_FAILURE(status)) {
    1812                 :            :                 dev_dbg(&adev->dev, "Failed to evaluate _DEP.\n");
    1813                 :            :                 return;
    1814                 :            :         }
    1815                 :            : 
    1816                 :            :         for (i = 0; i < dep_devices.count; i++) {
    1817                 :            :                 struct acpi_device_info *info;
    1818                 :            :                 int skip;
    1819                 :            : 
    1820                 :            :                 status = acpi_get_object_info(dep_devices.handles[i], &info);
    1821                 :            :                 if (ACPI_FAILURE(status)) {
    1822                 :            :                         dev_dbg(&adev->dev, "Error reading _DEP device info\n");
    1823                 :            :                         continue;
    1824                 :            :                 }
    1825                 :            : 
    1826                 :            :                 /*
    1827                 :            :                  * Skip the dependency of Windows System Power
    1828                 :            :                  * Management Controller
    1829                 :            :                  */
    1830                 :            :                 skip = info->valid & ACPI_VALID_HID &&
    1831                 :            :                         !strcmp(info->hardware_id.string, "INT3396");
    1832                 :            : 
    1833                 :            :                 kfree(info);
    1834                 :            : 
    1835                 :            :                 if (skip)
    1836                 :            :                         continue;
    1837                 :            : 
    1838                 :            :                 dep = kzalloc(sizeof(struct acpi_dep_data), GFP_KERNEL);
    1839                 :            :                 if (!dep)
    1840                 :            :                         return;
    1841                 :            : 
    1842                 :            :                 dep->master = dep_devices.handles[i];
    1843                 :            :                 dep->slave  = adev->handle;
    1844                 :            :                 adev->dep_unmet++;
    1845                 :            : 
    1846                 :            :                 mutex_lock(&acpi_dep_list_lock);
    1847                 :            :                 list_add_tail(&dep->node , &acpi_dep_list);
    1848                 :            :                 mutex_unlock(&acpi_dep_list_lock);
    1849                 :            :         }
    1850                 :            : }
    1851                 :            : 
    1852                 :       8880 : static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
    1853                 :            :                                       void *not_used, void **return_value)
    1854                 :            : {
    1855                 :       8880 :         struct acpi_device *device = NULL;
    1856                 :       8880 :         int type;
    1857                 :       8880 :         unsigned long long sta;
    1858                 :       8880 :         int result;
    1859                 :            : 
    1860                 :       8880 :         acpi_bus_get_device(handle, &device);
    1861         [ -  + ]:       8880 :         if (device)
    1862                 :          0 :                 goto out;
    1863                 :            : 
    1864                 :       8880 :         result = acpi_bus_type_and_status(handle, &type, &sta);
    1865         [ +  + ]:       8880 :         if (result)
    1866                 :            :                 return AE_OK;
    1867                 :            : 
    1868         [ -  + ]:       1710 :         if (type == ACPI_BUS_TYPE_POWER) {
    1869                 :          0 :                 acpi_add_power_resource(handle);
    1870                 :          0 :                 return AE_OK;
    1871                 :            :         }
    1872                 :            : 
    1873                 :       1710 :         acpi_add_single_object(&device, handle, type, sta);
    1874         [ +  - ]:       1710 :         if (!device)
    1875                 :            :                 return AE_CTRL_DEPTH;
    1876                 :            : 
    1877                 :       1710 :         acpi_scan_init_hotplug(device);
    1878                 :       1710 :         acpi_device_dep_initialize(device);
    1879                 :            : 
    1880                 :       1710 :  out:
    1881         [ +  + ]:       1710 :         if (!*return_value)
    1882                 :         30 :                 *return_value = device;
    1883                 :            : 
    1884                 :            :         return AE_OK;
    1885                 :            : }
    1886                 :            : 
    1887                 :         60 : static void acpi_default_enumeration(struct acpi_device *device)
    1888                 :            : {
    1889                 :            :         /*
    1890                 :            :          * Do not enumerate devices with enumeration_by_parent flag set as
    1891                 :            :          * they will be enumerated by their respective parents.
    1892                 :            :          */
    1893         [ +  - ]:         60 :         if (!device->flags.enumeration_by_parent) {
    1894                 :         60 :                 acpi_create_platform_device(device, NULL);
    1895                 :         60 :                 acpi_device_set_enumerated(device);
    1896                 :            :         } else {
    1897                 :          0 :                 blocking_notifier_call_chain(&acpi_reconfig_chain,
    1898                 :            :                                              ACPI_RECONFIG_DEVICE_ADD, device);
    1899                 :            :         }
    1900                 :         60 : }
    1901                 :            : 
    1902                 :            : static const struct acpi_device_id generic_device_ids[] = {
    1903                 :            :         {ACPI_DT_NAMESPACE_HID, },
    1904                 :            :         {"", },
    1905                 :            : };
    1906                 :            : 
    1907                 :          0 : static int acpi_generic_device_attach(struct acpi_device *adev,
    1908                 :            :                                       const struct acpi_device_id *not_used)
    1909                 :            : {
    1910                 :            :         /*
    1911                 :            :          * Since ACPI_DT_NAMESPACE_HID is the only ID handled here, the test
    1912                 :            :          * below can be unconditional.
    1913                 :            :          */
    1914         [ #  # ]:          0 :         if (adev->data.of_compatible)
    1915                 :          0 :                 acpi_default_enumeration(adev);
    1916                 :            : 
    1917                 :          0 :         return 1;
    1918                 :            : }
    1919                 :            : 
    1920                 :            : static struct acpi_scan_handler generic_device_handler = {
    1921                 :            :         .ids = generic_device_ids,
    1922                 :            :         .attach = acpi_generic_device_attach,
    1923                 :            : };
    1924                 :            : 
    1925                 :       1680 : static int acpi_scan_attach_handler(struct acpi_device *device)
    1926                 :            : {
    1927                 :       1680 :         struct acpi_hardware_id *hwid;
    1928                 :       1680 :         int ret = 0;
    1929                 :            : 
    1930         [ +  + ]:       1830 :         list_for_each_entry(hwid, &device->pnp.ids, list) {
    1931                 :        660 :                 const struct acpi_device_id *devid;
    1932                 :        660 :                 struct acpi_scan_handler *handler;
    1933                 :            : 
    1934                 :        660 :                 handler = acpi_scan_match_handler(hwid->id, &devid);
    1935         [ +  + ]:        660 :                 if (handler) {
    1936         [ -  + ]:        510 :                         if (!handler->attach) {
    1937                 :          0 :                                 device->pnp.type.platform_id = 0;
    1938                 :          0 :                                 continue;
    1939                 :            :                         }
    1940                 :        510 :                         device->handler = handler;
    1941                 :        510 :                         ret = handler->attach(device, devid);
    1942         [ -  + ]:        510 :                         if (ret > 0)
    1943                 :            :                                 break;
    1944                 :            : 
    1945                 :          0 :                         device->handler = NULL;
    1946         [ #  # ]:          0 :                         if (ret < 0)
    1947                 :            :                                 break;
    1948                 :            :                 }
    1949                 :            :         }
    1950                 :            : 
    1951                 :       1680 :         return ret;
    1952                 :            : }
    1953                 :            : 
    1954                 :       1710 : static void acpi_bus_attach(struct acpi_device *device)
    1955                 :            : {
    1956                 :       1710 :         struct acpi_device *child;
    1957                 :       1710 :         acpi_handle ejd;
    1958                 :       1710 :         int ret;
    1959                 :            : 
    1960         [ -  + ]:       1710 :         if (ACPI_SUCCESS(acpi_bus_get_ejd(device->handle, &ejd)))
    1961                 :          0 :                 register_dock_dependent_device(device, ejd);
    1962                 :            : 
    1963                 :       1710 :         acpi_bus_get_status(device);
    1964                 :            :         /* Skip devices that are not present. */
    1965         [ +  + ]:       1710 :         if (!acpi_device_is_present(device)) {
    1966                 :         30 :                 device->flags.initialized = false;
    1967                 :         30 :                 acpi_device_clear_enumerated(device);
    1968                 :         30 :                 device->flags.power_manageable = 0;
    1969                 :         30 :                 return;
    1970                 :            :         }
    1971         [ -  + ]:       1680 :         if (device->handler)
    1972                 :          0 :                 goto ok;
    1973                 :            : 
    1974         [ -  + ]:       1680 :         if (!device->flags.initialized) {
    1975                 :          0 :                 device->flags.power_manageable =
    1976                 :          0 :                         device->power.states[ACPI_STATE_D0].flags.valid;
    1977         [ #  # ]:          0 :                 if (acpi_bus_init_power(device))
    1978                 :          0 :                         device->flags.power_manageable = 0;
    1979                 :            : 
    1980                 :          0 :                 device->flags.initialized = true;
    1981         [ -  + ]:       1680 :         } else if (device->flags.visited) {
    1982                 :          0 :                 goto ok;
    1983                 :            :         }
    1984                 :            : 
    1985                 :       1680 :         ret = acpi_scan_attach_handler(device);
    1986         [ +  - ]:       1680 :         if (ret < 0)
    1987                 :            :                 return;
    1988                 :            : 
    1989                 :       1680 :         device->flags.match_driver = true;
    1990   [ +  +  +  - ]:       1680 :         if (ret > 0 && !device->flags.enumeration_by_parent) {
    1991                 :        510 :                 acpi_device_set_enumerated(device);
    1992                 :        510 :                 goto ok;
    1993                 :            :         }
    1994                 :            : 
    1995                 :       1170 :         ret = device_attach(&device->dev);
    1996         [ +  - ]:       1170 :         if (ret < 0)
    1997                 :            :                 return;
    1998                 :            : 
    1999   [ +  +  -  + ]:       1170 :         if (device->pnp.type.platform_id || device->flags.enumeration_by_parent)
    2000                 :         60 :                 acpi_default_enumeration(device);
    2001                 :            :         else
    2002                 :       1110 :                 acpi_device_set_enumerated(device);
    2003                 :            : 
    2004                 :       1680 :  ok:
    2005         [ +  + ]:       3360 :         list_for_each_entry(child, &device->children, node)
    2006                 :       1680 :                 acpi_bus_attach(child);
    2007                 :            : 
    2008   [ +  +  +  + ]:       1680 :         if (device->handler && device->handler->hotplug.notify_online)
    2009                 :         90 :                 device->handler->hotplug.notify_online(device);
    2010                 :            : }
    2011                 :            : 
    2012                 :          0 : void acpi_walk_dep_device_list(acpi_handle handle)
    2013                 :            : {
    2014                 :          0 :         struct acpi_dep_data *dep, *tmp;
    2015                 :          0 :         struct acpi_device *adev;
    2016                 :            : 
    2017                 :          0 :         mutex_lock(&acpi_dep_list_lock);
    2018         [ #  # ]:          0 :         list_for_each_entry_safe(dep, tmp, &acpi_dep_list, node) {
    2019         [ #  # ]:          0 :                 if (dep->master == handle) {
    2020                 :          0 :                         acpi_bus_get_device(dep->slave, &adev);
    2021         [ #  # ]:          0 :                         if (!adev)
    2022                 :          0 :                                 continue;
    2023                 :            : 
    2024                 :          0 :                         adev->dep_unmet--;
    2025         [ #  # ]:          0 :                         if (!adev->dep_unmet)
    2026                 :          0 :                                 acpi_bus_attach(adev);
    2027                 :          0 :                         list_del(&dep->node);
    2028                 :          0 :                         kfree(dep);
    2029                 :            :                 }
    2030                 :            :         }
    2031                 :          0 :         mutex_unlock(&acpi_dep_list_lock);
    2032                 :          0 : }
    2033                 :            : EXPORT_SYMBOL_GPL(acpi_walk_dep_device_list);
    2034                 :            : 
    2035                 :            : /**
    2036                 :            :  * acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
    2037                 :            :  * @handle: Root of the namespace scope to scan.
    2038                 :            :  *
    2039                 :            :  * Scan a given ACPI tree (probably recently hot-plugged) and create and add
    2040                 :            :  * found devices.
    2041                 :            :  *
    2042                 :            :  * If no devices were found, -ENODEV is returned, but it does not mean that
    2043                 :            :  * there has been a real error.  There just have been no suitable ACPI objects
    2044                 :            :  * in the table trunk from which the kernel could create a device and add an
    2045                 :            :  * appropriate driver.
    2046                 :            :  *
    2047                 :            :  * Must be called under acpi_scan_lock.
    2048                 :            :  */
    2049                 :         30 : int acpi_bus_scan(acpi_handle handle)
    2050                 :            : {
    2051                 :         30 :         void *device = NULL;
    2052                 :            : 
    2053         [ +  - ]:         30 :         if (ACPI_SUCCESS(acpi_bus_check_add(handle, 0, NULL, &device)))
    2054                 :         30 :                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
    2055                 :            :                                     acpi_bus_check_add, NULL, NULL, &device);
    2056                 :            : 
    2057         [ +  - ]:         30 :         if (device) {
    2058                 :         30 :                 acpi_bus_attach(device);
    2059                 :         30 :                 return 0;
    2060                 :            :         }
    2061                 :            :         return -ENODEV;
    2062                 :            : }
    2063                 :            : EXPORT_SYMBOL(acpi_bus_scan);
    2064                 :            : 
    2065                 :            : /**
    2066                 :            :  * acpi_bus_trim - Detach scan handlers and drivers from ACPI device objects.
    2067                 :            :  * @adev: Root of the ACPI namespace scope to walk.
    2068                 :            :  *
    2069                 :            :  * Must be called under acpi_scan_lock.
    2070                 :            :  */
    2071                 :          0 : void acpi_bus_trim(struct acpi_device *adev)
    2072                 :            : {
    2073                 :          0 :         struct acpi_scan_handler *handler = adev->handler;
    2074                 :          0 :         struct acpi_device *child;
    2075                 :            : 
    2076         [ #  # ]:          0 :         list_for_each_entry_reverse(child, &adev->children, node)
    2077                 :          0 :                 acpi_bus_trim(child);
    2078                 :            : 
    2079                 :          0 :         adev->flags.match_driver = false;
    2080         [ #  # ]:          0 :         if (handler) {
    2081         [ #  # ]:          0 :                 if (handler->detach)
    2082                 :          0 :                         handler->detach(adev);
    2083                 :            : 
    2084                 :          0 :                 adev->handler = NULL;
    2085                 :            :         } else {
    2086                 :          0 :                 device_release_driver(&adev->dev);
    2087                 :            :         }
    2088                 :            :         /*
    2089                 :            :          * Most likely, the device is going away, so put it into D3cold before
    2090                 :            :          * that.
    2091                 :            :          */
    2092                 :          0 :         acpi_device_set_power(adev, ACPI_STATE_D3_COLD);
    2093                 :          0 :         adev->flags.initialized = false;
    2094                 :          0 :         acpi_device_clear_enumerated(adev);
    2095                 :          0 : }
    2096                 :            : EXPORT_SYMBOL_GPL(acpi_bus_trim);
    2097                 :            : 
    2098                 :          0 : int acpi_bus_register_early_device(int type)
    2099                 :            : {
    2100                 :          0 :         struct acpi_device *device = NULL;
    2101                 :          0 :         int result;
    2102                 :            : 
    2103                 :          0 :         result = acpi_add_single_object(&device, NULL,
    2104                 :            :                                         type, ACPI_STA_DEFAULT);
    2105         [ #  # ]:          0 :         if (result)
    2106                 :            :                 return result;
    2107                 :            : 
    2108                 :          0 :         device->flags.match_driver = true;
    2109                 :          0 :         return device_attach(&device->dev);
    2110                 :            : }
    2111                 :            : EXPORT_SYMBOL_GPL(acpi_bus_register_early_device);
    2112                 :            : 
    2113                 :         30 : static int acpi_bus_scan_fixed(void)
    2114                 :            : {
    2115                 :         30 :         int result = 0;
    2116                 :            : 
    2117                 :            :         /*
    2118                 :            :          * Enumerate all fixed-feature devices.
    2119                 :            :          */
    2120         [ +  - ]:         30 :         if (!(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) {
    2121                 :         30 :                 struct acpi_device *device = NULL;
    2122                 :            : 
    2123                 :         30 :                 result = acpi_add_single_object(&device, NULL,
    2124                 :            :                                                 ACPI_BUS_TYPE_POWER_BUTTON,
    2125                 :            :                                                 ACPI_STA_DEFAULT);
    2126         [ +  - ]:         30 :                 if (result)
    2127                 :          0 :                         return result;
    2128                 :            : 
    2129                 :         30 :                 device->flags.match_driver = true;
    2130                 :         30 :                 result = device_attach(&device->dev);
    2131         [ +  - ]:         30 :                 if (result < 0)
    2132                 :            :                         return result;
    2133                 :            : 
    2134                 :         30 :                 device_init_wakeup(&device->dev, true);
    2135                 :            :         }
    2136                 :            : 
    2137         [ -  + ]:         30 :         if (!(acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON)) {
    2138                 :          0 :                 struct acpi_device *device = NULL;
    2139                 :            : 
    2140                 :          0 :                 result = acpi_add_single_object(&device, NULL,
    2141                 :            :                                                 ACPI_BUS_TYPE_SLEEP_BUTTON,
    2142                 :            :                                                 ACPI_STA_DEFAULT);
    2143         [ #  # ]:          0 :                 if (result)
    2144                 :          0 :                         return result;
    2145                 :            : 
    2146                 :          0 :                 device->flags.match_driver = true;
    2147                 :          0 :                 result = device_attach(&device->dev);
    2148                 :            :         }
    2149                 :            : 
    2150                 :         30 :         return result < 0 ? result : 0;
    2151                 :            : }
    2152                 :            : 
    2153                 :          0 : static void __init acpi_get_spcr_uart_addr(void)
    2154                 :            : {
    2155                 :          0 :         acpi_status status;
    2156                 :          0 :         struct acpi_table_spcr *spcr_ptr;
    2157                 :            : 
    2158                 :          0 :         status = acpi_get_table(ACPI_SIG_SPCR, 0,
    2159                 :            :                                 (struct acpi_table_header **)&spcr_ptr);
    2160         [ #  # ]:          0 :         if (ACPI_SUCCESS(status))
    2161                 :          0 :                 spcr_uart_addr = spcr_ptr->serial_port.address;
    2162                 :            :         else
    2163                 :          0 :                 printk(KERN_WARNING PREFIX "STAO table present, but SPCR is missing\n");
    2164                 :          0 : }
    2165                 :            : 
    2166                 :            : static bool acpi_scan_initialized;
    2167                 :            : 
    2168                 :         30 : int __init acpi_scan_init(void)
    2169                 :            : {
    2170                 :         30 :         int result;
    2171                 :         30 :         acpi_status status;
    2172                 :         30 :         struct acpi_table_stao *stao_ptr;
    2173                 :            : 
    2174                 :         30 :         acpi_pci_root_init();
    2175                 :         30 :         acpi_pci_link_init();
    2176                 :         30 :         acpi_processor_init();
    2177                 :         30 :         acpi_platform_init();
    2178                 :         30 :         acpi_lpss_init();
    2179                 :         30 :         acpi_apd_init();
    2180                 :         30 :         acpi_cmos_rtc_init();
    2181                 :         30 :         acpi_container_init();
    2182                 :         30 :         acpi_memory_hotplug_init();
    2183                 :         30 :         acpi_watchdog_init();
    2184                 :         30 :         acpi_pnp_init();
    2185                 :         30 :         acpi_int340x_thermal_init();
    2186                 :         30 :         acpi_amba_init();
    2187                 :         30 :         acpi_init_lpit();
    2188                 :            : 
    2189                 :         30 :         acpi_scan_add_handler(&generic_device_handler);
    2190                 :            : 
    2191                 :            :         /*
    2192                 :            :          * If there is STAO table, check whether it needs to ignore the UART
    2193                 :            :          * device in SPCR table.
    2194                 :            :          */
    2195                 :         30 :         status = acpi_get_table(ACPI_SIG_STAO, 0,
    2196                 :            :                                 (struct acpi_table_header **)&stao_ptr);
    2197         [ -  + ]:         30 :         if (ACPI_SUCCESS(status)) {
    2198         [ #  # ]:          0 :                 if (stao_ptr->header.length > sizeof(struct acpi_table_stao))
    2199                 :          0 :                         printk(KERN_INFO PREFIX "STAO Name List not yet supported.");
    2200                 :            : 
    2201         [ #  # ]:          0 :                 if (stao_ptr->ignore_uart)
    2202                 :          0 :                         acpi_get_spcr_uart_addr();
    2203                 :            :         }
    2204                 :            : 
    2205                 :         30 :         acpi_gpe_apply_masked_gpes();
    2206                 :         30 :         acpi_update_all_gpes();
    2207                 :            : 
    2208                 :            :         /*
    2209                 :            :          * Although we call __add_memory() that is documented to require the
    2210                 :            :          * device_hotplug_lock, it is not necessary here because this is an
    2211                 :            :          * early code when userspace or any other code path cannot trigger
    2212                 :            :          * hotplug/hotunplug operations.
    2213                 :            :          */
    2214                 :         30 :         mutex_lock(&acpi_scan_lock);
    2215                 :            :         /*
    2216                 :            :          * Enumerate devices in the ACPI namespace.
    2217                 :            :          */
    2218                 :         30 :         result = acpi_bus_scan(ACPI_ROOT_OBJECT);
    2219         [ -  + ]:         30 :         if (result)
    2220                 :          0 :                 goto out;
    2221                 :            : 
    2222                 :         30 :         result = acpi_bus_get_device(ACPI_ROOT_OBJECT, &acpi_root);
    2223         [ -  + ]:         30 :         if (result)
    2224                 :          0 :                 goto out;
    2225                 :            : 
    2226                 :            :         /* Fixed feature devices do not exist on HW-reduced platform */
    2227         [ +  - ]:         30 :         if (!acpi_gbl_reduced_hardware) {
    2228                 :         30 :                 result = acpi_bus_scan_fixed();
    2229         [ -  + ]:         30 :                 if (result) {
    2230                 :          0 :                         acpi_detach_data(acpi_root->handle,
    2231                 :            :                                          acpi_scan_drop_device);
    2232                 :          0 :                         acpi_device_del(acpi_root);
    2233                 :          0 :                         put_device(&acpi_root->dev);
    2234                 :          0 :                         goto out;
    2235                 :            :                 }
    2236                 :            :         }
    2237                 :            : 
    2238                 :         30 :         acpi_scan_initialized = true;
    2239                 :            : 
    2240                 :         30 :  out:
    2241                 :         30 :         mutex_unlock(&acpi_scan_lock);
    2242                 :         30 :         return result;
    2243                 :            : }
    2244                 :            : 
    2245                 :            : static struct acpi_probe_entry *ape;
    2246                 :            : static int acpi_probe_count;
    2247                 :            : static DEFINE_MUTEX(acpi_probe_mutex);
    2248                 :            : 
    2249                 :          0 : static int __init acpi_match_madt(union acpi_subtable_headers *header,
    2250                 :            :                                   const unsigned long end)
    2251                 :            : {
    2252   [ #  #  #  # ]:          0 :         if (!ape->subtable_valid || ape->subtable_valid(&header->common, ape))
    2253         [ #  # ]:          0 :                 if (!ape->probe_subtbl(header, end))
    2254                 :          0 :                         acpi_probe_count++;
    2255                 :            : 
    2256                 :          0 :         return 0;
    2257                 :            : }
    2258                 :            : 
    2259                 :          0 : int __init __acpi_probe_device_table(struct acpi_probe_entry *ap_head, int nr)
    2260                 :            : {
    2261                 :          0 :         int count = 0;
    2262                 :            : 
    2263         [ #  # ]:          0 :         if (acpi_disabled)
    2264                 :            :                 return 0;
    2265                 :            : 
    2266                 :          0 :         mutex_lock(&acpi_probe_mutex);
    2267         [ #  # ]:          0 :         for (ape = ap_head; nr; ape++, nr--) {
    2268         [ #  # ]:          0 :                 if (ACPI_COMPARE_NAMESEG(ACPI_SIG_MADT, ape->id)) {
    2269                 :          0 :                         acpi_probe_count = 0;
    2270                 :          0 :                         acpi_table_parse_madt(ape->type, acpi_match_madt, 0);
    2271                 :          0 :                         count += acpi_probe_count;
    2272                 :            :                 } else {
    2273                 :          0 :                         int res;
    2274                 :          0 :                         res = acpi_table_parse(ape->id, ape->probe_table);
    2275         [ #  # ]:          0 :                         if (!res)
    2276                 :          0 :                                 count++;
    2277                 :            :                 }
    2278                 :            :         }
    2279                 :          0 :         mutex_unlock(&acpi_probe_mutex);
    2280                 :            : 
    2281                 :          0 :         return count;
    2282                 :            : }
    2283                 :            : 
    2284                 :            : struct acpi_table_events_work {
    2285                 :            :         struct work_struct work;
    2286                 :            :         void *table;
    2287                 :            :         u32 event;
    2288                 :            : };
    2289                 :            : 
    2290                 :          0 : static void acpi_table_events_fn(struct work_struct *work)
    2291                 :            : {
    2292                 :          0 :         struct acpi_table_events_work *tew;
    2293                 :            : 
    2294                 :          0 :         tew = container_of(work, struct acpi_table_events_work, work);
    2295                 :            : 
    2296         [ #  # ]:          0 :         if (tew->event == ACPI_TABLE_EVENT_LOAD) {
    2297                 :          0 :                 acpi_scan_lock_acquire();
    2298                 :          0 :                 acpi_bus_scan(ACPI_ROOT_OBJECT);
    2299                 :          0 :                 acpi_scan_lock_release();
    2300                 :            :         }
    2301                 :            : 
    2302                 :          0 :         kfree(tew);
    2303                 :          0 : }
    2304                 :            : 
    2305                 :          0 : void acpi_scan_table_handler(u32 event, void *table, void *context)
    2306                 :            : {
    2307                 :          0 :         struct acpi_table_events_work *tew;
    2308                 :            : 
    2309         [ #  # ]:          0 :         if (!acpi_scan_initialized)
    2310                 :            :                 return;
    2311                 :            : 
    2312         [ #  # ]:          0 :         if (event != ACPI_TABLE_EVENT_LOAD)
    2313                 :            :                 return;
    2314                 :            : 
    2315                 :          0 :         tew = kmalloc(sizeof(*tew), GFP_KERNEL);
    2316         [ #  # ]:          0 :         if (!tew)
    2317                 :            :                 return;
    2318                 :            : 
    2319                 :          0 :         INIT_WORK(&tew->work, acpi_table_events_fn);
    2320                 :          0 :         tew->table = table;
    2321                 :          0 :         tew->event = event;
    2322                 :            : 
    2323                 :          0 :         schedule_work(&tew->work);
    2324                 :            : }
    2325                 :            : 
    2326                 :         60 : int acpi_reconfig_notifier_register(struct notifier_block *nb)
    2327                 :            : {
    2328                 :         60 :         return blocking_notifier_chain_register(&acpi_reconfig_chain, nb);
    2329                 :            : }
    2330                 :            : EXPORT_SYMBOL(acpi_reconfig_notifier_register);
    2331                 :            : 
    2332                 :          0 : int acpi_reconfig_notifier_unregister(struct notifier_block *nb)
    2333                 :            : {
    2334                 :          0 :         return blocking_notifier_chain_unregister(&acpi_reconfig_chain, nb);
    2335                 :            : }
    2336                 :            : EXPORT_SYMBOL(acpi_reconfig_notifier_unregister);

Generated by: LCOV version 1.14