thinkpad_acpi.c 112.4 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 *  thinkpad_acpi.c - ThinkPad ACPI Extras
L
Linus Torvalds 已提交
3 4
 *
 *
5
 *  Copyright (C) 2004-2005 Borislav Deianov <borislav@users.sf.net>
6
 *  Copyright (C) 2006-2007 Henrique de Moraes Holschuh <hmh@hmh.eng.br>
L
Linus Torvalds 已提交
7 8 9 10 11 12 13 14 15 16 17 18 19
 *
 *  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
20 21
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 *  02110-1301, USA.
22 23
 */

24
#define IBM_VERSION "0.15"
25
#define TPACPI_SYSFS_VERSION 0x010000
26 27

/*
L
Linus Torvalds 已提交
28
 *  Changelog:
29 30
 *  2007-03-27  0.14	renamed to thinkpad_acpi and moved to
 *  			drivers/misc.
31 32 33 34
 *
 *  2006-11-22	0.13	new maintainer
 *  			changelog now lives in git commit history, and will
 *  			not be updated further in-file.
35
 *
36 37 38 39 40 41 42 43 44
 *  2005-08-17  0.12	fix compilation on 2.6.13-rc kernels
 *  2005-03-17	0.11	support for 600e, 770x
 *			    thanks to Jamie Lentin <lentinj@dial.pipex.com>
 *			support for 770e, G41
 *			G40 and G41 don't have a thinklight
 *			temperatures no longer experimental
 *			experimental brightness control
 *			experimental volume control
 *			experimental fan enable/disable
45
 *  2005-01-16	0.10	fix module loading on R30, R31
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
 *  2005-01-16	0.9	support for 570, R30, R31
 *			ultrabay support on A22p, A3x
 *			limit arg for cmos, led, beep, drop experimental status
 *			more capable led control on A21e, A22p, T20-22, X20
 *			experimental temperatures and fan speed
 *			experimental embedded controller register dump
 *			mark more functions as __init, drop incorrect __exit
 *			use MODULE_VERSION
 *			    thanks to Henrik Brix Andersen <brix@gentoo.org>
 *			fix parameter passing on module loading
 *			    thanks to Rusty Russell <rusty@rustcorp.com.au>
 *			    thanks to Jim Radford <radford@blackbean.org>
 *  2004-11-08	0.8	fix init error case, don't return from a macro
 *			    thanks to Chris Wright <chrisw@osdl.org>
 *  2004-10-23	0.7	fix module loading on A21e, A22p, T20, T21, X20
 *			fix led control on A21e
 *  2004-10-19	0.6	use acpi_bus_register_driver() to claim HKEY device
L
Linus Torvalds 已提交
63 64 65 66 67 68
 *  2004-10-18	0.5	thinklight support on A21e, G40, R32, T20, T21, X20
 *			proc file format changed
 *			video_switch command
 *			experimental cmos control
 *			experimental led control
 *			experimental acpi sounds
69 70 71 72 73 74 75 76 77 78 79 80 81 82
 *  2004-09-16	0.4	support for module parameters
 *			hotkey mask can be prefixed by 0x
 *			video output switching
 *			video expansion control
 *			ultrabay eject support
 *			removed lcd brightness/on/off control, didn't work
 *  2004-08-17	0.3	support for R40
 *			lcd off, brightness control
 *			thinklight on/off
 *  2004-08-14	0.2	support for T series, X20
 *			bluetooth enable/disable
 *			hotkey events disabled by default
 *			removed fan control, currently useless
 *  2004-08-09	0.1	initial release, support for X series
L
Linus Torvalds 已提交
83 84
 */

85
#include "thinkpad_acpi.h"
L
Linus Torvalds 已提交
86

87
MODULE_AUTHOR("Borislav Deianov, Henrique de Moraes Holschuh");
88 89 90 91
MODULE_DESCRIPTION(IBM_DESC);
MODULE_VERSION(IBM_VERSION);
MODULE_LICENSE("GPL");

92 93 94
/* Please remove this in year 2009 */
MODULE_ALIAS("ibm_acpi");

95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
/*
 * DMI matching for module autoloading
 *
 * See http://thinkwiki.org/wiki/List_of_DMI_IDs
 * See http://thinkwiki.org/wiki/BIOS_Upgrade_Downloads
 *
 * Only models listed in thinkwiki will be supported, so add yours
 * if it is not there yet.
 */
#define IBM_BIOS_MODULE_ALIAS(__type) \
	MODULE_ALIAS("dmi:bvnIBM:bvr" __type "ET??WW")

/* Non-ancient thinkpads */
MODULE_ALIAS("dmi:bvnIBM:*:svnIBM:*:pvrThinkPad*:rvnIBM:*");
MODULE_ALIAS("dmi:bvnLENOVO:*:svnLENOVO:*:pvrThinkPad*:rvnLENOVO:*");

/* Ancient thinkpad BIOSes have to be identified by
 * BIOS type or model number, and there are far less
 * BIOS types than model numbers... */
IBM_BIOS_MODULE_ALIAS("I[B,D,H,I,M,N,O,T,W,V,Y,Z]");
IBM_BIOS_MODULE_ALIAS("1[0,3,6,8,A-G,I,K,M-P,S,T]");
IBM_BIOS_MODULE_ALIAS("K[U,X-Z]");

L
Linus Torvalds 已提交
118 119
#define __unused __attribute__ ((unused))

120 121 122 123 124 125 126 127 128 129 130
/****************************************************************************
 ****************************************************************************
 *
 * ACPI Helpers and device model
 *
 ****************************************************************************
 ****************************************************************************/

/*************************************************************************
 * ACPI basic handles
 */
L
Linus Torvalds 已提交
131

132
static acpi_handle root_handle;
L
Linus Torvalds 已提交
133 134 135 136

#define IBM_HANDLE(object, parent, paths...)			\
	static acpi_handle  object##_handle;			\
	static acpi_handle *object##_parent = &parent##_handle;	\
137
	static char        *object##_path;			\
L
Linus Torvalds 已提交
138 139
	static char        *object##_paths[] = { paths }

140 141 142 143 144 145 146
IBM_HANDLE(ec, root, "\\_SB.PCI0.ISA.EC0",	/* 240, 240x */
	   "\\_SB.PCI.ISA.EC",	/* 570 */
	   "\\_SB.PCI0.ISA0.EC0",	/* 600e/x, 770e, 770x */
	   "\\_SB.PCI0.ISA.EC",	/* A21e, A2xm/p, T20-22, X20-21 */
	   "\\_SB.PCI0.AD4S.EC0",	/* i1400, R30 */
	   "\\_SB.PCI0.ICH3.EC0",	/* R31 */
	   "\\_SB.PCI0.LPC.EC",	/* all others */
147
	   );
148

149 150
IBM_HANDLE(ecrd, ec, "ECRD");	/* 570 */
IBM_HANDLE(ecwr, ec, "ECWR");	/* 570 */
151

152 153 154 155

/*************************************************************************
 * Misc ACPI handles
 */
156 157 158 159

IBM_HANDLE(cmos, root, "\\UCMS",	/* R50, R50e, R50p, R51, T4x, X31, X40 */
	   "\\CMOS",		/* A3x, G4x, R32, T23, T30, X22-24, X30 */
	   "\\CMS",		/* R40, R40e */
160
	   );			/* all others */
161 162 163 164

IBM_HANDLE(hkey, ec, "\\_SB.HKEY",	/* 600e/x, 770e, 770x */
	   "^HKEY",		/* R30, R31 */
	   "HKEY",		/* all others */
165
	   );			/* 570 */
166 167


168 169
/*************************************************************************
 * ACPI helpers
170 171
 */

L
Linus Torvalds 已提交
172 173 174 175
static int acpi_evalf(acpi_handle handle,
		      void *res, char *method, char *fmt, ...)
{
	char *fmt0 = fmt;
176 177 178 179 180 181 182 183 184
	struct acpi_object_list params;
	union acpi_object in_objs[IBM_MAX_ACPI_ARGS];
	struct acpi_buffer result, *resultp;
	union acpi_object out_obj;
	acpi_status status;
	va_list ap;
	char res_type;
	int success;
	int quiet;
L
Linus Torvalds 已提交
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209

	if (!*fmt) {
		printk(IBM_ERR "acpi_evalf() called with empty format\n");
		return 0;
	}

	if (*fmt == 'q') {
		quiet = 1;
		fmt++;
	} else
		quiet = 0;

	res_type = *(fmt++);

	params.count = 0;
	params.pointer = &in_objs[0];

	va_start(ap, fmt);
	while (*fmt) {
		char c = *(fmt++);
		switch (c) {
		case 'd':	/* int */
			in_objs[params.count].integer.value = va_arg(ap, int);
			in_objs[params.count++].type = ACPI_TYPE_INTEGER;
			break;
210
			/* add more types as needed */
L
Linus Torvalds 已提交
211 212 213 214 215 216 217 218
		default:
			printk(IBM_ERR "acpi_evalf() called "
			       "with invalid format character '%c'\n", c);
			return 0;
		}
	}
	va_end(ap);

219 220 221 222 223 224
	if (res_type != 'v') {
		result.length = sizeof(out_obj);
		result.pointer = &out_obj;
		resultp = &result;
	} else
		resultp = NULL;
L
Linus Torvalds 已提交
225

226
	status = acpi_evaluate_object(handle, method, &params, resultp);
L
Linus Torvalds 已提交
227 228

	switch (res_type) {
229
	case 'd':		/* int */
L
Linus Torvalds 已提交
230 231 232 233
		if (res)
			*(int *)res = out_obj.integer.value;
		success = status == AE_OK && out_obj.type == ACPI_TYPE_INTEGER;
		break;
234
	case 'v':		/* void */
L
Linus Torvalds 已提交
235 236
		success = status == AE_OK;
		break;
237
		/* add more types as needed */
L
Linus Torvalds 已提交
238 239 240 241 242 243
	default:
		printk(IBM_ERR "acpi_evalf() called "
		       "with invalid format character '%c'\n", res_type);
		return 0;
	}

244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
	if (!success && !quiet)
		printk(IBM_ERR "acpi_evalf(%s, %s, ...) failed: %d\n",
		       method, fmt0, status);

	return success;
}

static void __unused acpi_print_int(acpi_handle handle, char *method)
{
	int i;

	if (acpi_evalf(handle, &i, method, "d"))
		printk(IBM_INFO "%s = 0x%x\n", method, i);
	else
		printk(IBM_ERR "error calling %s\n", method);
}

static int acpi_ec_read(int i, u8 * p)
{
	int v;

	if (ecrd_handle) {
		if (!acpi_evalf(ecrd_handle, &v, NULL, "dd", i))
			return 0;
		*p = v;
	} else {
		if (ec_read(i, p) < 0)
			return 0;
	}

	return 1;
}

static int acpi_ec_write(int i, u8 v)
{
	if (ecwr_handle) {
		if (!acpi_evalf(ecwr_handle, NULL, NULL, "vdd", i, v))
			return 0;
	} else {
		if (ec_write(i, v) < 0)
			return 0;
	}

	return 1;
}

static int _sta(acpi_handle handle)
{
	int status;

	if (!handle || !acpi_evalf(handle, &status, "_STA", "d"))
		status = 0;

	return status;
}

300 301 302 303 304 305 306 307 308 309 310
static int issue_thinkpad_cmos_command(int cmos_cmd)
{
	if (!cmos_handle)
		return -ENXIO;

	if (!acpi_evalf(cmos_handle, NULL, NULL, "vd", cmos_cmd))
		return -EIO;

	return 0;
}

311 312 313 314
/*************************************************************************
 * ACPI device model
 */

315
static void drv_acpi_handle_init(char *name,
316 317
			   acpi_handle *handle, acpi_handle parent,
			   char **paths, int num_paths, char **path)
318 319 320 321
{
	int i;
	acpi_status status;

322 323 324
	vdbg_printk(TPACPI_DBG_INIT, "trying to locate ACPI handle for %s\n",
		name);

325 326 327 328
	for (i = 0; i < num_paths; i++) {
		status = acpi_get_handle(parent, paths[i], handle);
		if (ACPI_SUCCESS(status)) {
			*path = paths[i];
329 330 331
			dbg_printk(TPACPI_DBG_INIT,
				   "Found ACPI handle %s for %s\n",
				   *path, name);
332 333 334 335
			return;
		}
	}

336 337
	vdbg_printk(TPACPI_DBG_INIT, "ACPI handle for %s not found\n",
		    name);
338 339 340
	*handle = NULL;
}

341
static void dispatch_acpi_notify(acpi_handle handle, u32 event, void *data)
342 343 344
{
	struct ibm_struct *ibm = data;

345
	if (!ibm || !ibm->acpi || !ibm->acpi->notify)
346 347
		return;

348
	ibm->acpi->notify(ibm, event);
349 350
}

351
static int __init setup_acpi_notify(struct ibm_struct *ibm)
352 353
{
	acpi_status status;
354
	int rc;
355

356 357 358
	BUG_ON(!ibm->acpi);

	if (!*ibm->acpi->handle)
359 360
		return 0;

361
	vdbg_printk(TPACPI_DBG_INIT,
362 363
		"setting up ACPI notify for %s\n", ibm->name);

364 365 366 367
	rc = acpi_bus_get_device(*ibm->acpi->handle, &ibm->acpi->device);
	if (rc < 0) {
		printk(IBM_ERR "acpi_bus_get_device(%s) failed: %d\n",
			ibm->name, rc);
368 369 370
		return -ENODEV;
	}

371 372
	acpi_driver_data(ibm->acpi->device) = ibm;
	sprintf(acpi_device_class(ibm->acpi->device), "%s/%s",
373 374
		IBM_ACPI_EVENT_PREFIX,
		ibm->name);
375

376 377
	status = acpi_install_notify_handler(*ibm->acpi->handle,
			ibm->acpi->type, dispatch_acpi_notify, ibm);
378 379 380 381 382 383 384 385 386 387
	if (ACPI_FAILURE(status)) {
		if (status == AE_ALREADY_EXISTS) {
			printk(IBM_NOTICE "another device driver is already handling %s events\n",
				ibm->name);
		} else {
			printk(IBM_ERR "acpi_install_notify_handler(%s) failed: %d\n",
				ibm->name, status);
		}
		return -ENODEV;
	}
388
	ibm->flags.acpi_notify_installed = 1;
389 390 391
	return 0;
}

392
static int __init tpacpi_device_add(struct acpi_device *device)
393 394 395 396
{
	return 0;
}

397
static int __init register_tpacpi_subdriver(struct ibm_struct *ibm)
398
{
399
	int rc;
400

401 402 403
	dbg_printk(TPACPI_DBG_INIT,
		"registering %s as an ACPI driver\n", ibm->name);

404 405 406 407
	BUG_ON(!ibm->acpi);

	ibm->acpi->driver = kzalloc(sizeof(struct acpi_driver), GFP_KERNEL);
	if (!ibm->acpi->driver) {
408 409
		printk(IBM_ERR "kzalloc(ibm->driver) failed\n");
		return -ENOMEM;
410 411
	}

412 413
	sprintf(ibm->acpi->driver->name, "%s_%s", IBM_NAME, ibm->name);
	ibm->acpi->driver->ids = ibm->acpi->hid;
414

415
	ibm->acpi->driver->ops.add = &tpacpi_device_add;
416

417 418
	rc = acpi_bus_register_driver(ibm->acpi->driver);
	if (rc < 0) {
419
		printk(IBM_ERR "acpi_bus_register_driver(%s) failed: %d\n",
420
		       ibm->name, rc);
421 422
		kfree(ibm->acpi->driver);
		ibm->acpi->driver = NULL;
423
	} else if (!rc)
424
		ibm->flags.acpi_driver_registered = 1;
425

426
	return rc;
427 428 429 430 431 432 433 434 435 436 437
}


/****************************************************************************
 ****************************************************************************
 *
 * Procfs Helpers
 *
 ****************************************************************************
 ****************************************************************************/

438 439
static int dispatch_procfs_read(char *page, char **start, off_t off,
			int count, int *eof, void *data)
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
{
	struct ibm_struct *ibm = data;
	int len;

	if (!ibm || !ibm->read)
		return -EINVAL;

	len = ibm->read(page);
	if (len < 0)
		return len;

	if (len <= off + count)
		*eof = 1;
	*start = page + off;
	len -= off;
	if (len > count)
		len = count;
	if (len < 0)
		len = 0;

	return len;
}

463 464 465
static int dispatch_procfs_write(struct file *file,
			const char __user * userbuf,
			unsigned long count, void *data)
466 467 468 469 470 471 472 473 474 475 476
{
	struct ibm_struct *ibm = data;
	char *kernbuf;
	int ret;

	if (!ibm || !ibm->write)
		return -EINVAL;

	kernbuf = kmalloc(count + 2, GFP_KERNEL);
	if (!kernbuf)
		return -ENOMEM;
L
Linus Torvalds 已提交
477

478 479 480 481
	if (copy_from_user(kernbuf, userbuf, count)) {
		kfree(kernbuf);
		return -EFAULT;
	}
L
Linus Torvalds 已提交
482

483 484 485 486 487
	kernbuf[count] = 0;
	strcat(kernbuf, ",");
	ret = ibm->write(kernbuf);
	if (ret == 0)
		ret = count;
L
Linus Torvalds 已提交
488

489 490 491
	kfree(kernbuf);

	return ret;
L
Linus Torvalds 已提交
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509
}

static char *next_cmd(char **cmds)
{
	char *start = *cmds;
	char *end;

	while ((end = strchr(start, ',')) && end == start)
		start = end + 1;

	if (!end)
		return NULL;

	*end = 0;
	*cmds = end + 1;
	return start;
}

510

511 512 513
/****************************************************************************
 ****************************************************************************
 *
514
 * Device model: input, hwmon and platform
515 516 517 518
 *
 ****************************************************************************
 ****************************************************************************/

519 520
static struct platform_device *tpacpi_pdev;
static struct class_device *tpacpi_hwmon;
521
static struct input_dev *tpacpi_inputdev;
522

523 524 525 526 527 528 529 530 531 532 533 534 535 536 537

static int tpacpi_resume_handler(struct platform_device *pdev)
{
	struct ibm_struct *ibm, *itmp;

	list_for_each_entry_safe(ibm, itmp,
				 &tpacpi_all_drivers,
				 all_drivers) {
		if (ibm->resume)
			(ibm->resume)();
	}

	return 0;
}

538 539 540 541 542
static struct platform_driver tpacpi_pdriver = {
	.driver = {
		.name = IBM_DRVR_NAME,
		.owner = THIS_MODULE,
	},
543
	.resume = tpacpi_resume_handler,
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 572 573
/*************************************************************************
 * thinkpad-acpi driver attributes
 */

/* interface_version --------------------------------------------------- */
static ssize_t tpacpi_driver_interface_version_show(
				struct device_driver *drv,
				char *buf)
{
	return snprintf(buf, PAGE_SIZE, "0x%08x\n", TPACPI_SYSFS_VERSION);
}

static DRIVER_ATTR(interface_version, S_IRUGO,
		tpacpi_driver_interface_version_show, NULL);

/* debug_level --------------------------------------------------------- */
static ssize_t tpacpi_driver_debug_show(struct device_driver *drv,
						char *buf)
{
	return snprintf(buf, PAGE_SIZE, "0x%04x\n", dbg_level);
}

static ssize_t tpacpi_driver_debug_store(struct device_driver *drv,
						const char *buf, size_t count)
{
	unsigned long t;

574
	if (parse_strtoul(buf, 0xffff, &t))
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623
		return -EINVAL;

	dbg_level = t;

	return count;
}

static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
		tpacpi_driver_debug_show, tpacpi_driver_debug_store);

/* version ------------------------------------------------------------- */
static ssize_t tpacpi_driver_version_show(struct device_driver *drv,
						char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%s v%s\n", IBM_DESC, IBM_VERSION);
}

static DRIVER_ATTR(version, S_IRUGO,
		tpacpi_driver_version_show, NULL);

/* --------------------------------------------------------------------- */

static struct driver_attribute* tpacpi_driver_attributes[] = {
	&driver_attr_debug_level, &driver_attr_version,
	&driver_attr_interface_version,
};

static int __init tpacpi_create_driver_attributes(struct device_driver *drv)
{
	int i, res;

	i = 0;
	res = 0;
	while (!res && i < ARRAY_SIZE(tpacpi_driver_attributes)) {
		res = driver_create_file(drv, tpacpi_driver_attributes[i]);
		i++;
	}

	return res;
}

static void tpacpi_remove_driver_attributes(struct device_driver *drv)
{
	int i;

	for(i = 0; i < ARRAY_SIZE(tpacpi_driver_attributes); i++)
		driver_remove_file(drv, tpacpi_driver_attributes[i]);
}

624 625 626 627 628 629 630 631 632 633 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
/*************************************************************************
 * sysfs support helpers
 */

struct attribute_set_obj {
	struct attribute_set s;
	struct attribute *a;
} __attribute__((packed));

static struct attribute_set *create_attr_set(unsigned int max_members,
						const char* name)
{
	struct attribute_set_obj *sobj;

	if (max_members == 0)
		return NULL;

	/* Allocates space for implicit NULL at the end too */
	sobj = kzalloc(sizeof(struct attribute_set_obj) +
		    max_members * sizeof(struct attribute *),
		    GFP_KERNEL);
	if (!sobj)
		return NULL;
	sobj->s.max_members = max_members;
	sobj->s.group.attrs = &sobj->a;
	sobj->s.group.name = name;

	return &sobj->s;
}

