Merge branches 'release' and 'stats' into release

[linux-2.6-omap-h63xx.git] / drivers / acpi / scan.c

diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index be74347d135435e5c5b4508b8144528bc58a0459..c7b0aa52dd230205f25ae2e3c74f469d6ef7c8d1 100644 (file)
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -35,8 +35,9 @@ struct acpi_device_bus_id{
  * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get:
  * char *modalias: "acpi:IBM0001:ACPI0001"
 */
-int create_modalias(struct acpi_device *acpi_dev, char *modalias, int size){
-
+static int create_modalias(struct acpi_device *acpi_dev, char *modalias,
+                          int size)
+{
        int len;
 
        if (!acpi_dev->flags.hardware_id)
@@ -318,16 +319,18 @@ static int acpi_bus_match(struct device *dev, struct device_driver *drv)
        return !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
 }
 
-static int acpi_device_uevent(struct device *dev, char **envp, int num_envp,
-                             char *buffer, int buffer_size)
+static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
        struct acpi_device *acpi_dev = to_acpi_device(dev);
+       int len;
 
-       strcpy(buffer, "MODALIAS=");
-       if (create_modalias(acpi_dev, buffer + 9, buffer_size - 9) > 0) {
-               envp[0] = buffer;
-               envp[1] = NULL;
-       }
+       if (add_uevent_var(env, "MODALIAS="))
+               return -ENOMEM;
+       len = create_modalias(acpi_dev, &env->buf[env->buflen - 1],
+                             sizeof(env->buf) - env->buflen);
+       if (len >= (sizeof(env->buf) - env->buflen))
+               return -ENOMEM;
+       env->buflen += len;
        return 0;
 }
 
@@ -827,7 +830,7 @@ static int acpi_bus_get_flags(struct acpi_device *device)
        if (ACPI_SUCCESS(status))
                device->flags.wake_capable = 1;
 
-       /* TBD: Peformance management */
+       /* TBD: Performance management */
 
        return 0;
 }
@@ -938,6 +941,15 @@ static int acpi_bay_match(struct acpi_device *device){
        return -ENODEV;
 }
 
+/*
+ * acpi_dock_match - see if a device has a _DCK method
+ */
+static int acpi_dock_match(struct acpi_device *device)
+{
+       acpi_handle tmp;
+       return acpi_get_handle(device->handle, "_DCK", &tmp);
+}
+
 static void acpi_device_set_id(struct acpi_device *device,
                               struct acpi_device *parent, acpi_handle handle,
                               int type)
