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	2
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 	struct typec_switch *port_switch[PMIC_GLINK_MAX_PORTS];
62 
63 	struct pmic_glink_client *client;
64 
65 	struct ucsi *ucsi;
66 	struct completion read_ack;
67 	struct completion write_ack;
68 	struct completion sync_ack;
69 	bool sync_pending;
70 	struct mutex lock;	/* protects concurrent access to PMIC Glink interface */
71 
72 	int sync_val;
73 
74 	struct work_struct notify_work;
75 	struct work_struct register_work;
76 
77 	u8 read_buf[UCSI_BUF_SIZE];
78 };
79 
pmic_glink_ucsi_read(struct ucsi * __ucsi,unsigned int offset,void * val,size_t val_len)80 static int pmic_glink_ucsi_read(struct ucsi *__ucsi, unsigned int offset,
81 				void *val, size_t val_len)
82 {
83 	struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi);
84 	struct ucsi_read_buf_req_msg req = {};
85 	unsigned long left;
86 	int ret;
87 
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;
91 
92 	mutex_lock(&ucsi->lock);
93 	memset(ucsi->read_buf, 0, sizeof(ucsi->read_buf));
94 	reinit_completion(&ucsi->read_ack);
95 
96 	ret = pmic_glink_send(ucsi->client, &req, sizeof(req));
97 	if (ret < 0) {
98 		dev_err(ucsi->dev, "failed to send UCSI read request: %d\n", ret);
99 		goto out_unlock;
100 	}
101 
102 	left = wait_for_completion_timeout(&ucsi->read_ack, 5 * HZ);
103 	if (!left) {
104 		dev_err(ucsi->dev, "timeout waiting for UCSI read response\n");
105 		ret = -ETIMEDOUT;
106 		goto out_unlock;
107 	}
108 
109 	memcpy(val, &ucsi->read_buf[offset], val_len);
110 	ret = 0;
111 
112 out_unlock:
113 	mutex_unlock(&ucsi->lock);
114 
115 	return ret;
116 }
117 
pmic_glink_ucsi_locked_write(struct pmic_glink_ucsi * ucsi,unsigned int offset,const void * val,size_t val_len)118 static int pmic_glink_ucsi_locked_write(struct pmic_glink_ucsi *ucsi, unsigned int offset,
119 					const void *val, size_t val_len)
120 {
121 	struct ucsi_write_buf_req_msg req = {};
122 	unsigned long left;
123 	int ret;
124 
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);
129 
130 	reinit_completion(&ucsi->write_ack);
131 
132 	ret = pmic_glink_send(ucsi->client, &req, sizeof(req));
133 	if (ret < 0) {
134 		dev_err(ucsi->dev, "failed to send UCSI write request: %d\n", ret);
135 		return ret;
136 	}
137 
138 	left = wait_for_completion_timeout(&ucsi->write_ack, 5 * HZ);
139 	if (!left) {
140 		dev_err(ucsi->dev, "timeout waiting for UCSI write response\n");
141 		return -ETIMEDOUT;
142 	}
143 
144 	return 0;
145 }
146 
pmic_glink_ucsi_async_write(struct ucsi * __ucsi,unsigned int offset,const void * val,size_t val_len)147 static int pmic_glink_ucsi_async_write(struct ucsi *__ucsi, unsigned int offset,
148 				       const void *val, size_t val_len)
149 {
150 	struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi);
151 	int ret;
152 
153 	mutex_lock(&ucsi->lock);
154 	ret = pmic_glink_ucsi_locked_write(ucsi, offset, val, val_len);
155 	mutex_unlock(&ucsi->lock);
156 
157 	return ret;
158 }
159 
pmic_glink_ucsi_sync_write(struct ucsi * __ucsi,unsigned int offset,const void * val,size_t val_len)160 static int pmic_glink_ucsi_sync_write(struct ucsi *__ucsi, unsigned int offset,
161 				      const void *val, size_t val_len)
162 {
163 	struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi);
164 	unsigned long left;
165 	int ret;
166 
167 	/* TOFIX: Downstream forces recipient to CON when UCSI_GET_ALTERNATE_MODES command */
168 
169 	mutex_lock(&ucsi->lock);
170 	ucsi->sync_val = 0;
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);
175 
176 	left = wait_for_completion_timeout(&ucsi->sync_ack, 5 * HZ);
177 	if (!left) {
178 		dev_err(ucsi->dev, "timeout waiting for UCSI sync write response\n");
179 		ret = -ETIMEDOUT;
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 
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
193 };
194 
pmic_glink_ucsi_read_ack(struct pmic_glink_ucsi * ucsi,const void * data,int len)195 static void pmic_glink_ucsi_read_ack(struct pmic_glink_ucsi *ucsi, const void *data, int len)
196 {
197 	const struct ucsi_read_buf_resp_msg *resp = data;
198 
199 	if (resp->ret_code)
200 		return;
201 
202 	memcpy(ucsi->read_buf, resp->buf, UCSI_BUF_SIZE);
203 	complete(&ucsi->read_ack);
204 }
205 
pmic_glink_ucsi_write_ack(struct pmic_glink_ucsi * ucsi,const void * data,int len)206 static void pmic_glink_ucsi_write_ack(struct pmic_glink_ucsi *ucsi, const void *data, int len)
207 {
208 	const struct ucsi_write_buf_resp_msg *resp = data;
209 
210 	if (resp->ret_code)
211 		return;
212 
213 	ucsi->sync_val = resp->ret_code;
214 	complete(&ucsi->write_ack);
215 }
216 
pmic_glink_ucsi_notify(struct work_struct * work)217 static void pmic_glink_ucsi_notify(struct work_struct *work)
218 {
219 	struct pmic_glink_ucsi *ucsi = container_of(work, struct pmic_glink_ucsi, notify_work);
220 	unsigned int con_num;
221 	u32 cci;
222 	int ret;
223 
224 	ret = pmic_glink_ucsi_read(ucsi->ucsi, UCSI_CCI, &cci, sizeof(cci));
225 	if (ret) {
226 		dev_err(ucsi->dev, "failed to read CCI on notification\n");
227 		return;
228 	}
229 
230 	con_num = UCSI_CCI_CONNECTOR(cci);
231 	if (con_num) {
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]);
235 
236 			if (orientation >= 0) {
237 				typec_switch_set(ucsi->port_switch[con_num - 1],
238 						 orientation ? TYPEC_ORIENTATION_REVERSE
239 							     : TYPEC_ORIENTATION_NORMAL);
240 			}
241 		}
242 
243 		ucsi_connector_change(ucsi->ucsi, con_num);
244 	}
245 
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);
252 	}
253 }
254 
pmic_glink_ucsi_register(struct work_struct * work)255 static void pmic_glink_ucsi_register(struct work_struct *work)
256 {
257 	struct pmic_glink_ucsi *ucsi = container_of(work, struct pmic_glink_ucsi, register_work);
258 
259 	ucsi_register(ucsi->ucsi);
260 }
261 
pmic_glink_ucsi_callback(const void * data,size_t len,void * priv)262 static void pmic_glink_ucsi_callback(const void *data, size_t len, void *priv)
263 {
264 	struct pmic_glink_ucsi *ucsi = priv;
265 	const struct pmic_glink_hdr *hdr = data;
266 
267 	switch (le32_to_cpu(hdr->opcode)) {
268 	case UC_UCSI_READ_BUF_REQ:
269 		pmic_glink_ucsi_read_ack(ucsi, data, len);
270 		break;
271 	case UC_UCSI_WRITE_BUF_REQ:
272 		pmic_glink_ucsi_write_ack(ucsi, data, len);
273 		break;
274 	case UC_UCSI_USBC_NOTIFY_IND:
275 		schedule_work(&ucsi->notify_work);
276 		break;
277 	};
278 }
279 
pmic_glink_ucsi_pdr_notify(void * priv,int state)280 static void pmic_glink_ucsi_pdr_notify(void *priv, int state)
281 {
282 	struct pmic_glink_ucsi *ucsi = priv;
283 
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);
288 }
289 
pmic_glink_ucsi_destroy(void * data)290 static void pmic_glink_ucsi_destroy(void *data)
291 {
292 	struct pmic_glink_ucsi *ucsi = data;
293 
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);
298 }
299 
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, },
305 	{}
306 };
307 
pmic_glink_ucsi_probe(struct auxiliary_device * adev,const struct auxiliary_device_id * id)308 static int pmic_glink_ucsi_probe(struct auxiliary_device *adev,
309 				 const struct auxiliary_device_id *id)
310 {
311 	struct pmic_glink_ucsi *ucsi;
312 	struct device *dev = &adev->dev;
313 	const struct of_device_id *match;
314 	struct fwnode_handle *fwnode;
315 	int ret;
316 
317 	ucsi = devm_kzalloc(dev, sizeof(*ucsi), GFP_KERNEL);
318 	if (!ucsi)
319 		return -ENOMEM;
320 
321 	ucsi->dev = dev;
322 	dev_set_drvdata(dev, ucsi);
323 
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);
330 
331 	ucsi->ucsi = ucsi_create(dev, &pmic_glink_ucsi_ops);
332 	if (IS_ERR(ucsi->ucsi))
333 		return PTR_ERR(ucsi->ucsi);
334 
335 	/* Make sure we destroy *after* pmic_glink unregister */
336 	ret = devm_add_action_or_reset(dev, pmic_glink_ucsi_destroy, ucsi);
337 	if (ret)
338 		return ret;
339 
340 	match = of_match_device(pmic_glink_ucsi_of_quirks, dev->parent);
341 	if (match)
342 		ucsi->ucsi->quirks = (unsigned long)match->data;
343 
344 	ucsi_set_drvdata(ucsi->ucsi, ucsi);
345 
346 	device_for_each_child_node(dev, fwnode) {
347 		struct gpio_desc *desc;
348 		u32 port;
349 
350 		ret = fwnode_property_read_u32(fwnode, "reg", &port);
351 		if (ret < 0) {
352 			dev_err(dev, "missing reg property of %pOFn\n", fwnode);
353 			return ret;
354 		}
355 
356 		if (port >= PMIC_GLINK_MAX_PORTS) {
357 			dev_warn(dev, "invalid connector number, ignoring\n");
358 			continue;
359 		}
360 
361 		desc = devm_gpiod_get_index_optional(&adev->dev, "orientation", port, GPIOD_IN);
362 
363 		/* If GPIO isn't found, continue */
364 		if (!desc)
365 			continue;
366 
367 		if (IS_ERR(desc))
368 			return dev_err_probe(dev, PTR_ERR(desc),
369 					     "unable to acquire orientation gpio\n");
370 		ucsi->port_orientation[port] = desc;
371 
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");
376 	}
377 
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,
382 						       ucsi);
383 	return PTR_ERR_OR_ZERO(ucsi->client);
384 }
385 
pmic_glink_ucsi_remove(struct auxiliary_device * adev)386 static void pmic_glink_ucsi_remove(struct auxiliary_device *adev)
387 {
388 	struct pmic_glink_ucsi *ucsi = dev_get_drvdata(&adev->dev);
389 
390 	/* Unregister first to stop having read & writes */
391 	ucsi_unregister(ucsi->ucsi);
392 }
393 
394 static const struct auxiliary_device_id pmic_glink_ucsi_id_table[] = {
395 	{ .name = "pmic_glink.ucsi", },
396 	{},
397 };
398 MODULE_DEVICE_TABLE(auxiliary, pmic_glink_ucsi_id_table);
399 
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,
405 };
406 
407 module_auxiliary_driver(pmic_glink_ucsi_driver);
408 
409 MODULE_DESCRIPTION("Qualcomm PMIC GLINK UCSI driver");
410 MODULE_LICENSE("GPL");
411