2019-05-19 21:51:31 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2010-08-11 06:44:05 +08:00
|
|
|
/*
|
2010-12-13 18:00:48 +08:00
|
|
|
* ideapad-laptop.c - Lenovo IdeaPad ACPI Extras
|
2010-08-11 06:44:05 +08:00
|
|
|
*
|
|
|
|
* Copyright © 2010 Intel Corporation
|
|
|
|
* Copyright © 2010 David Woodhouse <dwmw2@infradead.org>
|
|
|
|
*/
|
|
|
|
|
2011-03-30 06:21:43 +08:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2021-02-04 05:54:36 +08:00
|
|
|
#include <linux/acpi.h>
|
|
|
|
#include <linux/backlight.h>
|
2021-02-04 05:55:21 +08:00
|
|
|
#include <linux/bitops.h>
|
2021-02-04 05:57:07 +08:00
|
|
|
#include <linux/bug.h>
|
2021-02-04 05:54:36 +08:00
|
|
|
#include <linux/debugfs.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/dmi.h>
|
|
|
|
#include <linux/fb.h>
|
|
|
|
#include <linux/i8042.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/input.h>
|
|
|
|
#include <linux/input/sparse-keymap.h>
|
2021-02-04 05:55:27 +08:00
|
|
|
#include <linux/jiffies.h>
|
2010-08-11 06:44:05 +08:00
|
|
|
#include <linux/kernel.h>
|
2021-02-04 05:57:07 +08:00
|
|
|
#include <linux/leds.h>
|
2010-08-11 06:44:05 +08:00
|
|
|
#include <linux/module.h>
|
2010-12-13 18:00:15 +08:00
|
|
|
#include <linux/platform_device.h>
|
2021-01-05 21:14:43 +08:00
|
|
|
#include <linux/platform_profile.h>
|
2021-02-04 05:54:36 +08:00
|
|
|
#include <linux/rfkill.h>
|
2011-09-06 02:32:52 +08:00
|
|
|
#include <linux/seq_file.h>
|
2021-02-04 05:54:56 +08:00
|
|
|
#include <linux/sysfs.h>
|
2021-02-04 05:54:36 +08:00
|
|
|
#include <linux/types.h>
|
|
|
|
|
2015-06-16 22:28:04 +08:00
|
|
|
#include <acpi/video.h>
|
2010-08-11 06:44:05 +08:00
|
|
|
|
2021-02-04 05:57:07 +08:00
|
|
|
#include <dt-bindings/leds/common.h>
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
#define IDEAPAD_RFKILL_DEV_NUM 3
|
2010-08-11 06:44:05 +08: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 05:28:49 +08:00
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI)
|
2016-05-10 05:49:21 +08: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 05:28:49 +08:00
|
|
|
#endif
|
|
|
|
|
2017-08-15 00:13:51 +08:00
|
|
|
enum {
|
2021-02-04 05:56:22 +08:00
|
|
|
CFG_CAP_BT_BIT = 16,
|
|
|
|
CFG_CAP_3G_BIT = 17,
|
|
|
|
CFG_CAP_WIFI_BIT = 18,
|
|
|
|
CFG_CAP_CAM_BIT = 19,
|
|
|
|
CFG_CAP_TOUCHPAD_BIT = 30,
|
2021-02-04 05:55:59 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
GBMD_CONSERVATION_STATE_BIT = 5,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
SMBC_CONSERVATION_ON = 3,
|
|
|
|
SMBC_CONSERVATION_OFF = 5,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
2021-02-04 05:57:13 +08:00
|
|
|
HALS_KBD_BL_SUPPORT_BIT = 4,
|
|
|
|
HALS_KBD_BL_STATE_BIT = 5,
|
|
|
|
HALS_USB_CHARGING_SUPPORT_BIT = 6,
|
|
|
|
HALS_USB_CHARGING_STATE_BIT = 7,
|
|
|
|
HALS_FNLOCK_SUPPORT_BIT = 9,
|
|
|
|
HALS_FNLOCK_STATE_BIT = 10,
|
|
|
|
HALS_HOTKEYS_PRIMARY_BIT = 11,
|
2021-02-04 05:55:59 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
2021-02-04 05:57:13 +08:00
|
|
|
SALS_KBD_BL_ON = 0x8,
|
|
|
|
SALS_KBD_BL_OFF = 0x9,
|
|
|
|
SALS_USB_CHARGING_ON = 0xa,
|
|
|
|
SALS_USB_CHARGING_OFF = 0xb,
|
|
|
|
SALS_FNLOCK_ON = 0xe,
|
|
|
|
SALS_FNLOCK_OFF = 0xf,
|
2017-08-15 00:13:51 +08:00
|
|
|
};
|
|
|
|
|
2011-09-06 02:31:53 +08: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 16:08:11 +08:00
|
|
|
VPCCMD_W_FAN,
|
|
|
|
VPCCMD_R_RF,
|
2011-09-06 02:31:53 +08:00
|
|
|
VPCCMD_W_RF,
|
2012-07-06 16:08:11 +08:00
|
|
|
VPCCMD_R_FAN = 0x2B,
|
2012-07-06 16:07:50 +08:00
|
|
|
VPCCMD_R_SPECIAL_BUTTONS = 0x31,
|
2011-09-06 02:31:53 +08:00
|
|
|
VPCCMD_W_BL_POWER = 0x33,
|
|
|
|
};
|
|
|
|
|
2021-01-05 21:14:43 +08:00
|
|
|
struct ideapad_dytc_priv {
|
|
|
|
enum platform_profile_option current_profile;
|
|
|
|
struct platform_profile_handler pprof;
|
2021-02-04 05:56:56 +08:00
|
|
|
struct mutex mutex; /* protects the DYTC interface */
|
2021-01-05 21:14:43 +08:00
|
|
|
struct ideapad_private *priv;
|
|
|
|
};
|
|
|
|
|
2013-09-25 20:39:49 +08:00
|
|
|
struct ideapad_rfk_priv {
|
|
|
|
int dev;
|
|
|
|
struct ideapad_private *priv;
|
|
|
|
};
|
|
|
|
|
2010-08-12 00:59:35 +08:00
|
|
|
struct ideapad_private {
|
2013-09-25 20:39:47 +08:00
|
|
|
struct acpi_device *adev;
|
2010-12-13 18:01:12 +08:00
|
|
|
struct rfkill *rfk[IDEAPAD_RFKILL_DEV_NUM];
|
2013-09-25 20:39:49 +08:00
|
|
|
struct ideapad_rfk_priv rfk_priv[IDEAPAD_RFKILL_DEV_NUM];
|
2010-12-13 18:00:15 +08:00
|
|
|
struct platform_device *platform_device;
|
2010-12-13 18:00:38 +08:00
|
|
|
struct input_dev *inputdev;
|
2011-06-30 19:50:52 +08:00
|
|
|
struct backlight_device *blightdev;
|
2021-01-05 21:14:43 +08:00
|
|
|
struct ideapad_dytc_priv *dytc;
|
2011-09-06 02:32:52 +08:00
|
|
|
struct dentry *debug;
|
2011-06-30 19:50:40 +08:00
|
|
|
unsigned long cfg;
|
2016-05-10 05:49:21 +08:00
|
|
|
const char *fnesc_guid;
|
2021-02-04 05:56:10 +08:00
|
|
|
struct {
|
|
|
|
bool conservation_mode : 1;
|
|
|
|
bool dytc : 1;
|
|
|
|
bool fan_mode : 1;
|
|
|
|
bool fn_lock : 1;
|
|
|
|
bool hw_rfkill_switch : 1;
|
2021-02-04 05:57:07 +08:00
|
|
|
bool kbd_bl : 1;
|
2021-02-04 05:56:10 +08:00
|
|
|
bool touchpad_ctrl_via_ec : 1;
|
2021-02-04 05:57:13 +08:00
|
|
|
bool usb_charging : 1;
|
2021-02-04 05:56:10 +08:00
|
|
|
} features;
|
2021-02-04 05:57:07 +08:00
|
|
|
struct {
|
|
|
|
bool initialized;
|
|
|
|
struct led_classdev led;
|
|
|
|
unsigned int last_brightness;
|
|
|
|
} kbd_bl;
|
2010-08-11 06:44:05 +08:00
|
|
|
};
|
|
|
|
|
2010-10-01 15:40:22 +08: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 15:38:46 +08:00
|
|
|
/*
|
|
|
|
* ACPI Helpers
|
|
|
|
*/
|
2021-02-04 05:56:56 +08:00
|
|
|
#define IDEAPAD_EC_TIMEOUT 200 /* in ms */
|
2010-10-01 15:38:46 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
static int eval_int(acpi_handle handle, const char *name, unsigned long *res)
|
2010-10-01 15:38:46 +08:00
|
|
|
{
|
|
|
|
unsigned long long result;
|
2021-02-04 05:56:05 +08:00
|
|
|
acpi_status status;
|
2010-10-01 15:38:46 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
status = acpi_evaluate_integer(handle, (char *)name, NULL, &result);
|
|
|
|
if (ACPI_FAILURE(status))
|
2021-02-04 05:55:43 +08:00
|
|
|
return -EIO;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
*res = result;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2017-12-02 21:45:31 +08:00
|
|
|
return 0;
|
2010-10-01 15:38:46 +08:00
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
static int exec_simple_method(acpi_handle handle, const char *name, unsigned long arg)
|
2017-08-15 00:13:51 +08:00
|
|
|
{
|
2021-02-04 05:56:05 +08:00
|
|
|
acpi_status status = acpi_execute_simple_method(handle, (char *)name, arg);
|
2017-08-15 00:13:51 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
return ACPI_FAILURE(status) ? -EIO : 0;
|
2017-08-15 00:13:51 +08:00
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
static int eval_gbmd(acpi_handle handle, unsigned long *res)
|
2017-08-15 00:13:51 +08:00
|
|
|
{
|
2021-02-04 05:56:05 +08:00
|
|
|
return eval_int(handle, "GBMD", res);
|
2017-08-15 00:13:51 +08:00
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
static int exec_smbc(acpi_handle handle, unsigned long arg)
|
2021-01-05 21:14:43 +08:00
|
|
|
{
|
2021-02-04 05:56:05 +08:00
|
|
|
return exec_simple_method(handle, "SMBC", arg);
|
|
|
|
}
|
2021-01-05 21:14:43 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
static int eval_hals(acpi_handle handle, unsigned long *res)
|
|
|
|
{
|
|
|
|
return eval_int(handle, "HALS", res);
|
|
|
|
}
|
2021-01-05 21:14:43 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
static int exec_sals(acpi_handle handle, unsigned long arg)
|
|
|
|
{
|
|
|
|
return exec_simple_method(handle, "SALS", arg);
|
2021-01-05 21:14:43 +08:00
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
static int eval_int_with_arg(acpi_handle handle, const char *name, unsigned long arg, unsigned long *res)
|
2010-10-01 15:38:46 +08:00
|
|
|
{
|
|
|
|
struct acpi_object_list params;
|
2021-02-04 05:56:05 +08:00
|
|
|
unsigned long long result;
|
2010-10-01 15:38:46 +08:00
|
|
|
union acpi_object in_obj;
|
2021-02-04 05:56:05 +08:00
|
|
|
acpi_status status;
|
2010-10-01 15:38:46 +08:00
|
|
|
|
|
|
|
params.count = 1;
|
|
|
|
params.pointer = &in_obj;
|
|
|
|
in_obj.type = ACPI_TYPE_INTEGER;
|
2021-02-04 05:56:05 +08:00
|
|
|
in_obj.integer.value = arg;
|
2010-10-01 15:38:46 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
status = acpi_evaluate_integer(handle, (char *)name, ¶ms, &result);
|
|
|
|
if (ACPI_FAILURE(status))
|
2021-02-04 05:55:43 +08:00
|
|
|
return -EIO;
|
2021-02-04 05:56:05 +08:00
|
|
|
|
|
|
|
if (res)
|
|
|
|
*res = result;
|
|
|
|
|
2017-12-02 21:45:31 +08:00
|
|
|
return 0;
|
2021-02-04 05:56:05 +08:00
|
|
|
}
|
2017-12-02 21:45:31 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
static int eval_dytc(acpi_handle handle, unsigned long cmd, unsigned long *res)
|
|
|
|
{
|
|
|
|
return eval_int_with_arg(handle, "DYTC", cmd, res);
|
2010-10-01 15:38:46 +08:00
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
static int eval_vpcr(acpi_handle handle, unsigned long cmd, unsigned long *res)
|
|
|
|
{
|
|
|
|
return eval_int_with_arg(handle, "VPCR", cmd, res);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int eval_vpcw(acpi_handle handle, unsigned long cmd, unsigned long data)
|
2010-10-01 15:38:46 +08:00
|
|
|
{
|
|
|
|
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);
|
2021-02-04 05:56:05 +08:00
|
|
|
if (ACPI_FAILURE(status))
|
2021-02-04 05:55:43 +08:00
|
|
|
return -EIO;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2010-10-01 15:38:46 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
static int read_ec_data(acpi_handle handle, unsigned long cmd, unsigned long *data)
|
2010-10-01 15:38:46 +08:00
|
|
|
{
|
2021-02-04 05:56:05 +08:00
|
|
|
unsigned long end_jiffies, val;
|
|
|
|
int err;
|
2010-10-01 15:38:46 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
err = eval_vpcw(handle, 1, cmd);
|
2021-02-04 05:55:43 +08:00
|
|
|
if (err)
|
|
|
|
return err;
|
2010-10-01 15:38:46 +08:00
|
|
|
|
2021-02-04 05:55:27 +08:00
|
|
|
end_jiffies = jiffies + msecs_to_jiffies(IDEAPAD_EC_TIMEOUT) + 1;
|
|
|
|
|
|
|
|
while (time_before(jiffies, end_jiffies)) {
|
2010-10-01 15:38:46 +08:00
|
|
|
schedule();
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
err = eval_vpcr(handle, 1, &val);
|
2021-02-04 05:55:43 +08:00
|
|
|
if (err)
|
|
|
|
return err;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
if (val == 0)
|
|
|
|
return eval_vpcr(handle, 0, data);
|
2010-10-01 15:38:46 +08:00
|
|
|
}
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:55:32 +08:00
|
|
|
acpi_handle_err(handle, "timeout in %s\n", __func__);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:55:43 +08:00
|
|
|
return -ETIMEDOUT;
|
2010-10-01 15:38:46 +08:00
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
static int write_ec_cmd(acpi_handle handle, unsigned long cmd, unsigned long data)
|
2010-10-01 15:38:46 +08:00
|
|
|
{
|
2021-02-04 05:56:05 +08:00
|
|
|
unsigned long end_jiffies, val;
|
|
|
|
int err;
|
2010-10-01 15:38:46 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
err = eval_vpcw(handle, 0, data);
|
2021-02-04 05:55:43 +08:00
|
|
|
if (err)
|
|
|
|
return err;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
err = eval_vpcw(handle, 1, cmd);
|
2021-02-04 05:55:43 +08:00
|
|
|
if (err)
|
|
|
|
return err;
|
2010-10-01 15:38:46 +08:00
|
|
|
|
2021-02-04 05:55:27 +08:00
|
|
|
end_jiffies = jiffies + msecs_to_jiffies(IDEAPAD_EC_TIMEOUT) + 1;
|
|
|
|
|
|
|
|
while (time_before(jiffies, end_jiffies)) {
|
2010-10-01 15:38:46 +08:00
|
|
|
schedule();
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
err = eval_vpcr(handle, 1, &val);
|
2021-02-04 05:55:43 +08:00
|
|
|
if (err)
|
|
|
|
return err;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2010-10-01 15:38:46 +08:00
|
|
|
if (val == 0)
|
|
|
|
return 0;
|
|
|
|
}
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:55:32 +08:00
|
|
|
acpi_handle_err(handle, "timeout in %s\n", __func__);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:55:43 +08:00
|
|
|
return -ETIMEDOUT;
|
2010-10-01 15:38:46 +08:00
|
|
|
}
|
|
|
|
|
2011-09-06 02:32:52 +08:00
|
|
|
/*
|
|
|
|
* debugfs
|
|
|
|
*/
|
|
|
|
static int debugfs_status_show(struct seq_file *s, void *data)
|
|
|
|
{
|
2013-09-25 20:39:49 +08:00
|
|
|
struct ideapad_private *priv = s->private;
|
2011-09-06 02:32:52 +08:00
|
|
|
unsigned long value;
|
|
|
|
|
2013-09-25 20:39:49 +08:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &value))
|
2021-02-04 05:56:34 +08:00
|
|
|
seq_printf(s, "Backlight max: %lu\n", value);
|
2013-09-25 20:39:49 +08:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL, &value))
|
2021-02-04 05:56:34 +08:00
|
|
|
seq_printf(s, "Backlight now: %lu\n", value);
|
2013-09-25 20:39:49 +08:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &value))
|
2021-02-04 05:56:34 +08:00
|
|
|
seq_printf(s, "BL power value: %s (%lu)\n", value ? "on" : "off", value);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:56:34 +08:00
|
|
|
seq_puts(s, "=====================\n");
|
2011-09-06 02:32:52 +08:00
|
|
|
|
2013-09-25 20:39:49 +08:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_RF, &value))
|
2021-02-04 05:56:34 +08:00
|
|
|
seq_printf(s, "Radio status: %s (%lu)\n", value ? "on" : "off", value);
|
2013-09-25 20:39:49 +08:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_WIFI, &value))
|
2021-02-04 05:56:34 +08:00
|
|
|
seq_printf(s, "Wifi status: %s (%lu)\n", value ? "on" : "off", value);
|
2013-09-25 20:39:49 +08:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_BT, &value))
|
2021-02-04 05:56:34 +08:00
|
|
|
seq_printf(s, "BT status: %s (%lu)\n", value ? "on" : "off", value);
|
2013-09-25 20:39:49 +08:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_3G, &value))
|
2021-02-04 05:56:34 +08:00
|
|
|
seq_printf(s, "3G status: %s (%lu)\n", value ? "on" : "off", value);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:56:34 +08:00
|
|
|
seq_puts(s, "=====================\n");
|
2011-09-06 02:32:52 +08:00
|
|
|
|
2013-09-25 20:39:49 +08:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value))
|
2021-02-04 05:56:34 +08:00
|
|
|
seq_printf(s, "Touchpad status: %s (%lu)\n", value ? "on" : "off", value);
|
2013-09-25 20:39:49 +08:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &value))
|
2021-02-04 05:56:34 +08:00
|
|
|
seq_printf(s, "Camera status: %s (%lu)\n", value ? "on" : "off", value);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2017-08-15 00:13:51 +08:00
|
|
|
seq_puts(s, "=====================\n");
|
|
|
|
|
2021-02-04 05:56:34 +08:00
|
|
|
if (!eval_gbmd(priv->adev->handle, &value))
|
|
|
|
seq_printf(s, "GBMD: %#010lx\n", value);
|
|
|
|
if (!eval_hals(priv->adev->handle, &value))
|
|
|
|
seq_printf(s, "HALS: %#010lx\n", value);
|
2011-09-06 02:32:52 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2018-01-23 00:05:45 +08:00
|
|
|
DEFINE_SHOW_ATTRIBUTE(debugfs_status);
|
2011-09-06 02:32:52 +08:00
|
|
|
|
|
|
|
static int debugfs_cfg_show(struct seq_file *s, void *data)
|
|
|
|
{
|
2013-09-25 20:39:49 +08:00
|
|
|
struct ideapad_private *priv = s->private;
|
|
|
|
|
2021-02-04 05:56:39 +08:00
|
|
|
seq_printf(s, "_CFG: %#010lx\n\n", priv->cfg);
|
|
|
|
|
|
|
|
seq_puts(s, "Capabilities:");
|
2021-02-04 05:55:59 +08:00
|
|
|
if (test_bit(CFG_CAP_BT_BIT, &priv->cfg))
|
2021-02-04 05:56:39 +08:00
|
|
|
seq_puts(s, " bluetooth");
|
2021-02-04 05:55:59 +08:00
|
|
|
if (test_bit(CFG_CAP_3G_BIT, &priv->cfg))
|
2021-02-04 05:56:39 +08:00
|
|
|
seq_puts(s, " 3G");
|
2021-02-04 05:55:59 +08:00
|
|
|
if (test_bit(CFG_CAP_WIFI_BIT, &priv->cfg))
|
2021-02-04 05:56:39 +08:00
|
|
|
seq_puts(s, " wifi");
|
2021-02-04 05:55:59 +08:00
|
|
|
if (test_bit(CFG_CAP_CAM_BIT, &priv->cfg))
|
2021-02-04 05:56:39 +08:00
|
|
|
seq_puts(s, " camera");
|
2021-02-04 05:56:22 +08:00
|
|
|
if (test_bit(CFG_CAP_TOUCHPAD_BIT, &priv->cfg))
|
2021-02-04 05:56:39 +08:00
|
|
|
seq_puts(s, " touchpad");
|
|
|
|
seq_puts(s, "\n");
|
|
|
|
|
|
|
|
seq_puts(s, "Graphics: ");
|
|
|
|
switch (priv->cfg & 0x700) {
|
2021-02-04 05:54:23 +08:00
|
|
|
case 0x100:
|
2021-02-04 05:56:39 +08:00
|
|
|
seq_puts(s, "Intel");
|
2021-02-04 05:54:23 +08:00
|
|
|
break;
|
|
|
|
case 0x200:
|
2021-02-04 05:56:39 +08:00
|
|
|
seq_puts(s, "ATI");
|
2021-02-04 05:54:23 +08:00
|
|
|
break;
|
|
|
|
case 0x300:
|
2021-02-04 05:56:39 +08:00
|
|
|
seq_puts(s, "Nvidia");
|
2021-02-04 05:54:23 +08:00
|
|
|
break;
|
|
|
|
case 0x400:
|
2021-02-04 05:56:39 +08:00
|
|
|
seq_puts(s, "Intel and ATI");
|
2021-02-04 05:54:23 +08:00
|
|
|
break;
|
|
|
|
case 0x500:
|
2021-02-04 05:56:39 +08:00
|
|
|
seq_puts(s, "Intel and Nvidia");
|
2021-02-04 05:54:23 +08:00
|
|
|
break;
|
2011-09-06 02:32:52 +08:00
|
|
|
}
|
2021-02-04 05:56:39 +08:00
|
|
|
seq_puts(s, "\n");
|
2021-02-04 05:54:23 +08:00
|
|
|
|
2011-09-06 02:32:52 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2018-01-23 00:05:45 +08:00
|
|
|
DEFINE_SHOW_ATTRIBUTE(debugfs_cfg);
|
2011-09-06 02:32:52 +08:00
|
|
|
|
2019-06-12 20:12:54 +08:00
|
|
|
static void ideapad_debugfs_init(struct ideapad_private *priv)
|
2011-09-06 02:32:52 +08:00
|
|
|
{
|
2019-06-12 20:12:54 +08:00
|
|
|
struct dentry *dir;
|
2011-09-06 02:32:52 +08:00
|
|
|
|
2019-06-12 20:12:54 +08:00
|
|
|
dir = debugfs_create_dir("ideapad", NULL);
|
|
|
|
priv->debug = dir;
|
2011-09-06 02:32:52 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
debugfs_create_file("cfg", 0444, dir, priv, &debugfs_cfg_fops);
|
|
|
|
debugfs_create_file("status", 0444, dir, priv, &debugfs_status_fops);
|
2011-09-06 02:32:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ideapad_debugfs_exit(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(priv->debug);
|
|
|
|
priv->debug = NULL;
|
|
|
|
}
|
|
|
|
|
2010-12-13 18:00:48 +08:00
|
|
|
/*
|
2011-06-30 19:50:40 +08:00
|
|
|
* sysfs
|
2010-12-13 18:00:48 +08:00
|
|
|
*/
|
2021-02-04 05:56:56 +08:00
|
|
|
static ssize_t camera_power_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
2010-08-11 06:44:05 +08:00
|
|
|
{
|
2013-09-25 20:39:49 +08:00
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
2021-02-04 05:56:56 +08:00
|
|
|
unsigned long result;
|
2021-02-04 05:55:48 +08:00
|
|
|
int err;
|
2010-08-11 06:44:05 +08:00
|
|
|
|
2021-02-04 05:55:48 +08:00
|
|
|
err = read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &result);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:55:53 +08:00
|
|
|
return sysfs_emit(buf, "%d\n", !!result);
|
2010-08-11 06:44:05 +08:00
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
static ssize_t camera_power_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2010-08-11 06:44:05 +08:00
|
|
|
{
|
2013-09-25 20:39:49 +08:00
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
2021-02-04 05:55:53 +08:00
|
|
|
bool state;
|
2021-02-04 05:56:56 +08:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = kstrtobool(buf, &state);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = write_ec_cmd(priv->adev->handle, VPCCMD_W_CAMERA, state);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2010-08-11 06:44:05 +08:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
static DEVICE_ATTR_RW(camera_power);
|
2010-08-11 06:44:05 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
static ssize_t conservation_mode_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
2012-07-06 16:08:11 +08:00
|
|
|
{
|
2013-09-25 20:39:49 +08:00
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
2021-02-04 05:56:56 +08:00
|
|
|
unsigned long result;
|
2021-02-04 05:55:48 +08:00
|
|
|
int err;
|
2012-07-06 16:08:11 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = eval_gbmd(priv->adev->handle, &result);
|
2021-02-04 05:55:48 +08:00
|
|
|
if (err)
|
|
|
|
return err;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
|
|
|
return sysfs_emit(buf, "%d\n", !!test_bit(GBMD_CONSERVATION_STATE_BIT, &result));
|
2012-07-06 16:08:11 +08:00
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
static ssize_t conservation_mode_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2012-07-06 16:08:11 +08:00
|
|
|
{
|
2013-09-25 20:39:49 +08:00
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
2021-02-04 05:56:56 +08:00
|
|
|
bool state;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = kstrtobool(buf, &state);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = exec_smbc(priv->adev->handle, state ? SMBC_CONSERVATION_ON : SMBC_CONSERVATION_OFF);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2012-07-06 16:08:11 +08:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
static DEVICE_ATTR_RW(conservation_mode);
|
2012-07-06 16:08:11 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
static ssize_t fan_mode_show(struct device *dev,
|
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 02:47:56 +08:00
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
|
|
|
unsigned long result;
|
2021-02-04 05:55:48 +08:00
|
|
|
int err;
|
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 02:47:56 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = read_ec_data(priv->adev->handle, VPCCMD_R_FAN, &result);
|
2021-02-04 05:55:48 +08:00
|
|
|
if (err)
|
|
|
|
return err;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
|
|
|
return sysfs_emit(buf, "%lu\n", result);
|
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 02:47:56 +08:00
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
static ssize_t fan_mode_store(struct device *dev,
|
2021-02-04 05:56:44 +08:00
|
|
|
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 02:47:56 +08:00
|
|
|
{
|
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
2021-02-04 05:56:56 +08:00
|
|
|
unsigned int state;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = kstrtouint(buf, 0, &state);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (state > 4 || state == 3)
|
|
|
|
return -EINVAL;
|
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 02:47:56 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = write_ec_cmd(priv->adev->handle, VPCCMD_W_FAN, state);
|
|
|
|
if (err)
|
|
|
|
return err;
|
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 02:47:56 +08:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
static DEVICE_ATTR_RW(fan_mode);
|
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 02:47:56 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
static ssize_t fn_lock_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
2017-08-15 00:13:51 +08:00
|
|
|
{
|
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
2021-02-04 05:56:56 +08:00
|
|
|
unsigned long hals;
|
2021-02-04 05:55:48 +08:00
|
|
|
int err;
|
2017-08-15 00:13:51 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = eval_hals(priv->adev->handle, &hals);
|
2021-02-04 05:55:48 +08:00
|
|
|
if (err)
|
|
|
|
return err;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
|
|
|
return sysfs_emit(buf, "%d\n", !!test_bit(HALS_FNLOCK_STATE_BIT, &hals));
|
2017-08-15 00:13:51 +08:00
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
static ssize_t fn_lock_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2017-08-15 00:13:51 +08:00
|
|
|
{
|
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
|
|
|
bool state;
|
2021-02-04 05:56:56 +08:00
|
|
|
int err;
|
2017-08-15 00:13:51 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = kstrtobool(buf, &state);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = exec_sals(priv->adev->handle, state ? SALS_FNLOCK_ON : SALS_FNLOCK_OFF);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2017-08-15 00:13:51 +08:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
static DEVICE_ATTR_RW(fn_lock);
|
2017-08-15 00:13:51 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
static ssize_t touchpad_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
2018-05-14 00:05:07 +08:00
|
|
|
{
|
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
2021-02-04 05:56:56 +08:00
|
|
|
unsigned long result;
|
|
|
|
int err;
|
2018-05-14 00:05:07 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &result);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2018-05-14 00:05:07 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
return sysfs_emit(buf, "%d\n", !!result);
|
2018-05-14 00:05:07 +08:00
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
static ssize_t touchpad_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2018-05-14 00:05:07 +08:00
|
|
|
{
|
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
|
|
|
bool state;
|
2021-02-04 05:56:56 +08:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = kstrtobool(buf, &state);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2018-05-14 00:05:07 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = write_ec_cmd(priv->adev->handle, VPCCMD_W_TOUCHPAD, state);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2018-05-14 00:05:07 +08:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
static DEVICE_ATTR_RW(touchpad);
|
2018-05-14 00:05:07 +08:00
|
|
|
|
2021-02-04 05:57:13 +08:00
|
|
|
static ssize_t usb_charging_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
|
|
|
unsigned long hals;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = eval_hals(priv->adev->handle, &hals);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
return sysfs_emit(buf, "%d\n", !!test_bit(HALS_USB_CHARGING_STATE_BIT, &hals));
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t usb_charging_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
|
|
|
bool state;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = kstrtobool(buf, &state);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = exec_sals(priv->adev->handle, state ? SALS_USB_CHARGING_ON : SALS_USB_CHARGING_OFF);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR_RW(usb_charging);
|
|
|
|
|
2011-06-30 19:50:40 +08:00
|
|
|
static struct attribute *ideapad_attributes[] = {
|
|
|
|
&dev_attr_camera_power.attr,
|
2017-08-15 00:13:51 +08:00
|
|
|
&dev_attr_conservation_mode.attr,
|
2021-02-04 05:56:56 +08:00
|
|
|
&dev_attr_fan_mode.attr,
|
2018-05-14 00:05:07 +08:00
|
|
|
&dev_attr_fn_lock.attr,
|
2021-02-04 05:56:56 +08:00
|
|
|
&dev_attr_touchpad.attr,
|
2021-02-04 05:57:13 +08:00
|
|
|
&dev_attr_usb_charging.attr,
|
2011-06-30 19:50:40 +08:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2011-07-24 11:11:19 +08:00
|
|
|
static umode_t ideapad_is_visible(struct kobject *kobj,
|
2021-02-04 05:56:56 +08:00
|
|
|
struct attribute *attr,
|
|
|
|
int idx)
|
2011-06-30 19:50:47 +08:00
|
|
|
{
|
2021-02-04 05:55:15 +08:00
|
|
|
struct device *dev = kobj_to_dev(kobj);
|
2011-06-30 19:50:47 +08:00
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
2021-02-04 05:56:10 +08:00
|
|
|
bool supported = true;
|
2011-06-30 19:50:47 +08:00
|
|
|
|
|
|
|
if (attr == &dev_attr_camera_power.attr)
|
2021-02-04 05:55:59 +08:00
|
|
|
supported = test_bit(CFG_CAP_CAM_BIT, &priv->cfg);
|
2021-02-04 05:56:10 +08:00
|
|
|
else if (attr == &dev_attr_conservation_mode.attr)
|
|
|
|
supported = priv->features.conservation_mode;
|
|
|
|
else if (attr == &dev_attr_fan_mode.attr)
|
|
|
|
supported = priv->features.fan_mode;
|
|
|
|
else if (attr == &dev_attr_fn_lock.attr)
|
|
|
|
supported = priv->features.fn_lock;
|
|
|
|
else if (attr == &dev_attr_touchpad.attr)
|
2021-02-04 05:56:22 +08:00
|
|
|
supported = priv->features.touchpad_ctrl_via_ec &&
|
|
|
|
test_bit(CFG_CAP_TOUCHPAD_BIT, &priv->cfg);
|
2021-02-04 05:57:13 +08:00
|
|
|
else if (attr == &dev_attr_usb_charging.attr)
|
|
|
|
supported = priv->features.usb_charging;
|
2011-06-30 19:50:47 +08:00
|
|
|
|
|
|
|
return supported ? attr->mode : 0;
|
|
|
|
}
|
|
|
|
|
2014-07-17 01:43:15 +08:00
|
|
|
static const struct attribute_group ideapad_attribute_group = {
|
2011-06-30 19:50:47 +08:00
|
|
|
.is_visible = ideapad_is_visible,
|
2011-06-30 19:50:40 +08:00
|
|
|
.attrs = ideapad_attributes
|
|
|
|
};
|
|
|
|
|
2021-01-05 21:14:43 +08:00
|
|
|
/*
|
|
|
|
* DYTC Platform profile
|
|
|
|
*/
|
|
|
|
#define DYTC_CMD_QUERY 0 /* To get DYTC status - enable/revision */
|
|
|
|
#define DYTC_CMD_SET 1 /* To enable/disable IC function mode */
|
|
|
|
#define DYTC_CMD_GET 2 /* To get current IC function and mode */
|
|
|
|
#define DYTC_CMD_RESET 0x1ff /* To reset back to default */
|
|
|
|
|
|
|
|
#define DYTC_QUERY_ENABLE_BIT 8 /* Bit 8 - 0 = disabled, 1 = enabled */
|
|
|
|
#define DYTC_QUERY_SUBREV_BIT 16 /* Bits 16 - 27 - sub revision */
|
|
|
|
#define DYTC_QUERY_REV_BIT 28 /* Bits 28 - 31 - revision */
|
|
|
|
|
|
|
|
#define DYTC_GET_FUNCTION_BIT 8 /* Bits 8-11 - function setting */
|
|
|
|
#define DYTC_GET_MODE_BIT 12 /* Bits 12-15 - mode setting */
|
|
|
|
|
|
|
|
#define DYTC_SET_FUNCTION_BIT 12 /* Bits 12-15 - function setting */
|
|
|
|
#define DYTC_SET_MODE_BIT 16 /* Bits 16-19 - mode setting */
|
|
|
|
#define DYTC_SET_VALID_BIT 20 /* Bit 20 - 1 = on, 0 = off */
|
|
|
|
|
|
|
|
#define DYTC_FUNCTION_STD 0 /* Function = 0, standard mode */
|
|
|
|
#define DYTC_FUNCTION_CQL 1 /* Function = 1, lap mode */
|
|
|
|
#define DYTC_FUNCTION_MMC 11 /* Function = 11, desk mode */
|
|
|
|
|
|
|
|
#define DYTC_MODE_PERFORM 2 /* High power mode aka performance */
|
|
|
|
#define DYTC_MODE_LOW_POWER 3 /* Low power mode aka quiet */
|
|
|
|
#define DYTC_MODE_BALANCE 0xF /* Default mode aka balanced */
|
|
|
|
|
|
|
|
#define DYTC_SET_COMMAND(function, mode, on) \
|
|
|
|
(DYTC_CMD_SET | (function) << DYTC_SET_FUNCTION_BIT | \
|
|
|
|
(mode) << DYTC_SET_MODE_BIT | \
|
|
|
|
(on) << DYTC_SET_VALID_BIT)
|
|
|
|
|
|
|
|
#define DYTC_DISABLE_CQL DYTC_SET_COMMAND(DYTC_FUNCTION_CQL, DYTC_MODE_BALANCE, 0)
|
|
|
|
|
|
|
|
#define DYTC_ENABLE_CQL DYTC_SET_COMMAND(DYTC_FUNCTION_CQL, DYTC_MODE_BALANCE, 1)
|
|
|
|
|
|
|
|
static int convert_dytc_to_profile(int dytcmode, enum platform_profile_option *profile)
|
|
|
|
{
|
|
|
|
switch (dytcmode) {
|
|
|
|
case DYTC_MODE_LOW_POWER:
|
|
|
|
*profile = PLATFORM_PROFILE_LOW_POWER;
|
|
|
|
break;
|
|
|
|
case DYTC_MODE_BALANCE:
|
|
|
|
*profile = PLATFORM_PROFILE_BALANCED;
|
|
|
|
break;
|
|
|
|
case DYTC_MODE_PERFORM:
|
|
|
|
*profile = PLATFORM_PROFILE_PERFORMANCE;
|
|
|
|
break;
|
|
|
|
default: /* Unknown mode */
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-01-05 21:14:43 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int convert_profile_to_dytc(enum platform_profile_option profile, int *perfmode)
|
|
|
|
{
|
|
|
|
switch (profile) {
|
|
|
|
case PLATFORM_PROFILE_LOW_POWER:
|
|
|
|
*perfmode = DYTC_MODE_LOW_POWER;
|
|
|
|
break;
|
|
|
|
case PLATFORM_PROFILE_BALANCED:
|
|
|
|
*perfmode = DYTC_MODE_BALANCE;
|
|
|
|
break;
|
|
|
|
case PLATFORM_PROFILE_PERFORMANCE:
|
|
|
|
*perfmode = DYTC_MODE_PERFORM;
|
|
|
|
break;
|
|
|
|
default: /* Unknown profile */
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-01-05 21:14:43 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* dytc_profile_get: Function to register with platform_profile
|
|
|
|
* handler. Returns current platform profile.
|
|
|
|
*/
|
2021-02-04 05:56:56 +08:00
|
|
|
static int dytc_profile_get(struct platform_profile_handler *pprof,
|
|
|
|
enum platform_profile_option *profile)
|
2021-01-05 21:14:43 +08:00
|
|
|
{
|
2021-02-04 05:56:56 +08:00
|
|
|
struct ideapad_dytc_priv *dytc = container_of(pprof, struct ideapad_dytc_priv, pprof);
|
2021-01-05 21:14:43 +08:00
|
|
|
|
|
|
|
*profile = dytc->current_profile;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Helper function - check if we are in CQL mode and if we are
|
2021-02-04 05:56:56 +08:00
|
|
|
* - disable CQL,
|
2021-01-05 21:14:43 +08:00
|
|
|
* - run the command
|
|
|
|
* - enable CQL
|
|
|
|
* If not in CQL mode, just run the command
|
|
|
|
*/
|
2021-02-04 05:56:56 +08:00
|
|
|
static int dytc_cql_command(struct ideapad_private *priv, unsigned long cmd,
|
|
|
|
unsigned long *output)
|
2021-01-05 21:14:43 +08:00
|
|
|
{
|
2021-02-04 05:56:05 +08:00
|
|
|
int err, cmd_err, cur_funcmode;
|
2021-01-05 21:14:43 +08:00
|
|
|
|
|
|
|
/* Determine if we are in CQL mode. This alters the commands we do */
|
2021-02-04 05:56:05 +08:00
|
|
|
err = eval_dytc(priv->adev->handle, DYTC_CMD_GET, output);
|
2021-01-05 21:14:43 +08:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
cur_funcmode = (*output >> DYTC_GET_FUNCTION_BIT) & 0xF;
|
|
|
|
/* Check if we're OK to return immediately */
|
2021-02-04 05:56:05 +08:00
|
|
|
if (cmd == DYTC_CMD_GET && cur_funcmode != DYTC_FUNCTION_CQL)
|
2021-01-05 21:14:43 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (cur_funcmode == DYTC_FUNCTION_CQL) {
|
2021-02-04 05:56:05 +08:00
|
|
|
err = eval_dytc(priv->adev->handle, DYTC_DISABLE_CQL, NULL);
|
2021-01-05 21:14:43 +08:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
cmd_err = eval_dytc(priv->adev->handle, cmd, output);
|
2021-01-05 21:14:43 +08:00
|
|
|
/* Check return condition after we've restored CQL state */
|
|
|
|
|
|
|
|
if (cur_funcmode == DYTC_FUNCTION_CQL) {
|
2021-02-04 05:56:05 +08:00
|
|
|
err = eval_dytc(priv->adev->handle, DYTC_ENABLE_CQL, NULL);
|
2021-01-05 21:14:43 +08:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return cmd_err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* dytc_profile_set: Function to register with platform_profile
|
|
|
|
* handler. Sets current platform profile.
|
|
|
|
*/
|
2021-02-04 05:56:56 +08:00
|
|
|
static int dytc_profile_set(struct platform_profile_handler *pprof,
|
|
|
|
enum platform_profile_option profile)
|
2021-01-05 21:14:43 +08:00
|
|
|
{
|
2021-02-04 05:56:56 +08:00
|
|
|
struct ideapad_dytc_priv *dytc = container_of(pprof, struct ideapad_dytc_priv, pprof);
|
|
|
|
struct ideapad_private *priv = dytc->priv;
|
2021-01-05 21:14:43 +08:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = mutex_lock_interruptible(&dytc->mutex);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (profile == PLATFORM_PROFILE_BALANCED) {
|
|
|
|
/* To get back to balanced mode we just issue a reset command */
|
2021-02-04 05:56:05 +08:00
|
|
|
err = eval_dytc(priv->adev->handle, DYTC_CMD_RESET, NULL);
|
2021-01-05 21:14:43 +08:00
|
|
|
if (err)
|
|
|
|
goto unlock;
|
|
|
|
} else {
|
|
|
|
int perfmode;
|
|
|
|
|
|
|
|
err = convert_profile_to_dytc(profile, &perfmode);
|
|
|
|
if (err)
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
/* Determine if we are in CQL mode. This alters the commands we do */
|
2021-02-04 05:56:56 +08:00
|
|
|
err = dytc_cql_command(priv, DYTC_SET_COMMAND(DYTC_FUNCTION_MMC, perfmode, 1),
|
|
|
|
NULL);
|
2021-01-05 21:14:43 +08:00
|
|
|
if (err)
|
|
|
|
goto unlock;
|
|
|
|
}
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-01-05 21:14:43 +08:00
|
|
|
/* Success - update current profile */
|
|
|
|
dytc->current_profile = profile;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-01-05 21:14:43 +08:00
|
|
|
unlock:
|
|
|
|
mutex_unlock(&dytc->mutex);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-01-05 21:14:43 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dytc_profile_refresh(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
enum platform_profile_option profile;
|
2021-02-04 05:56:05 +08:00
|
|
|
unsigned long output;
|
|
|
|
int err, perfmode;
|
2021-01-05 21:14:43 +08:00
|
|
|
|
|
|
|
mutex_lock(&priv->dytc->mutex);
|
|
|
|
err = dytc_cql_command(priv, DYTC_CMD_GET, &output);
|
|
|
|
mutex_unlock(&priv->dytc->mutex);
|
|
|
|
if (err)
|
|
|
|
return;
|
|
|
|
|
|
|
|
perfmode = (output >> DYTC_GET_MODE_BIT) & 0xF;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
|
|
|
if (convert_dytc_to_profile(perfmode, &profile))
|
|
|
|
return;
|
|
|
|
|
2021-01-05 21:14:43 +08:00
|
|
|
if (profile != priv->dytc->current_profile) {
|
|
|
|
priv->dytc->current_profile = profile;
|
|
|
|
platform_profile_notify();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ideapad_dytc_profile_init(struct ideapad_private *priv)
|
|
|
|
{
|
2021-02-04 05:56:05 +08:00
|
|
|
int err, dytc_version;
|
|
|
|
unsigned long output;
|
2021-01-05 21:14:43 +08:00
|
|
|
|
2021-02-04 05:56:10 +08:00
|
|
|
if (!priv->features.dytc)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
err = eval_dytc(priv->adev->handle, DYTC_CMD_QUERY, &output);
|
2021-01-05 21:14:43 +08:00
|
|
|
/* For all other errors we can flag the failure */
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* Check DYTC is enabled and supports mode setting */
|
2021-02-04 05:56:56 +08:00
|
|
|
if (!test_bit(DYTC_QUERY_ENABLE_BIT, &output))
|
2021-01-05 21:14:43 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
dytc_version = (output >> DYTC_QUERY_REV_BIT) & 0xF;
|
|
|
|
if (dytc_version < 5)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
priv->dytc = kzalloc(sizeof(*priv->dytc), GFP_KERNEL);
|
2021-01-05 21:14:43 +08:00
|
|
|
if (!priv->dytc)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
mutex_init(&priv->dytc->mutex);
|
|
|
|
|
|
|
|
priv->dytc->priv = priv;
|
|
|
|
priv->dytc->pprof.profile_get = dytc_profile_get;
|
|
|
|
priv->dytc->pprof.profile_set = dytc_profile_set;
|
|
|
|
|
|
|
|
/* Setup supported modes */
|
|
|
|
set_bit(PLATFORM_PROFILE_LOW_POWER, priv->dytc->pprof.choices);
|
|
|
|
set_bit(PLATFORM_PROFILE_BALANCED, priv->dytc->pprof.choices);
|
|
|
|
set_bit(PLATFORM_PROFILE_PERFORMANCE, priv->dytc->pprof.choices);
|
|
|
|
|
|
|
|
/* Create platform_profile structure and register */
|
|
|
|
err = platform_profile_register(&priv->dytc->pprof);
|
|
|
|
if (err)
|
2021-02-04 05:56:56 +08:00
|
|
|
goto pp_reg_failed;
|
2021-01-05 21:14:43 +08:00
|
|
|
|
|
|
|
/* Ensure initial values are correct */
|
|
|
|
dytc_profile_refresh(priv);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
pp_reg_failed:
|
2021-01-05 21:14:43 +08:00
|
|
|
mutex_destroy(&priv->dytc->mutex);
|
|
|
|
kfree(priv->dytc);
|
|
|
|
priv->dytc = NULL;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-01-05 21:14:43 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ideapad_dytc_profile_exit(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
if (!priv->dytc)
|
|
|
|
return;
|
|
|
|
|
|
|
|
platform_profile_remove();
|
|
|
|
mutex_destroy(&priv->dytc->mutex);
|
|
|
|
kfree(priv->dytc);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-01-05 21:14:43 +08:00
|
|
|
priv->dytc = NULL;
|
|
|
|
}
|
|
|
|
|
2010-12-13 18:00:48 +08:00
|
|
|
/*
|
|
|
|
* Rfkill
|
|
|
|
*/
|
2010-12-13 18:01:12 +08:00
|
|
|
struct ideapad_rfk_data {
|
|
|
|
char *name;
|
|
|
|
int cfgbit;
|
|
|
|
int opcode;
|
|
|
|
int type;
|
|
|
|
};
|
|
|
|
|
2014-08-28 19:02:49 +08:00
|
|
|
static const struct ideapad_rfk_data ideapad_rfk_data[] = {
|
2021-02-04 05:55:59 +08:00
|
|
|
{ "ideapad_wlan", CFG_CAP_WIFI_BIT, VPCCMD_W_WIFI, RFKILL_TYPE_WLAN },
|
|
|
|
{ "ideapad_bluetooth", CFG_CAP_BT_BIT, VPCCMD_W_BT, RFKILL_TYPE_BLUETOOTH },
|
|
|
|
{ "ideapad_3g", CFG_CAP_3G_BIT, VPCCMD_W_3G, RFKILL_TYPE_WWAN },
|
2010-12-13 18:01:12 +08:00
|
|
|
};
|
|
|
|
|
2010-08-11 06:44:05 +08:00
|
|
|
static int ideapad_rfk_set(void *data, bool blocked)
|
|
|
|
{
|
2013-09-25 20:39:49 +08:00
|
|
|
struct ideapad_rfk_priv *priv = data;
|
2015-06-13 21:23:33 +08:00
|
|
|
int opcode = ideapad_rfk_data[priv->dev].opcode;
|
2010-10-01 15:39:59 +08:00
|
|
|
|
2015-06-13 21:23:33 +08:00
|
|
|
return write_ec_cmd(priv->priv->adev->handle, opcode, !blocked);
|
2010-08-11 06:44:05 +08:00
|
|
|
}
|
|
|
|
|
2017-06-09 14:08:18 +08:00
|
|
|
static const struct rfkill_ops ideapad_rfk_ops = {
|
2010-08-11 06:44:05 +08:00
|
|
|
.set_block = ideapad_rfk_set,
|
|
|
|
};
|
|
|
|
|
2011-09-06 02:32:01 +08:00
|
|
|
static void ideapad_sync_rfk_state(struct ideapad_private *priv)
|
2010-08-11 06:44:05 +08:00
|
|
|
{
|
2014-06-23 22:45:51 +08:00
|
|
|
unsigned long hw_blocked = 0;
|
2010-08-11 06:44:05 +08:00
|
|
|
int i;
|
|
|
|
|
2021-02-04 05:56:10 +08:00
|
|
|
if (priv->features.hw_rfkill_switch) {
|
2014-06-23 22:45:51 +08:00
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_RF, &hw_blocked))
|
|
|
|
return;
|
|
|
|
hw_blocked = !hw_blocked;
|
|
|
|
}
|
2010-08-11 06:44:05 +08:00
|
|
|
|
2010-12-13 18:01:12 +08:00
|
|
|
for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
|
2010-08-12 00:59:35 +08:00
|
|
|
if (priv->rfk[i])
|
2010-10-01 15:39:49 +08:00
|
|
|
rfkill_set_hw_state(priv->rfk[i], hw_blocked);
|
2010-08-11 06:44:05 +08:00
|
|
|
}
|
|
|
|
|
2013-09-25 20:39:48 +08:00
|
|
|
static int ideapad_register_rfkill(struct ideapad_private *priv, int dev)
|
2010-08-11 06:44:05 +08:00
|
|
|
{
|
2021-02-04 05:56:56 +08:00
|
|
|
unsigned long rf_enabled;
|
|
|
|
int err;
|
2010-08-11 06:44:05 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
if (no_bt_rfkill && ideapad_rfk_data[dev].type == RFKILL_TYPE_BLUETOOTH) {
|
2010-10-01 15:40:22 +08:00
|
|
|
/* Force to enable bluetooth when no_bt_rfkill=1 */
|
2021-02-04 05:56:56 +08:00
|
|
|
write_ec_cmd(priv->adev->handle, ideapad_rfk_data[dev].opcode, 1);
|
2010-10-01 15:40:22 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2013-09-25 20:39:49 +08:00
|
|
|
priv->rfk_priv[dev].dev = dev;
|
|
|
|
priv->rfk_priv[dev].priv = priv;
|
2010-10-01 15:40:22 +08:00
|
|
|
|
2013-09-25 20:39:48 +08:00
|
|
|
priv->rfk[dev] = rfkill_alloc(ideapad_rfk_data[dev].name,
|
2013-09-25 20:39:50 +08:00
|
|
|
&priv->platform_device->dev,
|
2013-09-25 20:39:48 +08:00
|
|
|
ideapad_rfk_data[dev].type,
|
|
|
|
&ideapad_rfk_ops,
|
2013-09-25 20:39:49 +08:00
|
|
|
&priv->rfk_priv[dev]);
|
2010-08-12 00:59:35 +08:00
|
|
|
if (!priv->rfk[dev])
|
2010-08-11 06:44:05 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = read_ec_data(priv->adev->handle, ideapad_rfk_data[dev].opcode - 1, &rf_enabled);
|
|
|
|
if (err)
|
|
|
|
rf_enabled = 1;
|
|
|
|
|
|
|
|
rfkill_init_sw_state(priv->rfk[dev], !rf_enabled);
|
2010-10-01 15:39:49 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = rfkill_register(priv->rfk[dev]);
|
|
|
|
if (err)
|
2010-08-12 00:59:35 +08:00
|
|
|
rfkill_destroy(priv->rfk[dev]);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
|
|
|
return err;
|
2010-08-11 06:44:05 +08:00
|
|
|
}
|
|
|
|
|
2013-09-25 20:39:48 +08:00
|
|
|
static void ideapad_unregister_rfkill(struct ideapad_private *priv, int dev)
|
2010-08-11 06:44:05 +08:00
|
|
|
{
|
2010-08-12 00:59:35 +08:00
|
|
|
if (!priv->rfk[dev])
|
2010-08-11 06:44:05 +08:00
|
|
|
return;
|
|
|
|
|
2010-08-12 00:59:35 +08:00
|
|
|
rfkill_unregister(priv->rfk[dev]);
|
|
|
|
rfkill_destroy(priv->rfk[dev]);
|
2010-08-11 06:44:05 +08:00
|
|
|
}
|
|
|
|
|
2010-12-13 18:00:15 +08:00
|
|
|
/*
|
|
|
|
* Platform device
|
|
|
|
*/
|
2013-09-25 20:39:50 +08:00
|
|
|
static int ideapad_sysfs_init(struct ideapad_private *priv)
|
2010-12-13 18:00:15 +08:00
|
|
|
{
|
2021-02-04 05:55:05 +08:00
|
|
|
return device_add_group(&priv->platform_device->dev,
|
|
|
|
&ideapad_attribute_group);
|
2010-12-13 18:00:15 +08:00
|
|
|
}
|
|
|
|
|
2013-09-25 20:39:50 +08:00
|
|
|
static void ideapad_sysfs_exit(struct ideapad_private *priv)
|
2010-12-13 18:00:15 +08:00
|
|
|
{
|
2021-02-04 05:55:05 +08:00
|
|
|
device_remove_group(&priv->platform_device->dev,
|
|
|
|
&ideapad_attribute_group);
|
2010-12-13 18:00:15 +08:00
|
|
|
}
|
|
|
|
|
2010-12-13 18:00:38 +08:00
|
|
|
/*
|
|
|
|
* input device
|
|
|
|
*/
|
|
|
|
static const struct key_entry ideapad_keymap[] = {
|
2021-02-04 05:56:56 +08:00
|
|
|
{ KE_KEY, 6, { KEY_SWITCHVIDEOMODE } },
|
|
|
|
{ KE_KEY, 7, { KEY_CAMERA } },
|
|
|
|
{ KE_KEY, 8, { KEY_MICMUTE } },
|
|
|
|
{ KE_KEY, 11, { KEY_F16 } },
|
|
|
|
{ KE_KEY, 13, { KEY_WLAN } },
|
|
|
|
{ KE_KEY, 16, { KEY_PROG1 } },
|
|
|
|
{ KE_KEY, 17, { KEY_PROG2 } },
|
|
|
|
{ KE_KEY, 64, { KEY_PROG3 } },
|
|
|
|
{ KE_KEY, 65, { KEY_PROG4 } },
|
|
|
|
{ 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 05:28:49 +08:00
|
|
|
{ KE_KEY, 128, { KEY_ESC } },
|
2021-02-04 05:56:56 +08:00
|
|
|
{ KE_END },
|
2010-12-13 18:00:38 +08:00
|
|
|
};
|
|
|
|
|
2012-12-22 05:18:33 +08:00
|
|
|
static int ideapad_input_init(struct ideapad_private *priv)
|
2010-12-13 18:00:38 +08:00
|
|
|
{
|
|
|
|
struct input_dev *inputdev;
|
2021-02-04 05:56:56 +08:00
|
|
|
int err;
|
2010-12-13 18:00:38 +08:00
|
|
|
|
|
|
|
inputdev = input_allocate_device();
|
2013-10-24 03:14:52 +08:00
|
|
|
if (!inputdev)
|
2010-12-13 18:00:38 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
inputdev->name = "Ideapad extra buttons";
|
|
|
|
inputdev->phys = "ideapad/input0";
|
|
|
|
inputdev->id.bustype = BUS_HOST;
|
2010-12-13 18:01:01 +08:00
|
|
|
inputdev->dev.parent = &priv->platform_device->dev;
|
2010-12-13 18:00:38 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = sparse_keymap_setup(inputdev, ideapad_keymap, NULL);
|
|
|
|
if (err) {
|
2021-02-04 05:55:32 +08:00
|
|
|
dev_err(&priv->platform_device->dev,
|
2021-02-04 05:56:56 +08:00
|
|
|
"Could not set up input device keymap: %d\n", err);
|
2010-12-13 18:00:38 +08:00
|
|
|
goto err_free_dev;
|
|
|
|
}
|
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = input_register_device(inputdev);
|
|
|
|
if (err) {
|
2021-02-04 05:55:32 +08:00
|
|
|
dev_err(&priv->platform_device->dev,
|
2021-02-04 05:56:56 +08:00
|
|
|
"Could not register input device: %d\n", err);
|
2017-03-09 20:11:44 +08:00
|
|
|
goto err_free_dev;
|
2010-12-13 18:00:38 +08:00
|
|
|
}
|
|
|
|
|
2010-12-13 18:01:01 +08:00
|
|
|
priv->inputdev = inputdev;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2010-12-13 18:00:38 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_free_dev:
|
|
|
|
input_free_device(inputdev);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
|
|
|
return err;
|
2010-12-13 18:00:38 +08:00
|
|
|
}
|
|
|
|
|
2011-07-27 15:27:34 +08:00
|
|
|
static void ideapad_input_exit(struct ideapad_private *priv)
|
2010-12-13 18:00:38 +08:00
|
|
|
{
|
2010-12-13 18:01:01 +08:00
|
|
|
input_unregister_device(priv->inputdev);
|
|
|
|
priv->inputdev = NULL;
|
2010-12-13 18:00:38 +08:00
|
|
|
}
|
|
|
|
|
2010-12-13 18:01:01 +08:00
|
|
|
static void ideapad_input_report(struct ideapad_private *priv,
|
|
|
|
unsigned long scancode)
|
2010-12-13 18:00:38 +08:00
|
|
|
{
|
2010-12-13 18:01:01 +08:00
|
|
|
sparse_keymap_report_event(priv->inputdev, scancode, 1, true);
|
2010-12-13 18:00:38 +08:00
|
|
|
}
|
|
|
|
|
2011-09-06 02:32:10 +08:00
|
|
|
static void ideapad_input_novokey(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
unsigned long long_pressed;
|
|
|
|
|
2013-09-25 20:39:49 +08:00
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_NOVO, &long_pressed))
|
2011-09-06 02:32:10 +08:00
|
|
|
return;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2011-09-06 02:32:10 +08:00
|
|
|
if (long_pressed)
|
|
|
|
ideapad_input_report(priv, 17);
|
|
|
|
else
|
|
|
|
ideapad_input_report(priv, 16);
|
|
|
|
}
|
|
|
|
|
2012-07-06 16:07:50 +08:00
|
|
|
static void ideapad_check_special_buttons(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
unsigned long bit, value;
|
|
|
|
|
2021-02-04 05:55:43 +08:00
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_SPECIAL_BUTTONS, &value))
|
|
|
|
return;
|
2012-07-06 16:07:50 +08:00
|
|
|
|
2021-02-04 05:55:21 +08:00
|
|
|
for_each_set_bit (bit, &value, 16) {
|
|
|
|
switch (bit) {
|
|
|
|
case 6: /* Z570 */
|
2021-02-04 05:56:56 +08:00
|
|
|
case 0: /* Z580 */
|
2021-02-04 05:55:21 +08:00
|
|
|
/* Thermal Management button */
|
|
|
|
ideapad_input_report(priv, 65);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
/* OneKey Theater button */
|
|
|
|
ideapad_input_report(priv, 64);
|
|
|
|
break;
|
|
|
|
default:
|
2021-02-04 05:55:32 +08:00
|
|
|
dev_info(&priv->platform_device->dev,
|
|
|
|
"Unknown special button: %lu\n", bit);
|
2021-02-04 05:55:21 +08:00
|
|
|
break;
|
2012-07-06 16:07:50 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-30 19:50:52 +08:00
|
|
|
/*
|
|
|
|
* backlight
|
|
|
|
*/
|
|
|
|
static int ideapad_backlight_get_brightness(struct backlight_device *blightdev)
|
|
|
|
{
|
2013-09-25 20:39:49 +08:00
|
|
|
struct ideapad_private *priv = bl_get_data(blightdev);
|
2011-06-30 19:50:52 +08:00
|
|
|
unsigned long now;
|
2021-02-04 05:55:43 +08:00
|
|
|
int err;
|
2011-06-30 19:50:52 +08:00
|
|
|
|
2021-02-04 05:55:43 +08:00
|
|
|
err = read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2011-06-30 19:50:52 +08:00
|
|
|
return now;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ideapad_backlight_update_status(struct backlight_device *blightdev)
|
|
|
|
{
|
2013-09-25 20:39:49 +08:00
|
|
|
struct ideapad_private *priv = bl_get_data(blightdev);
|
2021-02-04 05:55:43 +08:00
|
|
|
int err;
|
2013-09-25 20:39:49 +08:00
|
|
|
|
2021-02-04 05:55:43 +08:00
|
|
|
err = write_ec_cmd(priv->adev->handle, VPCCMD_W_BL,
|
|
|
|
blightdev->props.brightness);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:55:43 +08:00
|
|
|
err = write_ec_cmd(priv->adev->handle, VPCCMD_W_BL_POWER,
|
|
|
|
blightdev->props.power != FB_BLANK_POWERDOWN);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2011-06-30 19:50:52 +08:00
|
|
|
|
|
|
|
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;
|
2021-02-04 05:55:43 +08:00
|
|
|
int err;
|
2011-06-30 19:50:52 +08:00
|
|
|
|
2021-02-04 05:55:43 +08:00
|
|
|
err = read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &max);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:55:43 +08:00
|
|
|
err = read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:55:43 +08:00
|
|
|
err = read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2011-06-30 19:50:52 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
memset(&props, 0, sizeof(props));
|
|
|
|
|
2011-06-30 19:50:52 +08:00
|
|
|
props.max_brightness = max;
|
|
|
|
props.type = BACKLIGHT_PLATFORM;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2011-06-30 19:50:52 +08:00
|
|
|
blightdev = backlight_device_register("ideapad",
|
|
|
|
&priv->platform_device->dev,
|
|
|
|
priv,
|
|
|
|
&ideapad_backlight_ops,
|
|
|
|
&props);
|
|
|
|
if (IS_ERR(blightdev)) {
|
2021-02-04 05:56:56 +08:00
|
|
|
err = PTR_ERR(blightdev);
|
2021-02-04 05:55:32 +08:00
|
|
|
dev_err(&priv->platform_device->dev,
|
2021-02-04 05:56:56 +08:00
|
|
|
"Could not register backlight device: %d\n", err);
|
|
|
|
return err;
|
2011-06-30 19:50:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
priv->blightdev = blightdev;
|
|
|
|
blightdev->props.brightness = now;
|
|
|
|
blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2011-06-30 19:50:52 +08:00
|
|
|
backlight_update_status(blightdev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ideapad_backlight_exit(struct ideapad_private *priv)
|
|
|
|
{
|
2014-11-25 03:30:29 +08:00
|
|
|
backlight_device_unregister(priv->blightdev);
|
2011-06-30 19:50:52 +08:00
|
|
|
priv->blightdev = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ideapad_backlight_notify_power(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
struct backlight_device *blightdev = priv->blightdev;
|
2021-02-04 05:56:56 +08:00
|
|
|
unsigned long power;
|
2011-06-30 19:50:52 +08:00
|
|
|
|
2011-10-23 15:56:42 +08:00
|
|
|
if (!blightdev)
|
|
|
|
return;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2013-09-25 20:39:49 +08:00
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power))
|
2011-06-30 19:50:52 +08:00
|
|
|
return;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2011-06-30 19:50:52 +08:00
|
|
|
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 */
|
2021-02-04 05:56:56 +08:00
|
|
|
if (!priv->blightdev)
|
2013-09-25 20:39:49 +08:00
|
|
|
read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now);
|
2021-02-04 05:56:56 +08:00
|
|
|
else
|
|
|
|
backlight_force_update(priv->blightdev, BACKLIGHT_UPDATE_HOTKEY);
|
2011-06-30 19:50:52 +08:00
|
|
|
}
|
|
|
|
|
2021-02-04 05:57:07 +08:00
|
|
|
/*
|
|
|
|
* keyboard backlight
|
|
|
|
*/
|
|
|
|
static int ideapad_kbd_bl_brightness_get(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
unsigned long hals;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = eval_hals(priv->adev->handle, &hals);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
return !!test_bit(HALS_KBD_BL_STATE_BIT, &hals);
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum led_brightness ideapad_kbd_bl_led_cdev_brightness_get(struct led_classdev *led_cdev)
|
|
|
|
{
|
|
|
|
struct ideapad_private *priv = container_of(led_cdev, struct ideapad_private, kbd_bl.led);
|
|
|
|
|
|
|
|
return ideapad_kbd_bl_brightness_get(priv);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ideapad_kbd_bl_brightness_set(struct ideapad_private *priv, unsigned int brightness)
|
|
|
|
{
|
|
|
|
int err = exec_sals(priv->adev->handle, brightness ? SALS_KBD_BL_ON : SALS_KBD_BL_OFF);
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
priv->kbd_bl.last_brightness = brightness;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ideapad_kbd_bl_led_cdev_brightness_set(struct led_classdev *led_cdev,
|
|
|
|
enum led_brightness brightness)
|
|
|
|
{
|
|
|
|
struct ideapad_private *priv = container_of(led_cdev, struct ideapad_private, kbd_bl.led);
|
|
|
|
|
|
|
|
return ideapad_kbd_bl_brightness_set(priv, brightness);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ideapad_kbd_bl_notify(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
int brightness;
|
|
|
|
|
|
|
|
if (!priv->kbd_bl.initialized)
|
|
|
|
return;
|
|
|
|
|
|
|
|
brightness = ideapad_kbd_bl_brightness_get(priv);
|
|
|
|
if (brightness < 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (brightness == priv->kbd_bl.last_brightness)
|
|
|
|
return;
|
|
|
|
|
|
|
|
priv->kbd_bl.last_brightness = brightness;
|
|
|
|
|
|
|
|
led_classdev_notify_brightness_hw_changed(&priv->kbd_bl.led, brightness);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ideapad_kbd_bl_init(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
int brightness, err;
|
|
|
|
|
|
|
|
if (!priv->features.kbd_bl)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (WARN_ON(priv->kbd_bl.initialized))
|
|
|
|
return -EEXIST;
|
|
|
|
|
|
|
|
brightness = ideapad_kbd_bl_brightness_get(priv);
|
|
|
|
if (brightness < 0)
|
|
|
|
return brightness;
|
|
|
|
|
|
|
|
priv->kbd_bl.last_brightness = brightness;
|
|
|
|
|
|
|
|
priv->kbd_bl.led.name = "platform::" LED_FUNCTION_KBD_BACKLIGHT;
|
|
|
|
priv->kbd_bl.led.max_brightness = 1;
|
|
|
|
priv->kbd_bl.led.brightness_get = ideapad_kbd_bl_led_cdev_brightness_get;
|
|
|
|
priv->kbd_bl.led.brightness_set_blocking = ideapad_kbd_bl_led_cdev_brightness_set;
|
|
|
|
priv->kbd_bl.led.flags = LED_BRIGHT_HW_CHANGED;
|
|
|
|
|
|
|
|
err = led_classdev_register(&priv->platform_device->dev, &priv->kbd_bl.led);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
priv->kbd_bl.initialized = true;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ideapad_kbd_bl_exit(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
if (!priv->kbd_bl.initialized)
|
|
|
|
return;
|
|
|
|
|
|
|
|
priv->kbd_bl.initialized = false;
|
|
|
|
|
|
|
|
led_classdev_unregister(&priv->kbd_bl.led);
|
|
|
|
}
|
|
|
|
|
2010-12-13 18:00:48 +08:00
|
|
|
/*
|
|
|
|
* module init/exit
|
|
|
|
*/
|
2013-09-25 20:39:48 +08:00
|
|
|
static void ideapad_sync_touchpad_state(struct ideapad_private *priv)
|
2012-07-06 16:08:00 +08:00
|
|
|
{
|
|
|
|
unsigned long value;
|
|
|
|
|
2021-02-04 05:56:10 +08:00
|
|
|
if (!priv->features.touchpad_ctrl_via_ec)
|
2021-01-07 22:44:38 +08:00
|
|
|
return;
|
|
|
|
|
2012-07-06 16:08:00 +08:00
|
|
|
/* Without reading from EC touchpad LED doesn't switch state */
|
2013-09-25 20:39:48 +08:00
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value)) {
|
2021-02-04 05:56:56 +08:00
|
|
|
unsigned char param;
|
|
|
|
/*
|
|
|
|
* Some IdeaPads don't really turn off touchpad - they only
|
2012-07-06 16:08:00 +08:00
|
|
|
* switch the LED state. We (de)activate KBC AUX port to turn
|
|
|
|
* touchpad off and on. We send KEY_TOUCHPAD_OFF and
|
2021-02-04 05:56:56 +08:00
|
|
|
* KEY_TOUCHPAD_ON to not to get out of sync with LED
|
|
|
|
*/
|
|
|
|
i8042_command(¶m, value ? I8042_CMD_AUX_ENABLE : I8042_CMD_AUX_DISABLE);
|
2012-07-06 16:08:00 +08:00
|
|
|
ideapad_input_report(priv, value ? 67 : 66);
|
2021-02-04 05:57:01 +08:00
|
|
|
sysfs_notify(&priv->platform_device->dev.kobj, NULL, "touchpad");
|
2012-07-06 16:08:00 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-25 20:39:50 +08:00
|
|
|
static void ideapad_acpi_notify(acpi_handle handle, u32 event, void *data)
|
|
|
|
{
|
|
|
|
struct ideapad_private *priv = data;
|
2021-02-04 05:55:21 +08:00
|
|
|
unsigned long vpc1, vpc2, bit;
|
2013-09-25 20:39:50 +08:00
|
|
|
|
|
|
|
if (read_ec_data(handle, VPCCMD_R_VPC1, &vpc1))
|
|
|
|
return;
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2013-09-25 20:39:50 +08:00
|
|
|
if (read_ec_data(handle, VPCCMD_R_VPC2, &vpc2))
|
|
|
|
return;
|
|
|
|
|
|
|
|
vpc1 = (vpc2 << 8) | vpc1;
|
2021-02-04 05:55:21 +08:00
|
|
|
|
|
|
|
for_each_set_bit (bit, &vpc1, 16) {
|
|
|
|
switch (bit) {
|
|
|
|
case 13:
|
|
|
|
case 11:
|
|
|
|
case 8:
|
|
|
|
case 7:
|
|
|
|
case 6:
|
|
|
|
ideapad_input_report(priv, bit);
|
|
|
|
break;
|
2021-02-04 05:56:56 +08:00
|
|
|
case 9:
|
|
|
|
ideapad_sync_rfk_state(priv);
|
|
|
|
break;
|
2021-02-04 05:55:21 +08:00
|
|
|
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 1:
|
2021-02-04 05:56:56 +08:00
|
|
|
/*
|
|
|
|
* Some IdeaPads report event 1 every ~20
|
2021-02-04 05:55:21 +08:00
|
|
|
* seconds while on battery power; some
|
|
|
|
* report this when changing to/from tablet
|
2021-02-04 05:57:07 +08:00
|
|
|
* mode; some report this when the keyboard
|
|
|
|
* backlight has changed.
|
2021-02-04 05:55:21 +08:00
|
|
|
*/
|
2021-02-04 05:57:07 +08:00
|
|
|
ideapad_kbd_bl_notify(priv);
|
2021-02-04 05:55:21 +08:00
|
|
|
break;
|
2021-02-04 05:56:56 +08:00
|
|
|
case 0:
|
|
|
|
ideapad_check_special_buttons(priv);
|
|
|
|
break;
|
2021-02-04 05:55:21 +08:00
|
|
|
default:
|
2021-02-04 05:55:32 +08:00
|
|
|
dev_info(&priv->platform_device->dev,
|
|
|
|
"Unknown event: %lu\n", bit);
|
2013-09-25 20:39:50 +08: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 05:28:49 +08:00
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI)
|
|
|
|
static void ideapad_wmi_notify(u32 value, void *context)
|
|
|
|
{
|
2021-02-04 05:55:32 +08:00
|
|
|
struct ideapad_private *priv = context;
|
|
|
|
|
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 05:28:49 +08:00
|
|
|
switch (value) {
|
|
|
|
case 128:
|
2021-02-04 05:55:32 +08:00
|
|
|
ideapad_input_report(priv, value);
|
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 05:28:49 +08:00
|
|
|
break;
|
|
|
|
default:
|
2021-02-04 05:55:32 +08:00
|
|
|
dev_info(&priv->platform_device->dev,
|
|
|
|
"Unknown WMI event: %u\n", value);
|
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 05:28:49 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-06-23 22:45:51 +08:00
|
|
|
/*
|
platform/x86: ideapad-laptop: Remove no_hw_rfkill_list
When the ideapad-laptop driver was first written it was written for laptops
which had a hardware rfkill switch. So when the first ideapad laptops
showed up without a hw rfkill switch and it turned out that in this case
the ideapad firmware interface would always report the wifi being hardware-
blocked, a DMI id list of models which lack a hw rfkill switch was started
(by yours truly). Things were done this way to avoid regressing existing
models with a hw rfkill switch. In hindsight this was a mistake.
Lenovo releases a lot of ideapad models every year and even the latest
models still use the "VPC2004" ACPI interface the ideapad-laptop driver
binds to. Having a hw rfkill switch is quite rare on modern hardware, so
all these new models need to be added to the no_hw_rfkill_list, leading
to a never ending game of whack a mole.
Worse the failure mode when not present on the list, is very bad. In this
case the ideapad-laptop driver will report the wifi as being hw-blocked,
at which points NetworkManager does not even try to use it and the user
ends up with non working wifi.
This leads to various Linux fora on the internet being filled with
wifi not working on ideapad laptops stories, which does not make Linux
look good.
The failure mode when we flip the default to assuming that a hw rfkill
switch is not present OTOH is quite benign. When we properly report the
wifi as being hw-blocked on ideapads which do have the hw-switch; and it
is in the wifi-off position, then at least when using NetworkManager +
GNOME3 the user will get a "wifi disabled in hardware" message when trying
to connect to the wifi from the UI. If OTOH we assume there is no hardware
rfkill switch, then the user will get an empty list for the list of
available networks. Although the empty list vs the "wifi disabled in
hardware" message is a regression, it is a very minor regression and it
can easily be fixed on a model by model basis by filling the new
hw_rfkill_list this commit introduces.
Therefor this commit removes the ever growing no_hw_rfkill_list, flipping
the default to assuming there is no hw rfkill switch and adding a new
hw_rfkill_list. Thereby fixing the wifi not working on all the current
ideapad and yoga models which are not on the list yet and also fixing it
for all future ideapad and yoga models using the "VPC2004" ACPI interface.
Note once this patch has been accepted upstream. I plan to write a blog
post asking for users of ideapads and yoga's with a hw rfkill switch to
step forward, so that we can populate the new hw_rfkill_list with the few
older yoga and ideapad models which actually have a hw rfkill switch.
BugLink: https://bugzilla.redhat.com/show_bug.cgi?id=1703338
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2019-04-29 22:38:07 +08:00
|
|
|
* Some ideapads have a hardware rfkill switch, but most do not have one.
|
|
|
|
* Reading VPCCMD_R_RF always results in 0 on models without a hardware rfkill,
|
|
|
|
* switch causing ideapad_laptop to wrongly report all radios as hw-blocked.
|
|
|
|
* There used to be a long list of DMI ids for models without a hw rfkill
|
|
|
|
* switch here, but that resulted in playing whack a mole.
|
|
|
|
* More importantly wrongly reporting the wifi radio as hw-blocked, results in
|
|
|
|
* non working wifi. Whereas not reporting it hw-blocked, when it actually is
|
|
|
|
* hw-blocked results in an empty SSID list, which is a much more benign
|
|
|
|
* failure mode.
|
|
|
|
* So the default now is the much safer option of assuming there is no
|
|
|
|
* hardware rfkill switch. This default also actually matches most hardware,
|
|
|
|
* since having a hw rfkill switch is quite rare on modern hardware, so this
|
|
|
|
* also leads to a much shorter list.
|
2014-06-23 22:45:51 +08:00
|
|
|
*/
|
platform/x86: ideapad-laptop: Remove no_hw_rfkill_list
When the ideapad-laptop driver was first written it was written for laptops
which had a hardware rfkill switch. So when the first ideapad laptops
showed up without a hw rfkill switch and it turned out that in this case
the ideapad firmware interface would always report the wifi being hardware-
blocked, a DMI id list of models which lack a hw rfkill switch was started
(by yours truly). Things were done this way to avoid regressing existing
models with a hw rfkill switch. In hindsight this was a mistake.
Lenovo releases a lot of ideapad models every year and even the latest
models still use the "VPC2004" ACPI interface the ideapad-laptop driver
binds to. Having a hw rfkill switch is quite rare on modern hardware, so
all these new models need to be added to the no_hw_rfkill_list, leading
to a never ending game of whack a mole.
Worse the failure mode when not present on the list, is very bad. In this
case the ideapad-laptop driver will report the wifi as being hw-blocked,
at which points NetworkManager does not even try to use it and the user
ends up with non working wifi.
This leads to various Linux fora on the internet being filled with
wifi not working on ideapad laptops stories, which does not make Linux
look good.
The failure mode when we flip the default to assuming that a hw rfkill
switch is not present OTOH is quite benign. When we properly report the
wifi as being hw-blocked on ideapads which do have the hw-switch; and it
is in the wifi-off position, then at least when using NetworkManager +
GNOME3 the user will get a "wifi disabled in hardware" message when trying
to connect to the wifi from the UI. If OTOH we assume there is no hardware
rfkill switch, then the user will get an empty list for the list of
available networks. Although the empty list vs the "wifi disabled in
hardware" message is a regression, it is a very minor regression and it
can easily be fixed on a model by model basis by filling the new
hw_rfkill_list this commit introduces.
Therefor this commit removes the ever growing no_hw_rfkill_list, flipping
the default to assuming there is no hw rfkill switch and adding a new
hw_rfkill_list. Thereby fixing the wifi not working on all the current
ideapad and yoga models which are not on the list yet and also fixing it
for all future ideapad and yoga models using the "VPC2004" ACPI interface.
Note once this patch has been accepted upstream. I plan to write a blog
post asking for users of ideapads and yoga's with a hw rfkill switch to
step forward, so that we can populate the new hw_rfkill_list with the few
older yoga and ideapad models which actually have a hw rfkill switch.
BugLink: https://bugzilla.redhat.com/show_bug.cgi?id=1703338
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2019-04-29 22:38:07 +08:00
|
|
|
static const struct dmi_system_id hw_rfkill_list[] = {
|
2014-05-13 22:00:28 +08:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2021-02-04 05:56:10 +08:00
|
|
|
static void ideapad_check_features(struct ideapad_private *priv)
|
|
|
|
{
|
|
|
|
acpi_handle handle = priv->adev->handle;
|
|
|
|
unsigned long val;
|
|
|
|
|
|
|
|
priv->features.hw_rfkill_switch = dmi_check_system(hw_rfkill_list);
|
|
|
|
|
|
|
|
/* Most ideapads with ELAN0634 touchpad don't use EC touchpad switch */
|
|
|
|
priv->features.touchpad_ctrl_via_ec = !acpi_dev_present("ELAN0634", NULL, -1);
|
|
|
|
|
|
|
|
if (!read_ec_data(handle, VPCCMD_R_FAN, &val))
|
|
|
|
priv->features.fan_mode = true;
|
|
|
|
|
|
|
|
if (acpi_has_method(handle, "GBMD") && acpi_has_method(handle, "SBMC"))
|
|
|
|
priv->features.conservation_mode = true;
|
|
|
|
|
|
|
|
if (acpi_has_method(handle, "DYTC"))
|
|
|
|
priv->features.dytc = true;
|
|
|
|
|
2021-02-04 05:56:16 +08:00
|
|
|
if (acpi_has_method(handle, "HALS") && acpi_has_method(handle, "SALS")) {
|
|
|
|
if (!eval_hals(handle, &val)) {
|
|
|
|
if (test_bit(HALS_FNLOCK_SUPPORT_BIT, &val))
|
|
|
|
priv->features.fn_lock = true;
|
2021-02-04 05:57:07 +08:00
|
|
|
|
|
|
|
if (test_bit(HALS_KBD_BL_SUPPORT_BIT, &val))
|
|
|
|
priv->features.kbd_bl = true;
|
2021-02-04 05:57:13 +08:00
|
|
|
|
|
|
|
if (test_bit(HALS_USB_CHARGING_SUPPORT_BIT, &val))
|
|
|
|
priv->features.usb_charging = true;
|
2021-02-04 05:56:16 +08:00
|
|
|
}
|
|
|
|
}
|
2021-02-04 05:56:10 +08:00
|
|
|
}
|
|
|
|
|
2013-09-25 20:39:50 +08:00
|
|
|
static int ideapad_acpi_add(struct platform_device *pdev)
|
2010-08-11 06:44:05 +08:00
|
|
|
{
|
2010-08-12 00:59:35 +08:00
|
|
|
struct ideapad_private *priv;
|
2013-09-25 20:39:50 +08:00
|
|
|
struct acpi_device *adev;
|
2021-02-04 05:54:30 +08:00
|
|
|
acpi_status status;
|
2021-02-04 05:56:05 +08:00
|
|
|
unsigned long cfg;
|
2021-02-04 05:56:56 +08:00
|
|
|
int err, i;
|
2013-09-25 20:39:50 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = acpi_bus_get_device(ACPI_HANDLE(&pdev->dev), &adev);
|
|
|
|
if (err)
|
2013-09-25 20:39:50 +08:00
|
|
|
return -ENODEV;
|
2010-08-11 06:44:05 +08:00
|
|
|
|
2021-02-04 05:56:05 +08:00
|
|
|
if (eval_int(adev->handle, "_CFG", &cfg))
|
2010-10-01 15:39:14 +08: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 05:46:50 +08:00
|
|
|
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
|
2010-08-12 00:59:35 +08:00
|
|
|
if (!priv)
|
|
|
|
return -ENOMEM;
|
2013-09-25 20:39:50 +08:00
|
|
|
|
|
|
|
dev_set_drvdata(&pdev->dev, priv);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2011-06-30 19:50:40 +08:00
|
|
|
priv->cfg = cfg;
|
2013-09-25 20:39:47 +08:00
|
|
|
priv->adev = adev;
|
2013-09-25 20:39:50 +08:00
|
|
|
priv->platform_device = pdev;
|
2010-12-13 18:00:15 +08:00
|
|
|
|
2021-02-04 05:56:10 +08:00
|
|
|
ideapad_check_features(priv);
|
2021-01-07 22:44:38 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = ideapad_sysfs_init(priv);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2010-08-12 00:59:35 +08:00
|
|
|
|
2019-06-12 20:12:54 +08:00
|
|
|
ideapad_debugfs_init(priv);
|
2011-09-06 02:32:52 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = ideapad_input_init(priv);
|
|
|
|
if (err)
|
2010-12-13 18:00:38 +08:00
|
|
|
goto input_failed;
|
|
|
|
|
2021-02-04 05:57:07 +08:00
|
|
|
err = ideapad_kbd_bl_init(priv);
|
|
|
|
if (err) {
|
|
|
|
if (err != -ENODEV)
|
|
|
|
dev_warn(&pdev->dev, "Could not set up keyboard backlight LED: %d\n", err);
|
|
|
|
else
|
|
|
|
dev_info(&pdev->dev, "Keyboard backlight control not available\n");
|
|
|
|
}
|
|
|
|
|
2014-06-23 22:45:51 +08: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.
|
|
|
|
*/
|
2021-02-04 05:56:10 +08:00
|
|
|
if (!priv->features.hw_rfkill_switch)
|
2014-06-23 22:45:51 +08:00
|
|
|
write_ec_cmd(priv->adev->handle, VPCCMD_W_RF, 1);
|
|
|
|
|
2021-01-07 22:44:38 +08:00
|
|
|
/* The same for Touchpad */
|
2021-02-04 05:56:10 +08:00
|
|
|
if (!priv->features.touchpad_ctrl_via_ec)
|
2021-01-07 22:44:38 +08:00
|
|
|
write_ec_cmd(priv->adev->handle, VPCCMD_W_TOUCHPAD, 1);
|
|
|
|
|
2014-06-23 22:45:51 +08:00
|
|
|
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 02:32:01 +08:00
|
|
|
ideapad_sync_rfk_state(priv);
|
2013-09-25 20:39:48 +08:00
|
|
|
ideapad_sync_touchpad_state(priv);
|
2010-12-13 18:00:27 +08:00
|
|
|
|
2021-02-04 05:56:56 +08:00
|
|
|
err = ideapad_dytc_profile_init(priv);
|
|
|
|
if (err) {
|
|
|
|
if (err != -ENODEV)
|
|
|
|
dev_warn(&pdev->dev, "Could not set up DYTC interface: %d\n", err);
|
2021-02-04 05:56:10 +08:00
|
|
|
else
|
|
|
|
dev_info(&pdev->dev, "DYTC interface is not available\n");
|
|
|
|
}
|
2021-01-05 21:14:43 +08:00
|
|
|
|
2015-06-16 22:28:04 +08:00
|
|
|
if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
|
2021-02-04 05:56:56 +08:00
|
|
|
err = ideapad_backlight_init(priv);
|
|
|
|
if (err && err != -ENODEV)
|
2011-06-30 19:50:52 +08:00
|
|
|
goto backlight_failed;
|
|
|
|
}
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:54:30 +08:00
|
|
|
status = acpi_install_notify_handler(adev->handle,
|
|
|
|
ACPI_DEVICE_NOTIFY,
|
|
|
|
ideapad_acpi_notify, priv);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2021-02-04 05:56:56 +08:00
|
|
|
err = -EIO;
|
2013-09-25 20:39:50 +08:00
|
|
|
goto notification_failed;
|
2021-02-04 05:54:30 +08:00
|
|
|
}
|
2016-05-10 05:49:21 +08: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 05:28:49 +08:00
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI)
|
2016-05-10 05:49:21 +08:00
|
|
|
for (i = 0; i < ARRAY_SIZE(ideapad_wmi_fnesc_events); i++) {
|
2021-02-04 05:54:30 +08:00
|
|
|
status = wmi_install_notify_handler(ideapad_wmi_fnesc_events[i],
|
|
|
|
ideapad_wmi_notify, priv);
|
|
|
|
if (ACPI_SUCCESS(status)) {
|
2016-05-10 05:49:21 +08:00
|
|
|
priv->fnesc_guid = ideapad_wmi_fnesc_events[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:54:30 +08:00
|
|
|
if (ACPI_FAILURE(status) && status != AE_NOT_EXIST) {
|
2021-02-04 05:56:56 +08:00
|
|
|
err = -EIO;
|
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 05:28:49 +08:00
|
|
|
goto notification_failed_wmi;
|
2021-02-04 05:54:30 +08: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 05:28:49 +08:00
|
|
|
#endif
|
2011-06-30 19:50:52 +08:00
|
|
|
|
2010-08-11 06:44:05 +08:00
|
|
|
return 0;
|
2021-02-04 05:56:56 +08: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 05:28:49 +08:00
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI)
|
|
|
|
notification_failed_wmi:
|
|
|
|
acpi_remove_notify_handler(priv->adev->handle,
|
2021-02-04 05:56:56 +08:00
|
|
|
ACPI_DEVICE_NOTIFY,
|
|
|
|
ideapad_acpi_notify);
|
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 05:28:49 +08:00
|
|
|
#endif
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2013-09-25 20:39:50 +08:00
|
|
|
notification_failed:
|
|
|
|
ideapad_backlight_exit(priv);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2011-06-30 19:50:52 +08:00
|
|
|
backlight_failed:
|
2021-02-04 05:54:43 +08:00
|
|
|
ideapad_dytc_profile_exit(priv);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2011-06-30 19:50:52 +08:00
|
|
|
for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
|
2013-09-25 20:39:48 +08:00
|
|
|
ideapad_unregister_rfkill(priv, i);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:57:07 +08:00
|
|
|
ideapad_kbd_bl_exit(priv);
|
2011-07-27 15:27:34 +08:00
|
|
|
ideapad_input_exit(priv);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2010-12-13 18:00:38 +08:00
|
|
|
input_failed:
|
2011-09-06 02:32:52 +08:00
|
|
|
ideapad_debugfs_exit(priv);
|
2013-09-25 20:39:50 +08:00
|
|
|
ideapad_sysfs_exit(priv);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
|
|
|
return err;
|
2010-08-11 06:44:05 +08:00
|
|
|
}
|
|
|
|
|
2013-09-25 20:39:50 +08:00
|
|
|
static int ideapad_acpi_remove(struct platform_device *pdev)
|
2010-08-11 06:44:05 +08:00
|
|
|
{
|
2013-09-25 20:39:50 +08:00
|
|
|
struct ideapad_private *priv = dev_get_drvdata(&pdev->dev);
|
2010-08-11 06:44:05 +08:00
|
|
|
int i;
|
2010-08-12 00:59:35 +08: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 05:28:49 +08:00
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI)
|
2016-05-10 05:49:21 +08: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 05:28:49 +08:00
|
|
|
#endif
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2013-09-25 20:39:50 +08:00
|
|
|
acpi_remove_notify_handler(priv->adev->handle,
|
2021-02-04 05:56:56 +08:00
|
|
|
ACPI_DEVICE_NOTIFY,
|
|
|
|
ideapad_acpi_notify);
|
|
|
|
|
2011-06-30 19:50:52 +08:00
|
|
|
ideapad_backlight_exit(priv);
|
2021-01-05 21:14:43 +08:00
|
|
|
ideapad_dytc_profile_exit(priv);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2010-12-13 18:01:12 +08:00
|
|
|
for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
|
2013-09-25 20:39:48 +08:00
|
|
|
ideapad_unregister_rfkill(priv, i);
|
2021-02-04 05:56:56 +08:00
|
|
|
|
2021-02-04 05:57:07 +08:00
|
|
|
ideapad_kbd_bl_exit(priv);
|
2010-12-13 18:01:01 +08:00
|
|
|
ideapad_input_exit(priv);
|
2011-09-06 02:32:52 +08:00
|
|
|
ideapad_debugfs_exit(priv);
|
2013-09-25 20:39:50 +08:00
|
|
|
ideapad_sysfs_exit(priv);
|
2010-12-13 18:00:27 +08:00
|
|
|
|
2010-08-11 06:44:05 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-09-25 20:39:46 +08:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2021-02-04 05:54:23 +08:00
|
|
|
static int ideapad_acpi_resume(struct device *dev)
|
2012-07-06 16:08:00 +08:00
|
|
|
{
|
2021-02-04 05:54:23 +08:00
|
|
|
struct ideapad_private *priv = dev_get_drvdata(dev);
|
2013-09-25 20:39:48 +08:00
|
|
|
|
|
|
|
ideapad_sync_rfk_state(priv);
|
|
|
|
ideapad_sync_touchpad_state(priv);
|
2021-01-05 21:14:43 +08:00
|
|
|
|
|
|
|
if (priv->dytc)
|
|
|
|
dytc_profile_refresh(priv);
|
|
|
|
|
2012-07-06 16:08:00 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2013-09-25 20:39:46 +08:00
|
|
|
#endif
|
2013-09-25 20:39:50 +08:00
|
|
|
static SIMPLE_DEV_PM_OPS(ideapad_pm, NULL, ideapad_acpi_resume);
|
2012-07-06 16:08:00 +08:00
|
|
|
|
2013-09-25 20:39:50 +08:00
|
|
|
static const struct acpi_device_id ideapad_device_ids[] = {
|
2021-02-04 05:56:56 +08:00
|
|
|
{"VPC2004", 0},
|
|
|
|
{"", 0},
|
2010-08-11 06:44:05 +08:00
|
|
|
};
|
2013-09-25 20:39:50 +08: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 06:44:05 +08:00
|
|
|
|
|
|
|
MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
|
|
|
|
MODULE_DESCRIPTION("IdeaPad ACPI Extras");
|
|
|
|
MODULE_LICENSE("GPL");
|