#include <linux/acpi.h>
#include <linux/cleanup.h>
#include <linux/compiler_attributes.h>
#include <linux/dev_printk.h>
#include <linux/dmi.h>
#include <linux/input.h>
#include <linux/module.h>
#include <linux/notifier.h>
#include <linux/pm.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/sysfs.h>
#include <linux/types.h>
#include <linux/wmi.h>
#define YB9_KBDOCK_EVENT_GUID "806BD2A2-177B-481D-BFB5-3BA0BB4A2285"
#define YB9_KBDOCK_QUERY_GUID "E7F300FA-21CD-4003-ADAC-2696135982E6"
#define BKBD_DETACHED 0
#define YB9_FEATURE_STATUS_ID 0x00060000u
struct lenovo_feature_status {
__le32 id;
__le32 status;
} __packed;
static BLOCKING_NOTIFIER_HEAD(yb9_kbdock_chain_head);
static void devm_yb9_kbdock_unregister_notifier(void *data)
{
struct notifier_block *nb = data;
blocking_notifier_chain_unregister(&yb9_kbdock_chain_head, nb);
}
static int devm_yb9_kbdock_register_notifier(struct device *dev,
struct notifier_block *nb)
{
int ret;
ret = blocking_notifier_chain_register(&yb9_kbdock_chain_head, nb);
if (ret < 0)
return ret;
return devm_add_action_or_reset(dev, devm_yb9_kbdock_unregister_notifier, nb);
}
struct yb9_kbdock_data {
struct wmi_device *wdev;
struct input_dev *input_dev;
struct notifier_block nb;
spinlock_t lock;
};
static int yb9_kbdock_query(struct yb9_kbdock_data *d, u32 *bkbd)
{
struct wmi_buffer out;
int ret;
ret = wmidev_query_block(d->wdev, 0, &out,
sizeof(struct lenovo_feature_status));
if (ret)
return ret;
struct lenovo_feature_status *fs __free(kfree) = out.data;
if (le32_to_cpu(fs->id) != YB9_FEATURE_STATUS_ID)
return -EIO;
*bkbd = le32_to_cpu(fs->status);
return 0;
}
static void yb9_kbdock_report(struct yb9_kbdock_data *d, u32 bkbd)
{
int tablet = (bkbd == BKBD_DETACHED) ? 1 : 0;
spin_lock(&d->lock);
input_report_switch(d->input_dev, SW_TABLET_MODE, tablet);
input_sync(d->input_dev);
spin_unlock(&d->lock);
dev_dbg(&d->wdev->dev, "BKBD=%u SW_TABLET_MODE=%d\n", bkbd, tablet);
}
static int yb9_kbdock_sync(struct yb9_kbdock_data *d)
{
u32 bkbd;
int ret;
ret = yb9_kbdock_query(d, &bkbd);
if (ret)
return ret;
yb9_kbdock_report(d, bkbd);
return 0;
}
static int yb9_kbdock_nb_call(struct notifier_block *nb,
unsigned long bkbd, void *unused)
{
struct yb9_kbdock_data *d =
container_of(nb, struct yb9_kbdock_data, nb);
yb9_kbdock_report(d, bkbd);
return NOTIFY_DONE;
}
static ssize_t keyboard_position_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct yb9_kbdock_data *d = dev_get_drvdata(dev);
u32 bkbd;
int ret;
ret = yb9_kbdock_query(d, &bkbd);
if (ret)
return ret;
return sysfs_emit(buf, "%u\n", bkbd);
}
static DEVICE_ATTR_RO(keyboard_position);
static const struct attribute * const yb9_kbdock_attrs[] = {
&dev_attr_keyboard_position.attr,
NULL,
};
ATTRIBUTE_GROUPS(yb9_kbdock);
static int yb9_kbdock_resume(struct device *dev)
{
struct yb9_kbdock_data *d = dev_get_drvdata(dev);
return yb9_kbdock_sync(d);
}
static DEFINE_SIMPLE_DEV_PM_OPS(yb9_kbdock_pm_ops, NULL, yb9_kbdock_resume);
static int yb9_kbdock_block_probe(struct wmi_device *wdev, const void *ctx)
{
struct yb9_kbdock_data *d;
struct input_dev *input_dev;
int ret;
d = devm_kzalloc_obj(&wdev->dev, *d);
if (!d)
return -ENOMEM;
d->wdev = wdev;
spin_lock_init(&d->lock);
input_dev = devm_input_allocate_device(&wdev->dev);
if (!input_dev)
return -ENOMEM;
input_dev->name = "Lenovo Yoga Book 9 keyboard dock switch";
input_dev->phys = YB9_KBDOCK_QUERY_GUID "/input0";
input_dev->id.bustype = BUS_HOST;
input_set_capability(input_dev, EV_SW, SW_TABLET_MODE);
ret = input_register_device(input_dev);
if (ret)
return ret;
d->input_dev = input_dev;
d->nb.notifier_call = yb9_kbdock_nb_call;
ret = devm_yb9_kbdock_register_notifier(&wdev->dev, &d->nb);
if (ret)
return ret;
dev_set_drvdata(&wdev->dev, d);
return yb9_kbdock_sync(d);
}
static const struct wmi_device_id yb9_kbdock_block_id_table[] = {
{ .guid_string = YB9_KBDOCK_QUERY_GUID },
{ }
};
static struct wmi_driver yb9_kbdock_block_driver = {
.driver = {
.name = "lenovo-yb9-kbdock",
.dev_groups = yb9_kbdock_groups,
.pm = pm_sleep_ptr(&yb9_kbdock_pm_ops),
},
.id_table = yb9_kbdock_block_id_table,
.no_singleton = true,
.probe = yb9_kbdock_block_probe,
};
static void yb9_kbdock_notify_new(struct wmi_device *wdev,
const struct wmi_buffer *data)
{
u32 bkbd = le32_to_cpu(*(const __le32 *)data->data);
blocking_notifier_call_chain(&yb9_kbdock_chain_head, bkbd, NULL);
}
static const struct wmi_device_id yb9_kbdock_event_id_table[] = {
{ .guid_string = YB9_KBDOCK_EVENT_GUID },
{ }
};
MODULE_DEVICE_TABLE(wmi, yb9_kbdock_event_id_table);
static struct wmi_driver yb9_kbdock_event_driver = {
.driver = {
.name = "lenovo-yb9-kbdock-event",
},
.id_table = yb9_kbdock_event_id_table,
.no_singleton = true,
.notify_new = yb9_kbdock_notify_new,
.min_event_size = sizeof(__le32),
};
static const struct dmi_system_id yb9_kbdock_dmi_table[] __initconst = {
{
.matches = {
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
DMI_MATCH(DMI_PRODUCT_NAME, "83KJ"),
},
},
{ }
};
static int __init yb9_kbdock_init(void)
{
int ret;
if (!dmi_check_system(yb9_kbdock_dmi_table))
return -ENODEV;
ret = wmi_driver_register(&yb9_kbdock_event_driver);
if (ret)
return ret;
ret = wmi_driver_register(&yb9_kbdock_block_driver);
if (ret) {
wmi_driver_unregister(&yb9_kbdock_event_driver);
return ret;
}
return 0;
}
module_init(yb9_kbdock_init);
static void __exit yb9_kbdock_exit(void)
{
wmi_driver_unregister(&yb9_kbdock_block_driver);
wmi_driver_unregister(&yb9_kbdock_event_driver);
}
module_exit(yb9_kbdock_exit);
MODULE_AUTHOR("Dave Carey <carvsdriver@gmail.com>");
MODULE_DESCRIPTION("Lenovo Yoga Book 9 keyboard dock detection");
MODULE_LICENSE("GPL"