?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.133
[linux/fpc-iii.git] / drivers / acpi / acpi_video.c
blob1a23e7aa74df7f258361f72eb94a4349949e862e
1 /*
2 * video.c - ACPI Video Driver
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 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
21 */
22
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/types.h>
27 #include <linux/list.h>
28 #include <linux/mutex.h>
29 #include <linux/input.h>
30 #include <linux/backlight.h>
31 #include <linux/thermal.h>
32 #include <linux/sort.h>
33 #include <linux/pci.h>
34 #include <linux/pci_ids.h>
35 #include <linux/slab.h>
36 #include <linux/dmi.h>
37 #include <linux/suspend.h>
38 #include <linux/acpi.h>
39 #include <acpi/video.h>
40 #include <linux/uaccess.h>
41
42 #define PREFIX "ACPI: "
43
44 #define ACPI_VIDEO_BUS_NAME "Video Bus"
45 #define ACPI_VIDEO_DEVICE_NAME "Video Device"
46
47 #define MAX_NAME_LEN 20
48
49 #define _COMPONENT ACPI_VIDEO_COMPONENT
50 ACPI_MODULE_NAME("video");
51
52 MODULE_AUTHOR("Bruno Ducrot");
53 MODULE_DESCRIPTION("ACPI Video Driver");
54 MODULE_LICENSE("GPL");
55
56 static bool brightness_switch_enabled = true;
57 module_param(brightness_switch_enabled, bool, 0644);
58
59 /*
60 * By default, we don't allow duplicate ACPI video bus devices
61 * under the same VGA controller
62 */
63 static bool allow_duplicates;
64 module_param(allow_duplicates, bool, 0644);
65
66 static int disable_backlight_sysfs_if = -1;
67 module_param(disable_backlight_sysfs_if, int, 0444);
68
69 #define REPORT_OUTPUT_KEY_EVENTS 0x01
70 #define REPORT_BRIGHTNESS_KEY_EVENTS 0x02
71 static int report_key_events = -1;
72 module_param(report_key_events, int, 0644);
73 MODULE_PARM_DESC(report_key_events,
74 "0: none, 1: output changes, 2: brightness changes, 3: all");
75
76 static int hw_changes_brightness = -1;
77 module_param(hw_changes_brightness, int, 0644);
78 MODULE_PARM_DESC(hw_changes_brightness,
79 "Set this to 1 on buggy hw which changes the brightness itself when "
80 "a hotkey is pressed: -1: auto, 0: normal 1: hw-changes-brightness");
81
82 /*
83 * Whether the struct acpi_video_device_attrib::device_id_scheme bit should be
84 * assumed even if not actually set.
85 */
86 static bool device_id_scheme = false;
87 module_param(device_id_scheme, bool, 0444);
88
89 static int only_lcd = -1;
90 module_param(only_lcd, int, 0444);
91
92 static int register_count;
93 static DEFINE_MUTEX(register_count_mutex);
94 static DEFINE_MUTEX(video_list_lock);
95 static LIST_HEAD(video_bus_head);
96 static int acpi_video_bus_add(struct acpi_device *device);
97 static int acpi_video_bus_remove(struct acpi_device *device);
98 static void acpi_video_bus_notify(struct acpi_device *device, u32 event);
99 void acpi_video_detect_exit(void);
100
101 /*
102 * Indices in the _BCL method response: the first two items are special,
103 * the rest are all supported levels.
104 *
105 * See page 575 of the ACPI spec 3.0
106 */
107 enum acpi_video_level_idx {
108 ACPI_VIDEO_AC_LEVEL, /* level when machine has full power */
109 ACPI_VIDEO_BATTERY_LEVEL, /* level when machine is on batteries */
110 ACPI_VIDEO_FIRST_LEVEL, /* actual supported levels begin here */
111 };
112
113 static const struct acpi_device_id video_device_ids[] = {
114 {ACPI_VIDEO_HID, 0},
115 {"", 0},
116 };
117 MODULE_DEVICE_TABLE(acpi, video_device_ids);
118
119 static struct acpi_driver acpi_video_bus = {
120 .name = "video",
121 .class = ACPI_VIDEO_CLASS,
122 .ids = video_device_ids,
123 .ops = {
124 .add = acpi_video_bus_add,
125 .remove = acpi_video_bus_remove,
126 .notify = acpi_video_bus_notify,
127 },
128 };
129
130 struct acpi_video_bus_flags {
131 u8 multihead:1; /* can switch video heads */
132 u8 rom:1; /* can retrieve a video rom */
133 u8 post:1; /* can configure the head to */
134 u8 reserved:5;
135 };
136
137 struct acpi_video_bus_cap {
138 u8 _DOS:1; /* Enable/Disable output switching */
139 u8 _DOD:1; /* Enumerate all devices attached to display adapter */
140 u8 _ROM:1; /* Get ROM Data */
141 u8 _GPD:1; /* Get POST Device */
142 u8 _SPD:1; /* Set POST Device */
143 u8 _VPO:1; /* Video POST Options */
144 u8 reserved:2;
145 };
146
147 struct acpi_video_device_attrib {
148 u32 display_index:4; /* A zero-based instance of the Display */
149 u32 display_port_attachment:4; /* This field differentiates the display type */
150 u32 display_type:4; /* Describe the specific type in use */
151 u32 vendor_specific:4; /* Chipset Vendor Specific */
152 u32 bios_can_detect:1; /* BIOS can detect the device */
153 u32 depend_on_vga:1; /* Non-VGA output device whose power is related to
154 the VGA device. */
155 u32 pipe_id:3; /* For VGA multiple-head devices. */
156 u32 reserved:10; /* Must be 0 */
157
158 /*
159 * The device ID might not actually follow the scheme described by this
160 * struct acpi_video_device_attrib. If it does, then this bit
161 * device_id_scheme is set; otherwise, other fields should be ignored.
162 *
163 * (but also see the global flag device_id_scheme)
164 */
165 u32 device_id_scheme:1;
166 };
167
168 struct acpi_video_enumerated_device {
169 union {
170 u32 int_val;
171 struct acpi_video_device_attrib attrib;
172 } value;
173 struct acpi_video_device *bind_info;
174 };
175
176 struct acpi_video_bus {
177 struct acpi_device *device;
178 bool backlight_registered;
179 u8 dos_setting;
180 struct acpi_video_enumerated_device *attached_array;
181 u8 attached_count;
182 u8 child_count;
183 struct acpi_video_bus_cap cap;
184 struct acpi_video_bus_flags flags;
185 struct list_head video_device_list;
186 struct mutex device_list_lock; /* protects video_device_list */
187 struct list_head entry;
188 struct input_dev *input;
189 char phys[32]; /* for input device */
190 struct notifier_block pm_nb;
191 };
192
193 struct acpi_video_device_flags {
194 u8 crt:1;
195 u8 lcd:1;
196 u8 tvout:1;
197 u8 dvi:1;
198 u8 bios:1;
199 u8 unknown:1;
200 u8 notify:1;
201 u8 reserved:1;
202 };
203
204 struct acpi_video_device_cap {
205 u8 _ADR:1; /* Return the unique ID */
206 u8 _BCL:1; /* Query list of brightness control levels supported */
207 u8 _BCM:1; /* Set the brightness level */
208 u8 _BQC:1; /* Get current brightness level */
209 u8 _BCQ:1; /* Some buggy BIOS uses _BCQ instead of _BQC */
210 u8 _DDC:1; /* Return the EDID for this device */
211 };
212
213 struct acpi_video_device {
214 unsigned long device_id;
215 struct acpi_video_device_flags flags;
216 struct acpi_video_device_cap cap;
217 struct list_head entry;
218 struct delayed_work switch_brightness_work;
219 int switch_brightness_event;
220 struct acpi_video_bus *video;
221 struct acpi_device *dev;
222 struct acpi_video_device_brightness *brightness;
223 struct backlight_device *backlight;
224 struct thermal_cooling_device *cooling_dev;
225 };
226
227 static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data);
228 static void acpi_video_device_rebind(struct acpi_video_bus *video);
229 static void acpi_video_device_bind(struct acpi_video_bus *video,
230 struct acpi_video_device *device);
231 static int acpi_video_device_enumerate(struct acpi_video_bus *video);
232 static int acpi_video_device_lcd_set_level(struct acpi_video_device *device,
233 int level);
234 static int acpi_video_device_lcd_get_level_current(
235 struct acpi_video_device *device,
236 unsigned long long *level, bool raw);
237 static int acpi_video_get_next_level(struct acpi_video_device *device,
238 u32 level_current, u32 event);
239 static void acpi_video_switch_brightness(struct work_struct *work);
240
241 /* backlight device sysfs support */
242 static int acpi_video_get_brightness(struct backlight_device *bd)
243 {
244 unsigned long long cur_level;
245 int i;
246 struct acpi_video_device *vd = bl_get_data(bd);
247
248 if (acpi_video_device_lcd_get_level_current(vd, &cur_level, false))
249 return -EINVAL;
250 for (i = ACPI_VIDEO_FIRST_LEVEL; i < vd->brightness->count; i++) {
251 if (vd->brightness->levels[i] == cur_level)
252 return i - ACPI_VIDEO_FIRST_LEVEL;
253 }
254 return 0;
255 }
256
257 static int acpi_video_set_brightness(struct backlight_device *bd)
258 {
259 int request_level = bd->props.brightness + ACPI_VIDEO_FIRST_LEVEL;
260 struct acpi_video_device *vd = bl_get_data(bd);
261
262 cancel_delayed_work(&vd->switch_brightness_work);
263 return acpi_video_device_lcd_set_level(vd,
264 vd->brightness->levels[request_level]);
265 }
266
267 static const struct backlight_ops acpi_backlight_ops = {
268 .get_brightness = acpi_video_get_brightness,
269 .update_status = acpi_video_set_brightness,
270 };
271
272 /* thermal cooling device callbacks */
273 static int video_get_max_state(struct thermal_cooling_device *cooling_dev,
274 unsigned long *state)
275 {
276 struct acpi_device *device = cooling_dev->devdata;
277 struct acpi_video_device *video = acpi_driver_data(device);
278
279 *state = video->brightness->count - ACPI_VIDEO_FIRST_LEVEL - 1;
280 return 0;
281 }
282
283 static int video_get_cur_state(struct thermal_cooling_device *cooling_dev,
284 unsigned long *state)
285 {
286 struct acpi_device *device = cooling_dev->devdata;
287 struct acpi_video_device *video = acpi_driver_data(device);
288 unsigned long long level;
289 int offset;
290
291 if (acpi_video_device_lcd_get_level_current(video, &level, false))
292 return -EINVAL;
293 for (offset = ACPI_VIDEO_FIRST_LEVEL; offset < video->brightness->count;
294 offset++)
295 if (level == video->brightness->levels[offset]) {
296 *state = video->brightness->count - offset - 1;
297 return 0;
298 }
299
300 return -EINVAL;
301 }
302
303 static int
304 video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long state)
305 {
306 struct acpi_device *device = cooling_dev->devdata;
307 struct acpi_video_device *video = acpi_driver_data(device);
308 int level;
309
310 if (state >= video->brightness->count - ACPI_VIDEO_FIRST_LEVEL)
311 return -EINVAL;
312
313 state = video->brightness->count - state;
314 level = video->brightness->levels[state - 1];
315 return acpi_video_device_lcd_set_level(video, level);
316 }
317
318 static const struct thermal_cooling_device_ops video_cooling_ops = {
319 .get_max_state = video_get_max_state,
320 .get_cur_state = video_get_cur_state,
321 .set_cur_state = video_set_cur_state,
322 };
323
324 /*
325 * --------------------------------------------------------------------------
326 * Video Management
327 * --------------------------------------------------------------------------
328 */
329
330 static int
331 acpi_video_device_lcd_query_levels(acpi_handle handle,
332 union acpi_object **levels)
333 {
334 int status;
335 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
336 union acpi_object *obj;
337
338
339 *levels = NULL;
340
341 status = acpi_evaluate_object(handle, "_BCL", NULL, &buffer);
342 if (!ACPI_SUCCESS(status))
343 return status;
344 obj = (union acpi_object *)buffer.pointer;
345 if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
346 printk(KERN_ERR PREFIX "Invalid _BCL data\n");
347 status = -EFAULT;
348 goto err;
349 }
350
351 *levels = obj;
352
353 return 0;
354
355 err:
356 kfree(buffer.pointer);
357
358 return status;
359 }
360
361 static int
362 acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level)
363 {
364 int status;
365 int state;
366
367 status = acpi_execute_simple_method(device->dev->handle,
368 "_BCM", level);
369 if (ACPI_FAILURE(status)) {
370 ACPI_ERROR((AE_INFO, "Evaluating _BCM failed"));
371 return -EIO;
372 }
373
374 device->brightness->curr = level;
375 for (state = ACPI_VIDEO_FIRST_LEVEL; state < device->brightness->count;
376 state++)
377 if (level == device->brightness->levels[state]) {
378 if (device->backlight)
379 device->backlight->props.brightness =
380 state - ACPI_VIDEO_FIRST_LEVEL;
381 return 0;
382 }
383
384 ACPI_ERROR((AE_INFO, "Current brightness invalid"));
385 return -EINVAL;
386 }
387
388 /*
389 * For some buggy _BQC methods, we need to add a constant value to
390 * the _BQC return value to get the actual current brightness level
391 */
392
393 static int bqc_offset_aml_bug_workaround;
394 static int video_set_bqc_offset(const struct dmi_system_id *d)
395 {
396 bqc_offset_aml_bug_workaround = 9;
397 return 0;
398 }
399
400 static int video_disable_backlight_sysfs_if(
401 const struct dmi_system_id *d)
402 {
403 if (disable_backlight_sysfs_if == -1)
404 disable_backlight_sysfs_if = 1;
405 return 0;
406 }
407
408 static int video_set_device_id_scheme(const struct dmi_system_id *d)
409 {
410 device_id_scheme = true;
411 return 0;
412 }
413
414 static int video_enable_only_lcd(const struct dmi_system_id *d)
415 {
416 only_lcd = true;
417 return 0;
418 }
419
420 static int video_set_report_key_events(const struct dmi_system_id *id)
421 {
422 if (report_key_events == -1)
423 report_key_events = (uintptr_t)id->driver_data;
424 return 0;
425 }
426
427 static int video_hw_changes_brightness(
428 const struct dmi_system_id *d)
429 {
430 if (hw_changes_brightness == -1)
431 hw_changes_brightness = 1;
432 return 0;
433 }
434
435 static const struct dmi_system_id video_dmi_table[] = {
436 /*
437 * Broken _BQC workaround http://bugzilla.kernel.org/show_bug.cgi?id=13121
438 */
439 {
440 .callback = video_set_bqc_offset,
441 .ident = "Acer Aspire 5720",
442 .matches = {
443 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
444 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5720"),
445 },
446 },
447 {
448 .callback = video_set_bqc_offset,
449 .ident = "Acer Aspire 5710Z",
450 .matches = {
451 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
452 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5710Z"),
453 },
454 },
455 {
456 .callback = video_set_bqc_offset,
457 .ident = "eMachines E510",
458 .matches = {
459 DMI_MATCH(DMI_BOARD_VENDOR, "EMACHINES"),
460 DMI_MATCH(DMI_PRODUCT_NAME, "eMachines E510"),
461 },
462 },
463 {
464 .callback = video_set_bqc_offset,
465 .ident = "Acer Aspire 5315",
466 .matches = {
467 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
468 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5315"),
469 },
470 },
471 {
472 .callback = video_set_bqc_offset,
473 .ident = "Acer Aspire 7720",
474 .matches = {
475 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
476 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7720"),
477 },
478 },
479
480 /*
481 * Some machines have a broken acpi-video interface for brightness
482 * control, but still need an acpi_video_device_lcd_set_level() call
483 * on resume to turn the backlight power on. We Enable backlight
484 * control on these systems, but do not register a backlight sysfs
485 * as brightness control does not work.
486 */
487 {
488 /* https://bugzilla.kernel.org/show_bug.cgi?id=21012 */
489 .callback = video_disable_backlight_sysfs_if,
490 .ident = "Toshiba Portege R700",
491 .matches = {
492 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
493 DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE R700"),
494 },
495 },
496 {
497 /* https://bugs.freedesktop.org/show_bug.cgi?id=82634 */
498 .callback = video_disable_backlight_sysfs_if,
499 .ident = "Toshiba Portege R830",
500 .matches = {
501 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
502 DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE R830"),
503 },
504 },
505 {
506 /* https://bugzilla.kernel.org/show_bug.cgi?id=21012 */
507 .callback = video_disable_backlight_sysfs_if,
508 .ident = "Toshiba Satellite R830",
509 .matches = {
510 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
511 DMI_MATCH(DMI_PRODUCT_NAME, "SATELLITE R830"),
512 },
513 },
514 /*
515 * Some machine's _DOD IDs don't have bit 31(Device ID Scheme) set
516 * but the IDs actually follow the Device ID Scheme.
517 */
518 {
519 /* https://bugzilla.kernel.org/show_bug.cgi?id=104121 */
520 .callback = video_set_device_id_scheme,
521 .ident = "ESPRIMO Mobile M9410",
522 .matches = {
523 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
524 DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Mobile M9410"),
525 },
526 },
527 /*
528 * Some machines have multiple video output devices, but only the one
529 * that is the type of LCD can do the backlight control so we should not
530 * register backlight interface for other video output devices.
531 */
532 {
533 /* https://bugzilla.kernel.org/show_bug.cgi?id=104121 */
534 .callback = video_enable_only_lcd,
535 .ident = "ESPRIMO Mobile M9410",
536 .matches = {
537 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
538 DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Mobile M9410"),
539 },
540 },
541 /*
542 * Some machines report wrong key events on the acpi-bus, suppress
543 * key event reporting on these. Note this is only intended to work
544 * around events which are plain wrong. In some cases we get double
545 * events, in this case acpi-video is considered the canonical source
546 * and the events from the other source should be filtered. E.g.
547 * by calling acpi_video_handles_brightness_key_presses() from the
548 * vendor acpi/wmi driver or by using /lib/udev/hwdb.d/60-keyboard.hwdb
549 */
550 {
551 .callback = video_set_report_key_events,
552 .driver_data = (void *)((uintptr_t)REPORT_OUTPUT_KEY_EVENTS),
553 .ident = "Dell Vostro V131",
554 .matches = {
555 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
556 DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V131"),
557 },
558 },
559 /*
560 * Some machines change the brightness themselves when a brightness
561 * hotkey gets pressed, despite us telling them not to. In this case
562 * acpi_video_device_notify() should only call backlight_force_update(
563 * BACKLIGHT_UPDATE_HOTKEY) and not do anything else.
564 */
565 {
566 /* https://bugzilla.kernel.org/show_bug.cgi?id=204077 */
567 .callback = video_hw_changes_brightness,
568 .ident = "Packard Bell EasyNote MZ35",
569 .matches = {
570 DMI_MATCH(DMI_SYS_VENDOR, "Packard Bell"),
571 DMI_MATCH(DMI_PRODUCT_NAME, "EasyNote MZ35"),
572 },
573 },
574 {}
575 };
576
577 static unsigned long long
578 acpi_video_bqc_value_to_level(struct acpi_video_device *device,
579 unsigned long long bqc_value)
580 {
581 unsigned long long level;
582
583 if (device->brightness->flags._BQC_use_index) {
584 /*
585 * _BQC returns an index that doesn't account for the first 2
586 * items with special meaning (see enum acpi_video_level_idx),
587 * so we need to compensate for that by offsetting ourselves
588 */
589 if (device->brightness->flags._BCL_reversed)
590 bqc_value = device->brightness->count -
591 ACPI_VIDEO_FIRST_LEVEL - 1 - bqc_value;
592
593 level = device->brightness->levels[bqc_value +
594 ACPI_VIDEO_FIRST_LEVEL];
595 } else {
596 level = bqc_value;
597 }
598
599 level += bqc_offset_aml_bug_workaround;
600
601 return level;
602 }
603
604 static int
605 acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
606 unsigned long long *level, bool raw)
607 {
608 acpi_status status = AE_OK;
609 int i;
610
611 if (device->cap._BQC || device->cap._BCQ) {
612 char *buf = device->cap._BQC ? "_BQC" : "_BCQ";
613
614 status = acpi_evaluate_integer(device->dev->handle, buf,
615 NULL, level);
616 if (ACPI_SUCCESS(status)) {
617 if (raw) {
618 /*
619 * Caller has indicated he wants the raw
620 * value returned by _BQC, so don't furtherly
621 * mess with the value.
622 */
623 return 0;
624 }
625
626 *level = acpi_video_bqc_value_to_level(device, *level);
627
628 for (i = ACPI_VIDEO_FIRST_LEVEL;
629 i < device->brightness->count; i++)
630 if (device->brightness->levels[i] == *level) {
631 device->brightness->curr = *level;
632 return 0;
633 }
634 /*
635 * BQC returned an invalid level.
636 * Stop using it.
637 */
638 ACPI_WARNING((AE_INFO,
639 "%s returned an invalid level",
640 buf));
641 device->cap._BQC = device->cap._BCQ = 0;
642 } else {
643 /*
644 * Fixme:
645 * should we return an error or ignore this failure?
646 * dev->brightness->curr is a cached value which stores
647 * the correct current backlight level in most cases.
648 * ACPI video backlight still works w/ buggy _BQC.
649 * http://bugzilla.kernel.org/show_bug.cgi?id=12233
650 */
651 ACPI_WARNING((AE_INFO, "Evaluating %s failed", buf));
652 device->cap._BQC = device->cap._BCQ = 0;
653 }
654 }
655
656 *level = device->brightness->curr;
657 return 0;
658 }
659
660 static int
661 acpi_video_device_EDID(struct acpi_video_device *device,
662 union acpi_object **edid, ssize_t length)
663 {
664 int status;
665 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
666 union acpi_object *obj;
667 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
668 struct acpi_object_list args = { 1, &arg0 };
669
670
671 *edid = NULL;
672
673 if (!device)
674 return -ENODEV;
675 if (length == 128)
676 arg0.integer.value = 1;
677 else if (length == 256)
678 arg0.integer.value = 2;
679 else
680 return -EINVAL;
681
682 status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer);
683 if (ACPI_FAILURE(status))
684 return -ENODEV;
685
686 obj = buffer.pointer;
687
688 if (obj && obj->type == ACPI_TYPE_BUFFER)
689 *edid = obj;
690 else {
691 printk(KERN_ERR PREFIX "Invalid _DDC data\n");
692 status = -EFAULT;
693 kfree(obj);
694 }
695
696 return status;
697 }
698
699 /* bus */
700
701 /*
702 * Arg:
703 * video : video bus device pointer
704 * bios_flag :
705 * 0. The system BIOS should NOT automatically switch(toggle)
706 * the active display output.
707 * 1. The system BIOS should automatically switch (toggle) the
708 * active display output. No switch event.
709 * 2. The _DGS value should be locked.
710 * 3. The system BIOS should not automatically switch (toggle) the
711 * active display output, but instead generate the display switch
712 * event notify code.
713 * lcd_flag :
714 * 0. The system BIOS should automatically control the brightness level
715 * of the LCD when the power changes from AC to DC
716 * 1. The system BIOS should NOT automatically control the brightness
717 * level of the LCD when the power changes from AC to DC.
718 * Return Value:
719 * -EINVAL wrong arg.
720 */
721
722 static int
723 acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
724 {
725 acpi_status status;
726
727 if (!video->cap._DOS)
728 return 0;
729
730 if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1)
731 return -EINVAL;
732 video->dos_setting = (lcd_flag << 2) | bios_flag;
733 status = acpi_execute_simple_method(video->device->handle, "_DOS",
734 (lcd_flag << 2) | bios_flag);
735 if (ACPI_FAILURE(status))
736 return -EIO;
737
738 return 0;
739 }
740
741 /*
742 * Simple comparison function used to sort backlight levels.
743 */
744
745 static int
746 acpi_video_cmp_level(const void *a, const void *b)
747 {
748 return *(int *)a - *(int *)b;
749 }
750
751 /*
752 * Decides if _BQC/_BCQ for this system is usable
753 *
754 * We do this by changing the level first and then read out the current
755 * brightness level, if the value does not match, find out if it is using
756 * index. If not, clear the _BQC/_BCQ capability.
757 */
758 static int acpi_video_bqc_quirk(struct acpi_video_device *device,
759 int max_level, int current_level)
760 {
761 struct acpi_video_device_brightness *br = device->brightness;
762 int result;
763 unsigned long long level;
764 int test_level;
765
766 /* don't mess with existing known broken systems */
767 if (bqc_offset_aml_bug_workaround)
768 return 0;
769
770 /*
771 * Some systems always report current brightness level as maximum
772 * through _BQC, we need to test another value for them. However,
773 * there is a subtlety:
774 *
775 * If the _BCL package ordering is descending, the first level
776 * (br->levels[2]) is likely to be 0, and if the number of levels
777 * matches the number of steps, we might confuse a returned level to
778 * mean the index.
779 *
780 * For example:
781 *
782 * current_level = max_level = 100
783 * test_level = 0
784 * returned level = 100
785 *
786 * In this case 100 means the level, not the index, and _BCM failed.
787 * Still, if the _BCL package ordering is descending, the index of
788 * level 0 is also 100, so we assume _BQC is indexed, when it's not.
789 *
790 * This causes all _BQC calls to return bogus values causing weird
791 * behavior from the user's perspective. For example:
792 *
793 * xbacklight -set 10; xbacklight -set 20;
794 *
795 * would flash to 90% and then slowly down to the desired level (20).
796 *
797 * The solution is simple; test anything other than the first level
798 * (e.g. 1).
799 */
800 test_level = current_level == max_level
801 ? br->levels[ACPI_VIDEO_FIRST_LEVEL + 1]
802 : max_level;
803
804 result = acpi_video_device_lcd_set_level(device, test_level);
805 if (result)
806 return result;
807
808 result = acpi_video_device_lcd_get_level_current(device, &level, true);
809 if (result)
810 return result;
811
812 if (level != test_level) {
813 /* buggy _BQC found, need to find out if it uses index */
814 if (level < br->count) {
815 if (br->flags._BCL_reversed)
816 level = br->count - ACPI_VIDEO_FIRST_LEVEL - 1 - level;
817 if (br->levels[level + ACPI_VIDEO_FIRST_LEVEL] == test_level)
818 br->flags._BQC_use_index = 1;
819 }
820
821 if (!br->flags._BQC_use_index)
822 device->cap._BQC = device->cap._BCQ = 0;
823 }
824
825 return 0;
826 }
827
828 int acpi_video_get_levels(struct acpi_device *device,
829 struct acpi_video_device_brightness **dev_br,
830 int *pmax_level)
831 {
832 union acpi_object *obj = NULL;
833 int i, max_level = 0, count = 0, level_ac_battery = 0;
834 union acpi_object *o;
835 struct acpi_video_device_brightness *br = NULL;
836 int result = 0;
837 u32 value;
838
839 if (!ACPI_SUCCESS(acpi_video_device_lcd_query_levels(device->handle,
840 &obj))) {
841 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Could not query available "
842 "LCD brightness level\n"));
843 result = -ENODEV;
844 goto out;
845 }
846
847 if (obj->package.count < ACPI_VIDEO_FIRST_LEVEL) {
848 result = -EINVAL;
849 goto out;
850 }
851
852 br = kzalloc(sizeof(*br), GFP_KERNEL);
853 if (!br) {
854 printk(KERN_ERR "can't allocate memory\n");
855 result = -ENOMEM;
856 goto out;
857 }
858
859 /*
860 * Note that we have to reserve 2 extra items (ACPI_VIDEO_FIRST_LEVEL),
861 * in order to account for buggy BIOS which don't export the first two
862 * special levels (see below)
863 */
864 br->levels = kmalloc_array(obj->package.count + ACPI_VIDEO_FIRST_LEVEL,
865 sizeof(*br->levels),
866 GFP_KERNEL);
867 if (!br->levels) {
868 result = -ENOMEM;
869 goto out_free;
870 }
871
872 for (i = 0; i < obj->package.count; i++) {
873 o = (union acpi_object *)&obj->package.elements[i];
874 if (o->type != ACPI_TYPE_INTEGER) {
875 printk(KERN_ERR PREFIX "Invalid data\n");
876 continue;
877 }
878 value = (u32) o->integer.value;
879 /* Skip duplicate entries */
880 if (count > ACPI_VIDEO_FIRST_LEVEL
881 && br->levels[count - 1] == value)
882 continue;
883
884 br->levels[count] = value;
885
886 if (br->levels[count] > max_level)
887 max_level = br->levels[count];
888 count++;
889 }
890
891 /*
892 * some buggy BIOS don't export the levels
893 * when machine is on AC/Battery in _BCL package.
894 * In this case, the first two elements in _BCL packages
895 * are also supported brightness levels that OS should take care of.
896 */
897 for (i = ACPI_VIDEO_FIRST_LEVEL; i < count; i++) {
898 if (br->levels[i] == br->levels[ACPI_VIDEO_AC_LEVEL])
899 level_ac_battery++;
900 if (br->levels[i] == br->levels[ACPI_VIDEO_BATTERY_LEVEL])
901 level_ac_battery++;
902 }
903
904 if (level_ac_battery < ACPI_VIDEO_FIRST_LEVEL) {
905 level_ac_battery = ACPI_VIDEO_FIRST_LEVEL - level_ac_battery;
906 br->flags._BCL_no_ac_battery_levels = 1;
907 for (i = (count - 1 + level_ac_battery);
908 i >= ACPI_VIDEO_FIRST_LEVEL; i--)
909 br->levels[i] = br->levels[i - level_ac_battery];
910 count += level_ac_battery;
911 } else if (level_ac_battery > ACPI_VIDEO_FIRST_LEVEL)
912 ACPI_ERROR((AE_INFO, "Too many duplicates in _BCL package"));
913
914 /* Check if the _BCL package is in a reversed order */
915 if (max_level == br->levels[ACPI_VIDEO_FIRST_LEVEL]) {
916 br->flags._BCL_reversed = 1;
917 sort(&br->levels[ACPI_VIDEO_FIRST_LEVEL],
918 count - ACPI_VIDEO_FIRST_LEVEL,
919 sizeof(br->levels[ACPI_VIDEO_FIRST_LEVEL]),
920 acpi_video_cmp_level, NULL);
921 } else if (max_level != br->levels[count - 1])
922 ACPI_ERROR((AE_INFO,
923 "Found unordered _BCL package"));
924
925 br->count = count;
926 *dev_br = br;
927 if (pmax_level)
928 *pmax_level = max_level;
929
930 out:
931 kfree(obj);
932 return result;
933 out_free:
934 kfree(br);
935 goto out;
936 }
937 EXPORT_SYMBOL(acpi_video_get_levels);
938
939 /*
940 * Arg:
941 * device : video output device (LCD, CRT, ..)
942 *
943 * Return Value:
944 * Maximum brightness level
945 *
946 * Allocate and initialize device->brightness.
947 */
948
949 static int
950 acpi_video_init_brightness(struct acpi_video_device *device)
951 {
952 int i, max_level = 0;
953 unsigned long long level, level_old;
954 struct acpi_video_device_brightness *br = NULL;
955 int result = -EINVAL;
956
957 result = acpi_video_get_levels(device->dev, &br, &max_level);
958 if (result)
959 return result;
960 device->brightness = br;
961
962 /* _BQC uses INDEX while _BCL uses VALUE in some laptops */
963 br->curr = level = max_level;
964
965 if (!device->cap._BQC)
966 goto set_level;
967
968 result = acpi_video_device_lcd_get_level_current(device,
969 &level_old, true);
970 if (result)
971 goto out_free_levels;
972
973 result = acpi_video_bqc_quirk(device, max_level, level_old);
974 if (result)
975 goto out_free_levels;
976 /*
977 * cap._BQC may get cleared due to _BQC is found to be broken
978 * in acpi_video_bqc_quirk, so check again here.
979 */
980 if (!device->cap._BQC)
981 goto set_level;
982
983 level = acpi_video_bqc_value_to_level(device, level_old);
984 /*
985 * On some buggy laptops, _BQC returns an uninitialized
986 * value when invoked for the first time, i.e.
987 * level_old is invalid (no matter whether it's a level
988 * or an index). Set the backlight to max_level in this case.
989 */
990 for (i = ACPI_VIDEO_FIRST_LEVEL; i < br->count; i++)
991 if (level == br->levels[i])
992 break;
993 if (i == br->count || !level)
994 level = max_level;
995
996 set_level:
997 result = acpi_video_device_lcd_set_level(device, level);
998 if (result)
999 goto out_free_levels;
1000
1001 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1002 "found %d brightness levels\n",
1003 br->count - ACPI_VIDEO_FIRST_LEVEL));
1004 return 0;
1005
1006 out_free_levels:
1007 kfree(br->levels);
1008 kfree(br);
1009 device->brightness = NULL;
1010 return result;
1011 }
1012
1013 /*
1014 * Arg:
1015 * device : video output device (LCD, CRT, ..)
1016 *
1017 * Return Value:
1018 * None
1019 *
1020 * Find out all required AML methods defined under the output
1021 * device.
1022 */
1023
1024 static void acpi_video_device_find_cap(struct acpi_video_device *device)
1025 {
1026 if (acpi_has_method(device->dev->handle, "_ADR"))
1027 device->cap._ADR = 1;
1028 if (acpi_has_method(device->dev->handle, "_BCL"))
1029 device->cap._BCL = 1;
1030 if (acpi_has_method(device->dev->handle, "_BCM"))
1031 device->cap._BCM = 1;
1032 if (acpi_has_method(device->dev->handle, "_BQC")) {
1033 device->cap._BQC = 1;
1034 } else if (acpi_has_method(device->dev->handle, "_BCQ")) {
1035 printk(KERN_WARNING FW_BUG "_BCQ is used instead of _BQC\n");
1036 device->cap._BCQ = 1;
1037 }
1038
1039 if (acpi_has_method(device->dev->handle, "_DDC"))
1040 device->cap._DDC = 1;
1041 }
1042
1043 /*
1044 * Arg:
1045 * device : video output device (VGA)
1046 *
1047 * Return Value:
1048 * None
1049 *
1050 * Find out all required AML methods defined under the video bus device.
1051 */
1052
1053 static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
1054 {
1055 if (acpi_has_method(video->device->handle, "_DOS"))
1056 video->cap._DOS = 1;
1057 if (acpi_has_method(video->device->handle, "_DOD"))
1058 video->cap._DOD = 1;
1059 if (acpi_has_method(video->device->handle, "_ROM"))
1060 video->cap._ROM = 1;
1061 if (acpi_has_method(video->device->handle, "_GPD"))
1062 video->cap._GPD = 1;
1063 if (acpi_has_method(video->device->handle, "_SPD"))
1064 video->cap._SPD = 1;
1065 if (acpi_has_method(video->device->handle, "_VPO"))
1066 video->cap._VPO = 1;
1067 }
1068
1069 /*
1070 * Check whether the video bus device has required AML method to
1071 * support the desired features
1072 */
1073
1074 static int acpi_video_bus_check(struct acpi_video_bus *video)
1075 {
1076 acpi_status status = -ENOENT;
1077 struct pci_dev *dev;
1078
1079 if (!video)
1080 return -EINVAL;
1081
1082 dev = acpi_get_pci_dev(video->device->handle);
1083 if (!dev)
1084 return -ENODEV;
1085 pci_dev_put(dev);
1086
1087 /*
1088 * Since there is no HID, CID and so on for VGA driver, we have
1089 * to check well known required nodes.
1090 */
1091
1092 /* Does this device support video switching? */
1093 if (video->cap._DOS || video->cap._DOD) {
1094 if (!video->cap._DOS) {
1095 printk(KERN_WARNING FW_BUG
1096 "ACPI(%s) defines _DOD but not _DOS\n",
1097 acpi_device_bid(video->device));
1098 }
1099 video->flags.multihead = 1;
1100 status = 0;
1101 }
1102
1103 /* Does this device support retrieving a video ROM? */
1104 if (video->cap._ROM) {
1105 video->flags.rom = 1;
1106 status = 0;
1107 }
1108
1109 /* Does this device support configuring which video device to POST? */
1110 if (video->cap._GPD && video->cap._SPD && video->cap._VPO) {
1111 video->flags.post = 1;
1112 status = 0;
1113 }
1114
1115 return status;
1116 }
1117
1118 /*
1119 * --------------------------------------------------------------------------
1120 * Driver Interface
1121 * --------------------------------------------------------------------------
1122 */
1123
1124 /* device interface */
1125 static struct acpi_video_device_attrib *
1126 acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id)
1127 {
1128 struct acpi_video_enumerated_device *ids;
1129 int i;
1130
1131 for (i = 0; i < video->attached_count; i++) {
1132 ids = &video->attached_array[i];
1133 if ((ids->value.int_val & 0xffff) == device_id)
1134 return &ids->value.attrib;
1135 }
1136
1137 return NULL;
1138 }
1139
1140 static int
1141 acpi_video_get_device_type(struct acpi_video_bus *video,
1142 unsigned long device_id)
1143 {
1144 struct acpi_video_enumerated_device *ids;
1145 int i;
1146
1147 for (i = 0; i < video->attached_count; i++) {
1148 ids = &video->attached_array[i];
1149 if ((ids->value.int_val & 0xffff) == device_id)
1150 return ids->value.int_val;
1151 }
1152
1153 return 0;
1154 }
1155
1156 static int
1157 acpi_video_bus_get_one_device(struct acpi_device *device,
1158 struct acpi_video_bus *video)
1159 {
1160 unsigned long long device_id;
1161 int status, device_type;
1162 struct acpi_video_device *data;
1163 struct acpi_video_device_attrib *attribute;
1164
1165 status =
1166 acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
1167 /* Some device omits _ADR, we skip them instead of fail */
1168 if (ACPI_FAILURE(status))
1169 return 0;
1170
1171 data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
1172 if (!data)
1173 return -ENOMEM;
1174
1175 strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
1176 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
1177 device->driver_data = data;
1178
1179 data->device_id = device_id;
1180 data->video = video;
1181 data->dev = device;
1182 INIT_DELAYED_WORK(&data->switch_brightness_work,
1183 acpi_video_switch_brightness);
1184
1185 attribute = acpi_video_get_device_attr(video, device_id);
1186
1187 if (attribute && (attribute->device_id_scheme || device_id_scheme)) {
1188 switch (attribute->display_type) {
1189 case ACPI_VIDEO_DISPLAY_CRT:
1190 data->flags.crt = 1;
1191 break;
1192 case ACPI_VIDEO_DISPLAY_TV:
1193 data->flags.tvout = 1;
1194 break;
1195 case ACPI_VIDEO_DISPLAY_DVI:
1196 data->flags.dvi = 1;
1197 break;
1198 case ACPI_VIDEO_DISPLAY_LCD:
1199 data->flags.lcd = 1;
1200 break;
1201 default:
1202 data->flags.unknown = 1;
1203 break;
1204 }
1205 if (attribute->bios_can_detect)
1206 data->flags.bios = 1;
1207 } else {
1208 /* Check for legacy IDs */
1209 device_type = acpi_video_get_device_type(video, device_id);
1210 /* Ignore bits 16 and 18-20 */
1211 switch (device_type & 0xffe2ffff) {
1212 case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR:
1213 data->flags.crt = 1;
1214 break;
1215 case ACPI_VIDEO_DISPLAY_LEGACY_PANEL:
1216 data->flags.lcd = 1;
1217 break;
1218 case ACPI_VIDEO_DISPLAY_LEGACY_TV:
1219 data->flags.tvout = 1;
1220 break;
1221 default:
1222 data->flags.unknown = 1;
1223 }
1224 }
1225
1226 acpi_video_device_bind(video, data);
1227 acpi_video_device_find_cap(data);
1228
1229 mutex_lock(&video->device_list_lock);
1230 list_add_tail(&data->entry, &video->video_device_list);
1231 mutex_unlock(&video->device_list_lock);
1232
1233 return status;
1234 }
1235
1236 /*
1237 * Arg:
1238 * video : video bus device
1239 *
1240 * Return:
1241 * none
1242 *
1243 * Enumerate the video device list of the video bus,
1244 * bind the ids with the corresponding video devices
1245 * under the video bus.
1246 */
1247
1248 static void acpi_video_device_rebind(struct acpi_video_bus *video)
1249 {
1250 struct acpi_video_device *dev;
1251
1252 mutex_lock(&video->device_list_lock);
1253
1254 list_for_each_entry(dev, &video->video_device_list, entry)
1255 acpi_video_device_bind(video, dev);
1256
1257 mutex_unlock(&video->device_list_lock);
1258 }
1259
1260 /*
1261 * Arg:
1262 * video : video bus device
1263 * device : video output device under the video
1264 * bus
1265 *
1266 * Return:
1267 * none
1268 *
1269 * Bind the ids with the corresponding video devices
1270 * under the video bus.
1271 */
1272
1273 static void
1274 acpi_video_device_bind(struct acpi_video_bus *video,
1275 struct acpi_video_device *device)
1276 {
1277 struct acpi_video_enumerated_device *ids;
1278 int i;
1279
1280 for (i = 0; i < video->attached_count; i++) {
1281 ids = &video->attached_array[i];
1282 if (device->device_id == (ids->value.int_val & 0xffff)) {
1283 ids->bind_info = device;
1284 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "device_bind %d\n", i));
1285 }
1286 }
1287 }
1288
1289 static bool acpi_video_device_in_dod(struct acpi_video_device *device)
1290 {
1291 struct acpi_video_bus *video = device->video;
1292 int i;
1293
1294 /*
1295 * If we have a broken _DOD or we have more than 8 output devices
1296 * under the graphics controller node that we can't proper deal with
1297 * in the operation region code currently, no need to test.
1298 */
1299 if (!video->attached_count || video->child_count > 8)
1300 return true;
1301
1302 for (i = 0; i < video->attached_count; i++) {
1303 if ((video->attached_array[i].value.int_val & 0xfff) ==
1304 (device->device_id & 0xfff))
1305 return true;
1306 }
1307
1308 return false;
1309 }
1310
1311 /*
1312 * Arg:
1313 * video : video bus device
1314 *
1315 * Return:
1316 * < 0 : error
1317 *
1318 * Call _DOD to enumerate all devices attached to display adapter
1319 *
1320 */
1321
1322 static int acpi_video_device_enumerate(struct acpi_video_bus *video)
1323 {
1324 int status;
1325 int count;
1326 int i;
1327 struct acpi_video_enumerated_device *active_list;
1328 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1329 union acpi_object *dod = NULL;
1330 union acpi_object *obj;
1331
1332 if (!video->cap._DOD)
1333 return AE_NOT_EXIST;
1334
1335 status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
1336 if (!ACPI_SUCCESS(status)) {
1337 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD"));
1338 return status;
1339 }
1340
1341 dod = buffer.pointer;
1342 if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
1343 ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data"));
1344 status = -EFAULT;
1345 goto out;
1346 }
1347
1348 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d video heads in _DOD\n",
1349 dod->package.count));
1350
1351 active_list = kcalloc(1 + dod->package.count,
1352 sizeof(struct acpi_video_enumerated_device),
1353 GFP_KERNEL);
1354 if (!active_list) {
1355 status = -ENOMEM;
1356 goto out;
1357 }
1358
1359 count = 0;
1360 for (i = 0; i < dod->package.count; i++) {
1361 obj = &dod->package.elements[i];
1362
1363 if (obj->type != ACPI_TYPE_INTEGER) {
1364 printk(KERN_ERR PREFIX
1365 "Invalid _DOD data in element %d\n", i);
1366 continue;
1367 }
1368
1369 active_list[count].value.int_val = obj->integer.value;
1370 active_list[count].bind_info = NULL;
1371 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "dod element[%d] = %d\n", i,
1372 (int)obj->integer.value));
1373 count++;
1374 }
1375
1376 kfree(video->attached_array);
1377
1378 video->attached_array = active_list;
1379 video->attached_count = count;
1380
1381 out:
1382 kfree(buffer.pointer);
1383 return status;
1384 }
1385
1386 static int
1387 acpi_video_get_next_level(struct acpi_video_device *device,
1388 u32 level_current, u32 event)
1389 {
1390 int min, max, min_above, max_below, i, l, delta = 255;
1391 max = max_below = 0;
1392 min = min_above = 255;
1393 /* Find closest level to level_current */
1394 for (i = ACPI_VIDEO_FIRST_LEVEL; i < device->brightness->count; i++) {
1395 l = device->brightness->levels[i];
1396 if (abs(l - level_current) < abs(delta)) {
1397 delta = l - level_current;
1398 if (!delta)
1399 break;
1400 }
1401 }
1402 /* Ajust level_current to closest available level */
1403 level_current += delta;
1404 for (i = ACPI_VIDEO_FIRST_LEVEL; i < device->brightness->count; i++) {
1405 l = device->brightness->levels[i];
1406 if (l < min)
1407 min = l;
1408 if (l > max)
1409 max = l;
1410 if (l < min_above && l > level_current)
1411 min_above = l;
1412 if (l > max_below && l < level_current)
1413 max_below = l;
1414 }
1415
1416 switch (event) {
1417 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:
1418 return (level_current < max) ? min_above : min;
1419 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:
1420 return (level_current < max) ? min_above : max;
1421 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:
1422 return (level_current > min) ? max_below : min;
1423 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:
1424 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:
1425 return 0;
1426 default:
1427 return level_current;
1428 }
1429 }
1430
1431 static void
1432 acpi_video_switch_brightness(struct work_struct *work)
1433 {
1434 struct acpi_video_device *device = container_of(to_delayed_work(work),
1435 struct acpi_video_device, switch_brightness_work);
1436 unsigned long long level_current, level_next;
1437 int event = device->switch_brightness_event;
1438 int result = -EINVAL;
1439
1440 /* no warning message if acpi_backlight=vendor or a quirk is used */
1441 if (!device->backlight)
1442 return;
1443
1444 if (!device->brightness)
1445 goto out;
1446
1447 result = acpi_video_device_lcd_get_level_current(device,
1448 &level_current,
1449 false);
1450 if (result)
1451 goto out;
1452
1453 level_next = acpi_video_get_next_level(device, level_current, event);
1454
1455 result = acpi_video_device_lcd_set_level(device, level_next);
1456
1457 if (!result)
1458 backlight_force_update(device->backlight,
1459 BACKLIGHT_UPDATE_HOTKEY);
1460
1461 out:
1462 if (result)
1463 printk(KERN_ERR PREFIX "Failed to switch the brightness\n");
1464 }
1465
1466 int acpi_video_get_edid(struct acpi_device *device, int type, int device_id,
1467 void **edid)
1468 {
1469 struct acpi_video_bus *video;
1470 struct acpi_video_device *video_device;
1471 union acpi_object *buffer = NULL;
1472 acpi_status status;
1473 int i, length;
1474
1475 if (!device || !acpi_driver_data(device))
1476 return -EINVAL;
1477
1478 video = acpi_driver_data(device);
1479
1480 for (i = 0; i < video->attached_count; i++) {
1481 video_device = video->attached_array[i].bind_info;
1482 length = 256;
1483
1484 if (!video_device)
1485 continue;
1486
1487 if (!video_device->cap._DDC)
1488 continue;
1489
1490 if (type) {
1491 switch (type) {
1492 case ACPI_VIDEO_DISPLAY_CRT:
1493 if (!video_device->flags.crt)
1494 continue;
1495 break;
1496 case ACPI_VIDEO_DISPLAY_TV:
1497 if (!video_device->flags.tvout)
1498 continue;
1499 break;
1500 case ACPI_VIDEO_DISPLAY_DVI:
1501 if (!video_device->flags.dvi)
1502 continue;
1503 break;
1504 case ACPI_VIDEO_DISPLAY_LCD:
1505 if (!video_device->flags.lcd)
1506 continue;
1507 break;
1508 }
1509 } else if (video_device->device_id != device_id) {
1510 continue;
1511 }
1512
1513 status = acpi_video_device_EDID(video_device, &buffer, length);
1514
1515 if (ACPI_FAILURE(status) || !buffer ||
1516 buffer->type != ACPI_TYPE_BUFFER) {
1517 length = 128;
1518 status = acpi_video_device_EDID(video_device, &buffer,
1519 length);
1520 if (ACPI_FAILURE(status) || !buffer ||
1521 buffer->type != ACPI_TYPE_BUFFER) {
1522 continue;
1523 }
1524 }
1525
1526 *edid = buffer->buffer.pointer;
1527 return length;
1528 }
1529
1530 return -ENODEV;
1531 }
1532 EXPORT_SYMBOL(acpi_video_get_edid);
1533
1534 static int
1535 acpi_video_bus_get_devices(struct acpi_video_bus *video,
1536 struct acpi_device *device)
1537 {
1538 int status = 0;
1539 struct acpi_device *dev;
1540
1541 /*
1542 * There are systems where video module known to work fine regardless
1543 * of broken _DOD and ignoring returned value here doesn't cause
1544 * any issues later.
1545 */
1546 acpi_video_device_enumerate(video);
1547
1548 list_for_each_entry(dev, &device->children, node) {
1549
1550 status = acpi_video_bus_get_one_device(dev, video);
1551 if (status) {
1552 dev_err(&dev->dev, "Can't attach device\n");
1553 break;
1554 }
1555 video->child_count++;
1556 }
1557 return status;
1558 }
1559
1560 /* acpi_video interface */
1561
1562 /*
1563 * Win8 requires setting bit2 of _DOS to let firmware know it shouldn't
1564 * preform any automatic brightness change on receiving a notification.
1565 */
1566 static int acpi_video_bus_start_devices(struct acpi_video_bus *video)
1567 {
1568 return acpi_video_bus_DOS(video, 0,
1569 acpi_osi_is_win8() ? 1 : 0);
1570 }
1571
1572 static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
1573 {
1574 return acpi_video_bus_DOS(video, 0,
1575 acpi_osi_is_win8() ? 0 : 1);
1576 }
1577
1578 static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
1579 {
1580 struct acpi_video_bus *video = acpi_driver_data(device);
1581 struct input_dev *input;
1582 int keycode = 0;
1583
1584 if (!video || !video->input)
1585 return;
1586
1587 input = video->input;
1588
1589 switch (event) {
1590 case ACPI_VIDEO_NOTIFY_SWITCH: /* User requested a switch,
1591 * most likely via hotkey. */
1592 keycode = KEY_SWITCHVIDEOMODE;
1593 break;
1594
1595 case ACPI_VIDEO_NOTIFY_PROBE: /* User plugged in or removed a video
1596 * connector. */
1597 acpi_video_device_enumerate(video);
1598 acpi_video_device_rebind(video);
1599 keycode = KEY_SWITCHVIDEOMODE;
1600 break;
1601
1602 case ACPI_VIDEO_NOTIFY_CYCLE: /* Cycle Display output hotkey pressed. */
1603 keycode = KEY_SWITCHVIDEOMODE;
1604 break;
1605 case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT: /* Next Display output hotkey pressed. */
1606 keycode = KEY_VIDEO_NEXT;
1607 break;
1608 case ACPI_VIDEO_NOTIFY_PREV_OUTPUT: /* previous Display output hotkey pressed. */
1609 keycode = KEY_VIDEO_PREV;
1610 break;
1611
1612 default:
1613 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1614 "Unsupported event [0x%x]\n", event));
1615 break;
1616 }
1617
1618 if (acpi_notifier_call_chain(device, event, 0))
1619 /* Something vetoed the keypress. */
1620 keycode = 0;
1621
1622 if (keycode && (report_key_events & REPORT_OUTPUT_KEY_EVENTS)) {
1623 input_report_key(input, keycode, 1);
1624 input_sync(input);
1625 input_report_key(input, keycode, 0);
1626 input_sync(input);
1627 }
1628
1629 return;
1630 }
1631
1632 static void brightness_switch_event(struct acpi_video_device *video_device,
1633 u32 event)
1634 {
1635 if (!brightness_switch_enabled)
1636 return;
1637
1638 video_device->switch_brightness_event = event;
1639 schedule_delayed_work(&video_device->switch_brightness_work, HZ / 10);
1640 }
1641
1642 static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
1643 {
1644 struct acpi_video_device *video_device = data;
1645 struct acpi_device *device = NULL;
1646 struct acpi_video_bus *bus;
1647 struct input_dev *input;
1648 int keycode = 0;
1649
1650 if (!video_device)
1651 return;
1652
1653 device = video_device->dev;
1654 bus = video_device->video;
1655 input = bus->input;
1656
1657 if (hw_changes_brightness > 0) {
1658 if (video_device->backlight)
1659 backlight_force_update(video_device->backlight,
1660 BACKLIGHT_UPDATE_HOTKEY);
1661 acpi_notifier_call_chain(device, event, 0);
1662 return;
1663 }
1664
1665 switch (event) {
1666 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: /* Cycle brightness */
1667 brightness_switch_event(video_device, event);
1668 keycode = KEY_BRIGHTNESS_CYCLE;
1669 break;
1670 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: /* Increase brightness */
1671 brightness_switch_event(video_device, event);
1672 keycode = KEY_BRIGHTNESSUP;
1673 break;
1674 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: /* Decrease brightness */
1675 brightness_switch_event(video_device, event);
1676 keycode = KEY_BRIGHTNESSDOWN;
1677 break;
1678 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightness */
1679 brightness_switch_event(video_device, event);
1680 keycode = KEY_BRIGHTNESS_ZERO;
1681 break;
1682 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: /* display device off */
1683 brightness_switch_event(video_device, event);
1684 keycode = KEY_DISPLAY_OFF;
1685 break;
1686 default:
1687 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1688 "Unsupported event [0x%x]\n", event));
1689 break;
1690 }
1691
1692 acpi_notifier_call_chain(device, event, 0);
1693
1694 if (keycode && (report_key_events & REPORT_BRIGHTNESS_KEY_EVENTS)) {
1695 input_report_key(input, keycode, 1);
1696 input_sync(input);
1697 input_report_key(input, keycode, 0);
1698 input_sync(input);
1699 }
1700
1701 return;
1702 }
1703
1704 static int acpi_video_resume(struct notifier_block *nb,
1705 unsigned long val, void *ign)
1706 {
1707 struct acpi_video_bus *video;
1708 struct acpi_video_device *video_device;
1709 int i;
1710
1711 switch (val) {
1712 case PM_HIBERNATION_PREPARE:
1713 case PM_SUSPEND_PREPARE:
1714 case PM_RESTORE_PREPARE:
1715 return NOTIFY_DONE;
1716 }
1717
1718 video = container_of(nb, struct acpi_video_bus, pm_nb);
1719
1720 dev_info(&video->device->dev, "Restoring backlight state\n");
1721
1722 for (i = 0; i < video->attached_count; i++) {
1723 video_device = video->attached_array[i].bind_info;
1724 if (video_device && video_device->brightness)
1725 acpi_video_device_lcd_set_level(video_device,
1726 video_device->brightness->curr);
1727 }
1728
1729 return NOTIFY_OK;
1730 }
1731
1732 static acpi_status
1733 acpi_video_bus_match(acpi_handle handle, u32 level, void *context,
1734 void **return_value)
1735 {
1736 struct acpi_device *device = context;
1737 struct acpi_device *sibling;
1738 int result;
1739
1740 if (handle == device->handle)
1741 return AE_CTRL_TERMINATE;
1742
1743 result = acpi_bus_get_device(handle, &sibling);
1744 if (result)
1745 return AE_OK;
1746
1747 if (!strcmp(acpi_device_name(sibling), ACPI_VIDEO_BUS_NAME))
1748 return AE_ALREADY_EXISTS;
1749
1750 return AE_OK;
1751 }
1752
1753 static void acpi_video_dev_register_backlight(struct acpi_video_device *device)
1754 {
1755 struct backlight_properties props;
1756 struct pci_dev *pdev;
1757 acpi_handle acpi_parent;
1758 struct device *parent = NULL;
1759 int result;
1760 static int count;
1761 char *name;
1762
1763 result = acpi_video_init_brightness(device);
1764 if (result)
1765 return;
1766
1767 if (disable_backlight_sysfs_if > 0)
1768 return;
1769
1770 name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
1771 if (!name)
1772 return;
1773 count++;
1774
1775 acpi_get_parent(device->dev->handle, &acpi_parent);
1776
1777 pdev = acpi_get_pci_dev(acpi_parent);
1778 if (pdev) {
1779 parent = &pdev->dev;
1780 pci_dev_put(pdev);
1781 }
1782
1783 memset(&props, 0, sizeof(struct backlight_properties));
1784 props.type = BACKLIGHT_FIRMWARE;
1785 props.max_brightness =
1786 device->brightness->count - ACPI_VIDEO_FIRST_LEVEL - 1;
1787 device->backlight = backlight_device_register(name,
1788 parent,
1789 device,
1790 &acpi_backlight_ops,
1791 &props);
1792 kfree(name);
1793 if (IS_ERR(device->backlight)) {
1794 device->backlight = NULL;
1795 return;
1796 }
1797
1798 /*
1799 * Save current brightness level in case we have to restore it
1800 * before acpi_video_device_lcd_set_level() is called next time.
1801 */
1802 device->backlight->props.brightness =
1803 acpi_video_get_brightness(device->backlight);
1804
1805 device->cooling_dev = thermal_cooling_device_register("LCD",
1806 device->dev, &video_cooling_ops);
1807 if (IS_ERR(device->cooling_dev)) {
1808 /*
1809 * Set cooling_dev to NULL so we don't crash trying to free it.
1810 * Also, why the hell we are returning early and not attempt to
1811 * register video output if cooling device registration failed?
1812 * -- dtor
1813 */
1814 device->cooling_dev = NULL;
1815 return;
1816 }
1817
1818 dev_info(&device->dev->dev, "registered as cooling_device%d\n",
1819 device->cooling_dev->id);
1820 result = sysfs_create_link(&device->dev->dev.kobj,
1821 &device->cooling_dev->device.kobj,
1822 "thermal_cooling");
1823 if (result)
1824 printk(KERN_ERR PREFIX "Create sysfs link\n");
1825 result = sysfs_create_link(&device->cooling_dev->device.kobj,
1826 &device->dev->dev.kobj, "device");
1827 if (result)
1828 printk(KERN_ERR PREFIX "Create sysfs link\n");
1829 }
1830
1831 static void acpi_video_run_bcl_for_osi(struct acpi_video_bus *video)
1832 {
1833 struct acpi_video_device *dev;
1834 union acpi_object *levels;
1835
1836 mutex_lock(&video->device_list_lock);
1837 list_for_each_entry(dev, &video->video_device_list, entry) {
1838 if (!acpi_video_device_lcd_query_levels(dev->dev->handle, &levels))
1839 kfree(levels);
1840 }
1841 mutex_unlock(&video->device_list_lock);
1842 }
1843
1844 static bool acpi_video_should_register_backlight(struct acpi_video_device *dev)
1845 {
1846 /*
1847 * Do not create backlight device for video output
1848 * device that is not in the enumerated list.
1849 */
1850 if (!acpi_video_device_in_dod(dev)) {
1851 dev_dbg(&dev->dev->dev, "not in _DOD list, ignore\n");
1852 return false;
1853 }
1854
1855 if (only_lcd)
1856 return dev->flags.lcd;
1857 return true;
1858 }
1859
1860 static int acpi_video_bus_register_backlight(struct acpi_video_bus *video)
1861 {
1862 struct acpi_video_device *dev;
1863
1864 if (video->backlight_registered)
1865 return 0;
1866
1867 acpi_video_run_bcl_for_osi(video);
1868
1869 if (acpi_video_get_backlight_type() != acpi_backlight_video)
1870 return 0;
1871
1872 mutex_lock(&video->device_list_lock);
1873 list_for_each_entry(dev, &video->video_device_list, entry) {
1874 if (acpi_video_should_register_backlight(dev))
1875 acpi_video_dev_register_backlight(dev);
1876 }
1877 mutex_unlock(&video->device_list_lock);
1878
1879 video->backlight_registered = true;
1880
1881 video->pm_nb.notifier_call = acpi_video_resume;
1882 video->pm_nb.priority = 0;
1883 return register_pm_notifier(&video->pm_nb);
1884 }
1885
1886 static void acpi_video_dev_unregister_backlight(struct acpi_video_device *device)
1887 {
1888 if (device->backlight) {
1889 backlight_device_unregister(device->backlight);
1890 device->backlight = NULL;
1891 }
1892 if (device->brightness) {
1893 kfree(device->brightness->levels);
1894 kfree(device->brightness);
1895 device->brightness = NULL;
1896 }
1897 if (device->cooling_dev) {
1898 sysfs_remove_link(&device->dev->dev.kobj, "thermal_cooling");
1899 sysfs_remove_link(&device->cooling_dev->device.kobj, "device");
1900 thermal_cooling_device_unregister(device->cooling_dev);
1901 device->cooling_dev = NULL;
1902 }
1903 }
1904
1905 static int acpi_video_bus_unregister_backlight(struct acpi_video_bus *video)
1906 {
1907 struct acpi_video_device *dev;
1908 int error;
1909
1910 if (!video->backlight_registered)
1911 return 0;
1912
1913 error = unregister_pm_notifier(&video->pm_nb);
1914
1915 mutex_lock(&video->device_list_lock);
1916 list_for_each_entry(dev, &video->video_device_list, entry)
1917 acpi_video_dev_unregister_backlight(dev);
1918 mutex_unlock(&video->device_list_lock);
1919
1920 video->backlight_registered = false;
1921
1922 return error;
1923 }
1924
1925 static void acpi_video_dev_add_notify_handler(struct acpi_video_device *device)
1926 {
1927 acpi_status status;
1928 struct acpi_device *adev = device->dev;
1929
1930 status = acpi_install_notify_handler(adev->handle, ACPI_DEVICE_NOTIFY,
1931 acpi_video_device_notify, device);
1932 if (ACPI_FAILURE(status))
1933 dev_err(&adev->dev, "Error installing notify handler\n");
1934 else
1935 device->flags.notify = 1;
1936 }
1937
1938 static int acpi_video_bus_add_notify_handler(struct acpi_video_bus *video)
1939 {
1940 struct input_dev *input;
1941 struct acpi_video_device *dev;
1942 int error;
1943
1944 video->input = input = input_allocate_device();
1945 if (!input) {
1946 error = -ENOMEM;
1947 goto out;
1948 }
1949
1950 error = acpi_video_bus_start_devices(video);
1951 if (error)
1952 goto err_free_input;
1953
1954 snprintf(video->phys, sizeof(video->phys),
1955 "%s/video/input0", acpi_device_hid(video->device));
1956
1957 input->name = acpi_device_name(video->device);
1958 input->phys = video->phys;
1959 input->id.bustype = BUS_HOST;
1960 input->id.product = 0x06;
1961 input->dev.parent = &video->device->dev;
1962 input->evbit[0] = BIT(EV_KEY);
1963 set_bit(KEY_SWITCHVIDEOMODE, input->keybit);
1964 set_bit(KEY_VIDEO_NEXT, input->keybit);
1965 set_bit(KEY_VIDEO_PREV, input->keybit);
1966 set_bit(KEY_BRIGHTNESS_CYCLE, input->keybit);
1967 set_bit(KEY_BRIGHTNESSUP, input->keybit);
1968 set_bit(KEY_BRIGHTNESSDOWN, input->keybit);
1969 set_bit(KEY_BRIGHTNESS_ZERO, input->keybit);
1970 set_bit(KEY_DISPLAY_OFF, input->keybit);
1971
1972 error = input_register_device(input);
1973 if (error)
1974 goto err_stop_dev;
1975
1976 mutex_lock(&video->device_list_lock);
1977 list_for_each_entry(dev, &video->video_device_list, entry)
1978 acpi_video_dev_add_notify_handler(dev);
1979 mutex_unlock(&video->device_list_lock);
1980
1981 return 0;
1982
1983 err_stop_dev:
1984 acpi_video_bus_stop_devices(video);
1985 err_free_input:
1986 input_free_device(input);
1987 video->input = NULL;
1988 out:
1989 return error;
1990 }
1991
1992 static void acpi_video_dev_remove_notify_handler(struct acpi_video_device *dev)
1993 {
1994 if (dev->flags.notify) {
1995 acpi_remove_notify_handler(dev->dev->handle, ACPI_DEVICE_NOTIFY,
1996 acpi_video_device_notify);
1997 dev->flags.notify = 0;
1998 }
1999 }
2000
2001 static void acpi_video_bus_remove_notify_handler(struct acpi_video_bus *video)
2002 {
2003 struct acpi_video_device *dev;
2004
2005 mutex_lock(&video->device_list_lock);
2006 list_for_each_entry(dev, &video->video_device_list, entry)
2007 acpi_video_dev_remove_notify_handler(dev);
2008 mutex_unlock(&video->device_list_lock);
2009
2010 acpi_video_bus_stop_devices(video);
2011 input_unregister_device(video->input);
2012 video->input = NULL;
2013 }
2014
2015 static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
2016 {
2017 struct acpi_video_device *dev, *next;
2018
2019 mutex_lock(&video->device_list_lock);
2020 list_for_each_entry_safe(dev, next, &video->video_device_list, entry) {
2021 list_del(&dev->entry);
2022 kfree(dev);
2023 }
2024 mutex_unlock(&video->device_list_lock);
2025
2026 return 0;
2027 }
2028
2029 static int instance;
2030
2031 static int acpi_video_bus_add(struct acpi_device *device)
2032 {
2033 struct acpi_video_bus *video;
2034 int error;
2035 acpi_status status;
2036
2037 status = acpi_walk_namespace(ACPI_TYPE_DEVICE,
2038 device->parent->handle, 1,
2039 acpi_video_bus_match, NULL,
2040 device, NULL);
2041 if (status == AE_ALREADY_EXISTS) {
2042 printk(KERN_WARNING FW_BUG
2043 "Duplicate ACPI video bus devices for the"
2044 " same VGA controller, please try module "
2045 "parameter \"video.allow_duplicates=1\""
2046 "if the current driver doesn't work.\n");
2047 if (!allow_duplicates)
2048 return -ENODEV;
2049 }
2050
2051 video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
2052 if (!video)
2053 return -ENOMEM;
2054
2055 /* a hack to fix the duplicate name "VID" problem on T61 */
2056 if (!strcmp(device->pnp.bus_id, "VID")) {
2057 if (instance)
2058 device->pnp.bus_id[3] = '0' + instance;
2059 instance++;
2060 }
2061 /* a hack to fix the duplicate name "VGA" problem on Pa 3553 */
2062 if (!strcmp(device->pnp.bus_id, "VGA")) {
2063 if (instance)
2064 device->pnp.bus_id[3] = '0' + instance;
2065 instance++;
2066 }
2067
2068 video->device = device;
2069 strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
2070 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
2071 device->driver_data = video;
2072
2073 acpi_video_bus_find_cap(video);
2074 error = acpi_video_bus_check(video);
2075 if (error)
2076 goto err_free_video;
2077
2078 mutex_init(&video->device_list_lock);
2079 INIT_LIST_HEAD(&video->video_device_list);
2080
2081 error = acpi_video_bus_get_devices(video, device);
2082 if (error)
2083 goto err_put_video;
2084
2085 printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s rom: %s post: %s)\n",
2086 ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
2087 video->flags.multihead ? "yes" : "no",
2088 video->flags.rom ? "yes" : "no",
2089 video->flags.post ? "yes" : "no");
2090 mutex_lock(&video_list_lock);
2091 list_add_tail(&video->entry, &video_bus_head);
2092 mutex_unlock(&video_list_lock);
2093
2094 acpi_video_bus_register_backlight(video);
2095 acpi_video_bus_add_notify_handler(video);
2096
2097 return 0;
2098
2099 err_put_video:
2100 acpi_video_bus_put_devices(video);
2101 kfree(video->attached_array);
2102 err_free_video:
2103 kfree(video);
2104 device->driver_data = NULL;
2105
2106 return error;
2107 }
2108
2109 static int acpi_video_bus_remove(struct acpi_device *device)
2110 {
2111 struct acpi_video_bus *video = NULL;
2112
2113
2114 if (!device || !acpi_driver_data(device))
2115 return -EINVAL;
2116
2117 video = acpi_driver_data(device);
2118
2119 acpi_video_bus_remove_notify_handler(video);
2120 acpi_video_bus_unregister_backlight(video);
2121 acpi_video_bus_put_devices(video);
2122
2123 mutex_lock(&video_list_lock);
2124 list_del(&video->entry);
2125 mutex_unlock(&video_list_lock);
2126
2127 kfree(video->attached_array);
2128 kfree(video);
2129
2130 return 0;
2131 }
2132
2133 static int __init is_i740(struct pci_dev *dev)
2134 {
2135 if (dev->device == 0x00D1)
2136 return 1;
2137 if (dev->device == 0x7000)
2138 return 1;
2139 return 0;
2140 }
2141
2142 static int __init intel_opregion_present(void)
2143 {
2144 int opregion = 0;
2145 struct pci_dev *dev = NULL;
2146 u32 address;
2147
2148 for_each_pci_dev(dev) {
2149 if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
2150 continue;
2151 if (dev->vendor != PCI_VENDOR_ID_INTEL)
2152 continue;
2153 /* We don't want to poke around undefined i740 registers */
2154 if (is_i740(dev))
2155 continue;
2156 pci_read_config_dword(dev, 0xfc, &address);
2157 if (!address)
2158 continue;
2159 opregion = 1;
2160 }
2161 return opregion;
2162 }
2163
2164 /* Check if the chassis-type indicates there is no builtin LCD panel */
2165 static bool dmi_is_desktop(void)
2166 {
2167 const char *chassis_type;
2168 unsigned long type;
2169
2170 chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE);
2171 if (!chassis_type)
2172 return false;
2173
2174 if (kstrtoul(chassis_type, 10, &type) != 0)
2175 return false;
2176
2177 switch (type) {
2178 case 0x03: /* Desktop */
2179 case 0x04: /* Low Profile Desktop */
2180 case 0x05: /* Pizza Box */
2181 case 0x06: /* Mini Tower */
2182 case 0x07: /* Tower */
2183 case 0x10: /* Lunch Box */
2184 case 0x11: /* Main Server Chassis */
2185 return true;
2186 }
2187
2188 return false;
2189 }
2190
2191 int acpi_video_register(void)
2192 {
2193 int ret = 0;
2194
2195 mutex_lock(&register_count_mutex);
2196 if (register_count) {
2197 /*
2198 * if the function of acpi_video_register is already called,
2199 * don't register the acpi_vide_bus again and return no error.
2200 */
2201 goto leave;
2202 }
2203
2204 /*
2205 * We're seeing a lot of bogus backlight interfaces on newer machines
2206 * without a LCD such as desktops, servers and HDMI sticks. Checking
2207 * the lcd flag fixes this, so enable this on any machines which are
2208 * win8 ready (where we also prefer the native backlight driver, so
2209 * normally the acpi_video code should not register there anyways).
2210 */
2211 if (only_lcd == -1) {
2212 if (dmi_is_desktop() && acpi_osi_is_win8())
2213 only_lcd = true;
2214 else
2215 only_lcd = false;
2216 }
2217
2218 dmi_check_system(video_dmi_table);
2219
2220 ret = acpi_bus_register_driver(&acpi_video_bus);
2221 if (ret)
2222 goto leave;
2223
2224 /*
2225 * When the acpi_video_bus is loaded successfully, increase
2226 * the counter reference.
2227 */
2228 register_count = 1;
2229
2230 leave:
2231 mutex_unlock(&register_count_mutex);
2232 return ret;
2233 }
2234 EXPORT_SYMBOL(acpi_video_register);
2235
2236 void acpi_video_unregister(void)
2237 {
2238 mutex_lock(&register_count_mutex);
2239 if (register_count) {
2240 acpi_bus_unregister_driver(&acpi_video_bus);
2241 register_count = 0;
2242 }
2243 mutex_unlock(&register_count_mutex);
2244 }
2245 EXPORT_SYMBOL(acpi_video_unregister);
2246
2247 void acpi_video_unregister_backlight(void)
2248 {
2249 struct acpi_video_bus *video;
2250
2251 mutex_lock(&register_count_mutex);
2252 if (register_count) {
2253 mutex_lock(&video_list_lock);
2254 list_for_each_entry(video, &video_bus_head, entry)
2255 acpi_video_bus_unregister_backlight(video);
2256 mutex_unlock(&video_list_lock);
2257 }
2258 mutex_unlock(&register_count_mutex);
2259 }
2260
2261 bool acpi_video_handles_brightness_key_presses(void)
2262 {
2263 bool have_video_busses;
2264
2265 mutex_lock(&video_list_lock);
2266 have_video_busses = !list_empty(&video_bus_head);
2267 mutex_unlock(&video_list_lock);
2268
2269 return have_video_busses &&
2270 (report_key_events & REPORT_BRIGHTNESS_KEY_EVENTS);
2271 }
2272 EXPORT_SYMBOL(acpi_video_handles_brightness_key_presses);
2273
2274 /*
2275 * This is kind of nasty. Hardware using Intel chipsets may require
2276 * the video opregion code to be run first in order to initialise
2277 * state before any ACPI video calls are made. To handle this we defer
2278 * registration of the video class until the opregion code has run.
2279 */
2280
2281 static int __init acpi_video_init(void)
2282 {
2283 /*
2284 * Let the module load even if ACPI is disabled (e.g. due to
2285 * a broken BIOS) so that i915.ko can still be loaded on such
2286 * old systems without an AcpiOpRegion.
2287 *
2288 * acpi_video_register() will report -ENODEV later as well due
2289 * to acpi_disabled when i915.ko tries to register itself afterwards.
2290 */
2291 if (acpi_disabled)
2292 return 0;
2293
2294 if (intel_opregion_present())
2295 return 0;
2296
2297 return acpi_video_register();
2298 }
2299
2300 static void __exit acpi_video_exit(void)
2301 {
2302 acpi_video_detect_exit();
2303 acpi_video_unregister();
2304
2305 return;
2306 }
2307
2308 module_init(acpi_video_init);
2309 module_exit(acpi_video_exit);
Linux with added FPC-III support