video.c 52.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 *  video.c - ACPI Video Driver ($Revision:$)
 *
 *  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 28 29 30 31
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  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.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/list.h>
32
#include <linux/mutex.h>
L
Linus Torvalds 已提交
33 34
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
35
#include <linux/input.h>
36
#include <linux/backlight.h>
37
#include <linux/thermal.h>
38
#include <linux/video_output.h>
L
Linus Torvalds 已提交
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
#include <asm/uaccess.h>

#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>

#define ACPI_VIDEO_COMPONENT		0x08000000
#define ACPI_VIDEO_CLASS		"video"
#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

54 55 56 57 58
#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 已提交
59

60
#define MAX_NAME_LEN	20
L
Linus Torvalds 已提交
61

62 63 64 65 66
#define ACPI_VIDEO_DISPLAY_CRT	1
#define ACPI_VIDEO_DISPLAY_TV	2
#define ACPI_VIDEO_DISPLAY_DVI	3
#define ACPI_VIDEO_DISPLAY_LCD	4

L
Linus Torvalds 已提交
67
#define _COMPONENT		ACPI_VIDEO_COMPONENT
68
ACPI_MODULE_NAME("video");
L
Linus Torvalds 已提交
69

70
MODULE_AUTHOR("Bruno Ducrot");
71
MODULE_DESCRIPTION("ACPI Video Driver");
L
Linus Torvalds 已提交
72 73
MODULE_LICENSE("GPL");

74 75 76
static int brightness_switch_enabled = 1;
module_param(brightness_switch_enabled, bool, 0644);

L
Len Brown 已提交
77 78
static int acpi_video_bus_add(struct acpi_device *device);
static int acpi_video_bus_remove(struct acpi_device *device, int type);
79
static int acpi_video_resume(struct acpi_device *device);
L
Linus Torvalds 已提交
80

81 82 83 84 85 86
static const struct acpi_device_id video_device_ids[] = {
	{ACPI_VIDEO_HID, 0},
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, video_device_ids);

L
Linus Torvalds 已提交
87
static struct acpi_driver acpi_video_bus = {
L
Len Brown 已提交
88
	.name = "video",
L
Linus Torvalds 已提交
89
	.class = ACPI_VIDEO_CLASS,
90
	.ids = video_device_ids,
L
Linus Torvalds 已提交
91 92 93
	.ops = {
		.add = acpi_video_bus_add,
		.remove = acpi_video_bus_remove,
94
		.resume = acpi_video_resume,
L
Len Brown 已提交
95
		},
L
Linus Torvalds 已提交
96 97 98
};

struct acpi_video_bus_flags {
L
Len Brown 已提交
99 100 101 102
	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 已提交
103 104 105
};

struct acpi_video_bus_cap {
L
Len Brown 已提交
106 107 108 109 110 111 112
	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 */
	u8 reserved:2;
L
Linus Torvalds 已提交
113 114
};

L
Len Brown 已提交
115 116
struct acpi_video_device_attrib {
	u32 display_index:4;	/* A zero-based instance of the Display */
117
	u32 display_port_attachment:4;	/*This field differentiates the display type */
L
Len Brown 已提交
118
	u32 display_type:4;	/*Describe the specific type in use */
119
	u32 vendor_specific:4;	/*Chipset Vendor Specific */
L
Len Brown 已提交
120 121 122 123 124 125
	u32 bios_can_detect:1;	/*BIOS can detect the device */
	u32 depend_on_vga:1;	/*Non-VGA output device whose power is related to 
				   the VGA device. */
	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 已提交
126 127 128 129 130
};

struct acpi_video_enumerated_device {
	union {
		u32 int_val;
L
Len Brown 已提交
131
		struct acpi_video_device_attrib attrib;
L
Linus Torvalds 已提交
132 133 134 135 136
	} value;
	struct acpi_video_device *bind_info;
};

struct acpi_video_bus {
137
	struct acpi_device *device;
L
Len Brown 已提交
138
	u8 dos_setting;
L
Linus Torvalds 已提交
139
	struct acpi_video_enumerated_device *attached_array;
L
Len Brown 已提交
140 141
	u8 attached_count;
	struct acpi_video_bus_cap cap;
L
Linus Torvalds 已提交
142
	struct acpi_video_bus_flags flags;
L
Len Brown 已提交
143
	struct list_head video_device_list;
144
	struct mutex device_list_lock;	/* protects video_device_list */
L
Len Brown 已提交
145
	struct proc_dir_entry *dir;
146 147
	struct input_dev *input;
	char phys[32];	/* for input device */
L
Linus Torvalds 已提交
148 149 150
};

struct acpi_video_device_flags {
L
Len Brown 已提交
151 152 153
	u8 crt:1;
	u8 lcd:1;
	u8 tvout:1;
154
	u8 dvi:1;
L
Len Brown 已提交
155 156
	u8 bios:1;
	u8 unknown:1;
157
	u8 reserved:2;
L
Linus Torvalds 已提交
158 159 160
};

struct acpi_video_device_cap {
L
Len Brown 已提交
161 162 163
	u8 _ADR:1;		/*Return the unique ID */
	u8 _BCL:1;		/*Query list of brightness control levels supported */
	u8 _BCM:1;		/*Set the brightness level */
164
	u8 _BQC:1;		/* Get current brightness level */
L
Len Brown 已提交
165 166 167 168
	u8 _DDC:1;		/*Return the EDID for this device */
	u8 _DCS:1;		/*Return status of output device */
	u8 _DGS:1;		/*Query graphics state */
	u8 _DSS:1;		/*Device state set */
L
Linus Torvalds 已提交
169 170 171
};

struct acpi_video_device_brightness {
L
Len Brown 已提交
172 173 174
	int curr;
	int count;
	int *levels;
L
Linus Torvalds 已提交
175 176 177
};

struct acpi_video_device {
L
Len Brown 已提交
178 179 180 181 182 183
	unsigned long device_id;
	struct acpi_video_device_flags flags;
	struct acpi_video_device_cap cap;
	struct list_head entry;
	struct acpi_video_bus *video;
	struct acpi_device *dev;
L
Linus Torvalds 已提交
184
	struct acpi_video_device_brightness *brightness;
185
	struct backlight_device *backlight;
186
	struct thermal_cooling_device *cdev;
187
	struct output_device *output_dev;
L
Linus Torvalds 已提交
188 189 190 191 192
};

/* bus */
static int acpi_video_bus_info_open_fs(struct inode *inode, struct file *file);
static struct file_operations acpi_video_bus_info_fops = {
193
	.owner = THIS_MODULE,
L
Len Brown 已提交
194 195 196 197
	.open = acpi_video_bus_info_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
198 199 200 201
};

static int acpi_video_bus_ROM_open_fs(struct inode *inode, struct file *file);
static struct file_operations acpi_video_bus_ROM_fops = {
202
	.owner = THIS_MODULE,
L
Len Brown 已提交
203 204 205 206
	.open = acpi_video_bus_ROM_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
207 208
};

L
Len Brown 已提交
209 210
static int acpi_video_bus_POST_info_open_fs(struct inode *inode,
					    struct file *file);
L
Linus Torvalds 已提交
211
static struct file_operations acpi_video_bus_POST_info_fops = {
212
	.owner = THIS_MODULE,
L
Len Brown 已提交
213 214 215 216
	.open = acpi_video_bus_POST_info_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
217 218 219 220
};

static int acpi_video_bus_POST_open_fs(struct inode *inode, struct file *file);
static struct file_operations acpi_video_bus_POST_fops = {
221
	.owner = THIS_MODULE,
L
Len Brown 已提交
222 223 224 225
	.open = acpi_video_bus_POST_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
226 227 228 229
};

static int acpi_video_bus_DOS_open_fs(struct inode *inode, struct file *file);
static struct file_operations acpi_video_bus_DOS_fops = {
230
	.owner = THIS_MODULE,
L
Len Brown 已提交
231 232 233 234
	.open = acpi_video_bus_DOS_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
235 236 237
};

/* device */
L
Len Brown 已提交
238 239
static int acpi_video_device_info_open_fs(struct inode *inode,
					  struct file *file);
L
Linus Torvalds 已提交
240
static struct file_operations acpi_video_device_info_fops = {
241
	.owner = THIS_MODULE,
L
Len Brown 已提交
242 243 244 245
	.open = acpi_video_device_info_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
246 247
};

L
Len Brown 已提交
248 249
static int acpi_video_device_state_open_fs(struct inode *inode,
					   struct file *file);
L
Linus Torvalds 已提交
250
static struct file_operations acpi_video_device_state_fops = {
251
	.owner = THIS_MODULE,
L
Len Brown 已提交
252 253 254 255
	.open = acpi_video_device_state_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
256 257
};

L
Len Brown 已提交
258 259
static int acpi_video_device_brightness_open_fs(struct inode *inode,
						struct file *file);
L
Linus Torvalds 已提交
260
static struct file_operations acpi_video_device_brightness_fops = {
261
	.owner = THIS_MODULE,
L
Len Brown 已提交
262 263 264 265
	.open = acpi_video_device_brightness_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
266 267
};

L
Len Brown 已提交
268 269
static int acpi_video_device_EDID_open_fs(struct inode *inode,
					  struct file *file);
L
Linus Torvalds 已提交
270
static struct file_operations acpi_video_device_EDID_fops = {
271
	.owner = THIS_MODULE,
L
Len Brown 已提交
272 273 274 275
	.open = acpi_video_device_EDID_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
276 277
};

L
Len Brown 已提交
278
static char device_decode[][30] = {
L
Linus Torvalds 已提交
279 280 281 282 283 284
	"motherboard VGA device",
	"PCI VGA device",
	"AGP VGA device",
	"UNKNOWN",
};

L
Len Brown 已提交
285 286 287 288
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 已提交
289
static int acpi_video_device_enumerate(struct acpi_video_bus *video);
290 291 292 293
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,
294
			unsigned long long *level);
