Merge branch 'acpi-video'

* acpi-video:
  ACPI: Add Toshiba NB100 to Vista _OSI blacklist
  ACPI / video: Ignore BIOS initial backlight value for HP 250 G1
  ACPI / video: Add Lenovo IdeaPad Yoga 13 to acpi video detect blacklist
  thinkpad-acpi: fix handle locate for video and query of _BCL
  ACPI / video: Do not register backlight if win8 and native interface exists
  ACPI / video: seperate backlight control and event interface
  backlight: introduce backlight_device_registered
  ACPI: add missing win8 OSI comment to blacklist
  ACPI: update win8 OSI blacklist

7 files changed, 403 insertions, 205 deletions

diff --git a/drivers/acpi/blacklist.c b/drivers/acpi/blacklist.c
index 9515f18898b2..b7fd1aeb6c42 100644
--- a/drivers/acpi/blacklist.c
+++ b/drivers/acpi/blacklist.c
@@ -274,6 +274,19 @@ static struct dmi_system_id acpi_osi_dmi_table[] __initdata = {
                 },
         },
         {
+        .callback = dmi_disable_osi_vista,
+        .ident = "Toshiba NB100",
+        .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
+                     DMI_MATCH(DMI_PRODUCT_NAME, "NB100"),
+                },
+        },
+
+        /*
+         * The following machines have broken backlight support when reporting
+         * the Windows 2012 OSI, so disable it until their support is fixed.
+         */
+        {
         .callback = dmi_disable_osi_win8,
         .ident = "ASUS Zenbook Prime UX31A",
         .matches = {
@@ -297,6 +310,54 @@ static struct dmi_system_id acpi_osi_dmi_table[] __initdata = {
                      DMI_MATCH(DMI_PRODUCT_VERSION, "3259A2G"),
                 },
         },
+        {
+        .callback = dmi_disable_osi_win8,
+        .ident = "ThinkPad Edge E530",
+        .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
+                     DMI_MATCH(DMI_PRODUCT_VERSION, "3259CTO"),
+                },
+        },
+        {
+        .callback = dmi_disable_osi_win8,
+        .ident = "ThinkPad Edge E530",
+        .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
+                     DMI_MATCH(DMI_PRODUCT_VERSION, "3259HJG"),
+                },
+        },
+        {
+        .callback = dmi_disable_osi_win8,
+        .ident = "Acer Aspire V5-573G",
+        .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "Acer Aspire"),
+                     DMI_MATCH(DMI_PRODUCT_VERSION, "V5-573G/Dazzle_HW"),
+                },
+        },
+        {
+        .callback = dmi_disable_osi_win8,
+        .ident = "Acer Aspire V5-572G",
+        .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "Acer Aspire"),
+                     DMI_MATCH(DMI_PRODUCT_VERSION, "V5-572G/Dazzle_CX"),
+                },
+        },
+        {
+        .callback = dmi_disable_osi_win8,
+        .ident = "ThinkPad T431s",
+        .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
+                     DMI_MATCH(DMI_PRODUCT_VERSION, "20AACTO1WW"),
+                },
+        },
+        {
+        .callback = dmi_disable_osi_win8,
+        .ident = "ThinkPad T430",
+        .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
+                     DMI_MATCH(DMI_PRODUCT_VERSION, "2349D15"),
+                },
+        },
 
         /*
          * BIOS invocation of _OSI(Linux) is almost always a BIOS bug.
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index 20f423337e1f..e9304dc7ebfa 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -169,9 +169,7 @@ int acpi_create_platform_device(struct acpi_device *adev,
                                         Video
   -------------------------------------------------------------------------- */
 #if defined(CONFIG_ACPI_VIDEO) || defined(CONFIG_ACPI_VIDEO_MODULE)
