1
2
3
4
5
6
7
8
9#include <linux/completion.h>
10#include <linux/property.h>
11#include <linux/device.h>
12#include <linux/module.h>
13#include <linux/delay.h>
14#include <linux/slab.h>
15#include <linux/usb/typec_dp.h>
16
17#include "ucsi.h"
18#include "trace.h"
19
20
21
22
23
24
25
26
27
28#define UCSI_TIMEOUT_MS 5000
29
30
31
32
33
34
35
36
37#define UCSI_SWAP_TIMEOUT_MS 5000
38
39static int ucsi_acknowledge_command(struct ucsi *ucsi)
40{
41 u64 ctrl;
42
43 ctrl = UCSI_ACK_CC_CI;
44 ctrl |= UCSI_ACK_COMMAND_COMPLETE;
45
46 return ucsi->ops->sync_write(ucsi, UCSI_CONTROL, &ctrl, sizeof(ctrl));
47}
48
49static int ucsi_acknowledge_connector_change(struct ucsi *ucsi)
50{
51 u64 ctrl;
52
53 ctrl = UCSI_ACK_CC_CI;
54 ctrl |= UCSI_ACK_CONNECTOR_CHANGE;
55
56 return ucsi->ops->sync_write(ucsi, UCSI_CONTROL, &ctrl, sizeof(ctrl));
57}
58
59static int ucsi_exec_command(struct ucsi *ucsi, u64 command);
60
61static int ucsi_read_error(struct ucsi *ucsi)
62{
63 u16 error;
64 int ret;
65
66
67 ret = ucsi_acknowledge_command(ucsi);
68 if (ret)
69 return ret;
70
71 ret = ucsi_exec_command(ucsi, UCSI_GET_ERROR_STATUS);
72 if (ret < 0)
73 return ret;
74
75 ret = ucsi->ops->read(ucsi, UCSI_MESSAGE_IN, &error, sizeof(error));
76 if (ret)
77 return ret;
78
79 switch (error) {
80 case UCSI_ERROR_INCOMPATIBLE_PARTNER:
81 return -EOPNOTSUPP;
82 case UCSI_ERROR_CC_COMMUNICATION_ERR:
83 return -ECOMM;
84 case UCSI_ERROR_CONTRACT_NEGOTIATION_FAIL:
85 return -EPROTO;
86 case UCSI_ERROR_DEAD_BATTERY:
87 dev_warn(ucsi->dev, "Dead battery condition!\n");
88 return -EPERM;
89 case UCSI_ERROR_INVALID_CON_NUM:
90 case UCSI_ERROR_UNREGONIZED_CMD:
91 case UCSI_ERROR_INVALID_CMD_ARGUMENT:
92 dev_err(ucsi->dev, "possible UCSI driver bug %u\n", error);
93 return -EINVAL;
94 case UCSI_ERROR_OVERCURRENT:
95 dev_warn(ucsi->dev, "Overcurrent condition\n");
96 break;
97 case UCSI_ERROR_PARTNER_REJECTED_SWAP:
98 dev_warn(ucsi->dev, "Partner rejected swap\n");
99 break;
100 case UCSI_ERROR_HARD_RESET:
101 dev_warn(ucsi->dev, "Hard reset occurred\n");
102 break;
103 case UCSI_ERROR_PPM_POLICY_CONFLICT:
104 dev_warn(ucsi->dev, "PPM Policy conflict\n");
105 break;
106 case UCSI_ERROR_SWAP_REJECTED:
107 dev_warn(ucsi->dev, "Swap rejected\n");
108 break;
109 case UCSI_ERROR_UNDEFINED:
110 default:
111 dev_err(ucsi->dev, "unknown error %u\n", error);
112 break;
113 }
114
115 return -EIO;
116}
117
118static int ucsi_exec_command(struct ucsi *ucsi, u64 cmd)
119{
120 u32 cci;
121 int ret;
122
123 ret = ucsi->ops->sync_write(ucsi, UCSI_CONTROL, &cmd, sizeof(cmd));
124 if (ret)
125 return ret;
126
127 ret = ucsi->ops->read(ucsi, UCSI_CCI, &cci, sizeof(cci));
128 if (ret)
129 return ret;
130
131 if (cci & UCSI_CCI_BUSY)
132 return -EBUSY;
133
134 if (!(cci & UCSI_CCI_COMMAND_COMPLETE))
135 return -EIO;
136
137 if (cci & UCSI_CCI_NOT_SUPPORTED)
138 return -EOPNOTSUPP;
139
140 if (cci & UCSI_CCI_ERROR) {
141 if (cmd == UCSI_GET_ERROR_STATUS)
142 return -EIO;
143 return ucsi_read_error(ucsi);
144 }
145
146 return UCSI_CCI_LENGTH(cci);
147}
148
149int ucsi_send_command(struct ucsi *ucsi, u64 command,
150 void *data, size_t size)
151{
152 u8 length;
153 int ret;
154
155 mutex_lock(&ucsi->ppm_lock);
156
157 ret = ucsi_exec_command(ucsi, command);
158 if (ret < 0)
159 goto out;
160
161 length = ret;
162
163 if (data) {
164 ret = ucsi->ops->read(ucsi, UCSI_MESSAGE_IN, data, size);
165 if (ret)
166 goto out;
167 }
168
169 ret = ucsi_acknowledge_command(ucsi);
170 if (ret)
171 goto out;
172
173 ret = length;
174out:
175 mutex_unlock(&ucsi->ppm_lock);
176 return ret;
177}
178EXPORT_SYMBOL_GPL(ucsi_send_command);
179
180int ucsi_resume(struct ucsi *ucsi)
181{
182 u64 command;
183
184
185 command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy;
186
187 return ucsi_send_command(ucsi, command, NULL, 0);
188}
189EXPORT_SYMBOL_GPL(ucsi_resume);
190
191
192void ucsi_altmode_update_active(struct ucsi_connector *con)
193{
194 const struct typec_altmode *altmode = NULL;
195 u64 command;
196 int ret;
197 u8 cur;
198 int i;
199
200 command = UCSI_GET_CURRENT_CAM | UCSI_CONNECTOR_NUMBER(con->num);
201 ret = ucsi_send_command(con->ucsi, command, &cur, sizeof(cur));
202 if (ret < 0) {
203 if (con->ucsi->version > 0x0100) {
204 dev_err(con->ucsi->dev,
205 "GET_CURRENT_CAM command failed\n");
206 return;
207 }
208 cur = 0xff;
209 }
210
211 if (cur < UCSI_MAX_ALTMODES)
212 altmode = typec_altmode_get_partner(con->port_altmode[cur]);
213
214 for (i = 0; con->partner_altmode[i]; i++)
215 typec_altmode_update_active(con->partner_altmode[i],
216 con->partner_altmode[i] == altmode);
217}
218
219static int ucsi_altmode_next_mode(struct typec_altmode **alt, u16 svid)
220{
221 u8 mode = 1;
222 int i;
223
224 for (i = 0; alt[i]; i++) {
225 if (i > MODE_DISCOVERY_MAX)
226 return -ERANGE;
227
228 if (alt[i]->svid == svid)
229 mode++;
230 }
231
232 return mode;
233}
234
235static int ucsi_next_altmode(struct typec_altmode **alt)
236{
237 int i = 0;
238
239 for (i = 0; i < UCSI_MAX_ALTMODES; i++)
240 if (!alt[i])
241 return i;
242
243 return -ENOENT;
244}
245
246static int ucsi_register_altmode(struct ucsi_connector *con,
247 struct typec_altmode_desc *desc,
248 u8 recipient)
249{
250 struct typec_altmode *alt;
251 bool override;
252 int ret;
253 int i;
254
255 override = !!(con->ucsi->cap.features & UCSI_CAP_ALT_MODE_OVERRIDE);
256
257 switch (recipient) {
258 case UCSI_RECIPIENT_CON:
259 i = ucsi_next_altmode(con->port_altmode);
260 if (i < 0) {
261 ret = i;
262 goto err;
263 }
264
265 ret = ucsi_altmode_next_mode(con->port_altmode, desc->svid);
266 if (ret < 0)
267 return ret;
268
269 desc->mode = ret;
270
271 switch (desc->svid) {
272 case USB_TYPEC_DP_SID:
273 alt = ucsi_register_displayport(con, override, i, desc);
274 break;
275 case USB_TYPEC_NVIDIA_VLINK_SID:
276 if (desc->vdo == USB_TYPEC_NVIDIA_VLINK_DBG_VDO)
277 alt = typec_port_register_altmode(con->port,
278 desc);
279 else
280 alt = ucsi_register_displayport(con, override,
281 i, desc);
282 break;
283 default:
284 alt = typec_port_register_altmode(con->port, desc);
285 break;
286 }
287
288 if (IS_ERR(alt)) {
289 ret = PTR_ERR(alt);
290 goto err;
291 }
292
293 con->port_altmode[i] = alt;
294 break;
295 case UCSI_RECIPIENT_SOP:
296 i = ucsi_next_altmode(con->partner_altmode);
297 if (i < 0) {
298 ret = i;
299 goto err;
300 }
301
302 ret = ucsi_altmode_next_mode(con->partner_altmode, desc->svid);
303 if (ret < 0)
304 return ret;
305
306 desc->mode = ret;
307
308 alt = typec_partner_register_altmode(con->partner, desc);
309 if (IS_ERR(alt)) {
310 ret = PTR_ERR(alt);
311 goto err;
312 }
313
314 con->partner_altmode[i] = alt;
315 break;
316 default:
317 return -EINVAL;
318 }
319
320 trace_ucsi_register_altmode(recipient, alt);
321
322 return 0;
323
324err:
325 dev_err(con->ucsi->dev, "failed to registers svid 0x%04x mode %d\n",
326 desc->svid, desc->mode);
327
328 return ret;
329}
330
331static int
332ucsi_register_altmodes_nvidia(struct ucsi_connector *con, u8 recipient)
333{
334 int max_altmodes = UCSI_MAX_ALTMODES;
335 struct typec_altmode_desc desc;
336 struct ucsi_altmode alt;
337 struct ucsi_altmode orig[UCSI_MAX_ALTMODES];
338 struct ucsi_altmode updated[UCSI_MAX_ALTMODES];
339 struct ucsi *ucsi = con->ucsi;
340 bool multi_dp = false;
341 u64 command;
342 int ret;
343 int len;
344 int i;
345 int k = 0;
346
347 if (recipient == UCSI_RECIPIENT_CON)
348 max_altmodes = con->ucsi->cap.num_alt_modes;
349
350 memset(orig, 0, sizeof(orig));
351 memset(updated, 0, sizeof(updated));
352
353
354 for (i = 0; i < max_altmodes; i++) {
355 memset(&alt, 0, sizeof(alt));
356 command = UCSI_GET_ALTERNATE_MODES;
357 command |= UCSI_GET_ALTMODE_RECIPIENT(recipient);
358 command |= UCSI_GET_ALTMODE_CONNECTOR_NUMBER(con->num);
359 command |= UCSI_GET_ALTMODE_OFFSET(i);
360 len = ucsi_send_command(con->ucsi, command, &alt, sizeof(alt));
361
362
363
364
365
366 if (len < 0)
367 return len;
368
369
370 if (!len || !alt.svid)
371 break;
372
373 orig[k].mid = alt.mid;
374 orig[k].svid = alt.svid;
375 k++;
376 }
377
378
379
380
381 if (recipient == UCSI_RECIPIENT_CON)
382 multi_dp = ucsi->ops->update_altmodes(ucsi, orig, updated);
383
384
385 for (i = 0; i < max_altmodes; i++) {
386 memset(&desc, 0, sizeof(desc));
387 if (multi_dp && recipient == UCSI_RECIPIENT_CON) {
388 desc.svid = updated[i].svid;
389 desc.vdo = updated[i].mid;
390 } else {
391 desc.svid = orig[i].svid;
392 desc.vdo = orig[i].mid;
393 }
394 desc.roles = TYPEC_PORT_DRD;
395
396 if (!desc.svid)
397 return 0;
398
399 ret = ucsi_register_altmode(con, &desc, recipient);
400 if (ret)
401 return ret;
402 }
403
404 return 0;
405}
406
407static int ucsi_register_altmodes(struct ucsi_connector *con, u8 recipient)
408{
409 int max_altmodes = UCSI_MAX_ALTMODES;
410 struct typec_altmode_desc desc;
411 struct ucsi_altmode alt[2];
412 u64 command;
413 int num;
414 int ret;
415 int len;
416 int j;
417 int i;
418
419 if (!(con->ucsi->cap.features & UCSI_CAP_ALT_MODE_DETAILS))
420 return 0;
421
422 if (recipient == UCSI_RECIPIENT_SOP && con->partner_altmode[0])
423 return 0;
424
425 if (con->ucsi->ops->update_altmodes)
426 return ucsi_register_altmodes_nvidia(con, recipient);
427
428 if (recipient == UCSI_RECIPIENT_CON)
429 max_altmodes = con->ucsi->cap.num_alt_modes;
430
431 for (i = 0; i < max_altmodes;) {
432 memset(alt, 0, sizeof(alt));
433 command = UCSI_GET_ALTERNATE_MODES;
434 command |= UCSI_GET_ALTMODE_RECIPIENT(recipient);
435 command |= UCSI_GET_ALTMODE_CONNECTOR_NUMBER(con->num);
436 command |= UCSI_GET_ALTMODE_OFFSET(i);
437 len = ucsi_send_command(con->ucsi, command, alt, sizeof(alt));
438 if (len <= 0)
439 return len;
440
441
442
443
444
445
446
447 num = len / sizeof(alt[0]);
448 i += num;
449
450 for (j = 0; j < num; j++) {
451 if (!alt[j].svid)
452 return 0;
453
454 memset(&desc, 0, sizeof(desc));
455 desc.vdo = alt[j].mid;
456 desc.svid = alt[j].svid;
457 desc.roles = TYPEC_PORT_DRD;
458
459 ret = ucsi_register_altmode(con, &desc, recipient);
460 if (ret)
461 return ret;
462 }
463 }
464
465 return 0;
466}
467
468static void ucsi_unregister_altmodes(struct ucsi_connector *con, u8 recipient)
469{
470 const struct typec_altmode *pdev;
471 struct typec_altmode **adev;
472 int i = 0;
473
474 switch (recipient) {
475 case UCSI_RECIPIENT_CON:
476 adev = con->port_altmode;
477 break;
478 case UCSI_RECIPIENT_SOP:
479 adev = con->partner_altmode;
480 break;
481 default:
482 return;
483 }
484
485 while (adev[i]) {
486 if (recipient == UCSI_RECIPIENT_SOP &&
487 (adev[i]->svid == USB_TYPEC_DP_SID ||
488 (adev[i]->svid == USB_TYPEC_NVIDIA_VLINK_SID &&
489 adev[i]->vdo != USB_TYPEC_NVIDIA_VLINK_DBG_VDO))) {
490 pdev = typec_altmode_get_partner(adev[i]);
491 ucsi_displayport_remove_partner((void *)pdev);
492 }
493 typec_unregister_altmode(adev[i]);
494 adev[i++] = NULL;
495 }
496}
497
498static int ucsi_get_pdos(struct ucsi_connector *con, int is_partner,
499 u32 *pdos, int offset, int num_pdos)
500{
501 struct ucsi *ucsi = con->ucsi;
502 u64 command;
503 int ret;
504
505 command = UCSI_COMMAND(UCSI_GET_PDOS) | UCSI_CONNECTOR_NUMBER(con->num);
506 command |= UCSI_GET_PDOS_PARTNER_PDO(is_partner);
507 command |= UCSI_GET_PDOS_PDO_OFFSET(offset);
508 command |= UCSI_GET_PDOS_NUM_PDOS(num_pdos - 1);
509 command |= UCSI_GET_PDOS_SRC_PDOS;
510 ret = ucsi_send_command(ucsi, command, pdos + offset,
511 num_pdos * sizeof(u32));
512 if (ret < 0)
513 dev_err(ucsi->dev, "UCSI_GET_PDOS failed (%d)\n", ret);
514 if (ret == 0 && offset == 0)
515 dev_warn(ucsi->dev, "UCSI_GET_PDOS returned 0 bytes\n");
516
517 return ret;
518}
519
520static void ucsi_get_src_pdos(struct ucsi_connector *con, int is_partner)
521{
522 int ret;
523
524
525 ret = ucsi_get_pdos(con, 1, con->src_pdos, 0, UCSI_MAX_PDOS);
526 if (ret < 0)
527 return;
528
529 con->num_pdos = ret / sizeof(u32);
530 if (con->num_pdos < UCSI_MAX_PDOS)
531 return;
532
533
534 ret = ucsi_get_pdos(con, 1, con->src_pdos, UCSI_MAX_PDOS,
535 PDO_MAX_OBJECTS - UCSI_MAX_PDOS);
536 if (ret < 0)
537 return;
538
539 con->num_pdos += ret / sizeof(u32);
540}
541
542static void ucsi_pwr_opmode_change(struct ucsi_connector *con)
543{
544 switch (UCSI_CONSTAT_PWR_OPMODE(con->status.flags)) {
545 case UCSI_CONSTAT_PWR_OPMODE_PD:
546 con->rdo = con->status.request_data_obj;
547 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_PD);
548 ucsi_get_src_pdos(con, 1);
549 break;
550 case UCSI_CONSTAT_PWR_OPMODE_TYPEC1_5:
551 con->rdo = 0;
552 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_1_5A);
553 break;
554 case UCSI_CONSTAT_PWR_OPMODE_TYPEC3_0:
555 con->rdo = 0;
556 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_3_0A);
557 break;
558 default:
559 con->rdo = 0;
560 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_USB);
561 break;
562 }
563}
564
565static int ucsi_register_partner(struct ucsi_connector *con)
566{
567 u8 pwr_opmode = UCSI_CONSTAT_PWR_OPMODE(con->status.flags);
568 struct typec_partner_desc desc;
569 struct typec_partner *partner;
570
571 if (con->partner)
572 return 0;
573
574 memset(&desc, 0, sizeof(desc));
575
576 switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) {
577 case UCSI_CONSTAT_PARTNER_TYPE_DEBUG:
578 desc.accessory = TYPEC_ACCESSORY_DEBUG;
579 break;
580 case UCSI_CONSTAT_PARTNER_TYPE_AUDIO:
581 desc.accessory = TYPEC_ACCESSORY_AUDIO;
582 break;
583 default:
584 break;
585 }
586
587 desc.usb_pd = pwr_opmode == UCSI_CONSTAT_PWR_OPMODE_PD;
588
589 partner = typec_register_partner(con->port, &desc);
590 if (IS_ERR(partner)) {
591 dev_err(con->ucsi->dev,
592 "con%d: failed to register partner (%ld)\n", con->num,
593 PTR_ERR(partner));
594 return PTR_ERR(partner);
595 }
596
597 con->partner = partner;
598
599 return 0;
600}
601
602static void ucsi_unregister_partner(struct ucsi_connector *con)
603{
604 if (!con->partner)
605 return;
606
607 ucsi_unregister_altmodes(con, UCSI_RECIPIENT_SOP);
608 typec_unregister_partner(con->partner);
609 con->partner = NULL;
610}
611
612static void ucsi_partner_change(struct ucsi_connector *con)
613{
614 enum usb_role u_role = USB_ROLE_NONE;
615 int ret;
616
617 if (!con->partner)
618 return;
619
620 switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) {
621 case UCSI_CONSTAT_PARTNER_TYPE_UFP:
622 case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP:
623 u_role = USB_ROLE_HOST;
624 fallthrough;
625 case UCSI_CONSTAT_PARTNER_TYPE_CABLE:
626 typec_set_data_role(con->port, TYPEC_HOST);
627 break;
628 case UCSI_CONSTAT_PARTNER_TYPE_DFP:
629 u_role = USB_ROLE_DEVICE;
630 typec_set_data_role(con->port, TYPEC_DEVICE);
631 break;
632 default:
633 break;
634 }
635
636
637 if (!completion_done(&con->complete))
638 complete(&con->complete);
639
640
641 if (!(UCSI_CONSTAT_PARTNER_FLAGS(con->status.flags) & UCSI_CONSTAT_PARTNER_FLAG_USB))
642 u_role = USB_ROLE_NONE;
643
644 ret = usb_role_switch_set_role(con->usb_role_sw, u_role);
645 if (ret)
646 dev_err(con->ucsi->dev, "con:%d: failed to set usb role:%d\n",
647 con->num, u_role);
648
649
650 ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_SOP);
651 if (ret)
652 dev_err(con->ucsi->dev,
653 "con%d: failed to register partner alternate modes\n",
654 con->num);
655 else
656 ucsi_altmode_update_active(con);
657}
658
659static void ucsi_handle_connector_change(struct work_struct *work)
660{
661 struct ucsi_connector *con = container_of(work, struct ucsi_connector,
662 work);
663 struct ucsi *ucsi = con->ucsi;
664 struct ucsi_connector_status pre_ack_status;
665 struct ucsi_connector_status post_ack_status;
666 enum typec_role role;
667 enum usb_role u_role = USB_ROLE_NONE;
668 u16 inferred_changes;
669 u16 changed_flags;
670 u64 command;
671 int ret;
672
673 mutex_lock(&con->lock);
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704 command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num);
705 ret = ucsi_send_command(ucsi, command, &pre_ack_status,
706 sizeof(pre_ack_status));
707 if (ret < 0) {
708 dev_err(ucsi->dev, "%s: GET_CONNECTOR_STATUS failed (%d)\n",
709 __func__, ret);
710 goto out_unlock;
711 }
712 con->unprocessed_changes |= pre_ack_status.change;
713
714
715 command = UCSI_GET_CAM_SUPPORTED;
716 command |= UCSI_CONNECTOR_NUMBER(con->num);
717 ucsi_send_command(con->ucsi, command, NULL, 0);
718
719
720 ret = ucsi_acknowledge_connector_change(ucsi);
721 clear_bit(EVENT_PENDING, &ucsi->flags);
722 if (ret) {
723 dev_err(ucsi->dev, "%s: ACK failed (%d)", __func__, ret);
724 goto out_unlock;
725 }
726
727
728 command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num);
729 ret = ucsi_send_command(ucsi, command, &post_ack_status,
730 sizeof(post_ack_status));
731 if (ret < 0) {
732 dev_err(ucsi->dev, "%s: GET_CONNECTOR_STATUS failed (%d)\n",
733 __func__, ret);
734 goto out_unlock;
735 }
736
737
738 changed_flags = pre_ack_status.flags ^ post_ack_status.flags;
739 inferred_changes = 0;
740 if (UCSI_CONSTAT_PWR_OPMODE(changed_flags) != 0)
741 inferred_changes |= UCSI_CONSTAT_POWER_OPMODE_CHANGE;
742
743 if (changed_flags & UCSI_CONSTAT_CONNECTED)
744 inferred_changes |= UCSI_CONSTAT_CONNECT_CHANGE;
745
746 if (changed_flags & UCSI_CONSTAT_PWR_DIR)
747 inferred_changes |= UCSI_CONSTAT_POWER_DIR_CHANGE;
748
749 if (UCSI_CONSTAT_PARTNER_FLAGS(changed_flags) != 0)
750 inferred_changes |= UCSI_CONSTAT_PARTNER_CHANGE;
751
752 if (UCSI_CONSTAT_PARTNER_TYPE(changed_flags) != 0)
753 inferred_changes |= UCSI_CONSTAT_PARTNER_CHANGE;
754
755
756 inferred_changes &= ~post_ack_status.change;
757 if (inferred_changes)
758 dev_dbg(ucsi->dev, "%s: Inferred changes that would have been lost: 0x%04x\n",
759 __func__, inferred_changes);
760
761 con->unprocessed_changes |= inferred_changes;
762
763
764 if (post_ack_status.change)
765 goto out_unlock;
766
767
768 con->status = post_ack_status;
769 con->status.change = con->unprocessed_changes;
770 con->unprocessed_changes = 0;
771
772 role = !!(con->status.flags & UCSI_CONSTAT_PWR_DIR);
773
774 if (con->status.change & UCSI_CONSTAT_POWER_OPMODE_CHANGE ||
775 con->status.change & UCSI_CONSTAT_POWER_LEVEL_CHANGE) {
776 ucsi_pwr_opmode_change(con);
777 ucsi_port_psy_changed(con);
778 }
779
780 if (con->status.change & UCSI_CONSTAT_POWER_DIR_CHANGE) {
781 typec_set_pwr_role(con->port, role);
782
783
784 if (!completion_done(&con->complete))
785 complete(&con->complete);
786 }
787
788 if (con->status.change & UCSI_CONSTAT_CONNECT_CHANGE) {
789 typec_set_pwr_role(con->port, role);
790
791 switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) {
792 case UCSI_CONSTAT_PARTNER_TYPE_UFP:
793 case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP:
794 u_role = USB_ROLE_HOST;
795 fallthrough;
796 case UCSI_CONSTAT_PARTNER_TYPE_CABLE:
797 typec_set_data_role(con->port, TYPEC_HOST);
798 break;
799 case UCSI_CONSTAT_PARTNER_TYPE_DFP:
800 u_role = USB_ROLE_DEVICE;
801 typec_set_data_role(con->port, TYPEC_DEVICE);
802 break;
803 default:
804 break;
805 }
806
807 if (con->status.flags & UCSI_CONSTAT_CONNECTED)
808 ucsi_register_partner(con);
809 else
810 ucsi_unregister_partner(con);
811
812 ucsi_port_psy_changed(con);
813
814
815 if (!(UCSI_CONSTAT_PARTNER_FLAGS(con->status.flags) &
816 UCSI_CONSTAT_PARTNER_FLAG_USB))
817 u_role = USB_ROLE_NONE;
818
819 ret = usb_role_switch_set_role(con->usb_role_sw, u_role);
820 if (ret)
821 dev_err(ucsi->dev, "con:%d: failed to set usb role:%d\n",
822 con->num, u_role);
823 }
824
825 if (con->status.change & UCSI_CONSTAT_PARTNER_CHANGE)
826 ucsi_partner_change(con);
827
828 trace_ucsi_connector_change(con->num, &con->status);
829
830out_unlock:
831 if (test_and_clear_bit(EVENT_PENDING, &ucsi->flags)) {
832 schedule_work(&con->work);
833 mutex_unlock(&con->lock);
834 return;
835 }
836
837 clear_bit(EVENT_PROCESSING, &ucsi->flags);
838 mutex_unlock(&con->lock);
839}
840
841
842
843
844
845
846void ucsi_connector_change(struct ucsi *ucsi, u8 num)
847{
848 struct ucsi_connector *con = &ucsi->connector[num - 1];
849
850 if (!(ucsi->ntfy & UCSI_ENABLE_NTFY_CONNECTOR_CHANGE)) {
851 dev_dbg(ucsi->dev, "Bogus connector change event\n");
852 return;
853 }
854
855 set_bit(EVENT_PENDING, &ucsi->flags);
856
857 if (!test_and_set_bit(EVENT_PROCESSING, &ucsi->flags))
858 schedule_work(&con->work);
859}
860EXPORT_SYMBOL_GPL(ucsi_connector_change);
861
862
863
864static int ucsi_reset_connector(struct ucsi_connector *con, bool hard)
865{
866 u64 command;
867
868 command = UCSI_CONNECTOR_RESET | UCSI_CONNECTOR_NUMBER(con->num);
869 command |= hard ? UCSI_CONNECTOR_RESET_HARD : 0;
870
871 return ucsi_send_command(con->ucsi, command, NULL, 0);
872}
873
874static int ucsi_reset_ppm(struct ucsi *ucsi)
875{
876 u64 command = UCSI_PPM_RESET;
877 unsigned long tmo;
878 u32 cci;
879 int ret;
880
881 mutex_lock(&ucsi->ppm_lock);
882
883 ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL, &command,
884 sizeof(command));
885 if (ret < 0)
886 goto out;
887
888 tmo = jiffies + msecs_to_jiffies(UCSI_TIMEOUT_MS);
889
890 do {
891 if (time_is_before_jiffies(tmo)) {
892 ret = -ETIMEDOUT;
893 goto out;
894 }
895
896 ret = ucsi->ops->read(ucsi, UCSI_CCI, &cci, sizeof(cci));
897 if (ret)
898 goto out;
899
900
901 if (cci & ~UCSI_CCI_RESET_COMPLETE) {
902 ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL,
903 &command,
904 sizeof(command));
905 if (ret < 0)
906 goto out;
907 }
908
909 msleep(20);
910 } while (!(cci & UCSI_CCI_RESET_COMPLETE));
911
912out:
913 mutex_unlock(&ucsi->ppm_lock);
914 return ret;
915}
916
917static int ucsi_role_cmd(struct ucsi_connector *con, u64 command)
918{
919 int ret;
920
921 ret = ucsi_send_command(con->ucsi, command, NULL, 0);
922 if (ret == -ETIMEDOUT) {
923 u64 c;
924
925
926 ucsi_reset_ppm(con->ucsi);
927
928 c = UCSI_SET_NOTIFICATION_ENABLE | con->ucsi->ntfy;
929 ucsi_send_command(con->ucsi, c, NULL, 0);
930
931 ucsi_reset_connector(con, true);
932 }
933
934 return ret;
935}
936
937static int ucsi_dr_swap(struct typec_port *port, enum typec_data_role role)
938{
939 struct ucsi_connector *con = typec_get_drvdata(port);
940 u8 partner_type;
941 u64 command;
942 int ret = 0;
943
944 mutex_lock(&con->lock);
945
946 if (!con->partner) {
947 ret = -ENOTCONN;
948 goto out_unlock;
949 }
950
951 partner_type = UCSI_CONSTAT_PARTNER_TYPE(con->status.flags);
952 if ((partner_type == UCSI_CONSTAT_PARTNER_TYPE_DFP &&
953 role == TYPEC_DEVICE) ||
954 (partner_type == UCSI_CONSTAT_PARTNER_TYPE_UFP &&
955 role == TYPEC_HOST))
956 goto out_unlock;
957
958 command = UCSI_SET_UOR | UCSI_CONNECTOR_NUMBER(con->num);
959 command |= UCSI_SET_UOR_ROLE(role);
960 command |= UCSI_SET_UOR_ACCEPT_ROLE_SWAPS;
961 ret = ucsi_role_cmd(con, command);
962 if (ret < 0)
963 goto out_unlock;
964
965 if (!wait_for_completion_timeout(&con->complete,
966 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS)))
967 ret = -ETIMEDOUT;
968
969out_unlock:
970 mutex_unlock(&con->lock);
971
972 return ret < 0 ? ret : 0;
973}
974
975static int ucsi_pr_swap(struct typec_port *port, enum typec_role role)
976{
977 struct ucsi_connector *con = typec_get_drvdata(port);
978 enum typec_role cur_role;
979 u64 command;
980 int ret = 0;
981
982 mutex_lock(&con->lock);
983
984 if (!con->partner) {
985 ret = -ENOTCONN;
986 goto out_unlock;
987 }
988
989 cur_role = !!(con->status.flags & UCSI_CONSTAT_PWR_DIR);
990
991 if (cur_role == role)
992 goto out_unlock;
993
994 command = UCSI_SET_PDR | UCSI_CONNECTOR_NUMBER(con->num);
995 command |= UCSI_SET_PDR_ROLE(role);
996 command |= UCSI_SET_PDR_ACCEPT_ROLE_SWAPS;
997 ret = ucsi_role_cmd(con, command);
998 if (ret < 0)
999 goto out_unlock;
1000
1001 if (!wait_for_completion_timeout(&con->complete,
1002 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS))) {
1003 ret = -ETIMEDOUT;
1004 goto out_unlock;
1005 }
1006
1007
1008 if (UCSI_CONSTAT_PWR_OPMODE(con->status.flags) !=
1009 UCSI_CONSTAT_PWR_OPMODE_PD) {
1010 ucsi_reset_connector(con, true);
1011 ret = -EPROTO;
1012 }
1013
1014out_unlock:
1015 mutex_unlock(&con->lock);
1016
1017 return ret;
1018}
1019
1020static const struct typec_operations ucsi_ops = {
1021 .dr_set = ucsi_dr_swap,
1022 .pr_set = ucsi_pr_swap
1023};
1024
1025
1026static struct fwnode_handle *ucsi_find_fwnode(struct ucsi_connector *con)
1027{
1028 struct fwnode_handle *fwnode;
1029 int i = 1;
1030
1031 device_for_each_child_node(con->ucsi->dev, fwnode)
1032 if (i++ == con->num)
1033 return fwnode;
1034 return NULL;
1035}
1036
1037static int ucsi_register_port(struct ucsi *ucsi, int index)
1038{
1039 struct ucsi_connector *con = &ucsi->connector[index];
1040 struct typec_capability *cap = &con->typec_cap;
1041 enum typec_accessory *accessory = cap->accessory;
1042 enum usb_role u_role = USB_ROLE_NONE;
1043 u64 command;
1044 int ret;
1045
1046 INIT_WORK(&con->work, ucsi_handle_connector_change);
1047 init_completion(&con->complete);
1048 mutex_init(&con->lock);
1049 con->num = index + 1;
1050 con->ucsi = ucsi;
1051
1052
1053 mutex_lock(&con->lock);
1054
1055
1056 command = UCSI_GET_CONNECTOR_CAPABILITY;
1057 command |= UCSI_CONNECTOR_NUMBER(con->num);
1058 ret = ucsi_send_command(ucsi, command, &con->cap, sizeof(con->cap));
1059 if (ret < 0)
1060 goto out_unlock;
1061
1062 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DRP)
1063 cap->data = TYPEC_PORT_DRD;
1064 else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DFP)
1065 cap->data = TYPEC_PORT_DFP;
1066 else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_UFP)
1067 cap->data = TYPEC_PORT_UFP;
1068
1069 if ((con->cap.flags & UCSI_CONCAP_FLAG_PROVIDER) &&
1070 (con->cap.flags & UCSI_CONCAP_FLAG_CONSUMER))
1071 cap->type = TYPEC_PORT_DRP;
1072 else if (con->cap.flags & UCSI_CONCAP_FLAG_PROVIDER)
1073 cap->type = TYPEC_PORT_SRC;
1074 else if (con->cap.flags & UCSI_CONCAP_FLAG_CONSUMER)
1075 cap->type = TYPEC_PORT_SNK;
1076
1077 cap->revision = ucsi->cap.typec_version;
1078 cap->pd_revision = ucsi->cap.pd_version;
1079 cap->svdm_version = SVDM_VER_2_0;
1080 cap->prefer_role = TYPEC_NO_PREFERRED_ROLE;
1081
1082 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_AUDIO_ACCESSORY)
1083 *accessory++ = TYPEC_ACCESSORY_AUDIO;
1084 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DEBUG_ACCESSORY)
1085 *accessory = TYPEC_ACCESSORY_DEBUG;
1086
1087 cap->fwnode = ucsi_find_fwnode(con);
1088 cap->driver_data = con;
1089 cap->ops = &ucsi_ops;
1090
1091 ret = ucsi_register_port_psy(con);
1092 if (ret)
1093 goto out;
1094
1095
1096 con->port = typec_register_port(ucsi->dev, cap);
1097 if (IS_ERR(con->port)) {
1098 ret = PTR_ERR(con->port);
1099 goto out;
1100 }
1101
1102
1103 ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_CON);
1104 if (ret) {
1105 dev_err(ucsi->dev, "con%d: failed to register alt modes\n",
1106 con->num);
1107 goto out;
1108 }
1109
1110
1111 command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num);
1112 ret = ucsi_send_command(ucsi, command, &con->status, sizeof(con->status));
1113 if (ret < 0) {
1114 dev_err(ucsi->dev, "con%d: failed to get status\n", con->num);
1115 ret = 0;
1116 goto out;
1117 }
1118 ret = 0;
1119
1120 switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) {
1121 case UCSI_CONSTAT_PARTNER_TYPE_UFP:
1122 case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP:
1123 u_role = USB_ROLE_HOST;
1124 fallthrough;
1125 case UCSI_CONSTAT_PARTNER_TYPE_CABLE:
1126 typec_set_data_role(con->port, TYPEC_HOST);
1127 break;
1128 case UCSI_CONSTAT_PARTNER_TYPE_DFP:
1129 u_role = USB_ROLE_DEVICE;
1130 typec_set_data_role(con->port, TYPEC_DEVICE);
1131 break;
1132 default:
1133 break;
1134 }
1135
1136
1137 if (con->status.flags & UCSI_CONSTAT_CONNECTED) {
1138 typec_set_pwr_role(con->port,
1139 !!(con->status.flags & UCSI_CONSTAT_PWR_DIR));
1140 ucsi_pwr_opmode_change(con);
1141 ucsi_register_partner(con);
1142 ucsi_port_psy_changed(con);
1143 }
1144
1145 con->usb_role_sw = fwnode_usb_role_switch_get(cap->fwnode);
1146 if (IS_ERR(con->usb_role_sw)) {
1147 dev_err(ucsi->dev, "con%d: failed to get usb role switch\n",
1148 con->num);
1149 con->usb_role_sw = NULL;
1150 }
1151
1152
1153 if (!(UCSI_CONSTAT_PARTNER_FLAGS(con->status.flags) & UCSI_CONSTAT_PARTNER_FLAG_USB))
1154 u_role = USB_ROLE_NONE;
1155
1156 ret = usb_role_switch_set_role(con->usb_role_sw, u_role);
1157 if (ret) {
1158 dev_err(ucsi->dev, "con:%d: failed to set usb role:%d\n",
1159 con->num, u_role);
1160 ret = 0;
1161 }
1162
1163 if (con->partner) {
1164 ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_SOP);
1165 if (ret) {
1166 dev_err(ucsi->dev,
1167 "con%d: failed to register alternate modes\n",
1168 con->num);
1169 ret = 0;
1170 } else {
1171 ucsi_altmode_update_active(con);
1172 }
1173 }
1174
1175 trace_ucsi_register_port(con->num, &con->status);
1176
1177out:
1178 fwnode_handle_put(cap->fwnode);
1179out_unlock:
1180 mutex_unlock(&con->lock);
1181 return ret;
1182}
1183
1184
1185
1186
1187
1188
1189
1190static int ucsi_init(struct ucsi *ucsi)
1191{
1192 struct ucsi_connector *con;
1193 u64 command;
1194 int ret;
1195 int i;
1196
1197
1198 ret = ucsi_reset_ppm(ucsi);
1199 if (ret) {
1200 dev_err(ucsi->dev, "failed to reset PPM!\n");
1201 goto err;
1202 }
1203
1204
1205 ucsi->ntfy = UCSI_ENABLE_NTFY_CMD_COMPLETE | UCSI_ENABLE_NTFY_ERROR;
1206 command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy;
1207 ret = ucsi_send_command(ucsi, command, NULL, 0);
1208 if (ret < 0)
1209 goto err_reset;
1210
1211
1212 command = UCSI_GET_CAPABILITY;
1213 ret = ucsi_send_command(ucsi, command, &ucsi->cap, sizeof(ucsi->cap));
1214 if (ret < 0)
1215 goto err_reset;
1216
1217 if (!ucsi->cap.num_connectors) {
1218 ret = -ENODEV;
1219 goto err_reset;
1220 }
1221
1222
1223 ucsi->connector = kcalloc(ucsi->cap.num_connectors + 1,
1224 sizeof(*ucsi->connector), GFP_KERNEL);
1225 if (!ucsi->connector) {
1226 ret = -ENOMEM;
1227 goto err_reset;
1228 }
1229
1230
1231 for (i = 0; i < ucsi->cap.num_connectors; i++) {
1232 ret = ucsi_register_port(ucsi, i);
1233 if (ret)
1234 goto err_unregister;
1235 }
1236
1237
1238 ucsi->ntfy = UCSI_ENABLE_NTFY_ALL;
1239 command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy;
1240 ret = ucsi_send_command(ucsi, command, NULL, 0);
1241 if (ret < 0)
1242 goto err_unregister;
1243
1244 return 0;
1245
1246err_unregister:
1247 for (con = ucsi->connector; con->port; con++) {
1248 ucsi_unregister_partner(con);
1249 ucsi_unregister_altmodes(con, UCSI_RECIPIENT_CON);
1250 ucsi_unregister_port_psy(con);
1251 typec_unregister_port(con->port);
1252 con->port = NULL;
1253 }
1254
1255err_reset:
1256 memset(&ucsi->cap, 0, sizeof(ucsi->cap));
1257 ucsi_reset_ppm(ucsi);
1258err:
1259 return ret;
1260}
1261
1262static void ucsi_init_work(struct work_struct *work)
1263{
1264 struct ucsi *ucsi = container_of(work, struct ucsi, work);
1265 int ret;
1266
1267 ret = ucsi_init(ucsi);
1268 if (ret)
1269 dev_err(ucsi->dev, "PPM init failed (%d)\n", ret);
1270}
1271
1272
1273
1274
1275
1276void *ucsi_get_drvdata(struct ucsi *ucsi)
1277{
1278 return ucsi->driver_data;
1279}
1280EXPORT_SYMBOL_GPL(ucsi_get_drvdata);
1281
1282
1283
1284
1285
1286
1287void ucsi_set_drvdata(struct ucsi *ucsi, void *data)
1288{
1289 ucsi->driver_data = data;
1290}
1291EXPORT_SYMBOL_GPL(ucsi_set_drvdata);
1292
1293
1294
1295
1296
1297
1298struct ucsi *ucsi_create(struct device *dev, const struct ucsi_operations *ops)
1299{
1300 struct ucsi *ucsi;
1301
1302 if (!ops || !ops->read || !ops->sync_write || !ops->async_write)
1303 return ERR_PTR(-EINVAL);
1304
1305 ucsi = kzalloc(sizeof(*ucsi), GFP_KERNEL);
1306 if (!ucsi)
1307 return ERR_PTR(-ENOMEM);
1308
1309 INIT_WORK(&ucsi->work, ucsi_init_work);
1310 mutex_init(&ucsi->ppm_lock);
1311 ucsi->dev = dev;
1312 ucsi->ops = ops;
1313
1314 return ucsi;
1315}
1316EXPORT_SYMBOL_GPL(ucsi_create);
1317
1318
1319
1320
1321
1322void ucsi_destroy(struct ucsi *ucsi)
1323{
1324 kfree(ucsi);
1325}
1326EXPORT_SYMBOL_GPL(ucsi_destroy);
1327
1328
1329
1330
1331
1332int ucsi_register(struct ucsi *ucsi)
1333{
1334 int ret;
1335
1336 ret = ucsi->ops->read(ucsi, UCSI_VERSION, &ucsi->version,
1337 sizeof(ucsi->version));
1338 if (ret)
1339 return ret;
1340
1341 if (!ucsi->version)
1342 return -ENODEV;
1343
1344 queue_work(system_long_wq, &ucsi->work);
1345
1346 return 0;
1347}
1348EXPORT_SYMBOL_GPL(ucsi_register);
1349
1350
1351
1352
1353
1354
1355
1356void ucsi_unregister(struct ucsi *ucsi)
1357{
1358 u64 cmd = UCSI_SET_NOTIFICATION_ENABLE;
1359 int i;
1360
1361
1362 cancel_work_sync(&ucsi->work);
1363
1364
1365 ucsi->ops->async_write(ucsi, UCSI_CONTROL, &cmd, sizeof(cmd));
1366
1367 for (i = 0; i < ucsi->cap.num_connectors; i++) {
1368 cancel_work_sync(&ucsi->connector[i].work);
1369 ucsi_unregister_partner(&ucsi->connector[i]);
1370 ucsi_unregister_altmodes(&ucsi->connector[i],
1371 UCSI_RECIPIENT_CON);
1372 ucsi_unregister_port_psy(&ucsi->connector[i]);
1373 typec_unregister_port(ucsi->connector[i].port);
1374 }
1375
1376 kfree(ucsi->connector);
1377}
1378EXPORT_SYMBOL_GPL(ucsi_unregister);
1379
1380MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
1381MODULE_LICENSE("GPL v2");
1382MODULE_DESCRIPTION("USB Type-C Connector System Software Interface driver");
1383
