1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  ideapad-laptop.c - Lenovo IdeaPad ACPI Extras
   4 *
   5 *  Copyright © 2010 Intel Corporation
   6 *  Copyright © 2010 David Woodhouse <dwmw2@infradead.org>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
   7 */
   8
   9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  10
  11#include <linux/acpi.h>
  12#include <linux/backlight.h>
  13#include <linux/bitops.h>
  14#include <linux/bug.h>
  15#include <linux/debugfs.h>
  16#include <linux/device.h>
  17#include <linux/dmi.h>
  18#include <linux/fb.h>
  19#include <linux/i8042.h>
  20#include <linux/init.h>
  21#include <linux/input.h>
  22#include <linux/input/sparse-keymap.h>
  23#include <linux/jiffies.h>
  24#include <linux/kernel.h>
  25#include <linux/leds.h>
  26#include <linux/module.h>
  27#include <linux/platform_device.h>
  28#include <linux/platform_profile.h>
 
  29#include <linux/rfkill.h>
 
 
 
 
 
 
  30#include <linux/seq_file.h>
  31#include <linux/sysfs.h>
  32#include <linux/types.h>
  33#include <linux/wmi.h>
  34
  35#include <acpi/video.h>
  36
  37#include <dt-bindings/leds/common.h>
  38
  39#define IDEAPAD_RFKILL_DEV_NUM	3
  40
  41enum {
  42	CFG_CAP_BT_BIT       = 16,
  43	CFG_CAP_3G_BIT       = 17,
  44	CFG_CAP_WIFI_BIT     = 18,
  45	CFG_CAP_CAM_BIT      = 19,
  46
  47	/*
  48	 * These are OnScreenDisplay support bits that can be useful to determine
  49	 * whether a hotkey exists/should show OSD. But they aren't particularly
  50	 * meaningful since they were introduced later, i.e. 2010 IdeaPads
  51	 * don't have these, but they still have had OSD for hotkeys.
  52	 */
  53	CFG_OSD_NUMLK_BIT    = 27,
  54	CFG_OSD_CAPSLK_BIT   = 28,
  55	CFG_OSD_MICMUTE_BIT  = 29,
  56	CFG_OSD_TOUCHPAD_BIT = 30,
  57	CFG_OSD_CAM_BIT      = 31,
  58};
  59
  60enum {
  61	GBMD_CONSERVATION_STATE_BIT = 5,
  62};
  63
  64enum {
  65	SBMC_CONSERVATION_ON  = 3,
  66	SBMC_CONSERVATION_OFF = 5,
  67};
  68
  69enum {
  70	HALS_KBD_BL_SUPPORT_BIT       = 4,
  71	HALS_KBD_BL_STATE_BIT         = 5,
  72	HALS_USB_CHARGING_SUPPORT_BIT = 6,
  73	HALS_USB_CHARGING_STATE_BIT   = 7,
  74	HALS_FNLOCK_SUPPORT_BIT       = 9,
  75	HALS_FNLOCK_STATE_BIT         = 10,
  76	HALS_HOTKEYS_PRIMARY_BIT      = 11,
  77};
 
  78
  79enum {
  80	SALS_KBD_BL_ON        = 0x8,
  81	SALS_KBD_BL_OFF       = 0x9,
  82	SALS_USB_CHARGING_ON  = 0xa,
  83	SALS_USB_CHARGING_OFF = 0xb,
  84	SALS_FNLOCK_ON        = 0xe,
  85	SALS_FNLOCK_OFF       = 0xf,
  86};
  87
  88enum {
  89	VPCCMD_R_VPC1 = 0x10,
  90	VPCCMD_R_BL_MAX,
  91	VPCCMD_R_BL,
  92	VPCCMD_W_BL,
  93	VPCCMD_R_WIFI,
  94	VPCCMD_W_WIFI,
  95	VPCCMD_R_BT,
  96	VPCCMD_W_BT,
  97	VPCCMD_R_BL_POWER,
  98	VPCCMD_R_NOVO,
  99	VPCCMD_R_VPC2,
 100	VPCCMD_R_TOUCHPAD,
 101	VPCCMD_W_TOUCHPAD,
 102	VPCCMD_R_CAMERA,
 103	VPCCMD_W_CAMERA,
 104	VPCCMD_R_3G,
 105	VPCCMD_W_3G,
 106	VPCCMD_R_ODD, /* 0x21 */
 107	VPCCMD_W_FAN,
 108	VPCCMD_R_RF,
 109	VPCCMD_W_RF,
 110	VPCCMD_R_FAN = 0x2B,
 111	VPCCMD_R_SPECIAL_BUTTONS = 0x31,
 112	VPCCMD_W_BL_POWER = 0x33,
 113};
 114
 115struct ideapad_dytc_priv {
 116	enum platform_profile_option current_profile;
 117	struct platform_profile_handler pprof;
 118	struct mutex mutex; /* protects the DYTC interface */
 119	struct ideapad_private *priv;
 120};
 121
 122struct ideapad_rfk_priv {
 123	int dev;
 124	struct ideapad_private *priv;
 125};
 126
 127struct ideapad_private {
 128	struct acpi_device *adev;
 129	struct rfkill *rfk[IDEAPAD_RFKILL_DEV_NUM];
 130	struct ideapad_rfk_priv rfk_priv[IDEAPAD_RFKILL_DEV_NUM];
 131	struct platform_device *platform_device;
 132	struct input_dev *inputdev;
 133	struct backlight_device *blightdev;
 134	struct ideapad_dytc_priv *dytc;
 135	struct dentry *debug;
 136	unsigned long cfg;
 137	unsigned long r_touchpad_val;
 138	struct {
 139		bool conservation_mode    : 1;
 140		bool dytc                 : 1;
 141		bool fan_mode             : 1;
 142		bool fn_lock              : 1;
 143		bool set_fn_lock_led      : 1;
 144		bool hw_rfkill_switch     : 1;
 145		bool kbd_bl               : 1;
 146		bool touchpad_ctrl_via_ec : 1;
 147		bool ctrl_ps2_aux_port    : 1;
 148		bool usb_charging         : 1;
 149	} features;
 150	struct {
 151		bool initialized;
 152		struct led_classdev led;
 153		unsigned int last_brightness;
 154	} kbd_bl;
 155};
 156
 157static bool no_bt_rfkill;
 158module_param(no_bt_rfkill, bool, 0444);
 159MODULE_PARM_DESC(no_bt_rfkill, "No rfkill for bluetooth.");
 160
 161static bool allow_v4_dytc;
 162module_param(allow_v4_dytc, bool, 0444);
 163MODULE_PARM_DESC(allow_v4_dytc,
 164	"Enable DYTC version 4 platform-profile support. "
 165	"If you need this please report this to: platform-driver-x86@vger.kernel.org");
 166
 167static bool hw_rfkill_switch;
 168module_param(hw_rfkill_switch, bool, 0444);
 169MODULE_PARM_DESC(hw_rfkill_switch,
 170	"Enable rfkill support for laptops with a hw on/off wifi switch/slider. "
 171	"If you need this please report this to: platform-driver-x86@vger.kernel.org");
 172
 173static bool set_fn_lock_led;
 174module_param(set_fn_lock_led, bool, 0444);
 175MODULE_PARM_DESC(set_fn_lock_led,
 176	"Enable driver based updates of the fn-lock LED on fn-lock changes. "
 177	"If you need this please report this to: platform-driver-x86@vger.kernel.org");
 178
 179static bool ctrl_ps2_aux_port;
 180module_param(ctrl_ps2_aux_port, bool, 0444);
 181MODULE_PARM_DESC(ctrl_ps2_aux_port,
 182	"Enable driver based PS/2 aux port en-/dis-abling on touchpad on/off toggle. "
 183	"If you need this please report this to: platform-driver-x86@vger.kernel.org");
 184
 185static bool touchpad_ctrl_via_ec;
 186module_param(touchpad_ctrl_via_ec, bool, 0444);
 187MODULE_PARM_DESC(touchpad_ctrl_via_ec,
 188	"Enable registering a 'touchpad' sysfs-attribute which can be used to manually "
 189	"tell the EC to enable/disable the touchpad. This may not work on all models.");
 190
 191/*
 192 * shared data
 193 */
 194
 195static struct ideapad_private *ideapad_shared;
 196static DEFINE_MUTEX(ideapad_shared_mutex);
 197
 198static int ideapad_shared_init(struct ideapad_private *priv)
 199{
 200	int ret;
 201
 202	mutex_lock(&ideapad_shared_mutex);
 203
 204	if (!ideapad_shared) {
 205		ideapad_shared = priv;
 206		ret = 0;
 207	} else {
 208		dev_warn(&priv->adev->dev, "found multiple platform devices\n");
 209		ret = -EINVAL;
 210	}
 211
 212	mutex_unlock(&ideapad_shared_mutex);
 213
 214	return ret;
 215}
 216
 217static void ideapad_shared_exit(struct ideapad_private *priv)
 218{
 219	mutex_lock(&ideapad_shared_mutex);
 220
 221	if (ideapad_shared == priv)
 222		ideapad_shared = NULL;
 223
 224	mutex_unlock(&ideapad_shared_mutex);
 225}
 226
 227/*
 228 * ACPI Helpers
 229 */
 230#define IDEAPAD_EC_TIMEOUT 200 /* in ms */
 231
 232static int eval_int(acpi_handle handle, const char *name, unsigned long *res)
 233{
 234	unsigned long long result;
 235	acpi_status status;
 
 236
 237	status = acpi_evaluate_integer(handle, (char *)name, NULL, &result);
 238	if (ACPI_FAILURE(status))
 239		return -EIO;
 240
 241	*res = result;
 242
 243	return 0;
 244}
 245
 246static int exec_simple_method(acpi_handle handle, const char *name, unsigned long arg)
 247{
 248	acpi_status status = acpi_execute_simple_method(handle, (char *)name, arg);
 249
 250	return ACPI_FAILURE(status) ? -EIO : 0;
 251}
 252
 253static int eval_gbmd(acpi_handle handle, unsigned long *res)
 254{
 255	return eval_int(handle, "GBMD", res);
 256}
 257
 258static int exec_sbmc(acpi_handle handle, unsigned long arg)
 259{
 260	return exec_simple_method(handle, "SBMC", arg);
 261}
 262
 263static int eval_hals(acpi_handle handle, unsigned long *res)
 264{
 265	return eval_int(handle, "HALS", res);
 266}
 267
 268static int exec_sals(acpi_handle handle, unsigned long arg)
 269{
 270	return exec_simple_method(handle, "SALS", arg);
 271}
 272
 273static int eval_int_with_arg(acpi_handle handle, const char *name, unsigned long arg, unsigned long *res)
 274{
 275	struct acpi_object_list params;
 276	unsigned long long result;
 
 277	union acpi_object in_obj;
 278	acpi_status status;
 279
 280	params.count = 1;
 281	params.pointer = &in_obj;
 282	in_obj.type = ACPI_TYPE_INTEGER;
 283	in_obj.integer.value = arg;
 284
 285	status = acpi_evaluate_integer(handle, (char *)name, &params, &result);
 286	if (ACPI_FAILURE(status))
 287		return -EIO;
 288
 289	if (res)
 290		*res = result;
 291
 
 
 
 
 
 292	return 0;
 293}
 294
 295static int eval_dytc(acpi_handle handle, unsigned long cmd, unsigned long *res)
 296{
 297	return eval_int_with_arg(handle, "DYTC", cmd, res);
 298}
 299
 300static int eval_vpcr(acpi_handle handle, unsigned long cmd, unsigned long *res)
 301{
 302	return eval_int_with_arg(handle, "VPCR", cmd, res);
 303}
 304
 305static int eval_vpcw(acpi_handle handle, unsigned long cmd, unsigned long data)
 306{
 307	struct acpi_object_list params;
 308	union acpi_object in_obj[2];
 309	acpi_status status;
 310
 311	params.count = 2;
 312	params.pointer = in_obj;
 313	in_obj[0].type = ACPI_TYPE_INTEGER;
 314	in_obj[0].integer.value = cmd;
 315	in_obj[1].type = ACPI_TYPE_INTEGER;
 316	in_obj[1].integer.value = data;
 317
 318	status = acpi_evaluate_object(handle, "VPCW", &params, NULL);
 319	if (ACPI_FAILURE(status))
 320		return -EIO;
 321
 322	return 0;
 323}
 324
 325static int read_ec_data(acpi_handle handle, unsigned long cmd, unsigned long *data)
 326{
 327	unsigned long end_jiffies, val;
 328	int err;
 329
 330	err = eval_vpcw(handle, 1, cmd);
 331	if (err)
 332		return err;
 333
 334	end_jiffies = jiffies + msecs_to_jiffies(IDEAPAD_EC_TIMEOUT) + 1;
 
 335
 336	while (time_before(jiffies, end_jiffies)) {
 
 337		schedule();
 338
 339		err = eval_vpcr(handle, 1, &val);
 340		if (err)
 341			return err;
 342
 343		if (val == 0)
 344			return eval_vpcr(handle, 0, data);
 
 345	}
 346
 347	acpi_handle_err(handle, "timeout in %s\n", __func__);
 348
 349	return -ETIMEDOUT;
 350}
 351
 352static int write_ec_cmd(acpi_handle handle, unsigned long cmd, unsigned long data)
 353{
 354	unsigned long end_jiffies, val;
 355	int err;
 356
 357	err = eval_vpcw(handle, 0, data);
 358	if (err)
 359		return err;
 360
 361	err = eval_vpcw(handle, 1, cmd);
 362	if (err)
 363		return err;
 364
 365	end_jiffies = jiffies + msecs_to_jiffies(IDEAPAD_EC_TIMEOUT) + 1;
 
 
 
 366
 367	while (time_before(jiffies, end_jiffies)) {
 
 368		schedule();
 369
 370		err = eval_vpcr(handle, 1, &val);
 371		if (err)
 372			return err;
 373
 374		if (val == 0)
 375			return 0;
 376	}
 377
 378	acpi_handle_err(handle, "timeout in %s\n", __func__);
 379
 380	return -ETIMEDOUT;
 381}
 382
 383/*
 384 * debugfs
 385 */
 386static int debugfs_status_show(struct seq_file *s, void *data)
 387{
 388	struct ideapad_private *priv = s->private;
 389	unsigned long value;
 390
 
 
 
 391	if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &value))
 392		seq_printf(s, "Backlight max:  %lu\n", value);
 393	if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL, &value))
 394		seq_printf(s, "Backlight now:  %lu\n", value);
 395	if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &value))
 396		seq_printf(s, "BL power value: %s (%lu)\n", value ? "on" : "off", value);
 397
 398	seq_puts(s, "=====================\n");
 399
 400	if (!read_ec_data(priv->adev->handle, VPCCMD_R_RF, &value))
 401		seq_printf(s, "Radio status: %s (%lu)\n", value ? "on" : "off", value);
 
 402	if (!read_ec_data(priv->adev->handle, VPCCMD_R_WIFI, &value))
 403		seq_printf(s, "Wifi status:  %s (%lu)\n", value ? "on" : "off", value);
 
 404	if (!read_ec_data(priv->adev->handle, VPCCMD_R_BT, &value))
 405		seq_printf(s, "BT status:    %s (%lu)\n", value ? "on" : "off", value);
 
 406	if (!read_ec_data(priv->adev->handle, VPCCMD_R_3G, &value))
 407		seq_printf(s, "3G status:    %s (%lu)\n", value ? "on" : "off", value);
 408
 409	seq_puts(s, "=====================\n");
 410
 411	if (!read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value))
 412		seq_printf(s, "Touchpad status: %s (%lu)\n", value ? "on" : "off", value);
 
 413	if (!read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &value))
 414		seq_printf(s, "Camera status:   %s (%lu)\n", value ? "on" : "off", value);
 415
 416	seq_puts(s, "=====================\n");
 417
 418	if (!eval_gbmd(priv->adev->handle, &value))
 419		seq_printf(s, "GBMD: %#010lx\n", value);
 420	if (!eval_hals(priv->adev->handle, &value))
 421		seq_printf(s, "HALS: %#010lx\n", value);
 
 422
 423	return 0;
 424}
 425DEFINE_SHOW_ATTRIBUTE(debugfs_status);
 426
 427static int debugfs_cfg_show(struct seq_file *s, void *data)
 428{
 429	struct ideapad_private *priv = s->private;
 430
 431	seq_printf(s, "_CFG: %#010lx\n\n", priv->cfg);
 432
 433	seq_puts(s, "Capabilities:");
 434	if (test_bit(CFG_CAP_BT_BIT, &priv->cfg))
 435		seq_puts(s, " bluetooth");
 436	if (test_bit(CFG_CAP_3G_BIT, &priv->cfg))
 437		seq_puts(s, " 3G");
 438	if (test_bit(CFG_CAP_WIFI_BIT, &priv->cfg))
 439		seq_puts(s, " wifi");
 440	if (test_bit(CFG_CAP_CAM_BIT, &priv->cfg))
 441		seq_puts(s, " camera");
 442	seq_puts(s, "\n");
 443
 444	seq_puts(s, "OSD support:");
 445	if (test_bit(CFG_OSD_NUMLK_BIT, &priv->cfg))
 446		seq_puts(s, " num-lock");
 447	if (test_bit(CFG_OSD_CAPSLK_BIT, &priv->cfg))
 448		seq_puts(s, " caps-lock");
 449	if (test_bit(CFG_OSD_MICMUTE_BIT, &priv->cfg))
 450		seq_puts(s, " mic-mute");
 451	if (test_bit(CFG_OSD_TOUCHPAD_BIT, &priv->cfg))
 452		seq_puts(s, " touchpad");
 453	if (test_bit(CFG_OSD_CAM_BIT, &priv->cfg))
 454		seq_puts(s, " camera");
 455	seq_puts(s, "\n");
 456
 457	seq_puts(s, "Graphics: ");
 458	switch (priv->cfg & 0x700) {
 459	case 0x100:
 460		seq_puts(s, "Intel");
 461		break;
 462	case 0x200:
 463		seq_puts(s, "ATI");
 464		break;
 465	case 0x300:
 466		seq_puts(s, "Nvidia");
 467		break;
 468	case 0x400:
 469		seq_puts(s, "Intel and ATI");
 470		break;
 471	case 0x500:
 472		seq_puts(s, "Intel and Nvidia");
 473		break;
 474	}
 475	seq_puts(s, "\n");
 476
 477	return 0;
 478}
 479DEFINE_SHOW_ATTRIBUTE(debugfs_cfg);
 480
 481static void ideapad_debugfs_init(struct ideapad_private *priv)
 482{
 483	struct dentry *dir;
 484
 485	dir = debugfs_create_dir("ideapad", NULL);
 486	priv->debug = dir;
 
 
 
 487
 488	debugfs_create_file("cfg", 0444, dir, priv, &debugfs_cfg_fops);
 489	debugfs_create_file("status", 0444, dir, priv, &debugfs_status_fops);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 490}
 491
 492static void ideapad_debugfs_exit(struct ideapad_private *priv)
 493{
 494	debugfs_remove_recursive(priv->debug);
 495	priv->debug = NULL;
 496}
 497
 498/*
 499 * sysfs
 500 */
 501static ssize_t camera_power_show(struct device *dev,
 502				 struct device_attribute *attr,
 503				 char *buf)
 504{
 505	struct ideapad_private *priv = dev_get_drvdata(dev);
 506	unsigned long result;
 507	int err;
 508
 509	err = read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &result);
 510	if (err)
 511		return err;
 512
 513	return sysfs_emit(buf, "%d\n", !!result);
 514}
 515
 516static ssize_t camera_power_store(struct device *dev,
 517				  struct device_attribute *attr,
 518				  const char *buf, size_t count)
 519{
 520	struct ideapad_private *priv = dev_get_drvdata(dev);
 521	bool state;
 522	int err;
 523
 524	err = kstrtobool(buf, &state);
 525	if (err)
 526		return err;
 527
 528	err = write_ec_cmd(priv->adev->handle, VPCCMD_W_CAMERA, state);
 529	if (err)
 530		return err;
 531
 532	return count;
 
 
 533}
 534
 535static DEVICE_ATTR_RW(camera_power);
 536
 537static ssize_t conservation_mode_show(struct device *dev,
 538				      struct device_attribute *attr,
 539				      char *buf)
 540{
 541	struct ideapad_private *priv = dev_get_drvdata(dev);
 542	unsigned long result;
 543	int err;
 544
 545	err = eval_gbmd(priv->adev->handle, &result);
 546	if (err)
 547		return err;
 548
 549	return sysfs_emit(buf, "%d\n", !!test_bit(GBMD_CONSERVATION_STATE_BIT, &result));
 550}
 551
 552static ssize_t conservation_mode_store(struct device *dev,
 553				       struct device_attribute *attr,
 554				       const char *buf, size_t count)
 555{
 556	struct ideapad_private *priv = dev_get_drvdata(dev);
 557	bool state;
 558	int err;
 559
 560	err = kstrtobool(buf, &state);
 561	if (err)
 562		return err;
 563
 564	err = exec_sbmc(priv->adev->handle, state ? SBMC_CONSERVATION_ON : SBMC_CONSERVATION_OFF);
 565	if (err)
 566		return err;
 567
 568	return count;
 569}
 570
 571static DEVICE_ATTR_RW(conservation_mode);
 572
 573static ssize_t fan_mode_show(struct device *dev,
 574			     struct device_attribute *attr,
 575			     char *buf)
 576{
 577	struct ideapad_private *priv = dev_get_drvdata(dev);
 578	unsigned long result;
 579	int err;
 580
 581	err = read_ec_data(priv->adev->handle, VPCCMD_R_FAN, &result);
 582	if (err)
 583		return err;
 584
 585	return sysfs_emit(buf, "%lu\n", result);
 586}
 587
 588static ssize_t fan_mode_store(struct device *dev,
 589			      struct device_attribute *attr,
 590			      const char *buf, size_t count)
 591{
 
 592	struct ideapad_private *priv = dev_get_drvdata(dev);
 593	unsigned int state;
 594	int err;
 595
 596	err = kstrtouint(buf, 0, &state);
 597	if (err)
 598		return err;
 599
 600	if (state > 4 || state == 3)
 601		return -EINVAL;
 602
 603	err = write_ec_cmd(priv->adev->handle, VPCCMD_W_FAN, state);
 604	if (err)
 605		return err;
 606
 607	return count;
 608}
 609
 610static DEVICE_ATTR_RW(fan_mode);
 611
 612static ssize_t fn_lock_show(struct device *dev,
 613			    struct device_attribute *attr,
 614			    char *buf)
 615{
 
 616	struct ideapad_private *priv = dev_get_drvdata(dev);
 617	unsigned long hals;
 618	int err;
 619
 620	err = eval_hals(priv->adev->handle, &hals);
 621	if (err)
 622		return err;
 623
 624	return sysfs_emit(buf, "%d\n", !!test_bit(HALS_FNLOCK_STATE_BIT, &hals));
 
 
 625}
 626
 627static ssize_t fn_lock_store(struct device *dev,
 628			     struct device_attribute *attr,
 629			     const char *buf, size_t count)
 630{
 
 631	struct ideapad_private *priv = dev_get_drvdata(dev);
 632	bool state;
 633	int err;
 634
 635	err = kstrtobool(buf, &state);
 636	if (err)
 637		return err;
 638
 639	err = exec_sals(priv->adev->handle, state ? SALS_FNLOCK_ON : SALS_FNLOCK_OFF);
 640	if (err)
 641		return err;
 642
 
 
 
 
 
 
 
 
 
 643	return count;
 644}
 645
 646static DEVICE_ATTR_RW(fn_lock);
 647
 648static ssize_t touchpad_show(struct device *dev,
 649			     struct device_attribute *attr,
 650			     char *buf)
 651{
 652	struct ideapad_private *priv = dev_get_drvdata(dev);
 653	unsigned long result;
 654	int err;
 655
 656	err = read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &result);
 657	if (err)
 658		return err;
 659
 660	priv->r_touchpad_val = result;
 661
 662	return sysfs_emit(buf, "%d\n", !!result);
 
 
 663}
 664
 665static ssize_t touchpad_store(struct device *dev,
 666			      struct device_attribute *attr,
 667			      const char *buf, size_t count)
 
 668{
 669	struct ideapad_private *priv = dev_get_drvdata(dev);
 670	bool state;
 671	int err;
 672
 673	err = kstrtobool(buf, &state);
 674	if (err)
 675		return err;
 676
 677	err = write_ec_cmd(priv->adev->handle, VPCCMD_W_TOUCHPAD, state);
 678	if (err)
 679		return err;
 680
 681	priv->r_touchpad_val = state;
 
 
 682
 
 
 
 683	return count;
 684}
 685
 686static DEVICE_ATTR_RW(touchpad);
 687
 688static ssize_t usb_charging_show(struct device *dev,
 689				 struct device_attribute *attr,
 690				 char *buf)
 691{
 692	struct ideapad_private *priv = dev_get_drvdata(dev);
 693	unsigned long hals;
 694	int err;
 695
 696	err = eval_hals(priv->adev->handle, &hals);
 697	if (err)
 698		return err;
 699
 700	return sysfs_emit(buf, "%d\n", !!test_bit(HALS_USB_CHARGING_STATE_BIT, &hals));
 
 
 701}
 702
 703static ssize_t usb_charging_store(struct device *dev,
 704				  struct device_attribute *attr,
 705				  const char *buf, size_t count)
 706{
 707	struct ideapad_private *priv = dev_get_drvdata(dev);
 708	bool state;
 709	int err;
 710
 711	err = kstrtobool(buf, &state);
 712	if (err)
 713		return err;
 714
 715	err = exec_sals(priv->adev->handle, state ? SALS_USB_CHARGING_ON : SALS_USB_CHARGING_OFF);
 716	if (err)
 717		return err;
 718
 
 
 
 
 
 719	return count;
 720}
 721
 722static DEVICE_ATTR_RW(usb_charging);
 723
 724static struct attribute *ideapad_attributes[] = {
 725	&dev_attr_camera_power.attr,
 726	&dev_attr_conservation_mode.attr,
 727	&dev_attr_fan_mode.attr,
 728	&dev_attr_fn_lock.attr,
 729	&dev_attr_touchpad.attr,
 730	&dev_attr_usb_charging.attr,
 731	NULL
 732};
 733
 734static umode_t ideapad_is_visible(struct kobject *kobj,
 735				  struct attribute *attr,
 736				  int idx)
 737{
 738	struct device *dev = kobj_to_dev(kobj);
 739	struct ideapad_private *priv = dev_get_drvdata(dev);
 740	bool supported = true;
 741
 742	if (attr == &dev_attr_camera_power.attr)
 743		supported = test_bit(CFG_CAP_CAM_BIT, &priv->cfg);
 744	else if (attr == &dev_attr_conservation_mode.attr)
 745		supported = priv->features.conservation_mode;
 746	else if (attr == &dev_attr_fan_mode.attr)
 747		supported = priv->features.fan_mode;
 748	else if (attr == &dev_attr_fn_lock.attr)
 749		supported = priv->features.fn_lock;
 750	else if (attr == &dev_attr_touchpad.attr)
 751		supported = priv->features.touchpad_ctrl_via_ec;
 752	else if (attr == &dev_attr_usb_charging.attr)
 753		supported = priv->features.usb_charging;
 754
 755	return supported ? attr->mode : 0;
 756}
 757
 758static const struct attribute_group ideapad_attribute_group = {
 759	.is_visible = ideapad_is_visible,
 760	.attrs = ideapad_attributes
 761};
 762
 763/*
 764 * DYTC Platform profile
 765 */
 766#define DYTC_CMD_QUERY        0 /* To get DYTC status - enable/revision */
 767#define DYTC_CMD_SET          1 /* To enable/disable IC function mode */
 768#define DYTC_CMD_GET          2 /* To get current IC function and mode */
 769#define DYTC_CMD_RESET    0x1ff /* To reset back to default */
 770
 771#define DYTC_QUERY_ENABLE_BIT 8  /* Bit        8 - 0 = disabled, 1 = enabled */
 772#define DYTC_QUERY_SUBREV_BIT 16 /* Bits 16 - 27 - sub revision */
 773#define DYTC_QUERY_REV_BIT    28 /* Bits 28 - 31 - revision */
 774
 775#define DYTC_GET_FUNCTION_BIT 8  /* Bits  8-11 - function setting */
 776#define DYTC_GET_MODE_BIT     12 /* Bits 12-15 - mode setting */
 777
 778#define DYTC_SET_FUNCTION_BIT 12 /* Bits 12-15 - function setting */
 779#define DYTC_SET_MODE_BIT     16 /* Bits 16-19 - mode setting */
 780#define DYTC_SET_VALID_BIT    20 /* Bit     20 - 1 = on, 0 = off */
 781
 782#define DYTC_FUNCTION_STD     0  /* Function = 0, standard mode */
 783#define DYTC_FUNCTION_CQL     1  /* Function = 1, lap mode */
 784#define DYTC_FUNCTION_MMC     11 /* Function = 11, desk mode */
 785
 786#define DYTC_MODE_PERFORM     2  /* High power mode aka performance */
 787#define DYTC_MODE_LOW_POWER       3  /* Low power mode aka quiet */
 788#define DYTC_MODE_BALANCE   0xF  /* Default mode aka balanced */
 789
 790#define DYTC_SET_COMMAND(function, mode, on) \
 791	(DYTC_CMD_SET | (function) << DYTC_SET_FUNCTION_BIT | \
 792	 (mode) << DYTC_SET_MODE_BIT | \
 793	 (on) << DYTC_SET_VALID_BIT)
 794
 795#define DYTC_DISABLE_CQL DYTC_SET_COMMAND(DYTC_FUNCTION_CQL, DYTC_MODE_BALANCE, 0)
 796
 797#define DYTC_ENABLE_CQL DYTC_SET_COMMAND(DYTC_FUNCTION_CQL, DYTC_MODE_BALANCE, 1)
 798
 799static int convert_dytc_to_profile(int dytcmode, enum platform_profile_option *profile)
 800{
 801	switch (dytcmode) {
 802	case DYTC_MODE_LOW_POWER:
 803		*profile = PLATFORM_PROFILE_LOW_POWER;
 804		break;
 805	case DYTC_MODE_BALANCE:
 806		*profile =  PLATFORM_PROFILE_BALANCED;
 807		break;
 808	case DYTC_MODE_PERFORM:
 809		*profile =  PLATFORM_PROFILE_PERFORMANCE;
 810		break;
 811	default: /* Unknown mode */
 812		return -EINVAL;
 813	}
 814
 815	return 0;
 816}
 817
 818static int convert_profile_to_dytc(enum platform_profile_option profile, int *perfmode)
 819{
 820	switch (profile) {
 821	case PLATFORM_PROFILE_LOW_POWER:
 822		*perfmode = DYTC_MODE_LOW_POWER;
 823		break;
 824	case PLATFORM_PROFILE_BALANCED:
 825		*perfmode = DYTC_MODE_BALANCE;
 826		break;
 827	case PLATFORM_PROFILE_PERFORMANCE:
 828		*perfmode = DYTC_MODE_PERFORM;
 829		break;
 830	default: /* Unknown profile */
 831		return -EOPNOTSUPP;
 832	}
 833
 834	return 0;
 835}
 836
 837/*
 838 * dytc_profile_get: Function to register with platform_profile
 839 * handler. Returns current platform profile.
 840 */
 841static int dytc_profile_get(struct platform_profile_handler *pprof,
 842			    enum platform_profile_option *profile)
 843{
 844	struct ideapad_dytc_priv *dytc = container_of(pprof, struct ideapad_dytc_priv, pprof);
 845
 846	*profile = dytc->current_profile;
 847	return 0;
 848}
 849
 850/*
 851 * Helper function - check if we are in CQL mode and if we are
 852 *  - disable CQL,
 853 *  - run the command
 854 *  - enable CQL
 855 *  If not in CQL mode, just run the command
 856 */
 857static int dytc_cql_command(struct ideapad_private *priv, unsigned long cmd,
 858			    unsigned long *output)
 859{
 860	int err, cmd_err, cur_funcmode;
 861
 862	/* Determine if we are in CQL mode. This alters the commands we do */
 863	err = eval_dytc(priv->adev->handle, DYTC_CMD_GET, output);
 864	if (err)
 865		return err;
 866
 867	cur_funcmode = (*output >> DYTC_GET_FUNCTION_BIT) & 0xF;
 868	/* Check if we're OK to return immediately */
 869	if (cmd == DYTC_CMD_GET && cur_funcmode != DYTC_FUNCTION_CQL)
 870		return 0;
 871
 872	if (cur_funcmode == DYTC_FUNCTION_CQL) {
 873		err = eval_dytc(priv->adev->handle, DYTC_DISABLE_CQL, NULL);
 874		if (err)
 875			return err;
 876	}
 877
 878	cmd_err = eval_dytc(priv->adev->handle, cmd, output);
 879	/* Check return condition after we've restored CQL state */
 880
 881	if (cur_funcmode == DYTC_FUNCTION_CQL) {
 882		err = eval_dytc(priv->adev->handle, DYTC_ENABLE_CQL, NULL);
 883		if (err)
 884			return err;
 885	}
 886
 887	return cmd_err;
 888}
 889
 890/*
 891 * dytc_profile_set: Function to register with platform_profile
 892 * handler. Sets current platform profile.
 893 */
 894static int dytc_profile_set(struct platform_profile_handler *pprof,
 895			    enum platform_profile_option profile)
 896{
 897	struct ideapad_dytc_priv *dytc = container_of(pprof, struct ideapad_dytc_priv, pprof);
 898	struct ideapad_private *priv = dytc->priv;
 899	unsigned long output;
 900	int err;
 901
 902	err = mutex_lock_interruptible(&dytc->mutex);
 903	if (err)
 904		return err;
 905
 906	if (profile == PLATFORM_PROFILE_BALANCED) {
 907		/* To get back to balanced mode we just issue a reset command */
 908		err = eval_dytc(priv->adev->handle, DYTC_CMD_RESET, NULL);
 909		if (err)
 910			goto unlock;
 911	} else {
 912		int perfmode;
 913
 914		err = convert_profile_to_dytc(profile, &perfmode);
 915		if (err)
 916			goto unlock;
 917
 918		/* Determine if we are in CQL mode. This alters the commands we do */
 919		err = dytc_cql_command(priv, DYTC_SET_COMMAND(DYTC_FUNCTION_MMC, perfmode, 1),
 920				       &output);
 921		if (err)
 922			goto unlock;
 923	}
 924
 925	/* Success - update current profile */
 926	dytc->current_profile = profile;
 927
 928unlock:
 929	mutex_unlock(&dytc->mutex);
 930
 931	return err;
 932}
 933
 934static void dytc_profile_refresh(struct ideapad_private *priv)
 935{
 936	enum platform_profile_option profile;
 937	unsigned long output;
 938	int err, perfmode;
 939
 940	mutex_lock(&priv->dytc->mutex);
 941	err = dytc_cql_command(priv, DYTC_CMD_GET, &output);
 942	mutex_unlock(&priv->dytc->mutex);
 943	if (err)
 944		return;
 945
 946	perfmode = (output >> DYTC_GET_MODE_BIT) & 0xF;
 947
 948	if (convert_dytc_to_profile(perfmode, &profile))
 949		return;
 950
 951	if (profile != priv->dytc->current_profile) {
 952		priv->dytc->current_profile = profile;
 953		platform_profile_notify();
 954	}
 955}
 956
 957static const struct dmi_system_id ideapad_dytc_v4_allow_table[] = {
 958	{
 959		/* Ideapad 5 Pro 16ACH6 */
 960		.matches = {
 961			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 962			DMI_MATCH(DMI_PRODUCT_NAME, "82L5")
 963		}
 964	},
 965	{
 966		/* Ideapad 5 15ITL05 */
 967		.matches = {
 968			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 969			DMI_MATCH(DMI_PRODUCT_VERSION, "IdeaPad 5 15ITL05")
 970		}
 971	},
 972	{}
 973};
 974
 975static int ideapad_dytc_profile_init(struct ideapad_private *priv)
 976{
 977	int err, dytc_version;
 978	unsigned long output;
 979
 980	if (!priv->features.dytc)
 981		return -ENODEV;
 982
 983	err = eval_dytc(priv->adev->handle, DYTC_CMD_QUERY, &output);
 984	/* For all other errors we can flag the failure */
 985	if (err)
 986		return err;
 987
 988	/* Check DYTC is enabled and supports mode setting */
 989	if (!test_bit(DYTC_QUERY_ENABLE_BIT, &output)) {
 990		dev_info(&priv->platform_device->dev, "DYTC_QUERY_ENABLE_BIT returned false\n");
 991		return -ENODEV;
 992	}
 993
 994	dytc_version = (output >> DYTC_QUERY_REV_BIT) & 0xF;
 995
 996	if (dytc_version < 4) {
 997		dev_info(&priv->platform_device->dev, "DYTC_VERSION < 4 is not supported\n");
 998		return -ENODEV;
 999	}
1000
1001	if (dytc_version < 5 &&
1002	    !(allow_v4_dytc || dmi_check_system(ideapad_dytc_v4_allow_table))) {
1003		dev_info(&priv->platform_device->dev,
1004			 "DYTC_VERSION 4 support may not work. Pass ideapad_laptop.allow_v4_dytc=Y on the kernel commandline to enable\n");
1005		return -ENODEV;
1006	}
1007
1008	priv->dytc = kzalloc(sizeof(*priv->dytc), GFP_KERNEL);
1009	if (!priv->dytc)
1010		return -ENOMEM;
1011
1012	mutex_init(&priv->dytc->mutex);
1013
1014	priv->dytc->priv = priv;
1015	priv->dytc->pprof.profile_get = dytc_profile_get;
1016	priv->dytc->pprof.profile_set = dytc_profile_set;
1017
1018	/* Setup supported modes */
1019	set_bit(PLATFORM_PROFILE_LOW_POWER, priv->dytc->pprof.choices);
1020	set_bit(PLATFORM_PROFILE_BALANCED, priv->dytc->pprof.choices);
1021	set_bit(PLATFORM_PROFILE_PERFORMANCE, priv->dytc->pprof.choices);
1022
1023	/* Create platform_profile structure and register */
1024	err = platform_profile_register(&priv->dytc->pprof);
1025	if (err)
1026		goto pp_reg_failed;
1027
1028	/* Ensure initial values are correct */
1029	dytc_profile_refresh(priv);
1030
1031	return 0;
1032
1033pp_reg_failed:
1034	mutex_destroy(&priv->dytc->mutex);
1035	kfree(priv->dytc);
1036	priv->dytc = NULL;
1037
1038	return err;
1039}
1040
1041static void ideapad_dytc_profile_exit(struct ideapad_private *priv)
1042{
1043	if (!priv->dytc)
1044		return;
1045
1046	platform_profile_remove();
1047	mutex_destroy(&priv->dytc->mutex);
1048	kfree(priv->dytc);
1049
1050	priv->dytc = NULL;
1051}
1052
1053/*
1054 * Rfkill
1055 */
1056struct ideapad_rfk_data {
1057	char *name;
1058	int cfgbit;
1059	int opcode;
1060	int type;
1061};
1062
1063static const struct ideapad_rfk_data ideapad_rfk_data[] = {
1064	{ "ideapad_wlan",      CFG_CAP_WIFI_BIT, VPCCMD_W_WIFI, RFKILL_TYPE_WLAN },
1065	{ "ideapad_bluetooth", CFG_CAP_BT_BIT,   VPCCMD_W_BT,   RFKILL_TYPE_BLUETOOTH },
1066	{ "ideapad_3g",        CFG_CAP_3G_BIT,   VPCCMD_W_3G,   RFKILL_TYPE_WWAN },
1067};
1068
1069static int ideapad_rfk_set(void *data, bool blocked)
1070{
1071	struct ideapad_rfk_priv *priv = data;
1072	int opcode = ideapad_rfk_data[priv->dev].opcode;
1073
1074	return write_ec_cmd(priv->priv->adev->handle, opcode, !blocked);
1075}
1076
1077static const struct rfkill_ops ideapad_rfk_ops = {
1078	.set_block = ideapad_rfk_set,
1079};
1080
1081static void ideapad_sync_rfk_state(struct ideapad_private *priv)
1082{
1083	unsigned long hw_blocked = 0;
1084	int i;
1085
1086	if (priv->features.hw_rfkill_switch) {
1087		if (read_ec_data(priv->adev->handle, VPCCMD_R_RF, &hw_blocked))
1088			return;
1089		hw_blocked = !hw_blocked;
1090	}
1091
1092	for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
1093		if (priv->rfk[i])
1094			rfkill_set_hw_state(priv->rfk[i], hw_blocked);
1095}
1096
1097static int ideapad_register_rfkill(struct ideapad_private *priv, int dev)
1098{
1099	unsigned long rf_enabled;
1100	int err;
1101
1102	if (no_bt_rfkill && ideapad_rfk_data[dev].type == RFKILL_TYPE_BLUETOOTH) {
 
1103		/* Force to enable bluetooth when no_bt_rfkill=1 */
1104		write_ec_cmd(priv->adev->handle, ideapad_rfk_data[dev].opcode, 1);
 
1105		return 0;
1106	}
1107
1108	priv->rfk_priv[dev].dev = dev;
1109	priv->rfk_priv[dev].priv = priv;
1110
1111	priv->rfk[dev] = rfkill_alloc(ideapad_rfk_data[dev].name,
1112				      &priv->platform_device->dev,
1113				      ideapad_rfk_data[dev].type,
1114				      &ideapad_rfk_ops,
1115				      &priv->rfk_priv[dev]);
1116	if (!priv->rfk[dev])
1117		return -ENOMEM;
1118
1119	err = read_ec_data(priv->adev->handle, ideapad_rfk_data[dev].opcode - 1, &rf_enabled);
1120	if (err)
1121		rf_enabled = 1;
1122
1123	rfkill_init_sw_state(priv->rfk[dev], !rf_enabled);
 
 
1124
1125	err = rfkill_register(priv->rfk[dev]);
1126	if (err)
1127		rfkill_destroy(priv->rfk[dev]);
1128
1129	return err;
 
1130}
1131
1132static void ideapad_unregister_rfkill(struct ideapad_private *priv, int dev)
1133{
1134	if (!priv->rfk[dev])
1135		return;
1136
1137	rfkill_unregister(priv->rfk[dev]);
1138	rfkill_destroy(priv->rfk[dev]);
1139}
1140
1141/*
1142 * Platform device
1143 */
1144static int ideapad_sysfs_init(struct ideapad_private *priv)
1145{
1146	return device_add_group(&priv->platform_device->dev,
1147				&ideapad_attribute_group);
1148}
1149
1150static void ideapad_sysfs_exit(struct ideapad_private *priv)
1151{
1152	device_remove_group(&priv->platform_device->dev,
1153			    &ideapad_attribute_group);
1154}
1155
1156/*
1157 * input device
1158 */
1159#define IDEAPAD_WMI_KEY 0x100
1160
1161static const struct key_entry ideapad_keymap[] = {
1162	{ KE_KEY,   6, { KEY_SWITCHVIDEOMODE } },
1163	{ KE_KEY,   7, { KEY_CAMERA } },
1164	{ KE_KEY,   8, { KEY_MICMUTE } },
1165	{ KE_KEY,  11, { KEY_F16 } },
1166	{ KE_KEY,  13, { KEY_WLAN } },
1167	{ KE_KEY,  16, { KEY_PROG1 } },
1168	{ KE_KEY,  17, { KEY_PROG2 } },
1169	{ KE_KEY,  64, { KEY_PROG3 } },
1170	{ KE_KEY,  65, { KEY_PROG4 } },
1171	{ KE_KEY,  66, { KEY_TOUCHPAD_OFF } },
1172	{ KE_KEY,  67, { KEY_TOUCHPAD_ON } },
1173	{ KE_KEY,  68, { KEY_TOUCHPAD_TOGGLE } },
1174	{ KE_KEY, 128, { KEY_ESC } },
1175
1176	/*
1177	 * WMI keys
1178	 */
1179
1180	/* FnLock (handled by the firmware) */
1181	{ KE_IGNORE,	0x02 | IDEAPAD_WMI_KEY },
1182	/* Esc (handled by the firmware) */
1183	{ KE_IGNORE,	0x03 | IDEAPAD_WMI_KEY },
1184	/* Customizable Lenovo Hotkey ("star" with 'S' inside) */
1185	{ KE_KEY,	0x01 | IDEAPAD_WMI_KEY, { KEY_FAVORITES } },
1186	/* Dark mode toggle */
1187	{ KE_KEY,	0x13 | IDEAPAD_WMI_KEY, { KEY_PROG1 } },
1188	/* Sound profile switch */
1189	{ KE_KEY,	0x12 | IDEAPAD_WMI_KEY, { KEY_PROG2 } },
1190	/* Lenovo Virtual Background application */
1191	{ KE_KEY,	0x28 | IDEAPAD_WMI_KEY, { KEY_PROG3 } },
1192	/* Lenovo Support */
1193	{ KE_KEY,	0x27 | IDEAPAD_WMI_KEY, { KEY_HELP } },
1194	/* Refresh Rate Toggle */
1195	{ KE_KEY,	0x0a | IDEAPAD_WMI_KEY, { KEY_DISPLAYTOGGLE } },
1196
1197	{ KE_END },
1198};
1199
1200static int ideapad_input_init(struct ideapad_private *priv)
1201{
1202	struct input_dev *inputdev;
1203	int err;
1204
1205	inputdev = input_allocate_device();
1206	if (!inputdev)
1207		return -ENOMEM;
1208
1209	inputdev->name = "Ideapad extra buttons";
1210	inputdev->phys = "ideapad/input0";
1211	inputdev->id.bustype = BUS_HOST;
1212	inputdev->dev.parent = &priv->platform_device->dev;
1213
1214	err = sparse_keymap_setup(inputdev, ideapad_keymap, NULL);
1215	if (err) {
1216		dev_err(&priv->platform_device->dev,
1217			"Could not set up input device keymap: %d\n", err);
1218		goto err_free_dev;
1219	}
1220
1221	err = input_register_device(inputdev);
1222	if (err) {
1223		dev_err(&priv->platform_device->dev,
1224			"Could not register input device: %d\n", err);
1225		goto err_free_dev;
1226	}
1227
1228	priv->inputdev = inputdev;
1229
1230	return 0;
1231
1232err_free_dev:
1233	input_free_device(inputdev);
1234
1235	return err;
1236}
1237
1238static void ideapad_input_exit(struct ideapad_private *priv)
1239{
1240	input_unregister_device(priv->inputdev);
1241	priv->inputdev = NULL;
1242}
1243
1244static void ideapad_input_report(struct ideapad_private *priv,
1245				 unsigned long scancode)
1246{
1247	sparse_keymap_report_event(priv->inputdev, scancode, 1, true);
1248}
1249
1250static void ideapad_input_novokey(struct ideapad_private *priv)
1251{
1252	unsigned long long_pressed;
1253
1254	if (read_ec_data(priv->adev->handle, VPCCMD_R_NOVO, &long_pressed))
1255		return;
1256
1257	if (long_pressed)
1258		ideapad_input_report(priv, 17);
1259	else
1260		ideapad_input_report(priv, 16);
1261}
1262
1263static void ideapad_check_special_buttons(struct ideapad_private *priv)
1264{
1265	unsigned long bit, value;
1266
1267	if (read_ec_data(priv->adev->handle, VPCCMD_R_SPECIAL_BUTTONS, &value))
1268		return;
1269
1270	for_each_set_bit (bit, &value, 16) {
1271		switch (bit) {
1272		case 6:	/* Z570 */
1273		case 0:	/* Z580 */
1274			/* Thermal Management button */
1275			ideapad_input_report(priv, 65);
1276			break;
1277		case 1:
1278			/* OneKey Theater button */
1279			ideapad_input_report(priv, 64);
1280			break;
1281		default:
1282			dev_info(&priv->platform_device->dev,
1283				 "Unknown special button: %lu\n", bit);
1284			break;
 
1285		}
1286	}
1287}
1288
1289/*
1290 * backlight
1291 */
1292static int ideapad_backlight_get_brightness(struct backlight_device *blightdev)
1293{
1294	struct ideapad_private *priv = bl_get_data(blightdev);
1295	unsigned long now;
1296	int err;
1297
1298	err = read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now);
1299	if (err)
1300		return err;
1301
 
 
1302	return now;
1303}
1304
1305static int ideapad_backlight_update_status(struct backlight_device *blightdev)
1306{
1307	struct ideapad_private *priv = bl_get_data(blightdev);
1308	int err;
1309
1310	err = write_ec_cmd(priv->adev->handle, VPCCMD_W_BL,
1311			   blightdev->props.brightness);
1312	if (err)
1313		return err;
1314
1315	err = write_ec_cmd(priv->adev->handle, VPCCMD_W_BL_POWER,
1316			   blightdev->props.power != FB_BLANK_POWERDOWN);
1317	if (err)
1318		return err;
1319
1320	return 0;
1321}
1322
1323static const struct backlight_ops ideapad_backlight_ops = {
1324	.get_brightness = ideapad_backlight_get_brightness,
1325	.update_status = ideapad_backlight_update_status,
1326};
1327
1328static int ideapad_backlight_init(struct ideapad_private *priv)
1329{
1330	struct backlight_device *blightdev;
1331	struct backlight_properties props;
1332	unsigned long max, now, power;
1333	int err;
1334
1335	err = read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &max);
1336	if (err)
1337		return err;
1338
1339	err = read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now);
1340	if (err)
1341		return err;
1342
1343	err = read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power);
1344	if (err)
1345		return err;
1346
1347	memset(&props, 0, sizeof(props));
 
