Merge branch 'acpi-cleanup'
authorRafael J. Wysocki <rafael.j.wysocki@intel.com>
Fri, 15 Feb 2013 12:58:30 +0000 (13:58 +0100)
committerRafael J. Wysocki <rafael.j.wysocki@intel.com>
Fri, 15 Feb 2013 12:58:30 +0000 (13:58 +0100)
* acpi-cleanup: (21 commits)
  ACPI / hotplug: Fix concurrency issues and memory leaks
  ACPI: Remove the use of CONFIG_ACPI_CONTAINER_MODULE
  ACPI / scan: Full transition to D3cold in acpi_device_unregister()
  ACPI / scan: Make acpi_bus_hot_remove_device() acquire the scan lock
  ACPI: Drop the container.h header file
  ACPI / Documentation: refer to correct file for acpi_platform_device_ids[] table
  ACPI / scan: Make container driver use struct acpi_scan_handler
  ACPI / scan: Remove useless #ifndef from acpi_eject_store()
  ACPI: Unbind ACPI drv when probe failed
  ACPI: sysfs eject support for ACPI scan handlers
  ACPI / scan: Follow priorities of IDs when matching scan handlers
  ACPI / PCI: pci_slot: replace printk(KERN_xxx) with pr_xxx()
  ACPI / dock: Fix acpi_bus_get_device() check in drivers/acpi/dock.c
  ACPI / scan: Clean up acpi_bus_get_parent()
  ACPI / platform: Use struct acpi_scan_handler for creating devices
  ACPI / PCI: Make PCI IRQ link driver use struct acpi_scan_handler
  ACPI / PCI: Make PCI root driver use struct acpi_scan_handler
  ACPI / scan: Introduce struct acpi_scan_handler
  ACPI / scan: Make scanning of fixed devices follow the general scheme
  ACPI: Drop device start operation that is not used
  ...

1  2 
drivers/acpi/scan.c

diff --combined drivers/acpi/scan.c
index c4358716aadcca510a58ccfb5b0d554d159b917c,d16a94ef0baf6e1c89ddfd4415572e0fa1f6f554..daee7497efd30137f2dddef2497f9968555d4e26
@@@ -29,30 -29,10 +29,10 @@@ extern struct acpi_device *acpi_root
  
  static const char *dummy_hid = "device";
  
- /*
-  * The following ACPI IDs are known to be suitable for representing as
-  * platform devices.
-  */
- static const struct acpi_device_id acpi_platform_device_ids[] = {
-       { "PNP0D40" },
-       /* Haswell LPSS devices */
-       { "INT33C0", ACPI_PLATFORM_CLK },
-       { "INT33C1", ACPI_PLATFORM_CLK },
-       { "INT33C2", ACPI_PLATFORM_CLK },
-       { "INT33C3", ACPI_PLATFORM_CLK },
-       { "INT33C4", ACPI_PLATFORM_CLK },
-       { "INT33C5", ACPI_PLATFORM_CLK },
-       { "INT33C6", ACPI_PLATFORM_CLK },
-       { "INT33C7", ACPI_PLATFORM_CLK },
-       { }
- };
  static LIST_HEAD(acpi_device_list);
  static LIST_HEAD(acpi_bus_id_list);
  static DEFINE_MUTEX(acpi_scan_lock);
+ static LIST_HEAD(acpi_scan_handlers_list);
  DEFINE_MUTEX(acpi_device_lock);
  LIST_HEAD(acpi_wakeup_device_list);
  
@@@ -62,6 -42,27 +42,27 @@@ struct acpi_device_bus_id
        struct list_head node;
  };
  
