1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2015-2017 Google, Inc 4 * 5 * USB Power Delivery protocol stack. 6 */ 7 8 #include <linux/completion.h> 9 #include <linux/debugfs.h> 10 #include <linux/device.h> 11 #include <linux/hrtimer.h> 12 #include <linux/jiffies.h> 13 #include <linux/kernel.h> 14 #include <linux/kthread.h> 15 #include <linux/module.h> 16 #include <linux/mutex.h> 17 #include <linux/power_supply.h> 18 #include <linux/proc_fs.h> 19 #include <linux/property.h> 20 #include <linux/sched/clock.h> 21 #include <linux/seq_file.h> 22 #include <linux/slab.h> 23 #include <linux/spinlock.h> 24 #include <linux/usb.h> 25 #include <linux/usb/pd.h> 26 #include <linux/usb/pd_ado.h> 27 #include <linux/usb/pd_bdo.h> 28 #include <linux/usb/pd_ext_sdb.h> 29 #include <linux/usb/pd_vdo.h> 30 #include <linux/usb/role.h> 31 #include <linux/usb/tcpm.h> 32 #include <linux/usb/typec_altmode.h> 33 34 #include <uapi/linux/sched/types.h> 35 36 #define FOREACH_STATE(S) \ 37 S(INVALID_STATE), \ 38 S(TOGGLING), \ 39 S(CHECK_CONTAMINANT), \ 40 S(SRC_UNATTACHED), \ 41 S(SRC_ATTACH_WAIT), \ 42 S(SRC_ATTACHED), \ 43 S(SRC_STARTUP), \ 44 S(SRC_SEND_CAPABILITIES), \ 45 S(SRC_SEND_CAPABILITIES_TIMEOUT), \ 46 S(SRC_NEGOTIATE_CAPABILITIES), \ 47 S(SRC_TRANSITION_SUPPLY), \ 48 S(SRC_READY), \ 49 S(SRC_WAIT_NEW_CAPABILITIES), \ 50 \ 51 S(SNK_UNATTACHED), \ 52 S(SNK_ATTACH_WAIT), \ 53 S(SNK_DEBOUNCED), \ 54 S(SNK_ATTACHED), \ 55 S(SNK_STARTUP), \ 56 S(SNK_DISCOVERY), \ 57 S(SNK_DISCOVERY_DEBOUNCE), \ 58 S(SNK_DISCOVERY_DEBOUNCE_DONE), \ 59 S(SNK_WAIT_CAPABILITIES), \ 60 S(SNK_NEGOTIATE_CAPABILITIES), \ 61 S(SNK_NEGOTIATE_PPS_CAPABILITIES), \ 62 S(SNK_TRANSITION_SINK), \ 63 S(SNK_TRANSITION_SINK_VBUS), \ 64 S(SNK_READY), \ 65 \ 66 S(ACC_UNATTACHED), \ 67 S(DEBUG_ACC_ATTACHED), \ 68 S(AUDIO_ACC_ATTACHED), \ 69 S(AUDIO_ACC_DEBOUNCE), \ 70 \ 71 S(HARD_RESET_SEND), \ 72 S(HARD_RESET_START), \ 73 S(SRC_HARD_RESET_VBUS_OFF), \ 74 S(SRC_HARD_RESET_VBUS_ON), \ 75 S(SNK_HARD_RESET_SINK_OFF), \ 76 S(SNK_HARD_RESET_WAIT_VBUS), \ 77 S(SNK_HARD_RESET_SINK_ON), \ 78 \ 79 S(SOFT_RESET), \ 80 S(SRC_SOFT_RESET_WAIT_SNK_TX), \ 81 S(SNK_SOFT_RESET), \ 82 S(SOFT_RESET_SEND), \ 83 \ 84 S(DR_SWAP_ACCEPT), \ 85 S(DR_SWAP_SEND), \ 86 S(DR_SWAP_SEND_TIMEOUT), \ 87 S(DR_SWAP_CANCEL), \ 88 S(DR_SWAP_CHANGE_DR), \ 89 \ 90 S(PR_SWAP_ACCEPT), \ 91 S(PR_SWAP_SEND), \ 92 S(PR_SWAP_SEND_TIMEOUT), \ 93 S(PR_SWAP_CANCEL), \ 94 S(PR_SWAP_START), \ 95 S(PR_SWAP_SRC_SNK_TRANSITION_OFF), \ 96 S(PR_SWAP_SRC_SNK_SOURCE_OFF), \ 97 S(PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED), \ 98 S(PR_SWAP_SRC_SNK_SINK_ON), \ 99 S(PR_SWAP_SNK_SRC_SINK_OFF), \ 100 S(PR_SWAP_SNK_SRC_SOURCE_ON), \ 101 S(PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP), \ 102 \ 103 S(VCONN_SWAP_ACCEPT), \ 104 S(VCONN_SWAP_SEND), \ 105 S(VCONN_SWAP_SEND_TIMEOUT), \ 106 S(VCONN_SWAP_CANCEL), \ 107 S(VCONN_SWAP_START), \ 108 S(VCONN_SWAP_WAIT_FOR_VCONN), \ 109 S(VCONN_SWAP_TURN_ON_VCONN), \ 110 S(VCONN_SWAP_TURN_OFF_VCONN), \ 111 \ 112 S(FR_SWAP_SEND), \ 113 S(FR_SWAP_SEND_TIMEOUT), \ 114 S(FR_SWAP_SNK_SRC_TRANSITION_TO_OFF), \ 115 S(FR_SWAP_SNK_SRC_NEW_SINK_READY), \ 116 S(FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED), \ 117 S(FR_SWAP_CANCEL), \ 118 \ 119 S(SNK_TRY), \ 120 S(SNK_TRY_WAIT), \ 121 S(SNK_TRY_WAIT_DEBOUNCE), \ 122 S(SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS), \ 123 S(SRC_TRYWAIT), \ 124 S(SRC_TRYWAIT_DEBOUNCE), \ 125 S(SRC_TRYWAIT_UNATTACHED), \ 126 \ 127 S(SRC_TRY), \ 128 S(SRC_TRY_WAIT), \ 129 S(SRC_TRY_DEBOUNCE), \ 130 S(SNK_TRYWAIT), \ 131 S(SNK_TRYWAIT_DEBOUNCE), \ 132 S(SNK_TRYWAIT_VBUS), \ 133 S(BIST_RX), \ 134 \ 135 S(GET_STATUS_SEND), \ 136 S(GET_STATUS_SEND_TIMEOUT), \ 137 S(GET_PPS_STATUS_SEND), \ 138 S(GET_PPS_STATUS_SEND_TIMEOUT), \ 139 \ 140 S(GET_SINK_CAP), \ 141 S(GET_SINK_CAP_TIMEOUT), \ 142 \ 143 S(ERROR_RECOVERY), \ 144 S(PORT_RESET), \ 145 S(PORT_RESET_WAIT_OFF), \ 146 \ 147 S(AMS_START), \ 148 S(CHUNK_NOT_SUPP) 149 150 #define FOREACH_AMS(S) \ 151 S(NONE_AMS), \ 152 S(POWER_NEGOTIATION), \ 153 S(GOTOMIN), \ 154 S(SOFT_RESET_AMS), \ 155 S(HARD_RESET), \ 156 S(CABLE_RESET), \ 157 S(GET_SOURCE_CAPABILITIES), \ 158 S(GET_SINK_CAPABILITIES), \ 159 S(POWER_ROLE_SWAP), \ 160 S(FAST_ROLE_SWAP), \ 161 S(DATA_ROLE_SWAP), \ 162 S(VCONN_SWAP), \ 163 S(SOURCE_ALERT), \ 164 S(GETTING_SOURCE_EXTENDED_CAPABILITIES),\ 165 S(GETTING_SOURCE_SINK_STATUS), \ 166 S(GETTING_BATTERY_CAPABILITIES), \ 167 S(GETTING_BATTERY_STATUS), \ 168 S(GETTING_MANUFACTURER_INFORMATION), \ 169 S(SECURITY), \ 170 S(FIRMWARE_UPDATE), \ 171 S(DISCOVER_IDENTITY), \ 172 S(SOURCE_STARTUP_CABLE_PLUG_DISCOVER_IDENTITY), \ 173 S(DISCOVER_SVIDS), \ 174 S(DISCOVER_MODES), \ 175 S(DFP_TO_UFP_ENTER_MODE), \ 176 S(DFP_TO_UFP_EXIT_MODE), \ 177 S(DFP_TO_CABLE_PLUG_ENTER_MODE), \ 178 S(DFP_TO_CABLE_PLUG_EXIT_MODE), \ 179 S(ATTENTION), \ 180 S(BIST), \ 181 S(UNSTRUCTURED_VDMS), \ 182 S(STRUCTURED_VDMS), \ 183 S(COUNTRY_INFO), \ 184 S(COUNTRY_CODES) 185 186 #define GENERATE_ENUM(e) e 187 #define GENERATE_STRING(s) #s 188 189 enum tcpm_state { 190 FOREACH_STATE(GENERATE_ENUM) 191 }; 192 193 static const char * const tcpm_states[] = { 194 FOREACH_STATE(GENERATE_STRING) 195 }; 196 197 enum tcpm_ams { 198 FOREACH_AMS(GENERATE_ENUM) 199 }; 200 201 static const char * const tcpm_ams_str[] = { 202 FOREACH_AMS(GENERATE_STRING) 203 }; 204 205 enum vdm_states { 206 VDM_STATE_ERR_BUSY = -3, 207 VDM_STATE_ERR_SEND = -2, 208 VDM_STATE_ERR_TMOUT = -1, 209 VDM_STATE_DONE = 0, 210 /* Anything >0 represents an active state */ 211 VDM_STATE_READY = 1, 212 VDM_STATE_BUSY = 2, 213 VDM_STATE_WAIT_RSP_BUSY = 3, 214 VDM_STATE_SEND_MESSAGE = 4, 215 }; 216 217 enum pd_msg_request { 218 PD_MSG_NONE = 0, 219 PD_MSG_CTRL_REJECT, 220 PD_MSG_CTRL_WAIT, 221 PD_MSG_CTRL_NOT_SUPP, 222 PD_MSG_DATA_SINK_CAP, 223 PD_MSG_DATA_SOURCE_CAP, 224 }; 225 226 enum adev_actions { 227 ADEV_NONE = 0, 228 ADEV_NOTIFY_USB_AND_QUEUE_VDM, 229 ADEV_QUEUE_VDM, 230 ADEV_QUEUE_VDM_SEND_EXIT_MODE_ON_FAIL, 231 ADEV_ATTENTION, 232 }; 233 234 /* 235 * Initial current capability of the new source when vSafe5V is applied during PD3.0 Fast Role Swap. 236 * Based on "Table 6-14 Fixed Supply PDO - Sink" of "USB Power Delivery Specification Revision 3.0, 237 * Version 1.2" 238 */ 239 enum frs_typec_current { 240 FRS_NOT_SUPPORTED, 241 FRS_DEFAULT_POWER, 242 FRS_5V_1P5A, 243 FRS_5V_3A, 244 }; 245 246 /* Events from low level driver */ 247 248 #define TCPM_CC_EVENT BIT(0) 249 #define TCPM_VBUS_EVENT BIT(1) 250 #define TCPM_RESET_EVENT BIT(2) 251 #define TCPM_FRS_EVENT BIT(3) 252 #define TCPM_SOURCING_VBUS BIT(4) 253 #define TCPM_PORT_CLEAN BIT(5) 254 255 #define LOG_BUFFER_ENTRIES 1024 256 #define LOG_BUFFER_ENTRY_SIZE 128 257 258 /* Alternate mode support */ 259 260 #define SVID_DISCOVERY_MAX 16 261 #define ALTMODE_DISCOVERY_MAX (SVID_DISCOVERY_MAX * MODE_DISCOVERY_MAX) 262 263 #define GET_SINK_CAP_RETRY_MS 100 264 #define SEND_DISCOVER_RETRY_MS 100 265 266 struct pd_mode_data { 267 int svid_index; /* current SVID index */ 268 int nsvids; 269 u16 svids[SVID_DISCOVERY_MAX]; 270 int altmodes; /* number of alternate modes */ 271 struct typec_altmode_desc altmode_desc[ALTMODE_DISCOVERY_MAX]; 272 }; 273 274 /* 275 * @min_volt: Actual min voltage at the local port 276 * @req_min_volt: Requested min voltage to the port partner 277 * @max_volt: Actual max voltage at the local port 278 * @req_max_volt: Requested max voltage to the port partner 279 * @max_curr: Actual max current at the local port 280 * @req_max_curr: Requested max current of the port partner 281 * @req_out_volt: Requested output voltage to the port partner 282 * @req_op_curr: Requested operating current to the port partner 283 * @supported: Parter has at least one APDO hence supports PPS 284 * @active: PPS mode is active 285 */ 286 struct pd_pps_data { 287 u32 min_volt; 288 u32 req_min_volt; 289 u32 max_volt; 290 u32 req_max_volt; 291 u32 max_curr; 292 u32 req_max_curr; 293 u32 req_out_volt; 294 u32 req_op_curr; 295 bool supported; 296 bool active; 297 }; 298 299 struct tcpm_port { 300 struct device *dev; 301 302 struct mutex lock; /* tcpm state machine lock */ 303 struct kthread_worker *wq; 304 305 struct typec_capability typec_caps; 306 struct typec_port *typec_port; 307 308 struct tcpc_dev *tcpc; 309 struct usb_role_switch *role_sw; 310 311 enum typec_role vconn_role; 312 enum typec_role pwr_role; 313 enum typec_data_role data_role; 314 enum typec_pwr_opmode pwr_opmode; 315 316 struct usb_pd_identity partner_ident; 317 struct typec_partner_desc partner_desc; 318 struct typec_partner *partner; 319 320 enum typec_cc_status cc_req; 321 enum typec_cc_status src_rp; /* work only if pd_supported == false */ 322 323 enum typec_cc_status cc1; 324 enum typec_cc_status cc2; 325 enum typec_cc_polarity polarity; 326 327 bool attached; 328 bool connected; 329 bool registered; 330 bool pd_supported; 331 enum typec_port_type port_type; 332 333 /* 334 * Set to true when vbus is greater than VSAFE5V min. 335 * Set to false when vbus falls below vSinkDisconnect max threshold. 336 */ 337 bool vbus_present; 338 339 /* 340 * Set to true when vbus is less than VSAFE0V max. 341 * Set to false when vbus is greater than VSAFE0V max. 342 */ 343 bool vbus_vsafe0v; 344 345 bool vbus_never_low; 346 bool vbus_source; 347 bool vbus_charge; 348 349 /* Set to true when Discover_Identity Command is expected to be sent in Ready states. */ 350 bool send_discover; 351 bool op_vsafe5v; 352 353 int try_role; 354 int try_snk_count; 355 int try_src_count; 356 357 enum pd_msg_request queued_message; 358 359 enum tcpm_state enter_state; 360 enum tcpm_state prev_state; 361 enum tcpm_state state; 362 enum tcpm_state delayed_state; 363 ktime_t delayed_runtime; 364 unsigned long delay_ms; 365 366 spinlock_t pd_event_lock; 367 u32 pd_events; 368 369 struct kthread_work event_work; 370 struct hrtimer state_machine_timer; 371 struct kthread_work state_machine; 372 struct hrtimer vdm_state_machine_timer; 373 struct kthread_work vdm_state_machine; 374 struct hrtimer enable_frs_timer; 375 struct kthread_work enable_frs; 376 struct hrtimer send_discover_timer; 377 struct kthread_work send_discover_work; 378 bool state_machine_running; 379 /* Set to true when VDM State Machine has following actions. */ 380 bool vdm_sm_running; 381 382 struct completion tx_complete; 383 enum tcpm_transmit_status tx_status; 384 385 struct mutex swap_lock; /* swap command lock */ 386 bool swap_pending; 387 bool non_pd_role_swap; 388 struct completion swap_complete; 389 int swap_status; 390 391 unsigned int negotiated_rev; 392 unsigned int message_id; 393 unsigned int caps_count; 394 unsigned int hard_reset_count; 395 bool pd_capable; 396 bool explicit_contract; 397 unsigned int rx_msgid; 398 399 /* USB PD objects */ 400 struct usb_power_delivery *pd; 401 struct usb_power_delivery_capabilities *port_source_caps; 402 struct usb_power_delivery_capabilities *port_sink_caps; 403 struct usb_power_delivery *partner_pd; 404 struct usb_power_delivery_capabilities *partner_source_caps; 405 struct usb_power_delivery_capabilities *partner_sink_caps; 406 407 /* Partner capabilities/requests */ 408 u32 sink_request; 409 u32 source_caps[PDO_MAX_OBJECTS]; 410 unsigned int nr_source_caps; 411 u32 sink_caps[PDO_MAX_OBJECTS]; 412 unsigned int nr_sink_caps; 413 414 /* Local capabilities */ 415 u32 src_pdo[PDO_MAX_OBJECTS]; 416 unsigned int nr_src_pdo; 417 u32 snk_pdo[PDO_MAX_OBJECTS]; 418 unsigned int nr_snk_pdo; 419 u32 snk_vdo_v1[VDO_MAX_OBJECTS]; 420 unsigned int nr_snk_vdo_v1; 421 u32 snk_vdo[VDO_MAX_OBJECTS]; 422 unsigned int nr_snk_vdo; 423 424 unsigned int operating_snk_mw; 425 bool update_sink_caps; 426 427 /* Requested current / voltage to the port partner */ 428 u32 req_current_limit; 429 u32 req_supply_voltage; 430 /* Actual current / voltage limit of the local port */ 431 u32 current_limit; 432 u32 supply_voltage; 433 434 /* Used to export TA voltage and current */ 435 struct power_supply *psy; 436 struct power_supply_desc psy_desc; 437 enum power_supply_usb_type usb_type; 438 439 u32 bist_request; 440 441 /* PD state for Vendor Defined Messages */ 442 enum vdm_states vdm_state; 443 u32 vdm_retries; 444 /* next Vendor Defined Message to send */ 445 u32 vdo_data[VDO_MAX_SIZE]; 446 u8 vdo_count; 447 /* VDO to retry if UFP responder replied busy */ 448 u32 vdo_retry; 449 450 /* PPS */ 451 struct pd_pps_data pps_data; 452 struct completion pps_complete; 453 bool pps_pending; 454 int pps_status; 455 456 /* Alternate mode data */ 457 struct pd_mode_data mode_data; 458 struct typec_altmode *partner_altmode[ALTMODE_DISCOVERY_MAX]; 459 struct typec_altmode *port_altmode[ALTMODE_DISCOVERY_MAX]; 460 461 /* Deadline in jiffies to exit src_try_wait state */ 462 unsigned long max_wait; 463 464 /* port belongs to a self powered device */ 465 bool self_powered; 466 467 /* Sink FRS */ 468 enum frs_typec_current new_source_frs_current; 469 470 /* Sink caps have been queried */ 471 bool sink_cap_done; 472 473 /* Collision Avoidance and Atomic Message Sequence */ 474 enum tcpm_state upcoming_state; 475 enum tcpm_ams ams; 476 enum tcpm_ams next_ams; 477 bool in_ams; 478 479 /* Auto vbus discharge status */ 480 bool auto_vbus_discharge_enabled; 481 482 /* 483 * When set, port requests PD_P_SNK_STDBY_MW upon entering SNK_DISCOVERY and 484 * the actual current limit after RX of PD_CTRL_PSRDY for PD link, 485 * SNK_READY for non-pd link. 486 */ 487 bool slow_charger_loop; 488 489 /* 490 * When true indicates that the lower level drivers indicate potential presence 491 * of contaminant in the connector pins based on the tcpm state machine 492 * transitions. 493 */ 494 bool potential_contaminant; 495 #ifdef CONFIG_DEBUG_FS 496 struct dentry *dentry; 497 struct mutex logbuffer_lock; /* log buffer access lock */ 498 int logbuffer_head; 499 int logbuffer_tail; 500 u8 *logbuffer[LOG_BUFFER_ENTRIES]; 501 #endif 502 }; 503 504 struct pd_rx_event { 505 struct kthread_work work; 506 struct tcpm_port *port; 507 struct pd_message msg; 508 }; 509 510 static const char * const pd_rev[] = { 511 [PD_REV10] = "rev1", 512 [PD_REV20] = "rev2", 513 [PD_REV30] = "rev3", 514 }; 515 516 #define tcpm_cc_is_sink(cc) \ 517 ((cc) == TYPEC_CC_RP_DEF || (cc) == TYPEC_CC_RP_1_5 || \ 518 (cc) == TYPEC_CC_RP_3_0) 519 520 #define tcpm_port_is_sink(port) \ 521 ((tcpm_cc_is_sink((port)->cc1) && !tcpm_cc_is_sink((port)->cc2)) || \ 522 (tcpm_cc_is_sink((port)->cc2) && !tcpm_cc_is_sink((port)->cc1))) 523 524 #define tcpm_cc_is_source(cc) ((cc) == TYPEC_CC_RD) 525 #define tcpm_cc_is_audio(cc) ((cc) == TYPEC_CC_RA) 526 #define tcpm_cc_is_open(cc) ((cc) == TYPEC_CC_OPEN) 527 528 #define tcpm_port_is_source(port) \ 529 ((tcpm_cc_is_source((port)->cc1) && \ 530 !tcpm_cc_is_source((port)->cc2)) || \ 531 (tcpm_cc_is_source((port)->cc2) && \ 532 !tcpm_cc_is_source((port)->cc1))) 533 534 #define tcpm_port_is_debug(port) \ 535 (tcpm_cc_is_source((port)->cc1) && tcpm_cc_is_source((port)->cc2)) 536 537 #define tcpm_port_is_audio(port) \ 538 (tcpm_cc_is_audio((port)->cc1) && tcpm_cc_is_audio((port)->cc2)) 539 540 #define tcpm_port_is_audio_detached(port) \ 541 ((tcpm_cc_is_audio((port)->cc1) && tcpm_cc_is_open((port)->cc2)) || \ 542 (tcpm_cc_is_audio((port)->cc2) && tcpm_cc_is_open((port)->cc1))) 543 544 #define tcpm_try_snk(port) \ 545 ((port)->try_snk_count == 0 && (port)->try_role == TYPEC_SINK && \ 546 (port)->port_type == TYPEC_PORT_DRP) 547 548 #define tcpm_try_src(port) \ 549 ((port)->try_src_count == 0 && (port)->try_role == TYPEC_SOURCE && \ 550 (port)->port_type == TYPEC_PORT_DRP) 551 552 #define tcpm_data_role_for_source(port) \ 553 ((port)->typec_caps.data == TYPEC_PORT_UFP ? \ 554 TYPEC_DEVICE : TYPEC_HOST) 555 556 #define tcpm_data_role_for_sink(port) \ 557 ((port)->typec_caps.data == TYPEC_PORT_DFP ? \ 558 TYPEC_HOST : TYPEC_DEVICE) 559 560 #define tcpm_sink_tx_ok(port) \ 561 (tcpm_port_is_sink(port) && \ 562 ((port)->cc1 == TYPEC_CC_RP_3_0 || (port)->cc2 == TYPEC_CC_RP_3_0)) 563 564 #define tcpm_wait_for_discharge(port) \ 565 (((port)->auto_vbus_discharge_enabled && !(port)->vbus_vsafe0v) ? PD_T_SAFE_0V : 0) 566 567 static enum tcpm_state tcpm_default_state(struct tcpm_port *port) 568 { 569 if (port->port_type == TYPEC_PORT_DRP) { 570 if (port->try_role == TYPEC_SINK) 571 return SNK_UNATTACHED; 572 else if (port->try_role == TYPEC_SOURCE) 573 return SRC_UNATTACHED; 574 /* Fall through to return SRC_UNATTACHED */ 575 } else if (port->port_type == TYPEC_PORT_SNK) { 576 return SNK_UNATTACHED; 577 } 578 return SRC_UNATTACHED; 579 } 580 581 static bool tcpm_port_is_disconnected(struct tcpm_port *port) 582 { 583 return (!port->attached && port->cc1 == TYPEC_CC_OPEN && 584 port->cc2 == TYPEC_CC_OPEN) || 585 (port->attached && ((port->polarity == TYPEC_POLARITY_CC1 && 586 port->cc1 == TYPEC_CC_OPEN) || 587 (port->polarity == TYPEC_POLARITY_CC2 && 588 port->cc2 == TYPEC_CC_OPEN))); 589 } 590 591 /* 592 * Logging 593 */ 594 595 #ifdef CONFIG_DEBUG_FS 596 597 static bool tcpm_log_full(struct tcpm_port *port) 598 { 599 return port->logbuffer_tail == 600 (port->logbuffer_head + 1) % LOG_BUFFER_ENTRIES; 601 } 602 603 __printf(2, 0) 604 static void _tcpm_log(struct tcpm_port *port, const char *fmt, va_list args) 605 { 606 char tmpbuffer[LOG_BUFFER_ENTRY_SIZE]; 607 u64 ts_nsec = local_clock(); 608 unsigned long rem_nsec; 609 610 mutex_lock(&port->logbuffer_lock); 611 if (!port->logbuffer[port->logbuffer_head]) { 612 port->logbuffer[port->logbuffer_head] = 613 kzalloc(LOG_BUFFER_ENTRY_SIZE, GFP_KERNEL); 614 if (!port->logbuffer[port->logbuffer_head]) { 615 mutex_unlock(&port->logbuffer_lock); 616 return; 617 } 618 } 619 620 vsnprintf(tmpbuffer, sizeof(tmpbuffer), fmt, args); 621 622 if (tcpm_log_full(port)) { 623 port->logbuffer_head = max(port->logbuffer_head - 1, 0); 624 strcpy(tmpbuffer, "overflow"); 625 } 626 627 if (port->logbuffer_head < 0 || 628 port->logbuffer_head >= LOG_BUFFER_ENTRIES) { 629 dev_warn(port->dev, 630 "Bad log buffer index %d\n", port->logbuffer_head); 631 goto abort; 632 } 633 634 if (!port->logbuffer[port->logbuffer_head]) { 635 dev_warn(port->dev, 636 "Log buffer index %d is NULL\n", port->logbuffer_head); 637 goto abort; 638 } 639 640 rem_nsec = do_div(ts_nsec, 1000000000); 641 scnprintf(port->logbuffer[port->logbuffer_head], 642 LOG_BUFFER_ENTRY_SIZE, "[%5lu.%06lu] %s", 643 (unsigned long)ts_nsec, rem_nsec / 1000, 644 tmpbuffer); 645 port->logbuffer_head = (port->logbuffer_head + 1) % LOG_BUFFER_ENTRIES; 646 647 abort: 648 mutex_unlock(&port->logbuffer_lock); 649 } 650 651 __printf(2, 3) 652 static void tcpm_log(struct tcpm_port *port, const char *fmt, ...) 653 { 654 va_list args; 655 656 /* Do not log while disconnected and unattached */ 657 if (tcpm_port_is_disconnected(port) && 658 (port->state == SRC_UNATTACHED || port->state == SNK_UNATTACHED || 659 port->state == TOGGLING || port->state == CHECK_CONTAMINANT)) 660 return; 661 662 va_start(args, fmt); 663 _tcpm_log(port, fmt, args); 664 va_end(args); 665 } 666 667 __printf(2, 3) 668 static void tcpm_log_force(struct tcpm_port *port, const char *fmt, ...) 669 { 670 va_list args; 671 672 va_start(args, fmt); 673 _tcpm_log(port, fmt, args); 674 va_end(args); 675 } 676 677 static void tcpm_log_source_caps(struct tcpm_port *port) 678 { 679 int i; 680 681 for (i = 0; i < port->nr_source_caps; i++) { 682 u32 pdo = port->source_caps[i]; 683 enum pd_pdo_type type = pdo_type(pdo); 684 char msg[64]; 685 686 switch (type) { 687 case PDO_TYPE_FIXED: 688 scnprintf(msg, sizeof(msg), 689 "%u mV, %u mA [%s%s%s%s%s%s]", 690 pdo_fixed_voltage(pdo), 691 pdo_max_current(pdo), 692 (pdo & PDO_FIXED_DUAL_ROLE) ? 693 "R" : "", 694 (pdo & PDO_FIXED_SUSPEND) ? 695 "S" : "", 696 (pdo & PDO_FIXED_HIGHER_CAP) ? 697 "H" : "", 698 (pdo & PDO_FIXED_USB_COMM) ? 699 "U" : "", 700 (pdo & PDO_FIXED_DATA_SWAP) ? 701 "D" : "", 702 (pdo & PDO_FIXED_EXTPOWER) ? 703 "E" : ""); 704 break; 705 case PDO_TYPE_VAR: 706 scnprintf(msg, sizeof(msg), 707 "%u-%u mV, %u mA", 708 pdo_min_voltage(pdo), 709 pdo_max_voltage(pdo), 710 pdo_max_current(pdo)); 711 break; 712 case PDO_TYPE_BATT: 713 scnprintf(msg, sizeof(msg), 714 "%u-%u mV, %u mW", 715 pdo_min_voltage(pdo), 716 pdo_max_voltage(pdo), 717 pdo_max_power(pdo)); 718 break; 719 case PDO_TYPE_APDO: 720 if (pdo_apdo_type(pdo) == APDO_TYPE_PPS) 721 scnprintf(msg, sizeof(msg), 722 "%u-%u mV, %u mA", 723 pdo_pps_apdo_min_voltage(pdo), 724 pdo_pps_apdo_max_voltage(pdo), 725 pdo_pps_apdo_max_current(pdo)); 726 else 727 strcpy(msg, "undefined APDO"); 728 break; 729 default: 730 strcpy(msg, "undefined"); 731 break; 732 } 733 tcpm_log(port, " PDO %d: type %d, %s", 734 i, type, msg); 735 } 736 } 737 738 static int tcpm_debug_show(struct seq_file *s, void *v) 739 { 740 struct tcpm_port *port = s->private; 741 int tail; 742 743 mutex_lock(&port->logbuffer_lock); 744 tail = port->logbuffer_tail; 745 while (tail != port->logbuffer_head) { 746 seq_printf(s, "%s\n", port->logbuffer[tail]); 747 tail = (tail + 1) % LOG_BUFFER_ENTRIES; 748 } 749 if (!seq_has_overflowed(s)) 750 port->logbuffer_tail = tail; 751 mutex_unlock(&port->logbuffer_lock); 752 753 return 0; 754 } 755 DEFINE_SHOW_ATTRIBUTE(tcpm_debug); 756 757 static void tcpm_debugfs_init(struct tcpm_port *port) 758 { 759 char name[NAME_MAX]; 760 761 mutex_init(&port->logbuffer_lock); 762 snprintf(name, NAME_MAX, "tcpm-%s", dev_name(port->dev)); 763 port->dentry = debugfs_create_dir(name, usb_debug_root); 764 debugfs_create_file("log", S_IFREG | 0444, port->dentry, port, 765 &tcpm_debug_fops); 766 } 767 768 static void tcpm_debugfs_exit(struct tcpm_port *port) 769 { 770 int i; 771 772 mutex_lock(&port->logbuffer_lock); 773 for (i = 0; i < LOG_BUFFER_ENTRIES; i++) { 774 kfree(port->logbuffer[i]); 775 port->logbuffer[i] = NULL; 776 } 777 mutex_unlock(&port->logbuffer_lock); 778 779 debugfs_remove(port->dentry); 780 } 781 782 #else 783 784 __printf(2, 3) 785 static void tcpm_log(const struct tcpm_port *port, const char *fmt, ...) { } 786 __printf(2, 3) 787 static void tcpm_log_force(struct tcpm_port *port, const char *fmt, ...) { } 788 static void tcpm_log_source_caps(struct tcpm_port *port) { } 789 static void tcpm_debugfs_init(const struct tcpm_port *port) { } 790 static void tcpm_debugfs_exit(const struct tcpm_port *port) { } 791 792 #endif 793 794 static void tcpm_set_cc(struct tcpm_port *port, enum typec_cc_status cc) 795 { 796 tcpm_log(port, "cc:=%d", cc); 797 port->cc_req = cc; 798 port->tcpc->set_cc(port->tcpc, cc); 799 } 800 801 static int tcpm_enable_auto_vbus_discharge(struct tcpm_port *port, bool enable) 802 { 803 int ret = 0; 804 805 if (port->tcpc->enable_auto_vbus_discharge) { 806 ret = port->tcpc->enable_auto_vbus_discharge(port->tcpc, enable); 807 tcpm_log_force(port, "%s vbus discharge ret:%d", enable ? "enable" : "disable", 808 ret); 809 if (!ret) 810 port->auto_vbus_discharge_enabled = enable; 811 } 812 813 return ret; 814 } 815 816 static void tcpm_apply_rc(struct tcpm_port *port) 817 { 818 /* 819 * TCPCI: Move to APPLY_RC state to prevent disconnect during PR_SWAP 820 * when Vbus auto discharge on disconnect is enabled. 821 */ 822 if (port->tcpc->enable_auto_vbus_discharge && port->tcpc->apply_rc) { 823 tcpm_log(port, "Apply_RC"); 824 port->tcpc->apply_rc(port->tcpc, port->cc_req, port->polarity); 825 tcpm_enable_auto_vbus_discharge(port, false); 826 } 827 } 828 829 /* 830 * Determine RP value to set based on maximum current supported 831 * by a port if configured as source. 832 * Returns CC value to report to link partner. 833 */ 834 static enum typec_cc_status tcpm_rp_cc(struct tcpm_port *port) 835 { 836 const u32 *src_pdo = port->src_pdo; 837 int nr_pdo = port->nr_src_pdo; 838 int i; 839 840 if (!port->pd_supported) 841 return port->src_rp; 842 843 /* 844 * Search for first entry with matching voltage. 845 * It should report the maximum supported current. 846 */ 847 for (i = 0; i < nr_pdo; i++) { 848 const u32 pdo = src_pdo[i]; 849 850 if (pdo_type(pdo) == PDO_TYPE_FIXED && 851 pdo_fixed_voltage(pdo) == 5000) { 852 unsigned int curr = pdo_max_current(pdo); 853 854 if (curr >= 3000) 855 return TYPEC_CC_RP_3_0; 856 else if (curr >= 1500) 857 return TYPEC_CC_RP_1_5; 858 return TYPEC_CC_RP_DEF; 859 } 860 } 861 862 return TYPEC_CC_RP_DEF; 863 } 864 865 static void tcpm_ams_finish(struct tcpm_port *port) 866 { 867 tcpm_log(port, "AMS %s finished", tcpm_ams_str[port->ams]); 868 869 if (port->pd_capable && port->pwr_role == TYPEC_SOURCE) { 870 if (port->negotiated_rev >= PD_REV30) 871 tcpm_set_cc(port, SINK_TX_OK); 872 else 873 tcpm_set_cc(port, SINK_TX_NG); 874 } else if (port->pwr_role == TYPEC_SOURCE) { 875 tcpm_set_cc(port, tcpm_rp_cc(port)); 876 } 877 878 port->in_ams = false; 879 port->ams = NONE_AMS; 880 } 881 882 static int tcpm_pd_transmit(struct tcpm_port *port, 883 enum tcpm_transmit_type type, 884 const struct pd_message *msg) 885 { 886 unsigned long timeout; 887 int ret; 888 889 if (msg) 890 tcpm_log(port, "PD TX, header: %#x", le16_to_cpu(msg->header)); 891 else 892 tcpm_log(port, "PD TX, type: %#x", type); 893 894 reinit_completion(&port->tx_complete); 895 ret = port->tcpc->pd_transmit(port->tcpc, type, msg, port->negotiated_rev); 896 if (ret < 0) 897 return ret; 898 899 mutex_unlock(&port->lock); 900 timeout = wait_for_completion_timeout(&port->tx_complete, 901 msecs_to_jiffies(PD_T_TCPC_TX_TIMEOUT)); 902 mutex_lock(&port->lock); 903 if (!timeout) 904 return -ETIMEDOUT; 905 906 switch (port->tx_status) { 907 case TCPC_TX_SUCCESS: 908 port->message_id = (port->message_id + 1) & PD_HEADER_ID_MASK; 909 /* 910 * USB PD rev 2.0, 8.3.2.2.1: 911 * USB PD rev 3.0, 8.3.2.1.3: 912 * "... Note that every AMS is Interruptible until the first 913 * Message in the sequence has been successfully sent (GoodCRC 914 * Message received)." 915 */ 916 if (port->ams != NONE_AMS) 917 port->in_ams = true; 918 break; 919 case TCPC_TX_DISCARDED: 920 ret = -EAGAIN; 921 break; 922 case TCPC_TX_FAILED: 923 default: 924 ret = -EIO; 925 break; 926 } 927 928 /* Some AMS don't expect responses. Finish them here. */ 929 if (port->ams == ATTENTION || port->ams == SOURCE_ALERT) 930 tcpm_ams_finish(port); 931 932 return ret; 933 } 934 935 void tcpm_pd_transmit_complete(struct tcpm_port *port, 936 enum tcpm_transmit_status status) 937 { 938 tcpm_log(port, "PD TX complete, status: %u", status); 939 port->tx_status = status; 940 complete(&port->tx_complete); 941 } 942 EXPORT_SYMBOL_GPL(tcpm_pd_transmit_complete); 943 944 static int tcpm_mux_set(struct tcpm_port *port, int state, 945 enum usb_role usb_role, 946 enum typec_orientation orientation) 947 { 948 int ret; 949 950 tcpm_log(port, "Requesting mux state %d, usb-role %d, orientation %d", 951 state, usb_role, orientation); 952 953 ret = typec_set_orientation(port->typec_port, orientation); 954 if (ret) 955 return ret; 956 957 if (port->role_sw) { 958 ret = usb_role_switch_set_role(port->role_sw, usb_role); 959 if (ret) 960 return ret; 961 } 962 963 return typec_set_mode(port->typec_port, state); 964 } 965 966 static int tcpm_set_polarity(struct tcpm_port *port, 967 enum typec_cc_polarity polarity) 968 { 969 int ret; 970 971 tcpm_log(port, "polarity %d", polarity); 972 973 ret = port->tcpc->set_polarity(port->tcpc, polarity); 974 if (ret < 0) 975 return ret; 976 977 port->polarity = polarity; 978 979 return 0; 980 } 981 982 static int tcpm_set_vconn(struct tcpm_port *port, bool enable) 983 { 984 int ret; 985 986 tcpm_log(port, "vconn:=%d", enable); 987 988 ret = port->tcpc->set_vconn(port->tcpc, enable); 989 if (!ret) { 990 port->vconn_role = enable ? TYPEC_SOURCE : TYPEC_SINK; 991 typec_set_vconn_role(port->typec_port, port->vconn_role); 992 } 993 994 return ret; 995 } 996 997 static u32 tcpm_get_current_limit(struct tcpm_port *port) 998 { 999 enum typec_cc_status cc; 1000 u32 limit; 1001 1002 cc = port->polarity ? port->cc2 : port->cc1; 1003 switch (cc) { 1004 case TYPEC_CC_RP_1_5: 1005 limit = 1500; 1006 break; 1007 case TYPEC_CC_RP_3_0: 1008 limit = 3000; 1009 break; 1010 case TYPEC_CC_RP_DEF: 1011 default: 1012 if (port->tcpc->get_current_limit) 1013 limit = port->tcpc->get_current_limit(port->tcpc); 1014 else 1015 limit = 0; 1016 break; 1017 } 1018 1019 return limit; 1020 } 1021 1022 static int tcpm_set_current_limit(struct tcpm_port *port, u32 max_ma, u32 mv) 1023 { 1024 int ret = -EOPNOTSUPP; 1025 1026 tcpm_log(port, "Setting voltage/current limit %u mV %u mA", mv, max_ma); 1027 1028 port->supply_voltage = mv; 1029 port->current_limit = max_ma; 1030 power_supply_changed(port->psy); 1031 1032 if (port->tcpc->set_current_limit) 1033 ret = port->tcpc->set_current_limit(port->tcpc, max_ma, mv); 1034 1035 return ret; 1036 } 1037 1038 static int tcpm_set_attached_state(struct tcpm_port *port, bool attached) 1039 { 1040 return port->tcpc->set_roles(port->tcpc, attached, port->pwr_role, 1041 port->data_role); 1042 } 1043 1044 static int tcpm_set_roles(struct tcpm_port *port, bool attached, 1045 enum typec_role role, enum typec_data_role data) 1046 { 1047 enum typec_orientation orientation; 1048 enum usb_role usb_role; 1049 int ret; 1050 1051 if (port->polarity == TYPEC_POLARITY_CC1) 1052 orientation = TYPEC_ORIENTATION_NORMAL; 1053 else 1054 orientation = TYPEC_ORIENTATION_REVERSE; 1055 1056 if (port->typec_caps.data == TYPEC_PORT_DRD) { 1057 if (data == TYPEC_HOST) 1058 usb_role = USB_ROLE_HOST; 1059 else 1060 usb_role = USB_ROLE_DEVICE; 1061 } else if (port->typec_caps.data == TYPEC_PORT_DFP) { 1062 if (data == TYPEC_HOST) { 1063 if (role == TYPEC_SOURCE) 1064 usb_role = USB_ROLE_HOST; 1065 else 1066 usb_role = USB_ROLE_NONE; 1067 } else { 1068 return -ENOTSUPP; 1069 } 1070 } else { 1071 if (data == TYPEC_DEVICE) { 1072 if (role == TYPEC_SINK) 1073 usb_role = USB_ROLE_DEVICE; 1074 else 1075 usb_role = USB_ROLE_NONE; 1076 } else { 1077 return -ENOTSUPP; 1078 } 1079 } 1080 1081 ret = tcpm_mux_set(port, TYPEC_STATE_USB, usb_role, orientation); 1082 if (ret < 0) 1083 return ret; 1084 1085 ret = port->tcpc->set_roles(port->tcpc, attached, role, data); 1086 if (ret < 0) 1087 return ret; 1088 1089 port->pwr_role = role; 1090 port->data_role = data; 1091 typec_set_data_role(port->typec_port, data); 1092 typec_set_pwr_role(port->typec_port, role); 1093 1094 return 0; 1095 } 1096 1097 static int tcpm_set_pwr_role(struct tcpm_port *port, enum typec_role role) 1098 { 1099 int ret; 1100 1101 ret = port->tcpc->set_roles(port->tcpc, true, role, 1102 port->data_role); 1103 if (ret < 0) 1104 return ret; 1105 1106 port->pwr_role = role; 1107 typec_set_pwr_role(port->typec_port, role); 1108 1109 return 0; 1110 } 1111 1112 /* 1113 * Transform the PDO to be compliant to PD rev2.0. 1114 * Return 0 if the PDO type is not defined in PD rev2.0. 1115 * Otherwise, return the converted PDO. 1116 */ 1117 static u32 tcpm_forge_legacy_pdo(struct tcpm_port *port, u32 pdo, enum typec_role role) 1118 { 1119 switch (pdo_type(pdo)) { 1120 case PDO_TYPE_FIXED: 1121 if (role == TYPEC_SINK) 1122 return pdo & ~PDO_FIXED_FRS_CURR_MASK; 1123 else 1124 return pdo & ~PDO_FIXED_UNCHUNK_EXT; 1125 case PDO_TYPE_VAR: 1126 case PDO_TYPE_BATT: 1127 return pdo; 1128 case PDO_TYPE_APDO: 1129 default: 1130 return 0; 1131 } 1132 } 1133 1134 static int tcpm_pd_send_source_caps(struct tcpm_port *port) 1135 { 1136 struct pd_message msg; 1137 u32 pdo; 1138 unsigned int i, nr_pdo = 0; 1139 1140 memset(&msg, 0, sizeof(msg)); 1141 1142 for (i = 0; i < port->nr_src_pdo; i++) { 1143 if (port->negotiated_rev >= PD_REV30) { 1144 msg.payload[nr_pdo++] = cpu_to_le32(port->src_pdo[i]); 1145 } else { 1146 pdo = tcpm_forge_legacy_pdo(port, port->src_pdo[i], TYPEC_SOURCE); 1147 if (pdo) 1148 msg.payload[nr_pdo++] = cpu_to_le32(pdo); 1149 } 1150 } 1151 1152 if (!nr_pdo) { 1153 /* No source capabilities defined, sink only */ 1154 msg.header = PD_HEADER_LE(PD_CTRL_REJECT, 1155 port->pwr_role, 1156 port->data_role, 1157 port->negotiated_rev, 1158 port->message_id, 0); 1159 } else { 1160 msg.header = PD_HEADER_LE(PD_DATA_SOURCE_CAP, 1161 port->pwr_role, 1162 port->data_role, 1163 port->negotiated_rev, 1164 port->message_id, 1165 nr_pdo); 1166 } 1167 1168 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 1169 } 1170 1171 static int tcpm_pd_send_sink_caps(struct tcpm_port *port) 1172 { 1173 struct pd_message msg; 1174 u32 pdo; 1175 unsigned int i, nr_pdo = 0; 1176 1177 memset(&msg, 0, sizeof(msg)); 1178 1179 for (i = 0; i < port->nr_snk_pdo; i++) { 1180 if (port->negotiated_rev >= PD_REV30) { 1181 msg.payload[nr_pdo++] = cpu_to_le32(port->snk_pdo[i]); 1182 } else { 1183 pdo = tcpm_forge_legacy_pdo(port, port->snk_pdo[i], TYPEC_SINK); 1184 if (pdo) 1185 msg.payload[nr_pdo++] = cpu_to_le32(pdo); 1186 } 1187 } 1188 1189 if (!nr_pdo) { 1190 /* No sink capabilities defined, source only */ 1191 msg.header = PD_HEADER_LE(PD_CTRL_REJECT, 1192 port->pwr_role, 1193 port->data_role, 1194 port->negotiated_rev, 1195 port->message_id, 0); 1196 } else { 1197 msg.header = PD_HEADER_LE(PD_DATA_SINK_CAP, 1198 port->pwr_role, 1199 port->data_role, 1200 port->negotiated_rev, 1201 port->message_id, 1202 nr_pdo); 1203 } 1204 1205 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 1206 } 1207 1208 static void mod_tcpm_delayed_work(struct tcpm_port *port, unsigned int delay_ms) 1209 { 1210 if (delay_ms) { 1211 hrtimer_start(&port->state_machine_timer, ms_to_ktime(delay_ms), HRTIMER_MODE_REL); 1212 } else { 1213 hrtimer_cancel(&port->state_machine_timer); 1214 kthread_queue_work(port->wq, &port->state_machine); 1215 } 1216 } 1217 1218 static void mod_vdm_delayed_work(struct tcpm_port *port, unsigned int delay_ms) 1219 { 1220 if (delay_ms) { 1221 hrtimer_start(&port->vdm_state_machine_timer, ms_to_ktime(delay_ms), 1222 HRTIMER_MODE_REL); 1223 } else { 1224 hrtimer_cancel(&port->vdm_state_machine_timer); 1225 kthread_queue_work(port->wq, &port->vdm_state_machine); 1226 } 1227 } 1228 1229 static void mod_enable_frs_delayed_work(struct tcpm_port *port, unsigned int delay_ms) 1230 { 1231 if (delay_ms) { 1232 hrtimer_start(&port->enable_frs_timer, ms_to_ktime(delay_ms), HRTIMER_MODE_REL); 1233 } else { 1234 hrtimer_cancel(&port->enable_frs_timer); 1235 kthread_queue_work(port->wq, &port->enable_frs); 1236 } 1237 } 1238 1239 static void mod_send_discover_delayed_work(struct tcpm_port *port, unsigned int delay_ms) 1240 { 1241 if (delay_ms) { 1242 hrtimer_start(&port->send_discover_timer, ms_to_ktime(delay_ms), HRTIMER_MODE_REL); 1243 } else { 1244 hrtimer_cancel(&port->send_discover_timer); 1245 kthread_queue_work(port->wq, &port->send_discover_work); 1246 } 1247 } 1248 1249 static void tcpm_set_state(struct tcpm_port *port, enum tcpm_state state, 1250 unsigned int delay_ms) 1251 { 1252 if (delay_ms) { 1253 tcpm_log(port, "pending state change %s -> %s @ %u ms [%s %s]", 1254 tcpm_states[port->state], tcpm_states[state], delay_ms, 1255 pd_rev[port->negotiated_rev], tcpm_ams_str[port->ams]); 1256 port->delayed_state = state; 1257 mod_tcpm_delayed_work(port, delay_ms); 1258 port->delayed_runtime = ktime_add(ktime_get(), ms_to_ktime(delay_ms)); 1259 port->delay_ms = delay_ms; 1260 } else { 1261 tcpm_log(port, "state change %s -> %s [%s %s]", 1262 tcpm_states[port->state], tcpm_states[state], 1263 pd_rev[port->negotiated_rev], tcpm_ams_str[port->ams]); 1264 port->delayed_state = INVALID_STATE; 1265 port->prev_state = port->state; 1266 port->state = state; 1267 /* 1268 * Don't re-queue the state machine work item if we're currently 1269 * in the state machine and we're immediately changing states. 1270 * tcpm_state_machine_work() will continue running the state 1271 * machine. 1272 */ 1273 if (!port->state_machine_running) 1274 mod_tcpm_delayed_work(port, 0); 1275 } 1276 } 1277 1278 static void tcpm_set_state_cond(struct tcpm_port *port, enum tcpm_state state, 1279 unsigned int delay_ms) 1280 { 1281 if (port->enter_state == port->state) 1282 tcpm_set_state(port, state, delay_ms); 1283 else 1284 tcpm_log(port, 1285 "skipped %sstate change %s -> %s [%u ms], context state %s [%s %s]", 1286 delay_ms ? "delayed " : "", 1287 tcpm_states[port->state], tcpm_states[state], 1288 delay_ms, tcpm_states[port->enter_state], 1289 pd_rev[port->negotiated_rev], tcpm_ams_str[port->ams]); 1290 } 1291 1292 static void tcpm_queue_message(struct tcpm_port *port, 1293 enum pd_msg_request message) 1294 { 1295 port->queued_message = message; 1296 mod_tcpm_delayed_work(port, 0); 1297 } 1298 1299 static bool tcpm_vdm_ams(struct tcpm_port *port) 1300 { 1301 switch (port->ams) { 1302 case DISCOVER_IDENTITY: 1303 case SOURCE_STARTUP_CABLE_PLUG_DISCOVER_IDENTITY: 1304 case DISCOVER_SVIDS: 1305 case DISCOVER_MODES: 1306 case DFP_TO_UFP_ENTER_MODE: 1307 case DFP_TO_UFP_EXIT_MODE: 1308 case DFP_TO_CABLE_PLUG_ENTER_MODE: 1309 case DFP_TO_CABLE_PLUG_EXIT_MODE: 1310 case ATTENTION: 1311 case UNSTRUCTURED_VDMS: 1312 case STRUCTURED_VDMS: 1313 break; 1314 default: 1315 return false; 1316 } 1317 1318 return true; 1319 } 1320 1321 static bool tcpm_ams_interruptible(struct tcpm_port *port) 1322 { 1323 switch (port->ams) { 1324 /* Interruptible AMS */ 1325 case NONE_AMS: 1326 case SECURITY: 1327 case FIRMWARE_UPDATE: 1328 case DISCOVER_IDENTITY: 1329 case SOURCE_STARTUP_CABLE_PLUG_DISCOVER_IDENTITY: 1330 case DISCOVER_SVIDS: 1331 case DISCOVER_MODES: 1332 case DFP_TO_UFP_ENTER_MODE: 1333 case DFP_TO_UFP_EXIT_MODE: 1334 case DFP_TO_CABLE_PLUG_ENTER_MODE: 1335 case DFP_TO_CABLE_PLUG_EXIT_MODE: 1336 case UNSTRUCTURED_VDMS: 1337 case STRUCTURED_VDMS: 1338 case COUNTRY_INFO: 1339 case COUNTRY_CODES: 1340 break; 1341 /* Non-Interruptible AMS */ 1342 default: 1343 if (port->in_ams) 1344 return false; 1345 break; 1346 } 1347 1348 return true; 1349 } 1350 1351 static int tcpm_ams_start(struct tcpm_port *port, enum tcpm_ams ams) 1352 { 1353 int ret = 0; 1354 1355 tcpm_log(port, "AMS %s start", tcpm_ams_str[ams]); 1356 1357 if (!tcpm_ams_interruptible(port) && 1358 !(ams == HARD_RESET || ams == SOFT_RESET_AMS)) { 1359 port->upcoming_state = INVALID_STATE; 1360 tcpm_log(port, "AMS %s not interruptible, aborting", 1361 tcpm_ams_str[port->ams]); 1362 return -EAGAIN; 1363 } 1364 1365 if (port->pwr_role == TYPEC_SOURCE) { 1366 enum typec_cc_status cc_req = port->cc_req; 1367 1368 port->ams = ams; 1369 1370 if (ams == HARD_RESET) { 1371 tcpm_set_cc(port, tcpm_rp_cc(port)); 1372 tcpm_pd_transmit(port, TCPC_TX_HARD_RESET, NULL); 1373 tcpm_set_state(port, HARD_RESET_START, 0); 1374 return ret; 1375 } else if (ams == SOFT_RESET_AMS) { 1376 if (!port->explicit_contract) 1377 tcpm_set_cc(port, tcpm_rp_cc(port)); 1378 tcpm_set_state(port, SOFT_RESET_SEND, 0); 1379 return ret; 1380 } else if (tcpm_vdm_ams(port)) { 1381 /* tSinkTx is enforced in vdm_run_state_machine */ 1382 if (port->negotiated_rev >= PD_REV30) 1383 tcpm_set_cc(port, SINK_TX_NG); 1384 return ret; 1385 } 1386 1387 if (port->negotiated_rev >= PD_REV30) 1388 tcpm_set_cc(port, SINK_TX_NG); 1389 1390 switch (port->state) { 1391 case SRC_READY: 1392 case SRC_STARTUP: 1393 case SRC_SOFT_RESET_WAIT_SNK_TX: 1394 case SOFT_RESET: 1395 case SOFT_RESET_SEND: 1396 if (port->negotiated_rev >= PD_REV30) 1397 tcpm_set_state(port, AMS_START, 1398 cc_req == SINK_TX_OK ? 1399 PD_T_SINK_TX : 0); 1400 else 1401 tcpm_set_state(port, AMS_START, 0); 1402 break; 1403 default: 1404 if (port->negotiated_rev >= PD_REV30) 1405 tcpm_set_state(port, SRC_READY, 1406 cc_req == SINK_TX_OK ? 1407 PD_T_SINK_TX : 0); 1408 else 1409 tcpm_set_state(port, SRC_READY, 0); 1410 break; 1411 } 1412 } else { 1413 if (port->negotiated_rev >= PD_REV30 && 1414 !tcpm_sink_tx_ok(port) && 1415 ams != SOFT_RESET_AMS && 1416 ams != HARD_RESET) { 1417 port->upcoming_state = INVALID_STATE; 1418 tcpm_log(port, "Sink TX No Go"); 1419 return -EAGAIN; 1420 } 1421 1422 port->ams = ams; 1423 1424 if (ams == HARD_RESET) { 1425 tcpm_pd_transmit(port, TCPC_TX_HARD_RESET, NULL); 1426 tcpm_set_state(port, HARD_RESET_START, 0); 1427 return ret; 1428 } else if (tcpm_vdm_ams(port)) { 1429 return ret; 1430 } 1431 1432 if (port->state == SNK_READY || 1433 port->state == SNK_SOFT_RESET) 1434 tcpm_set_state(port, AMS_START, 0); 1435 else 1436 tcpm_set_state(port, SNK_READY, 0); 1437 } 1438 1439 return ret; 1440 } 1441 1442 /* 1443 * VDM/VDO handling functions 1444 */ 1445 static void tcpm_queue_vdm(struct tcpm_port *port, const u32 header, 1446 const u32 *data, int cnt) 1447 { 1448 u32 vdo_hdr = port->vdo_data[0]; 1449 1450 WARN_ON(!mutex_is_locked(&port->lock)); 1451 1452 /* If is sending discover_identity, handle received message first */ 1453 if (PD_VDO_SVDM(vdo_hdr) && PD_VDO_CMD(vdo_hdr) == CMD_DISCOVER_IDENT) { 1454 port->send_discover = true; 1455 mod_send_discover_delayed_work(port, SEND_DISCOVER_RETRY_MS); 1456 } else { 1457 /* Make sure we are not still processing a previous VDM packet */ 1458 WARN_ON(port->vdm_state > VDM_STATE_DONE); 1459 } 1460 1461 port->vdo_count = cnt + 1; 1462 port->vdo_data[0] = header; 1463 memcpy(&port->vdo_data[1], data, sizeof(u32) * cnt); 1464 /* Set ready, vdm state machine will actually send */ 1465 port->vdm_retries = 0; 1466 port->vdm_state = VDM_STATE_READY; 1467 port->vdm_sm_running = true; 1468 1469 mod_vdm_delayed_work(port, 0); 1470 } 1471 1472 static void tcpm_queue_vdm_unlocked(struct tcpm_port *port, const u32 header, 1473 const u32 *data, int cnt) 1474 { 1475 mutex_lock(&port->lock); 1476 tcpm_queue_vdm(port, header, data, cnt); 1477 mutex_unlock(&port->lock); 1478 } 1479 1480 static void svdm_consume_identity(struct tcpm_port *port, const u32 *p, int cnt) 1481 { 1482 u32 vdo = p[VDO_INDEX_IDH]; 1483 u32 product = p[VDO_INDEX_PRODUCT]; 1484 1485 memset(&port->mode_data, 0, sizeof(port->mode_data)); 1486 1487 port->partner_ident.id_header = vdo; 1488 port->partner_ident.cert_stat = p[VDO_INDEX_CSTAT]; 1489 port->partner_ident.product = product; 1490 1491 typec_partner_set_identity(port->partner); 1492 1493 tcpm_log(port, "Identity: %04x:%04x.%04x", 1494 PD_IDH_VID(vdo), 1495 PD_PRODUCT_PID(product), product & 0xffff); 1496 } 1497 1498 static bool svdm_consume_svids(struct tcpm_port *port, const u32 *p, int cnt) 1499 { 1500 struct pd_mode_data *pmdata = &port->mode_data; 1501 int i; 1502 1503 for (i = 1; i < cnt; i++) { 1504 u16 svid; 1505 1506 svid = (p[i] >> 16) & 0xffff; 1507 if (!svid) 1508 return false; 1509 1510 if (pmdata->nsvids >= SVID_DISCOVERY_MAX) 1511 goto abort; 1512 1513 pmdata->svids[pmdata->nsvids++] = svid; 1514 tcpm_log(port, "SVID %d: 0x%x", pmdata->nsvids, svid); 1515 1516 svid = p[i] & 0xffff; 1517 if (!svid) 1518 return false; 1519 1520 if (pmdata->nsvids >= SVID_DISCOVERY_MAX) 1521 goto abort; 1522 1523 pmdata->svids[pmdata->nsvids++] = svid; 1524 tcpm_log(port, "SVID %d: 0x%x", pmdata->nsvids, svid); 1525 } 1526 1527 /* 1528 * PD3.0 Spec 6.4.4.3.2: The SVIDs are returned 2 per VDO (see Table 1529 * 6-43), and can be returned maximum 6 VDOs per response (see Figure 1530 * 6-19). If the Respondersupports 12 or more SVID then the Discover 1531 * SVIDs Command Shall be executed multiple times until a Discover 1532 * SVIDs VDO is returned ending either with a SVID value of 0x0000 in 1533 * the last part of the last VDO or with a VDO containing two SVIDs 1534 * with values of 0x0000. 1535 * 1536 * However, some odd dockers support SVIDs less than 12 but without 1537 * 0x0000 in the last VDO, so we need to break the Discover SVIDs 1538 * request and return false here. 1539 */ 1540 return cnt == 7; 1541 abort: 1542 tcpm_log(port, "SVID_DISCOVERY_MAX(%d) too low!", SVID_DISCOVERY_MAX); 1543 return false; 1544 } 1545 1546 static void svdm_consume_modes(struct tcpm_port *port, const u32 *p, int cnt) 1547 { 1548 struct pd_mode_data *pmdata = &port->mode_data; 1549 struct typec_altmode_desc *paltmode; 1550 int i; 1551 1552 if (pmdata->altmodes >= ARRAY_SIZE(port->partner_altmode)) { 1553 /* Already logged in svdm_consume_svids() */ 1554 return; 1555 } 1556 1557 for (i = 1; i < cnt; i++) { 1558 paltmode = &pmdata->altmode_desc[pmdata->altmodes]; 1559 memset(paltmode, 0, sizeof(*paltmode)); 1560 1561 paltmode->svid = pmdata->svids[pmdata->svid_index]; 1562 paltmode->mode = i; 1563 paltmode->vdo = p[i]; 1564 1565 tcpm_log(port, " Alternate mode %d: SVID 0x%04x, VDO %d: 0x%08x", 1566 pmdata->altmodes, paltmode->svid, 1567 paltmode->mode, paltmode->vdo); 1568 1569 pmdata->altmodes++; 1570 } 1571 } 1572 1573 static void tcpm_register_partner_altmodes(struct tcpm_port *port) 1574 { 1575 struct pd_mode_data *modep = &port->mode_data; 1576 struct typec_altmode *altmode; 1577 int i; 1578 1579 for (i = 0; i < modep->altmodes; i++) { 1580 altmode = typec_partner_register_altmode(port->partner, 1581 &modep->altmode_desc[i]); 1582 if (IS_ERR(altmode)) { 1583 tcpm_log(port, "Failed to register partner SVID 0x%04x", 1584 modep->altmode_desc[i].svid); 1585 altmode = NULL; 1586 } 1587 port->partner_altmode[i] = altmode; 1588 } 1589 } 1590 1591 #define supports_modal(port) PD_IDH_MODAL_SUPP((port)->partner_ident.id_header) 1592 1593 static int tcpm_pd_svdm(struct tcpm_port *port, struct typec_altmode *adev, 1594 const u32 *p, int cnt, u32 *response, 1595 enum adev_actions *adev_action) 1596 { 1597 struct typec_port *typec = port->typec_port; 1598 struct typec_altmode *pdev; 1599 struct pd_mode_data *modep; 1600 int svdm_version; 1601 int rlen = 0; 1602 int cmd_type; 1603 int cmd; 1604 int i; 1605 1606 cmd_type = PD_VDO_CMDT(p[0]); 1607 cmd = PD_VDO_CMD(p[0]); 1608 1609 tcpm_log(port, "Rx VDM cmd 0x%x type %d cmd %d len %d", 1610 p[0], cmd_type, cmd, cnt); 1611 1612 modep = &port->mode_data; 1613 1614 pdev = typec_match_altmode(port->partner_altmode, ALTMODE_DISCOVERY_MAX, 1615 PD_VDO_VID(p[0]), PD_VDO_OPOS(p[0])); 1616 1617 svdm_version = typec_get_negotiated_svdm_version(typec); 1618 if (svdm_version < 0) 1619 return 0; 1620 1621 switch (cmd_type) { 1622 case CMDT_INIT: 1623 switch (cmd) { 1624 case CMD_DISCOVER_IDENT: 1625 if (PD_VDO_VID(p[0]) != USB_SID_PD) 1626 break; 1627 1628 if (PD_VDO_SVDM_VER(p[0]) < svdm_version) { 1629 typec_partner_set_svdm_version(port->partner, 1630 PD_VDO_SVDM_VER(p[0])); 1631 svdm_version = PD_VDO_SVDM_VER(p[0]); 1632 } 1633 1634 port->ams = DISCOVER_IDENTITY; 1635 /* 1636 * PD2.0 Spec 6.10.3: respond with NAK as DFP (data host) 1637 * PD3.1 Spec 6.4.4.2.5.1: respond with NAK if "invalid field" or 1638 * "wrong configuation" or "Unrecognized" 1639 */ 1640 if ((port->data_role == TYPEC_DEVICE || svdm_version >= SVDM_VER_2_0) && 1641 port->nr_snk_vdo) { 1642 if (svdm_version < SVDM_VER_2_0) { 1643 for (i = 0; i < port->nr_snk_vdo_v1; i++) 1644 response[i + 1] = port->snk_vdo_v1[i]; 1645 rlen = port->nr_snk_vdo_v1 + 1; 1646 1647 } else { 1648 for (i = 0; i < port->nr_snk_vdo; i++) 1649 response[i + 1] = port->snk_vdo[i]; 1650 rlen = port->nr_snk_vdo + 1; 1651 } 1652 } 1653 break; 1654 case CMD_DISCOVER_SVID: 1655 port->ams = DISCOVER_SVIDS; 1656 break; 1657 case CMD_DISCOVER_MODES: 1658 port->ams = DISCOVER_MODES; 1659 break; 1660 case CMD_ENTER_MODE: 1661 port->ams = DFP_TO_UFP_ENTER_MODE; 1662 break; 1663 case CMD_EXIT_MODE: 1664 port->ams = DFP_TO_UFP_EXIT_MODE; 1665 break; 1666 case CMD_ATTENTION: 1667 /* Attention command does not have response */ 1668 *adev_action = ADEV_ATTENTION; 1669 return 0; 1670 default: 1671 break; 1672 } 1673 if (rlen >= 1) { 1674 response[0] = p[0] | VDO_CMDT(CMDT_RSP_ACK); 1675 } else if (rlen == 0) { 1676 response[0] = p[0] | VDO_CMDT(CMDT_RSP_NAK); 1677 rlen = 1; 1678 } else { 1679 response[0] = p[0] | VDO_CMDT(CMDT_RSP_BUSY); 1680 rlen = 1; 1681 } 1682 response[0] = (response[0] & ~VDO_SVDM_VERS_MASK) | 1683 (VDO_SVDM_VERS(typec_get_negotiated_svdm_version(typec))); 1684 break; 1685 case CMDT_RSP_ACK: 1686 /* silently drop message if we are not connected */ 1687 if (IS_ERR_OR_NULL(port->partner)) 1688 break; 1689 1690 tcpm_ams_finish(port); 1691 1692 switch (cmd) { 1693 case CMD_DISCOVER_IDENT: 1694 if (PD_VDO_SVDM_VER(p[0]) < svdm_version) 1695 typec_partner_set_svdm_version(port->partner, 1696 PD_VDO_SVDM_VER(p[0])); 1697 /* 6.4.4.3.1 */ 1698 svdm_consume_identity(port, p, cnt); 1699 response[0] = VDO(USB_SID_PD, 1, typec_get_negotiated_svdm_version(typec), 1700 CMD_DISCOVER_SVID); 1701 rlen = 1; 1702 break; 1703 case CMD_DISCOVER_SVID: 1704 /* 6.4.4.3.2 */ 1705 if (svdm_consume_svids(port, p, cnt)) { 1706 response[0] = VDO(USB_SID_PD, 1, svdm_version, CMD_DISCOVER_SVID); 1707 rlen = 1; 1708 } else if (modep->nsvids && supports_modal(port)) { 1709 response[0] = VDO(modep->svids[0], 1, svdm_version, 1710 CMD_DISCOVER_MODES); 1711 rlen = 1; 1712 } 1713 break; 1714 case CMD_DISCOVER_MODES: 1715 /* 6.4.4.3.3 */ 1716 svdm_consume_modes(port, p, cnt); 1717 modep->svid_index++; 1718 if (modep->svid_index < modep->nsvids) { 1719 u16 svid = modep->svids[modep->svid_index]; 1720 response[0] = VDO(svid, 1, svdm_version, CMD_DISCOVER_MODES); 1721 rlen = 1; 1722 } else { 1723 tcpm_register_partner_altmodes(port); 1724 } 1725 break; 1726 case CMD_ENTER_MODE: 1727 if (adev && pdev) 1728 *adev_action = ADEV_QUEUE_VDM_SEND_EXIT_MODE_ON_FAIL; 1729 return 0; 1730 case CMD_EXIT_MODE: 1731 if (adev && pdev) { 1732 /* Back to USB Operation */ 1733 *adev_action = ADEV_NOTIFY_USB_AND_QUEUE_VDM; 1734 return 0; 1735 } 1736 break; 1737 case VDO_CMD_VENDOR(0) ... VDO_CMD_VENDOR(15): 1738 break; 1739 default: 1740 /* Unrecognized SVDM */ 1741 response[0] = p[0] | VDO_CMDT(CMDT_RSP_NAK); 1742 rlen = 1; 1743 response[0] = (response[0] & ~VDO_SVDM_VERS_MASK) | 1744 (VDO_SVDM_VERS(svdm_version)); 1745 break; 1746 } 1747 break; 1748 case CMDT_RSP_NAK: 1749 tcpm_ams_finish(port); 1750 switch (cmd) { 1751 case CMD_DISCOVER_IDENT: 1752 case CMD_DISCOVER_SVID: 1753 case CMD_DISCOVER_MODES: 1754 case VDO_CMD_VENDOR(0) ... VDO_CMD_VENDOR(15): 1755 break; 1756 case CMD_ENTER_MODE: 1757 /* Back to USB Operation */ 1758 *adev_action = ADEV_NOTIFY_USB_AND_QUEUE_VDM; 1759 return 0; 1760 default: 1761 /* Unrecognized SVDM */ 1762 response[0] = p[0] | VDO_CMDT(CMDT_RSP_NAK); 1763 rlen = 1; 1764 response[0] = (response[0] & ~VDO_SVDM_VERS_MASK) | 1765 (VDO_SVDM_VERS(svdm_version)); 1766 break; 1767 } 1768 break; 1769 default: 1770 response[0] = p[0] | VDO_CMDT(CMDT_RSP_NAK); 1771 rlen = 1; 1772 response[0] = (response[0] & ~VDO_SVDM_VERS_MASK) | 1773 (VDO_SVDM_VERS(svdm_version)); 1774 break; 1775 } 1776 1777 /* Informing the alternate mode drivers about everything */ 1778 *adev_action = ADEV_QUEUE_VDM; 1779 return rlen; 1780 } 1781 1782 static void tcpm_pd_handle_msg(struct tcpm_port *port, 1783 enum pd_msg_request message, 1784 enum tcpm_ams ams); 1785 1786 static void tcpm_handle_vdm_request(struct tcpm_port *port, 1787 const __le32 *payload, int cnt) 1788 { 1789 enum adev_actions adev_action = ADEV_NONE; 1790 struct typec_altmode *adev; 1791 u32 p[PD_MAX_PAYLOAD]; 1792 u32 response[8] = { }; 1793 int i, rlen = 0; 1794 1795 for (i = 0; i < cnt; i++) 1796 p[i] = le32_to_cpu(payload[i]); 1797 1798 adev = typec_match_altmode(port->port_altmode, ALTMODE_DISCOVERY_MAX, 1799 PD_VDO_VID(p[0]), PD_VDO_OPOS(p[0])); 1800 1801 if (port->vdm_state == VDM_STATE_BUSY) { 1802 /* If UFP responded busy retry after timeout */ 1803 if (PD_VDO_CMDT(p[0]) == CMDT_RSP_BUSY) { 1804 port->vdm_state = VDM_STATE_WAIT_RSP_BUSY; 1805 port->vdo_retry = (p[0] & ~VDO_CMDT_MASK) | 1806 CMDT_INIT; 1807 mod_vdm_delayed_work(port, PD_T_VDM_BUSY); 1808 return; 1809 } 1810 port->vdm_state = VDM_STATE_DONE; 1811 } 1812 1813 if (PD_VDO_SVDM(p[0]) && (adev || tcpm_vdm_ams(port) || port->nr_snk_vdo)) { 1814 /* 1815 * Here a SVDM is received (INIT or RSP or unknown). Set the vdm_sm_running in 1816 * advance because we are dropping the lock but may send VDMs soon. 1817 * For the cases of INIT received: 1818 * - If no response to send, it will be cleared later in this function. 1819 * - If there are responses to send, it will be cleared in the state machine. 1820 * For the cases of RSP received: 1821 * - If no further INIT to send, it will be cleared later in this function. 1822 * - Otherwise, it will be cleared in the state machine if timeout or it will go 1823 * back here until no further INIT to send. 1824 * For the cases of unknown type received: 1825 * - We will send NAK and the flag will be cleared in the state machine. 1826 */ 1827 port->vdm_sm_running = true; 1828 rlen = tcpm_pd_svdm(port, adev, p, cnt, response, &adev_action); 1829 } else { 1830 if (port->negotiated_rev >= PD_REV30) 1831 tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS); 1832 } 1833 1834 /* 1835 * We are done with any state stored in the port struct now, except 1836 * for any port struct changes done by the tcpm_queue_vdm() call 1837 * below, which is a separate operation. 1838 * 1839 * So we can safely release the lock here; and we MUST release the 1840 * lock here to avoid an AB BA lock inversion: 1841 * 1842 * If we keep the lock here then the lock ordering in this path is: 1843 * 1. tcpm_pd_rx_handler take the tcpm port lock 1844 * 2. One of the typec_altmode_* calls below takes the alt-mode's lock 1845 * 1846 * And we also have this ordering: 1847 * 1. alt-mode driver takes the alt-mode's lock 1848 * 2. alt-mode driver calls tcpm_altmode_enter which takes the 1849 * tcpm port lock 1850 * 1851 * Dropping our lock here avoids this. 1852 */ 1853 mutex_unlock(&port->lock); 1854 1855 if (adev) { 1856 switch (adev_action) { 1857 case ADEV_NONE: 1858 break; 1859 case ADEV_NOTIFY_USB_AND_QUEUE_VDM: 1860 WARN_ON(typec_altmode_notify(adev, TYPEC_STATE_USB, NULL)); 1861 typec_altmode_vdm(adev, p[0], &p[1], cnt); 1862 break; 1863 case ADEV_QUEUE_VDM: 1864 typec_altmode_vdm(adev, p[0], &p[1], cnt); 1865 break; 1866 case ADEV_QUEUE_VDM_SEND_EXIT_MODE_ON_FAIL: 1867 if (typec_altmode_vdm(adev, p[0], &p[1], cnt)) { 1868 int svdm_version = typec_get_negotiated_svdm_version( 1869 port->typec_port); 1870 if (svdm_version < 0) 1871 break; 1872 1873 response[0] = VDO(adev->svid, 1, svdm_version, 1874 CMD_EXIT_MODE); 1875 response[0] |= VDO_OPOS(adev->mode); 1876 rlen = 1; 1877 } 1878 break; 1879 case ADEV_ATTENTION: 1880 typec_altmode_attention(adev, p[1]); 1881 break; 1882 } 1883 } 1884 1885 /* 1886 * We must re-take the lock here to balance the unlock in 1887 * tcpm_pd_rx_handler, note that no changes, other then the 1888 * tcpm_queue_vdm call, are made while the lock is held again. 1889 * All that is done after the call is unwinding the call stack until 1890 * we return to tcpm_pd_rx_handler and do the unlock there. 1891 */ 1892 mutex_lock(&port->lock); 1893 1894 if (rlen > 0) 1895 tcpm_queue_vdm(port, response[0], &response[1], rlen - 1); 1896 else 1897 port->vdm_sm_running = false; 1898 } 1899 1900 static void tcpm_send_vdm(struct tcpm_port *port, u32 vid, int cmd, 1901 const u32 *data, int count) 1902 { 1903 int svdm_version = typec_get_negotiated_svdm_version(port->typec_port); 1904 u32 header; 1905 1906 if (svdm_version < 0) 1907 return; 1908 1909 if (WARN_ON(count > VDO_MAX_SIZE - 1)) 1910 count = VDO_MAX_SIZE - 1; 1911 1912 /* set VDM header with VID & CMD */ 1913 header = VDO(vid, ((vid & USB_SID_PD) == USB_SID_PD) ? 1914 1 : (PD_VDO_CMD(cmd) <= CMD_ATTENTION), 1915 svdm_version, cmd); 1916 tcpm_queue_vdm(port, header, data, count); 1917 } 1918 1919 static unsigned int vdm_ready_timeout(u32 vdm_hdr) 1920 { 1921 unsigned int timeout; 1922 int cmd = PD_VDO_CMD(vdm_hdr); 1923 1924 /* its not a structured VDM command */ 1925 if (!PD_VDO_SVDM(vdm_hdr)) 1926 return PD_T_VDM_UNSTRUCTURED; 1927 1928 switch (PD_VDO_CMDT(vdm_hdr)) { 1929 case CMDT_INIT: 1930 if (cmd == CMD_ENTER_MODE || cmd == CMD_EXIT_MODE) 1931 timeout = PD_T_VDM_WAIT_MODE_E; 1932 else 1933 timeout = PD_T_VDM_SNDR_RSP; 1934 break; 1935 default: 1936 if (cmd == CMD_ENTER_MODE || cmd == CMD_EXIT_MODE) 1937 timeout = PD_T_VDM_E_MODE; 1938 else 1939 timeout = PD_T_VDM_RCVR_RSP; 1940 break; 1941 } 1942 return timeout; 1943 } 1944 1945 static void vdm_run_state_machine(struct tcpm_port *port) 1946 { 1947 struct pd_message msg; 1948 int i, res = 0; 1949 u32 vdo_hdr = port->vdo_data[0]; 1950 1951 switch (port->vdm_state) { 1952 case VDM_STATE_READY: 1953 /* Only transmit VDM if attached */ 1954 if (!port->attached) { 1955 port->vdm_state = VDM_STATE_ERR_BUSY; 1956 break; 1957 } 1958 1959 /* 1960 * if there's traffic or we're not in PDO ready state don't send 1961 * a VDM. 1962 */ 1963 if (port->state != SRC_READY && port->state != SNK_READY) { 1964 port->vdm_sm_running = false; 1965 break; 1966 } 1967 1968 /* TODO: AMS operation for Unstructured VDM */ 1969 if (PD_VDO_SVDM(vdo_hdr) && PD_VDO_CMDT(vdo_hdr) == CMDT_INIT) { 1970 switch (PD_VDO_CMD(vdo_hdr)) { 1971 case CMD_DISCOVER_IDENT: 1972 res = tcpm_ams_start(port, DISCOVER_IDENTITY); 1973 if (res == 0) { 1974 port->send_discover = false; 1975 } else if (res == -EAGAIN) { 1976 port->vdo_data[0] = 0; 1977 mod_send_discover_delayed_work(port, 1978 SEND_DISCOVER_RETRY_MS); 1979 } 1980 break; 1981 case CMD_DISCOVER_SVID: 1982 res = tcpm_ams_start(port, DISCOVER_SVIDS); 1983 break; 1984 case CMD_DISCOVER_MODES: 1985 res = tcpm_ams_start(port, DISCOVER_MODES); 1986 break; 1987 case CMD_ENTER_MODE: 1988 res = tcpm_ams_start(port, DFP_TO_UFP_ENTER_MODE); 1989 break; 1990 case CMD_EXIT_MODE: 1991 res = tcpm_ams_start(port, DFP_TO_UFP_EXIT_MODE); 1992 break; 1993 case CMD_ATTENTION: 1994 res = tcpm_ams_start(port, ATTENTION); 1995 break; 1996 case VDO_CMD_VENDOR(0) ... VDO_CMD_VENDOR(15): 1997 res = tcpm_ams_start(port, STRUCTURED_VDMS); 1998 break; 1999 default: 2000 res = -EOPNOTSUPP; 2001 break; 2002 } 2003 2004 if (res < 0) { 2005 port->vdm_state = VDM_STATE_ERR_BUSY; 2006 return; 2007 } 2008 } 2009 2010 port->vdm_state = VDM_STATE_SEND_MESSAGE; 2011 mod_vdm_delayed_work(port, (port->negotiated_rev >= PD_REV30 && 2012 port->pwr_role == TYPEC_SOURCE && 2013 PD_VDO_SVDM(vdo_hdr) && 2014 PD_VDO_CMDT(vdo_hdr) == CMDT_INIT) ? 2015 PD_T_SINK_TX : 0); 2016 break; 2017 case VDM_STATE_WAIT_RSP_BUSY: 2018 port->vdo_data[0] = port->vdo_retry; 2019 port->vdo_count = 1; 2020 port->vdm_state = VDM_STATE_READY; 2021 tcpm_ams_finish(port); 2022 break; 2023 case VDM_STATE_BUSY: 2024 port->vdm_state = VDM_STATE_ERR_TMOUT; 2025 if (port->ams != NONE_AMS) 2026 tcpm_ams_finish(port); 2027 break; 2028 case VDM_STATE_ERR_SEND: 2029 /* 2030 * A partner which does not support USB PD will not reply, 2031 * so this is not a fatal error. At the same time, some 2032 * devices may not return GoodCRC under some circumstances, 2033 * so we need to retry. 2034 */ 2035 if (port->vdm_retries < 3) { 2036 tcpm_log(port, "VDM Tx error, retry"); 2037 port->vdm_retries++; 2038 port->vdm_state = VDM_STATE_READY; 2039 if (PD_VDO_SVDM(vdo_hdr) && PD_VDO_CMDT(vdo_hdr) == CMDT_INIT) 2040 tcpm_ams_finish(port); 2041 } else { 2042 tcpm_ams_finish(port); 2043 } 2044 break; 2045 case VDM_STATE_SEND_MESSAGE: 2046 /* Prepare and send VDM */ 2047 memset(&msg, 0, sizeof(msg)); 2048 msg.header = PD_HEADER_LE(PD_DATA_VENDOR_DEF, 2049 port->pwr_role, 2050 port->data_role, 2051 port->negotiated_rev, 2052 port->message_id, port->vdo_count); 2053 for (i = 0; i < port->vdo_count; i++) 2054 msg.payload[i] = cpu_to_le32(port->vdo_data[i]); 2055 res = tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 2056 if (res < 0) { 2057 port->vdm_state = VDM_STATE_ERR_SEND; 2058 } else { 2059 unsigned long timeout; 2060 2061 port->vdm_retries = 0; 2062 port->vdo_data[0] = 0; 2063 port->vdm_state = VDM_STATE_BUSY; 2064 timeout = vdm_ready_timeout(vdo_hdr); 2065 mod_vdm_delayed_work(port, timeout); 2066 } 2067 break; 2068 default: 2069 break; 2070 } 2071 } 2072 2073 static void vdm_state_machine_work(struct kthread_work *work) 2074 { 2075 struct tcpm_port *port = container_of(work, struct tcpm_port, vdm_state_machine); 2076 enum vdm_states prev_state; 2077 2078 mutex_lock(&port->lock); 2079 2080 /* 2081 * Continue running as long as the port is not busy and there was 2082 * a state change. 2083 */ 2084 do { 2085 prev_state = port->vdm_state; 2086 vdm_run_state_machine(port); 2087 } while (port->vdm_state != prev_state && 2088 port->vdm_state != VDM_STATE_BUSY && 2089 port->vdm_state != VDM_STATE_SEND_MESSAGE); 2090 2091 if (port->vdm_state < VDM_STATE_READY) 2092 port->vdm_sm_running = false; 2093 2094 mutex_unlock(&port->lock); 2095 } 2096 2097 enum pdo_err { 2098 PDO_NO_ERR, 2099 PDO_ERR_NO_VSAFE5V, 2100 PDO_ERR_VSAFE5V_NOT_FIRST, 2101 PDO_ERR_PDO_TYPE_NOT_IN_ORDER, 2102 PDO_ERR_FIXED_NOT_SORTED, 2103 PDO_ERR_VARIABLE_BATT_NOT_SORTED, 2104 PDO_ERR_DUPE_PDO, 2105 PDO_ERR_PPS_APDO_NOT_SORTED, 2106 PDO_ERR_DUPE_PPS_APDO, 2107 }; 2108 2109 static const char * const pdo_err_msg[] = { 2110 [PDO_ERR_NO_VSAFE5V] = 2111 " err: source/sink caps should at least have vSafe5V", 2112 [PDO_ERR_VSAFE5V_NOT_FIRST] = 2113 " err: vSafe5V Fixed Supply Object Shall always be the first object", 2114 [PDO_ERR_PDO_TYPE_NOT_IN_ORDER] = 2115 " err: PDOs should be in the following order: Fixed; Battery; Variable", 2116 [PDO_ERR_FIXED_NOT_SORTED] = 2117 " err: Fixed supply pdos should be in increasing order of their fixed voltage", 2118 [PDO_ERR_VARIABLE_BATT_NOT_SORTED] = 2119 " err: Variable/Battery supply pdos should be in increasing order of their minimum voltage", 2120 [PDO_ERR_DUPE_PDO] = 2121 " err: Variable/Batt supply pdos cannot have same min/max voltage", 2122 [PDO_ERR_PPS_APDO_NOT_SORTED] = 2123 " err: Programmable power supply apdos should be in increasing order of their maximum voltage", 2124 [PDO_ERR_DUPE_PPS_APDO] = 2125 " err: Programmable power supply apdos cannot have same min/max voltage and max current", 2126 }; 2127 2128 static enum pdo_err tcpm_caps_err(struct tcpm_port *port, const u32 *pdo, 2129 unsigned int nr_pdo) 2130 { 2131 unsigned int i; 2132 2133 /* Should at least contain vSafe5v */ 2134 if (nr_pdo < 1) 2135 return PDO_ERR_NO_VSAFE5V; 2136 2137 /* The vSafe5V Fixed Supply Object Shall always be the first object */ 2138 if (pdo_type(pdo[0]) != PDO_TYPE_FIXED || 2139 pdo_fixed_voltage(pdo[0]) != VSAFE5V) 2140 return PDO_ERR_VSAFE5V_NOT_FIRST; 2141 2142 for (i = 1; i < nr_pdo; i++) { 2143 if (pdo_type(pdo[i]) < pdo_type(pdo[i - 1])) { 2144 return PDO_ERR_PDO_TYPE_NOT_IN_ORDER; 2145 } else if (pdo_type(pdo[i]) == pdo_type(pdo[i - 1])) { 2146 enum pd_pdo_type type = pdo_type(pdo[i]); 2147 2148 switch (type) { 2149 /* 2150 * The remaining Fixed Supply Objects, if 2151 * present, shall be sent in voltage order; 2152 * lowest to highest. 2153 */ 2154 case PDO_TYPE_FIXED: 2155 if (pdo_fixed_voltage(pdo[i]) <= 2156 pdo_fixed_voltage(pdo[i - 1])) 2157 return PDO_ERR_FIXED_NOT_SORTED; 2158 break; 2159 /* 2160 * The Battery Supply Objects and Variable 2161 * supply, if present shall be sent in Minimum 2162 * Voltage order; lowest to highest. 2163 */ 2164 case PDO_TYPE_VAR: 2165 case PDO_TYPE_BATT: 2166 if (pdo_min_voltage(pdo[i]) < 2167 pdo_min_voltage(pdo[i - 1])) 2168 return PDO_ERR_VARIABLE_BATT_NOT_SORTED; 2169 else if ((pdo_min_voltage(pdo[i]) == 2170 pdo_min_voltage(pdo[i - 1])) && 2171 (pdo_max_voltage(pdo[i]) == 2172 pdo_max_voltage(pdo[i - 1]))) 2173 return PDO_ERR_DUPE_PDO; 2174 break; 2175 /* 2176 * The Programmable Power Supply APDOs, if present, 2177 * shall be sent in Maximum Voltage order; 2178 * lowest to highest. 2179 */ 2180 case PDO_TYPE_APDO: 2181 if (pdo_apdo_type(pdo[i]) != APDO_TYPE_PPS) 2182 break; 2183 2184 if (pdo_pps_apdo_max_voltage(pdo[i]) < 2185 pdo_pps_apdo_max_voltage(pdo[i - 1])) 2186 return PDO_ERR_PPS_APDO_NOT_SORTED; 2187 else if (pdo_pps_apdo_min_voltage(pdo[i]) == 2188 pdo_pps_apdo_min_voltage(pdo[i - 1]) && 2189 pdo_pps_apdo_max_voltage(pdo[i]) == 2190 pdo_pps_apdo_max_voltage(pdo[i - 1]) && 2191 pdo_pps_apdo_max_current(pdo[i]) == 2192 pdo_pps_apdo_max_current(pdo[i - 1])) 2193 return PDO_ERR_DUPE_PPS_APDO; 2194 break; 2195 default: 2196 tcpm_log_force(port, " Unknown pdo type"); 2197 } 2198 } 2199 } 2200 2201 return PDO_NO_ERR; 2202 } 2203 2204 static int tcpm_validate_caps(struct tcpm_port *port, const u32 *pdo, 2205 unsigned int nr_pdo) 2206 { 2207 enum pdo_err err_index = tcpm_caps_err(port, pdo, nr_pdo); 2208 2209 if (err_index != PDO_NO_ERR) { 2210 tcpm_log_force(port, " %s", pdo_err_msg[err_index]); 2211 return -EINVAL; 2212 } 2213 2214 return 0; 2215 } 2216 2217 static int tcpm_altmode_enter(struct typec_altmode *altmode, u32 *vdo) 2218 { 2219 struct tcpm_port *port = typec_altmode_get_drvdata(altmode); 2220 int svdm_version; 2221 u32 header; 2222 2223 svdm_version = typec_get_negotiated_svdm_version(port->typec_port); 2224 if (svdm_version < 0) 2225 return svdm_version; 2226 2227 header = VDO(altmode->svid, vdo ? 2 : 1, svdm_version, CMD_ENTER_MODE); 2228 header |= VDO_OPOS(altmode->mode); 2229 2230 tcpm_queue_vdm_unlocked(port, header, vdo, vdo ? 1 : 0); 2231 return 0; 2232 } 2233 2234 static int tcpm_altmode_exit(struct typec_altmode *altmode) 2235 { 2236 struct tcpm_port *port = typec_altmode_get_drvdata(altmode); 2237 int svdm_version; 2238 u32 header; 2239 2240 svdm_version = typec_get_negotiated_svdm_version(port->typec_port); 2241 if (svdm_version < 0) 2242 return svdm_version; 2243 2244 header = VDO(altmode->svid, 1, svdm_version, CMD_EXIT_MODE); 2245 header |= VDO_OPOS(altmode->mode); 2246 2247 tcpm_queue_vdm_unlocked(port, header, NULL, 0); 2248 return 0; 2249 } 2250 2251 static int tcpm_altmode_vdm(struct typec_altmode *altmode, 2252 u32 header, const u32 *data, int count) 2253 { 2254 struct tcpm_port *port = typec_altmode_get_drvdata(altmode); 2255 2256 tcpm_queue_vdm_unlocked(port, header, data, count - 1); 2257 2258 return 0; 2259 } 2260 2261 static const struct typec_altmode_ops tcpm_altmode_ops = { 2262 .enter = tcpm_altmode_enter, 2263 .exit = tcpm_altmode_exit, 2264 .vdm = tcpm_altmode_vdm, 2265 }; 2266 2267 /* 2268 * PD (data, control) command handling functions 2269 */ 2270 static inline enum tcpm_state ready_state(struct tcpm_port *port) 2271 { 2272 if (port->pwr_role == TYPEC_SOURCE) 2273 return SRC_READY; 2274 else 2275 return SNK_READY; 2276 } 2277 2278 static int tcpm_pd_send_control(struct tcpm_port *port, 2279 enum pd_ctrl_msg_type type); 2280 2281 static void tcpm_handle_alert(struct tcpm_port *port, const __le32 *payload, 2282 int cnt) 2283 { 2284 u32 p0 = le32_to_cpu(payload[0]); 2285 unsigned int type = usb_pd_ado_type(p0); 2286 2287 if (!type) { 2288 tcpm_log(port, "Alert message received with no type"); 2289 tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP); 2290 return; 2291 } 2292 2293 /* Just handling non-battery alerts for now */ 2294 if (!(type & USB_PD_ADO_TYPE_BATT_STATUS_CHANGE)) { 2295 if (port->pwr_role == TYPEC_SOURCE) { 2296 port->upcoming_state = GET_STATUS_SEND; 2297 tcpm_ams_start(port, GETTING_SOURCE_SINK_STATUS); 2298 } else { 2299 /* 2300 * Do not check SinkTxOk here in case the Source doesn't set its Rp to 2301 * SinkTxOk in time. 2302 */ 2303 port->ams = GETTING_SOURCE_SINK_STATUS; 2304 tcpm_set_state(port, GET_STATUS_SEND, 0); 2305 } 2306 } else { 2307 tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP); 2308 } 2309 } 2310 2311 static int tcpm_set_auto_vbus_discharge_threshold(struct tcpm_port *port, 2312 enum typec_pwr_opmode mode, bool pps_active, 2313 u32 requested_vbus_voltage) 2314 { 2315 int ret; 2316 2317 if (!port->tcpc->set_auto_vbus_discharge_threshold) 2318 return 0; 2319 2320 ret = port->tcpc->set_auto_vbus_discharge_threshold(port->tcpc, mode, pps_active, 2321 requested_vbus_voltage); 2322 tcpm_log_force(port, 2323 "set_auto_vbus_discharge_threshold mode:%d pps_active:%c vbus:%u ret:%d", 2324 mode, pps_active ? 'y' : 'n', requested_vbus_voltage, ret); 2325 2326 return ret; 2327 } 2328 2329 static void tcpm_pd_handle_state(struct tcpm_port *port, 2330 enum tcpm_state state, 2331 enum tcpm_ams ams, 2332 unsigned int delay_ms) 2333 { 2334 switch (port->state) { 2335 case SRC_READY: 2336 case SNK_READY: 2337 port->ams = ams; 2338 tcpm_set_state(port, state, delay_ms); 2339 break; 2340 /* 8.3.3.4.1.1 and 6.8.1 power transitioning */ 2341 case SNK_TRANSITION_SINK: 2342 case SNK_TRANSITION_SINK_VBUS: 2343 case SRC_TRANSITION_SUPPLY: 2344 tcpm_set_state(port, HARD_RESET_SEND, 0); 2345 break; 2346 default: 2347 if (!tcpm_ams_interruptible(port)) { 2348 tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ? 2349 SRC_SOFT_RESET_WAIT_SNK_TX : 2350 SNK_SOFT_RESET, 2351 0); 2352 } else { 2353 /* process the Message 6.8.1 */ 2354 port->upcoming_state = state; 2355 port->next_ams = ams; 2356 tcpm_set_state(port, ready_state(port), delay_ms); 2357 } 2358 break; 2359 } 2360 } 2361 2362 static void tcpm_pd_handle_msg(struct tcpm_port *port, 2363 enum pd_msg_request message, 2364 enum tcpm_ams ams) 2365 { 2366 switch (port->state) { 2367 case SRC_READY: 2368 case SNK_READY: 2369 port->ams = ams; 2370 tcpm_queue_message(port, message); 2371 break; 2372 /* PD 3.0 Spec 8.3.3.4.1.1 and 6.8.1 */ 2373 case SNK_TRANSITION_SINK: 2374 case SNK_TRANSITION_SINK_VBUS: 2375 case SRC_TRANSITION_SUPPLY: 2376 tcpm_set_state(port, HARD_RESET_SEND, 0); 2377 break; 2378 default: 2379 if (!tcpm_ams_interruptible(port)) { 2380 tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ? 2381 SRC_SOFT_RESET_WAIT_SNK_TX : 2382 SNK_SOFT_RESET, 2383 0); 2384 } else { 2385 port->next_ams = ams; 2386 tcpm_set_state(port, ready_state(port), 0); 2387 /* 6.8.1 process the Message */ 2388 tcpm_queue_message(port, message); 2389 } 2390 break; 2391 } 2392 } 2393 2394 static int tcpm_register_source_caps(struct tcpm_port *port) 2395 { 2396 struct usb_power_delivery_desc desc = { port->negotiated_rev }; 2397 struct usb_power_delivery_capabilities_desc caps = { }; 2398 struct usb_power_delivery_capabilities *cap; 2399 2400 if (!port->partner_pd) 2401 port->partner_pd = usb_power_delivery_register(NULL, &desc); 2402 if (IS_ERR(port->partner_pd)) 2403 return PTR_ERR(port->partner_pd); 2404 2405 memcpy(caps.pdo, port->source_caps, sizeof(u32) * port->nr_source_caps); 2406 caps.role = TYPEC_SOURCE; 2407 2408 cap = usb_power_delivery_register_capabilities(port->partner_pd, &caps); 2409 if (IS_ERR(cap)) 2410 return PTR_ERR(cap); 2411 2412 port->partner_source_caps = cap; 2413 2414 return 0; 2415 } 2416 2417 static int tcpm_register_sink_caps(struct tcpm_port *port) 2418 { 2419 struct usb_power_delivery_desc desc = { port->negotiated_rev }; 2420 struct usb_power_delivery_capabilities_desc caps = { }; 2421 struct usb_power_delivery_capabilities *cap; 2422 2423 if (!port->partner_pd) 2424 port->partner_pd = usb_power_delivery_register(NULL, &desc); 2425 if (IS_ERR(port->partner_pd)) 2426 return PTR_ERR(port->partner_pd); 2427 2428 memcpy(caps.pdo, port->sink_caps, sizeof(u32) * port->nr_sink_caps); 2429 caps.role = TYPEC_SINK; 2430 2431 cap = usb_power_delivery_register_capabilities(port->partner_pd, &caps); 2432 if (IS_ERR(cap)) 2433 return PTR_ERR(cap); 2434 2435 port->partner_sink_caps = cap; 2436 2437 return 0; 2438 } 2439 2440 static void tcpm_pd_data_request(struct tcpm_port *port, 2441 const struct pd_message *msg) 2442 { 2443 enum pd_data_msg_type type = pd_header_type_le(msg->header); 2444 unsigned int cnt = pd_header_cnt_le(msg->header); 2445 unsigned int rev = pd_header_rev_le(msg->header); 2446 unsigned int i; 2447 enum frs_typec_current partner_frs_current; 2448 bool frs_enable; 2449 int ret; 2450 2451 if (tcpm_vdm_ams(port) && type != PD_DATA_VENDOR_DEF) { 2452 port->vdm_state = VDM_STATE_ERR_BUSY; 2453 tcpm_ams_finish(port); 2454 mod_vdm_delayed_work(port, 0); 2455 } 2456 2457 switch (type) { 2458 case PD_DATA_SOURCE_CAP: 2459 for (i = 0; i < cnt; i++) 2460 port->source_caps[i] = le32_to_cpu(msg->payload[i]); 2461 2462 port->nr_source_caps = cnt; 2463 2464 tcpm_log_source_caps(port); 2465 2466 tcpm_validate_caps(port, port->source_caps, 2467 port->nr_source_caps); 2468 2469 tcpm_register_source_caps(port); 2470 2471 /* 2472 * Adjust revision in subsequent message headers, as required, 2473 * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't 2474 * support Rev 1.0 so just do nothing in that scenario. 2475 */ 2476 if (rev == PD_REV10) { 2477 if (port->ams == GET_SOURCE_CAPABILITIES) 2478 tcpm_ams_finish(port); 2479 break; 2480 } 2481 2482 if (rev < PD_MAX_REV) 2483 port->negotiated_rev = rev; 2484 2485 if (port->pwr_role == TYPEC_SOURCE) { 2486 if (port->ams == GET_SOURCE_CAPABILITIES) 2487 tcpm_pd_handle_state(port, SRC_READY, NONE_AMS, 0); 2488 /* Unexpected Source Capabilities */ 2489 else 2490 tcpm_pd_handle_msg(port, 2491 port->negotiated_rev < PD_REV30 ? 2492 PD_MSG_CTRL_REJECT : 2493 PD_MSG_CTRL_NOT_SUPP, 2494 NONE_AMS); 2495 } else if (port->state == SNK_WAIT_CAPABILITIES) { 2496 /* 2497 * This message may be received even if VBUS is not 2498 * present. This is quite unexpected; see USB PD 2499 * specification, sections 8.3.3.6.3.1 and 8.3.3.6.3.2. 2500 * However, at the same time, we must be ready to 2501 * receive this message and respond to it 15ms after 2502 * receiving PS_RDY during power swap operations, no matter 2503 * if VBUS is available or not (USB PD specification, 2504 * section 6.5.9.2). 2505 * So we need to accept the message either way, 2506 * but be prepared to keep waiting for VBUS after it was 2507 * handled. 2508 */ 2509 port->ams = POWER_NEGOTIATION; 2510 port->in_ams = true; 2511 tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0); 2512 } else { 2513 if (port->ams == GET_SOURCE_CAPABILITIES) 2514 tcpm_ams_finish(port); 2515 tcpm_pd_handle_state(port, SNK_NEGOTIATE_CAPABILITIES, 2516 POWER_NEGOTIATION, 0); 2517 } 2518 break; 2519 case PD_DATA_REQUEST: 2520 /* 2521 * Adjust revision in subsequent message headers, as required, 2522 * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't 2523 * support Rev 1.0 so just reject in that scenario. 2524 */ 2525 if (rev == PD_REV10) { 2526 tcpm_pd_handle_msg(port, 2527 port->negotiated_rev < PD_REV30 ? 2528 PD_MSG_CTRL_REJECT : 2529 PD_MSG_CTRL_NOT_SUPP, 2530 NONE_AMS); 2531 break; 2532 } 2533 2534 if (rev < PD_MAX_REV) 2535 port->negotiated_rev = rev; 2536 2537 if (port->pwr_role != TYPEC_SOURCE || cnt != 1) { 2538 tcpm_pd_handle_msg(port, 2539 port->negotiated_rev < PD_REV30 ? 2540 PD_MSG_CTRL_REJECT : 2541 PD_MSG_CTRL_NOT_SUPP, 2542 NONE_AMS); 2543 break; 2544 } 2545 2546 port->sink_request = le32_to_cpu(msg->payload[0]); 2547 2548 if (port->vdm_sm_running && port->explicit_contract) { 2549 tcpm_pd_handle_msg(port, PD_MSG_CTRL_WAIT, port->ams); 2550 break; 2551 } 2552 2553 if (port->state == SRC_SEND_CAPABILITIES) 2554 tcpm_set_state(port, SRC_NEGOTIATE_CAPABILITIES, 0); 2555 else 2556 tcpm_pd_handle_state(port, SRC_NEGOTIATE_CAPABILITIES, 2557 POWER_NEGOTIATION, 0); 2558 break; 2559 case PD_DATA_SINK_CAP: 2560 /* We don't do anything with this at the moment... */ 2561 for (i = 0; i < cnt; i++) 2562 port->sink_caps[i] = le32_to_cpu(msg->payload[i]); 2563 2564 partner_frs_current = (port->sink_caps[0] & PDO_FIXED_FRS_CURR_MASK) >> 2565 PDO_FIXED_FRS_CURR_SHIFT; 2566 frs_enable = partner_frs_current && (partner_frs_current <= 2567 port->new_source_frs_current); 2568 tcpm_log(port, 2569 "Port partner FRS capable partner_frs_current:%u port_frs_current:%u enable:%c", 2570 partner_frs_current, port->new_source_frs_current, frs_enable ? 'y' : 'n'); 2571 if (frs_enable) { 2572 ret = port->tcpc->enable_frs(port->tcpc, true); 2573 tcpm_log(port, "Enable FRS %s, ret:%d\n", ret ? "fail" : "success", ret); 2574 } 2575 2576 port->nr_sink_caps = cnt; 2577 port->sink_cap_done = true; 2578 tcpm_register_sink_caps(port); 2579 2580 if (port->ams == GET_SINK_CAPABILITIES) 2581 tcpm_set_state(port, ready_state(port), 0); 2582 /* Unexpected Sink Capabilities */ 2583 else 2584 tcpm_pd_handle_msg(port, 2585 port->negotiated_rev < PD_REV30 ? 2586 PD_MSG_CTRL_REJECT : 2587 PD_MSG_CTRL_NOT_SUPP, 2588 NONE_AMS); 2589 break; 2590 case PD_DATA_VENDOR_DEF: 2591 tcpm_handle_vdm_request(port, msg->payload, cnt); 2592 break; 2593 case PD_DATA_BIST: 2594 port->bist_request = le32_to_cpu(msg->payload[0]); 2595 tcpm_pd_handle_state(port, BIST_RX, BIST, 0); 2596 break; 2597 case PD_DATA_ALERT: 2598 if (port->state != SRC_READY && port->state != SNK_READY) 2599 tcpm_pd_handle_state(port, port->pwr_role == TYPEC_SOURCE ? 2600 SRC_SOFT_RESET_WAIT_SNK_TX : SNK_SOFT_RESET, 2601 NONE_AMS, 0); 2602 else 2603 tcpm_handle_alert(port, msg->payload, cnt); 2604 break; 2605 case PD_DATA_BATT_STATUS: 2606 case PD_DATA_GET_COUNTRY_INFO: 2607 /* Currently unsupported */ 2608 tcpm_pd_handle_msg(port, port->negotiated_rev < PD_REV30 ? 2609 PD_MSG_CTRL_REJECT : 2610 PD_MSG_CTRL_NOT_SUPP, 2611 NONE_AMS); 2612 break; 2613 default: 2614 tcpm_pd_handle_msg(port, port->negotiated_rev < PD_REV30 ? 2615 PD_MSG_CTRL_REJECT : 2616 PD_MSG_CTRL_NOT_SUPP, 2617 NONE_AMS); 2618 tcpm_log(port, "Unrecognized data message type %#x", type); 2619 break; 2620 } 2621 } 2622 2623 static void tcpm_pps_complete(struct tcpm_port *port, int result) 2624 { 2625 if (port->pps_pending) { 2626 port->pps_status = result; 2627 port->pps_pending = false; 2628 complete(&port->pps_complete); 2629 } 2630 } 2631 2632 static void tcpm_pd_ctrl_request(struct tcpm_port *port, 2633 const struct pd_message *msg) 2634 { 2635 enum pd_ctrl_msg_type type = pd_header_type_le(msg->header); 2636 enum tcpm_state next_state; 2637 2638 /* 2639 * Stop VDM state machine if interrupted by other Messages while NOT_SUPP is allowed in 2640 * VDM AMS if waiting for VDM responses and will be handled later. 2641 */ 2642 if (tcpm_vdm_ams(port) && type != PD_CTRL_NOT_SUPP && type != PD_CTRL_GOOD_CRC) { 2643 port->vdm_state = VDM_STATE_ERR_BUSY; 2644 tcpm_ams_finish(port); 2645 mod_vdm_delayed_work(port, 0); 2646 } 2647 2648 switch (type) { 2649 case PD_CTRL_GOOD_CRC: 2650 case PD_CTRL_PING: 2651 break; 2652 case PD_CTRL_GET_SOURCE_CAP: 2653 tcpm_pd_handle_msg(port, PD_MSG_DATA_SOURCE_CAP, GET_SOURCE_CAPABILITIES); 2654 break; 2655 case PD_CTRL_GET_SINK_CAP: 2656 tcpm_pd_handle_msg(port, PD_MSG_DATA_SINK_CAP, GET_SINK_CAPABILITIES); 2657 break; 2658 case PD_CTRL_GOTO_MIN: 2659 break; 2660 case PD_CTRL_PS_RDY: 2661 switch (port->state) { 2662 case SNK_TRANSITION_SINK: 2663 if (port->vbus_present) { 2664 tcpm_set_current_limit(port, 2665 port->req_current_limit, 2666 port->req_supply_voltage); 2667 port->explicit_contract = true; 2668 tcpm_set_auto_vbus_discharge_threshold(port, 2669 TYPEC_PWR_MODE_PD, 2670 port->pps_data.active, 2671 port->supply_voltage); 2672 tcpm_set_state(port, SNK_READY, 0); 2673 } else { 2674 /* 2675 * Seen after power swap. Keep waiting for VBUS 2676 * in a transitional state. 2677 */ 2678 tcpm_set_state(port, 2679 SNK_TRANSITION_SINK_VBUS, 0); 2680 } 2681 break; 2682 case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED: 2683 tcpm_set_state(port, PR_SWAP_SRC_SNK_SINK_ON, 0); 2684 break; 2685 case PR_SWAP_SNK_SRC_SINK_OFF: 2686 tcpm_set_state(port, PR_SWAP_SNK_SRC_SOURCE_ON, 0); 2687 break; 2688 case VCONN_SWAP_WAIT_FOR_VCONN: 2689 tcpm_set_state(port, VCONN_SWAP_TURN_OFF_VCONN, 0); 2690 break; 2691 case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF: 2692 tcpm_set_state(port, FR_SWAP_SNK_SRC_NEW_SINK_READY, 0); 2693 break; 2694 default: 2695 tcpm_pd_handle_state(port, 2696 port->pwr_role == TYPEC_SOURCE ? 2697 SRC_SOFT_RESET_WAIT_SNK_TX : 2698 SNK_SOFT_RESET, 2699 NONE_AMS, 0); 2700 break; 2701 } 2702 break; 2703 case PD_CTRL_REJECT: 2704 case PD_CTRL_WAIT: 2705 case PD_CTRL_NOT_SUPP: 2706 switch (port->state) { 2707 case SNK_NEGOTIATE_CAPABILITIES: 2708 /* USB PD specification, Figure 8-43 */ 2709 if (port->explicit_contract) 2710 next_state = SNK_READY; 2711 else 2712 next_state = SNK_WAIT_CAPABILITIES; 2713 2714 /* Threshold was relaxed before sending Request. Restore it back. */ 2715 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_PD, 2716 port->pps_data.active, 2717 port->supply_voltage); 2718 tcpm_set_state(port, next_state, 0); 2719 break; 2720 case SNK_NEGOTIATE_PPS_CAPABILITIES: 2721 /* Revert data back from any requested PPS updates */ 2722 port->pps_data.req_out_volt = port->supply_voltage; 2723 port->pps_data.req_op_curr = port->current_limit; 2724 port->pps_status = (type == PD_CTRL_WAIT ? 2725 -EAGAIN : -EOPNOTSUPP); 2726 2727 /* Threshold was relaxed before sending Request. Restore it back. */ 2728 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_PD, 2729 port->pps_data.active, 2730 port->supply_voltage); 2731 2732 tcpm_set_state(port, SNK_READY, 0); 2733 break; 2734 case DR_SWAP_SEND: 2735 port->swap_status = (type == PD_CTRL_WAIT ? 2736 -EAGAIN : -EOPNOTSUPP); 2737 tcpm_set_state(port, DR_SWAP_CANCEL, 0); 2738 break; 2739 case PR_SWAP_SEND: 2740 port->swap_status = (type == PD_CTRL_WAIT ? 2741 -EAGAIN : -EOPNOTSUPP); 2742 tcpm_set_state(port, PR_SWAP_CANCEL, 0); 2743 break; 2744 case VCONN_SWAP_SEND: 2745 port->swap_status = (type == PD_CTRL_WAIT ? 2746 -EAGAIN : -EOPNOTSUPP); 2747 tcpm_set_state(port, VCONN_SWAP_CANCEL, 0); 2748 break; 2749 case FR_SWAP_SEND: 2750 tcpm_set_state(port, FR_SWAP_CANCEL, 0); 2751 break; 2752 case GET_SINK_CAP: 2753 port->sink_cap_done = true; 2754 tcpm_set_state(port, ready_state(port), 0); 2755 break; 2756 case SRC_READY: 2757 case SNK_READY: 2758 if (port->vdm_state > VDM_STATE_READY) { 2759 port->vdm_state = VDM_STATE_DONE; 2760 if (tcpm_vdm_ams(port)) 2761 tcpm_ams_finish(port); 2762 mod_vdm_delayed_work(port, 0); 2763 break; 2764 } 2765 fallthrough; 2766 default: 2767 tcpm_pd_handle_state(port, 2768 port->pwr_role == TYPEC_SOURCE ? 2769 SRC_SOFT_RESET_WAIT_SNK_TX : 2770 SNK_SOFT_RESET, 2771 NONE_AMS, 0); 2772 break; 2773 } 2774 break; 2775 case PD_CTRL_ACCEPT: 2776 switch (port->state) { 2777 case SNK_NEGOTIATE_CAPABILITIES: 2778 port->pps_data.active = false; 2779 tcpm_set_state(port, SNK_TRANSITION_SINK, 0); 2780 break; 2781 case SNK_NEGOTIATE_PPS_CAPABILITIES: 2782 port->pps_data.active = true; 2783 port->pps_data.min_volt = port->pps_data.req_min_volt; 2784 port->pps_data.max_volt = port->pps_data.req_max_volt; 2785 port->pps_data.max_curr = port->pps_data.req_max_curr; 2786 port->req_supply_voltage = port->pps_data.req_out_volt; 2787 port->req_current_limit = port->pps_data.req_op_curr; 2788 power_supply_changed(port->psy); 2789 tcpm_set_state(port, SNK_TRANSITION_SINK, 0); 2790 break; 2791 case SOFT_RESET_SEND: 2792 if (port->ams == SOFT_RESET_AMS) 2793 tcpm_ams_finish(port); 2794 if (port->pwr_role == TYPEC_SOURCE) { 2795 port->upcoming_state = SRC_SEND_CAPABILITIES; 2796 tcpm_ams_start(port, POWER_NEGOTIATION); 2797 } else { 2798 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0); 2799 } 2800 break; 2801 case DR_SWAP_SEND: 2802 tcpm_set_state(port, DR_SWAP_CHANGE_DR, 0); 2803 break; 2804 case PR_SWAP_SEND: 2805 tcpm_set_state(port, PR_SWAP_START, 0); 2806 break; 2807 case VCONN_SWAP_SEND: 2808 tcpm_set_state(port, VCONN_SWAP_START, 0); 2809 break; 2810 case FR_SWAP_SEND: 2811 tcpm_set_state(port, FR_SWAP_SNK_SRC_TRANSITION_TO_OFF, 0); 2812 break; 2813 default: 2814 tcpm_pd_handle_state(port, 2815 port->pwr_role == TYPEC_SOURCE ? 2816 SRC_SOFT_RESET_WAIT_SNK_TX : 2817 SNK_SOFT_RESET, 2818 NONE_AMS, 0); 2819 break; 2820 } 2821 break; 2822 case PD_CTRL_SOFT_RESET: 2823 port->ams = SOFT_RESET_AMS; 2824 tcpm_set_state(port, SOFT_RESET, 0); 2825 break; 2826 case PD_CTRL_DR_SWAP: 2827 /* 2828 * XXX 2829 * 6.3.9: If an alternate mode is active, a request to swap 2830 * alternate modes shall trigger a port reset. 2831 */ 2832 if (port->typec_caps.data != TYPEC_PORT_DRD) { 2833 tcpm_pd_handle_msg(port, 2834 port->negotiated_rev < PD_REV30 ? 2835 PD_MSG_CTRL_REJECT : 2836 PD_MSG_CTRL_NOT_SUPP, 2837 NONE_AMS); 2838 } else { 2839 if (port->send_discover) { 2840 tcpm_queue_message(port, PD_MSG_CTRL_WAIT); 2841 break; 2842 } 2843 2844 tcpm_pd_handle_state(port, DR_SWAP_ACCEPT, DATA_ROLE_SWAP, 0); 2845 } 2846 break; 2847 case PD_CTRL_PR_SWAP: 2848 if (port->port_type != TYPEC_PORT_DRP) { 2849 tcpm_pd_handle_msg(port, 2850 port->negotiated_rev < PD_REV30 ? 2851 PD_MSG_CTRL_REJECT : 2852 PD_MSG_CTRL_NOT_SUPP, 2853 NONE_AMS); 2854 } else { 2855 if (port->send_discover) { 2856 tcpm_queue_message(port, PD_MSG_CTRL_WAIT); 2857 break; 2858 } 2859 2860 tcpm_pd_handle_state(port, PR_SWAP_ACCEPT, POWER_ROLE_SWAP, 0); 2861 } 2862 break; 2863 case PD_CTRL_VCONN_SWAP: 2864 if (port->send_discover) { 2865 tcpm_queue_message(port, PD_MSG_CTRL_WAIT); 2866 break; 2867 } 2868 2869 tcpm_pd_handle_state(port, VCONN_SWAP_ACCEPT, VCONN_SWAP, 0); 2870 break; 2871 case PD_CTRL_GET_SOURCE_CAP_EXT: 2872 case PD_CTRL_GET_STATUS: 2873 case PD_CTRL_FR_SWAP: 2874 case PD_CTRL_GET_PPS_STATUS: 2875 case PD_CTRL_GET_COUNTRY_CODES: 2876 /* Currently not supported */ 2877 tcpm_pd_handle_msg(port, 2878 port->negotiated_rev < PD_REV30 ? 2879 PD_MSG_CTRL_REJECT : 2880 PD_MSG_CTRL_NOT_SUPP, 2881 NONE_AMS); 2882 break; 2883 default: 2884 tcpm_pd_handle_msg(port, 2885 port->negotiated_rev < PD_REV30 ? 2886 PD_MSG_CTRL_REJECT : 2887 PD_MSG_CTRL_NOT_SUPP, 2888 NONE_AMS); 2889 tcpm_log(port, "Unrecognized ctrl message type %#x", type); 2890 break; 2891 } 2892 } 2893 2894 static void tcpm_pd_ext_msg_request(struct tcpm_port *port, 2895 const struct pd_message *msg) 2896 { 2897 enum pd_ext_msg_type type = pd_header_type_le(msg->header); 2898 unsigned int data_size = pd_ext_header_data_size_le(msg->ext_msg.header); 2899 2900 /* stopping VDM state machine if interrupted by other Messages */ 2901 if (tcpm_vdm_ams(port)) { 2902 port->vdm_state = VDM_STATE_ERR_BUSY; 2903 tcpm_ams_finish(port); 2904 mod_vdm_delayed_work(port, 0); 2905 } 2906 2907 if (!(le16_to_cpu(msg->ext_msg.header) & PD_EXT_HDR_CHUNKED)) { 2908 tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS); 2909 tcpm_log(port, "Unchunked extended messages unsupported"); 2910 return; 2911 } 2912 2913 if (data_size > PD_EXT_MAX_CHUNK_DATA) { 2914 tcpm_pd_handle_state(port, CHUNK_NOT_SUPP, NONE_AMS, PD_T_CHUNK_NOT_SUPP); 2915 tcpm_log(port, "Chunk handling not yet supported"); 2916 return; 2917 } 2918 2919 switch (type) { 2920 case PD_EXT_STATUS: 2921 case PD_EXT_PPS_STATUS: 2922 if (port->ams == GETTING_SOURCE_SINK_STATUS) { 2923 tcpm_ams_finish(port); 2924 tcpm_set_state(port, ready_state(port), 0); 2925 } else { 2926 /* unexpected Status or PPS_Status Message */ 2927 tcpm_pd_handle_state(port, port->pwr_role == TYPEC_SOURCE ? 2928 SRC_SOFT_RESET_WAIT_SNK_TX : SNK_SOFT_RESET, 2929 NONE_AMS, 0); 2930 } 2931 break; 2932 case PD_EXT_SOURCE_CAP_EXT: 2933 case PD_EXT_GET_BATT_CAP: 2934 case PD_EXT_GET_BATT_STATUS: 2935 case PD_EXT_BATT_CAP: 2936 case PD_EXT_GET_MANUFACTURER_INFO: 2937 case PD_EXT_MANUFACTURER_INFO: 2938 case PD_EXT_SECURITY_REQUEST: 2939 case PD_EXT_SECURITY_RESPONSE: 2940 case PD_EXT_FW_UPDATE_REQUEST: 2941 case PD_EXT_FW_UPDATE_RESPONSE: 2942 case PD_EXT_COUNTRY_INFO: 2943 case PD_EXT_COUNTRY_CODES: 2944 tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS); 2945 break; 2946 default: 2947 tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS); 2948 tcpm_log(port, "Unrecognized extended message type %#x", type); 2949 break; 2950 } 2951 } 2952 2953 static void tcpm_pd_rx_handler(struct kthread_work *work) 2954 { 2955 struct pd_rx_event *event = container_of(work, 2956 struct pd_rx_event, work); 2957 const struct pd_message *msg = &event->msg; 2958 unsigned int cnt = pd_header_cnt_le(msg->header); 2959 struct tcpm_port *port = event->port; 2960 2961 mutex_lock(&port->lock); 2962 2963 tcpm_log(port, "PD RX, header: %#x [%d]", le16_to_cpu(msg->header), 2964 port->attached); 2965 2966 if (port->attached) { 2967 enum pd_ctrl_msg_type type = pd_header_type_le(msg->header); 2968 unsigned int msgid = pd_header_msgid_le(msg->header); 2969 2970 /* 2971 * USB PD standard, 6.6.1.2: 2972 * "... if MessageID value in a received Message is the 2973 * same as the stored value, the receiver shall return a 2974 * GoodCRC Message with that MessageID value and drop 2975 * the Message (this is a retry of an already received 2976 * Message). Note: this shall not apply to the Soft_Reset 2977 * Message which always has a MessageID value of zero." 2978 */ 2979 if (msgid == port->rx_msgid && type != PD_CTRL_SOFT_RESET) 2980 goto done; 2981 port->rx_msgid = msgid; 2982 2983 /* 2984 * If both ends believe to be DFP/host, we have a data role 2985 * mismatch. 2986 */ 2987 if (!!(le16_to_cpu(msg->header) & PD_HEADER_DATA_ROLE) == 2988 (port->data_role == TYPEC_HOST)) { 2989 tcpm_log(port, 2990 "Data role mismatch, initiating error recovery"); 2991 tcpm_set_state(port, ERROR_RECOVERY, 0); 2992 } else { 2993 if (le16_to_cpu(msg->header) & PD_HEADER_EXT_HDR) 2994 tcpm_pd_ext_msg_request(port, msg); 2995 else if (cnt) 2996 tcpm_pd_data_request(port, msg); 2997 else 2998 tcpm_pd_ctrl_request(port, msg); 2999 } 3000 } 3001 3002 done: 3003 mutex_unlock(&port->lock); 3004 kfree(event); 3005 } 3006 3007 void tcpm_pd_receive(struct tcpm_port *port, const struct pd_message *msg) 3008 { 3009 struct pd_rx_event *event; 3010 3011 event = kzalloc(sizeof(*event), GFP_ATOMIC); 3012 if (!event) 3013 return; 3014 3015 kthread_init_work(&event->work, tcpm_pd_rx_handler); 3016 event->port = port; 3017 memcpy(&event->msg, msg, sizeof(*msg)); 3018 kthread_queue_work(port->wq, &event->work); 3019 } 3020 EXPORT_SYMBOL_GPL(tcpm_pd_receive); 3021 3022 static int tcpm_pd_send_control(struct tcpm_port *port, 3023 enum pd_ctrl_msg_type type) 3024 { 3025 struct pd_message msg; 3026 3027 memset(&msg, 0, sizeof(msg)); 3028 msg.header = PD_HEADER_LE(type, port->pwr_role, 3029 port->data_role, 3030 port->negotiated_rev, 3031 port->message_id, 0); 3032 3033 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 3034 } 3035 3036 /* 3037 * Send queued message without affecting state. 3038 * Return true if state machine should go back to sleep, 3039 * false otherwise. 3040 */ 3041 static bool tcpm_send_queued_message(struct tcpm_port *port) 3042 { 3043 enum pd_msg_request queued_message; 3044 int ret; 3045 3046 do { 3047 queued_message = port->queued_message; 3048 port->queued_message = PD_MSG_NONE; 3049 3050 switch (queued_message) { 3051 case PD_MSG_CTRL_WAIT: 3052 tcpm_pd_send_control(port, PD_CTRL_WAIT); 3053 break; 3054 case PD_MSG_CTRL_REJECT: 3055 tcpm_pd_send_control(port, PD_CTRL_REJECT); 3056 break; 3057 case PD_MSG_CTRL_NOT_SUPP: 3058 tcpm_pd_send_control(port, PD_CTRL_NOT_SUPP); 3059 break; 3060 case PD_MSG_DATA_SINK_CAP: 3061 ret = tcpm_pd_send_sink_caps(port); 3062 if (ret < 0) { 3063 tcpm_log(port, "Unable to send snk caps, ret=%d", ret); 3064 tcpm_set_state(port, SNK_SOFT_RESET, 0); 3065 } 3066 tcpm_ams_finish(port); 3067 break; 3068 case PD_MSG_DATA_SOURCE_CAP: 3069 ret = tcpm_pd_send_source_caps(port); 3070 if (ret < 0) { 3071 tcpm_log(port, 3072 "Unable to send src caps, ret=%d", 3073 ret); 3074 tcpm_set_state(port, SOFT_RESET_SEND, 0); 3075 } else if (port->pwr_role == TYPEC_SOURCE) { 3076 tcpm_ams_finish(port); 3077 tcpm_set_state(port, HARD_RESET_SEND, 3078 PD_T_SENDER_RESPONSE); 3079 } else { 3080 tcpm_ams_finish(port); 3081 } 3082 break; 3083 default: 3084 break; 3085 } 3086 } while (port->queued_message != PD_MSG_NONE); 3087 3088 if (port->delayed_state != INVALID_STATE) { 3089 if (ktime_after(port->delayed_runtime, ktime_get())) { 3090 mod_tcpm_delayed_work(port, ktime_to_ms(ktime_sub(port->delayed_runtime, 3091 ktime_get()))); 3092 return true; 3093 } 3094 port->delayed_state = INVALID_STATE; 3095 } 3096 return false; 3097 } 3098 3099 static int tcpm_pd_check_request(struct tcpm_port *port) 3100 { 3101 u32 pdo, rdo = port->sink_request; 3102 unsigned int max, op, pdo_max, index; 3103 enum pd_pdo_type type; 3104 3105 index = rdo_index(rdo); 3106 if (!index || index > port->nr_src_pdo) 3107 return -EINVAL; 3108 3109 pdo = port->src_pdo[index - 1]; 3110 type = pdo_type(pdo); 3111 switch (type) { 3112 case PDO_TYPE_FIXED: 3113 case PDO_TYPE_VAR: 3114 max = rdo_max_current(rdo); 3115 op = rdo_op_current(rdo); 3116 pdo_max = pdo_max_current(pdo); 3117 3118 if (op > pdo_max) 3119 return -EINVAL; 3120 if (max > pdo_max && !(rdo & RDO_CAP_MISMATCH)) 3121 return -EINVAL; 3122 3123 if (type == PDO_TYPE_FIXED) 3124 tcpm_log(port, 3125 "Requested %u mV, %u mA for %u / %u mA", 3126 pdo_fixed_voltage(pdo), pdo_max, op, max); 3127 else 3128 tcpm_log(port, 3129 "Requested %u -> %u mV, %u mA for %u / %u mA", 3130 pdo_min_voltage(pdo), pdo_max_voltage(pdo), 3131 pdo_max, op, max); 3132 break; 3133 case PDO_TYPE_BATT: 3134 max = rdo_max_power(rdo); 3135 op = rdo_op_power(rdo); 3136 pdo_max = pdo_max_power(pdo); 3137 3138 if (op > pdo_max) 3139 return -EINVAL; 3140 if (max > pdo_max && !(rdo & RDO_CAP_MISMATCH)) 3141 return -EINVAL; 3142 tcpm_log(port, 3143 "Requested %u -> %u mV, %u mW for %u / %u mW", 3144 pdo_min_voltage(pdo), pdo_max_voltage(pdo), 3145 pdo_max, op, max); 3146 break; 3147 default: 3148 return -EINVAL; 3149 } 3150 3151 port->op_vsafe5v = index == 1; 3152 3153 return 0; 3154 } 3155 3156 #define min_power(x, y) min(pdo_max_power(x), pdo_max_power(y)) 3157 #define min_current(x, y) min(pdo_max_current(x), pdo_max_current(y)) 3158 3159 static int tcpm_pd_select_pdo(struct tcpm_port *port, int *sink_pdo, 3160 int *src_pdo) 3161 { 3162 unsigned int i, j, max_src_mv = 0, min_src_mv = 0, max_mw = 0, 3163 max_mv = 0, src_mw = 0, src_ma = 0, max_snk_mv = 0, 3164 min_snk_mv = 0; 3165 int ret = -EINVAL; 3166 3167 port->pps_data.supported = false; 3168 port->usb_type = POWER_SUPPLY_USB_TYPE_PD; 3169 power_supply_changed(port->psy); 3170 3171 /* 3172 * Select the source PDO providing the most power which has a 3173 * matchig sink cap. 3174 */ 3175 for (i = 0; i < port->nr_source_caps; i++) { 3176 u32 pdo = port->source_caps[i]; 3177 enum pd_pdo_type type = pdo_type(pdo); 3178 3179 switch (type) { 3180 case PDO_TYPE_FIXED: 3181 max_src_mv = pdo_fixed_voltage(pdo); 3182 min_src_mv = max_src_mv; 3183 break; 3184 case PDO_TYPE_BATT: 3185 case PDO_TYPE_VAR: 3186 max_src_mv = pdo_max_voltage(pdo); 3187 min_src_mv = pdo_min_voltage(pdo); 3188 break; 3189 case PDO_TYPE_APDO: 3190 if (pdo_apdo_type(pdo) == APDO_TYPE_PPS) { 3191 port->pps_data.supported = true; 3192 port->usb_type = 3193 POWER_SUPPLY_USB_TYPE_PD_PPS; 3194 power_supply_changed(port->psy); 3195 } 3196 continue; 3197 default: 3198 tcpm_log(port, "Invalid source PDO type, ignoring"); 3199 continue; 3200 } 3201 3202 switch (type) { 3203 case PDO_TYPE_FIXED: 3204 case PDO_TYPE_VAR: 3205 src_ma = pdo_max_current(pdo); 3206 src_mw = src_ma * min_src_mv / 1000; 3207 break; 3208 case PDO_TYPE_BATT: 3209 src_mw = pdo_max_power(pdo); 3210 break; 3211 case PDO_TYPE_APDO: 3212 continue; 3213 default: 3214 tcpm_log(port, "Invalid source PDO type, ignoring"); 3215 continue; 3216 } 3217 3218 for (j = 0; j < port->nr_snk_pdo; j++) { 3219 pdo = port->snk_pdo[j]; 3220 3221 switch (pdo_type(pdo)) { 3222 case PDO_TYPE_FIXED: 3223 max_snk_mv = pdo_fixed_voltage(pdo); 3224 min_snk_mv = max_snk_mv; 3225 break; 3226 case PDO_TYPE_BATT: 3227 case PDO_TYPE_VAR: 3228 max_snk_mv = pdo_max_voltage(pdo); 3229 min_snk_mv = pdo_min_voltage(pdo); 3230 break; 3231 case PDO_TYPE_APDO: 3232 continue; 3233 default: 3234 tcpm_log(port, "Invalid sink PDO type, ignoring"); 3235 continue; 3236 } 3237 3238 if (max_src_mv <= max_snk_mv && 3239 min_src_mv >= min_snk_mv) { 3240 /* Prefer higher voltages if available */ 3241 if ((src_mw == max_mw && min_src_mv > max_mv) || 3242 src_mw > max_mw) { 3243 *src_pdo = i; 3244 *sink_pdo = j; 3245 max_mw = src_mw; 3246 max_mv = min_src_mv; 3247 ret = 0; 3248 } 3249 } 3250 } 3251 } 3252 3253 return ret; 3254 } 3255 3256 #define min_pps_apdo_current(x, y) \ 3257 min(pdo_pps_apdo_max_current(x), pdo_pps_apdo_max_current(y)) 3258 3259 static unsigned int tcpm_pd_select_pps_apdo(struct tcpm_port *port) 3260 { 3261 unsigned int i, j, max_mw = 0, max_mv = 0; 3262 unsigned int min_src_mv, max_src_mv, src_ma, src_mw; 3263 unsigned int min_snk_mv, max_snk_mv; 3264 unsigned int max_op_mv; 3265 u32 pdo, src, snk; 3266 unsigned int src_pdo = 0, snk_pdo = 0; 3267 3268 /* 3269 * Select the source PPS APDO providing the most power while staying 3270 * within the board's limits. We skip the first PDO as this is always 3271 * 5V 3A. 3272 */ 3273 for (i = 1; i < port->nr_source_caps; ++i) { 3274 pdo = port->source_caps[i]; 3275 3276 switch (pdo_type(pdo)) { 3277 case PDO_TYPE_APDO: 3278 if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) { 3279 tcpm_log(port, "Not PPS APDO (source), ignoring"); 3280 continue; 3281 } 3282 3283 min_src_mv = pdo_pps_apdo_min_voltage(pdo); 3284 max_src_mv = pdo_pps_apdo_max_voltage(pdo); 3285 src_ma = pdo_pps_apdo_max_current(pdo); 3286 src_mw = (src_ma * max_src_mv) / 1000; 3287 3288 /* 3289 * Now search through the sink PDOs to find a matching 3290 * PPS APDO. Again skip the first sink PDO as this will 3291 * always be 5V 3A. 3292 */ 3293 for (j = 1; j < port->nr_snk_pdo; j++) { 3294 pdo = port->snk_pdo[j]; 3295 3296 switch (pdo_type(pdo)) { 3297 case PDO_TYPE_APDO: 3298 if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) { 3299 tcpm_log(port, 3300 "Not PPS APDO (sink), ignoring"); 3301 continue; 3302 } 3303 3304 min_snk_mv = 3305 pdo_pps_apdo_min_voltage(pdo); 3306 max_snk_mv = 3307 pdo_pps_apdo_max_voltage(pdo); 3308 break; 3309 default: 3310 tcpm_log(port, 3311 "Not APDO type (sink), ignoring"); 3312 continue; 3313 } 3314 3315 if (min_src_mv <= max_snk_mv && 3316 max_src_mv >= min_snk_mv) { 3317 max_op_mv = min(max_src_mv, max_snk_mv); 3318 src_mw = (max_op_mv * src_ma) / 1000; 3319 /* Prefer higher voltages if available */ 3320 if ((src_mw == max_mw && 3321 max_op_mv > max_mv) || 3322 src_mw > max_mw) { 3323 src_pdo = i; 3324 snk_pdo = j; 3325 max_mw = src_mw; 3326 max_mv = max_op_mv; 3327 } 3328 } 3329 } 3330 3331 break; 3332 default: 3333 tcpm_log(port, "Not APDO type (source), ignoring"); 3334 continue; 3335 } 3336 } 3337 3338 if (src_pdo) { 3339 src = port->source_caps[src_pdo]; 3340 snk = port->snk_pdo[snk_pdo]; 3341 3342 port->pps_data.req_min_volt = max(pdo_pps_apdo_min_voltage(src), 3343 pdo_pps_apdo_min_voltage(snk)); 3344 port->pps_data.req_max_volt = min(pdo_pps_apdo_max_voltage(src), 3345 pdo_pps_apdo_max_voltage(snk)); 3346 port->pps_data.req_max_curr = min_pps_apdo_current(src, snk); 3347 port->pps_data.req_out_volt = min(port->pps_data.req_max_volt, 3348 max(port->pps_data.req_min_volt, 3349 port->pps_data.req_out_volt)); 3350 port->pps_data.req_op_curr = min(port->pps_data.req_max_curr, 3351 port->pps_data.req_op_curr); 3352 } 3353 3354 return src_pdo; 3355 } 3356 3357 static int tcpm_pd_build_request(struct tcpm_port *port, u32 *rdo) 3358 { 3359 unsigned int mv, ma, mw, flags; 3360 unsigned int max_ma, max_mw; 3361 enum pd_pdo_type type; 3362 u32 pdo, matching_snk_pdo; 3363 int src_pdo_index = 0; 3364 int snk_pdo_index = 0; 3365 int ret; 3366 3367 ret = tcpm_pd_select_pdo(port, &snk_pdo_index, &src_pdo_index); 3368 if (ret < 0) 3369 return ret; 3370 3371 pdo = port->source_caps[src_pdo_index]; 3372 matching_snk_pdo = port->snk_pdo[snk_pdo_index]; 3373 type = pdo_type(pdo); 3374 3375 switch (type) { 3376 case PDO_TYPE_FIXED: 3377 mv = pdo_fixed_voltage(pdo); 3378 break; 3379 case PDO_TYPE_BATT: 3380 case PDO_TYPE_VAR: 3381 mv = pdo_min_voltage(pdo); 3382 break; 3383 default: 3384 tcpm_log(port, "Invalid PDO selected!"); 3385 return -EINVAL; 3386 } 3387 3388 /* Select maximum available current within the sink pdo's limit */ 3389 if (type == PDO_TYPE_BATT) { 3390 mw = min_power(pdo, matching_snk_pdo); 3391 ma = 1000 * mw / mv; 3392 } else { 3393 ma = min_current(pdo, matching_snk_pdo); 3394 mw = ma * mv / 1000; 3395 } 3396 3397 flags = RDO_USB_COMM | RDO_NO_SUSPEND; 3398 3399 /* Set mismatch bit if offered power is less than operating power */ 3400 max_ma = ma; 3401 max_mw = mw; 3402 if (mw < port->operating_snk_mw) { 3403 flags |= RDO_CAP_MISMATCH; 3404 if (type == PDO_TYPE_BATT && 3405 (pdo_max_power(matching_snk_pdo) > pdo_max_power(pdo))) 3406 max_mw = pdo_max_power(matching_snk_pdo); 3407 else if (pdo_max_current(matching_snk_pdo) > 3408 pdo_max_current(pdo)) 3409 max_ma = pdo_max_current(matching_snk_pdo); 3410 } 3411 3412 tcpm_log(port, "cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d", 3413 port->cc_req, port->cc1, port->cc2, port->vbus_source, 3414 port->vconn_role == TYPEC_SOURCE ? "source" : "sink", 3415 port->polarity); 3416 3417 if (type == PDO_TYPE_BATT) { 3418 *rdo = RDO_BATT(src_pdo_index + 1, mw, max_mw, flags); 3419 3420 tcpm_log(port, "Requesting PDO %d: %u mV, %u mW%s", 3421 src_pdo_index, mv, mw, 3422 flags & RDO_CAP_MISMATCH ? " [mismatch]" : ""); 3423 } else { 3424 *rdo = RDO_FIXED(src_pdo_index + 1, ma, max_ma, flags); 3425 3426 tcpm_log(port, "Requesting PDO %d: %u mV, %u mA%s", 3427 src_pdo_index, mv, ma, 3428 flags & RDO_CAP_MISMATCH ? " [mismatch]" : ""); 3429 } 3430 3431 port->req_current_limit = ma; 3432 port->req_supply_voltage = mv; 3433 3434 return 0; 3435 } 3436 3437 static int tcpm_pd_send_request(struct tcpm_port *port) 3438 { 3439 struct pd_message msg; 3440 int ret; 3441 u32 rdo; 3442 3443 ret = tcpm_pd_build_request(port, &rdo); 3444 if (ret < 0) 3445 return ret; 3446 3447 /* 3448 * Relax the threshold as voltage will be adjusted after Accept Message plus tSrcTransition. 3449 * It is safer to modify the threshold here. 3450 */ 3451 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, 0); 3452 3453 memset(&msg, 0, sizeof(msg)); 3454 msg.header = PD_HEADER_LE(PD_DATA_REQUEST, 3455 port->pwr_role, 3456 port->data_role, 3457 port->negotiated_rev, 3458 port->message_id, 1); 3459 msg.payload[0] = cpu_to_le32(rdo); 3460 3461 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 3462 } 3463 3464 static int tcpm_pd_build_pps_request(struct tcpm_port *port, u32 *rdo) 3465 { 3466 unsigned int out_mv, op_ma, op_mw, max_mv, max_ma, flags; 3467 enum pd_pdo_type type; 3468 unsigned int src_pdo_index; 3469 u32 pdo; 3470 3471 src_pdo_index = tcpm_pd_select_pps_apdo(port); 3472 if (!src_pdo_index) 3473 return -EOPNOTSUPP; 3474 3475 pdo = port->source_caps[src_pdo_index]; 3476 type = pdo_type(pdo); 3477 3478 switch (type) { 3479 case PDO_TYPE_APDO: 3480 if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) { 3481 tcpm_log(port, "Invalid APDO selected!"); 3482 return -EINVAL; 3483 } 3484 max_mv = port->pps_data.req_max_volt; 3485 max_ma = port->pps_data.req_max_curr; 3486 out_mv = port->pps_data.req_out_volt; 3487 op_ma = port->pps_data.req_op_curr; 3488 break; 3489 default: 3490 tcpm_log(port, "Invalid PDO selected!"); 3491 return -EINVAL; 3492 } 3493 3494 flags = RDO_USB_COMM | RDO_NO_SUSPEND; 3495 3496 op_mw = (op_ma * out_mv) / 1000; 3497 if (op_mw < port->operating_snk_mw) { 3498 /* 3499 * Try raising current to meet power needs. If that's not enough 3500 * then try upping the voltage. If that's still not enough 3501 * then we've obviously chosen a PPS APDO which really isn't 3502 * suitable so abandon ship. 3503 */ 3504 op_ma = (port->operating_snk_mw * 1000) / out_mv; 3505 if ((port->operating_snk_mw * 1000) % out_mv) 3506 ++op_ma; 3507 op_ma += RDO_PROG_CURR_MA_STEP - (op_ma % RDO_PROG_CURR_MA_STEP); 3508 3509 if (op_ma > max_ma) { 3510 op_ma = max_ma; 3511 out_mv = (port->operating_snk_mw * 1000) / op_ma; 3512 if ((port->operating_snk_mw * 1000) % op_ma) 3513 ++out_mv; 3514 out_mv += RDO_PROG_VOLT_MV_STEP - 3515 (out_mv % RDO_PROG_VOLT_MV_STEP); 3516 3517 if (out_mv > max_mv) { 3518 tcpm_log(port, "Invalid PPS APDO selected!"); 3519 return -EINVAL; 3520 } 3521 } 3522 } 3523 3524 tcpm_log(port, "cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d", 3525 port->cc_req, port->cc1, port->cc2, port->vbus_source, 3526 port->vconn_role == TYPEC_SOURCE ? "source" : "sink", 3527 port->polarity); 3528 3529 *rdo = RDO_PROG(src_pdo_index + 1, out_mv, op_ma, flags); 3530 3531 tcpm_log(port, "Requesting APDO %d: %u mV, %u mA", 3532 src_pdo_index, out_mv, op_ma); 3533 3534 port->pps_data.req_op_curr = op_ma; 3535 port->pps_data.req_out_volt = out_mv; 3536 3537 return 0; 3538 } 3539 3540 static int tcpm_pd_send_pps_request(struct tcpm_port *port) 3541 { 3542 struct pd_message msg; 3543 int ret; 3544 u32 rdo; 3545 3546 ret = tcpm_pd_build_pps_request(port, &rdo); 3547 if (ret < 0) 3548 return ret; 3549 3550 /* Relax the threshold as voltage will be adjusted right after Accept Message. */ 3551 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, 0); 3552 3553 memset(&msg, 0, sizeof(msg)); 3554 msg.header = PD_HEADER_LE(PD_DATA_REQUEST, 3555 port->pwr_role, 3556 port->data_role, 3557 port->negotiated_rev, 3558 port->message_id, 1); 3559 msg.payload[0] = cpu_to_le32(rdo); 3560 3561 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 3562 } 3563 3564 static int tcpm_set_vbus(struct tcpm_port *port, bool enable) 3565 { 3566 int ret; 3567 3568 if (enable && port->vbus_charge) 3569 return -EINVAL; 3570 3571 tcpm_log(port, "vbus:=%d charge=%d", enable, port->vbus_charge); 3572 3573 ret = port->tcpc->set_vbus(port->tcpc, enable, port->vbus_charge); 3574 if (ret < 0) 3575 return ret; 3576 3577 port->vbus_source = enable; 3578 return 0; 3579 } 3580 3581 static int tcpm_set_charge(struct tcpm_port *port, bool charge) 3582 { 3583 int ret; 3584 3585 if (charge && port->vbus_source) 3586 return -EINVAL; 3587 3588 if (charge != port->vbus_charge) { 3589 tcpm_log(port, "vbus=%d charge:=%d", port->vbus_source, charge); 3590 ret = port->tcpc->set_vbus(port->tcpc, port->vbus_source, 3591 charge); 3592 if (ret < 0) 3593 return ret; 3594 } 3595 port->vbus_charge = charge; 3596 power_supply_changed(port->psy); 3597 return 0; 3598 } 3599 3600 static bool tcpm_start_toggling(struct tcpm_port *port, enum typec_cc_status cc) 3601 { 3602 int ret; 3603 3604 if (!port->tcpc->start_toggling) 3605 return false; 3606 3607 tcpm_log_force(port, "Start toggling"); 3608 ret = port->tcpc->start_toggling(port->tcpc, port->port_type, cc); 3609 return ret == 0; 3610 } 3611 3612 static int tcpm_init_vbus(struct tcpm_port *port) 3613 { 3614 int ret; 3615 3616 ret = port->tcpc->set_vbus(port->tcpc, false, false); 3617 port->vbus_source = false; 3618 port->vbus_charge = false; 3619 return ret; 3620 } 3621 3622 static int tcpm_init_vconn(struct tcpm_port *port) 3623 { 3624 int ret; 3625 3626 ret = port->tcpc->set_vconn(port->tcpc, false); 3627 port->vconn_role = TYPEC_SINK; 3628 return ret; 3629 } 3630 3631 static void tcpm_typec_connect(struct tcpm_port *port) 3632 { 3633 if (!port->connected) { 3634 /* Make sure we don't report stale identity information */ 3635 memset(&port->partner_ident, 0, sizeof(port->partner_ident)); 3636 port->partner_desc.usb_pd = port->pd_capable; 3637 if (tcpm_port_is_debug(port)) 3638 port->partner_desc.accessory = TYPEC_ACCESSORY_DEBUG; 3639 else if (tcpm_port_is_audio(port)) 3640 port->partner_desc.accessory = TYPEC_ACCESSORY_AUDIO; 3641 else 3642 port->partner_desc.accessory = TYPEC_ACCESSORY_NONE; 3643 port->partner = typec_register_partner(port->typec_port, 3644 &port->partner_desc); 3645 port->connected = true; 3646 typec_partner_set_usb_power_delivery(port->partner, port->partner_pd); 3647 } 3648 } 3649 3650 static int tcpm_src_attach(struct tcpm_port *port) 3651 { 3652 enum typec_cc_polarity polarity = 3653 port->cc2 == TYPEC_CC_RD ? TYPEC_POLARITY_CC2 3654 : TYPEC_POLARITY_CC1; 3655 int ret; 3656 3657 if (port->attached) 3658 return 0; 3659 3660 ret = tcpm_set_polarity(port, polarity); 3661 if (ret < 0) 3662 return ret; 3663 3664 tcpm_enable_auto_vbus_discharge(port, true); 3665 3666 ret = tcpm_set_roles(port, true, TYPEC_SOURCE, tcpm_data_role_for_source(port)); 3667 if (ret < 0) 3668 return ret; 3669 3670 if (port->pd_supported) { 3671 ret = port->tcpc->set_pd_rx(port->tcpc, true); 3672 if (ret < 0) 3673 goto out_disable_mux; 3674 } 3675 3676 /* 3677 * USB Type-C specification, version 1.2, 3678 * chapter 4.5.2.2.8.1 (Attached.SRC Requirements) 3679 * Enable VCONN only if the non-RD port is set to RA. 3680 */ 3681 if ((polarity == TYPEC_POLARITY_CC1 && port->cc2 == TYPEC_CC_RA) || 3682 (polarity == TYPEC_POLARITY_CC2 && port->cc1 == TYPEC_CC_RA)) { 3683 ret = tcpm_set_vconn(port, true); 3684 if (ret < 0) 3685 goto out_disable_pd; 3686 } 3687 3688 ret = tcpm_set_vbus(port, true); 3689 if (ret < 0) 3690 goto out_disable_vconn; 3691 3692 port->pd_capable = false; 3693 3694 port->partner = NULL; 3695 3696 port->attached = true; 3697 port->send_discover = true; 3698 3699 return 0; 3700 3701 out_disable_vconn: 3702 tcpm_set_vconn(port, false); 3703 out_disable_pd: 3704 if (port->pd_supported) 3705 port->tcpc->set_pd_rx(port->tcpc, false); 3706 out_disable_mux: 3707 tcpm_mux_set(port, TYPEC_STATE_SAFE, USB_ROLE_NONE, 3708 TYPEC_ORIENTATION_NONE); 3709 return ret; 3710 } 3711 3712 static void tcpm_typec_disconnect(struct tcpm_port *port) 3713 { 3714 if (port->connected) { 3715 typec_partner_set_usb_power_delivery(port->partner, NULL); 3716 typec_unregister_partner(port->partner); 3717 port->partner = NULL; 3718 port->connected = false; 3719 } 3720 } 3721 3722 static void tcpm_unregister_altmodes(struct tcpm_port *port) 3723 { 3724 struct pd_mode_data *modep = &port->mode_data; 3725 int i; 3726 3727 for (i = 0; i < modep->altmodes; i++) { 3728 typec_unregister_altmode(port->partner_altmode[i]); 3729 port->partner_altmode[i] = NULL; 3730 } 3731 3732 memset(modep, 0, sizeof(*modep)); 3733 } 3734 3735 static void tcpm_set_partner_usb_comm_capable(struct tcpm_port *port, bool capable) 3736 { 3737 tcpm_log(port, "Setting usb_comm capable %s", capable ? "true" : "false"); 3738 3739 if (port->tcpc->set_partner_usb_comm_capable) 3740 port->tcpc->set_partner_usb_comm_capable(port->tcpc, capable); 3741 } 3742 3743 static void tcpm_reset_port(struct tcpm_port *port) 3744 { 3745 tcpm_enable_auto_vbus_discharge(port, false); 3746 port->in_ams = false; 3747 port->ams = NONE_AMS; 3748 port->vdm_sm_running = false; 3749 tcpm_unregister_altmodes(port); 3750 tcpm_typec_disconnect(port); 3751 port->attached = false; 3752 port->pd_capable = false; 3753 port->pps_data.supported = false; 3754 tcpm_set_partner_usb_comm_capable(port, false); 3755 3756 /* 3757 * First Rx ID should be 0; set this to a sentinel of -1 so that 3758 * we can check tcpm_pd_rx_handler() if we had seen it before. 3759 */ 3760 port->rx_msgid = -1; 3761 3762 port->tcpc->set_pd_rx(port->tcpc, false); 3763 tcpm_init_vbus(port); /* also disables charging */ 3764 tcpm_init_vconn(port); 3765 tcpm_set_current_limit(port, 0, 0); 3766 tcpm_set_polarity(port, TYPEC_POLARITY_CC1); 3767 tcpm_mux_set(port, TYPEC_STATE_SAFE, USB_ROLE_NONE, 3768 TYPEC_ORIENTATION_NONE); 3769 tcpm_set_attached_state(port, false); 3770 port->try_src_count = 0; 3771 port->try_snk_count = 0; 3772 port->usb_type = POWER_SUPPLY_USB_TYPE_C; 3773 power_supply_changed(port->psy); 3774 port->nr_sink_caps = 0; 3775 port->sink_cap_done = false; 3776 if (port->tcpc->enable_frs) 3777 port->tcpc->enable_frs(port->tcpc, false); 3778 3779 usb_power_delivery_unregister_capabilities(port->partner_sink_caps); 3780 port->partner_sink_caps = NULL; 3781 usb_power_delivery_unregister_capabilities(port->partner_source_caps); 3782 port->partner_source_caps = NULL; 3783 usb_power_delivery_unregister(port->partner_pd); 3784 port->partner_pd = NULL; 3785 } 3786 3787 static void tcpm_detach(struct tcpm_port *port) 3788 { 3789 if (tcpm_port_is_disconnected(port)) 3790 port->hard_reset_count = 0; 3791 3792 if (!port->attached) 3793 return; 3794 3795 if (port->tcpc->set_bist_data) { 3796 tcpm_log(port, "disable BIST MODE TESTDATA"); 3797 port->tcpc->set_bist_data(port->tcpc, false); 3798 } 3799 3800 tcpm_reset_port(port); 3801 } 3802 3803 static void tcpm_src_detach(struct tcpm_port *port) 3804 { 3805 tcpm_detach(port); 3806 } 3807 3808 static int tcpm_snk_attach(struct tcpm_port *port) 3809 { 3810 int ret; 3811 3812 if (port->attached) 3813 return 0; 3814 3815 ret = tcpm_set_polarity(port, port->cc2 != TYPEC_CC_OPEN ? 3816 TYPEC_POLARITY_CC2 : TYPEC_POLARITY_CC1); 3817 if (ret < 0) 3818 return ret; 3819 3820 tcpm_enable_auto_vbus_discharge(port, true); 3821 3822 ret = tcpm_set_roles(port, true, TYPEC_SINK, tcpm_data_role_for_sink(port)); 3823 if (ret < 0) 3824 return ret; 3825 3826 port->pd_capable = false; 3827 3828 port->partner = NULL; 3829 3830 port->attached = true; 3831 port->send_discover = true; 3832 3833 return 0; 3834 } 3835 3836 static void tcpm_snk_detach(struct tcpm_port *port) 3837 { 3838 tcpm_detach(port); 3839 } 3840 3841 static int tcpm_acc_attach(struct tcpm_port *port) 3842 { 3843 int ret; 3844 3845 if (port->attached) 3846 return 0; 3847 3848 ret = tcpm_set_roles(port, true, TYPEC_SOURCE, 3849 tcpm_data_role_for_source(port)); 3850 if (ret < 0) 3851 return ret; 3852 3853 port->partner = NULL; 3854 3855 tcpm_typec_connect(port); 3856 3857 port->attached = true; 3858 3859 return 0; 3860 } 3861 3862 static void tcpm_acc_detach(struct tcpm_port *port) 3863 { 3864 tcpm_detach(port); 3865 } 3866 3867 static inline enum tcpm_state hard_reset_state(struct tcpm_port *port) 3868 { 3869 if (port->hard_reset_count < PD_N_HARD_RESET_COUNT) 3870 return HARD_RESET_SEND; 3871 if (port->pd_capable) 3872 return ERROR_RECOVERY; 3873 if (port->pwr_role == TYPEC_SOURCE) 3874 return SRC_UNATTACHED; 3875 if (port->state == SNK_WAIT_CAPABILITIES) 3876 return SNK_READY; 3877 return SNK_UNATTACHED; 3878 } 3879 3880 static inline enum tcpm_state unattached_state(struct tcpm_port *port) 3881 { 3882 if (port->port_type == TYPEC_PORT_DRP) { 3883 if (port->pwr_role == TYPEC_SOURCE) 3884 return SRC_UNATTACHED; 3885 else 3886 return SNK_UNATTACHED; 3887 } else if (port->port_type == TYPEC_PORT_SRC) { 3888 return SRC_UNATTACHED; 3889 } 3890 3891 return SNK_UNATTACHED; 3892 } 3893 3894 static void tcpm_swap_complete(struct tcpm_port *port, int result) 3895 { 3896 if (port->swap_pending) { 3897 port->swap_status = result; 3898 port->swap_pending = false; 3899 port->non_pd_role_swap = false; 3900 complete(&port->swap_complete); 3901 } 3902 } 3903 3904 static enum typec_pwr_opmode tcpm_get_pwr_opmode(enum typec_cc_status cc) 3905 { 3906 switch (cc) { 3907 case TYPEC_CC_RP_1_5: 3908 return TYPEC_PWR_MODE_1_5A; 3909 case TYPEC_CC_RP_3_0: 3910 return TYPEC_PWR_MODE_3_0A; 3911 case TYPEC_CC_RP_DEF: 3912 default: 3913 return TYPEC_PWR_MODE_USB; 3914 } 3915 } 3916 3917 static enum typec_cc_status tcpm_pwr_opmode_to_rp(enum typec_pwr_opmode opmode) 3918 { 3919 switch (opmode) { 3920 case TYPEC_PWR_MODE_USB: 3921 return TYPEC_CC_RP_DEF; 3922 case TYPEC_PWR_MODE_1_5A: 3923 return TYPEC_CC_RP_1_5; 3924 case TYPEC_PWR_MODE_3_0A: 3925 case TYPEC_PWR_MODE_PD: 3926 default: 3927 return TYPEC_CC_RP_3_0; 3928 } 3929 } 3930 3931 static void run_state_machine(struct tcpm_port *port) 3932 { 3933 int ret; 3934 enum typec_pwr_opmode opmode; 3935 unsigned int msecs; 3936 enum tcpm_state upcoming_state; 3937 3938 if (port->tcpc->check_contaminant && port->state != CHECK_CONTAMINANT) 3939 port->potential_contaminant = ((port->enter_state == SRC_ATTACH_WAIT && 3940 port->state == SRC_UNATTACHED) || 3941 (port->enter_state == SNK_ATTACH_WAIT && 3942 port->state == SNK_UNATTACHED)); 3943 3944 port->enter_state = port->state; 3945 switch (port->state) { 3946 case TOGGLING: 3947 break; 3948 case CHECK_CONTAMINANT: 3949 port->tcpc->check_contaminant(port->tcpc); 3950 break; 3951 /* SRC states */ 3952 case SRC_UNATTACHED: 3953 if (!port->non_pd_role_swap) 3954 tcpm_swap_complete(port, -ENOTCONN); 3955 tcpm_src_detach(port); 3956 if (port->potential_contaminant) { 3957 tcpm_set_state(port, CHECK_CONTAMINANT, 0); 3958 break; 3959 } 3960 if (tcpm_start_toggling(port, tcpm_rp_cc(port))) { 3961 tcpm_set_state(port, TOGGLING, 0); 3962 break; 3963 } 3964 tcpm_set_cc(port, tcpm_rp_cc(port)); 3965 if (port->port_type == TYPEC_PORT_DRP) 3966 tcpm_set_state(port, SNK_UNATTACHED, PD_T_DRP_SNK); 3967 break; 3968 case SRC_ATTACH_WAIT: 3969 if (tcpm_port_is_debug(port)) 3970 tcpm_set_state(port, DEBUG_ACC_ATTACHED, 3971 PD_T_CC_DEBOUNCE); 3972 else if (tcpm_port_is_audio(port)) 3973 tcpm_set_state(port, AUDIO_ACC_ATTACHED, 3974 PD_T_CC_DEBOUNCE); 3975 else if (tcpm_port_is_source(port) && port->vbus_vsafe0v) 3976 tcpm_set_state(port, 3977 tcpm_try_snk(port) ? SNK_TRY 3978 : SRC_ATTACHED, 3979 PD_T_CC_DEBOUNCE); 3980 break; 3981 3982 case SNK_TRY: 3983 port->try_snk_count++; 3984 /* 3985 * Requirements: 3986 * - Do not drive vconn or vbus 3987 * - Terminate CC pins (both) to Rd 3988 * Action: 3989 * - Wait for tDRPTry (PD_T_DRP_TRY). 3990 * Until then, ignore any state changes. 3991 */ 3992 tcpm_set_cc(port, TYPEC_CC_RD); 3993 tcpm_set_state(port, SNK_TRY_WAIT, PD_T_DRP_TRY); 3994 break; 3995 case SNK_TRY_WAIT: 3996 if (tcpm_port_is_sink(port)) { 3997 tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE, 0); 3998 } else { 3999 tcpm_set_state(port, SRC_TRYWAIT, 0); 4000 port->max_wait = 0; 4001 } 4002 break; 4003 case SNK_TRY_WAIT_DEBOUNCE: 4004 tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS, 4005 PD_T_TRY_CC_DEBOUNCE); 4006 break; 4007 case SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS: 4008 if (port->vbus_present && tcpm_port_is_sink(port)) 4009 tcpm_set_state(port, SNK_ATTACHED, 0); 4010 else 4011 port->max_wait = 0; 4012 break; 4013 case SRC_TRYWAIT: 4014 tcpm_set_cc(port, tcpm_rp_cc(port)); 4015 if (port->max_wait == 0) { 4016 port->max_wait = jiffies + 4017 msecs_to_jiffies(PD_T_DRP_TRY); 4018 tcpm_set_state(port, SRC_TRYWAIT_UNATTACHED, 4019 PD_T_DRP_TRY); 4020 } else { 4021 if (time_is_after_jiffies(port->max_wait)) 4022 tcpm_set_state(port, SRC_TRYWAIT_UNATTACHED, 4023 jiffies_to_msecs(port->max_wait - 4024 jiffies)); 4025 else 4026 tcpm_set_state(port, SNK_UNATTACHED, 0); 4027 } 4028 break; 4029 case SRC_TRYWAIT_DEBOUNCE: 4030 tcpm_set_state(port, SRC_ATTACHED, PD_T_CC_DEBOUNCE); 4031 break; 4032 case SRC_TRYWAIT_UNATTACHED: 4033 tcpm_set_state(port, SNK_UNATTACHED, 0); 4034 break; 4035 4036 case SRC_ATTACHED: 4037 ret = tcpm_src_attach(port); 4038 tcpm_set_state(port, SRC_UNATTACHED, 4039 ret < 0 ? 0 : PD_T_PS_SOURCE_ON); 4040 break; 4041 case SRC_STARTUP: 4042 opmode = tcpm_get_pwr_opmode(tcpm_rp_cc(port)); 4043 typec_set_pwr_opmode(port->typec_port, opmode); 4044 port->pwr_opmode = TYPEC_PWR_MODE_USB; 4045 port->caps_count = 0; 4046 port->negotiated_rev = PD_MAX_REV; 4047 port->message_id = 0; 4048 port->rx_msgid = -1; 4049 port->explicit_contract = false; 4050 /* SNK -> SRC POWER/FAST_ROLE_SWAP finished */ 4051 if (port->ams == POWER_ROLE_SWAP || 4052 port->ams == FAST_ROLE_SWAP) 4053 tcpm_ams_finish(port); 4054 if (!port->pd_supported) { 4055 tcpm_set_state(port, SRC_READY, 0); 4056 break; 4057 } 4058 port->upcoming_state = SRC_SEND_CAPABILITIES; 4059 tcpm_ams_start(port, POWER_NEGOTIATION); 4060 break; 4061 case SRC_SEND_CAPABILITIES: 4062 port->caps_count++; 4063 if (port->caps_count > PD_N_CAPS_COUNT) { 4064 tcpm_set_state(port, SRC_READY, 0); 4065 break; 4066 } 4067 ret = tcpm_pd_send_source_caps(port); 4068 if (ret < 0) { 4069 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 4070 PD_T_SEND_SOURCE_CAP); 4071 } else { 4072 /* 4073 * Per standard, we should clear the reset counter here. 4074 * However, that can result in state machine hang-ups. 4075 * Reset it only in READY state to improve stability. 4076 */ 4077 /* port->hard_reset_count = 0; */ 4078 port->caps_count = 0; 4079 port->pd_capable = true; 4080 tcpm_set_state_cond(port, SRC_SEND_CAPABILITIES_TIMEOUT, 4081 PD_T_SEND_SOURCE_CAP); 4082 } 4083 break; 4084 case SRC_SEND_CAPABILITIES_TIMEOUT: 4085 /* 4086 * Error recovery for a PD_DATA_SOURCE_CAP reply timeout. 4087 * 4088 * PD 2.0 sinks are supposed to accept src-capabilities with a 4089 * 3.0 header and simply ignore any src PDOs which the sink does 4090 * not understand such as PPS but some 2.0 sinks instead ignore 4091 * the entire PD_DATA_SOURCE_CAP message, causing contract 4092 * negotiation to fail. 4093 * 4094 * After PD_N_HARD_RESET_COUNT hard-reset attempts, we try 4095 * sending src-capabilities with a lower PD revision to 4096 * make these broken sinks work. 4097 */ 4098 if (port->hard_reset_count < PD_N_HARD_RESET_COUNT) { 4099 tcpm_set_state(port, HARD_RESET_SEND, 0); 4100 } else if (port->negotiated_rev > PD_REV20) { 4101 port->negotiated_rev--; 4102 port->hard_reset_count = 0; 4103 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0); 4104 } else { 4105 tcpm_set_state(port, hard_reset_state(port), 0); 4106 } 4107 break; 4108 case SRC_NEGOTIATE_CAPABILITIES: 4109 ret = tcpm_pd_check_request(port); 4110 if (ret < 0) { 4111 tcpm_pd_send_control(port, PD_CTRL_REJECT); 4112 if (!port->explicit_contract) { 4113 tcpm_set_state(port, 4114 SRC_WAIT_NEW_CAPABILITIES, 0); 4115 } else { 4116 tcpm_set_state(port, SRC_READY, 0); 4117 } 4118 } else { 4119 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 4120 tcpm_set_partner_usb_comm_capable(port, 4121 !!(port->sink_request & RDO_USB_COMM)); 4122 tcpm_set_state(port, SRC_TRANSITION_SUPPLY, 4123 PD_T_SRC_TRANSITION); 4124 } 4125 break; 4126 case SRC_TRANSITION_SUPPLY: 4127 /* XXX: regulator_set_voltage(vbus, ...) */ 4128 tcpm_pd_send_control(port, PD_CTRL_PS_RDY); 4129 port->explicit_contract = true; 4130 typec_set_pwr_opmode(port->typec_port, TYPEC_PWR_MODE_PD); 4131 port->pwr_opmode = TYPEC_PWR_MODE_PD; 4132 tcpm_set_state_cond(port, SRC_READY, 0); 4133 break; 4134 case SRC_READY: 4135 #if 1 4136 port->hard_reset_count = 0; 4137 #endif 4138 port->try_src_count = 0; 4139 4140 tcpm_swap_complete(port, 0); 4141 tcpm_typec_connect(port); 4142 4143 if (port->ams != NONE_AMS) 4144 tcpm_ams_finish(port); 4145 if (port->next_ams != NONE_AMS) { 4146 port->ams = port->next_ams; 4147 port->next_ams = NONE_AMS; 4148 } 4149 4150 /* 4151 * If previous AMS is interrupted, switch to the upcoming 4152 * state. 4153 */ 4154 if (port->upcoming_state != INVALID_STATE) { 4155 upcoming_state = port->upcoming_state; 4156 port->upcoming_state = INVALID_STATE; 4157 tcpm_set_state(port, upcoming_state, 0); 4158 break; 4159 } 4160 4161 /* 4162 * 6.4.4.3.1 Discover Identity 4163 * "The Discover Identity Command Shall only be sent to SOP when there is an 4164 * Explicit Contract." 4165 * For now, this driver only supports SOP for DISCOVER_IDENTITY, thus using 4166 * port->explicit_contract to decide whether to send the command. 4167 */ 4168 if (port->explicit_contract) 4169 mod_send_discover_delayed_work(port, 0); 4170 else 4171 port->send_discover = false; 4172 4173 /* 4174 * 6.3.5 4175 * Sending ping messages is not necessary if 4176 * - the source operates at vSafe5V 4177 * or 4178 * - The system is not operating in PD mode 4179 * or 4180 * - Both partners are connected using a Type-C connector 4181 * 4182 * There is no actual need to send PD messages since the local 4183 * port type-c and the spec does not clearly say whether PD is 4184 * possible when type-c is connected to Type-A/B 4185 */ 4186 break; 4187 case SRC_WAIT_NEW_CAPABILITIES: 4188 /* Nothing to do... */ 4189 break; 4190 4191 /* SNK states */ 4192 case SNK_UNATTACHED: 4193 if (!port->non_pd_role_swap) 4194 tcpm_swap_complete(port, -ENOTCONN); 4195 tcpm_pps_complete(port, -ENOTCONN); 4196 tcpm_snk_detach(port); 4197 if (port->potential_contaminant) { 4198 tcpm_set_state(port, CHECK_CONTAMINANT, 0); 4199 break; 4200 } 4201 if (tcpm_start_toggling(port, TYPEC_CC_RD)) { 4202 tcpm_set_state(port, TOGGLING, 0); 4203 break; 4204 } 4205 tcpm_set_cc(port, TYPEC_CC_RD); 4206 if (port->port_type == TYPEC_PORT_DRP) 4207 tcpm_set_state(port, SRC_UNATTACHED, PD_T_DRP_SRC); 4208 break; 4209 case SNK_ATTACH_WAIT: 4210 if ((port->cc1 == TYPEC_CC_OPEN && 4211 port->cc2 != TYPEC_CC_OPEN) || 4212 (port->cc1 != TYPEC_CC_OPEN && 4213 port->cc2 == TYPEC_CC_OPEN)) 4214 tcpm_set_state(port, SNK_DEBOUNCED, 4215 PD_T_CC_DEBOUNCE); 4216 else if (tcpm_port_is_disconnected(port)) 4217 tcpm_set_state(port, SNK_UNATTACHED, 4218 PD_T_PD_DEBOUNCE); 4219 break; 4220 case SNK_DEBOUNCED: 4221 if (tcpm_port_is_disconnected(port)) 4222 tcpm_set_state(port, SNK_UNATTACHED, 4223 PD_T_PD_DEBOUNCE); 4224 else if (port->vbus_present) 4225 tcpm_set_state(port, 4226 tcpm_try_src(port) ? SRC_TRY 4227 : SNK_ATTACHED, 4228 0); 4229 break; 4230 case SRC_TRY: 4231 port->try_src_count++; 4232 tcpm_set_cc(port, tcpm_rp_cc(port)); 4233 port->max_wait = 0; 4234 tcpm_set_state(port, SRC_TRY_WAIT, 0); 4235 break; 4236 case SRC_TRY_WAIT: 4237 if (port->max_wait == 0) { 4238 port->max_wait = jiffies + 4239 msecs_to_jiffies(PD_T_DRP_TRY); 4240 msecs = PD_T_DRP_TRY; 4241 } else { 4242 if (time_is_after_jiffies(port->max_wait)) 4243 msecs = jiffies_to_msecs(port->max_wait - 4244 jiffies); 4245 else 4246 msecs = 0; 4247 } 4248 tcpm_set_state(port, SNK_TRYWAIT, msecs); 4249 break; 4250 case SRC_TRY_DEBOUNCE: 4251 tcpm_set_state(port, SRC_ATTACHED, PD_T_PD_DEBOUNCE); 4252 break; 4253 case SNK_TRYWAIT: 4254 tcpm_set_cc(port, TYPEC_CC_RD); 4255 tcpm_set_state(port, SNK_TRYWAIT_VBUS, PD_T_CC_DEBOUNCE); 4256 break; 4257 case SNK_TRYWAIT_VBUS: 4258 /* 4259 * TCPM stays in this state indefinitely until VBUS 4260 * is detected as long as Rp is not detected for 4261 * more than a time period of tPDDebounce. 4262 */ 4263 if (port->vbus_present && tcpm_port_is_sink(port)) { 4264 tcpm_set_state(port, SNK_ATTACHED, 0); 4265 break; 4266 } 4267 if (!tcpm_port_is_sink(port)) 4268 tcpm_set_state(port, SNK_TRYWAIT_DEBOUNCE, 0); 4269 break; 4270 case SNK_TRYWAIT_DEBOUNCE: 4271 tcpm_set_state(port, SNK_UNATTACHED, PD_T_PD_DEBOUNCE); 4272 break; 4273 case SNK_ATTACHED: 4274 ret = tcpm_snk_attach(port); 4275 if (ret < 0) 4276 tcpm_set_state(port, SNK_UNATTACHED, 0); 4277 else 4278 tcpm_set_state(port, SNK_STARTUP, 0); 4279 break; 4280 case SNK_STARTUP: 4281 opmode = tcpm_get_pwr_opmode(port->polarity ? 4282 port->cc2 : port->cc1); 4283 typec_set_pwr_opmode(port->typec_port, opmode); 4284 port->pwr_opmode = TYPEC_PWR_MODE_USB; 4285 port->negotiated_rev = PD_MAX_REV; 4286 port->message_id = 0; 4287 port->rx_msgid = -1; 4288 port->explicit_contract = false; 4289 4290 if (port->ams == POWER_ROLE_SWAP || 4291 port->ams == FAST_ROLE_SWAP) 4292 /* SRC -> SNK POWER/FAST_ROLE_SWAP finished */ 4293 tcpm_ams_finish(port); 4294 4295 tcpm_set_state(port, SNK_DISCOVERY, 0); 4296 break; 4297 case SNK_DISCOVERY: 4298 if (port->vbus_present) { 4299 u32 current_lim = tcpm_get_current_limit(port); 4300 4301 if (port->slow_charger_loop && (current_lim > PD_P_SNK_STDBY_MW / 5)) 4302 current_lim = PD_P_SNK_STDBY_MW / 5; 4303 tcpm_set_current_limit(port, current_lim, 5000); 4304 tcpm_set_charge(port, true); 4305 if (!port->pd_supported) 4306 tcpm_set_state(port, SNK_READY, 0); 4307 else 4308 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0); 4309 break; 4310 } 4311 /* 4312 * For DRP, timeouts differ. Also, handling is supposed to be 4313 * different and much more complex (dead battery detection; 4314 * see USB power delivery specification, section 8.3.3.6.1.5.1). 4315 */ 4316 tcpm_set_state(port, hard_reset_state(port), 4317 port->port_type == TYPEC_PORT_DRP ? 4318 PD_T_DB_DETECT : PD_T_NO_RESPONSE); 4319 break; 4320 case SNK_DISCOVERY_DEBOUNCE: 4321 tcpm_set_state(port, SNK_DISCOVERY_DEBOUNCE_DONE, 4322 PD_T_CC_DEBOUNCE); 4323 break; 4324 case SNK_DISCOVERY_DEBOUNCE_DONE: 4325 if (!tcpm_port_is_disconnected(port) && 4326 tcpm_port_is_sink(port) && 4327 ktime_after(port->delayed_runtime, ktime_get())) { 4328 tcpm_set_state(port, SNK_DISCOVERY, 4329 ktime_to_ms(ktime_sub(port->delayed_runtime, ktime_get()))); 4330 break; 4331 } 4332 tcpm_set_state(port, unattached_state(port), 0); 4333 break; 4334 case SNK_WAIT_CAPABILITIES: 4335 ret = port->tcpc->set_pd_rx(port->tcpc, true); 4336 if (ret < 0) { 4337 tcpm_set_state(port, SNK_READY, 0); 4338 break; 4339 } 4340 /* 4341 * If VBUS has never been low, and we time out waiting 4342 * for source cap, try a soft reset first, in case we 4343 * were already in a stable contract before this boot. 4344 * Do this only once. 4345 */ 4346 if (port->vbus_never_low) { 4347 port->vbus_never_low = false; 4348 tcpm_set_state(port, SNK_SOFT_RESET, 4349 PD_T_SINK_WAIT_CAP); 4350 } else { 4351 tcpm_set_state(port, hard_reset_state(port), 4352 PD_T_SINK_WAIT_CAP); 4353 } 4354 break; 4355 case SNK_NEGOTIATE_CAPABILITIES: 4356 port->pd_capable = true; 4357 tcpm_set_partner_usb_comm_capable(port, 4358 !!(port->source_caps[0] & PDO_FIXED_USB_COMM)); 4359 port->hard_reset_count = 0; 4360 ret = tcpm_pd_send_request(port); 4361 if (ret < 0) { 4362 /* Restore back to the original state */ 4363 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_PD, 4364 port->pps_data.active, 4365 port->supply_voltage); 4366 /* Let the Source send capabilities again. */ 4367 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0); 4368 } else { 4369 tcpm_set_state_cond(port, hard_reset_state(port), 4370 PD_T_SENDER_RESPONSE); 4371 } 4372 break; 4373 case SNK_NEGOTIATE_PPS_CAPABILITIES: 4374 ret = tcpm_pd_send_pps_request(port); 4375 if (ret < 0) { 4376 /* Restore back to the original state */ 4377 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_PD, 4378 port->pps_data.active, 4379 port->supply_voltage); 4380 port->pps_status = ret; 4381 /* 4382 * If this was called due to updates to sink 4383 * capabilities, and pps is no longer valid, we should 4384 * safely fall back to a standard PDO. 4385 */ 4386 if (port->update_sink_caps) 4387 tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0); 4388 else 4389 tcpm_set_state(port, SNK_READY, 0); 4390 } else { 4391 tcpm_set_state_cond(port, hard_reset_state(port), 4392 PD_T_SENDER_RESPONSE); 4393 } 4394 break; 4395 case SNK_TRANSITION_SINK: 4396 /* From the USB PD spec: 4397 * "The Sink Shall transition to Sink Standby before a positive or 4398 * negative voltage transition of VBUS. During Sink Standby 4399 * the Sink Shall reduce its power draw to pSnkStdby." 4400 * 4401 * This is not applicable to PPS though as the port can continue 4402 * to draw negotiated power without switching to standby. 4403 */ 4404 if (port->supply_voltage != port->req_supply_voltage && !port->pps_data.active && 4405 port->current_limit * port->supply_voltage / 1000 > PD_P_SNK_STDBY_MW) { 4406 u32 stdby_ma = PD_P_SNK_STDBY_MW * 1000 / port->supply_voltage; 4407 4408 tcpm_log(port, "Setting standby current %u mV @ %u mA", 4409 port->supply_voltage, stdby_ma); 4410 tcpm_set_current_limit(port, stdby_ma, port->supply_voltage); 4411 } 4412 fallthrough; 4413 case SNK_TRANSITION_SINK_VBUS: 4414 tcpm_set_state(port, hard_reset_state(port), 4415 PD_T_PS_TRANSITION); 4416 break; 4417 case SNK_READY: 4418 port->try_snk_count = 0; 4419 port->update_sink_caps = false; 4420 if (port->explicit_contract) { 4421 typec_set_pwr_opmode(port->typec_port, 4422 TYPEC_PWR_MODE_PD); 4423 port->pwr_opmode = TYPEC_PWR_MODE_PD; 4424 } 4425 4426 if (!port->pd_capable && port->slow_charger_loop) 4427 tcpm_set_current_limit(port, tcpm_get_current_limit(port), 5000); 4428 tcpm_swap_complete(port, 0); 4429 tcpm_typec_connect(port); 4430 mod_enable_frs_delayed_work(port, 0); 4431 tcpm_pps_complete(port, port->pps_status); 4432 4433 if (port->ams != NONE_AMS) 4434 tcpm_ams_finish(port); 4435 if (port->next_ams != NONE_AMS) { 4436 port->ams = port->next_ams; 4437 port->next_ams = NONE_AMS; 4438 } 4439 4440 /* 4441 * If previous AMS is interrupted, switch to the upcoming 4442 * state. 4443 */ 4444 if (port->upcoming_state != INVALID_STATE) { 4445 upcoming_state = port->upcoming_state; 4446 port->upcoming_state = INVALID_STATE; 4447 tcpm_set_state(port, upcoming_state, 0); 4448 break; 4449 } 4450 4451 /* 4452 * 6.4.4.3.1 Discover Identity 4453 * "The Discover Identity Command Shall only be sent to SOP when there is an 4454 * Explicit Contract." 4455 * For now, this driver only supports SOP for DISCOVER_IDENTITY, thus using 4456 * port->explicit_contract. 4457 */ 4458 if (port->explicit_contract) 4459 mod_send_discover_delayed_work(port, 0); 4460 else 4461 port->send_discover = false; 4462 4463 power_supply_changed(port->psy); 4464 break; 4465 4466 /* Accessory states */ 4467 case ACC_UNATTACHED: 4468 tcpm_acc_detach(port); 4469 tcpm_set_state(port, SRC_UNATTACHED, 0); 4470 break; 4471 case DEBUG_ACC_ATTACHED: 4472 case AUDIO_ACC_ATTACHED: 4473 ret = tcpm_acc_attach(port); 4474 if (ret < 0) 4475 tcpm_set_state(port, ACC_UNATTACHED, 0); 4476 break; 4477 case AUDIO_ACC_DEBOUNCE: 4478 tcpm_set_state(port, ACC_UNATTACHED, PD_T_CC_DEBOUNCE); 4479 break; 4480 4481 /* Hard_Reset states */ 4482 case HARD_RESET_SEND: 4483 if (port->ams != NONE_AMS) 4484 tcpm_ams_finish(port); 4485 /* 4486 * State machine will be directed to HARD_RESET_START, 4487 * thus set upcoming_state to INVALID_STATE. 4488 */ 4489 port->upcoming_state = INVALID_STATE; 4490 tcpm_ams_start(port, HARD_RESET); 4491 break; 4492 case HARD_RESET_START: 4493 port->sink_cap_done = false; 4494 if (port->tcpc->enable_frs) 4495 port->tcpc->enable_frs(port->tcpc, false); 4496 port->hard_reset_count++; 4497 port->tcpc->set_pd_rx(port->tcpc, false); 4498 tcpm_unregister_altmodes(port); 4499 port->nr_sink_caps = 0; 4500 port->send_discover = true; 4501 if (port->pwr_role == TYPEC_SOURCE) 4502 tcpm_set_state(port, SRC_HARD_RESET_VBUS_OFF, 4503 PD_T_PS_HARD_RESET); 4504 else 4505 tcpm_set_state(port, SNK_HARD_RESET_SINK_OFF, 0); 4506 break; 4507 case SRC_HARD_RESET_VBUS_OFF: 4508 /* 4509 * 7.1.5 Response to Hard Resets 4510 * Hard Reset Signaling indicates a communication failure has occurred and the 4511 * Source Shall stop driving VCONN, Shall remove Rp from the VCONN pin and Shall 4512 * drive VBUS to vSafe0V as shown in Figure 7-9. 4513 */ 4514 tcpm_set_vconn(port, false); 4515 tcpm_set_vbus(port, false); 4516 tcpm_set_roles(port, port->self_powered, TYPEC_SOURCE, 4517 tcpm_data_role_for_source(port)); 4518 /* 4519 * If tcpc fails to notify vbus off, TCPM will wait for PD_T_SAFE_0V + 4520 * PD_T_SRC_RECOVER before turning vbus back on. 4521 * From Table 7-12 Sequence Description for a Source Initiated Hard Reset: 4522 * 4. Policy Engine waits tPSHardReset after sending Hard Reset Signaling and then 4523 * tells the Device Policy Manager to instruct the power supply to perform a 4524 * Hard Reset. The transition to vSafe0V Shall occur within tSafe0V (t2). 4525 * 5. After tSrcRecover the Source applies power to VBUS in an attempt to 4526 * re-establish communication with the Sink and resume USB Default Operation. 4527 * The transition to vSafe5V Shall occur within tSrcTurnOn(t4). 4528 */ 4529 tcpm_set_state(port, SRC_HARD_RESET_VBUS_ON, PD_T_SAFE_0V + PD_T_SRC_RECOVER); 4530 break; 4531 case SRC_HARD_RESET_VBUS_ON: 4532 tcpm_set_vconn(port, true); 4533 tcpm_set_vbus(port, true); 4534 if (port->ams == HARD_RESET) 4535 tcpm_ams_finish(port); 4536 if (port->pd_supported) 4537 port->tcpc->set_pd_rx(port->tcpc, true); 4538 tcpm_set_attached_state(port, true); 4539 tcpm_set_state(port, SRC_UNATTACHED, PD_T_PS_SOURCE_ON); 4540 break; 4541 case SNK_HARD_RESET_SINK_OFF: 4542 /* Do not discharge/disconnect during hard reseet */ 4543 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, 0); 4544 memset(&port->pps_data, 0, sizeof(port->pps_data)); 4545 tcpm_set_vconn(port, false); 4546 if (port->pd_capable) 4547 tcpm_set_charge(port, false); 4548 tcpm_set_roles(port, port->self_powered, TYPEC_SINK, 4549 tcpm_data_role_for_sink(port)); 4550 /* 4551 * VBUS may or may not toggle, depending on the adapter. 4552 * If it doesn't toggle, transition to SNK_HARD_RESET_SINK_ON 4553 * directly after timeout. 4554 */ 4555 tcpm_set_state(port, SNK_HARD_RESET_SINK_ON, PD_T_SAFE_0V); 4556 break; 4557 case SNK_HARD_RESET_WAIT_VBUS: 4558 if (port->ams == HARD_RESET) 4559 tcpm_ams_finish(port); 4560 /* Assume we're disconnected if VBUS doesn't come back. */ 4561 tcpm_set_state(port, SNK_UNATTACHED, 4562 PD_T_SRC_RECOVER_MAX + PD_T_SRC_TURN_ON); 4563 break; 4564 case SNK_HARD_RESET_SINK_ON: 4565 /* Note: There is no guarantee that VBUS is on in this state */ 4566 /* 4567 * XXX: 4568 * The specification suggests that dual mode ports in sink 4569 * mode should transition to state PE_SRC_Transition_to_default. 4570 * See USB power delivery specification chapter 8.3.3.6.1.3. 4571 * This would mean to 4572 * - turn off VCONN, reset power supply 4573 * - request hardware reset 4574 * - turn on VCONN 4575 * - Transition to state PE_Src_Startup 4576 * SNK only ports shall transition to state Snk_Startup 4577 * (see chapter 8.3.3.3.8). 4578 * Similar, dual-mode ports in source mode should transition 4579 * to PE_SNK_Transition_to_default. 4580 */ 4581 if (port->pd_capable) { 4582 tcpm_set_current_limit(port, 4583 tcpm_get_current_limit(port), 4584 5000); 4585 tcpm_set_charge(port, true); 4586 } 4587 if (port->ams == HARD_RESET) 4588 tcpm_ams_finish(port); 4589 tcpm_set_attached_state(port, true); 4590 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, VSAFE5V); 4591 tcpm_set_state(port, SNK_STARTUP, 0); 4592 break; 4593 4594 /* Soft_Reset states */ 4595 case SOFT_RESET: 4596 port->message_id = 0; 4597 port->rx_msgid = -1; 4598 /* remove existing capabilities */ 4599 usb_power_delivery_unregister_capabilities(port->partner_source_caps); 4600 port->partner_source_caps = NULL; 4601 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 4602 tcpm_ams_finish(port); 4603 if (port->pwr_role == TYPEC_SOURCE) { 4604 port->upcoming_state = SRC_SEND_CAPABILITIES; 4605 tcpm_ams_start(port, POWER_NEGOTIATION); 4606 } else { 4607 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0); 4608 } 4609 break; 4610 case SRC_SOFT_RESET_WAIT_SNK_TX: 4611 case SNK_SOFT_RESET: 4612 if (port->ams != NONE_AMS) 4613 tcpm_ams_finish(port); 4614 port->upcoming_state = SOFT_RESET_SEND; 4615 tcpm_ams_start(port, SOFT_RESET_AMS); 4616 break; 4617 case SOFT_RESET_SEND: 4618 port->message_id = 0; 4619 port->rx_msgid = -1; 4620 /* remove existing capabilities */ 4621 usb_power_delivery_unregister_capabilities(port->partner_source_caps); 4622 port->partner_source_caps = NULL; 4623 if (tcpm_pd_send_control(port, PD_CTRL_SOFT_RESET)) 4624 tcpm_set_state_cond(port, hard_reset_state(port), 0); 4625 else 4626 tcpm_set_state_cond(port, hard_reset_state(port), 4627 PD_T_SENDER_RESPONSE); 4628 break; 4629 4630 /* DR_Swap states */ 4631 case DR_SWAP_SEND: 4632 tcpm_pd_send_control(port, PD_CTRL_DR_SWAP); 4633 if (port->data_role == TYPEC_DEVICE || port->negotiated_rev > PD_REV20) 4634 port->send_discover = true; 4635 tcpm_set_state_cond(port, DR_SWAP_SEND_TIMEOUT, 4636 PD_T_SENDER_RESPONSE); 4637 break; 4638 case DR_SWAP_ACCEPT: 4639 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 4640 if (port->data_role == TYPEC_DEVICE || port->negotiated_rev > PD_REV20) 4641 port->send_discover = true; 4642 tcpm_set_state_cond(port, DR_SWAP_CHANGE_DR, 0); 4643 break; 4644 case DR_SWAP_SEND_TIMEOUT: 4645 tcpm_swap_complete(port, -ETIMEDOUT); 4646 port->send_discover = false; 4647 tcpm_ams_finish(port); 4648 tcpm_set_state(port, ready_state(port), 0); 4649 break; 4650 case DR_SWAP_CHANGE_DR: 4651 tcpm_unregister_altmodes(port); 4652 if (port->data_role == TYPEC_HOST) 4653 tcpm_set_roles(port, true, port->pwr_role, 4654 TYPEC_DEVICE); 4655 else 4656 tcpm_set_roles(port, true, port->pwr_role, 4657 TYPEC_HOST); 4658 tcpm_ams_finish(port); 4659 tcpm_set_state(port, ready_state(port), 0); 4660 break; 4661 4662 case FR_SWAP_SEND: 4663 if (tcpm_pd_send_control(port, PD_CTRL_FR_SWAP)) { 4664 tcpm_set_state(port, ERROR_RECOVERY, 0); 4665 break; 4666 } 4667 tcpm_set_state_cond(port, FR_SWAP_SEND_TIMEOUT, PD_T_SENDER_RESPONSE); 4668 break; 4669 case FR_SWAP_SEND_TIMEOUT: 4670 tcpm_set_state(port, ERROR_RECOVERY, 0); 4671 break; 4672 case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF: 4673 tcpm_set_state(port, ERROR_RECOVERY, PD_T_PS_SOURCE_OFF); 4674 break; 4675 case FR_SWAP_SNK_SRC_NEW_SINK_READY: 4676 if (port->vbus_source) 4677 tcpm_set_state(port, FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED, 0); 4678 else 4679 tcpm_set_state(port, ERROR_RECOVERY, PD_T_RECEIVER_RESPONSE); 4680 break; 4681 case FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED: 4682 tcpm_set_pwr_role(port, TYPEC_SOURCE); 4683 if (tcpm_pd_send_control(port, PD_CTRL_PS_RDY)) { 4684 tcpm_set_state(port, ERROR_RECOVERY, 0); 4685 break; 4686 } 4687 tcpm_set_cc(port, tcpm_rp_cc(port)); 4688 tcpm_set_state(port, SRC_STARTUP, PD_T_SWAP_SRC_START); 4689 break; 4690 4691 /* PR_Swap states */ 4692 case PR_SWAP_ACCEPT: 4693 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 4694 tcpm_set_state(port, PR_SWAP_START, 0); 4695 break; 4696 case PR_SWAP_SEND: 4697 tcpm_pd_send_control(port, PD_CTRL_PR_SWAP); 4698 tcpm_set_state_cond(port, PR_SWAP_SEND_TIMEOUT, 4699 PD_T_SENDER_RESPONSE); 4700 break; 4701 case PR_SWAP_SEND_TIMEOUT: 4702 tcpm_swap_complete(port, -ETIMEDOUT); 4703 tcpm_set_state(port, ready_state(port), 0); 4704 break; 4705 case PR_SWAP_START: 4706 tcpm_apply_rc(port); 4707 if (port->pwr_role == TYPEC_SOURCE) 4708 tcpm_set_state(port, PR_SWAP_SRC_SNK_TRANSITION_OFF, 4709 PD_T_SRC_TRANSITION); 4710 else 4711 tcpm_set_state(port, PR_SWAP_SNK_SRC_SINK_OFF, 0); 4712 break; 4713 case PR_SWAP_SRC_SNK_TRANSITION_OFF: 4714 /* 4715 * Prevent vbus discharge circuit from turning on during PR_SWAP 4716 * as this is not a disconnect. 4717 */ 4718 tcpm_set_vbus(port, false); 4719 port->explicit_contract = false; 4720 /* allow time for Vbus discharge, must be < tSrcSwapStdby */ 4721 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF, 4722 PD_T_SRCSWAPSTDBY); 4723 break; 4724 case PR_SWAP_SRC_SNK_SOURCE_OFF: 4725 tcpm_set_cc(port, TYPEC_CC_RD); 4726 /* allow CC debounce */ 4727 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED, 4728 PD_T_CC_DEBOUNCE); 4729 break; 4730 case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED: 4731 /* 4732 * USB-PD standard, 6.2.1.4, Port Power Role: 4733 * "During the Power Role Swap Sequence, for the initial Source 4734 * Port, the Port Power Role field shall be set to Sink in the 4735 * PS_RDY Message indicating that the initial Source’s power 4736 * supply is turned off" 4737 */ 4738 tcpm_set_pwr_role(port, TYPEC_SINK); 4739 if (tcpm_pd_send_control(port, PD_CTRL_PS_RDY)) { 4740 tcpm_set_state(port, ERROR_RECOVERY, 0); 4741 break; 4742 } 4743 tcpm_set_state(port, ERROR_RECOVERY, PD_T_PS_SOURCE_ON_PRS); 4744 break; 4745 case PR_SWAP_SRC_SNK_SINK_ON: 4746 tcpm_enable_auto_vbus_discharge(port, true); 4747 /* Set the vbus disconnect threshold for implicit contract */ 4748 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, VSAFE5V); 4749 tcpm_set_state(port, SNK_STARTUP, 0); 4750 break; 4751 case PR_SWAP_SNK_SRC_SINK_OFF: 4752 /* will be source, remove existing capabilities */ 4753 usb_power_delivery_unregister_capabilities(port->partner_source_caps); 4754 port->partner_source_caps = NULL; 4755 /* 4756 * Prevent vbus discharge circuit from turning on during PR_SWAP 4757 * as this is not a disconnect. 4758 */ 4759 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, 4760 port->pps_data.active, 0); 4761 tcpm_set_charge(port, false); 4762 tcpm_set_state(port, hard_reset_state(port), 4763 PD_T_PS_SOURCE_OFF); 4764 break; 4765 case PR_SWAP_SNK_SRC_SOURCE_ON: 4766 tcpm_enable_auto_vbus_discharge(port, true); 4767 tcpm_set_cc(port, tcpm_rp_cc(port)); 4768 tcpm_set_vbus(port, true); 4769 /* 4770 * allow time VBUS ramp-up, must be < tNewSrc 4771 * Also, this window overlaps with CC debounce as well. 4772 * So, Wait for the max of two which is PD_T_NEWSRC 4773 */ 4774 tcpm_set_state(port, PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP, 4775 PD_T_NEWSRC); 4776 break; 4777 case PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP: 4778 /* 4779 * USB PD standard, 6.2.1.4: 4780 * "Subsequent Messages initiated by the Policy Engine, 4781 * such as the PS_RDY Message sent to indicate that Vbus 4782 * is ready, will have the Port Power Role field set to 4783 * Source." 4784 */ 4785 tcpm_set_pwr_role(port, TYPEC_SOURCE); 4786 tcpm_pd_send_control(port, PD_CTRL_PS_RDY); 4787 tcpm_set_state(port, SRC_STARTUP, PD_T_SWAP_SRC_START); 4788 break; 4789 4790 case VCONN_SWAP_ACCEPT: 4791 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 4792 tcpm_ams_finish(port); 4793 tcpm_set_state(port, VCONN_SWAP_START, 0); 4794 break; 4795 case VCONN_SWAP_SEND: 4796 tcpm_pd_send_control(port, PD_CTRL_VCONN_SWAP); 4797 tcpm_set_state(port, VCONN_SWAP_SEND_TIMEOUT, 4798 PD_T_SENDER_RESPONSE); 4799 break; 4800 case VCONN_SWAP_SEND_TIMEOUT: 4801 tcpm_swap_complete(port, -ETIMEDOUT); 4802 tcpm_set_state(port, ready_state(port), 0); 4803 break; 4804 case VCONN_SWAP_START: 4805 if (port->vconn_role == TYPEC_SOURCE) 4806 tcpm_set_state(port, VCONN_SWAP_WAIT_FOR_VCONN, 0); 4807 else 4808 tcpm_set_state(port, VCONN_SWAP_TURN_ON_VCONN, 0); 4809 break; 4810 case VCONN_SWAP_WAIT_FOR_VCONN: 4811 tcpm_set_state(port, hard_reset_state(port), 4812 PD_T_VCONN_SOURCE_ON); 4813 break; 4814 case VCONN_SWAP_TURN_ON_VCONN: 4815 tcpm_set_vconn(port, true); 4816 tcpm_pd_send_control(port, PD_CTRL_PS_RDY); 4817 tcpm_set_state(port, ready_state(port), 0); 4818 break; 4819 case VCONN_SWAP_TURN_OFF_VCONN: 4820 tcpm_set_vconn(port, false); 4821 tcpm_set_state(port, ready_state(port), 0); 4822 break; 4823 4824 case DR_SWAP_CANCEL: 4825 case PR_SWAP_CANCEL: 4826 case VCONN_SWAP_CANCEL: 4827 tcpm_swap_complete(port, port->swap_status); 4828 if (port->pwr_role == TYPEC_SOURCE) 4829 tcpm_set_state(port, SRC_READY, 0); 4830 else 4831 tcpm_set_state(port, SNK_READY, 0); 4832 break; 4833 case FR_SWAP_CANCEL: 4834 if (port->pwr_role == TYPEC_SOURCE) 4835 tcpm_set_state(port, SRC_READY, 0); 4836 else 4837 tcpm_set_state(port, SNK_READY, 0); 4838 break; 4839 4840 case BIST_RX: 4841 switch (BDO_MODE_MASK(port->bist_request)) { 4842 case BDO_MODE_CARRIER2: 4843 tcpm_pd_transmit(port, TCPC_TX_BIST_MODE_2, NULL); 4844 tcpm_set_state(port, unattached_state(port), 4845 PD_T_BIST_CONT_MODE); 4846 break; 4847 case BDO_MODE_TESTDATA: 4848 if (port->tcpc->set_bist_data) { 4849 tcpm_log(port, "Enable BIST MODE TESTDATA"); 4850 port->tcpc->set_bist_data(port->tcpc, true); 4851 } 4852 break; 4853 default: 4854 break; 4855 } 4856 break; 4857 case GET_STATUS_SEND: 4858 tcpm_pd_send_control(port, PD_CTRL_GET_STATUS); 4859 tcpm_set_state(port, GET_STATUS_SEND_TIMEOUT, 4860 PD_T_SENDER_RESPONSE); 4861 break; 4862 case GET_STATUS_SEND_TIMEOUT: 4863 tcpm_set_state(port, ready_state(port), 0); 4864 break; 4865 case GET_PPS_STATUS_SEND: 4866 tcpm_pd_send_control(port, PD_CTRL_GET_PPS_STATUS); 4867 tcpm_set_state(port, GET_PPS_STATUS_SEND_TIMEOUT, 4868 PD_T_SENDER_RESPONSE); 4869 break; 4870 case GET_PPS_STATUS_SEND_TIMEOUT: 4871 tcpm_set_state(port, ready_state(port), 0); 4872 break; 4873 case GET_SINK_CAP: 4874 tcpm_pd_send_control(port, PD_CTRL_GET_SINK_CAP); 4875 tcpm_set_state(port, GET_SINK_CAP_TIMEOUT, PD_T_SENDER_RESPONSE); 4876 break; 4877 case GET_SINK_CAP_TIMEOUT: 4878 port->sink_cap_done = true; 4879 tcpm_set_state(port, ready_state(port), 0); 4880 break; 4881 case ERROR_RECOVERY: 4882 tcpm_swap_complete(port, -EPROTO); 4883 tcpm_pps_complete(port, -EPROTO); 4884 tcpm_set_state(port, PORT_RESET, 0); 4885 break; 4886 case PORT_RESET: 4887 tcpm_reset_port(port); 4888 tcpm_set_cc(port, TYPEC_CC_OPEN); 4889 tcpm_set_state(port, PORT_RESET_WAIT_OFF, 4890 PD_T_ERROR_RECOVERY); 4891 break; 4892 case PORT_RESET_WAIT_OFF: 4893 tcpm_set_state(port, 4894 tcpm_default_state(port), 4895 port->vbus_present ? PD_T_PS_SOURCE_OFF : 0); 4896 break; 4897 4898 /* AMS intermediate state */ 4899 case AMS_START: 4900 if (port->upcoming_state == INVALID_STATE) { 4901 tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ? 4902 SRC_READY : SNK_READY, 0); 4903 break; 4904 } 4905 4906 upcoming_state = port->upcoming_state; 4907 port->upcoming_state = INVALID_STATE; 4908 tcpm_set_state(port, upcoming_state, 0); 4909 break; 4910 4911 /* Chunk state */ 4912 case CHUNK_NOT_SUPP: 4913 tcpm_pd_send_control(port, PD_CTRL_NOT_SUPP); 4914 tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ? SRC_READY : SNK_READY, 0); 4915 break; 4916 default: 4917 WARN(1, "Unexpected port state %d\n", port->state); 4918 break; 4919 } 4920 } 4921 4922 static void tcpm_state_machine_work(struct kthread_work *work) 4923 { 4924 struct tcpm_port *port = container_of(work, struct tcpm_port, state_machine); 4925 enum tcpm_state prev_state; 4926 4927 mutex_lock(&port->lock); 4928 port->state_machine_running = true; 4929 4930 if (port->queued_message && tcpm_send_queued_message(port)) 4931 goto done; 4932 4933 /* If we were queued due to a delayed state change, update it now */ 4934 if (port->delayed_state) { 4935 tcpm_log(port, "state change %s -> %s [delayed %ld ms]", 4936 tcpm_states[port->state], 4937 tcpm_states[port->delayed_state], port->delay_ms); 4938 port->prev_state = port->state; 4939 port->state = port->delayed_state; 4940 port->delayed_state = INVALID_STATE; 4941 } 4942 4943 /* 4944 * Continue running as long as we have (non-delayed) state changes 4945 * to make. 4946 */ 4947 do { 4948 prev_state = port->state; 4949 run_state_machine(port); 4950 if (port->queued_message) 4951 tcpm_send_queued_message(port); 4952 } while (port->state != prev_state && !port->delayed_state); 4953 4954 done: 4955 port->state_machine_running = false; 4956 mutex_unlock(&port->lock); 4957 } 4958 4959 static void _tcpm_cc_change(struct tcpm_port *port, enum typec_cc_status cc1, 4960 enum typec_cc_status cc2) 4961 { 4962 enum typec_cc_status old_cc1, old_cc2; 4963 enum tcpm_state new_state; 4964 4965 old_cc1 = port->cc1; 4966 old_cc2 = port->cc2; 4967 port->cc1 = cc1; 4968 port->cc2 = cc2; 4969 4970 tcpm_log_force(port, 4971 "CC1: %u -> %u, CC2: %u -> %u [state %s, polarity %d, %s]", 4972 old_cc1, cc1, old_cc2, cc2, tcpm_states[port->state], 4973 port->polarity, 4974 tcpm_port_is_disconnected(port) ? "disconnected" 4975 : "connected"); 4976 4977 switch (port->state) { 4978 case TOGGLING: 4979 if (tcpm_port_is_debug(port) || tcpm_port_is_audio(port) || 4980 tcpm_port_is_source(port)) 4981 tcpm_set_state(port, SRC_ATTACH_WAIT, 0); 4982 else if (tcpm_port_is_sink(port)) 4983 tcpm_set_state(port, SNK_ATTACH_WAIT, 0); 4984 break; 4985 case CHECK_CONTAMINANT: 4986 /* Wait for Toggling to be resumed */ 4987 break; 4988 case SRC_UNATTACHED: 4989 case ACC_UNATTACHED: 4990 if (tcpm_port_is_debug(port) || tcpm_port_is_audio(port) || 4991 tcpm_port_is_source(port)) 4992 tcpm_set_state(port, SRC_ATTACH_WAIT, 0); 4993 break; 4994 case SRC_ATTACH_WAIT: 4995 if (tcpm_port_is_disconnected(port) || 4996 tcpm_port_is_audio_detached(port)) 4997 tcpm_set_state(port, SRC_UNATTACHED, 0); 4998 else if (cc1 != old_cc1 || cc2 != old_cc2) 4999 tcpm_set_state(port, SRC_ATTACH_WAIT, 0); 5000 break; 5001 case SRC_ATTACHED: 5002 case SRC_STARTUP: 5003 case SRC_SEND_CAPABILITIES: 5004 case SRC_READY: 5005 if (tcpm_port_is_disconnected(port) || 5006 !tcpm_port_is_source(port)) { 5007 if (port->port_type == TYPEC_PORT_SRC) 5008 tcpm_set_state(port, SRC_UNATTACHED, tcpm_wait_for_discharge(port)); 5009 else 5010 tcpm_set_state(port, SNK_UNATTACHED, tcpm_wait_for_discharge(port)); 5011 } 5012 break; 5013 case SNK_UNATTACHED: 5014 if (tcpm_port_is_sink(port)) 5015 tcpm_set_state(port, SNK_ATTACH_WAIT, 0); 5016 break; 5017 case SNK_ATTACH_WAIT: 5018 if ((port->cc1 == TYPEC_CC_OPEN && 5019 port->cc2 != TYPEC_CC_OPEN) || 5020 (port->cc1 != TYPEC_CC_OPEN && 5021 port->cc2 == TYPEC_CC_OPEN)) 5022 new_state = SNK_DEBOUNCED; 5023 else if (tcpm_port_is_disconnected(port)) 5024 new_state = SNK_UNATTACHED; 5025 else 5026 break; 5027 if (new_state != port->delayed_state) 5028 tcpm_set_state(port, SNK_ATTACH_WAIT, 0); 5029 break; 5030 case SNK_DEBOUNCED: 5031 if (tcpm_port_is_disconnected(port)) 5032 new_state = SNK_UNATTACHED; 5033 else if (port->vbus_present) 5034 new_state = tcpm_try_src(port) ? SRC_TRY : SNK_ATTACHED; 5035 else 5036 new_state = SNK_UNATTACHED; 5037 if (new_state != port->delayed_state) 5038 tcpm_set_state(port, SNK_DEBOUNCED, 0); 5039 break; 5040 case SNK_READY: 5041 /* 5042 * EXIT condition is based primarily on vbus disconnect and CC is secondary. 5043 * "A port that has entered into USB PD communications with the Source and 5044 * has seen the CC voltage exceed vRd-USB may monitor the CC pin to detect 5045 * cable disconnect in addition to monitoring VBUS. 5046 * 5047 * A port that is monitoring the CC voltage for disconnect (but is not in 5048 * the process of a USB PD PR_Swap or USB PD FR_Swap) shall transition to 5049 * Unattached.SNK within tSinkDisconnect after the CC voltage remains below 5050 * vRd-USB for tPDDebounce." 5051 * 5052 * When set_auto_vbus_discharge_threshold is enabled, CC pins go 5053 * away before vbus decays to disconnect threshold. Allow 5054 * disconnect to be driven by vbus disconnect when auto vbus 5055 * discharge is enabled. 5056 */ 5057 if (!port->auto_vbus_discharge_enabled && tcpm_port_is_disconnected(port)) 5058 tcpm_set_state(port, unattached_state(port), 0); 5059 else if (!port->pd_capable && 5060 (cc1 != old_cc1 || cc2 != old_cc2)) 5061 tcpm_set_current_limit(port, 5062 tcpm_get_current_limit(port), 5063 5000); 5064 break; 5065 5066 case AUDIO_ACC_ATTACHED: 5067 if (cc1 == TYPEC_CC_OPEN || cc2 == TYPEC_CC_OPEN) 5068 tcpm_set_state(port, AUDIO_ACC_DEBOUNCE, 0); 5069 break; 5070 case AUDIO_ACC_DEBOUNCE: 5071 if (tcpm_port_is_audio(port)) 5072 tcpm_set_state(port, AUDIO_ACC_ATTACHED, 0); 5073 break; 5074 5075 case DEBUG_ACC_ATTACHED: 5076 if (cc1 == TYPEC_CC_OPEN || cc2 == TYPEC_CC_OPEN) 5077 tcpm_set_state(port, ACC_UNATTACHED, 0); 5078 break; 5079 5080 case SNK_TRY: 5081 /* Do nothing, waiting for timeout */ 5082 break; 5083 5084 case SNK_DISCOVERY: 5085 /* CC line is unstable, wait for debounce */ 5086 if (tcpm_port_is_disconnected(port)) 5087 tcpm_set_state(port, SNK_DISCOVERY_DEBOUNCE, 0); 5088 break; 5089 case SNK_DISCOVERY_DEBOUNCE: 5090 break; 5091 5092 case SRC_TRYWAIT: 5093 /* Hand over to state machine if needed */ 5094 if (!port->vbus_present && tcpm_port_is_source(port)) 5095 tcpm_set_state(port, SRC_TRYWAIT_DEBOUNCE, 0); 5096 break; 5097 case SRC_TRYWAIT_DEBOUNCE: 5098 if (port->vbus_present || !tcpm_port_is_source(port)) 5099 tcpm_set_state(port, SRC_TRYWAIT, 0); 5100 break; 5101 case SNK_TRY_WAIT_DEBOUNCE: 5102 if (!tcpm_port_is_sink(port)) { 5103 port->max_wait = 0; 5104 tcpm_set_state(port, SRC_TRYWAIT, 0); 5105 } 5106 break; 5107 case SRC_TRY_WAIT: 5108 if (tcpm_port_is_source(port)) 5109 tcpm_set_state(port, SRC_TRY_DEBOUNCE, 0); 5110 break; 5111 case SRC_TRY_DEBOUNCE: 5112 tcpm_set_state(port, SRC_TRY_WAIT, 0); 5113 break; 5114 case SNK_TRYWAIT_DEBOUNCE: 5115 if (tcpm_port_is_sink(port)) 5116 tcpm_set_state(port, SNK_TRYWAIT_VBUS, 0); 5117 break; 5118 case SNK_TRYWAIT_VBUS: 5119 if (!tcpm_port_is_sink(port)) 5120 tcpm_set_state(port, SNK_TRYWAIT_DEBOUNCE, 0); 5121 break; 5122 case SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS: 5123 if (!tcpm_port_is_sink(port)) 5124 tcpm_set_state(port, SRC_TRYWAIT, PD_T_TRY_CC_DEBOUNCE); 5125 else 5126 tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS, 0); 5127 break; 5128 case SNK_TRYWAIT: 5129 /* Do nothing, waiting for tCCDebounce */ 5130 break; 5131 case PR_SWAP_SNK_SRC_SINK_OFF: 5132 case PR_SWAP_SRC_SNK_TRANSITION_OFF: 5133 case PR_SWAP_SRC_SNK_SOURCE_OFF: 5134 case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED: 5135 case PR_SWAP_SNK_SRC_SOURCE_ON: 5136 /* 5137 * CC state change is expected in PR_SWAP 5138 * Ignore it. 5139 */ 5140 break; 5141 case FR_SWAP_SEND: 5142 case FR_SWAP_SEND_TIMEOUT: 5143 case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF: 5144 case FR_SWAP_SNK_SRC_NEW_SINK_READY: 5145 case FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED: 5146 /* Do nothing, CC change expected */ 5147 break; 5148 5149 case PORT_RESET: 5150 case PORT_RESET_WAIT_OFF: 5151 /* 5152 * State set back to default mode once the timer completes. 5153 * Ignore CC changes here. 5154 */ 5155 break; 5156 default: 5157 /* 5158 * While acting as sink and auto vbus discharge is enabled, Allow disconnect 5159 * to be driven by vbus disconnect. 5160 */ 5161 if (tcpm_port_is_disconnected(port) && !(port->pwr_role == TYPEC_SINK && 5162 port->auto_vbus_discharge_enabled)) 5163 tcpm_set_state(port, unattached_state(port), 0); 5164 break; 5165 } 5166 } 5167 5168 static void _tcpm_pd_vbus_on(struct tcpm_port *port) 5169 { 5170 tcpm_log_force(port, "VBUS on"); 5171 port->vbus_present = true; 5172 /* 5173 * When vbus_present is true i.e. Voltage at VBUS is greater than VSAFE5V implicitly 5174 * states that vbus is not at VSAFE0V, hence clear the vbus_vsafe0v flag here. 5175 */ 5176 port->vbus_vsafe0v = false; 5177 5178 switch (port->state) { 5179 case SNK_TRANSITION_SINK_VBUS: 5180 port->explicit_contract = true; 5181 tcpm_set_state(port, SNK_READY, 0); 5182 break; 5183 case SNK_DISCOVERY: 5184 tcpm_set_state(port, SNK_DISCOVERY, 0); 5185 break; 5186 5187 case SNK_DEBOUNCED: 5188 tcpm_set_state(port, tcpm_try_src(port) ? SRC_TRY 5189 : SNK_ATTACHED, 5190 0); 5191 break; 5192 case SNK_HARD_RESET_WAIT_VBUS: 5193 tcpm_set_state(port, SNK_HARD_RESET_SINK_ON, 0); 5194 break; 5195 case SRC_ATTACHED: 5196 tcpm_set_state(port, SRC_STARTUP, 0); 5197 break; 5198 case SRC_HARD_RESET_VBUS_ON: 5199 tcpm_set_state(port, SRC_STARTUP, 0); 5200 break; 5201 5202 case SNK_TRY: 5203 /* Do nothing, waiting for timeout */ 5204 break; 5205 case SRC_TRYWAIT: 5206 /* Do nothing, Waiting for Rd to be detected */ 5207 break; 5208 case SRC_TRYWAIT_DEBOUNCE: 5209 tcpm_set_state(port, SRC_TRYWAIT, 0); 5210 break; 5211 case SNK_TRY_WAIT_DEBOUNCE: 5212 /* Do nothing, waiting for PD_DEBOUNCE to do be done */ 5213 break; 5214 case SNK_TRYWAIT: 5215 /* Do nothing, waiting for tCCDebounce */ 5216 break; 5217 case SNK_TRYWAIT_VBUS: 5218 if (tcpm_port_is_sink(port)) 5219 tcpm_set_state(port, SNK_ATTACHED, 0); 5220 break; 5221 case SNK_TRYWAIT_DEBOUNCE: 5222 /* Do nothing, waiting for Rp */ 5223 break; 5224 case SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS: 5225 if (port->vbus_present && tcpm_port_is_sink(port)) 5226 tcpm_set_state(port, SNK_ATTACHED, 0); 5227 break; 5228 case SRC_TRY_WAIT: 5229 case SRC_TRY_DEBOUNCE: 5230 /* Do nothing, waiting for sink detection */ 5231 break; 5232 case FR_SWAP_SEND: 5233 case FR_SWAP_SEND_TIMEOUT: 5234 case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF: 5235 case FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED: 5236 if (port->tcpc->frs_sourcing_vbus) 5237 port->tcpc->frs_sourcing_vbus(port->tcpc); 5238 break; 5239 case FR_SWAP_SNK_SRC_NEW_SINK_READY: 5240 if (port->tcpc->frs_sourcing_vbus) 5241 port->tcpc->frs_sourcing_vbus(port->tcpc); 5242 tcpm_set_state(port, FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED, 0); 5243 break; 5244 5245 case PORT_RESET: 5246 case PORT_RESET_WAIT_OFF: 5247 /* 5248 * State set back to default mode once the timer completes. 5249 * Ignore vbus changes here. 5250 */ 5251 break; 5252 5253 default: 5254 break; 5255 } 5256 } 5257 5258 static void _tcpm_pd_vbus_off(struct tcpm_port *port) 5259 { 5260 tcpm_log_force(port, "VBUS off"); 5261 port->vbus_present = false; 5262 port->vbus_never_low = false; 5263 switch (port->state) { 5264 case SNK_HARD_RESET_SINK_OFF: 5265 tcpm_set_state(port, SNK_HARD_RESET_WAIT_VBUS, 0); 5266 break; 5267 case HARD_RESET_SEND: 5268 break; 5269 case SNK_TRY: 5270 /* Do nothing, waiting for timeout */ 5271 break; 5272 case SRC_TRYWAIT: 5273 /* Hand over to state machine if needed */ 5274 if (tcpm_port_is_source(port)) 5275 tcpm_set_state(port, SRC_TRYWAIT_DEBOUNCE, 0); 5276 break; 5277 case SNK_TRY_WAIT_DEBOUNCE: 5278 /* Do nothing, waiting for PD_DEBOUNCE to do be done */ 5279 break; 5280 case SNK_TRYWAIT: 5281 case SNK_TRYWAIT_VBUS: 5282 case SNK_TRYWAIT_DEBOUNCE: 5283 break; 5284 case SNK_ATTACH_WAIT: 5285 case SNK_DEBOUNCED: 5286 /* Do nothing, as TCPM is still waiting for vbus to reaach VSAFE5V to connect */ 5287 break; 5288 5289 case SNK_NEGOTIATE_CAPABILITIES: 5290 break; 5291 5292 case PR_SWAP_SRC_SNK_TRANSITION_OFF: 5293 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF, 0); 5294 break; 5295 5296 case PR_SWAP_SNK_SRC_SINK_OFF: 5297 /* Do nothing, expected */ 5298 break; 5299 5300 case PR_SWAP_SNK_SRC_SOURCE_ON: 5301 /* 5302 * Do nothing when vbus off notification is received. 5303 * TCPM can wait for PD_T_NEWSRC in PR_SWAP_SNK_SRC_SOURCE_ON 5304 * for the vbus source to ramp up. 5305 */ 5306 break; 5307 5308 case PORT_RESET_WAIT_OFF: 5309 tcpm_set_state(port, tcpm_default_state(port), 0); 5310 break; 5311 5312 case SRC_TRY_WAIT: 5313 case SRC_TRY_DEBOUNCE: 5314 /* Do nothing, waiting for sink detection */ 5315 break; 5316 5317 case SRC_STARTUP: 5318 case SRC_SEND_CAPABILITIES: 5319 case SRC_SEND_CAPABILITIES_TIMEOUT: 5320 case SRC_NEGOTIATE_CAPABILITIES: 5321 case SRC_TRANSITION_SUPPLY: 5322 case SRC_READY: 5323 case SRC_WAIT_NEW_CAPABILITIES: 5324 /* 5325 * Force to unattached state to re-initiate connection. 5326 * DRP port should move to Unattached.SNK instead of Unattached.SRC if 5327 * sink removed. Although sink removal here is due to source's vbus collapse, 5328 * treat it the same way for consistency. 5329 */ 5330 if (port->port_type == TYPEC_PORT_SRC) 5331 tcpm_set_state(port, SRC_UNATTACHED, tcpm_wait_for_discharge(port)); 5332 else 5333 tcpm_set_state(port, SNK_UNATTACHED, tcpm_wait_for_discharge(port)); 5334 break; 5335 5336 case PORT_RESET: 5337 /* 5338 * State set back to default mode once the timer completes. 5339 * Ignore vbus changes here. 5340 */ 5341 break; 5342 5343 case FR_SWAP_SEND: 5344 case FR_SWAP_SEND_TIMEOUT: 5345 case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF: 5346 case FR_SWAP_SNK_SRC_NEW_SINK_READY: 5347 case FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED: 5348 /* Do nothing, vbus drop expected */ 5349 break; 5350 5351 default: 5352 if (port->pwr_role == TYPEC_SINK && port->attached) 5353 tcpm_set_state(port, SNK_UNATTACHED, tcpm_wait_for_discharge(port)); 5354 break; 5355 } 5356 } 5357 5358 static void _tcpm_pd_vbus_vsafe0v(struct tcpm_port *port) 5359 { 5360 tcpm_log_force(port, "VBUS VSAFE0V"); 5361 port->vbus_vsafe0v = true; 5362 switch (port->state) { 5363 case SRC_HARD_RESET_VBUS_OFF: 5364 /* 5365 * After establishing the vSafe0V voltage condition on VBUS, the Source Shall wait 5366 * tSrcRecover before re-applying VCONN and restoring VBUS to vSafe5V. 5367 */ 5368 tcpm_set_state(port, SRC_HARD_RESET_VBUS_ON, PD_T_SRC_RECOVER); 5369 break; 5370 case SRC_ATTACH_WAIT: 5371 if (tcpm_port_is_source(port)) 5372 tcpm_set_state(port, tcpm_try_snk(port) ? SNK_TRY : SRC_ATTACHED, 5373 PD_T_CC_DEBOUNCE); 5374 break; 5375 case SRC_STARTUP: 5376 case SRC_SEND_CAPABILITIES: 5377 case SRC_SEND_CAPABILITIES_TIMEOUT: 5378 case SRC_NEGOTIATE_CAPABILITIES: 5379 case SRC_TRANSITION_SUPPLY: 5380 case SRC_READY: 5381 case SRC_WAIT_NEW_CAPABILITIES: 5382 if (port->auto_vbus_discharge_enabled) { 5383 if (port->port_type == TYPEC_PORT_SRC) 5384 tcpm_set_state(port, SRC_UNATTACHED, 0); 5385 else 5386 tcpm_set_state(port, SNK_UNATTACHED, 0); 5387 } 5388 break; 5389 case PR_SWAP_SNK_SRC_SINK_OFF: 5390 case PR_SWAP_SNK_SRC_SOURCE_ON: 5391 /* Do nothing, vsafe0v is expected during transition */ 5392 break; 5393 case SNK_ATTACH_WAIT: 5394 case SNK_DEBOUNCED: 5395 /*Do nothing, still waiting for VSAFE5V for connect */ 5396 break; 5397 default: 5398 if (port->pwr_role == TYPEC_SINK && port->auto_vbus_discharge_enabled) 5399 tcpm_set_state(port, SNK_UNATTACHED, 0); 5400 break; 5401 } 5402 } 5403 5404 static void _tcpm_pd_hard_reset(struct tcpm_port *port) 5405 { 5406 tcpm_log_force(port, "Received hard reset"); 5407 if (port->bist_request == BDO_MODE_TESTDATA && port->tcpc->set_bist_data) 5408 port->tcpc->set_bist_data(port->tcpc, false); 5409 5410 if (port->ams != NONE_AMS) 5411 port->ams = NONE_AMS; 5412 if (port->hard_reset_count < PD_N_HARD_RESET_COUNT) 5413 port->ams = HARD_RESET; 5414 /* 5415 * If we keep receiving hard reset requests, executing the hard reset 5416 * must have failed. Revert to error recovery if that happens. 5417 */ 5418 tcpm_set_state(port, 5419 port->hard_reset_count < PD_N_HARD_RESET_COUNT ? 5420 HARD_RESET_START : ERROR_RECOVERY, 5421 0); 5422 } 5423 5424 static void tcpm_pd_event_handler(struct kthread_work *work) 5425 { 5426 struct tcpm_port *port = container_of(work, struct tcpm_port, 5427 event_work); 5428 u32 events; 5429 5430 mutex_lock(&port->lock); 5431 5432 spin_lock(&port->pd_event_lock); 5433 while (port->pd_events) { 5434 events = port->pd_events; 5435 port->pd_events = 0; 5436 spin_unlock(&port->pd_event_lock); 5437 if (events & TCPM_RESET_EVENT) 5438 _tcpm_pd_hard_reset(port); 5439 if (events & TCPM_VBUS_EVENT) { 5440 bool vbus; 5441 5442 vbus = port->tcpc->get_vbus(port->tcpc); 5443 if (vbus) { 5444 _tcpm_pd_vbus_on(port); 5445 } else { 5446 _tcpm_pd_vbus_off(port); 5447 /* 5448 * When TCPC does not support detecting vsafe0v voltage level, 5449 * treat vbus absent as vsafe0v. Else invoke is_vbus_vsafe0v 5450 * to see if vbus has discharge to VSAFE0V. 5451 */ 5452 if (!port->tcpc->is_vbus_vsafe0v || 5453 port->tcpc->is_vbus_vsafe0v(port->tcpc)) 5454 _tcpm_pd_vbus_vsafe0v(port); 5455 } 5456 } 5457 if (events & TCPM_CC_EVENT) { 5458 enum typec_cc_status cc1, cc2; 5459 5460 if (port->tcpc->get_cc(port->tcpc, &cc1, &cc2) == 0) 5461 _tcpm_cc_change(port, cc1, cc2); 5462 } 5463 if (events & TCPM_FRS_EVENT) { 5464 if (port->state == SNK_READY) { 5465 int ret; 5466 5467 port->upcoming_state = FR_SWAP_SEND; 5468 ret = tcpm_ams_start(port, FAST_ROLE_SWAP); 5469 if (ret == -EAGAIN) 5470 port->upcoming_state = INVALID_STATE; 5471 } else { 5472 tcpm_log(port, "Discarding FRS_SIGNAL! Not in sink ready"); 5473 } 5474 } 5475 if (events & TCPM_SOURCING_VBUS) { 5476 tcpm_log(port, "sourcing vbus"); 5477 /* 5478 * In fast role swap case TCPC autonomously sources vbus. Set vbus_source 5479 * true as TCPM wouldn't have called tcpm_set_vbus. 5480 * 5481 * When vbus is sourced on the command on TCPM i.e. TCPM called 5482 * tcpm_set_vbus to source vbus, vbus_source would already be true. 5483 */ 5484 port->vbus_source = true; 5485 _tcpm_pd_vbus_on(port); 5486 } 5487 if (events & TCPM_PORT_CLEAN) { 5488 tcpm_log(port, "port clean"); 5489 if (port->state == CHECK_CONTAMINANT) { 5490 if (tcpm_start_toggling(port, tcpm_rp_cc(port))) 5491 tcpm_set_state(port, TOGGLING, 0); 5492 else 5493 tcpm_set_state(port, tcpm_default_state(port), 0); 5494 } 5495 } 5496 5497 spin_lock(&port->pd_event_lock); 5498 } 5499 spin_unlock(&port->pd_event_lock); 5500 mutex_unlock(&port->lock); 5501 } 5502 5503 void tcpm_cc_change(struct tcpm_port *port) 5504 { 5505 spin_lock(&port->pd_event_lock); 5506 port->pd_events |= TCPM_CC_EVENT; 5507 spin_unlock(&port->pd_event_lock); 5508 kthread_queue_work(port->wq, &port->event_work); 5509 } 5510 EXPORT_SYMBOL_GPL(tcpm_cc_change); 5511 5512 void tcpm_vbus_change(struct tcpm_port *port) 5513 { 5514 spin_lock(&port->pd_event_lock); 5515 port->pd_events |= TCPM_VBUS_EVENT; 5516 spin_unlock(&port->pd_event_lock); 5517 kthread_queue_work(port->wq, &port->event_work); 5518 } 5519 EXPORT_SYMBOL_GPL(tcpm_vbus_change); 5520 5521 void tcpm_pd_hard_reset(struct tcpm_port *port) 5522 { 5523 spin_lock(&port->pd_event_lock); 5524 port->pd_events = TCPM_RESET_EVENT; 5525 spin_unlock(&port->pd_event_lock); 5526 kthread_queue_work(port->wq, &port->event_work); 5527 } 5528 EXPORT_SYMBOL_GPL(tcpm_pd_hard_reset); 5529 5530 void tcpm_sink_frs(struct tcpm_port *port) 5531 { 5532 spin_lock(&port->pd_event_lock); 5533 port->pd_events |= TCPM_FRS_EVENT; 5534 spin_unlock(&port->pd_event_lock); 5535 kthread_queue_work(port->wq, &port->event_work); 5536 } 5537 EXPORT_SYMBOL_GPL(tcpm_sink_frs); 5538 5539 void tcpm_sourcing_vbus(struct tcpm_port *port) 5540 { 5541 spin_lock(&port->pd_event_lock); 5542 port->pd_events |= TCPM_SOURCING_VBUS; 5543 spin_unlock(&port->pd_event_lock); 5544 kthread_queue_work(port->wq, &port->event_work); 5545 } 5546 EXPORT_SYMBOL_GPL(tcpm_sourcing_vbus); 5547 5548 void tcpm_port_clean(struct tcpm_port *port) 5549 { 5550 spin_lock(&port->pd_event_lock); 5551 port->pd_events |= TCPM_PORT_CLEAN; 5552 spin_unlock(&port->pd_event_lock); 5553 kthread_queue_work(port->wq, &port->event_work); 5554 } 5555 EXPORT_SYMBOL_GPL(tcpm_port_clean); 5556 5557 bool tcpm_port_is_toggling(struct tcpm_port *port) 5558 { 5559 return port->port_type == TYPEC_PORT_DRP && port->state == TOGGLING; 5560 } 5561 EXPORT_SYMBOL_GPL(tcpm_port_is_toggling); 5562 5563 static void tcpm_enable_frs_work(struct kthread_work *work) 5564 { 5565 struct tcpm_port *port = container_of(work, struct tcpm_port, enable_frs); 5566 int ret; 5567 5568 mutex_lock(&port->lock); 5569 /* Not FRS capable */ 5570 if (!port->connected || port->port_type != TYPEC_PORT_DRP || 5571 port->pwr_opmode != TYPEC_PWR_MODE_PD || 5572 !port->tcpc->enable_frs || 5573 /* Sink caps queried */ 5574 port->sink_cap_done || port->negotiated_rev < PD_REV30) 5575 goto unlock; 5576 5577 /* Send when the state machine is idle */ 5578 if (port->state != SNK_READY || port->vdm_sm_running || port->send_discover) 5579 goto resched; 5580 5581 port->upcoming_state = GET_SINK_CAP; 5582 ret = tcpm_ams_start(port, GET_SINK_CAPABILITIES); 5583 if (ret == -EAGAIN) { 5584 port->upcoming_state = INVALID_STATE; 5585 } else { 5586 port->sink_cap_done = true; 5587 goto unlock; 5588 } 5589 resched: 5590 mod_enable_frs_delayed_work(port, GET_SINK_CAP_RETRY_MS); 5591 unlock: 5592 mutex_unlock(&port->lock); 5593 } 5594 5595 static void tcpm_send_discover_work(struct kthread_work *work) 5596 { 5597 struct tcpm_port *port = container_of(work, struct tcpm_port, send_discover_work); 5598 5599 mutex_lock(&port->lock); 5600 /* No need to send DISCOVER_IDENTITY anymore */ 5601 if (!port->send_discover) 5602 goto unlock; 5603 5604 if (port->data_role == TYPEC_DEVICE && port->negotiated_rev < PD_REV30) { 5605 port->send_discover = false; 5606 goto unlock; 5607 } 5608 5609 /* Retry if the port is not idle */ 5610 if ((port->state != SRC_READY && port->state != SNK_READY) || port->vdm_sm_running) { 5611 mod_send_discover_delayed_work(port, SEND_DISCOVER_RETRY_MS); 5612 goto unlock; 5613 } 5614 5615 tcpm_send_vdm(port, USB_SID_PD, CMD_DISCOVER_IDENT, NULL, 0); 5616 5617 unlock: 5618 mutex_unlock(&port->lock); 5619 } 5620 5621 static int tcpm_dr_set(struct typec_port *p, enum typec_data_role data) 5622 { 5623 struct tcpm_port *port = typec_get_drvdata(p); 5624 int ret; 5625 5626 mutex_lock(&port->swap_lock); 5627 mutex_lock(&port->lock); 5628 5629 if (port->typec_caps.data != TYPEC_PORT_DRD) { 5630 ret = -EINVAL; 5631 goto port_unlock; 5632 } 5633 if (port->state != SRC_READY && port->state != SNK_READY) { 5634 ret = -EAGAIN; 5635 goto port_unlock; 5636 } 5637 5638 if (port->data_role == data) { 5639 ret = 0; 5640 goto port_unlock; 5641 } 5642 5643 /* 5644 * XXX 5645 * 6.3.9: If an alternate mode is active, a request to swap 5646 * alternate modes shall trigger a port reset. 5647 * Reject data role swap request in this case. 5648 */ 5649 5650 if (!port->pd_capable) { 5651 /* 5652 * If the partner is not PD capable, reset the port to 5653 * trigger a role change. This can only work if a preferred 5654 * role is configured, and if it matches the requested role. 5655 */ 5656 if (port->try_role == TYPEC_NO_PREFERRED_ROLE || 5657 port->try_role == port->pwr_role) { 5658 ret = -EINVAL; 5659 goto port_unlock; 5660 } 5661 port->non_pd_role_swap = true; 5662 tcpm_set_state(port, PORT_RESET, 0); 5663 } else { 5664 port->upcoming_state = DR_SWAP_SEND; 5665 ret = tcpm_ams_start(port, DATA_ROLE_SWAP); 5666 if (ret == -EAGAIN) { 5667 port->upcoming_state = INVALID_STATE; 5668 goto port_unlock; 5669 } 5670 } 5671 5672 port->swap_status = 0; 5673 port->swap_pending = true; 5674 reinit_completion(&port->swap_complete); 5675 mutex_unlock(&port->lock); 5676 5677 if (!wait_for_completion_timeout(&port->swap_complete, 5678 msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT))) 5679 ret = -ETIMEDOUT; 5680 else 5681 ret = port->swap_status; 5682 5683 port->non_pd_role_swap = false; 5684 goto swap_unlock; 5685 5686 port_unlock: 5687 mutex_unlock(&port->lock); 5688 swap_unlock: 5689 mutex_unlock(&port->swap_lock); 5690 return ret; 5691 } 5692 5693 static int tcpm_pr_set(struct typec_port *p, enum typec_role role) 5694 { 5695 struct tcpm_port *port = typec_get_drvdata(p); 5696 int ret; 5697 5698 mutex_lock(&port->swap_lock); 5699 mutex_lock(&port->lock); 5700 5701 if (port->port_type != TYPEC_PORT_DRP) { 5702 ret = -EINVAL; 5703 goto port_unlock; 5704 } 5705 if (port->state != SRC_READY && port->state != SNK_READY) { 5706 ret = -EAGAIN; 5707 goto port_unlock; 5708 } 5709 5710 if (role == port->pwr_role) { 5711 ret = 0; 5712 goto port_unlock; 5713 } 5714 5715 port->upcoming_state = PR_SWAP_SEND; 5716 ret = tcpm_ams_start(port, POWER_ROLE_SWAP); 5717 if (ret == -EAGAIN) { 5718 port->upcoming_state = INVALID_STATE; 5719 goto port_unlock; 5720 } 5721 5722 port->swap_status = 0; 5723 port->swap_pending = true; 5724 reinit_completion(&port->swap_complete); 5725 mutex_unlock(&port->lock); 5726 5727 if (!wait_for_completion_timeout(&port->swap_complete, 5728 msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT))) 5729 ret = -ETIMEDOUT; 5730 else 5731 ret = port->swap_status; 5732 5733 goto swap_unlock; 5734 5735 port_unlock: 5736 mutex_unlock(&port->lock); 5737 swap_unlock: 5738 mutex_unlock(&port->swap_lock); 5739 return ret; 5740 } 5741 5742 static int tcpm_vconn_set(struct typec_port *p, enum typec_role role) 5743 { 5744 struct tcpm_port *port = typec_get_drvdata(p); 5745 int ret; 5746 5747 mutex_lock(&port->swap_lock); 5748 mutex_lock(&port->lock); 5749 5750 if (port->state != SRC_READY && port->state != SNK_READY) { 5751 ret = -EAGAIN; 5752 goto port_unlock; 5753 } 5754 5755 if (role == port->vconn_role) { 5756 ret = 0; 5757 goto port_unlock; 5758 } 5759 5760 port->upcoming_state = VCONN_SWAP_SEND; 5761 ret = tcpm_ams_start(port, VCONN_SWAP); 5762 if (ret == -EAGAIN) { 5763 port->upcoming_state = INVALID_STATE; 5764 goto port_unlock; 5765 } 5766 5767 port->swap_status = 0; 5768 port->swap_pending = true; 5769 reinit_completion(&port->swap_complete); 5770 mutex_unlock(&port->lock); 5771 5772 if (!wait_for_completion_timeout(&port->swap_complete, 5773 msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT))) 5774 ret = -ETIMEDOUT; 5775 else 5776 ret = port->swap_status; 5777 5778 goto swap_unlock; 5779 5780 port_unlock: 5781 mutex_unlock(&port->lock); 5782 swap_unlock: 5783 mutex_unlock(&port->swap_lock); 5784 return ret; 5785 } 5786 5787 static int tcpm_try_role(struct typec_port *p, int role) 5788 { 5789 struct tcpm_port *port = typec_get_drvdata(p); 5790 struct tcpc_dev *tcpc = port->tcpc; 5791 int ret = 0; 5792 5793 mutex_lock(&port->lock); 5794 if (tcpc->try_role) 5795 ret = tcpc->try_role(tcpc, role); 5796 if (!ret) 5797 port->try_role = role; 5798 port->try_src_count = 0; 5799 port->try_snk_count = 0; 5800 mutex_unlock(&port->lock); 5801 5802 return ret; 5803 } 5804 5805 static int tcpm_pps_set_op_curr(struct tcpm_port *port, u16 req_op_curr) 5806 { 5807 unsigned int target_mw; 5808 int ret; 5809 5810 mutex_lock(&port->swap_lock); 5811 mutex_lock(&port->lock); 5812 5813 if (!port->pps_data.active) { 5814 ret = -EOPNOTSUPP; 5815 goto port_unlock; 5816 } 5817 5818 if (port->state != SNK_READY) { 5819 ret = -EAGAIN; 5820 goto port_unlock; 5821 } 5822 5823 if (req_op_curr > port->pps_data.max_curr) { 5824 ret = -EINVAL; 5825 goto port_unlock; 5826 } 5827 5828 target_mw = (req_op_curr * port->supply_voltage) / 1000; 5829 if (target_mw < port->operating_snk_mw) { 5830 ret = -EINVAL; 5831 goto port_unlock; 5832 } 5833 5834 port->upcoming_state = SNK_NEGOTIATE_PPS_CAPABILITIES; 5835 ret = tcpm_ams_start(port, POWER_NEGOTIATION); 5836 if (ret == -EAGAIN) { 5837 port->upcoming_state = INVALID_STATE; 5838 goto port_unlock; 5839 } 5840 5841 /* Round down operating current to align with PPS valid steps */ 5842 req_op_curr = req_op_curr - (req_op_curr % RDO_PROG_CURR_MA_STEP); 5843 5844 reinit_completion(&port->pps_complete); 5845 port->pps_data.req_op_curr = req_op_curr; 5846 port->pps_status = 0; 5847 port->pps_pending = true; 5848 mutex_unlock(&port->lock); 5849 5850 if (!wait_for_completion_timeout(&port->pps_complete, 5851 msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT))) 5852 ret = -ETIMEDOUT; 5853 else 5854 ret = port->pps_status; 5855 5856 goto swap_unlock; 5857 5858 port_unlock: 5859 mutex_unlock(&port->lock); 5860 swap_unlock: 5861 mutex_unlock(&port->swap_lock); 5862 5863 return ret; 5864 } 5865 5866 static int tcpm_pps_set_out_volt(struct tcpm_port *port, u16 req_out_volt) 5867 { 5868 unsigned int target_mw; 5869 int ret; 5870 5871 mutex_lock(&port->swap_lock); 5872 mutex_lock(&port->lock); 5873 5874 if (!port->pps_data.active) { 5875 ret = -EOPNOTSUPP; 5876 goto port_unlock; 5877 } 5878 5879 if (port->state != SNK_READY) { 5880 ret = -EAGAIN; 5881 goto port_unlock; 5882 } 5883 5884 if (req_out_volt < port->pps_data.min_volt || 5885 req_out_volt > port->pps_data.max_volt) { 5886 ret = -EINVAL; 5887 goto port_unlock; 5888 } 5889 5890 target_mw = (port->current_limit * req_out_volt) / 1000; 5891 if (target_mw < port->operating_snk_mw) { 5892 ret = -EINVAL; 5893 goto port_unlock; 5894 } 5895 5896 port->upcoming_state = SNK_NEGOTIATE_PPS_CAPABILITIES; 5897 ret = tcpm_ams_start(port, POWER_NEGOTIATION); 5898 if (ret == -EAGAIN) { 5899 port->upcoming_state = INVALID_STATE; 5900 goto port_unlock; 5901 } 5902 5903 /* Round down output voltage to align with PPS valid steps */ 5904 req_out_volt = req_out_volt - (req_out_volt % RDO_PROG_VOLT_MV_STEP); 5905 5906 reinit_completion(&port->pps_complete); 5907 port->pps_data.req_out_volt = req_out_volt; 5908 port->pps_status = 0; 5909 port->pps_pending = true; 5910 mutex_unlock(&port->lock); 5911 5912 if (!wait_for_completion_timeout(&port->pps_complete, 5913 msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT))) 5914 ret = -ETIMEDOUT; 5915 else 5916 ret = port->pps_status; 5917 5918 goto swap_unlock; 5919 5920 port_unlock: 5921 mutex_unlock(&port->lock); 5922 swap_unlock: 5923 mutex_unlock(&port->swap_lock); 5924 5925 return ret; 5926 } 5927 5928 static int tcpm_pps_activate(struct tcpm_port *port, bool activate) 5929 { 5930 int ret = 0; 5931 5932 mutex_lock(&port->swap_lock); 5933 mutex_lock(&port->lock); 5934 5935 if (!port->pps_data.supported) { 5936 ret = -EOPNOTSUPP; 5937 goto port_unlock; 5938 } 5939 5940 /* Trying to deactivate PPS when already deactivated so just bail */ 5941 if (!port->pps_data.active && !activate) 5942 goto port_unlock; 5943 5944 if (port->state != SNK_READY) { 5945 ret = -EAGAIN; 5946 goto port_unlock; 5947 } 5948 5949 if (activate) 5950 port->upcoming_state = SNK_NEGOTIATE_PPS_CAPABILITIES; 5951 else 5952 port->upcoming_state = SNK_NEGOTIATE_CAPABILITIES; 5953 ret = tcpm_ams_start(port, POWER_NEGOTIATION); 5954 if (ret == -EAGAIN) { 5955 port->upcoming_state = INVALID_STATE; 5956 goto port_unlock; 5957 } 5958 5959 reinit_completion(&port->pps_complete); 5960 port->pps_status = 0; 5961 port->pps_pending = true; 5962 5963 /* Trigger PPS request or move back to standard PDO contract */ 5964 if (activate) { 5965 port->pps_data.req_out_volt = port->supply_voltage; 5966 port->pps_data.req_op_curr = port->current_limit; 5967 } 5968 mutex_unlock(&port->lock); 5969 5970 if (!wait_for_completion_timeout(&port->pps_complete, 5971 msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT))) 5972 ret = -ETIMEDOUT; 5973 else 5974 ret = port->pps_status; 5975 5976 goto swap_unlock; 5977 5978 port_unlock: 5979 mutex_unlock(&port->lock); 5980 swap_unlock: 5981 mutex_unlock(&port->swap_lock); 5982 5983 return ret; 5984 } 5985 5986 static void tcpm_init(struct tcpm_port *port) 5987 { 5988 enum typec_cc_status cc1, cc2; 5989 5990 port->tcpc->init(port->tcpc); 5991 5992 tcpm_reset_port(port); 5993 5994 /* 5995 * XXX 5996 * Should possibly wait for VBUS to settle if it was enabled locally 5997 * since tcpm_reset_port() will disable VBUS. 5998 */ 5999 port->vbus_present = port->tcpc->get_vbus(port->tcpc); 6000 if (port->vbus_present) 6001 port->vbus_never_low = true; 6002 6003 /* 6004 * 1. When vbus_present is true, voltage on VBUS is already at VSAFE5V. 6005 * So implicitly vbus_vsafe0v = false. 6006 * 6007 * 2. When vbus_present is false and TCPC does NOT support querying 6008 * vsafe0v status, then, it's best to assume vbus is at VSAFE0V i.e. 6009 * vbus_vsafe0v is true. 6010 * 6011 * 3. When vbus_present is false and TCPC does support querying vsafe0v, 6012 * then, query tcpc for vsafe0v status. 6013 */ 6014 if (port->vbus_present) 6015 port->vbus_vsafe0v = false; 6016 else if (!port->tcpc->is_vbus_vsafe0v) 6017 port->vbus_vsafe0v = true; 6018 else 6019 port->vbus_vsafe0v = port->tcpc->is_vbus_vsafe0v(port->tcpc); 6020 6021 tcpm_set_state(port, tcpm_default_state(port), 0); 6022 6023 if (port->tcpc->get_cc(port->tcpc, &cc1, &cc2) == 0) 6024 _tcpm_cc_change(port, cc1, cc2); 6025 6026 /* 6027 * Some adapters need a clean slate at startup, and won't recover 6028 * otherwise. So do not try to be fancy and force a clean disconnect. 6029 */ 6030 tcpm_set_state(port, PORT_RESET, 0); 6031 } 6032 6033 static int tcpm_port_type_set(struct typec_port *p, enum typec_port_type type) 6034 { 6035 struct tcpm_port *port = typec_get_drvdata(p); 6036 6037 mutex_lock(&port->lock); 6038 if (type == port->port_type) 6039 goto port_unlock; 6040 6041 port->port_type = type; 6042 6043 if (!port->connected) { 6044 tcpm_set_state(port, PORT_RESET, 0); 6045 } else if (type == TYPEC_PORT_SNK) { 6046 if (!(port->pwr_role == TYPEC_SINK && 6047 port->data_role == TYPEC_DEVICE)) 6048 tcpm_set_state(port, PORT_RESET, 0); 6049 } else if (type == TYPEC_PORT_SRC) { 6050 if (!(port->pwr_role == TYPEC_SOURCE && 6051 port->data_role == TYPEC_HOST)) 6052 tcpm_set_state(port, PORT_RESET, 0); 6053 } 6054 6055 port_unlock: 6056 mutex_unlock(&port->lock); 6057 return 0; 6058 } 6059 6060 static const struct typec_operations tcpm_ops = { 6061 .try_role = tcpm_try_role, 6062 .dr_set = tcpm_dr_set, 6063 .pr_set = tcpm_pr_set, 6064 .vconn_set = tcpm_vconn_set, 6065 .port_type_set = tcpm_port_type_set 6066 }; 6067 6068 void tcpm_tcpc_reset(struct tcpm_port *port) 6069 { 6070 mutex_lock(&port->lock); 6071 /* XXX: Maintain PD connection if possible? */ 6072 tcpm_init(port); 6073 mutex_unlock(&port->lock); 6074 } 6075 EXPORT_SYMBOL_GPL(tcpm_tcpc_reset); 6076 6077 static void tcpm_port_unregister_pd(struct tcpm_port *port) 6078 { 6079 usb_power_delivery_unregister_capabilities(port->port_sink_caps); 6080 port->port_sink_caps = NULL; 6081 usb_power_delivery_unregister_capabilities(port->port_source_caps); 6082 port->port_source_caps = NULL; 6083 usb_power_delivery_unregister(port->pd); 6084 port->pd = NULL; 6085 } 6086 6087 static int tcpm_port_register_pd(struct tcpm_port *port) 6088 { 6089 struct usb_power_delivery_desc desc = { port->typec_caps.pd_revision }; 6090 struct usb_power_delivery_capabilities_desc caps = { }; 6091 struct usb_power_delivery_capabilities *cap; 6092 int ret; 6093 6094 if (!port->nr_src_pdo && !port->nr_snk_pdo) 6095 return 0; 6096 6097 port->pd = usb_power_delivery_register(port->dev, &desc); 6098 if (IS_ERR(port->pd)) { 6099 ret = PTR_ERR(port->pd); 6100 goto err_unregister; 6101 } 6102 6103 if (port->nr_src_pdo) { 6104 memcpy_and_pad(caps.pdo, sizeof(caps.pdo), port->src_pdo, 6105 port->nr_src_pdo * sizeof(u32), 0); 6106 caps.role = TYPEC_SOURCE; 6107 6108 cap = usb_power_delivery_register_capabilities(port->pd, &caps); 6109 if (IS_ERR(cap)) { 6110 ret = PTR_ERR(cap); 6111 goto err_unregister; 6112 } 6113 6114 port->port_source_caps = cap; 6115 } 6116 6117 if (port->nr_snk_pdo) { 6118 memcpy_and_pad(caps.pdo, sizeof(caps.pdo), port->snk_pdo, 6119 port->nr_snk_pdo * sizeof(u32), 0); 6120 caps.role = TYPEC_SINK; 6121 6122 cap = usb_power_delivery_register_capabilities(port->pd, &caps); 6123 if (IS_ERR(cap)) { 6124 ret = PTR_ERR(cap); 6125 goto err_unregister; 6126 } 6127 6128 port->port_sink_caps = cap; 6129 } 6130 6131 return 0; 6132 6133 err_unregister: 6134 tcpm_port_unregister_pd(port); 6135 6136 return ret; 6137 } 6138 6139 static int tcpm_fw_get_caps(struct tcpm_port *port, 6140 struct fwnode_handle *fwnode) 6141 { 6142 const char *opmode_str; 6143 int ret; 6144 u32 mw, frs_current; 6145 6146 if (!fwnode) 6147 return -EINVAL; 6148 6149 /* 6150 * This fwnode has a "compatible" property, but is never populated as a 6151 * struct device. Instead we simply parse it to read the properties. 6152 * This it breaks fw_devlink=on. To maintain backward compatibility 6153 * with existing DT files, we work around this by deleting any 6154 * fwnode_links to/from this fwnode. 6155 */ 6156 fw_devlink_purge_absent_suppliers(fwnode); 6157 6158 ret = typec_get_fw_cap(&port->typec_caps, fwnode); 6159 if (ret < 0) 6160 return ret; 6161 6162 port->port_type = port->typec_caps.type; 6163 port->pd_supported = !fwnode_property_read_bool(fwnode, "pd-disable"); 6164 6165 port->slow_charger_loop = fwnode_property_read_bool(fwnode, "slow-charger-loop"); 6166 if (port->port_type == TYPEC_PORT_SNK) 6167 goto sink; 6168 6169 /* Get Source PDOs for the PD port or Source Rp value for the non-PD port */ 6170 if (port->pd_supported) { 6171 ret = fwnode_property_count_u32(fwnode, "source-pdos"); 6172 if (ret == 0) 6173 return -EINVAL; 6174 else if (ret < 0) 6175 return ret; 6176 6177 port->nr_src_pdo = min(ret, PDO_MAX_OBJECTS); 6178 ret = fwnode_property_read_u32_array(fwnode, "source-pdos", 6179 port->src_pdo, port->nr_src_pdo); 6180 if (ret) 6181 return ret; 6182 ret = tcpm_validate_caps(port, port->src_pdo, port->nr_src_pdo); 6183 if (ret) 6184 return ret; 6185 } else { 6186 ret = fwnode_property_read_string(fwnode, "typec-power-opmode", &opmode_str); 6187 if (ret) 6188 return ret; 6189 ret = typec_find_pwr_opmode(opmode_str); 6190 if (ret < 0) 6191 return ret; 6192 port->src_rp = tcpm_pwr_opmode_to_rp(ret); 6193 } 6194 6195 if (port->port_type == TYPEC_PORT_SRC) 6196 return 0; 6197 6198 sink: 6199 port->self_powered = fwnode_property_read_bool(fwnode, "self-powered"); 6200 6201 if (!port->pd_supported) 6202 return 0; 6203 6204 /* Get sink pdos */ 6205 ret = fwnode_property_count_u32(fwnode, "sink-pdos"); 6206 if (ret <= 0) 6207 return -EINVAL; 6208 6209 port->nr_snk_pdo = min(ret, PDO_MAX_OBJECTS); 6210 ret = fwnode_property_read_u32_array(fwnode, "sink-pdos", 6211 port->snk_pdo, port->nr_snk_pdo); 6212 if ((ret < 0) || tcpm_validate_caps(port, port->snk_pdo, 6213 port->nr_snk_pdo)) 6214 return -EINVAL; 6215 6216 if (fwnode_property_read_u32(fwnode, "op-sink-microwatt", &mw) < 0) 6217 return -EINVAL; 6218 port->operating_snk_mw = mw / 1000; 6219 6220 /* FRS can only be supported by DRP ports */ 6221 if (port->port_type == TYPEC_PORT_DRP) { 6222 ret = fwnode_property_read_u32(fwnode, "new-source-frs-typec-current", 6223 &frs_current); 6224 if (ret >= 0 && frs_current <= FRS_5V_3A) 6225 port->new_source_frs_current = frs_current; 6226 } 6227 6228 /* sink-vdos is optional */ 6229 ret = fwnode_property_count_u32(fwnode, "sink-vdos"); 6230 if (ret < 0) 6231 ret = 0; 6232 6233 port->nr_snk_vdo = min(ret, VDO_MAX_OBJECTS); 6234 if (port->nr_snk_vdo) { 6235 ret = fwnode_property_read_u32_array(fwnode, "sink-vdos", 6236 port->snk_vdo, 6237 port->nr_snk_vdo); 6238 if (ret < 0) 6239 return ret; 6240 } 6241 6242 /* If sink-vdos is found, sink-vdos-v1 is expected for backward compatibility. */ 6243 if (port->nr_snk_vdo) { 6244 ret = fwnode_property_count_u32(fwnode, "sink-vdos-v1"); 6245 if (ret < 0) 6246 return ret; 6247 else if (ret == 0) 6248 return -ENODATA; 6249 6250 port->nr_snk_vdo_v1 = min(ret, VDO_MAX_OBJECTS); 6251 ret = fwnode_property_read_u32_array(fwnode, "sink-vdos-v1", 6252 port->snk_vdo_v1, 6253 port->nr_snk_vdo_v1); 6254 if (ret < 0) 6255 return ret; 6256 } 6257 6258 return 0; 6259 } 6260 6261 /* Power Supply access to expose source power information */ 6262 enum tcpm_psy_online_states { 6263 TCPM_PSY_OFFLINE = 0, 6264 TCPM_PSY_FIXED_ONLINE, 6265 TCPM_PSY_PROG_ONLINE, 6266 }; 6267 6268 static enum power_supply_property tcpm_psy_props[] = { 6269 POWER_SUPPLY_PROP_USB_TYPE, 6270 POWER_SUPPLY_PROP_ONLINE, 6271 POWER_SUPPLY_PROP_VOLTAGE_MIN, 6272 POWER_SUPPLY_PROP_VOLTAGE_MAX, 6273 POWER_SUPPLY_PROP_VOLTAGE_NOW, 6274 POWER_SUPPLY_PROP_CURRENT_MAX, 6275 POWER_SUPPLY_PROP_CURRENT_NOW, 6276 }; 6277 6278 static int tcpm_psy_get_online(struct tcpm_port *port, 6279 union power_supply_propval *val) 6280 { 6281 if (port->vbus_charge) { 6282 if (port->pps_data.active) 6283 val->intval = TCPM_PSY_PROG_ONLINE; 6284 else 6285 val->intval = TCPM_PSY_FIXED_ONLINE; 6286 } else { 6287 val->intval = TCPM_PSY_OFFLINE; 6288 } 6289 6290 return 0; 6291 } 6292 6293 static int tcpm_psy_get_voltage_min(struct tcpm_port *port, 6294 union power_supply_propval *val) 6295 { 6296 if (port->pps_data.active) 6297 val->intval = port->pps_data.min_volt * 1000; 6298 else 6299 val->intval = port->supply_voltage * 1000; 6300 6301 return 0; 6302 } 6303 6304 static int tcpm_psy_get_voltage_max(struct tcpm_port *port, 6305 union power_supply_propval *val) 6306 { 6307 if (port->pps_data.active) 6308 val->intval = port->pps_data.max_volt * 1000; 6309 else 6310 val->intval = port->supply_voltage * 1000; 6311 6312 return 0; 6313 } 6314 6315 static int tcpm_psy_get_voltage_now(struct tcpm_port *port, 6316 union power_supply_propval *val) 6317 { 6318 val->intval = port->supply_voltage * 1000; 6319 6320 return 0; 6321 } 6322 6323 static int tcpm_psy_get_current_max(struct tcpm_port *port, 6324 union power_supply_propval *val) 6325 { 6326 if (port->pps_data.active) 6327 val->intval = port->pps_data.max_curr * 1000; 6328 else 6329 val->intval = port->current_limit * 1000; 6330 6331 return 0; 6332 } 6333 6334 static int tcpm_psy_get_current_now(struct tcpm_port *port, 6335 union power_supply_propval *val) 6336 { 6337 val->intval = port->current_limit * 1000; 6338 6339 return 0; 6340 } 6341 6342 static int tcpm_psy_get_prop(struct power_supply *psy, 6343 enum power_supply_property psp, 6344 union power_supply_propval *val) 6345 { 6346 struct tcpm_port *port = power_supply_get_drvdata(psy); 6347 int ret = 0; 6348 6349 switch (psp) { 6350 case POWER_SUPPLY_PROP_USB_TYPE: 6351 val->intval = port->usb_type; 6352 break; 6353 case POWER_SUPPLY_PROP_ONLINE: 6354 ret = tcpm_psy_get_online(port, val); 6355 break; 6356 case POWER_SUPPLY_PROP_VOLTAGE_MIN: 6357 ret = tcpm_psy_get_voltage_min(port, val); 6358 break; 6359 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 6360 ret = tcpm_psy_get_voltage_max(port, val); 6361 break; 6362 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 6363 ret = tcpm_psy_get_voltage_now(port, val); 6364 break; 6365 case POWER_SUPPLY_PROP_CURRENT_MAX: 6366 ret = tcpm_psy_get_current_max(port, val); 6367 break; 6368 case POWER_SUPPLY_PROP_CURRENT_NOW: 6369 ret = tcpm_psy_get_current_now(port, val); 6370 break; 6371 default: 6372 ret = -EINVAL; 6373 break; 6374 } 6375 6376 return ret; 6377 } 6378 6379 static int tcpm_psy_set_online(struct tcpm_port *port, 6380 const union power_supply_propval *val) 6381 { 6382 int ret; 6383 6384 switch (val->intval) { 6385 case TCPM_PSY_FIXED_ONLINE: 6386 ret = tcpm_pps_activate(port, false); 6387 break; 6388 case TCPM_PSY_PROG_ONLINE: 6389 ret = tcpm_pps_activate(port, true); 6390 break; 6391 default: 6392 ret = -EINVAL; 6393 break; 6394 } 6395 6396 return ret; 6397 } 6398 6399 static int tcpm_psy_set_prop(struct power_supply *psy, 6400 enum power_supply_property psp, 6401 const union power_supply_propval *val) 6402 { 6403 struct tcpm_port *port = power_supply_get_drvdata(psy); 6404 int ret; 6405 6406 /* 6407 * All the properties below are related to USB PD. The check needs to be 6408 * property specific when a non-pd related property is added. 6409 */ 6410 if (!port->pd_supported) 6411 return -EOPNOTSUPP; 6412 6413 switch (psp) { 6414 case POWER_SUPPLY_PROP_ONLINE: 6415 ret = tcpm_psy_set_online(port, val); 6416 break; 6417 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 6418 if (val->intval < port->pps_data.min_volt * 1000 || 6419 val->intval > port->pps_data.max_volt * 1000) 6420 ret = -EINVAL; 6421 else 6422 ret = tcpm_pps_set_out_volt(port, val->intval / 1000); 6423 break; 6424 case POWER_SUPPLY_PROP_CURRENT_NOW: 6425 if (val->intval > port->pps_data.max_curr * 1000) 6426 ret = -EINVAL; 6427 else 6428 ret = tcpm_pps_set_op_curr(port, val->intval / 1000); 6429 break; 6430 default: 6431 ret = -EINVAL; 6432 break; 6433 } 6434 power_supply_changed(port->psy); 6435 return ret; 6436 } 6437 6438 static int tcpm_psy_prop_writeable(struct power_supply *psy, 6439 enum power_supply_property psp) 6440 { 6441 switch (psp) { 6442 case POWER_SUPPLY_PROP_ONLINE: 6443 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 6444 case POWER_SUPPLY_PROP_CURRENT_NOW: 6445 return 1; 6446 default: 6447 return 0; 6448 } 6449 } 6450 6451 static enum power_supply_usb_type tcpm_psy_usb_types[] = { 6452 POWER_SUPPLY_USB_TYPE_C, 6453 POWER_SUPPLY_USB_TYPE_PD, 6454 POWER_SUPPLY_USB_TYPE_PD_PPS, 6455 }; 6456 6457 static const char *tcpm_psy_name_prefix = "tcpm-source-psy-"; 6458 6459 static int devm_tcpm_psy_register(struct tcpm_port *port) 6460 { 6461 struct power_supply_config psy_cfg = {}; 6462 const char *port_dev_name = dev_name(port->dev); 6463 size_t psy_name_len = strlen(tcpm_psy_name_prefix) + 6464 strlen(port_dev_name) + 1; 6465 char *psy_name; 6466 6467 psy_cfg.drv_data = port; 6468 psy_cfg.fwnode = dev_fwnode(port->dev); 6469 psy_name = devm_kzalloc(port->dev, psy_name_len, GFP_KERNEL); 6470 if (!psy_name) 6471 return -ENOMEM; 6472 6473 snprintf(psy_name, psy_name_len, "%s%s", tcpm_psy_name_prefix, 6474 port_dev_name); 6475 port->psy_desc.name = psy_name; 6476 port->psy_desc.type = POWER_SUPPLY_TYPE_USB; 6477 port->psy_desc.usb_types = tcpm_psy_usb_types; 6478 port->psy_desc.num_usb_types = ARRAY_SIZE(tcpm_psy_usb_types); 6479 port->psy_desc.properties = tcpm_psy_props; 6480 port->psy_desc.num_properties = ARRAY_SIZE(tcpm_psy_props); 6481 port->psy_desc.get_property = tcpm_psy_get_prop; 6482 port->psy_desc.set_property = tcpm_psy_set_prop; 6483 port->psy_desc.property_is_writeable = tcpm_psy_prop_writeable; 6484 6485 port->usb_type = POWER_SUPPLY_USB_TYPE_C; 6486 6487 port->psy = devm_power_supply_register(port->dev, &port->psy_desc, 6488 &psy_cfg); 6489 6490 return PTR_ERR_OR_ZERO(port->psy); 6491 } 6492 6493 static enum hrtimer_restart state_machine_timer_handler(struct hrtimer *timer) 6494 { 6495 struct tcpm_port *port = container_of(timer, struct tcpm_port, state_machine_timer); 6496 6497 if (port->registered) 6498 kthread_queue_work(port->wq, &port->state_machine); 6499 return HRTIMER_NORESTART; 6500 } 6501 6502 static enum hrtimer_restart vdm_state_machine_timer_handler(struct hrtimer *timer) 6503 { 6504 struct tcpm_port *port = container_of(timer, struct tcpm_port, vdm_state_machine_timer); 6505 6506 if (port->registered) 6507 kthread_queue_work(port->wq, &port->vdm_state_machine); 6508 return HRTIMER_NORESTART; 6509 } 6510 6511 static enum hrtimer_restart enable_frs_timer_handler(struct hrtimer *timer) 6512 { 6513 struct tcpm_port *port = container_of(timer, struct tcpm_port, enable_frs_timer); 6514 6515 if (port->registered) 6516 kthread_queue_work(port->wq, &port->enable_frs); 6517 return HRTIMER_NORESTART; 6518 } 6519 6520 static enum hrtimer_restart send_discover_timer_handler(struct hrtimer *timer) 6521 { 6522 struct tcpm_port *port = container_of(timer, struct tcpm_port, send_discover_timer); 6523 6524 if (port->registered) 6525 kthread_queue_work(port->wq, &port->send_discover_work); 6526 return HRTIMER_NORESTART; 6527 } 6528 6529 struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) 6530 { 6531 struct tcpm_port *port; 6532 int err; 6533 6534 if (!dev || !tcpc || 6535 !tcpc->get_vbus || !tcpc->set_cc || !tcpc->get_cc || 6536 !tcpc->set_polarity || !tcpc->set_vconn || !tcpc->set_vbus || 6537 !tcpc->set_pd_rx || !tcpc->set_roles || !tcpc->pd_transmit) 6538 return ERR_PTR(-EINVAL); 6539 6540 port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL); 6541 if (!port) 6542 return ERR_PTR(-ENOMEM); 6543 6544 port->dev = dev; 6545 port->tcpc = tcpc; 6546 6547 mutex_init(&port->lock); 6548 mutex_init(&port->swap_lock); 6549 6550 port->wq = kthread_create_worker(0, dev_name(dev)); 6551 if (IS_ERR(port->wq)) 6552 return ERR_CAST(port->wq); 6553 sched_set_fifo(port->wq->task); 6554 6555 kthread_init_work(&port->state_machine, tcpm_state_machine_work); 6556 kthread_init_work(&port->vdm_state_machine, vdm_state_machine_work); 6557 kthread_init_work(&port->event_work, tcpm_pd_event_handler); 6558 kthread_init_work(&port->enable_frs, tcpm_enable_frs_work); 6559 kthread_init_work(&port->send_discover_work, tcpm_send_discover_work); 6560 hrtimer_init(&port->state_machine_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 6561 port->state_machine_timer.function = state_machine_timer_handler; 6562 hrtimer_init(&port->vdm_state_machine_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 6563 port->vdm_state_machine_timer.function = vdm_state_machine_timer_handler; 6564 hrtimer_init(&port->enable_frs_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 6565 port->enable_frs_timer.function = enable_frs_timer_handler; 6566 hrtimer_init(&port->send_discover_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 6567 port->send_discover_timer.function = send_discover_timer_handler; 6568 6569 spin_lock_init(&port->pd_event_lock); 6570 6571 init_completion(&port->tx_complete); 6572 init_completion(&port->swap_complete); 6573 init_completion(&port->pps_complete); 6574 tcpm_debugfs_init(port); 6575 6576 err = tcpm_fw_get_caps(port, tcpc->fwnode); 6577 if (err < 0) 6578 goto out_destroy_wq; 6579 6580 port->try_role = port->typec_caps.prefer_role; 6581 6582 port->typec_caps.fwnode = tcpc->fwnode; 6583 port->typec_caps.revision = 0x0120; /* Type-C spec release 1.2 */ 6584 port->typec_caps.pd_revision = 0x0300; /* USB-PD spec release 3.0 */ 6585 port->typec_caps.svdm_version = SVDM_VER_2_0; 6586 port->typec_caps.driver_data = port; 6587 port->typec_caps.ops = &tcpm_ops; 6588 port->typec_caps.orientation_aware = 1; 6589 6590 port->partner_desc.identity = &port->partner_ident; 6591 port->port_type = port->typec_caps.type; 6592 6593 port->role_sw = usb_role_switch_get(port->dev); 6594 if (!port->role_sw) 6595 port->role_sw = fwnode_usb_role_switch_get(tcpc->fwnode); 6596 if (IS_ERR(port->role_sw)) { 6597 err = PTR_ERR(port->role_sw); 6598 goto out_destroy_wq; 6599 } 6600 6601 err = devm_tcpm_psy_register(port); 6602 if (err) 6603 goto out_role_sw_put; 6604 power_supply_changed(port->psy); 6605 6606 err = tcpm_port_register_pd(port); 6607 if (err) 6608 goto out_role_sw_put; 6609 6610 port->typec_caps.pd = port->pd; 6611 6612 port->typec_port = typec_register_port(port->dev, &port->typec_caps); 6613 if (IS_ERR(port->typec_port)) { 6614 err = PTR_ERR(port->typec_port); 6615 goto out_unregister_pd; 6616 } 6617 6618 typec_port_register_altmodes(port->typec_port, 6619 &tcpm_altmode_ops, port, 6620 port->port_altmode, ALTMODE_DISCOVERY_MAX); 6621 port->registered = true; 6622 6623 mutex_lock(&port->lock); 6624 tcpm_init(port); 6625 mutex_unlock(&port->lock); 6626 6627 tcpm_log(port, "%s: registered", dev_name(dev)); 6628 return port; 6629 6630 out_unregister_pd: 6631 tcpm_port_unregister_pd(port); 6632 out_role_sw_put: 6633 usb_role_switch_put(port->role_sw); 6634 out_destroy_wq: 6635 tcpm_debugfs_exit(port); 6636 kthread_destroy_worker(port->wq); 6637 return ERR_PTR(err); 6638 } 6639 EXPORT_SYMBOL_GPL(tcpm_register_port); 6640 6641 void tcpm_unregister_port(struct tcpm_port *port) 6642 { 6643 int i; 6644 6645 port->registered = false; 6646 kthread_destroy_worker(port->wq); 6647 6648 hrtimer_cancel(&port->send_discover_timer); 6649 hrtimer_cancel(&port->enable_frs_timer); 6650 hrtimer_cancel(&port->vdm_state_machine_timer); 6651 hrtimer_cancel(&port->state_machine_timer); 6652 6653 tcpm_reset_port(port); 6654 6655 tcpm_port_unregister_pd(port); 6656 6657 for (i = 0; i < ARRAY_SIZE(port->port_altmode); i++) 6658 typec_unregister_altmode(port->port_altmode[i]); 6659 typec_unregister_port(port->typec_port); 6660 usb_role_switch_put(port->role_sw); 6661 tcpm_debugfs_exit(port); 6662 } 6663 EXPORT_SYMBOL_GPL(tcpm_unregister_port); 6664 6665 MODULE_AUTHOR("Guenter Roeck <groeck@chromium.org>"); 6666 MODULE_DESCRIPTION("USB Type-C Port Manager"); 6667 MODULE_LICENSE("GPL"); 6668