drivers/usb/typec/tcpm/tcpm.c

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