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