1348
 
1349	props.max_brightness = max;
1350	props.type = BACKLIGHT_PLATFORM;
1351
1352	blightdev = backlight_device_register("ideapad",
1353					      &priv->platform_device->dev,
1354					      priv,
1355					      &ideapad_backlight_ops,
1356					      &props);
1357	if (IS_ERR(blightdev)) {
1358		err = PTR_ERR(blightdev);
1359		dev_err(&priv->platform_device->dev,
1360			"Could not register backlight device: %d\n", err);
1361		return err;
1362	}
1363
1364	priv->blightdev = blightdev;
1365	blightdev->props.brightness = now;
1366	blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
1367
1368	backlight_update_status(blightdev);
1369
1370	return 0;
1371}
1372
1373static void ideapad_backlight_exit(struct ideapad_private *priv)
1374{
1375	backlight_device_unregister(priv->blightdev);
1376	priv->blightdev = NULL;
1377}
1378
1379static void ideapad_backlight_notify_power(struct ideapad_private *priv)
1380{
1381	struct backlight_device *blightdev = priv->blightdev;
1382	unsigned long power;
 
1383
1384	if (!blightdev)
1385		return;
1386
1387	if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power))
1388		return;
1389
1390	blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
1391}
1392
1393static void ideapad_backlight_notify_brightness(struct ideapad_private *priv)
1394{
1395	unsigned long now;
1396
1397	/* if we control brightness via acpi video driver */
1398	if (!priv->blightdev)
1399		read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now);
1400	else
1401		backlight_force_update(priv->blightdev, BACKLIGHT_UPDATE_HOTKEY);
1402}
1403
1404/*
1405 * keyboard backlight
1406 */
1407static int ideapad_kbd_bl_brightness_get(struct ideapad_private *priv)
1408{
1409	unsigned long hals;
1410	int err;
1411
1412	err = eval_hals(priv->adev->handle, &hals);
1413	if (err)
1414		return err;
1415
1416	return !!test_bit(HALS_KBD_BL_STATE_BIT, &hals);
1417}
1418
1419static enum led_brightness ideapad_kbd_bl_led_cdev_brightness_get(struct led_classdev *led_cdev)
1420{
1421	struct ideapad_private *priv = container_of(led_cdev, struct ideapad_private, kbd_bl.led);
1422
1423	return ideapad_kbd_bl_brightness_get(priv);
1424}
1425
1426static int ideapad_kbd_bl_brightness_set(struct ideapad_private *priv, unsigned int brightness)
1427{
1428	int err = exec_sals(priv->adev->handle, brightness ? SALS_KBD_BL_ON : SALS_KBD_BL_OFF);
1429
1430	if (err)
1431		return err;
1432
1433	priv->kbd_bl.last_brightness = brightness;
1434
1435	return 0;
1436}
1437
1438static int ideapad_kbd_bl_led_cdev_brightness_set(struct led_classdev *led_cdev,
1439						  enum led_brightness brightness)
1440{
1441	struct ideapad_private *priv = container_of(led_cdev, struct ideapad_private, kbd_bl.led);
1442
1443	return ideapad_kbd_bl_brightness_set(priv, brightness);
1444}
1445
1446static void ideapad_kbd_bl_notify(struct ideapad_private *priv)
1447{
1448	int brightness;
1449
1450	if (!priv->kbd_bl.initialized)
1451		return;
1452
1453	brightness = ideapad_kbd_bl_brightness_get(priv);
1454	if (brightness < 0)
1455		return;
 
1456
1457	if (brightness == priv->kbd_bl.last_brightness)
1458		return;
1459
1460	priv->kbd_bl.last_brightness = brightness;
1461
1462	led_classdev_notify_brightness_hw_changed(&priv->kbd_bl.led, brightness);
1463}
1464
1465static int ideapad_kbd_bl_init(struct ideapad_private *priv)
1466{
1467	int brightness, err;
1468
1469	if (!priv->features.kbd_bl)
1470		return -ENODEV;
1471
1472	if (WARN_ON(priv->kbd_bl.initialized))
1473		return -EEXIST;
1474
1475	brightness = ideapad_kbd_bl_brightness_get(priv);
1476	if (brightness < 0)
1477		return brightness;
1478
1479	priv->kbd_bl.last_brightness = brightness;
1480
1481	priv->kbd_bl.led.name                    = "platform::" LED_FUNCTION_KBD_BACKLIGHT;
1482	priv->kbd_bl.led.max_brightness          = 1;
1483	priv->kbd_bl.led.brightness_get          = ideapad_kbd_bl_led_cdev_brightness_get;
1484	priv->kbd_bl.led.brightness_set_blocking = ideapad_kbd_bl_led_cdev_brightness_set;
1485	priv->kbd_bl.led.flags                   = LED_BRIGHT_HW_CHANGED;
1486
1487	err = led_classdev_register(&priv->platform_device->dev, &priv->kbd_bl.led);
1488	if (err)
1489		return err;
1490
1491	priv->kbd_bl.initialized = true;
1492
1493	return 0;
1494}
1495
1496static void ideapad_kbd_bl_exit(struct ideapad_private *priv)
1497{
1498	if (!priv->kbd_bl.initialized)
1499		return;
1500
1501	priv->kbd_bl.initialized = false;
1502
1503	led_classdev_unregister(&priv->kbd_bl.led);
1504}
1505
1506/*
1507 * module init/exit
1508 */
1509static void ideapad_sync_touchpad_state(struct ideapad_private *priv, bool send_events)
1510{
1511	unsigned long value;
1512	unsigned char param;
1513	int ret;
1514
1515	/* Without reading from EC touchpad LED doesn't switch state */
1516	ret = read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value);
1517	if (ret)
1518		return;
1519
1520	/*
1521	 * Some IdeaPads don't really turn off touchpad - they only
1522	 * switch the LED state. We (de)activate KBC AUX port to turn
1523	 * touchpad off and on. We send KEY_TOUCHPAD_OFF and
1524	 * KEY_TOUCHPAD_ON to not to get out of sync with LED
1525	 */
1526	if (priv->features.ctrl_ps2_aux_port)
1527		i8042_command(&param, value ? I8042_CMD_AUX_ENABLE : I8042_CMD_AUX_DISABLE);
1528
1529	if (send_events) {
1530		/*
1531		 * On older models the EC controls the touchpad and toggles it
1532		 * on/off itself, in this case we report KEY_TOUCHPAD_ON/_OFF.
1533		 * If the EC did not toggle, report KEY_TOUCHPAD_TOGGLE.
1534		 */
1535		if (value != priv->r_touchpad_val) {
1536			ideapad_input_report(priv, value ? 67 : 66);
1537			sysfs_notify(&priv->platform_device->dev.kobj, NULL, "touchpad");
1538		} else {
1539			ideapad_input_report(priv, 68);
1540		}
1541	}
1542
1543	priv->r_touchpad_val = value;
1544}
1545
1546static void ideapad_acpi_notify(acpi_handle handle, u32 event, void *data)
1547{
1548	struct ideapad_private *priv = data;
1549	unsigned long vpc1, vpc2, bit;
1550
1551	if (read_ec_data(handle, VPCCMD_R_VPC1, &vpc1))
1552		return;
1553
1554	if (read_ec_data(handle, VPCCMD_R_VPC2, &vpc2))
1555		return;
1556
1557	vpc1 = (vpc2 << 8) | vpc1;
1558
1559	for_each_set_bit (bit, &vpc1, 16) {
1560		switch (bit) {
1561		case 13:
1562		case 11:
1563		case 8:
1564		case 7:
1565		case 6:
1566			ideapad_input_report(priv, bit);
1567			break;
1568		case 10:
1569			/*
1570			 * This event gets send on a Yoga 300-11IBR when the EC
1571			 * believes that the device has changed between laptop/
1572			 * tent/stand/tablet mode. The EC relies on getting
1573			 * angle info from 2 accelerometers through a special
1574			 * windows service calling a DSM on the DUAL250E ACPI-
1575			 * device. Linux does not do this, making the laptop/
1576			 * tent/stand/tablet mode info unreliable, so we simply
1577			 * ignore these events.
1578			 */
1579			break;
1580		case 9:
1581			ideapad_sync_rfk_state(priv);
1582			break;
1583		case 5:
1584			ideapad_sync_touchpad_state(priv, true);
1585			break;
1586		case 4:
1587			ideapad_backlight_notify_brightness(priv);
1588			break;
1589		case 3:
1590			ideapad_input_novokey(priv);
1591			break;
1592		case 2:
1593			ideapad_backlight_notify_power(priv);
1594			break;
1595		case 1:
1596			/*
1597			 * Some IdeaPads report event 1 every ~20
1598			 * seconds while on battery power; some
1599			 * report this when changing to/from tablet
1600			 * mode; some report this when the keyboard
1601			 * backlight has changed.
1602			 */
1603			ideapad_kbd_bl_notify(priv);
1604			break;
1605		case 0:
1606			ideapad_check_special_buttons(priv);
1607			break;
1608		default:
1609			dev_info(&priv->platform_device->dev,
1610				 "Unknown event: %lu\n", bit);
1611		}
1612	}
1613}
1614
1615/* On some models we need to call exec_sals(SALS_FNLOCK_ON/OFF) to set the LED */
1616static const struct dmi_system_id set_fn_lock_led_list[] = {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1617	{
1618		/* https://bugzilla.kernel.org/show_bug.cgi?id=212671 */
1619		.matches = {
1620			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
1621			DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Legion R7000P2020H"),
1622		}
1623	},
1624	{
 
1625		.matches = {
1626			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
1627			DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Legion 5 15ARH05"),
1628		}
1629	},
1630	{}
1631};
1632
1633/*
1634 * Some ideapads have a hardware rfkill switch, but most do not have one.
1635 * Reading VPCCMD_R_RF always results in 0 on models without a hardware rfkill,
1636 * switch causing ideapad_laptop to wrongly report all radios as hw-blocked.
1637 * There used to be a long list of DMI ids for models without a hw rfkill
1638 * switch here, but that resulted in playing whack a mole.
1639 * More importantly wrongly reporting the wifi radio as hw-blocked, results in
1640 * non working wifi. Whereas not reporting it hw-blocked, when it actually is
1641 * hw-blocked results in an empty SSID list, which is a much more benign
1642 * failure mode.
1643 * So the default now is the much safer option of assuming there is no
1644 * hardware rfkill switch. This default also actually matches most hardware,
1645 * since having a hw rfkill switch is quite rare on modern hardware, so this
1646 * also leads to a much shorter list.
1647 */
1648static const struct dmi_system_id hw_rfkill_list[] = {
1649	{}
1650};
1651
1652/*
1653 * On some models the EC toggles the touchpad muted LED on touchpad toggle
1654 * hotkey presses, but the EC does not actually disable the touchpad itself.
1655 * On these models the driver needs to explicitly enable/disable the i8042
1656 * (PS/2) aux port.
1657 */
1658static const struct dmi_system_id ctrl_ps2_aux_port_list[] = {
1659	{
1660	/* Lenovo Ideapad Z570 */
1661	.matches = {
1662		DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
1663		DMI_MATCH(DMI_PRODUCT_VERSION, "Ideapad Z570"),
1664		},
1665	},
1666	{}
1667};
1668
1669static void ideapad_check_features(struct ideapad_private *priv)
1670{
1671	acpi_handle handle = priv->adev->handle;
1672	unsigned long val;
1673
1674	priv->features.set_fn_lock_led =
1675		set_fn_lock_led || dmi_check_system(set_fn_lock_led_list);
1676	priv->features.hw_rfkill_switch =
1677		hw_rfkill_switch || dmi_check_system(hw_rfkill_list);
1678	priv->features.ctrl_ps2_aux_port =
1679		ctrl_ps2_aux_port || dmi_check_system(ctrl_ps2_aux_port_list);
1680	priv->features.touchpad_ctrl_via_ec = touchpad_ctrl_via_ec;
1681
1682	if (!read_ec_data(handle, VPCCMD_R_FAN, &val))
1683		priv->features.fan_mode = true;
1684
1685	if (acpi_has_method(handle, "GBMD") && acpi_has_method(handle, "SBMC"))
1686		priv->features.conservation_mode = true;
1687
1688	if (acpi_has_method(handle, "DYTC"))
1689		priv->features.dytc = true;
1690
1691	if (acpi_has_method(handle, "HALS") && acpi_has_method(handle, "SALS")) {
1692		if (!eval_hals(handle, &val)) {
1693			if (test_bit(HALS_FNLOCK_SUPPORT_BIT, &val))
1694				priv->features.fn_lock = true;
1695
1696			if (test_bit(HALS_KBD_BL_SUPPORT_BIT, &val))
1697				priv->features.kbd_bl = true;
1698
1699			if (test_bit(HALS_USB_CHARGING_SUPPORT_BIT, &val))
1700				priv->features.usb_charging = true;
1701		}
1702	}
1703}
1704
1705#if IS_ENABLED(CONFIG_ACPI_WMI)
1706/*
1707 * WMI driver
1708 */
1709enum ideapad_wmi_event_type {
1710	IDEAPAD_WMI_EVENT_ESC,
1711	IDEAPAD_WMI_EVENT_FN_KEYS,
1712};
1713
1714struct ideapad_wmi_private {
1715	enum ideapad_wmi_event_type event;
1716};
1717
1718static int ideapad_wmi_probe(struct wmi_device *wdev, const void *context)
1719{
1720	struct ideapad_wmi_private *wpriv;
1721
1722	wpriv = devm_kzalloc(&wdev->dev, sizeof(*wpriv), GFP_KERNEL);
1723	if (!wpriv)
1724		return -ENOMEM;
1725
1726	*wpriv = *(const struct ideapad_wmi_private *)context;
1727
1728	dev_set_drvdata(&wdev->dev, wpriv);
1729	return 0;
1730}
1731
1732static void ideapad_wmi_notify(struct wmi_device *wdev, union acpi_object *data)
1733{
1734	struct ideapad_wmi_private *wpriv = dev_get_drvdata(&wdev->dev);
1735	struct ideapad_private *priv;
1736	unsigned long result;
1737
1738	mutex_lock(&ideapad_shared_mutex);
1739
1740	priv = ideapad_shared;
1741	if (!priv)
1742		goto unlock;
1743
1744	switch (wpriv->event) {
1745	case IDEAPAD_WMI_EVENT_ESC:
1746		ideapad_input_report(priv, 128);
1747		break;
1748	case IDEAPAD_WMI_EVENT_FN_KEYS:
1749		if (priv->features.set_fn_lock_led &&
1750		    !eval_hals(priv->adev->handle, &result)) {
1751			bool state = test_bit(HALS_FNLOCK_STATE_BIT, &result);
1752
1753			exec_sals(priv->adev->handle, state ? SALS_FNLOCK_ON : SALS_FNLOCK_OFF);
1754		}
1755
1756		if (data->type != ACPI_TYPE_INTEGER) {
1757			dev_warn(&wdev->dev,
1758				 "WMI event data is not an integer\n");
1759			break;
1760		}
1761
1762		dev_dbg(&wdev->dev, "WMI fn-key event: 0x%llx\n",
1763			data->integer.value);
1764
1765		ideapad_input_report(priv,
1766				     data->integer.value | IDEAPAD_WMI_KEY);
1767
1768		break;
1769	}
1770unlock:
1771	mutex_unlock(&ideapad_shared_mutex);
1772}
1773
1774static const struct ideapad_wmi_private ideapad_wmi_context_esc = {
1775	.event = IDEAPAD_WMI_EVENT_ESC
1776};
1777
1778static const struct ideapad_wmi_private ideapad_wmi_context_fn_keys = {
1779	.event = IDEAPAD_WMI_EVENT_FN_KEYS
1780};
1781
1782static const struct wmi_device_id ideapad_wmi_ids[] = {
1783	{ "26CAB2E5-5CF1-46AE-AAC3-4A12B6BA50E6", &ideapad_wmi_context_esc }, /* Yoga 3 */
1784	{ "56322276-8493-4CE8-A783-98C991274F5E", &ideapad_wmi_context_esc }, /* Yoga 700 */
1785	{ "8FC0DE0C-B4E4-43FD-B0F3-8871711C1294", &ideapad_wmi_context_fn_keys }, /* Legion 5 */
1786	{},
1787};
1788MODULE_DEVICE_TABLE(wmi, ideapad_wmi_ids);
1789
1790static struct wmi_driver ideapad_wmi_driver = {
1791	.driver = {
1792		.name = "ideapad_wmi",
1793	},
1794	.id_table = ideapad_wmi_ids,
1795	.probe = ideapad_wmi_probe,
1796	.notify = ideapad_wmi_notify,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1797};
1798
1799static int ideapad_wmi_driver_register(void)
1800{
1801	return wmi_driver_register(&ideapad_wmi_driver);
1802}
1803
1804static void ideapad_wmi_driver_unregister(void)
1805{
1806	return wmi_driver_unregister(&ideapad_wmi_driver);
1807}
1808
1809#else
1810static inline int ideapad_wmi_driver_register(void) { return 0; }
1811static inline void ideapad_wmi_driver_unregister(void) { }
1812#endif
1813
1814/*
1815 * ACPI driver
1816 */
1817static int ideapad_acpi_add(struct platform_device *pdev)
1818{
1819	struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);
 
