ideapad-laptop.c 26.2 KB
Newer Older
David Woodhouse's avatar
David Woodhouse committed
1
/*
2
 *  ideapad-laptop.c - Lenovo IdeaPad ACPI Extras
David Woodhouse's avatar
David Woodhouse committed
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 *
 *  Copyright © 2010 Intel Corporation
 *  Copyright © 2010 David Woodhouse <dwmw2@infradead.org>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 *  02110-1301, USA.
 */

Joe Perches's avatar
Joe Perches committed
23 24
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

David Woodhouse's avatar
David Woodhouse committed
25 26 27 28
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
29
#include <linux/acpi.h>
David Woodhouse's avatar
David Woodhouse committed
30
#include <linux/rfkill.h>
31
#include <linux/platform_device.h>
Ike Panhc's avatar
Ike Panhc committed
32 33
#include <linux/input.h>
#include <linux/input/sparse-keymap.h>
Ike Panhc's avatar
Ike Panhc committed
34 35
#include <linux/backlight.h>
#include <linux/fb.h>
Ike Panhc's avatar
Ike Panhc committed
36 37
#include <linux/debugfs.h>
#include <linux/seq_file.h>
38
#include <linux/i8042.h>
39
#include <linux/dmi.h>
40
#include <linux/device.h>
41
#include <acpi/video.h>
David Woodhouse's avatar
David Woodhouse committed
42

43
#define IDEAPAD_RFKILL_DEV_NUM	(3)
David Woodhouse's avatar
David Woodhouse committed
44

45 46 47
#define CFG_BT_BIT	(16)
#define CFG_3G_BIT	(17)
#define CFG_WIFI_BIT	(18)
48
#define CFG_CAMERA_BIT	(19)
49

50
#if IS_ENABLED(CONFIG_ACPI_WMI)
51 52 53 54
static const char *const ideapad_wmi_fnesc_events[] = {
	"26CAB2E5-5CF1-46AE-AAC3-4A12B6BA50E6", /* Yoga 3 */
	"56322276-8493-4CE8-A783-98C991274F5E", /* Yoga 700 */
};
55 56
#endif

Ike Panhc's avatar
Ike Panhc committed
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
enum {
	VPCCMD_R_VPC1 = 0x10,
	VPCCMD_R_BL_MAX,
	VPCCMD_R_BL,
	VPCCMD_W_BL,
	VPCCMD_R_WIFI,
	VPCCMD_W_WIFI,
	VPCCMD_R_BT,
	VPCCMD_W_BT,
	VPCCMD_R_BL_POWER,
	VPCCMD_R_NOVO,
	VPCCMD_R_VPC2,
	VPCCMD_R_TOUCHPAD,
	VPCCMD_W_TOUCHPAD,
	VPCCMD_R_CAMERA,
	VPCCMD_W_CAMERA,
	VPCCMD_R_3G,
	VPCCMD_W_3G,
	VPCCMD_R_ODD, /* 0x21 */
76 77
	VPCCMD_W_FAN,
	VPCCMD_R_RF,
Ike Panhc's avatar
Ike Panhc committed
78
	VPCCMD_W_RF,
79
	VPCCMD_R_FAN = 0x2B,
80
	VPCCMD_R_SPECIAL_BUTTONS = 0x31,
Ike Panhc's avatar
Ike Panhc committed
81 82 83
	VPCCMD_W_BL_POWER = 0x33,
};

84 85 86 87 88
struct ideapad_rfk_priv {
	int dev;
	struct ideapad_private *priv;
};

89
struct ideapad_private {
90
	struct acpi_device *adev;
91
	struct rfkill *rfk[IDEAPAD_RFKILL_DEV_NUM];
92
	struct ideapad_rfk_priv rfk_priv[IDEAPAD_RFKILL_DEV_NUM];
93
	struct platform_device *platform_device;
Ike Panhc's avatar
Ike Panhc committed
94
	struct input_dev *inputdev;
Ike Panhc's avatar
Ike Panhc committed
95
	struct backlight_device *blightdev;
Ike Panhc's avatar
Ike Panhc committed
96
	struct dentry *debug;
97
	unsigned long cfg;
98
	bool has_hw_rfkill_switch;
99
	const char *fnesc_guid;
David Woodhouse's avatar
David Woodhouse committed
100 101
};

Ike Panhc's avatar
Ike Panhc committed
102 103 104 105
static bool no_bt_rfkill;
module_param(no_bt_rfkill, bool, 0444);
MODULE_PARM_DESC(no_bt_rfkill, "No rfkill for bluetooth.");

Ike Panhc's avatar
Ike Panhc committed
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
/*
 * ACPI Helpers
 */
#define IDEAPAD_EC_TIMEOUT (100) /* in ms */

static int read_method_int(acpi_handle handle, const char *method, int *val)
{
	acpi_status status;
	unsigned long long result;

	status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
	if (ACPI_FAILURE(status)) {
		*val = -1;
		return -1;
	} else {
		*val = result;
		return 0;
	}
}

static int method_vpcr(acpi_handle handle, int cmd, int *ret)
{
	acpi_status status;
	unsigned long long result;
	struct acpi_object_list params;
	union acpi_object in_obj;

	params.count = 1;
	params.pointer = &in_obj;
	in_obj.type = ACPI_TYPE_INTEGER;
	in_obj.integer.value = cmd;

	status = acpi_evaluate_integer(handle, "VPCR", &params, &result);

	if (ACPI_FAILURE(status)) {
		*ret = -1;
		return -1;
	} else {
		*ret = result;
		return 0;
	}
}

