?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'cleancache/linux-next'
[linux-2.6/next.git] / drivers / acpi / video.c
blobec574fc8fbc6028089eea27ab90695c4accf794c
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>
6 * Copyright (C) 2006 Thomas Tuttle <linux-kernel@ttuttle.net>
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>
32 #include <linux/mutex.h>
33 #include <linux/input.h>
34 #include <linux/backlight.h>
35 #include <linux/thermal.h>
36 #include <linux/sort.h>
37 #include <linux/pci.h>
38 #include <linux/pci_ids.h>
39 #include <linux/slab.h>
40 #include <asm/uaccess.h>
41 #include <linux/dmi.h>
42 #include <acpi/acpi_bus.h>
43 #include <acpi/acpi_drivers.h>
44 #include <linux/suspend.h>
45 #include <acpi/video.h>
46
47 #define PREFIX "ACPI: "
48
49 #define ACPI_VIDEO_CLASS "video"
50 #define ACPI_VIDEO_BUS_NAME "Video Bus"
51 #define ACPI_VIDEO_DEVICE_NAME "Video Device"
52 #define ACPI_VIDEO_NOTIFY_SWITCH 0x80
53 #define ACPI_VIDEO_NOTIFY_PROBE 0x81
54 #define ACPI_VIDEO_NOTIFY_CYCLE 0x82
55 #define ACPI_VIDEO_NOTIFY_NEXT_OUTPUT 0x83
56 #define ACPI_VIDEO_NOTIFY_PREV_OUTPUT 0x84
57
58 #define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS 0x85
59 #define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS 0x86
60 #define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS 0x87
61 #define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS 0x88
62 #define ACPI_VIDEO_NOTIFY_DISPLAY_OFF 0x89
63
64 #define MAX_NAME_LEN 20
65
66 #define _COMPONENT ACPI_VIDEO_COMPONENT
67 ACPI_MODULE_NAME("video");
68
69 MODULE_AUTHOR("Bruno Ducrot");
70 MODULE_DESCRIPTION("ACPI Video Driver");
71 MODULE_LICENSE("GPL");
72
73 static int brightness_switch_enabled = 1;
74 module_param(brightness_switch_enabled, bool, 0644);
75
76 /*
77 * By default, we don't allow duplicate ACPI video bus devices
78 * under the same VGA controller
79 */
80 static int allow_duplicates;
81 module_param(allow_duplicates, bool, 0644);
82
83 /*
84 * Some BIOSes claim they use minimum backlight at boot,
85 * and this may bring dimming screen after boot
86 */
87 static int use_bios_initial_backlight = 1;
88 module_param(use_bios_initial_backlight, bool, 0644);
89
90 static int register_count = 0;
91 static int acpi_video_bus_add(struct acpi_device *device);
92 static int acpi_video_bus_remove(struct acpi_device *device, int type);
93 static void acpi_video_bus_notify(struct acpi_device *device, u32 event);
94
95 static const struct acpi_device_id video_device_ids[] = {
96 {ACPI_VIDEO_HID, 0},
97 {"", 0},
98 };
99 MODULE_DEVICE_TABLE(acpi, video_device_ids);
100
101 static struct acpi_driver acpi_video_bus = {
102 .name = "video",
103 .class = ACPI_VIDEO_CLASS,
104 .ids = video_device_ids,
105 .ops = {
106 .add = acpi_video_bus_add,
107 .remove = acpi_video_bus_remove,
108 .notify = acpi_video_bus_notify,
109 },
110 };
111
112 struct acpi_video_bus_flags {
113 u8 multihead:1; /* can switch video heads */
114 u8 rom:1; /* can retrieve a video rom */
115 u8 post:1; /* can configure the head to */
116 u8 reserved:5;
117 };
118
119 struct acpi_video_bus_cap {
120 u8 _DOS:1; /*Enable/Disable output switching */
121 u8 _DOD:1; /*Enumerate all devices attached to display adapter */
122 u8 _ROM:1; /*Get ROM Data */
123 u8 _GPD:1; /*Get POST Device */
124 u8 _SPD:1; /*Set POST Device */
125 u8 _VPO:1; /*Video POST Options */
126 u8 reserved:2;
127 };
128
129 struct acpi_video_device_attrib {
130 u32 display_index:4; /* A zero-based instance of the Display */
131 u32 display_port_attachment:4; /*This field differentiates the display type */
132 u32 display_type:4; /*Describe the specific type in use */
133 u32 vendor_specific:4; /*Chipset Vendor Specific */
134 u32 bios_can_detect:1; /*BIOS can detect the device */
135 u32 depend_on_vga:1; /*Non-VGA output device whose power is related to
136 the VGA device. */
137 u32 pipe_id:3; /*For VGA multiple-head devices. */
138 u32 reserved:10; /*Must be 0 */
139 u32 device_id_scheme:1; /*Device ID Scheme */
140 };
141
142 struct acpi_video_enumerated_device {
143 union {
144 u32 int_val;
145 struct acpi_video_device_attrib attrib;
146 } value;
147 struct acpi_video_device *bind_info;
148 };
149
150 struct acpi_video_bus {
151 struct acpi_device *device;
152 u8 dos_setting;
153 struct acpi_video_enumerated_device *attached_array;
154 u8 attached_count;
155 struct acpi_video_bus_cap cap;
156 struct acpi_video_bus_flags flags;
157 struct list_head video_device_list;
158 struct mutex device_list_lock; /* protects video_device_list */
159 struct input_dev *input;
160 char phys[32]; /* for input device */
161 struct notifier_block pm_nb;
162 };
163
164 struct acpi_video_device_flags {
165 u8 crt:1;
166 u8 lcd:1;
167 u8 tvout:1;
168 u8 dvi:1;
169 u8 bios:1;
170 u8 unknown:1;
171 u8 reserved:2;
172 };
173
174 struct acpi_video_device_cap {
175 u8 _ADR:1; /*Return the unique ID */
176 u8 _BCL:1; /*Query list of brightness control levels supported */
177 u8 _BCM:1; /*Set the brightness level */
178 u8 _BQC:1; /* Get current brightness level */
179 u8 _BCQ:1; /* Some buggy BIOS uses _BCQ instead of _BQC */
180 u8 _DDC:1; /*Return the EDID for this device */
181 };
182
183 struct acpi_video_brightness_flags {
184 u8 _BCL_no_ac_battery_levels:1; /* no AC/Battery levels in _BCL */
185 u8 _BCL_reversed:1; /* _BCL package is in a reversed order*/
186 u8 _BCL_use_index:1; /* levels in _BCL are index values */
187 u8 _BCM_use_index:1; /* input of _BCM is an index value */
188 u8 _BQC_use_index:1; /* _BQC returns an index value */
189 };
190
191 struct acpi_video_device_brightness {
192 int curr;
193 int count;
194 int *levels;
195 struct acpi_video_brightness_flags flags;
196 };
197
198 struct acpi_video_device {
199 unsigned long device_id;
200 struct acpi_video_device_flags flags;
201 struct acpi_video_device_cap cap;
202 struct list_head entry;
203 struct acpi_video_bus *video;
204 struct acpi_device *dev;
205 struct acpi_video_device_brightness *brightness;
206 struct backlight_device *backlight;
207 struct thermal_cooling_device *cooling_dev;
208 };
209
210 static const char device_decode[][30] = {
211 "motherboard VGA device",
212 "PCI VGA device",
213 "AGP VGA device",
214 "UNKNOWN",
215 };
216
217 static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data);
218 static void acpi_video_device_rebind(struct acpi_video_bus *video);
219 static void acpi_video_device_bind(struct acpi_video_bus *video,
220 struct acpi_video_device *device);
221 static int acpi_video_device_enumerate(struct acpi_video_bus *video);
222 static int acpi_video_device_lcd_set_level(struct acpi_video_device *device,
223 int level);
224 static int acpi_video_device_lcd_get_level_current(
225 struct acpi_video_device *device,
226 unsigned long long *level, int init);
227 static int acpi_video_get_next_level(struct acpi_video_device *device,
228 u32 level_current, u32 event);
229 static int acpi_video_switch_brightness(struct acpi_video_device *device,
230 int event);
231
232 /*backlight device sysfs support*/
233 static int acpi_video_get_brightness(struct backlight_device *bd)
234 {
235 unsigned long long cur_level;
236 int i;
237 struct acpi_video_device *vd =
238 (struct acpi_video_device *)bl_get_data(bd);
239
240 if (acpi_video_device_lcd_get_level_current(vd, &cur_level, 0))
241 return -EINVAL;
242 for (i = 2; i < vd->brightness->count; i++) {
243 if (vd->brightness->levels[i] == cur_level)
244 /* The first two entries are special - see page 575
245 of the ACPI spec 3.0 */
246 return i-2;
247 }
248 return 0;
249 }
250
251 static int acpi_video_set_brightness(struct backlight_device *bd)
252 {
253 int request_level = bd->props.brightness + 2;
254 struct acpi_video_device *vd =
255 (struct acpi_video_device *)bl_get_data(bd);
256
257 return acpi_video_device_lcd_set_level(vd,
258 vd->brightness->levels[request_level]);
259 }
260
261 static const struct backlight_ops acpi_backlight_ops = {
262 .get_brightness = acpi_video_get_brightness,
263 .update_status = acpi_video_set_brightness,
264 };
265
266 /* thermal cooling device callbacks */
267 static int video_get_max_state(struct thermal_cooling_device *cooling_dev, unsigned
268 long *state)
269 {
270 struct acpi_device *device = cooling_dev->devdata;
271 struct acpi_video_device *video = acpi_driver_data(device);
272
273 *state = video->brightness->count - 3;
274 return 0;
275 }
276
277 static int video_get_cur_state(struct thermal_cooling_device *cooling_dev, unsigned
278 long *state)
279 {
280 struct acpi_device *device = cooling_dev->devdata;
281 struct acpi_video_device *video = acpi_driver_data(device);
282 unsigned long long level;
283 int offset;
284
285 if (acpi_video_device_lcd_get_level_current(video, &level, 0))
286 return -EINVAL;
287 for (offset = 2; offset < video->brightness->count; offset++)
288 if (level == video->brightness->levels[offset]) {
289 *state = video->brightness->count - offset - 1;
290 return 0;
291 }
292
293 return -EINVAL;
294 }
295
296 static int
297 video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long state)
298 {
299 struct acpi_device *device = cooling_dev->devdata;
300 struct acpi_video_device *video = acpi_driver_data(device);
301 int level;
302
303 if ( state >= video->brightness->count - 2)
304 return -EINVAL;
305
306 state = video->brightness->count - state;
307 level = video->brightness->levels[state -1];
308 return acpi_video_device_lcd_set_level(video, level);
309 }
310
311 static struct thermal_cooling_device_ops video_cooling_ops = {
312 .get_max_state = video_get_max_state,
313 .get_cur_state = video_get_cur_state,
314 .set_cur_state = video_set_cur_state,
315 };
316
317 /* --------------------------------------------------------------------------
318 Video Management
319 -------------------------------------------------------------------------- */
320
321 static int
322 acpi_video_device_lcd_query_levels(struct acpi_video_device *device,
323 union acpi_object **levels)
324 {
325 int status;
326 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
327 union acpi_object *obj;
328
329
330 *levels = NULL;
331
332 status = acpi_evaluate_object(device->dev->handle, "_BCL", NULL, &buffer);
333 if (!ACPI_SUCCESS(status))
334 return status;
335 obj = (union acpi_object *)buffer.pointer;
336 if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
337 printk(KERN_ERR PREFIX "Invalid _BCL data\n");
338 status = -EFAULT;
339 goto err;
340 }
341
342 *levels = obj;
343
344 return 0;
345
346 err:
347 kfree(buffer.pointer);
348
349 return status;
350 }
351
352 static int
353 acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level)
354 {
355 int status;
356 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
357 struct acpi_object_list args = { 1, &arg0 };
358 int state;
359
360 arg0.integer.value = level;
361
362 status = acpi_evaluate_object(device->dev->handle, "_BCM",
363 &args, NULL);
364 if (ACPI_FAILURE(status)) {
365 ACPI_ERROR((AE_INFO, "Evaluating _BCM failed"));
366 return -EIO;
367 }
368
369 device->brightness->curr = level;
370 for (state = 2; state < device->brightness->count; state++)
371 if (level == device->brightness->levels[state]) {
372 if (device->backlight)
373 device->backlight->props.brightness = state - 2;
374 return 0;
375 }
376
377 ACPI_ERROR((AE_INFO, "Current brightness invalid"));
378 return -EINVAL;
379 }
380
381 /*
382 * For some buggy _BQC methods, we need to add a constant value to
383 * the _BQC return value to get the actual current brightness level
384 */
385
386 static int bqc_offset_aml_bug_workaround;
387 static int __init video_set_bqc_offset(const struct dmi_system_id *d)
388 {
389 bqc_offset_aml_bug_workaround = 9;
390 return 0;
391 }
392
393 static struct dmi_system_id video_dmi_table[] __initdata = {
394 /*
395 * Broken _BQC workaround http://bugzilla.kernel.org/show_bug.cgi?id=13121
396 */
397 {
398 .callback = video_set_bqc_offset,
399 .ident = "Acer Aspire 5720",
400 .matches = {
401 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
402 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5720"),
403 },
404 },
405 {
406 .callback = video_set_bqc_offset,
407 .ident = "Acer Aspire 5710Z",
408 .matches = {
409 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
410 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5710Z"),
411 },
412 },
413 {
414 .callback = video_set_bqc_offset,
415 .ident = "eMachines E510",
416 .matches = {
417 DMI_MATCH(DMI_BOARD_VENDOR, "EMACHINES"),
418 DMI_MATCH(DMI_PRODUCT_NAME, "eMachines E510"),
419 },
420 },
421 {
422 .callback = video_set_bqc_offset,
423 .ident = "Acer Aspire 5315",
424 .matches = {
425 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
426 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5315"),
427 },
428 },
429 {
430 .callback = video_set_bqc_offset,
431 .ident = "Acer Aspire 7720",
432 .matches = {
433 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
434 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7720"),
435 },
436 },
437 {}
438 };
439
440 static int
441 acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
442 unsigned long long *level, int init)
443 {
444 acpi_status status = AE_OK;
445 int i;
446
447 if (device->cap._BQC || device->cap._BCQ) {
448 char *buf = device->cap._BQC ? "_BQC" : "_BCQ";
449
450 status = acpi_evaluate_integer(device->dev->handle, buf,
451 NULL, level);
452 if (ACPI_SUCCESS(status)) {
453 if (device->brightness->flags._BQC_use_index) {
454 if (device->brightness->flags._BCL_reversed)
455 *level = device->brightness->count
456 - 3 - (*level);
457 *level = device->brightness->levels[*level + 2];
458
459 }
460 *level += bqc_offset_aml_bug_workaround;
461 for (i = 2; i < device->brightness->count; i++)
462 if (device->brightness->levels[i] == *level) {
463 device->brightness->curr = *level;
464 return 0;
465 }
466 if (!init) {
467 /*
468 * BQC returned an invalid level.
469 * Stop using it.
470 */
471 ACPI_WARNING((AE_INFO,
472 "%s returned an invalid level",
473 buf));
474 device->cap._BQC = device->cap._BCQ = 0;
475 }
476 } else {
477 /* Fixme:
478 * should we return an error or ignore this failure?
479 * dev->brightness->curr is a cached value which stores
480 * the correct current backlight level in most cases.
481 * ACPI video backlight still works w/ buggy _BQC.
482 * http://bugzilla.kernel.org/show_bug.cgi?id=12233
483 */
484 ACPI_WARNING((AE_INFO, "Evaluating %s failed", buf));
485 device->cap._BQC = device->cap._BCQ = 0;
486 }
487 }
488
489 *level = device->brightness->curr;
490 return 0;
491 }
492
493 static int
494 acpi_video_device_EDID(struct acpi_video_device *device,
495 union acpi_object **edid, ssize_t length)
496 {
497 int status;
498 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
499 union acpi_object *obj;
500 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
501 struct acpi_object_list args = { 1, &arg0 };
502
503
504 *edid = NULL;
505
506 if (!device)
507 return -ENODEV;
508 if (length == 128)
509 arg0.integer.value = 1;
510 else if (length == 256)
511 arg0.integer.value = 2;
512 else
513 return -EINVAL;
514
515 status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer);
516 if (ACPI_FAILURE(status))
517 return -ENODEV;
518
519 obj = buffer.pointer;
520
521 if (obj && obj->type == ACPI_TYPE_BUFFER)
522 *edid = obj;
523 else {
524 printk(KERN_ERR PREFIX "Invalid _DDC data\n");
525 status = -EFAULT;
526 kfree(obj);
527 }
528
529 return status;
530 }
531
532 /* bus */
533
534 /*
535 * Arg:
536 * video : video bus device pointer
537 * bios_flag :
538 * 0. The system BIOS should NOT automatically switch(toggle)
539 * the active display output.
540 * 1. The system BIOS should automatically switch (toggle) the
541 * active display output. No switch event.
542 * 2. The _DGS value should be locked.
543 * 3. The system BIOS should not automatically switch (toggle) the
544 * active display output, but instead generate the display switch
545 * event notify code.
546 * lcd_flag :
547 * 0. The system BIOS should automatically control the brightness level
548 * of the LCD when the power changes from AC to DC
549 * 1. The system BIOS should NOT automatically control the brightness
550 * level of the LCD when the power changes from AC to DC.
551 * Return Value:
552 * -1 wrong arg.
553 */
554
555 static int
556 acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
557 {
558 u64 status = 0;
559 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
560 struct acpi_object_list args = { 1, &arg0 };
561
562
563 if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1) {
564 status = -1;
565 goto Failed;
566 }
567 arg0.integer.value = (lcd_flag << 2) | bios_flag;
568 video->dos_setting = arg0.integer.value;
569 acpi_evaluate_object(video->device->handle, "_DOS", &args, NULL);
570
571 Failed:
572 return status;
573 }
574
575 /*
576 * Simple comparison function used to sort backlight levels.
577 */
578
579 static int
580 acpi_video_cmp_level(const void *a, const void *b)
581 {
582 return *(int *)a - *(int *)b;
583 }
584
585 /*
586 * Arg:
587 * device : video output device (LCD, CRT, ..)
588 *
589 * Return Value:
590 * Maximum brightness level
591 *
592 * Allocate and initialize device->brightness.
593 */
594
595 static int
596 acpi_video_init_brightness(struct acpi_video_device *device)
597 {
598 union acpi_object *obj = NULL;
599 int i, max_level = 0, count = 0, level_ac_battery = 0;
600 unsigned long long level, level_old;
601 union acpi_object *o;
602 struct acpi_video_device_brightness *br = NULL;
603 int result = -EINVAL;
604
605 if (!ACPI_SUCCESS(acpi_video_device_lcd_query_levels(device, &obj))) {
606 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Could not query available "
607 "LCD brightness level\n"));
608 goto out;
609 }
610
611 if (obj->package.count < 2)
612 goto out;
613
614 br = kzalloc(sizeof(*br), GFP_KERNEL);
615 if (!br) {
616 printk(KERN_ERR "can't allocate memory\n");
617 result = -ENOMEM;
618 goto out;
619 }
620
621 br->levels = kmalloc((obj->package.count + 2) * sizeof *(br->levels),
622 GFP_KERNEL);
623 if (!br->levels) {
624 result = -ENOMEM;
625 goto out_free;
626 }
627
628 for (i = 0; i < obj->package.count; i++) {
629 o = (union acpi_object *)&obj->package.elements[i];
630 if (o->type != ACPI_TYPE_INTEGER) {
631 printk(KERN_ERR PREFIX "Invalid data\n");
632 continue;
633 }
634 br->levels[count] = (u32) o->integer.value;
635
636 if (br->levels[count] > max_level)
637 max_level = br->levels[count];
638 count++;
639 }
640
641 /*
642 * some buggy BIOS don't export the levels
643 * when machine is on AC/Battery in _BCL package.
644 * In this case, the first two elements in _BCL packages
645 * are also supported brightness levels that OS should take care of.
646 */
647 for (i = 2; i < count; i++) {
648 if (br->levels[i] == br->levels[0])
649 level_ac_battery++;
650 if (br->levels[i] == br->levels[1])
651 level_ac_battery++;
652 }
653
654 if (level_ac_battery < 2) {
655 level_ac_battery = 2 - level_ac_battery;
656 br->flags._BCL_no_ac_battery_levels = 1;
657 for (i = (count - 1 + level_ac_battery); i >= 2; i--)
658 br->levels[i] = br->levels[i - level_ac_battery];
659 count += level_ac_battery;
660 } else if (level_ac_battery > 2)
661 ACPI_ERROR((AE_INFO, "Too many duplicates in _BCL package\n"));
662
663 /* Check if the _BCL package is in a reversed order */
664 if (max_level == br->levels[2]) {
665 br->flags._BCL_reversed = 1;
666 sort(&br->levels[2], count - 2, sizeof(br->levels[2]),
667 acpi_video_cmp_level, NULL);
668 } else if (max_level != br->levels[count - 1])
669 ACPI_ERROR((AE_INFO,
670 "Found unordered _BCL package\n"));
671
672 br->count = count;
673 device->brightness = br;
674
675 /* Check the input/output of _BQC/_BCL/_BCM */
676 if ((max_level < 100) && (max_level <= (count - 2)))
677 br->flags._BCL_use_index = 1;
678
679 /*
680 * _BCM is always consistent with _BCL,
681 * at least for all the laptops we have ever seen.
682 */
683 br->flags._BCM_use_index = br->flags._BCL_use_index;
684
685 /* _BQC uses INDEX while _BCL uses VALUE in some laptops */
686 br->curr = level = max_level;
687
688 if (!device->cap._BQC)
689 goto set_level;
690
691 result = acpi_video_device_lcd_get_level_current(device, &level_old, 1);
692 if (result)
693 goto out_free_levels;
694
695 /*
696 * Set the level to maximum and check if _BQC uses indexed value
697 */
698 result = acpi_video_device_lcd_set_level(device, max_level);
699 if (result)
700 goto out_free_levels;
701
702 result = acpi_video_device_lcd_get_level_current(device, &level, 0);
703 if (result)
704 goto out_free_levels;
705
706 br->flags._BQC_use_index = (level == max_level ? 0 : 1);
707
708 if (!br->flags._BQC_use_index) {
709 /*
710 * Set the backlight to the initial state.
711 * On some buggy laptops, _BQC returns an uninitialized value
712 * when invoked for the first time, i.e. level_old is invalid.
713 * set the backlight to max_level in this case
714 */
715 if (use_bios_initial_backlight) {
716 for (i = 2; i < br->count; i++)
717 if (level_old == br->levels[i])
718 level = level_old;
719 }
720 goto set_level;
721 }
722
723 if (br->flags._BCL_reversed)
724 level_old = (br->count - 1) - level_old;
725 level = br->levels[level_old];
726
727 set_level:
728 result = acpi_video_device_lcd_set_level(device, level);
729 if (result)
730 goto out_free_levels;
731
732 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
733 "found %d brightness levels\n", count - 2));
734 kfree(obj);
735 return result;
736
737 out_free_levels:
738 kfree(br->levels);
739 out_free:
740 kfree(br);
741 out:
742 device->brightness = NULL;
743 kfree(obj);
744 return result;
745 }
746
747 /*
748 * Arg:
749 * device : video output device (LCD, CRT, ..)
750 *
751 * Return Value:
752 * None
753 *
754 * Find out all required AML methods defined under the output
755 * device.
756 */
757
758 static void acpi_video_device_find_cap(struct acpi_video_device *device)
759 {
760 acpi_handle h_dummy1;
761
762 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_ADR", &h_dummy1))) {
763 device->cap._ADR = 1;
764 }
765 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCL", &h_dummy1))) {
766 device->cap._BCL = 1;
767 }
768 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCM", &h_dummy1))) {
769 device->cap._BCM = 1;
770 }
771 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle,"_BQC",&h_dummy1)))
772 device->cap._BQC = 1;
773 else if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCQ",
774 &h_dummy1))) {
775 printk(KERN_WARNING FW_BUG "_BCQ is used instead of _BQC\n");
776 device->cap._BCQ = 1;
777 }
778
779 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DDC", &h_dummy1))) {
780 device->cap._DDC = 1;
781 }
782
783 if (acpi_video_backlight_support()) {
784 struct backlight_properties props;
785 struct pci_dev *pdev;
786 acpi_handle acpi_parent;
787 struct device *parent = NULL;
788 int result;
789 static int count = 0;
790 char *name;
791
792 result = acpi_video_init_brightness(device);
793 if (result)
794 return;
795 name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
796 if (!name)
797 return;
798 count++;
799
800 acpi_get_parent(device->dev->handle, &acpi_parent);
801
802 pdev = acpi_get_pci_dev(acpi_parent);
803 if (pdev) {
804 parent = &pdev->dev;
805 pci_dev_put(pdev);
806 }
807
808 memset(&props, 0, sizeof(struct backlight_properties));
809 props.type = BACKLIGHT_FIRMWARE;
810 props.max_brightness = device->brightness->count - 3;
811 device->backlight = backlight_device_register(name,
812 parent,
813 device,
814 &acpi_backlight_ops,
815 &props);
816 kfree(name);
817 if (IS_ERR(device->backlight))
818 return;
819
820 /*
821 * Save current brightness level in case we have to restore it
822 * before acpi_video_device_lcd_set_level() is called next time.
823 */
824 device->backlight->props.brightness =
825 acpi_video_get_brightness(device->backlight);
826
827 device->cooling_dev = thermal_cooling_device_register("LCD",
828 device->dev, &video_cooling_ops);
829 if (IS_ERR(device->cooling_dev)) {
830 /*
831 * Set cooling_dev to NULL so we don't crash trying to
832 * free it.
833 * Also, why the hell we are returning early and
834 * not attempt to register video output if cooling
835 * device registration failed?
836 * -- dtor
837 */
838 device->cooling_dev = NULL;
839 return;
840 }
841
842 dev_info(&device->dev->dev, "registered as cooling_device%d\n",
843 device->cooling_dev->id);
844 result = sysfs_create_link(&device->dev->dev.kobj,
845 &device->cooling_dev->device.kobj,
846 "thermal_cooling");
847 if (result)
848 printk(KERN_ERR PREFIX "Create sysfs link\n");
849 result = sysfs_create_link(&device->cooling_dev->device.kobj,
850 &device->dev->dev.kobj, "device");
851 if (result)
852 printk(KERN_ERR PREFIX "Create sysfs link\n");
853
854 }
855 }
856
857 /*
858 * Arg:
859 * device : video output device (VGA)
860 *
861 * Return Value:
862 * None
863 *
864 * Find out all required AML methods defined under the video bus device.
865 */
866
867 static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
868 {
869 acpi_handle h_dummy1;
870
871 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOS", &h_dummy1))) {
872 video->cap._DOS = 1;
873 }
874 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOD", &h_dummy1))) {
875 video->cap._DOD = 1;
876 }
877 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_ROM", &h_dummy1))) {
878 video->cap._ROM = 1;
879 }
880 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_GPD", &h_dummy1))) {
881 video->cap._GPD = 1;
882 }
883 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_SPD", &h_dummy1))) {
884 video->cap._SPD = 1;
885 }
886 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_VPO", &h_dummy1))) {
887 video->cap._VPO = 1;
888 }
889 }
890
891 /*
892 * Check whether the video bus device has required AML method to
893 * support the desired features
894 */
895
896 static int acpi_video_bus_check(struct acpi_video_bus *video)
897 {
898 acpi_status status = -ENOENT;
899 struct pci_dev *dev;
900
901 if (!video)
902 return -EINVAL;
903
904 dev = acpi_get_pci_dev(video->device->handle);
905 if (!dev)
906 return -ENODEV;
907 pci_dev_put(dev);
908
909 /* Since there is no HID, CID and so on for VGA driver, we have
910 * to check well known required nodes.
911 */
912
913 /* Does this device support video switching? */
914 if (video->cap._DOS || video->cap._DOD) {
915 if (!video->cap._DOS) {
916 printk(KERN_WARNING FW_BUG
917 "ACPI(%s) defines _DOD but not _DOS\n",
918 acpi_device_bid(video->device));
919 }
920 video->flags.multihead = 1;
921 status = 0;
922 }
923
924 /* Does this device support retrieving a video ROM? */
925 if (video->cap._ROM) {
926 video->flags.rom = 1;
927 status = 0;
928 }
929
930 /* Does this device support configuring which video device to POST? */
931 if (video->cap._GPD && video->cap._SPD && video->cap._VPO) {
932 video->flags.post = 1;
933 status = 0;
934 }
935
936 return status;
937 }
938
939 /* --------------------------------------------------------------------------
940 Driver Interface
941 -------------------------------------------------------------------------- */
942
943 /* device interface */
944 static struct acpi_video_device_attrib*
945 acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id)
946 {
947 struct acpi_video_enumerated_device *ids;
948 int i;
949
950 for (i = 0; i < video->attached_count; i++) {
951 ids = &video->attached_array[i];
952 if ((ids->value.int_val & 0xffff) == device_id)
953 return &ids->value.attrib;
954 }
955
956 return NULL;
957 }
958
959 static int
960 acpi_video_get_device_type(struct acpi_video_bus *video,
961 unsigned long device_id)
962 {
963 struct acpi_video_enumerated_device *ids;
964 int i;
965
966 for (i = 0; i < video->attached_count; i++) {
967 ids = &video->attached_array[i];
968 if ((ids->value.int_val & 0xffff) == device_id)
969 return ids->value.int_val;
970 }
971
972 return 0;
973 }
974
975 static int
976 acpi_video_bus_get_one_device(struct acpi_device *device,
977 struct acpi_video_bus *video)
978 {
979 unsigned long long device_id;
980 int status, device_type;
981 struct acpi_video_device *data;
982 struct acpi_video_device_attrib* attribute;
983
984 if (!device || !video)
985 return -EINVAL;
986
987 status =
988 acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
989 if (ACPI_SUCCESS(status)) {
990
991 data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
992 if (!data)
993 return -ENOMEM;
994
995 strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
996 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
997 device->driver_data = data;
998
999 data->device_id = device_id;
1000 data->video = video;
1001 data->dev = device;
1002
1003 attribute = acpi_video_get_device_attr(video, device_id);
1004
1005 if((attribute != NULL) && attribute->device_id_scheme) {
1006 switch (attribute->display_type) {
1007 case ACPI_VIDEO_DISPLAY_CRT:
1008 data->flags.crt = 1;
1009 break;
1010 case ACPI_VIDEO_DISPLAY_TV:
1011 data->flags.tvout = 1;
1012 break;
1013 case ACPI_VIDEO_DISPLAY_DVI:
1014 data->flags.dvi = 1;
1015 break;
1016 case ACPI_VIDEO_DISPLAY_LCD:
1017 data->flags.lcd = 1;
1018 break;
1019 default:
1020 data->flags.unknown = 1;
1021 break;
1022 }
1023 if(attribute->bios_can_detect)
1024 data->flags.bios = 1;
1025 } else {
1026 /* Check for legacy IDs */
1027 device_type = acpi_video_get_device_type(video,
1028 device_id);
1029 /* Ignore bits 16 and 18-20 */
1030 switch (device_type & 0xffe2ffff) {
1031 case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR:
1032 data->flags.crt = 1;
1033 break;
1034 case ACPI_VIDEO_DISPLAY_LEGACY_PANEL:
1035 data->flags.lcd = 1;
1036 break;
1037 case ACPI_VIDEO_DISPLAY_LEGACY_TV:
1038 data->flags.tvout = 1;
1039 break;
1040 default:
1041 data->flags.unknown = 1;
1042 }
1043 }
1044
1045 acpi_video_device_bind(video, data);
1046 acpi_video_device_find_cap(data);
1047
1048 status = acpi_install_notify_handler(device->handle,
1049 ACPI_DEVICE_NOTIFY,
1050 acpi_video_device_notify,
1051 data);
1052 if (ACPI_FAILURE(status)) {
1053 printk(KERN_ERR PREFIX
1054 "Error installing notify handler\n");
1055 if(data->brightness)
1056 kfree(data->brightness->levels);
1057 kfree(data->brightness);
1058 kfree(data);
1059 return -ENODEV;
1060 }
1061
1062 mutex_lock(&video->device_list_lock);
1063 list_add_tail(&data->entry, &video->video_device_list);
1064 mutex_unlock(&video->device_list_lock);
1065
1066 return 0;
1067 }
1068
1069 return -ENOENT;
1070 }
1071
1072 /*
1073 * Arg:
1074 * video : video bus device
1075 *
1076 * Return:
1077 * none
1078 *
1079 * Enumerate the video device list of the video bus,
1080 * bind the ids with the corresponding video devices
1081 * under the video bus.
1082 */
1083
1084 static void acpi_video_device_rebind(struct acpi_video_bus *video)
1085 {
1086 struct acpi_video_device *dev;
1087
1088 mutex_lock(&video->device_list_lock);
1089
1090 list_for_each_entry(dev, &video->video_device_list, entry)
1091 acpi_video_device_bind(video, dev);
1092
1093 mutex_unlock(&video->device_list_lock);
1094 }
1095
1096 /*
1097 * Arg:
1098 * video : video bus device
1099 * device : video output device under the video
1100 * bus
1101 *
1102 * Return:
1103 * none
1104 *
1105 * Bind the ids with the corresponding video devices
1106 * under the video bus.
1107 */
1108
1109 static void
1110 acpi_video_device_bind(struct acpi_video_bus *video,
1111 struct acpi_video_device *device)
1112 {
1113 struct acpi_video_enumerated_device *ids;
1114 int i;
1115
1116 for (i = 0; i < video->attached_count; i++) {
1117 ids = &video->attached_array[i];
1118 if (device->device_id == (ids->value.int_val & 0xffff)) {
1119 ids->bind_info = device;
1120 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "device_bind %d\n", i));
1121 }
1122 }
1123 }
1124
1125 /*
1126 * Arg:
1127 * video : video bus device
1128 *
1129 * Return:
1130 * < 0 : error
1131 *
1132 * Call _DOD to enumerate all devices attached to display adapter
1133 *
1134 */
1135
1136 static int acpi_video_device_enumerate(struct acpi_video_bus *video)
1137 {
1138 int status;
1139 int count;
1140 int i;
1141 struct acpi_video_enumerated_device *active_list;
1142 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1143 union acpi_object *dod = NULL;
1144 union acpi_object *obj;
1145
1146 status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
1147 if (!ACPI_SUCCESS(status)) {
1148 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD"));
1149 return status;
1150 }
1151
1152 dod = buffer.pointer;
1153 if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
1154 ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data"));
1155 status = -EFAULT;
1156 goto out;
1157 }
1158
1159 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d video heads in _DOD\n",
1160 dod->package.count));
1161
1162 active_list = kcalloc(1 + dod->package.count,
1163 sizeof(struct acpi_video_enumerated_device),
1164 GFP_KERNEL);
1165 if (!active_list) {
1166 status = -ENOMEM;
1167 goto out;
1168 }
1169
1170 count = 0;
1171 for (i = 0; i < dod->package.count; i++) {
1172 obj = &dod->package.elements[i];
1173
1174 if (obj->type != ACPI_TYPE_INTEGER) {
1175 printk(KERN_ERR PREFIX
1176 "Invalid _DOD data in element %d\n", i);
1177 continue;
1178 }
1179
1180 active_list[count].value.int_val = obj->integer.value;
1181 active_list[count].bind_info = NULL;
1182 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "dod element[%d] = %d\n", i,
1183 (int)obj->integer.value));
1184 count++;
1185 }
1186
1187 kfree(video->attached_array);
1188
1189 video->attached_array = active_list;
1190 video->attached_count = count;
1191
1192 out:
1193 kfree(buffer.pointer);
1194 return status;
1195 }
1196
1197 static int
1198 acpi_video_get_next_level(struct acpi_video_device *device,
1199 u32 level_current, u32 event)
1200 {
1201 int min, max, min_above, max_below, i, l, delta = 255;
1202 max = max_below = 0;
1203 min = min_above = 255;
1204 /* Find closest level to level_current */
1205 for (i = 2; i < device->brightness->count; i++) {
1206 l = device->brightness->levels[i];
1207 if (abs(l - level_current) < abs(delta)) {
1208 delta = l - level_current;
1209 if (!delta)
1210 break;
1211 }
1212 }
1213 /* Ajust level_current to closest available level */
1214 level_current += delta;
1215 for (i = 2; i < device->brightness->count; i++) {
1216 l = device->brightness->levels[i];
1217 if (l < min)
1218 min = l;
1219 if (l > max)
1220 max = l;
1221 if (l < min_above && l > level_current)
1222 min_above = l;
1223 if (l > max_below && l < level_current)
1224 max_below = l;
1225 }
1226
1227 switch (event) {
1228 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:
1229 return (level_current < max) ? min_above : min;
1230 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:
1231 return (level_current < max) ? min_above : max;
1232 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:
1233 return (level_current > min) ? max_below : min;
1234 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:
1235 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:
1236 return 0;
1237 default:
1238 return level_current;
1239 }
1240 }
1241
1242 static int
1243 acpi_video_switch_brightness(struct acpi_video_device *device, int event)
1244 {
1245 unsigned long long level_current, level_next;
1246 int result = -EINVAL;
1247
1248 /* no warning message if acpi_backlight=vendor is used */
1249 if (!acpi_video_backlight_support())
1250 return 0;
1251
1252 if (!device->brightness)
1253 goto out;
1254
1255 result = acpi_video_device_lcd_get_level_current(device,
1256 &level_current, 0);
1257 if (result)
1258 goto out;
1259
1260 level_next = acpi_video_get_next_level(device, level_current, event);
1261
1262 result = acpi_video_device_lcd_set_level(device, level_next);
1263
1264 if (!result)
1265 backlight_force_update(device->backlight,
1266 BACKLIGHT_UPDATE_HOTKEY);
1267
1268 out:
1269 if (result)
1270 printk(KERN_ERR PREFIX "Failed to switch the brightness\n");
1271
1272 return result;
1273 }
1274
1275 int acpi_video_get_edid(struct acpi_device *device, int type, int device_id,
1276 void **edid)
1277 {
1278 struct acpi_video_bus *video;
1279 struct acpi_video_device *video_device;
1280 union acpi_object *buffer = NULL;
1281 acpi_status status;
1282 int i, length;
1283
1284 if (!device || !acpi_driver_data(device))
1285 return -EINVAL;
1286
1287 video = acpi_driver_data(device);
1288
1289 for (i = 0; i < video->attached_count; i++) {
1290 video_device = video->attached_array[i].bind_info;
1291 length = 256;
1292
1293 if (!video_device)
1294 continue;
1295
1296 if (!video_device->cap._DDC)
1297 continue;
1298
1299 if (type) {
1300 switch (type) {
1301 case ACPI_VIDEO_DISPLAY_CRT:
1302 if (!video_device->flags.crt)
1303 continue;
1304 break;
1305 case ACPI_VIDEO_DISPLAY_TV:
1306 if (!video_device->flags.tvout)
1307 continue;
1308 break;
1309 case ACPI_VIDEO_DISPLAY_DVI:
1310 if (!video_device->flags.dvi)
1311 continue;
1312 break;
1313 case ACPI_VIDEO_DISPLAY_LCD:
1314 if (!video_device->flags.lcd)
1315 continue;
1316 break;
1317 }
1318 } else if (video_device->device_id != device_id) {
1319 continue;
1320 }
1321
1322 status = acpi_video_device_EDID(video_device, &buffer, length);
1323
1324 if (ACPI_FAILURE(status) || !buffer ||
1325 buffer->type != ACPI_TYPE_BUFFER) {
1326 length = 128;
1327 status = acpi_video_device_EDID(video_device, &buffer,
1328 length);
1329 if (ACPI_FAILURE(status) || !buffer ||
1330 buffer->type != ACPI_TYPE_BUFFER) {
1331 continue;
1332 }
1333 }
1334
1335 *edid = buffer->buffer.pointer;
1336 return length;
1337 }
1338
1339 return -ENODEV;
1340 }
1341 EXPORT_SYMBOL(acpi_video_get_edid);
1342
1343 static int
1344 acpi_video_bus_get_devices(struct acpi_video_bus *video,
1345 struct acpi_device *device)
1346 {
1347 int status = 0;
1348 struct acpi_device *dev;
1349
1350 acpi_video_device_enumerate(video);
1351
1352 list_for_each_entry(dev, &device->children, node) {
1353
1354 status = acpi_video_bus_get_one_device(dev, video);
1355 if (ACPI_FAILURE(status)) {
1356 printk(KERN_WARNING PREFIX
1357 "Can't attach device\n");
1358 continue;
1359 }
1360 }
1361 return status;
1362 }
1363
1364 static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
1365 {
1366 acpi_status status;
1367
1368 if (!device || !device->video)
1369 return -ENOENT;
1370
1371 status = acpi_remove_notify_handler(device->dev->handle,
1372 ACPI_DEVICE_NOTIFY,
1373 acpi_video_device_notify);
1374 if (ACPI_FAILURE(status)) {
1375 printk(KERN_WARNING PREFIX
1376 "Can't remove video notify handler\n");
1377 }
1378 if (device->backlight) {
1379 backlight_device_unregister(device->backlight);
1380 device->backlight = NULL;
1381 }
1382 if (device->cooling_dev) {
1383 sysfs_remove_link(&device->dev->dev.kobj,
1384 "thermal_cooling");
1385 sysfs_remove_link(&device->cooling_dev->device.kobj,
1386 "device");
1387 thermal_cooling_device_unregister(device->cooling_dev);
1388 device->cooling_dev = NULL;
1389 }
1390
1391 return 0;
1392 }
1393
1394 static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
1395 {
1396 int status;
1397 struct acpi_video_device *dev, *next;
1398
1399 mutex_lock(&video->device_list_lock);
1400
1401 list_for_each_entry_safe(dev, next, &video->video_device_list, entry) {
1402
1403 status = acpi_video_bus_put_one_device(dev);
1404 if (ACPI_FAILURE(status))
1405 printk(KERN_WARNING PREFIX
1406 "hhuuhhuu bug in acpi video driver.\n");
1407
1408 if (dev->brightness) {
1409 kfree(dev->brightness->levels);
1410 kfree(dev->brightness);
1411 }
1412 list_del(&dev->entry);
1413 kfree(dev);
1414 }
1415
1416 mutex_unlock(&video->device_list_lock);
1417
1418 return 0;
1419 }
1420
1421 /* acpi_video interface */
1422
1423 static int acpi_video_bus_start_devices(struct acpi_video_bus *video)
1424 {
1425 return acpi_video_bus_DOS(video, 0, 0);
1426 }
1427
1428 static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
1429 {
1430 return acpi_video_bus_DOS(video, 0, 1);
1431 }
1432
1433 static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
1434 {
1435 struct acpi_video_bus *video = acpi_driver_data(device);
1436 struct input_dev *input;
1437 int keycode = 0;
1438
1439 if (!video)
1440 return;
1441
1442 input = video->input;
1443
1444 switch (event) {
1445 case ACPI_VIDEO_NOTIFY_SWITCH: /* User requested a switch,
1446 * most likely via hotkey. */
1447 acpi_bus_generate_proc_event(device, event, 0);
1448 keycode = KEY_SWITCHVIDEOMODE;
1449 break;
1450
1451 case ACPI_VIDEO_NOTIFY_PROBE: /* User plugged in or removed a video
1452 * connector. */
1453 acpi_video_device_enumerate(video);
1454 acpi_video_device_rebind(video);
1455 acpi_bus_generate_proc_event(device, event, 0);
1456 keycode = KEY_SWITCHVIDEOMODE;
1457 break;
1458
1459 case ACPI_VIDEO_NOTIFY_CYCLE: /* Cycle Display output hotkey pressed. */
1460 acpi_bus_generate_proc_event(device, event, 0);
1461 keycode = KEY_SWITCHVIDEOMODE;
1462 break;
1463 case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT: /* Next Display output hotkey pressed. */
1464 acpi_bus_generate_proc_event(device, event, 0);
1465 keycode = KEY_VIDEO_NEXT;
1466 break;
1467 case ACPI_VIDEO_NOTIFY_PREV_OUTPUT: /* previous Display output hotkey pressed. */
1468 acpi_bus_generate_proc_event(device, event, 0);
1469 keycode = KEY_VIDEO_PREV;
1470 break;
1471
1472 default:
1473 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1474 "Unsupported event [0x%x]\n", event));
1475 break;
1476 }
1477
1478 acpi_notifier_call_chain(device, event, 0);
1479
1480 if (keycode) {
1481 input_report_key(input, keycode, 1);
1482 input_sync(input);
1483 input_report_key(input, keycode, 0);
1484 input_sync(input);
1485 }
1486
1487 return;
1488 }
1489
1490 static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
1491 {
1492 struct acpi_video_device *video_device = data;
1493 struct acpi_device *device = NULL;
1494 struct acpi_video_bus *bus;
1495 struct input_dev *input;
1496 int keycode = 0;
1497
1498 if (!video_device)
1499 return;
1500
1501 device = video_device->dev;
1502 bus = video_device->video;
1503 input = bus->input;
1504
1505 switch (event) {
1506 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: /* Cycle brightness */
1507 if (brightness_switch_enabled)
1508 acpi_video_switch_brightness(video_device, event);
1509 acpi_bus_generate_proc_event(device, event, 0);
1510 keycode = KEY_BRIGHTNESS_CYCLE;
1511 break;
1512 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: /* Increase brightness */
1513 if (brightness_switch_enabled)
1514 acpi_video_switch_brightness(video_device, event);
1515 acpi_bus_generate_proc_event(device, event, 0);
1516 keycode = KEY_BRIGHTNESSUP;
1517 break;
1518 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: /* Decrease brightness */
1519 if (brightness_switch_enabled)
1520 acpi_video_switch_brightness(video_device, event);
1521 acpi_bus_generate_proc_event(device, event, 0);
1522 keycode = KEY_BRIGHTNESSDOWN;
1523 break;
1524 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightnesss */
1525 if (brightness_switch_enabled)
1526 acpi_video_switch_brightness(video_device, event);
1527 acpi_bus_generate_proc_event(device, event, 0);
1528 keycode = KEY_BRIGHTNESS_ZERO;
1529 break;
1530 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: /* display device off */
1531 if (brightness_switch_enabled)
1532 acpi_video_switch_brightness(video_device, event);
1533 acpi_bus_generate_proc_event(device, event, 0);
1534 keycode = KEY_DISPLAY_OFF;
1535 break;
1536 default:
1537 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1538 "Unsupported event [0x%x]\n", event));
1539 break;
1540 }
1541
1542 acpi_notifier_call_chain(device, event, 0);
1543
1544 if (keycode) {
1545 input_report_key(input, keycode, 1);
1546 input_sync(input);
1547 input_report_key(input, keycode, 0);
1548 input_sync(input);
1549 }
1550
1551 return;
1552 }
1553
1554 static int acpi_video_resume(struct notifier_block *nb,
1555 unsigned long val, void *ign)
1556 {
1557 struct acpi_video_bus *video;
1558 struct acpi_video_device *video_device;
1559 int i;
1560
1561 switch (val) {
1562 case PM_HIBERNATION_PREPARE:
1563 case PM_SUSPEND_PREPARE:
1564 case PM_RESTORE_PREPARE:
1565 return NOTIFY_DONE;
1566 }
1567
1568 video = container_of(nb, struct acpi_video_bus, pm_nb);
1569
1570 dev_info(&video->device->dev, "Restoring backlight state\n");
1571
1572 for (i = 0; i < video->attached_count; i++) {
1573 video_device = video->attached_array[i].bind_info;
1574 if (video_device && video_device->backlight)
1575 acpi_video_set_brightness(video_device->backlight);
1576 }
1577
1578 return NOTIFY_OK;
1579 }
1580
1581 static acpi_status
1582 acpi_video_bus_match(acpi_handle handle, u32 level, void *context,
1583 void **return_value)
1584 {
1585 struct acpi_device *device = context;
1586 struct acpi_device *sibling;
1587 int result;
1588
1589 if (handle == device->handle)
1590 return AE_CTRL_TERMINATE;
1591
1592 result = acpi_bus_get_device(handle, &sibling);
1593 if (result)
1594 return AE_OK;
1595
1596 if (!strcmp(acpi_device_name(sibling), ACPI_VIDEO_BUS_NAME))
1597 return AE_ALREADY_EXISTS;
1598
1599 return AE_OK;
1600 }
1601
1602 static int instance;
1603
1604 static int acpi_video_bus_add(struct acpi_device *device)
1605 {
1606 struct acpi_video_bus *video;
1607 struct input_dev *input;
1608 int error;
1609 acpi_status status;
1610
1611 status = acpi_walk_namespace(ACPI_TYPE_DEVICE,
1612 device->parent->handle, 1,
1613 acpi_video_bus_match, NULL,
1614 device, NULL);
1615 if (status == AE_ALREADY_EXISTS) {
1616 printk(KERN_WARNING FW_BUG
1617 "Duplicate ACPI video bus devices for the"
1618 " same VGA controller, please try module "
1619 "parameter \"video.allow_duplicates=1\""
1620 "if the current driver doesn't work.\n");
1621 if (!allow_duplicates)
1622 return -ENODEV;
1623 }
1624
1625 video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
1626 if (!video)
1627 return -ENOMEM;
1628
1629 /* a hack to fix the duplicate name "VID" problem on T61 */
1630 if (!strcmp(device->pnp.bus_id, "VID")) {
1631 if (instance)
1632 device->pnp.bus_id[3] = '0' + instance;
1633 instance ++;
1634 }
1635 /* a hack to fix the duplicate name "VGA" problem on Pa 3553 */
1636 if (!strcmp(device->pnp.bus_id, "VGA")) {
1637 if (instance)
1638 device->pnp.bus_id[3] = '0' + instance;
1639 instance++;
1640 }
1641
1642 video->device = device;
1643 strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
1644 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
1645 device->driver_data = video;
1646
1647 acpi_video_bus_find_cap(video);
1648 error = acpi_video_bus_check(video);
1649 if (error)
1650 goto err_free_video;
1651
1652 mutex_init(&video->device_list_lock);
1653 INIT_LIST_HEAD(&video->video_device_list);
1654
1655 acpi_video_bus_get_devices(video, device);
1656 acpi_video_bus_start_devices(video);
1657
1658 video->input = input = input_allocate_device();
1659 if (!input) {
1660 error = -ENOMEM;
1661 goto err_stop_video;
1662 }
1663
1664 snprintf(video->phys, sizeof(video->phys),
1665 "%s/video/input0", acpi_device_hid(video->device));
1666
1667 input->name = acpi_device_name(video->device);
1668 input->phys = video->phys;
1669 input->id.bustype = BUS_HOST;
1670 input->id.product = 0x06;
1671 input->dev.parent = &device->dev;
1672 input->evbit[0] = BIT(EV_KEY);
1673 set_bit(KEY_SWITCHVIDEOMODE, input->keybit);
1674 set_bit(KEY_VIDEO_NEXT, input->keybit);
1675 set_bit(KEY_VIDEO_PREV, input->keybit);
1676 set_bit(KEY_BRIGHTNESS_CYCLE, input->keybit);
1677 set_bit(KEY_BRIGHTNESSUP, input->keybit);
1678 set_bit(KEY_BRIGHTNESSDOWN, input->keybit);
1679 set_bit(KEY_BRIGHTNESS_ZERO, input->keybit);
1680 set_bit(KEY_DISPLAY_OFF, input->keybit);
1681
1682 error = input_register_device(input);
1683 if (error)
1684 goto err_free_input_dev;
1685
1686 printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s rom: %s post: %s)\n",
1687 ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
1688 video->flags.multihead ? "yes" : "no",
1689 video->flags.rom ? "yes" : "no",
1690 video->flags.post ? "yes" : "no");
1691
1692 video->pm_nb.notifier_call = acpi_video_resume;
1693 video->pm_nb.priority = 0;
1694 register_pm_notifier(&video->pm_nb);
1695
1696 return 0;
1697
1698 err_free_input_dev:
1699 input_free_device(input);
1700 err_stop_video:
1701 acpi_video_bus_stop_devices(video);
1702 acpi_video_bus_put_devices(video);
1703 kfree(video->attached_array);
1704 err_free_video:
1705 kfree(video);
1706 device->driver_data = NULL;
1707
1708 return error;
1709 }
1710
1711 static int acpi_video_bus_remove(struct acpi_device *device, int type)
1712 {
1713 struct acpi_video_bus *video = NULL;
1714
1715
1716 if (!device || !acpi_driver_data(device))
1717 return -EINVAL;
1718
1719 video = acpi_driver_data(device);
1720
1721 unregister_pm_notifier(&video->pm_nb);
1722
1723 acpi_video_bus_stop_devices(video);
1724 acpi_video_bus_put_devices(video);
1725
1726 input_unregister_device(video->input);
1727 kfree(video->attached_array);
1728 kfree(video);
1729
1730 return 0;
1731 }
1732
1733 static int __init intel_opregion_present(void)
1734 {
1735 #if defined(CONFIG_DRM_I915) || defined(CONFIG_DRM_I915_MODULE)
1736 struct pci_dev *dev = NULL;
1737 u32 address;
1738
1739 for_each_pci_dev(dev) {
1740 if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
1741 continue;
1742 if (dev->vendor != PCI_VENDOR_ID_INTEL)
1743 continue;
1744 pci_read_config_dword(dev, 0xfc, &address);
1745 if (!address)
1746 continue;
1747 return 1;
1748 }
1749 #endif
1750 return 0;
1751 }
1752
1753 int acpi_video_register(void)
1754 {
1755 int result = 0;
1756 if (register_count) {
1757 /*
1758 * if the function of acpi_video_register is already called,
1759 * don't register the acpi_vide_bus again and return no error.
1760 */
1761 return 0;
1762 }
1763
1764 result = acpi_bus_register_driver(&acpi_video_bus);
1765 if (result < 0)
1766 return -ENODEV;
1767
1768 /*
1769 * When the acpi_video_bus is loaded successfully, increase
1770 * the counter reference.
1771 */
1772 register_count = 1;
1773
1774 return 0;
1775 }
1776 EXPORT_SYMBOL(acpi_video_register);
1777
1778 void acpi_video_unregister(void)
1779 {
1780 if (!register_count) {
1781 /*
1782 * If the acpi video bus is already unloaded, don't
1783 * unload it again and return directly.
1784 */
1785 return;
1786 }
1787 acpi_bus_unregister_driver(&acpi_video_bus);
1788
1789 register_count = 0;
1790
1791 return;
1792 }
1793 EXPORT_SYMBOL(acpi_video_unregister);
1794
1795 /*
1796 * This is kind of nasty. Hardware using Intel chipsets may require
1797 * the video opregion code to be run first in order to initialise
1798 * state before any ACPI video calls are made. To handle this we defer
1799 * registration of the video class until the opregion code has run.
1800 */
1801
1802 static int __init acpi_video_init(void)
1803 {
1804 dmi_check_system(video_dmi_table);
1805
1806 if (intel_opregion_present())
1807 return 0;
1808
1809 return acpi_video_register();
1810 }
1811
1812 static void __exit acpi_video_exit(void)
1813 {
1814 acpi_video_unregister();
1815
1816 return;
1817 }
1818
1819 module_init(acpi_video_init);
1820 module_exit(acpi_video_exit);
linux-next