+ void acpi_scan_lock_acquire(void)
+ {
+       mutex_lock(&acpi_scan_lock);
+ }
+ EXPORT_SYMBOL_GPL(acpi_scan_lock_acquire);
+ void acpi_scan_lock_release(void)
+ {
+       mutex_unlock(&acpi_scan_lock);
+ }
+ EXPORT_SYMBOL_GPL(acpi_scan_lock_release);
+ int acpi_scan_add_handler(struct acpi_scan_handler *handler)
+ {
+       if (!handler || !handler->attach)
+               return -EINVAL;
+       list_add_tail(&handler->list_node, &acpi_scan_handlers_list);
+       return 0;
+ }
  /*
   * Creates hid/cid(s) string needed for modalias and uevent
   * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get:
@@@ -116,7 -117,7 +117,7 @@@ static DEVICE_ATTR(modalias, 0444, acpi
   */
  void acpi_bus_hot_remove_device(void *context)
  {
-       struct acpi_eject_event *ej_event = (struct acpi_eject_event *) context;
+       struct acpi_eject_event *ej_event = context;
        struct acpi_device *device = ej_event->device;
        acpi_handle handle = device->handle;
        acpi_handle temp;
        acpi_status status = AE_OK;
        u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE; /* default */
  
+       mutex_lock(&acpi_scan_lock);
+       /* If there is no handle, the device node has been unregistered. */
+       if (!device->handle) {
+               dev_dbg(&device->dev, "ACPI handle missing\n");
+               put_device(&device->dev);
+               goto out;
+       }
        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                "Hot-removing device %s...\n", dev_name(&device->dev)));
  
        acpi_bus_trim(device);
-       /* Device node has been released. */
+       /* Device node has been unregistered. */
+       put_device(&device->dev);
        device = NULL;
  
-       /* power off device */
-       status = acpi_evaluate_object(handle, "_PS3", NULL, NULL);
-       if (ACPI_FAILURE(status) && status != AE_NOT_FOUND)
-               printk(KERN_WARNING PREFIX
-                               "Power-off device failed\n");
        if (ACPI_SUCCESS(acpi_get_handle(handle, "_LCK", &temp))) {
                arg_list.count = 1;
                arg_list.pointer = &arg;
        status = acpi_evaluate_object(handle, "_EJ0", &arg_list, NULL);
        if (ACPI_FAILURE(status)) {
                if (status != AE_NOT_FOUND)
-                       printk(KERN_WARNING PREFIX
-                                       "Eject device failed\n");
-               goto err_out;
-       }
+                       acpi_handle_warn(handle, "Eject failed\n");
  
-       kfree(context);
-       return;
+               /* Tell the firmware the hot-remove operation has failed. */
+               acpi_evaluate_hotplug_ost(handle, ej_event->event,
+                                         ost_code, NULL);
+       }
  
- err_out:
-       /* Inform firmware the hot-remove operation has completed w/ error */
-       (void) acpi_evaluate_hotplug_ost(handle,
-                               ej_event->event, ost_code, NULL);
+  out:
+       mutex_unlock(&acpi_scan_lock);
        kfree(context);
        return;
  }