static int method_vpcw(acpi_handle handle, int cmd, int data)
{
	struct acpi_object_list params;
	union acpi_object in_obj[2];
	acpi_status status;

	params.count = 2;
	params.pointer = in_obj;
	in_obj[0].type = ACPI_TYPE_INTEGER;
	in_obj[0].integer.value = cmd;
	in_obj[1].type = ACPI_TYPE_INTEGER;
	in_obj[1].integer.value = data;

	status = acpi_evaluate_object(handle, "VPCW", &params, NULL);
	if (status != AE_OK)
		return -1;
	return 0;
}

static int read_ec_data(acpi_handle handle, int cmd, unsigned long *data)
{
	int val;
	unsigned long int end_jiffies;

	if (method_vpcw(handle, 1, cmd))
		return -1;

	for (end_jiffies = jiffies+(HZ)*IDEAPAD_EC_TIMEOUT/1000+1;
	     time_before(jiffies, end_jiffies);) {
		schedule();
		if (method_vpcr(handle, 1, &val))
			return -1;
		if (val == 0) {
			if (method_vpcr(handle, 0, &val))
				return -1;
			*data = val;
			return 0;
		}
	}
	pr_err("timeout in read_ec_cmd\n");
	return -1;
}

static int write_ec_cmd(acpi_handle handle, int cmd, unsigned long data)
{
	int val;
	unsigned long int end_jiffies;

	if (method_vpcw(handle, 0, data))
		return -1;
	if (method_vpcw(handle, 1, cmd))
		return -1;

	for (end_jiffies = jiffies+(HZ)*IDEAPAD_EC_TIMEOUT/1000+1;
	     time_before(jiffies, end_jiffies);) {
		schedule();
		if (method_vpcr(handle, 1, &val))
			return -1;
		if (val == 0)
			return 0;
	}
	pr_err("timeout in write_ec_cmd\n");
	return -1;
}

Ike Panhc's avatar
Ike Panhc committed
214 215 216 217 218
/*
 * debugfs
 */
static int debugfs_status_show(struct seq_file *s, void *data)
{
219
	struct ideapad_private *priv = s->private;
Ike Panhc's avatar
Ike Panhc committed
220 221
	unsigned long value;

222 223 224 225
	if (!priv)
		return -EINVAL;

	if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &value))
Ike Panhc's avatar
Ike Panhc committed
226
		seq_printf(s, "Backlight max:\t%lu\n", value);
227
	if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL, &value))
Ike Panhc's avatar
Ike Panhc committed
228
		seq_printf(s, "Backlight now:\t%lu\n", value);
229
	if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &value))
Ike Panhc's avatar
Ike Panhc committed
230 231 232
		seq_printf(s, "BL power value:\t%s\n", value ? "On" : "Off");
	seq_printf(s, "=====================\n");

233
	if (!read_ec_data(priv->adev->handle, VPCCMD_R_RF, &value))
Ike Panhc's avatar
Ike Panhc committed
234 235
		seq_printf(s, "Radio status:\t%s(%lu)\n",
			   value ? "On" : "Off", value);
236
	if (!read_ec_data(priv->adev->handle, VPCCMD_R_WIFI, &value))
Ike Panhc's avatar
Ike Panhc committed
237 238
		seq_printf(s, "Wifi status:\t%s(%lu)\n",
			   value ? "On" : "Off", value);
239
	if (!read_ec_data(priv->adev->handle, VPCCMD_R_BT, &value))
Ike Panhc's avatar
Ike Panhc committed
240 241
		seq_printf(s, "BT status:\t%s(%lu)\n",
			   value ? "On" : "Off", value);
242
	if (!read_ec_data(priv->adev->handle, VPCCMD_R_3G, &value))
Ike Panhc's avatar
Ike Panhc committed
243 244 245 246
		seq_printf(s, "3G status:\t%s(%lu)\n",
			   value ? "On" : "Off", value);
	seq_printf(s, "=====================\n");

247
	if (!read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value))
Ike Panhc's avatar
Ike Panhc committed
248 249
		seq_printf(s, "Touchpad status:%s(%lu)\n",
			   value ? "On" : "Off", value);
250
	if (!read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &value))
Ike Panhc's avatar
Ike Panhc committed
251 252 253 254 255 256 257 258
		seq_printf(s, "Camera status:\t%s(%lu)\n",
			   value ? "On" : "Off", value);

	return 0;
}

static int debugfs_status_open(struct inode *inode, struct file *file)
{
259
	return single_open(file, debugfs_status_show, inode->i_private);
Ike Panhc's avatar
Ike Panhc committed
260 261 262 263 264 265 266 267 268 269 270 271
}

static const struct file_operations debugfs_status_fops = {
	.owner = THIS_MODULE,
	.open = debugfs_status_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
};