-bool acpi_video_backlight_quirks(void);
-#else
-static inline bool acpi_video_backlight_quirks(void) { return false; }
+bool acpi_osi_is_win8(void);
 #endif
 
 #endif /* _ACPI_INTERNAL_H_ */
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index aebcf6355df4..38c3a28d6392 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -88,7 +88,16 @@ module_param(allow_duplicates, bool, 0644);
 static bool use_bios_initial_backlight = 1;
 module_param(use_bios_initial_backlight, bool, 0644);
 
+/*
+ * For Windows 8 systems: if set ture and the GPU driver has
+ * registered a backlight interface, skip registering ACPI video's.
+ */
+static bool use_native_backlight = false;
+module_param(use_native_backlight, bool, 0644);
+
 static int register_count;
+static struct mutex video_list_lock;
+static struct list_head video_bus_head;
 static int acpi_video_bus_add(struct acpi_device *device);
 static int acpi_video_bus_remove(struct acpi_device *device);
 static void acpi_video_bus_notify(struct acpi_device *device, u32 event);
@@ -157,6 +166,7 @@ struct acpi_video_bus {
         struct acpi_video_bus_flags flags;
         struct list_head video_device_list;
         struct mutex device_list_lock;  /* protects video_device_list */
+        struct list_head entry;
         struct input_dev *input;
         char phys[32];  /* for input device */
         struct notifier_block pm_nb;
@@ -229,6 +239,14 @@ static int acpi_video_get_next_level(struct acpi_video_device *device,
 static int acpi_video_switch_brightness(struct acpi_video_device *device,
                                          int event);
 
+static bool acpi_video_verify_backlight_support(void)
+{
+        if (acpi_osi_is_win8() && use_native_backlight &&
+            backlight_device_registered(BACKLIGHT_RAW))
+                return false;
+        return acpi_video_backlight_support();
+}
+
 /* backlight device sysfs support */
 static int acpi_video_get_brightness(struct backlight_device *bd)
 {
@@ -486,6 +504,14 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
                 DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion m4 Notebook PC"),
                 },
         },
+        {
+         .callback = video_ignore_initial_backlight,
+         .ident = "HP 250 G1",
+         .matches = {
+                DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
+                DMI_MATCH(DMI_PRODUCT_NAME, "HP 250 G1 Notebook PC"),
+                },
+        },
         {}
 };
 
@@ -884,79 +910,6 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
 
         if (acpi_has_method(device->dev->handle, "_DDC"))
                 device->cap._DDC = 1;
