acpi_video.c 54.6 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 *  video.c - ACPI Video Driver
L
Linus Torvalds 已提交
3 4 5
 *
 *  Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
 *  Copyright (C) 2004 Bruno Ducrot <ducrot@poupinou.org>
6
 *  Copyright (C) 2006 Thomas Tuttle <linux-kernel@ttuttle.net>
L
Linus Torvalds 已提交
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or (at
 *  your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#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 34
#include <linux/pci.h>
#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>
L
Linus Torvalds 已提交
41

42
#define PREFIX "ACPI: "
43

L
Linus Torvalds 已提交
44 45 46 47 48 49 50 51
#define ACPI_VIDEO_BUS_NAME		"Video Bus"
#define ACPI_VIDEO_DEVICE_NAME		"Video Device"
#define ACPI_VIDEO_NOTIFY_SWITCH	0x80
#define ACPI_VIDEO_NOTIFY_PROBE		0x81
#define ACPI_VIDEO_NOTIFY_CYCLE		0x82
#define ACPI_VIDEO_NOTIFY_NEXT_OUTPUT	0x83
#define ACPI_VIDEO_NOTIFY_PREV_OUTPUT	0x84

52 53 54 55 56
#define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS	0x85
#define	ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS	0x86
#define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS	0x87
#define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS	0x88
#define ACPI_VIDEO_NOTIFY_DISPLAY_OFF		0x89
L
Linus Torvalds 已提交
57

58
#define MAX_NAME_LEN	20
L
Linus Torvalds 已提交
59 60

#define _COMPONENT		ACPI_VIDEO_COMPONENT
61
ACPI_MODULE_NAME("video");
L
Linus Torvalds 已提交
62

63
MODULE_AUTHOR("Bruno Ducrot");
64
MODULE_DESCRIPTION("ACPI Video Driver");
L
Linus Torvalds 已提交
65 66
MODULE_LICENSE("GPL");

67
static bool brightness_switch_enabled = 1;
68 69
module_param(brightness_switch_enabled, bool, 0644);

70 71 72 73
/*
 * By default, we don't allow duplicate ACPI video bus devices
 * under the same VGA controller
 */
74
static bool allow_duplicates;
75 76
module_param(allow_duplicates, bool, 0644);

77 78 79
static int disable_backlight_sysfs_if = -1;
module_param(disable_backlight_sysfs_if, int, 0444);

80 81 82 83 84 85 86
#define REPORT_OUTPUT_KEY_EVENTS		0x01
#define REPORT_BRIGHTNESS_KEY_EVENTS		0x02
static int report_key_events = -1;
module_param(report_key_events, int, 0644);
MODULE_PARM_DESC(report_key_events,
	"0: none, 1: output changes, 2: brightness changes, 3: all");

87 88 89 90 91 92
static bool device_id_scheme = false;
module_param(device_id_scheme, bool, 0444);

static bool only_lcd = false;
module_param(only_lcd, bool, 0444);

93 94
static DECLARE_COMPLETION(register_done);
static DEFINE_MUTEX(register_done_mutex);
95 96
static struct mutex video_list_lock;
static struct list_head video_bus_head;
L
Len Brown 已提交
97
static int acpi_video_bus_add(struct acpi_device *device);
98
static int acpi_video_bus_remove(struct acpi_device *device);
99
static void acpi_video_bus_notify(struct acpi_device *device, u32 event);
100
void acpi_video_detect_exit(void);
L
Linus Torvalds 已提交
101

102 103 104 105 106 107
static const struct acpi_device_id video_device_ids[] = {
	{ACPI_VIDEO_HID, 0},
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, video_device_ids);

L
Linus Torvalds 已提交
108
static struct acpi_driver acpi_video_bus = {
L
Len Brown 已提交
109
	.name = "video",
L
Linus Torvalds 已提交
110
	.class = ACPI_VIDEO_CLASS,
111
	.ids = video_device_ids,
L
Linus Torvalds 已提交
112 113 114
	.ops = {
		.add = acpi_video_bus_add,
		.remove = acpi_video_bus_remove,
115
		.notify = acpi_video_bus_notify,
L
Len Brown 已提交
116
		},
L
Linus Torvalds 已提交
117 118 119
};

struct acpi_video_bus_flags {
L
Len Brown 已提交
120 121 122 123
	u8 multihead:1;		/* can switch video heads */
	u8 rom:1;		/* can retrieve a video rom */
	u8 post:1;		/* can configure the head to */
	u8 reserved:5;
L
Linus Torvalds 已提交
124 125 126
};

struct acpi_video_bus_cap {
127 128 129 130 131 132
	u8 _DOS:1;		/* Enable/Disable output switching */
	u8 _DOD:1;		/* Enumerate all devices attached to display adapter */
	u8 _ROM:1;		/* Get ROM Data */
	u8 _GPD:1;		/* Get POST Device */
	u8 _SPD:1;		/* Set POST Device */
	u8 _VPO:1;		/* Video POST Options */
L
Len Brown 已提交
133
	u8 reserved:2;
L
Linus Torvalds 已提交
134 135
};

L
Len Brown 已提交
136 137
struct acpi_video_device_attrib {
	u32 display_index:4;	/* A zero-based instance of the Display */
138 139 140 141 142
	u32 display_port_attachment:4;	/* This field differentiates the display type */
	u32 display_type:4;	/* Describe the specific type in use */
	u32 vendor_specific:4;	/* Chipset Vendor Specific */
	u32 bios_can_detect:1;	/* BIOS can detect the device */
	u32 depend_on_vga:1;	/* Non-VGA output device whose power is related to
L
Len Brown 已提交
143
				   the VGA device. */
144 145 146
	u32 pipe_id:3;		/* For VGA multiple-head devices. */
	u32 reserved:10;	/* Must be 0 */
	u32 device_id_scheme:1;	/* Device ID Scheme */
L
Linus Torvalds 已提交
147 148 149 150 151
};

struct acpi_video_enumerated_device {
	union {
		u32 int_val;
L
Len Brown 已提交
152
		struct acpi_video_device_attrib attrib;
L
Linus Torvalds 已提交
153 154 155 156 157
	} value;
	struct acpi_video_device *bind_info;
};

struct acpi_video_bus {
158
	struct acpi_device *device;
159
	bool backlight_registered;
L
Len Brown 已提交
160
	u8 dos_setting;
L
Linus Torvalds 已提交
161
	struct acpi_video_enumerated_device *attached_array;
L
Len Brown 已提交
162
	u8 attached_count;
163
	u8 child_count;
L
Len Brown 已提交
164
	struct acpi_video_bus_cap cap;
L
Linus Torvalds 已提交
165
	struct acpi_video_bus_flags flags;
L
Len Brown 已提交
166
	struct list_head video_device_list;
167
	struct mutex device_list_lock;	/* protects video_device_list */
168
	struct list_head entry;
169 170
	struct input_dev *input;
	char phys[32];	/* for input device */
171
	struct notifier_block pm_nb;
L
Linus Torvalds 已提交
172 173 174
};

struct acpi_video_device_flags {
L
Len Brown 已提交
175 176 177
	u8 crt:1;
	u8 lcd:1;
	u8 tvout:1;
178
	u8 dvi:1;
L
Len Brown 已提交
179 180
	u8 bios:1;
	u8 unknown:1;
181 182
	u8 notify:1;
	u8 reserved:1;
L
Linus Torvalds 已提交
183 184 185
};

struct acpi_video_device_cap {
186 187 188
	u8 _ADR:1;		/* Return the unique ID */
	u8 _BCL:1;		/* Query list of brightness control levels supported */
	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 */
L
Linus Torvalds 已提交
192 193
};

194 195
struct acpi_video_brightness_flags {
	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
};

L
Linus Torvalds 已提交
200
struct acpi_video_device_brightness {
L
Len Brown 已提交
201 202 203
	int curr;
	int count;
	int *levels;
204
	struct acpi_video_brightness_flags flags;
L
Linus Torvalds 已提交
205 206 207
};

struct acpi_video_device {
L
Len Brown 已提交
208 209 210 211
	unsigned long device_id;
	struct acpi_video_device_flags flags;
	struct acpi_video_device_cap cap;
	struct list_head entry;
212 213
	struct delayed_work switch_brightness_work;
	int switch_brightness_event;
L
Len Brown 已提交
214 215
	struct acpi_video_bus *video;
	struct acpi_device *dev;
L
Linus Torvalds 已提交
216
	struct acpi_video_device_brightness *brightness;
217
	struct backlight_device *backlight;
218
	struct thermal_cooling_device *cooling_dev;
L
Linus Torvalds 已提交
219 220
};

J
Jan Engelhardt 已提交
221
static const char device_decode[][30] = {
L
Linus Torvalds 已提交
222 223 224 225 226 227
	"motherboard VGA device",
	"PCI VGA device",
	"AGP VGA device",
	"UNKNOWN",
};

L
Len Brown 已提交
228 229 230 231
static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data);
static void acpi_video_device_rebind(struct acpi_video_bus *video);
static void acpi_video_device_bind(struct acpi_video_bus *video,
				   struct acpi_video_device *device);
L
Linus Torvalds 已提交
232
static int acpi_video_device_enumerate(struct acpi_video_bus *video);
233 234 235 236
static int acpi_video_device_lcd_set_level(struct acpi_video_device *device,
			int level);
static int acpi_video_device_lcd_get_level_current(
			struct acpi_video_device *device,
237
			unsigned long long *level, bool raw);
L
Len Brown 已提交
238 239
static int acpi_video_get_next_level(struct acpi_video_device *device,
				     u32 level_current, u32 event);
240
static void acpi_video_switch_brightness(struct work_struct *work);
L
Linus Torvalds 已提交
241