static int debugfs_cfg_show(struct seq_file *s, void *data)
{
272 273 274
	struct ideapad_private *priv = s->private;

	if (!priv) {
Ike Panhc's avatar
Ike Panhc committed
275 276 277
		seq_printf(s, "cfg: N/A\n");
	} else {
		seq_printf(s, "cfg: 0x%.8lX\n\nCapability: ",
278 279
			   priv->cfg);
		if (test_bit(CFG_BT_BIT, &priv->cfg))
Ike Panhc's avatar
Ike Panhc committed
280
			seq_printf(s, "Bluetooth ");
281
		if (test_bit(CFG_3G_BIT, &priv->cfg))
Ike Panhc's avatar
Ike Panhc committed
282
			seq_printf(s, "3G ");
283
		if (test_bit(CFG_WIFI_BIT, &priv->cfg))
Ike Panhc's avatar
Ike Panhc committed
284
			seq_printf(s, "Wireless ");
285
		if (test_bit(CFG_CAMERA_BIT, &priv->cfg))
Ike Panhc's avatar
Ike Panhc committed
286 287
			seq_printf(s, "Camera ");
		seq_printf(s, "\nGraphic: ");
288
		switch ((priv->cfg)&0x700) {
Ike Panhc's avatar
Ike Panhc committed
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
		case 0x100:
			seq_printf(s, "Intel");
			break;
		case 0x200:
			seq_printf(s, "ATI");
			break;
		case 0x300:
			seq_printf(s, "Nvidia");
			break;
		case 0x400:
			seq_printf(s, "Intel and ATI");
			break;
		case 0x500:
			seq_printf(s, "Intel and Nvidia");
			break;
		}
		seq_printf(s, "\n");
	}
	return 0;
}

static int debugfs_cfg_open(struct inode *inode, struct file *file)
{
312
	return single_open(file, debugfs_cfg_show, inode->i_private);
Ike Panhc's avatar
Ike Panhc committed
313 314 315 316 317 318 319 320 321 322
}

static const struct file_operations debugfs_cfg_fops = {
	.owner = THIS_MODULE,
	.open = debugfs_cfg_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
};

323
static int ideapad_debugfs_init(struct ideapad_private *priv)
Ike Panhc's avatar
Ike Panhc committed
324 325 326 327 328 329 330 331 332
{
	struct dentry *node;

	priv->debug = debugfs_create_dir("ideapad", NULL);
	if (priv->debug == NULL) {
		pr_err("failed to create debugfs directory");
		goto errout;
	}

333
	node = debugfs_create_file("cfg", S_IRUGO, priv->debug, priv,
Ike Panhc's avatar
Ike Panhc committed
334 335 336 337 338 339
				   &debugfs_cfg_fops);
	if (!node) {
		pr_err("failed to create cfg in debugfs");
		goto errout;
	}

340
	node = debugfs_create_file("status", S_IRUGO, priv->debug, priv,
Ike Panhc's avatar
Ike Panhc committed
341 342
				   &debugfs_status_fops);
	if (!node) {
343
		pr_err("failed to create status in debugfs");
Ike Panhc's avatar
Ike Panhc committed
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
		goto errout;
	}

	return 0;

errout:
	return -ENOMEM;
}

static void ideapad_debugfs_exit(struct ideapad_private *priv)
{
	debugfs_remove_recursive(priv->debug);
	priv->debug = NULL;
}

359
/*
360
 * sysfs
361
 */
David Woodhouse's avatar
David Woodhouse committed
362 363 364 365
static ssize_t show_ideapad_cam(struct device *dev,
				struct device_attribute *attr,
				char *buf)
{
366
	unsigned long result;
367
	struct ideapad_private *priv = dev_get_drvdata(dev);
David Woodhouse's avatar
David Woodhouse committed
368

369
	if (read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &result))
370 371
		return sprintf(buf, "-1\n");
	return sprintf(buf, "%lu\n", result);
David Woodhouse's avatar
David Woodhouse committed
372 373 374 375 376 377 378
}

