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(lock: &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(lock: &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, pathname: (char *)name, NULL, data: &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, method: (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, name: "GBMD", res);
255}
256
257static int exec_sbmc(acpi_handle handle, unsigned long arg)
258{
259 return exec_simple_method(handle, name: "SBMC", arg);
260}
261
262static int eval_hals(acpi_handle handle, unsigned long *res)
263{
264 return eval_int(handle, name: "HALS", res);
265}
266
267static int exec_sals(acpi_handle handle, unsigned long arg)
268{
269 return exec_simple_method(handle, name: "SALS", arg);
270}
271
272static int exec_kblc(acpi_handle handle, unsigned long arg)
273{
274 return exec_simple_method(handle, name: "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, name: "KBLC", arg: 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, name: "DYTC", arg: 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(handle: priv->adev->handle, cmd: VPCCMD_R_BL_MAX, data: &value))
296 seq_printf(m: s, fmt: "Backlight max: %lu\n", value);
297 if (!read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_BL, data: &value))
298 seq_printf(m: s, fmt: "Backlight now: %lu\n", value);
299 if (!read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_BL_POWER, data: &value))
300 seq_printf(m: s, fmt: "BL power value: %s (%lu)\n", value ? "on" : "off", value);
301
302 seq_puts(m: s, s: "=====================\n");
303
304 if (!read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_RF, data: &value))
305 seq_printf(m: s, fmt: "Radio status: %s (%lu)\n", value ? "on" : "off", value);
306 if (!read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_WIFI, data: &value))
307 seq_printf(m: s, fmt: "Wifi status: %s (%lu)\n", value ? "on" : "off", value);
308 if (!read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_BT, data: &value))
309 seq_printf(m: s, fmt: "BT status: %s (%lu)\n", value ? "on" : "off", value);
310 if (!read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_3G, data: &value))
311 seq_printf(m: s, fmt: "3G status: %s (%lu)\n", value ? "on" : "off", value);
312
313 seq_puts(m: s, s: "=====================\n");
314
315 if (!read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_TOUCHPAD, data: &value))
316 seq_printf(m: s, fmt: "Touchpad status: %s (%lu)\n", value ? "on" : "off", value);
317 if (!read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_CAMERA, data: &value))
318 seq_printf(m: s, fmt: "Camera status: %s (%lu)\n", value ? "on" : "off", value);
319
320 seq_puts(m: s, s: "=====================\n");
321
322 if (!eval_gbmd(handle: priv->adev->handle, res: &value))
323 seq_printf(m: s, fmt: "GBMD: %#010lx\n", value);
324 if (!eval_hals(handle: priv->adev->handle, res: &value))
325 seq_printf(m: s, fmt: "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(m: s, fmt: "_CFG: %#010lx\n\n", priv->cfg);
336
337 seq_puts(m: s, s: "Capabilities:");
338 if (test_bit(CFG_CAP_BT_BIT, &priv->cfg))
339 seq_puts(m: s, s: " bluetooth");
340 if (test_bit(CFG_CAP_3G_BIT, &priv->cfg))
341 seq_puts(m: s, s: " 3G");
342 if (test_bit(CFG_CAP_WIFI_BIT, &priv->cfg))
343 seq_puts(m: s, s: " wifi");
344 if (test_bit(CFG_CAP_CAM_BIT, &priv->cfg))
345 seq_puts(m: s, s: " camera");
346 seq_puts(m: s, s: "\n");
347
348 seq_puts(m: s, s: "OSD support:");
349 if (test_bit(CFG_OSD_NUMLK_BIT, &priv->cfg))
350 seq_puts(m: s, s: " num-lock");
351 if (test_bit(CFG_OSD_CAPSLK_BIT, &priv->cfg))
352 seq_puts(m: s, s: " caps-lock");
353 if (test_bit(CFG_OSD_MICMUTE_BIT, &priv->cfg))
354 seq_puts(m: s, s: " mic-mute");
355 if (test_bit(CFG_OSD_TOUCHPAD_BIT, &priv->cfg))
356 seq_puts(m: s, s: " touchpad");
357 if (test_bit(CFG_OSD_CAM_BIT, &priv->cfg))
358 seq_puts(m: s, s: " camera");
359 seq_puts(m: s, s: "\n");
360
361 seq_puts(m: s, s: "Graphics: ");
362 switch (priv->cfg & 0x700) {
363 case 0x100:
364 seq_puts(m: s, s: "Intel");
365 break;
366 case 0x200:
367 seq_puts(m: s, s: "ATI");
368 break;
369 case 0x300:
370 seq_puts(m: s, s: "Nvidia");
371 break;
372 case 0x400:
373 seq_puts(m: s, s: "Intel and ATI");
374 break;
375 case 0x500:
376 seq_puts(m: s, s: "Intel and Nvidia");
377 break;
378 }
379 seq_puts(m: s, 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(name: "ideapad", NULL);
390 priv->debug = dir;
391
392 debugfs_create_file(name: "cfg", mode: 0444, parent: dir, data: priv, fops: &debugfs_cfg_fops);
393 debugfs_create_file(name: "status", mode: 0444, parent: dir, data: priv, fops: &debugfs_status_fops);
394}
395
396static void ideapad_debugfs_exit(struct ideapad_private *priv)
397{
398 debugfs_remove_recursive(dentry: 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(handle: priv->adev->handle, cmd: VPCCMD_R_CAMERA, data: &result);
414 if (err)
415 return err;
416
417 return sysfs_emit(buf, fmt: "%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(s: buf, res: &state);
429 if (err)
430 return err;
431
432 err = write_ec_cmd(handle: priv->adev->handle, cmd: VPCCMD_W_CAMERA, data: 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(handle: priv->adev->handle, res: &result);
450 if (err)
451 return err;
452
453 return sysfs_emit(buf, fmt: "%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(s: buf, res: &state);
465 if (err)
466 return err;
467
468 err = exec_sbmc(handle: priv->adev->handle, arg: 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(handle: priv->adev->handle, cmd: VPCCMD_R_FAN, data: &result);
486 if (err)
487 return err;
488
489 return sysfs_emit(buf, fmt: "%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(s: buf, base: 0, res: &state);
501 if (err)
502 return err;
503
504 if (state > 4 || state == 3)
505 return -EINVAL;
506
507 err = write_ec_cmd(handle: priv->adev->handle, cmd: VPCCMD_W_FAN, data: 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(handle: priv->adev->handle, res: &hals);
525 if (err)
526 return err;
527
528 return sysfs_emit(buf, fmt: "%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(s: buf, res: &state);
540 if (err)
541 return err;
542
543 err = exec_sals(handle: priv->adev->handle, arg: 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(handle: priv->adev->handle, cmd: VPCCMD_R_TOUCHPAD, data: &result);
561 if (err)
562 return err;
563
564 priv->r_touchpad_val = result;
565
566 return sysfs_emit(buf, fmt: "%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(s: buf, res: &state);
578 if (err)
579 return err;
580
581 err = write_ec_cmd(handle: priv->adev->handle, cmd: VPCCMD_W_TOUCHPAD, data: 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(handle: priv->adev->handle, res: &hals);
601 if (err)
602 return err;
603
604 return sysfs_emit(buf, fmt: "%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(s: buf, res: &state);
616 if (err)
617 return err;
618
619 err = exec_sals(handle: priv->adev->handle, arg: 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(handle: priv->adev->handle, DYTC_CMD_GET, res: 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(handle: priv->adev->handle, DYTC_DISABLE_CQL, NULL);
778 if (err)
779 return err;
780 }
781
782 cmd_err = eval_dytc(handle: priv->adev->handle, cmd, res: output);
783 /* Check return condition after we've restored CQL state */
784
785 if (cur_funcmode == DYTC_FUNCTION_CQL) {
786 err = eval_dytc(handle: 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(handle: 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: &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: &output);
825 if (err)
826 goto unlock;
827 }
828
829 /* Success - update current profile */
830 dytc->current_profile = profile;
831
832unlock:
833 mutex_unlock(lock: &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: &output);
846 mutex_unlock(lock: &priv->dytc->mutex);
847 if (err)
848 return;
849
850 perfmode = (output >> DYTC_GET_MODE_BIT) & 0xF;
851
852 if (convert_dytc_to_profile(dytcmode: perfmode, profile: &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(handle: priv->adev->handle, DYTC_CMD_QUERY, res: &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(list: 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(size: 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(nr: PLATFORM_PROFILE_LOW_POWER, addr: priv->dytc->pprof.choices);
924 set_bit(nr: PLATFORM_PROFILE_BALANCED, addr: priv->dytc->pprof.choices);
925 set_bit(nr: PLATFORM_PROFILE_PERFORMANCE, addr: priv->dytc->pprof.choices);
926
927 /* Create platform_profile structure and register */
928 err = platform_profile_register(pprof: &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(lock: &priv->dytc->mutex);
939 kfree(objp: 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(lock: &priv->dytc->mutex);
952 kfree(objp: 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(handle: priv->priv->adev->handle, cmd: opcode, data: !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(handle: priv->adev->handle, cmd: VPCCMD_R_RF, data: &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(rfkill: priv->rfk[i], blocked: 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(handle: priv->adev->handle, cmd: ideapad_rfk_data[dev].opcode, data: 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(name: ideapad_rfk_data[dev].name,
1016 parent: &priv->platform_device->dev,
1017 type: ideapad_rfk_data[dev].type,
1018 ops: &ideapad_rfk_ops,
1019 ops_data: &priv->rfk_priv[dev]);
1020 if (!priv->rfk[dev])
1021 return -ENOMEM;
1022
1023 err = read_ec_data(handle: priv->adev->handle, cmd: ideapad_rfk_data[dev].opcode - 1, data: &rf_enabled);
1024 if (err)
1025 rf_enabled = 1;
1026
1027 rfkill_init_sw_state(rfkill: priv->rfk[dev], blocked: !rf_enabled);
1028
1029 err = rfkill_register(rfkill: priv->rfk[dev]);
1030 if (err)
1031 rfkill_destroy(rfkill: 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(rfkill: priv->rfk[dev]);
1042 rfkill_destroy(rfkill: 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(dev: &priv->platform_device->dev,
1051 grp: &ideapad_attribute_group);
1052}
1053
1054static void ideapad_sysfs_exit(struct ideapad_private *priv)
1055{
1056 device_remove_group(dev: &priv->platform_device->dev,
1057 grp: &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 /* Refresh Rate Toggle (Fn+R) */
1095 { KE_KEY, 0x10 | IDEAPAD_WMI_KEY, { KEY_REFRESH_RATE_TOGGLE } },
1096 /* Dark mode toggle */
1097 { KE_KEY, 0x13 | IDEAPAD_WMI_KEY, { KEY_PROG1 } },
1098 /* Sound profile switch */
1099 { KE_KEY, 0x12 | IDEAPAD_WMI_KEY, { KEY_PROG2 } },
1100 /* Lenovo Virtual Background application */
1101 { KE_KEY, 0x28 | IDEAPAD_WMI_KEY, { KEY_PROG3 } },
1102 /* Lenovo Support */
1103 { KE_KEY, 0x27 | IDEAPAD_WMI_KEY, { KEY_HELP } },
1104 /* Refresh Rate Toggle */
1105 { KE_KEY, 0x0a | IDEAPAD_WMI_KEY, { KEY_REFRESH_RATE_TOGGLE } },
1106
1107 { KE_END },
1108};
1109
1110static int ideapad_input_init(struct ideapad_private *priv)
1111{
1112 struct input_dev *inputdev;
1113 int err;
1114
1115 inputdev = input_allocate_device();
1116 if (!inputdev)
1117 return -ENOMEM;
1118
1119 inputdev->name = "Ideapad extra buttons";
1120 inputdev->phys = "ideapad/input0";
1121 inputdev->id.bustype = BUS_HOST;
1122 inputdev->dev.parent = &priv->platform_device->dev;
1123
1124 err = sparse_keymap_setup(dev: inputdev, keymap: ideapad_keymap, NULL);
1125 if (err) {
1126 dev_err(&priv->platform_device->dev,
1127 "Could not set up input device keymap: %d\n", err);
1128 goto err_free_dev;
1129 }
1130
1131 err = input_register_device(inputdev);
1132 if (err) {
1133 dev_err(&priv->platform_device->dev,
1134 "Could not register input device: %d\n", err);
1135 goto err_free_dev;
1136 }
1137
1138 priv->inputdev = inputdev;
1139
1140 return 0;
1141
1142err_free_dev:
1143 input_free_device(dev: inputdev);
1144
1145 return err;
1146}
1147
1148static void ideapad_input_exit(struct ideapad_private *priv)
1149{
1150 input_unregister_device(priv->inputdev);
1151 priv->inputdev = NULL;
1152}
1153
1154static void ideapad_input_report(struct ideapad_private *priv,
1155 unsigned long scancode)
1156{
1157 sparse_keymap_report_event(dev: priv->inputdev, code: scancode, value: 1, autorelease: true);
1158}
1159
1160static void ideapad_input_novokey(struct ideapad_private *priv)
1161{
1162 unsigned long long_pressed;
1163
1164 if (read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_NOVO, data: &long_pressed))
1165 return;
1166
1167 if (long_pressed)
1168 ideapad_input_report(priv, scancode: 17);
1169 else
1170 ideapad_input_report(priv, scancode: 16);
1171}
1172
1173static void ideapad_check_special_buttons(struct ideapad_private *priv)
1174{
1175 unsigned long bit, value;
1176
1177 if (read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_SPECIAL_BUTTONS, data: &value))
1178 return;
1179
1180 for_each_set_bit (bit, &value, 16) {
1181 switch (bit) {
1182 case 6: /* Z570 */
1183 case 0: /* Z580 */
1184 /* Thermal Management button */
1185 ideapad_input_report(priv, scancode: 65);
1186 break;
1187 case 1:
1188 /* OneKey Theater button */
1189 ideapad_input_report(priv, scancode: 64);
1190 break;
1191 default:
1192 dev_info(&priv->platform_device->dev,
1193 "Unknown special button: %lu\n", bit);
1194 break;
1195 }
1196 }
1197}
1198
1199/*
1200 * backlight
1201 */
1202static int ideapad_backlight_get_brightness(struct backlight_device *blightdev)
1203{
1204 struct ideapad_private *priv = bl_get_data(bl_dev: blightdev);
1205 unsigned long now;
1206 int err;
1207
1208 err = read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_BL, data: &now);
1209 if (err)
1210 return err;
1211
1212 return now;
1213}
1214
1215static int ideapad_backlight_update_status(struct backlight_device *blightdev)
1216{
1217 struct ideapad_private *priv = bl_get_data(bl_dev: blightdev);
1218 int err;
1219
1220 err = write_ec_cmd(handle: priv->adev->handle, cmd: VPCCMD_W_BL,
1221 data: blightdev->props.brightness);
1222 if (err)
1223 return err;
1224
1225 err = write_ec_cmd(handle: priv->adev->handle, cmd: VPCCMD_W_BL_POWER,
1226 data: blightdev->props.power != FB_BLANK_POWERDOWN);
1227 if (err)
1228 return err;
1229
1230 return 0;
1231}
1232
1233static const struct backlight_ops ideapad_backlight_ops = {
1234 .get_brightness = ideapad_backlight_get_brightness,
1235 .update_status = ideapad_backlight_update_status,
1236};
1237
1238static int ideapad_backlight_init(struct ideapad_private *priv)
1239{
1240 struct backlight_device *blightdev;
1241 struct backlight_properties props;
1242 unsigned long max, now, power;
1243 int err;
1244
1245 err = read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_BL_MAX, data: &max);
1246 if (err)
1247 return err;
1248
1249 err = read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_BL, data: &now);
1250 if (err)
1251 return err;
1252
1253 err = read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_BL_POWER, data: &power);
1254 if (err)
1255 return err;
1256
1257 memset(&props, 0, sizeof(props));
1258
1259 props.max_brightness = max;
1260 props.type = BACKLIGHT_PLATFORM;
1261
1262 blightdev = backlight_device_register(name: "ideapad",
1263 dev: &priv->platform_device->dev,
1264 devdata: priv,
1265 ops: &ideapad_backlight_ops,
1266 props: &props);
1267 if (IS_ERR(ptr: blightdev)) {
1268 err = PTR_ERR(ptr: blightdev);
1269 dev_err(&priv->platform_device->dev,
1270 "Could not register backlight device: %d\n", err);
1271 return err;
1272 }
1273
1274 priv->blightdev = blightdev;
1275 blightdev->props.brightness = now;
1276 blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
1277
1278 backlight_update_status(bd: blightdev);
1279
1280 return 0;
1281}
1282
1283static void ideapad_backlight_exit(struct ideapad_private *priv)
1284{
1285 backlight_device_unregister(bd: priv->blightdev);
1286 priv->blightdev = NULL;
1287}
1288
1289static void ideapad_backlight_notify_power(struct ideapad_private *priv)
1290{
1291 struct backlight_device *blightdev = priv->blightdev;
1292 unsigned long power;
1293
1294 if (!blightdev)
1295 return;
1296
1297 if (read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_BL_POWER, data: &power))
1298 return;
1299
1300 blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
1301}
1302
1303static void ideapad_backlight_notify_brightness(struct ideapad_private *priv)
1304{
1305 unsigned long now;
1306
1307 /* if we control brightness via acpi video driver */
1308 if (!priv->blightdev)
1309 read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_BL, data: &now);
1310 else
1311 backlight_force_update(bd: priv->blightdev, reason: BACKLIGHT_UPDATE_HOTKEY);
1312}
1313
1314/*
1315 * keyboard backlight
1316 */
1317static int ideapad_kbd_bl_check_tristate(int type)
1318{
1319 return (type == KBD_BL_TRISTATE) || (type == KBD_BL_TRISTATE_AUTO);
1320}
1321
1322static int ideapad_kbd_bl_brightness_get(struct ideapad_private *priv)
1323{
1324 unsigned long value;
1325 int err;
1326
1327 if (ideapad_kbd_bl_check_tristate(type: priv->kbd_bl.type)) {
1328 err = eval_kblc(handle: priv->adev->handle,
1329 FIELD_PREP(KBD_BL_COMMAND_TYPE, priv->kbd_bl.type) |
1330 KBD_BL_COMMAND_GET,
1331 res: &value);
1332
1333 if (err)
1334 return err;
1335
1336 /* Convert returned value to brightness level */
1337 value = FIELD_GET(KBD_BL_GET_BRIGHTNESS, value);
1338
1339 /* Off, low or high */
1340 if (value <= priv->kbd_bl.led.max_brightness)
1341 return value;
1342
1343 /* Auto, report as off */
1344 if (value == priv->kbd_bl.led.max_brightness + 1)
1345 return 0;
1346
1347 /* Unknown value */
1348 dev_warn(&priv->platform_device->dev,
1349 "Unknown keyboard backlight value: %lu", value);
1350 return -EINVAL;
1351 }
1352
1353 err = eval_hals(handle: priv->adev->handle, res: &value);
1354 if (err)
1355 return err;
1356
1357 return !!test_bit(HALS_KBD_BL_STATE_BIT, &value);
1358}
1359
1360static enum led_brightness ideapad_kbd_bl_led_cdev_brightness_get(struct led_classdev *led_cdev)
1361{
1362 struct ideapad_private *priv = container_of(led_cdev, struct ideapad_private, kbd_bl.led);
1363
1364 return ideapad_kbd_bl_brightness_get(priv);
1365}
1366
1367static int ideapad_kbd_bl_brightness_set(struct ideapad_private *priv, unsigned int brightness)
1368{
1369 int err;
1370 unsigned long value;
1371 int type = priv->kbd_bl.type;
1372
1373 if (ideapad_kbd_bl_check_tristate(type)) {
1374 if (brightness > priv->kbd_bl.led.max_brightness)
1375 return -EINVAL;
1376
1377 value = FIELD_PREP(KBD_BL_SET_BRIGHTNESS, brightness) |
1378 FIELD_PREP(KBD_BL_COMMAND_TYPE, type) |
1379 KBD_BL_COMMAND_SET;
1380 err = exec_kblc(handle: priv->adev->handle, arg: value);
1381 } else {
1382 err = exec_sals(handle: priv->adev->handle, arg: brightness ? SALS_KBD_BL_ON : SALS_KBD_BL_OFF);
1383 }
1384
1385 if (err)
1386 return err;
1387
1388 priv->kbd_bl.last_brightness = brightness;
1389
1390 return 0;
1391}
1392
1393static int ideapad_kbd_bl_led_cdev_brightness_set(struct led_classdev *led_cdev,
1394 enum led_brightness brightness)
1395{
1396 struct ideapad_private *priv = container_of(led_cdev, struct ideapad_private, kbd_bl.led);
1397
1398 return ideapad_kbd_bl_brightness_set(priv, brightness);
1399}
1400
1401static void ideapad_kbd_bl_notify(struct ideapad_private *priv)
1402{
1403 int brightness;
1404
1405 if (!priv->kbd_bl.initialized)
1406 return;
1407
1408 brightness = ideapad_kbd_bl_brightness_get(priv);
1409 if (brightness < 0)
1410 return;
1411
1412 if (brightness == priv->kbd_bl.last_brightness)
1413 return;
1414
1415 priv->kbd_bl.last_brightness = brightness;
1416
1417 led_classdev_notify_brightness_hw_changed(led_cdev: &priv->kbd_bl.led, brightness);
1418}
1419
1420static int ideapad_kbd_bl_init(struct ideapad_private *priv)
1421{
1422 int brightness, err;
1423
1424 if (!priv->features.kbd_bl)
1425 return -ENODEV;
1426
1427 if (WARN_ON(priv->kbd_bl.initialized))
1428 return -EEXIST;
1429
1430 if (ideapad_kbd_bl_check_tristate(type: priv->kbd_bl.type)) {
1431 priv->kbd_bl.led.max_brightness = 2;
1432 } else {
1433 priv->kbd_bl.led.max_brightness = 1;
1434 }
1435
1436 brightness = ideapad_kbd_bl_brightness_get(priv);
1437 if (brightness < 0)
1438 return brightness;
1439
1440 priv->kbd_bl.last_brightness = brightness;
1441 priv->kbd_bl.led.name = "platform::" LED_FUNCTION_KBD_BACKLIGHT;
1442 priv->kbd_bl.led.brightness_get = ideapad_kbd_bl_led_cdev_brightness_get;
1443 priv->kbd_bl.led.brightness_set_blocking = ideapad_kbd_bl_led_cdev_brightness_set;
1444 priv->kbd_bl.led.flags = LED_BRIGHT_HW_CHANGED;
1445
1446 err = led_classdev_register(parent: &priv->platform_device->dev, led_cdev: &priv->kbd_bl.led);
1447 if (err)
1448 return err;
1449
1450 priv->kbd_bl.initialized = true;
1451
1452 return 0;
1453}
1454
1455static void ideapad_kbd_bl_exit(struct ideapad_private *priv)
1456{
1457 if (!priv->kbd_bl.initialized)
1458 return;
1459
1460 priv->kbd_bl.initialized = false;
1461
1462 led_classdev_unregister(led_cdev: &priv->kbd_bl.led);
1463}
1464
1465/*
1466 * module init/exit
1467 */
1468static void ideapad_sync_touchpad_state(struct ideapad_private *priv, bool send_events)
1469{
1470 unsigned long value;
1471 unsigned char param;
1472 int ret;
1473
1474 /* Without reading from EC touchpad LED doesn't switch state */
1475 ret = read_ec_data(handle: priv->adev->handle, cmd: VPCCMD_R_TOUCHPAD, data: &value);
1476 if (ret)
1477 return;
1478
1479 /*
1480 * Some IdeaPads don't really turn off touchpad - they only
1481 * switch the LED state. We (de)activate KBC AUX port to turn
1482 * touchpad off and on. We send KEY_TOUCHPAD_OFF and
1483 * KEY_TOUCHPAD_ON to not to get out of sync with LED
1484 */
1485 if (priv->features.ctrl_ps2_aux_port)
1486 i8042_command(param: &param, command: value ? I8042_CMD_AUX_ENABLE : I8042_CMD_AUX_DISABLE);
1487
1488 /*
1489 * On older models the EC controls the touchpad and toggles it on/off
1490 * itself, in this case we report KEY_TOUCHPAD_ON/_OFF. Some models do
1491 * an acpi-notify with VPC bit 5 set on resume, so this function get
1492 * called with send_events=true on every resume. Therefor if the EC did
1493 * not toggle, do nothing to avoid sending spurious KEY_TOUCHPAD_TOGGLE.
1494 */
1495 if (send_events && value != priv->r_touchpad_val) {
1496 ideapad_input_report(priv, scancode: value ? 67 : 66);
1497 sysfs_notify(kobj: &priv->platform_device->dev.kobj, NULL, attr: "touchpad");
1498 }
1499
1500 priv->r_touchpad_val = value;
1501}
1502
1503static void ideapad_acpi_notify(acpi_handle handle, u32 event, void *data)
1504{
1505 struct ideapad_private *priv = data;
1506 unsigned long vpc1, vpc2, bit;
1507
1508 if (read_ec_data(handle, cmd: VPCCMD_R_VPC1, data: &vpc1))
1509 return;
1510
1511 if (read_ec_data(handle, cmd: VPCCMD_R_VPC2, data: &vpc2))
1512 return;
1513
1514 vpc1 = (vpc2 << 8) | vpc1;
1515
1516 for_each_set_bit (bit, &vpc1, 16) {
1517 switch (bit) {
1518 case 13:
1519 case 11:
1520 case 8:
1521 case 7:
1522 case 6:
1523 ideapad_input_report(priv, scancode: bit);
1524 break;
1525 case 10:
1526 /*
1527 * This event gets send on a Yoga 300-11IBR when the EC
1528 * believes that the device has changed between laptop/
1529 * tent/stand/tablet mode. The EC relies on getting
1530 * angle info from 2 accelerometers through a special
1531 * windows service calling a DSM on the DUAL250E ACPI-
1532 * device. Linux does not do this, making the laptop/
1533 * tent/stand/tablet mode info unreliable, so we simply
1534 * ignore these events.
1535 */
1536 break;
1537 case 9:
1538 ideapad_sync_rfk_state(priv);
1539 break;
1540 case 5:
1541 ideapad_sync_touchpad_state(priv, send_events: true);
1542 break;
1543 case 4:
1544 ideapad_backlight_notify_brightness(priv);
1545 break;
1546 case 3:
1547 ideapad_input_novokey(priv);
1548 break;
1549 case 2:
1550 ideapad_backlight_notify_power(priv);
1551 break;
1552 case KBD_BL_KBLC_CHANGED_EVENT:
1553 case 1:
1554 /*
1555 * Some IdeaPads report event 1 every ~20
1556 * seconds while on battery power; some
1557 * report this when changing to/from tablet
1558 * mode; some report this when the keyboard
1559 * backlight has changed.
1560 */
1561 ideapad_kbd_bl_notify(priv);
1562 break;
1563 case 0:
1564 ideapad_check_special_buttons(priv);
1565 break;
1566 default:
1567 dev_info(&priv->platform_device->dev,
1568 "Unknown event: %lu\n", bit);
1569 }
1570 }
1571}
1572
1573/* On some models we need to call exec_sals(SALS_FNLOCK_ON/OFF) to set the LED */
1574static const struct dmi_system_id set_fn_lock_led_list[] = {
1575 {
1576 /* https://bugzilla.kernel.org/show_bug.cgi?id=212671 */
1577 .matches = {
1578 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
1579 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Legion R7000P2020H"),
1580 }
1581 },
1582 {
1583 .matches = {
1584 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
1585 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Legion 5 15ARH05"),
1586 }
1587 },
1588 {}
1589};
1590
1591/*
1592 * Some ideapads have a hardware rfkill switch, but most do not have one.
1593 * Reading VPCCMD_R_RF always results in 0 on models without a hardware rfkill,
1594 * switch causing ideapad_laptop to wrongly report all radios as hw-blocked.
1595 * There used to be a long list of DMI ids for models without a hw rfkill
1596 * switch here, but that resulted in playing whack a mole.
1597 * More importantly wrongly reporting the wifi radio as hw-blocked, results in
1598 * non working wifi. Whereas not reporting it hw-blocked, when it actually is
1599 * hw-blocked results in an empty SSID list, which is a much more benign
1600 * failure mode.
1601 * So the default now is the much safer option of assuming there is no
1602 * hardware rfkill switch. This default also actually matches most hardware,
1603 * since having a hw rfkill switch is quite rare on modern hardware, so this
1604 * also leads to a much shorter list.
1605 */
1606static const struct dmi_system_id hw_rfkill_list[] = {
1607 {}
1608};
1609
1610/*
1611 * On some models the EC toggles the touchpad muted LED on touchpad toggle
1612 * hotkey presses, but the EC does not actually disable the touchpad itself.
1613 * On these models the driver needs to explicitly enable/disable the i8042
1614 * (PS/2) aux port.
1615 */
1616static const struct dmi_system_id ctrl_ps2_aux_port_list[] = {
1617 {
1618 /* Lenovo Ideapad Z570 */
1619 .matches = {
1620 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
1621 DMI_MATCH(DMI_PRODUCT_VERSION, "Ideapad Z570"),
1622 },
1623 },
1624 {}
1625};
1626
1627static void ideapad_check_features(struct ideapad_private *priv)
1628{
1629 acpi_handle handle = priv->adev->handle;
1630 unsigned long val;
1631
1632 priv->features.set_fn_lock_led =
1633 set_fn_lock_led || dmi_check_system(list: set_fn_lock_led_list);
1634 priv->features.hw_rfkill_switch =
1635 hw_rfkill_switch || dmi_check_system(list: hw_rfkill_list);
1636 priv->features.ctrl_ps2_aux_port =
1637 ctrl_ps2_aux_port || dmi_check_system(list: ctrl_ps2_aux_port_list);
1638 priv->features.touchpad_ctrl_via_ec = touchpad_ctrl_via_ec;
1639
1640 if (!read_ec_data(handle, cmd: VPCCMD_R_FAN, data: &val))
1641 priv->features.fan_mode = true;
1642
1643 if (acpi_has_method(handle, name: "GBMD") && acpi_has_method(handle, name: "SBMC"))
1644 priv->features.conservation_mode = true;
1645
1646 if (acpi_has_method(handle, name: "DYTC"))
1647 priv->features.dytc = true;
1648
1649 if (acpi_has_method(handle, name: "HALS") && acpi_has_method(handle, name: "SALS")) {
1650 if (!eval_hals(handle, res: &val)) {
1651 if (test_bit(HALS_FNLOCK_SUPPORT_BIT, &val))
1652 priv->features.fn_lock = true;
1653
1654 if (test_bit(HALS_KBD_BL_SUPPORT_BIT, &val)) {
1655 priv->features.kbd_bl = true;
1656 priv->kbd_bl.type = KBD_BL_STANDARD;
1657 }
1658
1659 if (test_bit(HALS_USB_CHARGING_SUPPORT_BIT, &val))
1660 priv->features.usb_charging = true;
1661 }
1662 }
1663
1664 if (acpi_has_method(handle, name: "KBLC")) {
1665 if (!eval_kblc(handle: priv->adev->handle, KBD_BL_QUERY_TYPE, res: &val)) {
1666 if (val == KBD_BL_TRISTATE_TYPE) {
1667 priv->features.kbd_bl = true;
1668 priv->kbd_bl.type = KBD_BL_TRISTATE;
1669 } else if (val == KBD_BL_TRISTATE_AUTO_TYPE) {
1670 priv->features.kbd_bl = true;
1671 priv->kbd_bl.type = KBD_BL_TRISTATE_AUTO;
1672 } else {
1673 dev_warn(&priv->platform_device->dev,
1674 "Unknown keyboard type: %lu",
1675 val);
1676 }
1677 }
1678 }
1679}
1680
1681#if IS_ENABLED(CONFIG_ACPI_WMI)
1682/*
1683 * WMI driver
1684 */
1685enum ideapad_wmi_event_type {
1686 IDEAPAD_WMI_EVENT_ESC,
1687 IDEAPAD_WMI_EVENT_FN_KEYS,
1688};
1689
1690struct ideapad_wmi_private {
1691 enum ideapad_wmi_event_type event;
1692};
1693
1694static int ideapad_wmi_probe(struct wmi_device *wdev, const void *context)
1695{
1696 struct ideapad_wmi_private *wpriv;
1697
1698 wpriv = devm_kzalloc(dev: &wdev->dev, size: sizeof(*wpriv), GFP_KERNEL);
1699 if (!wpriv)
1700 return -ENOMEM;
1701
1702 *wpriv = *(const struct ideapad_wmi_private *)context;
1703
1704 dev_set_drvdata(dev: &wdev->dev, data: wpriv);
1705 return 0;
1706}
1707
1708static void ideapad_wmi_notify(struct wmi_device *wdev, union acpi_object *data)
1709{
1710 struct ideapad_wmi_private *wpriv = dev_get_drvdata(dev: &wdev->dev);
1711 struct ideapad_private *priv;
1712 unsigned long result;
1713
1714 mutex_lock(&ideapad_shared_mutex);
1715
1716 priv = ideapad_shared;
1717 if (!priv)
1718 goto unlock;
1719
1720 switch (wpriv->event) {
1721 case IDEAPAD_WMI_EVENT_ESC:
1722 ideapad_input_report(priv, scancode: 128);
1723 break;
1724 case IDEAPAD_WMI_EVENT_FN_KEYS:
1725 if (priv->features.set_fn_lock_led &&
1726 !eval_hals(handle: priv->adev->handle, res: &result)) {
1727 bool state = test_bit(HALS_FNLOCK_STATE_BIT, &result);
1728
1729 exec_sals(handle: priv->adev->handle, arg: state ? SALS_FNLOCK_ON : SALS_FNLOCK_OFF);
1730 }
1731
1732 if (data->type != ACPI_TYPE_INTEGER) {
1733 dev_warn(&wdev->dev,
1734 "WMI event data is not an integer\n");
1735 break;
1736 }
1737
1738 dev_dbg(&wdev->dev, "WMI fn-key event: 0x%llx\n",
1739 data->integer.value);
1740
1741 ideapad_input_report(priv,
1742 scancode: data->integer.value | IDEAPAD_WMI_KEY);
1743
1744 break;
1745 }
1746unlock:
1747 mutex_unlock(lock: &ideapad_shared_mutex);
1748}
1749
1750static const struct ideapad_wmi_private ideapad_wmi_context_esc = {
1751 .event = IDEAPAD_WMI_EVENT_ESC
1752};
1753
1754static const struct ideapad_wmi_private ideapad_wmi_context_fn_keys = {
1755 .event = IDEAPAD_WMI_EVENT_FN_KEYS
1756};
1757
1758static const struct wmi_device_id ideapad_wmi_ids[] = {
1759 { "26CAB2E5-5CF1-46AE-AAC3-4A12B6BA50E6", &ideapad_wmi_context_esc }, /* Yoga 3 */
1760 { "56322276-8493-4CE8-A783-98C991274F5E", &ideapad_wmi_context_esc }, /* Yoga 700 */
1761 { "8FC0DE0C-B4E4-43FD-B0F3-8871711C1294", &ideapad_wmi_context_fn_keys }, /* Legion 5 */
1762 {},
1763};
1764MODULE_DEVICE_TABLE(wmi, ideapad_wmi_ids);
1765
1766static struct wmi_driver ideapad_wmi_driver = {
1767 .driver = {
1768 .name = "ideapad_wmi",
1769 },
1770 .id_table = ideapad_wmi_ids,
1771 .probe = ideapad_wmi_probe,
1772 .notify = ideapad_wmi_notify,
1773};
1774
1775static int ideapad_wmi_driver_register(void)
1776{
1777 return wmi_driver_register(&ideapad_wmi_driver);
1778}
1779
1780static void ideapad_wmi_driver_unregister(void)
1781{
1782 return wmi_driver_unregister(driver: &ideapad_wmi_driver);
1783}
1784
1785#else
1786static inline int ideapad_wmi_driver_register(void) { return 0; }
1787static inline void ideapad_wmi_driver_unregister(void) { }
1788#endif
1789
1790/*
1791 * ACPI driver
1792 */
1793static int ideapad_acpi_add(struct platform_device *pdev)
1794{
1795 struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);
1796 struct ideapad_private *priv;
1797 acpi_status status;
1798 unsigned long cfg;
1799 int err, i;
1800
1801 if (!adev || eval_int(handle: adev->handle, name: "_CFG", res: &cfg))
1802 return -ENODEV;
1803
1804 priv = devm_kzalloc(dev: &pdev->dev, size: sizeof(*priv), GFP_KERNEL);
1805 if (!priv)
1806 return -ENOMEM;
1807
1808 dev_set_drvdata(dev: &pdev->dev, data: priv);
1809
1810 priv->cfg = cfg;
1811 priv->adev = adev;
1812 priv->platform_device = pdev;
1813
1814 ideapad_check_features(priv);
1815
1816 err = ideapad_sysfs_init(priv);
1817 if (err)
1818 return err;
1819
1820 ideapad_debugfs_init(priv);
1821
1822 err = ideapad_input_init(priv);
1823 if (err)
1824 goto input_failed;
1825
1826 err = ideapad_kbd_bl_init(priv);
1827 if (err) {
1828 if (err != -ENODEV)
1829 dev_warn(&pdev->dev, "Could not set up keyboard backlight LED: %d\n", err);
1830 else
1831 dev_info(&pdev->dev, "Keyboard backlight control not available\n");
1832 }
1833
1834 /*
1835 * On some models without a hw-switch (the yoga 2 13 at least)
1836 * VPCCMD_W_RF must be explicitly set to 1 for the wifi to work.
1837 */
1838 if (!priv->features.hw_rfkill_switch)
1839 write_ec_cmd(handle: priv->adev->handle, cmd: VPCCMD_W_RF, data: 1);
1840
1841 for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
1842 if (test_bit(ideapad_rfk_data[i].cfgbit, &priv->cfg))
1843 ideapad_register_rfkill(priv, dev: i);
1844
1845 ideapad_sync_rfk_state(priv);
1846 ideapad_sync_touchpad_state(priv, send_events: false);
1847
1848 err = ideapad_dytc_profile_init(priv);
1849 if (err) {
1850 if (err != -ENODEV)
1851 dev_warn(&pdev->dev, "Could not set up DYTC interface: %d\n", err);
1852 else
1853 dev_info(&pdev->dev, "DYTC interface is not available\n");
1854 }
1855
1856 if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
1857 err = ideapad_backlight_init(priv);
1858 if (err && err != -ENODEV)
1859 goto backlight_failed;
1860 }
1861
1862 status = acpi_install_notify_handler(device: adev->handle,
1863 ACPI_DEVICE_NOTIFY,
1864 handler: ideapad_acpi_notify, context: priv);
1865 if (ACPI_FAILURE(status)) {
1866 err = -EIO;
1867 goto notification_failed;
1868 }
1869
1870 err = ideapad_shared_init(priv);
1871 if (err)
1872 goto shared_init_failed;
1873
1874 return 0;
1875
1876shared_init_failed:
1877 acpi_remove_notify_handler(device: priv->adev->handle,
1878 ACPI_DEVICE_NOTIFY,
1879 handler: ideapad_acpi_notify);
1880
1881notification_failed:
1882 ideapad_backlight_exit(priv);
1883
1884backlight_failed:
1885 ideapad_dytc_profile_exit(priv);
1886
1887 for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
1888 ideapad_unregister_rfkill(priv, dev: i);
1889
1890 ideapad_kbd_bl_exit(priv);
1891 ideapad_input_exit(priv);
1892
1893input_failed:
1894 ideapad_debugfs_exit(priv);
1895 ideapad_sysfs_exit(priv);
1896
1897 return err;
1898}
1899
1900static void ideapad_acpi_remove(struct platform_device *pdev)
1901{
1902 struct ideapad_private *priv = dev_get_drvdata(dev: &pdev->dev);
1903 int i;
1904
1905 ideapad_shared_exit(priv);
1906
1907 acpi_remove_notify_handler(device: priv->adev->handle,
1908 ACPI_DEVICE_NOTIFY,
1909 handler: ideapad_acpi_notify);
1910
1911 ideapad_backlight_exit(priv);
1912 ideapad_dytc_profile_exit(priv);
1913
1914 for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
1915 ideapad_unregister_rfkill(priv, dev: i);
1916
1917 ideapad_kbd_bl_exit(priv);
1918 ideapad_input_exit(priv);
1919 ideapad_debugfs_exit(priv);
1920 ideapad_sysfs_exit(priv);
1921}
1922
1923#ifdef CONFIG_PM_SLEEP
1924static int ideapad_acpi_resume(struct device *dev)
1925{
1926 struct ideapad_private *priv = dev_get_drvdata(dev);
1927
1928 ideapad_sync_rfk_state(priv);
1929 ideapad_sync_touchpad_state(priv, send_events: false);
1930
1931 if (priv->dytc)
1932 dytc_profile_refresh(priv);
1933
1934 return 0;
1935}
1936#endif
1937static SIMPLE_DEV_PM_OPS(ideapad_pm, NULL, ideapad_acpi_resume);
1938
1939static const struct acpi_device_id ideapad_device_ids[] = {
1940 {"VPC2004", 0},
1941 {"", 0},
1942};
1943MODULE_DEVICE_TABLE(acpi, ideapad_device_ids);
1944
1945static struct platform_driver ideapad_acpi_driver = {
1946 .probe = ideapad_acpi_add,
1947 .remove_new = ideapad_acpi_remove,
1948 .driver = {
1949 .name = "ideapad_acpi",
1950 .pm = &ideapad_pm,
1951 .acpi_match_table = ACPI_PTR(ideapad_device_ids),
1952 },
1953};
1954
1955static int __init ideapad_laptop_init(void)
1956{
1957 int err;
1958
1959 err = ideapad_wmi_driver_register();
1960 if (err)
1961 return err;
1962
1963 err = platform_driver_register(&ideapad_acpi_driver);
1964 if (err) {
1965 ideapad_wmi_driver_unregister();
1966 return err;
1967 }
1968
1969 return 0;
1970}
1971module_init(ideapad_laptop_init)
1972
1973static void __exit ideapad_laptop_exit(void)
1974{
1975 ideapad_wmi_driver_unregister();
1976 platform_driver_unregister(&ideapad_acpi_driver);
1977}
1978module_exit(ideapad_laptop_exit)
1979
1980MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
1981MODULE_DESCRIPTION("IdeaPad ACPI Extras");
1982MODULE_LICENSE("GPL");
1983

source code of linux/drivers/platform/x86/ideapad-laptop.c