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