L
Len Brown 已提交
295 296 297 298
static int acpi_video_get_next_level(struct acpi_video_device *device,
				     u32 level_current, u32 event);
static void acpi_video_switch_brightness(struct acpi_video_device *device,
					 int event);
299
static int acpi_video_device_get_state(struct acpi_video_device *device,
300
			    unsigned long long *state);
301 302
static int acpi_video_output_get(struct output_device *od);
static int acpi_video_device_set_state(struct acpi_video_device *device, int state);
L
Linus Torvalds 已提交
303

304 305 306
/*backlight device sysfs support*/
static int acpi_video_get_brightness(struct backlight_device *bd)
{
307
	unsigned long long cur_level;
308
	int i;
309
	struct acpi_video_device *vd =
310
		(struct acpi_video_device *)bl_get_data(bd);
311
	acpi_video_device_lcd_get_level_current(vd, &cur_level);
312 313 314 315 316 317 318
	for (i = 2; i < vd->brightness->count; i++) {
		if (vd->brightness->levels[i] == cur_level)
			/* The first two entries are special - see page 575
			   of the ACPI spec 3.0 */
			return i-2;
	}
	return 0;
319 320 321 322
}

static int acpi_video_set_brightness(struct backlight_device *bd)
{
323
	int request_level = bd->props.brightness+2;
324
	struct acpi_video_device *vd =
325
		(struct acpi_video_device *)bl_get_data(bd);
326 327
	acpi_video_device_lcd_set_level(vd,
					vd->brightness->levels[request_level]);
328 329 330
	return 0;
}

331 332 333 334 335
static struct backlight_ops acpi_backlight_ops = {
	.get_brightness = acpi_video_get_brightness,
	.update_status  = acpi_video_set_brightness,
};

336 337 338
/*video output device sysfs support*/
static int acpi_video_output_get(struct output_device *od)
{
339
	unsigned long long state;
340
	struct acpi_video_device *vd =
341
		(struct acpi_video_device *)dev_get_drvdata(&od->dev);
342 343 344 345 346 347 348 349
	acpi_video_device_get_state(vd, &state);
	return (int)state;
}

static int acpi_video_output_set(struct output_device *od)
{
	unsigned long state = od->request_state;
	struct acpi_video_device *vd=
350
		(struct acpi_video_device *)dev_get_drvdata(&od->dev);
351 352 353 354 355 356 357
	return acpi_video_device_set_state(vd, state);
}

static struct output_properties acpi_output_properties = {
	.set_state = acpi_video_output_set,
	.get_status = acpi_video_output_get,
};
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372


/* thermal cooling device callbacks */
static int video_get_max_state(struct thermal_cooling_device *cdev, char *buf)
{
	struct acpi_device *device = cdev->devdata;
	struct acpi_video_device *video = acpi_driver_data(device);

	return sprintf(buf, "%d\n", video->brightness->count - 3);
}

static int video_get_cur_state(struct thermal_cooling_device *cdev, char *buf)
{
	struct acpi_device *device = cdev->devdata;
	struct acpi_video_device *video = acpi_driver_data(device);
373
	unsigned long long level;
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
	int state;

	acpi_video_device_lcd_get_level_current(video, &level);
	for (state = 2; state < video->brightness->count; state++)
		if (level == video->brightness->levels[state])
			return sprintf(buf, "%d\n",
				       video->brightness->count - state - 1);

	return -EINVAL;
}

static int
video_set_cur_state(struct thermal_cooling_device *cdev, unsigned int state)
{
	struct acpi_device *device = cdev->devdata;
	struct acpi_video_device *video = acpi_driver_data(device);
	int level;

	if ( state >= video->brightness->count - 2)
		return -EINVAL;

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

static struct thermal_cooling_device_ops video_cooling_ops = {
	.get_max_state = video_get_max_state,
	.get_cur_state = video_get_cur_state,
	.set_cur_state = video_set_cur_state,
};

L
Linus Torvalds 已提交
406 407 408 409 410 411 412
/* --------------------------------------------------------------------------
                               Video Management
   -------------------------------------------------------------------------- */

/* device */

static int
413
acpi_video_device_query(struct acpi_video_device *device, unsigned long long *state)
L
Linus Torvalds 已提交
414
{
L
Len Brown 已提交
415
	int status;
416 417

	status = acpi_evaluate_integer(device->dev->handle, "_DGS", NULL, state);
L
Linus Torvalds 已提交
418

419
	return status;
L
Linus Torvalds 已提交
420 421 422
}

static int
L
Len Brown 已提交
423
acpi_video_device_get_state(struct acpi_video_device *device,
424
			    unsigned long long *state)
L
Linus Torvalds 已提交
425
{
L
Len Brown 已提交
426
	int status;
L
Linus Torvalds 已提交
427

428
	status = acpi_evaluate_integer(device->dev->handle, "_DCS", NULL, state);
L
Linus Torvalds 已提交
429

430
	return status;
L
Linus Torvalds 已提交
431 432 433
}

static int
L
Len Brown 已提交
434
acpi_video_device_set_state(struct acpi_video_device *device, int state)
L
Linus Torvalds 已提交
435
{
L
Len Brown 已提交
436 437 438
	int status;
	union acpi_object arg0 = { ACPI_TYPE_INTEGER };
	struct acpi_object_list args = { 1, &arg0 };
439
	unsigned long long ret;
L
Linus Torvalds 已提交
440 441 442


	arg0.integer.value = state;
443
	status = acpi_evaluate_integer(device->dev->handle, "_DSS", &args, &ret);
L
Linus Torvalds 已提交
444

445
	return status;
L
Linus Torvalds 已提交
446 447 448
}

static int
L
Len Brown 已提交
449 450
acpi_video_device_lcd_query_levels(struct acpi_video_device *device,
				   union acpi_object **levels)
L
Linus Torvalds 已提交
451
{
L
Len Brown 已提交
452 453 454
	int status;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *obj;
L
Linus Torvalds 已提交
455 456 457 458


	*levels = NULL;

459
	status = acpi_evaluate_object(device->dev->handle, "_BCL", NULL, &buffer);
L
Linus Torvalds 已提交
460
	if (!ACPI_SUCCESS(status))
461
		return status;
L
Len Brown 已提交
462
	obj = (union acpi_object *)buffer.pointer;
463
	if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
464
		printk(KERN_ERR PREFIX "Invalid _BCL data\n");
L
Linus Torvalds 已提交
465 466 467 468 469 470
		status = -EFAULT;
		goto err;
	}

	*levels = obj;

471
	return 0;
L
Linus Torvalds 已提交
472

L
Len Brown 已提交
473
      err:
474
	kfree(buffer.pointer);
L
Linus Torvalds 已提交
475

476
	return status;
L
Linus Torvalds 已提交
477 478 479
}

static int
L
Len Brown 已提交
480
acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level)
L
Linus Torvalds 已提交
481
{
482
	int status = AE_OK;
L
Len Brown 已提交
483 484
	union acpi_object arg0 = { ACPI_TYPE_INTEGER };
	struct acpi_object_list args = { 1, &arg0 };
L
Linus Torvalds 已提交
485 486 487 488


	arg0.integer.value = level;

489 490 491 492
	if (device->cap._BCM)
		status = acpi_evaluate_object(device->dev->handle, "_BCM",
					      &args, NULL);
	device->brightness->curr = level;
493
	return status;
L
Linus Torvalds 已提交
494 495 496
}

static int
L
Len Brown 已提交
497
acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
498
					unsigned long long *level)
L
Linus Torvalds 已提交
499
{
500 501 502 503 504
	if (device->cap._BQC)
		return acpi_evaluate_integer(device->dev->handle, "_BQC", NULL,
					     level);
	*level = device->brightness->curr;
	return AE_OK;
L
Linus Torvalds 已提交
505 506 507
}

static int
L
Len Brown 已提交
508 509
acpi_video_device_EDID(struct acpi_video_device *device,
		       union acpi_object **edid, ssize_t length)
L
Linus Torvalds 已提交
510
{
L
Len Brown 已提交
511 512 513 514 515
	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 已提交
516 517 518 519 520


	*edid = NULL;

	if (!device)
521
		return -ENODEV;
L
Linus Torvalds 已提交
522 523 524 525 526
	if (length == 128)
		arg0.integer.value = 1;
	else if (length == 256)
		arg0.integer.value = 2;
	else
527
		return -EINVAL;
L
Linus Torvalds 已提交
528

529
	status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer);
L
Linus Torvalds 已提交
530
	if (ACPI_FAILURE(status))
531
		return -ENODEV;
L
Linus Torvalds 已提交
532

533
	obj = buffer.pointer;
L
Linus Torvalds 已提交
534 535 536 537

	if (obj && obj->type == ACPI_TYPE_BUFFER)
		*edid = obj;
	else {
538
		printk(KERN_ERR PREFIX "Invalid _DDC data\n");
L
Linus Torvalds 已提交
539 540 541 542
		status = -EFAULT;
		kfree(obj);
	}

543
	return status;
L
Linus Torvalds 已提交
544 545 546 547 548
}

/* bus */

static int
L
Len Brown 已提交
549
acpi_video_bus_set_POST(struct acpi_video_bus *video, unsigned long option)
L
Linus Torvalds 已提交
550
{
L
Len Brown 已提交
551
	int status;
552
	unsigned long long tmp;
L
Len Brown 已提交
553 554
	union acpi_object arg0 = { ACPI_TYPE_INTEGER };
	struct acpi_object_list args = { 1, &arg0 };
L
Linus Torvalds 已提交
555 556 557 558


	arg0.integer.value = option;

559
	status = acpi_evaluate_integer(video->device->handle, "_SPD", &args, &tmp);
L
Linus Torvalds 已提交
560
	if (ACPI_SUCCESS(status))
L
Len Brown 已提交
561
		status = tmp ? (-EINVAL) : (AE_OK);
L
Linus Torvalds 已提交
562

563
	return status;
L
Linus Torvalds 已提交
564 565 566
}

