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 <asm/io.h> 9 #include <common.h> 10 #include <dm.h> 11 #include <asm/gpio.h> 12 #include <irq-generic.h> 13 #include <rk_timer_irq.h> 14 #include <power/power_delivery/tcpm.h> 15 #include <power/power_delivery/pd_vdo.h> 16 17 #define FOREACH_STATE(S) \ 18 S(INVALID_STATE), \ 19 S(TOGGLING), \ 20 S(SRC_UNATTACHED), \ 21 S(SRC_ATTACH_WAIT), \ 22 S(SRC_ATTACHED), \ 23 S(SRC_STARTUP), \ 24 S(SRC_SEND_CAPABILITIES), \ 25 S(SRC_SEND_CAPABILITIES_TIMEOUT), \ 26 S(SRC_NEGOTIATE_CAPABILITIES), \ 27 S(SRC_TRANSITION_SUPPLY), \ 28 S(SRC_READY), \ 29 S(SRC_WAIT_NEW_CAPABILITIES), \ 30 \ 31 S(SNK_UNATTACHED), \ 32 S(SNK_ATTACH_WAIT), \ 33 S(SNK_DEBOUNCED), \ 34 S(SNK_ATTACHED), \ 35 S(SNK_STARTUP), \ 36 S(SNK_DISCOVERY), \ 37 S(SNK_DISCOVERY_DEBOUNCE), \ 38 S(SNK_DISCOVERY_DEBOUNCE_DONE), \ 39 S(SNK_WAIT_CAPABILITIES), \ 40 S(SNK_NEGOTIATE_CAPABILITIES), \ 41 S(SNK_NEGOTIATE_PPS_CAPABILITIES), \ 42 S(SNK_TRANSITION_SINK), \ 43 S(SNK_TRANSITION_SINK_VBUS), \ 44 S(SNK_READY), \ 45 \ 46 S(ACC_UNATTACHED), \ 47 S(DEBUG_ACC_ATTACHED), \ 48 S(AUDIO_ACC_ATTACHED), \ 49 S(AUDIO_ACC_DEBOUNCE), \ 50 \ 51 S(HARD_RESET_SEND), \ 52 S(HARD_RESET_START), \ 53 S(SRC_HARD_RESET_VBUS_OFF), \ 54 S(SRC_HARD_RESET_VBUS_ON), \ 55 S(SNK_HARD_RESET_SINK_OFF), \ 56 S(SNK_HARD_RESET_WAIT_VBUS), \ 57 S(SNK_HARD_RESET_SINK_ON), \ 58 \ 59 S(SOFT_RESET), \ 60 S(SRC_SOFT_RESET_WAIT_SNK_TX), \ 61 S(SNK_SOFT_RESET), \ 62 S(SOFT_RESET_SEND), \ 63 \ 64 S(DR_SWAP_ACCEPT), \ 65 S(DR_SWAP_SEND), \ 66 S(DR_SWAP_SEND_TIMEOUT), \ 67 S(DR_SWAP_CANCEL), \ 68 S(DR_SWAP_CHANGE_DR), \ 69 \ 70 S(PR_SWAP_ACCEPT), \ 71 S(PR_SWAP_SEND), \ 72 S(PR_SWAP_SEND_TIMEOUT), \ 73 S(PR_SWAP_CANCEL), \ 74 S(PR_SWAP_START), \ 75 S(PR_SWAP_SRC_SNK_TRANSITION_OFF), \ 76 S(PR_SWAP_SRC_SNK_SOURCE_OFF), \ 77 S(PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED), \ 78 S(PR_SWAP_SRC_SNK_SINK_ON), \ 79 S(PR_SWAP_SNK_SRC_SINK_OFF), \ 80 S(PR_SWAP_SNK_SRC_SOURCE_ON), \ 81 S(PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP), \ 82 \ 83 S(VCONN_SWAP_ACCEPT), \ 84 S(VCONN_SWAP_SEND), \ 85 S(VCONN_SWAP_SEND_TIMEOUT), \ 86 S(VCONN_SWAP_CANCEL), \ 87 S(VCONN_SWAP_START), \ 88 S(VCONN_SWAP_WAIT_FOR_VCONN), \ 89 S(VCONN_SWAP_TURN_ON_VCONN), \ 90 S(VCONN_SWAP_TURN_OFF_VCONN), \ 91 \ 92 S(FR_SWAP_SEND), \ 93 S(FR_SWAP_SEND_TIMEOUT), \ 94 S(FR_SWAP_SNK_SRC_TRANSITION_TO_OFF), \ 95 S(FR_SWAP_SNK_SRC_NEW_SINK_READY), \ 96 S(FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED), \ 97 S(FR_SWAP_CANCEL), \ 98 \ 99 S(SNK_TRY), \ 100 S(SNK_TRY_WAIT), \ 101 S(SNK_TRY_WAIT_DEBOUNCE), \ 102 S(SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS), \ 103 S(SRC_TRYWAIT), \ 104 S(SRC_TRYWAIT_DEBOUNCE), \ 105 S(SRC_TRYWAIT_UNATTACHED), \ 106 \ 107 S(SRC_TRY), \ 108 S(SRC_TRY_WAIT), \ 109 S(SRC_TRY_DEBOUNCE), \ 110 S(SNK_TRYWAIT), \ 111 S(SNK_TRYWAIT_DEBOUNCE), \ 112 S(SNK_TRYWAIT_VBUS), \ 113 S(BIST_RX), \ 114 \ 115 S(GET_STATUS_SEND), \ 116 S(GET_STATUS_SEND_TIMEOUT), \ 117 S(GET_PPS_STATUS_SEND), \ 118 S(GET_PPS_STATUS_SEND_TIMEOUT), \ 119 \ 120 S(GET_SINK_CAP), \ 121 S(GET_SINK_CAP_TIMEOUT), \ 122 \ 123 S(ERROR_RECOVERY), \ 124 S(PORT_RESET), \ 125 S(PORT_RESET_WAIT_OFF), \ 126 \ 127 S(AMS_START), \ 128 S(CHUNK_NOT_SUPP) 129 130 #define FOREACH_AMS(S) \ 131 S(NONE_AMS), \ 132 S(POWER_NEGOTIATION), \ 133 S(GOTOMIN), \ 134 S(SOFT_RESET_AMS), \ 135 S(HARD_RESET), \ 136 S(CABLE_RESET), \ 137 S(GET_SOURCE_CAPABILITIES), \ 138 S(GET_SINK_CAPABILITIES), \ 139 S(POWER_ROLE_SWAP), \ 140 S(FAST_ROLE_SWAP), \ 141 S(DATA_ROLE_SWAP), \ 142 S(VCONN_SWAP), \ 143 S(SOURCE_ALERT), \ 144 S(GETTING_SOURCE_EXTENDED_CAPABILITIES),\ 145 S(GETTING_SOURCE_SINK_STATUS), \ 146 S(GETTING_BATTERY_CAPABILITIES), \ 147 S(GETTING_BATTERY_STATUS), \ 148 S(GETTING_MANUFACTURER_INFORMATION), \ 149 S(SECURITY), \ 150 S(FIRMWARE_UPDATE), \ 151 S(DISCOVER_IDENTITY), \ 152 S(SOURCE_STARTUP_CABLE_PLUG_DISCOVER_IDENTITY), \ 153 S(DISCOVER_SVIDS), \ 154 S(DISCOVER_MODES), \ 155 S(DFP_TO_UFP_ENTER_MODE), \ 156 S(DFP_TO_UFP_EXIT_MODE), \ 157 S(DFP_TO_CABLE_PLUG_ENTER_MODE), \ 158 S(DFP_TO_CABLE_PLUG_EXIT_MODE), \ 159 S(ATTENTION), \ 160 S(BIST), \ 161 S(UNSTRUCTURED_VDMS), \ 162 S(STRUCTURED_VDMS), \ 163 S(COUNTRY_INFO), \ 164 S(COUNTRY_CODES) 165 166 #define GENERATE_ENUM(e) e 167 #define GENERATE_STRING(s) #s 168 #define TCPM_POLL_EVENT_TIME_OUT 2000 169 170 enum tcpm_state { 171 FOREACH_STATE(GENERATE_ENUM) 172 }; 173 174 static const char * const tcpm_states[] = { 175 FOREACH_STATE(GENERATE_STRING) 176 }; 177 178 enum tcpm_ams { 179 FOREACH_AMS(GENERATE_ENUM) 180 }; 181 182 static const char * const tcpm_ams_str[] = { 183 FOREACH_AMS(GENERATE_STRING) 184 }; 185 186 enum vdm_states { 187 VDM_STATE_ERR_BUSY = -3, 188 VDM_STATE_ERR_SEND = -2, 189 VDM_STATE_ERR_TMOUT = -1, 190 VDM_STATE_DONE = 0, 191 /* Anything >0 represents an active state */ 192 VDM_STATE_READY = 1, 193 VDM_STATE_BUSY = 2, 194 VDM_STATE_WAIT_RSP_BUSY = 3, 195 VDM_STATE_SEND_MESSAGE = 4, 196 }; 197 198 enum pd_msg_request { 199 PD_MSG_NONE = 0, 200 PD_MSG_CTRL_REJECT, 201 PD_MSG_CTRL_WAIT, 202 PD_MSG_CTRL_NOT_SUPP, 203 PD_MSG_DATA_SINK_CAP, 204 PD_MSG_DATA_SOURCE_CAP, 205 }; 206 207 enum adev_actions { 208 ADEV_NONE = 0, 209 ADEV_NOTIFY_USB_AND_QUEUE_VDM, 210 ADEV_QUEUE_VDM, 211 ADEV_QUEUE_VDM_SEND_EXIT_MODE_ON_FAIL, 212 ADEV_ATTENTION, 213 }; 214 215 /* 216 * Initial current capability of the new source when vSafe5V is applied during PD3.0 Fast Role Swap. 217 * Based on "Table 6-14 Fixed Supply PDO - Sink" of "USB Power Delivery Specification Revision 3.0, 218 * Version 1.2" 219 */ 220 enum frs_typec_current { 221 FRS_NOT_SUPPORTED, 222 FRS_DEFAULT_POWER, 223 FRS_5V_1P5A, 224 FRS_5V_3A, 225 }; 226 227 /* Events from low level driver */ 228 229 #define TCPM_CC_EVENT BIT(0) 230 #define TCPM_VBUS_EVENT BIT(1) 231 #define TCPM_RESET_EVENT BIT(2) 232 #define TCPM_FRS_EVENT BIT(3) 233 #define TCPM_SOURCING_VBUS BIT(4) 234 235 #define LOG_BUFFER_ENTRIES 1024 236 #define LOG_BUFFER_ENTRY_SIZE 128 237 238 /* Alternate mode support */ 239 240 #define SVID_DISCOVERY_MAX 16 241 #define ALTMODE_DISCOVERY_MAX (SVID_DISCOVERY_MAX * MODE_DISCOVERY_MAX) 242 243 #define GET_SINK_CAP_RETRY_MS 100 244 #define SEND_DISCOVER_RETRY_MS 100 245 246 /* 247 * @min_volt: Actual min voltage at the local port 248 * @req_min_volt: Requested min voltage to the port partner 249 * @max_volt: Actual max voltage at the local port 250 * @req_max_volt: Requested max voltage to the port partner 251 * @max_curr: Actual max current at the local port 252 * @req_max_curr: Requested max current of the port partner 253 * @req_out_volt: Requested output voltage to the port partner 254 * @req_op_curr: Requested operating current to the port partner 255 * @supported: Parter has atleast one APDO hence supports PPS 256 * @active: PPS mode is active 257 */ 258 struct pd_pps_data { 259 u32 min_volt; 260 u32 req_min_volt; 261 u32 max_volt; 262 u32 req_max_volt; 263 u32 max_curr; 264 u32 req_max_curr; 265 u32 req_out_volt; 266 u32 req_op_curr; 267 bool supported; 268 bool active; 269 }; 270 271 enum power_supply_usb_type { 272 POWER_SUPPLY_USB_TYPE_UNKNOWN = 0, 273 POWER_SUPPLY_USB_TYPE_SDP, /* Standard Downstream Port */ 274 POWER_SUPPLY_USB_TYPE_DCP, /* Dedicated Charging Port */ 275 POWER_SUPPLY_USB_TYPE_CDP, /* Charging Downstream Port */ 276 POWER_SUPPLY_USB_TYPE_ACA, /* Accessory Charger Adapters */ 277 POWER_SUPPLY_USB_TYPE_C, /* Type C Port */ 278 POWER_SUPPLY_USB_TYPE_PD, /* Power Delivery Port */ 279 POWER_SUPPLY_USB_TYPE_PD_DRP, /* PD Dual Role Port */ 280 POWER_SUPPLY_USB_TYPE_PD_PPS, /* PD Programmable Power Supply */ 281 POWER_SUPPLY_USB_TYPE_APPLE_BRICK_ID, /* Apple Charging Method */ 282 }; 283 284 struct tcpm_port { 285 struct udevice *dev; 286 struct typec_capability typec_caps; 287 struct tcpc_dev *tcpc; 288 289 enum typec_role vconn_role; 290 enum typec_role pwr_role; 291 enum typec_data_role data_role; 292 enum typec_pwr_opmode pwr_opmode; 293 294 struct usb_pd_identity partner_ident; 295 struct typec_partner_desc partner_desc; 296 struct typec_partner *partner; 297 298 enum typec_cc_status cc_req; 299 300 enum typec_cc_status cc1; 301 enum typec_cc_status cc2; 302 enum typec_cc_polarity polarity; 303 304 bool attached; 305 bool connected; 306 int poll_event_cnt; 307 enum typec_port_type port_type; 308 309 /* 310 * Set to true when vbus is greater than VSAFE5V min. 311 * Set to false when vbus falls below vSinkDisconnect max threshold. 312 */ 313 bool vbus_present; 314 315 /* 316 * Set to true when vbus is less than VSAFE0V max. 317 * Set to false when vbus is greater than VSAFE0V max. 318 */ 319 bool vbus_vsafe0v; 320 321 bool vbus_never_low; 322 bool vbus_source; 323 bool vbus_charge; 324 325 /* Set to true when Discover_Identity Command is expected to be sent in Ready states. */ 326 bool send_discover; 327 bool op_vsafe5v; 328 329 int try_role; 330 int try_snk_count; 331 int try_src_count; 332 333 enum pd_msg_request queued_message; 334 335 enum tcpm_state enter_state; 336 enum tcpm_state prev_state; 337 enum tcpm_state state; 338 enum tcpm_state delayed_state; 339 unsigned long delay_ms; 340 341 spinlock_t pd_event_lock; 342 u32 pd_events; 343 344 bool state_machine_running; 345 /* Set to true when VDM State Machine has following actions. */ 346 bool vdm_sm_running; 347 348 bool tx_complete; 349 enum tcpm_transmit_status tx_status; 350 351 struct mutex swap_lock; /* swap command lock */ 352 bool swap_pending; 353 bool non_pd_role_swap; 354 int swap_status; 355 356 unsigned int negotiated_rev; 357 unsigned int message_id; 358 unsigned int caps_count; 359 unsigned int hard_reset_count; 360 bool pd_capable; 361 bool explicit_contract; 362 unsigned int rx_msgid; 363 364 /* Partner capabilities/requests */ 365 u32 sink_request; 366 u32 source_caps[PDO_MAX_OBJECTS]; 367 unsigned int nr_source_caps; 368 u32 sink_caps[PDO_MAX_OBJECTS]; 369 unsigned int nr_sink_caps; 370 371 /* 372 * whether to wait for the Type-C device to send the DR_SWAP Message flag 373 * For Type-C device with Dual-Role Power and Dual-Role Data, the port side 374 * is used as sink + ufp, then the tcpm framework needs to wait for Type-C 375 * device to initiate DR_swap Message. 376 */ 377 bool wait_dr_swap_Message; 378 379 /* Local capabilities */ 380 u32 src_pdo[PDO_MAX_OBJECTS]; 381 unsigned int nr_src_pdo; 382 u32 snk_pdo[PDO_MAX_OBJECTS]; 383 unsigned int nr_snk_pdo; 384 u32 snk_vdo_v1[VDO_MAX_OBJECTS]; 385 unsigned int nr_snk_vdo_v1; 386 u32 snk_vdo[VDO_MAX_OBJECTS]; 387 unsigned int nr_snk_vdo; 388 389 unsigned int operating_snk_mw; 390 bool update_sink_caps; 391 392 /* Requested current / voltage to the port partner */ 393 u32 req_current_limit; 394 u32 req_supply_voltage; 395 /* Actual current / voltage limit of the local port */ 396 u32 current_limit; 397 u32 supply_voltage; 398 399 enum power_supply_usb_type usb_type; 400 401 u32 bist_request; 402 403 /* PD state for Vendor Defined Messages */ 404 enum vdm_states vdm_state; 405 u32 vdm_retries; 406 /* next Vendor Defined Message to send */ 407 u32 vdo_data[VDO_MAX_SIZE]; 408 u8 vdo_count; 409 /* VDO to retry if UFP responder replied busy */ 410 u32 vdo_retry; 411 412 /* PPS */ 413 struct pd_pps_data pps_data; 414 bool pps_pending; 415 int pps_status; 416 417 /* Deadline in jiffies to exit src_try_wait state */ 418 unsigned long max_wait; 419 420 /* port belongs to a self powered device */ 421 bool self_powered; 422 423 /* Sink FRS */ 424 enum frs_typec_current new_source_frs_current; 425 426 /* Sink caps have been queried */ 427 bool sink_cap_done; 428 429 /* Port is still in tCCDebounce */ 430 bool debouncing; 431 432 /* Collision Avoidance and Atomic Message Sequence */ 433 enum tcpm_state upcoming_state; 434 enum tcpm_ams ams; 435 enum tcpm_ams next_ams; 436 bool in_ams; 437 438 /* Auto vbus discharge status */ 439 bool auto_vbus_discharge_enabled; 440 441 /* 442 * When set, port requests PD_P_SNK_STDBY_MW upon entering SNK_DISCOVERY and 443 * the actual currrent limit after RX of PD_CTRL_PSRDY for PD link, 444 * SNK_READY for non-pd link. 445 */ 446 bool slow_charger_loop; 447 #ifdef CONFIG_DEBUG_FS 448 struct dentry *dentry; 449 struct mutex logbuffer_lock; /* log buffer access lock */ 450 int logbuffer_head; 451 int logbuffer_tail; 452 u8 *logbuffer[LOG_BUFFER_ENTRIES]; 453 #endif 454 }; 455 456 struct pd_rx_event { 457 struct tcpm_port *port; 458 struct pd_message msg; 459 }; 460 461 static const char * const pd_rev[] = { 462 [PD_REV10] = "rev1", 463 [PD_REV20] = "rev2", 464 [PD_REV30] = "rev3", 465 }; 466 467 #define tcpm_cc_is_sink(cc) \ 468 ((cc) == TYPEC_CC_RP_DEF || (cc) == TYPEC_CC_RP_1_5 || \ 469 (cc) == TYPEC_CC_RP_3_0) 470 471 #define tcpm_port_is_sink(port) \ 472 ((tcpm_cc_is_sink((port)->cc1) && !tcpm_cc_is_sink((port)->cc2)) || \ 473 (tcpm_cc_is_sink((port)->cc2) && !tcpm_cc_is_sink((port)->cc1))) 474 475 #define tcpm_cc_is_source(cc) ((cc) == TYPEC_CC_RD) 476 #define tcpm_cc_is_audio(cc) ((cc) == TYPEC_CC_RA) 477 #define tcpm_cc_is_open(cc) ((cc) == TYPEC_CC_OPEN) 478 479 #define tcpm_port_is_source(port) \ 480 ((tcpm_cc_is_source((port)->cc1) && \ 481 !tcpm_cc_is_source((port)->cc2)) || \ 482 (tcpm_cc_is_source((port)->cc2) && \ 483 !tcpm_cc_is_source((port)->cc1))) 484 485 #define tcpm_port_is_debug(port) \ 486 (tcpm_cc_is_source((port)->cc1) && tcpm_cc_is_source((port)->cc2)) 487 488 #define tcpm_port_is_audio(port) \ 489 (tcpm_cc_is_audio((port)->cc1) && tcpm_cc_is_audio((port)->cc2)) 490 491 #define tcpm_port_is_audio_detached(port) \ 492 ((tcpm_cc_is_audio((port)->cc1) && tcpm_cc_is_open((port)->cc2)) || \ 493 (tcpm_cc_is_audio((port)->cc2) && tcpm_cc_is_open((port)->cc1))) 494 495 #define tcpm_try_snk(port) \ 496 ((port)->try_snk_count == 0 && (port)->try_role == TYPEC_SINK && \ 497 (port)->port_type == TYPEC_PORT_DRP) 498 499 #define tcpm_try_src(port) \ 500 ((port)->try_src_count == 0 && (port)->try_role == TYPEC_SOURCE && \ 501 (port)->port_type == TYPEC_PORT_DRP) 502 503 #define tcpm_data_role_for_source(port) \ 504 ((port)->typec_caps.data == TYPEC_PORT_UFP ? \ 505 TYPEC_DEVICE : TYPEC_HOST) 506 507 #define tcpm_data_role_for_sink(port) \ 508 ((port)->typec_caps.data == TYPEC_PORT_DFP ? \ 509 TYPEC_HOST : TYPEC_DEVICE) 510 511 static enum tcpm_state tcpm_default_state(struct tcpm_port *port) 512 { 513 if (port->port_type == TYPEC_PORT_DRP) { 514 if (port->try_role == TYPEC_SINK) 515 return SNK_UNATTACHED; 516 else if (port->try_role == TYPEC_SOURCE) 517 return SRC_UNATTACHED; 518 /* Fall through to return SRC_UNATTACHED */ 519 } else if (port->port_type == TYPEC_PORT_SNK) { 520 return SNK_UNATTACHED; 521 } 522 return SRC_UNATTACHED; 523 } 524 525 static bool tcpm_port_is_disconnected(struct tcpm_port *port) 526 { 527 return (!port->attached && port->cc1 == TYPEC_CC_OPEN && 528 port->cc2 == TYPEC_CC_OPEN) || 529 (port->attached && ((port->polarity == TYPEC_POLARITY_CC1 && 530 port->cc1 == TYPEC_CC_OPEN) || 531 (port->polarity == TYPEC_POLARITY_CC2 && 532 port->cc2 == TYPEC_CC_OPEN))); 533 } 534 535 static void tcpm_set_cc(struct tcpm_port *port, enum typec_cc_status cc) 536 { 537 debug("%s: cc = %d", __func__, cc); 538 port->cc_req = cc; 539 port->tcpc->set_cc(port->tcpc, cc); 540 } 541 542 /* 543 * Determine RP value to set based on maximum current supported 544 * by a port if configured as source. 545 * Returns CC value to report to link partner. 546 */ 547 static enum typec_cc_status tcpm_rp_cc(struct tcpm_port *port) 548 { 549 const u32 *src_pdo = port->src_pdo; 550 int nr_pdo = port->nr_src_pdo; 551 int i; 552 553 /* 554 * Search for first entry with matching voltage. 555 * It should report the maximum supported current. 556 */ 557 for (i = 0; i < nr_pdo; i++) { 558 const u32 pdo = src_pdo[i]; 559 560 if (pdo_type(pdo) == PDO_TYPE_FIXED && 561 pdo_fixed_voltage(pdo) == 5000) { 562 unsigned int curr = pdo_max_current(pdo); 563 564 if (curr >= 3000) 565 return TYPEC_CC_RP_3_0; 566 else if (curr >= 1500) 567 return TYPEC_CC_RP_1_5; 568 return TYPEC_CC_RP_DEF; 569 } 570 } 571 572 return TYPEC_CC_RP_DEF; 573 } 574 575 static int tcpm_pd_transmit(struct tcpm_port *port, 576 enum tcpm_transmit_type type, 577 const struct pd_message *msg) 578 { 579 int ret; 580 int timeout = PD_T_TCPC_TX_TIMEOUT; 581 582 if (msg) 583 debug("PD TX, header: %#x\n", le16_to_cpu(msg->header)); 584 else 585 debug("PD TX, type: %#x\n", type); 586 587 port->tx_complete = false; 588 ret = port->tcpc->pd_transmit(port->tcpc, type, msg, port->negotiated_rev); 589 if (ret < 0) 590 return ret; 591 592 while ((timeout > 0) && (!port->tx_complete)) { 593 port->tcpc->poll_event(port->tcpc); 594 udelay(1000); 595 timeout--; 596 } 597 598 if (!timeout) { 599 printf("%s: pd transmit data timeout\n", __func__); 600 return -ETIMEDOUT; 601 } 602 603 switch (port->tx_status) { 604 case TCPC_TX_SUCCESS: 605 port->message_id = (port->message_id + 1) & PD_HEADER_ID_MASK; 606 break; 607 case TCPC_TX_DISCARDED: 608 ret = -EAGAIN; 609 break; 610 case TCPC_TX_FAILED: 611 default: 612 ret = -EIO; 613 break; 614 } 615 616 return ret; 617 } 618 619 void tcpm_pd_transmit_complete(struct tcpm_port *port, 620 enum tcpm_transmit_status status) 621 { 622 debug("%s: PD TX complete, status: %u\n", __func__, status); 623 port->poll_event_cnt = 0; 624 port->tx_status = status; 625 port->tx_complete = true; 626 } 627 EXPORT_SYMBOL_GPL(tcpm_pd_transmit_complete); 628 629 static int tcpm_set_polarity(struct tcpm_port *port, 630 enum typec_cc_polarity polarity) 631 { 632 int ret; 633 634 debug("%s: polarity %d\n", __func__, polarity); 635 636 ret = port->tcpc->set_polarity(port->tcpc, polarity); 637 if (ret < 0) 638 return ret; 639 640 port->polarity = polarity; 641 642 return 0; 643 } 644 645 static int tcpm_set_vconn(struct tcpm_port *port, bool enable) 646 { 647 int ret; 648 649 debug("%s: vconn = %d\n", __func__, enable); 650 651 ret = port->tcpc->set_vconn(port->tcpc, enable); 652 if (!ret) 653 port->vconn_role = enable ? TYPEC_SOURCE : TYPEC_SINK; 654 655 return ret; 656 } 657 658 static u32 tcpm_get_current_limit(struct tcpm_port *port) 659 { 660 enum typec_cc_status cc; 661 u32 limit; 662 663 cc = port->polarity ? port->cc2 : port->cc1; 664 switch (cc) { 665 case TYPEC_CC_RP_1_5: 666 limit = 1500; 667 break; 668 case TYPEC_CC_RP_3_0: 669 limit = 3000; 670 break; 671 case TYPEC_CC_RP_DEF: 672 default: 673 if (port->tcpc->get_current_limit) 674 limit = port->tcpc->get_current_limit(port->tcpc); 675 else 676 limit = 0; 677 break; 678 } 679 680 return limit; 681 } 682 683 static int tcpm_set_current_limit(struct tcpm_port *port, u32 max_ma, u32 mv) 684 { 685 int ret = -EOPNOTSUPP; 686 687 debug("Setting voltage/current limit %u mV %u mA\n", mv, max_ma); 688 689 port->supply_voltage = mv; 690 port->current_limit = max_ma; 691 692 if (port->tcpc->set_current_limit) 693 ret = port->tcpc->set_current_limit(port->tcpc, max_ma, mv); 694 695 return ret; 696 } 697 698 static int tcpm_set_attached_state(struct tcpm_port *port, bool attached) 699 { 700 return port->tcpc->set_roles(port->tcpc, attached, port->pwr_role, 701 port->data_role); 702 } 703 704 static int tcpm_set_roles(struct tcpm_port *port, bool attached, 705 enum typec_role role, enum typec_data_role data) 706 { 707 #if 0 708 enum typec_orientation orientation; 709 enum usb_role usb_role; 710 #endif 711 int ret; 712 713 #if 0 714 if (port->polarity == TYPEC_POLARITY_CC1) 715 orientation = TYPEC_ORIENTATION_NORMAL; 716 else 717 orientation = TYPEC_ORIENTATION_REVERSE; 718 719 if (data == TYPEC_HOST) 720 usb_role = USB_ROLE_HOST; 721 else 722 usb_role = USB_ROLE_DEVICE; 723 724 ret = tcpm_mux_set(port, TYPEC_STATE_USB, usb_role, orientation); 725 if (ret < 0) 726 return ret; 727 #endif 728 729 ret = port->tcpc->set_roles(port->tcpc, attached, role, data); 730 if (ret < 0) 731 return ret; 732 733 port->pwr_role = role; 734 port->data_role = data; 735 #if 0 736 typec_set_data_role(port->typec_port, data); 737 typec_set_pwr_role(port->typec_port, role); 738 #endif 739 740 return 0; 741 } 742 743 static int tcpm_pd_send_source_caps(struct tcpm_port *port) 744 { 745 struct pd_message msg; 746 int i; 747 748 memset(&msg, 0, sizeof(msg)); 749 750 if (!port->nr_src_pdo) { 751 /* No source capabilities defined, sink only */ 752 msg.header = PD_HEADER_LE(PD_CTRL_REJECT, 753 port->pwr_role, 754 port->data_role, 755 port->negotiated_rev, 756 port->message_id, 0); 757 } else { 758 msg.header = PD_HEADER_LE(PD_DATA_SOURCE_CAP, 759 port->pwr_role, 760 port->data_role, 761 port->negotiated_rev, 762 port->message_id, 763 port->nr_src_pdo); 764 } 765 766 for (i = 0; i < port->nr_src_pdo; i++) 767 msg.payload[i] = cpu_to_le32(port->src_pdo[i]); 768 769 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 770 } 771 772 static int tcpm_pd_send_sink_caps(struct tcpm_port *port) 773 { 774 struct pd_message msg; 775 unsigned int i; 776 777 memset(&msg, 0, sizeof(msg)); 778 779 if (!port->nr_snk_pdo) { 780 /* No sink capabilities defined, source only */ 781 msg.header = PD_HEADER_LE(PD_CTRL_REJECT, 782 port->pwr_role, 783 port->data_role, 784 port->negotiated_rev, 785 port->message_id, 0); 786 } else { 787 msg.header = PD_HEADER_LE(PD_DATA_SINK_CAP, 788 port->pwr_role, 789 port->data_role, 790 port->negotiated_rev, 791 port->message_id, 792 port->nr_snk_pdo); 793 } 794 795 for (i = 0; i < port->nr_snk_pdo; i++) 796 msg.payload[i] = cpu_to_le32(port->snk_pdo[i]); 797 798 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 799 } 800 801 static void tcpm_state_machine(struct tcpm_port *port); 802 static void tcpm_timer_uninit(struct tcpm_port *port); 803 static void tcpm_timer_irq(int irq, void *data) 804 { 805 struct tcpm_port *port = data; 806 807 writel(TIMER_CLR_INT, TIMER_BASE + TIMER_INTSTATUS); 808 tcpm_timer_uninit(port); 809 tcpm_state_machine(port); 810 } 811 812 static void tcpm_timer_init(struct tcpm_port *port, uint32_t ms) 813 { 814 uint64_t period = 24000ULL * ms; 815 816 /* Disable before conifg */ 817 writel(0, TIMER_BASE + TIMER_CTRL); 818 819 /* Config */ 820 writel((uint32_t)period, TIMER_BASE + TIMER_LOAD_COUNT0); 821 writel((uint32_t)(period >> 32), TIMER_BASE + TIMER_LOAD_COUNT1); 822 writel(TIMER_CLR_INT, TIMER_BASE + TIMER_INTSTATUS); 823 writel(TIMER_EN | TIMER_INT_EN, TIMER_BASE + TIMER_CTRL); 824 825 /* IRQ */ 826 irq_install_handler(TIMER_IRQ, 827 (interrupt_handler_t *)tcpm_timer_irq, port); 828 irq_handler_enable(TIMER_IRQ); 829 } 830 831 static void tcpm_timer_uninit(struct tcpm_port *port) 832 { 833 writel(0, TIMER_BASE + TIMER_CTRL); 834 835 irq_handler_disable(TIMER_IRQ); 836 irq_free_handler(TIMER_IRQ); 837 } 838 839 static void mod_tcpm_delayed_work(struct tcpm_port *port, unsigned int delay_ms) 840 { 841 if (delay_ms) { 842 tcpm_timer_init(port, delay_ms); 843 } else { 844 tcpm_timer_uninit(port); 845 tcpm_state_machine(port); 846 } 847 } 848 849 static void tcpm_set_state(struct tcpm_port *port, enum tcpm_state state, 850 unsigned int delay_ms) 851 { 852 debug("%s: line = %d, delay_ms = %d, set state = %s\n", 853 __func__, __LINE__, delay_ms, tcpm_states[state]); 854 855 if (delay_ms) { 856 debug("pending state change %s -> %s @ %u ms [%s]\n", 857 tcpm_states[port->state], tcpm_states[state], delay_ms, 858 pd_rev[port->negotiated_rev]); 859 port->delayed_state = state; 860 mod_tcpm_delayed_work(port, delay_ms); 861 port->delay_ms = delay_ms; 862 } else { 863 debug("state change %s -> %s\n", 864 tcpm_states[port->state], tcpm_states[state]); 865 port->delayed_state = INVALID_STATE; 866 port->prev_state = port->state; 867 port->state = state; 868 /* 869 * Don't re-queue the state machine work item if we're currently 870 * in the state machine and we're immediately changing states. 871 * tcpm_state_machine_work() will continue running the state 872 * machine. 873 */ 874 if (!port->state_machine_running) 875 mod_tcpm_delayed_work(port, 0); 876 } 877 } 878 879 static void tcpm_set_state_cond(struct tcpm_port *port, enum tcpm_state state, 880 unsigned int delay_ms) 881 { 882 if (port->enter_state == port->state) 883 tcpm_set_state(port, state, delay_ms); 884 else 885 debug("skipped %sstate change %s -> %s [%u ms], context state %s [%s %s]\n", 886 delay_ms ? "delayed " : "", 887 tcpm_states[port->state], tcpm_states[state], 888 delay_ms, tcpm_states[port->enter_state], 889 pd_rev[port->negotiated_rev], tcpm_ams_str[port->ams]); 890 } 891 892 static void tcpm_queue_message(struct tcpm_port *port, 893 enum pd_msg_request message) 894 { 895 port->queued_message = message; 896 mod_tcpm_delayed_work(port, 0); 897 } 898 899 #if 0 900 static void tcpm_pd_handle_msg(struct tcpm_port *port, 901 enum pd_msg_request message, 902 enum tcpm_ams ams); 903 #endif 904 905 enum pdo_err { 906 PDO_NO_ERR, 907 PDO_ERR_NO_VSAFE5V, 908 PDO_ERR_VSAFE5V_NOT_FIRST, 909 PDO_ERR_PDO_TYPE_NOT_IN_ORDER, 910 PDO_ERR_FIXED_NOT_SORTED, 911 PDO_ERR_VARIABLE_BATT_NOT_SORTED, 912 PDO_ERR_DUPE_PDO, 913 PDO_ERR_PPS_APDO_NOT_SORTED, 914 PDO_ERR_DUPE_PPS_APDO, 915 }; 916 917 static const char * const pdo_err_msg[] = { 918 [PDO_ERR_NO_VSAFE5V] = 919 " err: source/sink caps should atleast have vSafe5V", 920 [PDO_ERR_VSAFE5V_NOT_FIRST] = 921 " err: vSafe5V Fixed Supply Object Shall always be the first object", 922 [PDO_ERR_PDO_TYPE_NOT_IN_ORDER] = 923 " err: PDOs should be in the following order: Fixed; Battery; Variable", 924 [PDO_ERR_FIXED_NOT_SORTED] = 925 " err: Fixed supply pdos should be in increasing order of their fixed voltage", 926 [PDO_ERR_VARIABLE_BATT_NOT_SORTED] = 927 " err: Variable/Battery supply pdos should be in increasing order of their minimum voltage", 928 [PDO_ERR_DUPE_PDO] = 929 " err: Variable/Batt supply pdos cannot have same min/max voltage", 930 [PDO_ERR_PPS_APDO_NOT_SORTED] = 931 " err: Programmable power supply apdos should be in increasing order of their maximum voltage", 932 [PDO_ERR_DUPE_PPS_APDO] = 933 " err: Programmable power supply apdos cannot have same min/max voltage and max current", 934 }; 935 936 static enum pdo_err tcpm_caps_err(struct tcpm_port *port, const u32 *pdo, 937 unsigned int nr_pdo) 938 { 939 unsigned int i; 940 941 /* Should at least contain vSafe5v */ 942 if (nr_pdo < 1) 943 return PDO_ERR_NO_VSAFE5V; 944 945 /* The vSafe5V Fixed Supply Object Shall always be the first object */ 946 if (pdo_type(pdo[0]) != PDO_TYPE_FIXED || 947 pdo_fixed_voltage(pdo[0]) != VSAFE5V) 948 return PDO_ERR_VSAFE5V_NOT_FIRST; 949 950 for (i = 1; i < nr_pdo; i++) { 951 if (pdo_type(pdo[i]) < pdo_type(pdo[i - 1])) { 952 return PDO_ERR_PDO_TYPE_NOT_IN_ORDER; 953 } else if (pdo_type(pdo[i]) == pdo_type(pdo[i - 1])) { 954 enum pd_pdo_type type = pdo_type(pdo[i]); 955 956 switch (type) { 957 /* 958 * The remaining Fixed Supply Objects, if 959 * present, shall be sent in voltage order; 960 * lowest to highest. 961 */ 962 case PDO_TYPE_FIXED: 963 if (pdo_fixed_voltage(pdo[i]) <= 964 pdo_fixed_voltage(pdo[i - 1])) 965 return PDO_ERR_FIXED_NOT_SORTED; 966 break; 967 /* 968 * The Battery Supply Objects and Variable 969 * supply, if present shall be sent in Minimum 970 * Voltage order; lowest to highest. 971 */ 972 case PDO_TYPE_VAR: 973 case PDO_TYPE_BATT: 974 if (pdo_min_voltage(pdo[i]) < 975 pdo_min_voltage(pdo[i - 1])) 976 return PDO_ERR_VARIABLE_BATT_NOT_SORTED; 977 else if ((pdo_min_voltage(pdo[i]) == 978 pdo_min_voltage(pdo[i - 1])) && 979 (pdo_max_voltage(pdo[i]) == 980 pdo_max_voltage(pdo[i - 1]))) 981 return PDO_ERR_DUPE_PDO; 982 break; 983 /* 984 * The Programmable Power Supply APDOs, if present, 985 * shall be sent in Maximum Voltage order; 986 * lowest to highest. 987 */ 988 case PDO_TYPE_APDO: 989 if (pdo_apdo_type(pdo[i]) != APDO_TYPE_PPS) 990 break; 991 992 if (pdo_pps_apdo_max_voltage(pdo[i]) < 993 pdo_pps_apdo_max_voltage(pdo[i - 1])) 994 return PDO_ERR_PPS_APDO_NOT_SORTED; 995 else if (pdo_pps_apdo_min_voltage(pdo[i]) == 996 pdo_pps_apdo_min_voltage(pdo[i - 1]) && 997 pdo_pps_apdo_max_voltage(pdo[i]) == 998 pdo_pps_apdo_max_voltage(pdo[i - 1]) && 999 pdo_pps_apdo_max_current(pdo[i]) == 1000 pdo_pps_apdo_max_current(pdo[i - 1])) 1001 return PDO_ERR_DUPE_PPS_APDO; 1002 break; 1003 default: 1004 printf("%s: Unknown pdo type\n", __func__); 1005 } 1006 } 1007 } 1008 1009 return PDO_NO_ERR; 1010 } 1011 1012 static int tcpm_validate_caps(struct tcpm_port *port, const u32 *pdo, 1013 unsigned int nr_pdo) 1014 { 1015 enum pdo_err err_index = tcpm_caps_err(port, pdo, nr_pdo); 1016 1017 if (err_index != PDO_NO_ERR) { 1018 printf("%s", pdo_err_msg[err_index]); 1019 return -EINVAL; 1020 } 1021 1022 return 0; 1023 } 1024 1025 /* 1026 * PD (data, control) command handling functions 1027 */ 1028 static inline enum tcpm_state ready_state(struct tcpm_port *port) 1029 { 1030 if (port->pwr_role == TYPEC_SOURCE) 1031 return SRC_READY; 1032 else 1033 return SNK_READY; 1034 } 1035 1036 static int tcpm_pd_send_control(struct tcpm_port *port, 1037 enum pd_ctrl_msg_type type); 1038 1039 #if 0 1040 static void tcpm_pd_handle_msg(struct tcpm_port *port, 1041 enum pd_msg_request message, 1042 enum tcpm_ams ams) 1043 { 1044 switch (port->state) { 1045 case SRC_READY: 1046 case SNK_READY: 1047 port->ams = ams; 1048 tcpm_queue_message(port, message); 1049 break; 1050 /* PD 3.0 Spec 8.3.3.4.1.1 and 6.8.1 */ 1051 case SNK_TRANSITION_SINK: 1052 case SNK_TRANSITION_SINK_VBUS: 1053 case SRC_TRANSITION_SUPPLY: 1054 tcpm_set_state(port, HARD_RESET_SEND, 0); 1055 break; 1056 default: 1057 if (!tcpm_ams_interruptible(port)) { 1058 tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ? 1059 SRC_SOFT_RESET_WAIT_SNK_TX : 1060 SNK_SOFT_RESET, 1061 0); 1062 } else { 1063 port->next_ams = ams; 1064 tcpm_set_state(port, ready_state(port), 0); 1065 /* 6.8.1 process the Message */ 1066 tcpm_queue_message(port, message); 1067 } 1068 break; 1069 } 1070 } 1071 #endif 1072 1073 static void tcpm_pd_data_request(struct tcpm_port *port, 1074 const struct pd_message *msg) 1075 { 1076 enum pd_data_msg_type type = pd_header_type_le(msg->header); 1077 unsigned int cnt = pd_header_cnt_le(msg->header); 1078 unsigned int rev = pd_header_rev_le(msg->header); 1079 unsigned int i; 1080 1081 switch (type) { 1082 case PD_DATA_SOURCE_CAP: 1083 for (i = 0; i < cnt; i++) 1084 port->source_caps[i] = le32_to_cpu(msg->payload[i]); 1085 1086 port->nr_source_caps = cnt; 1087 1088 tcpm_validate_caps(port, port->source_caps, 1089 port->nr_source_caps); 1090 1091 /* 1092 * Adjust revision in subsequent message headers, as required, 1093 * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't 1094 * support Rev 1.0 so just do nothing in that scenario. 1095 */ 1096 if (rev == PD_REV10) { 1097 break; 1098 } 1099 1100 if (rev < PD_MAX_REV) 1101 port->negotiated_rev = rev; 1102 1103 if ((pdo_type(port->source_caps[0]) == PDO_TYPE_FIXED) && 1104 (port->source_caps[0] & PDO_FIXED_DUAL_ROLE) && 1105 (port->source_caps[0] & PDO_FIXED_DATA_SWAP)) { 1106 /* Dual role power and data, eg: self-powered Type-C */ 1107 port->wait_dr_swap_Message = true; 1108 } else { 1109 /* Non-Dual role power, eg: adapter */ 1110 port->wait_dr_swap_Message = false; 1111 } 1112 1113 /* 1114 * This message may be received even if VBUS is not 1115 * present. This is quite unexpected; see USB PD 1116 * specification, sections 8.3.3.6.3.1 and 8.3.3.6.3.2. 1117 * However, at the same time, we must be ready to 1118 * receive this message and respond to it 15ms after 1119 * receiving PS_RDY during power swap operations, no matter 1120 * if VBUS is available or not (USB PD specification, 1121 * section 6.5.9.2). 1122 * So we need to accept the message either way, 1123 * but be prepared to keep waiting for VBUS after it was 1124 * handled. 1125 */ 1126 tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0); 1127 break; 1128 case PD_DATA_REQUEST: 1129 /* 1130 * Adjust revision in subsequent message headers, as required, 1131 * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't 1132 * support Rev 1.0 so just reject in that scenario. 1133 */ 1134 if (rev == PD_REV10) { 1135 tcpm_queue_message(port, PD_MSG_CTRL_REJECT); 1136 break; 1137 } 1138 1139 if (rev < PD_MAX_REV) 1140 port->negotiated_rev = rev; 1141 1142 port->sink_request = le32_to_cpu(msg->payload[0]); 1143 1144 tcpm_set_state(port, SRC_NEGOTIATE_CAPABILITIES, 0); 1145 break; 1146 case PD_DATA_SINK_CAP: 1147 /* We don't do anything with this at the moment... */ 1148 for (i = 0; i < cnt; i++) 1149 port->sink_caps[i] = le32_to_cpu(msg->payload[i]); 1150 1151 port->nr_sink_caps = cnt; 1152 break; 1153 default: 1154 break; 1155 } 1156 } 1157 1158 static void tcpm_pd_ctrl_request(struct tcpm_port *port, 1159 const struct pd_message *msg) 1160 { 1161 enum pd_ctrl_msg_type type = pd_header_type_le(msg->header); 1162 enum tcpm_state next_state; 1163 1164 switch (type) { 1165 case PD_CTRL_GOOD_CRC: 1166 case PD_CTRL_PING: 1167 break; 1168 case PD_CTRL_GET_SOURCE_CAP: 1169 switch (port->state) { 1170 case SRC_READY: 1171 case SNK_READY: 1172 tcpm_queue_message(port, PD_MSG_DATA_SOURCE_CAP); 1173 break; 1174 default: 1175 tcpm_queue_message(port, PD_MSG_CTRL_REJECT); 1176 break; 1177 } 1178 break; 1179 case PD_CTRL_GET_SINK_CAP: 1180 switch (port->state) { 1181 case SRC_READY: 1182 case SNK_READY: 1183 tcpm_queue_message(port, PD_MSG_DATA_SINK_CAP); 1184 break; 1185 default: 1186 tcpm_queue_message(port, PD_MSG_CTRL_REJECT); 1187 break; 1188 } 1189 break; 1190 case PD_CTRL_GOTO_MIN: 1191 break; 1192 case PD_CTRL_PS_RDY: 1193 switch (port->state) { 1194 case SNK_TRANSITION_SINK: 1195 if (port->vbus_present) { 1196 tcpm_set_current_limit(port, 1197 port->req_current_limit, 1198 port->req_supply_voltage); 1199 port->explicit_contract = true; 1200 tcpm_set_state(port, SNK_READY, 0); 1201 } else { 1202 /* 1203 * Seen after power swap. Keep waiting for VBUS 1204 * in a transitional state. 1205 */ 1206 tcpm_set_state(port, 1207 SNK_TRANSITION_SINK_VBUS, 0); 1208 } 1209 break; 1210 default: 1211 break; 1212 } 1213 break; 1214 case PD_CTRL_REJECT: 1215 case PD_CTRL_WAIT: 1216 case PD_CTRL_NOT_SUPP: 1217 switch (port->state) { 1218 case SNK_NEGOTIATE_CAPABILITIES: 1219 /* USB PD specification, Figure 8-43 */ 1220 if (port->explicit_contract) 1221 next_state = SNK_READY; 1222 else 1223 next_state = SNK_WAIT_CAPABILITIES; 1224 1225 tcpm_set_state(port, next_state, 0); 1226 break; 1227 case SNK_NEGOTIATE_PPS_CAPABILITIES: 1228 /* Revert data back from any requested PPS updates */ 1229 port->pps_data.req_out_volt = port->supply_voltage; 1230 port->pps_data.req_op_curr = port->current_limit; 1231 port->pps_status = (type == PD_CTRL_WAIT ? 1232 -EAGAIN : -EOPNOTSUPP); 1233 tcpm_set_state(port, SNK_READY, 0); 1234 break; 1235 default: 1236 break; 1237 } 1238 break; 1239 case PD_CTRL_ACCEPT: 1240 switch (port->state) { 1241 case SNK_NEGOTIATE_CAPABILITIES: 1242 port->pps_data.active = false; 1243 tcpm_set_state(port, SNK_TRANSITION_SINK, 0); 1244 break; 1245 case SNK_NEGOTIATE_PPS_CAPABILITIES: 1246 port->pps_data.active = true; 1247 /* ???? */ 1248 port->pps_data.min_volt = port->pps_data.req_min_volt; 1249 port->pps_data.max_volt = port->pps_data.req_max_volt; 1250 port->pps_data.max_curr = port->pps_data.req_max_curr; 1251 port->req_supply_voltage = port->pps_data.req_out_volt; 1252 port->req_current_limit = port->pps_data.req_op_curr; 1253 tcpm_set_state(port, SNK_TRANSITION_SINK, 0); 1254 break; 1255 case SOFT_RESET_SEND: 1256 port->message_id = 0; 1257 port->rx_msgid = -1; 1258 if (port->pwr_role == TYPEC_SOURCE) 1259 next_state = SRC_SEND_CAPABILITIES; 1260 else 1261 next_state = SNK_WAIT_CAPABILITIES; 1262 tcpm_set_state(port, next_state, 0); 1263 break; 1264 default: 1265 break; 1266 } 1267 break; 1268 case PD_CTRL_SOFT_RESET: 1269 tcpm_set_state(port, SOFT_RESET, 0); 1270 break; 1271 case PD_CTRL_DR_SWAP: 1272 if (port->port_type != TYPEC_PORT_DRP) { 1273 tcpm_queue_message(port, PD_MSG_CTRL_REJECT); 1274 break; 1275 } 1276 /* 1277 * XXX 1278 * 6.3.9: If an alternate mode is active, a request to swap 1279 * alternate modes shall trigger a port reset. 1280 */ 1281 switch (port->state) { 1282 case SRC_READY: 1283 case SNK_READY: 1284 #if 0 1285 if (port->vdm_sm_running) { 1286 tcpm_queue_message(port, PD_MSG_CTRL_WAIT); 1287 break; 1288 } 1289 #endif 1290 tcpm_set_state(port, DR_SWAP_ACCEPT, 0); 1291 break; 1292 default: 1293 tcpm_queue_message(port, PD_MSG_CTRL_WAIT); 1294 break; 1295 } 1296 break; 1297 case PD_CTRL_PR_SWAP: 1298 case PD_CTRL_VCONN_SWAP: 1299 case PD_CTRL_GET_SOURCE_CAP_EXT: 1300 case PD_CTRL_GET_STATUS: 1301 case PD_CTRL_FR_SWAP: 1302 case PD_CTRL_GET_PPS_STATUS: 1303 case PD_CTRL_GET_COUNTRY_CODES: 1304 /* Currently not supported */ 1305 printf("Currently not supported type %#x \n", type); 1306 tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP); 1307 break; 1308 default: 1309 printf("Unrecognized ctrl message type %#x\n", type); 1310 break; 1311 } 1312 } 1313 1314 #if 0 1315 static void tcpm_pd_ext_msg_request(struct tcpm_port *port, 1316 const struct pd_message *msg) 1317 { 1318 enum pd_ext_msg_type type = pd_header_type_le(msg->header); 1319 unsigned int data_size = pd_ext_header_data_size_le(msg->ext_msg.header); 1320 1321 if (!(le16_to_cpu(msg->ext_msg.header) & PD_EXT_HDR_CHUNKED)) { 1322 tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS); 1323 printf("Unchunked extended messages unsupported\n"); 1324 return; 1325 } 1326 1327 if (data_size > PD_EXT_MAX_CHUNK_DATA) { 1328 tcpm_pd_handle_state(port, CHUNK_NOT_SUPP, NONE_AMS, PD_T_CHUNK_NOT_SUPP); 1329 printf("Chunk handling not yet supported\n"); 1330 return; 1331 } 1332 1333 switch (type) { 1334 case PD_EXT_STATUS: 1335 case PD_EXT_PPS_STATUS: 1336 tcpm_set_state(port, ready_state(port), 0); 1337 } 1338 break; 1339 case PD_EXT_SOURCE_CAP_EXT: 1340 case PD_EXT_GET_BATT_CAP: 1341 case PD_EXT_GET_BATT_STATUS: 1342 case PD_EXT_BATT_CAP: 1343 case PD_EXT_GET_MANUFACTURER_INFO: 1344 case PD_EXT_MANUFACTURER_INFO: 1345 case PD_EXT_SECURITY_REQUEST: 1346 case PD_EXT_SECURITY_RESPONSE: 1347 case PD_EXT_FW_UPDATE_REQUEST: 1348 case PD_EXT_FW_UPDATE_RESPONSE: 1349 case PD_EXT_COUNTRY_INFO: 1350 case PD_EXT_COUNTRY_CODES: 1351 tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS); 1352 break; 1353 default: 1354 tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS); 1355 printf("Unrecognized extended message type %#x\n", type); 1356 break; 1357 } 1358 } 1359 #endif 1360 1361 static void tcpm_pd_rx_handler(struct tcpm_port *port, 1362 struct pd_rx_event *event) 1363 { 1364 const struct pd_message *msg = &event->msg; 1365 unsigned int cnt = pd_header_cnt_le(msg->header); 1366 1367 debug("PD RX, header: %#x [%d]\n", le16_to_cpu(msg->header), 1368 port->attached); 1369 1370 if (port->attached) { 1371 enum pd_ctrl_msg_type type = pd_header_type_le(msg->header); 1372 unsigned int msgid = pd_header_msgid_le(msg->header); 1373 1374 /* 1375 * USB PD standard, 6.6.1.2: 1376 * "... if MessageID value in a received Message is the 1377 * same as the stored value, the receiver shall return a 1378 * GoodCRC Message with that MessageID value and drop 1379 * the Message (this is a retry of an already received 1380 * Message). Note: this shall not apply to the Soft_Reset 1381 * Message which always has a MessageID value of zero." 1382 */ 1383 if (msgid == port->rx_msgid && type != PD_CTRL_SOFT_RESET) 1384 goto done; 1385 port->rx_msgid = msgid; 1386 1387 /* 1388 * If both ends believe to be DFP/host, we have a data role 1389 * mismatch. 1390 */ 1391 if (!!(le16_to_cpu(msg->header) & PD_HEADER_DATA_ROLE) == 1392 (port->data_role == TYPEC_HOST)) { 1393 printf("Data role mismatch, initiating error recovery\n"); 1394 tcpm_set_state(port, ERROR_RECOVERY, 0); 1395 } else { 1396 if (cnt) 1397 tcpm_pd_data_request(port, msg); 1398 else 1399 tcpm_pd_ctrl_request(port, msg); 1400 } 1401 } 1402 1403 done: 1404 kfree(event); 1405 } 1406 1407 void tcpm_pd_receive(struct tcpm_port *port, const struct pd_message *msg) 1408 { 1409 struct pd_rx_event *event; 1410 1411 port->poll_event_cnt = 0; 1412 event = kzalloc(sizeof(*event), GFP_ATOMIC); 1413 if (!event) 1414 return; 1415 1416 event->port = port; 1417 memcpy(&event->msg, msg, sizeof(*msg)); 1418 tcpm_pd_rx_handler(port, event); 1419 } 1420 EXPORT_SYMBOL_GPL(tcpm_pd_receive); 1421 1422 static int tcpm_pd_send_control(struct tcpm_port *port, 1423 enum pd_ctrl_msg_type type) 1424 { 1425 struct pd_message msg; 1426 1427 memset(&msg, 0, sizeof(msg)); 1428 msg.header = PD_HEADER_LE(type, port->pwr_role, 1429 port->data_role, 1430 port->negotiated_rev, 1431 port->message_id, 0); 1432 1433 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 1434 } 1435 1436 /* 1437 * Send queued message without affecting state. 1438 * Return true if state machine should go back to sleep, 1439 * false otherwise. 1440 */ 1441 static bool tcpm_send_queued_message(struct tcpm_port *port) 1442 { 1443 enum pd_msg_request queued_message; 1444 1445 do { 1446 queued_message = port->queued_message; 1447 port->queued_message = PD_MSG_NONE; 1448 1449 switch (queued_message) { 1450 case PD_MSG_CTRL_WAIT: 1451 tcpm_pd_send_control(port, PD_CTRL_WAIT); 1452 break; 1453 case PD_MSG_CTRL_REJECT: 1454 tcpm_pd_send_control(port, PD_CTRL_REJECT); 1455 break; 1456 case PD_MSG_CTRL_NOT_SUPP: 1457 tcpm_pd_send_control(port, PD_CTRL_NOT_SUPP); 1458 break; 1459 case PD_MSG_DATA_SINK_CAP: 1460 tcpm_pd_send_sink_caps(port); 1461 break; 1462 case PD_MSG_DATA_SOURCE_CAP: 1463 tcpm_pd_send_source_caps(port); 1464 break; 1465 default: 1466 break; 1467 } 1468 } while (port->queued_message != PD_MSG_NONE); 1469 1470 #if 0 1471 /* ??? */ 1472 if (port->delayed_state != INVALID_STATE) { 1473 if (ktime_after(port->delayed_runtime, ktime_get())) { 1474 mod_tcpm_delayed_work(port, ktime_to_ms(ktime_sub(port->delayed_runtime, 1475 ktime_get()))); 1476 return true; 1477 } 1478 port->delayed_state = INVALID_STATE; 1479 } 1480 #endif 1481 return false; 1482 } 1483 1484 static int tcpm_pd_check_request(struct tcpm_port *port) 1485 { 1486 u32 pdo, rdo = port->sink_request; 1487 unsigned int max, op, pdo_max, index; 1488 enum pd_pdo_type type; 1489 1490 index = rdo_index(rdo); 1491 if (!index || index > port->nr_src_pdo) 1492 return -EINVAL; 1493 1494 pdo = port->src_pdo[index - 1]; 1495 type = pdo_type(pdo); 1496 switch (type) { 1497 case PDO_TYPE_FIXED: 1498 case PDO_TYPE_VAR: 1499 max = rdo_max_current(rdo); 1500 op = rdo_op_current(rdo); 1501 pdo_max = pdo_max_current(pdo); 1502 1503 if (op > pdo_max) 1504 return -EINVAL; 1505 if (max > pdo_max && !(rdo & RDO_CAP_MISMATCH)) 1506 return -EINVAL; 1507 1508 if (type == PDO_TYPE_FIXED) 1509 debug("Requested %u mV, %u mA for %u / %u mA\n", 1510 pdo_fixed_voltage(pdo), pdo_max, op, max); 1511 else 1512 debug("Requested %u -> %u mV, %u mA for %u / %u mA\n", 1513 pdo_min_voltage(pdo), pdo_max_voltage(pdo), 1514 pdo_max, op, max); 1515 break; 1516 case PDO_TYPE_BATT: 1517 max = rdo_max_power(rdo); 1518 op = rdo_op_power(rdo); 1519 pdo_max = pdo_max_power(pdo); 1520 1521 if (op > pdo_max) 1522 return -EINVAL; 1523 if (max > pdo_max && !(rdo & RDO_CAP_MISMATCH)) 1524 return -EINVAL; 1525 printf("Requested %u -> %u mV, %u mW for %u / %u mW\n", 1526 pdo_min_voltage(pdo), pdo_max_voltage(pdo), 1527 pdo_max, op, max); 1528 break; 1529 default: 1530 return -EINVAL; 1531 } 1532 1533 port->op_vsafe5v = index == 1; 1534 1535 return 0; 1536 } 1537 1538 #define min_power(x, y) min(pdo_max_power(x), pdo_max_power(y)) 1539 #define min_current(x, y) min(pdo_max_current(x), pdo_max_current(y)) 1540 1541 static int tcpm_pd_select_pdo(struct tcpm_port *port, int *sink_pdo, 1542 int *src_pdo) 1543 { 1544 unsigned int i, j, max_src_mv = 0, min_src_mv = 0, max_mw = 0, 1545 max_mv = 0, src_mw = 0, src_ma = 0, max_snk_mv = 0, 1546 min_snk_mv = 0; 1547 int ret = -EINVAL; 1548 1549 port->pps_data.supported = false; 1550 port->usb_type = POWER_SUPPLY_USB_TYPE_PD; 1551 1552 /* 1553 * Select the source PDO providing the most power which has a 1554 * matchig sink cap. 1555 */ 1556 for (i = 0; i < port->nr_source_caps; i++) { 1557 u32 pdo = port->source_caps[i]; 1558 enum pd_pdo_type type = pdo_type(pdo); 1559 1560 switch (type) { 1561 case PDO_TYPE_FIXED: 1562 max_src_mv = pdo_fixed_voltage(pdo); 1563 min_src_mv = max_src_mv; 1564 break; 1565 case PDO_TYPE_BATT: 1566 case PDO_TYPE_VAR: 1567 max_src_mv = pdo_max_voltage(pdo); 1568 min_src_mv = pdo_min_voltage(pdo); 1569 break; 1570 case PDO_TYPE_APDO: 1571 if (pdo_apdo_type(pdo) == APDO_TYPE_PPS) { 1572 port->pps_data.supported = true; 1573 port->usb_type = 1574 POWER_SUPPLY_USB_TYPE_PD_PPS; 1575 } 1576 continue; 1577 default: 1578 printf("Invalid source PDO type, ignoring\n"); 1579 continue; 1580 } 1581 1582 switch (type) { 1583 case PDO_TYPE_FIXED: 1584 case PDO_TYPE_VAR: 1585 src_ma = pdo_max_current(pdo); 1586 src_mw = src_ma * min_src_mv / 1000; 1587 break; 1588 case PDO_TYPE_BATT: 1589 src_mw = pdo_max_power(pdo); 1590 break; 1591 case PDO_TYPE_APDO: 1592 continue; 1593 default: 1594 printf("Invalid source PDO type, ignoring\n"); 1595 continue; 1596 } 1597 1598 for (j = 0; j < port->nr_snk_pdo; j++) { 1599 pdo = port->snk_pdo[j]; 1600 1601 switch (pdo_type(pdo)) { 1602 case PDO_TYPE_FIXED: 1603 max_snk_mv = pdo_fixed_voltage(pdo); 1604 min_snk_mv = max_snk_mv; 1605 break; 1606 case PDO_TYPE_BATT: 1607 case PDO_TYPE_VAR: 1608 max_snk_mv = pdo_max_voltage(pdo); 1609 min_snk_mv = pdo_min_voltage(pdo); 1610 break; 1611 case PDO_TYPE_APDO: 1612 continue; 1613 default: 1614 printf("Invalid sink PDO type, ignoring\n"); 1615 continue; 1616 } 1617 1618 if (max_src_mv <= max_snk_mv && 1619 min_src_mv >= min_snk_mv) { 1620 /* Prefer higher voltages if available */ 1621 if ((src_mw == max_mw && min_src_mv > max_mv) || 1622 src_mw > max_mw) { 1623 *src_pdo = i; 1624 *sink_pdo = j; 1625 max_mw = src_mw; 1626 max_mv = min_src_mv; 1627 ret = 0; 1628 } 1629 } 1630 } 1631 } 1632 1633 return ret; 1634 } 1635 1636 #define min_pps_apdo_current(x, y) \ 1637 min(pdo_pps_apdo_max_current(x), pdo_pps_apdo_max_current(y)) 1638 1639 static unsigned int tcpm_pd_select_pps_apdo(struct tcpm_port *port) 1640 { 1641 unsigned int i, j, max_mw = 0, max_mv = 0; 1642 unsigned int min_src_mv, max_src_mv, src_ma, src_mw; 1643 unsigned int min_snk_mv, max_snk_mv; 1644 unsigned int max_op_mv; 1645 u32 pdo, src, snk; 1646 unsigned int src_pdo = 0, snk_pdo = 0; 1647 1648 /* 1649 * Select the source PPS APDO providing the most power while staying 1650 * within the board's limits. We skip the first PDO as this is always 1651 * 5V 3A. 1652 */ 1653 for (i = 1; i < port->nr_source_caps; ++i) { 1654 pdo = port->source_caps[i]; 1655 1656 switch (pdo_type(pdo)) { 1657 case PDO_TYPE_APDO: 1658 if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) { 1659 printf("Not PPS APDO (source), ignoring\n"); 1660 continue; 1661 } 1662 1663 min_src_mv = pdo_pps_apdo_min_voltage(pdo); 1664 max_src_mv = pdo_pps_apdo_max_voltage(pdo); 1665 src_ma = pdo_pps_apdo_max_current(pdo); 1666 src_mw = (src_ma * max_src_mv) / 1000; 1667 1668 /* 1669 * Now search through the sink PDOs to find a matching 1670 * PPS APDO. Again skip the first sink PDO as this will 1671 * always be 5V 3A. 1672 */ 1673 for (j = 1; j < port->nr_snk_pdo; j++) { 1674 pdo = port->snk_pdo[j]; 1675 1676 switch (pdo_type(pdo)) { 1677 case PDO_TYPE_APDO: 1678 if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) { 1679 printf("Not PPS APDO (sink), ignoring\n"); 1680 continue; 1681 } 1682 1683 min_snk_mv = 1684 pdo_pps_apdo_min_voltage(pdo); 1685 max_snk_mv = 1686 pdo_pps_apdo_max_voltage(pdo); 1687 break; 1688 default: 1689 printf("Not APDO type (sink), ignoring\n"); 1690 continue; 1691 } 1692 1693 if (min_src_mv <= max_snk_mv && 1694 max_src_mv >= min_snk_mv) { 1695 max_op_mv = min(max_src_mv, max_snk_mv); 1696 src_mw = (max_op_mv * src_ma) / 1000; 1697 /* Prefer higher voltages if available */ 1698 if ((src_mw == max_mw && 1699 max_op_mv > max_mv) || 1700 src_mw > max_mw) { 1701 src_pdo = i; 1702 snk_pdo = j; 1703 max_mw = src_mw; 1704 max_mv = max_op_mv; 1705 } 1706 } 1707 } 1708 1709 break; 1710 default: 1711 printf("Not APDO type (source), ignoring\n"); 1712 continue; 1713 } 1714 } 1715 1716 if (src_pdo) { 1717 src = port->source_caps[src_pdo]; 1718 snk = port->snk_pdo[snk_pdo]; 1719 1720 port->pps_data.req_min_volt = max(pdo_pps_apdo_min_voltage(src), 1721 pdo_pps_apdo_min_voltage(snk)); 1722 port->pps_data.req_max_volt = min(pdo_pps_apdo_max_voltage(src), 1723 pdo_pps_apdo_max_voltage(snk)); 1724 port->pps_data.req_max_curr = min_pps_apdo_current(src, snk); 1725 port->pps_data.req_out_volt = min(port->pps_data.req_max_volt, 1726 max(port->pps_data.req_min_volt, 1727 port->pps_data.req_out_volt)); 1728 port->pps_data.req_op_curr = min(port->pps_data.req_max_curr, 1729 port->pps_data.req_op_curr); 1730 } 1731 1732 return src_pdo; 1733 } 1734 1735 static int tcpm_pd_build_request(struct tcpm_port *port, u32 *rdo) 1736 { 1737 unsigned int mv, ma, mw, flags; 1738 unsigned int max_ma, max_mw; 1739 enum pd_pdo_type type; 1740 u32 pdo, matching_snk_pdo; 1741 int src_pdo_index = 0; 1742 int snk_pdo_index = 0; 1743 int ret; 1744 1745 ret = tcpm_pd_select_pdo(port, &snk_pdo_index, &src_pdo_index); 1746 if (ret < 0) 1747 return ret; 1748 1749 pdo = port->source_caps[src_pdo_index]; 1750 matching_snk_pdo = port->snk_pdo[snk_pdo_index]; 1751 type = pdo_type(pdo); 1752 1753 switch (type) { 1754 case PDO_TYPE_FIXED: 1755 mv = pdo_fixed_voltage(pdo); 1756 break; 1757 case PDO_TYPE_BATT: 1758 case PDO_TYPE_VAR: 1759 mv = pdo_min_voltage(pdo); 1760 break; 1761 default: 1762 printf("Invalid PDO selected!\n"); 1763 return -EINVAL; 1764 } 1765 1766 /* Select maximum available current within the sink pdo's limit */ 1767 if (type == PDO_TYPE_BATT) { 1768 mw = min_power(pdo, matching_snk_pdo); 1769 ma = 1000 * mw / mv; 1770 } else { 1771 ma = min_current(pdo, matching_snk_pdo); 1772 mw = ma * mv / 1000; 1773 } 1774 1775 flags = RDO_USB_COMM | RDO_NO_SUSPEND; 1776 1777 /* Set mismatch bit if offered power is less than operating power */ 1778 max_ma = ma; 1779 max_mw = mw; 1780 if (mw < port->operating_snk_mw) { 1781 flags |= RDO_CAP_MISMATCH; 1782 if (type == PDO_TYPE_BATT && 1783 (pdo_max_power(matching_snk_pdo) > pdo_max_power(pdo))) 1784 max_mw = pdo_max_power(matching_snk_pdo); 1785 else if (pdo_max_current(matching_snk_pdo) > 1786 pdo_max_current(pdo)) 1787 max_ma = pdo_max_current(matching_snk_pdo); 1788 } 1789 1790 debug("cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d\n", 1791 port->cc_req, port->cc1, port->cc2, port->vbus_source, 1792 port->vconn_role == TYPEC_SOURCE ? "source" : "sink", 1793 port->polarity); 1794 1795 if (type == PDO_TYPE_BATT) { 1796 *rdo = RDO_BATT(src_pdo_index + 1, mw, max_mw, flags); 1797 1798 printf("Requesting PDO %d: %u mV, %u mW%s\n", 1799 src_pdo_index, mv, mw, 1800 flags & RDO_CAP_MISMATCH ? " [mismatch]" : ""); 1801 } else { 1802 *rdo = RDO_FIXED(src_pdo_index + 1, ma, max_ma, flags); 1803 1804 printf("Requesting PDO %d: %u mV, %u mA%s\n", 1805 src_pdo_index, mv, ma, 1806 flags & RDO_CAP_MISMATCH ? " [mismatch]" : ""); 1807 } 1808 1809 port->req_current_limit = ma; 1810 port->req_supply_voltage = mv; 1811 1812 return 0; 1813 } 1814 1815 static int tcpm_pd_send_request(struct tcpm_port *port) 1816 { 1817 struct pd_message msg; 1818 int ret; 1819 u32 rdo; 1820 1821 ret = tcpm_pd_build_request(port, &rdo); 1822 if (ret < 0) 1823 return ret; 1824 1825 memset(&msg, 0, sizeof(msg)); 1826 msg.header = PD_HEADER_LE(PD_DATA_REQUEST, 1827 port->pwr_role, 1828 port->data_role, 1829 port->negotiated_rev, 1830 port->message_id, 1); 1831 msg.payload[0] = cpu_to_le32(rdo); 1832 1833 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 1834 } 1835 1836 static int tcpm_pd_build_pps_request(struct tcpm_port *port, u32 *rdo) 1837 { 1838 unsigned int out_mv, op_ma, op_mw, max_mv, max_ma, flags; 1839 enum pd_pdo_type type; 1840 unsigned int src_pdo_index; 1841 u32 pdo; 1842 1843 src_pdo_index = tcpm_pd_select_pps_apdo(port); 1844 if (!src_pdo_index) 1845 return -EOPNOTSUPP; 1846 1847 pdo = port->source_caps[src_pdo_index]; 1848 type = pdo_type(pdo); 1849 1850 switch (type) { 1851 case PDO_TYPE_APDO: 1852 if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) { 1853 printf("Invalid APDO selected!\n"); 1854 return -EINVAL; 1855 } 1856 max_mv = port->pps_data.req_max_volt; 1857 max_ma = port->pps_data.req_max_curr; 1858 out_mv = port->pps_data.req_out_volt; 1859 op_ma = port->pps_data.req_op_curr; 1860 break; 1861 default: 1862 printf("Invalid PDO selected!\n"); 1863 return -EINVAL; 1864 } 1865 1866 flags = RDO_USB_COMM | RDO_NO_SUSPEND; 1867 1868 op_mw = (op_ma * out_mv) / 1000; 1869 if (op_mw < port->operating_snk_mw) { 1870 /* 1871 * Try raising current to meet power needs. If that's not enough 1872 * then try upping the voltage. If that's still not enough 1873 * then we've obviously chosen a PPS APDO which really isn't 1874 * suitable so abandon ship. 1875 */ 1876 op_ma = (port->operating_snk_mw * 1000) / out_mv; 1877 if ((port->operating_snk_mw * 1000) % out_mv) 1878 ++op_ma; 1879 op_ma += RDO_PROG_CURR_MA_STEP - (op_ma % RDO_PROG_CURR_MA_STEP); 1880 1881 if (op_ma > max_ma) { 1882 op_ma = max_ma; 1883 out_mv = (port->operating_snk_mw * 1000) / op_ma; 1884 if ((port->operating_snk_mw * 1000) % op_ma) 1885 ++out_mv; 1886 out_mv += RDO_PROG_VOLT_MV_STEP - 1887 (out_mv % RDO_PROG_VOLT_MV_STEP); 1888 1889 if (out_mv > max_mv) { 1890 printf("Invalid PPS APDO selected!\n"); 1891 return -EINVAL; 1892 } 1893 } 1894 } 1895 1896 debug("cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d\n", 1897 port->cc_req, port->cc1, port->cc2, port->vbus_source, 1898 port->vconn_role == TYPEC_SOURCE ? "source" : "sink", 1899 port->polarity); 1900 1901 *rdo = RDO_PROG(src_pdo_index + 1, out_mv, op_ma, flags); 1902 1903 printf("Requesting APDO %d: %u mV, %u mA\n", 1904 src_pdo_index, out_mv, op_ma); 1905 1906 port->pps_data.req_op_curr = op_ma; 1907 port->pps_data.req_out_volt = out_mv; 1908 1909 return 0; 1910 } 1911 1912 static int tcpm_pd_send_pps_request(struct tcpm_port *port) 1913 { 1914 struct pd_message msg; 1915 int ret; 1916 u32 rdo; 1917 1918 ret = tcpm_pd_build_pps_request(port, &rdo); 1919 if (ret < 0) 1920 return ret; 1921 1922 memset(&msg, 0, sizeof(msg)); 1923 msg.header = PD_HEADER_LE(PD_DATA_REQUEST, 1924 port->pwr_role, 1925 port->data_role, 1926 port->negotiated_rev, 1927 port->message_id, 1); 1928 msg.payload[0] = cpu_to_le32(rdo); 1929 1930 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 1931 } 1932 1933 static int tcpm_set_vbus(struct tcpm_port *port, bool enable) 1934 { 1935 int ret; 1936 1937 if (enable && port->vbus_charge) 1938 return -EINVAL; 1939 1940 debug("vbus = %d charge = %d\n", enable, port->vbus_charge); 1941 1942 ret = port->tcpc->set_vbus(port->tcpc, enable, port->vbus_charge); 1943 if (ret < 0) 1944 return ret; 1945 1946 port->vbus_source = enable; 1947 return 0; 1948 } 1949 1950 static int tcpm_set_charge(struct tcpm_port *port, bool charge) 1951 { 1952 int ret; 1953 1954 if (charge && port->vbus_source) 1955 return -EINVAL; 1956 1957 if (charge != port->vbus_charge) { 1958 debug("vbus = %d charge = %d\n", port->vbus_source, charge); 1959 ret = port->tcpc->set_vbus(port->tcpc, port->vbus_source, 1960 charge); 1961 if (ret < 0) 1962 return ret; 1963 } 1964 port->vbus_charge = charge; 1965 return 0; 1966 } 1967 1968 static bool tcpm_start_toggling(struct tcpm_port *port, enum typec_cc_status cc) 1969 { 1970 int ret; 1971 1972 if (!port->tcpc->start_toggling) 1973 return false; 1974 1975 printf("Start toggling\n"); 1976 ret = port->tcpc->start_toggling(port->tcpc, port->port_type, cc); 1977 return ret == 0; 1978 } 1979 1980 static int tcpm_init_vbus(struct tcpm_port *port) 1981 { 1982 int ret; 1983 1984 ret = port->tcpc->set_vbus(port->tcpc, false, false); 1985 port->vbus_source = false; 1986 port->vbus_charge = false; 1987 return ret; 1988 } 1989 1990 static int tcpm_init_vconn(struct tcpm_port *port) 1991 { 1992 int ret; 1993 1994 ret = port->tcpc->set_vconn(port->tcpc, false); 1995 port->vconn_role = TYPEC_SINK; 1996 return ret; 1997 } 1998 1999 static void tcpm_typec_connect(struct tcpm_port *port) 2000 { 2001 if (!port->connected) { 2002 port->connected = true; 2003 } 2004 } 2005 2006 static int tcpm_src_attach(struct tcpm_port *port) 2007 { 2008 enum typec_cc_polarity polarity = 2009 port->cc2 == TYPEC_CC_RD ? TYPEC_POLARITY_CC2 2010 : TYPEC_POLARITY_CC1; 2011 int ret; 2012 2013 if (port->attached) 2014 return 0; 2015 2016 ret = tcpm_set_polarity(port, polarity); 2017 if (ret < 0) 2018 return ret; 2019 2020 ret = tcpm_set_roles(port, true, TYPEC_SOURCE, TYPEC_HOST); 2021 if (ret < 0) 2022 return ret; 2023 2024 ret = port->tcpc->set_pd_rx(port->tcpc, true); 2025 if (ret < 0) 2026 goto out_disable_mux; 2027 2028 /* 2029 * USB Type-C specification, version 1.2, 2030 * chapter 4.5.2.2.8.1 (Attached.SRC Requirements) 2031 * Enable VCONN only if the non-RD port is set to RA. 2032 */ 2033 if ((polarity == TYPEC_POLARITY_CC1 && port->cc2 == TYPEC_CC_RA) || 2034 (polarity == TYPEC_POLARITY_CC2 && port->cc1 == TYPEC_CC_RA)) { 2035 ret = tcpm_set_vconn(port, true); 2036 if (ret < 0) 2037 goto out_disable_pd; 2038 } 2039 2040 ret = tcpm_set_vbus(port, true); 2041 if (ret < 0) 2042 goto out_disable_vconn; 2043 2044 port->pd_capable = false; 2045 2046 port->partner = NULL; 2047 2048 port->attached = true; 2049 port->debouncing = false; 2050 //port->send_discover = true; 2051 2052 return 0; 2053 2054 out_disable_vconn: 2055 tcpm_set_vconn(port, false); 2056 out_disable_pd: 2057 port->tcpc->set_pd_rx(port->tcpc, false); 2058 out_disable_mux: 2059 printf("CC connected in %s as DFP\n", 2060 polarity ? "CC2" : "CC1"); 2061 return 0; 2062 } 2063 2064 static void tcpm_typec_disconnect(struct tcpm_port *port) 2065 { 2066 if (port->connected) { 2067 port->partner = NULL; 2068 port->connected = false; 2069 } 2070 } 2071 2072 static void tcpm_reset_port(struct tcpm_port *port) 2073 { 2074 tcpm_timer_uninit(port); 2075 tcpm_typec_disconnect(port); 2076 port->poll_event_cnt = 0; 2077 port->wait_dr_swap_Message = false; 2078 port->attached = false; 2079 port->pd_capable = false; 2080 port->pps_data.supported = false; 2081 2082 /* 2083 * First Rx ID should be 0; set this to a sentinel of -1 so that 2084 * we can check tcpm_pd_rx_handler() if we had seen it before. 2085 */ 2086 port->rx_msgid = -1; 2087 2088 port->tcpc->set_pd_rx(port->tcpc, false); 2089 tcpm_init_vbus(port); /* also disables charging */ 2090 tcpm_init_vconn(port); 2091 tcpm_set_current_limit(port, 0, 0); 2092 tcpm_set_polarity(port, TYPEC_POLARITY_CC1); 2093 tcpm_set_attached_state(port, false); 2094 port->usb_type = POWER_SUPPLY_USB_TYPE_C; 2095 port->nr_sink_caps = 0; 2096 port->sink_cap_done = false; 2097 } 2098 2099 static void tcpm_detach(struct tcpm_port *port) 2100 { 2101 if (tcpm_port_is_disconnected(port)) 2102 port->hard_reset_count = 0; 2103 2104 if (!port->attached) 2105 return; 2106 2107 tcpm_reset_port(port); 2108 } 2109 2110 static void tcpm_src_detach(struct tcpm_port *port) 2111 { 2112 tcpm_detach(port); 2113 } 2114 2115 static int tcpm_snk_attach(struct tcpm_port *port) 2116 { 2117 int ret; 2118 2119 if (port->attached) 2120 return 0; 2121 2122 ret = tcpm_set_polarity(port, port->cc2 != TYPEC_CC_OPEN ? 2123 TYPEC_POLARITY_CC2 : TYPEC_POLARITY_CC1); 2124 if (ret < 0) 2125 return ret; 2126 2127 ret = tcpm_set_roles(port, true, TYPEC_SINK, TYPEC_DEVICE); 2128 if (ret < 0) 2129 return ret; 2130 2131 port->pd_capable = false; 2132 2133 port->partner = NULL; 2134 2135 port->attached = true; 2136 port->debouncing = false; 2137 printf("CC connected in %s as UFP\n", 2138 port->cc1 != TYPEC_CC_OPEN ? "CC1" : "CC2"); 2139 2140 return 0; 2141 } 2142 2143 static void tcpm_snk_detach(struct tcpm_port *port) 2144 { 2145 tcpm_detach(port); 2146 } 2147 2148 static int tcpm_acc_attach(struct tcpm_port *port) 2149 { 2150 int ret; 2151 2152 if (port->attached) 2153 return 0; 2154 2155 ret = tcpm_set_roles(port, true, TYPEC_SOURCE, TYPEC_HOST); 2156 if (ret < 0) 2157 return ret; 2158 2159 port->partner = NULL; 2160 2161 tcpm_typec_connect(port); 2162 2163 port->attached = true; 2164 2165 dev_info(port->dev, "CC connected as Audio Accessory\n"); 2166 2167 return 0; 2168 } 2169 2170 static void tcpm_acc_detach(struct tcpm_port *port) 2171 { 2172 tcpm_detach(port); 2173 } 2174 2175 static inline enum tcpm_state hard_reset_state(struct tcpm_port *port) 2176 { 2177 if (port->hard_reset_count < PD_N_HARD_RESET_COUNT) 2178 return HARD_RESET_SEND; 2179 if (port->pd_capable) 2180 return ERROR_RECOVERY; 2181 if (port->pwr_role == TYPEC_SOURCE) 2182 return SRC_UNATTACHED; 2183 if (port->state == SNK_WAIT_CAPABILITIES) 2184 return SNK_READY; 2185 return SNK_UNATTACHED; 2186 } 2187 2188 static inline enum tcpm_state unattached_state(struct tcpm_port *port) 2189 { 2190 if (port->port_type == TYPEC_PORT_DRP) { 2191 if (port->pwr_role == TYPEC_SOURCE) 2192 return SRC_UNATTACHED; 2193 else 2194 return SNK_UNATTACHED; 2195 } else if (port->port_type == TYPEC_PORT_SRC) { 2196 return SRC_UNATTACHED; 2197 } 2198 2199 return SNK_UNATTACHED; 2200 } 2201 2202 bool tcpm_is_toggling(struct tcpm_port *port) 2203 { 2204 if (port->port_type == TYPEC_PORT_DRP) 2205 return port->state == SRC_UNATTACHED || port->state == SNK_UNATTACHED || 2206 port->state == TOGGLING; 2207 2208 return false; 2209 } 2210 EXPORT_SYMBOL_GPL(tcpm_is_toggling); 2211 2212 static void run_state_machine(struct tcpm_port *port) 2213 { 2214 int ret; 2215 2216 port->enter_state = port->state; 2217 switch (port->state) { 2218 case TOGGLING: 2219 break; 2220 /* SRC states */ 2221 case SRC_UNATTACHED: 2222 tcpm_src_detach(port); 2223 if (tcpm_start_toggling(port, tcpm_rp_cc(port))) { 2224 tcpm_set_state(port, TOGGLING, 0); 2225 break; 2226 } 2227 tcpm_set_cc(port, tcpm_rp_cc(port)); 2228 if (port->port_type == TYPEC_PORT_DRP) 2229 tcpm_set_state(port, SNK_UNATTACHED, PD_T_DRP_SNK); 2230 break; 2231 case SRC_ATTACH_WAIT: 2232 if (tcpm_port_is_debug(port)) 2233 tcpm_set_state(port, DEBUG_ACC_ATTACHED, 2234 PD_T_CC_DEBOUNCE); 2235 else if (tcpm_port_is_audio(port)) 2236 tcpm_set_state(port, AUDIO_ACC_ATTACHED, 2237 PD_T_CC_DEBOUNCE); 2238 else if (tcpm_port_is_source(port)) 2239 tcpm_set_state(port, SRC_ATTACHED, PD_T_CC_DEBOUNCE); 2240 break; 2241 2242 case SRC_ATTACHED: 2243 ret = tcpm_src_attach(port); 2244 /* 2245 * Currently, vbus control is not implemented, 2246 * and the SRC detection process cannot be fully implemented. 2247 */ 2248 tcpm_set_state(port, SRC_READY, 0); 2249 #if 0 2250 tcpm_set_state(port, SRC_UNATTACHED, 2251 ret < 0 ? 0 : PD_T_PS_SOURCE_ON); 2252 #endif 2253 break; 2254 case SRC_STARTUP: 2255 port->caps_count = 0; 2256 port->negotiated_rev = PD_MAX_REV; 2257 port->message_id = 0; 2258 port->rx_msgid = -1; 2259 port->explicit_contract = false; 2260 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0); 2261 break; 2262 case SRC_SEND_CAPABILITIES: 2263 port->caps_count++; 2264 if (port->caps_count > PD_N_CAPS_COUNT) { 2265 tcpm_set_state(port, SRC_READY, 0); 2266 break; 2267 } 2268 ret = tcpm_pd_send_source_caps(port); 2269 if (ret < 0) { 2270 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 2271 PD_T_SEND_SOURCE_CAP); 2272 } else { 2273 /* 2274 * Per standard, we should clear the reset counter here. 2275 * However, that can result in state machine hang-ups. 2276 * Reset it only in READY state to improve stability. 2277 */ 2278 /* port->hard_reset_count = 0; */ 2279 port->caps_count = 0; 2280 port->pd_capable = true; 2281 tcpm_set_state_cond(port, SRC_SEND_CAPABILITIES_TIMEOUT, 2282 PD_T_SEND_SOURCE_CAP); 2283 } 2284 break; 2285 case SRC_SEND_CAPABILITIES_TIMEOUT: 2286 /* 2287 * Error recovery for a PD_DATA_SOURCE_CAP reply timeout. 2288 * 2289 * PD 2.0 sinks are supposed to accept src-capabilities with a 2290 * 3.0 header and simply ignore any src PDOs which the sink does 2291 * not understand such as PPS but some 2.0 sinks instead ignore 2292 * the entire PD_DATA_SOURCE_CAP message, causing contract 2293 * negotiation to fail. 2294 * 2295 * After PD_N_HARD_RESET_COUNT hard-reset attempts, we try 2296 * sending src-capabilities with a lower PD revision to 2297 * make these broken sinks work. 2298 */ 2299 if (port->hard_reset_count < PD_N_HARD_RESET_COUNT) { 2300 tcpm_set_state(port, HARD_RESET_SEND, 0); 2301 } else if (port->negotiated_rev > PD_REV20) { 2302 port->negotiated_rev--; 2303 port->hard_reset_count = 0; 2304 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0); 2305 } else { 2306 tcpm_set_state(port, hard_reset_state(port), 0); 2307 } 2308 break; 2309 case SRC_NEGOTIATE_CAPABILITIES: 2310 ret = tcpm_pd_check_request(port); 2311 if (ret < 0) { 2312 tcpm_pd_send_control(port, PD_CTRL_REJECT); 2313 if (!port->explicit_contract) { 2314 tcpm_set_state(port, 2315 SRC_WAIT_NEW_CAPABILITIES, 0); 2316 } else { 2317 tcpm_set_state(port, SRC_READY, 0); 2318 } 2319 } else { 2320 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 2321 tcpm_set_state(port, SRC_TRANSITION_SUPPLY, 2322 PD_T_SRC_TRANSITION); 2323 } 2324 break; 2325 case SRC_TRANSITION_SUPPLY: 2326 /* XXX: regulator_set_voltage(vbus, ...) */ 2327 tcpm_pd_send_control(port, PD_CTRL_PS_RDY); 2328 port->explicit_contract = true; 2329 tcpm_set_state_cond(port, SRC_READY, 0); 2330 break; 2331 case SRC_READY: 2332 #if 1 2333 port->hard_reset_count = 0; 2334 #endif 2335 port->try_src_count = 0; 2336 2337 tcpm_typec_connect(port); 2338 break; 2339 case SRC_WAIT_NEW_CAPABILITIES: 2340 /* Nothing to do... */ 2341 break; 2342 2343 /* SNK states */ 2344 case SNK_UNATTACHED: 2345 tcpm_snk_detach(port); 2346 if (tcpm_start_toggling(port, TYPEC_CC_RD)) { 2347 tcpm_set_state(port, TOGGLING, 0); 2348 break; 2349 } 2350 tcpm_set_cc(port, TYPEC_CC_RD); 2351 if (port->port_type == TYPEC_PORT_DRP) 2352 tcpm_set_state(port, SRC_UNATTACHED, PD_T_DRP_SRC); 2353 break; 2354 case SNK_ATTACH_WAIT: 2355 if ((port->cc1 == TYPEC_CC_OPEN && 2356 port->cc2 != TYPEC_CC_OPEN) || 2357 (port->cc1 != TYPEC_CC_OPEN && 2358 port->cc2 == TYPEC_CC_OPEN)) 2359 tcpm_set_state(port, SNK_DEBOUNCED, 2360 PD_T_CC_DEBOUNCE); 2361 else if (tcpm_port_is_disconnected(port)) 2362 tcpm_set_state(port, SNK_UNATTACHED, 2363 PD_T_CC_DEBOUNCE); 2364 break; 2365 case SNK_DEBOUNCED: 2366 if (tcpm_port_is_disconnected(port)) { 2367 tcpm_set_state(port, SNK_UNATTACHED, 2368 PD_T_PD_DEBOUNCE); 2369 } else if (port->vbus_present) 2370 tcpm_set_state(port, SNK_ATTACHED, 0); 2371 else 2372 /* Wait for VBUS, but not forever */ 2373 tcpm_set_state(port, PORT_RESET, PD_T_PS_SOURCE_ON); 2374 break; 2375 2376 case SNK_ATTACHED: 2377 ret = tcpm_snk_attach(port); 2378 if (ret < 0) 2379 tcpm_set_state(port, SNK_UNATTACHED, 0); 2380 else 2381 tcpm_set_state(port, SNK_STARTUP, 0); 2382 break; 2383 case SNK_STARTUP: 2384 port->negotiated_rev = PD_MAX_REV; 2385 port->message_id = 0; 2386 port->rx_msgid = -1; 2387 port->explicit_contract = false; 2388 tcpm_set_state(port, SNK_DISCOVERY, 0); 2389 break; 2390 case SNK_DISCOVERY: 2391 if (port->vbus_present) { 2392 tcpm_set_current_limit(port, 2393 tcpm_get_current_limit(port), 2394 5000); 2395 tcpm_set_charge(port, true); 2396 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0); 2397 break; 2398 } 2399 /* 2400 * For DRP, timeouts differ. Also, handling is supposed to be 2401 * different and much more complex (dead battery detection; 2402 * see USB power delivery specification, section 8.3.3.6.1.5.1). 2403 */ 2404 tcpm_set_state(port, hard_reset_state(port), 2405 port->port_type == TYPEC_PORT_DRP ? 2406 PD_T_DB_DETECT : PD_T_NO_RESPONSE); 2407 break; 2408 case SNK_DISCOVERY_DEBOUNCE: 2409 tcpm_set_state(port, SNK_DISCOVERY_DEBOUNCE_DONE, 2410 PD_T_CC_DEBOUNCE); 2411 break; 2412 case SNK_DISCOVERY_DEBOUNCE_DONE: 2413 #if 0 2414 if (!tcpm_port_is_disconnected(port) && 2415 tcpm_port_is_sink(port) && 2416 ktime_after(port->delayed_runtime, ktime_get())) { 2417 tcpm_set_state(port, SNK_DISCOVERY, 2418 ktime_to_ms(ktime_sub(port->delayed_runtime, ktime_get()))); 2419 break; 2420 } 2421 #endif 2422 tcpm_set_state(port, unattached_state(port), 0); 2423 break; 2424 case SNK_WAIT_CAPABILITIES: 2425 ret = port->tcpc->set_pd_rx(port->tcpc, true); 2426 if (ret < 0) { 2427 tcpm_set_state(port, SNK_READY, 0); 2428 break; 2429 } 2430 /* 2431 * If VBUS has never been low, and we time out waiting 2432 * for source cap, try a soft reset first, in case we 2433 * were already in a stable contract before this boot. 2434 * Do this only once. 2435 */ 2436 if (port->vbus_never_low) { 2437 port->vbus_never_low = false; 2438 tcpm_set_state(port, SOFT_RESET_SEND, 2439 PD_T_SINK_WAIT_CAP); 2440 } else { 2441 tcpm_set_state(port, hard_reset_state(port), 2442 PD_T_SINK_WAIT_CAP); 2443 } 2444 break; 2445 case SNK_NEGOTIATE_CAPABILITIES: 2446 port->pd_capable = true; 2447 port->hard_reset_count = 0; 2448 ret = tcpm_pd_send_request(port); 2449 if (ret < 0) { 2450 /* Let the Source send capabilities again. */ 2451 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0); 2452 } else { 2453 tcpm_set_state_cond(port, hard_reset_state(port), 2454 PD_T_SENDER_RESPONSE); 2455 } 2456 break; 2457 case SNK_NEGOTIATE_PPS_CAPABILITIES: 2458 ret = tcpm_pd_send_pps_request(port); 2459 if (ret < 0) { 2460 port->pps_status = ret; 2461 /* 2462 * If this was called due to updates to sink 2463 * capabilities, and pps is no longer valid, we should 2464 * safely fall back to a standard PDO. 2465 */ 2466 if (port->update_sink_caps) 2467 tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0); 2468 else 2469 tcpm_set_state(port, SNK_READY, 0); 2470 } else { 2471 tcpm_set_state_cond(port, hard_reset_state(port), 2472 PD_T_SENDER_RESPONSE); 2473 } 2474 break; 2475 case SNK_TRANSITION_SINK: 2476 case SNK_TRANSITION_SINK_VBUS: 2477 tcpm_set_state(port, hard_reset_state(port), 2478 PD_T_PS_TRANSITION); 2479 break; 2480 case SNK_READY: 2481 port->try_snk_count = 0; 2482 port->update_sink_caps = false; 2483 tcpm_typec_connect(port); 2484 /* 2485 * Here poll_event_cnt is cleared, waiting for self-powered Type-C devices 2486 * to send DR_swap Messge until 1s (TCPM_POLL_EVENT_TIME_OUT * 500us)timeout 2487 */ 2488 if (port->wait_dr_swap_Message) 2489 port->poll_event_cnt = 0; 2490 2491 break; 2492 2493 /* Accessory states */ 2494 case ACC_UNATTACHED: 2495 tcpm_acc_detach(port); 2496 tcpm_set_state(port, SRC_UNATTACHED, 0); 2497 break; 2498 case DEBUG_ACC_ATTACHED: 2499 case AUDIO_ACC_ATTACHED: 2500 ret = tcpm_acc_attach(port); 2501 if (ret < 0) 2502 tcpm_set_state(port, ACC_UNATTACHED, 0); 2503 break; 2504 case AUDIO_ACC_DEBOUNCE: 2505 tcpm_set_state(port, ACC_UNATTACHED, PD_T_CC_DEBOUNCE); 2506 break; 2507 2508 /* Hard_Reset states */ 2509 case HARD_RESET_SEND: 2510 tcpm_pd_transmit(port, TCPC_TX_HARD_RESET, NULL); 2511 tcpm_set_state(port, HARD_RESET_START, 0); 2512 port->wait_dr_swap_Message = false; 2513 break; 2514 case HARD_RESET_START: 2515 port->hard_reset_count++; 2516 port->tcpc->set_pd_rx(port->tcpc, false); 2517 port->nr_sink_caps = 0; 2518 port->send_discover = true; 2519 if (port->pwr_role == TYPEC_SOURCE) 2520 tcpm_set_state(port, SRC_HARD_RESET_VBUS_OFF, 2521 PD_T_PS_HARD_RESET); 2522 else 2523 tcpm_set_state(port, SNK_HARD_RESET_SINK_OFF, 0); 2524 break; 2525 case SRC_HARD_RESET_VBUS_OFF: 2526 tcpm_set_vconn(port, true); 2527 tcpm_set_vbus(port, false); 2528 tcpm_set_roles(port, port->self_powered, TYPEC_SOURCE, 2529 TYPEC_HOST); 2530 tcpm_set_state(port, SRC_HARD_RESET_VBUS_ON, PD_T_SRC_RECOVER); 2531 break; 2532 case SRC_HARD_RESET_VBUS_ON: 2533 tcpm_set_vconn(port, true); 2534 tcpm_set_vbus(port, true); 2535 port->tcpc->set_pd_rx(port->tcpc, true); 2536 tcpm_set_attached_state(port, true); 2537 tcpm_set_state(port, SRC_UNATTACHED, PD_T_PS_SOURCE_ON); 2538 break; 2539 case SNK_HARD_RESET_SINK_OFF: 2540 memset(&port->pps_data, 0, sizeof(port->pps_data)); 2541 tcpm_set_vconn(port, false); 2542 if (port->pd_capable) 2543 tcpm_set_charge(port, false); 2544 tcpm_set_roles(port, port->self_powered, TYPEC_SINK, 2545 TYPEC_DEVICE); 2546 /* 2547 * VBUS may or may not toggle, depending on the adapter. 2548 * If it doesn't toggle, transition to SNK_HARD_RESET_SINK_ON 2549 * directly after timeout. 2550 */ 2551 tcpm_set_state(port, SNK_HARD_RESET_SINK_ON, PD_T_SAFE_0V); 2552 break; 2553 case SNK_HARD_RESET_WAIT_VBUS: 2554 /* Assume we're disconnected if VBUS doesn't come back. */ 2555 tcpm_set_state(port, SNK_UNATTACHED, 2556 PD_T_SRC_RECOVER_MAX + PD_T_SRC_TURN_ON); 2557 break; 2558 case SNK_HARD_RESET_SINK_ON: 2559 /* Note: There is no guarantee that VBUS is on in this state */ 2560 /* 2561 * XXX: 2562 * The specification suggests that dual mode ports in sink 2563 * mode should transition to state PE_SRC_Transition_to_default. 2564 * See USB power delivery specification chapter 8.3.3.6.1.3. 2565 * This would mean to to 2566 * - turn off VCONN, reset power supply 2567 * - request hardware reset 2568 * - turn on VCONN 2569 * - Transition to state PE_Src_Startup 2570 * SNK only ports shall transition to state Snk_Startup 2571 * (see chapter 8.3.3.3.8). 2572 * Similar, dual-mode ports in source mode should transition 2573 * to PE_SNK_Transition_to_default. 2574 */ 2575 if (port->pd_capable) { 2576 tcpm_set_current_limit(port, 2577 tcpm_get_current_limit(port), 2578 5000); 2579 tcpm_set_charge(port, true); 2580 } 2581 tcpm_set_attached_state(port, true); 2582 tcpm_set_state(port, SNK_STARTUP, 0); 2583 break; 2584 2585 /* Soft_Reset states */ 2586 case SOFT_RESET: 2587 port->message_id = 0; 2588 port->rx_msgid = -1; 2589 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 2590 if (port->pwr_role == TYPEC_SOURCE) { 2591 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0); 2592 } else { 2593 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0); 2594 } 2595 break; 2596 case SOFT_RESET_SEND: 2597 port->message_id = 0; 2598 port->rx_msgid = -1; 2599 if (tcpm_pd_send_control(port, PD_CTRL_SOFT_RESET)) 2600 tcpm_set_state_cond(port, hard_reset_state(port), 0); 2601 else 2602 tcpm_set_state_cond(port, hard_reset_state(port), 2603 PD_T_SENDER_RESPONSE); 2604 break; 2605 2606 /* DR_Swap states */ 2607 case DR_SWAP_SEND: 2608 tcpm_pd_send_control(port, PD_CTRL_DR_SWAP); 2609 tcpm_set_state_cond(port, DR_SWAP_SEND_TIMEOUT, 2610 PD_T_SENDER_RESPONSE); 2611 break; 2612 case DR_SWAP_ACCEPT: 2613 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 2614 #if 0 2615 /* Set VDM state machine running flag ASAP */ 2616 if (port->data_role == TYPEC_DEVICE && port->send_discover) 2617 port->vdm_sm_running = true; 2618 #endif 2619 tcpm_set_state_cond(port, DR_SWAP_CHANGE_DR, 0); 2620 break; 2621 case DR_SWAP_SEND_TIMEOUT: 2622 //tcpm_swap_complete(port, -ETIMEDOUT); 2623 tcpm_set_state(port, ready_state(port), 0); 2624 break; 2625 case DR_SWAP_CHANGE_DR: 2626 if (port->data_role == TYPEC_HOST) { 2627 //tcpm_unregister_altmodes(port); 2628 tcpm_set_roles(port, true, port->pwr_role, 2629 TYPEC_DEVICE); 2630 } else { 2631 tcpm_set_roles(port, true, port->pwr_role, 2632 TYPEC_HOST); 2633 //port->send_discover = true; 2634 } 2635 /* DR_swap process complete, wait_dr_swap_Message is cleared */ 2636 port->wait_dr_swap_Message = false; 2637 tcpm_set_state(port, ready_state(port), 0); 2638 break; 2639 2640 #if 0 2641 2642 /* PR_Swap states */ 2643 case PR_SWAP_ACCEPT: 2644 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 2645 tcpm_set_state(port, PR_SWAP_START, 0); 2646 break; 2647 case PR_SWAP_SEND: 2648 tcpm_pd_send_control(port, PD_CTRL_PR_SWAP); 2649 tcpm_set_state_cond(port, PR_SWAP_SEND_TIMEOUT, 2650 PD_T_SENDER_RESPONSE); 2651 break; 2652 case PR_SWAP_SEND_TIMEOUT: 2653 tcpm_set_state(port, ready_state(port), 0); 2654 break; 2655 case PR_SWAP_START: 2656 tcpm_apply_rc(port); 2657 if (port->pwr_role == TYPEC_SOURCE) 2658 tcpm_set_state(port, PR_SWAP_SRC_SNK_TRANSITION_OFF, 2659 PD_T_SRC_TRANSITION); 2660 else 2661 tcpm_set_state(port, PR_SWAP_SNK_SRC_SINK_OFF, 0); 2662 break; 2663 case PR_SWAP_SRC_SNK_TRANSITION_OFF: 2664 /* 2665 * Prevent vbus discharge circuit from turning on during PR_SWAP 2666 * as this is not a disconnect. 2667 */ 2668 tcpm_set_vbus(port, false); 2669 port->explicit_contract = false; 2670 /* allow time for Vbus discharge, must be < tSrcSwapStdby */ 2671 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF, 2672 PD_T_SRCSWAPSTDBY); 2673 break; 2674 case PR_SWAP_SRC_SNK_SOURCE_OFF: 2675 timer_val_msecs = PD_T_CC_DEBOUNCE; 2676 trace_android_vh_typec_tcpm_get_timer(tcpm_states[PR_SWAP_SRC_SNK_SOURCE_OFF], 2677 CC_DEBOUNCE, &timer_val_msecs); 2678 tcpm_set_cc(port, TYPEC_CC_RD); 2679 /* allow CC debounce */ 2680 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED, 2681 timer_val_msecs); 2682 break; 2683 case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED: 2684 /* 2685 * USB-PD standard, 6.2.1.4, Port Power Role: 2686 * "During the Power Role Swap Sequence, for the initial Source 2687 * Port, the Port Power Role field shall be set to Sink in the 2688 * PS_RDY Message indicating that the initial Source’s power 2689 * supply is turned off" 2690 */ 2691 tcpm_set_pwr_role(port, TYPEC_SINK); 2692 if (tcpm_pd_send_control(port, PD_CTRL_PS_RDY)) { 2693 tcpm_set_state(port, ERROR_RECOVERY, 0); 2694 break; 2695 } 2696 tcpm_set_state(port, ERROR_RECOVERY, PD_T_PS_SOURCE_ON_PRS); 2697 break; 2698 case PR_SWAP_SRC_SNK_SINK_ON: 2699 tcpm_enable_auto_vbus_discharge(port, true); 2700 /* Set the vbus disconnect threshold for implicit contract */ 2701 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, VSAFE5V); 2702 tcpm_set_state(port, SNK_STARTUP, 0); 2703 break; 2704 case PR_SWAP_SNK_SRC_SINK_OFF: 2705 timer_val_msecs = PD_T_PS_SOURCE_OFF; 2706 trace_android_vh_typec_tcpm_get_timer(tcpm_states[PR_SWAP_SNK_SRC_SINK_OFF], 2707 SOURCE_OFF, &timer_val_msecs); 2708 /* 2709 * Prevent vbus discharge circuit from turning on during PR_SWAP 2710 * as this is not a disconnect. 2711 */ 2712 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, 2713 port->pps_data.active, 0); 2714 tcpm_set_charge(port, false); 2715 tcpm_set_state(port, hard_reset_state(port), timer_val_msecs); 2716 break; 2717 case PR_SWAP_SNK_SRC_SOURCE_ON: 2718 tcpm_enable_auto_vbus_discharge(port, true); 2719 tcpm_set_cc(port, tcpm_rp_cc(port)); 2720 tcpm_set_vbus(port, true); 2721 /* 2722 * allow time VBUS ramp-up, must be < tNewSrc 2723 * Also, this window overlaps with CC debounce as well. 2724 * So, Wait for the max of two which is PD_T_NEWSRC 2725 */ 2726 tcpm_set_state(port, PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP, 2727 PD_T_NEWSRC); 2728 break; 2729 case PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP: 2730 /* 2731 * USB PD standard, 6.2.1.4: 2732 * "Subsequent Messages initiated by the Policy Engine, 2733 * such as the PS_RDY Message sent to indicate that Vbus 2734 * is ready, will have the Port Power Role field set to 2735 * Source." 2736 */ 2737 tcpm_set_pwr_role(port, TYPEC_SOURCE); 2738 tcpm_pd_send_control(port, PD_CTRL_PS_RDY); 2739 tcpm_set_state(port, SRC_STARTUP, PD_T_SWAP_SRC_START); 2740 break; 2741 #endif 2742 case GET_STATUS_SEND: 2743 tcpm_pd_send_control(port, PD_CTRL_GET_STATUS); 2744 tcpm_set_state(port, GET_STATUS_SEND_TIMEOUT, 2745 PD_T_SENDER_RESPONSE); 2746 break; 2747 case GET_STATUS_SEND_TIMEOUT: 2748 tcpm_set_state(port, ready_state(port), 0); 2749 break; 2750 case GET_PPS_STATUS_SEND: 2751 tcpm_pd_send_control(port, PD_CTRL_GET_PPS_STATUS); 2752 tcpm_set_state(port, GET_PPS_STATUS_SEND_TIMEOUT, 2753 PD_T_SENDER_RESPONSE); 2754 break; 2755 case GET_PPS_STATUS_SEND_TIMEOUT: 2756 tcpm_set_state(port, ready_state(port), 0); 2757 break; 2758 case GET_SINK_CAP: 2759 tcpm_pd_send_control(port, PD_CTRL_GET_SINK_CAP); 2760 tcpm_set_state(port, GET_SINK_CAP_TIMEOUT, PD_T_SENDER_RESPONSE); 2761 break; 2762 case GET_SINK_CAP_TIMEOUT: 2763 tcpm_set_state(port, ready_state(port), 0); 2764 break; 2765 case ERROR_RECOVERY: 2766 tcpm_set_state(port, PORT_RESET, 0); 2767 break; 2768 case PORT_RESET: 2769 tcpm_reset_port(port); 2770 tcpm_set_cc(port, TYPEC_CC_OPEN); 2771 tcpm_set_state(port, PORT_RESET_WAIT_OFF, 2772 PD_T_ERROR_RECOVERY); 2773 break; 2774 case PORT_RESET_WAIT_OFF: 2775 tcpm_set_state(port, 2776 tcpm_default_state(port), 2777 port->vbus_present ? PD_T_PS_SOURCE_OFF : 0); 2778 break; 2779 default: 2780 printf("Unexpected port state %d\n", port->state); 2781 break; 2782 } 2783 } 2784 2785 static void tcpm_state_machine(struct tcpm_port *port) 2786 { 2787 enum tcpm_state prev_state; 2788 2789 mutex_lock(&port->lock); 2790 port->state_machine_running = true; 2791 2792 if (port->queued_message && tcpm_send_queued_message(port)) 2793 goto done; 2794 2795 /* If we were queued due to a delayed state change, update it now */ 2796 if (port->delayed_state) { 2797 debug("state change %s -> %s [delayed %ld ms]\n", 2798 tcpm_states[port->state], 2799 tcpm_states[port->delayed_state], port->delay_ms); 2800 port->prev_state = port->state; 2801 port->state = port->delayed_state; 2802 port->delayed_state = INVALID_STATE; 2803 } 2804 2805 /* 2806 * Continue running as long as we have (non-delayed) state changes 2807 * to make. 2808 */ 2809 do { 2810 prev_state = port->state; 2811 run_state_machine(port); 2812 if (port->queued_message) 2813 tcpm_send_queued_message(port); 2814 } while (port->state != prev_state && !port->delayed_state); 2815 2816 done: 2817 port->state_machine_running = false; 2818 mutex_unlock(&port->lock); 2819 } 2820 2821 static void _tcpm_cc_change(struct tcpm_port *port, enum typec_cc_status cc1, 2822 enum typec_cc_status cc2) 2823 { 2824 enum typec_cc_status old_cc1, old_cc2; 2825 enum tcpm_state new_state; 2826 2827 old_cc1 = port->cc1; 2828 old_cc2 = port->cc2; 2829 port->cc1 = cc1; 2830 port->cc2 = cc2; 2831 2832 debug("CC1: %u -> %u, CC2: %u -> %u [state %s, polarity %d, %s]\n", 2833 old_cc1, cc1, old_cc2, cc2, tcpm_states[port->state], 2834 port->polarity, 2835 tcpm_port_is_disconnected(port) ? "disconnected" : "connected"); 2836 2837 switch (port->state) { 2838 case TOGGLING: 2839 if (tcpm_port_is_debug(port) || tcpm_port_is_audio(port) || 2840 tcpm_port_is_source(port)) 2841 tcpm_set_state(port, SRC_ATTACH_WAIT, 0); 2842 else if (tcpm_port_is_sink(port)) 2843 tcpm_set_state(port, SNK_ATTACH_WAIT, 0); 2844 break; 2845 case SRC_UNATTACHED: 2846 case ACC_UNATTACHED: 2847 if (tcpm_port_is_debug(port) || tcpm_port_is_audio(port) || 2848 tcpm_port_is_source(port)) 2849 tcpm_set_state(port, SRC_ATTACH_WAIT, 0); 2850 break; 2851 case SRC_ATTACH_WAIT: 2852 if (tcpm_port_is_disconnected(port) || 2853 tcpm_port_is_audio_detached(port)) 2854 tcpm_set_state(port, SRC_UNATTACHED, 0); 2855 else if (cc1 != old_cc1 || cc2 != old_cc2) 2856 tcpm_set_state(port, SRC_ATTACH_WAIT, 0); 2857 break; 2858 case SRC_ATTACHED: 2859 case SRC_SEND_CAPABILITIES: 2860 case SRC_READY: 2861 if (tcpm_port_is_disconnected(port) || 2862 !tcpm_port_is_source(port)) 2863 tcpm_set_state(port, SRC_UNATTACHED, 0); 2864 break; 2865 case SNK_UNATTACHED: 2866 if (tcpm_port_is_sink(port)) 2867 tcpm_set_state(port, SNK_ATTACH_WAIT, 0); 2868 break; 2869 case SNK_ATTACH_WAIT: 2870 if ((port->cc1 == TYPEC_CC_OPEN && 2871 port->cc2 != TYPEC_CC_OPEN) || 2872 (port->cc1 != TYPEC_CC_OPEN && 2873 port->cc2 == TYPEC_CC_OPEN)) 2874 new_state = SNK_DEBOUNCED; 2875 else if (tcpm_port_is_disconnected(port)) 2876 new_state = SNK_UNATTACHED; 2877 else 2878 break; 2879 if (new_state != port->delayed_state) 2880 tcpm_set_state(port, SNK_ATTACH_WAIT, 0); 2881 break; 2882 case SNK_DEBOUNCED: 2883 if (tcpm_port_is_disconnected(port)) 2884 new_state = SNK_UNATTACHED; 2885 else if (port->vbus_present) 2886 new_state = tcpm_try_src(port) ? SRC_TRY : SNK_ATTACHED; 2887 else 2888 new_state = SNK_UNATTACHED; 2889 if (new_state != port->delayed_state) 2890 tcpm_set_state(port, SNK_DEBOUNCED, 0); 2891 break; 2892 case SNK_READY: 2893 if (tcpm_port_is_disconnected(port)) 2894 tcpm_set_state(port, unattached_state(port), 0); 2895 else if (!port->pd_capable && 2896 (cc1 != old_cc1 || cc2 != old_cc2)) 2897 tcpm_set_current_limit(port, 2898 tcpm_get_current_limit(port), 2899 5000); 2900 break; 2901 2902 case AUDIO_ACC_ATTACHED: 2903 if (cc1 == TYPEC_CC_OPEN || cc2 == TYPEC_CC_OPEN) 2904 tcpm_set_state(port, AUDIO_ACC_DEBOUNCE, 0); 2905 break; 2906 case AUDIO_ACC_DEBOUNCE: 2907 if (tcpm_port_is_audio(port)) 2908 tcpm_set_state(port, AUDIO_ACC_ATTACHED, 0); 2909 break; 2910 2911 case DEBUG_ACC_ATTACHED: 2912 if (cc1 == TYPEC_CC_OPEN || cc2 == TYPEC_CC_OPEN) 2913 tcpm_set_state(port, ACC_UNATTACHED, 0); 2914 break; 2915 2916 case SNK_TRY: 2917 /* Do nothing, waiting for timeout */ 2918 break; 2919 2920 case SNK_DISCOVERY: 2921 /* CC line is unstable, wait for debounce */ 2922 if (tcpm_port_is_disconnected(port)) 2923 tcpm_set_state(port, SNK_DISCOVERY_DEBOUNCE, 0); 2924 break; 2925 case SNK_DISCOVERY_DEBOUNCE: 2926 break; 2927 2928 case SRC_TRYWAIT: 2929 /* Hand over to state machine if needed */ 2930 if (!port->vbus_present && tcpm_port_is_source(port)) 2931 tcpm_set_state(port, SRC_TRYWAIT_DEBOUNCE, 0); 2932 break; 2933 case SRC_TRYWAIT_DEBOUNCE: 2934 if (port->vbus_present || !tcpm_port_is_source(port)) 2935 tcpm_set_state(port, SRC_TRYWAIT, 0); 2936 break; 2937 case SNK_TRY_WAIT_DEBOUNCE: 2938 if (!tcpm_port_is_sink(port)) { 2939 port->max_wait = 0; 2940 tcpm_set_state(port, SRC_TRYWAIT, 0); 2941 } 2942 break; 2943 case SRC_TRY_WAIT: 2944 if (tcpm_port_is_source(port)) 2945 tcpm_set_state(port, SRC_TRY_DEBOUNCE, 0); 2946 break; 2947 case SRC_TRY_DEBOUNCE: 2948 tcpm_set_state(port, SRC_TRY_WAIT, 0); 2949 break; 2950 case SNK_TRYWAIT_DEBOUNCE: 2951 if (tcpm_port_is_sink(port)) 2952 tcpm_set_state(port, SNK_TRYWAIT_VBUS, 0); 2953 break; 2954 case SNK_TRYWAIT_VBUS: 2955 if (!tcpm_port_is_sink(port)) 2956 tcpm_set_state(port, SNK_TRYWAIT_DEBOUNCE, 0); 2957 break; 2958 case SNK_TRYWAIT: 2959 /* Do nothing, waiting for tCCDebounce */ 2960 break; 2961 case PR_SWAP_SNK_SRC_SINK_OFF: 2962 case PR_SWAP_SRC_SNK_TRANSITION_OFF: 2963 case PR_SWAP_SRC_SNK_SOURCE_OFF: 2964 case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED: 2965 case PR_SWAP_SNK_SRC_SOURCE_ON: 2966 /* 2967 * CC state change is expected in PR_SWAP 2968 * Ignore it. 2969 */ 2970 break; 2971 2972 case PORT_RESET: 2973 case PORT_RESET_WAIT_OFF: 2974 /* 2975 * State set back to default mode once the timer completes. 2976 * Ignore CC changes here. 2977 */ 2978 break; 2979 default: 2980 /* 2981 * While acting as sink and auto vbus discharge is enabled, Allow disconnect 2982 * to be driven by vbus disconnect. 2983 */ 2984 if (tcpm_port_is_disconnected(port)) 2985 tcpm_set_state(port, unattached_state(port), 0); 2986 break; 2987 } 2988 } 2989 2990 static void _tcpm_pd_vbus_on(struct tcpm_port *port) 2991 { 2992 debug("%s: VBUS on\n", __func__); 2993 port->vbus_present = true; 2994 /* 2995 * When vbus_present is true i.e. Voltage at VBUS is greater than VSAFE5V implicitly 2996 * states that vbus is not at VSAFE0V, hence clear the vbus_vsafe0v flag here. 2997 */ 2998 port->vbus_vsafe0v = false; 2999 3000 switch (port->state) { 3001 case SNK_TRANSITION_SINK_VBUS: 3002 port->explicit_contract = true; 3003 tcpm_set_state(port, SNK_READY, 0); 3004 break; 3005 case SNK_DISCOVERY: 3006 tcpm_set_state(port, SNK_DISCOVERY, 0); 3007 break; 3008 case SNK_DEBOUNCED: 3009 tcpm_set_state(port, SNK_ATTACHED, 0); 3010 break; 3011 case SNK_HARD_RESET_WAIT_VBUS: 3012 tcpm_set_state(port, SNK_HARD_RESET_SINK_ON, 0); 3013 break; 3014 case SRC_ATTACHED: 3015 tcpm_set_state(port, SRC_STARTUP, 0); 3016 break; 3017 case SRC_HARD_RESET_VBUS_ON: 3018 tcpm_set_state(port, SRC_STARTUP, 0); 3019 break; 3020 3021 case SNK_TRY: 3022 /* Do nothing, waiting for timeout */ 3023 break; 3024 case SRC_TRYWAIT: 3025 /* Do nothing, Waiting for Rd to be detected */ 3026 break; 3027 case SRC_TRYWAIT_DEBOUNCE: 3028 tcpm_set_state(port, SRC_TRYWAIT, 0); 3029 break; 3030 case SNK_TRY_WAIT_DEBOUNCE: 3031 /* Do nothing, waiting for PD_DEBOUNCE to do be done */ 3032 break; 3033 case SNK_TRYWAIT: 3034 /* Do nothing, waiting for tCCDebounce */ 3035 break; 3036 case SNK_TRYWAIT_VBUS: 3037 if (tcpm_port_is_sink(port)) 3038 tcpm_set_state(port, SNK_ATTACHED, 0); 3039 break; 3040 case SNK_TRYWAIT_DEBOUNCE: 3041 /* Do nothing, waiting for Rp */ 3042 break; 3043 case SRC_TRY_WAIT: 3044 case SRC_TRY_DEBOUNCE: 3045 /* Do nothing, waiting for sink detection */ 3046 break; 3047 3048 case PORT_RESET: 3049 case PORT_RESET_WAIT_OFF: 3050 /* 3051 * State set back to default mode once the timer completes. 3052 * Ignore vbus changes here. 3053 */ 3054 break; 3055 3056 default: 3057 break; 3058 } 3059 } 3060 3061 static void _tcpm_pd_vbus_off(struct tcpm_port *port) 3062 { 3063 debug("%s: VBUS off\n", __func__); 3064 port->vbus_present = false; 3065 port->vbus_never_low = false; 3066 switch (port->state) { 3067 case SNK_HARD_RESET_SINK_OFF: 3068 tcpm_set_state(port, SNK_HARD_RESET_WAIT_VBUS, 0); 3069 break; 3070 case HARD_RESET_SEND: 3071 break; 3072 case SNK_TRY: 3073 /* Do nothing, waiting for timeout */ 3074 break; 3075 case SRC_TRYWAIT: 3076 /* Hand over to state machine if needed */ 3077 if (tcpm_port_is_source(port)) 3078 tcpm_set_state(port, SRC_TRYWAIT_DEBOUNCE, 0); 3079 break; 3080 case SNK_TRY_WAIT_DEBOUNCE: 3081 /* Do nothing, waiting for PD_DEBOUNCE to do be done */ 3082 break; 3083 case SNK_TRYWAIT: 3084 case SNK_TRYWAIT_VBUS: 3085 case SNK_TRYWAIT_DEBOUNCE: 3086 break; 3087 case SNK_ATTACH_WAIT: 3088 port->debouncing = false; 3089 tcpm_set_state(port, SNK_UNATTACHED, 0); 3090 break; 3091 3092 case SNK_NEGOTIATE_CAPABILITIES: 3093 break; 3094 3095 case PR_SWAP_SRC_SNK_TRANSITION_OFF: 3096 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF, 0); 3097 break; 3098 3099 case PR_SWAP_SNK_SRC_SINK_OFF: 3100 /* Do nothing, expected */ 3101 break; 3102 3103 case PR_SWAP_SNK_SRC_SOURCE_ON: 3104 /* 3105 * Do nothing when vbus off notification is received. 3106 * TCPM can wait for PD_T_NEWSRC in PR_SWAP_SNK_SRC_SOURCE_ON 3107 * for the vbus source to ramp up. 3108 */ 3109 break; 3110 3111 case PORT_RESET_WAIT_OFF: 3112 tcpm_set_state(port, tcpm_default_state(port), 0); 3113 break; 3114 3115 case SRC_TRY_WAIT: 3116 case SRC_TRY_DEBOUNCE: 3117 /* Do nothing, waiting for sink detection */ 3118 break; 3119 3120 case PORT_RESET: 3121 /* 3122 * State set back to default mode once the timer completes. 3123 * Ignore vbus changes here. 3124 */ 3125 break; 3126 3127 default: 3128 if (port->pwr_role == TYPEC_SINK && port->attached) 3129 tcpm_set_state(port, SNK_UNATTACHED, 0); 3130 break; 3131 } 3132 } 3133 3134 static void _tcpm_pd_hard_reset(struct tcpm_port *port) 3135 { 3136 debug("Received hard reset\n"); 3137 port->poll_event_cnt = 0; 3138 3139 /* If a hard reset message is received during the port reset process, 3140 * we should ignore it, that is, do not set port->state to HARD_RESET_START. 3141 */ 3142 if (port->state == PORT_RESET || port->state == PORT_RESET_WAIT_OFF) 3143 return ; 3144 3145 /* 3146 * If we keep receiving hard reset requests, executing the hard reset 3147 * must have failed. Revert to error recovery if that happens. 3148 */ 3149 tcpm_set_state(port, 3150 port->hard_reset_count < PD_N_HARD_RESET_COUNT ? 3151 HARD_RESET_START : ERROR_RECOVERY, 3152 0); 3153 } 3154 3155 #if 0 3156 static void tcpm_pd_event_handler(struct tcpm_port *port) 3157 { 3158 u32 events; 3159 3160 while (port->pd_events) { 3161 events = port->pd_events; 3162 port->pd_events = 0; 3163 if (events & TCPM_RESET_EVENT) 3164 _tcpm_pd_hard_reset(port); 3165 if (events & TCPM_VBUS_EVENT) { 3166 bool vbus; 3167 3168 vbus = port->tcpc->get_vbus(port->tcpc); 3169 if (vbus) { 3170 _tcpm_pd_vbus_on(port); 3171 } else { 3172 _tcpm_pd_vbus_off(port); 3173 /* 3174 * When TCPC does not support detecting vsafe0v voltage level, 3175 * treat vbus absent as vsafe0v. Else invoke is_vbus_vsafe0v 3176 * to see if vbus has discharge to VSAFE0V. 3177 */ 3178 if (!port->tcpc->is_vbus_vsafe0v || 3179 port->tcpc->is_vbus_vsafe0v(port->tcpc)) 3180 _tcpm_pd_vbus_vsafe0v(port); 3181 } 3182 } 3183 if (events & TCPM_CC_EVENT) { 3184 enum typec_cc_status cc1, cc2; 3185 3186 if (port->tcpc->get_cc(port->tcpc, &cc1, &cc2) == 0) 3187 _tcpm_cc_change(port, cc1, cc2); 3188 } 3189 if (events & TCPM_FRS_EVENT) { 3190 if (port->state == SNK_READY) { 3191 int ret; 3192 3193 port->upcoming_state = FR_SWAP_SEND; 3194 ret = tcpm_ams_start(port, FAST_ROLE_SWAP); 3195 if (ret == -EAGAIN) 3196 port->upcoming_state = INVALID_STATE; 3197 } else { 3198 tcpm_log(port, "Discarding FRS_SIGNAL! Not in sink ready"); 3199 } 3200 } 3201 if (events & TCPM_SOURCING_VBUS) { 3202 tcpm_log(port, "sourcing vbus"); 3203 /* 3204 * In fast role swap case TCPC autonomously sources vbus. Set vbus_source 3205 * true as TCPM wouldn't have called tcpm_set_vbus. 3206 * 3207 * When vbus is sourced on the command on TCPM i.e. TCPM called 3208 * tcpm_set_vbus to source vbus, vbus_source would already be true. 3209 */ 3210 port->vbus_source = true; 3211 _tcpm_pd_vbus_on(port); 3212 } 3213 } 3214 } 3215 #endif 3216 3217 void tcpm_cc_change(struct tcpm_port *port) 3218 { 3219 enum typec_cc_status cc1, cc2; 3220 3221 port->poll_event_cnt = 0; 3222 if (port->tcpc->get_cc(port->tcpc, &cc1, &cc2) == 0) 3223 _tcpm_cc_change(port, cc1, cc2); 3224 } 3225 EXPORT_SYMBOL_GPL(tcpm_cc_change); 3226 3227 void tcpm_vbus_change(struct tcpm_port *port) 3228 { 3229 bool vbus; 3230 3231 port->poll_event_cnt = 0; 3232 vbus = port->tcpc->get_vbus(port->tcpc); 3233 if (vbus) 3234 _tcpm_pd_vbus_on(port); 3235 else 3236 _tcpm_pd_vbus_off(port); 3237 } 3238 EXPORT_SYMBOL_GPL(tcpm_vbus_change); 3239 3240 void tcpm_pd_hard_reset(struct tcpm_port *port) 3241 { 3242 port->poll_event_cnt = 0; 3243 _tcpm_pd_hard_reset(port); 3244 } 3245 EXPORT_SYMBOL_GPL(tcpm_pd_hard_reset); 3246 3247 static void tcpm_init(struct tcpm_port *port) 3248 { 3249 enum typec_cc_status cc1, cc2; 3250 3251 port->tcpc->init(port->tcpc); 3252 3253 tcpm_reset_port(port); 3254 3255 /* 3256 * XXX 3257 * Should possibly wait for VBUS to settle if it was enabled locally 3258 * since tcpm_reset_port() will disable VBUS. 3259 */ 3260 port->vbus_present = port->tcpc->get_vbus(port->tcpc); 3261 if (port->vbus_present) 3262 port->vbus_never_low = true; 3263 3264 /* 3265 * 1. When vbus_present is true, voltage on VBUS is already at VSAFE5V. 3266 * So implicitly vbus_vsafe0v = false. 3267 * 3268 * 2. When vbus_present is false and TCPC does NOT support querying 3269 * vsafe0v status, then, it's best to assume vbus is at VSAFE0V i.e. 3270 * vbus_vsafe0v is true. 3271 * 3272 * 3. When vbus_present is false and TCPC does support querying vsafe0v, 3273 * then, query tcpc for vsafe0v status. 3274 */ 3275 if (port->vbus_present) 3276 port->vbus_vsafe0v = false; 3277 else if (!port->tcpc->is_vbus_vsafe0v) 3278 port->vbus_vsafe0v = true; 3279 else 3280 port->vbus_vsafe0v = port->tcpc->is_vbus_vsafe0v(port->tcpc); 3281 3282 tcpm_set_state(port, tcpm_default_state(port), 0); 3283 3284 if (port->tcpc->get_cc(port->tcpc, &cc1, &cc2) == 0) 3285 _tcpm_cc_change(port, cc1, cc2); 3286 } 3287 3288 void tcpm_tcpc_reset(struct tcpm_port *port) 3289 { 3290 mutex_lock(&port->lock); 3291 /* XXX: Maintain PD connection if possible? */ 3292 tcpm_init(port); 3293 mutex_unlock(&port->lock); 3294 } 3295 EXPORT_SYMBOL_GPL(tcpm_tcpc_reset); 3296 3297 static int tcpm_fw_get_caps(struct tcpm_port *port) 3298 { 3299 const char *cap_str; 3300 ofnode node = port->tcpc->connector_node; 3301 int ret; 3302 u32 mw, frs_current; 3303 3304 #if 0 3305 /* USB data support is optional */ 3306 cap_str = ofnode_read_string(node, "data-role"); 3307 if (cap_str) { 3308 ret = typec_find_port_data_role(cap_str); 3309 if (ret < 0) 3310 return ret; 3311 port->typec_caps.data = ret; 3312 } 3313 #endif 3314 3315 cap_str = ofnode_read_string(node, "power-role"); 3316 if (!cap_str) { 3317 return -EINVAL; 3318 } else { 3319 if (!strcmp("dual", cap_str)) 3320 port->typec_caps.type = TYPEC_PORT_DRP; 3321 else if (!strcmp("source", cap_str)) 3322 port->typec_caps.type = TYPEC_PORT_SRC; 3323 else if (!strcmp("sink", cap_str)) 3324 port->typec_caps.type = TYPEC_PORT_SNK; 3325 else 3326 return EINVAL; 3327 } 3328 3329 port->port_type = port->typec_caps.type; 3330 3331 port->slow_charger_loop = ofnode_read_bool(node, "slow-charger-loop"); 3332 if (port->port_type == TYPEC_PORT_SNK) 3333 goto sink; 3334 3335 /* Get source pdos */ 3336 ret = ofnode_read_size(node, "source-pdos") / sizeof(u32); 3337 if (ret <= 0) 3338 return -EINVAL; 3339 3340 port->nr_src_pdo = min(ret, PDO_MAX_OBJECTS); 3341 ret = ofnode_read_u32_array(node, "source-pdos", 3342 port->src_pdo, port->nr_src_pdo); 3343 if (ret || tcpm_validate_caps(port, port->src_pdo, 3344 port->nr_src_pdo)) 3345 return -EINVAL; 3346 3347 if (port->port_type == TYPEC_PORT_SRC) 3348 return 0; 3349 3350 /* Get the preferred power role for DRP */ 3351 cap_str = ofnode_read_string(node, "try-power-role"); 3352 if (!cap_str) { 3353 return -EINVAL; 3354 } else { 3355 if (!strcmp("sink", cap_str)) 3356 port->typec_caps.prefer_role = TYPEC_SINK; 3357 else if (!strcmp("source", cap_str)) 3358 port->typec_caps.prefer_role = TYPEC_SOURCE; 3359 else 3360 return -EINVAL; 3361 } 3362 if (port->typec_caps.prefer_role < 0) 3363 return -EINVAL; 3364 sink: 3365 /* Get sink pdos */ 3366 ret = ofnode_read_size(node, "sink-pdos") / sizeof(u32); 3367 if (ret <= 0) 3368 return -EINVAL; 3369 3370 port->nr_snk_pdo = min(ret, PDO_MAX_OBJECTS); 3371 ret = ofnode_read_u32_array(node, "sink-pdos", 3372 port->snk_pdo, port->nr_snk_pdo); 3373 if (ret || tcpm_validate_caps(port, port->snk_pdo, 3374 port->nr_snk_pdo)) 3375 return -EINVAL; 3376 3377 if (ofnode_read_u32_array(node, "op-sink-microwatt", &mw, 1)) 3378 return -EINVAL; 3379 port->operating_snk_mw = mw / 1000; 3380 3381 port->self_powered = ofnode_read_bool(node, "self-powered"); 3382 3383 /* FRS can only be supported by DRP ports */ 3384 if (port->port_type == TYPEC_PORT_DRP) { 3385 ret = ofnode_read_u32_array(node, "new-source-frs-typec-current", 3386 &frs_current, 1); 3387 if (ret >= 0 && frs_current <= FRS_5V_3A) 3388 port->new_source_frs_current = frs_current; 3389 } 3390 3391 /* sink-vdos is optional */ 3392 ret = ofnode_read_size(node, "sink-vdos") / sizeof(u32); 3393 if (ret < 0) 3394 ret = 0; 3395 3396 port->nr_snk_vdo = min(ret, VDO_MAX_OBJECTS); 3397 if (port->nr_snk_vdo) { 3398 ret = ofnode_read_u32_array(node, "sink-vdos", 3399 port->snk_vdo, port->nr_snk_vdo); 3400 if (ret) 3401 return ret; 3402 } 3403 3404 /* If sink-vdos is found, sink-vdos-v1 is expected for backward compatibility. */ 3405 if (port->nr_snk_vdo) { 3406 ret = ofnode_read_size(node, "sink-vdos-v1") / sizeof(u32); 3407 if (ret < 0) 3408 return ret; 3409 else if (ret == 0) 3410 return -ENODATA; 3411 3412 port->nr_snk_vdo_v1 = min(ret, VDO_MAX_OBJECTS); 3413 ret = ofnode_read_u32_array(node, "sink-vdos-v1", 3414 port->snk_vdo_v1, 3415 port->nr_snk_vdo_v1); 3416 if (ret) 3417 return ret; 3418 } 3419 3420 return 0; 3421 } 3422 3423 struct tcpm_port *tcpm_port_init(struct udevice *dev, struct tcpc_dev *tcpc) 3424 { 3425 struct tcpm_port *port; 3426 int err; 3427 3428 if (!dev || !tcpc || 3429 !tcpc->get_vbus || !tcpc->set_cc || !tcpc->get_cc || 3430 !tcpc->set_polarity || !tcpc->set_vconn || !tcpc->set_vbus || 3431 !tcpc->set_pd_rx || !tcpc->set_roles || !tcpc->pd_transmit) 3432 return ERR_PTR(-EINVAL); 3433 3434 port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL); 3435 if (!port) 3436 return ERR_PTR(-ENOMEM); 3437 3438 port->dev = dev; 3439 port->tcpc = tcpc; 3440 3441 err = tcpm_fw_get_caps(port); 3442 if (err < 0) { 3443 printf("%s: please check the dts config of %s node(%d)\n", 3444 __func__, dev_read_name(dev), err); 3445 return ERR_PTR(err); 3446 } 3447 3448 port->try_role = port->typec_caps.prefer_role; 3449 3450 port->typec_caps.revision = 0x0120; /* Type-C spec release 1.2 */ 3451 port->typec_caps.pd_revision = 0x0300; /* USB-PD spec release 3.0 */ 3452 port->typec_caps.svdm_version = SVDM_VER_2_0; 3453 port->typec_caps.driver_data = port; 3454 port->typec_caps.orientation_aware = 1; 3455 3456 port->port_type = port->typec_caps.type; 3457 3458 tcpm_init(port); 3459 3460 printf("%s: init finished\n", dev_read_name(dev)); 3461 3462 return port; 3463 } 3464 EXPORT_SYMBOL_GPL(tcpm_port_init); 3465 3466 void tcpm_poll_event(struct tcpm_port *port) 3467 { 3468 if (!port->tcpc->get_vbus(port->tcpc)) 3469 return ; 3470 3471 while (port->poll_event_cnt < TCPM_POLL_EVENT_TIME_OUT) { 3472 if (!port->wait_dr_swap_Message && 3473 ((port->state == SNK_READY) || 3474 (port->state == SRC_READY) || 3475 (port->state == DEBUG_ACC_ATTACHED) || 3476 (port->state == AUDIO_ACC_ATTACHED))) 3477 break; 3478 3479 port->tcpc->poll_event(port->tcpc); 3480 port->poll_event_cnt++; 3481 udelay(500); 3482 } 3483 3484 /* 3485 * At this time, call the callback function of the respective pd chip 3486 * to enter the low-power mode. In order to reduce the time spent on 3487 * the PD chip driver as much as possible, the tcpm framework does not 3488 * fully process the communication initiated by the device,so it should 3489 * be noted that we can disable the internal oscillator, etc., but do 3490 * not turn off the power of the transceiver module, otherwise the 3491 * self-powered Type-C device will initiate a Message(eg: self-powered 3492 * Type-C hub initiates a SINK capability request(PD_CTRL_GET_SINK_CAP)) 3493 * and the pd chip cannot reply to GoodCRC, causing the self-powered Type-C 3494 * device to switch vbus to vSafe5v, or even turn off vbus. 3495 */ 3496 if (port->tcpc->enter_low_power_mode) { 3497 if (port->tcpc->enter_low_power_mode(port->tcpc, 3498 port->attached, 3499 port->pd_capable)) 3500 printf("failed to enter low power\n"); 3501 else 3502 printf("PD chip enter low power mode\n"); 3503 } 3504 } 3505 EXPORT_SYMBOL_GPL(tcpm_poll_event); 3506 3507 int tcpm_get_voltage(struct tcpm_port *port) 3508 { 3509 return port->supply_voltage * 1000; 3510 } 3511 EXPORT_SYMBOL_GPL(tcpm_get_voltage); 3512 3513 int tcpm_get_current(struct tcpm_port *port) 3514 { 3515 return port->current_limit * 1000; 3516 } 3517 EXPORT_SYMBOL_GPL(tcpm_get_voltage); 3518 3519 int tcpm_get_online(struct tcpm_port *port) 3520 { 3521 if (port->state == SNK_READY) 3522 return 1; 3523 else 3524 return 0; 3525 } 3526 EXPORT_SYMBOL_GPL(tcpm_get_online); 3527 3528 void tcpm_uninit_port(struct tcpm_port *port) 3529 { 3530 tcpm_reset_port(port); 3531 } 3532 EXPORT_SYMBOL_GPL(tcpm_unregister_port); 3533