drivers/acpi/video.c

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