static ssize_t store_ideapad_cam(struct device *dev,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{
	int ret, state;
379
	struct ideapad_private *priv = dev_get_drvdata(dev);
David Woodhouse's avatar
David Woodhouse committed
380 381 382 383 384

	if (!count)
		return 0;
	if (sscanf(buf, "%i", &state) != 1)
		return -EINVAL;
385
	ret = write_ec_cmd(priv->adev->handle, VPCCMD_W_CAMERA, state);
David Woodhouse's avatar
David Woodhouse committed
386
	if (ret < 0)
387
		return -EIO;
David Woodhouse's avatar
David Woodhouse committed
388 389 390 391 392
	return count;
}

static DEVICE_ATTR(camera_power, 0644, show_ideapad_cam, store_ideapad_cam);

393 394 395 396 397
static ssize_t show_ideapad_fan(struct device *dev,
				struct device_attribute *attr,
				char *buf)
{
	unsigned long result;
398
	struct ideapad_private *priv = dev_get_drvdata(dev);
399

400
	if (read_ec_data(priv->adev->handle, VPCCMD_R_FAN, &result))
401 402 403 404 405 406 407 408 409
		return sprintf(buf, "-1\n");
	return sprintf(buf, "%lu\n", result);
}

static ssize_t store_ideapad_fan(struct device *dev,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{
	int ret, state;
410
	struct ideapad_private *priv = dev_get_drvdata(dev);
411 412 413 414 415 416 417

	if (!count)
		return 0;
	if (sscanf(buf, "%i", &state) != 1)
		return -EINVAL;
	if (state < 0 || state > 4 || state == 3)
		return -EINVAL;
418
	ret = write_ec_cmd(priv->adev->handle, VPCCMD_W_FAN, state);
419 420 421 422 423 424 425
	if (ret < 0)
		return -EIO;
	return count;
}

static DEVICE_ATTR(fan_mode, 0644, show_ideapad_fan, store_ideapad_fan);

426 427
static struct attribute *ideapad_attributes[] = {
	&dev_attr_camera_power.attr,
428
	&dev_attr_fan_mode.attr,
429 430 431
	NULL
};

432
static umode_t ideapad_is_visible(struct kobject *kobj,
433 434 435 436 437 438 439 440 441
				 struct attribute *attr,
				 int idx)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct ideapad_private *priv = dev_get_drvdata(dev);
	bool supported;

	if (attr == &dev_attr_camera_power.attr)
		supported = test_bit(CFG_CAMERA_BIT, &(priv->cfg));
442 443
	else if (attr == &dev_attr_fan_mode.attr) {
		unsigned long value;
444 445
		supported = !read_ec_data(priv->adev->handle, VPCCMD_R_FAN,
					  &value);
446
	} else
447 448 449 450 451
		supported = true;

	return supported ? attr->mode : 0;
}

452
static const struct attribute_group ideapad_attribute_group = {
453
	.is_visible = ideapad_is_visible,
454 455 456
	.attrs = ideapad_attributes
};

457 458 459
/*
 * Rfkill
 */
460 461 462 463 464 465 466
struct ideapad_rfk_data {
	char *name;
	int cfgbit;
	int opcode;
	int type;
};

467
static const struct ideapad_rfk_data ideapad_rfk_data[] = {
Ike Panhc's avatar
Ike Panhc committed
468 469 470
	{ "ideapad_wlan",    CFG_WIFI_BIT, VPCCMD_W_WIFI, RFKILL_TYPE_WLAN },
	{ "ideapad_bluetooth", CFG_BT_BIT, VPCCMD_W_BT, RFKILL_TYPE_BLUETOOTH },
	{ "ideapad_3g",        CFG_3G_BIT, VPCCMD_W_3G, RFKILL_TYPE_WWAN },
471 472
};

David Woodhouse's avatar
David Woodhouse committed
473 474
static int ideapad_rfk_set(void *data, bool blocked)
{
475
	struct ideapad_rfk_priv *priv = data;
476
	int opcode = ideapad_rfk_data[priv->dev].opcode;
Ike Panhc's avatar
Ike Panhc committed
477

478
	return write_ec_cmd(priv->priv->adev->handle, opcode, !blocked);
David Woodhouse's avatar
David Woodhouse committed
479 480 481 482 483 484
}

static struct rfkill_ops ideapad_rfk_ops = {
	.set_block = ideapad_rfk_set,
};

485
static void ideapad_sync_rfk_state(struct ideapad_private *priv)
David Woodhouse's avatar
David Woodhouse committed
486
{
487
	unsigned long hw_blocked = 0;
David Woodhouse's avatar
David Woodhouse committed
488 489
	int i;

490 491 492 493 494
	if (priv->has_hw_rfkill_switch) {
		if (read_ec_data(priv->adev->handle, VPCCMD_R_RF, &hw_blocked))
			return;
		hw_blocked = !hw_blocked;
	}
David Woodhouse's avatar
David Woodhouse committed
495

496
	for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
497
		if (priv->rfk[i])
498
			rfkill_set_hw_state(priv->rfk[i], hw_blocked);
David Woodhouse's avatar
David Woodhouse committed
499 500
}

501
static int ideapad_register_rfkill(struct ideapad_private *priv, int dev)
David Woodhouse's avatar
David Woodhouse committed
502 503
{
	int ret;
504
	unsigned long sw_blocked;
David Woodhouse's avatar
David Woodhouse committed
505

Ike Panhc's avatar
Ike Panhc committed
506 507 508
	if (no_bt_rfkill &&
	    (ideapad_rfk_data[dev].type == RFKILL_TYPE_BLUETOOTH)) {
		/* Force to enable bluetooth when no_bt_rfkill=1 */
509
		write_ec_cmd(priv->adev->handle,
Ike Panhc's avatar
Ike Panhc committed
510 511 512
			     ideapad_rfk_data[dev].opcode, 1);
		return 0;
	}
513 514
	priv->rfk_priv[dev].dev = dev;
	priv->rfk_priv[dev].priv = priv;
Ike Panhc's avatar
Ike Panhc committed
515

516
	priv->rfk[dev] = rfkill_alloc(ideapad_rfk_data[dev].name,
517
				      &priv->platform_device->dev,
518 519
				      ideapad_rfk_data[dev].type,
				      &ideapad_rfk_ops,
520
				      &priv->rfk_priv[dev]);
521
	if (!priv->rfk[dev])
David Woodhouse's avatar
David Woodhouse committed
522 523
		return -ENOMEM;

524
	if (read_ec_data(priv->adev->handle, ideapad_rfk_data[dev].opcode-1,
525 526 527 528 529 530 531
			 &sw_blocked)) {
		rfkill_init_sw_state(priv->rfk[dev], 0);
	} else {
		sw_blocked = !sw_blocked;
		rfkill_init_sw_state(priv->rfk[dev], sw_blocked);
	}

532
	ret = rfkill_register(priv->rfk[dev]);
David Woodhouse's avatar
David Woodhouse committed
533
	if (ret) {
534
		rfkill_destroy(priv->rfk[dev]);
David Woodhouse's avatar
David Woodhouse committed
535 536 537 538 539
		return ret;
	}
	return 0;
}

540
static void ideapad_unregister_rfkill(struct ideapad_private *priv, int dev)
David Woodhouse's avatar
David Woodhouse committed
541
{
542
	if (!priv->rfk[dev])
David Woodhouse's avatar
David Woodhouse committed
543 544
		return;

545 546
	rfkill_unregister(priv->rfk[dev]);
	rfkill_destroy(priv->rfk[dev]);
David Woodhouse's avatar
David Woodhouse committed
547 548
}

549 550 551
/*
 * Platform device
 */
552
static int ideapad_sysfs_init(struct ideapad_private *priv)
553
{
554
	return sysfs_create_group(&priv->platform_device->dev.kobj,
555
				    &ideapad_attribute_group);
556 557
}

558
static void ideapad_sysfs_exit(struct ideapad_private *priv)
559
{
560
	sysfs_remove_group(&priv->platform_device->dev.kobj,
561
			   &ideapad_attribute_group);
562 563
}

Ike Panhc's avatar
Ike Panhc committed
564 565 566 567
/*
 * input device
 */
static const struct key_entry ideapad_keymap[] = {
Ike Panhc's avatar
Ike Panhc committed
568
	{ KE_KEY, 6,  { KEY_SWITCHVIDEOMODE } },
569
	{ KE_KEY, 7,  { KEY_CAMERA } },
570
	{ KE_KEY, 8,  { KEY_MICMUTE } },
571
	{ KE_KEY, 11, { KEY_F16 } },
Ike Panhc's avatar
Ike Panhc committed
572 573 574
	{ KE_KEY, 13, { KEY_WLAN } },
	{ KE_KEY, 16, { KEY_PROG1 } },
	{ KE_KEY, 17, { KEY_PROG2 } },
575 576
	{ KE_KEY, 64, { KEY_PROG3 } },
	{ KE_KEY, 65, { KEY_PROG4 } },
577 578
	{ KE_KEY, 66, { KEY_TOUCHPAD_OFF } },
	{ KE_KEY, 67, { KEY_TOUCHPAD_ON } },
579 580
	{ KE_KEY, 128, { KEY_ESC } },

Ike Panhc's avatar
Ike Panhc committed
581 582 583
	{ KE_END, 0 },
};

584
static int ideapad_input_init(struct ideapad_private *priv)
Ike Panhc's avatar
Ike Panhc committed
585 586 587 588 589
{
	struct input_dev *inputdev;
	int error;

	inputdev = input_allocate_device();
590
	if (!inputdev)
Ike Panhc's avatar
Ike Panhc committed
591 592 593 594 595
		return -ENOMEM;

	inputdev->name = "Ideapad extra buttons";
	inputdev->phys = "ideapad/input0";
	inputdev->id.bustype = BUS_HOST;
596
	inputdev->dev.parent = &priv->platform_device->dev;
Ike Panhc's avatar
Ike Panhc committed
597 598 599 600 601 602 603 604 605 606 607 608 609

	error = sparse_keymap_setup(inputdev, ideapad_keymap, NULL);
	if (error) {
		pr_err("Unable to setup input device keymap\n");
		goto err_free_dev;
	}

	error = input_register_device(inputdev);
	if (error) {
		pr_err("Unable to register input device\n");
		goto err_free_keymap;
	}

610
	priv->inputdev = inputdev;
Ike Panhc's avatar
Ike Panhc committed
611 612 613 614 615 616 617 618 619
	return 0;

err_free_keymap:
	sparse_keymap_free(inputdev);
err_free_dev:
	input_free_device(inputdev);
	return error;
}

620
static void ideapad_input_exit(struct ideapad_private *priv)
Ike Panhc's avatar
Ike Panhc committed
621
{
622 623 624
	sparse_keymap_free(priv->inputdev);
	input_unregister_device(priv->inputdev);
	priv->inputdev = NULL;
Ike Panhc's avatar
Ike Panhc committed
625 626
}

627 628
static void ideapad_input_report(struct ideapad_private *priv,
				 unsigned long scancode)
Ike Panhc's avatar
Ike Panhc committed
629
{
630
	sparse_keymap_report_event(priv->inputdev, scancode, 1, true);
Ike Panhc's avatar
Ike Panhc committed
631 632
}

Ike Panhc's avatar
Ike Panhc committed
633 634 635 636
static void ideapad_input_novokey(struct ideapad_private *priv)
{
	unsigned long long_pressed;

637
	if (read_ec_data(priv->adev->handle, VPCCMD_R_NOVO, &long_pressed))
Ike Panhc's avatar
Ike Panhc committed
638 639 640 641 642 643 644
		return;
	if (long_pressed)
		ideapad_input_report(priv, 17);
	else
		ideapad_input_report(priv, 16);
}

645 646 647 648
static void ideapad_check_special_buttons(struct ideapad_private *priv)
{
	unsigned long bit, value;

649
	read_ec_data(priv->adev->handle, VPCCMD_R_SPECIAL_BUTTONS, &value);
650 651 652 653

	for (bit = 0; bit < 16; bit++) {
		if (test_bit(bit, &value)) {
			switch (bit) {
654 655
			case 0:	/* Z580 */
			case 6:	/* Z570 */
656 657 658 659 660 661 662
				/* Thermal Management button */
				ideapad_input_report(priv, 65);
				break;
			case 1:
				/* OneKey Theater button */
				ideapad_input_report(priv, 64);
				break;
663 664 665
			default:
				pr_info("Unknown special button: %lu\n", bit);
				break;
666 667 668 669 670
			}
		}
	}
}

Ike Panhc's avatar
Ike Panhc committed
671 672 673 674 675
/*
 * backlight
 */
static int ideapad_backlight_get_brightness(struct backlight_device *blightdev)
{
676
	struct ideapad_private *priv = bl_get_data(blightdev);
Ike Panhc's avatar
Ike Panhc committed
677 678
	unsigned long now;

679 680 681 682
	if (!priv)
		return -EINVAL;

	if (read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now))
Ike Panhc's avatar
Ike Panhc committed
683 684 685 686 687 688
		return -EIO;
	return now;
}