242
/* backlight device sysfs support */
243 244
static int acpi_video_get_brightness(struct backlight_device *bd)
{
245
	unsigned long long cur_level;
246
	int i;
247
	struct acpi_video_device *vd = bl_get_data(bd);
248

249
	if (acpi_video_device_lcd_get_level_current(vd, &cur_level, false))
250
		return -EINVAL;
251 252
	for (i = 2; i < vd->brightness->count; i++) {
		if (vd->brightness->levels[i] == cur_level)
253 254 255 256
			/*
			 * The first two entries are special - see page 575
			 * of the ACPI spec 3.0
			 */
257
			return i - 2;
258 259
	}
	return 0;
260 261 262 263
}

static int acpi_video_set_brightness(struct backlight_device *bd)
{
264
	int request_level = bd->props.brightness + 2;
265
	struct acpi_video_device *vd = bl_get_data(bd);
266

267
	cancel_delayed_work(&vd->switch_brightness_work);
268 269
	return acpi_video_device_lcd_set_level(vd,
				vd->brightness->levels[request_level]);
270 271
}

L
Lionel Debroux 已提交
272
static const struct backlight_ops acpi_backlight_ops = {
273 274 275 276
	.get_brightness = acpi_video_get_brightness,
	.update_status  = acpi_video_set_brightness,
};

277
/* thermal cooling device callbacks */
278
static int video_get_max_state(struct thermal_cooling_device *cooling_dev, unsigned
279
			       long *state)
280
{
281
	struct acpi_device *device = cooling_dev->devdata;
282 283
	struct acpi_video_device *video = acpi_driver_data(device);

284 285
	*state = video->brightness->count - 3;
	return 0;
286 287
}

288
static int video_get_cur_state(struct thermal_cooling_device *cooling_dev, unsigned
289
			       long *state)
290
{
291
	struct acpi_device *device = cooling_dev->devdata;
292
	struct acpi_video_device *video = acpi_driver_data(device);
293
	unsigned long long level;
294
	int offset;
295

296
	if (acpi_video_device_lcd_get_level_current(video, &level, false))
297
		return -EINVAL;
298 299 300 301 302
	for (offset = 2; offset < video->brightness->count; offset++)
		if (level == video->brightness->levels[offset]) {
			*state = video->brightness->count - offset - 1;
			return 0;
		}
303 304 305 306 307

	return -EINVAL;
}

static int
308
video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long state)
309
{
310
	struct acpi_device *device = cooling_dev->devdata;
311 312 313
	struct acpi_video_device *video = acpi_driver_data(device);
	int level;

314
	if (state >= video->brightness->count - 2)
315 316 317
		return -EINVAL;

	state = video->brightness->count - state;
318
	level = video->brightness->levels[state - 1];
319 320 321
	return acpi_video_device_lcd_set_level(video, level);
}

V
Vasiliy Kulikov 已提交
322
static const struct thermal_cooling_device_ops video_cooling_ops = {
323 324 325 326 327
	.get_max_state = video_get_max_state,
	.get_cur_state = video_get_cur_state,
	.set_cur_state = video_set_cur_state,
};

328 329 330 331 332
/*
 * --------------------------------------------------------------------------
 *                             Video Management
 * --------------------------------------------------------------------------
 */
L
Linus Torvalds 已提交
333 334

static int
L
Len Brown 已提交
335 336
acpi_video_device_lcd_query_levels(struct acpi_video_device *device,
				   union acpi_object **levels)
L
Linus Torvalds 已提交
337
{
L
Len Brown 已提交
338 339 340
	int status;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *obj;
L
Linus Torvalds 已提交
341 342 343 344


	*levels = NULL;

345
	status = acpi_evaluate_object(device->dev->handle, "_BCL", NULL, &buffer);
L
Linus Torvalds 已提交
346
	if (!ACPI_SUCCESS(status))
347
		return status;
L
Len Brown 已提交
348
	obj = (union acpi_object *)buffer.pointer;
349
	if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
350
		printk(KERN_ERR PREFIX "Invalid _BCL data\n");
L
Linus Torvalds 已提交
351 352 353 354 355 356
		status = -EFAULT;
		goto err;
	}

	*levels = obj;

357
	return 0;
L
Linus Torvalds 已提交
358

359
err:
360
	kfree(buffer.pointer);
L
Linus Torvalds 已提交
361

362
	return status;
L
Linus Torvalds 已提交
363 364 365
}

static int
L
Len Brown 已提交
366
acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level)
L
Linus Torvalds 已提交
367
{
368
	int status;
369
	int state;
L
Linus Torvalds 已提交
370

371 372
	status = acpi_execute_simple_method(device->dev->handle,
					    "_BCM", level);
373 374 375 376 377
	if (ACPI_FAILURE(status)) {
		ACPI_ERROR((AE_INFO, "Evaluating _BCM failed"));
		return -EIO;
	}

378
	device->brightness->curr = level;
379
	for (state = 2; state < device->brightness->count; state++)
380
		if (level == device->brightness->levels[state]) {
381 382
			if (device->backlight)
				device->backlight->props.brightness = state - 2;
383 384
			return 0;
		}
385

386 387
	ACPI_ERROR((AE_INFO, "Current brightness invalid"));
	return -EINVAL;
L
Linus Torvalds 已提交
388 389
}

390 391 392 393 394 395
/*
 * For some buggy _BQC methods, we need to add a constant value to
 * the _BQC return value to get the actual current brightness level
 */

static int bqc_offset_aml_bug_workaround;
396
static int video_set_bqc_offset(const struct dmi_system_id *d)
397 398 399 400 401
{
	bqc_offset_aml_bug_workaround = 9;
	return 0;
}

402
static int video_disable_backlight_sysfs_if(
403 404 405 406 407 408 409
	const struct dmi_system_id *d)
{
	if (disable_backlight_sysfs_if == -1)
		disable_backlight_sysfs_if = 1;
	return 0;
}

410 411 412 413 414 415 416 417 418 419 420 421
static int video_set_device_id_scheme(const struct dmi_system_id *d)
{
	device_id_scheme = true;
	return 0;
}

static int video_enable_only_lcd(const struct dmi_system_id *d)
{
	only_lcd = true;
	return 0;
}

422 423 424 425 426 427 428
static int video_set_report_key_events(const struct dmi_system_id *id)
{
	if (report_key_events == -1)
		report_key_events = (uintptr_t)id->driver_data;
	return 0;
}

429
static struct dmi_system_id video_dmi_table[] = {
430 431 432 433 434 435 436 437 438 439 440
	/*
	 * Broken _BQC workaround http://bugzilla.kernel.org/show_bug.cgi?id=13121
	 */
	{
	 .callback = video_set_bqc_offset,
	 .ident = "Acer Aspire 5720",
	 .matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
		DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5720"),
		},
	},
441 442 443 444 445 446 447 448
	{
	 .callback = video_set_bqc_offset,
	 .ident = "Acer Aspire 5710Z",
	 .matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
		DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5710Z"),
		},
	},
449 450 451 452 453 454 455 456
	{
	 .callback = video_set_bqc_offset,
	 .ident = "eMachines E510",
	 .matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "EMACHINES"),
		DMI_MATCH(DMI_PRODUCT_NAME, "eMachines E510"),
		},
	},
457 458 459 460 461 462 463 464
	{
	 .callback = video_set_bqc_offset,
	 .ident = "Acer Aspire 5315",
	 .matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
		DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5315"),
		},
	},
465 466 467 468 469 470 471 472
	{
	 .callback = video_set_bqc_offset,
	 .ident = "Acer Aspire 7720",
	 .matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
		DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7720"),
		},
	},
473

474 475 476 477 478 479 480
	/*
	 * Some machines have a broken acpi-video interface for brightness
	 * control, but still need an acpi_video_device_lcd_set_level() call
	 * on resume to turn the backlight power on.  We Enable backlight
	 * control on these systems, but do not register a backlight sysfs
	 * as brightness control does not work.
	 */
481 482 483 484 485 486 487 488 489
	{
	 /* https://bugzilla.kernel.org/show_bug.cgi?id=21012 */
	 .callback = video_disable_backlight_sysfs_if,
	 .ident = "Toshiba Portege R700",
	 .matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
		DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE R700"),
		},
	},
490 491 492 493 494 495 496 497 498
	{
	 /* https://bugs.freedesktop.org/show_bug.cgi?id=82634 */
	 .callback = video_disable_backlight_sysfs_if,
	 .ident = "Toshiba Portege R830",
	 .matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
		DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE R830"),
		},
	},
499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
	/*
	 * Some machine's _DOD IDs don't have bit 31(Device ID Scheme) set
	 * but the IDs actually follow the Device ID Scheme.
	 */
	{
	 /* https://bugzilla.kernel.org/show_bug.cgi?id=104121 */
	 .callback = video_set_device_id_scheme,
	 .ident = "ESPRIMO Mobile M9410",
	 .matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
		DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Mobile M9410"),
		},
	},
	/*
	 * Some machines have multiple video output devices, but only the one
	 * that is the type of LCD can do the backlight control so we should not
	 * register backlight interface for other video output devices.
	 */
	{
	 /* https://bugzilla.kernel.org/show_bug.cgi?id=104121 */
	 .callback = video_enable_only_lcd,
	 .ident = "ESPRIMO Mobile M9410",
	 .matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
		DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Mobile M9410"),
		},
	},
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
	/*
	 * Some machines report wrong key events on the acpi-bus, suppress
	 * key event reporting on these.  Note this is only intended to work
	 * around events which are plain wrong. In some cases we get double
	 * events, in this case acpi-video is considered the canonical source
	 * and the events from the other source should be filtered. E.g.
	 * by calling acpi_video_handles_brightness_key_presses() from the
	 * vendor acpi/wmi driver or by using /lib/udev/hwdb.d/60-keyboard.hwdb
	 */
	{
	 .callback = video_set_report_key_events,
	 .driver_data = (void *)((uintptr_t)REPORT_OUTPUT_KEY_EVENTS),
	 .ident = "Dell Vostro V131",
	 .matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
		DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V131"),
		},
	},
