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