-
-        if (acpi_video_backlight_support()) {
-                struct backlight_properties props;
-                struct pci_dev *pdev;
-                acpi_handle acpi_parent;
-                struct device *parent = NULL;
-                int result;
-                static int count;
-                char *name;
-
-                result = acpi_video_init_brightness(device);
-                if (result)
-                        return;
-                name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
-                if (!name)
-                        return;
-                count++;
-
-                acpi_get_parent(device->dev->handle, &acpi_parent);
-
-                pdev = acpi_get_pci_dev(acpi_parent);
-                if (pdev) {
-                        parent = &pdev->dev;
-                        pci_dev_put(pdev);
-                }
-
-                memset(&props, 0, sizeof(struct backlight_properties));
-                props.type = BACKLIGHT_FIRMWARE;
-                props.max_brightness = device->brightness->count - 3;
-                device->backlight = backlight_device_register(name,
-                                                              parent,
-                                                              device,
-                                                              &acpi_backlight_ops,
-                                                              &props);
-                kfree(name);
-                if (IS_ERR(device->backlight))
-                        return;
-
-                /*
-                 * Save current brightness level in case we have to restore it
-                 * before acpi_video_device_lcd_set_level() is called next time.
-                 */
-                device->backlight->props.brightness =
-                                acpi_video_get_brightness(device->backlight);
-
-                device->cooling_dev = thermal_cooling_device_register("LCD",
-                                        device->dev, &video_cooling_ops);
-                if (IS_ERR(device->cooling_dev)) {
-                        /*
-                         * Set cooling_dev to NULL so we don't crash trying to
-                         * free it.
-                         * Also, why the hell we are returning early and
-                         * not attempt to register video output if cooling
-                         * device registration failed?
-                         * -- dtor
-                         */
-                        device->cooling_dev = NULL;
-                        return;
-                }
-
-                dev_info(&device->dev->dev, "registered as cooling_device%d\n",
-                         device->cooling_dev->id);
-                result = sysfs_create_link(&device->dev->dev.kobj,
-                                &device->cooling_dev->device.kobj,
-                                "thermal_cooling");
-                if (result)
-                        printk(KERN_ERR PREFIX "Create sysfs link\n");
-                result = sysfs_create_link(&device->cooling_dev->device.kobj,
-                                &device->dev->dev.kobj, "device");
-                if (result)
-                        printk(KERN_ERR PREFIX "Create sysfs link\n");
-
-        }
 }
 
 /*
@@ -1143,13 +1096,6 @@ acpi_video_bus_get_one_device(struct acpi_device *device,
         acpi_video_device_bind(video, data);
         acpi_video_device_find_cap(data);
 
-        status = acpi_install_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
-                                             acpi_video_device_notify, data);
-        if (ACPI_FAILURE(status))
-                dev_err(&device->dev, "Error installing notify handler\n");
-        else
-                data->flags.notify = 1;
-
         mutex_lock(&video->device_list_lock);
         list_add_tail(&data->entry, &video->video_device_list);
         mutex_unlock(&video->device_list_lock);
@@ -1333,8 +1279,8 @@ acpi_video_switch_brightness(struct acpi_video_device *device, int event)
         unsigned long long level_current, level_next;
         int result = -EINVAL;
 
-        /* no warning message if acpi_backlight=vendor is used */
-        if (!acpi_video_backlight_support())
+        /* no warning message if acpi_backlight=vendor or a quirk is used */
+        if (!acpi_video_verify_backlight_support())
                 return 0;
 
         if (!device->brightness)
@@ -1454,64 +1400,6 @@ acpi_video_bus_get_devices(struct acpi_video_bus *video,
         return status;
 }
 