544 545 546
	{}
};

547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571
static unsigned long long
acpi_video_bqc_value_to_level(struct acpi_video_device *device,
			      unsigned long long bqc_value)
{
	unsigned long long level;

	if (device->brightness->flags._BQC_use_index) {
		/*
		 * _BQC returns an index that doesn't account for
		 * the first 2 items with special meaning, so we need
		 * to compensate for that by offsetting ourselves
		 */
		if (device->brightness->flags._BCL_reversed)
			bqc_value = device->brightness->count - 3 - bqc_value;

		level = device->brightness->levels[bqc_value + 2];
	} else {
		level = bqc_value;
	}

	level += bqc_offset_aml_bug_workaround;

	return level;
}

L
Linus Torvalds 已提交
572
static int
L
Len Brown 已提交
573
acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
574
					unsigned long long *level, bool raw)
L
Linus Torvalds 已提交
575
{
576
	acpi_status status = AE_OK;
577
	int i;
578

579 580 581 582
	if (device->cap._BQC || device->cap._BCQ) {
		char *buf = device->cap._BQC ? "_BQC" : "_BCQ";

		status = acpi_evaluate_integer(device->dev->handle, buf,
583 584
						NULL, level);
		if (ACPI_SUCCESS(status)) {
585 586 587 588 589 590 591 592 593
			if (raw) {
				/*
				 * Caller has indicated he wants the raw
				 * value returned by _BQC, so don't furtherly
				 * mess with the value.
				 */
				return 0;
			}

594
			*level = acpi_video_bqc_value_to_level(device, *level);
595

596 597 598 599
			for (i = 2; i < device->brightness->count; i++)
				if (device->brightness->levels[i] == *level) {
					device->brightness->curr = *level;
					return 0;
600
				}
601 602 603 604 605 606 607 608
			/*
			 * BQC returned an invalid level.
			 * Stop using it.
			 */
			ACPI_WARNING((AE_INFO,
				      "%s returned an invalid level",
				      buf));
			device->cap._BQC = device->cap._BCQ = 0;
609
		} else {
610 611
			/*
			 * Fixme:
612 613 614 615 616 617
			 * should we return an error or ignore this failure?
			 * dev->brightness->curr is a cached value which stores
			 * the correct current backlight level in most cases.
			 * ACPI video backlight still works w/ buggy _BQC.
			 * http://bugzilla.kernel.org/show_bug.cgi?id=12233
			 */
618 619
			ACPI_WARNING((AE_INFO, "Evaluating %s failed", buf));
			device->cap._BQC = device->cap._BCQ = 0;
620 621 622
		}
	}

623
	*level = device->brightness->curr;
624
	return 0;
L
Linus Torvalds 已提交
625 626 627
}

static int
L
Len Brown 已提交
628 629
acpi_video_device_EDID(struct acpi_video_device *device,
		       union acpi_object **edid, ssize_t length)
L
Linus Torvalds 已提交
630
{
L
Len Brown 已提交
631 632 633 634 635
	int status;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *obj;
	union acpi_object arg0 = { ACPI_TYPE_INTEGER };
	struct acpi_object_list args = { 1, &arg0 };
L
Linus Torvalds 已提交
636 637 638 639 640


	*edid = NULL;

	if (!device)
641
		return -ENODEV;
L
Linus Torvalds 已提交
642 643 644 645 646
	if (length == 128)
		arg0.integer.value = 1;
	else if (length == 256)
		arg0.integer.value = 2;
	else
647
		return -EINVAL;
L
Linus Torvalds 已提交
648

649
	status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer);
L
Linus Torvalds 已提交
650
	if (ACPI_FAILURE(status))
651
		return -ENODEV;
L
Linus Torvalds 已提交
652

653
	obj = buffer.pointer;
L
Linus Torvalds 已提交
654 655 656 657

	if (obj && obj->type == ACPI_TYPE_BUFFER)
		*edid = obj;
	else {
658
		printk(KERN_ERR PREFIX "Invalid _DDC data\n");
L
Linus Torvalds 已提交
659 660 661 662
		status = -EFAULT;
		kfree(obj);
	}

663
	return status;
L
Linus Torvalds 已提交
664 665 666 667 668 669
}

/* bus */

/*
 *  Arg:
670 671
 *	video		: video bus device pointer
 *	bios_flag	:
L
Linus Torvalds 已提交
672 673 674
 *		0.	The system BIOS should NOT automatically switch(toggle)
 *			the active display output.
 *		1.	The system BIOS should automatically switch (toggle) the
675
 *			active display output. No switch event.
L
Linus Torvalds 已提交
676 677 678 679 680 681
 *		2.	The _DGS value should be locked.
 *		3.	The system BIOS should not automatically switch (toggle) the
 *			active display output, but instead generate the display switch
 *			event notify code.
 *	lcd_flag	:
 *		0.	The system BIOS should automatically control the brightness level
682
 *			of the LCD when the power changes from AC to DC
683
 *		1.	The system BIOS should NOT automatically control the brightness
684
 *			level of the LCD when the power changes from AC to DC.
685
 *  Return Value:
686
 *		-EINVAL	wrong arg.
L
Linus Torvalds 已提交
687 688 689
 */

static int
L
Len Brown 已提交
690
acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
L
Linus Torvalds 已提交
691
{
692
	acpi_status status;
L
Linus Torvalds 已提交
693

694 695
	if (!video->cap._DOS)
		return 0;
L
Linus Torvalds 已提交
696

697 698
	if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1)
		return -EINVAL;
699 700 701
	video->dos_setting = (lcd_flag << 2) | bios_flag;
	status = acpi_execute_simple_method(video->device->handle, "_DOS",
					    (lcd_flag << 2) | bios_flag);
702 703
	if (ACPI_FAILURE(status))
		return -EIO;
L
Linus Torvalds 已提交
704

705
	return 0;
L
Linus Torvalds 已提交
706 707
}

708 709 710 711 712 713 714 715 716 717
/*
 * Simple comparison function used to sort backlight levels.
 */

static int
acpi_video_cmp_level(const void *a, const void *b)
{
	return *(int *)a - *(int *)b;
}

718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740
/*
 * Decides if _BQC/_BCQ for this system is usable
 *
 * We do this by changing the level first and then read out the current
 * brightness level, if the value does not match, find out if it is using
 * index. If not, clear the _BQC/_BCQ capability.
 */
static int acpi_video_bqc_quirk(struct acpi_video_device *device,
				int max_level, int current_level)
{
	struct acpi_video_device_brightness *br = device->brightness;
	int result;
	unsigned long long level;
	int test_level;

	/* don't mess with existing known broken systems */
	if (bqc_offset_aml_bug_workaround)
		return 0;

	/*
	 * Some systems always report current brightness level as maximum
	 * through _BQC, we need to test another value for them.
	 */
741
	test_level = current_level == max_level ? br->levels[3] : max_level;
742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767

	result = acpi_video_device_lcd_set_level(device, test_level);
	if (result)
		return result;

	result = acpi_video_device_lcd_get_level_current(device, &level, true);
	if (result)
		return result;

	if (level != test_level) {
		/* buggy _BQC found, need to find out if it uses index */
		if (level < br->count) {
			if (br->flags._BCL_reversed)
				level = br->count - 3 - level;
			if (br->levels[level + 2] == test_level)
				br->flags._BQC_use_index = 1;
		}

		if (!br->flags._BQC_use_index)
			device->cap._BQC = device->cap._BCQ = 0;
	}

	return 0;
}


L
Linus Torvalds 已提交
768
/*
769 770
 *  Arg:
 *	device	: video output device (LCD, CRT, ..)
L
Linus Torvalds 已提交
771 772
 *
 *  Return Value:
773 774 775 776 777 778 779 780 781
 *	Maximum brightness level
 *
 *  Allocate and initialize device->brightness.
 */

static int
acpi_video_init_brightness(struct acpi_video_device *device)
{
	union acpi_object *obj = NULL;
782
	int i, max_level = 0, count = 0, level_ac_battery = 0;
783
	unsigned long long level, level_old;
784 785
	union acpi_object *o;
	struct acpi_video_device_brightness *br = NULL;
786
	int result = -EINVAL;
787
	u32 value;
788 789 790 791 792 793 794 795 796 797 798 799 800

	if (!ACPI_SUCCESS(acpi_video_device_lcd_query_levels(device, &obj))) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Could not query available "
						"LCD brightness level\n"));
		goto out;
	}

	if (obj->package.count < 2)
		goto out;

	br = kzalloc(sizeof(*br), GFP_KERNEL);
	if (!br) {
		printk(KERN_ERR "can't allocate memory\n");
801
		result = -ENOMEM;
802 803 804
		goto out;
	}

805
	br->levels = kmalloc((obj->package.count + 2) * sizeof *(br->levels),
806
				GFP_KERNEL);
807 808
	if (!br->levels) {
		result = -ENOMEM;
809
		goto out_free;
810
	}
811 812 813 814 815 816 817

	for (i = 0; i < obj->package.count; i++) {
		o = (union acpi_object *)&obj->package.elements[i];
		if (o->type != ACPI_TYPE_INTEGER) {
			printk(KERN_ERR PREFIX "Invalid data\n");
			continue;
		}
818 819 820 821 822 823
		value = (u32) o->integer.value;
		/* Skip duplicate entries */
		if (count > 2 && br->levels[count - 1] == value)
			continue;

		br->levels[count] = value;
824 825 826 827 828 829

		if (br->levels[count] > max_level)
			max_level = br->levels[count];
		count++;
	}

