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