PageRenderTime 129ms CodeModel.GetById 20ms app.highlight 97ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/acpi/video.c

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