830 831 832 833 834 835
	/*
	 * some buggy BIOS don't export the levels
	 * when machine is on AC/Battery in _BCL package.
	 * In this case, the first two elements in _BCL packages
	 * are also supported brightness levels that OS should take care of.
	 */
836 837
	for (i = 2; i < count; i++) {
		if (br->levels[i] == br->levels[0])
838
			level_ac_battery++;
839 840 841
		if (br->levels[i] == br->levels[1])
			level_ac_battery++;
	}
842 843 844 845 846 847 848 849

	if (level_ac_battery < 2) {
		level_ac_battery = 2 - level_ac_battery;
		br->flags._BCL_no_ac_battery_levels = 1;
		for (i = (count - 1 + level_ac_battery); i >= 2; i--)
			br->levels[i] = br->levels[i - level_ac_battery];
		count += level_ac_battery;
	} else if (level_ac_battery > 2)
850
		ACPI_ERROR((AE_INFO, "Too many duplicates in _BCL package"));
851

852 853 854 855 856 857 858
	/* Check if the _BCL package is in a reversed order */
	if (max_level == br->levels[2]) {
		br->flags._BCL_reversed = 1;
		sort(&br->levels[2], count - 2, sizeof(br->levels[2]),
			acpi_video_cmp_level, NULL);
	} else if (max_level != br->levels[count - 1])
		ACPI_ERROR((AE_INFO,
859
			    "Found unordered _BCL package"));
860 861 862

	br->count = count;
	device->brightness = br;
863 864

	/* _BQC uses INDEX while _BCL uses VALUE in some laptops */
865
	br->curr = level = max_level;
866 867 868 869

	if (!device->cap._BQC)
		goto set_level;

870 871
	result = acpi_video_device_lcd_get_level_current(device,
							 &level_old, true);
872 873 874
	if (result)
		goto out_free_levels;

875
	result = acpi_video_bqc_quirk(device, max_level, level_old);
876 877
	if (result)
		goto out_free_levels;
878 879 880 881 882 883
	/*
	 * cap._BQC may get cleared due to _BQC is found to be broken
	 * in acpi_video_bqc_quirk, so check again here.
	 */
	if (!device->cap._BQC)
		goto set_level;
884

885 886 887 888 889 890 891 892 893 894 895 896
	level = acpi_video_bqc_value_to_level(device, level_old);
	/*
	 * On some buggy laptops, _BQC returns an uninitialized
	 * value when invoked for the first time, i.e.
	 * level_old is invalid (no matter whether it's a level
	 * or an index). Set the backlight to max_level in this case.
	 */
	for (i = 2; i < br->count; i++)
		if (level == br->levels[i])
			break;
	if (i == br->count || !level)
		level = max_level;
897 898

set_level:
899
	result = acpi_video_device_lcd_set_level(device, level);
900 901
	if (result)
		goto out_free_levels;
902

903 904
	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			  "found %d brightness levels\n", count - 2));
905
	kfree(obj);
906
	return result;
907 908 909 910 911 912 913 914

out_free_levels:
	kfree(br->levels);
out_free:
	kfree(br);
out:
	device->brightness = NULL;
	kfree(obj);
915
	return result;
916 917 918 919 920 921 922
}

/*
 *  Arg:
 *	device	: video output device (LCD, CRT, ..)
 *
 *  Return Value:
923
 *	None
L
Linus Torvalds 已提交
924
 *
925
 *  Find out all required AML methods defined under the output
L
Linus Torvalds 已提交
926 927 928
 *  device.
 */

L
Len Brown 已提交
929
static void acpi_video_device_find_cap(struct acpi_video_device *device)
L
Linus Torvalds 已提交
930
{
931
	if (acpi_has_method(device->dev->handle, "_ADR"))
L
Linus Torvalds 已提交
932
		device->cap._ADR = 1;
933
	if (acpi_has_method(device->dev->handle, "_BCL"))
L
Len Brown 已提交
934
		device->cap._BCL = 1;
935
	if (acpi_has_method(device->dev->handle, "_BCM"))
L
Len Brown 已提交
936
		device->cap._BCM = 1;
937
	if (acpi_has_method(device->dev->handle, "_BQC")) {
938
		device->cap._BQC = 1;
939
	} else if (acpi_has_method(device->dev->handle, "_BCQ")) {
940 941 942 943
		printk(KERN_WARNING FW_BUG "_BCQ is used instead of _BQC\n");
		device->cap._BCQ = 1;
	}

944
	if (acpi_has_method(device->dev->handle, "_DDC"))
L
Len Brown 已提交
945
		device->cap._DDC = 1;
L
Linus Torvalds 已提交
946 947 948
}

/*
949 950
 *  Arg:
 *	device	: video output device (VGA)
L
Linus Torvalds 已提交
951 952
 *
 *  Return Value:
953
 *	None
L
Linus Torvalds 已提交
954
 *
955
 *  Find out all required AML methods defined under the video bus device.
L
Linus Torvalds 已提交
956 957
 */

L
Len Brown 已提交
958
static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
L
Linus Torvalds 已提交
959
{
960
	if (acpi_has_method(video->device->handle, "_DOS"))
L
Linus Torvalds 已提交
961
		video->cap._DOS = 1;
962
	if (acpi_has_method(video->device->handle, "_DOD"))
L
Linus Torvalds 已提交
963
		video->cap._DOD = 1;
964
	if (acpi_has_method(video->device->handle, "_ROM"))
L
Linus Torvalds 已提交
965
		video->cap._ROM = 1;
966
	if (acpi_has_method(video->device->handle, "_GPD"))
L
Linus Torvalds 已提交
967
		video->cap._GPD = 1;
968
	if (acpi_has_method(video->device->handle, "_SPD"))
L
Linus Torvalds 已提交
969
		video->cap._SPD = 1;
970
	if (acpi_has_method(video->device->handle, "_VPO"))
L
Linus Torvalds 已提交
971 972 973 974 975 976 977 978
		video->cap._VPO = 1;
}

/*
 * Check whether the video bus device has required AML method to
 * support the desired features
 */

L
Len Brown 已提交
979
static int acpi_video_bus_check(struct acpi_video_bus *video)
L
Linus Torvalds 已提交
980
{
L
Len Brown 已提交
981
	acpi_status status = -ENOENT;
982
	struct pci_dev *dev;
L
Linus Torvalds 已提交
983 984

	if (!video)
985
		return -EINVAL;
L
Linus Torvalds 已提交
986

987
	dev = acpi_get_pci_dev(video->device->handle);
988 989
	if (!dev)
		return -ENODEV;
990
	pci_dev_put(dev);
991

992 993
	/*
	 * Since there is no HID, CID and so on for VGA driver, we have
L
Linus Torvalds 已提交
994 995 996
	 * to check well known required nodes.
	 */

997
	/* Does this device support video switching? */
998 999 1000 1001 1002 1003
	if (video->cap._DOS || video->cap._DOD) {
		if (!video->cap._DOS) {
			printk(KERN_WARNING FW_BUG
				"ACPI(%s) defines _DOD but not _DOS\n",
				acpi_device_bid(video->device));
		}
L
Linus Torvalds 已提交
1004 1005 1006 1007
		video->flags.multihead = 1;
		status = 0;
	}

1008
	/* Does this device support retrieving a video ROM? */
L
Len Brown 已提交
1009
	if (video->cap._ROM) {
L
Linus Torvalds 已提交
1010 1011 1012 1013
		video->flags.rom = 1;
		status = 0;
	}

1014
	/* Does this device support configuring which video device to POST? */
L
Len Brown 已提交
1015
	if (video->cap._GPD && video->cap._SPD && video->cap._VPO) {
L
Linus Torvalds 已提交
1016 1017 1018 1019
		video->flags.post = 1;
		status = 0;
	}

1020
	return status;
L
Linus Torvalds 已提交
1021 1022
}

1023 1024 1025 1026 1027
/*
 * --------------------------------------------------------------------------
 *                               Driver Interface
 * --------------------------------------------------------------------------
 */
L
Linus Torvalds 已提交
1028 1029

/* device interface */
1030
static struct acpi_video_device_attrib *
1031 1032
acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id)
{
1033 1034 1035 1036 1037 1038 1039 1040
	struct acpi_video_enumerated_device *ids;
	int i;

	for (i = 0; i < video->attached_count; i++) {
		ids = &video->attached_array[i];
		if ((ids->value.int_val & 0xffff) == device_id)
			return &ids->value.attrib;
	}
1041 1042 1043

	return NULL;
}
L
Linus Torvalds 已提交
1044

1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
static int
acpi_video_get_device_type(struct acpi_video_bus *video,
			   unsigned long device_id)
{
	struct acpi_video_enumerated_device *ids;
	int i;

	for (i = 0; i < video->attached_count; i++) {
		ids = &video->attached_array[i];
		if ((ids->value.int_val & 0xffff) == device_id)
			return ids->value.int_val;
	}

	return 0;
}

L
Linus Torvalds 已提交
1061
static int
L
Len Brown 已提交
1062 1063
acpi_video_bus_get_one_device(struct acpi_device *device,
			      struct acpi_video_bus *video)
