1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
4 * Copyright (c) 2023, Linaro Ltd
5 */
6 #include <linux/auxiliary_bus.h>
7 #include <linux/module.h>
8 #include <linux/mutex.h>
9 #include <linux/property.h>
10 #include <linux/soc/qcom/pdr.h>
11 #include <linux/usb/typec_mux.h>
12 #include <linux/gpio/consumer.h>
13 #include <linux/soc/qcom/pmic_glink.h>
14 #include "ucsi.h"
15
16 #define PMIC_GLINK_MAX_PORTS 2
17
18 #define UCSI_BUF_SIZE 48
19
20 #define MSG_TYPE_REQ_RESP 1
21 #define UCSI_BUF_SIZE 48
22
23 #define UC_NOTIFY_RECEIVER_UCSI 0x0
24 #define UC_UCSI_READ_BUF_REQ 0x11
25 #define UC_UCSI_WRITE_BUF_REQ 0x12
26 #define UC_UCSI_USBC_NOTIFY_IND 0x13
27
28 struct ucsi_read_buf_req_msg {
29 struct pmic_glink_hdr hdr;
30 };
31
32 struct ucsi_read_buf_resp_msg {
33 struct pmic_glink_hdr hdr;
34 u8 buf[UCSI_BUF_SIZE];
35 u32 ret_code;
36 };
37
38 struct ucsi_write_buf_req_msg {
39 struct pmic_glink_hdr hdr;
40 u8 buf[UCSI_BUF_SIZE];
41 u32 reserved;
42 };
43
44 struct ucsi_write_buf_resp_msg {
45 struct pmic_glink_hdr hdr;
46 u32 ret_code;
47 };
48
49 struct ucsi_notify_ind_msg {
50 struct pmic_glink_hdr hdr;
51 u32 notification;
52 u32 receiver;
53 u32 reserved;
54 };
55
56 struct pmic_glink_ucsi {
57 struct device *dev;
58
59 struct gpio_desc *port_orientation[PMIC_GLINK_MAX_PORTS];
60 struct typec_switch *port_switch[PMIC_GLINK_MAX_PORTS];
61
62 struct pmic_glink_client *client;
63
64 struct ucsi *ucsi;
65 struct completion read_ack;
66 struct completion write_ack;
67 struct completion sync_ack;
68 bool sync_pending;
69 struct mutex lock; /* protects concurrent access to PMIC Glink interface */
70
71 int sync_val;
72
73 struct work_struct notify_work;
74 struct work_struct register_work;
75
76 u8 read_buf[UCSI_BUF_SIZE];
77 };
78
pmic_glink_ucsi_read(struct ucsi * __ucsi,unsigned int offset,void * val,size_t val_len)79 static int pmic_glink_ucsi_read(struct ucsi *__ucsi, unsigned int offset,
80 void *val, size_t val_len)
81 {
82 struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi);
83 struct ucsi_read_buf_req_msg req = {};
84 unsigned long left;
85 int ret;
86
87 req.hdr.owner = PMIC_GLINK_OWNER_USBC;
88 req.hdr.type = MSG_TYPE_REQ_RESP;
89 req.hdr.opcode = UC_UCSI_READ_BUF_REQ;
90
91 mutex_lock(&ucsi->lock);
92 memset(ucsi->read_buf, 0, sizeof(ucsi->read_buf));
93 reinit_completion(&ucsi->read_ack);
94
95 ret = pmic_glink_send(ucsi->client, &req, sizeof(req));
96 if (ret < 0) {
97 dev_err(ucsi->dev, "failed to send UCSI read request: %d\n", ret);
98 goto out_unlock;
99 }
100
101 left = wait_for_completion_timeout(&ucsi->read_ack, 5 * HZ);
102 if (!left) {
103 dev_err(ucsi->dev, "timeout waiting for UCSI read response\n");
104 ret = -ETIMEDOUT;
105 goto out_unlock;
106 }
107
108 memcpy(val, &ucsi->read_buf[offset], val_len);
109 ret = 0;
110
111 out_unlock:
112 mutex_unlock(&ucsi->lock);
113
114 return ret;
115 }
116
pmic_glink_ucsi_locked_write(struct pmic_glink_ucsi * ucsi,unsigned int offset,const void * val,size_t val_len)117 static int pmic_glink_ucsi_locked_write(struct pmic_glink_ucsi *ucsi, unsigned int offset,
118 const void *val, size_t val_len)
119 {
120 struct ucsi_write_buf_req_msg req = {};
121 unsigned long left;
122 int ret;
123
124 req.hdr.owner = PMIC_GLINK_OWNER_USBC;
125 req.hdr.type = MSG_TYPE_REQ_RESP;
126 req.hdr.opcode = UC_UCSI_WRITE_BUF_REQ;
127 memcpy(&req.buf[offset], val, val_len);
128
129 reinit_completion(&ucsi->write_ack);
130
131 ret = pmic_glink_send(ucsi->client, &req, sizeof(req));
132 if (ret < 0) {
133 dev_err(ucsi->dev, "failed to send UCSI write request: %d\n", ret);
134 return ret;
135 }
136
137 left = wait_for_completion_timeout(&ucsi->write_ack, 5 * HZ);
138 if (!left) {
139 dev_err(ucsi->dev, "timeout waiting for UCSI write response\n");
140 return -ETIMEDOUT;
141 }
142
143 return 0;
144 }
145
pmic_glink_ucsi_async_write(struct ucsi * __ucsi,unsigned int offset,const void * val,size_t val_len)146 static int pmic_glink_ucsi_async_write(struct ucsi *__ucsi, unsigned int offset,
147 const void *val, size_t val_len)
148 {
149 struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi);
150 int ret;
151
152 mutex_lock(&ucsi->lock);
153 ret = pmic_glink_ucsi_locked_write(ucsi, offset, val, val_len);
154 mutex_unlock(&ucsi->lock);
155
156 return ret;
157 }
158
pmic_glink_ucsi_sync_write(struct ucsi * __ucsi,unsigned int offset,const void * val,size_t val_len)159 static int pmic_glink_ucsi_sync_write(struct ucsi *__ucsi, unsigned int offset,
160 const void *val, size_t val_len)
161 {
162 struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi);
163 unsigned long left;
164 int ret;
165
166 /* TOFIX: Downstream forces recipient to CON when UCSI_GET_ALTERNATE_MODES command */
167
168 mutex_lock(&ucsi->lock);
169 ucsi->sync_val = 0;
170 reinit_completion(&ucsi->sync_ack);
171 ucsi->sync_pending = true;
172 ret = pmic_glink_ucsi_locked_write(ucsi, offset, val, val_len);
173 mutex_unlock(&ucsi->lock);
174
175 left = wait_for_completion_timeout(&ucsi->sync_ack, 5 * HZ);
176 if (!left) {
177 dev_err(ucsi->dev, "timeout waiting for UCSI sync write response\n");
178 /* return 0 here and let core UCSI code handle the CCI_BUSY */
179 ret = 0;
180 } else if (ucsi->sync_val) {
181 dev_err(ucsi->dev, "sync write returned: %d\n", ucsi->sync_val);
182 }
183
184 ucsi->sync_pending = false;
185
186 return ret;
187 }
188
pmic_glink_ucsi_update_connector(struct ucsi_connector * con)189 static void pmic_glink_ucsi_update_connector(struct ucsi_connector *con)
190 {
191 struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(con->ucsi);
192
193 if (con->num > PMIC_GLINK_MAX_PORTS ||
194 !ucsi->port_orientation[con->num - 1])
195 return;
196
197 con->typec_cap.orientation_aware = true;
198 }
199
pmic_glink_ucsi_connector_status(struct ucsi_connector * con)200 static void pmic_glink_ucsi_connector_status(struct ucsi_connector *con)
201 {
202 struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(con->ucsi);
203 int orientation;
204
205 if (con->num > PMIC_GLINK_MAX_PORTS ||
206 !ucsi->port_orientation[con->num - 1])
207 return;
208
209 orientation = gpiod_get_value(ucsi->port_orientation[con->num - 1]);
210 if (orientation >= 0) {
211 typec_switch_set(ucsi->port_switch[con->num - 1],
212 orientation ? TYPEC_ORIENTATION_REVERSE
213 : TYPEC_ORIENTATION_NORMAL);
214 }
215 }
216
217 static const struct ucsi_operations pmic_glink_ucsi_ops = {
218 .read = pmic_glink_ucsi_read,
219 .sync_write = pmic_glink_ucsi_sync_write,
220 .async_write = pmic_glink_ucsi_async_write,
221 .update_connector = pmic_glink_ucsi_update_connector,
222 .connector_status = pmic_glink_ucsi_connector_status,
223 };
224
pmic_glink_ucsi_read_ack(struct pmic_glink_ucsi * ucsi,const void * data,int len)225 static void pmic_glink_ucsi_read_ack(struct pmic_glink_ucsi *ucsi, const void *data, int len)
226 {
227 const struct ucsi_read_buf_resp_msg *resp = data;
228
229 if (resp->ret_code)
230 return;
231
232 memcpy(ucsi->read_buf, resp->buf, UCSI_BUF_SIZE);
233 complete(&ucsi->read_ack);
234 }
235
pmic_glink_ucsi_write_ack(struct pmic_glink_ucsi * ucsi,const void * data,int len)236 static void pmic_glink_ucsi_write_ack(struct pmic_glink_ucsi *ucsi, const void *data, int len)
237 {
238 const struct ucsi_write_buf_resp_msg *resp = data;
239
240 if (resp->ret_code)
241 return;
242
243 ucsi->sync_val = resp->ret_code;
244 complete(&ucsi->write_ack);
245 }
246
pmic_glink_ucsi_notify(struct work_struct * work)247 static void pmic_glink_ucsi_notify(struct work_struct *work)
248 {
249 struct pmic_glink_ucsi *ucsi = container_of(work, struct pmic_glink_ucsi, notify_work);
250 unsigned int con_num;
251 u32 cci;
252 int ret;
253
254 ret = pmic_glink_ucsi_read(ucsi->ucsi, UCSI_CCI, &cci, sizeof(cci));
255 if (ret) {
256 dev_err(ucsi->dev, "failed to read CCI on notification\n");
257 return;
258 }
259
260 con_num = UCSI_CCI_CONNECTOR(cci);
261 if (con_num)
262 ucsi_connector_change(ucsi->ucsi, con_num);
263
264 if (ucsi->sync_pending &&
265 (cci & (UCSI_CCI_ACK_COMPLETE | UCSI_CCI_COMMAND_COMPLETE))) {
266 complete(&ucsi->sync_ack);
267 }
268 }
269
pmic_glink_ucsi_register(struct work_struct * work)270 static void pmic_glink_ucsi_register(struct work_struct *work)
271 {
272 struct pmic_glink_ucsi *ucsi = container_of(work, struct pmic_glink_ucsi, register_work);
273
274 ucsi_register(ucsi->ucsi);
275 }
276
pmic_glink_ucsi_callback(const void * data,size_t len,void * priv)277 static void pmic_glink_ucsi_callback(const void *data, size_t len, void *priv)
278 {
279 struct pmic_glink_ucsi *ucsi = priv;
280 const struct pmic_glink_hdr *hdr = data;
281
282 switch (le32_to_cpu(hdr->opcode)) {
283 case UC_UCSI_READ_BUF_REQ:
284 pmic_glink_ucsi_read_ack(ucsi, data, len);
285 break;
286 case UC_UCSI_WRITE_BUF_REQ:
287 pmic_glink_ucsi_write_ack(ucsi, data, len);
288 break;
289 case UC_UCSI_USBC_NOTIFY_IND:
290 schedule_work(&ucsi->notify_work);
291 break;
292 };
293 }
294
pmic_glink_ucsi_pdr_notify(void * priv,int state)295 static void pmic_glink_ucsi_pdr_notify(void *priv, int state)
296 {
297 struct pmic_glink_ucsi *ucsi = priv;
298
299 if (state == SERVREG_SERVICE_STATE_UP)
300 schedule_work(&ucsi->register_work);
301 else if (state == SERVREG_SERVICE_STATE_DOWN)
302 ucsi_unregister(ucsi->ucsi);
303 }
304
pmic_glink_ucsi_destroy(void * data)305 static void pmic_glink_ucsi_destroy(void *data)
306 {
307 struct pmic_glink_ucsi *ucsi = data;
308
309 /* Protect to make sure we're not in a middle of a transaction from a glink callback */
310 mutex_lock(&ucsi->lock);
311 ucsi_destroy(ucsi->ucsi);
312 mutex_unlock(&ucsi->lock);
313 }
314
pmic_glink_ucsi_probe(struct auxiliary_device * adev,const struct auxiliary_device_id * id)315 static int pmic_glink_ucsi_probe(struct auxiliary_device *adev,
316 const struct auxiliary_device_id *id)
317 {
318 struct pmic_glink_ucsi *ucsi;
319 struct device *dev = &adev->dev;
320 struct fwnode_handle *fwnode;
321 int ret;
322
323 ucsi = devm_kzalloc(dev, sizeof(*ucsi), GFP_KERNEL);
324 if (!ucsi)
325 return -ENOMEM;
326
327 ucsi->dev = dev;
328 dev_set_drvdata(dev, ucsi);
329
330 INIT_WORK(&ucsi->notify_work, pmic_glink_ucsi_notify);
331 INIT_WORK(&ucsi->register_work, pmic_glink_ucsi_register);
332 init_completion(&ucsi->read_ack);
333 init_completion(&ucsi->write_ack);
334 init_completion(&ucsi->sync_ack);
335 mutex_init(&ucsi->lock);
336
337 ucsi->ucsi = ucsi_create(dev, &pmic_glink_ucsi_ops);
338 if (IS_ERR(ucsi->ucsi))
339 return PTR_ERR(ucsi->ucsi);
340
341 /* Make sure we destroy *after* pmic_glink unregister */
342 ret = devm_add_action_or_reset(dev, pmic_glink_ucsi_destroy, ucsi);
343 if (ret)
344 return ret;
345
346 ucsi_set_drvdata(ucsi->ucsi, ucsi);
347
348 device_for_each_child_node(dev, fwnode) {
349 struct gpio_desc *desc;
350 u32 port;
351
352 ret = fwnode_property_read_u32(fwnode, "reg", &port);
353 if (ret < 0) {
354 dev_err(dev, "missing reg property of %pOFn\n", fwnode);
355 fwnode_handle_put(fwnode);
356 return ret;
357 }
358
359 if (port >= PMIC_GLINK_MAX_PORTS) {
360 dev_warn(dev, "invalid connector number, ignoring\n");
361 continue;
362 }
363
364 desc = devm_gpiod_get_index_optional(&adev->dev, "orientation", port, GPIOD_IN);
365
366 /* If GPIO isn't found, continue */
367 if (!desc)
368 continue;
369
370 if (IS_ERR(desc)) {
371 fwnode_handle_put(fwnode);
372 return dev_err_probe(dev, PTR_ERR(desc),
373 "unable to acquire orientation gpio\n");
374 }
375 ucsi->port_orientation[port] = desc;
376
377 ucsi->port_switch[port] = fwnode_typec_switch_get(fwnode);
378 if (IS_ERR(ucsi->port_switch[port]))
379 return dev_err_probe(dev, PTR_ERR(ucsi->port_switch[port]),
380 "failed to acquire orientation-switch\n");
381 }
382
383 ucsi->client = devm_pmic_glink_client_alloc(dev, PMIC_GLINK_OWNER_USBC,
384 pmic_glink_ucsi_callback,
385 pmic_glink_ucsi_pdr_notify,
386 ucsi);
387 if (IS_ERR(ucsi->client))
388 return PTR_ERR(ucsi->client);
389
390 pmic_glink_client_register(ucsi->client);
391
392 return 0;
393 }
394
pmic_glink_ucsi_remove(struct auxiliary_device * adev)395 static void pmic_glink_ucsi_remove(struct auxiliary_device *adev)
396 {
397 struct pmic_glink_ucsi *ucsi = dev_get_drvdata(&adev->dev);
398
399 /* Unregister first to stop having read & writes */
400 ucsi_unregister(ucsi->ucsi);
401 }
402
403 static const struct auxiliary_device_id pmic_glink_ucsi_id_table[] = {
404 { .name = "pmic_glink.ucsi", },
405 {},
406 };
407 MODULE_DEVICE_TABLE(auxiliary, pmic_glink_ucsi_id_table);
408
409 static struct auxiliary_driver pmic_glink_ucsi_driver = {
410 .name = "pmic_glink_ucsi",
411 .probe = pmic_glink_ucsi_probe,
412 .remove = pmic_glink_ucsi_remove,
413 .id_table = pmic_glink_ucsi_id_table,
414 };
415
416 module_auxiliary_driver(pmic_glink_ucsi_driver);
417
418 MODULE_DESCRIPTION("Qualcomm PMIC GLINK UCSI driver");
419 MODULE_LICENSE("GPL");
420