mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1728 lines
41 KiB
1728 lines
41 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* ideapad-laptop.c - Lenovo IdeaPad ACPI Extras |
|
* |
|
* Copyright © 2010 Intel Corporation |
|
* Copyright © 2010 David Woodhouse <[email protected]> |
|
*/ |
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
|
|
|
#include <linux/acpi.h> |
|
#include <linux/backlight.h> |
|
#include <linux/bitops.h> |
|
#include <linux/bug.h> |
|
#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> |
|
#include <linux/jiffies.h> |
|
#include <linux/kernel.h> |
|
#include <linux/leds.h> |
|
#include <linux/module.h> |
|
#include <linux/platform_device.h> |
|
#include <linux/platform_profile.h> |
|
#include <linux/rfkill.h> |
|
#include <linux/seq_file.h> |
|
#include <linux/sysfs.h> |
|
#include <linux/types.h> |
|
|
|
#include <acpi/video.h> |
|
|
|
#include <dt-bindings/leds/common.h> |
|
|
|
#define IDEAPAD_RFKILL_DEV_NUM 3 |
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI) |
|
static const char *const ideapad_wmi_fnesc_events[] = { |
|
"26CAB2E5-5CF1-46AE-AAC3-4A12B6BA50E6", /* Yoga 3 */ |
|
"56322276-8493-4CE8-A783-98C991274F5E", /* Yoga 700 */ |
|
"8FC0DE0C-B4E4-43FD-B0F3-8871711C1294", /* Legion 5 */ |
|
}; |
|
#endif |
|
|
|
enum { |
|
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, |
|
}; |
|
|
|
enum { |
|
GBMD_CONSERVATION_STATE_BIT = 5, |
|
}; |
|
|
|
enum { |
|
SBMC_CONSERVATION_ON = 3, |
|
SBMC_CONSERVATION_OFF = 5, |
|
}; |
|
|
|
enum { |
|
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, |
|
}; |
|
|
|
enum { |
|
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, |
|
}; |
|
|
|
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 */ |
|
VPCCMD_W_FAN, |
|
VPCCMD_R_RF, |
|
VPCCMD_W_RF, |
|
VPCCMD_R_FAN = 0x2B, |
|
VPCCMD_R_SPECIAL_BUTTONS = 0x31, |
|
VPCCMD_W_BL_POWER = 0x33, |
|
}; |
|
|
|
struct ideapad_dytc_priv { |
|
enum platform_profile_option current_profile; |
|
struct platform_profile_handler pprof; |
|
struct mutex mutex; /* protects the DYTC interface */ |
|
struct ideapad_private *priv; |
|
}; |
|
|
|
struct ideapad_rfk_priv { |
|
int dev; |
|
struct ideapad_private *priv; |
|
}; |
|
|
|
struct ideapad_private { |
|
struct acpi_device *adev; |
|
struct rfkill *rfk[IDEAPAD_RFKILL_DEV_NUM]; |
|
struct ideapad_rfk_priv rfk_priv[IDEAPAD_RFKILL_DEV_NUM]; |
|
struct platform_device *platform_device; |
|
struct input_dev *inputdev; |
|
struct backlight_device *blightdev; |
|
struct ideapad_dytc_priv *dytc; |
|
struct dentry *debug; |
|
unsigned long cfg; |
|
const char *fnesc_guid; |
|
struct { |
|
bool conservation_mode : 1; |
|
bool dytc : 1; |
|
bool fan_mode : 1; |
|
bool fn_lock : 1; |
|
bool hw_rfkill_switch : 1; |
|
bool kbd_bl : 1; |
|
bool touchpad_ctrl_via_ec : 1; |
|
bool usb_charging : 1; |
|
} features; |
|
struct { |
|
bool initialized; |
|
struct led_classdev led; |
|
unsigned int last_brightness; |
|
} kbd_bl; |
|
}; |
|
|
|
static bool no_bt_rfkill; |
|
module_param(no_bt_rfkill, bool, 0444); |
|
MODULE_PARM_DESC(no_bt_rfkill, "No rfkill for bluetooth."); |
|
|
|
/* |
|
* ACPI Helpers |
|
*/ |
|
#define IDEAPAD_EC_TIMEOUT 200 /* in ms */ |
|
|
|
static int eval_int(acpi_handle handle, const char *name, unsigned long *res) |
|
{ |
|
unsigned long long result; |
|
acpi_status status; |
|
|
|
status = acpi_evaluate_integer(handle, (char *)name, NULL, &result); |
|
if (ACPI_FAILURE(status)) |
|
return -EIO; |
|
|
|
*res = result; |
|
|
|
return 0; |
|
} |
|
|
|
static int exec_simple_method(acpi_handle handle, const char *name, unsigned long arg) |
|
{ |
|
acpi_status status = acpi_execute_simple_method(handle, (char *)name, arg); |
|
|
|
return ACPI_FAILURE(status) ? -EIO : 0; |
|
} |
|
|
|
static int eval_gbmd(acpi_handle handle, unsigned long *res) |
|
{ |
|
return eval_int(handle, "GBMD", res); |
|
} |
|
|
|
static int exec_sbmc(acpi_handle handle, unsigned long arg) |
|
{ |
|
return exec_simple_method(handle, "SBMC", arg); |
|
} |
|
|
|
static int eval_hals(acpi_handle handle, unsigned long *res) |
|
{ |
|
return eval_int(handle, "HALS", res); |
|
} |
|
|
|
static int exec_sals(acpi_handle handle, unsigned long arg) |
|
{ |
|
return exec_simple_method(handle, "SALS", arg); |
|
} |
|
|
|
static int eval_int_with_arg(acpi_handle handle, const char *name, unsigned long arg, unsigned long *res) |
|
{ |
|
struct acpi_object_list params; |
|
unsigned long long result; |
|
union acpi_object in_obj; |
|
acpi_status status; |
|
|
|
params.count = 1; |
|
params.pointer = &in_obj; |
|
in_obj.type = ACPI_TYPE_INTEGER; |
|
in_obj.integer.value = arg; |
|
|
|
status = acpi_evaluate_integer(handle, (char *)name, ¶ms, &result); |
|
if (ACPI_FAILURE(status)) |
|
return -EIO; |
|
|
|
if (res) |
|
*res = result; |
|
|
|
return 0; |
|
} |
|
|
|
static int eval_dytc(acpi_handle handle, unsigned long cmd, unsigned long *res) |
|
{ |
|
return eval_int_with_arg(handle, "DYTC", cmd, res); |
|
} |
|
|
|
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) |
|
{ |
|
struct acpi_object_list params; |
|
union acpi_object in_obj[2]; |
|
acpi_status status; |
|
|
|
params.count = 2; |
|
params.pointer = in_obj; |
|
in_obj[0].type = ACPI_TYPE_INTEGER; |
|
in_obj[0].integer.value = cmd; |
|
in_obj[1].type = ACPI_TYPE_INTEGER; |
|
in_obj[1].integer.value = data; |
|
|
|
status = acpi_evaluate_object(handle, "VPCW", ¶ms, NULL); |
|
if (ACPI_FAILURE(status)) |
|
return -EIO; |
|
|
|
return 0; |
|
} |
|
|
|
static int read_ec_data(acpi_handle handle, unsigned long cmd, unsigned long *data) |
|
{ |
|
unsigned long end_jiffies, val; |
|
int err; |
|
|
|
err = eval_vpcw(handle, 1, cmd); |
|
if (err) |
|
return err; |
|
|
|
end_jiffies = jiffies + msecs_to_jiffies(IDEAPAD_EC_TIMEOUT) + 1; |
|
|
|
while (time_before(jiffies, end_jiffies)) { |
|
schedule(); |
|
|
|
err = eval_vpcr(handle, 1, &val); |
|
if (err) |
|
return err; |
|
|
|
if (val == 0) |
|
return eval_vpcr(handle, 0, data); |
|
} |
|
|
|
acpi_handle_err(handle, "timeout in %s\n", __func__); |
|
|
|
return -ETIMEDOUT; |
|
} |
|
|
|
static int write_ec_cmd(acpi_handle handle, unsigned long cmd, unsigned long data) |
|
{ |
|
unsigned long end_jiffies, val; |
|
int err; |
|
|
|
err = eval_vpcw(handle, 0, data); |
|
if (err) |
|
return err; |
|
|
|
err = eval_vpcw(handle, 1, cmd); |
|
if (err) |
|
return err; |
|
|
|
end_jiffies = jiffies + msecs_to_jiffies(IDEAPAD_EC_TIMEOUT) + 1; |
|
|
|
while (time_before(jiffies, end_jiffies)) { |
|
schedule(); |
|
|
|
err = eval_vpcr(handle, 1, &val); |
|
if (err) |
|
return err; |
|
|
|
if (val == 0) |
|
return 0; |
|
} |
|
|
|
acpi_handle_err(handle, "timeout in %s\n", __func__); |
|
|
|
return -ETIMEDOUT; |
|
} |
|
|
|
/* |
|
* debugfs |
|
*/ |
|
static int debugfs_status_show(struct seq_file *s, void *data) |
|
{ |
|
struct ideapad_private *priv = s->private; |
|
unsigned long value; |
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &value)) |
|
seq_printf(s, "Backlight max: %lu\n", value); |
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL, &value)) |
|
seq_printf(s, "Backlight now: %lu\n", value); |
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &value)) |
|
seq_printf(s, "BL power value: %s (%lu)\n", value ? "on" : "off", value); |
|
|
|
seq_puts(s, "=====================\n"); |
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_RF, &value)) |
|
seq_printf(s, "Radio status: %s (%lu)\n", value ? "on" : "off", value); |
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_WIFI, &value)) |
|
seq_printf(s, "Wifi status: %s (%lu)\n", value ? "on" : "off", value); |
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_BT, &value)) |
|
seq_printf(s, "BT status: %s (%lu)\n", value ? "on" : "off", value); |
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_3G, &value)) |
|
seq_printf(s, "3G status: %s (%lu)\n", value ? "on" : "off", value); |
|
|
|
seq_puts(s, "=====================\n"); |
|
|
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value)) |
|
seq_printf(s, "Touchpad status: %s (%lu)\n", value ? "on" : "off", value); |
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &value)) |
|
seq_printf(s, "Camera status: %s (%lu)\n", value ? "on" : "off", value); |
|
|
|
seq_puts(s, "=====================\n"); |
|
|
|
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); |
|
|
|
return 0; |
|
} |
|
DEFINE_SHOW_ATTRIBUTE(debugfs_status); |
|
|
|
static int debugfs_cfg_show(struct seq_file *s, void *data) |
|
{ |
|
struct ideapad_private *priv = s->private; |
|
|
|
seq_printf(s, "_CFG: %#010lx\n\n", priv->cfg); |
|
|
|
seq_puts(s, "Capabilities:"); |
|
if (test_bit(CFG_CAP_BT_BIT, &priv->cfg)) |
|
seq_puts(s, " bluetooth"); |
|
if (test_bit(CFG_CAP_3G_BIT, &priv->cfg)) |
|
seq_puts(s, " 3G"); |
|
if (test_bit(CFG_CAP_WIFI_BIT, &priv->cfg)) |
|
seq_puts(s, " wifi"); |
|
if (test_bit(CFG_CAP_CAM_BIT, &priv->cfg)) |
|
seq_puts(s, " camera"); |
|
if (test_bit(CFG_CAP_TOUCHPAD_BIT, &priv->cfg)) |
|
seq_puts(s, " touchpad"); |
|
seq_puts(s, "\n"); |
|
|
|
seq_puts(s, "Graphics: "); |
|
switch (priv->cfg & 0x700) { |
|
case 0x100: |
|
seq_puts(s, "Intel"); |
|
break; |
|
case 0x200: |
|
seq_puts(s, "ATI"); |
|
break; |
|
case 0x300: |
|
seq_puts(s, "Nvidia"); |
|
break; |
|
case 0x400: |
|
seq_puts(s, "Intel and ATI"); |
|
break; |
|
case 0x500: |
|
seq_puts(s, "Intel and Nvidia"); |
|
break; |
|
} |
|
seq_puts(s, "\n"); |
|
|
|
return 0; |
|
} |
|
DEFINE_SHOW_ATTRIBUTE(debugfs_cfg); |
|
|
|
static void ideapad_debugfs_init(struct ideapad_private *priv) |
|
{ |
|
struct dentry *dir; |
|
|
|
dir = debugfs_create_dir("ideapad", NULL); |
|
priv->debug = dir; |
|
|
|
debugfs_create_file("cfg", 0444, dir, priv, &debugfs_cfg_fops); |
|
debugfs_create_file("status", 0444, dir, priv, &debugfs_status_fops); |
|
} |
|
|
|
static void ideapad_debugfs_exit(struct ideapad_private *priv) |
|
{ |
|
debugfs_remove_recursive(priv->debug); |
|
priv->debug = NULL; |
|
} |
|
|
|
/* |
|
* sysfs |
|
*/ |
|
static ssize_t camera_power_show(struct device *dev, |
|
struct device_attribute *attr, |
|
char *buf) |
|
{ |
|
struct ideapad_private *priv = dev_get_drvdata(dev); |
|
unsigned long result; |
|
int err; |
|
|
|
err = read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &result); |
|
if (err) |
|
return err; |
|
|
|
return sysfs_emit(buf, "%d\n", !!result); |
|
} |
|
|
|
static ssize_t camera_power_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 = write_ec_cmd(priv->adev->handle, VPCCMD_W_CAMERA, state); |
|
if (err) |
|
return err; |
|
|
|
return count; |
|
} |
|
|
|
static DEVICE_ATTR_RW(camera_power); |
|
|
|
static ssize_t conservation_mode_show(struct device *dev, |
|
struct device_attribute *attr, |
|
char *buf) |
|
{ |
|
struct ideapad_private *priv = dev_get_drvdata(dev); |
|
unsigned long result; |
|
int err; |
|
|
|
err = eval_gbmd(priv->adev->handle, &result); |
|
if (err) |
|
return err; |
|
|
|
return sysfs_emit(buf, "%d\n", !!test_bit(GBMD_CONSERVATION_STATE_BIT, &result)); |
|
} |
|
|
|
static ssize_t conservation_mode_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_sbmc(priv->adev->handle, state ? SBMC_CONSERVATION_ON : SBMC_CONSERVATION_OFF); |
|
if (err) |
|
return err; |
|
|
|
return count; |
|
} |
|
|
|
static DEVICE_ATTR_RW(conservation_mode); |
|
|
|
static ssize_t fan_mode_show(struct device *dev, |
|
struct device_attribute *attr, |
|
char *buf) |
|
{ |
|
struct ideapad_private *priv = dev_get_drvdata(dev); |
|
unsigned long result; |
|
int err; |
|
|
|
err = read_ec_data(priv->adev->handle, VPCCMD_R_FAN, &result); |
|
if (err) |
|
return err; |
|
|
|
return sysfs_emit(buf, "%lu\n", result); |
|
} |
|
|
|
static ssize_t fan_mode_store(struct device *dev, |
|
struct device_attribute *attr, |
|
const char *buf, size_t count) |
|
{ |
|
struct ideapad_private *priv = dev_get_drvdata(dev); |
|
unsigned int state; |
|
int err; |
|
|
|
err = kstrtouint(buf, 0, &state); |
|
if (err) |
|
return err; |
|
|
|
if (state > 4 || state == 3) |
|
return -EINVAL; |
|
|
|
err = write_ec_cmd(priv->adev->handle, VPCCMD_W_FAN, state); |
|
if (err) |
|
return err; |
|
|
|
return count; |
|
} |
|
|
|
static DEVICE_ATTR_RW(fan_mode); |
|
|
|
static ssize_t fn_lock_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_FNLOCK_STATE_BIT, &hals)); |
|
} |
|
|
|
static ssize_t fn_lock_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_FNLOCK_ON : SALS_FNLOCK_OFF); |
|
if (err) |
|
return err; |
|
|
|
return count; |
|
} |
|
|
|
static DEVICE_ATTR_RW(fn_lock); |
|
|
|
static ssize_t touchpad_show(struct device *dev, |
|
struct device_attribute *attr, |
|
char *buf) |
|
{ |
|
struct ideapad_private *priv = dev_get_drvdata(dev); |
|
unsigned long result; |
|
int err; |
|
|
|
err = read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &result); |
|
if (err) |
|
return err; |
|
|
|
return sysfs_emit(buf, "%d\n", !!result); |
|
} |
|
|
|
static ssize_t touchpad_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 = write_ec_cmd(priv->adev->handle, VPCCMD_W_TOUCHPAD, state); |
|
if (err) |
|
return err; |
|
|
|
return count; |
|
} |
|
|
|
static DEVICE_ATTR_RW(touchpad); |
|
|
|
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); |
|
|
|
static struct attribute *ideapad_attributes[] = { |
|
&dev_attr_camera_power.attr, |
|
&dev_attr_conservation_mode.attr, |
|
&dev_attr_fan_mode.attr, |
|
&dev_attr_fn_lock.attr, |
|
&dev_attr_touchpad.attr, |
|
&dev_attr_usb_charging.attr, |
|
NULL |
|
}; |
|
|
|
static umode_t ideapad_is_visible(struct kobject *kobj, |
|
struct attribute *attr, |
|
int idx) |
|
{ |
|
struct device *dev = kobj_to_dev(kobj); |
|
struct ideapad_private *priv = dev_get_drvdata(dev); |
|
bool supported = true; |
|
|
|
if (attr == &dev_attr_camera_power.attr) |
|
supported = test_bit(CFG_CAP_CAM_BIT, &priv->cfg); |
|
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) |
|
supported = priv->features.touchpad_ctrl_via_ec && |
|
test_bit(CFG_CAP_TOUCHPAD_BIT, &priv->cfg); |
|
else if (attr == &dev_attr_usb_charging.attr) |
|
supported = priv->features.usb_charging; |
|
|
|
return supported ? attr->mode : 0; |
|
} |
|
|
|
static const struct attribute_group ideapad_attribute_group = { |
|
.is_visible = ideapad_is_visible, |
|
.attrs = ideapad_attributes |
|
}; |
|
|
|
/* |
|
* 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; |
|
} |
|
|
|
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; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
/* |
|
* dytc_profile_get: Function to register with platform_profile |
|
* handler. Returns current platform profile. |
|
*/ |
|
static int dytc_profile_get(struct platform_profile_handler *pprof, |
|
enum platform_profile_option *profile) |
|
{ |
|
struct ideapad_dytc_priv *dytc = container_of(pprof, struct ideapad_dytc_priv, pprof); |
|
|
|
*profile = dytc->current_profile; |
|
return 0; |
|
} |
|
|
|
/* |
|
* Helper function - check if we are in CQL mode and if we are |
|
* - disable CQL, |
|
* - run the command |
|
* - enable CQL |
|
* If not in CQL mode, just run the command |
|
*/ |
|
static int dytc_cql_command(struct ideapad_private *priv, unsigned long cmd, |
|
unsigned long *output) |
|
{ |
|
int err, cmd_err, cur_funcmode; |
|
|
|
/* Determine if we are in CQL mode. This alters the commands we do */ |
|
err = eval_dytc(priv->adev->handle, DYTC_CMD_GET, output); |
|
if (err) |
|
return err; |
|
|
|
cur_funcmode = (*output >> DYTC_GET_FUNCTION_BIT) & 0xF; |
|
/* Check if we're OK to return immediately */ |
|
if (cmd == DYTC_CMD_GET && cur_funcmode != DYTC_FUNCTION_CQL) |
|
return 0; |
|
|
|
if (cur_funcmode == DYTC_FUNCTION_CQL) { |
|
err = eval_dytc(priv->adev->handle, DYTC_DISABLE_CQL, NULL); |
|
if (err) |
|
return err; |
|
} |
|
|
|
cmd_err = eval_dytc(priv->adev->handle, cmd, output); |
|
/* Check return condition after we've restored CQL state */ |
|
|
|
if (cur_funcmode == DYTC_FUNCTION_CQL) { |
|
err = eval_dytc(priv->adev->handle, DYTC_ENABLE_CQL, NULL); |
|
if (err) |
|
return err; |
|
} |
|
|
|
return cmd_err; |
|
} |
|
|
|
/* |
|
* dytc_profile_set: Function to register with platform_profile |
|
* handler. Sets current platform profile. |
|
*/ |
|
static int dytc_profile_set(struct platform_profile_handler *pprof, |
|
enum platform_profile_option profile) |
|
{ |
|
struct ideapad_dytc_priv *dytc = container_of(pprof, struct ideapad_dytc_priv, pprof); |
|
struct ideapad_private *priv = dytc->priv; |
|
unsigned long output; |
|
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 */ |
|
err = eval_dytc(priv->adev->handle, DYTC_CMD_RESET, NULL); |
|
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 */ |
|
err = dytc_cql_command(priv, DYTC_SET_COMMAND(DYTC_FUNCTION_MMC, perfmode, 1), |
|
&output); |
|
if (err) |
|
goto unlock; |
|
} |
|
|
|
/* Success - update current profile */ |
|
dytc->current_profile = profile; |
|
|
|
unlock: |
|
mutex_unlock(&dytc->mutex); |
|
|
|
return err; |
|
} |
|
|
|
static void dytc_profile_refresh(struct ideapad_private *priv) |
|
{ |
|
enum platform_profile_option profile; |
|
unsigned long output; |
|
int err, perfmode; |
|
|
|
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; |
|
|
|
if (convert_dytc_to_profile(perfmode, &profile)) |
|
return; |
|
|
|
if (profile != priv->dytc->current_profile) { |
|
priv->dytc->current_profile = profile; |
|
platform_profile_notify(); |
|
} |
|
} |
|
|
|
static int ideapad_dytc_profile_init(struct ideapad_private *priv) |
|
{ |
|
int err, dytc_version; |
|
unsigned long output; |
|
|
|
if (!priv->features.dytc) |
|
return -ENODEV; |
|
|
|
err = eval_dytc(priv->adev->handle, DYTC_CMD_QUERY, &output); |
|
/* For all other errors we can flag the failure */ |
|
if (err) |
|
return err; |
|
|
|
/* Check DYTC is enabled and supports mode setting */ |
|
if (!test_bit(DYTC_QUERY_ENABLE_BIT, &output)) |
|
return -ENODEV; |
|
|
|
dytc_version = (output >> DYTC_QUERY_REV_BIT) & 0xF; |
|
if (dytc_version < 5) |
|
return -ENODEV; |
|
|
|
priv->dytc = kzalloc(sizeof(*priv->dytc), GFP_KERNEL); |
|
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) |
|
goto pp_reg_failed; |
|
|
|
/* Ensure initial values are correct */ |
|
dytc_profile_refresh(priv); |
|
|
|
return 0; |
|
|
|
pp_reg_failed: |
|
mutex_destroy(&priv->dytc->mutex); |
|
kfree(priv->dytc); |
|
priv->dytc = NULL; |
|
|
|
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); |
|
|
|
priv->dytc = NULL; |
|
} |
|
|
|
/* |
|
* Rfkill |
|
*/ |
|
struct ideapad_rfk_data { |
|
char *name; |
|
int cfgbit; |
|
int opcode; |
|
int type; |
|
}; |
|
|
|
static const struct ideapad_rfk_data ideapad_rfk_data[] = { |
|
{ "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 }, |
|
}; |
|
|
|
static int ideapad_rfk_set(void *data, bool blocked) |
|
{ |
|
struct ideapad_rfk_priv *priv = data; |
|
int opcode = ideapad_rfk_data[priv->dev].opcode; |
|
|
|
return write_ec_cmd(priv->priv->adev->handle, opcode, !blocked); |
|
} |
|
|
|
static const struct rfkill_ops ideapad_rfk_ops = { |
|
.set_block = ideapad_rfk_set, |
|
}; |
|
|
|
static void ideapad_sync_rfk_state(struct ideapad_private *priv) |
|
{ |
|
unsigned long hw_blocked = 0; |
|
int i; |
|
|
|
if (priv->features.hw_rfkill_switch) { |
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_RF, &hw_blocked)) |
|
return; |
|
hw_blocked = !hw_blocked; |
|
} |
|
|
|
for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++) |
|
if (priv->rfk[i]) |
|
rfkill_set_hw_state(priv->rfk[i], hw_blocked); |
|
} |
|
|
|
static int ideapad_register_rfkill(struct ideapad_private *priv, int dev) |
|
{ |
|
unsigned long rf_enabled; |
|
int err; |
|
|
|
if (no_bt_rfkill && ideapad_rfk_data[dev].type == RFKILL_TYPE_BLUETOOTH) { |
|
/* Force to enable bluetooth when no_bt_rfkill=1 */ |
|
write_ec_cmd(priv->adev->handle, ideapad_rfk_data[dev].opcode, 1); |
|
return 0; |
|
} |
|
|
|
priv->rfk_priv[dev].dev = dev; |
|
priv->rfk_priv[dev].priv = priv; |
|
|
|
priv->rfk[dev] = rfkill_alloc(ideapad_rfk_data[dev].name, |
|
&priv->platform_device->dev, |
|
ideapad_rfk_data[dev].type, |
|
&ideapad_rfk_ops, |
|
&priv->rfk_priv[dev]); |
|
if (!priv->rfk[dev]) |
|
return -ENOMEM; |
|
|
|
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); |
|
|
|
err = rfkill_register(priv->rfk[dev]); |
|
if (err) |
|
rfkill_destroy(priv->rfk[dev]); |
|
|
|
return err; |
|
} |
|
|
|
static void ideapad_unregister_rfkill(struct ideapad_private *priv, int dev) |
|
{ |
|
if (!priv->rfk[dev]) |
|
return; |
|
|
|
rfkill_unregister(priv->rfk[dev]); |
|
rfkill_destroy(priv->rfk[dev]); |
|
} |
|
|
|
/* |
|
* Platform device |
|
*/ |
|
static int ideapad_sysfs_init(struct ideapad_private *priv) |
|
{ |
|
return device_add_group(&priv->platform_device->dev, |
|
&ideapad_attribute_group); |
|
} |
|
|
|
static void ideapad_sysfs_exit(struct ideapad_private *priv) |
|
{ |
|
device_remove_group(&priv->platform_device->dev, |
|
&ideapad_attribute_group); |
|
} |
|
|
|
/* |
|
* input device |
|
*/ |
|
static const struct key_entry ideapad_keymap[] = { |
|
{ 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 } }, |
|
{ KE_KEY, 128, { KEY_ESC } }, |
|
{ KE_END }, |
|
}; |
|
|
|
static int ideapad_input_init(struct ideapad_private *priv) |
|
{ |
|
struct input_dev *inputdev; |
|
int err; |
|
|
|
inputdev = input_allocate_device(); |
|
if (!inputdev) |
|
return -ENOMEM; |
|
|
|
inputdev->name = "Ideapad extra buttons"; |
|
inputdev->phys = "ideapad/input0"; |
|
inputdev->id.bustype = BUS_HOST; |
|
inputdev->dev.parent = &priv->platform_device->dev; |
|
|
|
err = sparse_keymap_setup(inputdev, ideapad_keymap, NULL); |
|
if (err) { |
|
dev_err(&priv->platform_device->dev, |
|
"Could not set up input device keymap: %d\n", err); |
|
goto err_free_dev; |
|
} |
|
|
|
err = input_register_device(inputdev); |
|
if (err) { |
|
dev_err(&priv->platform_device->dev, |
|
"Could not register input device: %d\n", err); |
|
goto err_free_dev; |
|
} |
|
|
|
priv->inputdev = inputdev; |
|
|
|
return 0; |
|
|
|
err_free_dev: |
|
input_free_device(inputdev); |
|
|
|
return err; |
|
} |
|
|
|
static void ideapad_input_exit(struct ideapad_private *priv) |
|
{ |
|
input_unregister_device(priv->inputdev); |
|
priv->inputdev = NULL; |
|
} |
|
|
|
static void ideapad_input_report(struct ideapad_private *priv, |
|
unsigned long scancode) |
|
{ |
|
sparse_keymap_report_event(priv->inputdev, scancode, 1, true); |
|
} |
|
|
|
static void ideapad_input_novokey(struct ideapad_private *priv) |
|
{ |
|
unsigned long long_pressed; |
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_NOVO, &long_pressed)) |
|
return; |
|
|
|
if (long_pressed) |
|
ideapad_input_report(priv, 17); |
|
else |
|
ideapad_input_report(priv, 16); |
|
} |
|
|
|
static void ideapad_check_special_buttons(struct ideapad_private *priv) |
|
{ |
|
unsigned long bit, value; |
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_SPECIAL_BUTTONS, &value)) |
|
return; |
|
|
|
for_each_set_bit (bit, &value, 16) { |
|
switch (bit) { |
|
case 6: /* Z570 */ |
|
case 0: /* Z580 */ |
|
/* Thermal Management button */ |
|
ideapad_input_report(priv, 65); |
|
break; |
|
case 1: |
|
/* OneKey Theater button */ |
|
ideapad_input_report(priv, 64); |
|
break; |
|
default: |
|
dev_info(&priv->platform_device->dev, |
|
"Unknown special button: %lu\n", bit); |
|
break; |
|
} |
|
} |
|
} |
|
|
|
/* |
|
* backlight |
|
*/ |
|
static int ideapad_backlight_get_brightness(struct backlight_device *blightdev) |
|
{ |
|
struct ideapad_private *priv = bl_get_data(blightdev); |
|
unsigned long now; |
|
int err; |
|
|
|
err = read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now); |
|
if (err) |
|
return err; |
|
|
|
return now; |
|
} |
|
|
|
static int ideapad_backlight_update_status(struct backlight_device *blightdev) |
|
{ |
|
struct ideapad_private *priv = bl_get_data(blightdev); |
|
int err; |
|
|
|
err = write_ec_cmd(priv->adev->handle, VPCCMD_W_BL, |
|
blightdev->props.brightness); |
|
if (err) |
|
return err; |
|
|
|
err = write_ec_cmd(priv->adev->handle, VPCCMD_W_BL_POWER, |
|
blightdev->props.power != FB_BLANK_POWERDOWN); |
|
if (err) |
|
return err; |
|
|
|
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; |
|
int err; |
|
|
|
err = read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &max); |
|
if (err) |
|
return err; |
|
|
|
err = read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now); |
|
if (err) |
|
return err; |
|
|
|
err = read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power); |
|
if (err) |
|
return err; |
|
|
|
memset(&props, 0, sizeof(props)); |
|
|
|
props.max_brightness = max; |
|
props.type = BACKLIGHT_PLATFORM; |
|
|
|
blightdev = backlight_device_register("ideapad", |
|
&priv->platform_device->dev, |
|
priv, |
|
&ideapad_backlight_ops, |
|
&props); |
|
if (IS_ERR(blightdev)) { |
|
err = PTR_ERR(blightdev); |
|
dev_err(&priv->platform_device->dev, |
|
"Could not register backlight device: %d\n", err); |
|
return err; |
|
} |
|
|
|
priv->blightdev = blightdev; |
|
blightdev->props.brightness = now; |
|
blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN; |
|
|
|
backlight_update_status(blightdev); |
|
|
|
return 0; |
|
} |
|
|
|
static void ideapad_backlight_exit(struct ideapad_private *priv) |
|
{ |
|
backlight_device_unregister(priv->blightdev); |
|
priv->blightdev = NULL; |
|
} |
|
|
|
static void ideapad_backlight_notify_power(struct ideapad_private *priv) |
|
{ |
|
struct backlight_device *blightdev = priv->blightdev; |
|
unsigned long power; |
|
|
|
if (!blightdev) |
|
return; |
|
|
|
if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power)) |
|
return; |
|
|
|
blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN; |
|
} |
|
|
|
static void ideapad_backlight_notify_brightness(struct ideapad_private *priv) |
|
{ |
|
unsigned long now; |
|
|
|
/* if we control brightness via acpi video driver */ |
|
if (!priv->blightdev) |
|
read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now); |
|
else |
|
backlight_force_update(priv->blightdev, BACKLIGHT_UPDATE_HOTKEY); |
|
} |
|
|
|
/* |
|
* 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); |
|
} |
|
|
|
/* |
|
* module init/exit |
|
*/ |
|
static void ideapad_sync_touchpad_state(struct ideapad_private *priv) |
|
{ |
|
unsigned long value; |
|
|
|
if (!priv->features.touchpad_ctrl_via_ec) |
|
return; |
|
|
|
/* Without reading from EC touchpad LED doesn't switch state */ |
|
if (!read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value)) { |
|
unsigned char param; |
|
/* |
|
* Some IdeaPads don't really turn off touchpad - they only |
|
* switch the LED state. We (de)activate KBC AUX port to turn |
|
* touchpad off and on. We send KEY_TOUCHPAD_OFF and |
|
* KEY_TOUCHPAD_ON to not to get out of sync with LED |
|
*/ |
|
i8042_command(¶m, value ? I8042_CMD_AUX_ENABLE : I8042_CMD_AUX_DISABLE); |
|
ideapad_input_report(priv, value ? 67 : 66); |
|
sysfs_notify(&priv->platform_device->dev.kobj, NULL, "touchpad"); |
|
} |
|
} |
|
|
|
static void ideapad_acpi_notify(acpi_handle handle, u32 event, void *data) |
|
{ |
|
struct ideapad_private *priv = data; |
|
unsigned long vpc1, vpc2, bit; |
|
|
|
if (read_ec_data(handle, VPCCMD_R_VPC1, &vpc1)) |
|
return; |
|
|
|
if (read_ec_data(handle, VPCCMD_R_VPC2, &vpc2)) |
|
return; |
|
|
|
vpc1 = (vpc2 << 8) | vpc1; |
|
|
|
for_each_set_bit (bit, &vpc1, 16) { |
|
switch (bit) { |
|
case 13: |
|
case 11: |
|
case 8: |
|
case 7: |
|
case 6: |
|
ideapad_input_report(priv, bit); |
|
break; |
|
case 10: |
|
/* |
|
* This event gets send on a Yoga 300-11IBR when the EC |
|
* believes that the device has changed between laptop/ |
|
* tent/stand/tablet mode. The EC relies on getting |
|
* angle info from 2 accelerometers through a special |
|
* windows service calling a DSM on the DUAL250E ACPI- |
|
* device. Linux does not do this, making the laptop/ |
|
* tent/stand/tablet mode info unreliable, so we simply |
|
* ignore these events. |
|
*/ |
|
break; |
|
case 9: |
|
ideapad_sync_rfk_state(priv); |
|
break; |
|
case 5: |
|
ideapad_sync_touchpad_state(priv); |
|
break; |
|
case 4: |
|
ideapad_backlight_notify_brightness(priv); |
|
break; |
|
case 3: |
|
ideapad_input_novokey(priv); |
|
break; |
|
case 2: |
|
ideapad_backlight_notify_power(priv); |
|
break; |
|
case 1: |
|
/* |
|
* Some IdeaPads report event 1 every ~20 |
|
* seconds while on battery power; some |
|
* report this when changing to/from tablet |
|
* mode; some report this when the keyboard |
|
* backlight has changed. |
|
*/ |
|
ideapad_kbd_bl_notify(priv); |
|
break; |
|
case 0: |
|
ideapad_check_special_buttons(priv); |
|
break; |
|
default: |
|
dev_info(&priv->platform_device->dev, |
|
"Unknown event: %lu\n", bit); |
|
} |
|
} |
|
} |
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI) |
|
static void ideapad_wmi_notify(u32 value, void *context) |
|
{ |
|
struct ideapad_private *priv = context; |
|
unsigned long result; |
|
|
|
switch (value) { |
|
case 128: |
|
ideapad_input_report(priv, value); |
|
break; |
|
case 208: |
|
if (!eval_hals(priv->adev->handle, &result)) { |
|
bool state = test_bit(HALS_FNLOCK_STATE_BIT, &result); |
|
|
|
exec_sals(priv->adev->handle, state ? SALS_FNLOCK_ON : SALS_FNLOCK_OFF); |
|
} |
|
break; |
|
default: |
|
dev_info(&priv->platform_device->dev, |
|
"Unknown WMI event: %u\n", value); |
|
} |
|
} |
|
#endif |
|
|
|
/* |
|
* 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. |
|
*/ |
|
static const struct dmi_system_id hw_rfkill_list[] = { |
|
{} |
|
}; |
|
|
|
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; |
|
|
|
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; |
|
|
|
if (test_bit(HALS_KBD_BL_SUPPORT_BIT, &val)) |
|
priv->features.kbd_bl = true; |
|
|
|
if (test_bit(HALS_USB_CHARGING_SUPPORT_BIT, &val)) |
|
priv->features.usb_charging = true; |
|
} |
|
} |
|
} |
|
|
|
static int ideapad_acpi_add(struct platform_device *pdev) |
|
{ |
|
struct ideapad_private *priv; |
|
struct acpi_device *adev; |
|
acpi_status status; |
|
unsigned long cfg; |
|
int err, i; |
|
|
|
err = acpi_bus_get_device(ACPI_HANDLE(&pdev->dev), &adev); |
|
if (err) |
|
return -ENODEV; |
|
|
|
if (eval_int(adev->handle, "_CFG", &cfg)) |
|
return -ENODEV; |
|
|
|
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); |
|
if (!priv) |
|
return -ENOMEM; |
|
|
|
dev_set_drvdata(&pdev->dev, priv); |
|
|
|
priv->cfg = cfg; |
|
priv->adev = adev; |
|
priv->platform_device = pdev; |
|
|
|
ideapad_check_features(priv); |
|
|
|
err = ideapad_sysfs_init(priv); |
|
if (err) |
|
return err; |
|
|
|
ideapad_debugfs_init(priv); |
|
|
|
err = ideapad_input_init(priv); |
|
if (err) |
|
goto input_failed; |
|
|
|
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"); |
|
} |
|
|
|
/* |
|
* On some models without a hw-switch (the yoga 2 13 at least) |
|
* VPCCMD_W_RF must be explicitly set to 1 for the wifi to work. |
|
*/ |
|
if (!priv->features.hw_rfkill_switch) |
|
write_ec_cmd(priv->adev->handle, VPCCMD_W_RF, 1); |
|
|
|
/* The same for Touchpad */ |
|
if (!priv->features.touchpad_ctrl_via_ec) |
|
write_ec_cmd(priv->adev->handle, VPCCMD_W_TOUCHPAD, 1); |
|
|
|
for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++) |
|
if (test_bit(ideapad_rfk_data[i].cfgbit, &priv->cfg)) |
|
ideapad_register_rfkill(priv, i); |
|
|
|
ideapad_sync_rfk_state(priv); |
|
ideapad_sync_touchpad_state(priv); |
|
|
|
err = ideapad_dytc_profile_init(priv); |
|
if (err) { |
|
if (err != -ENODEV) |
|
dev_warn(&pdev->dev, "Could not set up DYTC interface: %d\n", err); |
|
else |
|
dev_info(&pdev->dev, "DYTC interface is not available\n"); |
|
} |
|
|
|
if (acpi_video_get_backlight_type() == acpi_backlight_vendor) { |
|
err = ideapad_backlight_init(priv); |
|
if (err && err != -ENODEV) |
|
goto backlight_failed; |
|
} |
|
|
|
status = acpi_install_notify_handler(adev->handle, |
|
ACPI_DEVICE_NOTIFY, |
|
ideapad_acpi_notify, priv); |
|
if (ACPI_FAILURE(status)) { |
|
err = -EIO; |
|
goto notification_failed; |
|
} |
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI) |
|
for (i = 0; i < ARRAY_SIZE(ideapad_wmi_fnesc_events); i++) { |
|
status = wmi_install_notify_handler(ideapad_wmi_fnesc_events[i], |
|
ideapad_wmi_notify, priv); |
|
if (ACPI_SUCCESS(status)) { |
|
priv->fnesc_guid = ideapad_wmi_fnesc_events[i]; |
|
break; |
|
} |
|
} |
|
|
|
if (ACPI_FAILURE(status) && status != AE_NOT_EXIST) { |
|
err = -EIO; |
|
goto notification_failed_wmi; |
|
} |
|
#endif |
|
|
|
return 0; |
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI) |
|
notification_failed_wmi: |
|
acpi_remove_notify_handler(priv->adev->handle, |
|
ACPI_DEVICE_NOTIFY, |
|
ideapad_acpi_notify); |
|
#endif |
|
|
|
notification_failed: |
|
ideapad_backlight_exit(priv); |
|
|
|
backlight_failed: |
|
ideapad_dytc_profile_exit(priv); |
|
|
|
for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++) |
|
ideapad_unregister_rfkill(priv, i); |
|
|
|
ideapad_kbd_bl_exit(priv); |
|
ideapad_input_exit(priv); |
|
|
|
input_failed: |
|
ideapad_debugfs_exit(priv); |
|
ideapad_sysfs_exit(priv); |
|
|
|
return err; |
|
} |
|
|
|
static int ideapad_acpi_remove(struct platform_device *pdev) |
|
{ |
|
struct ideapad_private *priv = dev_get_drvdata(&pdev->dev); |
|
int i; |
|
|
|
#if IS_ENABLED(CONFIG_ACPI_WMI) |
|
if (priv->fnesc_guid) |
|
wmi_remove_notify_handler(priv->fnesc_guid); |
|
#endif |
|
|
|
acpi_remove_notify_handler(priv->adev->handle, |
|
ACPI_DEVICE_NOTIFY, |
|
ideapad_acpi_notify); |
|
|
|
ideapad_backlight_exit(priv); |
|
ideapad_dytc_profile_exit(priv); |
|
|
|
for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++) |
|
ideapad_unregister_rfkill(priv, i); |
|
|
|
ideapad_kbd_bl_exit(priv); |
|
ideapad_input_exit(priv); |
|
ideapad_debugfs_exit(priv); |
|
ideapad_sysfs_exit(priv); |
|
|
|
return 0; |
|
} |
|
|
|
#ifdef CONFIG_PM_SLEEP |
|
static int ideapad_acpi_resume(struct device *dev) |
|
{ |
|
struct ideapad_private *priv = dev_get_drvdata(dev); |
|
|
|
ideapad_sync_rfk_state(priv); |
|
ideapad_sync_touchpad_state(priv); |
|
|
|
if (priv->dytc) |
|
dytc_profile_refresh(priv); |
|
|
|
return 0; |
|
} |
|
#endif |
|
static SIMPLE_DEV_PM_OPS(ideapad_pm, NULL, ideapad_acpi_resume); |
|
|
|
static const struct acpi_device_id ideapad_device_ids[] = { |
|
{"VPC2004", 0}, |
|
{"", 0}, |
|
}; |
|
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); |
|
|
|
MODULE_AUTHOR("David Woodhouse <[email protected]>"); |
|
MODULE_DESCRIPTION("IdeaPad ACPI Extras"); |
|
MODULE_LICENSE("GPL");
|
|
|