@@ -947,6 +959,7 @@ static void acpi_device_set_id(struct acpi_device *device,
        char *hid = NULL;
        char *uid = NULL;
        struct acpi_compatible_id_list *cid_list = NULL;
+       const char *cid_add = NULL;
        acpi_status status;
 
        switch (type) {
@@ -969,15 +982,18 @@ static void acpi_device_set_id(struct acpi_device *device,
                        device->flags.bus_address = 1;
                }
 
-               if(!(info->valid & (ACPI_VALID_HID | ACPI_VALID_CID))){
-                       status = acpi_video_bus_match(device);
-                       if(ACPI_SUCCESS(status))
-                               hid = ACPI_VIDEO_HID;
+               /* If we have a video/bay/dock device, add our selfdefined
+                  HID to the CID list. Like that the video/bay/dock drivers
+                  will get autoloaded and the device might still match
+                  against another driver.
+               */
+               if (ACPI_SUCCESS(acpi_video_bus_match(device)))
+                       cid_add = ACPI_VIDEO_HID;
+               else if (ACPI_SUCCESS(acpi_bay_match(device)))
+                       cid_add = ACPI_BAY_HID;
+               else if (ACPI_SUCCESS(acpi_dock_match(device)))
+                       cid_add = ACPI_DOCK_HID;
 
-                       status = acpi_bay_match(device);
-                       if (ACPI_SUCCESS(status))
-                               hid = ACPI_BAY_HID;
-               }
                break;
        case ACPI_BUS_TYPE_POWER:
                hid = ACPI_POWER_HID;
@@ -1018,11 +1034,44 @@ static void acpi_device_set_id(struct acpi_device *device,
                strcpy(device->pnp.unique_id, uid);
                device->flags.unique_id = 1;
        }
-       if (cid_list) {
-               device->pnp.cid_list = kmalloc(cid_list->size, GFP_KERNEL);
-               if (device->pnp.cid_list)
-                       memcpy(device->pnp.cid_list, cid_list, cid_list->size);
-               else
+       if (cid_list || cid_add) {
+               struct  acpi_compatible_id_list *list;
+               int size = 0;
+               int count = 0;
+
+               if (cid_list) {
+                       size = cid_list->size;
+               } else if (cid_add) {
+                       size = sizeof(struct acpi_compatible_id_list);
+                       cid_list = ACPI_ALLOCATE_ZEROED((acpi_size) size);
+                       if (!cid_list) {
+                               printk(KERN_ERR "Memory allocation error\n");
+                               kfree(buffer.pointer);
+                               return;
+                       } else {
+                               cid_list->count = 0;
+                               cid_list->size = size;
+                       }
+               }
+               if (cid_add)
+                       size += sizeof(struct acpi_compatible_id);
+               list = kmalloc(size, GFP_KERNEL);
+
+               if (list) {
+                       if (cid_list) {
+                               memcpy(list, cid_list, cid_list->size);
+                               count = cid_list->count;
+                       }
+                       if (cid_add) {
+                               strncpy(list->id[count].value, cid_add,
+                                       ACPI_MAX_CID_LENGTH);
+                               count++;
+                               device->flags.compatible_ids = 1;
+                       }
+                       list->size = size;
+                       list->count = count;
+                       device->pnp.cid_list = list;
+               } else
                        printk(KERN_ERR "Memory allocation error\n");
        }
 
@@ -1077,6 +1126,20 @@ static int acpi_bus_remove(struct acpi_device *dev, int rmdevice)
        return 0;
 }
 
+static int
+acpi_is_child_device(struct acpi_device *device,
+                       int (*matcher)(struct acpi_device *))
+{
+       int result = -ENODEV;
+
+       do {
+               if (ACPI_SUCCESS(matcher(device)))
+                       return AE_OK;
+       } while ((device = device->parent));
+
+       return result;
+}
+
 static int
 acpi_add_single_object(struct acpi_device **child,
                       struct acpi_device *parent, acpi_handle handle, int type,
@@ -1128,10 +1191,20 @@ acpi_add_single_object(struct acpi_device **child,
        case ACPI_BUS_TYPE_PROCESSOR:
        case ACPI_BUS_TYPE_DEVICE:
                result = acpi_bus_get_status(device);
-               if (ACPI_FAILURE(result) || !device->status.present) {
-                       result = -ENOENT;
+               if (ACPI_FAILURE(result)) {
+                       result = -ENODEV;
                        goto end;
                }
+               if (!device->status.present) {
+                       /* Bay and dock should be handled even if absent */
+                       if (!ACPI_SUCCESS(
+                            acpi_is_child_device(device, acpi_bay_match)) &&
+                           !ACPI_SUCCESS(
+                            acpi_is_child_device(device, acpi_dock_match))) {
+                                       result = -ENODEV;
+                                       goto end;
+                       }
+               }
                break;
        default:
                STRUCT_TO_INT(device->status) =
@@ -1446,6 +1519,8 @@ static int acpi_bus_scan_fixed(struct acpi_device *root)
        return result;
 }
 
+int __init acpi_boot_ec_enable(void);
+
 static int __init acpi_scan_init(void)
 {
        int result;
@@ -1477,6 +1552,10 @@ static int __init acpi_scan_init(void)
         * Enumerate devices in the ACPI namespace.
         */
        result = acpi_bus_scan_fixed(acpi_root);
+
+       /* EC region might be needed at bus_scan, so enable it now */
+       acpi_boot_ec_enable();
+
        if (!result)
                result = acpi_bus_scan(acpi_root, &ops);