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