blob: ec574fc8fbc6028089eea27ab90695c4accf794c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * video.c - ACPI Video Driver ($Revision:$)
3 *
4 * Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
5 * Copyright (C) 2004 Bruno Ducrot <ducrot@poupinou.org>
Thomas Tuttlef4715182006-12-19 12:56:14 -08006 * Copyright (C) 2006 Thomas Tuttle <linux-kernel@ttuttle.net>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or (at
13 * your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, write to the Free Software Foundation, Inc.,
22 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23 *
24 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 */
26
27#include <linux/kernel.h>
28#include <linux/module.h>
29#include <linux/init.h>
30#include <linux/types.h>
31#include <linux/list.h>
Dmitry Torokhovbbac81f2007-11-05 11:43:32 -050032#include <linux/mutex.h>
Luming Yue9dab192007-08-20 18:23:53 +080033#include <linux/input.h>
Yu Luming2f3d0002006-11-11 02:40:34 +080034#include <linux/backlight.h>
Zhang Rui702ed512008-01-17 15:51:22 +080035#include <linux/thermal.h>
Zhang Rui935e5f22008-12-11 16:24:52 -050036#include <linux/sort.h>
Matthew Garrett74a365b2009-03-19 21:35:39 +000037#include <linux/pci.h>
38#include <linux/pci_ids.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090039#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <asm/uaccess.h>
Len Browneb27cae2009-07-06 23:40:19 -040041#include <linux/dmi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <acpi/acpi_bus.h>
43#include <acpi/acpi_drivers.h>
Rafael J. Wysockiac7729d2010-04-05 01:43:51 +020044#include <linux/suspend.h>
Matthew Garrette92a7162010-01-12 14:17:03 -050045#include <acpi/video.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
Len Browna192a952009-07-28 16:45:54 -040047#define PREFIX "ACPI: "
48
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#define ACPI_VIDEO_CLASS "video"
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#define ACPI_VIDEO_BUS_NAME "Video Bus"
51#define ACPI_VIDEO_DEVICE_NAME "Video Device"
52#define ACPI_VIDEO_NOTIFY_SWITCH 0x80
53#define ACPI_VIDEO_NOTIFY_PROBE 0x81
54#define ACPI_VIDEO_NOTIFY_CYCLE 0x82
55#define ACPI_VIDEO_NOTIFY_NEXT_OUTPUT 0x83
56#define ACPI_VIDEO_NOTIFY_PREV_OUTPUT 0x84
57
Thomas Tuttlef4715182006-12-19 12:56:14 -080058#define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS 0x85
59#define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS 0x86
60#define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS 0x87
61#define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS 0x88
62#define ACPI_VIDEO_NOTIFY_DISPLAY_OFF 0x89
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Yu Luming2f3d0002006-11-11 02:40:34 +080064#define MAX_NAME_LEN 20
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#define _COMPONENT ACPI_VIDEO_COMPONENT
Len Brownf52fd662007-02-12 22:42:12 -050067ACPI_MODULE_NAME("video");
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
Len Brownf52fd662007-02-12 22:42:12 -050069MODULE_AUTHOR("Bruno Ducrot");
Len Brown7cda93e2007-02-12 23:50:02 -050070MODULE_DESCRIPTION("ACPI Video Driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -070071MODULE_LICENSE("GPL");
72
Zhang Rui8a681a42008-01-25 14:47:49 +080073static int brightness_switch_enabled = 1;
74module_param(brightness_switch_enabled, bool, 0644);
75
Zhang Ruic504f8c2009-12-30 15:59:23 +080076/*
77 * By default, we don't allow duplicate ACPI video bus devices
78 * under the same VGA controller
79 */
80static int allow_duplicates;
81module_param(allow_duplicates, bool, 0644);
82
Zhang Rui99fd1892010-12-06 15:04:27 +080083/*
84 * Some BIOSes claim they use minimum backlight at boot,
85 * and this may bring dimming screen after boot
86 */
87static int use_bios_initial_backlight = 1;
88module_param(use_bios_initial_backlight, bool, 0644);
89
Zhao Yakui86e437f2009-06-16 11:23:13 +080090static int register_count = 0;
Len Brown4be44fc2005-08-05 00:44:28 -040091static int acpi_video_bus_add(struct acpi_device *device);
92static int acpi_video_bus_remove(struct acpi_device *device, int type);
Bjorn Helgaas70155582009-04-07 15:37:11 +000093static void acpi_video_bus_notify(struct acpi_device *device, u32 event);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Thomas Renninger1ba90e32007-07-23 14:44:41 +020095static const struct acpi_device_id video_device_ids[] = {
96 {ACPI_VIDEO_HID, 0},
97 {"", 0},
98};
99MODULE_DEVICE_TABLE(acpi, video_device_ids);
100
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101static struct acpi_driver acpi_video_bus = {
Len Brownc2b67052007-02-12 23:33:40 -0500102 .name = "video",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 .class = ACPI_VIDEO_CLASS,
Thomas Renninger1ba90e32007-07-23 14:44:41 +0200104 .ids = video_device_ids,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 .ops = {
106 .add = acpi_video_bus_add,
107 .remove = acpi_video_bus_remove,
Bjorn Helgaas70155582009-04-07 15:37:11 +0000108 .notify = acpi_video_bus_notify,
Len Brown4be44fc2005-08-05 00:44:28 -0400109 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110};
111
112struct acpi_video_bus_flags {
Len Brown4be44fc2005-08-05 00:44:28 -0400113 u8 multihead:1; /* can switch video heads */
114 u8 rom:1; /* can retrieve a video rom */
115 u8 post:1; /* can configure the head to */
116 u8 reserved:5;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117};
118
119struct acpi_video_bus_cap {
Len Brown4be44fc2005-08-05 00:44:28 -0400120 u8 _DOS:1; /*Enable/Disable output switching */
121 u8 _DOD:1; /*Enumerate all devices attached to display adapter */
122 u8 _ROM:1; /*Get ROM Data */
123 u8 _GPD:1; /*Get POST Device */
124 u8 _SPD:1; /*Set POST Device */
125 u8 _VPO:1; /*Video POST Options */
126 u8 reserved:2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127};
128
Len Brown4be44fc2005-08-05 00:44:28 -0400129struct acpi_video_device_attrib {
130 u32 display_index:4; /* A zero-based instance of the Display */
Julius Volz98fb8fe2007-02-20 16:38:40 +0100131 u32 display_port_attachment:4; /*This field differentiates the display type */
Len Brown4be44fc2005-08-05 00:44:28 -0400132 u32 display_type:4; /*Describe the specific type in use */
Julius Volz98fb8fe2007-02-20 16:38:40 +0100133 u32 vendor_specific:4; /*Chipset Vendor Specific */
Len Brown4be44fc2005-08-05 00:44:28 -0400134 u32 bios_can_detect:1; /*BIOS can detect the device */
135 u32 depend_on_vga:1; /*Non-VGA output device whose power is related to
136 the VGA device. */
137 u32 pipe_id:3; /*For VGA multiple-head devices. */
138 u32 reserved:10; /*Must be 0 */
139 u32 device_id_scheme:1; /*Device ID Scheme */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140};
141
142struct acpi_video_enumerated_device {
143 union {
144 u32 int_val;
Len Brown4be44fc2005-08-05 00:44:28 -0400145 struct acpi_video_device_attrib attrib;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 } value;
147 struct acpi_video_device *bind_info;
148};
149
150struct acpi_video_bus {
Patrick Mochele6afa0d2006-05-19 16:54:40 -0400151 struct acpi_device *device;
Len Brown4be44fc2005-08-05 00:44:28 -0400152 u8 dos_setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 struct acpi_video_enumerated_device *attached_array;
Len Brown4be44fc2005-08-05 00:44:28 -0400154 u8 attached_count;
155 struct acpi_video_bus_cap cap;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 struct acpi_video_bus_flags flags;
Len Brown4be44fc2005-08-05 00:44:28 -0400157 struct list_head video_device_list;
Dmitry Torokhovbbac81f2007-11-05 11:43:32 -0500158 struct mutex device_list_lock; /* protects video_device_list */
Luming Yue9dab192007-08-20 18:23:53 +0800159 struct input_dev *input;
160 char phys[32]; /* for input device */
Rafael J. Wysockiac7729d2010-04-05 01:43:51 +0200161 struct notifier_block pm_nb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162};
163
164struct acpi_video_device_flags {
Len Brown4be44fc2005-08-05 00:44:28 -0400165 u8 crt:1;
166 u8 lcd:1;
167 u8 tvout:1;
Rui Zhang82cae992007-01-03 23:40:53 -0500168 u8 dvi:1;
Len Brown4be44fc2005-08-05 00:44:28 -0400169 u8 bios:1;
170 u8 unknown:1;
Rui Zhang82cae992007-01-03 23:40:53 -0500171 u8 reserved:2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172};
173
174struct acpi_video_device_cap {
Len Brown4be44fc2005-08-05 00:44:28 -0400175 u8 _ADR:1; /*Return the unique ID */
176 u8 _BCL:1; /*Query list of brightness control levels supported */
177 u8 _BCM:1; /*Set the brightness level */
Yu Luming2f3d0002006-11-11 02:40:34 +0800178 u8 _BQC:1; /* Get current brightness level */
Zhang Ruic60d6382009-03-18 16:27:18 +0800179 u8 _BCQ:1; /* Some buggy BIOS uses _BCQ instead of _BQC */
Len Brown4be44fc2005-08-05 00:44:28 -0400180 u8 _DDC:1; /*Return the EDID for this device */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181};
182
Zhang Ruid32f6942009-03-18 16:27:12 +0800183struct acpi_video_brightness_flags {
184 u8 _BCL_no_ac_battery_levels:1; /* no AC/Battery levels in _BCL */
Zhang Ruid80fb992009-03-18 16:27:14 +0800185 u8 _BCL_reversed:1; /* _BCL package is in a reversed order*/
Zhang Rui1a7c6182009-03-18 16:27:16 +0800186 u8 _BCL_use_index:1; /* levels in _BCL are index values */
187 u8 _BCM_use_index:1; /* input of _BCM is an index value */
188 u8 _BQC_use_index:1; /* _BQC returns an index value */
Zhang Ruid32f6942009-03-18 16:27:12 +0800189};
190
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191struct acpi_video_device_brightness {
Len Brown4be44fc2005-08-05 00:44:28 -0400192 int curr;
193 int count;
194 int *levels;
Zhang Ruid32f6942009-03-18 16:27:12 +0800195 struct acpi_video_brightness_flags flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196};
197
198struct acpi_video_device {
Len Brown4be44fc2005-08-05 00:44:28 -0400199 unsigned long device_id;
200 struct acpi_video_device_flags flags;
201 struct acpi_video_device_cap cap;
202 struct list_head entry;
203 struct acpi_video_bus *video;
204 struct acpi_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 struct acpi_video_device_brightness *brightness;
Yu Luming2f3d0002006-11-11 02:40:34 +0800206 struct backlight_device *backlight;
Dmitry Torokhov4a703a82009-08-29 23:03:16 -0400207 struct thermal_cooling_device *cooling_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208};
209
Jan Engelhardtb7171ae2009-01-12 00:08:19 +0100210static const char device_decode[][30] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 "motherboard VGA device",
212 "PCI VGA device",
213 "AGP VGA device",
214 "UNKNOWN",
215};
216
Len Brown4be44fc2005-08-05 00:44:28 -0400217static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data);
218static void acpi_video_device_rebind(struct acpi_video_bus *video);
219static void acpi_video_device_bind(struct acpi_video_bus *video,
220 struct acpi_video_device *device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221static int acpi_video_device_enumerate(struct acpi_video_bus *video);
Yu Luming2f3d0002006-11-11 02:40:34 +0800222static int acpi_video_device_lcd_set_level(struct acpi_video_device *device,
223 int level);
224static int acpi_video_device_lcd_get_level_current(
225 struct acpi_video_device *device,
Matthew Garrett70287db2010-02-16 16:53:50 -0500226 unsigned long long *level, int init);
Len Brown4be44fc2005-08-05 00:44:28 -0400227static int acpi_video_get_next_level(struct acpi_video_device *device,
228 u32 level_current, u32 event);
Zhang Ruic8890f92009-03-18 16:27:08 +0800229static int acpi_video_switch_brightness(struct acpi_video_device *device,
Len Brown4be44fc2005-08-05 00:44:28 -0400230 int event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
Yu Luming2f3d0002006-11-11 02:40:34 +0800232/*backlight device sysfs support*/
233static int acpi_video_get_brightness(struct backlight_device *bd)
234{
Matthew Wilcox27663c52008-10-10 02:22:59 -0400235 unsigned long long cur_level;
Matthew Garrett38531e62007-12-26 02:03:26 +0000236 int i;
Yu Luming2f3d0002006-11-11 02:40:34 +0800237 struct acpi_video_device *vd =
Richard Purdie655bfd72007-07-09 12:17:24 +0100238 (struct acpi_video_device *)bl_get_data(bd);
Zhang Ruic8890f92009-03-18 16:27:08 +0800239
Matthew Garrett70287db2010-02-16 16:53:50 -0500240 if (acpi_video_device_lcd_get_level_current(vd, &cur_level, 0))
Zhang Ruic8890f92009-03-18 16:27:08 +0800241 return -EINVAL;
Matthew Garrett38531e62007-12-26 02:03:26 +0000242 for (i = 2; i < vd->brightness->count; i++) {
243 if (vd->brightness->levels[i] == cur_level)
244 /* The first two entries are special - see page 575
245 of the ACPI spec 3.0 */
246 return i-2;
247 }
248 return 0;
Yu Luming2f3d0002006-11-11 02:40:34 +0800249}
250
251static int acpi_video_set_brightness(struct backlight_device *bd)
252{
Zhang Rui24450c72009-03-18 16:27:10 +0800253 int request_level = bd->props.brightness + 2;
Yu Luming2f3d0002006-11-11 02:40:34 +0800254 struct acpi_video_device *vd =
Richard Purdie655bfd72007-07-09 12:17:24 +0100255 (struct acpi_video_device *)bl_get_data(bd);
Zhang Rui24450c72009-03-18 16:27:10 +0800256
257 return acpi_video_device_lcd_set_level(vd,
258 vd->brightness->levels[request_level]);
Yu Luming2f3d0002006-11-11 02:40:34 +0800259}
260
Lionel Debrouxacc24722010-11-16 14:14:02 +0100261static const struct backlight_ops acpi_backlight_ops = {
Richard Purdie599a52d2007-02-10 23:07:48 +0000262 .get_brightness = acpi_video_get_brightness,
263 .update_status = acpi_video_set_brightness,
264};
265
Zhang Rui702ed512008-01-17 15:51:22 +0800266/* thermal cooling device callbacks */
Dmitry Torokhov4a703a82009-08-29 23:03:16 -0400267static int video_get_max_state(struct thermal_cooling_device *cooling_dev, unsigned
Matthew Garrett6503e5d2008-11-27 17:48:13 +0000268 long *state)
Zhang Rui702ed512008-01-17 15:51:22 +0800269{
Dmitry Torokhov4a703a82009-08-29 23:03:16 -0400270 struct acpi_device *device = cooling_dev->devdata;
Zhang Rui702ed512008-01-17 15:51:22 +0800271 struct acpi_video_device *video = acpi_driver_data(device);
272
Matthew Garrett6503e5d2008-11-27 17:48:13 +0000273 *state = video->brightness->count - 3;
274 return 0;
Zhang Rui702ed512008-01-17 15:51:22 +0800275}
276
Dmitry Torokhov4a703a82009-08-29 23:03:16 -0400277static int video_get_cur_state(struct thermal_cooling_device *cooling_dev, unsigned
Matthew Garrett6503e5d2008-11-27 17:48:13 +0000278 long *state)
Zhang Rui702ed512008-01-17 15:51:22 +0800279{
Dmitry Torokhov4a703a82009-08-29 23:03:16 -0400280 struct acpi_device *device = cooling_dev->devdata;
Zhang Rui702ed512008-01-17 15:51:22 +0800281 struct acpi_video_device *video = acpi_driver_data(device);
Matthew Wilcox27663c52008-10-10 02:22:59 -0400282 unsigned long long level;
Matthew Garrett6503e5d2008-11-27 17:48:13 +0000283 int offset;
Zhang Rui702ed512008-01-17 15:51:22 +0800284
Matthew Garrett70287db2010-02-16 16:53:50 -0500285 if (acpi_video_device_lcd_get_level_current(video, &level, 0))
Zhang Ruic8890f92009-03-18 16:27:08 +0800286 return -EINVAL;
Matthew Garrett6503e5d2008-11-27 17:48:13 +0000287 for (offset = 2; offset < video->brightness->count; offset++)
288 if (level == video->brightness->levels[offset]) {
289 *state = video->brightness->count - offset - 1;
290 return 0;
291 }
Zhang Rui702ed512008-01-17 15:51:22 +0800292
293 return -EINVAL;
294}
295
296static int
Dmitry Torokhov4a703a82009-08-29 23:03:16 -0400297video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long state)
Zhang Rui702ed512008-01-17 15:51:22 +0800298{
Dmitry Torokhov4a703a82009-08-29 23:03:16 -0400299 struct acpi_device *device = cooling_dev->devdata;
Zhang Rui702ed512008-01-17 15:51:22 +0800300 struct acpi_video_device *video = acpi_driver_data(device);
301 int level;
302
303 if ( state >= video->brightness->count - 2)
304 return -EINVAL;
305
306 state = video->brightness->count - state;
307 level = video->brightness->levels[state -1];
308 return acpi_video_device_lcd_set_level(video, level);
309}
310
311static struct thermal_cooling_device_ops video_cooling_ops = {
312 .get_max_state = video_get_max_state,
313 .get_cur_state = video_get_cur_state,
314 .set_cur_state = video_set_cur_state,
315};
316
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317/* --------------------------------------------------------------------------
318 Video Management
319 -------------------------------------------------------------------------- */
320
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321static int
Len Brown4be44fc2005-08-05 00:44:28 -0400322acpi_video_device_lcd_query_levels(struct acpi_video_device *device,
323 union acpi_object **levels)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324{
Len Brown4be44fc2005-08-05 00:44:28 -0400325 int status;
326 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
327 union acpi_object *obj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
330 *levels = NULL;
331
Patrick Mochel90130262006-05-19 16:54:48 -0400332 status = acpi_evaluate_object(device->dev->handle, "_BCL", NULL, &buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 if (!ACPI_SUCCESS(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400334 return status;
Len Brown4be44fc2005-08-05 00:44:28 -0400335 obj = (union acpi_object *)buffer.pointer;
Adrian Bunk6665bda2006-03-11 10:12:00 -0500336 if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
Len Brown64684632006-06-26 23:41:38 -0400337 printk(KERN_ERR PREFIX "Invalid _BCL data\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 status = -EFAULT;
339 goto err;
340 }
341
342 *levels = obj;
343
Patrick Mocheld550d982006-06-27 00:41:40 -0400344 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
Len Brown4be44fc2005-08-05 00:44:28 -0400346 err:
Jesper Juhl6044ec82005-11-07 01:01:32 -0800347 kfree(buffer.pointer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Patrick Mocheld550d982006-06-27 00:41:40 -0400349 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350}
351
352static int
Len Brown4be44fc2005-08-05 00:44:28 -0400353acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354{
Zhang Rui24450c72009-03-18 16:27:10 +0800355 int status;
Len Brown4be44fc2005-08-05 00:44:28 -0400356 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
357 struct acpi_object_list args = { 1, &arg0 };
Zhang Rui9e6dada2008-12-31 10:58:48 +0800358 int state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 arg0.integer.value = level;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
Zhang Rui24450c72009-03-18 16:27:10 +0800362 status = acpi_evaluate_object(device->dev->handle, "_BCM",
363 &args, NULL);
364 if (ACPI_FAILURE(status)) {
365 ACPI_ERROR((AE_INFO, "Evaluating _BCM failed"));
366 return -EIO;
367 }
368
Alexey Starikovskiy4500ca82007-09-03 16:29:58 +0400369 device->brightness->curr = level;
Zhang Rui9e6dada2008-12-31 10:58:48 +0800370 for (state = 2; state < device->brightness->count; state++)
Zhang Rui24450c72009-03-18 16:27:10 +0800371 if (level == device->brightness->levels[state]) {
Zhang Rui1a7c6182009-03-18 16:27:16 +0800372 if (device->backlight)
373 device->backlight->props.brightness = state - 2;
Zhang Rui24450c72009-03-18 16:27:10 +0800374 return 0;
375 }
Zhang Rui9e6dada2008-12-31 10:58:48 +0800376
Zhang Rui24450c72009-03-18 16:27:10 +0800377 ACPI_ERROR((AE_INFO, "Current brightness invalid"));
378 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379}
380
Zhang Rui45cb50e2009-04-24 12:13:18 -0400381/*
382 * For some buggy _BQC methods, we need to add a constant value to
383 * the _BQC return value to get the actual current brightness level
384 */
385
386static int bqc_offset_aml_bug_workaround;
387static int __init video_set_bqc_offset(const struct dmi_system_id *d)
388{
389 bqc_offset_aml_bug_workaround = 9;
390 return 0;
391}
392
393static struct dmi_system_id video_dmi_table[] __initdata = {
394 /*
395 * Broken _BQC workaround http://bugzilla.kernel.org/show_bug.cgi?id=13121
396 */
397 {
398 .callback = video_set_bqc_offset,
399 .ident = "Acer Aspire 5720",
400 .matches = {
401 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
402 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5720"),
403 },
404 },
Len Brown5afc4ab2009-05-07 21:11:56 -0400405 {
406 .callback = video_set_bqc_offset,
407 .ident = "Acer Aspire 5710Z",
408 .matches = {
409 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
410 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5710Z"),
411 },
412 },
Zhang Rui34ac2722009-05-26 23:35:34 -0400413 {
414 .callback = video_set_bqc_offset,
415 .ident = "eMachines E510",
416 .matches = {
417 DMI_MATCH(DMI_BOARD_VENDOR, "EMACHINES"),
418 DMI_MATCH(DMI_PRODUCT_NAME, "eMachines E510"),
419 },
420 },
Zhang Rui93bcece2009-05-19 15:08:41 -0400421 {
422 .callback = video_set_bqc_offset,
423 .ident = "Acer Aspire 5315",
424 .matches = {
425 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
426 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5315"),
427 },
428 },
Zhang Rui152a4e62009-06-22 11:31:18 +0800429 {
430 .callback = video_set_bqc_offset,
431 .ident = "Acer Aspire 7720",
432 .matches = {
433 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
434 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7720"),
435 },
436 },
Zhang Rui45cb50e2009-04-24 12:13:18 -0400437 {}
438};
439
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440static int
Len Brown4be44fc2005-08-05 00:44:28 -0400441acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
Matthew Garrett70287db2010-02-16 16:53:50 -0500442 unsigned long long *level, int init)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443{
Zhang Ruic8890f92009-03-18 16:27:08 +0800444 acpi_status status = AE_OK;
Vladimir Serbinenko4e231fa2009-06-24 15:17:36 +0800445 int i;
Zhang Ruic8890f92009-03-18 16:27:08 +0800446
Zhang Ruic60d6382009-03-18 16:27:18 +0800447 if (device->cap._BQC || device->cap._BCQ) {
448 char *buf = device->cap._BQC ? "_BQC" : "_BCQ";
449
450 status = acpi_evaluate_integer(device->dev->handle, buf,
Zhang Ruic8890f92009-03-18 16:27:08 +0800451 NULL, level);
452 if (ACPI_SUCCESS(status)) {
Zhang Rui1a7c6182009-03-18 16:27:16 +0800453 if (device->brightness->flags._BQC_use_index) {
454 if (device->brightness->flags._BCL_reversed)
455 *level = device->brightness->count
456 - 3 - (*level);
457 *level = device->brightness->levels[*level + 2];
458
459 }
Zhang Rui45cb50e2009-04-24 12:13:18 -0400460 *level += bqc_offset_aml_bug_workaround;
Vladimir Serbinenko4e231fa2009-06-24 15:17:36 +0800461 for (i = 2; i < device->brightness->count; i++)
462 if (device->brightness->levels[i] == *level) {
463 device->brightness->curr = *level;
464 return 0;
465 }
Matthew Garrett70287db2010-02-16 16:53:50 -0500466 if (!init) {
467 /*
468 * BQC returned an invalid level.
469 * Stop using it.
470 */
471 ACPI_WARNING((AE_INFO,
472 "%s returned an invalid level",
473 buf));
474 device->cap._BQC = device->cap._BCQ = 0;
475 }
Zhang Ruic8890f92009-03-18 16:27:08 +0800476 } else {
477 /* Fixme:
478 * should we return an error or ignore this failure?
479 * dev->brightness->curr is a cached value which stores
480 * the correct current backlight level in most cases.
481 * ACPI video backlight still works w/ buggy _BQC.
482 * http://bugzilla.kernel.org/show_bug.cgi?id=12233
483 */
Zhang Ruic60d6382009-03-18 16:27:18 +0800484 ACPI_WARNING((AE_INFO, "Evaluating %s failed", buf));
485 device->cap._BQC = device->cap._BCQ = 0;
Zhang Ruic8890f92009-03-18 16:27:08 +0800486 }
487 }
488
Alexey Starikovskiy4500ca82007-09-03 16:29:58 +0400489 *level = device->brightness->curr;
Zhang Ruic8890f92009-03-18 16:27:08 +0800490 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491}
492
493static int
Len Brown4be44fc2005-08-05 00:44:28 -0400494acpi_video_device_EDID(struct acpi_video_device *device,
495 union acpi_object **edid, ssize_t length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
Len Brown4be44fc2005-08-05 00:44:28 -0400497 int status;
498 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
499 union acpi_object *obj;
500 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
501 struct acpi_object_list args = { 1, &arg0 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
504 *edid = NULL;
505
506 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400507 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 if (length == 128)
509 arg0.integer.value = 1;
510 else if (length == 256)
511 arg0.integer.value = 2;
512 else
Patrick Mocheld550d982006-06-27 00:41:40 -0400513 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
Patrick Mochel90130262006-05-19 16:54:48 -0400515 status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400517 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200519 obj = buffer.pointer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
521 if (obj && obj->type == ACPI_TYPE_BUFFER)
522 *edid = obj;
523 else {
Len Brown64684632006-06-26 23:41:38 -0400524 printk(KERN_ERR PREFIX "Invalid _DDC data\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 status = -EFAULT;
526 kfree(obj);
527 }
528
Patrick Mocheld550d982006-06-27 00:41:40 -0400529 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530}
531
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532/* bus */
533
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534/*
535 * Arg:
536 * video : video bus device pointer
537 * bios_flag :
538 * 0. The system BIOS should NOT automatically switch(toggle)
539 * the active display output.
540 * 1. The system BIOS should automatically switch (toggle) the
Julius Volz98fb8fe2007-02-20 16:38:40 +0100541 * active display output. No switch event.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 * 2. The _DGS value should be locked.
543 * 3. The system BIOS should not automatically switch (toggle) the
544 * active display output, but instead generate the display switch
545 * event notify code.
546 * lcd_flag :
547 * 0. The system BIOS should automatically control the brightness level
Julius Volz98fb8fe2007-02-20 16:38:40 +0100548 * of the LCD when the power changes from AC to DC
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 * 1. The system BIOS should NOT automatically control the brightness
Julius Volz98fb8fe2007-02-20 16:38:40 +0100550 * level of the LCD when the power changes from AC to DC.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 * Return Value:
552 * -1 wrong arg.
553 */
554
555static int
Len Brown4be44fc2005-08-05 00:44:28 -0400556acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557{
Lin Ming439913f2010-01-28 10:53:19 +0800558 u64 status = 0;
Len Brown4be44fc2005-08-05 00:44:28 -0400559 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
560 struct acpi_object_list args = { 1, &arg0 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
Len Brown4be44fc2005-08-05 00:44:28 -0400563 if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 status = -1;
565 goto Failed;
566 }
567 arg0.integer.value = (lcd_flag << 2) | bios_flag;
568 video->dos_setting = arg0.integer.value;
Patrick Mochel90130262006-05-19 16:54:48 -0400569 acpi_evaluate_object(video->device->handle, "_DOS", &args, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
Len Brown4be44fc2005-08-05 00:44:28 -0400571 Failed:
Patrick Mocheld550d982006-06-27 00:41:40 -0400572 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573}
574
575/*
Zhang Rui935e5f22008-12-11 16:24:52 -0500576 * Simple comparison function used to sort backlight levels.
577 */
578
579static int
580acpi_video_cmp_level(const void *a, const void *b)
581{
582 return *(int *)a - *(int *)b;
583}
584
585/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 * Arg:
587 * device : video output device (LCD, CRT, ..)
588 *
589 * Return Value:
Julia Jomantaite469778c2008-06-23 22:50:42 +0100590 * Maximum brightness level
591 *
592 * Allocate and initialize device->brightness.
593 */
594
595static int
596acpi_video_init_brightness(struct acpi_video_device *device)
597{
598 union acpi_object *obj = NULL;
Zhang Ruid32f6942009-03-18 16:27:12 +0800599 int i, max_level = 0, count = 0, level_ac_battery = 0;
Zhang Rui1a7c6182009-03-18 16:27:16 +0800600 unsigned long long level, level_old;
Julia Jomantaite469778c2008-06-23 22:50:42 +0100601 union acpi_object *o;
602 struct acpi_video_device_brightness *br = NULL;
Zhang Rui1a7c6182009-03-18 16:27:16 +0800603 int result = -EINVAL;
Julia Jomantaite469778c2008-06-23 22:50:42 +0100604
605 if (!ACPI_SUCCESS(acpi_video_device_lcd_query_levels(device, &obj))) {
606 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Could not query available "
607 "LCD brightness level\n"));
608 goto out;
609 }
610
611 if (obj->package.count < 2)
612 goto out;
613
614 br = kzalloc(sizeof(*br), GFP_KERNEL);
615 if (!br) {
616 printk(KERN_ERR "can't allocate memory\n");
Zhang Rui1a7c6182009-03-18 16:27:16 +0800617 result = -ENOMEM;
Julia Jomantaite469778c2008-06-23 22:50:42 +0100618 goto out;
619 }
620
Zhang Ruid32f6942009-03-18 16:27:12 +0800621 br->levels = kmalloc((obj->package.count + 2) * sizeof *(br->levels),
Julia Jomantaite469778c2008-06-23 22:50:42 +0100622 GFP_KERNEL);
Zhang Rui1a7c6182009-03-18 16:27:16 +0800623 if (!br->levels) {
624 result = -ENOMEM;
Julia Jomantaite469778c2008-06-23 22:50:42 +0100625 goto out_free;
Zhang Rui1a7c6182009-03-18 16:27:16 +0800626 }
Julia Jomantaite469778c2008-06-23 22:50:42 +0100627
628 for (i = 0; i < obj->package.count; i++) {
629 o = (union acpi_object *)&obj->package.elements[i];
630 if (o->type != ACPI_TYPE_INTEGER) {
631 printk(KERN_ERR PREFIX "Invalid data\n");
632 continue;
633 }
634 br->levels[count] = (u32) o->integer.value;
635
636 if (br->levels[count] > max_level)
637 max_level = br->levels[count];
638 count++;
639 }
640
Zhang Ruid32f6942009-03-18 16:27:12 +0800641 /*
642 * some buggy BIOS don't export the levels
643 * when machine is on AC/Battery in _BCL package.
644 * In this case, the first two elements in _BCL packages
645 * are also supported brightness levels that OS should take care of.
646 */
Zhang Rui90af2cf2009-04-14 11:02:18 +0800647 for (i = 2; i < count; i++) {
648 if (br->levels[i] == br->levels[0])
Zhang Ruid32f6942009-03-18 16:27:12 +0800649 level_ac_battery++;
Zhang Rui90af2cf2009-04-14 11:02:18 +0800650 if (br->levels[i] == br->levels[1])
651 level_ac_battery++;
652 }
Zhang Rui935e5f22008-12-11 16:24:52 -0500653
Zhang Ruid32f6942009-03-18 16:27:12 +0800654 if (level_ac_battery < 2) {
655 level_ac_battery = 2 - level_ac_battery;
656 br->flags._BCL_no_ac_battery_levels = 1;
657 for (i = (count - 1 + level_ac_battery); i >= 2; i--)
658 br->levels[i] = br->levels[i - level_ac_battery];
659 count += level_ac_battery;
660 } else if (level_ac_battery > 2)
661 ACPI_ERROR((AE_INFO, "Too many duplicates in _BCL package\n"));
662
Zhang Ruid80fb992009-03-18 16:27:14 +0800663 /* Check if the _BCL package is in a reversed order */
664 if (max_level == br->levels[2]) {
665 br->flags._BCL_reversed = 1;
666 sort(&br->levels[2], count - 2, sizeof(br->levels[2]),
667 acpi_video_cmp_level, NULL);
668 } else if (max_level != br->levels[count - 1])
669 ACPI_ERROR((AE_INFO,
670 "Found unordered _BCL package\n"));
Julia Jomantaite469778c2008-06-23 22:50:42 +0100671
672 br->count = count;
673 device->brightness = br;
Zhang Rui1a7c6182009-03-18 16:27:16 +0800674
675 /* Check the input/output of _BQC/_BCL/_BCM */
676 if ((max_level < 100) && (max_level <= (count - 2)))
677 br->flags._BCL_use_index = 1;
678
679 /*
680 * _BCM is always consistent with _BCL,
681 * at least for all the laptops we have ever seen.
682 */
683 br->flags._BCM_use_index = br->flags._BCL_use_index;
684
685 /* _BQC uses INDEX while _BCL uses VALUE in some laptops */
Zhang Rui90c53ca2009-08-31 12:39:54 -0400686 br->curr = level = max_level;
Zhang Ruie047cca2009-04-09 14:24:35 +0800687
688 if (!device->cap._BQC)
689 goto set_level;
690
Matthew Garrett70287db2010-02-16 16:53:50 -0500691 result = acpi_video_device_lcd_get_level_current(device, &level_old, 1);
Zhang Rui1a7c6182009-03-18 16:27:16 +0800692 if (result)
693 goto out_free_levels;
694
Zhang Ruie047cca2009-04-09 14:24:35 +0800695 /*
696 * Set the level to maximum and check if _BQC uses indexed value
697 */
698 result = acpi_video_device_lcd_set_level(device, max_level);
Zhang Rui1a7c6182009-03-18 16:27:16 +0800699 if (result)
700 goto out_free_levels;
701
Matthew Garrett70287db2010-02-16 16:53:50 -0500702 result = acpi_video_device_lcd_get_level_current(device, &level, 0);
Zhang Rui1a7c6182009-03-18 16:27:16 +0800703 if (result)
704 goto out_free_levels;
705
Zhang Ruie047cca2009-04-09 14:24:35 +0800706 br->flags._BQC_use_index = (level == max_level ? 0 : 1);
Zhang Rui1a7c6182009-03-18 16:27:16 +0800707
Zhang Rui90c53ca2009-08-31 12:39:54 -0400708 if (!br->flags._BQC_use_index) {
709 /*
710 * Set the backlight to the initial state.
711 * On some buggy laptops, _BQC returns an uninitialized value
712 * when invoked for the first time, i.e. level_old is invalid.
713 * set the backlight to max_level in this case
714 */
Zhang Rui99fd1892010-12-06 15:04:27 +0800715 if (use_bios_initial_backlight) {
716 for (i = 2; i < br->count; i++)
717 if (level_old == br->levels[i])
718 level = level_old;
719 }
Zhang Ruie047cca2009-04-09 14:24:35 +0800720 goto set_level;
Zhang Rui90c53ca2009-08-31 12:39:54 -0400721 }
Zhang Ruie047cca2009-04-09 14:24:35 +0800722
723 if (br->flags._BCL_reversed)
724 level_old = (br->count - 1) - level_old;
Zhang Rui90c53ca2009-08-31 12:39:54 -0400725 level = br->levels[level_old];
Zhang Ruie047cca2009-04-09 14:24:35 +0800726
727set_level:
Zhang Rui90c53ca2009-08-31 12:39:54 -0400728 result = acpi_video_device_lcd_set_level(device, level);
Zhang Ruie047cca2009-04-09 14:24:35 +0800729 if (result)
730 goto out_free_levels;
Zhang Rui1a7c6182009-03-18 16:27:16 +0800731
Zhang Ruid32f6942009-03-18 16:27:12 +0800732 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
733 "found %d brightness levels\n", count - 2));
Julia Jomantaite469778c2008-06-23 22:50:42 +0100734 kfree(obj);
Zhang Rui1a7c6182009-03-18 16:27:16 +0800735 return result;
Julia Jomantaite469778c2008-06-23 22:50:42 +0100736
737out_free_levels:
738 kfree(br->levels);
739out_free:
740 kfree(br);
741out:
742 device->brightness = NULL;
743 kfree(obj);
Zhang Rui1a7c6182009-03-18 16:27:16 +0800744 return result;
Julia Jomantaite469778c2008-06-23 22:50:42 +0100745}
746
747/*
748 * Arg:
749 * device : video output device (LCD, CRT, ..)
750 *
751 * Return Value:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 * None
753 *
Julius Volz98fb8fe2007-02-20 16:38:40 +0100754 * Find out all required AML methods defined under the output
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 * device.
756 */
757
Len Brown4be44fc2005-08-05 00:44:28 -0400758static void acpi_video_device_find_cap(struct acpi_video_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 acpi_handle h_dummy1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
Patrick Mochel90130262006-05-19 16:54:48 -0400762 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_ADR", &h_dummy1))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 device->cap._ADR = 1;
764 }
Patrick Mochel90130262006-05-19 16:54:48 -0400765 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCL", &h_dummy1))) {
Len Brown4be44fc2005-08-05 00:44:28 -0400766 device->cap._BCL = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 }
Patrick Mochel90130262006-05-19 16:54:48 -0400768 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCM", &h_dummy1))) {
Len Brown4be44fc2005-08-05 00:44:28 -0400769 device->cap._BCM = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 }
Yu Luming2f3d0002006-11-11 02:40:34 +0800771 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle,"_BQC",&h_dummy1)))
772 device->cap._BQC = 1;
Zhang Ruic60d6382009-03-18 16:27:18 +0800773 else if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCQ",
774 &h_dummy1))) {
775 printk(KERN_WARNING FW_BUG "_BCQ is used instead of _BQC\n");
776 device->cap._BCQ = 1;
777 }
778
Patrick Mochel90130262006-05-19 16:54:48 -0400779 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DDC", &h_dummy1))) {
Len Brown4be44fc2005-08-05 00:44:28 -0400780 device->cap._DDC = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
Zhang Rui1a7c6182009-03-18 16:27:16 +0800783 if (acpi_video_backlight_support()) {
Matthew Garretta19a6ee2010-02-17 16:39:44 -0500784 struct backlight_properties props;
Matthew Garrett9661e922011-03-22 16:30:25 -0700785 struct pci_dev *pdev;
786 acpi_handle acpi_parent;
787 struct device *parent = NULL;
Zhang Rui702ed512008-01-17 15:51:22 +0800788 int result;
Yu Luming2f3d0002006-11-11 02:40:34 +0800789 static int count = 0;
790 char *name;
Zhang Rui1a7c6182009-03-18 16:27:16 +0800791
792 result = acpi_video_init_brightness(device);
793 if (result)
794 return;
Julia Lawallaeb834d2010-04-27 14:06:04 -0700795 name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
Yu Luming2f3d0002006-11-11 02:40:34 +0800796 if (!name)
797 return;
Julia Lawallaeb834d2010-04-27 14:06:04 -0700798 count++;
Yu Luming2f3d0002006-11-11 02:40:34 +0800799
Matthew Garrett9661e922011-03-22 16:30:25 -0700800 acpi_get_parent(device->dev->handle, &acpi_parent);
801
802 pdev = acpi_get_pci_dev(acpi_parent);
803 if (pdev) {
804 parent = &pdev->dev;
805 pci_dev_put(pdev);
806 }
807
Matthew Garretta19a6ee2010-02-17 16:39:44 -0500808 memset(&props, 0, sizeof(struct backlight_properties));
Matthew Garrettbb7ca742011-03-22 16:30:21 -0700809 props.type = BACKLIGHT_FIRMWARE;
Matthew Garretta19a6ee2010-02-17 16:39:44 -0500810 props.max_brightness = device->brightness->count - 3;
Matthew Garrett9661e922011-03-22 16:30:25 -0700811 device->backlight = backlight_device_register(name,
812 parent,
813 device,
Matthew Garretta19a6ee2010-02-17 16:39:44 -0500814 &acpi_backlight_ops,
815 &props);
Yu Luming2f3d0002006-11-11 02:40:34 +0800816 kfree(name);
Zhang Ruie01ce792009-07-29 08:53:29 +0800817 if (IS_ERR(device->backlight))
818 return;
Zhang Rui702ed512008-01-17 15:51:22 +0800819
Rafael J. Wysockiac7729d2010-04-05 01:43:51 +0200820 /*
821 * Save current brightness level in case we have to restore it
822 * before acpi_video_device_lcd_set_level() is called next time.
823 */
824 device->backlight->props.brightness =
825 acpi_video_get_brightness(device->backlight);
Zhang Rui702ed512008-01-17 15:51:22 +0800826
Dmitry Torokhov4a703a82009-08-29 23:03:16 -0400827 device->cooling_dev = thermal_cooling_device_register("LCD",
Zhang Rui702ed512008-01-17 15:51:22 +0800828 device->dev, &video_cooling_ops);
Dmitry Torokhov4a703a82009-08-29 23:03:16 -0400829 if (IS_ERR(device->cooling_dev)) {
Dmitry Torokhov4b4fe3b2009-08-08 00:26:25 -0700830 /*
Dmitry Torokhov4a703a82009-08-29 23:03:16 -0400831 * Set cooling_dev to NULL so we don't crash trying to
Dmitry Torokhov4b4fe3b2009-08-08 00:26:25 -0700832 * free it.
833 * Also, why the hell we are returning early and
834 * not attempt to register video output if cooling
835 * device registration failed?
836 * -- dtor
837 */
Dmitry Torokhov4a703a82009-08-29 23:03:16 -0400838 device->cooling_dev = NULL;
Thomas Sujith43ff39f2008-02-15 18:29:18 -0500839 return;
Dmitry Torokhov4b4fe3b2009-08-08 00:26:25 -0700840 }
Thomas Sujith43ff39f2008-02-15 18:29:18 -0500841
Greg Kroah-Hartmanfc3a8822008-05-02 06:02:41 +0200842 dev_info(&device->dev->dev, "registered as cooling_device%d\n",
Dmitry Torokhov4a703a82009-08-29 23:03:16 -0400843 device->cooling_dev->id);
Julia Lawall90300622008-04-11 10:09:24 +0800844 result = sysfs_create_link(&device->dev->dev.kobj,
Dmitry Torokhov4a703a82009-08-29 23:03:16 -0400845 &device->cooling_dev->device.kobj,
Julia Lawall90300622008-04-11 10:09:24 +0800846 "thermal_cooling");
847 if (result)
848 printk(KERN_ERR PREFIX "Create sysfs link\n");
Dmitry Torokhov4a703a82009-08-29 23:03:16 -0400849 result = sysfs_create_link(&device->cooling_dev->device.kobj,
Julia Lawall90300622008-04-11 10:09:24 +0800850 &device->dev->dev.kobj, "device");
851 if (result)
852 printk(KERN_ERR PREFIX "Create sysfs link\n");
853
Yu Luming2f3d0002006-11-11 02:40:34 +0800854 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855}
856
857/*
858 * Arg:
859 * device : video output device (VGA)
860 *
861 * Return Value:
862 * None
863 *
Julius Volz98fb8fe2007-02-20 16:38:40 +0100864 * Find out all required AML methods defined under the video bus device.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 */
866
Len Brown4be44fc2005-08-05 00:44:28 -0400867static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868{
Len Brown4be44fc2005-08-05 00:44:28 -0400869 acpi_handle h_dummy1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870
Patrick Mochel90130262006-05-19 16:54:48 -0400871 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOS", &h_dummy1))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 video->cap._DOS = 1;
873 }
Patrick Mochel90130262006-05-19 16:54:48 -0400874 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOD", &h_dummy1))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 video->cap._DOD = 1;
876 }
Patrick Mochel90130262006-05-19 16:54:48 -0400877 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_ROM", &h_dummy1))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 video->cap._ROM = 1;
879 }
Patrick Mochel90130262006-05-19 16:54:48 -0400880 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_GPD", &h_dummy1))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 video->cap._GPD = 1;
882 }
Patrick Mochel90130262006-05-19 16:54:48 -0400883 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_SPD", &h_dummy1))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 video->cap._SPD = 1;
885 }
Patrick Mochel90130262006-05-19 16:54:48 -0400886 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_VPO", &h_dummy1))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 video->cap._VPO = 1;
888 }
889}
890
891/*
892 * Check whether the video bus device has required AML method to
893 * support the desired features
894 */
895
Len Brown4be44fc2005-08-05 00:44:28 -0400896static int acpi_video_bus_check(struct acpi_video_bus *video)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897{
Len Brown4be44fc2005-08-05 00:44:28 -0400898 acpi_status status = -ENOENT;
Alexander Chiang1e4cffe2009-06-10 19:56:00 +0000899 struct pci_dev *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900
901 if (!video)
Patrick Mocheld550d982006-06-27 00:41:40 -0400902 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903
Alexander Chiang1e4cffe2009-06-10 19:56:00 +0000904 dev = acpi_get_pci_dev(video->device->handle);
Thomas Renninger22c13f92008-08-01 17:37:54 +0200905 if (!dev)
906 return -ENODEV;
Alexander Chiang1e4cffe2009-06-10 19:56:00 +0000907 pci_dev_put(dev);
Thomas Renninger22c13f92008-08-01 17:37:54 +0200908
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 /* Since there is no HID, CID and so on for VGA driver, we have
910 * to check well known required nodes.
911 */
912
Julius Volz98fb8fe2007-02-20 16:38:40 +0100913 /* Does this device support video switching? */
Stefan Bader3a1151e2009-08-21 11:03:05 +0200914 if (video->cap._DOS || video->cap._DOD) {
915 if (!video->cap._DOS) {
916 printk(KERN_WARNING FW_BUG
917 "ACPI(%s) defines _DOD but not _DOS\n",
918 acpi_device_bid(video->device));
919 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 video->flags.multihead = 1;
921 status = 0;
922 }
923
Julius Volz98fb8fe2007-02-20 16:38:40 +0100924 /* Does this device support retrieving a video ROM? */
Len Brown4be44fc2005-08-05 00:44:28 -0400925 if (video->cap._ROM) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 video->flags.rom = 1;
927 status = 0;
928 }
929
Julius Volz98fb8fe2007-02-20 16:38:40 +0100930 /* Does this device support configuring which video device to POST? */
Len Brown4be44fc2005-08-05 00:44:28 -0400931 if (video->cap._GPD && video->cap._SPD && video->cap._VPO) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 video->flags.post = 1;
933 status = 0;
934 }
935
Patrick Mocheld550d982006-06-27 00:41:40 -0400936 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937}
938
939/* --------------------------------------------------------------------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 Driver Interface
941 -------------------------------------------------------------------------- */
942
943/* device interface */
Rui Zhang82cae992007-01-03 23:40:53 -0500944static struct acpi_video_device_attrib*
945acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id)
946{
Dmitry Torokhov78eed022007-11-05 11:43:33 -0500947 struct acpi_video_enumerated_device *ids;
948 int i;
Rui Zhang82cae992007-01-03 23:40:53 -0500949
Dmitry Torokhov78eed022007-11-05 11:43:33 -0500950 for (i = 0; i < video->attached_count; i++) {
951 ids = &video->attached_array[i];
952 if ((ids->value.int_val & 0xffff) == device_id)
953 return &ids->value.attrib;
954 }
955
Rui Zhang82cae992007-01-03 23:40:53 -0500956 return NULL;
957}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
959static int
Matthew Garrette92a7162010-01-12 14:17:03 -0500960acpi_video_get_device_type(struct acpi_video_bus *video,
961 unsigned long device_id)
962{
963 struct acpi_video_enumerated_device *ids;
964 int i;
965
966 for (i = 0; i < video->attached_count; i++) {
967 ids = &video->attached_array[i];
968 if ((ids->value.int_val & 0xffff) == device_id)
969 return ids->value.int_val;
970 }
971
972 return 0;
973}
974
975static int
Len Brown4be44fc2005-08-05 00:44:28 -0400976acpi_video_bus_get_one_device(struct acpi_device *device,
977 struct acpi_video_bus *video)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978{
Matthew Wilcox27663c52008-10-10 02:22:59 -0400979 unsigned long long device_id;
Matthew Garrette92a7162010-01-12 14:17:03 -0500980 int status, device_type;
Len Brown4be44fc2005-08-05 00:44:28 -0400981 struct acpi_video_device *data;
Rui Zhang82cae992007-01-03 23:40:53 -0500982 struct acpi_video_device_attrib* attribute;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
984 if (!device || !video)
Patrick Mocheld550d982006-06-27 00:41:40 -0400985 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986
Len Brown4be44fc2005-08-05 00:44:28 -0400987 status =
988 acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 if (ACPI_SUCCESS(status)) {
990
Burman Yan36bcbec2006-12-19 12:56:11 -0800991 data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 if (!data)
Patrick Mocheld550d982006-06-27 00:41:40 -0400993 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
996 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700997 device->driver_data = data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998
999 data->device_id = device_id;
1000 data->video = video;
1001 data->dev = device;
1002
Rui Zhang82cae992007-01-03 23:40:53 -05001003 attribute = acpi_video_get_device_attr(video, device_id);
1004
1005 if((attribute != NULL) && attribute->device_id_scheme) {
1006 switch (attribute->display_type) {
1007 case ACPI_VIDEO_DISPLAY_CRT:
1008 data->flags.crt = 1;
1009 break;
1010 case ACPI_VIDEO_DISPLAY_TV:
1011 data->flags.tvout = 1;
1012 break;
1013 case ACPI_VIDEO_DISPLAY_DVI:
1014 data->flags.dvi = 1;
1015 break;
1016 case ACPI_VIDEO_DISPLAY_LCD:
1017 data->flags.lcd = 1;
1018 break;
1019 default:
1020 data->flags.unknown = 1;
1021 break;
1022 }
1023 if(attribute->bios_can_detect)
1024 data->flags.bios = 1;
Matthew Garrette92a7162010-01-12 14:17:03 -05001025 } else {
1026 /* Check for legacy IDs */
1027 device_type = acpi_video_get_device_type(video,
1028 device_id);
1029 /* Ignore bits 16 and 18-20 */
1030 switch (device_type & 0xffe2ffff) {
1031 case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR:
1032 data->flags.crt = 1;
1033 break;
1034 case ACPI_VIDEO_DISPLAY_LEGACY_PANEL:
1035 data->flags.lcd = 1;
1036 break;
1037 case ACPI_VIDEO_DISPLAY_LEGACY_TV:
1038 data->flags.tvout = 1;
1039 break;
1040 default:
1041 data->flags.unknown = 1;
1042 }
1043 }
Len Brown4be44fc2005-08-05 00:44:28 -04001044
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 acpi_video_device_bind(video, data);
1046 acpi_video_device_find_cap(data);
1047
Patrick Mochel90130262006-05-19 16:54:48 -04001048 status = acpi_install_notify_handler(device->handle,
Len Brown4be44fc2005-08-05 00:44:28 -04001049 ACPI_DEVICE_NOTIFY,
1050 acpi_video_device_notify,
1051 data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 if (ACPI_FAILURE(status)) {
Lin Ming55ac9a02008-09-28 14:51:56 +08001053 printk(KERN_ERR PREFIX
1054 "Error installing notify handler\n");
Yu, Luming973bf492006-04-27 05:25:00 -04001055 if(data->brightness)
1056 kfree(data->brightness->levels);
1057 kfree(data->brightness);
1058 kfree(data);
1059 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 }
1061
Dmitry Torokhovbbac81f2007-11-05 11:43:32 -05001062 mutex_lock(&video->device_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 list_add_tail(&data->entry, &video->video_device_list);
Dmitry Torokhovbbac81f2007-11-05 11:43:32 -05001064 mutex_unlock(&video->device_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
Patrick Mocheld550d982006-06-27 00:41:40 -04001066 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 }
1068
Patrick Mocheld550d982006-06-27 00:41:40 -04001069 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070}
1071
1072/*
1073 * Arg:
1074 * video : video bus device
1075 *
1076 * Return:
1077 * none
1078 *
1079 * Enumerate the video device list of the video bus,
1080 * bind the ids with the corresponding video devices
1081 * under the video bus.
Len Brown4be44fc2005-08-05 00:44:28 -04001082 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083
Len Brown4be44fc2005-08-05 00:44:28 -04001084static void acpi_video_device_rebind(struct acpi_video_bus *video)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085{
Dmitry Torokhovff102ea2007-11-05 11:43:31 -05001086 struct acpi_video_device *dev;
1087
Dmitry Torokhovbbac81f2007-11-05 11:43:32 -05001088 mutex_lock(&video->device_list_lock);
Dmitry Torokhovff102ea2007-11-05 11:43:31 -05001089
1090 list_for_each_entry(dev, &video->video_device_list, entry)
Len Brown4be44fc2005-08-05 00:44:28 -04001091 acpi_video_device_bind(video, dev);
Dmitry Torokhovff102ea2007-11-05 11:43:31 -05001092
Dmitry Torokhovbbac81f2007-11-05 11:43:32 -05001093 mutex_unlock(&video->device_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094}
1095
1096/*
1097 * Arg:
1098 * video : video bus device
1099 * device : video output device under the video
1100 * bus
1101 *
1102 * Return:
1103 * none
1104 *
1105 * Bind the ids with the corresponding video devices
1106 * under the video bus.
Len Brown4be44fc2005-08-05 00:44:28 -04001107 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108
1109static void
Len Brown4be44fc2005-08-05 00:44:28 -04001110acpi_video_device_bind(struct acpi_video_bus *video,
1111 struct acpi_video_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112{
Dmitry Torokhov78eed022007-11-05 11:43:33 -05001113 struct acpi_video_enumerated_device *ids;
Len Brown4be44fc2005-08-05 00:44:28 -04001114 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
Dmitry Torokhov78eed022007-11-05 11:43:33 -05001116 for (i = 0; i < video->attached_count; i++) {
1117 ids = &video->attached_array[i];
1118 if (device->device_id == (ids->value.int_val & 0xffff)) {
1119 ids->bind_info = device;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "device_bind %d\n", i));
1121 }
1122 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123}
1124
1125/*
1126 * Arg:
1127 * video : video bus device
1128 *
1129 * Return:
1130 * < 0 : error
1131 *
1132 * Call _DOD to enumerate all devices attached to display adapter
1133 *
Len Brown4be44fc2005-08-05 00:44:28 -04001134 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135
1136static int acpi_video_device_enumerate(struct acpi_video_bus *video)
1137{
Len Brown4be44fc2005-08-05 00:44:28 -04001138 int status;
1139 int count;
1140 int i;
Dmitry Torokhov78eed022007-11-05 11:43:33 -05001141 struct acpi_video_enumerated_device *active_list;
Len Brown4be44fc2005-08-05 00:44:28 -04001142 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1143 union acpi_object *dod = NULL;
1144 union acpi_object *obj;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145
Patrick Mochel90130262006-05-19 16:54:48 -04001146 status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 if (!ACPI_SUCCESS(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -04001148 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD"));
Patrick Mocheld550d982006-06-27 00:41:40 -04001149 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 }
1151
Jan Engelhardt50dd0962006-10-01 00:28:50 +02001152 dod = buffer.pointer;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -04001154 ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 status = -EFAULT;
1156 goto out;
1157 }
1158
1159 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d video heads in _DOD\n",
Len Brown4be44fc2005-08-05 00:44:28 -04001160 dod->package.count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161
Dmitry Torokhov78eed022007-11-05 11:43:33 -05001162 active_list = kcalloc(1 + dod->package.count,
1163 sizeof(struct acpi_video_enumerated_device),
1164 GFP_KERNEL);
1165 if (!active_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 status = -ENOMEM;
1167 goto out;
1168 }
1169
1170 count = 0;
1171 for (i = 0; i < dod->package.count; i++) {
Jan Engelhardt50dd0962006-10-01 00:28:50 +02001172 obj = &dod->package.elements[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
1174 if (obj->type != ACPI_TYPE_INTEGER) {
Dmitry Torokhov78eed022007-11-05 11:43:33 -05001175 printk(KERN_ERR PREFIX
1176 "Invalid _DOD data in element %d\n", i);
1177 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 }
Dmitry Torokhov78eed022007-11-05 11:43:33 -05001179
1180 active_list[count].value.int_val = obj->integer.value;
1181 active_list[count].bind_info = NULL;
Len Brown4be44fc2005-08-05 00:44:28 -04001182 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "dod element[%d] = %d\n", i,
1183 (int)obj->integer.value));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 count++;
1185 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186
Jesper Juhl6044ec82005-11-07 01:01:32 -08001187 kfree(video->attached_array);
Len Brown4be44fc2005-08-05 00:44:28 -04001188
Dmitry Torokhov78eed022007-11-05 11:43:33 -05001189 video->attached_array = active_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 video->attached_count = count;
Dmitry Torokhov78eed022007-11-05 11:43:33 -05001191
1192 out:
Len Brown02438d82006-06-30 03:19:10 -04001193 kfree(buffer.pointer);
Patrick Mocheld550d982006-06-27 00:41:40 -04001194 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195}
1196
Len Brown4be44fc2005-08-05 00:44:28 -04001197static int
1198acpi_video_get_next_level(struct acpi_video_device *device,
1199 u32 level_current, u32 event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200{
Alexey Starikovskiy63f0edf2007-09-03 16:30:08 +04001201 int min, max, min_above, max_below, i, l, delta = 255;
Thomas Tuttlef4715182006-12-19 12:56:14 -08001202 max = max_below = 0;
1203 min = min_above = 255;
Alexey Starikovskiy63f0edf2007-09-03 16:30:08 +04001204 /* Find closest level to level_current */
Zhao Yakui0a3db1c2009-02-02 11:33:41 +08001205 for (i = 2; i < device->brightness->count; i++) {
Alexey Starikovskiy63f0edf2007-09-03 16:30:08 +04001206 l = device->brightness->levels[i];
1207 if (abs(l - level_current) < abs(delta)) {
1208 delta = l - level_current;
1209 if (!delta)
1210 break;
1211 }
1212 }
1213 /* Ajust level_current to closest available level */
1214 level_current += delta;
Zhao Yakui0a3db1c2009-02-02 11:33:41 +08001215 for (i = 2; i < device->brightness->count; i++) {
Thomas Tuttlef4715182006-12-19 12:56:14 -08001216 l = device->brightness->levels[i];
1217 if (l < min)
1218 min = l;
1219 if (l > max)
1220 max = l;
1221 if (l < min_above && l > level_current)
1222 min_above = l;
1223 if (l > max_below && l < level_current)
1224 max_below = l;
1225 }
1226
1227 switch (event) {
1228 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:
1229 return (level_current < max) ? min_above : min;
1230 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:
1231 return (level_current < max) ? min_above : max;
1232 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:
1233 return (level_current > min) ? max_below : min;
1234 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:
1235 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:
1236 return 0;
1237 default:
1238 return level_current;
1239 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240}
1241
Zhang Ruic8890f92009-03-18 16:27:08 +08001242static int
Len Brown4be44fc2005-08-05 00:44:28 -04001243acpi_video_switch_brightness(struct acpi_video_device *device, int event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244{
Matthew Wilcox27663c52008-10-10 02:22:59 -04001245 unsigned long long level_current, level_next;
Zhang Ruic8890f92009-03-18 16:27:08 +08001246 int result = -EINVAL;
1247
Zhang Rui28c32e92009-07-13 10:33:24 +08001248 /* no warning message if acpi_backlight=vendor is used */
1249 if (!acpi_video_backlight_support())
1250 return 0;
1251
Julia Jomantaite469778c2008-06-23 22:50:42 +01001252 if (!device->brightness)
Zhang Ruic8890f92009-03-18 16:27:08 +08001253 goto out;
1254
1255 result = acpi_video_device_lcd_get_level_current(device,
Matthew Garrett70287db2010-02-16 16:53:50 -05001256 &level_current, 0);
Zhang Ruic8890f92009-03-18 16:27:08 +08001257 if (result)
1258 goto out;
1259
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 level_next = acpi_video_get_next_level(device, level_current, event);
Zhang Ruic8890f92009-03-18 16:27:08 +08001261
Zhang Rui24450c72009-03-18 16:27:10 +08001262 result = acpi_video_device_lcd_set_level(device, level_next);
Zhang Ruic8890f92009-03-18 16:27:08 +08001263
Matthew Garrett36342742009-07-14 17:06:03 +01001264 if (!result)
1265 backlight_force_update(device->backlight,
1266 BACKLIGHT_UPDATE_HOTKEY);
1267
Zhang Ruic8890f92009-03-18 16:27:08 +08001268out:
1269 if (result)
1270 printk(KERN_ERR PREFIX "Failed to switch the brightness\n");
1271
1272 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273}
1274
Matthew Garrette92a7162010-01-12 14:17:03 -05001275int acpi_video_get_edid(struct acpi_device *device, int type, int device_id,
1276 void **edid)
1277{
1278 struct acpi_video_bus *video;
1279 struct acpi_video_device *video_device;
1280 union acpi_object *buffer = NULL;
1281 acpi_status status;
1282 int i, length;
1283
1284 if (!device || !acpi_driver_data(device))
1285 return -EINVAL;
1286
1287 video = acpi_driver_data(device);
1288
1289 for (i = 0; i < video->attached_count; i++) {
1290 video_device = video->attached_array[i].bind_info;
1291 length = 256;
1292
1293 if (!video_device)
1294 continue;
1295
Zhang Rui82069552010-12-06 15:04:24 +08001296 if (!video_device->cap._DDC)
1297 continue;
1298
Matthew Garrette92a7162010-01-12 14:17:03 -05001299 if (type) {
1300 switch (type) {
1301 case ACPI_VIDEO_DISPLAY_CRT:
1302 if (!video_device->flags.crt)
1303 continue;
1304 break;
1305 case ACPI_VIDEO_DISPLAY_TV:
1306 if (!video_device->flags.tvout)
1307 continue;
1308 break;
1309 case ACPI_VIDEO_DISPLAY_DVI:
1310 if (!video_device->flags.dvi)
1311 continue;
1312 break;
1313 case ACPI_VIDEO_DISPLAY_LCD:
1314 if (!video_device->flags.lcd)
1315 continue;
1316 break;
1317 }
1318 } else if (video_device->device_id != device_id) {
1319 continue;
1320 }
1321
1322 status = acpi_video_device_EDID(video_device, &buffer, length);
1323
1324 if (ACPI_FAILURE(status) || !buffer ||
1325 buffer->type != ACPI_TYPE_BUFFER) {
1326 length = 128;
1327 status = acpi_video_device_EDID(video_device, &buffer,
1328 length);
1329 if (ACPI_FAILURE(status) || !buffer ||
1330 buffer->type != ACPI_TYPE_BUFFER) {
1331 continue;
1332 }
1333 }
1334
1335 *edid = buffer->buffer.pointer;
1336 return length;
1337 }
1338
1339 return -ENODEV;
1340}
1341EXPORT_SYMBOL(acpi_video_get_edid);
1342
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343static int
Len Brown4be44fc2005-08-05 00:44:28 -04001344acpi_video_bus_get_devices(struct acpi_video_bus *video,
1345 struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346{
Len Brown4be44fc2005-08-05 00:44:28 -04001347 int status = 0;
Dmitry Torokhovff102ea2007-11-05 11:43:31 -05001348 struct acpi_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349
1350 acpi_video_device_enumerate(video);
1351
Dmitry Torokhovff102ea2007-11-05 11:43:31 -05001352 list_for_each_entry(dev, &device->children, node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353
1354 status = acpi_video_bus_get_one_device(dev, video);
1355 if (ACPI_FAILURE(status)) {
Lin Ming55ac9a02008-09-28 14:51:56 +08001356 printk(KERN_WARNING PREFIX
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001357 "Can't attach device\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 continue;
1359 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 }
Patrick Mocheld550d982006-06-27 00:41:40 -04001361 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362}
1363
Len Brown4be44fc2005-08-05 00:44:28 -04001364static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365{
Karol Kozimor031ec772005-07-30 04:18:00 -04001366 acpi_status status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367
1368 if (!device || !device->video)
Patrick Mocheld550d982006-06-27 00:41:40 -04001369 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
Patrick Mochel90130262006-05-19 16:54:48 -04001371 status = acpi_remove_notify_handler(device->dev->handle,
Len Brown4be44fc2005-08-05 00:44:28 -04001372 ACPI_DEVICE_NOTIFY,
1373 acpi_video_device_notify);
Andi Kleencfa806f2010-07-20 15:18:36 -07001374 if (ACPI_FAILURE(status)) {
1375 printk(KERN_WARNING PREFIX
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001376 "Can't remove video notify handler\n");
Andi Kleencfa806f2010-07-20 15:18:36 -07001377 }
Keith Packarde29b3ee2009-08-06 15:57:54 -07001378 if (device->backlight) {
Keith Packarde29b3ee2009-08-06 15:57:54 -07001379 backlight_device_unregister(device->backlight);
1380 device->backlight = NULL;
1381 }
Dmitry Torokhov4a703a82009-08-29 23:03:16 -04001382 if (device->cooling_dev) {
Zhang Rui702ed512008-01-17 15:51:22 +08001383 sysfs_remove_link(&device->dev->dev.kobj,
1384 "thermal_cooling");
Dmitry Torokhov4a703a82009-08-29 23:03:16 -04001385 sysfs_remove_link(&device->cooling_dev->device.kobj,
Zhang Rui702ed512008-01-17 15:51:22 +08001386 "device");
Dmitry Torokhov4a703a82009-08-29 23:03:16 -04001387 thermal_cooling_device_unregister(device->cooling_dev);
1388 device->cooling_dev = NULL;
Zhang Rui702ed512008-01-17 15:51:22 +08001389 }
Dmitry Torokhovff102ea2007-11-05 11:43:31 -05001390
Patrick Mocheld550d982006-06-27 00:41:40 -04001391 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392}
1393
Len Brown4be44fc2005-08-05 00:44:28 -04001394static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395{
Len Brown4be44fc2005-08-05 00:44:28 -04001396 int status;
Dmitry Torokhovff102ea2007-11-05 11:43:31 -05001397 struct acpi_video_device *dev, *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398
Dmitry Torokhovbbac81f2007-11-05 11:43:32 -05001399 mutex_lock(&video->device_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400
Dmitry Torokhovff102ea2007-11-05 11:43:31 -05001401 list_for_each_entry_safe(dev, next, &video->video_device_list, entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402
Dmitry Torokhovff102ea2007-11-05 11:43:31 -05001403 status = acpi_video_bus_put_one_device(dev);
Len Brown4be44fc2005-08-05 00:44:28 -04001404 if (ACPI_FAILURE(status))
1405 printk(KERN_WARNING PREFIX
1406 "hhuuhhuu bug in acpi video driver.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407
Dmitry Torokhovff102ea2007-11-05 11:43:31 -05001408 if (dev->brightness) {
1409 kfree(dev->brightness->levels);
1410 kfree(dev->brightness);
1411 }
1412 list_del(&dev->entry);
1413 kfree(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 }
1415
Dmitry Torokhovbbac81f2007-11-05 11:43:32 -05001416 mutex_unlock(&video->device_list_lock);
Dmitry Torokhovff102ea2007-11-05 11:43:31 -05001417
Patrick Mocheld550d982006-06-27 00:41:40 -04001418 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419}
1420
1421/* acpi_video interface */
1422
Len Brown4be44fc2005-08-05 00:44:28 -04001423static int acpi_video_bus_start_devices(struct acpi_video_bus *video)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424{
Zhang Ruia21101c2007-09-14 11:46:22 +08001425 return acpi_video_bus_DOS(video, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426}
1427
Len Brown4be44fc2005-08-05 00:44:28 -04001428static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429{
1430 return acpi_video_bus_DOS(video, 0, 1);
1431}
1432
Bjorn Helgaas70155582009-04-07 15:37:11 +00001433static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434{
Bjorn Helgaas70155582009-04-07 15:37:11 +00001435 struct acpi_video_bus *video = acpi_driver_data(device);
Luming Yue9dab192007-08-20 18:23:53 +08001436 struct input_dev *input;
Matthew Garrett17c452f2009-12-11 17:40:46 -05001437 int keycode = 0;
Luming Yue9dab192007-08-20 18:23:53 +08001438
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 if (!video)
Patrick Mocheld550d982006-06-27 00:41:40 -04001440 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441
Luming Yue9dab192007-08-20 18:23:53 +08001442 input = video->input;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443
1444 switch (event) {
Julius Volz98fb8fe2007-02-20 16:38:40 +01001445 case ACPI_VIDEO_NOTIFY_SWITCH: /* User requested a switch,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 * most likely via hotkey. */
Len Brown14e04fb2007-08-23 15:20:26 -04001447 acpi_bus_generate_proc_event(device, event, 0);
Luming Yue9dab192007-08-20 18:23:53 +08001448 keycode = KEY_SWITCHVIDEOMODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 break;
1450
Julius Volz98fb8fe2007-02-20 16:38:40 +01001451 case ACPI_VIDEO_NOTIFY_PROBE: /* User plugged in or removed a video
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 * connector. */
1453 acpi_video_device_enumerate(video);
1454 acpi_video_device_rebind(video);
Len Brown14e04fb2007-08-23 15:20:26 -04001455 acpi_bus_generate_proc_event(device, event, 0);
Luming Yue9dab192007-08-20 18:23:53 +08001456 keycode = KEY_SWITCHVIDEOMODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 break;
1458
Len Brown4be44fc2005-08-05 00:44:28 -04001459 case ACPI_VIDEO_NOTIFY_CYCLE: /* Cycle Display output hotkey pressed. */
Len Brown25c87f72007-08-25 01:44:01 -04001460 acpi_bus_generate_proc_event(device, event, 0);
Luming Yue9dab192007-08-20 18:23:53 +08001461 keycode = KEY_SWITCHVIDEOMODE;
1462 break;
Len Brown4be44fc2005-08-05 00:44:28 -04001463 case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT: /* Next Display output hotkey pressed. */
Len Brown25c87f72007-08-25 01:44:01 -04001464 acpi_bus_generate_proc_event(device, event, 0);
Luming Yue9dab192007-08-20 18:23:53 +08001465 keycode = KEY_VIDEO_NEXT;
1466 break;
Len Brown4be44fc2005-08-05 00:44:28 -04001467 case ACPI_VIDEO_NOTIFY_PREV_OUTPUT: /* previous Display output hotkey pressed. */
Len Brown14e04fb2007-08-23 15:20:26 -04001468 acpi_bus_generate_proc_event(device, event, 0);
Luming Yue9dab192007-08-20 18:23:53 +08001469 keycode = KEY_VIDEO_PREV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 break;
1471
1472 default:
1473 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -04001474 "Unsupported event [0x%x]\n", event));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 break;
1476 }
1477
Zhang Rui7761f632008-01-25 14:48:12 +08001478 acpi_notifier_call_chain(device, event, 0);
Matthew Garrett17c452f2009-12-11 17:40:46 -05001479
1480 if (keycode) {
1481 input_report_key(input, keycode, 1);
1482 input_sync(input);
1483 input_report_key(input, keycode, 0);
1484 input_sync(input);
1485 }
Luming Yue9dab192007-08-20 18:23:53 +08001486
Patrick Mocheld550d982006-06-27 00:41:40 -04001487 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488}
1489
Len Brown4be44fc2005-08-05 00:44:28 -04001490static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491{
Jan Engelhardt50dd0962006-10-01 00:28:50 +02001492 struct acpi_video_device *video_device = data;
Len Brown4be44fc2005-08-05 00:44:28 -04001493 struct acpi_device *device = NULL;
Luming Yue9dab192007-08-20 18:23:53 +08001494 struct acpi_video_bus *bus;
1495 struct input_dev *input;
Matthew Garrett17c452f2009-12-11 17:40:46 -05001496 int keycode = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 if (!video_device)
Patrick Mocheld550d982006-06-27 00:41:40 -04001499 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500
Patrick Mochele6afa0d2006-05-19 16:54:40 -04001501 device = video_device->dev;
Luming Yue9dab192007-08-20 18:23:53 +08001502 bus = video_device->video;
1503 input = bus->input;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504
1505 switch (event) {
Len Brown4be44fc2005-08-05 00:44:28 -04001506 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: /* Cycle brightness */
Zhang Rui8a681a42008-01-25 14:47:49 +08001507 if (brightness_switch_enabled)
1508 acpi_video_switch_brightness(video_device, event);
Len Brown25c87f72007-08-25 01:44:01 -04001509 acpi_bus_generate_proc_event(device, event, 0);
Luming Yue9dab192007-08-20 18:23:53 +08001510 keycode = KEY_BRIGHTNESS_CYCLE;
1511 break;
Len Brown4be44fc2005-08-05 00:44:28 -04001512 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: /* Increase brightness */
Zhang Rui8a681a42008-01-25 14:47:49 +08001513 if (brightness_switch_enabled)
1514 acpi_video_switch_brightness(video_device, event);
Len Brown25c87f72007-08-25 01:44:01 -04001515 acpi_bus_generate_proc_event(device, event, 0);
Luming Yue9dab192007-08-20 18:23:53 +08001516 keycode = KEY_BRIGHTNESSUP;
1517 break;
Len Brown4be44fc2005-08-05 00:44:28 -04001518 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: /* Decrease brightness */
Zhang Rui8a681a42008-01-25 14:47:49 +08001519 if (brightness_switch_enabled)
1520 acpi_video_switch_brightness(video_device, event);
Len Brown25c87f72007-08-25 01:44:01 -04001521 acpi_bus_generate_proc_event(device, event, 0);
Luming Yue9dab192007-08-20 18:23:53 +08001522 keycode = KEY_BRIGHTNESSDOWN;
1523 break;
Len Brown4be44fc2005-08-05 00:44:28 -04001524 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightnesss */
Zhang Rui8a681a42008-01-25 14:47:49 +08001525 if (brightness_switch_enabled)
1526 acpi_video_switch_brightness(video_device, event);
Len Brown25c87f72007-08-25 01:44:01 -04001527 acpi_bus_generate_proc_event(device, event, 0);
Luming Yue9dab192007-08-20 18:23:53 +08001528 keycode = KEY_BRIGHTNESS_ZERO;
1529 break;
Len Brown4be44fc2005-08-05 00:44:28 -04001530 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: /* display device off */
Zhang Rui8a681a42008-01-25 14:47:49 +08001531 if (brightness_switch_enabled)
1532 acpi_video_switch_brightness(video_device, event);
Len Brown14e04fb2007-08-23 15:20:26 -04001533 acpi_bus_generate_proc_event(device, event, 0);
Luming Yue9dab192007-08-20 18:23:53 +08001534 keycode = KEY_DISPLAY_OFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 break;
1536 default:
1537 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -04001538 "Unsupported event [0x%x]\n", event));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 break;
1540 }
Luming Yue9dab192007-08-20 18:23:53 +08001541
Zhang Rui7761f632008-01-25 14:48:12 +08001542 acpi_notifier_call_chain(device, event, 0);
Matthew Garrett17c452f2009-12-11 17:40:46 -05001543
1544 if (keycode) {
1545 input_report_key(input, keycode, 1);
1546 input_sync(input);
1547 input_report_key(input, keycode, 0);
1548 input_sync(input);
1549 }
Luming Yue9dab192007-08-20 18:23:53 +08001550
Patrick Mocheld550d982006-06-27 00:41:40 -04001551 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552}
1553
Rafael J. Wysockiac7729d2010-04-05 01:43:51 +02001554static int acpi_video_resume(struct notifier_block *nb,
1555 unsigned long val, void *ign)
Matthew Garrett863c1492008-02-04 23:31:24 -08001556{
1557 struct acpi_video_bus *video;
1558 struct acpi_video_device *video_device;
1559 int i;
1560
Rafael J. Wysockiac7729d2010-04-05 01:43:51 +02001561 switch (val) {
1562 case PM_HIBERNATION_PREPARE:
1563 case PM_SUSPEND_PREPARE:
1564 case PM_RESTORE_PREPARE:
1565 return NOTIFY_DONE;
1566 }
Matthew Garrett863c1492008-02-04 23:31:24 -08001567
Rafael J. Wysockiac7729d2010-04-05 01:43:51 +02001568 video = container_of(nb, struct acpi_video_bus, pm_nb);
1569
1570 dev_info(&video->device->dev, "Restoring backlight state\n");
Matthew Garrett863c1492008-02-04 23:31:24 -08001571
1572 for (i = 0; i < video->attached_count; i++) {
1573 video_device = video->attached_array[i].bind_info;
1574 if (video_device && video_device->backlight)
1575 acpi_video_set_brightness(video_device->backlight);
1576 }
Rafael J. Wysockiac7729d2010-04-05 01:43:51 +02001577
1578 return NOTIFY_OK;
Matthew Garrett863c1492008-02-04 23:31:24 -08001579}
1580
Zhang Ruic504f8c2009-12-30 15:59:23 +08001581static acpi_status
1582acpi_video_bus_match(acpi_handle handle, u32 level, void *context,
1583 void **return_value)
1584{
1585 struct acpi_device *device = context;
1586 struct acpi_device *sibling;
1587 int result;
1588
1589 if (handle == device->handle)
1590 return AE_CTRL_TERMINATE;
1591
1592 result = acpi_bus_get_device(handle, &sibling);
1593 if (result)
1594 return AE_OK;
1595
1596 if (!strcmp(acpi_device_name(sibling), ACPI_VIDEO_BUS_NAME))
1597 return AE_ALREADY_EXISTS;
1598
1599 return AE_OK;
1600}
1601
Rafael J. Wysockiac7729d2010-04-05 01:43:51 +02001602static int instance;
1603
Len Brown4be44fc2005-08-05 00:44:28 -04001604static int acpi_video_bus_add(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605{
Dmitry Torokhovf51e8392007-11-05 11:43:30 -05001606 struct acpi_video_bus *video;
Luming Yue9dab192007-08-20 18:23:53 +08001607 struct input_dev *input;
Dmitry Torokhovf51e8392007-11-05 11:43:30 -05001608 int error;
Zhang Ruic504f8c2009-12-30 15:59:23 +08001609 acpi_status status;
1610
1611 status = acpi_walk_namespace(ACPI_TYPE_DEVICE,
1612 device->parent->handle, 1,
1613 acpi_video_bus_match, NULL,
1614 device, NULL);
1615 if (status == AE_ALREADY_EXISTS) {
1616 printk(KERN_WARNING FW_BUG
1617 "Duplicate ACPI video bus devices for the"
1618 " same VGA controller, please try module "
1619 "parameter \"video.allow_duplicates=1\""
1620 "if the current driver doesn't work.\n");
1621 if (!allow_duplicates)
1622 return -ENODEV;
1623 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624
Burman Yan36bcbec2006-12-19 12:56:11 -08001625 video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 if (!video)
Patrick Mocheld550d982006-06-27 00:41:40 -04001627 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628
Zhang Ruie6d9da12007-08-25 02:23:31 -04001629 /* a hack to fix the duplicate name "VID" problem on T61 */
1630 if (!strcmp(device->pnp.bus_id, "VID")) {
1631 if (instance)
1632 device->pnp.bus_id[3] = '0' + instance;
1633 instance ++;
1634 }
Zhao Yakuif3b39f12009-02-02 22:55:01 -05001635 /* a hack to fix the duplicate name "VGA" problem on Pa 3553 */
1636 if (!strcmp(device->pnp.bus_id, "VGA")) {
1637 if (instance)
1638 device->pnp.bus_id[3] = '0' + instance;
1639 instance++;
1640 }
Zhang Ruie6d9da12007-08-25 02:23:31 -04001641
Patrick Mochele6afa0d2006-05-19 16:54:40 -04001642 video->device = device;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
1644 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
Pavel Machekdb89b4f2008-09-22 14:37:34 -07001645 device->driver_data = video;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
1647 acpi_video_bus_find_cap(video);
Dmitry Torokhovf51e8392007-11-05 11:43:30 -05001648 error = acpi_video_bus_check(video);
1649 if (error)
1650 goto err_free_video;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651
Dmitry Torokhovbbac81f2007-11-05 11:43:32 -05001652 mutex_init(&video->device_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 INIT_LIST_HEAD(&video->video_device_list);
1654
1655 acpi_video_bus_get_devices(video, device);
1656 acpi_video_bus_start_devices(video);
1657
Luming Yue9dab192007-08-20 18:23:53 +08001658 video->input = input = input_allocate_device();
Dmitry Torokhovf51e8392007-11-05 11:43:30 -05001659 if (!input) {
1660 error = -ENOMEM;
Bjorn Helgaas70155582009-04-07 15:37:11 +00001661 goto err_stop_video;
Dmitry Torokhovf51e8392007-11-05 11:43:30 -05001662 }
Luming Yue9dab192007-08-20 18:23:53 +08001663
1664 snprintf(video->phys, sizeof(video->phys),
1665 "%s/video/input0", acpi_device_hid(video->device));
1666
1667 input->name = acpi_device_name(video->device);
1668 input->phys = video->phys;
1669 input->id.bustype = BUS_HOST;
1670 input->id.product = 0x06;
Dmitry Torokhov91c05c62007-11-05 11:43:29 -05001671 input->dev.parent = &device->dev;
Luming Yue9dab192007-08-20 18:23:53 +08001672 input->evbit[0] = BIT(EV_KEY);
1673 set_bit(KEY_SWITCHVIDEOMODE, input->keybit);
1674 set_bit(KEY_VIDEO_NEXT, input->keybit);
1675 set_bit(KEY_VIDEO_PREV, input->keybit);
1676 set_bit(KEY_BRIGHTNESS_CYCLE, input->keybit);
1677 set_bit(KEY_BRIGHTNESSUP, input->keybit);
1678 set_bit(KEY_BRIGHTNESSDOWN, input->keybit);
1679 set_bit(KEY_BRIGHTNESS_ZERO, input->keybit);
1680 set_bit(KEY_DISPLAY_OFF, input->keybit);
Luming Yue9dab192007-08-20 18:23:53 +08001681
Dmitry Torokhovf51e8392007-11-05 11:43:30 -05001682 error = input_register_device(input);
1683 if (error)
1684 goto err_free_input_dev;
Luming Yue9dab192007-08-20 18:23:53 +08001685
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s rom: %s post: %s)\n",
Len Brown4be44fc2005-08-05 00:44:28 -04001687 ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
1688 video->flags.multihead ? "yes" : "no",
1689 video->flags.rom ? "yes" : "no",
1690 video->flags.post ? "yes" : "no");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691
Rafael J. Wysockiac7729d2010-04-05 01:43:51 +02001692 video->pm_nb.notifier_call = acpi_video_resume;
1693 video->pm_nb.priority = 0;
1694 register_pm_notifier(&video->pm_nb);
1695
Dmitry Torokhovf51e8392007-11-05 11:43:30 -05001696 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697
Dmitry Torokhovf51e8392007-11-05 11:43:30 -05001698 err_free_input_dev:
1699 input_free_device(input);
Dmitry Torokhovf51e8392007-11-05 11:43:30 -05001700 err_stop_video:
1701 acpi_video_bus_stop_devices(video);
1702 acpi_video_bus_put_devices(video);
1703 kfree(video->attached_array);
Dmitry Torokhovf51e8392007-11-05 11:43:30 -05001704 err_free_video:
1705 kfree(video);
Pavel Machekdb89b4f2008-09-22 14:37:34 -07001706 device->driver_data = NULL;
Dmitry Torokhovf51e8392007-11-05 11:43:30 -05001707
1708 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709}
1710
Len Brown4be44fc2005-08-05 00:44:28 -04001711static int acpi_video_bus_remove(struct acpi_device *device, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712{
Len Brown4be44fc2005-08-05 00:44:28 -04001713 struct acpi_video_bus *video = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715
1716 if (!device || !acpi_driver_data(device))
Patrick Mocheld550d982006-06-27 00:41:40 -04001717 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718
Jan Engelhardt50dd0962006-10-01 00:28:50 +02001719 video = acpi_driver_data(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720
Rafael J. Wysockiac7729d2010-04-05 01:43:51 +02001721 unregister_pm_notifier(&video->pm_nb);
1722
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 acpi_video_bus_stop_devices(video);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 acpi_video_bus_put_devices(video);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725
Luming Yue9dab192007-08-20 18:23:53 +08001726 input_unregister_device(video->input);
Jesper Juhl6044ec82005-11-07 01:01:32 -08001727 kfree(video->attached_array);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 kfree(video);
1729
Patrick Mocheld550d982006-06-27 00:41:40 -04001730 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731}
1732
Matthew Garrett74a365b2009-03-19 21:35:39 +00001733static int __init intel_opregion_present(void)
1734{
1735#if defined(CONFIG_DRM_I915) || defined(CONFIG_DRM_I915_MODULE)
1736 struct pci_dev *dev = NULL;
1737 u32 address;
1738
1739 for_each_pci_dev(dev) {
1740 if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
1741 continue;
1742 if (dev->vendor != PCI_VENDOR_ID_INTEL)
1743 continue;
1744 pci_read_config_dword(dev, 0xfc, &address);
1745 if (!address)
1746 continue;
1747 return 1;
1748 }
1749#endif
1750 return 0;
1751}
1752
1753int acpi_video_register(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754{
Len Brown4be44fc2005-08-05 00:44:28 -04001755 int result = 0;
Zhao Yakui86e437f2009-06-16 11:23:13 +08001756 if (register_count) {
1757 /*
1758 * if the function of acpi_video_register is already called,
1759 * don't register the acpi_vide_bus again and return no error.
1760 */
1761 return 0;
1762 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 result = acpi_bus_register_driver(&acpi_video_bus);
Zhang Rui39fe3942010-10-08 13:55:11 +08001765 if (result < 0)
Patrick Mocheld550d982006-06-27 00:41:40 -04001766 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767
Zhao Yakui86e437f2009-06-16 11:23:13 +08001768 /*
1769 * When the acpi_video_bus is loaded successfully, increase
1770 * the counter reference.
1771 */
1772 register_count = 1;
1773
Patrick Mocheld550d982006-06-27 00:41:40 -04001774 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775}
Matthew Garrett74a365b2009-03-19 21:35:39 +00001776EXPORT_SYMBOL(acpi_video_register);
1777
Zhao Yakui86e437f2009-06-16 11:23:13 +08001778void acpi_video_unregister(void)
1779{
1780 if (!register_count) {
1781 /*
1782 * If the acpi video bus is already unloaded, don't
1783 * unload it again and return directly.
1784 */
1785 return;
1786 }
1787 acpi_bus_unregister_driver(&acpi_video_bus);
1788
Zhao Yakui86e437f2009-06-16 11:23:13 +08001789 register_count = 0;
1790
1791 return;
1792}
1793EXPORT_SYMBOL(acpi_video_unregister);
1794
Matthew Garrett74a365b2009-03-19 21:35:39 +00001795/*
1796 * This is kind of nasty. Hardware using Intel chipsets may require
1797 * the video opregion code to be run first in order to initialise
1798 * state before any ACPI video calls are made. To handle this we defer
1799 * registration of the video class until the opregion code has run.
1800 */
1801
1802static int __init acpi_video_init(void)
1803{
Zhang Rui45cb50e2009-04-24 12:13:18 -04001804 dmi_check_system(video_dmi_table);
1805
Matthew Garrett74a365b2009-03-19 21:35:39 +00001806 if (intel_opregion_present())
1807 return 0;
1808
1809 return acpi_video_register();
1810}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811
Zhao Yakui86e437f2009-06-16 11:23:13 +08001812static void __exit acpi_video_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813{
Zhao Yakui86e437f2009-06-16 11:23:13 +08001814 acpi_video_unregister();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815
Patrick Mocheld550d982006-06-27 00:41:40 -04001816 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818
1819module_init(acpi_video_init);
1820module_exit(acpi_video_exit);