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