/* not multi-threaded safe, use it in a single thread per set */
static int add_to_attr_set(struct attribute_set* s, struct attribute *attr)
{
	if (!s || !attr)
		return -EINVAL;

	if (s->members >= s->max_members)
		return -ENOMEM;

	s->group.attrs[s->members] = attr;
	s->members++;

	return 0;
}

static int add_many_to_attr_set(struct attribute_set* s,
			struct attribute **attr,
			unsigned int count)
{
	int i, res;

	for (i = 0; i < count; i++) {
		res = add_to_attr_set(s, attr[i]);
		if (res)
			return res;
	}

	return 0;
}

static void delete_attr_set(struct attribute_set* s, struct kobject *kobj)
{
	sysfs_remove_group(kobj, &s->group);
	destroy_attr_set(s);
}

static int parse_strtoul(const char *buf,
		unsigned long max, unsigned long *value)
{
	char *endp;

	*value = simple_strtoul(buf, &endp, 0);
	while (*endp && isspace(*endp))
		endp++;
	if (*endp || *value > max)
		return -EINVAL;

	return 0;
}

704 705 706 707 708 709 710 711 712
/****************************************************************************
 ****************************************************************************
 *
 * Subdrivers
 *
 ****************************************************************************
 ****************************************************************************/

/*************************************************************************
713
 * thinkpad-acpi init subdriver
714 715
 */

716
static int __init thinkpad_acpi_driver_init(struct ibm_init_struct *iibm)
L
Linus Torvalds 已提交
717 718 719 720
{
	printk(IBM_INFO "%s v%s\n", IBM_DESC, IBM_VERSION);
	printk(IBM_INFO "%s\n", IBM_URL);

721 722 723 724 725 726 727 728 729 730 731 732 733
	printk(IBM_INFO "ThinkPad BIOS %s, EC %s\n",
		(thinkpad_id.bios_version_str) ?
			thinkpad_id.bios_version_str : "unknown",
		(thinkpad_id.ec_version_str) ?
			thinkpad_id.ec_version_str : "unknown");

	if (thinkpad_id.vendor && thinkpad_id.model_str)
		printk(IBM_INFO "%s %s\n",
			(thinkpad_id.vendor == PCI_VENDOR_ID_IBM) ?
				"IBM" : ((thinkpad_id.vendor ==
						PCI_VENDOR_ID_LENOVO) ?
					"Lenovo" : "Unknown vendor"),
			thinkpad_id.model_str);
734

L
Linus Torvalds 已提交
735 736 737
	return 0;
}

738
static int thinkpad_acpi_driver_read(char *p)
L
Linus Torvalds 已提交
739 740 741 742 743 744 745 746 747
{
	int len = 0;

	len += sprintf(p + len, "driver:\t\t%s\n", IBM_DESC);
	len += sprintf(p + len, "version:\t%s\n", IBM_VERSION);

	return len;
}

748 749 750 751 752
static struct ibm_struct thinkpad_acpi_driver_data = {
	.name = "driver",
	.read = thinkpad_acpi_driver_read,
};

753 754 755 756
/*************************************************************************
 * Hotkey subdriver
 */

757
static int hotkey_orig_status;
758
static u32 hotkey_orig_mask;
759
static u32 hotkey_all_mask;
760 761
static u32 hotkey_reserved_mask;

762
static u16 *hotkey_keycode_map;
763

764
static struct attribute_set *hotkey_dev_attributes;
765

766 767 768 769 770 771 772
static int hotkey_get_wlsw(int *status)
{
	if (!acpi_evalf(hkey_handle, status, "WLSW", "d"))
		return -EIO;
	return 0;
}

773 774 775 776 777
/* sysfs hotkey enable ------------------------------------------------- */
static ssize_t hotkey_enable_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
778 779
	int res, status;
	u32 mask;
780 781 782 783 784 785 786 787 788 789 790 791 792

	res = hotkey_get(&status, &mask);
	if (res)
		return res;

	return snprintf(buf, PAGE_SIZE, "%d\n", status);
}

static ssize_t hotkey_enable_store(struct device *dev,
			    struct device_attribute *attr,
			    const char *buf, size_t count)
{
	unsigned long t;
793 794
	int res, status;
	u32 mask;
795 796 797 798 799 800 801 802 803 804 805 806

	if (parse_strtoul(buf, 1, &t))
		return -EINVAL;

	res = hotkey_get(&status, &mask);
	if (!res)
		res = hotkey_set(t, mask);

	return (res) ? res : count;
}

static struct device_attribute dev_attr_hotkey_enable =
807
	__ATTR(hotkey_enable, S_IWUSR | S_IRUGO,
808 809 810 811 812 813 814
		hotkey_enable_show, hotkey_enable_store);

/* sysfs hotkey mask --------------------------------------------------- */
static ssize_t hotkey_mask_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
815 816
	int res, status;
	u32 mask;
817 818 819 820 821

	res = hotkey_get(&status, &mask);
	if (res)
		return res;

822
	return snprintf(buf, PAGE_SIZE, "0x%08x\n", mask);
823 824 825 826 827 828 829
}

static ssize_t hotkey_mask_store(struct device *dev,
			    struct device_attribute *attr,
			    const char *buf, size_t count)
{
	unsigned long t;
830 831
	int res, status;
	u32 mask;
832

833
	if (parse_strtoul(buf, 0xffffffffUL, &t))
834 835 836 837 838 839 840 841 842 843
		return -EINVAL;

	res = hotkey_get(&status, &mask);
	if (!res)
		hotkey_set(status, t);

	return (res) ? res : count;
}

static struct device_attribute dev_attr_hotkey_mask =
844
	__ATTR(hotkey_mask, S_IWUSR | S_IRUGO,
845 846 847 848 849 850 851 852 853 854 855
		hotkey_mask_show, hotkey_mask_store);

/* sysfs hotkey bios_enabled ------------------------------------------- */
static ssize_t hotkey_bios_enabled_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_orig_status);
}

static struct device_attribute dev_attr_hotkey_bios_enabled =
856
	__ATTR(hotkey_bios_enabled, S_IRUGO, hotkey_bios_enabled_show, NULL);
857 858 859 860 861 862

/* sysfs hotkey bios_mask ---------------------------------------------- */
static ssize_t hotkey_bios_mask_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
863
	return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_orig_mask);
864 865 866
}

static struct device_attribute dev_attr_hotkey_bios_mask =
867
	__ATTR(hotkey_bios_mask, S_IRUGO, hotkey_bios_mask_show, NULL);
868

869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
/* sysfs hotkey all_mask ----------------------------------------------- */
static ssize_t hotkey_all_mask_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_all_mask);
}

static struct device_attribute dev_attr_hotkey_all_mask =
	__ATTR(hotkey_all_mask, S_IRUGO, hotkey_all_mask_show, NULL);

/* sysfs hotkey recommended_mask --------------------------------------- */
static ssize_t hotkey_recommended_mask_show(struct device *dev,
					    struct device_attribute *attr,
					    char *buf)
{
	return snprintf(buf, PAGE_SIZE, "0x%08x\n",
			hotkey_all_mask & ~hotkey_reserved_mask);
}

static struct device_attribute dev_attr_hotkey_recommended_mask =
	__ATTR(hotkey_recommended_mask, S_IRUGO,
		hotkey_recommended_mask_show, NULL);

893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908
/* sysfs hotkey radio_sw ----------------------------------------------- */
static ssize_t hotkey_radio_sw_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	int res, s;
	res = hotkey_get_wlsw(&s);
	if (res < 0)
		return res;

	return snprintf(buf, PAGE_SIZE, "%d\n", !!s);
}

static struct device_attribute dev_attr_hotkey_radio_sw =
	__ATTR(hotkey_radio_sw, S_IRUGO, hotkey_radio_sw_show, NULL);

909 910 911 912 913 914
/* --------------------------------------------------------------------- */

static struct attribute *hotkey_mask_attributes[] = {
	&dev_attr_hotkey_mask.attr,
	&dev_attr_hotkey_bios_enabled.attr,
	&dev_attr_hotkey_bios_mask.attr,
915 916
	&dev_attr_hotkey_all_mask.attr,
	&dev_attr_hotkey_recommended_mask.attr,
917 918
};

919
static int __init hotkey_init(struct ibm_init_struct *iibm)
920
{
921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972

	static u16 ibm_keycode_map[] __initdata = {
		/* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */
		KEY_FN_F1,	KEY_FN_F2,	KEY_COFFEE,	KEY_SLEEP,
		KEY_WLAN,	KEY_FN_F6, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
		KEY_FN_F9,	KEY_FN_F10,	KEY_FN_F11,	KEY_SUSPEND,
		/* Scan codes 0x0C to 0x0F: Other ACPI HKEY hot keys */
		KEY_UNKNOWN,	/* 0x0C: FN+BACKSPACE */
		KEY_UNKNOWN,	/* 0x0D: FN+INSERT */
		KEY_UNKNOWN,	/* 0x0E: FN+DELETE */
		KEY_RESERVED,	/* 0x0F: FN+HOME (brightness up) */
		/* Scan codes 0x10 to 0x1F: Extended ACPI HKEY hot keys */
		KEY_RESERVED,	/* 0x10: FN+END (brightness down) */
		KEY_RESERVED,	/* 0x11: FN+PGUP (thinklight toggle) */
		KEY_UNKNOWN,	/* 0x12: FN+PGDOWN */
		KEY_ZOOM,	/* 0x13: FN+SPACE (zoom) */
		KEY_RESERVED,	/* 0x14: VOLUME UP */
		KEY_RESERVED,	/* 0x15: VOLUME DOWN */
		KEY_RESERVED,	/* 0x16: MUTE */
		KEY_VENDOR,	/* 0x17: Thinkpad/AccessIBM/Lenovo */
		/* (assignments unknown, please report if found) */
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
	};
	static u16 lenovo_keycode_map[] __initdata = {
		/* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */
		KEY_FN_F1,	KEY_COFFEE,	KEY_BATTERY,	KEY_SLEEP,
		KEY_WLAN,	KEY_FN_F6, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
		KEY_FN_F9,	KEY_FN_F10,	KEY_FN_F11,	KEY_SUSPEND,
		/* Scan codes 0x0C to 0x0F: Other ACPI HKEY hot keys */
		KEY_UNKNOWN,	/* 0x0C: FN+BACKSPACE */
		KEY_UNKNOWN,	/* 0x0D: FN+INSERT */
		KEY_UNKNOWN,	/* 0x0E: FN+DELETE */
		KEY_BRIGHTNESSUP,	/* 0x0F: FN+HOME (brightness up) */
		/* Scan codes 0x10 to 0x1F: Extended ACPI HKEY hot keys */
		KEY_BRIGHTNESSDOWN,	/* 0x10: FN+END (brightness down) */
		KEY_RESERVED,	/* 0x11: FN+PGUP (thinklight toggle) */
		KEY_UNKNOWN,	/* 0x12: FN+PGDOWN */
		KEY_ZOOM,	/* 0x13: FN+SPACE (zoom) */
		KEY_RESERVED,	/* 0x14: VOLUME UP */
		KEY_RESERVED,	/* 0x15: VOLUME DOWN */
		KEY_RESERVED,	/* 0x16: MUTE */
		KEY_VENDOR,	/* 0x17: Thinkpad/AccessIBM/Lenovo */
		/* (assignments unknown, please report if found) */
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
	};

#define TPACPI_HOTKEY_MAP_LEN		ARRAY_SIZE(ibm_keycode_map)
#define TPACPI_HOTKEY_MAP_SIZE		sizeof(ibm_keycode_map)
#define TPACPI_HOTKEY_MAP_TYPESIZE	sizeof(ibm_keycode_map[0])

973
	int res, i;
974
	int status;
975

976 977
	vdbg_printk(TPACPI_DBG_INIT, "initializing hotkey subdriver\n");

978 979
	BUG_ON(!tpacpi_inputdev);

980
	IBM_ACPIHANDLE_INIT(hkey);
981
	mutex_init(&hotkey_mutex);
982

983
	/* hotkey not supported on 570 */
984
	tp_features.hotkey = hkey_handle != NULL;
985

986
	vdbg_printk(TPACPI_DBG_INIT, "hotkeys are %s\n",
987
		str_supported(tp_features.hotkey));
988

989
	if (tp_features.hotkey) {
990
		hotkey_dev_attributes = create_attr_set(7, NULL);
991 992 993 994 995 996 997
		if (!hotkey_dev_attributes)
			return -ENOMEM;
		res = add_to_attr_set(hotkey_dev_attributes,
				&dev_attr_hotkey_enable.attr);
		if (res)
			return res;

998 999
		/* mask not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
		   A30, R30, R31, T20-22, X20-21, X22-24 */
1000 1001
		tp_features.hotkey_mask =
			acpi_evalf(hkey_handle, NULL, "DHKN", "qv");
1002

1003
		vdbg_printk(TPACPI_DBG_INIT, "hotkey masks are %s\n",
1004
			str_supported(tp_features.hotkey_mask));
1005

1006 1007 1008 1009 1010 1011 1012
		if (tp_features.hotkey_mask) {
			/* MHKA available in A31, R40, R40e, T4x, X31, and later */
			if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
					"MHKA", "qd"))
				hotkey_all_mask = 0x080cU; /* FN+F12, FN+F4, FN+F3 */
		}

1013
		res = hotkey_get(&hotkey_orig_status, &hotkey_orig_mask);
1014 1015 1016 1017 1018
		if (!res && tp_features.hotkey_mask) {
			res = add_many_to_attr_set(hotkey_dev_attributes,
				hotkey_mask_attributes,
				ARRAY_SIZE(hotkey_mask_attributes));
		}
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029

		/* Not all thinkpads have a hardware radio switch */
		if (!res && acpi_evalf(hkey_handle, &status, "WLSW", "qd")) {
			tp_features.hotkey_wlsw = 1;
			printk(IBM_INFO
				"radio switch found; radios are %s\n",
				enabled(status, 0));
			res = add_to_attr_set(hotkey_dev_attributes,
					&dev_attr_hotkey_radio_sw.attr);
		}

1030 1031 1032 1033
		if (!res)
			res = register_attr_set_with_sysfs(
					hotkey_dev_attributes,
					&tpacpi_pdev->dev.kobj);
1034 1035
		if (res)
			return res;
1036

1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
		/* Set up key map */

		hotkey_keycode_map = kmalloc(TPACPI_HOTKEY_MAP_SIZE,
						GFP_KERNEL);
		if (!hotkey_keycode_map) {
			printk(IBM_ERR "failed to allocate memory for key map\n");
			return -ENOMEM;
		}

		if (thinkpad_id.vendor == PCI_VENDOR_ID_LENOVO) {
			dbg_printk(TPACPI_DBG_INIT,
				   "using Lenovo default hot key map\n");
			memcpy(hotkey_keycode_map, &lenovo_keycode_map,
				TPACPI_HOTKEY_MAP_SIZE);
		} else {
			dbg_printk(TPACPI_DBG_INIT,
				   "using IBM default hot key map\n");
			memcpy(hotkey_keycode_map, &ibm_keycode_map,
				TPACPI_HOTKEY_MAP_SIZE);
		}

1058 1059 1060 1061 1062
#ifndef CONFIG_THINKPAD_ACPI_INPUT_ENABLED
		for (i = 0; i < 12; i++)
			hotkey_keycode_map[i] = KEY_UNKNOWN;
#endif /* ! CONFIG_THINKPAD_ACPI_INPUT_ENABLED */

1063 1064 1065
		set_bit(EV_KEY, tpacpi_inputdev->evbit);
		set_bit(EV_MSC, tpacpi_inputdev->evbit);
		set_bit(MSC_SCAN, tpacpi_inputdev->mscbit);
1066 1067 1068 1069
		tpacpi_inputdev->keycodesize = TPACPI_HOTKEY_MAP_TYPESIZE;
		tpacpi_inputdev->keycodemax = TPACPI_HOTKEY_MAP_LEN;
		tpacpi_inputdev->keycode = hotkey_keycode_map;
		for (i = 0; i < TPACPI_HOTKEY_MAP_LEN; i++) {
1070 1071 1072 1073 1074 1075 1076 1077 1078
			if (hotkey_keycode_map[i] != KEY_RESERVED) {
				set_bit(hotkey_keycode_map[i],
					tpacpi_inputdev->keybit);
			} else {
				if (i < sizeof(hotkey_reserved_mask)*8)
					hotkey_reserved_mask |= 1 << i;
			}
		}

1079 1080 1081 1082 1083
		if (tp_features.hotkey_wlsw) {
			set_bit(EV_SW, tpacpi_inputdev->evbit);
			set_bit(SW_RADIO, tpacpi_inputdev->swbit);
		}

1084 1085 1086 1087 1088 1089 1090 1091
#ifdef CONFIG_THINKPAD_ACPI_INPUT_ENABLED
		dbg_printk(TPACPI_DBG_INIT,
				"enabling hot key handling\n");
		res = hotkey_set(1, (hotkey_all_mask & ~hotkey_reserved_mask)
					| hotkey_orig_mask);
		if (res)
			return res;
#endif /* CONFIG_THINKPAD_ACPI_INPUT_ENABLED */
1092 1093
	}

1094
	return (tp_features.hotkey)? 0 : 1;
1095 1096 1097 1098
}

static void hotkey_exit(void)
{
1099 1100
	int res;

1101
	if (tp_features.hotkey) {
1102
		dbg_printk(TPACPI_DBG_EXIT, "restoring original hotkey mask\n");
1103 1104 1105
		res = hotkey_set(hotkey_orig_status, hotkey_orig_mask);
		if (res)
			printk(IBM_ERR "failed to restore hotkey to BIOS defaults\n");
1106
	}
1107 1108 1109 1110 1111

	if (hotkey_dev_attributes) {
		delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj);
		hotkey_dev_attributes = NULL;
	}
1112 1113
}

1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
static void tpacpi_input_send_key(unsigned int scancode,
				  unsigned int keycode)
{
	if (keycode != KEY_RESERVED) {
		input_report_key(tpacpi_inputdev, keycode, 1);
		if (keycode == KEY_UNKNOWN)
			input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN,
				    scancode);
		input_sync(tpacpi_inputdev);

		input_report_key(tpacpi_inputdev, keycode, 0);
		if (keycode == KEY_UNKNOWN)
			input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN,
				    scancode);
		input_sync(tpacpi_inputdev);
	}
}

1132 1133 1134 1135 1136 1137 1138 1139 1140
static void tpacpi_input_send_radiosw(void)
{
	int wlsw;

	if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&wlsw))
		input_report_switch(tpacpi_inputdev,
				    SW_RADIO, !!wlsw);
}

1141 1142
static void hotkey_notify(struct ibm_struct *ibm, u32 event)
{
1143 1144 1145
	u32 hkey;
	unsigned int keycode, scancode;
	int sendacpi = 1;
1146

1147
	if (event == 0x80 && acpi_evalf(hkey_handle, &hkey, "MHKP", "d")) {
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174
		if (tpacpi_inputdev->users > 0) {
			switch (hkey >> 12) {
			case 1:
				/* 0x1000-0x1FFF: key presses */
				scancode = hkey & 0xfff;
				if (scancode > 0 && scancode < 0x21) {
					scancode--;
					keycode = hotkey_keycode_map[scancode];
					tpacpi_input_send_key(scancode, keycode);
					sendacpi = (keycode == KEY_RESERVED
						|| keycode == KEY_UNKNOWN);
				} else {
					printk(IBM_ERR
					       "hotkey 0x%04x out of range for keyboard map\n",
					       hkey);
				}
				break;
			case 5:
				/* 0x5000-0x5FFF: LID */
				/* we don't handle it through this path, just
				 * eat up known LID events */
				if (hkey != 0x5001 && hkey != 0x5002) {
					printk(IBM_ERR
						"unknown LID-related hotkey event: 0x%04x\n",
						hkey);
				}
				break;
1175 1176 1177 1178 1179 1180 1181 1182
			case 7:
				/* 0x7000-0x7FFF: misc */
				if (tp_features.hotkey_wlsw && hkey == 0x7000) {
						tpacpi_input_send_radiosw();
						sendacpi = 0;
					break;
				}
				/* fallthrough to default */
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
			default:
				/* case 2: dock-related */
				/*	0x2305 - T43 waking up due to bay lever eject while aslept */
				/* case 3: ultra-bay related. maybe bay in dock? */
				/*	0x3003 - T43 after wake up by bay lever eject (0x2305) */
				printk(IBM_NOTICE "unhandled hotkey event 0x%04x\n", hkey);
			}
		}

		if (sendacpi)
			acpi_bus_generate_event(ibm->acpi->device, event, hkey);
1194 1195
	} else {
		printk(IBM_ERR "unknown hotkey notification event %d\n", event);
1196
		acpi_bus_generate_event(ibm->acpi->device, event, 0);
1197 1198 1199
	}
}

1200 1201 1202 1203 1204
static void hotkey_resume(void)
{
	tpacpi_input_send_radiosw();
}

1205 1206 1207
/*
 * Call with hotkey_mutex held
 */