static int ideapad_backlight_update_status(struct backlight_device *blightdev)
{
689 690 691 692 693 694
	struct ideapad_private *priv = bl_get_data(blightdev);

	if (!priv)
		return -EINVAL;

	if (write_ec_cmd(priv->adev->handle, VPCCMD_W_BL,
Ike Panhc's avatar
Ike Panhc committed
695
			 blightdev->props.brightness))
Ike Panhc's avatar
Ike Panhc committed
696
		return -EIO;
697
	if (write_ec_cmd(priv->adev->handle, VPCCMD_W_BL_POWER,
Ike Panhc's avatar
Ike Panhc committed
698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714
			 blightdev->props.power == FB_BLANK_POWERDOWN ? 0 : 1))
		return -EIO;

	return 0;
}

static const struct backlight_ops ideapad_backlight_ops = {
	.get_brightness = ideapad_backlight_get_brightness,
	.update_status = ideapad_backlight_update_status,
};

static int ideapad_backlight_init(struct ideapad_private *priv)
{
	struct backlight_device *blightdev;
	struct backlight_properties props;
	unsigned long max, now, power;

715
	if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &max))
Ike Panhc's avatar
Ike Panhc committed
716
		return -EIO;
717
	if (read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now))
Ike Panhc's avatar
Ike Panhc committed
718
		return -EIO;