@@@ -213,12 -215,10 +215,10 @@@ acpi_eject_store(struct device *d, stru
        if ((!count) || (buf[0] != '1')) {
                return -EINVAL;
        }
- #ifndef FORCE_EJECT
-       if (acpi_device->driver == NULL) {
+       if (!acpi_device->driver && !acpi_device->handler) {
                ret = -ENODEV;
                goto err;
        }
- #endif
        status = acpi_get_type(acpi_device->handle, &type);
        if (ACPI_FAILURE(status) || (!acpi_device->flags.ejectable)) {
                ret = -ENODEV;
                goto err;
        }
  
+       get_device(&acpi_device->dev);
        ej_event->device = acpi_device;
        if (acpi_device->flags.eject_pending) {
                /* event originated from ACPI eject notification */
                        ej_event->event, ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
        }
  
-       acpi_os_hotplug_execute(acpi_bus_hot_remove_device, (void *)ej_event);
+       status = acpi_os_hotplug_execute(acpi_bus_hot_remove_device, ej_event);
+       if (ACPI_FAILURE(status)) {
+               put_device(&acpi_device->dev);
+               kfree(ej_event);
+       }
  err:
        return ret;
  }
@@@ -491,9 -496,9 +496,9 @@@ const struct acpi_device_id *acpi_match
                                               const struct device *dev)
  {
        struct acpi_device *adev;
 +      acpi_handle handle = ACPI_HANDLE(dev);
  
 -      if (!ids || !ACPI_HANDLE(dev)
 -          || ACPI_FAILURE(acpi_bus_get_device(ACPI_HANDLE(dev), &adev)))
 +      if (!ids || !handle || acpi_bus_get_device(handle, &adev))
                return NULL;
  
        return __acpi_match_device(adev, ids);
@@@ -637,8 -642,9 +642,9 @@@ static int acpi_device_probe(struct dev
                        ret = acpi_device_install_notify_handler(acpi_dev);
                        if (ret) {
                                if (acpi_drv->ops.remove)
-                                       acpi_drv->ops.remove(acpi_dev,
-                                                    acpi_dev->removal_type);
+                                       acpi_drv->ops.remove(acpi_dev);
+                               acpi_dev->driver = NULL;
+                               acpi_dev->driver_data = NULL;
                                return ret;
                        }
                }
@@@ -660,7 -666,7 +666,7 @@@ static int acpi_device_remove(struct de
                if (acpi_drv->ops.notify)
                        acpi_device_remove_notify_handler(acpi_dev);
                if (acpi_drv->ops.remove)
-                       acpi_drv->ops.remove(acpi_dev, acpi_dev->removal_type);
+                       acpi_drv->ops.remove(acpi_dev);
        }
        acpi_dev->driver = NULL;
        acpi_dev->driver_data = NULL;
@@@ -792,10 -798,12 +798,12 @@@ static void acpi_device_unregister(stru
  
        device_del(&device->dev);
        /*
-        * Drop the reference counts of all power resources the device depends
-        * on and turn off the ones that have no more references.
+        * Transition the device to D3cold to drop the reference counts of all
+        * power resources the device depends on and turn off the ones that have
+        * no more references.
         */
-       acpi_power_transition(device, ACPI_STATE_D3_COLD);
+       acpi_device_set_power(device, ACPI_STATE_D3_COLD);
+       device->handle = NULL;
        put_device(&device->dev);
  }
  
@@@ -883,29 -891,23 +891,23 @@@ EXPORT_SYMBOL(acpi_bus_unregister_drive
     -------------------------------------------------------------------------- */
  static struct acpi_device *acpi_bus_get_parent(acpi_handle handle)
  {
+       struct acpi_device *device = NULL;
        acpi_status status;
-       int ret;
-       struct acpi_device *device;
  
        /*
         * Fixed hardware devices do not appear in the namespace and do not
         * have handles, but we fabricate acpi_devices for them, so we have
         * to deal with them specially.
         */
-       if (handle == NULL)
+       if (!handle)
                return acpi_root;
  
        do {
                status = acpi_get_parent(handle, &handle);
-               if (status == AE_NULL_ENTRY)
-                       return NULL;
                if (ACPI_FAILURE(status))
-                       return acpi_root;
-               ret = acpi_bus_get_device(handle, &device);
-               if (ret == 0)
-                       return device;
-       } while (1);
+                       return status == AE_NULL_ENTRY ? NULL : acpi_root;
+       } while (acpi_bus_get_device(handle, &device));
+       return device;
  }
  
  acpi_status
@@@ -1176,10 -1178,7 +1178,10 @@@ static void acpi_bus_get_power_flags(st
                        device->power.flags.power_resources)
                device->power.states[ACPI_STATE_D3_COLD].flags.os_accessible = 1;
  
 -      acpi_bus_init_power(device);
 +      if (acpi_bus_init_power(device)) {
 +              acpi_free_power_resources_lists(device);
 +              device->flags.power_manageable = 0;
 +      }
  }
  
  static void acpi_bus_get_flags(struct acpi_device *device)