1820	struct ideapad_private *priv;
1821	acpi_status status;
1822	unsigned long cfg;
1823	int err, i;
1824
1825	if (!adev || eval_int(adev->handle, "_CFG", &cfg))
 
 
 
 
1826		return -ENODEV;
1827
1828	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
1829	if (!priv)
1830		return -ENOMEM;
1831
1832	dev_set_drvdata(&pdev->dev, priv);
1833
1834	priv->cfg = cfg;
1835	priv->adev = adev;
1836	priv->platform_device = pdev;
 
1837
1838	ideapad_check_features(priv);
1839
1840	err = ideapad_sysfs_init(priv);
1841	if (err)
1842		return err;
1843
1844	ideapad_debugfs_init(priv);
 
 
1845
1846	err = ideapad_input_init(priv);
1847	if (err)
1848		goto input_failed;
1849
1850	err = ideapad_kbd_bl_init(priv);
1851	if (err) {
1852		if (err != -ENODEV)
1853			dev_warn(&pdev->dev, "Could not set up keyboard backlight LED: %d\n", err);
1854		else
1855			dev_info(&pdev->dev, "Keyboard backlight control not available\n");
1856	}
1857
1858	/*
1859	 * On some models without a hw-switch (the yoga 2 13 at least)
1860	 * VPCCMD_W_RF must be explicitly set to 1 for the wifi to work.
1861	 */
1862	if (!priv->features.hw_rfkill_switch)
1863		write_ec_cmd(priv->adev->handle, VPCCMD_W_RF, 1);
1864
1865	for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
1866		if (test_bit(ideapad_rfk_data[i].cfgbit, &priv->cfg))
1867			ideapad_register_rfkill(priv, i);
1868
1869	ideapad_sync_rfk_state(priv);
1870	ideapad_sync_touchpad_state(priv, false);
1871
1872	err = ideapad_dytc_profile_init(priv);
1873	if (err) {
1874		if (err != -ENODEV)
1875			dev_warn(&pdev->dev, "Could not set up DYTC interface: %d\n", err);
1876		else
1877			dev_info(&pdev->dev, "DYTC interface is not available\n");
1878	}
1879
1880	if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
1881		err = ideapad_backlight_init(priv);
1882		if (err && err != -ENODEV)
1883			goto backlight_failed;
1884	}
1885
1886	status = acpi_install_notify_handler(adev->handle,
1887					     ACPI_DEVICE_NOTIFY,
1888					     ideapad_acpi_notify, priv);
1889	if (ACPI_FAILURE(status)) {
1890		err = -EIO;
1891		goto notification_failed;
1892	}
1893
1894	err = ideapad_shared_init(priv);
1895	if (err)
1896		goto shared_init_failed;
 
 
 
 
 
 
 
 
 