L
Linus Torvalds 已提交
1064
{
1065
	unsigned long long device_id;
1066
	int status, device_type;
L
Len Brown 已提交
1067
	struct acpi_video_device *data;
1068
	struct acpi_video_device_attrib *attribute;
L
Linus Torvalds 已提交
1069

L
Len Brown 已提交
1070 1071
	status =
	    acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
1072 1073 1074
	/* Some device omits _ADR, we skip them instead of fail */
	if (ACPI_FAILURE(status))
		return 0;
L
Linus Torvalds 已提交
1075

1076 1077 1078
	data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
	if (!data)
		return -ENOMEM;
1079

1080 1081 1082 1083 1084 1085 1086
	strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
	device->driver_data = data;

	data->device_id = device_id;
	data->video = video;
	data->dev = device;
1087 1088
	INIT_DELAYED_WORK(&data->switch_brightness_work,
			  acpi_video_switch_brightness);
1089 1090 1091

	attribute = acpi_video_get_device_attr(video, device_id);

1092
	if (attribute && (attribute->device_id_scheme || device_id_scheme)) {
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
		switch (attribute->display_type) {
		case ACPI_VIDEO_DISPLAY_CRT:
			data->flags.crt = 1;
			break;
		case ACPI_VIDEO_DISPLAY_TV:
			data->flags.tvout = 1;
			break;
		case ACPI_VIDEO_DISPLAY_DVI:
			data->flags.dvi = 1;
			break;
		case ACPI_VIDEO_DISPLAY_LCD:
			data->flags.lcd = 1;
			break;
		default:
			data->flags.unknown = 1;
			break;
		}
1110
		if (attribute->bios_can_detect)
1111 1112 1113 1114 1115 1116
			data->flags.bios = 1;
	} else {
		/* Check for legacy IDs */
		device_type = acpi_video_get_device_type(video, device_id);
		/* Ignore bits 16 and 18-20 */
		switch (device_type & 0xffe2ffff) {
1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127
		case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR:
			data->flags.crt = 1;
			break;
		case ACPI_VIDEO_DISPLAY_LEGACY_PANEL:
			data->flags.lcd = 1;
			break;
		case ACPI_VIDEO_DISPLAY_LEGACY_TV:
			data->flags.tvout = 1;
			break;
		default:
			data->flags.unknown = 1;
1128
		}
1129
	}
L
Len Brown 已提交
1130

1131 1132
	acpi_video_device_bind(video, data);
	acpi_video_device_find_cap(data);
L
Linus Torvalds 已提交
1133

1134 1135 1136
	mutex_lock(&video->device_list_lock);
	list_add_tail(&data->entry, &video->video_device_list);
	mutex_unlock(&video->device_list_lock);
L
Linus Torvalds 已提交
1137

1138
	return status;
L
Linus Torvalds 已提交
1139 1140 1141 1142
}

/*
 *  Arg:
1143
 *	video	: video bus device
L
Linus Torvalds 已提交
1144 1145
 *
 *  Return:
1146 1147 1148
 *	none
 *
 *  Enumerate the video device list of the video bus,
L
Linus Torvalds 已提交
1149 1150
 *  bind the ids with the corresponding video devices
 *  under the video bus.
L
Len Brown 已提交
1151
 */
L
Linus Torvalds 已提交
1152

L
Len Brown 已提交
1153
static void acpi_video_device_rebind(struct acpi_video_bus *video)
L
Linus Torvalds 已提交
1154
{
1155 1156
	struct acpi_video_device *dev;

1157
	mutex_lock(&video->device_list_lock);
1158 1159

	list_for_each_entry(dev, &video->video_device_list, entry)
L
Len Brown 已提交
1160
		acpi_video_device_bind(video, dev);
1161

1162
	mutex_unlock(&video->device_list_lock);
L
Linus Torvalds 已提交
1163 1164 1165 1166
}

/*
 *  Arg:
1167 1168 1169
 *	video	: video bus device
 *	device	: video output device under the video
 *		bus
L
Linus Torvalds 已提交
1170 1171
 *
 *  Return:
1172 1173
 *	none
 *
L
Linus Torvalds 已提交
1174 1175
 *  Bind the ids with the corresponding video devices
 *  under the video bus.
L
Len Brown 已提交
1176
 */
L
Linus Torvalds 已提交
1177 1178

static void
L
Len Brown 已提交
1179 1180
acpi_video_device_bind(struct acpi_video_bus *video,
		       struct acpi_video_device *device)
L
Linus Torvalds 已提交
1181
{
1182
	struct acpi_video_enumerated_device *ids;
L
Len Brown 已提交
1183
	int i;
L
Linus Torvalds 已提交
1184

1185 1186 1187 1188
	for (i = 0; i < video->attached_count; i++) {
		ids = &video->attached_array[i];
		if (device->device_id == (ids->value.int_val & 0xffff)) {
			ids->bind_info = device;
L
Linus Torvalds 已提交
1189 1190 1191 1192 1193
			ACPI_DEBUG_PRINT((ACPI_DB_INFO, "device_bind %d\n", i));
		}
	}
}

1194 1195 1196 1197 1198
static bool acpi_video_device_in_dod(struct acpi_video_device *device)
{
	struct acpi_video_bus *video = device->video;
	int i;

1199 1200 1201 1202 1203 1204
	/*
	 * If we have a broken _DOD or we have more than 8 output devices
	 * under the graphics controller node that we can't proper deal with
	 * in the operation region code currently, no need to test.
	 */
	if (!video->attached_count || video->child_count > 8)
1205 1206 1207
		return true;

	for (i = 0; i < video->attached_count; i++) {
1208 1209
		if ((video->attached_array[i].value.int_val & 0xfff) ==
		    (device->device_id & 0xfff))
1210 1211 1212 1213 1214 1215
			return true;
	}

	return false;
}

L
Linus Torvalds 已提交
1216 1217
/*
 *  Arg:
1218
 *	video	: video bus device
L
Linus Torvalds 已提交
1219 1220
 *
 *  Return:
1221 1222
 *	< 0	: error
 *
L
Linus Torvalds 已提交
1223 1224
 *  Call _DOD to enumerate all devices attached to display adapter
 *
L
Len Brown 已提交
1225
 */
L
Linus Torvalds 已提交
1226 1227 1228

static int acpi_video_device_enumerate(struct acpi_video_bus *video)
{
L
Len Brown 已提交
1229 1230 1231
	int status;
	int count;
	int i;
1232
	struct acpi_video_enumerated_device *active_list;
L
Len Brown 已提交
1233 1234 1235
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *dod = NULL;
	union acpi_object *obj;
L
Linus Torvalds 已提交
1236

1237
	status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
L
Linus Torvalds 已提交
1238
	if (!ACPI_SUCCESS(status)) {
1239
		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD"));
1240
		return status;
L
Linus Torvalds 已提交
1241 1242
	}

1243
	dod = buffer.pointer;
L
Linus Torvalds 已提交
1244
	if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
1245
		ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data"));
L
Linus Torvalds 已提交
1246 1247 1248 1249 1250
		status = -EFAULT;
		goto out;
	}

	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d video heads in _DOD\n",
L
Len Brown 已提交
1251
			  dod->package.count));
L
Linus Torvalds 已提交
1252

1253 1254 1255 1256
	active_list = kcalloc(1 + dod->package.count,
			      sizeof(struct acpi_video_enumerated_device),
			      GFP_KERNEL);
	if (!active_list) {
L
Linus Torvalds 已提交
1257 1258 1259 1260 1261 1262
		status = -ENOMEM;
		goto out;
	}

	count = 0;
	for (i = 0; i < dod->package.count; i++) {
1263
		obj = &dod->package.elements[i];
L
Linus Torvalds 已提交
1264 1265

		if (obj->type != ACPI_TYPE_INTEGER) {
1266 1267 1268
			printk(KERN_ERR PREFIX
				"Invalid _DOD data in element %d\n", i);
			continue;
L
Linus Torvalds 已提交
1269
		}
1270 1271 1272

		active_list[count].value.int_val = obj->integer.value;
		active_list[count].bind_info = NULL;
L
Len Brown 已提交
1273 1274
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "dod element[%d] = %d\n", i,
				  (int)obj->integer.value));
L
Linus Torvalds 已提交
1275 1276 1277
		count++;
	}

1278
	kfree(video->attached_array);
L
Len Brown 已提交
1279

1280
	video->attached_array = active_list;
L
Linus Torvalds 已提交
1281
	video->attached_count = count;
1282

1283
out:
1284
	kfree(buffer.pointer);
1285
	return status;
L
Linus Torvalds 已提交
1286 1287
}

L
Len Brown 已提交
1288 1289 1290
static int
acpi_video_get_next_level(struct acpi_video_device *device,
			  u32 level_current, u32 event)
L
Linus Torvalds 已提交
1291
{
1292
	int min, max, min_above, max_below, i, l, delta = 255;
1293 1294
	max = max_below = 0;
	min = min_above = 255;
1295
	/* Find closest level to level_current */
1296
	for (i = 2; i < device->brightness->count; i++) {
1297 1298 1299 1300 1301 1302 1303 1304 1305
		l = device->brightness->levels[i];
		if (abs(l - level_current) < abs(delta)) {
			delta = l - level_current;
			if (!delta)
				break;
		}
	}
	/* Ajust level_current to closest available level */
	level_current += delta;
1306
	for (i = 2; i < device->brightness->count; i++) {
1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330
		l = device->brightness->levels[i];
		if (l < min)
			min = l;
		if (l > max)
			max = l;
		if (l < min_above && l > level_current)
			min_above = l;
		if (l > max_below && l < level_current)
			max_below = l;
	}

	switch (event) {
	case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:
		return (level_current < max) ? min_above : min;
	case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:
		return (level_current < max) ? min_above : max;
	case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:
		return (level_current > min) ? max_below : min;
	case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:
	case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:
		return 0;
	default:
		return level_current;
	}
L
Linus Torvalds 已提交
1331 1332
}

