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