2019-05-27 06:55:06 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2013-08-01 23:43:59 +00:00
|
|
|
* video.c - ACPI Video Driver
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
|
|
|
|
* Copyright (C) 2004 Bruno Ducrot <ducrot@poupinou.org>
|
2006-12-19 20:56:14 +00:00
|
|
|
* Copyright (C) 2006 Thomas Tuttle <linux-kernel@ttuttle.net>
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
2021-02-03 18:48:33 +00:00
|
|
|
#define pr_fmt(fmt) "ACPI: video: " fmt
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/list.h>
|
2007-11-05 16:43:32 +00:00
|
|
|
#include <linux/mutex.h>
|
2007-08-20 10:23:53 +00:00
|
|
|
#include <linux/input.h>
|
2006-11-10 18:40:34 +00:00
|
|
|
#include <linux/backlight.h>
|
2008-01-17 07:51:22 +00:00
|
|
|
#include <linux/thermal.h>
|
2008-12-11 21:24:52 +00:00
|
|
|
#include <linux/sort.h>
|
2009-03-19 21:35:39 +00:00
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/pci_ids.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2009-07-07 03:40:19 +00:00
|
|
|
#include <linux/dmi.h>
|
2010-04-04 23:43:51 +00:00
|
|
|
#include <linux/suspend.h>
|
2013-12-03 00:49:16 +00:00
|
|
|
#include <linux/acpi.h>
|
2010-01-12 19:17:03 +00:00
|
|
|
#include <acpi/video.h>
|
2016-12-24 19:46:01 +00:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define ACPI_VIDEO_BUS_NAME "Video Bus"
|
|
|
|
#define ACPI_VIDEO_DEVICE_NAME "Video Device"
|
|
|
|
|
2006-11-10 18:40:34 +00:00
|
|
|
#define MAX_NAME_LEN 20
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-13 03:42:12 +00:00
|
|
|
MODULE_AUTHOR("Bruno Ducrot");
|
2007-02-13 04:50:02 +00:00
|
|
|
MODULE_DESCRIPTION("ACPI Video Driver");
|
2005-04-16 22:20:36 +00:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2018-01-23 15:59:20 +00:00
|
|
|
static bool brightness_switch_enabled = true;
|
2008-01-25 06:47:49 +00:00
|
|
|
module_param(brightness_switch_enabled, bool, 0644);
|
|
|
|
|
2009-12-30 07:59:23 +00:00
|
|
|
/*
|
|
|
|
* By default, we don't allow duplicate ACPI video bus devices
|
|
|
|
* under the same VGA controller
|
|
|
|
*/
|
2012-01-12 23:02:20 +00:00
|
|
|
static bool allow_duplicates;
|
2009-12-30 07:59:23 +00:00
|
|
|
module_param(allow_duplicates, bool, 0644);
|
|
|
|
|
2015-06-09 08:32:25 +00:00
|
|
|
static int disable_backlight_sysfs_if = -1;
|
|
|
|
module_param(disable_backlight_sysfs_if, int, 0444);
|
|
|
|
|
2015-12-22 18:09:51 +00:00
|
|
|
#define REPORT_OUTPUT_KEY_EVENTS 0x01
|
|
|
|
#define REPORT_BRIGHTNESS_KEY_EVENTS 0x02
|
|
|
|
static int report_key_events = -1;
|
|
|
|
module_param(report_key_events, int, 0644);
|
|
|
|
MODULE_PARM_DESC(report_key_events,
|
|
|
|
"0: none, 1: output changes, 2: brightness changes, 3: all");
|
|
|
|
|
2019-07-12 10:00:33 +00:00
|
|
|
static int hw_changes_brightness = -1;
|
|
|
|
module_param(hw_changes_brightness, int, 0644);
|
|
|
|
MODULE_PARM_DESC(hw_changes_brightness,
|
|
|
|
"Set this to 1 on buggy hw which changes the brightness itself when "
|
|
|
|
"a hotkey is pressed: -1: auto, 0: normal 1: hw-changes-brightness");
|
|
|
|
|
2017-04-19 10:36:18 +00:00
|
|
|
/*
|
|
|
|
* Whether the struct acpi_video_device_attrib::device_id_scheme bit should be
|
|
|
|
* assumed even if not actually set.
|
|
|
|
*/
|
2015-10-28 07:09:23 +00:00
|
|
|
static bool device_id_scheme = false;
|
|
|
|
module_param(device_id_scheme, bool, 0444);
|
|
|
|
|
2017-12-23 18:41:47 +00:00
|
|
|
static int only_lcd = -1;
|
|
|
|
module_param(only_lcd, int, 0444);
|
2015-10-28 07:09:23 +00:00
|
|
|
|
2016-01-14 08:41:45 +00:00
|
|
|
static int register_count;
|
|
|
|
static DEFINE_MUTEX(register_count_mutex);
|
2016-01-14 08:41:46 +00:00
|
|
|
static DEFINE_MUTEX(video_list_lock);
|
|
|
|
static LIST_HEAD(video_bus_head);
|
2005-08-05 04:44:28 +00:00
|
|
|
static int acpi_video_bus_add(struct acpi_device *device);
|
2013-01-23 23:24:48 +00:00
|
|
|
static int acpi_video_bus_remove(struct acpi_device *device);
|
2009-04-07 15:37:11 +00:00
|
|
|
static void acpi_video_bus_notify(struct acpi_device *device, u32 event);
|
2015-06-16 14:27:52 +00:00
|
|
|
void acpi_video_detect_exit(void);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-04-19 09:48:07 +00:00
|
|
|
/*
|
|
|
|
* Indices in the _BCL method response: the first two items are special,
|
|
|
|
* the rest are all supported levels.
|
|
|
|
*
|
|
|
|
* See page 575 of the ACPI spec 3.0
|
|
|
|
*/
|
|
|
|
enum acpi_video_level_idx {
|
|
|
|
ACPI_VIDEO_AC_LEVEL, /* level when machine has full power */
|
|
|
|
ACPI_VIDEO_BATTERY_LEVEL, /* level when machine is on batteries */
|
|
|
|
ACPI_VIDEO_FIRST_LEVEL, /* actual supported levels begin here */
|
|
|
|
};
|
|
|
|
|
2007-07-23 12:44:41 +00:00
|
|
|
static const struct acpi_device_id video_device_ids[] = {
|
|
|
|
{ACPI_VIDEO_HID, 0},
|
|
|
|
{"", 0},
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(acpi, video_device_ids);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static struct acpi_driver acpi_video_bus = {
|
2007-02-13 04:33:40 +00:00
|
|
|
.name = "video",
|
2005-04-16 22:20:36 +00:00
|
|
|
.class = ACPI_VIDEO_CLASS,
|
2007-07-23 12:44:41 +00:00
|
|
|
.ids = video_device_ids,
|
2005-04-16 22:20:36 +00:00
|
|
|
.ops = {
|
|
|
|
.add = acpi_video_bus_add,
|
|
|
|
.remove = acpi_video_bus_remove,
|
2009-04-07 15:37:11 +00:00
|
|
|
.notify = acpi_video_bus_notify,
|
2005-08-05 04:44:28 +00:00
|
|
|
},
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_video_bus_flags {
|
2005-08-05 04:44:28 +00:00
|
|
|
u8 multihead:1; /* can switch video heads */
|
|
|
|
u8 rom:1; /* can retrieve a video rom */
|
|
|
|
u8 post:1; /* can configure the head to */
|
|
|
|
u8 reserved:5;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_video_bus_cap {
|
2013-08-01 23:43:59 +00:00
|
|
|
u8 _DOS:1; /* Enable/Disable output switching */
|
|
|
|
u8 _DOD:1; /* Enumerate all devices attached to display adapter */
|
|
|
|
u8 _ROM:1; /* Get ROM Data */
|
|
|
|
u8 _GPD:1; /* Get POST Device */
|
|
|
|
u8 _SPD:1; /* Set POST Device */
|
|
|
|
u8 _VPO:1; /* Video POST Options */
|
2005-08-05 04:44:28 +00:00
|
|
|
u8 reserved:2;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
struct acpi_video_device_attrib {
|
|
|
|
u32 display_index:4; /* A zero-based instance of the Display */
|
2013-08-01 23:43:59 +00:00
|
|
|
u32 display_port_attachment:4; /* This field differentiates the display type */
|
|
|
|
u32 display_type:4; /* Describe the specific type in use */
|
|
|
|
u32 vendor_specific:4; /* Chipset Vendor Specific */
|
|
|
|
u32 bios_can_detect:1; /* BIOS can detect the device */
|
|
|
|
u32 depend_on_vga:1; /* Non-VGA output device whose power is related to
|
2005-08-05 04:44:28 +00:00
|
|
|
the VGA device. */
|
2013-08-01 23:43:59 +00:00
|
|
|
u32 pipe_id:3; /* For VGA multiple-head devices. */
|
|
|
|
u32 reserved:10; /* Must be 0 */
|
2017-04-19 10:36:18 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The device ID might not actually follow the scheme described by this
|
|
|
|
* struct acpi_video_device_attrib. If it does, then this bit
|
|
|
|
* device_id_scheme is set; otherwise, other fields should be ignored.
|
|
|
|
*
|
|
|
|
* (but also see the global flag device_id_scheme)
|
|
|
|
*/
|
|
|
|
u32 device_id_scheme:1;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_video_enumerated_device {
|
|
|
|
union {
|
|
|
|
u32 int_val;
|
2005-08-05 04:44:28 +00:00
|
|
|
struct acpi_video_device_attrib attrib;
|
2005-04-16 22:20:36 +00:00
|
|
|
} value;
|
|
|
|
struct acpi_video_device *bind_info;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_video_bus {
|
2006-05-19 20:54:40 +00:00
|
|
|
struct acpi_device *device;
|
2014-05-15 11:22:33 +00:00
|
|
|
bool backlight_registered;
|
2005-08-05 04:44:28 +00:00
|
|
|
u8 dos_setting;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct acpi_video_enumerated_device *attached_array;
|
2005-08-05 04:44:28 +00:00
|
|
|
u8 attached_count;
|
2014-12-15 08:01:29 +00:00
|
|
|
u8 child_count;
|
2005-08-05 04:44:28 +00:00
|
|
|
struct acpi_video_bus_cap cap;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct acpi_video_bus_flags flags;
|
2005-08-05 04:44:28 +00:00
|
|
|
struct list_head video_device_list;
|
2007-11-05 16:43:32 +00:00
|
|
|
struct mutex device_list_lock; /* protects video_device_list */
|
2013-10-11 13:27:44 +00:00
|
|
|
struct list_head entry;
|
2007-08-20 10:23:53 +00:00
|
|
|
struct input_dev *input;
|
|
|
|
char phys[32]; /* for input device */
|
2010-04-04 23:43:51 +00:00
|
|
|
struct notifier_block pm_nb;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_video_device_flags {
|
2005-08-05 04:44:28 +00:00
|
|
|
u8 crt:1;
|
|
|
|
u8 lcd:1;
|
|
|
|
u8 tvout:1;
|
2007-01-04 04:40:53 +00:00
|
|
|
u8 dvi:1;
|
2005-08-05 04:44:28 +00:00
|
|
|
u8 bios:1;
|
|
|
|
u8 unknown:1;
|
ACPI: video: correct acpi_video_bus_add error processing
acpi_video_bus_get_devices() may fail due to some video output device
doesn't have the _ADR method, and in this case, the error processing
is to simply free the video structure in acpi_video_bus_add(), while
leaving those already registered video output devices in the wild,
which means for some video output device, we have already registered
a backlight interface and installed a notification handler for it.
So it can happen when user is using this system, on hotkey pressing,
the notification handler will send a keycode through a non-existing
input device, causing kernel freeze.
To solve this problem, free all those already registered video output
devices once something goes wrong in acpi_video_bus_get_devices(), so
that no wild backlight interfaces and notification handlers exist.
References: https://bugzilla.kernel.org/show_bug.cgi?id=51731
Reported-and-tested-by: <i-tek@web.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-04-25 02:47:49 +00:00
|
|
|
u8 notify:1;
|
|
|
|
u8 reserved:1;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_video_device_cap {
|
2013-08-01 23:43:59 +00:00
|
|
|
u8 _ADR:1; /* Return the unique ID */
|
|
|
|
u8 _BCL:1; /* Query list of brightness control levels supported */
|
|
|
|
u8 _BCM:1; /* Set the brightness level */
|
2006-11-10 18:40:34 +00:00
|
|
|
u8 _BQC:1; /* Get current brightness level */
|
2009-03-18 08:27:18 +00:00
|
|
|
u8 _BCQ:1; /* Some buggy BIOS uses _BCQ instead of _BQC */
|
2013-08-01 23:43:59 +00:00
|
|
|
u8 _DDC:1; /* Return the EDID for this device */
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_video_device {
|
2005-08-05 04:44:28 +00:00
|
|
|
unsigned long device_id;
|
|
|
|
struct acpi_video_device_flags flags;
|
|
|
|
struct acpi_video_device_cap cap;
|
|
|
|
struct list_head entry;
|
2014-07-18 12:32:51 +00:00
|
|
|
struct delayed_work switch_brightness_work;
|
|
|
|
int switch_brightness_event;
|
2005-08-05 04:44:28 +00:00
|
|
|
struct acpi_video_bus *video;
|
|
|
|
struct acpi_device *dev;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct acpi_video_device_brightness *brightness;
|
2006-11-10 18:40:34 +00:00
|
|
|
struct backlight_device *backlight;
|
2009-08-30 03:03:16 +00:00
|
|
|
struct thermal_cooling_device *cooling_dev;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data);
|
|
|
|
static void acpi_video_device_rebind(struct acpi_video_bus *video);
|
|
|
|
static void acpi_video_device_bind(struct acpi_video_bus *video,
|
|
|
|
struct acpi_video_device *device);
|
2005-04-16 22:20:36 +00:00
|
|
|
static int acpi_video_device_enumerate(struct acpi_video_bus *video);
|
2006-11-10 18:40:34 +00:00
|
|
|
static int acpi_video_device_lcd_set_level(struct acpi_video_device *device,
|
|
|
|
int level);
|
|
|
|
static int acpi_video_device_lcd_get_level_current(
|
|
|
|
struct acpi_video_device *device,
|
2013-03-19 16:22:50 +00:00
|
|
|
unsigned long long *level, bool raw);
|
2005-08-05 04:44:28 +00:00
|
|
|
static int acpi_video_get_next_level(struct acpi_video_device *device,
|
|
|
|
u32 level_current, u32 event);
|
2014-07-18 12:32:51 +00:00
|
|
|
static void acpi_video_switch_brightness(struct work_struct *work);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-08-01 23:43:59 +00:00
|
|
|
/* backlight device sysfs support */
|
2006-11-10 18:40:34 +00:00
|
|
|
static int acpi_video_get_brightness(struct backlight_device *bd)
|
|
|
|
{
|
2008-10-10 06:22:59 +00:00
|
|
|
unsigned long long cur_level;
|
2007-12-26 02:03:26 +00:00
|
|
|
int i;
|
2013-08-03 20:15:21 +00:00
|
|
|
struct acpi_video_device *vd = bl_get_data(bd);
|
2009-03-18 08:27:08 +00:00
|
|
|
|
2013-03-19 16:22:50 +00:00
|
|
|
if (acpi_video_device_lcd_get_level_current(vd, &cur_level, false))
|
2009-03-18 08:27:08 +00:00
|
|
|
return -EINVAL;
|
2017-04-19 09:48:07 +00:00
|
|
|
for (i = ACPI_VIDEO_FIRST_LEVEL; i < vd->brightness->count; i++) {
|
2007-12-26 02:03:26 +00:00
|
|
|
if (vd->brightness->levels[i] == cur_level)
|
2017-04-19 09:48:07 +00:00
|
|
|
return i - ACPI_VIDEO_FIRST_LEVEL;
|
2007-12-26 02:03:26 +00:00
|
|
|
}
|
|
|
|
return 0;
|
2006-11-10 18:40:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_video_set_brightness(struct backlight_device *bd)
|
|
|
|
{
|
2017-04-19 09:48:07 +00:00
|
|
|
int request_level = bd->props.brightness + ACPI_VIDEO_FIRST_LEVEL;
|
2013-08-03 20:15:21 +00:00
|
|
|
struct acpi_video_device *vd = bl_get_data(bd);
|
2009-03-18 08:27:10 +00:00
|
|
|
|
2014-07-18 12:32:51 +00:00
|
|
|
cancel_delayed_work(&vd->switch_brightness_work);
|
2009-03-18 08:27:10 +00:00
|
|
|
return acpi_video_device_lcd_set_level(vd,
|
|
|
|
vd->brightness->levels[request_level]);
|
2006-11-10 18:40:34 +00:00
|
|
|
}
|
|
|
|
|
2010-11-16 13:14:02 +00:00
|
|
|
static const struct backlight_ops acpi_backlight_ops = {
|
2007-02-10 23:07:48 +00:00
|
|
|
.get_brightness = acpi_video_get_brightness,
|
|
|
|
.update_status = acpi_video_set_brightness,
|
|
|
|
};
|
|
|
|
|
2008-01-17 07:51:22 +00:00
|
|
|
/* thermal cooling device callbacks */
|
2017-04-19 09:48:07 +00:00
|
|
|
static int video_get_max_state(struct thermal_cooling_device *cooling_dev,
|
|
|
|
unsigned long *state)
|
2008-01-17 07:51:22 +00:00
|
|
|
{
|
2009-08-30 03:03:16 +00:00
|
|
|
struct acpi_device *device = cooling_dev->devdata;
|
2008-01-17 07:51:22 +00:00
|
|
|
struct acpi_video_device *video = acpi_driver_data(device);
|
|
|
|
|
2017-04-19 09:48:07 +00:00
|
|
|
*state = video->brightness->count - ACPI_VIDEO_FIRST_LEVEL - 1;
|
2008-11-27 17:48:13 +00:00
|
|
|
return 0;
|
2008-01-17 07:51:22 +00:00
|
|
|
}
|
|
|
|
|
2017-04-19 09:48:07 +00:00
|
|
|
static int video_get_cur_state(struct thermal_cooling_device *cooling_dev,
|
|
|
|
unsigned long *state)
|
2008-01-17 07:51:22 +00:00
|
|
|
{
|
2009-08-30 03:03:16 +00:00
|
|
|
struct acpi_device *device = cooling_dev->devdata;
|
2008-01-17 07:51:22 +00:00
|
|
|
struct acpi_video_device *video = acpi_driver_data(device);
|
2008-10-10 06:22:59 +00:00
|
|
|
unsigned long long level;
|
2008-11-27 17:48:13 +00:00
|
|
|
int offset;
|
2008-01-17 07:51:22 +00:00
|
|
|
|
2013-03-19 16:22:50 +00:00
|
|
|
if (acpi_video_device_lcd_get_level_current(video, &level, false))
|
2009-03-18 08:27:08 +00:00
|
|
|
return -EINVAL;
|
2017-04-19 09:48:07 +00:00
|
|
|
for (offset = ACPI_VIDEO_FIRST_LEVEL; offset < video->brightness->count;
|
|
|
|
offset++)
|
2008-11-27 17:48:13 +00:00
|
|
|
if (level == video->brightness->levels[offset]) {
|
|
|
|
*state = video->brightness->count - offset - 1;
|
|
|
|
return 0;
|
|
|
|
}
|
2008-01-17 07:51:22 +00:00
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2009-08-30 03:03:16 +00:00
|
|
|
video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long state)
|
2008-01-17 07:51:22 +00:00
|
|
|
{
|
2009-08-30 03:03:16 +00:00
|
|
|
struct acpi_device *device = cooling_dev->devdata;
|
2008-01-17 07:51:22 +00:00
|
|
|
struct acpi_video_device *video = acpi_driver_data(device);
|
|
|
|
int level;
|
|
|
|
|
2017-04-19 09:48:07 +00:00
|
|
|
if (state >= video->brightness->count - ACPI_VIDEO_FIRST_LEVEL)
|
2008-01-17 07:51:22 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
state = video->brightness->count - state;
|
2013-08-03 20:12:50 +00:00
|
|
|
level = video->brightness->levels[state - 1];
|
2008-01-17 07:51:22 +00:00
|
|
|
return acpi_video_device_lcd_set_level(video, level);
|
|
|
|
}
|
|
|
|
|
2011-06-25 17:07:52 +00:00
|
|
|
static const struct thermal_cooling_device_ops video_cooling_ops = {
|
2008-01-17 07:51:22 +00:00
|
|
|
.get_max_state = video_get_max_state,
|
|
|
|
.get_cur_state = video_get_cur_state,
|
|
|
|
.set_cur_state = video_set_cur_state,
|
|
|
|
};
|
|
|
|
|
2013-08-01 23:43:59 +00:00
|
|
|
/*
|
|
|
|
* --------------------------------------------------------------------------
|
|
|
|
* Video Management
|
|
|
|
* --------------------------------------------------------------------------
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static int
|
2016-04-27 12:45:04 +00:00
|
|
|
acpi_video_device_lcd_query_levels(acpi_handle handle,
|
2005-08-05 04:44:28 +00:00
|
|
|
union acpi_object **levels)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-08-05 04:44:28 +00:00
|
|
|
int status;
|
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
union acpi_object *obj;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
|
|
|
*levels = NULL;
|
|
|
|
|
2016-04-27 12:45:04 +00:00
|
|
|
status = acpi_evaluate_object(handle, "_BCL", NULL, &buffer);
|
2021-02-03 18:48:33 +00:00
|
|
|
if (ACPI_FAILURE(status))
|
2006-06-27 04:41:40 +00:00
|
|
|
return status;
|
2005-08-05 04:44:28 +00:00
|
|
|
obj = (union acpi_object *)buffer.pointer;
|
2006-03-11 15:12:00 +00:00
|
|
|
if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_info(handle, "Invalid _BCL data\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
status = -EFAULT;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
*levels = obj;
|
|
|
|
|
2006-06-27 04:41:40 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-08-03 20:12:50 +00:00
|
|
|
err:
|
2005-11-07 09:01:32 +00:00
|
|
|
kfree(buffer.pointer);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-27 04:41:40 +00:00
|
|
|
return status;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2005-08-05 04:44:28 +00:00
|
|
|
acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-03-18 08:27:10 +00:00
|
|
|
int status;
|
2008-12-31 02:58:48 +00:00
|
|
|
int state;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-06-28 16:24:39 +00:00
|
|
|
status = acpi_execute_simple_method(device->dev->handle,
|
|
|
|
"_BCM", level);
|
2009-03-18 08:27:10 +00:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_info(device->dev->handle, "_BCM evaluation failed\n");
|
2009-03-18 08:27:10 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2007-09-03 12:29:58 +00:00
|
|
|
device->brightness->curr = level;
|
2017-04-19 09:48:07 +00:00
|
|
|
for (state = ACPI_VIDEO_FIRST_LEVEL; state < device->brightness->count;
|
|
|
|
state++)
|
2009-03-18 08:27:10 +00:00
|
|
|
if (level == device->brightness->levels[state]) {
|
2009-03-18 08:27:16 +00:00
|
|
|
if (device->backlight)
|
2017-04-19 09:48:07 +00:00
|
|
|
device->backlight->props.brightness =
|
|
|
|
state - ACPI_VIDEO_FIRST_LEVEL;
|
2009-03-18 08:27:10 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-12-31 02:58:48 +00:00
|
|
|
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_info(device->dev->handle, "Current brightness invalid\n");
|
2009-03-18 08:27:10 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-04-24 16:13:18 +00:00
|
|
|
/*
|
|
|
|
* For some buggy _BQC methods, we need to add a constant value to
|
|
|
|
* the _BQC return value to get the actual current brightness level
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int bqc_offset_aml_bug_workaround;
|
2015-06-16 14:27:53 +00:00
|
|
|
static int video_set_bqc_offset(const struct dmi_system_id *d)
|
2009-04-24 16:13:18 +00:00
|
|
|
{
|
|
|
|
bqc_offset_aml_bug_workaround = 9;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-06-16 14:27:53 +00:00
|
|
|
static int video_disable_backlight_sysfs_if(
|
2015-06-09 08:32:25 +00:00
|
|
|
const struct dmi_system_id *d)
|
|
|
|
{
|
|
|
|
if (disable_backlight_sysfs_if == -1)
|
|
|
|
disable_backlight_sysfs_if = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-10-28 07:09:23 +00:00
|
|
|
static int video_set_device_id_scheme(const struct dmi_system_id *d)
|
|
|
|
{
|
|
|
|
device_id_scheme = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int video_enable_only_lcd(const struct dmi_system_id *d)
|
|
|
|
{
|
|
|
|
only_lcd = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-12-22 18:09:52 +00:00
|
|
|
static int video_set_report_key_events(const struct dmi_system_id *id)
|
|
|
|
{
|
|
|
|
if (report_key_events == -1)
|
|
|
|
report_key_events = (uintptr_t)id->driver_data;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-07-12 10:00:33 +00:00
|
|
|
static int video_hw_changes_brightness(
|
|
|
|
const struct dmi_system_id *d)
|
|
|
|
{
|
|
|
|
if (hw_changes_brightness == -1)
|
|
|
|
hw_changes_brightness = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-09-14 09:59:30 +00:00
|
|
|
static const struct dmi_system_id video_dmi_table[] = {
|
2009-04-24 16:13:18 +00:00
|
|
|
/*
|
|
|
|
* Broken _BQC workaround http://bugzilla.kernel.org/show_bug.cgi?id=13121
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
.callback = video_set_bqc_offset,
|
|
|
|
.ident = "Acer Aspire 5720",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5720"),
|
|
|
|
},
|
|
|
|
},
|
2009-05-08 01:11:56 +00:00
|
|
|
{
|
|
|
|
.callback = video_set_bqc_offset,
|
|
|
|
.ident = "Acer Aspire 5710Z",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5710Z"),
|
|
|
|
},
|
|
|
|
},
|
2009-05-27 03:35:34 +00:00
|
|
|
{
|
|
|
|
.callback = video_set_bqc_offset,
|
|
|
|
.ident = "eMachines E510",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "EMACHINES"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "eMachines E510"),
|
|
|
|
},
|
|
|
|
},
|
2009-05-19 19:08:41 +00:00
|
|
|
{
|
|
|
|
.callback = video_set_bqc_offset,
|
|
|
|
.ident = "Acer Aspire 5315",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5315"),
|
|
|
|
},
|
|
|
|
},
|
2009-06-22 03:31:18 +00:00
|
|
|
{
|
|
|
|
.callback = video_set_bqc_offset,
|
|
|
|
.ident = "Acer Aspire 7720",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7720"),
|
|
|
|
},
|
|
|
|
},
|
2014-08-28 08:20:46 +00:00
|
|
|
|
2015-06-09 08:32:25 +00:00
|
|
|
/*
|
|
|
|
* Some machines have a broken acpi-video interface for brightness
|
|
|
|
* control, but still need an acpi_video_device_lcd_set_level() call
|
|
|
|
* on resume to turn the backlight power on. We Enable backlight
|
|
|
|
* control on these systems, but do not register a backlight sysfs
|
|
|
|
* as brightness control does not work.
|
|
|
|
*/
|
2016-01-11 13:46:17 +00:00
|
|
|
{
|
|
|
|
/* https://bugzilla.kernel.org/show_bug.cgi?id=21012 */
|
|
|
|
.callback = video_disable_backlight_sysfs_if,
|
|
|
|
.ident = "Toshiba Portege R700",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE R700"),
|
|
|
|
},
|
|
|
|
},
|
2015-06-09 08:32:25 +00:00
|
|
|
{
|
|
|
|
/* https://bugs.freedesktop.org/show_bug.cgi?id=82634 */
|
|
|
|
.callback = video_disable_backlight_sysfs_if,
|
|
|
|
.ident = "Toshiba Portege R830",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE R830"),
|
|
|
|
},
|
|
|
|
},
|
2016-01-14 13:24:39 +00:00
|
|
|
{
|
|
|
|
/* https://bugzilla.kernel.org/show_bug.cgi?id=21012 */
|
|
|
|
.callback = video_disable_backlight_sysfs_if,
|
|
|
|
.ident = "Toshiba Satellite R830",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "SATELLITE R830"),
|
|
|
|
},
|
|
|
|
},
|
2015-10-28 07:09:23 +00:00
|
|
|
/*
|
|
|
|
* Some machine's _DOD IDs don't have bit 31(Device ID Scheme) set
|
|
|
|
* but the IDs actually follow the Device ID Scheme.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
/* https://bugzilla.kernel.org/show_bug.cgi?id=104121 */
|
|
|
|
.callback = video_set_device_id_scheme,
|
|
|
|
.ident = "ESPRIMO Mobile M9410",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Mobile M9410"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
/*
|
|
|
|
* Some machines have multiple video output devices, but only the one
|
|
|
|
* that is the type of LCD can do the backlight control so we should not
|
|
|
|
* register backlight interface for other video output devices.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
/* https://bugzilla.kernel.org/show_bug.cgi?id=104121 */
|
|
|
|
.callback = video_enable_only_lcd,
|
|
|
|
.ident = "ESPRIMO Mobile M9410",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Mobile M9410"),
|
|
|
|
},
|
|
|
|
},
|
2015-12-22 18:09:52 +00:00
|
|
|
/*
|
|
|
|
* Some machines report wrong key events on the acpi-bus, suppress
|
|
|
|
* key event reporting on these. Note this is only intended to work
|
|
|
|
* around events which are plain wrong. In some cases we get double
|
|
|
|
* events, in this case acpi-video is considered the canonical source
|
|
|
|
* and the events from the other source should be filtered. E.g.
|
|
|
|
* by calling acpi_video_handles_brightness_key_presses() from the
|
|
|
|
* vendor acpi/wmi driver or by using /lib/udev/hwdb.d/60-keyboard.hwdb
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
.callback = video_set_report_key_events,
|
|
|
|
.driver_data = (void *)((uintptr_t)REPORT_OUTPUT_KEY_EVENTS),
|
|
|
|
.ident = "Dell Vostro V131",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V131"),
|
|
|
|
},
|
|
|
|
},
|
2021-06-30 15:23:16 +00:00
|
|
|
{
|
|
|
|
.callback = video_set_report_key_events,
|
|
|
|
.driver_data = (void *)((uintptr_t)REPORT_BRIGHTNESS_KEY_EVENTS),
|
|
|
|
.ident = "Dell Vostro 3350",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 3350"),
|
|
|
|
},
|
|
|
|
},
|
2019-07-12 10:00:33 +00:00
|
|
|
/*
|
|
|
|
* Some machines change the brightness themselves when a brightness
|
|
|
|
* hotkey gets pressed, despite us telling them not to. In this case
|
|
|
|
* acpi_video_device_notify() should only call backlight_force_update(
|
|
|
|
* BACKLIGHT_UPDATE_HOTKEY) and not do anything else.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
/* https://bugzilla.kernel.org/show_bug.cgi?id=204077 */
|
|
|
|
.callback = video_hw_changes_brightness,
|
|
|
|
.ident = "Packard Bell EasyNote MZ35",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Packard Bell"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "EasyNote MZ35"),
|
|
|
|
},
|
|
|
|
},
|
2009-04-24 16:13:18 +00:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2013-03-19 16:22:52 +00:00
|
|
|
static unsigned long long
|
|
|
|
acpi_video_bqc_value_to_level(struct acpi_video_device *device,
|
|
|
|
unsigned long long bqc_value)
|
|
|
|
{
|
|
|
|
unsigned long long level;
|
|
|
|
|
|
|
|
if (device->brightness->flags._BQC_use_index) {
|
|
|
|
/*
|
2017-04-19 09:48:07 +00:00
|
|
|
* _BQC returns an index that doesn't account for the first 2
|
|
|
|
* items with special meaning (see enum acpi_video_level_idx),
|
|
|
|
* so we need to compensate for that by offsetting ourselves
|
2013-03-19 16:22:52 +00:00
|
|
|
*/
|
|
|
|
if (device->brightness->flags._BCL_reversed)
|
2017-04-19 09:48:07 +00:00
|
|
|
bqc_value = device->brightness->count -
|
|
|
|
ACPI_VIDEO_FIRST_LEVEL - 1 - bqc_value;
|
2013-03-19 16:22:52 +00:00
|
|
|
|
2017-04-19 09:48:07 +00:00
|
|
|
level = device->brightness->levels[bqc_value +
|
2020-11-05 02:06:00 +00:00
|
|
|
ACPI_VIDEO_FIRST_LEVEL];
|
2013-03-19 16:22:52 +00:00
|
|
|
} else {
|
|
|
|
level = bqc_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
level += bqc_offset_aml_bug_workaround;
|
|
|
|
|
|
|
|
return level;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int
|
2005-08-05 04:44:28 +00:00
|
|
|
acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
|
2013-03-19 16:22:50 +00:00
|
|
|
unsigned long long *level, bool raw)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-03-18 08:27:08 +00:00
|
|
|
acpi_status status = AE_OK;
|
2009-06-24 07:17:36 +00:00
|
|
|
int i;
|
2009-03-18 08:27:08 +00:00
|
|
|
|
2009-03-18 08:27:18 +00:00
|
|
|
if (device->cap._BQC || device->cap._BCQ) {
|
|
|
|
char *buf = device->cap._BQC ? "_BQC" : "_BCQ";
|
|
|
|
|
|
|
|
status = acpi_evaluate_integer(device->dev->handle, buf,
|
2009-03-18 08:27:08 +00:00
|
|
|
NULL, level);
|
|
|
|
if (ACPI_SUCCESS(status)) {
|
2013-03-19 16:22:50 +00:00
|
|
|
if (raw) {
|
|
|
|
/*
|
|
|
|
* Caller has indicated he wants the raw
|
|
|
|
* value returned by _BQC, so don't furtherly
|
|
|
|
* mess with the value.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-03-19 16:22:52 +00:00
|
|
|
*level = acpi_video_bqc_value_to_level(device, *level);
|
2009-03-18 08:27:16 +00:00
|
|
|
|
2017-04-19 09:48:07 +00:00
|
|
|
for (i = ACPI_VIDEO_FIRST_LEVEL;
|
|
|
|
i < device->brightness->count; i++)
|
2009-06-24 07:17:36 +00:00
|
|
|
if (device->brightness->levels[i] == *level) {
|
|
|
|
device->brightness->curr = *level;
|
|
|
|
return 0;
|
2013-08-03 20:12:50 +00:00
|
|
|
}
|
2013-03-19 16:22:50 +00:00
|
|
|
/*
|
|
|
|
* BQC returned an invalid level.
|
|
|
|
* Stop using it.
|
|
|
|
*/
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_info(device->dev->handle,
|
|
|
|
"%s returned an invalid level", buf);
|
2013-03-19 16:22:50 +00:00
|
|
|
device->cap._BQC = device->cap._BCQ = 0;
|
2009-03-18 08:27:08 +00:00
|
|
|
} else {
|
2013-08-01 23:43:59 +00:00
|
|
|
/*
|
|
|
|
* Fixme:
|
2009-03-18 08:27:08 +00:00
|
|
|
* should we return an error or ignore this failure?
|
|
|
|
* dev->brightness->curr is a cached value which stores
|
|
|
|
* the correct current backlight level in most cases.
|
|
|
|
* ACPI video backlight still works w/ buggy _BQC.
|
|
|
|
* http://bugzilla.kernel.org/show_bug.cgi?id=12233
|
|
|
|
*/
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_info(device->dev->handle,
|
|
|
|
"%s evaluation failed", buf);
|
2009-03-18 08:27:18 +00:00
|
|
|
device->cap._BQC = device->cap._BCQ = 0;
|
2009-03-18 08:27:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-03 12:29:58 +00:00
|
|
|
*level = device->brightness->curr;
|
2009-03-18 08:27:08 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2005-08-05 04:44:28 +00:00
|
|
|
acpi_video_device_EDID(struct acpi_video_device *device,
|
|
|
|
union acpi_object **edid, ssize_t length)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-08-05 04:44:28 +00:00
|
|
|
int status;
|
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
union acpi_object *obj;
|
|
|
|
union acpi_object arg0 = { ACPI_TYPE_INTEGER };
|
|
|
|
struct acpi_object_list args = { 1, &arg0 };
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
|
|
|
*edid = NULL;
|
|
|
|
|
|
|
|
if (!device)
|
2006-06-27 04:41:40 +00:00
|
|
|
return -ENODEV;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (length == 128)
|
|
|
|
arg0.integer.value = 1;
|
|
|
|
else if (length == 256)
|
|
|
|
arg0.integer.value = 2;
|
|
|
|
else
|
2006-06-27 04:41:40 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-05-19 20:54:48 +00:00
|
|
|
status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ACPI_FAILURE(status))
|
2006-06-27 04:41:40 +00:00
|
|
|
return -ENODEV;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-09-30 22:28:50 +00:00
|
|
|
obj = buffer.pointer;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (obj && obj->type == ACPI_TYPE_BUFFER)
|
|
|
|
*edid = obj;
|
|
|
|
else {
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_info(device->dev->handle, "Invalid _DDC data\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
status = -EFAULT;
|
|
|
|
kfree(obj);
|
|
|
|
}
|
|
|
|
|
2006-06-27 04:41:40 +00:00
|
|
|
return status;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* bus */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Arg:
|
2013-08-01 23:43:59 +00:00
|
|
|
* video : video bus device pointer
|
|
|
|
* bios_flag :
|
2005-04-16 22:20:36 +00:00
|
|
|
* 0. The system BIOS should NOT automatically switch(toggle)
|
|
|
|
* the active display output.
|
|
|
|
* 1. The system BIOS should automatically switch (toggle) the
|
2007-02-20 15:38:40 +00:00
|
|
|
* active display output. No switch event.
|
2005-04-16 22:20:36 +00:00
|
|
|
* 2. The _DGS value should be locked.
|
|
|
|
* 3. The system BIOS should not automatically switch (toggle) the
|
|
|
|
* active display output, but instead generate the display switch
|
|
|
|
* event notify code.
|
|
|
|
* lcd_flag :
|
|
|
|
* 0. The system BIOS should automatically control the brightness level
|
2019-10-07 15:48:18 +00:00
|
|
|
* of the LCD when:
|
|
|
|
* - the power changes from AC to DC (ACPI appendix B)
|
|
|
|
* - a brightness hotkey gets pressed (implied by Win7/8 backlight docs)
|
2013-08-01 23:43:59 +00:00
|
|
|
* 1. The system BIOS should NOT automatically control the brightness
|
2019-10-07 15:48:18 +00:00
|
|
|
* level of the LCD when:
|
|
|
|
* - the power changes from AC to DC (ACPI appendix B)
|
|
|
|
* - a brightness hotkey gets pressed (implied by Win7/8 backlight docs)
|
2013-08-01 23:43:59 +00:00
|
|
|
* Return Value:
|
2012-03-30 17:32:08 +00:00
|
|
|
* -EINVAL wrong arg.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
2005-08-05 04:44:28 +00:00
|
|
|
acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-03-30 17:32:08 +00:00
|
|
|
acpi_status status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-06-20 01:48:43 +00:00
|
|
|
if (!video->cap._DOS)
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-03-30 17:32:08 +00:00
|
|
|
if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1)
|
|
|
|
return -EINVAL;
|
2013-06-28 16:24:39 +00:00
|
|
|
video->dos_setting = (lcd_flag << 2) | bios_flag;
|
|
|
|
status = acpi_execute_simple_method(video->device->handle, "_DOS",
|
|
|
|
(lcd_flag << 2) | bios_flag);
|
2012-03-30 17:32:08 +00:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return -EIO;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-03-30 17:32:08 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-12-11 21:24:52 +00:00
|
|
|
/*
|
|
|
|
* Simple comparison function used to sort backlight levels.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
|
|
|
acpi_video_cmp_level(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
return *(int *)a - *(int *)b;
|
|
|
|
}
|
|
|
|
|
2013-04-22 12:08:32 +00:00
|
|
|
/*
|
|
|
|
* Decides if _BQC/_BCQ for this system is usable
|
|
|
|
*
|
|
|
|
* We do this by changing the level first and then read out the current
|
|
|
|
* brightness level, if the value does not match, find out if it is using
|
|
|
|
* index. If not, clear the _BQC/_BCQ capability.
|
|
|
|
*/
|
|
|
|
static int acpi_video_bqc_quirk(struct acpi_video_device *device,
|
|
|
|
int max_level, int current_level)
|
|
|
|
{
|
|
|
|
struct acpi_video_device_brightness *br = device->brightness;
|
|
|
|
int result;
|
|
|
|
unsigned long long level;
|
|
|
|
int test_level;
|
|
|
|
|
|
|
|
/* don't mess with existing known broken systems */
|
|
|
|
if (bqc_offset_aml_bug_workaround)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some systems always report current brightness level as maximum
|
2017-04-19 10:36:18 +00:00
|
|
|
* through _BQC, we need to test another value for them. However,
|
|
|
|
* there is a subtlety:
|
|
|
|
*
|
|
|
|
* If the _BCL package ordering is descending, the first level
|
|
|
|
* (br->levels[2]) is likely to be 0, and if the number of levels
|
|
|
|
* matches the number of steps, we might confuse a returned level to
|
|
|
|
* mean the index.
|
|
|
|
*
|
|
|
|
* For example:
|
|
|
|
*
|
|
|
|
* current_level = max_level = 100
|
|
|
|
* test_level = 0
|
|
|
|
* returned level = 100
|
|
|
|
*
|
|
|
|
* In this case 100 means the level, not the index, and _BCM failed.
|
|
|
|
* Still, if the _BCL package ordering is descending, the index of
|
|
|
|
* level 0 is also 100, so we assume _BQC is indexed, when it's not.
|
|
|
|
*
|
|
|
|
* This causes all _BQC calls to return bogus values causing weird
|
|
|
|
* behavior from the user's perspective. For example:
|
|
|
|
*
|
|
|
|
* xbacklight -set 10; xbacklight -set 20;
|
|
|
|
*
|
|
|
|
* would flash to 90% and then slowly down to the desired level (20).
|
|
|
|
*
|
|
|
|
* The solution is simple; test anything other than the first level
|
|
|
|
* (e.g. 1).
|
2013-04-22 12:08:32 +00:00
|
|
|
*/
|
2017-04-19 09:48:07 +00:00
|
|
|
test_level = current_level == max_level
|
|
|
|
? br->levels[ACPI_VIDEO_FIRST_LEVEL + 1]
|
|
|
|
: max_level;
|
2013-04-22 12:08:32 +00:00
|
|
|
|
|
|
|
result = acpi_video_device_lcd_set_level(device, test_level);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
result = acpi_video_device_lcd_get_level_current(device, &level, true);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
if (level != test_level) {
|
|
|
|
/* buggy _BQC found, need to find out if it uses index */
|
|
|
|
if (level < br->count) {
|
|
|
|
if (br->flags._BCL_reversed)
|
2017-04-19 09:48:07 +00:00
|
|
|
level = br->count - ACPI_VIDEO_FIRST_LEVEL - 1 - level;
|
|
|
|
if (br->levels[level + ACPI_VIDEO_FIRST_LEVEL] == test_level)
|
2013-04-22 12:08:32 +00:00
|
|
|
br->flags._BQC_use_index = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!br->flags._BQC_use_index)
|
|
|
|
device->cap._BQC = device->cap._BCQ = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-04-27 12:45:04 +00:00
|
|
|
int acpi_video_get_levels(struct acpi_device *device,
|
2016-05-21 07:30:46 +00:00
|
|
|
struct acpi_video_device_brightness **dev_br,
|
|
|
|
int *pmax_level)
|
2008-06-23 21:50:42 +00:00
|
|
|
{
|
|
|
|
union acpi_object *obj = NULL;
|
2009-03-18 08:27:12 +00:00
|
|
|
int i, max_level = 0, count = 0, level_ac_battery = 0;
|
2008-06-23 21:50:42 +00:00
|
|
|
union acpi_object *o;
|
|
|
|
struct acpi_video_device_brightness *br = NULL;
|
2016-04-27 12:45:04 +00:00
|
|
|
int result = 0;
|
ACPI / video: Filter the _BCL table for duplicate brightness values
Some devices have duplicate entries in there brightness levels table, ie
on my Dell Latitude E6430 the table looks like this:
[ 3.686060] acpi backlight index 0, val 80
[ 3.686095] acpi backlight index 1, val 50
[ 3.686122] acpi backlight index 2, val 5
[ 3.686147] acpi backlight index 3, val 5
[ 3.686172] acpi backlight index 4, val 5
[ 3.686197] acpi backlight index 5, val 5
[ 3.686223] acpi backlight index 6, val 5
[ 3.686248] acpi backlight index 7, val 5
[ 3.686273] acpi backlight index 8, val 6
[ 3.686332] acpi backlight index 9, val 7
[ 3.686356] acpi backlight index 10, val 8
[ 3.686380] acpi backlight index 11, val 9
etc.
Notice that brightness values 0-5 are all mapped to 5. This means that
if userspace writes any value between 0 and 5 to the brightness sysfs attribute
and then reads it, it will always return 0, which is somewhat unexpected.
This is a problem for ie gnome-settings-daemon, which uses read-modify-write
logic when the users presses the brightness up or down keys. This is done
this way to take brightness changes from other sources into account.
On this specific laptop what happens once the brightness has been set to 0,
is that gsd reads 0, adds 5, writes 5, and on the next brightness up key press
again reads 0, so things get stuck at the lowest brightness setting.
Filtering out the duplicate table entries, makes any write to brightness
read back as the written value as one would expect, fixing this.
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Reviewed-by: Aaron Lu <aaron.lu@intel.com>
Cc: All applicable <stable@vger.kernel.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-02-13 15:32:51 +00:00
|
|
|
u32 value;
|
2008-06-23 21:50:42 +00:00
|
|
|
|
2021-02-03 18:48:33 +00:00
|
|
|
if (ACPI_FAILURE(acpi_video_device_lcd_query_levels(device->handle, &obj))) {
|
|
|
|
acpi_handle_debug(device->handle,
|
|
|
|
"Could not query available LCD brightness level\n");
|
2016-04-27 12:45:04 +00:00
|
|
|
result = -ENODEV;
|
2008-06-23 21:50:42 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2017-04-19 09:48:07 +00:00
|
|
|
if (obj->package.count < ACPI_VIDEO_FIRST_LEVEL) {
|
2016-04-27 12:45:04 +00:00
|
|
|
result = -EINVAL;
|
2008-06-23 21:50:42 +00:00
|
|
|
goto out;
|
2016-04-27 12:45:04 +00:00
|
|
|
}
|
2008-06-23 21:50:42 +00:00
|
|
|
|
|
|
|
br = kzalloc(sizeof(*br), GFP_KERNEL);
|
|
|
|
if (!br) {
|
2009-03-18 08:27:16 +00:00
|
|
|
result = -ENOMEM;
|
2008-06-23 21:50:42 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2017-04-19 10:36:18 +00:00
|
|
|
/*
|
|
|
|
* Note that we have to reserve 2 extra items (ACPI_VIDEO_FIRST_LEVEL),
|
|
|
|
* in order to account for buggy BIOS which don't export the first two
|
|
|
|
* special levels (see below)
|
|
|
|
*/
|
treewide: kmalloc() -> kmalloc_array()
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This
patch replaces cases of:
kmalloc(a * b, gfp)
with:
kmalloc_array(a * b, gfp)
as well as handling cases of:
kmalloc(a * b * c, gfp)
with:
kmalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kmalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kmalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The tools/ directory was manually excluded, since it has its own
implementation of kmalloc().
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kmalloc
+ kmalloc_array
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kmalloc(sizeof(THING) * C2, ...)
|
kmalloc(sizeof(TYPE) * C2, ...)
|
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(C1 * C2, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * E2
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 20:55:00 +00:00
|
|
|
br->levels = kmalloc_array(obj->package.count + ACPI_VIDEO_FIRST_LEVEL,
|
|
|
|
sizeof(*br->levels),
|
|
|
|
GFP_KERNEL);
|
2009-03-18 08:27:16 +00:00
|
|
|
if (!br->levels) {
|
|
|
|
result = -ENOMEM;
|
2008-06-23 21:50:42 +00:00
|
|
|
goto out_free;
|
2009-03-18 08:27:16 +00:00
|
|
|
}
|
2008-06-23 21:50:42 +00:00
|
|
|
|
|
|
|
for (i = 0; i < obj->package.count; i++) {
|
|
|
|
o = (union acpi_object *)&obj->package.elements[i];
|
|
|
|
if (o->type != ACPI_TYPE_INTEGER) {
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_info(device->handle, "Invalid data\n");
|
2008-06-23 21:50:42 +00:00
|
|
|
continue;
|
|
|
|
}
|
ACPI / video: Filter the _BCL table for duplicate brightness values
Some devices have duplicate entries in there brightness levels table, ie
on my Dell Latitude E6430 the table looks like this:
[ 3.686060] acpi backlight index 0, val 80
[ 3.686095] acpi backlight index 1, val 50
[ 3.686122] acpi backlight index 2, val 5
[ 3.686147] acpi backlight index 3, val 5
[ 3.686172] acpi backlight index 4, val 5
[ 3.686197] acpi backlight index 5, val 5
[ 3.686223] acpi backlight index 6, val 5
[ 3.686248] acpi backlight index 7, val 5
[ 3.686273] acpi backlight index 8, val 6
[ 3.686332] acpi backlight index 9, val 7
[ 3.686356] acpi backlight index 10, val 8
[ 3.686380] acpi backlight index 11, val 9
etc.
Notice that brightness values 0-5 are all mapped to 5. This means that
if userspace writes any value between 0 and 5 to the brightness sysfs attribute
and then reads it, it will always return 0, which is somewhat unexpected.
This is a problem for ie gnome-settings-daemon, which uses read-modify-write
logic when the users presses the brightness up or down keys. This is done
this way to take brightness changes from other sources into account.
On this specific laptop what happens once the brightness has been set to 0,
is that gsd reads 0, adds 5, writes 5, and on the next brightness up key press
again reads 0, so things get stuck at the lowest brightness setting.
Filtering out the duplicate table entries, makes any write to brightness
read back as the written value as one would expect, fixing this.
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Reviewed-by: Aaron Lu <aaron.lu@intel.com>
Cc: All applicable <stable@vger.kernel.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-02-13 15:32:51 +00:00
|
|
|
value = (u32) o->integer.value;
|
|
|
|
/* Skip duplicate entries */
|
2017-04-19 09:48:07 +00:00
|
|
|
if (count > ACPI_VIDEO_FIRST_LEVEL
|
|
|
|
&& br->levels[count - 1] == value)
|
ACPI / video: Filter the _BCL table for duplicate brightness values
Some devices have duplicate entries in there brightness levels table, ie
on my Dell Latitude E6430 the table looks like this:
[ 3.686060] acpi backlight index 0, val 80
[ 3.686095] acpi backlight index 1, val 50
[ 3.686122] acpi backlight index 2, val 5
[ 3.686147] acpi backlight index 3, val 5
[ 3.686172] acpi backlight index 4, val 5
[ 3.686197] acpi backlight index 5, val 5
[ 3.686223] acpi backlight index 6, val 5
[ 3.686248] acpi backlight index 7, val 5
[ 3.686273] acpi backlight index 8, val 6
[ 3.686332] acpi backlight index 9, val 7
[ 3.686356] acpi backlight index 10, val 8
[ 3.686380] acpi backlight index 11, val 9
etc.
Notice that brightness values 0-5 are all mapped to 5. This means that
if userspace writes any value between 0 and 5 to the brightness sysfs attribute
and then reads it, it will always return 0, which is somewhat unexpected.
This is a problem for ie gnome-settings-daemon, which uses read-modify-write
logic when the users presses the brightness up or down keys. This is done
this way to take brightness changes from other sources into account.
On this specific laptop what happens once the brightness has been set to 0,
is that gsd reads 0, adds 5, writes 5, and on the next brightness up key press
again reads 0, so things get stuck at the lowest brightness setting.
Filtering out the duplicate table entries, makes any write to brightness
read back as the written value as one would expect, fixing this.
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Reviewed-by: Aaron Lu <aaron.lu@intel.com>
Cc: All applicable <stable@vger.kernel.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-02-13 15:32:51 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
br->levels[count] = value;
|
2008-06-23 21:50:42 +00:00
|
|
|
|
|
|
|
if (br->levels[count] > max_level)
|
|
|
|
max_level = br->levels[count];
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
2009-03-18 08:27:12 +00:00
|
|
|
/*
|
|
|
|
* some buggy BIOS don't export the levels
|
|
|
|
* when machine is on AC/Battery in _BCL package.
|
|
|
|
* In this case, the first two elements in _BCL packages
|
|
|
|
* are also supported brightness levels that OS should take care of.
|
|
|
|
*/
|
2017-04-19 09:48:07 +00:00
|
|
|
for (i = ACPI_VIDEO_FIRST_LEVEL; i < count; i++) {
|
|
|
|
if (br->levels[i] == br->levels[ACPI_VIDEO_AC_LEVEL])
|
2009-03-18 08:27:12 +00:00
|
|
|
level_ac_battery++;
|
2017-04-19 09:48:07 +00:00
|
|
|
if (br->levels[i] == br->levels[ACPI_VIDEO_BATTERY_LEVEL])
|
2009-04-14 03:02:18 +00:00
|
|
|
level_ac_battery++;
|
|
|
|
}
|
2009-03-18 08:27:12 +00:00
|
|
|
|
2017-04-19 09:48:07 +00:00
|
|
|
if (level_ac_battery < ACPI_VIDEO_FIRST_LEVEL) {
|
|
|
|
level_ac_battery = ACPI_VIDEO_FIRST_LEVEL - level_ac_battery;
|
2009-03-18 08:27:12 +00:00
|
|
|
br->flags._BCL_no_ac_battery_levels = 1;
|
2017-04-19 09:48:07 +00:00
|
|
|
for (i = (count - 1 + level_ac_battery);
|
|
|
|
i >= ACPI_VIDEO_FIRST_LEVEL; i--)
|
2009-03-18 08:27:12 +00:00
|
|
|
br->levels[i] = br->levels[i - level_ac_battery];
|
|
|
|
count += level_ac_battery;
|
2017-04-19 09:48:07 +00:00
|
|
|
} else if (level_ac_battery > ACPI_VIDEO_FIRST_LEVEL)
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_info(device->handle,
|
|
|
|
"Too many duplicates in _BCL package");
|
2009-03-18 08:27:12 +00:00
|
|
|
|
2009-03-18 08:27:14 +00:00
|
|
|
/* Check if the _BCL package is in a reversed order */
|
2017-04-19 09:48:07 +00:00
|
|
|
if (max_level == br->levels[ACPI_VIDEO_FIRST_LEVEL]) {
|
2009-03-18 08:27:14 +00:00
|
|
|
br->flags._BCL_reversed = 1;
|
2017-04-19 09:48:07 +00:00
|
|
|
sort(&br->levels[ACPI_VIDEO_FIRST_LEVEL],
|
|
|
|
count - ACPI_VIDEO_FIRST_LEVEL,
|
|
|
|
sizeof(br->levels[ACPI_VIDEO_FIRST_LEVEL]),
|
|
|
|
acpi_video_cmp_level, NULL);
|
2009-03-18 08:27:14 +00:00
|
|
|
} else if (max_level != br->levels[count - 1])
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_info(device->handle,
|
|
|
|
"Found unordered _BCL package");
|
2008-06-23 21:50:42 +00:00
|
|
|
|
|
|
|
br->count = count;
|
2016-04-27 12:45:04 +00:00
|
|
|
*dev_br = br;
|
2016-05-21 07:30:46 +00:00
|
|
|
if (pmax_level)
|
|
|
|
*pmax_level = max_level;
|
2016-04-27 12:45:04 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
kfree(obj);
|
|
|
|
return result;
|
|
|
|
out_free:
|
|
|
|
kfree(br);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_video_get_levels);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Arg:
|
|
|
|
* device : video output device (LCD, CRT, ..)
|
|
|
|
*
|
|
|
|
* Return Value:
|
|
|
|
* Maximum brightness level
|
|
|
|
*
|
|
|
|
* Allocate and initialize device->brightness.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
|
|
|
acpi_video_init_brightness(struct acpi_video_device *device)
|
|
|
|
{
|
|
|
|
int i, max_level = 0;
|
|
|
|
unsigned long long level, level_old;
|
|
|
|
struct acpi_video_device_brightness *br = NULL;
|
2020-02-29 00:12:43 +00:00
|
|
|
int result;
|
2016-04-27 12:45:04 +00:00
|
|
|
|
2016-05-21 07:30:46 +00:00
|
|
|
result = acpi_video_get_levels(device->dev, &br, &max_level);
|
2016-04-27 12:45:04 +00:00
|
|
|
if (result)
|
|
|
|
return result;
|
2008-06-23 21:50:42 +00:00
|
|
|
device->brightness = br;
|
2009-03-18 08:27:16 +00:00
|
|
|
|
|
|
|
/* _BQC uses INDEX while _BCL uses VALUE in some laptops */
|
2009-08-31 16:39:54 +00:00
|
|
|
br->curr = level = max_level;
|
2009-04-09 06:24:35 +00:00
|
|
|
|
|
|
|
if (!device->cap._BQC)
|
|
|
|
goto set_level;
|
|
|
|
|
2013-03-19 16:22:50 +00:00
|
|
|
result = acpi_video_device_lcd_get_level_current(device,
|
|
|
|
&level_old, true);
|
2009-03-18 08:27:16 +00:00
|
|
|
if (result)
|
|
|
|
goto out_free_levels;
|
|
|
|
|
2013-04-22 12:08:32 +00:00
|
|
|
result = acpi_video_bqc_quirk(device, max_level, level_old);
|
2009-03-18 08:27:16 +00:00
|
|
|
if (result)
|
|
|
|
goto out_free_levels;
|
2013-04-22 12:08:32 +00:00
|
|
|
/*
|
|
|
|
* cap._BQC may get cleared due to _BQC is found to be broken
|
|
|
|
* in acpi_video_bqc_quirk, so check again here.
|
|
|
|
*/
|
|
|
|
if (!device->cap._BQC)
|
|
|
|
goto set_level;
|
2009-04-09 06:24:35 +00:00
|
|
|
|
2013-11-15 06:39:12 +00:00
|
|
|
level = acpi_video_bqc_value_to_level(device, level_old);
|
|
|
|
/*
|
|
|
|
* On some buggy laptops, _BQC returns an uninitialized
|
|
|
|
* value when invoked for the first time, i.e.
|
|
|
|
* level_old is invalid (no matter whether it's a level
|
|
|
|
* or an index). Set the backlight to max_level in this case.
|
|
|
|
*/
|
2017-04-19 09:48:07 +00:00
|
|
|
for (i = ACPI_VIDEO_FIRST_LEVEL; i < br->count; i++)
|
2013-11-15 06:39:12 +00:00
|
|
|
if (level == br->levels[i])
|
|
|
|
break;
|
|
|
|
if (i == br->count || !level)
|
|
|
|
level = max_level;
|
2009-04-09 06:24:35 +00:00
|
|
|
|
|
|
|
set_level:
|
2009-08-31 16:39:54 +00:00
|
|
|
result = acpi_video_device_lcd_set_level(device, level);
|
2009-04-09 06:24:35 +00:00
|
|
|
if (result)
|
|
|
|
goto out_free_levels;
|
2009-03-18 08:27:16 +00:00
|
|
|
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_debug(device->dev->handle, "found %d brightness levels\n",
|
|
|
|
br->count - ACPI_VIDEO_FIRST_LEVEL);
|
|
|
|
|
2016-04-27 12:45:04 +00:00
|
|
|
return 0;
|
2008-06-23 21:50:42 +00:00
|
|
|
|
|
|
|
out_free_levels:
|
|
|
|
kfree(br->levels);
|
|
|
|
kfree(br);
|
|
|
|
device->brightness = NULL;
|
2009-03-18 08:27:16 +00:00
|
|
|
return result;
|
2008-06-23 21:50:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Arg:
|
|
|
|
* device : video output device (LCD, CRT, ..)
|
|
|
|
*
|
|
|
|
* Return Value:
|
2013-08-01 23:43:59 +00:00
|
|
|
* None
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2007-02-20 15:38:40 +00:00
|
|
|
* Find out all required AML methods defined under the output
|
2005-04-16 22:20:36 +00:00
|
|
|
* device.
|
|
|
|
*/
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
static void acpi_video_device_find_cap(struct acpi_video_device *device)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-06-28 16:24:38 +00:00
|
|
|
if (acpi_has_method(device->dev->handle, "_ADR"))
|
2005-04-16 22:20:36 +00:00
|
|
|
device->cap._ADR = 1;
|
2013-06-28 16:24:38 +00:00
|
|
|
if (acpi_has_method(device->dev->handle, "_BCL"))
|
2005-08-05 04:44:28 +00:00
|
|
|
device->cap._BCL = 1;
|
2013-06-28 16:24:38 +00:00
|
|
|
if (acpi_has_method(device->dev->handle, "_BCM"))
|
2005-08-05 04:44:28 +00:00
|
|
|
device->cap._BCM = 1;
|
2013-06-28 16:24:38 +00:00
|
|
|
if (acpi_has_method(device->dev->handle, "_BQC")) {
|
2006-11-10 18:40:34 +00:00
|
|
|
device->cap._BQC = 1;
|
2013-06-28 16:24:38 +00:00
|
|
|
} else if (acpi_has_method(device->dev->handle, "_BCQ")) {
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_info(device->dev->handle,
|
|
|
|
"_BCQ is used instead of _BQC\n");
|
2009-03-18 08:27:18 +00:00
|
|
|
device->cap._BCQ = 1;
|
|
|
|
}
|
|
|
|
|
2013-06-28 16:24:38 +00:00
|
|
|
if (acpi_has_method(device->dev->handle, "_DDC"))
|
2005-08-05 04:44:28 +00:00
|
|
|
device->cap._DDC = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2013-08-01 23:43:59 +00:00
|
|
|
* Arg:
|
|
|
|
* device : video output device (VGA)
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Return Value:
|
2013-08-01 23:43:59 +00:00
|
|
|
* None
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2007-02-20 15:38:40 +00:00
|
|
|
* Find out all required AML methods defined under the video bus device.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-06-28 16:24:38 +00:00
|
|
|
if (acpi_has_method(video->device->handle, "_DOS"))
|
2005-04-16 22:20:36 +00:00
|
|
|
video->cap._DOS = 1;
|
2013-06-28 16:24:38 +00:00
|
|
|
if (acpi_has_method(video->device->handle, "_DOD"))
|
2005-04-16 22:20:36 +00:00
|
|
|
video->cap._DOD = 1;
|
2013-06-28 16:24:38 +00:00
|
|
|
if (acpi_has_method(video->device->handle, "_ROM"))
|
2005-04-16 22:20:36 +00:00
|
|
|
video->cap._ROM = 1;
|
2013-06-28 16:24:38 +00:00
|
|
|
if (acpi_has_method(video->device->handle, "_GPD"))
|
2005-04-16 22:20:36 +00:00
|
|
|
video->cap._GPD = 1;
|
2013-06-28 16:24:38 +00:00
|
|
|
if (acpi_has_method(video->device->handle, "_SPD"))
|
2005-04-16 22:20:36 +00:00
|
|
|
video->cap._SPD = 1;
|
2013-06-28 16:24:38 +00:00
|
|
|
if (acpi_has_method(video->device->handle, "_VPO"))
|
2005-04-16 22:20:36 +00:00
|
|
|
video->cap._VPO = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check whether the video bus device has required AML method to
|
|
|
|
* support the desired features
|
|
|
|
*/
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
static int acpi_video_bus_check(struct acpi_video_bus *video)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-08-05 04:44:28 +00:00
|
|
|
acpi_status status = -ENOENT;
|
2009-06-10 19:56:00 +00:00
|
|
|
struct pci_dev *dev;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!video)
|
2006-06-27 04:41:40 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-06-10 19:56:00 +00:00
|
|
|
dev = acpi_get_pci_dev(video->device->handle);
|
2008-08-01 15:37:54 +00:00
|
|
|
if (!dev)
|
|
|
|
return -ENODEV;
|
2009-06-10 19:56:00 +00:00
|
|
|
pci_dev_put(dev);
|
2008-08-01 15:37:54 +00:00
|
|
|
|
2013-08-01 23:43:59 +00:00
|
|
|
/*
|
|
|
|
* Since there is no HID, CID and so on for VGA driver, we have
|
2005-04-16 22:20:36 +00:00
|
|
|
* to check well known required nodes.
|
|
|
|
*/
|
|
|
|
|
2007-02-20 15:38:40 +00:00
|
|
|
/* Does this device support video switching? */
|
2009-08-21 09:03:05 +00:00
|
|
|
if (video->cap._DOS || video->cap._DOD) {
|
|
|
|
if (!video->cap._DOS) {
|
2021-02-03 18:48:33 +00:00
|
|
|
pr_info(FW_BUG "ACPI(%s) defines _DOD but not _DOS\n",
|
2009-08-21 09:03:05 +00:00
|
|
|
acpi_device_bid(video->device));
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
video->flags.multihead = 1;
|
|
|
|
status = 0;
|
|
|
|
}
|
|
|
|
|
2007-02-20 15:38:40 +00:00
|
|
|
/* Does this device support retrieving a video ROM? */
|
2005-08-05 04:44:28 +00:00
|
|
|
if (video->cap._ROM) {
|
2005-04-16 22:20:36 +00:00
|
|
|
video->flags.rom = 1;
|
|
|
|
status = 0;
|
|
|
|
}
|
|
|
|
|
2007-02-20 15:38:40 +00:00
|
|
|
/* Does this device support configuring which video device to POST? */
|
2005-08-05 04:44:28 +00:00
|
|
|
if (video->cap._GPD && video->cap._SPD && video->cap._VPO) {
|
2005-04-16 22:20:36 +00:00
|
|
|
video->flags.post = 1;
|
|
|
|
status = 0;
|
|
|
|
}
|
|
|
|
|
2006-06-27 04:41:40 +00:00
|
|
|
return status;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-08-01 23:43:59 +00:00
|
|
|
/*
|
|
|
|
* --------------------------------------------------------------------------
|
|
|
|
* Driver Interface
|
|
|
|
* --------------------------------------------------------------------------
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* device interface */
|
2013-08-03 20:12:50 +00:00
|
|
|
static struct acpi_video_device_attrib *
|
2007-01-04 04:40:53 +00:00
|
|
|
acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id)
|
|
|
|
{
|
2007-11-05 16:43:33 +00:00
|
|
|
struct acpi_video_enumerated_device *ids;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < video->attached_count; i++) {
|
|
|
|
ids = &video->attached_array[i];
|
|
|
|
if ((ids->value.int_val & 0xffff) == device_id)
|
|
|
|
return &ids->value.attrib;
|
|
|
|
}
|
2007-01-04 04:40:53 +00:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-01-12 19:17:03 +00:00
|
|
|
static int
|
|
|
|
acpi_video_get_device_type(struct acpi_video_bus *video,
|
|
|
|
unsigned long device_id)
|
|
|
|
{
|
|
|
|
struct acpi_video_enumerated_device *ids;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < video->attached_count; i++) {
|
|
|
|
ids = &video->attached_array[i];
|
|
|
|
if ((ids->value.int_val & 0xffff) == device_id)
|
|
|
|
return ids->value.int_val;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int
|
2005-08-05 04:44:28 +00:00
|
|
|
acpi_video_bus_get_one_device(struct acpi_device *device,
|
|
|
|
struct acpi_video_bus *video)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-10-10 06:22:59 +00:00
|
|
|
unsigned long long device_id;
|
2010-01-12 19:17:03 +00:00
|
|
|
int status, device_type;
|
2005-08-05 04:44:28 +00:00
|
|
|
struct acpi_video_device *data;
|
2013-08-03 20:12:50 +00:00
|
|
|
struct acpi_video_device_attrib *attribute;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
status =
|
|
|
|
acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
|
ACPI: video: correct acpi_video_bus_add error processing
acpi_video_bus_get_devices() may fail due to some video output device
doesn't have the _ADR method, and in this case, the error processing
is to simply free the video structure in acpi_video_bus_add(), while
leaving those already registered video output devices in the wild,
which means for some video output device, we have already registered
a backlight interface and installed a notification handler for it.
So it can happen when user is using this system, on hotkey pressing,
the notification handler will send a keycode through a non-existing
input device, causing kernel freeze.
To solve this problem, free all those already registered video output
devices once something goes wrong in acpi_video_bus_get_devices(), so
that no wild backlight interfaces and notification handlers exist.
References: https://bugzilla.kernel.org/show_bug.cgi?id=51731
Reported-and-tested-by: <i-tek@web.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-04-25 02:47:49 +00:00
|
|
|
/* Some device omits _ADR, we skip them instead of fail */
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
ACPI: video: correct acpi_video_bus_add error processing
acpi_video_bus_get_devices() may fail due to some video output device
doesn't have the _ADR method, and in this case, the error processing
is to simply free the video structure in acpi_video_bus_add(), while
leaving those already registered video output devices in the wild,
which means for some video output device, we have already registered
a backlight interface and installed a notification handler for it.
So it can happen when user is using this system, on hotkey pressing,
the notification handler will send a keycode through a non-existing
input device, causing kernel freeze.
To solve this problem, free all those already registered video output
devices once something goes wrong in acpi_video_bus_get_devices(), so
that no wild backlight interfaces and notification handlers exist.
References: https://bugzilla.kernel.org/show_bug.cgi?id=51731
Reported-and-tested-by: <i-tek@web.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-04-25 02:47:49 +00:00
|
|
|
data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
|
|
|
|
if (!data)
|
|
|
|
return -ENOMEM;
|
2007-01-04 04:40:53 +00:00
|
|
|
|
ACPI: video: correct acpi_video_bus_add error processing
acpi_video_bus_get_devices() may fail due to some video output device
doesn't have the _ADR method, and in this case, the error processing
is to simply free the video structure in acpi_video_bus_add(), while
leaving those already registered video output devices in the wild,
which means for some video output device, we have already registered
a backlight interface and installed a notification handler for it.
So it can happen when user is using this system, on hotkey pressing,
the notification handler will send a keycode through a non-existing
input device, causing kernel freeze.
To solve this problem, free all those already registered video output
devices once something goes wrong in acpi_video_bus_get_devices(), so
that no wild backlight interfaces and notification handlers exist.
References: https://bugzilla.kernel.org/show_bug.cgi?id=51731
Reported-and-tested-by: <i-tek@web.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-04-25 02:47:49 +00:00
|
|
|
strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
|
|
|
|
strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
|
|
|
|
device->driver_data = data;
|
|
|
|
|
|
|
|
data->device_id = device_id;
|
|
|
|
data->video = video;
|
|
|
|
data->dev = device;
|
2014-07-18 12:32:51 +00:00
|
|
|
INIT_DELAYED_WORK(&data->switch_brightness_work,
|
|
|
|
acpi_video_switch_brightness);
|
ACPI: video: correct acpi_video_bus_add error processing
acpi_video_bus_get_devices() may fail due to some video output device
doesn't have the _ADR method, and in this case, the error processing
is to simply free the video structure in acpi_video_bus_add(), while
leaving those already registered video output devices in the wild,
which means for some video output device, we have already registered
a backlight interface and installed a notification handler for it.
So it can happen when user is using this system, on hotkey pressing,
the notification handler will send a keycode through a non-existing
input device, causing kernel freeze.
To solve this problem, free all those already registered video output
devices once something goes wrong in acpi_video_bus_get_devices(), so
that no wild backlight interfaces and notification handlers exist.
References: https://bugzilla.kernel.org/show_bug.cgi?id=51731
Reported-and-tested-by: <i-tek@web.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-04-25 02:47:49 +00:00
|
|
|
|
|
|
|
attribute = acpi_video_get_device_attr(video, device_id);
|
|
|
|
|
2015-10-28 07:09:23 +00:00
|
|
|
if (attribute && (attribute->device_id_scheme || device_id_scheme)) {
|
ACPI: video: correct acpi_video_bus_add error processing
acpi_video_bus_get_devices() may fail due to some video output device
doesn't have the _ADR method, and in this case, the error processing
is to simply free the video structure in acpi_video_bus_add(), while
leaving those already registered video output devices in the wild,
which means for some video output device, we have already registered
a backlight interface and installed a notification handler for it.
So it can happen when user is using this system, on hotkey pressing,
the notification handler will send a keycode through a non-existing
input device, causing kernel freeze.
To solve this problem, free all those already registered video output
devices once something goes wrong in acpi_video_bus_get_devices(), so
that no wild backlight interfaces and notification handlers exist.
References: https://bugzilla.kernel.org/show_bug.cgi?id=51731
Reported-and-tested-by: <i-tek@web.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-04-25 02:47:49 +00:00
|
|
|
switch (attribute->display_type) {
|
|
|
|
case ACPI_VIDEO_DISPLAY_CRT:
|
|
|
|
data->flags.crt = 1;
|
|
|
|
break;
|
|
|
|
case ACPI_VIDEO_DISPLAY_TV:
|
|
|
|
data->flags.tvout = 1;
|
|
|
|
break;
|
|
|
|
case ACPI_VIDEO_DISPLAY_DVI:
|
|
|
|
data->flags.dvi = 1;
|
|
|
|
break;
|
|
|
|
case ACPI_VIDEO_DISPLAY_LCD:
|
|
|
|
data->flags.lcd = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
data->flags.unknown = 1;
|
|
|
|
break;
|
|
|
|
}
|
2013-08-03 20:12:50 +00:00
|
|
|
if (attribute->bios_can_detect)
|
ACPI: video: correct acpi_video_bus_add error processing
acpi_video_bus_get_devices() may fail due to some video output device
doesn't have the _ADR method, and in this case, the error processing
is to simply free the video structure in acpi_video_bus_add(), while
leaving those already registered video output devices in the wild,
which means for some video output device, we have already registered
a backlight interface and installed a notification handler for it.
So it can happen when user is using this system, on hotkey pressing,
the notification handler will send a keycode through a non-existing
input device, causing kernel freeze.
To solve this problem, free all those already registered video output
devices once something goes wrong in acpi_video_bus_get_devices(), so
that no wild backlight interfaces and notification handlers exist.
References: https://bugzilla.kernel.org/show_bug.cgi?id=51731
Reported-and-tested-by: <i-tek@web.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-04-25 02:47:49 +00:00
|
|
|
data->flags.bios = 1;
|
|
|
|
} else {
|
|
|
|
/* Check for legacy IDs */
|
|
|
|
device_type = acpi_video_get_device_type(video, device_id);
|
|
|
|
/* Ignore bits 16 and 18-20 */
|
|
|
|
switch (device_type & 0xffe2ffff) {
|
2013-08-03 20:12:50 +00:00
|
|
|
case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR:
|
|
|
|
data->flags.crt = 1;
|
|
|
|
break;
|
|
|
|
case ACPI_VIDEO_DISPLAY_LEGACY_PANEL:
|
|
|
|
data->flags.lcd = 1;
|
|
|
|
break;
|
|
|
|
case ACPI_VIDEO_DISPLAY_LEGACY_TV:
|
|
|
|
data->flags.tvout = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
data->flags.unknown = 1;
|
2010-01-12 19:17:03 +00:00
|
|
|
}
|
ACPI: video: correct acpi_video_bus_add error processing
acpi_video_bus_get_devices() may fail due to some video output device
doesn't have the _ADR method, and in this case, the error processing
is to simply free the video structure in acpi_video_bus_add(), while
leaving those already registered video output devices in the wild,
which means for some video output device, we have already registered
a backlight interface and installed a notification handler for it.
So it can happen when user is using this system, on hotkey pressing,
the notification handler will send a keycode through a non-existing
input device, causing kernel freeze.
To solve this problem, free all those already registered video output
devices once something goes wrong in acpi_video_bus_get_devices(), so
that no wild backlight interfaces and notification handlers exist.
References: https://bugzilla.kernel.org/show_bug.cgi?id=51731
Reported-and-tested-by: <i-tek@web.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-04-25 02:47:49 +00:00
|
|
|
}
|
2005-08-05 04:44:28 +00:00
|
|
|
|
ACPI: video: correct acpi_video_bus_add error processing
acpi_video_bus_get_devices() may fail due to some video output device
doesn't have the _ADR method, and in this case, the error processing
is to simply free the video structure in acpi_video_bus_add(), while
leaving those already registered video output devices in the wild,
which means for some video output device, we have already registered
a backlight interface and installed a notification handler for it.
So it can happen when user is using this system, on hotkey pressing,
the notification handler will send a keycode through a non-existing
input device, causing kernel freeze.
To solve this problem, free all those already registered video output
devices once something goes wrong in acpi_video_bus_get_devices(), so
that no wild backlight interfaces and notification handlers exist.
References: https://bugzilla.kernel.org/show_bug.cgi?id=51731
Reported-and-tested-by: <i-tek@web.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-04-25 02:47:49 +00:00
|
|
|
acpi_video_device_bind(video, data);
|
|
|
|
acpi_video_device_find_cap(data);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
ACPI: video: correct acpi_video_bus_add error processing
acpi_video_bus_get_devices() may fail due to some video output device
doesn't have the _ADR method, and in this case, the error processing
is to simply free the video structure in acpi_video_bus_add(), while
leaving those already registered video output devices in the wild,
which means for some video output device, we have already registered
a backlight interface and installed a notification handler for it.
So it can happen when user is using this system, on hotkey pressing,
the notification handler will send a keycode through a non-existing
input device, causing kernel freeze.
To solve this problem, free all those already registered video output
devices once something goes wrong in acpi_video_bus_get_devices(), so
that no wild backlight interfaces and notification handlers exist.
References: https://bugzilla.kernel.org/show_bug.cgi?id=51731
Reported-and-tested-by: <i-tek@web.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-04-25 02:47:49 +00:00
|
|
|
mutex_lock(&video->device_list_lock);
|
|
|
|
list_add_tail(&data->entry, &video->video_device_list);
|
|
|
|
mutex_unlock(&video->device_list_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
ACPI: video: correct acpi_video_bus_add error processing
acpi_video_bus_get_devices() may fail due to some video output device
doesn't have the _ADR method, and in this case, the error processing
is to simply free the video structure in acpi_video_bus_add(), while
leaving those already registered video output devices in the wild,
which means for some video output device, we have already registered
a backlight interface and installed a notification handler for it.
So it can happen when user is using this system, on hotkey pressing,
the notification handler will send a keycode through a non-existing
input device, causing kernel freeze.
To solve this problem, free all those already registered video output
devices once something goes wrong in acpi_video_bus_get_devices(), so
that no wild backlight interfaces and notification handlers exist.
References: https://bugzilla.kernel.org/show_bug.cgi?id=51731
Reported-and-tested-by: <i-tek@web.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-04-25 02:47:49 +00:00
|
|
|
return status;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Arg:
|
2013-08-01 23:43:59 +00:00
|
|
|
* video : video bus device
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Return:
|
2013-08-01 23:43:59 +00:00
|
|
|
* none
|
|
|
|
*
|
|
|
|
* Enumerate the video device list of the video bus,
|
2005-04-16 22:20:36 +00:00
|
|
|
* bind the ids with the corresponding video devices
|
|
|
|
* under the video bus.
|
2005-08-05 04:44:28 +00:00
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
static void acpi_video_device_rebind(struct acpi_video_bus *video)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-11-05 16:43:31 +00:00
|
|
|
struct acpi_video_device *dev;
|
|
|
|
|
2007-11-05 16:43:32 +00:00
|
|
|
mutex_lock(&video->device_list_lock);
|
2007-11-05 16:43:31 +00:00
|
|
|
|
|
|
|
list_for_each_entry(dev, &video->video_device_list, entry)
|
2005-08-05 04:44:28 +00:00
|
|
|
acpi_video_device_bind(video, dev);
|
2007-11-05 16:43:31 +00:00
|
|
|
|
2007-11-05 16:43:32 +00:00
|
|
|
mutex_unlock(&video->device_list_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Arg:
|
2013-08-01 23:43:59 +00:00
|
|
|
* video : video bus device
|
|
|
|
* device : video output device under the video
|
|
|
|
* bus
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Return:
|
2013-08-01 23:43:59 +00:00
|
|
|
* none
|
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Bind the ids with the corresponding video devices
|
|
|
|
* under the video bus.
|
2005-08-05 04:44:28 +00:00
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static void
|
2005-08-05 04:44:28 +00:00
|
|
|
acpi_video_device_bind(struct acpi_video_bus *video,
|
|
|
|
struct acpi_video_device *device)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-11-05 16:43:33 +00:00
|
|
|
struct acpi_video_enumerated_device *ids;
|
2005-08-05 04:44:28 +00:00
|
|
|
int i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-11-05 16:43:33 +00:00
|
|
|
for (i = 0; i < video->attached_count; i++) {
|
|
|
|
ids = &video->attached_array[i];
|
|
|
|
if (device->device_id == (ids->value.int_val & 0xffff)) {
|
|
|
|
ids->bind_info = device;
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_debug(video->device->handle, "%s: %d\n",
|
|
|
|
__func__, i);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-30 06:10:17 +00:00
|
|
|
static bool acpi_video_device_in_dod(struct acpi_video_device *device)
|
|
|
|
{
|
|
|
|
struct acpi_video_bus *video = device->video;
|
|
|
|
int i;
|
|
|
|
|
2014-12-15 08:01:29 +00:00
|
|
|
/*
|
|
|
|
* If we have a broken _DOD or we have more than 8 output devices
|
|
|
|
* under the graphics controller node that we can't proper deal with
|
|
|
|
* in the operation region code currently, no need to test.
|
|
|
|
*/
|
|
|
|
if (!video->attached_count || video->child_count > 8)
|
2014-09-30 06:10:17 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
for (i = 0; i < video->attached_count; i++) {
|
2014-12-01 01:09:18 +00:00
|
|
|
if ((video->attached_array[i].value.int_val & 0xfff) ==
|
|
|
|
(device->device_id & 0xfff))
|
2014-09-30 06:10:17 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Arg:
|
2013-08-01 23:43:59 +00:00
|
|
|
* video : video bus device
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Return:
|
2013-08-01 23:43:59 +00:00
|
|
|
* < 0 : error
|
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Call _DOD to enumerate all devices attached to display adapter
|
|
|
|
*
|
2005-08-05 04:44:28 +00:00
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static int acpi_video_device_enumerate(struct acpi_video_bus *video)
|
|
|
|
{
|
2005-08-05 04:44:28 +00:00
|
|
|
int status;
|
|
|
|
int count;
|
|
|
|
int i;
|
2007-11-05 16:43:33 +00:00
|
|
|
struct acpi_video_enumerated_device *active_list;
|
2005-08-05 04:44:28 +00:00
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
union acpi_object *dod = NULL;
|
|
|
|
union acpi_object *obj;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-05-27 07:47:06 +00:00
|
|
|
if (!video->cap._DOD)
|
|
|
|
return AE_NOT_EXIST;
|
|
|
|
|
2006-05-19 20:54:48 +00:00
|
|
|
status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
|
2021-02-03 18:48:33 +00:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
acpi_handle_info(video->device->handle,
|
|
|
|
"_DOD evaluation failed: %s\n",
|
|
|
|
acpi_format_exception(status));
|
2006-06-27 04:41:40 +00:00
|
|
|
return status;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-09-30 22:28:50 +00:00
|
|
|
dod = buffer.pointer;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_info(video->device->handle, "Invalid _DOD data\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
status = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_debug(video->device->handle, "Found %d video heads in _DOD\n",
|
|
|
|
dod->package.count);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-11-05 16:43:33 +00:00
|
|
|
active_list = kcalloc(1 + dod->package.count,
|
|
|
|
sizeof(struct acpi_video_enumerated_device),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!active_list) {
|
2005-04-16 22:20:36 +00:00
|
|
|
status = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
for (i = 0; i < dod->package.count; i++) {
|
2006-09-30 22:28:50 +00:00
|
|
|
obj = &dod->package.elements[i];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (obj->type != ACPI_TYPE_INTEGER) {
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_info(video->device->handle,
|
|
|
|
"Invalid _DOD data in element %d\n", i);
|
2007-11-05 16:43:33 +00:00
|
|
|
continue;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-11-05 16:43:33 +00:00
|
|
|
|
|
|
|
active_list[count].value.int_val = obj->integer.value;
|
|
|
|
active_list[count].bind_info = NULL;
|
2021-02-03 18:48:33 +00:00
|
|
|
|
|
|
|
acpi_handle_debug(video->device->handle,
|
|
|
|
"_DOD element[%d] = %d\n", i,
|
|
|
|
(int)obj->integer.value);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
2005-11-07 09:01:32 +00:00
|
|
|
kfree(video->attached_array);
|
2005-08-05 04:44:28 +00:00
|
|
|
|
2007-11-05 16:43:33 +00:00
|
|
|
video->attached_array = active_list;
|
2005-04-16 22:20:36 +00:00
|
|
|
video->attached_count = count;
|
2007-11-05 16:43:33 +00:00
|
|
|
|
2013-08-03 20:12:50 +00:00
|
|
|
out:
|
2006-06-30 07:19:10 +00:00
|
|
|
kfree(buffer.pointer);
|
2006-06-27 04:41:40 +00:00
|
|
|
return status;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
static int
|
|
|
|
acpi_video_get_next_level(struct acpi_video_device *device,
|
|
|
|
u32 level_current, u32 event)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-09-03 12:30:08 +00:00
|
|
|
int min, max, min_above, max_below, i, l, delta = 255;
|
2006-12-19 20:56:14 +00:00
|
|
|
max = max_below = 0;
|
|
|
|
min = min_above = 255;
|
2007-09-03 12:30:08 +00:00
|
|
|
/* Find closest level to level_current */
|
2017-04-19 09:48:07 +00:00
|
|
|
for (i = ACPI_VIDEO_FIRST_LEVEL; i < device->brightness->count; i++) {
|
2007-09-03 12:30:08 +00:00
|
|
|
l = device->brightness->levels[i];
|
|
|
|
if (abs(l - level_current) < abs(delta)) {
|
|
|
|
delta = l - level_current;
|
|
|
|
if (!delta)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2021-03-13 01:55:35 +00:00
|
|
|
/* Adjust level_current to closest available level */
|
2007-09-03 12:30:08 +00:00
|
|
|
level_current += delta;
|
2017-04-19 09:48:07 +00:00
|
|
|
for (i = ACPI_VIDEO_FIRST_LEVEL; i < device->brightness->count; i++) {
|
2006-12-19 20:56:14 +00:00
|
|
|
l = device->brightness->levels[i];
|
|
|
|
if (l < min)
|
|
|
|
min = l;
|
|
|
|
if (l > max)
|
|
|
|
max = l;
|
|
|
|
if (l < min_above && l > level_current)
|
|
|
|
min_above = l;
|
|
|
|
if (l > max_below && l < level_current)
|
|
|
|
max_below = l;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (event) {
|
|
|
|
case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:
|
|
|
|
return (level_current < max) ? min_above : min;
|
|
|
|
case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:
|
|
|
|
return (level_current < max) ? min_above : max;
|
|
|
|
case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:
|
|
|
|
return (level_current > min) ? max_below : min;
|
|
|
|
case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:
|
|
|
|
case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
return level_current;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2014-07-18 12:32:51 +00:00
|
|
|
static void
|
|
|
|
acpi_video_switch_brightness(struct work_struct *work)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-07-18 12:32:51 +00:00
|
|
|
struct acpi_video_device *device = container_of(to_delayed_work(work),
|
|
|
|
struct acpi_video_device, switch_brightness_work);
|
2008-10-10 06:22:59 +00:00
|
|
|
unsigned long long level_current, level_next;
|
2014-07-18 12:32:51 +00:00
|
|
|
int event = device->switch_brightness_event;
|
2009-03-18 08:27:08 +00:00
|
|
|
int result = -EINVAL;
|
|
|
|
|
2013-10-11 13:27:45 +00:00
|
|
|
/* no warning message if acpi_backlight=vendor or a quirk is used */
|
2015-06-09 08:32:25 +00:00
|
|
|
if (!device->backlight)
|
2014-07-18 12:32:51 +00:00
|
|
|
return;
|
2009-07-13 02:33:24 +00:00
|
|
|
|
2008-06-23 21:50:42 +00:00
|
|
|
if (!device->brightness)
|
2009-03-18 08:27:08 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
result = acpi_video_device_lcd_get_level_current(device,
|
2013-03-19 16:22:50 +00:00
|
|
|
&level_current,
|
|
|
|
false);
|
2009-03-18 08:27:08 +00:00
|
|
|
if (result)
|
|
|
|
goto out;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
level_next = acpi_video_get_next_level(device, level_current, event);
|
2009-03-18 08:27:08 +00:00
|
|
|
|
2009-03-18 08:27:10 +00:00
|
|
|
result = acpi_video_device_lcd_set_level(device, level_next);
|
2009-03-18 08:27:08 +00:00
|
|
|
|
2009-07-14 16:06:03 +00:00
|
|
|
if (!result)
|
|
|
|
backlight_force_update(device->backlight,
|
|
|
|
BACKLIGHT_UPDATE_HOTKEY);
|
|
|
|
|
2009-03-18 08:27:08 +00:00
|
|
|
out:
|
|
|
|
if (result)
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_info(device->dev->handle,
|
|
|
|
"Failed to switch brightness\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-01-12 19:17:03 +00:00
|
|
|
int acpi_video_get_edid(struct acpi_device *device, int type, int device_id,
|
|
|
|
void **edid)
|
|
|
|
{
|
|
|
|
struct acpi_video_bus *video;
|
|
|
|
struct acpi_video_device *video_device;
|
|
|
|
union acpi_object *buffer = NULL;
|
|
|
|
acpi_status status;
|
|
|
|
int i, length;
|
|
|
|
|
|
|
|
if (!device || !acpi_driver_data(device))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
video = acpi_driver_data(device);
|
|
|
|
|
|
|
|
for (i = 0; i < video->attached_count; i++) {
|
|
|
|
video_device = video->attached_array[i].bind_info;
|
|
|
|
length = 256;
|
|
|
|
|
|
|
|
if (!video_device)
|
|
|
|
continue;
|
|
|
|
|
2010-12-06 07:04:24 +00:00
|
|
|
if (!video_device->cap._DDC)
|
|
|
|
continue;
|
|
|
|
|
2010-01-12 19:17:03 +00:00
|
|
|
if (type) {
|
|
|
|
switch (type) {
|
|
|
|
case ACPI_VIDEO_DISPLAY_CRT:
|
|
|
|
if (!video_device->flags.crt)
|
|
|
|
continue;
|
|
|
|
break;
|
|
|
|
case ACPI_VIDEO_DISPLAY_TV:
|
|
|
|
if (!video_device->flags.tvout)
|
|
|
|
continue;
|
|
|
|
break;
|
|
|
|
case ACPI_VIDEO_DISPLAY_DVI:
|
|
|
|
if (!video_device->flags.dvi)
|
|
|
|
continue;
|
|
|
|
break;
|
|
|
|
case ACPI_VIDEO_DISPLAY_LCD:
|
|
|
|
if (!video_device->flags.lcd)
|
|
|
|
continue;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else if (video_device->device_id != device_id) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
status = acpi_video_device_EDID(video_device, &buffer, length);
|
|
|
|
|
|
|
|
if (ACPI_FAILURE(status) || !buffer ||
|
|
|
|
buffer->type != ACPI_TYPE_BUFFER) {
|
|
|
|
length = 128;
|
|
|
|
status = acpi_video_device_EDID(video_device, &buffer,
|
|
|
|
length);
|
|
|
|
if (ACPI_FAILURE(status) || !buffer ||
|
|
|
|
buffer->type != ACPI_TYPE_BUFFER) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*edid = buffer->buffer.pointer;
|
|
|
|
return length;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_video_get_edid);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int
|
2005-08-05 04:44:28 +00:00
|
|
|
acpi_video_bus_get_devices(struct acpi_video_bus *video,
|
|
|
|
struct acpi_device *device)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-10-13 00:41:25 +00:00
|
|
|
int status = 0;
|
2007-11-05 16:43:31 +00:00
|
|
|
struct acpi_device *dev;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-10-13 00:41:25 +00:00
|
|
|
/*
|
|
|
|
* There are systems where video module known to work fine regardless
|
|
|
|
* of broken _DOD and ignoring returned value here doesn't cause
|
|
|
|
* any issues later.
|
|
|
|
*/
|
|
|
|
acpi_video_device_enumerate(video);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-11-05 16:43:31 +00:00
|
|
|
list_for_each_entry(dev, &device->children, node) {
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
status = acpi_video_bus_get_one_device(dev, video);
|
2012-03-30 17:32:08 +00:00
|
|
|
if (status) {
|
ACPI: video: correct acpi_video_bus_add error processing
acpi_video_bus_get_devices() may fail due to some video output device
doesn't have the _ADR method, and in this case, the error processing
is to simply free the video structure in acpi_video_bus_add(), while
leaving those already registered video output devices in the wild,
which means for some video output device, we have already registered
a backlight interface and installed a notification handler for it.
So it can happen when user is using this system, on hotkey pressing,
the notification handler will send a keycode through a non-existing
input device, causing kernel freeze.
To solve this problem, free all those already registered video output
devices once something goes wrong in acpi_video_bus_get_devices(), so
that no wild backlight interfaces and notification handlers exist.
References: https://bugzilla.kernel.org/show_bug.cgi?id=51731
Reported-and-tested-by: <i-tek@web.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-04-25 02:47:49 +00:00
|
|
|
dev_err(&dev->dev, "Can't attach device\n");
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2014-12-15 08:01:29 +00:00
|
|
|
video->child_count++;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-06-27 04:41:40 +00:00
|
|
|
return status;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* acpi_video interface */
|
|
|
|
|
2013-07-16 05:08:05 +00:00
|
|
|
/*
|
|
|
|
* Win8 requires setting bit2 of _DOS to let firmware know it shouldn't
|
2021-03-13 01:55:35 +00:00
|
|
|
* perform any automatic brightness change on receiving a notification.
|
2013-07-16 05:08:05 +00:00
|
|
|
*/
|
2005-08-05 04:44:28 +00:00
|
|
|
static int acpi_video_bus_start_devices(struct acpi_video_bus *video)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-07-16 05:08:05 +00:00
|
|
|
return acpi_video_bus_DOS(video, 0,
|
2013-10-11 13:27:45 +00:00
|
|
|
acpi_osi_is_win8() ? 1 : 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-07-16 05:08:05 +00:00
|
|
|
return acpi_video_bus_DOS(video, 0,
|
2013-10-11 13:27:45 +00:00
|
|
|
acpi_osi_is_win8() ? 0 : 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-04-07 15:37:11 +00:00
|
|
|
static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-04-07 15:37:11 +00:00
|
|
|
struct acpi_video_bus *video = acpi_driver_data(device);
|
2007-08-20 10:23:53 +00:00
|
|
|
struct input_dev *input;
|
2009-12-11 22:40:46 +00:00
|
|
|
int keycode = 0;
|
2007-08-20 10:23:53 +00:00
|
|
|
|
2013-10-11 13:27:44 +00:00
|
|
|
if (!video || !video->input)
|
2006-06-27 04:41:40 +00:00
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-08-20 10:23:53 +00:00
|
|
|
input = video->input;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
switch (event) {
|
2007-02-20 15:38:40 +00:00
|
|
|
case ACPI_VIDEO_NOTIFY_SWITCH: /* User requested a switch,
|
2005-04-16 22:20:36 +00:00
|
|
|
* most likely via hotkey. */
|
2012-08-02 13:30:27 +00:00
|
|
|
keycode = KEY_SWITCHVIDEOMODE;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
2007-02-20 15:38:40 +00:00
|
|
|
case ACPI_VIDEO_NOTIFY_PROBE: /* User plugged in or removed a video
|
2005-04-16 22:20:36 +00:00
|
|
|
* connector. */
|
|
|
|
acpi_video_device_enumerate(video);
|
|
|
|
acpi_video_device_rebind(video);
|
2007-08-20 10:23:53 +00:00
|
|
|
keycode = KEY_SWITCHVIDEOMODE;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
case ACPI_VIDEO_NOTIFY_CYCLE: /* Cycle Display output hotkey pressed. */
|
2007-08-20 10:23:53 +00:00
|
|
|
keycode = KEY_SWITCHVIDEOMODE;
|
|
|
|
break;
|
2005-08-05 04:44:28 +00:00
|
|
|
case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT: /* Next Display output hotkey pressed. */
|
2007-08-20 10:23:53 +00:00
|
|
|
keycode = KEY_VIDEO_NEXT;
|
|
|
|
break;
|
2005-08-05 04:44:28 +00:00
|
|
|
case ACPI_VIDEO_NOTIFY_PREV_OUTPUT: /* previous Display output hotkey pressed. */
|
2007-08-20 10:23:53 +00:00
|
|
|
keycode = KEY_VIDEO_PREV;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_debug(device->handle, "Unsupported event [0x%x]\n",
|
|
|
|
event);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-08-02 13:30:27 +00:00
|
|
|
if (acpi_notifier_call_chain(device, event, 0))
|
|
|
|
/* Something vetoed the keypress. */
|
|
|
|
keycode = 0;
|
2009-12-11 22:40:46 +00:00
|
|
|
|
2015-12-22 18:09:51 +00:00
|
|
|
if (keycode && (report_key_events & REPORT_OUTPUT_KEY_EVENTS)) {
|
2009-12-11 22:40:46 +00:00
|
|
|
input_report_key(input, keycode, 1);
|
|
|
|
input_sync(input);
|
|
|
|
input_report_key(input, keycode, 0);
|
|
|
|
input_sync(input);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2014-07-18 12:32:51 +00:00
|
|
|
static void brightness_switch_event(struct acpi_video_device *video_device,
|
|
|
|
u32 event)
|
|
|
|
{
|
|
|
|
if (!brightness_switch_enabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
video_device->switch_brightness_event = event;
|
|
|
|
schedule_delayed_work(&video_device->switch_brightness_work, HZ / 10);
|
|
|
|
}
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-09-30 22:28:50 +00:00
|
|
|
struct acpi_video_device *video_device = data;
|
2005-08-05 04:44:28 +00:00
|
|
|
struct acpi_device *device = NULL;
|
2007-08-20 10:23:53 +00:00
|
|
|
struct acpi_video_bus *bus;
|
|
|
|
struct input_dev *input;
|
2009-12-11 22:40:46 +00:00
|
|
|
int keycode = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!video_device)
|
2006-06-27 04:41:40 +00:00
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-05-19 20:54:40 +00:00
|
|
|
device = video_device->dev;
|
2007-08-20 10:23:53 +00:00
|
|
|
bus = video_device->video;
|
|
|
|
input = bus->input;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-07-12 10:00:33 +00:00
|
|
|
if (hw_changes_brightness > 0) {
|
|
|
|
if (video_device->backlight)
|
|
|
|
backlight_force_update(video_device->backlight,
|
|
|
|
BACKLIGHT_UPDATE_HOTKEY);
|
|
|
|
acpi_notifier_call_chain(device, event, 0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (event) {
|
2005-08-05 04:44:28 +00:00
|
|
|
case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: /* Cycle brightness */
|
2014-07-18 12:32:51 +00:00
|
|
|
brightness_switch_event(video_device, event);
|
2007-08-20 10:23:53 +00:00
|
|
|
keycode = KEY_BRIGHTNESS_CYCLE;
|
|
|
|
break;
|
2005-08-05 04:44:28 +00:00
|
|
|
case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: /* Increase brightness */
|
2014-07-18 12:32:51 +00:00
|
|
|
brightness_switch_event(video_device, event);
|
2007-08-20 10:23:53 +00:00
|
|
|
keycode = KEY_BRIGHTNESSUP;
|
|
|
|
break;
|
2005-08-05 04:44:28 +00:00
|
|
|
case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: /* Decrease brightness */
|
2014-07-18 12:32:51 +00:00
|
|
|
brightness_switch_event(video_device, event);
|
2007-08-20 10:23:53 +00:00
|
|
|
keycode = KEY_BRIGHTNESSDOWN;
|
|
|
|
break;
|
2011-05-10 08:16:21 +00:00
|
|
|
case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightness */
|
2014-07-18 12:32:51 +00:00
|
|
|
brightness_switch_event(video_device, event);
|
2007-08-20 10:23:53 +00:00
|
|
|
keycode = KEY_BRIGHTNESS_ZERO;
|
|
|
|
break;
|
2005-08-05 04:44:28 +00:00
|
|
|
case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: /* display device off */
|
2014-07-18 12:32:51 +00:00
|
|
|
brightness_switch_event(video_device, event);
|
2007-08-20 10:23:53 +00:00
|
|
|
keycode = KEY_DISPLAY_OFF;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
default:
|
2021-02-03 18:48:33 +00:00
|
|
|
acpi_handle_debug(handle, "Unsupported event [0x%x]\n", event);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-08-20 10:23:53 +00:00
|
|
|
|
2008-01-25 06:48:12 +00:00
|
|
|
acpi_notifier_call_chain(device, event, 0);
|
2009-12-11 22:40:46 +00:00
|
|
|
|
2015-12-22 18:09:51 +00:00
|
|
|
if (keycode && (report_key_events & REPORT_BRIGHTNESS_KEY_EVENTS)) {
|
2009-12-11 22:40:46 +00:00
|
|
|
input_report_key(input, keycode, 1);
|
|
|
|
input_sync(input);
|
|
|
|
input_report_key(input, keycode, 0);
|
|
|
|
input_sync(input);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-04-04 23:43:51 +00:00
|
|
|
static int acpi_video_resume(struct notifier_block *nb,
|
|
|
|
unsigned long val, void *ign)
|
2008-02-05 07:31:24 +00:00
|
|
|
{
|
|
|
|
struct acpi_video_bus *video;
|
|
|
|
struct acpi_video_device *video_device;
|
|
|
|
int i;
|
|
|
|
|
2010-04-04 23:43:51 +00:00
|
|
|
switch (val) {
|
2022-05-19 14:37:32 +00:00
|
|
|
case PM_POST_HIBERNATION:
|
|
|
|
case PM_POST_SUSPEND:
|
|
|
|
case PM_POST_RESTORE:
|
|
|
|
video = container_of(nb, struct acpi_video_bus, pm_nb);
|
|
|
|
|
|
|
|
dev_info(&video->device->dev, "Restoring backlight state\n");
|
|
|
|
|
|
|
|
for (i = 0; i < video->attached_count; i++) {
|
|
|
|
video_device = video->attached_array[i].bind_info;
|
|
|
|
if (video_device && video_device->brightness)
|
|
|
|
acpi_video_device_lcd_set_level(video_device,
|
|
|
|
video_device->brightness->curr);
|
|
|
|
}
|
2008-02-05 07:31:24 +00:00
|
|
|
|
2022-05-19 14:37:32 +00:00
|
|
|
return NOTIFY_OK;
|
2008-02-05 07:31:24 +00:00
|
|
|
}
|
2022-05-19 14:37:32 +00:00
|
|
|
return NOTIFY_DONE;
|
2008-02-05 07:31:24 +00:00
|
|
|
}
|
|
|
|
|
2009-12-30 07:59:23 +00:00
|
|
|
static acpi_status
|
|
|
|
acpi_video_bus_match(acpi_handle handle, u32 level, void *context,
|
|
|
|
void **return_value)
|
|
|
|
{
|
|
|
|
struct acpi_device *device = context;
|
|
|
|
struct acpi_device *sibling;
|
|
|
|
|
|
|
|
if (handle == device->handle)
|
|
|
|
return AE_CTRL_TERMINATE;
|
|
|
|
|
2021-12-03 16:37:10 +00:00
|
|
|
sibling = acpi_fetch_acpi_dev(handle);
|
|
|
|
if (!sibling)
|
2009-12-30 07:59:23 +00:00
|
|
|
return AE_OK;
|
|
|
|
|
|
|
|
if (!strcmp(acpi_device_name(sibling), ACPI_VIDEO_BUS_NAME))
|
|
|
|
return AE_ALREADY_EXISTS;
|
|
|
|
|
|
|
|
return AE_OK;
|
|
|
|
}
|
|
|
|
|
2013-10-11 13:27:44 +00:00
|
|
|
static void acpi_video_dev_register_backlight(struct acpi_video_device *device)
|
|
|
|
{
|
2014-05-15 11:22:33 +00:00
|
|
|
struct backlight_properties props;
|
|
|
|
struct pci_dev *pdev;
|
|
|
|
acpi_handle acpi_parent;
|
|
|
|
struct device *parent = NULL;
|
|
|
|
int result;
|
|
|
|
static int count;
|
|
|
|
char *name;
|
2013-10-11 13:27:44 +00:00
|
|
|
|
2014-05-15 11:22:33 +00:00
|
|
|
result = acpi_video_init_brightness(device);
|
|
|
|
if (result)
|
|
|
|
return;
|
2015-06-09 08:32:25 +00:00
|
|
|
|
|
|
|
if (disable_backlight_sysfs_if > 0)
|
|
|
|
return;
|
|
|
|
|
2014-05-15 11:22:33 +00:00
|
|
|
name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
|
|
|
|
if (!name)
|
|
|
|
return;
|
|
|
|
count++;
|
2013-10-11 13:27:44 +00:00
|
|
|
|
2014-05-15 11:22:33 +00:00
|
|
|
acpi_get_parent(device->dev->handle, &acpi_parent);
|
2013-10-11 13:27:44 +00:00
|
|
|
|
2014-05-15 11:22:33 +00:00
|
|
|
pdev = acpi_get_pci_dev(acpi_parent);
|
|
|
|
if (pdev) {
|
|
|
|
parent = &pdev->dev;
|
|
|
|
pci_dev_put(pdev);
|
|
|
|
}
|
2013-10-11 13:27:44 +00:00
|
|
|
|
2014-05-15 11:22:33 +00:00
|
|
|
memset(&props, 0, sizeof(struct backlight_properties));
|
|
|
|
props.type = BACKLIGHT_FIRMWARE;
|
2017-04-19 09:48:07 +00:00
|
|
|
props.max_brightness =
|
|
|
|
device->brightness->count - ACPI_VIDEO_FIRST_LEVEL - 1;
|
2014-05-15 11:22:33 +00:00
|
|
|
device->backlight = backlight_device_register(name,
|
|
|
|
parent,
|
|
|
|
device,
|
|
|
|
&acpi_backlight_ops,
|
|
|
|
&props);
|
|
|
|
kfree(name);
|
2015-06-09 08:32:25 +00:00
|
|
|
if (IS_ERR(device->backlight)) {
|
|
|
|
device->backlight = NULL;
|
2014-05-15 11:22:33 +00:00
|
|
|
return;
|
2015-06-09 08:32:25 +00:00
|
|
|
}
|
2013-10-11 13:27:44 +00:00
|
|
|
|
2014-05-15 11:22:33 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
2013-10-11 13:27:44 +00:00
|
|
|
|
2014-05-15 11:22:33 +00:00
|
|
|
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;
|
2013-10-11 13:27:44 +00:00
|
|
|
}
|
2014-05-15 11:22:33 +00:00
|
|
|
|
|
|
|
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)
|
2021-02-03 18:48:33 +00:00
|
|
|
pr_info("sysfs link creation failed\n");
|
|
|
|
|
2014-05-15 11:22:33 +00:00
|
|
|
result = sysfs_create_link(&device->cooling_dev->device.kobj,
|
|
|
|
&device->dev->dev.kobj, "device");
|
|
|
|
if (result)
|
2021-02-03 18:48:33 +00:00
|
|
|
pr_info("Reverse sysfs link creation failed\n");
|
2013-10-11 13:27:44 +00:00
|
|
|
}
|
|
|
|
|
2014-10-28 06:35:59 +00:00
|
|
|
static void acpi_video_run_bcl_for_osi(struct acpi_video_bus *video)
|
|
|
|
{
|
|
|
|
struct acpi_video_device *dev;
|
|
|
|
union acpi_object *levels;
|
|
|
|
|
|
|
|
mutex_lock(&video->device_list_lock);
|
|
|
|
list_for_each_entry(dev, &video->video_device_list, entry) {
|
2016-05-21 07:30:46 +00:00
|
|
|
if (!acpi_video_device_lcd_query_levels(dev->dev->handle, &levels))
|
2014-10-28 06:35:59 +00:00
|
|
|
kfree(levels);
|
|
|
|
}
|
|
|
|
mutex_unlock(&video->device_list_lock);
|
|
|
|
}
|
|
|
|
|
2015-10-28 07:09:23 +00:00
|
|
|
static bool acpi_video_should_register_backlight(struct acpi_video_device *dev)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Do not create backlight device for video output
|
|
|
|
* device that is not in the enumerated list.
|
|
|
|
*/
|
|
|
|
if (!acpi_video_device_in_dod(dev)) {
|
|
|
|
dev_dbg(&dev->dev->dev, "not in _DOD list, ignore\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (only_lcd)
|
|
|
|
return dev->flags.lcd;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-10-11 13:27:44 +00:00
|
|
|
static int acpi_video_bus_register_backlight(struct acpi_video_bus *video)
|
|
|
|
{
|
|
|
|
struct acpi_video_device *dev;
|
|
|
|
|
2014-05-21 13:39:55 +00:00
|
|
|
if (video->backlight_registered)
|
|
|
|
return 0;
|
|
|
|
|
2014-10-28 06:35:59 +00:00
|
|
|
acpi_video_run_bcl_for_osi(video);
|
|
|
|
|
2015-06-16 14:27:51 +00:00
|
|
|
if (acpi_video_get_backlight_type() != acpi_backlight_video)
|
2014-05-15 11:22:33 +00:00
|
|
|
return 0;
|
|
|
|
|
2013-10-11 13:27:44 +00:00
|
|
|
mutex_lock(&video->device_list_lock);
|
2015-10-28 07:09:23 +00:00
|
|
|
list_for_each_entry(dev, &video->video_device_list, entry) {
|
|
|
|
if (acpi_video_should_register_backlight(dev))
|
|
|
|
acpi_video_dev_register_backlight(dev);
|
|
|
|
}
|
2013-10-11 13:27:44 +00:00
|
|
|
mutex_unlock(&video->device_list_lock);
|
|
|
|
|
2014-05-15 11:22:33 +00:00
|
|
|
video->backlight_registered = true;
|
|
|
|
|
2013-10-11 13:27:44 +00:00
|
|
|
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;
|
2014-05-15 11:22:33 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!video->backlight_registered)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error = unregister_pm_notifier(&video->pm_nb);
|
2013-10-11 13:27:44 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2014-05-15 11:22:33 +00:00
|
|
|
video->backlight_registered = false;
|
|
|
|
|
2013-10-11 13:27:44 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2010-04-04 23:43:51 +00:00
|
|
|
static int instance;
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
static int acpi_video_bus_add(struct acpi_device *device)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-11-05 16:43:30 +00:00
|
|
|
struct acpi_video_bus *video;
|
|
|
|
int error;
|
2009-12-30 07:59:23 +00:00
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
status = acpi_walk_namespace(ACPI_TYPE_DEVICE,
|
|
|
|
device->parent->handle, 1,
|
|
|
|
acpi_video_bus_match, NULL,
|
|
|
|
device, NULL);
|
|
|
|
if (status == AE_ALREADY_EXISTS) {
|
2021-02-03 18:48:33 +00:00
|
|
|
pr_info(FW_BUG
|
2009-12-30 07:59:23 +00:00
|
|
|
"Duplicate ACPI video bus devices for the"
|
|
|
|
" same VGA controller, please try module "
|
|
|
|
"parameter \"video.allow_duplicates=1\""
|
|
|
|
"if the current driver doesn't work.\n");
|
|
|
|
if (!allow_duplicates)
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-19 20:56:11 +00:00
|
|
|
video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!video)
|
2006-06-27 04:41:40 +00:00
|
|
|
return -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-08-25 06:23:31 +00:00
|
|
|
/* a hack to fix the duplicate name "VID" problem on T61 */
|
|
|
|
if (!strcmp(device->pnp.bus_id, "VID")) {
|
|
|
|
if (instance)
|
|
|
|
device->pnp.bus_id[3] = '0' + instance;
|
2013-08-03 20:12:50 +00:00
|
|
|
instance++;
|
2007-08-25 06:23:31 +00:00
|
|
|
}
|
2009-02-03 03:55:01 +00:00
|
|
|
/* a hack to fix the duplicate name "VGA" problem on Pa 3553 */
|
|
|
|
if (!strcmp(device->pnp.bus_id, "VGA")) {
|
|
|
|
if (instance)
|
|
|
|
device->pnp.bus_id[3] = '0' + instance;
|
|
|
|
instance++;
|
|
|
|
}
|
2007-08-25 06:23:31 +00:00
|
|
|
|
2006-05-19 20:54:40 +00:00
|
|
|
video->device = device;
|
2005-04-16 22:20:36 +00:00
|
|
|
strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
|
|
|
|
strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
|
2008-09-22 21:37:34 +00:00
|
|
|
device->driver_data = video;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
acpi_video_bus_find_cap(video);
|
2007-11-05 16:43:30 +00:00
|
|
|
error = acpi_video_bus_check(video);
|
|
|
|
if (error)
|
|
|
|
goto err_free_video;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-11-05 16:43:32 +00:00
|
|
|
mutex_init(&video->device_list_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
INIT_LIST_HEAD(&video->video_device_list);
|
|
|
|
|
2012-03-30 17:32:08 +00:00
|
|
|
error = acpi_video_bus_get_devices(video, device);
|
|
|
|
if (error)
|
ACPI: video: correct acpi_video_bus_add error processing
acpi_video_bus_get_devices() may fail due to some video output device
doesn't have the _ADR method, and in this case, the error processing
is to simply free the video structure in acpi_video_bus_add(), while
leaving those already registered video output devices in the wild,
which means for some video output device, we have already registered
a backlight interface and installed a notification handler for it.
So it can happen when user is using this system, on hotkey pressing,
the notification handler will send a keycode through a non-existing
input device, causing kernel freeze.
To solve this problem, free all those already registered video output
devices once something goes wrong in acpi_video_bus_get_devices(), so
that no wild backlight interfaces and notification handlers exist.
References: https://bugzilla.kernel.org/show_bug.cgi?id=51731
Reported-and-tested-by: <i-tek@web.de>
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-04-25 02:47:49 +00:00
|
|
|
goto err_put_video;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-02-03 18:48:33 +00:00
|
|
|
pr_info("%s [%s] (multi-head: %s rom: %s post: %s)\n",
|
2005-08-05 04:44:28 +00:00
|
|
|
ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
|
|
|
|
video->flags.multihead ? "yes" : "no",
|
|
|
|
video->flags.rom ? "yes" : "no",
|
|
|
|
video->flags.post ? "yes" : "no");
|
2013-10-11 13:27:44 +00:00
|
|
|
mutex_lock(&video_list_lock);
|
|
|
|
list_add_tail(&video->entry, &video_bus_head);
|
|
|
|
mutex_unlock(&video_list_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-10-11 13:27:44 +00:00
|
|
|
acpi_video_bus_register_backlight(video);
|
|
|
|
acpi_video_bus_add_notify_handler(video);
|
2010-04-04 23:43:51 +00:00
|
|
|
|
2007-11-05 16:43:30 +00:00
|
|
|
return 0;
|
|
|
|
|
2013-10-11 13:27:44 +00:00
|
|
|
err_put_video:
|
2007-11-05 16:43:30 +00:00
|
|
|
acpi_video_bus_put_devices(video);
|
|
|
|
kfree(video->attached_array);
|
2013-10-11 13:27:44 +00:00
|
|
|
err_free_video:
|
2007-11-05 16:43:30 +00:00
|
|
|
kfree(video);
|
2008-09-22 21:37:34 +00:00
|
|
|
device->driver_data = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-11-05 16:43:30 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-01-23 23:24:48 +00:00
|
|
|
static int acpi_video_bus_remove(struct acpi_device *device)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-08-05 04:44:28 +00:00
|
|
|
struct acpi_video_bus *video = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
|
|
|
if (!device || !acpi_driver_data(device))
|
2006-06-27 04:41:40 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-09-30 22:28:50 +00:00
|
|
|
video = acpi_driver_data(device);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-10-11 13:27:44 +00:00
|
|
|
acpi_video_bus_remove_notify_handler(video);
|
|
|
|
acpi_video_bus_unregister_backlight(video);
|
2005-04-16 22:20:36 +00:00
|
|
|
acpi_video_bus_put_devices(video);
|
|
|
|
|
2013-10-11 13:27:44 +00:00
|
|
|
mutex_lock(&video_list_lock);
|
|
|
|
list_del(&video->entry);
|
|
|
|
mutex_unlock(&video_list_lock);
|
|
|
|
|
2005-11-07 09:01:32 +00:00
|
|
|
kfree(video->attached_array);
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(video);
|
|
|
|
|
2006-06-27 04:41:40 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2012-04-25 13:33:48 +00:00
|
|
|
static int __init is_i740(struct pci_dev *dev)
|
|
|
|
{
|
|
|
|
if (dev->device == 0x00D1)
|
|
|
|
return 1;
|
|
|
|
if (dev->device == 0x7000)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-19 21:35:39 +00:00
|
|
|
static int __init intel_opregion_present(void)
|
|
|
|
{
|
2012-04-25 13:33:48 +00:00
|
|
|
int opregion = 0;
|
2009-03-19 21:35:39 +00:00
|
|
|
struct pci_dev *dev = NULL;
|
|
|
|
u32 address;
|
|
|
|
|
|
|
|
for_each_pci_dev(dev) {
|
|
|
|
if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
|
|
|
|
continue;
|
|
|
|
if (dev->vendor != PCI_VENDOR_ID_INTEL)
|
|
|
|
continue;
|
2012-04-25 13:33:48 +00:00
|
|
|
/* We don't want to poke around undefined i740 registers */
|
|
|
|
if (is_i740(dev))
|
|
|
|
continue;
|
2009-03-19 21:35:39 +00:00
|
|
|
pci_read_config_dword(dev, 0xfc, &address);
|
|
|
|
if (!address)
|
|
|
|
continue;
|
2012-04-25 13:33:48 +00:00
|
|
|
opregion = 1;
|
2009-03-19 21:35:39 +00:00
|
|
|
}
|
2012-04-25 13:33:48 +00:00
|
|
|
return opregion;
|
2009-03-19 21:35:39 +00:00
|
|
|
}
|
|
|
|
|
2019-01-07 16:08:20 +00:00
|
|
|
/* Check if the chassis-type indicates there is no builtin LCD panel */
|
2018-04-17 16:23:50 +00:00
|
|
|
static bool dmi_is_desktop(void)
|
|
|
|
{
|
|
|
|
const char *chassis_type;
|
2019-01-07 16:08:20 +00:00
|
|
|
unsigned long type;
|
2018-04-17 16:23:50 +00:00
|
|
|
|
|
|
|
chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE);
|
|
|
|
if (!chassis_type)
|
|
|
|
return false;
|
|
|
|
|
2019-01-07 16:08:20 +00:00
|
|
|
if (kstrtoul(chassis_type, 10, &type) != 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case 0x03: /* Desktop */
|
|
|
|
case 0x04: /* Low Profile Desktop */
|
|
|
|
case 0x05: /* Pizza Box */
|
|
|
|
case 0x06: /* Mini Tower */
|
|
|
|
case 0x07: /* Tower */
|
2019-01-07 16:08:21 +00:00
|
|
|
case 0x10: /* Lunch Box */
|
2019-01-07 16:08:20 +00:00
|
|
|
case 0x11: /* Main Server Chassis */
|
2018-04-17 16:23:50 +00:00
|
|
|
return true;
|
2019-01-07 16:08:20 +00:00
|
|
|
}
|
2018-04-17 16:23:50 +00:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-04-06 21:16:53 +00:00
|
|
|
/*
|
|
|
|
* We're seeing a lot of bogus backlight interfaces on newer machines
|
|
|
|
* without a LCD such as desktops, servers and HDMI sticks. Checking the
|
|
|
|
* lcd flag fixes this, enable this by default on any machines which are:
|
|
|
|
* 1. Win8 ready (where we also prefer the native backlight driver, so
|
|
|
|
* normally the acpi_video code should not register there anyways); *and*
|
|
|
|
* 2.1 Report a desktop/server DMI chassis-type, or
|
|
|
|
* 2.2 Are an ACPI-reduced-hardware platform (and thus won't use the EC for
|
|
|
|
backlight control)
|
|
|
|
*/
|
|
|
|
static bool should_check_lcd_flag(void)
|
|
|
|
{
|
|
|
|
if (!acpi_osi_is_win8())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (dmi_is_desktop())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (acpi_reduced_hardware())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-07-25 19:43:39 +00:00
|
|
|
int acpi_video_register(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2015-06-16 14:27:54 +00:00
|
|
|
int ret = 0;
|
2015-03-01 10:41:38 +00:00
|
|
|
|
2016-01-14 08:41:45 +00:00
|
|
|
mutex_lock(®ister_count_mutex);
|
|
|
|
if (register_count) {
|
2009-06-16 03:23:13 +00:00
|
|
|
/*
|
2013-07-25 19:43:39 +00:00
|
|
|
* if the function of acpi_video_register is already called,
|
2019-12-11 09:37:28 +00:00
|
|
|
* don't register the acpi_video_bus again and return no error.
|
2009-06-16 03:23:13 +00:00
|
|
|
*/
|
2015-06-16 14:27:54 +00:00
|
|
|
goto leave;
|
2009-06-16 03:23:13 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-04-06 21:16:53 +00:00
|
|
|
if (only_lcd == -1)
|
|
|
|
only_lcd = should_check_lcd_flag();
|
2017-12-23 18:41:47 +00:00
|
|
|
|
2015-06-16 14:27:53 +00:00
|
|
|
dmi_check_system(video_dmi_table);
|
|
|
|
|
2015-03-01 10:41:38 +00:00
|
|
|
ret = acpi_bus_register_driver(&acpi_video_bus);
|
|
|
|
if (ret)
|
2015-06-16 14:27:54 +00:00
|
|
|
goto leave;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-06-16 03:23:13 +00:00
|
|
|
/*
|
|
|
|
* When the acpi_video_bus is loaded successfully, increase
|
|
|
|
* the counter reference.
|
|
|
|
*/
|
2016-01-14 08:41:45 +00:00
|
|
|
register_count = 1;
|
2009-06-16 03:23:13 +00:00
|
|
|
|
2015-06-16 14:27:54 +00:00
|
|
|
leave:
|
2016-01-14 08:41:45 +00:00
|
|
|
mutex_unlock(®ister_count_mutex);
|
2015-06-16 14:27:54 +00:00
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2013-07-25 19:43:39 +00:00
|
|
|
EXPORT_SYMBOL(acpi_video_register);
|
2009-03-19 21:35:39 +00:00
|
|
|
|
2009-06-16 03:23:13 +00:00
|
|
|
void acpi_video_unregister(void)
|
|
|
|
{
|
2016-01-14 08:41:45 +00:00
|
|
|
mutex_lock(®ister_count_mutex);
|
|
|
|
if (register_count) {
|
2015-06-16 14:27:54 +00:00
|
|
|
acpi_bus_unregister_driver(&acpi_video_bus);
|
2016-01-14 08:41:45 +00:00
|
|
|
register_count = 0;
|
2009-06-16 03:23:13 +00:00
|
|
|
}
|
2016-01-14 08:41:45 +00:00
|
|
|
mutex_unlock(®ister_count_mutex);
|
2009-06-16 03:23:13 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_video_unregister);
|
|
|
|
|
ACPI / video: Add an acpi_video_unregister_backlight function
Add an acpi_video_unregister_backlight function, which only unregisters
the backlight device, and leaves the acpi_notifier in place. Some acpi_vendor
driver need this as they don't want the acpi_video# backlight device, but do
need the acpi-video driver for hotkey handling.
Chances are that this new acpi_video_unregister_backlight() is actually
what existing acpi_vendor drivers have wanted all along. Currently acpi_vendor
drivers which want to disable the acpi_video# backlight device, make 2 calls:
acpi_video_dmi_promote_vendor();
acpi_video_unregister();
The intention here is to make things independent of when acpi_video_register()
gets called. As acpi_video_register() will get called on acpi-video load time
on non intel gfx machines, while it gets called on i915 load time on intel
gfx machines.
This leads to the following 2 interesting scenarios:
a) intel gfx:
1) acpi-video module gets loaded (as it is a dependency of acpi_vendor
and i915)
2) acpi-video does NOT call acpi_video_register()
3) acpi_vendor loads (lets assume it loads before i915), calls
acpi_video_dmi_promote_vendor(); which sets
ACPI_VIDEO_BACKLIGHT_DMI_VENDOR
4) calls acpi_video_unregister -> not registered, nop
5) i915 loads, calls acpi_video_register
6) acpi_video_register registers the acpi_notifier for the hotkeys,
does NOT register a backlight device because of
ACPI_VIDEO_BACKLIGHT_DMI_VENDOR
b) non intel gfx
1) acpi-video module gets loaded (as it is a dependency acpi_vendor)
2) acpi-video calls acpi_video_register()
3) acpi_video_register registers the acpi_notifier for the hotkeys,
and a backlight device
4) acpi_vendor loads, calls acpi_video_dmi_promote_vendor()
5) calls acpi_video_unregister, this unregisters BOTH the acpi_notifier
for the hotkeys AND the backlight device
So here we have possibly the same acpi_vendor module, making the same calls,
but with different results, in one cases acpi-video does handle hotkeys,
in the other it does not.
Note that the a) scenario turns into b) if we assume the i915 module loads
before the vendor_acpi module, so we also have different behavior depending
on module loading order!
So as said I believe that quite a few existing acpi_vendor modules really
always want the behavior of a), hence this patch adds a new
acpi_video_unregister_backlight() which gives the behavior of a) independent
of module loading order.
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-05-17 08:48:01 +00:00
|
|
|
void acpi_video_unregister_backlight(void)
|
|
|
|
{
|
|
|
|
struct acpi_video_bus *video;
|
|
|
|
|
2016-01-14 08:41:45 +00:00
|
|
|
mutex_lock(®ister_count_mutex);
|
|
|
|
if (register_count) {
|
2015-06-16 14:27:54 +00:00
|
|
|
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);
|
|
|
|
}
|
2016-01-14 08:41:45 +00:00
|
|
|
mutex_unlock(®ister_count_mutex);
|
ACPI / video: Add an acpi_video_unregister_backlight function
Add an acpi_video_unregister_backlight function, which only unregisters
the backlight device, and leaves the acpi_notifier in place. Some acpi_vendor
driver need this as they don't want the acpi_video# backlight device, but do
need the acpi-video driver for hotkey handling.
Chances are that this new acpi_video_unregister_backlight() is actually
what existing acpi_vendor drivers have wanted all along. Currently acpi_vendor
drivers which want to disable the acpi_video# backlight device, make 2 calls:
acpi_video_dmi_promote_vendor();
acpi_video_unregister();
The intention here is to make things independent of when acpi_video_register()
gets called. As acpi_video_register() will get called on acpi-video load time
on non intel gfx machines, while it gets called on i915 load time on intel
gfx machines.
This leads to the following 2 interesting scenarios:
a) intel gfx:
1) acpi-video module gets loaded (as it is a dependency of acpi_vendor
and i915)
2) acpi-video does NOT call acpi_video_register()
3) acpi_vendor loads (lets assume it loads before i915), calls
acpi_video_dmi_promote_vendor(); which sets
ACPI_VIDEO_BACKLIGHT_DMI_VENDOR
4) calls acpi_video_unregister -> not registered, nop
5) i915 loads, calls acpi_video_register
6) acpi_video_register registers the acpi_notifier for the hotkeys,
does NOT register a backlight device because of
ACPI_VIDEO_BACKLIGHT_DMI_VENDOR
b) non intel gfx
1) acpi-video module gets loaded (as it is a dependency acpi_vendor)
2) acpi-video calls acpi_video_register()
3) acpi_video_register registers the acpi_notifier for the hotkeys,
and a backlight device
4) acpi_vendor loads, calls acpi_video_dmi_promote_vendor()
5) calls acpi_video_unregister, this unregisters BOTH the acpi_notifier
for the hotkeys AND the backlight device
So here we have possibly the same acpi_vendor module, making the same calls,
but with different results, in one cases acpi-video does handle hotkeys,
in the other it does not.
Note that the a) scenario turns into b) if we assume the i915 module loads
before the vendor_acpi module, so we also have different behavior depending
on module loading order!
So as said I believe that quite a few existing acpi_vendor modules really
always want the behavior of a), hence this patch adds a new
acpi_video_unregister_backlight() which gives the behavior of a) independent
of module loading order.
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-05-17 08:48:01 +00:00
|
|
|
}
|
|
|
|
|
2015-12-22 18:09:48 +00:00
|
|
|
bool acpi_video_handles_brightness_key_presses(void)
|
|
|
|
{
|
|
|
|
bool have_video_busses;
|
|
|
|
|
|
|
|
mutex_lock(&video_list_lock);
|
|
|
|
have_video_busses = !list_empty(&video_bus_head);
|
|
|
|
mutex_unlock(&video_list_lock);
|
|
|
|
|
2015-12-22 18:09:51 +00:00
|
|
|
return have_video_busses &&
|
|
|
|
(report_key_events & REPORT_BRIGHTNESS_KEY_EVENTS);
|
2015-12-22 18:09:48 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_video_handles_brightness_key_presses);
|
|
|
|
|
2009-03-19 21:35:39 +00:00
|
|
|
/*
|
|
|
|
* This is kind of nasty. Hardware using Intel chipsets may require
|
|
|
|
* the video opregion code to be run first in order to initialise
|
|
|
|
* state before any ACPI video calls are made. To handle this we defer
|
|
|
|
* registration of the video class until the opregion code has run.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int __init acpi_video_init(void)
|
|
|
|
{
|
2015-03-01 10:41:37 +00:00
|
|
|
/*
|
|
|
|
* Let the module load even if ACPI is disabled (e.g. due to
|
|
|
|
* a broken BIOS) so that i915.ko can still be loaded on such
|
|
|
|
* old systems without an AcpiOpRegion.
|
|
|
|
*
|
|
|
|
* acpi_video_register() will report -ENODEV later as well due
|
|
|
|
* to acpi_disabled when i915.ko tries to register itself afterwards.
|
|
|
|
*/
|
|
|
|
if (acpi_disabled)
|
|
|
|
return 0;
|
|
|
|
|
2009-03-19 21:35:39 +00:00
|
|
|
if (intel_opregion_present())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return acpi_video_register();
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-06-16 03:23:13 +00:00
|
|
|
static void __exit acpi_video_exit(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2015-06-16 14:27:52 +00:00
|
|
|
acpi_video_detect_exit();
|
2009-06-16 03:23:13 +00:00
|
|
|
acpi_video_unregister();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(acpi_video_init);
|
|
|
|
module_exit(acpi_video_exit);
|