| Message ID | 20240528-yoga-ec-driver-v4-2-4fa8dfaae7b6@linaro.org |
|---|---|
| State | Superseded |
| Headers | show |
| Series | power: supply: Lenovo Yoga C630 EC | expand |
On 28/05/2024 21:44, Dmitry Baryshkov wrote: > Lenovo Yoga C630 WOS is a laptop using Snapdragon 850 SoC. Like many > laptops it uses embedded controller (EC) to perform various platform an embedded controller > operations, including, but not limited, to Type-C port control or power > supply handlng. > > Add the driver for the EC, that creates devices for UCSI and power > supply devices. > > Signed-off-by: Dmitry Baryshkov <dmitry.baryshkov@linaro.org> > --- > drivers/platform/arm64/Kconfig | 14 ++ > drivers/platform/arm64/Makefile | 1 + > drivers/platform/arm64/lenovo-yoga-c630.c | 279 +++++++++++++++++++++++++ > include/linux/platform_data/lenovo-yoga-c630.h | 42 ++++ > 4 files changed, 336 insertions(+) > > diff --git a/drivers/platform/arm64/Kconfig b/drivers/platform/arm64/Kconfig > index 8fdca0f8e909..8c103b3150d1 100644 > --- a/drivers/platform/arm64/Kconfig > +++ b/drivers/platform/arm64/Kconfig > @@ -32,4 +32,18 @@ config EC_ACER_ASPIRE1 > laptop where this information is not properly exposed via the > standard ACPI devices. > > +config EC_LENOVO_YOGA_C630 > + tristate "Lenovo Yoga C630 Embedded Controller driver" > + depends on I2C > + help > + Driver for the Embedded Controller in the Qualcomm Snapdragon-based > + Lenovo Yoga C630, which provides battery and power adapter > + information. > + > + This driver provides battery and AC status support for the mentioned > + laptop where this information is not properly exposed via the > + standard ACPI devices. > + > + Say M or Y here to include this support. > + > endif # ARM64_PLATFORM_DEVICES > diff --git a/drivers/platform/arm64/Makefile b/drivers/platform/arm64/Makefile > index 4fcc9855579b..b2ae9114fdd8 100644 > --- a/drivers/platform/arm64/Makefile > +++ b/drivers/platform/arm64/Makefile > @@ -6,3 +6,4 @@ > # > > obj-$(CONFIG_EC_ACER_ASPIRE1) += acer-aspire1-ec.o > +obj-$(CONFIG_EC_LENOVO_YOGA_C630) += lenovo-yoga-c630.o > diff --git a/drivers/platform/arm64/lenovo-yoga-c630.c b/drivers/platform/arm64/lenovo-yoga-c630.c > new file mode 100644 > index 000000000000..3d1d5acde807 > --- /dev/null > +++ b/drivers/platform/arm64/lenovo-yoga-c630.c > @@ -0,0 +1,279 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * Copyright (c) 2022-2024, Linaro Ltd > + * Authors: > + * Bjorn Andersson > + * Dmitry Baryshkov > + */ > +#include <linux/auxiliary_bus.h> > +#include <linux/i2c.h> > +#include <linux/module.h> > +#include <linux/notifier.h> > +#include <linux/platform_data/lenovo-yoga-c630.h> > + > +#define LENOVO_EC_RESPONSE_REG 0x01 > +#define LENOVO_EC_REQUEST_REG 0x02 > + > +#define LENOVO_EC_UCSI_WRITE 0x20 > +#define LENOVO_EC_UCSI_READ 0x21 > + > +#define LENOVO_EC_READ_REG 0xb0 > +#define LENOVO_EC_REQUEST_NEXT_EVENT 0x84 > + > +struct yoga_c630_ec { > + struct i2c_client *client; > + struct mutex lock; > + struct blocking_notifier_head notifier_list; > +}; > + > +static int yoga_c630_ec_request(struct yoga_c630_ec *ec, u8 *req, size_t req_len, > + u8 *resp, size_t resp_len) > +{ > + int ret; > + > + WARN_ON(!mutex_is_locked(&ec->lock)); > + > + ret = i2c_smbus_write_i2c_block_data(ec->client, LENOVO_EC_REQUEST_REG, > + req_len, req); > + if (ret < 0) > + return ret; > + > + return i2c_smbus_read_i2c_block_data(ec->client, LENOVO_EC_RESPONSE_REG, > + resp_len, resp); > +} > + > +int yoga_c630_ec_read8(struct yoga_c630_ec *ec, u8 addr) > +{ > + u8 req[2] = { LENOVO_EC_READ_REG, }; > + int ret; > + u8 val; > + > + mutex_lock(&ec->lock); > + req[1] = addr; > + ret = yoga_c630_ec_request(ec, req, sizeof(req), &val, 1); > + mutex_unlock(&ec->lock); > + > + return ret < 0 ? ret : val; > +} > +EXPORT_SYMBOL_GPL(yoga_c630_ec_read8); > + > +int yoga_c630_ec_read16(struct yoga_c630_ec *ec, u8 addr) > +{ > + u8 req[2] = { LENOVO_EC_READ_REG, }; > + int ret; > + u8 msb; > + u8 lsb; > + > + mutex_lock(&ec->lock); > + > + req[1] = addr; > + ret = yoga_c630_ec_request(ec, req, sizeof(req), &lsb, 1); > + if (ret < 0) > + goto out; > + > + req[1] = addr + 1; > + ret = yoga_c630_ec_request(ec, req, sizeof(req), &msb, 1); > + > +out: > + mutex_unlock(&ec->lock); > + > + return ret < 0 ? ret : msb << 8 | lsb; > +} > +EXPORT_SYMBOL_GPL(yoga_c630_ec_read16); > + > +u16 yoga_c630_ec_ucsi_get_version(struct yoga_c630_ec *ec) > +{ > + u8 req[3] = { 0xb3, 0xf2, 0x20}; You have a define above for the read_reg and write_reg commands, could you not define 0xb3 as LENOVO_EC_GET_VERSION ? All of the other commands here seem to have a named define. > + int ret; > + u8 msb; > + u8 lsb; > + > + mutex_lock(&ec->lock); > + ret = yoga_c630_ec_request(ec, req, sizeof(req), &lsb, 1); > + if (ret < 0) > + goto out; > + > + req[2]++; why not set reg[2] = 0x21; also is req[2] some kind of address ? > + ret = yoga_c630_ec_request(ec, req, sizeof(req), &msb, 1); > + > +out: > + mutex_unlock(&ec->lock); > + > + return ret < 0 ? ret : msb << 8 | lsb; > +} > +EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_get_version); > + > +int yoga_c630_ec_ucsi_write(struct yoga_c630_ec *ec, > + const u8 req[YOGA_C630_UCSI_WRITE_SIZE]) > +{ > + int ret; > + > + mutex_lock(&ec->lock); > + ret = i2c_smbus_write_i2c_block_data(ec->client, LENOVO_EC_UCSI_WRITE, > + YOGA_C630_UCSI_WRITE_SIZE, req); > + mutex_unlock(&ec->lock); > + > + return ret < 0 ? ret : 0; > +} > +EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_write); > + > +int yoga_c630_ec_ucsi_read(struct yoga_c630_ec *ec, > + u8 resp[YOGA_C630_UCSI_READ_SIZE]) > +{ > + int ret; > + > + mutex_lock(&ec->lock); > + ret = i2c_smbus_read_i2c_block_data(ec->client, LENOVO_EC_UCSI_READ, > + YOGA_C630_UCSI_READ_SIZE, resp); > + mutex_unlock(&ec->lock); > + > + return ret < 0 ? ret : 0; > +} > +EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_read); > + > +static irqreturn_t yoga_c630_ec_intr(int irq, void *data) > +{ > + u8 req[] = { LENOVO_EC_REQUEST_NEXT_EVENT }; > + struct yoga_c630_ec *ec = data; > + u8 event; > + int ret; > + > + mutex_lock(&ec->lock); > + ret = yoga_c630_ec_request(ec, req, sizeof(req), &event, 1); > + mutex_unlock(&ec->lock); > + if (ret < 0) > + return IRQ_HANDLED; > + > + pr_info("NOTIFY %x\n", event); why not dev_info() ? --- bod
On Tue, 28 May 2024, Dmitry Baryshkov wrote: > Lenovo Yoga C630 WOS is a laptop using Snapdragon 850 SoC. Like many > laptops it uses embedded controller (EC) to perform various platform > operations, including, but not limited, to Type-C port control or power > supply handlng. > > Add the driver for the EC, that creates devices for UCSI and power > supply devices. > > Signed-off-by: Dmitry Baryshkov <dmitry.baryshkov@linaro.org> > --- > drivers/platform/arm64/Kconfig | 14 ++ > drivers/platform/arm64/Makefile | 1 + > drivers/platform/arm64/lenovo-yoga-c630.c | 279 +++++++++++++++++++++++++ > include/linux/platform_data/lenovo-yoga-c630.h | 42 ++++ > 4 files changed, 336 insertions(+) > > diff --git a/drivers/platform/arm64/Kconfig b/drivers/platform/arm64/Kconfig > index 8fdca0f8e909..8c103b3150d1 100644 > --- a/drivers/platform/arm64/Kconfig > +++ b/drivers/platform/arm64/Kconfig > @@ -32,4 +32,18 @@ config EC_ACER_ASPIRE1 > laptop where this information is not properly exposed via the > standard ACPI devices. > > +config EC_LENOVO_YOGA_C630 > + tristate "Lenovo Yoga C630 Embedded Controller driver" > + depends on I2C > + help > + Driver for the Embedded Controller in the Qualcomm Snapdragon-based > + Lenovo Yoga C630, which provides battery and power adapter > + information. > + > + This driver provides battery and AC status support for the mentioned > + laptop where this information is not properly exposed via the > + standard ACPI devices. > + > + Say M or Y here to include this support. > + > endif # ARM64_PLATFORM_DEVICES > diff --git a/drivers/platform/arm64/Makefile b/drivers/platform/arm64/Makefile > index 4fcc9855579b..b2ae9114fdd8 100644 > --- a/drivers/platform/arm64/Makefile > +++ b/drivers/platform/arm64/Makefile > @@ -6,3 +6,4 @@ > # > > obj-$(CONFIG_EC_ACER_ASPIRE1) += acer-aspire1-ec.o > +obj-$(CONFIG_EC_LENOVO_YOGA_C630) += lenovo-yoga-c630.o > diff --git a/drivers/platform/arm64/lenovo-yoga-c630.c b/drivers/platform/arm64/lenovo-yoga-c630.c > new file mode 100644 > index 000000000000..3d1d5acde807 > --- /dev/null > +++ b/drivers/platform/arm64/lenovo-yoga-c630.c > @@ -0,0 +1,279 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * Copyright (c) 2022-2024, Linaro Ltd > + * Authors: > + * Bjorn Andersson > + * Dmitry Baryshkov > + */ > +#include <linux/auxiliary_bus.h> > +#include <linux/i2c.h> > +#include <linux/module.h> > +#include <linux/notifier.h> > +#include <linux/platform_data/lenovo-yoga-c630.h> > + > +#define LENOVO_EC_RESPONSE_REG 0x01 > +#define LENOVO_EC_REQUEST_REG 0x02 > + > +#define LENOVO_EC_UCSI_WRITE 0x20 > +#define LENOVO_EC_UCSI_READ 0x21 > + > +#define LENOVO_EC_READ_REG 0xb0 > +#define LENOVO_EC_REQUEST_NEXT_EVENT 0x84 > + > +struct yoga_c630_ec { > + struct i2c_client *client; > + struct mutex lock; Add include for struct mutex. > + struct blocking_notifier_head notifier_list; > +}; > + > +static int yoga_c630_ec_request(struct yoga_c630_ec *ec, u8 *req, size_t req_len, > + u8 *resp, size_t resp_len) > +{ > + int ret; > + > + WARN_ON(!mutex_is_locked(&ec->lock)); There some lockdep way to assert the same thing. > + ret = i2c_smbus_write_i2c_block_data(ec->client, LENOVO_EC_REQUEST_REG, > + req_len, req); > + if (ret < 0) > + return ret; > + > + return i2c_smbus_read_i2c_block_data(ec->client, LENOVO_EC_RESPONSE_REG, > + resp_len, resp); > +} > + > +int yoga_c630_ec_read8(struct yoga_c630_ec *ec, u8 addr) > +{ > + u8 req[2] = { LENOVO_EC_READ_REG, }; > + int ret; > + u8 val; > + > + mutex_lock(&ec->lock); > + req[1] = addr; > + ret = yoga_c630_ec_request(ec, req, sizeof(req), &val, 1); > + mutex_unlock(&ec->lock); > + > + return ret < 0 ? ret : val; > +} > +EXPORT_SYMBOL_GPL(yoga_c630_ec_read8); > + > +int yoga_c630_ec_read16(struct yoga_c630_ec *ec, u8 addr) > +{ > + u8 req[2] = { LENOVO_EC_READ_REG, }; > + int ret; > + u8 msb; > + u8 lsb; > + > + mutex_lock(&ec->lock); > + > + req[1] = addr; > + ret = yoga_c630_ec_request(ec, req, sizeof(req), &lsb, 1); > + if (ret < 0) > + goto out; > + > + req[1] = addr + 1; > + ret = yoga_c630_ec_request(ec, req, sizeof(req), &msb, 1); > + > +out: > + mutex_unlock(&ec->lock); Please use the scoped_guard from linux/cleanup.h for the mutex so you can immediately return instead of adding the out label. > + > + return ret < 0 ? ret : msb << 8 | lsb; > +} > +EXPORT_SYMBOL_GPL(yoga_c630_ec_read16); > + > +u16 yoga_c630_ec_ucsi_get_version(struct yoga_c630_ec *ec) > +{ > + u8 req[3] = { 0xb3, 0xf2, 0x20}; > + int ret; > + u8 msb; > + u8 lsb; > + > + mutex_lock(&ec->lock); > + ret = yoga_c630_ec_request(ec, req, sizeof(req), &lsb, 1); > + if (ret < 0) > + goto out; > + > + req[2]++; > + ret = yoga_c630_ec_request(ec, req, sizeof(req), &msb, 1); > + > +out: > + mutex_unlock(&ec->lock); Ditto. > + return ret < 0 ? ret : msb << 8 | lsb; > +} > +EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_get_version); > + > +int yoga_c630_ec_ucsi_write(struct yoga_c630_ec *ec, > + const u8 req[YOGA_C630_UCSI_WRITE_SIZE]) > +{ > + int ret; > + > + mutex_lock(&ec->lock); > + ret = i2c_smbus_write_i2c_block_data(ec->client, LENOVO_EC_UCSI_WRITE, > + YOGA_C630_UCSI_WRITE_SIZE, req); > + mutex_unlock(&ec->lock); > + > + return ret < 0 ? ret : 0; > +} > +EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_write); > + > +int yoga_c630_ec_ucsi_read(struct yoga_c630_ec *ec, > + u8 resp[YOGA_C630_UCSI_READ_SIZE]) > +{ > + int ret; > + > + mutex_lock(&ec->lock); > + ret = i2c_smbus_read_i2c_block_data(ec->client, LENOVO_EC_UCSI_READ, > + YOGA_C630_UCSI_READ_SIZE, resp); > + mutex_unlock(&ec->lock); > + > + return ret < 0 ? ret : 0; > +} > +EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_read); > + > +static irqreturn_t yoga_c630_ec_intr(int irq, void *data) > +{ > + u8 req[] = { LENOVO_EC_REQUEST_NEXT_EVENT }; > + struct yoga_c630_ec *ec = data; > + u8 event; > + int ret; > + > + mutex_lock(&ec->lock); > + ret = yoga_c630_ec_request(ec, req, sizeof(req), &event, 1); > + mutex_unlock(&ec->lock); > + if (ret < 0) > + return IRQ_HANDLED; > + > + pr_info("NOTIFY %x\n", event); > + > + blocking_notifier_call_chain(&ec->notifier_list, event, ec); > + > + return IRQ_HANDLED; Add include for IRQ_HANDLED and irqreturn_t. > +} > + > +/** > + * yoga_c630_ec_register_notify - Register a notifier callback for EC events. > + * @ec: Yoga C630 EC > + * @nb: Notifier block pointer to register > + * > + * Return: 0 on success or negative error code. > + */ > +int yoga_c630_ec_register_notify(struct yoga_c630_ec *ec, struct notifier_block *nb) > +{ > + return blocking_notifier_chain_register(&ec->notifier_list, > + nb); Fits to one line. > +} > +EXPORT_SYMBOL_GPL(yoga_c630_ec_register_notify); > + > +/** > + * yoga_c630_ec_unregister_notify - Unregister notifier callback for EC events. > + * @ec: Yoga C630 EC > + * @nb: Notifier block pointer to unregister > + * > + * Unregister a notifier callback that was previously registered with > + * yoga_c630_ec_register_notify(). > + */ > +void yoga_c630_ec_unregister_notify(struct yoga_c630_ec *ec, struct notifier_block *nb) > +{ > + blocking_notifier_chain_unregister(&ec->notifier_list, nb); > +} > +EXPORT_SYMBOL_GPL(yoga_c630_ec_unregister_notify); > + > +static void yoga_c630_aux_release(struct device *dev) > +{ > + struct auxiliary_device *adev = to_auxiliary_dev(dev); > + > + kfree(adev); > +} > + > +static void yoga_c630_aux_remove(void *data) > +{ > + struct auxiliary_device *adev = data; > + > + auxiliary_device_delete(adev); > + auxiliary_device_uninit(adev); > +} > + > +static int yoga_c630_aux_init(struct device *parent, const char *name, > + struct yoga_c630_ec *ec) > +{ > + struct auxiliary_device *adev; > + int ret; > + > + adev = kzalloc(sizeof(*adev), GFP_KERNEL); Add include for kzalloc. > + if (!adev) > + return -ENOMEM; Add include for ENOMEM. I might have missed some other includes your code is using which are not directly included currently, please add them as well. > + adev->name = name; > + adev->id = 0; > + adev->dev.parent = parent; > + adev->dev.release = yoga_c630_aux_release; > + adev->dev.platform_data = ec; > + > + ret = auxiliary_device_init(adev); > + if (ret) { > + kfree(adev); > + return ret; > + } > + > + ret = auxiliary_device_add(adev); > + if (ret) { > + auxiliary_device_uninit(adev); > + return ret; > + } > + > + return devm_add_action_or_reset(parent, yoga_c630_aux_remove, adev); > +} > + > +static int yoga_c630_ec_probe(struct i2c_client *client) > +{ > + struct yoga_c630_ec *ec; > + struct device *dev = &client->dev; Reverse the order of these two. > + int ret; > + > + ec = devm_kzalloc(dev, sizeof(*ec), GFP_KERNEL); > + if (!ec) > + return -ENOMEM; > + > + mutex_init(&ec->lock); > + ec->client = client; > + BLOCKING_INIT_NOTIFIER_HEAD(&ec->notifier_list); > + > + ret = devm_request_threaded_irq(dev, client->irq, > + NULL, yoga_c630_ec_intr, Could you please rename the handler function such that it's immediately obvious you're using irq thread (I had to check this from here when reviewing your handler since you used mutex inside it). > + IRQF_ONESHOT, "yoga_c630_ec", ec); > + if (ret < 0) > + return dev_err_probe(dev, ret, "unable to request irq\n"); > + > + ret = yoga_c630_aux_init(dev, YOGA_C630_DEV_PSY, ec); > + if (ret) > + return ret; > + > + return yoga_c630_aux_init(dev, YOGA_C630_DEV_UCSI, ec); > +} > + > + > +static const struct of_device_id yoga_c630_ec_of_match[] = { > + { .compatible = "lenovo,yoga-c630-ec" }, > + {} > +}; > +MODULE_DEVICE_TABLE(of, yoga_c630_ec_of_match); > + > +static const struct i2c_device_id yoga_c630_ec_i2c_id_table[] = { > + { "yoga-c630-ec", }, > + {} > +}; > +MODULE_DEVICE_TABLE(i2c, yoga_c630_ec_i2c_id_table); > + > +static struct i2c_driver yoga_c630_ec_i2c_driver = { > + .driver = { > + .name = "yoga-c630-ec", > + .of_match_table = yoga_c630_ec_of_match > + }, > + .probe = yoga_c630_ec_probe, > + .id_table = yoga_c630_ec_i2c_id_table, > +}; > +module_i2c_driver(yoga_c630_ec_i2c_driver); > + > +MODULE_DESCRIPTION("Lenovo Yoga C630 Embedded Controller"); > +MODULE_LICENSE("GPL"); > diff --git a/include/linux/platform_data/lenovo-yoga-c630.h b/include/linux/platform_data/lenovo-yoga-c630.h > new file mode 100644 > index 000000000000..2b893dbeb124 > --- /dev/null > +++ b/include/linux/platform_data/lenovo-yoga-c630.h > @@ -0,0 +1,42 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * Copyright (c) 2022-2024, Linaro Ltd > + * Authors: > + * Bjorn Andersson > + * Dmitry Baryshkov > + */ > + > +#ifndef _LENOVO_YOGA_C630_DATA_H > +#define _LENOVO_YOGA_C630_DATA_H > + > +struct yoga_c630_ec; > + > +#define YOGA_C630_MOD_NAME "lenovo_yoga_c630" > + > +#define YOGA_C630_DEV_UCSI "ucsi" > +#define YOGA_C630_DEV_PSY "psy" > + > +int yoga_c630_ec_read8(struct yoga_c630_ec *ec, u8 addr); > +int yoga_c630_ec_read16(struct yoga_c630_ec *ec, u8 addr); > + > +int yoga_c630_ec_register_notify(struct yoga_c630_ec *ec, struct notifier_block *nb); > +void yoga_c630_ec_unregister_notify(struct yoga_c630_ec *ec, struct notifier_block *nb); You need a forward declaration for struct notifier_block like you already have for yoga_c630_ec. > +#define YOGA_C630_UCSI_WRITE_SIZE 8 > +#define YOGA_C630_UCSI_CCI_SIZE 4 > +#define YOGA_C630_UCSI_DATA_SIZE 16 > +#define YOGA_C630_UCSI_READ_SIZE (YOGA_C630_UCSI_CCI_SIZE + YOGA_C630_UCSI_DATA_SIZE) > +u16 yoga_c630_ec_ucsi_get_version(struct yoga_c630_ec *ec); > +int yoga_c630_ec_ucsi_write(struct yoga_c630_ec *ec, > + const u8 req[YOGA_C630_UCSI_WRITE_SIZE]); > +int yoga_c630_ec_ucsi_read(struct yoga_c630_ec *ec, > + u8 resp[YOGA_C630_UCSI_READ_SIZE]); > + > +#define LENOVO_EC_EVENT_USB 0x20 > +#define LENOVO_EC_EVENT_UCSI 0x21 > +#define LENOVO_EC_EVENT_HPD 0x22 > +#define LENOVO_EC_EVENT_BAT_STATUS 0x24 > +#define LENOVO_EC_EVENT_BAT_INFO 0x25 > +#define LENOVO_EC_EVENT_BAT_ADPT_STATUS 0x37 > + > +#endif > >
diff --git a/drivers/platform/arm64/Kconfig b/drivers/platform/arm64/Kconfig index 8fdca0f8e909..8c103b3150d1 100644 --- a/drivers/platform/arm64/Kconfig +++ b/drivers/platform/arm64/Kconfig @@ -32,4 +32,18 @@ config EC_ACER_ASPIRE1 laptop where this information is not properly exposed via the standard ACPI devices. +config EC_LENOVO_YOGA_C630 + tristate "Lenovo Yoga C630 Embedded Controller driver" + depends on I2C + help + Driver for the Embedded Controller in the Qualcomm Snapdragon-based + Lenovo Yoga C630, which provides battery and power adapter + information. + + This driver provides battery and AC status support for the mentioned + laptop where this information is not properly exposed via the + standard ACPI devices. + + Say M or Y here to include this support. + endif # ARM64_PLATFORM_DEVICES diff --git a/drivers/platform/arm64/Makefile b/drivers/platform/arm64/Makefile index 4fcc9855579b..b2ae9114fdd8 100644 --- a/drivers/platform/arm64/Makefile +++ b/drivers/platform/arm64/Makefile @@ -6,3 +6,4 @@ # obj-$(CONFIG_EC_ACER_ASPIRE1) += acer-aspire1-ec.o +obj-$(CONFIG_EC_LENOVO_YOGA_C630) += lenovo-yoga-c630.o diff --git a/drivers/platform/arm64/lenovo-yoga-c630.c b/drivers/platform/arm64/lenovo-yoga-c630.c new file mode 100644 index 000000000000..3d1d5acde807 --- /dev/null +++ b/drivers/platform/arm64/lenovo-yoga-c630.c @@ -0,0 +1,279 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (c) 2022-2024, Linaro Ltd + * Authors: + * Bjorn Andersson + * Dmitry Baryshkov + */ +#include <linux/auxiliary_bus.h> +#include <linux/i2c.h> +#include <linux/module.h> +#include <linux/notifier.h> +#include <linux/platform_data/lenovo-yoga-c630.h> + +#define LENOVO_EC_RESPONSE_REG 0x01 +#define LENOVO_EC_REQUEST_REG 0x02 + +#define LENOVO_EC_UCSI_WRITE 0x20 +#define LENOVO_EC_UCSI_READ 0x21 + +#define LENOVO_EC_READ_REG 0xb0 +#define LENOVO_EC_REQUEST_NEXT_EVENT 0x84 + +struct yoga_c630_ec { + struct i2c_client *client; + struct mutex lock; + struct blocking_notifier_head notifier_list; +}; + +static int yoga_c630_ec_request(struct yoga_c630_ec *ec, u8 *req, size_t req_len, + u8 *resp, size_t resp_len) +{ + int ret; + + WARN_ON(!mutex_is_locked(&ec->lock)); + + ret = i2c_smbus_write_i2c_block_data(ec->client, LENOVO_EC_REQUEST_REG, + req_len, req); + if (ret < 0) + return ret; + + return i2c_smbus_read_i2c_block_data(ec->client, LENOVO_EC_RESPONSE_REG, + resp_len, resp); +} + +int yoga_c630_ec_read8(struct yoga_c630_ec *ec, u8 addr) +{ + u8 req[2] = { LENOVO_EC_READ_REG, }; + int ret; + u8 val; + + mutex_lock(&ec->lock); + req[1] = addr; + ret = yoga_c630_ec_request(ec, req, sizeof(req), &val, 1); + mutex_unlock(&ec->lock); + + return ret < 0 ? ret : val; +} +EXPORT_SYMBOL_GPL(yoga_c630_ec_read8); + +int yoga_c630_ec_read16(struct yoga_c630_ec *ec, u8 addr) +{ + u8 req[2] = { LENOVO_EC_READ_REG, }; + int ret; + u8 msb; + u8 lsb; + + mutex_lock(&ec->lock); + + req[1] = addr; + ret = yoga_c630_ec_request(ec, req, sizeof(req), &lsb, 1); + if (ret < 0) + goto out; + + req[1] = addr + 1; + ret = yoga_c630_ec_request(ec, req, sizeof(req), &msb, 1); + +out: + mutex_unlock(&ec->lock); + + return ret < 0 ? ret : msb << 8 | lsb; +} +EXPORT_SYMBOL_GPL(yoga_c630_ec_read16); + +u16 yoga_c630_ec_ucsi_get_version(struct yoga_c630_ec *ec) +{ + u8 req[3] = { 0xb3, 0xf2, 0x20}; + int ret; + u8 msb; + u8 lsb; + + mutex_lock(&ec->lock); + ret = yoga_c630_ec_request(ec, req, sizeof(req), &lsb, 1); + if (ret < 0) + goto out; + + req[2]++; + ret = yoga_c630_ec_request(ec, req, sizeof(req), &msb, 1); + +out: + mutex_unlock(&ec->lock); + + return ret < 0 ? ret : msb << 8 | lsb; +} +EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_get_version); + +int yoga_c630_ec_ucsi_write(struct yoga_c630_ec *ec, + const u8 req[YOGA_C630_UCSI_WRITE_SIZE]) +{ + int ret; + + mutex_lock(&ec->lock); + ret = i2c_smbus_write_i2c_block_data(ec->client, LENOVO_EC_UCSI_WRITE, + YOGA_C630_UCSI_WRITE_SIZE, req); + mutex_unlock(&ec->lock); + + return ret < 0 ? ret : 0; +} +EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_write); + +int yoga_c630_ec_ucsi_read(struct yoga_c630_ec *ec, + u8 resp[YOGA_C630_UCSI_READ_SIZE]) +{ + int ret; + + mutex_lock(&ec->lock); + ret = i2c_smbus_read_i2c_block_data(ec->client, LENOVO_EC_UCSI_READ, + YOGA_C630_UCSI_READ_SIZE, resp); + mutex_unlock(&ec->lock); + + return ret < 0 ? ret : 0; +} +EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_read); + +static irqreturn_t yoga_c630_ec_intr(int irq, void *data) +{ + u8 req[] = { LENOVO_EC_REQUEST_NEXT_EVENT }; + struct yoga_c630_ec *ec = data; + u8 event; + int ret; + + mutex_lock(&ec->lock); + ret = yoga_c630_ec_request(ec, req, sizeof(req), &event, 1); + mutex_unlock(&ec->lock); + if (ret < 0) + return IRQ_HANDLED; + + pr_info("NOTIFY %x\n", event); + + blocking_notifier_call_chain(&ec->notifier_list, event, ec); + + return IRQ_HANDLED; +} + +/** + * yoga_c630_ec_register_notify - Register a notifier callback for EC events. + * @ec: Yoga C630 EC + * @nb: Notifier block pointer to register + * + * Return: 0 on success or negative error code. + */ +int yoga_c630_ec_register_notify(struct yoga_c630_ec *ec, struct notifier_block *nb) +{ + return blocking_notifier_chain_register(&ec->notifier_list, + nb); +} +EXPORT_SYMBOL_GPL(yoga_c630_ec_register_notify); + +/** + * yoga_c630_ec_unregister_notify - Unregister notifier callback for EC events. + * @ec: Yoga C630 EC + * @nb: Notifier block pointer to unregister + * + * Unregister a notifier callback that was previously registered with + * yoga_c630_ec_register_notify(). + */ +void yoga_c630_ec_unregister_notify(struct yoga_c630_ec *ec, struct notifier_block *nb) +{ + blocking_notifier_chain_unregister(&ec->notifier_list, nb); +} +EXPORT_SYMBOL_GPL(yoga_c630_ec_unregister_notify); + +static void yoga_c630_aux_release(struct device *dev) +{ + struct auxiliary_device *adev = to_auxiliary_dev(dev); + + kfree(adev); +} + +static void yoga_c630_aux_remove(void *data) +{ + struct auxiliary_device *adev = data; + + auxiliary_device_delete(adev); + auxiliary_device_uninit(adev); +} + +static int yoga_c630_aux_init(struct device *parent, const char *name, + struct yoga_c630_ec *ec) +{ + struct auxiliary_device *adev; + int ret; + + adev = kzalloc(sizeof(*adev), GFP_KERNEL); + if (!adev) + return -ENOMEM; + + adev->name = name; + adev->id = 0; + adev->dev.parent = parent; + adev->dev.release = yoga_c630_aux_release; + adev->dev.platform_data = ec; + + ret = auxiliary_device_init(adev); + if (ret) { + kfree(adev); + return ret; + } + + ret = auxiliary_device_add(adev); + if (ret) { + auxiliary_device_uninit(adev); + return ret; + } + + return devm_add_action_or_reset(parent, yoga_c630_aux_remove, adev); +} + +static int yoga_c630_ec_probe(struct i2c_client *client) +{ + struct yoga_c630_ec *ec; + struct device *dev = &client->dev; + int ret; + + ec = devm_kzalloc(dev, sizeof(*ec), GFP_KERNEL); + if (!ec) + return -ENOMEM; + + mutex_init(&ec->lock); + ec->client = client; + BLOCKING_INIT_NOTIFIER_HEAD(&ec->notifier_list); + + ret = devm_request_threaded_irq(dev, client->irq, + NULL, yoga_c630_ec_intr, + IRQF_ONESHOT, "yoga_c630_ec", ec); + if (ret < 0) + return dev_err_probe(dev, ret, "unable to request irq\n"); + + ret = yoga_c630_aux_init(dev, YOGA_C630_DEV_PSY, ec); + if (ret) + return ret; + + return yoga_c630_aux_init(dev, YOGA_C630_DEV_UCSI, ec); +} + + +static const struct of_device_id yoga_c630_ec_of_match[] = { + { .compatible = "lenovo,yoga-c630-ec" }, + {} +}; +MODULE_DEVICE_TABLE(of, yoga_c630_ec_of_match); + +static const struct i2c_device_id yoga_c630_ec_i2c_id_table[] = { + { "yoga-c630-ec", }, + {} +}; +MODULE_DEVICE_TABLE(i2c, yoga_c630_ec_i2c_id_table); + +static struct i2c_driver yoga_c630_ec_i2c_driver = { + .driver = { + .name = "yoga-c630-ec", + .of_match_table = yoga_c630_ec_of_match + }, + .probe = yoga_c630_ec_probe, + .id_table = yoga_c630_ec_i2c_id_table, +}; +module_i2c_driver(yoga_c630_ec_i2c_driver); + +MODULE_DESCRIPTION("Lenovo Yoga C630 Embedded Controller"); +MODULE_LICENSE("GPL"); diff --git a/include/linux/platform_data/lenovo-yoga-c630.h b/include/linux/platform_data/lenovo-yoga-c630.h new file mode 100644 index 000000000000..2b893dbeb124 --- /dev/null +++ b/include/linux/platform_data/lenovo-yoga-c630.h @@ -0,0 +1,42 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (c) 2022-2024, Linaro Ltd + * Authors: + * Bjorn Andersson + * Dmitry Baryshkov + */ + +#ifndef _LENOVO_YOGA_C630_DATA_H +#define _LENOVO_YOGA_C630_DATA_H + +struct yoga_c630_ec; + +#define YOGA_C630_MOD_NAME "lenovo_yoga_c630" + +#define YOGA_C630_DEV_UCSI "ucsi" +#define YOGA_C630_DEV_PSY "psy" + +int yoga_c630_ec_read8(struct yoga_c630_ec *ec, u8 addr); +int yoga_c630_ec_read16(struct yoga_c630_ec *ec, u8 addr); + +int yoga_c630_ec_register_notify(struct yoga_c630_ec *ec, struct notifier_block *nb); +void yoga_c630_ec_unregister_notify(struct yoga_c630_ec *ec, struct notifier_block *nb); + +#define YOGA_C630_UCSI_WRITE_SIZE 8 +#define YOGA_C630_UCSI_CCI_SIZE 4 +#define YOGA_C630_UCSI_DATA_SIZE 16 +#define YOGA_C630_UCSI_READ_SIZE (YOGA_C630_UCSI_CCI_SIZE + YOGA_C630_UCSI_DATA_SIZE) +u16 yoga_c630_ec_ucsi_get_version(struct yoga_c630_ec *ec); +int yoga_c630_ec_ucsi_write(struct yoga_c630_ec *ec, + const u8 req[YOGA_C630_UCSI_WRITE_SIZE]); +int yoga_c630_ec_ucsi_read(struct yoga_c630_ec *ec, + u8 resp[YOGA_C630_UCSI_READ_SIZE]); + +#define LENOVO_EC_EVENT_USB 0x20 +#define LENOVO_EC_EVENT_UCSI 0x21 +#define LENOVO_EC_EVENT_HPD 0x22 +#define LENOVO_EC_EVENT_BAT_STATUS 0x24 +#define LENOVO_EC_EVENT_BAT_INFO 0x25 +#define LENOVO_EC_EVENT_BAT_ADPT_STATUS 0x37 + +#endif
Lenovo Yoga C630 WOS is a laptop using Snapdragon 850 SoC. Like many laptops it uses embedded controller (EC) to perform various platform operations, including, but not limited, to Type-C port control or power supply handlng. Add the driver for the EC, that creates devices for UCSI and power supply devices. Signed-off-by: Dmitry Baryshkov <dmitry.baryshkov@linaro.org> --- drivers/platform/arm64/Kconfig | 14 ++ drivers/platform/arm64/Makefile | 1 + drivers/platform/arm64/lenovo-yoga-c630.c | 279 +++++++++++++++++++++++++ include/linux/platform_data/lenovo-yoga-c630.h | 42 ++++ 4 files changed, 336 insertions(+)