drivers/acpi/acpi_video.c

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