1208
static int hotkey_get(int *status, u32 *mask)
L
Linus Torvalds 已提交
1209 1210
{
	if (!acpi_evalf(hkey_handle, status, "DHKC", "d"))
1211
		return -EIO;
1212

1213
	if (tp_features.hotkey_mask)
1214
		if (!acpi_evalf(hkey_handle, mask, "DHKN", "d"))
1215
			return -EIO;
1216

1217
	return 0;
L
Linus Torvalds 已提交
1218 1219
}

1220 1221 1222
/*
 * Call with hotkey_mutex held
 */
1223
static int hotkey_set(int status, u32 mask)
L
Linus Torvalds 已提交
1224 1225 1226 1227
{
	int i;

	if (!acpi_evalf(hkey_handle, NULL, "MHKC", "vd", status))
1228
		return -EIO;
L
Linus Torvalds 已提交
1229

1230
	if (tp_features.hotkey_mask)
1231 1232 1233 1234
		for (i = 0; i < 32; i++) {
			int bit = ((1 << i) & mask) != 0;
			if (!acpi_evalf(hkey_handle,
					NULL, "MHKM", "vdd", i + 1, bit))
1235
				return -EIO;
1236
		}
L
Linus Torvalds 已提交
1237

1238
	return 0;
L
Linus Torvalds 已提交
1239 1240
}

1241
/* procfs -------------------------------------------------------------- */
1242
static int hotkey_read(char *p)
L
Linus Torvalds 已提交
1243
{
1244 1245
	int res, status;
	u32 mask;
L
Linus Torvalds 已提交
1246 1247
	int len = 0;

1248
	if (!tp_features.hotkey) {
1249 1250 1251 1252
		len += sprintf(p + len, "status:\t\tnot supported\n");
		return len;
	}

1253 1254 1255
	res = mutex_lock_interruptible(&hotkey_mutex);
	if (res < 0)
		return res;
1256
	res = hotkey_get(&status, &mask);
1257
	mutex_unlock(&hotkey_mutex);
1258 1259
	if (res)
		return res;
L
Linus Torvalds 已提交
1260 1261

	len += sprintf(p + len, "status:\t\t%s\n", enabled(status, 0));
1262
	if (tp_features.hotkey_mask) {
1263
		len += sprintf(p + len, "mask:\t\t0x%08x\n", mask);
L
Linus Torvalds 已提交
1264 1265 1266 1267 1268 1269 1270 1271 1272 1273
		len += sprintf(p + len,
			       "commands:\tenable, disable, reset, <mask>\n");
	} else {
		len += sprintf(p + len, "mask:\t\tnot supported\n");
		len += sprintf(p + len, "commands:\tenable, disable, reset\n");
	}

	return len;
}

1274
static int hotkey_write(char *buf)
L
Linus Torvalds 已提交
1275
{
1276 1277
	int res, status;
	u32 mask;
L
Linus Torvalds 已提交
1278 1279 1280
	char *cmd;
	int do_cmd = 0;

1281
	if (!tp_features.hotkey)
L
Linus Torvalds 已提交
1282 1283
		return -ENODEV;

1284 1285 1286 1287
	res = mutex_lock_interruptible(&hotkey_mutex);
	if (res < 0)
		return res;

1288 1289
	res = hotkey_get(&status, &mask);
	if (res)
1290
		goto errexit;
1291

1292
	res = 0;
L
Linus Torvalds 已提交
1293 1294 1295 1296 1297 1298
	while ((cmd = next_cmd(&buf))) {
		if (strlencmp(cmd, "enable") == 0) {
			status = 1;
		} else if (strlencmp(cmd, "disable") == 0) {
			status = 0;
		} else if (strlencmp(cmd, "reset") == 0) {
1299 1300
			status = hotkey_orig_status;
			mask = hotkey_orig_mask;
L
Linus Torvalds 已提交
1301 1302 1303 1304
		} else if (sscanf(cmd, "0x%x", &mask) == 1) {
			/* mask set */
		} else if (sscanf(cmd, "%x", &mask) == 1) {
			/* mask set */
1305 1306 1307 1308
		} else {
			res = -EINVAL;
			goto errexit;
		}
L
Linus Torvalds 已提交
1309 1310 1311
		do_cmd = 1;
	}

1312
	if (do_cmd)
1313
		res = hotkey_set(status, mask);
L
Linus Torvalds 已提交
1314

1315 1316 1317
errexit:
	mutex_unlock(&hotkey_mutex);
	return res;
1318
}
L
Linus Torvalds 已提交
1319

1320 1321 1322 1323 1324
static const struct acpi_device_id ibm_htk_device_ids[] = {
	{IBM_HKEY_HID, 0},
	{"", 0},
};

1325
static struct tp_acpi_drv_struct ibm_hotkey_acpidriver = {
1326
	.hid = ibm_htk_device_ids,
1327 1328 1329 1330 1331
	.notify = hotkey_notify,
	.handle = &hkey_handle,
	.type = ACPI_DEVICE_NOTIFY,
};

1332 1333 1334 1335 1336
static struct ibm_struct hotkey_driver_data = {
	.name = "hotkey",
	.read = hotkey_read,
	.write = hotkey_write,
	.exit = hotkey_exit,
1337
	.resume = hotkey_resume,
1338
	.acpi = &ibm_hotkey_acpidriver,
1339 1340
};

1341 1342 1343
/*************************************************************************
 * Bluetooth subdriver
 */
L
Linus Torvalds 已提交
1344

1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374
/* sysfs bluetooth enable ---------------------------------------------- */
static ssize_t bluetooth_enable_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	int status;

	status = bluetooth_get_radiosw();
	if (status < 0)
		return status;

	return snprintf(buf, PAGE_SIZE, "%d\n", status ? 1 : 0);
}

static ssize_t bluetooth_enable_store(struct device *dev,
			    struct device_attribute *attr,
			    const char *buf, size_t count)
{
	unsigned long t;
	int res;

	if (parse_strtoul(buf, 1, &t))
		return -EINVAL;

	res = bluetooth_set_radiosw(t);

	return (res) ? res : count;
}

static struct device_attribute dev_attr_bluetooth_enable =
1375
	__ATTR(bluetooth_enable, S_IWUSR | S_IRUGO,
1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
		bluetooth_enable_show, bluetooth_enable_store);

/* --------------------------------------------------------------------- */

static struct attribute *bluetooth_attributes[] = {
	&dev_attr_bluetooth_enable.attr,
	NULL
};

static const struct attribute_group bluetooth_attr_group = {
	.attrs = bluetooth_attributes,
};

1389
static int __init bluetooth_init(struct ibm_init_struct *iibm)
L
Linus Torvalds 已提交
1390
{
1391
	int res;
1392 1393
	int status = 0;

1394 1395
	vdbg_printk(TPACPI_DBG_INIT, "initializing bluetooth subdriver\n");

1396
	IBM_ACPIHANDLE_INIT(hkey);
1397

1398 1399
	/* bluetooth not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
	   G4x, R30, R31, R40e, R50e, T20-22, X20-21 */
1400
	tp_features.bluetooth = hkey_handle &&
1401 1402 1403 1404 1405 1406
	    acpi_evalf(hkey_handle, &status, "GBDC", "qd");

	vdbg_printk(TPACPI_DBG_INIT, "bluetooth is %s, status 0x%02x\n",
		str_supported(tp_features.bluetooth),
		status);

1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
	if (tp_features.bluetooth) {
		if (!(status & TP_ACPI_BLUETOOTH_HWPRESENT)) {
			/* no bluetooth hardware present in system */
			tp_features.bluetooth = 0;
			dbg_printk(TPACPI_DBG_INIT,
				   "bluetooth hardware not installed\n");
		} else {
			res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
					&bluetooth_attr_group);
			if (res)
				return res;
		}
1419
	}
1420

1421
	return (tp_features.bluetooth)? 0 : 1;
L
Linus Torvalds 已提交
1422 1423
}

1424 1425 1426 1427 1428 1429
static void bluetooth_exit(void)
{
	sysfs_remove_group(&tpacpi_pdev->dev.kobj,
			&bluetooth_attr_group);
}

1430
static int bluetooth_get_radiosw(void)
L
Linus Torvalds 已提交
1431 1432 1433
{
	int status;

1434 1435
	if (!tp_features.bluetooth)
		return -ENODEV;
L
Linus Torvalds 已提交
1436

1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459
	if (!acpi_evalf(hkey_handle, &status, "GBDC", "d"))
		return -EIO;

	return ((status & TP_ACPI_BLUETOOTH_RADIOSSW) != 0);
}

static int bluetooth_set_radiosw(int radio_on)
{
	int status;

	if (!tp_features.bluetooth)
		return -ENODEV;

	if (!acpi_evalf(hkey_handle, &status, "GBDC", "d"))
		return -EIO;
	if (radio_on)
		status |= TP_ACPI_BLUETOOTH_RADIOSSW;
	else
		status &= ~TP_ACPI_BLUETOOTH_RADIOSSW;
	if (!acpi_evalf(hkey_handle, NULL, "SBDC", "vd", status))
		return -EIO;

	return 0;
L
Linus Torvalds 已提交
1460 1461
}

1462
/* procfs -------------------------------------------------------------- */
1463
static int bluetooth_read(char *p)
L
Linus Torvalds 已提交
1464 1465
{
	int len = 0;
1466
	int status = bluetooth_get_radiosw();
L
Linus Torvalds 已提交
1467

1468
	if (!tp_features.bluetooth)
L
Linus Torvalds 已提交
1469 1470
		len += sprintf(p + len, "status:\t\tnot supported\n");
	else {
1471 1472
		len += sprintf(p + len, "status:\t\t%s\n",
				(status)? "enabled" : "disabled");
L
Linus Torvalds 已提交
1473 1474 1475 1476 1477 1478
		len += sprintf(p + len, "commands:\tenable, disable\n");
	}

	return len;
}

1479
static int bluetooth_write(char *buf)
L
Linus Torvalds 已提交
1480 1481 1482
{
	char *cmd;

1483
	if (!tp_features.bluetooth)
1484
		return -ENODEV;
L
Linus Torvalds 已提交
1485 1486 1487

	while ((cmd = next_cmd(&buf))) {
		if (strlencmp(cmd, "enable") == 0) {
1488
			bluetooth_set_radiosw(1);
L
Linus Torvalds 已提交
1489
		} else if (strlencmp(cmd, "disable") == 0) {
1490
			bluetooth_set_radiosw(0);
L
Linus Torvalds 已提交
1491 1492 1493 1494 1495 1496 1497
		} else
			return -EINVAL;
	}

	return 0;
}

1498 1499 1500 1501
static struct ibm_struct bluetooth_driver_data = {
	.name = "bluetooth",
	.read = bluetooth_read,
	.write = bluetooth_write,
1502
	.exit = bluetooth_exit,
1503 1504
};

1505 1506 1507 1508
/*************************************************************************
 * Wan subdriver
 */

1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538
/* sysfs wan enable ---------------------------------------------------- */
static ssize_t wan_enable_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	int status;

	status = wan_get_radiosw();
	if (status < 0)
		return status;

	return snprintf(buf, PAGE_SIZE, "%d\n", status ? 1 : 0);
}

static ssize_t wan_enable_store(struct device *dev,
			    struct device_attribute *attr,
			    const char *buf, size_t count)
{
	unsigned long t;
	int res;

	if (parse_strtoul(buf, 1, &t))
		return -EINVAL;

	res = wan_set_radiosw(t);

	return (res) ? res : count;
}

static struct device_attribute dev_attr_wan_enable =
1539
	__ATTR(wwan_enable, S_IWUSR | S_IRUGO,
1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
		wan_enable_show, wan_enable_store);

/* --------------------------------------------------------------------- */

static struct attribute *wan_attributes[] = {
	&dev_attr_wan_enable.attr,
	NULL
};

static const struct attribute_group wan_attr_group = {
	.attrs = wan_attributes,
};

1553
static int __init wan_init(struct ibm_init_struct *iibm)
1554
{
1555
	int res;
1556 1557
	int status = 0;

1558 1559
	vdbg_printk(TPACPI_DBG_INIT, "initializing wan subdriver\n");

1560
	IBM_ACPIHANDLE_INIT(hkey);
1561

1562
	tp_features.wan = hkey_handle &&
1563 1564 1565 1566 1567 1568
	    acpi_evalf(hkey_handle, &status, "GWAN", "qd");

	vdbg_printk(TPACPI_DBG_INIT, "wan is %s, status 0x%02x\n",
		str_supported(tp_features.wan),
		status);

1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580
	if (tp_features.wan) {
		if (!(status & TP_ACPI_WANCARD_HWPRESENT)) {
			/* no wan hardware present in system */
			tp_features.wan = 0;
			dbg_printk(TPACPI_DBG_INIT,
				   "wan hardware not installed\n");
		} else {
			res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
					&wan_attr_group);
			if (res)
				return res;
		}
1581
	}
1582

1583
	return (tp_features.wan)? 0 : 1;
1584 1585
}

1586 1587 1588 1589 1590 1591
static void wan_exit(void)
{
	sysfs_remove_group(&tpacpi_pdev->dev.kobj,
		&wan_attr_group);
}

1592
static int wan_get_radiosw(void)
1593 1594 1595
{
	int status;

1596 1597
	if (!tp_features.wan)
		return -ENODEV;
1598

1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621
	if (!acpi_evalf(hkey_handle, &status, "GWAN", "d"))
		return -EIO;

	return ((status & TP_ACPI_WANCARD_RADIOSSW) != 0);
}

static int wan_set_radiosw(int radio_on)
{
	int status;

	if (!tp_features.wan)
		return -ENODEV;

	if (!acpi_evalf(hkey_handle, &status, "GWAN", "d"))
		return -EIO;
	if (radio_on)
		status |= TP_ACPI_WANCARD_RADIOSSW;
	else
		status &= ~TP_ACPI_WANCARD_RADIOSSW;
	if (!acpi_evalf(hkey_handle, NULL, "SWAN", "vd", status))
		return -EIO;

	return 0;
1622 1623
}

1624
/* procfs -------------------------------------------------------------- */
1625 1626 1627
static int wan_read(char *p)
{
	int len = 0;
1628
	int status = wan_get_radiosw();
1629

1630
	if (!tp_features.wan)
1631 1632
		len += sprintf(p + len, "status:\t\tnot supported\n");
	else {
1633 1634
		len += sprintf(p + len, "status:\t\t%s\n",
				(status)? "enabled" : "disabled");
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
		len += sprintf(p + len, "commands:\tenable, disable\n");
	}

	return len;
}

static int wan_write(char *buf)
{
	char *cmd;

1645
	if (!tp_features.wan)
1646 1647 1648 1649
		return -ENODEV;

	while ((cmd = next_cmd(&buf))) {
		if (strlencmp(cmd, "enable") == 0) {
1650
			wan_set_radiosw(1);
1651
		} else if (strlencmp(cmd, "disable") == 0) {
1652
			wan_set_radiosw(0);
1653 1654 1655 1656 1657 1658 1659
		} else
			return -EINVAL;
	}

	return 0;
}

1660 1661 1662 1663
static struct ibm_struct wan_driver_data = {
	.name = "wan",
	.read = wan_read,
	.write = wan_write,
1664
	.exit = wan_exit,
1665
	.flags.experimental = 1,
1666 1667
};

1668 1669 1670 1671
/*************************************************************************
 * Video subdriver
 */

1672 1673
static enum video_access_mode video_supported;
static int video_orig_autosw;
1674

1675 1676 1677 1678 1679 1680 1681 1682 1683
IBM_HANDLE(vid, root, "\\_SB.PCI.AGP.VGA",	/* 570 */
	   "\\_SB.PCI0.AGP0.VID0",	/* 600e/x, 770x */
	   "\\_SB.PCI0.VID0",	/* 770e */
	   "\\_SB.PCI0.VID",	/* A21e, G4x, R50e, X30, X40 */
	   "\\_SB.PCI0.AGP.VID",	/* all others */
	   );				/* R30, R31 */

IBM_HANDLE(vid2, root, "\\_SB.PCI0.AGPB.VID");	/* G41 */

1684
static int __init video_init(struct ibm_init_struct *iibm)
L
Linus Torvalds 已提交
1685
{
1686 1687
	int ivga;

1688 1689
	vdbg_printk(TPACPI_DBG_INIT, "initializing video subdriver\n");

1690 1691
	IBM_ACPIHANDLE_INIT(vid);
	IBM_ACPIHANDLE_INIT(vid2);
1692

1693 1694 1695 1696 1697 1698
	if (vid2_handle && acpi_evalf(NULL, &ivga, "\\IVGA", "d") && ivga)
		/* G41, assume IVGA doesn't change */
		vid_handle = vid2_handle;

	if (!vid_handle)
		/* video switching not supported on R30, R31 */
1699
		video_supported = TPACPI_VIDEO_NONE;
1700 1701
	else if (acpi_evalf(vid_handle, &video_orig_autosw, "SWIT", "qd"))
		/* 570 */
1702
		video_supported = TPACPI_VIDEO_570;
1703 1704
	else if (acpi_evalf(vid_handle, &video_orig_autosw, "^VADL", "qd"))
		/* 600e/x, 770e, 770x */
1705
		video_supported = TPACPI_VIDEO_770;
1706 1707
	else
		/* all others */
1708
		video_supported = TPACPI_VIDEO_NEW;
L
Linus Torvalds 已提交
1709

1710 1711 1712 1713
	vdbg_printk(TPACPI_DBG_INIT, "video is %s, mode %d\n",
		str_supported(video_supported != TPACPI_VIDEO_NONE),
		video_supported);

1714
	return (video_supported != TPACPI_VIDEO_NONE)? 0 : 1;
L
Linus Torvalds 已提交
1715 1716
}

1717 1718
static void video_exit(void)
{
1719 1720 1721 1722 1723
	dbg_printk(TPACPI_DBG_EXIT,
		   "restoring original video autoswitch mode\n");
	if (video_autosw_set(video_orig_autosw))
		printk(IBM_ERR "error while trying to restore original "
			"video autoswitch mode\n");
1724 1725
}

1726
static int video_outputsw_get(void)
L
Linus Torvalds 已提交
1727 1728 1729 1730
{
	int status = 0;
	int i;

1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766
	switch (video_supported) {
	case TPACPI_VIDEO_570:
		if (!acpi_evalf(NULL, &i, "\\_SB.PHS", "dd",
				 TP_ACPI_VIDEO_570_PHSCMD))
			return -EIO;
		status = i & TP_ACPI_VIDEO_570_PHSMASK;
		break;
	case TPACPI_VIDEO_770:
		if (!acpi_evalf(NULL, &i, "\\VCDL", "d"))
			return -EIO;
		if (i)
			status |= TP_ACPI_VIDEO_S_LCD;
		if (!acpi_evalf(NULL, &i, "\\VCDC", "d"))
			return -EIO;
		if (i)
			status |= TP_ACPI_VIDEO_S_CRT;
		break;
	case TPACPI_VIDEO_NEW:
		if (!acpi_evalf(NULL, NULL, "\\VUPS", "vd", 1) ||
		    !acpi_evalf(NULL, &i, "\\VCDC", "d"))
			return -EIO;
		if (i)
			status |= TP_ACPI_VIDEO_S_CRT;

		if (!acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0) ||
		    !acpi_evalf(NULL, &i, "\\VCDL", "d"))
			return -EIO;
		if (i)
			status |= TP_ACPI_VIDEO_S_LCD;
		if (!acpi_evalf(NULL, &i, "\\VCDD", "d"))
			return -EIO;
		if (i)
			status |= TP_ACPI_VIDEO_S_DVI;
		break;
	default:
		return -ENOSYS;
1767 1768 1769 1770
	}

	return status;
}
L
Linus Torvalds 已提交
1771

1772
static int video_outputsw_set(int status)
1773
{
1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787
	int autosw;
	int res = 0;

	switch (video_supported) {
	case TPACPI_VIDEO_570:
		res = acpi_evalf(NULL, NULL,
				 "\\_SB.PHS2", "vdd",
				 TP_ACPI_VIDEO_570_PHS2CMD,
				 status | TP_ACPI_VIDEO_570_PHS2SET);
		break;
	case TPACPI_VIDEO_770:
		autosw = video_autosw_get();
		if (autosw < 0)
			return autosw;
L
Linus Torvalds 已提交
1788

1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805
		res = video_autosw_set(1);
		if (res)
			return res;
		res = acpi_evalf(vid_handle, NULL,
				 "ASWT", "vdd", status * 0x100, 0);
		if (!autosw && video_autosw_set(autosw)) {
			printk(IBM_ERR "video auto-switch left enabled due to error\n");
			return -EIO;
		}
		break;
	case TPACPI_VIDEO_NEW:
		res = acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0x80) &&
			acpi_evalf(NULL, NULL, "\\VSDS", "vdd", status, 1);
		break;
	default:
		return -ENOSYS;
	}
L
Linus Torvalds 已提交
1806

1807
	return (res)? 0 : -EIO;
L
Linus Torvalds 已提交
1808 1809
}

1810
static int video_autosw_get(void)
1811
{
1812
	int autosw = 0;
1813

1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826
	switch (video_supported) {
	case TPACPI_VIDEO_570:
		if (!acpi_evalf(vid_handle, &autosw, "SWIT", "d"))
			return -EIO;
		break;
	case TPACPI_VIDEO_770:
	case TPACPI_VIDEO_NEW:
		if (!acpi_evalf(vid_handle, &autosw, "^VDEE", "d"))
			return -EIO;
		break;
	default:
		return -ENOSYS;
	}
1827

1828
	return autosw & 1;
1829 1830
}

