2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* video.c - ACPI Video Driver ($Revision:$)
|
|
|
|
*
|
|
|
|
* Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
|
|
|
|
* Copyright (C) 2004 Bruno Ducrot <ducrot@poupinou.org>
|
2006-12-19 13:56:14 -07:00
|
|
|
* Copyright (C) 2006 Thomas Tuttle <linux-kernel@ttuttle.net>
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or (at
|
|
|
|
* your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/list.h>
|
2007-11-05 09:43:32 -07:00
|
|
|
#include <linux/mutex.h>
|
2007-08-20 04:23:53 -06:00
|
|
|
#include <linux/input.h>
|
2006-11-10 11:40:34 -07:00
|
|
|
#include <linux/backlight.h>
|
2008-01-17 00:51:22 -07:00
|
|
|
#include <linux/thermal.h>
|
2008-12-11 14:24:52 -07:00
|
|
|
#include <linux/sort.h>
|
2009-03-19 15:35:39 -06: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 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/uaccess.h>
|
2009-07-06 21:40:19 -06:00
|
|
|
#include <linux/dmi.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <acpi/acpi_bus.h>
|
|
|
|
#include <acpi/acpi_drivers.h>
|
2010-04-04 17:43:51 -06:00
|
|
|
#include <linux/suspend.h>
|
2010-01-12 12:17:03 -07:00
|
|
|
#include <acpi/video.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-07-28 14:45:54 -06:00
|
|
|
#define PREFIX "ACPI: "
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define ACPI_VIDEO_CLASS "video"
|
|
|
|
#define ACPI_VIDEO_BUS_NAME "Video Bus"
|
|
|
|
#define ACPI_VIDEO_DEVICE_NAME "Video Device"
|
|
|
|
#define ACPI_VIDEO_NOTIFY_SWITCH 0x80
|
|
|
|
#define ACPI_VIDEO_NOTIFY_PROBE 0x81
|
|
|
|
#define ACPI_VIDEO_NOTIFY_CYCLE 0x82
|
|
|
|
#define ACPI_VIDEO_NOTIFY_NEXT_OUTPUT 0x83
|
|
|
|
#define ACPI_VIDEO_NOTIFY_PREV_OUTPUT 0x84
|
|
|
|
|
2006-12-19 13:56:14 -07:00
|
|
|
#define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS 0x85
|
|
|
|
#define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS 0x86
|
|
|
|
#define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS 0x87
|
|
|
|
#define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS 0x88
|
|
|
|
#define ACPI_VIDEO_NOTIFY_DISPLAY_OFF 0x89
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-10 11:40:34 -07:00
|
|
|
#define MAX_NAME_LEN 20
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define _COMPONENT ACPI_VIDEO_COMPONENT
|
2007-02-12 20:42:12 -07:00
|
|
|
ACPI_MODULE_NAME("video");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-12 20:42:12 -07:00
|
|
|
MODULE_AUTHOR("Bruno Ducrot");
|
2007-02-12 21:50:02 -07:00
|
|
|
MODULE_DESCRIPTION("ACPI Video Driver");
|
2005-04-16 16:20:36 -06:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2008-01-24 23:47:49 -07:00
|
|
|
static int brightness_switch_enabled = 1;
|
|
|
|
module_param(brightness_switch_enabled, bool, 0644);
|
|
|
|
|
2009-12-30 00:59:23 -07:00
|
|
|
/*
|
|
|
|
* By default, we don't allow duplicate ACPI video bus devices
|
|
|
|
* under the same VGA controller
|
|
|
|
*/
|
|
|
|
static int allow_duplicates;
|
|
|
|
module_param(allow_duplicates, bool, 0644);
|
|
|
|
|
2010-12-06 00:04:27 -07:00
|
|
|
/*
|
|
|
|
* Some BIOSes claim they use minimum backlight at boot,
|
|
|
|
* and this may bring dimming screen after boot
|
|
|
|
*/
|
|
|
|
static int use_bios_initial_backlight = 1;
|
|
|
|
module_param(use_bios_initial_backlight, bool, 0644);
|
|
|
|
|
2009-06-15 21:23:13 -06:00
|
|
|
static int register_count = 0;
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_video_bus_add(struct acpi_device *device);
|
|
|
|
static int acpi_video_bus_remove(struct acpi_device *device, int type);
|
2009-04-07 09:37:11 -06:00
|
|
|
static void acpi_video_bus_notify(struct acpi_device *device, u32 event);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-23 06:44:41 -06: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 16:20:36 -06:00
|
|
|
static struct acpi_driver acpi_video_bus = {
|
2007-02-12 21:33:40 -07:00
|
|
|
.name = "video",
|
2005-04-16 16:20:36 -06:00
|
|
|
.class = ACPI_VIDEO_CLASS,
|
2007-07-23 06:44:41 -06:00
|
|
|
.ids = video_device_ids,
|
2005-04-16 16:20:36 -06:00
|
|
|
.ops = {
|
|
|
|
.add = acpi_video_bus_add,
|
|
|
|
.remove = acpi_video_bus_remove,
|
2009-04-07 09:37:11 -06:00
|
|
|
.notify = acpi_video_bus_notify,
|
2005-08-04 22:44:28 -06:00
|
|
|
},
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_video_bus_flags {
|
2005-08-04 22:44:28 -06: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 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_video_bus_cap {
|
2005-08-04 22:44:28 -06: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 */
|
|
|
|
u8 reserved:2;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_video_device_attrib {
|
|
|
|
u32 display_index:4; /* A zero-based instance of the Display */
|
2007-02-20 08:38:40 -07:00
|
|
|
u32 display_port_attachment:4; /*This field differentiates the display type */
|
2005-08-04 22:44:28 -06:00
|
|
|
u32 display_type:4; /*Describe the specific type in use */
|
2007-02-20 08:38:40 -07:00
|
|
|
u32 vendor_specific:4; /*Chipset Vendor Specific */
|
2005-08-04 22:44:28 -06:00
|
|
|
u32 bios_can_detect:1; /*BIOS can detect the device */
|
|
|
|
u32 depend_on_vga:1; /*Non-VGA output device whose power is related to
|
|
|
|
the VGA device. */
|
|
|
|
u32 pipe_id:3; /*For VGA multiple-head devices. */
|
|
|
|
u32 reserved:10; /*Must be 0 */
|
|
|
|
u32 device_id_scheme:1; /*Device ID Scheme */
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_video_enumerated_device {
|
|
|
|
union {
|
|
|
|
u32 int_val;
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_video_device_attrib attrib;
|
2005-04-16 16:20:36 -06:00
|
|
|
} value;
|
|
|
|
struct acpi_video_device *bind_info;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_video_bus {
|
2006-05-19 14:54:40 -06:00
|
|
|
struct acpi_device *device;
|
2005-08-04 22:44:28 -06:00
|
|
|
u8 dos_setting;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct acpi_video_enumerated_device *attached_array;
|
2005-08-04 22:44:28 -06:00
|
|
|
u8 attached_count;
|
|
|
|
struct acpi_video_bus_cap cap;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct acpi_video_bus_flags flags;
|
2005-08-04 22:44:28 -06:00
|
|
|
struct list_head video_device_list;
|
2007-11-05 09:43:32 -07:00
|
|
|
struct mutex device_list_lock; /* protects video_device_list */
|
2007-08-20 04:23:53 -06:00
|
|
|
struct input_dev *input;
|
|
|
|
char phys[32]; /* for input device */
|
2010-04-04 17:43:51 -06:00
|
|
|
struct notifier_block pm_nb;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_video_device_flags {
|
2005-08-04 22:44:28 -06:00
|
|
|
u8 crt:1;
|
|
|
|
u8 lcd:1;
|
|
|
|
u8 tvout:1;
|
2007-01-03 21:40:53 -07:00
|
|
|
u8 dvi:1;
|
2005-08-04 22:44:28 -06:00
|
|
|
u8 bios:1;
|
|
|
|
u8 unknown:1;
|
2007-01-03 21:40:53 -07:00
|
|
|
u8 reserved:2;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_video_device_cap {
|
2005-08-04 22:44:28 -06: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 11:40:34 -07:00
|
|
|
u8 _BQC:1; /* Get current brightness level */
|
2009-03-18 02:27:18 -06:00
|
|
|
u8 _BCQ:1; /* Some buggy BIOS uses _BCQ instead of _BQC */
|
2005-08-04 22:44:28 -06:00
|
|
|
u8 _DDC:1; /*Return the EDID for this device */
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2009-03-18 02:27:12 -06:00
|
|
|
struct acpi_video_brightness_flags {
|
|
|
|
u8 _BCL_no_ac_battery_levels:1; /* no AC/Battery levels in _BCL */
|
2009-03-18 02:27:14 -06:00
|
|
|
u8 _BCL_reversed:1; /* _BCL package is in a reversed order*/
|
2009-03-18 02:27:16 -06:00
|
|
|
u8 _BCL_use_index:1; /* levels in _BCL are index values */
|
|
|
|
u8 _BCM_use_index:1; /* input of _BCM is an index value */
|
|
|
|
u8 _BQC_use_index:1; /* _BQC returns an index value */
|
2009-03-18 02:27:12 -06:00
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct acpi_video_device_brightness {
|
2005-08-04 22:44:28 -06:00
|
|
|
int curr;
|
|
|
|
int count;
|
|
|
|
int *levels;
|
2009-03-18 02:27:12 -06:00
|
|
|
struct acpi_video_brightness_flags flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_video_device {
|
2005-08-04 22:44:28 -06:00
|
|
|
unsigned long device_id;
|
|
|
|
struct acpi_video_device_flags flags;
|
|
|
|
struct acpi_video_device_cap cap;
|
|
|
|
struct list_head entry;
|
|
|
|
struct acpi_video_bus *video;
|
|
|
|
struct acpi_device *dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct acpi_video_device_brightness *brightness;
|
2006-11-10 11:40:34 -07:00
|
|
|
struct backlight_device *backlight;
|
2009-08-29 21:03:16 -06:00
|
|
|
struct thermal_cooling_device *cooling_dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2009-01-11 16:08:19 -07:00
|
|
|
static const char device_decode[][30] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
"motherboard VGA device",
|
|
|
|
"PCI VGA device",
|
|
|
|
"AGP VGA device",
|
|
|
|
"UNKNOWN",
|
|
|
|
};
|
|
|
|
|
2005-08-04 22:44:28 -06: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 16:20:36 -06:00
|
|
|
static int acpi_video_device_enumerate(struct acpi_video_bus *video);
|
2006-11-10 11:40:34 -07: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,
|
2010-02-16 14:53:50 -07:00
|
|
|
unsigned long long *level, int init);
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_video_get_next_level(struct acpi_video_device *device,
|
|
|
|
u32 level_current, u32 event);
|
2009-03-18 02:27:08 -06:00
|
|
|
static int acpi_video_switch_brightness(struct acpi_video_device *device,
|
2005-08-04 22:44:28 -06:00
|
|
|
int event);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-10 11:40:34 -07:00
|
|
|
/*backlight device sysfs support*/
|
|
|
|
static int acpi_video_get_brightness(struct backlight_device *bd)
|
|
|
|
{
|
2008-10-10 00:22:59 -06:00
|
|
|
unsigned long long cur_level;
|
2007-12-25 19:03:26 -07:00
|
|
|
int i;
|
2006-11-10 11:40:34 -07:00
|
|
|
struct acpi_video_device *vd =
|
2007-07-09 05:17:24 -06:00
|
|
|
(struct acpi_video_device *)bl_get_data(bd);
|
2009-03-18 02:27:08 -06:00
|
|
|
|
2010-02-16 14:53:50 -07:00
|
|
|
if (acpi_video_device_lcd_get_level_current(vd, &cur_level, 0))
|
2009-03-18 02:27:08 -06:00
|
|
|
return -EINVAL;
|
2007-12-25 19:03:26 -07:00
|
|
|
for (i = 2; i < vd->brightness->count; i++) {
|
|
|
|
if (vd->brightness->levels[i] == cur_level)
|
|
|
|
/* The first two entries are special - see page 575
|
|
|
|
of the ACPI spec 3.0 */
|
|
|
|
return i-2;
|
|
|
|
}
|
|
|
|
return 0;
|
2006-11-10 11:40:34 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_video_set_brightness(struct backlight_device *bd)
|
|
|
|
{
|
2009-03-18 02:27:10 -06:00
|
|
|
int request_level = bd->props.brightness + 2;
|
2006-11-10 11:40:34 -07:00
|
|
|
struct acpi_video_device *vd =
|
2007-07-09 05:17:24 -06:00
|
|
|
(struct acpi_video_device *)bl_get_data(bd);
|
2009-03-18 02:27:10 -06:00
|
|
|
|
|
|
|
return acpi_video_device_lcd_set_level(vd,
|
|
|
|
vd->brightness->levels[request_level]);
|
2006-11-10 11:40:34 -07:00
|
|
|
}
|
|
|
|
|
2010-11-16 06:14:02 -07:00
|
|
|
static const struct backlight_ops acpi_backlight_ops = {
|
2007-02-10 16:07:48 -07:00
|
|
|
.get_brightness = acpi_video_get_brightness,
|
|
|
|
.update_status = acpi_video_set_brightness,
|
|
|
|
};
|
|
|
|
|
2008-01-17 00:51:22 -07:00
|
|
|
/* thermal cooling device callbacks */
|
2009-08-29 21:03:16 -06:00
|
|
|
static int video_get_max_state(struct thermal_cooling_device *cooling_dev, unsigned
|
2008-11-27 10:48:13 -07:00
|
|
|
long *state)
|
2008-01-17 00:51:22 -07:00
|
|
|
{
|
2009-08-29 21:03:16 -06:00
|
|
|
struct acpi_device *device = cooling_dev->devdata;
|
2008-01-17 00:51:22 -07:00
|
|
|
struct acpi_video_device *video = acpi_driver_data(device);
|
|
|
|
|
2008-11-27 10:48:13 -07:00
|
|
|
*state = video->brightness->count - 3;
|
|
|
|
return 0;
|
2008-01-17 00:51:22 -07:00
|
|
|
}
|
|
|
|
|
2009-08-29 21:03:16 -06:00
|
|
|
static int video_get_cur_state(struct thermal_cooling_device *cooling_dev, unsigned
|
2008-11-27 10:48:13 -07:00
|
|
|
long *state)
|
2008-01-17 00:51:22 -07:00
|
|
|
{
|
2009-08-29 21:03:16 -06:00
|
|
|
struct acpi_device *device = cooling_dev->devdata;
|
2008-01-17 00:51:22 -07:00
|
|
|
struct acpi_video_device *video = acpi_driver_data(device);
|
2008-10-10 00:22:59 -06:00
|
|
|
unsigned long long level;
|
2008-11-27 10:48:13 -07:00
|
|
|
int offset;
|
2008-01-17 00:51:22 -07:00
|
|
|
|
2010-02-16 14:53:50 -07:00
|
|
|
if (acpi_video_device_lcd_get_level_current(video, &level, 0))
|
2009-03-18 02:27:08 -06:00
|
|
|
return -EINVAL;
|
2008-11-27 10:48:13 -07:00
|
|
|
for (offset = 2; offset < video->brightness->count; offset++)
|
|
|
|
if (level == video->brightness->levels[offset]) {
|
|
|
|
*state = video->brightness->count - offset - 1;
|
|
|
|
return 0;
|
|
|
|
}
|
2008-01-17 00:51:22 -07:00
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2009-08-29 21:03:16 -06:00
|
|
|
video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long state)
|
2008-01-17 00:51:22 -07:00
|
|
|
{
|
2009-08-29 21:03:16 -06:00
|
|
|
struct acpi_device *device = cooling_dev->devdata;
|
2008-01-17 00:51:22 -07:00
|
|
|
struct acpi_video_device *video = acpi_driver_data(device);
|
|
|
|
int level;
|
|
|
|
|
|
|
|
if ( state >= video->brightness->count - 2)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
state = video->brightness->count - state;
|
|
|
|
level = video->brightness->levels[state -1];
|
|
|
|
return acpi_video_device_lcd_set_level(video, level);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct thermal_cooling_device_ops video_cooling_ops = {
|
|
|
|
.get_max_state = video_get_max_state,
|
|
|
|
.get_cur_state = video_get_cur_state,
|
|
|
|
.set_cur_state = video_set_cur_state,
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Video Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static int
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_video_device_lcd_query_levels(struct acpi_video_device *device,
|
|
|
|
union acpi_object **levels)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
int status;
|
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
union acpi_object *obj;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
*levels = NULL;
|
|
|
|
|
2006-05-19 14:54:48 -06:00
|
|
|
status = acpi_evaluate_object(device->dev->handle, "_BCL", NULL, &buffer);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!ACPI_SUCCESS(status))
|
2006-06-26 22:41:40 -06:00
|
|
|
return status;
|
2005-08-04 22:44:28 -06:00
|
|
|
obj = (union acpi_object *)buffer.pointer;
|
2006-03-11 08:12:00 -07:00
|
|
|
if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
|
2006-06-26 21:41:38 -06:00
|
|
|
printk(KERN_ERR PREFIX "Invalid _BCL data\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
status = -EFAULT;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
*levels = obj;
|
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
err:
|
2005-11-07 02:01:32 -07:00
|
|
|
kfree(buffer.pointer);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return status;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-03-18 02:27:10 -06:00
|
|
|
int status;
|
2005-08-04 22:44:28 -06:00
|
|
|
union acpi_object arg0 = { ACPI_TYPE_INTEGER };
|
|
|
|
struct acpi_object_list args = { 1, &arg0 };
|
2008-12-30 19:58:48 -07:00
|
|
|
int state;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
arg0.integer.value = level;
|
|
|
|
|
2009-03-18 02:27:10 -06:00
|
|
|
status = acpi_evaluate_object(device->dev->handle, "_BCM",
|
|
|
|
&args, NULL);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
ACPI_ERROR((AE_INFO, "Evaluating _BCM failed"));
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2007-09-03 06:29:58 -06:00
|
|
|
device->brightness->curr = level;
|
2008-12-30 19:58:48 -07:00
|
|
|
for (state = 2; state < device->brightness->count; state++)
|
2009-03-18 02:27:10 -06:00
|
|
|
if (level == device->brightness->levels[state]) {
|
2009-03-18 02:27:16 -06:00
|
|
|
if (device->backlight)
|
|
|
|
device->backlight->props.brightness = state - 2;
|
2009-03-18 02:27:10 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2008-12-30 19:58:48 -07:00
|
|
|
|
2009-03-18 02:27:10 -06:00
|
|
|
ACPI_ERROR((AE_INFO, "Current brightness invalid"));
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-04-24 10:13:18 -06: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;
|
|
|
|
static int __init video_set_bqc_offset(const struct dmi_system_id *d)
|
|
|
|
{
|
|
|
|
bqc_offset_aml_bug_workaround = 9;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dmi_system_id video_dmi_table[] __initdata = {
|
|
|
|
/*
|
|
|
|
* 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-07 19:11:56 -06: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-26 21:35:34 -06: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 13:08:41 -06: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-21 21:31:18 -06:00
|
|
|
{
|
|
|
|
.callback = video_set_bqc_offset,
|
|
|
|
.ident = "Acer Aspire 7720",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7720"),
|
|
|
|
},
|
|
|
|
},
|
2009-04-24 10:13:18 -06:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
|
2010-02-16 14:53:50 -07:00
|
|
|
unsigned long long *level, int init)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-03-18 02:27:08 -06:00
|
|
|
acpi_status status = AE_OK;
|
2009-06-24 01:17:36 -06:00
|
|
|
int i;
|
2009-03-18 02:27:08 -06:00
|
|
|
|
2009-03-18 02:27:18 -06: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 02:27:08 -06:00
|
|
|
NULL, level);
|
|
|
|
if (ACPI_SUCCESS(status)) {
|
2009-03-18 02:27:16 -06:00
|
|
|
if (device->brightness->flags._BQC_use_index) {
|
|
|
|
if (device->brightness->flags._BCL_reversed)
|
|
|
|
*level = device->brightness->count
|
|
|
|
- 3 - (*level);
|
|
|
|
*level = device->brightness->levels[*level + 2];
|
|
|
|
|
|
|
|
}
|
2009-04-24 10:13:18 -06:00
|
|
|
*level += bqc_offset_aml_bug_workaround;
|
2009-06-24 01:17:36 -06:00
|
|
|
for (i = 2; i < device->brightness->count; i++)
|
|
|
|
if (device->brightness->levels[i] == *level) {
|
|
|
|
device->brightness->curr = *level;
|
|
|
|
return 0;
|
|
|
|
}
|
2010-02-16 14:53:50 -07:00
|
|
|
if (!init) {
|
|
|
|
/*
|
|
|
|
* BQC returned an invalid level.
|
|
|
|
* Stop using it.
|
|
|
|
*/
|
|
|
|
ACPI_WARNING((AE_INFO,
|
|
|
|
"%s returned an invalid level",
|
|
|
|
buf));
|
|
|
|
device->cap._BQC = device->cap._BCQ = 0;
|
|
|
|
}
|
2009-03-18 02:27:08 -06:00
|
|
|
} else {
|
|
|
|
/* Fixme:
|
|
|
|
* 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
|
|
|
|
*/
|
2009-03-18 02:27:18 -06:00
|
|
|
ACPI_WARNING((AE_INFO, "Evaluating %s failed", buf));
|
|
|
|
device->cap._BQC = device->cap._BCQ = 0;
|
2009-03-18 02:27:08 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-03 06:29:58 -06:00
|
|
|
*level = device->brightness->curr;
|
2009-03-18 02:27:08 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_video_device_EDID(struct acpi_video_device *device,
|
|
|
|
union acpi_object **edid, ssize_t length)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06: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 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
*edid = NULL;
|
|
|
|
|
|
|
|
if (!device)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (length == 128)
|
|
|
|
arg0.integer.value = 1;
|
|
|
|
else if (length == 256)
|
|
|
|
arg0.integer.value = 2;
|
|
|
|
else
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-05-19 14:54:48 -06:00
|
|
|
status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ACPI_FAILURE(status))
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-09-30 16:28:50 -06:00
|
|
|
obj = buffer.pointer;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (obj && obj->type == ACPI_TYPE_BUFFER)
|
|
|
|
*edid = obj;
|
|
|
|
else {
|
2006-06-26 21:41:38 -06:00
|
|
|
printk(KERN_ERR PREFIX "Invalid _DDC data\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
status = -EFAULT;
|
|
|
|
kfree(obj);
|
|
|
|
}
|
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return status;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* bus */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Arg:
|
|
|
|
* video : video bus device pointer
|
|
|
|
* bios_flag :
|
|
|
|
* 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 08:38:40 -07:00
|
|
|
* active display output. No switch event.
|
2005-04-16 16:20:36 -06: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
|
2007-02-20 08:38:40 -07:00
|
|
|
* of the LCD when the power changes from AC to DC
|
2005-04-16 16:20:36 -06:00
|
|
|
* 1. The system BIOS should NOT automatically control the brightness
|
2007-02-20 08:38:40 -07:00
|
|
|
* level of the LCD when the power changes from AC to DC.
|
2005-04-16 16:20:36 -06:00
|
|
|
* Return Value:
|
|
|
|
* -1 wrong arg.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-01-27 19:53:19 -07:00
|
|
|
u64 status = 0;
|
2005-08-04 22:44:28 -06:00
|
|
|
union acpi_object arg0 = { ACPI_TYPE_INTEGER };
|
|
|
|
struct acpi_object_list args = { 1, &arg0 };
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1) {
|
2005-04-16 16:20:36 -06:00
|
|
|
status = -1;
|
|
|
|
goto Failed;
|
|
|
|
}
|
|
|
|
arg0.integer.value = (lcd_flag << 2) | bios_flag;
|
|
|
|
video->dos_setting = arg0.integer.value;
|
2006-05-19 14:54:48 -06:00
|
|
|
acpi_evaluate_object(video->device->handle, "_DOS", &args, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
Failed:
|
2006-06-26 22:41:40 -06:00
|
|
|
return status;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-12-11 14:24:52 -07: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;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Arg:
|
|
|
|
* device : video output device (LCD, CRT, ..)
|
|
|
|
*
|
|
|
|
* Return Value:
|
2008-06-23 15:50:42 -06:00
|
|
|
* Maximum brightness level
|
|
|
|
*
|
|
|
|
* Allocate and initialize device->brightness.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
|
|
|
acpi_video_init_brightness(struct acpi_video_device *device)
|
|
|
|
{
|
|
|
|
union acpi_object *obj = NULL;
|
2009-03-18 02:27:12 -06:00
|
|
|
int i, max_level = 0, count = 0, level_ac_battery = 0;
|
2009-03-18 02:27:16 -06:00
|
|
|
unsigned long long level, level_old;
|
2008-06-23 15:50:42 -06:00
|
|
|
union acpi_object *o;
|
|
|
|
struct acpi_video_device_brightness *br = NULL;
|
2009-03-18 02:27:16 -06:00
|
|
|
int result = -EINVAL;
|
2008-06-23 15:50:42 -06:00
|
|
|
|
|
|
|
if (!ACPI_SUCCESS(acpi_video_device_lcd_query_levels(device, &obj))) {
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Could not query available "
|
|
|
|
"LCD brightness level\n"));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (obj->package.count < 2)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
br = kzalloc(sizeof(*br), GFP_KERNEL);
|
|
|
|
if (!br) {
|
|
|
|
printk(KERN_ERR "can't allocate memory\n");
|
2009-03-18 02:27:16 -06:00
|
|
|
result = -ENOMEM;
|
2008-06-23 15:50:42 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-03-18 02:27:12 -06:00
|
|
|
br->levels = kmalloc((obj->package.count + 2) * sizeof *(br->levels),
|
2008-06-23 15:50:42 -06:00
|
|
|
GFP_KERNEL);
|
2009-03-18 02:27:16 -06:00
|
|
|
if (!br->levels) {
|
|
|
|
result = -ENOMEM;
|
2008-06-23 15:50:42 -06:00
|
|
|
goto out_free;
|
2009-03-18 02:27:16 -06:00
|
|
|
}
|
2008-06-23 15:50:42 -06:00
|
|
|
|
|
|
|
for (i = 0; i < obj->package.count; i++) {
|
|
|
|
o = (union acpi_object *)&obj->package.elements[i];
|
|
|
|
if (o->type != ACPI_TYPE_INTEGER) {
|
|
|
|
printk(KERN_ERR PREFIX "Invalid data\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
br->levels[count] = (u32) o->integer.value;
|
|
|
|
|
|
|
|
if (br->levels[count] > max_level)
|
|
|
|
max_level = br->levels[count];
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
2009-03-18 02:27:12 -06: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.
|
|
|
|
*/
|
2009-04-13 21:02:18 -06:00
|
|
|
for (i = 2; i < count; i++) {
|
|
|
|
if (br->levels[i] == br->levels[0])
|
2009-03-18 02:27:12 -06:00
|
|
|
level_ac_battery++;
|
2009-04-13 21:02:18 -06:00
|
|
|
if (br->levels[i] == br->levels[1])
|
|
|
|
level_ac_battery++;
|
|
|
|
}
|
2009-03-18 02:27:12 -06:00
|
|
|
|
|
|
|
if (level_ac_battery < 2) {
|
|
|
|
level_ac_battery = 2 - level_ac_battery;
|
|
|
|
br->flags._BCL_no_ac_battery_levels = 1;
|
|
|
|
for (i = (count - 1 + level_ac_battery); i >= 2; i--)
|
|
|
|
br->levels[i] = br->levels[i - level_ac_battery];
|
|
|
|
count += level_ac_battery;
|
|
|
|
} else if (level_ac_battery > 2)
|
|
|
|
ACPI_ERROR((AE_INFO, "Too many duplicates in _BCL package\n"));
|
|
|
|
|
2009-03-18 02:27:14 -06:00
|
|
|
/* Check if the _BCL package is in a reversed order */
|
|
|
|
if (max_level == br->levels[2]) {
|
|
|
|
br->flags._BCL_reversed = 1;
|
|
|
|
sort(&br->levels[2], count - 2, sizeof(br->levels[2]),
|
|
|
|
acpi_video_cmp_level, NULL);
|
|
|
|
} else if (max_level != br->levels[count - 1])
|
|
|
|
ACPI_ERROR((AE_INFO,
|
|
|
|
"Found unordered _BCL package\n"));
|
2008-06-23 15:50:42 -06:00
|
|
|
|
|
|
|
br->count = count;
|
|
|
|
device->brightness = br;
|
2009-03-18 02:27:16 -06:00
|
|
|
|
|
|
|
/* Check the input/output of _BQC/_BCL/_BCM */
|
|
|
|
if ((max_level < 100) && (max_level <= (count - 2)))
|
|
|
|
br->flags._BCL_use_index = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* _BCM is always consistent with _BCL,
|
|
|
|
* at least for all the laptops we have ever seen.
|
|
|
|
*/
|
|
|
|
br->flags._BCM_use_index = br->flags._BCL_use_index;
|
|
|
|
|
|
|
|
/* _BQC uses INDEX while _BCL uses VALUE in some laptops */
|
2009-08-31 10:39:54 -06:00
|
|
|
br->curr = level = max_level;
|
2009-04-09 00:24:35 -06:00
|
|
|
|
|
|
|
if (!device->cap._BQC)
|
|
|
|
goto set_level;
|
|
|
|
|
2010-02-16 14:53:50 -07:00
|
|
|
result = acpi_video_device_lcd_get_level_current(device, &level_old, 1);
|
2009-03-18 02:27:16 -06:00
|
|
|
if (result)
|
|
|
|
goto out_free_levels;
|
|
|
|
|
2009-04-09 00:24:35 -06:00
|
|
|
/*
|
|
|
|
* Set the level to maximum and check if _BQC uses indexed value
|
|
|
|
*/
|
|
|
|
result = acpi_video_device_lcd_set_level(device, max_level);
|
2009-03-18 02:27:16 -06:00
|
|
|
if (result)
|
|
|
|
goto out_free_levels;
|
|
|
|
|
2010-02-16 14:53:50 -07:00
|
|
|
result = acpi_video_device_lcd_get_level_current(device, &level, 0);
|
2009-03-18 02:27:16 -06:00
|
|
|
if (result)
|
|
|
|
goto out_free_levels;
|
|
|
|
|
2009-04-09 00:24:35 -06:00
|
|
|
br->flags._BQC_use_index = (level == max_level ? 0 : 1);
|
|
|
|
|
2009-08-31 10:39:54 -06:00
|
|
|
if (!br->flags._BQC_use_index) {
|
|
|
|
/*
|
|
|
|
* Set the backlight to the initial state.
|
|
|
|
* On some buggy laptops, _BQC returns an uninitialized value
|
|
|
|
* when invoked for the first time, i.e. level_old is invalid.
|
|
|
|
* set the backlight to max_level in this case
|
|
|
|
*/
|
2010-12-06 00:04:27 -07:00
|
|
|
if (use_bios_initial_backlight) {
|
|
|
|
for (i = 2; i < br->count; i++)
|
|
|
|
if (level_old == br->levels[i])
|
|
|
|
level = level_old;
|
|
|
|
}
|
2009-04-09 00:24:35 -06:00
|
|
|
goto set_level;
|
2009-08-31 10:39:54 -06:00
|
|
|
}
|
2009-04-09 00:24:35 -06:00
|
|
|
|
|
|
|
if (br->flags._BCL_reversed)
|
|
|
|
level_old = (br->count - 1) - level_old;
|
2009-08-31 10:39:54 -06:00
|
|
|
level = br->levels[level_old];
|
2009-04-09 00:24:35 -06:00
|
|
|
|
|
|
|
set_level:
|
2009-08-31 10:39:54 -06:00
|
|
|
result = acpi_video_device_lcd_set_level(device, level);
|
2009-04-09 00:24:35 -06:00
|
|
|
if (result)
|
|
|
|
goto out_free_levels;
|
2009-03-18 02:27:16 -06:00
|
|
|
|
2009-03-18 02:27:12 -06:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"found %d brightness levels\n", count - 2));
|
2008-06-23 15:50:42 -06:00
|
|
|
kfree(obj);
|
2009-03-18 02:27:16 -06:00
|
|
|
return result;
|
2008-06-23 15:50:42 -06:00
|
|
|
|
|
|
|
out_free_levels:
|
|
|
|
kfree(br->levels);
|
|
|
|
out_free:
|
|
|
|
kfree(br);
|
|
|
|
out:
|
|
|
|
device->brightness = NULL;
|
|
|
|
kfree(obj);
|
2009-03-18 02:27:16 -06:00
|
|
|
return result;
|
2008-06-23 15:50:42 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Arg:
|
|
|
|
* device : video output device (LCD, CRT, ..)
|
|
|
|
*
|
|
|
|
* Return Value:
|
2005-04-16 16:20:36 -06:00
|
|
|
* None
|
|
|
|
*
|
2007-02-20 08:38:40 -07:00
|
|
|
* Find out all required AML methods defined under the output
|
2005-04-16 16:20:36 -06:00
|
|
|
* device.
|
|
|
|
*/
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static void acpi_video_device_find_cap(struct acpi_video_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
acpi_handle h_dummy1;
|
|
|
|
|
2006-05-19 14:54:48 -06:00
|
|
|
if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_ADR", &h_dummy1))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
device->cap._ADR = 1;
|
|
|
|
}
|
2006-05-19 14:54:48 -06:00
|
|
|
if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCL", &h_dummy1))) {
|
2005-08-04 22:44:28 -06:00
|
|
|
device->cap._BCL = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-05-19 14:54:48 -06:00
|
|
|
if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCM", &h_dummy1))) {
|
2005-08-04 22:44:28 -06:00
|
|
|
device->cap._BCM = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-11-10 11:40:34 -07:00
|
|
|
if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle,"_BQC",&h_dummy1)))
|
|
|
|
device->cap._BQC = 1;
|
2009-03-18 02:27:18 -06:00
|
|
|
else if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCQ",
|
|
|
|
&h_dummy1))) {
|
|
|
|
printk(KERN_WARNING FW_BUG "_BCQ is used instead of _BQC\n");
|
|
|
|
device->cap._BCQ = 1;
|
|
|
|
}
|
|
|
|
|
2006-05-19 14:54:48 -06:00
|
|
|
if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DDC", &h_dummy1))) {
|
2005-08-04 22:44:28 -06:00
|
|
|
device->cap._DDC = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-03-18 02:27:16 -06:00
|
|
|
if (acpi_video_backlight_support()) {
|
2010-02-17 14:39:44 -07:00
|
|
|
struct backlight_properties props;
|
2008-01-17 00:51:22 -07:00
|
|
|
int result;
|
2006-11-10 11:40:34 -07:00
|
|
|
static int count = 0;
|
|
|
|
char *name;
|
2009-03-18 02:27:16 -06:00
|
|
|
|
|
|
|
result = acpi_video_init_brightness(device);
|
|
|
|
if (result)
|
|
|
|
return;
|
2010-04-27 15:06:04 -06:00
|
|
|
name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
|
2006-11-10 11:40:34 -07:00
|
|
|
if (!name)
|
|
|
|
return;
|
2010-04-27 15:06:04 -06:00
|
|
|
count++;
|
2006-11-10 11:40:34 -07:00
|
|
|
|
2010-02-17 14:39:44 -07:00
|
|
|
memset(&props, 0, sizeof(struct backlight_properties));
|
2011-03-22 17:30:21 -06:00
|
|
|
props.type = BACKLIGHT_FIRMWARE;
|
2010-02-17 14:39:44 -07:00
|
|
|
props.max_brightness = device->brightness->count - 3;
|
|
|
|
device->backlight = backlight_device_register(name, NULL, device,
|
|
|
|
&acpi_backlight_ops,
|
|
|
|
&props);
|
2006-11-10 11:40:34 -07:00
|
|
|
kfree(name);
|
2009-07-28 18:53:29 -06:00
|
|
|
if (IS_ERR(device->backlight))
|
|
|
|
return;
|
2008-01-17 00:51:22 -07:00
|
|
|
|
2010-04-04 17:43:51 -06: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);
|
2008-01-17 00:51:22 -07:00
|
|
|
|
2009-06-21 21:31:14 -06:00
|
|
|
result = sysfs_create_link(&device->backlight->dev.kobj,
|
|
|
|
&device->dev->dev.kobj, "device");
|
|
|
|
if (result)
|
|
|
|
printk(KERN_ERR PREFIX "Create sysfs link\n");
|
|
|
|
|
2009-08-29 21:03:16 -06:00
|
|
|
device->cooling_dev = thermal_cooling_device_register("LCD",
|
2008-01-17 00:51:22 -07:00
|
|
|
device->dev, &video_cooling_ops);
|
2009-08-29 21:03:16 -06:00
|
|
|
if (IS_ERR(device->cooling_dev)) {
|
2009-08-08 01:26:25 -06:00
|
|
|
/*
|
2009-08-29 21:03:16 -06:00
|
|
|
* Set cooling_dev to NULL so we don't crash trying to
|
2009-08-08 01:26:25 -06:00
|
|
|
* free it.
|
|
|
|
* Also, why the hell we are returning early and
|
|
|
|
* not attempt to register video output if cooling
|
|
|
|
* device registration failed?
|
|
|
|
* -- dtor
|
|
|
|
*/
|
2009-08-29 21:03:16 -06:00
|
|
|
device->cooling_dev = NULL;
|
2008-02-15 16:29:18 -07:00
|
|
|
return;
|
2009-08-08 01:26:25 -06:00
|
|
|
}
|
2008-02-15 16:29:18 -07:00
|
|
|
|
2008-05-01 22:02:41 -06:00
|
|
|
dev_info(&device->dev->dev, "registered as cooling_device%d\n",
|
2009-08-29 21:03:16 -06:00
|
|
|
device->cooling_dev->id);
|
2008-04-10 20:09:24 -06:00
|
|
|
result = sysfs_create_link(&device->dev->dev.kobj,
|
2009-08-29 21:03:16 -06:00
|
|
|
&device->cooling_dev->device.kobj,
|
2008-04-10 20:09:24 -06:00
|
|
|
"thermal_cooling");
|
|
|
|
if (result)
|
|
|
|
printk(KERN_ERR PREFIX "Create sysfs link\n");
|
2009-08-29 21:03:16 -06:00
|
|
|
result = sysfs_create_link(&device->cooling_dev->device.kobj,
|
2008-04-10 20:09:24 -06:00
|
|
|
&device->dev->dev.kobj, "device");
|
|
|
|
if (result)
|
|
|
|
printk(KERN_ERR PREFIX "Create sysfs link\n");
|
|
|
|
|
2006-11-10 11:40:34 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Arg:
|
|
|
|
* device : video output device (VGA)
|
|
|
|
*
|
|
|
|
* Return Value:
|
|
|
|
* None
|
|
|
|
*
|
2007-02-20 08:38:40 -07:00
|
|
|
* Find out all required AML methods defined under the video bus device.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_handle h_dummy1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-05-19 14:54:48 -06:00
|
|
|
if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOS", &h_dummy1))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
video->cap._DOS = 1;
|
|
|
|
}
|
2006-05-19 14:54:48 -06:00
|
|
|
if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOD", &h_dummy1))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
video->cap._DOD = 1;
|
|
|
|
}
|
2006-05-19 14:54:48 -06:00
|
|
|
if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_ROM", &h_dummy1))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
video->cap._ROM = 1;
|
|
|
|
}
|
2006-05-19 14:54:48 -06:00
|
|
|
if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_GPD", &h_dummy1))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
video->cap._GPD = 1;
|
|
|
|
}
|
2006-05-19 14:54:48 -06:00
|
|
|
if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_SPD", &h_dummy1))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
video->cap._SPD = 1;
|
|
|
|
}
|
2006-05-19 14:54:48 -06:00
|
|
|
if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_VPO", &h_dummy1))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
video->cap._VPO = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check whether the video bus device has required AML method to
|
|
|
|
* support the desired features
|
|
|
|
*/
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_video_bus_check(struct acpi_video_bus *video)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_status status = -ENOENT;
|
2009-06-10 13:56:00 -06:00
|
|
|
struct pci_dev *dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!video)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-06-10 13:56:00 -06:00
|
|
|
dev = acpi_get_pci_dev(video->device->handle);
|
2008-08-01 09:37:54 -06:00
|
|
|
if (!dev)
|
|
|
|
return -ENODEV;
|
2009-06-10 13:56:00 -06:00
|
|
|
pci_dev_put(dev);
|
2008-08-01 09:37:54 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Since there is no HID, CID and so on for VGA driver, we have
|
|
|
|
* to check well known required nodes.
|
|
|
|
*/
|
|
|
|
|
2007-02-20 08:38:40 -07:00
|
|
|
/* Does this device support video switching? */
|
2009-08-21 03:03:05 -06:00
|
|
|
if (video->cap._DOS || video->cap._DOD) {
|
|
|
|
if (!video->cap._DOS) {
|
|
|
|
printk(KERN_WARNING FW_BUG
|
|
|
|
"ACPI(%s) defines _DOD but not _DOS\n",
|
|
|
|
acpi_device_bid(video->device));
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
video->flags.multihead = 1;
|
|
|
|
status = 0;
|
|
|
|
}
|
|
|
|
|
2007-02-20 08:38:40 -07:00
|
|
|
/* Does this device support retrieving a video ROM? */
|
2005-08-04 22:44:28 -06:00
|
|
|
if (video->cap._ROM) {
|
2005-04-16 16:20:36 -06:00
|
|
|
video->flags.rom = 1;
|
|
|
|
status = 0;
|
|
|
|
}
|
|
|
|
|
2007-02-20 08:38:40 -07:00
|
|
|
/* Does this device support configuring which video device to POST? */
|
2005-08-04 22:44:28 -06:00
|
|
|
if (video->cap._GPD && video->cap._SPD && video->cap._VPO) {
|
2005-04-16 16:20:36 -06:00
|
|
|
video->flags.post = 1;
|
|
|
|
status = 0;
|
|
|
|
}
|
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return status;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Driver Interface
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/* device interface */
|
2007-01-03 21:40:53 -07:00
|
|
|
static struct acpi_video_device_attrib*
|
|
|
|
acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id)
|
|
|
|
{
|
2007-11-05 09:43:33 -07: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-03 21:40:53 -07:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-01-12 12:17:03 -07: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 16:20:36 -06:00
|
|
|
static int
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_video_bus_get_one_device(struct acpi_device *device,
|
|
|
|
struct acpi_video_bus *video)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-10-10 00:22:59 -06:00
|
|
|
unsigned long long device_id;
|
2010-01-12 12:17:03 -07:00
|
|
|
int status, device_type;
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_video_device *data;
|
2007-01-03 21:40:53 -07:00
|
|
|
struct acpi_video_device_attrib* attribute;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!device || !video)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
status =
|
|
|
|
acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ACPI_SUCCESS(status)) {
|
|
|
|
|
2006-12-19 13:56:11 -07:00
|
|
|
data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!data)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
|
|
|
|
strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
|
2008-09-22 15:37:34 -06:00
|
|
|
device->driver_data = data;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
data->device_id = device_id;
|
|
|
|
data->video = video;
|
|
|
|
data->dev = device;
|
|
|
|
|
2007-01-03 21:40:53 -07:00
|
|
|
attribute = acpi_video_get_device_attr(video, device_id);
|
|
|
|
|
|
|
|
if((attribute != NULL) && attribute->device_id_scheme) {
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
if(attribute->bios_can_detect)
|
|
|
|
data->flags.bios = 1;
|
2010-01-12 12:17:03 -07:00
|
|
|
} 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) {
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2005-08-04 22:44:28 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
acpi_video_device_bind(video, data);
|
|
|
|
acpi_video_device_find_cap(data);
|
|
|
|
|
2006-05-19 14:54:48 -06:00
|
|
|
status = acpi_install_notify_handler(device->handle,
|
2005-08-04 22:44:28 -06:00
|
|
|
ACPI_DEVICE_NOTIFY,
|
|
|
|
acpi_video_device_notify,
|
|
|
|
data);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2008-09-28 00:51:56 -06:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Error installing notify handler\n");
|
2006-04-27 03:25:00 -06:00
|
|
|
if(data->brightness)
|
|
|
|
kfree(data->brightness->levels);
|
|
|
|
kfree(data->brightness);
|
|
|
|
kfree(data);
|
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-11-05 09:43:32 -07:00
|
|
|
mutex_lock(&video->device_list_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
list_add_tail(&data->entry, &video->video_device_list);
|
2007-11-05 09:43:32 -07:00
|
|
|
mutex_unlock(&video->device_list_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENOENT;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Arg:
|
|
|
|
* video : video bus device
|
|
|
|
*
|
|
|
|
* Return:
|
|
|
|
* none
|
|
|
|
*
|
|
|
|
* Enumerate the video device list of the video bus,
|
|
|
|
* bind the ids with the corresponding video devices
|
|
|
|
* under the video bus.
|
2005-08-04 22:44:28 -06:00
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static void acpi_video_device_rebind(struct acpi_video_bus *video)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-11-05 09:43:31 -07:00
|
|
|
struct acpi_video_device *dev;
|
|
|
|
|
2007-11-05 09:43:32 -07:00
|
|
|
mutex_lock(&video->device_list_lock);
|
2007-11-05 09:43:31 -07:00
|
|
|
|
|
|
|
list_for_each_entry(dev, &video->video_device_list, entry)
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_video_device_bind(video, dev);
|
2007-11-05 09:43:31 -07:00
|
|
|
|
2007-11-05 09:43:32 -07:00
|
|
|
mutex_unlock(&video->device_list_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Arg:
|
|
|
|
* video : video bus device
|
|
|
|
* device : video output device under the video
|
|
|
|
* bus
|
|
|
|
*
|
|
|
|
* Return:
|
|
|
|
* none
|
|
|
|
*
|
|
|
|
* Bind the ids with the corresponding video devices
|
|
|
|
* under the video bus.
|
2005-08-04 22:44:28 -06:00
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static void
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_video_device_bind(struct acpi_video_bus *video,
|
|
|
|
struct acpi_video_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-11-05 09:43:33 -07:00
|
|
|
struct acpi_video_enumerated_device *ids;
|
2005-08-04 22:44:28 -06:00
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-05 09:43:33 -07: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;
|
2005-04-16 16:20:36 -06:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "device_bind %d\n", i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Arg:
|
|
|
|
* video : video bus device
|
|
|
|
*
|
|
|
|
* Return:
|
|
|
|
* < 0 : error
|
|
|
|
*
|
|
|
|
* Call _DOD to enumerate all devices attached to display adapter
|
|
|
|
*
|
2005-08-04 22:44:28 -06:00
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static int acpi_video_device_enumerate(struct acpi_video_bus *video)
|
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
int status;
|
|
|
|
int count;
|
|
|
|
int i;
|
2007-11-05 09:43:33 -07:00
|
|
|
struct acpi_video_enumerated_device *active_list;
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
union acpi_object *dod = NULL;
|
|
|
|
union acpi_object *obj;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-05-19 14:54:48 -06:00
|
|
|
status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!ACPI_SUCCESS(status)) {
|
2006-06-26 21:58:43 -06:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD"));
|
2006-06-26 22:41:40 -06:00
|
|
|
return status;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-09-30 16:28:50 -06:00
|
|
|
dod = buffer.pointer;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
|
2006-06-26 21:58:43 -06:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data"));
|
2005-04-16 16:20:36 -06:00
|
|
|
status = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d video heads in _DOD\n",
|
2005-08-04 22:44:28 -06:00
|
|
|
dod->package.count));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-05 09:43:33 -07:00
|
|
|
active_list = kcalloc(1 + dod->package.count,
|
|
|
|
sizeof(struct acpi_video_enumerated_device),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!active_list) {
|
2005-04-16 16:20:36 -06:00
|
|
|
status = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
for (i = 0; i < dod->package.count; i++) {
|
2006-09-30 16:28:50 -06:00
|
|
|
obj = &dod->package.elements[i];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (obj->type != ACPI_TYPE_INTEGER) {
|
2007-11-05 09:43:33 -07:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Invalid _DOD data in element %d\n", i);
|
|
|
|
continue;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-11-05 09:43:33 -07:00
|
|
|
|
|
|
|
active_list[count].value.int_val = obj->integer.value;
|
|
|
|
active_list[count].bind_info = NULL;
|
2005-08-04 22:44:28 -06:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "dod element[%d] = %d\n", i,
|
|
|
|
(int)obj->integer.value));
|
2005-04-16 16:20:36 -06:00
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
2005-11-07 02:01:32 -07:00
|
|
|
kfree(video->attached_array);
|
2005-08-04 22:44:28 -06:00
|
|
|
|
2007-11-05 09:43:33 -07:00
|
|
|
video->attached_array = active_list;
|
2005-04-16 16:20:36 -06:00
|
|
|
video->attached_count = count;
|
2007-11-05 09:43:33 -07:00
|
|
|
|
|
|
|
out:
|
2006-06-30 01:19:10 -06:00
|
|
|
kfree(buffer.pointer);
|
2006-06-26 22:41:40 -06:00
|
|
|
return status;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int
|
|
|
|
acpi_video_get_next_level(struct acpi_video_device *device,
|
|
|
|
u32 level_current, u32 event)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-09-03 06:30:08 -06:00
|
|
|
int min, max, min_above, max_below, i, l, delta = 255;
|
2006-12-19 13:56:14 -07:00
|
|
|
max = max_below = 0;
|
|
|
|
min = min_above = 255;
|
2007-09-03 06:30:08 -06:00
|
|
|
/* Find closest level to level_current */
|
2009-02-01 20:33:41 -07:00
|
|
|
for (i = 2; i < device->brightness->count; i++) {
|
2007-09-03 06:30:08 -06:00
|
|
|
l = device->brightness->levels[i];
|
|
|
|
if (abs(l - level_current) < abs(delta)) {
|
|
|
|
delta = l - level_current;
|
|
|
|
if (!delta)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Ajust level_current to closest available level */
|
|
|
|
level_current += delta;
|
2009-02-01 20:33:41 -07:00
|
|
|
for (i = 2; i < device->brightness->count; i++) {
|
2006-12-19 13:56:14 -07: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 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-03-18 02:27:08 -06:00
|
|
|
static int
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_video_switch_brightness(struct acpi_video_device *device, int event)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-10-10 00:22:59 -06:00
|
|
|
unsigned long long level_current, level_next;
|
2009-03-18 02:27:08 -06:00
|
|
|
int result = -EINVAL;
|
|
|
|
|
2009-07-12 20:33:24 -06:00
|
|
|
/* no warning message if acpi_backlight=vendor is used */
|
|
|
|
if (!acpi_video_backlight_support())
|
|
|
|
return 0;
|
|
|
|
|
2008-06-23 15:50:42 -06:00
|
|
|
if (!device->brightness)
|
2009-03-18 02:27:08 -06:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
result = acpi_video_device_lcd_get_level_current(device,
|
2010-02-16 14:53:50 -07:00
|
|
|
&level_current, 0);
|
2009-03-18 02:27:08 -06:00
|
|
|
if (result)
|
|
|
|
goto out;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
level_next = acpi_video_get_next_level(device, level_current, event);
|
2009-03-18 02:27:08 -06:00
|
|
|
|
2009-03-18 02:27:10 -06:00
|
|
|
result = acpi_video_device_lcd_set_level(device, level_next);
|
2009-03-18 02:27:08 -06:00
|
|
|
|
2009-07-14 10:06:03 -06:00
|
|
|
if (!result)
|
|
|
|
backlight_force_update(device->backlight,
|
|
|
|
BACKLIGHT_UPDATE_HOTKEY);
|
|
|
|
|
2009-03-18 02:27:08 -06:00
|
|
|
out:
|
|
|
|
if (result)
|
|
|
|
printk(KERN_ERR PREFIX "Failed to switch the brightness\n");
|
|
|
|
|
|
|
|
return result;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-01-12 12:17:03 -07: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 00:04:24 -07:00
|
|
|
if (!video_device->cap._DDC)
|
|
|
|
continue;
|
|
|
|
|
2010-01-12 12:17:03 -07: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 16:20:36 -06:00
|
|
|
static int
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_video_bus_get_devices(struct acpi_video_bus *video,
|
|
|
|
struct acpi_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
int status = 0;
|
2007-11-05 09:43:31 -07:00
|
|
|
struct acpi_device *dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
acpi_video_device_enumerate(video);
|
|
|
|
|
2007-11-05 09:43:31 -07:00
|
|
|
list_for_each_entry(dev, &device->children, node) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
status = acpi_video_bus_get_one_device(dev, video);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2008-09-28 00:51:56 -06:00
|
|
|
printk(KERN_WARNING PREFIX
|
2010-07-20 16:18:36 -06:00
|
|
|
"Cant attach device\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2006-06-26 22:41:40 -06:00
|
|
|
return status;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-07-30 02:18:00 -06:00
|
|
|
acpi_status status;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!device || !device->video)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENOENT;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-05-19 14:54:48 -06:00
|
|
|
status = acpi_remove_notify_handler(device->dev->handle,
|
2005-08-04 22:44:28 -06:00
|
|
|
ACPI_DEVICE_NOTIFY,
|
|
|
|
acpi_video_device_notify);
|
2010-07-20 16:18:36 -06:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
printk(KERN_WARNING PREFIX
|
|
|
|
"Cant remove video notify handler\n");
|
|
|
|
}
|
2009-08-06 16:57:54 -06:00
|
|
|
if (device->backlight) {
|
|
|
|
sysfs_remove_link(&device->backlight->dev.kobj, "device");
|
|
|
|
backlight_device_unregister(device->backlight);
|
|
|
|
device->backlight = NULL;
|
|
|
|
}
|
2009-08-29 21:03:16 -06:00
|
|
|
if (device->cooling_dev) {
|
2008-01-17 00:51:22 -07:00
|
|
|
sysfs_remove_link(&device->dev->dev.kobj,
|
|
|
|
"thermal_cooling");
|
2009-08-29 21:03:16 -06:00
|
|
|
sysfs_remove_link(&device->cooling_dev->device.kobj,
|
2008-01-17 00:51:22 -07:00
|
|
|
"device");
|
2009-08-29 21:03:16 -06:00
|
|
|
thermal_cooling_device_unregister(device->cooling_dev);
|
|
|
|
device->cooling_dev = NULL;
|
2008-01-17 00:51:22 -07:00
|
|
|
}
|
2007-11-05 09:43:31 -07:00
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
int status;
|
2007-11-05 09:43:31 -07:00
|
|
|
struct acpi_video_device *dev, *next;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-05 09:43:32 -07:00
|
|
|
mutex_lock(&video->device_list_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-05 09:43:31 -07:00
|
|
|
list_for_each_entry_safe(dev, next, &video->video_device_list, entry) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-05 09:43:31 -07:00
|
|
|
status = acpi_video_bus_put_one_device(dev);
|
2005-08-04 22:44:28 -06:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
printk(KERN_WARNING PREFIX
|
|
|
|
"hhuuhhuu bug in acpi video driver.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-05 09:43:31 -07:00
|
|
|
if (dev->brightness) {
|
|
|
|
kfree(dev->brightness->levels);
|
|
|
|
kfree(dev->brightness);
|
|
|
|
}
|
|
|
|
list_del(&dev->entry);
|
|
|
|
kfree(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-11-05 09:43:32 -07:00
|
|
|
mutex_unlock(&video->device_list_lock);
|
2007-11-05 09:43:31 -07:00
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* acpi_video interface */
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_video_bus_start_devices(struct acpi_video_bus *video)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-09-13 21:46:22 -06:00
|
|
|
return acpi_video_bus_DOS(video, 0, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return acpi_video_bus_DOS(video, 0, 1);
|
|
|
|
}
|
|
|
|
|
2009-04-07 09:37:11 -06:00
|
|
|
static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-04-07 09:37:11 -06:00
|
|
|
struct acpi_video_bus *video = acpi_driver_data(device);
|
2007-08-20 04:23:53 -06:00
|
|
|
struct input_dev *input;
|
2009-12-11 15:40:46 -07:00
|
|
|
int keycode = 0;
|
2007-08-20 04:23:53 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!video)
|
2006-06-26 22:41:40 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-08-20 04:23:53 -06:00
|
|
|
input = video->input;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
switch (event) {
|
2007-02-20 08:38:40 -07:00
|
|
|
case ACPI_VIDEO_NOTIFY_SWITCH: /* User requested a switch,
|
2005-04-16 16:20:36 -06:00
|
|
|
* most likely via hotkey. */
|
2007-08-23 13:20:26 -06:00
|
|
|
acpi_bus_generate_proc_event(device, event, 0);
|
2007-08-20 04:23:53 -06:00
|
|
|
keycode = KEY_SWITCHVIDEOMODE;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2007-02-20 08:38:40 -07:00
|
|
|
case ACPI_VIDEO_NOTIFY_PROBE: /* User plugged in or removed a video
|
2005-04-16 16:20:36 -06:00
|
|
|
* connector. */
|
|
|
|
acpi_video_device_enumerate(video);
|
|
|
|
acpi_video_device_rebind(video);
|
2007-08-23 13:20:26 -06:00
|
|
|
acpi_bus_generate_proc_event(device, event, 0);
|
2007-08-20 04:23:53 -06:00
|
|
|
keycode = KEY_SWITCHVIDEOMODE;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
case ACPI_VIDEO_NOTIFY_CYCLE: /* Cycle Display output hotkey pressed. */
|
2007-08-24 23:44:01 -06:00
|
|
|
acpi_bus_generate_proc_event(device, event, 0);
|
2007-08-20 04:23:53 -06:00
|
|
|
keycode = KEY_SWITCHVIDEOMODE;
|
|
|
|
break;
|
2005-08-04 22:44:28 -06:00
|
|
|
case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT: /* Next Display output hotkey pressed. */
|
2007-08-24 23:44:01 -06:00
|
|
|
acpi_bus_generate_proc_event(device, event, 0);
|
2007-08-20 04:23:53 -06:00
|
|
|
keycode = KEY_VIDEO_NEXT;
|
|
|
|
break;
|
2005-08-04 22:44:28 -06:00
|
|
|
case ACPI_VIDEO_NOTIFY_PREV_OUTPUT: /* previous Display output hotkey pressed. */
|
2007-08-23 13:20:26 -06:00
|
|
|
acpi_bus_generate_proc_event(device, event, 0);
|
2007-08-20 04:23:53 -06:00
|
|
|
keycode = KEY_VIDEO_PREV;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2005-08-04 22:44:28 -06:00
|
|
|
"Unsupported event [0x%x]\n", event));
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-01-24 23:48:12 -07:00
|
|
|
acpi_notifier_call_chain(device, event, 0);
|
2009-12-11 15:40:46 -07:00
|
|
|
|
|
|
|
if (keycode) {
|
|
|
|
input_report_key(input, keycode, 1);
|
|
|
|
input_sync(input);
|
|
|
|
input_report_key(input, keycode, 0);
|
|
|
|
input_sync(input);
|
|
|
|
}
|
2007-08-20 04:23:53 -06:00
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-09-30 16:28:50 -06:00
|
|
|
struct acpi_video_device *video_device = data;
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_device *device = NULL;
|
2007-08-20 04:23:53 -06:00
|
|
|
struct acpi_video_bus *bus;
|
|
|
|
struct input_dev *input;
|
2009-12-11 15:40:46 -07:00
|
|
|
int keycode = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!video_device)
|
2006-06-26 22:41:40 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-05-19 14:54:40 -06:00
|
|
|
device = video_device->dev;
|
2007-08-20 04:23:53 -06:00
|
|
|
bus = video_device->video;
|
|
|
|
input = bus->input;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
switch (event) {
|
2005-08-04 22:44:28 -06:00
|
|
|
case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: /* Cycle brightness */
|
2008-01-24 23:47:49 -07:00
|
|
|
if (brightness_switch_enabled)
|
|
|
|
acpi_video_switch_brightness(video_device, event);
|
2007-08-23 13:20:26 -06:00
|
|
|
acpi_bus_generate_proc_event(device, event, 0);
|
2007-08-20 04:23:53 -06:00
|
|
|
keycode = KEY_BRIGHTNESS_CYCLE;
|
|
|
|
break;
|
2005-08-04 22:44:28 -06:00
|
|
|
case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: /* Increase brightness */
|
2008-01-24 23:47:49 -07:00
|
|
|
if (brightness_switch_enabled)
|
|
|
|
acpi_video_switch_brightness(video_device, event);
|
2007-08-24 23:44:01 -06:00
|
|
|
acpi_bus_generate_proc_event(device, event, 0);
|
2007-08-20 04:23:53 -06:00
|
|
|
keycode = KEY_BRIGHTNESSUP;
|
|
|
|
break;
|
2005-08-04 22:44:28 -06:00
|
|
|
case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: /* Decrease brightness */
|
2008-01-24 23:47:49 -07:00
|
|
|
if (brightness_switch_enabled)
|
|
|
|
acpi_video_switch_brightness(video_device, event);
|
2007-08-24 23:44:01 -06:00
|
|
|
acpi_bus_generate_proc_event(device, event, 0);
|
2007-08-20 04:23:53 -06:00
|
|
|
keycode = KEY_BRIGHTNESSDOWN;
|
|
|
|
break;
|
2005-08-04 22:44:28 -06:00
|
|
|
case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightnesss */
|
2008-01-24 23:47:49 -07:00
|
|
|
if (brightness_switch_enabled)
|
|
|
|
acpi_video_switch_brightness(video_device, event);
|
2007-08-24 23:44:01 -06:00
|
|
|
acpi_bus_generate_proc_event(device, event, 0);
|
2007-08-20 04:23:53 -06:00
|
|
|
keycode = KEY_BRIGHTNESS_ZERO;
|
|
|
|
break;
|
2005-08-04 22:44:28 -06:00
|
|
|
case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: /* display device off */
|
2008-01-24 23:47:49 -07:00
|
|
|
if (brightness_switch_enabled)
|
|
|
|
acpi_video_switch_brightness(video_device, event);
|
2007-08-23 13:20:26 -06:00
|
|
|
acpi_bus_generate_proc_event(device, event, 0);
|
2007-08-20 04:23:53 -06:00
|
|
|
keycode = KEY_DISPLAY_OFF;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2005-08-04 22:44:28 -06:00
|
|
|
"Unsupported event [0x%x]\n", event));
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
2007-08-20 04:23:53 -06:00
|
|
|
|
2008-01-24 23:48:12 -07:00
|
|
|
acpi_notifier_call_chain(device, event, 0);
|
2009-12-11 15:40:46 -07:00
|
|
|
|
|
|
|
if (keycode) {
|
|
|
|
input_report_key(input, keycode, 1);
|
|
|
|
input_sync(input);
|
|
|
|
input_report_key(input, keycode, 0);
|
|
|
|
input_sync(input);
|
|
|
|
}
|
2007-08-20 04:23:53 -06:00
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-04-04 17:43:51 -06:00
|
|
|
static int acpi_video_resume(struct notifier_block *nb,
|
|
|
|
unsigned long val, void *ign)
|
2008-02-05 00:31:24 -07:00
|
|
|
{
|
|
|
|
struct acpi_video_bus *video;
|
|
|
|
struct acpi_video_device *video_device;
|
|
|
|
int i;
|
|
|
|
|
2010-04-04 17:43:51 -06:00
|
|
|
switch (val) {
|
|
|
|
case PM_HIBERNATION_PREPARE:
|
|
|
|
case PM_SUSPEND_PREPARE:
|
|
|
|
case PM_RESTORE_PREPARE:
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
2008-02-05 00:31:24 -07:00
|
|
|
|
2010-04-04 17:43:51 -06:00
|
|
|
video = container_of(nb, struct acpi_video_bus, pm_nb);
|
|
|
|
|
|
|
|
dev_info(&video->device->dev, "Restoring backlight state\n");
|
2008-02-05 00:31:24 -07:00
|
|
|
|
|
|
|
for (i = 0; i < video->attached_count; i++) {
|
|
|
|
video_device = video->attached_array[i].bind_info;
|
|
|
|
if (video_device && video_device->backlight)
|
|
|
|
acpi_video_set_brightness(video_device->backlight);
|
|
|
|
}
|
2010-04-04 17:43:51 -06:00
|
|
|
|
|
|
|
return NOTIFY_OK;
|
2008-02-05 00:31:24 -07:00
|
|
|
}
|
|
|
|
|
2009-12-30 00:59:23 -07: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;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
if (handle == device->handle)
|
|
|
|
return AE_CTRL_TERMINATE;
|
|
|
|
|
|
|
|
result = acpi_bus_get_device(handle, &sibling);
|
|
|
|
if (result)
|
|
|
|
return AE_OK;
|
|
|
|
|
|
|
|
if (!strcmp(acpi_device_name(sibling), ACPI_VIDEO_BUS_NAME))
|
|
|
|
return AE_ALREADY_EXISTS;
|
|
|
|
|
|
|
|
return AE_OK;
|
|
|
|
}
|
|
|
|
|
2010-04-04 17:43:51 -06:00
|
|
|
static int instance;
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_video_bus_add(struct acpi_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-11-05 09:43:30 -07:00
|
|
|
struct acpi_video_bus *video;
|
2007-08-20 04:23:53 -06:00
|
|
|
struct input_dev *input;
|
2007-11-05 09:43:30 -07:00
|
|
|
int error;
|
2009-12-30 00:59:23 -07: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) {
|
|
|
|
printk(KERN_WARNING FW_BUG
|
|
|
|
"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 16:20:36 -06:00
|
|
|
|
2006-12-19 13:56:11 -07:00
|
|
|
video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!video)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-08-25 00:23:31 -06: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;
|
|
|
|
instance ++;
|
|
|
|
}
|
2009-02-02 20:55:01 -07: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 00:23:31 -06:00
|
|
|
|
2006-05-19 14:54:40 -06:00
|
|
|
video->device = device;
|
2005-04-16 16:20:36 -06:00
|
|
|
strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
|
|
|
|
strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
|
2008-09-22 15:37:34 -06:00
|
|
|
device->driver_data = video;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
acpi_video_bus_find_cap(video);
|
2007-11-05 09:43:30 -07:00
|
|
|
error = acpi_video_bus_check(video);
|
|
|
|
if (error)
|
|
|
|
goto err_free_video;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-05 09:43:32 -07:00
|
|
|
mutex_init(&video->device_list_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
INIT_LIST_HEAD(&video->video_device_list);
|
|
|
|
|
|
|
|
acpi_video_bus_get_devices(video, device);
|
|
|
|
acpi_video_bus_start_devices(video);
|
|
|
|
|
2007-08-20 04:23:53 -06:00
|
|
|
video->input = input = input_allocate_device();
|
2007-11-05 09:43:30 -07:00
|
|
|
if (!input) {
|
|
|
|
error = -ENOMEM;
|
2009-04-07 09:37:11 -06:00
|
|
|
goto err_stop_video;
|
2007-11-05 09:43:30 -07:00
|
|
|
}
|
2007-08-20 04:23:53 -06:00
|
|
|
|
|
|
|
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;
|
2007-11-05 09:43:29 -07:00
|
|
|
input->dev.parent = &device->dev;
|
2007-08-20 04:23:53 -06:00
|
|
|
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);
|
|
|
|
|
2007-11-05 09:43:30 -07:00
|
|
|
error = input_register_device(input);
|
|
|
|
if (error)
|
|
|
|
goto err_free_input_dev;
|
2007-08-20 04:23:53 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s rom: %s post: %s)\n",
|
2005-08-04 22:44:28 -06:00
|
|
|
ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
|
|
|
|
video->flags.multihead ? "yes" : "no",
|
|
|
|
video->flags.rom ? "yes" : "no",
|
|
|
|
video->flags.post ? "yes" : "no");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-04 17:43:51 -06:00
|
|
|
video->pm_nb.notifier_call = acpi_video_resume;
|
|
|
|
video->pm_nb.priority = 0;
|
|
|
|
register_pm_notifier(&video->pm_nb);
|
|
|
|
|
2007-11-05 09:43:30 -07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_free_input_dev:
|
|
|
|
input_free_device(input);
|
|
|
|
err_stop_video:
|
|
|
|
acpi_video_bus_stop_devices(video);
|
|
|
|
acpi_video_bus_put_devices(video);
|
|
|
|
kfree(video->attached_array);
|
|
|
|
err_free_video:
|
|
|
|
kfree(video);
|
2008-09-22 15:37:34 -06:00
|
|
|
device->driver_data = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-05 09:43:30 -07:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_video_bus_remove(struct acpi_device *device, int type)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_video_bus *video = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
if (!device || !acpi_driver_data(device))
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-09-30 16:28:50 -06:00
|
|
|
video = acpi_driver_data(device);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-04 17:43:51 -06:00
|
|
|
unregister_pm_notifier(&video->pm_nb);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
acpi_video_bus_stop_devices(video);
|
|
|
|
acpi_video_bus_put_devices(video);
|
|
|
|
|
2007-08-20 04:23:53 -06:00
|
|
|
input_unregister_device(video->input);
|
2005-11-07 02:01:32 -07:00
|
|
|
kfree(video->attached_array);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(video);
|
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-03-19 15:35:39 -06:00
|
|
|
static int __init intel_opregion_present(void)
|
|
|
|
{
|
|
|
|
#if defined(CONFIG_DRM_I915) || defined(CONFIG_DRM_I915_MODULE)
|
|
|
|
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;
|
|
|
|
pci_read_config_dword(dev, 0xfc, &address);
|
|
|
|
if (!address)
|
|
|
|
continue;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int acpi_video_register(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
int result = 0;
|
2009-06-15 21:23:13 -06:00
|
|
|
if (register_count) {
|
|
|
|
/*
|
|
|
|
* if the function of acpi_video_register is already called,
|
|
|
|
* don't register the acpi_vide_bus again and return no error.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
result = acpi_bus_register_driver(&acpi_video_bus);
|
2010-10-07 23:55:11 -06:00
|
|
|
if (result < 0)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-06-15 21:23:13 -06:00
|
|
|
/*
|
|
|
|
* When the acpi_video_bus is loaded successfully, increase
|
|
|
|
* the counter reference.
|
|
|
|
*/
|
|
|
|
register_count = 1;
|
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-03-19 15:35:39 -06:00
|
|
|
EXPORT_SYMBOL(acpi_video_register);
|
|
|
|
|
2009-06-15 21:23:13 -06:00
|
|
|
void acpi_video_unregister(void)
|
|
|
|
{
|
|
|
|
if (!register_count) {
|
|
|
|
/*
|
|
|
|
* If the acpi video bus is already unloaded, don't
|
|
|
|
* unload it again and return directly.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
acpi_bus_unregister_driver(&acpi_video_bus);
|
|
|
|
|
|
|
|
register_count = 0;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_video_unregister);
|
|
|
|
|
2009-03-19 15:35:39 -06: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)
|
|
|
|
{
|
2009-04-24 10:13:18 -06:00
|
|
|
dmi_check_system(video_dmi_table);
|
|
|
|
|
2009-03-19 15:35:39 -06:00
|
|
|
if (intel_opregion_present())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return acpi_video_register();
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-06-15 21:23:13 -06:00
|
|
|
static void __exit acpi_video_exit(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-06-15 21:23:13 -06:00
|
|
|
acpi_video_unregister();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(acpi_video_init);
|
|
|
|
module_exit(acpi_video_exit);
|