static int
567
acpi_video_bus_get_POST(struct acpi_video_bus *video, unsigned long long *id)
L
Linus Torvalds 已提交
568 569 570
{
	int status;

571
	status = acpi_evaluate_integer(video->device->handle, "_GPD", NULL, id);
L
Linus Torvalds 已提交
572

573
	return status;
L
Linus Torvalds 已提交
574 575 576
}

static int
L
Len Brown 已提交
577
acpi_video_bus_POST_options(struct acpi_video_bus *video,
578
			    unsigned long long *options)
L
Linus Torvalds 已提交
579
{
L
Len Brown 已提交
580
	int status;
L
Linus Torvalds 已提交
581

582
	status = acpi_evaluate_integer(video->device->handle, "_VPO", NULL, options);
L
Linus Torvalds 已提交
583 584
	*options &= 3;

585
	return status;
L
Linus Torvalds 已提交
586 587 588 589 590 591 592 593 594
}

/*
 *  Arg:
 *  	video		: video bus device pointer
 *	bios_flag	: 
 *		0.	The system BIOS should NOT automatically switch(toggle)
 *			the active display output.
 *		1.	The system BIOS should automatically switch (toggle) the
595
 *			active display output. No switch event.
L
Linus Torvalds 已提交
596 597 598 599 600 601
 *		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
602
 *			of the LCD when the power changes from AC to DC
L
Linus Torvalds 已提交
603
 *		1. 	The system BIOS should NOT automatically control the brightness 
604
 *			level of the LCD when the power changes from AC to DC.
L
Linus Torvalds 已提交
605 606 607 608 609
 * Return Value:
 * 		-1	wrong arg.
 */

static int
L
Len Brown 已提交
610
acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
L
Linus Torvalds 已提交
611
{
L
Len Brown 已提交
612 613 614
	acpi_integer status = 0;
	union acpi_object arg0 = { ACPI_TYPE_INTEGER };
	struct acpi_object_list args = { 1, &arg0 };
L
Linus Torvalds 已提交
615 616


L
Len Brown 已提交
617
	if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1) {
L
Linus Torvalds 已提交
618 619 620 621 622
		status = -1;
		goto Failed;
	}
	arg0.integer.value = (lcd_flag << 2) | bios_flag;
	video->dos_setting = arg0.integer.value;
623
	acpi_evaluate_object(video->device->handle, "_DOS", &args, NULL);
L
Linus Torvalds 已提交
624

L
Len Brown 已提交
625
      Failed:
626
	return status;
L
Linus Torvalds 已提交
627 628 629 630 631 632 633
}

/*
 *  Arg:	
 *  	device	: video output device (LCD, CRT, ..)
 *
 *  Return Value:
634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703
 *	Maximum brightness level
 *
 *  Allocate and initialize device->brightness.
 */

static int
acpi_video_init_brightness(struct acpi_video_device *device)
{
	union acpi_object *obj = NULL;
	int i, max_level = 0, count = 0;
	union acpi_object *o;
	struct acpi_video_device_brightness *br = NULL;

	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");
		goto out;
	}

	br->levels = kmalloc(obj->package.count * sizeof *(br->levels),
				GFP_KERNEL);
	if (!br->levels)
		goto out_free;

	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;
		}
		br->levels[count] = (u32) o->integer.value;

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

	if (count < 2)
		goto out_free_levels;

	br->count = count;
	device->brightness = br;
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "found %d brightness levels\n", count));
	kfree(obj);
	return max_level;

out_free_levels:
	kfree(br->levels);
out_free:
	kfree(br);
out:
	device->brightness = NULL;
	kfree(obj);
	return 0;
}

/*
 *  Arg:
 *	device	: video output device (LCD, CRT, ..)
 *
 *  Return Value:
L
Linus Torvalds 已提交
704 705
 *  	None
 *
706
 *  Find out all required AML methods defined under the output
L
Linus Torvalds 已提交
707 708 709
 *  device.
 */

L
Len Brown 已提交
710
static void acpi_video_device_find_cap(struct acpi_video_device *device)
L
Linus Torvalds 已提交
711 712
{
	acpi_handle h_dummy1;
713
	u32 max_level = 0;
L
Linus Torvalds 已提交
714 715


716
	memset(&device->cap, 0, sizeof(device->cap));
L
Linus Torvalds 已提交
717

718
	if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_ADR", &h_dummy1))) {
L
Linus Torvalds 已提交
719 720
		device->cap._ADR = 1;
	}
721
	if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCL", &h_dummy1))) {
L
Len Brown 已提交
722
		device->cap._BCL = 1;
L
Linus Torvalds 已提交
723
	}
724
	if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCM", &h_dummy1))) {
L
Len Brown 已提交
725
		device->cap._BCM = 1;
L
Linus Torvalds 已提交
726
	}
727 728
	if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle,"_BQC",&h_dummy1)))
		device->cap._BQC = 1;
729
	if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DDC", &h_dummy1))) {
L
Len Brown 已提交
730
		device->cap._DDC = 1;
L
Linus Torvalds 已提交
731
	}
732
	if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DCS", &h_dummy1))) {
L
Linus Torvalds 已提交
733 734
		device->cap._DCS = 1;
	}
735
	if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DGS", &h_dummy1))) {
L
Linus Torvalds 已提交
736 737
		device->cap._DGS = 1;
	}
738
	if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DSS", &h_dummy1))) {
L
Linus Torvalds 已提交
739 740 741
		device->cap._DSS = 1;
	}

742
	max_level = acpi_video_init_brightness(device);
L
Linus Torvalds 已提交
743

744
	if (device->cap._BCL && device->cap._BCM && max_level > 0) {
745
		int result;
746 747 748 749 750 751 752 753
		static int count = 0;
		char *name;
		name = kzalloc(MAX_NAME_LEN, GFP_KERNEL);
		if (!name)
			return;

		sprintf(name, "acpi_video%d", count++);
		device->backlight = backlight_device_register(name,
754
			NULL, device, &acpi_backlight_ops);
755
		device->backlight->props.max_brightness = device->brightness->count-3;
756 757 758 759 760 761 762 763 764 765 766
		/*
		 * If there exists the _BQC object, the _BQC object will be
		 * called to get the current backlight brightness. Otherwise
		 * the brightness will be set to the maximum.
		 */
		if (device->cap._BQC)
			device->backlight->props.brightness =
				acpi_video_get_brightness(device->backlight);
		else
			device->backlight->props.brightness =
				device->backlight->props.max_brightness;
767
		backlight_update_status(device->backlight);
768
		kfree(name);
769 770 771

		device->cdev = thermal_cooling_device_register("LCD",
					device->dev, &video_cooling_ops);
772 773 774
		if (IS_ERR(device->cdev))
			return;

775 776
		dev_info(&device->dev->dev, "registered as cooling_device%d\n",
			 device->cdev->id);
777 778 779 780 781 782 783 784 785 786
		result = sysfs_create_link(&device->dev->dev.kobj,
				&device->cdev->device.kobj,
				"thermal_cooling");
		if (result)
			printk(KERN_ERR PREFIX "Create sysfs link\n");
		result = sysfs_create_link(&device->cdev->device.kobj,
				&device->dev->dev.kobj, "device");
		if (result)
			printk(KERN_ERR PREFIX "Create sysfs link\n");

787
	}
788 789 790 791 792 793 794 795 796 797 798
	if (device->cap._DCS && device->cap._DSS){
		static int count = 0;
		char *name;
		name = kzalloc(MAX_NAME_LEN, GFP_KERNEL);
		if (!name)
			return;
		sprintf(name, "acpi_video%d", count++);
		device->output_dev = video_output_register(name,
				NULL, device, &acpi_output_properties);
		kfree(name);
	}
799
	return;
L
Linus Torvalds 已提交
800 801 802 803 804 805 806 807 808
}

/*
 *  Arg:	
 *  	device	: video output device (VGA)
 *
 *  Return Value:
 *  	None
 *
809
 *  Find out all required AML methods defined under the video bus device.
L
Linus Torvalds 已提交
810 811
 */

L
Len Brown 已提交
812
static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
L
Linus Torvalds 已提交
813
{
L
Len Brown 已提交
814
	acpi_handle h_dummy1;
L
Linus Torvalds 已提交
815

816
	memset(&video->cap, 0, sizeof(video->cap));
817
	if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOS", &h_dummy1))) {
L
Linus Torvalds 已提交
818 819
		video->cap._DOS = 1;
	}
820
	if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOD", &h_dummy1))) {
L
Linus Torvalds 已提交
821 822
		video->cap._DOD = 1;
	}
823
	if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_ROM", &h_dummy1))) {
L
Linus Torvalds 已提交
824 825
		video->cap._ROM = 1;
	}
826
	if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_GPD", &h_dummy1))) {
L
Linus Torvalds 已提交
827 828
		video->cap._GPD = 1;
	}
829
	if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_SPD", &h_dummy1))) {
L
Linus Torvalds 已提交
830 831
		video->cap._SPD = 1;
	}
832
	if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_VPO", &h_dummy1))) {
L
Linus Torvalds 已提交
833 834 835 836 837 838 839 840 841
		video->cap._VPO = 1;
	}
}

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

L
Len Brown 已提交
842
static int acpi_video_bus_check(struct acpi_video_bus *video)
L
Linus Torvalds 已提交
843
{
L
Len Brown 已提交
844
	acpi_status status = -ENOENT;
845

L
Linus Torvalds 已提交
846 847

	if (!video)
848
		return -EINVAL;
L
Linus Torvalds 已提交
849 850 851 852 853

	/* Since there is no HID, CID and so on for VGA driver, we have
	 * to check well known required nodes.
	 */

854
	/* Does this device support video switching? */
L
Len Brown 已提交
855
	if (video->cap._DOS) {
L
Linus Torvalds 已提交
856 857 858 859
		video->flags.multihead = 1;
		status = 0;
	}

860
	/* Does this device support retrieving a video ROM? */
L
Len Brown 已提交
861
	if (video->cap._ROM) {
L
Linus Torvalds 已提交
862 863 864 865
		video->flags.rom = 1;
		status = 0;
	}

866
	/* Does this device support configuring which video device to POST? */
L
Len Brown 已提交
867
	if (video->cap._GPD && video->cap._SPD && video->cap._VPO) {
L
Linus Torvalds 已提交
868 869 870 871
		video->flags.post = 1;
		status = 0;
	}

872
	return status;
L
Linus Torvalds 已提交
873 874 875 876 877 878
}