1831
static int video_autosw_set(int enable)
1832
{
1833 1834 1835
	if (!acpi_evalf(vid_handle, NULL, "_DOS", "vd", (enable)? 1 : 0))
		return -EIO;
	return 0;
1836 1837
}

1838
static int video_outputsw_cycle(void)
1839
{
1840 1841
	int autosw = video_autosw_get();
	int res;
1842

1843 1844
	if (autosw < 0)
		return autosw;
1845

1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865
	switch (video_supported) {
	case TPACPI_VIDEO_570:
		res = video_autosw_set(1);
		if (res)
			return res;
		res = acpi_evalf(ec_handle, NULL, "_Q16", "v");
		break;
	case TPACPI_VIDEO_770:
	case TPACPI_VIDEO_NEW:
		res = video_autosw_set(1);
		if (res)
			return res;
		res = acpi_evalf(vid_handle, NULL, "VSWT", "v");
		break;
	default:
		return -ENOSYS;
	}
	if (!autosw && video_autosw_set(autosw)) {
		printk(IBM_ERR "video auto-switch left enabled due to error\n");
		return -EIO;
1866 1867
	}

1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886
	return (res)? 0 : -EIO;
}

static int video_expand_toggle(void)
{
	switch (video_supported) {
	case TPACPI_VIDEO_570:
		return acpi_evalf(ec_handle, NULL, "_Q17", "v")?
			0 : -EIO;
	case TPACPI_VIDEO_770:
		return acpi_evalf(vid_handle, NULL, "VEXP", "v")?
			0 : -EIO;
	case TPACPI_VIDEO_NEW:
		return acpi_evalf(NULL, NULL, "\\VEXP", "v")?
			0 : -EIO;
	default:
		return -ENOSYS;
	}
	/* not reached */
1887 1888
}

1889 1890
static int video_read(char *p)
{
1891
	int status, autosw;
1892 1893
	int len = 0;

1894
	if (video_supported == TPACPI_VIDEO_NONE) {
1895 1896 1897 1898
		len += sprintf(p + len, "status:\t\tnot supported\n");
		return len;
	}

1899 1900 1901 1902 1903 1904 1905 1906
	status = video_outputsw_get();
	if (status < 0)
		return status;

	autosw = video_autosw_get();
	if (autosw < 0)
		return autosw;

1907 1908 1909
	len += sprintf(p + len, "status:\t\tsupported\n");
	len += sprintf(p + len, "lcd:\t\t%s\n", enabled(status, 0));
	len += sprintf(p + len, "crt:\t\t%s\n", enabled(status, 1));
1910
	if (video_supported == TPACPI_VIDEO_NEW)
1911 1912 1913 1914
		len += sprintf(p + len, "dvi:\t\t%s\n", enabled(status, 3));
	len += sprintf(p + len, "auto:\t\t%s\n", enabled(autosw, 0));
	len += sprintf(p + len, "commands:\tlcd_enable, lcd_disable\n");
	len += sprintf(p + len, "commands:\tcrt_enable, crt_disable\n");
1915
	if (video_supported == TPACPI_VIDEO_NEW)
1916 1917 1918 1919 1920 1921 1922
		len += sprintf(p + len, "commands:\tdvi_enable, dvi_disable\n");
	len += sprintf(p + len, "commands:\tauto_enable, auto_disable\n");
	len += sprintf(p + len, "commands:\tvideo_switch, expand_toggle\n");

	return len;
}

1923
static int video_write(char *buf)
L
Linus Torvalds 已提交
1924 1925 1926
{
	char *cmd;
	int enable, disable, status;
1927
	int res;
L
Linus Torvalds 已提交
1928

1929
	if (video_supported == TPACPI_VIDEO_NONE)
1930 1931
		return -ENODEV;

1932 1933
	enable = 0;
	disable = 0;
L
Linus Torvalds 已提交
1934 1935 1936

	while ((cmd = next_cmd(&buf))) {
		if (strlencmp(cmd, "lcd_enable") == 0) {
1937
			enable |= TP_ACPI_VIDEO_S_LCD;
L
Linus Torvalds 已提交
1938
		} else if (strlencmp(cmd, "lcd_disable") == 0) {
1939
			disable |= TP_ACPI_VIDEO_S_LCD;
L
Linus Torvalds 已提交
1940
		} else if (strlencmp(cmd, "crt_enable") == 0) {
1941
			enable |= TP_ACPI_VIDEO_S_CRT;
L
Linus Torvalds 已提交
1942
		} else if (strlencmp(cmd, "crt_disable") == 0) {
1943
			disable |= TP_ACPI_VIDEO_S_CRT;
1944
		} else if (video_supported == TPACPI_VIDEO_NEW &&
1945
			   strlencmp(cmd, "dvi_enable") == 0) {
1946
			enable |= TP_ACPI_VIDEO_S_DVI;
1947
		} else if (video_supported == TPACPI_VIDEO_NEW &&
1948
			   strlencmp(cmd, "dvi_disable") == 0) {
1949
			disable |= TP_ACPI_VIDEO_S_DVI;
L
Linus Torvalds 已提交
1950
		} else if (strlencmp(cmd, "auto_enable") == 0) {
1951 1952 1953
			res = video_autosw_set(1);
			if (res)
				return res;
L
Linus Torvalds 已提交
1954
		} else if (strlencmp(cmd, "auto_disable") == 0) {
1955 1956 1957
			res = video_autosw_set(0);
			if (res)
				return res;
L
Linus Torvalds 已提交
1958
		} else if (strlencmp(cmd, "video_switch") == 0) {
1959 1960 1961
			res = video_outputsw_cycle();
			if (res)
				return res;
L
Linus Torvalds 已提交
1962
		} else if (strlencmp(cmd, "expand_toggle") == 0) {
1963 1964 1965
			res = video_expand_toggle();
			if (res)
				return res;
L
Linus Torvalds 已提交
1966 1967 1968 1969 1970
		} else
			return -EINVAL;
	}

	if (enable || disable) {
1971 1972 1973 1974 1975 1976
		status = video_outputsw_get();
		if (status < 0)
			return status;
		res = video_outputsw_set((status & ~disable) | enable);
		if (res)
			return res;
L
Linus Torvalds 已提交
1977 1978 1979 1980 1981
	}

	return 0;
}

1982 1983 1984 1985 1986 1987 1988
static struct ibm_struct video_driver_data = {
	.name = "video",
	.read = video_read,
	.write = video_write,
	.exit = video_exit,
};

1989 1990 1991
/*************************************************************************
 * Light (thinklight) subdriver
 */
L
Linus Torvalds 已提交
1992

1993 1994 1995
IBM_HANDLE(lght, root, "\\LGHT");	/* A21e, A2xm/p, T20-22, X20-21 */
IBM_HANDLE(ledb, ec, "LEDB");		/* G4x */

1996
static int __init light_init(struct ibm_init_struct *iibm)
L
Linus Torvalds 已提交
1997
{
1998 1999
	vdbg_printk(TPACPI_DBG_INIT, "initializing light subdriver\n");

2000 2001 2002
	IBM_ACPIHANDLE_INIT(ledb);
	IBM_ACPIHANDLE_INIT(lght);
	IBM_ACPIHANDLE_INIT(cmos);
2003

2004
	/* light not supported on 570, 600e/x, 770e, 770x, G4x, R30, R31 */
2005
	tp_features.light = (cmos_handle || lght_handle) && !ledb_handle;
2006

2007
	if (tp_features.light)
2008 2009
		/* light status not supported on
		   570, 600e/x, 770e, 770x, G4x, R30, R31, R32, X20 */
2010 2011
		tp_features.light_status =
			acpi_evalf(ec_handle, NULL, "KBLT", "qv");
L
Linus Torvalds 已提交
2012

2013
	vdbg_printk(TPACPI_DBG_INIT, "light is %s\n",
2014
		str_supported(tp_features.light));
2015

2016
	return (tp_features.light)? 0 : 1;
L
Linus Torvalds 已提交
2017 2018
}

2019
static int light_read(char *p)
L
Linus Torvalds 已提交
2020 2021 2022 2023
{
	int len = 0;
	int status = 0;

2024
	if (!tp_features.light) {
2025
		len += sprintf(p + len, "status:\t\tnot supported\n");
2026
	} else if (!tp_features.light_status) {
2027 2028 2029
		len += sprintf(p + len, "status:\t\tunknown\n");
		len += sprintf(p + len, "commands:\ton, off\n");
	} else {
L
Linus Torvalds 已提交
2030 2031 2032
		if (!acpi_evalf(ec_handle, &status, "KBLT", "d"))
			return -EIO;
		len += sprintf(p + len, "status:\t\t%s\n", onoff(status, 0));
2033 2034
		len += sprintf(p + len, "commands:\ton, off\n");
	}
L
Linus Torvalds 已提交
2035 2036 2037 2038

	return len;
}

2039
static int light_write(char *buf)
L
Linus Torvalds 已提交
2040 2041 2042 2043
{
	int cmos_cmd, lght_cmd;
	char *cmd;
	int success;
2044

2045
	if (!tp_features.light)
2046 2047
		return -ENODEV;

L
Linus Torvalds 已提交
2048 2049 2050 2051 2052 2053 2054 2055 2056
	while ((cmd = next_cmd(&buf))) {
		if (strlencmp(cmd, "on") == 0) {
			cmos_cmd = 0x0c;
			lght_cmd = 1;
		} else if (strlencmp(cmd, "off") == 0) {
			cmos_cmd = 0x0d;
			lght_cmd = 0;
		} else
			return -EINVAL;
2057

L
Linus Torvalds 已提交
2058
		success = cmos_handle ?
2059 2060
		    acpi_evalf(cmos_handle, NULL, NULL, "vd", cmos_cmd) :
		    acpi_evalf(lght_handle, NULL, NULL, "vd", lght_cmd);
L
Linus Torvalds 已提交
2061 2062 2063 2064 2065 2066 2067
		if (!success)
			return -EIO;
	}

	return 0;
}

2068 2069 2070 2071 2072 2073
static struct ibm_struct light_driver_data = {
	.name = "light",
	.read = light_read,
	.write = light_write,
};

2074 2075 2076
/*************************************************************************
 * Dock subdriver
 */
L
Linus Torvalds 已提交
2077

2078
#ifdef CONFIG_THINKPAD_ACPI_DOCK
2079 2080 2081 2082 2083 2084 2085

IBM_HANDLE(dock, root, "\\_SB.GDCK",	/* X30, X31, X40 */
	   "\\_SB.PCI0.DOCK",	/* 600e/x,770e,770x,A2xm/p,T20-22,X20-21 */
	   "\\_SB.PCI0.PCI1.DOCK",	/* all others */
	   "\\_SB.PCI.ISA.SLCE",	/* 570 */
    );				/* A21e,G4x,R30,R31,R32,R40,R40e,R50e */

2086 2087 2088
/* don't list other alternatives as we install a notify handler on the 570 */
IBM_HANDLE(pci, root, "\\_SB.PCI");	/* 570 */

2089 2090 2091 2092 2093
static const struct acpi_device_id ibm_pci_device_ids[] = {
	{PCI_ROOT_HID_STRING, 0},
	{"", 0},
};

2094 2095 2096 2097 2098 2099 2100
static struct tp_acpi_drv_struct ibm_dock_acpidriver[2] = {
	{
	 .notify = dock_notify,
	 .handle = &dock_handle,
	 .type = ACPI_SYSTEM_NOTIFY,
	},
	{
2101 2102 2103
	/* THIS ONE MUST NEVER BE USED FOR DRIVER AUTOLOADING.
	 * We just use it to get notifications of dock hotplug
	 * in very old thinkpads */
2104
	 .hid = ibm_pci_device_ids,
2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123
	 .notify = dock_notify,
	 .handle = &pci_handle,
	 .type = ACPI_SYSTEM_NOTIFY,
	},
};

static struct ibm_struct dock_driver_data[2] = {
	{
	 .name = "dock",
	 .read = dock_read,
	 .write = dock_write,
	 .acpi = &ibm_dock_acpidriver[0],
	},
	{
	 .name = "dock",
	 .acpi = &ibm_dock_acpidriver[1],
	},
};

L
Linus Torvalds 已提交
2124 2125
#define dock_docked() (_sta(dock_handle) & 1)

2126
static int __init dock_init(struct ibm_init_struct *iibm)
2127
{
2128 2129
	vdbg_printk(TPACPI_DBG_INIT, "initializing dock subdriver\n");

2130
	IBM_ACPIHANDLE_INIT(dock);
2131

2132 2133 2134
	vdbg_printk(TPACPI_DBG_INIT, "dock is %s\n",
		str_supported(dock_handle != NULL));

2135 2136 2137
	return (dock_handle)? 0 : 1;
}

2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159
static int __init dock_init2(struct ibm_init_struct *iibm)
{
	int dock2_needed;

	vdbg_printk(TPACPI_DBG_INIT, "initializing dock subdriver part 2\n");

	if (dock_driver_data[0].flags.acpi_driver_registered &&
	    dock_driver_data[0].flags.acpi_notify_installed) {
		IBM_ACPIHANDLE_INIT(pci);
		dock2_needed = (pci_handle != NULL);
		vdbg_printk(TPACPI_DBG_INIT,
			    "dock PCI handler for the TP 570 is %s\n",
			    str_supported(dock2_needed));
	} else {
		vdbg_printk(TPACPI_DBG_INIT,
		"dock subdriver part 2 not required\n");
		dock2_needed = 0;
	}

	return (dock2_needed)? 0 : 1;
}

2160 2161 2162
static void dock_notify(struct ibm_struct *ibm, u32 event)
{
	int docked = dock_docked();
2163 2164
	int pci = ibm->acpi->hid && ibm->acpi->device &&
		acpi_match_device_ids(ibm->acpi->device, ibm_pci_device_ids);
2165
	int data;
2166 2167

	if (event == 1 && !pci)	/* 570 */
2168
		data = 1;	/* button */
2169
	else if (event == 1 && pci)	/* 570 */
2170
		data = 3;	/* dock */
2171
	else if (event == 3 && docked)
2172
		data = 1;	/* button */
2173
	else if (event == 3 && !docked)
2174
		data = 2;	/* undock */
2175
	else if (event == 0 && docked)
2176
		data = 3;	/* dock */
2177 2178 2179
	else {
		printk(IBM_ERR "unknown dock event %d, status %d\n",
		       event, _sta(dock_handle));
2180
		data = 0;	/* unknown */
2181
	}
2182 2183 2184 2185
	acpi_bus_generate_event(ibm->acpi->device, event, data);
	acpi_bus_generate_netlink_event(ibm->acpi->device->pnp.device_class,
					  ibm->acpi->device->dev.bus_id,
					  event, data);
2186 2187
}

2188
static int dock_read(char *p)
L
Linus Torvalds 已提交
2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204
{
	int len = 0;
	int docked = dock_docked();

	if (!dock_handle)
		len += sprintf(p + len, "status:\t\tnot supported\n");
	else if (!docked)
		len += sprintf(p + len, "status:\t\tundocked\n");
	else {
		len += sprintf(p + len, "status:\t\tdocked\n");
		len += sprintf(p + len, "commands:\tdock, undock\n");
	}

	return len;
}

2205
static int dock_write(char *buf)
L
Linus Torvalds 已提交
2206 2207 2208 2209
{
	char *cmd;

	if (!dock_docked())
2210
		return -ENODEV;
L
Linus Torvalds 已提交
2211 2212 2213

	while ((cmd = next_cmd(&buf))) {
		if (strlencmp(cmd, "undock") == 0) {
2214 2215
			if (!acpi_evalf(dock_handle, NULL, "_DCK", "vd", 0) ||
			    !acpi_evalf(dock_handle, NULL, "_EJ0", "vd", 1))
2216 2217 2218 2219 2220 2221
				return -EIO;
		} else if (strlencmp(cmd, "dock") == 0) {
			if (!acpi_evalf(dock_handle, NULL, "_DCK", "vd", 1))
				return -EIO;
		} else
			return -EINVAL;
L
Linus Torvalds 已提交
2222
	}
2223 2224

	return 0;
L
Linus Torvalds 已提交
2225
}
2226

2227
#endif /* CONFIG_THINKPAD_ACPI_DOCK */
2228 2229 2230 2231

/*************************************************************************
 * Bay subdriver
 */
L
Linus Torvalds 已提交
2232

2233
#ifdef CONFIG_THINKPAD_ACPI_BAY
2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
IBM_HANDLE(bay, root, "\\_SB.PCI.IDE.SECN.MAST",	/* 570 */
	   "\\_SB.PCI0.IDE0.IDES.IDSM",	/* 600e/x, 770e, 770x */
	   "\\_SB.PCI0.SATA.SCND.MSTR",	/* T60, X60, Z60 */
	   "\\_SB.PCI0.IDE0.SCND.MSTR",	/* all others */
	   );				/* A21e, R30, R31 */
IBM_HANDLE(bay_ej, bay, "_EJ3",	/* 600e/x, A2xm/p, A3x */
	   "_EJ0",		/* all others */
	   );			/* 570,A21e,G4x,R30,R31,R32,R40e,R50e */
IBM_HANDLE(bay2, root, "\\_SB.PCI0.IDE0.PRIM.SLAV",	/* A3x, R32 */
	   "\\_SB.PCI0.IDE0.IDEP.IDPS",	/* 600e/x, 770e, 770x */
	   );				/* all others */
IBM_HANDLE(bay2_ej, bay2, "_EJ3",	/* 600e/x, 770e, A3x */
	   "_EJ0",			/* 770x */
	   );				/* all others */

2249
static int __init bay_init(struct ibm_init_struct *iibm)
L
Linus Torvalds 已提交
2250
{
2251 2252
	vdbg_printk(TPACPI_DBG_INIT, "initializing bay subdriver\n");

2253
	IBM_ACPIHANDLE_INIT(bay);
2254
	if (bay_handle)
2255 2256
		IBM_ACPIHANDLE_INIT(bay_ej);
	IBM_ACPIHANDLE_INIT(bay2);
2257
	if (bay2_handle)
2258
		IBM_ACPIHANDLE_INIT(bay2_ej);
2259

2260 2261 2262 2263
	tp_features.bay_status = bay_handle &&
		acpi_evalf(bay_handle, NULL, "_STA", "qv");
	tp_features.bay_status2 = bay2_handle &&
		acpi_evalf(bay2_handle, NULL, "_STA", "qv");
2264

2265 2266 2267 2268
	tp_features.bay_eject = bay_handle && bay_ej_handle &&
		(strlencmp(bay_ej_path, "_EJ0") == 0 || experimental);
	tp_features.bay_eject2 = bay2_handle && bay2_ej_handle &&
		(strlencmp(bay2_ej_path, "_EJ0") == 0 || experimental);
L
Linus Torvalds 已提交
2269

2270 2271
	vdbg_printk(TPACPI_DBG_INIT,
		"bay 1: status %s, eject %s; bay 2: status %s, eject %s\n",
2272 2273 2274 2275
		str_supported(tp_features.bay_status),
		str_supported(tp_features.bay_eject),
		str_supported(tp_features.bay_status2),
		str_supported(tp_features.bay_eject2));
2276

2277 2278
	return (tp_features.bay_status || tp_features.bay_eject ||
		tp_features.bay_status2 || tp_features.bay_eject2)? 0 : 1;
L
Linus Torvalds 已提交
2279 2280
}

2281 2282
static void bay_notify(struct ibm_struct *ibm, u32 event)
{
2283
	acpi_bus_generate_event(ibm->acpi->device, event, 0);
2284 2285 2286
	acpi_bus_generate_netlink_event(ibm->acpi->device->pnp.device_class,
					  ibm->acpi->device->dev.bus_id,
					  event, 0);
2287 2288
}

2289 2290 2291
#define bay_occupied(b) (_sta(b##_handle) & 1)

static int bay_read(char *p)
L
Linus Torvalds 已提交
2292 2293
{
	int len = 0;
2294 2295 2296 2297
	int occupied = bay_occupied(bay);
	int occupied2 = bay_occupied(bay2);
	int eject, eject2;

2298 2299 2300 2301 2302
	len += sprintf(p + len, "status:\t\t%s\n",
		tp_features.bay_status ?
			(occupied ? "occupied" : "unoccupied") :
				"not supported");
	if (tp_features.bay_status2)
2303 2304 2305
		len += sprintf(p + len, "status2:\t%s\n", occupied2 ?
			       "occupied" : "unoccupied");

2306 2307
	eject = tp_features.bay_eject && occupied;
	eject2 = tp_features.bay_eject2 && occupied2;
2308 2309 2310 2311

	if (eject && eject2)
		len += sprintf(p + len, "commands:\teject, eject2\n");
	else if (eject)
L
Linus Torvalds 已提交
2312
		len += sprintf(p + len, "commands:\teject\n");
2313 2314
	else if (eject2)
		len += sprintf(p + len, "commands:\teject2\n");
L
Linus Torvalds 已提交
2315 2316 2317 2318

	return len;
}

