Merge branch 'acpi-video'

* acpi-video:
  ACPI / video: Add 4 new models to the use_native_backlight DMI list
  ACPI / video: Add use native backlight quirk for the ThinkPad W530
  ACPI / video: Unregister the backlight device if a raw one shows up later
  backlight: Add backlight device (un)registration notification
  nouveau: Don't check acpi_video_backlight_support() before registering backlight
  acer-wmi: Add Aspire 5741 to video_vendor_dmi_table
  acer-wmi: Switch to acpi_video_unregister_backlight
  ACPI / video: Add an acpi_video_unregister_backlight function
  ACPI / video: Don't register acpi_video_resume notifier without backlight devices
  ACPI / video: change acpi-video brightness_switch_enabled default to 0

7 files changed, 245 insertions, 77 deletions

diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index c6e72ee53903..0933ec4924d3 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -3481,7 +3481,7 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
                         the allocated input device; If set to 0, video driver
                         will only send out the event without touching backlight
                         brightness level.
-                        default: 1
+                        default: 0
 
         virtio_mmio.device=
                         [VMMIO] Memory mapped virtio (platform) device.
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index f8bc5a755dda..101fb090dcb9 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -68,7 +68,7 @@ MODULE_AUTHOR("Bruno Ducrot");
 MODULE_DESCRIPTION("ACPI Video Driver");
 MODULE_LICENSE("GPL");
 
-static bool brightness_switch_enabled = 1;
+static bool brightness_switch_enabled;
 module_param(brightness_switch_enabled, bool, 0644);
 
 /*
@@ -150,6 +150,8 @@ struct acpi_video_enumerated_device {
 
 struct acpi_video_bus {
         struct acpi_device *device;
+        bool backlight_registered;
+        bool backlight_notifier_registered;
         u8 dos_setting;
         struct acpi_video_enumerated_device *attached_array;
         u8 attached_count;
@@ -161,6 +163,7 @@ struct acpi_video_bus {
         struct input_dev *input;
         char phys[32];  /* for input device */
         struct notifier_block pm_nb;
