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