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