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