719
	if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power))
Ike Panhc's avatar
Ike Panhc committed
720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744
		return -EIO;

	memset(&props, 0, sizeof(struct backlight_properties));
	props.max_brightness = max;
	props.type = BACKLIGHT_PLATFORM;
	blightdev = backlight_device_register("ideapad",
					      &priv->platform_device->dev,
					      priv,
					      &ideapad_backlight_ops,
					      &props);
	if (IS_ERR(blightdev)) {
		pr_err("Could not register backlight device\n");
		return PTR_ERR(blightdev);
	}

	priv->blightdev = blightdev;
	blightdev->props.brightness = now;
	blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
	backlight_update_status(blightdev);

	return 0;
}

static void ideapad_backlight_exit(struct ideapad_private *priv)
{
745
	backlight_device_unregister(priv->blightdev);
Ike Panhc's avatar
Ike Panhc committed
746 747 748 749 750 751 752 753
	priv->blightdev = NULL;
}

static void ideapad_backlight_notify_power(struct ideapad_private *priv)
{
	unsigned long power;
	struct backlight_device *blightdev = priv->blightdev;

754 755
	if (!blightdev)
		return;
756
	if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power))
Ike Panhc's avatar
Ike Panhc committed
757 758 759 760 761 762 763 764 765 766
		return;
	blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
}

static void ideapad_backlight_notify_brightness(struct ideapad_private *priv)
{
	unsigned long now;

	/* if we control brightness via acpi video driver */
	if (priv->blightdev == NULL) {
767
		read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now);
Ike Panhc's avatar
Ike Panhc committed
768 769 770 771 772 773
		return;
	}

	backlight_force_update(priv->blightdev, BACKLIGHT_UPDATE_HOTKEY);
}

774 775 776
/*
 * module init/exit
 */
777
static void ideapad_sync_touchpad_state(struct ideapad_private *priv)
778 779 780 781
{
	unsigned long value;

	/* Without reading from EC touchpad LED doesn't switch state */
782
	if (!read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value)) {
783 784 785 786 787 788 789 790 791 792 793
		/* Some IdeaPads don't really turn off touchpad - they only
		 * switch the LED state. We (de)activate KBC AUX port to turn
		 * touchpad off and on. We send KEY_TOUCHPAD_OFF and
		 * KEY_TOUCHPAD_ON to not to get out of sync with LED */
		unsigned char param;
		i8042_command(&param, value ? I8042_CMD_AUX_ENABLE :
			      I8042_CMD_AUX_DISABLE);
		ideapad_input_report(priv, value ? 67 : 66);
	}
}

