2010-08-11 05:44:05 +07:00
|
|
|
/*
|
2010-12-13 17:00:48 +07:00
|
|
|
* ideapad-laptop.c - Lenovo IdeaPad ACPI Extras
|
2010-08-11 05:44:05 +07:00
|
|
|
*
|
|
|
|
* Copyright © 2010 Intel Corporation
|
|
|
|
* Copyright © 2010 David Woodhouse <dwmw2@infradead.org>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
|
|
* 02110-1301, USA.
|
|
|
|
*/
|
|
|
|
|
2011-03-30 05:21:43 +07:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2010-08-11 05:44:05 +07:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/types.h>
|
2013-12-03 07:49:16 +07:00
|
|
|
#include <linux/acpi.h>
|
2010-08-11 05:44:05 +07:00
|
|
|
#include <linux/rfkill.h>
|
2010-12-13 17:00:15 +07:00
|
|
|
#include <linux/platform_device.h>
|
2010-12-13 17:00:38 +07:00
|
|
|
#include <linux/input.h>
|
|
|
|
#include <linux/input/sparse-keymap.h>
|
2011-06-30 18:50:52 +07:00
|
|
|
#include <linux/backlight.h>
|
|
|
|
#include <linux/fb.h>
|
2011-09-06 01:32:52 +07:00
|
|
|
#include <linux/debugfs.h>
|
|
|
|
#include <linux/seq_file.h>
|
2012-07-06 15:08:00 +07:00
|
|
|
#include <linux/i8042.h>
|
2014-05-13 21:00:28 +07:00
|
|
|
#include <linux/dmi.h>
|
ideapad_laptop: Introduce the use of the managed version of kzalloc
This patch moves data allocated using kzalloc to managed data allocated
using devm_kzalloc and cleans now unnecessary kfrees in probe and remove
functions. The label sysfs_failed is removed as it is no longer
required. Also, linux/device.h is added to make sure the devm_*()
routine declarations are unambiguously available.
The following Coccinelle semantic patch was used for making the change:
@platform@
identifier p, probefn, removefn;
@@
struct platform_driver p = {
.probe = probefn,
.remove = removefn,
};
@prb@
identifier platform.probefn, pdev;
expression e, e1, e2;
@@
probefn(struct platform_device *pdev, ...) {
<+...
- e = kzalloc(e1, e2)
+ e = devm_kzalloc(&pdev->dev, e1, e2)
...
?-kfree(e);
...+>
}
@rem depends on prb@
identifier platform.removefn;
expression e;
@@
removefn(...) {
<...
- kfree(e);
...>
}
Signed-off-by: Himangi Saraogi <himangi774@gmail.com>
Acked-by: Julia Lawall <julia.lawall@lip6.fr>
Signed-off-by: Matthew Garrett <matthew.garrett@nebula.com>
2014-06-10 04:46:50 +07:00
|
|
|
#include <linux/device.h>
|
2015-06-16 21:28:04 +07:00
|
|
|
#include <acpi/video.h>
|
2010-08-11 05:44:05 +07:00
|
|
|
|
2010-12-13 17:01:12 +07:00
|
|
|
#define IDEAPAD_RFKILL_DEV_NUM (3)
|
2010-08-11 05:44:05 +07:00
|
|
|
|
2011-06-30 18:50:40 +07:00
|
|
|
#define CFG_BT_BIT (16)
|
|
|
|
#define CFG_3G_BIT (17)
|
|
|
|
#define CFG_WIFI_BIT (18)
|
2011-06-30 18:50:47 +07:00
|
|
|
#define CFG_CAMERA_BIT (19)
|
2011-06-30 18:50:40 +07:00
|
|
|
|
ideapad-laptop: add support for Yoga 3 ESC key
The ideapad-laptop handles most special keys on various Lenovo Laptops
including the Yoga line. Unfortunately, the Yoga 3 11/13/14 models have
one important exception, which is the Fn-ESC combination.
On other Lenovo Laptops, this is FnLock, which switches the function keys
between the primary (Mute, Vol down, Vol up, ...) and the secondary (F1,
F2, F3, ...) behavior. On the new machines, FnLock is only available
through BIOS setup (possibly through a yet-to-be-implemented feature
in this driver) but not through Fn-ESC, but instead the ESC key itself
switched between ESC and a "Paper Display" app for Windows.
Unfortunately, that means that you can never have both ESC *and* the
function keys working at the same time without needing to press Fn on
one of them.
As pointed out in the official Lenovo Forum by dozens of users, this
makes the machine rather useless for any serious work [1].
I have now studied the ACPI DSDT one more time and found the event
that is generated for the ESC key. Unlike all other key events on this
machine, it is actually a WMI, while the other ones are read from the
embedded controller.
I am now installing a WMI notifier that uses the event number from the
WMI subsystem as the scancode. The only event number generated here is
'128', and that fits in nicely with the two existing ranges of scancodes
used by the EC: 0-15 for the 16-bit VPCCMD_R_VPC register, 16-17 for
the VPCCMD_R_NOVO register and 64-67 for VPCCMD_R_SPECIAL_BUTTONS.
The only sane way to handle this button (in absence of the Windows Paper
Display driver) seems to be to have it emit KEY_ESC, so that is what
I use as the default. Should any user ever want to overwrite the default,
they can install their own keymap.
To ensure that we can still build the driver without adding a CONFIG_WMI
dependency, all new code is enclosed in #ifdef.
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
[1] https://forums.lenovo.com/t5/Lenovo-Yoga-Series-Notebooks/YOGA-3-14-How-to-reclaim-my-Esc-key-and-permanently-disable/td-p/2070816
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-11-07 04:28:49 +07:00
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI)
|
2016-05-10 04:49:21 +07:00
|
|
|
static const char *const ideapad_wmi_fnesc_events[] = {
|
|
|
|
"26CAB2E5-5CF1-46AE-AAC3-4A12B6BA50E6", /* Yoga 3 */
|
|
|
|
"56322276-8493-4CE8-A783-98C991274F5E", /* Yoga 700 */
|
|
|
|
};
|
ideapad-laptop: add support for Yoga 3 ESC key
The ideapad-laptop handles most special keys on various Lenovo Laptops
including the Yoga line. Unfortunately, the Yoga 3 11/13/14 models have
one important exception, which is the Fn-ESC combination.
On other Lenovo Laptops, this is FnLock, which switches the function keys
between the primary (Mute, Vol down, Vol up, ...) and the secondary (F1,
F2, F3, ...) behavior. On the new machines, FnLock is only available
through BIOS setup (possibly through a yet-to-be-implemented feature
in this driver) but not through Fn-ESC, but instead the ESC key itself
switched between ESC and a "Paper Display" app for Windows.
Unfortunately, that means that you can never have both ESC *and* the
function keys working at the same time without needing to press Fn on
one of them.
As pointed out in the official Lenovo Forum by dozens of users, this
makes the machine rather useless for any serious work [1].
I have now studied the ACPI DSDT one more time and found the event
that is generated for the ESC key. Unlike all other key events on this
machine, it is actually a WMI, while the other ones are read from the
embedded controller.
I am now installing a WMI notifier that uses the event number from the
WMI subsystem as the scancode. The only event number generated here is
'128', and that fits in nicely with the two existing ranges of scancodes
used by the EC: 0-15 for the 16-bit VPCCMD_R_VPC register, 16-17 for
the VPCCMD_R_NOVO register and 64-67 for VPCCMD_R_SPECIAL_BUTTONS.
The only sane way to handle this button (in absence of the Windows Paper
Display driver) seems to be to have it emit KEY_ESC, so that is what
I use as the default. Should any user ever want to overwrite the default,
they can install their own keymap.
To ensure that we can still build the driver without adding a CONFIG_WMI
dependency, all new code is enclosed in #ifdef.
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
[1] https://forums.lenovo.com/t5/Lenovo-Yoga-Series-Notebooks/YOGA-3-14-How-to-reclaim-my-Esc-key-and-permanently-disable/td-p/2070816
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-11-07 04:28:49 +07:00
|
|
|
#endif
|
|
|
|
|
2011-09-06 01:31:53 +07:00
|
|
|
enum {
|
|
|
|
VPCCMD_R_VPC1 = 0x10,
|
|
|
|
VPCCMD_R_BL_MAX,
|
|
|
|
VPCCMD_R_BL,
|
|
|
|
VPCCMD_W_BL,
|
|
|
|
VPCCMD_R_WIFI,
|
|
|
|
VPCCMD_W_WIFI,
|
|
|
|
VPCCMD_R_BT,
|
|
|
|
VPCCMD_W_BT,
|
|
|
|
VPCCMD_R_BL_POWER,
|
|
|
|
VPCCMD_R_NOVO,
|
|
|
|
VPCCMD_R_VPC2,
|
|
|
|
VPCCMD_R_TOUCHPAD,
|
|
|
|
VPCCMD_W_TOUCHPAD,
|
|
|
|
VPCCMD_R_CAMERA,
|
|
|
|
VPCCMD_W_CAMERA,
|
|
|
|
VPCCMD_R_3G,
|
|
|
|
VPCCMD_W_3G,
|
|
|
|
VPCCMD_R_ODD, /* 0x21 */
|
2012-07-06 15:08:11 +07:00
|
|
|
VPCCMD_W_FAN,
|
|
|
|
VPCCMD_R_RF,
|
2011-09-06 01:31:53 +07:00
|
|
|
VPCCMD_W_RF,
|
2012-07-06 15:08:11 +07:00
|
|
|
VPCCMD_R_FAN = 0x2B,
|
2012-07-06 15:07:50 +07:00
|
|
|
VPCCMD_R_SPECIAL_BUTTONS = 0x31,
|
2011-09-06 01:31:53 +07:00
|
|
|
VPCCMD_W_BL_POWER = 0x33,
|
|
|
|
};
|
|
|
|
|
2013-09-25 19:39:49 +07:00
|
|
|
struct ideapad_rfk_priv {
|
|
|
|
int dev;
|
|
|
|
struct ideapad_private *priv;
|
|
|
|
};
|
|
|
|
|
2010-08-11 23:59:35 +07:00
|
|
|
struct ideapad_private {
|
2013-09-25 19:39:47 +07:00
|
|
|
struct acpi_device *adev;
|
2010-12-13 17:01:12 +07:00
|
|
|
struct rfkill *rfk[IDEAPAD_RFKILL_DEV_NUM];
|
2013-09-25 19:39:49 +07:00
|
|
|
struct ideapad_rfk_priv rfk_priv[IDEAPAD_RFKILL_DEV_NUM];
|
2010-12-13 17:00:15 +07:00
|
|
|
struct platform_device *platform_device;
|
2010-12-13 17:00:38 +07:00
|
|
|
struct input_dev *inputdev;
|
2011-06-30 18:50:52 +07:00
|
|
|
struct backlight_device *blightdev;
|
2011-09-06 01:32:52 +07:00
|
|
|
struct dentry *debug;
|
2011-06-30 18:50:40 +07:00
|
|
|
unsigned long cfg;
|
2014-06-23 21:45:51 +07:00
|
|
|
bool has_hw_rfkill_switch;
|
2016-05-10 04:49:21 +07:00
|
|
|
const char *fnesc_guid;
|
2010-08-11 05:44:05 +07:00
|
|
|
};
|
|
|
|
|
2010-10-01 14:40:22 +07:00
|
|
|
static bool no_bt_rfkill;
|
|
|
|
module_param(no_bt_rfkill, bool, 0444);
|
|
|
|
MODULE_PARM_DESC(no_bt_rfkill, "No rfkill for bluetooth.");
|
|
|
|
|
2010-10-01 14:38:46 +07:00
|
|
|
/*
|
|
|
|
* ACPI Helpers
|
|
|
|
*/
|
|
|
|
#define IDEAPAD_EC_TIMEOUT (100) /* in ms */
|
|
|
|
|
|
|
|
static int read_method_int(acpi_handle handle, const char *method, int *val)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
unsigned long long result;
|
|
|
|
|
|
|
|
status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
*val = -1;
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
*val = result;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int method_vpcr(acpi_handle handle, int cmd, int *ret)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
unsigned long long result;
|
|
|
|
struct acpi_object_list params;
|
|
|
|
union acpi_object in_obj;
|
|
|
|
|
|
|
|
params.count = 1;
|
|
|
|
params.pointer = &in_obj;
|
|
|
|
in_obj.type = ACPI_TYPE_INTEGER;
|
|
|
|
in_obj.integer.value = cmd;
|
|
|
|
|
|
|
|
status = acpi_evaluate_integer(handle, "VPCR", ¶ms, &result);
|
|
|
|
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
*ret = -1;
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
*ret = result;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int method_vpcw(acpi_handle handle, int cmd, int data)
|
|
|
|
{
|
|
|
|
struct acpi_object_list params;
|
|
|
|
union acpi_object in_obj[2];
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
params.count = 2;
|
|
|
|
params.pointer = in_obj;
|
|
|
|
in_obj[0].type = ACPI_TYPE_INTEGER;
|
|
|
|
in_obj[0].integer.value = cmd;
|
|
|
|
in_obj[1].type = ACPI_TYPE_INTEGER;
|
|
|
|
in_obj[1].integer.value = data;
|
|
|
|
|
|
|
|
status = acpi_evaluate_object(handle, "VPCW", ¶ms, NULL);
|
|
|
|
if (status != AE_OK)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int read_ec_data(acpi_handle handle, int cmd, unsigned long *data)
|
|
|
|
{
|
|
|
|
int val;
|
|
|
|
unsigned long int end_jiffies;
|
|
|
|
|
|
|
|
if (method_vpcw(handle, 1, cmd))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
for (end_jiffies = jiffies+(HZ)*IDEAPAD_EC_TIMEOUT/1000+1;
|
|
|
|
time_before(jiffies, end_jiffies);) {
|
|
|
|
schedule();
|
|
|
|
if (method_vpcr(handle, 1, &val))
|
|
|
|
return -1;
|
|
|
|
if (val == 0) {
|
|
|
|
if (method_vpcr(handle, 0, &val))
|
|
|
|
return -1;
|
|
|
|
*data = val;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pr_err("timeout in read_ec_cmd\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int write_ec_cmd(acpi_handle handle, int cmd, unsigned long data)
|
|
|
|
{
|
|
|
|
int val;
|
|
|
|
unsigned long int end_jiffies;
|
|
|
|
|
|
|
|
if (method_vpcw(handle, 0, data))
|
|
|
|
return -1;
|
|
|
|
if (method_vpcw(handle, 1, cmd))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
for (end_jiffies = jiffies+(HZ)*IDEAPAD_EC_TIMEOUT/1000+1;
|
|
|
|
time_before(jiffies, end_jiffies);) {
|
|
|
|
schedule();
|
|
|
|
if (method_vpcr(handle, 1, &val))
|
|
|
|
return -1;
|
|
|
|
if (val == 0)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
pr_err("timeout in write_ec_cmd\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-09-06 01:32:52 +07:00
|
|
|
/*
|
|
|
|
* debugfs
|
|
|
|
*/
|
|
|
|
static int debugfs_status_show(struct seq_file *s, void *data)
|
|
|
|
{
|
2013-09-25 19:39:49 +07:00
|
|
|
struct ideapad_private *priv = s->private;
|
2011-09-06 01:32:52 +07:00
|
|
|
unsigned long value;
|
|
|
|
|
2013-09-25 19:39:49 +07:00
|
|
|
if (!priv)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &value))
|
2011-09-06 01:32:52 +07:00
|
|
|
seq_printf(s, "Backlight max:\t%lu\n", value);
|
2013-09-25 19:39:49 +07:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL, &value))
|
2011-09-06 01:32:52 +07:00
|
|
|
seq_printf(s, "Backlight now:\t%lu\n", value);
|
2013-09-25 19:39:49 +07:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &value))
|
2011-09-06 01:32:52 +07:00
|
|
|
seq_printf(s, "BL power value:\t%s\n", value ? "On" : "Off");
|
|
|
|
seq_printf(s, "=====================\n");
|
|
|
|
|
2013-09-25 19:39:49 +07:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_RF, &value))
|
2011-09-06 01:32:52 +07:00
|
|
|
seq_printf(s, "Radio status:\t%s(%lu)\n",
|
|
|
|
value ? "On" : "Off", value);
|
2013-09-25 19:39:49 +07:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_WIFI, &value))
|
2011-09-06 01:32:52 +07:00
|
|
|
seq_printf(s, "Wifi status:\t%s(%lu)\n",
|
|
|
|
value ? "On" : "Off", value);
|
2013-09-25 19:39:49 +07:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_BT, &value))
|
2011-09-06 01:32:52 +07:00
|
|
|
seq_printf(s, "BT status:\t%s(%lu)\n",
|
|
|
|
value ? "On" : "Off", value);
|
2013-09-25 19:39:49 +07:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_3G, &value))
|
2011-09-06 01:32:52 +07:00
|
|
|
seq_printf(s, "3G status:\t%s(%lu)\n",
|
|
|
|
value ? "On" : "Off", value);
|
|
|
|
seq_printf(s, "=====================\n");
|
|
|
|
|
2013-09-25 19:39:49 +07:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value))
|
2011-09-06 01:32:52 +07:00
|
|
|
seq_printf(s, "Touchpad status:%s(%lu)\n",
|
|
|
|
value ? "On" : "Off", value);
|
2013-09-25 19:39:49 +07:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &value))
|
2011-09-06 01:32:52 +07:00
|
|
|
seq_printf(s, "Camera status:\t%s(%lu)\n",
|
|
|
|
value ? "On" : "Off", value);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int debugfs_status_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2013-09-25 19:39:49 +07:00
|
|
|
return single_open(file, debugfs_status_show, inode->i_private);
|
2011-09-06 01:32:52 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations debugfs_status_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = debugfs_status_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int debugfs_cfg_show(struct seq_file *s, void *data)
|
|
|
|
{
|
2013-09-25 19:39:49 +07:00
|
|
|
struct ideapad_private *priv = s->private;
|
|
|
|
|
|
|
|
if (!priv) {
|
2011-09-06 01:32:52 +07:00
|
|
|
seq_printf(s, "cfg: N/A\n");
|
|
|
|
} else {
|
|
|
|
seq_printf(s, "cfg: 0x%.8lX\n\nCapability: ",
|
2013-09-25 19:39:49 +07:00
|
|
|
priv->cfg);
|
|
|
|
if (test_bit(CFG_BT_BIT, &priv->cfg))
|
2011-09-06 01:32:52 +07:00
|
|
|
seq_printf(s, "Bluetooth ");
|
2013-09-25 19:39:49 +07:00
|
|
|
if (test_bit(CFG_3G_BIT, &priv->cfg))
|
2011-09-06 01:32:52 +07:00
|
|
|
seq_printf(s, "3G ");
|
2013-09-25 19:39:49 +07:00
|
|
|
if (test_bit(CFG_WIFI_BIT, &priv->cfg))
|
2011-09-06 01:32:52 +07:00
|
|
|
seq_printf(s, "Wireless ");
|
2013-09-25 19:39:49 +07:00
|
|
|
if (test_bit(CFG_CAMERA_BIT, &priv->cfg))
|
2011-09-06 01:32:52 +07:00
|
|
|
seq_printf(s, "Camera ");
|
|
|
|
seq_printf(s, "\nGraphic: ");
|
2013-09-25 19:39:49 +07:00
|
|
|
switch ((priv->cfg)&0x700) {
|
2011-09-06 01:32:52 +07:00
|
|
|
case 0x100:
|
|
|
|
seq_printf(s, "Intel");
|
|
|
|
break;
|
|
|
|
case 0x200:
|
|
|
|
seq_printf(s, "ATI");
|
|
|
|
break;
|
|
|
|
case 0x300:
|
|
|
|
seq_printf(s, "Nvidia");
|
|
|
|
break;
|
|
|
|
case 0x400:
|
|
|
|
seq_printf(s, "Intel and ATI");
|
|
|
|
break;
|
|
|
|
case 0x500:
|
|
|
|
seq_printf(s, "Intel and Nvidia");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
seq_printf(s, "\n");
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int debugfs_cfg_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2013-09-25 19:39:49 +07:00
|
|
|
return single_open(file, debugfs_cfg_show, inode->i_private);
|
2011-09-06 01:32:52 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations debugfs_cfg_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = debugfs_cfg_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
2012-12-22 04:18:33 +07:00
|
|
|
static int ideapad_debugfs_init(struct ideapad_private *priv)
|
2011-09-06 01:32:52 +07:00
|
|
|
{
|
|
|
|
struct dentry *node;
|
|
|
|
|
|
|
|
priv->debug = debugfs_create_dir("ideapad", NULL);
|
|
|
|
if (priv->debug == NULL) {
|
|
|
|
pr_err("failed to create debugfs directory");
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
|
2013-09-25 19:39:49 +07:00
|
|
|
node = debugfs_create_file("cfg", S_IRUGO, priv->debug, priv,
|
2011-09-06 01:32:52 +07:00
|
|
|
&debugfs_cfg_fops);
|
|
|
|
if (!node) {
|
|
|
|
pr_err("failed to create cfg in debugfs");
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
|
2013-09-25 19:39:49 +07:00
|
|
|
node = debugfs_create_file("status", S_IRUGO, priv->debug, priv,
|
2011-09-06 01:32:52 +07:00
|
|
|
&debugfs_status_fops);
|
|
|
|
if (!node) {
|
2012-05-03 16:38:35 +07:00
|
|
|
pr_err("failed to create status in debugfs");
|
2011-09-06 01:32:52 +07:00
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
errout:
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ideapad_debugfs_exit(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(priv->debug);
|
|
|
|
priv->debug = NULL;
|
|
|
|
}
|
|
|
|
|
2010-12-13 17:00:48 +07:00
|
|
|
/*
|
2011-06-30 18:50:40 +07:00
|
|
|
* sysfs
|
2010-12-13 17:00:48 +07:00
|
|
|
*/
|
2010-08-11 05:44:05 +07:00
|
|
|
static ssize_t show_ideapad_cam(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
2010-10-01 14:39:40 +07:00
|
|
|
unsigned long result;
|
2013-09-25 19:39:49 +07:00
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
2010-08-11 05:44:05 +07:00
|
|
|
|
2013-09-25 19:39:49 +07:00
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &result))
|
2010-10-01 14:39:40 +07:00
|
|
|
return sprintf(buf, "-1\n");
|
|
|
|
return sprintf(buf, "%lu\n", result);
|
2010-08-11 05:44:05 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t store_ideapad_cam(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
int ret, state;
|
2013-09-25 19:39:49 +07:00
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
2010-08-11 05:44:05 +07:00
|
|
|
|
|
|
|
if (!count)
|
|
|
|
return 0;
|
|
|
|
if (sscanf(buf, "%i", &state) != 1)
|
|
|
|
return -EINVAL;
|
2013-09-25 19:39:49 +07:00
|
|
|
ret = write_ec_cmd(priv->adev->handle, VPCCMD_W_CAMERA, state);
|
2010-08-11 05:44:05 +07:00
|
|
|
if (ret < 0)
|
2012-07-06 15:08:11 +07:00
|
|
|
return -EIO;
|
2010-08-11 05:44:05 +07:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(camera_power, 0644, show_ideapad_cam, store_ideapad_cam);
|
|
|
|
|
2012-07-06 15:08:11 +07:00
|
|
|
static ssize_t show_ideapad_fan(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
unsigned long result;
|
2013-09-25 19:39:49 +07:00
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
2012-07-06 15:08:11 +07:00
|
|
|
|
2013-09-25 19:39:49 +07:00
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_FAN, &result))
|
2012-07-06 15:08:11 +07:00
|
|
|
return sprintf(buf, "-1\n");
|
|
|
|
return sprintf(buf, "%lu\n", result);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t store_ideapad_fan(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
int ret, state;
|
2013-09-25 19:39:49 +07:00
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
2012-07-06 15:08:11 +07:00
|
|
|
|
|
|
|
if (!count)
|
|
|
|
return 0;
|
|
|
|
if (sscanf(buf, "%i", &state) != 1)
|
|
|
|
return -EINVAL;
|
|
|
|
if (state < 0 || state > 4 || state == 3)
|
|
|
|
return -EINVAL;
|
2013-09-25 19:39:49 +07:00
|
|
|
ret = write_ec_cmd(priv->adev->handle, VPCCMD_W_FAN, state);
|
2012-07-06 15:08:11 +07:00
|
|
|
if (ret < 0)
|
|
|
|
return -EIO;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(fan_mode, 0644, show_ideapad_fan, store_ideapad_fan);
|
|
|
|
|
platform/x86: ideapad-laptop: Add sysfs interface for touchpad state
Lenovo Yoga (many variants: Yoga, Yoga2 Pro, Yoga2 13, Yoga3 Pro, Yoga 3
14, etc) has multiple modles that are a hybrid laptop, working in laptop
mode as well as tablet mode.
Currently, there is no easy interface to determine the touchpad status,
which in case of the Yoga family of machines, can also be useful to
assume tablet mode status.
Note: The ideapad-laptop driver does not provide a SW_TABLET_MODE either.
For a detailed discussion on why we want either of the interfaces,
please see:
https://bugs.launchpad.net/onboard/+bug/1366421/comments/43
This patch adds a sysfs interface for read/write access under:
/sys/bus/platform/devices/VPC2004\:00/touchpad_mode
Signed-off-by: Ritesh Raj Sarraf <rrs@debian.org>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2017-02-18 01:47:56 +07:00
|
|
|
static ssize_t touchpad_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
|
|
|
unsigned long result;
|
|
|
|
|
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &result))
|
|
|
|
return sprintf(buf, "-1\n");
|
|
|
|
return sprintf(buf, "%lu\n", result);
|
|
|
|
}
|
|
|
|
|
2017-05-22 20:07:03 +07:00
|
|
|
/* Switch to RO for now: It might be revisited in the future */
|
|
|
|
static ssize_t __maybe_unused touchpad_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
platform/x86: ideapad-laptop: Add sysfs interface for touchpad state
Lenovo Yoga (many variants: Yoga, Yoga2 Pro, Yoga2 13, Yoga3 Pro, Yoga 3
14, etc) has multiple modles that are a hybrid laptop, working in laptop
mode as well as tablet mode.
Currently, there is no easy interface to determine the touchpad status,
which in case of the Yoga family of machines, can also be useful to
assume tablet mode status.
Note: The ideapad-laptop driver does not provide a SW_TABLET_MODE either.
For a detailed discussion on why we want either of the interfaces,
please see:
https://bugs.launchpad.net/onboard/+bug/1366421/comments/43
This patch adds a sysfs interface for read/write access under:
/sys/bus/platform/devices/VPC2004\:00/touchpad_mode
Signed-off-by: Ritesh Raj Sarraf <rrs@debian.org>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2017-02-18 01:47:56 +07:00
|
|
|
{
|
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
|
|
|
bool state;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = kstrtobool(buf, &state);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = write_ec_cmd(priv->adev->handle, VPCCMD_W_TOUCHPAD, state);
|
|
|
|
if (ret < 0)
|
|
|
|
return -EIO;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2017-05-07 18:28:30 +07:00
|
|
|
static DEVICE_ATTR_RO(touchpad);
|
platform/x86: ideapad-laptop: Add sysfs interface for touchpad state
Lenovo Yoga (many variants: Yoga, Yoga2 Pro, Yoga2 13, Yoga3 Pro, Yoga 3
14, etc) has multiple modles that are a hybrid laptop, working in laptop
mode as well as tablet mode.
Currently, there is no easy interface to determine the touchpad status,
which in case of the Yoga family of machines, can also be useful to
assume tablet mode status.
Note: The ideapad-laptop driver does not provide a SW_TABLET_MODE either.
For a detailed discussion on why we want either of the interfaces,
please see:
https://bugs.launchpad.net/onboard/+bug/1366421/comments/43
This patch adds a sysfs interface for read/write access under:
/sys/bus/platform/devices/VPC2004\:00/touchpad_mode
Signed-off-by: Ritesh Raj Sarraf <rrs@debian.org>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2017-02-18 01:47:56 +07:00
|
|
|
|
2011-06-30 18:50:40 +07:00
|
|
|
static struct attribute *ideapad_attributes[] = {
|
|
|
|
&dev_attr_camera_power.attr,
|
2012-07-06 15:08:11 +07:00
|
|
|
&dev_attr_fan_mode.attr,
|
platform/x86: ideapad-laptop: Add sysfs interface for touchpad state
Lenovo Yoga (many variants: Yoga, Yoga2 Pro, Yoga2 13, Yoga3 Pro, Yoga 3
14, etc) has multiple modles that are a hybrid laptop, working in laptop
mode as well as tablet mode.
Currently, there is no easy interface to determine the touchpad status,
which in case of the Yoga family of machines, can also be useful to
assume tablet mode status.
Note: The ideapad-laptop driver does not provide a SW_TABLET_MODE either.
For a detailed discussion on why we want either of the interfaces,
please see:
https://bugs.launchpad.net/onboard/+bug/1366421/comments/43
This patch adds a sysfs interface for read/write access under:
/sys/bus/platform/devices/VPC2004\:00/touchpad_mode
Signed-off-by: Ritesh Raj Sarraf <rrs@debian.org>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2017-02-18 01:47:56 +07:00
|
|
|
&dev_attr_touchpad.attr,
|
2011-06-30 18:50:40 +07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2011-07-24 10:11:19 +07:00
|
|
|
static umode_t ideapad_is_visible(struct kobject *kobj,
|
2011-06-30 18:50:47 +07:00
|
|
|
struct attribute *attr,
|
|
|
|
int idx)
|
|
|
|
{
|
|
|
|
struct device *dev = container_of(kobj, struct device, kobj);
|
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
|
|
|
bool supported;
|
|
|
|
|
|
|
|
if (attr == &dev_attr_camera_power.attr)
|
|
|
|
supported = test_bit(CFG_CAMERA_BIT, &(priv->cfg));
|
2012-07-06 15:08:11 +07:00
|
|
|
else if (attr == &dev_attr_fan_mode.attr) {
|
|
|
|
unsigned long value;
|
2013-09-25 19:39:49 +07:00
|
|
|
supported = !read_ec_data(priv->adev->handle, VPCCMD_R_FAN,
|
|
|
|
&value);
|
2012-07-06 15:08:11 +07:00
|
|
|
} else
|
2011-06-30 18:50:47 +07:00
|
|
|
supported = true;
|
|
|
|
|
|
|
|
return supported ? attr->mode : 0;
|
|
|
|
}
|
|
|
|
|
2014-07-17 00:43:15 +07:00
|
|
|
static const struct attribute_group ideapad_attribute_group = {
|
2011-06-30 18:50:47 +07:00
|
|
|
.is_visible = ideapad_is_visible,
|
2011-06-30 18:50:40 +07:00
|
|
|
.attrs = ideapad_attributes
|
|
|
|
};
|
|
|
|
|
2010-12-13 17:00:48 +07:00
|
|
|
/*
|
|
|
|
* Rfkill
|
|
|
|
*/
|
2010-12-13 17:01:12 +07:00
|
|
|
struct ideapad_rfk_data {
|
|
|
|
char *name;
|
|
|
|
int cfgbit;
|
|
|
|
int opcode;
|
|
|
|
int type;
|
|
|
|
};
|
|
|
|
|
2014-08-28 18:02:49 +07:00
|
|
|
static const struct ideapad_rfk_data ideapad_rfk_data[] = {
|
2011-09-06 01:31:53 +07:00
|
|
|
{ "ideapad_wlan", CFG_WIFI_BIT, VPCCMD_W_WIFI, RFKILL_TYPE_WLAN },
|
|
|
|
{ "ideapad_bluetooth", CFG_BT_BIT, VPCCMD_W_BT, RFKILL_TYPE_BLUETOOTH },
|
|
|
|
{ "ideapad_3g", CFG_3G_BIT, VPCCMD_W_3G, RFKILL_TYPE_WWAN },
|
2010-12-13 17:01:12 +07:00
|
|
|
};
|
|
|
|
|
2010-08-11 05:44:05 +07:00
|
|
|
static int ideapad_rfk_set(void *data, bool blocked)
|
|
|
|
{
|
2013-09-25 19:39:49 +07:00
|
|
|
struct ideapad_rfk_priv *priv = data;
|
2015-06-13 20:23:33 +07:00
|
|
|
int opcode = ideapad_rfk_data[priv->dev].opcode;
|
2010-10-01 14:39:59 +07:00
|
|
|
|
2015-06-13 20:23:33 +07:00
|
|
|
return write_ec_cmd(priv->priv->adev->handle, opcode, !blocked);
|
2010-08-11 05:44:05 +07:00
|
|
|
}
|
|
|
|
|
2017-06-09 13:08:18 +07:00
|
|
|
static const struct rfkill_ops ideapad_rfk_ops = {
|
2010-08-11 05:44:05 +07:00
|
|
|
.set_block = ideapad_rfk_set,
|
|
|
|
};
|
|
|
|
|
2011-09-06 01:32:01 +07:00
|
|
|
static void ideapad_sync_rfk_state(struct ideapad_private *priv)
|
2010-08-11 05:44:05 +07:00
|
|
|
{
|
2014-06-23 21:45:51 +07:00
|
|
|
unsigned long hw_blocked = 0;
|
2010-08-11 05:44:05 +07:00
|
|
|
int i;
|
|
|
|
|
2014-06-23 21:45:51 +07:00
|
|
|
if (priv->has_hw_rfkill_switch) {
|
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_RF, &hw_blocked))
|
|
|
|
return;
|
|
|
|
hw_blocked = !hw_blocked;
|
|
|
|
}
|
2010-08-11 05:44:05 +07:00
|
|
|
|
2010-12-13 17:01:12 +07:00
|
|
|
for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
|
2010-08-11 23:59:35 +07:00
|
|
|
if (priv->rfk[i])
|
2010-10-01 14:39:49 +07:00
|
|
|
rfkill_set_hw_state(priv->rfk[i], hw_blocked);
|
2010-08-11 05:44:05 +07:00
|
|
|
}
|
|
|
|
|
2013-09-25 19:39:48 +07:00
|
|
|
static int ideapad_register_rfkill(struct ideapad_private *priv, int dev)
|
2010-08-11 05:44:05 +07:00
|
|
|
{
|
|
|
|
int ret;
|
2010-10-01 14:39:49 +07:00
|
|
|
unsigned long sw_blocked;
|
2010-08-11 05:44:05 +07:00
|
|
|
|
2010-10-01 14:40:22 +07:00
|
|
|
if (no_bt_rfkill &&
|
|
|
|
(ideapad_rfk_data[dev].type == RFKILL_TYPE_BLUETOOTH)) {
|
|
|
|
/* Force to enable bluetooth when no_bt_rfkill=1 */
|
2013-09-25 19:39:49 +07:00
|
|
|
write_ec_cmd(priv->adev->handle,
|
2010-10-01 14:40:22 +07:00
|
|
|
ideapad_rfk_data[dev].opcode, 1);
|
|
|
|
return 0;
|
|
|
|
}
|
2013-09-25 19:39:49 +07:00
|
|
|
priv->rfk_priv[dev].dev = dev;
|
|
|
|
priv->rfk_priv[dev].priv = priv;
|
2010-10-01 14:40:22 +07:00
|
|
|
|
2013-09-25 19:39:48 +07:00
|
|
|
priv->rfk[dev] = rfkill_alloc(ideapad_rfk_data[dev].name,
|
2013-09-25 19:39:50 +07:00
|
|
|
&priv->platform_device->dev,
|
2013-09-25 19:39:48 +07:00
|
|
|
ideapad_rfk_data[dev].type,
|
|
|
|
&ideapad_rfk_ops,
|
2013-09-25 19:39:49 +07:00
|
|
|
&priv->rfk_priv[dev]);
|
2010-08-11 23:59:35 +07:00
|
|
|
if (!priv->rfk[dev])
|
2010-08-11 05:44:05 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2013-09-25 19:39:49 +07:00
|
|
|
if (read_ec_data(priv->adev->handle, ideapad_rfk_data[dev].opcode-1,
|
2010-10-01 14:39:49 +07:00
|
|
|
&sw_blocked)) {
|
|
|
|
rfkill_init_sw_state(priv->rfk[dev], 0);
|
|
|
|
} else {
|
|
|
|
sw_blocked = !sw_blocked;
|
|
|
|
rfkill_init_sw_state(priv->rfk[dev], sw_blocked);
|
|
|
|
}
|
|
|
|
|
2010-08-11 23:59:35 +07:00
|
|
|
ret = rfkill_register(priv->rfk[dev]);
|
2010-08-11 05:44:05 +07:00
|
|
|
if (ret) {
|
2010-08-11 23:59:35 +07:00
|
|
|
rfkill_destroy(priv->rfk[dev]);
|
2010-08-11 05:44:05 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-09-25 19:39:48 +07:00
|
|
|
static void ideapad_unregister_rfkill(struct ideapad_private *priv, int dev)
|
2010-08-11 05:44:05 +07:00
|
|
|
{
|
2010-08-11 23:59:35 +07:00
|
|
|
if (!priv->rfk[dev])
|
2010-08-11 05:44:05 +07:00
|
|
|
return;
|
|
|
|
|
2010-08-11 23:59:35 +07:00
|
|
|
rfkill_unregister(priv->rfk[dev]);
|
|
|
|
rfkill_destroy(priv->rfk[dev]);
|
2010-08-11 05:44:05 +07:00
|
|
|
}
|
|
|
|
|
2010-12-13 17:00:15 +07:00
|
|
|
/*
|
|
|
|
* Platform device
|
|
|
|
*/
|
2013-09-25 19:39:50 +07:00
|
|
|
static int ideapad_sysfs_init(struct ideapad_private *priv)
|
2010-12-13 17:00:15 +07:00
|
|
|
{
|
2013-09-25 19:39:50 +07:00
|
|
|
return sysfs_create_group(&priv->platform_device->dev.kobj,
|
2010-12-13 17:00:27 +07:00
|
|
|
&ideapad_attribute_group);
|
2010-12-13 17:00:15 +07:00
|
|
|
}
|
|
|
|
|
2013-09-25 19:39:50 +07:00
|
|
|
static void ideapad_sysfs_exit(struct ideapad_private *priv)
|
2010-12-13 17:00:15 +07:00
|
|
|
{
|
2010-12-13 17:01:01 +07:00
|
|
|
sysfs_remove_group(&priv->platform_device->dev.kobj,
|
2010-12-13 17:00:27 +07:00
|
|
|
&ideapad_attribute_group);
|
2010-12-13 17:00:15 +07:00
|
|
|
}
|
|
|
|
|
2010-12-13 17:00:38 +07:00
|
|
|
/*
|
|
|
|
* input device
|
|
|
|
*/
|
|
|
|
static const struct key_entry ideapad_keymap[] = {
|
2011-09-06 01:32:10 +07:00
|
|
|
{ KE_KEY, 6, { KEY_SWITCHVIDEOMODE } },
|
2012-07-06 15:07:50 +07:00
|
|
|
{ KE_KEY, 7, { KEY_CAMERA } },
|
2016-06-06 08:46:11 +07:00
|
|
|
{ KE_KEY, 8, { KEY_MICMUTE } },
|
2012-07-06 15:07:50 +07:00
|
|
|
{ KE_KEY, 11, { KEY_F16 } },
|
2011-09-06 01:32:10 +07:00
|
|
|
{ KE_KEY, 13, { KEY_WLAN } },
|
|
|
|
{ KE_KEY, 16, { KEY_PROG1 } },
|
|
|
|
{ KE_KEY, 17, { KEY_PROG2 } },
|
2012-07-06 15:07:50 +07:00
|
|
|
{ KE_KEY, 64, { KEY_PROG3 } },
|
|
|
|
{ KE_KEY, 65, { KEY_PROG4 } },
|
2012-07-06 15:08:00 +07:00
|
|
|
{ KE_KEY, 66, { KEY_TOUCHPAD_OFF } },
|
|
|
|
{ KE_KEY, 67, { KEY_TOUCHPAD_ON } },
|
ideapad-laptop: add support for Yoga 3 ESC key
The ideapad-laptop handles most special keys on various Lenovo Laptops
including the Yoga line. Unfortunately, the Yoga 3 11/13/14 models have
one important exception, which is the Fn-ESC combination.
On other Lenovo Laptops, this is FnLock, which switches the function keys
between the primary (Mute, Vol down, Vol up, ...) and the secondary (F1,
F2, F3, ...) behavior. On the new machines, FnLock is only available
through BIOS setup (possibly through a yet-to-be-implemented feature
in this driver) but not through Fn-ESC, but instead the ESC key itself
switched between ESC and a "Paper Display" app for Windows.
Unfortunately, that means that you can never have both ESC *and* the
function keys working at the same time without needing to press Fn on
one of them.
As pointed out in the official Lenovo Forum by dozens of users, this
makes the machine rather useless for any serious work [1].
I have now studied the ACPI DSDT one more time and found the event
that is generated for the ESC key. Unlike all other key events on this
machine, it is actually a WMI, while the other ones are read from the
embedded controller.
I am now installing a WMI notifier that uses the event number from the
WMI subsystem as the scancode. The only event number generated here is
'128', and that fits in nicely with the two existing ranges of scancodes
used by the EC: 0-15 for the 16-bit VPCCMD_R_VPC register, 16-17 for
the VPCCMD_R_NOVO register and 64-67 for VPCCMD_R_SPECIAL_BUTTONS.
The only sane way to handle this button (in absence of the Windows Paper
Display driver) seems to be to have it emit KEY_ESC, so that is what
I use as the default. Should any user ever want to overwrite the default,
they can install their own keymap.
To ensure that we can still build the driver without adding a CONFIG_WMI
dependency, all new code is enclosed in #ifdef.
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
[1] https://forums.lenovo.com/t5/Lenovo-Yoga-Series-Notebooks/YOGA-3-14-How-to-reclaim-my-Esc-key-and-permanently-disable/td-p/2070816
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-11-07 04:28:49 +07:00
|
|
|
{ KE_KEY, 128, { KEY_ESC } },
|
|
|
|
|
2010-12-13 17:00:38 +07:00
|
|
|
{ KE_END, 0 },
|
|
|
|
};
|
|
|
|
|
2012-12-22 04:18:33 +07:00
|
|
|
static int ideapad_input_init(struct ideapad_private *priv)
|
2010-12-13 17:00:38 +07:00
|
|
|
{
|
|
|
|
struct input_dev *inputdev;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
inputdev = input_allocate_device();
|
2013-10-24 02:14:52 +07:00
|
|
|
if (!inputdev)
|
2010-12-13 17:00:38 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
inputdev->name = "Ideapad extra buttons";
|
|
|
|
inputdev->phys = "ideapad/input0";
|
|
|
|
inputdev->id.bustype = BUS_HOST;
|
2010-12-13 17:01:01 +07:00
|
|
|
inputdev->dev.parent = &priv->platform_device->dev;
|
2010-12-13 17:00:38 +07:00
|
|
|
|
|
|
|
error = sparse_keymap_setup(inputdev, ideapad_keymap, NULL);
|
|
|
|
if (error) {
|
|
|
|
pr_err("Unable to setup input device keymap\n");
|
|
|
|
goto err_free_dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = input_register_device(inputdev);
|
|
|
|
if (error) {
|
|
|
|
pr_err("Unable to register input device\n");
|
2017-03-09 19:11:44 +07:00
|
|
|
goto err_free_dev;
|
2010-12-13 17:00:38 +07:00
|
|
|
}
|
|
|
|
|
2010-12-13 17:01:01 +07:00
|
|
|
priv->inputdev = inputdev;
|
2010-12-13 17:00:38 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_free_dev:
|
|
|
|
input_free_device(inputdev);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2011-07-27 14:27:34 +07:00
|
|
|
static void ideapad_input_exit(struct ideapad_private *priv)
|
2010-12-13 17:00:38 +07:00
|
|
|
{
|
2010-12-13 17:01:01 +07:00
|
|
|
input_unregister_device(priv->inputdev);
|
|
|
|
priv->inputdev = NULL;
|
2010-12-13 17:00:38 +07:00
|
|
|
}
|
|
|
|
|
2010-12-13 17:01:01 +07:00
|
|
|
static void ideapad_input_report(struct ideapad_private *priv,
|
|
|
|
unsigned long scancode)
|
2010-12-13 17:00:38 +07:00
|
|
|
{
|
2010-12-13 17:01:01 +07:00
|
|
|
sparse_keymap_report_event(priv->inputdev, scancode, 1, true);
|
2010-12-13 17:00:38 +07:00
|
|
|
}
|
|
|
|
|
2011-09-06 01:32:10 +07:00
|
|
|
static void ideapad_input_novokey(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
unsigned long long_pressed;
|
|
|
|
|
2013-09-25 19:39:49 +07:00
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_NOVO, &long_pressed))
|
2011-09-06 01:32:10 +07:00
|
|
|
return;
|
|
|
|
if (long_pressed)
|
|
|
|
ideapad_input_report(priv, 17);
|
|
|
|
else
|
|
|
|
ideapad_input_report(priv, 16);
|
|
|
|
}
|
|
|
|
|
2012-07-06 15:07:50 +07:00
|
|
|
static void ideapad_check_special_buttons(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
unsigned long bit, value;
|
|
|
|
|
2013-09-25 19:39:49 +07:00
|
|
|
read_ec_data(priv->adev->handle, VPCCMD_R_SPECIAL_BUTTONS, &value);
|
2012-07-06 15:07:50 +07:00
|
|
|
|
|
|
|
for (bit = 0; bit < 16; bit++) {
|
|
|
|
if (test_bit(bit, &value)) {
|
|
|
|
switch (bit) {
|
2013-03-20 17:34:17 +07:00
|
|
|
case 0: /* Z580 */
|
|
|
|
case 6: /* Z570 */
|
2012-07-06 15:07:50 +07:00
|
|
|
/* Thermal Management button */
|
|
|
|
ideapad_input_report(priv, 65);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
/* OneKey Theater button */
|
|
|
|
ideapad_input_report(priv, 64);
|
|
|
|
break;
|
2013-03-20 17:34:17 +07:00
|
|
|
default:
|
|
|
|
pr_info("Unknown special button: %lu\n", bit);
|
|
|
|
break;
|
2012-07-06 15:07:50 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-30 18:50:52 +07:00
|
|
|
/*
|
|
|
|
* backlight
|
|
|
|
*/
|
|
|
|
static int ideapad_backlight_get_brightness(struct backlight_device *blightdev)
|
|
|
|
{
|
2013-09-25 19:39:49 +07:00
|
|
|
struct ideapad_private *priv = bl_get_data(blightdev);
|
2011-06-30 18:50:52 +07:00
|
|
|
unsigned long now;
|
|
|
|
|
2013-09-25 19:39:49 +07:00
|
|
|
if (!priv)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now))
|
2011-06-30 18:50:52 +07:00
|
|
|
return -EIO;
|
|
|
|
return now;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ideapad_backlight_update_status(struct backlight_device *blightdev)
|
|
|
|
{
|
2013-09-25 19:39:49 +07:00
|
|
|
struct ideapad_private *priv = bl_get_data(blightdev);
|
|
|
|
|
|
|
|
if (!priv)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (write_ec_cmd(priv->adev->handle, VPCCMD_W_BL,
|
2011-09-06 01:31:53 +07:00
|
|
|
blightdev->props.brightness))
|
2011-06-30 18:50:52 +07:00
|
|
|
return -EIO;
|
2013-09-25 19:39:49 +07:00
|
|
|
if (write_ec_cmd(priv->adev->handle, VPCCMD_W_BL_POWER,
|
2011-06-30 18:50:52 +07:00
|
|
|
blightdev->props.power == FB_BLANK_POWERDOWN ? 0 : 1))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct backlight_ops ideapad_backlight_ops = {
|
|
|
|
.get_brightness = ideapad_backlight_get_brightness,
|
|
|
|
.update_status = ideapad_backlight_update_status,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ideapad_backlight_init(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
struct backlight_device *blightdev;
|
|
|
|
struct backlight_properties props;
|
|
|
|
unsigned long max, now, power;
|
|
|
|
|
2013-09-25 19:39:49 +07:00
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &max))
|
2011-06-30 18:50:52 +07:00
|
|
|
return -EIO;
|
2013-09-25 19:39:49 +07:00
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now))
|
2011-06-30 18:50:52 +07:00
|
|
|
return -EIO;
|
2013-09-25 19:39:49 +07:00
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power))
|
2011-06-30 18:50:52 +07:00
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
memset(&props, 0, sizeof(struct backlight_properties));
|
|
|
|
props.max_brightness = max;
|
|
|
|
props.type = BACKLIGHT_PLATFORM;
|
|
|
|
blightdev = backlight_device_register("ideapad",
|
|
|
|
&priv->platform_device->dev,
|
|
|
|
priv,
|
|
|
|
&ideapad_backlight_ops,
|
|
|
|
&props);
|
|
|
|
if (IS_ERR(blightdev)) {
|
|
|
|
pr_err("Could not register backlight device\n");
|
|
|
|
return PTR_ERR(blightdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
priv->blightdev = blightdev;
|
|
|
|
blightdev->props.brightness = now;
|
|
|
|
blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
|
|
|
|
backlight_update_status(blightdev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ideapad_backlight_exit(struct ideapad_private *priv)
|
|
|
|
{
|
2014-11-25 02:30:29 +07:00
|
|
|
backlight_device_unregister(priv->blightdev);
|
2011-06-30 18:50:52 +07:00
|
|
|
priv->blightdev = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ideapad_backlight_notify_power(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
unsigned long power;
|
|
|
|
struct backlight_device *blightdev = priv->blightdev;
|
|
|
|
|
2011-10-23 14:56:42 +07:00
|
|
|
if (!blightdev)
|
|
|
|
return;
|
2013-09-25 19:39:49 +07:00
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power))
|
2011-06-30 18:50:52 +07:00
|
|
|
return;
|
|
|
|
blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ideapad_backlight_notify_brightness(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
unsigned long now;
|
|
|
|
|
|
|
|
/* if we control brightness via acpi video driver */
|
|
|
|
if (priv->blightdev == NULL) {
|
2013-09-25 19:39:49 +07:00
|
|
|
read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now);
|
2011-06-30 18:50:52 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
backlight_force_update(priv->blightdev, BACKLIGHT_UPDATE_HOTKEY);
|
|
|
|
}
|
|
|
|
|
2010-12-13 17:00:48 +07:00
|
|
|
/*
|
|
|
|
* module init/exit
|
|
|
|
*/
|
2013-09-25 19:39:48 +07:00
|
|
|
static void ideapad_sync_touchpad_state(struct ideapad_private *priv)
|
2012-07-06 15:08:00 +07:00
|
|
|
{
|
|
|
|
unsigned long value;
|
|
|
|
|
|
|
|
/* Without reading from EC touchpad LED doesn't switch state */
|
2013-09-25 19:39:48 +07:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value)) {
|
2012-07-06 15:08:00 +07:00
|
|
|
/* Some IdeaPads don't really turn off touchpad - they only
|
|
|
|
* switch the LED state. We (de)activate KBC AUX port to turn
|
|
|
|
* touchpad off and on. We send KEY_TOUCHPAD_OFF and
|
|
|
|
* KEY_TOUCHPAD_ON to not to get out of sync with LED */
|
|
|
|
unsigned char param;
|
|
|
|
i8042_command(¶m, value ? I8042_CMD_AUX_ENABLE :
|
|
|
|
I8042_CMD_AUX_DISABLE);
|
|
|
|
ideapad_input_report(priv, value ? 67 : 66);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-25 19:39:50 +07:00
|
|
|
static void ideapad_acpi_notify(acpi_handle handle, u32 event, void *data)
|
|
|
|
{
|
|
|
|
struct ideapad_private *priv = data;
|
|
|
|
unsigned long vpc1, vpc2, vpc_bit;
|
|
|
|
|
|
|
|
if (read_ec_data(handle, VPCCMD_R_VPC1, &vpc1))
|
|
|
|
return;
|
|
|
|
if (read_ec_data(handle, VPCCMD_R_VPC2, &vpc2))
|
|
|
|
return;
|
|
|
|
|
|
|
|
vpc1 = (vpc2 << 8) | vpc1;
|
|
|
|
for (vpc_bit = 0; vpc_bit < 16; vpc_bit++) {
|
|
|
|
if (test_bit(vpc_bit, &vpc1)) {
|
|
|
|
switch (vpc_bit) {
|
|
|
|
case 9:
|
|
|
|
ideapad_sync_rfk_state(priv);
|
|
|
|
break;
|
|
|
|
case 13:
|
|
|
|
case 11:
|
2016-06-06 08:46:11 +07:00
|
|
|
case 8:
|
2013-09-25 19:39:50 +07:00
|
|
|
case 7:
|
|
|
|
case 6:
|
|
|
|
ideapad_input_report(priv, vpc_bit);
|
|
|
|
break;
|
|
|
|
case 5:
|
|
|
|
ideapad_sync_touchpad_state(priv);
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
ideapad_backlight_notify_brightness(priv);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
ideapad_input_novokey(priv);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
ideapad_backlight_notify_power(priv);
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
ideapad_check_special_buttons(priv);
|
|
|
|
break;
|
2017-05-22 17:38:55 +07:00
|
|
|
case 1:
|
|
|
|
/* Some IdeaPads report event 1 every ~20
|
|
|
|
* seconds while on battery power; some
|
|
|
|
* report this when changing to/from tablet
|
|
|
|
* mode. Squelch this event.
|
|
|
|
*/
|
|
|
|
break;
|
2013-09-25 19:39:50 +07:00
|
|
|
default:
|
|
|
|
pr_info("Unknown event: %lu\n", vpc_bit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
ideapad-laptop: add support for Yoga 3 ESC key
The ideapad-laptop handles most special keys on various Lenovo Laptops
including the Yoga line. Unfortunately, the Yoga 3 11/13/14 models have
one important exception, which is the Fn-ESC combination.
On other Lenovo Laptops, this is FnLock, which switches the function keys
between the primary (Mute, Vol down, Vol up, ...) and the secondary (F1,
F2, F3, ...) behavior. On the new machines, FnLock is only available
through BIOS setup (possibly through a yet-to-be-implemented feature
in this driver) but not through Fn-ESC, but instead the ESC key itself
switched between ESC and a "Paper Display" app for Windows.
Unfortunately, that means that you can never have both ESC *and* the
function keys working at the same time without needing to press Fn on
one of them.
As pointed out in the official Lenovo Forum by dozens of users, this
makes the machine rather useless for any serious work [1].
I have now studied the ACPI DSDT one more time and found the event
that is generated for the ESC key. Unlike all other key events on this
machine, it is actually a WMI, while the other ones are read from the
embedded controller.
I am now installing a WMI notifier that uses the event number from the
WMI subsystem as the scancode. The only event number generated here is
'128', and that fits in nicely with the two existing ranges of scancodes
used by the EC: 0-15 for the 16-bit VPCCMD_R_VPC register, 16-17 for
the VPCCMD_R_NOVO register and 64-67 for VPCCMD_R_SPECIAL_BUTTONS.
The only sane way to handle this button (in absence of the Windows Paper
Display driver) seems to be to have it emit KEY_ESC, so that is what
I use as the default. Should any user ever want to overwrite the default,
they can install their own keymap.
To ensure that we can still build the driver without adding a CONFIG_WMI
dependency, all new code is enclosed in #ifdef.
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
[1] https://forums.lenovo.com/t5/Lenovo-Yoga-Series-Notebooks/YOGA-3-14-How-to-reclaim-my-Esc-key-and-permanently-disable/td-p/2070816
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-11-07 04:28:49 +07:00
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI)
|
|
|
|
static void ideapad_wmi_notify(u32 value, void *context)
|
|
|
|
{
|
|
|
|
switch (value) {
|
|
|
|
case 128:
|
|
|
|
ideapad_input_report(context, value);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
pr_info("Unknown WMI event %u\n", value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-06-23 21:45:51 +07:00
|
|
|
/*
|
|
|
|
* Some ideapads don't have a hardware rfkill switch, reading VPCCMD_R_RF
|
|
|
|
* always results in 0 on these models, causing ideapad_laptop to wrongly
|
|
|
|
* report all radios as hardware-blocked.
|
|
|
|
*/
|
2014-08-28 18:02:49 +07:00
|
|
|
static const struct dmi_system_id no_hw_rfkill_list[] = {
|
2015-05-02 20:14:08 +07:00
|
|
|
{
|
|
|
|
.ident = "Lenovo G40-30",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo G40-30"),
|
|
|
|
},
|
|
|
|
},
|
2015-01-18 19:44:40 +07:00
|
|
|
{
|
|
|
|
.ident = "Lenovo G50-30",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo G50-30"),
|
|
|
|
},
|
|
|
|
},
|
2017-02-22 02:53:48 +07:00
|
|
|
{
|
|
|
|
.ident = "Lenovo V310-15ISK",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo V310-15ISK"),
|
|
|
|
},
|
|
|
|
},
|
2017-02-22 02:53:48 +07:00
|
|
|
{
|
|
|
|
.ident = "Lenovo ideapad 310-15IKB",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo ideapad 310-15IKB"),
|
|
|
|
},
|
|
|
|
},
|
2016-12-07 02:17:43 +07:00
|
|
|
{
|
|
|
|
.ident = "Lenovo ideapad Y700-15ACZ",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo ideapad Y700-15ACZ"),
|
|
|
|
},
|
|
|
|
},
|
2016-02-27 13:09:58 +07:00
|
|
|
{
|
|
|
|
.ident = "Lenovo ideapad Y700-15ISK",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo ideapad Y700-15ISK"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.ident = "Lenovo ideapad Y700 Touch-15ISK",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo ideapad Y700 Touch-15ISK"),
|
|
|
|
},
|
|
|
|
},
|
2015-12-10 09:12:52 +07:00
|
|
|
{
|
|
|
|
.ident = "Lenovo ideapad Y700-17ISK",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo ideapad Y700-17ISK"),
|
|
|
|
},
|
|
|
|
},
|
2017-06-18 18:09:31 +07:00
|
|
|
{
|
|
|
|
.ident = "Lenovo Legion Y520-15IKBN",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Y520-15IKBN"),
|
|
|
|
},
|
|
|
|
},
|
2014-05-13 21:00:28 +07:00
|
|
|
{
|
2014-06-23 21:45:51 +07:00
|
|
|
.ident = "Lenovo Yoga 2 11 / 13 / Pro",
|
2014-05-13 21:00:28 +07:00
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
2014-06-23 21:45:51 +07:00
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Yoga 2"),
|
2014-05-13 21:00:28 +07:00
|
|
|
},
|
|
|
|
},
|
2015-08-10 15:45:45 +07:00
|
|
|
{
|
2015-11-07 05:26:59 +07:00
|
|
|
.ident = "Lenovo Yoga 2 11 / 13 / Pro",
|
2015-08-10 15:45:45 +07:00
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
2015-11-07 05:26:59 +07:00
|
|
|
DMI_MATCH(DMI_BOARD_NAME, "Yoga2"),
|
2015-08-10 15:45:45 +07:00
|
|
|
},
|
|
|
|
},
|
2015-07-19 06:10:21 +07:00
|
|
|
{
|
2015-11-07 05:26:59 +07:00
|
|
|
.ident = "Lenovo Yoga 3 1170 / 1470",
|
2015-07-19 06:10:21 +07:00
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
2015-11-07 05:26:59 +07:00
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Yoga 3"),
|
2015-07-19 06:10:21 +07:00
|
|
|
},
|
|
|
|
},
|
2014-10-27 10:09:50 +07:00
|
|
|
{
|
|
|
|
.ident = "Lenovo Yoga 3 Pro 1370",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
2015-11-07 05:26:59 +07:00
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo YOGA 3"),
|
2014-10-27 10:09:50 +07:00
|
|
|
},
|
|
|
|
},
|
2016-01-24 22:46:42 +07:00
|
|
|
{
|
|
|
|
.ident = "Lenovo Yoga 700",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo YOGA 700"),
|
|
|
|
},
|
|
|
|
},
|
2015-11-09 23:09:05 +07:00
|
|
|
{
|
|
|
|
.ident = "Lenovo Yoga 900",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo YOGA 900"),
|
|
|
|
},
|
|
|
|
},
|
2016-10-19 17:27:40 +07:00
|
|
|
{
|
|
|
|
.ident = "Lenovo Yoga 900",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
|
|
|
DMI_MATCH(DMI_BOARD_NAME, "VIUU4"),
|
|
|
|
},
|
|
|
|
},
|
2016-10-12 06:28:02 +07:00
|
|
|
{
|
|
|
|
.ident = "Lenovo YOGA 910-13IKB",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo YOGA 910-13IKB"),
|
|
|
|
},
|
|
|
|
},
|
2014-05-13 21:00:28 +07:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2013-09-25 19:39:50 +07:00
|
|
|
static int ideapad_acpi_add(struct platform_device *pdev)
|
2010-08-11 05:44:05 +07:00
|
|
|
{
|
2011-06-30 18:50:40 +07:00
|
|
|
int ret, i;
|
2012-06-12 23:28:50 +07:00
|
|
|
int cfg;
|
2010-08-11 23:59:35 +07:00
|
|
|
struct ideapad_private *priv;
|
2013-09-25 19:39:50 +07:00
|
|
|
struct acpi_device *adev;
|
|
|
|
|
|
|
|
ret = acpi_bus_get_device(ACPI_HANDLE(&pdev->dev), &adev);
|
|
|
|
if (ret)
|
|
|
|
return -ENODEV;
|
2010-08-11 05:44:05 +07:00
|
|
|
|
2013-09-25 19:39:47 +07:00
|
|
|
if (read_method_int(adev->handle, "_CFG", &cfg))
|
2010-10-01 14:39:14 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
ideapad_laptop: Introduce the use of the managed version of kzalloc
This patch moves data allocated using kzalloc to managed data allocated
using devm_kzalloc and cleans now unnecessary kfrees in probe and remove
functions. The label sysfs_failed is removed as it is no longer
required. Also, linux/device.h is added to make sure the devm_*()
routine declarations are unambiguously available.
The following Coccinelle semantic patch was used for making the change:
@platform@
identifier p, probefn, removefn;
@@
struct platform_driver p = {
.probe = probefn,
.remove = removefn,
};
@prb@
identifier platform.probefn, pdev;
expression e, e1, e2;
@@
probefn(struct platform_device *pdev, ...) {
<+...
- e = kzalloc(e1, e2)
+ e = devm_kzalloc(&pdev->dev, e1, e2)
...
?-kfree(e);
...+>
}
@rem depends on prb@
identifier platform.removefn;
expression e;
@@
removefn(...) {
<...
- kfree(e);
...>
}
Signed-off-by: Himangi Saraogi <himangi774@gmail.com>
Acked-by: Julia Lawall <julia.lawall@lip6.fr>
Signed-off-by: Matthew Garrett <matthew.garrett@nebula.com>
2014-06-10 04:46:50 +07:00
|
|
|
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
|
2010-08-11 23:59:35 +07:00
|
|
|
if (!priv)
|
|
|
|
return -ENOMEM;
|
2013-09-25 19:39:50 +07:00
|
|
|
|
|
|
|
dev_set_drvdata(&pdev->dev, priv);
|
2011-06-30 18:50:40 +07:00
|
|
|
priv->cfg = cfg;
|
2013-09-25 19:39:47 +07:00
|
|
|
priv->adev = adev;
|
2013-09-25 19:39:50 +07:00
|
|
|
priv->platform_device = pdev;
|
2014-06-23 21:45:51 +07:00
|
|
|
priv->has_hw_rfkill_switch = !dmi_check_system(no_hw_rfkill_list);
|
2010-12-13 17:00:15 +07:00
|
|
|
|
2013-09-25 19:39:50 +07:00
|
|
|
ret = ideapad_sysfs_init(priv);
|
2010-12-13 17:00:15 +07:00
|
|
|
if (ret)
|
ideapad_laptop: Introduce the use of the managed version of kzalloc
This patch moves data allocated using kzalloc to managed data allocated
using devm_kzalloc and cleans now unnecessary kfrees in probe and remove
functions. The label sysfs_failed is removed as it is no longer
required. Also, linux/device.h is added to make sure the devm_*()
routine declarations are unambiguously available.
The following Coccinelle semantic patch was used for making the change:
@platform@
identifier p, probefn, removefn;
@@
struct platform_driver p = {
.probe = probefn,
.remove = removefn,
};
@prb@
identifier platform.probefn, pdev;
expression e, e1, e2;
@@
probefn(struct platform_device *pdev, ...) {
<+...
- e = kzalloc(e1, e2)
+ e = devm_kzalloc(&pdev->dev, e1, e2)
...
?-kfree(e);
...+>
}
@rem depends on prb@
identifier platform.removefn;
expression e;
@@
removefn(...) {
<...
- kfree(e);
...>
}
Signed-off-by: Himangi Saraogi <himangi774@gmail.com>
Acked-by: Julia Lawall <julia.lawall@lip6.fr>
Signed-off-by: Matthew Garrett <matthew.garrett@nebula.com>
2014-06-10 04:46:50 +07:00
|
|
|
return ret;
|
2010-08-11 23:59:35 +07:00
|
|
|
|
2011-09-06 01:32:52 +07:00
|
|
|
ret = ideapad_debugfs_init(priv);
|
|
|
|
if (ret)
|
|
|
|
goto debugfs_failed;
|
|
|
|
|
2010-12-13 17:01:01 +07:00
|
|
|
ret = ideapad_input_init(priv);
|
2010-12-13 17:00:38 +07:00
|
|
|
if (ret)
|
|
|
|
goto input_failed;
|
|
|
|
|
2014-06-23 21:45:51 +07:00
|
|
|
/*
|
|
|
|
* On some models without a hw-switch (the yoga 2 13 at least)
|
|
|
|
* VPCCMD_W_RF must be explicitly set to 1 for the wifi to work.
|
|
|
|
*/
|
|
|
|
if (!priv->has_hw_rfkill_switch)
|
|
|
|
write_ec_cmd(priv->adev->handle, VPCCMD_W_RF, 1);
|
|
|
|
|
|
|
|
for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
|
|
|
|
if (test_bit(ideapad_rfk_data[i].cfgbit, &priv->cfg))
|
|
|
|
ideapad_register_rfkill(priv, i);
|
|
|
|
|
2011-09-06 01:32:01 +07:00
|
|
|
ideapad_sync_rfk_state(priv);
|
2013-09-25 19:39:48 +07:00
|
|
|
ideapad_sync_touchpad_state(priv);
|
2010-12-13 17:00:27 +07:00
|
|
|
|
2015-06-16 21:28:04 +07:00
|
|
|
if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
|
2011-06-30 18:50:52 +07:00
|
|
|
ret = ideapad_backlight_init(priv);
|
|
|
|
if (ret && ret != -ENODEV)
|
|
|
|
goto backlight_failed;
|
|
|
|
}
|
2013-09-25 19:39:50 +07:00
|
|
|
ret = acpi_install_notify_handler(adev->handle,
|
|
|
|
ACPI_DEVICE_NOTIFY, ideapad_acpi_notify, priv);
|
|
|
|
if (ret)
|
|
|
|
goto notification_failed;
|
2016-05-10 04:49:21 +07:00
|
|
|
|
ideapad-laptop: add support for Yoga 3 ESC key
The ideapad-laptop handles most special keys on various Lenovo Laptops
including the Yoga line. Unfortunately, the Yoga 3 11/13/14 models have
one important exception, which is the Fn-ESC combination.
On other Lenovo Laptops, this is FnLock, which switches the function keys
between the primary (Mute, Vol down, Vol up, ...) and the secondary (F1,
F2, F3, ...) behavior. On the new machines, FnLock is only available
through BIOS setup (possibly through a yet-to-be-implemented feature
in this driver) but not through Fn-ESC, but instead the ESC key itself
switched between ESC and a "Paper Display" app for Windows.
Unfortunately, that means that you can never have both ESC *and* the
function keys working at the same time without needing to press Fn on
one of them.
As pointed out in the official Lenovo Forum by dozens of users, this
makes the machine rather useless for any serious work [1].
I have now studied the ACPI DSDT one more time and found the event
that is generated for the ESC key. Unlike all other key events on this
machine, it is actually a WMI, while the other ones are read from the
embedded controller.
I am now installing a WMI notifier that uses the event number from the
WMI subsystem as the scancode. The only event number generated here is
'128', and that fits in nicely with the two existing ranges of scancodes
used by the EC: 0-15 for the 16-bit VPCCMD_R_VPC register, 16-17 for
the VPCCMD_R_NOVO register and 64-67 for VPCCMD_R_SPECIAL_BUTTONS.
The only sane way to handle this button (in absence of the Windows Paper
Display driver) seems to be to have it emit KEY_ESC, so that is what
I use as the default. Should any user ever want to overwrite the default,
they can install their own keymap.
To ensure that we can still build the driver without adding a CONFIG_WMI
dependency, all new code is enclosed in #ifdef.
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
[1] https://forums.lenovo.com/t5/Lenovo-Yoga-Series-Notebooks/YOGA-3-14-How-to-reclaim-my-Esc-key-and-permanently-disable/td-p/2070816
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-11-07 04:28:49 +07:00
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI)
|
2016-05-10 04:49:21 +07:00
|
|
|
for (i = 0; i < ARRAY_SIZE(ideapad_wmi_fnesc_events); i++) {
|
|
|
|
ret = wmi_install_notify_handler(ideapad_wmi_fnesc_events[i],
|
|
|
|
ideapad_wmi_notify, priv);
|
|
|
|
if (ret == AE_OK) {
|
|
|
|
priv->fnesc_guid = ideapad_wmi_fnesc_events[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
ideapad-laptop: add support for Yoga 3 ESC key
The ideapad-laptop handles most special keys on various Lenovo Laptops
including the Yoga line. Unfortunately, the Yoga 3 11/13/14 models have
one important exception, which is the Fn-ESC combination.
On other Lenovo Laptops, this is FnLock, which switches the function keys
between the primary (Mute, Vol down, Vol up, ...) and the secondary (F1,
F2, F3, ...) behavior. On the new machines, FnLock is only available
through BIOS setup (possibly through a yet-to-be-implemented feature
in this driver) but not through Fn-ESC, but instead the ESC key itself
switched between ESC and a "Paper Display" app for Windows.
Unfortunately, that means that you can never have both ESC *and* the
function keys working at the same time without needing to press Fn on
one of them.
As pointed out in the official Lenovo Forum by dozens of users, this
makes the machine rather useless for any serious work [1].
I have now studied the ACPI DSDT one more time and found the event
that is generated for the ESC key. Unlike all other key events on this
machine, it is actually a WMI, while the other ones are read from the
embedded controller.
I am now installing a WMI notifier that uses the event number from the
WMI subsystem as the scancode. The only event number generated here is
'128', and that fits in nicely with the two existing ranges of scancodes
used by the EC: 0-15 for the 16-bit VPCCMD_R_VPC register, 16-17 for
the VPCCMD_R_NOVO register and 64-67 for VPCCMD_R_SPECIAL_BUTTONS.
The only sane way to handle this button (in absence of the Windows Paper
Display driver) seems to be to have it emit KEY_ESC, so that is what
I use as the default. Should any user ever want to overwrite the default,
they can install their own keymap.
To ensure that we can still build the driver without adding a CONFIG_WMI
dependency, all new code is enclosed in #ifdef.
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
[1] https://forums.lenovo.com/t5/Lenovo-Yoga-Series-Notebooks/YOGA-3-14-How-to-reclaim-my-Esc-key-and-permanently-disable/td-p/2070816
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-11-07 04:28:49 +07:00
|
|
|
if (ret != AE_OK && ret != AE_NOT_EXIST)
|
|
|
|
goto notification_failed_wmi;
|
|
|
|
#endif
|
2011-06-30 18:50:52 +07:00
|
|
|
|
2010-08-11 05:44:05 +07:00
|
|
|
return 0;
|
ideapad-laptop: add support for Yoga 3 ESC key
The ideapad-laptop handles most special keys on various Lenovo Laptops
including the Yoga line. Unfortunately, the Yoga 3 11/13/14 models have
one important exception, which is the Fn-ESC combination.
On other Lenovo Laptops, this is FnLock, which switches the function keys
between the primary (Mute, Vol down, Vol up, ...) and the secondary (F1,
F2, F3, ...) behavior. On the new machines, FnLock is only available
through BIOS setup (possibly through a yet-to-be-implemented feature
in this driver) but not through Fn-ESC, but instead the ESC key itself
switched between ESC and a "Paper Display" app for Windows.
Unfortunately, that means that you can never have both ESC *and* the
function keys working at the same time without needing to press Fn on
one of them.
As pointed out in the official Lenovo Forum by dozens of users, this
makes the machine rather useless for any serious work [1].
I have now studied the ACPI DSDT one more time and found the event
that is generated for the ESC key. Unlike all other key events on this
machine, it is actually a WMI, while the other ones are read from the
embedded controller.
I am now installing a WMI notifier that uses the event number from the
WMI subsystem as the scancode. The only event number generated here is
'128', and that fits in nicely with the two existing ranges of scancodes
used by the EC: 0-15 for the 16-bit VPCCMD_R_VPC register, 16-17 for
the VPCCMD_R_NOVO register and 64-67 for VPCCMD_R_SPECIAL_BUTTONS.
The only sane way to handle this button (in absence of the Windows Paper
Display driver) seems to be to have it emit KEY_ESC, so that is what
I use as the default. Should any user ever want to overwrite the default,
they can install their own keymap.
To ensure that we can still build the driver without adding a CONFIG_WMI
dependency, all new code is enclosed in #ifdef.
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
[1] https://forums.lenovo.com/t5/Lenovo-Yoga-Series-Notebooks/YOGA-3-14-How-to-reclaim-my-Esc-key-and-permanently-disable/td-p/2070816
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-11-07 04:28:49 +07:00
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI)
|
|
|
|
notification_failed_wmi:
|
|
|
|
acpi_remove_notify_handler(priv->adev->handle,
|
|
|
|
ACPI_DEVICE_NOTIFY, ideapad_acpi_notify);
|
|
|
|
#endif
|
2013-09-25 19:39:50 +07:00
|
|
|
notification_failed:
|
|
|
|
ideapad_backlight_exit(priv);
|
2011-06-30 18:50:52 +07:00
|
|
|
backlight_failed:
|
|
|
|
for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
|
2013-09-25 19:39:48 +07:00
|
|
|
ideapad_unregister_rfkill(priv, i);
|
2011-07-27 14:27:34 +07:00
|
|
|
ideapad_input_exit(priv);
|
2010-12-13 17:00:38 +07:00
|
|
|
input_failed:
|
2011-09-06 01:32:52 +07:00
|
|
|
ideapad_debugfs_exit(priv);
|
|
|
|
debugfs_failed:
|
2013-09-25 19:39:50 +07:00
|
|
|
ideapad_sysfs_exit(priv);
|
2010-12-13 17:00:15 +07:00
|
|
|
return ret;
|
2010-08-11 05:44:05 +07:00
|
|
|
}
|
|
|
|
|
2013-09-25 19:39:50 +07:00
|
|
|
static int ideapad_acpi_remove(struct platform_device *pdev)
|
2010-08-11 05:44:05 +07:00
|
|
|
{
|
2013-09-25 19:39:50 +07:00
|
|
|
struct ideapad_private *priv = dev_get_drvdata(&pdev->dev);
|
2010-08-11 05:44:05 +07:00
|
|
|
int i;
|
2010-08-11 23:59:35 +07:00
|
|
|
|
ideapad-laptop: add support for Yoga 3 ESC key
The ideapad-laptop handles most special keys on various Lenovo Laptops
including the Yoga line. Unfortunately, the Yoga 3 11/13/14 models have
one important exception, which is the Fn-ESC combination.
On other Lenovo Laptops, this is FnLock, which switches the function keys
between the primary (Mute, Vol down, Vol up, ...) and the secondary (F1,
F2, F3, ...) behavior. On the new machines, FnLock is only available
through BIOS setup (possibly through a yet-to-be-implemented feature
in this driver) but not through Fn-ESC, but instead the ESC key itself
switched between ESC and a "Paper Display" app for Windows.
Unfortunately, that means that you can never have both ESC *and* the
function keys working at the same time without needing to press Fn on
one of them.
As pointed out in the official Lenovo Forum by dozens of users, this
makes the machine rather useless for any serious work [1].
I have now studied the ACPI DSDT one more time and found the event
that is generated for the ESC key. Unlike all other key events on this
machine, it is actually a WMI, while the other ones are read from the
embedded controller.
I am now installing a WMI notifier that uses the event number from the
WMI subsystem as the scancode. The only event number generated here is
'128', and that fits in nicely with the two existing ranges of scancodes
used by the EC: 0-15 for the 16-bit VPCCMD_R_VPC register, 16-17 for
the VPCCMD_R_NOVO register and 64-67 for VPCCMD_R_SPECIAL_BUTTONS.
The only sane way to handle this button (in absence of the Windows Paper
Display driver) seems to be to have it emit KEY_ESC, so that is what
I use as the default. Should any user ever want to overwrite the default,
they can install their own keymap.
To ensure that we can still build the driver without adding a CONFIG_WMI
dependency, all new code is enclosed in #ifdef.
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
[1] https://forums.lenovo.com/t5/Lenovo-Yoga-Series-Notebooks/YOGA-3-14-How-to-reclaim-my-Esc-key-and-permanently-disable/td-p/2070816
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-11-07 04:28:49 +07:00
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI)
|
2016-05-10 04:49:21 +07:00
|
|
|
if (priv->fnesc_guid)
|
|
|
|
wmi_remove_notify_handler(priv->fnesc_guid);
|
ideapad-laptop: add support for Yoga 3 ESC key
The ideapad-laptop handles most special keys on various Lenovo Laptops
including the Yoga line. Unfortunately, the Yoga 3 11/13/14 models have
one important exception, which is the Fn-ESC combination.
On other Lenovo Laptops, this is FnLock, which switches the function keys
between the primary (Mute, Vol down, Vol up, ...) and the secondary (F1,
F2, F3, ...) behavior. On the new machines, FnLock is only available
through BIOS setup (possibly through a yet-to-be-implemented feature
in this driver) but not through Fn-ESC, but instead the ESC key itself
switched between ESC and a "Paper Display" app for Windows.
Unfortunately, that means that you can never have both ESC *and* the
function keys working at the same time without needing to press Fn on
one of them.
As pointed out in the official Lenovo Forum by dozens of users, this
makes the machine rather useless for any serious work [1].
I have now studied the ACPI DSDT one more time and found the event
that is generated for the ESC key. Unlike all other key events on this
machine, it is actually a WMI, while the other ones are read from the
embedded controller.
I am now installing a WMI notifier that uses the event number from the
WMI subsystem as the scancode. The only event number generated here is
'128', and that fits in nicely with the two existing ranges of scancodes
used by the EC: 0-15 for the 16-bit VPCCMD_R_VPC register, 16-17 for
the VPCCMD_R_NOVO register and 64-67 for VPCCMD_R_SPECIAL_BUTTONS.
The only sane way to handle this button (in absence of the Windows Paper
Display driver) seems to be to have it emit KEY_ESC, so that is what
I use as the default. Should any user ever want to overwrite the default,
they can install their own keymap.
To ensure that we can still build the driver without adding a CONFIG_WMI
dependency, all new code is enclosed in #ifdef.
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
[1] https://forums.lenovo.com/t5/Lenovo-Yoga-Series-Notebooks/YOGA-3-14-How-to-reclaim-my-Esc-key-and-permanently-disable/td-p/2070816
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-11-07 04:28:49 +07:00
|
|
|
#endif
|
2013-09-25 19:39:50 +07:00
|
|
|
acpi_remove_notify_handler(priv->adev->handle,
|
|
|
|
ACPI_DEVICE_NOTIFY, ideapad_acpi_notify);
|
2011-06-30 18:50:52 +07:00
|
|
|
ideapad_backlight_exit(priv);
|
2010-12-13 17:01:12 +07:00
|
|
|
for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
|
2013-09-25 19:39:48 +07:00
|
|
|
ideapad_unregister_rfkill(priv, i);
|
2010-12-13 17:01:01 +07:00
|
|
|
ideapad_input_exit(priv);
|
2011-09-06 01:32:52 +07:00
|
|
|
ideapad_debugfs_exit(priv);
|
2013-09-25 19:39:50 +07:00
|
|
|
ideapad_sysfs_exit(priv);
|
|
|
|
dev_set_drvdata(&pdev->dev, NULL);
|
2010-12-13 17:00:27 +07:00
|
|
|
|
2010-08-11 05:44:05 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-09-25 19:39:46 +07:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2012-07-06 15:08:00 +07:00
|
|
|
static int ideapad_acpi_resume(struct device *device)
|
|
|
|
{
|
2013-09-25 19:39:48 +07:00
|
|
|
struct ideapad_private *priv;
|
|
|
|
|
|
|
|
if (!device)
|
|
|
|
return -EINVAL;
|
|
|
|
priv = dev_get_drvdata(device);
|
|
|
|
|
|
|
|
ideapad_sync_rfk_state(priv);
|
|
|
|
ideapad_sync_touchpad_state(priv);
|
2012-07-06 15:08:00 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2013-09-25 19:39:46 +07:00
|
|
|
#endif
|
2013-09-25 19:39:50 +07:00
|
|
|
static SIMPLE_DEV_PM_OPS(ideapad_pm, NULL, ideapad_acpi_resume);
|
2012-07-06 15:08:00 +07:00
|
|
|
|
2013-09-25 19:39:50 +07:00
|
|
|
static const struct acpi_device_id ideapad_device_ids[] = {
|
|
|
|
{ "VPC2004", 0},
|
|
|
|
{ "", 0},
|
2010-08-11 05:44:05 +07:00
|
|
|
};
|
2013-09-25 19:39:50 +07:00
|
|
|
MODULE_DEVICE_TABLE(acpi, ideapad_device_ids);
|
|
|
|
|
|
|
|
static struct platform_driver ideapad_acpi_driver = {
|
|
|
|
.probe = ideapad_acpi_add,
|
|
|
|
.remove = ideapad_acpi_remove,
|
|
|
|
.driver = {
|
|
|
|
.name = "ideapad_acpi",
|
|
|
|
.pm = &ideapad_pm,
|
|
|
|
.acpi_match_table = ACPI_PTR(ideapad_device_ids),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
module_platform_driver(ideapad_acpi_driver);
|
2010-08-11 05:44:05 +07:00
|
|
|
|
|
|
|
MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
|
|
|
|
MODULE_DESCRIPTION("IdeaPad ACPI Extras");
|
|
|
|
MODULE_LICENSE("GPL");
|