-static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
-{
-        acpi_status status;
-
-        if (!device || !device->video)
-                return -ENOENT;
-
-        if (device->flags.notify) {
-                status = acpi_remove_notify_handler(device->dev->handle,
-                                ACPI_DEVICE_NOTIFY, acpi_video_device_notify);
-                if (ACPI_FAILURE(status))
-                        dev_err(&device->dev->dev,
-                                        "Can't remove video notify handler\n");
-        }
-
-        if (device->backlight) {
-                backlight_device_unregister(device->backlight);
-                device->backlight = NULL;
-        }
-        if (device->cooling_dev) {
-                sysfs_remove_link(&device->dev->dev.kobj,
-                                  "thermal_cooling");
-                sysfs_remove_link(&device->cooling_dev->device.kobj,
-                                  "device");
-                thermal_cooling_device_unregister(device->cooling_dev);
-                device->cooling_dev = NULL;
-        }
-
-        return 0;
-}
-
-static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
-{
-        int status;
-        struct acpi_video_device *dev, *next;
-
-        mutex_lock(&video->device_list_lock);
-
-        list_for_each_entry_safe(dev, next, &video->video_device_list, entry) {
-
-                status = acpi_video_bus_put_one_device(dev);
-                if (ACPI_FAILURE(status))
-                        printk(KERN_WARNING PREFIX
-                               "hhuuhhuu bug in acpi video driver.\n");
-
-                if (dev->brightness) {
-                        kfree(dev->brightness->levels);
-                        kfree(dev->brightness);
-                }
-                list_del(&dev->entry);
-                kfree(dev);
-        }
-
-        mutex_unlock(&video->device_list_lock);
-
-        return 0;
-}
-
 /* acpi_video interface */
 
 /*
@@ -1521,13 +1409,13 @@ static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
 static int acpi_video_bus_start_devices(struct acpi_video_bus *video)
 {
         return acpi_video_bus_DOS(video, 0,
-                                  acpi_video_backlight_quirks() ? 1 : 0);
+                                  acpi_osi_is_win8() ? 1 : 0);
 }
 
 static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
 {
         return acpi_video_bus_DOS(video, 0,
-                                  acpi_video_backlight_quirks() ? 0 : 1);
+                                  acpi_osi_is_win8() ? 0 : 1);
 }
 
 static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
@@ -1536,7 +1424,7 @@ static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
         struct input_dev *input;
         int keycode = 0;
 
-        if (!video)
+        if (!video || !video->input)
                 return;
 
         input = video->input;
@@ -1691,12 +1579,236 @@ acpi_video_bus_match(acpi_handle handle, u32 level, void *context,
         return AE_OK;
 }
 
+static void acpi_video_dev_register_backlight(struct acpi_video_device *device)
+{
+        if (acpi_video_verify_backlight_support()) {
+                struct backlight_properties props;
+                struct pci_dev *pdev;
+                acpi_handle acpi_parent;
+                struct device *parent = NULL;
+                int result;
+                static int count;
+                char *name;
+
+                result = acpi_video_init_brightness(device);
+                if (result)
+                        return;
+                name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
+                if (!name)
+                        return;
+                count++;
+
+                acpi_get_parent(device->dev->handle, &acpi_parent);
+
+                pdev = acpi_get_pci_dev(acpi_parent);
+                if (pdev) {
+                        parent = &pdev->dev;
+                        pci_dev_put(pdev);
+                }
+
+                memset(&props, 0, sizeof(struct backlight_properties));
+                props.type = BACKLIGHT_FIRMWARE;
+                props.max_brightness = device->brightness->count - 3;
+                device->backlight = backlight_device_register(name,
+                                                              parent,
+                                                              device,
+                                                              &acpi_backlight_ops,
+                                                              &props);
+                kfree(name);
+                if (IS_ERR(device->backlight))
+                        return;
+
+                /*
+                 * Save current brightness level in case we have to restore it
+                 * before acpi_video_device_lcd_set_level() is called next time.
+                 */
+                device->backlight->props.brightness =
+                                acpi_video_get_brightness(device->backlight);
+
+                device->cooling_dev = thermal_cooling_device_register("LCD",
+                                        device->dev, &video_cooling_ops);
+                if (IS_ERR(device->cooling_dev)) {
+                        /*
+                         * Set cooling_dev to NULL so we don't crash trying to
+                         * free it.
+                         * Also, why the hell we are returning early and
+                         * not attempt to register video output if cooling
+                         * device registration failed?
+                         * -- dtor
+                         */
+                        device->cooling_dev = NULL;
+                        return;
+                }
+
+                dev_info(&device->dev->dev, "registered as cooling_device%d\n",
+                         device->cooling_dev->id);
+                result = sysfs_create_link(&device->dev->dev.kobj,
+                                &device->cooling_dev->device.kobj,
+                                "thermal_cooling");
+                if (result)
+                        printk(KERN_ERR PREFIX "Create sysfs link\n");
+                result = sysfs_create_link(&device->cooling_dev->device.kobj,
+                                &device->dev->dev.kobj, "device");
+                if (result)
+                        printk(KERN_ERR PREFIX "Create sysfs link\n");
+        }
+}
+
+static int acpi_video_bus_register_backlight(struct acpi_video_bus *video)
+{
+        struct acpi_video_device *dev;
+
+        mutex_lock(&video->device_list_lock);
+        list_for_each_entry(dev, &video->video_device_list, entry)
+                acpi_video_dev_register_backlight(dev);
+        mutex_unlock(&video->device_list_lock);
+
+        video->pm_nb.notifier_call = acpi_video_resume;
+        video->pm_nb.priority = 0;
+        return register_pm_notifier(&video->pm_nb);
+}
+
+static void acpi_video_dev_unregister_backlight(struct acpi_video_device *device)
+{
+        if (device->backlight) {
+                backlight_device_unregister(device->backlight);
+                device->backlight = NULL;
+        }
+        if (device->brightness) {
+                kfree(device->brightness->levels);
+                kfree(device->brightness);
+                device->brightness = NULL;
+        }
+        if (device->cooling_dev) {
+                sysfs_remove_link(&device->dev->dev.kobj, "thermal_cooling");
+                sysfs_remove_link(&device->cooling_dev->device.kobj, "device");
+                thermal_cooling_device_unregister(device->cooling_dev);
+                device->cooling_dev = NULL;
+        }
+}
+
+static int acpi_video_bus_unregister_backlight(struct acpi_video_bus *video)
+{
+        struct acpi_video_device *dev;
+        int error = unregister_pm_notifier(&video->pm_nb);
+
+        mutex_lock(&video->device_list_lock);
+        list_for_each_entry(dev, &video->video_device_list, entry)
+                acpi_video_dev_unregister_backlight(dev);
+        mutex_unlock(&video->device_list_lock);
+
+        return error;
+}
+
+static void acpi_video_dev_add_notify_handler(struct acpi_video_device *device)
+{
+        acpi_status status;
+        struct acpi_device *adev = device->dev;
+
+        status = acpi_install_notify_handler(adev->handle, ACPI_DEVICE_NOTIFY,
+                                             acpi_video_device_notify, device);
+        if (ACPI_FAILURE(status))
+                dev_err(&adev->dev, "Error installing notify handler\n");
+        else
+                device->flags.notify = 1;
+}
+
+static int acpi_video_bus_add_notify_handler(struct acpi_video_bus *video)
+{
+        struct input_dev *input;
+        struct acpi_video_device *dev;
+        int error;
+
+        video->input = input = input_allocate_device();
+        if (!input) {
+                error = -ENOMEM;
+                goto out;
+        }
+
+        error = acpi_video_bus_start_devices(video);
+        if (error)
+                goto err_free_input;
+
+        snprintf(video->phys, sizeof(video->phys),
+                        "%s/video/input0", acpi_device_hid(video->device));
+
+        input->name = acpi_device_name(video->device);
+        input->phys = video->phys;
+        input->id.bustype = BUS_HOST;
+        input->id.product = 0x06;
+        input->dev.parent = &video->device->dev;
+        input->evbit[0] = BIT(EV_KEY);
+        set_bit(KEY_SWITCHVIDEOMODE, input->keybit);
+        set_bit(KEY_VIDEO_NEXT, input->keybit);
+        set_bit(KEY_VIDEO_PREV, input->keybit);
+        set_bit(KEY_BRIGHTNESS_CYCLE, input->keybit);
+        set_bit(KEY_BRIGHTNESSUP, input->keybit);
+        set_bit(KEY_BRIGHTNESSDOWN, input->keybit);
+        set_bit(KEY_BRIGHTNESS_ZERO, input->keybit);
+        set_bit(KEY_DISPLAY_OFF, input->keybit);
+
+        error = input_register_device(input);
+        if (error)
+                goto err_stop_dev;
+
+        mutex_lock(&video->device_list_lock);
+        list_for_each_entry(dev, &video->video_device_list, entry)
+                acpi_video_dev_add_notify_handler(dev);
+        mutex_unlock(&video->device_list_lock);
+
+        return 0;
+
+err_stop_dev:
+        acpi_video_bus_stop_devices(video);
+err_free_input:
+        input_free_device(input);
+        video->input = NULL;
+out:
+        return error;
+}
+
+static void acpi_video_dev_remove_notify_handler(struct acpi_video_device *dev)
+{
+        if (dev->flags.notify) {
+                acpi_remove_notify_handler(dev->dev->handle, ACPI_DEVICE_NOTIFY,
+                                           acpi_video_device_notify);
+                dev->flags.notify = 0;
+        }
+}
+
+static void acpi_video_bus_remove_notify_handler(struct acpi_video_bus *video)
+{
+        struct acpi_video_device *dev;
+
+        mutex_lock(&video->device_list_lock);
+        list_for_each_entry(dev, &video->video_device_list, entry)
+                acpi_video_dev_remove_notify_handler(dev);
+        mutex_unlock(&video->device_list_lock);
+
+        acpi_video_bus_stop_devices(video);
+        input_unregister_device(video->input);
+        video->input = NULL;
+}
+
+static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
+{
+        struct acpi_video_device *dev, *next;
+
+        mutex_lock(&video->device_list_lock);
+        list_for_each_entry_safe(dev, next, &video->video_device_list, entry) {
+                list_del(&dev->entry);
+                kfree(dev);
+        }
+        mutex_unlock(&video->device_list_lock);
+
+        return 0;
+}
+
 static int instance;
 
 static int acpi_video_bus_add(struct acpi_device *device)
 {
         struct acpi_video_bus *video;
-        struct input_dev *input;
         int error;
         acpi_status status;
 
@@ -1748,62 +1860,24 @@ static int acpi_video_bus_add(struct acpi_device *device)
         if (error)
                 goto err_put_video;
 
-        video->input = input = input_allocate_device();
-        if (!input) {
-                error = -ENOMEM;
-                goto err_put_video;
-        }
-
-        error = acpi_video_bus_start_devices(video);
-        if (error)
-                goto err_free_input_dev;
-
-        snprintf(video->phys, sizeof(video->phys),
-                "%s/video/input0", acpi_device_hid(video->device));
-
-        input->name = acpi_device_name(video->device);
-        input->phys = video->phys;
-        input->id.bustype = BUS_HOST;
-        input->id.product = 0x06;
-        input->dev.parent = &device->dev;
-        input->evbit[0] = BIT(EV_KEY);
-        set_bit(KEY_SWITCHVIDEOMODE, input->keybit);
-        set_bit(KEY_VIDEO_NEXT, input->keybit);
-        set_bit(KEY_VIDEO_PREV, input->keybit);
-        set_bit(KEY_BRIGHTNESS_CYCLE, input->keybit);
-        set_bit(KEY_BRIGHTNESSUP, input->keybit);
-        set_bit(KEY_BRIGHTNESSDOWN, input->keybit);
-        set_bit(KEY_BRIGHTNESS_ZERO, input->keybit);
-        set_bit(KEY_DISPLAY_OFF, input->keybit);
-
         printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s  rom: %s  post: %s)\n",
                ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
                video->flags.multihead ? "yes" : "no",
                video->flags.rom ? "yes" : "no",
                video->flags.post ? "yes" : "no");