794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812
static void ideapad_acpi_notify(acpi_handle handle, u32 event, void *data)
{
	struct ideapad_private *priv = data;
	unsigned long vpc1, vpc2, vpc_bit;

	if (read_ec_data(handle, VPCCMD_R_VPC1, &vpc1))
		return;
	if (read_ec_data(handle, VPCCMD_R_VPC2, &vpc2))
		return;

	vpc1 = (vpc2 << 8) | vpc1;
	for (vpc_bit = 0; vpc_bit < 16; vpc_bit++) {
		if (test_bit(vpc_bit, &vpc1)) {
			switch (vpc_bit) {
			case 9:
				ideapad_sync_rfk_state(priv);
				break;
			case 13:
			case 11:
813
			case 8:
814 815
			case 7:
			case 6:
816
			case 1:
817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840
				ideapad_input_report(priv, vpc_bit);
				break;
			case 5:
				ideapad_sync_touchpad_state(priv);
				break;
			case 4:
				ideapad_backlight_notify_brightness(priv);
				break;
			case 3:
				ideapad_input_novokey(priv);
				break;
			case 2:
				ideapad_backlight_notify_power(priv);
				break;
			case 0:
				ideapad_check_special_buttons(priv);
				break;
			default:
				pr_info("Unknown event: %lu\n", vpc_bit);
			}
		}
	}
}

841 842 843 844 845 846 847 848 849 850 851 852 853
#if IS_ENABLED(CONFIG_ACPI_WMI)
static void ideapad_wmi_notify(u32 value, void *context)
{
	switch (value) {
	case 128:
		ideapad_input_report(context, value);
		break;
	default:
		pr_info("Unknown WMI event %u\n", value);
	}
}
#endif

854 855 856 857 858
/*
 * Some ideapads don't have a hardware rfkill switch, reading VPCCMD_R_RF
 * always results in 0 on these models, causing ideapad_laptop to wrongly
 * report all radios as hardware-blocked.
 */
859
static const struct dmi_system_id no_hw_rfkill_list[] = {
860 861 862 863 864 865 866
	{
		.ident = "Lenovo G40-30",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo G40-30"),
		},
	},
867 868 869 870 871 872 873
	{
		.ident = "Lenovo G50-30",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo G50-30"),
		},
	},
874 875 876 877 878 879 880 881 882 883 884 885 886 887
	{
		.ident = "Lenovo ideapad Y700-15ISK",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo ideapad Y700-15ISK"),
		},
	},
	{
		.ident = "Lenovo ideapad Y700 Touch-15ISK",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo ideapad Y700 Touch-15ISK"),
		},
	},
888 889 890 891 892 893 894
	{
		.ident = "Lenovo ideapad Y700-17ISK",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo ideapad Y700-17ISK"),
		},
	},
895
	{
896
		.ident = "Lenovo Yoga 2 11 / 13 / Pro",
897 898
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
899
			DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Yoga 2"),
900 901
		},
	},
902
	{
903
		.ident = "Lenovo Yoga 2 11 / 13 / Pro",
904 905
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
906
			DMI_MATCH(DMI_BOARD_NAME, "Yoga2"),
907 908
		},
	},
909
	{
910
		.ident = "Lenovo Yoga 3 1170 / 1470",
911 912
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
913
			DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Yoga 3"),
914 915
		},
	},
916 917 918 919
	{
		.ident = "Lenovo Yoga 3 Pro 1370",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
920
			DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo YOGA 3"),
921 922
		},
	},
923 924 925 926 927 928 929
	{
		.ident = "Lenovo Yoga 700",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo YOGA 700"),
		},
	},
930 931 932 933 934 935 936
	{
		.ident = "Lenovo Yoga 900",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo YOGA 900"),
		},
	},
937 938 939 940 941 942 943
	{
		.ident = "Lenovo Yoga 900",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_BOARD_NAME, "VIUU4"),
		},
	},
944 945 946 947 948 949 950
	{
		.ident = "Lenovo YOGA 910-13IKB",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
			DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo YOGA 910-13IKB"),
		},
	},
951 952 953
	{}
};

954
static int ideapad_acpi_add(struct platform_device *pdev)
David Woodhouse's avatar
David Woodhouse committed
955
{
956
	int ret, i;
957
	int cfg;
958
	struct ideapad_private *priv;
959 960 961 962 963
	struct acpi_device *adev;

	ret = acpi_bus_get_device(ACPI_HANDLE(&pdev->dev), &adev);
	if (ret)
		return -ENODEV;
David Woodhouse's avatar
David Woodhouse committed
964

965
	if (read_method_int(adev->handle, "_CFG", &cfg))
966 967
		return -ENODEV;

968
	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
969 970
	if (!priv)
		return -ENOMEM;
971 972

	dev_set_drvdata(&pdev->dev, priv);
973
	priv->cfg = cfg;
974
	priv->adev = adev;
975
	priv->platform_device = pdev;
976
	priv->has_hw_rfkill_switch = !dmi_check_system(no_hw_rfkill_list);
977

978
	ret = ideapad_sysfs_init(priv);
979
	if (ret)
980
		return ret;
981

Ike Panhc's avatar
Ike Panhc committed
982 983 984 985
	ret = ideapad_debugfs_init(priv);
	if (ret)
		goto debugfs_failed;

986
	ret = ideapad_input_init(priv);
Ike Panhc's avatar
Ike Panhc committed
987 988 989
	if (ret)
		goto input_failed;

990 991 992 993 994 995 996 997 998 999 1000
	/*
	 * On some models without a hw-switch (the yoga 2 13 at least)
	 * VPCCMD_W_RF must be explicitly set to 1 for the wifi to work.
	 */
	if (!priv->has_hw_rfkill_switch)
		write_ec_cmd(priv->adev->handle, VPCCMD_W_RF, 1);

	for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
		if (test_bit(ideapad_rfk_data[i].cfgbit, &priv->cfg))
			ideapad_register_rfkill(priv, i);

1001
	ideapad_sync_rfk_state(priv);
1002
	ideapad_sync_touchpad_state(priv);
1003

1004
	if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
Ike Panhc's avatar
Ike Panhc committed
1005 1006 1007 1008
		ret = ideapad_backlight_init(priv);
		if (ret && ret != -ENODEV)
			goto backlight_failed;
	}