/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
879
static struct proc_dir_entry *acpi_video_dir;
L
Linus Torvalds 已提交
880 881 882

/* video devices */

L
Len Brown 已提交
883
static int acpi_video_device_info_seq_show(struct seq_file *seq, void *offset)
L
Linus Torvalds 已提交
884
{
885
	struct acpi_video_device *dev = seq->private;
L
Linus Torvalds 已提交
886 887 888 889 890 891 892 893 894 895 896 897 898


	if (!dev)
		goto end;

	seq_printf(seq, "device_id:    0x%04x\n", (u32) dev->device_id);
	seq_printf(seq, "type:         ");
	if (dev->flags.crt)
		seq_printf(seq, "CRT\n");
	else if (dev->flags.lcd)
		seq_printf(seq, "LCD\n");
	else if (dev->flags.tvout)
		seq_printf(seq, "TVOUT\n");
899 900
	else if (dev->flags.dvi)
		seq_printf(seq, "DVI\n");
L
Linus Torvalds 已提交
901 902 903
	else
		seq_printf(seq, "UNKNOWN\n");

L
Len Brown 已提交
904
	seq_printf(seq, "known by bios: %s\n", dev->flags.bios ? "yes" : "no");
L
Linus Torvalds 已提交
905

L
Len Brown 已提交
906
      end:
907
	return 0;
L
Linus Torvalds 已提交
908 909 910
}

