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