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