Merge branch 'fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/evalenti/linux...
[linux/fpc-iii.git] / drivers / platform / x86 / ideapad-laptop.c
blobbe3bc2f4edd4279d04749aba6db4f93aedf06c4f
1 /*
2 * ideapad-laptop.c - Lenovo IdeaPad ACPI Extras
4 * Copyright © 2010 Intel Corporation
5 * Copyright © 2010 David Woodhouse <dwmw2@infradead.org>
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.
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.
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.
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/types.h>
29 #include <linux/acpi.h>
30 #include <linux/rfkill.h>
31 #include <linux/platform_device.h>
32 #include <linux/input.h>
33 #include <linux/input/sparse-keymap.h>
34 #include <linux/backlight.h>
35 #include <linux/fb.h>
36 #include <linux/debugfs.h>
37 #include <linux/seq_file.h>
38 #include <linux/i8042.h>
39 #include <linux/dmi.h>
40 #include <linux/device.h>
41 #include <acpi/video.h>
43 #define IDEAPAD_RFKILL_DEV_NUM (3)
45 #define CFG_BT_BIT (16)
46 #define CFG_3G_BIT (17)
47 #define CFG_WIFI_BIT (18)
48 #define CFG_CAMERA_BIT (19)
50 #if IS_ENABLED(CONFIG_ACPI_WMI)
51 static const char ideapad_wmi_fnesc_event[] = "26CAB2E5-5CF1-46AE-AAC3-4A12B6BA50E6";
52 #endif
54 enum {
55 VPCCMD_R_VPC1 = 0x10,
56 VPCCMD_R_BL_MAX,
57 VPCCMD_R_BL,
58 VPCCMD_W_BL,
59 VPCCMD_R_WIFI,
60 VPCCMD_W_WIFI,
61 VPCCMD_R_BT,
62 VPCCMD_W_BT,
63 VPCCMD_R_BL_POWER,
64 VPCCMD_R_NOVO,
65 VPCCMD_R_VPC2,
66 VPCCMD_R_TOUCHPAD,
67 VPCCMD_W_TOUCHPAD,
68 VPCCMD_R_CAMERA,
69 VPCCMD_W_CAMERA,
70 VPCCMD_R_3G,
71 VPCCMD_W_3G,
72 VPCCMD_R_ODD, /* 0x21 */
73 VPCCMD_W_FAN,
74 VPCCMD_R_RF,
75 VPCCMD_W_RF,
76 VPCCMD_R_FAN = 0x2B,
77 VPCCMD_R_SPECIAL_BUTTONS = 0x31,
78 VPCCMD_W_BL_POWER = 0x33,
81 struct ideapad_rfk_priv {
82 int dev;
83 struct ideapad_private *priv;
86 struct ideapad_private {
87 struct acpi_device *adev;
88 struct rfkill *rfk[IDEAPAD_RFKILL_DEV_NUM];
89 struct ideapad_rfk_priv rfk_priv[IDEAPAD_RFKILL_DEV_NUM];
90 struct platform_device *platform_device;
91 struct input_dev *inputdev;
92 struct backlight_device *blightdev;
93 struct dentry *debug;
94 unsigned long cfg;
95 bool has_hw_rfkill_switch;
98 static bool no_bt_rfkill;
99 module_param(no_bt_rfkill, bool, 0444);
100 MODULE_PARM_DESC(no_bt_rfkill, "No rfkill for bluetooth.");
103 * ACPI Helpers
105 #define IDEAPAD_EC_TIMEOUT (100) /* in ms */
107 static int read_method_int(acpi_handle handle, const char *method, int *val)
109 acpi_status status;
110 unsigned long long result;
112 status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
113 if (ACPI_FAILURE(status)) {
114 *val = -1;
115 return -1;
116 } else {
117 *val = result;
118 return 0;
122 static int method_vpcr(acpi_handle handle, int cmd, int *ret)
124 acpi_status status;
125 unsigned long long result;
126 struct acpi_object_list params;
127 union acpi_object in_obj;
129 params.count = 1;
130 params.pointer = &in_obj;
131 in_obj.type = ACPI_TYPE_INTEGER;
132 in_obj.integer.value = cmd;
134 status = acpi_evaluate_integer(handle, "VPCR", &params, &result);
136 if (ACPI_FAILURE(status)) {
137 *ret = -1;
138 return -1;
139 } else {
140 *ret = result;
141 return 0;
145 static int method_vpcw(acpi_handle handle, int cmd, int data)
147 struct acpi_object_list params;
148 union acpi_object in_obj[2];
149 acpi_status status;
151 params.count = 2;
152 params.pointer = in_obj;
153 in_obj[0].type = ACPI_TYPE_INTEGER;
154 in_obj[0].integer.value = cmd;
155 in_obj[1].type = ACPI_TYPE_INTEGER;
156 in_obj[1].integer.value = data;
158 status = acpi_evaluate_object(handle, "VPCW", &params, NULL);
159 if (status != AE_OK)
160 return -1;
161 return 0;
164 static int read_ec_data(acpi_handle handle, int cmd, unsigned long *data)
166 int val;
167 unsigned long int end_jiffies;
169 if (method_vpcw(handle, 1, cmd))
170 return -1;
172 for (end_jiffies = jiffies+(HZ)*IDEAPAD_EC_TIMEOUT/1000+1;
173 time_before(jiffies, end_jiffies);) {
174 schedule();
175 if (method_vpcr(handle, 1, &val))
176 return -1;
177 if (val == 0) {
178 if (method_vpcr(handle, 0, &val))
179 return -1;
180 *data = val;
181 return 0;
184 pr_err("timeout in read_ec_cmd\n");
185 return -1;
188 static int write_ec_cmd(acpi_handle handle, int cmd, unsigned long data)
190 int val;
191 unsigned long int end_jiffies;
193 if (method_vpcw(handle, 0, data))
194 return -1;
195 if (method_vpcw(handle, 1, cmd))
196 return -1;
198 for (end_jiffies = jiffies+(HZ)*IDEAPAD_EC_TIMEOUT/1000+1;
199 time_before(jiffies, end_jiffies);) {
200 schedule();
201 if (method_vpcr(handle, 1, &val))
202 return -1;
203 if (val == 0)
204 return 0;
206 pr_err("timeout in write_ec_cmd\n");
207 return -1;
211 * debugfs
213 static int debugfs_status_show(struct seq_file *s, void *data)
215 struct ideapad_private *priv = s->private;
216 unsigned long value;
218 if (!priv)
219 return -EINVAL;
221 if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &value))
222 seq_printf(s, "Backlight max:\t%lu\n", value);
223 if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL, &value))
224 seq_printf(s, "Backlight now:\t%lu\n", value);
225 if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &value))
226 seq_printf(s, "BL power value:\t%s\n", value ? "On" : "Off");
227 seq_printf(s, "=====================\n");
229 if (!read_ec_data(priv->adev->handle, VPCCMD_R_RF, &value))
230 seq_printf(s, "Radio status:\t%s(%lu)\n",
231 value ? "On" : "Off", value);
232 if (!read_ec_data(priv->adev->handle, VPCCMD_R_WIFI, &value))
233 seq_printf(s, "Wifi status:\t%s(%lu)\n",
234 value ? "On" : "Off", value);
235 if (!read_ec_data(priv->adev->handle, VPCCMD_R_BT, &value))
236 seq_printf(s, "BT status:\t%s(%lu)\n",
237 value ? "On" : "Off", value);
238 if (!read_ec_data(priv->adev->handle, VPCCMD_R_3G, &value))
239 seq_printf(s, "3G status:\t%s(%lu)\n",
240 value ? "On" : "Off", value);
241 seq_printf(s, "=====================\n");
243 if (!read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value))
244 seq_printf(s, "Touchpad status:%s(%lu)\n",
245 value ? "On" : "Off", value);
246 if (!read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &value))
247 seq_printf(s, "Camera status:\t%s(%lu)\n",
248 value ? "On" : "Off", value);
250 return 0;
253 static int debugfs_status_open(struct inode *inode, struct file *file)
255 return single_open(file, debugfs_status_show, inode->i_private);
258 static const struct file_operations debugfs_status_fops = {
259 .owner = THIS_MODULE,
260 .open = debugfs_status_open,
261 .read = seq_read,
262 .llseek = seq_lseek,
263 .release = single_release,
266 static int debugfs_cfg_show(struct seq_file *s, void *data)
268 struct ideapad_private *priv = s->private;
270 if (!priv) {
271 seq_printf(s, "cfg: N/A\n");
272 } else {
273 seq_printf(s, "cfg: 0x%.8lX\n\nCapability: ",
274 priv->cfg);
275 if (test_bit(CFG_BT_BIT, &priv->cfg))
276 seq_printf(s, "Bluetooth ");
277 if (test_bit(CFG_3G_BIT, &priv->cfg))
278 seq_printf(s, "3G ");
279 if (test_bit(CFG_WIFI_BIT, &priv->cfg))
280 seq_printf(s, "Wireless ");
281 if (test_bit(CFG_CAMERA_BIT, &priv->cfg))
282 seq_printf(s, "Camera ");
283 seq_printf(s, "\nGraphic: ");
284 switch ((priv->cfg)&0x700) {
285 case 0x100:
286 seq_printf(s, "Intel");
287 break;
288 case 0x200:
289 seq_printf(s, "ATI");
290 break;
291 case 0x300:
292 seq_printf(s, "Nvidia");
293 break;
294 case 0x400:
295 seq_printf(s, "Intel and ATI");
296 break;
297 case 0x500:
298 seq_printf(s, "Intel and Nvidia");
299 break;
301 seq_printf(s, "\n");
303 return 0;
306 static int debugfs_cfg_open(struct inode *inode, struct file *file)
308 return single_open(file, debugfs_cfg_show, inode->i_private);
311 static const struct file_operations debugfs_cfg_fops = {
312 .owner = THIS_MODULE,
313 .open = debugfs_cfg_open,
314 .read = seq_read,
315 .llseek = seq_lseek,
316 .release = single_release,
319 static int ideapad_debugfs_init(struct ideapad_private *priv)
321 struct dentry *node;
323 priv->debug = debugfs_create_dir("ideapad", NULL);
324 if (priv->debug == NULL) {
325 pr_err("failed to create debugfs directory");
326 goto errout;
329 node = debugfs_create_file("cfg", S_IRUGO, priv->debug, priv,
330 &debugfs_cfg_fops);
331 if (!node) {
332 pr_err("failed to create cfg in debugfs");
333 goto errout;
336 node = debugfs_create_file("status", S_IRUGO, priv->debug, priv,
337 &debugfs_status_fops);
338 if (!node) {
339 pr_err("failed to create status in debugfs");
340 goto errout;
343 return 0;
345 errout:
346 return -ENOMEM;
349 static void ideapad_debugfs_exit(struct ideapad_private *priv)
351 debugfs_remove_recursive(priv->debug);
352 priv->debug = NULL;
356 * sysfs
358 static ssize_t show_ideapad_cam(struct device *dev,
359 struct device_attribute *attr,
360 char *buf)
362 unsigned long result;
363 struct ideapad_private *priv = dev_get_drvdata(dev);
365 if (read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &result))
366 return sprintf(buf, "-1\n");
367 return sprintf(buf, "%lu\n", result);
370 static ssize_t store_ideapad_cam(struct device *dev,
371 struct device_attribute *attr,
372 const char *buf, size_t count)
374 int ret, state;
375 struct ideapad_private *priv = dev_get_drvdata(dev);
377 if (!count)
378 return 0;
379 if (sscanf(buf, "%i", &state) != 1)
380 return -EINVAL;
381 ret = write_ec_cmd(priv->adev->handle, VPCCMD_W_CAMERA, state);
382 if (ret < 0)
383 return -EIO;
384 return count;
387 static DEVICE_ATTR(camera_power, 0644, show_ideapad_cam, store_ideapad_cam);
389 static ssize_t show_ideapad_fan(struct device *dev,
390 struct device_attribute *attr,
391 char *buf)
393 unsigned long result;
394 struct ideapad_private *priv = dev_get_drvdata(dev);
396 if (read_ec_data(priv->adev->handle, VPCCMD_R_FAN, &result))
397 return sprintf(buf, "-1\n");
398 return sprintf(buf, "%lu\n", result);
401 static ssize_t store_ideapad_fan(struct device *dev,
402 struct device_attribute *attr,
403 const char *buf, size_t count)
405 int ret, state;
406 struct ideapad_private *priv = dev_get_drvdata(dev);
408 if (!count)
409 return 0;
410 if (sscanf(buf, "%i", &state) != 1)
411 return -EINVAL;
412 if (state < 0 || state > 4 || state == 3)
413 return -EINVAL;
414 ret = write_ec_cmd(priv->adev->handle, VPCCMD_W_FAN, state);
415 if (ret < 0)
416 return -EIO;
417 return count;
420 static DEVICE_ATTR(fan_mode, 0644, show_ideapad_fan, store_ideapad_fan);
422 static struct attribute *ideapad_attributes[] = {
423 &dev_attr_camera_power.attr,
424 &dev_attr_fan_mode.attr,
425 NULL
428 static umode_t ideapad_is_visible(struct kobject *kobj,
429 struct attribute *attr,
430 int idx)
432 struct device *dev = container_of(kobj, struct device, kobj);
433 struct ideapad_private *priv = dev_get_drvdata(dev);
434 bool supported;
436 if (attr == &dev_attr_camera_power.attr)
437 supported = test_bit(CFG_CAMERA_BIT, &(priv->cfg));
438 else if (attr == &dev_attr_fan_mode.attr) {
439 unsigned long value;
440 supported = !read_ec_data(priv->adev->handle, VPCCMD_R_FAN,
441 &value);
442 } else
443 supported = true;
445 return supported ? attr->mode : 0;
448 static const struct attribute_group ideapad_attribute_group = {
449 .is_visible = ideapad_is_visible,
450 .attrs = ideapad_attributes
454 * Rfkill
456 struct ideapad_rfk_data {
457 char *name;
458 int cfgbit;
459 int opcode;
460 int type;
463 static const struct ideapad_rfk_data ideapad_rfk_data[] = {
464 { "ideapad_wlan", CFG_WIFI_BIT, VPCCMD_W_WIFI, RFKILL_TYPE_WLAN },
465 { "ideapad_bluetooth", CFG_BT_BIT, VPCCMD_W_BT, RFKILL_TYPE_BLUETOOTH },
466 { "ideapad_3g", CFG_3G_BIT, VPCCMD_W_3G, RFKILL_TYPE_WWAN },
469 static int ideapad_rfk_set(void *data, bool blocked)
471 struct ideapad_rfk_priv *priv = data;
472 int opcode = ideapad_rfk_data[priv->dev].opcode;
474 return write_ec_cmd(priv->priv->adev->handle, opcode, !blocked);
477 static struct rfkill_ops ideapad_rfk_ops = {
478 .set_block = ideapad_rfk_set,
481 static void ideapad_sync_rfk_state(struct ideapad_private *priv)
483 unsigned long hw_blocked = 0;
484 int i;
486 if (priv->has_hw_rfkill_switch) {
487 if (read_ec_data(priv->adev->handle, VPCCMD_R_RF, &hw_blocked))
488 return;
489 hw_blocked = !hw_blocked;
492 for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
493 if (priv->rfk[i])
494 rfkill_set_hw_state(priv->rfk[i], hw_blocked);
497 static int ideapad_register_rfkill(struct ideapad_private *priv, int dev)
499 int ret;
500 unsigned long sw_blocked;
502 if (no_bt_rfkill &&
503 (ideapad_rfk_data[dev].type == RFKILL_TYPE_BLUETOOTH)) {
504 /* Force to enable bluetooth when no_bt_rfkill=1 */
505 write_ec_cmd(priv->adev->handle,
506 ideapad_rfk_data[dev].opcode, 1);
507 return 0;
509 priv->rfk_priv[dev].dev = dev;
510 priv->rfk_priv[dev].priv = priv;
512 priv->rfk[dev] = rfkill_alloc(ideapad_rfk_data[dev].name,
513 &priv->platform_device->dev,
514 ideapad_rfk_data[dev].type,
515 &ideapad_rfk_ops,
516 &priv->rfk_priv[dev]);
517 if (!priv->rfk[dev])
518 return -ENOMEM;
520 if (read_ec_data(priv->adev->handle, ideapad_rfk_data[dev].opcode-1,
521 &sw_blocked)) {
522 rfkill_init_sw_state(priv->rfk[dev], 0);
523 } else {
524 sw_blocked = !sw_blocked;
525 rfkill_init_sw_state(priv->rfk[dev], sw_blocked);
528 ret = rfkill_register(priv->rfk[dev]);
529 if (ret) {
530 rfkill_destroy(priv->rfk[dev]);
531 return ret;
533 return 0;
536 static void ideapad_unregister_rfkill(struct ideapad_private *priv, int dev)
538 if (!priv->rfk[dev])
539 return;
541 rfkill_unregister(priv->rfk[dev]);
542 rfkill_destroy(priv->rfk[dev]);
546 * Platform device
548 static int ideapad_sysfs_init(struct ideapad_private *priv)
550 return sysfs_create_group(&priv->platform_device->dev.kobj,
551 &ideapad_attribute_group);
554 static void ideapad_sysfs_exit(struct ideapad_private *priv)
556 sysfs_remove_group(&priv->platform_device->dev.kobj,
557 &ideapad_attribute_group);
561 * input device
563 static const struct key_entry ideapad_keymap[] = {
564 { KE_KEY, 6, { KEY_SWITCHVIDEOMODE } },
565 { KE_KEY, 7, { KEY_CAMERA } },
566 { KE_KEY, 11, { KEY_F16 } },
567 { KE_KEY, 13, { KEY_WLAN } },
568 { KE_KEY, 16, { KEY_PROG1 } },
569 { KE_KEY, 17, { KEY_PROG2 } },
570 { KE_KEY, 64, { KEY_PROG3 } },
571 { KE_KEY, 65, { KEY_PROG4 } },
572 { KE_KEY, 66, { KEY_TOUCHPAD_OFF } },
573 { KE_KEY, 67, { KEY_TOUCHPAD_ON } },
574 { KE_KEY, 128, { KEY_ESC } },
576 { KE_END, 0 },
579 static int ideapad_input_init(struct ideapad_private *priv)
581 struct input_dev *inputdev;
582 int error;
584 inputdev = input_allocate_device();
585 if (!inputdev)
586 return -ENOMEM;
588 inputdev->name = "Ideapad extra buttons";
589 inputdev->phys = "ideapad/input0";
590 inputdev->id.bustype = BUS_HOST;
591 inputdev->dev.parent = &priv->platform_device->dev;
593 error = sparse_keymap_setup(inputdev, ideapad_keymap, NULL);
594 if (error) {
595 pr_err("Unable to setup input device keymap\n");
596 goto err_free_dev;
599 error = input_register_device(inputdev);
600 if (error) {
601 pr_err("Unable to register input device\n");
602 goto err_free_keymap;
605 priv->inputdev = inputdev;
606 return 0;
608 err_free_keymap:
609 sparse_keymap_free(inputdev);
610 err_free_dev:
611 input_free_device(inputdev);
612 return error;
615 static void ideapad_input_exit(struct ideapad_private *priv)
617 sparse_keymap_free(priv->inputdev);
618 input_unregister_device(priv->inputdev);
619 priv->inputdev = NULL;
622 static void ideapad_input_report(struct ideapad_private *priv,
623 unsigned long scancode)
625 sparse_keymap_report_event(priv->inputdev, scancode, 1, true);
628 static void ideapad_input_novokey(struct ideapad_private *priv)
630 unsigned long long_pressed;
632 if (read_ec_data(priv->adev->handle, VPCCMD_R_NOVO, &long_pressed))
633 return;
634 if (long_pressed)
635 ideapad_input_report(priv, 17);
636 else
637 ideapad_input_report(priv, 16);
640 static void ideapad_check_special_buttons(struct ideapad_private *priv)
642 unsigned long bit, value;
644 read_ec_data(priv->adev->handle, VPCCMD_R_SPECIAL_BUTTONS, &value);
646 for (bit = 0; bit < 16; bit++) {
647 if (test_bit(bit, &value)) {
648 switch (bit) {
649 case 0: /* Z580 */
650 case 6: /* Z570 */
651 /* Thermal Management button */
652 ideapad_input_report(priv, 65);
653 break;
654 case 1:
655 /* OneKey Theater button */
656 ideapad_input_report(priv, 64);
657 break;
658 default:
659 pr_info("Unknown special button: %lu\n", bit);
660 break;
667 * backlight
669 static int ideapad_backlight_get_brightness(struct backlight_device *blightdev)
671 struct ideapad_private *priv = bl_get_data(blightdev);
672 unsigned long now;
674 if (!priv)
675 return -EINVAL;
677 if (read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now))
678 return -EIO;
679 return now;
682 static int ideapad_backlight_update_status(struct backlight_device *blightdev)
684 struct ideapad_private *priv = bl_get_data(blightdev);
686 if (!priv)
687 return -EINVAL;
689 if (write_ec_cmd(priv->adev->handle, VPCCMD_W_BL,
690 blightdev->props.brightness))
691 return -EIO;
692 if (write_ec_cmd(priv->adev->handle, VPCCMD_W_BL_POWER,
693 blightdev->props.power == FB_BLANK_POWERDOWN ? 0 : 1))
694 return -EIO;
696 return 0;
699 static const struct backlight_ops ideapad_backlight_ops = {
700 .get_brightness = ideapad_backlight_get_brightness,
701 .update_status = ideapad_backlight_update_status,
704 static int ideapad_backlight_init(struct ideapad_private *priv)
706 struct backlight_device *blightdev;
707 struct backlight_properties props;
708 unsigned long max, now, power;
710 if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &max))
711 return -EIO;
712 if (read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now))
713 return -EIO;
714 if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power))
715 return -EIO;
717 memset(&props, 0, sizeof(struct backlight_properties));
718 props.max_brightness = max;
719 props.type = BACKLIGHT_PLATFORM;
720 blightdev = backlight_device_register("ideapad",
721 &priv->platform_device->dev,
722 priv,
723 &ideapad_backlight_ops,
724 &props);
725 if (IS_ERR(blightdev)) {
726 pr_err("Could not register backlight device\n");
727 return PTR_ERR(blightdev);
730 priv->blightdev = blightdev;
731 blightdev->props.brightness = now;
732 blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
733 backlight_update_status(blightdev);
735 return 0;
738 static void ideapad_backlight_exit(struct ideapad_private *priv)
740 backlight_device_unregister(priv->blightdev);
741 priv->blightdev = NULL;
744 static void ideapad_backlight_notify_power(struct ideapad_private *priv)
746 unsigned long power;
747 struct backlight_device *blightdev = priv->blightdev;
749 if (!blightdev)
750 return;
751 if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power))
752 return;
753 blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
756 static void ideapad_backlight_notify_brightness(struct ideapad_private *priv)
758 unsigned long now;
760 /* if we control brightness via acpi video driver */
761 if (priv->blightdev == NULL) {
762 read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now);
763 return;
766 backlight_force_update(priv->blightdev, BACKLIGHT_UPDATE_HOTKEY);
770 * module init/exit
772 static void ideapad_sync_touchpad_state(struct ideapad_private *priv)
774 unsigned long value;
776 /* Without reading from EC touchpad LED doesn't switch state */
777 if (!read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value)) {
778 /* Some IdeaPads don't really turn off touchpad - they only
779 * switch the LED state. We (de)activate KBC AUX port to turn
780 * touchpad off and on. We send KEY_TOUCHPAD_OFF and
781 * KEY_TOUCHPAD_ON to not to get out of sync with LED */
782 unsigned char param;
783 i8042_command(&param, value ? I8042_CMD_AUX_ENABLE :
784 I8042_CMD_AUX_DISABLE);
785 ideapad_input_report(priv, value ? 67 : 66);
789 static void ideapad_acpi_notify(acpi_handle handle, u32 event, void *data)
791 struct ideapad_private *priv = data;
792 unsigned long vpc1, vpc2, vpc_bit;
794 if (read_ec_data(handle, VPCCMD_R_VPC1, &vpc1))
795 return;
796 if (read_ec_data(handle, VPCCMD_R_VPC2, &vpc2))
797 return;
799 vpc1 = (vpc2 << 8) | vpc1;
800 for (vpc_bit = 0; vpc_bit < 16; vpc_bit++) {
801 if (test_bit(vpc_bit, &vpc1)) {
802 switch (vpc_bit) {
803 case 9:
804 ideapad_sync_rfk_state(priv);
805 break;
806 case 13:
807 case 11:
808 case 7:
809 case 6:
810 ideapad_input_report(priv, vpc_bit);
811 break;
812 case 5:
813 ideapad_sync_touchpad_state(priv);
814 break;
815 case 4:
816 ideapad_backlight_notify_brightness(priv);
817 break;
818 case 3:
819 ideapad_input_novokey(priv);
820 break;
821 case 2:
822 ideapad_backlight_notify_power(priv);
823 break;
824 case 0:
825 ideapad_check_special_buttons(priv);
826 break;
827 default:
828 pr_info("Unknown event: %lu\n", vpc_bit);
834 #if IS_ENABLED(CONFIG_ACPI_WMI)
835 static void ideapad_wmi_notify(u32 value, void *context)
837 switch (value) {
838 case 128:
839 ideapad_input_report(context, value);
840 break;
841 default:
842 pr_info("Unknown WMI event %u\n", value);
845 #endif
848 * Some ideapads don't have a hardware rfkill switch, reading VPCCMD_R_RF
849 * always results in 0 on these models, causing ideapad_laptop to wrongly
850 * report all radios as hardware-blocked.
852 static const struct dmi_system_id no_hw_rfkill_list[] = {
854 .ident = "Lenovo G40-30",
855 .matches = {
856 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
857 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo G40-30"),
861 .ident = "Lenovo G50-30",
862 .matches = {
863 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
864 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo G50-30"),
868 .ident = "Lenovo ideapad Y700-15ISK",
869 .matches = {
870 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
871 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo ideapad Y700-15ISK"),
875 .ident = "Lenovo ideapad Y700 Touch-15ISK",
876 .matches = {
877 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
878 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo ideapad Y700 Touch-15ISK"),
882 .ident = "Lenovo ideapad Y700-17ISK",
883 .matches = {
884 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
885 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo ideapad Y700-17ISK"),
889 .ident = "Lenovo Yoga 2 11 / 13 / Pro",
890 .matches = {
891 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
892 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Yoga 2"),
896 .ident = "Lenovo Yoga 2 11 / 13 / Pro",
897 .matches = {
898 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
899 DMI_MATCH(DMI_BOARD_NAME, "Yoga2"),
903 .ident = "Lenovo Yoga 3 1170 / 1470",
904 .matches = {
905 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
906 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Yoga 3"),
910 .ident = "Lenovo Yoga 3 Pro 1370",
911 .matches = {
912 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
913 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo YOGA 3"),
917 .ident = "Lenovo Yoga 700",
918 .matches = {
919 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
920 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo YOGA 700"),
924 .ident = "Lenovo Yoga 900",
925 .matches = {
926 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
927 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo YOGA 900"),
933 static int ideapad_acpi_add(struct platform_device *pdev)
935 int ret, i;
936 int cfg;
937 struct ideapad_private *priv;
938 struct acpi_device *adev;
940 ret = acpi_bus_get_device(ACPI_HANDLE(&pdev->dev), &adev);
941 if (ret)
942 return -ENODEV;
944 if (read_method_int(adev->handle, "_CFG", &cfg))
945 return -ENODEV;
947 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
948 if (!priv)
949 return -ENOMEM;
951 dev_set_drvdata(&pdev->dev, priv);
952 priv->cfg = cfg;
953 priv->adev = adev;
954 priv->platform_device = pdev;
955 priv->has_hw_rfkill_switch = !dmi_check_system(no_hw_rfkill_list);
957 ret = ideapad_sysfs_init(priv);
958 if (ret)
959 return ret;
961 ret = ideapad_debugfs_init(priv);
962 if (ret)
963 goto debugfs_failed;
965 ret = ideapad_input_init(priv);
966 if (ret)
967 goto input_failed;
970 * On some models without a hw-switch (the yoga 2 13 at least)
971 * VPCCMD_W_RF must be explicitly set to 1 for the wifi to work.
973 if (!priv->has_hw_rfkill_switch)
974 write_ec_cmd(priv->adev->handle, VPCCMD_W_RF, 1);
976 for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
977 if (test_bit(ideapad_rfk_data[i].cfgbit, &priv->cfg))
978 ideapad_register_rfkill(priv, i);
980 ideapad_sync_rfk_state(priv);
981 ideapad_sync_touchpad_state(priv);
983 if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
984 ret = ideapad_backlight_init(priv);
985 if (ret && ret != -ENODEV)
986 goto backlight_failed;
988 ret = acpi_install_notify_handler(adev->handle,
989 ACPI_DEVICE_NOTIFY, ideapad_acpi_notify, priv);
990 if (ret)
991 goto notification_failed;
992 #if IS_ENABLED(CONFIG_ACPI_WMI)
993 ret = wmi_install_notify_handler(ideapad_wmi_fnesc_event, ideapad_wmi_notify, priv);
994 if (ret != AE_OK && ret != AE_NOT_EXIST)
995 goto notification_failed_wmi;
996 #endif
998 return 0;
999 #if IS_ENABLED(CONFIG_ACPI_WMI)
1000 notification_failed_wmi:
1001 acpi_remove_notify_handler(priv->adev->handle,
1002 ACPI_DEVICE_NOTIFY, ideapad_acpi_notify);
1003 #endif
1004 notification_failed:
1005 ideapad_backlight_exit(priv);
1006 backlight_failed:
1007 for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
1008 ideapad_unregister_rfkill(priv, i);
1009 ideapad_input_exit(priv);
1010 input_failed:
1011 ideapad_debugfs_exit(priv);
1012 debugfs_failed:
1013 ideapad_sysfs_exit(priv);
1014 return ret;
1017 static int ideapad_acpi_remove(struct platform_device *pdev)
1019 struct ideapad_private *priv = dev_get_drvdata(&pdev->dev);
1020 int i;
1022 #if IS_ENABLED(CONFIG_ACPI_WMI)
1023 wmi_remove_notify_handler(ideapad_wmi_fnesc_event);
1024 #endif
1025 acpi_remove_notify_handler(priv->adev->handle,
1026 ACPI_DEVICE_NOTIFY, ideapad_acpi_notify);
1027 ideapad_backlight_exit(priv);
1028 for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
1029 ideapad_unregister_rfkill(priv, i);
1030 ideapad_input_exit(priv);
1031 ideapad_debugfs_exit(priv);
1032 ideapad_sysfs_exit(priv);
1033 dev_set_drvdata(&pdev->dev, NULL);
1035 return 0;
1038 #ifdef CONFIG_PM_SLEEP
1039 static int ideapad_acpi_resume(struct device *device)
1041 struct ideapad_private *priv;
1043 if (!device)
1044 return -EINVAL;
1045 priv = dev_get_drvdata(device);
1047 ideapad_sync_rfk_state(priv);
1048 ideapad_sync_touchpad_state(priv);
1049 return 0;
1051 #endif
1052 static SIMPLE_DEV_PM_OPS(ideapad_pm, NULL, ideapad_acpi_resume);
1054 static const struct acpi_device_id ideapad_device_ids[] = {
1055 { "VPC2004", 0},
1056 { "", 0},
1058 MODULE_DEVICE_TABLE(acpi, ideapad_device_ids);
1060 static struct platform_driver ideapad_acpi_driver = {
1061 .probe = ideapad_acpi_add,
1062 .remove = ideapad_acpi_remove,
1063 .driver = {
1064 .name = "ideapad_acpi",
1065 .pm = &ideapad_pm,
1066 .acpi_match_table = ACPI_PTR(ideapad_device_ids),
1070 module_platform_driver(ideapad_acpi_driver);
1072 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
1073 MODULE_DESCRIPTION("IdeaPad ACPI Extras");
1074 MODULE_LICENSE("GPL");