Merge branch 'acpi-video' (975bcabb) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/acpi/blacklist.c

+61 −0

Original line number	Diff line number	Diff line
		@@ -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.

drivers/acpi/internal.h

+1 −3

Original line number	Diff line number	Diff line
		@@ -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_ */

drivers/acpi/video.c

+272 −193

Original line number	Diff line number	Diff line
		@@ -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,58 +1860,20 @@ 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:
		acpi_video_bus_put_devices(video);
		kfree(video->attached_array);
		@@ -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;

drivers/acpi/video_detect.c

+10 −2

Original line number	Diff line number	Diff line
		@@ -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

drivers/platform/x86/thinkpad_acpi.c

+24 −7

Original line number	Diff line number	Diff line
		@@ -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,9 +6098,19 @@ 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",
		@@ -6101,8 +6119,7 @@ static int __init tpacpi_query_bcl_levels(acpi_handle handle)
		} 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);