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