?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
init: return proper error code in do_mounts_rd()
[linux-2.6/kvm.git] / drivers / acpi / video.c
bloba18e497f1c3ca92722fd5f8bc8e36bb774d7b982
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 result = sysfs_create_link(&device->backlight->dev.kobj,
828 &device->dev->dev.kobj, "device");
829 if (result)
830 printk(KERN_ERR PREFIX "Create sysfs link\n");
831
832 device->cooling_dev = thermal_cooling_device_register("LCD",
833 device->dev, &video_cooling_ops);
834 if (IS_ERR(device->cooling_dev)) {
835 /*
836 * Set cooling_dev to NULL so we don't crash trying to
837 * free it.
838 * Also, why the hell we are returning early and
839 * not attempt to register video output if cooling
840 * device registration failed?
841 * -- dtor
842 */
843 device->cooling_dev = NULL;
844 return;
845 }
846
847 dev_info(&device->dev->dev, "registered as cooling_device%d\n",
848 device->cooling_dev->id);
849 result = sysfs_create_link(&device->dev->dev.kobj,
850 &device->cooling_dev->device.kobj,
851 "thermal_cooling");
852 if (result)
853 printk(KERN_ERR PREFIX "Create sysfs link\n");
854 result = sysfs_create_link(&device->cooling_dev->device.kobj,
855 &device->dev->dev.kobj, "device");
856 if (result)
857 printk(KERN_ERR PREFIX "Create sysfs link\n");
858
859 }
860 }
861
862 /*
863 * Arg:
864 * device : video output device (VGA)
865 *
866 * Return Value:
867 * None
868 *
869 * Find out all required AML methods defined under the video bus device.
870 */
871
872 static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
873 {
874 acpi_handle h_dummy1;
875
876 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOS", &h_dummy1))) {
877 video->cap._DOS = 1;
878 }
879 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOD", &h_dummy1))) {
880 video->cap._DOD = 1;
881 }
882 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_ROM", &h_dummy1))) {
883 video->cap._ROM = 1;
884 }
885 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_GPD", &h_dummy1))) {
886 video->cap._GPD = 1;
887 }
888 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_SPD", &h_dummy1))) {
889 video->cap._SPD = 1;
890 }
891 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_VPO", &h_dummy1))) {
892 video->cap._VPO = 1;
893 }
894 }
895
896 /*
897 * Check whether the video bus device has required AML method to
898 * support the desired features
899 */
900
901 static int acpi_video_bus_check(struct acpi_video_bus *video)
902 {
903 acpi_status status = -ENOENT;
904 struct pci_dev *dev;
905
906 if (!video)
907 return -EINVAL;
908
909 dev = acpi_get_pci_dev(video->device->handle);
910 if (!dev)
911 return -ENODEV;
912 pci_dev_put(dev);
913
914 /* Since there is no HID, CID and so on for VGA driver, we have
915 * to check well known required nodes.
916 */
917
918 /* Does this device support video switching? */
919 if (video->cap._DOS || video->cap._DOD) {
920 if (!video->cap._DOS) {
921 printk(KERN_WARNING FW_BUG
922 "ACPI(%s) defines _DOD but not _DOS\n",
923 acpi_device_bid(video->device));
924 }
925 video->flags.multihead = 1;
926 status = 0;
927 }
928
929 /* Does this device support retrieving a video ROM? */
930 if (video->cap._ROM) {
931 video->flags.rom = 1;
932 status = 0;
933 }
934
935 /* Does this device support configuring which video device to POST? */
936 if (video->cap._GPD && video->cap._SPD && video->cap._VPO) {
937 video->flags.post = 1;
938 status = 0;
939 }
940
941 return status;
942 }
943
944 /* --------------------------------------------------------------------------
945 Driver Interface
946 -------------------------------------------------------------------------- */
947
948 /* device interface */
949 static struct acpi_video_device_attrib*
950 acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id)
951 {
952 struct acpi_video_enumerated_device *ids;
953 int i;
954
955 for (i = 0; i < video->attached_count; i++) {
956 ids = &video->attached_array[i];
957 if ((ids->value.int_val & 0xffff) == device_id)
958 return &ids->value.attrib;
959 }
960
961 return NULL;
962 }
963
964 static int
965 acpi_video_get_device_type(struct acpi_video_bus *video,
966 unsigned long device_id)
967 {
968 struct acpi_video_enumerated_device *ids;
969 int i;
970
971 for (i = 0; i < video->attached_count; i++) {
972 ids = &video->attached_array[i];
973 if ((ids->value.int_val & 0xffff) == device_id)
974 return ids->value.int_val;
975 }
976
977 return 0;
978 }
979
980 static int
981 acpi_video_bus_get_one_device(struct acpi_device *device,
982 struct acpi_video_bus *video)
983 {
984 unsigned long long device_id;
985 int status, device_type;
986 struct acpi_video_device *data;
987 struct acpi_video_device_attrib* attribute;
988
989 if (!device || !video)
990 return -EINVAL;
991
992 status =
993 acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
994 if (ACPI_SUCCESS(status)) {
995
996 data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
997 if (!data)
998 return -ENOMEM;
999
1000 strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
1001 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
1002 device->driver_data = data;
1003
1004 data->device_id = device_id;
1005 data->video = video;
1006 data->dev = device;
1007
1008 attribute = acpi_video_get_device_attr(video, device_id);
1009
1010 if((attribute != NULL) && attribute->device_id_scheme) {
1011 switch (attribute->display_type) {
1012 case ACPI_VIDEO_DISPLAY_CRT:
1013 data->flags.crt = 1;
1014 break;
1015 case ACPI_VIDEO_DISPLAY_TV:
1016 data->flags.tvout = 1;
1017 break;
1018 case ACPI_VIDEO_DISPLAY_DVI:
1019 data->flags.dvi = 1;
1020 break;
1021 case ACPI_VIDEO_DISPLAY_LCD:
1022 data->flags.lcd = 1;
1023 break;
1024 default:
1025 data->flags.unknown = 1;
1026 break;
1027 }
1028 if(attribute->bios_can_detect)
1029 data->flags.bios = 1;
1030 } else {
1031 /* Check for legacy IDs */
1032 device_type = acpi_video_get_device_type(video,
1033 device_id);
1034 /* Ignore bits 16 and 18-20 */
1035 switch (device_type & 0xffe2ffff) {
1036 case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR:
1037 data->flags.crt = 1;
1038 break;
1039 case ACPI_VIDEO_DISPLAY_LEGACY_PANEL:
1040 data->flags.lcd = 1;
1041 break;
1042 case ACPI_VIDEO_DISPLAY_LEGACY_TV:
1043 data->flags.tvout = 1;
1044 break;
1045 default:
1046 data->flags.unknown = 1;
1047 }
1048 }
1049
1050 acpi_video_device_bind(video, data);
1051 acpi_video_device_find_cap(data);
1052
1053 status = acpi_install_notify_handler(device->handle,
1054 ACPI_DEVICE_NOTIFY,
1055 acpi_video_device_notify,
1056 data);
1057 if (ACPI_FAILURE(status)) {
1058 printk(KERN_ERR PREFIX
1059 "Error installing notify handler\n");
1060 if(data->brightness)
1061 kfree(data->brightness->levels);
1062 kfree(data->brightness);
1063 kfree(data);
1064 return -ENODEV;
1065 }
1066
1067 mutex_lock(&video->device_list_lock);
1068 list_add_tail(&data->entry, &video->video_device_list);
1069 mutex_unlock(&video->device_list_lock);
1070
1071 return 0;
1072 }
1073
1074 return -ENOENT;
1075 }
1076
1077 /*
1078 * Arg:
1079 * video : video bus device
1080 *
1081 * Return:
1082 * none
1083 *
1084 * Enumerate the video device list of the video bus,
1085 * bind the ids with the corresponding video devices
1086 * under the video bus.
1087 */
1088
1089 static void acpi_video_device_rebind(struct acpi_video_bus *video)
1090 {
1091 struct acpi_video_device *dev;
1092
1093 mutex_lock(&video->device_list_lock);
1094
1095 list_for_each_entry(dev, &video->video_device_list, entry)
1096 acpi_video_device_bind(video, dev);
1097
1098 mutex_unlock(&video->device_list_lock);
1099 }
1100
1101 /*
1102 * Arg:
1103 * video : video bus device
1104 * device : video output device under the video
1105 * bus
1106 *
1107 * Return:
1108 * none
1109 *
1110 * Bind the ids with the corresponding video devices
1111 * under the video bus.
1112 */
1113
1114 static void
1115 acpi_video_device_bind(struct acpi_video_bus *video,
1116 struct acpi_video_device *device)
1117 {
1118 struct acpi_video_enumerated_device *ids;
1119 int i;
1120
1121 for (i = 0; i < video->attached_count; i++) {
1122 ids = &video->attached_array[i];
1123 if (device->device_id == (ids->value.int_val & 0xffff)) {
1124 ids->bind_info = device;
1125 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "device_bind %d\n", i));
1126 }
1127 }
1128 }
1129
1130 /*
1131 * Arg:
1132 * video : video bus device
1133 *
1134 * Return:
1135 * < 0 : error
1136 *
1137 * Call _DOD to enumerate all devices attached to display adapter
1138 *
1139 */
1140
1141 static int acpi_video_device_enumerate(struct acpi_video_bus *video)
1142 {
1143 int status;
1144 int count;
1145 int i;
1146 struct acpi_video_enumerated_device *active_list;
1147 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1148 union acpi_object *dod = NULL;
1149 union acpi_object *obj;
1150
1151 status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
1152 if (!ACPI_SUCCESS(status)) {
1153 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD"));
1154 return status;
1155 }
1156
1157 dod = buffer.pointer;
1158 if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
1159 ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data"));
1160 status = -EFAULT;
1161 goto out;
1162 }
1163
1164 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d video heads in _DOD\n",
1165 dod->package.count));
1166
1167 active_list = kcalloc(1 + dod->package.count,
1168 sizeof(struct acpi_video_enumerated_device),
1169 GFP_KERNEL);
1170 if (!active_list) {
1171 status = -ENOMEM;
1172 goto out;
1173 }
1174
1175 count = 0;
1176 for (i = 0; i < dod->package.count; i++) {
1177 obj = &dod->package.elements[i];
1178
1179 if (obj->type != ACPI_TYPE_INTEGER) {
1180 printk(KERN_ERR PREFIX
1181 "Invalid _DOD data in element %d\n", i);
1182 continue;
1183 }
1184
1185 active_list[count].value.int_val = obj->integer.value;
1186 active_list[count].bind_info = NULL;
1187 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "dod element[%d] = %d\n", i,
1188 (int)obj->integer.value));
1189 count++;
1190 }
1191
1192 kfree(video->attached_array);
1193
1194 video->attached_array = active_list;
1195 video->attached_count = count;
1196
1197 out:
1198 kfree(buffer.pointer);
1199 return status;
1200 }
1201
1202 static int
1203 acpi_video_get_next_level(struct acpi_video_device *device,
1204 u32 level_current, u32 event)
1205 {
1206 int min, max, min_above, max_below, i, l, delta = 255;
1207 max = max_below = 0;
1208 min = min_above = 255;
1209 /* Find closest level to level_current */
1210 for (i = 2; i < device->brightness->count; i++) {
1211 l = device->brightness->levels[i];
1212 if (abs(l - level_current) < abs(delta)) {
1213 delta = l - level_current;
1214 if (!delta)
1215 break;
1216 }
1217 }
1218 /* Ajust level_current to closest available level */
1219 level_current += delta;
1220 for (i = 2; i < device->brightness->count; i++) {
1221 l = device->brightness->levels[i];
1222 if (l < min)
1223 min = l;
1224 if (l > max)
1225 max = l;
1226 if (l < min_above && l > level_current)
1227 min_above = l;
1228 if (l > max_below && l < level_current)
1229 max_below = l;
1230 }
1231
1232 switch (event) {
1233 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:
1234 return (level_current < max) ? min_above : min;
1235 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:
1236 return (level_current < max) ? min_above : max;
1237 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:
1238 return (level_current > min) ? max_below : min;
1239 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:
1240 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:
1241 return 0;
1242 default:
1243 return level_current;
1244 }
1245 }
1246
1247 static int
1248 acpi_video_switch_brightness(struct acpi_video_device *device, int event)
1249 {
1250 unsigned long long level_current, level_next;
1251 int result = -EINVAL;
1252
1253 /* no warning message if acpi_backlight=vendor is used */
1254 if (!acpi_video_backlight_support())
1255 return 0;
1256
1257 if (!device->brightness)
1258 goto out;
1259
1260 result = acpi_video_device_lcd_get_level_current(device,
1261 &level_current, 0);
1262 if (result)
1263 goto out;
1264
1265 level_next = acpi_video_get_next_level(device, level_current, event);
1266
1267 result = acpi_video_device_lcd_set_level(device, level_next);
1268
1269 if (!result)
1270 backlight_force_update(device->backlight,
1271 BACKLIGHT_UPDATE_HOTKEY);
1272
1273 out:
1274 if (result)
1275 printk(KERN_ERR PREFIX "Failed to switch the brightness\n");
1276
1277 return result;
1278 }
1279
1280 int acpi_video_get_edid(struct acpi_device *device, int type, int device_id,
1281 void **edid)
1282 {
1283 struct acpi_video_bus *video;
1284 struct acpi_video_device *video_device;
1285 union acpi_object *buffer = NULL;
1286 acpi_status status;
1287 int i, length;
1288
1289 if (!device || !acpi_driver_data(device))
1290 return -EINVAL;
1291
1292 video = acpi_driver_data(device);
1293
1294 for (i = 0; i < video->attached_count; i++) {
1295 video_device = video->attached_array[i].bind_info;
1296 length = 256;
1297
1298 if (!video_device)
1299 continue;
1300
1301 if (!video_device->cap._DDC)
1302 continue;
1303
1304 if (type) {
1305 switch (type) {
1306 case ACPI_VIDEO_DISPLAY_CRT:
1307 if (!video_device->flags.crt)
1308 continue;
1309 break;
1310 case ACPI_VIDEO_DISPLAY_TV:
1311 if (!video_device->flags.tvout)
1312 continue;
1313 break;
1314 case ACPI_VIDEO_DISPLAY_DVI:
1315 if (!video_device->flags.dvi)
1316 continue;
1317 break;
1318 case ACPI_VIDEO_DISPLAY_LCD:
1319 if (!video_device->flags.lcd)
1320 continue;
1321 break;
1322 }
1323 } else if (video_device->device_id != device_id) {
1324 continue;
1325 }
1326
1327 status = acpi_video_device_EDID(video_device, &buffer, length);
1328
1329 if (ACPI_FAILURE(status) || !buffer ||
1330 buffer->type != ACPI_TYPE_BUFFER) {
1331 length = 128;
1332 status = acpi_video_device_EDID(video_device, &buffer,
1333 length);
1334 if (ACPI_FAILURE(status) || !buffer ||
1335 buffer->type != ACPI_TYPE_BUFFER) {
1336 continue;
1337 }
1338 }
1339
1340 *edid = buffer->buffer.pointer;
1341 return length;
1342 }
1343
1344 return -ENODEV;
1345 }
1346 EXPORT_SYMBOL(acpi_video_get_edid);
1347
1348 static int
1349 acpi_video_bus_get_devices(struct acpi_video_bus *video,
1350 struct acpi_device *device)
1351 {
1352 int status = 0;
1353 struct acpi_device *dev;
1354
1355 acpi_video_device_enumerate(video);
1356
1357 list_for_each_entry(dev, &device->children, node) {
1358
1359 status = acpi_video_bus_get_one_device(dev, video);
1360 if (ACPI_FAILURE(status)) {
1361 printk(KERN_WARNING PREFIX
1362 "Cant attach device\n");
1363 continue;
1364 }
1365 }
1366 return status;
1367 }
1368
1369 static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
1370 {
1371 acpi_status status;
1372
1373 if (!device || !device->video)
1374 return -ENOENT;
1375
1376 status = acpi_remove_notify_handler(device->dev->handle,
1377 ACPI_DEVICE_NOTIFY,
1378 acpi_video_device_notify);
1379 if (ACPI_FAILURE(status)) {
1380 printk(KERN_WARNING PREFIX
1381 "Cant remove video notify handler\n");
1382 }
1383 if (device->backlight) {
1384 sysfs_remove_link(&device->backlight->dev.kobj, "device");
1385 backlight_device_unregister(device->backlight);
1386 device->backlight = NULL;
1387 }
1388 if (device->cooling_dev) {
1389 sysfs_remove_link(&device->dev->dev.kobj,
1390 "thermal_cooling");
1391 sysfs_remove_link(&device->cooling_dev->device.kobj,
1392 "device");
1393 thermal_cooling_device_unregister(device->cooling_dev);
1394 device->cooling_dev = NULL;
1395 }
1396
1397 return 0;
1398 }
1399
1400 static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
1401 {
1402 int status;
1403 struct acpi_video_device *dev, *next;
1404
1405 mutex_lock(&video->device_list_lock);
1406
1407 list_for_each_entry_safe(dev, next, &video->video_device_list, entry) {
1408
1409 status = acpi_video_bus_put_one_device(dev);
1410 if (ACPI_FAILURE(status))
1411 printk(KERN_WARNING PREFIX
1412 "hhuuhhuu bug in acpi video driver.\n");
1413
1414 if (dev->brightness) {
1415 kfree(dev->brightness->levels);
1416 kfree(dev->brightness);
1417 }
1418 list_del(&dev->entry);
1419 kfree(dev);
1420 }
1421
1422 mutex_unlock(&video->device_list_lock);
1423
1424 return 0;
1425 }
1426
1427 /* acpi_video interface */
1428
1429 static int acpi_video_bus_start_devices(struct acpi_video_bus *video)
1430 {
1431 return acpi_video_bus_DOS(video, 0, 0);
1432 }
1433
1434 static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
1435 {
1436 return acpi_video_bus_DOS(video, 0, 1);
1437 }
1438
1439 static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
1440 {
1441 struct acpi_video_bus *video = acpi_driver_data(device);
1442 struct input_dev *input;
1443 int keycode = 0;
1444
1445 if (!video)
1446 return;
1447
1448 input = video->input;
1449
1450 switch (event) {
1451 case ACPI_VIDEO_NOTIFY_SWITCH: /* User requested a switch,
1452 * most likely via hotkey. */
1453 acpi_bus_generate_proc_event(device, event, 0);
1454 keycode = KEY_SWITCHVIDEOMODE;
1455 break;
1456
1457 case ACPI_VIDEO_NOTIFY_PROBE: /* User plugged in or removed a video
1458 * connector. */
1459 acpi_video_device_enumerate(video);
1460 acpi_video_device_rebind(video);
1461 acpi_bus_generate_proc_event(device, event, 0);
1462 keycode = KEY_SWITCHVIDEOMODE;
1463 break;
1464
1465 case ACPI_VIDEO_NOTIFY_CYCLE: /* Cycle Display output hotkey pressed. */
1466 acpi_bus_generate_proc_event(device, event, 0);
1467 keycode = KEY_SWITCHVIDEOMODE;
1468 break;
1469 case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT: /* Next Display output hotkey pressed. */
1470 acpi_bus_generate_proc_event(device, event, 0);
1471 keycode = KEY_VIDEO_NEXT;
1472 break;
1473 case ACPI_VIDEO_NOTIFY_PREV_OUTPUT: /* previous Display output hotkey pressed. */
1474 acpi_bus_generate_proc_event(device, event, 0);
1475 keycode = KEY_VIDEO_PREV;
1476 break;
1477
1478 default:
1479 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1480 "Unsupported event [0x%x]\n", event));
1481 break;
1482 }
1483
1484 acpi_notifier_call_chain(device, event, 0);
1485
1486 if (keycode) {
1487 input_report_key(input, keycode, 1);
1488 input_sync(input);
1489 input_report_key(input, keycode, 0);
1490 input_sync(input);
1491 }
1492
1493 return;
1494 }
1495
1496 static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
1497 {
1498 struct acpi_video_device *video_device = data;
1499 struct acpi_device *device = NULL;
1500 struct acpi_video_bus *bus;
1501 struct input_dev *input;
1502 int keycode = 0;
1503
1504 if (!video_device)
1505 return;
1506
1507 device = video_device->dev;
1508 bus = video_device->video;
1509 input = bus->input;
1510
1511 switch (event) {
1512 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: /* Cycle 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_BRIGHTNESS_CYCLE;
1517 break;
1518 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: /* Increase 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_BRIGHTNESSUP;
1523 break;
1524 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: /* Decrease brightness */
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_BRIGHTNESSDOWN;
1529 break;
1530 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightnesss */
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_BRIGHTNESS_ZERO;
1535 break;
1536 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: /* display device off */
1537 if (brightness_switch_enabled)
1538 acpi_video_switch_brightness(video_device, event);
1539 acpi_bus_generate_proc_event(device, event, 0);
1540 keycode = KEY_DISPLAY_OFF;
1541 break;
1542 default:
1543 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1544 "Unsupported event [0x%x]\n", event));
1545 break;
1546 }
1547
1548 acpi_notifier_call_chain(device, event, 0);
1549
1550 if (keycode) {
1551 input_report_key(input, keycode, 1);
1552 input_sync(input);
1553 input_report_key(input, keycode, 0);
1554 input_sync(input);
1555 }
1556
1557 return;
1558 }
1559
1560 static int acpi_video_resume(struct notifier_block *nb,
1561 unsigned long val, void *ign)
1562 {
1563 struct acpi_video_bus *video;
1564 struct acpi_video_device *video_device;
1565 int i;
1566
1567 switch (val) {
1568 case PM_HIBERNATION_PREPARE:
1569 case PM_SUSPEND_PREPARE:
1570 case PM_RESTORE_PREPARE:
1571 return NOTIFY_DONE;
1572 }
1573
1574 video = container_of(nb, struct acpi_video_bus, pm_nb);
1575
1576 dev_info(&video->device->dev, "Restoring backlight state\n");
1577
1578 for (i = 0; i < video->attached_count; i++) {
1579 video_device = video->attached_array[i].bind_info;
1580 if (video_device && video_device->backlight)
1581 acpi_video_set_brightness(video_device->backlight);
1582 }
1583
1584 return NOTIFY_OK;
1585 }
1586
1587 static acpi_status
1588 acpi_video_bus_match(acpi_handle handle, u32 level, void *context,
1589 void **return_value)
1590 {
1591 struct acpi_device *device = context;
1592 struct acpi_device *sibling;
1593 int result;
1594
1595 if (handle == device->handle)
1596 return AE_CTRL_TERMINATE;
1597
1598 result = acpi_bus_get_device(handle, &sibling);
1599 if (result)
1600 return AE_OK;
1601
1602 if (!strcmp(acpi_device_name(sibling), ACPI_VIDEO_BUS_NAME))
1603 return AE_ALREADY_EXISTS;
1604
1605 return AE_OK;
1606 }
1607
1608 static int instance;
1609
1610 static int acpi_video_bus_add(struct acpi_device *device)
1611 {
1612 struct acpi_video_bus *video;
1613 struct input_dev *input;
1614 int error;
1615 acpi_status status;
1616
1617 status = acpi_walk_namespace(ACPI_TYPE_DEVICE,
1618 device->parent->handle, 1,
1619 acpi_video_bus_match, NULL,
1620 device, NULL);
1621 if (status == AE_ALREADY_EXISTS) {
1622 printk(KERN_WARNING FW_BUG
1623 "Duplicate ACPI video bus devices for the"
1624 " same VGA controller, please try module "
1625 "parameter \"video.allow_duplicates=1\""
1626 "if the current driver doesn't work.\n");
1627 if (!allow_duplicates)
1628 return -ENODEV;
1629 }
1630
1631 video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
1632 if (!video)
1633 return -ENOMEM;
1634
1635 /* a hack to fix the duplicate name "VID" problem on T61 */
1636 if (!strcmp(device->pnp.bus_id, "VID")) {
1637 if (instance)
1638 device->pnp.bus_id[3] = '0' + instance;
1639 instance ++;
1640 }
1641 /* a hack to fix the duplicate name "VGA" problem on Pa 3553 */
1642 if (!strcmp(device->pnp.bus_id, "VGA")) {
1643 if (instance)
1644 device->pnp.bus_id[3] = '0' + instance;
1645 instance++;
1646 }
1647
1648 video->device = device;
1649 strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
1650 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
1651 device->driver_data = video;
1652
1653 acpi_video_bus_find_cap(video);
1654 error = acpi_video_bus_check(video);
1655 if (error)
1656 goto err_free_video;
1657
1658 mutex_init(&video->device_list_lock);
1659 INIT_LIST_HEAD(&video->video_device_list);
1660
1661 acpi_video_bus_get_devices(video, device);
1662 acpi_video_bus_start_devices(video);
1663
1664 video->input = input = input_allocate_device();
1665 if (!input) {
1666 error = -ENOMEM;
1667 goto err_stop_video;
1668 }
1669
1670 snprintf(video->phys, sizeof(video->phys),
1671 "%s/video/input0", acpi_device_hid(video->device));
1672
1673 input->name = acpi_device_name(video->device);
1674 input->phys = video->phys;
1675 input->id.bustype = BUS_HOST;
1676 input->id.product = 0x06;
1677 input->dev.parent = &device->dev;
1678 input->evbit[0] = BIT(EV_KEY);
1679 set_bit(KEY_SWITCHVIDEOMODE, input->keybit);
1680 set_bit(KEY_VIDEO_NEXT, input->keybit);
1681 set_bit(KEY_VIDEO_PREV, input->keybit);
1682 set_bit(KEY_BRIGHTNESS_CYCLE, input->keybit);
1683 set_bit(KEY_BRIGHTNESSUP, input->keybit);
1684 set_bit(KEY_BRIGHTNESSDOWN, input->keybit);
1685 set_bit(KEY_BRIGHTNESS_ZERO, input->keybit);
1686 set_bit(KEY_DISPLAY_OFF, input->keybit);
1687
1688 error = input_register_device(input);
1689 if (error)
1690 goto err_free_input_dev;
1691
1692 printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s rom: %s post: %s)\n",
1693 ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
1694 video->flags.multihead ? "yes" : "no",
1695 video->flags.rom ? "yes" : "no",
1696 video->flags.post ? "yes" : "no");
1697
1698 video->pm_nb.notifier_call = acpi_video_resume;
1699 video->pm_nb.priority = 0;
1700 register_pm_notifier(&video->pm_nb);
1701
1702 return 0;
1703
1704 err_free_input_dev:
1705 input_free_device(input);
1706 err_stop_video:
1707 acpi_video_bus_stop_devices(video);
1708 acpi_video_bus_put_devices(video);
1709 kfree(video->attached_array);
1710 err_free_video:
1711 kfree(video);
1712 device->driver_data = NULL;
1713
1714 return error;
1715 }
1716
1717 static int acpi_video_bus_remove(struct acpi_device *device, int type)
1718 {
1719 struct acpi_video_bus *video = NULL;
1720
1721
1722 if (!device || !acpi_driver_data(device))
1723 return -EINVAL;
1724
1725 video = acpi_driver_data(device);
1726
1727 unregister_pm_notifier(&video->pm_nb);
1728
1729 acpi_video_bus_stop_devices(video);
1730 acpi_video_bus_put_devices(video);
1731
1732 input_unregister_device(video->input);
1733 kfree(video->attached_array);
1734 kfree(video);
1735
1736 return 0;
1737 }
1738
1739 static int __init intel_opregion_present(void)
1740 {
1741 #if defined(CONFIG_DRM_I915) || defined(CONFIG_DRM_I915_MODULE)
1742 struct pci_dev *dev = NULL;
1743 u32 address;
1744
1745 for_each_pci_dev(dev) {
1746 if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
1747 continue;
1748 if (dev->vendor != PCI_VENDOR_ID_INTEL)
1749 continue;
1750 pci_read_config_dword(dev, 0xfc, &address);
1751 if (!address)
1752 continue;
1753 return 1;
1754 }
1755 #endif
1756 return 0;
1757 }
1758
1759 int acpi_video_register(void)
1760 {
1761 int result = 0;
1762 if (register_count) {
1763 /*
1764 * if the function of acpi_video_register is already called,
1765 * don't register the acpi_vide_bus again and return no error.
1766 */
1767 return 0;
1768 }
1769
1770 result = acpi_bus_register_driver(&acpi_video_bus);
1771 if (result < 0)
1772 return -ENODEV;
1773
1774 /*
1775 * When the acpi_video_bus is loaded successfully, increase
1776 * the counter reference.
1777 */
1778 register_count = 1;
1779
1780 return 0;
1781 }
1782 EXPORT_SYMBOL(acpi_video_register);
1783
1784 void acpi_video_unregister(void)
1785 {
1786 if (!register_count) {
1787 /*
1788 * If the acpi video bus is already unloaded, don't
1789 * unload it again and return directly.
1790 */
1791 return;
1792 }
1793 acpi_bus_unregister_driver(&acpi_video_bus);
1794
1795 register_count = 0;
1796
1797 return;
1798 }
1799 EXPORT_SYMBOL(acpi_video_unregister);
1800
1801 /*
1802 * This is kind of nasty. Hardware using Intel chipsets may require
1803 * the video opregion code to be run first in order to initialise
1804 * state before any ACPI video calls are made. To handle this we defer
1805 * registration of the video class until the opregion code has run.
1806 */
1807
1808 static int __init acpi_video_init(void)
1809 {
1810 dmi_check_system(video_dmi_table);
1811
1812 if (intel_opregion_present())
1813 return 0;
1814
1815 return acpi_video_register();
1816 }
1817
1818 static void __exit acpi_video_exit(void)
1819 {
1820 acpi_video_unregister();
1821
1822 return;
1823 }
1824
1825 module_init(acpi_video_init);
1826 module_exit(acpi_video_exit);
kernel-based virtual machine