1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2015-2017 Google, Inc 4 * 5 * USB Power Delivery protocol stack. 6 */ 7 8 #include <linux/completion.h> 9 #include <linux/debugfs.h> 10 #include <linux/device.h> 11 #include <linux/jiffies.h> 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/mutex.h> 15 #include <linux/power_supply.h> 16 #include <linux/proc_fs.h> 17 #include <linux/property.h> 18 #include <linux/sched/clock.h> 19 #include <linux/seq_file.h> 20 #include <linux/slab.h> 21 #include <linux/spinlock.h> 22 #include <linux/usb.h> 23 #include <linux/usb/pd.h> 24 #include <linux/usb/pd_ado.h> 25 #include <linux/usb/pd_bdo.h> 26 #include <linux/usb/pd_ext_sdb.h> 27 #include <linux/usb/pd_vdo.h> 28 #include <linux/usb/role.h> 29 #include <linux/usb/tcpm.h> 30 #include <linux/usb/typec_altmode.h> 31 #include <linux/workqueue.h> 32 33 #define FOREACH_STATE(S) \ 34 S(INVALID_STATE), \ 35 S(TOGGLING), \ 36 S(SRC_UNATTACHED), \ 37 S(SRC_ATTACH_WAIT), \ 38 S(SRC_ATTACHED), \ 39 S(SRC_STARTUP), \ 40 S(SRC_SEND_CAPABILITIES), \ 41 S(SRC_SEND_CAPABILITIES_TIMEOUT), \ 42 S(SRC_NEGOTIATE_CAPABILITIES), \ 43 S(SRC_TRANSITION_SUPPLY), \ 44 S(SRC_READY), \ 45 S(SRC_WAIT_NEW_CAPABILITIES), \ 46 \ 47 S(SNK_UNATTACHED), \ 48 S(SNK_ATTACH_WAIT), \ 49 S(SNK_DEBOUNCED), \ 50 S(SNK_ATTACHED), \ 51 S(SNK_STARTUP), \ 52 S(SNK_DISCOVERY), \ 53 S(SNK_DISCOVERY_DEBOUNCE), \ 54 S(SNK_DISCOVERY_DEBOUNCE_DONE), \ 55 S(SNK_WAIT_CAPABILITIES), \ 56 S(SNK_NEGOTIATE_CAPABILITIES), \ 57 S(SNK_NEGOTIATE_PPS_CAPABILITIES), \ 58 S(SNK_TRANSITION_SINK), \ 59 S(SNK_TRANSITION_SINK_VBUS), \ 60 S(SNK_READY), \ 61 \ 62 S(ACC_UNATTACHED), \ 63 S(DEBUG_ACC_ATTACHED), \ 64 S(AUDIO_ACC_ATTACHED), \ 65 S(AUDIO_ACC_DEBOUNCE), \ 66 \ 67 S(HARD_RESET_SEND), \ 68 S(HARD_RESET_START), \ 69 S(SRC_HARD_RESET_VBUS_OFF), \ 70 S(SRC_HARD_RESET_VBUS_ON), \ 71 S(SNK_HARD_RESET_SINK_OFF), \ 72 S(SNK_HARD_RESET_WAIT_VBUS), \ 73 S(SNK_HARD_RESET_SINK_ON), \ 74 \ 75 S(SOFT_RESET), \ 76 S(SOFT_RESET_SEND), \ 77 \ 78 S(DR_SWAP_ACCEPT), \ 79 S(DR_SWAP_SEND), \ 80 S(DR_SWAP_SEND_TIMEOUT), \ 81 S(DR_SWAP_CANCEL), \ 82 S(DR_SWAP_CHANGE_DR), \ 83 \ 84 S(PR_SWAP_ACCEPT), \ 85 S(PR_SWAP_SEND), \ 86 S(PR_SWAP_SEND_TIMEOUT), \ 87 S(PR_SWAP_CANCEL), \ 88 S(PR_SWAP_START), \ 89 S(PR_SWAP_SRC_SNK_TRANSITION_OFF), \ 90 S(PR_SWAP_SRC_SNK_SOURCE_OFF), \ 91 S(PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED), \ 92 S(PR_SWAP_SRC_SNK_SINK_ON), \ 93 S(PR_SWAP_SNK_SRC_SINK_OFF), \ 94 S(PR_SWAP_SNK_SRC_SOURCE_ON), \ 95 S(PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP), \ 96 \ 97 S(VCONN_SWAP_ACCEPT), \ 98 S(VCONN_SWAP_SEND), \ 99 S(VCONN_SWAP_SEND_TIMEOUT), \ 100 S(VCONN_SWAP_CANCEL), \ 101 S(VCONN_SWAP_START), \ 102 S(VCONN_SWAP_WAIT_FOR_VCONN), \ 103 S(VCONN_SWAP_TURN_ON_VCONN), \ 104 S(VCONN_SWAP_TURN_OFF_VCONN), \ 105 \ 106 S(SNK_TRY), \ 107 S(SNK_TRY_WAIT), \ 108 S(SNK_TRY_WAIT_DEBOUNCE), \ 109 S(SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS), \ 110 S(SRC_TRYWAIT), \ 111 S(SRC_TRYWAIT_DEBOUNCE), \ 112 S(SRC_TRYWAIT_UNATTACHED), \ 113 \ 114 S(SRC_TRY), \ 115 S(SRC_TRY_WAIT), \ 116 S(SRC_TRY_DEBOUNCE), \ 117 S(SNK_TRYWAIT), \ 118 S(SNK_TRYWAIT_DEBOUNCE), \ 119 S(SNK_TRYWAIT_VBUS), \ 120 S(BIST_RX), \ 121 \ 122 S(GET_STATUS_SEND), \ 123 S(GET_STATUS_SEND_TIMEOUT), \ 124 S(GET_PPS_STATUS_SEND), \ 125 S(GET_PPS_STATUS_SEND_TIMEOUT), \ 126 \ 127 S(ERROR_RECOVERY), \ 128 S(PORT_RESET), \ 129 S(PORT_RESET_WAIT_OFF) 130 131 #define GENERATE_ENUM(e) e 132 #define GENERATE_STRING(s) #s 133 134 enum tcpm_state { 135 FOREACH_STATE(GENERATE_ENUM) 136 }; 137 138 static const char * const tcpm_states[] = { 139 FOREACH_STATE(GENERATE_STRING) 140 }; 141 142 enum vdm_states { 143 VDM_STATE_ERR_BUSY = -3, 144 VDM_STATE_ERR_SEND = -2, 145 VDM_STATE_ERR_TMOUT = -1, 146 VDM_STATE_DONE = 0, 147 /* Anything >0 represents an active state */ 148 VDM_STATE_READY = 1, 149 VDM_STATE_BUSY = 2, 150 VDM_STATE_WAIT_RSP_BUSY = 3, 151 }; 152 153 enum pd_msg_request { 154 PD_MSG_NONE = 0, 155 PD_MSG_CTRL_REJECT, 156 PD_MSG_CTRL_WAIT, 157 PD_MSG_CTRL_NOT_SUPP, 158 PD_MSG_DATA_SINK_CAP, 159 PD_MSG_DATA_SOURCE_CAP, 160 }; 161 162 /* Events from low level driver */ 163 164 #define TCPM_CC_EVENT BIT(0) 165 #define TCPM_VBUS_EVENT BIT(1) 166 #define TCPM_RESET_EVENT BIT(2) 167 168 #define LOG_BUFFER_ENTRIES 1024 169 #define LOG_BUFFER_ENTRY_SIZE 128 170 171 /* Alternate mode support */ 172 173 #define SVID_DISCOVERY_MAX 16 174 #define ALTMODE_DISCOVERY_MAX (SVID_DISCOVERY_MAX * MODE_DISCOVERY_MAX) 175 176 struct pd_mode_data { 177 int svid_index; /* current SVID index */ 178 int nsvids; 179 u16 svids[SVID_DISCOVERY_MAX]; 180 int altmodes; /* number of alternate modes */ 181 struct typec_altmode_desc altmode_desc[ALTMODE_DISCOVERY_MAX]; 182 }; 183 184 struct pd_pps_data { 185 u32 min_volt; 186 u32 max_volt; 187 u32 max_curr; 188 u32 out_volt; 189 u32 op_curr; 190 bool supported; 191 bool active; 192 }; 193 194 struct tcpm_port { 195 struct device *dev; 196 197 struct mutex lock; /* tcpm state machine lock */ 198 struct workqueue_struct *wq; 199 200 struct typec_capability typec_caps; 201 struct typec_port *typec_port; 202 203 struct tcpc_dev *tcpc; 204 struct usb_role_switch *role_sw; 205 206 enum typec_role vconn_role; 207 enum typec_role pwr_role; 208 enum typec_data_role data_role; 209 enum typec_pwr_opmode pwr_opmode; 210 211 struct usb_pd_identity partner_ident; 212 struct typec_partner_desc partner_desc; 213 struct typec_partner *partner; 214 215 enum typec_cc_status cc_req; 216 217 enum typec_cc_status cc1; 218 enum typec_cc_status cc2; 219 enum typec_cc_polarity polarity; 220 221 bool attached; 222 bool connected; 223 enum typec_port_type port_type; 224 bool vbus_present; 225 bool vbus_never_low; 226 bool vbus_source; 227 bool vbus_charge; 228 229 bool send_discover; 230 bool op_vsafe5v; 231 232 int try_role; 233 int try_snk_count; 234 int try_src_count; 235 236 enum pd_msg_request queued_message; 237 238 enum tcpm_state enter_state; 239 enum tcpm_state prev_state; 240 enum tcpm_state state; 241 enum tcpm_state delayed_state; 242 unsigned long delayed_runtime; 243 unsigned long delay_ms; 244 245 spinlock_t pd_event_lock; 246 u32 pd_events; 247 248 struct work_struct event_work; 249 struct delayed_work state_machine; 250 struct delayed_work vdm_state_machine; 251 bool state_machine_running; 252 253 struct completion tx_complete; 254 enum tcpm_transmit_status tx_status; 255 256 struct mutex swap_lock; /* swap command lock */ 257 bool swap_pending; 258 bool non_pd_role_swap; 259 struct completion swap_complete; 260 int swap_status; 261 262 unsigned int negotiated_rev; 263 unsigned int message_id; 264 unsigned int caps_count; 265 unsigned int hard_reset_count; 266 bool pd_capable; 267 bool explicit_contract; 268 unsigned int rx_msgid; 269 270 /* Partner capabilities/requests */ 271 u32 sink_request; 272 u32 source_caps[PDO_MAX_OBJECTS]; 273 unsigned int nr_source_caps; 274 u32 sink_caps[PDO_MAX_OBJECTS]; 275 unsigned int nr_sink_caps; 276 277 /* Local capabilities */ 278 u32 src_pdo[PDO_MAX_OBJECTS]; 279 unsigned int nr_src_pdo; 280 u32 snk_pdo[PDO_MAX_OBJECTS]; 281 unsigned int nr_snk_pdo; 282 u32 snk_vdo[VDO_MAX_OBJECTS]; 283 unsigned int nr_snk_vdo; 284 285 unsigned int operating_snk_mw; 286 bool update_sink_caps; 287 288 /* Requested current / voltage */ 289 u32 current_limit; 290 u32 supply_voltage; 291 292 /* Used to export TA voltage and current */ 293 struct power_supply *psy; 294 struct power_supply_desc psy_desc; 295 enum power_supply_usb_type usb_type; 296 297 u32 bist_request; 298 299 /* PD state for Vendor Defined Messages */ 300 enum vdm_states vdm_state; 301 u32 vdm_retries; 302 /* next Vendor Defined Message to send */ 303 u32 vdo_data[VDO_MAX_SIZE]; 304 u8 vdo_count; 305 /* VDO to retry if UFP responder replied busy */ 306 u32 vdo_retry; 307 308 /* PPS */ 309 struct pd_pps_data pps_data; 310 struct completion pps_complete; 311 bool pps_pending; 312 int pps_status; 313 314 /* Alternate mode data */ 315 struct pd_mode_data mode_data; 316 struct typec_altmode *partner_altmode[ALTMODE_DISCOVERY_MAX]; 317 struct typec_altmode *port_altmode[ALTMODE_DISCOVERY_MAX]; 318 319 /* Deadline in jiffies to exit src_try_wait state */ 320 unsigned long max_wait; 321 322 /* port belongs to a self powered device */ 323 bool self_powered; 324 325 #ifdef CONFIG_DEBUG_FS 326 struct dentry *dentry; 327 struct mutex logbuffer_lock; /* log buffer access lock */ 328 int logbuffer_head; 329 int logbuffer_tail; 330 u8 *logbuffer[LOG_BUFFER_ENTRIES]; 331 #endif 332 }; 333 334 struct pd_rx_event { 335 struct work_struct work; 336 struct tcpm_port *port; 337 struct pd_message msg; 338 }; 339 340 #define tcpm_cc_is_sink(cc) \ 341 ((cc) == TYPEC_CC_RP_DEF || (cc) == TYPEC_CC_RP_1_5 || \ 342 (cc) == TYPEC_CC_RP_3_0) 343 344 #define tcpm_port_is_sink(port) \ 345 ((tcpm_cc_is_sink((port)->cc1) && !tcpm_cc_is_sink((port)->cc2)) || \ 346 (tcpm_cc_is_sink((port)->cc2) && !tcpm_cc_is_sink((port)->cc1))) 347 348 #define tcpm_cc_is_source(cc) ((cc) == TYPEC_CC_RD) 349 #define tcpm_cc_is_audio(cc) ((cc) == TYPEC_CC_RA) 350 #define tcpm_cc_is_open(cc) ((cc) == TYPEC_CC_OPEN) 351 352 #define tcpm_port_is_source(port) \ 353 ((tcpm_cc_is_source((port)->cc1) && \ 354 !tcpm_cc_is_source((port)->cc2)) || \ 355 (tcpm_cc_is_source((port)->cc2) && \ 356 !tcpm_cc_is_source((port)->cc1))) 357 358 #define tcpm_port_is_debug(port) \ 359 (tcpm_cc_is_source((port)->cc1) && tcpm_cc_is_source((port)->cc2)) 360 361 #define tcpm_port_is_audio(port) \ 362 (tcpm_cc_is_audio((port)->cc1) && tcpm_cc_is_audio((port)->cc2)) 363 364 #define tcpm_port_is_audio_detached(port) \ 365 ((tcpm_cc_is_audio((port)->cc1) && tcpm_cc_is_open((port)->cc2)) || \ 366 (tcpm_cc_is_audio((port)->cc2) && tcpm_cc_is_open((port)->cc1))) 367 368 #define tcpm_try_snk(port) \ 369 ((port)->try_snk_count == 0 && (port)->try_role == TYPEC_SINK && \ 370 (port)->port_type == TYPEC_PORT_DRP) 371 372 #define tcpm_try_src(port) \ 373 ((port)->try_src_count == 0 && (port)->try_role == TYPEC_SOURCE && \ 374 (port)->port_type == TYPEC_PORT_DRP) 375 376 #define tcpm_data_role_for_source(port) \ 377 ((port)->typec_caps.data == TYPEC_PORT_UFP ? \ 378 TYPEC_DEVICE : TYPEC_HOST) 379 380 #define tcpm_data_role_for_sink(port) \ 381 ((port)->typec_caps.data == TYPEC_PORT_DFP ? \ 382 TYPEC_HOST : TYPEC_DEVICE) 383 384 static enum tcpm_state tcpm_default_state(struct tcpm_port *port) 385 { 386 if (port->port_type == TYPEC_PORT_DRP) { 387 if (port->try_role == TYPEC_SINK) 388 return SNK_UNATTACHED; 389 else if (port->try_role == TYPEC_SOURCE) 390 return SRC_UNATTACHED; 391 /* Fall through to return SRC_UNATTACHED */ 392 } else if (port->port_type == TYPEC_PORT_SNK) { 393 return SNK_UNATTACHED; 394 } 395 return SRC_UNATTACHED; 396 } 397 398 static bool tcpm_port_is_disconnected(struct tcpm_port *port) 399 { 400 return (!port->attached && port->cc1 == TYPEC_CC_OPEN && 401 port->cc2 == TYPEC_CC_OPEN) || 402 (port->attached && ((port->polarity == TYPEC_POLARITY_CC1 && 403 port->cc1 == TYPEC_CC_OPEN) || 404 (port->polarity == TYPEC_POLARITY_CC2 && 405 port->cc2 == TYPEC_CC_OPEN))); 406 } 407 408 /* 409 * Logging 410 */ 411 412 #ifdef CONFIG_DEBUG_FS 413 414 static bool tcpm_log_full(struct tcpm_port *port) 415 { 416 return port->logbuffer_tail == 417 (port->logbuffer_head + 1) % LOG_BUFFER_ENTRIES; 418 } 419 420 __printf(2, 0) 421 static void _tcpm_log(struct tcpm_port *port, const char *fmt, va_list args) 422 { 423 char tmpbuffer[LOG_BUFFER_ENTRY_SIZE]; 424 u64 ts_nsec = local_clock(); 425 unsigned long rem_nsec; 426 427 mutex_lock(&port->logbuffer_lock); 428 if (!port->logbuffer[port->logbuffer_head]) { 429 port->logbuffer[port->logbuffer_head] = 430 kzalloc(LOG_BUFFER_ENTRY_SIZE, GFP_KERNEL); 431 if (!port->logbuffer[port->logbuffer_head]) { 432 mutex_unlock(&port->logbuffer_lock); 433 return; 434 } 435 } 436 437 vsnprintf(tmpbuffer, sizeof(tmpbuffer), fmt, args); 438 439 if (tcpm_log_full(port)) { 440 port->logbuffer_head = max(port->logbuffer_head - 1, 0); 441 strcpy(tmpbuffer, "overflow"); 442 } 443 444 if (port->logbuffer_head < 0 || 445 port->logbuffer_head >= LOG_BUFFER_ENTRIES) { 446 dev_warn(port->dev, 447 "Bad log buffer index %d\n", port->logbuffer_head); 448 goto abort; 449 } 450 451 if (!port->logbuffer[port->logbuffer_head]) { 452 dev_warn(port->dev, 453 "Log buffer index %d is NULL\n", port->logbuffer_head); 454 goto abort; 455 } 456 457 rem_nsec = do_div(ts_nsec, 1000000000); 458 scnprintf(port->logbuffer[port->logbuffer_head], 459 LOG_BUFFER_ENTRY_SIZE, "[%5lu.%06lu] %s", 460 (unsigned long)ts_nsec, rem_nsec / 1000, 461 tmpbuffer); 462 port->logbuffer_head = (port->logbuffer_head + 1) % LOG_BUFFER_ENTRIES; 463 464 abort: 465 mutex_unlock(&port->logbuffer_lock); 466 } 467 468 __printf(2, 3) 469 static void tcpm_log(struct tcpm_port *port, const char *fmt, ...) 470 { 471 va_list args; 472 473 /* Do not log while disconnected and unattached */ 474 if (tcpm_port_is_disconnected(port) && 475 (port->state == SRC_UNATTACHED || port->state == SNK_UNATTACHED || 476 port->state == TOGGLING)) 477 return; 478 479 va_start(args, fmt); 480 _tcpm_log(port, fmt, args); 481 va_end(args); 482 } 483 484 __printf(2, 3) 485 static void tcpm_log_force(struct tcpm_port *port, const char *fmt, ...) 486 { 487 va_list args; 488 489 va_start(args, fmt); 490 _tcpm_log(port, fmt, args); 491 va_end(args); 492 } 493 494 static void tcpm_log_source_caps(struct tcpm_port *port) 495 { 496 int i; 497 498 for (i = 0; i < port->nr_source_caps; i++) { 499 u32 pdo = port->source_caps[i]; 500 enum pd_pdo_type type = pdo_type(pdo); 501 char msg[64]; 502 503 switch (type) { 504 case PDO_TYPE_FIXED: 505 scnprintf(msg, sizeof(msg), 506 "%u mV, %u mA [%s%s%s%s%s%s]", 507 pdo_fixed_voltage(pdo), 508 pdo_max_current(pdo), 509 (pdo & PDO_FIXED_DUAL_ROLE) ? 510 "R" : "", 511 (pdo & PDO_FIXED_SUSPEND) ? 512 "S" : "", 513 (pdo & PDO_FIXED_HIGHER_CAP) ? 514 "H" : "", 515 (pdo & PDO_FIXED_USB_COMM) ? 516 "U" : "", 517 (pdo & PDO_FIXED_DATA_SWAP) ? 518 "D" : "", 519 (pdo & PDO_FIXED_EXTPOWER) ? 520 "E" : ""); 521 break; 522 case PDO_TYPE_VAR: 523 scnprintf(msg, sizeof(msg), 524 "%u-%u mV, %u mA", 525 pdo_min_voltage(pdo), 526 pdo_max_voltage(pdo), 527 pdo_max_current(pdo)); 528 break; 529 case PDO_TYPE_BATT: 530 scnprintf(msg, sizeof(msg), 531 "%u-%u mV, %u mW", 532 pdo_min_voltage(pdo), 533 pdo_max_voltage(pdo), 534 pdo_max_power(pdo)); 535 break; 536 case PDO_TYPE_APDO: 537 if (pdo_apdo_type(pdo) == APDO_TYPE_PPS) 538 scnprintf(msg, sizeof(msg), 539 "%u-%u mV, %u mA", 540 pdo_pps_apdo_min_voltage(pdo), 541 pdo_pps_apdo_max_voltage(pdo), 542 pdo_pps_apdo_max_current(pdo)); 543 else 544 strcpy(msg, "undefined APDO"); 545 break; 546 default: 547 strcpy(msg, "undefined"); 548 break; 549 } 550 tcpm_log(port, " PDO %d: type %d, %s", 551 i, type, msg); 552 } 553 } 554 555 static int tcpm_debug_show(struct seq_file *s, void *v) 556 { 557 struct tcpm_port *port = (struct tcpm_port *)s->private; 558 int tail; 559 560 mutex_lock(&port->logbuffer_lock); 561 tail = port->logbuffer_tail; 562 while (tail != port->logbuffer_head) { 563 seq_printf(s, "%s\n", port->logbuffer[tail]); 564 tail = (tail + 1) % LOG_BUFFER_ENTRIES; 565 } 566 if (!seq_has_overflowed(s)) 567 port->logbuffer_tail = tail; 568 mutex_unlock(&port->logbuffer_lock); 569 570 return 0; 571 } 572 DEFINE_SHOW_ATTRIBUTE(tcpm_debug); 573 574 static void tcpm_debugfs_init(struct tcpm_port *port) 575 { 576 char name[NAME_MAX]; 577 578 mutex_init(&port->logbuffer_lock); 579 snprintf(name, NAME_MAX, "tcpm-%s", dev_name(port->dev)); 580 port->dentry = debugfs_create_file(name, S_IFREG | 0444, usb_debug_root, 581 port, &tcpm_debug_fops); 582 } 583 584 static void tcpm_debugfs_exit(struct tcpm_port *port) 585 { 586 int i; 587 588 mutex_lock(&port->logbuffer_lock); 589 for (i = 0; i < LOG_BUFFER_ENTRIES; i++) { 590 kfree(port->logbuffer[i]); 591 port->logbuffer[i] = NULL; 592 } 593 mutex_unlock(&port->logbuffer_lock); 594 595 debugfs_remove(port->dentry); 596 } 597 598 #else 599 600 __printf(2, 3) 601 static void tcpm_log(const struct tcpm_port *port, const char *fmt, ...) { } 602 __printf(2, 3) 603 static void tcpm_log_force(struct tcpm_port *port, const char *fmt, ...) { } 604 static void tcpm_log_source_caps(struct tcpm_port *port) { } 605 static void tcpm_debugfs_init(const struct tcpm_port *port) { } 606 static void tcpm_debugfs_exit(const struct tcpm_port *port) { } 607 608 #endif 609 610 static int tcpm_pd_transmit(struct tcpm_port *port, 611 enum tcpm_transmit_type type, 612 const struct pd_message *msg) 613 { 614 unsigned long timeout; 615 int ret; 616 617 if (msg) 618 tcpm_log(port, "PD TX, header: %#x", le16_to_cpu(msg->header)); 619 else 620 tcpm_log(port, "PD TX, type: %#x", type); 621 622 reinit_completion(&port->tx_complete); 623 ret = port->tcpc->pd_transmit(port->tcpc, type, msg); 624 if (ret < 0) 625 return ret; 626 627 mutex_unlock(&port->lock); 628 timeout = wait_for_completion_timeout(&port->tx_complete, 629 msecs_to_jiffies(PD_T_TCPC_TX_TIMEOUT)); 630 mutex_lock(&port->lock); 631 if (!timeout) 632 return -ETIMEDOUT; 633 634 switch (port->tx_status) { 635 case TCPC_TX_SUCCESS: 636 port->message_id = (port->message_id + 1) & PD_HEADER_ID_MASK; 637 return 0; 638 case TCPC_TX_DISCARDED: 639 return -EAGAIN; 640 case TCPC_TX_FAILED: 641 default: 642 return -EIO; 643 } 644 } 645 646 void tcpm_pd_transmit_complete(struct tcpm_port *port, 647 enum tcpm_transmit_status status) 648 { 649 tcpm_log(port, "PD TX complete, status: %u", status); 650 port->tx_status = status; 651 complete(&port->tx_complete); 652 } 653 EXPORT_SYMBOL_GPL(tcpm_pd_transmit_complete); 654 655 static int tcpm_mux_set(struct tcpm_port *port, int state, 656 enum usb_role usb_role, 657 enum typec_orientation orientation) 658 { 659 int ret; 660 661 tcpm_log(port, "Requesting mux state %d, usb-role %d, orientation %d", 662 state, usb_role, orientation); 663 664 ret = typec_set_orientation(port->typec_port, orientation); 665 if (ret) 666 return ret; 667 668 if (port->role_sw) { 669 ret = usb_role_switch_set_role(port->role_sw, usb_role); 670 if (ret) 671 return ret; 672 } 673 674 return typec_set_mode(port->typec_port, state); 675 } 676 677 static int tcpm_set_polarity(struct tcpm_port *port, 678 enum typec_cc_polarity polarity) 679 { 680 int ret; 681 682 tcpm_log(port, "polarity %d", polarity); 683 684 ret = port->tcpc->set_polarity(port->tcpc, polarity); 685 if (ret < 0) 686 return ret; 687 688 port->polarity = polarity; 689 690 return 0; 691 } 692 693 static int tcpm_set_vconn(struct tcpm_port *port, bool enable) 694 { 695 int ret; 696 697 tcpm_log(port, "vconn:=%d", enable); 698 699 ret = port->tcpc->set_vconn(port->tcpc, enable); 700 if (!ret) { 701 port->vconn_role = enable ? TYPEC_SOURCE : TYPEC_SINK; 702 typec_set_vconn_role(port->typec_port, port->vconn_role); 703 } 704 705 return ret; 706 } 707 708 static u32 tcpm_get_current_limit(struct tcpm_port *port) 709 { 710 enum typec_cc_status cc; 711 u32 limit; 712 713 cc = port->polarity ? port->cc2 : port->cc1; 714 switch (cc) { 715 case TYPEC_CC_RP_1_5: 716 limit = 1500; 717 break; 718 case TYPEC_CC_RP_3_0: 719 limit = 3000; 720 break; 721 case TYPEC_CC_RP_DEF: 722 default: 723 if (port->tcpc->get_current_limit) 724 limit = port->tcpc->get_current_limit(port->tcpc); 725 else 726 limit = 0; 727 break; 728 } 729 730 return limit; 731 } 732 733 static int tcpm_set_current_limit(struct tcpm_port *port, u32 max_ma, u32 mv) 734 { 735 int ret = -EOPNOTSUPP; 736 737 tcpm_log(port, "Setting voltage/current limit %u mV %u mA", mv, max_ma); 738 739 port->supply_voltage = mv; 740 port->current_limit = max_ma; 741 742 if (port->tcpc->set_current_limit) 743 ret = port->tcpc->set_current_limit(port->tcpc, max_ma, mv); 744 745 return ret; 746 } 747 748 /* 749 * Determine RP value to set based on maximum current supported 750 * by a port if configured as source. 751 * Returns CC value to report to link partner. 752 */ 753 static enum typec_cc_status tcpm_rp_cc(struct tcpm_port *port) 754 { 755 const u32 *src_pdo = port->src_pdo; 756 int nr_pdo = port->nr_src_pdo; 757 int i; 758 759 /* 760 * Search for first entry with matching voltage. 761 * It should report the maximum supported current. 762 */ 763 for (i = 0; i < nr_pdo; i++) { 764 const u32 pdo = src_pdo[i]; 765 766 if (pdo_type(pdo) == PDO_TYPE_FIXED && 767 pdo_fixed_voltage(pdo) == 5000) { 768 unsigned int curr = pdo_max_current(pdo); 769 770 if (curr >= 3000) 771 return TYPEC_CC_RP_3_0; 772 else if (curr >= 1500) 773 return TYPEC_CC_RP_1_5; 774 return TYPEC_CC_RP_DEF; 775 } 776 } 777 778 return TYPEC_CC_RP_DEF; 779 } 780 781 static int tcpm_set_attached_state(struct tcpm_port *port, bool attached) 782 { 783 return port->tcpc->set_roles(port->tcpc, attached, port->pwr_role, 784 port->data_role); 785 } 786 787 static int tcpm_set_roles(struct tcpm_port *port, bool attached, 788 enum typec_role role, enum typec_data_role data) 789 { 790 enum typec_orientation orientation; 791 enum usb_role usb_role; 792 int ret; 793 794 if (port->polarity == TYPEC_POLARITY_CC1) 795 orientation = TYPEC_ORIENTATION_NORMAL; 796 else 797 orientation = TYPEC_ORIENTATION_REVERSE; 798 799 if (port->typec_caps.data == TYPEC_PORT_DRD) { 800 if (data == TYPEC_HOST) 801 usb_role = USB_ROLE_HOST; 802 else 803 usb_role = USB_ROLE_DEVICE; 804 } else if (port->typec_caps.data == TYPEC_PORT_DFP) { 805 if (data == TYPEC_HOST) { 806 if (role == TYPEC_SOURCE) 807 usb_role = USB_ROLE_HOST; 808 else 809 usb_role = USB_ROLE_NONE; 810 } else { 811 return -ENOTSUPP; 812 } 813 } else { 814 if (data == TYPEC_DEVICE) { 815 if (role == TYPEC_SINK) 816 usb_role = USB_ROLE_DEVICE; 817 else 818 usb_role = USB_ROLE_NONE; 819 } else { 820 return -ENOTSUPP; 821 } 822 } 823 824 ret = tcpm_mux_set(port, TYPEC_STATE_USB, usb_role, orientation); 825 if (ret < 0) 826 return ret; 827 828 ret = port->tcpc->set_roles(port->tcpc, attached, role, data); 829 if (ret < 0) 830 return ret; 831 832 port->pwr_role = role; 833 port->data_role = data; 834 typec_set_data_role(port->typec_port, data); 835 typec_set_pwr_role(port->typec_port, role); 836 837 return 0; 838 } 839 840 static int tcpm_set_pwr_role(struct tcpm_port *port, enum typec_role role) 841 { 842 int ret; 843 844 ret = port->tcpc->set_roles(port->tcpc, true, role, 845 port->data_role); 846 if (ret < 0) 847 return ret; 848 849 port->pwr_role = role; 850 typec_set_pwr_role(port->typec_port, role); 851 852 return 0; 853 } 854 855 static int tcpm_pd_send_source_caps(struct tcpm_port *port) 856 { 857 struct pd_message msg; 858 int i; 859 860 memset(&msg, 0, sizeof(msg)); 861 if (!port->nr_src_pdo) { 862 /* No source capabilities defined, sink only */ 863 msg.header = PD_HEADER_LE(PD_CTRL_REJECT, 864 port->pwr_role, 865 port->data_role, 866 port->negotiated_rev, 867 port->message_id, 0); 868 } else { 869 msg.header = PD_HEADER_LE(PD_DATA_SOURCE_CAP, 870 port->pwr_role, 871 port->data_role, 872 port->negotiated_rev, 873 port->message_id, 874 port->nr_src_pdo); 875 } 876 for (i = 0; i < port->nr_src_pdo; i++) 877 msg.payload[i] = cpu_to_le32(port->src_pdo[i]); 878 879 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 880 } 881 882 static int tcpm_pd_send_sink_caps(struct tcpm_port *port) 883 { 884 struct pd_message msg; 885 int i; 886 887 memset(&msg, 0, sizeof(msg)); 888 if (!port->nr_snk_pdo) { 889 /* No sink capabilities defined, source only */ 890 msg.header = PD_HEADER_LE(PD_CTRL_REJECT, 891 port->pwr_role, 892 port->data_role, 893 port->negotiated_rev, 894 port->message_id, 0); 895 } else { 896 msg.header = PD_HEADER_LE(PD_DATA_SINK_CAP, 897 port->pwr_role, 898 port->data_role, 899 port->negotiated_rev, 900 port->message_id, 901 port->nr_snk_pdo); 902 } 903 for (i = 0; i < port->nr_snk_pdo; i++) 904 msg.payload[i] = cpu_to_le32(port->snk_pdo[i]); 905 906 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 907 } 908 909 static void tcpm_set_state(struct tcpm_port *port, enum tcpm_state state, 910 unsigned int delay_ms) 911 { 912 if (delay_ms) { 913 tcpm_log(port, "pending state change %s -> %s @ %u ms", 914 tcpm_states[port->state], tcpm_states[state], 915 delay_ms); 916 port->delayed_state = state; 917 mod_delayed_work(port->wq, &port->state_machine, 918 msecs_to_jiffies(delay_ms)); 919 port->delayed_runtime = jiffies + msecs_to_jiffies(delay_ms); 920 port->delay_ms = delay_ms; 921 } else { 922 tcpm_log(port, "state change %s -> %s", 923 tcpm_states[port->state], tcpm_states[state]); 924 port->delayed_state = INVALID_STATE; 925 port->prev_state = port->state; 926 port->state = state; 927 /* 928 * Don't re-queue the state machine work item if we're currently 929 * in the state machine and we're immediately changing states. 930 * tcpm_state_machine_work() will continue running the state 931 * machine. 932 */ 933 if (!port->state_machine_running) 934 mod_delayed_work(port->wq, &port->state_machine, 0); 935 } 936 } 937 938 static void tcpm_set_state_cond(struct tcpm_port *port, enum tcpm_state state, 939 unsigned int delay_ms) 940 { 941 if (port->enter_state == port->state) 942 tcpm_set_state(port, state, delay_ms); 943 else 944 tcpm_log(port, 945 "skipped %sstate change %s -> %s [%u ms], context state %s", 946 delay_ms ? "delayed " : "", 947 tcpm_states[port->state], tcpm_states[state], 948 delay_ms, tcpm_states[port->enter_state]); 949 } 950 951 static void tcpm_queue_message(struct tcpm_port *port, 952 enum pd_msg_request message) 953 { 954 port->queued_message = message; 955 mod_delayed_work(port->wq, &port->state_machine, 0); 956 } 957 958 /* 959 * VDM/VDO handling functions 960 */ 961 static void tcpm_queue_vdm(struct tcpm_port *port, const u32 header, 962 const u32 *data, int cnt) 963 { 964 port->vdo_count = cnt + 1; 965 port->vdo_data[0] = header; 966 memcpy(&port->vdo_data[1], data, sizeof(u32) * cnt); 967 /* Set ready, vdm state machine will actually send */ 968 port->vdm_retries = 0; 969 port->vdm_state = VDM_STATE_READY; 970 } 971 972 static void svdm_consume_identity(struct tcpm_port *port, const __le32 *payload, 973 int cnt) 974 { 975 u32 vdo = le32_to_cpu(payload[VDO_INDEX_IDH]); 976 u32 product = le32_to_cpu(payload[VDO_INDEX_PRODUCT]); 977 978 memset(&port->mode_data, 0, sizeof(port->mode_data)); 979 980 port->partner_ident.id_header = vdo; 981 port->partner_ident.cert_stat = le32_to_cpu(payload[VDO_INDEX_CSTAT]); 982 port->partner_ident.product = product; 983 984 typec_partner_set_identity(port->partner); 985 986 tcpm_log(port, "Identity: %04x:%04x.%04x", 987 PD_IDH_VID(vdo), 988 PD_PRODUCT_PID(product), product & 0xffff); 989 } 990 991 static bool svdm_consume_svids(struct tcpm_port *port, const __le32 *payload, 992 int cnt) 993 { 994 struct pd_mode_data *pmdata = &port->mode_data; 995 int i; 996 997 for (i = 1; i < cnt; i++) { 998 u32 p = le32_to_cpu(payload[i]); 999 u16 svid; 1000 1001 svid = (p >> 16) & 0xffff; 1002 if (!svid) 1003 return false; 1004 1005 if (pmdata->nsvids >= SVID_DISCOVERY_MAX) 1006 goto abort; 1007 1008 pmdata->svids[pmdata->nsvids++] = svid; 1009 tcpm_log(port, "SVID %d: 0x%x", pmdata->nsvids, svid); 1010 1011 svid = p & 0xffff; 1012 if (!svid) 1013 return false; 1014 1015 if (pmdata->nsvids >= SVID_DISCOVERY_MAX) 1016 goto abort; 1017 1018 pmdata->svids[pmdata->nsvids++] = svid; 1019 tcpm_log(port, "SVID %d: 0x%x", pmdata->nsvids, svid); 1020 } 1021 return true; 1022 abort: 1023 tcpm_log(port, "SVID_DISCOVERY_MAX(%d) too low!", SVID_DISCOVERY_MAX); 1024 return false; 1025 } 1026 1027 static void svdm_consume_modes(struct tcpm_port *port, const __le32 *payload, 1028 int cnt) 1029 { 1030 struct pd_mode_data *pmdata = &port->mode_data; 1031 struct typec_altmode_desc *paltmode; 1032 int i; 1033 1034 if (pmdata->altmodes >= ARRAY_SIZE(port->partner_altmode)) { 1035 /* Already logged in svdm_consume_svids() */ 1036 return; 1037 } 1038 1039 for (i = 1; i < cnt; i++) { 1040 paltmode = &pmdata->altmode_desc[pmdata->altmodes]; 1041 memset(paltmode, 0, sizeof(*paltmode)); 1042 1043 paltmode->svid = pmdata->svids[pmdata->svid_index]; 1044 paltmode->mode = i; 1045 paltmode->vdo = le32_to_cpu(payload[i]); 1046 1047 tcpm_log(port, " Alternate mode %d: SVID 0x%04x, VDO %d: 0x%08x", 1048 pmdata->altmodes, paltmode->svid, 1049 paltmode->mode, paltmode->vdo); 1050 1051 pmdata->altmodes++; 1052 } 1053 } 1054 1055 static void tcpm_register_partner_altmodes(struct tcpm_port *port) 1056 { 1057 struct pd_mode_data *modep = &port->mode_data; 1058 struct typec_altmode *altmode; 1059 int i; 1060 1061 for (i = 0; i < modep->altmodes; i++) { 1062 altmode = typec_partner_register_altmode(port->partner, 1063 &modep->altmode_desc[i]); 1064 if (!altmode) 1065 tcpm_log(port, "Failed to register partner SVID 0x%04x", 1066 modep->altmode_desc[i].svid); 1067 port->partner_altmode[i] = altmode; 1068 } 1069 } 1070 1071 #define supports_modal(port) PD_IDH_MODAL_SUPP((port)->partner_ident.id_header) 1072 1073 static int tcpm_pd_svdm(struct tcpm_port *port, const __le32 *payload, int cnt, 1074 u32 *response) 1075 { 1076 struct typec_altmode *adev; 1077 struct typec_altmode *pdev; 1078 struct pd_mode_data *modep; 1079 u32 p[PD_MAX_PAYLOAD]; 1080 int rlen = 0; 1081 int cmd_type; 1082 int cmd; 1083 int i; 1084 1085 for (i = 0; i < cnt; i++) 1086 p[i] = le32_to_cpu(payload[i]); 1087 1088 cmd_type = PD_VDO_CMDT(p[0]); 1089 cmd = PD_VDO_CMD(p[0]); 1090 1091 tcpm_log(port, "Rx VDM cmd 0x%x type %d cmd %d len %d", 1092 p[0], cmd_type, cmd, cnt); 1093 1094 modep = &port->mode_data; 1095 1096 adev = typec_match_altmode(port->port_altmode, ALTMODE_DISCOVERY_MAX, 1097 PD_VDO_VID(p[0]), PD_VDO_OPOS(p[0])); 1098 1099 pdev = typec_match_altmode(port->partner_altmode, ALTMODE_DISCOVERY_MAX, 1100 PD_VDO_VID(p[0]), PD_VDO_OPOS(p[0])); 1101 1102 switch (cmd_type) { 1103 case CMDT_INIT: 1104 switch (cmd) { 1105 case CMD_DISCOVER_IDENT: 1106 /* 6.4.4.3.1: Only respond as UFP (device) */ 1107 if (port->data_role == TYPEC_DEVICE && 1108 port->nr_snk_vdo) { 1109 for (i = 0; i < port->nr_snk_vdo; i++) 1110 response[i + 1] = port->snk_vdo[i]; 1111 rlen = port->nr_snk_vdo + 1; 1112 } 1113 break; 1114 case CMD_DISCOVER_SVID: 1115 break; 1116 case CMD_DISCOVER_MODES: 1117 break; 1118 case CMD_ENTER_MODE: 1119 break; 1120 case CMD_EXIT_MODE: 1121 break; 1122 case CMD_ATTENTION: 1123 /* Attention command does not have response */ 1124 if (adev) 1125 typec_altmode_attention(adev, p[1]); 1126 return 0; 1127 default: 1128 break; 1129 } 1130 if (rlen >= 1) { 1131 response[0] = p[0] | VDO_CMDT(CMDT_RSP_ACK); 1132 } else if (rlen == 0) { 1133 response[0] = p[0] | VDO_CMDT(CMDT_RSP_NAK); 1134 rlen = 1; 1135 } else { 1136 response[0] = p[0] | VDO_CMDT(CMDT_RSP_BUSY); 1137 rlen = 1; 1138 } 1139 break; 1140 case CMDT_RSP_ACK: 1141 /* silently drop message if we are not connected */ 1142 if (IS_ERR_OR_NULL(port->partner)) 1143 break; 1144 1145 switch (cmd) { 1146 case CMD_DISCOVER_IDENT: 1147 /* 6.4.4.3.1 */ 1148 svdm_consume_identity(port, payload, cnt); 1149 response[0] = VDO(USB_SID_PD, 1, CMD_DISCOVER_SVID); 1150 rlen = 1; 1151 break; 1152 case CMD_DISCOVER_SVID: 1153 /* 6.4.4.3.2 */ 1154 if (svdm_consume_svids(port, payload, cnt)) { 1155 response[0] = VDO(USB_SID_PD, 1, 1156 CMD_DISCOVER_SVID); 1157 rlen = 1; 1158 } else if (modep->nsvids && supports_modal(port)) { 1159 response[0] = VDO(modep->svids[0], 1, 1160 CMD_DISCOVER_MODES); 1161 rlen = 1; 1162 } 1163 break; 1164 case CMD_DISCOVER_MODES: 1165 /* 6.4.4.3.3 */ 1166 svdm_consume_modes(port, payload, cnt); 1167 modep->svid_index++; 1168 if (modep->svid_index < modep->nsvids) { 1169 u16 svid = modep->svids[modep->svid_index]; 1170 response[0] = VDO(svid, 1, CMD_DISCOVER_MODES); 1171 rlen = 1; 1172 } else { 1173 tcpm_register_partner_altmodes(port); 1174 } 1175 break; 1176 case CMD_ENTER_MODE: 1177 if (adev && pdev) { 1178 typec_altmode_update_active(pdev, true); 1179 1180 if (typec_altmode_vdm(adev, p[0], &p[1], cnt)) { 1181 response[0] = VDO(adev->svid, 1, 1182 CMD_EXIT_MODE); 1183 response[0] |= VDO_OPOS(adev->mode); 1184 return 1; 1185 } 1186 } 1187 return 0; 1188 case CMD_EXIT_MODE: 1189 if (adev && pdev) { 1190 typec_altmode_update_active(pdev, false); 1191 1192 /* Back to USB Operation */ 1193 WARN_ON(typec_altmode_notify(adev, 1194 TYPEC_STATE_USB, 1195 NULL)); 1196 } 1197 break; 1198 default: 1199 break; 1200 } 1201 break; 1202 case CMDT_RSP_NAK: 1203 switch (cmd) { 1204 case CMD_ENTER_MODE: 1205 /* Back to USB Operation */ 1206 if (adev) 1207 WARN_ON(typec_altmode_notify(adev, 1208 TYPEC_STATE_USB, 1209 NULL)); 1210 break; 1211 default: 1212 break; 1213 } 1214 break; 1215 default: 1216 break; 1217 } 1218 1219 /* Informing the alternate mode drivers about everything */ 1220 if (adev) 1221 typec_altmode_vdm(adev, p[0], &p[1], cnt); 1222 1223 return rlen; 1224 } 1225 1226 static void tcpm_handle_vdm_request(struct tcpm_port *port, 1227 const __le32 *payload, int cnt) 1228 { 1229 int rlen = 0; 1230 u32 response[8] = { }; 1231 u32 p0 = le32_to_cpu(payload[0]); 1232 1233 if (port->vdm_state == VDM_STATE_BUSY) { 1234 /* If UFP responded busy retry after timeout */ 1235 if (PD_VDO_CMDT(p0) == CMDT_RSP_BUSY) { 1236 port->vdm_state = VDM_STATE_WAIT_RSP_BUSY; 1237 port->vdo_retry = (p0 & ~VDO_CMDT_MASK) | 1238 CMDT_INIT; 1239 mod_delayed_work(port->wq, &port->vdm_state_machine, 1240 msecs_to_jiffies(PD_T_VDM_BUSY)); 1241 return; 1242 } 1243 port->vdm_state = VDM_STATE_DONE; 1244 } 1245 1246 if (PD_VDO_SVDM(p0)) 1247 rlen = tcpm_pd_svdm(port, payload, cnt, response); 1248 1249 if (rlen > 0) { 1250 tcpm_queue_vdm(port, response[0], &response[1], rlen - 1); 1251 mod_delayed_work(port->wq, &port->vdm_state_machine, 0); 1252 } 1253 } 1254 1255 static void tcpm_send_vdm(struct tcpm_port *port, u32 vid, int cmd, 1256 const u32 *data, int count) 1257 { 1258 u32 header; 1259 1260 if (WARN_ON(count > VDO_MAX_SIZE - 1)) 1261 count = VDO_MAX_SIZE - 1; 1262 1263 /* set VDM header with VID & CMD */ 1264 header = VDO(vid, ((vid & USB_SID_PD) == USB_SID_PD) ? 1265 1 : (PD_VDO_CMD(cmd) <= CMD_ATTENTION), cmd); 1266 tcpm_queue_vdm(port, header, data, count); 1267 1268 mod_delayed_work(port->wq, &port->vdm_state_machine, 0); 1269 } 1270 1271 static unsigned int vdm_ready_timeout(u32 vdm_hdr) 1272 { 1273 unsigned int timeout; 1274 int cmd = PD_VDO_CMD(vdm_hdr); 1275 1276 /* its not a structured VDM command */ 1277 if (!PD_VDO_SVDM(vdm_hdr)) 1278 return PD_T_VDM_UNSTRUCTURED; 1279 1280 switch (PD_VDO_CMDT(vdm_hdr)) { 1281 case CMDT_INIT: 1282 if (cmd == CMD_ENTER_MODE || cmd == CMD_EXIT_MODE) 1283 timeout = PD_T_VDM_WAIT_MODE_E; 1284 else 1285 timeout = PD_T_VDM_SNDR_RSP; 1286 break; 1287 default: 1288 if (cmd == CMD_ENTER_MODE || cmd == CMD_EXIT_MODE) 1289 timeout = PD_T_VDM_E_MODE; 1290 else 1291 timeout = PD_T_VDM_RCVR_RSP; 1292 break; 1293 } 1294 return timeout; 1295 } 1296 1297 static void vdm_run_state_machine(struct tcpm_port *port) 1298 { 1299 struct pd_message msg; 1300 int i, res; 1301 1302 switch (port->vdm_state) { 1303 case VDM_STATE_READY: 1304 /* Only transmit VDM if attached */ 1305 if (!port->attached) { 1306 port->vdm_state = VDM_STATE_ERR_BUSY; 1307 break; 1308 } 1309 1310 /* 1311 * if there's traffic or we're not in PDO ready state don't send 1312 * a VDM. 1313 */ 1314 if (port->state != SRC_READY && port->state != SNK_READY) 1315 break; 1316 1317 /* Prepare and send VDM */ 1318 memset(&msg, 0, sizeof(msg)); 1319 msg.header = PD_HEADER_LE(PD_DATA_VENDOR_DEF, 1320 port->pwr_role, 1321 port->data_role, 1322 port->negotiated_rev, 1323 port->message_id, port->vdo_count); 1324 for (i = 0; i < port->vdo_count; i++) 1325 msg.payload[i] = cpu_to_le32(port->vdo_data[i]); 1326 res = tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 1327 if (res < 0) { 1328 port->vdm_state = VDM_STATE_ERR_SEND; 1329 } else { 1330 unsigned long timeout; 1331 1332 port->vdm_retries = 0; 1333 port->vdm_state = VDM_STATE_BUSY; 1334 timeout = vdm_ready_timeout(port->vdo_data[0]); 1335 mod_delayed_work(port->wq, &port->vdm_state_machine, 1336 timeout); 1337 } 1338 break; 1339 case VDM_STATE_WAIT_RSP_BUSY: 1340 port->vdo_data[0] = port->vdo_retry; 1341 port->vdo_count = 1; 1342 port->vdm_state = VDM_STATE_READY; 1343 break; 1344 case VDM_STATE_BUSY: 1345 port->vdm_state = VDM_STATE_ERR_TMOUT; 1346 break; 1347 case VDM_STATE_ERR_SEND: 1348 /* 1349 * A partner which does not support USB PD will not reply, 1350 * so this is not a fatal error. At the same time, some 1351 * devices may not return GoodCRC under some circumstances, 1352 * so we need to retry. 1353 */ 1354 if (port->vdm_retries < 3) { 1355 tcpm_log(port, "VDM Tx error, retry"); 1356 port->vdm_retries++; 1357 port->vdm_state = VDM_STATE_READY; 1358 } 1359 break; 1360 default: 1361 break; 1362 } 1363 } 1364 1365 static void vdm_state_machine_work(struct work_struct *work) 1366 { 1367 struct tcpm_port *port = container_of(work, struct tcpm_port, 1368 vdm_state_machine.work); 1369 enum vdm_states prev_state; 1370 1371 mutex_lock(&port->lock); 1372 1373 /* 1374 * Continue running as long as the port is not busy and there was 1375 * a state change. 1376 */ 1377 do { 1378 prev_state = port->vdm_state; 1379 vdm_run_state_machine(port); 1380 } while (port->vdm_state != prev_state && 1381 port->vdm_state != VDM_STATE_BUSY); 1382 1383 mutex_unlock(&port->lock); 1384 } 1385 1386 enum pdo_err { 1387 PDO_NO_ERR, 1388 PDO_ERR_NO_VSAFE5V, 1389 PDO_ERR_VSAFE5V_NOT_FIRST, 1390 PDO_ERR_PDO_TYPE_NOT_IN_ORDER, 1391 PDO_ERR_FIXED_NOT_SORTED, 1392 PDO_ERR_VARIABLE_BATT_NOT_SORTED, 1393 PDO_ERR_DUPE_PDO, 1394 PDO_ERR_PPS_APDO_NOT_SORTED, 1395 PDO_ERR_DUPE_PPS_APDO, 1396 }; 1397 1398 static const char * const pdo_err_msg[] = { 1399 [PDO_ERR_NO_VSAFE5V] = 1400 " err: source/sink caps should atleast have vSafe5V", 1401 [PDO_ERR_VSAFE5V_NOT_FIRST] = 1402 " err: vSafe5V Fixed Supply Object Shall always be the first object", 1403 [PDO_ERR_PDO_TYPE_NOT_IN_ORDER] = 1404 " err: PDOs should be in the following order: Fixed; Battery; Variable", 1405 [PDO_ERR_FIXED_NOT_SORTED] = 1406 " err: Fixed supply pdos should be in increasing order of their fixed voltage", 1407 [PDO_ERR_VARIABLE_BATT_NOT_SORTED] = 1408 " err: Variable/Battery supply pdos should be in increasing order of their minimum voltage", 1409 [PDO_ERR_DUPE_PDO] = 1410 " err: Variable/Batt supply pdos cannot have same min/max voltage", 1411 [PDO_ERR_PPS_APDO_NOT_SORTED] = 1412 " err: Programmable power supply apdos should be in increasing order of their maximum voltage", 1413 [PDO_ERR_DUPE_PPS_APDO] = 1414 " err: Programmable power supply apdos cannot have same min/max voltage and max current", 1415 }; 1416 1417 static enum pdo_err tcpm_caps_err(struct tcpm_port *port, const u32 *pdo, 1418 unsigned int nr_pdo) 1419 { 1420 unsigned int i; 1421 1422 /* Should at least contain vSafe5v */ 1423 if (nr_pdo < 1) 1424 return PDO_ERR_NO_VSAFE5V; 1425 1426 /* The vSafe5V Fixed Supply Object Shall always be the first object */ 1427 if (pdo_type(pdo[0]) != PDO_TYPE_FIXED || 1428 pdo_fixed_voltage(pdo[0]) != VSAFE5V) 1429 return PDO_ERR_VSAFE5V_NOT_FIRST; 1430 1431 for (i = 1; i < nr_pdo; i++) { 1432 if (pdo_type(pdo[i]) < pdo_type(pdo[i - 1])) { 1433 return PDO_ERR_PDO_TYPE_NOT_IN_ORDER; 1434 } else if (pdo_type(pdo[i]) == pdo_type(pdo[i - 1])) { 1435 enum pd_pdo_type type = pdo_type(pdo[i]); 1436 1437 switch (type) { 1438 /* 1439 * The remaining Fixed Supply Objects, if 1440 * present, shall be sent in voltage order; 1441 * lowest to highest. 1442 */ 1443 case PDO_TYPE_FIXED: 1444 if (pdo_fixed_voltage(pdo[i]) <= 1445 pdo_fixed_voltage(pdo[i - 1])) 1446 return PDO_ERR_FIXED_NOT_SORTED; 1447 break; 1448 /* 1449 * The Battery Supply Objects and Variable 1450 * supply, if present shall be sent in Minimum 1451 * Voltage order; lowest to highest. 1452 */ 1453 case PDO_TYPE_VAR: 1454 case PDO_TYPE_BATT: 1455 if (pdo_min_voltage(pdo[i]) < 1456 pdo_min_voltage(pdo[i - 1])) 1457 return PDO_ERR_VARIABLE_BATT_NOT_SORTED; 1458 else if ((pdo_min_voltage(pdo[i]) == 1459 pdo_min_voltage(pdo[i - 1])) && 1460 (pdo_max_voltage(pdo[i]) == 1461 pdo_max_voltage(pdo[i - 1]))) 1462 return PDO_ERR_DUPE_PDO; 1463 break; 1464 /* 1465 * The Programmable Power Supply APDOs, if present, 1466 * shall be sent in Maximum Voltage order; 1467 * lowest to highest. 1468 */ 1469 case PDO_TYPE_APDO: 1470 if (pdo_apdo_type(pdo[i]) != APDO_TYPE_PPS) 1471 break; 1472 1473 if (pdo_pps_apdo_max_voltage(pdo[i]) < 1474 pdo_pps_apdo_max_voltage(pdo[i - 1])) 1475 return PDO_ERR_PPS_APDO_NOT_SORTED; 1476 else if (pdo_pps_apdo_min_voltage(pdo[i]) == 1477 pdo_pps_apdo_min_voltage(pdo[i - 1]) && 1478 pdo_pps_apdo_max_voltage(pdo[i]) == 1479 pdo_pps_apdo_max_voltage(pdo[i - 1]) && 1480 pdo_pps_apdo_max_current(pdo[i]) == 1481 pdo_pps_apdo_max_current(pdo[i - 1])) 1482 return PDO_ERR_DUPE_PPS_APDO; 1483 break; 1484 default: 1485 tcpm_log_force(port, " Unknown pdo type"); 1486 } 1487 } 1488 } 1489 1490 return PDO_NO_ERR; 1491 } 1492 1493 static int tcpm_validate_caps(struct tcpm_port *port, const u32 *pdo, 1494 unsigned int nr_pdo) 1495 { 1496 enum pdo_err err_index = tcpm_caps_err(port, pdo, nr_pdo); 1497 1498 if (err_index != PDO_NO_ERR) { 1499 tcpm_log_force(port, " %s", pdo_err_msg[err_index]); 1500 return -EINVAL; 1501 } 1502 1503 return 0; 1504 } 1505 1506 static int tcpm_altmode_enter(struct typec_altmode *altmode, u32 *vdo) 1507 { 1508 struct tcpm_port *port = typec_altmode_get_drvdata(altmode); 1509 u32 header; 1510 1511 mutex_lock(&port->lock); 1512 header = VDO(altmode->svid, vdo ? 2 : 1, CMD_ENTER_MODE); 1513 header |= VDO_OPOS(altmode->mode); 1514 1515 tcpm_queue_vdm(port, header, vdo, vdo ? 1 : 0); 1516 mod_delayed_work(port->wq, &port->vdm_state_machine, 0); 1517 mutex_unlock(&port->lock); 1518 1519 return 0; 1520 } 1521 1522 static int tcpm_altmode_exit(struct typec_altmode *altmode) 1523 { 1524 struct tcpm_port *port = typec_altmode_get_drvdata(altmode); 1525 u32 header; 1526 1527 mutex_lock(&port->lock); 1528 header = VDO(altmode->svid, 1, CMD_EXIT_MODE); 1529 header |= VDO_OPOS(altmode->mode); 1530 1531 tcpm_queue_vdm(port, header, NULL, 0); 1532 mod_delayed_work(port->wq, &port->vdm_state_machine, 0); 1533 mutex_unlock(&port->lock); 1534 1535 return 0; 1536 } 1537 1538 static int tcpm_altmode_vdm(struct typec_altmode *altmode, 1539 u32 header, const u32 *data, int count) 1540 { 1541 struct tcpm_port *port = typec_altmode_get_drvdata(altmode); 1542 1543 mutex_lock(&port->lock); 1544 tcpm_queue_vdm(port, header, data, count - 1); 1545 mod_delayed_work(port->wq, &port->vdm_state_machine, 0); 1546 mutex_unlock(&port->lock); 1547 1548 return 0; 1549 } 1550 1551 static const struct typec_altmode_ops tcpm_altmode_ops = { 1552 .enter = tcpm_altmode_enter, 1553 .exit = tcpm_altmode_exit, 1554 .vdm = tcpm_altmode_vdm, 1555 }; 1556 1557 /* 1558 * PD (data, control) command handling functions 1559 */ 1560 static inline enum tcpm_state ready_state(struct tcpm_port *port) 1561 { 1562 if (port->pwr_role == TYPEC_SOURCE) 1563 return SRC_READY; 1564 else 1565 return SNK_READY; 1566 } 1567 1568 static int tcpm_pd_send_control(struct tcpm_port *port, 1569 enum pd_ctrl_msg_type type); 1570 1571 static void tcpm_handle_alert(struct tcpm_port *port, const __le32 *payload, 1572 int cnt) 1573 { 1574 u32 p0 = le32_to_cpu(payload[0]); 1575 unsigned int type = usb_pd_ado_type(p0); 1576 1577 if (!type) { 1578 tcpm_log(port, "Alert message received with no type"); 1579 return; 1580 } 1581 1582 /* Just handling non-battery alerts for now */ 1583 if (!(type & USB_PD_ADO_TYPE_BATT_STATUS_CHANGE)) { 1584 switch (port->state) { 1585 case SRC_READY: 1586 case SNK_READY: 1587 tcpm_set_state(port, GET_STATUS_SEND, 0); 1588 break; 1589 default: 1590 tcpm_queue_message(port, PD_MSG_CTRL_WAIT); 1591 break; 1592 } 1593 } 1594 } 1595 1596 static void tcpm_pd_data_request(struct tcpm_port *port, 1597 const struct pd_message *msg) 1598 { 1599 enum pd_data_msg_type type = pd_header_type_le(msg->header); 1600 unsigned int cnt = pd_header_cnt_le(msg->header); 1601 unsigned int rev = pd_header_rev_le(msg->header); 1602 unsigned int i; 1603 1604 switch (type) { 1605 case PD_DATA_SOURCE_CAP: 1606 if (port->pwr_role != TYPEC_SINK) 1607 break; 1608 1609 for (i = 0; i < cnt; i++) 1610 port->source_caps[i] = le32_to_cpu(msg->payload[i]); 1611 1612 port->nr_source_caps = cnt; 1613 1614 tcpm_log_source_caps(port); 1615 1616 tcpm_validate_caps(port, port->source_caps, 1617 port->nr_source_caps); 1618 1619 /* 1620 * Adjust revision in subsequent message headers, as required, 1621 * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't 1622 * support Rev 1.0 so just do nothing in that scenario. 1623 */ 1624 if (rev == PD_REV10) 1625 break; 1626 1627 if (rev < PD_MAX_REV) 1628 port->negotiated_rev = rev; 1629 1630 /* 1631 * This message may be received even if VBUS is not 1632 * present. This is quite unexpected; see USB PD 1633 * specification, sections 8.3.3.6.3.1 and 8.3.3.6.3.2. 1634 * However, at the same time, we must be ready to 1635 * receive this message and respond to it 15ms after 1636 * receiving PS_RDY during power swap operations, no matter 1637 * if VBUS is available or not (USB PD specification, 1638 * section 6.5.9.2). 1639 * So we need to accept the message either way, 1640 * but be prepared to keep waiting for VBUS after it was 1641 * handled. 1642 */ 1643 tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0); 1644 break; 1645 case PD_DATA_REQUEST: 1646 if (port->pwr_role != TYPEC_SOURCE || 1647 cnt != 1) { 1648 tcpm_queue_message(port, PD_MSG_CTRL_REJECT); 1649 break; 1650 } 1651 1652 /* 1653 * Adjust revision in subsequent message headers, as required, 1654 * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't 1655 * support Rev 1.0 so just reject in that scenario. 1656 */ 1657 if (rev == PD_REV10) { 1658 tcpm_queue_message(port, PD_MSG_CTRL_REJECT); 1659 break; 1660 } 1661 1662 if (rev < PD_MAX_REV) 1663 port->negotiated_rev = rev; 1664 1665 port->sink_request = le32_to_cpu(msg->payload[0]); 1666 tcpm_set_state(port, SRC_NEGOTIATE_CAPABILITIES, 0); 1667 break; 1668 case PD_DATA_SINK_CAP: 1669 /* We don't do anything with this at the moment... */ 1670 for (i = 0; i < cnt; i++) 1671 port->sink_caps[i] = le32_to_cpu(msg->payload[i]); 1672 port->nr_sink_caps = cnt; 1673 break; 1674 case PD_DATA_VENDOR_DEF: 1675 tcpm_handle_vdm_request(port, msg->payload, cnt); 1676 break; 1677 case PD_DATA_BIST: 1678 if (port->state == SRC_READY || port->state == SNK_READY) { 1679 port->bist_request = le32_to_cpu(msg->payload[0]); 1680 tcpm_set_state(port, BIST_RX, 0); 1681 } 1682 break; 1683 case PD_DATA_ALERT: 1684 tcpm_handle_alert(port, msg->payload, cnt); 1685 break; 1686 case PD_DATA_BATT_STATUS: 1687 case PD_DATA_GET_COUNTRY_INFO: 1688 /* Currently unsupported */ 1689 tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP); 1690 break; 1691 default: 1692 tcpm_log(port, "Unhandled data message type %#x", type); 1693 break; 1694 } 1695 } 1696 1697 static void tcpm_pps_complete(struct tcpm_port *port, int result) 1698 { 1699 if (port->pps_pending) { 1700 port->pps_status = result; 1701 port->pps_pending = false; 1702 complete(&port->pps_complete); 1703 } 1704 } 1705 1706 static void tcpm_pd_ctrl_request(struct tcpm_port *port, 1707 const struct pd_message *msg) 1708 { 1709 enum pd_ctrl_msg_type type = pd_header_type_le(msg->header); 1710 enum tcpm_state next_state; 1711 1712 switch (type) { 1713 case PD_CTRL_GOOD_CRC: 1714 case PD_CTRL_PING: 1715 break; 1716 case PD_CTRL_GET_SOURCE_CAP: 1717 switch (port->state) { 1718 case SRC_READY: 1719 case SNK_READY: 1720 tcpm_queue_message(port, PD_MSG_DATA_SOURCE_CAP); 1721 break; 1722 default: 1723 tcpm_queue_message(port, PD_MSG_CTRL_REJECT); 1724 break; 1725 } 1726 break; 1727 case PD_CTRL_GET_SINK_CAP: 1728 switch (port->state) { 1729 case SRC_READY: 1730 case SNK_READY: 1731 tcpm_queue_message(port, PD_MSG_DATA_SINK_CAP); 1732 break; 1733 default: 1734 tcpm_queue_message(port, PD_MSG_CTRL_REJECT); 1735 break; 1736 } 1737 break; 1738 case PD_CTRL_GOTO_MIN: 1739 break; 1740 case PD_CTRL_PS_RDY: 1741 switch (port->state) { 1742 case SNK_TRANSITION_SINK: 1743 if (port->vbus_present) { 1744 tcpm_set_current_limit(port, 1745 port->current_limit, 1746 port->supply_voltage); 1747 port->explicit_contract = true; 1748 tcpm_set_state(port, SNK_READY, 0); 1749 } else { 1750 /* 1751 * Seen after power swap. Keep waiting for VBUS 1752 * in a transitional state. 1753 */ 1754 tcpm_set_state(port, 1755 SNK_TRANSITION_SINK_VBUS, 0); 1756 } 1757 break; 1758 case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED: 1759 tcpm_set_state(port, PR_SWAP_SRC_SNK_SINK_ON, 0); 1760 break; 1761 case PR_SWAP_SNK_SRC_SINK_OFF: 1762 tcpm_set_state(port, PR_SWAP_SNK_SRC_SOURCE_ON, 0); 1763 break; 1764 case VCONN_SWAP_WAIT_FOR_VCONN: 1765 tcpm_set_state(port, VCONN_SWAP_TURN_OFF_VCONN, 0); 1766 break; 1767 default: 1768 break; 1769 } 1770 break; 1771 case PD_CTRL_REJECT: 1772 case PD_CTRL_WAIT: 1773 case PD_CTRL_NOT_SUPP: 1774 switch (port->state) { 1775 case SNK_NEGOTIATE_CAPABILITIES: 1776 /* USB PD specification, Figure 8-43 */ 1777 if (port->explicit_contract) 1778 next_state = SNK_READY; 1779 else 1780 next_state = SNK_WAIT_CAPABILITIES; 1781 tcpm_set_state(port, next_state, 0); 1782 break; 1783 case SNK_NEGOTIATE_PPS_CAPABILITIES: 1784 /* Revert data back from any requested PPS updates */ 1785 port->pps_data.out_volt = port->supply_voltage; 1786 port->pps_data.op_curr = port->current_limit; 1787 port->pps_status = (type == PD_CTRL_WAIT ? 1788 -EAGAIN : -EOPNOTSUPP); 1789 tcpm_set_state(port, SNK_READY, 0); 1790 break; 1791 case DR_SWAP_SEND: 1792 port->swap_status = (type == PD_CTRL_WAIT ? 1793 -EAGAIN : -EOPNOTSUPP); 1794 tcpm_set_state(port, DR_SWAP_CANCEL, 0); 1795 break; 1796 case PR_SWAP_SEND: 1797 port->swap_status = (type == PD_CTRL_WAIT ? 1798 -EAGAIN : -EOPNOTSUPP); 1799 tcpm_set_state(port, PR_SWAP_CANCEL, 0); 1800 break; 1801 case VCONN_SWAP_SEND: 1802 port->swap_status = (type == PD_CTRL_WAIT ? 1803 -EAGAIN : -EOPNOTSUPP); 1804 tcpm_set_state(port, VCONN_SWAP_CANCEL, 0); 1805 break; 1806 default: 1807 break; 1808 } 1809 break; 1810 case PD_CTRL_ACCEPT: 1811 switch (port->state) { 1812 case SNK_NEGOTIATE_CAPABILITIES: 1813 port->pps_data.active = false; 1814 tcpm_set_state(port, SNK_TRANSITION_SINK, 0); 1815 break; 1816 case SNK_NEGOTIATE_PPS_CAPABILITIES: 1817 port->pps_data.active = true; 1818 port->supply_voltage = port->pps_data.out_volt; 1819 port->current_limit = port->pps_data.op_curr; 1820 tcpm_set_state(port, SNK_TRANSITION_SINK, 0); 1821 break; 1822 case SOFT_RESET_SEND: 1823 port->message_id = 0; 1824 port->rx_msgid = -1; 1825 if (port->pwr_role == TYPEC_SOURCE) 1826 next_state = SRC_SEND_CAPABILITIES; 1827 else 1828 next_state = SNK_WAIT_CAPABILITIES; 1829 tcpm_set_state(port, next_state, 0); 1830 break; 1831 case DR_SWAP_SEND: 1832 tcpm_set_state(port, DR_SWAP_CHANGE_DR, 0); 1833 break; 1834 case PR_SWAP_SEND: 1835 tcpm_set_state(port, PR_SWAP_START, 0); 1836 break; 1837 case VCONN_SWAP_SEND: 1838 tcpm_set_state(port, VCONN_SWAP_START, 0); 1839 break; 1840 default: 1841 break; 1842 } 1843 break; 1844 case PD_CTRL_SOFT_RESET: 1845 tcpm_set_state(port, SOFT_RESET, 0); 1846 break; 1847 case PD_CTRL_DR_SWAP: 1848 if (port->typec_caps.data != TYPEC_PORT_DRD) { 1849 tcpm_queue_message(port, PD_MSG_CTRL_REJECT); 1850 break; 1851 } 1852 /* 1853 * XXX 1854 * 6.3.9: If an alternate mode is active, a request to swap 1855 * alternate modes shall trigger a port reset. 1856 */ 1857 switch (port->state) { 1858 case SRC_READY: 1859 case SNK_READY: 1860 tcpm_set_state(port, DR_SWAP_ACCEPT, 0); 1861 break; 1862 default: 1863 tcpm_queue_message(port, PD_MSG_CTRL_WAIT); 1864 break; 1865 } 1866 break; 1867 case PD_CTRL_PR_SWAP: 1868 if (port->port_type != TYPEC_PORT_DRP) { 1869 tcpm_queue_message(port, PD_MSG_CTRL_REJECT); 1870 break; 1871 } 1872 switch (port->state) { 1873 case SRC_READY: 1874 case SNK_READY: 1875 tcpm_set_state(port, PR_SWAP_ACCEPT, 0); 1876 break; 1877 default: 1878 tcpm_queue_message(port, PD_MSG_CTRL_WAIT); 1879 break; 1880 } 1881 break; 1882 case PD_CTRL_VCONN_SWAP: 1883 switch (port->state) { 1884 case SRC_READY: 1885 case SNK_READY: 1886 tcpm_set_state(port, VCONN_SWAP_ACCEPT, 0); 1887 break; 1888 default: 1889 tcpm_queue_message(port, PD_MSG_CTRL_WAIT); 1890 break; 1891 } 1892 break; 1893 case PD_CTRL_GET_SOURCE_CAP_EXT: 1894 case PD_CTRL_GET_STATUS: 1895 case PD_CTRL_FR_SWAP: 1896 case PD_CTRL_GET_PPS_STATUS: 1897 case PD_CTRL_GET_COUNTRY_CODES: 1898 /* Currently not supported */ 1899 tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP); 1900 break; 1901 default: 1902 tcpm_log(port, "Unhandled ctrl message type %#x", type); 1903 break; 1904 } 1905 } 1906 1907 static void tcpm_pd_ext_msg_request(struct tcpm_port *port, 1908 const struct pd_message *msg) 1909 { 1910 enum pd_ext_msg_type type = pd_header_type_le(msg->header); 1911 unsigned int data_size = pd_ext_header_data_size_le(msg->ext_msg.header); 1912 1913 if (!(msg->ext_msg.header & PD_EXT_HDR_CHUNKED)) { 1914 tcpm_log(port, "Unchunked extended messages unsupported"); 1915 return; 1916 } 1917 1918 if (data_size > PD_EXT_MAX_CHUNK_DATA) { 1919 tcpm_log(port, "Chunk handling not yet supported"); 1920 return; 1921 } 1922 1923 switch (type) { 1924 case PD_EXT_STATUS: 1925 /* 1926 * If PPS related events raised then get PPS status to clear 1927 * (see USB PD 3.0 Spec, 6.5.2.4) 1928 */ 1929 if (msg->ext_msg.data[USB_PD_EXT_SDB_EVENT_FLAGS] & 1930 USB_PD_EXT_SDB_PPS_EVENTS) 1931 tcpm_set_state(port, GET_PPS_STATUS_SEND, 0); 1932 else 1933 tcpm_set_state(port, ready_state(port), 0); 1934 break; 1935 case PD_EXT_PPS_STATUS: 1936 /* 1937 * For now the PPS status message is used to clear events 1938 * and nothing more. 1939 */ 1940 tcpm_set_state(port, ready_state(port), 0); 1941 break; 1942 case PD_EXT_SOURCE_CAP_EXT: 1943 case PD_EXT_GET_BATT_CAP: 1944 case PD_EXT_GET_BATT_STATUS: 1945 case PD_EXT_BATT_CAP: 1946 case PD_EXT_GET_MANUFACTURER_INFO: 1947 case PD_EXT_MANUFACTURER_INFO: 1948 case PD_EXT_SECURITY_REQUEST: 1949 case PD_EXT_SECURITY_RESPONSE: 1950 case PD_EXT_FW_UPDATE_REQUEST: 1951 case PD_EXT_FW_UPDATE_RESPONSE: 1952 case PD_EXT_COUNTRY_INFO: 1953 case PD_EXT_COUNTRY_CODES: 1954 tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP); 1955 break; 1956 default: 1957 tcpm_log(port, "Unhandled extended message type %#x", type); 1958 break; 1959 } 1960 } 1961 1962 static void tcpm_pd_rx_handler(struct work_struct *work) 1963 { 1964 struct pd_rx_event *event = container_of(work, 1965 struct pd_rx_event, work); 1966 const struct pd_message *msg = &event->msg; 1967 unsigned int cnt = pd_header_cnt_le(msg->header); 1968 struct tcpm_port *port = event->port; 1969 1970 mutex_lock(&port->lock); 1971 1972 tcpm_log(port, "PD RX, header: %#x [%d]", le16_to_cpu(msg->header), 1973 port->attached); 1974 1975 if (port->attached) { 1976 enum pd_ctrl_msg_type type = pd_header_type_le(msg->header); 1977 unsigned int msgid = pd_header_msgid_le(msg->header); 1978 1979 /* 1980 * USB PD standard, 6.6.1.2: 1981 * "... if MessageID value in a received Message is the 1982 * same as the stored value, the receiver shall return a 1983 * GoodCRC Message with that MessageID value and drop 1984 * the Message (this is a retry of an already received 1985 * Message). Note: this shall not apply to the Soft_Reset 1986 * Message which always has a MessageID value of zero." 1987 */ 1988 if (msgid == port->rx_msgid && type != PD_CTRL_SOFT_RESET) 1989 goto done; 1990 port->rx_msgid = msgid; 1991 1992 /* 1993 * If both ends believe to be DFP/host, we have a data role 1994 * mismatch. 1995 */ 1996 if (!!(le16_to_cpu(msg->header) & PD_HEADER_DATA_ROLE) == 1997 (port->data_role == TYPEC_HOST)) { 1998 tcpm_log(port, 1999 "Data role mismatch, initiating error recovery"); 2000 tcpm_set_state(port, ERROR_RECOVERY, 0); 2001 } else { 2002 if (msg->header & PD_HEADER_EXT_HDR) 2003 tcpm_pd_ext_msg_request(port, msg); 2004 else if (cnt) 2005 tcpm_pd_data_request(port, msg); 2006 else 2007 tcpm_pd_ctrl_request(port, msg); 2008 } 2009 } 2010 2011 done: 2012 mutex_unlock(&port->lock); 2013 kfree(event); 2014 } 2015 2016 void tcpm_pd_receive(struct tcpm_port *port, const struct pd_message *msg) 2017 { 2018 struct pd_rx_event *event; 2019 2020 event = kzalloc(sizeof(*event), GFP_ATOMIC); 2021 if (!event) 2022 return; 2023 2024 INIT_WORK(&event->work, tcpm_pd_rx_handler); 2025 event->port = port; 2026 memcpy(&event->msg, msg, sizeof(*msg)); 2027 queue_work(port->wq, &event->work); 2028 } 2029 EXPORT_SYMBOL_GPL(tcpm_pd_receive); 2030 2031 static int tcpm_pd_send_control(struct tcpm_port *port, 2032 enum pd_ctrl_msg_type type) 2033 { 2034 struct pd_message msg; 2035 2036 memset(&msg, 0, sizeof(msg)); 2037 msg.header = PD_HEADER_LE(type, port->pwr_role, 2038 port->data_role, 2039 port->negotiated_rev, 2040 port->message_id, 0); 2041 2042 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 2043 } 2044 2045 /* 2046 * Send queued message without affecting state. 2047 * Return true if state machine should go back to sleep, 2048 * false otherwise. 2049 */ 2050 static bool tcpm_send_queued_message(struct tcpm_port *port) 2051 { 2052 enum pd_msg_request queued_message; 2053 2054 do { 2055 queued_message = port->queued_message; 2056 port->queued_message = PD_MSG_NONE; 2057 2058 switch (queued_message) { 2059 case PD_MSG_CTRL_WAIT: 2060 tcpm_pd_send_control(port, PD_CTRL_WAIT); 2061 break; 2062 case PD_MSG_CTRL_REJECT: 2063 tcpm_pd_send_control(port, PD_CTRL_REJECT); 2064 break; 2065 case PD_MSG_CTRL_NOT_SUPP: 2066 tcpm_pd_send_control(port, PD_CTRL_NOT_SUPP); 2067 break; 2068 case PD_MSG_DATA_SINK_CAP: 2069 tcpm_pd_send_sink_caps(port); 2070 break; 2071 case PD_MSG_DATA_SOURCE_CAP: 2072 tcpm_pd_send_source_caps(port); 2073 break; 2074 default: 2075 break; 2076 } 2077 } while (port->queued_message != PD_MSG_NONE); 2078 2079 if (port->delayed_state != INVALID_STATE) { 2080 if (time_is_after_jiffies(port->delayed_runtime)) { 2081 mod_delayed_work(port->wq, &port->state_machine, 2082 port->delayed_runtime - jiffies); 2083 return true; 2084 } 2085 port->delayed_state = INVALID_STATE; 2086 } 2087 return false; 2088 } 2089 2090 static int tcpm_pd_check_request(struct tcpm_port *port) 2091 { 2092 u32 pdo, rdo = port->sink_request; 2093 unsigned int max, op, pdo_max, index; 2094 enum pd_pdo_type type; 2095 2096 index = rdo_index(rdo); 2097 if (!index || index > port->nr_src_pdo) 2098 return -EINVAL; 2099 2100 pdo = port->src_pdo[index - 1]; 2101 type = pdo_type(pdo); 2102 switch (type) { 2103 case PDO_TYPE_FIXED: 2104 case PDO_TYPE_VAR: 2105 max = rdo_max_current(rdo); 2106 op = rdo_op_current(rdo); 2107 pdo_max = pdo_max_current(pdo); 2108 2109 if (op > pdo_max) 2110 return -EINVAL; 2111 if (max > pdo_max && !(rdo & RDO_CAP_MISMATCH)) 2112 return -EINVAL; 2113 2114 if (type == PDO_TYPE_FIXED) 2115 tcpm_log(port, 2116 "Requested %u mV, %u mA for %u / %u mA", 2117 pdo_fixed_voltage(pdo), pdo_max, op, max); 2118 else 2119 tcpm_log(port, 2120 "Requested %u -> %u mV, %u mA for %u / %u mA", 2121 pdo_min_voltage(pdo), pdo_max_voltage(pdo), 2122 pdo_max, op, max); 2123 break; 2124 case PDO_TYPE_BATT: 2125 max = rdo_max_power(rdo); 2126 op = rdo_op_power(rdo); 2127 pdo_max = pdo_max_power(pdo); 2128 2129 if (op > pdo_max) 2130 return -EINVAL; 2131 if (max > pdo_max && !(rdo & RDO_CAP_MISMATCH)) 2132 return -EINVAL; 2133 tcpm_log(port, 2134 "Requested %u -> %u mV, %u mW for %u / %u mW", 2135 pdo_min_voltage(pdo), pdo_max_voltage(pdo), 2136 pdo_max, op, max); 2137 break; 2138 default: 2139 return -EINVAL; 2140 } 2141 2142 port->op_vsafe5v = index == 1; 2143 2144 return 0; 2145 } 2146 2147 #define min_power(x, y) min(pdo_max_power(x), pdo_max_power(y)) 2148 #define min_current(x, y) min(pdo_max_current(x), pdo_max_current(y)) 2149 2150 static int tcpm_pd_select_pdo(struct tcpm_port *port, int *sink_pdo, 2151 int *src_pdo) 2152 { 2153 unsigned int i, j, max_src_mv = 0, min_src_mv = 0, max_mw = 0, 2154 max_mv = 0, src_mw = 0, src_ma = 0, max_snk_mv = 0, 2155 min_snk_mv = 0; 2156 int ret = -EINVAL; 2157 2158 port->pps_data.supported = false; 2159 port->usb_type = POWER_SUPPLY_USB_TYPE_PD; 2160 2161 /* 2162 * Select the source PDO providing the most power which has a 2163 * matchig sink cap. 2164 */ 2165 for (i = 0; i < port->nr_source_caps; i++) { 2166 u32 pdo = port->source_caps[i]; 2167 enum pd_pdo_type type = pdo_type(pdo); 2168 2169 switch (type) { 2170 case PDO_TYPE_FIXED: 2171 max_src_mv = pdo_fixed_voltage(pdo); 2172 min_src_mv = max_src_mv; 2173 break; 2174 case PDO_TYPE_BATT: 2175 case PDO_TYPE_VAR: 2176 max_src_mv = pdo_max_voltage(pdo); 2177 min_src_mv = pdo_min_voltage(pdo); 2178 break; 2179 case PDO_TYPE_APDO: 2180 if (pdo_apdo_type(pdo) == APDO_TYPE_PPS) { 2181 port->pps_data.supported = true; 2182 port->usb_type = 2183 POWER_SUPPLY_USB_TYPE_PD_PPS; 2184 } 2185 continue; 2186 default: 2187 tcpm_log(port, "Invalid source PDO type, ignoring"); 2188 continue; 2189 } 2190 2191 switch (type) { 2192 case PDO_TYPE_FIXED: 2193 case PDO_TYPE_VAR: 2194 src_ma = pdo_max_current(pdo); 2195 src_mw = src_ma * min_src_mv / 1000; 2196 break; 2197 case PDO_TYPE_BATT: 2198 src_mw = pdo_max_power(pdo); 2199 break; 2200 case PDO_TYPE_APDO: 2201 continue; 2202 default: 2203 tcpm_log(port, "Invalid source PDO type, ignoring"); 2204 continue; 2205 } 2206 2207 for (j = 0; j < port->nr_snk_pdo; j++) { 2208 pdo = port->snk_pdo[j]; 2209 2210 switch (pdo_type(pdo)) { 2211 case PDO_TYPE_FIXED: 2212 max_snk_mv = pdo_fixed_voltage(pdo); 2213 min_snk_mv = max_snk_mv; 2214 break; 2215 case PDO_TYPE_BATT: 2216 case PDO_TYPE_VAR: 2217 max_snk_mv = pdo_max_voltage(pdo); 2218 min_snk_mv = pdo_min_voltage(pdo); 2219 break; 2220 case PDO_TYPE_APDO: 2221 continue; 2222 default: 2223 tcpm_log(port, "Invalid sink PDO type, ignoring"); 2224 continue; 2225 } 2226 2227 if (max_src_mv <= max_snk_mv && 2228 min_src_mv >= min_snk_mv) { 2229 /* Prefer higher voltages if available */ 2230 if ((src_mw == max_mw && min_src_mv > max_mv) || 2231 src_mw > max_mw) { 2232 *src_pdo = i; 2233 *sink_pdo = j; 2234 max_mw = src_mw; 2235 max_mv = min_src_mv; 2236 ret = 0; 2237 } 2238 } 2239 } 2240 } 2241 2242 return ret; 2243 } 2244 2245 #define min_pps_apdo_current(x, y) \ 2246 min(pdo_pps_apdo_max_current(x), pdo_pps_apdo_max_current(y)) 2247 2248 static unsigned int tcpm_pd_select_pps_apdo(struct tcpm_port *port) 2249 { 2250 unsigned int i, j, max_mw = 0, max_mv = 0; 2251 unsigned int min_src_mv, max_src_mv, src_ma, src_mw; 2252 unsigned int min_snk_mv, max_snk_mv; 2253 unsigned int max_op_mv; 2254 u32 pdo, src, snk; 2255 unsigned int src_pdo = 0, snk_pdo = 0; 2256 2257 /* 2258 * Select the source PPS APDO providing the most power while staying 2259 * within the board's limits. We skip the first PDO as this is always 2260 * 5V 3A. 2261 */ 2262 for (i = 1; i < port->nr_source_caps; ++i) { 2263 pdo = port->source_caps[i]; 2264 2265 switch (pdo_type(pdo)) { 2266 case PDO_TYPE_APDO: 2267 if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) { 2268 tcpm_log(port, "Not PPS APDO (source), ignoring"); 2269 continue; 2270 } 2271 2272 min_src_mv = pdo_pps_apdo_min_voltage(pdo); 2273 max_src_mv = pdo_pps_apdo_max_voltage(pdo); 2274 src_ma = pdo_pps_apdo_max_current(pdo); 2275 src_mw = (src_ma * max_src_mv) / 1000; 2276 2277 /* 2278 * Now search through the sink PDOs to find a matching 2279 * PPS APDO. Again skip the first sink PDO as this will 2280 * always be 5V 3A. 2281 */ 2282 for (j = 1; j < port->nr_snk_pdo; j++) { 2283 pdo = port->snk_pdo[j]; 2284 2285 switch (pdo_type(pdo)) { 2286 case PDO_TYPE_APDO: 2287 if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) { 2288 tcpm_log(port, 2289 "Not PPS APDO (sink), ignoring"); 2290 continue; 2291 } 2292 2293 min_snk_mv = 2294 pdo_pps_apdo_min_voltage(pdo); 2295 max_snk_mv = 2296 pdo_pps_apdo_max_voltage(pdo); 2297 break; 2298 default: 2299 tcpm_log(port, 2300 "Not APDO type (sink), ignoring"); 2301 continue; 2302 } 2303 2304 if (min_src_mv <= max_snk_mv && 2305 max_src_mv >= min_snk_mv) { 2306 max_op_mv = min(max_src_mv, max_snk_mv); 2307 src_mw = (max_op_mv * src_ma) / 1000; 2308 /* Prefer higher voltages if available */ 2309 if ((src_mw == max_mw && 2310 max_op_mv > max_mv) || 2311 src_mw > max_mw) { 2312 src_pdo = i; 2313 snk_pdo = j; 2314 max_mw = src_mw; 2315 max_mv = max_op_mv; 2316 } 2317 } 2318 } 2319 2320 break; 2321 default: 2322 tcpm_log(port, "Not APDO type (source), ignoring"); 2323 continue; 2324 } 2325 } 2326 2327 if (src_pdo) { 2328 src = port->source_caps[src_pdo]; 2329 snk = port->snk_pdo[snk_pdo]; 2330 2331 port->pps_data.min_volt = max(pdo_pps_apdo_min_voltage(src), 2332 pdo_pps_apdo_min_voltage(snk)); 2333 port->pps_data.max_volt = min(pdo_pps_apdo_max_voltage(src), 2334 pdo_pps_apdo_max_voltage(snk)); 2335 port->pps_data.max_curr = min_pps_apdo_current(src, snk); 2336 port->pps_data.out_volt = min(port->pps_data.max_volt, 2337 max(port->pps_data.min_volt, 2338 port->pps_data.out_volt)); 2339 port->pps_data.op_curr = min(port->pps_data.max_curr, 2340 port->pps_data.op_curr); 2341 } 2342 2343 return src_pdo; 2344 } 2345 2346 static int tcpm_pd_build_request(struct tcpm_port *port, u32 *rdo) 2347 { 2348 unsigned int mv, ma, mw, flags; 2349 unsigned int max_ma, max_mw; 2350 enum pd_pdo_type type; 2351 u32 pdo, matching_snk_pdo; 2352 int src_pdo_index = 0; 2353 int snk_pdo_index = 0; 2354 int ret; 2355 2356 ret = tcpm_pd_select_pdo(port, &snk_pdo_index, &src_pdo_index); 2357 if (ret < 0) 2358 return ret; 2359 2360 pdo = port->source_caps[src_pdo_index]; 2361 matching_snk_pdo = port->snk_pdo[snk_pdo_index]; 2362 type = pdo_type(pdo); 2363 2364 switch (type) { 2365 case PDO_TYPE_FIXED: 2366 mv = pdo_fixed_voltage(pdo); 2367 break; 2368 case PDO_TYPE_BATT: 2369 case PDO_TYPE_VAR: 2370 mv = pdo_min_voltage(pdo); 2371 break; 2372 default: 2373 tcpm_log(port, "Invalid PDO selected!"); 2374 return -EINVAL; 2375 } 2376 2377 /* Select maximum available current within the sink pdo's limit */ 2378 if (type == PDO_TYPE_BATT) { 2379 mw = min_power(pdo, matching_snk_pdo); 2380 ma = 1000 * mw / mv; 2381 } else { 2382 ma = min_current(pdo, matching_snk_pdo); 2383 mw = ma * mv / 1000; 2384 } 2385 2386 flags = RDO_USB_COMM | RDO_NO_SUSPEND; 2387 2388 /* Set mismatch bit if offered power is less than operating power */ 2389 max_ma = ma; 2390 max_mw = mw; 2391 if (mw < port->operating_snk_mw) { 2392 flags |= RDO_CAP_MISMATCH; 2393 if (type == PDO_TYPE_BATT && 2394 (pdo_max_power(matching_snk_pdo) > pdo_max_power(pdo))) 2395 max_mw = pdo_max_power(matching_snk_pdo); 2396 else if (pdo_max_current(matching_snk_pdo) > 2397 pdo_max_current(pdo)) 2398 max_ma = pdo_max_current(matching_snk_pdo); 2399 } 2400 2401 tcpm_log(port, "cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d", 2402 port->cc_req, port->cc1, port->cc2, port->vbus_source, 2403 port->vconn_role == TYPEC_SOURCE ? "source" : "sink", 2404 port->polarity); 2405 2406 if (type == PDO_TYPE_BATT) { 2407 *rdo = RDO_BATT(src_pdo_index + 1, mw, max_mw, flags); 2408 2409 tcpm_log(port, "Requesting PDO %d: %u mV, %u mW%s", 2410 src_pdo_index, mv, mw, 2411 flags & RDO_CAP_MISMATCH ? " [mismatch]" : ""); 2412 } else { 2413 *rdo = RDO_FIXED(src_pdo_index + 1, ma, max_ma, flags); 2414 2415 tcpm_log(port, "Requesting PDO %d: %u mV, %u mA%s", 2416 src_pdo_index, mv, ma, 2417 flags & RDO_CAP_MISMATCH ? " [mismatch]" : ""); 2418 } 2419 2420 port->current_limit = ma; 2421 port->supply_voltage = mv; 2422 2423 return 0; 2424 } 2425 2426 static int tcpm_pd_send_request(struct tcpm_port *port) 2427 { 2428 struct pd_message msg; 2429 int ret; 2430 u32 rdo; 2431 2432 ret = tcpm_pd_build_request(port, &rdo); 2433 if (ret < 0) 2434 return ret; 2435 2436 memset(&msg, 0, sizeof(msg)); 2437 msg.header = PD_HEADER_LE(PD_DATA_REQUEST, 2438 port->pwr_role, 2439 port->data_role, 2440 port->negotiated_rev, 2441 port->message_id, 1); 2442 msg.payload[0] = cpu_to_le32(rdo); 2443 2444 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 2445 } 2446 2447 static int tcpm_pd_build_pps_request(struct tcpm_port *port, u32 *rdo) 2448 { 2449 unsigned int out_mv, op_ma, op_mw, max_mv, max_ma, flags; 2450 enum pd_pdo_type type; 2451 unsigned int src_pdo_index; 2452 u32 pdo; 2453 2454 src_pdo_index = tcpm_pd_select_pps_apdo(port); 2455 if (!src_pdo_index) 2456 return -EOPNOTSUPP; 2457 2458 pdo = port->source_caps[src_pdo_index]; 2459 type = pdo_type(pdo); 2460 2461 switch (type) { 2462 case PDO_TYPE_APDO: 2463 if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) { 2464 tcpm_log(port, "Invalid APDO selected!"); 2465 return -EINVAL; 2466 } 2467 max_mv = port->pps_data.max_volt; 2468 max_ma = port->pps_data.max_curr; 2469 out_mv = port->pps_data.out_volt; 2470 op_ma = port->pps_data.op_curr; 2471 break; 2472 default: 2473 tcpm_log(port, "Invalid PDO selected!"); 2474 return -EINVAL; 2475 } 2476 2477 flags = RDO_USB_COMM | RDO_NO_SUSPEND; 2478 2479 op_mw = (op_ma * out_mv) / 1000; 2480 if (op_mw < port->operating_snk_mw) { 2481 /* 2482 * Try raising current to meet power needs. If that's not enough 2483 * then try upping the voltage. If that's still not enough 2484 * then we've obviously chosen a PPS APDO which really isn't 2485 * suitable so abandon ship. 2486 */ 2487 op_ma = (port->operating_snk_mw * 1000) / out_mv; 2488 if ((port->operating_snk_mw * 1000) % out_mv) 2489 ++op_ma; 2490 op_ma += RDO_PROG_CURR_MA_STEP - (op_ma % RDO_PROG_CURR_MA_STEP); 2491 2492 if (op_ma > max_ma) { 2493 op_ma = max_ma; 2494 out_mv = (port->operating_snk_mw * 1000) / op_ma; 2495 if ((port->operating_snk_mw * 1000) % op_ma) 2496 ++out_mv; 2497 out_mv += RDO_PROG_VOLT_MV_STEP - 2498 (out_mv % RDO_PROG_VOLT_MV_STEP); 2499 2500 if (out_mv > max_mv) { 2501 tcpm_log(port, "Invalid PPS APDO selected!"); 2502 return -EINVAL; 2503 } 2504 } 2505 } 2506 2507 tcpm_log(port, "cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d", 2508 port->cc_req, port->cc1, port->cc2, port->vbus_source, 2509 port->vconn_role == TYPEC_SOURCE ? "source" : "sink", 2510 port->polarity); 2511 2512 *rdo = RDO_PROG(src_pdo_index + 1, out_mv, op_ma, flags); 2513 2514 tcpm_log(port, "Requesting APDO %d: %u mV, %u mA", 2515 src_pdo_index, out_mv, op_ma); 2516 2517 port->pps_data.op_curr = op_ma; 2518 port->pps_data.out_volt = out_mv; 2519 2520 return 0; 2521 } 2522 2523 static int tcpm_pd_send_pps_request(struct tcpm_port *port) 2524 { 2525 struct pd_message msg; 2526 int ret; 2527 u32 rdo; 2528 2529 ret = tcpm_pd_build_pps_request(port, &rdo); 2530 if (ret < 0) 2531 return ret; 2532 2533 memset(&msg, 0, sizeof(msg)); 2534 msg.header = PD_HEADER_LE(PD_DATA_REQUEST, 2535 port->pwr_role, 2536 port->data_role, 2537 port->negotiated_rev, 2538 port->message_id, 1); 2539 msg.payload[0] = cpu_to_le32(rdo); 2540 2541 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); 2542 } 2543 2544 static int tcpm_set_vbus(struct tcpm_port *port, bool enable) 2545 { 2546 int ret; 2547 2548 if (enable && port->vbus_charge) 2549 return -EINVAL; 2550 2551 tcpm_log(port, "vbus:=%d charge=%d", enable, port->vbus_charge); 2552 2553 ret = port->tcpc->set_vbus(port->tcpc, enable, port->vbus_charge); 2554 if (ret < 0) 2555 return ret; 2556 2557 port->vbus_source = enable; 2558 return 0; 2559 } 2560 2561 static int tcpm_set_charge(struct tcpm_port *port, bool charge) 2562 { 2563 int ret; 2564 2565 if (charge && port->vbus_source) 2566 return -EINVAL; 2567 2568 if (charge != port->vbus_charge) { 2569 tcpm_log(port, "vbus=%d charge:=%d", port->vbus_source, charge); 2570 ret = port->tcpc->set_vbus(port->tcpc, port->vbus_source, 2571 charge); 2572 if (ret < 0) 2573 return ret; 2574 } 2575 port->vbus_charge = charge; 2576 return 0; 2577 } 2578 2579 static bool tcpm_start_toggling(struct tcpm_port *port, enum typec_cc_status cc) 2580 { 2581 int ret; 2582 2583 if (!port->tcpc->start_toggling) 2584 return false; 2585 2586 tcpm_log_force(port, "Start toggling"); 2587 ret = port->tcpc->start_toggling(port->tcpc, port->port_type, cc); 2588 return ret == 0; 2589 } 2590 2591 static void tcpm_set_cc(struct tcpm_port *port, enum typec_cc_status cc) 2592 { 2593 tcpm_log(port, "cc:=%d", cc); 2594 port->cc_req = cc; 2595 port->tcpc->set_cc(port->tcpc, cc); 2596 } 2597 2598 static int tcpm_init_vbus(struct tcpm_port *port) 2599 { 2600 int ret; 2601 2602 ret = port->tcpc->set_vbus(port->tcpc, false, false); 2603 port->vbus_source = false; 2604 port->vbus_charge = false; 2605 return ret; 2606 } 2607 2608 static int tcpm_init_vconn(struct tcpm_port *port) 2609 { 2610 int ret; 2611 2612 ret = port->tcpc->set_vconn(port->tcpc, false); 2613 port->vconn_role = TYPEC_SINK; 2614 return ret; 2615 } 2616 2617 static void tcpm_typec_connect(struct tcpm_port *port) 2618 { 2619 if (!port->connected) { 2620 /* Make sure we don't report stale identity information */ 2621 memset(&port->partner_ident, 0, sizeof(port->partner_ident)); 2622 port->partner_desc.usb_pd = port->pd_capable; 2623 if (tcpm_port_is_debug(port)) 2624 port->partner_desc.accessory = TYPEC_ACCESSORY_DEBUG; 2625 else if (tcpm_port_is_audio(port)) 2626 port->partner_desc.accessory = TYPEC_ACCESSORY_AUDIO; 2627 else 2628 port->partner_desc.accessory = TYPEC_ACCESSORY_NONE; 2629 port->partner = typec_register_partner(port->typec_port, 2630 &port->partner_desc); 2631 port->connected = true; 2632 } 2633 } 2634 2635 static int tcpm_src_attach(struct tcpm_port *port) 2636 { 2637 enum typec_cc_polarity polarity = 2638 port->cc2 == TYPEC_CC_RD ? TYPEC_POLARITY_CC2 2639 : TYPEC_POLARITY_CC1; 2640 int ret; 2641 2642 if (port->attached) 2643 return 0; 2644 2645 ret = tcpm_set_polarity(port, polarity); 2646 if (ret < 0) 2647 return ret; 2648 2649 ret = tcpm_set_roles(port, true, TYPEC_SOURCE, 2650 tcpm_data_role_for_source(port)); 2651 if (ret < 0) 2652 return ret; 2653 2654 ret = port->tcpc->set_pd_rx(port->tcpc, true); 2655 if (ret < 0) 2656 goto out_disable_mux; 2657 2658 /* 2659 * USB Type-C specification, version 1.2, 2660 * chapter 4.5.2.2.8.1 (Attached.SRC Requirements) 2661 * Enable VCONN only if the non-RD port is set to RA. 2662 */ 2663 if ((polarity == TYPEC_POLARITY_CC1 && port->cc2 == TYPEC_CC_RA) || 2664 (polarity == TYPEC_POLARITY_CC2 && port->cc1 == TYPEC_CC_RA)) { 2665 ret = tcpm_set_vconn(port, true); 2666 if (ret < 0) 2667 goto out_disable_pd; 2668 } 2669 2670 ret = tcpm_set_vbus(port, true); 2671 if (ret < 0) 2672 goto out_disable_vconn; 2673 2674 port->pd_capable = false; 2675 2676 port->partner = NULL; 2677 2678 port->attached = true; 2679 port->send_discover = true; 2680 2681 return 0; 2682 2683 out_disable_vconn: 2684 tcpm_set_vconn(port, false); 2685 out_disable_pd: 2686 port->tcpc->set_pd_rx(port->tcpc, false); 2687 out_disable_mux: 2688 tcpm_mux_set(port, TYPEC_STATE_SAFE, USB_ROLE_NONE, 2689 TYPEC_ORIENTATION_NONE); 2690 return ret; 2691 } 2692 2693 static void tcpm_typec_disconnect(struct tcpm_port *port) 2694 { 2695 if (port->connected) { 2696 typec_unregister_partner(port->partner); 2697 port->partner = NULL; 2698 port->connected = false; 2699 } 2700 } 2701 2702 static void tcpm_unregister_altmodes(struct tcpm_port *port) 2703 { 2704 struct pd_mode_data *modep = &port->mode_data; 2705 int i; 2706 2707 for (i = 0; i < modep->altmodes; i++) { 2708 typec_unregister_altmode(port->partner_altmode[i]); 2709 port->partner_altmode[i] = NULL; 2710 } 2711 2712 memset(modep, 0, sizeof(*modep)); 2713 } 2714 2715 static void tcpm_reset_port(struct tcpm_port *port) 2716 { 2717 tcpm_unregister_altmodes(port); 2718 tcpm_typec_disconnect(port); 2719 port->attached = false; 2720 port->pd_capable = false; 2721 port->pps_data.supported = false; 2722 2723 /* 2724 * First Rx ID should be 0; set this to a sentinel of -1 so that 2725 * we can check tcpm_pd_rx_handler() if we had seen it before. 2726 */ 2727 port->rx_msgid = -1; 2728 2729 port->tcpc->set_pd_rx(port->tcpc, false); 2730 tcpm_init_vbus(port); /* also disables charging */ 2731 tcpm_init_vconn(port); 2732 tcpm_set_current_limit(port, 0, 0); 2733 tcpm_set_polarity(port, TYPEC_POLARITY_CC1); 2734 tcpm_mux_set(port, TYPEC_STATE_SAFE, USB_ROLE_NONE, 2735 TYPEC_ORIENTATION_NONE); 2736 tcpm_set_attached_state(port, false); 2737 port->try_src_count = 0; 2738 port->try_snk_count = 0; 2739 port->usb_type = POWER_SUPPLY_USB_TYPE_C; 2740 2741 power_supply_changed(port->psy); 2742 } 2743 2744 static void tcpm_detach(struct tcpm_port *port) 2745 { 2746 if (!port->attached) 2747 return; 2748 2749 if (tcpm_port_is_disconnected(port)) 2750 port->hard_reset_count = 0; 2751 2752 tcpm_reset_port(port); 2753 } 2754 2755 static void tcpm_src_detach(struct tcpm_port *port) 2756 { 2757 tcpm_detach(port); 2758 } 2759 2760 static int tcpm_snk_attach(struct tcpm_port *port) 2761 { 2762 int ret; 2763 2764 if (port->attached) 2765 return 0; 2766 2767 ret = tcpm_set_polarity(port, port->cc2 != TYPEC_CC_OPEN ? 2768 TYPEC_POLARITY_CC2 : TYPEC_POLARITY_CC1); 2769 if (ret < 0) 2770 return ret; 2771 2772 ret = tcpm_set_roles(port, true, TYPEC_SINK, 2773 tcpm_data_role_for_sink(port)); 2774 if (ret < 0) 2775 return ret; 2776 2777 port->pd_capable = false; 2778 2779 port->partner = NULL; 2780 2781 port->attached = true; 2782 port->send_discover = true; 2783 2784 return 0; 2785 } 2786 2787 static void tcpm_snk_detach(struct tcpm_port *port) 2788 { 2789 tcpm_detach(port); 2790 } 2791 2792 static int tcpm_acc_attach(struct tcpm_port *port) 2793 { 2794 int ret; 2795 2796 if (port->attached) 2797 return 0; 2798 2799 ret = tcpm_set_roles(port, true, TYPEC_SOURCE, 2800 tcpm_data_role_for_source(port)); 2801 if (ret < 0) 2802 return ret; 2803 2804 port->partner = NULL; 2805 2806 tcpm_typec_connect(port); 2807 2808 port->attached = true; 2809 2810 return 0; 2811 } 2812 2813 static void tcpm_acc_detach(struct tcpm_port *port) 2814 { 2815 tcpm_detach(port); 2816 } 2817 2818 static inline enum tcpm_state hard_reset_state(struct tcpm_port *port) 2819 { 2820 if (port->hard_reset_count < PD_N_HARD_RESET_COUNT) 2821 return HARD_RESET_SEND; 2822 if (port->pd_capable) 2823 return ERROR_RECOVERY; 2824 if (port->pwr_role == TYPEC_SOURCE) 2825 return SRC_UNATTACHED; 2826 if (port->state == SNK_WAIT_CAPABILITIES) 2827 return SNK_READY; 2828 return SNK_UNATTACHED; 2829 } 2830 2831 static inline enum tcpm_state unattached_state(struct tcpm_port *port) 2832 { 2833 if (port->port_type == TYPEC_PORT_DRP) { 2834 if (port->pwr_role == TYPEC_SOURCE) 2835 return SRC_UNATTACHED; 2836 else 2837 return SNK_UNATTACHED; 2838 } else if (port->port_type == TYPEC_PORT_SRC) { 2839 return SRC_UNATTACHED; 2840 } 2841 2842 return SNK_UNATTACHED; 2843 } 2844 2845 static void tcpm_check_send_discover(struct tcpm_port *port) 2846 { 2847 if (port->data_role == TYPEC_HOST && port->send_discover && 2848 port->pd_capable) { 2849 tcpm_send_vdm(port, USB_SID_PD, CMD_DISCOVER_IDENT, NULL, 0); 2850 port->send_discover = false; 2851 } 2852 } 2853 2854 static void tcpm_swap_complete(struct tcpm_port *port, int result) 2855 { 2856 if (port->swap_pending) { 2857 port->swap_status = result; 2858 port->swap_pending = false; 2859 port->non_pd_role_swap = false; 2860 complete(&port->swap_complete); 2861 } 2862 } 2863 2864 static enum typec_pwr_opmode tcpm_get_pwr_opmode(enum typec_cc_status cc) 2865 { 2866 switch (cc) { 2867 case TYPEC_CC_RP_1_5: 2868 return TYPEC_PWR_MODE_1_5A; 2869 case TYPEC_CC_RP_3_0: 2870 return TYPEC_PWR_MODE_3_0A; 2871 case TYPEC_CC_RP_DEF: 2872 default: 2873 return TYPEC_PWR_MODE_USB; 2874 } 2875 } 2876 2877 static void run_state_machine(struct tcpm_port *port) 2878 { 2879 int ret; 2880 enum typec_pwr_opmode opmode; 2881 unsigned int msecs; 2882 2883 port->enter_state = port->state; 2884 switch (port->state) { 2885 case TOGGLING: 2886 break; 2887 /* SRC states */ 2888 case SRC_UNATTACHED: 2889 if (!port->non_pd_role_swap) 2890 tcpm_swap_complete(port, -ENOTCONN); 2891 tcpm_src_detach(port); 2892 if (tcpm_start_toggling(port, tcpm_rp_cc(port))) { 2893 tcpm_set_state(port, TOGGLING, 0); 2894 break; 2895 } 2896 tcpm_set_cc(port, tcpm_rp_cc(port)); 2897 if (port->port_type == TYPEC_PORT_DRP) 2898 tcpm_set_state(port, SNK_UNATTACHED, PD_T_DRP_SNK); 2899 break; 2900 case SRC_ATTACH_WAIT: 2901 if (tcpm_port_is_debug(port)) 2902 tcpm_set_state(port, DEBUG_ACC_ATTACHED, 2903 PD_T_CC_DEBOUNCE); 2904 else if (tcpm_port_is_audio(port)) 2905 tcpm_set_state(port, AUDIO_ACC_ATTACHED, 2906 PD_T_CC_DEBOUNCE); 2907 else if (tcpm_port_is_source(port)) 2908 tcpm_set_state(port, 2909 tcpm_try_snk(port) ? SNK_TRY 2910 : SRC_ATTACHED, 2911 PD_T_CC_DEBOUNCE); 2912 break; 2913 2914 case SNK_TRY: 2915 port->try_snk_count++; 2916 /* 2917 * Requirements: 2918 * - Do not drive vconn or vbus 2919 * - Terminate CC pins (both) to Rd 2920 * Action: 2921 * - Wait for tDRPTry (PD_T_DRP_TRY). 2922 * Until then, ignore any state changes. 2923 */ 2924 tcpm_set_cc(port, TYPEC_CC_RD); 2925 tcpm_set_state(port, SNK_TRY_WAIT, PD_T_DRP_TRY); 2926 break; 2927 case SNK_TRY_WAIT: 2928 if (tcpm_port_is_sink(port)) { 2929 tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE, 0); 2930 } else { 2931 tcpm_set_state(port, SRC_TRYWAIT, 0); 2932 port->max_wait = 0; 2933 } 2934 break; 2935 case SNK_TRY_WAIT_DEBOUNCE: 2936 tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS, 2937 PD_T_PD_DEBOUNCE); 2938 break; 2939 case SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS: 2940 if (port->vbus_present && tcpm_port_is_sink(port)) { 2941 tcpm_set_state(port, SNK_ATTACHED, 0); 2942 } else { 2943 tcpm_set_state(port, SRC_TRYWAIT, 0); 2944 port->max_wait = 0; 2945 } 2946 break; 2947 case SRC_TRYWAIT: 2948 tcpm_set_cc(port, tcpm_rp_cc(port)); 2949 if (port->max_wait == 0) { 2950 port->max_wait = jiffies + 2951 msecs_to_jiffies(PD_T_DRP_TRY); 2952 tcpm_set_state(port, SRC_TRYWAIT_UNATTACHED, 2953 PD_T_DRP_TRY); 2954 } else { 2955 if (time_is_after_jiffies(port->max_wait)) 2956 tcpm_set_state(port, SRC_TRYWAIT_UNATTACHED, 2957 jiffies_to_msecs(port->max_wait - 2958 jiffies)); 2959 else 2960 tcpm_set_state(port, SNK_UNATTACHED, 0); 2961 } 2962 break; 2963 case SRC_TRYWAIT_DEBOUNCE: 2964 tcpm_set_state(port, SRC_ATTACHED, PD_T_CC_DEBOUNCE); 2965 break; 2966 case SRC_TRYWAIT_UNATTACHED: 2967 tcpm_set_state(port, SNK_UNATTACHED, 0); 2968 break; 2969 2970 case SRC_ATTACHED: 2971 ret = tcpm_src_attach(port); 2972 tcpm_set_state(port, SRC_UNATTACHED, 2973 ret < 0 ? 0 : PD_T_PS_SOURCE_ON); 2974 break; 2975 case SRC_STARTUP: 2976 opmode = tcpm_get_pwr_opmode(tcpm_rp_cc(port)); 2977 typec_set_pwr_opmode(port->typec_port, opmode); 2978 port->pwr_opmode = TYPEC_PWR_MODE_USB; 2979 port->caps_count = 0; 2980 port->negotiated_rev = PD_MAX_REV; 2981 port->message_id = 0; 2982 port->rx_msgid = -1; 2983 port->explicit_contract = false; 2984 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0); 2985 break; 2986 case SRC_SEND_CAPABILITIES: 2987 port->caps_count++; 2988 if (port->caps_count > PD_N_CAPS_COUNT) { 2989 tcpm_set_state(port, SRC_READY, 0); 2990 break; 2991 } 2992 ret = tcpm_pd_send_source_caps(port); 2993 if (ret < 0) { 2994 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 2995 PD_T_SEND_SOURCE_CAP); 2996 } else { 2997 /* 2998 * Per standard, we should clear the reset counter here. 2999 * However, that can result in state machine hang-ups. 3000 * Reset it only in READY state to improve stability. 3001 */ 3002 /* port->hard_reset_count = 0; */ 3003 port->caps_count = 0; 3004 port->pd_capable = true; 3005 tcpm_set_state_cond(port, SRC_SEND_CAPABILITIES_TIMEOUT, 3006 PD_T_SEND_SOURCE_CAP); 3007 } 3008 break; 3009 case SRC_SEND_CAPABILITIES_TIMEOUT: 3010 /* 3011 * Error recovery for a PD_DATA_SOURCE_CAP reply timeout. 3012 * 3013 * PD 2.0 sinks are supposed to accept src-capabilities with a 3014 * 3.0 header and simply ignore any src PDOs which the sink does 3015 * not understand such as PPS but some 2.0 sinks instead ignore 3016 * the entire PD_DATA_SOURCE_CAP message, causing contract 3017 * negotiation to fail. 3018 * 3019 * After PD_N_HARD_RESET_COUNT hard-reset attempts, we try 3020 * sending src-capabilities with a lower PD revision to 3021 * make these broken sinks work. 3022 */ 3023 if (port->hard_reset_count < PD_N_HARD_RESET_COUNT) { 3024 tcpm_set_state(port, HARD_RESET_SEND, 0); 3025 } else if (port->negotiated_rev > PD_REV20) { 3026 port->negotiated_rev--; 3027 port->hard_reset_count = 0; 3028 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0); 3029 } else { 3030 tcpm_set_state(port, hard_reset_state(port), 0); 3031 } 3032 break; 3033 case SRC_NEGOTIATE_CAPABILITIES: 3034 ret = tcpm_pd_check_request(port); 3035 if (ret < 0) { 3036 tcpm_pd_send_control(port, PD_CTRL_REJECT); 3037 if (!port->explicit_contract) { 3038 tcpm_set_state(port, 3039 SRC_WAIT_NEW_CAPABILITIES, 0); 3040 } else { 3041 tcpm_set_state(port, SRC_READY, 0); 3042 } 3043 } else { 3044 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 3045 tcpm_set_state(port, SRC_TRANSITION_SUPPLY, 3046 PD_T_SRC_TRANSITION); 3047 } 3048 break; 3049 case SRC_TRANSITION_SUPPLY: 3050 /* XXX: regulator_set_voltage(vbus, ...) */ 3051 tcpm_pd_send_control(port, PD_CTRL_PS_RDY); 3052 port->explicit_contract = true; 3053 typec_set_pwr_opmode(port->typec_port, TYPEC_PWR_MODE_PD); 3054 port->pwr_opmode = TYPEC_PWR_MODE_PD; 3055 tcpm_set_state_cond(port, SRC_READY, 0); 3056 break; 3057 case SRC_READY: 3058 #if 1 3059 port->hard_reset_count = 0; 3060 #endif 3061 port->try_src_count = 0; 3062 3063 tcpm_swap_complete(port, 0); 3064 tcpm_typec_connect(port); 3065 3066 tcpm_check_send_discover(port); 3067 /* 3068 * 6.3.5 3069 * Sending ping messages is not necessary if 3070 * - the source operates at vSafe5V 3071 * or 3072 * - The system is not operating in PD mode 3073 * or 3074 * - Both partners are connected using a Type-C connector 3075 * 3076 * There is no actual need to send PD messages since the local 3077 * port type-c and the spec does not clearly say whether PD is 3078 * possible when type-c is connected to Type-A/B 3079 */ 3080 break; 3081 case SRC_WAIT_NEW_CAPABILITIES: 3082 /* Nothing to do... */ 3083 break; 3084 3085 /* SNK states */ 3086 case SNK_UNATTACHED: 3087 if (!port->non_pd_role_swap) 3088 tcpm_swap_complete(port, -ENOTCONN); 3089 tcpm_pps_complete(port, -ENOTCONN); 3090 tcpm_snk_detach(port); 3091 if (tcpm_start_toggling(port, TYPEC_CC_RD)) { 3092 tcpm_set_state(port, TOGGLING, 0); 3093 break; 3094 } 3095 tcpm_set_cc(port, TYPEC_CC_RD); 3096 if (port->port_type == TYPEC_PORT_DRP) 3097 tcpm_set_state(port, SRC_UNATTACHED, PD_T_DRP_SRC); 3098 break; 3099 case SNK_ATTACH_WAIT: 3100 if ((port->cc1 == TYPEC_CC_OPEN && 3101 port->cc2 != TYPEC_CC_OPEN) || 3102 (port->cc1 != TYPEC_CC_OPEN && 3103 port->cc2 == TYPEC_CC_OPEN)) 3104 tcpm_set_state(port, SNK_DEBOUNCED, 3105 PD_T_CC_DEBOUNCE); 3106 else if (tcpm_port_is_disconnected(port)) 3107 tcpm_set_state(port, SNK_UNATTACHED, 3108 PD_T_PD_DEBOUNCE); 3109 break; 3110 case SNK_DEBOUNCED: 3111 if (tcpm_port_is_disconnected(port)) 3112 tcpm_set_state(port, SNK_UNATTACHED, 3113 PD_T_PD_DEBOUNCE); 3114 else if (port->vbus_present) 3115 tcpm_set_state(port, 3116 tcpm_try_src(port) ? SRC_TRY 3117 : SNK_ATTACHED, 3118 0); 3119 else 3120 /* Wait for VBUS, but not forever */ 3121 tcpm_set_state(port, PORT_RESET, PD_T_PS_SOURCE_ON); 3122 break; 3123 3124 case SRC_TRY: 3125 port->try_src_count++; 3126 tcpm_set_cc(port, tcpm_rp_cc(port)); 3127 port->max_wait = 0; 3128 tcpm_set_state(port, SRC_TRY_WAIT, 0); 3129 break; 3130 case SRC_TRY_WAIT: 3131 if (port->max_wait == 0) { 3132 port->max_wait = jiffies + 3133 msecs_to_jiffies(PD_T_DRP_TRY); 3134 msecs = PD_T_DRP_TRY; 3135 } else { 3136 if (time_is_after_jiffies(port->max_wait)) 3137 msecs = jiffies_to_msecs(port->max_wait - 3138 jiffies); 3139 else 3140 msecs = 0; 3141 } 3142 tcpm_set_state(port, SNK_TRYWAIT, msecs); 3143 break; 3144 case SRC_TRY_DEBOUNCE: 3145 tcpm_set_state(port, SRC_ATTACHED, PD_T_PD_DEBOUNCE); 3146 break; 3147 case SNK_TRYWAIT: 3148 tcpm_set_cc(port, TYPEC_CC_RD); 3149 tcpm_set_state(port, SNK_TRYWAIT_VBUS, PD_T_CC_DEBOUNCE); 3150 break; 3151 case SNK_TRYWAIT_VBUS: 3152 /* 3153 * TCPM stays in this state indefinitely until VBUS 3154 * is detected as long as Rp is not detected for 3155 * more than a time period of tPDDebounce. 3156 */ 3157 if (port->vbus_present && tcpm_port_is_sink(port)) { 3158 tcpm_set_state(port, SNK_ATTACHED, 0); 3159 break; 3160 } 3161 if (!tcpm_port_is_sink(port)) 3162 tcpm_set_state(port, SNK_TRYWAIT_DEBOUNCE, 0); 3163 break; 3164 case SNK_TRYWAIT_DEBOUNCE: 3165 tcpm_set_state(port, SNK_UNATTACHED, PD_T_PD_DEBOUNCE); 3166 break; 3167 case SNK_ATTACHED: 3168 ret = tcpm_snk_attach(port); 3169 if (ret < 0) 3170 tcpm_set_state(port, SNK_UNATTACHED, 0); 3171 else 3172 tcpm_set_state(port, SNK_STARTUP, 0); 3173 break; 3174 case SNK_STARTUP: 3175 opmode = tcpm_get_pwr_opmode(port->polarity ? 3176 port->cc2 : port->cc1); 3177 typec_set_pwr_opmode(port->typec_port, opmode); 3178 port->pwr_opmode = TYPEC_PWR_MODE_USB; 3179 port->negotiated_rev = PD_MAX_REV; 3180 port->message_id = 0; 3181 port->rx_msgid = -1; 3182 port->explicit_contract = false; 3183 tcpm_set_state(port, SNK_DISCOVERY, 0); 3184 break; 3185 case SNK_DISCOVERY: 3186 if (port->vbus_present) { 3187 tcpm_set_current_limit(port, 3188 tcpm_get_current_limit(port), 3189 5000); 3190 tcpm_set_charge(port, true); 3191 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0); 3192 break; 3193 } 3194 /* 3195 * For DRP, timeouts differ. Also, handling is supposed to be 3196 * different and much more complex (dead battery detection; 3197 * see USB power delivery specification, section 8.3.3.6.1.5.1). 3198 */ 3199 tcpm_set_state(port, hard_reset_state(port), 3200 port->port_type == TYPEC_PORT_DRP ? 3201 PD_T_DB_DETECT : PD_T_NO_RESPONSE); 3202 break; 3203 case SNK_DISCOVERY_DEBOUNCE: 3204 tcpm_set_state(port, SNK_DISCOVERY_DEBOUNCE_DONE, 3205 PD_T_CC_DEBOUNCE); 3206 break; 3207 case SNK_DISCOVERY_DEBOUNCE_DONE: 3208 if (!tcpm_port_is_disconnected(port) && 3209 tcpm_port_is_sink(port) && 3210 time_is_after_jiffies(port->delayed_runtime)) { 3211 tcpm_set_state(port, SNK_DISCOVERY, 3212 jiffies_to_msecs(port->delayed_runtime - 3213 jiffies)); 3214 break; 3215 } 3216 tcpm_set_state(port, unattached_state(port), 0); 3217 break; 3218 case SNK_WAIT_CAPABILITIES: 3219 ret = port->tcpc->set_pd_rx(port->tcpc, true); 3220 if (ret < 0) { 3221 tcpm_set_state(port, SNK_READY, 0); 3222 break; 3223 } 3224 /* 3225 * If VBUS has never been low, and we time out waiting 3226 * for source cap, try a soft reset first, in case we 3227 * were already in a stable contract before this boot. 3228 * Do this only once. 3229 */ 3230 if (port->vbus_never_low) { 3231 port->vbus_never_low = false; 3232 tcpm_set_state(port, SOFT_RESET_SEND, 3233 PD_T_SINK_WAIT_CAP); 3234 } else { 3235 tcpm_set_state(port, hard_reset_state(port), 3236 PD_T_SINK_WAIT_CAP); 3237 } 3238 break; 3239 case SNK_NEGOTIATE_CAPABILITIES: 3240 port->pd_capable = true; 3241 port->hard_reset_count = 0; 3242 ret = tcpm_pd_send_request(port); 3243 if (ret < 0) { 3244 /* Let the Source send capabilities again. */ 3245 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0); 3246 } else { 3247 tcpm_set_state_cond(port, hard_reset_state(port), 3248 PD_T_SENDER_RESPONSE); 3249 } 3250 break; 3251 case SNK_NEGOTIATE_PPS_CAPABILITIES: 3252 ret = tcpm_pd_send_pps_request(port); 3253 if (ret < 0) { 3254 port->pps_status = ret; 3255 /* 3256 * If this was called due to updates to sink 3257 * capabilities, and pps is no longer valid, we should 3258 * safely fall back to a standard PDO. 3259 */ 3260 if (port->update_sink_caps) 3261 tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0); 3262 else 3263 tcpm_set_state(port, SNK_READY, 0); 3264 } else { 3265 tcpm_set_state_cond(port, hard_reset_state(port), 3266 PD_T_SENDER_RESPONSE); 3267 } 3268 break; 3269 case SNK_TRANSITION_SINK: 3270 case SNK_TRANSITION_SINK_VBUS: 3271 tcpm_set_state(port, hard_reset_state(port), 3272 PD_T_PS_TRANSITION); 3273 break; 3274 case SNK_READY: 3275 port->try_snk_count = 0; 3276 port->update_sink_caps = false; 3277 if (port->explicit_contract) { 3278 typec_set_pwr_opmode(port->typec_port, 3279 TYPEC_PWR_MODE_PD); 3280 port->pwr_opmode = TYPEC_PWR_MODE_PD; 3281 } 3282 3283 tcpm_swap_complete(port, 0); 3284 tcpm_typec_connect(port); 3285 tcpm_check_send_discover(port); 3286 tcpm_pps_complete(port, port->pps_status); 3287 3288 power_supply_changed(port->psy); 3289 3290 break; 3291 3292 /* Accessory states */ 3293 case ACC_UNATTACHED: 3294 tcpm_acc_detach(port); 3295 tcpm_set_state(port, SRC_UNATTACHED, 0); 3296 break; 3297 case DEBUG_ACC_ATTACHED: 3298 case AUDIO_ACC_ATTACHED: 3299 ret = tcpm_acc_attach(port); 3300 if (ret < 0) 3301 tcpm_set_state(port, ACC_UNATTACHED, 0); 3302 break; 3303 case AUDIO_ACC_DEBOUNCE: 3304 tcpm_set_state(port, ACC_UNATTACHED, PD_T_CC_DEBOUNCE); 3305 break; 3306 3307 /* Hard_Reset states */ 3308 case HARD_RESET_SEND: 3309 tcpm_pd_transmit(port, TCPC_TX_HARD_RESET, NULL); 3310 tcpm_set_state(port, HARD_RESET_START, 0); 3311 break; 3312 case HARD_RESET_START: 3313 port->hard_reset_count++; 3314 port->tcpc->set_pd_rx(port->tcpc, false); 3315 tcpm_unregister_altmodes(port); 3316 port->send_discover = true; 3317 if (port->pwr_role == TYPEC_SOURCE) 3318 tcpm_set_state(port, SRC_HARD_RESET_VBUS_OFF, 3319 PD_T_PS_HARD_RESET); 3320 else 3321 tcpm_set_state(port, SNK_HARD_RESET_SINK_OFF, 0); 3322 break; 3323 case SRC_HARD_RESET_VBUS_OFF: 3324 tcpm_set_vconn(port, true); 3325 tcpm_set_vbus(port, false); 3326 tcpm_set_roles(port, port->self_powered, TYPEC_SOURCE, 3327 tcpm_data_role_for_source(port)); 3328 tcpm_set_state(port, SRC_HARD_RESET_VBUS_ON, PD_T_SRC_RECOVER); 3329 break; 3330 case SRC_HARD_RESET_VBUS_ON: 3331 tcpm_set_vbus(port, true); 3332 port->tcpc->set_pd_rx(port->tcpc, true); 3333 tcpm_set_attached_state(port, true); 3334 tcpm_set_state(port, SRC_UNATTACHED, PD_T_PS_SOURCE_ON); 3335 break; 3336 case SNK_HARD_RESET_SINK_OFF: 3337 memset(&port->pps_data, 0, sizeof(port->pps_data)); 3338 tcpm_set_vconn(port, false); 3339 if (port->pd_capable) 3340 tcpm_set_charge(port, false); 3341 tcpm_set_roles(port, port->self_powered, TYPEC_SINK, 3342 tcpm_data_role_for_sink(port)); 3343 /* 3344 * VBUS may or may not toggle, depending on the adapter. 3345 * If it doesn't toggle, transition to SNK_HARD_RESET_SINK_ON 3346 * directly after timeout. 3347 */ 3348 tcpm_set_state(port, SNK_HARD_RESET_SINK_ON, PD_T_SAFE_0V); 3349 break; 3350 case SNK_HARD_RESET_WAIT_VBUS: 3351 /* Assume we're disconnected if VBUS doesn't come back. */ 3352 tcpm_set_state(port, SNK_UNATTACHED, 3353 PD_T_SRC_RECOVER_MAX + PD_T_SRC_TURN_ON); 3354 break; 3355 case SNK_HARD_RESET_SINK_ON: 3356 /* Note: There is no guarantee that VBUS is on in this state */ 3357 /* 3358 * XXX: 3359 * The specification suggests that dual mode ports in sink 3360 * mode should transition to state PE_SRC_Transition_to_default. 3361 * See USB power delivery specification chapter 8.3.3.6.1.3. 3362 * This would mean to to 3363 * - turn off VCONN, reset power supply 3364 * - request hardware reset 3365 * - turn on VCONN 3366 * - Transition to state PE_Src_Startup 3367 * SNK only ports shall transition to state Snk_Startup 3368 * (see chapter 8.3.3.3.8). 3369 * Similar, dual-mode ports in source mode should transition 3370 * to PE_SNK_Transition_to_default. 3371 */ 3372 if (port->pd_capable) { 3373 tcpm_set_current_limit(port, 3374 tcpm_get_current_limit(port), 3375 5000); 3376 tcpm_set_charge(port, true); 3377 } 3378 tcpm_set_attached_state(port, true); 3379 tcpm_set_state(port, SNK_STARTUP, 0); 3380 break; 3381 3382 /* Soft_Reset states */ 3383 case SOFT_RESET: 3384 port->message_id = 0; 3385 port->rx_msgid = -1; 3386 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 3387 if (port->pwr_role == TYPEC_SOURCE) 3388 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0); 3389 else 3390 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0); 3391 break; 3392 case SOFT_RESET_SEND: 3393 port->message_id = 0; 3394 port->rx_msgid = -1; 3395 if (tcpm_pd_send_control(port, PD_CTRL_SOFT_RESET)) 3396 tcpm_set_state_cond(port, hard_reset_state(port), 0); 3397 else 3398 tcpm_set_state_cond(port, hard_reset_state(port), 3399 PD_T_SENDER_RESPONSE); 3400 break; 3401 3402 /* DR_Swap states */ 3403 case DR_SWAP_SEND: 3404 tcpm_pd_send_control(port, PD_CTRL_DR_SWAP); 3405 tcpm_set_state_cond(port, DR_SWAP_SEND_TIMEOUT, 3406 PD_T_SENDER_RESPONSE); 3407 break; 3408 case DR_SWAP_ACCEPT: 3409 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 3410 tcpm_set_state_cond(port, DR_SWAP_CHANGE_DR, 0); 3411 break; 3412 case DR_SWAP_SEND_TIMEOUT: 3413 tcpm_swap_complete(port, -ETIMEDOUT); 3414 tcpm_set_state(port, ready_state(port), 0); 3415 break; 3416 case DR_SWAP_CHANGE_DR: 3417 if (port->data_role == TYPEC_HOST) { 3418 tcpm_unregister_altmodes(port); 3419 tcpm_set_roles(port, true, port->pwr_role, 3420 TYPEC_DEVICE); 3421 } else { 3422 tcpm_set_roles(port, true, port->pwr_role, 3423 TYPEC_HOST); 3424 port->send_discover = true; 3425 } 3426 tcpm_set_state(port, ready_state(port), 0); 3427 break; 3428 3429 /* PR_Swap states */ 3430 case PR_SWAP_ACCEPT: 3431 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 3432 tcpm_set_state(port, PR_SWAP_START, 0); 3433 break; 3434 case PR_SWAP_SEND: 3435 tcpm_pd_send_control(port, PD_CTRL_PR_SWAP); 3436 tcpm_set_state_cond(port, PR_SWAP_SEND_TIMEOUT, 3437 PD_T_SENDER_RESPONSE); 3438 break; 3439 case PR_SWAP_SEND_TIMEOUT: 3440 tcpm_swap_complete(port, -ETIMEDOUT); 3441 tcpm_set_state(port, ready_state(port), 0); 3442 break; 3443 case PR_SWAP_START: 3444 if (port->pwr_role == TYPEC_SOURCE) 3445 tcpm_set_state(port, PR_SWAP_SRC_SNK_TRANSITION_OFF, 3446 PD_T_SRC_TRANSITION); 3447 else 3448 tcpm_set_state(port, PR_SWAP_SNK_SRC_SINK_OFF, 0); 3449 break; 3450 case PR_SWAP_SRC_SNK_TRANSITION_OFF: 3451 tcpm_set_vbus(port, false); 3452 port->explicit_contract = false; 3453 /* allow time for Vbus discharge, must be < tSrcSwapStdby */ 3454 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF, 3455 PD_T_SRCSWAPSTDBY); 3456 break; 3457 case PR_SWAP_SRC_SNK_SOURCE_OFF: 3458 tcpm_set_cc(port, TYPEC_CC_RD); 3459 /* allow CC debounce */ 3460 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED, 3461 PD_T_CC_DEBOUNCE); 3462 break; 3463 case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED: 3464 /* 3465 * USB-PD standard, 6.2.1.4, Port Power Role: 3466 * "During the Power Role Swap Sequence, for the initial Source 3467 * Port, the Port Power Role field shall be set to Sink in the 3468 * PS_RDY Message indicating that the initial Source’s power 3469 * supply is turned off" 3470 */ 3471 tcpm_set_pwr_role(port, TYPEC_SINK); 3472 if (tcpm_pd_send_control(port, PD_CTRL_PS_RDY)) { 3473 tcpm_set_state(port, ERROR_RECOVERY, 0); 3474 break; 3475 } 3476 tcpm_set_state_cond(port, SNK_UNATTACHED, PD_T_PS_SOURCE_ON); 3477 break; 3478 case PR_SWAP_SRC_SNK_SINK_ON: 3479 tcpm_set_state(port, SNK_STARTUP, 0); 3480 break; 3481 case PR_SWAP_SNK_SRC_SINK_OFF: 3482 tcpm_set_charge(port, false); 3483 tcpm_set_state(port, hard_reset_state(port), 3484 PD_T_PS_SOURCE_OFF); 3485 break; 3486 case PR_SWAP_SNK_SRC_SOURCE_ON: 3487 tcpm_set_cc(port, tcpm_rp_cc(port)); 3488 tcpm_set_vbus(port, true); 3489 /* 3490 * allow time VBUS ramp-up, must be < tNewSrc 3491 * Also, this window overlaps with CC debounce as well. 3492 * So, Wait for the max of two which is PD_T_NEWSRC 3493 */ 3494 tcpm_set_state(port, PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP, 3495 PD_T_NEWSRC); 3496 break; 3497 case PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP: 3498 /* 3499 * USB PD standard, 6.2.1.4: 3500 * "Subsequent Messages initiated by the Policy Engine, 3501 * such as the PS_RDY Message sent to indicate that Vbus 3502 * is ready, will have the Port Power Role field set to 3503 * Source." 3504 */ 3505 tcpm_set_pwr_role(port, TYPEC_SOURCE); 3506 tcpm_pd_send_control(port, PD_CTRL_PS_RDY); 3507 tcpm_set_state(port, SRC_STARTUP, 0); 3508 break; 3509 3510 case VCONN_SWAP_ACCEPT: 3511 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 3512 tcpm_set_state(port, VCONN_SWAP_START, 0); 3513 break; 3514 case VCONN_SWAP_SEND: 3515 tcpm_pd_send_control(port, PD_CTRL_VCONN_SWAP); 3516 tcpm_set_state(port, VCONN_SWAP_SEND_TIMEOUT, 3517 PD_T_SENDER_RESPONSE); 3518 break; 3519 case VCONN_SWAP_SEND_TIMEOUT: 3520 tcpm_swap_complete(port, -ETIMEDOUT); 3521 tcpm_set_state(port, ready_state(port), 0); 3522 break; 3523 case VCONN_SWAP_START: 3524 if (port->vconn_role == TYPEC_SOURCE) 3525 tcpm_set_state(port, VCONN_SWAP_WAIT_FOR_VCONN, 0); 3526 else 3527 tcpm_set_state(port, VCONN_SWAP_TURN_ON_VCONN, 0); 3528 break; 3529 case VCONN_SWAP_WAIT_FOR_VCONN: 3530 tcpm_set_state(port, hard_reset_state(port), 3531 PD_T_VCONN_SOURCE_ON); 3532 break; 3533 case VCONN_SWAP_TURN_ON_VCONN: 3534 tcpm_set_vconn(port, true); 3535 tcpm_pd_send_control(port, PD_CTRL_PS_RDY); 3536 tcpm_set_state(port, ready_state(port), 0); 3537 break; 3538 case VCONN_SWAP_TURN_OFF_VCONN: 3539 tcpm_set_vconn(port, false); 3540 tcpm_set_state(port, ready_state(port), 0); 3541 break; 3542 3543 case DR_SWAP_CANCEL: 3544 case PR_SWAP_CANCEL: 3545 case VCONN_SWAP_CANCEL: 3546 tcpm_swap_complete(port, port->swap_status); 3547 if (port->pwr_role == TYPEC_SOURCE) 3548 tcpm_set_state(port, SRC_READY, 0); 3549 else 3550 tcpm_set_state(port, SNK_READY, 0); 3551 break; 3552 3553 case BIST_RX: 3554 switch (BDO_MODE_MASK(port->bist_request)) { 3555 case BDO_MODE_CARRIER2: 3556 tcpm_pd_transmit(port, TCPC_TX_BIST_MODE_2, NULL); 3557 break; 3558 default: 3559 break; 3560 } 3561 /* Always switch to unattached state */ 3562 tcpm_set_state(port, unattached_state(port), 0); 3563 break; 3564 case GET_STATUS_SEND: 3565 tcpm_pd_send_control(port, PD_CTRL_GET_STATUS); 3566 tcpm_set_state(port, GET_STATUS_SEND_TIMEOUT, 3567 PD_T_SENDER_RESPONSE); 3568 break; 3569 case GET_STATUS_SEND_TIMEOUT: 3570 tcpm_set_state(port, ready_state(port), 0); 3571 break; 3572 case GET_PPS_STATUS_SEND: 3573 tcpm_pd_send_control(port, PD_CTRL_GET_PPS_STATUS); 3574 tcpm_set_state(port, GET_PPS_STATUS_SEND_TIMEOUT, 3575 PD_T_SENDER_RESPONSE); 3576 break; 3577 case GET_PPS_STATUS_SEND_TIMEOUT: 3578 tcpm_set_state(port, ready_state(port), 0); 3579 break; 3580 case ERROR_RECOVERY: 3581 tcpm_swap_complete(port, -EPROTO); 3582 tcpm_pps_complete(port, -EPROTO); 3583 tcpm_set_state(port, PORT_RESET, 0); 3584 break; 3585 case PORT_RESET: 3586 tcpm_reset_port(port); 3587 tcpm_set_cc(port, TYPEC_CC_OPEN); 3588 tcpm_set_state(port, PORT_RESET_WAIT_OFF, 3589 PD_T_ERROR_RECOVERY); 3590 break; 3591 case PORT_RESET_WAIT_OFF: 3592 tcpm_set_state(port, 3593 tcpm_default_state(port), 3594 port->vbus_present ? PD_T_PS_SOURCE_OFF : 0); 3595 break; 3596 default: 3597 WARN(1, "Unexpected port state %d\n", port->state); 3598 break; 3599 } 3600 } 3601 3602 static void tcpm_state_machine_work(struct work_struct *work) 3603 { 3604 struct tcpm_port *port = container_of(work, struct tcpm_port, 3605 state_machine.work); 3606 enum tcpm_state prev_state; 3607 3608 mutex_lock(&port->lock); 3609 port->state_machine_running = true; 3610 3611 if (port->queued_message && tcpm_send_queued_message(port)) 3612 goto done; 3613 3614 /* If we were queued due to a delayed state change, update it now */ 3615 if (port->delayed_state) { 3616 tcpm_log(port, "state change %s -> %s [delayed %ld ms]", 3617 tcpm_states[port->state], 3618 tcpm_states[port->delayed_state], port->delay_ms); 3619 port->prev_state = port->state; 3620 port->state = port->delayed_state; 3621 port->delayed_state = INVALID_STATE; 3622 } 3623 3624 /* 3625 * Continue running as long as we have (non-delayed) state changes 3626 * to make. 3627 */ 3628 do { 3629 prev_state = port->state; 3630 run_state_machine(port); 3631 if (port->queued_message) 3632 tcpm_send_queued_message(port); 3633 } while (port->state != prev_state && !port->delayed_state); 3634 3635 done: 3636 port->state_machine_running = false; 3637 mutex_unlock(&port->lock); 3638 } 3639 3640 static void _tcpm_cc_change(struct tcpm_port *port, enum typec_cc_status cc1, 3641 enum typec_cc_status cc2) 3642 { 3643 enum typec_cc_status old_cc1, old_cc2; 3644 enum tcpm_state new_state; 3645 3646 old_cc1 = port->cc1; 3647 old_cc2 = port->cc2; 3648 port->cc1 = cc1; 3649 port->cc2 = cc2; 3650 3651 tcpm_log_force(port, 3652 "CC1: %u -> %u, CC2: %u -> %u [state %s, polarity %d, %s]", 3653 old_cc1, cc1, old_cc2, cc2, tcpm_states[port->state], 3654 port->polarity, 3655 tcpm_port_is_disconnected(port) ? "disconnected" 3656 : "connected"); 3657 3658 switch (port->state) { 3659 case TOGGLING: 3660 if (tcpm_port_is_debug(port) || tcpm_port_is_audio(port) || 3661 tcpm_port_is_source(port)) 3662 tcpm_set_state(port, SRC_ATTACH_WAIT, 0); 3663 else if (tcpm_port_is_sink(port)) 3664 tcpm_set_state(port, SNK_ATTACH_WAIT, 0); 3665 break; 3666 case SRC_UNATTACHED: 3667 case ACC_UNATTACHED: 3668 if (tcpm_port_is_debug(port) || tcpm_port_is_audio(port) || 3669 tcpm_port_is_source(port)) 3670 tcpm_set_state(port, SRC_ATTACH_WAIT, 0); 3671 break; 3672 case SRC_ATTACH_WAIT: 3673 if (tcpm_port_is_disconnected(port) || 3674 tcpm_port_is_audio_detached(port)) 3675 tcpm_set_state(port, SRC_UNATTACHED, 0); 3676 else if (cc1 != old_cc1 || cc2 != old_cc2) 3677 tcpm_set_state(port, SRC_ATTACH_WAIT, 0); 3678 break; 3679 case SRC_ATTACHED: 3680 case SRC_SEND_CAPABILITIES: 3681 case SRC_READY: 3682 if (tcpm_port_is_disconnected(port) || 3683 !tcpm_port_is_source(port)) { 3684 if (port->port_type == TYPEC_PORT_SRC) 3685 tcpm_set_state(port, SRC_UNATTACHED, 0); 3686 else 3687 tcpm_set_state(port, SNK_UNATTACHED, 0); 3688 } 3689 break; 3690 case SNK_UNATTACHED: 3691 if (tcpm_port_is_sink(port)) 3692 tcpm_set_state(port, SNK_ATTACH_WAIT, 0); 3693 break; 3694 case SNK_ATTACH_WAIT: 3695 if ((port->cc1 == TYPEC_CC_OPEN && 3696 port->cc2 != TYPEC_CC_OPEN) || 3697 (port->cc1 != TYPEC_CC_OPEN && 3698 port->cc2 == TYPEC_CC_OPEN)) 3699 new_state = SNK_DEBOUNCED; 3700 else if (tcpm_port_is_disconnected(port)) 3701 new_state = SNK_UNATTACHED; 3702 else 3703 break; 3704 if (new_state != port->delayed_state) 3705 tcpm_set_state(port, SNK_ATTACH_WAIT, 0); 3706 break; 3707 case SNK_DEBOUNCED: 3708 if (tcpm_port_is_disconnected(port)) 3709 new_state = SNK_UNATTACHED; 3710 else if (port->vbus_present) 3711 new_state = tcpm_try_src(port) ? SRC_TRY : SNK_ATTACHED; 3712 else 3713 new_state = SNK_UNATTACHED; 3714 if (new_state != port->delayed_state) 3715 tcpm_set_state(port, SNK_DEBOUNCED, 0); 3716 break; 3717 case SNK_READY: 3718 if (tcpm_port_is_disconnected(port)) 3719 tcpm_set_state(port, unattached_state(port), 0); 3720 else if (!port->pd_capable && 3721 (cc1 != old_cc1 || cc2 != old_cc2)) 3722 tcpm_set_current_limit(port, 3723 tcpm_get_current_limit(port), 3724 5000); 3725 break; 3726 3727 case AUDIO_ACC_ATTACHED: 3728 if (cc1 == TYPEC_CC_OPEN || cc2 == TYPEC_CC_OPEN) 3729 tcpm_set_state(port, AUDIO_ACC_DEBOUNCE, 0); 3730 break; 3731 case AUDIO_ACC_DEBOUNCE: 3732 if (tcpm_port_is_audio(port)) 3733 tcpm_set_state(port, AUDIO_ACC_ATTACHED, 0); 3734 break; 3735 3736 case DEBUG_ACC_ATTACHED: 3737 if (cc1 == TYPEC_CC_OPEN || cc2 == TYPEC_CC_OPEN) 3738 tcpm_set_state(port, ACC_UNATTACHED, 0); 3739 break; 3740 3741 case SNK_TRY: 3742 /* Do nothing, waiting for timeout */ 3743 break; 3744 3745 case SNK_DISCOVERY: 3746 /* CC line is unstable, wait for debounce */ 3747 if (tcpm_port_is_disconnected(port)) 3748 tcpm_set_state(port, SNK_DISCOVERY_DEBOUNCE, 0); 3749 break; 3750 case SNK_DISCOVERY_DEBOUNCE: 3751 break; 3752 3753 case SRC_TRYWAIT: 3754 /* Hand over to state machine if needed */ 3755 if (!port->vbus_present && tcpm_port_is_source(port)) 3756 tcpm_set_state(port, SRC_TRYWAIT_DEBOUNCE, 0); 3757 break; 3758 case SRC_TRYWAIT_DEBOUNCE: 3759 if (port->vbus_present || !tcpm_port_is_source(port)) 3760 tcpm_set_state(port, SRC_TRYWAIT, 0); 3761 break; 3762 case SNK_TRY_WAIT_DEBOUNCE: 3763 if (!tcpm_port_is_sink(port)) { 3764 port->max_wait = 0; 3765 tcpm_set_state(port, SRC_TRYWAIT, 0); 3766 } 3767 break; 3768 case SRC_TRY_WAIT: 3769 if (tcpm_port_is_source(port)) 3770 tcpm_set_state(port, SRC_TRY_DEBOUNCE, 0); 3771 break; 3772 case SRC_TRY_DEBOUNCE: 3773 tcpm_set_state(port, SRC_TRY_WAIT, 0); 3774 break; 3775 case SNK_TRYWAIT_DEBOUNCE: 3776 if (tcpm_port_is_sink(port)) 3777 tcpm_set_state(port, SNK_TRYWAIT_VBUS, 0); 3778 break; 3779 case SNK_TRYWAIT_VBUS: 3780 if (!tcpm_port_is_sink(port)) 3781 tcpm_set_state(port, SNK_TRYWAIT_DEBOUNCE, 0); 3782 break; 3783 case SNK_TRYWAIT: 3784 /* Do nothing, waiting for tCCDebounce */ 3785 break; 3786 case PR_SWAP_SNK_SRC_SINK_OFF: 3787 case PR_SWAP_SRC_SNK_TRANSITION_OFF: 3788 case PR_SWAP_SRC_SNK_SOURCE_OFF: 3789 case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED: 3790 case PR_SWAP_SNK_SRC_SOURCE_ON: 3791 /* 3792 * CC state change is expected in PR_SWAP 3793 * Ignore it. 3794 */ 3795 break; 3796 3797 default: 3798 if (tcpm_port_is_disconnected(port)) 3799 tcpm_set_state(port, unattached_state(port), 0); 3800 break; 3801 } 3802 } 3803 3804 static void _tcpm_pd_vbus_on(struct tcpm_port *port) 3805 { 3806 tcpm_log_force(port, "VBUS on"); 3807 port->vbus_present = true; 3808 switch (port->state) { 3809 case SNK_TRANSITION_SINK_VBUS: 3810 port->explicit_contract = true; 3811 tcpm_set_state(port, SNK_READY, 0); 3812 break; 3813 case SNK_DISCOVERY: 3814 tcpm_set_state(port, SNK_DISCOVERY, 0); 3815 break; 3816 3817 case SNK_DEBOUNCED: 3818 tcpm_set_state(port, tcpm_try_src(port) ? SRC_TRY 3819 : SNK_ATTACHED, 3820 0); 3821 break; 3822 case SNK_HARD_RESET_WAIT_VBUS: 3823 tcpm_set_state(port, SNK_HARD_RESET_SINK_ON, 0); 3824 break; 3825 case SRC_ATTACHED: 3826 tcpm_set_state(port, SRC_STARTUP, 0); 3827 break; 3828 case SRC_HARD_RESET_VBUS_ON: 3829 tcpm_set_state(port, SRC_STARTUP, 0); 3830 break; 3831 3832 case SNK_TRY: 3833 /* Do nothing, waiting for timeout */ 3834 break; 3835 case SRC_TRYWAIT: 3836 /* Do nothing, Waiting for Rd to be detected */ 3837 break; 3838 case SRC_TRYWAIT_DEBOUNCE: 3839 tcpm_set_state(port, SRC_TRYWAIT, 0); 3840 break; 3841 case SNK_TRY_WAIT_DEBOUNCE: 3842 /* Do nothing, waiting for PD_DEBOUNCE to do be done */ 3843 break; 3844 case SNK_TRYWAIT: 3845 /* Do nothing, waiting for tCCDebounce */ 3846 break; 3847 case SNK_TRYWAIT_VBUS: 3848 if (tcpm_port_is_sink(port)) 3849 tcpm_set_state(port, SNK_ATTACHED, 0); 3850 break; 3851 case SNK_TRYWAIT_DEBOUNCE: 3852 /* Do nothing, waiting for Rp */ 3853 break; 3854 case SRC_TRY_WAIT: 3855 case SRC_TRY_DEBOUNCE: 3856 /* Do nothing, waiting for sink detection */ 3857 break; 3858 default: 3859 break; 3860 } 3861 } 3862 3863 static void _tcpm_pd_vbus_off(struct tcpm_port *port) 3864 { 3865 tcpm_log_force(port, "VBUS off"); 3866 port->vbus_present = false; 3867 port->vbus_never_low = false; 3868 switch (port->state) { 3869 case SNK_HARD_RESET_SINK_OFF: 3870 tcpm_set_state(port, SNK_HARD_RESET_WAIT_VBUS, 0); 3871 break; 3872 case SRC_HARD_RESET_VBUS_OFF: 3873 tcpm_set_state(port, SRC_HARD_RESET_VBUS_ON, 0); 3874 break; 3875 case HARD_RESET_SEND: 3876 break; 3877 3878 case SNK_TRY: 3879 /* Do nothing, waiting for timeout */ 3880 break; 3881 case SRC_TRYWAIT: 3882 /* Hand over to state machine if needed */ 3883 if (tcpm_port_is_source(port)) 3884 tcpm_set_state(port, SRC_TRYWAIT_DEBOUNCE, 0); 3885 break; 3886 case SNK_TRY_WAIT_DEBOUNCE: 3887 /* Do nothing, waiting for PD_DEBOUNCE to do be done */ 3888 break; 3889 case SNK_TRYWAIT: 3890 case SNK_TRYWAIT_VBUS: 3891 case SNK_TRYWAIT_DEBOUNCE: 3892 break; 3893 case SNK_ATTACH_WAIT: 3894 tcpm_set_state(port, SNK_UNATTACHED, 0); 3895 break; 3896 3897 case SNK_NEGOTIATE_CAPABILITIES: 3898 break; 3899 3900 case PR_SWAP_SRC_SNK_TRANSITION_OFF: 3901 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF, 0); 3902 break; 3903 3904 case PR_SWAP_SNK_SRC_SINK_OFF: 3905 /* Do nothing, expected */ 3906 break; 3907 3908 case PORT_RESET_WAIT_OFF: 3909 tcpm_set_state(port, tcpm_default_state(port), 0); 3910 break; 3911 case SRC_TRY_WAIT: 3912 case SRC_TRY_DEBOUNCE: 3913 /* Do nothing, waiting for sink detection */ 3914 break; 3915 default: 3916 if (port->pwr_role == TYPEC_SINK && 3917 port->attached) 3918 tcpm_set_state(port, SNK_UNATTACHED, 0); 3919 break; 3920 } 3921 } 3922 3923 static void _tcpm_pd_hard_reset(struct tcpm_port *port) 3924 { 3925 tcpm_log_force(port, "Received hard reset"); 3926 /* 3927 * If we keep receiving hard reset requests, executing the hard reset 3928 * must have failed. Revert to error recovery if that happens. 3929 */ 3930 tcpm_set_state(port, 3931 port->hard_reset_count < PD_N_HARD_RESET_COUNT ? 3932 HARD_RESET_START : ERROR_RECOVERY, 3933 0); 3934 } 3935 3936 static void tcpm_pd_event_handler(struct work_struct *work) 3937 { 3938 struct tcpm_port *port = container_of(work, struct tcpm_port, 3939 event_work); 3940 u32 events; 3941 3942 mutex_lock(&port->lock); 3943 3944 spin_lock(&port->pd_event_lock); 3945 while (port->pd_events) { 3946 events = port->pd_events; 3947 port->pd_events = 0; 3948 spin_unlock(&port->pd_event_lock); 3949 if (events & TCPM_RESET_EVENT) 3950 _tcpm_pd_hard_reset(port); 3951 if (events & TCPM_VBUS_EVENT) { 3952 bool vbus; 3953 3954 vbus = port->tcpc->get_vbus(port->tcpc); 3955 if (vbus) 3956 _tcpm_pd_vbus_on(port); 3957 else 3958 _tcpm_pd_vbus_off(port); 3959 } 3960 if (events & TCPM_CC_EVENT) { 3961 enum typec_cc_status cc1, cc2; 3962 3963 if (port->tcpc->get_cc(port->tcpc, &cc1, &cc2) == 0) 3964 _tcpm_cc_change(port, cc1, cc2); 3965 } 3966 spin_lock(&port->pd_event_lock); 3967 } 3968 spin_unlock(&port->pd_event_lock); 3969 mutex_unlock(&port->lock); 3970 } 3971 3972 void tcpm_cc_change(struct tcpm_port *port) 3973 { 3974 spin_lock(&port->pd_event_lock); 3975 port->pd_events |= TCPM_CC_EVENT; 3976 spin_unlock(&port->pd_event_lock); 3977 queue_work(port->wq, &port->event_work); 3978 } 3979 EXPORT_SYMBOL_GPL(tcpm_cc_change); 3980 3981 void tcpm_vbus_change(struct tcpm_port *port) 3982 { 3983 spin_lock(&port->pd_event_lock); 3984 port->pd_events |= TCPM_VBUS_EVENT; 3985 spin_unlock(&port->pd_event_lock); 3986 queue_work(port->wq, &port->event_work); 3987 } 3988 EXPORT_SYMBOL_GPL(tcpm_vbus_change); 3989 3990 void tcpm_pd_hard_reset(struct tcpm_port *port) 3991 { 3992 spin_lock(&port->pd_event_lock); 3993 port->pd_events = TCPM_RESET_EVENT; 3994 spin_unlock(&port->pd_event_lock); 3995 queue_work(port->wq, &port->event_work); 3996 } 3997 EXPORT_SYMBOL_GPL(tcpm_pd_hard_reset); 3998 3999 static int tcpm_dr_set(struct typec_port *p, enum typec_data_role data) 4000 { 4001 struct tcpm_port *port = typec_get_drvdata(p); 4002 int ret; 4003 4004 mutex_lock(&port->swap_lock); 4005 mutex_lock(&port->lock); 4006 4007 if (port->typec_caps.data != TYPEC_PORT_DRD) { 4008 ret = -EINVAL; 4009 goto port_unlock; 4010 } 4011 if (port->state != SRC_READY && port->state != SNK_READY) { 4012 ret = -EAGAIN; 4013 goto port_unlock; 4014 } 4015 4016 if (port->data_role == data) { 4017 ret = 0; 4018 goto port_unlock; 4019 } 4020 4021 /* 4022 * XXX 4023 * 6.3.9: If an alternate mode is active, a request to swap 4024 * alternate modes shall trigger a port reset. 4025 * Reject data role swap request in this case. 4026 */ 4027 4028 if (!port->pd_capable) { 4029 /* 4030 * If the partner is not PD capable, reset the port to 4031 * trigger a role change. This can only work if a preferred 4032 * role is configured, and if it matches the requested role. 4033 */ 4034 if (port->try_role == TYPEC_NO_PREFERRED_ROLE || 4035 port->try_role == port->pwr_role) { 4036 ret = -EINVAL; 4037 goto port_unlock; 4038 } 4039 port->non_pd_role_swap = true; 4040 tcpm_set_state(port, PORT_RESET, 0); 4041 } else { 4042 tcpm_set_state(port, DR_SWAP_SEND, 0); 4043 } 4044 4045 port->swap_status = 0; 4046 port->swap_pending = true; 4047 reinit_completion(&port->swap_complete); 4048 mutex_unlock(&port->lock); 4049 4050 if (!wait_for_completion_timeout(&port->swap_complete, 4051 msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT))) 4052 ret = -ETIMEDOUT; 4053 else 4054 ret = port->swap_status; 4055 4056 port->non_pd_role_swap = false; 4057 goto swap_unlock; 4058 4059 port_unlock: 4060 mutex_unlock(&port->lock); 4061 swap_unlock: 4062 mutex_unlock(&port->swap_lock); 4063 return ret; 4064 } 4065 4066 static int tcpm_pr_set(struct typec_port *p, enum typec_role role) 4067 { 4068 struct tcpm_port *port = typec_get_drvdata(p); 4069 int ret; 4070 4071 mutex_lock(&port->swap_lock); 4072 mutex_lock(&port->lock); 4073 4074 if (port->port_type != TYPEC_PORT_DRP) { 4075 ret = -EINVAL; 4076 goto port_unlock; 4077 } 4078 if (port->state != SRC_READY && port->state != SNK_READY) { 4079 ret = -EAGAIN; 4080 goto port_unlock; 4081 } 4082 4083 if (role == port->pwr_role) { 4084 ret = 0; 4085 goto port_unlock; 4086 } 4087 4088 port->swap_status = 0; 4089 port->swap_pending = true; 4090 reinit_completion(&port->swap_complete); 4091 tcpm_set_state(port, PR_SWAP_SEND, 0); 4092 mutex_unlock(&port->lock); 4093 4094 if (!wait_for_completion_timeout(&port->swap_complete, 4095 msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT))) 4096 ret = -ETIMEDOUT; 4097 else 4098 ret = port->swap_status; 4099 4100 goto swap_unlock; 4101 4102 port_unlock: 4103 mutex_unlock(&port->lock); 4104 swap_unlock: 4105 mutex_unlock(&port->swap_lock); 4106 return ret; 4107 } 4108 4109 static int tcpm_vconn_set(struct typec_port *p, enum typec_role role) 4110 { 4111 struct tcpm_port *port = typec_get_drvdata(p); 4112 int ret; 4113 4114 mutex_lock(&port->swap_lock); 4115 mutex_lock(&port->lock); 4116 4117 if (port->state != SRC_READY && port->state != SNK_READY) { 4118 ret = -EAGAIN; 4119 goto port_unlock; 4120 } 4121 4122 if (role == port->vconn_role) { 4123 ret = 0; 4124 goto port_unlock; 4125 } 4126 4127 port->swap_status = 0; 4128 port->swap_pending = true; 4129 reinit_completion(&port->swap_complete); 4130 tcpm_set_state(port, VCONN_SWAP_SEND, 0); 4131 mutex_unlock(&port->lock); 4132 4133 if (!wait_for_completion_timeout(&port->swap_complete, 4134 msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT))) 4135 ret = -ETIMEDOUT; 4136 else 4137 ret = port->swap_status; 4138 4139 goto swap_unlock; 4140 4141 port_unlock: 4142 mutex_unlock(&port->lock); 4143 swap_unlock: 4144 mutex_unlock(&port->swap_lock); 4145 return ret; 4146 } 4147 4148 static int tcpm_try_role(struct typec_port *p, int role) 4149 { 4150 struct tcpm_port *port = typec_get_drvdata(p); 4151 struct tcpc_dev *tcpc = port->tcpc; 4152 int ret = 0; 4153 4154 mutex_lock(&port->lock); 4155 if (tcpc->try_role) 4156 ret = tcpc->try_role(tcpc, role); 4157 if (!ret) 4158 port->try_role = role; 4159 port->try_src_count = 0; 4160 port->try_snk_count = 0; 4161 mutex_unlock(&port->lock); 4162 4163 return ret; 4164 } 4165 4166 static int tcpm_pps_set_op_curr(struct tcpm_port *port, u16 op_curr) 4167 { 4168 unsigned int target_mw; 4169 int ret; 4170 4171 mutex_lock(&port->swap_lock); 4172 mutex_lock(&port->lock); 4173 4174 if (!port->pps_data.active) { 4175 ret = -EOPNOTSUPP; 4176 goto port_unlock; 4177 } 4178 4179 if (port->state != SNK_READY) { 4180 ret = -EAGAIN; 4181 goto port_unlock; 4182 } 4183 4184 if (op_curr > port->pps_data.max_curr) { 4185 ret = -EINVAL; 4186 goto port_unlock; 4187 } 4188 4189 target_mw = (op_curr * port->pps_data.out_volt) / 1000; 4190 if (target_mw < port->operating_snk_mw) { 4191 ret = -EINVAL; 4192 goto port_unlock; 4193 } 4194 4195 /* Round down operating current to align with PPS valid steps */ 4196 op_curr = op_curr - (op_curr % RDO_PROG_CURR_MA_STEP); 4197 4198 reinit_completion(&port->pps_complete); 4199 port->pps_data.op_curr = op_curr; 4200 port->pps_status = 0; 4201 port->pps_pending = true; 4202 tcpm_set_state(port, SNK_NEGOTIATE_PPS_CAPABILITIES, 0); 4203 mutex_unlock(&port->lock); 4204 4205 if (!wait_for_completion_timeout(&port->pps_complete, 4206 msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT))) 4207 ret = -ETIMEDOUT; 4208 else 4209 ret = port->pps_status; 4210 4211 goto swap_unlock; 4212 4213 port_unlock: 4214 mutex_unlock(&port->lock); 4215 swap_unlock: 4216 mutex_unlock(&port->swap_lock); 4217 4218 return ret; 4219 } 4220 4221 static int tcpm_pps_set_out_volt(struct tcpm_port *port, u16 out_volt) 4222 { 4223 unsigned int target_mw; 4224 int ret; 4225 4226 mutex_lock(&port->swap_lock); 4227 mutex_lock(&port->lock); 4228 4229 if (!port->pps_data.active) { 4230 ret = -EOPNOTSUPP; 4231 goto port_unlock; 4232 } 4233 4234 if (port->state != SNK_READY) { 4235 ret = -EAGAIN; 4236 goto port_unlock; 4237 } 4238 4239 if (out_volt < port->pps_data.min_volt || 4240 out_volt > port->pps_data.max_volt) { 4241 ret = -EINVAL; 4242 goto port_unlock; 4243 } 4244 4245 target_mw = (port->pps_data.op_curr * out_volt) / 1000; 4246 if (target_mw < port->operating_snk_mw) { 4247 ret = -EINVAL; 4248 goto port_unlock; 4249 } 4250 4251 /* Round down output voltage to align with PPS valid steps */ 4252 out_volt = out_volt - (out_volt % RDO_PROG_VOLT_MV_STEP); 4253 4254 reinit_completion(&port->pps_complete); 4255 port->pps_data.out_volt = out_volt; 4256 port->pps_status = 0; 4257 port->pps_pending = true; 4258 tcpm_set_state(port, SNK_NEGOTIATE_PPS_CAPABILITIES, 0); 4259 mutex_unlock(&port->lock); 4260 4261 if (!wait_for_completion_timeout(&port->pps_complete, 4262 msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT))) 4263 ret = -ETIMEDOUT; 4264 else 4265 ret = port->pps_status; 4266 4267 goto swap_unlock; 4268 4269 port_unlock: 4270 mutex_unlock(&port->lock); 4271 swap_unlock: 4272 mutex_unlock(&port->swap_lock); 4273 4274 return ret; 4275 } 4276 4277 static int tcpm_pps_activate(struct tcpm_port *port, bool activate) 4278 { 4279 int ret = 0; 4280 4281 mutex_lock(&port->swap_lock); 4282 mutex_lock(&port->lock); 4283 4284 if (!port->pps_data.supported) { 4285 ret = -EOPNOTSUPP; 4286 goto port_unlock; 4287 } 4288 4289 /* Trying to deactivate PPS when already deactivated so just bail */ 4290 if (!port->pps_data.active && !activate) 4291 goto port_unlock; 4292 4293 if (port->state != SNK_READY) { 4294 ret = -EAGAIN; 4295 goto port_unlock; 4296 } 4297 4298 reinit_completion(&port->pps_complete); 4299 port->pps_status = 0; 4300 port->pps_pending = true; 4301 4302 /* Trigger PPS request or move back to standard PDO contract */ 4303 if (activate) { 4304 port->pps_data.out_volt = port->supply_voltage; 4305 port->pps_data.op_curr = port->current_limit; 4306 tcpm_set_state(port, SNK_NEGOTIATE_PPS_CAPABILITIES, 0); 4307 } else { 4308 tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0); 4309 } 4310 mutex_unlock(&port->lock); 4311 4312 if (!wait_for_completion_timeout(&port->pps_complete, 4313 msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT))) 4314 ret = -ETIMEDOUT; 4315 else 4316 ret = port->pps_status; 4317 4318 goto swap_unlock; 4319 4320 port_unlock: 4321 mutex_unlock(&port->lock); 4322 swap_unlock: 4323 mutex_unlock(&port->swap_lock); 4324 4325 return ret; 4326 } 4327 4328 static void tcpm_init(struct tcpm_port *port) 4329 { 4330 enum typec_cc_status cc1, cc2; 4331 4332 port->tcpc->init(port->tcpc); 4333 4334 tcpm_reset_port(port); 4335 4336 /* 4337 * XXX 4338 * Should possibly wait for VBUS to settle if it was enabled locally 4339 * since tcpm_reset_port() will disable VBUS. 4340 */ 4341 port->vbus_present = port->tcpc->get_vbus(port->tcpc); 4342 if (port->vbus_present) 4343 port->vbus_never_low = true; 4344 4345 tcpm_set_state(port, tcpm_default_state(port), 0); 4346 4347 if (port->tcpc->get_cc(port->tcpc, &cc1, &cc2) == 0) 4348 _tcpm_cc_change(port, cc1, cc2); 4349 4350 /* 4351 * Some adapters need a clean slate at startup, and won't recover 4352 * otherwise. So do not try to be fancy and force a clean disconnect. 4353 */ 4354 tcpm_set_state(port, PORT_RESET, 0); 4355 } 4356 4357 static int tcpm_port_type_set(struct typec_port *p, enum typec_port_type type) 4358 { 4359 struct tcpm_port *port = typec_get_drvdata(p); 4360 4361 mutex_lock(&port->lock); 4362 if (type == port->port_type) 4363 goto port_unlock; 4364 4365 port->port_type = type; 4366 4367 if (!port->connected) { 4368 tcpm_set_state(port, PORT_RESET, 0); 4369 } else if (type == TYPEC_PORT_SNK) { 4370 if (!(port->pwr_role == TYPEC_SINK && 4371 port->data_role == TYPEC_DEVICE)) 4372 tcpm_set_state(port, PORT_RESET, 0); 4373 } else if (type == TYPEC_PORT_SRC) { 4374 if (!(port->pwr_role == TYPEC_SOURCE && 4375 port->data_role == TYPEC_HOST)) 4376 tcpm_set_state(port, PORT_RESET, 0); 4377 } 4378 4379 port_unlock: 4380 mutex_unlock(&port->lock); 4381 return 0; 4382 } 4383 4384 static const struct typec_operations tcpm_ops = { 4385 .try_role = tcpm_try_role, 4386 .dr_set = tcpm_dr_set, 4387 .pr_set = tcpm_pr_set, 4388 .vconn_set = tcpm_vconn_set, 4389 .port_type_set = tcpm_port_type_set 4390 }; 4391 4392 void tcpm_tcpc_reset(struct tcpm_port *port) 4393 { 4394 mutex_lock(&port->lock); 4395 /* XXX: Maintain PD connection if possible? */ 4396 tcpm_init(port); 4397 mutex_unlock(&port->lock); 4398 } 4399 EXPORT_SYMBOL_GPL(tcpm_tcpc_reset); 4400 4401 static int tcpm_fw_get_caps(struct tcpm_port *port, 4402 struct fwnode_handle *fwnode) 4403 { 4404 const char *cap_str; 4405 int ret; 4406 u32 mw; 4407 4408 if (!fwnode) 4409 return -EINVAL; 4410 4411 /* USB data support is optional */ 4412 ret = fwnode_property_read_string(fwnode, "data-role", &cap_str); 4413 if (ret == 0) { 4414 ret = typec_find_port_data_role(cap_str); 4415 if (ret < 0) 4416 return ret; 4417 port->typec_caps.data = ret; 4418 } 4419 4420 ret = fwnode_property_read_string(fwnode, "power-role", &cap_str); 4421 if (ret < 0) 4422 return ret; 4423 4424 ret = typec_find_port_power_role(cap_str); 4425 if (ret < 0) 4426 return ret; 4427 port->typec_caps.type = ret; 4428 port->port_type = port->typec_caps.type; 4429 4430 if (port->port_type == TYPEC_PORT_SNK) 4431 goto sink; 4432 4433 /* Get source pdos */ 4434 ret = fwnode_property_count_u32(fwnode, "source-pdos"); 4435 if (ret <= 0) 4436 return -EINVAL; 4437 4438 port->nr_src_pdo = min(ret, PDO_MAX_OBJECTS); 4439 ret = fwnode_property_read_u32_array(fwnode, "source-pdos", 4440 port->src_pdo, port->nr_src_pdo); 4441 if ((ret < 0) || tcpm_validate_caps(port, port->src_pdo, 4442 port->nr_src_pdo)) 4443 return -EINVAL; 4444 4445 if (port->port_type == TYPEC_PORT_SRC) 4446 return 0; 4447 4448 /* Get the preferred power role for DRP */ 4449 ret = fwnode_property_read_string(fwnode, "try-power-role", &cap_str); 4450 if (ret < 0) 4451 return ret; 4452 4453 port->typec_caps.prefer_role = typec_find_power_role(cap_str); 4454 if (port->typec_caps.prefer_role < 0) 4455 return -EINVAL; 4456 sink: 4457 /* Get sink pdos */ 4458 ret = fwnode_property_count_u32(fwnode, "sink-pdos"); 4459 if (ret <= 0) 4460 return -EINVAL; 4461 4462 port->nr_snk_pdo = min(ret, PDO_MAX_OBJECTS); 4463 ret = fwnode_property_read_u32_array(fwnode, "sink-pdos", 4464 port->snk_pdo, port->nr_snk_pdo); 4465 if ((ret < 0) || tcpm_validate_caps(port, port->snk_pdo, 4466 port->nr_snk_pdo)) 4467 return -EINVAL; 4468 4469 if (fwnode_property_read_u32(fwnode, "op-sink-microwatt", &mw) < 0) 4470 return -EINVAL; 4471 port->operating_snk_mw = mw / 1000; 4472 4473 port->self_powered = fwnode_property_read_bool(fwnode, "self-powered"); 4474 4475 return 0; 4476 } 4477 4478 /* Power Supply access to expose source power information */ 4479 enum tcpm_psy_online_states { 4480 TCPM_PSY_OFFLINE = 0, 4481 TCPM_PSY_FIXED_ONLINE, 4482 TCPM_PSY_PROG_ONLINE, 4483 }; 4484 4485 static enum power_supply_property tcpm_psy_props[] = { 4486 POWER_SUPPLY_PROP_USB_TYPE, 4487 POWER_SUPPLY_PROP_ONLINE, 4488 POWER_SUPPLY_PROP_VOLTAGE_MIN, 4489 POWER_SUPPLY_PROP_VOLTAGE_MAX, 4490 POWER_SUPPLY_PROP_VOLTAGE_NOW, 4491 POWER_SUPPLY_PROP_CURRENT_MAX, 4492 POWER_SUPPLY_PROP_CURRENT_NOW, 4493 }; 4494 4495 static int tcpm_psy_get_online(struct tcpm_port *port, 4496 union power_supply_propval *val) 4497 { 4498 if (port->vbus_charge) { 4499 if (port->pps_data.active) 4500 val->intval = TCPM_PSY_PROG_ONLINE; 4501 else 4502 val->intval = TCPM_PSY_FIXED_ONLINE; 4503 } else { 4504 val->intval = TCPM_PSY_OFFLINE; 4505 } 4506 4507 return 0; 4508 } 4509 4510 static int tcpm_psy_get_voltage_min(struct tcpm_port *port, 4511 union power_supply_propval *val) 4512 { 4513 if (port->pps_data.active) 4514 val->intval = port->pps_data.min_volt * 1000; 4515 else 4516 val->intval = port->supply_voltage * 1000; 4517 4518 return 0; 4519 } 4520 4521 static int tcpm_psy_get_voltage_max(struct tcpm_port *port, 4522 union power_supply_propval *val) 4523 { 4524 if (port->pps_data.active) 4525 val->intval = port->pps_data.max_volt * 1000; 4526 else 4527 val->intval = port->supply_voltage * 1000; 4528 4529 return 0; 4530 } 4531 4532 static int tcpm_psy_get_voltage_now(struct tcpm_port *port, 4533 union power_supply_propval *val) 4534 { 4535 val->intval = port->supply_voltage * 1000; 4536 4537 return 0; 4538 } 4539 4540 static int tcpm_psy_get_current_max(struct tcpm_port *port, 4541 union power_supply_propval *val) 4542 { 4543 if (port->pps_data.active) 4544 val->intval = port->pps_data.max_curr * 1000; 4545 else 4546 val->intval = port->current_limit * 1000; 4547 4548 return 0; 4549 } 4550 4551 static int tcpm_psy_get_current_now(struct tcpm_port *port, 4552 union power_supply_propval *val) 4553 { 4554 val->intval = port->current_limit * 1000; 4555 4556 return 0; 4557 } 4558 4559 static int tcpm_psy_get_prop(struct power_supply *psy, 4560 enum power_supply_property psp, 4561 union power_supply_propval *val) 4562 { 4563 struct tcpm_port *port = power_supply_get_drvdata(psy); 4564 int ret = 0; 4565 4566 switch (psp) { 4567 case POWER_SUPPLY_PROP_USB_TYPE: 4568 val->intval = port->usb_type; 4569 break; 4570 case POWER_SUPPLY_PROP_ONLINE: 4571 ret = tcpm_psy_get_online(port, val); 4572 break; 4573 case POWER_SUPPLY_PROP_VOLTAGE_MIN: 4574 ret = tcpm_psy_get_voltage_min(port, val); 4575 break; 4576 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 4577 ret = tcpm_psy_get_voltage_max(port, val); 4578 break; 4579 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 4580 ret = tcpm_psy_get_voltage_now(port, val); 4581 break; 4582 case POWER_SUPPLY_PROP_CURRENT_MAX: 4583 ret = tcpm_psy_get_current_max(port, val); 4584 break; 4585 case POWER_SUPPLY_PROP_CURRENT_NOW: 4586 ret = tcpm_psy_get_current_now(port, val); 4587 break; 4588 default: 4589 ret = -EINVAL; 4590 break; 4591 } 4592 4593 return ret; 4594 } 4595 4596 static int tcpm_psy_set_online(struct tcpm_port *port, 4597 const union power_supply_propval *val) 4598 { 4599 int ret; 4600 4601 switch (val->intval) { 4602 case TCPM_PSY_FIXED_ONLINE: 4603 ret = tcpm_pps_activate(port, false); 4604 break; 4605 case TCPM_PSY_PROG_ONLINE: 4606 ret = tcpm_pps_activate(port, true); 4607 break; 4608 default: 4609 ret = -EINVAL; 4610 break; 4611 } 4612 4613 return ret; 4614 } 4615 4616 static int tcpm_psy_set_prop(struct power_supply *psy, 4617 enum power_supply_property psp, 4618 const union power_supply_propval *val) 4619 { 4620 struct tcpm_port *port = power_supply_get_drvdata(psy); 4621 int ret; 4622 4623 switch (psp) { 4624 case POWER_SUPPLY_PROP_ONLINE: 4625 ret = tcpm_psy_set_online(port, val); 4626 break; 4627 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 4628 if (val->intval < port->pps_data.min_volt * 1000 || 4629 val->intval > port->pps_data.max_volt * 1000) 4630 ret = -EINVAL; 4631 else 4632 ret = tcpm_pps_set_out_volt(port, val->intval / 1000); 4633 break; 4634 case POWER_SUPPLY_PROP_CURRENT_NOW: 4635 if (val->intval > port->pps_data.max_curr * 1000) 4636 ret = -EINVAL; 4637 else 4638 ret = tcpm_pps_set_op_curr(port, val->intval / 1000); 4639 break; 4640 default: 4641 ret = -EINVAL; 4642 break; 4643 } 4644 4645 return ret; 4646 } 4647 4648 static int tcpm_psy_prop_writeable(struct power_supply *psy, 4649 enum power_supply_property psp) 4650 { 4651 switch (psp) { 4652 case POWER_SUPPLY_PROP_ONLINE: 4653 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 4654 case POWER_SUPPLY_PROP_CURRENT_NOW: 4655 return 1; 4656 default: 4657 return 0; 4658 } 4659 } 4660 4661 static enum power_supply_usb_type tcpm_psy_usb_types[] = { 4662 POWER_SUPPLY_USB_TYPE_C, 4663 POWER_SUPPLY_USB_TYPE_PD, 4664 POWER_SUPPLY_USB_TYPE_PD_PPS, 4665 }; 4666 4667 static const char *tcpm_psy_name_prefix = "tcpm-source-psy-"; 4668 4669 static int devm_tcpm_psy_register(struct tcpm_port *port) 4670 { 4671 struct power_supply_config psy_cfg = {}; 4672 const char *port_dev_name = dev_name(port->dev); 4673 size_t psy_name_len = strlen(tcpm_psy_name_prefix) + 4674 strlen(port_dev_name) + 1; 4675 char *psy_name; 4676 4677 psy_cfg.drv_data = port; 4678 psy_cfg.fwnode = dev_fwnode(port->dev); 4679 psy_name = devm_kzalloc(port->dev, psy_name_len, GFP_KERNEL); 4680 if (!psy_name) 4681 return -ENOMEM; 4682 4683 snprintf(psy_name, psy_name_len, "%s%s", tcpm_psy_name_prefix, 4684 port_dev_name); 4685 port->psy_desc.name = psy_name; 4686 port->psy_desc.type = POWER_SUPPLY_TYPE_USB, 4687 port->psy_desc.usb_types = tcpm_psy_usb_types; 4688 port->psy_desc.num_usb_types = ARRAY_SIZE(tcpm_psy_usb_types); 4689 port->psy_desc.properties = tcpm_psy_props, 4690 port->psy_desc.num_properties = ARRAY_SIZE(tcpm_psy_props), 4691 port->psy_desc.get_property = tcpm_psy_get_prop, 4692 port->psy_desc.set_property = tcpm_psy_set_prop, 4693 port->psy_desc.property_is_writeable = tcpm_psy_prop_writeable, 4694 4695 port->usb_type = POWER_SUPPLY_USB_TYPE_C; 4696 4697 port->psy = devm_power_supply_register(port->dev, &port->psy_desc, 4698 &psy_cfg); 4699 4700 return PTR_ERR_OR_ZERO(port->psy); 4701 } 4702 4703 struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) 4704 { 4705 struct tcpm_port *port; 4706 int err; 4707 4708 if (!dev || !tcpc || 4709 !tcpc->get_vbus || !tcpc->set_cc || !tcpc->get_cc || 4710 !tcpc->set_polarity || !tcpc->set_vconn || !tcpc->set_vbus || 4711 !tcpc->set_pd_rx || !tcpc->set_roles || !tcpc->pd_transmit) 4712 return ERR_PTR(-EINVAL); 4713 4714 port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL); 4715 if (!port) 4716 return ERR_PTR(-ENOMEM); 4717 4718 port->dev = dev; 4719 port->tcpc = tcpc; 4720 4721 mutex_init(&port->lock); 4722 mutex_init(&port->swap_lock); 4723 4724 port->wq = create_singlethread_workqueue(dev_name(dev)); 4725 if (!port->wq) 4726 return ERR_PTR(-ENOMEM); 4727 INIT_DELAYED_WORK(&port->state_machine, tcpm_state_machine_work); 4728 INIT_DELAYED_WORK(&port->vdm_state_machine, vdm_state_machine_work); 4729 INIT_WORK(&port->event_work, tcpm_pd_event_handler); 4730 4731 spin_lock_init(&port->pd_event_lock); 4732 4733 init_completion(&port->tx_complete); 4734 init_completion(&port->swap_complete); 4735 init_completion(&port->pps_complete); 4736 tcpm_debugfs_init(port); 4737 4738 err = tcpm_fw_get_caps(port, tcpc->fwnode); 4739 if (err < 0) 4740 goto out_destroy_wq; 4741 4742 port->try_role = port->typec_caps.prefer_role; 4743 4744 port->typec_caps.fwnode = tcpc->fwnode; 4745 port->typec_caps.revision = 0x0120; /* Type-C spec release 1.2 */ 4746 port->typec_caps.pd_revision = 0x0300; /* USB-PD spec release 3.0 */ 4747 port->typec_caps.driver_data = port; 4748 port->typec_caps.ops = &tcpm_ops; 4749 port->typec_caps.orientation_aware = 1; 4750 4751 port->partner_desc.identity = &port->partner_ident; 4752 port->port_type = port->typec_caps.type; 4753 4754 port->role_sw = usb_role_switch_get(port->dev); 4755 if (IS_ERR(port->role_sw)) { 4756 err = PTR_ERR(port->role_sw); 4757 goto out_destroy_wq; 4758 } 4759 4760 err = devm_tcpm_psy_register(port); 4761 if (err) 4762 goto out_role_sw_put; 4763 4764 port->typec_port = typec_register_port(port->dev, &port->typec_caps); 4765 if (IS_ERR(port->typec_port)) { 4766 err = PTR_ERR(port->typec_port); 4767 goto out_role_sw_put; 4768 } 4769 4770 mutex_lock(&port->lock); 4771 tcpm_init(port); 4772 mutex_unlock(&port->lock); 4773 4774 tcpm_log(port, "%s: registered", dev_name(dev)); 4775 return port; 4776 4777 out_role_sw_put: 4778 usb_role_switch_put(port->role_sw); 4779 out_destroy_wq: 4780 tcpm_debugfs_exit(port); 4781 destroy_workqueue(port->wq); 4782 return ERR_PTR(err); 4783 } 4784 EXPORT_SYMBOL_GPL(tcpm_register_port); 4785 4786 void tcpm_unregister_port(struct tcpm_port *port) 4787 { 4788 int i; 4789 4790 tcpm_reset_port(port); 4791 for (i = 0; i < ARRAY_SIZE(port->port_altmode); i++) 4792 typec_unregister_altmode(port->port_altmode[i]); 4793 typec_unregister_port(port->typec_port); 4794 usb_role_switch_put(port->role_sw); 4795 tcpm_debugfs_exit(port); 4796 destroy_workqueue(port->wq); 4797 } 4798 EXPORT_SYMBOL_GPL(tcpm_unregister_port); 4799 4800 MODULE_AUTHOR("Guenter Roeck <groeck@chromium.org>"); 4801 MODULE_DESCRIPTION("USB Type-C Port Manager"); 4802 MODULE_LICENSE("GPL"); 4803