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