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