1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
4 * Copyright (c) 2023, Linaro Ltd
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>
17 #define PMIC_GLINK_MAX_PORTS 2
19 #define UCSI_BUF_SIZE 48
21 #define MSG_TYPE_REQ_RESP 1
22 #define UCSI_BUF_SIZE 48
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
29 struct ucsi_read_buf_req_msg {
30 struct pmic_glink_hdr hdr;
33 struct ucsi_read_buf_resp_msg {
34 struct pmic_glink_hdr hdr;
35 u8 buf[UCSI_BUF_SIZE];
39 struct ucsi_write_buf_req_msg {
40 struct pmic_glink_hdr hdr;
41 u8 buf[UCSI_BUF_SIZE];
45 struct ucsi_write_buf_resp_msg {
46 struct pmic_glink_hdr hdr;
50 struct ucsi_notify_ind_msg {
51 struct pmic_glink_hdr hdr;
57 struct pmic_glink_ucsi {
60 struct gpio_desc *port_orientation[PMIC_GLINK_MAX_PORTS];
61 struct typec_switch *port_switch[PMIC_GLINK_MAX_PORTS];
63 struct pmic_glink_client *client;
66 struct completion read_ack;
67 struct completion write_ack;
68 struct completion sync_ack;
70 struct mutex lock; /* protects concurrent access to PMIC Glink interface */
74 struct work_struct notify_work;
75 struct work_struct register_work;
77 u8 read_buf[UCSI_BUF_SIZE];
80 static int pmic_glink_ucsi_read(struct ucsi *__ucsi, unsigned int offset,
81 void *val, size_t val_len)
83 struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi);
84 struct ucsi_read_buf_req_msg req = {};
88 req.hdr.owner = PMIC_GLINK_OWNER_USBC;
89 req.hdr.type = MSG_TYPE_REQ_RESP;
90 req.hdr.opcode = UC_UCSI_READ_BUF_REQ;
92 mutex_lock(&ucsi->lock);
93 memset(ucsi->read_buf, 0, sizeof(ucsi->read_buf));
94 reinit_completion(&ucsi->read_ack);
96 ret = pmic_glink_send(ucsi->client, &req, sizeof(req));
98 dev_err(ucsi->dev, "failed to send UCSI read request: %d\n", ret);
102 left = wait_for_completion_timeout(&ucsi->read_ack, 5 * HZ);
104 dev_err(ucsi->dev, "timeout waiting for UCSI read response\n");
109 memcpy(val, &ucsi->read_buf[offset], val_len);
113 mutex_unlock(&ucsi->lock);
118 static int pmic_glink_ucsi_locked_write(struct pmic_glink_ucsi *ucsi, unsigned int offset,
119 const void *val, size_t val_len)
121 struct ucsi_write_buf_req_msg req = {};
125 req.hdr.owner = PMIC_GLINK_OWNER_USBC;
126 req.hdr.type = MSG_TYPE_REQ_RESP;
127 req.hdr.opcode = UC_UCSI_WRITE_BUF_REQ;
128 memcpy(&req.buf[offset], val, val_len);
130 reinit_completion(&ucsi->write_ack);
132 ret = pmic_glink_send(ucsi->client, &req, sizeof(req));
134 dev_err(ucsi->dev, "failed to send UCSI write request: %d\n", ret);
138 left = wait_for_completion_timeout(&ucsi->write_ack, 5 * HZ);
140 dev_err(ucsi->dev, "timeout waiting for UCSI write response\n");
147 static int pmic_glink_ucsi_async_write(struct ucsi *__ucsi, unsigned int offset,
148 const void *val, size_t val_len)
150 struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi);
153 mutex_lock(&ucsi->lock);
154 ret = pmic_glink_ucsi_locked_write(ucsi, offset, val, val_len);
155 mutex_unlock(&ucsi->lock);
160 static int pmic_glink_ucsi_sync_write(struct ucsi *__ucsi, unsigned int offset,
161 const void *val, size_t val_len)
163 struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi);
167 /* TOFIX: Downstream forces recipient to CON when UCSI_GET_ALTERNATE_MODES command */
169 mutex_lock(&ucsi->lock);
171 reinit_completion(&ucsi->sync_ack);
172 ucsi->sync_pending = true;
173 ret = pmic_glink_ucsi_locked_write(ucsi, offset, val, val_len);
174 mutex_unlock(&ucsi->lock);
176 left = wait_for_completion_timeout(&ucsi->sync_ack, 5 * HZ);
178 dev_err(ucsi->dev, "timeout waiting for UCSI sync write response\n");
180 } else if (ucsi->sync_val) {
181 dev_err(ucsi->dev, "sync write returned: %d\n", ucsi->sync_val);
184 ucsi->sync_pending = false;
189 static const struct ucsi_operations pmic_glink_ucsi_ops = {
190 .read = pmic_glink_ucsi_read,
191 .sync_write = pmic_glink_ucsi_sync_write,
192 .async_write = pmic_glink_ucsi_async_write
195 static void pmic_glink_ucsi_read_ack(struct pmic_glink_ucsi *ucsi, const void *data, int len)
197 const struct ucsi_read_buf_resp_msg *resp = data;
202 memcpy(ucsi->read_buf, resp->buf, UCSI_BUF_SIZE);
203 complete(&ucsi->read_ack);
206 static void pmic_glink_ucsi_write_ack(struct pmic_glink_ucsi *ucsi, const void *data, int len)
208 const struct ucsi_write_buf_resp_msg *resp = data;
213 ucsi->sync_val = resp->ret_code;
214 complete(&ucsi->write_ack);
217 static void pmic_glink_ucsi_notify(struct work_struct *work)
219 struct pmic_glink_ucsi *ucsi = container_of(work, struct pmic_glink_ucsi, notify_work);
220 unsigned int con_num;
224 ret = pmic_glink_ucsi_read(ucsi->ucsi, UCSI_CCI, &cci, sizeof(cci));
226 dev_err(ucsi->dev, "failed to read CCI on notification\n");
230 con_num = UCSI_CCI_CONNECTOR(cci);
232 if (con_num <= PMIC_GLINK_MAX_PORTS &&
233 ucsi->port_orientation[con_num - 1]) {
234 int orientation = gpiod_get_value(ucsi->port_orientation[con_num - 1]);
236 if (orientation >= 0) {
237 typec_switch_set(ucsi->port_switch[con_num - 1],
238 orientation ? TYPEC_ORIENTATION_REVERSE
239 : TYPEC_ORIENTATION_NORMAL);
243 ucsi_connector_change(ucsi->ucsi, con_num);
246 if (ucsi->sync_pending && cci & UCSI_CCI_BUSY) {
247 ucsi->sync_val = -EBUSY;
248 complete(&ucsi->sync_ack);
249 } else if (ucsi->sync_pending &&
250 (cci & (UCSI_CCI_ACK_COMPLETE | UCSI_CCI_COMMAND_COMPLETE))) {
251 complete(&ucsi->sync_ack);
255 static void pmic_glink_ucsi_register(struct work_struct *work)
257 struct pmic_glink_ucsi *ucsi = container_of(work, struct pmic_glink_ucsi, register_work);
259 ucsi_register(ucsi->ucsi);
262 static void pmic_glink_ucsi_callback(const void *data, size_t len, void *priv)
264 struct pmic_glink_ucsi *ucsi = priv;
265 const struct pmic_glink_hdr *hdr = data;
267 switch (le32_to_cpu(hdr->opcode)) {
268 case UC_UCSI_READ_BUF_REQ:
269 pmic_glink_ucsi_read_ack(ucsi, data, len);
271 case UC_UCSI_WRITE_BUF_REQ:
272 pmic_glink_ucsi_write_ack(ucsi, data, len);
274 case UC_UCSI_USBC_NOTIFY_IND:
275 schedule_work(&ucsi->notify_work);
280 static void pmic_glink_ucsi_pdr_notify(void *priv, int state)
282 struct pmic_glink_ucsi *ucsi = priv;
284 if (state == SERVREG_SERVICE_STATE_UP)
285 schedule_work(&ucsi->register_work);
286 else if (state == SERVREG_SERVICE_STATE_DOWN)
287 ucsi_unregister(ucsi->ucsi);
290 static void pmic_glink_ucsi_destroy(void *data)
292 struct pmic_glink_ucsi *ucsi = data;
294 /* Protect to make sure we're not in a middle of a transaction from a glink callback */
295 mutex_lock(&ucsi->lock);
296 ucsi_destroy(ucsi->ucsi);
297 mutex_unlock(&ucsi->lock);
300 static const struct of_device_id pmic_glink_ucsi_of_quirks[] = {
301 { .compatible = "qcom,qcm6490-pmic-glink", .data = (void *)UCSI_NO_PARTNER_PDOS, },
302 { .compatible = "qcom,sc8180x-pmic-glink", .data = (void *)UCSI_NO_PARTNER_PDOS, },
303 { .compatible = "qcom,sc8280xp-pmic-glink", .data = (void *)UCSI_NO_PARTNER_PDOS, },
304 { .compatible = "qcom,sm8350-pmic-glink", .data = (void *)UCSI_NO_PARTNER_PDOS, },
305 { .compatible = "qcom,sm8550-pmic-glink", .data = (void *)UCSI_NO_PARTNER_PDOS, },
309 static int pmic_glink_ucsi_probe(struct auxiliary_device *adev,
310 const struct auxiliary_device_id *id)
312 struct pmic_glink_ucsi *ucsi;
313 struct device *dev = &adev->dev;
314 const struct of_device_id *match;
315 struct fwnode_handle *fwnode;
318 ucsi = devm_kzalloc(dev, sizeof(*ucsi), GFP_KERNEL);
323 dev_set_drvdata(dev, ucsi);
325 INIT_WORK(&ucsi->notify_work, pmic_glink_ucsi_notify);
326 INIT_WORK(&ucsi->register_work, pmic_glink_ucsi_register);
327 init_completion(&ucsi->read_ack);
328 init_completion(&ucsi->write_ack);
329 init_completion(&ucsi->sync_ack);
330 mutex_init(&ucsi->lock);
332 ucsi->ucsi = ucsi_create(dev, &pmic_glink_ucsi_ops);
333 if (IS_ERR(ucsi->ucsi))
334 return PTR_ERR(ucsi->ucsi);
336 /* Make sure we destroy *after* pmic_glink unregister */
337 ret = devm_add_action_or_reset(dev, pmic_glink_ucsi_destroy, ucsi);
341 match = of_match_device(pmic_glink_ucsi_of_quirks, dev->parent);
343 ucsi->ucsi->quirks = (unsigned long)match->data;
345 ucsi_set_drvdata(ucsi->ucsi, ucsi);
347 device_for_each_child_node(dev, fwnode) {
348 struct gpio_desc *desc;
351 ret = fwnode_property_read_u32(fwnode, "reg", &port);
353 dev_err(dev, "missing reg property of %pOFn\n", fwnode);
357 if (port >= PMIC_GLINK_MAX_PORTS) {
358 dev_warn(dev, "invalid connector number, ignoring\n");
362 desc = devm_gpiod_get_index_optional(&adev->dev, "orientation", port, GPIOD_IN);
364 /* If GPIO isn't found, continue */
369 return dev_err_probe(dev, PTR_ERR(desc),
370 "unable to acquire orientation gpio\n");
371 ucsi->port_orientation[port] = desc;
373 ucsi->port_switch[port] = fwnode_typec_switch_get(fwnode);
374 if (IS_ERR(ucsi->port_switch[port]))
375 return dev_err_probe(dev, PTR_ERR(ucsi->port_switch[port]),
376 "failed to acquire orientation-switch\n");
379 ucsi->client = devm_pmic_glink_register_client(dev,
380 PMIC_GLINK_OWNER_USBC,
381 pmic_glink_ucsi_callback,
382 pmic_glink_ucsi_pdr_notify,
384 return PTR_ERR_OR_ZERO(ucsi->client);
387 static void pmic_glink_ucsi_remove(struct auxiliary_device *adev)
389 struct pmic_glink_ucsi *ucsi = dev_get_drvdata(&adev->dev);
391 /* Unregister first to stop having read & writes */
392 ucsi_unregister(ucsi->ucsi);
395 static const struct auxiliary_device_id pmic_glink_ucsi_id_table[] = {
396 { .name = "pmic_glink.ucsi", },
399 MODULE_DEVICE_TABLE(auxiliary, pmic_glink_ucsi_id_table);
401 static struct auxiliary_driver pmic_glink_ucsi_driver = {
402 .name = "pmic_glink_ucsi",
403 .probe = pmic_glink_ucsi_probe,
404 .remove = pmic_glink_ucsi_remove,
405 .id_table = pmic_glink_ucsi_id_table,
408 module_auxiliary_driver(pmic_glink_ucsi_driver);
410 MODULE_DESCRIPTION("Qualcomm PMIC GLINK UCSI driver");
411 MODULE_LICENSE("GPL");