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