1 files changed, 139 insertions, 15 deletions

diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 1fcb8678665c..53502d1bbf26 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -29,6 +29,27 @@ 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", 0 },
+        { "INT33C1", 0 },
+        { "INT33C2", 0 },
+        { "INT33C3", 0 },
+        { "INT33C4", 0 },
+        { "INT33C5", 0 },
+        { "INT33C6", 0 },
+        { "INT33C7", 0 },
+
+        { }
+};
+
 static LIST_HEAD(acpi_device_list);
 static LIST_HEAD(acpi_bus_id_list);
 DEFINE_MUTEX(acpi_device_lock);
@@ -97,6 +118,7 @@ void acpi_bus_hot_remove_device(void *context)
         struct acpi_eject_event *ej_event = (struct acpi_eject_event *) context;
         struct acpi_device *device;
         acpi_handle handle = ej_event->handle;
+        acpi_handle temp;
         struct acpi_object_list arg_list;
         union acpi_object arg;
         acpi_status status = AE_OK;
@@ -117,13 +139,16 @@ void acpi_bus_hot_remove_device(void *context)
                 goto err_out;
         }
 
+        /* device has been freed */
+        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 (device->flags.lockable) {
+        if (ACPI_SUCCESS(acpi_get_handle(handle, "_LCK", &temp))) {
                 arg_list.count = 1;
                 arg_list.pointer = &arg;
                 arg.type = ACPI_TYPE_INTEGER;
@@ -157,6 +182,7 @@ err_out:
         kfree(context);
         return;
 }
+EXPORT_SYMBOL(acpi_bus_hot_remove_device);
 
 static ssize_t
 acpi_eject_store(struct device *d, struct device_attribute *attr,
@@ -216,6 +242,25 @@ acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *bu
 }
 static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
 
+static ssize_t acpi_device_uid_show(struct device *dev,
+                                    struct device_attribute *attr, char *buf)
+{
+        struct acpi_device *acpi_dev = to_acpi_device(dev);
+
+        return sprintf(buf, "%s\n", acpi_dev->pnp.unique_id);
+}
+static DEVICE_ATTR(uid, 0444, acpi_device_uid_show, NULL);
+
+static ssize_t acpi_device_adr_show(struct device *dev,
+                                    struct device_attribute *attr, char *buf)
+{
+        struct acpi_device *acpi_dev = to_acpi_device(dev);
+
+        return sprintf(buf, "0x%08x\n",
+                       (unsigned int)(acpi_dev->pnp.bus_address));
+}
+static DEVICE_ATTR(adr, 0444, acpi_device_adr_show, NULL);
+
 static ssize_t
 acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *buf) {
         struct acpi_device *acpi_dev = to_acpi_device(dev);
@@ -259,11 +304,21 @@ static ssize_t description_show(struct device *dev,
 }
 static DEVICE_ATTR(description, 0444, description_show, NULL);
 
+static ssize_t
+acpi_device_sun_show(struct device *dev, struct device_attribute *attr,
+                     char *buf) {
+        struct acpi_device *acpi_dev = to_acpi_device(dev);
+
+        return sprintf(buf, "%lu\n", acpi_dev->pnp.sun);
+}
+static DEVICE_ATTR(sun, 0444, acpi_device_sun_show, NULL);
+
 static int acpi_device_setup_files(struct acpi_device *dev)
 {
         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
         acpi_status status;
         acpi_handle temp;
+        unsigned long long sun;
         int result = 0;
 
         /*
@@ -300,6 +355,21 @@ static int acpi_device_setup_files(struct acpi_device *dev)
                         goto end;
         }
 
+        if (dev->flags.bus_address)
+                result = device_create_file(&dev->dev, &dev_attr_adr);
+        if (dev->pnp.unique_id)
+                result = device_create_file(&dev->dev, &dev_attr_uid);
+
+        status = acpi_evaluate_integer(dev->handle, "_SUN", NULL, &sun);
+        if (ACPI_SUCCESS(status)) {
+                dev->pnp.sun = (unsigned long)sun;
+                result = device_create_file(&dev->dev, &dev_attr_sun);
+                if (result)
+                        goto end;
+        } else {
+                dev->pnp.sun = (unsigned long)-1;
+        }
+
         /*
          * If device has _EJ0, 'eject' file is created that is used to trigger
          * hot-removal function from userland.
@@ -331,6 +401,14 @@ static void acpi_device_remove_files(struct acpi_device *dev)
         if (ACPI_SUCCESS(status))
                 device_remove_file(&dev->dev, &dev_attr_eject);
 
+        status = acpi_get_handle(dev->handle, "_SUN", &temp);
+        if (ACPI_SUCCESS(status))
+                device_remove_file(&dev->dev, &dev_attr_sun);
+
+        if (dev->pnp.unique_id)
+                device_remove_file(&dev->dev, &dev_attr_uid);
+        if (dev->flags.bus_address)
+                device_remove_file(&dev->dev, &dev_attr_adr);
         device_remove_file(&dev->dev, &dev_attr_modalias);
         device_remove_file(&dev->dev, &dev_attr_hid);
         if (dev->handle)
@@ -340,8 +418,8 @@ static void acpi_device_remove_files(struct acpi_device *dev)
                         ACPI Bus operations
    -------------------------------------------------------------------------- */
 
-int acpi_match_device_ids(struct acpi_device *device,
-                          const struct acpi_device_id *ids)
+static const struct acpi_device_id *__acpi_match_device(
+        struct acpi_device *device, const struct acpi_device_id *ids)
 {
         const struct acpi_device_id *id;
         struct acpi_hardware_id *hwid;
@@ -351,14 +429,44 @@ int acpi_match_device_ids(struct acpi_device *device,
          * driver for it.
          */
         if (!device->status.present)
-                return -ENODEV;
+                return NULL;
 
         for (id = ids; id->id[0]; id++)
                 list_for_each_entry(hwid, &device->pnp.ids, list)
                         if (!strcmp((char *) id->id, hwid->id))
-                                return 0;
+                                return id;
 
-        return -ENOENT;
+        return NULL;
+}
+
+/**
+ * acpi_match_device - Match a struct device against a given list of ACPI IDs
+ * @ids: Array of struct acpi_device_id object to match against.
+ * @dev: The device structure to match.
+ *
+ * Check if @dev has a valid ACPI handle and if there is a struct acpi_device
+ * object for that handle and use that object to match against a given list of
+ * device IDs.
+ *
+ * Return a pointer to the first matching ID on success or %NULL on failure.
+ */
+const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
+                                               const struct device *dev)
+{
+        struct acpi_device *adev;
+
+        if (!ids || !ACPI_HANDLE(dev)
+            || ACPI_FAILURE(acpi_bus_get_device(ACPI_HANDLE(dev), &adev)))
+                return NULL;
+
+        return __acpi_match_device(adev, ids);
+}
+EXPORT_SYMBOL_GPL(acpi_match_device);
+
+int acpi_match_device_ids(struct acpi_device *device,
+                          const struct acpi_device_id *ids)
+{
+        return __acpi_match_device(device, ids) ? 0 : -ENOENT;
 }
 EXPORT_SYMBOL(acpi_match_device_ids);
 
@@ -377,6 +485,7 @@ static void acpi_device_release(struct device *dev)
         struct acpi_device *acpi_dev = to_acpi_device(dev);
 
         acpi_free_ids(acpi_dev);
+        kfree(acpi_dev->pnp.unique_id);
         kfree(acpi_dev);
 }
 
@@ -859,8 +968,8 @@ acpi_bus_extract_wakeup_device_power_package(acpi_handle handle,
 static void acpi_bus_set_run_wake_flags(struct acpi_device *device)
 {
         struct acpi_device_id button_device_ids[] = {
-                {"PNP0C0D", 0},
                 {"PNP0C0C", 0},
+                {"PNP0C0D", 0},
                 {"PNP0C0E", 0},
                 {"", 0},
         };
@@ -872,6 +981,11 @@ static void acpi_bus_set_run_wake_flags(struct acpi_device *device)
         /* Power button, Lid switch always enable wakeup */
         if (!acpi_match_device_ids(device, button_device_ids)) {
                 device->wakeup.flags.run_wake = 1;
+                if (!acpi_match_device_ids(device, &button_device_ids[1])) {
+                        /* Do not use Lid/sleep button for S5 wakeup */
+                        if (device->wakeup.sleep_state == ACPI_STATE_S5)
+                                device->wakeup.sleep_state = ACPI_STATE_S4;
+                }
                 device_set_wakeup_capable(&device->dev, true);
                 return;
         }
@@ -965,8 +1079,10 @@ static int acpi_bus_get_power_flags(struct acpi_device *device)
                  * D3hot is only valid if _PR3 present.
                  */
                 if (ps->resources.count ||
-                    (ps->flags.explicit_set && i < ACPI_STATE_D3_HOT))
+                    (ps->flags.explicit_set && i < ACPI_STATE_D3_HOT)) {
                         ps->flags.valid = 1;
+                        ps->flags.os_accessible = 1;
+                }
 
                 ps->power = -1; /* Unknown - driver assigned */
                 ps->latency = -1;       /* Unknown - driver assigned */
@@ -982,6 +1098,11 @@ static int acpi_bus_get_power_flags(struct acpi_device *device)
         if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set)
                 device->power.states[ACPI_STATE_D3_COLD].flags.explicit_set = 1;
 
+        /* Presence of _PS3 or _PRx means we can put the device into D3 cold */
+        if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set ||
+                        device->power.flags.power_resources)
+                device->power.states[ACPI_STATE_D3_COLD].flags.os_accessible = 1;
+
         acpi_bus_init_power(device);
 
         return 0;
