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