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