@@ -1013,11 +1134,6 @@ static int acpi_bus_get_flags(struct acpi_device *device)
                         device->flags.ejectable = 1;
         }
 
-        /* Presence of _LCK indicates 'lockable' */
-        status = acpi_get_handle(device->handle, "_LCK", &temp);
-        if (ACPI_SUCCESS(status))
-                device->flags.lockable = 1;
-
         /* Power resources cannot be power manageable. */
         if (device->device_type == ACPI_BUS_TYPE_POWER)
                 return 0;
@@ -1185,7 +1301,7 @@ static void acpi_device_set_id(struct acpi_device *device)
 {
         acpi_status status;
         struct acpi_device_info *info;
-        struct acpica_device_id_list *cid_list;
+        struct acpi_pnp_device_id_list *cid_list;
         int i;
 
         switch (device->device_type) {
@@ -1212,6 +1328,9 @@ static void acpi_device_set_id(struct acpi_device *device)
                         device->pnp.bus_address = info->address;
                         device->flags.bus_address = 1;
                 }
+                if (info->valid & ACPI_VALID_UID)
+                        device->pnp.unique_id = kstrdup(info->unique_id.string,
+                                                        GFP_KERNEL);
 
                 kfree(info);
 
@@ -1483,8 +1602,13 @@ static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl,
          */
         device = NULL;
         acpi_bus_get_device(handle, &device);
-        if (ops->acpi_op_add && !device)
+        if (ops->acpi_op_add && !device) {
                 acpi_add_single_object(&device, handle, type, sta, ops);
+                /* Is the device a known good platform device? */
+                if (device
+                    && !acpi_match_device_ids(device, acpi_platform_device_ids))
+                        acpi_create_platform_device(device);
+        }
 
         if (!device)
                 return AE_CTRL_DEPTH;