?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.20.7
[linux/fpc-iii.git] / drivers / acpi / video.c
blob3d54680d0333c34464b1df9e5fe2631b63050079
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/proc_fs.h>
33 #include <linux/seq_file.h>
34
35 #include <asm/uaccess.h>
36
37 #include <acpi/acpi_bus.h>
38 #include <acpi/acpi_drivers.h>
39
40 #define ACPI_VIDEO_COMPONENT 0x08000000
41 #define ACPI_VIDEO_CLASS "video"
42 #define ACPI_VIDEO_DRIVER_NAME "ACPI Video Driver"
43 #define ACPI_VIDEO_BUS_NAME "Video Bus"
44 #define ACPI_VIDEO_DEVICE_NAME "Video Device"
45 #define ACPI_VIDEO_NOTIFY_SWITCH 0x80
46 #define ACPI_VIDEO_NOTIFY_PROBE 0x81
47 #define ACPI_VIDEO_NOTIFY_CYCLE 0x82
48 #define ACPI_VIDEO_NOTIFY_NEXT_OUTPUT 0x83
49 #define ACPI_VIDEO_NOTIFY_PREV_OUTPUT 0x84
50
51 #define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS 0x85
52 #define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS 0x86
53 #define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS 0x87
54 #define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS 0x88
55 #define ACPI_VIDEO_NOTIFY_DISPLAY_OFF 0x89
56
57 #define ACPI_VIDEO_HEAD_INVALID (~0u - 1)
58 #define ACPI_VIDEO_HEAD_END (~0u)
59
60 #define _COMPONENT ACPI_VIDEO_COMPONENT
61 ACPI_MODULE_NAME("acpi_video")
62
63 MODULE_AUTHOR("Bruno Ducrot");
64 MODULE_DESCRIPTION(ACPI_VIDEO_DRIVER_NAME);
65 MODULE_LICENSE("GPL");
66
67 static int acpi_video_bus_add(struct acpi_device *device);
68 static int acpi_video_bus_remove(struct acpi_device *device, int type);
69 static int acpi_video_bus_match(struct acpi_device *device,
70 struct acpi_driver *driver);
71
72 static struct acpi_driver acpi_video_bus = {
73 .name = ACPI_VIDEO_DRIVER_NAME,
74 .class = ACPI_VIDEO_CLASS,
75 .ops = {
76 .add = acpi_video_bus_add,
77 .remove = acpi_video_bus_remove,
78 .match = acpi_video_bus_match,
79 },
80 };
81
82 struct acpi_video_bus_flags {
83 u8 multihead:1; /* can switch video heads */
84 u8 rom:1; /* can retrieve a video rom */
85 u8 post:1; /* can configure the head to */
86 u8 reserved:5;
87 };
88
89 struct acpi_video_bus_cap {
90 u8 _DOS:1; /*Enable/Disable output switching */
91 u8 _DOD:1; /*Enumerate all devices attached to display adapter */
92 u8 _ROM:1; /*Get ROM Data */
93 u8 _GPD:1; /*Get POST Device */
94 u8 _SPD:1; /*Set POST Device */
95 u8 _VPO:1; /*Video POST Options */
96 u8 reserved:2;
97 };
98
99 struct acpi_video_device_attrib {
100 u32 display_index:4; /* A zero-based instance of the Display */
101 u32 display_port_attachment:4; /*This field differenates displays type */
102 u32 display_type:4; /*Describe the specific type in use */
103 u32 vendor_specific:4; /*Chipset Vendor Specifi */
104 u32 bios_can_detect:1; /*BIOS can detect the device */
105 u32 depend_on_vga:1; /*Non-VGA output device whose power is related to
106 the VGA device. */
107 u32 pipe_id:3; /*For VGA multiple-head devices. */
108 u32 reserved:10; /*Must be 0 */
109 u32 device_id_scheme:1; /*Device ID Scheme */
110 };
111
112 struct acpi_video_enumerated_device {
113 union {
114 u32 int_val;
115 struct acpi_video_device_attrib attrib;
116 } value;
117 struct acpi_video_device *bind_info;
118 };
119
120 struct acpi_video_bus {
121 struct acpi_device *device;
122 u8 dos_setting;
123 struct acpi_video_enumerated_device *attached_array;
124 u8 attached_count;
125 struct acpi_video_bus_cap cap;
126 struct acpi_video_bus_flags flags;
127 struct semaphore sem;
128 struct list_head video_device_list;
129 struct proc_dir_entry *dir;
130 };
131
132 struct acpi_video_device_flags {
133 u8 crt:1;
134 u8 lcd:1;
135 u8 tvout:1;
136 u8 bios:1;
137 u8 unknown:1;
138 u8 reserved:3;
139 };
140
141 struct acpi_video_device_cap {
142 u8 _ADR:1; /*Return the unique ID */
143 u8 _BCL:1; /*Query list of brightness control levels supported */
144 u8 _BCM:1; /*Set the brightness level */
145 u8 _DDC:1; /*Return the EDID for this device */
146 u8 _DCS:1; /*Return status of output device */
147 u8 _DGS:1; /*Query graphics state */
148 u8 _DSS:1; /*Device state set */
149 u8 _reserved:1;
150 };
151
152 struct acpi_video_device_brightness {
153 int curr;
154 int count;
155 int *levels;
156 };
157
158 struct acpi_video_device {
159 unsigned long device_id;
160 struct acpi_video_device_flags flags;
161 struct acpi_video_device_cap cap;
162 struct list_head entry;
163 struct acpi_video_bus *video;
164 struct acpi_device *dev;
165 struct acpi_video_device_brightness *brightness;
166 };
167
168 /* bus */
169 static int acpi_video_bus_info_open_fs(struct inode *inode, struct file *file);
170 static struct file_operations acpi_video_bus_info_fops = {
171 .open = acpi_video_bus_info_open_fs,
172 .read = seq_read,
173 .llseek = seq_lseek,
174 .release = single_release,
175 };
176
177 static int acpi_video_bus_ROM_open_fs(struct inode *inode, struct file *file);
178 static struct file_operations acpi_video_bus_ROM_fops = {
179 .open = acpi_video_bus_ROM_open_fs,
180 .read = seq_read,
181 .llseek = seq_lseek,
182 .release = single_release,
183 };
184
185 static int acpi_video_bus_POST_info_open_fs(struct inode *inode,
186 struct file *file);
187 static struct file_operations acpi_video_bus_POST_info_fops = {
188 .open = acpi_video_bus_POST_info_open_fs,
189 .read = seq_read,
190 .llseek = seq_lseek,
191 .release = single_release,
192 };
193
194 static int acpi_video_bus_POST_open_fs(struct inode *inode, struct file *file);
195 static struct file_operations acpi_video_bus_POST_fops = {
196 .open = acpi_video_bus_POST_open_fs,
197 .read = seq_read,
198 .llseek = seq_lseek,
199 .release = single_release,
200 };
201
202 static int acpi_video_bus_DOS_open_fs(struct inode *inode, struct file *file);
203 static struct file_operations acpi_video_bus_DOS_fops = {
204 .open = acpi_video_bus_DOS_open_fs,
205 .read = seq_read,
206 .llseek = seq_lseek,
207 .release = single_release,
208 };
209
210 /* device */
211 static int acpi_video_device_info_open_fs(struct inode *inode,
212 struct file *file);
213 static struct file_operations acpi_video_device_info_fops = {
214 .open = acpi_video_device_info_open_fs,
215 .read = seq_read,
216 .llseek = seq_lseek,
217 .release = single_release,
218 };
219
220 static int acpi_video_device_state_open_fs(struct inode *inode,
221 struct file *file);
222 static struct file_operations acpi_video_device_state_fops = {
223 .open = acpi_video_device_state_open_fs,
224 .read = seq_read,
225 .llseek = seq_lseek,
226 .release = single_release,
227 };
228
229 static int acpi_video_device_brightness_open_fs(struct inode *inode,
230 struct file *file);
231 static struct file_operations acpi_video_device_brightness_fops = {
232 .open = acpi_video_device_brightness_open_fs,
233 .read = seq_read,
234 .llseek = seq_lseek,
235 .release = single_release,
236 };
237
238 static int acpi_video_device_EDID_open_fs(struct inode *inode,
239 struct file *file);
240 static struct file_operations acpi_video_device_EDID_fops = {
241 .open = acpi_video_device_EDID_open_fs,
242 .read = seq_read,
243 .llseek = seq_lseek,
244 .release = single_release,
245 };
246
247 static char device_decode[][30] = {
248 "motherboard VGA device",
249 "PCI VGA device",
250 "AGP VGA device",
251 "UNKNOWN",
252 };
253
254 static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data);
255 static void acpi_video_device_rebind(struct acpi_video_bus *video);
256 static void acpi_video_device_bind(struct acpi_video_bus *video,
257 struct acpi_video_device *device);
258 static int acpi_video_device_enumerate(struct acpi_video_bus *video);
259 static int acpi_video_switch_output(struct acpi_video_bus *video, int event);
260 static int acpi_video_get_next_level(struct acpi_video_device *device,
261 u32 level_current, u32 event);
262 static void acpi_video_switch_brightness(struct acpi_video_device *device,
263 int event);
264
265 /* --------------------------------------------------------------------------
266 Video Management
267 -------------------------------------------------------------------------- */
268
269 /* device */
270
271 static int
272 acpi_video_device_query(struct acpi_video_device *device, unsigned long *state)
273 {
274 int status;
275
276 status = acpi_evaluate_integer(device->dev->handle, "_DGS", NULL, state);
277
278 return status;
279 }
280
281 static int
282 acpi_video_device_get_state(struct acpi_video_device *device,
283 unsigned long *state)
284 {
285 int status;
286
287 status = acpi_evaluate_integer(device->dev->handle, "_DCS", NULL, state);
288
289 return status;
290 }
291
292 static int
293 acpi_video_device_set_state(struct acpi_video_device *device, int state)
294 {
295 int status;
296 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
297 struct acpi_object_list args = { 1, &arg0 };
298 unsigned long ret;
299
300
301 arg0.integer.value = state;
302 status = acpi_evaluate_integer(device->dev->handle, "_DSS", &args, &ret);
303
304 return status;
305 }
306
307 static int
308 acpi_video_device_lcd_query_levels(struct acpi_video_device *device,
309 union acpi_object **levels)
310 {
311 int status;
312 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
313 union acpi_object *obj;
314
315
316 *levels = NULL;
317
318 status = acpi_evaluate_object(device->dev->handle, "_BCL", NULL, &buffer);
319 if (!ACPI_SUCCESS(status))
320 return status;
321 obj = (union acpi_object *)buffer.pointer;
322 if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
323 printk(KERN_ERR PREFIX "Invalid _BCL data\n");
324 status = -EFAULT;
325 goto err;
326 }
327
328 *levels = obj;
329
330 return 0;
331
332 err:
333 kfree(buffer.pointer);
334
335 return status;
336 }
337
338 static int
339 acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level)
340 {
341 int status;
342 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
343 struct acpi_object_list args = { 1, &arg0 };
344
345
346 arg0.integer.value = level;
347 status = acpi_evaluate_object(device->dev->handle, "_BCM", &args, NULL);
348
349 printk(KERN_DEBUG "set_level status: %x\n", status);
350 return status;
351 }
352
353 static int
354 acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
355 unsigned long *level)
356 {
357 int status;
358
359 status = acpi_evaluate_integer(device->dev->handle, "_BQC", NULL, level);
360
361 return status;
362 }
363
364 static int
365 acpi_video_device_EDID(struct acpi_video_device *device,
366 union acpi_object **edid, ssize_t length)
367 {
368 int status;
369 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
370 union acpi_object *obj;
371 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
372 struct acpi_object_list args = { 1, &arg0 };
373
374
375 *edid = NULL;
376
377 if (!device)
378 return -ENODEV;
379 if (length == 128)
380 arg0.integer.value = 1;
381 else if (length == 256)
382 arg0.integer.value = 2;
383 else
384 return -EINVAL;
385
386 status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer);
387 if (ACPI_FAILURE(status))
388 return -ENODEV;
389
390 obj = buffer.pointer;
391
392 if (obj && obj->type == ACPI_TYPE_BUFFER)
393 *edid = obj;
394 else {
395 printk(KERN_ERR PREFIX "Invalid _DDC data\n");
396 status = -EFAULT;
397 kfree(obj);
398 }
399
400 return status;
401 }
402
403 /* bus */
404
405 static int
406 acpi_video_bus_set_POST(struct acpi_video_bus *video, unsigned long option)
407 {
408 int status;
409 unsigned long tmp;
410 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
411 struct acpi_object_list args = { 1, &arg0 };
412
413
414 arg0.integer.value = option;
415
416 status = acpi_evaluate_integer(video->device->handle, "_SPD", &args, &tmp);
417 if (ACPI_SUCCESS(status))
418 status = tmp ? (-EINVAL) : (AE_OK);
419
420 return status;
421 }
422
423 static int
424 acpi_video_bus_get_POST(struct acpi_video_bus *video, unsigned long *id)
425 {
426 int status;
427
428 status = acpi_evaluate_integer(video->device->handle, "_GPD", NULL, id);
429
430 return status;
431 }
432
433 static int
434 acpi_video_bus_POST_options(struct acpi_video_bus *video,
435 unsigned long *options)
436 {
437 int status;
438
439 status = acpi_evaluate_integer(video->device->handle, "_VPO", NULL, options);
440 *options &= 3;
441
442 return status;
443 }
444
445 /*
446 * Arg:
447 * video : video bus device pointer
448 * bios_flag :
449 * 0. The system BIOS should NOT automatically switch(toggle)
450 * the active display output.
451 * 1. The system BIOS should automatically switch (toggle) the
452 * active display output. No swich event.
453 * 2. The _DGS value should be locked.
454 * 3. The system BIOS should not automatically switch (toggle) the
455 * active display output, but instead generate the display switch
456 * event notify code.
457 * lcd_flag :
458 * 0. The system BIOS should automatically control the brightness level
459 * of the LCD, when the power changes from AC to DC
460 * 1. The system BIOS should NOT automatically control the brightness
461 * level of the LCD, when the power changes from AC to DC.
462 * Return Value:
463 * -1 wrong arg.
464 */
465
466 static int
467 acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
468 {
469 acpi_integer status = 0;
470 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
471 struct acpi_object_list args = { 1, &arg0 };
472
473
474 if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1) {
475 status = -1;
476 goto Failed;
477 }
478 arg0.integer.value = (lcd_flag << 2) | bios_flag;
479 video->dos_setting = arg0.integer.value;
480 acpi_evaluate_object(video->device->handle, "_DOS", &args, NULL);
481
482 Failed:
483 return status;
484 }
485
486 /*
487 * Arg:
488 * device : video output device (LCD, CRT, ..)
489 *
490 * Return Value:
491 * None
492 *
493 * Find out all required AML method defined under the output
494 * device.
495 */
496
497 static void acpi_video_device_find_cap(struct acpi_video_device *device)
498 {
499 acpi_integer status;
500 acpi_handle h_dummy1;
501 int i;
502 union acpi_object *obj = NULL;
503 struct acpi_video_device_brightness *br = NULL;
504
505
506 memset(&device->cap, 0, 4);
507
508 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_ADR", &h_dummy1))) {
509 device->cap._ADR = 1;
510 }
511 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCL", &h_dummy1))) {
512 device->cap._BCL = 1;
513 }
514 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCM", &h_dummy1))) {
515 device->cap._BCM = 1;
516 }
517 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DDC", &h_dummy1))) {
518 device->cap._DDC = 1;
519 }
520 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DCS", &h_dummy1))) {
521 device->cap._DCS = 1;
522 }
523 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DGS", &h_dummy1))) {
524 device->cap._DGS = 1;
525 }
526 if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DSS", &h_dummy1))) {
527 device->cap._DSS = 1;
528 }
529
530 status = acpi_video_device_lcd_query_levels(device, &obj);
531
532 if (obj && obj->type == ACPI_TYPE_PACKAGE && obj->package.count >= 2) {
533 int count = 0;
534 union acpi_object *o;
535
536 br = kzalloc(sizeof(*br), GFP_KERNEL);
537 if (!br) {
538 printk(KERN_ERR "can't allocate memory\n");
539 } else {
540 br->levels = kmalloc(obj->package.count *
541 sizeof *(br->levels), GFP_KERNEL);
542 if (!br->levels)
543 goto out;
544
545 for (i = 0; i < obj->package.count; i++) {
546 o = (union acpi_object *)&obj->package.
547 elements[i];
548 if (o->type != ACPI_TYPE_INTEGER) {
549 printk(KERN_ERR PREFIX "Invalid data\n");
550 continue;
551 }
552 br->levels[count] = (u32) o->integer.value;
553 count++;
554 }
555 out:
556 if (count < 2) {
557 kfree(br->levels);
558 kfree(br);
559 } else {
560 br->count = count;
561 device->brightness = br;
562 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
563 "found %d brightness levels\n",
564 count));
565 }
566 }
567 }
568
569 kfree(obj);
570
571 return;
572 }
573
574 /*
575 * Arg:
576 * device : video output device (VGA)
577 *
578 * Return Value:
579 * None
580 *
581 * Find out all required AML method defined under the video bus device.
582 */
583
584 static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
585 {
586 acpi_handle h_dummy1;
587
588 memset(&video->cap, 0, 4);
589 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOS", &h_dummy1))) {
590 video->cap._DOS = 1;
591 }
592 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOD", &h_dummy1))) {
593 video->cap._DOD = 1;
594 }
595 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_ROM", &h_dummy1))) {
596 video->cap._ROM = 1;
597 }
598 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_GPD", &h_dummy1))) {
599 video->cap._GPD = 1;
600 }
601 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_SPD", &h_dummy1))) {
602 video->cap._SPD = 1;
603 }
604 if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_VPO", &h_dummy1))) {
605 video->cap._VPO = 1;
606 }
607 }
608
609 /*
610 * Check whether the video bus device has required AML method to
611 * support the desired features
612 */
613
614 static int acpi_video_bus_check(struct acpi_video_bus *video)
615 {
616 acpi_status status = -ENOENT;
617
618
619 if (!video)
620 return -EINVAL;
621
622 /* Since there is no HID, CID and so on for VGA driver, we have
623 * to check well known required nodes.
624 */
625
626 /* Does this device able to support video switching ? */
627 if (video->cap._DOS) {
628 video->flags.multihead = 1;
629 status = 0;
630 }
631
632 /* Does this device able to retrieve a retrieve a video ROM ? */
633 if (video->cap._ROM) {
634 video->flags.rom = 1;
635 status = 0;
636 }
637
638 /* Does this device able to configure which video device to POST ? */
639 if (video->cap._GPD && video->cap._SPD && video->cap._VPO) {
640 video->flags.post = 1;
641 status = 0;
642 }
643
644 return status;
645 }
646
647 /* --------------------------------------------------------------------------
648 FS Interface (/proc)
649 -------------------------------------------------------------------------- */
650
651 static struct proc_dir_entry *acpi_video_dir;
652
653 /* video devices */
654
655 static int acpi_video_device_info_seq_show(struct seq_file *seq, void *offset)
656 {
657 struct acpi_video_device *dev = seq->private;
658
659
660 if (!dev)
661 goto end;
662
663 seq_printf(seq, "device_id: 0x%04x\n", (u32) dev->device_id);
664 seq_printf(seq, "type: ");
665 if (dev->flags.crt)
666 seq_printf(seq, "CRT\n");
667 else if (dev->flags.lcd)
668 seq_printf(seq, "LCD\n");
669 else if (dev->flags.tvout)
670 seq_printf(seq, "TVOUT\n");
671 else
672 seq_printf(seq, "UNKNOWN\n");
673
674 seq_printf(seq, "known by bios: %s\n", dev->flags.bios ? "yes" : "no");
675
676 end:
677 return 0;
678 }
679
680 static int
681 acpi_video_device_info_open_fs(struct inode *inode, struct file *file)
682 {
683 return single_open(file, acpi_video_device_info_seq_show,
684 PDE(inode)->data);
685 }
686
687 static int acpi_video_device_state_seq_show(struct seq_file *seq, void *offset)
688 {
689 int status;
690 struct acpi_video_device *dev = seq->private;
691 unsigned long state;
692
693
694 if (!dev)
695 goto end;
696
697 status = acpi_video_device_get_state(dev, &state);
698 seq_printf(seq, "state: ");
699 if (ACPI_SUCCESS(status))
700 seq_printf(seq, "0x%02lx\n", state);
701 else
702 seq_printf(seq, "<not supported>\n");
703
704 status = acpi_video_device_query(dev, &state);
705 seq_printf(seq, "query: ");
706 if (ACPI_SUCCESS(status))
707 seq_printf(seq, "0x%02lx\n", state);
708 else
709 seq_printf(seq, "<not supported>\n");
710
711 end:
712 return 0;
713 }
714
715 static int
716 acpi_video_device_state_open_fs(struct inode *inode, struct file *file)
717 {
718 return single_open(file, acpi_video_device_state_seq_show,
719 PDE(inode)->data);
720 }
721
722 static ssize_t
723 acpi_video_device_write_state(struct file *file,
724 const char __user * buffer,
725 size_t count, loff_t * data)
726 {
727 int status;
728 struct seq_file *m = file->private_data;
729 struct acpi_video_device *dev = m->private;
730 char str[12] = { 0 };
731 u32 state = 0;
732
733
734 if (!dev || count + 1 > sizeof str)
735 return -EINVAL;
736
737 if (copy_from_user(str, buffer, count))
738 return -EFAULT;
739
740 str[count] = 0;
741 state = simple_strtoul(str, NULL, 0);
742 state &= ((1ul << 31) | (1ul << 30) | (1ul << 0));
743
744 status = acpi_video_device_set_state(dev, state);
745
746 if (status)
747 return -EFAULT;
748
749 return count;
750 }
751
752 static int
753 acpi_video_device_brightness_seq_show(struct seq_file *seq, void *offset)
754 {
755 struct acpi_video_device *dev = seq->private;
756 int i;
757
758
759 if (!dev || !dev->brightness) {
760 seq_printf(seq, "<not supported>\n");
761 return 0;
762 }
763
764 seq_printf(seq, "levels: ");
765 for (i = 0; i < dev->brightness->count; i++)
766 seq_printf(seq, " %d", dev->brightness->levels[i]);
767 seq_printf(seq, "\ncurrent: %d\n", dev->brightness->curr);
768
769 return 0;
770 }
771
772 static int
773 acpi_video_device_brightness_open_fs(struct inode *inode, struct file *file)
774 {
775 return single_open(file, acpi_video_device_brightness_seq_show,
776 PDE(inode)->data);
777 }
778
779 static ssize_t
780 acpi_video_device_write_brightness(struct file *file,
781 const char __user * buffer,
782 size_t count, loff_t * data)
783 {
784 struct seq_file *m = file->private_data;
785 struct acpi_video_device *dev = m->private;
786 char str[4] = { 0 };
787 unsigned int level = 0;
788 int i;
789
790
791 if (!dev || !dev->brightness || count + 1 > sizeof str)
792 return -EINVAL;
793
794 if (copy_from_user(str, buffer, count))
795 return -EFAULT;
796
797 str[count] = 0;
798 level = simple_strtoul(str, NULL, 0);
799
800 if (level > 100)
801 return -EFAULT;
802
803 /* validate though the list of available levels */
804 for (i = 0; i < dev->brightness->count; i++)
805 if (level == dev->brightness->levels[i]) {
806 if (ACPI_SUCCESS
807 (acpi_video_device_lcd_set_level(dev, level)))
808 dev->brightness->curr = level;
809 break;
810 }
811
812 return count;
813 }
814
815 static int acpi_video_device_EDID_seq_show(struct seq_file *seq, void *offset)
816 {
817 struct acpi_video_device *dev = seq->private;
818 int status;
819 int i;
820 union acpi_object *edid = NULL;
821
822
823 if (!dev)
824 goto out;
825
826 status = acpi_video_device_EDID(dev, &edid, 128);
827 if (ACPI_FAILURE(status)) {
828 status = acpi_video_device_EDID(dev, &edid, 256);
829 }
830
831 if (ACPI_FAILURE(status)) {
832 goto out;
833 }
834
835 if (edid && edid->type == ACPI_TYPE_BUFFER) {
836 for (i = 0; i < edid->buffer.length; i++)
837 seq_putc(seq, edid->buffer.pointer[i]);
838 }
839
840 out:
841 if (!edid)
842 seq_printf(seq, "<not supported>\n");
843 else
844 kfree(edid);
845
846 return 0;
847 }
848
849 static int
850 acpi_video_device_EDID_open_fs(struct inode *inode, struct file *file)
851 {
852 return single_open(file, acpi_video_device_EDID_seq_show,
853 PDE(inode)->data);
854 }
855
856 static int acpi_video_device_add_fs(struct acpi_device *device)
857 {
858 struct proc_dir_entry *entry = NULL;
859 struct acpi_video_device *vid_dev;
860
861
862 if (!device)
863 return -ENODEV;
864
865 vid_dev = acpi_driver_data(device);
866 if (!vid_dev)
867 return -ENODEV;
868
869 if (!acpi_device_dir(device)) {
870 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
871 vid_dev->video->dir);
872 if (!acpi_device_dir(device))
873 return -ENODEV;
874 acpi_device_dir(device)->owner = THIS_MODULE;
875 }
876
877 /* 'info' [R] */
878 entry = create_proc_entry("info", S_IRUGO, acpi_device_dir(device));
879 if (!entry)
880 return -ENODEV;
881 else {
882 entry->proc_fops = &acpi_video_device_info_fops;
883 entry->data = acpi_driver_data(device);
884 entry->owner = THIS_MODULE;
885 }
886
887 /* 'state' [R/W] */
888 entry =
889 create_proc_entry("state", S_IFREG | S_IRUGO | S_IWUSR,
890 acpi_device_dir(device));
891 if (!entry)
892 return -ENODEV;
893 else {
894 acpi_video_device_state_fops.write = acpi_video_device_write_state;
895 entry->proc_fops = &acpi_video_device_state_fops;
896 entry->data = acpi_driver_data(device);
897 entry->owner = THIS_MODULE;
898 }
899
900 /* 'brightness' [R/W] */
901 entry =
902 create_proc_entry("brightness", S_IFREG | S_IRUGO | S_IWUSR,
903 acpi_device_dir(device));
904 if (!entry)
905 return -ENODEV;
906 else {
907 acpi_video_device_brightness_fops.write = acpi_video_device_write_brightness;
908 entry->proc_fops = &acpi_video_device_brightness_fops;
909 entry->data = acpi_driver_data(device);
910 entry->owner = THIS_MODULE;
911 }
912
913 /* 'EDID' [R] */
914 entry = create_proc_entry("EDID", S_IRUGO, acpi_device_dir(device));
915 if (!entry)
916 return -ENODEV;
917 else {
918 entry->proc_fops = &acpi_video_device_EDID_fops;
919 entry->data = acpi_driver_data(device);
920 entry->owner = THIS_MODULE;
921 }
922
923 return 0;
924 }
925
926 static int acpi_video_device_remove_fs(struct acpi_device *device)
927 {
928 struct acpi_video_device *vid_dev;
929
930 vid_dev = acpi_driver_data(device);
931 if (!vid_dev || !vid_dev->video || !vid_dev->video->dir)
932 return -ENODEV;
933
934 if (acpi_device_dir(device)) {
935 remove_proc_entry("info", acpi_device_dir(device));
936 remove_proc_entry("state", acpi_device_dir(device));
937 remove_proc_entry("brightness", acpi_device_dir(device));
938 remove_proc_entry("EDID", acpi_device_dir(device));
939 remove_proc_entry(acpi_device_bid(device), vid_dev->video->dir);
940 acpi_device_dir(device) = NULL;
941 }
942
943 return 0;
944 }
945
946 /* video bus */
947 static int acpi_video_bus_info_seq_show(struct seq_file *seq, void *offset)
948 {
949 struct acpi_video_bus *video = seq->private;
950
951
952 if (!video)
953 goto end;
954
955 seq_printf(seq, "Switching heads: %s\n",
956 video->flags.multihead ? "yes" : "no");
957 seq_printf(seq, "Video ROM: %s\n",
958 video->flags.rom ? "yes" : "no");
959 seq_printf(seq, "Device to be POSTed on boot: %s\n",
960 video->flags.post ? "yes" : "no");
961
962 end:
963 return 0;
964 }
965
966 static int acpi_video_bus_info_open_fs(struct inode *inode, struct file *file)
967 {
968 return single_open(file, acpi_video_bus_info_seq_show,
969 PDE(inode)->data);
970 }
971
972 static int acpi_video_bus_ROM_seq_show(struct seq_file *seq, void *offset)
973 {
974 struct acpi_video_bus *video = seq->private;
975
976
977 if (!video)
978 goto end;
979
980 printk(KERN_INFO PREFIX "Please implement %s\n", __FUNCTION__);
981 seq_printf(seq, "<TODO>\n");
982
983 end:
984 return 0;
985 }
986
987 static int acpi_video_bus_ROM_open_fs(struct inode *inode, struct file *file)
988 {
989 return single_open(file, acpi_video_bus_ROM_seq_show, PDE(inode)->data);
990 }
991
992 static int acpi_video_bus_POST_info_seq_show(struct seq_file *seq, void *offset)
993 {
994 struct acpi_video_bus *video = seq->private;
995 unsigned long options;
996 int status;
997
998
999 if (!video)
1000 goto end;
1001
1002 status = acpi_video_bus_POST_options(video, &options);
1003 if (ACPI_SUCCESS(status)) {
1004 if (!(options & 1)) {
1005 printk(KERN_WARNING PREFIX
1006 "The motherboard VGA device is not listed as a possible POST device.\n");
1007 printk(KERN_WARNING PREFIX
1008 "This indicate a BIOS bug. Please contact the manufacturer.\n");
1009 }
1010 printk("%lx\n", options);
1011 seq_printf(seq, "can POST: <intgrated video>");
1012 if (options & 2)
1013 seq_printf(seq, " <PCI video>");
1014 if (options & 4)
1015 seq_printf(seq, " <AGP video>");
1016 seq_putc(seq, '\n');
1017 } else
1018 seq_printf(seq, "<not supported>\n");
1019 end:
1020 return 0;
1021 }
1022
1023 static int
1024 acpi_video_bus_POST_info_open_fs(struct inode *inode, struct file *file)
1025 {
1026 return single_open(file, acpi_video_bus_POST_info_seq_show,
1027 PDE(inode)->data);
1028 }
1029
1030 static int acpi_video_bus_POST_seq_show(struct seq_file *seq, void *offset)
1031 {
1032 struct acpi_video_bus *video = seq->private;
1033 int status;
1034 unsigned long id;
1035
1036
1037 if (!video)
1038 goto end;
1039
1040 status = acpi_video_bus_get_POST(video, &id);
1041 if (!ACPI_SUCCESS(status)) {
1042 seq_printf(seq, "<not supported>\n");
1043 goto end;
1044 }
1045 seq_printf(seq, "device posted is <%s>\n", device_decode[id & 3]);
1046
1047 end:
1048 return 0;
1049 }
1050
1051 static int acpi_video_bus_DOS_seq_show(struct seq_file *seq, void *offset)
1052 {
1053 struct acpi_video_bus *video = seq->private;
1054
1055
1056 seq_printf(seq, "DOS setting: <%d>\n", video->dos_setting);
1057
1058 return 0;
1059 }
1060
1061 static int acpi_video_bus_POST_open_fs(struct inode *inode, struct file *file)
1062 {
1063 return single_open(file, acpi_video_bus_POST_seq_show,
1064 PDE(inode)->data);
1065 }
1066
1067 static int acpi_video_bus_DOS_open_fs(struct inode *inode, struct file *file)
1068 {
1069 return single_open(file, acpi_video_bus_DOS_seq_show, PDE(inode)->data);
1070 }
1071
1072 static ssize_t
1073 acpi_video_bus_write_POST(struct file *file,
1074 const char __user * buffer,
1075 size_t count, loff_t * data)
1076 {
1077 int status;
1078 struct seq_file *m = file->private_data;
1079 struct acpi_video_bus *video = m->private;
1080 char str[12] = { 0 };
1081 unsigned long opt, options;
1082
1083
1084 if (!video || count + 1 > sizeof str)
1085 return -EINVAL;
1086
1087 status = acpi_video_bus_POST_options(video, &options);
1088 if (!ACPI_SUCCESS(status))
1089 return -EINVAL;
1090
1091 if (copy_from_user(str, buffer, count))
1092 return -EFAULT;
1093
1094 str[count] = 0;
1095 opt = strtoul(str, NULL, 0);
1096 if (opt > 3)
1097 return -EFAULT;
1098
1099 /* just in case an OEM 'forget' the motherboard... */
1100 options |= 1;
1101
1102 if (options & (1ul << opt)) {
1103 status = acpi_video_bus_set_POST(video, opt);
1104 if (!ACPI_SUCCESS(status))
1105 return -EFAULT;
1106
1107 }
1108
1109 return count;
1110 }
1111
1112 static ssize_t
1113 acpi_video_bus_write_DOS(struct file *file,
1114 const char __user * buffer,
1115 size_t count, loff_t * data)
1116 {
1117 int status;
1118 struct seq_file *m = file->private_data;
1119 struct acpi_video_bus *video = m->private;
1120 char str[12] = { 0 };
1121 unsigned long opt;
1122
1123
1124 if (!video || count + 1 > sizeof str)
1125 return -EINVAL;
1126
1127 if (copy_from_user(str, buffer, count))
1128 return -EFAULT;
1129
1130 str[count] = 0;
1131 opt = strtoul(str, NULL, 0);
1132 if (opt > 7)
1133 return -EFAULT;
1134
1135 status = acpi_video_bus_DOS(video, opt & 0x3, (opt & 0x4) >> 2);
1136
1137 if (!ACPI_SUCCESS(status))
1138 return -EFAULT;
1139
1140 return count;
1141 }
1142
1143 static int acpi_video_bus_add_fs(struct acpi_device *device)
1144 {
1145 struct proc_dir_entry *entry = NULL;
1146 struct acpi_video_bus *video;
1147
1148
1149 video = acpi_driver_data(device);
1150
1151 if (!acpi_device_dir(device)) {
1152 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1153 acpi_video_dir);
1154 if (!acpi_device_dir(device))
1155 return -ENODEV;
1156 video->dir = acpi_device_dir(device);
1157 acpi_device_dir(device)->owner = THIS_MODULE;
1158 }
1159
1160 /* 'info' [R] */
1161 entry = create_proc_entry("info", S_IRUGO, acpi_device_dir(device));
1162 if (!entry)
1163 return -ENODEV;
1164 else {
1165 entry->proc_fops = &acpi_video_bus_info_fops;
1166 entry->data = acpi_driver_data(device);
1167 entry->owner = THIS_MODULE;
1168 }
1169
1170 /* 'ROM' [R] */
1171 entry = create_proc_entry("ROM", S_IRUGO, acpi_device_dir(device));
1172 if (!entry)
1173 return -ENODEV;
1174 else {
1175 entry->proc_fops = &acpi_video_bus_ROM_fops;
1176 entry->data = acpi_driver_data(device);
1177 entry->owner = THIS_MODULE;
1178 }
1179
1180 /* 'POST_info' [R] */
1181 entry =
1182 create_proc_entry("POST_info", S_IRUGO, acpi_device_dir(device));
1183 if (!entry)
1184 return -ENODEV;
1185 else {
1186 entry->proc_fops = &acpi_video_bus_POST_info_fops;
1187 entry->data = acpi_driver_data(device);
1188 entry->owner = THIS_MODULE;
1189 }
1190
1191 /* 'POST' [R/W] */
1192 entry =
1193 create_proc_entry("POST", S_IFREG | S_IRUGO | S_IRUSR,
1194 acpi_device_dir(device));
1195 if (!entry)
1196 return -ENODEV;
1197 else {
1198 acpi_video_bus_POST_fops.write = acpi_video_bus_write_POST;
1199 entry->proc_fops = &acpi_video_bus_POST_fops;
1200 entry->data = acpi_driver_data(device);
1201 entry->owner = THIS_MODULE;
1202 }
1203
1204 /* 'DOS' [R/W] */
1205 entry =
1206 create_proc_entry("DOS", S_IFREG | S_IRUGO | S_IRUSR,
1207 acpi_device_dir(device));
1208 if (!entry)
1209 return -ENODEV;
1210 else {
1211 acpi_video_bus_DOS_fops.write = acpi_video_bus_write_DOS;
1212 entry->proc_fops = &acpi_video_bus_DOS_fops;
1213 entry->data = acpi_driver_data(device);
1214 entry->owner = THIS_MODULE;
1215 }
1216
1217 return 0;
1218 }
1219
1220 static int acpi_video_bus_remove_fs(struct acpi_device *device)
1221 {
1222 struct acpi_video_bus *video;
1223
1224
1225 video = acpi_driver_data(device);
1226
1227 if (acpi_device_dir(device)) {
1228 remove_proc_entry("info", acpi_device_dir(device));
1229 remove_proc_entry("ROM", acpi_device_dir(device));
1230 remove_proc_entry("POST_info", acpi_device_dir(device));
1231 remove_proc_entry("POST", acpi_device_dir(device));
1232 remove_proc_entry("DOS", acpi_device_dir(device));
1233 remove_proc_entry(acpi_device_bid(device), acpi_video_dir);
1234 acpi_device_dir(device) = NULL;
1235 }
1236
1237 return 0;
1238 }
1239
1240 /* --------------------------------------------------------------------------
1241 Driver Interface
1242 -------------------------------------------------------------------------- */
1243
1244 /* device interface */
1245
1246 static int
1247 acpi_video_bus_get_one_device(struct acpi_device *device,
1248 struct acpi_video_bus *video)
1249 {
1250 unsigned long device_id;
1251 int status;
1252 struct acpi_video_device *data;
1253
1254
1255 if (!device || !video)
1256 return -EINVAL;
1257
1258 status =
1259 acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
1260 if (ACPI_SUCCESS(status)) {
1261
1262 data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
1263 if (!data)
1264 return -ENOMEM;
1265
1266 strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
1267 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
1268 acpi_driver_data(device) = data;
1269
1270 data->device_id = device_id;
1271 data->video = video;
1272 data->dev = device;
1273
1274 switch (device_id & 0xffff) {
1275 case 0x0100:
1276 data->flags.crt = 1;
1277 break;
1278 case 0x0400:
1279 data->flags.lcd = 1;
1280 break;
1281 case 0x0200:
1282 data->flags.tvout = 1;
1283 break;
1284 default:
1285 data->flags.unknown = 1;
1286 break;
1287 }
1288
1289 acpi_video_device_bind(video, data);
1290 acpi_video_device_find_cap(data);
1291
1292 status = acpi_install_notify_handler(device->handle,
1293 ACPI_DEVICE_NOTIFY,
1294 acpi_video_device_notify,
1295 data);
1296 if (ACPI_FAILURE(status)) {
1297 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1298 "Error installing notify handler\n"));
1299 if(data->brightness)
1300 kfree(data->brightness->levels);
1301 kfree(data->brightness);
1302 kfree(data);
1303 return -ENODEV;
1304 }
1305
1306 down(&video->sem);
1307 list_add_tail(&data->entry, &video->video_device_list);
1308 up(&video->sem);
1309
1310 acpi_video_device_add_fs(device);
1311
1312 return 0;
1313 }
1314
1315 return -ENOENT;
1316 }
1317
1318 /*
1319 * Arg:
1320 * video : video bus device
1321 *
1322 * Return:
1323 * none
1324 *
1325 * Enumerate the video device list of the video bus,
1326 * bind the ids with the corresponding video devices
1327 * under the video bus.
1328 */
1329
1330 static void acpi_video_device_rebind(struct acpi_video_bus *video)
1331 {
1332 struct list_head *node, *next;
1333 list_for_each_safe(node, next, &video->video_device_list) {
1334 struct acpi_video_device *dev =
1335 container_of(node, struct acpi_video_device, entry);
1336 acpi_video_device_bind(video, dev);
1337 }
1338 }
1339
1340 /*
1341 * Arg:
1342 * video : video bus device
1343 * device : video output device under the video
1344 * bus
1345 *
1346 * Return:
1347 * none
1348 *
1349 * Bind the ids with the corresponding video devices
1350 * under the video bus.
1351 */
1352
1353 static void
1354 acpi_video_device_bind(struct acpi_video_bus *video,
1355 struct acpi_video_device *device)
1356 {
1357 int i;
1358
1359 #define IDS_VAL(i) video->attached_array[i].value.int_val
1360 #define IDS_BIND(i) video->attached_array[i].bind_info
1361
1362 for (i = 0; IDS_VAL(i) != ACPI_VIDEO_HEAD_INVALID &&
1363 i < video->attached_count; i++) {
1364 if (device->device_id == (IDS_VAL(i) & 0xffff)) {
1365 IDS_BIND(i) = device;
1366 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "device_bind %d\n", i));
1367 }
1368 }
1369 #undef IDS_VAL
1370 #undef IDS_BIND
1371 }
1372
1373 /*
1374 * Arg:
1375 * video : video bus device
1376 *
1377 * Return:
1378 * < 0 : error
1379 *
1380 * Call _DOD to enumerate all devices attached to display adapter
1381 *
1382 */
1383
1384 static int acpi_video_device_enumerate(struct acpi_video_bus *video)
1385 {
1386 int status;
1387 int count;
1388 int i;
1389 struct acpi_video_enumerated_device *active_device_list;
1390 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1391 union acpi_object *dod = NULL;
1392 union acpi_object *obj;
1393
1394 status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
1395 if (!ACPI_SUCCESS(status)) {
1396 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD"));
1397 return status;
1398 }
1399
1400 dod = buffer.pointer;
1401 if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
1402 ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data"));
1403 status = -EFAULT;
1404 goto out;
1405 }
1406
1407 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d video heads in _DOD\n",
1408 dod->package.count));
1409
1410 active_device_list = kmalloc((1 +
1411 dod->package.count) *
1412 sizeof(struct
1413 acpi_video_enumerated_device),
1414 GFP_KERNEL);
1415
1416 if (!active_device_list) {
1417 status = -ENOMEM;
1418 goto out;
1419 }
1420
1421 count = 0;
1422 for (i = 0; i < dod->package.count; i++) {
1423 obj = &dod->package.elements[i];
1424
1425 if (obj->type != ACPI_TYPE_INTEGER) {
1426 printk(KERN_ERR PREFIX "Invalid _DOD data\n");
1427 active_device_list[i].value.int_val =
1428 ACPI_VIDEO_HEAD_INVALID;
1429 }
1430 active_device_list[i].value.int_val = obj->integer.value;
1431 active_device_list[i].bind_info = NULL;
1432 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "dod element[%d] = %d\n", i,
1433 (int)obj->integer.value));
1434 count++;
1435 }
1436 active_device_list[count].value.int_val = ACPI_VIDEO_HEAD_END;
1437
1438 kfree(video->attached_array);
1439
1440 video->attached_array = active_device_list;
1441 video->attached_count = count;
1442 out:
1443 kfree(buffer.pointer);
1444 return status;
1445 }
1446
1447 /*
1448 * Arg:
1449 * video : video bus device
1450 * event : Nontify Event
1451 *
1452 * Return:
1453 * < 0 : error
1454 *
1455 * 1. Find out the current active output device.
1456 * 2. Identify the next output device to switch
1457 * 3. call _DSS to do actual switch.
1458 */
1459
1460 static int acpi_video_switch_output(struct acpi_video_bus *video, int event)
1461 {
1462 struct list_head *node, *next;
1463 struct acpi_video_device *dev = NULL;
1464 struct acpi_video_device *dev_next = NULL;
1465 struct acpi_video_device *dev_prev = NULL;
1466 unsigned long state;
1467 int status = 0;
1468
1469
1470 list_for_each_safe(node, next, &video->video_device_list) {
1471 dev = container_of(node, struct acpi_video_device, entry);
1472 status = acpi_video_device_get_state(dev, &state);
1473 if (state & 0x2) {
1474 dev_next =
1475 container_of(node->next, struct acpi_video_device,
1476 entry);
1477 dev_prev =
1478 container_of(node->prev, struct acpi_video_device,
1479 entry);
1480 goto out;
1481 }
1482 }
1483 dev_next = container_of(node->next, struct acpi_video_device, entry);
1484 dev_prev = container_of(node->prev, struct acpi_video_device, entry);
1485 out:
1486 switch (event) {
1487 case ACPI_VIDEO_NOTIFY_CYCLE:
1488 case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT:
1489 acpi_video_device_set_state(dev, 0);
1490 acpi_video_device_set_state(dev_next, 0x80000001);
1491 break;
1492 case ACPI_VIDEO_NOTIFY_PREV_OUTPUT:
1493 acpi_video_device_set_state(dev, 0);
1494 acpi_video_device_set_state(dev_prev, 0x80000001);
1495 default:
1496 break;
1497 }
1498
1499 return status;
1500 }
1501
1502 static int
1503 acpi_video_get_next_level(struct acpi_video_device *device,
1504 u32 level_current, u32 event)
1505 {
1506 int min, max, min_above, max_below, i, l;
1507 max = max_below = 0;
1508 min = min_above = 255;
1509 for (i = 0; i < device->brightness->count; i++) {
1510 l = device->brightness->levels[i];
1511 if (l < min)
1512 min = l;
1513 if (l > max)
1514 max = l;
1515 if (l < min_above && l > level_current)
1516 min_above = l;
1517 if (l > max_below && l < level_current)
1518 max_below = l;
1519 }
1520
1521 switch (event) {
1522 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:
1523 return (level_current < max) ? min_above : min;
1524 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:
1525 return (level_current < max) ? min_above : max;
1526 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:
1527 return (level_current > min) ? max_below : min;
1528 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:
1529 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:
1530 return 0;
1531 default:
1532 return level_current;
1533 }
1534 }
1535
1536 static void
1537 acpi_video_switch_brightness(struct acpi_video_device *device, int event)
1538 {
1539 unsigned long level_current, level_next;
1540 acpi_video_device_lcd_get_level_current(device, &level_current);
1541 level_next = acpi_video_get_next_level(device, level_current, event);
1542 acpi_video_device_lcd_set_level(device, level_next);
1543 }
1544
1545 static int
1546 acpi_video_bus_get_devices(struct acpi_video_bus *video,
1547 struct acpi_device *device)
1548 {
1549 int status = 0;
1550 struct list_head *node, *next;
1551
1552
1553 acpi_video_device_enumerate(video);
1554
1555 list_for_each_safe(node, next, &device->children) {
1556 struct acpi_device *dev =
1557 list_entry(node, struct acpi_device, node);
1558
1559 if (!dev)
1560 continue;
1561
1562 status = acpi_video_bus_get_one_device(dev, video);
1563 if (ACPI_FAILURE(status)) {
1564 ACPI_EXCEPTION((AE_INFO, status, "Cant attach device"));
1565 continue;
1566 }
1567
1568 }
1569 return status;
1570 }
1571
1572 static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
1573 {
1574 acpi_status status;
1575 struct acpi_video_bus *video;
1576
1577
1578 if (!device || !device->video)
1579 return -ENOENT;
1580
1581 video = device->video;
1582
1583 down(&video->sem);
1584 list_del(&device->entry);
1585 up(&video->sem);
1586 acpi_video_device_remove_fs(device->dev);
1587
1588 status = acpi_remove_notify_handler(device->dev->handle,
1589 ACPI_DEVICE_NOTIFY,
1590 acpi_video_device_notify);
1591
1592 return 0;
1593 }
1594
1595 static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
1596 {
1597 int status;
1598 struct list_head *node, *next;
1599
1600
1601 list_for_each_safe(node, next, &video->video_device_list) {
1602 struct acpi_video_device *data =
1603 list_entry(node, struct acpi_video_device, entry);
1604 if (!data)
1605 continue;
1606
1607 status = acpi_video_bus_put_one_device(data);
1608 if (ACPI_FAILURE(status))
1609 printk(KERN_WARNING PREFIX
1610 "hhuuhhuu bug in acpi video driver.\n");
1611
1612 if (data->brightness)
1613 kfree(data->brightness->levels);
1614 kfree(data->brightness);
1615 kfree(data);
1616 }
1617
1618 return 0;
1619 }
1620
1621 /* acpi_video interface */
1622
1623 static int acpi_video_bus_start_devices(struct acpi_video_bus *video)
1624 {
1625 return acpi_video_bus_DOS(video, 1, 0);
1626 }
1627
1628 static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
1629 {
1630 return acpi_video_bus_DOS(video, 0, 1);
1631 }
1632
1633 static void acpi_video_bus_notify(acpi_handle handle, u32 event, void *data)
1634 {
1635 struct acpi_video_bus *video = data;
1636 struct acpi_device *device = NULL;
1637
1638 printk("video bus notify\n");
1639
1640 if (!video)
1641 return;
1642
1643 device = video->device;
1644
1645 switch (event) {
1646 case ACPI_VIDEO_NOTIFY_SWITCH: /* User request that a switch occur,
1647 * most likely via hotkey. */
1648 acpi_bus_generate_event(device, event, 0);
1649 break;
1650
1651 case ACPI_VIDEO_NOTIFY_PROBE: /* User plug or remove a video
1652 * connector. */
1653 acpi_video_device_enumerate(video);
1654 acpi_video_device_rebind(video);
1655 acpi_video_switch_output(video, event);
1656 acpi_bus_generate_event(device, event, 0);
1657 break;
1658
1659 case ACPI_VIDEO_NOTIFY_CYCLE: /* Cycle Display output hotkey pressed. */
1660 case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT: /* Next Display output hotkey pressed. */
1661 case ACPI_VIDEO_NOTIFY_PREV_OUTPUT: /* previous Display output hotkey pressed. */
1662 acpi_video_switch_output(video, event);
1663 acpi_bus_generate_event(device, event, 0);
1664 break;
1665
1666 default:
1667 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1668 "Unsupported event [0x%x]\n", event));
1669 break;
1670 }
1671
1672 return;
1673 }
1674
1675 static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
1676 {
1677 struct acpi_video_device *video_device = data;
1678 struct acpi_device *device = NULL;
1679
1680 if (!video_device)
1681 return;
1682
1683 device = video_device->dev;
1684
1685 switch (event) {
1686 case ACPI_VIDEO_NOTIFY_SWITCH: /* change in status (cycle output device) */
1687 case ACPI_VIDEO_NOTIFY_PROBE: /* change in status (output device status) */
1688 acpi_bus_generate_event(device, event, 0);
1689 break;
1690 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: /* Cycle brightness */
1691 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: /* Increase brightness */
1692 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: /* Decrease brightness */
1693 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightnesss */
1694 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: /* display device off */
1695 acpi_video_switch_brightness(video_device, event);
1696 acpi_bus_generate_event(device, event, 0);
1697 break;
1698 default:
1699 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1700 "Unsupported event [0x%x]\n", event));
1701 break;
1702 }
1703 return;
1704 }
1705
1706 static int acpi_video_bus_add(struct acpi_device *device)
1707 {
1708 int result = 0;
1709 acpi_status status = 0;
1710 struct acpi_video_bus *video = NULL;
1711
1712
1713 if (!device)
1714 return -EINVAL;
1715
1716 video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
1717 if (!video)
1718 return -ENOMEM;
1719
1720 video->device = device;
1721 strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
1722 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
1723 acpi_driver_data(device) = video;
1724
1725 acpi_video_bus_find_cap(video);
1726 result = acpi_video_bus_check(video);
1727 if (result)
1728 goto end;
1729
1730 result = acpi_video_bus_add_fs(device);
1731 if (result)
1732 goto end;
1733
1734 init_MUTEX(&video->sem);
1735 INIT_LIST_HEAD(&video->video_device_list);
1736
1737 acpi_video_bus_get_devices(video, device);
1738 acpi_video_bus_start_devices(video);
1739
1740 status = acpi_install_notify_handler(device->handle,
1741 ACPI_DEVICE_NOTIFY,
1742 acpi_video_bus_notify, video);
1743 if (ACPI_FAILURE(status)) {
1744 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1745 "Error installing notify handler\n"));
1746 acpi_video_bus_stop_devices(video);
1747 acpi_video_bus_put_devices(video);
1748 kfree(video->attached_array);
1749 acpi_video_bus_remove_fs(device);
1750 result = -ENODEV;
1751 goto end;
1752 }
1753
1754 printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s rom: %s post: %s)\n",
1755 ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
1756 video->flags.multihead ? "yes" : "no",
1757 video->flags.rom ? "yes" : "no",
1758 video->flags.post ? "yes" : "no");
1759
1760 end:
1761 if (result)
1762 kfree(video);
1763
1764 return result;
1765 }
1766
1767 static int acpi_video_bus_remove(struct acpi_device *device, int type)
1768 {
1769 acpi_status status = 0;
1770 struct acpi_video_bus *video = NULL;
1771
1772
1773 if (!device || !acpi_driver_data(device))
1774 return -EINVAL;
1775
1776 video = acpi_driver_data(device);
1777
1778 acpi_video_bus_stop_devices(video);
1779
1780 status = acpi_remove_notify_handler(video->device->handle,
1781 ACPI_DEVICE_NOTIFY,
1782 acpi_video_bus_notify);
1783
1784 acpi_video_bus_put_devices(video);
1785 acpi_video_bus_remove_fs(device);
1786
1787 kfree(video->attached_array);
1788 kfree(video);
1789
1790 return 0;
1791 }
1792
1793 static int
1794 acpi_video_bus_match(struct acpi_device *device, struct acpi_driver *driver)
1795 {
1796 acpi_handle h_dummy1;
1797 acpi_handle h_dummy2;
1798 acpi_handle h_dummy3;
1799
1800
1801 if (!device || !driver)
1802 return -EINVAL;
1803
1804 /* Since there is no HID, CID for ACPI Video drivers, we have
1805 * to check well known required nodes for each feature we support.
1806 */
1807
1808 /* Does this device able to support video switching ? */
1809 if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_DOD", &h_dummy1)) &&
1810 ACPI_SUCCESS(acpi_get_handle(device->handle, "_DOS", &h_dummy2)))
1811 return 0;
1812
1813 /* Does this device able to retrieve a video ROM ? */
1814 if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_ROM", &h_dummy1)))
1815 return 0;
1816
1817 /* Does this device able to configure which video head to be POSTed ? */
1818 if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_VPO", &h_dummy1)) &&
1819 ACPI_SUCCESS(acpi_get_handle(device->handle, "_GPD", &h_dummy2)) &&
1820 ACPI_SUCCESS(acpi_get_handle(device->handle, "_SPD", &h_dummy3)))
1821 return 0;
1822
1823 return -ENODEV;
1824 }
1825
1826 static int __init acpi_video_init(void)
1827 {
1828 int result = 0;
1829
1830
1831 /*
1832 acpi_dbg_level = 0xFFFFFFFF;
1833 acpi_dbg_layer = 0x08000000;
1834 */
1835
1836 acpi_video_dir = proc_mkdir(ACPI_VIDEO_CLASS, acpi_root_dir);
1837 if (!acpi_video_dir)
1838 return -ENODEV;
1839 acpi_video_dir->owner = THIS_MODULE;
1840
1841 result = acpi_bus_register_driver(&acpi_video_bus);
1842 if (result < 0) {
1843 remove_proc_entry(ACPI_VIDEO_CLASS, acpi_root_dir);
1844 return -ENODEV;
1845 }
1846
1847 return 0;
1848 }
1849
1850 static void __exit acpi_video_exit(void)
1851 {
1852
1853 acpi_bus_unregister_driver(&acpi_video_bus);
1854
1855 remove_proc_entry(ACPI_VIDEO_CLASS, acpi_root_dir);
1856
1857 return;
1858 }
1859
1860 module_init(acpi_video_init);
1861 module_exit(acpi_video_exit);
Linux with added FPC-III support