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