thinkpad_acpi.c 283.1 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-or-later
L
Linus Torvalds 已提交
2
/*
3
 *  thinkpad_acpi.c - ThinkPad ACPI Extras
L
Linus Torvalds 已提交
4
 *
5
 *  Copyright (C) 2004-2005 Borislav Deianov <borislav@users.sf.net>
6
 *  Copyright (C) 2006-2009 Henrique de Moraes Holschuh <hmh@hmh.eng.br>
7 8
 */

9 10
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

11
#define TPACPI_VERSION "0.26"
12
#define TPACPI_SYSFS_VERSION 0x030000
13 14

/*
L
Linus Torvalds 已提交
15
 *  Changelog:
16 17
 *  2007-10-20		changelog trimmed down
 *
18 19
 *  2007-03-27  0.14	renamed to thinkpad_acpi and moved to
 *  			drivers/misc.
20 21 22 23
 *
 *  2006-11-22	0.13	new maintainer
 *  			changelog now lives in git commit history, and will
 *  			not be updated further in-file.
24
 *
25 26
 *  2005-03-17	0.11	support for 600e, 770x
 *			    thanks to Jamie Lentin <lentinj@dial.pipex.com>
27 28
 *
 *  2005-01-16	0.9	use MODULE_VERSION
29 30 31 32 33 34
 *			    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>
L
Linus Torvalds 已提交
35 36
 */

37 38 39 40 41 42 43
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/list.h>
#include <linux/mutex.h>
44
#include <linux/sched.h>
45
#include <linux/sched/signal.h>
46 47 48
#include <linux/kthread.h>
#include <linux/freezer.h>
#include <linux/delay.h>
49
#include <linux/slab.h>
50 51
#include <linux/nvram.h>
#include <linux/proc_fs.h>
52
#include <linux/seq_file.h>
53 54
#include <linux/sysfs.h>
#include <linux/backlight.h>
55
#include <linux/bitops.h>
56 57 58 59 60
#include <linux/fb.h>
#include <linux/platform_device.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/input.h>
61
#include <linux/leds.h>
62
#include <linux/rfkill.h>
63 64 65
#include <linux/dmi.h>
#include <linux/jiffies.h>
#include <linux/workqueue.h>
66
#include <linux/acpi.h>
67
#include <linux/pci.h>
68
#include <linux/power_supply.h>
69
#include <linux/platform_profile.h>
70 71 72
#include <sound/core.h>
#include <sound/control.h>
#include <sound/initval.h>
73
#include <linux/uaccess.h>
74
#include <acpi/battery.h>
75
#include <acpi/video.h>
76 77 78 79 80 81 82

/* ThinkPad CMOS commands */
#define TP_CMOS_VOLUME_DOWN	0
#define TP_CMOS_VOLUME_UP	1
#define TP_CMOS_VOLUME_MUTE	2
#define TP_CMOS_BRIGHTNESS_UP	4
#define TP_CMOS_BRIGHTNESS_DOWN	5
83 84
#define TP_CMOS_THINKLIGHT_ON	12
#define TP_CMOS_THINKLIGHT_OFF	13
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111

/* NVRAM Addresses */
enum tp_nvram_addr {
	TP_NVRAM_ADDR_HK2		= 0x57,
	TP_NVRAM_ADDR_THINKLIGHT	= 0x58,
	TP_NVRAM_ADDR_VIDEO		= 0x59,
	TP_NVRAM_ADDR_BRIGHTNESS	= 0x5e,
	TP_NVRAM_ADDR_MIXER		= 0x60,
};

/* NVRAM bit masks */
enum {
	TP_NVRAM_MASK_HKT_THINKPAD	= 0x08,
	TP_NVRAM_MASK_HKT_ZOOM		= 0x20,
	TP_NVRAM_MASK_HKT_DISPLAY	= 0x40,
	TP_NVRAM_MASK_HKT_HIBERNATE	= 0x80,
	TP_NVRAM_MASK_THINKLIGHT	= 0x10,
	TP_NVRAM_MASK_HKT_DISPEXPND	= 0x30,
	TP_NVRAM_MASK_HKT_BRIGHTNESS	= 0x20,
	TP_NVRAM_MASK_LEVEL_BRIGHTNESS	= 0x0f,
	TP_NVRAM_POS_LEVEL_BRIGHTNESS	= 0,
	TP_NVRAM_MASK_MUTE		= 0x40,
	TP_NVRAM_MASK_HKT_VOLUME	= 0x80,
	TP_NVRAM_MASK_LEVEL_VOLUME	= 0x0f,
	TP_NVRAM_POS_LEVEL_VOLUME	= 0,
};

112 113 114 115 116
/* Misc NVRAM-related */
enum {
	TP_NVRAM_LEVEL_VOLUME_MAX = 14,
};

117
/* ACPI HIDs */
118 119
#define TPACPI_ACPI_IBM_HKEY_HID	"IBM0068"
#define TPACPI_ACPI_LENOVO_HKEY_HID	"LEN0068"
120
#define TPACPI_ACPI_LENOVO_HKEY_V2_HID	"LEN0268"
121
#define TPACPI_ACPI_EC_HID		"PNP0C09"
122 123 124 125 126

/* Input IDs */
#define TPACPI_HKEY_INPUT_PRODUCT	0x5054 /* "TP" */
#define TPACPI_HKEY_INPUT_VERSION	0x4101

127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
/* ACPI \WGSV commands */
enum {
	TP_ACPI_WGSV_GET_STATE		= 0x01, /* Get state information */
	TP_ACPI_WGSV_PWR_ON_ON_RESUME	= 0x02, /* Resume WWAN powered on */
	TP_ACPI_WGSV_PWR_OFF_ON_RESUME	= 0x03,	/* Resume WWAN powered off */
	TP_ACPI_WGSV_SAVE_STATE		= 0x04, /* Save state for S4/S5 */
};

/* TP_ACPI_WGSV_GET_STATE bits */
enum {
	TP_ACPI_WGSV_STATE_WWANEXIST	= 0x0001, /* WWAN hw available */
	TP_ACPI_WGSV_STATE_WWANPWR	= 0x0002, /* WWAN radio enabled */
	TP_ACPI_WGSV_STATE_WWANPWRRES	= 0x0004, /* WWAN state at resume */
	TP_ACPI_WGSV_STATE_WWANBIOSOFF	= 0x0008, /* WWAN disabled in BIOS */
	TP_ACPI_WGSV_STATE_BLTHEXIST	= 0x0001, /* BLTH hw available */
	TP_ACPI_WGSV_STATE_BLTHPWR	= 0x0002, /* BLTH radio enabled */
	TP_ACPI_WGSV_STATE_BLTHPWRRES	= 0x0004, /* BLTH state at resume */
	TP_ACPI_WGSV_STATE_BLTHBIOSOFF	= 0x0008, /* BLTH disabled in BIOS */
	TP_ACPI_WGSV_STATE_UWBEXIST	= 0x0010, /* UWB hw available */
	TP_ACPI_WGSV_STATE_UWBPWR	= 0x0020, /* UWB radio enabled */
};
148

149 150 151 152 153 154
/* HKEY events */
enum tpacpi_hkey_event_t {
	/* Hotkey-related */
	TP_HKEY_EV_HOTKEY_BASE		= 0x1001, /* first hotkey (FN+F1) */
	TP_HKEY_EV_BRGHT_UP		= 0x1010, /* Brightness up */
	TP_HKEY_EV_BRGHT_DOWN		= 0x1011, /* Brightness down */
155
	TP_HKEY_EV_KBD_LIGHT		= 0x1012, /* Thinklight/kbd backlight */
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
	TP_HKEY_EV_VOL_UP		= 0x1015, /* Volume up or unmute */
	TP_HKEY_EV_VOL_DOWN		= 0x1016, /* Volume down or unmute */
	TP_HKEY_EV_VOL_MUTE		= 0x1017, /* Mixer output mute */

	/* Reasons for waking up from S3/S4 */
	TP_HKEY_EV_WKUP_S3_UNDOCK	= 0x2304, /* undock requested, S3 */
	TP_HKEY_EV_WKUP_S4_UNDOCK	= 0x2404, /* undock requested, S4 */
	TP_HKEY_EV_WKUP_S3_BAYEJ	= 0x2305, /* bay ejection req, S3 */
	TP_HKEY_EV_WKUP_S4_BAYEJ	= 0x2405, /* bay ejection req, S4 */
	TP_HKEY_EV_WKUP_S3_BATLOW	= 0x2313, /* battery empty, S3 */
	TP_HKEY_EV_WKUP_S4_BATLOW	= 0x2413, /* battery empty, S4 */

	/* Auto-sleep after eject request */
	TP_HKEY_EV_BAYEJ_ACK		= 0x3003, /* bay ejection complete */
	TP_HKEY_EV_UNDOCK_ACK		= 0x4003, /* undock complete */

	/* Misc bay events */
	TP_HKEY_EV_OPTDRV_EJ		= 0x3006, /* opt. drive tray ejected */
174 175 176 177
	TP_HKEY_EV_HOTPLUG_DOCK		= 0x4010, /* docked into hotplug dock
						     or port replicator */
	TP_HKEY_EV_HOTPLUG_UNDOCK	= 0x4011, /* undocked from hotplug
						     dock or port replicator */
178 179 180 181 182 183

	/* User-interface events */
	TP_HKEY_EV_LID_CLOSE		= 0x5001, /* laptop lid closed */
	TP_HKEY_EV_LID_OPEN		= 0x5002, /* laptop lid opened */
	TP_HKEY_EV_TABLET_TABLET	= 0x5009, /* tablet swivel up */
	TP_HKEY_EV_TABLET_NOTEBOOK	= 0x500a, /* tablet swivel down */
184 185 186
	TP_HKEY_EV_TABLET_CHANGED	= 0x60c0, /* X1 Yoga (2016):
						   * enter/leave tablet mode
						   */
187 188 189 190
	TP_HKEY_EV_PEN_INSERTED		= 0x500b, /* tablet pen inserted */
	TP_HKEY_EV_PEN_REMOVED		= 0x500c, /* tablet pen removed */
	TP_HKEY_EV_BRGHT_CHANGED	= 0x5010, /* backlight control event */

191 192 193
	/* Key-related user-interface events */
	TP_HKEY_EV_KEY_NUMLOCK		= 0x6000, /* NumLock key pressed */
	TP_HKEY_EV_KEY_FN		= 0x6005, /* Fn key pressed? E420 */
194
	TP_HKEY_EV_KEY_FN_ESC           = 0x6060, /* Fn+Esc key pressed X240 */
195

196 197 198 199 200
	/* Thermal events */
	TP_HKEY_EV_ALARM_BAT_HOT	= 0x6011, /* battery too hot */
	TP_HKEY_EV_ALARM_BAT_XHOT	= 0x6012, /* battery critically hot */
	TP_HKEY_EV_ALARM_SENSOR_HOT	= 0x6021, /* sensor too hot */
	TP_HKEY_EV_ALARM_SENSOR_XHOT	= 0x6022, /* sensor critically hot */
201 202 203 204 205 206
	TP_HKEY_EV_THM_TABLE_CHANGED	= 0x6030, /* windows; thermal table changed */
	TP_HKEY_EV_THM_CSM_COMPLETED    = 0x6032, /* windows; thermal control set
						   * command completed. Related to
						   * AML DYTC */
	TP_HKEY_EV_THM_TRANSFM_CHANGED  = 0x60F0, /* windows; thermal transformation
						   * changed. Related to AML GMTS */
207

208 209
	/* AC-related events */
	TP_HKEY_EV_AC_CHANGED		= 0x6040, /* AC status changed */
210

211 212 213 214
	/* Further user-interface events */
	TP_HKEY_EV_PALM_DETECTED	= 0x60b0, /* palm hoveres keyboard */
	TP_HKEY_EV_PALM_UNDETECTED	= 0x60b1, /* palm removed */

215 216 217 218
	/* Misc */
	TP_HKEY_EV_RFKILL_CHANGED	= 0x7000, /* rfkill switch changed */
};

219 220 221 222
/****************************************************************************
 * Main driver
 */

223 224 225 226 227
#define TPACPI_NAME "thinkpad"
#define TPACPI_DESC "ThinkPad ACPI Extras"
#define TPACPI_FILE TPACPI_NAME "_acpi"
#define TPACPI_URL "http://ibm-acpi.sf.net/"
#define TPACPI_MAIL "ibm-acpi-devel@lists.sourceforge.net"
228

229 230 231
#define TPACPI_PROC_DIR "ibm"
#define TPACPI_ACPI_EVENT_PREFIX "ibm"
#define TPACPI_DRVR_NAME TPACPI_FILE
232
#define TPACPI_DRVR_SHORTNAME "tpacpi"
233
#define TPACPI_HWMON_DRVR_NAME TPACPI_NAME "_hwmon"
234

235
#define TPACPI_NVRAM_KTHREAD_NAME "ktpacpi_nvramd"
236
#define TPACPI_WORKQUEUE_NAME "ktpacpid"
237

238
#define TPACPI_MAX_ACPI_ARGS 3
239

240
/* Debugging printk groups */
241
#define TPACPI_DBG_ALL		0xffff
242
#define TPACPI_DBG_DISCLOSETASK	0x8000
243 244
#define TPACPI_DBG_INIT		0x0001
#define TPACPI_DBG_EXIT		0x0002
245
#define TPACPI_DBG_RFKILL	0x0004
246
#define TPACPI_DBG_HKEY		0x0008
247
#define TPACPI_DBG_FAN		0x0010
248
#define TPACPI_DBG_BRGHT	0x0020
249
#define TPACPI_DBG_MIXER	0x0040
250

251 252 253
#define onoff(status, bit) ((status) & (1 << (bit)) ? "on" : "off")
#define enabled(status, bit) ((status) & (1 << (bit)) ? "enabled" : "disabled")
#define strlencmp(a, b) (strncmp((a), (b), strlen(b)))
254 255 256


/****************************************************************************
257
 * Driver-wide structs and misc. variables
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
 */

struct ibm_struct;

struct tp_acpi_drv_struct {
	const struct acpi_device_id *hid;
	struct acpi_driver *driver;

	void (*notify) (struct ibm_struct *, u32);
	acpi_handle *handle;
	u32 type;
	struct acpi_device *device;
};

struct ibm_struct {
	char *name;

275
	int (*read) (struct seq_file *);
276 277 278
	int (*write) (char *);
	void (*exit) (void);
	void (*resume) (void);
279
	void (*suspend) (void);
280
	void (*shutdown) (void);
281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298

	struct list_head all_drivers;

	struct tp_acpi_drv_struct *acpi;

	struct {
		u8 acpi_driver_registered:1;
		u8 acpi_notify_installed:1;
		u8 proc_created:1;
		u8 init_called:1;
		u8 experimental:1;
	} flags;
};

struct ibm_init_struct {
	char param[32];

	int (*init) (struct ibm_init_struct *);
A
Al Viro 已提交
299
	umode_t base_procfs_mode;
300 301 302 303 304 305 306 307
	struct ibm_struct *data;
};

static struct {
	u32 bluetooth:1;
	u32 hotkey:1;
	u32 hotkey_mask:1;
	u32 hotkey_wlsw:1;
308 309 310
	enum {
		TP_HOTKEY_TABLET_NONE = 0,
		TP_HOTKEY_TABLET_USES_MHKG,
311
		TP_HOTKEY_TABLET_USES_GMMS,
312
	} hotkey_tablet;
313
	u32 kbdlight:1;
314 315
	u32 light:1;
	u32 light_status:1;
316
	u32 bright_acpimode:1;
317
	u32 bright_unkfw:1;
318
	u32 wan:1;
319
	u32 uwb:1;
320
	u32 fan_ctrl_status_undef:1;
321
	u32 second_fan:1;
322
	u32 second_fan_ctl:1;
323
	u32 beep_needs_two_args:1;
324
	u32 mixer_no_level_control:1;
325
	u32 battery_force_primary:1;
326 327 328 329 330 331 332
	u32 input_device_registered:1;
	u32 platform_drv_registered:1;
	u32 platform_drv_attrs_registered:1;
	u32 sensors_pdrv_registered:1;
	u32 sensors_pdrv_attrs_registered:1;
	u32 sensors_pdev_attrs_registered:1;
	u32 hotkey_poll_active:1;
333
	u32 has_adaptive_kbd:1;
334 335
} tp_features;

336 337
static struct {
	u16 hotkey_mask_ff:1;
338
	u16 volume_ctrl_forbidden:1;
339 340
} tp_warned;

341 342 343 344 345 346 347
struct thinkpad_id_data {
	unsigned int vendor;	/* ThinkPad vendor:
				 * PCI_VENDOR_ID_IBM/PCI_VENDOR_ID_LENOVO */

	char *bios_version_str;	/* Something like 1ZET51WW (1.03z) */
	char *ec_version_str;	/* Something like 1ZHT51WW-1.04a */

348 349 350
	u32 bios_model;		/* 1Y = 0x3159, 0 = unknown */
	u32 ec_model;
	u16 bios_release;	/* 1ZETK1WW = 0x4b31, 0 = unknown */
351
	u16 ec_release;
352

353 354
	char *model_str;	/* ThinkPad T43 */
	char *nummodel_str;	/* 9384A9C for a 9384-A9C model */
355 356 357
};
static struct thinkpad_id_data thinkpad_id;

358 359 360 361 362 363
static enum {
	TPACPI_LIFE_INIT = 0,
	TPACPI_LIFE_RUNNING,
	TPACPI_LIFE_EXITING,
} tpacpi_lifecycle;

364 365 366
static int experimental;
static u32 dbg_level;

367 368
static struct workqueue_struct *tpacpi_wq;

369 370 371 372 373 374
enum led_status_t {
	TPACPI_LED_OFF = 0,
	TPACPI_LED_ON,
	TPACPI_LED_BLINK,
};

375
/* tpacpi LED class */
376 377
struct tpacpi_led_classdev {
	struct led_classdev led_classdev;
378
	int led;
379 380
};

381 382 383
/* brightness level capabilities */
static unsigned int bright_maxlvl;	/* 0 = unknown */

384 385
#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
static int dbg_wlswemul;
386
static bool tpacpi_wlsw_emulstate;
387
static int dbg_bluetoothemul;
388
static bool tpacpi_bluetooth_emulstate;
389
static int dbg_wwanemul;
390
static bool tpacpi_wwan_emulstate;
391
static int dbg_uwbemul;
392
static bool tpacpi_uwb_emulstate;
393 394 395
#endif


396 397 398 399
/*************************************************************************
 *  Debugging helpers
 */

400 401 402 403 404 405
#define dbg_printk(a_dbg_level, format, arg...)				\
do {									\
	if (dbg_level & (a_dbg_level))					\
		printk(KERN_DEBUG pr_fmt("%s: " format),		\
		       __func__, ##arg);				\
} while (0)
406 407 408 409 410

#ifdef CONFIG_THINKPAD_ACPI_DEBUG
#define vdbg_printk dbg_printk
static const char *str_supported(int is_supported);
#else
411 412
static inline const char *str_supported(int is_supported) { return ""; }
#define vdbg_printk(a_dbg_level, format, arg...)	\
413
	do { if (0) no_printk(format, ##arg); } while (0)
414 415
#endif

416 417
static void tpacpi_log_usertask(const char * const what)
{
418 419
	printk(KERN_DEBUG pr_fmt("%s: access by process with PID %d\n"),
	       what, task_tgid_vnr(current));
420 421
}

422 423 424 425 426 427 428 429
#define tpacpi_disclose_usertask(what, format, arg...)			\
do {									\
	if (unlikely((dbg_level & TPACPI_DBG_DISCLOSETASK) &&		\
		     (tpacpi_lifecycle == TPACPI_LIFE_RUNNING))) {	\
		printk(KERN_DEBUG pr_fmt("%s: PID %d: " format),	\
		       what, task_tgid_vnr(current), ## arg);		\
	}								\
} while (0)
430

431 432 433
/*
 * Quirk handling helpers
 *
434 435
 * ThinkPad IDs and versions seen in the field so far are
 * two or three characters from the set [0-9A-Z], i.e. base 36.
436 437 438 439
 *
 * We use values well outside that range as specials.
 */

440 441
#define TPACPI_MATCH_ANY		0xffffffffU
#define TPACPI_MATCH_ANY_VERSION	0xffffU
442 443
#define TPACPI_MATCH_UNKNOWN		0U

444 445 446 447
/* TPID('1', 'Y') == 0x3159 */
#define TPID(__c1, __c2)	(((__c1) << 8) | (__c2))
#define TPID3(__c1, __c2, __c3)	(((__c1) << 16) | ((__c2) << 8) | (__c3))
#define TPVER TPID
448 449 450 451 452 453 454 455 456 457 458 459 460

#define TPACPI_Q_IBM(__id1, __id2, __quirk)	\
	{ .vendor = PCI_VENDOR_ID_IBM,		\
	  .bios = TPID(__id1, __id2),		\
	  .ec = TPACPI_MATCH_ANY,		\
	  .quirks = (__quirk) }

#define TPACPI_Q_LNV(__id1, __id2, __quirk)	\
	{ .vendor = PCI_VENDOR_ID_LENOVO,	\
	  .bios = TPID(__id1, __id2),		\
	  .ec = TPACPI_MATCH_ANY,		\
	  .quirks = (__quirk) }

461 462 463 464 465 466
#define TPACPI_Q_LNV3(__id1, __id2, __id3, __quirk) \
	{ .vendor = PCI_VENDOR_ID_LENOVO,	\
	  .bios = TPID3(__id1, __id2, __id3),	\
	  .ec = TPACPI_MATCH_ANY,		\
	  .quirks = (__quirk) }

467 468 469 470 471 472
#define TPACPI_QEC_IBM(__id1, __id2, __quirk)	\
	{ .vendor = PCI_VENDOR_ID_IBM,		\
	  .bios = TPACPI_MATCH_ANY,		\
	  .ec = TPID(__id1, __id2),		\
	  .quirks = (__quirk) }

473 474 475 476 477 478
#define TPACPI_QEC_LNV(__id1, __id2, __quirk)	\
	{ .vendor = PCI_VENDOR_ID_LENOVO,	\
	  .bios = TPACPI_MATCH_ANY,		\
	  .ec = TPID(__id1, __id2),		\
	  .quirks = (__quirk) }

479 480
struct tpacpi_quirk {
	unsigned int vendor;
481 482
	u32 bios;
	u32 ec;
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517
	unsigned long quirks;
};

/**
 * tpacpi_check_quirks() - search BIOS/EC version on a list
 * @qlist:		array of &struct tpacpi_quirk
 * @qlist_size:		number of elements in @qlist
 *
 * Iterates over a quirks list until one is found that matches the
 * ThinkPad's vendor, BIOS and EC model.
 *
 * Returns 0 if nothing matches, otherwise returns the quirks field of
 * the matching &struct tpacpi_quirk entry.
 *
 * The match criteria is: vendor, ec and bios much match.
 */
static unsigned long __init tpacpi_check_quirks(
			const struct tpacpi_quirk *qlist,
			unsigned int qlist_size)
{
	while (qlist_size) {
		if ((qlist->vendor == thinkpad_id.vendor ||
				qlist->vendor == TPACPI_MATCH_ANY) &&
		    (qlist->bios == thinkpad_id.bios_model ||
				qlist->bios == TPACPI_MATCH_ANY) &&
		    (qlist->ec == thinkpad_id.ec_model ||
				qlist->ec == TPACPI_MATCH_ANY))
			return qlist->quirks;

		qlist_size--;
		qlist++;
	}
	return 0;
}

518 519 520 521 522 523 524 525 526
static inline bool __pure __init tpacpi_is_lenovo(void)
{
	return thinkpad_id.vendor == PCI_VENDOR_ID_LENOVO;
}

static inline bool __pure __init tpacpi_is_ibm(void)
{
	return thinkpad_id.vendor == PCI_VENDOR_ID_IBM;
}
527

528 529 530 531 532 533 534 535 536 537 538
/****************************************************************************
 ****************************************************************************
 *
 * ACPI Helpers and device model
 *
 ****************************************************************************
 ****************************************************************************/

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

540
static acpi_handle root_handle;
541
static acpi_handle ec_handle;
L
Linus Torvalds 已提交
542

543
#define TPACPI_HANDLE(object, parent, paths...)			\
L
Linus Torvalds 已提交
544
	static acpi_handle  object##_handle;			\
545
	static const acpi_handle * const object##_parent __initconst =	\
546 547
						&parent##_handle; \
	static char *object##_paths[] __initdata = { paths }
L
Linus Torvalds 已提交
548

549 550
TPACPI_HANDLE(ecrd, ec, "ECRD");	/* 570 */
TPACPI_HANDLE(ecwr, ec, "ECWR");	/* 570 */
551

552 553
TPACPI_HANDLE(cmos, root, "\\UCMS",	/* R50, R50e, R50p, R51, */
					/* T4x, X31, X40 */
554 555
	   "\\CMOS",		/* A3x, G4x, R32, T23, T30, X22-24, X30 */
	   "\\CMS",		/* R40, R40e */
556
	   );			/* all others */
557

558
TPACPI_HANDLE(hkey, ec, "\\_SB.HKEY",	/* 600e/x, 770e, 770x */
559 560
	   "^HKEY",		/* R30, R31 */
	   "HKEY",		/* all others */
561
	   );			/* 570 */
562

563 564
/*************************************************************************
 * ACPI helpers
565 566
 */

L
Linus Torvalds 已提交
567
static int acpi_evalf(acpi_handle handle,
568
		      int *res, char *method, char *fmt, ...)
L
Linus Torvalds 已提交
569 570
{
	char *fmt0 = fmt;
571
	struct acpi_object_list params;
572
	union acpi_object in_objs[TPACPI_MAX_ACPI_ARGS];
573 574 575 576 577 578 579
	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 已提交
580 581

	if (!*fmt) {
582
		pr_err("acpi_evalf() called with empty format\n");
L
Linus Torvalds 已提交
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604
		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;
605
			/* add more types as needed */
L
Linus Torvalds 已提交
606
		default:
607 608
			pr_err("acpi_evalf() called with invalid format character '%c'\n",
			       c);
609
			va_end(ap);
L
Linus Torvalds 已提交
610 611 612 613 614
			return 0;
		}
	}
	va_end(ap);

615 616 617 618 619 620
	if (res_type != 'v') {
		result.length = sizeof(out_obj);
		result.pointer = &out_obj;
		resultp = &result;
	} else
		resultp = NULL;
L
Linus Torvalds 已提交
621

622
	status = acpi_evaluate_object(handle, method, &params, resultp);
L
Linus Torvalds 已提交
623 624

	switch (res_type) {
625
	case 'd':		/* int */
626 627 628
		success = (status == AE_OK &&
			   out_obj.type == ACPI_TYPE_INTEGER);
		if (success && res)
629
			*res = out_obj.integer.value;
L
Linus Torvalds 已提交
630
		break;
631
	case 'v':		/* void */
L
Linus Torvalds 已提交
632 633
		success = status == AE_OK;
		break;
634
		/* add more types as needed */
L
Linus Torvalds 已提交
635
	default:
636 637
		pr_err("acpi_evalf() called with invalid format character '%c'\n",
		       res_type);
L
Linus Torvalds 已提交
638 639 640
		return 0;
	}

641
	if (!success && !quiet)
642
		pr_err("acpi_evalf(%s, %s, ...) failed: %s\n",
643
		       method, fmt0, acpi_format_exception(status));
644 645 646 647

	return success;
}

648
static int acpi_ec_read(int i, u8 *p)
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
{
	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;
}

677 678 679 680 681 682 683 684 685 686 687
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;
}

688 689 690 691
/*************************************************************************
 * ACPI device model
 */

692 693
#define TPACPI_ACPIHANDLE_INIT(object) \
	drv_acpi_handle_init(#object, &object##_handle, *object##_parent, \
694
		object##_paths, ARRAY_SIZE(object##_paths))
695

696 697 698
static void __init drv_acpi_handle_init(const char *name,
			   acpi_handle *handle, const acpi_handle parent,
			   char **paths, const int num_paths)
699 700 701 702
{
	int i;
	acpi_status status;

703 704 705
	vdbg_printk(TPACPI_DBG_INIT, "trying to locate ACPI handle for %s\n",
		name);

706 707 708
	for (i = 0; i < num_paths; i++) {
		status = acpi_get_handle(parent, paths[i], handle);
		if (ACPI_SUCCESS(status)) {
709 710
			dbg_printk(TPACPI_DBG_INIT,
				   "Found ACPI handle %s for %s\n",
711
				   paths[i], name);
712 713 714 715
			return;
		}
	}

716 717
	vdbg_printk(TPACPI_DBG_INIT, "ACPI handle for %s not found\n",
		    name);
718 719 720
	*handle = NULL;
}

721 722 723
static acpi_status __init tpacpi_acpi_handle_locate_callback(acpi_handle handle,
			u32 level, void *context, void **return_value)
{
724 725 726 727 728 729 730 731
	struct acpi_device *dev;
	if (!strcmp(context, "video")) {
		if (acpi_bus_get_device(handle, &dev))
			return AE_OK;
		if (strcmp(ACPI_VIDEO_HID, acpi_device_hid(dev)))
			return AE_OK;
	}

732 733 734 735 736 737 738 739 740 741 742 743
	*(acpi_handle *)return_value = handle;

	return AE_CTRL_TERMINATE;
}

static void __init tpacpi_acpi_handle_locate(const char *name,
		const char *hid,
		acpi_handle *handle)
{
	acpi_status status;
	acpi_handle device_found;

744
	BUG_ON(!name || !handle);
745 746
	vdbg_printk(TPACPI_DBG_INIT,
			"trying to locate ACPI handle for %s, using HID %s\n",
747
			name, hid ? hid : "NULL");
748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765

	memset(&device_found, 0, sizeof(device_found));
	status = acpi_get_devices(hid, tpacpi_acpi_handle_locate_callback,
				  (void *)name, &device_found);

	*handle = NULL;

	if (ACPI_SUCCESS(status)) {
		*handle = device_found;
		dbg_printk(TPACPI_DBG_INIT,
			   "Found ACPI handle for %s\n", name);
	} else {
		vdbg_printk(TPACPI_DBG_INIT,
			    "Could not locate an ACPI handle for %s: %s\n",
			    name, acpi_format_exception(status));
	}
}

766
static void dispatch_acpi_notify(acpi_handle handle, u32 event, void *data)
767 768 769
{
	struct ibm_struct *ibm = data;

770 771 772
	if (tpacpi_lifecycle != TPACPI_LIFE_RUNNING)
		return;

773
	if (!ibm || !ibm->acpi || !ibm->acpi->notify)
774 775
		return;

776
	ibm->acpi->notify(ibm, event);
777 778
}

779
static int __init setup_acpi_notify(struct ibm_struct *ibm)
780 781
{
	acpi_status status;
782
	int rc;
783

784 785 786
	BUG_ON(!ibm->acpi);

	if (!*ibm->acpi->handle)
787 788
		return 0;

789
	vdbg_printk(TPACPI_DBG_INIT,
790 791
		"setting up ACPI notify for %s\n", ibm->name);

792 793
	rc = acpi_bus_get_device(*ibm->acpi->handle, &ibm->acpi->device);
	if (rc < 0) {
794
		pr_err("acpi_bus_get_device(%s) failed: %d\n", ibm->name, rc);
795 796 797
		return -ENODEV;
	}

798
	ibm->acpi->device->driver_data = ibm;
799
	sprintf(acpi_device_class(ibm->acpi->device), "%s/%s",
800
		TPACPI_ACPI_EVENT_PREFIX,
801
		ibm->name);
802

803 804
	status = acpi_install_notify_handler(*ibm->acpi->handle,
			ibm->acpi->type, dispatch_acpi_notify, ibm);
805 806
	if (ACPI_FAILURE(status)) {
		if (status == AE_ALREADY_EXISTS) {
807 808
			pr_notice("another device driver is already handling %s events\n",
				  ibm->name);
809
		} else {
810
			pr_err("acpi_install_notify_handler(%s) failed: %s\n",
811
			       ibm->name, acpi_format_exception(status));
812 813 814
		}
		return -ENODEV;
	}
815
	ibm->flags.acpi_notify_installed = 1;
816 817 818
	return 0;
}

819
static int __init tpacpi_device_add(struct acpi_device *device)
820 821 822 823
{
	return 0;
}

824
static int __init register_tpacpi_subdriver(struct ibm_struct *ibm)
825
{
826
	int rc;
827

828 829 830
	dbg_printk(TPACPI_DBG_INIT,
		"registering %s as an ACPI driver\n", ibm->name);

831 832 833 834
	BUG_ON(!ibm->acpi);

	ibm->acpi->driver = kzalloc(sizeof(struct acpi_driver), GFP_KERNEL);
	if (!ibm->acpi->driver) {
835
		pr_err("failed to allocate memory for ibm->acpi->driver\n");
836
		return -ENOMEM;
837 838
	}

839
	sprintf(ibm->acpi->driver->name, "%s_%s", TPACPI_NAME, ibm->name);
840
	ibm->acpi->driver->ids = ibm->acpi->hid;
841

842
	ibm->acpi->driver->ops.add = &tpacpi_device_add;
843

844 845
	rc = acpi_bus_register_driver(ibm->acpi->driver);
	if (rc < 0) {
846
		pr_err("acpi_bus_register_driver(%s) failed: %d\n",
847
		       ibm->name, rc);
848 849
		kfree(ibm->acpi->driver);
		ibm->acpi->driver = NULL;
850
	} else if (!rc)
851
		ibm->flags.acpi_driver_registered = 1;
852

853
	return rc;
854 855 856 857 858 859 860 861 862 863 864
}


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

865
static int dispatch_proc_show(struct seq_file *m, void *v)
866
{
867
	struct ibm_struct *ibm = m->private;
868 869 870

	if (!ibm || !ibm->read)
		return -EINVAL;
871 872
	return ibm->read(m);
}
873

874 875
static int dispatch_proc_open(struct inode *inode, struct file *file)
{
A
Al Viro 已提交
876
	return single_open(file, dispatch_proc_show, PDE_DATA(inode));
877 878
}

879
static ssize_t dispatch_proc_write(struct file *file,
880
			const char __user *userbuf,
881
			size_t count, loff_t *pos)
882
{
A
Al Viro 已提交
883
	struct ibm_struct *ibm = PDE_DATA(file_inode(file));
884 885 886 887 888
	char *kernbuf;
	int ret;

	if (!ibm || !ibm->write)
		return -EINVAL;
889 890 891 892 893 894
	if (count > PAGE_SIZE - 1)
		return -EINVAL;

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

896 897 898 899
	if (copy_from_user(kernbuf, userbuf, count)) {
		kfree(kernbuf);
		return -EFAULT;
	}
L
Linus Torvalds 已提交
900

901
	kernbuf[count] = 0;
902 903 904
	ret = ibm->write(kernbuf);
	if (ret == 0)
		ret = count;
L
Linus Torvalds 已提交
905

906 907 908
	kfree(kernbuf);

	return ret;
L
Linus Torvalds 已提交
909 910
}

911 912 913 914 915 916
static const struct proc_ops dispatch_proc_ops = {
	.proc_open	= dispatch_proc_open,
	.proc_read	= seq_read,
	.proc_lseek	= seq_lseek,
	.proc_release	= single_release,
	.proc_write	= dispatch_proc_write,
917 918
};

919 920 921
/****************************************************************************
 ****************************************************************************
 *
922
 * Device model: input, hwmon and platform
923 924 925 926
 *
 ****************************************************************************
 ****************************************************************************/

927
static struct platform_device *tpacpi_pdev;
928
static struct platform_device *tpacpi_sensors_pdev;
929
static struct device *tpacpi_hwmon;
930
static struct input_dev *tpacpi_inputdev;
931
static struct mutex tpacpi_inputdev_send_mutex;
932
static LIST_HEAD(tpacpi_all_drivers);
933

934
#ifdef CONFIG_PM_SLEEP
935
static int tpacpi_suspend_handler(struct device *dev)
936 937 938 939 940 941 942
{
	struct ibm_struct *ibm, *itmp;

	list_for_each_entry_safe(ibm, itmp,
				 &tpacpi_all_drivers,
				 all_drivers) {
		if (ibm->suspend)
943
			(ibm->suspend)();
944 945 946 947 948
	}

	return 0;
}

949
static int tpacpi_resume_handler(struct device *dev)
950 951 952 953 954 955 956 957 958 959 960 961
{
	struct ibm_struct *ibm, *itmp;

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

	return 0;
}
962
#endif
963

964 965 966
static SIMPLE_DEV_PM_OPS(tpacpi_pm,
			 tpacpi_suspend_handler, tpacpi_resume_handler);

967 968 969 970 971 972 973 974 975 976 977 978
static void tpacpi_shutdown_handler(struct platform_device *pdev)
{
	struct ibm_struct *ibm, *itmp;

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

979 980
static struct platform_driver tpacpi_pdriver = {
	.driver = {
981
		.name = TPACPI_DRVR_NAME,
982
		.pm = &tpacpi_pm,
983
	},
984
	.shutdown = tpacpi_shutdown_handler,
985 986
};

987 988
static struct platform_driver tpacpi_hwmon_pdriver = {
	.driver = {
989
		.name = TPACPI_HWMON_DRVR_NAME,
990 991
	},
};
992

993
/*************************************************************************
994
 * sysfs support helpers
995 996
 */

997 998 999
struct attribute_set {
	unsigned int members, max_members;
	struct attribute_group group;
1000 1001
};

1002 1003 1004 1005 1006 1007
struct attribute_set_obj {
	struct attribute_set s;
	struct attribute *a;
} __attribute__((packed));

static struct attribute_set *create_attr_set(unsigned int max_members,
1008
						const char *name)
1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
{
	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;
}

1028
#define destroy_attr_set(_set) \
1029
	kfree(_set)
1030

1031
/* not multi-threaded safe, use it in a single thread per set */
1032
static int add_to_attr_set(struct attribute_set *s, struct attribute *attr)
1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
{
	if (!s || !attr)
		return -EINVAL;

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

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

	return 0;
}

1046
static int add_many_to_attr_set(struct attribute_set *s,
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
			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;
}

1061
static void delete_attr_set(struct attribute_set *s, struct kobject *kobj)
1062 1063 1064 1065 1066
{
	sysfs_remove_group(kobj, &s->group);
	destroy_attr_set(s);
}

1067 1068 1069
#define register_attr_set_with_sysfs(_attr_set, _kobj) \
	sysfs_create_group(_kobj, &_attr_set->group)

1070 1071 1072 1073 1074
static int parse_strtoul(const char *buf,
		unsigned long max, unsigned long *value)
{
	char *endp;

1075 1076
	*value = simple_strtoul(skip_spaces(buf), &endp, 0);
	endp = skip_spaces(endp);
1077 1078 1079 1080 1081 1082
	if (*endp || *value > max)
		return -EINVAL;

	return 0;
}

1083 1084 1085
static void tpacpi_disable_brightness_delay(void)
{
	if (acpi_evalf(hkey_handle, NULL, "PWMS", "qvd", 0))
1086
		pr_notice("ACPI backlight control delay disabled\n");
1087 1088
}

J
Johannes Berg 已提交
1089 1090 1091 1092
static void printk_deprecated_attribute(const char * const what,
					const char * const details)
{
	tpacpi_log_usertask("deprecated sysfs attribute");
1093
	pr_warn("WARNING: sysfs attribute %s is deprecated and will be removed. %s\n",
J
Johannes Berg 已提交
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 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 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
		what, details);
}

/*************************************************************************
 * rfkill and radio control support helpers
 */

/*
 * ThinkPad-ACPI firmware handling model:
 *
 * WLSW (master wireless switch) is event-driven, and is common to all
 * firmware-controlled radios.  It cannot be controlled, just monitored,
 * as expected.  It overrides all radio state in firmware
 *
 * The kernel, a masked-off hotkey, and WLSW can change the radio state
 * (TODO: verify how WLSW interacts with the returned radio state).
 *
 * The only time there are shadow radio state changes, is when
 * masked-off hotkeys are used.
 */

/*
 * Internal driver API for radio state:
 *
 * int: < 0 = error, otherwise enum tpacpi_rfkill_state
 * bool: true means radio blocked (off)
 */
enum tpacpi_rfkill_state {
	TPACPI_RFK_RADIO_OFF = 0,
	TPACPI_RFK_RADIO_ON
};

/* rfkill switches */
enum tpacpi_rfk_id {
	TPACPI_RFK_BLUETOOTH_SW_ID = 0,
	TPACPI_RFK_WWAN_SW_ID,
	TPACPI_RFK_UWB_SW_ID,
	TPACPI_RFK_SW_MAX
};

static const char *tpacpi_rfkill_names[] = {
	[TPACPI_RFK_BLUETOOTH_SW_ID] = "bluetooth",
	[TPACPI_RFK_WWAN_SW_ID] = "wwan",
	[TPACPI_RFK_UWB_SW_ID] = "uwb",
	[TPACPI_RFK_SW_MAX] = NULL
};

/* ThinkPad-ACPI rfkill subdriver */
struct tpacpi_rfk {
	struct rfkill *rfkill;
	enum tpacpi_rfk_id id;
	const struct tpacpi_rfk_ops *ops;
};

struct tpacpi_rfk_ops {
	/* firmware interface */
	int (*get_status)(void);
	int (*set_status)(const enum tpacpi_rfkill_state);
};

static struct tpacpi_rfk *tpacpi_rfkill_switches[TPACPI_RFK_SW_MAX];

/* Query FW and update rfkill sw state for a given rfkill switch */
static int tpacpi_rfk_update_swstate(const struct tpacpi_rfk *tp_rfk)
{
	int status;

	if (!tp_rfk)
		return -ENODEV;

	status = (tp_rfk->ops->get_status)();
	if (status < 0)
		return status;

	rfkill_set_sw_state(tp_rfk->rfkill,
			    (status == TPACPI_RFK_RADIO_OFF));

	return status;
}

/* Query FW and update rfkill sw state for all rfkill switches */
static void tpacpi_rfk_update_swstate_all(void)
{
	unsigned int i;

	for (i = 0; i < TPACPI_RFK_SW_MAX; i++)
		tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[i]);
}

/*
 * Sync the HW-blocking state of all rfkill switches,
 * do notice it causes the rfkill core to schedule uevents
 */
static void tpacpi_rfk_update_hwblock_state(bool blocked)
{
	unsigned int i;
	struct tpacpi_rfk *tp_rfk;

	for (i = 0; i < TPACPI_RFK_SW_MAX; i++) {
		tp_rfk = tpacpi_rfkill_switches[i];
		if (tp_rfk) {
			if (rfkill_set_hw_state(tp_rfk->rfkill,
						blocked)) {
				/* ignore -- we track sw block */
			}
		}
	}
}

/* Call to get the WLSW state from the firmware */
static int hotkey_get_wlsw(void);

/* Call to query WLSW state and update all rfkill switches */
static bool tpacpi_rfk_check_hwblock_state(void)
{
	int res = hotkey_get_wlsw();
	int hw_blocked;

	/* When unknown or unsupported, we have to assume it is unblocked */
	if (res < 0)
		return false;

	hw_blocked = (res == TPACPI_RFK_RADIO_OFF);
	tpacpi_rfk_update_hwblock_state(hw_blocked);

	return hw_blocked;
}

static int tpacpi_rfk_hook_set_block(void *data, bool blocked)
{
	struct tpacpi_rfk *tp_rfk = data;
	int res;

	dbg_printk(TPACPI_DBG_RFKILL,
		   "request to change radio state to %s\n",
		   blocked ? "blocked" : "unblocked");

	/* try to set radio state */
	res = (tp_rfk->ops->set_status)(blocked ?
				TPACPI_RFK_RADIO_OFF : TPACPI_RFK_RADIO_ON);

	/* and update the rfkill core with whatever the FW really did */
	tpacpi_rfk_update_swstate(tp_rfk);

	return (res < 0) ? res : 0;
}

static const struct rfkill_ops tpacpi_rfk_rfkill_ops = {
	.set_block = tpacpi_rfk_hook_set_block,
};

static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
			const struct tpacpi_rfk_ops *tp_rfkops,
1247 1248
			const enum rfkill_type rfktype,
			const char *name,
J
Johannes Berg 已提交
1249
			const bool set_default)
1250
{
J
Johannes Berg 已提交
1251
	struct tpacpi_rfk *atp_rfk;
1252
	int res;
1253
	bool sw_state = false;
1254
	bool hw_state;
1255
	int sw_status;
1256

J
Johannes Berg 已提交
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266
	BUG_ON(id >= TPACPI_RFK_SW_MAX || tpacpi_rfkill_switches[id]);

	atp_rfk = kzalloc(sizeof(struct tpacpi_rfk), GFP_KERNEL);
	if (atp_rfk)
		atp_rfk->rfkill = rfkill_alloc(name,
						&tpacpi_pdev->dev,
						rfktype,
						&tpacpi_rfk_rfkill_ops,
						atp_rfk);
	if (!atp_rfk || !atp_rfk->rfkill) {
1267
		pr_err("failed to allocate memory for rfkill class\n");
J
Johannes Berg 已提交
1268
		kfree(atp_rfk);
1269 1270 1271
		return -ENOMEM;
	}

J
Johannes Berg 已提交
1272 1273
	atp_rfk->id = id;
	atp_rfk->ops = tp_rfkops;
1274

1275 1276
	sw_status = (tp_rfkops->get_status)();
	if (sw_status < 0) {
1277 1278
		pr_err("failed to read initial state for %s, error %d\n",
		       name, sw_status);
1279
	} else {
1280
		sw_state = (sw_status == TPACPI_RFK_RADIO_OFF);
1281 1282 1283
		if (set_default) {
			/* try to keep the initial state, since we ask the
			 * firmware to preserve it across S5 in NVRAM */
1284
			rfkill_init_sw_state(atp_rfk->rfkill, sw_state);
1285 1286
		}
	}
1287 1288
	hw_state = tpacpi_rfk_check_hwblock_state();
	rfkill_set_hw_state(atp_rfk->rfkill, hw_state);
J
Johannes Berg 已提交
1289 1290

	res = rfkill_register(atp_rfk->rfkill);
1291
	if (res < 0) {
1292
		pr_err("failed to register %s rfkill switch: %d\n", name, res);
J
Johannes Berg 已提交
1293 1294
		rfkill_destroy(atp_rfk->rfkill);
		kfree(atp_rfk);
1295 1296 1297
		return res;
	}

J
Johannes Berg 已提交
1298
	tpacpi_rfkill_switches[id] = atp_rfk;
1299

1300
	pr_info("rfkill switch %s: radio is %sblocked\n",
1301
		name, (sw_state || hw_state) ? "" : "un");
1302 1303 1304
	return 0;
}

J
Johannes Berg 已提交
1305
static void tpacpi_destroy_rfkill(const enum tpacpi_rfk_id id)
1306
{
J
Johannes Berg 已提交
1307 1308 1309 1310 1311 1312 1313
	struct tpacpi_rfk *tp_rfk;

	BUG_ON(id >= TPACPI_RFK_SW_MAX);

	tp_rfk = tpacpi_rfkill_switches[id];
	if (tp_rfk) {
		rfkill_unregister(tp_rfk->rfkill);
1314
		rfkill_destroy(tp_rfk->rfkill);
J
Johannes Berg 已提交
1315 1316 1317
		tpacpi_rfkill_switches[id] = NULL;
		kfree(tp_rfk);
	}
1318 1319 1320 1321 1322 1323 1324 1325
}

static void printk_deprecated_rfkill_attribute(const char * const what)
{
	printk_deprecated_attribute(what,
			"Please switch to generic rfkill before year 2010");
}

J
Johannes Berg 已提交
1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 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
/* sysfs <radio> enable ------------------------------------------------ */
static ssize_t tpacpi_rfk_sysfs_enable_show(const enum tpacpi_rfk_id id,
					    struct device_attribute *attr,
					    char *buf)
{
	int status;

	printk_deprecated_rfkill_attribute(attr->attr.name);

	/* This is in the ABI... */
	if (tpacpi_rfk_check_hwblock_state()) {
		status = TPACPI_RFK_RADIO_OFF;
	} else {
		status = tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[id]);
		if (status < 0)
			return status;
	}

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

static ssize_t tpacpi_rfk_sysfs_enable_store(const enum tpacpi_rfk_id id,
			    struct device_attribute *attr,
			    const char *buf, size_t count)
{
	unsigned long t;
	int res;

	printk_deprecated_rfkill_attribute(attr->attr.name);

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

	tpacpi_disclose_usertask(attr->attr.name, "set to %ld\n", t);

	/* This is in the ABI... */
	if (tpacpi_rfk_check_hwblock_state() && !!t)
		return -EPERM;

	res = tpacpi_rfkill_switches[id]->ops->set_status((!!t) ?
				TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF);
	tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[id]);

	return (res < 0) ? res : count;
}

/* procfs -------------------------------------------------------------- */
1374
static int tpacpi_rfk_procfs_read(const enum tpacpi_rfk_id id, struct seq_file *m)
J
Johannes Berg 已提交
1375 1376
{
	if (id >= TPACPI_RFK_SW_MAX)
1377
		seq_printf(m, "status:\t\tnot supported\n");
J
Johannes Berg 已提交
1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390
	else {
		int status;

		/* This is in the ABI... */
		if (tpacpi_rfk_check_hwblock_state()) {
			status = TPACPI_RFK_RADIO_OFF;
		} else {
			status = tpacpi_rfk_update_swstate(
						tpacpi_rfkill_switches[id]);
			if (status < 0)
				return status;
		}

1391
		seq_printf(m, "status:\t\t%s\n",
J
Johannes Berg 已提交
1392 1393
				(status == TPACPI_RFK_RADIO_ON) ?
					"enabled" : "disabled");
1394
		seq_printf(m, "commands:\tenable, disable\n");
J
Johannes Berg 已提交
1395 1396
	}

1397
	return 0;
J
Johannes Berg 已提交
1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408
}

static int tpacpi_rfk_procfs_write(const enum tpacpi_rfk_id id, char *buf)
{
	char *cmd;
	int status = -1;
	int res = 0;

	if (id >= TPACPI_RFK_SW_MAX)
		return -ENODEV;

1409
	while ((cmd = strsep(&buf, ","))) {
J
Johannes Berg 已提交
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
		if (strlencmp(cmd, "enable") == 0)
			status = TPACPI_RFK_RADIO_ON;
		else if (strlencmp(cmd, "disable") == 0)
			status = TPACPI_RFK_RADIO_OFF;
		else
			return -EINVAL;
	}

	if (status != -1) {
		tpacpi_disclose_usertask("procfs", "attempt to %s %s\n",
				(status == TPACPI_RFK_RADIO_ON) ?
						"enable" : "disable",
				tpacpi_rfkill_names[id]);
		res = (tpacpi_rfkill_switches[id]->ops->set_status)(status);
		tpacpi_rfk_update_swstate(tpacpi_rfkill_switches[id]);
	}

	return res;
}

1430
/*************************************************************************
1431
 * thinkpad-acpi driver attributes
1432 1433
 */

1434
/* interface_version --------------------------------------------------- */
1435
static ssize_t interface_version_show(struct device_driver *drv, char *buf)
L
Linus Torvalds 已提交
1436
{
1437 1438
	return snprintf(buf, PAGE_SIZE, "0x%08x\n", TPACPI_SYSFS_VERSION);
}
1439
static DRIVER_ATTR_RO(interface_version);
1440 1441

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

1447 1448
static ssize_t debug_level_store(struct device_driver *drv, const char *buf,
				 size_t count)
1449 1450 1451 1452 1453 1454 1455 1456 1457 1458
{
	unsigned long t;

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

	dbg_level = t;

	return count;
}
1459
static DRIVER_ATTR_RW(debug_level);
1460 1461

/* version ------------------------------------------------------------- */
1462
static ssize_t version_show(struct device_driver *drv, char *buf)
1463
{
1464 1465
	return snprintf(buf, PAGE_SIZE, "%s v%s\n",
			TPACPI_DESC, TPACPI_VERSION);
1466
}
1467
static DRIVER_ATTR_RO(version);
1468 1469 1470

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

1471 1472 1473
#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES

/* wlsw_emulstate ------------------------------------------------------ */
1474
static ssize_t wlsw_emulstate_show(struct device_driver *drv, char *buf)
1475 1476 1477 1478
{
	return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_wlsw_emulstate);
}

1479 1480
static ssize_t wlsw_emulstate_store(struct device_driver *drv, const char *buf,
				    size_t count)
1481 1482 1483 1484 1485 1486
{
	unsigned long t;

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

J
Johannes Berg 已提交
1487
	if (tpacpi_wlsw_emulstate != !!t) {
1488
		tpacpi_wlsw_emulstate = !!t;
J
Johannes Berg 已提交
1489 1490
		tpacpi_rfk_update_hwblock_state(!t);	/* negative logic */
	}
1491 1492 1493

	return count;
}
1494
static DRIVER_ATTR_RW(wlsw_emulstate);
1495 1496

/* bluetooth_emulstate ------------------------------------------------- */
1497
static ssize_t bluetooth_emulstate_show(struct device_driver *drv, char *buf)
1498 1499 1500 1501
{
	return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_bluetooth_emulstate);
}

1502 1503
static ssize_t bluetooth_emulstate_store(struct device_driver *drv,
					 const char *buf, size_t count)
1504 1505 1506 1507 1508 1509 1510 1511 1512 1513
{
	unsigned long t;

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

	tpacpi_bluetooth_emulstate = !!t;

	return count;
}
1514
static DRIVER_ATTR_RW(bluetooth_emulstate);
1515 1516

/* wwan_emulstate ------------------------------------------------- */
1517
static ssize_t wwan_emulstate_show(struct device_driver *drv, char *buf)
1518 1519 1520 1521
{
	return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_wwan_emulstate);
}

1522 1523
static ssize_t wwan_emulstate_store(struct device_driver *drv, const char *buf,
				    size_t count)
1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
{
	unsigned long t;

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

	tpacpi_wwan_emulstate = !!t;

	return count;
}
1534
static DRIVER_ATTR_RW(wwan_emulstate);
1535

1536
/* uwb_emulstate ------------------------------------------------- */
1537
static ssize_t uwb_emulstate_show(struct device_driver *drv, char *buf)
1538 1539 1540 1541
{
	return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_uwb_emulstate);
}

1542 1543
static ssize_t uwb_emulstate_store(struct device_driver *drv, const char *buf,
				   size_t count)
1544 1545 1546 1547 1548 1549 1550 1551 1552 1553
{
	unsigned long t;

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

	tpacpi_uwb_emulstate = !!t;

	return count;
}
1554
static DRIVER_ATTR_RW(uwb_emulstate);
1555 1556 1557 1558
#endif

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

1559
static struct driver_attribute *tpacpi_driver_attributes[] = {
1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574
	&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++;
	}

1575 1576 1577 1578 1579 1580 1581
#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
	if (!res && dbg_wlswemul)
		res = driver_create_file(drv, &driver_attr_wlsw_emulstate);
	if (!res && dbg_bluetoothemul)
		res = driver_create_file(drv, &driver_attr_bluetooth_emulstate);
	if (!res && dbg_wwanemul)
		res = driver_create_file(drv, &driver_attr_wwan_emulstate);
1582 1583
	if (!res && dbg_uwbemul)
		res = driver_create_file(drv, &driver_attr_uwb_emulstate);
1584 1585
#endif

1586 1587 1588 1589 1590 1591 1592
	return res;
}

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

1593
	for (i = 0; i < ARRAY_SIZE(tpacpi_driver_attributes); i++)
1594
		driver_remove_file(drv, tpacpi_driver_attributes[i]);
1595 1596 1597 1598 1599

#ifdef THINKPAD_ACPI_DEBUGFACILITIES
	driver_remove_file(drv, &driver_attr_wlsw_emulstate);
	driver_remove_file(drv, &driver_attr_bluetooth_emulstate);
	driver_remove_file(drv, &driver_attr_wwan_emulstate);
1600
	driver_remove_file(drv, &driver_attr_uwb_emulstate);
1601
#endif
1602 1603
}

1604 1605 1606 1607 1608 1609 1610 1611
/*************************************************************************
 * Firmware Data
 */

/*
 * Table of recommended minimum BIOS versions
 *
 * Reasons for listing:
1612
 *    1. Stable BIOS, listed because the unknown amount of
1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623
 *       bugs and bad ACPI behaviour on older versions
 *
 *    2. BIOS or EC fw with known bugs that trigger on Linux
 *
 *    3. BIOS with known reduced functionality in older versions
 *
 *  We recommend the latest BIOS and EC version.
 *  We only support the latest BIOS and EC fw version as a rule.
 *
 *  Sources: IBM ThinkPad Public Web Documents (update changelogs),
 *  Information from users in ThinkWiki
1624 1625 1626
 *
 *  WARNING: we use this table also to detect that the machine is
 *  a ThinkPad in some cases, so don't remove entries lightly.
1627 1628 1629 1630 1631 1632
 */

#define TPV_Q(__v, __id1, __id2, __bv1, __bv2)		\
	{ .vendor	= (__v),			\
	  .bios		= TPID(__id1, __id2),		\
	  .ec		= TPACPI_MATCH_ANY,		\
1633 1634
	  .quirks	= TPACPI_MATCH_ANY_VERSION << 16 \
			  | TPVER(__bv1, __bv2) }
1635 1636

#define TPV_Q_X(__v, __bid1, __bid2, __bv1, __bv2,	\
1637
		__eid, __ev1, __ev2)			\
1638 1639
	{ .vendor	= (__v),			\
	  .bios		= TPID(__bid1, __bid2),		\
1640
	  .ec		= __eid,			\
1641 1642
	  .quirks	= TPVER(__ev1, __ev2) << 16	\
			  | TPVER(__bv1, __bv2) }
1643 1644 1645 1646

#define TPV_QI0(__id1, __id2, __bv1, __bv2) \
	TPV_Q(PCI_VENDOR_ID_IBM, __id1, __id2, __bv1, __bv2)

1647
/* Outdated IBM BIOSes often lack the EC id string */
1648 1649
#define TPV_QI1(__id1, __id2, __bv1, __bv2, __ev1, __ev2) \
	TPV_Q_X(PCI_VENDOR_ID_IBM, __id1, __id2, 	\
1650 1651 1652 1653 1654
		__bv1, __bv2, TPID(__id1, __id2),	\
		__ev1, __ev2),				\
	TPV_Q_X(PCI_VENDOR_ID_IBM, __id1, __id2, 	\
		__bv1, __bv2, TPACPI_MATCH_UNKNOWN,	\
		__ev1, __ev2)
1655

1656
/* Outdated IBM BIOSes often lack the EC id string */
1657 1658 1659
#define TPV_QI2(__bid1, __bid2, __bv1, __bv2,		\
		__eid1, __eid2, __ev1, __ev2) 		\
	TPV_Q_X(PCI_VENDOR_ID_IBM, __bid1, __bid2, 	\
1660 1661 1662 1663 1664
		__bv1, __bv2, TPID(__eid1, __eid2),	\
		__ev1, __ev2),				\
	TPV_Q_X(PCI_VENDOR_ID_IBM, __bid1, __bid2, 	\
		__bv1, __bv2, TPACPI_MATCH_UNKNOWN,	\
		__ev1, __ev2)
1665 1666 1667 1668 1669 1670

#define TPV_QL0(__id1, __id2, __bv1, __bv2) \
	TPV_Q(PCI_VENDOR_ID_LENOVO, __id1, __id2, __bv1, __bv2)

#define TPV_QL1(__id1, __id2, __bv1, __bv2, __ev1, __ev2) \
	TPV_Q_X(PCI_VENDOR_ID_LENOVO, __id1, __id2, 	\
1671 1672
		__bv1, __bv2, TPID(__id1, __id2),	\
		__ev1, __ev2)
1673 1674 1675 1676

#define TPV_QL2(__bid1, __bid2, __bv1, __bv2,		\
		__eid1, __eid2, __ev1, __ev2) 		\
	TPV_Q_X(PCI_VENDOR_ID_LENOVO, __bid1, __bid2, 	\
1677 1678
		__bv1, __bv2, TPID(__eid1, __eid2),	\
		__ev1, __ev2)
1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735

static const struct tpacpi_quirk tpacpi_bios_version_qtable[] __initconst = {
	/*  Numeric models ------------------ */
	/*      FW MODEL   BIOS VERS	      */
	TPV_QI0('I', 'M',  '6', '5'),		 /* 570 */
	TPV_QI0('I', 'U',  '2', '6'),		 /* 570E */
	TPV_QI0('I', 'B',  '5', '4'),		 /* 600 */
	TPV_QI0('I', 'H',  '4', '7'),		 /* 600E */
	TPV_QI0('I', 'N',  '3', '6'),		 /* 600E */
	TPV_QI0('I', 'T',  '5', '5'),		 /* 600X */
	TPV_QI0('I', 'D',  '4', '8'),		 /* 770, 770E, 770ED */
	TPV_QI0('I', 'I',  '4', '2'),		 /* 770X */
	TPV_QI0('I', 'O',  '2', '3'),		 /* 770Z */

	/* A-series ------------------------- */
	/*      FW MODEL   BIOS VERS  EC VERS */
	TPV_QI0('I', 'W',  '5', '9'),		 /* A20m */
	TPV_QI0('I', 'V',  '6', '9'),		 /* A20p */
	TPV_QI0('1', '0',  '2', '6'),		 /* A21e, A22e */
	TPV_QI0('K', 'U',  '3', '6'),		 /* A21e */
	TPV_QI0('K', 'X',  '3', '6'),		 /* A21m, A22m */
	TPV_QI0('K', 'Y',  '3', '8'),		 /* A21p, A22p */
	TPV_QI0('1', 'B',  '1', '7'),		 /* A22e */
	TPV_QI0('1', '3',  '2', '0'),		 /* A22m */
	TPV_QI0('1', 'E',  '7', '3'),		 /* A30/p (0) */
	TPV_QI1('1', 'G',  '4', '1',  '1', '7'), /* A31/p (0) */
	TPV_QI1('1', 'N',  '1', '6',  '0', '7'), /* A31/p (0) */

	/* G-series ------------------------- */
	/*      FW MODEL   BIOS VERS	      */
	TPV_QI0('1', 'T',  'A', '6'),		 /* G40 */
	TPV_QI0('1', 'X',  '5', '7'),		 /* G41 */

	/* R-series, T-series --------------- */
	/*      FW MODEL   BIOS VERS  EC VERS */
	TPV_QI0('1', 'C',  'F', '0'),		 /* R30 */
	TPV_QI0('1', 'F',  'F', '1'),		 /* R31 */
	TPV_QI0('1', 'M',  '9', '7'),		 /* R32 */
	TPV_QI0('1', 'O',  '6', '1'),		 /* R40 */
	TPV_QI0('1', 'P',  '6', '5'),		 /* R40 */
	TPV_QI0('1', 'S',  '7', '0'),		 /* R40e */
	TPV_QI1('1', 'R',  'D', 'R',  '7', '1'), /* R50/p, R51,
						    T40/p, T41/p, T42/p (1) */
	TPV_QI1('1', 'V',  '7', '1',  '2', '8'), /* R50e, R51 (1) */
	TPV_QI1('7', '8',  '7', '1',  '0', '6'), /* R51e (1) */
	TPV_QI1('7', '6',  '6', '9',  '1', '6'), /* R52 (1) */
	TPV_QI1('7', '0',  '6', '9',  '2', '8'), /* R52, T43 (1) */

	TPV_QI0('I', 'Y',  '6', '1'),		 /* T20 */
	TPV_QI0('K', 'Z',  '3', '4'),		 /* T21 */
	TPV_QI0('1', '6',  '3', '2'),		 /* T22 */
	TPV_QI1('1', 'A',  '6', '4',  '2', '3'), /* T23 (0) */
	TPV_QI1('1', 'I',  '7', '1',  '2', '0'), /* T30 (0) */
	TPV_QI1('1', 'Y',  '6', '5',  '2', '9'), /* T43/p (1) */

	TPV_QL1('7', '9',  'E', '3',  '5', '0'), /* T60/p */
	TPV_QL1('7', 'C',  'D', '2',  '2', '2'), /* R60, R60i */
1736
	TPV_QL1('7', 'E',  'D', '0',  '1', '5'), /* R60e, R60i */
1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751

	/*      BIOS FW    BIOS VERS  EC FW     EC VERS */
	TPV_QI2('1', 'W',  '9', '0',  '1', 'V', '2', '8'), /* R50e (1) */
	TPV_QL2('7', 'I',  '3', '4',  '7', '9', '5', '0'), /* T60/p wide */

	/* X-series ------------------------- */
	/*      FW MODEL   BIOS VERS  EC VERS */
	TPV_QI0('I', 'Z',  '9', 'D'),		 /* X20, X21 */
	TPV_QI0('1', 'D',  '7', '0'),		 /* X22, X23, X24 */
	TPV_QI1('1', 'K',  '4', '8',  '1', '8'), /* X30 (0) */
	TPV_QI1('1', 'Q',  '9', '7',  '2', '3'), /* X31, X32 (0) */
	TPV_QI1('1', 'U',  'D', '3',  'B', '2'), /* X40 (0) */
	TPV_QI1('7', '4',  '6', '4',  '2', '7'), /* X41 (0) */
	TPV_QI1('7', '5',  '6', '0',  '2', '0'), /* X41t (0) */

1752 1753
	TPV_QL1('7', 'B',  'D', '7',  '4', '0'), /* X60/s */
	TPV_QL1('7', 'J',  '3', '0',  '1', '3'), /* X60t */
1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783

	/* (0) - older versions lack DMI EC fw string and functionality */
	/* (1) - older versions known to lack functionality */
};

#undef TPV_QL1
#undef TPV_QL0
#undef TPV_QI2
#undef TPV_QI1
#undef TPV_QI0
#undef TPV_Q_X
#undef TPV_Q

static void __init tpacpi_check_outdated_fw(void)
{
	unsigned long fwvers;
	u16 ec_version, bios_version;

	fwvers = tpacpi_check_quirks(tpacpi_bios_version_qtable,
				ARRAY_SIZE(tpacpi_bios_version_qtable));

	if (!fwvers)
		return;

	bios_version = fwvers & 0xffffU;
	ec_version = (fwvers >> 16) & 0xffffU;

	/* note that unknown versions are set to 0x0000 and we use that */
	if ((bios_version > thinkpad_id.bios_release) ||
	    (ec_version > thinkpad_id.ec_release &&
1784
				ec_version != TPACPI_MATCH_ANY_VERSION)) {
1785 1786 1787 1788 1789 1790 1791
		/*
		 * The changelogs would let us track down the exact
		 * reason, but it is just too much of a pain to track
		 * it.  We only list BIOSes that are either really
		 * broken, or really stable to begin with, so it is
		 * best if the user upgrades the firmware anyway.
		 */
1792
		pr_warn("WARNING: Outdated ThinkPad BIOS/EC firmware\n");
1793
		pr_warn("WARNING: This firmware may be missing critical bug fixes and/or important features\n");
1794 1795 1796
	}
}

1797 1798 1799 1800 1801 1802
static bool __init tpacpi_is_fw_known(void)
{
	return tpacpi_check_quirks(tpacpi_bios_version_qtable,
			ARRAY_SIZE(tpacpi_bios_version_qtable)) != 0;
}

1803 1804 1805 1806 1807 1808 1809 1810 1811
/****************************************************************************
 ****************************************************************************
 *
 * Subdrivers
 *
 ****************************************************************************
 ****************************************************************************/

/*************************************************************************
1812
 * thinkpad-acpi metadata subdriver
1813 1814
 */

1815
static int thinkpad_acpi_driver_read(struct seq_file *m)
L
Linus Torvalds 已提交
1816
{
1817 1818 1819
	seq_printf(m, "driver:\t\t%s\n", TPACPI_DESC);
	seq_printf(m, "version:\t%s\n", TPACPI_VERSION);
	return 0;
L
Linus Torvalds 已提交
1820 1821
}

1822 1823 1824 1825 1826
static struct ibm_struct thinkpad_acpi_driver_data = {
	.name = "driver",
	.read = thinkpad_acpi_driver_read,
};

1827 1828 1829 1830
/*************************************************************************
 * Hotkey subdriver
 */

1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
/*
 * ThinkPad firmware event model
 *
 * The ThinkPad firmware has two main event interfaces: normal ACPI
 * notifications (which follow the ACPI standard), and a private event
 * interface.
 *
 * The private event interface also issues events for the hotkeys.  As
 * the driver gained features, the event handling code ended up being
 * built around the hotkey subdriver.  This will need to be refactored
 * to a more formal event API eventually.
 *
 * Some "hotkeys" are actually supposed to be used as event reports,
 * such as "brightness has changed", "volume has changed", depending on
 * the ThinkPad model and how the firmware is operating.
 *
 * Unlike other classes, hotkey-class events have mask/unmask control on
 * non-ancient firmware.  However, how it behaves changes a lot with the
 * firmware model and version.
 */

1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876
enum {	/* hot key scan codes (derived from ACPI DSDT) */
	TP_ACPI_HOTKEYSCAN_FNF1		= 0,
	TP_ACPI_HOTKEYSCAN_FNF2,
	TP_ACPI_HOTKEYSCAN_FNF3,
	TP_ACPI_HOTKEYSCAN_FNF4,
	TP_ACPI_HOTKEYSCAN_FNF5,
	TP_ACPI_HOTKEYSCAN_FNF6,
	TP_ACPI_HOTKEYSCAN_FNF7,
	TP_ACPI_HOTKEYSCAN_FNF8,
	TP_ACPI_HOTKEYSCAN_FNF9,
	TP_ACPI_HOTKEYSCAN_FNF10,
	TP_ACPI_HOTKEYSCAN_FNF11,
	TP_ACPI_HOTKEYSCAN_FNF12,
	TP_ACPI_HOTKEYSCAN_FNBACKSPACE,
	TP_ACPI_HOTKEYSCAN_FNINSERT,
	TP_ACPI_HOTKEYSCAN_FNDELETE,
	TP_ACPI_HOTKEYSCAN_FNHOME,
	TP_ACPI_HOTKEYSCAN_FNEND,
	TP_ACPI_HOTKEYSCAN_FNPAGEUP,
	TP_ACPI_HOTKEYSCAN_FNPAGEDOWN,
	TP_ACPI_HOTKEYSCAN_FNSPACE,
	TP_ACPI_HOTKEYSCAN_VOLUMEUP,
	TP_ACPI_HOTKEYSCAN_VOLUMEDOWN,
	TP_ACPI_HOTKEYSCAN_MUTE,
	TP_ACPI_HOTKEYSCAN_THINKPAD,
1877 1878 1879 1880 1881 1882 1883 1884 1885
	TP_ACPI_HOTKEYSCAN_UNK1,
	TP_ACPI_HOTKEYSCAN_UNK2,
	TP_ACPI_HOTKEYSCAN_UNK3,
	TP_ACPI_HOTKEYSCAN_UNK4,
	TP_ACPI_HOTKEYSCAN_UNK5,
	TP_ACPI_HOTKEYSCAN_UNK6,
	TP_ACPI_HOTKEYSCAN_UNK7,
	TP_ACPI_HOTKEYSCAN_UNK8,

1886 1887 1888
	/* Adaptive keyboard keycodes */
	TP_ACPI_HOTKEYSCAN_ADAPTIVE_START,
	TP_ACPI_HOTKEYSCAN_MUTE2        = TP_ACPI_HOTKEYSCAN_ADAPTIVE_START,
1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908
	TP_ACPI_HOTKEYSCAN_BRIGHTNESS_ZERO,
	TP_ACPI_HOTKEYSCAN_CLIPPING_TOOL,
	TP_ACPI_HOTKEYSCAN_CLOUD,
	TP_ACPI_HOTKEYSCAN_UNK9,
	TP_ACPI_HOTKEYSCAN_VOICE,
	TP_ACPI_HOTKEYSCAN_UNK10,
	TP_ACPI_HOTKEYSCAN_GESTURES,
	TP_ACPI_HOTKEYSCAN_UNK11,
	TP_ACPI_HOTKEYSCAN_UNK12,
	TP_ACPI_HOTKEYSCAN_UNK13,
	TP_ACPI_HOTKEYSCAN_CONFIG,
	TP_ACPI_HOTKEYSCAN_NEW_TAB,
	TP_ACPI_HOTKEYSCAN_RELOAD,
	TP_ACPI_HOTKEYSCAN_BACK,
	TP_ACPI_HOTKEYSCAN_MIC_DOWN,
	TP_ACPI_HOTKEYSCAN_MIC_UP,
	TP_ACPI_HOTKEYSCAN_MIC_CANCELLATION,
	TP_ACPI_HOTKEYSCAN_CAMERA_MODE,
	TP_ACPI_HOTKEYSCAN_ROTATE_DISPLAY,

1909 1910 1911 1912 1913
	/* Lenovo extended keymap, starting at 0x1300 */
	TP_ACPI_HOTKEYSCAN_EXTENDED_START,
	/* first new observed key (star, favorites) is 0x1311 */
	TP_ACPI_HOTKEYSCAN_STAR = 69,
	TP_ACPI_HOTKEYSCAN_CLIPPING_TOOL2,
1914
	TP_ACPI_HOTKEYSCAN_CALCULATOR,
1915 1916
	TP_ACPI_HOTKEYSCAN_BLUETOOTH,
	TP_ACPI_HOTKEYSCAN_KEYBOARD,
1917 1918 1919 1920
	TP_ACPI_HOTKEYSCAN_FN_RIGHT_SHIFT, /* Used by "Lenovo Quick Clean" */
	TP_ACPI_HOTKEYSCAN_NOTIFICATION_CENTER,
	TP_ACPI_HOTKEYSCAN_PICKUP_PHONE,
	TP_ACPI_HOTKEYSCAN_HANGUP_PHONE,
1921

1922 1923
	/* Hotkey keymap size */
	TPACPI_HOTKEY_MAP_LEN
1924 1925
};

1926
enum {	/* Keys/events available through NVRAM polling */
1927 1928 1929 1930 1931 1932 1933 1934 1935 1936
	TPACPI_HKEY_NVRAM_KNOWN_MASK = 0x00fb88c0U,
	TPACPI_HKEY_NVRAM_GOOD_MASK  = 0x00fb8000U,
};

enum {	/* Positions of some of the keys in hotkey masks */
	TP_ACPI_HKEY_DISPSWTCH_MASK	= 1 << TP_ACPI_HOTKEYSCAN_FNF7,
	TP_ACPI_HKEY_DISPXPAND_MASK	= 1 << TP_ACPI_HOTKEYSCAN_FNF8,
	TP_ACPI_HKEY_HIBERNATE_MASK	= 1 << TP_ACPI_HOTKEYSCAN_FNF12,
	TP_ACPI_HKEY_BRGHTUP_MASK	= 1 << TP_ACPI_HOTKEYSCAN_FNHOME,
	TP_ACPI_HKEY_BRGHTDWN_MASK	= 1 << TP_ACPI_HOTKEYSCAN_FNEND,
1937
	TP_ACPI_HKEY_KBD_LIGHT_MASK	= 1 << TP_ACPI_HOTKEYSCAN_FNPAGEUP,
1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973
	TP_ACPI_HKEY_ZOOM_MASK		= 1 << TP_ACPI_HOTKEYSCAN_FNSPACE,
	TP_ACPI_HKEY_VOLUP_MASK		= 1 << TP_ACPI_HOTKEYSCAN_VOLUMEUP,
	TP_ACPI_HKEY_VOLDWN_MASK	= 1 << TP_ACPI_HOTKEYSCAN_VOLUMEDOWN,
	TP_ACPI_HKEY_MUTE_MASK		= 1 << TP_ACPI_HOTKEYSCAN_MUTE,
	TP_ACPI_HKEY_THINKPAD_MASK	= 1 << TP_ACPI_HOTKEYSCAN_THINKPAD,
};

enum {	/* NVRAM to ACPI HKEY group map */
	TP_NVRAM_HKEY_GROUP_HK2		= TP_ACPI_HKEY_THINKPAD_MASK |
					  TP_ACPI_HKEY_ZOOM_MASK |
					  TP_ACPI_HKEY_DISPSWTCH_MASK |
					  TP_ACPI_HKEY_HIBERNATE_MASK,
	TP_NVRAM_HKEY_GROUP_BRIGHTNESS	= TP_ACPI_HKEY_BRGHTUP_MASK |
					  TP_ACPI_HKEY_BRGHTDWN_MASK,
	TP_NVRAM_HKEY_GROUP_VOLUME	= TP_ACPI_HKEY_VOLUP_MASK |
					  TP_ACPI_HKEY_VOLDWN_MASK |
					  TP_ACPI_HKEY_MUTE_MASK,
};

#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
struct tp_nvram_state {
       u16 thinkpad_toggle:1;
       u16 zoom_toggle:1;
       u16 display_toggle:1;
       u16 thinklight_toggle:1;
       u16 hibernate_toggle:1;
       u16 displayexp_toggle:1;
       u16 display_state:1;
       u16 brightness_toggle:1;
       u16 volume_toggle:1;
       u16 mute:1;

       u8 brightness_level;
       u8 volume_level;
};

1974
/* kthread for the hotkey poller */
1975
static struct task_struct *tpacpi_hotkey_task;
1976 1977

/*
1978 1979 1980 1981 1982
 * Acquire mutex to write poller control variables as an
 * atomic block.
 *
 * Increment hotkey_config_change when changing them if you
 * want the kthread to forget old state.
1983 1984 1985
 *
 * See HOTKEY_CONFIG_CRITICAL_START/HOTKEY_CONFIG_CRITICAL_END
 */
1986 1987 1988
static struct mutex hotkey_thread_data_mutex;
static unsigned int hotkey_config_change;

1989 1990 1991 1992
/*
 * hotkey poller control variables
 *
 * Must be atomic or readers will also need to acquire mutex
1993 1994 1995 1996 1997
 *
 * HOTKEY_CONFIG_CRITICAL_START/HOTKEY_CONFIG_CRITICAL_END
 * should be used only when the changes need to be taken as
 * a block, OR when one needs to force the kthread to forget
 * old state.
1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009
 */
static u32 hotkey_source_mask;		/* bit mask 0=ACPI,1=NVRAM */
static unsigned int hotkey_poll_freq = 10; /* Hz */

#define HOTKEY_CONFIG_CRITICAL_START \
	do { \
		mutex_lock(&hotkey_thread_data_mutex); \
		hotkey_config_change++; \
	} while (0);
#define HOTKEY_CONFIG_CRITICAL_END \
	mutex_unlock(&hotkey_thread_data_mutex);

2010 2011 2012
#else /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */

#define hotkey_source_mask 0U
2013 2014
#define HOTKEY_CONFIG_CRITICAL_START
#define HOTKEY_CONFIG_CRITICAL_END
2015 2016 2017

#endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */

2018 2019
static struct mutex hotkey_mutex;

2020 2021 2022 2023 2024 2025 2026 2027
static enum {	/* Reasons for waking up */
	TP_ACPI_WAKEUP_NONE = 0,	/* None or unknown */
	TP_ACPI_WAKEUP_BAYEJ,		/* Bay ejection request */
	TP_ACPI_WAKEUP_UNDOCK,		/* Undock request */
} hotkey_wakeup_reason;

static int hotkey_autosleep_ack;

2028 2029
static u32 hotkey_orig_mask;		/* events the BIOS had enabled */
static u32 hotkey_all_mask;		/* all events supported in fw */
2030
static u32 hotkey_adaptive_all_mask;	/* all adaptive events supported in fw */
2031 2032 2033 2034
static u32 hotkey_reserved_mask;	/* events better left disabled */
static u32 hotkey_driver_mask;		/* events needed by the driver */
static u32 hotkey_user_mask;		/* events visible to userspace */
static u32 hotkey_acpi_mask;		/* events enabled in firmware */
2035

2036
static u16 *hotkey_keycode_map;
2037

2038
static struct attribute_set *hotkey_dev_attributes;
2039

2040 2041
static void tpacpi_driver_event(const unsigned int hkey_event);
static void hotkey_driver_event(const unsigned int scancode);
2042
static void hotkey_poll_setup(const bool may_warn);
2043

2044 2045
/* HKEY.MHKG() return bits */
#define TP_HOTKEY_TABLET_MASK (1 << 3)
2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067
enum {
	TP_ACPI_MULTI_MODE_INVALID	= 0,
	TP_ACPI_MULTI_MODE_UNKNOWN	= 1 << 0,
	TP_ACPI_MULTI_MODE_LAPTOP	= 1 << 1,
	TP_ACPI_MULTI_MODE_TABLET	= 1 << 2,
	TP_ACPI_MULTI_MODE_FLAT		= 1 << 3,
	TP_ACPI_MULTI_MODE_STAND	= 1 << 4,
	TP_ACPI_MULTI_MODE_TENT		= 1 << 5,
	TP_ACPI_MULTI_MODE_STAND_TENT	= 1 << 6,
};

enum {
	/* The following modes are considered tablet mode for the purpose of
	 * reporting the status to userspace. i.e. in all these modes it makes
	 * sense to disable the laptop input devices such as touchpad and
	 * keyboard.
	 */
	TP_ACPI_MULTI_MODE_TABLET_LIKE	= TP_ACPI_MULTI_MODE_TABLET |
					  TP_ACPI_MULTI_MODE_STAND |
					  TP_ACPI_MULTI_MODE_TENT |
					  TP_ACPI_MULTI_MODE_STAND_TENT,
};
2068

J
Johannes Berg 已提交
2069
static int hotkey_get_wlsw(void)
2070
{
J
Johannes Berg 已提交
2071 2072 2073 2074 2075
	int status;

	if (!tp_features.hotkey_wlsw)
		return -ENODEV;

2076
#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
J
Johannes Berg 已提交
2077 2078 2079
	if (dbg_wlswemul)
		return (tpacpi_wlsw_emulstate) ?
				TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
2080
#endif
J
Johannes Berg 已提交
2081 2082

	if (!acpi_evalf(hkey_handle, &status, "WLSW", "d"))
2083
		return -EIO;
J
Johannes Berg 已提交
2084 2085

	return (status) ? TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
2086 2087
}

2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116
static int hotkey_gmms_get_tablet_mode(int s, int *has_tablet_mode)
{
	int type = (s >> 16) & 0xffff;
	int value = s & 0xffff;
	int mode = TP_ACPI_MULTI_MODE_INVALID;
	int valid_modes = 0;

	if (has_tablet_mode)
		*has_tablet_mode = 0;

	switch (type) {
	case 1:
		valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
			      TP_ACPI_MULTI_MODE_TABLET |
			      TP_ACPI_MULTI_MODE_STAND_TENT;
		break;
	case 2:
		valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
			      TP_ACPI_MULTI_MODE_FLAT |
			      TP_ACPI_MULTI_MODE_TABLET |
			      TP_ACPI_MULTI_MODE_STAND |
			      TP_ACPI_MULTI_MODE_TENT;
		break;
	case 3:
		valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
			      TP_ACPI_MULTI_MODE_FLAT;
		break;
	case 4:
	case 5:
2117 2118 2119
		/* In mode 4, FLAT is not specified as a valid mode. However,
		 * it can be seen at least on the X1 Yoga 2nd Generation.
		 */
2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169
		valid_modes = TP_ACPI_MULTI_MODE_LAPTOP |
			      TP_ACPI_MULTI_MODE_FLAT |
			      TP_ACPI_MULTI_MODE_TABLET |
			      TP_ACPI_MULTI_MODE_STAND |
			      TP_ACPI_MULTI_MODE_TENT;
		break;
	default:
		pr_err("Unknown multi mode status type %d with value 0x%04X, please report this to %s\n",
		       type, value, TPACPI_MAIL);
		return 0;
	}

	if (has_tablet_mode && (valid_modes & TP_ACPI_MULTI_MODE_TABLET_LIKE))
		*has_tablet_mode = 1;

	switch (value) {
	case 1:
		mode = TP_ACPI_MULTI_MODE_LAPTOP;
		break;
	case 2:
		mode = TP_ACPI_MULTI_MODE_FLAT;
		break;
	case 3:
		mode = TP_ACPI_MULTI_MODE_TABLET;
		break;
	case 4:
		if (type == 1)
			mode = TP_ACPI_MULTI_MODE_STAND_TENT;
		else
			mode = TP_ACPI_MULTI_MODE_STAND;
		break;
	case 5:
		mode = TP_ACPI_MULTI_MODE_TENT;
		break;
	default:
		if (type == 5 && value == 0xffff) {
			pr_warn("Multi mode status is undetected, assuming laptop\n");
			return 0;
		}
	}

	if (!(mode & valid_modes)) {
		pr_err("Unknown/reserved multi mode value 0x%04X for type %d, please report this to %s\n",
		       value, type, TPACPI_MAIL);
		return 0;
	}

	return !!(mode & TP_ACPI_MULTI_MODE_TABLET_LIKE);
}

2170 2171 2172 2173
static int hotkey_get_tablet_mode(int *status)
{
	int s;

2174 2175 2176 2177 2178 2179 2180
	switch (tp_features.hotkey_tablet) {
	case TP_HOTKEY_TABLET_USES_MHKG:
		if (!acpi_evalf(hkey_handle, &s, "MHKG", "d"))
			return -EIO;

		*status = ((s & TP_HOTKEY_TABLET_MASK) != 0);
		break;
2181 2182
	case TP_HOTKEY_TABLET_USES_GMMS:
		if (!acpi_evalf(hkey_handle, &s, "GMMS", "dd", 0))
2183 2184
			return -EIO;

2185
		*status = hotkey_gmms_get_tablet_mode(s, NULL);
2186 2187 2188 2189
		break;
	default:
		break;
	}
2190

2191
	return 0;
2192 2193
}

2194
/*
2195 2196 2197 2198 2199
 * Reads current event mask from firmware, and updates
 * hotkey_acpi_mask accordingly.  Also resets any bits
 * from hotkey_user_mask that are unavailable to be
 * delivered (shadow requirement of the userspace ABI).
 *
2200 2201 2202 2203 2204
 * Call with hotkey_mutex held
 */
static int hotkey_mask_get(void)
{
	if (tp_features.hotkey_mask) {
2205 2206
		u32 m = 0;

2207
		if (!acpi_evalf(hkey_handle, &m, "DHKN", "d"))
2208
			return -EIO;
2209 2210 2211 2212 2213

		hotkey_acpi_mask = m;
	} else {
		/* no mask support doesn't mean no event support... */
		hotkey_acpi_mask = hotkey_all_mask;
2214
	}
2215 2216 2217

	/* sync userspace-visible mask */
	hotkey_user_mask &= (hotkey_acpi_mask | hotkey_source_mask);
2218 2219 2220 2221

	return 0;
}

2222
static void hotkey_mask_warn_incomplete_mask(void)
2223 2224 2225 2226 2227 2228 2229
{
	/* log only what the user can fix... */
	const u32 wantedmask = hotkey_driver_mask &
		~(hotkey_acpi_mask | hotkey_source_mask) &
		(hotkey_all_mask | TPACPI_HKEY_NVRAM_KNOWN_MASK);

	if (wantedmask)
2230
		pr_notice("required events 0x%08x not enabled!\n", wantedmask);
2231 2232
}

2233
/*
2234 2235 2236 2237 2238 2239
 * Set the firmware mask when supported
 *
 * Also calls hotkey_mask_get to update hotkey_acpi_mask.
 *
 * NOTE: does not set bits in hotkey_user_mask, but may reset them.
 *
2240 2241 2242 2243 2244 2245 2246
 * Call with hotkey_mutex held
 */
static int hotkey_mask_set(u32 mask)
{
	int i;
	int rc = 0;

2247
	const u32 fwmask = mask & ~hotkey_source_mask;
2248

2249
	if (tp_features.hotkey_mask) {
2250 2251 2252
		for (i = 0; i < 32; i++) {
			if (!acpi_evalf(hkey_handle,
					NULL, "MHKM", "vdd", i + 1,
2253
					!!(mask & (1 << i)))) {
2254 2255 2256 2257
				rc = -EIO;
				break;
			}
		}
2258
	}
2259

2260 2261 2262 2263 2264 2265 2266 2267
	/*
	 * We *must* make an inconditional call to hotkey_mask_get to
	 * refresh hotkey_acpi_mask and update hotkey_user_mask
	 *
	 * Take the opportunity to also log when we cannot _enable_
	 * a given event.
	 */
	if (!hotkey_mask_get() && !rc && (fwmask & ~hotkey_acpi_mask)) {
2268
		pr_notice("asked for hotkey mask 0x%08x, but firmware forced it to 0x%08x\n",
2269
			  fwmask, hotkey_acpi_mask);
2270 2271
	}

2272 2273
	if (tpacpi_lifecycle != TPACPI_LIFE_EXITING)
		hotkey_mask_warn_incomplete_mask();
2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292

	return rc;
}

/*
 * Sets hotkey_user_mask and tries to set the firmware mask
 *
 * Call with hotkey_mutex held
 */
static int hotkey_user_mask_set(const u32 mask)
{
	int rc;

	/* Give people a chance to notice they are doing something that
	 * is bound to go boom on their users sooner or later */
	if (!tp_warned.hotkey_mask_ff &&
	    (mask == 0xffff || mask == 0xffffff ||
	     mask == 0xffffffff)) {
		tp_warned.hotkey_mask_ff = 1;
2293 2294 2295
		pr_notice("setting the hotkey mask to 0x%08x is likely not the best way to go about it\n",
			  mask);
		pr_notice("please consider using the driver defaults, and refer to up-to-date thinkpad-acpi documentation\n");
2296 2297 2298 2299 2300 2301 2302 2303 2304
	}

	/* Try to enable what the user asked for, plus whatever we need.
	 * this syncs everything but won't enable bits in hotkey_user_mask */
	rc = hotkey_mask_set((mask | hotkey_driver_mask) & ~hotkey_source_mask);

	/* Enable the available bits in hotkey_user_mask */
	hotkey_user_mask = mask & (hotkey_acpi_mask | hotkey_source_mask);

2305 2306 2307
	return rc;
}

2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326
/*
 * Sets the driver hotkey mask.
 *
 * Can be called even if the hotkey subdriver is inactive
 */
static int tpacpi_hotkey_driver_mask_set(const u32 mask)
{
	int rc;

	/* Do the right thing if hotkey_init has not been called yet */
	if (!tp_features.hotkey) {
		hotkey_driver_mask = mask;
		return 0;
	}

	mutex_lock(&hotkey_mutex);

	HOTKEY_CONFIG_CRITICAL_START
	hotkey_driver_mask = mask;
2327
#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2328
	hotkey_source_mask |= (mask & ~hotkey_all_mask);
2329
#endif
2330 2331 2332 2333
	HOTKEY_CONFIG_CRITICAL_END

	rc = hotkey_mask_set((hotkey_acpi_mask | hotkey_driver_mask) &
							~hotkey_source_mask);
2334 2335
	hotkey_poll_setup(true);

2336 2337 2338 2339 2340
	mutex_unlock(&hotkey_mutex);

	return rc;
}

2341 2342 2343 2344 2345 2346 2347 2348
static int hotkey_status_get(int *status)
{
	if (!acpi_evalf(hkey_handle, status, "DHKC", "d"))
		return -EIO;

	return 0;
}

2349
static int hotkey_status_set(bool enable)
2350
{
2351
	if (!acpi_evalf(hkey_handle, NULL, "MHKC", "vd", enable ? 1 : 0))
2352 2353 2354 2355 2356
		return -EIO;

	return 0;
}

2357
static void tpacpi_input_send_tabletsw(void)
2358
{
2359
	int state;
2360

2361 2362 2363
	if (tp_features.hotkey_tablet &&
	    !hotkey_get_tablet_mode(&state)) {
		mutex_lock(&tpacpi_inputdev_send_mutex);
2364

2365 2366 2367 2368 2369 2370
		input_report_switch(tpacpi_inputdev,
				    SW_TABLET_MODE, !!state);
		input_sync(tpacpi_inputdev);

		mutex_unlock(&tpacpi_inputdev_send_mutex);
	}
2371 2372
}

2373 2374
/* Do NOT call without validating scancode first */
static void tpacpi_input_send_key(const unsigned int scancode)
2375
{
2376
	const unsigned int keycode = hotkey_keycode_map[scancode];
2377 2378 2379 2380

	if (keycode != KEY_RESERVED) {
		mutex_lock(&tpacpi_inputdev_send_mutex);

2381
		input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN, scancode);
2382 2383 2384
		input_report_key(tpacpi_inputdev, keycode, 1);
		input_sync(tpacpi_inputdev);

2385
		input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN, scancode);
2386 2387 2388 2389 2390 2391 2392
		input_report_key(tpacpi_inputdev, keycode, 0);
		input_sync(tpacpi_inputdev);

		mutex_unlock(&tpacpi_inputdev_send_mutex);
	}
}

2393 2394 2395
/* Do NOT call without validating scancode first */
static void tpacpi_input_send_key_masked(const unsigned int scancode)
{
2396
	hotkey_driver_event(scancode);
2397 2398 2399 2400
	if (hotkey_user_mask & (1 << scancode))
		tpacpi_input_send_key(scancode);
}

2401 2402 2403
#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
static struct tp_acpi_drv_struct ibm_hotkey_acpidriver;

2404
/* Do NOT call without validating scancode first */
2405 2406
static void tpacpi_hotkey_send_key(unsigned int scancode)
{
2407
	tpacpi_input_send_key_masked(scancode);
2408 2409
}

2410
static void hotkey_read_nvram(struct tp_nvram_state *n, const u32 m)
2411 2412 2413 2414 2415 2416 2417 2418 2419 2420
{
	u8 d;

	if (m & TP_NVRAM_HKEY_GROUP_HK2) {
		d = nvram_read_byte(TP_NVRAM_ADDR_HK2);
		n->thinkpad_toggle = !!(d & TP_NVRAM_MASK_HKT_THINKPAD);
		n->zoom_toggle = !!(d & TP_NVRAM_MASK_HKT_ZOOM);
		n->display_toggle = !!(d & TP_NVRAM_MASK_HKT_DISPLAY);
		n->hibernate_toggle = !!(d & TP_NVRAM_MASK_HKT_HIBERNATE);
	}
2421
	if (m & TP_ACPI_HKEY_KBD_LIGHT_MASK) {
2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446
		d = nvram_read_byte(TP_NVRAM_ADDR_THINKLIGHT);
		n->thinklight_toggle = !!(d & TP_NVRAM_MASK_THINKLIGHT);
	}
	if (m & TP_ACPI_HKEY_DISPXPAND_MASK) {
		d = nvram_read_byte(TP_NVRAM_ADDR_VIDEO);
		n->displayexp_toggle =
				!!(d & TP_NVRAM_MASK_HKT_DISPEXPND);
	}
	if (m & TP_NVRAM_HKEY_GROUP_BRIGHTNESS) {
		d = nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS);
		n->brightness_level = (d & TP_NVRAM_MASK_LEVEL_BRIGHTNESS)
				>> TP_NVRAM_POS_LEVEL_BRIGHTNESS;
		n->brightness_toggle =
				!!(d & TP_NVRAM_MASK_HKT_BRIGHTNESS);
	}
	if (m & TP_NVRAM_HKEY_GROUP_VOLUME) {
		d = nvram_read_byte(TP_NVRAM_ADDR_MIXER);
		n->volume_level = (d & TP_NVRAM_MASK_LEVEL_VOLUME)
				>> TP_NVRAM_POS_LEVEL_VOLUME;
		n->mute = !!(d & TP_NVRAM_MASK_MUTE);
		n->volume_toggle = !!(d & TP_NVRAM_MASK_HKT_VOLUME);
	}
}

#define TPACPI_COMPARE_KEY(__scancode, __member) \
2447 2448 2449 2450 2451
do { \
	if ((event_mask & (1 << __scancode)) && \
	    oldn->__member != newn->__member) \
		tpacpi_hotkey_send_key(__scancode); \
} while (0)
2452 2453

#define TPACPI_MAY_SEND_KEY(__scancode) \
2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467
do { \
	if (event_mask & (1 << __scancode)) \
		tpacpi_hotkey_send_key(__scancode); \
} while (0)

static void issue_volchange(const unsigned int oldvol,
			    const unsigned int newvol,
			    const u32 event_mask)
{
	unsigned int i = oldvol;

	while (i > newvol) {
		TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN);
		i--;
2468
	}
2469 2470 2471 2472 2473
	while (i < newvol) {
		TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
		i++;
	}
}
2474

2475 2476 2477 2478 2479
static void issue_brightnesschange(const unsigned int oldbrt,
				   const unsigned int newbrt,
				   const u32 event_mask)
{
	unsigned int i = oldbrt;
2480

2481 2482 2483
	while (i > newbrt) {
		TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND);
		i--;
2484
	}
2485 2486 2487 2488 2489 2490 2491 2492 2493 2494
	while (i < newbrt) {
		TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME);
		i++;
	}
}

static void hotkey_compare_and_issue_event(struct tp_nvram_state *oldn,
					   struct tp_nvram_state *newn,
					   const u32 event_mask)
{
2495

2496 2497 2498 2499 2500 2501 2502 2503 2504
	TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_THINKPAD, thinkpad_toggle);
	TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNSPACE, zoom_toggle);
	TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF7, display_toggle);
	TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF12, hibernate_toggle);

	TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNPAGEUP, thinklight_toggle);

	TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF8, displayexp_toggle);

2505 2506 2507 2508 2509 2510
	/*
	 * Handle volume
	 *
	 * This code is supposed to duplicate the IBM firmware behaviour:
	 * - Pressing MUTE issues mute hotkey message, even when already mute
	 * - Pressing Volume up/down issues volume up/down hotkey messages,
2511
	 *   even when already at maximum or minimum volume
2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528
	 * - The act of unmuting issues volume up/down notification,
	 *   depending which key was used to unmute
	 *
	 * We are constrained to what the NVRAM can tell us, which is not much
	 * and certainly not enough if more than one volume hotkey was pressed
	 * since the last poll cycle.
	 *
	 * Just to make our life interesting, some newer Lenovo ThinkPads have
	 * bugs in the BIOS and may fail to update volume_toggle properly.
	 */
	if (newn->mute) {
		/* muted */
		if (!oldn->mute ||
		    oldn->volume_toggle != newn->volume_toggle ||
		    oldn->volume_level != newn->volume_level) {
			/* recently muted, or repeated mute keypress, or
			 * multiple presses ending in mute */
2529 2530
			issue_volchange(oldn->volume_level, newn->volume_level,
				event_mask);
2531 2532
			TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_MUTE);
		}
2533 2534 2535 2536
	} else {
		/* unmute */
		if (oldn->mute) {
			/* recently unmuted, issue 'unmute' keypress */
2537
			TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
2538 2539
		}
		if (oldn->volume_level != newn->volume_level) {
2540 2541
			issue_volchange(oldn->volume_level, newn->volume_level,
				event_mask);
2542 2543 2544
		} else if (oldn->volume_toggle != newn->volume_toggle) {
			/* repeated vol up/down keypress at end of scale ? */
			if (newn->volume_level == 0)
2545
				TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN);
2546 2547
			else if (newn->volume_level >= TP_NVRAM_LEVEL_VOLUME_MAX)
				TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
2548 2549 2550 2551
		}
	}

	/* handle brightness */
2552 2553
	if (oldn->brightness_level != newn->brightness_level) {
		issue_brightnesschange(oldn->brightness_level,
2554
				       newn->brightness_level, event_mask);
2555 2556 2557
	} else if (oldn->brightness_toggle != newn->brightness_toggle) {
		/* repeated key presses that didn't change state */
		if (newn->brightness_level == 0)
2558
			TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND);
2559 2560 2561
		else if (newn->brightness_level >= bright_maxlvl
				&& !tp_features.bright_unkfw)
			TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME);
2562 2563 2564 2565
	}

#undef TPACPI_COMPARE_KEY
#undef TPACPI_MAY_SEND_KEY
2566
}
2567

2568 2569 2570 2571 2572 2573 2574
/*
 * Polling driver
 *
 * We track all events in hotkey_source_mask all the time, since
 * most of them are edge-based.  We only issue those requested by
 * hotkey_user_mask or hotkey_driver_mask, though.
 */
2575 2576
static int hotkey_kthread(void *data)
{
2577
	struct tp_nvram_state s[2] = { 0 };
2578
	u32 poll_mask, event_mask;
2579 2580
	unsigned int si, so;
	unsigned long t;
2581
	unsigned int change_detector;
2582
	unsigned int poll_freq;
2583
	bool was_frozen;
2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596

	if (tpacpi_lifecycle == TPACPI_LIFE_EXITING)
		goto exit;

	set_freezable();

	so = 0;
	si = 1;
	t = 0;

	/* Initial state for compares */
	mutex_lock(&hotkey_thread_data_mutex);
	change_detector = hotkey_config_change;
2597 2598 2599
	poll_mask = hotkey_source_mask;
	event_mask = hotkey_source_mask &
			(hotkey_driver_mask | hotkey_user_mask);
2600
	poll_freq = hotkey_poll_freq;
2601
	mutex_unlock(&hotkey_thread_data_mutex);
2602
	hotkey_read_nvram(&s[so], poll_mask);
2603

2604 2605 2606 2607 2608 2609 2610
	while (!kthread_should_stop()) {
		if (t == 0) {
			if (likely(poll_freq))
				t = 1000/poll_freq;
			else
				t = 100;	/* should never happen... */
		}
2611
		t = msleep_interruptible(t);
2612
		if (unlikely(kthread_freezable_should_stop(&was_frozen)))
2613
			break;
2614 2615

		if (t > 0 && !was_frozen)
2616 2617 2618
			continue;

		mutex_lock(&hotkey_thread_data_mutex);
2619
		if (was_frozen || hotkey_config_change != change_detector) {
2620 2621 2622 2623 2624
			/* forget old state on thaw or config change */
			si = so;
			t = 0;
			change_detector = hotkey_config_change;
		}
2625 2626 2627
		poll_mask = hotkey_source_mask;
		event_mask = hotkey_source_mask &
				(hotkey_driver_mask | hotkey_user_mask);
2628
		poll_freq = hotkey_poll_freq;
2629 2630
		mutex_unlock(&hotkey_thread_data_mutex);

2631 2632
		if (likely(poll_mask)) {
			hotkey_read_nvram(&s[si], poll_mask);
2633 2634
			if (likely(si != so)) {
				hotkey_compare_and_issue_event(&s[so], &s[si],
2635
								event_mask);
2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646
			}
		}

		so = si;
		si ^= 1;
	}

exit:
	return 0;
}

2647
/* call with hotkey_mutex held */
2648 2649 2650 2651 2652 2653 2654 2655 2656
static void hotkey_poll_stop_sync(void)
{
	if (tpacpi_hotkey_task) {
		kthread_stop(tpacpi_hotkey_task);
		tpacpi_hotkey_task = NULL;
	}
}

/* call with hotkey_mutex held */
2657
static void hotkey_poll_setup(const bool may_warn)
2658
{
2659 2660
	const u32 poll_driver_mask = hotkey_driver_mask & hotkey_source_mask;
	const u32 poll_user_mask = hotkey_user_mask & hotkey_source_mask;
2661

2662 2663 2664
	if (hotkey_poll_freq > 0 &&
	    (poll_driver_mask ||
	     (poll_user_mask && tpacpi_inputdev->users > 0))) {
2665 2666
		if (!tpacpi_hotkey_task) {
			tpacpi_hotkey_task = kthread_run(hotkey_kthread,
2667
					NULL, TPACPI_NVRAM_KTHREAD_NAME);
2668 2669
			if (IS_ERR(tpacpi_hotkey_task)) {
				tpacpi_hotkey_task = NULL;
2670
				pr_err("could not create kernel thread for hotkey polling\n");
2671 2672 2673 2674
			}
		}
	} else {
		hotkey_poll_stop_sync();
2675
		if (may_warn && (poll_driver_mask || poll_user_mask) &&
2676
		    hotkey_poll_freq == 0) {
2677
			pr_notice("hot keys 0x%08x and/or events 0x%08x require polling, which is currently disabled\n",
2678
				  poll_user_mask, poll_driver_mask);
2679 2680 2681 2682
		}
	}
}

2683
static void hotkey_poll_setup_safe(const bool may_warn)
2684 2685 2686 2687 2688 2689
{
	mutex_lock(&hotkey_mutex);
	hotkey_poll_setup(may_warn);
	mutex_unlock(&hotkey_mutex);
}

2690 2691 2692 2693 2694 2695 2696 2697 2698
/* call with hotkey_mutex held */
static void hotkey_poll_set_freq(unsigned int freq)
{
	if (!freq)
		hotkey_poll_stop_sync();

	hotkey_poll_freq = freq;
}

2699 2700
#else /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */

2701 2702 2703 2704 2705
static void hotkey_poll_setup(const bool __unused)
{
}

static void hotkey_poll_setup_safe(const bool __unused)
2706 2707 2708 2709 2710
{
}

#endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */

2711 2712 2713 2714 2715
static int hotkey_inputdev_open(struct input_dev *dev)
{
	switch (tpacpi_lifecycle) {
	case TPACPI_LIFE_INIT:
	case TPACPI_LIFE_RUNNING:
2716
		hotkey_poll_setup_safe(false);
2717
		return 0;
2718 2719
	case TPACPI_LIFE_EXITING:
		return -EBUSY;
2720 2721 2722 2723 2724 2725 2726 2727 2728 2729
	}

	/* Should only happen if tpacpi_lifecycle is corrupt */
	BUG();
	return -EBUSY;
}

static void hotkey_inputdev_close(struct input_dev *dev)
{
	/* disable hotkey polling when possible */
2730
	if (tpacpi_lifecycle != TPACPI_LIFE_EXITING &&
2731
	    !(hotkey_source_mask & hotkey_driver_mask))
2732
		hotkey_poll_setup_safe(false);
2733 2734
}

2735 2736 2737 2738 2739
/* sysfs hotkey enable ------------------------------------------------- */
static ssize_t hotkey_enable_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
2740
	int res, status;
2741

2742 2743 2744
	printk_deprecated_attribute("hotkey_enable",
			"Hotkey reporting is always enabled");

2745
	res = hotkey_status_get(&status);
2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756
	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;
2757 2758 2759

	printk_deprecated_attribute("hotkey_enable",
			"Hotkeys can be disabled through hotkey_mask");
2760 2761 2762 2763

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

2764 2765
	if (t == 0)
		return -EPERM;
2766

2767
	return count;
2768 2769
}

2770
static DEVICE_ATTR_RW(hotkey_enable);
2771 2772 2773 2774 2775 2776

/* sysfs hotkey mask --------------------------------------------------- */
static ssize_t hotkey_mask_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
2777
	return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_user_mask);
2778 2779 2780 2781 2782 2783 2784
}

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

2787
	if (parse_strtoul(buf, 0xffffffffUL, &t))
2788 2789
		return -EINVAL;

2790
	if (mutex_lock_killable(&hotkey_mutex))
2791 2792
		return -ERESTARTSYS;

2793
	res = hotkey_user_mask_set(t);
2794 2795

#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2796
	hotkey_poll_setup(true);
2797 2798
#endif

2799
	mutex_unlock(&hotkey_mutex);
2800

2801 2802
	tpacpi_disclose_usertask("hotkey_mask", "set to 0x%08lx\n", t);

2803 2804 2805
	return (res) ? res : count;
}

2806
static DEVICE_ATTR_RW(hotkey_mask);
2807 2808 2809 2810 2811 2812

/* sysfs hotkey bios_enabled ------------------------------------------- */
static ssize_t hotkey_bios_enabled_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
2813
	return sprintf(buf, "0\n");
2814 2815
}

2816
static DEVICE_ATTR_RO(hotkey_bios_enabled);
2817 2818 2819 2820 2821 2822

/* sysfs hotkey bios_mask ---------------------------------------------- */
static ssize_t hotkey_bios_mask_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
2823 2824
	printk_deprecated_attribute("hotkey_bios_mask",
			"This attribute is useless.");
2825
	return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_orig_mask);
2826 2827
}

2828
static DEVICE_ATTR_RO(hotkey_bios_mask);
2829

2830 2831 2832 2833 2834
/* sysfs hotkey all_mask ----------------------------------------------- */
static ssize_t hotkey_all_mask_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
2835 2836
	return snprintf(buf, PAGE_SIZE, "0x%08x\n",
				hotkey_all_mask | hotkey_source_mask);
2837 2838
}

2839
static DEVICE_ATTR_RO(hotkey_all_mask);
2840

2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851
/* sysfs hotkey all_mask ----------------------------------------------- */
static ssize_t hotkey_adaptive_all_mask_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	return snprintf(buf, PAGE_SIZE, "0x%08x\n",
			hotkey_adaptive_all_mask | hotkey_source_mask);
}

static DEVICE_ATTR_RO(hotkey_adaptive_all_mask);

2852 2853 2854 2855 2856 2857
/* 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",
2858 2859
			(hotkey_all_mask | hotkey_source_mask)
			& ~hotkey_reserved_mask);
2860 2861
}

2862
static DEVICE_ATTR_RO(hotkey_recommended_mask);
2863

2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878
#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL

/* sysfs hotkey hotkey_source_mask ------------------------------------- */
static ssize_t hotkey_source_mask_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_source_mask);
}

static ssize_t hotkey_source_mask_store(struct device *dev,
			    struct device_attribute *attr,
			    const char *buf, size_t count)
{
	unsigned long t;
2879 2880
	u32 r_ev;
	int rc;
2881 2882 2883 2884 2885

	if (parse_strtoul(buf, 0xffffffffUL, &t) ||
		((t & ~TPACPI_HKEY_NVRAM_KNOWN_MASK) != 0))
		return -EINVAL;

2886
	if (mutex_lock_killable(&hotkey_mutex))
2887 2888 2889 2890 2891 2892
		return -ERESTARTSYS;

	HOTKEY_CONFIG_CRITICAL_START
	hotkey_source_mask = t;
	HOTKEY_CONFIG_CRITICAL_END

2893 2894
	rc = hotkey_mask_set((hotkey_user_mask | hotkey_driver_mask) &
			~hotkey_source_mask);
2895
	hotkey_poll_setup(true);
2896 2897 2898 2899

	/* check if events needed by the driver got disabled */
	r_ev = hotkey_driver_mask & ~(hotkey_acpi_mask & hotkey_all_mask)
		& ~hotkey_source_mask & TPACPI_HKEY_NVRAM_KNOWN_MASK;
2900 2901 2902

	mutex_unlock(&hotkey_mutex);

2903
	if (rc < 0)
2904
		pr_err("hotkey_source_mask: failed to update the firmware event mask!\n");
2905 2906

	if (r_ev)
2907
		pr_notice("hotkey_source_mask: some important events were disabled: 0x%04x\n",
2908
			  r_ev);
2909

2910 2911
	tpacpi_disclose_usertask("hotkey_source_mask", "set to 0x%08lx\n", t);

2912
	return (rc < 0) ? rc : count;
2913 2914
}

2915
static DEVICE_ATTR_RW(hotkey_source_mask);
2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933

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

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

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

2934
	if (mutex_lock_killable(&hotkey_mutex))
2935 2936
		return -ERESTARTSYS;

2937 2938
	hotkey_poll_set_freq(t);
	hotkey_poll_setup(true);
2939 2940 2941

	mutex_unlock(&hotkey_mutex);

2942 2943
	tpacpi_disclose_usertask("hotkey_poll_freq", "set to %lu\n", t);

2944 2945 2946
	return count;
}

2947
static DEVICE_ATTR_RW(hotkey_poll_freq);
2948 2949 2950

#endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */

2951
/* sysfs hotkey radio_sw (pollable) ------------------------------------ */
2952 2953 2954 2955
static ssize_t hotkey_radio_sw_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
J
Johannes Berg 已提交
2956 2957
	int res;
	res = hotkey_get_wlsw();
2958 2959 2960
	if (res < 0)
		return res;

J
Johannes Berg 已提交
2961 2962 2963 2964 2965
	/* Opportunistic update */
	tpacpi_rfk_update_hwblock_state((res == TPACPI_RFK_RADIO_OFF));

	return snprintf(buf, PAGE_SIZE, "%d\n",
			(res == TPACPI_RFK_RADIO_OFF) ? 0 : 1);
2966 2967
}

2968
static DEVICE_ATTR_RO(hotkey_radio_sw);
2969

2970 2971 2972 2973 2974 2975 2976
static void hotkey_radio_sw_notify_change(void)
{
	if (tp_features.hotkey_wlsw)
		sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
			     "hotkey_radio_sw");
}

2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989
/* sysfs hotkey tablet mode (pollable) --------------------------------- */
static ssize_t hotkey_tablet_mode_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	int res, s;
	res = hotkey_get_tablet_mode(&s);
	if (res < 0)
		return res;

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

2990
static DEVICE_ATTR_RO(hotkey_tablet_mode);
2991 2992 2993 2994 2995 2996 2997 2998

static void hotkey_tablet_mode_notify_change(void)
{
	if (tp_features.hotkey_tablet)
		sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
			     "hotkey_tablet_mode");
}

2999
/* sysfs wakeup reason (pollable) -------------------------------------- */
3000 3001 3002 3003 3004 3005 3006
static ssize_t hotkey_wakeup_reason_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_wakeup_reason);
}

3007
static DEVICE_ATTR(wakeup_reason, S_IRUGO, hotkey_wakeup_reason_show, NULL);
3008

A
Adrian Bunk 已提交
3009
static void hotkey_wakeup_reason_notify_change(void)
3010
{
3011 3012
	sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
		     "wakeup_reason");
3013 3014 3015
}

/* sysfs wakeup hotunplug_complete (pollable) -------------------------- */
3016 3017 3018 3019 3020 3021 3022
static ssize_t hotkey_wakeup_hotunplug_complete_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_autosleep_ack);
}

3023 3024
static DEVICE_ATTR(wakeup_hotunplug_complete, S_IRUGO,
		   hotkey_wakeup_hotunplug_complete_show, NULL);
3025

A
Adrian Bunk 已提交
3026
static void hotkey_wakeup_hotunplug_complete_notify_change(void)
3027
{
3028 3029
	sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
		     "wakeup_hotunplug_complete");
3030 3031
}

3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048
/* sysfs adaptive kbd mode --------------------------------------------- */

static int adaptive_keyboard_get_mode(void);
static int adaptive_keyboard_set_mode(int new_mode);

enum ADAPTIVE_KEY_MODE {
	HOME_MODE,
	WEB_BROWSER_MODE,
	WEB_CONFERENCE_MODE,
	FUNCTION_MODE,
	LAYFLAT_MODE
};

static ssize_t adaptive_kbd_mode_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
3049
	int current_mode;
3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082

	current_mode = adaptive_keyboard_get_mode();
	if (current_mode < 0)
		return current_mode;

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

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

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

	res = adaptive_keyboard_set_mode(t);
	return (res < 0) ? res : count;
}

static DEVICE_ATTR_RW(adaptive_kbd_mode);

static struct attribute *adaptive_kbd_attributes[] = {
	&dev_attr_adaptive_kbd_mode.attr,
	NULL
};

static const struct attribute_group adaptive_kbd_attr_group = {
	.attrs = adaptive_kbd_attributes,
};

3083 3084
/* --------------------------------------------------------------------- */

3085 3086
static struct attribute *hotkey_attributes[] __initdata = {
	&dev_attr_hotkey_enable.attr,
3087
	&dev_attr_hotkey_bios_enabled.attr,
3088
	&dev_attr_hotkey_bios_mask.attr,
3089 3090
	&dev_attr_wakeup_reason.attr,
	&dev_attr_wakeup_hotunplug_complete.attr,
3091 3092
	&dev_attr_hotkey_mask.attr,
	&dev_attr_hotkey_all_mask.attr,
3093
	&dev_attr_hotkey_adaptive_all_mask.attr,
3094
	&dev_attr_hotkey_recommended_mask.attr,
3095
#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3096 3097 3098
	&dev_attr_hotkey_source_mask.attr,
	&dev_attr_hotkey_poll_freq.attr,
#endif
3099 3100
};

J
Johannes Berg 已提交
3101 3102 3103
/*
 * Sync both the hw and sw blocking state of all switches
 */
3104 3105 3106 3107
static void tpacpi_send_radiosw_update(void)
{
	int wlsw;

J
Johannes Berg 已提交
3108 3109 3110 3111 3112
	/*
	 * We must sync all rfkill controllers *before* issuing any
	 * rfkill input events, or we will race the rfkill core input
	 * handler.
	 *
3113
	 * tpacpi_inputdev_send_mutex works as a synchronization point
J
Johannes Berg 已提交
3114 3115 3116 3117 3118 3119 3120 3121 3122 3123
	 * for the above.
	 *
	 * We optimize to avoid numerous calls to hotkey_get_wlsw.
	 */

	wlsw = hotkey_get_wlsw();

	/* Sync hw blocking state first if it is hw-blocked */
	if (wlsw == TPACPI_RFK_RADIO_OFF)
		tpacpi_rfk_update_hwblock_state(true);
3124

J
Johannes Berg 已提交
3125 3126 3127 3128 3129 3130 3131 3132 3133
	/* Sync sw blocking state */
	tpacpi_rfk_update_swstate_all();

	/* Sync hw blocking state last if it is hw-unblocked */
	if (wlsw == TPACPI_RFK_RADIO_ON)
		tpacpi_rfk_update_hwblock_state(false);

	/* Issue rfkill input event for WLSW switch */
	if (!(wlsw < 0)) {
3134 3135 3136
		mutex_lock(&tpacpi_inputdev_send_mutex);

		input_report_switch(tpacpi_inputdev,
J
Johannes Berg 已提交
3137
				    SW_RFKILL_ALL, (wlsw > 0));
3138 3139 3140 3141
		input_sync(tpacpi_inputdev);

		mutex_unlock(&tpacpi_inputdev_send_mutex);
	}
J
Johannes Berg 已提交
3142 3143 3144 3145 3146

	/*
	 * this can be unconditional, as we will poll state again
	 * if userspace uses the notify to read data
	 */
3147 3148 3149
	hotkey_radio_sw_notify_change();
}

3150 3151 3152
static void hotkey_exit(void)
{
#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3153
	mutex_lock(&hotkey_mutex);
3154
	hotkey_poll_stop_sync();
3155
	mutex_unlock(&hotkey_mutex);
3156 3157 3158 3159 3160
#endif

	if (hotkey_dev_attributes)
		delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj);

3161
	dbg_printk(TPACPI_DBG_EXIT | TPACPI_DBG_HKEY,
3162 3163 3164 3165 3166 3167
		   "restoring original HKEY status and mask\n");
	/* yes, there is a bitwise or below, we want the
	 * functions to be called even if one of them fail */
	if (((tp_features.hotkey_mask &&
	      hotkey_mask_set(hotkey_orig_mask)) |
	     hotkey_status_set(false)) != 0)
3168
		pr_err("failed to restore hot key mask to BIOS defaults\n");
3169 3170
}

3171 3172 3173 3174 3175 3176 3177 3178 3179
static void __init hotkey_unmap(const unsigned int scancode)
{
	if (hotkey_keycode_map[scancode] != KEY_RESERVED) {
		clear_bit(hotkey_keycode_map[scancode],
			  tpacpi_inputdev->keybit);
		hotkey_keycode_map[scancode] = KEY_RESERVED;
	}
}

3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208
/*
 * HKEY quirks:
 *   TPACPI_HK_Q_INIMASK:	Supports FN+F3,FN+F4,FN+F12
 */

#define	TPACPI_HK_Q_INIMASK	0x0001

static const struct tpacpi_quirk tpacpi_hotkey_qtable[] __initconst = {
	TPACPI_Q_IBM('I', 'H', TPACPI_HK_Q_INIMASK), /* 600E */
	TPACPI_Q_IBM('I', 'N', TPACPI_HK_Q_INIMASK), /* 600E */
	TPACPI_Q_IBM('I', 'D', TPACPI_HK_Q_INIMASK), /* 770, 770E, 770ED */
	TPACPI_Q_IBM('I', 'W', TPACPI_HK_Q_INIMASK), /* A20m */
	TPACPI_Q_IBM('I', 'V', TPACPI_HK_Q_INIMASK), /* A20p */
	TPACPI_Q_IBM('1', '0', TPACPI_HK_Q_INIMASK), /* A21e, A22e */
	TPACPI_Q_IBM('K', 'U', TPACPI_HK_Q_INIMASK), /* A21e */
	TPACPI_Q_IBM('K', 'X', TPACPI_HK_Q_INIMASK), /* A21m, A22m */
	TPACPI_Q_IBM('K', 'Y', TPACPI_HK_Q_INIMASK), /* A21p, A22p */
	TPACPI_Q_IBM('1', 'B', TPACPI_HK_Q_INIMASK), /* A22e */
	TPACPI_Q_IBM('1', '3', TPACPI_HK_Q_INIMASK), /* A22m */
	TPACPI_Q_IBM('1', 'E', TPACPI_HK_Q_INIMASK), /* A30/p (0) */
	TPACPI_Q_IBM('1', 'C', TPACPI_HK_Q_INIMASK), /* R30 */
	TPACPI_Q_IBM('1', 'F', TPACPI_HK_Q_INIMASK), /* R31 */
	TPACPI_Q_IBM('I', 'Y', TPACPI_HK_Q_INIMASK), /* T20 */
	TPACPI_Q_IBM('K', 'Z', TPACPI_HK_Q_INIMASK), /* T21 */
	TPACPI_Q_IBM('1', '6', TPACPI_HK_Q_INIMASK), /* T22 */
	TPACPI_Q_IBM('I', 'Z', TPACPI_HK_Q_INIMASK), /* X20, X21 */
	TPACPI_Q_IBM('1', 'D', TPACPI_HK_Q_INIMASK), /* X22, X23, X24 */
};

3209 3210
typedef u16 tpacpi_keymap_entry_t;
typedef tpacpi_keymap_entry_t tpacpi_keymap_t[TPACPI_HOTKEY_MAP_LEN];
3211

3212 3213
static int hotkey_init_tablet_mode(void)
{
3214 3215
	int in_tablet_mode = 0, res;
	char *type = NULL;
3216

3217 3218 3219 3220 3221
	if (acpi_evalf(hkey_handle, &res, "GMMS", "qdd", 0)) {
		int has_tablet_mode;

		in_tablet_mode = hotkey_gmms_get_tablet_mode(res,
							     &has_tablet_mode);
3222 3223 3224 3225 3226 3227 3228 3229
		/*
		 * The Yoga 11e series has 2 accelerometers described by a
		 * BOSC0200 ACPI node. This setup relies on a Windows service
		 * which calls special ACPI methods on this node to report
		 * the laptop/tent/tablet mode to the EC. The bmc150 iio driver
		 * does not support this, so skip the hotkey on these models.
		 */
		if (has_tablet_mode && !acpi_dev_present("BOSC0200", "1", -1))
3230 3231 3232
			tp_features.hotkey_tablet = TP_HOTKEY_TABLET_USES_GMMS;
		type = "GMMS";
	} else if (acpi_evalf(hkey_handle, &res, "MHKG", "qd")) {
3233
		/* For X41t, X60t, X61t Tablets... */
3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252
		tp_features.hotkey_tablet = TP_HOTKEY_TABLET_USES_MHKG;
		in_tablet_mode = !!(res & TP_HOTKEY_TABLET_MASK);
		type = "MHKG";
	}

	if (!tp_features.hotkey_tablet)
		return 0;

	pr_info("Tablet mode switch found (type: %s), currently in %s mode\n",
		type, in_tablet_mode ? "tablet" : "laptop");

	res = add_to_attr_set(hotkey_dev_attributes,
			      &dev_attr_hotkey_tablet_mode.attr);
	if (res)
		return -1;

	return in_tablet_mode;
}

3253
static int __init hotkey_init(struct ibm_init_struct *iibm)
3254
{
3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283
	/* Requirements for changing the default keymaps:
	 *
	 * 1. Many of the keys are mapped to KEY_RESERVED for very
	 *    good reasons.  Do not change them unless you have deep
	 *    knowledge on the IBM and Lenovo ThinkPad firmware for
	 *    the various ThinkPad models.  The driver behaves
	 *    differently for KEY_RESERVED: such keys have their
	 *    hot key mask *unset* in mask_recommended, and also
	 *    in the initial hot key mask programmed into the
	 *    firmware at driver load time, which means the firm-
	 *    ware may react very differently if you change them to
	 *    something else;
	 *
	 * 2. You must be subscribed to the linux-thinkpad and
	 *    ibm-acpi-devel mailing lists, and you should read the
	 *    list archives since 2007 if you want to change the
	 *    keymaps.  This requirement exists so that you will
	 *    know the past history of problems with the thinkpad-
	 *    acpi driver keymaps, and also that you will be
	 *    listening to any bug reports;
	 *
	 * 3. Do not send thinkpad-acpi specific patches directly to
	 *    for merging, *ever*.  Send them to the linux-acpi
	 *    mailinglist for comments.  Merging is to be done only
	 *    through acpi-test and the ACPI maintainer.
	 *
	 * If the above is too much to ask, don't change the keymap.
	 * Ask the thinkpad-acpi maintainer to do it, instead.
	 */
3284 3285 3286 3287 3288 3289 3290 3291 3292

	enum keymap_index {
		TPACPI_KEYMAP_IBM_GENERIC = 0,
		TPACPI_KEYMAP_LENOVO_GENERIC,
	};

	static const tpacpi_keymap_t tpacpi_keymaps[] __initconst = {
	/* Generic keymap for IBM ThinkPads */
	[TPACPI_KEYMAP_IBM_GENERIC] = {
3293
		/* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */
3294
		KEY_FN_F1,	KEY_BATTERY,	KEY_COFFEE,	KEY_SLEEP,
3295 3296
		KEY_WLAN,	KEY_FN_F6, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
		KEY_FN_F9,	KEY_FN_F10,	KEY_FN_F11,	KEY_SUSPEND,
3297 3298

		/* Scan codes 0x0C to 0x1F: Other ACPI HKEY hot keys */
3299 3300 3301
		KEY_UNKNOWN,	/* 0x0C: FN+BACKSPACE */
		KEY_UNKNOWN,	/* 0x0D: FN+INSERT */
		KEY_UNKNOWN,	/* 0x0E: FN+DELETE */
3302

3303
		/* brightness: firmware always reacts to them */
3304 3305
		KEY_RESERVED,	/* 0x0F: FN+HOME (brightness up) */
		KEY_RESERVED,	/* 0x10: FN+END (brightness down) */
3306 3307

		/* Thinklight: firmware always react to it */
3308
		KEY_RESERVED,	/* 0x11: FN+PGUP (thinklight toggle) */
3309

3310 3311
		KEY_UNKNOWN,	/* 0x12: FN+PGDOWN */
		KEY_ZOOM,	/* 0x13: FN+SPACE (zoom) */
3312 3313 3314 3315

		/* Volume: firmware always react to it and reprograms
		 * the built-in *extra* mixer.  Never map it to control
		 * another mixer by default. */
3316 3317 3318
		KEY_RESERVED,	/* 0x14: VOLUME UP */
		KEY_RESERVED,	/* 0x15: VOLUME DOWN */
		KEY_RESERVED,	/* 0x16: MUTE */
3319

3320
		KEY_VENDOR,	/* 0x17: Thinkpad/AccessIBM/Lenovo */
3321

3322 3323 3324
		/* (assignments unknown, please report if found) */
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3325 3326 3327 3328 3329 3330 3331

		/* No assignments, only used for Adaptive keyboards. */
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
3332 3333 3334 3335 3336 3337 3338 3339 3340

		/* No assignment, used for newer Lenovo models */
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN

3341 3342 3343 3344
		},

	/* Generic keymap for Lenovo ThinkPads */
	[TPACPI_KEYMAP_LENOVO_GENERIC] = {
3345 3346
		/* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */
		KEY_FN_F1,	KEY_COFFEE,	KEY_BATTERY,	KEY_SLEEP,
3347
		KEY_WLAN,	KEY_CAMERA, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
3348
		KEY_FN_F9,	KEY_FN_F10,	KEY_FN_F11,	KEY_SUSPEND,
3349 3350

		/* Scan codes 0x0C to 0x1F: Other ACPI HKEY hot keys */
3351 3352 3353
		KEY_UNKNOWN,	/* 0x0C: FN+BACKSPACE */
		KEY_UNKNOWN,	/* 0x0D: FN+INSERT */
		KEY_UNKNOWN,	/* 0x0E: FN+DELETE */
3354

3355 3356 3357 3358 3359
		/* These should be enabled --only-- when ACPI video
		 * is disabled (i.e. in "vendor" mode), and are handled
		 * in a special way by the init code */
		KEY_BRIGHTNESSUP,	/* 0x0F: FN+HOME (brightness up) */
		KEY_BRIGHTNESSDOWN,	/* 0x10: FN+END (brightness down) */
3360

3361
		KEY_RESERVED,	/* 0x11: FN+PGUP (thinklight toggle) */
3362

3363 3364
		KEY_UNKNOWN,	/* 0x12: FN+PGDOWN */
		KEY_ZOOM,	/* 0x13: FN+SPACE (zoom) */
3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376

		/* Volume: z60/z61, T60 (BIOS version?): firmware always
		 * react to it and reprograms the built-in *extra* mixer.
		 * Never map it to control another mixer by default.
		 *
		 * T60?, T61, R60?, R61: firmware and EC tries to send
		 * these over the regular keyboard, so these are no-ops,
		 * but there are still weird bugs re. MUTE, so do not
		 * change unless you get test reports from all Lenovo
		 * models.  May cause the BIOS to interfere with the
		 * HDA mixer.
		 */
3377 3378 3379
		KEY_RESERVED,	/* 0x14: VOLUME UP */
		KEY_RESERVED,	/* 0x15: VOLUME DOWN */
		KEY_RESERVED,	/* 0x16: MUTE */
3380

3381
		KEY_VENDOR,	/* 0x17: Thinkpad/AccessIBM/Lenovo */
3382

3383 3384 3385 3386 3387 3388 3389 3390 3391
		/* (assignments unknown, please report if found) */
		KEY_UNKNOWN, KEY_UNKNOWN,

		/*
		 * The mic mute button only sends 0x1a.  It does not
		 * automatically mute the mic or change the mute light.
		 */
		KEY_MICMUTE,	/* 0x1a: Mic mute (since ?400 or so) */

3392
		/* (assignments unknown, please report if found) */
3393
		KEY_UNKNOWN,
3394 3395

		/* Extra keys in use since the X240 / T440 / T540 */
3396
		KEY_CONFIG, KEY_SEARCH, KEY_SCALE, KEY_FILE,
3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425

		/*
		 * These are the adaptive keyboard keycodes for Carbon X1 2014.
		 * The first item in this list is the Mute button which is
		 * emitted with 0x103 through
		 * adaptive_keyboard_hotkey_notify_hotkey() when the sound
		 * symbol is held.
		 * We'll need to offset those by 0x20.
		 */
		KEY_RESERVED,        /* Mute held, 0x103 */
		KEY_BRIGHTNESS_MIN,  /* Backlight off */
		KEY_RESERVED,        /* Clipping tool */
		KEY_RESERVED,        /* Cloud */
		KEY_RESERVED,
		KEY_VOICECOMMAND,    /* Voice */
		KEY_RESERVED,
		KEY_RESERVED,        /* Gestures */
		KEY_RESERVED,
		KEY_RESERVED,
		KEY_RESERVED,
		KEY_CONFIG,          /* Settings */
		KEY_RESERVED,        /* New tab */
		KEY_REFRESH,         /* Reload */
		KEY_BACK,            /* Back */
		KEY_RESERVED,        /* Microphone down */
		KEY_RESERVED,        /* Microphone up */
		KEY_RESERVED,        /* Microphone cancellation */
		KEY_RESERVED,        /* Camera mode */
		KEY_RESERVED,        /* Rotate display, 0x116 */
3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443

		/*
		 * These are found in 2017 models (e.g. T470s, X270).
		 * The lowest known value is 0x311, which according to
		 * the manual should launch a user defined favorite
		 * application.
		 *
		 * The offset for these is TP_ACPI_HOTKEYSCAN_EXTENDED_START,
		 * corresponding to 0x34.
		 */

		/* (assignments unknown, please report if found) */
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
		KEY_UNKNOWN,

3444
		KEY_BOOKMARKS,			/* Favorite app, 0x311 */
3445
		KEY_SELECTIVE_SCREENSHOT,	/* Clipping tool */
3446 3447 3448 3449 3450 3451 3452
		KEY_CALC,			/* Calculator (above numpad, P52) */
		KEY_BLUETOOTH,			/* Bluetooth */
		KEY_KEYBOARD,			/* Keyboard, 0x315 */
		KEY_FN_RIGHT_SHIFT,		/* Fn + right Shift */
		KEY_NOTIFICATION_CENTER,	/* Notification Center */
		KEY_PICKUP_PHONE,		/* Answer incoming call */
		KEY_HANGUP_PHONE,		/* Decline incoming call */
3453
		},
3454 3455
	};

3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470
	static const struct tpacpi_quirk tpacpi_keymap_qtable[] __initconst = {
		/* Generic maps (fallback) */
		{
		  .vendor = PCI_VENDOR_ID_IBM,
		  .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY,
		  .quirks = TPACPI_KEYMAP_IBM_GENERIC,
		},
		{
		  .vendor = PCI_VENDOR_ID_LENOVO,
		  .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY,
		  .quirks = TPACPI_KEYMAP_LENOVO_GENERIC,
		},
	};

#define TPACPI_HOTKEY_MAP_SIZE		sizeof(tpacpi_keymap_t)
3471
#define TPACPI_HOTKEY_MAP_TYPESIZE	sizeof(tpacpi_keymap_entry_t)
3472

3473
	int res, i;
3474
	int status;
3475
	int hkeyv;
3476 3477
	bool radiosw_state  = false;
	bool tabletsw_state = false;
3478

3479
	unsigned long quirks;
3480
	unsigned long keymap_id;
3481

3482 3483
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
			"initializing hotkey subdriver\n");
3484

3485
	BUG_ON(!tpacpi_inputdev);
3486 3487
	BUG_ON(tpacpi_inputdev->open != NULL ||
	       tpacpi_inputdev->close != NULL);
3488

3489
	TPACPI_ACPIHANDLE_INIT(hkey);
3490
	mutex_init(&hotkey_mutex);
3491

3492 3493 3494 3495
#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
	mutex_init(&hotkey_thread_data_mutex);
#endif

3496
	/* hotkey not supported on 570 */
3497
	tp_features.hotkey = hkey_handle != NULL;
3498

3499 3500
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
		"hotkeys are %s\n",
3501
		str_supported(tp_features.hotkey));
3502

3503 3504
	if (!tp_features.hotkey)
		return 1;
3505

3506 3507 3508
	quirks = tpacpi_check_quirks(tpacpi_hotkey_qtable,
				     ARRAY_SIZE(tpacpi_hotkey_qtable));

3509 3510
	tpacpi_disable_brightness_delay();

3511 3512 3513 3514 3515
	/* MUST have enough space for all attributes to be added to
	 * hotkey_dev_attributes */
	hotkey_dev_attributes = create_attr_set(
					ARRAY_SIZE(hotkey_attributes) + 2,
					NULL);
3516 3517 3518 3519 3520 3521 3522 3523
	if (!hotkey_dev_attributes)
		return -ENOMEM;
	res = add_many_to_attr_set(hotkey_dev_attributes,
			hotkey_attributes,
			ARRAY_SIZE(hotkey_attributes));
	if (res)
		goto err_exit;

3524
	/* mask not supported on 600e/x, 770e, 770x, A21e, A2xm/p,
3525 3526 3527
	   A30, R30, R31, T20-22, X20-21, X22-24.  Detected by checking
	   for HKEY interface version 0x100 */
	if (acpi_evalf(hkey_handle, &hkeyv, "MHKV", "qd")) {
3528 3529 3530 3531 3532 3533
		vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
			    "firmware HKEY interface version: 0x%x\n",
			    hkeyv);

		switch (hkeyv >> 8) {
		case 1:
3534 3535 3536 3537
			/*
			 * MHKV 0x100 in A31, R40, R40e,
			 * T4x, X31, and later
			 */
3538 3539 3540 3541

			/* Paranoia check AND init hotkey_all_mask */
			if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
					"MHKA", "qd")) {
3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559
				pr_err("missing MHKA handler, please report this to %s\n",
				       TPACPI_MAIL);
				/* Fallback: pre-init for FN+F3,F4,F12 */
				hotkey_all_mask = 0x080cU;
			} else {
				tp_features.hotkey_mask = 1;
			}
			break;

		case 2:
			/*
			 * MHKV 0x200 in X1, T460s, X260, T560, X1 Tablet (2016)
			 */

			/* Paranoia check AND init hotkey_all_mask */
			if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
					"MHKA", "dd", 1)) {
				pr_err("missing MHKA handler, please report this to %s\n",
3560 3561 3562 3563 3564 3565
				       TPACPI_MAIL);
				/* Fallback: pre-init for FN+F3,F4,F12 */
				hotkey_all_mask = 0x080cU;
			} else {
				tp_features.hotkey_mask = 1;
			}
3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591

			/*
			 * Check if we have an adaptive keyboard, like on the
			 * Lenovo Carbon X1 2014 (2nd Gen).
			 */
			if (acpi_evalf(hkey_handle, &hotkey_adaptive_all_mask,
				       "MHKA", "dd", 2)) {
				if (hotkey_adaptive_all_mask != 0) {
					tp_features.has_adaptive_kbd = true;
					res = sysfs_create_group(
						&tpacpi_pdev->dev.kobj,
						&adaptive_kbd_attr_group);
					if (res)
						goto err_exit;
				}
			} else {
				tp_features.has_adaptive_kbd = false;
				hotkey_adaptive_all_mask = 0x0U;
			}
			break;

		default:
			pr_err("unknown version of the HKEY interface: 0x%x\n",
			       hkeyv);
			pr_err("please report this to %s\n", TPACPI_MAIL);
			break;
3592
		}
3593
	}
3594

3595 3596
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
		"hotkey masks are %s\n",
3597
		str_supported(tp_features.hotkey_mask));
3598

3599 3600 3601 3602
	/* Init hotkey_all_mask if not initialized yet */
	if (!tp_features.hotkey_mask && !hotkey_all_mask &&
	    (quirks & TPACPI_HK_Q_INIMASK))
		hotkey_all_mask = 0x080cU;  /* FN+F12, FN+F4, FN+F3 */
3603

3604
	/* Init hotkey_acpi_mask and hotkey_orig_mask */
3605
	if (tp_features.hotkey_mask) {
3606 3607
		/* hotkey_source_mask *must* be zero for
		 * the first hotkey_mask_get to return hotkey_orig_mask */
3608 3609 3610 3611
		res = hotkey_mask_get();
		if (res)
			goto err_exit;

3612 3613 3614 3615
		hotkey_orig_mask = hotkey_acpi_mask;
	} else {
		hotkey_orig_mask = hotkey_all_mask;
		hotkey_acpi_mask = hotkey_all_mask;
3616
	}
3617

3618 3619 3620
#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
	if (dbg_wlswemul) {
		tp_features.hotkey_wlsw = 1;
3621
		radiosw_state = !!tpacpi_wlsw_emulstate;
3622
		pr_info("radio switch emulation enabled\n");
3623 3624
	} else
#endif
3625 3626 3627
	/* Not all thinkpads have a hardware radio switch */
	if (acpi_evalf(hkey_handle, &status, "WLSW", "qd")) {
		tp_features.hotkey_wlsw = 1;
3628
		radiosw_state = !!status;
3629
		pr_info("radio switch found; radios are %s\n",
3630
			enabled(status, 0));
3631 3632
	}
	if (tp_features.hotkey_wlsw)
3633 3634
		res = add_to_attr_set(hotkey_dev_attributes,
				&dev_attr_hotkey_radio_sw.attr);
3635

3636 3637 3638 3639 3640
	res = hotkey_init_tablet_mode();
	if (res < 0)
		goto err_exit;

	tabletsw_state = res;
3641

3642 3643
	res = register_attr_set_with_sysfs(hotkey_dev_attributes,
					   &tpacpi_pdev->dev.kobj);
3644 3645
	if (res)
		goto err_exit;
3646

3647
	/* Set up key map */
3648 3649 3650 3651 3652 3653
	keymap_id = tpacpi_check_quirks(tpacpi_keymap_qtable,
					ARRAY_SIZE(tpacpi_keymap_qtable));
	BUG_ON(keymap_id >= ARRAY_SIZE(tpacpi_keymaps));
	dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
		   "using keymap number %lu\n", keymap_id);

3654 3655 3656 3657 3658 3659 3660
	hotkey_keycode_map = kmemdup(&tpacpi_keymaps[keymap_id],
			TPACPI_HOTKEY_MAP_SIZE,	GFP_KERNEL);
	if (!hotkey_keycode_map) {
		pr_err("failed to allocate memory for key map\n");
		res = -ENOMEM;
		goto err_exit;
	}
3661

3662
	input_set_capability(tpacpi_inputdev, EV_MSC, MSC_SCAN);
3663 3664 3665 3666 3667
	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++) {
		if (hotkey_keycode_map[i] != KEY_RESERVED) {
3668 3669
			input_set_capability(tpacpi_inputdev, EV_KEY,
						hotkey_keycode_map[i]);
3670 3671 3672
		} else {
			if (i < sizeof(hotkey_reserved_mask)*8)
				hotkey_reserved_mask |= 1 << i;
3673
		}
3674
	}
3675

3676
	if (tp_features.hotkey_wlsw) {
3677
		input_set_capability(tpacpi_inputdev, EV_SW, SW_RFKILL_ALL);
3678 3679
		input_report_switch(tpacpi_inputdev,
				    SW_RFKILL_ALL, radiosw_state);
3680 3681
	}
	if (tp_features.hotkey_tablet) {
3682
		input_set_capability(tpacpi_inputdev, EV_SW, SW_TABLET_MODE);
3683 3684
		input_report_switch(tpacpi_inputdev,
				    SW_TABLET_MODE, tabletsw_state);
3685
	}
3686

3687
	/* Do not issue duplicate brightness change events to
3688 3689
	 * userspace. tpacpi_detect_brightness_capabilities() must have
	 * been called before this point  */
3690
	if (acpi_video_get_backlight_type() != acpi_backlight_vendor) {
3691 3692
		pr_info("This ThinkPad has standard ACPI backlight brightness control, supported by the ACPI video driver\n");
		pr_notice("Disabling thinkpad-acpi brightness events by default...\n");
3693

3694 3695 3696
		/* Disable brightness up/down on Lenovo thinkpads when
		 * ACPI is handling them, otherwise it is plain impossible
		 * for userspace to do something even remotely sane */
3697 3698 3699
		hotkey_reserved_mask |=
			(1 << TP_ACPI_HOTKEYSCAN_FNHOME)
			| (1 << TP_ACPI_HOTKEYSCAN_FNEND);
3700 3701
		hotkey_unmap(TP_ACPI_HOTKEYSCAN_FNHOME);
		hotkey_unmap(TP_ACPI_HOTKEYSCAN_FNEND);
3702
	}
3703

3704
#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
3705 3706 3707
	hotkey_source_mask = TPACPI_HKEY_NVRAM_GOOD_MASK
				& ~hotkey_all_mask
				& ~hotkey_reserved_mask;
3708 3709 3710 3711 3712 3713

	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
		    "hotkey source mask 0x%08x, polling freq %u\n",
		    hotkey_source_mask, hotkey_poll_freq);
#endif

3714 3715
	dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
			"enabling firmware HKEY event interface...\n");
3716
	res = hotkey_status_set(true);
3717 3718 3719 3720
	if (res) {
		hotkey_exit();
		return res;
	}
3721 3722 3723
	res = hotkey_mask_set(((hotkey_all_mask & ~hotkey_reserved_mask)
			       | hotkey_driver_mask)
			      & ~hotkey_source_mask);
3724 3725 3726 3727
	if (res < 0 && res != -ENXIO) {
		hotkey_exit();
		return res;
	}
3728 3729 3730 3731 3732
	hotkey_user_mask = (hotkey_acpi_mask | hotkey_source_mask)
				& ~hotkey_reserved_mask;
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_HKEY,
		"initial masks: user=0x%08x, fw=0x%08x, poll=0x%08x\n",
		hotkey_user_mask, hotkey_acpi_mask, hotkey_source_mask);
3733

3734 3735
	tpacpi_inputdev->open = &hotkey_inputdev_open;
	tpacpi_inputdev->close = &hotkey_inputdev_close;
3736

3737
	hotkey_poll_setup_safe(true);
3738

3739
	return 0;
3740

3741 3742
err_exit:
	delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj);
3743 3744 3745
	sysfs_remove_group(&tpacpi_pdev->dev.kobj,
			&adaptive_kbd_attr_group);

3746
	hotkey_dev_attributes = NULL;
3747

3748
	return (res < 0) ? res : 1;
3749 3750
}

3751 3752 3753 3754 3755 3756 3757
/* Thinkpad X1 Carbon support 5 modes including Home mode, Web browser
 * mode, Web conference mode, Function mode and Lay-flat mode.
 * We support Home mode and Function mode currently.
 *
 * Will consider support rest of modes in future.
 *
 */
3758
static const int adaptive_keyboard_modes[] = {
3759 3760 3761 3762 3763 3764 3765 3766
	HOME_MODE,
/*	WEB_BROWSER_MODE = 2,
	WEB_CONFERENCE_MODE = 3, */
	FUNCTION_MODE
};

#define DFR_CHANGE_ROW			0x101
#define DFR_SHOW_QUICKVIEW_ROW		0x102
3767
#define FIRST_ADAPTIVE_KEY		0x103
3768 3769 3770 3771 3772 3773 3774

/* press Fn key a while second, it will switch to Function Mode. Then
 * release Fn key, previous mode be restored.
 */
static bool adaptive_keyboard_mode_is_saved;
static int adaptive_keyboard_prev_mode;

3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800
static int adaptive_keyboard_get_mode(void)
{
	int mode = 0;

	if (!acpi_evalf(hkey_handle, &mode, "GTRW", "dd", 0)) {
		pr_err("Cannot read adaptive keyboard mode\n");
		return -EIO;
	}

	return mode;
}

static int adaptive_keyboard_set_mode(int new_mode)
{
	if (new_mode < 0 ||
		new_mode > LAYFLAT_MODE)
		return -EINVAL;

	if (!acpi_evalf(hkey_handle, NULL, "STRW", "vd", new_mode)) {
		pr_err("Cannot set adaptive keyboard mode\n");
		return -EIO;
	}

	return 0;
}

3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820
static int adaptive_keyboard_get_next_mode(int mode)
{
	size_t i;
	size_t max_mode = ARRAY_SIZE(adaptive_keyboard_modes) - 1;

	for (i = 0; i <= max_mode; i++) {
		if (adaptive_keyboard_modes[i] == mode)
			break;
	}

	if (i >= max_mode)
		i = 0;
	else
		i++;

	return adaptive_keyboard_modes[i];
}

static bool adaptive_keyboard_hotkey_notify_hotkey(unsigned int scancode)
{
3821
	int current_mode = 0;
3822
	int new_mode = 0;
3823
	int keycode;
3824 3825 3826 3827 3828 3829 3830

	switch (scancode) {
	case DFR_CHANGE_ROW:
		if (adaptive_keyboard_mode_is_saved) {
			new_mode = adaptive_keyboard_prev_mode;
			adaptive_keyboard_mode_is_saved = false;
		} else {
3831 3832
			current_mode = adaptive_keyboard_get_mode();
			if (current_mode < 0)
3833
				return false;
3834 3835
			new_mode = adaptive_keyboard_get_next_mode(
					current_mode);
3836 3837
		}

3838
		if (adaptive_keyboard_set_mode(new_mode) < 0)
3839 3840 3841 3842 3843
			return false;

		return true;

	case DFR_SHOW_QUICKVIEW_ROW:
3844 3845
		current_mode = adaptive_keyboard_get_mode();
		if (current_mode < 0)
3846 3847
			return false;

3848 3849 3850 3851 3852
		adaptive_keyboard_prev_mode = current_mode;
		adaptive_keyboard_mode_is_saved = true;

		if (adaptive_keyboard_set_mode (FUNCTION_MODE) < 0)
			return false;
3853 3854 3855
		return true;

	default:
3856
		if (scancode < FIRST_ADAPTIVE_KEY ||
3857 3858 3859
		    scancode >= FIRST_ADAPTIVE_KEY +
		    TP_ACPI_HOTKEYSCAN_EXTENDED_START -
		    TP_ACPI_HOTKEYSCAN_ADAPTIVE_START) {
3860
			pr_info("Unhandled adaptive keyboard key: 0x%x\n",
3861
				scancode);
3862 3863
			return false;
		}
3864 3865
		keycode = hotkey_keycode_map[scancode - FIRST_ADAPTIVE_KEY +
					     TP_ACPI_HOTKEYSCAN_ADAPTIVE_START];
3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877
		if (keycode != KEY_RESERVED) {
			mutex_lock(&tpacpi_inputdev_send_mutex);

			input_report_key(tpacpi_inputdev, keycode, 1);
			input_sync(tpacpi_inputdev);

			input_report_key(tpacpi_inputdev, keycode, 0);
			input_sync(tpacpi_inputdev);

			mutex_unlock(&tpacpi_inputdev_send_mutex);
		}
		return true;
3878 3879 3880
	}
}

3881 3882 3883 3884 3885 3886 3887 3888 3889
static bool hotkey_notify_hotkey(const u32 hkey,
				 bool *send_acpi_ev,
				 bool *ignore_acpi_ev)
{
	/* 0x1000-0x1FFF: key presses */
	unsigned int scancode = hkey & 0xfff;
	*send_acpi_ev = true;
	*ignore_acpi_ev = false;

3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907
	/*
	 * Original events are in the 0x10XX range, the adaptive keyboard
	 * found in 2014 X1 Carbon emits events are of 0x11XX. In 2017
	 * models, additional keys are emitted through 0x13XX.
	 */
	switch ((hkey >> 8) & 0xf) {
	case 0:
		if (scancode > 0 &&
		    scancode <= TP_ACPI_HOTKEYSCAN_ADAPTIVE_START) {
			/* HKEY event 0x1001 is scancode 0x00 */
			scancode--;
			if (!(hotkey_source_mask & (1 << scancode))) {
				tpacpi_input_send_key_masked(scancode);
				*send_acpi_ev = false;
			} else {
				*ignore_acpi_ev = true;
			}
			return true;
3908
		}
3909 3910 3911
		break;

	case 1:
3912
		return adaptive_keyboard_hotkey_notify_hotkey(scancode);
3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925

	case 3:
		/* Extended keycodes start at 0x300 and our offset into the map
		 * TP_ACPI_HOTKEYSCAN_EXTENDED_START. The calculated scancode
		 * will be positive, but might not be in the correct range.
		 */
		scancode -= (0x300 - TP_ACPI_HOTKEYSCAN_EXTENDED_START);
		if (scancode >= TP_ACPI_HOTKEYSCAN_EXTENDED_START &&
		    scancode < TPACPI_HOTKEY_MAP_LEN) {
			tpacpi_input_send_key(scancode);
			return true;
		}
		break;
3926
	}
3927

3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939
	return false;
}

static bool hotkey_notify_wakeup(const u32 hkey,
				 bool *send_acpi_ev,
				 bool *ignore_acpi_ev)
{
	/* 0x2000-0x2FFF: Wakeup reason */
	*send_acpi_ev = true;
	*ignore_acpi_ev = false;

	switch (hkey) {
3940 3941
	case TP_HKEY_EV_WKUP_S3_UNDOCK: /* suspend, undock */
	case TP_HKEY_EV_WKUP_S4_UNDOCK: /* hibernation, undock */
3942 3943 3944 3945
		hotkey_wakeup_reason = TP_ACPI_WAKEUP_UNDOCK;
		*ignore_acpi_ev = true;
		break;

3946 3947
	case TP_HKEY_EV_WKUP_S3_BAYEJ: /* suspend, bay eject */
	case TP_HKEY_EV_WKUP_S4_BAYEJ: /* hibernation, bay eject */
3948 3949 3950 3951
		hotkey_wakeup_reason = TP_ACPI_WAKEUP_BAYEJ;
		*ignore_acpi_ev = true;
		break;

3952 3953
	case TP_HKEY_EV_WKUP_S3_BATLOW: /* Battery on critical low level/S3 */
	case TP_HKEY_EV_WKUP_S4_BATLOW: /* Battery on critical low level/S4 */
3954
		pr_alert("EMERGENCY WAKEUP: battery almost empty\n");
3955 3956 3957 3958 3959
		/* how to auto-heal: */
		/* 2313: woke up from S3, go to S4/S5 */
		/* 2413: woke up from S4, go to S5 */
		break;

3960 3961 3962 3963 3964
	default:
		return false;
	}

	if (hotkey_wakeup_reason != TP_ACPI_WAKEUP_NONE) {
3965
		pr_info("woke up due to a hot-unplug request...\n");
3966 3967 3968 3969 3970
		hotkey_wakeup_reason_notify_change();
	}
	return true;
}

3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998
static bool hotkey_notify_dockevent(const u32 hkey,
				 bool *send_acpi_ev,
				 bool *ignore_acpi_ev)
{
	/* 0x4000-0x4FFF: dock-related events */
	*send_acpi_ev = true;
	*ignore_acpi_ev = false;

	switch (hkey) {
	case TP_HKEY_EV_UNDOCK_ACK:
		/* ACPI undock operation completed after wakeup */
		hotkey_autosleep_ack = 1;
		pr_info("undocked\n");
		hotkey_wakeup_hotunplug_complete_notify_change();
		return true;

	case TP_HKEY_EV_HOTPLUG_DOCK: /* docked to port replicator */
		pr_info("docked into hotplug port replicator\n");
		return true;
	case TP_HKEY_EV_HOTPLUG_UNDOCK: /* undocked from port replicator */
		pr_info("undocked from hotplug port replicator\n");
		return true;

	default:
		return false;
	}
}

3999 4000 4001 4002 4003 4004 4005 4006 4007
static bool hotkey_notify_usrevent(const u32 hkey,
				 bool *send_acpi_ev,
				 bool *ignore_acpi_ev)
{
	/* 0x5000-0x5FFF: human interface helpers */
	*send_acpi_ev = true;
	*ignore_acpi_ev = false;

	switch (hkey) {
4008 4009
	case TP_HKEY_EV_PEN_INSERTED:  /* X61t: tablet pen inserted into bay */
	case TP_HKEY_EV_PEN_REMOVED:   /* X61t: tablet pen removed from bay */
4010 4011
		return true;

4012 4013
	case TP_HKEY_EV_TABLET_TABLET:   /* X41t-X61t: tablet mode */
	case TP_HKEY_EV_TABLET_NOTEBOOK: /* X41t-X61t: normal mode */
4014 4015 4016 4017 4018
		tpacpi_input_send_tabletsw();
		hotkey_tablet_mode_notify_change();
		*send_acpi_ev = false;
		return true;

4019 4020 4021
	case TP_HKEY_EV_LID_CLOSE:	/* Lid closed */
	case TP_HKEY_EV_LID_OPEN:	/* Lid opened */
	case TP_HKEY_EV_BRGHT_CHANGED:	/* brightness changed */
4022
		/* do not propagate these events */
4023 4024 4025 4026 4027 4028 4029 4030
		*ignore_acpi_ev = true;
		return true;

	default:
		return false;
	}
}

4031
static void thermal_dump_all_sensors(void);
4032
static void palmsensor_refresh(void);
4033

4034
static bool hotkey_notify_6xxx(const u32 hkey,
4035 4036 4037
				 bool *send_acpi_ev,
				 bool *ignore_acpi_ev)
{
4038
	/* 0x6000-0x6FFF: thermal alarms/notices and keyboard events */
4039 4040 4041 4042
	*send_acpi_ev = true;
	*ignore_acpi_ev = false;

	switch (hkey) {
4043
	case TP_HKEY_EV_THM_TABLE_CHANGED:
4044 4045 4046 4047 4048 4049
		pr_debug("EC reports: Thermal Table has changed\n");
		/* recommended action: do nothing, we don't have
		 * Lenovo ATM information */
		return true;
	case TP_HKEY_EV_THM_CSM_COMPLETED:
		pr_debug("EC reports: Thermal Control Command set completed (DYTC)\n");
4050 4051
		/* Thermal event - pass on to event handler */
		tpacpi_driver_event(hkey);
4052 4053 4054
		return true;
	case TP_HKEY_EV_THM_TRANSFM_CHANGED:
		pr_debug("EC reports: Thermal Transformation changed (GMTS)\n");
4055 4056 4057
		/* recommended action: do nothing, we don't have
		 * Lenovo ATM information */
		return true;
4058
	case TP_HKEY_EV_ALARM_BAT_HOT:
4059
		pr_crit("THERMAL ALARM: battery is too hot!\n");
4060
		/* recommended action: warn user through gui */
4061
		break;
4062
	case TP_HKEY_EV_ALARM_BAT_XHOT:
4063
		pr_alert("THERMAL EMERGENCY: battery is extremely hot!\n");
4064
		/* recommended action: immediate sleep/hibernate */
4065
		break;
4066
	case TP_HKEY_EV_ALARM_SENSOR_HOT:
4067
		pr_crit("THERMAL ALARM: a sensor reports something is too hot!\n");
4068 4069
		/* recommended action: warn user through gui, that */
		/* some internal component is too hot */
4070
		break;
4071
	case TP_HKEY_EV_ALARM_SENSOR_XHOT:
4072
		pr_alert("THERMAL EMERGENCY: a sensor reports something is extremely hot!\n");
4073
		/* recommended action: immediate sleep/hibernate */
4074
		break;
4075 4076 4077 4078 4079
	case TP_HKEY_EV_AC_CHANGED:
		/* X120e, X121e, X220, X220i, X220t, X230, T420, T420s, W520:
		 * AC status changed; can be triggered by plugging or
		 * unplugging AC adapter, docking or undocking. */

4080
		fallthrough;
4081 4082 4083

	case TP_HKEY_EV_KEY_NUMLOCK:
	case TP_HKEY_EV_KEY_FN:
4084
	case TP_HKEY_EV_KEY_FN_ESC:
4085 4086 4087 4088 4089 4090
		/* key press events, we just ignore them as long as the EC
		 * is still reporting them in the normal keyboard stream */
		*send_acpi_ev = false;
		*ignore_acpi_ev = true;
		return true;

4091 4092 4093 4094
	case TP_HKEY_EV_TABLET_CHANGED:
		tpacpi_input_send_tabletsw();
		hotkey_tablet_mode_notify_change();
		*send_acpi_ev = false;
4095
		return true;
4096

4097 4098
	case TP_HKEY_EV_PALM_DETECTED:
	case TP_HKEY_EV_PALM_UNDETECTED:
4099 4100
		/* palm detected  - pass on to event handler */
		palmsensor_refresh();
4101 4102
		return true;

4103
	default:
4104 4105
		/* report simply as unknown, no sensor dump */
		return false;
4106
	}
4107 4108

	thermal_dump_all_sensors();
4109
	return true;
4110 4111
}

4112 4113
static void hotkey_notify(struct ibm_struct *ibm, u32 event)
{
4114
	u32 hkey;
4115 4116 4117
	bool send_acpi_ev;
	bool ignore_acpi_ev;
	bool known_ev;
4118 4119

	if (event != 0x80) {
4120
		pr_err("unknown HKEY notification event %d\n", event);
4121
		/* forward it to userspace, maybe it knows how to handle it */
4122 4123
		acpi_bus_generate_netlink_event(
					ibm->acpi->device->pnp.device_class,
4124
					dev_name(&ibm->acpi->device->dev),
4125
					event, 0);
4126 4127 4128 4129 4130
		return;
	}

	while (1) {
		if (!acpi_evalf(hkey_handle, &hkey, "MHKP", "d")) {
4131
			pr_err("failed to retrieve HKEY event\n");
4132 4133 4134 4135 4136 4137 4138 4139
			return;
		}

		if (hkey == 0) {
			/* queue empty */
			return;
		}

4140 4141
		send_acpi_ev = true;
		ignore_acpi_ev = false;
4142

4143 4144 4145
		switch (hkey >> 12) {
		case 1:
			/* 0x1000-0x1FFF: key presses */
4146 4147
			known_ev = hotkey_notify_hotkey(hkey, &send_acpi_ev,
						 &ignore_acpi_ev);
4148
			break;
4149
		case 2:
4150 4151 4152
			/* 0x2000-0x2FFF: Wakeup reason */
			known_ev = hotkey_notify_wakeup(hkey, &send_acpi_ev,
						 &ignore_acpi_ev);
4153 4154
			break;
		case 3:
4155
			/* 0x3000-0x3FFF: bay-related wakeups */
4156 4157
			switch (hkey) {
			case TP_HKEY_EV_BAYEJ_ACK:
4158
				hotkey_autosleep_ack = 1;
4159
				pr_info("bay ejected\n");
4160
				hotkey_wakeup_hotunplug_complete_notify_change();
4161
				known_ev = true;
4162 4163 4164 4165 4166 4167
				break;
			case TP_HKEY_EV_OPTDRV_EJ:
				/* FIXME: kick libata if SATA link offline */
				known_ev = true;
				break;
			default:
4168
				known_ev = false;
4169 4170 4171
			}
			break;
		case 4:
4172 4173 4174
			/* 0x4000-0x4FFF: dock-related events */
			known_ev = hotkey_notify_dockevent(hkey, &send_acpi_ev,
						&ignore_acpi_ev);
4175
			break;
4176
		case 5:
4177
			/* 0x5000-0x5FFF: human interface helpers */
4178 4179
			known_ev = hotkey_notify_usrevent(hkey, &send_acpi_ev,
						 &ignore_acpi_ev);
4180
			break;
4181
		case 6:
4182 4183 4184
			/* 0x6000-0x6FFF: thermal alarms/notices and
			 *                keyboard events */
			known_ev = hotkey_notify_6xxx(hkey, &send_acpi_ev,
4185 4186
						 &ignore_acpi_ev);
			break;
4187 4188
		case 7:
			/* 0x7000-0x7FFF: misc */
4189 4190
			if (tp_features.hotkey_wlsw &&
					hkey == TP_HKEY_EV_RFKILL_CHANGED) {
4191
				tpacpi_send_radiosw_update();
4192
				send_acpi_ev = 0;
4193
				known_ev = true;
4194 4195
				break;
			}
4196
			fallthrough;	/* to default */
4197
		default:
4198
			known_ev = false;
4199
		}
4200
		if (!known_ev) {
4201
			pr_notice("unhandled HKEY event 0x%04x\n", hkey);
4202 4203
			pr_notice("please report the conditions when this event happened to %s\n",
				  TPACPI_MAIL);
4204
		}
4205

4206
		/* netlink events */
4207
		if (!ignore_acpi_ev && send_acpi_ev) {
4208 4209
			acpi_bus_generate_netlink_event(
					ibm->acpi->device->pnp.device_class,
4210
					dev_name(&ibm->acpi->device->dev),
4211
					event, hkey);
4212
		}
4213 4214 4215
	}
}

4216
static void hotkey_suspend(void)
4217 4218 4219 4220
{
	/* Do these on suspend, we get the events on early resume! */
	hotkey_wakeup_reason = TP_ACPI_WAKEUP_NONE;
	hotkey_autosleep_ack = 0;
4221 4222

	/* save previous mode of adaptive keyboard of X1 Carbon */
4223 4224 4225 4226
	if (tp_features.has_adaptive_kbd) {
		if (!acpi_evalf(hkey_handle, &adaptive_keyboard_prev_mode,
					"GTRW", "dd", 0)) {
			pr_err("Cannot read adaptive keyboard mode.\n");
4227 4228
		}
	}
4229 4230
}

4231 4232
static void hotkey_resume(void)
{
4233 4234
	tpacpi_disable_brightness_delay();

4235 4236
	if (hotkey_status_set(true) < 0 ||
	    hotkey_mask_set(hotkey_acpi_mask) < 0)
4237
		pr_err("error while attempting to reset the event firmware interface\n");
4238

4239
	tpacpi_send_radiosw_update();
4240
	tpacpi_input_send_tabletsw();
4241
	hotkey_tablet_mode_notify_change();
4242 4243
	hotkey_wakeup_reason_notify_change();
	hotkey_wakeup_hotunplug_complete_notify_change();
4244
	hotkey_poll_setup_safe(false);
4245 4246

	/* restore previous mode of adapive keyboard of X1 Carbon */
4247 4248 4249 4250
	if (tp_features.has_adaptive_kbd) {
		if (!acpi_evalf(hkey_handle, NULL, "STRW", "vd",
					adaptive_keyboard_prev_mode)) {
			pr_err("Cannot set adaptive keyboard mode.\n");
4251 4252
		}
	}
4253 4254
}

4255
/* procfs -------------------------------------------------------------- */
4256
static int hotkey_read(struct seq_file *m)
L
Linus Torvalds 已提交
4257
{
4258
	int res, status;
L
Linus Torvalds 已提交
4259

4260
	if (!tp_features.hotkey) {
4261 4262
		seq_printf(m, "status:\t\tnot supported\n");
		return 0;
4263 4264
	}

4265
	if (mutex_lock_killable(&hotkey_mutex))
4266
		return -ERESTARTSYS;
4267 4268 4269
	res = hotkey_status_get(&status);
	if (!res)
		res = hotkey_mask_get();
4270
	mutex_unlock(&hotkey_mutex);
4271 4272
	if (res)
		return res;
L
Linus Torvalds 已提交
4273

4274
	seq_printf(m, "status:\t\t%s\n", enabled(status, 0));
4275
	if (hotkey_all_mask) {
4276 4277
		seq_printf(m, "mask:\t\t0x%08x\n", hotkey_user_mask);
		seq_printf(m, "commands:\tenable, disable, reset, <mask>\n");
L
Linus Torvalds 已提交
4278
	} else {
4279 4280
		seq_printf(m, "mask:\t\tnot supported\n");
		seq_printf(m, "commands:\tenable, disable, reset\n");
L
Linus Torvalds 已提交
4281 4282
	}

4283
	return 0;
L
Linus Torvalds 已提交
4284 4285
}

4286
static void hotkey_enabledisable_warn(bool enable)
4287 4288
{
	tpacpi_log_usertask("procfs hotkey enable/disable");
4289
	if (!WARN((tpacpi_lifecycle == TPACPI_LIFE_RUNNING || !enable),
4290 4291
		  pr_fmt("hotkey enable/disable functionality has been removed from the driver.  Hotkeys are always enabled.\n")))
		pr_err("Please remove the hotkey=enable module parameter, it is deprecated.  Hotkeys are always enabled.\n");
4292 4293
}

4294
static int hotkey_write(char *buf)
L
Linus Torvalds 已提交
4295
{
4296
	int res;
4297
	u32 mask;
L
Linus Torvalds 已提交
4298 4299
	char *cmd;

4300
	if (!tp_features.hotkey)
L
Linus Torvalds 已提交
4301 4302
		return -ENODEV;

4303
	if (mutex_lock_killable(&hotkey_mutex))
4304
		return -ERESTARTSYS;
4305

4306
	mask = hotkey_user_mask;
4307

4308
	res = 0;
4309
	while ((cmd = strsep(&buf, ","))) {
L
Linus Torvalds 已提交
4310
		if (strlencmp(cmd, "enable") == 0) {
4311
			hotkey_enabledisable_warn(1);
L
Linus Torvalds 已提交
4312
		} else if (strlencmp(cmd, "disable") == 0) {
4313
			hotkey_enabledisable_warn(0);
4314
			res = -EPERM;
L
Linus Torvalds 已提交
4315
		} else if (strlencmp(cmd, "reset") == 0) {
4316 4317
			mask = (hotkey_all_mask | hotkey_source_mask)
				& ~hotkey_reserved_mask;
L
Linus Torvalds 已提交
4318 4319 4320 4321
		} else if (sscanf(cmd, "0x%x", &mask) == 1) {
			/* mask set */
		} else if (sscanf(cmd, "%x", &mask) == 1) {
			/* mask set */
4322 4323 4324 4325
		} else {
			res = -EINVAL;
			goto errexit;
		}
L
Linus Torvalds 已提交
4326
	}
4327

4328
	if (!res) {
4329 4330
		tpacpi_disclose_usertask("procfs hotkey",
			"set mask to 0x%08x\n", mask);
4331 4332
		res = hotkey_user_mask_set(mask);
	}
L
Linus Torvalds 已提交
4333

4334 4335 4336
errexit:
	mutex_unlock(&hotkey_mutex);
	return res;
4337
}
L
Linus Torvalds 已提交
4338

4339
static const struct acpi_device_id ibm_htk_device_ids[] = {
4340 4341
	{TPACPI_ACPI_IBM_HKEY_HID, 0},
	{TPACPI_ACPI_LENOVO_HKEY_HID, 0},
4342
	{TPACPI_ACPI_LENOVO_HKEY_V2_HID, 0},
4343 4344 4345
	{"", 0},
};

4346
static struct tp_acpi_drv_struct ibm_hotkey_acpidriver = {
4347
	.hid = ibm_htk_device_ids,
4348 4349 4350 4351 4352
	.notify = hotkey_notify,
	.handle = &hkey_handle,
	.type = ACPI_DEVICE_NOTIFY,
};

4353 4354 4355 4356 4357
static struct ibm_struct hotkey_driver_data = {
	.name = "hotkey",
	.read = hotkey_read,
	.write = hotkey_write,
	.exit = hotkey_exit,
4358
	.resume = hotkey_resume,
4359
	.suspend = hotkey_suspend,
4360
	.acpi = &ibm_hotkey_acpidriver,
4361 4362
};

4363 4364 4365
/*************************************************************************
 * Bluetooth subdriver
 */
L
Linus Torvalds 已提交
4366

4367 4368 4369 4370
enum {
	/* ACPI GBDC/SBDC bits */
	TP_ACPI_BLUETOOTH_HWPRESENT	= 0x01,	/* Bluetooth hw available */
	TP_ACPI_BLUETOOTH_RADIOSSW	= 0x02,	/* Bluetooth radio enabled */
4371
	TP_ACPI_BLUETOOTH_RESUMECTRL	= 0x04,	/* Bluetooth state at resume:
4372
						   0 = disable, 1 = enable */
4373 4374 4375 4376 4377 4378 4379 4380 4381
};

enum {
	/* ACPI \BLTH commands */
	TP_ACPI_BLTH_GET_ULTRAPORT_ID	= 0x00, /* Get Ultraport BT ID */
	TP_ACPI_BLTH_GET_PWR_ON_RESUME	= 0x01, /* Get power-on-resume state */
	TP_ACPI_BLTH_PWR_ON_ON_RESUME	= 0x02, /* Resume powered on */
	TP_ACPI_BLTH_PWR_OFF_ON_RESUME	= 0x03,	/* Resume powered off */
	TP_ACPI_BLTH_SAVE_STATE		= 0x05, /* Save state for S4/S5 */
4382 4383
};

4384 4385
#define TPACPI_RFK_BLUETOOTH_SW_NAME	"tpacpi_bluetooth_sw"

J
Johannes Berg 已提交
4386
static int bluetooth_get_status(void)
4387 4388 4389
{
	int status;

4390 4391 4392
#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
	if (dbg_bluetoothemul)
		return (tpacpi_bluetooth_emulstate) ?
J
Johannes Berg 已提交
4393
		       TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
4394 4395
#endif

4396 4397 4398
	if (!acpi_evalf(hkey_handle, &status, "GBDC", "d"))
		return -EIO;

4399
	return ((status & TP_ACPI_BLUETOOTH_RADIOSSW) != 0) ?
J
Johannes Berg 已提交
4400
			TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
4401 4402
}

J
Johannes Berg 已提交
4403
static int bluetooth_set_status(enum tpacpi_rfkill_state state)
4404 4405 4406
{
	int status;

4407
	vdbg_printk(TPACPI_DBG_RFKILL,
J
Johannes Berg 已提交
4408 4409
		"will attempt to %s bluetooth\n",
		(state == TPACPI_RFK_RADIO_ON) ? "enable" : "disable");
4410

4411 4412
#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
	if (dbg_bluetoothemul) {
J
Johannes Berg 已提交
4413
		tpacpi_bluetooth_emulstate = (state == TPACPI_RFK_RADIO_ON);
4414 4415 4416 4417
		return 0;
	}
#endif

J
Johannes Berg 已提交
4418
	if (state == TPACPI_RFK_RADIO_ON)
4419 4420 4421 4422
		status = TP_ACPI_BLUETOOTH_RADIOSSW
			  | TP_ACPI_BLUETOOTH_RESUMECTRL;
	else
		status = 0;
J
Johannes Berg 已提交
4423

4424 4425 4426 4427 4428
	if (!acpi_evalf(hkey_handle, NULL, "SBDC", "vd", status))
		return -EIO;

	return 0;
}
4429

4430 4431 4432 4433 4434
/* sysfs bluetooth enable ---------------------------------------------- */
static ssize_t bluetooth_enable_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
J
Johannes Berg 已提交
4435 4436
	return tpacpi_rfk_sysfs_enable_show(TPACPI_RFK_BLUETOOTH_SW_ID,
			attr, buf);
4437 4438 4439 4440 4441 4442
}

static ssize_t bluetooth_enable_store(struct device *dev,
			    struct device_attribute *attr,
			    const char *buf, size_t count)
{
J
Johannes Berg 已提交
4443 4444
	return tpacpi_rfk_sysfs_enable_store(TPACPI_RFK_BLUETOOTH_SW_ID,
				attr, buf, count);
4445 4446
}

4447
static DEVICE_ATTR_RW(bluetooth_enable);
4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459

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

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

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

J
Johannes Berg 已提交
4460 4461 4462 4463
static const struct tpacpi_rfk_ops bluetooth_tprfk_ops = {
	.get_status = bluetooth_get_status,
	.set_status = bluetooth_set_status,
};
4464

4465 4466 4467 4468 4469
static void bluetooth_shutdown(void)
{
	/* Order firmware to save current state to NVRAM */
	if (!acpi_evalf(NULL, NULL, "\\BLTH", "vd",
			TP_ACPI_BLTH_SAVE_STATE))
4470
		pr_notice("failed to save bluetooth state to NVRAM\n");
4471 4472
	else
		vdbg_printk(TPACPI_DBG_RFKILL,
4473
			"bluetooth state saved to NVRAM\n");
4474 4475
}

4476 4477 4478 4479
static void bluetooth_exit(void)
{
	sysfs_remove_group(&tpacpi_pdev->dev.kobj,
			&bluetooth_attr_group);
J
Johannes Berg 已提交
4480 4481 4482 4483

	tpacpi_destroy_rfkill(TPACPI_RFK_BLUETOOTH_SW_ID);

	bluetooth_shutdown();
4484 4485
}

4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 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 4548 4549 4550 4551 4552 4553
static const struct dmi_system_id bt_fwbug_list[] __initconst = {
	{
		.ident = "ThinkPad E485",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_BOARD_NAME, "20KU"),
		},
	},
	{
		.ident = "ThinkPad E585",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_BOARD_NAME, "20KV"),
		},
	},
	{
		.ident = "ThinkPad A285 - 20MW",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_BOARD_NAME, "20MW"),
		},
	},
	{
		.ident = "ThinkPad A285 - 20MX",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_BOARD_NAME, "20MX"),
		},
	},
	{
		.ident = "ThinkPad A485 - 20MU",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_BOARD_NAME, "20MU"),
		},
	},
	{
		.ident = "ThinkPad A485 - 20MV",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_BOARD_NAME, "20MV"),
		},
	},
	{}
};

static const struct pci_device_id fwbug_cards_ids[] __initconst = {
	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x24F3) },
	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x24FD) },
	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2526) },
	{}
};


static int __init have_bt_fwbug(void)
{
	/*
	 * Some AMD based ThinkPads have a firmware bug that calling
	 * "GBDC" will cause bluetooth on Intel wireless cards blocked
	 */
	if (dmi_check_system(bt_fwbug_list) && pci_dev_present(fwbug_cards_ids)) {
		vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
			FW_BUG "disable bluetooth subdriver for Intel cards\n");
		return 1;
	} else
		return 0;
}

4554
static int __init bluetooth_init(struct ibm_init_struct *iibm)
L
Linus Torvalds 已提交
4555
{
4556
	int res;
4557 4558
	int status = 0;

4559 4560
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
			"initializing bluetooth subdriver\n");
4561

4562
	TPACPI_ACPIHANDLE_INIT(hkey);
4563

4564 4565
	/* bluetooth not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
	   G4x, R30, R31, R40e, R50e, T20-22, X20-21 */
4566
	tp_features.bluetooth = !have_bt_fwbug() && hkey_handle &&
4567 4568
	    acpi_evalf(hkey_handle, &status, "GBDC", "qd");

4569 4570
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
		"bluetooth is %s, status 0x%02x\n",
4571 4572 4573
		str_supported(tp_features.bluetooth),
		status);

4574 4575 4576
#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
	if (dbg_bluetoothemul) {
		tp_features.bluetooth = 1;
4577
		pr_info("bluetooth switch emulation enabled\n");
4578 4579
	} else
#endif
4580 4581 4582 4583
	if (tp_features.bluetooth &&
	    !(status & TP_ACPI_BLUETOOTH_HWPRESENT)) {
		/* no bluetooth hardware present in system */
		tp_features.bluetooth = 0;
4584
		dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
4585 4586 4587
			   "bluetooth hardware not installed\n");
	}

4588 4589 4590 4591
	if (!tp_features.bluetooth)
		return 1;

	res = tpacpi_new_rfkill(TPACPI_RFK_BLUETOOTH_SW_ID,
J
Johannes Berg 已提交
4592
				&bluetooth_tprfk_ops,
4593
				RFKILL_TYPE_BLUETOOTH,
4594
				TPACPI_RFK_BLUETOOTH_SW_NAME,
J
Johannes Berg 已提交
4595 4596 4597 4598 4599 4600
				true);
	if (res)
		return res;

	res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
				&bluetooth_attr_group);
4601
	if (res) {
J
Johannes Berg 已提交
4602
		tpacpi_destroy_rfkill(TPACPI_RFK_BLUETOOTH_SW_ID);
4603
		return res;
4604
	}
4605

4606
	return 0;
L
Linus Torvalds 已提交
4607 4608
}

4609
/* procfs -------------------------------------------------------------- */
4610
static int bluetooth_read(struct seq_file *m)
L
Linus Torvalds 已提交
4611
{
4612
	return tpacpi_rfk_procfs_read(TPACPI_RFK_BLUETOOTH_SW_ID, m);
L
Linus Torvalds 已提交
4613 4614
}

4615
static int bluetooth_write(char *buf)
L
Linus Torvalds 已提交
4616
{
J
Johannes Berg 已提交
4617
	return tpacpi_rfk_procfs_write(TPACPI_RFK_BLUETOOTH_SW_ID, buf);
L
Linus Torvalds 已提交
4618 4619
}

4620 4621 4622 4623
static struct ibm_struct bluetooth_driver_data = {
	.name = "bluetooth",
	.read = bluetooth_read,
	.write = bluetooth_write,
4624
	.exit = bluetooth_exit,
4625
	.shutdown = bluetooth_shutdown,
4626 4627
};

4628 4629 4630 4631
/*************************************************************************
 * Wan subdriver
 */

4632 4633 4634 4635
enum {
	/* ACPI GWAN/SWAN bits */
	TP_ACPI_WANCARD_HWPRESENT	= 0x01,	/* Wan hw available */
	TP_ACPI_WANCARD_RADIOSSW	= 0x02,	/* Wan radio enabled */
4636
	TP_ACPI_WANCARD_RESUMECTRL	= 0x04,	/* Wan state at resume:
4637
						   0 = disable, 1 = enable */
4638 4639
};

4640 4641
#define TPACPI_RFK_WWAN_SW_NAME		"tpacpi_wwan_sw"

J
Johannes Berg 已提交
4642
static int wan_get_status(void)
4643 4644 4645
{
	int status;

4646 4647 4648
#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
	if (dbg_wwanemul)
		return (tpacpi_wwan_emulstate) ?
J
Johannes Berg 已提交
4649
		       TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
4650 4651
#endif

4652 4653 4654
	if (!acpi_evalf(hkey_handle, &status, "GWAN", "d"))
		return -EIO;

4655
	return ((status & TP_ACPI_WANCARD_RADIOSSW) != 0) ?
J
Johannes Berg 已提交
4656
			TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
4657 4658
}

J
Johannes Berg 已提交
4659
static int wan_set_status(enum tpacpi_rfkill_state state)
4660 4661 4662
{
	int status;

4663
	vdbg_printk(TPACPI_DBG_RFKILL,
J
Johannes Berg 已提交
4664 4665
		"will attempt to %s wwan\n",
		(state == TPACPI_RFK_RADIO_ON) ? "enable" : "disable");
4666

4667 4668
#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
	if (dbg_wwanemul) {
J
Johannes Berg 已提交
4669
		tpacpi_wwan_emulstate = (state == TPACPI_RFK_RADIO_ON);
4670 4671 4672 4673
		return 0;
	}
#endif

J
Johannes Berg 已提交
4674
	if (state == TPACPI_RFK_RADIO_ON)
4675 4676 4677 4678
		status = TP_ACPI_WANCARD_RADIOSSW
			 | TP_ACPI_WANCARD_RESUMECTRL;
	else
		status = 0;
J
Johannes Berg 已提交
4679

4680 4681 4682 4683 4684
	if (!acpi_evalf(hkey_handle, NULL, "SWAN", "vd", status))
		return -EIO;

	return 0;
}
4685

4686 4687 4688 4689 4690
/* sysfs wan enable ---------------------------------------------------- */
static ssize_t wan_enable_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
J
Johannes Berg 已提交
4691 4692
	return tpacpi_rfk_sysfs_enable_show(TPACPI_RFK_WWAN_SW_ID,
			attr, buf);
4693 4694 4695 4696 4697 4698
}

static ssize_t wan_enable_store(struct device *dev,
			    struct device_attribute *attr,
			    const char *buf, size_t count)
{
J
Johannes Berg 已提交
4699 4700
	return tpacpi_rfk_sysfs_enable_store(TPACPI_RFK_WWAN_SW_ID,
			attr, buf, count);
4701 4702
}

4703 4704
static DEVICE_ATTR(wwan_enable, S_IWUSR | S_IRUGO,
		   wan_enable_show, wan_enable_store);
4705 4706 4707 4708

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

static struct attribute *wan_attributes[] = {
4709
	&dev_attr_wwan_enable.attr,
4710 4711 4712 4713 4714 4715 4716
	NULL
};

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

J
Johannes Berg 已提交
4717 4718 4719 4720
static const struct tpacpi_rfk_ops wan_tprfk_ops = {
	.get_status = wan_get_status,
	.set_status = wan_set_status,
};
4721

4722 4723 4724 4725 4726
static void wan_shutdown(void)
{
	/* Order firmware to save current state to NVRAM */
	if (!acpi_evalf(NULL, NULL, "\\WGSV", "vd",
			TP_ACPI_WGSV_SAVE_STATE))
4727
		pr_notice("failed to save WWAN state to NVRAM\n");
4728 4729 4730
	else
		vdbg_printk(TPACPI_DBG_RFKILL,
			"WWAN state saved to NVRAM\n");
4731 4732
}

4733 4734 4735 4736
static void wan_exit(void)
{
	sysfs_remove_group(&tpacpi_pdev->dev.kobj,
		&wan_attr_group);
J
Johannes Berg 已提交
4737 4738 4739 4740

	tpacpi_destroy_rfkill(TPACPI_RFK_WWAN_SW_ID);

	wan_shutdown();
4741 4742
}

4743
static int __init wan_init(struct ibm_init_struct *iibm)
4744
{
4745
	int res;
4746 4747
	int status = 0;

4748 4749
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
			"initializing wan subdriver\n");
4750

4751
	TPACPI_ACPIHANDLE_INIT(hkey);
4752

4753
	tp_features.wan = hkey_handle &&
4754 4755
	    acpi_evalf(hkey_handle, &status, "GWAN", "qd");

4756 4757
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
		"wan is %s, status 0x%02x\n",
4758 4759 4760
		str_supported(tp_features.wan),
		status);

4761 4762 4763
#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
	if (dbg_wwanemul) {
		tp_features.wan = 1;
4764
		pr_info("wwan switch emulation enabled\n");
4765 4766
	} else
#endif
4767 4768 4769 4770
	if (tp_features.wan &&
	    !(status & TP_ACPI_WANCARD_HWPRESENT)) {
		/* no wan hardware present in system */
		tp_features.wan = 0;
4771
		dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
4772 4773 4774
			   "wan hardware not installed\n");
	}

4775 4776 4777 4778
	if (!tp_features.wan)
		return 1;

	res = tpacpi_new_rfkill(TPACPI_RFK_WWAN_SW_ID,
J
Johannes Berg 已提交
4779
				&wan_tprfk_ops,
4780
				RFKILL_TYPE_WWAN,
4781
				TPACPI_RFK_WWAN_SW_NAME,
J
Johannes Berg 已提交
4782 4783 4784 4785 4786 4787 4788
				true);
	if (res)
		return res;

	res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
				&wan_attr_group);

4789
	if (res) {
J
Johannes Berg 已提交
4790
		tpacpi_destroy_rfkill(TPACPI_RFK_WWAN_SW_ID);
4791
		return res;
4792
	}
4793

4794
	return 0;
4795 4796
}

4797
/* procfs -------------------------------------------------------------- */
4798
static int wan_read(struct seq_file *m)
4799
{
4800
	return tpacpi_rfk_procfs_read(TPACPI_RFK_WWAN_SW_ID, m);
4801 4802 4803 4804
}

static int wan_write(char *buf)
{
J
Johannes Berg 已提交
4805
	return tpacpi_rfk_procfs_write(TPACPI_RFK_WWAN_SW_ID, buf);
4806 4807
}

4808 4809 4810 4811
static struct ibm_struct wan_driver_data = {
	.name = "wan",
	.read = wan_read,
	.write = wan_write,
4812
	.exit = wan_exit,
4813
	.shutdown = wan_shutdown,
4814 4815
};

4816 4817 4818 4819 4820 4821 4822 4823 4824 4825
/*************************************************************************
 * UWB subdriver
 */

enum {
	/* ACPI GUWB/SUWB bits */
	TP_ACPI_UWB_HWPRESENT	= 0x01,	/* UWB hw available */
	TP_ACPI_UWB_RADIOSSW	= 0x02,	/* UWB radio enabled */
};

4826 4827
#define TPACPI_RFK_UWB_SW_NAME	"tpacpi_uwb_sw"

J
Johannes Berg 已提交
4828
static int uwb_get_status(void)
4829 4830 4831 4832 4833 4834
{
	int status;

#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
	if (dbg_uwbemul)
		return (tpacpi_uwb_emulstate) ?
J
Johannes Berg 已提交
4835
		       TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
4836 4837 4838 4839 4840 4841
#endif

	if (!acpi_evalf(hkey_handle, &status, "GUWB", "d"))
		return -EIO;

	return ((status & TP_ACPI_UWB_RADIOSSW) != 0) ?
J
Johannes Berg 已提交
4842
			TPACPI_RFK_RADIO_ON : TPACPI_RFK_RADIO_OFF;
4843 4844
}

J
Johannes Berg 已提交
4845
static int uwb_set_status(enum tpacpi_rfkill_state state)
4846 4847 4848
{
	int status;

4849
	vdbg_printk(TPACPI_DBG_RFKILL,
J
Johannes Berg 已提交
4850 4851
		"will attempt to %s UWB\n",
		(state == TPACPI_RFK_RADIO_ON) ? "enable" : "disable");
4852

4853 4854
#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
	if (dbg_uwbemul) {
J
Johannes Berg 已提交
4855
		tpacpi_uwb_emulstate = (state == TPACPI_RFK_RADIO_ON);
4856 4857 4858 4859
		return 0;
	}
#endif

J
Johannes Berg 已提交
4860 4861 4862 4863 4864
	if (state == TPACPI_RFK_RADIO_ON)
		status = TP_ACPI_UWB_RADIOSSW;
	else
		status = 0;

4865 4866 4867 4868 4869 4870 4871 4872
	if (!acpi_evalf(hkey_handle, NULL, "SUWB", "vd", status))
		return -EIO;

	return 0;
}

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

J
Johannes Berg 已提交
4873 4874 4875 4876
static const struct tpacpi_rfk_ops uwb_tprfk_ops = {
	.get_status = uwb_get_status,
	.set_status = uwb_set_status,
};
4877 4878 4879

static void uwb_exit(void)
{
J
Johannes Berg 已提交
4880
	tpacpi_destroy_rfkill(TPACPI_RFK_UWB_SW_ID);
4881 4882 4883 4884 4885 4886 4887
}

static int __init uwb_init(struct ibm_init_struct *iibm)
{
	int res;
	int status = 0;

4888 4889
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
			"initializing uwb subdriver\n");
4890 4891 4892 4893 4894 4895

	TPACPI_ACPIHANDLE_INIT(hkey);

	tp_features.uwb = hkey_handle &&
	    acpi_evalf(hkey_handle, &status, "GUWB", "qd");

4896 4897
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_RFKILL,
		"uwb is %s, status 0x%02x\n",
4898 4899 4900 4901 4902 4903
		str_supported(tp_features.uwb),
		status);

#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
	if (dbg_uwbemul) {
		tp_features.uwb = 1;
4904
		pr_info("uwb switch emulation enabled\n");
4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918
	} else
#endif
	if (tp_features.uwb &&
	    !(status & TP_ACPI_UWB_HWPRESENT)) {
		/* no uwb hardware present in system */
		tp_features.uwb = 0;
		dbg_printk(TPACPI_DBG_INIT,
			   "uwb hardware not installed\n");
	}

	if (!tp_features.uwb)
		return 1;

	res = tpacpi_new_rfkill(TPACPI_RFK_UWB_SW_ID,
J
Johannes Berg 已提交
4919
				&uwb_tprfk_ops,
4920
				RFKILL_TYPE_UWB,
4921
				TPACPI_RFK_UWB_SW_NAME,
J
Johannes Berg 已提交
4922
				false);
4923 4924 4925 4926 4927 4928 4929 4930 4931
	return res;
}

static struct ibm_struct uwb_driver_data = {
	.name = "uwb",
	.exit = uwb_exit,
	.flags.experimental = 1,
};

4932 4933 4934 4935
/*************************************************************************
 * Video subdriver
 */

4936 4937
#ifdef CONFIG_THINKPAD_ACPI_VIDEO

4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958
enum video_access_mode {
	TPACPI_VIDEO_NONE = 0,
	TPACPI_VIDEO_570,	/* 570 */
	TPACPI_VIDEO_770,	/* 600e/x, 770e, 770x */
	TPACPI_VIDEO_NEW,	/* all others */
};

enum {	/* video status flags, based on VIDEO_570 */
	TP_ACPI_VIDEO_S_LCD = 0x01,	/* LCD output enabled */
	TP_ACPI_VIDEO_S_CRT = 0x02,	/* CRT output enabled */
	TP_ACPI_VIDEO_S_DVI = 0x08,	/* DVI output enabled */
};

enum {  /* TPACPI_VIDEO_570 constants */
	TP_ACPI_VIDEO_570_PHSCMD = 0x87,	/* unknown magic constant :( */
	TP_ACPI_VIDEO_570_PHSMASK = 0x03,	/* PHS bits that map to
						 * video_status_flags */
	TP_ACPI_VIDEO_570_PHS2CMD = 0x8b,	/* unknown magic constant :( */
	TP_ACPI_VIDEO_570_PHS2SET = 0x80,	/* unknown magic constant :( */
};

4959 4960
static enum video_access_mode video_supported;
static int video_orig_autosw;
4961

4962 4963 4964
static int video_autosw_get(void);
static int video_autosw_set(int enable);

4965 4966 4967 4968 4969 4970 4971 4972 4973
TPACPI_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.VGA",	/* X100e and a few others */
	      "\\_SB.PCI0.AGP.VID",	/* all others */
	);				/* R30, R31 */

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

4976
static int __init video_init(struct ibm_init_struct *iibm)
L
Linus Torvalds 已提交
4977
{
4978 4979
	int ivga;

4980 4981
	vdbg_printk(TPACPI_DBG_INIT, "initializing video subdriver\n");

4982
	TPACPI_ACPIHANDLE_INIT(vid);
4983 4984
	if (tpacpi_is_ibm())
		TPACPI_ACPIHANDLE_INIT(vid2);
4985

4986 4987 4988 4989 4990 4991
	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 */
4992
		video_supported = TPACPI_VIDEO_NONE;
4993 4994
	else if (tpacpi_is_ibm() &&
		 acpi_evalf(vid_handle, &video_orig_autosw, "SWIT", "qd"))
4995
		/* 570 */
4996
		video_supported = TPACPI_VIDEO_570;
4997 4998
	else if (tpacpi_is_ibm() &&
		 acpi_evalf(vid_handle, &video_orig_autosw, "^VADL", "qd"))
4999
		/* 600e/x, 770e, 770x */
5000
		video_supported = TPACPI_VIDEO_770;
5001 5002
	else
		/* all others */
5003
		video_supported = TPACPI_VIDEO_NEW;
L
Linus Torvalds 已提交
5004

5005 5006 5007 5008
	vdbg_printk(TPACPI_DBG_INIT, "video is %s, mode %d\n",
		str_supported(video_supported != TPACPI_VIDEO_NONE),
		video_supported);

5009
	return (video_supported != TPACPI_VIDEO_NONE) ? 0 : 1;
L
Linus Torvalds 已提交
5010 5011
}

5012 5013
static void video_exit(void)
{
5014 5015 5016
	dbg_printk(TPACPI_DBG_EXIT,
		   "restoring original video autoswitch mode\n");
	if (video_autosw_set(video_orig_autosw))
5017
		pr_err("error while trying to restore original video autoswitch mode\n");
5018 5019
}

5020
static int video_outputsw_get(void)
L
Linus Torvalds 已提交
5021 5022 5023 5024
{
	int status = 0;
	int i;

5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060
	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;
5061 5062 5063 5064
	}

	return status;
}
L
Linus Torvalds 已提交
5065

5066
static int video_outputsw_set(int status)
5067
{
5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081
	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 已提交
5082

5083 5084 5085 5086 5087 5088
		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)) {
5089
			pr_err("video auto-switch left enabled due to error\n");
5090 5091 5092 5093 5094
			return -EIO;
		}
		break;
	case TPACPI_VIDEO_NEW:
		res = acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0x80) &&
5095
		      acpi_evalf(NULL, NULL, "\\VSDS", "vdd", status, 1);
5096 5097 5098 5099
		break;
	default:
		return -ENOSYS;
	}
L
Linus Torvalds 已提交
5100

5101
	return (res) ? 0 : -EIO;
L
Linus Torvalds 已提交
5102 5103
}

5104
static int video_autosw_get(void)
5105
{
5106
	int autosw = 0;
5107

5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120
	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;
	}
5121

5122
	return autosw & 1;
5123 5124
}

5125
static int video_autosw_set(int enable)
5126
{
5127
	if (!acpi_evalf(vid_handle, NULL, "_DOS", "vd", (enable) ? 1 : 0))
5128 5129
		return -EIO;
	return 0;
5130 5131
}

5132
static int video_outputsw_cycle(void)
5133
{
5134 5135
	int autosw = video_autosw_get();
	int res;
5136

5137 5138
	if (autosw < 0)
		return autosw;
5139

5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157
	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)) {
5158
		pr_err("video auto-switch left enabled due to error\n");
5159
		return -EIO;
5160 5161
	}

5162
	return (res) ? 0 : -EIO;
5163 5164 5165 5166 5167 5168
}

static int video_expand_toggle(void)
{
	switch (video_supported) {
	case TPACPI_VIDEO_570:
5169
		return acpi_evalf(ec_handle, NULL, "_Q17", "v") ?
5170 5171
			0 : -EIO;
	case TPACPI_VIDEO_770:
5172
		return acpi_evalf(vid_handle, NULL, "VEXP", "v") ?
5173 5174
			0 : -EIO;
	case TPACPI_VIDEO_NEW:
5175
		return acpi_evalf(NULL, NULL, "\\VEXP", "v") ?
5176 5177 5178 5179 5180
			0 : -EIO;
	default:
		return -ENOSYS;
	}
	/* not reached */
5181 5182
}

5183
static int video_read(struct seq_file *m)
5184
{
5185
	int status, autosw;
5186

5187
	if (video_supported == TPACPI_VIDEO_NONE) {
5188 5189
		seq_printf(m, "status:\t\tnot supported\n");
		return 0;
5190 5191
	}

5192 5193 5194 5195
	/* Even reads can crash X.org, so... */
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

5196 5197 5198 5199 5200 5201 5202 5203
	status = video_outputsw_get();
	if (status < 0)
		return status;

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

5204 5205 5206
	seq_printf(m, "status:\t\tsupported\n");
	seq_printf(m, "lcd:\t\t%s\n", enabled(status, 0));
	seq_printf(m, "crt:\t\t%s\n", enabled(status, 1));
5207
	if (video_supported == TPACPI_VIDEO_NEW)
5208 5209 5210 5211
		seq_printf(m, "dvi:\t\t%s\n", enabled(status, 3));
	seq_printf(m, "auto:\t\t%s\n", enabled(autosw, 0));
	seq_printf(m, "commands:\tlcd_enable, lcd_disable\n");
	seq_printf(m, "commands:\tcrt_enable, crt_disable\n");
5212
	if (video_supported == TPACPI_VIDEO_NEW)
5213 5214 5215
		seq_printf(m, "commands:\tdvi_enable, dvi_disable\n");
	seq_printf(m, "commands:\tauto_enable, auto_disable\n");
	seq_printf(m, "commands:\tvideo_switch, expand_toggle\n");
5216

5217
	return 0;
5218 5219
}

5220
static int video_write(char *buf)
L
Linus Torvalds 已提交
5221 5222 5223
{
	char *cmd;
	int enable, disable, status;
5224
	int res;
L
Linus Torvalds 已提交
5225

5226
	if (video_supported == TPACPI_VIDEO_NONE)
5227 5228
		return -ENODEV;

5229 5230 5231 5232
	/* Even reads can crash X.org, let alone writes... */
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

5233 5234
	enable = 0;
	disable = 0;
L
Linus Torvalds 已提交
5235

5236
	while ((cmd = strsep(&buf, ","))) {
L
Linus Torvalds 已提交
5237
		if (strlencmp(cmd, "lcd_enable") == 0) {
5238
			enable |= TP_ACPI_VIDEO_S_LCD;
L
Linus Torvalds 已提交
5239
		} else if (strlencmp(cmd, "lcd_disable") == 0) {
5240
			disable |= TP_ACPI_VIDEO_S_LCD;
L
Linus Torvalds 已提交
5241
		} else if (strlencmp(cmd, "crt_enable") == 0) {
5242
			enable |= TP_ACPI_VIDEO_S_CRT;
L
Linus Torvalds 已提交
5243
		} else if (strlencmp(cmd, "crt_disable") == 0) {
5244
			disable |= TP_ACPI_VIDEO_S_CRT;
5245
		} else if (video_supported == TPACPI_VIDEO_NEW &&
5246
			   strlencmp(cmd, "dvi_enable") == 0) {
5247
			enable |= TP_ACPI_VIDEO_S_DVI;
5248
		} else if (video_supported == TPACPI_VIDEO_NEW &&
5249
			   strlencmp(cmd, "dvi_disable") == 0) {
5250
			disable |= TP_ACPI_VIDEO_S_DVI;
L
Linus Torvalds 已提交
5251
		} else if (strlencmp(cmd, "auto_enable") == 0) {
5252 5253 5254
			res = video_autosw_set(1);
			if (res)
				return res;
L
Linus Torvalds 已提交
5255
		} else if (strlencmp(cmd, "auto_disable") == 0) {
5256 5257 5258
			res = video_autosw_set(0);
			if (res)
				return res;
L
Linus Torvalds 已提交
5259
		} else if (strlencmp(cmd, "video_switch") == 0) {
5260 5261 5262
			res = video_outputsw_cycle();
			if (res)
				return res;
L
Linus Torvalds 已提交
5263
		} else if (strlencmp(cmd, "expand_toggle") == 0) {
5264 5265 5266
			res = video_expand_toggle();
			if (res)
				return res;
L
Linus Torvalds 已提交
5267 5268 5269 5270 5271
		} else
			return -EINVAL;
	}

	if (enable || disable) {
5272 5273 5274 5275 5276 5277
		status = video_outputsw_get();
		if (status < 0)
			return status;
		res = video_outputsw_set((status & ~disable) | enable);
		if (res)
			return res;
L
Linus Torvalds 已提交
5278 5279 5280 5281 5282
	}

	return 0;
}

5283 5284 5285 5286 5287 5288 5289
static struct ibm_struct video_driver_data = {
	.name = "video",
	.read = video_read,
	.write = video_write,
	.exit = video_exit,
};

5290 5291
#endif /* CONFIG_THINKPAD_ACPI_VIDEO */

5292 5293 5294 5295
/*************************************************************************
 * Keyboard backlight subdriver
 */

5296 5297 5298
static enum led_brightness kbdlight_brightness;
static DEFINE_MUTEX(kbdlight_mutex);

5299 5300
static int kbdlight_set_level(int level)
{
5301 5302
	int ret = 0;

5303 5304 5305
	if (!hkey_handle)
		return -ENXIO;

5306 5307
	mutex_lock(&kbdlight_mutex);

5308
	if (!acpi_evalf(hkey_handle, NULL, "MLCS", "dd", level))
5309 5310 5311
		ret = -EIO;
	else
		kbdlight_brightness = level;
5312

5313 5314 5315
	mutex_unlock(&kbdlight_mutex);

	return ret;
5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378
}

static int kbdlight_get_level(void)
{
	int status = 0;

	if (!hkey_handle)
		return -ENXIO;

	if (!acpi_evalf(hkey_handle, &status, "MLCG", "dd", 0))
		return -EIO;

	if (status < 0)
		return status;

	return status & 0x3;
}

static bool kbdlight_is_supported(void)
{
	int status = 0;

	if (!hkey_handle)
		return false;

	if (!acpi_has_method(hkey_handle, "MLCG")) {
		vdbg_printk(TPACPI_DBG_INIT, "kbdlight MLCG is unavailable\n");
		return false;
	}

	if (!acpi_evalf(hkey_handle, &status, "MLCG", "qdd", 0)) {
		vdbg_printk(TPACPI_DBG_INIT, "kbdlight MLCG failed\n");
		return false;
	}

	if (status < 0) {
		vdbg_printk(TPACPI_DBG_INIT, "kbdlight MLCG err: %d\n", status);
		return false;
	}

	vdbg_printk(TPACPI_DBG_INIT, "kbdlight MLCG returned 0x%x\n", status);
	/*
	 * Guessed test for keyboard backlight:
	 *
	 * Machines with backlight keyboard return:
	 *   b010100000010000000XX - ThinkPad X1 Carbon 3rd
	 *   b110100010010000000XX - ThinkPad x230
	 *   b010100000010000000XX - ThinkPad x240
	 *   b010100000010000000XX - ThinkPad W541
	 * (XX is current backlight level)
	 *
	 * Machines without backlight keyboard return:
	 *   b10100001000000000000 - ThinkPad x230
	 *   b10110001000000000000 - ThinkPad E430
	 *   b00000000000000000000 - ThinkPad E450
	 *
	 * Candidate BITs for detection test (XOR):
	 *   b01000000001000000000
	 *              ^
	 */
	return status & BIT(9);
}

5379
static int kbdlight_sysfs_set(struct led_classdev *led_cdev,
5380 5381
			enum led_brightness brightness)
{
5382
	return kbdlight_set_level(brightness);
5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399
}

static enum led_brightness kbdlight_sysfs_get(struct led_classdev *led_cdev)
{
	int level;

	level = kbdlight_get_level();
	if (level < 0)
		return 0;

	return level;
}

static struct tpacpi_led_classdev tpacpi_led_kbdlight = {
	.led_classdev = {
		.name		= "tpacpi::kbd_backlight",
		.max_brightness	= 2,
5400
		.flags		= LED_BRIGHT_HW_CHANGED,
5401
		.brightness_set_blocking = &kbdlight_sysfs_set,
5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419
		.brightness_get	= &kbdlight_sysfs_get,
	}
};

static int __init kbdlight_init(struct ibm_init_struct *iibm)
{
	int rc;

	vdbg_printk(TPACPI_DBG_INIT, "initializing kbdlight subdriver\n");

	TPACPI_ACPIHANDLE_INIT(hkey);

	if (!kbdlight_is_supported()) {
		tp_features.kbdlight = 0;
		vdbg_printk(TPACPI_DBG_INIT, "kbdlight is unsupported\n");
		return 1;
	}

5420
	kbdlight_brightness = kbdlight_sysfs_get(NULL);
5421 5422 5423 5424 5425 5426 5427 5428 5429
	tp_features.kbdlight = 1;

	rc = led_classdev_register(&tpacpi_pdev->dev,
				   &tpacpi_led_kbdlight.led_classdev);
	if (rc < 0) {
		tp_features.kbdlight = 0;
		return rc;
	}

5430 5431
	tpacpi_hotkey_driver_mask_set(hotkey_driver_mask |
				      TP_ACPI_HKEY_KBD_LIGHT_MASK);
5432 5433 5434 5435 5436
	return 0;
}

static void kbdlight_exit(void)
{
5437
	led_classdev_unregister(&tpacpi_led_kbdlight.led_classdev);
5438 5439
}

5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453
static int kbdlight_set_level_and_update(int level)
{
	int ret;
	struct led_classdev *led_cdev;

	ret = kbdlight_set_level(level);
	led_cdev = &tpacpi_led_kbdlight.led_classdev;

	if (ret == 0 && !(led_cdev->flags & LED_SUSPENDED))
		led_cdev->brightness = level;

	return ret;
}

5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474
static int kbdlight_read(struct seq_file *m)
{
	int level;

	if (!tp_features.kbdlight) {
		seq_printf(m, "status:\t\tnot supported\n");
	} else {
		level = kbdlight_get_level();
		if (level < 0)
			seq_printf(m, "status:\t\terror %d\n", level);
		else
			seq_printf(m, "status:\t\t%d\n", level);
		seq_printf(m, "commands:\t0, 1, 2\n");
	}

	return 0;
}

static int kbdlight_write(char *buf)
{
	char *cmd;
5475
	int res, level = -EINVAL;
5476 5477 5478 5479

	if (!tp_features.kbdlight)
		return -ENODEV;

5480
	while ((cmd = strsep(&buf, ","))) {
5481 5482 5483
		res = kstrtoint(cmd, 10, &level);
		if (res < 0)
			return res;
5484 5485
	}

5486
	if (level >= 3 || level < 0)
5487 5488
		return -EINVAL;

5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509
	return kbdlight_set_level_and_update(level);
}

static void kbdlight_suspend(void)
{
	struct led_classdev *led_cdev;

	if (!tp_features.kbdlight)
		return;

	led_cdev = &tpacpi_led_kbdlight.led_classdev;
	led_update_brightness(led_cdev);
	led_classdev_suspend(led_cdev);
}

static void kbdlight_resume(void)
{
	if (!tp_features.kbdlight)
		return;

	led_classdev_resume(&tpacpi_led_kbdlight.led_classdev);
5510 5511 5512 5513 5514 5515
}

static struct ibm_struct kbdlight_driver_data = {
	.name = "kbdlight",
	.read = kbdlight_read,
	.write = kbdlight_write,
5516 5517
	.suspend = kbdlight_suspend,
	.resume = kbdlight_resume,
5518 5519 5520
	.exit = kbdlight_exit,
};

5521 5522 5523
/*************************************************************************
 * Light (thinklight) subdriver
 */
L
Linus Torvalds 已提交
5524

5525 5526
TPACPI_HANDLE(lght, root, "\\LGHT");	/* A21e, A2xm/p, T20-22, X20-21 */
TPACPI_HANDLE(ledb, ec, "LEDB");		/* G4x */
5527

5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547
static int light_get_status(void)
{
	int status = 0;

	if (tp_features.light_status) {
		if (!acpi_evalf(ec_handle, &status, "KBLT", "d"))
			return -EIO;
		return (!!status);
	}

	return -ENXIO;
}

static int light_set_status(int status)
{
	int rc;

	if (tp_features.light) {
		if (cmos_handle) {
			rc = acpi_evalf(cmos_handle, NULL, NULL, "vd",
5548
					(status) ?
5549 5550 5551 5552
						TP_CMOS_THINKLIGHT_ON :
						TP_CMOS_THINKLIGHT_OFF);
		} else {
			rc = acpi_evalf(lght_handle, NULL, NULL, "vd",
5553
					(status) ? 1 : 0);
5554
		}
5555
		return (rc) ? 0 : -EIO;
5556 5557 5558 5559 5560
	}

	return -ENXIO;
}

5561
static int light_sysfs_set(struct led_classdev *led_cdev,
5562 5563
			enum led_brightness brightness)
{
5564 5565
	return light_set_status((brightness != LED_OFF) ?
				TPACPI_LED_ON : TPACPI_LED_OFF);
5566 5567 5568 5569
}

static enum led_brightness light_sysfs_get(struct led_classdev *led_cdev)
{
5570
	return (light_get_status() == 1) ? LED_FULL : LED_OFF;
5571 5572 5573 5574 5575
}

static struct tpacpi_led_classdev tpacpi_led_thinklight = {
	.led_classdev = {
		.name		= "tpacpi::thinklight",
5576
		.brightness_set_blocking = &light_sysfs_set,
5577 5578 5579 5580
		.brightness_get	= &light_sysfs_get,
	}
};

5581
static int __init light_init(struct ibm_init_struct *iibm)
L
Linus Torvalds 已提交
5582
{
5583
	int rc;
5584

5585 5586
	vdbg_printk(TPACPI_DBG_INIT, "initializing light subdriver\n");

5587 5588 5589 5590
	if (tpacpi_is_ibm()) {
		TPACPI_ACPIHANDLE_INIT(ledb);
		TPACPI_ACPIHANDLE_INIT(lght);
	}
5591
	TPACPI_ACPIHANDLE_INIT(cmos);
5592

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

5596
	if (tp_features.light)
5597 5598
		/* light status not supported on
		   570, 600e/x, 770e, 770x, G4x, R30, R31, R32, X20 */
5599 5600
		tp_features.light_status =
			acpi_evalf(ec_handle, NULL, "KBLT", "qv");
L
Linus Torvalds 已提交
5601

5602 5603 5604
	vdbg_printk(TPACPI_DBG_INIT, "light is %s, light status is %s\n",
		str_supported(tp_features.light),
		str_supported(tp_features.light_status));
5605

5606 5607 5608 5609 5610
	if (!tp_features.light)
		return 1;

	rc = led_classdev_register(&tpacpi_pdev->dev,
				   &tpacpi_led_thinklight.led_classdev);
5611 5612 5613 5614

	if (rc < 0) {
		tp_features.light = 0;
		tp_features.light_status = 0;
5615 5616
	} else  {
		rc = 0;
5617
	}
5618

5619 5620 5621 5622 5623 5624
	return rc;
}

static void light_exit(void)
{
	led_classdev_unregister(&tpacpi_led_thinklight.led_classdev);
L
Linus Torvalds 已提交
5625 5626
}

5627
static int light_read(struct seq_file *m)
L
Linus Torvalds 已提交
5628
{
5629
	int status;
L
Linus Torvalds 已提交
5630

5631
	if (!tp_features.light) {
5632
		seq_printf(m, "status:\t\tnot supported\n");
5633
	} else if (!tp_features.light_status) {
5634 5635
		seq_printf(m, "status:\t\tunknown\n");
		seq_printf(m, "commands:\ton, off\n");
5636
	} else {
5637 5638 5639
		status = light_get_status();
		if (status < 0)
			return status;
5640 5641
		seq_printf(m, "status:\t\t%s\n", onoff(status, 0));
		seq_printf(m, "commands:\ton, off\n");
5642
	}
L
Linus Torvalds 已提交
5643

5644
	return 0;
L
Linus Torvalds 已提交
5645 5646
}

5647
static int light_write(char *buf)
L
Linus Torvalds 已提交
5648 5649
{
	char *cmd;
5650
	int newstatus = 0;
5651

5652
	if (!tp_features.light)
5653 5654
		return -ENODEV;

5655
	while ((cmd = strsep(&buf, ","))) {
L
Linus Torvalds 已提交
5656
		if (strlencmp(cmd, "on") == 0) {
5657
			newstatus = 1;
L
Linus Torvalds 已提交
5658
		} else if (strlencmp(cmd, "off") == 0) {
5659
			newstatus = 0;
L
Linus Torvalds 已提交
5660 5661 5662 5663
		} else
			return -EINVAL;
	}

5664
	return light_set_status(newstatus);
L
Linus Torvalds 已提交
5665 5666
}

5667 5668 5669 5670
static struct ibm_struct light_driver_data = {
	.name = "light",
	.read = light_read,
	.write = light_write,
5671
	.exit = light_exit,
5672 5673
};

5674 5675 5676 5677
/*************************************************************************
 * CMOS subdriver
 */

5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689
/* 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);
5690
	return (res) ? res : count;
5691 5692
}

5693
static DEVICE_ATTR_WO(cmos_command);
5694 5695 5696

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

5697
static int __init cmos_init(struct ibm_init_struct *iibm)
5698
{
5699 5700
	int res;

5701 5702 5703
	vdbg_printk(TPACPI_DBG_INIT,
		"initializing cmos commands subdriver\n");

5704
	TPACPI_ACPIHANDLE_INIT(cmos);
5705

5706 5707
	vdbg_printk(TPACPI_DBG_INIT, "cmos commands are %s\n",
		str_supported(cmos_handle != NULL));
5708 5709 5710 5711 5712

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

5713
	return (cmos_handle) ? 0 : 1;
5714 5715
}

5716 5717 5718 5719 5720
static void cmos_exit(void)
{
	device_remove_file(&tpacpi_pdev->dev, &dev_attr_cmos_command);
}

5721
static int cmos_read(struct seq_file *m)
L
Linus Torvalds 已提交
5722
{
5723 5724
	/* cmos not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
	   R30, R31, T20-22, X20-21 */
L
Linus Torvalds 已提交
5725
	if (!cmos_handle)
5726
		seq_printf(m, "status:\t\tnot supported\n");
L
Linus Torvalds 已提交
5727
	else {
5728 5729
		seq_printf(m, "status:\t\tsupported\n");
		seq_printf(m, "commands:\t<cmd> (<cmd> is 0-21)\n");
L
Linus Torvalds 已提交
5730 5731
	}

5732
	return 0;
L
Linus Torvalds 已提交
5733 5734
}

5735
static int cmos_write(char *buf)
L
Linus Torvalds 已提交
5736 5737
{
	char *cmd;
5738
	int cmos_cmd, res;
L
Linus Torvalds 已提交
5739

5740
	while ((cmd = strsep(&buf, ","))) {
5741 5742
		if (sscanf(cmd, "%u", &cmos_cmd) == 1 &&
		    cmos_cmd >= 0 && cmos_cmd <= 21) {
L
Linus Torvalds 已提交
5743 5744 5745 5746
			/* cmos_cmd set */
		} else
			return -EINVAL;

5747 5748 5749
		res = issue_thinkpad_cmos_command(cmos_cmd);
		if (res)
			return res;
L
Linus Torvalds 已提交
5750 5751 5752
	}

	return 0;
5753 5754
}

5755 5756 5757 5758
static struct ibm_struct cmos_driver_data = {
	.name = "cmos",
	.read = cmos_read,
	.write = cmos_write,
5759
	.exit = cmos_exit,
5760
};
5761 5762 5763 5764 5765

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

5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778
enum led_access_mode {
	TPACPI_LED_NONE = 0,
	TPACPI_LED_570,	/* 570 */
	TPACPI_LED_OLD,	/* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
	TPACPI_LED_NEW,	/* all others */
};

enum {	/* For TPACPI_LED_OLD */
	TPACPI_LED_EC_HLCL = 0x0c,	/* EC reg to get led to power on */
	TPACPI_LED_EC_HLBL = 0x0d,	/* EC reg to blink a lit led */
	TPACPI_LED_EC_HLMS = 0x0e,	/* EC reg to select led to command */
};

5779
static enum led_access_mode led_supported;
5780

5781
static acpi_handle led_handle;
5782

5783
#define TPACPI_LED_NUMLEDS 16
5784 5785
static struct tpacpi_led_classdev *tpacpi_leds;
static enum led_status_t tpacpi_led_state_cache[TPACPI_LED_NUMLEDS];
H
Harvey Harrison 已提交
5786
static const char * const tpacpi_led_names[TPACPI_LED_NUMLEDS] = {
5787 5788 5789 5790 5791 5792 5793 5794 5795
	/* there's a limit of 19 chars + NULL before 2.6.26 */
	"tpacpi::power",
	"tpacpi:orange:batt",
	"tpacpi:green:batt",
	"tpacpi::dock_active",
	"tpacpi::bay_active",
	"tpacpi::dock_batt",
	"tpacpi::unknown_led",
	"tpacpi::standby",
5796 5797 5798 5799 5800
	"tpacpi::dock_status1",
	"tpacpi::dock_status2",
	"tpacpi::unknown_led2",
	"tpacpi::unknown_led3",
	"tpacpi::thinkvantage",
5801
};
5802
#define TPACPI_SAFE_LEDS	0x1081U
5803 5804 5805 5806 5807 5808

static inline bool tpacpi_is_led_restricted(const unsigned int led)
{
#ifdef CONFIG_THINKPAD_ACPI_UNSAFE_LEDS
	return false;
#else
5809
	return (1U & (TPACPI_SAFE_LEDS >> led)) == 0;
5810 5811
#endif
}
5812

5813
static int led_get_status(const unsigned int led)
5814 5815
{
	int status;
5816
	enum led_status_t led_s;
5817 5818 5819 5820 5821 5822

	switch (led_supported) {
	case TPACPI_LED_570:
		if (!acpi_evalf(ec_handle,
				&status, "GLED", "dd", 1 << led))
			return -EIO;
5823
		led_s = (status == 0) ?
5824
				TPACPI_LED_OFF :
5825
				((status == 1) ?
5826 5827
					TPACPI_LED_ON :
					TPACPI_LED_BLINK);
5828 5829
		tpacpi_led_state_cache[led] = led_s;
		return led_s;
5830 5831 5832 5833 5834 5835 5836
	default:
		return -ENXIO;
	}

	/* not reached */
}

5837 5838
static int led_set_status(const unsigned int led,
			  const enum led_status_t ledstatus)
5839 5840
{
	/* off, on, blink. Index is led_status_t */
5841 5842
	static const unsigned int led_sled_arg1[] = { 0, 1, 3 };
	static const unsigned int led_led_arg1[] = { 0, 0x80, 0xc0 };
5843 5844 5845 5846 5847

	int rc = 0;

	switch (led_supported) {
	case TPACPI_LED_570:
5848
		/* 570 */
5849
		if (unlikely(led > 7))
5850
			return -EINVAL;
5851 5852
		if (unlikely(tpacpi_is_led_restricted(led)))
			return -EPERM;
5853 5854
		if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
				(1 << led), led_sled_arg1[ledstatus]))
5855
			return -EIO;
5856
		break;
5857
	case TPACPI_LED_OLD:
5858
		/* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20 */
5859
		if (unlikely(led > 7))
5860
			return -EINVAL;
5861 5862
		if (unlikely(tpacpi_is_led_restricted(led)))
			return -EPERM;
5863 5864 5865 5866 5867 5868 5869 5870
		rc = ec_write(TPACPI_LED_EC_HLMS, (1 << led));
		if (rc >= 0)
			rc = ec_write(TPACPI_LED_EC_HLBL,
				      (ledstatus == TPACPI_LED_BLINK) << led);
		if (rc >= 0)
			rc = ec_write(TPACPI_LED_EC_HLCL,
				      (ledstatus != TPACPI_LED_OFF) << led);
		break;
5871
	case TPACPI_LED_NEW:
5872
		/* all others */
5873 5874 5875 5876
		if (unlikely(led >= TPACPI_LED_NUMLEDS))
			return -EINVAL;
		if (unlikely(tpacpi_is_led_restricted(led)))
			return -EPERM;
5877 5878
		if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
				led, led_led_arg1[ledstatus]))
5879
			return -EIO;
5880
		break;
5881
	default:
5882
		return -ENXIO;
5883 5884
	}

5885 5886 5887 5888 5889 5890
	if (!rc)
		tpacpi_led_state_cache[led] = ledstatus;

	return rc;
}

5891
static int led_sysfs_set(struct led_classdev *led_cdev,
5892 5893 5894 5895
			enum led_brightness brightness)
{
	struct tpacpi_led_classdev *data = container_of(led_cdev,
			     struct tpacpi_led_classdev, led_classdev);
5896
	enum led_status_t new_state;
5897

5898
	if (brightness == LED_OFF)
5899
		new_state = TPACPI_LED_OFF;
5900
	else if (tpacpi_led_state_cache[data->led] != TPACPI_LED_BLINK)
5901
		new_state = TPACPI_LED_ON;
5902
	else
5903
		new_state = TPACPI_LED_BLINK;
5904

5905
	return led_set_status(data->led, new_state);
5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921
}

static int led_sysfs_blink_set(struct led_classdev *led_cdev,
			unsigned long *delay_on, unsigned long *delay_off)
{
	struct tpacpi_led_classdev *data = container_of(led_cdev,
			     struct tpacpi_led_classdev, led_classdev);

	/* Can we choose the flash rate? */
	if (*delay_on == 0 && *delay_off == 0) {
		/* yes. set them to the hardware blink rate (1 Hz) */
		*delay_on = 500; /* ms */
		*delay_off = 500; /* ms */
	} else if ((*delay_on != 500) || (*delay_off != 500))
		return -EINVAL;

5922
	return led_set_status(data->led, TPACPI_LED_BLINK);
5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938
}

static enum led_brightness led_sysfs_get(struct led_classdev *led_cdev)
{
	int rc;

	struct tpacpi_led_classdev *data = container_of(led_cdev,
			     struct tpacpi_led_classdev, led_classdev);

	rc = led_get_status(data->led);

	if (rc == TPACPI_LED_OFF || rc < 0)
		rc = LED_OFF;	/* no error handling in led class :( */
	else
		rc = LED_FULL;

5939 5940 5941
	return rc;
}

5942 5943 5944 5945
static void led_exit(void)
{
	unsigned int i;

5946 5947
	for (i = 0; i < TPACPI_LED_NUMLEDS; i++)
		led_classdev_unregister(&tpacpi_leds[i].led_classdev);
5948 5949 5950 5951

	kfree(tpacpi_leds);
}

5952 5953
static int __init tpacpi_init_led(unsigned int led)
{
5954 5955 5956 5957
	/* LEDs with no name don't get registered */
	if (!tpacpi_led_names[led])
		return 0;

5958
	tpacpi_leds[led].led_classdev.brightness_set_blocking = &led_sysfs_set;
5959 5960
	tpacpi_leds[led].led_classdev.blink_set = &led_sysfs_blink_set;
	if (led_supported == TPACPI_LED_570)
5961
		tpacpi_leds[led].led_classdev.brightness_get = &led_sysfs_get;
5962 5963

	tpacpi_leds[led].led_classdev.name = tpacpi_led_names[led];
5964
	tpacpi_leds[led].led = led;
5965

5966
	return led_classdev_register(&tpacpi_pdev->dev, &tpacpi_leds[led].led_classdev);
5967 5968
}

5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013
static const struct tpacpi_quirk led_useful_qtable[] __initconst = {
	TPACPI_Q_IBM('1', 'E', 0x009f), /* A30 */
	TPACPI_Q_IBM('1', 'N', 0x009f), /* A31 */
	TPACPI_Q_IBM('1', 'G', 0x009f), /* A31 */

	TPACPI_Q_IBM('1', 'I', 0x0097), /* T30 */
	TPACPI_Q_IBM('1', 'R', 0x0097), /* T40, T41, T42, R50, R51 */
	TPACPI_Q_IBM('7', '0', 0x0097), /* T43, R52 */
	TPACPI_Q_IBM('1', 'Y', 0x0097), /* T43 */
	TPACPI_Q_IBM('1', 'W', 0x0097), /* R50e */
	TPACPI_Q_IBM('1', 'V', 0x0097), /* R51 */
	TPACPI_Q_IBM('7', '8', 0x0097), /* R51e */
	TPACPI_Q_IBM('7', '6', 0x0097), /* R52 */

	TPACPI_Q_IBM('1', 'K', 0x00bf), /* X30 */
	TPACPI_Q_IBM('1', 'Q', 0x00bf), /* X31, X32 */
	TPACPI_Q_IBM('1', 'U', 0x00bf), /* X40 */
	TPACPI_Q_IBM('7', '4', 0x00bf), /* X41 */
	TPACPI_Q_IBM('7', '5', 0x00bf), /* X41t */

	TPACPI_Q_IBM('7', '9', 0x1f97), /* T60 (1) */
	TPACPI_Q_IBM('7', '7', 0x1f97), /* Z60* (1) */
	TPACPI_Q_IBM('7', 'F', 0x1f97), /* Z61* (1) */
	TPACPI_Q_IBM('7', 'B', 0x1fb7), /* X60 (1) */

	/* (1) - may have excess leds enabled on MSB */

	/* Defaults (order matters, keep last, don't reorder!) */
	{ /* Lenovo */
	  .vendor = PCI_VENDOR_ID_LENOVO,
	  .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY,
	  .quirks = 0x1fffU,
	},
	{ /* IBM ThinkPads with no EC version string */
	  .vendor = PCI_VENDOR_ID_IBM,
	  .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_UNKNOWN,
	  .quirks = 0x00ffU,
	},
	{ /* IBM ThinkPads with EC version string */
	  .vendor = PCI_VENDOR_ID_IBM,
	  .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY,
	  .quirks = 0x00bfU,
	},
};

6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039
static enum led_access_mode __init led_init_detect_mode(void)
{
	acpi_status status;

	if (tpacpi_is_ibm()) {
		/* 570 */
		status = acpi_get_handle(ec_handle, "SLED", &led_handle);
		if (ACPI_SUCCESS(status))
			return TPACPI_LED_570;

		/* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
		status = acpi_get_handle(ec_handle, "SYSL", &led_handle);
		if (ACPI_SUCCESS(status))
			return TPACPI_LED_OLD;
	}

	/* most others */
	status = acpi_get_handle(ec_handle, "LED", &led_handle);
	if (ACPI_SUCCESS(status))
		return TPACPI_LED_NEW;

	/* R30, R31, and unknown firmwares */
	led_handle = NULL;
	return TPACPI_LED_NONE;
}

6040
static int __init led_init(struct ibm_init_struct *iibm)
6041
{
6042 6043
	unsigned int i;
	int rc;
6044
	unsigned long useful_leds;
6045

6046 6047
	vdbg_printk(TPACPI_DBG_INIT, "initializing LED subdriver\n");

6048
	led_supported = led_init_detect_mode();
6049

6050 6051 6052 6053 6054 6055 6056 6057 6058 6059
	if (led_supported != TPACPI_LED_NONE) {
		useful_leds = tpacpi_check_quirks(led_useful_qtable,
				ARRAY_SIZE(led_useful_qtable));

		if (!useful_leds) {
			led_handle = NULL;
			led_supported = TPACPI_LED_NONE;
		}
	}

6060 6061 6062
	vdbg_printk(TPACPI_DBG_INIT, "LED commands are %s, mode %d\n",
		str_supported(led_supported), led_supported);

6063 6064 6065
	if (led_supported == TPACPI_LED_NONE)
		return 1;

K
Kees Cook 已提交
6066
	tpacpi_leds = kcalloc(TPACPI_LED_NUMLEDS, sizeof(*tpacpi_leds),
6067 6068
			      GFP_KERNEL);
	if (!tpacpi_leds) {
6069
		pr_err("Out of memory for LED data\n");
6070 6071 6072 6073
		return -ENOMEM;
	}

	for (i = 0; i < TPACPI_LED_NUMLEDS; i++) {
6074 6075
		tpacpi_leds[i].led = -1;

6076
		if (!tpacpi_is_led_restricted(i) && test_bit(i, &useful_leds)) {
6077 6078 6079 6080 6081
			rc = tpacpi_init_led(i);
			if (rc < 0) {
				led_exit();
				return rc;
			}
6082 6083 6084
		}
	}

6085
#ifdef CONFIG_THINKPAD_ACPI_UNSAFE_LEDS
6086
	pr_notice("warning: userspace override of important firmware LEDs is enabled\n");
6087
#endif
6088
	return 0;
6089 6090
}

6091 6092 6093
#define str_led_status(s) \
	((s) == TPACPI_LED_OFF ? "off" : \
		((s) == TPACPI_LED_ON ? "on" : "blinking"))
6094

6095
static int led_read(struct seq_file *m)
L
Linus Torvalds 已提交
6096
{
6097
	if (!led_supported) {
6098 6099
		seq_printf(m, "status:\t\tnot supported\n");
		return 0;
6100
	}
6101
	seq_printf(m, "status:\t\tsupported\n");
6102

6103
	if (led_supported == TPACPI_LED_570) {
6104 6105 6106
		/* 570 */
		int i, status;
		for (i = 0; i < 8; i++) {
6107 6108
			status = led_get_status(i);
			if (status < 0)
6109
				return -EIO;
6110
			seq_printf(m, "%d:\t\t%s\n",
6111
				       i, str_led_status(status));
6112 6113 6114
		}
	}

6115
	seq_printf(m, "commands:\t<led> on, <led> off, <led> blink (<led> is 0-15)\n");
L
Linus Torvalds 已提交
6116

6117
	return 0;
L
Linus Torvalds 已提交
6118 6119
}

6120
static int led_write(char *buf)
L
Linus Torvalds 已提交
6121 6122
{
	char *cmd;
6123 6124
	int led, rc;
	enum led_status_t s;
6125 6126 6127

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

6129
	while ((cmd = strsep(&buf, ","))) {
6130
		if (sscanf(cmd, "%d", &led) != 1)
L
Linus Torvalds 已提交
6131 6132
			return -EINVAL;

6133 6134 6135 6136
		if (led < 0 || led > (TPACPI_LED_NUMLEDS - 1))
			return -ENODEV;

		if (tpacpi_leds[led].led < 0)
6137 6138
			return -ENODEV;

6139
		if (strstr(cmd, "off")) {
6140
			s = TPACPI_LED_OFF;
L
Linus Torvalds 已提交
6141
		} else if (strstr(cmd, "on")) {
6142
			s = TPACPI_LED_ON;
6143
		} else if (strstr(cmd, "blink")) {
6144
			s = TPACPI_LED_BLINK;
6145
		} else {
6146
			return -EINVAL;
6147
		}
6148 6149 6150 6151

		rc = led_set_status(led, s);
		if (rc < 0)
			return rc;
6152 6153 6154 6155 6156
	}

	return 0;
}

6157 6158 6159 6160
static struct ibm_struct led_driver_data = {
	.name = "led",
	.read = led_read,
	.write = led_write,
6161
	.exit = led_exit,
6162 6163
};

6164 6165 6166 6167
/*************************************************************************
 * Beep subdriver
 */

6168
TPACPI_HANDLE(beep, ec, "BEEP");	/* all except R30, R31 */
6169

6170 6171 6172 6173 6174 6175 6176
#define TPACPI_BEEP_Q1 0x0001

static const struct tpacpi_quirk beep_quirk_table[] __initconst = {
	TPACPI_Q_IBM('I', 'M', TPACPI_BEEP_Q1), /* 570 */
	TPACPI_Q_IBM('I', 'U', TPACPI_BEEP_Q1), /* 570E - unverified */
};

6177
static int __init beep_init(struct ibm_init_struct *iibm)
6178
{
6179 6180
	unsigned long quirks;

6181 6182
	vdbg_printk(TPACPI_DBG_INIT, "initializing beep subdriver\n");

6183
	TPACPI_ACPIHANDLE_INIT(beep);
6184

6185 6186 6187
	vdbg_printk(TPACPI_DBG_INIT, "beep is %s\n",
		str_supported(beep_handle != NULL));

6188 6189 6190 6191 6192
	quirks = tpacpi_check_quirks(beep_quirk_table,
				     ARRAY_SIZE(beep_quirk_table));

	tp_features.beep_needs_two_args = !!(quirks & TPACPI_BEEP_Q1);

6193
	return (beep_handle) ? 0 : 1;
6194 6195
}

6196
static int beep_read(struct seq_file *m)
6197 6198
{
	if (!beep_handle)
6199
		seq_printf(m, "status:\t\tnot supported\n");
6200
	else {
6201 6202
		seq_printf(m, "status:\t\tsupported\n");
		seq_printf(m, "commands:\t<cmd> (<cmd> is 0-17)\n");
6203 6204
	}

6205
	return 0;
6206 6207 6208 6209 6210 6211 6212 6213 6214 6215
}

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

	if (!beep_handle)
		return -ENODEV;

6216
	while ((cmd = strsep(&buf, ","))) {
6217 6218 6219 6220 6221
		if (sscanf(cmd, "%u", &beep_cmd) == 1 &&
		    beep_cmd >= 0 && beep_cmd <= 17) {
			/* beep_cmd set */
		} else
			return -EINVAL;
6222 6223 6224 6225 6226 6227 6228 6229 6230
		if (tp_features.beep_needs_two_args) {
			if (!acpi_evalf(beep_handle, NULL, NULL, "vdd",
					beep_cmd, 0))
				return -EIO;
		} else {
			if (!acpi_evalf(beep_handle, NULL, NULL, "vd",
					beep_cmd))
				return -EIO;
		}
6231 6232 6233 6234 6235
	}

	return 0;
}

6236 6237 6238 6239 6240 6241
static struct ibm_struct beep_driver_data = {
	.name = "beep",
	.read = beep_read,
	.write = beep_write,
};

6242 6243 6244
/*************************************************************************
 * Thermal subdriver
 */
6245

6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257
enum thermal_access_mode {
	TPACPI_THERMAL_NONE = 0,	/* No thermal support */
	TPACPI_THERMAL_ACPI_TMP07,	/* Use ACPI TMP0-7 */
	TPACPI_THERMAL_ACPI_UPDT,	/* Use ACPI TMP0-7 with UPDT */
	TPACPI_THERMAL_TPEC_8,		/* Use ACPI EC regs, 8 sensors */
	TPACPI_THERMAL_TPEC_16,		/* Use ACPI EC regs, 16 sensors */
};

enum { /* TPACPI_THERMAL_TPEC_* */
	TP_EC_THERMAL_TMP0 = 0x78,	/* ACPI EC regs TMP 0..7 */
	TP_EC_THERMAL_TMP8 = 0xC0,	/* ACPI EC regs TMP 8..15 */
	TP_EC_THERMAL_TMP_NA = -128,	/* ACPI EC sensor not available */
6258 6259

	TPACPI_THERMAL_SENSOR_NA = -128000, /* Sensor not available */
6260 6261
};

6262

6263 6264 6265 6266 6267
#define TPACPI_MAX_THERMAL_SENSORS 16	/* Max thermal sensors supported */
struct ibm_thermal_sensors_struct {
	s32 temp[TPACPI_MAX_THERMAL_SENSORS];
};

6268
static enum thermal_access_mode thermal_read_mode;
6269

6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286
/* idx is zero-based */
static int thermal_get_sensor(int idx, s32 *value)
{
	int t;
	s8 tmp;
	char tmpi[5];

	t = TP_EC_THERMAL_TMP0;

	switch (thermal_read_mode) {
#if TPACPI_MAX_THERMAL_SENSORS >= 16
	case TPACPI_THERMAL_TPEC_16:
		if (idx >= 8 && idx <= 15) {
			t = TP_EC_THERMAL_TMP8;
			idx -= 8;
		}
#endif
6287
		fallthrough;
6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342
	case TPACPI_THERMAL_TPEC_8:
		if (idx <= 7) {
			if (!acpi_ec_read(t + idx, &tmp))
				return -EIO;
			*value = tmp * 1000;
			return 0;
		}
		break;

	case TPACPI_THERMAL_ACPI_UPDT:
		if (idx <= 7) {
			snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx);
			if (!acpi_evalf(ec_handle, NULL, "UPDT", "v"))
				return -EIO;
			if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
				return -EIO;
			*value = (t - 2732) * 100;
			return 0;
		}
		break;

	case TPACPI_THERMAL_ACPI_TMP07:
		if (idx <= 7) {
			snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx);
			if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
				return -EIO;
			if (t > 127 || t < -127)
				t = TP_EC_THERMAL_TMP_NA;
			*value = t * 1000;
			return 0;
		}
		break;

	case TPACPI_THERMAL_NONE:
	default:
		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;

6343
	for (i = 0 ; i < n; i++) {
6344 6345 6346 6347 6348 6349 6350
		res = thermal_get_sensor(i, &s->temp[i]);
		if (res)
			return res;
	}

	return n;
}
6351

6352 6353 6354 6355 6356 6357 6358 6359 6360
static void thermal_dump_all_sensors(void)
{
	int n, i;
	struct ibm_thermal_sensors_struct t;

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

6361
	pr_notice("temperatures (Celsius):");
6362 6363 6364

	for (i = 0; i < n; i++) {
		if (t.temp[i] != TPACPI_THERMAL_SENSOR_NA)
6365
			pr_cont(" %d", (int)(t.temp[i] / 1000));
6366
		else
6367
			pr_cont(" N/A");
6368 6369
	}

6370
	pr_cont("\n");
6371 6372
}

6373 6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384 6385 6386 6387
/* 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;
6388
	if (value == TPACPI_THERMAL_SENSOR_NA)
6389 6390 6391 6392 6393 6394
		return -ENXIO;

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

#define THERMAL_SENSOR_ATTR_TEMP(_idxA, _idxB) \
6395 6396
	 SENSOR_ATTR(temp##_idxA##_input, S_IRUGO, \
		     thermal_temp_input_show, NULL, _idxB)
6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451 6452

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

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

6453
static int __init thermal_init(struct ibm_init_struct *iibm)
6454
{
6455 6456
	u8 t, ta1, ta2;
	int i;
6457
	int acpi_tmp7;
6458
	int res;
6459

6460 6461
	vdbg_printk(TPACPI_DBG_INIT, "initializing thermal subdriver\n");

6462
	acpi_tmp7 = acpi_evalf(ec_handle, NULL, "TMP7", "qv");
6463

6464
	if (thinkpad_id.ec_model) {
6465 6466 6467 6468 6469 6470
		/*
		 * Direct EC access mode: sensors at registers
		 * 0x78-0x7F, 0xC0-0xC7.  Registers return 0x00 for
		 * non-implemented, thermal sensors return 0x80 when
		 * not available
		 */
6471

6472 6473
		ta1 = ta2 = 0;
		for (i = 0; i < 8; i++) {
6474
			if (acpi_ec_read(TP_EC_THERMAL_TMP0 + i, &t)) {
6475 6476 6477 6478 6479
				ta1 |= t;
			} else {
				ta1 = 0;
				break;
			}
6480
			if (acpi_ec_read(TP_EC_THERMAL_TMP8 + i, &t)) {
6481 6482 6483 6484 6485 6486 6487 6488 6489
				ta2 |= t;
			} else {
				ta1 = 0;
				break;
			}
		}
		if (ta1 == 0) {
			/* This is sheer paranoia, but we handle it anyway */
			if (acpi_tmp7) {
6490
				pr_err("ThinkPad ACPI EC access misbehaving, falling back to ACPI TMPx access mode\n");
6491
				thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
6492
			} else {
6493
				pr_err("ThinkPad ACPI EC access misbehaving, disabling thermal sensors access\n");
6494
				thermal_read_mode = TPACPI_THERMAL_NONE;
6495 6496 6497 6498
			}
		} else {
			thermal_read_mode =
			    (ta2 != 0) ?
6499
			    TPACPI_THERMAL_TPEC_16 : TPACPI_THERMAL_TPEC_8;
6500 6501
		}
	} else if (acpi_tmp7) {
6502 6503
		if (tpacpi_is_ibm() &&
		    acpi_evalf(ec_handle, NULL, "UPDT", "qv")) {
6504
			/* 600e/x, 770e, 770x */
6505
			thermal_read_mode = TPACPI_THERMAL_ACPI_UPDT;
6506
		} else {
6507
			/* IBM/LENOVO DSDT EC.TMPx access, max 8 sensors */
6508
			thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
6509 6510 6511
		}
	} else {
		/* temperatures not supported on 570, G4x, R30, R31, R32 */
6512
		thermal_read_mode = TPACPI_THERMAL_NONE;
6513
	}
6514

6515 6516 6517 6518
	vdbg_printk(TPACPI_DBG_INIT, "thermal is %s, mode %d\n",
		str_supported(thermal_read_mode != TPACPI_THERMAL_NONE),
		thermal_read_mode);

6519
	switch (thermal_read_mode) {
6520
	case TPACPI_THERMAL_TPEC_16:
6521
		res = sysfs_create_group(&tpacpi_hwmon->kobj,
6522 6523 6524 6525 6526 6527 6528
				&thermal_temp_input16_group);
		if (res)
			return res;
		break;
	case TPACPI_THERMAL_TPEC_8:
	case TPACPI_THERMAL_ACPI_TMP07:
	case TPACPI_THERMAL_ACPI_UPDT:
6529
		res = sysfs_create_group(&tpacpi_hwmon->kobj,
6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543
				&thermal_temp_input8_group);
		if (res)
			return res;
		break;
	case TPACPI_THERMAL_NONE:
	default:
		return 1;
	}

	return 0;
}

static void thermal_exit(void)
{
6544
	switch (thermal_read_mode) {
6545
	case TPACPI_THERMAL_TPEC_16:
6546
		sysfs_remove_group(&tpacpi_hwmon->kobj,
6547 6548 6549 6550 6551
				   &thermal_temp_input16_group);
		break;
	case TPACPI_THERMAL_TPEC_8:
	case TPACPI_THERMAL_ACPI_TMP07:
	case TPACPI_THERMAL_ACPI_UPDT:
6552
		sysfs_remove_group(&tpacpi_hwmon->kobj,
6553
				   &thermal_temp_input8_group);
6554 6555 6556 6557 6558
		break;
	case TPACPI_THERMAL_NONE:
	default:
		break;
	}
6559 6560
}

6561
static int thermal_read(struct seq_file *m)
6562 6563 6564 6565 6566 6567 6568 6569
{
	int n, i;
	struct ibm_thermal_sensors_struct t;

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

6570
	seq_printf(m, "temperatures:\t");
6571 6572 6573

	if (n > 0) {
		for (i = 0; i < (n - 1); i++)
6574 6575
			seq_printf(m, "%d ", t.temp[i] / 1000);
		seq_printf(m, "%d\n", t.temp[i] / 1000);
6576
	} else
6577
		seq_printf(m, "not supported\n");
6578

6579
	return 0;
6580 6581
}

6582 6583 6584
static struct ibm_struct thermal_driver_data = {
	.name = "thermal",
	.read = thermal_read,
6585
	.exit = thermal_exit,
6586 6587
};

6588 6589 6590 6591
/*************************************************************************
 * Backlight/brightness subdriver
 */

6592 6593
#define TPACPI_BACKLIGHT_DEV_NAME "thinkpad_screen"

6594 6595 6596 6597 6598 6599 6600 6601 6602 6603 6604 6605
/*
 * ThinkPads can read brightness from two places: EC HBRV (0x31), or
 * CMOS NVRAM byte 0x5E, bits 0-3.
 *
 * EC HBRV (0x31) has the following layout
 *   Bit 7: unknown function
 *   Bit 6: unknown function
 *   Bit 5: Z: honour scale changes, NZ: ignore scale changes
 *   Bit 4: must be set to zero to avoid problems
 *   Bit 3-0: backlight brightness level
 *
 * brightness_get_raw returns status data in the HBRV layout
6606 6607 6608 6609
 *
 * WARNING: The X61 has been verified to use HBRV for something else, so
 * this should be used _only_ on IBM ThinkPads, and maybe with some careful
 * testing on the very early *60 Lenovo models...
6610 6611
 */

6612 6613 6614 6615 6616 6617 6618 6619 6620
enum {
	TP_EC_BACKLIGHT = 0x31,

	/* TP_EC_BACKLIGHT bitmasks */
	TP_EC_BACKLIGHT_LVLMSK = 0x1F,
	TP_EC_BACKLIGHT_CMDMSK = 0xE0,
	TP_EC_BACKLIGHT_MAPSW = 0x20,
};

6621 6622 6623 6624 6625 6626 6627 6628
enum tpacpi_brightness_access_mode {
	TPACPI_BRGHT_MODE_AUTO = 0,	/* Not implemented yet */
	TPACPI_BRGHT_MODE_EC,		/* EC control */
	TPACPI_BRGHT_MODE_UCMS_STEP,	/* UCMS step-based control */
	TPACPI_BRGHT_MODE_ECNVRAM,	/* EC control w/ NVRAM store */
	TPACPI_BRGHT_MODE_MAX
};

6629
static struct backlight_device *ibm_backlight_device;
6630 6631 6632 6633

static enum tpacpi_brightness_access_mode brightness_mode =
		TPACPI_BRGHT_MODE_MAX;

6634 6635
static unsigned int brightness_enable = 2; /* 2 = auto, 0 = no, 1 = yes */

6636
static struct mutex brightness_mutex;
6637

6638 6639 6640
/* NVRAM brightness access,
 * call with brightness_mutex held! */
static unsigned int tpacpi_brightness_nvram_get(void)
6641
{
6642
	u8 lnvram;
6643

6644 6645 6646
	lnvram = (nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS)
		  & TP_NVRAM_MASK_LEVEL_BRIGHTNESS)
		  >> TP_NVRAM_POS_LEVEL_BRIGHTNESS;
6647
	lnvram &= bright_maxlvl;
6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702

	return lnvram;
}

static void tpacpi_brightness_checkpoint_nvram(void)
{
	u8 lec = 0;
	u8 b_nvram;

	if (brightness_mode != TPACPI_BRGHT_MODE_ECNVRAM)
		return;

	vdbg_printk(TPACPI_DBG_BRGHT,
		"trying to checkpoint backlight level to NVRAM...\n");

	if (mutex_lock_killable(&brightness_mutex) < 0)
		return;

	if (unlikely(!acpi_ec_read(TP_EC_BACKLIGHT, &lec)))
		goto unlock;
	lec &= TP_EC_BACKLIGHT_LVLMSK;
	b_nvram = nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS);

	if (lec != ((b_nvram & TP_NVRAM_MASK_LEVEL_BRIGHTNESS)
			     >> TP_NVRAM_POS_LEVEL_BRIGHTNESS)) {
		/* NVRAM needs update */
		b_nvram &= ~(TP_NVRAM_MASK_LEVEL_BRIGHTNESS <<
				TP_NVRAM_POS_LEVEL_BRIGHTNESS);
		b_nvram |= lec;
		nvram_write_byte(b_nvram, TP_NVRAM_ADDR_BRIGHTNESS);
		dbg_printk(TPACPI_DBG_BRGHT,
			   "updated NVRAM backlight level to %u (0x%02x)\n",
			   (unsigned int) lec, (unsigned int) b_nvram);
	} else
		vdbg_printk(TPACPI_DBG_BRGHT,
			   "NVRAM backlight level already is %u (0x%02x)\n",
			   (unsigned int) lec, (unsigned int) b_nvram);

unlock:
	mutex_unlock(&brightness_mutex);
}


/* call with brightness_mutex held! */
static int tpacpi_brightness_get_raw(int *status)
{
	u8 lec = 0;

	switch (brightness_mode) {
	case TPACPI_BRGHT_MODE_UCMS_STEP:
		*status = tpacpi_brightness_nvram_get();
		return 0;
	case TPACPI_BRGHT_MODE_EC:
	case TPACPI_BRGHT_MODE_ECNVRAM:
		if (unlikely(!acpi_ec_read(TP_EC_BACKLIGHT, &lec)))
6703
			return -EIO;
6704 6705 6706 6707
		*status = lec;
		return 0;
	default:
		return -ENXIO;
6708
	}
6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745 6746
}

/* call with brightness_mutex held! */
/* do NOT call with illegal backlight level value */
static int tpacpi_brightness_set_ec(unsigned int value)
{
	u8 lec = 0;

	if (unlikely(!acpi_ec_read(TP_EC_BACKLIGHT, &lec)))
		return -EIO;

	if (unlikely(!acpi_ec_write(TP_EC_BACKLIGHT,
				(lec & TP_EC_BACKLIGHT_CMDMSK) |
				(value & TP_EC_BACKLIGHT_LVLMSK))))
		return -EIO;

	return 0;
}

/* call with brightness_mutex held! */
static int tpacpi_brightness_set_ucmsstep(unsigned int value)
{
	int cmos_cmd, inc;
	unsigned int current_value, i;

	current_value = tpacpi_brightness_nvram_get();

	if (value == current_value)
		return 0;

	cmos_cmd = (value > current_value) ?
			TP_CMOS_BRIGHTNESS_UP :
			TP_CMOS_BRIGHTNESS_DOWN;
	inc = (value > current_value) ? 1 : -1;

	for (i = current_value; i != value; i += inc)
		if (issue_thinkpad_cmos_command(cmos_cmd))
			return -EIO;
6747

6748
	return 0;
6749 6750 6751
}

/* May return EINTR which can always be mapped to ERESTARTSYS */
6752
static int brightness_set(unsigned int value)
6753
{
6754
	int res;
6755

6756
	if (value > bright_maxlvl)
6757 6758
		return -EINVAL;

6759 6760 6761
	vdbg_printk(TPACPI_DBG_BRGHT,
			"set backlight level to %d\n", value);

6762
	res = mutex_lock_killable(&brightness_mutex);
6763 6764 6765
	if (res < 0)
		return res;

6766 6767 6768 6769 6770 6771 6772 6773 6774 6775
	switch (brightness_mode) {
	case TPACPI_BRGHT_MODE_EC:
	case TPACPI_BRGHT_MODE_ECNVRAM:
		res = tpacpi_brightness_set_ec(value);
		break;
	case TPACPI_BRGHT_MODE_UCMS_STEP:
		res = tpacpi_brightness_set_ucmsstep(value);
		break;
	default:
		res = -ENXIO;
6776 6777 6778 6779 6780 6781 6782 6783 6784 6785
	}

	mutex_unlock(&brightness_mutex);
	return res;
}

/* sysfs backlight class ----------------------------------------------- */

static int brightness_update_status(struct backlight_device *bd)
{
6786
	unsigned int level =
6787 6788
		(bd->props.fb_blank == FB_BLANK_UNBLANK &&
		 bd->props.power == FB_BLANK_UNBLANK) ?
6789 6790 6791 6792 6793 6794 6795 6796 6797
				bd->props.brightness : 0;

	dbg_printk(TPACPI_DBG_BRGHT,
			"backlight: attempt to set level to %d\n",
			level);

	/* it is the backlight class's job (caller) to handle
	 * EINTR and other errors properly */
	return brightness_set(level);
6798 6799
}

6800
static int brightness_get(struct backlight_device *bd)
6801
{
6802
	int status, res;
6803

6804
	res = mutex_lock_killable(&brightness_mutex);
6805
	if (res < 0)
6806 6807 6808 6809 6810 6811 6812 6813
		return 0;

	res = tpacpi_brightness_get_raw(&status);

	mutex_unlock(&brightness_mutex);

	if (res < 0)
		return 0;
6814

6815
	return status & TP_EC_BACKLIGHT_LVLMSK;
6816 6817
}

6818 6819 6820 6821 6822 6823
static void tpacpi_brightness_notify_change(void)
{
	backlight_force_update(ibm_backlight_device,
			       BACKLIGHT_UPDATE_HOTKEY);
}

L
Lionel Debroux 已提交
6824
static const struct backlight_ops ibm_backlight_data = {
6825 6826
	.get_brightness = brightness_get,
	.update_status  = brightness_update_status,
6827
};
6828

6829
/* --------------------------------------------------------------------- */
6830

6831 6832 6833 6834 6835
/*
 * Call _BCL method of video device.  On some ThinkPads this will
 * switch the firmware to the ACPI brightness control mode.
 */

6836 6837 6838 6839
static int __init tpacpi_query_bcl_levels(acpi_handle handle)
{
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *obj;
6840
	struct acpi_device *device, *child;
6841 6842
	int rc;

6843 6844 6845 6846 6847 6848 6849
	if (acpi_bus_get_device(handle, &device))
		return 0;

	rc = 0;
	list_for_each_entry(child, &device->children, node) {
		acpi_status status = acpi_evaluate_object(child->handle, "_BCL",
							  NULL, &buffer);
6850 6851
		if (ACPI_FAILURE(status)) {
			buffer.length = ACPI_ALLOCATE_BUFFER;
6852
			continue;
6853
		}
6854

6855 6856
		obj = (union acpi_object *)buffer.pointer;
		if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
6857
			pr_err("Unknown _BCL data, please report this to %s\n",
6858
				TPACPI_MAIL);
6859 6860 6861 6862
			rc = 0;
		} else {
			rc = obj->package.count;
		}
6863
		break;
6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875
	}

	kfree(buffer.pointer);
	return rc;
}


/*
 * Returns 0 (no ACPI _BCL or _BCL invalid), or size of brightness map
 */
static unsigned int __init tpacpi_check_std_acpi_brightness_support(void)
{
6876
	acpi_handle video_device;
6877 6878
	int bcl_levels = 0;

6879
	tpacpi_acpi_handle_locate("video", NULL, &video_device);
6880 6881
	if (video_device)
		bcl_levels = tpacpi_query_bcl_levels(video_device);
6882

6883
	tp_features.bright_acpimode = (bcl_levels > 0);
6884

6885
	return (bcl_levels > 2) ? (bcl_levels - 2) : 0;
6886 6887
}

6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900
/*
 * These are only useful for models that have only one possibility
 * of GPU.  If the BIOS model handles both ATI and Intel, don't use
 * these quirks.
 */
#define TPACPI_BRGHT_Q_NOEC	0x0001	/* Must NOT use EC HBRV */
#define TPACPI_BRGHT_Q_EC	0x0002  /* Should or must use EC HBRV */
#define TPACPI_BRGHT_Q_ASK	0x8000	/* Ask for user report */

static const struct tpacpi_quirk brightness_quirk_table[] __initconst = {
	/* Models with ATI GPUs known to require ECNVRAM mode */
	TPACPI_Q_IBM('1', 'Y', TPACPI_BRGHT_Q_EC),	/* T43/p ATI */

6901
	/* Models with ATI GPUs that can use ECNVRAM */
6902
	TPACPI_Q_IBM('1', 'R', TPACPI_BRGHT_Q_EC),	/* R50,51 T40-42 */
6903
	TPACPI_Q_IBM('1', 'Q', TPACPI_BRGHT_Q_ASK|TPACPI_BRGHT_Q_EC),
6904
	TPACPI_Q_IBM('7', '6', TPACPI_BRGHT_Q_EC),	/* R52 */
6905 6906
	TPACPI_Q_IBM('7', '8', TPACPI_BRGHT_Q_ASK|TPACPI_BRGHT_Q_EC),

6907
	/* Models with Intel Extreme Graphics 2 */
6908
	TPACPI_Q_IBM('1', 'U', TPACPI_BRGHT_Q_NOEC),	/* X40 */
6909 6910
	TPACPI_Q_IBM('1', 'V', TPACPI_BRGHT_Q_ASK|TPACPI_BRGHT_Q_EC),
	TPACPI_Q_IBM('1', 'W', TPACPI_BRGHT_Q_ASK|TPACPI_BRGHT_Q_EC),
6911 6912 6913 6914 6915 6916 6917

	/* Models with Intel GMA900 */
	TPACPI_Q_IBM('7', '0', TPACPI_BRGHT_Q_NOEC),	/* T43, R52 */
	TPACPI_Q_IBM('7', '4', TPACPI_BRGHT_Q_NOEC),	/* X41 */
	TPACPI_Q_IBM('7', '5', TPACPI_BRGHT_Q_NOEC),	/* X41 Tablet */
};

6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949
/*
 * Returns < 0 for error, otherwise sets tp_features.bright_*
 * and bright_maxlvl.
 */
static void __init tpacpi_detect_brightness_capabilities(void)
{
	unsigned int b;

	vdbg_printk(TPACPI_DBG_INIT,
		    "detecting firmware brightness interface capabilities\n");

	/* we could run a quirks check here (same table used by
	 * brightness_init) if needed */

	/*
	 * We always attempt to detect acpi support, so as to switch
	 * Lenovo Vista BIOS to ACPI brightness mode even if we are not
	 * going to publish a backlight interface
	 */
	b = tpacpi_check_std_acpi_brightness_support();
	switch (b) {
	case 16:
		bright_maxlvl = 15;
		break;
	case 8:
	case 0:
		bright_maxlvl = 7;
		break;
	default:
		tp_features.bright_unkfw = 1;
		bright_maxlvl = b - 1;
	}
6950
	pr_debug("detected %u brightness levels\n", bright_maxlvl + 1);
6951 6952
}

6953
static int __init brightness_init(struct ibm_init_struct *iibm)
6954
{
6955
	struct backlight_properties props;
6956
	int b;
6957
	unsigned long quirks;
6958

6959 6960
	vdbg_printk(TPACPI_DBG_INIT, "initializing brightness subdriver\n");

6961 6962
	mutex_init(&brightness_mutex);

6963 6964 6965
	quirks = tpacpi_check_quirks(brightness_quirk_table,
				ARRAY_SIZE(brightness_quirk_table));

6966 6967 6968 6969 6970
	/* tpacpi_detect_brightness_capabilities() must have run already */

	/* if it is unknown, we don't handle it: it wouldn't be safe */
	if (tp_features.bright_unkfw)
		return 1;
6971

6972
	if (!brightness_enable) {
6973
		dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_BRGHT,
6974
			   "brightness support disabled by module parameter\n");
6975 6976 6977
		return 1;
	}

6978
	if (acpi_video_get_backlight_type() != acpi_backlight_vendor) {
6979
		if (brightness_enable > 1) {
6980
			pr_info("Standard ACPI backlight interface available, not loading native one\n");
6981 6982
			return 1;
		} else if (brightness_enable == 1) {
6983
			pr_warn("Cannot enable backlight brightness support, ACPI is already handling it.  Refer to the acpi_backlight kernel parameter.\n");
6984 6985
			return 1;
		}
6986 6987 6988
	} else if (!tp_features.bright_acpimode) {
		pr_notice("ACPI backlight interface not available\n");
		return 1;
6989 6990
	}

6991 6992
	pr_notice("ACPI native brightness control enabled\n");

6993 6994 6995 6996 6997 6998 6999
	/*
	 * Check for module parameter bogosity, note that we
	 * init brightness_mode to TPACPI_BRGHT_MODE_MAX in order to be
	 * able to detect "unspecified"
	 */
	if (brightness_mode > TPACPI_BRGHT_MODE_MAX)
		return -EINVAL;
7000

7001 7002 7003
	/* TPACPI_BRGHT_MODE_AUTO not implemented yet, just use default */
	if (brightness_mode == TPACPI_BRGHT_MODE_AUTO ||
	    brightness_mode == TPACPI_BRGHT_MODE_MAX) {
7004 7005 7006
		if (quirks & TPACPI_BRGHT_Q_EC)
			brightness_mode = TPACPI_BRGHT_MODE_ECNVRAM;
		else
7007
			brightness_mode = TPACPI_BRGHT_MODE_UCMS_STEP;
7008

7009
		dbg_printk(TPACPI_DBG_BRGHT,
7010
			   "driver auto-selected brightness_mode=%d\n",
7011 7012
			   brightness_mode);
	}
7013

7014
	/* Safety */
7015
	if (!tpacpi_is_ibm() &&
7016 7017 7018 7019
	    (brightness_mode == TPACPI_BRGHT_MODE_ECNVRAM ||
	     brightness_mode == TPACPI_BRGHT_MODE_EC))
		return -EINVAL;

7020
	if (tpacpi_brightness_get_raw(&b) < 0)
7021
		return 1;
7022

7023
	memset(&props, 0, sizeof(struct backlight_properties));
M
Matthew Garrett 已提交
7024
	props.type = BACKLIGHT_PLATFORM;
7025 7026
	props.max_brightness = bright_maxlvl;
	props.brightness = b & TP_EC_BACKLIGHT_LVLMSK;
7027 7028 7029 7030
	ibm_backlight_device = backlight_device_register(TPACPI_BACKLIGHT_DEV_NAME,
							 NULL, NULL,
							 &ibm_backlight_data,
							 &props);
7031
	if (IS_ERR(ibm_backlight_device)) {
7032 7033
		int rc = PTR_ERR(ibm_backlight_device);
		ibm_backlight_device = NULL;
7034
		pr_err("Could not register backlight device\n");
7035
		return rc;
7036
	}
7037 7038
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_BRGHT,
			"brightness is supported\n");
7039

7040
	if (quirks & TPACPI_BRGHT_Q_ASK) {
7041 7042 7043 7044
		pr_notice("brightness: will use unverified default: brightness_mode=%d\n",
			  brightness_mode);
		pr_notice("brightness: please report to %s whether it works well or not on your ThinkPad\n",
			  TPACPI_MAIL);
7045 7046
	}

7047 7048 7049 7050
	/* Added by mistake in early 2007.  Probably useless, but it could
	 * be working around some unknown firmware problem where the value
	 * read at startup doesn't match the real hardware state... so leave
	 * it in place just in case */
7051 7052
	backlight_update_status(ibm_backlight_device);

7053
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_BRGHT,
7054
		    "brightness: registering brightness hotkeys as change notification\n");
7055 7056
	tpacpi_hotkey_driver_mask_set(hotkey_driver_mask
				| TP_ACPI_HKEY_BRGHTUP_MASK
7057
				| TP_ACPI_HKEY_BRGHTDWN_MASK);
7058 7059 7060
	return 0;
}

7061
static void brightness_suspend(void)
7062 7063 7064 7065 7066 7067 7068 7069 7070
{
	tpacpi_brightness_checkpoint_nvram();
}

static void brightness_shutdown(void)
{
	tpacpi_brightness_checkpoint_nvram();
}

7071 7072 7073
static void brightness_exit(void)
{
	if (ibm_backlight_device) {
7074
		vdbg_printk(TPACPI_DBG_EXIT | TPACPI_DBG_BRGHT,
7075
			    "calling backlight_device_unregister()\n");
7076 7077
		backlight_device_unregister(ibm_backlight_device);
	}
7078 7079

	tpacpi_brightness_checkpoint_nvram();
7080 7081
}

7082
static int brightness_read(struct seq_file *m)
7083 7084 7085
{
	int level;

7086 7087
	level = brightness_get(NULL);
	if (level < 0) {
7088
		seq_printf(m, "level:\t\tunreadable\n");
7089
	} else {
7090 7091
		seq_printf(m, "level:\t\t%d\n", level);
		seq_printf(m, "commands:\tup, down\n");
7092 7093
		seq_printf(m, "commands:\tlevel <level> (<level> is 0-%d)\n",
			       bright_maxlvl);
7094 7095
	}

7096
	return 0;
7097 7098
}

7099 7100 7101
static int brightness_write(char *buf)
{
	int level;
7102
	int rc;
L
Linus Torvalds 已提交
7103 7104
	char *cmd;

7105 7106 7107
	level = brightness_get(NULL);
	if (level < 0)
		return level;
7108

7109
	while ((cmd = strsep(&buf, ","))) {
7110
		if (strlencmp(cmd, "up") == 0) {
7111
			if (level < bright_maxlvl)
7112
				level++;
7113
		} else if (strlencmp(cmd, "down") == 0) {
7114 7115 7116
			if (level > 0)
				level--;
		} else if (sscanf(cmd, "level %d", &level) == 1 &&
7117
			   level >= 0 && level <= bright_maxlvl) {
7118
			/* new level set */
7119 7120 7121 7122
		} else
			return -EINVAL;
	}

7123 7124 7125
	tpacpi_disclose_usertask("procfs brightness",
			"set level to %d\n", level);

7126 7127 7128 7129 7130
	/*
	 * Now we know what the final level should be, so we try to set it.
	 * Doing it this way makes the syscall restartable in case of EINTR
	 */
	rc = brightness_set(level);
7131 7132 7133
	if (!rc && ibm_backlight_device)
		backlight_force_update(ibm_backlight_device,
					BACKLIGHT_UPDATE_SYSFS);
7134
	return (rc == -EINTR) ? -ERESTARTSYS : rc;
7135 7136
}

7137 7138 7139 7140 7141
static struct ibm_struct brightness_driver_data = {
	.name = "brightness",
	.read = brightness_read,
	.write = brightness_write,
	.exit = brightness_exit,
7142 7143
	.suspend = brightness_suspend,
	.shutdown = brightness_shutdown,
7144 7145
};

7146 7147 7148
/*************************************************************************
 * Volume subdriver
 */
7149

7150 7151 7152 7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165
/*
 * IBM ThinkPads have a simple volume controller with MUTE gating.
 * Very early Lenovo ThinkPads follow the IBM ThinkPad spec.
 *
 * Since the *61 series (and probably also the later *60 series), Lenovo
 * ThinkPads only implement the MUTE gate.
 *
 * EC register 0x30
 *   Bit 6: MUTE (1 mutes sound)
 *   Bit 3-0: Volume
 *   Other bits should be zero as far as we know.
 *
 * This is also stored in CMOS NVRAM, byte 0x60, bit 6 (MUTE), and
 * bits 3-0 (volume).  Other bits in NVRAM may have other functions,
 * such as bit 7 which is used to detect repeated presses of MUTE,
 * and we leave them unchanged.
7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176
 *
 * On newer Lenovo ThinkPads, the EC can automatically change the volume
 * in response to user input.  Unfortunately, this rarely works well.
 * The laptop changes the state of its internal MUTE gate and, on some
 * models, sends KEY_MUTE, causing any user code that responds to the
 * mute button to get confused.  The hardware MUTE gate is also
 * unnecessary, since user code can handle the mute button without
 * kernel or EC help.
 *
 * To avoid confusing userspace, we simply disable all EC-based mute
 * and volume controls when possible.
7177 7178
 */

7179 7180
#ifdef CONFIG_THINKPAD_ACPI_ALSA_SUPPORT

7181 7182 7183 7184
#define TPACPI_ALSA_DRVNAME  "ThinkPad EC"
#define TPACPI_ALSA_SHRTNAME "ThinkPad Console Audio Control"
#define TPACPI_ALSA_MIXERNAME TPACPI_ALSA_SHRTNAME

7185 7186 7187 7188 7189 7190
#if SNDRV_CARDS <= 32
#define DEFAULT_ALSA_IDX		~((1 << (SNDRV_CARDS - 3)) - 1)
#else
#define DEFAULT_ALSA_IDX		~((1 << (32 - 3)) - 1)
#endif
static int alsa_index = DEFAULT_ALSA_IDX; /* last three slots */
7191
static char *alsa_id = "ThinkPadEC";
7192
static bool alsa_enable = SNDRV_DEFAULT_ENABLE1;
7193 7194 7195 7196 7197 7198 7199 7200 7201

struct tpacpi_alsa_data {
	struct snd_card *card;
	struct snd_ctl_elem_id *ctl_mute_id;
	struct snd_ctl_elem_id *ctl_vol_id;
};

static struct snd_card *alsa_card;

7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223
enum {
	TP_EC_AUDIO = 0x30,

	/* TP_EC_AUDIO bits */
	TP_EC_AUDIO_MUTESW = 6,

	/* TP_EC_AUDIO bitmasks */
	TP_EC_AUDIO_LVL_MSK = 0x0F,
	TP_EC_AUDIO_MUTESW_MSK = (1 << TP_EC_AUDIO_MUTESW),

	/* Maximum volume */
	TP_EC_VOLUME_MAX = 14,
};

enum tpacpi_volume_access_mode {
	TPACPI_VOL_MODE_AUTO = 0,	/* Not implemented yet */
	TPACPI_VOL_MODE_EC,		/* Pure EC control */
	TPACPI_VOL_MODE_UCMS_STEP,	/* UCMS step-based control: N/A */
	TPACPI_VOL_MODE_ECNVRAM,	/* EC control w/ NVRAM store */
	TPACPI_VOL_MODE_MAX
};

7224 7225 7226 7227 7228 7229 7230
enum tpacpi_volume_capabilities {
	TPACPI_VOL_CAP_AUTO = 0,	/* Use white/blacklist */
	TPACPI_VOL_CAP_VOLMUTE,		/* Output vol and mute */
	TPACPI_VOL_CAP_MUTEONLY,	/* Output mute only */
	TPACPI_VOL_CAP_MAX
};

7231 7232 7233 7234 7235 7236 7237
enum tpacpi_mute_btn_mode {
	TP_EC_MUTE_BTN_LATCH  = 0,	/* Mute mutes; up/down unmutes */
	/* We don't know what mode 1 is. */
	TP_EC_MUTE_BTN_NONE   = 2,	/* Mute and up/down are just keys */
	TP_EC_MUTE_BTN_TOGGLE = 3,	/* Mute toggles; up/down unmutes */
};

7238 7239 7240
static enum tpacpi_volume_access_mode volume_mode =
	TPACPI_VOL_MODE_MAX;

7241
static enum tpacpi_volume_capabilities volume_capabilities;
7242
static bool volume_control_allowed;
7243 7244 7245
static bool software_mute_requested = true;
static bool software_mute_active;
static int software_mute_orig_mode;
7246

7247 7248 7249 7250 7251 7252 7253
/*
 * Used to syncronize writers to TP_EC_AUDIO and
 * TP_NVRAM_ADDR_MIXER, as we need to do read-modify-write
 */
static struct mutex volume_mutex;

static void tpacpi_volume_checkpoint_nvram(void)
7254
{
7255 7256
	u8 lec = 0;
	u8 b_nvram;
7257
	u8 ec_mask;
7258 7259 7260

	if (volume_mode != TPACPI_VOL_MODE_ECNVRAM)
		return;
7261 7262
	if (!volume_control_allowed)
		return;
7263 7264
	if (software_mute_active)
		return;
7265 7266 7267

	vdbg_printk(TPACPI_DBG_MIXER,
		"trying to checkpoint mixer state to NVRAM...\n");
7268

7269 7270 7271 7272 7273
	if (tp_features.mixer_no_level_control)
		ec_mask = TP_EC_AUDIO_MUTESW_MSK;
	else
		ec_mask = TP_EC_AUDIO_MUTESW_MSK | TP_EC_AUDIO_LVL_MSK;

7274 7275 7276 7277 7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288 7289
	if (mutex_lock_killable(&volume_mutex) < 0)
		return;

	if (unlikely(!acpi_ec_read(TP_EC_AUDIO, &lec)))
		goto unlock;
	lec &= ec_mask;
	b_nvram = nvram_read_byte(TP_NVRAM_ADDR_MIXER);

	if (lec != (b_nvram & ec_mask)) {
		/* NVRAM needs update */
		b_nvram &= ~ec_mask;
		b_nvram |= lec;
		nvram_write_byte(b_nvram, TP_NVRAM_ADDR_MIXER);
		dbg_printk(TPACPI_DBG_MIXER,
			   "updated NVRAM mixer status to 0x%02x (0x%02x)\n",
			   (unsigned int) lec, (unsigned int) b_nvram);
7290
	} else {
7291 7292 7293
		vdbg_printk(TPACPI_DBG_MIXER,
			   "NVRAM mixer status already is 0x%02x (0x%02x)\n",
			   (unsigned int) lec, (unsigned int) b_nvram);
7294 7295
	}

7296 7297
unlock:
	mutex_unlock(&volume_mutex);
7298 7299
}

7300
static int volume_get_status_ec(u8 *status)
7301
{
7302
	u8 s;
7303

7304 7305
	if (!acpi_ec_read(TP_EC_AUDIO, &s))
		return -EIO;
7306

7307
	*status = s;
L
Linus Torvalds 已提交
7308

7309
	dbg_printk(TPACPI_DBG_MIXER, "status 0x%02x\n", s);
7310

7311 7312
	return 0;
}
7313

7314 7315 7316 7317
static int volume_get_status(u8 *status)
{
	return volume_get_status_ec(status);
}
7318

7319 7320 7321 7322
static int volume_set_status_ec(const u8 status)
{
	if (!acpi_ec_write(TP_EC_AUDIO, status))
		return -EIO;
7323

7324 7325
	dbg_printk(TPACPI_DBG_MIXER, "set EC mixer to 0x%02x\n", status);

7326 7327 7328 7329 7330 7331
	/*
	 * On X200s, and possibly on others, it can take a while for
	 * reads to become correct.
	 */
	msleep(1);

7332 7333 7334 7335 7336 7337 7338 7339
	return 0;
}

static int volume_set_status(const u8 status)
{
	return volume_set_status_ec(status);
}

7340 7341
/* returns < 0 on error, 0 on no change, 1 on change */
static int __volume_set_mute_ec(const bool mute)
7342 7343 7344 7345 7346 7347 7348 7349 7350 7351 7352 7353 7354 7355
{
	int rc;
	u8 s, n;

	if (mutex_lock_killable(&volume_mutex) < 0)
		return -EINTR;

	rc = volume_get_status_ec(&s);
	if (rc)
		goto unlock;

	n = (mute) ? s | TP_EC_AUDIO_MUTESW_MSK :
		     s & ~TP_EC_AUDIO_MUTESW_MSK;

7356
	if (n != s) {
7357
		rc = volume_set_status_ec(n);
7358 7359 7360
		if (!rc)
			rc = 1;
	}
7361 7362 7363 7364 7365 7366

unlock:
	mutex_unlock(&volume_mutex);
	return rc;
}

7367 7368 7369 7370 7371 7372 7373
static int volume_alsa_set_mute(const bool mute)
{
	dbg_printk(TPACPI_DBG_MIXER, "ALSA: trying to %smute\n",
		   (mute) ? "" : "un");
	return __volume_set_mute_ec(mute);
}

7374 7375
static int volume_set_mute(const bool mute)
{
7376 7377
	int rc;

7378 7379
	dbg_printk(TPACPI_DBG_MIXER, "trying to %smute\n",
		   (mute) ? "" : "un");
7380 7381 7382

	rc = __volume_set_mute_ec(mute);
	return (rc < 0) ? rc : 0;
7383 7384
}

7385 7386
/* returns < 0 on error, 0 on no change, 1 on change */
static int __volume_set_volume_ec(const u8 vol)
7387 7388 7389 7390 7391 7392 7393 7394 7395 7396 7397 7398 7399 7400 7401 7402
{
	int rc;
	u8 s, n;

	if (vol > TP_EC_VOLUME_MAX)
		return -EINVAL;

	if (mutex_lock_killable(&volume_mutex) < 0)
		return -EINTR;

	rc = volume_get_status_ec(&s);
	if (rc)
		goto unlock;

	n = (s & ~TP_EC_AUDIO_LVL_MSK) | vol;

7403
	if (n != s) {
7404
		rc = volume_set_status_ec(n);
7405 7406 7407
		if (!rc)
			rc = 1;
	}
7408 7409 7410 7411 7412 7413

unlock:
	mutex_unlock(&volume_mutex);
	return rc;
}

7414 7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446 7447 7448 7449 7450 7451 7452 7453 7454 7455 7456 7457 7458 7459 7460 7461 7462 7463 7464
static int volume_set_software_mute(bool startup)
{
	int result;

	if (!tpacpi_is_lenovo())
		return -ENODEV;

	if (startup) {
		if (!acpi_evalf(ec_handle, &software_mute_orig_mode,
				"HAUM", "qd"))
			return -EIO;

		dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER,
			    "Initial HAUM setting was %d\n",
			    software_mute_orig_mode);
	}

	if (!acpi_evalf(ec_handle, &result, "SAUM", "qdd",
			(int)TP_EC_MUTE_BTN_NONE))
		return -EIO;

	if (result != TP_EC_MUTE_BTN_NONE)
		pr_warn("Unexpected SAUM result %d\n",
			result);

	/*
	 * In software mute mode, the standard codec controls take
	 * precendence, so we unmute the ThinkPad HW switch at
	 * startup.  Just on case there are SAUM-capable ThinkPads
	 * with level controls, set max HW volume as well.
	 */
	if (tp_features.mixer_no_level_control)
		result = volume_set_mute(false);
	else
		result = volume_set_status(TP_EC_VOLUME_MAX);

	if (result != 0)
		pr_warn("Failed to unmute the HW mute switch\n");

	return 0;
}

static void volume_exit_software_mute(void)
{
	int r;

	if (!acpi_evalf(ec_handle, &r, "SAUM", "qdd", software_mute_orig_mode)
	    || r != software_mute_orig_mode)
		pr_warn("Failed to restore mute mode\n");
}

7465
static int volume_alsa_set_volume(const u8 vol)
7466 7467
{
	dbg_printk(TPACPI_DBG_MIXER,
7468 7469
		   "ALSA: trying to set volume level to %hu\n", vol);
	return __volume_set_volume_ec(vol);
7470 7471
}

7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515
static void volume_alsa_notify_change(void)
{
	struct tpacpi_alsa_data *d;

	if (alsa_card && alsa_card->private_data) {
		d = alsa_card->private_data;
		if (d->ctl_mute_id)
			snd_ctl_notify(alsa_card,
					SNDRV_CTL_EVENT_MASK_VALUE,
					d->ctl_mute_id);
		if (d->ctl_vol_id)
			snd_ctl_notify(alsa_card,
					SNDRV_CTL_EVENT_MASK_VALUE,
					d->ctl_vol_id);
	}
}

static int volume_alsa_vol_info(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_info *uinfo)
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	uinfo->count = 1;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = TP_EC_VOLUME_MAX;
	return 0;
}

static int volume_alsa_vol_get(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_value *ucontrol)
{
	u8 s;
	int rc;

	rc = volume_get_status(&s);
	if (rc < 0)
		return rc;

	ucontrol->value.integer.value[0] = s & TP_EC_AUDIO_LVL_MSK;
	return 0;
}

static int volume_alsa_vol_put(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_value *ucontrol)
{
7516 7517
	tpacpi_disclose_usertask("ALSA", "set volume to %ld\n",
				 ucontrol->value.integer.value[0]);
7518
	return volume_alsa_set_volume(ucontrol->value.integer.value[0]);
7519 7520 7521 7522 7523 7524 7525 7526 7527 7528 7529 7530 7531 7532 7533 7534 7535 7536 7537 7538 7539 7540
}

#define volume_alsa_mute_info snd_ctl_boolean_mono_info

static int volume_alsa_mute_get(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_value *ucontrol)
{
	u8 s;
	int rc;

	rc = volume_get_status(&s);
	if (rc < 0)
		return rc;

	ucontrol->value.integer.value[0] =
				(s & TP_EC_AUDIO_MUTESW_MSK) ? 0 : 1;
	return 0;
}

static int volume_alsa_mute_put(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_value *ucontrol)
{
7541 7542 7543
	tpacpi_disclose_usertask("ALSA", "%smute\n",
				 ucontrol->value.integer.value[0] ?
					"un" : "");
7544
	return volume_alsa_set_mute(!ucontrol->value.integer.value[0]);
7545 7546
}

7547
static struct snd_kcontrol_new volume_alsa_control_vol __initdata = {
7548 7549 7550 7551 7552 7553 7554 7555
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Console Playback Volume",
	.index = 0,
	.access = SNDRV_CTL_ELEM_ACCESS_READ,
	.info = volume_alsa_vol_info,
	.get = volume_alsa_vol_get,
};

7556
static struct snd_kcontrol_new volume_alsa_control_mute __initdata = {
7557 7558 7559 7560 7561 7562 7563 7564
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Console Playback Switch",
	.index = 0,
	.access = SNDRV_CTL_ELEM_ACCESS_READ,
	.info = volume_alsa_mute_info,
	.get = volume_alsa_mute_get,
};

7565
static void volume_suspend(void)
7566 7567 7568 7569
{
	tpacpi_volume_checkpoint_nvram();
}

7570 7571
static void volume_resume(void)
{
7572 7573 7574 7575 7576 7577
	if (software_mute_active) {
		if (volume_set_software_mute(false) < 0)
			pr_warn("Failed to restore software mute\n");
	} else {
		volume_alsa_notify_change();
	}
7578 7579
}

7580 7581 7582 7583 7584 7585 7586
static void volume_shutdown(void)
{
	tpacpi_volume_checkpoint_nvram();
}

static void volume_exit(void)
{
7587 7588 7589 7590 7591
	if (alsa_card) {
		snd_card_free(alsa_card);
		alsa_card = NULL;
	}

7592
	tpacpi_volume_checkpoint_nvram();
7593 7594 7595

	if (software_mute_active)
		volume_exit_software_mute();
7596 7597
}

7598 7599 7600 7601 7602 7603 7604 7605
static int __init volume_create_alsa_mixer(void)
{
	struct snd_card *card;
	struct tpacpi_alsa_data *data;
	struct snd_kcontrol *ctl_vol;
	struct snd_kcontrol *ctl_mute;
	int rc;

7606 7607 7608
	rc = snd_card_new(&tpacpi_pdev->dev,
			  alsa_index, alsa_id, THIS_MODULE,
			  sizeof(struct tpacpi_alsa_data), &card);
7609
	if (rc < 0 || !card) {
7610
		pr_err("Failed to create ALSA card structures: %d\n", rc);
7611 7612
		return 1;
	}
7613 7614 7615 7616 7617 7618 7619 7620 7621 7622 7623 7624 7625 7626 7627 7628 7629 7630 7631 7632 7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643

	BUG_ON(!card->private_data);
	data = card->private_data;
	data->card = card;

	strlcpy(card->driver, TPACPI_ALSA_DRVNAME,
		sizeof(card->driver));
	strlcpy(card->shortname, TPACPI_ALSA_SHRTNAME,
		sizeof(card->shortname));
	snprintf(card->mixername, sizeof(card->mixername), "ThinkPad EC %s",
		 (thinkpad_id.ec_version_str) ?
			thinkpad_id.ec_version_str : "(unknown)");
	snprintf(card->longname, sizeof(card->longname),
		 "%s at EC reg 0x%02x, fw %s", card->shortname, TP_EC_AUDIO,
		 (thinkpad_id.ec_version_str) ?
			thinkpad_id.ec_version_str : "unknown");

	if (volume_control_allowed) {
		volume_alsa_control_vol.put = volume_alsa_vol_put;
		volume_alsa_control_vol.access =
				SNDRV_CTL_ELEM_ACCESS_READWRITE;

		volume_alsa_control_mute.put = volume_alsa_mute_put;
		volume_alsa_control_mute.access =
				SNDRV_CTL_ELEM_ACCESS_READWRITE;
	}

	if (!tp_features.mixer_no_level_control) {
		ctl_vol = snd_ctl_new1(&volume_alsa_control_vol, NULL);
		rc = snd_ctl_add(card, ctl_vol);
		if (rc < 0) {
7644 7645
			pr_err("Failed to create ALSA volume control: %d\n",
			       rc);
7646
			goto err_exit;
7647
		}
7648 7649
		data->ctl_vol_id = &ctl_vol->id;
	}
7650

7651 7652 7653
	ctl_mute = snd_ctl_new1(&volume_alsa_control_mute, NULL);
	rc = snd_ctl_add(card, ctl_mute);
	if (rc < 0) {
7654
		pr_err("Failed to create ALSA mute control: %d\n", rc);
7655
		goto err_exit;
7656 7657
	}
	data->ctl_mute_id = &ctl_mute->id;
7658

7659 7660
	rc = snd_card_register(card);
	if (rc < 0) {
7661
		pr_err("Failed to register ALSA card: %d\n", rc);
7662
		goto err_exit;
7663 7664 7665
	}

	alsa_card = card;
7666 7667 7668 7669 7670
	return 0;

err_exit:
	snd_card_free(card);
	return 1;
7671 7672
}

7673 7674 7675 7676 7677 7678 7679 7680 7681 7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695 7696 7697 7698
#define TPACPI_VOL_Q_MUTEONLY	0x0001	/* Mute-only control available */
#define TPACPI_VOL_Q_LEVEL	0x0002  /* Volume control available */

static const struct tpacpi_quirk volume_quirk_table[] __initconst = {
	/* Whitelist volume level on all IBM by default */
	{ .vendor = PCI_VENDOR_ID_IBM,
	  .bios   = TPACPI_MATCH_ANY,
	  .ec     = TPACPI_MATCH_ANY,
	  .quirks = TPACPI_VOL_Q_LEVEL },

	/* Lenovo models with volume control (needs confirmation) */
	TPACPI_QEC_LNV('7', 'C', TPACPI_VOL_Q_LEVEL), /* R60/i */
	TPACPI_QEC_LNV('7', 'E', TPACPI_VOL_Q_LEVEL), /* R60e/i */
	TPACPI_QEC_LNV('7', '9', TPACPI_VOL_Q_LEVEL), /* T60/p */
	TPACPI_QEC_LNV('7', 'B', TPACPI_VOL_Q_LEVEL), /* X60/s */
	TPACPI_QEC_LNV('7', 'J', TPACPI_VOL_Q_LEVEL), /* X60t */
	TPACPI_QEC_LNV('7', '7', TPACPI_VOL_Q_LEVEL), /* Z60 */
	TPACPI_QEC_LNV('7', 'F', TPACPI_VOL_Q_LEVEL), /* Z61 */

	/* Whitelist mute-only on all Lenovo by default */
	{ .vendor = PCI_VENDOR_ID_LENOVO,
	  .bios   = TPACPI_MATCH_ANY,
	  .ec	  = TPACPI_MATCH_ANY,
	  .quirks = TPACPI_VOL_Q_MUTEONLY }
};

7699 7700
static int __init volume_init(struct ibm_init_struct *iibm)
{
7701
	unsigned long quirks;
7702
	int rc;
7703

7704 7705 7706 7707 7708 7709 7710 7711 7712 7713 7714 7715 7716
	vdbg_printk(TPACPI_DBG_INIT, "initializing volume subdriver\n");

	mutex_init(&volume_mutex);

	/*
	 * Check for module parameter bogosity, note that we
	 * init volume_mode to TPACPI_VOL_MODE_MAX in order to be
	 * able to detect "unspecified"
	 */
	if (volume_mode > TPACPI_VOL_MODE_MAX)
		return -EINVAL;

	if (volume_mode == TPACPI_VOL_MODE_UCMS_STEP) {
7717 7718
		pr_err("UCMS step volume mode not implemented, please contact %s\n",
		       TPACPI_MAIL);
7719 7720 7721
		return 1;
	}

7722 7723 7724
	if (volume_capabilities >= TPACPI_VOL_CAP_MAX)
		return -EINVAL;

7725 7726 7727 7728 7729 7730
	/*
	 * The ALSA mixer is our primary interface.
	 * When disabled, don't install the subdriver at all
	 */
	if (!alsa_enable) {
		vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER,
7731
			    "ALSA mixer disabled by parameter, not loading volume subdriver...\n");
7732 7733 7734
		return 1;
	}

7735 7736 7737 7738 7739 7740 7741 7742 7743 7744 7745 7746 7747 7748 7749 7750 7751 7752 7753 7754 7755 7756 7757 7758 7759 7760 7761
	quirks = tpacpi_check_quirks(volume_quirk_table,
				     ARRAY_SIZE(volume_quirk_table));

	switch (volume_capabilities) {
	case TPACPI_VOL_CAP_AUTO:
		if (quirks & TPACPI_VOL_Q_MUTEONLY)
			tp_features.mixer_no_level_control = 1;
		else if (quirks & TPACPI_VOL_Q_LEVEL)
			tp_features.mixer_no_level_control = 0;
		else
			return 1; /* no mixer */
		break;
	case TPACPI_VOL_CAP_VOLMUTE:
		tp_features.mixer_no_level_control = 0;
		break;
	case TPACPI_VOL_CAP_MUTEONLY:
		tp_features.mixer_no_level_control = 1;
		break;
	default:
		return 1;
	}

	if (volume_capabilities != TPACPI_VOL_CAP_AUTO)
		dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER,
				"using user-supplied volume_capabilities=%d\n",
				volume_capabilities);

7762 7763 7764 7765 7766 7767 7768 7769 7770 7771 7772 7773 7774 7775
	if (volume_mode == TPACPI_VOL_MODE_AUTO ||
	    volume_mode == TPACPI_VOL_MODE_MAX) {
		volume_mode = TPACPI_VOL_MODE_ECNVRAM;

		dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER,
				"driver auto-selected volume_mode=%d\n",
				volume_mode);
	} else {
		dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER,
				"using user-supplied volume_mode=%d\n",
				volume_mode);
	}

	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER,
7776 7777
			"mute is supported, volume control is %s\n",
			str_supported(!tp_features.mixer_no_level_control));
7778

7779 7780 7781 7782 7783 7784 7785 7786
	if (software_mute_requested && volume_set_software_mute(true) == 0) {
		software_mute_active = true;
	} else {
		rc = volume_create_alsa_mixer();
		if (rc) {
			pr_err("Could not create the ALSA mixer interface\n");
			return rc;
		}
7787

7788 7789 7790 7791 7792
		pr_info("Console audio control enabled, mode: %s\n",
			(volume_control_allowed) ?
				"override (read/write)" :
				"monitor (read only)");
	}
7793

7794 7795 7796 7797 7798 7799 7800
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_MIXER,
		"registering volume hotkeys as change notification\n");
	tpacpi_hotkey_driver_mask_set(hotkey_driver_mask
			| TP_ACPI_HKEY_VOLUP_MASK
			| TP_ACPI_HKEY_VOLDWN_MASK
			| TP_ACPI_HKEY_MUTE_MASK);

7801 7802
	return 0;
}
7803

7804
static int volume_read(struct seq_file *m)
7805
{
7806
	u8 status;
7807

7808
	if (volume_get_status(&status) < 0) {
7809
		seq_printf(m, "level:\t\tunreadable\n");
7810
	} else {
7811
		if (tp_features.mixer_no_level_control)
7812
			seq_printf(m, "level:\t\tunsupported\n");
7813
		else
7814
			seq_printf(m, "level:\t\t%d\n",
7815 7816
					status & TP_EC_AUDIO_LVL_MSK);

7817
		seq_printf(m, "mute:\t\t%s\n",
7818
				onoff(status, TP_EC_AUDIO_MUTESW));
7819

7820
		if (volume_control_allowed) {
7821
			seq_printf(m, "commands:\tunmute, mute\n");
7822
			if (!tp_features.mixer_no_level_control) {
7823 7824 7825
				seq_printf(m, "commands:\tup, down\n");
				seq_printf(m, "commands:\tlevel <level> (<level> is 0-%d)\n",
					      TP_EC_VOLUME_MAX);
7826
			}
7827 7828 7829 7830 7831 7832 7833 7834
		}
	}

	return 0;
}

static int volume_write(char *buf)
{
7835 7836 7837
	u8 s;
	u8 new_level, new_mute;
	int l;
7838
	char *cmd;
7839
	int rc;
7840

7841 7842 7843 7844 7845 7846 7847
	/*
	 * We do allow volume control at driver startup, so that the
	 * user can set initial state through the volume=... parameter hack.
	 */
	if (!volume_control_allowed && tpacpi_lifecycle != TPACPI_LIFE_INIT) {
		if (unlikely(!tp_warned.volume_ctrl_forbidden)) {
			tp_warned.volume_ctrl_forbidden = 1;
7848 7849
			pr_notice("Console audio control in monitor mode, changes are not allowed\n");
			pr_notice("Use the volume_control=1 module parameter to enable volume control\n");
7850 7851 7852 7853
		}
		return -EPERM;
	}

7854 7855 7856
	rc = volume_get_status(&s);
	if (rc < 0)
		return rc;
7857

7858 7859 7860
	new_level = s & TP_EC_AUDIO_LVL_MSK;
	new_mute  = s & TP_EC_AUDIO_MUTESW_MSK;

7861
	while ((cmd = strsep(&buf, ","))) {
7862 7863 7864 7865 7866 7867 7868 7869 7870 7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881
		if (!tp_features.mixer_no_level_control) {
			if (strlencmp(cmd, "up") == 0) {
				if (new_mute)
					new_mute = 0;
				else if (new_level < TP_EC_VOLUME_MAX)
					new_level++;
				continue;
			} else if (strlencmp(cmd, "down") == 0) {
				if (new_mute)
					new_mute = 0;
				else if (new_level > 0)
					new_level--;
				continue;
			} else if (sscanf(cmd, "level %u", &l) == 1 &&
				   l >= 0 && l <= TP_EC_VOLUME_MAX) {
					new_level = l;
				continue;
			}
		}
		if (strlencmp(cmd, "mute") == 0)
7882
			new_mute = TP_EC_AUDIO_MUTESW_MSK;
7883 7884 7885
		else if (strlencmp(cmd, "unmute") == 0)
			new_mute = 0;
		else
L
Linus Torvalds 已提交
7886
			return -EINVAL;
7887
	}
L
Linus Torvalds 已提交
7888

7889 7890 7891 7892 7893 7894 7895 7896 7897 7898
	if (tp_features.mixer_no_level_control) {
		tpacpi_disclose_usertask("procfs volume", "%smute\n",
					new_mute ? "" : "un");
		rc = volume_set_mute(!!new_mute);
	} else {
		tpacpi_disclose_usertask("procfs volume",
					"%smute and set level to %d\n",
					new_mute ? "" : "un", new_level);
		rc = volume_set_status(new_mute | new_level);
	}
7899
	volume_alsa_notify_change();
7900

7901
	return (rc == -EINTR) ? -ERESTARTSYS : rc;
7902 7903
}

7904 7905 7906 7907
static struct ibm_struct volume_driver_data = {
	.name = "volume",
	.read = volume_read,
	.write = volume_write,
7908 7909
	.exit = volume_exit,
	.suspend = volume_suspend,
7910
	.resume = volume_resume,
7911
	.shutdown = volume_shutdown,
7912
};
7913

7914 7915 7916 7917
#else /* !CONFIG_THINKPAD_ACPI_ALSA_SUPPORT */

#define alsa_card NULL

7918
static inline void volume_alsa_notify_change(void)
7919 7920 7921 7922 7923
{
}

static int __init volume_init(struct ibm_init_struct *iibm)
{
7924
	pr_info("volume: disabled as there is no ALSA support in this kernel\n");
7925 7926 7927 7928 7929 7930 7931 7932 7933 7934

	return 1;
}

static struct ibm_struct volume_driver_data = {
	.name = "volume",
};

#endif /* CONFIG_THINKPAD_ACPI_ALSA_SUPPORT */

7935 7936 7937 7938 7939 7940 7941
/*************************************************************************
 * Fan subdriver
 */

/*
 * FAN ACCESS MODES
 *
7942
 * TPACPI_FAN_RD_ACPI_GFAN:
7943 7944
 * 	ACPI GFAN method: returns fan level
 *
7945
 * 	see TPACPI_FAN_WR_ACPI_SFAN
7946
 * 	EC 0x2f (HFSP) not available if GFAN exists
7947
 *
7948
 * TPACPI_FAN_WR_ACPI_SFAN:
7949 7950
 * 	ACPI SFAN method: sets fan level, 0 (stop) to 7 (max)
 *
7951 7952
 * 	EC 0x2f (HFSP) might be available *for reading*, but do not use
 * 	it for writing.
7953
 *
7954
 * TPACPI_FAN_WR_TPEC:
7955 7956
 * 	ThinkPad EC register 0x2f (HFSP): fan control loop mode
 * 	Supported on almost all ThinkPads
7957 7958 7959
 *
 * 	Fan speed changes of any sort (including those caused by the
 * 	disengaged mode) are usually done slowly by the firmware as the
7960
 * 	maximum amount of fan duty cycle change per second seems to be
7961 7962 7963 7964 7965 7966 7967 7968 7969
 * 	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.
7970
 *	 6	full speed mode (takes precedence over bit 7);
7971
 *		not available on all thinkpads.  May disable
7972 7973 7974 7975 7976
 *		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.
7977 7978 7979 7980 7981 7982 7983
 *	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
7984
 * 		TPACPI_FAN_WR_ACPI_FANS (X31/X40/X41)
7985 7986
 *
 *	FIRMWARE BUG: on some models, EC 0x2f might not be initialized at
7987
 *	boot. Apparently the EC does not initialize it, so unless ACPI DSDT
7988 7989 7990
 *	does so, its initial value is meaningless (0x07).
 *
 *	For firmware bugs, refer to:
7991
 *	https://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
7992 7993 7994 7995 7996 7997 7998 7999 8000 8001 8002 8003
 *
 * 	----
 *
 *	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.
 *
8004
 *	Unfortunately a lot of ThinkPads with new-style ECs but whose firmware
8005 8006 8007 8008 8009 8010 8011
 *	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.
 *
8012 8013
 *	FIRMWARE BUG: may go stale while the EC is switching to full speed
 *	mode.
8014 8015
 *
 *	For firmware bugs, refer to:
8016
 *	https://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
8017
 *
8018 8019 8020 8021 8022 8023 8024 8025 8026 8027 8028 8029 8030 8031 8032
 *	----
 *
 *	ThinkPad EC register 0x31 bit 0 (only on select models)
 *
 *	When bit 0 of EC register 0x31 is zero, the tachometer registers
 *	show the speed of the main fan.  When bit 0 of EC register 0x31
 *	is one, the tachometer registers show the speed of the auxiliary
 *	fan.
 *
 *	Fan control seems to affect both fans, regardless of the state
 *	of this bit.
 *
 *	So far, only the firmware for the X60/X61 non-tablet versions
 *	seem to support this (firmware TP-7M).
 *
8033
 * TPACPI_FAN_WR_ACPI_FANS:
8034 8035 8036 8037 8038 8039 8040 8041 8042 8043
 *	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).
 *
8044
 * 	There are three default speed sets, accessible as handles:
8045 8046 8047 8048 8049
 * 	FS1L,FS1M,FS1H; FS2L,FS2M,FS2H; FS3L,FS3M,FS3H
 *
 * 	ACPI DSDT switches which set is in use depending on various
 * 	factors.
 *
8050
 * 	TPACPI_FAN_WR_TPEC is also available and should be used to
8051 8052 8053 8054
 * 	command the fan.  The X31/X40/X41 seems to have 8 fan levels,
 * 	but the ACPI tables just mention level 7.
 */

8055 8056 8057 8058
enum {					/* Fan control constants */
	fan_status_offset = 0x2f,	/* EC register 0x2f */
	fan_rpm_offset = 0x84,		/* EC register 0x84: LSB, 0x85 MSB (RPM)
					 * 0x84 must be read before 0x85 */
8059 8060
	fan_select_offset = 0x31,	/* EC register 0x31 (Firmware 7M)
					   bit 0 selects which fan is active */
8061 8062 8063 8064 8065 8066 8067 8068 8069 8070 8071 8072 8073 8074 8075 8076 8077 8078 8079 8080 8081 8082 8083 8084 8085 8086 8087

	TP_EC_FAN_FULLSPEED = 0x40,	/* EC fan mode: full speed */
	TP_EC_FAN_AUTO	    = 0x80,	/* EC fan mode: auto fan control */

	TPACPI_FAN_LAST_LEVEL = 0x100,	/* Use cached last-seen fan level */
};

enum fan_status_access_mode {
	TPACPI_FAN_NONE = 0,		/* No fan status or control */
	TPACPI_FAN_RD_ACPI_GFAN,	/* Use ACPI GFAN */
	TPACPI_FAN_RD_TPEC,		/* Use ACPI EC regs 0x2f, 0x84-0x85 */
};

enum fan_control_access_mode {
	TPACPI_FAN_WR_NONE = 0,		/* No fan control */
	TPACPI_FAN_WR_ACPI_SFAN,	/* Use ACPI SFAN */
	TPACPI_FAN_WR_TPEC,		/* Use ACPI EC reg 0x2f */
	TPACPI_FAN_WR_ACPI_FANS,	/* Use ACPI FANS and EC reg 0x2f */
};

enum fan_control_commands {
	TPACPI_FAN_CMD_SPEED 	= 0x0001,	/* speed command */
	TPACPI_FAN_CMD_LEVEL 	= 0x0002,	/* level command  */
	TPACPI_FAN_CMD_ENABLE	= 0x0004,	/* enable/disable cmd,
						 * and also watchdog cmd */
};

8088
static bool fan_control_allowed;
8089

8090 8091 8092
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;
8093

8094
static u8 fan_control_initial_status;
8095
static u8 fan_control_desired_level;
8096
static u8 fan_control_resume_level;
8097 8098 8099
static int fan_watchdog_maxinterval;

static struct mutex fan_mutex;
8100

8101 8102
static void fan_watchdog_fire(struct work_struct *ignored);
static DECLARE_DELAYED_WORK(fan_watchdog_task, fan_watchdog_fire);
8103

8104 8105
TPACPI_HANDLE(fans, ec, "FANS");	/* X31, X40, X41 */
TPACPI_HANDLE(gfan, ec, "GFAN",	/* 570 */
8106 8107
	   "\\FSPD",		/* 600e/x, 770e, 770x */
	   );			/* all others */
8108
TPACPI_HANDLE(sfan, ec, "SFAN",	/* 570 */
8109 8110 8111
	   "JFNS",		/* 770x-JL */
	   );			/* all others */

8112 8113 8114 8115 8116 8117 8118 8119 8120 8121 8122
/*
 * Unitialized HFSP quirk: ACPI DSDT and EC fail to initialize the
 * HFSP register at boot, so it contains 0x07 but the Thinkpad could
 * be in auto mode (0x80).
 *
 * This is corrected by any write to HFSP either by the driver, or
 * by the firmware.
 *
 * We assume 0x07 really means auto mode while this quirk is active,
 * as this is far more likely than the ThinkPad being in level 7,
 * which is only used by the firmware during thermal emergencies.
8123 8124 8125
 *
 * Enable for TP-1Y (T43), TP-78 (R51e), TP-76 (R52),
 * TP-70 (T43, R52), which are known to be buggy.
8126 8127
 */

8128
static void fan_quirk1_setup(void)
8129 8130
{
	if (fan_control_initial_status == 0x07) {
8131
		pr_notice("fan_init: initial fan status is unknown, assuming it is in auto mode\n");
8132
		tp_features.fan_ctrl_status_undef = 1;
8133 8134 8135 8136 8137 8138 8139 8140 8141 8142 8143 8144 8145 8146 8147 8148 8149 8150 8151
	}
}

static void fan_quirk1_handle(u8 *fan_status)
{
	if (unlikely(tp_features.fan_ctrl_status_undef)) {
		if (*fan_status != fan_control_initial_status) {
			/* something changed the HFSP regisnter since
			 * driver init time, so it is not undefined
			 * anymore */
			tp_features.fan_ctrl_status_undef = 0;
		} else {
			/* Return most likely status. In fact, it
			 * might be the only possible status */
			*fan_status = TP_EC_FAN_AUTO;
		}
	}
}

8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162 8163 8164 8165 8166 8167 8168 8169 8170 8171 8172 8173 8174 8175 8176 8177 8178 8179 8180 8181 8182 8183
/* Select main fan on X60/X61, NOOP on others */
static bool fan_select_fan1(void)
{
	if (tp_features.second_fan) {
		u8 val;

		if (ec_read(fan_select_offset, &val) < 0)
			return false;
		val &= 0xFEU;
		if (ec_write(fan_select_offset, val) < 0)
			return false;
	}
	return true;
}

/* Select secondary fan on X60/X61 */
static bool fan_select_fan2(void)
{
	u8 val;

	if (!tp_features.second_fan)
		return false;

	if (ec_read(fan_select_offset, &val) < 0)
		return false;
	val |= 0x01U;
	if (ec_write(fan_select_offset, val) < 0)
		return false;

	return true;
}

8184
/*
8185
 * Call with fan_mutex held
8186
 */
8187
static void fan_update_desired_level(u8 status)
8188
{
8189 8190 8191 8192 8193 8194 8195 8196
	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;
	}
}
8197

8198 8199 8200
static int fan_get_status(u8 *status)
{
	u8 s;
8201

8202 8203
	/* TODO:
	 * Add TPACPI_FAN_RD_ACPI_FANS ? */
8204

8205
	switch (fan_status_access_mode) {
8206
	case TPACPI_FAN_RD_ACPI_GFAN: {
8207
		/* 570, 600e/x, 770e, 770x */
8208
		int res;
8209

8210
		if (unlikely(!acpi_evalf(gfan_handle, &res, NULL, "d")))
8211
			return -EIO;
8212

8213
		if (likely(status))
8214
			*status = res & 0x07;
8215

8216
		break;
8217
	}
8218 8219 8220 8221 8222
	case TPACPI_FAN_RD_TPEC:
		/* all except 570, 600e/x, 770e, 770x */
		if (unlikely(!acpi_ec_read(fan_status_offset, &s)))
			return -EIO;

8223
		if (likely(status)) {
8224
			*status = s;
8225 8226
			fan_quirk1_handle(status);
		}
8227 8228

		break;
8229

8230
	default:
8231
		return -ENXIO;
8232 8233
	}

8234 8235
	return 0;
}
8236

8237 8238 8239 8240
static int fan_get_status_safe(u8 *status)
{
	int rc;
	u8 s;
8241

8242
	if (mutex_lock_killable(&fan_mutex))
8243 8244 8245 8246 8247
		return -ERESTARTSYS;
	rc = fan_get_status(&s);
	if (!rc)
		fan_update_desired_level(s);
	mutex_unlock(&fan_mutex);
8248

8249 8250
	if (rc)
		return rc;
8251 8252
	if (status)
		*status = s;
8253

8254
	return 0;
8255 8256 8257
}

static int fan_get_speed(unsigned int *speed)
8258
{
8259
	u8 hi, lo;
8260

8261 8262 8263
	switch (fan_status_access_mode) {
	case TPACPI_FAN_RD_TPEC:
		/* all except 570, 600e/x, 770e, 770x */
8264 8265
		if (unlikely(!fan_select_fan1()))
			return -EIO;
8266 8267 8268
		if (unlikely(!acpi_ec_read(fan_rpm_offset, &lo) ||
			     !acpi_ec_read(fan_rpm_offset + 1, &hi)))
			return -EIO;
8269

8270 8271
		if (likely(speed))
			*speed = (hi << 8) | lo;
8272

8273
		break;
8274

8275 8276 8277
	default:
		return -ENXIO;
	}
8278

8279
	return 0;
8280 8281
}

8282 8283 8284 8285 8286 8287 8288 8289 8290 8291 8292 8293 8294 8295 8296 8297 8298 8299 8300 8301 8302 8303 8304 8305 8306 8307 8308 8309
static int fan2_get_speed(unsigned int *speed)
{
	u8 hi, lo;
	bool rc;

	switch (fan_status_access_mode) {
	case TPACPI_FAN_RD_TPEC:
		/* all except 570, 600e/x, 770e, 770x */
		if (unlikely(!fan_select_fan2()))
			return -EIO;
		rc = !acpi_ec_read(fan_rpm_offset, &lo) ||
			     !acpi_ec_read(fan_rpm_offset + 1, &hi);
		fan_select_fan1(); /* play it safe */
		if (rc)
			return -EIO;

		if (likely(speed))
			*speed = (hi << 8) | lo;

		break;

	default:
		return -ENXIO;
	}

	return 0;
}

8310
static int fan_set_level(int level)
8311
{
8312 8313
	if (!fan_control_allowed)
		return -EPERM;
8314

8315 8316
	switch (fan_control_access_mode) {
	case TPACPI_FAN_WR_ACPI_SFAN:
8317
		if ((level < 0) || (level > 7))
8318
			return -EINVAL;
8319 8320 8321 8322 8323 8324 8325 8326 8327 8328 8329

		if (tp_features.second_fan_ctl) {
			if (!fan_select_fan2() ||
			    !acpi_evalf(sfan_handle, NULL, NULL, "vd", level)) {
				pr_warn("Couldn't set 2nd fan level, disabling support\n");
				tp_features.second_fan_ctl = 0;
			}
			fan_select_fan1();
		}
		if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", level))
			return -EIO;
8330
		break;
8331

8332 8333
	case TPACPI_FAN_WR_ACPI_FANS:
	case TPACPI_FAN_WR_TPEC:
8334 8335
		if (!(level & TP_EC_FAN_AUTO) &&
		    !(level & TP_EC_FAN_FULLSPEED) &&
8336 8337
		    ((level < 0) || (level > 7)))
			return -EINVAL;
8338

8339 8340 8341 8342
		/* 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 */
8343
		else if (level & TP_EC_FAN_AUTO)
8344
			level |= 4;	/* safety min speed 4 */
8345

8346 8347 8348 8349 8350 8351 8352 8353 8354
		if (tp_features.second_fan_ctl) {
			if (!fan_select_fan2() ||
			    !acpi_ec_write(fan_status_offset, level)) {
				pr_warn("Couldn't set 2nd fan level, disabling support\n");
				tp_features.second_fan_ctl = 0;
			}
			fan_select_fan1();

		}
8355 8356 8357 8358 8359
		if (!acpi_ec_write(fan_status_offset, level))
			return -EIO;
		else
			tp_features.fan_ctrl_status_undef = 0;
		break;
8360

8361 8362 8363
	default:
		return -ENXIO;
	}
8364 8365 8366

	vdbg_printk(TPACPI_DBG_FAN,
		"fan control: set fan control register to 0x%02x\n", level);
8367
	return 0;
8368 8369
}

8370
static int fan_set_level_safe(int level)
8371
{
8372
	int rc;
8373

8374 8375
	if (!fan_control_allowed)
		return -EPERM;
8376

8377
	if (mutex_lock_killable(&fan_mutex))
8378
		return -ERESTARTSYS;
8379

8380 8381
	if (level == TPACPI_FAN_LAST_LEVEL)
		level = fan_control_desired_level;
8382

8383 8384 8385 8386 8387 8388
	rc = fan_set_level(level);
	if (!rc)
		fan_update_desired_level(level);

	mutex_unlock(&fan_mutex);
	return rc;
8389 8390
}

8391
static int fan_set_enable(void)
8392
{
8393 8394
	u8 s;
	int rc;
8395

8396 8397 8398
	if (!fan_control_allowed)
		return -EPERM;

8399
	if (mutex_lock_killable(&fan_mutex))
8400
		return -ERESTARTSYS;
8401

8402 8403 8404 8405 8406 8407
	switch (fan_control_access_mode) {
	case TPACPI_FAN_WR_ACPI_FANS:
	case TPACPI_FAN_WR_TPEC:
		rc = fan_get_status(&s);
		if (rc < 0)
			break;
8408

8409 8410 8411 8412 8413
		/* Don't go out of emergency fan mode */
		if (s != 7) {
			s &= 0x07;
			s |= TP_EC_FAN_AUTO | 4; /* min fan speed 4 */
		}
8414

8415 8416 8417 8418 8419 8420 8421
		if (!acpi_ec_write(fan_status_offset, s))
			rc = -EIO;
		else {
			tp_features.fan_ctrl_status_undef = 0;
			rc = 0;
		}
		break;
8422

8423 8424 8425 8426
	case TPACPI_FAN_WR_ACPI_SFAN:
		rc = fan_get_status(&s);
		if (rc < 0)
			break;
8427

8428
		s &= 0x07;
8429

8430 8431
		/* Set fan to at least level 4 */
		s |= 4;
8432

8433
		if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", s))
8434
			rc = -EIO;
8435 8436 8437
		else
			rc = 0;
		break;
8438

8439 8440 8441
	default:
		rc = -ENXIO;
	}
8442

8443
	mutex_unlock(&fan_mutex);
8444 8445 8446 8447 8448

	if (!rc)
		vdbg_printk(TPACPI_DBG_FAN,
			"fan control: set fan control register to 0x%02x\n",
			s);
8449
	return rc;
8450
}
8451

8452
static int fan_set_disable(void)
8453
{
8454
	int rc;
8455

8456 8457
	if (!fan_control_allowed)
		return -EPERM;
8458

8459
	if (mutex_lock_killable(&fan_mutex))
8460
		return -ERESTARTSYS;
8461

8462 8463 8464 8465 8466 8467 8468 8469 8470 8471
	rc = 0;
	switch (fan_control_access_mode) {
	case TPACPI_FAN_WR_ACPI_FANS:
	case TPACPI_FAN_WR_TPEC:
		if (!acpi_ec_write(fan_status_offset, 0x00))
			rc = -EIO;
		else {
			fan_control_desired_level = 0;
			tp_features.fan_ctrl_status_undef = 0;
		}
8472 8473
		break;

8474 8475 8476 8477 8478
	case TPACPI_FAN_WR_ACPI_SFAN:
		if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", 0x00))
			rc = -EIO;
		else
			fan_control_desired_level = 0;
8479 8480 8481
		break;

	default:
8482
		rc = -ENXIO;
8483 8484
	}

8485 8486 8487
	if (!rc)
		vdbg_printk(TPACPI_DBG_FAN,
			"fan control: set fan control register to 0\n");
8488 8489 8490 8491 8492

	mutex_unlock(&fan_mutex);
	return rc;
}

8493
static int fan_set_speed(int speed)
8494
{
8495
	int rc;
8496

8497 8498
	if (!fan_control_allowed)
		return -EPERM;
8499

8500
	if (mutex_lock_killable(&fan_mutex))
8501
		return -ERESTARTSYS;
8502

8503 8504 8505 8506 8507 8508 8509 8510 8511
	rc = 0;
	switch (fan_control_access_mode) {
	case TPACPI_FAN_WR_ACPI_FANS:
		if (speed >= 0 && speed <= 65535) {
			if (!acpi_evalf(fans_handle, NULL, NULL, "vddd",
					speed, speed, speed))
				rc = -EIO;
		} else
			rc = -EINVAL;
8512 8513 8514
		break;

	default:
8515
		rc = -ENXIO;
8516 8517
	}

8518 8519
	mutex_unlock(&fan_mutex);
	return rc;
8520 8521 8522 8523
}

static void fan_watchdog_reset(void)
{
8524 8525 8526
	if (fan_control_access_mode == TPACPI_FAN_WR_NONE)
		return;

8527
	if (fan_watchdog_maxinterval > 0 &&
8528 8529 8530 8531 8532
	    tpacpi_lifecycle != TPACPI_LIFE_EXITING)
		mod_delayed_work(tpacpi_wq, &fan_watchdog_task,
			msecs_to_jiffies(fan_watchdog_maxinterval * 1000));
	else
		cancel_delayed_work(&fan_watchdog_task);
8533 8534
}

8535
static void fan_watchdog_fire(struct work_struct *ignored)
8536
{
8537
	int rc;
8538

8539 8540
	if (tpacpi_lifecycle != TPACPI_LIFE_RUNNING)
		return;
8541

8542
	pr_notice("fan watchdog: enabling fan\n");
8543 8544
	rc = fan_set_enable();
	if (rc < 0) {
8545 8546
		pr_err("fan watchdog: error %d while enabling fan, will try again later...\n",
		       rc);
8547 8548 8549 8550
		/* reschedule for later */
		fan_watchdog_reset();
	}
}
8551

8552 8553 8554 8555 8556 8557 8558 8559 8560 8561 8562 8563 8564 8565 8566 8567 8568 8569 8570 8571 8572 8573 8574 8575 8576 8577 8578 8579 8580 8581 8582 8583 8584 8585 8586 8587 8588 8589 8590 8591 8592 8593
/*
 * 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 (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);
}
8594

8595 8596 8597 8598 8599 8600 8601 8602 8603 8604
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;

8605 8606 8607
	tpacpi_disclose_usertask("hwmon pwm1_enable",
			"set fan mode to %lu\n", t);

8608 8609 8610 8611 8612 8613 8614 8615 8616 8617 8618 8619 8620
	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;
8621
	default:
8622
		return -EINVAL;
8623
	}
8624 8625 8626 8627 8628 8629 8630 8631 8632 8633

	res = fan_set_level_safe(level);
	if (res == -ENXIO)
		return -EINVAL;
	else if (res < 0)
		return res;

	fan_watchdog_reset();

	return count;
8634 8635
}

8636 8637
static DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
		   fan_pwm1_enable_show, fan_pwm1_enable_store);
8638 8639 8640 8641 8642

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

8647 8648 8649
	res = fan_get_status_safe(&status);
	if (res)
		return res;
8650

8651 8652 8653
	if ((status &
	     (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) != 0)
		status = fan_control_desired_level;
8654

8655 8656
	if (status > 7)
		status = 7;
8657

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

8661 8662 8663
static ssize_t fan_pwm1_store(struct device *dev,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
8664
{
8665
	unsigned long s;
8666
	int rc;
8667
	u8 status, newlevel;
8668

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

8672 8673 8674
	tpacpi_disclose_usertask("hwmon pwm1",
			"set fan speed to %lu\n", s);

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

8678
	if (mutex_lock_killable(&fan_mutex))
8679
		return -ERESTARTSYS;
8680

8681 8682 8683 8684 8685 8686 8687 8688 8689
	rc = fan_get_status(&status);
	if (!rc && (status &
		    (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) == 0) {
		rc = fan_set_level(newlevel);
		if (rc == -ENXIO)
			rc = -EINVAL;
		else if (!rc) {
			fan_update_desired_level(newlevel);
			fan_watchdog_reset();
8690
		}
8691
	}
8692

8693
	mutex_unlock(&fan_mutex);
8694
	return (rc) ? rc : count;
8695
}
8696

8697
static DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, fan_pwm1_show, fan_pwm1_store);
8698

8699 8700 8701 8702 8703 8704 8705
/* 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;
8706

8707 8708 8709
	res = fan_get_speed(&speed);
	if (res < 0)
		return res;
8710

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

8714
static DEVICE_ATTR(fan1_input, S_IRUGO, fan_fan1_input_show, NULL);
8715

8716 8717 8718 8719 8720 8721 8722 8723 8724 8725 8726 8727 8728 8729 8730
/* sysfs fan fan2_input ------------------------------------------------ */
static ssize_t fan_fan2_input_show(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	int res;
	unsigned int speed;

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

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

8731
static DEVICE_ATTR(fan2_input, S_IRUGO, fan_fan2_input_show, NULL);
8732

8733
/* sysfs fan fan_watchdog (hwmon driver) ------------------------------- */
8734
static ssize_t fan_watchdog_show(struct device_driver *drv, char *buf)
8735 8736
{
	return snprintf(buf, PAGE_SIZE, "%u\n", fan_watchdog_maxinterval);
8737 8738
}

8739 8740
static ssize_t fan_watchdog_store(struct device_driver *drv, const char *buf,
				  size_t count)
8741
{
8742 8743 8744 8745
	unsigned long t;

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

8747 8748 8749
	if (!fan_control_allowed)
		return -EPERM;

8750 8751
	fan_watchdog_maxinterval = t;
	fan_watchdog_reset();
8752

8753 8754
	tpacpi_disclose_usertask("fan_watchdog", "set to %lu\n", t);

8755 8756
	return count;
}
8757
static DRIVER_ATTR_RW(fan_watchdog);
8758 8759 8760

/* --------------------------------------------------------------------- */
static struct attribute *fan_attributes[] = {
8761 8762
	&dev_attr_pwm1_enable.attr, &dev_attr_pwm1.attr,
	&dev_attr_fan1_input.attr,
8763
	NULL, /* for fan2_input */
8764 8765 8766 8767 8768 8769 8770
	NULL
};

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

8771
#define TPACPI_FAN_Q1	0x0001		/* Unitialized HFSP */
8772
#define TPACPI_FAN_2FAN	0x0002		/* EC 0x31 bit 0 selects fan2 */
8773
#define TPACPI_FAN_2CTL	0x0004		/* selects fan2 control */
8774 8775

static const struct tpacpi_quirk fan_quirk_table[] __initconst = {
8776 8777 8778 8779 8780 8781
	TPACPI_QEC_IBM('1', 'Y', TPACPI_FAN_Q1),
	TPACPI_QEC_IBM('7', '8', TPACPI_FAN_Q1),
	TPACPI_QEC_IBM('7', '6', TPACPI_FAN_Q1),
	TPACPI_QEC_IBM('7', '0', TPACPI_FAN_Q1),
	TPACPI_QEC_LNV('7', 'M', TPACPI_FAN_2FAN),
	TPACPI_Q_LNV('N', '1', TPACPI_FAN_2FAN),
8782 8783 8784 8785 8786
	TPACPI_Q_LNV3('N', '1', 'D', TPACPI_FAN_2CTL),	/* P70 */
	TPACPI_Q_LNV3('N', '1', 'E', TPACPI_FAN_2CTL),	/* P50 */
	TPACPI_Q_LNV3('N', '1', 'T', TPACPI_FAN_2CTL),	/* P71 */
	TPACPI_Q_LNV3('N', '1', 'U', TPACPI_FAN_2CTL),	/* P51 */
	TPACPI_Q_LNV3('N', '2', 'C', TPACPI_FAN_2CTL),	/* P52 / P72 */
8787
	TPACPI_Q_LNV3('N', '2', 'N', TPACPI_FAN_2CTL),	/* P53 / P73 */
8788 8789
	TPACPI_Q_LNV3('N', '2', 'E', TPACPI_FAN_2CTL),	/* P1 / X1 Extreme (1st gen) */
	TPACPI_Q_LNV3('N', '2', 'O', TPACPI_FAN_2CTL),	/* P1 / X1 Extreme (2nd gen) */
8790
	TPACPI_Q_LNV3('N', '2', 'V', TPACPI_FAN_2CTL),	/* P1 / X1 Extreme (3nd gen) */
8791
	TPACPI_Q_LNV3('N', '3', '0', TPACPI_FAN_2CTL),	/* P15 (1st gen) / P15v (1st gen) */
8792 8793
};

8794 8795 8796
static int __init fan_init(struct ibm_init_struct *iibm)
{
	int rc;
8797
	unsigned long quirks;
8798

8799 8800
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_FAN,
			"initializing fan subdriver\n");
8801 8802 8803 8804 8805 8806 8807

	mutex_init(&fan_mutex);
	fan_status_access_mode = TPACPI_FAN_NONE;
	fan_control_access_mode = TPACPI_FAN_WR_NONE;
	fan_control_commands = 0;
	fan_watchdog_maxinterval = 0;
	tp_features.fan_ctrl_status_undef = 0;
8808
	tp_features.second_fan = 0;
8809
	tp_features.second_fan_ctl = 0;
8810 8811
	fan_control_desired_level = 7;

8812 8813 8814 8815 8816
	if (tpacpi_is_ibm()) {
		TPACPI_ACPIHANDLE_INIT(fans);
		TPACPI_ACPIHANDLE_INIT(gfan);
		TPACPI_ACPIHANDLE_INIT(sfan);
	}
8817

8818 8819 8820
	quirks = tpacpi_check_quirks(fan_quirk_table,
				     ARRAY_SIZE(fan_quirk_table));

8821 8822 8823 8824 8825 8826 8827 8828 8829
	if (gfan_handle) {
		/* 570, 600e/x, 770e, 770x */
		fan_status_access_mode = TPACPI_FAN_RD_ACPI_GFAN;
	} else {
		/* all other ThinkPads: note that even old-style
		 * ThinkPad ECs supports the fan control register */
		if (likely(acpi_ec_read(fan_status_offset,
					&fan_control_initial_status))) {
			fan_status_access_mode = TPACPI_FAN_RD_TPEC;
8830 8831
			if (quirks & TPACPI_FAN_Q1)
				fan_quirk1_setup();
8832 8833
			if (quirks & TPACPI_FAN_2FAN) {
				tp_features.second_fan = 1;
8834 8835 8836 8837 8838 8839
				pr_info("secondary fan support enabled\n");
			}
			if (quirks & TPACPI_FAN_2CTL) {
				tp_features.second_fan = 1;
				tp_features.second_fan_ctl = 1;
				pr_info("secondary fan control enabled\n");
8840
			}
8841
		} else {
8842
			pr_err("ThinkPad ACPI EC access misbehaving, fan status and control unavailable\n");
8843 8844 8845 8846 8847 8848 8849 8850 8851 8852 8853 8854 8855 8856 8857 8858 8859 8860 8861 8862 8863 8864 8865 8866 8867 8868 8869 8870
			return 1;
		}
	}

	if (sfan_handle) {
		/* 570, 770x-JL */
		fan_control_access_mode = TPACPI_FAN_WR_ACPI_SFAN;
		fan_control_commands |=
		    TPACPI_FAN_CMD_LEVEL | TPACPI_FAN_CMD_ENABLE;
	} else {
		if (!gfan_handle) {
			/* gfan without sfan means no fan control */
			/* all other models implement TP EC 0x2f control */

			if (fans_handle) {
				/* X31, X40, X41 */
				fan_control_access_mode =
				    TPACPI_FAN_WR_ACPI_FANS;
				fan_control_commands |=
				    TPACPI_FAN_CMD_SPEED |
				    TPACPI_FAN_CMD_LEVEL |
				    TPACPI_FAN_CMD_ENABLE;
			} else {
				fan_control_access_mode = TPACPI_FAN_WR_TPEC;
				fan_control_commands |=
				    TPACPI_FAN_CMD_LEVEL |
				    TPACPI_FAN_CMD_ENABLE;
			}
8871
		}
8872
	}
8873

8874 8875
	vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_FAN,
		"fan is %s, modes %d, %d\n",
8876 8877 8878
		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);
8879

8880 8881 8882 8883
	/* fan control master switch */
	if (!fan_control_allowed) {
		fan_control_access_mode = TPACPI_FAN_WR_NONE;
		fan_control_commands = 0;
8884
		dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_FAN,
8885
			   "fan control features disabled by parameter\n");
8886
	}
8887

8888 8889 8890
	/* update fan_control_desired_level */
	if (fan_status_access_mode != TPACPI_FAN_NONE)
		fan_get_status_safe(NULL);
8891

8892 8893
	if (fan_status_access_mode != TPACPI_FAN_NONE ||
	    fan_control_access_mode != TPACPI_FAN_WR_NONE) {
8894 8895 8896
		if (tp_features.second_fan) {
			/* attach second fan tachometer */
			fan_attributes[ARRAY_SIZE(fan_attributes)-2] =
8897
					&dev_attr_fan2_input.attr;
8898
		}
8899
		rc = sysfs_create_group(&tpacpi_hwmon->kobj,
8900 8901 8902
					 &fan_attr_group);
		if (rc < 0)
			return rc;
8903 8904 8905 8906

		rc = driver_create_file(&tpacpi_hwmon_pdriver.driver,
					&driver_attr_fan_watchdog);
		if (rc < 0) {
8907
			sysfs_remove_group(&tpacpi_hwmon->kobj,
8908 8909 8910
					&fan_attr_group);
			return rc;
		}
8911 8912 8913
		return 0;
	} else
		return 1;
8914 8915
}

8916
static void fan_exit(void)
8917
{
8918
	vdbg_printk(TPACPI_DBG_EXIT | TPACPI_DBG_FAN,
8919
		    "cancelling any pending fan watchdog tasks\n");
8920

8921
	/* FIXME: can we really do this unconditionally? */
8922
	sysfs_remove_group(&tpacpi_hwmon->kobj, &fan_attr_group);
8923 8924
	driver_remove_file(&tpacpi_hwmon_pdriver.driver,
			   &driver_attr_fan_watchdog);
8925

8926
	cancel_delayed_work(&fan_watchdog_task);
8927
	flush_workqueue(tpacpi_wq);
8928 8929
}

8930
static void fan_suspend(void)
8931
{
8932 8933
	int rc;

8934 8935 8936 8937
	if (!fan_control_allowed)
		return;

	/* Store fan status in cache */
8938 8939 8940
	fan_control_resume_level = 0;
	rc = fan_get_status_safe(&fan_control_resume_level);
	if (rc < 0)
8941 8942
		pr_notice("failed to read fan level for later restore during resume: %d\n",
			  rc);
8943 8944 8945

	/* if it is undefined, don't attempt to restore it.
	 * KEEP THIS LAST */
8946
	if (tp_features.fan_ctrl_status_undef)
8947
		fan_control_resume_level = 0;
8948 8949 8950 8951 8952 8953
}

static void fan_resume(void)
{
	u8 current_level = 7;
	bool do_set = false;
8954
	int rc;
8955 8956 8957 8958 8959

	/* DSDT *always* updates status on resume */
	tp_features.fan_ctrl_status_undef = 0;

	if (!fan_control_allowed ||
8960
	    !fan_control_resume_level ||
8961 8962 8963 8964 8965
	    (fan_get_status_safe(&current_level) < 0))
		return;

	switch (fan_control_access_mode) {
	case TPACPI_FAN_WR_ACPI_SFAN:
8966 8967
		/* never decrease fan level */
		do_set = (fan_control_resume_level > current_level);
8968 8969 8970
		break;
	case TPACPI_FAN_WR_ACPI_FANS:
	case TPACPI_FAN_WR_TPEC:
8971 8972 8973 8974 8975 8976 8977 8978 8979 8980 8981 8982 8983 8984 8985 8986 8987 8988 8989 8990 8991
		/* never decrease fan level, scale is:
		 * TP_EC_FAN_FULLSPEED > 7 >= TP_EC_FAN_AUTO
		 *
		 * We expect the firmware to set either 7 or AUTO, but we
		 * handle FULLSPEED out of paranoia.
		 *
		 * So, we can safely only restore FULLSPEED or 7, anything
		 * else could slow the fan.  Restoring AUTO is useless, at
		 * best that's exactly what the DSDT already set (it is the
		 * slower it uses).
		 *
		 * Always keep in mind that the DSDT *will* have set the
		 * fans to what the vendor supposes is the best level.  We
		 * muck with it only to speed the fan up.
		 */
		if (fan_control_resume_level != 7 &&
		    !(fan_control_resume_level & TP_EC_FAN_FULLSPEED))
			return;
		else
			do_set = !(current_level & TP_EC_FAN_FULLSPEED) &&
				 (current_level != fan_control_resume_level);
8992 8993 8994 8995 8996
		break;
	default:
		return;
	}
	if (do_set) {
8997 8998
		pr_notice("restoring fan level to 0x%02x\n",
			  fan_control_resume_level);
8999 9000
		rc = fan_set_level_safe(fan_control_resume_level);
		if (rc < 0)
9001
			pr_notice("failed to restore fan level: %d\n", rc);
9002 9003 9004
	}
}

9005
static int fan_read(struct seq_file *m)
9006 9007 9008 9009 9010 9011
{
	int rc;
	u8 status;
	unsigned int speed = 0;

	switch (fan_status_access_mode) {
9012
	case TPACPI_FAN_RD_ACPI_GFAN:
9013
		/* 570, 600e/x, 770e, 770x */
9014 9015
		rc = fan_get_status_safe(&status);
		if (rc < 0)
9016 9017
			return rc;

9018
		seq_printf(m, "status:\t\t%s\n"
9019 9020 9021 9022
			       "level:\t\t%d\n",
			       (status != 0) ? "enabled" : "disabled", status);
		break;

9023
	case TPACPI_FAN_RD_TPEC:
9024
		/* all except 570, 600e/x, 770e, 770x */
9025 9026
		rc = fan_get_status_safe(&status);
		if (rc < 0)
9027 9028
			return rc;

9029
		seq_printf(m, "status:\t\t%s\n",
9030 9031
			       (status != 0) ? "enabled" : "disabled");

9032 9033
		rc = fan_get_speed(&speed);
		if (rc < 0)
9034 9035
			return rc;

9036
		seq_printf(m, "speed:\t\t%d\n", speed);
9037

9038
		if (status & TP_EC_FAN_FULLSPEED)
9039
			/* Disengaged mode takes precedence */
9040
			seq_printf(m, "level:\t\tdisengaged\n");
9041
		else if (status & TP_EC_FAN_AUTO)
9042
			seq_printf(m, "level:\t\tauto\n");
9043
		else
9044
			seq_printf(m, "level:\t\t%d\n", status);
9045 9046
		break;

9047
	case TPACPI_FAN_NONE:
9048
	default:
9049
		seq_printf(m, "status:\t\tnot supported\n");
9050 9051
	}

9052
	if (fan_control_commands & TPACPI_FAN_CMD_LEVEL) {
9053
		seq_printf(m, "commands:\tlevel <level>");
9054 9055

		switch (fan_control_access_mode) {
9056
		case TPACPI_FAN_WR_ACPI_SFAN:
9057
			seq_printf(m, " (<level> is 0-7)\n");
9058 9059 9060
			break;

		default:
9061
			seq_printf(m, " (<level> is 0-7, auto, disengaged, full-speed)\n");
9062 9063 9064
			break;
		}
	}
9065

9066
	if (fan_control_commands & TPACPI_FAN_CMD_ENABLE)
9067
		seq_printf(m, "commands:\tenable, disable\n"
9068
			       "commands:\twatchdog <timeout> (<timeout> is 0 (off), 1-120 (seconds))\n");
L
Linus Torvalds 已提交
9069

9070
	if (fan_control_commands & TPACPI_FAN_CMD_SPEED)
9071
		seq_printf(m, "commands:\tspeed <speed> (<speed> is 0-65535)\n");
9072

9073
	return 0;
9074 9075
}

9076 9077 9078 9079
static int fan_write_cmd_level(const char *cmd, int *rc)
{
	int level;

9080
	if (strlencmp(cmd, "level auto") == 0)
9081
		level = TP_EC_FAN_AUTO;
9082
	else if ((strlencmp(cmd, "level disengaged") == 0) |
9083
			(strlencmp(cmd, "level full-speed") == 0))
9084
		level = TP_EC_FAN_FULLSPEED;
9085
	else if (sscanf(cmd, "level %d", &level) != 1)
9086 9087
		return 0;

9088 9089
	*rc = fan_set_level_safe(level);
	if (*rc == -ENXIO)
9090 9091
		pr_err("level command accepted for unsupported access mode %d\n",
		       fan_control_access_mode);
9092 9093 9094
	else if (!*rc)
		tpacpi_disclose_usertask("procfs fan",
			"set level to %d\n", level);
9095 9096 9097 9098 9099 9100 9101 9102 9103

	return 1;
}

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

9104 9105
	*rc = fan_set_enable();
	if (*rc == -ENXIO)
9106 9107
		pr_err("enable command accepted for unsupported access mode %d\n",
		       fan_control_access_mode);
9108 9109
	else if (!*rc)
		tpacpi_disclose_usertask("procfs fan", "enable\n");
9110 9111 9112 9113 9114 9115 9116 9117 9118

	return 1;
}

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

9119 9120
	*rc = fan_set_disable();
	if (*rc == -ENXIO)
9121 9122
		pr_err("disable command accepted for unsupported access mode %d\n",
		       fan_control_access_mode);
9123 9124
	else if (!*rc)
		tpacpi_disclose_usertask("procfs fan", "disable\n");
9125 9126 9127 9128 9129 9130 9131 9132

	return 1;
}

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

9133 9134 9135
	/* TODO:
	 * Support speed <low> <medium> <high> ? */

9136 9137 9138
	if (sscanf(cmd, "speed %d", &speed) != 1)
		return 0;

9139 9140
	*rc = fan_set_speed(speed);
	if (*rc == -ENXIO)
9141 9142
		pr_err("speed command accepted for unsupported access mode %d\n",
		       fan_control_access_mode);
9143 9144 9145
	else if (!*rc)
		tpacpi_disclose_usertask("procfs fan",
			"set speed to %d\n", speed);
9146 9147 9148 9149

	return 1;
}

9150 9151 9152 9153 9154 9155 9156 9157 9158
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;
9159
	else {
9160
		fan_watchdog_maxinterval = interval;
9161 9162 9163 9164
		tpacpi_disclose_usertask("procfs fan",
			"set watchdog timer to %d\n",
			interval);
	}
9165 9166 9167 9168

	return 1;
}

9169 9170 9171 9172 9173
static int fan_write(char *buf)
{
	char *cmd;
	int rc = 0;

9174
	while (!rc && (cmd = strsep(&buf, ","))) {
9175
		if (!((fan_control_commands & TPACPI_FAN_CMD_LEVEL) &&
9176
		      fan_write_cmd_level(cmd, &rc)) &&
9177
		    !((fan_control_commands & TPACPI_FAN_CMD_ENABLE) &&
9178
		      (fan_write_cmd_enable(cmd, &rc) ||
9179 9180
		       fan_write_cmd_disable(cmd, &rc) ||
		       fan_write_cmd_watchdog(cmd, &rc))) &&
9181
		    !((fan_control_commands & TPACPI_FAN_CMD_SPEED) &&
9182 9183 9184
		      fan_write_cmd_speed(cmd, &rc))
		    )
			rc = -EINVAL;
9185 9186
		else if (!rc)
			fan_watchdog_reset();
9187 9188 9189 9190 9191
	}

	return rc;
}

9192 9193 9194 9195 9196
static struct ibm_struct fan_driver_data = {
	.name = "fan",
	.read = fan_read,
	.write = fan_write,
	.exit = fan_exit,
9197 9198
	.suspend = fan_suspend,
	.resume = fan_resume,
9199 9200
};

9201 9202 9203 9204
/*************************************************************************
 * Mute LED subdriver
 */

9205
#define TPACPI_LED_MAX		2
9206 9207 9208 9209 9210 9211 9212 9213

struct tp_led_table {
	acpi_string name;
	int on_value;
	int off_value;
	int state;
};

9214 9215
static struct tp_led_table led_tables[TPACPI_LED_MAX] = {
	[LED_AUDIO_MUTE] = {
9216 9217 9218 9219
		.name = "SSMS",
		.on_value = 1,
		.off_value = 0,
	},
9220
	[LED_AUDIO_MICMUTE] = {
9221 9222 9223 9224 9225 9226 9227 9228 9229 9230 9231
		.name = "MMTS",
		.on_value = 2,
		.off_value = 0,
	},
};

static int mute_led_on_off(struct tp_led_table *t, bool state)
{
	acpi_handle temp;
	int output;

9232
	if (ACPI_FAILURE(acpi_get_handle(hkey_handle, t->name, &temp))) {
9233 9234 9235 9236 9237 9238 9239 9240 9241 9242 9243 9244
		pr_warn("Thinkpad ACPI has no %s interface.\n", t->name);
		return -EIO;
	}

	if (!acpi_evalf(hkey_handle, &output, t->name, "dd",
			state ? t->on_value : t->off_value))
		return -EIO;

	t->state = state;
	return state;
}

9245
static int tpacpi_led_set(int whichled, bool on)
9246 9247 9248 9249 9250 9251 9252 9253 9254
{
	struct tp_led_table *t;

	t = &led_tables[whichled];
	if (t->state < 0 || t->state == on)
		return t->state;
	return mute_led_on_off(t, on);
}

9255 9256 9257
static int tpacpi_led_mute_set(struct led_classdev *led_cdev,
			       enum led_brightness brightness)
{
9258
	return tpacpi_led_set(LED_AUDIO_MUTE, brightness != LED_OFF);
9259 9260 9261 9262 9263
}

static int tpacpi_led_micmute_set(struct led_classdev *led_cdev,
				  enum led_brightness brightness)
{
9264
	return tpacpi_led_set(LED_AUDIO_MICMUTE, brightness != LED_OFF);
9265 9266
}

9267 9268
static struct led_classdev mute_led_cdev[TPACPI_LED_MAX] = {
	[LED_AUDIO_MUTE] = {
9269 9270 9271 9272 9273
		.name		= "platform::mute",
		.max_brightness = 1,
		.brightness_set_blocking = tpacpi_led_mute_set,
		.default_trigger = "audio-mute",
	},
9274
	[LED_AUDIO_MICMUTE] = {
9275 9276 9277 9278 9279 9280
		.name		= "platform::micmute",
		.max_brightness = 1,
		.brightness_set_blocking = tpacpi_led_micmute_set,
		.default_trigger = "audio-micmute",
	},
};
9281 9282 9283 9284

static int mute_led_init(struct ibm_init_struct *iibm)
{
	acpi_handle temp;
9285
	int i, err;
9286 9287 9288

	for (i = 0; i < TPACPI_LED_MAX; i++) {
		struct tp_led_table *t = &led_tables[i];
9289
		if (ACPI_FAILURE(acpi_get_handle(hkey_handle, t->name, &temp))) {
9290
			t->state = -ENODEV;
9291 9292 9293
			continue;
		}

9294
		mute_led_cdev[i].brightness = ledtrig_audio_get(i);
9295 9296
		err = led_classdev_register(&tpacpi_pdev->dev, &mute_led_cdev[i]);
		if (err < 0) {
9297 9298
			while (i--)
				led_classdev_unregister(&mute_led_cdev[i]);
9299 9300
			return err;
		}
9301 9302 9303 9304 9305 9306 9307 9308
	}
	return 0;
}

static void mute_led_exit(void)
{
	int i;

9309
	for (i = 0; i < TPACPI_LED_MAX; i++) {
9310 9311
		led_classdev_unregister(&mute_led_cdev[i]);
		tpacpi_led_set(i, false);
9312
	}
9313 9314
}

9315 9316 9317 9318 9319 9320 9321 9322 9323 9324 9325
static void mute_led_resume(void)
{
	int i;

	for (i = 0; i < TPACPI_LED_MAX; i++) {
		struct tp_led_table *t = &led_tables[i];
		if (t->state >= 0)
			mute_led_on_off(t, t->state);
	}
}

9326 9327 9328
static struct ibm_struct mute_led_driver_data = {
	.name = "mute_led",
	.exit = mute_led_exit,
9329
	.resume = mute_led_resume,
9330 9331
};

9332 9333 9334 9335 9336 9337 9338 9339 9340 9341 9342 9343 9344 9345 9346 9347 9348 9349 9350 9351 9352 9353 9354 9355 9356 9357 9358 9359 9360 9361 9362 9363 9364 9365 9366 9367 9368 9369 9370 9371 9372 9373 9374 9375 9376 9377 9378 9379 9380 9381 9382 9383 9384 9385 9386 9387 9388 9389 9390 9391 9392 9393 9394 9395 9396 9397 9398 9399 9400 9401 9402 9403 9404 9405 9406 9407 9408 9409 9410 9411 9412 9413 9414 9415 9416 9417 9418 9419 9420 9421 9422 9423 9424 9425 9426 9427 9428 9429 9430 9431 9432 9433 9434 9435 9436 9437 9438 9439 9440 9441 9442 9443 9444 9445 9446 9447 9448 9449 9450 9451 9452 9453 9454 9455 9456 9457 9458 9459 9460
/*
 * Battery Wear Control Driver
 * Contact: Ognjen Galic <smclt30p@gmail.com>
 */

/* Metadata */

#define GET_START	"BCTG"
#define SET_START	"BCCS"
#define GET_STOP	"BCSG"
#define SET_STOP	"BCSS"

enum {
	BAT_ANY = 0,
	BAT_PRIMARY = 1,
	BAT_SECONDARY = 2
};

enum {
	/* Error condition bit */
	METHOD_ERR = BIT(31),
};

enum {
	/* This is used in the get/set helpers */
	THRESHOLD_START,
	THRESHOLD_STOP,
};

struct tpacpi_battery_data {
	int charge_start;
	int start_support;
	int charge_stop;
	int stop_support;
};

struct tpacpi_battery_driver_data {
	struct tpacpi_battery_data batteries[3];
	int individual_addressing;
};

static struct tpacpi_battery_driver_data battery_info;

/* ACPI helpers/functions/probes */

/**
 * This evaluates a ACPI method call specific to the battery
 * ACPI extension. The specifics are that an error is marked
 * in the 32rd bit of the response, so we just check that here.
 */
static acpi_status tpacpi_battery_acpi_eval(char *method, int *ret, int param)
{
	int response;

	if (!acpi_evalf(hkey_handle, &response, method, "dd", param)) {
		acpi_handle_err(hkey_handle, "%s: evaluate failed", method);
		return AE_ERROR;
	}
	if (response & METHOD_ERR) {
		acpi_handle_err(hkey_handle,
				"%s evaluated but flagged as error", method);
		return AE_ERROR;
	}
	*ret = response;
	return AE_OK;
}

static int tpacpi_battery_get(int what, int battery, int *ret)
{
	switch (what) {
	case THRESHOLD_START:
		if ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_START, ret, battery))
			return -ENODEV;

		/* The value is in the low 8 bits of the response */
		*ret = *ret & 0xFF;
		return 0;
	case THRESHOLD_STOP:
		if ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_STOP, ret, battery))
			return -ENODEV;
		/* Value is in lower 8 bits */
		*ret = *ret & 0xFF;
		/*
		 * On the stop value, if we return 0 that
		 * does not make any sense. 0 means Default, which
		 * means that charging stops at 100%, so we return
		 * that.
		 */
		if (*ret == 0)
			*ret = 100;
		return 0;
	default:
		pr_crit("wrong parameter: %d", what);
		return -EINVAL;
	}
}

static int tpacpi_battery_set(int what, int battery, int value)
{
	int param, ret;
	/* The first 8 bits are the value of the threshold */
	param = value;
	/* The battery ID is in bits 8-9, 2 bits */
	param |= battery << 8;

	switch (what) {
	case THRESHOLD_START:
		if ACPI_FAILURE(tpacpi_battery_acpi_eval(SET_START, &ret, param)) {
			pr_err("failed to set charge threshold on battery %d",
					battery);
			return -ENODEV;
		}
		return 0;
	case THRESHOLD_STOP:
		if ACPI_FAILURE(tpacpi_battery_acpi_eval(SET_STOP, &ret, param)) {
			pr_err("failed to set stop threshold: %d", battery);
			return -ENODEV;
		}
		return 0;
	default:
		pr_crit("wrong parameter: %d", what);
		return -EINVAL;
	}
}

static int tpacpi_battery_probe(int battery)
{
	int ret = 0;

9461 9462 9463
	memset(&battery_info.batteries[battery], 0,
		sizeof(battery_info.batteries[battery]));

9464 9465 9466 9467 9468 9469 9470 9471 9472 9473 9474 9475 9476 9477 9478 9479 9480 9481 9482 9483 9484 9485 9486 9487 9488 9489 9490 9491 9492 9493 9494 9495 9496 9497 9498 9499 9500 9501 9502 9503 9504 9505 9506 9507 9508 9509 9510 9511 9512 9513 9514 9515 9516 9517
	/*
	 * 1) Get the current start threshold
	 * 2) Check for support
	 * 3) Get the current stop threshold
	 * 4) Check for support
	 */
	if (acpi_has_method(hkey_handle, GET_START)) {
		if ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_START, &ret, battery)) {
			pr_err("Error probing battery %d\n", battery);
			return -ENODEV;
		}
		/* Individual addressing is in bit 9 */
		if (ret & BIT(9))
			battery_info.individual_addressing = true;
		/* Support is marked in bit 8 */
		if (ret & BIT(8))
			battery_info.batteries[battery].start_support = 1;
		else
			return -ENODEV;
		if (tpacpi_battery_get(THRESHOLD_START, battery,
			&battery_info.batteries[battery].charge_start)) {
			pr_err("Error probing battery %d\n", battery);
			return -ENODEV;
		}
	}
	if (acpi_has_method(hkey_handle, GET_STOP)) {
		if ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_STOP, &ret, battery)) {
			pr_err("Error probing battery stop; %d\n", battery);
			return -ENODEV;
		}
		/* Support is marked in bit 8 */
		if (ret & BIT(8))
			battery_info.batteries[battery].stop_support = 1;
		else
			return -ENODEV;
		if (tpacpi_battery_get(THRESHOLD_STOP, battery,
			&battery_info.batteries[battery].charge_stop)) {
			pr_err("Error probing battery stop: %d\n", battery);
			return -ENODEV;
		}
	}
	pr_info("battery %d registered (start %d, stop %d)",
			battery,
			battery_info.batteries[battery].charge_start,
			battery_info.batteries[battery].charge_stop);

	return 0;
}

/* General helper functions */

static int tpacpi_battery_get_id(const char *battery_name)
{

9518 9519
	if (strcmp(battery_name, "BAT0") == 0 ||
	    tp_features.battery_force_primary)
9520 9521 9522 9523 9524 9525 9526 9527 9528 9529 9530 9531 9532 9533 9534 9535 9536 9537 9538 9539 9540 9541 9542 9543 9544 9545 9546 9547 9548 9549 9550 9551 9552 9553 9554 9555 9556 9557 9558 9559 9560 9561 9562 9563 9564 9565 9566
		return BAT_PRIMARY;
	if (strcmp(battery_name, "BAT1") == 0)
		return BAT_SECONDARY;
	/*
	 * If for some reason the battery is not BAT0 nor is it
	 * BAT1, we will assume it's the default, first battery,
	 * AKA primary.
	 */
	pr_warn("unknown battery %s, assuming primary", battery_name);
	return BAT_PRIMARY;
}

/* sysfs interface */

static ssize_t tpacpi_battery_store(int what,
				    struct device *dev,
				    const char *buf, size_t count)
{
	struct power_supply *supply = to_power_supply(dev);
	unsigned long value;
	int battery, rval;
	/*
	 * Some systems have support for more than
	 * one battery. If that is the case,
	 * tpacpi_battery_probe marked that addressing
	 * them individually is supported, so we do that
	 * based on the device struct.
	 *
	 * On systems that are not supported, we assume
	 * the primary as most of the ACPI calls fail
	 * with "Any Battery" as the parameter.
	 */
	if (battery_info.individual_addressing)
		/* BAT_PRIMARY or BAT_SECONDARY */
		battery = tpacpi_battery_get_id(supply->desc->name);
	else
		battery = BAT_PRIMARY;

	rval = kstrtoul(buf, 10, &value);
	if (rval)
		return rval;

	switch (what) {
	case THRESHOLD_START:
		if (!battery_info.batteries[battery].start_support)
			return -ENODEV;
		/* valid values are [0, 99] */
9567
		if (value > 99)
9568 9569 9570 9571 9572 9573 9574 9575 9576 9577 9578 9579 9580 9581 9582 9583 9584 9585 9586 9587 9588 9589 9590 9591 9592 9593 9594 9595 9596 9597 9598 9599 9600 9601 9602 9603 9604 9605 9606 9607 9608 9609 9610 9611 9612 9613 9614 9615 9616 9617 9618 9619 9620 9621 9622 9623 9624 9625 9626 9627 9628
			return -EINVAL;
		if (value > battery_info.batteries[battery].charge_stop)
			return -EINVAL;
		if (tpacpi_battery_set(THRESHOLD_START, battery, value))
			return -ENODEV;
		battery_info.batteries[battery].charge_start = value;
		return count;

	case THRESHOLD_STOP:
		if (!battery_info.batteries[battery].stop_support)
			return -ENODEV;
		/* valid values are [1, 100] */
		if (value < 1 || value > 100)
			return -EINVAL;
		if (value < battery_info.batteries[battery].charge_start)
			return -EINVAL;
		battery_info.batteries[battery].charge_stop = value;
		/*
		 * When 100 is passed to stop, we need to flip
		 * it to 0 as that the EC understands that as
		 * "Default", which will charge to 100%
		 */
		if (value == 100)
			value = 0;
		if (tpacpi_battery_set(THRESHOLD_STOP, battery, value))
			return -EINVAL;
		return count;
	default:
		pr_crit("Wrong parameter: %d", what);
		return -EINVAL;
	}
	return count;
}

static ssize_t tpacpi_battery_show(int what,
				   struct device *dev,
				   char *buf)
{
	struct power_supply *supply = to_power_supply(dev);
	int ret, battery;
	/*
	 * Some systems have support for more than
	 * one battery. If that is the case,
	 * tpacpi_battery_probe marked that addressing
	 * them individually is supported, so we;
	 * based on the device struct.
	 *
	 * On systems that are not supported, we assume
	 * the primary as most of the ACPI calls fail
	 * with "Any Battery" as the parameter.
	 */
	if (battery_info.individual_addressing)
		/* BAT_PRIMARY or BAT_SECONDARY */
		battery = tpacpi_battery_get_id(supply->desc->name);
	else
		battery = BAT_PRIMARY;
	if (tpacpi_battery_get(what, battery, &ret))
		return -ENODEV;
	return sprintf(buf, "%d\n", ret);
}

9629
static ssize_t charge_control_start_threshold_show(struct device *device,
9630 9631 9632 9633 9634 9635
				struct device_attribute *attr,
				char *buf)
{
	return tpacpi_battery_show(THRESHOLD_START, device, buf);
}

9636
static ssize_t charge_control_end_threshold_show(struct device *device,
9637 9638 9639 9640 9641 9642
				struct device_attribute *attr,
				char *buf)
{
	return tpacpi_battery_show(THRESHOLD_STOP, device, buf);
}

9643
static ssize_t charge_control_start_threshold_store(struct device *dev,
9644 9645 9646 9647 9648 9649
				struct device_attribute *attr,
				const char *buf, size_t count)
{
	return tpacpi_battery_store(THRESHOLD_START, dev, buf, count);
}

9650
static ssize_t charge_control_end_threshold_store(struct device *dev,
9651 9652 9653 9654 9655 9656
				struct device_attribute *attr,
				const char *buf, size_t count)
{
	return tpacpi_battery_store(THRESHOLD_STOP, dev, buf, count);
}

9657 9658
static DEVICE_ATTR_RW(charge_control_start_threshold);
static DEVICE_ATTR_RW(charge_control_end_threshold);
9659
static struct device_attribute dev_attr_charge_start_threshold = __ATTR(
9660 9661 9662 9663 9664
	charge_start_threshold,
	0644,
	charge_control_start_threshold_show,
	charge_control_start_threshold_store
);
9665
static struct device_attribute dev_attr_charge_stop_threshold = __ATTR(
9666 9667 9668 9669 9670
	charge_stop_threshold,
	0644,
	charge_control_end_threshold_show,
	charge_control_end_threshold_store
);
9671 9672

static struct attribute *tpacpi_battery_attrs[] = {
9673 9674
	&dev_attr_charge_control_start_threshold.attr,
	&dev_attr_charge_control_end_threshold.attr,
9675 9676 9677 9678 9679 9680 9681 9682 9683 9684 9685 9686 9687 9688 9689 9690 9691 9692 9693 9694 9695 9696 9697 9698 9699 9700 9701 9702 9703 9704 9705 9706 9707 9708
	&dev_attr_charge_start_threshold.attr,
	&dev_attr_charge_stop_threshold.attr,
	NULL,
};

ATTRIBUTE_GROUPS(tpacpi_battery);

/* ACPI battery hooking */

static int tpacpi_battery_add(struct power_supply *battery)
{
	int batteryid = tpacpi_battery_get_id(battery->desc->name);

	if (tpacpi_battery_probe(batteryid))
		return -ENODEV;
	if (device_add_groups(&battery->dev, tpacpi_battery_groups))
		return -ENODEV;
	return 0;
}

static int tpacpi_battery_remove(struct power_supply *battery)
{
	device_remove_groups(&battery->dev, tpacpi_battery_groups);
	return 0;
}

static struct acpi_battery_hook battery_hook = {
	.add_battery = tpacpi_battery_add,
	.remove_battery = tpacpi_battery_remove,
	.name = "ThinkPad Battery Extension",
};

/* Subdriver init/exit */

9709 9710 9711 9712 9713
static const struct tpacpi_quirk battery_quirk_table[] __initconst = {
	/*
	 * Individual addressing is broken on models that expose the
	 * primary battery as BAT1.
	 */
9714 9715 9716
	TPACPI_Q_LNV('J', '7', true),       /* B5400 */
	TPACPI_Q_LNV('J', 'I', true),       /* Thinkpad 11e */
	TPACPI_Q_LNV3('R', '0', 'B', true), /* Thinkpad 11e gen 3 */
9717
	TPACPI_Q_LNV3('R', '0', 'C', true), /* Thinkpad 13 */
9718
	TPACPI_Q_LNV3('R', '0', 'J', true), /* Thinkpad 13 gen 2 */
9719
	TPACPI_Q_LNV3('R', '0', 'K', true), /* Thinkpad 11e gen 4 celeron BIOS */
9720 9721
};

9722 9723
static int __init tpacpi_battery_init(struct ibm_init_struct *ibm)
{
9724 9725
	memset(&battery_info, 0, sizeof(battery_info));

9726 9727 9728 9729
	tp_features.battery_force_primary = tpacpi_check_quirks(
					battery_quirk_table,
					ARRAY_SIZE(battery_quirk_table));

9730 9731 9732 9733 9734 9735 9736 9737 9738 9739 9740 9741 9742 9743
	battery_hook_register(&battery_hook);
	return 0;
}

static void tpacpi_battery_exit(void)
{
	battery_hook_unregister(&battery_hook);
}

static struct ibm_struct battery_driver_data = {
	.name = "battery",
	.exit = tpacpi_battery_exit,
};

9744 9745 9746 9747 9748 9749 9750 9751 9752 9753 9754 9755 9756 9757 9758 9759 9760 9761 9762 9763 9764 9765 9766 9767 9768 9769 9770 9771 9772 9773 9774 9775 9776 9777 9778 9779 9780 9781 9782 9783 9784 9785 9786 9787 9788 9789 9790 9791 9792 9793 9794 9795 9796 9797 9798 9799 9800 9801 9802 9803 9804 9805 9806 9807 9808 9809 9810 9811 9812 9813 9814 9815 9816 9817 9818 9819
/*************************************************************************
 * LCD Shadow subdriver, for the Lenovo PrivacyGuard feature
 */

static int lcdshadow_state;

static int lcdshadow_on_off(bool state)
{
	acpi_handle set_shadow_handle;
	int output;

	if (ACPI_FAILURE(acpi_get_handle(hkey_handle, "SSSS", &set_shadow_handle))) {
		pr_warn("Thinkpad ACPI has no %s interface.\n", "SSSS");
		return -EIO;
	}

	if (!acpi_evalf(set_shadow_handle, &output, NULL, "dd", (int)state))
		return -EIO;

	lcdshadow_state = state;
	return 0;
}

static int lcdshadow_set(bool on)
{
	if (lcdshadow_state < 0)
		return lcdshadow_state;
	if (lcdshadow_state == on)
		return 0;
	return lcdshadow_on_off(on);
}

static int tpacpi_lcdshadow_init(struct ibm_init_struct *iibm)
{
	acpi_handle get_shadow_handle;
	int output;

	if (ACPI_FAILURE(acpi_get_handle(hkey_handle, "GSSS", &get_shadow_handle))) {
		lcdshadow_state = -ENODEV;
		return 0;
	}

	if (!acpi_evalf(get_shadow_handle, &output, NULL, "dd", 0)) {
		lcdshadow_state = -EIO;
		return -EIO;
	}
	if (!(output & 0x10000)) {
		lcdshadow_state = -ENODEV;
		return 0;
	}
	lcdshadow_state = output & 0x1;

	return 0;
}

static void lcdshadow_resume(void)
{
	if (lcdshadow_state >= 0)
		lcdshadow_on_off(lcdshadow_state);
}

static int lcdshadow_read(struct seq_file *m)
{
	if (lcdshadow_state < 0) {
		seq_puts(m, "status:\t\tnot supported\n");
	} else {
		seq_printf(m, "status:\t\t%d\n", lcdshadow_state);
		seq_puts(m, "commands:\t0, 1\n");
	}

	return 0;
}

static int lcdshadow_write(char *buf)
{
	char *cmd;
9820
	int res, state = -EINVAL;
9821 9822 9823 9824

	if (lcdshadow_state < 0)
		return -ENODEV;

9825
	while ((cmd = strsep(&buf, ","))) {
9826 9827 9828
		res = kstrtoint(cmd, 10, &state);
		if (res < 0)
			return res;
9829 9830
	}

9831
	if (state >= 2 || state < 0)
9832 9833 9834 9835 9836 9837 9838 9839 9840 9841 9842 9843
		return -EINVAL;

	return lcdshadow_set(state);
}

static struct ibm_struct lcdshadow_driver_data = {
	.name = "lcdshadow",
	.resume = lcdshadow_resume,
	.read = lcdshadow_read,
	.write = lcdshadow_write,
};

9844
/*************************************************************************
9845
 * Thinkpad sensor interfaces
9846 9847 9848 9849 9850
 */

#define DYTC_CMD_GET          2 /* To get current IC function and mode */
#define DYTC_GET_LAPMODE_BIT 17 /* Set when in lapmode */

9851 9852
#define PALMSENSOR_PRESENT_BIT 0 /* Determine if psensor present */
#define PALMSENSOR_ON_BIT      1 /* psensor status */
9853

9854 9855 9856 9857
static bool has_palmsensor;
static bool has_lapsensor;
static bool palm_state;
static bool lap_state;
9858

9859
static int dytc_command(int command, int *output)
9860 9861 9862
{
	acpi_handle dytc_handle;

9863 9864
	if (ACPI_FAILURE(acpi_get_handle(hkey_handle, "DYTC", &dytc_handle))) {
		/* Platform doesn't support DYTC */
9865
		return -ENODEV;
9866 9867
	}
	if (!acpi_evalf(dytc_handle, output, NULL, "dd", command))
9868
		return -EIO;
9869 9870 9871 9872 9873 9874 9875 9876 9877 9878 9879
	return 0;
}

static int lapsensor_get(bool *present, bool *state)
{
	int output, err;

	*present = false;
	err = dytc_command(DYTC_CMD_GET, &output);
	if (err)
		return err;
9880 9881 9882

	*present = true; /*If we get his far, we have lapmode support*/
	*state = output & BIT(DYTC_GET_LAPMODE_BIT) ? true : false;
9883 9884 9885
	return 0;
}

9886
static int palmsensor_get(bool *present, bool *state)
9887
{
9888 9889
	acpi_handle psensor_handle;
	int output;
9890

9891 9892 9893 9894 9895 9896 9897 9898
	*present = false;
	if (ACPI_FAILURE(acpi_get_handle(hkey_handle, "GPSS", &psensor_handle)))
		return -ENODEV;
	if (!acpi_evalf(psensor_handle, &output, NULL, "d"))
		return -EIO;

	*present = output & BIT(PALMSENSOR_PRESENT_BIT) ? true : false;
	*state = output & BIT(PALMSENSOR_ON_BIT) ? true : false;
9899 9900 9901
	return 0;
}

9902
static void lapsensor_refresh(void)
9903
{
9904
	bool state;
9905 9906
	int err;

9907 9908 9909 9910 9911 9912 9913 9914 9915 9916
	if (has_lapsensor) {
		err = lapsensor_get(&has_lapsensor, &state);
		if (err)
			return;
		if (lap_state != state) {
			lap_state = state;
			sysfs_notify(&tpacpi_pdev->dev.kobj, NULL, "dytc_lapmode");
		}
	}
}
9917

9918 9919 9920 9921 9922 9923 9924 9925 9926 9927 9928 9929 9930 9931
static void palmsensor_refresh(void)
{
	bool state;
	int err;

	if (has_palmsensor) {
		err = palmsensor_get(&has_palmsensor, &state);
		if (err)
			return;
		if (palm_state != state) {
			palm_state = state;
			sysfs_notify(&tpacpi_pdev->dev.kobj, NULL, "palmsensor");
		}
	}
9932 9933 9934 9935 9936 9937
}

static ssize_t dytc_lapmode_show(struct device *dev,
					struct device_attribute *attr,
					char *buf)
{
9938 9939 9940
	if (has_lapsensor)
		return sysfs_emit(buf, "%d\n", lap_state);
	return sysfs_emit(buf, "\n");
9941 9942 9943
}
static DEVICE_ATTR_RO(dytc_lapmode);

9944 9945 9946 9947 9948 9949 9950 9951 9952
static ssize_t palmsensor_show(struct device *dev,
					struct device_attribute *attr,
					char *buf)
{
	if (has_palmsensor)
		return sysfs_emit(buf, "%d\n", palm_state);
	return sysfs_emit(buf, "\n");
}
static DEVICE_ATTR_RO(palmsensor);
9953

9954
static int tpacpi_proxsensor_init(struct ibm_init_struct *iibm)
9955
{
9956
	int palm_err, lap_err, err;
9957

9958 9959 9960 9961 9962
	palm_err = palmsensor_get(&has_palmsensor, &palm_state);
	lap_err = lapsensor_get(&has_lapsensor, &lap_state);
	/*
	 * If support isn't available (ENODEV) for both devices then quit, but
	 * don't return an error.
9963
	 */
9964
	if ((palm_err == -ENODEV) && (lap_err == -ENODEV))
9965
		return 0;
9966
	/* Otherwise, if there was an error return it */
9967
	if (palm_err && (palm_err != -ENODEV))
9968
		return palm_err;
9969
	if (lap_err && (lap_err != -ENODEV))
9970 9971 9972 9973 9974 9975 9976 9977 9978 9979 9980 9981 9982
		return lap_err;

	if (has_palmsensor) {
		err = sysfs_create_file(&tpacpi_pdev->dev.kobj, &dev_attr_palmsensor.attr);
		if (err)
			return err;
	}
	if (has_lapsensor) {
		err = sysfs_create_file(&tpacpi_pdev->dev.kobj, &dev_attr_dytc_lapmode.attr);
		if (err)
			return err;
	}
	return 0;
9983 9984
}

9985
static void proxsensor_exit(void)
9986
{
9987 9988 9989 9990
	if (has_lapsensor)
		sysfs_remove_file(&tpacpi_pdev->dev.kobj, &dev_attr_dytc_lapmode.attr);
	if (has_palmsensor)
		sysfs_remove_file(&tpacpi_pdev->dev.kobj, &dev_attr_palmsensor.attr);
9991 9992
}

9993 9994 9995
static struct ibm_struct proxsensor_driver_data = {
	.name = "proximity-sensor",
	.exit = proxsensor_exit,
9996 9997
};

9998 9999 10000 10001 10002 10003 10004 10005 10006 10007 10008 10009 10010 10011 10012 10013 10014 10015 10016 10017 10018 10019 10020 10021 10022 10023 10024 10025 10026 10027 10028 10029 10030 10031 10032 10033 10034 10035 10036 10037 10038 10039 10040 10041 10042 10043 10044 10045 10046 10047 10048 10049 10050 10051 10052 10053 10054 10055 10056 10057 10058 10059 10060 10061 10062 10063 10064 10065 10066 10067 10068 10069 10070 10071 10072 10073 10074 10075 10076 10077 10078 10079 10080
#if IS_ENABLED(CONFIG_ACPI_PLATFORM_PROFILE)

/*************************************************************************
 * DYTC Platform Profile interface
 */

#define DYTC_CMD_QUERY        0 /* To get DYTC status - enable/revision */
#define DYTC_CMD_SET          1 /* To enable/disable IC function mode */
#define DYTC_CMD_RESET    0x1ff /* To reset back to default */

#define DYTC_QUERY_ENABLE_BIT 8  /* Bit        8 - 0 = disabled, 1 = enabled */
#define DYTC_QUERY_SUBREV_BIT 16 /* Bits 16 - 27 - sub revision */
#define DYTC_QUERY_REV_BIT    28 /* Bits 28 - 31 - revision */

#define DYTC_GET_FUNCTION_BIT 8  /* Bits  8-11 - function setting */
#define DYTC_GET_MODE_BIT     12 /* Bits 12-15 - mode setting */

#define DYTC_SET_FUNCTION_BIT 12 /* Bits 12-15 - function setting */
#define DYTC_SET_MODE_BIT     16 /* Bits 16-19 - mode setting */
#define DYTC_SET_VALID_BIT    20 /* Bit     20 - 1 = on, 0 = off */

#define DYTC_FUNCTION_STD     0  /* Function = 0, standard mode */
#define DYTC_FUNCTION_CQL     1  /* Function = 1, lap mode */
#define DYTC_FUNCTION_MMC     11 /* Function = 11, desk mode */

#define DYTC_MODE_PERFORM     2  /* High power mode aka performance */
#define DYTC_MODE_LOWPOWER    3  /* Low power mode */
#define DYTC_MODE_BALANCE   0xF  /* Default mode aka balanced */

#define DYTC_SET_COMMAND(function, mode, on) \
	(DYTC_CMD_SET | (function) << DYTC_SET_FUNCTION_BIT | \
	 (mode) << DYTC_SET_MODE_BIT | \
	 (on) << DYTC_SET_VALID_BIT)

#define DYTC_DISABLE_CQL DYTC_SET_COMMAND(DYTC_FUNCTION_CQL, DYTC_MODE_BALANCE, 0)

#define DYTC_ENABLE_CQL DYTC_SET_COMMAND(DYTC_FUNCTION_CQL, DYTC_MODE_BALANCE, 1)

static bool dytc_profile_available;
static enum platform_profile_option dytc_current_profile;
static atomic_t dytc_ignore_event = ATOMIC_INIT(0);
static DEFINE_MUTEX(dytc_mutex);

static int convert_dytc_to_profile(int dytcmode, enum platform_profile_option *profile)
{
	switch (dytcmode) {
	case DYTC_MODE_LOWPOWER:
		*profile = PLATFORM_PROFILE_LOW_POWER;
		break;
	case DYTC_MODE_BALANCE:
		*profile =  PLATFORM_PROFILE_BALANCED;
		break;
	case DYTC_MODE_PERFORM:
		*profile =  PLATFORM_PROFILE_PERFORMANCE;
		break;
	default: /* Unknown mode */
		return -EINVAL;
	}
	return 0;
}

static int convert_profile_to_dytc(enum platform_profile_option profile, int *perfmode)
{
	switch (profile) {
	case PLATFORM_PROFILE_LOW_POWER:
		*perfmode = DYTC_MODE_LOWPOWER;
		break;
	case PLATFORM_PROFILE_BALANCED:
		*perfmode = DYTC_MODE_BALANCE;
		break;
	case PLATFORM_PROFILE_PERFORMANCE:
		*perfmode = DYTC_MODE_PERFORM;
		break;
	default: /* Unknown profile */
		return -EOPNOTSUPP;
	}
	return 0;
}

/*
 * dytc_profile_get: Function to register with platform_profile
 * handler. Returns current platform profile.
 */
10081 10082
static int dytc_profile_get(struct platform_profile_handler *pprof,
			    enum platform_profile_option *profile)
10083 10084 10085 10086 10087 10088 10089 10090 10091 10092 10093 10094
{
	*profile = dytc_current_profile;
	return 0;
}

/*
 * Helper function - check if we are in CQL mode and if we are
 *  -  disable CQL,
 *  - run the command
 *  - enable CQL
 *  If not in CQL mode, just run the command
 */
10095
static int dytc_cql_command(int command, int *output)
10096 10097 10098 10099 10100 10101 10102 10103 10104 10105 10106 10107 10108 10109 10110 10111 10112 10113 10114 10115 10116 10117 10118 10119 10120 10121 10122 10123 10124 10125 10126 10127 10128 10129 10130 10131 10132
{
	int err, cmd_err, dummy;
	int cur_funcmode;

	/* Determine if we are in CQL mode. This alters the commands we do */
	err = dytc_command(DYTC_CMD_GET, output);
	if (err)
		return err;

	cur_funcmode = (*output >> DYTC_GET_FUNCTION_BIT) & 0xF;
	/* Check if we're OK to return immediately */
	if ((command == DYTC_CMD_GET) && (cur_funcmode != DYTC_FUNCTION_CQL))
		return 0;

	if (cur_funcmode == DYTC_FUNCTION_CQL) {
		atomic_inc(&dytc_ignore_event);
		err = dytc_command(DYTC_DISABLE_CQL, &dummy);
		if (err)
			return err;
	}

	cmd_err = dytc_command(command,	output);
	/* Check return condition after we've restored CQL state */

	if (cur_funcmode == DYTC_FUNCTION_CQL) {
		err = dytc_command(DYTC_ENABLE_CQL, &dummy);
		if (err)
			return err;
	}

	return cmd_err;
}

/*
 * dytc_profile_set: Function to register with platform_profile
 * handler. Sets current platform profile.
 */
10133 10134
static int dytc_profile_set(struct platform_profile_handler *pprof,
			    enum platform_profile_option profile)
10135 10136 10137 10138 10139 10140 10141 10142 10143 10144 10145 10146 10147 10148 10149 10150 10151 10152 10153 10154 10155 10156 10157 10158 10159 10160 10161 10162 10163 10164 10165 10166 10167 10168 10169 10170 10171 10172 10173 10174 10175 10176 10177 10178 10179 10180 10181 10182 10183 10184 10185 10186 10187 10188 10189 10190 10191 10192 10193 10194 10195 10196 10197 10198 10199 10200 10201 10202 10203 10204 10205 10206 10207 10208 10209 10210 10211 10212 10213 10214 10215 10216 10217 10218 10219 10220 10221 10222 10223 10224 10225 10226 10227 10228 10229 10230 10231 10232 10233 10234 10235 10236 10237 10238 10239 10240 10241 10242 10243 10244 10245 10246 10247 10248 10249 10250 10251 10252 10253 10254 10255
{
	int output;
	int err;

	if (!dytc_profile_available)
		return -ENODEV;

	err = mutex_lock_interruptible(&dytc_mutex);
	if (err)
		return err;

	if (profile == PLATFORM_PROFILE_BALANCED) {
		/* To get back to balanced mode we just issue a reset command */
		err = dytc_command(DYTC_CMD_RESET, &output);
		if (err)
			goto unlock;
	} else {
		int perfmode;

		err = convert_profile_to_dytc(profile, &perfmode);
		if (err)
			goto unlock;

		/* Determine if we are in CQL mode. This alters the commands we do */
		err = dytc_cql_command(DYTC_SET_COMMAND(DYTC_FUNCTION_MMC, perfmode, 1), &output);
		if (err)
			goto unlock;
	}
	/* Success - update current profile */
	dytc_current_profile = profile;
unlock:
	mutex_unlock(&dytc_mutex);
	return err;
}

static void dytc_profile_refresh(void)
{
	enum platform_profile_option profile;
	int output, err;
	int perfmode;

	mutex_lock(&dytc_mutex);
	err = dytc_cql_command(DYTC_CMD_GET, &output);
	mutex_unlock(&dytc_mutex);
	if (err)
		return;

	perfmode = (output >> DYTC_GET_MODE_BIT) & 0xF;
	convert_dytc_to_profile(perfmode, &profile);
	if (profile != dytc_current_profile) {
		dytc_current_profile = profile;
		platform_profile_notify();
	}
}

static struct platform_profile_handler dytc_profile = {
	.profile_get = dytc_profile_get,
	.profile_set = dytc_profile_set,
};

static int tpacpi_dytc_profile_init(struct ibm_init_struct *iibm)
{
	int err, output;

	/* Setup supported modes */
	set_bit(PLATFORM_PROFILE_LOW_POWER, dytc_profile.choices);
	set_bit(PLATFORM_PROFILE_BALANCED, dytc_profile.choices);
	set_bit(PLATFORM_PROFILE_PERFORMANCE, dytc_profile.choices);

	dytc_profile_available = false;
	err = dytc_command(DYTC_CMD_QUERY, &output);
	/*
	 * If support isn't available (ENODEV) then don't return an error
	 * and don't create the sysfs group
	 */
	if (err == -ENODEV)
		return 0;
	/* For all other errors we can flag the failure */
	if (err)
		return err;

	/* Check DYTC is enabled and supports mode setting */
	if (output & BIT(DYTC_QUERY_ENABLE_BIT)) {
		/* Only DYTC v5.0 and later has this feature. */
		int dytc_version;

		dytc_version = (output >> DYTC_QUERY_REV_BIT) & 0xF;
		if (dytc_version >= 5) {
			dbg_printk(TPACPI_DBG_INIT,
				   "DYTC version %d: thermal mode available\n", dytc_version);
			/* Create platform_profile structure and register */
			err = platform_profile_register(&dytc_profile);
			/*
			 * If for some reason platform_profiles aren't enabled
			 * don't quit terminally.
			 */
			if (err)
				return 0;

			dytc_profile_available = true;
			/* Ensure initial values are correct */
			dytc_profile_refresh();
		}
	}
	return 0;
}

static void dytc_profile_exit(void)
{
	if (dytc_profile_available) {
		dytc_profile_available = false;
		platform_profile_remove();
	}
}

static struct ibm_struct  dytc_profile_driver_data = {
	.name = "dytc-profile",
	.exit = dytc_profile_exit,
};
#endif /* CONFIG_ACPI_PLATFORM_PROFILE */

10256 10257 10258 10259 10260 10261 10262 10263 10264
/*************************************************************************
 * Keyboard language interface
 */

struct keyboard_lang_data {
	const char *lang_str;
	int lang_code;
};

10265
static const struct keyboard_lang_data keyboard_lang_data[] = {
10266 10267 10268 10269
	{"be", 0x080c},
	{"cz", 0x0405},
	{"da", 0x0406},
	{"de", 0x0c07},
10270
	{"en", 0x0000},
10271 10272 10273 10274 10275 10276 10277 10278 10279 10280 10281 10282 10283 10284 10285 10286 10287 10288 10289 10290 10291 10292 10293 10294 10295 10296 10297 10298 10299 10300 10301 10302 10303 10304 10305 10306 10307 10308 10309 10310 10311 10312 10313 10314 10315
	{"es", 0x2c0a},
	{"et", 0x0425},
	{"fr", 0x040c},
	{"fr-ch", 0x100c},
	{"hu", 0x040e},
	{"it", 0x0410},
	{"jp", 0x0411},
	{"nl", 0x0413},
	{"nn", 0x0414},
	{"pl", 0x0415},
	{"pt", 0x0816},
	{"sl", 0x041b},
	{"sv", 0x081d},
	{"tr", 0x041f},
};

static int set_keyboard_lang_command(int command)
{
	acpi_handle sskl_handle;
	int output;

	if (ACPI_FAILURE(acpi_get_handle(hkey_handle, "SSKL", &sskl_handle))) {
		/* Platform doesn't support SSKL */
		return -ENODEV;
	}

	if (!acpi_evalf(sskl_handle, &output, NULL, "dd", command))
		return -EIO;

	return 0;
}

static int get_keyboard_lang(int *output)
{
	acpi_handle gskl_handle;
	int kbd_lang;

	if (ACPI_FAILURE(acpi_get_handle(hkey_handle, "GSKL", &gskl_handle))) {
		/* Platform doesn't support GSKL */
		return -ENODEV;
	}

	if (!acpi_evalf(gskl_handle, &kbd_lang, NULL, "dd", 0x02000000))
		return -EIO;

10316 10317 10318 10319 10320 10321 10322
	/*
	 * METHOD_ERR gets returned on devices where there are no special (e.g. '=',
	 * '(' and ')') keys which use layout dependent key-press emulation.
	 */
	if (kbd_lang & METHOD_ERR)
		return -ENODEV;

10323 10324 10325 10326 10327 10328 10329 10330 10331 10332
	*output = kbd_lang;

	return 0;
}

/* sysfs keyboard language entry */
static ssize_t keyboard_lang_show(struct device *dev,
				struct device_attribute *attr,
				char *buf)
{
10333
	int output, err, i, len = 0;
10334 10335 10336 10337 10338 10339 10340

	err = get_keyboard_lang(&output);
	if (err)
		return err;

	for (i = 0; i < ARRAY_SIZE(keyboard_lang_data); i++) {
		if (i)
10341
			len += sysfs_emit_at(buf, len, "%s", " ");
10342 10343

		if (output == keyboard_lang_data[i].lang_code) {
10344
			len += sysfs_emit_at(buf, len, "[%s]", keyboard_lang_data[i].lang_str);
10345
		} else {
10346
			len += sysfs_emit_at(buf, len, "%s", keyboard_lang_data[i].lang_str);
10347 10348
		}
	}
10349
	len += sysfs_emit_at(buf, len, "\n");
10350

10351
	return len;
10352 10353 10354 10355 10356 10357 10358 10359 10360 10361 10362 10363 10364 10365 10366 10367 10368 10369 10370 10371 10372 10373 10374 10375 10376 10377
}

static ssize_t keyboard_lang_store(struct device *dev,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
	int err, i;
	bool lang_found = false;
	int lang_code = 0;

	for (i = 0; i < ARRAY_SIZE(keyboard_lang_data); i++) {
		if (sysfs_streq(buf, keyboard_lang_data[i].lang_str)) {
			lang_code = keyboard_lang_data[i].lang_code;
			lang_found = true;
			break;
		}
	}

	if (lang_found) {
		lang_code = lang_code | 1 << 24;

		/* Set language code */
		err = set_keyboard_lang_command(lang_code);
		if (err)
			return err;
	} else {
10378
		dev_err(&tpacpi_pdev->dev, "Unknown Keyboard language. Ignoring\n");
10379 10380 10381 10382 10383 10384 10385 10386 10387 10388 10389 10390 10391 10392 10393 10394 10395 10396 10397 10398 10399 10400 10401 10402 10403 10404 10405 10406
		return -EINVAL;
	}

	tpacpi_disclose_usertask(attr->attr.name,
			"keyboard language is set to  %s\n", buf);

	sysfs_notify(&tpacpi_pdev->dev.kobj, NULL, "keyboard_lang");

	return count;
}
static DEVICE_ATTR_RW(keyboard_lang);

static struct attribute *kbdlang_attributes[] = {
	&dev_attr_keyboard_lang.attr,
	NULL
};

static const struct attribute_group kbdlang_attr_group = {
	.attrs = kbdlang_attributes,
};

static int tpacpi_kbdlang_init(struct ibm_init_struct *iibm)
{
	int err, output;

	err = get_keyboard_lang(&output);
	/*
	 * If support isn't available (ENODEV) then don't return an error
10407
	 * just don't create the sysfs group.
10408 10409 10410 10411 10412 10413 10414 10415
	 */
	if (err == -ENODEV)
		return 0;

	if (err)
		return err;

	/* Platform supports this feature - create the sysfs file */
10416
	return sysfs_create_group(&tpacpi_pdev->dev.kobj, &kbdlang_attr_group);
10417 10418 10419 10420 10421 10422 10423 10424 10425 10426 10427 10428
}

static void kbdlang_exit(void)
{
	sysfs_remove_group(&tpacpi_pdev->dev.kobj, &kbdlang_attr_group);
}

static struct ibm_struct kbdlang_driver_data = {
	.name = "kbdlang",
	.exit = kbdlang_exit,
};

10429 10430 10431 10432 10433 10434 10435 10436
/****************************************************************************
 ****************************************************************************
 *
 * Infrastructure
 *
 ****************************************************************************
 ****************************************************************************/

10437 10438 10439 10440 10441 10442
/*
 * HKEY event callout for other subdrivers go here
 * (yes, it is ugly, but it is quick, safe, and gets the job done
 */
static void tpacpi_driver_event(const unsigned int hkey_event)
{
10443 10444 10445 10446 10447 10448 10449
	if (ibm_backlight_device) {
		switch (hkey_event) {
		case TP_HKEY_EV_BRGHT_UP:
		case TP_HKEY_EV_BRGHT_DOWN:
			tpacpi_brightness_notify_change();
		}
	}
10450 10451 10452 10453 10454 10455 10456 10457
	if (alsa_card) {
		switch (hkey_event) {
		case TP_HKEY_EV_VOL_UP:
		case TP_HKEY_EV_VOL_DOWN:
		case TP_HKEY_EV_VOL_MUTE:
			volume_alsa_notify_change();
		}
	}
10458 10459 10460 10461 10462 10463 10464 10465 10466 10467 10468 10469 10470 10471 10472 10473 10474 10475
	if (tp_features.kbdlight && hkey_event == TP_HKEY_EV_KBD_LIGHT) {
		enum led_brightness brightness;

		mutex_lock(&kbdlight_mutex);

		/*
		 * Check the brightness actually changed, setting the brightness
		 * through kbdlight_set_level() also triggers this event.
		 */
		brightness = kbdlight_sysfs_get(NULL);
		if (kbdlight_brightness != brightness) {
			kbdlight_brightness = brightness;
			led_classdev_notify_brightness_hw_changed(
				&tpacpi_led_kbdlight.led_classdev, brightness);
		}

		mutex_unlock(&kbdlight_mutex);
	}
10476

10477
	if (hkey_event == TP_HKEY_EV_THM_CSM_COMPLETED) {
10478
		lapsensor_refresh();
10479 10480 10481 10482 10483 10484
#if IS_ENABLED(CONFIG_ACPI_PLATFORM_PROFILE)
		/* If we are already accessing DYTC then skip dytc update */
		if (!atomic_add_unless(&dytc_ignore_event, -1, 0))
			dytc_profile_refresh();
#endif
	}
10485 10486 10487 10488
}

static void hotkey_driver_event(const unsigned int scancode)
{
10489
	tpacpi_driver_event(TP_HKEY_EV_HOTKEY_BASE + scancode);
10490 10491
}

10492 10493
/* --------------------------------------------------------------------- */

10494
/* /proc support */
10495
static struct proc_dir_entry *proc_dir;
10496

10497 10498 10499
/*
 * Module and infrastructure proble, init and exit handling
 */
L
Linus Torvalds 已提交
10500

10501
static bool force_load;
10502

10503
#ifdef CONFIG_THINKPAD_ACPI_DEBUG
10504
static const char * __init str_supported(int is_supported)
10505
{
10506
	static char text_unsupported[] __initdata = "not supported";
10507

10508
	return (is_supported) ? &text_unsupported[4] : &text_unsupported[0];
10509 10510 10511
}
#endif /* CONFIG_THINKPAD_ACPI_DEBUG */

10512 10513 10514 10515 10516 10517 10518 10519 10520 10521 10522 10523 10524 10525 10526 10527 10528 10529 10530 10531 10532 10533 10534 10535 10536 10537 10538 10539 10540 10541 10542 10543 10544 10545 10546 10547 10548 10549 10550 10551
static void ibm_exit(struct ibm_struct *ibm)
{
	dbg_printk(TPACPI_DBG_EXIT, "removing %s\n", ibm->name);

	list_del_init(&ibm->all_drivers);

	if (ibm->flags.acpi_notify_installed) {
		dbg_printk(TPACPI_DBG_EXIT,
			"%s: acpi_remove_notify_handler\n", ibm->name);
		BUG_ON(!ibm->acpi);
		acpi_remove_notify_handler(*ibm->acpi->handle,
					   ibm->acpi->type,
					   dispatch_acpi_notify);
		ibm->flags.acpi_notify_installed = 0;
	}

	if (ibm->flags.proc_created) {
		dbg_printk(TPACPI_DBG_EXIT,
			"%s: remove_proc_entry\n", ibm->name);
		remove_proc_entry(ibm->name, proc_dir);
		ibm->flags.proc_created = 0;
	}

	if (ibm->flags.acpi_driver_registered) {
		dbg_printk(TPACPI_DBG_EXIT,
			"%s: acpi_bus_unregister_driver\n", ibm->name);
		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;
	}

	if (ibm->flags.init_called && ibm->exit) {
		ibm->exit();
		ibm->flags.init_called = 0;
	}

	dbg_printk(TPACPI_DBG_INIT, "finished removing %s\n", ibm->name);
}
10552

10553
static int __init ibm_init(struct ibm_init_struct *iibm)
L
Linus Torvalds 已提交
10554 10555
{
	int ret;
10556
	struct ibm_struct *ibm = iibm->data;
L
Linus Torvalds 已提交
10557 10558
	struct proc_dir_entry *entry;

10559 10560 10561 10562
	BUG_ON(ibm == NULL);

	INIT_LIST_HEAD(&ibm->all_drivers);

10563
	if (ibm->flags.experimental && !experimental)
L
Linus Torvalds 已提交
10564 10565
		return 0;

10566 10567 10568
	dbg_printk(TPACPI_DBG_INIT,
		"probing for %s\n", ibm->name);

10569 10570
	if (iibm->init) {
		ret = iibm->init(iibm);
10571 10572 10573
		if (ret > 0)
			return 0;	/* probe failed */
		if (ret)
L
Linus Torvalds 已提交
10574
			return ret;
10575

10576
		ibm->flags.init_called = 1;
L
Linus Torvalds 已提交
10577 10578
	}

10579 10580 10581 10582 10583 10584
	if (ibm->acpi) {
		if (ibm->acpi->hid) {
			ret = register_tpacpi_subdriver(ibm);
			if (ret)
				goto err_out;
		}
10585

10586 10587 10588
		if (ibm->acpi->notify) {
			ret = setup_acpi_notify(ibm);
			if (ret == -ENODEV) {
10589 10590
				pr_notice("disabling subdriver %s\n",
					  ibm->name);
10591 10592 10593 10594 10595
				ret = 0;
				goto err_out;
			}
			if (ret < 0)
				goto err_out;
10596 10597 10598
		}
	}

10599 10600 10601
	dbg_printk(TPACPI_DBG_INIT,
		"%s installed\n", ibm->name);

10602
	if (ibm->read) {
A
Al Viro 已提交
10603
		umode_t mode = iibm->base_procfs_mode;
10604

10605 10606
		if (!mode)
			mode = S_IRUGO;
10607 10608 10609
		if (ibm->write)
			mode |= S_IWUSR;
		entry = proc_create_data(ibm->name, mode, proc_dir,
10610
					 &dispatch_proc_ops, ibm);
10611
		if (!entry) {
10612
			pr_err("unable to create proc entry %s\n", ibm->name);
10613 10614
			ret = -ENODEV;
			goto err_out;
10615
		}
10616
		ibm->flags.proc_created = 1;
10617
	}
L
Linus Torvalds 已提交
10618

10619 10620
	list_add_tail(&ibm->all_drivers, &tpacpi_all_drivers);

L
Linus Torvalds 已提交
10621
	return 0;
10622 10623

err_out:
10624 10625 10626 10627
	dbg_printk(TPACPI_DBG_INIT,
		"%s: at error exit path with result %d\n",
		ibm->name, ret);

10628
	ibm_exit(ibm);
10629
	return (ret < 0) ? ret : 0;
L
Linus Torvalds 已提交
10630 10631
}

10632 10633
/* Probing */

10634 10635
static char __init tpacpi_parse_fw_id(const char * const s,
				      u32 *model, u16 *release)
10636
{
10637 10638 10639 10640 10641 10642 10643 10644 10645
	int i;

	if (!s || strlen(s) < 8)
		goto invalid;

	for (i = 0; i < 8; i++)
		if (!((s[i] >= '0' && s[i] <= '9') ||
		      (s[i] >= 'A' && s[i] <= 'Z')))
			goto invalid;
10646

10647 10648 10649 10650
	/*
	 * Most models: xxyTkkWW (#.##c)
	 * Ancient 570/600 and -SL lacks (#.##c)
	 */
10651 10652 10653 10654
	if (s[3] == 'T' || s[3] == 'N') {
		*model = TPID(s[0], s[1]);
		*release = TPVER(s[4], s[5]);
		return s[2];
10655 10656

	/* New models: xxxyTkkW (#.##c); T550 and some others */
10657 10658 10659 10660 10661 10662 10663 10664
	} else if (s[4] == 'T' || s[4] == 'N') {
		*model = TPID3(s[0], s[1], s[2]);
		*release = TPVER(s[5], s[6]);
		return s[3];
	}

invalid:
	return '\0';
10665 10666
}

10667 10668 10669 10670 10671 10672 10673 10674 10675 10676 10677 10678 10679 10680 10681 10682 10683 10684 10685 10686 10687 10688 10689 10690 10691 10692 10693 10694 10695 10696 10697
static void find_new_ec_fwstr(const struct dmi_header *dm, void *private)
{
	char *ec_fw_string = (char *) private;
	const char *dmi_data = (const char *)dm;
	/*
	 * ThinkPad Embedded Controller Program Table on newer models
	 *
	 * Offset |  Name                | Width  | Description
	 * ----------------------------------------------------
	 *  0x00  | Type                 | BYTE   | 0x8C
	 *  0x01  | Length               | BYTE   |
	 *  0x02  | Handle               | WORD   | Varies
	 *  0x04  | Signature            | BYTEx6 | ASCII for "LENOVO"
	 *  0x0A  | OEM struct offset    | BYTE   | 0x0B
	 *  0x0B  | OEM struct number    | BYTE   | 0x07, for this structure
	 *  0x0C  | OEM struct revision  | BYTE   | 0x01, for this format
	 *  0x0D  | ECP version ID       | STR ID |
	 *  0x0E  | ECP release date     | STR ID |
	 */

	/* Return if data structure not match */
	if (dm->type != 140 || dm->length < 0x0F ||
	memcmp(dmi_data + 4, "LENOVO", 6) != 0 ||
	dmi_data[0x0A] != 0x0B || dmi_data[0x0B] != 0x07 ||
	dmi_data[0x0C] != 0x01)
		return;

	/* fwstr is the first 8byte string  */
	strncpy(ec_fw_string, dmi_data + 0x0F, 8);
}

10698 10699 10700 10701 10702
/* returns 0 - probe ok, or < 0 - probe error.
 * Probe ok doesn't mean thinkpad found.
 * On error, kfree() cleanup on tp->* is not performed, caller must do it */
static int __must_check __init get_thinkpad_model_data(
						struct thinkpad_id_data *tp)
L
Linus Torvalds 已提交
10703
{
10704
	const struct dmi_device *dev = NULL;
10705
	char ec_fw_string[18] = {0};
10706
	char const *s;
10707
	char t;
L
Linus Torvalds 已提交
10708

10709
	if (!tp)
10710
		return -EINVAL;
10711 10712 10713 10714 10715 10716 10717 10718

	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
10719
		return 0;
10720

10721 10722 10723 10724
	s = dmi_get_system_info(DMI_BIOS_VERSION);
	tp->bios_version_str = kstrdup(s, GFP_KERNEL);
	if (s && !tp->bios_version_str)
		return -ENOMEM;
10725 10726

	/* Really ancient ThinkPad 240X will fail this, which is fine */
10727 10728 10729
	t = tpacpi_parse_fw_id(tp->bios_version_str,
			       &tp->bios_model, &tp->bios_release);
	if (t != 'E' && t != 'C')
10730
		return 0;
10731

10732 10733 10734 10735 10736
	/*
	 * 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.
	 *
10737
	 * See https://thinkwiki.org/wiki/List_of_DMI_IDs
10738 10739 10740 10741 10742 10743 10744
	 */
	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;
10745
			break;
10746
		}
L
Linus Torvalds 已提交
10747
	}
10748

10749 10750 10751 10752 10753 10754 10755 10756 10757 10758 10759 10760 10761 10762 10763 10764 10765 10766
	/* Newer ThinkPads have different EC program info table */
	if (!ec_fw_string[0])
		dmi_walk(find_new_ec_fwstr, &ec_fw_string);

	if (ec_fw_string[0]) {
		tp->ec_version_str = kstrdup(ec_fw_string, GFP_KERNEL);
		if (!tp->ec_version_str)
			return -ENOMEM;

		t = tpacpi_parse_fw_id(ec_fw_string,
			 &tp->ec_model, &tp->ec_release);
		if (t != 'H') {
			pr_notice("ThinkPad firmware release %s doesn't match the known patterns\n",
				  ec_fw_string);
			pr_notice("please report this to %s\n", TPACPI_MAIL);
		}
	}

10767
	s = dmi_get_system_info(DMI_PRODUCT_VERSION);
10768
	if (s && !(strncasecmp(s, "ThinkPad", 8) && strncasecmp(s, "Lenovo", 6))) {
10769 10770 10771
		tp->model_str = kstrdup(s, GFP_KERNEL);
		if (!tp->model_str)
			return -ENOMEM;
10772 10773
	} else {
		s = dmi_get_system_info(DMI_BIOS_VENDOR);
10774
		if (s && !(strncasecmp(s, "Lenovo", 6))) {
10775 10776 10777 10778
			tp->model_str = kstrdup(s, GFP_KERNEL);
			if (!tp->model_str)
				return -ENOMEM;
		}
10779
	}
10780

10781 10782 10783 10784 10785 10786
	s = dmi_get_system_info(DMI_PRODUCT_NAME);
	tp->nummodel_str = kstrdup(s, GFP_KERNEL);
	if (s && !tp->nummodel_str)
		return -ENOMEM;

	return 0;
L
Linus Torvalds 已提交
10787 10788
}

10789 10790 10791 10792 10793 10794 10795
static int __init probe_for_thinkpad(void)
{
	int is_thinkpad;

	if (acpi_disabled)
		return -ENODEV;

10796 10797 10798 10799
	/* It would be dangerous to run the driver in this case */
	if (!tpacpi_is_ibm() && !tpacpi_is_lenovo())
		return -ENODEV;

10800 10801
	/*
	 * Non-ancient models have better DMI tagging, but very old models
10802
	 * don't.  tpacpi_is_fw_known() is a cheat to help in that case.
10803
	 */
10804 10805 10806
	is_thinkpad = (thinkpad_id.model_str != NULL) ||
		      (thinkpad_id.ec_model != 0) ||
		      tpacpi_is_fw_known();
10807

10808 10809
	/* The EC handler is required */
	tpacpi_acpi_handle_locate("ec", TPACPI_ACPI_EC_HID, &ec_handle);
10810 10811
	if (!ec_handle) {
		if (is_thinkpad)
10812
			pr_err("Not yet supported ThinkPad detected!\n");
10813 10814 10815
		return -ENODEV;
	}

10816 10817 10818
	if (!is_thinkpad && !force_load)
		return -ENODEV;

10819 10820 10821
	return 0;
}

10822 10823
static void __init thinkpad_acpi_init_banner(void)
{
10824 10825
	pr_info("%s v%s\n", TPACPI_DESC, TPACPI_VERSION);
	pr_info("%s\n", TPACPI_URL);
10826

10827
	pr_info("ThinkPad BIOS %s, EC %s\n",
10828 10829 10830 10831 10832 10833 10834 10835
		(thinkpad_id.bios_version_str) ?
			thinkpad_id.bios_version_str : "unknown",
		(thinkpad_id.ec_version_str) ?
			thinkpad_id.ec_version_str : "unknown");

	BUG_ON(!thinkpad_id.vendor);

	if (thinkpad_id.model_str)
10836
		pr_info("%s %s, model %s\n",
10837 10838 10839 10840 10841 10842 10843 10844
			(thinkpad_id.vendor == PCI_VENDOR_ID_IBM) ?
				"IBM" : ((thinkpad_id.vendor ==
						PCI_VENDOR_ID_LENOVO) ?
					"Lenovo" : "Unknown vendor"),
			thinkpad_id.model_str,
			(thinkpad_id.nummodel_str) ?
				thinkpad_id.nummodel_str : "unknown");
}
10845

10846
/* Module init, exit, parameters */
L
Linus Torvalds 已提交
10847

10848 10849 10850 10851 10852 10853 10854 10855 10856 10857 10858 10859 10860 10861 10862 10863
static struct ibm_init_struct ibms_init[] __initdata = {
	{
		.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,
	},
10864 10865 10866 10867
	{
		.init = uwb_init,
		.data = &uwb_driver_data,
	},
10868
#ifdef CONFIG_THINKPAD_ACPI_VIDEO
10869 10870
	{
		.init = video_init,
10871
		.base_procfs_mode = S_IRUSR,
10872 10873
		.data = &video_driver_data,
	},
10874
#endif
10875 10876 10877 10878
	{
		.init = kbdlight_init,
		.data = &kbdlight_driver_data,
	},
10879 10880 10881 10882 10883 10884 10885 10886 10887 10888 10889 10890 10891 10892 10893 10894 10895 10896 10897 10898 10899 10900 10901 10902 10903
	{
		.init = light_init,
		.data = &light_driver_data,
	},
	{
		.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,
	},
	{
		.init = brightness_init,
		.data = &brightness_driver_data,
	},
	{
10904
		.init = volume_init,
10905 10906 10907 10908 10909 10910
		.data = &volume_driver_data,
	},
	{
		.init = fan_init,
		.data = &fan_driver_data,
	},
10911 10912 10913 10914
	{
		.init = mute_led_init,
		.data = &mute_led_driver_data,
	},
10915 10916 10917 10918
	{
		.init = tpacpi_battery_init,
		.data = &battery_driver_data,
	},
10919 10920 10921 10922
	{
		.init = tpacpi_lcdshadow_init,
		.data = &lcdshadow_driver_data,
	},
10923
	{
10924 10925
		.init = tpacpi_proxsensor_init,
		.data = &proxsensor_driver_data,
10926
	},
10927 10928 10929 10930 10931 10932
#if IS_ENABLED(CONFIG_ACPI_PLATFORM_PROFILE)
	{
		.init = tpacpi_dytc_profile_init,
		.data = &dytc_profile_driver_data,
	},
#endif
10933 10934 10935 10936
	{
		.init = tpacpi_kbdlang_init,
		.data = &kbdlang_driver_data,
	},
10937 10938
};

10939
static int __init set_ibm_param(const char *val, const struct kernel_param *kp)
L
Linus Torvalds 已提交
10940 10941
{
	unsigned int i;
10942
	struct ibm_struct *ibm;
L
Linus Torvalds 已提交
10943

10944 10945 10946
	if (!kp || !kp->name || !val)
		return -EINVAL;

10947 10948
	for (i = 0; i < ARRAY_SIZE(ibms_init); i++) {
		ibm = ibms_init[i].data;
10949 10950 10951 10952
		WARN_ON(ibm == NULL);

		if (!ibm || !ibm->name)
			continue;
10953 10954

		if (strcmp(ibm->name, kp->name) == 0 && ibm->write) {
10955
			if (strlen(val) > sizeof(ibms_init[i].param) - 1)
10956
				return -ENOSPC;
10957
			strcpy(ibms_init[i].param, val);
10958 10959
			return 0;
		}
10960
	}
L
Linus Torvalds 已提交
10961 10962 10963 10964

	return -EINVAL;
}

10965
module_param(experimental, int, 0444);
10966
MODULE_PARM_DESC(experimental,
10967
		 "Enables experimental features when non-zero");
10968

10969
module_param_named(debug, dbg_level, uint, 0);
10970
MODULE_PARM_DESC(debug, "Sets debug level bit-mask");
10971

10972
module_param(force_load, bool, 0444);
10973
MODULE_PARM_DESC(force_load,
10974
		 "Attempts to load the driver even on a mis-identified ThinkPad when true");
10975

10976
module_param_named(fan_control, fan_control_allowed, bool, 0444);
10977
MODULE_PARM_DESC(fan_control,
10978
		 "Enables setting fan parameters features when true");
10979

10980
module_param_named(brightness_mode, brightness_mode, uint, 0444);
10981
MODULE_PARM_DESC(brightness_mode,
10982
		 "Selects brightness control strategy: 0=auto, 1=EC, 2=UCMS, 3=EC+NVRAM");
10983

10984
module_param(brightness_enable, uint, 0444);
10985
MODULE_PARM_DESC(brightness_enable,
10986
		 "Enables backlight control when 1, disables when 0");
10987

10988
#ifdef CONFIG_THINKPAD_ACPI_ALSA_SUPPORT
10989 10990
module_param_named(volume_mode, volume_mode, uint, 0444);
MODULE_PARM_DESC(volume_mode,
10991
		 "Selects volume control strategy: 0=auto, 1=EC, 2=N/A, 3=EC+NVRAM");
10992

10993 10994
module_param_named(volume_capabilities, volume_capabilities, uint, 0444);
MODULE_PARM_DESC(volume_capabilities,
10995
		 "Selects the mixer capabilities: 0=auto, 1=volume and mute, 2=mute only");
10996

10997 10998
module_param_named(volume_control, volume_control_allowed, bool, 0444);
MODULE_PARM_DESC(volume_control,
10999
		 "Enables software override for the console audio control when true");
11000

11001 11002 11003 11004
module_param_named(software_mute, software_mute_requested, bool, 0444);
MODULE_PARM_DESC(software_mute,
		 "Request full software mute control");

11005 11006 11007 11008 11009 11010 11011
/* ALSA module API parameters */
module_param_named(index, alsa_index, int, 0444);
MODULE_PARM_DESC(index, "ALSA index for the ACPI EC Mixer");
module_param_named(id, alsa_id, charp, 0444);
MODULE_PARM_DESC(id, "ALSA id for the ACPI EC Mixer");
module_param_named(enable, alsa_enable, bool, 0444);
MODULE_PARM_DESC(enable, "Enable the ALSA interface for the ACPI EC Mixer");
11012
#endif /* CONFIG_THINKPAD_ACPI_ALSA_SUPPORT */
11013

11014
/* The module parameter can't be read back, that's why 0 is used here */
11015
#define TPACPI_PARAM(feature) \
11016
	module_param_call(feature, set_ibm_param, NULL, NULL, 0); \
11017
	MODULE_PARM_DESC(feature, "Simulates thinkpad-acpi procfs command at module load, see documentation")
L
Linus Torvalds 已提交
11018

11019 11020 11021 11022 11023 11024 11025 11026 11027 11028
TPACPI_PARAM(hotkey);
TPACPI_PARAM(bluetooth);
TPACPI_PARAM(video);
TPACPI_PARAM(light);
TPACPI_PARAM(cmos);
TPACPI_PARAM(led);
TPACPI_PARAM(beep);
TPACPI_PARAM(brightness);
TPACPI_PARAM(volume);
TPACPI_PARAM(fan);
11029

11030
#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
11031
module_param(dbg_wlswemul, uint, 0444);
11032 11033 11034 11035 11036
MODULE_PARM_DESC(dbg_wlswemul, "Enables WLSW emulation");
module_param_named(wlsw_state, tpacpi_wlsw_emulstate, bool, 0);
MODULE_PARM_DESC(wlsw_state,
		 "Initial state of the emulated WLSW switch");

11037
module_param(dbg_bluetoothemul, uint, 0444);
11038 11039 11040 11041 11042
MODULE_PARM_DESC(dbg_bluetoothemul, "Enables bluetooth switch emulation");
module_param_named(bluetooth_state, tpacpi_bluetooth_emulstate, bool, 0);
MODULE_PARM_DESC(bluetooth_state,
		 "Initial state of the emulated bluetooth switch");

11043
module_param(dbg_wwanemul, uint, 0444);
11044 11045 11046 11047
MODULE_PARM_DESC(dbg_wwanemul, "Enables WWAN switch emulation");
module_param_named(wwan_state, tpacpi_wwan_emulstate, bool, 0);
MODULE_PARM_DESC(wwan_state,
		 "Initial state of the emulated WWAN switch");
11048

11049
module_param(dbg_uwbemul, uint, 0444);
11050 11051 11052 11053
MODULE_PARM_DESC(dbg_uwbemul, "Enables UWB switch emulation");
module_param_named(uwb_state, tpacpi_uwb_emulstate, bool, 0);
MODULE_PARM_DESC(uwb_state,
		 "Initial state of the emulated UWB switch");
11054 11055
#endif

11056 11057 11058 11059 11060 11061 11062 11063 11064 11065 11066 11067 11068 11069 11070 11071 11072 11073 11074
static void thinkpad_acpi_module_exit(void)
{
	struct ibm_struct *ibm, *itmp;

	tpacpi_lifecycle = TPACPI_LIFE_EXITING;

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

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

	if (tpacpi_inputdev) {
		if (tp_features.input_device_registered)
			input_unregister_device(tpacpi_inputdev);
		else
			input_free_device(tpacpi_inputdev);
11075
		kfree(hotkey_keycode_map);
11076 11077 11078 11079 11080 11081 11082 11083 11084 11085 11086 11087 11088 11089 11090 11091 11092 11093 11094 11095 11096 11097
	}

	if (tpacpi_hwmon)
		hwmon_device_unregister(tpacpi_hwmon);

	if (tpacpi_sensors_pdev)
		platform_device_unregister(tpacpi_sensors_pdev);
	if (tpacpi_pdev)
		platform_device_unregister(tpacpi_pdev);

	if (tp_features.sensors_pdrv_attrs_registered)
		tpacpi_remove_driver_attributes(&tpacpi_hwmon_pdriver.driver);
	if (tp_features.platform_drv_attrs_registered)
		tpacpi_remove_driver_attributes(&tpacpi_pdriver.driver);

	if (tp_features.sensors_pdrv_registered)
		platform_driver_unregister(&tpacpi_hwmon_pdriver);

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

	if (proc_dir)
11098
		remove_proc_entry(TPACPI_PROC_DIR, acpi_root_dir);
11099

11100 11101 11102
	if (tpacpi_wq)
		destroy_workqueue(tpacpi_wq);

11103 11104 11105
	kfree(thinkpad_id.bios_version_str);
	kfree(thinkpad_id.ec_version_str);
	kfree(thinkpad_id.model_str);
11106
	kfree(thinkpad_id.nummodel_str);
11107 11108
}

11109

11110
static int __init thinkpad_acpi_module_init(void)
L
Linus Torvalds 已提交
11111 11112 11113
{
	int ret, i;

11114 11115
	tpacpi_lifecycle = TPACPI_LIFE_INIT;

11116
	/* Driver-level probe */
11117

11118 11119
	ret = get_thinkpad_model_data(&thinkpad_id);
	if (ret) {
11120
		pr_err("unable to get DMI data: %d\n", ret);
11121 11122 11123
		thinkpad_acpi_module_exit();
		return ret;
	}
11124
	ret = probe_for_thinkpad();
11125 11126
	if (ret) {
		thinkpad_acpi_module_exit();
11127
		return ret;
11128
	}
L
Linus Torvalds 已提交
11129

11130
	/* Driver initialization */
11131

11132 11133 11134
	thinkpad_acpi_init_banner();
	tpacpi_check_outdated_fw();

11135 11136
	TPACPI_ACPIHANDLE_INIT(ecrd);
	TPACPI_ACPIHANDLE_INIT(ecwr);
L
Linus Torvalds 已提交
11137

11138 11139 11140 11141 11142 11143
	tpacpi_wq = create_singlethread_workqueue(TPACPI_WORKQUEUE_NAME);
	if (!tpacpi_wq) {
		thinkpad_acpi_module_exit();
		return -ENOMEM;
	}

11144
	proc_dir = proc_mkdir(TPACPI_PROC_DIR, acpi_root_dir);
L
Linus Torvalds 已提交
11145
	if (!proc_dir) {
11146
		pr_err("unable to create proc dir " TPACPI_PROC_DIR "\n");
11147
		thinkpad_acpi_module_exit();
L
Linus Torvalds 已提交
11148 11149
		return -ENODEV;
	}
11150

11151 11152
	ret = platform_driver_register(&tpacpi_pdriver);
	if (ret) {
11153
		pr_err("unable to register main platform driver\n");
11154 11155 11156
		thinkpad_acpi_module_exit();
		return ret;
	}
11157 11158
	tp_features.platform_drv_registered = 1;

11159 11160
	ret = platform_driver_register(&tpacpi_hwmon_pdriver);
	if (ret) {
11161
		pr_err("unable to register hwmon platform driver\n");
11162 11163 11164 11165 11166
		thinkpad_acpi_module_exit();
		return ret;
	}
	tp_features.sensors_pdrv_registered = 1;

11167
	ret = tpacpi_create_driver_attributes(&tpacpi_pdriver.driver);
11168 11169
	if (!ret) {
		tp_features.platform_drv_attrs_registered = 1;
11170 11171
		ret = tpacpi_create_driver_attributes(
					&tpacpi_hwmon_pdriver.driver);
11172
	}
11173
	if (ret) {
11174
		pr_err("unable to create sysfs driver attributes\n");
11175 11176 11177
		thinkpad_acpi_module_exit();
		return ret;
	}
11178
	tp_features.sensors_pdrv_attrs_registered = 1;
11179

11180 11181

	/* Device initialization */
11182
	tpacpi_pdev = platform_device_register_simple(TPACPI_DRVR_NAME, -1,
11183 11184 11185 11186
							NULL, 0);
	if (IS_ERR(tpacpi_pdev)) {
		ret = PTR_ERR(tpacpi_pdev);
		tpacpi_pdev = NULL;
11187
		pr_err("unable to register platform device\n");
11188 11189 11190
		thinkpad_acpi_module_exit();
		return ret;
	}
11191
	tpacpi_sensors_pdev = platform_device_register_simple(
11192 11193
						TPACPI_HWMON_DRVR_NAME,
						-1, NULL, 0);
11194 11195 11196
	if (IS_ERR(tpacpi_sensors_pdev)) {
		ret = PTR_ERR(tpacpi_sensors_pdev);
		tpacpi_sensors_pdev = NULL;
11197
		pr_err("unable to register hwmon platform device\n");
11198 11199 11200 11201
		thinkpad_acpi_module_exit();
		return ret;
	}
	tp_features.sensors_pdev_attrs_registered = 1;
11202 11203 11204
	tpacpi_hwmon = hwmon_device_register_with_groups(
		&tpacpi_sensors_pdev->dev, TPACPI_NAME, NULL, NULL);

11205 11206 11207
	if (IS_ERR(tpacpi_hwmon)) {
		ret = PTR_ERR(tpacpi_hwmon);
		tpacpi_hwmon = NULL;
11208
		pr_err("unable to register hwmon device\n");
11209 11210 11211
		thinkpad_acpi_module_exit();
		return ret;
	}
11212
	mutex_init(&tpacpi_inputdev_send_mutex);
11213 11214 11215 11216 11217 11218 11219
	tpacpi_inputdev = input_allocate_device();
	if (!tpacpi_inputdev) {
		thinkpad_acpi_module_exit();
		return -ENOMEM;
	} else {
		/* Prepare input device, but don't register */
		tpacpi_inputdev->name = "ThinkPad Extra Buttons";
11220
		tpacpi_inputdev->phys = TPACPI_DRVR_NAME "/input0";
11221
		tpacpi_inputdev->id.bustype = BUS_HOST;
11222
		tpacpi_inputdev->id.vendor = thinkpad_id.vendor;
11223 11224
		tpacpi_inputdev->id.product = TPACPI_HKEY_INPUT_PRODUCT;
		tpacpi_inputdev->id.version = TPACPI_HKEY_INPUT_VERSION;
11225
		tpacpi_inputdev->dev.parent = &tpacpi_pdev->dev;
11226
	}
11227 11228 11229 11230 11231

	/* Init subdriver dependencies */
	tpacpi_detect_brightness_capabilities();

	/* Init subdrivers */
11232 11233 11234 11235
	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 已提交
11236
		if (ret < 0) {
11237
			thinkpad_acpi_module_exit();
L
Linus Torvalds 已提交
11238 11239 11240
			return ret;
		}
	}
11241 11242 11243

	tpacpi_lifecycle = TPACPI_LIFE_RUNNING;

11244 11245
	ret = input_register_device(tpacpi_inputdev);
	if (ret < 0) {
11246
		pr_err("unable to register input device\n");
11247 11248 11249 11250 11251
		thinkpad_acpi_module_exit();
		return ret;
	} else {
		tp_features.input_device_registered = 1;
	}
L
Linus Torvalds 已提交
11252 11253 11254 11255

	return 0;
}

11256 11257
MODULE_ALIAS(TPACPI_DRVR_SHORTNAME);

11258 11259 11260 11261 11262 11263 11264 11265 11266
/*
 * This will autoload the driver in almost every ThinkPad
 * in widespread use.
 *
 * Only _VERY_ old models, like the 240, 240x and 570 lack
 * the HKEY event interface.
 */
MODULE_DEVICE_TABLE(acpi, ibm_htk_device_ids);

11267 11268 11269
/*
 * DMI matching for module autoloading
 *
11270 11271
 * See https://thinkwiki.org/wiki/List_of_DMI_IDs
 * See https://thinkwiki.org/wiki/BIOS_Upgrade_Downloads
11272 11273 11274 11275 11276
 *
 * Only models listed in thinkwiki will be supported, so add yours
 * if it is not there yet.
 */
#define IBM_BIOS_MODULE_ALIAS(__type) \
11277
	MODULE_ALIAS("dmi:bvnIBM:bvr" __type "ET??WW*")
11278 11279 11280 11281

/* Ancient thinkpad BIOSes have to be identified by
 * BIOS type or model number, and there are far less
 * BIOS types than model numbers... */
11282
IBM_BIOS_MODULE_ALIAS("I[MU]");		/* 570, 570e */
11283

11284 11285
MODULE_AUTHOR("Borislav Deianov <borislav@users.sf.net>");
MODULE_AUTHOR("Henrique de Moraes Holschuh <hmh@hmh.eng.br>");
11286 11287
MODULE_DESCRIPTION(TPACPI_DESC);
MODULE_VERSION(TPACPI_VERSION);
11288 11289
MODULE_LICENSE("GPL");

11290 11291
module_init(thinkpad_acpi_module_init);
module_exit(thinkpad_acpi_module_exit);