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