@@@ -1441,19 -1440,21 +1443,21 @@@ void acpi_init_device_object(struct acp
        acpi_device_get_busid(device);
        acpi_device_set_id(device);
        acpi_bus_get_flags(device);
+       device->flags.match_driver = false;
        device_initialize(&device->dev);
        dev_set_uevent_suppress(&device->dev, true);
  }
  
  void acpi_device_add_finalize(struct acpi_device *device)
  {
+       device->flags.match_driver = true;
        dev_set_uevent_suppress(&device->dev, false);
        kobject_uevent(&device->dev.kobj, KOBJ_ADD);
  }
  
  static int acpi_add_single_object(struct acpi_device **child,
                                  acpi_handle handle, int type,
-                                 unsigned long long sta, bool match_driver)
+                                 unsigned long long sta)
  {
        int result;
        struct acpi_device *device;
        acpi_bus_get_power_flags(device);
        acpi_bus_get_wakeup_device_flags(device);
  
-       device->flags.match_driver = match_driver;
        result = acpi_device_add(device, acpi_device_release);
        if (result) {
                acpi_device_release(&device->dev);
@@@ -1562,12 -1562,10 +1565,10 @@@ static acpi_status acpi_bus_check_add(a
                return AE_CTRL_DEPTH;
        }
  
-       acpi_add_single_object(&device, handle, type, sta, false);
+       acpi_add_single_object(&device, handle, type, sta);
        if (!device)
                return AE_CTRL_DEPTH;
  
-       device->flags.match_driver = true;
   out:
        if (!*return_value)
                *return_value = device;
        return AE_OK;
  }
  
+ static int acpi_scan_do_attach_handler(struct acpi_device *device, char *id)
+ {
+       struct acpi_scan_handler *handler;
+       list_for_each_entry(handler, &acpi_scan_handlers_list, list_node) {
+               const struct acpi_device_id *devid;
+               for (devid = handler->ids; devid->id[0]; devid++) {
+                       int ret;
+                       if (strcmp((char *)devid->id, id))
+                               continue;
+                       ret = handler->attach(device, devid);
+                       if (ret > 0) {
+                               device->handler = handler;
+                               return ret;
+                       } else if (ret < 0) {
+                               return ret;
+                       }
+               }
+       }
+       return 0;
+ }
+ static int acpi_scan_attach_handler(struct acpi_device *device)
+ {
+       struct acpi_hardware_id *hwid;
+       int ret = 0;
+       list_for_each_entry(hwid, &device->pnp.ids, list) {
+               ret = acpi_scan_do_attach_handler(device, hwid->id);
+               if (ret)
+                       break;
+       }
+       return ret;
+ }
  static acpi_status acpi_bus_device_attach(acpi_handle handle, u32 lvl_not_used,
                                          void *not_used, void **ret_not_used)
  {
-       const struct acpi_device_id *id;
-       acpi_status status = AE_OK;
        struct acpi_device *device;
        unsigned long long sta_not_used;
-       int type_not_used;
+       int ret;
  
        /*
         * Ignore errors ignored by acpi_bus_check_add() to avoid terminating
         * namespace walks prematurely.
         */
-       if (acpi_bus_type_and_status(handle, &type_not_used, &sta_not_used))
+       if (acpi_bus_type_and_status(handle, &ret, &sta_not_used))
                return AE_OK;
  
        if (acpi_bus_get_device(handle, &device))
                return AE_CTRL_DEPTH;
  
-       id = __acpi_match_device(device, acpi_platform_device_ids);
-       if (id) {
-               /* This is a known good platform device. */
-               acpi_create_platform_device(device, id->driver_data);
-       } else if (device_attach(&device->dev) < 0) {
-               status = AE_CTRL_DEPTH;
-       }
-       return status;
+       ret = acpi_scan_attach_handler(device);
+       if (ret)
+               return ret > 0 ? AE_OK : AE_CTRL_DEPTH;
+       ret = device_attach(&device->dev);
+       return ret >= 0 ? AE_OK : AE_CTRL_DEPTH;
  }
  
  /**
   * there has been a real error.  There just have been no suitable ACPI objects
   * in the table trunk from which the kernel could create a device and add an
   * appropriate driver.
+  *
+  * Must be called under acpi_scan_lock.
   */
  int acpi_bus_scan(acpi_handle handle)
  {
        void *device = NULL;
        int error = 0;
  
-       mutex_lock(&acpi_scan_lock);
        if (ACPI_SUCCESS(acpi_bus_check_add(handle, 0, NULL, &device)))
                acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
                                    acpi_bus_check_add, NULL, NULL, &device);
                acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
                                    acpi_bus_device_attach, NULL, NULL, NULL);
  
