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