2319
static int bay_write(char *buf)
L
Linus Torvalds 已提交
2320 2321 2322
{
	char *cmd;

2323
	if (!tp_features.bay_eject && !tp_features.bay_eject2)
2324 2325
		return -ENODEV;

L
Linus Torvalds 已提交
2326
	while ((cmd = next_cmd(&buf))) {
2327
		if (tp_features.bay_eject && strlencmp(cmd, "eject") == 0) {
2328 2329
			if (!acpi_evalf(bay_ej_handle, NULL, NULL, "vd", 1))
				return -EIO;
2330
		} else if (tp_features.bay_eject2 &&
2331 2332
			   strlencmp(cmd, "eject2") == 0) {
			if (!acpi_evalf(bay2_ej_handle, NULL, NULL, "vd", 1))
L
Linus Torvalds 已提交
2333 2334 2335 2336 2337 2338
				return -EIO;
		} else
			return -EINVAL;
	}

	return 0;
2339
}
2340

2341 2342 2343 2344 2345 2346
static struct tp_acpi_drv_struct ibm_bay_acpidriver = {
	.notify = bay_notify,
	.handle = &bay_handle,
	.type = ACPI_SYSTEM_NOTIFY,
};

2347 2348 2349 2350
static struct ibm_struct bay_driver_data = {
	.name = "bay",
	.read = bay_read,
	.write = bay_write,
2351
	.acpi = &ibm_bay_acpidriver,
2352 2353
};

2354
#endif /* CONFIG_THINKPAD_ACPI_BAY */
L
Linus Torvalds 已提交
2355

2356 2357 2358 2359
/*************************************************************************
 * CMOS subdriver
 */

2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379
/* sysfs cmos_command -------------------------------------------------- */
static ssize_t cmos_command_store(struct device *dev,
			    struct device_attribute *attr,
			    const char *buf, size_t count)
{
	unsigned long cmos_cmd;
	int res;

	if (parse_strtoul(buf, 21, &cmos_cmd))
		return -EINVAL;

	res = issue_thinkpad_cmos_command(cmos_cmd);
	return (res)? res : count;
}

static struct device_attribute dev_attr_cmos_command =
	__ATTR(cmos_command, S_IWUSR, NULL, cmos_command_store);

/* --------------------------------------------------------------------- */

2380
static int __init cmos_init(struct ibm_init_struct *iibm)
2381
{
2382 2383
	int res;

2384 2385 2386
	vdbg_printk(TPACPI_DBG_INIT,
		"initializing cmos commands subdriver\n");

2387
	IBM_ACPIHANDLE_INIT(cmos);
2388

2389 2390
	vdbg_printk(TPACPI_DBG_INIT, "cmos commands are %s\n",
		str_supported(cmos_handle != NULL));
2391 2392 2393 2394 2395

	res = device_create_file(&tpacpi_pdev->dev, &dev_attr_cmos_command);
	if (res)
		return res;

2396 2397 2398
	return (cmos_handle)? 0 : 1;
}

2399 2400 2401 2402 2403
static void cmos_exit(void)
{
	device_remove_file(&tpacpi_pdev->dev, &dev_attr_cmos_command);
}

2404
static int cmos_read(char *p)
L
Linus Torvalds 已提交
2405 2406 2407
{
	int len = 0;

2408 2409
	/* cmos not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
	   R30, R31, T20-22, X20-21 */
L
Linus Torvalds 已提交
2410 2411 2412 2413
	if (!cmos_handle)
		len += sprintf(p + len, "status:\t\tnot supported\n");
	else {
		len += sprintf(p + len, "status:\t\tsupported\n");
2414
		len += sprintf(p + len, "commands:\t<cmd> (<cmd> is 0-21)\n");
L
Linus Torvalds 已提交
2415 2416 2417 2418 2419
	}

	return len;
}

2420
static int cmos_write(char *buf)
L
Linus Torvalds 已提交
2421 2422
{
	char *cmd;
2423
	int cmos_cmd, res;
L
Linus Torvalds 已提交
2424 2425

	while ((cmd = next_cmd(&buf))) {
2426 2427
		if (sscanf(cmd, "%u", &cmos_cmd) == 1 &&
		    cmos_cmd >= 0 && cmos_cmd <= 21) {
L
Linus Torvalds 已提交
2428 2429 2430 2431
			/* cmos_cmd set */
		} else
			return -EINVAL;

2432 2433 2434
		res = issue_thinkpad_cmos_command(cmos_cmd);
		if (res)
			return res;
L
Linus Torvalds 已提交
2435 2436 2437
	}

	return 0;
2438 2439
}

2440 2441 2442 2443
static struct ibm_struct cmos_driver_data = {
	.name = "cmos",
	.read = cmos_read,
	.write = cmos_write,
2444
	.exit = cmos_exit,
2445
};
2446 2447 2448 2449 2450

/*************************************************************************
 * LED subdriver
 */

2451
static enum led_access_mode led_supported;
2452

2453 2454 2455 2456 2457
IBM_HANDLE(led, ec, "SLED",	/* 570 */
	   "SYSL",		/* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
	   "LED",		/* all others */
	   );			/* R30, R31 */

2458
static int __init led_init(struct ibm_init_struct *iibm)
2459
{
2460 2461
	vdbg_printk(TPACPI_DBG_INIT, "initializing LED subdriver\n");

2462
	IBM_ACPIHANDLE_INIT(led);
2463

2464 2465
	if (!led_handle)
		/* led not supported on R30, R31 */
2466
		led_supported = TPACPI_LED_NONE;
2467 2468
	else if (strlencmp(led_path, "SLED") == 0)
		/* 570 */
2469
		led_supported = TPACPI_LED_570;
2470 2471
	else if (strlencmp(led_path, "SYSL") == 0)
		/* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
2472
		led_supported = TPACPI_LED_OLD;
2473 2474
	else
		/* all others */
2475
		led_supported = TPACPI_LED_NEW;
2476

2477 2478 2479
	vdbg_printk(TPACPI_DBG_INIT, "LED commands are %s, mode %d\n",
		str_supported(led_supported), led_supported);

2480
	return (led_supported != TPACPI_LED_NONE)? 0 : 1;
2481 2482 2483 2484 2485
}

#define led_status(s) ((s) == 0 ? "off" : ((s) == 1 ? "on" : "blinking"))

static int led_read(char *p)
L
Linus Torvalds 已提交
2486 2487 2488
{
	int len = 0;

2489 2490 2491 2492 2493 2494
	if (!led_supported) {
		len += sprintf(p + len, "status:\t\tnot supported\n");
		return len;
	}
	len += sprintf(p + len, "status:\t\tsupported\n");

2495
	if (led_supported == TPACPI_LED_570) {
2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506
		/* 570 */
		int i, status;
		for (i = 0; i < 8; i++) {
			if (!acpi_evalf(ec_handle,
					&status, "GLED", "dd", 1 << i))
				return -EIO;
			len += sprintf(p + len, "%d:\t\t%s\n",
				       i, led_status(status));
		}
	}

L
Linus Torvalds 已提交
2507
	len += sprintf(p + len, "commands:\t"
2508
		       "<led> on, <led> off, <led> blink (<led> is 0-7)\n");
L
Linus Torvalds 已提交
2509 2510 2511 2512

	return len;
}

2513 2514 2515 2516 2517 2518 2519
/* off, on, blink */
static const int led_sled_arg1[] = { 0, 1, 3 };
static const int led_exp_hlbl[] = { 0, 0, 1 };	/* led# * */
static const int led_exp_hlcl[] = { 0, 1, 1 };	/* led# * */
static const int led_led_arg1[] = { 0, 0x80, 0xc0 };

static int led_write(char *buf)
L
Linus Torvalds 已提交
2520 2521
{
	char *cmd;
2522 2523 2524 2525
	int led, ind, ret;

	if (!led_supported)
		return -ENODEV;
L
Linus Torvalds 已提交
2526 2527

	while ((cmd = next_cmd(&buf))) {
2528
		if (sscanf(cmd, "%d", &led) != 1 || led < 0 || led > 7)
L
Linus Torvalds 已提交
2529 2530
			return -EINVAL;

2531 2532
		if (strstr(cmd, "off")) {
			ind = 0;
L
Linus Torvalds 已提交
2533
		} else if (strstr(cmd, "on")) {
2534 2535 2536
			ind = 1;
		} else if (strstr(cmd, "blink")) {
			ind = 2;
L
Linus Torvalds 已提交
2537 2538
		} else
			return -EINVAL;
2539

2540
		if (led_supported == TPACPI_LED_570) {
2541 2542
			/* 570 */
			led = 1 << led;
L
Linus Torvalds 已提交
2543
			if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
2544
					led, led_sled_arg1[ind]))
L
Linus Torvalds 已提交
2545
				return -EIO;
2546
		} else if (led_supported == TPACPI_LED_OLD) {
2547 2548
			/* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20 */
			led = 1 << led;
2549
			ret = ec_write(TPACPI_LED_EC_HLMS, led);
2550 2551
			if (ret >= 0)
				ret =
2552
				    ec_write(TPACPI_LED_EC_HLBL,
2553
				    	     led * led_exp_hlbl[ind]);
2554 2555
			if (ret >= 0)
				ret =
2556
				    ec_write(TPACPI_LED_EC_HLCL,
2557
				    	     led * led_exp_hlcl[ind]);
2558 2559 2560 2561 2562 2563
			if (ret < 0)
				return ret;
		} else {
			/* all others */
			if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
					led, led_led_arg1[ind]))
L
Linus Torvalds 已提交
2564
				return -EIO;
2565 2566 2567 2568 2569 2570
		}
	}

	return 0;
}

2571 2572 2573 2574 2575 2576
static struct ibm_struct led_driver_data = {
	.name = "led",
	.read = led_read,
	.write = led_write,
};

2577 2578 2579 2580 2581 2582
/*************************************************************************
 * Beep subdriver
 */

IBM_HANDLE(beep, ec, "BEEP");	/* all except R30, R31 */

2583
static int __init beep_init(struct ibm_init_struct *iibm)
2584
{
2585 2586
	vdbg_printk(TPACPI_DBG_INIT, "initializing beep subdriver\n");

2587
	IBM_ACPIHANDLE_INIT(beep);
2588

2589 2590 2591
	vdbg_printk(TPACPI_DBG_INIT, "beep is %s\n",
		str_supported(beep_handle != NULL));

2592 2593 2594
	return (beep_handle)? 0 : 1;
}

2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629
static int beep_read(char *p)
{
	int len = 0;

	if (!beep_handle)
		len += sprintf(p + len, "status:\t\tnot supported\n");
	else {
		len += sprintf(p + len, "status:\t\tsupported\n");
		len += sprintf(p + len, "commands:\t<cmd> (<cmd> is 0-17)\n");
	}

	return len;
}

static int beep_write(char *buf)
{
	char *cmd;
	int beep_cmd;

	if (!beep_handle)
		return -ENODEV;

	while ((cmd = next_cmd(&buf))) {
		if (sscanf(cmd, "%u", &beep_cmd) == 1 &&
		    beep_cmd >= 0 && beep_cmd <= 17) {
			/* beep_cmd set */
		} else
			return -EINVAL;
		if (!acpi_evalf(beep_handle, NULL, NULL, "vdd", beep_cmd, 0))
			return -EIO;
	}

	return 0;
}

2630 2631 2632 2633 2634 2635
static struct ibm_struct beep_driver_data = {
	.name = "beep",
	.read = beep_read,
	.write = beep_write,
};

2636 2637 2638
/*************************************************************************
 * Thermal subdriver
 */
2639

2640
static enum thermal_access_mode thermal_read_mode;
2641

2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720
/* sysfs temp##_input -------------------------------------------------- */

static ssize_t thermal_temp_input_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	struct sensor_device_attribute *sensor_attr =
					to_sensor_dev_attr(attr);
	int idx = sensor_attr->index;
	s32 value;
	int res;

	res = thermal_get_sensor(idx, &value);
	if (res)
		return res;
	if (value == TP_EC_THERMAL_TMP_NA * 1000)
		return -ENXIO;

	return snprintf(buf, PAGE_SIZE, "%d\n", value);
}

#define THERMAL_SENSOR_ATTR_TEMP(_idxA, _idxB) \
	 SENSOR_ATTR(temp##_idxA##_input, S_IRUGO, thermal_temp_input_show, NULL, _idxB)

static struct sensor_device_attribute sensor_dev_attr_thermal_temp_input[] = {
	THERMAL_SENSOR_ATTR_TEMP(1, 0),
	THERMAL_SENSOR_ATTR_TEMP(2, 1),
	THERMAL_SENSOR_ATTR_TEMP(3, 2),
	THERMAL_SENSOR_ATTR_TEMP(4, 3),
	THERMAL_SENSOR_ATTR_TEMP(5, 4),
	THERMAL_SENSOR_ATTR_TEMP(6, 5),
	THERMAL_SENSOR_ATTR_TEMP(7, 6),
	THERMAL_SENSOR_ATTR_TEMP(8, 7),
	THERMAL_SENSOR_ATTR_TEMP(9, 8),
	THERMAL_SENSOR_ATTR_TEMP(10, 9),
	THERMAL_SENSOR_ATTR_TEMP(11, 10),
	THERMAL_SENSOR_ATTR_TEMP(12, 11),
	THERMAL_SENSOR_ATTR_TEMP(13, 12),
	THERMAL_SENSOR_ATTR_TEMP(14, 13),
	THERMAL_SENSOR_ATTR_TEMP(15, 14),
	THERMAL_SENSOR_ATTR_TEMP(16, 15),
};

#define THERMAL_ATTRS(X) \
	&sensor_dev_attr_thermal_temp_input[X].dev_attr.attr

static struct attribute *thermal_temp_input_attr[] = {
	THERMAL_ATTRS(8),
	THERMAL_ATTRS(9),
	THERMAL_ATTRS(10),
	THERMAL_ATTRS(11),
	THERMAL_ATTRS(12),
	THERMAL_ATTRS(13),
	THERMAL_ATTRS(14),
	THERMAL_ATTRS(15),
	THERMAL_ATTRS(0),
	THERMAL_ATTRS(1),
	THERMAL_ATTRS(2),
	THERMAL_ATTRS(3),
	THERMAL_ATTRS(4),
	THERMAL_ATTRS(5),
	THERMAL_ATTRS(6),
	THERMAL_ATTRS(7),
	NULL
};

static const struct attribute_group thermal_temp_input16_group = {
	.attrs = thermal_temp_input_attr
};

static const struct attribute_group thermal_temp_input8_group = {
	.attrs = &thermal_temp_input_attr[8]
};

#undef THERMAL_SENSOR_ATTR_TEMP
#undef THERMAL_ATTRS

/* --------------------------------------------------------------------- */

2721
static int __init thermal_init(struct ibm_init_struct *iibm)
2722
{
2723 2724
	u8 t, ta1, ta2;
	int i;
2725
	int acpi_tmp7;
2726
	int res;
2727

2728 2729
	vdbg_printk(TPACPI_DBG_INIT, "initializing thermal subdriver\n");

2730
	acpi_tmp7 = acpi_evalf(ec_handle, NULL, "TMP7", "qv");
2731

2732
	if (thinkpad_id.ec_model) {
2733 2734 2735 2736 2737 2738
		/*
		 * Direct EC access mode: sensors at registers
		 * 0x78-0x7F, 0xC0-0xC7.  Registers return 0x00 for
		 * non-implemented, thermal sensors return 0x80 when
		 * not available
		 */
2739

2740 2741
		ta1 = ta2 = 0;
		for (i = 0; i < 8; i++) {
2742
			if (acpi_ec_read(TP_EC_THERMAL_TMP0 + i, &t)) {
2743 2744 2745 2746 2747
				ta1 |= t;
			} else {
				ta1 = 0;
				break;
			}
2748
			if (acpi_ec_read(TP_EC_THERMAL_TMP8 + i, &t)) {
2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760
				ta2 |= t;
			} else {
				ta1 = 0;
				break;
			}
		}
		if (ta1 == 0) {
			/* This is sheer paranoia, but we handle it anyway */
			if (acpi_tmp7) {
				printk(IBM_ERR
				       "ThinkPad ACPI EC access misbehaving, "
				       "falling back to ACPI TMPx access mode\n");
2761
				thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
2762 2763 2764 2765
			} else {
				printk(IBM_ERR
				       "ThinkPad ACPI EC access misbehaving, "
				       "disabling thermal sensors access\n");
2766
				thermal_read_mode = TPACPI_THERMAL_NONE;
2767 2768 2769 2770
			}
		} else {
			thermal_read_mode =
			    (ta2 != 0) ?
2771
			    TPACPI_THERMAL_TPEC_16 : TPACPI_THERMAL_TPEC_8;
2772 2773
		}
	} else if (acpi_tmp7) {
2774 2775
		if (acpi_evalf(ec_handle, NULL, "UPDT", "qv")) {
			/* 600e/x, 770e, 770x */
2776
			thermal_read_mode = TPACPI_THERMAL_ACPI_UPDT;
2777 2778
		} else {
			/* Standard ACPI TMPx access, max 8 sensors */
2779
			thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
2780 2781 2782
		}
	} else {
		/* temperatures not supported on 570, G4x, R30, R31, R32 */
2783
		thermal_read_mode = TPACPI_THERMAL_NONE;
2784
	}
2785

2786 2787 2788 2789
	vdbg_printk(TPACPI_DBG_INIT, "thermal is %s, mode %d\n",
		str_supported(thermal_read_mode != TPACPI_THERMAL_NONE),
		thermal_read_mode);

2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829
	switch(thermal_read_mode) {
	case TPACPI_THERMAL_TPEC_16:
		res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
				&thermal_temp_input16_group);
		if (res)
			return res;
		break;
	case TPACPI_THERMAL_TPEC_8:
	case TPACPI_THERMAL_ACPI_TMP07:
	case TPACPI_THERMAL_ACPI_UPDT:
		res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
				&thermal_temp_input8_group);
		if (res)
			return res;
		break;
	case TPACPI_THERMAL_NONE:
	default:
		return 1;
	}

	return 0;
}

static void thermal_exit(void)
{
	switch(thermal_read_mode) {
	case TPACPI_THERMAL_TPEC_16:
		sysfs_remove_group(&tpacpi_pdev->dev.kobj,
				   &thermal_temp_input16_group);
		break;
	case TPACPI_THERMAL_TPEC_8:
	case TPACPI_THERMAL_ACPI_TMP07:
	case TPACPI_THERMAL_ACPI_UPDT:
		sysfs_remove_group(&tpacpi_pdev->dev.kobj,
				   &thermal_temp_input16_group);
		break;
	case TPACPI_THERMAL_NONE:
	default:
		break;
	}
2830 2831
}

2832 2833
/* idx is zero-based */
static int thermal_get_sensor(int idx, s32 *value)
2834
{
2835
	int t;
2836
	s8 tmp;
2837
	char tmpi[5];
2838

2839
	t = TP_EC_THERMAL_TMP0;
2840

2841
	switch (thermal_read_mode) {
2842 2843
#if TPACPI_MAX_THERMAL_SENSORS >= 16
	case TPACPI_THERMAL_TPEC_16:
2844 2845 2846
		if (idx >= 8 && idx <= 15) {
			t = TP_EC_THERMAL_TMP8;
			idx -= 8;
2847 2848 2849
		}
		/* fallthrough */
#endif
2850
	case TPACPI_THERMAL_TPEC_8:
2851 2852
		if (idx <= 7) {
			if (!acpi_ec_read(t + idx, &tmp))
2853
				return -EIO;
2854 2855
			*value = tmp * 1000;
			return 0;
2856
		}
2857
		break;
2858

2859
	case TPACPI_THERMAL_ACPI_UPDT:
2860 2861 2862 2863
		if (idx <= 7) {
			snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx);
			if (!acpi_evalf(ec_handle, NULL, "UPDT", "v"))
				return -EIO;
2864 2865
			if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
				return -EIO;
2866 2867
			*value = (t - 2732) * 100;
			return 0;
2868
		}
2869
		break;
2870

2871
	case TPACPI_THERMAL_ACPI_TMP07:
2872 2873
		if (idx <= 7) {
			snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx);
2874 2875
			if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
				return -EIO;
2876 2877
			if (t > 127 || t < -127)
				t = TP_EC_THERMAL_TMP_NA;
2878 2879
			*value = t * 1000;
			return 0;
2880
		}
2881
		break;
2882

2883
	case TPACPI_THERMAL_NONE:
2884
	default:
2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908
		return -ENOSYS;
	}

	return -EINVAL;
}

static int thermal_get_sensors(struct ibm_thermal_sensors_struct *s)
{
	int res, i;
	int n;

	n = 8;
	i = 0;

	if (!s)
		return -EINVAL;

	if (thermal_read_mode == TPACPI_THERMAL_TPEC_16)
		n = 16;

	for(i = 0 ; i < n; i++) {
		res = thermal_get_sensor(i, &s->temp[i]);
		if (res)
			return res;
2909
	}
2910 2911

	return n;
2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931
}

static int thermal_read(char *p)
{
	int len = 0;
	int n, i;
	struct ibm_thermal_sensors_struct t;

	n = thermal_get_sensors(&t);
	if (unlikely(n < 0))
		return n;

	len += sprintf(p + len, "temperatures:\t");

	if (n > 0) {
		for (i = 0; i < (n - 1); i++)
			len += sprintf(p + len, "%d ", t.temp[i] / 1000);
		len += sprintf(p + len, "%d\n", t.temp[i] / 1000);
	} else
		len += sprintf(p + len, "not supported\n");
2932 2933 2934 2935

	return len;
}

2936 2937 2938
static struct ibm_struct thermal_driver_data = {
	.name = "thermal",
	.read = thermal_read,
2939
	.exit = thermal_exit,
2940 2941
};

