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