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