drivers/usb/typec/tcpm/tcpm.c

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