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,sc8180x-pmic-glink", .data
= (void *)UCSI_NO_PARTNER_PDOS
, },
302 { .compatible
= "qcom,sc8280xp-pmic-glink", .data
= (void *)UCSI_NO_PARTNER_PDOS
, },
303 { .compatible
= "qcom,sm8350-pmic-glink", .data
= (void *)UCSI_NO_PARTNER_PDOS
, },
304 { .compatible
= "qcom,sm8550-pmic-glink", .data
= (void *)UCSI_NO_PARTNER_PDOS
, },
308 static int pmic_glink_ucsi_probe(struct auxiliary_device
*adev
,
309 const struct auxiliary_device_id
*id
)
311 struct pmic_glink_ucsi
*ucsi
;
312 struct device
*dev
= &adev
->dev
;
313 const struct of_device_id
*match
;
314 struct fwnode_handle
*fwnode
;
317 ucsi
= devm_kzalloc(dev
, sizeof(*ucsi
), GFP_KERNEL
);
322 dev_set_drvdata(dev
, ucsi
);
324 INIT_WORK(&ucsi
->notify_work
, pmic_glink_ucsi_notify
);
325 INIT_WORK(&ucsi
->register_work
, pmic_glink_ucsi_register
);
326 init_completion(&ucsi
->read_ack
);
327 init_completion(&ucsi
->write_ack
);
328 init_completion(&ucsi
->sync_ack
);
329 mutex_init(&ucsi
->lock
);
331 ucsi
->ucsi
= ucsi_create(dev
, &pmic_glink_ucsi_ops
);
332 if (IS_ERR(ucsi
->ucsi
))
333 return PTR_ERR(ucsi
->ucsi
);
335 /* Make sure we destroy *after* pmic_glink unregister */
336 ret
= devm_add_action_or_reset(dev
, pmic_glink_ucsi_destroy
, ucsi
);
340 match
= of_match_device(pmic_glink_ucsi_of_quirks
, dev
->parent
);
342 ucsi
->ucsi
->quirks
= (unsigned long)match
->data
;
344 ucsi_set_drvdata(ucsi
->ucsi
, ucsi
);
346 device_for_each_child_node(dev
, fwnode
) {
347 struct gpio_desc
*desc
;
350 ret
= fwnode_property_read_u32(fwnode
, "reg", &port
);
352 dev_err(dev
, "missing reg property of %pOFn\n", fwnode
);
356 if (port
>= PMIC_GLINK_MAX_PORTS
) {
357 dev_warn(dev
, "invalid connector number, ignoring\n");
361 desc
= devm_gpiod_get_index_optional(&adev
->dev
, "orientation", port
, GPIOD_IN
);
363 /* If GPIO isn't found, continue */
368 return dev_err_probe(dev
, PTR_ERR(desc
),
369 "unable to acquire orientation gpio\n");
370 ucsi
->port_orientation
[port
] = desc
;
372 ucsi
->port_switch
[port
] = fwnode_typec_switch_get(fwnode
);
373 if (IS_ERR(ucsi
->port_switch
[port
]))
374 return dev_err_probe(dev
, PTR_ERR(ucsi
->port_switch
[port
]),
375 "failed to acquire orientation-switch\n");
378 ucsi
->client
= devm_pmic_glink_register_client(dev
,
379 PMIC_GLINK_OWNER_USBC
,
380 pmic_glink_ucsi_callback
,
381 pmic_glink_ucsi_pdr_notify
,
383 return PTR_ERR_OR_ZERO(ucsi
->client
);
386 static void pmic_glink_ucsi_remove(struct auxiliary_device
*adev
)
388 struct pmic_glink_ucsi
*ucsi
= dev_get_drvdata(&adev
->dev
);
390 /* Unregister first to stop having read & writes */
391 ucsi_unregister(ucsi
->ucsi
);
394 static const struct auxiliary_device_id pmic_glink_ucsi_id_table
[] = {
395 { .name
= "pmic_glink.ucsi", },
398 MODULE_DEVICE_TABLE(auxiliary
, pmic_glink_ucsi_id_table
);
400 static struct auxiliary_driver pmic_glink_ucsi_driver
= {
401 .name
= "pmic_glink_ucsi",
402 .probe
= pmic_glink_ucsi_probe
,
403 .remove
= pmic_glink_ucsi_remove
,
404 .id_table
= pmic_glink_ucsi_id_table
,
407 module_auxiliary_driver(pmic_glink_ucsi_driver
);
409 MODULE_DESCRIPTION("Qualcomm PMIC GLINK UCSI driver");
410 MODULE_LICENSE("GPL");