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