+        mutex_lock(&video_list_lock);
+        list_add_tail(&video->entry, &video_bus_head);
+        mutex_unlock(&video_list_lock);
 
-        video->pm_nb.notifier_call = acpi_video_resume;
-        video->pm_nb.priority = 0;
-        error = register_pm_notifier(&video->pm_nb);
-        if (error)
-                goto err_stop_video;
-
-        error = input_register_device(input);
-        if (error)
-                goto err_unregister_pm_notifier;
+        acpi_video_bus_register_backlight(video);
+        acpi_video_bus_add_notify_handler(video);
 
         return 0;
 
- err_unregister_pm_notifier:
-        unregister_pm_notifier(&video->pm_nb);
- err_stop_video:
-        acpi_video_bus_stop_devices(video);
- err_free_input_dev:
-        input_free_device(input);
- err_put_video:
+err_put_video:
         acpi_video_bus_put_devices(video);
         kfree(video->attached_array);
- err_free_video:
+err_free_video:
         kfree(video);
         device->driver_data = NULL;
 
@@ -1820,12 +1894,14 @@ static int acpi_video_bus_remove(struct acpi_device *device)
 
         video = acpi_driver_data(device);
 
-        unregister_pm_notifier(&video->pm_nb);
-
-        acpi_video_bus_stop_devices(video);
+        acpi_video_bus_remove_notify_handler(video);
+        acpi_video_bus_unregister_backlight(video);
         acpi_video_bus_put_devices(video);
 
