1 // SPDX-License-Identifier: GPL-2.0
3 * USB Type-C Connector System Software Interface driver
5 * Copyright (C) 2017, Intel Corporation
6 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
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>
21 * UCSI_TIMEOUT_MS - PPM communication timeout
23 * Ideally we could use MIN_TIME_TO_RESPOND_WITH_BUSY (which is defined in UCSI
24 * specification) here as reference, but unfortunately we can't. It is very
25 * difficult to estimate the time it takes for the system to process the command
26 * before it is actually passed to the PPM.
28 #define UCSI_TIMEOUT_MS 5000
31 * UCSI_SWAP_TIMEOUT_MS - Timeout for role swap requests
33 * 5 seconds is close to the time it takes for CapsCounter to reach 0, so even
34 * if the PPM does not generate Connector Change events before that with
35 * partners that do not support USB Power Delivery, this should still work.
37 #define UCSI_SWAP_TIMEOUT_MS 5000
39 static int ucsi_acknowledge_command(struct ucsi
*ucsi
)
43 ctrl
= UCSI_ACK_CC_CI
;
44 ctrl
|= UCSI_ACK_COMMAND_COMPLETE
;
46 return ucsi
->ops
->sync_write(ucsi
, UCSI_CONTROL
, &ctrl
, sizeof(ctrl
));
49 static int ucsi_acknowledge_connector_change(struct ucsi
*ucsi
)
53 ctrl
= UCSI_ACK_CC_CI
;
54 ctrl
|= UCSI_ACK_CONNECTOR_CHANGE
;
56 return ucsi
->ops
->sync_write(ucsi
, UCSI_CONTROL
, &ctrl
, sizeof(ctrl
));
59 static int ucsi_exec_command(struct ucsi
*ucsi
, u64 command
);
61 static int ucsi_read_error(struct ucsi
*ucsi
)
66 /* Acknowlege the command that failed */
67 ret
= ucsi_acknowledge_command(ucsi
);
71 ret
= ucsi_exec_command(ucsi
, UCSI_GET_ERROR_STATUS
);
75 ret
= ucsi
->ops
->read(ucsi
, UCSI_MESSAGE_IN
, &error
, sizeof(error
));
80 case UCSI_ERROR_INCOMPATIBLE_PARTNER
:
82 case UCSI_ERROR_CC_COMMUNICATION_ERR
:
84 case UCSI_ERROR_CONTRACT_NEGOTIATION_FAIL
:
86 case UCSI_ERROR_DEAD_BATTERY
:
87 dev_warn(ucsi
->dev
, "Dead battery condition!\n");
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
);
94 case UCSI_ERROR_OVERCURRENT
:
95 dev_warn(ucsi
->dev
, "Overcurrent condition\n");
97 case UCSI_ERROR_PARTNER_REJECTED_SWAP
:
98 dev_warn(ucsi
->dev
, "Partner rejected swap\n");
100 case UCSI_ERROR_HARD_RESET
:
101 dev_warn(ucsi
->dev
, "Hard reset occurred\n");
103 case UCSI_ERROR_PPM_POLICY_CONFLICT
:
104 dev_warn(ucsi
->dev
, "PPM Policy conflict\n");
106 case UCSI_ERROR_SWAP_REJECTED
:
107 dev_warn(ucsi
->dev
, "Swap rejected\n");
109 case UCSI_ERROR_UNDEFINED
:
111 dev_err(ucsi
->dev
, "unknown error %u\n", error
);
118 static int ucsi_exec_command(struct ucsi
*ucsi
, u64 cmd
)
123 ret
= ucsi
->ops
->sync_write(ucsi
, UCSI_CONTROL
, &cmd
, sizeof(cmd
));
127 ret
= ucsi
->ops
->read(ucsi
, UCSI_CCI
, &cci
, sizeof(cci
));
131 if (cci
& UCSI_CCI_BUSY
)
134 if (!(cci
& UCSI_CCI_COMMAND_COMPLETE
))
137 if (cci
& UCSI_CCI_NOT_SUPPORTED
)
140 if (cci
& UCSI_CCI_ERROR
) {
141 if (cmd
== UCSI_GET_ERROR_STATUS
)
143 return ucsi_read_error(ucsi
);
146 return UCSI_CCI_LENGTH(cci
);
149 int ucsi_send_command(struct ucsi
*ucsi
, u64 command
,
150 void *data
, size_t size
)
155 mutex_lock(&ucsi
->ppm_lock
);
157 ret
= ucsi_exec_command(ucsi
, command
);
164 ret
= ucsi
->ops
->read(ucsi
, UCSI_MESSAGE_IN
, data
, size
);
169 ret
= ucsi_acknowledge_command(ucsi
);
175 mutex_unlock(&ucsi
->ppm_lock
);
178 EXPORT_SYMBOL_GPL(ucsi_send_command
);
180 int ucsi_resume(struct ucsi
*ucsi
)
184 /* Restore UCSI notification enable mask after system resume */
185 command
= UCSI_SET_NOTIFICATION_ENABLE
| ucsi
->ntfy
;
187 return ucsi_send_command(ucsi
, command
, NULL
, 0);
189 EXPORT_SYMBOL_GPL(ucsi_resume
);
190 /* -------------------------------------------------------------------------- */
192 void ucsi_altmode_update_active(struct ucsi_connector
*con
)
194 const struct typec_altmode
*altmode
= NULL
;
200 command
= UCSI_GET_CURRENT_CAM
| UCSI_CONNECTOR_NUMBER(con
->num
);
201 ret
= ucsi_send_command(con
->ucsi
, command
, &cur
, sizeof(cur
));
203 if (con
->ucsi
->version
> 0x0100) {
204 dev_err(con
->ucsi
->dev
,
205 "GET_CURRENT_CAM command failed\n");
211 if (cur
< UCSI_MAX_ALTMODES
)
212 altmode
= typec_altmode_get_partner(con
->port_altmode
[cur
]);
214 for (i
= 0; con
->partner_altmode
[i
]; i
++)
215 typec_altmode_update_active(con
->partner_altmode
[i
],
216 con
->partner_altmode
[i
] == altmode
);
219 static int ucsi_altmode_next_mode(struct typec_altmode
**alt
, u16 svid
)
224 for (i
= 0; alt
[i
]; i
++) {
225 if (i
> MODE_DISCOVERY_MAX
)
228 if (alt
[i
]->svid
== svid
)
235 static int ucsi_next_altmode(struct typec_altmode
**alt
)
239 for (i
= 0; i
< UCSI_MAX_ALTMODES
; i
++)
246 static int ucsi_register_altmode(struct ucsi_connector
*con
,
247 struct typec_altmode_desc
*desc
,
250 struct typec_altmode
*alt
;
255 override
= !!(con
->ucsi
->cap
.features
& UCSI_CAP_ALT_MODE_OVERRIDE
);
258 case UCSI_RECIPIENT_CON
:
259 i
= ucsi_next_altmode(con
->port_altmode
);
265 ret
= ucsi_altmode_next_mode(con
->port_altmode
, desc
->svid
);
271 switch (desc
->svid
) {
272 case USB_TYPEC_DP_SID
:
273 alt
= ucsi_register_displayport(con
, override
, i
, desc
);
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
,
280 alt
= ucsi_register_displayport(con
, override
,
284 alt
= typec_port_register_altmode(con
->port
, desc
);
293 con
->port_altmode
[i
] = alt
;
295 case UCSI_RECIPIENT_SOP
:
296 i
= ucsi_next_altmode(con
->partner_altmode
);
302 ret
= ucsi_altmode_next_mode(con
->partner_altmode
, desc
->svid
);
308 alt
= typec_partner_register_altmode(con
->partner
, desc
);
314 con
->partner_altmode
[i
] = alt
;
320 trace_ucsi_register_altmode(recipient
, alt
);
325 dev_err(con
->ucsi
->dev
, "failed to registers svid 0x%04x mode %d\n",
326 desc
->svid
, desc
->mode
);
332 ucsi_register_altmodes_nvidia(struct ucsi_connector
*con
, u8 recipient
)
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;
347 if (recipient
== UCSI_RECIPIENT_CON
)
348 max_altmodes
= con
->ucsi
->cap
.num_alt_modes
;
350 memset(orig
, 0, sizeof(orig
));
351 memset(updated
, 0, sizeof(updated
));
353 /* First get all the alternate modes */
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
));
362 * We are collecting all altmodes first and then registering.
363 * Some type-C device will return zero length data beyond last
364 * alternate modes. We should not return if length is zero.
369 /* We got all altmodes, now break out and register them */
370 if (!len
|| !alt
.svid
)
373 orig
[k
].mid
= alt
.mid
;
374 orig
[k
].svid
= alt
.svid
;
378 * Update the original altmode table as some ppms may report
379 * multiple DP altmodes.
381 if (recipient
== UCSI_RECIPIENT_CON
)
382 multi_dp
= ucsi
->ops
->update_altmodes(ucsi
, orig
, updated
);
384 /* now register altmodes */
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
;
391 desc
.svid
= orig
[i
].svid
;
392 desc
.vdo
= orig
[i
].mid
;
394 desc
.roles
= TYPEC_PORT_DRD
;
399 ret
= ucsi_register_altmode(con
, &desc
, recipient
);
407 static int ucsi_register_altmodes(struct ucsi_connector
*con
, u8 recipient
)
409 int max_altmodes
= UCSI_MAX_ALTMODES
;
410 struct typec_altmode_desc desc
;
411 struct ucsi_altmode alt
[2];
419 if (!(con
->ucsi
->cap
.features
& UCSI_CAP_ALT_MODE_DETAILS
))
422 if (recipient
== UCSI_RECIPIENT_SOP
&& con
->partner_altmode
[0])
425 if (con
->ucsi
->ops
->update_altmodes
)
426 return ucsi_register_altmodes_nvidia(con
, recipient
);
428 if (recipient
== UCSI_RECIPIENT_CON
)
429 max_altmodes
= con
->ucsi
->cap
.num_alt_modes
;
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
));
442 * This code is requesting one alt mode at a time, but some PPMs
443 * may still return two. If that happens both alt modes need be
444 * registered and the offset for the next alt mode has to be
447 num
= len
/ sizeof(alt
[0]);
450 for (j
= 0; j
< num
; j
++) {
454 memset(&desc
, 0, sizeof(desc
));
455 desc
.vdo
= alt
[j
].mid
;
456 desc
.svid
= alt
[j
].svid
;
457 desc
.roles
= TYPEC_PORT_DRD
;
459 ret
= ucsi_register_altmode(con
, &desc
, recipient
);
468 static void ucsi_unregister_altmodes(struct ucsi_connector
*con
, u8 recipient
)
470 const struct typec_altmode
*pdev
;
471 struct typec_altmode
**adev
;
475 case UCSI_RECIPIENT_CON
:
476 adev
= con
->port_altmode
;
478 case UCSI_RECIPIENT_SOP
:
479 adev
= con
->partner_altmode
;
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
);
493 typec_unregister_altmode(adev
[i
]);
498 static int ucsi_get_pdos(struct ucsi_connector
*con
, int is_partner
,
499 u32
*pdos
, int offset
, int num_pdos
)
501 struct ucsi
*ucsi
= con
->ucsi
;
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
));
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");
520 static void ucsi_get_src_pdos(struct ucsi_connector
*con
, int is_partner
)
524 /* UCSI max payload means only getting at most 4 PDOs at a time */
525 ret
= ucsi_get_pdos(con
, 1, con
->src_pdos
, 0, UCSI_MAX_PDOS
);
529 con
->num_pdos
= ret
/ sizeof(u32
); /* number of bytes to 32-bit PDOs */
530 if (con
->num_pdos
< UCSI_MAX_PDOS
)
533 /* get the remaining PDOs, if any */
534 ret
= ucsi_get_pdos(con
, 1, con
->src_pdos
, UCSI_MAX_PDOS
,
535 PDO_MAX_OBJECTS
- UCSI_MAX_PDOS
);
539 con
->num_pdos
+= ret
/ sizeof(u32
);
542 static void ucsi_pwr_opmode_change(struct ucsi_connector
*con
)
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);
550 case UCSI_CONSTAT_PWR_OPMODE_TYPEC1_5
:
552 typec_set_pwr_opmode(con
->port
, TYPEC_PWR_MODE_1_5A
);
554 case UCSI_CONSTAT_PWR_OPMODE_TYPEC3_0
:
556 typec_set_pwr_opmode(con
->port
, TYPEC_PWR_MODE_3_0A
);
560 typec_set_pwr_opmode(con
->port
, TYPEC_PWR_MODE_USB
);
565 static int ucsi_register_partner(struct ucsi_connector
*con
)
567 u8 pwr_opmode
= UCSI_CONSTAT_PWR_OPMODE(con
->status
.flags
);
568 struct typec_partner_desc desc
;
569 struct typec_partner
*partner
;
574 memset(&desc
, 0, sizeof(desc
));
576 switch (UCSI_CONSTAT_PARTNER_TYPE(con
->status
.flags
)) {
577 case UCSI_CONSTAT_PARTNER_TYPE_DEBUG
:
578 desc
.accessory
= TYPEC_ACCESSORY_DEBUG
;
580 case UCSI_CONSTAT_PARTNER_TYPE_AUDIO
:
581 desc
.accessory
= TYPEC_ACCESSORY_AUDIO
;
587 desc
.usb_pd
= pwr_opmode
== UCSI_CONSTAT_PWR_OPMODE_PD
;
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
,
594 return PTR_ERR(partner
);
597 con
->partner
= partner
;
602 static void ucsi_unregister_partner(struct ucsi_connector
*con
)
607 ucsi_unregister_altmodes(con
, UCSI_RECIPIENT_SOP
);
608 typec_unregister_partner(con
->partner
);
612 static void ucsi_partner_change(struct ucsi_connector
*con
)
619 switch (UCSI_CONSTAT_PARTNER_TYPE(con
->status
.flags
)) {
620 case UCSI_CONSTAT_PARTNER_TYPE_UFP
:
621 case UCSI_CONSTAT_PARTNER_TYPE_CABLE
:
622 case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP
:
623 typec_set_data_role(con
->port
, TYPEC_HOST
);
625 case UCSI_CONSTAT_PARTNER_TYPE_DFP
:
626 typec_set_data_role(con
->port
, TYPEC_DEVICE
);
632 /* Complete pending data role swap */
633 if (!completion_done(&con
->complete
))
634 complete(&con
->complete
);
636 /* Can't rely on Partner Flags field. Always checking the alt modes. */
637 ret
= ucsi_register_altmodes(con
, UCSI_RECIPIENT_SOP
);
639 dev_err(con
->ucsi
->dev
,
640 "con%d: failed to register partner alternate modes\n",
643 ucsi_altmode_update_active(con
);
646 static void ucsi_handle_connector_change(struct work_struct
*work
)
648 struct ucsi_connector
*con
= container_of(work
, struct ucsi_connector
,
650 struct ucsi
*ucsi
= con
->ucsi
;
651 struct ucsi_connector_status pre_ack_status
;
652 struct ucsi_connector_status post_ack_status
;
653 enum typec_role role
;
654 u16 inferred_changes
;
659 mutex_lock(&con
->lock
);
662 * Some/many PPMs have an issue where all fields in the change bitfield
663 * are cleared when an ACK is send. This will causes any change
664 * between GET_CONNECTOR_STATUS and ACK to be lost.
666 * We work around this by re-fetching the connector status afterwards.
667 * We then infer any changes that we see have happened but that may not
668 * be represented in the change bitfield.
670 * Also, even though we don't need to know the currently supported alt
671 * modes, we run the GET_CAM_SUPPORTED command to ensure the PPM does
672 * not get stuck in case it assumes we do.
673 * Always do this, rather than relying on UCSI_CONSTAT_CAM_CHANGE to be
674 * set in the change bitfield.
676 * We end up with the following actions:
677 * 1. UCSI_GET_CONNECTOR_STATUS, store result, update unprocessed_changes
678 * 2. UCSI_GET_CAM_SUPPORTED, discard result
679 * 3. ACK connector change
680 * 4. UCSI_GET_CONNECTOR_STATUS, store result
681 * 5. Infere lost changes by comparing UCSI_GET_CONNECTOR_STATUS results
682 * 6. If PPM reported a new change, then restart in order to ACK
683 * 7. Process everything as usual.
685 * We may end up seeing a change twice, but we can only miss extremely
686 * short transitional changes.
689 /* 1. First UCSI_GET_CONNECTOR_STATUS */
690 command
= UCSI_GET_CONNECTOR_STATUS
| UCSI_CONNECTOR_NUMBER(con
->num
);
691 ret
= ucsi_send_command(ucsi
, command
, &pre_ack_status
,
692 sizeof(pre_ack_status
));
694 dev_err(ucsi
->dev
, "%s: GET_CONNECTOR_STATUS failed (%d)\n",
698 con
->unprocessed_changes
|= pre_ack_status
.change
;
700 /* 2. Run UCSI_GET_CAM_SUPPORTED and discard the result. */
701 command
= UCSI_GET_CAM_SUPPORTED
;
702 command
|= UCSI_CONNECTOR_NUMBER(con
->num
);
703 ucsi_send_command(con
->ucsi
, command
, NULL
, 0);
705 /* 3. ACK connector change */
706 clear_bit(EVENT_PENDING
, &ucsi
->flags
);
707 ret
= ucsi_acknowledge_connector_change(ucsi
);
709 dev_err(ucsi
->dev
, "%s: ACK failed (%d)", __func__
, ret
);
713 /* 4. Second UCSI_GET_CONNECTOR_STATUS */
714 command
= UCSI_GET_CONNECTOR_STATUS
| UCSI_CONNECTOR_NUMBER(con
->num
);
715 ret
= ucsi_send_command(ucsi
, command
, &post_ack_status
,
716 sizeof(post_ack_status
));
718 dev_err(ucsi
->dev
, "%s: GET_CONNECTOR_STATUS failed (%d)\n",
723 /* 5. Inferre any missing changes */
724 changed_flags
= pre_ack_status
.flags
^ post_ack_status
.flags
;
725 inferred_changes
= 0;
726 if (UCSI_CONSTAT_PWR_OPMODE(changed_flags
) != 0)
727 inferred_changes
|= UCSI_CONSTAT_POWER_OPMODE_CHANGE
;
729 if (changed_flags
& UCSI_CONSTAT_CONNECTED
)
730 inferred_changes
|= UCSI_CONSTAT_CONNECT_CHANGE
;
732 if (changed_flags
& UCSI_CONSTAT_PWR_DIR
)
733 inferred_changes
|= UCSI_CONSTAT_POWER_DIR_CHANGE
;
735 if (UCSI_CONSTAT_PARTNER_FLAGS(changed_flags
) != 0)
736 inferred_changes
|= UCSI_CONSTAT_PARTNER_CHANGE
;
738 if (UCSI_CONSTAT_PARTNER_TYPE(changed_flags
) != 0)
739 inferred_changes
|= UCSI_CONSTAT_PARTNER_CHANGE
;
741 /* Mask out anything that was correctly notified in the later call. */
742 inferred_changes
&= ~post_ack_status
.change
;
743 if (inferred_changes
)
744 dev_dbg(ucsi
->dev
, "%s: Inferred changes that would have been lost: 0x%04x\n",
745 __func__
, inferred_changes
);
747 con
->unprocessed_changes
|= inferred_changes
;
749 /* 6. If PPM reported a new change, then restart in order to ACK */
750 if (post_ack_status
.change
)
753 /* 7. Continue as if nothing happened */
754 con
->status
= post_ack_status
;
755 con
->status
.change
= con
->unprocessed_changes
;
756 con
->unprocessed_changes
= 0;
758 role
= !!(con
->status
.flags
& UCSI_CONSTAT_PWR_DIR
);
760 if (con
->status
.change
& UCSI_CONSTAT_POWER_OPMODE_CHANGE
||
761 con
->status
.change
& UCSI_CONSTAT_POWER_LEVEL_CHANGE
) {
762 ucsi_pwr_opmode_change(con
);
763 ucsi_port_psy_changed(con
);
766 if (con
->status
.change
& UCSI_CONSTAT_POWER_DIR_CHANGE
) {
767 typec_set_pwr_role(con
->port
, role
);
769 /* Complete pending power role swap */
770 if (!completion_done(&con
->complete
))
771 complete(&con
->complete
);
774 if (con
->status
.change
& UCSI_CONSTAT_CONNECT_CHANGE
) {
775 typec_set_pwr_role(con
->port
, role
);
777 switch (UCSI_CONSTAT_PARTNER_TYPE(con
->status
.flags
)) {
778 case UCSI_CONSTAT_PARTNER_TYPE_UFP
:
779 case UCSI_CONSTAT_PARTNER_TYPE_CABLE
:
780 case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP
:
781 typec_set_data_role(con
->port
, TYPEC_HOST
);
783 case UCSI_CONSTAT_PARTNER_TYPE_DFP
:
784 typec_set_data_role(con
->port
, TYPEC_DEVICE
);
790 if (con
->status
.flags
& UCSI_CONSTAT_CONNECTED
)
791 ucsi_register_partner(con
);
793 ucsi_unregister_partner(con
);
795 ucsi_port_psy_changed(con
);
798 if (con
->status
.change
& UCSI_CONSTAT_PARTNER_CHANGE
)
799 ucsi_partner_change(con
);
801 trace_ucsi_connector_change(con
->num
, &con
->status
);
804 if (test_and_clear_bit(EVENT_PENDING
, &ucsi
->flags
)) {
805 schedule_work(&con
->work
);
806 mutex_unlock(&con
->lock
);
810 clear_bit(EVENT_PROCESSING
, &ucsi
->flags
);
811 mutex_unlock(&con
->lock
);
815 * ucsi_connector_change - Process Connector Change Event
816 * @ucsi: UCSI Interface
817 * @num: Connector number
819 void ucsi_connector_change(struct ucsi
*ucsi
, u8 num
)
821 struct ucsi_connector
*con
= &ucsi
->connector
[num
- 1];
823 if (!(ucsi
->ntfy
& UCSI_ENABLE_NTFY_CONNECTOR_CHANGE
)) {
824 dev_dbg(ucsi
->dev
, "Bogus connector change event\n");
828 set_bit(EVENT_PENDING
, &ucsi
->flags
);
830 if (!test_and_set_bit(EVENT_PROCESSING
, &ucsi
->flags
))
831 schedule_work(&con
->work
);
833 EXPORT_SYMBOL_GPL(ucsi_connector_change
);
835 /* -------------------------------------------------------------------------- */
837 static int ucsi_reset_connector(struct ucsi_connector
*con
, bool hard
)
841 command
= UCSI_CONNECTOR_RESET
| UCSI_CONNECTOR_NUMBER(con
->num
);
842 command
|= hard
? UCSI_CONNECTOR_RESET_HARD
: 0;
844 return ucsi_send_command(con
->ucsi
, command
, NULL
, 0);
847 static int ucsi_reset_ppm(struct ucsi
*ucsi
)
849 u64 command
= UCSI_PPM_RESET
;
854 mutex_lock(&ucsi
->ppm_lock
);
856 ret
= ucsi
->ops
->async_write(ucsi
, UCSI_CONTROL
, &command
,
861 tmo
= jiffies
+ msecs_to_jiffies(UCSI_TIMEOUT_MS
);
864 if (time_is_before_jiffies(tmo
)) {
869 ret
= ucsi
->ops
->read(ucsi
, UCSI_CCI
, &cci
, sizeof(cci
));
873 /* If the PPM is still doing something else, reset it again. */
874 if (cci
& ~UCSI_CCI_RESET_COMPLETE
) {
875 ret
= ucsi
->ops
->async_write(ucsi
, UCSI_CONTROL
,
883 } while (!(cci
& UCSI_CCI_RESET_COMPLETE
));
886 mutex_unlock(&ucsi
->ppm_lock
);
890 static int ucsi_role_cmd(struct ucsi_connector
*con
, u64 command
)
894 ret
= ucsi_send_command(con
->ucsi
, command
, NULL
, 0);
895 if (ret
== -ETIMEDOUT
) {
898 /* PPM most likely stopped responding. Resetting everything. */
899 ucsi_reset_ppm(con
->ucsi
);
901 c
= UCSI_SET_NOTIFICATION_ENABLE
| con
->ucsi
->ntfy
;
902 ucsi_send_command(con
->ucsi
, c
, NULL
, 0);
904 ucsi_reset_connector(con
, true);
910 static int ucsi_dr_swap(struct typec_port
*port
, enum typec_data_role role
)
912 struct ucsi_connector
*con
= typec_get_drvdata(port
);
917 mutex_lock(&con
->lock
);
924 partner_type
= UCSI_CONSTAT_PARTNER_TYPE(con
->status
.flags
);
925 if ((partner_type
== UCSI_CONSTAT_PARTNER_TYPE_DFP
&&
926 role
== TYPEC_DEVICE
) ||
927 (partner_type
== UCSI_CONSTAT_PARTNER_TYPE_UFP
&&
931 command
= UCSI_SET_UOR
| UCSI_CONNECTOR_NUMBER(con
->num
);
932 command
|= UCSI_SET_UOR_ROLE(role
);
933 command
|= UCSI_SET_UOR_ACCEPT_ROLE_SWAPS
;
934 ret
= ucsi_role_cmd(con
, command
);
938 if (!wait_for_completion_timeout(&con
->complete
,
939 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS
)))
943 mutex_unlock(&con
->lock
);
945 return ret
< 0 ? ret
: 0;
948 static int ucsi_pr_swap(struct typec_port
*port
, enum typec_role role
)
950 struct ucsi_connector
*con
= typec_get_drvdata(port
);
951 enum typec_role cur_role
;
955 mutex_lock(&con
->lock
);
962 cur_role
= !!(con
->status
.flags
& UCSI_CONSTAT_PWR_DIR
);
964 if (cur_role
== role
)
967 command
= UCSI_SET_PDR
| UCSI_CONNECTOR_NUMBER(con
->num
);
968 command
|= UCSI_SET_PDR_ROLE(role
);
969 command
|= UCSI_SET_PDR_ACCEPT_ROLE_SWAPS
;
970 ret
= ucsi_role_cmd(con
, command
);
974 if (!wait_for_completion_timeout(&con
->complete
,
975 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS
))) {
980 /* Something has gone wrong while swapping the role */
981 if (UCSI_CONSTAT_PWR_OPMODE(con
->status
.flags
) !=
982 UCSI_CONSTAT_PWR_OPMODE_PD
) {
983 ucsi_reset_connector(con
, true);
988 mutex_unlock(&con
->lock
);
993 static const struct typec_operations ucsi_ops
= {
994 .dr_set
= ucsi_dr_swap
,
995 .pr_set
= ucsi_pr_swap
998 /* Caller must call fwnode_handle_put() after use */
999 static struct fwnode_handle
*ucsi_find_fwnode(struct ucsi_connector
*con
)
1001 struct fwnode_handle
*fwnode
;
1004 device_for_each_child_node(con
->ucsi
->dev
, fwnode
)
1005 if (i
++ == con
->num
)
1010 static int ucsi_register_port(struct ucsi
*ucsi
, int index
)
1012 struct ucsi_connector
*con
= &ucsi
->connector
[index
];
1013 struct typec_capability
*cap
= &con
->typec_cap
;
1014 enum typec_accessory
*accessory
= cap
->accessory
;
1018 INIT_WORK(&con
->work
, ucsi_handle_connector_change
);
1019 init_completion(&con
->complete
);
1020 mutex_init(&con
->lock
);
1021 con
->num
= index
+ 1;
1024 /* Delay other interactions with the con until registration is complete */
1025 mutex_lock(&con
->lock
);
1027 /* Get connector capability */
1028 command
= UCSI_GET_CONNECTOR_CAPABILITY
;
1029 command
|= UCSI_CONNECTOR_NUMBER(con
->num
);
1030 ret
= ucsi_send_command(ucsi
, command
, &con
->cap
, sizeof(con
->cap
));
1034 if (con
->cap
.op_mode
& UCSI_CONCAP_OPMODE_DRP
)
1035 cap
->data
= TYPEC_PORT_DRD
;
1036 else if (con
->cap
.op_mode
& UCSI_CONCAP_OPMODE_DFP
)
1037 cap
->data
= TYPEC_PORT_DFP
;
1038 else if (con
->cap
.op_mode
& UCSI_CONCAP_OPMODE_UFP
)
1039 cap
->data
= TYPEC_PORT_UFP
;
1041 if ((con
->cap
.flags
& UCSI_CONCAP_FLAG_PROVIDER
) &&
1042 (con
->cap
.flags
& UCSI_CONCAP_FLAG_CONSUMER
))
1043 cap
->type
= TYPEC_PORT_DRP
;
1044 else if (con
->cap
.flags
& UCSI_CONCAP_FLAG_PROVIDER
)
1045 cap
->type
= TYPEC_PORT_SRC
;
1046 else if (con
->cap
.flags
& UCSI_CONCAP_FLAG_CONSUMER
)
1047 cap
->type
= TYPEC_PORT_SNK
;
1049 cap
->revision
= ucsi
->cap
.typec_version
;
1050 cap
->pd_revision
= ucsi
->cap
.pd_version
;
1051 cap
->prefer_role
= TYPEC_NO_PREFERRED_ROLE
;
1053 if (con
->cap
.op_mode
& UCSI_CONCAP_OPMODE_AUDIO_ACCESSORY
)
1054 *accessory
++ = TYPEC_ACCESSORY_AUDIO
;
1055 if (con
->cap
.op_mode
& UCSI_CONCAP_OPMODE_DEBUG_ACCESSORY
)
1056 *accessory
= TYPEC_ACCESSORY_DEBUG
;
1058 cap
->fwnode
= ucsi_find_fwnode(con
);
1059 cap
->driver_data
= con
;
1060 cap
->ops
= &ucsi_ops
;
1062 ret
= ucsi_register_port_psy(con
);
1066 /* Register the connector */
1067 con
->port
= typec_register_port(ucsi
->dev
, cap
);
1068 if (IS_ERR(con
->port
)) {
1069 ret
= PTR_ERR(con
->port
);
1073 /* Alternate modes */
1074 ret
= ucsi_register_altmodes(con
, UCSI_RECIPIENT_CON
);
1076 dev_err(ucsi
->dev
, "con%d: failed to register alt modes\n",
1081 /* Get the status */
1082 command
= UCSI_GET_CONNECTOR_STATUS
| UCSI_CONNECTOR_NUMBER(con
->num
);
1083 ret
= ucsi_send_command(ucsi
, command
, &con
->status
, sizeof(con
->status
));
1085 dev_err(ucsi
->dev
, "con%d: failed to get status\n", con
->num
);
1089 ret
= 0; /* ucsi_send_command() returns length on success */
1091 switch (UCSI_CONSTAT_PARTNER_TYPE(con
->status
.flags
)) {
1092 case UCSI_CONSTAT_PARTNER_TYPE_UFP
:
1093 case UCSI_CONSTAT_PARTNER_TYPE_CABLE
:
1094 case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP
:
1095 typec_set_data_role(con
->port
, TYPEC_HOST
);
1097 case UCSI_CONSTAT_PARTNER_TYPE_DFP
:
1098 typec_set_data_role(con
->port
, TYPEC_DEVICE
);
1104 /* Check if there is already something connected */
1105 if (con
->status
.flags
& UCSI_CONSTAT_CONNECTED
) {
1106 typec_set_pwr_role(con
->port
,
1107 !!(con
->status
.flags
& UCSI_CONSTAT_PWR_DIR
));
1108 ucsi_pwr_opmode_change(con
);
1109 ucsi_register_partner(con
);
1110 ucsi_port_psy_changed(con
);
1114 ret
= ucsi_register_altmodes(con
, UCSI_RECIPIENT_SOP
);
1117 "con%d: failed to register alternate modes\n",
1121 ucsi_altmode_update_active(con
);
1125 trace_ucsi_register_port(con
->num
, &con
->status
);
1128 fwnode_handle_put(cap
->fwnode
);
1130 mutex_unlock(&con
->lock
);
1135 * ucsi_init - Initialize UCSI interface
1136 * @ucsi: UCSI to be initialized
1138 * Registers all ports @ucsi has and enables all notification events.
1140 static int ucsi_init(struct ucsi
*ucsi
)
1142 struct ucsi_connector
*con
;
1148 ret
= ucsi_reset_ppm(ucsi
);
1150 dev_err(ucsi
->dev
, "failed to reset PPM!\n");
1154 /* Enable basic notifications */
1155 ucsi
->ntfy
= UCSI_ENABLE_NTFY_CMD_COMPLETE
| UCSI_ENABLE_NTFY_ERROR
;
1156 command
= UCSI_SET_NOTIFICATION_ENABLE
| ucsi
->ntfy
;
1157 ret
= ucsi_send_command(ucsi
, command
, NULL
, 0);
1161 /* Get PPM capabilities */
1162 command
= UCSI_GET_CAPABILITY
;
1163 ret
= ucsi_send_command(ucsi
, command
, &ucsi
->cap
, sizeof(ucsi
->cap
));
1167 if (!ucsi
->cap
.num_connectors
) {
1172 /* Allocate the connectors. Released in ucsi_unregister_ppm() */
1173 ucsi
->connector
= kcalloc(ucsi
->cap
.num_connectors
+ 1,
1174 sizeof(*ucsi
->connector
), GFP_KERNEL
);
1175 if (!ucsi
->connector
) {
1180 /* Register all connectors */
1181 for (i
= 0; i
< ucsi
->cap
.num_connectors
; i
++) {
1182 ret
= ucsi_register_port(ucsi
, i
);
1184 goto err_unregister
;
1187 /* Enable all notifications */
1188 ucsi
->ntfy
= UCSI_ENABLE_NTFY_ALL
;
1189 command
= UCSI_SET_NOTIFICATION_ENABLE
| ucsi
->ntfy
;
1190 ret
= ucsi_send_command(ucsi
, command
, NULL
, 0);
1192 goto err_unregister
;
1197 for (con
= ucsi
->connector
; con
->port
; con
++) {
1198 ucsi_unregister_partner(con
);
1199 ucsi_unregister_altmodes(con
, UCSI_RECIPIENT_CON
);
1200 ucsi_unregister_port_psy(con
);
1201 typec_unregister_port(con
->port
);
1206 ucsi_reset_ppm(ucsi
);
1211 static void ucsi_init_work(struct work_struct
*work
)
1213 struct ucsi
*ucsi
= container_of(work
, struct ucsi
, work
);
1216 ret
= ucsi_init(ucsi
);
1218 dev_err(ucsi
->dev
, "PPM init failed (%d)\n", ret
);
1222 * ucsi_get_drvdata - Return private driver data pointer
1223 * @ucsi: UCSI interface
1225 void *ucsi_get_drvdata(struct ucsi
*ucsi
)
1227 return ucsi
->driver_data
;
1229 EXPORT_SYMBOL_GPL(ucsi_get_drvdata
);
1232 * ucsi_get_drvdata - Assign private driver data pointer
1233 * @ucsi: UCSI interface
1234 * @data: Private data pointer
1236 void ucsi_set_drvdata(struct ucsi
*ucsi
, void *data
)
1238 ucsi
->driver_data
= data
;
1240 EXPORT_SYMBOL_GPL(ucsi_set_drvdata
);
1243 * ucsi_create - Allocate UCSI instance
1244 * @dev: Device interface to the PPM (Platform Policy Manager)
1245 * @ops: I/O routines
1247 struct ucsi
*ucsi_create(struct device
*dev
, const struct ucsi_operations
*ops
)
1251 if (!ops
|| !ops
->read
|| !ops
->sync_write
|| !ops
->async_write
)
1252 return ERR_PTR(-EINVAL
);
1254 ucsi
= kzalloc(sizeof(*ucsi
), GFP_KERNEL
);
1256 return ERR_PTR(-ENOMEM
);
1258 INIT_WORK(&ucsi
->work
, ucsi_init_work
);
1259 mutex_init(&ucsi
->ppm_lock
);
1265 EXPORT_SYMBOL_GPL(ucsi_create
);
1268 * ucsi_destroy - Free UCSI instance
1269 * @ucsi: UCSI instance to be freed
1271 void ucsi_destroy(struct ucsi
*ucsi
)
1275 EXPORT_SYMBOL_GPL(ucsi_destroy
);
1278 * ucsi_register - Register UCSI interface
1279 * @ucsi: UCSI instance
1281 int ucsi_register(struct ucsi
*ucsi
)
1285 ret
= ucsi
->ops
->read(ucsi
, UCSI_VERSION
, &ucsi
->version
,
1286 sizeof(ucsi
->version
));
1293 queue_work(system_long_wq
, &ucsi
->work
);
1297 EXPORT_SYMBOL_GPL(ucsi_register
);
1300 * ucsi_unregister - Unregister UCSI interface
1301 * @ucsi: UCSI interface to be unregistered
1303 * Unregister UCSI interface that was created with ucsi_register().
1305 void ucsi_unregister(struct ucsi
*ucsi
)
1307 u64 cmd
= UCSI_SET_NOTIFICATION_ENABLE
;
1310 /* Make sure that we are not in the middle of driver initialization */
1311 cancel_work_sync(&ucsi
->work
);
1313 /* Disable notifications */
1314 ucsi
->ops
->async_write(ucsi
, UCSI_CONTROL
, &cmd
, sizeof(cmd
));
1316 for (i
= 0; i
< ucsi
->cap
.num_connectors
; i
++) {
1317 cancel_work_sync(&ucsi
->connector
[i
].work
);
1318 ucsi_unregister_partner(&ucsi
->connector
[i
]);
1319 ucsi_unregister_altmodes(&ucsi
->connector
[i
],
1320 UCSI_RECIPIENT_CON
);
1321 ucsi_unregister_port_psy(&ucsi
->connector
[i
]);
1322 typec_unregister_port(ucsi
->connector
[i
].port
);
1325 kfree(ucsi
->connector
);
1327 EXPORT_SYMBOL_GPL(ucsi_unregister
);
1329 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
1330 MODULE_LICENSE("GPL v2");
1331 MODULE_DESCRIPTION("USB Type-C Connector System Software Interface driver");