xref: /linux/drivers/platform/arm64/lenovo-yoga-c630.c (revision a1ff5a7d78a036d6c2178ee5acd6ba4946243800)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2022-2024, Linaro Ltd
4  * Authors:
5  *    Bjorn Andersson
6  *    Dmitry Baryshkov
7  */
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		0x01
22 #define LENOVO_EC_REQUEST_REG		0x02
23 
24 #define LENOVO_EC_UCSI_WRITE		0x20
25 #define LENOVO_EC_UCSI_READ		0x21
26 
27 #define LENOVO_EC_READ_REG		0xb0
28 #define LENOVO_EC_REQUEST_NEXT_EVENT	0x84
29 
30 #define LENOVO_EC_UCSI_VERSION		0x20
31 
32 struct yoga_c630_ec {
33 	struct i2c_client *client;
34 	struct mutex lock;
35 	struct blocking_notifier_head notifier_list;
36 };
37 
yoga_c630_ec_request(struct yoga_c630_ec * ec,u8 * req,size_t req_len,u8 * resp,size_t resp_len)38 static 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 
yoga_c630_ec_read8(struct yoga_c630_ec * ec,u8 addr)54 int 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 }
69 EXPORT_SYMBOL_GPL(yoga_c630_ec_read8);
70 
yoga_c630_ec_read16(struct yoga_c630_ec * ec,u8 addr)71 int 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 }
96 EXPORT_SYMBOL_GPL(yoga_c630_ec_read16);
97 
yoga_c630_ec_ucsi_get_version(struct yoga_c630_ec * ec)98 u16 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 }
119 EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_get_version);
120 
yoga_c630_ec_ucsi_write(struct yoga_c630_ec * ec,const u8 req[YOGA_C630_UCSI_WRITE_SIZE])121 int 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 }
133 EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_write);
134 
yoga_c630_ec_ucsi_read(struct yoga_c630_ec * ec,u8 resp[YOGA_C630_UCSI_READ_SIZE])135 int 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 }
147 EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_read);
148 
yoga_c630_ec_thread_intr(int irq,void * data)149 static 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 EC
170  * @nb: Notifier block pointer to register
171  *
172  * Return: 0 on success or negative error code.
173  */
yoga_c630_ec_register_notify(struct yoga_c630_ec * ec,struct notifier_block * nb)174 int 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 }
178 EXPORT_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 EC
183  * @nb: Notifier block pointer to unregister
184  *
185  * Unregister a notifier callback that was previously registered with
186  * yoga_c630_ec_register_notify().
187  */
yoga_c630_ec_unregister_notify(struct yoga_c630_ec * ec,struct notifier_block * nb)188 void 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 }
192 EXPORT_SYMBOL_GPL(yoga_c630_ec_unregister_notify);
193 
yoga_c630_aux_release(struct device * dev)194 static void yoga_c630_aux_release(struct device *dev)
195 {
196 	struct auxiliary_device *adev = to_auxiliary_dev(dev);
197 
198 	kfree(adev);
199 }
200 
yoga_c630_aux_remove(void * data)201 static 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 
yoga_c630_aux_init(struct device * parent,const char * name,struct yoga_c630_ec * ec)209 static 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 
yoga_c630_ec_probe(struct i2c_client * client)240 static 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 
268 static const struct of_device_id yoga_c630_ec_of_match[] = {
269 	{ .compatible = "lenovo,yoga-c630-ec" },
270 	{}
271 };
272 MODULE_DEVICE_TABLE(of, yoga_c630_ec_of_match);
273 
274 static const struct i2c_device_id yoga_c630_ec_i2c_id_table[] = {
275 	{ "yoga-c630-ec", },
276 	{}
277 };
278 MODULE_DEVICE_TABLE(i2c, yoga_c630_ec_i2c_id_table);
279 
280 static struct i2c_driver yoga_c630_ec_i2c_driver = {
281 	.driver = {
282 		.name = "yoga-c630-ec",
283 		.of_match_table = yoga_c630_ec_of_match
284 	},
285 	.probe = yoga_c630_ec_probe,
286 	.id_table = yoga_c630_ec_i2c_id_table,
287 };
288 module_i2c_driver(yoga_c630_ec_i2c_driver);
289 
290 MODULE_DESCRIPTION("Lenovo Yoga C630 Embedded Controller");
291 MODULE_LICENSE("GPL");
292