2942 2943 2944 2945
/*************************************************************************
 * EC Dump subdriver
 */

2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996
static u8 ecdump_regs[256];

static int ecdump_read(char *p)
{
	int len = 0;
	int i, j;
	u8 v;

	len += sprintf(p + len, "EC      "
		       " +00 +01 +02 +03 +04 +05 +06 +07"
		       " +08 +09 +0a +0b +0c +0d +0e +0f\n");
	for (i = 0; i < 256; i += 16) {
		len += sprintf(p + len, "EC 0x%02x:", i);
		for (j = 0; j < 16; j++) {
			if (!acpi_ec_read(i + j, &v))
				break;
			if (v != ecdump_regs[i + j])
				len += sprintf(p + len, " *%02x", v);
			else
				len += sprintf(p + len, "  %02x", v);
			ecdump_regs[i + j] = v;
		}
		len += sprintf(p + len, "\n");
		if (j != 16)
			break;
	}

	/* These are way too dangerous to advertise openly... */
#if 0
	len += sprintf(p + len, "commands:\t0x<offset> 0x<value>"
		       " (<offset> is 00-ff, <value> is 00-ff)\n");
	len += sprintf(p + len, "commands:\t0x<offset> <value>  "
		       " (<offset> is 00-ff, <value> is 0-255)\n");
#endif
	return len;
}

static int ecdump_write(char *buf)
{
	char *cmd;
	int i, v;

	while ((cmd = next_cmd(&buf))) {
		if (sscanf(cmd, "0x%x 0x%x", &i, &v) == 2) {
			/* i and v set */
		} else if (sscanf(cmd, "0x%x %u", &i, &v) == 2) {
			/* i and v set */
		} else
			return -EINVAL;
		if (i >= 0 && i < 256 && v >= 0 && v < 256) {
			if (!acpi_ec_write(i, v))
L
Linus Torvalds 已提交
2997 2998 2999 3000 3001 3002
				return -EIO;
		} else
			return -EINVAL;
	}

	return 0;
3003 3004
}

3005 3006 3007 3008
static struct ibm_struct ecdump_driver_data = {
	.name = "ecdump",
	.read = ecdump_read,
	.write = ecdump_write,
3009
	.flags.experimental = 1,
3010 3011
};

3012 3013 3014 3015
/*************************************************************************
 * Backlight/brightness subdriver
 */

3016
static struct backlight_device *ibm_backlight_device;
3017 3018 3019 3020 3021 3022

static struct backlight_ops ibm_backlight_data = {
        .get_brightness = brightness_get,
        .update_status  = brightness_update_status,
};

3023 3024
static struct mutex brightness_mutex;

3025
static int __init brightness_init(struct ibm_init_struct *iibm)
3026 3027 3028
{
	int b;

3029 3030
	vdbg_printk(TPACPI_DBG_INIT, "initializing brightness subdriver\n");

3031 3032
	mutex_init(&brightness_mutex);

3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045
	if (!brightness_mode) {
		if (thinkpad_id.vendor == PCI_VENDOR_ID_LENOVO)
			brightness_mode = 2;
		else
			brightness_mode = 3;

		dbg_printk(TPACPI_DBG_INIT, "selected brightness_mode=%d\n",
			brightness_mode);
	}

	if (brightness_mode > 3)
		return -EINVAL;

3046 3047
	b = brightness_get(NULL);
	if (b < 0)
3048
		return 1;
3049

3050 3051 3052
	ibm_backlight_device = backlight_device_register(
					TPACPI_BACKLIGHT_DEV_NAME, NULL, NULL,
					&ibm_backlight_data);
3053 3054 3055 3056
	if (IS_ERR(ibm_backlight_device)) {
		printk(IBM_ERR "Could not register backlight device\n");
		return PTR_ERR(ibm_backlight_device);
	}
3057
	vdbg_printk(TPACPI_DBG_INIT, "brightness is supported\n");
3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068

	ibm_backlight_device->props.max_brightness = 7;
	ibm_backlight_device->props.brightness = b;
	backlight_update_status(ibm_backlight_device);

	return 0;
}

static void brightness_exit(void)
{
	if (ibm_backlight_device) {
3069 3070
		vdbg_printk(TPACPI_DBG_EXIT,
			    "calling backlight_device_unregister()\n");
3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083
		backlight_device_unregister(ibm_backlight_device);
		ibm_backlight_device = NULL;
	}
}

static int brightness_update_status(struct backlight_device *bd)
{
	return brightness_set(
		(bd->props.fb_blank == FB_BLANK_UNBLANK &&
		 bd->props.power == FB_BLANK_UNBLANK) ?
				bd->props.brightness : 0);
}

3084 3085 3086 3087
/*
 * ThinkPads can read brightness from two places: EC 0x31, or
 * CMOS NVRAM byte 0x5E, bits 0-3.
 */
3088 3089
static int brightness_get(struct backlight_device *bd)
{
3090
	u8 lec = 0, lcmos = 0, level = 0;
3091

3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112
	if (brightness_mode & 1) {
		if (!acpi_ec_read(brightness_offset, &lec))
			return -EIO;
		lec &= 7;
		level = lec;
	};
	if (brightness_mode & 2) {
		lcmos = (nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS)
			 & TP_NVRAM_MASK_LEVEL_BRIGHTNESS)
			>> TP_NVRAM_POS_LEVEL_BRIGHTNESS;
		level = lcmos;
	}

	if (brightness_mode == 3 && lec != lcmos) {
		printk(IBM_ERR
			"CMOS NVRAM (%u) and EC (%u) do not agree "
			"on display brightness level\n",
			(unsigned int) lcmos,
			(unsigned int) lec);
		return -EIO;
	}
3113

3114
	return level;
3115 3116 3117
}

static int brightness_set(int value)
L
Linus Torvalds 已提交
3118
{
3119 3120
	int cmos_cmd, inc, i, res;
	int current_value;
3121

3122 3123
	if (value > 7)
		return -EINVAL;
3124

3125 3126 3127 3128 3129 3130 3131 3132 3133 3134
	res = mutex_lock_interruptible(&brightness_mutex);
	if (res < 0)
		return res;

	current_value = brightness_get(NULL);
	if (current_value < 0) {
		res = current_value;
		goto errout;
	}

3135 3136 3137
	cmos_cmd = value > current_value ?
			TP_CMOS_BRIGHTNESS_UP :
			TP_CMOS_BRIGHTNESS_DOWN;
3138
	inc = value > current_value ? 1 : -1;
3139

3140
	res = 0;
3141
	for (i = current_value; i != value; i += inc) {
3142
		if ((brightness_mode & 2) &&
3143 3144 3145 3146
		    issue_thinkpad_cmos_command(cmos_cmd)) {
			res = -EIO;
			goto errout;
		}
3147
		if ((brightness_mode & 1) &&
3148 3149 3150 3151
		    !acpi_ec_write(brightness_offset, i + inc)) {
			res = -EIO;
			goto errout;;
		}
3152 3153
	}

3154 3155 3156
errout:
	mutex_unlock(&brightness_mutex);
	return res;
3157 3158
}

3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175
static int brightness_read(char *p)
{
	int len = 0;
	int level;

	if ((level = brightness_get(NULL)) < 0) {
		len += sprintf(p + len, "level:\t\tunreadable\n");
	} else {
		len += sprintf(p + len, "level:\t\t%d\n", level & 0x7);
		len += sprintf(p + len, "commands:\tup, down\n");
		len += sprintf(p + len, "commands:\tlevel <level>"
			       " (<level> is 0-7)\n");
	}

	return len;
}

3176 3177 3178
static int brightness_write(char *buf)
{
	int level;
3179
	int new_level;
L
Linus Torvalds 已提交
3180 3181 3182
	char *cmd;

	while ((cmd = next_cmd(&buf))) {
3183 3184
		if ((level = brightness_get(NULL)) < 0)
			return level;
3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196
		level &= 7;

		if (strlencmp(cmd, "up") == 0) {
			new_level = level == 7 ? 7 : level + 1;
		} else if (strlencmp(cmd, "down") == 0) {
			new_level = level == 0 ? 0 : level - 1;
		} else if (sscanf(cmd, "level %d", &new_level) == 1 &&
			   new_level >= 0 && new_level <= 7) {
			/* new_level set */
		} else
			return -EINVAL;

3197
		brightness_set(new_level);
3198 3199 3200 3201 3202
	}

	return 0;
}

3203 3204 3205 3206 3207 3208 3209
static struct ibm_struct brightness_driver_data = {
	.name = "brightness",
	.read = brightness_read,
	.write = brightness_write,
	.exit = brightness_exit,
};

3210 3211 3212
/*************************************************************************
 * Volume subdriver
 */
3213

3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259
static int volume_read(char *p)
{
	int len = 0;
	u8 level;

	if (!acpi_ec_read(volume_offset, &level)) {
		len += sprintf(p + len, "level:\t\tunreadable\n");
	} else {
		len += sprintf(p + len, "level:\t\t%d\n", level & 0xf);
		len += sprintf(p + len, "mute:\t\t%s\n", onoff(level, 6));
		len += sprintf(p + len, "commands:\tup, down, mute\n");
		len += sprintf(p + len, "commands:\tlevel <level>"
			       " (<level> is 0-15)\n");
	}

	return len;
}

static int volume_write(char *buf)
{
	int cmos_cmd, inc, i;
	u8 level, mute;
	int new_level, new_mute;
	char *cmd;

	while ((cmd = next_cmd(&buf))) {
		if (!acpi_ec_read(volume_offset, &level))
			return -EIO;
		new_mute = mute = level & 0x40;
		new_level = level = level & 0xf;

		if (strlencmp(cmd, "up") == 0) {
			if (mute)
				new_mute = 0;
			else
				new_level = level == 15 ? 15 : level + 1;
		} else if (strlencmp(cmd, "down") == 0) {
			if (mute)
				new_mute = 0;
			else
				new_level = level == 0 ? 0 : level - 1;
		} else if (sscanf(cmd, "level %d", &new_level) == 1 &&
			   new_level >= 0 && new_level <= 15) {
			/* new_level set */
		} else if (strlencmp(cmd, "mute") == 0) {
			new_mute = 0x40;
L
Linus Torvalds 已提交
3260 3261 3262
		} else
			return -EINVAL;

3263
		if (new_level != level) {	/* mute doesn't change */
3264
			cmos_cmd = new_level > level ? TP_CMOS_VOLUME_UP : TP_CMOS_VOLUME_DOWN;
3265 3266
			inc = new_level > level ? 1 : -1;

3267
			if (mute && (issue_thinkpad_cmos_command(cmos_cmd) ||
3268 3269 3270 3271
				     !acpi_ec_write(volume_offset, level)))
				return -EIO;

			for (i = level; i != new_level; i += inc)
3272
				if (issue_thinkpad_cmos_command(cmos_cmd) ||
3273 3274 3275
				    !acpi_ec_write(volume_offset, i + inc))
					return -EIO;

3276
			if (mute && (issue_thinkpad_cmos_command(TP_CMOS_VOLUME_MUTE) ||
3277 3278 3279 3280 3281 3282
				     !acpi_ec_write(volume_offset,
						    new_level + mute)))
				return -EIO;
		}

		if (new_mute != mute) {	/* level doesn't change */
3283
			cmos_cmd = new_mute ? TP_CMOS_VOLUME_MUTE : TP_CMOS_VOLUME_UP;
3284

3285
			if (issue_thinkpad_cmos_command(cmos_cmd) ||
3286 3287 3288 3289 3290 3291 3292 3293
			    !acpi_ec_write(volume_offset, level + new_mute))
				return -EIO;
		}
	}

	return 0;
}

3294 3295 3296 3297 3298
static struct ibm_struct volume_driver_data = {
	.name = "volume",
	.read = volume_read,
	.write = volume_write,
};
3299 3300 3301 3302 3303 3304 3305 3306

/*************************************************************************
 * Fan subdriver
 */

/*
 * FAN ACCESS MODES
 *
3307
 * TPACPI_FAN_RD_ACPI_GFAN:
3308 3309
 * 	ACPI GFAN method: returns fan level
 *
3310
 * 	see TPACPI_FAN_WR_ACPI_SFAN
3311
 * 	EC 0x2f (HFSP) not available if GFAN exists
3312
 *
3313
 * TPACPI_FAN_WR_ACPI_SFAN:
3314 3315
 * 	ACPI SFAN method: sets fan level, 0 (stop) to 7 (max)
 *
3316 3317
 * 	EC 0x2f (HFSP) might be available *for reading*, but do not use
 * 	it for writing.
3318
 *
3319
 * TPACPI_FAN_WR_TPEC:
3320 3321
 * 	ThinkPad EC register 0x2f (HFSP): fan control loop mode
 * 	Supported on almost all ThinkPads
3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334
 *
 * 	Fan speed changes of any sort (including those caused by the
 * 	disengaged mode) are usually done slowly by the firmware as the
 * 	maximum ammount of fan duty cycle change per second seems to be
 * 	limited.
 *
 * 	Reading is not available if GFAN exists.
 * 	Writing is not available if SFAN exists.
 *
 * 	Bits
 *	 7	automatic mode engaged;
 *  		(default operation mode of the ThinkPad)
 * 		fan level is ignored in this mode.
3335
 *	 6	full speed mode (takes precedence over bit 7);
3336
 *		not available on all thinkpads.  May disable
3337 3338 3339 3340 3341
 *		the tachometer while the fan controller ramps up
 *		the speed (which can take up to a few *minutes*).
 *		Speeds up fan to 100% duty-cycle, which is far above
 *		the standard RPM levels.  It is not impossible that
 *		it could cause hardware damage.
3342 3343 3344 3345 3346 3347 3348
 *	5-3	unused in some models.  Extra bits for fan level
 *		in others, but still useless as all values above
 *		7 map to the same speed as level 7 in these models.
 *	2-0	fan level (0..7 usually)
 *			0x00 = stop
 * 			0x07 = max (set when temperatures critical)
 * 		Some ThinkPads may have other levels, see
3349
 * 		TPACPI_FAN_WR_ACPI_FANS (X31/X40/X41)
3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376
 *
 *	FIRMWARE BUG: on some models, EC 0x2f might not be initialized at
 *	boot. Apparently the EC does not intialize it, so unless ACPI DSDT
 *	does so, its initial value is meaningless (0x07).
 *
 *	For firmware bugs, refer to:
 *	http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
 *
 * 	----
 *
 *	ThinkPad EC register 0x84 (LSB), 0x85 (MSB):
 *	Main fan tachometer reading (in RPM)
 *
 *	This register is present on all ThinkPads with a new-style EC, and
 *	it is known not to be present on the A21m/e, and T22, as there is
 *	something else in offset 0x84 according to the ACPI DSDT.  Other
 *	ThinkPads from this same time period (and earlier) probably lack the
 *	tachometer as well.
 *
 *	Unfortunately a lot of ThinkPads with new-style ECs but whose firwmare
 *	was never fixed by IBM to report the EC firmware version string
 *	probably support the tachometer (like the early X models), so
 *	detecting it is quite hard.  We need more data to know for sure.
 *
 *	FIRMWARE BUG: always read 0x84 first, otherwise incorrect readings
 *	might result.
 *
3377 3378
 *	FIRMWARE BUG: may go stale while the EC is switching to full speed
 *	mode.
3379 3380 3381 3382
 *
 *	For firmware bugs, refer to:
 *	http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
 *
3383
 * TPACPI_FAN_WR_ACPI_FANS:
3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399
 *	ThinkPad X31, X40, X41.  Not available in the X60.
 *
 *	FANS ACPI handle: takes three arguments: low speed, medium speed,
 *	high speed.  ACPI DSDT seems to map these three speeds to levels
 *	as follows: STOP LOW LOW MED MED HIGH HIGH HIGH HIGH
 *	(this map is stored on FAN0..FAN8 as "0,1,1,2,2,3,3,3,3")
 *
 * 	The speeds are stored on handles
 * 	(FANA:FAN9), (FANC:FANB), (FANE:FAND).
 *
 * 	There are three default speed sets, acessible as handles:
 * 	FS1L,FS1M,FS1H; FS2L,FS2M,FS2H; FS3L,FS3M,FS3H
 *
 * 	ACPI DSDT switches which set is in use depending on various
 * 	factors.
 *
3400
 * 	TPACPI_FAN_WR_TPEC is also available and should be used to
3401 3402 3403 3404
 * 	command the fan.  The X31/X40/X41 seems to have 8 fan levels,
 * 	but the ACPI tables just mention level 7.
 */

3405 3406 3407
static enum fan_status_access_mode fan_status_access_mode;
static enum fan_control_access_mode fan_control_access_mode;
static enum fan_control_commands fan_control_commands;
3408

3409
static u8 fan_control_initial_status;
3410
static u8 fan_control_desired_level;
3411

3412
static void fan_watchdog_fire(struct work_struct *ignored);
3413
static int fan_watchdog_maxinterval;
3414
static DECLARE_DELAYED_WORK(fan_watchdog_task, fan_watchdog_fire);
3415

3416 3417 3418 3419 3420 3421 3422 3423
IBM_HANDLE(fans, ec, "FANS");	/* X31, X40, X41 */
IBM_HANDLE(gfan, ec, "GFAN",	/* 570 */
	   "\\FSPD",		/* 600e/x, 770e, 770x */
	   );			/* all others */
IBM_HANDLE(sfan, ec, "SFAN",	/* 570 */
	   "JFNS",		/* 770x-JL */
	   );			/* all others */

3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504
/*
 * SYSFS fan layout: hwmon compatible (device)
 *
 * pwm*_enable:
 * 	0: "disengaged" mode
 * 	1: manual mode
 * 	2: native EC "auto" mode (recommended, hardware default)
 *
 * pwm*: set speed in manual mode, ignored otherwise.
 * 	0 is level 0; 255 is level 7. Intermediate points done with linear
 * 	interpolation.
 *
 * fan*_input: tachometer reading, RPM
 *
 *
 * SYSFS fan layout: extensions
 *
 * fan_watchdog (driver):
 * 	fan watchdog interval in seconds, 0 disables (default), max 120
 */

/* sysfs fan pwm1_enable ----------------------------------------------- */
static ssize_t fan_pwm1_enable_show(struct device *dev,
				    struct device_attribute *attr,
				    char *buf)
{
	int res, mode;
	u8 status;

	res = fan_get_status_safe(&status);
	if (res)
		return res;

	if (unlikely(tp_features.fan_ctrl_status_undef)) {
		if (status != fan_control_initial_status) {
			tp_features.fan_ctrl_status_undef = 0;
		} else {
			/* Return most likely status. In fact, it
			 * might be the only possible status */
			status = TP_EC_FAN_AUTO;
		}
	}

	if (status & TP_EC_FAN_FULLSPEED) {
		mode = 0;
	} else if (status & TP_EC_FAN_AUTO) {
		mode = 2;
	} else
		mode = 1;

	return snprintf(buf, PAGE_SIZE, "%d\n", mode);
}

static ssize_t fan_pwm1_enable_store(struct device *dev,
				     struct device_attribute *attr,
				     const char *buf, size_t count)
{
	unsigned long t;
	int res, level;

	if (parse_strtoul(buf, 2, &t))
		return -EINVAL;

	switch (t) {
	case 0:
		level = TP_EC_FAN_FULLSPEED;
		break;
	case 1:
		level = TPACPI_FAN_LAST_LEVEL;
		break;
	case 2:
		level = TP_EC_FAN_AUTO;
		break;
	case 3:
		/* reserved for software-controlled auto mode */
		return -ENOSYS;
	default:
		return -EINVAL;
	}

	res = fan_set_level_safe(level);
3505 3506 3507
	if (res == -ENXIO)
		return -EINVAL;
	else if (res < 0)
3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570
		return res;

	fan_watchdog_reset();

	return count;
}

static struct device_attribute dev_attr_fan_pwm1_enable =
	__ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
		fan_pwm1_enable_show, fan_pwm1_enable_store);

