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 if (!video->cap._DOD) 1250 return AE_NOT_EXIST; 1251 1252 status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer); 1253 if (!ACPI_SUCCESS(status)) { 1254 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD")); 1255 return status; 1256 } 1257 1258 dod = buffer.pointer; 1259 if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) { 1260 ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data")); 1261 status = -EFAULT; 1262 goto out; 1263 } 1264 1265 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d video heads in _DOD\n", 1266 dod->package.count)); 1267 1268 active_list = kcalloc(1 + dod->package.count, 1269 sizeof(struct acpi_video_enumerated_device), 1270 GFP_KERNEL); 1271 if (!active_list) { 1272 status = -ENOMEM; 1273 goto out; 1274 } 1275 1276 count = 0; 1277 for (i = 0; i < dod->package.count; i++) { 1278 obj = &dod->package.elements[i]; 1279 1280 if (obj->type != ACPI_TYPE_INTEGER) { 1281 printk(KERN_ERR PREFIX 1282 "Invalid _DOD data in element %d\n", i); 1283 continue; 1284 } 1285 1286 active_list[count].value.int_val = obj->integer.value; 1287 active_list[count].bind_info = NULL; 1288 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "dod element[%d] = %d\n", i, 1289 (int)obj->integer.value)); 1290 count++; 1291 } 1292 1293 kfree(video->attached_array); 1294 1295 video->attached_array = active_list; 1296 video->attached_count = count; 1297 1298 out: 1299 kfree(buffer.pointer); 1300 return status; 1301 } 1302 1303 static int 1304 acpi_video_get_next_level(struct acpi_video_device *device, 1305 u32 level_current, u32 event) 1306 { 1307 int min, max, min_above, max_below, i, l, delta = 255; 1308 max = max_below = 0; 1309 min = min_above = 255; 1310 /* Find closest level to level_current */ 1311 for (i = 2; i < device->brightness->count; i++) { 1312 l = device->brightness->levels[i]; 1313 if (abs(l - level_current) < abs(delta)) { 1314 delta = l - level_current; 1315 if (!delta) 1316 break; 1317 } 1318 } 1319 /* Ajust level_current to closest available level */ 1320 level_current += delta; 1321 for (i = 2; i < device->brightness->count; i++) { 1322 l = device->brightness->levels[i]; 1323 if (l < min) 1324 min = l; 1325 if (l > max) 1326 max = l; 1327 if (l < min_above && l > level_current) 1328 min_above = l; 1329 if (l > max_below && l < level_current) 1330 max_below = l; 1331 } 1332 1333 switch (event) { 1334 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: 1335 return (level_current < max) ? min_above : min; 1336 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: 1337 return (level_current < max) ? min_above : max; 1338 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: 1339 return (level_current > min) ? max_below : min; 1340 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: 1341 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: 1342 return 0; 1343 default: 1344 return level_current; 1345 } 1346 } 1347 1348 static void 1349 acpi_video_switch_brightness(struct work_struct *work) 1350 { 1351 struct acpi_video_device *device = container_of(to_delayed_work(work), 1352 struct acpi_video_device, switch_brightness_work); 1353 unsigned long long level_current, level_next; 1354 int event = device->switch_brightness_event; 1355 int result = -EINVAL; 1356 1357 /* no warning message if acpi_backlight=vendor or a quirk is used */ 1358 if (!device->backlight) 1359 return; 1360 1361 if (!device->brightness) 1362 goto out; 1363 1364 result = acpi_video_device_lcd_get_level_current(device, 1365 &level_current, 1366 false); 1367 if (result) 1368 goto out; 1369 1370 level_next = acpi_video_get_next_level(device, level_current, event); 1371 1372 result = acpi_video_device_lcd_set_level(device, level_next); 1373 1374 if (!result) 1375 backlight_force_update(device->backlight, 1376 BACKLIGHT_UPDATE_HOTKEY); 1377 1378 out: 1379 if (result) 1380 printk(KERN_ERR PREFIX "Failed to switch the brightness\n"); 1381 } 1382 1383 int acpi_video_get_edid(struct acpi_device *device, int type, int device_id, 1384 void **edid) 1385 { 1386 struct acpi_video_bus *video; 1387 struct acpi_video_device *video_device; 1388 union acpi_object *buffer = NULL; 1389 acpi_status status; 1390 int i, length; 1391 1392 if (!device || !acpi_driver_data(device)) 1393 return -EINVAL; 1394 1395 video = acpi_driver_data(device); 1396 1397 for (i = 0; i < video->attached_count; i++) { 1398 video_device = video->attached_array[i].bind_info; 1399 length = 256; 1400 1401 if (!video_device) 1402 continue; 1403 1404 if (!video_device->cap._DDC) 1405 continue; 1406 1407 if (type) { 1408 switch (type) { 1409 case ACPI_VIDEO_DISPLAY_CRT: 1410 if (!video_device->flags.crt) 1411 continue; 1412 break; 1413 case ACPI_VIDEO_DISPLAY_TV: 1414 if (!video_device->flags.tvout) 1415 continue; 1416 break; 1417 case ACPI_VIDEO_DISPLAY_DVI: 1418 if (!video_device->flags.dvi) 1419 continue; 1420 break; 1421 case ACPI_VIDEO_DISPLAY_LCD: 1422 if (!video_device->flags.lcd) 1423 continue; 1424 break; 1425 } 1426 } else if (video_device->device_id != device_id) { 1427 continue; 1428 } 1429 1430 status = acpi_video_device_EDID(video_device, &buffer, length); 1431 1432 if (ACPI_FAILURE(status) || !buffer || 1433 buffer->type != ACPI_TYPE_BUFFER) { 1434 length = 128; 1435 status = acpi_video_device_EDID(video_device, &buffer, 1436 length); 1437 if (ACPI_FAILURE(status) || !buffer || 1438 buffer->type != ACPI_TYPE_BUFFER) { 1439 continue; 1440 } 1441 } 1442 1443 *edid = buffer->buffer.pointer; 1444 return length; 1445 } 1446 1447 return -ENODEV; 1448 } 1449 EXPORT_SYMBOL(acpi_video_get_edid); 1450 1451 static int 1452 acpi_video_bus_get_devices(struct acpi_video_bus *video, 1453 struct acpi_device *device) 1454 { 1455 int status = 0; 1456 struct acpi_device *dev; 1457 1458 /* 1459 * There are systems where video module known to work fine regardless 1460 * of broken _DOD and ignoring returned value here doesn't cause 1461 * any issues later. 1462 */ 1463 acpi_video_device_enumerate(video); 1464 1465 list_for_each_entry(dev, &device->children, node) { 1466 1467 status = acpi_video_bus_get_one_device(dev, video); 1468 if (status) { 1469 dev_err(&dev->dev, "Can't attach device\n"); 1470 break; 1471 } 1472 video->child_count++; 1473 } 1474 return status; 1475 } 1476 1477 /* acpi_video interface */ 1478 1479 /* 1480 * Win8 requires setting bit2 of _DOS to let firmware know it shouldn't 1481 * preform any automatic brightness change on receiving a notification. 1482 */ 1483 static int acpi_video_bus_start_devices(struct acpi_video_bus *video) 1484 { 1485 return acpi_video_bus_DOS(video, 0, 1486 acpi_osi_is_win8() ? 1 : 0); 1487 } 1488 1489 static int acpi_video_bus_stop_devices(struct acpi_video_bus *video) 1490 { 1491 return acpi_video_bus_DOS(video, 0, 1492 acpi_osi_is_win8() ? 0 : 1); 1493 } 1494 1495 static void acpi_video_bus_notify(struct acpi_device *device, u32 event) 1496 { 1497 struct acpi_video_bus *video = acpi_driver_data(device); 1498 struct input_dev *input; 1499 int keycode = 0; 1500 1501 if (!video || !video->input) 1502 return; 1503 1504 input = video->input; 1505 1506 switch (event) { 1507 case ACPI_VIDEO_NOTIFY_SWITCH: /* User requested a switch, 1508 * most likely via hotkey. */ 1509 keycode = KEY_SWITCHVIDEOMODE; 1510 break; 1511 1512 case ACPI_VIDEO_NOTIFY_PROBE: /* User plugged in or removed a video 1513 * connector. */ 1514 acpi_video_device_enumerate(video); 1515 acpi_video_device_rebind(video); 1516 keycode = KEY_SWITCHVIDEOMODE; 1517 break; 1518 1519 case ACPI_VIDEO_NOTIFY_CYCLE: /* Cycle Display output hotkey pressed. */ 1520 keycode = KEY_SWITCHVIDEOMODE; 1521 break; 1522 case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT: /* Next Display output hotkey pressed. */ 1523 keycode = KEY_VIDEO_NEXT; 1524 break; 1525 case ACPI_VIDEO_NOTIFY_PREV_OUTPUT: /* previous Display output hotkey pressed. */ 1526 keycode = KEY_VIDEO_PREV; 1527 break; 1528 1529 default: 1530 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 1531 "Unsupported event [0x%x]\n", event)); 1532 break; 1533 } 1534 1535 if (acpi_notifier_call_chain(device, event, 0)) 1536 /* Something vetoed the keypress. */ 1537 keycode = 0; 1538 1539 if (keycode && (report_key_events & REPORT_OUTPUT_KEY_EVENTS)) { 1540 input_report_key(input, keycode, 1); 1541 input_sync(input); 1542 input_report_key(input, keycode, 0); 1543 input_sync(input); 1544 } 1545 1546 return; 1547 } 1548 1549 static void brightness_switch_event(struct acpi_video_device *video_device, 1550 u32 event) 1551 { 1552 if (!brightness_switch_enabled) 1553 return; 1554 1555 video_device->switch_brightness_event = event; 1556 schedule_delayed_work(&video_device->switch_brightness_work, HZ / 10); 1557 } 1558 1559 static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data) 1560 { 1561 struct acpi_video_device *video_device = data; 1562 struct acpi_device *device = NULL; 1563 struct acpi_video_bus *bus; 1564 struct input_dev *input; 1565 int keycode = 0; 1566 1567 if (!video_device) 1568 return; 1569 1570 device = video_device->dev; 1571 bus = video_device->video; 1572 input = bus->input; 1573 1574 switch (event) { 1575 case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS: /* Cycle brightness */ 1576 brightness_switch_event(video_device, event); 1577 keycode = KEY_BRIGHTNESS_CYCLE; 1578 break; 1579 case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS: /* Increase brightness */ 1580 brightness_switch_event(video_device, event); 1581 keycode = KEY_BRIGHTNESSUP; 1582 break; 1583 case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS: /* Decrease brightness */ 1584 brightness_switch_event(video_device, event); 1585 keycode = KEY_BRIGHTNESSDOWN; 1586 break; 1587 case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightness */ 1588 brightness_switch_event(video_device, event); 1589 keycode = KEY_BRIGHTNESS_ZERO; 1590 break; 1591 case ACPI_VIDEO_NOTIFY_DISPLAY_OFF: /* display device off */ 1592 brightness_switch_event(video_device, event); 1593 keycode = KEY_DISPLAY_OFF; 1594 break; 1595 default: 1596 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 1597 "Unsupported event [0x%x]\n", event)); 1598 break; 1599 } 1600 1601 acpi_notifier_call_chain(device, event, 0); 1602 1603 if (keycode && (report_key_events & REPORT_BRIGHTNESS_KEY_EVENTS)) { 1604 input_report_key(input, keycode, 1); 1605 input_sync(input); 1606 input_report_key(input, keycode, 0); 1607 input_sync(input); 1608 } 1609 1610 return; 1611 } 1612 1613 static int acpi_video_resume(struct notifier_block *nb, 1614 unsigned long val, void *ign) 1615 { 1616 struct acpi_video_bus *video; 1617 struct acpi_video_device *video_device; 1618 int i; 1619 1620 switch (val) { 1621 case PM_HIBERNATION_PREPARE: 1622 case PM_SUSPEND_PREPARE: 1623 case PM_RESTORE_PREPARE: 1624 return NOTIFY_DONE; 1625 } 1626 1627 video = container_of(nb, struct acpi_video_bus, pm_nb); 1628 1629 dev_info(&video->device->dev, "Restoring backlight state\n"); 1630 1631 for (i = 0; i < video->attached_count; i++) { 1632 video_device = video->attached_array[i].bind_info; 1633 if (video_device && video_device->brightness) 1634 acpi_video_device_lcd_set_level(video_device, 1635 video_device->brightness->curr); 1636 } 1637 1638 return NOTIFY_OK; 1639 } 1640 1641 static acpi_status 1642 acpi_video_bus_match(acpi_handle handle, u32 level, void *context, 1643 void **return_value) 1644 { 1645 struct acpi_device *device = context; 1646 struct acpi_device *sibling; 1647 int result; 1648 1649 if (handle == device->handle) 1650 return AE_CTRL_TERMINATE; 1651 1652 result = acpi_bus_get_device(handle, &sibling); 1653 if (result) 1654 return AE_OK; 1655 1656 if (!strcmp(acpi_device_name(sibling), ACPI_VIDEO_BUS_NAME)) 1657 return AE_ALREADY_EXISTS; 1658 1659 return AE_OK; 1660 } 1661 1662 static void acpi_video_dev_register_backlight(struct acpi_video_device *device) 1663 { 1664 struct backlight_properties props; 1665 struct pci_dev *pdev; 1666 acpi_handle acpi_parent; 1667 struct device *parent = NULL; 1668 int result; 1669 static int count; 1670 char *name; 1671 1672 result = acpi_video_init_brightness(device); 1673 if (result) 1674 return; 1675 1676 if (disable_backlight_sysfs_if > 0) 1677 return; 1678 1679 name = kasprintf(GFP_KERNEL, "acpi_video%d", count); 1680 if (!name) 1681 return; 1682 count++; 1683 1684 acpi_get_parent(device->dev->handle, &acpi_parent); 1685 1686 pdev = acpi_get_pci_dev(acpi_parent); 1687 if (pdev) { 1688 parent = &pdev->dev; 1689 pci_dev_put(pdev); 1690 } 1691 1692 memset(&props, 0, sizeof(struct backlight_properties)); 1693 props.type = BACKLIGHT_FIRMWARE; 1694 props.max_brightness = device->brightness->count - 3; 1695 device->backlight = backlight_device_register(name, 1696 parent, 1697 device, 1698 &acpi_backlight_ops, 1699 &props); 1700 kfree(name); 1701 if (IS_ERR(device->backlight)) { 1702 device->backlight = NULL; 1703 return; 1704 } 1705 1706 /* 1707 * Save current brightness level in case we have to restore it 1708 * before acpi_video_device_lcd_set_level() is called next time. 1709 */ 1710 device->backlight->props.brightness = 1711 acpi_video_get_brightness(device->backlight); 1712 1713 device->cooling_dev = thermal_cooling_device_register("LCD", 1714 device->dev, &video_cooling_ops); 1715 if (IS_ERR(device->cooling_dev)) { 1716 /* 1717 * Set cooling_dev to NULL so we don't crash trying to free it. 1718 * Also, why the hell we are returning early and not attempt to 1719 * register video output if cooling device registration failed? 1720 * -- dtor 1721 */ 1722 device->cooling_dev = NULL; 1723 return; 1724 } 1725 1726 dev_info(&device->dev->dev, "registered as cooling_device%d\n", 1727 device->cooling_dev->id); 1728 result = sysfs_create_link(&device->dev->dev.kobj, 1729 &device->cooling_dev->device.kobj, 1730 "thermal_cooling"); 1731 if (result) 1732 printk(KERN_ERR PREFIX "Create sysfs link\n"); 1733 result = sysfs_create_link(&device->cooling_dev->device.kobj, 1734 &device->dev->dev.kobj, "device"); 1735 if (result) 1736 printk(KERN_ERR PREFIX "Create sysfs link\n"); 1737 } 1738 1739 static void acpi_video_run_bcl_for_osi(struct acpi_video_bus *video) 1740 { 1741 struct acpi_video_device *dev; 1742 union acpi_object *levels; 1743 1744 mutex_lock(&video->device_list_lock); 1745 list_for_each_entry(dev, &video->video_device_list, entry) { 1746 if (!acpi_video_device_lcd_query_levels(dev->dev->handle, &levels)) 1747 kfree(levels); 1748 } 1749 mutex_unlock(&video->device_list_lock); 1750 } 1751 1752 static bool acpi_video_should_register_backlight(struct acpi_video_device *dev) 1753 { 1754 /* 1755 * Do not create backlight device for video output 1756 * device that is not in the enumerated list. 1757 */ 1758 if (!acpi_video_device_in_dod(dev)) { 1759 dev_dbg(&dev->dev->dev, "not in _DOD list, ignore\n"); 1760 return false; 1761 } 1762 1763 if (only_lcd) 1764 return dev->flags.lcd; 1765 return true; 1766 } 1767 1768 static int acpi_video_bus_register_backlight(struct acpi_video_bus *video) 1769 { 1770 struct acpi_video_device *dev; 1771 1772 if (video->backlight_registered) 1773 return 0; 1774 1775 acpi_video_run_bcl_for_osi(video); 1776 1777 if (acpi_video_get_backlight_type() != acpi_backlight_video) 1778 return 0; 1779 1780 mutex_lock(&video->device_list_lock); 1781 list_for_each_entry(dev, &video->video_device_list, entry) { 1782 if (acpi_video_should_register_backlight(dev)) 1783 acpi_video_dev_register_backlight(dev); 1784 } 1785 mutex_unlock(&video->device_list_lock); 1786 1787 video->backlight_registered = true; 1788 1789 video->pm_nb.notifier_call = acpi_video_resume; 1790 video->pm_nb.priority = 0; 1791 return register_pm_notifier(&video->pm_nb); 1792 } 1793 1794 static void acpi_video_dev_unregister_backlight(struct acpi_video_device *device) 1795 { 1796 if (device->backlight) { 1797 backlight_device_unregister(device->backlight); 1798 device->backlight = NULL; 1799 } 1800 if (device->brightness) { 1801 kfree(device->brightness->levels); 1802 kfree(device->brightness); 1803 device->brightness = NULL; 1804 } 1805 if (device->cooling_dev) { 1806 sysfs_remove_link(&device->dev->dev.kobj, "thermal_cooling"); 1807 sysfs_remove_link(&device->cooling_dev->device.kobj, "device"); 1808 thermal_cooling_device_unregister(device->cooling_dev); 1809 device->cooling_dev = NULL; 1810 } 1811 } 1812 1813 static int acpi_video_bus_unregister_backlight(struct acpi_video_bus *video) 1814 { 1815 struct acpi_video_device *dev; 1816 int error; 1817 1818 if (!video->backlight_registered) 1819 return 0; 1820 1821 error = unregister_pm_notifier(&video->pm_nb); 1822 1823 mutex_lock(&video->device_list_lock); 1824 list_for_each_entry(dev, &video->video_device_list, entry) 1825 acpi_video_dev_unregister_backlight(dev); 1826 mutex_unlock(&video->device_list_lock); 1827 1828 video->backlight_registered = false; 1829 1830 return error; 1831 } 1832 1833 static void acpi_video_dev_add_notify_handler(struct acpi_video_device *device) 1834 { 1835 acpi_status status; 1836 struct acpi_device *adev = device->dev; 1837 1838 status = acpi_install_notify_handler(adev->handle, ACPI_DEVICE_NOTIFY, 1839 acpi_video_device_notify, device); 1840 if (ACPI_FAILURE(status)) 1841 dev_err(&adev->dev, "Error installing notify handler\n"); 1842 else 1843 device->flags.notify = 1; 1844 } 1845 1846 static int acpi_video_bus_add_notify_handler(struct acpi_video_bus *video) 1847 { 1848 struct input_dev *input; 1849 struct acpi_video_device *dev; 1850 int error; 1851 1852 video->input = input = input_allocate_device(); 1853 if (!input) { 1854 error = -ENOMEM; 1855 goto out; 1856 } 1857 1858 error = acpi_video_bus_start_devices(video); 1859 if (error) 1860 goto err_free_input; 1861 1862 snprintf(video->phys, sizeof(video->phys), 1863 "%s/video/input0", acpi_device_hid(video->device)); 1864 1865 input->name = acpi_device_name(video->device); 1866 input->phys = video->phys; 1867 input->id.bustype = BUS_HOST; 1868 input->id.product = 0x06; 1869 input->dev.parent = &video->device->dev; 1870 input->evbit[0] = BIT(EV_KEY); 1871 set_bit(KEY_SWITCHVIDEOMODE, input->keybit); 1872 set_bit(KEY_VIDEO_NEXT, input->keybit); 1873 set_bit(KEY_VIDEO_PREV, input->keybit); 1874 set_bit(KEY_BRIGHTNESS_CYCLE, input->keybit); 1875 set_bit(KEY_BRIGHTNESSUP, input->keybit); 1876 set_bit(KEY_BRIGHTNESSDOWN, input->keybit); 1877 set_bit(KEY_BRIGHTNESS_ZERO, input->keybit); 1878 set_bit(KEY_DISPLAY_OFF, input->keybit); 1879 1880 error = input_register_device(input); 1881 if (error) 1882 goto err_stop_dev; 1883 1884 mutex_lock(&video->device_list_lock); 1885 list_for_each_entry(dev, &video->video_device_list, entry) 1886 acpi_video_dev_add_notify_handler(dev); 1887 mutex_unlock(&video->device_list_lock); 1888 1889 return 0; 1890 1891 err_stop_dev: 1892 acpi_video_bus_stop_devices(video); 1893 err_free_input: 1894 input_free_device(input); 1895 video->input = NULL; 1896 out: 1897 return error; 1898 } 1899 1900 static void acpi_video_dev_remove_notify_handler(struct acpi_video_device *dev) 1901 { 1902 if (dev->flags.notify) { 1903 acpi_remove_notify_handler(dev->dev->handle, ACPI_DEVICE_NOTIFY, 1904 acpi_video_device_notify); 1905 dev->flags.notify = 0; 1906 } 1907 } 1908 1909 static void acpi_video_bus_remove_notify_handler(struct acpi_video_bus *video) 1910 { 1911 struct acpi_video_device *dev; 1912 1913 mutex_lock(&video->device_list_lock); 1914 list_for_each_entry(dev, &video->video_device_list, entry) 1915 acpi_video_dev_remove_notify_handler(dev); 1916 mutex_unlock(&video->device_list_lock); 1917 1918 acpi_video_bus_stop_devices(video); 1919 input_unregister_device(video->input); 1920 video->input = NULL; 1921 } 1922 1923 static int acpi_video_bus_put_devices(struct acpi_video_bus *video) 1924 { 1925 struct acpi_video_device *dev, *next; 1926 1927 mutex_lock(&video->device_list_lock); 1928 list_for_each_entry_safe(dev, next, &video->video_device_list, entry) { 1929 list_del(&dev->entry); 1930 kfree(dev); 1931 } 1932 mutex_unlock(&video->device_list_lock); 1933 1934 return 0; 1935 } 1936 1937 static int instance; 1938 1939 static int acpi_video_bus_add(struct acpi_device *device) 1940 { 1941 struct acpi_video_bus *video; 1942 int error; 1943 acpi_status status; 1944 1945 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, 1946 device->parent->handle, 1, 1947 acpi_video_bus_match, NULL, 1948 device, NULL); 1949 if (status == AE_ALREADY_EXISTS) { 1950 printk(KERN_WARNING FW_BUG 1951 "Duplicate ACPI video bus devices for the" 1952 " same VGA controller, please try module " 1953 "parameter \"video.allow_duplicates=1\"" 1954 "if the current driver doesn't work.\n"); 1955 if (!allow_duplicates) 1956 return -ENODEV; 1957 } 1958 1959 video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL); 1960 if (!video) 1961 return -ENOMEM; 1962 1963 /* a hack to fix the duplicate name "VID" problem on T61 */ 1964 if (!strcmp(device->pnp.bus_id, "VID")) { 1965 if (instance) 1966 device->pnp.bus_id[3] = '0' + instance; 1967 instance++; 1968 } 1969 /* a hack to fix the duplicate name "VGA" problem on Pa 3553 */ 1970 if (!strcmp(device->pnp.bus_id, "VGA")) { 1971 if (instance) 1972 device->pnp.bus_id[3] = '0' + instance; 1973 instance++; 1974 } 1975 1976 video->device = device; 1977 strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME); 1978 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS); 1979 device->driver_data = video; 1980 1981 acpi_video_bus_find_cap(video); 1982 error = acpi_video_bus_check(video); 1983 if (error) 1984 goto err_free_video; 1985 1986 mutex_init(&video->device_list_lock); 1987 INIT_LIST_HEAD(&video->video_device_list); 1988 1989 error = acpi_video_bus_get_devices(video, device); 1990 if (error) 1991 goto err_put_video; 1992 1993 printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s rom: %s post: %s)\n", 1994 ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device), 1995 video->flags.multihead ? "yes" : "no", 1996 video->flags.rom ? "yes" : "no", 1997 video->flags.post ? "yes" : "no"); 1998 mutex_lock(&video_list_lock); 1999 list_add_tail(&video->entry, &video_bus_head); 2000 mutex_unlock(&video_list_lock); 2001 2002 acpi_video_bus_register_backlight(video); 2003 acpi_video_bus_add_notify_handler(video); 2004 2005 return 0; 2006 2007 err_put_video: 2008 acpi_video_bus_put_devices(video); 2009 kfree(video->attached_array); 2010 err_free_video: 2011 kfree(video); 2012 device->driver_data = NULL; 2013 2014 return error; 2015 } 2016 2017 static int acpi_video_bus_remove(struct acpi_device *device) 2018 { 2019 struct acpi_video_bus *video = NULL; 2020 2021 2022 if (!device || !acpi_driver_data(device)) 2023 return -EINVAL; 2024 2025 video = acpi_driver_data(device); 2026 2027 acpi_video_bus_remove_notify_handler(video); 2028 acpi_video_bus_unregister_backlight(video); 2029 acpi_video_bus_put_devices(video); 2030 2031 mutex_lock(&video_list_lock); 2032 list_del(&video->entry); 2033 mutex_unlock(&video_list_lock); 2034 2035 kfree(video->attached_array); 2036 kfree(video); 2037 2038 return 0; 2039 } 2040 2041 static int __init is_i740(struct pci_dev *dev) 2042 { 2043 if (dev->device == 0x00D1) 2044 return 1; 2045 if (dev->device == 0x7000) 2046 return 1; 2047 return 0; 2048 } 2049 2050 static int __init intel_opregion_present(void) 2051 { 2052 int opregion = 0; 2053 struct pci_dev *dev = NULL; 2054 u32 address; 2055 2056 for_each_pci_dev(dev) { 2057 if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA) 2058 continue; 2059 if (dev->vendor != PCI_VENDOR_ID_INTEL) 2060 continue; 2061 /* We don't want to poke around undefined i740 registers */ 2062 if (is_i740(dev)) 2063 continue; 2064 pci_read_config_dword(dev, 0xfc, &address); 2065 if (!address) 2066 continue; 2067 opregion = 1; 2068 } 2069 return opregion; 2070 } 2071 2072 int acpi_video_register(void) 2073 { 2074 int ret = 0; 2075 2076 mutex_lock(®ister_count_mutex); 2077 if (register_count) { 2078 /* 2079 * if the function of acpi_video_register is already called, 2080 * don't register the acpi_vide_bus again and return no error. 2081 */ 2082 goto leave; 2083 } 2084 2085 dmi_check_system(video_dmi_table); 2086 2087 ret = acpi_bus_register_driver(&acpi_video_bus); 2088 if (ret) 2089 goto leave; 2090 2091 /* 2092 * When the acpi_video_bus is loaded successfully, increase 2093 * the counter reference. 2094 */ 2095 register_count = 1; 2096 2097 leave: 2098 mutex_unlock(®ister_count_mutex); 2099 return ret; 2100 } 2101 EXPORT_SYMBOL(acpi_video_register); 2102 2103 void acpi_video_unregister(void) 2104 { 2105 mutex_lock(®ister_count_mutex); 2106 if (register_count) { 2107 acpi_bus_unregister_driver(&acpi_video_bus); 2108 register_count = 0; 2109 } 2110 mutex_unlock(®ister_count_mutex); 2111 } 2112 EXPORT_SYMBOL(acpi_video_unregister); 2113 2114 void acpi_video_unregister_backlight(void) 2115 { 2116 struct acpi_video_bus *video; 2117 2118 mutex_lock(®ister_count_mutex); 2119 if (register_count) { 2120 mutex_lock(&video_list_lock); 2121 list_for_each_entry(video, &video_bus_head, entry) 2122 acpi_video_bus_unregister_backlight(video); 2123 mutex_unlock(&video_list_lock); 2124 } 2125 mutex_unlock(®ister_count_mutex); 2126 } 2127 2128 bool acpi_video_handles_brightness_key_presses(void) 2129 { 2130 bool have_video_busses; 2131 2132 mutex_lock(&video_list_lock); 2133 have_video_busses = !list_empty(&video_bus_head); 2134 mutex_unlock(&video_list_lock); 2135 2136 return have_video_busses && 2137 (report_key_events & REPORT_BRIGHTNESS_KEY_EVENTS); 2138 } 2139 EXPORT_SYMBOL(acpi_video_handles_brightness_key_presses); 2140 2141 /* 2142 * This is kind of nasty. Hardware using Intel chipsets may require 2143 * the video opregion code to be run first in order to initialise 2144 * state before any ACPI video calls are made. To handle this we defer 2145 * registration of the video class until the opregion code has run. 2146 */ 2147 2148 static int __init acpi_video_init(void) 2149 { 2150 /* 2151 * Let the module load even if ACPI is disabled (e.g. due to 2152 * a broken BIOS) so that i915.ko can still be loaded on such 2153 * old systems without an AcpiOpRegion. 2154 * 2155 * acpi_video_register() will report -ENODEV later as well due 2156 * to acpi_disabled when i915.ko tries to register itself afterwards. 2157 */ 2158 if (acpi_disabled) 2159 return 0; 2160 2161 if (intel_opregion_present()) 2162 return 0; 2163 2164 return acpi_video_register(); 2165 } 2166 2167 static void __exit acpi_video_exit(void) 2168 { 2169 acpi_video_detect_exit(); 2170 acpi_video_unregister(); 2171 2172 return; 2173 } 2174 2175 module_init(acpi_video_init); 2176 module_exit(acpi_video_exit); 2177