+        struct notifier_block backlight_nb;
 };
 
 struct acpi_video_device_flags {
@@ -473,6 +476,14 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
         },
         {
          .callback = video_set_use_native_backlight,
+         .ident = "ThinkPad W530",
+         .matches = {
+                DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
+                DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad W530"),
+                },
+        },
+        {
+         .callback = video_set_use_native_backlight,
         .ident = "ThinkPad X1 Carbon",
         .matches = {
                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
@@ -488,6 +499,14 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
                 },
         },
         {
+         .callback = video_set_use_native_backlight,
+         .ident = "Lenovo Yoga 2 11",
+         .matches = {
+                DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
+                DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Yoga 2 11"),
+                },
+        },
+        {
         .callback = video_set_use_native_backlight,
         .ident = "Thinkpad Helix",
         .matches = {
@@ -521,6 +540,14 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
         },
         {
          .callback = video_set_use_native_backlight,
+         .ident = "Acer Aspire V5-171",
+         .matches = {
+                DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+                DMI_MATCH(DMI_PRODUCT_NAME, "V5-171"),
+                },
+        },
+        {
+         .callback = video_set_use_native_backlight,
          .ident = "Acer Aspire V5-431",
          .matches = {
                 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
@@ -528,6 +555,14 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
                 },
         },
         {
+         .callback = video_set_use_native_backlight,
+         .ident = "Acer Aspire V5-471G",
+         .matches = {
+                DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
+                DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-471G"),
+                },
+        },
+        {
         .callback = video_set_use_native_backlight,
         .ident = "HP ProBook 4340s",
         .matches = {
@@ -579,6 +614,14 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
         },
         {
         .callback = video_set_use_native_backlight,
+        .ident = "HP EliteBook 8470p",
+        .matches = {
+                DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
+                DMI_MATCH(DMI_PRODUCT_NAME, "HP EliteBook 8470p"),
+                },
+        },
+        {
+        .callback = video_set_use_native_backlight,
         .ident = "HP EliteBook 8780w",
         .matches = {
                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
@@ -1658,88 +1701,92 @@ acpi_video_bus_match(acpi_handle handle, u32 level, void *context,
 
 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++;
+        struct backlight_properties props;
+        struct pci_dev *pdev;
+        acpi_handle acpi_parent;
+        struct device *parent = NULL;
+        int result;
+        static int count;
+        char *name;
 
-                acpi_get_parent(device->dev->handle, &acpi_parent);
+        result = acpi_video_init_brightness(device);
+        if (result)
+                return;
+        name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
+        if (!name)
+                return;
+        count++;
 
-                pdev = acpi_get_pci_dev(acpi_parent);
-                if (pdev) {
-                        parent = &pdev->dev;
-                        pci_dev_put(pdev);
-                }
+        acpi_get_parent(device->dev->handle, &acpi_parent);
 
-                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;
+        pdev = acpi_get_pci_dev(acpi_parent);
+        if (pdev) {
+                parent = &pdev->dev;
+                pci_dev_put(pdev);
+        }
 
-                /*
-                 * 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);
+        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;
 
-                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;
-                }
+        /*
+         * 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);
 
-                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");
+        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;
 
+        if (video->backlight_registered)
+                return 0;
+
+        if (!acpi_video_verify_backlight_support())
+                return 0;
+
         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->backlight_registered = true;
+
         video->pm_nb.notifier_call = acpi_video_resume;
         video->pm_nb.priority = 0;
         return register_pm_notifier(&video->pm_nb);
@@ -1767,13 +1814,20 @@ static void acpi_video_dev_unregister_backlight(struct acpi_video_device *device
 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);
+        int error;
+
+        if (!video->backlight_registered)
+                return 0;
+
+        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);
 
+        video->backlight_registered = false;
+
         return error;
 }
 
@@ -1867,6 +1921,56 @@ static void acpi_video_bus_remove_notify_handler(struct acpi_video_bus *video)
         video->input = NULL;
 }
 
+static int acpi_video_backlight_notify(struct notifier_block *nb,
+                                        unsigned long val, void *bd)
+{
+        struct backlight_device *backlight = bd;
+        struct acpi_video_bus *video;
+
+        /* acpi_video_verify_backlight_support only cares about raw devices */
+        if (backlight->props.type != BACKLIGHT_RAW)
+                return NOTIFY_DONE;
+
+        video = container_of(nb, struct acpi_video_bus, backlight_nb);
+
+        switch (val) {
+        case BACKLIGHT_REGISTERED:
+                if (!acpi_video_verify_backlight_support())
+                        acpi_video_bus_unregister_backlight(video);
+                break;
+        case BACKLIGHT_UNREGISTERED:
+                acpi_video_bus_register_backlight(video);
+                break;
+        }
+
+        return NOTIFY_OK;
+}
+
+static int acpi_video_bus_add_backlight_notify_handler(
+                                                struct acpi_video_bus *video)
+{
+        int error;
+
+        video->backlight_nb.notifier_call = acpi_video_backlight_notify;
+        video->backlight_nb.priority = 0;
+        error = backlight_register_notifier(&video->backlight_nb);
+        if (error == 0)
+                video->backlight_notifier_registered = true;
+
+        return error;
+}
+
+static int acpi_video_bus_remove_backlight_notify_handler(
+                                                struct acpi_video_bus *video)
+{
+        if (!video->backlight_notifier_registered)
+                return 0;
+
+        video->backlight_notifier_registered = false;
+
+        return backlight_unregister_notifier(&video->backlight_nb);
+}
+
 static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
 {
         struct acpi_video_device *dev, *next;
@@ -1948,6 +2052,7 @@ static int acpi_video_bus_add(struct acpi_device *device)
 
         acpi_video_bus_register_backlight(video);
         acpi_video_bus_add_notify_handler(video);
+        acpi_video_bus_add_backlight_notify_handler(video);
 
         return 0;
 
@@ -1971,6 +2076,7 @@ static int acpi_video_bus_remove(struct acpi_device *device)
 
         video = acpi_driver_data(device);
 
+        acpi_video_bus_remove_backlight_notify_handler(video);
         acpi_video_bus_remove_notify_handler(video);
         acpi_video_bus_unregister_backlight(video);
         acpi_video_bus_put_devices(video);
@@ -2061,6 +2167,20 @@ void acpi_video_unregister(void)
 }
 EXPORT_SYMBOL(acpi_video_unregister);
 
+void acpi_video_unregister_backlight(void)
+{
+        struct acpi_video_bus *video;
+
+        if (!register_count)
+                return;
+
+        mutex_lock(&video_list_lock);
+        list_for_each_entry(video, &video_bus_head, entry)
+                acpi_video_bus_unregister_backlight(video);
+        mutex_unlock(&video_list_lock);
+}
+EXPORT_SYMBOL(acpi_video_unregister_backlight);
+
 /*
  * This is kind of nasty. Hardware using Intel chipsets may require
  * the video opregion code to be run first in order to initialise
diff --git a/drivers/gpu/drm/nouveau/nouveau_backlight.c b/drivers/gpu/drm/nouveau/nouveau_backlight.c
index 630f6e84fc01..2c1e4aad7da3 100644
--- a/drivers/gpu/drm/nouveau/nouveau_backlight.c
+++ b/drivers/gpu/drm/nouveau/nouveau_backlight.c
@@ -31,7 +31,6 @@
  */
 
 #include <linux/backlight.h>
-#include <linux/acpi.h>
 
 #include "nouveau_drm.h"
 #include "nouveau_reg.h"
@@ -222,14 +221,6 @@ nouveau_backlight_init(struct drm_device *dev)
         struct nouveau_device *device = nv_device(drm->device);
         struct drm_connector *connector;
 
-#ifdef CONFIG_ACPI
-        if (acpi_video_backlight_support()) {
-                NV_INFO(drm, "ACPI backlight interface available, "
-                             "not registering our own\n");
-                return 0;
-        }
-#endif
-
         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                 if (connector->connector_type != DRM_MODE_CONNECTOR_LVDS &&
                     connector->connector_type != DRM_MODE_CONNECTOR_eDP)
diff --git a/drivers/platform/x86/acer-wmi.c b/drivers/platform/x86/acer-wmi.c
index c91f69b39db4..bbf78b2d6d93 100644
--- a/drivers/platform/x86/acer-wmi.c
+++ b/drivers/platform/x86/acer-wmi.c
@@ -570,6 +570,14 @@ static const struct dmi_system_id video_vendor_dmi_table[] = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5750"),
                 },
         },
+        {
+                .callback = video_set_backlight_video_vendor,
+                .ident = "Acer Aspire 5741",
+                .matches = {
+                        DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5741"),
+                },
+        },
         {}
 };
 
@@ -2228,7 +2236,7 @@ static int __init acer_wmi_init(void)
                 pr_info("Brightness must be controlled by acpi video driver\n");
         } else {
                 pr_info("Disabling ACPI video driver\n");
-                acpi_video_unregister();
+                acpi_video_unregister_backlight();
         }
 
         if (wmi_has_guid(WMID_GUID3)) {
diff --git a/drivers/video/backlight/backlight.c b/drivers/video/backlight/backlight.c
index bd2172c2d650..428089009cd5 100644
--- a/drivers/video/backlight/backlight.c
+++ b/drivers/video/backlight/backlight.c
@@ -23,6 +23,7 @@
 
 static struct list_head backlight_dev_list;
 static struct mutex backlight_dev_list_mutex;
+static struct blocking_notifier_head backlight_notifier;
 
 static const char *const backlight_types[] = {
         [BACKLIGHT_RAW] = "raw",
@@ -370,6 +371,9 @@ struct backlight_device *backlight_device_register(const char *name,
         list_add(&new_bd->entry, &backlight_dev_list);
         mutex_unlock(&backlight_dev_list_mutex);
 
+        blocking_notifier_call_chain(&backlight_notifier,
+                                     BACKLIGHT_REGISTERED, new_bd);
+
         return new_bd;
 }
 EXPORT_SYMBOL(backlight_device_register);
@@ -413,6 +417,10 @@ void backlight_device_unregister(struct backlight_device *bd)
                 pmac_backlight = NULL;
         mutex_unlock(&pmac_backlight_mutex);
 #endif
+
+        blocking_notifier_call_chain(&backlight_notifier,
+                                     BACKLIGHT_UNREGISTERED, bd);
+
         mutex_lock(&bd->ops_lock);
         bd->ops = NULL;
         mutex_unlock(&bd->ops_lock);
@@ -438,6 +446,36 @@ static int devm_backlight_device_match(struct device *dev, void *res,
 }
 
 /**
+ * backlight_register_notifier - get notified of backlight (un)registration
+ * @nb: notifier block with the notifier to call on backlight (un)registration
+ *
+ * @return 0 on success, otherwise a negative error code
+ *
+ * Register a notifier to get notified when backlight devices get registered
+ * or unregistered.
+ */
+int backlight_register_notifier(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_register(&backlight_notifier, nb);
+}
+EXPORT_SYMBOL(backlight_register_notifier);
+
+/**
+ * backlight_unregister_notifier - unregister a backlight notifier
+ * @nb: notifier block to unregister
+ *
+ * @return 0 on success, otherwise a negative error code
+ *
+ * Register a notifier to get notified when backlight devices get registered
+ * or unregistered.
+ */
+int backlight_unregister_notifier(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_unregister(&backlight_notifier, nb);
+}
+EXPORT_SYMBOL(backlight_unregister_notifier);
+
+/**
  * devm_backlight_device_register - resource managed backlight_device_register()
  * @dev: the device to register
  * @name: the name of the device
@@ -544,6 +582,8 @@ static int __init backlight_class_init(void)
         backlight_class->pm = &backlight_class_dev_pm_ops;
         INIT_LIST_HEAD(&backlight_dev_list);
         mutex_init(&backlight_dev_list_mutex);
+        BLOCKING_INIT_NOTIFIER_HEAD(&backlight_notifier);
+
         return 0;
 }
 
diff --git a/include/acpi/video.h b/include/acpi/video.h
index 61109f2609fc..ea4c7bbded4d 100644
--- a/include/acpi/video.h
+++ b/include/acpi/video.h
@@ -19,11 +19,13 @@ struct acpi_device;
 #if (defined CONFIG_ACPI_VIDEO || defined CONFIG_ACPI_VIDEO_MODULE)
 extern int acpi_video_register(void);
 extern void acpi_video_unregister(void);
+extern void acpi_video_unregister_backlight(void);
 extern int acpi_video_get_edid(struct acpi_device *device, int type,
                                int device_id, void **edid);
 #else
 static inline int acpi_video_register(void) { return 0; }
 static inline void acpi_video_unregister(void) { return; }
+static inline void acpi_video_unregister_backlight(void) { return; }
 static inline int acpi_video_get_edid(struct acpi_device *device, int type,
                                       int device_id, void **edid)
 {
diff --git a/include/linux/backlight.h b/include/linux/backlight.h
index 72647429adf6..adb14a8616df 100644
--- a/include/linux/backlight.h
+++ b/include/linux/backlight.h
@@ -40,6 +40,11 @@ enum backlight_type {
         BACKLIGHT_TYPE_MAX,
 };
 
+enum backlight_notification {
+        BACKLIGHT_REGISTERED,
+        BACKLIGHT_UNREGISTERED,
+};
+
 struct backlight_device;
 struct fb_info;
 
@@ -133,6 +138,8 @@ extern void devm_backlight_device_unregister(struct device *dev,
 extern void backlight_force_update(struct backlight_device *bd,
                                    enum backlight_update_reason reason);
 extern bool backlight_device_registered(enum backlight_type type);
+extern int backlight_register_notifier(struct notifier_block *nb);
+extern int backlight_unregister_notifier(struct notifier_block *nb);
 
 #define to_backlight_device(obj) container_of(obj, struct backlight_device, dev)