1009 1010 1011 1012
	ret = acpi_install_notify_handler(adev->handle,
		ACPI_DEVICE_NOTIFY, ideapad_acpi_notify, priv);
	if (ret)
		goto notification_failed;
1013

1014
#if IS_ENABLED(CONFIG_ACPI_WMI)
1015 1016 1017 1018 1019 1020 1021 1022
	for (i = 0; i < ARRAY_SIZE(ideapad_wmi_fnesc_events); i++) {
		ret = wmi_install_notify_handler(ideapad_wmi_fnesc_events[i],
						 ideapad_wmi_notify, priv);
		if (ret == AE_OK) {
			priv->fnesc_guid = ideapad_wmi_fnesc_events[i];
			break;
		}
	}
1023 1024 1025
	if (ret != AE_OK && ret != AE_NOT_EXIST)
		goto notification_failed_wmi;
#endif
Ike Panhc's avatar
Ike Panhc committed
1026

David Woodhouse's avatar
David Woodhouse committed
1027
	return 0;
1028 1029 1030 1031 1032
#if IS_ENABLED(CONFIG_ACPI_WMI)
notification_failed_wmi:
	acpi_remove_notify_handler(priv->adev->handle,
		ACPI_DEVICE_NOTIFY, ideapad_acpi_notify);
#endif
1033 1034
notification_failed:
	ideapad_backlight_exit(priv);
Ike Panhc's avatar
Ike Panhc committed
1035 1036
backlight_failed:
	for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
1037
		ideapad_unregister_rfkill(priv, i);
1038
	ideapad_input_exit(priv);
Ike Panhc's avatar
Ike Panhc committed
1039
input_failed:
Ike Panhc's avatar
Ike Panhc committed
1040 1041
	ideapad_debugfs_exit(priv);
debugfs_failed:
1042
	ideapad_sysfs_exit(priv);
1043
	return ret;
David Woodhouse's avatar
David Woodhouse committed
1044 1045
}

1046
static int ideapad_acpi_remove(struct platform_device *pdev)
David Woodhouse's avatar
David Woodhouse committed
1047
{
1048
	struct ideapad_private *priv = dev_get_drvdata(&pdev->dev);
David Woodhouse's avatar
David Woodhouse committed
1049
	int i;
1050

1051
#if IS_ENABLED(CONFIG_ACPI_WMI)
1052 1053
	if (priv->fnesc_guid)
		wmi_remove_notify_handler(priv->fnesc_guid);
1054
#endif
1055 1056
	acpi_remove_notify_handler(priv->adev->handle,
		ACPI_DEVICE_NOTIFY, ideapad_acpi_notify);
Ike Panhc's avatar
Ike Panhc committed
1057
	ideapad_backlight_exit(priv);
1058
	for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
1059
		ideapad_unregister_rfkill(priv, i);
1060
	ideapad_input_exit(priv);
Ike Panhc's avatar
Ike Panhc committed
1061
	ideapad_debugfs_exit(priv);
1062 1063
	ideapad_sysfs_exit(priv);
	dev_set_drvdata(&pdev->dev, NULL);
1064

David Woodhouse's avatar
David Woodhouse committed
1065 1066 1067
	return 0;
}

1068
#ifdef CONFIG_PM_SLEEP
1069 1070
static int ideapad_acpi_resume(struct device *device)
{
1071 1072 1073 1074 1075 1076 1077 1078
	struct ideapad_private *priv;

	if (!device)
		return -EINVAL;
	priv = dev_get_drvdata(device);

	ideapad_sync_rfk_state(priv);
	ideapad_sync_touchpad_state(priv);
1079 1080
	return 0;
}
1081
#endif
1082
static SIMPLE_DEV_PM_OPS(ideapad_pm, NULL, ideapad_acpi_resume);
1083

1084 1085 1086
static const struct acpi_device_id ideapad_device_ids[] = {
	{ "VPC2004", 0},
	{ "", 0},
David Woodhouse's avatar
David Woodhouse committed
1087
};
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
MODULE_DEVICE_TABLE(acpi, ideapad_device_ids);

static struct platform_driver ideapad_acpi_driver = {
	.probe = ideapad_acpi_add,
	.remove = ideapad_acpi_remove,
	.driver = {
		.name   = "ideapad_acpi",
		.pm     = &ideapad_pm,
		.acpi_match_table = ACPI_PTR(ideapad_device_ids),
	},
};

module_platform_driver(ideapad_acpi_driver);
David Woodhouse's avatar
David Woodhouse committed
1101 1102 1103 1104

MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
MODULE_DESCRIPTION("IdeaPad ACPI Extras");
MODULE_LICENSE("GPL");