SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/acpi/video.c

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