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