-       mutex_unlock(&acpi_scan_lock);
        return error;
  }
  EXPORT_SYMBOL(acpi_bus_scan);
@@@ -1644,8 -1676,17 +1679,17 @@@ static acpi_status acpi_bus_device_deta
        struct acpi_device *device = NULL;
  
        if (!acpi_bus_get_device(handle, &device)) {
+               struct acpi_scan_handler *dev_handler = device->handler;
                device->removal_type = ACPI_BUS_REMOVAL_EJECT;
-               device_release_driver(&device->dev);
+               if (dev_handler) {
+                       if (dev_handler->detach)
+                               dev_handler->detach(device);
+                       device->handler = NULL;
+               } else {
+                       device_release_driver(&device->dev);
+               }
        }
        return AE_OK;
  }
@@@ -1661,10 -1702,14 +1705,14 @@@ static acpi_status acpi_bus_remove(acpi
        return AE_OK;
  }
  
+ /**
+  * acpi_bus_trim - Remove ACPI device node and all of its descendants
+  * @start: Root of the ACPI device nodes subtree to remove.
+  *
+  * Must be called under acpi_scan_lock.
+  */
  void acpi_bus_trim(struct acpi_device *start)
  {
-       mutex_lock(&acpi_scan_lock);
        /*
         * Execute acpi_bus_device_detach() as a post-order callback to detach
         * all ACPI drivers from the device nodes being removed.
        acpi_walk_namespace(ACPI_TYPE_ANY, start->handle, ACPI_UINT32_MAX, NULL,
                            acpi_bus_remove, NULL, NULL);
        acpi_bus_remove(start->handle, 0, NULL, NULL);
-       mutex_unlock(&acpi_scan_lock);
  }
  EXPORT_SYMBOL_GPL(acpi_bus_trim);
  
  static int acpi_bus_scan_fixed(void)
  {
        int result = 0;
-       struct acpi_device *device = NULL;
  
        /*
         * Enumerate all fixed-feature devices.
         */
-       if ((acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON) == 0) {
+       if (!(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) {
+               struct acpi_device *device = NULL;
                result = acpi_add_single_object(&device, NULL,
                                                ACPI_BUS_TYPE_POWER_BUTTON,
-                                               ACPI_STA_DEFAULT, true);
+                                               ACPI_STA_DEFAULT);
+               if (result)
+                       return result;
+               result = device_attach(&device->dev);
+               if (result < 0)
+                       return result;
                device_init_wakeup(&device->dev, true);
        }
  
-       if ((acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON) == 0) {
+       if (!(acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON)) {
+               struct acpi_device *device = NULL;
                result = acpi_add_single_object(&device, NULL,
                                                ACPI_BUS_TYPE_SLEEP_BUTTON,
-                                               ACPI_STA_DEFAULT, true);
+                                               ACPI_STA_DEFAULT);
+               if (result)
+                       return result;
+               result = device_attach(&device->dev);
        }
  
-       return result;
+       return result < 0 ? result : 0;
  }
  
  int __init acpi_scan_init(void)
        }
  
        acpi_pci_root_init();
+       acpi_pci_link_init();
+       acpi_platform_init();
        acpi_csrt_init();
+       acpi_container_init();
  
+       mutex_lock(&acpi_scan_lock);
        /*
         * Enumerate devices in the ACPI namespace.
         */
        result = acpi_bus_scan(ACPI_ROOT_OBJECT);
        if (result)
-               return result;
+               goto out;
  
        result = acpi_bus_get_device(ACPI_ROOT_OBJECT, &acpi_root);
        if (result)
-               return result;
+               goto out;
  
        result = acpi_bus_scan_fixed();
        if (result) {
                acpi_device_unregister(acpi_root);
-               return result;
+               goto out;
        }
  
        acpi_update_all_gpes();
-       return 0;
+  out:
+       mutex_unlock(&acpi_scan_lock);
+       return result;
  }