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

source code of linux/drivers/acpi/acpi_video.c