/* sysfs fan pwm1 ------------------------------------------------------ */
static ssize_t fan_pwm1_show(struct device *dev,
			     struct device_attribute *attr,
			     char *buf)
{
	int res;
	u8 status;

	res = fan_get_status_safe(&status);
	if (res)
		return res;

	if (unlikely(tp_features.fan_ctrl_status_undef)) {
		if (status != fan_control_initial_status) {
			tp_features.fan_ctrl_status_undef = 0;
		} else {
			status = TP_EC_FAN_AUTO;
		}
	}

	if ((status &
	     (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) != 0)
		status = fan_control_desired_level;

	if (status > 7)
		status = 7;

	return snprintf(buf, PAGE_SIZE, "%u\n", (status * 255) / 7);
}

static ssize_t fan_pwm1_store(struct device *dev,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
	unsigned long s;
	int rc;
	u8 status, newlevel;

	if (parse_strtoul(buf, 255, &s))
		return -EINVAL;

	/* scale down from 0-255 to 0-7 */
	newlevel = (s >> 5) & 0x07;

	rc = mutex_lock_interruptible(&fan_mutex);
	if (rc < 0)
		return rc;

	rc = fan_get_status(&status);
	if (!rc && (status &
		    (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) == 0) {
		rc = fan_set_level(newlevel);
3571 3572 3573
		if (rc == -ENXIO)
			rc = -EINVAL;
		else if (!rc) {
3574
			fan_update_desired_level(newlevel);
3575 3576
			fan_watchdog_reset();
		}
3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620
	}

	mutex_unlock(&fan_mutex);
	return (rc)? rc : count;
}

static struct device_attribute dev_attr_fan_pwm1 =
	__ATTR(pwm1, S_IWUSR | S_IRUGO,
		fan_pwm1_show, fan_pwm1_store);

/* sysfs fan fan1_input ------------------------------------------------ */
static ssize_t fan_fan1_input_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	int res;
	unsigned int speed;

	res = fan_get_speed(&speed);
	if (res < 0)
		return res;

	return snprintf(buf, PAGE_SIZE, "%u\n", speed);
}

static struct device_attribute dev_attr_fan_fan1_input =
	__ATTR(fan1_input, S_IRUGO,
		fan_fan1_input_show, NULL);

/* sysfs fan fan_watchdog (driver) ------------------------------------- */
static ssize_t fan_fan_watchdog_show(struct device_driver *drv,
				     char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%u\n", fan_watchdog_maxinterval);
}

static ssize_t fan_fan_watchdog_store(struct device_driver *drv,
				      const char *buf, size_t count)
{
	unsigned long t;

	if (parse_strtoul(buf, 120, &t))
		return -EINVAL;

3621 3622 3623
	if (!fan_control_allowed)
		return -EPERM;

3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643
	fan_watchdog_maxinterval = t;
	fan_watchdog_reset();

	return count;
}

static DRIVER_ATTR(fan_watchdog, S_IWUSR | S_IRUGO,
		fan_fan_watchdog_show, fan_fan_watchdog_store);

/* --------------------------------------------------------------------- */
static struct attribute *fan_attributes[] = {
	&dev_attr_fan_pwm1_enable.attr, &dev_attr_fan_pwm1.attr,
	&dev_attr_fan_fan1_input.attr,
	NULL
};

static const struct attribute_group fan_attr_group = {
	.attrs = fan_attributes,
};

3644
static int __init fan_init(struct ibm_init_struct *iibm)
3645
{
3646 3647
	int rc;

3648 3649
	vdbg_printk(TPACPI_DBG_INIT, "initializing fan subdriver\n");

3650
	mutex_init(&fan_mutex);
3651 3652
	fan_status_access_mode = TPACPI_FAN_NONE;
	fan_control_access_mode = TPACPI_FAN_WR_NONE;
3653
	fan_control_commands = 0;
3654
	fan_watchdog_maxinterval = 0;
3655
	tp_features.fan_ctrl_status_undef = 0;
3656
	fan_control_desired_level = 7;
3657

3658 3659 3660
	IBM_ACPIHANDLE_INIT(fans);
	IBM_ACPIHANDLE_INIT(gfan);
	IBM_ACPIHANDLE_INIT(sfan);
3661

3662 3663
	if (gfan_handle) {
		/* 570, 600e/x, 770e, 770x */
3664
		fan_status_access_mode = TPACPI_FAN_RD_ACPI_GFAN;
3665 3666 3667
	} else {
		/* all other ThinkPads: note that even old-style
		 * ThinkPad ECs supports the fan control register */
3668 3669
		if (likely(acpi_ec_read(fan_status_offset,
					&fan_control_initial_status))) {
3670
			fan_status_access_mode = TPACPI_FAN_RD_TPEC;
3671 3672 3673 3674 3675 3676 3677 3678 3679

			/* In some ThinkPads, neither the EC nor the ACPI
			 * DSDT initialize the fan status, and it ends up
			 * being set to 0x07 when it *could* be either
			 * 0x07 or 0x80.
			 *
			 * Enable for TP-1Y (T43), TP-78 (R51e),
			 * TP-76 (R52), TP-70 (T43, R52), which are known
			 * to be buggy. */
3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692
			if (fan_control_initial_status == 0x07) {
				switch (thinkpad_id.ec_model) {
				case 0x5931: /* TP-1Y */
				case 0x3837: /* TP-78 */
				case 0x3637: /* TP-76 */
				case 0x3037: /* TP-70 */
					printk(IBM_NOTICE
					       "fan_init: initial fan status is "
					       "unknown, assuming it is in auto "
					       "mode\n");
					tp_features.fan_ctrl_status_undef = 1;
					;;
				}
3693
			}
3694 3695 3696 3697
		} else {
			printk(IBM_ERR
			       "ThinkPad ACPI EC access misbehaving, "
			       "fan status and control unavailable\n");
3698
			return 1;
3699 3700
		}
	}
3701

3702 3703
	if (sfan_handle) {
		/* 570, 770x-JL */
3704
		fan_control_access_mode = TPACPI_FAN_WR_ACPI_SFAN;
3705
		fan_control_commands |=
3706
		    TPACPI_FAN_CMD_LEVEL | TPACPI_FAN_CMD_ENABLE;
3707
	} else {
3708 3709 3710 3711 3712
		if (!gfan_handle) {
			/* gfan without sfan means no fan control */
			/* all other models implement TP EC 0x2f control */

			if (fans_handle) {
3713
				/* X31, X40, X41 */
3714
				fan_control_access_mode =
3715
				    TPACPI_FAN_WR_ACPI_FANS;
3716
				fan_control_commands |=
3717 3718 3719
				    TPACPI_FAN_CMD_SPEED |
				    TPACPI_FAN_CMD_LEVEL |
				    TPACPI_FAN_CMD_ENABLE;
3720
			} else {
3721
				fan_control_access_mode = TPACPI_FAN_WR_TPEC;
3722
				fan_control_commands |=
3723 3724
				    TPACPI_FAN_CMD_LEVEL |
				    TPACPI_FAN_CMD_ENABLE;
3725 3726 3727 3728
			}
		}
	}

3729 3730 3731 3732 3733
	vdbg_printk(TPACPI_DBG_INIT, "fan is %s, modes %d, %d\n",
		str_supported(fan_status_access_mode != TPACPI_FAN_NONE ||
		  fan_control_access_mode != TPACPI_FAN_WR_NONE),
		fan_status_access_mode, fan_control_access_mode);

3734 3735 3736 3737 3738 3739 3740 3741
	/* fan control master switch */
	if (!fan_control_allowed) {
		fan_control_access_mode = TPACPI_FAN_WR_NONE;
		fan_control_commands = 0;
		dbg_printk(TPACPI_DBG_INIT,
			   "fan control features disabled by parameter\n");
	}

3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771
	/* update fan_control_desired_level */
	if (fan_status_access_mode != TPACPI_FAN_NONE)
		fan_get_status_safe(NULL);

	if (fan_status_access_mode != TPACPI_FAN_NONE ||
	    fan_control_access_mode != TPACPI_FAN_WR_NONE) {
		rc = sysfs_create_group(&tpacpi_pdev->dev.kobj,
					 &fan_attr_group);
		if (!(rc < 0))
			rc = driver_create_file(&tpacpi_pdriver.driver,
					&driver_attr_fan_watchdog);
		if (rc < 0)
			return rc;
		return 0;
	} else
		return 1;
}

/*
 * Call with fan_mutex held
 */
static void fan_update_desired_level(u8 status)
{
	if ((status &
	     (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) == 0) {
		if (status > 7)
			fan_control_desired_level = 7;
		else
			fan_control_desired_level = status;
	}
3772
}
3773

3774
static int fan_get_status(u8 *status)
3775
{
3776
	u8 s;
3777

3778
	/* TODO:
3779
	 * Add TPACPI_FAN_RD_ACPI_FANS ? */
3780

3781
	switch (fan_status_access_mode) {
3782
	case TPACPI_FAN_RD_ACPI_GFAN:
3783
		/* 570, 600e/x, 770e, 770x */
3784 3785

		if (unlikely(!acpi_evalf(gfan_handle, &s, NULL, "d")))
L
Linus Torvalds 已提交
3786
			return -EIO;
3787

3788 3789
		if (likely(status))
			*status = s & 0x07;
3790 3791 3792

		break;

3793
	case TPACPI_FAN_RD_TPEC:
3794
		/* all except 570, 600e/x, 770e, 770x */
3795
		if (unlikely(!acpi_ec_read(fan_status_offset, &s)))
3796
			return -EIO;
3797

3798 3799 3800 3801 3802 3803 3804
		if (likely(status))
			*status = s;

		break;

	default:
		return -ENXIO;
3805 3806
	}

3807 3808 3809
	return 0;
}

3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828
static int fan_get_status_safe(u8 *status)
{
	int rc;
	u8 s;

	rc = mutex_lock_interruptible(&fan_mutex);
	if (rc < 0)
		return rc;
	rc = fan_get_status(&s);
	if (!rc)
		fan_update_desired_level(s);
	mutex_unlock(&fan_mutex);

	if (status)
		*status = s;

	return rc;
}

3829 3830
static void fan_exit(void)
{
3831
	vdbg_printk(TPACPI_DBG_EXIT, "cancelling any pending fan watchdog tasks\n");
3832 3833 3834 3835 3836

	/* FIXME: can we really do this unconditionally? */
	sysfs_remove_group(&tpacpi_pdev->dev.kobj, &fan_attr_group);
	driver_remove_file(&tpacpi_pdriver.driver, &driver_attr_fan_watchdog);

3837 3838 3839 3840
	cancel_delayed_work(&fan_watchdog_task);
	flush_scheduled_work();
}

3841 3842 3843 3844 3845
static int fan_get_speed(unsigned int *speed)
{
	u8 hi, lo;

	switch (fan_status_access_mode) {
3846
	case TPACPI_FAN_RD_TPEC:
3847
		/* all except 570, 600e/x, 770e, 770x */
3848 3849 3850 3851
		if (unlikely(!acpi_ec_read(fan_rpm_offset, &lo) ||
			     !acpi_ec_read(fan_rpm_offset + 1, &hi)))
			return -EIO;

3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863
		if (likely(speed))
			*speed = (hi << 8) | lo;

		break;

	default:
		return -ENXIO;
	}

	return 0;
}

3864
static void fan_watchdog_fire(struct work_struct *ignored)
3865
{
3866 3867
	int rc;

3868
	printk(IBM_NOTICE "fan watchdog: enabling fan\n");
3869 3870 3871 3872
	rc = fan_set_enable();
	if (rc < 0) {
		printk(IBM_ERR "fan watchdog: error %d while enabling fan, "
			"will try again later...\n", -rc);
3873 3874 3875
		/* reschedule for later */
		fan_watchdog_reset();
	}
3876 3877 3878 3879
}

static void fan_watchdog_reset(void)
{
3880
	static int fan_watchdog_active;
3881

3882 3883 3884
	if (fan_control_access_mode == TPACPI_FAN_WR_NONE)
		return;

3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899
	if (fan_watchdog_active)
		cancel_delayed_work(&fan_watchdog_task);

	if (fan_watchdog_maxinterval > 0) {
		fan_watchdog_active = 1;
		if (!schedule_delayed_work(&fan_watchdog_task,
				msecs_to_jiffies(fan_watchdog_maxinterval
						 * 1000))) {
			printk(IBM_ERR "failed to schedule the fan watchdog, "
			       "watchdog will not trigger\n");
		}
	} else
		fan_watchdog_active = 0;
}

3900
static int fan_set_level(int level)
3901
{
3902 3903 3904
	if (!fan_control_allowed)
		return -EPERM;

3905
	switch (fan_control_access_mode) {
3906
	case TPACPI_FAN_WR_ACPI_SFAN:
3907
		if (level >= 0 && level <= 7) {
3908
			if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", level))
3909
				return -EIO;
3910 3911 3912 3913
		} else
			return -EINVAL;
		break;

3914 3915 3916 3917
	case TPACPI_FAN_WR_ACPI_FANS:
	case TPACPI_FAN_WR_TPEC:
		if ((level != TP_EC_FAN_AUTO) &&
		    (level != TP_EC_FAN_FULLSPEED) &&
3918 3919 3920
		    ((level < 0) || (level > 7)))
			return -EINVAL;

3921 3922 3923 3924 3925 3926 3927
		/* safety net should the EC not support AUTO
		 * or FULLSPEED mode bits and just ignore them */
		if (level & TP_EC_FAN_FULLSPEED)
			level |= 7;	/* safety min speed 7 */
		else if (level & TP_EC_FAN_FULLSPEED)
			level |= 4;	/* safety min speed 4 */

3928
		if (!acpi_ec_write(fan_status_offset, level))
3929
			return -EIO;
3930
		else
3931
			tp_features.fan_ctrl_status_undef = 0;
3932 3933
		break;

3934 3935 3936 3937 3938 3939
	default:
		return -ENXIO;
	}
	return 0;
}

3940 3941 3942 3943
static int fan_set_level_safe(int level)
{
	int rc;

3944 3945 3946
	if (!fan_control_allowed)
		return -EPERM;

3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961
	rc = mutex_lock_interruptible(&fan_mutex);
	if (rc < 0)
		return rc;

	if (level == TPACPI_FAN_LAST_LEVEL)
		level = fan_control_desired_level;

	rc = fan_set_level(level);
	if (!rc)
		fan_update_desired_level(level);

	mutex_unlock(&fan_mutex);
	return rc;
}

3962 3963
static int fan_set_enable(void)
{
3964 3965 3966
	u8 s;
	int rc;

3967 3968 3969
	if (!fan_control_allowed)
		return -EPERM;

3970 3971 3972 3973
	rc = mutex_lock_interruptible(&fan_mutex);
	if (rc < 0)
		return rc;

3974
	switch (fan_control_access_mode) {
3975 3976
	case TPACPI_FAN_WR_ACPI_FANS:
	case TPACPI_FAN_WR_TPEC:
3977 3978 3979
		rc = fan_get_status(&s);
		if (rc < 0)
			break;
3980 3981

		/* Don't go out of emergency fan mode */
3982 3983 3984 3985
		if (s != 7) {
			s &= 0x07;
			s |= TP_EC_FAN_AUTO | 4; /* min fan speed 4 */
		}
3986 3987

		if (!acpi_ec_write(fan_status_offset, s))
3988 3989
			rc = -EIO;
		else {
3990
			tp_features.fan_ctrl_status_undef = 0;
3991 3992
			rc = 0;
		}
3993 3994
		break;

3995
	case TPACPI_FAN_WR_ACPI_SFAN:
3996 3997 3998
		rc = fan_get_status(&s);
		if (rc < 0)
			break;
3999 4000 4001 4002

		s &= 0x07;

		/* Set fan to at least level 4 */
4003
		s |= 4;
4004 4005

		if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", s))
4006 4007 4008
			rc= -EIO;
		else
			rc = 0;
4009 4010 4011
		break;

	default:
4012
		rc = -ENXIO;
4013
	}
4014 4015 4016

	mutex_unlock(&fan_mutex);
	return rc;
4017 4018 4019 4020
}

static int fan_set_disable(void)
{
4021 4022
	int rc;

4023 4024 4025
	if (!fan_control_allowed)
		return -EPERM;

4026 4027 4028 4029 4030
	rc = mutex_lock_interruptible(&fan_mutex);
	if (rc < 0)
		return rc;

	rc = 0;
4031
	switch (fan_control_access_mode) {
4032 4033
	case TPACPI_FAN_WR_ACPI_FANS:
	case TPACPI_FAN_WR_TPEC:
4034
		if (!acpi_ec_write(fan_status_offset, 0x00))
4035
			rc = -EIO;
4036 4037
		else {
			fan_control_desired_level = 0;
4038
			tp_features.fan_ctrl_status_undef = 0;
4039
		}
4040 4041
		break;

4042
	case TPACPI_FAN_WR_ACPI_SFAN:
4043
		if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", 0x00))
4044
			rc = -EIO;
4045 4046
		else
			fan_control_desired_level = 0;
4047 4048
		break;

4049
	default:
4050
		rc = -ENXIO;
4051
	}
4052

4053

4054 4055
	mutex_unlock(&fan_mutex);
	return rc;
4056 4057 4058 4059
}

static int fan_set_speed(int speed)
{
4060 4061
	int rc;

4062 4063 4064
	if (!fan_control_allowed)
		return -EPERM;

4065 4066 4067 4068 4069
	rc = mutex_lock_interruptible(&fan_mutex);
	if (rc < 0)
		return rc;

	rc = 0;
4070
	switch (fan_control_access_mode) {
4071
	case TPACPI_FAN_WR_ACPI_FANS:
4072 4073 4074
		if (speed >= 0 && speed <= 65535) {
			if (!acpi_evalf(fans_handle, NULL, NULL, "vddd",
					speed, speed, speed))
4075
				rc = -EIO;
4076
		} else
4077
			rc = -EINVAL;
4078 4079 4080
		break;

	default:
4081
		rc = -ENXIO;
4082
	}
4083 4084 4085

	mutex_unlock(&fan_mutex);
	return rc;
4086 4087 4088 4089 4090 4091 4092 4093 4094 4095
}

static int fan_read(char *p)
{
	int len = 0;
	int rc;
	u8 status;
	unsigned int speed = 0;

	switch (fan_status_access_mode) {
4096
	case TPACPI_FAN_RD_ACPI_GFAN:
4097
		/* 570, 600e/x, 770e, 770x */
4098
		if ((rc = fan_get_status_safe(&status)) < 0)
4099 4100 4101 4102 4103 4104 4105
			return rc;

		len += sprintf(p + len, "status:\t\t%s\n"
			       "level:\t\t%d\n",
			       (status != 0) ? "enabled" : "disabled", status);
		break;

4106
	case TPACPI_FAN_RD_TPEC:
4107
		/* all except 570, 600e/x, 770e, 770x */
4108
		if ((rc = fan_get_status_safe(&status)) < 0)
4109 4110
			return rc;

4111
		if (unlikely(tp_features.fan_ctrl_status_undef)) {
4112
			if (status != fan_control_initial_status)
4113
				tp_features.fan_ctrl_status_undef = 0;
4114 4115 4116
			else
				/* Return most likely status. In fact, it
				 * might be the only possible status */
4117
				status = TP_EC_FAN_AUTO;
4118 4119 4120 4121 4122 4123 4124 4125 4126 4127
		}

		len += sprintf(p + len, "status:\t\t%s\n",
			       (status != 0) ? "enabled" : "disabled");

		if ((rc = fan_get_speed(&speed)) < 0)
			return rc;

		len += sprintf(p + len, "speed:\t\t%d\n", speed);

4128
		if (status & TP_EC_FAN_FULLSPEED)
4129 4130
			/* Disengaged mode takes precedence */
			len += sprintf(p + len, "level:\t\tdisengaged\n");
4131
		else if (status & TP_EC_FAN_AUTO)
4132 4133 4134 4135 4136
			len += sprintf(p + len, "level:\t\tauto\n");
		else
			len += sprintf(p + len, "level:\t\t%d\n", status);
		break;

4137
	case TPACPI_FAN_NONE:
4138 4139 4140 4141
	default:
		len += sprintf(p + len, "status:\t\tnot supported\n");
	}

4142
	if (fan_control_commands & TPACPI_FAN_CMD_LEVEL) {
4143 4144 4145
		len += sprintf(p + len, "commands:\tlevel <level>");

		switch (fan_control_access_mode) {
4146
		case TPACPI_FAN_WR_ACPI_SFAN:
4147 4148 4149 4150 4151
			len += sprintf(p + len, " (<level> is 0-7)\n");
			break;

		default:
			len += sprintf(p + len, " (<level> is 0-7, "
4152
				       "auto, disengaged, full-speed)\n");
4153 4154 4155
			break;
		}
	}
4156

4157
	if (fan_control_commands & TPACPI_FAN_CMD_ENABLE)
4158 4159 4160
		len += sprintf(p + len, "commands:\tenable, disable\n"
			       "commands:\twatchdog <timeout> (<timeout> is 0 (off), "
			       "1-120 (seconds))\n");
L
Linus Torvalds 已提交
4161

4162
	if (fan_control_commands & TPACPI_FAN_CMD_SPEED)
4163 4164 4165 4166
		len += sprintf(p + len, "commands:\tspeed <speed>"
			       " (<speed> is 0-65535)\n");

	return len;
4167 4168
}

4169 4170 4171 4172
static int fan_write_cmd_level(const char *cmd, int *rc)
{
	int level;

4173
	if (strlencmp(cmd, "level auto") == 0)
4174
		level = TP_EC_FAN_AUTO;
4175 4176
	else if ((strlencmp(cmd, "level disengaged") == 0) |
	         (strlencmp(cmd, "level full-speed") == 0))
4177
		level = TP_EC_FAN_FULLSPEED;
4178
	else if (sscanf(cmd, "level %d", &level) != 1)
4179 4180
		return 0;

4181
	if ((*rc = fan_set_level_safe(level)) == -ENXIO)
4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215
		printk(IBM_ERR "level command accepted for unsupported "
		       "access mode %d", fan_control_access_mode);

	return 1;
}

static int fan_write_cmd_enable(const char *cmd, int *rc)
{
	if (strlencmp(cmd, "enable") != 0)
		return 0;

	if ((*rc = fan_set_enable()) == -ENXIO)
		printk(IBM_ERR "enable command accepted for unsupported "
		       "access mode %d", fan_control_access_mode);

	return 1;
}

static int fan_write_cmd_disable(const char *cmd, int *rc)
{
	if (strlencmp(cmd, "disable") != 0)
		return 0;

	if ((*rc = fan_set_disable()) == -ENXIO)
		printk(IBM_ERR "disable command accepted for unsupported "
		       "access mode %d", fan_control_access_mode);

	return 1;
}

static int fan_write_cmd_speed(const char *cmd, int *rc)
{
	int speed;

4216 4217 4218
	/* TODO:
	 * Support speed <low> <medium> <high> ? */

4219 4220 4221 4222 4223 4224 4225 4226 4227 4228
	if (sscanf(cmd, "speed %d", &speed) != 1)
		return 0;

	if ((*rc = fan_set_speed(speed)) == -ENXIO)
		printk(IBM_ERR "speed command accepted for unsupported "
		       "access mode %d", fan_control_access_mode);

	return 1;
}

4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243
static int fan_write_cmd_watchdog(const char *cmd, int *rc)
{
	int interval;

	if (sscanf(cmd, "watchdog %d", &interval) != 1)
		return 0;

	if (interval < 0 || interval > 120)
		*rc = -EINVAL;
	else
		fan_watchdog_maxinterval = interval;

	return 1;
}

4244 4245 4246 4247 4248 4249
static int fan_write(char *buf)
{
	char *cmd;
	int rc = 0;

	while (!rc && (cmd = next_cmd(&buf))) {
4250
		if (!((fan_control_commands & TPACPI_FAN_CMD_LEVEL) &&
4251
		      fan_write_cmd_level(cmd, &rc)) &&
4252
		    !((fan_control_commands & TPACPI_FAN_CMD_ENABLE) &&
4253
		      (fan_write_cmd_enable(cmd, &rc) ||
4254 4255
		       fan_write_cmd_disable(cmd, &rc) ||
		       fan_write_cmd_watchdog(cmd, &rc))) &&
4256
		    !((fan_control_commands & TPACPI_FAN_CMD_SPEED) &&
4257 4258 4259
		      fan_write_cmd_speed(cmd, &rc))
		    )
			rc = -EINVAL;
4260 4261
		else if (!rc)
			fan_watchdog_reset();
4262 4263 4264 4265 4266
	}

	return rc;
}

4267 4268 4269 4270 4271 4272 4273
static struct ibm_struct fan_driver_data = {
	.name = "fan",
	.read = fan_read,
	.write = fan_write,
	.exit = fan_exit,
};

4274 4275 4276 4277 4278 4279 4280 4281 4282
/****************************************************************************
 ****************************************************************************
 *
 * Infrastructure
 *
 ****************************************************************************
 ****************************************************************************/

/* /proc support */
4283
static struct proc_dir_entry *proc_dir;
4284

4285
/* Subdriver registry */
4286 4287
static LIST_HEAD(tpacpi_all_drivers);

L
Linus Torvalds 已提交
4288

4289 4290 4291
/*
 * Module and infrastructure proble, init and exit handling
 */
L
Linus Torvalds 已提交
4292

4293
#ifdef CONFIG_THINKPAD_ACPI_DEBUG
4294
static const char * __init str_supported(int is_supported)
4295
{
4296
	static char text_unsupported[] __initdata = "not supported";
4297

4298
	return (is_supported)? &text_unsupported[4] : &text_unsupported[0];
4299 4300 4301
}
#endif /* CONFIG_THINKPAD_ACPI_DEBUG */

4302
static int __init ibm_init(struct ibm_init_struct *iibm)
L
Linus Torvalds 已提交
4303 4304
{
	int ret;
4305
	struct ibm_struct *ibm = iibm->data;
L
Linus Torvalds 已提交
4306 4307
	struct proc_dir_entry *entry;

4308 4309 4310 4311
	BUG_ON(ibm == NULL);

	INIT_LIST_HEAD(&ibm->all_drivers);

4312
	if (ibm->flags.experimental && !experimental)
L
Linus Torvalds 已提交
4313 4314
		return 0;

4315 4316 4317
	dbg_printk(TPACPI_DBG_INIT,
		"probing for %s\n", ibm->name);

4318 4319
	if (iibm->init) {
		ret = iibm->init(iibm);
4320 4321 4322
		if (ret > 0)
			return 0;	/* probe failed */
		if (ret)
L
Linus Torvalds 已提交
4323
			return ret;
4324

4325
		ibm->flags.init_called = 1;
L
Linus Torvalds 已提交
4326 4327
	}

4328 4329 4330 4331 4332 4333
	if (ibm->acpi) {
		if (ibm->acpi->hid) {
			ret = register_tpacpi_subdriver(ibm);
			if (ret)
				goto err_out;
		}
4334

4335 4336 4337 4338 4339 4340 4341 4342 4343 4344
		if (ibm->acpi->notify) {
			ret = setup_acpi_notify(ibm);
			if (ret == -ENODEV) {
				printk(IBM_NOTICE "disabling subdriver %s\n",
					ibm->name);
				ret = 0;
				goto err_out;
			}
			if (ret < 0)
				goto err_out;
4345 4346 4347
		}
	}

4348 4349 4350
	dbg_printk(TPACPI_DBG_INIT,
		"%s installed\n", ibm->name);

4351 4352 4353 4354 4355 4356 4357
	if (ibm->read) {
		entry = create_proc_entry(ibm->name,
					  S_IFREG | S_IRUGO | S_IWUSR,
					  proc_dir);
		if (!entry) {
			printk(IBM_ERR "unable to create proc entry %s\n",
			       ibm->name);
4358 4359
			ret = -ENODEV;
			goto err_out;
4360 4361 4362
		}
		entry->owner = THIS_MODULE;
		entry->data = ibm;
4363
		entry->read_proc = &dispatch_procfs_read;
4364
		if (ibm->write)
4365
			entry->write_proc = &dispatch_procfs_write;
4366
		ibm->flags.proc_created = 1;
4367
	}
L
Linus Torvalds 已提交
4368

4369 4370
	list_add_tail(&ibm->all_drivers, &tpacpi_all_drivers);

L
Linus Torvalds 已提交
4371
	return 0;
4372 4373

err_out:
4374 4375 4376 4377
	dbg_printk(TPACPI_DBG_INIT,
		"%s: at error exit path with result %d\n",
		ibm->name, ret);

4378 4379
	ibm_exit(ibm);
	return (ret < 0)? ret : 0;
L
Linus Torvalds 已提交
4380 4381 4382 4383
}

static void ibm_exit(struct ibm_struct *ibm)
{
4384
	dbg_printk(TPACPI_DBG_EXIT, "removing %s\n", ibm->name);
4385 4386 4387

	list_del_init(&ibm->all_drivers);

4388
	if (ibm->flags.acpi_notify_installed) {
4389 4390
		dbg_printk(TPACPI_DBG_EXIT,
			"%s: acpi_remove_notify_handler\n", ibm->name);
4391 4392 4393 4394 4395 4396
		BUG_ON(!ibm->acpi);
		acpi_remove_notify_handler(*ibm->acpi->handle,
					   ibm->acpi->type,
					   dispatch_acpi_notify);
		ibm->flags.acpi_notify_installed = 0;
		ibm->flags.acpi_notify_installed = 0;
4397
	}
L
Linus Torvalds 已提交
4398

4399
	if (ibm->flags.proc_created) {
4400 4401
		dbg_printk(TPACPI_DBG_EXIT,
			"%s: remove_proc_entry\n", ibm->name);
L
Linus Torvalds 已提交
4402
		remove_proc_entry(ibm->name, proc_dir);
4403
		ibm->flags.proc_created = 0;
4404
	}
L
Linus Torvalds 已提交
4405

4406
	if (ibm->flags.acpi_driver_registered) {
4407 4408
		dbg_printk(TPACPI_DBG_EXIT,
			"%s: acpi_bus_unregister_driver\n", ibm->name);
4409 4410 4411 4412 4413
		BUG_ON(!ibm->acpi);
		acpi_bus_unregister_driver(ibm->acpi->driver);
		kfree(ibm->acpi->driver);
		ibm->acpi->driver = NULL;
		ibm->flags.acpi_driver_registered = 0;
4414 4415
	}

4416
	if (ibm->flags.init_called && ibm->exit) {
4417
		ibm->exit();
4418
		ibm->flags.init_called = 0;
L
Linus Torvalds 已提交
4419
	}
4420 4421

	dbg_printk(TPACPI_DBG_INIT, "finished removing %s\n", ibm->name);
L
Linus Torvalds 已提交
4422 4423
}

4424 4425
/* Probing */

4426
static void __init get_thinkpad_model_data(struct thinkpad_id_data *tp)
L
Linus Torvalds 已提交
4427
{
4428 4429
	struct dmi_device *dev = NULL;
	char ec_fw_string[18];
L
Linus Torvalds 已提交
4430

4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449
	if (!tp)
		return;

	memset(tp, 0, sizeof(*tp));

	if (dmi_name_in_vendors("IBM"))
		tp->vendor = PCI_VENDOR_ID_IBM;
	else if (dmi_name_in_vendors("LENOVO"))
		tp->vendor = PCI_VENDOR_ID_LENOVO;
	else
		return;

	tp->bios_version_str = kstrdup(dmi_get_system_info(DMI_BIOS_VERSION),
					GFP_KERNEL);
	if (!tp->bios_version_str)
		return;
	tp->bios_model = tp->bios_version_str[0]
			 | (tp->bios_version_str[1] << 8);

4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462
	/*
	 * ThinkPad T23 or newer, A31 or newer, R50e or newer,
	 * X32 or newer, all Z series;  Some models must have an
	 * up-to-date BIOS or they will not be detected.
	 *
	 * See http://thinkwiki.org/wiki/List_of_DMI_IDs
	 */
	while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
		if (sscanf(dev->name,
			   "IBM ThinkPad Embedded Controller -[%17c",
			   ec_fw_string) == 1) {
			ec_fw_string[sizeof(ec_fw_string) - 1] = 0;
			ec_fw_string[strcspn(ec_fw_string, " ]")] = 0;
4463 4464 4465 4466 4467

			tp->ec_version_str = kstrdup(ec_fw_string, GFP_KERNEL);
			tp->ec_model = ec_fw_string[0]
					| (ec_fw_string[1] << 8);
			break;
4468
		}
L
Linus Torvalds 已提交
4469
	}
4470 4471 4472 4473 4474 4475 4476

	tp->model_str = kstrdup(dmi_get_system_info(DMI_PRODUCT_VERSION),
					GFP_KERNEL);
	if (strnicmp(tp->model_str, "ThinkPad", 8) != 0) {
		kfree(tp->model_str);
		tp->model_str = NULL;
	}
L
Linus Torvalds 已提交
4477 4478
}

4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489
static int __init probe_for_thinkpad(void)
{
	int is_thinkpad;

	if (acpi_disabled)
		return -ENODEV;

	/*
	 * Non-ancient models have better DMI tagging, but very old models
	 * don't.
	 */
4490
	is_thinkpad = (thinkpad_id.model_str != NULL);
4491 4492

	/* ec is required because many other handles are relative to it */
4493
	IBM_ACPIHANDLE_INIT(ec);
4494 4495 4496 4497 4498 4499 4500
	if (!ec_handle) {
		if (is_thinkpad)
			printk(IBM_ERR
				"Not yet supported ThinkPad detected!\n");
		return -ENODEV;
	}

4501 4502 4503 4504 4505
	/*
	 * Risks a regression on very old machines, but reduces potential
	 * false positives a damn great deal
	 */
	if (!is_thinkpad)
4506
		is_thinkpad = (thinkpad_id.vendor == PCI_VENDOR_ID_IBM);
4507 4508 4509 4510

	if (!is_thinkpad && !force_load)
		return -ENODEV;

4511 4512 4513 4514
	return 0;
}


4515
/* Module init, exit, parameters */
L
Linus Torvalds 已提交
4516

4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547
static struct ibm_init_struct ibms_init[] __initdata = {
	{
		.init = thinkpad_acpi_driver_init,
		.data = &thinkpad_acpi_driver_data,
	},
	{
		.init = hotkey_init,
		.data = &hotkey_driver_data,
	},
	{
		.init = bluetooth_init,
		.data = &bluetooth_driver_data,
	},
	{
		.init = wan_init,
		.data = &wan_driver_data,
	},
	{
		.init = video_init,
		.data = &video_driver_data,
	},
	{
		.init = light_init,
		.data = &light_driver_data,
	},
#ifdef CONFIG_THINKPAD_ACPI_DOCK
	{
		.init = dock_init,
		.data = &dock_driver_data[0],
	},
	{
4548
		.init = dock_init2,
4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589
		.data = &dock_driver_data[1],
	},
#endif
#ifdef CONFIG_THINKPAD_ACPI_BAY
	{
		.init = bay_init,
		.data = &bay_driver_data,
	},
#endif
	{
		.init = cmos_init,
		.data = &cmos_driver_data,
	},
	{
		.init = led_init,
		.data = &led_driver_data,
	},
	{
		.init = beep_init,
		.data = &beep_driver_data,
	},
	{
		.init = thermal_init,
		.data = &thermal_driver_data,
	},
	{
		.data = &ecdump_driver_data,
	},
	{
		.init = brightness_init,
		.data = &brightness_driver_data,
	},
	{
		.data = &volume_driver_data,
	},
	{
		.init = fan_init,
		.data = &fan_driver_data,
	},
};

4590
static int __init set_ibm_param(const char *val, struct kernel_param *kp)
L
Linus Torvalds 已提交
4591 4592
{
	unsigned int i;
4593
	struct ibm_struct *ibm;
L
Linus Torvalds 已提交
4594

4595 4596 4597 4598 4599 4600
	for (i = 0; i < ARRAY_SIZE(ibms_init); i++) {
		ibm = ibms_init[i].data;
		BUG_ON(ibm == NULL);

		if (strcmp(ibm->name, kp->name) == 0 && ibm->write) {
			if (strlen(val) > sizeof(ibms_init[i].param) - 2)
4601
				return -ENOSPC;
4602 4603
			strcpy(ibms_init[i].param, val);
			strcat(ibms_init[i].param, ",");
4604 4605
			return 0;
		}
4606
	}
L
Linus Torvalds 已提交
4607 4608 4609 4610

	return -EINVAL;
}

4611 4612 4613
static int experimental;
module_param(experimental, int, 0);

4614 4615 4616
static u32 dbg_level;
module_param_named(debug, dbg_level, uint, 0);

4617
static int force_load;
4618
module_param(force_load, bool, 0);
4619

4620
static int fan_control_allowed;
4621
module_param_named(fan_control, fan_control_allowed, bool, 0);
4622

4623 4624 4625
static int brightness_mode;
module_param_named(brightness_mode, brightness_mode, int, 0);

L
Linus Torvalds 已提交
4626 4627 4628
#define IBM_PARAM(feature) \
	module_param_call(feature, set_ibm_param, NULL, NULL, 0)

4629 4630 4631 4632
IBM_PARAM(hotkey);
IBM_PARAM(bluetooth);
IBM_PARAM(video);
IBM_PARAM(light);
4633
#ifdef CONFIG_THINKPAD_ACPI_DOCK
4634
IBM_PARAM(dock);
4635
#endif
4636
#ifdef CONFIG_THINKPAD_ACPI_BAY
4637
IBM_PARAM(bay);
4638
#endif /* CONFIG_THINKPAD_ACPI_BAY */
4639 4640 4641 4642 4643 4644 4645 4646
IBM_PARAM(cmos);
IBM_PARAM(led);
IBM_PARAM(beep);
IBM_PARAM(ecdump);
IBM_PARAM(brightness);
IBM_PARAM(volume);
IBM_PARAM(fan);

4647
static int __init thinkpad_acpi_module_init(void)
L
Linus Torvalds 已提交
4648 4649 4650
{
	int ret, i;

4651
	/* Driver-level probe */
4652 4653

	get_thinkpad_model_data(&thinkpad_id);
4654
	ret = probe_for_thinkpad();
4655 4656
	if (ret) {
		thinkpad_acpi_module_exit();
4657
		return ret;
4658
	}
L
Linus Torvalds 已提交
4659

4660
	/* Driver initialization */
4661

4662 4663
	IBM_ACPIHANDLE_INIT(ecrd);
	IBM_ACPIHANDLE_INIT(ecwr);
L
Linus Torvalds 已提交
4664

4665
	proc_dir = proc_mkdir(IBM_PROC_DIR, acpi_root_dir);
L
Linus Torvalds 已提交
4666
	if (!proc_dir) {
4667
		printk(IBM_ERR "unable to create proc dir " IBM_PROC_DIR);
4668
		thinkpad_acpi_module_exit();
L
Linus Torvalds 已提交
4669 4670 4671
		return -ENODEV;
	}
	proc_dir->owner = THIS_MODULE;
4672

4673 4674 4675 4676 4677 4678
	ret = platform_driver_register(&tpacpi_pdriver);
	if (ret) {
		printk(IBM_ERR "unable to register platform driver\n");
		thinkpad_acpi_module_exit();
		return ret;
	}
4679 4680
	tp_features.platform_drv_registered = 1;

4681 4682 4683 4684 4685 4686
	ret = tpacpi_create_driver_attributes(&tpacpi_pdriver.driver);
	if (ret) {
		printk(IBM_ERR "unable to create sysfs driver attributes\n");
		thinkpad_acpi_module_exit();
		return ret;
	}
4687
	tp_features.platform_drv_attrs_registered = 1;
4688

4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707

	/* Device initialization */
	tpacpi_pdev = platform_device_register_simple(IBM_DRVR_NAME, -1,
							NULL, 0);
	if (IS_ERR(tpacpi_pdev)) {
		ret = PTR_ERR(tpacpi_pdev);
		tpacpi_pdev = NULL;
		printk(IBM_ERR "unable to register platform device\n");
		thinkpad_acpi_module_exit();
		return ret;
	}
	tpacpi_hwmon = hwmon_device_register(&tpacpi_pdev->dev);
	if (IS_ERR(tpacpi_hwmon)) {
		ret = PTR_ERR(tpacpi_hwmon);
		tpacpi_hwmon = NULL;
		printk(IBM_ERR "unable to register hwmon device\n");
		thinkpad_acpi_module_exit();
		return ret;
	}
4708 4709 4710 4711 4712 4713 4714 4715 4716 4717
	tpacpi_inputdev = input_allocate_device();
	if (!tpacpi_inputdev) {
		printk(IBM_ERR "unable to allocate input device\n");
		thinkpad_acpi_module_exit();
		return -ENOMEM;
	} else {
		/* Prepare input device, but don't register */
		tpacpi_inputdev->name = "ThinkPad Extra Buttons";
		tpacpi_inputdev->phys = IBM_DRVR_NAME "/input0";
		tpacpi_inputdev->id.bustype = BUS_HOST;
4718 4719 4720
		tpacpi_inputdev->id.vendor = (thinkpad_id.vendor) ?
						thinkpad_id.vendor :
						PCI_VENDOR_ID_IBM;
4721 4722 4723
		tpacpi_inputdev->id.product = TPACPI_HKEY_INPUT_PRODUCT;
		tpacpi_inputdev->id.version = TPACPI_HKEY_INPUT_VERSION;
	}
4724 4725 4726 4727
	for (i = 0; i < ARRAY_SIZE(ibms_init); i++) {
		ret = ibm_init(&ibms_init[i]);
		if (ret >= 0 && *ibms_init[i].param)
			ret = ibms_init[i].data->write(ibms_init[i].param);
L
Linus Torvalds 已提交
4728
		if (ret < 0) {
4729
			thinkpad_acpi_module_exit();
L
Linus Torvalds 已提交
4730 4731 4732
			return ret;
		}
	}
4733 4734 4735 4736 4737 4738 4739 4740
	ret = input_register_device(tpacpi_inputdev);
	if (ret < 0) {
		printk(IBM_ERR "unable to register input device\n");
		thinkpad_acpi_module_exit();
		return ret;
	} else {
		tp_features.input_device_registered = 1;
	}
L
Linus Torvalds 已提交
4741 4742 4743 4744

	return 0;
}

4745
static void thinkpad_acpi_module_exit(void)
4746
{
4747 4748 4749 4750 4751 4752 4753
	struct ibm_struct *ibm, *itmp;

	list_for_each_entry_safe_reverse(ibm, itmp,
					 &tpacpi_all_drivers,
					 all_drivers) {
		ibm_exit(ibm);
	}
4754

4755
	dbg_printk(TPACPI_DBG_INIT, "finished subdriver exit path...\n");
4756

4757 4758 4759 4760 4761 4762 4763
	if (tpacpi_inputdev) {
		if (tp_features.input_device_registered)
			input_unregister_device(tpacpi_inputdev);
		else
			input_free_device(tpacpi_inputdev);
	}

4764 4765 4766 4767 4768 4769
	if (tpacpi_hwmon)
		hwmon_device_unregister(tpacpi_hwmon);

	if (tpacpi_pdev)
		platform_device_unregister(tpacpi_pdev);

4770 4771 4772 4773 4774
	if (tp_features.platform_drv_attrs_registered)
		tpacpi_remove_driver_attributes(&tpacpi_pdriver.driver);

	if (tp_features.platform_drv_registered)
		platform_driver_unregister(&tpacpi_pdriver);
4775

4776
	if (proc_dir)
4777
		remove_proc_entry(IBM_PROC_DIR, acpi_root_dir);
4778

4779 4780 4781
	kfree(thinkpad_id.bios_version_str);
	kfree(thinkpad_id.ec_version_str);
	kfree(thinkpad_id.model_str);
4782 4783
}

4784 4785
module_init(thinkpad_acpi_module_init);
module_exit(thinkpad_acpi_module_exit);