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