static int
L
Len Brown 已提交
911
acpi_video_device_info_open_fs(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
912 913 914 915 916
{
	return single_open(file, acpi_video_device_info_seq_show,
			   PDE(inode)->data);
}

L
Len Brown 已提交
917
static int acpi_video_device_state_seq_show(struct seq_file *seq, void *offset)
L
Linus Torvalds 已提交
918
{
L
Len Brown 已提交
919
	int status;
920
	struct acpi_video_device *dev = seq->private;
921
	unsigned long long state;
L
Linus Torvalds 已提交
922 923 924 925 926 927 928 929


	if (!dev)
		goto end;

	status = acpi_video_device_get_state(dev, &state);
	seq_printf(seq, "state:     ");
	if (ACPI_SUCCESS(status))
930
		seq_printf(seq, "0x%02llx\n", state);
L
Linus Torvalds 已提交
931 932 933 934 935 936
	else
		seq_printf(seq, "<not supported>\n");

	status = acpi_video_device_query(dev, &state);
	seq_printf(seq, "query:     ");
	if (ACPI_SUCCESS(status))
937
		seq_printf(seq, "0x%02llx\n", state);
L
Linus Torvalds 已提交
938 939 940
	else
		seq_printf(seq, "<not supported>\n");

L
Len Brown 已提交
941
      end:
942
	return 0;
L
Linus Torvalds 已提交
943 944 945
}

static int
L
Len Brown 已提交
946
acpi_video_device_state_open_fs(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
947 948 949 950 951 952
{
	return single_open(file, acpi_video_device_state_seq_show,
			   PDE(inode)->data);
}

static ssize_t
L
Len Brown 已提交
953 954 955
acpi_video_device_write_state(struct file *file,
			      const char __user * buffer,
			      size_t count, loff_t * data)
L
Linus Torvalds 已提交
956
{
L
Len Brown 已提交
957
	int status;
958 959
	struct seq_file *m = file->private_data;
	struct acpi_video_device *dev = m->private;
L
Len Brown 已提交
960 961
	char str[12] = { 0 };
	u32 state = 0;
L
Linus Torvalds 已提交
962 963 964


	if (!dev || count + 1 > sizeof str)
965
		return -EINVAL;
L
Linus Torvalds 已提交
966 967

	if (copy_from_user(str, buffer, count))
968
		return -EFAULT;
L
Linus Torvalds 已提交
969 970 971

	str[count] = 0;
	state = simple_strtoul(str, NULL, 0);
L
Len Brown 已提交
972
	state &= ((1ul << 31) | (1ul << 30) | (1ul << 0));
L
Linus Torvalds 已提交
973 974 975 976

	status = acpi_video_device_set_state(dev, state);

	if (status)
977
		return -EFAULT;
L
Linus Torvalds 已提交
978

979
	return count;
L
Linus Torvalds 已提交
980 981 982
}

static int
L
Len Brown 已提交
983
acpi_video_device_brightness_seq_show(struct seq_file *seq, void *offset)
L
Linus Torvalds 已提交
984
{
985
	struct acpi_video_device *dev = seq->private;
L
Len Brown 已提交
986
	int i;
L
Linus Torvalds 已提交
987 988 989 990


	if (!dev || !dev->brightness) {
		seq_printf(seq, "<not supported>\n");
991
		return 0;
L
Linus Torvalds 已提交
992 993 994 995 996 997 998
	}

	seq_printf(seq, "levels: ");
	for (i = 0; i < dev->brightness->count; i++)
		seq_printf(seq, " %d", dev->brightness->levels[i]);
	seq_printf(seq, "\ncurrent: %d\n", dev->brightness->curr);

999
	return 0;
L
Linus Torvalds 已提交
1000 1001 1002
}

static int
L
Len Brown 已提交
1003
acpi_video_device_brightness_open_fs(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
1004 1005 1006 1007 1008 1009
{
	return single_open(file, acpi_video_device_brightness_seq_show,
			   PDE(inode)->data);
}

static ssize_t
L
Len Brown 已提交
1010 1011 1012
acpi_video_device_write_brightness(struct file *file,
				   const char __user * buffer,
				   size_t count, loff_t * data)
L
Linus Torvalds 已提交
1013
{
1014 1015
	struct seq_file *m = file->private_data;
	struct acpi_video_device *dev = m->private;
1016
	char str[5] = { 0 };
L
Len Brown 已提交
1017 1018
	unsigned int level = 0;
	int i;
L
Linus Torvalds 已提交
1019 1020


1021
	if (!dev || !dev->brightness || count + 1 > sizeof str)
1022
		return -EINVAL;
L
Linus Torvalds 已提交
1023 1024

	if (copy_from_user(str, buffer, count))
1025
		return -EFAULT;
L
Linus Torvalds 已提交
1026 1027 1028

	str[count] = 0;
	level = simple_strtoul(str, NULL, 0);
L
Len Brown 已提交
1029

L
Linus Torvalds 已提交
1030
	if (level > 100)
1031
		return -EFAULT;
L
Linus Torvalds 已提交
1032

1033
	/* validate through the list of available levels */
L
Linus Torvalds 已提交
1034 1035
	for (i = 0; i < dev->brightness->count; i++)
		if (level == dev->brightness->levels[i]) {
L
Len Brown 已提交
1036 1037
			if (ACPI_SUCCESS
			    (acpi_video_device_lcd_set_level(dev, level)))
L
Linus Torvalds 已提交
1038 1039 1040 1041
				dev->brightness->curr = level;
			break;
		}

1042
	return count;
L
Linus Torvalds 已提交
1043 1044
}

L
Len Brown 已提交
1045
static int acpi_video_device_EDID_seq_show(struct seq_file *seq, void *offset)
L
Linus Torvalds 已提交
1046
{
1047
	struct acpi_video_device *dev = seq->private;
L
Len Brown 已提交
1048 1049 1050
	int status;
	int i;
	union acpi_object *edid = NULL;
L
Linus Torvalds 已提交
1051 1052 1053 1054 1055


	if (!dev)
		goto out;

L
Len Brown 已提交
1056
	status = acpi_video_device_EDID(dev, &edid, 128);
L
Linus Torvalds 已提交
1057
	if (ACPI_FAILURE(status)) {
L
Len Brown 已提交
1058
		status = acpi_video_device_EDID(dev, &edid, 256);
L
Linus Torvalds 已提交
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069
	}

	if (ACPI_FAILURE(status)) {
		goto out;
	}

	if (edid && edid->type == ACPI_TYPE_BUFFER) {
		for (i = 0; i < edid->buffer.length; i++)
			seq_putc(seq, edid->buffer.pointer[i]);
	}

L
Len Brown 已提交
1070
      out:
L
Linus Torvalds 已提交
1071 1072 1073 1074 1075
	if (!edid)
		seq_printf(seq, "<not supported>\n");
	else
		kfree(edid);

1076
	return 0;
L
Linus Torvalds 已提交
1077 1078 1079
}

static int
L
Len Brown 已提交
1080
acpi_video_device_EDID_open_fs(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
1081 1082 1083 1084 1085
{
	return single_open(file, acpi_video_device_EDID_seq_show,
			   PDE(inode)->data);
}

L
Len Brown 已提交
1086
static int acpi_video_device_add_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
1087
{
1088
	struct proc_dir_entry *entry, *device_dir;
L
Linus Torvalds 已提交
1089 1090
	struct acpi_video_device *vid_dev;

1091
	vid_dev = acpi_driver_data(device);
L
Linus Torvalds 已提交
1092
	if (!vid_dev)
1093
		return -ENODEV;
L
Linus Torvalds 已提交
1094

1095 1096 1097 1098 1099 1100
	device_dir = proc_mkdir(acpi_device_bid(device),
				vid_dev->video->dir);
	if (!device_dir)
		return -ENOMEM;

	device_dir->owner = THIS_MODULE;
L
Linus Torvalds 已提交
1101 1102

	/* 'info' [R] */
1103
	entry = proc_create_data("info", S_IRUGO, device_dir,
1104
			&acpi_video_device_info_fops, acpi_driver_data(device));
L
Linus Torvalds 已提交
1105
	if (!entry)
1106
		goto err_remove_dir;
L
Linus Torvalds 已提交
1107 1108

	/* 'state' [R/W] */
1109 1110
	acpi_video_device_state_fops.write = acpi_video_device_write_state;
	entry = proc_create_data("state", S_IFREG | S_IRUGO | S_IWUSR,
1111
				 device_dir,
1112 1113
				 &acpi_video_device_state_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
1114
	if (!entry)
1115
		goto err_remove_info;
L
Linus Torvalds 已提交
1116 1117

	/* 'brightness' [R/W] */
1118 1119 1120
	acpi_video_device_brightness_fops.write =
		acpi_video_device_write_brightness;
	entry = proc_create_data("brightness", S_IFREG | S_IRUGO | S_IWUSR,
1121
				 device_dir,
1122 1123
				 &acpi_video_device_brightness_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
1124
	if (!entry)
1125
		goto err_remove_state;
L
Linus Torvalds 已提交
1126 1127

	/* 'EDID' [R] */
1128
	entry = proc_create_data("EDID", S_IRUGO, device_dir,
1129 1130
				 &acpi_video_device_EDID_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
1131
	if (!entry)
1132
		goto err_remove_brightness;
L
Linus Torvalds 已提交
1133

1134 1135
	acpi_device_dir(device) = device_dir;

1136
	return 0;
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146

 err_remove_brightness:
	remove_proc_entry("brightness", device_dir);
 err_remove_state:
	remove_proc_entry("state", device_dir);
 err_remove_info:
	remove_proc_entry("info", device_dir);
 err_remove_dir:
	remove_proc_entry(acpi_device_bid(device), vid_dev->video->dir);
	return -ENOMEM;
L
Linus Torvalds 已提交
1147 1148
}

L
Len Brown 已提交
1149
static int acpi_video_device_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
1150 1151
{
	struct acpi_video_device *vid_dev;
1152
	struct proc_dir_entry *device_dir;
L
Linus Torvalds 已提交
1153

1154
	vid_dev = acpi_driver_data(device);
L
Linus Torvalds 已提交
1155
	if (!vid_dev || !vid_dev->video || !vid_dev->video->dir)
1156
		return -ENODEV;
L
Linus Torvalds 已提交
1157

1158 1159 1160 1161 1162 1163
	device_dir = acpi_device_dir(device);
	if (device_dir) {
		remove_proc_entry("info", device_dir);
		remove_proc_entry("state", device_dir);
		remove_proc_entry("brightness", device_dir);
		remove_proc_entry("EDID", device_dir);
L
Len Brown 已提交
1164
		remove_proc_entry(acpi_device_bid(device), vid_dev->video->dir);
L
Linus Torvalds 已提交
1165 1166 1167
		acpi_device_dir(device) = NULL;
	}

1168
	return 0;
L
Linus Torvalds 已提交
1169 1170 1171
}

/* video bus */
L
Len Brown 已提交
1172
static int acpi_video_bus_info_seq_show(struct seq_file *seq, void *offset)
L
Linus Torvalds 已提交
1173
{
1174
	struct acpi_video_bus *video = seq->private;
L
Linus Torvalds 已提交
1175 1176 1177 1178 1179 1180


	if (!video)
		goto end;

	seq_printf(seq, "Switching heads:              %s\n",
L
Len Brown 已提交
1181
		   video->flags.multihead ? "yes" : "no");
L
Linus Torvalds 已提交
1182
	seq_printf(seq, "Video ROM:                    %s\n",
L
Len Brown 已提交
1183
		   video->flags.rom ? "yes" : "no");
L
Linus Torvalds 已提交
1184
	seq_printf(seq, "Device to be POSTed on boot:  %s\n",
L
Len Brown 已提交
1185
		   video->flags.post ? "yes" : "no");
L
Linus Torvalds 已提交
1186

L
Len Brown 已提交
1187
      end:
1188
	return 0;
L
Linus Torvalds 已提交
1189 1190
}

L
Len Brown 已提交
1191
static int acpi_video_bus_info_open_fs(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
1192
{
L
Len Brown 已提交
1193 1194
	return single_open(file, acpi_video_bus_info_seq_show,
			   PDE(inode)->data);
L
Linus Torvalds 已提交
1195 1196
}

L
Len Brown 已提交
1197
static int acpi_video_bus_ROM_seq_show(struct seq_file *seq, void *offset)
L
Linus Torvalds 已提交
1198
{
1199
	struct acpi_video_bus *video = seq->private;
L
Linus Torvalds 已提交
1200 1201 1202 1203 1204


	if (!video)
		goto end;

1205
	printk(KERN_INFO PREFIX "Please implement %s\n", __func__);
L
Linus Torvalds 已提交
1206 1207
	seq_printf(seq, "<TODO>\n");

L
Len Brown 已提交
1208
      end:
1209
	return 0;
L
Linus Torvalds 已提交
1210 1211
}

L
Len Brown 已提交
1212
static int acpi_video_bus_ROM_open_fs(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
1213 1214 1215 1216
{
	return single_open(file, acpi_video_bus_ROM_seq_show, PDE(inode)->data);
}

L
Len Brown 已提交
1217
static int acpi_video_bus_POST_info_seq_show(struct seq_file *seq, void *offset)
L
Linus Torvalds 已提交
1218
{
1219
	struct acpi_video_bus *video = seq->private;
1220
	unsigned long long options;
L
Len Brown 已提交
1221
	int status;
L
Linus Torvalds 已提交
1222 1223 1224 1225 1226 1227 1228 1229


	if (!video)
		goto end;

	status = acpi_video_bus_POST_options(video, &options);
	if (ACPI_SUCCESS(status)) {
		if (!(options & 1)) {
L
Len Brown 已提交
1230 1231 1232
			printk(KERN_WARNING PREFIX
			       "The motherboard VGA device is not listed as a possible POST device.\n");
			printk(KERN_WARNING PREFIX
1233
			       "This indicates a BIOS bug. Please contact the manufacturer.\n");
L
Linus Torvalds 已提交
1234
		}
1235
		printk("%llx\n", options);
1236
		seq_printf(seq, "can POST: <integrated video>");
L
Linus Torvalds 已提交
1237 1238 1239 1240 1241 1242 1243
		if (options & 2)
			seq_printf(seq, " <PCI video>");
		if (options & 4)
			seq_printf(seq, " <AGP video>");
		seq_putc(seq, '\n');
	} else
		seq_printf(seq, "<not supported>\n");
L
Len Brown 已提交
1244
      end:
1245
	return 0;
L
Linus Torvalds 已提交
1246 1247 1248
}

static int
L
Len Brown 已提交
1249
acpi_video_bus_POST_info_open_fs(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
1250
{
L
Len Brown 已提交
1251 1252
	return single_open(file, acpi_video_bus_POST_info_seq_show,
			   PDE(inode)->data);
L
Linus Torvalds 已提交
1253 1254
}

L
Len Brown 已提交
1255
static int acpi_video_bus_POST_seq_show(struct seq_file *seq, void *offset)
L
Linus Torvalds 已提交
1256
{
1257
	struct acpi_video_bus *video = seq->private;
L
Len Brown 已提交
1258
	int status;
1259
	unsigned long long id;
L
Linus Torvalds 已提交
1260 1261 1262 1263 1264


	if (!video)
		goto end;

L
Len Brown 已提交
1265
	status = acpi_video_bus_get_POST(video, &id);
L
Linus Torvalds 已提交
1266 1267 1268 1269
	if (!ACPI_SUCCESS(status)) {
		seq_printf(seq, "<not supported>\n");
		goto end;
	}
1270
	seq_printf(seq, "device POSTed is <%s>\n", device_decode[id & 3]);
L
Linus Torvalds 已提交
1271

L
Len Brown 已提交
1272
      end:
1273
	return 0;
L
Linus Torvalds 已提交
1274 1275
}

L
Len Brown 已提交
1276
static int acpi_video_bus_DOS_seq_show(struct seq_file *seq, void *offset)
L
Linus Torvalds 已提交
1277
{
1278
	struct acpi_video_bus *video = seq->private;
L
Linus Torvalds 已提交
1279 1280


L
Len Brown 已提交
1281
	seq_printf(seq, "DOS setting: <%d>\n", video->dos_setting);
L
Linus Torvalds 已提交
1282

1283
	return 0;
L
Linus Torvalds 已提交
1284 1285
}

L
Len Brown 已提交
1286
static int acpi_video_bus_POST_open_fs(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
1287
{
L
Len Brown 已提交
1288 1289
	return single_open(file, acpi_video_bus_POST_seq_show,
			   PDE(inode)->data);
L
Linus Torvalds 已提交
1290 1291
}

L
Len Brown 已提交
1292
static int acpi_video_bus_DOS_open_fs(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
1293 1294 1295 1296 1297
{
	return single_open(file, acpi_video_bus_DOS_seq_show, PDE(inode)->data);
}

static ssize_t
L
Len Brown 已提交
1298 1299 1300
acpi_video_bus_write_POST(struct file *file,
			  const char __user * buffer,
			  size_t count, loff_t * data)
L
Linus Torvalds 已提交
1301
{
L
Len Brown 已提交
1302
	int status;
1303 1304
	struct seq_file *m = file->private_data;
	struct acpi_video_bus *video = m->private;
L
Len Brown 已提交
1305
	char str[12] = { 0 };
1306
	unsigned long long opt, options;
L
Linus Torvalds 已提交
1307 1308 1309


	if (!video || count + 1 > sizeof str)
1310
		return -EINVAL;
L
Linus Torvalds 已提交
1311 1312 1313

	status = acpi_video_bus_POST_options(video, &options);
	if (!ACPI_SUCCESS(status))
1314
		return -EINVAL;
L
Linus Torvalds 已提交
1315 1316

	if (copy_from_user(str, buffer, count))
1317
		return -EFAULT;
L
Linus Torvalds 已提交
1318 1319 1320 1321

	str[count] = 0;
	opt = strtoul(str, NULL, 0);
	if (opt > 3)
1322
		return -EFAULT;
L
Linus Torvalds 已提交
1323

1324
	/* just in case an OEM 'forgot' the motherboard... */
L
Linus Torvalds 已提交
1325 1326 1327
	options |= 1;

	if (options & (1ul << opt)) {
L
Len Brown 已提交
1328
		status = acpi_video_bus_set_POST(video, opt);
L
Linus Torvalds 已提交
1329
		if (!ACPI_SUCCESS(status))
1330
			return -EFAULT;
L
Linus Torvalds 已提交
1331 1332 1333

	}

1334
	return count;
L
Linus Torvalds 已提交
1335 1336 1337
}

static ssize_t
L
Len Brown 已提交
1338 1339 1340
acpi_video_bus_write_DOS(struct file *file,
			 const char __user * buffer,
			 size_t count, loff_t * data)
L
Linus Torvalds 已提交
1341
{
L
Len Brown 已提交
1342
	int status;
1343 1344
	struct seq_file *m = file->private_data;
	struct acpi_video_bus *video = m->private;
L
Len Brown 已提交
1345 1346
	char str[12] = { 0 };
	unsigned long opt;
L
Linus Torvalds 已提交
1347 1348 1349


	if (!video || count + 1 > sizeof str)
1350
		return -EINVAL;
L
Linus Torvalds 已提交
1351 1352

	if (copy_from_user(str, buffer, count))
1353
		return -EFAULT;
L
Linus Torvalds 已提交
1354 1355 1356 1357

	str[count] = 0;
	opt = strtoul(str, NULL, 0);
	if (opt > 7)
1358
		return -EFAULT;
L
Linus Torvalds 已提交
1359

L
Len Brown 已提交
1360
	status = acpi_video_bus_DOS(video, opt & 0x3, (opt & 0x4) >> 2);
L
Linus Torvalds 已提交
1361 1362

	if (!ACPI_SUCCESS(status))
1363
		return -EFAULT;
L
Linus Torvalds 已提交
1364

1365
	return count;
L
Linus Torvalds 已提交
1366 1367
}

L
Len Brown 已提交
1368
static int acpi_video_bus_add_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
1369
{
1370 1371 1372
	struct acpi_video_bus *video = acpi_driver_data(device);
	struct proc_dir_entry *device_dir;
	struct proc_dir_entry *entry;
L
Linus Torvalds 已提交
1373

1374 1375 1376
	device_dir = proc_mkdir(acpi_device_bid(device), acpi_video_dir);
	if (!device_dir)
		return -ENOMEM;
L
Linus Torvalds 已提交
1377

1378
	device_dir->owner = THIS_MODULE;
L
Linus Torvalds 已提交
1379 1380

	/* 'info' [R] */
1381
	entry = proc_create_data("info", S_IRUGO, device_dir,
1382 1383
				 &acpi_video_bus_info_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
1384
	if (!entry)
1385
		goto err_remove_dir;
L
Linus Torvalds 已提交
1386 1387

	/* 'ROM' [R] */
1388
	entry = proc_create_data("ROM", S_IRUGO, device_dir,
1389 1390
				 &acpi_video_bus_ROM_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
1391
	if (!entry)
1392
		goto err_remove_info;
L
Linus Torvalds 已提交
1393 1394

	/* 'POST_info' [R] */
1395
	entry = proc_create_data("POST_info", S_IRUGO, device_dir,
1396 1397
				 &acpi_video_bus_POST_info_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
1398
	if (!entry)
1399
		goto err_remove_rom;
L
Linus Torvalds 已提交
1400 1401

	/* 'POST' [R/W] */
1402
	acpi_video_bus_POST_fops.write = acpi_video_bus_write_POST;
1403
	entry = proc_create_data("POST", S_IFREG | S_IRUGO | S_IWUSR,
1404
				 device_dir,
1405 1406
				 &acpi_video_bus_POST_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
1407
	if (!entry)
1408
		goto err_remove_post_info;
L
Linus Torvalds 已提交
1409 1410

	/* 'DOS' [R/W] */
1411
	acpi_video_bus_DOS_fops.write = acpi_video_bus_write_DOS;
1412
	entry = proc_create_data("DOS", S_IFREG | S_IRUGO | S_IWUSR,
1413
				 device_dir,
1414 1415
				 &acpi_video_bus_DOS_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
1416
	if (!entry)
1417
		goto err_remove_post;
L
Linus Torvalds 已提交
1418

1419
	video->dir = acpi_device_dir(device) = device_dir;
1420
	return 0;
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432

 err_remove_post:
	remove_proc_entry("POST", device_dir);
 err_remove_post_info:
	remove_proc_entry("POST_info", device_dir);
 err_remove_rom:
	remove_proc_entry("ROM", device_dir);
 err_remove_info:
	remove_proc_entry("info", device_dir);
 err_remove_dir:
	remove_proc_entry(acpi_device_bid(device), acpi_video_dir);
	return -ENOMEM;
L
Linus Torvalds 已提交
1433 1434
}

L
Len Brown 已提交
1435
static int acpi_video_bus_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
1436
{
1437 1438 1439 1440 1441 1442 1443 1444
	struct proc_dir_entry *device_dir = acpi_device_dir(device);

	if (device_dir) {
		remove_proc_entry("info", device_dir);
		remove_proc_entry("ROM", device_dir);
		remove_proc_entry("POST_info", device_dir);
		remove_proc_entry("POST", device_dir);
		remove_proc_entry("DOS", device_dir);
L
Len Brown 已提交
1445
		remove_proc_entry(acpi_device_bid(device), acpi_video_dir);
L
Linus Torvalds 已提交
1446 1447 1448
		acpi_device_dir(device) = NULL;
	}

1449
	return 0;
L
Linus Torvalds 已提交
1450 1451 1452 1453 1454 1455 1456
}

/* --------------------------------------------------------------------------
                                 Driver Interface
   -------------------------------------------------------------------------- */

/* device interface */
1457 1458 1459
static struct acpi_video_device_attrib*
acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id)
{
1460 1461 1462 1463 1464 1465 1466 1467
	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;
	}
1468 1469 1470

	return NULL;
}
L
Linus Torvalds 已提交
1471 1472

static int
L
Len Brown 已提交
1473 1474
acpi_video_bus_get_one_device(struct acpi_device *device,
			      struct acpi_video_bus *video)
L
Linus Torvalds 已提交
1475
{
1476
	unsigned long long device_id;
1477
	int status;
L
Len Brown 已提交
1478
	struct acpi_video_device *data;
1479
	struct acpi_video_device_attrib* attribute;
L
Linus Torvalds 已提交
1480 1481

	if (!device || !video)
1482
		return -EINVAL;
L
Linus Torvalds 已提交
1483

L
Len Brown 已提交
1484 1485
	status =
	    acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
L
Linus Torvalds 已提交
1486 1487
	if (ACPI_SUCCESS(status)) {

1488
		data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
L
Linus Torvalds 已提交
1489
		if (!data)
1490
			return -ENOMEM;
L
Linus Torvalds 已提交
1491 1492 1493 1494 1495 1496 1497 1498 1499

		strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
		strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
		acpi_driver_data(device) = data;

		data->device_id = device_id;
		data->video = video;
		data->dev = device;

1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522
		attribute = acpi_video_get_device_attr(video, device_id);

		if((attribute != NULL) && attribute->device_id_scheme) {
			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;
			}
			if(attribute->bios_can_detect)
				data->flags.bios = 1;
		} else
L
Linus Torvalds 已提交
1523
			data->flags.unknown = 1;
L
Len Brown 已提交
1524

L
Linus Torvalds 已提交
1525 1526 1527
		acpi_video_device_bind(video, data);
		acpi_video_device_find_cap(data);

1528
		status = acpi_install_notify_handler(device->handle,
L
Len Brown 已提交
1529 1530 1531
						     ACPI_DEVICE_NOTIFY,
						     acpi_video_device_notify,
						     data);
L
Linus Torvalds 已提交
1532 1533
		if (ACPI_FAILURE(status)) {
			ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
L
Len Brown 已提交
1534
					  "Error installing notify handler\n"));
1535 1536 1537 1538 1539
			if(data->brightness)
				kfree(data->brightness->levels);
			kfree(data->brightness);
			kfree(data);
			return -ENODEV;
L
Linus Torvalds 已提交
1540 1541
		}

1542
		mutex_lock(&video->device_list_lock);
L
Linus Torvalds 已提交
1543
		list_add_tail(&data->entry, &video->video_device_list);
1544
		mutex_unlock(&video->device_list_lock);
L
Linus Torvalds 已提交
1545 1546 1547

		acpi_video_device_add_fs(device);

1548
		return 0;
L
Linus Torvalds 已提交
1549 1550
	}

1551
	return -ENOENT;
L
Linus Torvalds 已提交
1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
}

/*
 *  Arg:
 *  	video	: video bus device 
 *
 *  Return:
 *  	none
 *  
 *  Enumerate the video device list of the video bus, 
 *  bind the ids with the corresponding video devices
 *  under the video bus.
L
Len Brown 已提交
1564
 */
L
Linus Torvalds 已提交
1565

L
Len Brown 已提交
1566
static void acpi_video_device_rebind(struct acpi_video_bus *video)
L
Linus Torvalds 已提交
1567
{
1568 1569
	struct acpi_video_device *dev;

1570
	mutex_lock(&video->device_list_lock);
1571 1572

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

1575
	mutex_unlock(&video->device_list_lock);
L
Linus Torvalds 已提交
1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588
}

/*
 *  Arg:
 *  	video	: video bus device 
 *  	device	: video output device under the video 
 *  		bus
 *
 *  Return:
 *  	none
 *  
 *  Bind the ids with the corresponding video devices
 *  under the video bus.
L
Len Brown 已提交
1589
 */
L
Linus Torvalds 已提交
1590 1591

static void
L
Len Brown 已提交
1592 1593
acpi_video_device_bind(struct acpi_video_bus *video,
		       struct acpi_video_device *device)
L
Linus Torvalds 已提交
1594
{
1595
	struct acpi_video_enumerated_device *ids;
L
Len Brown 已提交
1596
	int i;
L
Linus Torvalds 已提交
1597

1598 1599 1600 1601
	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 已提交
1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
			ACPI_DEBUG_PRINT((ACPI_DB_INFO, "device_bind %d\n", i));
		}
	}
}

/*
 *  Arg:
 *  	video	: video bus device 
 *
 *  Return:
 *  	< 0	: error
 *  
 *  Call _DOD to enumerate all devices attached to display adapter
 *
L
Len Brown 已提交
1616
 */
L
Linus Torvalds 已提交
1617 1618 1619

static int acpi_video_device_enumerate(struct acpi_video_bus *video)
{
L
Len Brown 已提交
1620 1621 1622
	int status;
	int count;
	int i;
1623
	struct acpi_video_enumerated_device *active_list;
L
Len Brown 已提交
1624 1625 1626
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *dod = NULL;
	union acpi_object *obj;
L
Linus Torvalds 已提交
1627

1628
	status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
L
Linus Torvalds 已提交
1629
	if (!ACPI_SUCCESS(status)) {
1630
		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD"));
1631
		return status;
L
Linus Torvalds 已提交
1632 1633
	}

1634
	dod = buffer.pointer;
L
Linus Torvalds 已提交
1635
	if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
1636
		ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data"));
L
Linus Torvalds 已提交
1637 1638 1639 1640 1641
		status = -EFAULT;
		goto out;
	}

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

1644 1645 1646 1647
	active_list = kcalloc(1 + dod->package.count,
			      sizeof(struct acpi_video_enumerated_device),
			      GFP_KERNEL);
	if (!active_list) {
L
Linus Torvalds 已提交
1648 1649 1650 1651 1652 1653
		status = -ENOMEM;
		goto out;
	}

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

		if (obj->type != ACPI_TYPE_INTEGER) {
1657 1658 1659
			printk(KERN_ERR PREFIX
				"Invalid _DOD data in element %d\n", i);
			continue;
L
Linus Torvalds 已提交
1660
		}
1661 1662 1663

		active_list[count].value.int_val = obj->integer.value;
		active_list[count].bind_info = NULL;
L
Len Brown 已提交
1664 1665
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "dod element[%d] = %d\n", i,
				  (int)obj->integer.value));
L
Linus Torvalds 已提交
1666 1667 1668
		count++;
	}

1669
	kfree(video->attached_array);
L
Len Brown 已提交
1670

1671
	video->attached_array = active_list;
L
Linus Torvalds 已提交
1672
	video->attached_count = count;
1673 1674

 out:
1675
	kfree(buffer.pointer);
1676
	return status;
L
Linus Torvalds 已提交
1677 1678
}

L
Len Brown 已提交
1679 1680 1681
static int
acpi_video_get_next_level(struct acpi_video_device *device,
			  u32 level_current, u32 event)
L
Linus Torvalds 已提交
1682
{
1683
	int min, max, min_above, max_below, i, l, delta = 255;
1684 1685
	max = max_below = 0;
	min = min_above = 255;
1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696
	/* Find closest level to level_current */
	for (i = 0; i < device->brightness->count; i++) {
		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;
1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721
	for (i = 0; i < device->brightness->count; i++) {
		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 已提交
1722 1723 1724
}

static void
L
Len Brown 已提交
1725
acpi_video_switch_brightness(struct acpi_video_device *device, int event)
L
Linus Torvalds 已提交
1726
{
1727
	unsigned long long level_current, level_next;
1728 1729
	if (!device->brightness)
		return;
L
Linus Torvalds 已提交
1730 1731 1732 1733 1734 1735
	acpi_video_device_lcd_get_level_current(device, &level_current);
	level_next = acpi_video_get_next_level(device, level_current, event);
	acpi_video_device_lcd_set_level(device, level_next);
}

static int
L
Len Brown 已提交
1736 1737
acpi_video_bus_get_devices(struct acpi_video_bus *video,
			   struct acpi_device *device)
L
Linus Torvalds 已提交
1738
{
L
Len Brown 已提交
1739
	int status = 0;
1740
	struct acpi_device *dev;
L
Linus Torvalds 已提交
1741 1742 1743

	acpi_video_device_enumerate(video);

1744
	list_for_each_entry(dev, &device->children, node) {
L
Linus Torvalds 已提交
1745 1746 1747

		status = acpi_video_bus_get_one_device(dev, video);
		if (ACPI_FAILURE(status)) {
1748 1749
			ACPI_DEBUG_PRINT((ACPI_DB_WARN,
					"Cant attach device"));
L
Linus Torvalds 已提交
1750 1751 1752
			continue;
		}
	}
1753
	return status;
L
Linus Torvalds 已提交
1754 1755
}

L
Len Brown 已提交
1756
static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
L
Linus Torvalds 已提交
1757
{
1758
	acpi_status status;
L
Linus Torvalds 已提交
1759 1760 1761 1762
	struct acpi_video_bus *video;


	if (!device || !device->video)
1763
		return -ENOENT;
L
Linus Torvalds 已提交
1764 1765 1766 1767 1768

	video = device->video;

	acpi_video_device_remove_fs(device->dev);

1769
	status = acpi_remove_notify_handler(device->dev->handle,
L
Len Brown 已提交
1770 1771
					    ACPI_DEVICE_NOTIFY,
					    acpi_video_device_notify);
1772
	backlight_device_unregister(device->backlight);
1773 1774 1775 1776 1777 1778 1779 1780
	if (device->cdev) {
		sysfs_remove_link(&device->dev->dev.kobj,
				  "thermal_cooling");
		sysfs_remove_link(&device->cdev->device.kobj,
				  "device");
		thermal_cooling_device_unregister(device->cdev);
		device->cdev = NULL;
	}
1781
	video_output_unregister(device->output_dev);
1782

1783
	return 0;
L
Linus Torvalds 已提交
1784 1785
}

L
Len Brown 已提交
1786
static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
L
Linus Torvalds 已提交
1787
{
L
Len Brown 已提交
1788
	int status;
1789
	struct acpi_video_device *dev, *next;
L
Linus Torvalds 已提交
1790

1791
	mutex_lock(&video->device_list_lock);
L
Linus Torvalds 已提交
1792

1793
	list_for_each_entry_safe(dev, next, &video->video_device_list, entry) {
L
Linus Torvalds 已提交
1794

1795
		status = acpi_video_bus_put_one_device(dev);
L
Len Brown 已提交
1796 1797 1798
		if (ACPI_FAILURE(status))
			printk(KERN_WARNING PREFIX
			       "hhuuhhuu bug in acpi video driver.\n");
L
Linus Torvalds 已提交
1799

1800 1801 1802 1803 1804 1805
		if (dev->brightness) {
			kfree(dev->brightness->levels);
			kfree(dev->brightness);
		}
		list_del(&dev->entry);
		kfree(dev);
L
Linus Torvalds 已提交
1806 1807
	}

1808
	mutex_unlock(&video->device_list_lock);
1809

1810
	return 0;
L
Linus Torvalds 已提交
1811 1812 1813 1814
}

/* acpi_video interface */

L
Len Brown 已提交
1815
static int acpi_video_bus_start_devices(struct acpi_video_bus *video)
L
Linus Torvalds 已提交
1816
{
1817
	return acpi_video_bus_DOS(video, 0, 0);
L
Linus Torvalds 已提交
1818 1819
}

L
Len Brown 已提交
1820
static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
L
Linus Torvalds 已提交
1821 1822 1823 1824
{
	return acpi_video_bus_DOS(video, 0, 1);
}

L
Len Brown 已提交
1825
static void acpi_video_bus_notify(acpi_handle handle, u32 event, void *data)
L
Linus Torvalds 已提交
1826
{
1827
	struct acpi_video_bus *video = data;
L
Len Brown 已提交
1828
	struct acpi_device *device = NULL;
1829 1830 1831
	struct input_dev *input;
	int keycode;

L
Linus Torvalds 已提交
1832
	if (!video)
1833
		return;
L
Linus Torvalds 已提交
1834

1835
	device = video->device;
1836
	input = video->input;
L
Linus Torvalds 已提交
1837 1838

	switch (event) {
1839
	case ACPI_VIDEO_NOTIFY_SWITCH:	/* User requested a switch,
L
Linus Torvalds 已提交
1840
					 * most likely via hotkey. */
1841
		acpi_bus_generate_proc_event(device, event, 0);
1842
		keycode = KEY_SWITCHVIDEOMODE;
L
Linus Torvalds 已提交
1843 1844
		break;

1845
	case ACPI_VIDEO_NOTIFY_PROBE:	/* User plugged in or removed a video
L
Linus Torvalds 已提交
1846 1847 1848
					 * connector. */
		acpi_video_device_enumerate(video);
		acpi_video_device_rebind(video);
1849
		acpi_bus_generate_proc_event(device, event, 0);
1850
		keycode = KEY_SWITCHVIDEOMODE;
L
Linus Torvalds 已提交
1851 1852
		break;

L
Len Brown 已提交
1853
	case ACPI_VIDEO_NOTIFY_CYCLE:	/* Cycle Display output hotkey pressed. */
L
Len Brown 已提交
1854
		acpi_bus_generate_proc_event(device, event, 0);
1855 1856
		keycode = KEY_SWITCHVIDEOMODE;
		break;
L
Len Brown 已提交
1857
	case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT:	/* Next Display output hotkey pressed. */
L
Len Brown 已提交
1858
		acpi_bus_generate_proc_event(device, event, 0);
1859 1860
		keycode = KEY_VIDEO_NEXT;
		break;
L
Len Brown 已提交
1861
	case ACPI_VIDEO_NOTIFY_PREV_OUTPUT:	/* previous Display output hotkey pressed. */
1862
		acpi_bus_generate_proc_event(device, event, 0);
1863
		keycode = KEY_VIDEO_PREV;
L
Linus Torvalds 已提交
1864 1865 1866
		break;

	default:
1867
		keycode = KEY_UNKNOWN;
L
Linus Torvalds 已提交
1868
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
1869
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
1870 1871 1872
		break;
	}

1873
	acpi_notifier_call_chain(device, event, 0);
1874 1875 1876 1877 1878
	input_report_key(input, keycode, 1);
	input_sync(input);
	input_report_key(input, keycode, 0);
	input_sync(input);

1879
	return;
L
Linus Torvalds 已提交
1880 1881
}

L
Len Brown 已提交
1882
static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
L
Linus Torvalds 已提交
1883
{
1884
	struct acpi_video_device *video_device = data;
L
Len Brown 已提交
1885
	struct acpi_device *device = NULL;
1886 1887 1888
	struct acpi_video_bus *bus;
	struct input_dev *input;
	int keycode;
L
Linus Torvalds 已提交
1889 1890

	if (!video_device)
1891
		return;
L
Linus Torvalds 已提交
1892

1893
	device = video_device->dev;
1894 1895
	bus = video_device->video;
	input = bus->input;
L
Linus Torvalds 已提交
1896 1897

	switch (event) {
L
Len Brown 已提交
1898
	case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:	/* Cycle brightness */
1899 1900
		if (brightness_switch_enabled)
			acpi_video_switch_brightness(video_device, event);
1901
		acpi_bus_generate_proc_event(device, event, 0);
1902 1903
		keycode = KEY_BRIGHTNESS_CYCLE;
		break;
L
Len Brown 已提交
1904
	case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:	/* Increase brightness */
1905 1906
		if (brightness_switch_enabled)
			acpi_video_switch_brightness(video_device, event);
L
Len Brown 已提交
1907
		acpi_bus_generate_proc_event(device, event, 0);
1908 1909
		keycode = KEY_BRIGHTNESSUP;
		break;
L
Len Brown 已提交
1910
	case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:	/* Decrease brightness */
1911 1912
		if (brightness_switch_enabled)
			acpi_video_switch_brightness(video_device, event);
L
Len Brown 已提交
1913
		acpi_bus_generate_proc_event(device, event, 0);
1914 1915
		keycode = KEY_BRIGHTNESSDOWN;
		break;
L
Len Brown 已提交
1916
	case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:	/* zero brightnesss */
1917 1918
		if (brightness_switch_enabled)
			acpi_video_switch_brightness(video_device, event);
L
Len Brown 已提交
1919
		acpi_bus_generate_proc_event(device, event, 0);
1920 1921
		keycode = KEY_BRIGHTNESS_ZERO;
		break;
L
Len Brown 已提交
1922
	case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:	/* display device off */
1923 1924
		if (brightness_switch_enabled)
			acpi_video_switch_brightness(video_device, event);
1925
		acpi_bus_generate_proc_event(device, event, 0);
1926
		keycode = KEY_DISPLAY_OFF;
L
Linus Torvalds 已提交
1927 1928
		break;
	default:
1929
		keycode = KEY_UNKNOWN;
L
Linus Torvalds 已提交
1930
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
1931
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
1932 1933
		break;
	}
1934

1935
	acpi_notifier_call_chain(device, event, 0);
1936 1937 1938 1939 1940
	input_report_key(input, keycode, 1);
	input_sync(input);
	input_report_key(input, keycode, 0);
	input_sync(input);

1941
	return;
L
Linus Torvalds 已提交
1942 1943
}

1944
static int instance;
1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963
static int acpi_video_resume(struct acpi_device *device)
{
	struct acpi_video_bus *video;
	struct acpi_video_device *video_device;
	int i;

	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;
		if (video_device && video_device->backlight)
			acpi_video_set_brightness(video_device->backlight);
	}
	return AE_OK;
}

L
Len Brown 已提交
1964
static int acpi_video_bus_add(struct acpi_device *device)
L
Linus Torvalds 已提交
1965
{
1966 1967
	acpi_status status;
	struct acpi_video_bus *video;
1968
	struct input_dev *input;
1969
	int error;
L
Linus Torvalds 已提交
1970

1971
	video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
L
Linus Torvalds 已提交
1972
	if (!video)
1973
		return -ENOMEM;
L
Linus Torvalds 已提交
1974

1975 1976 1977 1978 1979 1980 1981
	/* 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;
		instance ++;
	}

1982
	video->device = device;
L
Linus Torvalds 已提交
1983 1984 1985 1986 1987
	strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
	strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
	acpi_driver_data(device) = video;

	acpi_video_bus_find_cap(video);
1988 1989 1990
	error = acpi_video_bus_check(video);
	if (error)
		goto err_free_video;
L
Linus Torvalds 已提交
1991

1992 1993 1994
	error = acpi_video_bus_add_fs(device);
	if (error)
		goto err_free_video;
L
Linus Torvalds 已提交
1995

1996
	mutex_init(&video->device_list_lock);
L
Linus Torvalds 已提交
1997 1998 1999 2000 2001
	INIT_LIST_HEAD(&video->video_device_list);

	acpi_video_bus_get_devices(video, device);
	acpi_video_bus_start_devices(video);

2002
	status = acpi_install_notify_handler(device->handle,
L
Len Brown 已提交
2003 2004
					     ACPI_DEVICE_NOTIFY,
					     acpi_video_bus_notify, video);
L
Linus Torvalds 已提交
2005 2006
	if (ACPI_FAILURE(status)) {
		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
L
Len Brown 已提交
2007
				  "Error installing notify handler\n"));
2008 2009
		error = -ENODEV;
		goto err_stop_video;
L
Linus Torvalds 已提交
2010 2011
	}

2012
	video->input = input = input_allocate_device();
2013 2014 2015 2016
	if (!input) {
		error = -ENOMEM;
		goto err_uninstall_notify;
	}
2017 2018 2019 2020 2021 2022 2023 2024

	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;
2025
	input->dev.parent = &device->dev;
2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036
	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);
	set_bit(KEY_UNKNOWN, input->keybit);

2037 2038 2039
	error = input_register_device(input);
	if (error)
		goto err_free_input_dev;
2040

L
Linus Torvalds 已提交
2041
	printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s  rom: %s  post: %s)\n",
L
Len Brown 已提交
2042 2043 2044 2045
	       ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
	       video->flags.multihead ? "yes" : "no",
	       video->flags.rom ? "yes" : "no",
	       video->flags.post ? "yes" : "no");
L
Linus Torvalds 已提交
2046

2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061
	return 0;

 err_free_input_dev:
	input_free_device(input);
 err_uninstall_notify:
	acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
				   acpi_video_bus_notify);
 err_stop_video:
	acpi_video_bus_stop_devices(video);
	acpi_video_bus_put_devices(video);
	kfree(video->attached_array);
	acpi_video_bus_remove_fs(device);
 err_free_video:
	kfree(video);
	acpi_driver_data(device) = NULL;
L
Linus Torvalds 已提交
2062

2063
	return error;
L
Linus Torvalds 已提交
2064 2065
}

L
Len Brown 已提交
2066
static int acpi_video_bus_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
2067
{
L
Len Brown 已提交
2068 2069
	acpi_status status = 0;
	struct acpi_video_bus *video = NULL;
L
Linus Torvalds 已提交
2070 2071 2072


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

2075
	video = acpi_driver_data(device);
L
Linus Torvalds 已提交
2076 2077 2078

	acpi_video_bus_stop_devices(video);

2079
	status = acpi_remove_notify_handler(video->device->handle,
L
Len Brown 已提交
2080 2081
					    ACPI_DEVICE_NOTIFY,
					    acpi_video_bus_notify);
L
Linus Torvalds 已提交
2082 2083 2084 2085

	acpi_video_bus_put_devices(video);
	acpi_video_bus_remove_fs(device);

2086
	input_unregister_device(video->input);
2087
	kfree(video->attached_array);
L
Linus Torvalds 已提交
2088 2089
	kfree(video);

2090
	return 0;
L
Linus Torvalds 已提交
2091 2092
}

L
Len Brown 已提交
2093
static int __init acpi_video_init(void)
L
Linus Torvalds 已提交
2094
{
L
Len Brown 已提交
2095
	int result = 0;
L
Linus Torvalds 已提交
2096 2097 2098


	/*
L
Len Brown 已提交
2099 2100 2101
	   acpi_dbg_level = 0xFFFFFFFF;
	   acpi_dbg_layer = 0x08000000;
	 */
L
Linus Torvalds 已提交
2102 2103 2104

	acpi_video_dir = proc_mkdir(ACPI_VIDEO_CLASS, acpi_root_dir);
	if (!acpi_video_dir)
2105
		return -ENODEV;
L
Linus Torvalds 已提交
2106 2107 2108 2109 2110
	acpi_video_dir->owner = THIS_MODULE;

	result = acpi_bus_register_driver(&acpi_video_bus);
	if (result < 0) {
		remove_proc_entry(ACPI_VIDEO_CLASS, acpi_root_dir);
2111
		return -ENODEV;
L
Linus Torvalds 已提交
2112 2113
	}

2114
	return 0;
L
Linus Torvalds 已提交
2115 2116
}

L
Len Brown 已提交
2117
static void __exit acpi_video_exit(void)
L
Linus Torvalds 已提交
2118 2119 2120 2121 2122 2123
{

	acpi_bus_unregister_driver(&acpi_video_bus);

	remove_proc_entry(ACPI_VIDEO_CLASS, acpi_root_dir);

2124
	return;
L
Linus Torvalds 已提交
2125 2126 2127 2128
}

module_init(acpi_video_init);
module_exit(acpi_video_exit);