1333 1334
static void
acpi_video_switch_brightness(struct work_struct *work)
L
Linus Torvalds 已提交
1335
{
1336 1337
	struct acpi_video_device *device = container_of(to_delayed_work(work),
			     struct acpi_video_device, switch_brightness_work);
1338
	unsigned long long level_current, level_next;
1339
	int event = device->switch_brightness_event;
1340 1341
	int result = -EINVAL;

1342
	/* no warning message if acpi_backlight=vendor or a quirk is used */
1343
	if (!device->backlight)
1344
		return;
1345

1346
	if (!device->brightness)
1347 1348 1349
		goto out;

	result = acpi_video_device_lcd_get_level_current(device,
1350 1351
							 &level_current,
							 false);
1352 1353 1354
	if (result)
		goto out;

L
Linus Torvalds 已提交
1355
	level_next = acpi_video_get_next_level(device, level_current, event);
1356

1357
	result = acpi_video_device_lcd_set_level(device, level_next);
1358

1359 1360 1361 1362
	if (!result)
		backlight_force_update(device->backlight,
				       BACKLIGHT_UPDATE_HOTKEY);

1363 1364 1365
out:
	if (result)
		printk(KERN_ERR PREFIX "Failed to switch the brightness\n");
L
Linus Torvalds 已提交
1366 1367
}

1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
int acpi_video_get_edid(struct acpi_device *device, int type, int device_id,
			void **edid)
{
	struct acpi_video_bus *video;
	struct acpi_video_device *video_device;
	union acpi_object *buffer = NULL;
	acpi_status status;
	int i, length;

	if (!device || !acpi_driver_data(device))
		return -EINVAL;

	video = acpi_driver_data(device);

	for (i = 0; i < video->attached_count; i++) {
		video_device = video->attached_array[i].bind_info;
		length = 256;

		if (!video_device)
			continue;

1389 1390 1391
		if (!video_device->cap._DDC)
			continue;

1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435
		if (type) {
			switch (type) {
			case ACPI_VIDEO_DISPLAY_CRT:
				if (!video_device->flags.crt)
					continue;
				break;
			case ACPI_VIDEO_DISPLAY_TV:
				if (!video_device->flags.tvout)
					continue;
				break;
			case ACPI_VIDEO_DISPLAY_DVI:
				if (!video_device->flags.dvi)
					continue;
				break;
			case ACPI_VIDEO_DISPLAY_LCD:
				if (!video_device->flags.lcd)
					continue;
				break;
			}
		} else if (video_device->device_id != device_id) {
			continue;
		}

		status = acpi_video_device_EDID(video_device, &buffer, length);

		if (ACPI_FAILURE(status) || !buffer ||
		    buffer->type != ACPI_TYPE_BUFFER) {
			length = 128;
			status = acpi_video_device_EDID(video_device, &buffer,
							length);
			if (ACPI_FAILURE(status) || !buffer ||
			    buffer->type != ACPI_TYPE_BUFFER) {
				continue;
			}
		}

		*edid = buffer->buffer.pointer;
		return length;
	}

	return -ENODEV;
}
EXPORT_SYMBOL(acpi_video_get_edid);

L
Linus Torvalds 已提交
1436
static int
L
Len Brown 已提交
1437 1438
acpi_video_bus_get_devices(struct acpi_video_bus *video,
			   struct acpi_device *device)
L
Linus Torvalds 已提交
1439
{
1440
	int status = 0;
1441
	struct acpi_device *dev;
L
Linus Torvalds 已提交
1442

1443 1444 1445 1446 1447 1448
	/*
	 * There are systems where video module known to work fine regardless
	 * of broken _DOD and ignoring returned value here doesn't cause
	 * any issues later.
	 */
	acpi_video_device_enumerate(video);
L
Linus Torvalds 已提交
1449

1450
	list_for_each_entry(dev, &device->children, node) {
L
Linus Torvalds 已提交
1451 1452

		status = acpi_video_bus_get_one_device(dev, video);
1453
		if (status) {
1454 1455
			dev_err(&dev->dev, "Can't attach device\n");
			break;
L
Linus Torvalds 已提交
1456
		}
1457
		video->child_count++;
L
Linus Torvalds 已提交
1458
	}
1459
	return status;
L
Linus Torvalds 已提交
1460 1461 1462 1463
}

/* acpi_video interface */

1464 1465 1466 1467
/*
 * Win8 requires setting bit2 of _DOS to let firmware know it shouldn't
 * preform any automatic brightness change on receiving a notification.
 */
L
Len Brown 已提交
1468
static int acpi_video_bus_start_devices(struct acpi_video_bus *video)
L
Linus Torvalds 已提交
1469
{
1470
	return acpi_video_bus_DOS(video, 0,
1471
				  acpi_osi_is_win8() ? 1 : 0);
L
Linus Torvalds 已提交
1472 1473
}

L
Len Brown 已提交
1474
static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
L
Linus Torvalds 已提交
1475
{
1476
	return acpi_video_bus_DOS(video, 0,
1477
				  acpi_osi_is_win8() ? 0 : 1);
L
Linus Torvalds 已提交
1478 1479
}

1480
static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
L
Linus Torvalds 已提交
1481
{
1482
	struct acpi_video_bus *video = acpi_driver_data(device);
1483
	struct input_dev *input;
1484
	int keycode = 0;
1485

1486
	if (!video || !video->input)
1487
		return;
L
Linus Torvalds 已提交
1488

1489
	input = video->input;
L
Linus Torvalds 已提交
1490 1491

	switch (event) {
1492
	case ACPI_VIDEO_NOTIFY_SWITCH:	/* User requested a switch,
L
Linus Torvalds 已提交
1493
					 * most likely via hotkey. */
1494
		keycode = KEY_SWITCHVIDEOMODE;
L
Linus Torvalds 已提交
1495 1496
		break;

1497
	case ACPI_VIDEO_NOTIFY_PROBE:	/* User plugged in or removed a video
L
Linus Torvalds 已提交
1498 1499 1500
					 * connector. */
		acpi_video_device_enumerate(video);
		acpi_video_device_rebind(video);
1501
		keycode = KEY_SWITCHVIDEOMODE;
L
Linus Torvalds 已提交
1502 1503
		break;

L
Len Brown 已提交
1504
	case ACPI_VIDEO_NOTIFY_CYCLE:	/* Cycle Display output hotkey pressed. */
1505 1506
		keycode = KEY_SWITCHVIDEOMODE;
		break;
L
Len Brown 已提交
1507
	case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT:	/* Next Display output hotkey pressed. */
1508 1509
		keycode = KEY_VIDEO_NEXT;
		break;
L
Len Brown 已提交
1510
	case ACPI_VIDEO_NOTIFY_PREV_OUTPUT:	/* previous Display output hotkey pressed. */
1511
		keycode = KEY_VIDEO_PREV;
L
Linus Torvalds 已提交
1512 1513 1514 1515
		break;

	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
1516
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
1517 1518 1519
		break;
	}

1520 1521 1522
	if (acpi_notifier_call_chain(device, event, 0))
		/* Something vetoed the keypress. */
		keycode = 0;
1523

1524
	if (keycode && (report_key_events & REPORT_OUTPUT_KEY_EVENTS)) {
1525 1526 1527 1528 1529
		input_report_key(input, keycode, 1);
		input_sync(input);
		input_report_key(input, keycode, 0);
		input_sync(input);
	}
1530

1531
	return;
L
Linus Torvalds 已提交
1532 1533
}

1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
static void brightness_switch_event(struct acpi_video_device *video_device,
				    u32 event)
{
	if (!brightness_switch_enabled)
		return;

	video_device->switch_brightness_event = event;
	schedule_delayed_work(&video_device->switch_brightness_work, HZ / 10);
}

L
Len Brown 已提交
1544
static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
L
Linus Torvalds 已提交
1545
{
1546
	struct acpi_video_device *video_device = data;
L
Len Brown 已提交
1547
	struct acpi_device *device = NULL;
1548 1549
	struct acpi_video_bus *bus;
	struct input_dev *input;
1550
	int keycode = 0;
L
Linus Torvalds 已提交
1551 1552

	if (!video_device)
1553
		return;
L
Linus Torvalds 已提交
1554

1555
	device = video_device->dev;
1556 1557
	bus = video_device->video;
	input = bus->input;
L
Linus Torvalds 已提交
1558 1559

	switch (event) {
L
Len Brown 已提交
1560
	case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:	/* Cycle brightness */
1561
		brightness_switch_event(video_device, event);
1562 1563
		keycode = KEY_BRIGHTNESS_CYCLE;
		break;
L
Len Brown 已提交
1564
	case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:	/* Increase brightness */
1565
		brightness_switch_event(video_device, event);
1566 1567
		keycode = KEY_BRIGHTNESSUP;
		break;
L
Len Brown 已提交
1568
	case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:	/* Decrease brightness */
1569
		brightness_switch_event(video_device, event);
1570 1571
		keycode = KEY_BRIGHTNESSDOWN;
		break;
1572
	case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:	/* zero brightness */
1573
		brightness_switch_event(video_device, event);
1574 1575
		keycode = KEY_BRIGHTNESS_ZERO;
		break;
L
Len Brown 已提交
1576
	case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:	/* display device off */
1577
		brightness_switch_event(video_device, event);
1578
		keycode = KEY_DISPLAY_OFF;
L
Linus Torvalds 已提交
1579 1580 1581
		break;
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
1582
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
1583 1584
		break;
	}
1585

1586
	acpi_notifier_call_chain(device, event, 0);
1587

1588
	if (keycode && (report_key_events & REPORT_BRIGHTNESS_KEY_EVENTS)) {
1589 1590 1591 1592 1593
		input_report_key(input, keycode, 1);
		input_sync(input);
		input_report_key(input, keycode, 0);
		input_sync(input);
	}
1594

1595
	return;
L
Linus Torvalds 已提交
1596 1597
}

1598 1599
static int acpi_video_resume(struct notifier_block *nb,
				unsigned long val, void *ign)
