projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ACPI / video: Fix backlight taking 2 steps on a brightness up/down keypress
[deliverable/linux.git] / drivers / acpi / video.c
CommitLineData
1da177e4 1/*
21fcb34e 2 * video.c - ACPI Video Driver
1da177e4
LT		 3 *
4 * Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
5 * Copyright (C) 2004 Bruno Ducrot <ducrot@poupinou.org>
f4715189 6 * Copyright (C) 2006 Thomas Tuttle <linux-kernel@ttuttle.net>
1da177e4
LT		 7 *
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>
bbac81f5 32#include <linux/mutex.h>
e9dab196 33#include <linux/input.h>
2f3d000a 34#include <linux/backlight.h>
702ed512 35#include <linux/thermal.h>
935e5f29 36#include <linux/sort.h>
74a365b3
MG		 37#include <linux/pci.h>
38#include <linux/pci_ids.h>
5a0e3ad6 39#include <linux/slab.h>
eb27cae8 40#include <linux/dmi.h>
ac7729da 41#include <linux/suspend.h>
8b48463f 42#include <linux/acpi.h>
e92a7162 43#include <acpi/video.h>
8b48463f 44#include <asm/uaccess.h>
1da177e4 45
8c5bd7ad
RW		 46#include "internal.h"
47
1da177e4
LT		 48#define ACPI_VIDEO_BUS_NAME "Video Bus"
49#define ACPI_VIDEO_DEVICE_NAME "Video Device"
50#define ACPI_VIDEO_NOTIFY_SWITCH 0x80
51#define ACPI_VIDEO_NOTIFY_PROBE 0x81
52#define ACPI_VIDEO_NOTIFY_CYCLE 0x82
53#define ACPI_VIDEO_NOTIFY_NEXT_OUTPUT 0x83
54#define ACPI_VIDEO_NOTIFY_PREV_OUTPUT 0x84
55
f4715189
TT		 56#define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS 0x85
57#define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS 0x86
58#define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS 0x87
59#define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS 0x88
60#define ACPI_VIDEO_NOTIFY_DISPLAY_OFF 0x89
1da177e4 61
2f3d000a 62#define MAX_NAME_LEN 20
1da177e4 63
1da177e4 64#define _COMPONENT ACPI_VIDEO_COMPONENT
f52fd66d 65ACPI_MODULE_NAME("video");
1da177e4 66
f52fd66d 67MODULE_AUTHOR("Bruno Ducrot");
7cda93e0 68MODULE_DESCRIPTION("ACPI Video Driver");
1da177e4
LT		 69MODULE_LICENSE("GPL");
70
2843768b 71static bool brightness_switch_enabled = 1;
8a681a4d
ZR		 72module_param(brightness_switch_enabled, bool, 0644);
73
c504f8cb
ZR		 74/*
75 * By default, we don't allow duplicate ACPI video bus devices
76 * under the same VGA controller
77 */
90ab5ee9 78static bool allow_duplicates;
c504f8cb
ZR		 79module_param(allow_duplicates, bool, 0644);
80
fbc9fe1b 81/*
0e9f81d3
AL		 82 * For Windows 8 systems: used to decide if video module
83 * should skip registering backlight interface of its own.
fbc9fe1b 84 */
751109aa 85static int use_native_backlight_param = 1;
0e9f81d3
AL		 86module_param_named(use_native_backlight, use_native_backlight_param, int, 0444);
87static bool use_native_backlight_dmi = false;
fbc9fe1b 88
915ea7e4 89static int register_count;
67b662e1
AL		 90static struct mutex video_list_lock;
91static struct list_head video_bus_head;
4be44fcd 92static int acpi_video_bus_add(struct acpi_device *device);
51fac838 93static int acpi_video_bus_remove(struct acpi_device *device);
7015558f 94static void acpi_video_bus_notify(struct acpi_device *device, u32 event);
1da177e4 95
1ba90e3a
TR		 96static const struct acpi_device_id video_device_ids[] = {
97 {ACPI_VIDEO_HID, 0},
98 {"", 0},
99};
100MODULE_DEVICE_TABLE(acpi, video_device_ids);
101
1da177e4 102static struct acpi_driver acpi_video_bus = {
c2b6705b 103 .name = "video",
1da177e4 104 .class = ACPI_VIDEO_CLASS,
1ba90e3a 105 .ids = video_device_ids,
1da177e4
LT		 106 .ops = {
107 .add = acpi_video_bus_add,
108 .remove = acpi_video_bus_remove,
7015558f 109 .notify = acpi_video_bus_notify,
4be44fcd 110 },
1da177e4
LT		 111};
112
113struct acpi_video_bus_flags {
4be44fcd
LB		 114 u8 multihead:1; /* can switch video heads */
115 u8 rom:1; /* can retrieve a video rom */
116 u8 post:1; /* can configure the head to */
117 u8 reserved:5;
1da177e4
LT		 118};
119
120struct acpi_video_bus_cap {
21fcb34e
FC		 121 u8 _DOS:1; /* Enable/Disable output switching */
122 u8 _DOD:1; /* Enumerate all devices attached to display adapter */
123 u8 _ROM:1; /* Get ROM Data */
124 u8 _GPD:1; /* Get POST Device */
125 u8 _SPD:1; /* Set POST Device */
126 u8 _VPO:1; /* Video POST Options */
4be44fcd 127 u8 reserved:2;
1da177e4
LT		 128};
129
4be44fcd
LB		 130struct acpi_video_device_attrib {
131 u32 display_index:4; /* A zero-based instance of the Display */
21fcb34e
FC		 132 u32 display_port_attachment:4; /* This field differentiates the display type */
133 u32 display_type:4; /* Describe the specific type in use */
134 u32 vendor_specific:4; /* Chipset Vendor Specific */
135 u32 bios_can_detect:1; /* BIOS can detect the device */
136 u32 depend_on_vga:1; /* Non-VGA output device whose power is related to
4be44fcd 137 the VGA device. */
21fcb34e
FC		 138 u32 pipe_id:3; /* For VGA multiple-head devices. */
139 u32 reserved:10; /* Must be 0 */
140 u32 device_id_scheme:1; /* Device ID Scheme */
1da177e4
LT		 141};
142
143struct acpi_video_enumerated_device {
144 union {
145 u32 int_val;
4be44fcd 146 struct acpi_video_device_attrib attrib;
1da177e4
LT		 147 } value;
148 struct acpi_video_device *bind_info;
149};
150
151struct acpi_video_bus {
e6afa0de 152 struct acpi_device *device;
99678ed7 153 bool backlight_registered;
53a92ba7 154 bool backlight_notifier_registered;
4be44fcd 155 u8 dos_setting;
1da177e4 156 struct acpi_video_enumerated_device *attached_array;
4be44fcd
LB		 157 u8 attached_count;
158 struct acpi_video_bus_cap cap;
1da177e4 159 struct acpi_video_bus_flags flags;
4be44fcd 160 struct list_head video_device_list;
bbac81f5 161 struct mutex device_list_lock; /* protects video_device_list */
67b662e1 162 struct list_head entry;
e9dab196
LY		 163 struct input_dev *input;
164 char phys[32]; /* for input device */
ac7729da 165 struct notifier_block pm_nb;
53a92ba7 166 struct notifier_block backlight_nb;
1da177e4
LT		 167};
168
169struct acpi_video_device_flags {
4be44fcd
LB		 170 u8 crt:1;
171 u8 lcd:1;
172 u8 tvout:1;
82cae999 173 u8 dvi:1;
4be44fcd
LB		 174 u8 bios:1;
175 u8 unknown:1;
91e13aa3
AL		 176 u8 notify:1;
177 u8 reserved:1;
1da177e4
LT		 178};
179
180struct acpi_video_device_cap {
21fcb34e
FC		 181 u8 _ADR:1; /* Return the unique ID */
182 u8 _BCL:1; /* Query list of brightness control levels supported */
183 u8 _BCM:1; /* Set the brightness level */
2f3d000a 184 u8 _BQC:1; /* Get current brightness level */
c60d638e 185 u8 _BCQ:1; /* Some buggy BIOS uses _BCQ instead of _BQC */
21fcb34e 186 u8 _DDC:1; /* Return the EDID for this device */
1da177e4
LT		 187};
188
d32f6947
ZR		 189struct acpi_video_brightness_flags {
190 u8 _BCL_no_ac_battery_levels:1; /* no AC/Battery levels in _BCL */
21fcb34e 191 u8 _BCL_reversed:1; /* _BCL package is in a reversed order */
1a7c618a 192 u8 _BQC_use_index:1; /* _BQC returns an index value */
d32f6947
ZR		 193};
194
1da177e4 195struct acpi_video_device_brightness {
4be44fcd
LB		 196 int curr;
197 int count;
198 int *levels;
d32f6947 199 struct acpi_video_brightness_flags flags;
1da177e4
LT		 200};
201
202struct acpi_video_device {
4be44fcd
LB		 203 unsigned long device_id;
204 struct acpi_video_device_flags flags;
205 struct acpi_video_device_cap cap;
206 struct list_head entry;
8ab58e8e
LT		 207 struct delayed_work switch_brightness_work;
208 int switch_brightness_event;
4be44fcd
LB		 209 struct acpi_video_bus *video;
210 struct acpi_device *dev;
1da177e4 211 struct acpi_video_device_brightness *brightness;
2f3d000a 212 struct backlight_device *backlight;
4a703a8f 213 struct thermal_cooling_device *cooling_dev;
1da177e4
LT		 214};
215
b7171ae7 216static const char device_decode[][30] = {
1da177e4
LT		 217 "motherboard VGA device",
218 "PCI VGA device",
219 "AGP VGA device",
220 "UNKNOWN",
221};
222
4be44fcd
LB		 223static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data);
224static void acpi_video_device_rebind(struct acpi_video_bus *video);
225static void acpi_video_device_bind(struct acpi_video_bus *video,
226 struct acpi_video_device *device);
1da177e4 227static int acpi_video_device_enumerate(struct acpi_video_bus *video);
2f3d000a
YL		 228static int acpi_video_device_lcd_set_level(struct acpi_video_device *device,
229 int level);
230static int acpi_video_device_lcd_get_level_current(
231 struct acpi_video_device *device,
a89803df 232 unsigned long long *level, bool raw);
4be44fcd
LB		 233static int acpi_video_get_next_level(struct acpi_video_device *device,
234 u32 level_current, u32 event);
8ab58e8e 235static void acpi_video_switch_brightness(struct work_struct *work);
1da177e4 236
0e9f81d3
AL		 237static bool acpi_video_use_native_backlight(void)
238{
239 if (use_native_backlight_param != -1)
240 return use_native_backlight_param;
241 else
242 return use_native_backlight_dmi;
243}
244
0b9f7d93 245bool acpi_video_verify_backlight_support(void)
fbc9fe1b 246{
0e9f81d3 247 if (acpi_osi_is_win8() && acpi_video_use_native_backlight() &&
fbc9fe1b
AL		 248 backlight_device_registered(BACKLIGHT_RAW))
249 return false;
250 return acpi_video_backlight_support();
251}
0b9f7d93 252EXPORT_SYMBOL_GPL(acpi_video_verify_backlight_support);
fbc9fe1b 253
21fcb34e 254/* backlight device sysfs support */
2f3d000a
YL		 255static int acpi_video_get_brightness(struct backlight_device *bd)
256{
27663c58 257 unsigned long long cur_level;
38531e6f 258 int i;
7c364e79 259 struct acpi_video_device *vd = bl_get_data(bd);
c8890f90 260
a89803df 261 if (acpi_video_device_lcd_get_level_current(vd, &cur_level, false))
c8890f90 262 return -EINVAL;
38531e6f
MG		 263 for (i = 2; i < vd->brightness->count; i++) {
264 if (vd->brightness->levels[i] == cur_level)
21fcb34e
FC		 265 /*
266 * The first two entries are special - see page 575
267 * of the ACPI spec 3.0
268 */
915ea7e4 269 return i - 2;
38531e6f
MG		 270 }
271 return 0;
2f3d000a
YL		 272}
273
274static int acpi_video_set_brightness(struct backlight_device *bd)
275{
24450c7a 276 int request_level = bd->props.brightness + 2;
7c364e79 277 struct acpi_video_device *vd = bl_get_data(bd);
24450c7a 278
8ab58e8e 279 cancel_delayed_work(&vd->switch_brightness_work);
24450c7a
ZR		 280 return acpi_video_device_lcd_set_level(vd,
281 vd->brightness->levels[request_level]);
2f3d000a
YL		 282}
283
acc2472e 284static const struct backlight_ops acpi_backlight_ops = {
599a52d1
RP		 285 .get_brightness = acpi_video_get_brightness,
286 .update_status = acpi_video_set_brightness,
287};
288
702ed512 289/* thermal cooling device callbacks */
4a703a8f 290static int video_get_max_state(struct thermal_cooling_device *cooling_dev, unsigned
6503e5df 291 long *state)
702ed512 292{
4a703a8f 293 struct acpi_device *device = cooling_dev->devdata;
702ed512
ZR		 294 struct acpi_video_device *video = acpi_driver_data(device);
295
6503e5df
MG		 296 *state = video->brightness->count - 3;
297 return 0;
702ed512
ZR		 298}
299
4a703a8f 300static int video_get_cur_state(struct thermal_cooling_device *cooling_dev, unsigned
6503e5df 301 long *state)
702ed512 302{
4a703a8f 303 struct acpi_device *device = cooling_dev->devdata;
702ed512 304 struct acpi_video_device *video = acpi_driver_data(device);
27663c58 305 unsigned long long level;
6503e5df 306 int offset;
702ed512 307
a89803df 308 if (acpi_video_device_lcd_get_level_current(video, &level, false))
c8890f90 309 return -EINVAL;
6503e5df
MG		 310 for (offset = 2; offset < video->brightness->count; offset++)
311 if (level == video->brightness->levels[offset]) {
312 *state = video->brightness->count - offset - 1;
313 return 0;
314 }
702ed512
ZR		 315
316 return -EINVAL;
317}
318
319static int
4a703a8f 320video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long state)
702ed512 321{
4a703a8f 322 struct acpi_device *device = cooling_dev->devdata;
702ed512
ZR		 323 struct acpi_video_device *video = acpi_driver_data(device);
324 int level;
325
915ea7e4 326 if (state >= video->brightness->count - 2)
702ed512
ZR		 327 return -EINVAL;
328
329 state = video->brightness->count - state;
915ea7e4 330 level = video->brightness->levels[state - 1];
702ed512
ZR		 331 return acpi_video_device_lcd_set_level(video, level);
332}
333
9c8b04be 334static const struct thermal_cooling_device_ops video_cooling_ops = {
702ed512
ZR		 335 .get_max_state = video_get_max_state,
336 .get_cur_state = video_get_cur_state,
337 .set_cur_state = video_set_cur_state,
338};
339
21fcb34e
FC		 340/*
341 * --------------------------------------------------------------------------
342 * Video Management
343 * --------------------------------------------------------------------------
344 */
1da177e4 345
1da177e4 346static int
4be44fcd
LB		 347acpi_video_device_lcd_query_levels(struct acpi_video_device *device,
348 union acpi_object **levels)
1da177e4 349{
4be44fcd
LB		 350 int status;
351 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
352 union acpi_object *obj;
1da177e4 353
1da177e4
LT		 354
355 *levels = NULL;
356
90130268 357 status = acpi_evaluate_object(device->dev->handle, "_BCL", NULL, &buffer);
1da177e4 358 if (!ACPI_SUCCESS(status))
d550d98d 359 return status;
4be44fcd 360 obj = (union acpi_object *)buffer.pointer;
6665bda7 361 if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
6468463a 362 printk(KERN_ERR PREFIX "Invalid _BCL data\n");
1da177e4
LT		 363 status = -EFAULT;
364 goto err;
365 }
366
367 *levels = obj;
368
d550d98d 369 return 0;
1da177e4 370
915ea7e4 371err:
6044ec88 372 kfree(buffer.pointer);
1da177e4 373
d550d98d 374 return status;
1da177e4
LT		 375}
376
377static int
4be44fcd 378acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level)
1da177e4 379{
24450c7a 380 int status;
9e6dada9 381 int state;
1da177e4 382
0db98202
JL		 383 status = acpi_execute_simple_method(device->dev->handle,
384 "_BCM", level);
24450c7a
ZR		 385 if (ACPI_FAILURE(status)) {
386 ACPI_ERROR((AE_INFO, "Evaluating _BCM failed"));
387 return -EIO;
388 }
389
4500ca8e 390 device->brightness->curr = level;
9e6dada9 391 for (state = 2; state < device->brightness->count; state++)
24450c7a 392 if (level == device->brightness->levels[state]) {
1a7c618a
ZR		 393 if (device->backlight)
394 device->backlight->props.brightness = state - 2;
24450c7a
ZR		 395 return 0;
396 }
9e6dada9 397
24450c7a
ZR		 398 ACPI_ERROR((AE_INFO, "Current brightness invalid"));
399 return -EINVAL;
1da177e4
LT		 400}
401
45cb50e6
ZR		 402/*
403 * For some buggy _BQC methods, we need to add a constant value to
404 * the _BQC return value to get the actual current brightness level
405 */
406
407static int bqc_offset_aml_bug_workaround;
408static int __init video_set_bqc_offset(const struct dmi_system_id *d)
409{
410 bqc_offset_aml_bug_workaround = 9;
411 return 0;
412}
413
0e9f81d3
AL		 414static int __init video_set_use_native_backlight(const struct dmi_system_id *d)
415{
416 use_native_backlight_dmi = true;
417 return 0;
418}
419
45cb50e6
ZR		 420static struct dmi_system_id video_dmi_table[] __initdata = {
421 /*
422 * Broken _BQC workaround http://bugzilla.kernel.org/show_bug.cgi?id=13121
423 */
424 {
425 .callback = video_set_bqc_offset,
426 .ident = "Acer Aspire 5720",
427 .matches = {
428 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
429 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5720"),
430 },
431 },
5afc4abe
LB		 432 {
433 .callback = video_set_bqc_offset,
434 .ident = "Acer Aspire 5710Z",
435 .matches = {
436 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
437 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5710Z"),
438 },
439 },
34ac272b
ZR		 440 {
441 .callback = video_set_bqc_offset,
442 .ident = "eMachines E510",
443 .matches = {
444 DMI_MATCH(DMI_BOARD_VENDOR, "EMACHINES"),
445 DMI_MATCH(DMI_PRODUCT_NAME, "eMachines E510"),
446 },
447 },
93bcece2
ZR		 448 {
449 .callback = video_set_bqc_offset,
450 .ident = "Acer Aspire 5315",
451 .matches = {
452 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
453 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5315"),
454 },
455 },
152a4e63
ZR		 456 {
457 .callback = video_set_bqc_offset,
458 .ident = "Acer Aspire 7720",
459 .matches = {
460 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
461 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7720"),
462 },
463 },
0e9f81d3
AL		 464 {
465 .callback = video_set_use_native_backlight,
43d94902 466 .ident = "ThinkPad T430 and T430s",
0e9f81d3
AL		 467 .matches = {
468 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
43d94902 469 DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad T430"),
0e9f81d3
AL		 470 },
471 },
472 {
473 .callback = video_set_use_native_backlight,
474 .ident = "ThinkPad X230",
475 .matches = {
476 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
477 DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad X230"),
478 },
479 },
1e815db6
HG		 480 {
481 .callback = video_set_use_native_backlight,
482 .ident = "ThinkPad W530",
483 .matches = {
484 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
485 DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad W530"),
486 },
487 },
43d94902
HG		 488 {
489 .callback = video_set_use_native_backlight,
0e9f81d3
AL		 490 .ident = "ThinkPad X1 Carbon",
491 .matches = {
492 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
493 DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad X1 Carbon"),
494 },
495 },
496 {
497 .callback = video_set_use_native_backlight,
498 .ident = "Lenovo Yoga 13",
499 .matches = {
500 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
501 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo IdeaPad Yoga 13"),
502 },
503 },
0dc6b96a
HG		 504 {
505 .callback = video_set_use_native_backlight,
506 .ident = "Lenovo Yoga 2 11",
507 .matches = {
508 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
509 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Yoga 2 11"),
510 },
511 },
997dd7fe
SCP		 512 {
513 .callback = video_set_use_native_backlight,
514 .ident = "Thinkpad Helix",
515 .matches = {
516 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
517 DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad Helix"),
518 },
519 },
0e9f81d3
AL		 520 {
521 .callback = video_set_use_native_backlight,
522 .ident = "Dell Inspiron 7520",
523 .matches = {
524 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
5ff365fb 525 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 7520"),
0e9f81d3
AL		 526 },
527 },
528 {
529 .callback = video_set_use_native_backlight,
530 .ident = "Acer Aspire 5733Z",
531 .matches = {
532 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
533 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5733Z"),
534 },
535 },
43d94902
HG		 536 {
537 .callback = video_set_use_native_backlight,
538 .ident = "Acer Aspire 5742G",
539 .matches = {
540 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
541 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5742G"),
542 },
543 },
0dc6b96a
HG		 544 {
545 .callback = video_set_use_native_backlight,
546 .ident = "Acer Aspire V5-171",
547 .matches = {
548 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
549 DMI_MATCH(DMI_PRODUCT_NAME, "V5-171"),
550 },
551 },
0e9f81d3
AL		 552 {
553 .callback = video_set_use_native_backlight,
554 .ident = "Acer Aspire V5-431",
555 .matches = {
556 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
557 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-431"),
558 },
559 },
0dc6b96a
HG		 560 {
561 .callback = video_set_use_native_backlight,
562 .ident = "Acer Aspire V5-471G",
563 .matches = {
564 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
565 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-471G"),
566 },
567 },
ab7027de
MK		 568 {
569 .callback = video_set_use_native_backlight,
570 .ident = "Acer TravelMate B113",
571 .matches = {
572 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
573 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate B113"),
574 },
575 },
0e9f81d3
AL		 576 {
577 .callback = video_set_use_native_backlight,
578 .ident = "HP ProBook 4340s",
579 .matches = {
580 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
581 DMI_MATCH(DMI_PRODUCT_VERSION, "HP ProBook 4340s"),
582 },
583 },
584 {
585 .callback = video_set_use_native_backlight,
4cf465b5
HG		 586 .ident = "HP ProBook 4540s",
587 .matches = {
588 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
589 DMI_MATCH(DMI_PRODUCT_VERSION, "HP ProBook 4540s"),
590 },
591 },
592 {
593 .callback = video_set_use_native_backlight,
0e9f81d3
AL		 594 .ident = "HP ProBook 2013 models",
595 .matches = {
596 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
597 DMI_MATCH(DMI_PRODUCT_NAME, "HP ProBook "),
598 DMI_MATCH(DMI_PRODUCT_NAME, " G1"),
599 },
600 },
601 {
602 .callback = video_set_use_native_backlight,
603 .ident = "HP EliteBook 2013 models",
604 .matches = {
605 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
606 DMI_MATCH(DMI_PRODUCT_NAME, "HP EliteBook "),
607 DMI_MATCH(DMI_PRODUCT_NAME, " G1"),
608 },
609 },
610 {
611 .callback = video_set_use_native_backlight,
612 .ident = "HP ZBook 14",
613 .matches = {
614 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
615 DMI_MATCH(DMI_PRODUCT_NAME, "HP ZBook 14"),
616 },
617 },
618 {
619 .callback = video_set_use_native_backlight,
620 .ident = "HP ZBook 15",
621 .matches = {
622 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
623 DMI_MATCH(DMI_PRODUCT_NAME, "HP ZBook 15"),
624 },
625 },
626 {
627 .callback = video_set_use_native_backlight,
628 .ident = "HP ZBook 17",
629 .matches = {
630 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
631 DMI_MATCH(DMI_PRODUCT_NAME, "HP ZBook 17"),
632 },
633 },
634 {
635 .callback = video_set_use_native_backlight,
0dc6b96a
HG		 636 .ident = "HP EliteBook 8470p",
637 .matches = {
638 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
639 DMI_MATCH(DMI_PRODUCT_NAME, "HP EliteBook 8470p"),
640 },
641 },
642 {
643 .callback = video_set_use_native_backlight,
0e9f81d3
AL		 644 .ident = "HP EliteBook 8780w",
645 .matches = {
646 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
647 DMI_MATCH(DMI_PRODUCT_NAME, "HP EliteBook 8780w"),
648 },
649 },
45cb50e6
ZR		 650 {}
651};
652
994fa63c
DB		 653static unsigned long long
654acpi_video_bqc_value_to_level(struct acpi_video_device *device,
655 unsigned long long bqc_value)
656{
657 unsigned long long level;
658
659 if (device->brightness->flags._BQC_use_index) {
660 /*
661 * _BQC returns an index that doesn't account for
662 * the first 2 items with special meaning, so we need
663 * to compensate for that by offsetting ourselves
664 */
665 if (device->brightness->flags._BCL_reversed)
666 bqc_value = device->brightness->count - 3 - bqc_value;
667
668 level = device->brightness->levels[bqc_value + 2];
669 } else {
670 level = bqc_value;
671 }
672
673 level += bqc_offset_aml_bug_workaround;
674
675 return level;
676}
677
1da177e4 678static int
4be44fcd 679acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
a89803df 680 unsigned long long *level, bool raw)
1da177e4 681{
c8890f90 682 acpi_status status = AE_OK;
4e231fa4 683 int i;
c8890f90 684
c60d638e
ZR		 685 if (device->cap._BQC || device->cap._BCQ) {
686 char *buf = device->cap._BQC ? "_BQC" : "_BCQ";
687
688 status = acpi_evaluate_integer(device->dev->handle, buf,
c8890f90
ZR		 689 NULL, level);
690 if (ACPI_SUCCESS(status)) {
a89803df
DB		 691 if (raw) {
692 /*
693 * Caller has indicated he wants the raw
694 * value returned by _BQC, so don't furtherly
695 * mess with the value.
696 */
697 return 0;
698 }
699
994fa63c 700 *level = acpi_video_bqc_value_to_level(device, *level);
1a7c618a 701
4e231fa4
VS		 702 for (i = 2; i < device->brightness->count; i++)
703 if (device->brightness->levels[i] == *level) {
704 device->brightness->curr = *level;
705 return 0;
915ea7e4 706 }
a89803df
DB		 707 /*
708 * BQC returned an invalid level.
709 * Stop using it.
710 */
711 ACPI_WARNING((AE_INFO,
712 "%s returned an invalid level",
713 buf));
714 device->cap._BQC = device->cap._BCQ = 0;
c8890f90 715 } else {
21fcb34e
FC		 716 /*
717 * Fixme:
c8890f90
ZR		 718 * should we return an error or ignore this failure?
719 * dev->brightness->curr is a cached value which stores
720 * the correct current backlight level in most cases.
721 * ACPI video backlight still works w/ buggy _BQC.
722 * http://bugzilla.kernel.org/show_bug.cgi?id=12233
723 */
c60d638e
ZR		 724 ACPI_WARNING((AE_INFO, "Evaluating %s failed", buf));
725 device->cap._BQC = device->cap._BCQ = 0;
c8890f90
ZR		 726 }
727 }
728
4500ca8e 729 *level = device->brightness->curr;
c8890f90 730 return 0;
1da177e4
LT		 731}
732
733static int
4be44fcd
LB		 734acpi_video_device_EDID(struct acpi_video_device *device,
735 union acpi_object **edid, ssize_t length)
1da177e4 736{
4be44fcd
LB		 737 int status;
738 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
739 union acpi_object *obj;
740 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
741 struct acpi_object_list args = { 1, &arg0 };
1da177e4 742
1da177e4
LT		 743
744 *edid = NULL;
745
746 if (!device)
d550d98d 747 return -ENODEV;
1da177e4
LT		 748 if (length == 128)
749 arg0.integer.value = 1;
750 else if (length == 256)
751 arg0.integer.value = 2;
752 else
d550d98d 753 return -EINVAL;
1da177e4 754
90130268 755 status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer);
1da177e4 756 if (ACPI_FAILURE(status))
d550d98d 757 return -ENODEV;
1da177e4 758
50dd0969 759 obj = buffer.pointer;
1da177e4
LT		 760
761 if (obj && obj->type == ACPI_TYPE_BUFFER)
762 *edid = obj;
763 else {
6468463a 764 printk(KERN_ERR PREFIX "Invalid _DDC data\n");
1da177e4
LT		 765 status = -EFAULT;
766 kfree(obj);
767 }
768
d550d98d 769 return status;
1da177e4
LT		 770}
771
1da177e4
LT		 772/* bus */
773
1da177e4
LT		 774/*
775 * Arg:
21fcb34e
FC		 776 * video : video bus device pointer
777 * bios_flag :
1da177e4
LT		 778 * 0. The system BIOS should NOT automatically switch(toggle)
779 * the active display output.
780 * 1. The system BIOS should automatically switch (toggle) the
98fb8fe1 781 * active display output. No switch event.
1da177e4
LT		 782 * 2. The _DGS value should be locked.
783 * 3. The system BIOS should not automatically switch (toggle) the
784 * active display output, but instead generate the display switch
785 * event notify code.
786 * lcd_flag :
787 * 0. The system BIOS should automatically control the brightness level
98fb8fe1 788 * of the LCD when the power changes from AC to DC
21fcb34e 789 * 1. The system BIOS should NOT automatically control the brightness
98fb8fe1 790 * level of the LCD when the power changes from AC to DC.
21fcb34e 791 * Return Value:
ea9f8856 792 * -EINVAL wrong arg.
1da177e4
LT		 793 */
794
795static int
4be44fcd 796acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
1da177e4 797{
ea9f8856 798 acpi_status status;
1da177e4 799
b0373843
ZR		 800 if (!video->cap._DOS)
801 return 0;
1da177e4 802
ea9f8856
IM		 803 if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1)
804 return -EINVAL;
0db98202
JL		 805 video->dos_setting = (lcd_flag << 2) | bios_flag;
806 status = acpi_execute_simple_method(video->device->handle, "_DOS",
807 (lcd_flag << 2) | bios_flag);
ea9f8856
IM		 808 if (ACPI_FAILURE(status))
809 return -EIO;
1da177e4 810
ea9f8856 811 return 0;
1da177e4
LT		 812}
813
935e5f29
ZR		 814/*
815 * Simple comparison function used to sort backlight levels.
816 */
817
818static int
819acpi_video_cmp_level(const void *a, const void *b)
820{
821 return *(int *)a - *(int *)b;
822}
823
a50188da
AL		 824/*
825 * Decides if _BQC/_BCQ for this system is usable
826 *
827 * We do this by changing the level first and then read out the current
828 * brightness level, if the value does not match, find out if it is using
829 * index. If not, clear the _BQC/_BCQ capability.
830 */
831static int acpi_video_bqc_quirk(struct acpi_video_device *device,
832 int max_level, int current_level)
833{
834 struct acpi_video_device_brightness *br = device->brightness;
835 int result;
836 unsigned long long level;
837 int test_level;
838
839 /* don't mess with existing known broken systems */
840 if (bqc_offset_aml_bug_workaround)
841 return 0;
842
843 /*
844 * Some systems always report current brightness level as maximum
845 * through _BQC, we need to test another value for them.
846 */
b3b301c5 847 test_level = current_level == max_level ? br->levels[3] : max_level;
a50188da
AL		 848
849 result = acpi_video_device_lcd_set_level(device, test_level);
850 if (result)
851 return result;
852
853 result = acpi_video_device_lcd_get_level_current(device, &level, true);
854 if (result)
855 return result;
856
857 if (level != test_level) {
858 /* buggy _BQC found, need to find out if it uses index */
859 if (level < br->count) {
860 if (br->flags._BCL_reversed)
861 level = br->count - 3 - level;
862 if (br->levels[level + 2] == test_level)
863 br->flags._BQC_use_index = 1;
864 }
865
866 if (!br->flags._BQC_use_index)
867 device->cap._BQC = device->cap._BCQ = 0;
868 }
869
870 return 0;
871}
872
873
1da177e4 874/*
21fcb34e
FC		 875 * Arg:
876 * device : video output device (LCD, CRT, ..)
1da177e4
LT		 877 *
878 * Return Value:
469778c1
JJ		 879 * Maximum brightness level
880 *
881 * Allocate and initialize device->brightness.
882 */
883
884static int
885acpi_video_init_brightness(struct acpi_video_device *device)
886{
887 union acpi_object *obj = NULL;
d32f6947 888 int i, max_level = 0, count = 0, level_ac_battery = 0;
1a7c618a 889 unsigned long long level, level_old;
469778c1
JJ		 890 union acpi_object *o;
891 struct acpi_video_device_brightness *br = NULL;
1a7c618a 892 int result = -EINVAL;
bd8ba205 893 u32 value;
469778c1
JJ		 894
895 if (!ACPI_SUCCESS(acpi_video_device_lcd_query_levels(device, &obj))) {
896 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Could not query available "
897 "LCD brightness level\n"));
898 goto out;
899 }
900
901 if (obj->package.count < 2)
902 goto out;
903
904 br = kzalloc(sizeof(*br), GFP_KERNEL);
905 if (!br) {
906 printk(KERN_ERR "can't allocate memory\n");
1a7c618a 907 result = -ENOMEM;
469778c1
JJ		 908 goto out;
909 }
910
d32f6947 911 br->levels = kmalloc((obj->package.count + 2) * sizeof *(br->levels),
469778c1 912 GFP_KERNEL);
1a7c618a
ZR		 913 if (!br->levels) {
914 result = -ENOMEM;
469778c1 915 goto out_free;
1a7c618a 916 }
469778c1
JJ		 917
918 for (i = 0; i < obj->package.count; i++) {
919 o = (union acpi_object *)&obj->package.elements[i];
920 if (o->type != ACPI_TYPE_INTEGER) {
921 printk(KERN_ERR PREFIX "Invalid data\n");
922 continue;
923 }
bd8ba205
HG		 924 value = (u32) o->integer.value;
925 /* Skip duplicate entries */
926 if (count > 2 && br->levels[count - 1] == value)
927 continue;
928
929 br->levels[count] = value;
469778c1
JJ		 930
931 if (br->levels[count] > max_level)
932 max_level = br->levels[count];
933 count++;
934 }
935
d32f6947
ZR		 936 /*
937 * some buggy BIOS don't export the levels
938 * when machine is on AC/Battery in _BCL package.
939 * In this case, the first two elements in _BCL packages
940 * are also supported brightness levels that OS should take care of.
941 */
90af2cf6
ZR		 942 for (i = 2; i < count; i++) {
943 if (br->levels[i] == br->levels[0])
d32f6947 944 level_ac_battery++;
90af2cf6
ZR		 945 if (br->levels[i] == br->levels[1])
946 level_ac_battery++;
947 }
d32f6947
ZR		 948
949 if (level_ac_battery < 2) {
950 level_ac_battery = 2 - level_ac_battery;
951 br->flags._BCL_no_ac_battery_levels = 1;
952 for (i = (count - 1 + level_ac_battery); i >= 2; i--)
953 br->levels[i] = br->levels[i - level_ac_battery];
954 count += level_ac_battery;
955 } else if (level_ac_battery > 2)
bf6787eb 956 ACPI_ERROR((AE_INFO, "Too many duplicates in _BCL package"));
d32f6947 957
d80fb99f
ZR		 958 /* Check if the _BCL package is in a reversed order */
959 if (max_level == br->levels[2]) {
960 br->flags._BCL_reversed = 1;
961 sort(&br->levels[2], count - 2, sizeof(br->levels[2]),
962 acpi_video_cmp_level, NULL);
963 } else if (max_level != br->levels[count - 1])
964 ACPI_ERROR((AE_INFO,
bf6787eb 965 "Found unordered _BCL package"));
469778c1
JJ		 966
967 br->count = count;
968 device->brightness = br;
1a7c618a 969
1a7c618a 970 /* _BQC uses INDEX while _BCL uses VALUE in some laptops */
90c53ca4 971 br->curr = level = max_level;
e047cca6
ZR		 972
973 if (!device->cap._BQC)
974 goto set_level;
975
a89803df
DB		 976 result = acpi_video_device_lcd_get_level_current(device,
977 &level_old, true);
1a7c618a
ZR		 978 if (result)
979 goto out_free_levels;
980
a50188da 981 result = acpi_video_bqc_quirk(device, max_level, level_old);
1a7c618a
ZR		 982 if (result)
983 goto out_free_levels;
a50188da
AL		 984 /*
985 * cap._BQC may get cleared due to _BQC is found to be broken
986 * in acpi_video_bqc_quirk, so check again here.
987 */
988 if (!device->cap._BQC)
989 goto set_level;
e047cca6 990
545ef368
AL		 991 level = acpi_video_bqc_value_to_level(device, level_old);
992 /*
993 * On some buggy laptops, _BQC returns an uninitialized
994 * value when invoked for the first time, i.e.
995 * level_old is invalid (no matter whether it's a level
996 * or an index). Set the backlight to max_level in this case.
997 */
998 for (i = 2; i < br->count; i++)
999 if (level == br->levels[i])
1000 break;
1001 if (i == br->count || !level)
1002 level = max_level;
e047cca6 1003
e047cca6 1004set_level:
90c53ca4 1005 result = acpi_video_device_lcd_set_level(device, level);
e047cca6
ZR		 1006 if (result)
1007 goto out_free_levels;
1a7c618a 1008
d32f6947
ZR		 1009 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1010 "found %d brightness levels\n", count - 2));
469778c1 1011 kfree(obj);
1a7c618a 1012 return result;
469778c1
JJ		 1013
1014out_free_levels:
1015 kfree(br->levels);
1016out_free:
1017 kfree(br);
1018out:
1019 device->brightness = NULL;
1020 kfree(obj);
1a7c618a 1021 return result;
469778c1
JJ		 1022}
1023
1024/*
1025 * Arg:
1026 * device : video output device (LCD, CRT, ..)
1027 *
1028 * Return Value:
21fcb34e 1029 * None
1da177e4 1030 *
98fb8fe1 1031 * Find out all required AML methods defined under the output
1da177e4
LT		 1032 * device.
1033 */
1034
4be44fcd 1035static void acpi_video_device_find_cap(struct acpi_video_device *device)
1da177e4 1036{
952c63e9 1037 if (acpi_has_method(device->dev->handle, "_ADR"))
1da177e4 1038 device->cap._ADR = 1;
952c63e9 1039 if (acpi_has_method(device->dev->handle, "_BCL"))
4be44fcd 1040 device->cap._BCL = 1;
952c63e9 1041 if (acpi_has_method(device->dev->handle, "_BCM"))
4be44fcd 1042 device->cap._BCM = 1;
952c63e9 1043 if (acpi_has_method(device->dev->handle, "_BQC")) {
2f3d000a 1044 device->cap._BQC = 1;
952c63e9 1045 } else if (acpi_has_method(device->dev->handle, "_BCQ")) {
c60d638e
ZR		 1046 printk(KERN_WARNING FW_BUG "_BCQ is used instead of _BQC\n");
1047 device->cap._BCQ = 1;
1048 }
1049
952c63e9 1050 if (acpi_has_method(device->dev->handle, "_DDC"))
4be44fcd 1051 device->cap._DDC = 1;
1da177e4
LT		 1052}
1053
1054/*
21fcb34e
FC		 1055 * Arg:
1056 * device : video output device (VGA)
1da177e4
LT		 1057 *
1058 * Return Value:
21fcb34e 1059 * None
1da177e4 1060 *
98fb8fe1 1061 * Find out all required AML methods defined under the video bus device.
1da177e4
LT		 1062 */
1063
4be44fcd 1064static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
1da177e4 1065{
952c63e9 1066 if (acpi_has_method(video->device->handle, "_DOS"))
1da177e4 1067 video->cap._DOS = 1;
952c63e9 1068 if (acpi_has_method(video->device->handle, "_DOD"))
1da177e4 1069 video->cap._DOD = 1;
952c63e9 1070 if (acpi_has_method(video->device->handle, "_ROM"))
1da177e4 1071 video->cap._ROM = 1;
952c63e9 1072 if (acpi_has_method(video->device->handle, "_GPD"))
1da177e4 1073 video->cap._GPD = 1;
952c63e9 1074 if (acpi_has_method(video->device->handle, "_SPD"))
1da177e4 1075 video->cap._SPD = 1;
952c63e9 1076 if (acpi_has_method(video->device->handle, "_VPO"))
1da177e4 1077 video->cap._VPO = 1;
1da177e4
LT		 1078}
1079
1080/*
1081 * Check whether the video bus device has required AML method to
1082 * support the desired features
1083 */
1084
4be44fcd 1085static int acpi_video_bus_check(struct acpi_video_bus *video)
1da177e4 1086{
4be44fcd 1087 acpi_status status = -ENOENT;
1e4cffe7 1088 struct pci_dev *dev;
1da177e4
LT		 1089
1090 if (!video)
d550d98d 1091 return -EINVAL;
1da177e4 1092
1e4cffe7 1093 dev = acpi_get_pci_dev(video->device->handle);
22c13f9d
TR		 1094 if (!dev)
1095 return -ENODEV;
1e4cffe7 1096 pci_dev_put(dev);
22c13f9d 1097
21fcb34e
FC		 1098 /*
1099 * Since there is no HID, CID and so on for VGA driver, we have
1da177e4
LT		 1100 * to check well known required nodes.
1101 */
1102
98fb8fe1 1103 /* Does this device support video switching? */
3a1151e3
SB		 1104 if (video->cap._DOS || video->cap._DOD) {
1105 if (!video->cap._DOS) {
1106 printk(KERN_WARNING FW_BUG
1107 "ACPI(%s) defines _DOD but not _DOS\n",
1108 acpi_device_bid(video->device));
1109 }
1da177e4
LT		 1110 video->flags.multihead = 1;
1111 status = 0;
1112 }
1113
98fb8fe1 1114 /* Does this device support retrieving a video ROM? */
4be44fcd 1115 if (video->cap._ROM) {
1da177e4
LT		 1116 video->flags.rom = 1;
1117 status = 0;
1118 }
1119
98fb8fe1 1120 /* Does this device support configuring which video device to POST? */
4be44fcd 1121 if (video->cap._GPD && video->cap._SPD && video->cap._VPO) {
1da177e4
LT		 1122 video->flags.post = 1;
1123 status = 0;
1124 }
1125
d550d98d 1126 return status;
1da177e4
LT		 1127}
1128
21fcb34e
FC		 1129/*
1130 * --------------------------------------------------------------------------
1131 * Driver Interface
1132 * --------------------------------------------------------------------------
1133 */
1da177e4
LT		 1134
1135/* device interface */
915ea7e4 1136static struct acpi_video_device_attrib *
82cae999
RZ		 1137acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id)
1138{
78eed028
DT		 1139 struct acpi_video_enumerated_device *ids;
1140 int i;
1141
1142 for (i = 0; i < video->attached_count; i++) {
1143 ids = &video->attached_array[i];
1144 if ((ids->value.int_val & 0xffff) == device_id)
1145 return &ids->value.attrib;
1146 }
82cae999 1147
82cae999
RZ		 1148 return NULL;
1149}
1da177e4 1150
e92a7162
MG		 1151static int
1152acpi_video_get_device_type(struct acpi_video_bus *video,
1153 unsigned long device_id)
1154{
1155 struct acpi_video_enumerated_device *ids;
1156 int i;
1157
1158 for (i = 0; i < video->attached_count; i++) {
1159 ids = &video->attached_array[i];
1160 if ((ids->value.int_val & 0xffff) == device_id)
1161 return ids->value.int_val;
1162 }
1163
1164 return 0;
1165}
1166
1da177e4 1167static int
4be44fcd
LB		 1168acpi_video_bus_get_one_device(struct acpi_device *device,
1169 struct acpi_video_bus *video)
1da177e4 1170{
27663c58 1171 unsigned long long device_id;
e92a7162 1172 int status, device_type;
4be44fcd 1173 struct acpi_video_device *data;
915ea7e4 1174 struct acpi_video_device_attrib *attribute;
1da177e4 1175
4be44fcd
LB		 1176 status =
1177 acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
91e13aa3
AL		 1178 /* Some device omits _ADR, we skip them instead of fail */
1179 if (ACPI_FAILURE(status))
1180 return 0;
1da177e4 1181
91e13aa3
AL		 1182 data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
1183 if (!data)
1184 return -ENOMEM;
82cae999 1185
91e13aa3
AL		 1186 strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
1187 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
1188 device->driver_data = data;
1189
1190 data->device_id = device_id;
1191 data->video = video;
1192 data->dev = device;
8ab58e8e
LT		 1193 INIT_DELAYED_WORK(&data->switch_brightness_work,
1194 acpi_video_switch_brightness);
91e13aa3
AL		 1195
1196 attribute = acpi_video_get_device_attr(video, device_id);
1197
915ea7e4 1198 if (attribute && attribute->device_id_scheme) {
91e13aa3
AL		 1199 switch (attribute->display_type) {
1200 case ACPI_VIDEO_DISPLAY_CRT:
1201 data->flags.crt = 1;
1202 break;
1203 case ACPI_VIDEO_DISPLAY_TV:
1204 data->flags.tvout = 1;
1205 break;
1206 case ACPI_VIDEO_DISPLAY_DVI:
1207 data->flags.dvi = 1;
1208 break;
1209 case ACPI_VIDEO_DISPLAY_LCD:
1210 data->flags.lcd = 1;
1211 break;
1212 default:
1213 data->flags.unknown = 1;
1214 break;
1215 }
915ea7e4 1216 if (attribute->bios_can_detect)
91e13aa3
AL		 1217 data->flags.bios = 1;
1218 } else {
1219 /* Check for legacy IDs */
1220 device_type = acpi_video_get_device_type(video, device_id);
1221 /* Ignore bits 16 and 18-20 */
1222 switch (device_type & 0xffe2ffff) {
915ea7e4
FC		 1223 case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR:
1224 data->flags.crt = 1;
1225 break;
1226 case ACPI_VIDEO_DISPLAY_LEGACY_PANEL:
1227 data->flags.lcd = 1;
1228 break;
1229 case ACPI_VIDEO_DISPLAY_LEGACY_TV:
1230 data->flags.tvout = 1;
1231 break;
1232 default:
1233 data->flags.unknown = 1;
e92a7162 1234 }
91e13aa3 1235 }
4be44fcd 1236
91e13aa3
AL		 1237 acpi_video_device_bind(video, data);
1238 acpi_video_device_find_cap(data);
1da177e4 1239
91e13aa3
AL		 1240 mutex_lock(&video->device_list_lock);
1241 list_add_tail(&data->entry, &video->video_device_list);
1242 mutex_unlock(&video->device_list_lock);
1da177e4 1243
91e13aa3 1244 return status;
1da177e4
LT		 1245}
1246
1247/*
1248 * Arg:
21fcb34e 1249 * video : video bus device
1da177e4
LT		 1250 *
1251 * Return:
21fcb34e
FC		 1252 * none
1253 *
1254 * Enumerate the video device list of the video bus,
1da177e4
LT		 1255 * bind the ids with the corresponding video devices
1256 * under the video bus.
4be44fcd 1257 */
1da177e4 1258
4be44fcd 1259static void acpi_video_device_rebind(struct acpi_video_bus *video)
1da177e4 1260{
ff102ea9
DT		 1261 struct acpi_video_device *dev;
1262
bbac81f5 1263 mutex_lock(&video->device_list_lock);
ff102ea9
DT		 1264
1265 list_for_each_entry(dev, &video->video_device_list, entry)
4be44fcd 1266 acpi_video_device_bind(video, dev);
ff102ea9 1267
bbac81f5 1268 mutex_unlock(&video->device_list_lock);
1da177e4
LT		 1269}
1270
1271/*
1272 * Arg:
21fcb34e
FC		 1273 * video : video bus device
1274 * device : video output device under the video
1275 * bus
1da177e4
LT		 1276 *
1277 * Return:
21fcb34e
FC		 1278 * none
1279 *
1da177e4
LT		 1280 * Bind the ids with the corresponding video devices
1281 * under the video bus.
4be44fcd 1282 */
1da177e4
LT		 1283
1284static void
4be44fcd
LB		 1285acpi_video_device_bind(struct acpi_video_bus *video,
1286 struct acpi_video_device *device)
1da177e4 1287{
78eed028 1288 struct acpi_video_enumerated_device *ids;
4be44fcd 1289 int i;
1da177e4 1290
78eed028
DT		 1291 for (i = 0; i < video->attached_count; i++) {
1292 ids = &video->attached_array[i];
1293 if (device->device_id == (ids->value.int_val & 0xffff)) {
1294 ids->bind_info = device;
1da177e4
LT		 1295 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "device_bind %d\n", i));
1296 }
1297 }
1da177e4
LT		 1298}
1299
1300/*
1301 * Arg:
21fcb34e 1302 * video : video bus device
1da177e4
LT		 1303 *
1304 * Return:
21fcb34e
FC		 1305 * < 0 : error
1306 *
1da177e4
LT		 1307 * Call _DOD to enumerate all devices attached to display adapter
1308 *
4be44fcd 1309 */
1da177e4
LT		 1310
1311static int acpi_video_device_enumerate(struct acpi_video_bus *video)
1312{
4be44fcd
LB		 1313 int status;
1314 int count;
1315 int i;
78eed028 1316 struct acpi_video_enumerated_device *active_list;
4be44fcd
LB		 1317 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1318 union acpi_object *dod = NULL;
1319 union acpi_object *obj;
1da177e4 1320
90130268 1321 status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
1da177e4 1322 if (!ACPI_SUCCESS(status)) {
a6fc6720 1323 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD"));
d550d98d 1324 return status;
1da177e4
LT		 1325 }
1326
50dd0969 1327 dod = buffer.pointer;
1da177e4 1328 if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
a6fc6720 1329 ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data"));
1da177e4
LT		 1330 status = -EFAULT;
1331 goto out;
1332 }
1333
1334 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d video heads in _DOD\n",
4be44fcd 1335 dod->package.count));
1da177e4 1336
78eed028
DT		 1337 active_list = kcalloc(1 + dod->package.count,
1338 sizeof(struct acpi_video_enumerated_device),
1339 GFP_KERNEL);
1340 if (!active_list) {
1da177e4
LT		 1341 status = -ENOMEM;
1342 goto out;
1343 }
1344
1345 count = 0;
1346 for (i = 0; i < dod->package.count; i++) {
50dd0969 1347 obj = &dod->package.elements[i];
1da177e4
LT		 1348
1349 if (obj->type != ACPI_TYPE_INTEGER) {
78eed028
DT		 1350 printk(KERN_ERR PREFIX
1351 "Invalid _DOD data in element %d\n", i);
1352 continue;
1da177e4 1353 }
78eed028
DT		 1354
1355 active_list[count].value.int_val = obj->integer.value;
1356 active_list[count].bind_info = NULL;
4be44fcd
LB		 1357 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "dod element[%d] = %d\n", i,
1358 (int)obj->integer.value));
1da177e4
LT		 1359 count++;
1360 }
1da177e4 1361
6044ec88 1362 kfree(video->attached_array);
4be44fcd 1363
78eed028 1364 video->attached_array = active_list;
1da177e4 1365 video->attached_count = count;
78eed028 1366
915ea7e4 1367out:
02438d87 1368 kfree(buffer.pointer);
d550d98d 1369 return status;
1da177e4
LT		 1370}
1371
4be44fcd
LB		 1372static int
1373acpi_video_get_next_level(struct acpi_video_device *device,
1374 u32 level_current, u32 event)
1da177e4 1375{
63f0edfc 1376 int min, max, min_above, max_below, i, l, delta = 255;
f4715189
TT		 1377 max = max_below = 0;
1378 min = min_above = 255;
63f0edfc 1379 /* Find closest level to level_current */
0a3db1ce 1380 for (i = 2; i < device->brightness->count; i++) {
63f0edfc
AS		 1381 l = device->brightness->levels[i];
1382 if (abs(l - level_current) < abs(delta)) {
1383 delta = l - level_current;
1384 if (!delta)
1385 break;
1386 }
1387 }
1388 /* Ajust level_current to closest available level */
1389 level_current += delta;
0a3db1ce 1390 for (i = 2; i < device->brightness->count; i++) {
f4715189
TT		 1391 l = device->brightness->levels[i];
1392 if (l < min)
1393 min = l;
1394 if (l > max)
1395 max = l;
1396 if (l < min_above && l > level_current)
1397 min_above = l;
1398 if (l > max_below && l < level_current)
1399 max_below = l;
1400 }
1401
1402 switch (event) {
1403 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:
1404 return (level_current < max) ? min_above : min;
1405 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:
1406 return (level_current < max) ? min_above : max;
1407 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:
1408 return (level_current > min) ? max_below : min;
1409 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:
1410 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:
1411 return 0;
1412 default:
1413 return level_current;
1414 }
1da177e4
LT		 1415}
1416
8ab58e8e
LT		 1417static void
1418acpi_video_switch_brightness(struct work_struct *work)
1da177e4 1419{
8ab58e8e
LT		 1420 struct acpi_video_device *device = container_of(to_delayed_work(work),
1421 struct acpi_video_device, switch_brightness_work);
27663c58 1422 unsigned long long level_current, level_next;
8ab58e8e 1423 int event = device->switch_brightness_event;
c8890f90
ZR		 1424 int result = -EINVAL;
1425
fbc9fe1b
AL		 1426 /* no warning message if acpi_backlight=vendor or a quirk is used */
1427 if (!acpi_video_verify_backlight_support())
8ab58e8e 1428 return;
28c32e99 1429
469778c1 1430 if (!device->brightness)
c8890f90
ZR		 1431 goto out;
1432
1433 result = acpi_video_device_lcd_get_level_current(device,
a89803df
DB		 1434 &level_current,
1435 false);
c8890f90
ZR		 1436 if (result)
1437 goto out;
1438
1da177e4 1439 level_next = acpi_video_get_next_level(device, level_current, event);
c8890f90 1440
24450c7a 1441 result = acpi_video_device_lcd_set_level(device, level_next);
c8890f90 1442
36342742
MG		 1443 if (!result)
1444 backlight_force_update(device->backlight,
1445 BACKLIGHT_UPDATE_HOTKEY);
1446
c8890f90
ZR		 1447out:
1448 if (result)
1449 printk(KERN_ERR PREFIX "Failed to switch the brightness\n");
1da177e4
LT		 1450}
1451
e92a7162
MG		 1452int acpi_video_get_edid(struct acpi_device *device, int type, int device_id,
1453 void **edid)
1454{
1455 struct acpi_video_bus *video;
1456 struct acpi_video_device *video_device;
1457 union acpi_object *buffer = NULL;
1458 acpi_status status;
1459 int i, length;
1460
1461 if (!device || !acpi_driver_data(device))
1462 return -EINVAL;
1463
1464 video = acpi_driver_data(device);
1465
1466 for (i = 0; i < video->attached_count; i++) {
1467 video_device = video->attached_array[i].bind_info;
1468 length = 256;
1469
1470 if (!video_device)
1471 continue;
1472
82069552
ZR		 1473 if (!video_device->cap._DDC)
1474 continue;
1475
e92a7162
MG		 1476 if (type) {
1477 switch (type) {
1478 case ACPI_VIDEO_DISPLAY_CRT:
1479 if (!video_device->flags.crt)
1480 continue;
1481 break;
1482 case ACPI_VIDEO_DISPLAY_TV:
1483 if (!video_device->flags.tvout)
1484 continue;
1485 break;
1486 case ACPI_VIDEO_DISPLAY_DVI:
1487 if (!video_device->flags.dvi)
1488 continue;
1489 break;
1490 case ACPI_VIDEO_DISPLAY_LCD:
1491 if (!video_device->flags.lcd)
1492 continue;
1493 break;
1494 }
1495 } else if (video_device->device_id != device_id) {
1496 continue;
1497 }
1498
1499 status = acpi_video_device_EDID(video_device, &buffer, length);
1500
1501 if (ACPI_FAILURE(status) || !buffer ||
1502 buffer->type != ACPI_TYPE_BUFFER) {
1503 length = 128;
1504 status = acpi_video_device_EDID(video_device, &buffer,
1505 length);
1506 if (ACPI_FAILURE(status) || !buffer ||
1507 buffer->type != ACPI_TYPE_BUFFER) {
1508 continue;
1509 }
1510 }
1511
1512 *edid = buffer->buffer.pointer;
1513 return length;
1514 }
1515
1516 return -ENODEV;
1517}
1518EXPORT_SYMBOL(acpi_video_get_edid);
1519
1da177e4 1520static int
4be44fcd
LB		 1521acpi_video_bus_get_devices(struct acpi_video_bus *video,
1522 struct acpi_device *device)
1da177e4 1523{
fba4e087 1524 int status = 0;
ff102ea9 1525 struct acpi_device *dev;
1da177e4 1526
fba4e087
IM		 1527 /*
1528 * There are systems where video module known to work fine regardless
1529 * of broken _DOD and ignoring returned value here doesn't cause
1530 * any issues later.
1531 */
1532 acpi_video_device_enumerate(video);
1da177e4 1533
ff102ea9 1534 list_for_each_entry(dev, &device->children, node) {
1da177e4
LT		 1535
1536 status = acpi_video_bus_get_one_device(dev, video);
ea9f8856 1537 if (status) {
91e13aa3
AL		 1538 dev_err(&dev->dev, "Can't attach device\n");
1539 break;
1da177e4 1540 }
1da177e4 1541 }
d550d98d 1542 return status;
1da177e4
LT		 1543}
1544
1da177e4
LT		 1545/* acpi_video interface */
1546
efaa14c7
AL		 1547/*
1548 * Win8 requires setting bit2 of _DOS to let firmware know it shouldn't
1549 * preform any automatic brightness change on receiving a notification.
1550 */
4be44fcd 1551static int acpi_video_bus_start_devices(struct acpi_video_bus *video)
1da177e4 1552{
efaa14c7 1553 return acpi_video_bus_DOS(video, 0,
fbc9fe1b 1554 acpi_osi_is_win8() ? 1 : 0);
1da177e4
LT		 1555}
1556
4be44fcd 1557static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
1da177e4 1558{
efaa14c7 1559 return acpi_video_bus_DOS(video, 0,
fbc9fe1b 1560 acpi_osi_is_win8() ? 0 : 1);
1da177e4
LT		 1561}
1562
7015558f 1563static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
1da177e4 1564{
7015558f 1565 struct acpi_video_bus *video = acpi_driver_data(device);
e9dab196 1566 struct input_dev *input;
17c452f9 1567 int keycode = 0;
e9dab196 1568
67b662e1 1569 if (!video || !video->input)
d550d98d 1570 return;
1da177e4 1571
e9dab196 1572 input = video->input;
1da177e4
LT		 1573
1574 switch (event) {
98fb8fe1 1575 case ACPI_VIDEO_NOTIFY_SWITCH: /* User requested a switch,
1da177e4 1576 * most likely via hotkey. */
8a37c65d 1577 keycode = KEY_SWITCHVIDEOMODE;
1da177e4
LT		 1578 break;
1579
98fb8fe1 1580 case ACPI_VIDEO_NOTIFY_PROBE: /* User plugged in or removed a video
1da177e4
LT		 1581 * connector. */
1582 acpi_video_device_enumerate(video);
1583 acpi_video_device_rebind(video);
e9dab196 1584 keycode = KEY_SWITCHVIDEOMODE;
1da177e4
LT		 1585 break;
1586
4be44fcd 1587 case ACPI_VIDEO_NOTIFY_CYCLE: /* Cycle Display output hotkey pressed. */
e9dab196
LY		 1588 keycode = KEY_SWITCHVIDEOMODE;
1589 break;
4be44fcd 1590 case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT: /* Next Display output hotkey pressed. */
e9dab196
LY		 1591 keycode = KEY_VIDEO_NEXT;
1592 break;
4be44fcd 1593 case ACPI_VIDEO_NOTIFY_PREV_OUTPUT: /* previous Display output hotkey pressed. */
e9dab196 1594 keycode = KEY_VIDEO_PREV;
1da177e4
LT		 1595 break;
1596
1597 default:
1598 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
4be44fcd 1599 "Unsupported event [0x%x]\n", event));
1da177e4
LT		 1600 break;
1601 }
1602
8a37c65d
LT		 1603 if (acpi_notifier_call_chain(device, event, 0))
1604 /* Something vetoed the keypress. */
1605 keycode = 0;
17c452f9
MG		 1606
1607 if (keycode) {
1608 input_report_key(input, keycode, 1);
1609 input_sync(input);
1610 input_report_key(input, keycode, 0);
1611 input_sync(input);
1612 }
e9dab196 1613
d550d98d 1614 return;
1da177e4
LT		 1615}
1616
8ab58e8e
LT		 1617static void brightness_switch_event(struct acpi_video_device *video_device,
1618 u32 event)
1619{
1620 if (!brightness_switch_enabled)
1621 return;
1622
1623 video_device->switch_brightness_event = event;
1624 schedule_delayed_work(&video_device->switch_brightness_work, HZ / 10);
1625}
1626
4be44fcd 1627static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
1da177e4 1628{
50dd0969 1629 struct acpi_video_device *video_device = data;
4be44fcd 1630 struct acpi_device *device = NULL;
e9dab196
LY		 1631 struct acpi_video_bus *bus;
1632 struct input_dev *input;
17c452f9 1633 int keycode = 0;
1da177e4 1634
1da177e4 1635 if (!video_device)
d550d98d 1636 return;
1da177e4 1637
e6afa0de 1638 device = video_device->dev;
e9dab196
LY		 1639 bus = video_device->video;
1640 input = bus->input;
1da177e4
LT		 1641
1642 switch (event) {
4be44fcd 1643 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: /* Cycle brightness */
8ab58e8e 1644 brightness_switch_event(video_device, event);
e9dab196
LY		 1645 keycode = KEY_BRIGHTNESS_CYCLE;
1646 break;
4be44fcd 1647 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: /* Increase brightness */
8ab58e8e 1648 brightness_switch_event(video_device, event);
e9dab196
LY		 1649 keycode = KEY_BRIGHTNESSUP;
1650 break;
4be44fcd 1651 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: /* Decrease brightness */
8ab58e8e 1652 brightness_switch_event(video_device, event);
e9dab196
LY		 1653 keycode = KEY_BRIGHTNESSDOWN;
1654 break;
70f23fd6 1655 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightness */
8ab58e8e 1656 brightness_switch_event(video_device, event);
e9dab196
LY		 1657 keycode = KEY_BRIGHTNESS_ZERO;
1658 break;
4be44fcd 1659 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: /* display device off */
8ab58e8e 1660 brightness_switch_event(video_device, event);
e9dab196 1661 keycode = KEY_DISPLAY_OFF;
1da177e4
LT		 1662 break;
1663 default:
1664 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
4be44fcd 1665 "Unsupported event [0x%x]\n", event));
1da177e4
LT		 1666 break;
1667 }
e9dab196 1668
7761f638 1669 acpi_notifier_call_chain(device, event, 0);
17c452f9
MG		 1670
1671 if (keycode) {
1672 input_report_key(input, keycode, 1);
1673 input_sync(input);
1674 input_report_key(input, keycode, 0);
1675 input_sync(input);
1676 }
e9dab196 1677
d550d98d 1678 return;
1da177e4
LT		 1679}
1680
ac7729da
RW		 1681static int acpi_video_resume(struct notifier_block *nb,
1682 unsigned long val, void *ign)
863c1490
MG		 1683{
1684 struct acpi_video_bus *video;
1685 struct acpi_video_device *video_device;
1686 int i;
1687
ac7729da
RW		 1688 switch (val) {
1689 case PM_HIBERNATION_PREPARE:
1690 case PM_SUSPEND_PREPARE:
1691 case PM_RESTORE_PREPARE:
1692 return NOTIFY_DONE;
1693 }
863c1490 1694
ac7729da
RW		 1695 video = container_of(nb, struct acpi_video_bus, pm_nb);
1696
1697 dev_info(&video->device->dev, "Restoring backlight state\n");
863c1490
MG		 1698
1699 for (i = 0; i < video->attached_count; i++) {
1700 video_device = video->attached_array[i].bind_info;
1701 if (video_device && video_device->backlight)
1702 acpi_video_set_brightness(video_device->backlight);
1703 }
ac7729da
RW		 1704
1705 return NOTIFY_OK;
863c1490
MG		 1706}
1707
c504f8cb
ZR		 1708static acpi_status
1709acpi_video_bus_match(acpi_handle handle, u32 level, void *context,
1710 void **return_value)
1711{
1712 struct acpi_device *device = context;
1713 struct acpi_device *sibling;
1714 int result;
1715
1716 if (handle == device->handle)
1717 return AE_CTRL_TERMINATE;
1718
1719 result = acpi_bus_get_device(handle, &sibling);
1720 if (result)
1721 return AE_OK;
1722
1723 if (!strcmp(acpi_device_name(sibling), ACPI_VIDEO_BUS_NAME))
1724 return AE_ALREADY_EXISTS;
1725
1726 return AE_OK;
1727}
1728
67b662e1
AL		 1729static void acpi_video_dev_register_backlight(struct acpi_video_device *device)
1730{
99678ed7
HG		 1731 struct backlight_properties props;
1732 struct pci_dev *pdev;
1733 acpi_handle acpi_parent;
1734 struct device *parent = NULL;
1735 int result;
1736 static int count;
1737 char *name;
67b662e1 1738
99678ed7
HG		 1739 result = acpi_video_init_brightness(device);
1740 if (result)
1741 return;
1742 name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
1743 if (!name)
1744 return;
1745 count++;
67b662e1 1746
99678ed7 1747 acpi_get_parent(device->dev->handle, &acpi_parent);
67b662e1 1748
99678ed7
HG		 1749 pdev = acpi_get_pci_dev(acpi_parent);
1750 if (pdev) {
1751 parent = &pdev->dev;
1752 pci_dev_put(pdev);
1753 }
67b662e1 1754
99678ed7
HG		 1755 memset(&props, 0, sizeof(struct backlight_properties));
1756 props.type = BACKLIGHT_FIRMWARE;
1757 props.max_brightness = device->brightness->count - 3;
1758 device->backlight = backlight_device_register(name,
1759 parent,
1760 device,
1761 &acpi_backlight_ops,
1762 &props);
1763 kfree(name);
1764 if (IS_ERR(device->backlight))
1765 return;
67b662e1 1766
99678ed7
HG		 1767 /*
1768 * Save current brightness level in case we have to restore it
1769 * before acpi_video_device_lcd_set_level() is called next time.
1770 */
1771 device->backlight->props.brightness =
1772 acpi_video_get_brightness(device->backlight);
67b662e1 1773
99678ed7
HG		 1774 device->cooling_dev = thermal_cooling_device_register("LCD",
1775 device->dev, &video_cooling_ops);
1776 if (IS_ERR(device->cooling_dev)) {
1777 /*
1778 * Set cooling_dev to NULL so we don't crash trying to free it.
1779 * Also, why the hell we are returning early and not attempt to
1780 * register video output if cooling device registration failed?
1781 * -- dtor
1782 */
1783 device->cooling_dev = NULL;
1784 return;
67b662e1 1785 }
99678ed7
HG		 1786
1787 dev_info(&device->dev->dev, "registered as cooling_device%d\n",
1788 device->cooling_dev->id);
1789 result = sysfs_create_link(&device->dev->dev.kobj,
1790 &device->cooling_dev->device.kobj,
1791 "thermal_cooling");
1792 if (result)
1793 printk(KERN_ERR PREFIX "Create sysfs link\n");
1794 result = sysfs_create_link(&device->cooling_dev->device.kobj,
1795 &device->dev->dev.kobj, "device");
1796 if (result)
1797 printk(KERN_ERR PREFIX "Create sysfs link\n");
67b662e1
AL		 1798}
1799
1800static int acpi_video_bus_register_backlight(struct acpi_video_bus *video)
1801{
1802 struct acpi_video_device *dev;
1803
53a92ba7
HG		 1804 if (video->backlight_registered)
1805 return 0;
1806
99678ed7
HG		 1807 if (!acpi_video_verify_backlight_support())
1808 return 0;
1809
67b662e1
AL		 1810 mutex_lock(&video->device_list_lock);
1811 list_for_each_entry(dev, &video->video_device_list, entry)
1812 acpi_video_dev_register_backlight(dev);
1813 mutex_unlock(&video->device_list_lock);
1814
99678ed7
HG		 1815 video->backlight_registered = true;
1816
67b662e1
AL		 1817 video->pm_nb.notifier_call = acpi_video_resume;
1818 video->pm_nb.priority = 0;
1819 return register_pm_notifier(&video->pm_nb);
1820}
1821
1822static void acpi_video_dev_unregister_backlight(struct acpi_video_device *device)
1823{
1824 if (device->backlight) {
1825 backlight_device_unregister(device->backlight);
1826 device->backlight = NULL;
1827 }
1828 if (device->brightness) {
1829 kfree(device->brightness->levels);
1830 kfree(device->brightness);
1831 device->brightness = NULL;
1832 }
1833 if (device->cooling_dev) {
1834 sysfs_remove_link(&device->dev->dev.kobj, "thermal_cooling");
1835 sysfs_remove_link(&device->cooling_dev->device.kobj, "device");
1836 thermal_cooling_device_unregister(device->cooling_dev);
1837 device->cooling_dev = NULL;
1838 }
1839}
1840
1841static int acpi_video_bus_unregister_backlight(struct acpi_video_bus *video)
1842{
1843 struct acpi_video_device *dev;
99678ed7
HG		 1844 int error;
1845
1846 if (!video->backlight_registered)
1847 return 0;
1848
1849 error = unregister_pm_notifier(&video->pm_nb);
67b662e1
AL		 1850
1851 mutex_lock(&video->device_list_lock);
1852 list_for_each_entry(dev, &video->video_device_list, entry)
1853 acpi_video_dev_unregister_backlight(dev);
1854 mutex_unlock(&video->device_list_lock);
1855
99678ed7
HG		 1856 video->backlight_registered = false;
1857
67b662e1
AL		 1858 return error;
1859}
1860
1861static void acpi_video_dev_add_notify_handler(struct acpi_video_device *device)
1862{
1863 acpi_status status;
1864 struct acpi_device *adev = device->dev;
1865
1866 status = acpi_install_notify_handler(adev->handle, ACPI_DEVICE_NOTIFY,
1867 acpi_video_device_notify, device);
1868 if (ACPI_FAILURE(status))
1869 dev_err(&adev->dev, "Error installing notify handler\n");
1870 else
1871 device->flags.notify = 1;
1872}
1873
1874static int acpi_video_bus_add_notify_handler(struct acpi_video_bus *video)
1875{
1876 struct input_dev *input;
1877 struct acpi_video_device *dev;
1878 int error;
1879
1880 video->input = input = input_allocate_device();
1881 if (!input) {
1882 error = -ENOMEM;
1883 goto out;
1884 }
1885
1886 error = acpi_video_bus_start_devices(video);
1887 if (error)
1888 goto err_free_input;
1889
1890 snprintf(video->phys, sizeof(video->phys),
1891 "%s/video/input0", acpi_device_hid(video->device));
1892
1893 input->name = acpi_device_name(video->device);
1894 input->phys = video->phys;
1895 input->id.bustype = BUS_HOST;
1896 input->id.product = 0x06;
1897 input->dev.parent = &video->device->dev;
1898 input->evbit[0] = BIT(EV_KEY);
1899 set_bit(KEY_SWITCHVIDEOMODE, input->keybit);
1900 set_bit(KEY_VIDEO_NEXT, input->keybit);
1901 set_bit(KEY_VIDEO_PREV, input->keybit);
1902 set_bit(KEY_BRIGHTNESS_CYCLE, input->keybit);
1903 set_bit(KEY_BRIGHTNESSUP, input->keybit);
1904 set_bit(KEY_BRIGHTNESSDOWN, input->keybit);
1905 set_bit(KEY_BRIGHTNESS_ZERO, input->keybit);
1906 set_bit(KEY_DISPLAY_OFF, input->keybit);
1907
1908 error = input_register_device(input);
1909 if (error)
1910 goto err_stop_dev;
1911
1912 mutex_lock(&video->device_list_lock);
1913 list_for_each_entry(dev, &video->video_device_list, entry)
1914 acpi_video_dev_add_notify_handler(dev);
1915 mutex_unlock(&video->device_list_lock);
1916
1917 return 0;
1918
1919err_stop_dev:
1920 acpi_video_bus_stop_devices(video);
1921err_free_input:
1922 input_free_device(input);
1923 video->input = NULL;
1924out:
1925 return error;
1926}
1927
1928static void acpi_video_dev_remove_notify_handler(struct acpi_video_device *dev)
1929{
1930 if (dev->flags.notify) {
1931 acpi_remove_notify_handler(dev->dev->handle, ACPI_DEVICE_NOTIFY,
1932 acpi_video_device_notify);
1933 dev->flags.notify = 0;
1934 }
1935}
1936
1937static void acpi_video_bus_remove_notify_handler(struct acpi_video_bus *video)
1938{
1939 struct acpi_video_device *dev;
1940
1941 mutex_lock(&video->device_list_lock);
1942 list_for_each_entry(dev, &video->video_device_list, entry)
1943 acpi_video_dev_remove_notify_handler(dev);
1944 mutex_unlock(&video->device_list_lock);
1945
1946 acpi_video_bus_stop_devices(video);
1947 input_unregister_device(video->input);
1948 video->input = NULL;
1949}
1950
53a92ba7
HG		 1951static int acpi_video_backlight_notify(struct notifier_block *nb,
1952 unsigned long val, void *bd)
1953{
1954 struct backlight_device *backlight = bd;
1955 struct acpi_video_bus *video;
1956
1957 /* acpi_video_verify_backlight_support only cares about raw devices */
1958 if (backlight->props.type != BACKLIGHT_RAW)
1959 return NOTIFY_DONE;
1960
1961 video = container_of(nb, struct acpi_video_bus, backlight_nb);
1962
1963 switch (val) {
1964 case BACKLIGHT_REGISTERED:
1965 if (!acpi_video_verify_backlight_support())
1966 acpi_video_bus_unregister_backlight(video);
1967 break;
1968 case BACKLIGHT_UNREGISTERED:
1969 acpi_video_bus_register_backlight(video);
1970 break;
1971 }
1972
1973 return NOTIFY_OK;
1974}
1975
1976static int acpi_video_bus_add_backlight_notify_handler(
1977 struct acpi_video_bus *video)
1978{
1979 int error;
1980
1981 video->backlight_nb.notifier_call = acpi_video_backlight_notify;
1982 video->backlight_nb.priority = 0;
1983 error = backlight_register_notifier(&video->backlight_nb);
1984 if (error == 0)
1985 video->backlight_notifier_registered = true;
1986
1987 return error;
1988}
1989
1990static int acpi_video_bus_remove_backlight_notify_handler(
1991 struct acpi_video_bus *video)
1992{
1993 if (!video->backlight_notifier_registered)
1994 return 0;
1995
1996 video->backlight_notifier_registered = false;
1997
1998 return backlight_unregister_notifier(&video->backlight_nb);
1999}
2000
67b662e1
AL		 2001static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
2002{
2003 struct acpi_video_device *dev, *next;
2004
2005 mutex_lock(&video->device_list_lock);
2006 list_for_each_entry_safe(dev, next, &video->video_device_list, entry) {
2007 list_del(&dev->entry);
2008 kfree(dev);
2009 }
2010 mutex_unlock(&video->device_list_lock);
2011
2012 return 0;
2013}
2014
ac7729da
RW		 2015static int instance;
2016
4be44fcd 2017static int acpi_video_bus_add(struct acpi_device *device)
1da177e4 2018{
f51e8391 2019 struct acpi_video_bus *video;
f51e8391 2020 int error;
c504f8cb
ZR		 2021 acpi_status status;
2022
2023 status = acpi_walk_namespace(ACPI_TYPE_DEVICE,
2024 device->parent->handle, 1,
2025 acpi_video_bus_match, NULL,
2026 device, NULL);
2027 if (status == AE_ALREADY_EXISTS) {
2028 printk(KERN_WARNING FW_BUG
2029 "Duplicate ACPI video bus devices for the"
2030 " same VGA controller, please try module "
2031 "parameter \"video.allow_duplicates=1\""
2032 "if the current driver doesn't work.\n");
2033 if (!allow_duplicates)
2034 return -ENODEV;
2035 }
1da177e4 2036
36bcbec7 2037 video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
1da177e4 2038 if (!video)
d550d98d 2039 return -ENOMEM;
1da177e4 2040
e6d9da1d
ZR		 2041 /* a hack to fix the duplicate name "VID" problem on T61 */
2042 if (!strcmp(device->pnp.bus_id, "VID")) {
2043 if (instance)
2044 device->pnp.bus_id[3] = '0' + instance;
915ea7e4 2045 instance++;
e6d9da1d 2046 }
f3b39f13
ZY		 2047 /* a hack to fix the duplicate name "VGA" problem on Pa 3553 */
2048 if (!strcmp(device->pnp.bus_id, "VGA")) {
2049 if (instance)
2050 device->pnp.bus_id[3] = '0' + instance;
2051 instance++;
2052 }
e6d9da1d 2053
e6afa0de 2054 video->device = device;
1da177e4
LT		 2055 strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
2056 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
db89b4f0 2057 device->driver_data = video;
1da177e4
LT		 2058
2059 acpi_video_bus_find_cap(video);
f51e8391
DT		 2060 error = acpi_video_bus_check(video);
2061 if (error)
2062 goto err_free_video;
1da177e4 2063
bbac81f5 2064 mutex_init(&video->device_list_lock);
1da177e4
LT		 2065 INIT_LIST_HEAD(&video->video_device_list);
2066
ea9f8856
IM		 2067 error = acpi_video_bus_get_devices(video, device);
2068 if (error)
91e13aa3 2069 goto err_put_video;
1da177e4 2070
1da177e4 2071 printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s rom: %s post: %s)\n",
4be44fcd
LB		 2072 ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
2073 video->flags.multihead ? "yes" : "no",
2074 video->flags.rom ? "yes" : "no",
2075 video->flags.post ? "yes" : "no");
67b662e1
AL		 2076 mutex_lock(&video_list_lock);
2077 list_add_tail(&video->entry, &video_bus_head);
2078 mutex_unlock(&video_list_lock);
1da177e4 2079
67b662e1
AL		 2080 acpi_video_bus_register_backlight(video);
2081 acpi_video_bus_add_notify_handler(video);
53a92ba7 2082 acpi_video_bus_add_backlight_notify_handler(video);
ac7729da 2083
f51e8391
DT		 2084 return 0;
2085
67b662e1 2086err_put_video:
f51e8391
DT		 2087 acpi_video_bus_put_devices(video);
2088 kfree(video->attached_array);
67b662e1 2089err_free_video:
f51e8391 2090 kfree(video);
db89b4f0 2091 device->driver_data = NULL;
1da177e4 2092
f51e8391 2093 return error;
1da177e4
LT		 2094}
2095
51fac838 2096static int acpi_video_bus_remove(struct acpi_device *device)
1da177e4 2097{
4be44fcd 2098 struct acpi_video_bus *video = NULL;
1da177e4 2099
1da177e4
LT		 2100
2101 if (!device || !acpi_driver_data(device))
d550d98d 2102 return -EINVAL;
1da177e4 2103
50dd0969 2104 video = acpi_driver_data(device);
1da177e4 2105
53a92ba7 2106 acpi_video_bus_remove_backlight_notify_handler(video);
67b662e1
AL		 2107 acpi_video_bus_remove_notify_handler(video);
2108 acpi_video_bus_unregister_backlight(video);
1da177e4 2109 acpi_video_bus_put_devices(video);
1da177e4 2110
67b662e1
AL		 2111 mutex_lock(&video_list_lock);
2112 list_del(&video->entry);
2113 mutex_unlock(&video_list_lock);
2114
6044ec88 2115 kfree(video->attached_array);
1da177e4
LT		 2116 kfree(video);
2117
d550d98d 2118 return 0;
1da177e4
LT		 2119}
2120
c6996bdd
AC		 2121static int __init is_i740(struct pci_dev *dev)
2122{
2123 if (dev->device == 0x00D1)
2124 return 1;
2125 if (dev->device == 0x7000)
2126 return 1;
2127 return 0;
2128}
2129
74a365b3
MG		 2130static int __init intel_opregion_present(void)
2131{
c6996bdd 2132 int opregion = 0;
74a365b3
MG		 2133 struct pci_dev *dev = NULL;
2134 u32 address;
2135
2136 for_each_pci_dev(dev) {
2137 if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
2138 continue;
2139 if (dev->vendor != PCI_VENDOR_ID_INTEL)
2140 continue;
c6996bdd
AC		 2141 /* We don't want to poke around undefined i740 registers */
2142 if (is_i740(dev))
2143 continue;
74a365b3
MG		 2144 pci_read_config_dword(dev, 0xfc, &address);
2145 if (!address)
2146 continue;
c6996bdd 2147 opregion = 1;
74a365b3 2148 }
c6996bdd 2149 return opregion;
74a365b3
MG		 2150}
2151
8e5c2b77 2152int acpi_video_register(void)
1da177e4 2153{
8e5c2b77 2154 int result = 0;
86e437f0
ZY		 2155 if (register_count) {
2156 /*
8e5c2b77
RW		 2157 * if the function of acpi_video_register is already called,
2158 * don't register the acpi_vide_bus again and return no error.
86e437f0
ZY		 2159 */
2160 return 0;
2161 }
1da177e4 2162
67b662e1
AL		 2163 mutex_init(&video_list_lock);
2164 INIT_LIST_HEAD(&video_bus_head);
2165
1da177e4 2166 result = acpi_bus_register_driver(&acpi_video_bus);
39fe394d 2167 if (result < 0)
d550d98d 2168 return -ENODEV;
1da177e4 2169
86e437f0
ZY		 2170 /*
2171 * When the acpi_video_bus is loaded successfully, increase
2172 * the counter reference.
2173 */
2174 register_count = 1;
2175
d550d98d 2176 return 0;
1da177e4 2177}
8e5c2b77 2178EXPORT_SYMBOL(acpi_video_register);
74a365b3 2179
86e437f0
ZY		 2180void acpi_video_unregister(void)
2181{
2182 if (!register_count) {
2183 /*
2184 * If the acpi video bus is already unloaded, don't
2185 * unload it again and return directly.
2186 */
2187 return;
2188 }
2189 acpi_bus_unregister_driver(&acpi_video_bus);
2190
86e437f0
ZY		 2191 register_count = 0;
2192
2193 return;
2194}
2195EXPORT_SYMBOL(acpi_video_unregister);
2196
1b7f37e1
HG		 2197void acpi_video_unregister_backlight(void)
2198{
2199 struct acpi_video_bus *video;
2200
2201 if (!register_count)
2202 return;
2203
2204 mutex_lock(&video_list_lock);
2205 list_for_each_entry(video, &video_bus_head, entry)
2206 acpi_video_bus_unregister_backlight(video);
2207 mutex_unlock(&video_list_lock);
2208}
2209EXPORT_SYMBOL(acpi_video_unregister_backlight);
2210
74a365b3
MG		 2211/*
2212 * This is kind of nasty. Hardware using Intel chipsets may require
2213 * the video opregion code to be run first in order to initialise
2214 * state before any ACPI video calls are made. To handle this we defer
2215 * registration of the video class until the opregion code has run.
2216 */
2217
2218static int __init acpi_video_init(void)
2219{
45cb50e6
ZR		 2220 dmi_check_system(video_dmi_table);
2221
74a365b3
MG		 2222 if (intel_opregion_present())
2223 return 0;
2224
2225 return acpi_video_register();
2226}
1da177e4 2227
86e437f0 2228static void __exit acpi_video_exit(void)
1da177e4 2229{
86e437f0 2230 acpi_video_unregister();
1da177e4 2231
d550d98d 2232 return;
1da177e4
LT		 2233}
2234
2235module_init(acpi_video_init);
2236module_exit(acpi_video_exit);
Linux kernel - Deliverables
This page took 1.10447 seconds and 5 git commands to generate.