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