1600 1601 1602 1603 1604
{
	struct acpi_video_bus *video;
	struct acpi_video_device *video_device;
	int i;

1605 1606 1607 1608 1609 1610
	switch (val) {
	case PM_HIBERNATION_PREPARE:
	case PM_SUSPEND_PREPARE:
	case PM_RESTORE_PREPARE:
		return NOTIFY_DONE;
	}
1611

1612 1613 1614
	video = container_of(nb, struct acpi_video_bus, pm_nb);

	dev_info(&video->device->dev, "Restoring backlight state\n");
1615 1616 1617

	for (i = 0; i < video->attached_count; i++) {
		video_device = video->attached_array[i].bind_info;
1618 1619 1620
		if (video_device && video_device->brightness)
			acpi_video_device_lcd_set_level(video_device,
					video_device->brightness->curr);
1621
	}
1622 1623

	return NOTIFY_OK;
1624 1625
}

1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646
static acpi_status
acpi_video_bus_match(acpi_handle handle, u32 level, void *context,
			void **return_value)
{
	struct acpi_device *device = context;
	struct acpi_device *sibling;
	int result;

	if (handle == device->handle)
		return AE_CTRL_TERMINATE;

	result = acpi_bus_get_device(handle, &sibling);
	if (result)
		return AE_OK;

	if (!strcmp(acpi_device_name(sibling), ACPI_VIDEO_BUS_NAME))
			return AE_ALREADY_EXISTS;

	return AE_OK;
}

1647 1648
static void acpi_video_dev_register_backlight(struct acpi_video_device *device)
{
1649 1650 1651 1652 1653 1654 1655
	struct backlight_properties props;
	struct pci_dev *pdev;
	acpi_handle acpi_parent;
	struct device *parent = NULL;
	int result;
	static int count;
	char *name;
1656

1657 1658 1659
	result = acpi_video_init_brightness(device);
	if (result)
		return;
1660 1661 1662 1663

	if (disable_backlight_sysfs_if > 0)
		return;

1664 1665 1666 1667
	name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
	if (!name)
		return;
	count++;
1668

1669
	acpi_get_parent(device->dev->handle, &acpi_parent);
1670

1671 1672 1673 1674 1675
	pdev = acpi_get_pci_dev(acpi_parent);
	if (pdev) {
		parent = &pdev->dev;
		pci_dev_put(pdev);
	}
1676

1677 1678 1679 1680 1681 1682 1683 1684 1685
	memset(&props, 0, sizeof(struct backlight_properties));
	props.type = BACKLIGHT_FIRMWARE;
	props.max_brightness = device->brightness->count - 3;
	device->backlight = backlight_device_register(name,
						      parent,
						      device,
						      &acpi_backlight_ops,
						      &props);
	kfree(name);
1686 1687
	if (IS_ERR(device->backlight)) {
		device->backlight = NULL;
1688
		return;
1689
	}
1690

1691 1692 1693 1694 1695 1696
	/*
	 * Save current brightness level in case we have to restore it
	 * before acpi_video_device_lcd_set_level() is called next time.
	 */
	device->backlight->props.brightness =
			acpi_video_get_brightness(device->backlight);
1697

1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708
	device->cooling_dev = thermal_cooling_device_register("LCD",
				device->dev, &video_cooling_ops);
	if (IS_ERR(device->cooling_dev)) {
		/*
		 * Set cooling_dev to NULL so we don't crash trying to free it.
		 * Also, why the hell we are returning early and not attempt to
		 * register video output if cooling device registration failed?
		 * -- dtor
		 */
		device->cooling_dev = NULL;
		return;
1709
	}
1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721

	dev_info(&device->dev->dev, "registered as cooling_device%d\n",
		 device->cooling_dev->id);
	result = sysfs_create_link(&device->dev->dev.kobj,
			&device->cooling_dev->device.kobj,
			"thermal_cooling");
	if (result)
		printk(KERN_ERR PREFIX "Create sysfs link\n");
	result = sysfs_create_link(&device->cooling_dev->device.kobj,
			&device->dev->dev.kobj, "device");
	if (result)
		printk(KERN_ERR PREFIX "Create sysfs link\n");
1722 1723
}

1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
static void acpi_video_run_bcl_for_osi(struct acpi_video_bus *video)
{
	struct acpi_video_device *dev;
	union acpi_object *levels;

	mutex_lock(&video->device_list_lock);
	list_for_each_entry(dev, &video->video_device_list, entry) {
		if (!acpi_video_device_lcd_query_levels(dev, &levels))
			kfree(levels);
	}
	mutex_unlock(&video->device_list_lock);
}

1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752
static bool acpi_video_should_register_backlight(struct acpi_video_device *dev)
{
	/*
	 * Do not create backlight device for video output
	 * device that is not in the enumerated list.
	 */
	if (!acpi_video_device_in_dod(dev)) {
		dev_dbg(&dev->dev->dev, "not in _DOD list, ignore\n");
		return false;
	}

	if (only_lcd)
		return dev->flags.lcd;
	return true;
}

1753 1754 1755 1756
static int acpi_video_bus_register_backlight(struct acpi_video_bus *video)
{
	struct acpi_video_device *dev;

1757 1758 1759
	if (video->backlight_registered)
		return 0;

1760 1761
	acpi_video_run_bcl_for_osi(video);

1762
	if (acpi_video_get_backlight_type() != acpi_backlight_video)
1763 1764
		return 0;

1765
	mutex_lock(&video->device_list_lock);
1766 1767 1768 1769
	list_for_each_entry(dev, &video->video_device_list, entry) {
		if (acpi_video_should_register_backlight(dev))
			acpi_video_dev_register_backlight(dev);
	}
1770 1771
	mutex_unlock(&video->device_list_lock);

1772 1773
	video->backlight_registered = true;

1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800
	video->pm_nb.notifier_call = acpi_video_resume;
	video->pm_nb.priority = 0;
	return register_pm_notifier(&video->pm_nb);
}

static void acpi_video_dev_unregister_backlight(struct acpi_video_device *device)
{
	if (device->backlight) {
		backlight_device_unregister(device->backlight);
		device->backlight = NULL;
	}
	if (device->brightness) {
		kfree(device->brightness->levels);
		kfree(device->brightness);
		device->brightness = NULL;
	}
	if (device->cooling_dev) {
		sysfs_remove_link(&device->dev->dev.kobj, "thermal_cooling");
		sysfs_remove_link(&device->cooling_dev->device.kobj, "device");
		thermal_cooling_device_unregister(device->cooling_dev);
		device->cooling_dev = NULL;
	}
}

static int acpi_video_bus_unregister_backlight(struct acpi_video_bus *video)
{
	struct acpi_video_device *dev;
1801 1802 1803 1804 1805 1806
	int error;

	if (!video->backlight_registered)
		return 0;

	error = unregister_pm_notifier(&video->pm_nb);
1807 1808 1809 1810 1811 1812

	mutex_lock(&video->device_list_lock);
	list_for_each_entry(dev, &video->video_device_list, entry)
		acpi_video_dev_unregister_backlight(dev);
	mutex_unlock(&video->device_list_lock);

1813 1814
	video->backlight_registered = false;

1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921
	return error;
}

static void acpi_video_dev_add_notify_handler(struct acpi_video_device *device)
{
	acpi_status status;
	struct acpi_device *adev = device->dev;

	status = acpi_install_notify_handler(adev->handle, ACPI_DEVICE_NOTIFY,
					     acpi_video_device_notify, device);
	if (ACPI_FAILURE(status))
		dev_err(&adev->dev, "Error installing notify handler\n");
	else
		device->flags.notify = 1;
}

static int acpi_video_bus_add_notify_handler(struct acpi_video_bus *video)
{
	struct input_dev *input;
	struct acpi_video_device *dev;
	int error;

	video->input = input = input_allocate_device();
	if (!input) {
		error = -ENOMEM;
		goto out;
	}

	error = acpi_video_bus_start_devices(video);
	if (error)
		goto err_free_input;

	snprintf(video->phys, sizeof(video->phys),
			"%s/video/input0", acpi_device_hid(video->device));

	input->name = acpi_device_name(video->device);
	input->phys = video->phys;
	input->id.bustype = BUS_HOST;
	input->id.product = 0x06;
	input->dev.parent = &video->device->dev;
	input->evbit[0] = BIT(EV_KEY);
	set_bit(KEY_SWITCHVIDEOMODE, input->keybit);
	set_bit(KEY_VIDEO_NEXT, input->keybit);
	set_bit(KEY_VIDEO_PREV, input->keybit);
	set_bit(KEY_BRIGHTNESS_CYCLE, input->keybit);
	set_bit(KEY_BRIGHTNESSUP, input->keybit);
	set_bit(KEY_BRIGHTNESSDOWN, input->keybit);
	set_bit(KEY_BRIGHTNESS_ZERO, input->keybit);
	set_bit(KEY_DISPLAY_OFF, input->keybit);

	error = input_register_device(input);
	if (error)
		goto err_stop_dev;

	mutex_lock(&video->device_list_lock);
	list_for_each_entry(dev, &video->video_device_list, entry)
		acpi_video_dev_add_notify_handler(dev);
	mutex_unlock(&video->device_list_lock);

	return 0;

err_stop_dev:
	acpi_video_bus_stop_devices(video);
err_free_input:
	input_free_device(input);
	video->input = NULL;
out:
	return error;
}

static void acpi_video_dev_remove_notify_handler(struct acpi_video_device *dev)
{
	if (dev->flags.notify) {
		acpi_remove_notify_handler(dev->dev->handle, ACPI_DEVICE_NOTIFY,
					   acpi_video_device_notify);
		dev->flags.notify = 0;
	}
}

