drivers/usb/typec/tcpm/tcpm.c

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