1897
1898	return 0;
1899
1900shared_init_failed:
1901	acpi_remove_notify_handler(priv->adev->handle,
1902				   ACPI_DEVICE_NOTIFY,
1903				   ideapad_acpi_notify);
1904
1905notification_failed:
1906	ideapad_backlight_exit(priv);
1907
1908backlight_failed:
1909	ideapad_dytc_profile_exit(priv);
1910
1911	for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
1912		ideapad_unregister_rfkill(priv, i);
1913
1914	ideapad_kbd_bl_exit(priv);
1915	ideapad_input_exit(priv);
1916
1917input_failed:
1918	ideapad_debugfs_exit(priv);
 
1919	ideapad_sysfs_exit(priv);
1920
1921	return err;
1922}
1923
1924static int ideapad_acpi_remove(struct platform_device *pdev)
1925{
1926	struct ideapad_private *priv = dev_get_drvdata(&pdev->dev);
1927	int i;
1928
1929	ideapad_shared_exit(priv);
1930
 
 
1931	acpi_remove_notify_handler(priv->adev->handle,
1932				   ACPI_DEVICE_NOTIFY,
1933				   ideapad_acpi_notify);
1934
1935	ideapad_backlight_exit(priv);
1936	ideapad_dytc_profile_exit(priv);
1937
1938	for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
1939		ideapad_unregister_rfkill(priv, i);
1940
1941	ideapad_kbd_bl_exit(priv);
1942	ideapad_input_exit(priv);
1943	ideapad_debugfs_exit(priv);
1944	ideapad_sysfs_exit(priv);
 
1945
1946	return 0;
1947}
1948
1949#ifdef CONFIG_PM_SLEEP
1950static int ideapad_acpi_resume(struct device *dev)
1951{
1952	struct ideapad_private *priv = dev_get_drvdata(dev);
1953
1954	ideapad_sync_rfk_state(priv);
1955	ideapad_sync_touchpad_state(priv, false);
1956
1957	if (priv->dytc)
1958		dytc_profile_refresh(priv);
 
1959
 
 
1960	return 0;
1961}
1962#endif
1963static SIMPLE_DEV_PM_OPS(ideapad_pm, NULL, ideapad_acpi_resume);
1964
1965static const struct acpi_device_id ideapad_device_ids[] = {
1966	{"VPC2004", 0},
1967	{"", 0},
1968};
1969MODULE_DEVICE_TABLE(acpi, ideapad_device_ids);
1970
1971static struct platform_driver ideapad_acpi_driver = {
1972	.probe = ideapad_acpi_add,
1973	.remove = ideapad_acpi_remove,
1974	.driver = {
1975		.name   = "ideapad_acpi",
1976		.pm     = &ideapad_pm,
1977		.acpi_match_table = ACPI_PTR(ideapad_device_ids),
1978	},
1979};
1980
1981static int __init ideapad_laptop_init(void)
1982{
1983	int err;
1984
1985	err = ideapad_wmi_driver_register();
1986	if (err)
1987		return err;
1988
1989	err = platform_driver_register(&ideapad_acpi_driver);
1990	if (err) {
1991		ideapad_wmi_driver_unregister();
1992		return err;
1993	}
1994
1995	return 0;
1996}
1997module_init(ideapad_laptop_init)
1998
1999static void __exit ideapad_laptop_exit(void)
2000{
2001	ideapad_wmi_driver_unregister();
2002	platform_driver_unregister(&ideapad_acpi_driver);
2003}
2004module_exit(ideapad_laptop_exit)
2005
2006MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
2007MODULE_DESCRIPTION("IdeaPad ACPI Extras");
2008MODULE_LICENSE("GPL");