292 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Copyright (c) 2022-2024, Linaro Ltd4 * Authors:5 * Bjorn Andersson6 * Dmitry Baryshkov7 */8#include <linux/auxiliary_bus.h>9#include <linux/cleanup.h>10#include <linux/device.h>11#include <linux/err.h>12#include <linux/i2c.h>13#include <linux/irqreturn.h>14#include <linux/lockdep.h>15#include <linux/module.h>16#include <linux/mutex.h>17#include <linux/notifier.h>18#include <linux/slab.h>19#include <linux/platform_data/lenovo-yoga-c630.h>20 21#define LENOVO_EC_RESPONSE_REG 0x0122#define LENOVO_EC_REQUEST_REG 0x0223 24#define LENOVO_EC_UCSI_WRITE 0x2025#define LENOVO_EC_UCSI_READ 0x2126 27#define LENOVO_EC_READ_REG 0xb028#define LENOVO_EC_REQUEST_NEXT_EVENT 0x8429 30#define LENOVO_EC_UCSI_VERSION 0x2031 32struct yoga_c630_ec {33 struct i2c_client *client;34 struct mutex lock;35 struct blocking_notifier_head notifier_list;36};37 38static int yoga_c630_ec_request(struct yoga_c630_ec *ec, u8 *req, size_t req_len,39 u8 *resp, size_t resp_len)40{41 int ret;42 43 lockdep_assert_held(&ec->lock);44 45 ret = i2c_smbus_write_i2c_block_data(ec->client, LENOVO_EC_REQUEST_REG,46 req_len, req);47 if (ret < 0)48 return ret;49 50 return i2c_smbus_read_i2c_block_data(ec->client, LENOVO_EC_RESPONSE_REG,51 resp_len, resp);52}53 54int yoga_c630_ec_read8(struct yoga_c630_ec *ec, u8 addr)55{56 u8 req[2] = { LENOVO_EC_READ_REG, };57 int ret;58 u8 val;59 60 guard(mutex)(&ec->lock);61 62 req[1] = addr;63 ret = yoga_c630_ec_request(ec, req, sizeof(req), &val, 1);64 if (ret < 0)65 return ret;66 67 return val;68}69EXPORT_SYMBOL_GPL(yoga_c630_ec_read8);70 71int yoga_c630_ec_read16(struct yoga_c630_ec *ec, u8 addr)72{73 u8 req[2] = { LENOVO_EC_READ_REG, };74 int ret;75 u8 msb;76 u8 lsb;77 78 /* don't overflow the address */79 if (addr == 0xff)80 return -EINVAL;81 82 guard(mutex)(&ec->lock);83 84 req[1] = addr;85 ret = yoga_c630_ec_request(ec, req, sizeof(req), &lsb, 1);86 if (ret < 0)87 return ret;88 89 req[1] = addr + 1;90 ret = yoga_c630_ec_request(ec, req, sizeof(req), &msb, 1);91 if (ret < 0)92 return ret;93 94 return msb << 8 | lsb;95}96EXPORT_SYMBOL_GPL(yoga_c630_ec_read16);97 98u16 yoga_c630_ec_ucsi_get_version(struct yoga_c630_ec *ec)99{100 u8 req[3] = { 0xb3, 0xf2, };101 int ret;102 u8 msb;103 u8 lsb;104 105 guard(mutex)(&ec->lock);106 107 req[2] = LENOVO_EC_UCSI_VERSION;108 ret = yoga_c630_ec_request(ec, req, sizeof(req), &lsb, 1);109 if (ret < 0)110 return ret;111 112 req[2] = LENOVO_EC_UCSI_VERSION + 1;113 ret = yoga_c630_ec_request(ec, req, sizeof(req), &msb, 1);114 if (ret < 0)115 return ret;116 117 return msb << 8 | lsb;118}119EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_get_version);120 121int yoga_c630_ec_ucsi_write(struct yoga_c630_ec *ec,122 const u8 req[YOGA_C630_UCSI_WRITE_SIZE])123{124 int ret;125 126 mutex_lock(&ec->lock);127 ret = i2c_smbus_write_i2c_block_data(ec->client, LENOVO_EC_UCSI_WRITE,128 YOGA_C630_UCSI_WRITE_SIZE, req);129 mutex_unlock(&ec->lock);130 131 return ret < 0 ? ret : 0;132}133EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_write);134 135int yoga_c630_ec_ucsi_read(struct yoga_c630_ec *ec,136 u8 resp[YOGA_C630_UCSI_READ_SIZE])137{138 int ret;139 140 mutex_lock(&ec->lock);141 ret = i2c_smbus_read_i2c_block_data(ec->client, LENOVO_EC_UCSI_READ,142 YOGA_C630_UCSI_READ_SIZE, resp);143 mutex_unlock(&ec->lock);144 145 return ret < 0 ? ret : 0;146}147EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_read);148 149static irqreturn_t yoga_c630_ec_thread_intr(int irq, void *data)150{151 u8 req[] = { LENOVO_EC_REQUEST_NEXT_EVENT };152 struct yoga_c630_ec *ec = data;153 u8 event;154 int ret;155 156 mutex_lock(&ec->lock);157 ret = yoga_c630_ec_request(ec, req, sizeof(req), &event, 1);158 mutex_unlock(&ec->lock);159 if (ret < 0)160 return IRQ_HANDLED;161 162 blocking_notifier_call_chain(&ec->notifier_list, event, ec);163 164 return IRQ_HANDLED;165}166 167/**168 * yoga_c630_ec_register_notify - Register a notifier callback for EC events.169 * @ec: Yoga C630 EC170 * @nb: Notifier block pointer to register171 *172 * Return: 0 on success or negative error code.173 */174int yoga_c630_ec_register_notify(struct yoga_c630_ec *ec, struct notifier_block *nb)175{176 return blocking_notifier_chain_register(&ec->notifier_list, nb);177}178EXPORT_SYMBOL_GPL(yoga_c630_ec_register_notify);179 180/**181 * yoga_c630_ec_unregister_notify - Unregister notifier callback for EC events.182 * @ec: Yoga C630 EC183 * @nb: Notifier block pointer to unregister184 *185 * Unregister a notifier callback that was previously registered with186 * yoga_c630_ec_register_notify().187 */188void yoga_c630_ec_unregister_notify(struct yoga_c630_ec *ec, struct notifier_block *nb)189{190 blocking_notifier_chain_unregister(&ec->notifier_list, nb);191}192EXPORT_SYMBOL_GPL(yoga_c630_ec_unregister_notify);193 194static void yoga_c630_aux_release(struct device *dev)195{196 struct auxiliary_device *adev = to_auxiliary_dev(dev);197 198 kfree(adev);199}200 201static void yoga_c630_aux_remove(void *data)202{203 struct auxiliary_device *adev = data;204 205 auxiliary_device_delete(adev);206 auxiliary_device_uninit(adev);207}208 209static int yoga_c630_aux_init(struct device *parent, const char *name,210 struct yoga_c630_ec *ec)211{212 struct auxiliary_device *adev;213 int ret;214 215 adev = kzalloc(sizeof(*adev), GFP_KERNEL);216 if (!adev)217 return -ENOMEM;218 219 adev->name = name;220 adev->id = 0;221 adev->dev.parent = parent;222 adev->dev.release = yoga_c630_aux_release;223 adev->dev.platform_data = ec;224 225 ret = auxiliary_device_init(adev);226 if (ret) {227 kfree(adev);228 return ret;229 }230 231 ret = auxiliary_device_add(adev);232 if (ret) {233 auxiliary_device_uninit(adev);234 return ret;235 }236 237 return devm_add_action_or_reset(parent, yoga_c630_aux_remove, adev);238}239 240static int yoga_c630_ec_probe(struct i2c_client *client)241{242 struct device *dev = &client->dev;243 struct yoga_c630_ec *ec;244 int ret;245 246 ec = devm_kzalloc(dev, sizeof(*ec), GFP_KERNEL);247 if (!ec)248 return -ENOMEM;249 250 mutex_init(&ec->lock);251 ec->client = client;252 BLOCKING_INIT_NOTIFIER_HEAD(&ec->notifier_list);253 254 ret = devm_request_threaded_irq(dev, client->irq,255 NULL, yoga_c630_ec_thread_intr,256 IRQF_ONESHOT, "yoga_c630_ec", ec);257 if (ret < 0)258 return dev_err_probe(dev, ret, "unable to request irq\n");259 260 ret = yoga_c630_aux_init(dev, YOGA_C630_DEV_PSY, ec);261 if (ret)262 return ret;263 264 return yoga_c630_aux_init(dev, YOGA_C630_DEV_UCSI, ec);265}266 267 268static const struct of_device_id yoga_c630_ec_of_match[] = {269 { .compatible = "lenovo,yoga-c630-ec" },270 {}271};272MODULE_DEVICE_TABLE(of, yoga_c630_ec_of_match);273 274static const struct i2c_device_id yoga_c630_ec_i2c_id_table[] = {275 { "yoga-c630-ec", },276 {}277};278MODULE_DEVICE_TABLE(i2c, yoga_c630_ec_i2c_id_table);279 280static struct i2c_driver yoga_c630_ec_i2c_driver = {281 .driver = {282 .name = "yoga-c630-ec",283 .of_match_table = yoga_c630_ec_of_match284 },285 .probe = yoga_c630_ec_probe,286 .id_table = yoga_c630_ec_i2c_id_table,287};288module_i2c_driver(yoga_c630_ec_i2c_driver);289 290MODULE_DESCRIPTION("Lenovo Yoga C630 Embedded Controller");291MODULE_LICENSE("GPL");292