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