1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
4 * Copyright (c) 2022, Linaro Ltd
5 */
6 #include <linux/auxiliary_bus.h>
7 #include <linux/bitfield.h>
8 #include <linux/module.h>
9 #include <linux/of.h>
10 #include <linux/of_device.h>
11 #include <linux/mutex.h>
12 #include <linux/property.h>
13 #include <linux/soc/qcom/pdr.h>
14 #include <drm/bridge/aux-bridge.h>
15
16 #include <linux/usb/typec_altmode.h>
17 #include <linux/usb/typec_dp.h>
18 #include <linux/usb/typec_mux.h>
19 #include <linux/usb/typec_retimer.h>
20
21 #include <linux/soc/qcom/pmic_glink.h>
22
23 #define PMIC_GLINK_MAX_PORTS 3
24
25 #define USBC_SC8180X_NOTIFY_IND 0x13
26 #define USBC_CMD_WRITE_REQ 0x15
27 #define USBC_NOTIFY_IND 0x16
28
29 #define ALTMODE_PAN_EN 0x10
30 #define ALTMODE_PAN_ACK 0x11
31
32 struct usbc_write_req {
33 struct pmic_glink_hdr hdr;
34 __le32 cmd;
35 __le32 arg;
36 __le32 reserved;
37 };
38
39 #define NOTIFY_PAYLOAD_SIZE 16
40 struct usbc_notify {
41 struct pmic_glink_hdr hdr;
42 char payload[NOTIFY_PAYLOAD_SIZE];
43 u32 reserved;
44 };
45
46 struct usbc_sc8180x_notify {
47 struct pmic_glink_hdr hdr;
48 __le32 notification;
49 __le32 reserved[2];
50 };
51
52 enum pmic_glink_altmode_pin_assignment {
53 DPAM_HPD_OUT,
54 DPAM_HPD_A,
55 DPAM_HPD_B,
56 DPAM_HPD_C,
57 DPAM_HPD_D,
58 DPAM_HPD_E,
59 DPAM_HPD_F,
60 };
61
62 struct pmic_glink_altmode;
63
64 #define work_to_altmode_port(w) container_of((w), struct pmic_glink_altmode_port, work)
65
66 struct pmic_glink_altmode_port {
67 struct pmic_glink_altmode *altmode;
68 unsigned int index;
69
70 struct typec_switch *typec_switch;
71 struct typec_mux *typec_mux;
72 struct typec_mux_state state;
73 struct typec_retimer *typec_retimer;
74 struct typec_retimer_state retimer_state;
75 struct typec_altmode dp_alt;
76
77 struct work_struct work;
78
79 struct auxiliary_device *bridge;
80
81 enum typec_orientation orientation;
82 u16 svid;
83 u8 dp_data;
84 u8 mode;
85 u8 hpd_state;
86 u8 hpd_irq;
87 };
88
89 #define work_to_altmode(w) container_of((w), struct pmic_glink_altmode, enable_work)
90
91 struct pmic_glink_altmode {
92 struct device *dev;
93
94 unsigned int owner_id;
95
96 /* To synchronize WRITE_REQ acks */
97 struct mutex lock;
98
99 struct completion pan_ack;
100 struct pmic_glink_client *client;
101
102 struct work_struct enable_work;
103
104 struct pmic_glink_altmode_port ports[PMIC_GLINK_MAX_PORTS];
105 };
106
pmic_glink_altmode_request(struct pmic_glink_altmode * altmode,u32 cmd,u32 arg)107 static int pmic_glink_altmode_request(struct pmic_glink_altmode *altmode, u32 cmd, u32 arg)
108 {
109 struct usbc_write_req req = {};
110 unsigned long left;
111 int ret;
112
113 /*
114 * The USBC_CMD_WRITE_REQ ack doesn't identify the request, so wait for
115 * one ack at a time.
116 */
117 mutex_lock(&altmode->lock);
118
119 req.hdr.owner = cpu_to_le32(altmode->owner_id);
120 req.hdr.type = cpu_to_le32(PMIC_GLINK_REQ_RESP);
121 req.hdr.opcode = cpu_to_le32(USBC_CMD_WRITE_REQ);
122 req.cmd = cpu_to_le32(cmd);
123 req.arg = cpu_to_le32(arg);
124
125 ret = pmic_glink_send(altmode->client, &req, sizeof(req));
126 if (ret) {
127 dev_err(altmode->dev, "failed to send altmode request: %#x (%d)\n", cmd, ret);
128 goto out_unlock;
129 }
130
131 left = wait_for_completion_timeout(&altmode->pan_ack, 5 * HZ);
132 if (!left) {
133 dev_err(altmode->dev, "timeout waiting for altmode request ack for: %#x\n", cmd);
134 ret = -ETIMEDOUT;
135 }
136
137 out_unlock:
138 mutex_unlock(&altmode->lock);
139 return ret;
140 }
141
pmic_glink_altmode_enable_dp(struct pmic_glink_altmode * altmode,struct pmic_glink_altmode_port * port,u8 mode,bool hpd_state,bool hpd_irq)142 static void pmic_glink_altmode_enable_dp(struct pmic_glink_altmode *altmode,
143 struct pmic_glink_altmode_port *port,
144 u8 mode, bool hpd_state,
145 bool hpd_irq)
146 {
147 struct typec_displayport_data dp_data = {};
148 int ret;
149
150 dp_data.status = DP_STATUS_ENABLED;
151 if (hpd_state)
152 dp_data.status |= DP_STATUS_HPD_STATE;
153 if (hpd_irq)
154 dp_data.status |= DP_STATUS_IRQ_HPD;
155 dp_data.conf = DP_CONF_SET_PIN_ASSIGN(mode);
156
157 port->state.alt = &port->dp_alt;
158 port->state.data = &dp_data;
159 port->state.mode = TYPEC_MODAL_STATE(mode);
160
161 ret = typec_mux_set(port->typec_mux, &port->state);
162 if (ret)
163 dev_err(altmode->dev, "failed to switch mux to DP: %d\n", ret);
164
165 port->retimer_state.alt = &port->dp_alt;
166 port->retimer_state.data = &dp_data;
167 port->retimer_state.mode = TYPEC_MODAL_STATE(mode);
168
169 ret = typec_retimer_set(port->typec_retimer, &port->retimer_state);
170 if (ret)
171 dev_err(altmode->dev, "failed to setup retimer to DP: %d\n", ret);
172 }
173
pmic_glink_altmode_enable_usb(struct pmic_glink_altmode * altmode,struct pmic_glink_altmode_port * port)174 static void pmic_glink_altmode_enable_usb(struct pmic_glink_altmode *altmode,
175 struct pmic_glink_altmode_port *port)
176 {
177 int ret;
178
179 port->state.alt = NULL;
180 port->state.data = NULL;
181 port->state.mode = TYPEC_STATE_USB;
182
183 ret = typec_mux_set(port->typec_mux, &port->state);
184 if (ret)
185 dev_err(altmode->dev, "failed to switch mux to USB: %d\n", ret);
186
187 port->retimer_state.alt = NULL;
188 port->retimer_state.data = NULL;
189 port->retimer_state.mode = TYPEC_STATE_USB;
190
191 ret = typec_retimer_set(port->typec_retimer, &port->retimer_state);
192 if (ret)
193 dev_err(altmode->dev, "failed to setup retimer to USB: %d\n", ret);
194 }
195
pmic_glink_altmode_safe(struct pmic_glink_altmode * altmode,struct pmic_glink_altmode_port * port)196 static void pmic_glink_altmode_safe(struct pmic_glink_altmode *altmode,
197 struct pmic_glink_altmode_port *port)
198 {
199 int ret;
200
201 port->state.alt = NULL;
202 port->state.data = NULL;
203 port->state.mode = TYPEC_STATE_SAFE;
204
205 ret = typec_mux_set(port->typec_mux, &port->state);
206 if (ret)
207 dev_err(altmode->dev, "failed to switch mux to safe mode: %d\n", ret);
208
209 port->retimer_state.alt = NULL;
210 port->retimer_state.data = NULL;
211 port->retimer_state.mode = TYPEC_STATE_SAFE;
212
213 ret = typec_retimer_set(port->typec_retimer, &port->retimer_state);
214 if (ret)
215 dev_err(altmode->dev, "failed to setup retimer to USB: %d\n", ret);
216 }
217
pmic_glink_altmode_worker(struct work_struct * work)218 static void pmic_glink_altmode_worker(struct work_struct *work)
219 {
220 struct pmic_glink_altmode_port *alt_port = work_to_altmode_port(work);
221 struct pmic_glink_altmode *altmode = alt_port->altmode;
222 enum drm_connector_status conn_status;
223
224 typec_switch_set(alt_port->typec_switch, alt_port->orientation);
225
226 if (alt_port->svid == USB_TYPEC_DP_SID) {
227 if (alt_port->mode == 0xff) {
228 pmic_glink_altmode_safe(altmode, alt_port);
229 } else {
230 pmic_glink_altmode_enable_dp(altmode, alt_port,
231 alt_port->mode,
232 alt_port->hpd_state,
233 alt_port->hpd_irq);
234 }
235
236 if (alt_port->hpd_state)
237 conn_status = connector_status_connected;
238 else
239 conn_status = connector_status_disconnected;
240
241 drm_aux_hpd_bridge_notify(&alt_port->bridge->dev, conn_status);
242 } else {
243 pmic_glink_altmode_enable_usb(altmode, alt_port);
244 }
245
246 pmic_glink_altmode_request(altmode, ALTMODE_PAN_ACK, alt_port->index);
247 }
248
pmic_glink_altmode_orientation(unsigned int orientation)249 static enum typec_orientation pmic_glink_altmode_orientation(unsigned int orientation)
250 {
251 if (orientation == 0)
252 return TYPEC_ORIENTATION_NORMAL;
253 else if (orientation == 1)
254 return TYPEC_ORIENTATION_REVERSE;
255 else
256 return TYPEC_ORIENTATION_NONE;
257 }
258
259 #define SC8180X_PORT_MASK 0x000000ff
260 #define SC8180X_ORIENTATION_MASK 0x0000ff00
261 #define SC8180X_MUX_MASK 0x00ff0000
262 #define SC8180X_MODE_MASK 0x3f000000
263 #define SC8180X_HPD_STATE_MASK 0x40000000
264 #define SC8180X_HPD_IRQ_MASK 0x80000000
265
pmic_glink_altmode_sc8180xp_notify(struct pmic_glink_altmode * altmode,const void * data,size_t len)266 static void pmic_glink_altmode_sc8180xp_notify(struct pmic_glink_altmode *altmode,
267 const void *data, size_t len)
268 {
269 struct pmic_glink_altmode_port *alt_port;
270 const struct usbc_sc8180x_notify *msg;
271 u32 notification;
272 u8 orientation;
273 u8 hpd_state;
274 u8 hpd_irq;
275 u16 svid;
276 u8 port;
277 u8 mode;
278 u8 mux;
279
280 if (len != sizeof(*msg)) {
281 dev_warn(altmode->dev, "invalid length of USBC_NOTIFY indication: %zd\n", len);
282 return;
283 }
284
285 msg = data;
286 notification = le32_to_cpu(msg->notification);
287 port = FIELD_GET(SC8180X_PORT_MASK, notification);
288 orientation = FIELD_GET(SC8180X_ORIENTATION_MASK, notification);
289 mux = FIELD_GET(SC8180X_MUX_MASK, notification);
290 mode = FIELD_GET(SC8180X_MODE_MASK, notification);
291 hpd_state = FIELD_GET(SC8180X_HPD_STATE_MASK, notification);
292 hpd_irq = FIELD_GET(SC8180X_HPD_IRQ_MASK, notification);
293
294 svid = mux == 2 ? USB_TYPEC_DP_SID : 0;
295
296 if (port >= ARRAY_SIZE(altmode->ports) || !altmode->ports[port].altmode) {
297 dev_dbg(altmode->dev, "notification on undefined port %d\n", port);
298 return;
299 }
300
301 alt_port = &altmode->ports[port];
302 alt_port->orientation = pmic_glink_altmode_orientation(orientation);
303 alt_port->svid = svid;
304 alt_port->mode = mode;
305 alt_port->hpd_state = hpd_state;
306 alt_port->hpd_irq = hpd_irq;
307 schedule_work(&alt_port->work);
308 }
309
310 #define SC8280XP_DPAM_MASK 0x3f
311 #define SC8280XP_HPD_STATE_MASK BIT(6)
312 #define SC8280XP_HPD_IRQ_MASK BIT(7)
313
pmic_glink_altmode_sc8280xp_notify(struct pmic_glink_altmode * altmode,u16 svid,const void * data,size_t len)314 static void pmic_glink_altmode_sc8280xp_notify(struct pmic_glink_altmode *altmode,
315 u16 svid, const void *data, size_t len)
316 {
317 struct pmic_glink_altmode_port *alt_port;
318 const struct usbc_notify *notify;
319 u8 orientation;
320 u8 hpd_state;
321 u8 hpd_irq;
322 u8 mode;
323 u8 port;
324
325 if (len != sizeof(*notify)) {
326 dev_warn(altmode->dev, "invalid length USBC_NOTIFY_IND: %zd\n",
327 len);
328 return;
329 }
330
331 notify = data;
332
333 port = notify->payload[0];
334 orientation = notify->payload[1];
335 mode = FIELD_GET(SC8280XP_DPAM_MASK, notify->payload[8]) - DPAM_HPD_A;
336 hpd_state = FIELD_GET(SC8280XP_HPD_STATE_MASK, notify->payload[8]);
337 hpd_irq = FIELD_GET(SC8280XP_HPD_IRQ_MASK, notify->payload[8]);
338
339 if (port >= ARRAY_SIZE(altmode->ports) || !altmode->ports[port].altmode) {
340 dev_dbg(altmode->dev, "notification on undefined port %d\n", port);
341 return;
342 }
343
344 alt_port = &altmode->ports[port];
345 alt_port->orientation = pmic_glink_altmode_orientation(orientation);
346 alt_port->svid = svid;
347 alt_port->mode = mode;
348 alt_port->hpd_state = hpd_state;
349 alt_port->hpd_irq = hpd_irq;
350 schedule_work(&alt_port->work);
351 }
352
pmic_glink_altmode_callback(const void * data,size_t len,void * priv)353 static void pmic_glink_altmode_callback(const void *data, size_t len, void *priv)
354 {
355 struct pmic_glink_altmode *altmode = priv;
356 const struct pmic_glink_hdr *hdr = data;
357 u16 opcode;
358 u16 svid;
359
360 opcode = le32_to_cpu(hdr->opcode) & 0xff;
361 svid = le32_to_cpu(hdr->opcode) >> 16;
362
363 switch (opcode) {
364 case USBC_CMD_WRITE_REQ:
365 complete(&altmode->pan_ack);
366 break;
367 case USBC_NOTIFY_IND:
368 pmic_glink_altmode_sc8280xp_notify(altmode, svid, data, len);
369 break;
370 case USBC_SC8180X_NOTIFY_IND:
371 pmic_glink_altmode_sc8180xp_notify(altmode, data, len);
372 break;
373 }
374 }
375
pmic_glink_altmode_put_retimer(void * data)376 static void pmic_glink_altmode_put_retimer(void *data)
377 {
378 typec_retimer_put(data);
379 }
380
pmic_glink_altmode_put_mux(void * data)381 static void pmic_glink_altmode_put_mux(void *data)
382 {
383 typec_mux_put(data);
384 }
385
pmic_glink_altmode_put_switch(void * data)386 static void pmic_glink_altmode_put_switch(void *data)
387 {
388 typec_switch_put(data);
389 }
390
pmic_glink_altmode_enable_worker(struct work_struct * work)391 static void pmic_glink_altmode_enable_worker(struct work_struct *work)
392 {
393 struct pmic_glink_altmode *altmode = work_to_altmode(work);
394 int ret;
395
396 ret = pmic_glink_altmode_request(altmode, ALTMODE_PAN_EN, 0);
397 if (ret)
398 dev_err(altmode->dev, "failed to request altmode notifications: %d\n", ret);
399 }
400
pmic_glink_altmode_pdr_notify(void * priv,int state)401 static void pmic_glink_altmode_pdr_notify(void *priv, int state)
402 {
403 struct pmic_glink_altmode *altmode = priv;
404
405 if (state == SERVREG_SERVICE_STATE_UP)
406 schedule_work(&altmode->enable_work);
407 }
408
409 static const struct of_device_id pmic_glink_altmode_of_quirks[] = {
410 { .compatible = "qcom,sc8180x-pmic-glink", .data = (void *)PMIC_GLINK_OWNER_USBC },
411 {}
412 };
413
pmic_glink_altmode_probe(struct auxiliary_device * adev,const struct auxiliary_device_id * id)414 static int pmic_glink_altmode_probe(struct auxiliary_device *adev,
415 const struct auxiliary_device_id *id)
416 {
417 struct pmic_glink_altmode_port *alt_port;
418 struct pmic_glink_altmode *altmode;
419 const struct of_device_id *match;
420 struct fwnode_handle *fwnode;
421 struct device *dev = &adev->dev;
422 u32 port;
423 int ret;
424
425 altmode = devm_kzalloc(dev, sizeof(*altmode), GFP_KERNEL);
426 if (!altmode)
427 return -ENOMEM;
428
429 altmode->dev = dev;
430
431 match = of_match_device(pmic_glink_altmode_of_quirks, dev->parent);
432 if (match)
433 altmode->owner_id = (unsigned long)match->data;
434 else
435 altmode->owner_id = PMIC_GLINK_OWNER_USBC_PAN;
436
437 INIT_WORK(&altmode->enable_work, pmic_glink_altmode_enable_worker);
438 init_completion(&altmode->pan_ack);
439 mutex_init(&altmode->lock);
440
441 device_for_each_child_node(dev, fwnode) {
442 ret = fwnode_property_read_u32(fwnode, "reg", &port);
443 if (ret < 0) {
444 dev_err(dev, "missing reg property of %pOFn\n", fwnode);
445 fwnode_handle_put(fwnode);
446 return ret;
447 }
448
449 if (port >= ARRAY_SIZE(altmode->ports)) {
450 dev_warn(dev, "invalid connector number, ignoring\n");
451 continue;
452 }
453
454 if (altmode->ports[port].altmode) {
455 dev_err(dev, "multiple connector definition for port %u\n", port);
456 fwnode_handle_put(fwnode);
457 return -EINVAL;
458 }
459
460 alt_port = &altmode->ports[port];
461 alt_port->altmode = altmode;
462 alt_port->index = port;
463 INIT_WORK(&alt_port->work, pmic_glink_altmode_worker);
464
465 alt_port->bridge = devm_drm_dp_hpd_bridge_alloc(dev, to_of_node(fwnode));
466 if (IS_ERR(alt_port->bridge)) {
467 fwnode_handle_put(fwnode);
468 return PTR_ERR(alt_port->bridge);
469 }
470
471 alt_port->dp_alt.svid = USB_TYPEC_DP_SID;
472 alt_port->dp_alt.mode = USB_TYPEC_DP_MODE;
473 alt_port->dp_alt.active = 1;
474
475 alt_port->typec_mux = fwnode_typec_mux_get(fwnode);
476 if (IS_ERR(alt_port->typec_mux)) {
477 fwnode_handle_put(fwnode);
478 return dev_err_probe(dev, PTR_ERR(alt_port->typec_mux),
479 "failed to acquire mode-switch for port: %d\n",
480 port);
481 }
482
483 ret = devm_add_action_or_reset(dev, pmic_glink_altmode_put_mux,
484 alt_port->typec_mux);
485 if (ret) {
486 fwnode_handle_put(fwnode);
487 return ret;
488 }
489
490 alt_port->typec_retimer = fwnode_typec_retimer_get(fwnode);
491 if (IS_ERR(alt_port->typec_retimer)) {
492 fwnode_handle_put(fwnode);
493 return dev_err_probe(dev, PTR_ERR(alt_port->typec_retimer),
494 "failed to acquire retimer-switch for port: %d\n",
495 port);
496 }
497
498 ret = devm_add_action_or_reset(dev, pmic_glink_altmode_put_retimer,
499 alt_port->typec_retimer);
500 if (ret) {
501 fwnode_handle_put(fwnode);
502 return ret;
503 }
504
505 alt_port->typec_switch = fwnode_typec_switch_get(fwnode);
506 if (IS_ERR(alt_port->typec_switch)) {
507 fwnode_handle_put(fwnode);
508 return dev_err_probe(dev, PTR_ERR(alt_port->typec_switch),
509 "failed to acquire orientation-switch for port: %d\n",
510 port);
511 }
512
513 ret = devm_add_action_or_reset(dev, pmic_glink_altmode_put_switch,
514 alt_port->typec_switch);
515 if (ret) {
516 fwnode_handle_put(fwnode);
517 return ret;
518 }
519 }
520
521 for (port = 0; port < ARRAY_SIZE(altmode->ports); port++) {
522 alt_port = &altmode->ports[port];
523 if (!alt_port->bridge)
524 continue;
525
526 ret = devm_drm_dp_hpd_bridge_add(dev, alt_port->bridge);
527 if (ret)
528 return ret;
529 }
530
531 altmode->client = devm_pmic_glink_client_alloc(dev,
532 altmode->owner_id,
533 pmic_glink_altmode_callback,
534 pmic_glink_altmode_pdr_notify,
535 altmode);
536 if (IS_ERR(altmode->client))
537 return PTR_ERR(altmode->client);
538
539 pmic_glink_client_register(altmode->client);
540
541 return 0;
542 }
543
544 static const struct auxiliary_device_id pmic_glink_altmode_id_table[] = {
545 { .name = "pmic_glink.altmode", },
546 {},
547 };
548 MODULE_DEVICE_TABLE(auxiliary, pmic_glink_altmode_id_table);
549
550 static struct auxiliary_driver pmic_glink_altmode_driver = {
551 .name = "pmic_glink_altmode",
552 .probe = pmic_glink_altmode_probe,
553 .id_table = pmic_glink_altmode_id_table,
554 };
555
556 module_auxiliary_driver(pmic_glink_altmode_driver);
557
558 MODULE_DESCRIPTION("Qualcomm PMIC GLINK Altmode driver");
559 MODULE_LICENSE("GPL");
560