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