-        input_unregister_device(video->input);
+        mutex_lock(&video_list_lock);
+        list_del(&video->entry);
+        mutex_unlock(&video_list_lock);
+
         kfree(video->attached_array);
         kfree(video);
 
@@ -1874,6 +1950,9 @@ int acpi_video_register(void)
                 return 0;
         }
 
+        mutex_init(&video_list_lock);
+        INIT_LIST_HEAD(&video_bus_head);
+
         result = acpi_bus_register_driver(&acpi_video_bus);
         if (result < 0)
                 return -ENODEV;
diff --git a/drivers/acpi/video_detect.c b/drivers/acpi/video_detect.c
index 940edbf2fe8f..84875fd4c74f 100644
--- a/drivers/acpi/video_detect.c
+++ b/drivers/acpi/video_detect.c
@@ -168,6 +168,14 @@ static struct dmi_system_id video_detect_dmi_table[] = {
                 DMI_MATCH(DMI_PRODUCT_NAME, "UL30A"),
                 },
         },
+        {
+        .callback = video_detect_force_vendor,
+        .ident = "Lenovo Yoga 13",
+        .matches = {
+                DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
+                DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo IdeaPad Yoga 13"),
+                },
+        },
         { },
 };
 
@@ -233,11 +241,11 @@ static void acpi_video_caps_check(void)
                 acpi_video_get_capabilities(NULL);
 }
 
