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