static void acpi_video_bus_remove_notify_handler(struct acpi_video_bus *video)
{
	struct acpi_video_device *dev;

	mutex_lock(&video->device_list_lock);
	list_for_each_entry(dev, &video->video_device_list, entry)
		acpi_video_dev_remove_notify_handler(dev);
	mutex_unlock(&video->device_list_lock);

	acpi_video_bus_stop_devices(video);
	input_unregister_device(video->input);
	video->input = NULL;
}

static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
{
	struct acpi_video_device *dev, *next;

	mutex_lock(&video->device_list_lock);
	list_for_each_entry_safe(dev, next, &video->video_device_list, entry) {
		list_del(&dev->entry);
		kfree(dev);
	}
	mutex_unlock(&video->device_list_lock);

	return 0;
}

1922 1923
static int instance;

L
Len Brown 已提交
1924
static int acpi_video_bus_add(struct acpi_device *device)
L
Linus Torvalds 已提交
1925
{
1926 1927
	struct acpi_video_bus *video;
	int error;
1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942
	acpi_status status;

	status = acpi_walk_namespace(ACPI_TYPE_DEVICE,
				device->parent->handle, 1,
				acpi_video_bus_match, NULL,
				device, NULL);
	if (status == AE_ALREADY_EXISTS) {
		printk(KERN_WARNING FW_BUG
			"Duplicate ACPI video bus devices for the"
			" same VGA controller, please try module "
			"parameter \"video.allow_duplicates=1\""
			"if the current driver doesn't work.\n");
		if (!allow_duplicates)
			return -ENODEV;
	}
L
Linus Torvalds 已提交
1943

1944
	video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
L
Linus Torvalds 已提交
1945
	if (!video)
1946
		return -ENOMEM;
L
Linus Torvalds 已提交
1947

1948 1949 1950 1951
	/* a hack to fix the duplicate name "VID" problem on T61 */
	if (!strcmp(device->pnp.bus_id, "VID")) {
		if (instance)
			device->pnp.bus_id[3] = '0' + instance;
1952
		instance++;
1953
	}
1954 1955 1956 1957 1958 1959
	/* a hack to fix the duplicate name "VGA" problem on Pa 3553 */
	if (!strcmp(device->pnp.bus_id, "VGA")) {
		if (instance)
			device->pnp.bus_id[3] = '0' + instance;
		instance++;
	}
1960

1961
	video->device = device;
L
Linus Torvalds 已提交
1962 1963
	strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
	strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
1964
	device->driver_data = video;
L
Linus Torvalds 已提交
1965 1966

	acpi_video_bus_find_cap(video);
1967 1968 1969
	error = acpi_video_bus_check(video);
	if (error)
		goto err_free_video;
L
Linus Torvalds 已提交
1970

1971
	mutex_init(&video->device_list_lock);
L
Linus Torvalds 已提交
1972 1973
	INIT_LIST_HEAD(&video->video_device_list);

1974 1975
	error = acpi_video_bus_get_devices(video, device);
	if (error)
1976
		goto err_put_video;
L
Linus Torvalds 已提交
1977 1978

	printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s  rom: %s  post: %s)\n",
L
Len Brown 已提交
1979 1980 1981 1982
	       ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
	       video->flags.multihead ? "yes" : "no",
	       video->flags.rom ? "yes" : "no",
	       video->flags.post ? "yes" : "no");
1983 1984 1985
	mutex_lock(&video_list_lock);
	list_add_tail(&video->entry, &video_bus_head);
	mutex_unlock(&video_list_lock);
L
Linus Torvalds 已提交
1986

1987 1988
	acpi_video_bus_register_backlight(video);
	acpi_video_bus_add_notify_handler(video);
1989

1990 1991
	return 0;

1992
err_put_video:
1993 1994
	acpi_video_bus_put_devices(video);
	kfree(video->attached_array);
1995
err_free_video:
1996
	kfree(video);
1997
	device->driver_data = NULL;
L
Linus Torvalds 已提交
1998

1999
	return error;
L
Linus Torvalds 已提交
2000 2001
}

2002
static int acpi_video_bus_remove(struct acpi_device *device)
L
Linus Torvalds 已提交
2003
{
L
Len Brown 已提交
2004
	struct acpi_video_bus *video = NULL;
L
Linus Torvalds 已提交
2005 2006 2007


	if (!device || !acpi_driver_data(device))
2008
		return -EINVAL;
L
Linus Torvalds 已提交
2009

2010
	video = acpi_driver_data(device);
L
Linus Torvalds 已提交
2011

2012 2013
	acpi_video_bus_remove_notify_handler(video);
	acpi_video_bus_unregister_backlight(video);
L
Linus Torvalds 已提交
2014 2015
	acpi_video_bus_put_devices(video);

2016 2017 2018 2019
	mutex_lock(&video_list_lock);
	list_del(&video->entry);
	mutex_unlock(&video_list_lock);

2020
	kfree(video->attached_array);
L
Linus Torvalds 已提交
2021 2022
	kfree(video);

2023
	return 0;
L
Linus Torvalds 已提交
2024 2025
}

2026 2027 2028 2029 2030 2031 2032 2033 2034
static int __init is_i740(struct pci_dev *dev)
{
	if (dev->device == 0x00D1)
		return 1;
	if (dev->device == 0x7000)
		return 1;
	return 0;
}

2035 2036
static int __init intel_opregion_present(void)
{
2037
	int opregion = 0;
2038 2039 2040 2041 2042 2043 2044 2045
	struct pci_dev *dev = NULL;
	u32 address;

	for_each_pci_dev(dev) {
		if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
			continue;
		if (dev->vendor != PCI_VENDOR_ID_INTEL)
			continue;
2046 2047 2048
		/* We don't want to poke around undefined i740 registers */
		if (is_i740(dev))
			continue;
2049 2050 2051
		pci_read_config_dword(dev, 0xfc, &address);
		if (!address)
			continue;
2052
		opregion = 1;
2053
	}
2054
	return opregion;
2055 2056
}

2057
int acpi_video_register(void)
L
Linus Torvalds 已提交
2058
{
2059
	int ret = 0;
2060

2061 2062
	mutex_lock(&register_done_mutex);
	if (completion_done(&register_done)) {
2063
		/*
2064 2065
		 * if the function of acpi_video_register is already called,
		 * don't register the acpi_vide_bus again and return no error.
2066
		 */
2067
		goto leave;
2068
	}
L
Linus Torvalds 已提交
2069

2070 2071 2072
	mutex_init(&video_list_lock);
	INIT_LIST_HEAD(&video_bus_head);

2073 2074
	dmi_check_system(video_dmi_table);

2075 2076
	ret = acpi_bus_register_driver(&acpi_video_bus);
	if (ret)
2077
		goto leave;
L
Linus Torvalds 已提交
2078

2079 2080 2081 2082
	/*
	 * When the acpi_video_bus is loaded successfully, increase
	 * the counter reference.
	 */
2083
	complete(&register_done);
2084

2085
leave:
2086
	mutex_unlock(&register_done_mutex);
2087
	return ret;
L
Linus Torvalds 已提交
2088
}
2089
EXPORT_SYMBOL(acpi_video_register);
2090

2091 2092
void acpi_video_unregister(void)
{
2093 2094
	mutex_lock(&register_done_mutex);
	if (completion_done(&register_done)) {
2095
		acpi_bus_unregister_driver(&acpi_video_bus);
2096
		reinit_completion(&register_done);
2097
	}
2098
	mutex_unlock(&register_done_mutex);
2099 2100 2101
}
EXPORT_SYMBOL(acpi_video_unregister);

2102 2103 2104 2105
void acpi_video_unregister_backlight(void)
{
	struct acpi_video_bus *video;

2106 2107
	mutex_lock(&register_done_mutex);
	if (completion_done(&register_done)) {
2108 2109 2110 2111 2112
		mutex_lock(&video_list_lock);
		list_for_each_entry(video, &video_bus_head, entry)
			acpi_video_bus_unregister_backlight(video);
		mutex_unlock(&video_list_lock);
	}
2113
	mutex_unlock(&register_done_mutex);
2114 2115
}

2116 2117 2118 2119
bool acpi_video_handles_brightness_key_presses(void)
{
	bool have_video_busses;

2120
	wait_for_completion(&register_done);
2121 2122 2123 2124
	mutex_lock(&video_list_lock);
	have_video_busses = !list_empty(&video_bus_head);
	mutex_unlock(&video_list_lock);

2125 2126
	return have_video_busses &&
	       (report_key_events & REPORT_BRIGHTNESS_KEY_EVENTS);
2127 2128 2129
}
EXPORT_SYMBOL(acpi_video_handles_brightness_key_presses);

2130 2131 2132 2133 2134 2135 2136 2137 2138
/*
 * This is kind of nasty. Hardware using Intel chipsets may require
 * the video opregion code to be run first in order to initialise
 * state before any ACPI video calls are made. To handle this we defer
 * registration of the video class until the opregion code has run.
 */

static int __init acpi_video_init(void)
{
2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149
	/*
	 * Let the module load even if ACPI is disabled (e.g. due to
	 * a broken BIOS) so that i915.ko can still be loaded on such
	 * old systems without an AcpiOpRegion.
	 *
	 * acpi_video_register() will report -ENODEV later as well due
	 * to acpi_disabled when i915.ko tries to register itself afterwards.
	 */
	if (acpi_disabled)
		return 0;

2150 2151 2152 2153 2154
	if (intel_opregion_present())
		return 0;

	return acpi_video_register();
}
L
Linus Torvalds 已提交
2155

2156
static void __exit acpi_video_exit(void)
L
Linus Torvalds 已提交
2157
{
2158
	acpi_video_detect_exit();
2159
	acpi_video_unregister();
L
Linus Torvalds 已提交
2160

2161
	return;
L
Linus Torvalds 已提交
2162 2163 2164 2165
}

module_init(acpi_video_init);
module_exit(acpi_video_exit);