-bool acpi_video_backlight_quirks(void)
+bool acpi_osi_is_win8(void)
 {
         return acpi_gbl_osi_data >= ACPI_OSI_WIN_8;
 }
-EXPORT_SYMBOL(acpi_video_backlight_quirks);
+EXPORT_SYMBOL(acpi_osi_is_win8);
 
 /* Promote the vendor interface instead of the generic video module.
  * This function allow DMI blacklists to be implemented by externals
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index 03ca6c139f1a..170f2788ee67 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -700,6 +700,14 @@ static void __init drv_acpi_handle_init(const char *name,
 static acpi_status __init tpacpi_acpi_handle_locate_callback(acpi_handle handle,
                         u32 level, void *context, void **return_value)
 {
+        struct acpi_device *dev;
+        if (!strcmp(context, "video")) {
+                if (acpi_bus_get_device(handle, &dev))
+                        return AE_OK;
+                if (strcmp(ACPI_VIDEO_HID, acpi_device_hid(dev)))
+                        return AE_OK;
+        }
+
         *(acpi_handle *)return_value = handle;
 
         return AE_CTRL_TERMINATE;
@@ -712,10 +720,10 @@ static void __init tpacpi_acpi_handle_locate(const char *name,
         acpi_status status;
         acpi_handle device_found;
 
-        BUG_ON(!name || !hid || !handle);
+        BUG_ON(!name || !handle);
         vdbg_printk(TPACPI_DBG_INIT,
                         "trying to locate ACPI handle for %s, using HID %s\n",
-                        name, hid);
+                        name, hid ? hid : "NULL");
 
         memset(&device_found, 0, sizeof(device_found));
         status = acpi_get_devices(hid, tpacpi_acpi_handle_locate_callback,
@@ -6090,19 +6098,28 @@ static int __init tpacpi_query_bcl_levels(acpi_handle handle)
 {
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *obj;
+        struct acpi_device *device, *child;
         int rc;
 
-        if (ACPI_SUCCESS(acpi_evaluate_object(handle, "_BCL", NULL, &buffer))) {
+        if (acpi_bus_get_device(handle, &device))
+                return 0;
+
+        rc = 0;
+        list_for_each_entry(child, &device->children, node) {
+                acpi_status status = acpi_evaluate_object(child->handle, "_BCL",
+                                                          NULL, &buffer);
+                if (ACPI_FAILURE(status))
+                        continue;
+
                 obj = (union acpi_object *)buffer.pointer;
                 if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
                         pr_err("Unknown _BCL data, please report this to %s\n",
-                               TPACPI_MAIL);
+                                TPACPI_MAIL);
                         rc = 0;
                 } else {
                         rc = obj->package.count;
                 }
-        } else {
-                return 0;
+                break;
         }
 
         kfree(buffer.pointer);
@@ -6118,7 +6135,7 @@ static unsigned int __init tpacpi_check_std_acpi_brightness_support(void)
         acpi_handle video_device;
         int bcl_levels = 0;
 
-        tpacpi_acpi_handle_locate("video", ACPI_VIDEO_HID, &video_device);
+        tpacpi_acpi_handle_locate("video", NULL, &video_device);
         if (video_device)
                 bcl_levels = tpacpi_query_bcl_levels(video_device);
 
diff --git a/drivers/video/backlight/backlight.c b/drivers/video/backlight/backlight.c
index 94a403a9717a..5d05555fe841 100644
--- a/drivers/video/backlight/backlight.c
+++ b/drivers/video/backlight/backlight.c
@@ -21,6 +21,9 @@
 #include <asm/backlight.h>
 #endif
 
+static struct list_head backlight_dev_list;
+static struct mutex backlight_dev_list_mutex;
+
 static const char *const backlight_types[] = {
         [BACKLIGHT_RAW] = "raw",
         [BACKLIGHT_PLATFORM] = "platform",
@@ -349,10 +352,32 @@ struct backlight_device *backlight_device_register(const char *name,
         mutex_unlock(&pmac_backlight_mutex);
 #endif
 
+        mutex_lock(&backlight_dev_list_mutex);
+        list_add(&new_bd->entry, &backlight_dev_list);
+        mutex_unlock(&backlight_dev_list_mutex);
+
         return new_bd;
 }
 EXPORT_SYMBOL(backlight_device_register);
 
+bool backlight_device_registered(enum backlight_type type)
+{
+        bool found = false;
+        struct backlight_device *bd;
+
+        mutex_lock(&backlight_dev_list_mutex);
+        list_for_each_entry(bd, &backlight_dev_list, entry) {
+                if (bd->props.type == type) {
+                        found = true;
+                        break;
+                }
+        }
+        mutex_unlock(&backlight_dev_list_mutex);
+
+        return found;
+}
+EXPORT_SYMBOL(backlight_device_registered);
+
 /**
  * backlight_device_unregister - unregisters a backlight device object.
  * @bd: the backlight device object to be unregistered and freed.
@@ -364,6 +389,10 @@ void backlight_device_unregister(struct backlight_device *bd)
         if (!bd)
                 return;
 
+        mutex_lock(&backlight_dev_list_mutex);
+        list_del(&bd->entry);
+        mutex_unlock(&backlight_dev_list_mutex);
+
 #ifdef CONFIG_PMAC_BACKLIGHT
         mutex_lock(&pmac_backlight_mutex);
         if (pmac_backlight == bd)
@@ -499,6 +528,8 @@ static int __init backlight_class_init(void)
 
         backlight_class->dev_groups = bl_device_groups;
         backlight_class->pm = &backlight_class_dev_pm_ops;
+        INIT_LIST_HEAD(&backlight_dev_list);
+        mutex_init(&backlight_dev_list_mutex);
         return 0;
 }
 
diff --git a/include/linux/backlight.h b/include/linux/backlight.h
index 53b77949c79d..5f9cd963213d 100644
--- a/include/linux/backlight.h
+++ b/include/linux/backlight.h
@@ -100,6 +100,9 @@ struct backlight_device {
         /* The framebuffer notifier block */
         struct notifier_block fb_notif;
 
+        /* list entry of all registered backlight devices */
+        struct list_head entry;
+
         struct device dev;
 };
 
@@ -123,6 +126,7 @@ extern void devm_backlight_device_unregister(struct device *dev,
                                         struct backlight_device *bd);
 extern void backlight_force_update(struct backlight_device *bd,
                                    enum backlight_update_reason reason);
+extern bool backlight_device_registered(enum backlight_type type);
 
 #define to_backlight_device(obj) container_of(obj, struct backlight_device, dev)