]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/acpi/video.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


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