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