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/cleanup.h>
9 #include <linux/module.h>
10 #include <linux/of.h>
11 #include <linux/of_device.h>
12 #include <linux/mutex.h>
13 #include <linux/property.h>
14 #include <linux/soc/qcom/pdr.h>
15 #include <drm/bridge/aux-bridge.h>
16
17 #include <linux/usb/pd.h>
18 #include <linux/usb/typec_altmode.h>
19 #include <linux/usb/typec_dp.h>
20 #include <linux/usb/typec_mux.h>
21 #include <linux/usb/typec_retimer.h>
22 #include <linux/usb/typec_tbt.h>
23
24 #include <linux/soc/qcom/pmic_glink.h>
25
26 #define PMIC_GLINK_MAX_PORTS 3
27
28 #define USBC_SC8180X_NOTIFY_IND 0x13
29 #define USBC_CMD_WRITE_REQ 0x15
30 #define USBC_NOTIFY_IND 0x16
31
32 #define ALTMODE_PAN_EN 0x10
33 #define ALTMODE_PAN_ACK 0x11
34
35 struct usbc_write_req {
36 struct pmic_glink_hdr hdr;
37 __le32 cmd;
38 __le32 arg;
39 __le32 reserved;
40 };
41
42 struct usbc_sc8280x_dp_data {
43 u8 pin_assignment : 6;
44 u8 hpd_state : 1;
45 u8 hpd_irq : 1;
46 u8 res[7];
47 };
48
49 /* Used for both TBT and USB4 notifications */
50 struct usbc_sc8280x_tbt_data {
51 u8 usb_speed : 3;
52 u8 cable_type : 3;
53 /* This field is NOP on USB4, all cables support rounded rates by spec */
54 u8 rounded_cable : 1;
55 u8 power_limited : 1;
56 u8 res[11];
57 };
58
59 struct usbc_notify {
60 struct pmic_glink_hdr hdr;
61 u8 port_idx;
62 u8 orientation;
63 u8 mux_ctrl;
64 #define MUX_CTRL_STATE_NO_CONN 0
65 #define MUX_CTRL_STATE_USB3_ONLY 1
66 #define MUX_CTRL_STATE_DP4LN 2
67 #define MUX_CTRL_STATE_USB3_DP 3
68 #define MUX_CTRL_STATE_TUNNELING 4
69
70 u8 res;
71 __le16 vid;
72 __le16 svid;
73 union usbc_sc8280x_extended_data {
74 struct usbc_sc8280x_dp_data dp;
75 struct usbc_sc8280x_tbt_data tbt;
76 } extended_data;
77 };
78
79 struct usbc_sc8180x_notify {
80 struct pmic_glink_hdr hdr;
81 __le32 notification;
82 __le32 reserved[2];
83 };
84
85 enum pmic_glink_altmode_pin_assignment {
86 DPAM_HPD_OUT,
87 DPAM_HPD_A,
88 DPAM_HPD_B,
89 DPAM_HPD_C,
90 DPAM_HPD_D,
91 DPAM_HPD_E,
92 DPAM_HPD_F,
93 };
94
95 struct pmic_glink_altmode;
96
97 #define work_to_altmode_port(w) container_of((w), struct pmic_glink_altmode_port, work)
98
99 struct pmic_glink_altmode_port {
100 struct pmic_glink_altmode *altmode;
101 unsigned int index;
102
103 struct typec_switch *typec_switch;
104 struct typec_mux *typec_mux;
105 struct typec_mux_state state;
106 struct typec_retimer *typec_retimer;
107 struct typec_retimer_state retimer_state;
108 struct typec_altmode dp_alt;
109 struct typec_altmode tbt_alt;
110
111 struct work_struct work;
112
113 struct auxiliary_device *bridge;
114
115 enum typec_orientation orientation;
116 u16 svid;
117 struct usbc_sc8280x_tbt_data tbt_data;
118 u8 dp_data;
119 u8 mode;
120 u8 hpd_state;
121 u8 hpd_irq;
122 u8 mux_ctrl;
123 };
124
125 #define work_to_altmode(w) container_of((w), struct pmic_glink_altmode, enable_work)
126
127 struct pmic_glink_altmode {
128 struct device *dev;
129
130 unsigned int owner_id;
131
132 /* To synchronize WRITE_REQ acks */
133 struct mutex lock;
134
135 struct completion pan_ack;
136 struct pmic_glink_client *client;
137
138 struct work_struct enable_work;
139
140 struct pmic_glink_altmode_port ports[PMIC_GLINK_MAX_PORTS];
141 };
142
pmic_glink_altmode_request(struct pmic_glink_altmode * altmode,u32 cmd,u32 arg)143 static int pmic_glink_altmode_request(struct pmic_glink_altmode *altmode, u32 cmd, u32 arg)
144 {
145 struct usbc_write_req req = {};
146 unsigned long left;
147 int ret;
148
149 /*
150 * The USBC_CMD_WRITE_REQ ack doesn't identify the request, so wait for
151 * one ack at a time.
152 */
153 guard(mutex)(&altmode->lock);
154
155 req.hdr.owner = cpu_to_le32(altmode->owner_id);
156 req.hdr.type = cpu_to_le32(PMIC_GLINK_REQ_RESP);
157 req.hdr.opcode = cpu_to_le32(USBC_CMD_WRITE_REQ);
158 req.cmd = cpu_to_le32(cmd);
159 req.arg = cpu_to_le32(arg);
160
161 ret = pmic_glink_send(altmode->client, &req, sizeof(req));
162 if (ret) {
163 dev_err(altmode->dev, "failed to send altmode request: %#x (%d)\n", cmd, ret);
164 return ret;
165 }
166
167 left = wait_for_completion_timeout(&altmode->pan_ack, 5 * HZ);
168 if (!left) {
169 dev_err(altmode->dev, "timeout waiting for altmode request ack for: %#x\n", cmd);
170 return -ETIMEDOUT;
171 }
172
173 return 0;
174 }
175
pmic_glink_altmode_enable_dp(struct pmic_glink_altmode * altmode,struct pmic_glink_altmode_port * port,u8 mode,bool hpd_state,bool hpd_irq)176 static void pmic_glink_altmode_enable_dp(struct pmic_glink_altmode *altmode,
177 struct pmic_glink_altmode_port *port,
178 u8 mode, bool hpd_state,
179 bool hpd_irq)
180 {
181 struct typec_displayport_data dp_data = {};
182 int ret;
183
184 dp_data.status = DP_STATUS_ENABLED;
185 if (hpd_state)
186 dp_data.status |= DP_STATUS_HPD_STATE;
187 if (hpd_irq)
188 dp_data.status |= DP_STATUS_IRQ_HPD;
189 dp_data.conf = DP_CONF_SET_PIN_ASSIGN(mode);
190
191 port->state.alt = &port->dp_alt;
192 port->state.data = &dp_data;
193 port->state.mode = TYPEC_MODAL_STATE(mode);
194
195 ret = typec_mux_set(port->typec_mux, &port->state);
196 if (ret)
197 dev_err(altmode->dev, "failed to switch mux to DP: %d\n", ret);
198
199 port->retimer_state.alt = &port->dp_alt;
200 port->retimer_state.data = &dp_data;
201 port->retimer_state.mode = TYPEC_MODAL_STATE(mode);
202
203 ret = typec_retimer_set(port->typec_retimer, &port->retimer_state);
204 if (ret)
205 dev_err(altmode->dev, "failed to setup retimer to DP: %d\n", ret);
206 }
207
pmic_glink_altmode_enable_tbt(struct pmic_glink_altmode * altmode,struct pmic_glink_altmode_port * port)208 static void pmic_glink_altmode_enable_tbt(struct pmic_glink_altmode *altmode,
209 struct pmic_glink_altmode_port *port)
210 {
211 struct usbc_sc8280x_tbt_data *tbt = &port->tbt_data;
212 struct typec_thunderbolt_data tbt_data = {};
213 u32 cable_speed;
214 int ret;
215
216 /* Device Discover Mode VDO */
217 tbt_data.device_mode = TBT_MODE;
218 tbt_data.device_mode |= TBT_SET_ADAPTER(TBT_ADAPTER_TBT3);
219
220 /* Cable Discover Mode VDO */
221 tbt_data.cable_mode = TBT_MODE;
222
223 if (tbt->usb_speed == 0) {
224 cable_speed = TBT_CABLE_USB3_PASSIVE;
225 } else if (tbt->usb_speed == 1) {
226 cable_speed = TBT_CABLE_10_AND_20GBPS;
227 } else {
228 dev_err(altmode->dev,
229 "Got illegal TBT3 cable speed value (%u), falling back to passive\n",
230 tbt->usb_speed);
231 cable_speed = TBT_CABLE_USB3_PASSIVE;
232 }
233 tbt_data.cable_mode |= TBT_SET_CABLE_SPEED(cable_speed);
234
235 if (tbt->cable_type) {
236 tbt_data.cable_mode |= TBT_CABLE_ACTIVE_PASSIVE;
237 tbt_data.cable_mode |= TBT_SET_CABLE_ROUNDED(tbt->rounded_cable);
238 }
239
240 /* Enter Mode VDO */
241 tbt_data.enter_vdo |= TBT_MODE;
242 tbt_data.enter_vdo |= TBT_ENTER_MODE_CABLE_SPEED(cable_speed);
243
244 if (tbt->cable_type) {
245 tbt_data.enter_vdo |= TBT_CABLE_ACTIVE_PASSIVE;
246 tbt_data.enter_vdo |= TBT_SET_CABLE_ROUNDED(tbt->rounded_cable);
247 }
248
249 port->state.alt = &port->tbt_alt;
250 port->state.data = &tbt_data;
251 port->state.mode = TYPEC_MODAL_STATE(port->mode);
252
253 ret = typec_mux_set(port->typec_mux, &port->state);
254 if (ret)
255 dev_err(altmode->dev, "failed to switch mux to USB: %d\n", ret);
256
257 port->retimer_state.alt = &port->tbt_alt;
258 port->retimer_state.data = &tbt_data;
259 port->retimer_state.mode = TYPEC_MODAL_STATE(port->mode);
260
261 ret = typec_retimer_set(port->typec_retimer, &port->retimer_state);
262 if (ret)
263 dev_err(altmode->dev, "failed to setup retimer to USB: %d\n", ret);
264 }
265
pmic_glink_altmode_enable_usb4(struct pmic_glink_altmode * altmode,struct pmic_glink_altmode_port * port)266 static void pmic_glink_altmode_enable_usb4(struct pmic_glink_altmode *altmode,
267 struct pmic_glink_altmode_port *port)
268 {
269 struct usbc_sc8280x_tbt_data *tbt = &port->tbt_data;
270 struct enter_usb_data data = {};
271 int ret;
272
273 data.eudo = FIELD_PREP(EUDO_USB_MODE_MASK, EUDO_USB_MODE_USB4);
274
275 if (tbt->usb_speed == 0) {
276 data.eudo |= FIELD_PREP(EUDO_CABLE_SPEED_MASK, EUDO_CABLE_SPEED_USB4_GEN2);
277 } else if (tbt->usb_speed == 1) {
278 data.eudo |= FIELD_PREP(EUDO_CABLE_SPEED_MASK, EUDO_CABLE_SPEED_USB4_GEN3);
279 } else {
280 pr_err("Got illegal USB4 cable speed value (%u), falling back to G2\n",
281 tbt->usb_speed);
282 data.eudo |= FIELD_PREP(EUDO_CABLE_SPEED_MASK, EUDO_CABLE_SPEED_USB4_GEN2);
283 }
284
285 data.eudo |= FIELD_PREP(EUDO_CABLE_TYPE_MASK, tbt->cable_type);
286
287 port->state.alt = NULL;
288 port->state.data = &data;
289 port->state.mode = TYPEC_MODE_USB4;
290
291 ret = typec_mux_set(port->typec_mux, &port->state);
292 if (ret)
293 dev_err(altmode->dev, "failed to switch mux to USB: %d\n", ret);
294
295 port->retimer_state.alt = NULL;
296 port->retimer_state.data = &data;
297 port->retimer_state.mode = TYPEC_MODE_USB4;
298
299 ret = typec_retimer_set(port->typec_retimer, &port->retimer_state);
300 if (ret)
301 dev_err(altmode->dev, "failed to setup retimer to USB: %d\n", ret);
302 }
303
pmic_glink_altmode_enable_usb(struct pmic_glink_altmode * altmode,struct pmic_glink_altmode_port * port)304 static void pmic_glink_altmode_enable_usb(struct pmic_glink_altmode *altmode,
305 struct pmic_glink_altmode_port *port)
306 {
307 int ret;
308
309 port->state.alt = NULL;
310 port->state.data = NULL;
311 port->state.mode = TYPEC_STATE_USB;
312
313 ret = typec_mux_set(port->typec_mux, &port->state);
314 if (ret)
315 dev_err(altmode->dev, "failed to switch mux to USB: %d\n", ret);
316
317 port->retimer_state.alt = NULL;
318 port->retimer_state.data = NULL;
319 port->retimer_state.mode = TYPEC_STATE_USB;
320
321 ret = typec_retimer_set(port->typec_retimer, &port->retimer_state);
322 if (ret)
323 dev_err(altmode->dev, "failed to setup retimer to USB: %d\n", ret);
324 }
325
pmic_glink_altmode_safe(struct pmic_glink_altmode * altmode,struct pmic_glink_altmode_port * port)326 static void pmic_glink_altmode_safe(struct pmic_glink_altmode *altmode,
327 struct pmic_glink_altmode_port *port)
328 {
329 int ret;
330
331 port->state.alt = NULL;
332 port->state.data = NULL;
333 port->state.mode = TYPEC_STATE_SAFE;
334
335 ret = typec_mux_set(port->typec_mux, &port->state);
336 if (ret)
337 dev_err(altmode->dev, "failed to switch mux to safe mode: %d\n", ret);
338
339 port->retimer_state.alt = NULL;
340 port->retimer_state.data = NULL;
341 port->retimer_state.mode = TYPEC_STATE_SAFE;
342
343 ret = typec_retimer_set(port->typec_retimer, &port->retimer_state);
344 if (ret)
345 dev_err(altmode->dev, "failed to setup retimer to USB: %d\n", ret);
346 }
347
pmic_glink_altmode_worker(struct work_struct * work)348 static void pmic_glink_altmode_worker(struct work_struct *work)
349 {
350 struct pmic_glink_altmode_port *alt_port = work_to_altmode_port(work);
351 struct pmic_glink_altmode *altmode = alt_port->altmode;
352 enum drm_connector_status conn_status;
353
354 typec_switch_set(alt_port->typec_switch, alt_port->orientation);
355
356 /*
357 * MUX_CTRL_STATE_DP4LN/USB3_DP may only be set if SVID=DP, but we need
358 * to special-case the SVID=DP && mux_ctrl=NO_CONN case to deliver a
359 * HPD notification
360 */
361 if (alt_port->svid == USB_TYPEC_DP_SID) {
362 if (alt_port->mux_ctrl == MUX_CTRL_STATE_NO_CONN) {
363 pmic_glink_altmode_safe(altmode, alt_port);
364 } else {
365 pmic_glink_altmode_enable_dp(altmode, alt_port,
366 alt_port->mode,
367 alt_port->hpd_state,
368 alt_port->hpd_irq);
369 }
370
371 if (alt_port->hpd_state)
372 conn_status = connector_status_connected;
373 else
374 conn_status = connector_status_disconnected;
375
376 drm_aux_hpd_bridge_notify(&alt_port->bridge->dev, conn_status);
377 } else if (alt_port->mux_ctrl == MUX_CTRL_STATE_TUNNELING) {
378 if (alt_port->svid == USB_TYPEC_TBT_SID)
379 pmic_glink_altmode_enable_tbt(altmode, alt_port);
380 else
381 pmic_glink_altmode_enable_usb4(altmode, alt_port);
382 } else if (alt_port->mux_ctrl == MUX_CTRL_STATE_USB3_ONLY) {
383 pmic_glink_altmode_enable_usb(altmode, alt_port);
384 } else if (alt_port->mux_ctrl == MUX_CTRL_STATE_NO_CONN) {
385 pmic_glink_altmode_safe(altmode, alt_port);
386 } else {
387 dev_err(altmode->dev, "Got unknown mux_ctrl: %u on port %u, forcing safe mode\n",
388 alt_port->mux_ctrl, alt_port->index);
389 pmic_glink_altmode_safe(altmode, alt_port);
390 }
391
392 pmic_glink_altmode_request(altmode, ALTMODE_PAN_ACK, alt_port->index);
393 }
394
pmic_glink_altmode_orientation(unsigned int orientation)395 static enum typec_orientation pmic_glink_altmode_orientation(unsigned int orientation)
396 {
397 if (orientation == 0)
398 return TYPEC_ORIENTATION_NORMAL;
399 else if (orientation == 1)
400 return TYPEC_ORIENTATION_REVERSE;
401 else
402 return TYPEC_ORIENTATION_NONE;
403 }
404
405 #define SC8180X_PORT_MASK 0x000000ff
406 #define SC8180X_ORIENTATION_MASK 0x0000ff00
407 #define SC8180X_MUX_MASK 0x00ff0000
408 #define SC8180X_MODE_MASK 0x3f000000
409 #define SC8180X_HPD_STATE_MASK 0x40000000
410 #define SC8180X_HPD_IRQ_MASK 0x80000000
411
pmic_glink_altmode_sc8180xp_notify(struct pmic_glink_altmode * altmode,const void * data,size_t len)412 static void pmic_glink_altmode_sc8180xp_notify(struct pmic_glink_altmode *altmode,
413 const void *data, size_t len)
414 {
415 struct pmic_glink_altmode_port *alt_port;
416 const struct usbc_sc8180x_notify *msg;
417 u32 notification;
418 u8 orientation;
419 u8 hpd_state;
420 u8 hpd_irq;
421 u16 svid;
422 u8 port;
423 u8 mode;
424 u8 mux;
425
426 if (len != sizeof(*msg)) {
427 dev_warn(altmode->dev, "invalid length of USBC_NOTIFY indication: %zd\n", len);
428 return;
429 }
430
431 msg = data;
432 notification = le32_to_cpu(msg->notification);
433 port = FIELD_GET(SC8180X_PORT_MASK, notification);
434 orientation = FIELD_GET(SC8180X_ORIENTATION_MASK, notification);
435 mux = FIELD_GET(SC8180X_MUX_MASK, notification);
436 mode = FIELD_GET(SC8180X_MODE_MASK, notification);
437 hpd_state = FIELD_GET(SC8180X_HPD_STATE_MASK, notification);
438 hpd_irq = FIELD_GET(SC8180X_HPD_IRQ_MASK, notification);
439
440 svid = mux == 2 ? USB_TYPEC_DP_SID : 0;
441
442 if (port >= ARRAY_SIZE(altmode->ports) || !altmode->ports[port].altmode) {
443 dev_dbg(altmode->dev, "notification on undefined port %d\n", port);
444 return;
445 }
446
447 alt_port = &altmode->ports[port];
448 alt_port->orientation = pmic_glink_altmode_orientation(orientation);
449 alt_port->svid = svid;
450 alt_port->mode = mode;
451 alt_port->hpd_state = hpd_state;
452 alt_port->hpd_irq = hpd_irq;
453 schedule_work(&alt_port->work);
454 }
455
456 #define SC8280XP_DPAM_MASK 0x3f
457 #define SC8280XP_HPD_STATE_MASK BIT(6)
458 #define SC8280XP_HPD_IRQ_MASK BIT(7)
459
pmic_glink_altmode_sc8280xp_notify(struct pmic_glink_altmode * altmode,u16 svid,const void * data,size_t len)460 static void pmic_glink_altmode_sc8280xp_notify(struct pmic_glink_altmode *altmode,
461 u16 svid, const void *data, size_t len)
462 {
463 struct pmic_glink_altmode_port *alt_port;
464 const struct usbc_sc8280x_tbt_data *tbt;
465 const struct usbc_sc8280x_dp_data *dp;
466 const struct usbc_notify *notify;
467 u8 orientation;
468 u8 port;
469
470 if (len != sizeof(*notify)) {
471 dev_warn(altmode->dev, "invalid length USBC_NOTIFY_IND: %zd\n",
472 len);
473 return;
474 }
475
476 notify = data;
477
478 port = notify->port_idx;
479 orientation = notify->orientation;
480
481 if (port >= ARRAY_SIZE(altmode->ports) || !altmode->ports[port].altmode) {
482 dev_dbg(altmode->dev, "notification on undefined port %d\n", port);
483 return;
484 }
485
486 alt_port = &altmode->ports[port];
487 alt_port->orientation = pmic_glink_altmode_orientation(orientation);
488 alt_port->svid = svid;
489 alt_port->mux_ctrl = notify->mux_ctrl;
490
491 if (svid == USB_TYPEC_DP_SID) {
492 dp = ¬ify->extended_data.dp;
493
494 alt_port->mode = dp->pin_assignment - DPAM_HPD_A;
495 alt_port->hpd_state = dp->hpd_state;
496 alt_port->hpd_irq = dp->hpd_irq;
497 } else if (alt_port->mux_ctrl == MUX_CTRL_STATE_TUNNELING) {
498 /* Valid for both USB4 and TBT3 */
499 tbt = ¬ify->extended_data.tbt;
500
501 alt_port->tbt_data = *tbt;
502 }
503
504 schedule_work(&alt_port->work);
505 }
506
pmic_glink_altmode_callback(const void * data,size_t len,void * priv)507 static void pmic_glink_altmode_callback(const void *data, size_t len, void *priv)
508 {
509 struct pmic_glink_altmode *altmode = priv;
510 const struct pmic_glink_hdr *hdr = data;
511 u16 opcode;
512 u16 svid;
513
514 opcode = le32_to_cpu(hdr->opcode) & 0xff;
515 svid = le32_to_cpu(hdr->opcode) >> 16;
516
517 switch (opcode) {
518 case USBC_CMD_WRITE_REQ:
519 complete(&altmode->pan_ack);
520 break;
521 case USBC_NOTIFY_IND:
522 pmic_glink_altmode_sc8280xp_notify(altmode, svid, data, len);
523 break;
524 case USBC_SC8180X_NOTIFY_IND:
525 pmic_glink_altmode_sc8180xp_notify(altmode, data, len);
526 break;
527 }
528 }
529
pmic_glink_altmode_put_retimer(void * data)530 static void pmic_glink_altmode_put_retimer(void *data)
531 {
532 typec_retimer_put(data);
533 }
534
pmic_glink_altmode_put_mux(void * data)535 static void pmic_glink_altmode_put_mux(void *data)
536 {
537 typec_mux_put(data);
538 }
539
pmic_glink_altmode_put_switch(void * data)540 static void pmic_glink_altmode_put_switch(void *data)
541 {
542 typec_switch_put(data);
543 }
544
pmic_glink_altmode_enable_worker(struct work_struct * work)545 static void pmic_glink_altmode_enable_worker(struct work_struct *work)
546 {
547 struct pmic_glink_altmode *altmode = work_to_altmode(work);
548 int ret;
549
550 ret = pmic_glink_altmode_request(altmode, ALTMODE_PAN_EN, 0);
551 if (ret)
552 dev_err(altmode->dev, "failed to request altmode notifications: %d\n", ret);
553 }
554
pmic_glink_altmode_pdr_notify(void * priv,int state)555 static void pmic_glink_altmode_pdr_notify(void *priv, int state)
556 {
557 struct pmic_glink_altmode *altmode = priv;
558
559 if (state == SERVREG_SERVICE_STATE_UP)
560 schedule_work(&altmode->enable_work);
561 }
562
563 static const struct of_device_id pmic_glink_altmode_of_quirks[] = {
564 { .compatible = "qcom,sc8180x-pmic-glink", .data = (void *)PMIC_GLINK_OWNER_USBC },
565 {}
566 };
567
pmic_glink_altmode_probe(struct auxiliary_device * adev,const struct auxiliary_device_id * id)568 static int pmic_glink_altmode_probe(struct auxiliary_device *adev,
569 const struct auxiliary_device_id *id)
570 {
571 struct pmic_glink_altmode_port *alt_port;
572 struct pmic_glink_altmode *altmode;
573 const struct of_device_id *match;
574 struct fwnode_handle *fwnode;
575 struct device *dev = &adev->dev;
576 u32 port;
577 int ret;
578
579 altmode = devm_kzalloc(dev, sizeof(*altmode), GFP_KERNEL);
580 if (!altmode)
581 return -ENOMEM;
582
583 altmode->dev = dev;
584
585 match = of_match_device(pmic_glink_altmode_of_quirks, dev->parent);
586 if (match)
587 altmode->owner_id = (unsigned long)match->data;
588 else
589 altmode->owner_id = PMIC_GLINK_OWNER_USBC_PAN;
590
591 INIT_WORK(&altmode->enable_work, pmic_glink_altmode_enable_worker);
592 init_completion(&altmode->pan_ack);
593 mutex_init(&altmode->lock);
594
595 device_for_each_child_node(dev, fwnode) {
596 ret = fwnode_property_read_u32(fwnode, "reg", &port);
597 if (ret < 0) {
598 dev_err(dev, "missing reg property of %pOFn\n", fwnode);
599 fwnode_handle_put(fwnode);
600 return ret;
601 }
602
603 if (port >= ARRAY_SIZE(altmode->ports)) {
604 dev_warn(dev, "invalid connector number, ignoring\n");
605 continue;
606 }
607
608 if (altmode->ports[port].altmode) {
609 dev_err(dev, "multiple connector definition for port %u\n", port);
610 fwnode_handle_put(fwnode);
611 return -EINVAL;
612 }
613
614 alt_port = &altmode->ports[port];
615 alt_port->altmode = altmode;
616 alt_port->index = port;
617 INIT_WORK(&alt_port->work, pmic_glink_altmode_worker);
618
619 alt_port->bridge = devm_drm_dp_hpd_bridge_alloc(dev, to_of_node(fwnode));
620 if (IS_ERR(alt_port->bridge)) {
621 fwnode_handle_put(fwnode);
622 return PTR_ERR(alt_port->bridge);
623 }
624
625 alt_port->dp_alt.svid = USB_TYPEC_DP_SID;
626 alt_port->dp_alt.mode = USB_TYPEC_DP_MODE;
627 alt_port->dp_alt.active = 1;
628
629 alt_port->tbt_alt.svid = USB_TYPEC_TBT_SID;
630 alt_port->tbt_alt.mode = TYPEC_TBT_MODE;
631 alt_port->tbt_alt.active = 1;
632
633 alt_port->typec_mux = fwnode_typec_mux_get(fwnode);
634 if (IS_ERR(alt_port->typec_mux)) {
635 fwnode_handle_put(fwnode);
636 return dev_err_probe(dev, PTR_ERR(alt_port->typec_mux),
637 "failed to acquire mode-switch for port: %d\n",
638 port);
639 }
640
641 ret = devm_add_action_or_reset(dev, pmic_glink_altmode_put_mux,
642 alt_port->typec_mux);
643 if (ret) {
644 fwnode_handle_put(fwnode);
645 return ret;
646 }
647
648 alt_port->typec_retimer = fwnode_typec_retimer_get(fwnode);
649 if (IS_ERR(alt_port->typec_retimer)) {
650 fwnode_handle_put(fwnode);
651 return dev_err_probe(dev, PTR_ERR(alt_port->typec_retimer),
652 "failed to acquire retimer-switch for port: %d\n",
653 port);
654 }
655
656 ret = devm_add_action_or_reset(dev, pmic_glink_altmode_put_retimer,
657 alt_port->typec_retimer);
658 if (ret) {
659 fwnode_handle_put(fwnode);
660 return ret;
661 }
662
663 alt_port->typec_switch = fwnode_typec_switch_get(fwnode);
664 if (IS_ERR(alt_port->typec_switch)) {
665 fwnode_handle_put(fwnode);
666 return dev_err_probe(dev, PTR_ERR(alt_port->typec_switch),
667 "failed to acquire orientation-switch for port: %d\n",
668 port);
669 }
670
671 ret = devm_add_action_or_reset(dev, pmic_glink_altmode_put_switch,
672 alt_port->typec_switch);
673 if (ret) {
674 fwnode_handle_put(fwnode);
675 return ret;
676 }
677 }
678
679 for (port = 0; port < ARRAY_SIZE(altmode->ports); port++) {
680 alt_port = &altmode->ports[port];
681 if (!alt_port->bridge)
682 continue;
683
684 ret = devm_drm_dp_hpd_bridge_add(dev, alt_port->bridge);
685 if (ret)
686 return ret;
687 }
688
689 altmode->client = devm_pmic_glink_client_alloc(dev,
690 altmode->owner_id,
691 pmic_glink_altmode_callback,
692 pmic_glink_altmode_pdr_notify,
693 altmode);
694 if (IS_ERR(altmode->client))
695 return PTR_ERR(altmode->client);
696
697 pmic_glink_client_register(altmode->client);
698
699 return 0;
700 }
701
702 static const struct auxiliary_device_id pmic_glink_altmode_id_table[] = {
703 { .name = "pmic_glink.altmode", },
704 {},
705 };
706 MODULE_DEVICE_TABLE(auxiliary, pmic_glink_altmode_id_table);
707
708 static struct auxiliary_driver pmic_glink_altmode_driver = {
709 .name = "pmic_glink_altmode",
710 .probe = pmic_glink_altmode_probe,
711 .id_table = pmic_glink_altmode_id_table,
712 };
713
714 module_auxiliary_driver(pmic_glink_altmode_driver);
715
716 MODULE_DESCRIPTION("Qualcomm PMIC GLINK Altmode driver");
717 MODULE_LICENSE("GPL");
718