projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / acpi / video.c
CommitLineData
1da177e4
LT		 1/*
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>
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>
1da177e4
LT		 33#include <linux/proc_fs.h>
34#include <linux/seq_file.h>
e9dab196 35#include <linux/input.h>
2f3d000a 36#include <linux/backlight.h>
702ed512 37#include <linux/thermal.h>
23b0f015 38#include <linux/video_output.h>
935e5f29 39#include <linux/sort.h>
74a365b3
MG		 40#include <linux/pci.h>
41#include <linux/pci_ids.h>
5a0e3ad6 42#include <linux/slab.h>
1da177e4 43#include <asm/uaccess.h>
eb27cae8 44#include <linux/dmi.h>
1da177e4
LT		 45#include <acpi/acpi_bus.h>
46#include <acpi/acpi_drivers.h>
ac7729da 47#include <linux/suspend.h>
e92a7162 48#include <acpi/video.h>
1da177e4 49
a192a958
LB		 50#define PREFIX "ACPI: "
51
1da177e4 52#define ACPI_VIDEO_CLASS "video"
1da177e4
LT		 53#define ACPI_VIDEO_BUS_NAME "Video Bus"
54#define ACPI_VIDEO_DEVICE_NAME "Video Device"
55#define ACPI_VIDEO_NOTIFY_SWITCH 0x80
56#define ACPI_VIDEO_NOTIFY_PROBE 0x81
57#define ACPI_VIDEO_NOTIFY_CYCLE 0x82
58#define ACPI_VIDEO_NOTIFY_NEXT_OUTPUT 0x83
59#define ACPI_VIDEO_NOTIFY_PREV_OUTPUT 0x84
60
f4715189
TT		 61#define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS 0x85
62#define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS 0x86
63#define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS 0x87
64#define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS 0x88
65#define ACPI_VIDEO_NOTIFY_DISPLAY_OFF 0x89
1da177e4 66
2f3d000a 67#define MAX_NAME_LEN 20
1da177e4 68
1da177e4 69#define _COMPONENT ACPI_VIDEO_COMPONENT
f52fd66d 70ACPI_MODULE_NAME("video");
1da177e4 71
f52fd66d 72MODULE_AUTHOR("Bruno Ducrot");
7cda93e0 73MODULE_DESCRIPTION("ACPI Video Driver");
1da177e4
LT		 74MODULE_LICENSE("GPL");
75
8a681a4d
ZR		 76static int brightness_switch_enabled = 1;
77module_param(brightness_switch_enabled, bool, 0644);
78
c504f8cb
ZR		 79/*
80 * By default, we don't allow duplicate ACPI video bus devices
81 * under the same VGA controller
82 */
83static int allow_duplicates;
84module_param(allow_duplicates, bool, 0644);
85
86e437f0 86static int register_count = 0;
4be44fcd
LB		 87static int acpi_video_bus_add(struct acpi_device *device);
88static int acpi_video_bus_remove(struct acpi_device *device, int type);
7015558f 89static void acpi_video_bus_notify(struct acpi_device *device, u32 event);
1da177e4 90
1ba90e3a
TR		 91static const struct acpi_device_id video_device_ids[] = {
92 {ACPI_VIDEO_HID, 0},
93 {"", 0},
94};
95MODULE_DEVICE_TABLE(acpi, video_device_ids);
96
1da177e4 97static struct acpi_driver acpi_video_bus = {
c2b6705b 98 .name = "video",
1da177e4 99 .class = ACPI_VIDEO_CLASS,
1ba90e3a 100 .ids = video_device_ids,
1da177e4
LT		 101 .ops = {
102 .add = acpi_video_bus_add,
103 .remove = acpi_video_bus_remove,
7015558f 104 .notify = acpi_video_bus_notify,
4be44fcd 105 },
1da177e4
LT		 106};
107
108struct acpi_video_bus_flags {
4be44fcd
LB		 109 u8 multihead:1; /* can switch video heads */
110 u8 rom:1; /* can retrieve a video rom */
111 u8 post:1; /* can configure the head to */
112 u8 reserved:5;
1da177e4
LT		 113};
114
115struct acpi_video_bus_cap {
4be44fcd
LB		 116 u8 _DOS:1; /*Enable/Disable output switching */
117 u8 _DOD:1; /*Enumerate all devices attached to display adapter */
118 u8 _ROM:1; /*Get ROM Data */
119 u8 _GPD:1; /*Get POST Device */
120 u8 _SPD:1; /*Set POST Device */
121 u8 _VPO:1; /*Video POST Options */
122 u8 reserved:2;
1da177e4
LT		 123};
124
4be44fcd
LB		 125struct acpi_video_device_attrib {
126 u32 display_index:4; /* A zero-based instance of the Display */
98fb8fe1 127 u32 display_port_attachment:4; /*This field differentiates the display type */
4be44fcd 128 u32 display_type:4; /*Describe the specific type in use */
98fb8fe1 129 u32 vendor_specific:4; /*Chipset Vendor Specific */
4be44fcd
LB		 130 u32 bios_can_detect:1; /*BIOS can detect the device */
131 u32 depend_on_vga:1; /*Non-VGA output device whose power is related to
132 the VGA device. */
133 u32 pipe_id:3; /*For VGA multiple-head devices. */
134 u32 reserved:10; /*Must be 0 */
135 u32 device_id_scheme:1; /*Device ID Scheme */
1da177e4
LT		 136};
137
138struct acpi_video_enumerated_device {
139 union {
140 u32 int_val;
4be44fcd 141 struct acpi_video_device_attrib attrib;
1da177e4
LT		 142 } value;
143 struct acpi_video_device *bind_info;
144};
145
146struct acpi_video_bus {
e6afa0de 147 struct acpi_device *device;
4be44fcd 148 u8 dos_setting;
1da177e4 149 struct acpi_video_enumerated_device *attached_array;
4be44fcd
LB		 150 u8 attached_count;
151 struct acpi_video_bus_cap cap;
1da177e4 152 struct acpi_video_bus_flags flags;
4be44fcd 153 struct list_head video_device_list;
bbac81f5 154 struct mutex device_list_lock; /* protects video_device_list */
6e37c658 155#ifdef CONFIG_ACPI_PROCFS
4be44fcd 156 struct proc_dir_entry *dir;
6e37c658 157#endif
e9dab196
LY		 158 struct input_dev *input;
159 char phys[32]; /* for input device */
ac7729da 160 struct notifier_block pm_nb;
1da177e4
LT		 161};
162
163struct acpi_video_device_flags {
4be44fcd
LB		 164 u8 crt:1;
165 u8 lcd:1;
166 u8 tvout:1;
82cae999 167 u8 dvi:1;
4be44fcd
LB		 168 u8 bios:1;
169 u8 unknown:1;
82cae999 170 u8 reserved:2;
1da177e4
LT		 171};
172
173struct acpi_video_device_cap {
4be44fcd
LB		 174 u8 _ADR:1; /*Return the unique ID */
175 u8 _BCL:1; /*Query list of brightness control levels supported */
176 u8 _BCM:1; /*Set the brightness level */
2f3d000a 177 u8 _BQC:1; /* Get current brightness level */
c60d638e 178 u8 _BCQ:1; /* Some buggy BIOS uses _BCQ instead of _BQC */
4be44fcd
LB		 179 u8 _DDC:1; /*Return the EDID for this device */
180 u8 _DCS:1; /*Return status of output device */
181 u8 _DGS:1; /*Query graphics state */
182 u8 _DSS:1; /*Device state set */
1da177e4
LT		 183};
184
d32f6947
ZR		 185struct acpi_video_brightness_flags {
186 u8 _BCL_no_ac_battery_levels:1; /* no AC/Battery levels in _BCL */
d80fb99f 187 u8 _BCL_reversed:1; /* _BCL package is in a reversed order*/
1a7c618a
ZR		 188 u8 _BCL_use_index:1; /* levels in _BCL are index values */
189 u8 _BCM_use_index:1; /* input of _BCM is an index value */
190 u8 _BQC_use_index:1; /* _BQC returns an index value */
d32f6947
ZR		 191};
192
1da177e4 193struct acpi_video_device_brightness {
4be44fcd
LB		 194 int curr;
195 int count;
196 int *levels;
d32f6947 197 struct acpi_video_brightness_flags flags;
1da177e4
LT		 198};
199
200struct acpi_video_device {
4be44fcd
LB		 201 unsigned long device_id;
202 struct acpi_video_device_flags flags;
203 struct acpi_video_device_cap cap;
204 struct list_head entry;
205 struct acpi_video_bus *video;
206 struct acpi_device *dev;
1da177e4 207 struct acpi_video_device_brightness *brightness;
2f3d000a 208 struct backlight_device *backlight;
4a703a8f 209 struct thermal_cooling_device *cooling_dev;
23b0f015 210 struct output_device *output_dev;
1da177e4
LT		 211};
212
6e37c658 213#ifdef CONFIG_ACPI_PROCFS
1da177e4
LT		 214/* bus */
215static int acpi_video_bus_info_open_fs(struct inode *inode, struct file *file);
070d8eb1 216static const struct file_operations acpi_video_bus_info_fops = {
cf7acfab 217 .owner = THIS_MODULE,
4be44fcd
LB		 218 .open = acpi_video_bus_info_open_fs,
219 .read = seq_read,
220 .llseek = seq_lseek,
221 .release = single_release,
1da177e4
LT		 222};
223
224static int acpi_video_bus_ROM_open_fs(struct inode *inode, struct file *file);
070d8eb1 225static const struct file_operations acpi_video_bus_ROM_fops = {
cf7acfab 226 .owner = THIS_MODULE,
4be44fcd
LB		 227 .open = acpi_video_bus_ROM_open_fs,
228 .read = seq_read,
229 .llseek = seq_lseek,
230 .release = single_release,
1da177e4
LT		 231};
232
4be44fcd
LB		 233static int acpi_video_bus_POST_info_open_fs(struct inode *inode,
234 struct file *file);
070d8eb1 235static const struct file_operations acpi_video_bus_POST_info_fops = {
cf7acfab 236 .owner = THIS_MODULE,
4be44fcd
LB		 237 .open = acpi_video_bus_POST_info_open_fs,
238 .read = seq_read,
239 .llseek = seq_lseek,
240 .release = single_release,
1da177e4
LT		 241};
242
243static int acpi_video_bus_POST_open_fs(struct inode *inode, struct file *file);
c07c9a78 244static ssize_t acpi_video_bus_write_POST(struct file *file,
b7171ae7
JE		 245 const char __user *buffer, size_t count, loff_t *data);
246static const struct file_operations acpi_video_bus_POST_fops = {
cf7acfab 247 .owner = THIS_MODULE,
4be44fcd
LB		 248 .open = acpi_video_bus_POST_open_fs,
249 .read = seq_read,
b7171ae7 250 .write = acpi_video_bus_write_POST,
4be44fcd
LB		 251 .llseek = seq_lseek,
252 .release = single_release,
1da177e4
LT		 253};
254
1da177e4 255static int acpi_video_bus_DOS_open_fs(struct inode *inode, struct file *file);
c07c9a78 256static ssize_t acpi_video_bus_write_DOS(struct file *file,
b7171ae7
JE		 257 const char __user *buffer, size_t count, loff_t *data);
258static const struct file_operations acpi_video_bus_DOS_fops = {
cf7acfab 259 .owner = THIS_MODULE,
4be44fcd
LB		 260 .open = acpi_video_bus_DOS_open_fs,
261 .read = seq_read,
b7171ae7 262 .write = acpi_video_bus_write_DOS,
4be44fcd
LB		 263 .llseek = seq_lseek,
264 .release = single_release,
1da177e4
LT		 265};
266
267/* device */
4be44fcd
LB		 268static int acpi_video_device_info_open_fs(struct inode *inode,
269 struct file *file);
070d8eb1 270static const struct file_operations acpi_video_device_info_fops = {
cf7acfab 271 .owner = THIS_MODULE,
4be44fcd
LB		 272 .open = acpi_video_device_info_open_fs,
273 .read = seq_read,
274 .llseek = seq_lseek,
275 .release = single_release,
1da177e4
LT		 276};
277
4be44fcd
LB		 278static int acpi_video_device_state_open_fs(struct inode *inode,
279 struct file *file);
c07c9a78 280static ssize_t acpi_video_device_write_state(struct file *file,
b7171ae7
JE		 281 const char __user *buffer, size_t count, loff_t *data);
282static const struct file_operations acpi_video_device_state_fops = {
cf7acfab 283 .owner = THIS_MODULE,
4be44fcd
LB		 284 .open = acpi_video_device_state_open_fs,
285 .read = seq_read,
b7171ae7 286 .write = acpi_video_device_write_state,
4be44fcd
LB		 287 .llseek = seq_lseek,
288 .release = single_release,
1da177e4
LT		 289};
290
4be44fcd
LB		 291static int acpi_video_device_brightness_open_fs(struct inode *inode,
292 struct file *file);
c07c9a78 293static ssize_t acpi_video_device_write_brightness(struct file *file,
b7171ae7 294 const char __user *buffer, size_t count, loff_t *data);
828c0950 295static const struct file_operations acpi_video_device_brightness_fops = {
cf7acfab 296 .owner = THIS_MODULE,
4be44fcd
LB		 297 .open = acpi_video_device_brightness_open_fs,
298 .read = seq_read,
b7171ae7 299 .write = acpi_video_device_write_brightness,
4be44fcd
LB		 300 .llseek = seq_lseek,
301 .release = single_release,
1da177e4
LT		 302};
303
4be44fcd
LB		 304static int acpi_video_device_EDID_open_fs(struct inode *inode,
305 struct file *file);
070d8eb1 306static const struct file_operations acpi_video_device_EDID_fops = {
cf7acfab 307 .owner = THIS_MODULE,
4be44fcd
LB		 308 .open = acpi_video_device_EDID_open_fs,
309 .read = seq_read,
310 .llseek = seq_lseek,
311 .release = single_release,
1da177e4 312};
6e37c658 313#endif /* CONFIG_ACPI_PROCFS */
1da177e4 314
b7171ae7 315static const char device_decode[][30] = {
1da177e4
LT		 316 "motherboard VGA device",
317 "PCI VGA device",
318 "AGP VGA device",
319 "UNKNOWN",
320};
321
4be44fcd
LB		 322static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data);
323static void acpi_video_device_rebind(struct acpi_video_bus *video);
324static void acpi_video_device_bind(struct acpi_video_bus *video,
325 struct acpi_video_device *device);
1da177e4 326static int acpi_video_device_enumerate(struct acpi_video_bus *video);
2f3d000a
YL		 327static int acpi_video_device_lcd_set_level(struct acpi_video_device *device,
328 int level);
329static int acpi_video_device_lcd_get_level_current(
330 struct acpi_video_device *device,
70287db8 331 unsigned long long *level, int init);
4be44fcd
LB		 332static int acpi_video_get_next_level(struct acpi_video_device *device,
333 u32 level_current, u32 event);
c8890f90 334static int acpi_video_switch_brightness(struct acpi_video_device *device,
4be44fcd 335 int event);
23b0f015 336static int acpi_video_device_get_state(struct acpi_video_device *device,
27663c58 337 unsigned long long *state);
23b0f015
LY		 338static int acpi_video_output_get(struct output_device *od);
339static int acpi_video_device_set_state(struct acpi_video_device *device, int state);
1da177e4 340
2f3d000a
YL		 341/*backlight device sysfs support*/
342static int acpi_video_get_brightness(struct backlight_device *bd)
343{
27663c58 344 unsigned long long cur_level;
38531e6f 345 int i;
2f3d000a 346 struct acpi_video_device *vd =
655bfd7a 347 (struct acpi_video_device *)bl_get_data(bd);
c8890f90 348
70287db8 349 if (acpi_video_device_lcd_get_level_current(vd, &cur_level, 0))
c8890f90 350 return -EINVAL;
38531e6f
MG		 351 for (i = 2; i < vd->brightness->count; i++) {
352 if (vd->brightness->levels[i] == cur_level)
353 /* The first two entries are special - see page 575
354 of the ACPI spec 3.0 */
355 return i-2;
356 }
357 return 0;
2f3d000a
YL		 358}
359
360static int acpi_video_set_brightness(struct backlight_device *bd)
361{
24450c7a 362 int request_level = bd->props.brightness + 2;
2f3d000a 363 struct acpi_video_device *vd =
655bfd7a 364 (struct acpi_video_device *)bl_get_data(bd);
24450c7a
ZR		 365
366 return acpi_video_device_lcd_set_level(vd,
367 vd->brightness->levels[request_level]);
2f3d000a
YL		 368}
369
599a52d1
RP		 370static struct backlight_ops acpi_backlight_ops = {
371 .get_brightness = acpi_video_get_brightness,
372 .update_status = acpi_video_set_brightness,
373};
374
23b0f015
LY		 375/*video output device sysfs support*/
376static int acpi_video_output_get(struct output_device *od)
377{
27663c58 378 unsigned long long state;
23b0f015 379 struct acpi_video_device *vd =
60043428 380 (struct acpi_video_device *)dev_get_drvdata(&od->dev);
23b0f015
LY		 381 acpi_video_device_get_state(vd, &state);
382 return (int)state;
383}
384
385static int acpi_video_output_set(struct output_device *od)
386{
387 unsigned long state = od->request_state;
388 struct acpi_video_device *vd=
60043428 389 (struct acpi_video_device *)dev_get_drvdata(&od->dev);
23b0f015
LY		 390 return acpi_video_device_set_state(vd, state);
391}
392
393static struct output_properties acpi_output_properties = {
394 .set_state = acpi_video_output_set,
395 .get_status = acpi_video_output_get,
396};
702ed512
ZR		 397
398
399/* thermal cooling device callbacks */
4a703a8f 400static int video_get_max_state(struct thermal_cooling_device *cooling_dev, unsigned
6503e5df 401 long *state)
702ed512 402{
4a703a8f 403 struct acpi_device *device = cooling_dev->devdata;
702ed512
ZR		 404 struct acpi_video_device *video = acpi_driver_data(device);
405
6503e5df
MG		 406 *state = video->brightness->count - 3;
407 return 0;
702ed512
ZR		 408}
409
4a703a8f 410static int video_get_cur_state(struct thermal_cooling_device *cooling_dev, unsigned
6503e5df 411 long *state)
702ed512 412{
4a703a8f 413 struct acpi_device *device = cooling_dev->devdata;
702ed512 414 struct acpi_video_device *video = acpi_driver_data(device);
27663c58 415 unsigned long long level;
6503e5df 416 int offset;
702ed512 417
70287db8 418 if (acpi_video_device_lcd_get_level_current(video, &level, 0))
c8890f90 419 return -EINVAL;
6503e5df
MG		 420 for (offset = 2; offset < video->brightness->count; offset++)
421 if (level == video->brightness->levels[offset]) {
422 *state = video->brightness->count - offset - 1;
423 return 0;
424 }
702ed512
ZR		 425
426 return -EINVAL;
427}
428
429static int
4a703a8f 430video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long state)
702ed512 431{
4a703a8f 432 struct acpi_device *device = cooling_dev->devdata;
702ed512
ZR		 433 struct acpi_video_device *video = acpi_driver_data(device);
434 int level;
435
436 if ( state >= video->brightness->count - 2)
437 return -EINVAL;
438
439 state = video->brightness->count - state;
440 level = video->brightness->levels[state -1];
441 return acpi_video_device_lcd_set_level(video, level);
442}
443
444static struct thermal_cooling_device_ops video_cooling_ops = {
445 .get_max_state = video_get_max_state,
446 .get_cur_state = video_get_cur_state,
447 .set_cur_state = video_set_cur_state,
448};
449
1da177e4
LT		 450/* --------------------------------------------------------------------------
451 Video Management
452 -------------------------------------------------------------------------- */
453
454/* device */
455
1da177e4 456static int
4be44fcd 457acpi_video_device_get_state(struct acpi_video_device *device,
27663c58 458 unsigned long long *state)
1da177e4 459{
4be44fcd 460 int status;
1da177e4 461
90130268 462 status = acpi_evaluate_integer(device->dev->handle, "_DCS", NULL, state);
1da177e4 463
d550d98d 464 return status;
1da177e4
LT		 465}
466
467static int
4be44fcd 468acpi_video_device_set_state(struct acpi_video_device *device, int state)
1da177e4 469{
4be44fcd
LB		 470 int status;
471 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
472 struct acpi_object_list args = { 1, &arg0 };
27663c58 473 unsigned long long ret;
1da177e4 474
1da177e4
LT		 475
476 arg0.integer.value = state;
90130268 477 status = acpi_evaluate_integer(device->dev->handle, "_DSS", &args, &ret);
1da177e4 478
d550d98d 479 return status;
1da177e4
LT		 480}
481
482static int
4be44fcd
LB		 483acpi_video_device_lcd_query_levels(struct acpi_video_device *device,
484 union acpi_object **levels)
1da177e4 485{
4be44fcd
LB		 486 int status;
487 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
488 union acpi_object *obj;
1da177e4 489
1da177e4
LT		 490
491 *levels = NULL;
492
90130268 493 status = acpi_evaluate_object(device->dev->handle, "_BCL", NULL, &buffer);
1da177e4 494 if (!ACPI_SUCCESS(status))
d550d98d 495 return status;
4be44fcd 496 obj = (union acpi_object *)buffer.pointer;
6665bda7 497 if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
6468463a 498 printk(KERN_ERR PREFIX "Invalid _BCL data\n");
1da177e4
LT		 499 status = -EFAULT;
500 goto err;
501 }
502
503 *levels = obj;
504
d550d98d 505 return 0;
1da177e4 506
4be44fcd 507 err:
6044ec88 508 kfree(buffer.pointer);
1da177e4 509
d550d98d 510 return status;
1da177e4
LT		 511}
512
513static int
4be44fcd 514acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level)
1da177e4 515{
24450c7a 516 int status;
4be44fcd
LB		 517 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
518 struct acpi_object_list args = { 1, &arg0 };
9e6dada9 519 int state;
1da177e4 520
1da177e4 521 arg0.integer.value = level;
1da177e4 522
24450c7a
ZR		 523 status = acpi_evaluate_object(device->dev->handle, "_BCM",
524 &args, NULL);
525 if (ACPI_FAILURE(status)) {
526 ACPI_ERROR((AE_INFO, "Evaluating _BCM failed"));
527 return -EIO;
528 }
529
4500ca8e 530 device->brightness->curr = level;
9e6dada9 531 for (state = 2; state < device->brightness->count; state++)
24450c7a 532 if (level == device->brightness->levels[state]) {
1a7c618a
ZR		 533 if (device->backlight)
534 device->backlight->props.brightness = state - 2;
24450c7a
ZR		 535 return 0;
536 }
9e6dada9 537
24450c7a
ZR		 538 ACPI_ERROR((AE_INFO, "Current brightness invalid"));
539 return -EINVAL;
1da177e4
LT		 540}
541
45cb50e6
ZR		 542/*
543 * For some buggy _BQC methods, we need to add a constant value to
544 * the _BQC return value to get the actual current brightness level
545 */
546
547static int bqc_offset_aml_bug_workaround;
548static int __init video_set_bqc_offset(const struct dmi_system_id *d)
549{
550 bqc_offset_aml_bug_workaround = 9;
551 return 0;
552}
553
554static struct dmi_system_id video_dmi_table[] __initdata = {
555 /*
556 * Broken _BQC workaround http://bugzilla.kernel.org/show_bug.cgi?id=13121
557 */
558 {
559 .callback = video_set_bqc_offset,
560 .ident = "Acer Aspire 5720",
561 .matches = {
562 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
563 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5720"),
564 },
565 },
5afc4abe
LB		 566 {
567 .callback = video_set_bqc_offset,
568 .ident = "Acer Aspire 5710Z",
569 .matches = {
570 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
571 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5710Z"),
572 },
573 },
34ac272b
ZR		 574 {
575 .callback = video_set_bqc_offset,
576 .ident = "eMachines E510",
577 .matches = {
578 DMI_MATCH(DMI_BOARD_VENDOR, "EMACHINES"),
579 DMI_MATCH(DMI_PRODUCT_NAME, "eMachines E510"),
580 },
581 },
93bcece2
ZR		 582 {
583 .callback = video_set_bqc_offset,
584 .ident = "Acer Aspire 5315",
585 .matches = {
586 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
587 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5315"),
588 },
589 },
152a4e63
ZR		 590 {
591 .callback = video_set_bqc_offset,
592 .ident = "Acer Aspire 7720",
593 .matches = {
594 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
595 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7720"),
596 },
597 },
45cb50e6
ZR		 598 {}
599};
600
1da177e4 601static int
4be44fcd 602acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
70287db8 603 unsigned long long *level, int init)
1da177e4 604{
c8890f90 605 acpi_status status = AE_OK;
4e231fa4 606 int i;
c8890f90 607
c60d638e
ZR		 608 if (device->cap._BQC || device->cap._BCQ) {
609 char *buf = device->cap._BQC ? "_BQC" : "_BCQ";
610
611 status = acpi_evaluate_integer(device->dev->handle, buf,
c8890f90
ZR		 612 NULL, level);
613 if (ACPI_SUCCESS(status)) {
1a7c618a
ZR		 614 if (device->brightness->flags._BQC_use_index) {
615 if (device->brightness->flags._BCL_reversed)
616 *level = device->brightness->count
617 - 3 - (*level);
618 *level = device->brightness->levels[*level + 2];
619
620 }
45cb50e6 621 *level += bqc_offset_aml_bug_workaround;
4e231fa4
VS		 622 for (i = 2; i < device->brightness->count; i++)
623 if (device->brightness->levels[i] == *level) {
624 device->brightness->curr = *level;
625 return 0;
626 }
70287db8
MG		 627 if (!init) {
628 /*
629 * BQC returned an invalid level.
630 * Stop using it.
631 */
632 ACPI_WARNING((AE_INFO,
633 "%s returned an invalid level",
634 buf));
635 device->cap._BQC = device->cap._BCQ = 0;
636 }
c8890f90
ZR		 637 } else {
638 /* Fixme:
639 * should we return an error or ignore this failure?
640 * dev->brightness->curr is a cached value which stores
641 * the correct current backlight level in most cases.
642 * ACPI video backlight still works w/ buggy _BQC.
643 * http://bugzilla.kernel.org/show_bug.cgi?id=12233
644 */
c60d638e
ZR		 645 ACPI_WARNING((AE_INFO, "Evaluating %s failed", buf));
646 device->cap._BQC = device->cap._BCQ = 0;
c8890f90
ZR		 647 }
648 }
649
4500ca8e 650 *level = device->brightness->curr;
c8890f90 651 return 0;
1da177e4
LT		 652}
653
654static int
4be44fcd
LB		 655acpi_video_device_EDID(struct acpi_video_device *device,
656 union acpi_object **edid, ssize_t length)
1da177e4 657{
4be44fcd
LB		 658 int status;
659 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
660 union acpi_object *obj;
661 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
662 struct acpi_object_list args = { 1, &arg0 };
1da177e4 663
1da177e4
LT		 664
665 *edid = NULL;
666
667 if (!device)
d550d98d 668 return -ENODEV;
1da177e4
LT		 669 if (length == 128)
670 arg0.integer.value = 1;
671 else if (length == 256)
672 arg0.integer.value = 2;
673 else
d550d98d 674 return -EINVAL;
1da177e4 675
90130268 676 status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer);
1da177e4 677 if (ACPI_FAILURE(status))
d550d98d 678 return -ENODEV;
1da177e4 679
50dd0969 680 obj = buffer.pointer;
1da177e4
LT		 681
682 if (obj && obj->type == ACPI_TYPE_BUFFER)
683 *edid = obj;
684 else {
6468463a 685 printk(KERN_ERR PREFIX "Invalid _DDC data\n");
1da177e4
LT		 686 status = -EFAULT;
687 kfree(obj);
688 }
689
d550d98d 690 return status;
1da177e4
LT		 691}
692
1da177e4
LT		 693/* bus */
694
1da177e4
LT		 695/*
696 * Arg:
697 * video : video bus device pointer
698 * bios_flag :
699 * 0. The system BIOS should NOT automatically switch(toggle)
700 * the active display output.
701 * 1. The system BIOS should automatically switch (toggle) the
98fb8fe1 702 * active display output. No switch event.
1da177e4
LT		 703 * 2. The _DGS value should be locked.
704 * 3. The system BIOS should not automatically switch (toggle) the
705 * active display output, but instead generate the display switch
706 * event notify code.
707 * lcd_flag :
708 * 0. The system BIOS should automatically control the brightness level
98fb8fe1 709 * of the LCD when the power changes from AC to DC
1da177e4 710 * 1. The system BIOS should NOT automatically control the brightness
98fb8fe1 711 * level of the LCD when the power changes from AC to DC.
1da177e4
LT		 712 * Return Value:
713 * -1 wrong arg.
714 */
715
716static int
4be44fcd 717acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
1da177e4 718{
439913ff 719 u64 status = 0;
4be44fcd
LB		 720 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
721 struct acpi_object_list args = { 1, &arg0 };
1da177e4 722
1da177e4 723
4be44fcd 724 if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1) {
1da177e4
LT		 725 status = -1;
726 goto Failed;
727 }
728 arg0.integer.value = (lcd_flag << 2) | bios_flag;
729 video->dos_setting = arg0.integer.value;
90130268 730 acpi_evaluate_object(video->device->handle, "_DOS", &args, NULL);
1da177e4 731
4be44fcd 732 Failed:
d550d98d 733 return status;
1da177e4
LT		 734}
735
935e5f29
ZR		 736/*
737 * Simple comparison function used to sort backlight levels.
738 */
739
740static int
741acpi_video_cmp_level(const void *a, const void *b)
742{
743 return *(int *)a - *(int *)b;
744}
745
1da177e4
LT		 746/*
747 * Arg:
748 * device : video output device (LCD, CRT, ..)
749 *
750 * Return Value:
469778c1
JJ		 751 * Maximum brightness level
752 *
753 * Allocate and initialize device->brightness.
754 */
755
756static int
757acpi_video_init_brightness(struct acpi_video_device *device)
758{
759 union acpi_object *obj = NULL;
d32f6947 760 int i, max_level = 0, count = 0, level_ac_battery = 0;
1a7c618a 761 unsigned long long level, level_old;
469778c1
JJ		 762 union acpi_object *o;
763 struct acpi_video_device_brightness *br = NULL;
1a7c618a 764 int result = -EINVAL;
469778c1
JJ		 765
766 if (!ACPI_SUCCESS(acpi_video_device_lcd_query_levels(device, &obj))) {
767 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Could not query available "
768 "LCD brightness level\n"));
769 goto out;
770 }
771
772 if (obj->package.count < 2)
773 goto out;
774
775 br = kzalloc(sizeof(*br), GFP_KERNEL);
776 if (!br) {
777 printk(KERN_ERR "can't allocate memory\n");
1a7c618a 778 result = -ENOMEM;
469778c1
JJ		 779 goto out;
780 }
781
d32f6947 782 br->levels = kmalloc((obj->package.count + 2) * sizeof *(br->levels),
469778c1 783 GFP_KERNEL);
1a7c618a
ZR		 784 if (!br->levels) {
785 result = -ENOMEM;
469778c1 786 goto out_free;
1a7c618a 787 }
469778c1
JJ		 788
789 for (i = 0; i < obj->package.count; i++) {
790 o = (union acpi_object *)&obj->package.elements[i];
791 if (o->type != ACPI_TYPE_INTEGER) {
792 printk(KERN_ERR PREFIX "Invalid data\n");
793 continue;
794 }
795 br->levels[count] = (u32) o->integer.value;
796
797 if (br->levels[count] > max_level)
798 max_level = br->levels[count];
799 count++;
800 }
801
d32f6947
ZR		 802 /*
803 * some buggy BIOS don't export the levels
804 * when machine is on AC/Battery in _BCL package.
805 * In this case, the first two elements in _BCL packages
806 * are also supported brightness levels that OS should take care of.
807 */
90af2cf6
ZR		 808 for (i = 2; i < count; i++) {
809 if (br->levels[i] == br->levels[0])
d32f6947 810 level_ac_battery++;
90af2cf6
ZR		 811 if (br->levels[i] == br->levels[1])
812 level_ac_battery++;
813 }
d32f6947
ZR		 814
815 if (level_ac_battery < 2) {
816 level_ac_battery = 2 - level_ac_battery;
817 br->flags._BCL_no_ac_battery_levels = 1;
818 for (i = (count - 1 + level_ac_battery); i >= 2; i--)
819 br->levels[i] = br->levels[i - level_ac_battery];
820 count += level_ac_battery;
821 } else if (level_ac_battery > 2)
822 ACPI_ERROR((AE_INFO, "Too many duplicates in _BCL package\n"));
823
d80fb99f
ZR		 824 /* Check if the _BCL package is in a reversed order */
825 if (max_level == br->levels[2]) {
826 br->flags._BCL_reversed = 1;
827 sort(&br->levels[2], count - 2, sizeof(br->levels[2]),
828 acpi_video_cmp_level, NULL);
829 } else if (max_level != br->levels[count - 1])
830 ACPI_ERROR((AE_INFO,
831 "Found unordered _BCL package\n"));
469778c1
JJ		 832
833 br->count = count;
834 device->brightness = br;
1a7c618a
ZR		 835
836 /* Check the input/output of _BQC/_BCL/_BCM */
837 if ((max_level < 100) && (max_level <= (count - 2)))
838 br->flags._BCL_use_index = 1;
839
840 /*
841 * _BCM is always consistent with _BCL,
842 * at least for all the laptops we have ever seen.
843 */
844 br->flags._BCM_use_index = br->flags._BCL_use_index;
845
846 /* _BQC uses INDEX while _BCL uses VALUE in some laptops */
90c53ca4 847 br->curr = level = max_level;
e047cca6
ZR		 848
849 if (!device->cap._BQC)
850 goto set_level;
851
70287db8 852 result = acpi_video_device_lcd_get_level_current(device, &level_old, 1);
1a7c618a
ZR		 853 if (result)
854 goto out_free_levels;
855
e047cca6
ZR		 856 /*
857 * Set the level to maximum and check if _BQC uses indexed value
858 */
859 result = acpi_video_device_lcd_set_level(device, max_level);
1a7c618a
ZR		 860 if (result)
861 goto out_free_levels;
862
70287db8 863 result = acpi_video_device_lcd_get_level_current(device, &level, 0);
1a7c618a
ZR		 864 if (result)
865 goto out_free_levels;
866
e047cca6
ZR		 867 br->flags._BQC_use_index = (level == max_level ? 0 : 1);
868
90c53ca4
ZR		 869 if (!br->flags._BQC_use_index) {
870 /*
871 * Set the backlight to the initial state.
872 * On some buggy laptops, _BQC returns an uninitialized value
873 * when invoked for the first time, i.e. level_old is invalid.
874 * set the backlight to max_level in this case
875 */
876 for (i = 2; i < br->count; i++)
877 if (level_old == br->levels[i])
878 level = level_old;
e047cca6 879 goto set_level;
90c53ca4 880 }
e047cca6
ZR		 881
882 if (br->flags._BCL_reversed)
883 level_old = (br->count - 1) - level_old;
90c53ca4 884 level = br->levels[level_old];
e047cca6
ZR		 885
886set_level:
90c53ca4 887 result = acpi_video_device_lcd_set_level(device, level);
e047cca6
ZR		 888 if (result)
889 goto out_free_levels;
1a7c618a 890
d32f6947
ZR		 891 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
892 "found %d brightness levels\n", count - 2));
469778c1 893 kfree(obj);
1a7c618a 894 return result;
469778c1
JJ		 895
896out_free_levels:
897 kfree(br->levels);
898out_free:
899 kfree(br);
900out:
901 device->brightness = NULL;
902 kfree(obj);
1a7c618a 903 return result;
469778c1
JJ		 904}
905
906/*
907 * Arg:
908 * device : video output device (LCD, CRT, ..)
909 *
910 * Return Value:
1da177e4
LT		 911 * None
912 *
98fb8fe1 913 * Find out all required AML methods defined under the output
1da177e4
LT		 914 * device.
915 */
916
4be44fcd 917static void acpi_video_device_find_cap(struct acpi_video_device *device)
1da177e4 918{
1da177e4 919 acpi_handle h_dummy1;
1da177e4 920
90130268 921 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_ADR", &h_dummy1))) {
1da177e4
LT		 922 device->cap._ADR = 1;
923 }
90130268 924 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCL", &h_dummy1))) {
4be44fcd 925 device->cap._BCL = 1;
1da177e4 926 }
90130268 927 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCM", &h_dummy1))) {
4be44fcd 928 device->cap._BCM = 1;
1da177e4 929 }
2f3d000a
YL		 930 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle,"_BQC",&h_dummy1)))
931 device->cap._BQC = 1;
c60d638e
ZR		 932 else if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCQ",
933 &h_dummy1))) {
934 printk(KERN_WARNING FW_BUG "_BCQ is used instead of _BQC\n");
935 device->cap._BCQ = 1;
936 }
937
90130268 938 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DDC", &h_dummy1))) {
4be44fcd 939 device->cap._DDC = 1;
1da177e4 940 }
90130268 941 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DCS", &h_dummy1))) {
1da177e4
LT		 942 device->cap._DCS = 1;
943 }
90130268 944 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DGS", &h_dummy1))) {
1da177e4
LT		 945 device->cap._DGS = 1;
946 }
90130268 947 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DSS", &h_dummy1))) {
1da177e4
LT		 948 device->cap._DSS = 1;
949 }
950
1a7c618a 951 if (acpi_video_backlight_support()) {
a19a6ee6 952 struct backlight_properties props;
702ed512 953 int result;
2f3d000a
YL		 954 static int count = 0;
955 char *name;
1a7c618a
ZR		 956
957 result = acpi_video_init_brightness(device);
958 if (result)
959 return;
aeb834d9 960 name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
2f3d000a
YL		 961 if (!name)
962 return;
aeb834d9 963 count++;
2f3d000a 964
a19a6ee6
MG		 965 memset(&props, 0, sizeof(struct backlight_properties));
966 props.max_brightness = device->brightness->count - 3;
967 device->backlight = backlight_device_register(name, NULL, device,
968 &acpi_backlight_ops,
969 &props);
2f3d000a 970 kfree(name);
e01ce79b
ZR		 971 if (IS_ERR(device->backlight))
972 return;
702ed512 973
ac7729da
RW		 974 /*
975 * Save current brightness level in case we have to restore it
976 * before acpi_video_device_lcd_set_level() is called next time.
977 */
978 device->backlight->props.brightness =
979 acpi_video_get_brightness(device->backlight);
702ed512 980
056c308d
ZR		 981 result = sysfs_create_link(&device->backlight->dev.kobj,
982 &device->dev->dev.kobj, "device");
983 if (result)
984 printk(KERN_ERR PREFIX "Create sysfs link\n");
985
4a703a8f 986 device->cooling_dev = thermal_cooling_device_register("LCD",
702ed512 987 device->dev, &video_cooling_ops);
4a703a8f 988 if (IS_ERR(device->cooling_dev)) {
4b4fe3b6 989 /*
4a703a8f 990 * Set cooling_dev to NULL so we don't crash trying to
4b4fe3b6
DT		 991 * free it.
992 * Also, why the hell we are returning early and
993 * not attempt to register video output if cooling
994 * device registration failed?
995 * -- dtor
996 */
4a703a8f 997 device->cooling_dev = NULL;
43ff39f2 998 return;
4b4fe3b6 999 }
43ff39f2 1000
fc3a8828 1001 dev_info(&device->dev->dev, "registered as cooling_device%d\n",
4a703a8f 1002 device->cooling_dev->id);
9030062f 1003 result = sysfs_create_link(&device->dev->dev.kobj,
4a703a8f 1004 &device->cooling_dev->device.kobj,
9030062f
JL		 1005 "thermal_cooling");
1006 if (result)
1007 printk(KERN_ERR PREFIX "Create sysfs link\n");
4a703a8f 1008 result = sysfs_create_link(&device->cooling_dev->device.kobj,
9030062f
JL		 1009 &device->dev->dev.kobj, "device");
1010 if (result)
1011 printk(KERN_ERR PREFIX "Create sysfs link\n");
1012
2f3d000a 1013 }
c3d6de69
TR		 1014
1015 if (acpi_video_display_switch_support()) {
1016
1017 if (device->cap._DCS && device->cap._DSS) {
1018 static int count;
1019 char *name;
aeb834d9 1020 name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
c3d6de69
TR		 1021 if (!name)
1022 return;
aeb834d9 1023 count++;
c3d6de69
TR		 1024 device->output_dev = video_output_register(name,
1025 NULL, device, &acpi_output_properties);
1026 kfree(name);
1027 }
23b0f015 1028 }
1da177e4
LT		 1029}
1030
1031/*
1032 * Arg:
1033 * device : video output device (VGA)
1034 *
1035 * Return Value:
1036 * None
1037 *
98fb8fe1 1038 * Find out all required AML methods defined under the video bus device.
1da177e4
LT		 1039 */
1040
4be44fcd 1041static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
1da177e4 1042{
4be44fcd 1043 acpi_handle h_dummy1;
1da177e4 1044
90130268 1045 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOS", &h_dummy1))) {
1da177e4
LT		 1046 video->cap._DOS = 1;
1047 }
90130268 1048 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOD", &h_dummy1))) {
1da177e4
LT		 1049 video->cap._DOD = 1;
1050 }
90130268 1051 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_ROM", &h_dummy1))) {
1da177e4
LT		 1052 video->cap._ROM = 1;
1053 }
90130268 1054 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_GPD", &h_dummy1))) {
1da177e4
LT		 1055 video->cap._GPD = 1;
1056 }
90130268 1057 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_SPD", &h_dummy1))) {
1da177e4
LT		 1058 video->cap._SPD = 1;
1059 }
90130268 1060 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_VPO", &h_dummy1))) {
1da177e4
LT		 1061 video->cap._VPO = 1;
1062 }
1063}
1064
1065/*
1066 * Check whether the video bus device has required AML method to
1067 * support the desired features
1068 */
1069
4be44fcd 1070static int acpi_video_bus_check(struct acpi_video_bus *video)
1da177e4 1071{
4be44fcd 1072 acpi_status status = -ENOENT;
1e4cffe7 1073 struct pci_dev *dev;
1da177e4
LT		 1074
1075 if (!video)
d550d98d 1076 return -EINVAL;
1da177e4 1077
1e4cffe7 1078 dev = acpi_get_pci_dev(video->device->handle);
22c13f9d
TR		 1079 if (!dev)
1080 return -ENODEV;
1e4cffe7 1081 pci_dev_put(dev);
22c13f9d 1082
1da177e4
LT		 1083 /* Since there is no HID, CID and so on for VGA driver, we have
1084 * to check well known required nodes.
1085 */
1086
98fb8fe1 1087 /* Does this device support video switching? */
3a1151e3
SB		 1088 if (video->cap._DOS || video->cap._DOD) {
1089 if (!video->cap._DOS) {
1090 printk(KERN_WARNING FW_BUG
1091 "ACPI(%s) defines _DOD but not _DOS\n",
1092 acpi_device_bid(video->device));
1093 }
1da177e4
LT		 1094 video->flags.multihead = 1;
1095 status = 0;
1096 }
1097
98fb8fe1 1098 /* Does this device support retrieving a video ROM? */
4be44fcd 1099 if (video->cap._ROM) {
1da177e4
LT		 1100 video->flags.rom = 1;
1101 status = 0;
1102 }
1103
98fb8fe1 1104 /* Does this device support configuring which video device to POST? */
4be44fcd 1105 if (video->cap._GPD && video->cap._SPD && video->cap._VPO) {
1da177e4
LT		 1106 video->flags.post = 1;
1107 status = 0;
1108 }
1109
d550d98d 1110 return status;
1da177e4
LT		 1111}
1112
1113/* --------------------------------------------------------------------------
1114 FS Interface (/proc)
1115 -------------------------------------------------------------------------- */
6e37c658 1116#ifdef CONFIG_ACPI_PROCFS
1da177e4 1117
4be44fcd 1118static struct proc_dir_entry *acpi_video_dir;
1da177e4
LT		 1119
1120/* video devices */
1121
4be44fcd 1122static int acpi_video_device_info_seq_show(struct seq_file *seq, void *offset)
1da177e4 1123{
50dd0969 1124 struct acpi_video_device *dev = seq->private;
1da177e4 1125
1da177e4
LT		 1126
1127 if (!dev)
1128 goto end;
1129
1130 seq_printf(seq, "device_id: 0x%04x\n", (u32) dev->device_id);
1131 seq_printf(seq, "type: ");
1132 if (dev->flags.crt)
1133 seq_printf(seq, "CRT\n");
1134 else if (dev->flags.lcd)
1135 seq_printf(seq, "LCD\n");
1136 else if (dev->flags.tvout)
1137 seq_printf(seq, "TVOUT\n");
82cae999
RZ		 1138 else if (dev->flags.dvi)
1139 seq_printf(seq, "DVI\n");
1da177e4
LT		 1140 else
1141 seq_printf(seq, "UNKNOWN\n");
1142
4be44fcd 1143 seq_printf(seq, "known by bios: %s\n", dev->flags.bios ? "yes" : "no");
1da177e4 1144
4be44fcd 1145 end:
d550d98d 1146 return 0;
1da177e4
LT		 1147}
1148
1149static int
4be44fcd 1150acpi_video_device_info_open_fs(struct inode *inode, struct file *file)
1da177e4
LT		 1151{
1152 return single_open(file, acpi_video_device_info_seq_show,
1153 PDE(inode)->data);
1154}
1155
6e37c658
ZR		 1156static int
1157acpi_video_device_query(struct acpi_video_device *device,
1158 unsigned long long *state)
1159{
1160 int status;
1161
1162 status = acpi_evaluate_integer(device->dev->handle, "_DGS",
1163 NULL, state);
1164
1165 return status;
1166}
1167
4be44fcd 1168static int acpi_video_device_state_seq_show(struct seq_file *seq, void *offset)
1da177e4 1169{
4be44fcd 1170 int status;
50dd0969 1171 struct acpi_video_device *dev = seq->private;
27663c58 1172 unsigned long long state;
1da177e4 1173
1da177e4
LT		 1174
1175 if (!dev)
1176 goto end;
1177
1178 status = acpi_video_device_get_state(dev, &state);
1179 seq_printf(seq, "state: ");
1180 if (ACPI_SUCCESS(status))
27663c58 1181 seq_printf(seq, "0x%02llx\n", state);
1da177e4
LT		 1182 else
1183 seq_printf(seq, "<not supported>\n");
1184
1185 status = acpi_video_device_query(dev, &state);
1186 seq_printf(seq, "query: ");
1187 if (ACPI_SUCCESS(status))
27663c58 1188 seq_printf(seq, "0x%02llx\n", state);
1da177e4
LT		 1189 else
1190 seq_printf(seq, "<not supported>\n");
1191
4be44fcd 1192 end:
d550d98d 1193 return 0;
1da177e4
LT		 1194}
1195
1196static int
4be44fcd 1197acpi_video_device_state_open_fs(struct inode *inode, struct file *file)
1da177e4
LT		 1198{
1199 return single_open(file, acpi_video_device_state_seq_show,
1200 PDE(inode)->data);
1201}
1202
1203static ssize_t
4be44fcd
LB		 1204acpi_video_device_write_state(struct file *file,
1205 const char __user * buffer,
1206 size_t count, loff_t * data)
1da177e4 1207{
4be44fcd 1208 int status;
50dd0969
JE		 1209 struct seq_file *m = file->private_data;
1210 struct acpi_video_device *dev = m->private;
4be44fcd
LB		 1211 char str[12] = { 0 };
1212 u32 state = 0;
1da177e4 1213
1da177e4 1214
52a2b11c 1215 if (!dev || count >= sizeof(str))
d550d98d 1216 return -EINVAL;
1da177e4
LT		 1217
1218 if (copy_from_user(str, buffer, count))
d550d98d 1219 return -EFAULT;
1da177e4
LT		 1220
1221 str[count] = 0;
1222 state = simple_strtoul(str, NULL, 0);
4be44fcd 1223 state &= ((1ul << 31) | (1ul << 30) | (1ul << 0));
1da177e4
LT		 1224
1225 status = acpi_video_device_set_state(dev, state);
1226
1227 if (status)
d550d98d 1228 return -EFAULT;
1da177e4 1229
d550d98d 1230 return count;
1da177e4
LT		 1231}
1232
1233static int
4be44fcd 1234acpi_video_device_brightness_seq_show(struct seq_file *seq, void *offset)
1da177e4 1235{
50dd0969 1236 struct acpi_video_device *dev = seq->private;
4be44fcd 1237 int i;
1da177e4 1238
1da177e4
LT		 1239
1240 if (!dev || !dev->brightness) {
1241 seq_printf(seq, "<not supported>\n");
d550d98d 1242 return 0;
1da177e4
LT		 1243 }
1244
1245 seq_printf(seq, "levels: ");
0a3db1ce 1246 for (i = 2; i < dev->brightness->count; i++)
1da177e4
LT		 1247 seq_printf(seq, " %d", dev->brightness->levels[i]);
1248 seq_printf(seq, "\ncurrent: %d\n", dev->brightness->curr);
1249
d550d98d 1250 return 0;
1da177e4
LT		 1251}
1252
1253static int
4be44fcd 1254acpi_video_device_brightness_open_fs(struct inode *inode, struct file *file)
1da177e4
LT		 1255{
1256 return single_open(file, acpi_video_device_brightness_seq_show,
1257 PDE(inode)->data);
1258}
1259
1260static ssize_t
4be44fcd
LB		 1261acpi_video_device_write_brightness(struct file *file,
1262 const char __user * buffer,
1263 size_t count, loff_t * data)
1da177e4 1264{
50dd0969
JE		 1265 struct seq_file *m = file->private_data;
1266 struct acpi_video_device *dev = m->private;
c88c5786 1267 char str[5] = { 0 };
4be44fcd
LB		 1268 unsigned int level = 0;
1269 int i;
1da177e4 1270
1da177e4 1271
52a2b11c 1272 if (!dev || !dev->brightness || count >= sizeof(str))
d550d98d 1273 return -EINVAL;
1da177e4
LT		 1274
1275 if (copy_from_user(str, buffer, count))
d550d98d 1276 return -EFAULT;
1da177e4
LT		 1277
1278 str[count] = 0;
1279 level = simple_strtoul(str, NULL, 0);
4be44fcd 1280
1da177e4 1281 if (level > 100)
d550d98d 1282 return -EFAULT;
1da177e4 1283
98fb8fe1 1284 /* validate through the list of available levels */
0a3db1ce 1285 for (i = 2; i < dev->brightness->count; i++)
1da177e4 1286 if (level == dev->brightness->levels[i]) {
24450c7a
ZR		 1287 if (!acpi_video_device_lcd_set_level(dev, level))
1288 return count;
1da177e4
LT		 1289 break;
1290 }
1291
24450c7a 1292 return -EINVAL;
1da177e4
LT		 1293}
1294
4be44fcd 1295static int acpi_video_device_EDID_seq_show(struct seq_file *seq, void *offset)
1da177e4 1296{
50dd0969 1297 struct acpi_video_device *dev = seq->private;
4be44fcd
LB		 1298 int status;
1299 int i;
1300 union acpi_object *edid = NULL;
1da177e4 1301
1da177e4
LT		 1302
1303 if (!dev)
1304 goto out;
1305
4be44fcd 1306 status = acpi_video_device_EDID(dev, &edid, 128);
1da177e4 1307 if (ACPI_FAILURE(status)) {
4be44fcd 1308 status = acpi_video_device_EDID(dev, &edid, 256);
1da177e4
LT		 1309 }
1310
1311 if (ACPI_FAILURE(status)) {
1312 goto out;
1313 }
1314
1315 if (edid && edid->type == ACPI_TYPE_BUFFER) {
1316 for (i = 0; i < edid->buffer.length; i++)
1317 seq_putc(seq, edid->buffer.pointer[i]);
1318 }
1319
4be44fcd 1320 out:
1da177e4
LT		 1321 if (!edid)
1322 seq_printf(seq, "<not supported>\n");
1323 else
1324 kfree(edid);
1325
d550d98d 1326 return 0;
1da177e4
LT		 1327}
1328
1329static int
4be44fcd 1330acpi_video_device_EDID_open_fs(struct inode *inode, struct file *file)
1da177e4
LT		 1331{
1332 return single_open(file, acpi_video_device_EDID_seq_show,
1333 PDE(inode)->data);
1334}
1335
4be44fcd 1336static int acpi_video_device_add_fs(struct acpi_device *device)
1da177e4 1337{
251cb0bc 1338 struct proc_dir_entry *entry, *device_dir;
1da177e4
LT		 1339 struct acpi_video_device *vid_dev;
1340
50dd0969 1341 vid_dev = acpi_driver_data(device);
1da177e4 1342 if (!vid_dev)
d550d98d 1343 return -ENODEV;
1da177e4 1344
251cb0bc
DT		 1345 device_dir = proc_mkdir(acpi_device_bid(device),
1346 vid_dev->video->dir);
1347 if (!device_dir)
1348 return -ENOMEM;
1349
1da177e4 1350 /* 'info' [R] */
e0066c4e 1351 entry = proc_create_data("info", S_IRUGO, device_dir,
cf7acfab 1352 &acpi_video_device_info_fops, acpi_driver_data(device));
1da177e4 1353 if (!entry)
251cb0bc 1354 goto err_remove_dir;
1da177e4
LT		 1355
1356 /* 'state' [R/W] */
cf7acfab 1357 entry = proc_create_data("state", S_IFREG | S_IRUGO | S_IWUSR,
e0066c4e 1358 device_dir,
cf7acfab
DL		 1359 &acpi_video_device_state_fops,
1360 acpi_driver_data(device));
1da177e4 1361 if (!entry)
251cb0bc 1362 goto err_remove_info;
1da177e4
LT		 1363
1364 /* 'brightness' [R/W] */
cf7acfab 1365 entry = proc_create_data("brightness", S_IFREG | S_IRUGO | S_IWUSR,
e0066c4e 1366 device_dir,
cf7acfab
DL		 1367 &acpi_video_device_brightness_fops,
1368 acpi_driver_data(device));
1da177e4 1369 if (!entry)
251cb0bc 1370 goto err_remove_state;
1da177e4
LT		 1371
1372 /* 'EDID' [R] */
e0066c4e 1373 entry = proc_create_data("EDID", S_IRUGO, device_dir,
cf7acfab
DL		 1374 &acpi_video_device_EDID_fops,
1375 acpi_driver_data(device));
1da177e4 1376 if (!entry)
251cb0bc 1377 goto err_remove_brightness;
1da177e4 1378
e0066c4e
AD		 1379 acpi_device_dir(device) = device_dir;
1380
d550d98d 1381 return 0;
251cb0bc
DT		 1382
1383 err_remove_brightness:
1384 remove_proc_entry("brightness", device_dir);
1385 err_remove_state:
1386 remove_proc_entry("state", device_dir);
1387 err_remove_info:
1388 remove_proc_entry("info", device_dir);
1389 err_remove_dir:
1390 remove_proc_entry(acpi_device_bid(device), vid_dev->video->dir);
1391 return -ENOMEM;
1da177e4
LT		 1392}
1393
4be44fcd 1394static int acpi_video_device_remove_fs(struct acpi_device *device)
1da177e4
LT		 1395{
1396 struct acpi_video_device *vid_dev;
251cb0bc 1397 struct proc_dir_entry *device_dir;
1da177e4 1398
50dd0969 1399 vid_dev = acpi_driver_data(device);
1da177e4 1400 if (!vid_dev || !vid_dev->video || !vid_dev->video->dir)
d550d98d 1401 return -ENODEV;
1da177e4 1402
251cb0bc
DT		 1403 device_dir = acpi_device_dir(device);
1404 if (device_dir) {
1405 remove_proc_entry("info", device_dir);
1406 remove_proc_entry("state", device_dir);
1407 remove_proc_entry("brightness", device_dir);
1408 remove_proc_entry("EDID", device_dir);
4be44fcd 1409 remove_proc_entry(acpi_device_bid(device), vid_dev->video->dir);
1da177e4
LT		 1410 acpi_device_dir(device) = NULL;
1411 }
1412
d550d98d 1413 return 0;
1da177e4
LT		 1414}
1415
1da177e4 1416/* video bus */
4be44fcd 1417static int acpi_video_bus_info_seq_show(struct seq_file *seq, void *offset)
1da177e4 1418{
50dd0969 1419 struct acpi_video_bus *video = seq->private;
1da177e4 1420
1da177e4
LT		 1421
1422 if (!video)
1423 goto end;
1424
1425 seq_printf(seq, "Switching heads: %s\n",
4be44fcd 1426 video->flags.multihead ? "yes" : "no");
1da177e4 1427 seq_printf(seq, "Video ROM: %s\n",
4be44fcd 1428 video->flags.rom ? "yes" : "no");
1da177e4 1429 seq_printf(seq, "Device to be POSTed on boot: %s\n",
4be44fcd 1430 video->flags.post ? "yes" : "no");
1da177e4 1431
4be44fcd 1432 end:
d550d98d 1433 return 0;
1da177e4
LT		 1434}
1435
4be44fcd 1436static int acpi_video_bus_info_open_fs(struct inode *inode, struct file *file)
1da177e4 1437{
4be44fcd
LB		 1438 return single_open(file, acpi_video_bus_info_seq_show,
1439 PDE(inode)->data);
1da177e4
LT		 1440}
1441
4be44fcd 1442static int acpi_video_bus_ROM_seq_show(struct seq_file *seq, void *offset)
1da177e4 1443{
50dd0969 1444 struct acpi_video_bus *video = seq->private;
1da177e4 1445
1da177e4
LT		 1446
1447 if (!video)
1448 goto end;
1449
96b2dd1f 1450 printk(KERN_INFO PREFIX "Please implement %s\n", __func__);
1da177e4
LT		 1451 seq_printf(seq, "<TODO>\n");
1452
4be44fcd 1453 end:
d550d98d 1454 return 0;
1da177e4
LT		 1455}
1456
4be44fcd 1457static int acpi_video_bus_ROM_open_fs(struct inode *inode, struct file *file)
1da177e4
LT		 1458{
1459 return single_open(file, acpi_video_bus_ROM_seq_show, PDE(inode)->data);
1460}
1461
6e37c658
ZR		 1462static int
1463acpi_video_bus_POST_options(struct acpi_video_bus *video,
1464 unsigned long long *options)
1465{
1466 int status;
1467
1468 status = acpi_evaluate_integer(video->device->handle, "_VPO",
1469 NULL, options);
1470 *options &= 3;
1471
1472 return status;
1473}
1474
4be44fcd 1475static int acpi_video_bus_POST_info_seq_show(struct seq_file *seq, void *offset)
1da177e4 1476{
50dd0969 1477 struct acpi_video_bus *video = seq->private;
27663c58 1478 unsigned long long options;
4be44fcd 1479 int status;
1da177e4 1480
1da177e4
LT		 1481
1482 if (!video)
1483 goto end;
1484
1485 status = acpi_video_bus_POST_options(video, &options);
1486 if (ACPI_SUCCESS(status)) {
1487 if (!(options & 1)) {
4be44fcd
LB		 1488 printk(KERN_WARNING PREFIX
1489 "The motherboard VGA device is not listed as a possible POST device.\n");
1490 printk(KERN_WARNING PREFIX
98fb8fe1 1491 "This indicates a BIOS bug. Please contact the manufacturer.\n");
1da177e4 1492 }
4d939155 1493 printk(KERN_WARNING "%llx\n", options);
98fb8fe1 1494 seq_printf(seq, "can POST: <integrated video>");
1da177e4
LT		 1495 if (options & 2)
1496 seq_printf(seq, " <PCI video>");
1497 if (options & 4)
1498 seq_printf(seq, " <AGP video>");
1499 seq_putc(seq, '\n');
1500 } else
1501 seq_printf(seq, "<not supported>\n");
4be44fcd 1502 end:
d550d98d 1503 return 0;
1da177e4
LT		 1504}
1505
1506static int
4be44fcd 1507acpi_video_bus_POST_info_open_fs(struct inode *inode, struct file *file)
1da177e4 1508{
4be44fcd
LB		 1509 return single_open(file, acpi_video_bus_POST_info_seq_show,
1510 PDE(inode)->data);
1da177e4
LT		 1511}
1512
6e37c658
ZR		 1513static int
1514acpi_video_bus_get_POST(struct acpi_video_bus *video, unsigned long long *id)
1515{
1516 int status;
1517
1518 status = acpi_evaluate_integer(video->device->handle, "_GPD", NULL, id);
1519
1520 return status;
1521}
1522
4be44fcd 1523static int acpi_video_bus_POST_seq_show(struct seq_file *seq, void *offset)
1da177e4 1524{
50dd0969 1525 struct acpi_video_bus *video = seq->private;
4be44fcd 1526 int status;
27663c58 1527 unsigned long long id;
1da177e4 1528
1da177e4
LT		 1529
1530 if (!video)
1531 goto end;
1532
4be44fcd 1533 status = acpi_video_bus_get_POST(video, &id);
1da177e4
LT		 1534 if (!ACPI_SUCCESS(status)) {
1535 seq_printf(seq, "<not supported>\n");
1536 goto end;
1537 }
98fb8fe1 1538 seq_printf(seq, "device POSTed is <%s>\n", device_decode[id & 3]);
1da177e4 1539
4be44fcd 1540 end:
d550d98d 1541 return 0;
1da177e4
LT		 1542}
1543
4be44fcd 1544static int acpi_video_bus_DOS_seq_show(struct seq_file *seq, void *offset)
1da177e4 1545{
50dd0969 1546 struct acpi_video_bus *video = seq->private;
1da177e4 1547
1da177e4 1548
4be44fcd 1549 seq_printf(seq, "DOS setting: <%d>\n", video->dos_setting);
1da177e4 1550
d550d98d 1551 return 0;
1da177e4
LT		 1552}
1553
4be44fcd 1554static int acpi_video_bus_POST_open_fs(struct inode *inode, struct file *file)
1da177e4 1555{
4be44fcd
LB		 1556 return single_open(file, acpi_video_bus_POST_seq_show,
1557 PDE(inode)->data);
1da177e4
LT		 1558}
1559
4be44fcd 1560static int acpi_video_bus_DOS_open_fs(struct inode *inode, struct file *file)
1da177e4
LT		 1561{
1562 return single_open(file, acpi_video_bus_DOS_seq_show, PDE(inode)->data);
1563}
1564
6e37c658
ZR		 1565static int
1566acpi_video_bus_set_POST(struct acpi_video_bus *video, unsigned long option)
1567{
1568 int status;
1569 unsigned long long tmp;
1570 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
1571 struct acpi_object_list args = { 1, &arg0 };
1572
1573
1574 arg0.integer.value = option;
1575
1576 status = acpi_evaluate_integer(video->device->handle, "_SPD",
1577 &args, &tmp);
1578 if (ACPI_SUCCESS(status))
1579 status = tmp ? (-EINVAL) : (AE_OK);
1580
1581 return status;
1582}
1583
1da177e4 1584static ssize_t
4be44fcd
LB		 1585acpi_video_bus_write_POST(struct file *file,
1586 const char __user * buffer,
1587 size_t count, loff_t * data)
1da177e4 1588{
4be44fcd 1589 int status;
50dd0969
JE		 1590 struct seq_file *m = file->private_data;
1591 struct acpi_video_bus *video = m->private;
4be44fcd 1592 char str[12] = { 0 };
27663c58 1593 unsigned long long opt, options;
1da177e4 1594
1da177e4 1595
52a2b11c 1596 if (!video || count >= sizeof(str))
d550d98d 1597 return -EINVAL;
1da177e4
LT		 1598
1599 status = acpi_video_bus_POST_options(video, &options);
1600 if (!ACPI_SUCCESS(status))
d550d98d 1601 return -EINVAL;
1da177e4
LT		 1602
1603 if (copy_from_user(str, buffer, count))
d550d98d 1604 return -EFAULT;
1da177e4
LT		 1605
1606 str[count] = 0;
1607 opt = strtoul(str, NULL, 0);
1608 if (opt > 3)
d550d98d 1609 return -EFAULT;
1da177e4 1610
98fb8fe1 1611 /* just in case an OEM 'forgot' the motherboard... */
1da177e4
LT		 1612 options |= 1;
1613
1614 if (options & (1ul << opt)) {
4be44fcd 1615 status = acpi_video_bus_set_POST(video, opt);
1da177e4 1616 if (!ACPI_SUCCESS(status))
d550d98d 1617 return -EFAULT;
1da177e4
LT		 1618
1619 }
1620
d550d98d 1621 return count;
1da177e4
LT		 1622}
1623
1624static ssize_t
4be44fcd
LB		 1625acpi_video_bus_write_DOS(struct file *file,
1626 const char __user * buffer,
1627 size_t count, loff_t * data)
1da177e4 1628{
4be44fcd 1629 int status;
50dd0969
JE		 1630 struct seq_file *m = file->private_data;
1631 struct acpi_video_bus *video = m->private;
4be44fcd
LB		 1632 char str[12] = { 0 };
1633 unsigned long opt;
1da177e4 1634
1da177e4 1635
52a2b11c 1636 if (!video || count >= sizeof(str))
d550d98d 1637 return -EINVAL;
1da177e4
LT		 1638
1639 if (copy_from_user(str, buffer, count))
d550d98d 1640 return -EFAULT;
1da177e4
LT		 1641
1642 str[count] = 0;
1643 opt = strtoul(str, NULL, 0);
1644 if (opt > 7)
d550d98d 1645 return -EFAULT;
1da177e4 1646
4be44fcd 1647 status = acpi_video_bus_DOS(video, opt & 0x3, (opt & 0x4) >> 2);
1da177e4
LT		 1648
1649 if (!ACPI_SUCCESS(status))
d550d98d 1650 return -EFAULT;
1da177e4 1651
d550d98d 1652 return count;
1da177e4
LT		 1653}
1654
4be44fcd 1655static int acpi_video_bus_add_fs(struct acpi_device *device)
1da177e4 1656{
251cb0bc
DT		 1657 struct acpi_video_bus *video = acpi_driver_data(device);
1658 struct proc_dir_entry *device_dir;
1659 struct proc_dir_entry *entry;
1da177e4 1660
251cb0bc
DT		 1661 device_dir = proc_mkdir(acpi_device_bid(device), acpi_video_dir);
1662 if (!device_dir)
1663 return -ENOMEM;
1da177e4 1664
1da177e4 1665 /* 'info' [R] */
e0066c4e 1666 entry = proc_create_data("info", S_IRUGO, device_dir,
cf7acfab
DL		 1667 &acpi_video_bus_info_fops,
1668 acpi_driver_data(device));
1da177e4 1669 if (!entry)
251cb0bc 1670 goto err_remove_dir;
1da177e4
LT		 1671
1672 /* 'ROM' [R] */
e0066c4e 1673 entry = proc_create_data("ROM", S_IRUGO, device_dir,
cf7acfab
DL		 1674 &acpi_video_bus_ROM_fops,
1675 acpi_driver_data(device));
1da177e4 1676 if (!entry)
251cb0bc 1677 goto err_remove_info;
1da177e4
LT		 1678
1679 /* 'POST_info' [R] */
e0066c4e 1680 entry = proc_create_data("POST_info", S_IRUGO, device_dir,
cf7acfab
DL		 1681 &acpi_video_bus_POST_info_fops,
1682 acpi_driver_data(device));
1da177e4 1683 if (!entry)
251cb0bc 1684 goto err_remove_rom;
1da177e4
LT		 1685
1686 /* 'POST' [R/W] */
08acd4f8 1687 entry = proc_create_data("POST", S_IFREG | S_IRUGO | S_IWUSR,
e0066c4e 1688 device_dir,
cf7acfab
DL		 1689 &acpi_video_bus_POST_fops,
1690 acpi_driver_data(device));
1da177e4 1691 if (!entry)
251cb0bc 1692 goto err_remove_post_info;
1da177e4
LT		 1693
1694 /* 'DOS' [R/W] */
08acd4f8 1695 entry = proc_create_data("DOS", S_IFREG | S_IRUGO | S_IWUSR,
e0066c4e 1696 device_dir,
cf7acfab
DL		 1697 &acpi_video_bus_DOS_fops,
1698 acpi_driver_data(device));
1da177e4 1699 if (!entry)
251cb0bc 1700 goto err_remove_post;
1da177e4 1701
251cb0bc 1702 video->dir = acpi_device_dir(device) = device_dir;
d550d98d 1703 return 0;
251cb0bc
DT		 1704
1705 err_remove_post:
1706 remove_proc_entry("POST", device_dir);
1707 err_remove_post_info:
1708 remove_proc_entry("POST_info", device_dir);
1709 err_remove_rom:
1710 remove_proc_entry("ROM", device_dir);
1711 err_remove_info:
1712 remove_proc_entry("info", device_dir);
1713 err_remove_dir:
1714 remove_proc_entry(acpi_device_bid(device), acpi_video_dir);
1715 return -ENOMEM;
1da177e4
LT		 1716}
1717
4be44fcd 1718static int acpi_video_bus_remove_fs(struct acpi_device *device)
1da177e4 1719{
251cb0bc
DT		 1720 struct proc_dir_entry *device_dir = acpi_device_dir(device);
1721
1722 if (device_dir) {
1723 remove_proc_entry("info", device_dir);
1724 remove_proc_entry("ROM", device_dir);
1725 remove_proc_entry("POST_info", device_dir);
1726 remove_proc_entry("POST", device_dir);
1727 remove_proc_entry("DOS", device_dir);
4be44fcd 1728 remove_proc_entry(acpi_device_bid(device), acpi_video_dir);
1da177e4
LT		 1729 acpi_device_dir(device) = NULL;
1730 }
1731
d550d98d 1732 return 0;
1da177e4 1733}
6e37c658
ZR		 1734#else
1735static inline int acpi_video_device_add_fs(struct acpi_device *device)
1736{
1737 return 0;
1738}
1739static inline int acpi_video_device_remove_fs(struct acpi_device *device)
1740{
1741 return 0;
1742}
1743static inline int acpi_video_bus_add_fs(struct acpi_device *device)
1744{
1745 return 0;
1746}
1747static inline int acpi_video_bus_remove_fs(struct acpi_device *device)
1748{
1749 return 0;
1750}
1751#endif /* CONFIG_ACPI_PROCFS */
1da177e4
LT		 1752
1753/* --------------------------------------------------------------------------
1754 Driver Interface
1755 -------------------------------------------------------------------------- */
1756
1757/* device interface */
82cae999
RZ		 1758static struct acpi_video_device_attrib*
1759acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id)
1760{
78eed028
DT		 1761 struct acpi_video_enumerated_device *ids;
1762 int i;
1763
1764 for (i = 0; i < video->attached_count; i++) {
1765 ids = &video->attached_array[i];
1766 if ((ids->value.int_val & 0xffff) == device_id)
1767 return &ids->value.attrib;
1768 }
82cae999 1769
82cae999
RZ		 1770 return NULL;
1771}
1da177e4 1772
e92a7162
MG		 1773static int
1774acpi_video_get_device_type(struct acpi_video_bus *video,
1775 unsigned long device_id)
1776{
1777 struct acpi_video_enumerated_device *ids;
1778 int i;
1779
1780 for (i = 0; i < video->attached_count; i++) {
1781 ids = &video->attached_array[i];
1782 if ((ids->value.int_val & 0xffff) == device_id)
1783 return ids->value.int_val;
1784 }
1785
1786 return 0;
1787}
1788
1da177e4 1789static int
4be44fcd
LB		 1790acpi_video_bus_get_one_device(struct acpi_device *device,
1791 struct acpi_video_bus *video)
1da177e4 1792{
27663c58 1793 unsigned long long device_id;
e92a7162 1794 int status, device_type;
4be44fcd 1795 struct acpi_video_device *data;
82cae999 1796 struct acpi_video_device_attrib* attribute;
1da177e4
LT		 1797
1798 if (!device || !video)
d550d98d 1799 return -EINVAL;
1da177e4 1800
4be44fcd
LB		 1801 status =
1802 acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
1da177e4
LT		 1803 if (ACPI_SUCCESS(status)) {
1804
36bcbec7 1805 data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
1da177e4 1806 if (!data)
d550d98d 1807 return -ENOMEM;
1da177e4 1808
1da177e4
LT		 1809 strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
1810 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
db89b4f0 1811 device->driver_data = data;
1da177e4
LT		 1812
1813 data->device_id = device_id;
1814 data->video = video;
1815 data->dev = device;
1816
82cae999
RZ		 1817 attribute = acpi_video_get_device_attr(video, device_id);
1818
1819 if((attribute != NULL) && attribute->device_id_scheme) {
1820 switch (attribute->display_type) {
1821 case ACPI_VIDEO_DISPLAY_CRT:
1822 data->flags.crt = 1;
1823 break;
1824 case ACPI_VIDEO_DISPLAY_TV:
1825 data->flags.tvout = 1;
1826 break;
1827 case ACPI_VIDEO_DISPLAY_DVI:
1828 data->flags.dvi = 1;
1829 break;
1830 case ACPI_VIDEO_DISPLAY_LCD:
1831 data->flags.lcd = 1;
1832 break;
1833 default:
1834 data->flags.unknown = 1;
1835 break;
1836 }
1837 if(attribute->bios_can_detect)
1838 data->flags.bios = 1;
e92a7162
MG		 1839 } else {
1840 /* Check for legacy IDs */
1841 device_type = acpi_video_get_device_type(video,
1842 device_id);
1843 /* Ignore bits 16 and 18-20 */
1844 switch (device_type & 0xffe2ffff) {
1845 case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR:
1846 data->flags.crt = 1;
1847 break;
1848 case ACPI_VIDEO_DISPLAY_LEGACY_PANEL:
1849 data->flags.lcd = 1;
1850 break;
1851 case ACPI_VIDEO_DISPLAY_LEGACY_TV:
1852 data->flags.tvout = 1;
1853 break;
1854 default:
1855 data->flags.unknown = 1;
1856 }
1857 }
4be44fcd 1858
1da177e4
LT		 1859 acpi_video_device_bind(video, data);
1860 acpi_video_device_find_cap(data);
1861
90130268 1862 status = acpi_install_notify_handler(device->handle,
4be44fcd
LB		 1863 ACPI_DEVICE_NOTIFY,
1864 acpi_video_device_notify,
1865 data);
1da177e4 1866 if (ACPI_FAILURE(status)) {
55ac9a01
LM		 1867 printk(KERN_ERR PREFIX
1868 "Error installing notify handler\n");
973bf491
YL		 1869 if(data->brightness)
1870 kfree(data->brightness->levels);
1871 kfree(data->brightness);
1872 kfree(data);
1873 return -ENODEV;
1da177e4
LT		 1874 }
1875
bbac81f5 1876 mutex_lock(&video->device_list_lock);
1da177e4 1877 list_add_tail(&data->entry, &video->video_device_list);
bbac81f5 1878 mutex_unlock(&video->device_list_lock);
1da177e4
LT		 1879
1880 acpi_video_device_add_fs(device);
1881
d550d98d 1882 return 0;
1da177e4
LT		 1883 }
1884
d550d98d 1885 return -ENOENT;
1da177e4
LT		 1886}
1887
1888/*
1889 * Arg:
1890 * video : video bus device
1891 *
1892 * Return:
1893 * none
1894 *
1895 * Enumerate the video device list of the video bus,
1896 * bind the ids with the corresponding video devices
1897 * under the video bus.
4be44fcd 1898 */
1da177e4 1899
4be44fcd 1900static void acpi_video_device_rebind(struct acpi_video_bus *video)
1da177e4 1901{
ff102ea9
DT		 1902 struct acpi_video_device *dev;
1903
bbac81f5 1904 mutex_lock(&video->device_list_lock);
ff102ea9
DT		 1905
1906 list_for_each_entry(dev, &video->video_device_list, entry)
4be44fcd 1907 acpi_video_device_bind(video, dev);
ff102ea9 1908
bbac81f5 1909 mutex_unlock(&video->device_list_lock);
1da177e4
LT		 1910}
1911
1912/*
1913 * Arg:
1914 * video : video bus device
1915 * device : video output device under the video
1916 * bus
1917 *
1918 * Return:
1919 * none
1920 *
1921 * Bind the ids with the corresponding video devices
1922 * under the video bus.
4be44fcd 1923 */
1da177e4
LT		 1924
1925static void
4be44fcd
LB		 1926acpi_video_device_bind(struct acpi_video_bus *video,
1927 struct acpi_video_device *device)
1da177e4 1928{
78eed028 1929 struct acpi_video_enumerated_device *ids;
4be44fcd 1930 int i;
1da177e4 1931
78eed028
DT		 1932 for (i = 0; i < video->attached_count; i++) {
1933 ids = &video->attached_array[i];
1934 if (device->device_id == (ids->value.int_val & 0xffff)) {
1935 ids->bind_info = device;
1da177e4
LT		 1936 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "device_bind %d\n", i));
1937 }
1938 }
1da177e4
LT		 1939}
1940
1941/*
1942 * Arg:
1943 * video : video bus device
1944 *
1945 * Return:
1946 * < 0 : error
1947 *
1948 * Call _DOD to enumerate all devices attached to display adapter
1949 *
4be44fcd 1950 */
1da177e4
LT		 1951
1952static int acpi_video_device_enumerate(struct acpi_video_bus *video)
1953{
4be44fcd
LB		 1954 int status;
1955 int count;
1956 int i;
78eed028 1957 struct acpi_video_enumerated_device *active_list;
4be44fcd
LB		 1958 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1959 union acpi_object *dod = NULL;
1960 union acpi_object *obj;
1da177e4 1961
90130268 1962 status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
1da177e4 1963 if (!ACPI_SUCCESS(status)) {
a6fc6720 1964 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD"));
d550d98d 1965 return status;
1da177e4
LT		 1966 }
1967
50dd0969 1968 dod = buffer.pointer;
1da177e4 1969 if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
a6fc6720 1970 ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data"));
1da177e4
LT		 1971 status = -EFAULT;
1972 goto out;
1973 }
1974
1975 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d video heads in _DOD\n",
4be44fcd 1976 dod->package.count));
1da177e4 1977
78eed028
DT		 1978 active_list = kcalloc(1 + dod->package.count,
1979 sizeof(struct acpi_video_enumerated_device),
1980 GFP_KERNEL);
1981 if (!active_list) {
1da177e4
LT		 1982 status = -ENOMEM;
1983 goto out;
1984 }
1985
1986 count = 0;
1987 for (i = 0; i < dod->package.count; i++) {
50dd0969 1988 obj = &dod->package.elements[i];
1da177e4
LT		 1989
1990 if (obj->type != ACPI_TYPE_INTEGER) {
78eed028
DT		 1991 printk(KERN_ERR PREFIX
1992 "Invalid _DOD data in element %d\n", i);
1993 continue;
1da177e4 1994 }
78eed028
DT		 1995
1996 active_list[count].value.int_val = obj->integer.value;
1997 active_list[count].bind_info = NULL;
4be44fcd
LB		 1998 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "dod element[%d] = %d\n", i,
1999 (int)obj->integer.value));
1da177e4
LT		 2000 count++;
2001 }
1da177e4 2002
6044ec88 2003 kfree(video->attached_array);
4be44fcd 2004
78eed028 2005 video->attached_array = active_list;
1da177e4 2006 video->attached_count = count;
78eed028
DT		 2007
2008 out:
02438d87 2009 kfree(buffer.pointer);
d550d98d 2010 return status;
1da177e4
LT		 2011}
2012
4be44fcd
LB		 2013static int
2014acpi_video_get_next_level(struct acpi_video_device *device,
2015 u32 level_current, u32 event)
1da177e4 2016{
63f0edfc 2017 int min, max, min_above, max_below, i, l, delta = 255;
f4715189
TT		 2018 max = max_below = 0;
2019 min = min_above = 255;
63f0edfc 2020 /* Find closest level to level_current */
0a3db1ce 2021 for (i = 2; i < device->brightness->count; i++) {
63f0edfc
AS		 2022 l = device->brightness->levels[i];
2023 if (abs(l - level_current) < abs(delta)) {
2024 delta = l - level_current;
2025 if (!delta)
2026 break;
2027 }
2028 }
2029 /* Ajust level_current to closest available level */
2030 level_current += delta;
0a3db1ce 2031 for (i = 2; i < device->brightness->count; i++) {
f4715189
TT		 2032 l = device->brightness->levels[i];
2033 if (l < min)
2034 min = l;
2035 if (l > max)
2036 max = l;
2037 if (l < min_above && l > level_current)
2038 min_above = l;
2039 if (l > max_below && l < level_current)
2040 max_below = l;
2041 }
2042
2043 switch (event) {
2044 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:
2045 return (level_current < max) ? min_above : min;
2046 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:
2047 return (level_current < max) ? min_above : max;
2048 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:
2049 return (level_current > min) ? max_below : min;
2050 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:
2051 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:
2052 return 0;
2053 default:
2054 return level_current;
2055 }
1da177e4
LT		 2056}
2057
c8890f90 2058static int
4be44fcd 2059acpi_video_switch_brightness(struct acpi_video_device *device, int event)
1da177e4 2060{
27663c58 2061 unsigned long long level_current, level_next;
c8890f90
ZR		 2062 int result = -EINVAL;
2063
28c32e99
ZR		 2064 /* no warning message if acpi_backlight=vendor is used */
2065 if (!acpi_video_backlight_support())
2066 return 0;
2067
469778c1 2068 if (!device->brightness)
c8890f90
ZR		 2069 goto out;
2070
2071 result = acpi_video_device_lcd_get_level_current(device,
70287db8 2072 &level_current, 0);
c8890f90
ZR		 2073 if (result)
2074 goto out;
2075
1da177e4 2076 level_next = acpi_video_get_next_level(device, level_current, event);
c8890f90 2077
24450c7a 2078 result = acpi_video_device_lcd_set_level(device, level_next);
c8890f90 2079
36342742
MG		 2080 if (!result)
2081 backlight_force_update(device->backlight,
2082 BACKLIGHT_UPDATE_HOTKEY);
2083
c8890f90
ZR		 2084out:
2085 if (result)
2086 printk(KERN_ERR PREFIX "Failed to switch the brightness\n");
2087
2088 return result;
1da177e4
LT		 2089}
2090
e92a7162
MG		 2091int acpi_video_get_edid(struct acpi_device *device, int type, int device_id,
2092 void **edid)
2093{
2094 struct acpi_video_bus *video;
2095 struct acpi_video_device *video_device;
2096 union acpi_object *buffer = NULL;
2097 acpi_status status;
2098 int i, length;
2099
2100 if (!device || !acpi_driver_data(device))
2101 return -EINVAL;
2102
2103 video = acpi_driver_data(device);
2104
2105 for (i = 0; i < video->attached_count; i++) {
2106 video_device = video->attached_array[i].bind_info;
2107 length = 256;
2108
2109 if (!video_device)
2110 continue;
2111
2112 if (type) {
2113 switch (type) {
2114 case ACPI_VIDEO_DISPLAY_CRT:
2115 if (!video_device->flags.crt)
2116 continue;
2117 break;
2118 case ACPI_VIDEO_DISPLAY_TV:
2119 if (!video_device->flags.tvout)
2120 continue;
2121 break;
2122 case ACPI_VIDEO_DISPLAY_DVI:
2123 if (!video_device->flags.dvi)
2124 continue;
2125 break;
2126 case ACPI_VIDEO_DISPLAY_LCD:
2127 if (!video_device->flags.lcd)
2128 continue;
2129 break;
2130 }
2131 } else if (video_device->device_id != device_id) {
2132 continue;
2133 }
2134
2135 status = acpi_video_device_EDID(video_device, &buffer, length);
2136
2137 if (ACPI_FAILURE(status) || !buffer ||
2138 buffer->type != ACPI_TYPE_BUFFER) {
2139 length = 128;
2140 status = acpi_video_device_EDID(video_device, &buffer,
2141 length);
2142 if (ACPI_FAILURE(status) || !buffer ||
2143 buffer->type != ACPI_TYPE_BUFFER) {
2144 continue;
2145 }
2146 }
2147
2148 *edid = buffer->buffer.pointer;
2149 return length;
2150 }
2151
2152 return -ENODEV;
2153}
2154EXPORT_SYMBOL(acpi_video_get_edid);
2155
1da177e4 2156static int
4be44fcd
LB		 2157acpi_video_bus_get_devices(struct acpi_video_bus *video,
2158 struct acpi_device *device)
1da177e4 2159{
4be44fcd 2160 int status = 0;
ff102ea9 2161 struct acpi_device *dev;
1da177e4
LT		 2162
2163 acpi_video_device_enumerate(video);
2164
ff102ea9 2165 list_for_each_entry(dev, &device->children, node) {
1da177e4
LT		 2166
2167 status = acpi_video_bus_get_one_device(dev, video);
2168 if (ACPI_FAILURE(status)) {
55ac9a01 2169 printk(KERN_WARNING PREFIX
cfa806f0 2170 "Cant attach device\n");
1da177e4
LT		 2171 continue;
2172 }
1da177e4 2173 }
d550d98d 2174 return status;
1da177e4
LT		 2175}
2176
4be44fcd 2177static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
1da177e4 2178{
031ec77b 2179 acpi_status status;
1da177e4
LT		 2180
2181 if (!device || !device->video)
d550d98d 2182 return -ENOENT;
1da177e4 2183
1da177e4
LT		 2184 acpi_video_device_remove_fs(device->dev);
2185
90130268 2186 status = acpi_remove_notify_handler(device->dev->handle,
4be44fcd
LB		 2187 ACPI_DEVICE_NOTIFY,
2188 acpi_video_device_notify);
cfa806f0
AK		 2189 if (ACPI_FAILURE(status)) {
2190 printk(KERN_WARNING PREFIX
2191 "Cant remove video notify handler\n");
2192 }
e29b3ee3
KP		 2193 if (device->backlight) {
2194 sysfs_remove_link(&device->backlight->dev.kobj, "device");
2195 backlight_device_unregister(device->backlight);
2196 device->backlight = NULL;
2197 }
4a703a8f 2198 if (device->cooling_dev) {
702ed512
ZR		 2199 sysfs_remove_link(&device->dev->dev.kobj,
2200 "thermal_cooling");
4a703a8f 2201 sysfs_remove_link(&device->cooling_dev->device.kobj,
702ed512 2202 "device");
4a703a8f
DT		 2203 thermal_cooling_device_unregister(device->cooling_dev);
2204 device->cooling_dev = NULL;
702ed512 2205 }
23b0f015 2206 video_output_unregister(device->output_dev);
ff102ea9 2207
d550d98d 2208 return 0;
1da177e4
LT		 2209}
2210
4be44fcd 2211static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
1da177e4 2212{
4be44fcd 2213 int status;
ff102ea9 2214 struct acpi_video_device *dev, *next;
1da177e4 2215
bbac81f5 2216 mutex_lock(&video->device_list_lock);
1da177e4 2217
ff102ea9 2218 list_for_each_entry_safe(dev, next, &video->video_device_list, entry) {
1da177e4 2219
ff102ea9 2220 status = acpi_video_bus_put_one_device(dev);
4be44fcd
LB		 2221 if (ACPI_FAILURE(status))
2222 printk(KERN_WARNING PREFIX
2223 "hhuuhhuu bug in acpi video driver.\n");
1da177e4 2224
ff102ea9
DT		 2225 if (dev->brightness) {
2226 kfree(dev->brightness->levels);
2227 kfree(dev->brightness);
2228 }
2229 list_del(&dev->entry);
2230 kfree(dev);
1da177e4
LT		 2231 }
2232
bbac81f5 2233 mutex_unlock(&video->device_list_lock);
ff102ea9 2234
d550d98d 2235 return 0;
1da177e4
LT		 2236}
2237
2238/* acpi_video interface */
2239
4be44fcd 2240static int acpi_video_bus_start_devices(struct acpi_video_bus *video)
1da177e4 2241{
a21101c4 2242 return acpi_video_bus_DOS(video, 0, 0);
1da177e4
LT		 2243}
2244
4be44fcd 2245static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
1da177e4
LT		 2246{
2247 return acpi_video_bus_DOS(video, 0, 1);
2248}
2249
7015558f 2250static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
1da177e4 2251{
7015558f 2252 struct acpi_video_bus *video = acpi_driver_data(device);
e9dab196 2253 struct input_dev *input;
17c452f9 2254 int keycode = 0;
e9dab196 2255
1da177e4 2256 if (!video)
d550d98d 2257 return;
1da177e4 2258
e9dab196 2259 input = video->input;
1da177e4
LT		 2260
2261 switch (event) {
98fb8fe1 2262 case ACPI_VIDEO_NOTIFY_SWITCH: /* User requested a switch,
1da177e4 2263 * most likely via hotkey. */
14e04fb3 2264 acpi_bus_generate_proc_event(device, event, 0);
e9dab196 2265 keycode = KEY_SWITCHVIDEOMODE;
1da177e4
LT		 2266 break;
2267
98fb8fe1 2268 case ACPI_VIDEO_NOTIFY_PROBE: /* User plugged in or removed a video
1da177e4
LT		 2269 * connector. */
2270 acpi_video_device_enumerate(video);
2271 acpi_video_device_rebind(video);
14e04fb3 2272 acpi_bus_generate_proc_event(device, event, 0);
e9dab196 2273 keycode = KEY_SWITCHVIDEOMODE;
1da177e4
LT		 2274 break;
2275
4be44fcd 2276 case ACPI_VIDEO_NOTIFY_CYCLE: /* Cycle Display output hotkey pressed. */
25c87f7f 2277 acpi_bus_generate_proc_event(device, event, 0);
e9dab196
LY		 2278 keycode = KEY_SWITCHVIDEOMODE;
2279 break;
4be44fcd 2280 case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT: /* Next Display output hotkey pressed. */
25c87f7f 2281 acpi_bus_generate_proc_event(device, event, 0);
e9dab196
LY		 2282 keycode = KEY_VIDEO_NEXT;
2283 break;
4be44fcd 2284 case ACPI_VIDEO_NOTIFY_PREV_OUTPUT: /* previous Display output hotkey pressed. */
14e04fb3 2285 acpi_bus_generate_proc_event(device, event, 0);
e9dab196 2286 keycode = KEY_VIDEO_PREV;
1da177e4
LT		 2287 break;
2288
2289 default:
2290 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
4be44fcd 2291 "Unsupported event [0x%x]\n", event));
1da177e4
LT		 2292 break;
2293 }
2294
7761f638 2295 acpi_notifier_call_chain(device, event, 0);
17c452f9
MG		 2296
2297 if (keycode) {
2298 input_report_key(input, keycode, 1);
2299 input_sync(input);
2300 input_report_key(input, keycode, 0);
2301 input_sync(input);
2302 }
e9dab196 2303
d550d98d 2304 return;
1da177e4
LT		 2305}
2306
4be44fcd 2307static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
1da177e4 2308{
50dd0969 2309 struct acpi_video_device *video_device = data;
4be44fcd 2310 struct acpi_device *device = NULL;
e9dab196
LY		 2311 struct acpi_video_bus *bus;
2312 struct input_dev *input;
17c452f9 2313 int keycode = 0;
1da177e4 2314
1da177e4 2315 if (!video_device)
d550d98d 2316 return;
1da177e4 2317
e6afa0de 2318 device = video_device->dev;
e9dab196
LY		 2319 bus = video_device->video;
2320 input = bus->input;
1da177e4
LT		 2321
2322 switch (event) {
4be44fcd 2323 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: /* Cycle brightness */
8a681a4d
ZR		 2324 if (brightness_switch_enabled)
2325 acpi_video_switch_brightness(video_device, event);
14e04fb3 2326 acpi_bus_generate_proc_event(device, event, 0);
e9dab196
LY		 2327 keycode = KEY_BRIGHTNESS_CYCLE;
2328 break;
4be44fcd 2329 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: /* Increase brightness */
8a681a4d
ZR		 2330 if (brightness_switch_enabled)
2331 acpi_video_switch_brightness(video_device, event);
25c87f7f 2332 acpi_bus_generate_proc_event(device, event, 0);
e9dab196
LY		 2333 keycode = KEY_BRIGHTNESSUP;
2334 break;
4be44fcd 2335 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: /* Decrease brightness */
8a681a4d
ZR		 2336 if (brightness_switch_enabled)
2337 acpi_video_switch_brightness(video_device, event);
25c87f7f 2338 acpi_bus_generate_proc_event(device, event, 0);
e9dab196
LY		 2339 keycode = KEY_BRIGHTNESSDOWN;
2340 break;
4be44fcd 2341 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightnesss */
8a681a4d
ZR		 2342 if (brightness_switch_enabled)
2343 acpi_video_switch_brightness(video_device, event);
25c87f7f 2344 acpi_bus_generate_proc_event(device, event, 0);
e9dab196
LY		 2345 keycode = KEY_BRIGHTNESS_ZERO;
2346 break;
4be44fcd 2347 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: /* display device off */
8a681a4d
ZR		 2348 if (brightness_switch_enabled)
2349 acpi_video_switch_brightness(video_device, event);
14e04fb3 2350 acpi_bus_generate_proc_event(device, event, 0);
e9dab196 2351 keycode = KEY_DISPLAY_OFF;
1da177e4
LT		 2352 break;
2353 default:
2354 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
4be44fcd 2355 "Unsupported event [0x%x]\n", event));
1da177e4
LT		 2356 break;
2357 }
e9dab196 2358
7761f638 2359 acpi_notifier_call_chain(device, event, 0);
17c452f9
MG		 2360
2361 if (keycode) {
2362 input_report_key(input, keycode, 1);
2363 input_sync(input);
2364 input_report_key(input, keycode, 0);
2365 input_sync(input);
2366 }
e9dab196 2367
d550d98d 2368 return;
1da177e4
LT		 2369}
2370
ac7729da
RW		 2371static int acpi_video_resume(struct notifier_block *nb,
2372 unsigned long val, void *ign)
863c1490
MG		 2373{
2374 struct acpi_video_bus *video;
2375 struct acpi_video_device *video_device;
2376 int i;
2377
ac7729da
RW		 2378 switch (val) {
2379 case PM_HIBERNATION_PREPARE:
2380 case PM_SUSPEND_PREPARE:
2381 case PM_RESTORE_PREPARE:
2382 return NOTIFY_DONE;
2383 }
863c1490 2384
ac7729da
RW		 2385 video = container_of(nb, struct acpi_video_bus, pm_nb);
2386
2387 dev_info(&video->device->dev, "Restoring backlight state\n");
863c1490
MG		 2388
2389 for (i = 0; i < video->attached_count; i++) {
2390 video_device = video->attached_array[i].bind_info;
2391 if (video_device && video_device->backlight)
2392 acpi_video_set_brightness(video_device->backlight);
2393 }
ac7729da
RW		 2394
2395 return NOTIFY_OK;
863c1490
MG		 2396}
2397
c504f8cb
ZR		 2398static acpi_status
2399acpi_video_bus_match(acpi_handle handle, u32 level, void *context,
2400 void **return_value)
2401{
2402 struct acpi_device *device = context;
2403 struct acpi_device *sibling;
2404 int result;
2405
2406 if (handle == device->handle)
2407 return AE_CTRL_TERMINATE;
2408
2409 result = acpi_bus_get_device(handle, &sibling);
2410 if (result)
2411 return AE_OK;
2412
2413 if (!strcmp(acpi_device_name(sibling), ACPI_VIDEO_BUS_NAME))
2414 return AE_ALREADY_EXISTS;
2415
2416 return AE_OK;
2417}
2418
ac7729da
RW		 2419static int instance;
2420
4be44fcd 2421static int acpi_video_bus_add(struct acpi_device *device)
1da177e4 2422{
f51e8391 2423 struct acpi_video_bus *video;
e9dab196 2424 struct input_dev *input;
f51e8391 2425 int error;
c504f8cb
ZR		 2426 acpi_status status;
2427
2428 status = acpi_walk_namespace(ACPI_TYPE_DEVICE,
2429 device->parent->handle, 1,
2430 acpi_video_bus_match, NULL,
2431 device, NULL);
2432 if (status == AE_ALREADY_EXISTS) {
2433 printk(KERN_WARNING FW_BUG
2434 "Duplicate ACPI video bus devices for the"
2435 " same VGA controller, please try module "
2436 "parameter \"video.allow_duplicates=1\""
2437 "if the current driver doesn't work.\n");
2438 if (!allow_duplicates)
2439 return -ENODEV;
2440 }
1da177e4 2441
36bcbec7 2442 video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
1da177e4 2443 if (!video)
d550d98d 2444 return -ENOMEM;
1da177e4 2445
e6d9da1d
ZR		 2446 /* a hack to fix the duplicate name "VID" problem on T61 */
2447 if (!strcmp(device->pnp.bus_id, "VID")) {
2448 if (instance)
2449 device->pnp.bus_id[3] = '0' + instance;
2450 instance ++;
2451 }
f3b39f13
ZY		 2452 /* a hack to fix the duplicate name "VGA" problem on Pa 3553 */
2453 if (!strcmp(device->pnp.bus_id, "VGA")) {
2454 if (instance)
2455 device->pnp.bus_id[3] = '0' + instance;
2456 instance++;
2457 }
e6d9da1d 2458
e6afa0de 2459 video->device = device;
1da177e4
LT		 2460 strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
2461 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
db89b4f0 2462 device->driver_data = video;
1da177e4
LT		 2463
2464 acpi_video_bus_find_cap(video);
f51e8391
DT		 2465 error = acpi_video_bus_check(video);
2466 if (error)
2467 goto err_free_video;
1da177e4 2468
f51e8391
DT		 2469 error = acpi_video_bus_add_fs(device);
2470 if (error)
2471 goto err_free_video;
1da177e4 2472
bbac81f5 2473 mutex_init(&video->device_list_lock);
1da177e4
LT		 2474 INIT_LIST_HEAD(&video->video_device_list);
2475
2476 acpi_video_bus_get_devices(video, device);
2477 acpi_video_bus_start_devices(video);
2478
e9dab196 2479 video->input = input = input_allocate_device();
f51e8391
DT		 2480 if (!input) {
2481 error = -ENOMEM;
7015558f 2482 goto err_stop_video;
f51e8391 2483 }
e9dab196
LY		 2484
2485 snprintf(video->phys, sizeof(video->phys),
2486 "%s/video/input0", acpi_device_hid(video->device));
2487
2488 input->name = acpi_device_name(video->device);
2489 input->phys = video->phys;
2490 input->id.bustype = BUS_HOST;
2491 input->id.product = 0x06;
91c05c66 2492 input->dev.parent = &device->dev;
e9dab196
LY		 2493 input->evbit[0] = BIT(EV_KEY);
2494 set_bit(KEY_SWITCHVIDEOMODE, input->keybit);
2495 set_bit(KEY_VIDEO_NEXT, input->keybit);
2496 set_bit(KEY_VIDEO_PREV, input->keybit);
2497 set_bit(KEY_BRIGHTNESS_CYCLE, input->keybit);
2498 set_bit(KEY_BRIGHTNESSUP, input->keybit);
2499 set_bit(KEY_BRIGHTNESSDOWN, input->keybit);
2500 set_bit(KEY_BRIGHTNESS_ZERO, input->keybit);
2501 set_bit(KEY_DISPLAY_OFF, input->keybit);
e9dab196 2502
f51e8391
DT		 2503 error = input_register_device(input);
2504 if (error)
2505 goto err_free_input_dev;
e9dab196 2506
1da177e4 2507 printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s rom: %s post: %s)\n",
4be44fcd
LB		 2508 ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
2509 video->flags.multihead ? "yes" : "no",
2510 video->flags.rom ? "yes" : "no",
2511 video->flags.post ? "yes" : "no");
1da177e4 2512
ac7729da
RW		 2513 video->pm_nb.notifier_call = acpi_video_resume;
2514 video->pm_nb.priority = 0;
2515 register_pm_notifier(&video->pm_nb);
2516
f51e8391
DT		 2517 return 0;
2518
2519 err_free_input_dev:
2520 input_free_device(input);
f51e8391
DT		 2521 err_stop_video:
2522 acpi_video_bus_stop_devices(video);
2523 acpi_video_bus_put_devices(video);
2524 kfree(video->attached_array);
2525 acpi_video_bus_remove_fs(device);
2526 err_free_video:
2527 kfree(video);
db89b4f0 2528 device->driver_data = NULL;
1da177e4 2529
f51e8391 2530 return error;
1da177e4
LT		 2531}
2532
4be44fcd 2533static int acpi_video_bus_remove(struct acpi_device *device, int type)
1da177e4 2534{
4be44fcd 2535 struct acpi_video_bus *video = NULL;
1da177e4 2536
1da177e4
LT		 2537
2538 if (!device || !acpi_driver_data(device))
d550d98d 2539 return -EINVAL;
1da177e4 2540
50dd0969 2541 video = acpi_driver_data(device);
1da177e4 2542
ac7729da
RW		 2543 unregister_pm_notifier(&video->pm_nb);
2544
1da177e4 2545 acpi_video_bus_stop_devices(video);
1da177e4
LT		 2546 acpi_video_bus_put_devices(video);
2547 acpi_video_bus_remove_fs(device);
2548
e9dab196 2549 input_unregister_device(video->input);
6044ec88 2550 kfree(video->attached_array);
1da177e4
LT		 2551 kfree(video);
2552
d550d98d 2553 return 0;
1da177e4
LT		 2554}
2555
74a365b3
MG		 2556static int __init intel_opregion_present(void)
2557{
2558#if defined(CONFIG_DRM_I915) || defined(CONFIG_DRM_I915_MODULE)
2559 struct pci_dev *dev = NULL;
2560 u32 address;
2561
2562 for_each_pci_dev(dev) {
2563 if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
2564 continue;
2565 if (dev->vendor != PCI_VENDOR_ID_INTEL)
2566 continue;
2567 pci_read_config_dword(dev, 0xfc, &address);
2568 if (!address)
2569 continue;
2570 return 1;
2571 }
2572#endif
2573 return 0;
2574}
2575
2576int acpi_video_register(void)
1da177e4 2577{
4be44fcd 2578 int result = 0;
86e437f0
ZY		 2579 if (register_count) {
2580 /*
2581 * if the function of acpi_video_register is already called,
2582 * don't register the acpi_vide_bus again and return no error.
2583 */
2584 return 0;
2585 }
1da177e4 2586
6e37c658 2587#ifdef CONFIG_ACPI_PROCFS
1da177e4
LT		 2588 acpi_video_dir = proc_mkdir(ACPI_VIDEO_CLASS, acpi_root_dir);
2589 if (!acpi_video_dir)
d550d98d 2590 return -ENODEV;
6e37c658 2591#endif
1da177e4
LT		 2592
2593 result = acpi_bus_register_driver(&acpi_video_bus);
2594 if (result < 0) {
2595 remove_proc_entry(ACPI_VIDEO_CLASS, acpi_root_dir);
d550d98d 2596 return -ENODEV;
1da177e4
LT		 2597 }
2598
86e437f0
ZY		 2599 /*
2600 * When the acpi_video_bus is loaded successfully, increase
2601 * the counter reference.
2602 */
2603 register_count = 1;
2604
d550d98d 2605 return 0;
1da177e4 2606}
74a365b3
MG		 2607EXPORT_SYMBOL(acpi_video_register);
2608
86e437f0
ZY		 2609void acpi_video_unregister(void)
2610{
2611 if (!register_count) {
2612 /*
2613 * If the acpi video bus is already unloaded, don't
2614 * unload it again and return directly.
2615 */
2616 return;
2617 }
2618 acpi_bus_unregister_driver(&acpi_video_bus);
2619
6e37c658 2620#ifdef CONFIG_ACPI_PROCFS
86e437f0 2621 remove_proc_entry(ACPI_VIDEO_CLASS, acpi_root_dir);
6e37c658 2622#endif
86e437f0
ZY		 2623
2624 register_count = 0;
2625
2626 return;
2627}
2628EXPORT_SYMBOL(acpi_video_unregister);
2629
74a365b3
MG		 2630/*
2631 * This is kind of nasty. Hardware using Intel chipsets may require
2632 * the video opregion code to be run first in order to initialise
2633 * state before any ACPI video calls are made. To handle this we defer
2634 * registration of the video class until the opregion code has run.
2635 */
2636
2637static int __init acpi_video_init(void)
2638{
45cb50e6
ZR		 2639 dmi_check_system(video_dmi_table);
2640
74a365b3
MG		 2641 if (intel_opregion_present())
2642 return 0;
2643
2644 return acpi_video_register();
2645}
1da177e4 2646
86e437f0 2647static void __exit acpi_video_exit(void)
1da177e4 2648{
86e437f0 2649 acpi_video_unregister();
1da177e4 2650
d550d98d 2651 return;
1da177e4
LT		 2652}
2653
2654module_init(acpi_video_init);
2655module_exit(acpi_video_exit);
kernel source for telekom puls (alcatel/mediatek)