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