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