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/string_choices.h>
  25 #include <linux/usb.h>
  26 #include <linux/usb/pd.h>
  27 #include <linux/usb/pd_ado.h>
  28 #include <linux/usb/pd_bdo.h>
  29 #include <linux/usb/pd_ext_sdb.h>
  30 #include <linux/usb/pd_vdo.h>
  31 #include <linux/usb/role.h>
  32 #include <linux/usb/tcpm.h>
  33 #include <linux/usb/typec_altmode.h>
  34
  35 #include <uapi/linux/sched/types.h>
  36
  37 #define FOREACH_STATE(S)                        \
  38         S(INVALID_STATE),                       \
  39         S(TOGGLING),                    \
  40         S(CHECK_CONTAMINANT),                   \
  41         S(SRC_UNATTACHED),                      \
  42         S(SRC_ATTACH_WAIT),                     \
  43         S(SRC_ATTACHED),                        \
  44         S(SRC_STARTUP),                         \
  45         S(SRC_SEND_CAPABILITIES),               \
  46         S(SRC_SEND_CAPABILITIES_TIMEOUT),       \
  47         S(SRC_NEGOTIATE_CAPABILITIES),          \
  48         S(SRC_TRANSITION_SUPPLY),               \
  49         S(SRC_READY),                           \
  50         S(SRC_WAIT_NEW_CAPABILITIES),           \
  51                                                 \
  52         S(SNK_UNATTACHED),                      \
  53         S(SNK_ATTACH_WAIT),                     \
  54         S(SNK_DEBOUNCED),                       \
  55         S(SNK_ATTACHED),                        \
  56         S(SNK_STARTUP),                         \
  57         S(SNK_DISCOVERY),                       \
  58         S(SNK_DISCOVERY_DEBOUNCE),              \
  59         S(SNK_DISCOVERY_DEBOUNCE_DONE),         \
  60         S(SNK_WAIT_CAPABILITIES),               \
  61         S(SNK_WAIT_CAPABILITIES_TIMEOUT),       \
  62         S(SNK_NEGOTIATE_CAPABILITIES),          \
  63         S(SNK_NEGOTIATE_PPS_CAPABILITIES),      \
  64         S(SNK_TRANSITION_SINK),                 \
  65         S(SNK_TRANSITION_SINK_VBUS),            \
  66         S(SNK_READY),                           \
  67                                                 \
  68         S(ACC_UNATTACHED),                      \
  69         S(DEBUG_ACC_ATTACHED),                  \
  70         S(AUDIO_ACC_ATTACHED),                  \
  71         S(AUDIO_ACC_DEBOUNCE),                  \
  72                                                 \
  73         S(HARD_RESET_SEND),                     \
  74         S(HARD_RESET_START),                    \
  75         S(SRC_HARD_RESET_VBUS_OFF),             \
  76         S(SRC_HARD_RESET_VBUS_ON),              \
  77         S(SNK_HARD_RESET_SINK_OFF),             \
  78         S(SNK_HARD_RESET_WAIT_VBUS),            \
  79         S(SNK_HARD_RESET_SINK_ON),              \
  80                                                 \
  81         S(SOFT_RESET),                          \
  82         S(SRC_SOFT_RESET_WAIT_SNK_TX),          \
  83         S(SNK_SOFT_RESET),                      \
  84         S(SOFT_RESET_SEND),                     \
  85                                                 \
  86         S(DR_SWAP_ACCEPT),                      \
  87         S(DR_SWAP_SEND),                        \
  88         S(DR_SWAP_SEND_TIMEOUT),                \
  89         S(DR_SWAP_CANCEL),                      \
  90         S(DR_SWAP_CHANGE_DR),                   \
  91                                                 \
  92         S(PR_SWAP_ACCEPT),                      \
  93         S(PR_SWAP_SEND),                        \
  94         S(PR_SWAP_SEND_TIMEOUT),                \
  95         S(PR_SWAP_CANCEL),                      \
  96         S(PR_SWAP_START),                       \
  97         S(PR_SWAP_SRC_SNK_TRANSITION_OFF),      \
  98         S(PR_SWAP_SRC_SNK_SOURCE_OFF),          \
  99         S(PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED), \
 100         S(PR_SWAP_SRC_SNK_SINK_ON),             \
 101         S(PR_SWAP_SNK_SRC_SINK_OFF),            \
 102         S(PR_SWAP_SNK_SRC_SOURCE_ON),           \
 103         S(PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP),    \
 104                                                 \
 105         S(VCONN_SWAP_ACCEPT),                   \
 106         S(VCONN_SWAP_SEND),                     \
 107         S(VCONN_SWAP_SEND_TIMEOUT),             \
 108         S(VCONN_SWAP_CANCEL),                   \
 109         S(VCONN_SWAP_START),                    \
 110         S(VCONN_SWAP_WAIT_FOR_VCONN),           \
 111         S(VCONN_SWAP_TURN_ON_VCONN),            \
 112         S(VCONN_SWAP_TURN_OFF_VCONN),           \
 113         S(VCONN_SWAP_SEND_SOFT_RESET),          \
 114                                                 \
 115         S(FR_SWAP_SEND),                        \
 116         S(FR_SWAP_SEND_TIMEOUT),                \
 117         S(FR_SWAP_SNK_SRC_TRANSITION_TO_OFF),                   \
 118         S(FR_SWAP_SNK_SRC_NEW_SINK_READY),              \
 119         S(FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED), \
 120         S(FR_SWAP_CANCEL),                      \
 121                                                 \
 122         S(SNK_TRY),                             \
 123         S(SNK_TRY_WAIT),                        \
 124         S(SNK_TRY_WAIT_DEBOUNCE),               \
 125         S(SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS),    \
 126         S(SRC_TRYWAIT),                         \
 127         S(SRC_TRYWAIT_DEBOUNCE),                \
 128         S(SRC_TRYWAIT_UNATTACHED),              \
 129                                                 \
 130         S(SRC_TRY),                             \
 131         S(SRC_TRY_WAIT),                        \
 132         S(SRC_TRY_DEBOUNCE),                    \
 133         S(SNK_TRYWAIT),                         \
 134         S(SNK_TRYWAIT_DEBOUNCE),                \
 135         S(SNK_TRYWAIT_VBUS),                    \
 136         S(BIST_RX),                             \
 137                                                 \
 138         S(GET_STATUS_SEND),                     \
 139         S(GET_STATUS_SEND_TIMEOUT),             \
 140         S(GET_PPS_STATUS_SEND),                 \
 141         S(GET_PPS_STATUS_SEND_TIMEOUT),         \
 142                                                 \
 143         S(GET_SINK_CAP),                        \
 144         S(GET_SINK_CAP_TIMEOUT),                \
 145                                                 \
 146         S(ERROR_RECOVERY),                      \
 147         S(PORT_RESET),                          \
 148         S(PORT_RESET_WAIT_OFF),                 \
 149                                                 \
 150         S(AMS_START),                           \
 151         S(CHUNK_NOT_SUPP),                      \
 152                                                 \
 153         S(SRC_VDM_IDENTITY_REQUEST)
 154
 155 #define FOREACH_AMS(S)                          \
 156         S(NONE_AMS),                            \
 157         S(POWER_NEGOTIATION),                   \
 158         S(GOTOMIN),                             \
 159         S(SOFT_RESET_AMS),                      \
 160         S(HARD_RESET),                          \
 161         S(CABLE_RESET),                         \
 162         S(GET_SOURCE_CAPABILITIES),             \
 163         S(GET_SINK_CAPABILITIES),               \
 164         S(POWER_ROLE_SWAP),                     \
 165         S(FAST_ROLE_SWAP),                      \
 166         S(DATA_ROLE_SWAP),                      \
 167         S(VCONN_SWAP),                          \
 168         S(SOURCE_ALERT),                        \
 169         S(GETTING_SOURCE_EXTENDED_CAPABILITIES),\
 170         S(GETTING_SOURCE_SINK_STATUS),          \
 171         S(GETTING_BATTERY_CAPABILITIES),        \
 172         S(GETTING_BATTERY_STATUS),              \
 173         S(GETTING_MANUFACTURER_INFORMATION),    \
 174         S(SECURITY),                            \
 175         S(FIRMWARE_UPDATE),                     \
 176         S(DISCOVER_IDENTITY),                   \
 177         S(SOURCE_STARTUP_CABLE_PLUG_DISCOVER_IDENTITY), \
 178         S(DISCOVER_SVIDS),                      \
 179         S(DISCOVER_MODES),                      \
 180         S(DFP_TO_UFP_ENTER_MODE),               \
 181         S(DFP_TO_UFP_EXIT_MODE),                \
 182         S(DFP_TO_CABLE_PLUG_ENTER_MODE),        \
 183         S(DFP_TO_CABLE_PLUG_EXIT_MODE),         \
 184         S(ATTENTION),                           \
 185         S(BIST),                                \
 186         S(UNSTRUCTURED_VDMS),                   \
 187         S(STRUCTURED_VDMS),                     \
 188         S(COUNTRY_INFO),                        \
 189         S(COUNTRY_CODES),                       \
 190         S(REVISION_INFORMATION)
 191
 192 #define GENERATE_ENUM(e)        e
 193 #define GENERATE_STRING(s)      #s
 194
 195 enum tcpm_state {
 196         FOREACH_STATE(GENERATE_ENUM)
 197 };
 198
 199 static const char * const tcpm_states[] = {
 200         FOREACH_STATE(GENERATE_STRING)
 201 };
 202
 203 enum tcpm_ams {
 204         FOREACH_AMS(GENERATE_ENUM)
 205 };
 206
 207 static const char * const tcpm_ams_str[] = {
 208         FOREACH_AMS(GENERATE_STRING)
 209 };
 210
 211 enum vdm_states {
 212         VDM_STATE_ERR_BUSY = -3,
 213         VDM_STATE_ERR_SEND = -2,
 214         VDM_STATE_ERR_TMOUT = -1,
 215         VDM_STATE_DONE = 0,
 216         /* Anything >0 represents an active state */
 217         VDM_STATE_READY = 1,
 218         VDM_STATE_BUSY = 2,
 219         VDM_STATE_WAIT_RSP_BUSY = 3,
 220         VDM_STATE_SEND_MESSAGE = 4,
 221 };
 222
 223 enum pd_msg_request {
 224         PD_MSG_NONE = 0,
 225         PD_MSG_CTRL_REJECT,
 226         PD_MSG_CTRL_WAIT,
 227         PD_MSG_CTRL_NOT_SUPP,
 228         PD_MSG_DATA_SINK_CAP,
 229         PD_MSG_DATA_SOURCE_CAP,
 230         PD_MSG_DATA_REV,
 231 };
 232
 233 enum adev_actions {
 234         ADEV_NONE = 0,
 235         ADEV_NOTIFY_USB_AND_QUEUE_VDM,
 236         ADEV_QUEUE_VDM,
 237         ADEV_QUEUE_VDM_SEND_EXIT_MODE_ON_FAIL,
 238         ADEV_ATTENTION,
 239 };
 240
 241 /*
 242  * Initial current capability of the new source when vSafe5V is applied during PD3.0 Fast Role Swap.
 243  * Based on "Table 6-14 Fixed Supply PDO - Sink" of "USB Power Delivery Specification Revision 3.0,
 244  * Version 1.2"
 245  */
 246 enum frs_typec_current {
 247         FRS_NOT_SUPPORTED,
 248         FRS_DEFAULT_POWER,
 249         FRS_5V_1P5A,
 250         FRS_5V_3A,
 251 };
 252
 253 /* Events from low level driver */
 254
 255 #define TCPM_CC_EVENT           BIT(0)
 256 #define TCPM_VBUS_EVENT         BIT(1)
 257 #define TCPM_RESET_EVENT        BIT(2)
 258 #define TCPM_FRS_EVENT          BIT(3)
 259 #define TCPM_SOURCING_VBUS      BIT(4)
 260 #define TCPM_PORT_CLEAN         BIT(5)
 261 #define TCPM_PORT_ERROR         BIT(6)
 262
 263 #define LOG_BUFFER_ENTRIES      1024
 264 #define LOG_BUFFER_ENTRY_SIZE   128
 265
 266 /* Alternate mode support */
 267
 268 #define SVID_DISCOVERY_MAX      16
 269 #define ALTMODE_DISCOVERY_MAX   (SVID_DISCOVERY_MAX * MODE_DISCOVERY_MAX)
 270
 271 #define GET_SINK_CAP_RETRY_MS   100
 272 #define SEND_DISCOVER_RETRY_MS  100
 273
 274 struct pd_mode_data {
 275         int svid_index;         /* current SVID index           */
 276         int nsvids;
 277         u16 svids[SVID_DISCOVERY_MAX];
 278         int altmodes;           /* number of alternate modes    */
 279         struct typec_altmode_desc altmode_desc[ALTMODE_DISCOVERY_MAX];
 280 };
 281
 282 /*
 283  * @min_volt: Actual min voltage at the local port
 284  * @req_min_volt: Requested min voltage to the port partner
 285  * @max_volt: Actual max voltage at the local port
 286  * @req_max_volt: Requested max voltage to the port partner
 287  * @max_curr: Actual max current at the local port
 288  * @req_max_curr: Requested max current of the port partner
 289  * @req_out_volt: Requested output voltage to the port partner
 290  * @req_op_curr: Requested operating current to the port partner
 291  * @supported: Parter has at least one APDO hence supports PPS
 292  * @active: PPS mode is active
 293  */
 294 struct pd_pps_data {
 295         u32 min_volt;
 296         u32 req_min_volt;
 297         u32 max_volt;
 298         u32 req_max_volt;
 299         u32 max_curr;
 300         u32 req_max_curr;
 301         u32 req_out_volt;
 302         u32 req_op_curr;
 303         bool supported;
 304         bool active;
 305 };
 306
 307 struct pd_data {
 308         struct usb_power_delivery *pd;
 309         struct usb_power_delivery_capabilities *source_cap;
 310         struct usb_power_delivery_capabilities_desc source_desc;
 311         struct usb_power_delivery_capabilities *sink_cap;
 312         struct usb_power_delivery_capabilities_desc sink_desc;
 313         unsigned int operating_snk_mw;
 314 };
 315
 316 struct pd_revision_info {
 317         u8 rev_major;
 318         u8 rev_minor;
 319         u8 ver_major;
 320         u8 ver_minor;
 321 };
 322
 323 /*
 324  * @sink_wait_cap_time: Deadline (in ms) for tTypeCSinkWaitCap timer
 325  * @ps_src_wait_off_time: Deadline (in ms) for tPSSourceOff timer
 326  * @cc_debounce_time: Deadline (in ms) for tCCDebounce timer
 327  */
 328 struct pd_timings {
 329         u32 sink_wait_cap_time;
 330         u32 ps_src_off_time;
 331         u32 cc_debounce_time;
 332         u32 snk_bc12_cmpletion_time;
 333 };
 334
 335 struct tcpm_port {
 336         struct device *dev;
 337
 338         struct mutex lock;              /* tcpm state machine lock */
 339         struct kthread_worker *wq;
 340
 341         struct typec_capability typec_caps;
 342         struct typec_port *typec_port;
 343
 344         struct tcpc_dev *tcpc;
 345         struct usb_role_switch *role_sw;
 346
 347         enum typec_role vconn_role;
 348         enum typec_role pwr_role;
 349         enum typec_data_role data_role;
 350         enum typec_pwr_opmode pwr_opmode;
 351
 352         struct usb_pd_identity partner_ident;
 353         struct typec_partner_desc partner_desc;
 354         struct typec_partner *partner;
 355
 356         struct usb_pd_identity cable_ident;
 357         struct typec_cable_desc cable_desc;
 358         struct typec_cable *cable;
 359         struct typec_plug_desc plug_prime_desc;
 360         struct typec_plug *plug_prime;
 361
 362         enum typec_cc_status cc_req;
 363         enum typec_cc_status src_rp;    /* work only if pd_supported == false */
 364
 365         enum typec_cc_status cc1;
 366         enum typec_cc_status cc2;
 367         enum typec_cc_polarity polarity;
 368
 369         bool attached;
 370         bool connected;
 371         bool registered;
 372         bool pd_supported;
 373         enum typec_port_type port_type;
 374
 375         /*
 376          * Set to true when vbus is greater than VSAFE5V min.
 377          * Set to false when vbus falls below vSinkDisconnect max threshold.
 378          */
 379         bool vbus_present;
 380
 381         /*
 382          * Set to true when vbus is less than VSAFE0V max.
 383          * Set to false when vbus is greater than VSAFE0V max.
 384          */
 385         bool vbus_vsafe0v;
 386
 387         bool vbus_never_low;
 388         bool vbus_source;
 389         bool vbus_charge;
 390
 391         /* Set to true when Discover_Identity Command is expected to be sent in Ready states. */
 392         bool send_discover;
 393         bool op_vsafe5v;
 394
 395         int try_role;
 396         int try_snk_count;
 397         int try_src_count;
 398
 399         enum pd_msg_request queued_message;
 400
 401         enum tcpm_state enter_state;
 402         enum tcpm_state prev_state;
 403         enum tcpm_state state;
 404         enum tcpm_state delayed_state;
 405         ktime_t delayed_runtime;
 406         unsigned long delay_ms;
 407
 408         spinlock_t pd_event_lock;
 409         u32 pd_events;
 410
 411         struct kthread_work event_work;
 412         struct hrtimer state_machine_timer;
 413         struct kthread_work state_machine;
 414         struct hrtimer vdm_state_machine_timer;
 415         struct kthread_work vdm_state_machine;
 416         struct hrtimer enable_frs_timer;
 417         struct kthread_work enable_frs;
 418         struct hrtimer send_discover_timer;
 419         struct kthread_work send_discover_work;
 420         bool state_machine_running;
 421         /* Set to true when VDM State Machine has following actions. */
 422         bool vdm_sm_running;
 423
 424         struct completion tx_complete;
 425         enum tcpm_transmit_status tx_status;
 426
 427         struct mutex swap_lock;         /* swap command lock */
 428         bool swap_pending;
 429         bool non_pd_role_swap;
 430         struct completion swap_complete;
 431         int swap_status;
 432
 433         unsigned int negotiated_rev;
 434         unsigned int message_id;
 435         unsigned int caps_count;
 436         unsigned int hard_reset_count;
 437         bool pd_capable;
 438         bool explicit_contract;
 439         unsigned int rx_msgid;
 440
 441         /* USB PD objects */
 442         struct usb_power_delivery **pds;
 443         struct pd_data **pd_list;
 444         struct usb_power_delivery_capabilities *port_source_caps;
 445         struct usb_power_delivery_capabilities *port_sink_caps;
 446         struct usb_power_delivery *partner_pd;
 447         struct usb_power_delivery_capabilities *partner_source_caps;
 448         struct usb_power_delivery_capabilities *partner_sink_caps;
 449         struct usb_power_delivery *selected_pd;
 450
 451         /* Partner capabilities/requests */
 452         u32 sink_request;
 453         u32 source_caps[PDO_MAX_OBJECTS];
 454         unsigned int nr_source_caps;
 455         u32 sink_caps[PDO_MAX_OBJECTS];
 456         unsigned int nr_sink_caps;
 457
 458         /* Local capabilities */
 459         unsigned int pd_count;
 460         u32 src_pdo[PDO_MAX_OBJECTS];
 461         unsigned int nr_src_pdo;
 462         u32 snk_pdo[PDO_MAX_OBJECTS];
 463         unsigned int nr_snk_pdo;
 464         u32 snk_vdo_v1[VDO_MAX_OBJECTS];
 465         unsigned int nr_snk_vdo_v1;
 466         u32 snk_vdo[VDO_MAX_OBJECTS];
 467         unsigned int nr_snk_vdo;
 468
 469         unsigned int operating_snk_mw;
 470         bool update_sink_caps;
 471
 472         /* Requested current / voltage to the port partner */
 473         u32 req_current_limit;
 474         u32 req_supply_voltage;
 475         /* Actual current / voltage limit of the local port */
 476         u32 current_limit;
 477         u32 supply_voltage;
 478
 479         /* Used to export TA voltage and current */
 480         struct power_supply *psy;
 481         struct power_supply_desc psy_desc;
 482         enum power_supply_usb_type usb_type;
 483
 484         u32 bist_request;
 485
 486         /* PD state for Vendor Defined Messages */
 487         enum vdm_states vdm_state;
 488         u32 vdm_retries;
 489         /* next Vendor Defined Message to send */
 490         u32 vdo_data[VDO_MAX_SIZE];
 491         u8 vdo_count;
 492         /* VDO to retry if UFP responder replied busy */
 493         u32 vdo_retry;
 494
 495         /* PPS */
 496         struct pd_pps_data pps_data;
 497         struct completion pps_complete;
 498         bool pps_pending;
 499         int pps_status;
 500
 501         /* Alternate mode data */
 502         struct pd_mode_data mode_data;
 503         struct pd_mode_data mode_data_prime;
 504         struct typec_altmode *partner_altmode[ALTMODE_DISCOVERY_MAX];
 505         struct typec_altmode *plug_prime_altmode[ALTMODE_DISCOVERY_MAX];
 506         struct typec_altmode *port_altmode[ALTMODE_DISCOVERY_MAX];
 507
 508         /* Deadline in jiffies to exit src_try_wait state */
 509         unsigned long max_wait;
 510
 511         /* port belongs to a self powered device */
 512         bool self_powered;
 513
 514         /* Sink FRS */
 515         enum frs_typec_current new_source_frs_current;
 516
 517         /* Sink caps have been queried */
 518         bool sink_cap_done;
 519
 520         /* Collision Avoidance and Atomic Message Sequence */
 521         enum tcpm_state upcoming_state;
 522         enum tcpm_ams ams;
 523         enum tcpm_ams next_ams;
 524         bool in_ams;
 525
 526         /* Auto vbus discharge status */
 527         bool auto_vbus_discharge_enabled;
 528
 529         /*
 530          * When set, port requests PD_P_SNK_STDBY_MW upon entering SNK_DISCOVERY and
 531          * the actual current limit after RX of PD_CTRL_PSRDY for PD link,
 532          * SNK_READY for non-pd link.
 533          */
 534         bool slow_charger_loop;
 535
 536         /*
 537          * When true indicates that the lower level drivers indicate potential presence
 538          * of contaminant in the connector pins based on the tcpm state machine
 539          * transitions.
 540          */
 541         bool potential_contaminant;
 542
 543         /* SOP* Related Fields */
 544         /*
 545          * Flag to determine if SOP' Discover Identity is available. The flag
 546          * is set if Discover Identity on SOP' does not immediately follow
 547          * Discover Identity on SOP.
 548          */
 549         bool send_discover_prime;
 550         /*
 551          * tx_sop_type determines which SOP* a message is being sent on.
 552          * For messages that are queued and not sent immediately such as in
 553          * tcpm_queue_message or messages that send after state changes,
 554          * the tx_sop_type is set accordingly.
 555          */
 556         enum tcpm_transmit_type tx_sop_type;
 557         /*
 558          * Prior to discovering the port partner's Specification Revision, the
 559          * Vconn source and cable plug will use the lower of their two revisions.
 560          *
 561          * When the port partner's Specification Revision is discovered, the following
 562          * rules are put in place.
 563          *      1. If the cable revision (1) is lower than the revision negotiated
 564          * between the port and partner (2), the port and partner will communicate
 565          * on revision (2), but the port and cable will communicate on revision (1).
 566          *      2. If the cable revision (1) is higher than the revision negotiated
 567          * between the port and partner (2), the port and partner will communicate
 568          * on revision (2), and the port and cable will communicate on revision (2)
 569          * as well.
 570          */
 571         unsigned int negotiated_rev_prime;
 572         /*
 573          * Each SOP* type must maintain their own tx and rx message IDs
 574          */
 575         unsigned int message_id_prime;
 576         unsigned int rx_msgid_prime;
 577
 578         /* Timer deadline values configured at runtime */
 579         struct pd_timings timings;
 580
 581         /* Indicates maximum (revision, version) supported */
 582         struct pd_revision_info pd_rev;
 583 #ifdef CONFIG_DEBUG_FS
 584         struct dentry *dentry;
 585         struct mutex logbuffer_lock;    /* log buffer access lock */
 586         int logbuffer_head;
 587         int logbuffer_tail;
 588         u8 *logbuffer[LOG_BUFFER_ENTRIES];
 589 #endif
 590 };
 591
 592 struct pd_rx_event {
 593         struct kthread_work work;
 594         struct tcpm_port *port;
 595         struct pd_message msg;
 596         enum tcpm_transmit_type rx_sop_type;
 597 };
 598
 599 static const char * const pd_rev[] = {
 600         [PD_REV10]              = "rev1",
 601         [PD_REV20]              = "rev2",
 602         [PD_REV30]              = "rev3",
 603 };
 604
 605 #define tcpm_cc_is_sink(cc) \
 606         ((cc) == TYPEC_CC_RP_DEF || (cc) == TYPEC_CC_RP_1_5 || \
 607          (cc) == TYPEC_CC_RP_3_0)
 608
 609 /* As long as cc is pulled up, we can consider it as sink. */
 610 #define tcpm_port_is_sink(port) \
 611         (tcpm_cc_is_sink((port)->cc1) || tcpm_cc_is_sink((port)->cc2))
 612
 613 #define tcpm_cc_is_source(cc) ((cc) == TYPEC_CC_RD)
 614 #define tcpm_cc_is_audio(cc) ((cc) == TYPEC_CC_RA)
 615 #define tcpm_cc_is_open(cc) ((cc) == TYPEC_CC_OPEN)
 616
 617 #define tcpm_port_is_source(port) \
 618         ((tcpm_cc_is_source((port)->cc1) && \
 619          !tcpm_cc_is_source((port)->cc2)) || \
 620          (tcpm_cc_is_source((port)->cc2) && \
 621           !tcpm_cc_is_source((port)->cc1)))
 622
 623 #define tcpm_port_is_debug(port) \
 624         (tcpm_cc_is_source((port)->cc1) && tcpm_cc_is_source((port)->cc2))
 625
 626 #define tcpm_port_is_audio(port) \
 627         (tcpm_cc_is_audio((port)->cc1) && tcpm_cc_is_audio((port)->cc2))
 628
 629 #define tcpm_port_is_audio_detached(port) \
 630         ((tcpm_cc_is_audio((port)->cc1) && tcpm_cc_is_open((port)->cc2)) || \
 631          (tcpm_cc_is_audio((port)->cc2) && tcpm_cc_is_open((port)->cc1)))
 632
 633 #define tcpm_try_snk(port) \
 634         ((port)->try_snk_count == 0 && (port)->try_role == TYPEC_SINK && \
 635         (port)->port_type == TYPEC_PORT_DRP)
 636
 637 #define tcpm_try_src(port) \
 638         ((port)->try_src_count == 0 && (port)->try_role == TYPEC_SOURCE && \
 639         (port)->port_type == TYPEC_PORT_DRP)
 640
 641 #define tcpm_data_role_for_source(port) \
 642         ((port)->typec_caps.data == TYPEC_PORT_UFP ? \
 643         TYPEC_DEVICE : TYPEC_HOST)
 644
 645 #define tcpm_data_role_for_sink(port) \
 646         ((port)->typec_caps.data == TYPEC_PORT_DFP ? \
 647         TYPEC_HOST : TYPEC_DEVICE)
 648
 649 #define tcpm_sink_tx_ok(port) \
 650         (tcpm_port_is_sink(port) && \
 651         ((port)->cc1 == TYPEC_CC_RP_3_0 || (port)->cc2 == TYPEC_CC_RP_3_0))
 652
 653 #define tcpm_wait_for_discharge(port) \
 654         (((port)->auto_vbus_discharge_enabled && !(port)->vbus_vsafe0v) ? PD_T_SAFE_0V : 0)
 655
 656 static enum tcpm_state tcpm_default_state(struct tcpm_port *port)
 657 {
 658         if (port->port_type == TYPEC_PORT_DRP) {
 659                 if (port->try_role == TYPEC_SINK)
 660                         return SNK_UNATTACHED;
 661                 else if (port->try_role == TYPEC_SOURCE)
 662                         return SRC_UNATTACHED;
 663                 /* Fall through to return SRC_UNATTACHED */
 664         } else if (port->port_type == TYPEC_PORT_SNK) {
 665                 return SNK_UNATTACHED;
 666         }
 667         return SRC_UNATTACHED;
 668 }
 669
 670 static bool tcpm_port_is_disconnected(struct tcpm_port *port)
 671 {
 672         return (!port->attached && port->cc1 == TYPEC_CC_OPEN &&
 673                 port->cc2 == TYPEC_CC_OPEN) ||
 674                (port->attached && ((port->polarity == TYPEC_POLARITY_CC1 &&
 675                                     port->cc1 == TYPEC_CC_OPEN) ||
 676                                    (port->polarity == TYPEC_POLARITY_CC2 &&
 677                                     port->cc2 == TYPEC_CC_OPEN)));
 678 }
 679
 680 /*
 681  * Logging
 682  */
 683
 684 #ifdef CONFIG_DEBUG_FS
 685
 686 static bool tcpm_log_full(struct tcpm_port *port)
 687 {
 688         return port->logbuffer_tail ==
 689                 (port->logbuffer_head + 1) % LOG_BUFFER_ENTRIES;
 690 }
 691
 692 __printf(2, 0)
 693 static void _tcpm_log(struct tcpm_port *port, const char *fmt, va_list args)
 694 {
 695         char tmpbuffer[LOG_BUFFER_ENTRY_SIZE];
 696         u64 ts_nsec = local_clock();
 697         unsigned long rem_nsec;
 698
 699         mutex_lock(&port->logbuffer_lock);
 700         if (!port->logbuffer[port->logbuffer_head]) {
 701                 port->logbuffer[port->logbuffer_head] =
 702                                 kzalloc(LOG_BUFFER_ENTRY_SIZE, GFP_KERNEL);
 703                 if (!port->logbuffer[port->logbuffer_head]) {
 704                         mutex_unlock(&port->logbuffer_lock);
 705                         return;
 706                 }
 707         }
 708
 709         vsnprintf(tmpbuffer, sizeof(tmpbuffer), fmt, args);
 710
 711         if (tcpm_log_full(port)) {
 712                 port->logbuffer_head = max(port->logbuffer_head - 1, 0);
 713                 strcpy(tmpbuffer, "overflow");
 714         }
 715
 716         if (port->logbuffer_head < 0 ||
 717             port->logbuffer_head >= LOG_BUFFER_ENTRIES) {
 718                 dev_warn(port->dev,
 719                          "Bad log buffer index %d\n", port->logbuffer_head);
 720                 goto abort;
 721         }
 722
 723         if (!port->logbuffer[port->logbuffer_head]) {
 724                 dev_warn(port->dev,
 725                          "Log buffer index %d is NULL\n", port->logbuffer_head);
 726                 goto abort;
 727         }
 728
 729         rem_nsec = do_div(ts_nsec, 1000000000);
 730         scnprintf(port->logbuffer[port->logbuffer_head],
 731                   LOG_BUFFER_ENTRY_SIZE, "[%5lu.%06lu] %s",
 732                   (unsigned long)ts_nsec, rem_nsec / 1000,
 733                   tmpbuffer);
 734         port->logbuffer_head = (port->logbuffer_head + 1) % LOG_BUFFER_ENTRIES;
 735
 736 abort:
 737         mutex_unlock(&port->logbuffer_lock);
 738 }
 739
 740 __printf(2, 3)
 741 static void tcpm_log(struct tcpm_port *port, const char *fmt, ...)
 742 {
 743         va_list args;
 744
 745         /* Do not log while disconnected and unattached */
 746         if (tcpm_port_is_disconnected(port) &&
 747             (port->state == SRC_UNATTACHED || port->state == SNK_UNATTACHED ||
 748              port->state == TOGGLING || port->state == CHECK_CONTAMINANT))
 749                 return;
 750
 751         va_start(args, fmt);
 752         _tcpm_log(port, fmt, args);
 753         va_end(args);
 754 }
 755
 756 __printf(2, 3)
 757 static void tcpm_log_force(struct tcpm_port *port, const char *fmt, ...)
 758 {
 759         va_list args;
 760
 761         va_start(args, fmt);
 762         _tcpm_log(port, fmt, args);
 763         va_end(args);
 764 }
 765
 766 static void tcpm_log_source_caps(struct tcpm_port *port)
 767 {
 768         int i;
 769
 770         for (i = 0; i < port->nr_source_caps; i++) {
 771                 u32 pdo = port->source_caps[i];
 772                 enum pd_pdo_type type = pdo_type(pdo);
 773                 char msg[64];
 774
 775                 switch (type) {
 776                 case PDO_TYPE_FIXED:
 777                         scnprintf(msg, sizeof(msg),
 778                                   "%u mV, %u mA [%s%s%s%s%s%s]",
 779                                   pdo_fixed_voltage(pdo),
 780                                   pdo_max_current(pdo),
 781                                   (pdo & PDO_FIXED_DUAL_ROLE) ?
 782                                                         "R" : "",
 783                                   (pdo & PDO_FIXED_SUSPEND) ?
 784                                                         "S" : "",
 785                                   (pdo & PDO_FIXED_HIGHER_CAP) ?
 786                                                         "H" : "",
 787                                   (pdo & PDO_FIXED_USB_COMM) ?
 788                                                         "U" : "",
 789                                   (pdo & PDO_FIXED_DATA_SWAP) ?
 790                                                         "D" : "",
 791                                   (pdo & PDO_FIXED_EXTPOWER) ?
 792                                                         "E" : "");
 793                         break;
 794                 case PDO_TYPE_VAR:
 795                         scnprintf(msg, sizeof(msg),
 796                                   "%u-%u mV, %u mA",
 797                                   pdo_min_voltage(pdo),
 798                                   pdo_max_voltage(pdo),
 799                                   pdo_max_current(pdo));
 800                         break;
 801                 case PDO_TYPE_BATT:
 802                         scnprintf(msg, sizeof(msg),
 803                                   "%u-%u mV, %u mW",
 804                                   pdo_min_voltage(pdo),
 805                                   pdo_max_voltage(pdo),
 806                                   pdo_max_power(pdo));
 807                         break;
 808                 case PDO_TYPE_APDO:
 809                         if (pdo_apdo_type(pdo) == APDO_TYPE_PPS)
 810                                 scnprintf(msg, sizeof(msg),
 811                                           "%u-%u mV, %u mA",
 812                                           pdo_pps_apdo_min_voltage(pdo),
 813                                           pdo_pps_apdo_max_voltage(pdo),
 814                                           pdo_pps_apdo_max_current(pdo));
 815                         else
 816                                 strcpy(msg, "undefined APDO");
 817                         break;
 818                 default:
 819                         strcpy(msg, "undefined");
 820                         break;
 821                 }
 822                 tcpm_log(port, " PDO %d: type %d, %s",
 823                          i, type, msg);
 824         }
 825 }
 826
 827 static int tcpm_debug_show(struct seq_file *s, void *v)
 828 {
 829         struct tcpm_port *port = s->private;
 830         int tail;
 831
 832         mutex_lock(&port->logbuffer_lock);
 833         tail = port->logbuffer_tail;
 834         while (tail != port->logbuffer_head) {
 835                 seq_printf(s, "%s\n", port->logbuffer[tail]);
 836                 tail = (tail + 1) % LOG_BUFFER_ENTRIES;
 837         }
 838         if (!seq_has_overflowed(s))
 839                 port->logbuffer_tail = tail;
 840         mutex_unlock(&port->logbuffer_lock);
 841
 842         return 0;
 843 }
 844 DEFINE_SHOW_ATTRIBUTE(tcpm_debug);
 845
 846 static void tcpm_debugfs_init(struct tcpm_port *port)
 847 {
 848         char name[NAME_MAX];
 849
 850         mutex_init(&port->logbuffer_lock);
 851         snprintf(name, NAME_MAX, "tcpm-%s", dev_name(port->dev));
 852         port->dentry = debugfs_create_dir(name, usb_debug_root);
 853         debugfs_create_file("log", S_IFREG | 0444, port->dentry, port,
 854                             &tcpm_debug_fops);
 855 }
 856
 857 static void tcpm_debugfs_exit(struct tcpm_port *port)
 858 {
 859         int i;
 860
 861         mutex_lock(&port->logbuffer_lock);
 862         for (i = 0; i < LOG_BUFFER_ENTRIES; i++) {
 863                 kfree(port->logbuffer[i]);
 864                 port->logbuffer[i] = NULL;
 865         }
 866         mutex_unlock(&port->logbuffer_lock);
 867
 868         debugfs_remove(port->dentry);
 869 }
 870
 871 #else
 872
 873 __printf(2, 3)
 874 static void tcpm_log(const struct tcpm_port *port, const char *fmt, ...) { }
 875 __printf(2, 3)
 876 static void tcpm_log_force(struct tcpm_port *port, const char *fmt, ...) { }
 877 static void tcpm_log_source_caps(struct tcpm_port *port) { }
 878 static void tcpm_debugfs_init(const struct tcpm_port *port) { }
 879 static void tcpm_debugfs_exit(const struct tcpm_port *port) { }
 880
 881 #endif
 882
 883 static void tcpm_set_cc(struct tcpm_port *port, enum typec_cc_status cc)
 884 {
 885         tcpm_log(port, "cc:=%d", cc);
 886         port->cc_req = cc;
 887         port->tcpc->set_cc(port->tcpc, cc);
 888 }
 889
 890 static int tcpm_enable_auto_vbus_discharge(struct tcpm_port *port, bool enable)
 891 {
 892         int ret = 0;
 893
 894         if (port->tcpc->enable_auto_vbus_discharge) {
 895                 ret = port->tcpc->enable_auto_vbus_discharge(port->tcpc, enable);
 896                 tcpm_log_force(port, "%s vbus discharge ret:%d",
 897                                str_enable_disable(enable), ret);
 898                 if (!ret)
 899                         port->auto_vbus_discharge_enabled = enable;
 900         }
 901
 902         return ret;
 903 }
 904
 905 static void tcpm_apply_rc(struct tcpm_port *port)
 906 {
 907         /*
 908          * TCPCI: Move to APPLY_RC state to prevent disconnect during PR_SWAP
 909          * when Vbus auto discharge on disconnect is enabled.
 910          */
 911         if (port->tcpc->enable_auto_vbus_discharge && port->tcpc->apply_rc) {
 912                 tcpm_log(port, "Apply_RC");
 913                 port->tcpc->apply_rc(port->tcpc, port->cc_req, port->polarity);
 914                 tcpm_enable_auto_vbus_discharge(port, false);
 915         }
 916 }
 917
 918 /*
 919  * Determine RP value to set based on maximum current supported
 920  * by a port if configured as source.
 921  * Returns CC value to report to link partner.
 922  */
 923 static enum typec_cc_status tcpm_rp_cc(struct tcpm_port *port)
 924 {
 925         const u32 *src_pdo = port->src_pdo;
 926         int nr_pdo = port->nr_src_pdo;
 927         int i;
 928
 929         if (!port->pd_supported)
 930                 return port->src_rp;
 931
 932         /*
 933          * Search for first entry with matching voltage.
 934          * It should report the maximum supported current.
 935          */
 936         for (i = 0; i < nr_pdo; i++) {
 937                 const u32 pdo = src_pdo[i];
 938
 939                 if (pdo_type(pdo) == PDO_TYPE_FIXED &&
 940                     pdo_fixed_voltage(pdo) == 5000) {
 941                         unsigned int curr = pdo_max_current(pdo);
 942
 943                         if (curr >= 3000)
 944                                 return TYPEC_CC_RP_3_0;
 945                         else if (curr >= 1500)
 946                                 return TYPEC_CC_RP_1_5;
 947                         return TYPEC_CC_RP_DEF;
 948                 }
 949         }
 950
 951         return TYPEC_CC_RP_DEF;
 952 }
 953
 954 static void tcpm_ams_finish(struct tcpm_port *port)
 955 {
 956         tcpm_log(port, "AMS %s finished", tcpm_ams_str[port->ams]);
 957
 958         if (port->pd_capable && port->pwr_role == TYPEC_SOURCE) {
 959                 if (port->negotiated_rev >= PD_REV30)
 960                         tcpm_set_cc(port, SINK_TX_OK);
 961                 else
 962                         tcpm_set_cc(port, SINK_TX_NG);
 963         } else if (port->pwr_role == TYPEC_SOURCE) {
 964                 tcpm_set_cc(port, tcpm_rp_cc(port));
 965         }
 966
 967         port->in_ams = false;
 968         port->ams = NONE_AMS;
 969 }
 970
 971 static int tcpm_pd_transmit(struct tcpm_port *port,
 972                             enum tcpm_transmit_type tx_sop_type,
 973                             const struct pd_message *msg)
 974 {
 975         unsigned long time_left;
 976         int ret;
 977         unsigned int negotiated_rev;
 978
 979         switch (tx_sop_type) {
 980         case TCPC_TX_SOP_PRIME:
 981                 negotiated_rev = port->negotiated_rev_prime;
 982                 break;
 983         case TCPC_TX_SOP:
 984         default:
 985                 negotiated_rev = port->negotiated_rev;
 986                 break;
 987         }
 988
 989         if (msg)
 990                 tcpm_log(port, "PD TX, header: %#x", le16_to_cpu(msg->header));
 991         else
 992                 tcpm_log(port, "PD TX, type: %#x", tx_sop_type);
 993
 994         reinit_completion(&port->tx_complete);
 995         ret = port->tcpc->pd_transmit(port->tcpc, tx_sop_type, msg, negotiated_rev);
 996         if (ret < 0)
 997                 return ret;
 998
 999         mutex_unlock(&port->lock);
1000         time_left = wait_for_completion_timeout(&port->tx_complete,
1001                                                 msecs_to_jiffies(PD_T_TCPC_TX_TIMEOUT));
1002         mutex_lock(&port->lock);
1003         if (!time_left)
1004                 return -ETIMEDOUT;
1005
1006         switch (port->tx_status) {
1007         case TCPC_TX_SUCCESS:
1008                 switch (tx_sop_type) {
1009                 case TCPC_TX_SOP_PRIME:
1010                         port->message_id_prime = (port->message_id_prime + 1) &
1011                                                  PD_HEADER_ID_MASK;
1012                         break;
1013                 case TCPC_TX_SOP:
1014                 default:
1015                         port->message_id = (port->message_id + 1) &
1016                                            PD_HEADER_ID_MASK;
1017                         break;
1018                 }
1019                 /*
1020                  * USB PD rev 2.0, 8.3.2.2.1:
1021                  * USB PD rev 3.0, 8.3.2.1.3:
1022                  * "... Note that every AMS is Interruptible until the first
1023                  * Message in the sequence has been successfully sent (GoodCRC
1024                  * Message received)."
1025                  */
1026                 if (port->ams != NONE_AMS)
1027                         port->in_ams = true;
1028                 break;
1029         case TCPC_TX_DISCARDED:
1030                 ret = -EAGAIN;
1031                 break;
1032         case TCPC_TX_FAILED:
1033         default:
1034                 ret = -EIO;
1035                 break;
1036         }
1037
1038         /* Some AMS don't expect responses. Finish them here. */
1039         if (port->ams == ATTENTION || port->ams == SOURCE_ALERT)
1040                 tcpm_ams_finish(port);
1041
1042         return ret;
1043 }
1044
1045 void tcpm_pd_transmit_complete(struct tcpm_port *port,
1046                                enum tcpm_transmit_status status)
1047 {
1048         tcpm_log(port, "PD TX complete, status: %u", status);
1049         port->tx_status = status;
1050         complete(&port->tx_complete);
1051 }
1052 EXPORT_SYMBOL_GPL(tcpm_pd_transmit_complete);
1053
1054 static int tcpm_mux_set(struct tcpm_port *port, int state,
1055                         enum usb_role usb_role,
1056                         enum typec_orientation orientation)
1057 {
1058         int ret;
1059
1060         tcpm_log(port, "Requesting mux state %d, usb-role %d, orientation %d",
1061                  state, usb_role, orientation);
1062
1063         ret = typec_set_orientation(port->typec_port, orientation);
1064         if (ret)
1065                 return ret;
1066
1067         if (port->role_sw) {
1068                 ret = usb_role_switch_set_role(port->role_sw, usb_role);
1069                 if (ret)
1070                         return ret;
1071         }
1072
1073         return typec_set_mode(port->typec_port, state);
1074 }
1075
1076 static int tcpm_set_polarity(struct tcpm_port *port,
1077                              enum typec_cc_polarity polarity)
1078 {
1079         int ret;
1080
1081         tcpm_log(port, "polarity %d", polarity);
1082
1083         ret = port->tcpc->set_polarity(port->tcpc, polarity);
1084         if (ret < 0)
1085                 return ret;
1086
1087         port->polarity = polarity;
1088
1089         return 0;
1090 }
1091
1092 static int tcpm_set_vconn(struct tcpm_port *port, bool enable)
1093 {
1094         int ret;
1095
1096         tcpm_log(port, "vconn:=%d", enable);
1097
1098         ret = port->tcpc->set_vconn(port->tcpc, enable);
1099         if (!ret) {
1100                 port->vconn_role = enable ? TYPEC_SOURCE : TYPEC_SINK;
1101                 typec_set_vconn_role(port->typec_port, port->vconn_role);
1102         }
1103
1104         return ret;
1105 }
1106
1107 static u32 tcpm_get_current_limit(struct tcpm_port *port)
1108 {
1109         enum typec_cc_status cc;
1110         u32 limit;
1111
1112         cc = port->polarity ? port->cc2 : port->cc1;
1113         switch (cc) {
1114         case TYPEC_CC_RP_1_5:
1115                 limit = 1500;
1116                 break;
1117         case TYPEC_CC_RP_3_0:
1118                 limit = 3000;
1119                 break;
1120         case TYPEC_CC_RP_DEF:
1121         default:
1122                 if (port->tcpc->get_current_limit)
1123                         limit = port->tcpc->get_current_limit(port->tcpc);
1124                 else
1125                         limit = 0;
1126                 break;
1127         }
1128
1129         return limit;
1130 }
1131
1132 static int tcpm_set_current_limit(struct tcpm_port *port, u32 max_ma, u32 mv)
1133 {
1134         int ret = -EOPNOTSUPP;
1135
1136         tcpm_log(port, "Setting voltage/current limit %u mV %u mA", mv, max_ma);
1137
1138         port->supply_voltage = mv;
1139         port->current_limit = max_ma;
1140         power_supply_changed(port->psy);
1141
1142         if (port->tcpc->set_current_limit)
1143                 ret = port->tcpc->set_current_limit(port->tcpc, max_ma, mv);
1144
1145         return ret;
1146 }
1147
1148 static int tcpm_set_attached_state(struct tcpm_port *port, bool attached)
1149 {
1150         return port->tcpc->set_roles(port->tcpc, attached, port->pwr_role,
1151                                      port->data_role);
1152 }
1153
1154 static int tcpm_set_roles(struct tcpm_port *port, bool attached,
1155                           enum typec_role role, enum typec_data_role data)
1156 {
1157         enum typec_orientation orientation;
1158         enum usb_role usb_role;
1159         int ret;
1160
1161         if (port->polarity == TYPEC_POLARITY_CC1)
1162                 orientation = TYPEC_ORIENTATION_NORMAL;
1163         else
1164                 orientation = TYPEC_ORIENTATION_REVERSE;
1165
1166         if (port->typec_caps.data == TYPEC_PORT_DRD) {
1167                 if (data == TYPEC_HOST)
1168                         usb_role = USB_ROLE_HOST;
1169                 else
1170                         usb_role = USB_ROLE_DEVICE;
1171         } else if (port->typec_caps.data == TYPEC_PORT_DFP) {
1172                 if (data == TYPEC_HOST) {
1173                         if (role == TYPEC_SOURCE)
1174                                 usb_role = USB_ROLE_HOST;
1175                         else
1176                                 usb_role = USB_ROLE_NONE;
1177                 } else {
1178                         return -ENOTSUPP;
1179                 }
1180         } else {
1181                 if (data == TYPEC_DEVICE) {
1182                         if (role == TYPEC_SINK)
1183                                 usb_role = USB_ROLE_DEVICE;
1184                         else
1185                                 usb_role = USB_ROLE_NONE;
1186                 } else {
1187                         return -ENOTSUPP;
1188                 }
1189         }
1190
1191         ret = tcpm_mux_set(port, TYPEC_STATE_USB, usb_role, orientation);
1192         if (ret < 0)
1193                 return ret;
1194
1195         ret = port->tcpc->set_roles(port->tcpc, attached, role, data);
1196         if (ret < 0)
1197                 return ret;
1198
1199         if (port->tcpc->set_orientation) {
1200                 ret = port->tcpc->set_orientation(port->tcpc, orientation);
1201                 if (ret < 0)
1202                         return ret;
1203         }
1204
1205         port->pwr_role = role;
1206         port->data_role = data;
1207         typec_set_data_role(port->typec_port, data);
1208         typec_set_pwr_role(port->typec_port, role);
1209
1210         return 0;
1211 }
1212
1213 static int tcpm_set_pwr_role(struct tcpm_port *port, enum typec_role role)
1214 {
1215         int ret;
1216
1217         ret = port->tcpc->set_roles(port->tcpc, true, role,
1218                                     port->data_role);
1219         if (ret < 0)
1220                 return ret;
1221
1222         port->pwr_role = role;
1223         typec_set_pwr_role(port->typec_port, role);
1224
1225         return 0;
1226 }
1227
1228 /*
1229  * Transform the PDO to be compliant to PD rev2.0.
1230  * Return 0 if the PDO type is not defined in PD rev2.0.
1231  * Otherwise, return the converted PDO.
1232  */
1233 static u32 tcpm_forge_legacy_pdo(struct tcpm_port *port, u32 pdo, enum typec_role role)
1234 {
1235         switch (pdo_type(pdo)) {
1236         case PDO_TYPE_FIXED:
1237                 if (role == TYPEC_SINK)
1238                         return pdo & ~PDO_FIXED_FRS_CURR_MASK;
1239                 else
1240                         return pdo & ~PDO_FIXED_UNCHUNK_EXT;
1241         case PDO_TYPE_VAR:
1242         case PDO_TYPE_BATT:
1243                 return pdo;
1244         case PDO_TYPE_APDO:
1245         default:
1246                 return 0;
1247         }
1248 }
1249
1250 static int tcpm_pd_send_revision(struct tcpm_port *port)
1251 {
1252         struct pd_message msg;
1253         u32 rmdo;
1254
1255         memset(&msg, 0, sizeof(msg));
1256         rmdo = RMDO(port->pd_rev.rev_major, port->pd_rev.rev_minor,
1257                     port->pd_rev.ver_major, port->pd_rev.ver_minor);
1258         msg.payload[0] = cpu_to_le32(rmdo);
1259         msg.header = PD_HEADER_LE(PD_DATA_REVISION,
1260                                   port->pwr_role,
1261                                   port->data_role,
1262                                   port->negotiated_rev,
1263                                   port->message_id,
1264                                   1);
1265         return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
1266 }
1267
1268 static int tcpm_pd_send_source_caps(struct tcpm_port *port)
1269 {
1270         struct pd_message msg;
1271         u32 pdo;
1272         unsigned int i, nr_pdo = 0;
1273
1274         memset(&msg, 0, sizeof(msg));
1275
1276         for (i = 0; i < port->nr_src_pdo; i++) {
1277                 if (port->negotiated_rev >= PD_REV30) {
1278                         msg.payload[nr_pdo++] = cpu_to_le32(port->src_pdo[i]);
1279                 } else {
1280                         pdo = tcpm_forge_legacy_pdo(port, port->src_pdo[i], TYPEC_SOURCE);
1281                         if (pdo)
1282                                 msg.payload[nr_pdo++] = cpu_to_le32(pdo);
1283                 }
1284         }
1285
1286         if (!nr_pdo) {
1287                 /* No source capabilities defined, sink only */
1288                 msg.header = PD_HEADER_LE(PD_CTRL_REJECT,
1289                                           port->pwr_role,
1290                                           port->data_role,
1291                                           port->negotiated_rev,
1292                                           port->message_id, 0);
1293         } else {
1294                 msg.header = PD_HEADER_LE(PD_DATA_SOURCE_CAP,
1295                                           port->pwr_role,
1296                                           port->data_role,
1297                                           port->negotiated_rev,
1298                                           port->message_id,
1299                                           nr_pdo);
1300         }
1301
1302         return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
1303 }
1304
1305 static int tcpm_pd_send_sink_caps(struct tcpm_port *port)
1306 {
1307         struct pd_message msg;
1308         u32 pdo;
1309         unsigned int i, nr_pdo = 0;
1310
1311         memset(&msg, 0, sizeof(msg));
1312
1313         for (i = 0; i < port->nr_snk_pdo; i++) {
1314                 if (port->negotiated_rev >= PD_REV30) {
1315                         msg.payload[nr_pdo++] = cpu_to_le32(port->snk_pdo[i]);
1316                 } else {
1317                         pdo = tcpm_forge_legacy_pdo(port, port->snk_pdo[i], TYPEC_SINK);
1318                         if (pdo)
1319                                 msg.payload[nr_pdo++] = cpu_to_le32(pdo);
1320                 }
1321         }
1322
1323         if (!nr_pdo) {
1324                 /* No sink capabilities defined, source only */
1325                 msg.header = PD_HEADER_LE(PD_CTRL_REJECT,
1326                                           port->pwr_role,
1327                                           port->data_role,
1328                                           port->negotiated_rev,
1329                                           port->message_id, 0);
1330         } else {
1331                 msg.header = PD_HEADER_LE(PD_DATA_SINK_CAP,
1332                                           port->pwr_role,
1333                                           port->data_role,
1334                                           port->negotiated_rev,
1335                                           port->message_id,
1336                                           nr_pdo);
1337         }
1338
1339         return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
1340 }
1341
1342 static void mod_tcpm_delayed_work(struct tcpm_port *port, unsigned int delay_ms)
1343 {
1344         if (delay_ms) {
1345                 hrtimer_start(&port->state_machine_timer, ms_to_ktime(delay_ms), HRTIMER_MODE_REL);
1346         } else {
1347                 hrtimer_cancel(&port->state_machine_timer);
1348                 kthread_queue_work(port->wq, &port->state_machine);
1349         }
1350 }
1351
1352 static void mod_vdm_delayed_work(struct tcpm_port *port, unsigned int delay_ms)
1353 {
1354         if (delay_ms) {
1355                 hrtimer_start(&port->vdm_state_machine_timer, ms_to_ktime(delay_ms),
1356                               HRTIMER_MODE_REL);
1357         } else {
1358                 hrtimer_cancel(&port->vdm_state_machine_timer);
1359                 kthread_queue_work(port->wq, &port->vdm_state_machine);
1360         }
1361 }
1362
1363 static void mod_enable_frs_delayed_work(struct tcpm_port *port, unsigned int delay_ms)
1364 {
1365         if (delay_ms) {
1366                 hrtimer_start(&port->enable_frs_timer, ms_to_ktime(delay_ms), HRTIMER_MODE_REL);
1367         } else {
1368                 hrtimer_cancel(&port->enable_frs_timer);
1369                 kthread_queue_work(port->wq, &port->enable_frs);
1370         }
1371 }
1372
1373 static void mod_send_discover_delayed_work(struct tcpm_port *port, unsigned int delay_ms)
1374 {
1375         if (delay_ms) {
1376                 hrtimer_start(&port->send_discover_timer, ms_to_ktime(delay_ms), HRTIMER_MODE_REL);
1377         } else {
1378                 hrtimer_cancel(&port->send_discover_timer);
1379                 kthread_queue_work(port->wq, &port->send_discover_work);
1380         }
1381 }
1382
1383 static void tcpm_set_state(struct tcpm_port *port, enum tcpm_state state,
1384                            unsigned int delay_ms)
1385 {
1386         if (delay_ms) {
1387                 tcpm_log(port, "pending state change %s -> %s @ %u ms [%s %s]",
1388                          tcpm_states[port->state], tcpm_states[state], delay_ms,
1389                          pd_rev[port->negotiated_rev], tcpm_ams_str[port->ams]);
1390                 port->delayed_state = state;
1391                 mod_tcpm_delayed_work(port, delay_ms);
1392                 port->delayed_runtime = ktime_add(ktime_get(), ms_to_ktime(delay_ms));
1393                 port->delay_ms = delay_ms;
1394         } else {
1395                 tcpm_log(port, "state change %s -> %s [%s %s]",
1396                          tcpm_states[port->state], tcpm_states[state],
1397                          pd_rev[port->negotiated_rev], tcpm_ams_str[port->ams]);
1398                 port->delayed_state = INVALID_STATE;
1399                 port->prev_state = port->state;
1400                 port->state = state;
1401                 /*
1402                  * Don't re-queue the state machine work item if we're currently
1403                  * in the state machine and we're immediately changing states.
1404                  * tcpm_state_machine_work() will continue running the state
1405                  * machine.
1406                  */
1407                 if (!port->state_machine_running)
1408                         mod_tcpm_delayed_work(port, 0);
1409         }
1410 }
1411
1412 static void tcpm_set_state_cond(struct tcpm_port *port, enum tcpm_state state,
1413                                 unsigned int delay_ms)
1414 {
1415         if (port->enter_state == port->state)
1416                 tcpm_set_state(port, state, delay_ms);
1417         else
1418                 tcpm_log(port,
1419                          "skipped %sstate change %s -> %s [%u ms], context state %s [%s %s]",
1420                          delay_ms ? "delayed " : "",
1421                          tcpm_states[port->state], tcpm_states[state],
1422                          delay_ms, tcpm_states[port->enter_state],
1423                          pd_rev[port->negotiated_rev], tcpm_ams_str[port->ams]);
1424 }
1425
1426 static void tcpm_queue_message(struct tcpm_port *port,
1427                                enum pd_msg_request message)
1428 {
1429         port->queued_message = message;
1430         mod_tcpm_delayed_work(port, 0);
1431 }
1432
1433 static bool tcpm_vdm_ams(struct tcpm_port *port)
1434 {
1435         switch (port->ams) {
1436         case DISCOVER_IDENTITY:
1437         case SOURCE_STARTUP_CABLE_PLUG_DISCOVER_IDENTITY:
1438         case DISCOVER_SVIDS:
1439         case DISCOVER_MODES:
1440         case DFP_TO_UFP_ENTER_MODE:
1441         case DFP_TO_UFP_EXIT_MODE:
1442         case DFP_TO_CABLE_PLUG_ENTER_MODE:
1443         case DFP_TO_CABLE_PLUG_EXIT_MODE:
1444         case ATTENTION:
1445         case UNSTRUCTURED_VDMS:
1446         case STRUCTURED_VDMS:
1447                 break;
1448         default:
1449                 return false;
1450         }
1451
1452         return true;
1453 }
1454
1455 static bool tcpm_ams_interruptible(struct tcpm_port *port)
1456 {
1457         switch (port->ams) {
1458         /* Interruptible AMS */
1459         case NONE_AMS:
1460         case SECURITY:
1461         case FIRMWARE_UPDATE:
1462         case DISCOVER_IDENTITY:
1463         case SOURCE_STARTUP_CABLE_PLUG_DISCOVER_IDENTITY:
1464         case DISCOVER_SVIDS:
1465         case DISCOVER_MODES:
1466         case DFP_TO_UFP_ENTER_MODE:
1467         case DFP_TO_UFP_EXIT_MODE:
1468         case DFP_TO_CABLE_PLUG_ENTER_MODE:
1469         case DFP_TO_CABLE_PLUG_EXIT_MODE:
1470         case UNSTRUCTURED_VDMS:
1471         case STRUCTURED_VDMS:
1472         case COUNTRY_INFO:
1473         case COUNTRY_CODES:
1474                 break;
1475         /* Non-Interruptible AMS */
1476         default:
1477                 if (port->in_ams)
1478                         return false;
1479                 break;
1480         }
1481
1482         return true;
1483 }
1484
1485 static int tcpm_ams_start(struct tcpm_port *port, enum tcpm_ams ams)
1486 {
1487         int ret = 0;
1488
1489         tcpm_log(port, "AMS %s start", tcpm_ams_str[ams]);
1490
1491         if (!tcpm_ams_interruptible(port) &&
1492             !(ams == HARD_RESET || ams == SOFT_RESET_AMS)) {
1493                 port->upcoming_state = INVALID_STATE;
1494                 tcpm_log(port, "AMS %s not interruptible, aborting",
1495                          tcpm_ams_str[port->ams]);
1496                 return -EAGAIN;
1497         }
1498
1499         if (port->pwr_role == TYPEC_SOURCE) {
1500                 enum typec_cc_status cc_req = port->cc_req;
1501
1502                 port->ams = ams;
1503
1504                 if (ams == HARD_RESET) {
1505                         tcpm_set_cc(port, tcpm_rp_cc(port));
1506                         tcpm_pd_transmit(port, TCPC_TX_HARD_RESET, NULL);
1507                         tcpm_set_state(port, HARD_RESET_START, 0);
1508                         return ret;
1509                 } else if (ams == SOFT_RESET_AMS) {
1510                         if (!port->explicit_contract)
1511                                 tcpm_set_cc(port, tcpm_rp_cc(port));
1512                         tcpm_set_state(port, SOFT_RESET_SEND, 0);
1513                         return ret;
1514                 } else if (tcpm_vdm_ams(port)) {
1515                         /* tSinkTx is enforced in vdm_run_state_machine */
1516                         if (port->negotiated_rev >= PD_REV30)
1517                                 tcpm_set_cc(port, SINK_TX_NG);
1518                         return ret;
1519                 }
1520
1521                 if (port->negotiated_rev >= PD_REV30)
1522                         tcpm_set_cc(port, SINK_TX_NG);
1523
1524                 switch (port->state) {
1525                 case SRC_READY:
1526                 case SRC_STARTUP:
1527                 case SRC_SOFT_RESET_WAIT_SNK_TX:
1528                 case SOFT_RESET:
1529                 case SOFT_RESET_SEND:
1530                         if (port->negotiated_rev >= PD_REV30)
1531                                 tcpm_set_state(port, AMS_START,
1532                                                cc_req == SINK_TX_OK ?
1533                                                PD_T_SINK_TX : 0);
1534                         else
1535                                 tcpm_set_state(port, AMS_START, 0);
1536                         break;
1537                 default:
1538                         if (port->negotiated_rev >= PD_REV30)
1539                                 tcpm_set_state(port, SRC_READY,
1540                                                cc_req == SINK_TX_OK ?
1541                                                PD_T_SINK_TX : 0);
1542                         else
1543                                 tcpm_set_state(port, SRC_READY, 0);
1544                         break;
1545                 }
1546         } else {
1547                 if (port->negotiated_rev >= PD_REV30 &&
1548                     !tcpm_sink_tx_ok(port) &&
1549                     ams != SOFT_RESET_AMS &&
1550                     ams != HARD_RESET) {
1551                         port->upcoming_state = INVALID_STATE;
1552                         tcpm_log(port, "Sink TX No Go");
1553                         return -EAGAIN;
1554                 }
1555
1556                 port->ams = ams;
1557
1558                 if (ams == HARD_RESET) {
1559                         tcpm_pd_transmit(port, TCPC_TX_HARD_RESET, NULL);
1560                         tcpm_set_state(port, HARD_RESET_START, 0);
1561                         return ret;
1562                 } else if (tcpm_vdm_ams(port)) {
1563                         return ret;
1564                 }
1565
1566                 if (port->state == SNK_READY ||
1567                     port->state == SNK_SOFT_RESET)
1568                         tcpm_set_state(port, AMS_START, 0);
1569                 else
1570                         tcpm_set_state(port, SNK_READY, 0);
1571         }
1572
1573         return ret;
1574 }
1575
1576 /*
1577  * VDM/VDO handling functions
1578  */
1579 static void tcpm_queue_vdm(struct tcpm_port *port, const u32 header,
1580                            const u32 *data, int cnt, enum tcpm_transmit_type tx_sop_type)
1581 {
1582         u32 vdo_hdr = port->vdo_data[0];
1583
1584         WARN_ON(!mutex_is_locked(&port->lock));
1585
1586         /* If is sending discover_identity, handle received message first */
1587         if (PD_VDO_SVDM(vdo_hdr) && PD_VDO_CMD(vdo_hdr) == CMD_DISCOVER_IDENT) {
1588                 if (tx_sop_type == TCPC_TX_SOP_PRIME)
1589                         port->send_discover_prime = true;
1590                 else
1591                         port->send_discover = true;
1592                 mod_send_discover_delayed_work(port, SEND_DISCOVER_RETRY_MS);
1593         } else {
1594                 /* Make sure we are not still processing a previous VDM packet */
1595                 WARN_ON(port->vdm_state > VDM_STATE_DONE);
1596         }
1597
1598         port->vdo_count = cnt + 1;
1599         port->vdo_data[0] = header;
1600         memcpy(&port->vdo_data[1], data, sizeof(u32) * cnt);
1601         /* Set ready, vdm state machine will actually send */
1602         port->vdm_retries = 0;
1603         port->vdm_state = VDM_STATE_READY;
1604         port->vdm_sm_running = true;
1605
1606         port->tx_sop_type = tx_sop_type;
1607
1608         mod_vdm_delayed_work(port, 0);
1609 }
1610
1611 static void tcpm_queue_vdm_unlocked(struct tcpm_port *port, const u32 header,
1612                                     const u32 *data, int cnt, enum tcpm_transmit_type tx_sop_type)
1613 {
1614         if (port->state != SRC_READY && port->state != SNK_READY &&
1615             port->state != SRC_VDM_IDENTITY_REQUEST)
1616                 return;
1617
1618         mutex_lock(&port->lock);
1619         tcpm_queue_vdm(port, header, data, cnt, tx_sop_type);
1620         mutex_unlock(&port->lock);
1621 }
1622
1623 static void svdm_consume_identity(struct tcpm_port *port, const u32 *p, int cnt)
1624 {
1625         u32 vdo = p[VDO_INDEX_IDH];
1626         u32 product = p[VDO_INDEX_PRODUCT];
1627
1628         memset(&port->mode_data, 0, sizeof(port->mode_data));
1629
1630         port->partner_ident.id_header = vdo;
1631         port->partner_ident.cert_stat = p[VDO_INDEX_CSTAT];
1632         port->partner_ident.product = product;
1633
1634         if (port->partner)
1635                 typec_partner_set_identity(port->partner);
1636
1637         tcpm_log(port, "Identity: %04x:%04x.%04x",
1638                  PD_IDH_VID(vdo),
1639                  PD_PRODUCT_PID(product), product & 0xffff);
1640 }
1641
1642 static void svdm_consume_identity_sop_prime(struct tcpm_port *port, const u32 *p, int cnt)
1643 {
1644         u32 idh = p[VDO_INDEX_IDH];
1645         u32 product = p[VDO_INDEX_PRODUCT];
1646         int svdm_version;
1647
1648         /*
1649          * Attempt to consume identity only if cable currently is not set
1650          */
1651         if (!IS_ERR_OR_NULL(port->cable))
1652                 goto register_plug;
1653
1654         /* Reset cable identity */
1655         memset(&port->cable_ident, 0, sizeof(port->cable_ident));
1656
1657         /* Fill out id header, cert, product, cable VDO 1 */
1658         port->cable_ident.id_header = idh;
1659         port->cable_ident.cert_stat = p[VDO_INDEX_CSTAT];
1660         port->cable_ident.product = product;
1661         port->cable_ident.vdo[0] = p[VDO_INDEX_CABLE_1];
1662
1663         /* Fill out cable desc, infer svdm_version from pd revision */
1664         port->cable_desc.type = (enum typec_plug_type) (VDO_TYPEC_CABLE_TYPE(p[VDO_INDEX_CABLE_1]) +
1665                                                         USB_PLUG_TYPE_A);
1666         port->cable_desc.active = PD_IDH_PTYPE(idh) == IDH_PTYPE_ACABLE ? 1 : 0;
1667         /* Log PD Revision and additional cable VDO from negotiated revision */
1668         switch (port->negotiated_rev_prime) {
1669         case PD_REV30:
1670                 port->cable_desc.pd_revision = 0x0300;
1671                 if (port->cable_desc.active)
1672                         port->cable_ident.vdo[1] = p[VDO_INDEX_CABLE_2];
1673                 break;
1674         case PD_REV20:
1675                 port->cable_desc.pd_revision = 0x0200;
1676                 break;
1677         default:
1678                 port->cable_desc.pd_revision = 0x0200;
1679                 break;
1680         }
1681         port->cable_desc.identity = &port->cable_ident;
1682         /* Register Cable, set identity and svdm_version */
1683         port->cable = typec_register_cable(port->typec_port, &port->cable_desc);
1684         if (IS_ERR_OR_NULL(port->cable))
1685                 return;
1686         typec_cable_set_identity(port->cable);
1687         /* Get SVDM version */
1688         svdm_version = PD_VDO_SVDM_VER(p[VDO_INDEX_HDR]);
1689         typec_cable_set_svdm_version(port->cable, svdm_version);
1690
1691 register_plug:
1692         if (IS_ERR_OR_NULL(port->plug_prime)) {
1693                 port->plug_prime_desc.index = TYPEC_PLUG_SOP_P;
1694                 port->plug_prime = typec_register_plug(port->cable,
1695                                                        &port->plug_prime_desc);
1696         }
1697 }
1698
1699 static bool svdm_consume_svids(struct tcpm_port *port, const u32 *p, int cnt,
1700                                enum tcpm_transmit_type rx_sop_type)
1701 {
1702         struct pd_mode_data *pmdata = rx_sop_type == TCPC_TX_SOP_PRIME ?
1703                                       &port->mode_data_prime : &port->mode_data;
1704         int i;
1705
1706         for (i = 1; i < cnt; i++) {
1707                 u16 svid;
1708
1709                 svid = (p[i] >> 16) & 0xffff;
1710                 if (!svid)
1711                         return false;
1712
1713                 if (pmdata->nsvids >= SVID_DISCOVERY_MAX)
1714                         goto abort;
1715
1716                 pmdata->svids[pmdata->nsvids++] = svid;
1717                 tcpm_log(port, "SVID %d: 0x%x", pmdata->nsvids, svid);
1718
1719                 svid = p[i] & 0xffff;
1720                 if (!svid)
1721                         return false;
1722
1723                 if (pmdata->nsvids >= SVID_DISCOVERY_MAX)
1724                         goto abort;
1725
1726                 pmdata->svids[pmdata->nsvids++] = svid;
1727                 tcpm_log(port, "SVID %d: 0x%x", pmdata->nsvids, svid);
1728         }
1729
1730         /*
1731          * PD3.0 Spec 6.4.4.3.2: The SVIDs are returned 2 per VDO (see Table
1732          * 6-43), and can be returned maximum 6 VDOs per response (see Figure
1733          * 6-19). If the Respondersupports 12 or more SVID then the Discover
1734          * SVIDs Command Shall be executed multiple times until a Discover
1735          * SVIDs VDO is returned ending either with a SVID value of 0x0000 in
1736          * the last part of the last VDO or with a VDO containing two SVIDs
1737          * with values of 0x0000.
1738          *
1739          * However, some odd dockers support SVIDs less than 12 but without
1740          * 0x0000 in the last VDO, so we need to break the Discover SVIDs
1741          * request and return false here.
1742          */
1743         return cnt == 7;
1744 abort:
1745         tcpm_log(port, "SVID_DISCOVERY_MAX(%d) too low!", SVID_DISCOVERY_MAX);
1746         return false;
1747 }
1748
1749 static void svdm_consume_modes(struct tcpm_port *port, const u32 *p, int cnt,
1750                                enum tcpm_transmit_type rx_sop_type)
1751 {
1752         struct pd_mode_data *pmdata = &port->mode_data;
1753         struct typec_altmode_desc *paltmode;
1754         int i;
1755
1756         switch (rx_sop_type) {
1757         case TCPC_TX_SOP_PRIME:
1758                 pmdata = &port->mode_data_prime;
1759                 if (pmdata->altmodes >= ARRAY_SIZE(port->plug_prime_altmode)) {
1760                         /* Already logged in svdm_consume_svids() */
1761                         return;
1762                 }
1763                 break;
1764         case TCPC_TX_SOP:
1765                 pmdata = &port->mode_data;
1766                 if (pmdata->altmodes >= ARRAY_SIZE(port->partner_altmode)) {
1767                         /* Already logged in svdm_consume_svids() */
1768                         return;
1769                 }
1770                 break;
1771         default:
1772                 return;
1773         }
1774
1775         for (i = 1; i < cnt; i++) {
1776                 paltmode = &pmdata->altmode_desc[pmdata->altmodes];
1777                 memset(paltmode, 0, sizeof(*paltmode));
1778
1779                 paltmode->svid = pmdata->svids[pmdata->svid_index];
1780                 paltmode->mode = i;
1781                 paltmode->vdo = p[i];
1782
1783                 tcpm_log(port, " Alternate mode %d: SVID 0x%04x, VDO %d: 0x%08x",
1784                          pmdata->altmodes, paltmode->svid,
1785                          paltmode->mode, paltmode->vdo);
1786
1787                 pmdata->altmodes++;
1788         }
1789 }
1790
1791 static void tcpm_register_partner_altmodes(struct tcpm_port *port)
1792 {
1793         struct pd_mode_data *modep = &port->mode_data;
1794         struct typec_altmode *altmode;
1795         int i;
1796
1797         if (!port->partner)
1798                 return;
1799
1800         for (i = 0; i < modep->altmodes; i++) {
1801                 altmode = typec_partner_register_altmode(port->partner,
1802                                                 &modep->altmode_desc[i]);
1803                 if (IS_ERR(altmode)) {
1804                         tcpm_log(port, "Failed to register partner SVID 0x%04x",
1805                                  modep->altmode_desc[i].svid);
1806                         altmode = NULL;
1807                 }
1808                 port->partner_altmode[i] = altmode;
1809         }
1810 }
1811
1812 static void tcpm_register_plug_altmodes(struct tcpm_port *port)
1813 {
1814         struct pd_mode_data *modep = &port->mode_data_prime;
1815         struct typec_altmode *altmode;
1816         int i;
1817
1818         typec_plug_set_num_altmodes(port->plug_prime, modep->altmodes);
1819
1820         for (i = 0; i < modep->altmodes; i++) {
1821                 altmode = typec_plug_register_altmode(port->plug_prime,
1822                                                 &modep->altmode_desc[i]);
1823                 if (IS_ERR(altmode)) {
1824                         tcpm_log(port, "Failed to register plug SVID 0x%04x",
1825                                  modep->altmode_desc[i].svid);
1826                         altmode = NULL;
1827                 }
1828                 port->plug_prime_altmode[i] = altmode;
1829         }
1830 }
1831
1832 #define supports_modal(port)    PD_IDH_MODAL_SUPP((port)->partner_ident.id_header)
1833 #define supports_modal_cable(port)     PD_IDH_MODAL_SUPP((port)->cable_ident.id_header)
1834 #define supports_host(port)    PD_IDH_HOST_SUPP((port->partner_ident.id_header))
1835
1836 /*
1837  * Helper to determine whether the port is capable of SOP' communication at the
1838  * current point in time.
1839  */
1840 static bool tcpm_can_communicate_sop_prime(struct tcpm_port *port)
1841 {
1842         /* Check to see if tcpc supports SOP' communication */
1843         if (!port->tcpc->cable_comm_capable || !port->tcpc->cable_comm_capable(port->tcpc))
1844                 return false;
1845         /*
1846          * Power Delivery 2.0 Section 6.3.11
1847          * Before communicating with a Cable Plug a Port Should ensure that it
1848          * is the Vconn Source and that the Cable Plugs are powered by
1849          * performing a Vconn swap if necessary. Since it cannot be guaranteed
1850          * that the present Vconn Source is supplying Vconn, the only means to
1851          * ensure that the Cable Plugs are powered is for a Port wishing to
1852          * communicate with a Cable Plug is to become the Vconn Source.
1853          *
1854          * Power Delivery 3.0 Section 6.3.11
1855          * Before communicating with a Cable Plug a Port Shall ensure that it
1856          * is the Vconn source.
1857          */
1858         if (port->vconn_role != TYPEC_SOURCE)
1859                 return false;
1860         /*
1861          * Power Delivery 2.0 Section 2.4.4
1862          * When no Contract or an Implicit Contract is in place the Source can
1863          * communicate with a Cable Plug using SOP' packets in order to discover
1864          * its characteristics.
1865          *
1866          * Power Delivery 3.0 Section 2.4.4
1867          * When no Contract or an Implicit Contract is in place only the Source
1868          * port that is supplying Vconn is allowed to send packets to a Cable
1869          * Plug and is allowed to respond to packets from the Cable Plug.
1870          */
1871         if (!port->explicit_contract)
1872                 return port->pwr_role == TYPEC_SOURCE;
1873         if (port->negotiated_rev == PD_REV30)
1874                 return true;
1875         /*
1876          * Power Delivery 2.0 Section 2.4.4
1877          *
1878          * When an Explicit Contract is in place the DFP (either the Source or
1879          * the Sink) can communicate with the Cable Plug(s) using SOP’/SOP”
1880          * Packets (see Figure 2-3).
1881          */
1882         if (port->negotiated_rev == PD_REV20)
1883                 return port->data_role == TYPEC_HOST;
1884         return false;
1885 }
1886
1887 static bool tcpm_attempt_vconn_swap_discovery(struct tcpm_port *port)
1888 {
1889         if (!port->tcpc->attempt_vconn_swap_discovery)
1890                 return false;
1891
1892         /* Port is already source, no need to perform swap */
1893         if (port->vconn_role == TYPEC_SOURCE)
1894                 return false;
1895
1896         /*
1897          * Partner needs to support Alternate Modes with modal support. If
1898          * partner is also capable of being a USB Host, it could be a device
1899          * that supports Alternate Modes as the DFP.
1900          */
1901         if (!supports_modal(port) || supports_host(port))
1902                 return false;
1903
1904         if ((port->negotiated_rev == PD_REV20 && port->data_role == TYPEC_HOST) ||
1905             port->negotiated_rev == PD_REV30)
1906                 return port->tcpc->attempt_vconn_swap_discovery(port->tcpc);
1907
1908         return false;
1909 }
1910
1911
1912 static bool tcpm_cable_vdm_supported(struct tcpm_port *port)
1913 {
1914         return !IS_ERR_OR_NULL(port->cable) &&
1915                typec_cable_is_active(port->cable) &&
1916                supports_modal_cable(port) &&
1917                tcpm_can_communicate_sop_prime(port);
1918 }
1919
1920 static int tcpm_pd_svdm(struct tcpm_port *port, struct typec_altmode *adev,
1921                         const u32 *p, int cnt, u32 *response,
1922                         enum adev_actions *adev_action,
1923                         enum tcpm_transmit_type rx_sop_type,
1924                         enum tcpm_transmit_type *response_tx_sop_type)
1925 {
1926         struct typec_port *typec = port->typec_port;
1927         struct typec_altmode *pdev, *pdev_prime;
1928         struct pd_mode_data *modep, *modep_prime;
1929         int svdm_version;
1930         int rlen = 0;
1931         int cmd_type;
1932         int cmd;
1933         int i;
1934         int ret;
1935
1936         cmd_type = PD_VDO_CMDT(p[0]);
1937         cmd = PD_VDO_CMD(p[0]);
1938
1939         tcpm_log(port, "Rx VDM cmd 0x%x type %d cmd %d len %d",
1940                  p[0], cmd_type, cmd, cnt);
1941
1942         switch (rx_sop_type) {
1943         case TCPC_TX_SOP_PRIME:
1944                 modep_prime = &port->mode_data_prime;
1945                 pdev_prime = typec_match_altmode(port->plug_prime_altmode,
1946                                                  ALTMODE_DISCOVERY_MAX,
1947                                                  PD_VDO_VID(p[0]),
1948                                                  PD_VDO_OPOS(p[0]));
1949                 svdm_version = typec_get_cable_svdm_version(typec);
1950                 /*
1951                  * Update SVDM version if cable was discovered before port partner.
1952                  */
1953                 if (!IS_ERR_OR_NULL(port->cable) &&
1954                     PD_VDO_SVDM_VER(p[0]) < svdm_version)
1955                         typec_cable_set_svdm_version(port->cable, svdm_version);
1956                 break;
1957         case TCPC_TX_SOP:
1958                 modep = &port->mode_data;
1959                 pdev = typec_match_altmode(port->partner_altmode,
1960                                            ALTMODE_DISCOVERY_MAX,
1961                                            PD_VDO_VID(p[0]),
1962                                            PD_VDO_OPOS(p[0]));
1963                 svdm_version = typec_get_negotiated_svdm_version(typec);
1964                 if (svdm_version < 0)
1965                         return 0;
1966                 break;
1967         default:
1968                 modep = &port->mode_data;
1969                 pdev = typec_match_altmode(port->partner_altmode,
1970                                            ALTMODE_DISCOVERY_MAX,
1971                                            PD_VDO_VID(p[0]),
1972                                            PD_VDO_OPOS(p[0]));
1973                 svdm_version = typec_get_negotiated_svdm_version(typec);
1974                 if (svdm_version < 0)
1975                         return 0;
1976                 break;
1977         }
1978
1979         switch (cmd_type) {
1980         case CMDT_INIT:
1981                 /*
1982                  * Only the port or port partner is allowed to initialize SVDM
1983                  * commands over SOP'. In case the port partner initializes a
1984                  * sequence when it is not allowed to send SOP' messages, drop
1985                  * the message should the TCPM port try to process it.
1986                  */
1987                 if (rx_sop_type == TCPC_TX_SOP_PRIME)
1988                         return 0;
1989
1990                 switch (cmd) {
1991                 case CMD_DISCOVER_IDENT:
1992                         if (PD_VDO_VID(p[0]) != USB_SID_PD)
1993                                 break;
1994
1995                         if (IS_ERR_OR_NULL(port->partner))
1996                                 break;
1997
1998                         if (PD_VDO_SVDM_VER(p[0]) < svdm_version) {
1999                                 typec_partner_set_svdm_version(port->partner,
2000                                                                PD_VDO_SVDM_VER(p[0]));
2001                                 svdm_version = PD_VDO_SVDM_VER(p[0]);
2002                         }
2003
2004                         port->ams = DISCOVER_IDENTITY;
2005                         /*
2006                          * PD2.0 Spec 6.10.3: respond with NAK as DFP (data host)
2007                          * PD3.1 Spec 6.4.4.2.5.1: respond with NAK if "invalid field" or
2008                          * "wrong configuation" or "Unrecognized"
2009                          */
2010                         if ((port->data_role == TYPEC_DEVICE || svdm_version >= SVDM_VER_2_0) &&
2011                             port->nr_snk_vdo) {
2012                                 if (svdm_version < SVDM_VER_2_0) {
2013                                         for (i = 0; i < port->nr_snk_vdo_v1; i++)
2014                                                 response[i + 1] = port->snk_vdo_v1[i];
2015                                         rlen = port->nr_snk_vdo_v1 + 1;
2016
2017                                 } else {
2018                                         for (i = 0; i < port->nr_snk_vdo; i++)
2019                                                 response[i + 1] = port->snk_vdo[i];
2020                                         rlen = port->nr_snk_vdo + 1;
2021                                 }
2022                         }
2023                         break;
2024                 case CMD_DISCOVER_SVID:
2025                         port->ams = DISCOVER_SVIDS;
2026                         break;
2027                 case CMD_DISCOVER_MODES:
2028                         port->ams = DISCOVER_MODES;
2029                         break;
2030                 case CMD_ENTER_MODE:
2031                         port->ams = DFP_TO_UFP_ENTER_MODE;
2032                         break;
2033                 case CMD_EXIT_MODE:
2034                         port->ams = DFP_TO_UFP_EXIT_MODE;
2035                         break;
2036                 case CMD_ATTENTION:
2037                         /* Attention command does not have response */
2038                         *adev_action = ADEV_ATTENTION;
2039                         return 0;
2040                 default:
2041                         break;
2042                 }
2043                 if (rlen >= 1) {
2044                         response[0] = p[0] | VDO_CMDT(CMDT_RSP_ACK);
2045                 } else if (rlen == 0) {
2046                         response[0] = p[0] | VDO_CMDT(CMDT_RSP_NAK);
2047                         rlen = 1;
2048                 } else {
2049                         response[0] = p[0] | VDO_CMDT(CMDT_RSP_BUSY);
2050                         rlen = 1;
2051                 }
2052                 response[0] = (response[0] & ~VDO_SVDM_VERS_MASK) |
2053                               (VDO_SVDM_VERS(typec_get_negotiated_svdm_version(typec)));
2054                 break;
2055         case CMDT_RSP_ACK:
2056                 /*
2057                  * Silently drop message if we are not connected, but can process
2058                  * if SOP' Discover Identity prior to explicit contract.
2059                  */
2060                 if (IS_ERR_OR_NULL(port->partner) &&
2061                     !(rx_sop_type == TCPC_TX_SOP_PRIME && cmd == CMD_DISCOVER_IDENT))
2062                         break;
2063
2064                 tcpm_ams_finish(port);
2065
2066                 switch (cmd) {
2067                 /*
2068                  * SVDM Command Flow for SOP and SOP':
2069                  * SOP          Discover Identity
2070                  * SOP'         Discover Identity
2071                  * SOP          Discover SVIDs
2072                  *              Discover Modes
2073                  * (Active Cables)
2074                  * SOP'         Discover SVIDs
2075                  *              Discover Modes
2076                  *
2077                  * Perform Discover SOP' if the port can communicate with cable
2078                  * plug.
2079                  */
2080                 case CMD_DISCOVER_IDENT:
2081                         switch (rx_sop_type) {
2082                         case TCPC_TX_SOP:
2083                                 if (PD_VDO_SVDM_VER(p[0]) < svdm_version) {
2084                                         typec_partner_set_svdm_version(port->partner,
2085                                                                        PD_VDO_SVDM_VER(p[0]));
2086                                         /* If cable is discovered before partner, downgrade svdm */
2087                                         if (!IS_ERR_OR_NULL(port->cable) &&
2088                                             (typec_get_cable_svdm_version(port->typec_port) >
2089                                             svdm_version))
2090                                                 typec_cable_set_svdm_version(port->cable,
2091                                                                              svdm_version);
2092                                 }
2093                                 /* 6.4.4.3.1 */
2094                                 svdm_consume_identity(port, p, cnt);
2095                                 /* Attempt Vconn swap, delay SOP' discovery if necessary */
2096                                 if (tcpm_attempt_vconn_swap_discovery(port)) {
2097                                         port->send_discover_prime = true;
2098                                         port->upcoming_state = VCONN_SWAP_SEND;
2099                                         ret = tcpm_ams_start(port, VCONN_SWAP);
2100                                         if (!ret)
2101                                                 return 0;
2102                                         /* Cannot perform Vconn swap */
2103                                         port->upcoming_state = INVALID_STATE;
2104                                         port->send_discover_prime = false;
2105                                 }
2106
2107                                 /*
2108                                  * Attempt Discover Identity on SOP' if the
2109                                  * cable was not discovered previously, and use
2110                                  * the SVDM version of the partner to probe.
2111                                  */
2112                                 if (IS_ERR_OR_NULL(port->cable) &&
2113                                     tcpm_can_communicate_sop_prime(port)) {
2114                                         *response_tx_sop_type = TCPC_TX_SOP_PRIME;
2115                                         port->send_discover_prime = true;
2116                                         response[0] = VDO(USB_SID_PD, 1,
2117                                                           typec_get_negotiated_svdm_version(typec),
2118                                                           CMD_DISCOVER_IDENT);
2119                                         rlen = 1;
2120                                 } else {
2121                                         *response_tx_sop_type = TCPC_TX_SOP;
2122                                         response[0] = VDO(USB_SID_PD, 1,
2123                                                           typec_get_negotiated_svdm_version(typec),
2124                                                           CMD_DISCOVER_SVID);
2125                                         rlen = 1;
2126                                 }
2127                                 break;
2128                         case TCPC_TX_SOP_PRIME:
2129                                 /*
2130                                  * svdm_consume_identity_sop_prime will determine
2131                                  * the svdm_version for the cable moving forward.
2132                                  */
2133                                 svdm_consume_identity_sop_prime(port, p, cnt);
2134
2135                                 /*
2136                                  * If received in SRC_VDM_IDENTITY_REQUEST, continue
2137                                  * to SRC_SEND_CAPABILITIES
2138                                  */
2139                                 if (port->state == SRC_VDM_IDENTITY_REQUEST) {
2140                                         tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
2141                                         return 0;
2142                                 }
2143
2144                                 *response_tx_sop_type = TCPC_TX_SOP;
2145                                 response[0] = VDO(USB_SID_PD, 1,
2146                                                   typec_get_negotiated_svdm_version(typec),
2147                                                   CMD_DISCOVER_SVID);
2148                                 rlen = 1;
2149                                 break;
2150                         default:
2151                                 return 0;
2152                         }
2153                         break;
2154                 case CMD_DISCOVER_SVID:
2155                         *response_tx_sop_type = rx_sop_type;
2156                         /* 6.4.4.3.2 */
2157                         if (svdm_consume_svids(port, p, cnt, rx_sop_type)) {
2158                                 response[0] = VDO(USB_SID_PD, 1, svdm_version, CMD_DISCOVER_SVID);
2159                                 rlen = 1;
2160                         } else {
2161                                 if (rx_sop_type == TCPC_TX_SOP) {
2162                                         if (modep->nsvids && supports_modal(port)) {
2163                                                 response[0] = VDO(modep->svids[0], 1, svdm_version,
2164                                                                 CMD_DISCOVER_MODES);
2165                                                 rlen = 1;
2166                                         }
2167                                 } else if (rx_sop_type == TCPC_TX_SOP_PRIME) {
2168                                         if (modep_prime->nsvids) {
2169                                                 response[0] = VDO(modep_prime->svids[0], 1,
2170                                                                   svdm_version, CMD_DISCOVER_MODES);
2171                                                 rlen = 1;
2172                                         }
2173                                 }
2174                         }
2175                         break;
2176                 case CMD_DISCOVER_MODES:
2177                         if (rx_sop_type == TCPC_TX_SOP) {
2178                                 /* 6.4.4.3.3 */
2179                                 svdm_consume_modes(port, p, cnt, rx_sop_type);
2180                                 modep->svid_index++;
2181                                 if (modep->svid_index < modep->nsvids) {
2182                                         u16 svid = modep->svids[modep->svid_index];
2183                                         *response_tx_sop_type = TCPC_TX_SOP;
2184                                         response[0] = VDO(svid, 1, svdm_version,
2185                                                           CMD_DISCOVER_MODES);
2186                                         rlen = 1;
2187                                 } else if (tcpm_cable_vdm_supported(port)) {
2188                                         *response_tx_sop_type = TCPC_TX_SOP_PRIME;
2189                                         response[0] = VDO(USB_SID_PD, 1,
2190                                                           typec_get_cable_svdm_version(typec),
2191                                                           CMD_DISCOVER_SVID);
2192                                         rlen = 1;
2193                                 } else {
2194                                         tcpm_register_partner_altmodes(port);
2195                                 }
2196                         } else if (rx_sop_type == TCPC_TX_SOP_PRIME) {
2197                                 /* 6.4.4.3.3 */
2198                                 svdm_consume_modes(port, p, cnt, rx_sop_type);
2199                                 modep_prime->svid_index++;
2200                                 if (modep_prime->svid_index < modep_prime->nsvids) {
2201                                         u16 svid = modep_prime->svids[modep_prime->svid_index];
2202                                         *response_tx_sop_type = TCPC_TX_SOP_PRIME;
2203                                         response[0] = VDO(svid, 1,
2204                                                           typec_get_cable_svdm_version(typec),
2205                                                           CMD_DISCOVER_MODES);
2206                                         rlen = 1;
2207                                 } else {
2208                                         tcpm_register_plug_altmodes(port);
2209                                         tcpm_register_partner_altmodes(port);
2210                                 }
2211                         }
2212                         break;
2213                 case CMD_ENTER_MODE:
2214                         *response_tx_sop_type = rx_sop_type;
2215                         if (rx_sop_type == TCPC_TX_SOP) {
2216                                 if (adev && pdev) {
2217                                         typec_altmode_update_active(pdev, true);
2218                                         *adev_action = ADEV_QUEUE_VDM_SEND_EXIT_MODE_ON_FAIL;
2219                                 }
2220                         } else if (rx_sop_type == TCPC_TX_SOP_PRIME) {
2221                                 if (adev && pdev_prime) {
2222                                         typec_altmode_update_active(pdev_prime, true);
2223                                         *adev_action = ADEV_QUEUE_VDM_SEND_EXIT_MODE_ON_FAIL;
2224                                 }
2225                         }
2226                         return 0;
2227                 case CMD_EXIT_MODE:
2228                         *response_tx_sop_type = rx_sop_type;
2229                         if (rx_sop_type == TCPC_TX_SOP) {
2230                                 if (adev && pdev) {
2231                                         typec_altmode_update_active(pdev, false);
2232                                         /* Back to USB Operation */
2233                                         *adev_action = ADEV_NOTIFY_USB_AND_QUEUE_VDM;
2234                                         return 0;
2235                                 }
2236                         }
2237                         break;
2238                 case VDO_CMD_VENDOR(0) ... VDO_CMD_VENDOR(15):
2239                         break;
2240                 default:
2241                         /* Unrecognized SVDM */
2242                         response[0] = p[0] | VDO_CMDT(CMDT_RSP_NAK);
2243                         rlen = 1;
2244                         response[0] = (response[0] & ~VDO_SVDM_VERS_MASK) |
2245                                       (VDO_SVDM_VERS(svdm_version));
2246                         break;
2247                 }
2248                 break;
2249         case CMDT_RSP_NAK:
2250                 tcpm_ams_finish(port);
2251                 switch (cmd) {
2252                 case CMD_DISCOVER_IDENT:
2253                 case CMD_DISCOVER_SVID:
2254                 case CMD_DISCOVER_MODES:
2255                 case VDO_CMD_VENDOR(0) ... VDO_CMD_VENDOR(15):
2256                         break;
2257                 case CMD_ENTER_MODE:
2258                         /* Back to USB Operation */
2259                         *adev_action = ADEV_NOTIFY_USB_AND_QUEUE_VDM;
2260                         return 0;
2261                 default:
2262                         /* Unrecognized SVDM */
2263                         response[0] = p[0] | VDO_CMDT(CMDT_RSP_NAK);
2264                         rlen = 1;
2265                         response[0] = (response[0] & ~VDO_SVDM_VERS_MASK) |
2266                                       (VDO_SVDM_VERS(svdm_version));
2267                         break;
2268                 }
2269                 break;
2270         default:
2271                 response[0] = p[0] | VDO_CMDT(CMDT_RSP_NAK);
2272                 rlen = 1;
2273                 response[0] = (response[0] & ~VDO_SVDM_VERS_MASK) |
2274                               (VDO_SVDM_VERS(svdm_version));
2275                 break;
2276         }
2277
2278         /* Informing the alternate mode drivers about everything */
2279         *adev_action = ADEV_QUEUE_VDM;
2280         return rlen;
2281 }
2282
2283 static void tcpm_pd_handle_msg(struct tcpm_port *port,
2284                                enum pd_msg_request message,
2285                                enum tcpm_ams ams);
2286
2287 static void tcpm_handle_vdm_request(struct tcpm_port *port,
2288                                     const __le32 *payload, int cnt,
2289                                     enum tcpm_transmit_type rx_sop_type)
2290 {
2291         enum adev_actions adev_action = ADEV_NONE;
2292         struct typec_altmode *adev;
2293         u32 p[PD_MAX_PAYLOAD];
2294         u32 response[8] = { };
2295         int i, rlen = 0;
2296         enum tcpm_transmit_type response_tx_sop_type = TCPC_TX_SOP;
2297
2298         for (i = 0; i < cnt; i++)
2299                 p[i] = le32_to_cpu(payload[i]);
2300
2301         adev = typec_match_altmode(port->port_altmode, ALTMODE_DISCOVERY_MAX,
2302                                    PD_VDO_VID(p[0]), PD_VDO_OPOS(p[0]));
2303
2304         if (port->vdm_state == VDM_STATE_BUSY) {
2305                 /* If UFP responded busy retry after timeout */
2306                 if (PD_VDO_CMDT(p[0]) == CMDT_RSP_BUSY) {
2307                         port->vdm_state = VDM_STATE_WAIT_RSP_BUSY;
2308                         port->vdo_retry = (p[0] & ~VDO_CMDT_MASK) |
2309                                 CMDT_INIT;
2310                         mod_vdm_delayed_work(port, PD_T_VDM_BUSY);
2311                         return;
2312                 }
2313                 port->vdm_state = VDM_STATE_DONE;
2314         }
2315
2316         if (PD_VDO_SVDM(p[0]) && (adev || tcpm_vdm_ams(port) || port->nr_snk_vdo)) {
2317                 /*
2318                  * Here a SVDM is received (INIT or RSP or unknown). Set the vdm_sm_running in
2319                  * advance because we are dropping the lock but may send VDMs soon.
2320                  * For the cases of INIT received:
2321                  *  - If no response to send, it will be cleared later in this function.
2322                  *  - If there are responses to send, it will be cleared in the state machine.
2323                  * For the cases of RSP received:
2324                  *  - If no further INIT to send, it will be cleared later in this function.
2325                  *  - Otherwise, it will be cleared in the state machine if timeout or it will go
2326                  *    back here until no further INIT to send.
2327                  * For the cases of unknown type received:
2328                  *  - We will send NAK and the flag will be cleared in the state machine.
2329                  */
2330                 port->vdm_sm_running = true;
2331                 rlen = tcpm_pd_svdm(port, adev, p, cnt, response, &adev_action,
2332                                     rx_sop_type, &response_tx_sop_type);
2333         } else {
2334                 if (port->negotiated_rev >= PD_REV30)
2335                         tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS);
2336         }
2337
2338         /*
2339          * We are done with any state stored in the port struct now, except
2340          * for any port struct changes done by the tcpm_queue_vdm() call
2341          * below, which is a separate operation.
2342          *
2343          * So we can safely release the lock here; and we MUST release the
2344          * lock here to avoid an AB BA lock inversion:
2345          *
2346          * If we keep the lock here then the lock ordering in this path is:
2347          * 1. tcpm_pd_rx_handler take the tcpm port lock
2348          * 2. One of the typec_altmode_* calls below takes the alt-mode's lock
2349          *
2350          * And we also have this ordering:
2351          * 1. alt-mode driver takes the alt-mode's lock
2352          * 2. alt-mode driver calls tcpm_altmode_enter which takes the
2353          *    tcpm port lock
2354          *
2355          * Dropping our lock here avoids this.
2356          */
2357         mutex_unlock(&port->lock);
2358
2359         if (adev) {
2360                 switch (adev_action) {
2361                 case ADEV_NONE:
2362                         break;
2363                 case ADEV_NOTIFY_USB_AND_QUEUE_VDM:
2364                         WARN_ON(typec_altmode_notify(adev, TYPEC_STATE_USB, NULL));
2365                         typec_altmode_vdm(adev, p[0], &p[1], cnt);
2366                         break;
2367                 case ADEV_QUEUE_VDM:
2368                         if (response_tx_sop_type == TCPC_TX_SOP_PRIME)
2369                                 typec_cable_altmode_vdm(adev, TYPEC_PLUG_SOP_P, p[0], &p[1], cnt);
2370                         else
2371                                 typec_altmode_vdm(adev, p[0], &p[1], cnt);
2372                         break;
2373                 case ADEV_QUEUE_VDM_SEND_EXIT_MODE_ON_FAIL:
2374                         if (response_tx_sop_type == TCPC_TX_SOP_PRIME) {
2375                                 if (typec_cable_altmode_vdm(adev, TYPEC_PLUG_SOP_P,
2376                                                             p[0], &p[1], cnt)) {
2377                                         int svdm_version = typec_get_cable_svdm_version(
2378                                                                                 port->typec_port);
2379                                         if (svdm_version < 0)
2380                                                 break;
2381
2382                                         response[0] = VDO(adev->svid, 1, svdm_version,
2383                                                         CMD_EXIT_MODE);
2384                                         response[0] |= VDO_OPOS(adev->mode);
2385                                         rlen = 1;
2386                                 }
2387                         } else {
2388                                 if (typec_altmode_vdm(adev, p[0], &p[1], cnt)) {
2389                                         int svdm_version = typec_get_negotiated_svdm_version(
2390                                                                                 port->typec_port);
2391                                         if (svdm_version < 0)
2392                                                 break;
2393
2394                                         response[0] = VDO(adev->svid, 1, svdm_version,
2395                                                         CMD_EXIT_MODE);
2396                                         response[0] |= VDO_OPOS(adev->mode);
2397                                         rlen = 1;
2398                                 }
2399                         }
2400                         break;
2401                 case ADEV_ATTENTION:
2402                         if (typec_altmode_attention(adev, p[1]))
2403                                 tcpm_log(port, "typec_altmode_attention no port partner altmode");
2404                         break;
2405                 }
2406         }
2407
2408         /*
2409          * We must re-take the lock here to balance the unlock in
2410          * tcpm_pd_rx_handler, note that no changes, other then the
2411          * tcpm_queue_vdm call, are made while the lock is held again.
2412          * All that is done after the call is unwinding the call stack until
2413          * we return to tcpm_pd_rx_handler and do the unlock there.
2414          */
2415         mutex_lock(&port->lock);
2416
2417         if (rlen > 0)
2418                 tcpm_queue_vdm(port, response[0], &response[1], rlen - 1, response_tx_sop_type);
2419         else
2420                 port->vdm_sm_running = false;
2421 }
2422
2423 static void tcpm_send_vdm(struct tcpm_port *port, u32 vid, int cmd,
2424                           const u32 *data, int count, enum tcpm_transmit_type tx_sop_type)
2425 {
2426         int svdm_version;
2427         u32 header;
2428
2429         switch (tx_sop_type) {
2430         case TCPC_TX_SOP_PRIME:
2431                 /*
2432                  * If the port partner is discovered, then the port partner's
2433                  * SVDM Version will be returned
2434                  */
2435                 svdm_version = typec_get_cable_svdm_version(port->typec_port);
2436                 if (svdm_version < 0)
2437                         svdm_version = SVDM_VER_MAX;
2438                 break;
2439         case TCPC_TX_SOP:
2440                 svdm_version = typec_get_negotiated_svdm_version(port->typec_port);
2441                 if (svdm_version < 0)
2442                         return;
2443                 break;
2444         default:
2445                 svdm_version = typec_get_negotiated_svdm_version(port->typec_port);
2446                 if (svdm_version < 0)
2447                         return;
2448                 break;
2449         }
2450
2451         if (WARN_ON(count > VDO_MAX_SIZE - 1))
2452                 count = VDO_MAX_SIZE - 1;
2453
2454         /* set VDM header with VID & CMD */
2455         header = VDO(vid, ((vid & USB_SID_PD) == USB_SID_PD) ?
2456                         1 : (PD_VDO_CMD(cmd) <= CMD_ATTENTION),
2457                         svdm_version, cmd);
2458         tcpm_queue_vdm(port, header, data, count, tx_sop_type);
2459 }
2460
2461 static unsigned int vdm_ready_timeout(u32 vdm_hdr)
2462 {
2463         unsigned int timeout;
2464         int cmd = PD_VDO_CMD(vdm_hdr);
2465
2466         /* its not a structured VDM command */
2467         if (!PD_VDO_SVDM(vdm_hdr))
2468                 return PD_T_VDM_UNSTRUCTURED;
2469
2470         switch (PD_VDO_CMDT(vdm_hdr)) {
2471         case CMDT_INIT:
2472                 if (cmd == CMD_ENTER_MODE || cmd == CMD_EXIT_MODE)
2473                         timeout = PD_T_VDM_WAIT_MODE_E;
2474                 else
2475                         timeout = PD_T_VDM_SNDR_RSP;
2476                 break;
2477         default:
2478                 if (cmd == CMD_ENTER_MODE || cmd == CMD_EXIT_MODE)
2479                         timeout = PD_T_VDM_E_MODE;
2480                 else
2481                         timeout = PD_T_VDM_RCVR_RSP;
2482                 break;
2483         }
2484         return timeout;
2485 }
2486
2487 static void vdm_run_state_machine(struct tcpm_port *port)
2488 {
2489         struct pd_message msg;
2490         int i, res = 0;
2491         u32 vdo_hdr = port->vdo_data[0];
2492         u32 response[8] = { };
2493
2494         switch (port->vdm_state) {
2495         case VDM_STATE_READY:
2496                 /* Only transmit VDM if attached */
2497                 if (!port->attached) {
2498                         port->vdm_state = VDM_STATE_ERR_BUSY;
2499                         break;
2500                 }
2501
2502                 /*
2503                  * if there's traffic or we're not in PDO ready state don't send
2504                  * a VDM.
2505                  */
2506                 if (port->state != SRC_READY && port->state != SNK_READY &&
2507                     port->state != SRC_VDM_IDENTITY_REQUEST) {
2508                         port->vdm_sm_running = false;
2509                         break;
2510                 }
2511
2512                 /* TODO: AMS operation for Unstructured VDM */
2513                 if (PD_VDO_SVDM(vdo_hdr) && PD_VDO_CMDT(vdo_hdr) == CMDT_INIT) {
2514                         switch (PD_VDO_CMD(vdo_hdr)) {
2515                         case CMD_DISCOVER_IDENT:
2516                                 res = tcpm_ams_start(port, DISCOVER_IDENTITY);
2517                                 if (res == 0) {
2518                                         switch (port->tx_sop_type) {
2519                                         case TCPC_TX_SOP_PRIME:
2520                                                 port->send_discover_prime = false;
2521                                                 break;
2522                                         case TCPC_TX_SOP:
2523                                                 port->send_discover = false;
2524                                                 break;
2525                                         default:
2526                                                 port->send_discover = false;
2527                                                 break;
2528                                         }
2529                                 } else if (res == -EAGAIN) {
2530                                         port->vdo_data[0] = 0;
2531                                         mod_send_discover_delayed_work(port,
2532                                                                        SEND_DISCOVER_RETRY_MS);
2533                                 }
2534                                 break;
2535                         case CMD_DISCOVER_SVID:
2536                                 res = tcpm_ams_start(port, DISCOVER_SVIDS);
2537                                 break;
2538                         case CMD_DISCOVER_MODES:
2539                                 res = tcpm_ams_start(port, DISCOVER_MODES);
2540                                 break;
2541                         case CMD_ENTER_MODE:
2542                                 res = tcpm_ams_start(port, DFP_TO_UFP_ENTER_MODE);
2543                                 break;
2544                         case CMD_EXIT_MODE:
2545                                 res = tcpm_ams_start(port, DFP_TO_UFP_EXIT_MODE);
2546                                 break;
2547                         case CMD_ATTENTION:
2548                                 res = tcpm_ams_start(port, ATTENTION);
2549                                 break;
2550                         case VDO_CMD_VENDOR(0) ... VDO_CMD_VENDOR(15):
2551                                 res = tcpm_ams_start(port, STRUCTURED_VDMS);
2552                                 break;
2553                         default:
2554                                 res = -EOPNOTSUPP;
2555                                 break;
2556                         }
2557
2558                         if (res < 0) {
2559                                 port->vdm_state = VDM_STATE_ERR_BUSY;
2560                                 return;
2561                         }
2562                 }
2563
2564                 port->vdm_state = VDM_STATE_SEND_MESSAGE;
2565                 mod_vdm_delayed_work(port, (port->negotiated_rev >= PD_REV30 &&
2566                                             port->pwr_role == TYPEC_SOURCE &&
2567                                             PD_VDO_SVDM(vdo_hdr) &&
2568                                             PD_VDO_CMDT(vdo_hdr) == CMDT_INIT) ?
2569                                            PD_T_SINK_TX : 0);
2570                 break;
2571         case VDM_STATE_WAIT_RSP_BUSY:
2572                 port->vdo_data[0] = port->vdo_retry;
2573                 port->vdo_count = 1;
2574                 port->vdm_state = VDM_STATE_READY;
2575                 tcpm_ams_finish(port);
2576                 break;
2577         case VDM_STATE_BUSY:
2578                 port->vdm_state = VDM_STATE_ERR_TMOUT;
2579                 if (port->ams != NONE_AMS)
2580                         tcpm_ams_finish(port);
2581                 break;
2582         case VDM_STATE_ERR_SEND:
2583                 /*
2584                  * When sending Discover Identity to SOP' before establishing an
2585                  * explicit contract, do not retry. Instead, weave sending
2586                  * Source_Capabilities over SOP and Discover Identity over SOP'.
2587                  */
2588                 if (port->state == SRC_VDM_IDENTITY_REQUEST) {
2589                         tcpm_ams_finish(port);
2590                         port->vdm_state = VDM_STATE_DONE;
2591                         tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
2592                 /*
2593                  * A partner which does not support USB PD will not reply,
2594                  * so this is not a fatal error. At the same time, some
2595                  * devices may not return GoodCRC under some circumstances,
2596                  * so we need to retry.
2597                  */
2598                 } else if (port->vdm_retries < 3) {
2599                         tcpm_log(port, "VDM Tx error, retry");
2600                         port->vdm_retries++;
2601                         port->vdm_state = VDM_STATE_READY;
2602                         if (PD_VDO_SVDM(vdo_hdr) && PD_VDO_CMDT(vdo_hdr) == CMDT_INIT)
2603                                 tcpm_ams_finish(port);
2604                 } else {
2605                         tcpm_ams_finish(port);
2606                         if (port->tx_sop_type == TCPC_TX_SOP)
2607                                 break;
2608                         /* Handle SOP' Transmission Errors */
2609                         switch (PD_VDO_CMD(vdo_hdr)) {
2610                         /*
2611                          * If Discover Identity fails on SOP', then resume
2612                          * discovery process on SOP only.
2613                          */
2614                         case CMD_DISCOVER_IDENT:
2615                                 port->vdo_data[0] = 0;
2616                                 response[0] = VDO(USB_SID_PD, 1,
2617                                                   typec_get_negotiated_svdm_version(
2618                                                                         port->typec_port),
2619                                                   CMD_DISCOVER_SVID);
2620                                 tcpm_queue_vdm(port, response[0], &response[1],
2621                                                0, TCPC_TX_SOP);
2622                                 break;
2623                         /*
2624                          * If Discover SVIDs or Discover Modes fail, then
2625                          * proceed with Alt Mode discovery process on SOP.
2626                          */
2627                         case CMD_DISCOVER_SVID:
2628                                 tcpm_register_partner_altmodes(port);
2629                                 break;
2630                         case CMD_DISCOVER_MODES:
2631                                 tcpm_register_partner_altmodes(port);
2632                                 break;
2633                         default:
2634                                 break;
2635                         }
2636                 }
2637                 break;
2638         case VDM_STATE_SEND_MESSAGE:
2639                 /* Prepare and send VDM */
2640                 memset(&msg, 0, sizeof(msg));
2641                 if (port->tx_sop_type == TCPC_TX_SOP_PRIME) {
2642                         msg.header = PD_HEADER_LE(PD_DATA_VENDOR_DEF,
2643                                                   0,    /* Cable Plug Indicator for DFP/UFP */
2644                                                   0,    /* Reserved */
2645                                                   port->negotiated_rev_prime,
2646                                                   port->message_id_prime,
2647                                                   port->vdo_count);
2648                 } else {
2649                         msg.header = PD_HEADER_LE(PD_DATA_VENDOR_DEF,
2650                                                   port->pwr_role,
2651                                                   port->data_role,
2652                                                   port->negotiated_rev,
2653                                                   port->message_id,
2654                                                   port->vdo_count);
2655                 }
2656                 for (i = 0; i < port->vdo_count; i++)
2657                         msg.payload[i] = cpu_to_le32(port->vdo_data[i]);
2658                 res = tcpm_pd_transmit(port, port->tx_sop_type, &msg);
2659                 if (res < 0) {
2660                         port->vdm_state = VDM_STATE_ERR_SEND;
2661                 } else {
2662                         unsigned long timeout;
2663
2664                         port->vdm_retries = 0;
2665                         port->vdo_data[0] = 0;
2666                         port->vdm_state = VDM_STATE_BUSY;
2667                         timeout = vdm_ready_timeout(vdo_hdr);
2668                         mod_vdm_delayed_work(port, timeout);
2669                 }
2670                 break;
2671         default:
2672                 break;
2673         }
2674 }
2675
2676 static void vdm_state_machine_work(struct kthread_work *work)
2677 {
2678         struct tcpm_port *port = container_of(work, struct tcpm_port, vdm_state_machine);
2679         enum vdm_states prev_state;
2680
2681         mutex_lock(&port->lock);
2682
2683         /*
2684          * Continue running as long as the port is not busy and there was
2685          * a state change.
2686          */
2687         do {
2688                 prev_state = port->vdm_state;
2689                 vdm_run_state_machine(port);
2690         } while (port->vdm_state != prev_state &&
2691                  port->vdm_state != VDM_STATE_BUSY &&
2692                  port->vdm_state != VDM_STATE_SEND_MESSAGE);
2693
2694         if (port->vdm_state < VDM_STATE_READY)
2695                 port->vdm_sm_running = false;
2696
2697         mutex_unlock(&port->lock);
2698 }
2699
2700 enum pdo_err {
2701         PDO_NO_ERR,
2702         PDO_ERR_NO_VSAFE5V,
2703         PDO_ERR_VSAFE5V_NOT_FIRST,
2704         PDO_ERR_PDO_TYPE_NOT_IN_ORDER,
2705         PDO_ERR_FIXED_NOT_SORTED,
2706         PDO_ERR_VARIABLE_BATT_NOT_SORTED,
2707         PDO_ERR_DUPE_PDO,
2708         PDO_ERR_PPS_APDO_NOT_SORTED,
2709         PDO_ERR_DUPE_PPS_APDO,
2710 };
2711
2712 static const char * const pdo_err_msg[] = {
2713         [PDO_ERR_NO_VSAFE5V] =
2714         " err: source/sink caps should at least have vSafe5V",
2715         [PDO_ERR_VSAFE5V_NOT_FIRST] =
2716         " err: vSafe5V Fixed Supply Object Shall always be the first object",
2717         [PDO_ERR_PDO_TYPE_NOT_IN_ORDER] =
2718         " err: PDOs should be in the following order: Fixed; Battery; Variable",
2719         [PDO_ERR_FIXED_NOT_SORTED] =
2720         " err: Fixed supply pdos should be in increasing order of their fixed voltage",
2721         [PDO_ERR_VARIABLE_BATT_NOT_SORTED] =
2722         " err: Variable/Battery supply pdos should be in increasing order of their minimum voltage",
2723         [PDO_ERR_DUPE_PDO] =
2724         " err: Variable/Batt supply pdos cannot have same min/max voltage",
2725         [PDO_ERR_PPS_APDO_NOT_SORTED] =
2726         " err: Programmable power supply apdos should be in increasing order of their maximum voltage",
2727         [PDO_ERR_DUPE_PPS_APDO] =
2728         " err: Programmable power supply apdos cannot have same min/max voltage and max current",
2729 };
2730
2731 static enum pdo_err tcpm_caps_err(struct tcpm_port *port, const u32 *pdo,
2732                                   unsigned int nr_pdo)
2733 {
2734         unsigned int i;
2735
2736         /* Should at least contain vSafe5v */
2737         if (nr_pdo < 1)
2738                 return PDO_ERR_NO_VSAFE5V;
2739
2740         /* The vSafe5V Fixed Supply Object Shall always be the first object */
2741         if (pdo_type(pdo[0]) != PDO_TYPE_FIXED ||
2742             pdo_fixed_voltage(pdo[0]) != VSAFE5V)
2743                 return PDO_ERR_VSAFE5V_NOT_FIRST;
2744
2745         for (i = 1; i < nr_pdo; i++) {
2746                 if (pdo_type(pdo[i]) < pdo_type(pdo[i - 1])) {
2747                         return PDO_ERR_PDO_TYPE_NOT_IN_ORDER;
2748                 } else if (pdo_type(pdo[i]) == pdo_type(pdo[i - 1])) {
2749                         enum pd_pdo_type type = pdo_type(pdo[i]);
2750
2751                         switch (type) {
2752                         /*
2753                          * The remaining Fixed Supply Objects, if
2754                          * present, shall be sent in voltage order;
2755                          * lowest to highest.
2756                          */
2757                         case PDO_TYPE_FIXED:
2758                                 if (pdo_fixed_voltage(pdo[i]) <=
2759                                     pdo_fixed_voltage(pdo[i - 1]))
2760                                         return PDO_ERR_FIXED_NOT_SORTED;
2761                                 break;
2762                         /*
2763                          * The Battery Supply Objects and Variable
2764                          * supply, if present shall be sent in Minimum
2765                          * Voltage order; lowest to highest.
2766                          */
2767                         case PDO_TYPE_VAR:
2768                         case PDO_TYPE_BATT:
2769                                 if (pdo_min_voltage(pdo[i]) <
2770                                     pdo_min_voltage(pdo[i - 1]))
2771                                         return PDO_ERR_VARIABLE_BATT_NOT_SORTED;
2772                                 else if ((pdo_min_voltage(pdo[i]) ==
2773                                           pdo_min_voltage(pdo[i - 1])) &&
2774                                          (pdo_max_voltage(pdo[i]) ==
2775                                           pdo_max_voltage(pdo[i - 1])))
2776                                         return PDO_ERR_DUPE_PDO;
2777                                 break;
2778                         /*
2779                          * The Programmable Power Supply APDOs, if present,
2780                          * shall be sent in Maximum Voltage order;
2781                          * lowest to highest.
2782                          */
2783                         case PDO_TYPE_APDO:
2784                                 if (pdo_apdo_type(pdo[i]) != APDO_TYPE_PPS)
2785                                         break;
2786
2787                                 if (pdo_pps_apdo_max_voltage(pdo[i]) <
2788                                     pdo_pps_apdo_max_voltage(pdo[i - 1]))
2789                                         return PDO_ERR_PPS_APDO_NOT_SORTED;
2790                                 else if (pdo_pps_apdo_min_voltage(pdo[i]) ==
2791                                           pdo_pps_apdo_min_voltage(pdo[i - 1]) &&
2792                                          pdo_pps_apdo_max_voltage(pdo[i]) ==
2793                                           pdo_pps_apdo_max_voltage(pdo[i - 1]) &&
2794                                          pdo_pps_apdo_max_current(pdo[i]) ==
2795                                           pdo_pps_apdo_max_current(pdo[i - 1]))
2796                                         return PDO_ERR_DUPE_PPS_APDO;
2797                                 break;
2798                         default:
2799                                 tcpm_log_force(port, " Unknown pdo type");
2800                         }
2801                 }
2802         }
2803
2804         return PDO_NO_ERR;
2805 }
2806
2807 static int tcpm_validate_caps(struct tcpm_port *port, const u32 *pdo,
2808                               unsigned int nr_pdo)
2809 {
2810         enum pdo_err err_index = tcpm_caps_err(port, pdo, nr_pdo);
2811
2812         if (err_index != PDO_NO_ERR) {
2813                 tcpm_log_force(port, " %s", pdo_err_msg[err_index]);
2814                 return -EINVAL;
2815         }
2816
2817         return 0;
2818 }
2819
2820 static int tcpm_altmode_enter(struct typec_altmode *altmode, u32 *vdo)
2821 {
2822         struct tcpm_port *port = typec_altmode_get_drvdata(altmode);
2823         int svdm_version;
2824         u32 header;
2825
2826         svdm_version = typec_get_negotiated_svdm_version(port->typec_port);
2827         if (svdm_version < 0)
2828                 return svdm_version;
2829
2830         header = VDO(altmode->svid, vdo ? 2 : 1, svdm_version, CMD_ENTER_MODE);
2831         header |= VDO_OPOS(altmode->mode);
2832
2833         tcpm_queue_vdm_unlocked(port, header, vdo, vdo ? 1 : 0, TCPC_TX_SOP);
2834         return 0;
2835 }
2836
2837 static int tcpm_altmode_exit(struct typec_altmode *altmode)
2838 {
2839         struct tcpm_port *port = typec_altmode_get_drvdata(altmode);
2840         int svdm_version;
2841         u32 header;
2842
2843         svdm_version = typec_get_negotiated_svdm_version(port->typec_port);
2844         if (svdm_version < 0)
2845                 return svdm_version;
2846
2847         header = VDO(altmode->svid, 1, svdm_version, CMD_EXIT_MODE);
2848         header |= VDO_OPOS(altmode->mode);
2849
2850         tcpm_queue_vdm_unlocked(port, header, NULL, 0, TCPC_TX_SOP);
2851         return 0;
2852 }
2853
2854 static int tcpm_altmode_vdm(struct typec_altmode *altmode,
2855                             u32 header, const u32 *data, int count)
2856 {
2857         struct tcpm_port *port = typec_altmode_get_drvdata(altmode);
2858
2859         tcpm_queue_vdm_unlocked(port, header, data, count - 1, TCPC_TX_SOP);
2860
2861         return 0;
2862 }
2863
2864 static const struct typec_altmode_ops tcpm_altmode_ops = {
2865         .enter = tcpm_altmode_enter,
2866         .exit = tcpm_altmode_exit,
2867         .vdm = tcpm_altmode_vdm,
2868 };
2869
2870
2871 static int tcpm_cable_altmode_enter(struct typec_altmode *altmode, enum typec_plug_index sop,
2872                                     u32 *vdo)
2873 {
2874         struct tcpm_port *port = typec_altmode_get_drvdata(altmode);
2875         int svdm_version;
2876         u32 header;
2877
2878         svdm_version = typec_get_cable_svdm_version(port->typec_port);
2879         if (svdm_version < 0)
2880                 return svdm_version;
2881
2882         header = VDO(altmode->svid, vdo ? 2 : 1, svdm_version, CMD_ENTER_MODE);
2883         header |= VDO_OPOS(altmode->mode);
2884
2885         tcpm_queue_vdm_unlocked(port, header, vdo, vdo ? 1 : 0, TCPC_TX_SOP_PRIME);
2886         return 0;
2887 }
2888
2889 static int tcpm_cable_altmode_exit(struct typec_altmode *altmode, enum typec_plug_index sop)
2890 {
2891         struct tcpm_port *port = typec_altmode_get_drvdata(altmode);
2892         int svdm_version;
2893         u32 header;
2894
2895         svdm_version = typec_get_cable_svdm_version(port->typec_port);
2896         if (svdm_version < 0)
2897                 return svdm_version;
2898
2899         header = VDO(altmode->svid, 1, svdm_version, CMD_EXIT_MODE);
2900         header |= VDO_OPOS(altmode->mode);
2901
2902         tcpm_queue_vdm_unlocked(port, header, NULL, 0, TCPC_TX_SOP_PRIME);
2903         return 0;
2904 }
2905
2906 static int tcpm_cable_altmode_vdm(struct typec_altmode *altmode, enum typec_plug_index sop,
2907                                   u32 header, const u32 *data, int count)
2908 {
2909         struct tcpm_port *port = typec_altmode_get_drvdata(altmode);
2910
2911         tcpm_queue_vdm_unlocked(port, header, data, count - 1, TCPC_TX_SOP_PRIME);
2912
2913         return 0;
2914 }
2915
2916 static const struct typec_cable_ops tcpm_cable_ops = {
2917         .enter = tcpm_cable_altmode_enter,
2918         .exit = tcpm_cable_altmode_exit,
2919         .vdm = tcpm_cable_altmode_vdm,
2920 };
2921
2922 /*
2923  * PD (data, control) command handling functions
2924  */
2925 static inline enum tcpm_state ready_state(struct tcpm_port *port)
2926 {
2927         if (port->pwr_role == TYPEC_SOURCE)
2928                 return SRC_READY;
2929         else
2930                 return SNK_READY;
2931 }
2932
2933 static int tcpm_pd_send_control(struct tcpm_port *port,
2934                                 enum pd_ctrl_msg_type type,
2935                                 enum tcpm_transmit_type tx_sop_type);
2936
2937 static void tcpm_handle_alert(struct tcpm_port *port, const __le32 *payload,
2938                               int cnt)
2939 {
2940         u32 p0 = le32_to_cpu(payload[0]);
2941         unsigned int type = usb_pd_ado_type(p0);
2942
2943         if (!type) {
2944                 tcpm_log(port, "Alert message received with no type");
2945                 tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP);
2946                 return;
2947         }
2948
2949         /* Just handling non-battery alerts for now */
2950         if (!(type & USB_PD_ADO_TYPE_BATT_STATUS_CHANGE)) {
2951                 if (port->pwr_role == TYPEC_SOURCE) {
2952                         port->upcoming_state = GET_STATUS_SEND;
2953                         tcpm_ams_start(port, GETTING_SOURCE_SINK_STATUS);
2954                 } else {
2955                         /*
2956                          * Do not check SinkTxOk here in case the Source doesn't set its Rp to
2957                          * SinkTxOk in time.
2958                          */
2959                         port->ams = GETTING_SOURCE_SINK_STATUS;
2960                         tcpm_set_state(port, GET_STATUS_SEND, 0);
2961                 }
2962         } else {
2963                 tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP);
2964         }
2965 }
2966
2967 static int tcpm_set_auto_vbus_discharge_threshold(struct tcpm_port *port,
2968                                                   enum typec_pwr_opmode mode, bool pps_active,
2969                                                   u32 requested_vbus_voltage)
2970 {
2971         int ret;
2972
2973         if (!port->tcpc->set_auto_vbus_discharge_threshold)
2974                 return 0;
2975
2976         ret = port->tcpc->set_auto_vbus_discharge_threshold(port->tcpc, mode, pps_active,
2977                                                             requested_vbus_voltage,
2978                                                             port->pps_data.min_volt);
2979         tcpm_log_force(port,
2980                        "set_auto_vbus_discharge_threshold mode:%d pps_active:%c vbus:%u pps_apdo_min_volt:%u ret:%d",
2981                        mode, pps_active ? 'y' : 'n', requested_vbus_voltage,
2982                        port->pps_data.min_volt, ret);
2983
2984         return ret;
2985 }
2986
2987 static void tcpm_pd_handle_state(struct tcpm_port *port,
2988                                  enum tcpm_state state,
2989                                  enum tcpm_ams ams,
2990                                  unsigned int delay_ms)
2991 {
2992         switch (port->state) {
2993         case SRC_READY:
2994         case SNK_READY:
2995                 port->ams = ams;
2996                 tcpm_set_state(port, state, delay_ms);
2997                 break;
2998         /* 8.3.3.4.1.1 and 6.8.1 power transitioning */
2999         case SNK_TRANSITION_SINK:
3000         case SNK_TRANSITION_SINK_VBUS:
3001         case SRC_TRANSITION_SUPPLY:
3002                 tcpm_set_state(port, HARD_RESET_SEND, 0);
3003                 break;
3004         default:
3005                 if (!tcpm_ams_interruptible(port)) {
3006                         tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ?
3007                                        SRC_SOFT_RESET_WAIT_SNK_TX :
3008                                        SNK_SOFT_RESET,
3009                                        0);
3010                 } else {
3011                         /* process the Message 6.8.1 */
3012                         port->upcoming_state = state;
3013                         port->next_ams = ams;
3014                         tcpm_set_state(port, ready_state(port), delay_ms);
3015                 }
3016                 break;
3017         }
3018 }
3019
3020 static void tcpm_pd_handle_msg(struct tcpm_port *port,
3021                                enum pd_msg_request message,
3022                                enum tcpm_ams ams)
3023 {
3024         switch (port->state) {
3025         case SRC_READY:
3026         case SNK_READY:
3027                 port->ams = ams;
3028                 tcpm_queue_message(port, message);
3029                 break;
3030         /* PD 3.0 Spec 8.3.3.4.1.1 and 6.8.1 */
3031         case SNK_TRANSITION_SINK:
3032         case SNK_TRANSITION_SINK_VBUS:
3033         case SRC_TRANSITION_SUPPLY:
3034                 tcpm_set_state(port, HARD_RESET_SEND, 0);
3035                 break;
3036         default:
3037                 if (!tcpm_ams_interruptible(port)) {
3038                         tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ?
3039                                        SRC_SOFT_RESET_WAIT_SNK_TX :
3040                                        SNK_SOFT_RESET,
3041                                        0);
3042                 } else {
3043                         port->next_ams = ams;
3044                         tcpm_set_state(port, ready_state(port), 0);
3045                         /* 6.8.1 process the Message */
3046                         tcpm_queue_message(port, message);
3047                 }
3048                 break;
3049         }
3050 }
3051
3052 static int tcpm_register_source_caps(struct tcpm_port *port)
3053 {
3054         struct usb_power_delivery_desc desc = { port->negotiated_rev };
3055         struct usb_power_delivery_capabilities_desc caps = { };
3056         struct usb_power_delivery_capabilities *cap = port->partner_source_caps;
3057
3058         if (!port->partner_pd)
3059                 port->partner_pd = usb_power_delivery_register(NULL, &desc);
3060         if (IS_ERR(port->partner_pd))
3061                 return PTR_ERR(port->partner_pd);
3062
3063         memcpy(caps.pdo, port->source_caps, sizeof(u32) * port->nr_source_caps);
3064         caps.role = TYPEC_SOURCE;
3065
3066         if (cap) {
3067                 usb_power_delivery_unregister_capabilities(cap);
3068                 port->partner_source_caps = NULL;
3069         }
3070
3071         cap = usb_power_delivery_register_capabilities(port->partner_pd, &caps);
3072         if (IS_ERR(cap))
3073                 return PTR_ERR(cap);
3074
3075         port->partner_source_caps = cap;
3076
3077         return 0;
3078 }
3079
3080 static int tcpm_register_sink_caps(struct tcpm_port *port)
3081 {
3082         struct usb_power_delivery_desc desc = { port->negotiated_rev };
3083         struct usb_power_delivery_capabilities_desc caps = { };
3084         struct usb_power_delivery_capabilities *cap;
3085
3086         if (!port->partner_pd)
3087                 port->partner_pd = usb_power_delivery_register(NULL, &desc);
3088         if (IS_ERR(port->partner_pd))
3089                 return PTR_ERR(port->partner_pd);
3090
3091         memcpy(caps.pdo, port->sink_caps, sizeof(u32) * port->nr_sink_caps);
3092         caps.role = TYPEC_SINK;
3093
3094         cap = usb_power_delivery_register_capabilities(port->partner_pd, &caps);
3095         if (IS_ERR(cap))
3096                 return PTR_ERR(cap);
3097
3098         port->partner_sink_caps = cap;
3099
3100         return 0;
3101 }
3102
3103 static void tcpm_pd_data_request(struct tcpm_port *port,
3104                                  const struct pd_message *msg,
3105                                  enum tcpm_transmit_type rx_sop_type)
3106 {
3107         enum pd_data_msg_type type = pd_header_type_le(msg->header);
3108         unsigned int cnt = pd_header_cnt_le(msg->header);
3109         unsigned int rev = pd_header_rev_le(msg->header);
3110         unsigned int i;
3111         enum frs_typec_current partner_frs_current;
3112         bool frs_enable;
3113         int ret;
3114
3115         if (tcpm_vdm_ams(port) && type != PD_DATA_VENDOR_DEF) {
3116                 port->vdm_state = VDM_STATE_ERR_BUSY;
3117                 tcpm_ams_finish(port);
3118                 mod_vdm_delayed_work(port, 0);
3119         }
3120
3121         switch (type) {
3122         case PD_DATA_SOURCE_CAP:
3123                 for (i = 0; i < cnt; i++)
3124                         port->source_caps[i] = le32_to_cpu(msg->payload[i]);
3125
3126                 port->nr_source_caps = cnt;
3127
3128                 tcpm_log_source_caps(port);
3129
3130                 tcpm_validate_caps(port, port->source_caps,
3131                                    port->nr_source_caps);
3132
3133                 tcpm_register_source_caps(port);
3134
3135                 /*
3136                  * Adjust revision in subsequent message headers, as required,
3137                  * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't
3138                  * support Rev 1.0 so just do nothing in that scenario.
3139                  */
3140                 if (rev == PD_REV10) {
3141                         if (port->ams == GET_SOURCE_CAPABILITIES)
3142                                 tcpm_ams_finish(port);
3143                         break;
3144                 }
3145
3146                 if (rev < PD_MAX_REV) {
3147                         port->negotiated_rev = rev;
3148                         if (port->negotiated_rev_prime > port->negotiated_rev)
3149                                 port->negotiated_rev_prime = port->negotiated_rev;
3150                 }
3151
3152                 if (port->pwr_role == TYPEC_SOURCE) {
3153                         if (port->ams == GET_SOURCE_CAPABILITIES)
3154                                 tcpm_pd_handle_state(port, SRC_READY, NONE_AMS, 0);
3155                         /* Unexpected Source Capabilities */
3156                         else
3157                                 tcpm_pd_handle_msg(port,
3158                                                    port->negotiated_rev < PD_REV30 ?
3159                                                    PD_MSG_CTRL_REJECT :
3160                                                    PD_MSG_CTRL_NOT_SUPP,
3161                                                    NONE_AMS);
3162                 } else if (port->state == SNK_WAIT_CAPABILITIES ||
3163                            port->state == SNK_WAIT_CAPABILITIES_TIMEOUT) {
3164                 /*
3165                  * This message may be received even if VBUS is not
3166                  * present. This is quite unexpected; see USB PD
3167                  * specification, sections 8.3.3.6.3.1 and 8.3.3.6.3.2.
3168                  * However, at the same time, we must be ready to
3169                  * receive this message and respond to it 15ms after
3170                  * receiving PS_RDY during power swap operations, no matter
3171                  * if VBUS is available or not (USB PD specification,
3172                  * section 6.5.9.2).
3173                  * So we need to accept the message either way,
3174                  * but be prepared to keep waiting for VBUS after it was
3175                  * handled.
3176                  */
3177                         port->ams = POWER_NEGOTIATION;
3178                         port->in_ams = true;
3179                         tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0);
3180                 } else {
3181                         if (port->ams == GET_SOURCE_CAPABILITIES)
3182                                 tcpm_ams_finish(port);
3183                         tcpm_pd_handle_state(port, SNK_NEGOTIATE_CAPABILITIES,
3184                                              POWER_NEGOTIATION, 0);
3185                 }
3186                 break;
3187         case PD_DATA_REQUEST:
3188                 /*
3189                  * Adjust revision in subsequent message headers, as required,
3190                  * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't
3191                  * support Rev 1.0 so just reject in that scenario.
3192                  */
3193                 if (rev == PD_REV10) {
3194                         tcpm_pd_handle_msg(port,
3195                                            port->negotiated_rev < PD_REV30 ?
3196                                            PD_MSG_CTRL_REJECT :
3197                                            PD_MSG_CTRL_NOT_SUPP,
3198                                            NONE_AMS);
3199                         break;
3200                 }
3201
3202                 if (rev < PD_MAX_REV) {
3203                         port->negotiated_rev = rev;
3204                         if (port->negotiated_rev_prime > port->negotiated_rev)
3205                                 port->negotiated_rev_prime = port->negotiated_rev;
3206                 }
3207
3208                 if (port->pwr_role != TYPEC_SOURCE || cnt != 1) {
3209                         tcpm_pd_handle_msg(port,
3210                                            port->negotiated_rev < PD_REV30 ?
3211                                            PD_MSG_CTRL_REJECT :
3212                                            PD_MSG_CTRL_NOT_SUPP,
3213                                            NONE_AMS);
3214                         break;
3215                 }
3216
3217                 port->sink_request = le32_to_cpu(msg->payload[0]);
3218
3219                 if (port->vdm_sm_running && port->explicit_contract) {
3220                         tcpm_pd_handle_msg(port, PD_MSG_CTRL_WAIT, port->ams);
3221                         break;
3222                 }
3223
3224                 if (port->state == SRC_SEND_CAPABILITIES)
3225                         tcpm_set_state(port, SRC_NEGOTIATE_CAPABILITIES, 0);
3226                 else
3227                         tcpm_pd_handle_state(port, SRC_NEGOTIATE_CAPABILITIES,
3228                                              POWER_NEGOTIATION, 0);
3229                 break;
3230         case PD_DATA_SINK_CAP:
3231                 /* We don't do anything with this at the moment... */
3232                 for (i = 0; i < cnt; i++)
3233                         port->sink_caps[i] = le32_to_cpu(msg->payload[i]);
3234
3235                 partner_frs_current = (port->sink_caps[0] & PDO_FIXED_FRS_CURR_MASK) >>
3236                         PDO_FIXED_FRS_CURR_SHIFT;
3237                 frs_enable = partner_frs_current && (partner_frs_current <=
3238                                                      port->new_source_frs_current);
3239                 tcpm_log(port,
3240                          "Port partner FRS capable partner_frs_current:%u port_frs_current:%u enable:%c",
3241                          partner_frs_current, port->new_source_frs_current, frs_enable ? 'y' : 'n');
3242                 if (frs_enable) {
3243                         ret  = port->tcpc->enable_frs(port->tcpc, true);
3244                         tcpm_log(port, "Enable FRS %s, ret:%d\n", ret ? "fail" : "success", ret);
3245                 }
3246
3247                 port->nr_sink_caps = cnt;
3248                 port->sink_cap_done = true;
3249                 tcpm_register_sink_caps(port);
3250
3251                 if (port->ams == GET_SINK_CAPABILITIES)
3252                         tcpm_set_state(port, ready_state(port), 0);
3253                 /* Unexpected Sink Capabilities */
3254                 else
3255                         tcpm_pd_handle_msg(port,
3256                                            port->negotiated_rev < PD_REV30 ?
3257                                            PD_MSG_CTRL_REJECT :
3258                                            PD_MSG_CTRL_NOT_SUPP,
3259                                            NONE_AMS);
3260                 break;
3261         case PD_DATA_VENDOR_DEF:
3262                 tcpm_handle_vdm_request(port, msg->payload, cnt, rx_sop_type);
3263                 break;
3264         case PD_DATA_BIST:
3265                 port->bist_request = le32_to_cpu(msg->payload[0]);
3266                 tcpm_pd_handle_state(port, BIST_RX, BIST, 0);
3267                 break;
3268         case PD_DATA_ALERT:
3269                 if (port->state != SRC_READY && port->state != SNK_READY)
3270                         tcpm_pd_handle_state(port, port->pwr_role == TYPEC_SOURCE ?
3271                                              SRC_SOFT_RESET_WAIT_SNK_TX : SNK_SOFT_RESET,
3272                                              NONE_AMS, 0);
3273                 else
3274                         tcpm_handle_alert(port, msg->payload, cnt);
3275                 break;
3276         case PD_DATA_BATT_STATUS:
3277         case PD_DATA_GET_COUNTRY_INFO:
3278                 /* Currently unsupported */
3279                 tcpm_pd_handle_msg(port, port->negotiated_rev < PD_REV30 ?
3280                                    PD_MSG_CTRL_REJECT :
3281                                    PD_MSG_CTRL_NOT_SUPP,
3282                                    NONE_AMS);
3283                 break;
3284         default:
3285                 tcpm_pd_handle_msg(port, port->negotiated_rev < PD_REV30 ?
3286                                    PD_MSG_CTRL_REJECT :
3287                                    PD_MSG_CTRL_NOT_SUPP,
3288                                    NONE_AMS);
3289                 tcpm_log(port, "Unrecognized data message type %#x", type);
3290                 break;
3291         }
3292 }
3293
3294 static void tcpm_pps_complete(struct tcpm_port *port, int result)
3295 {
3296         if (port->pps_pending) {
3297                 port->pps_status = result;
3298                 port->pps_pending = false;
3299                 complete(&port->pps_complete);
3300         }
3301 }
3302
3303 static void tcpm_pd_ctrl_request(struct tcpm_port *port,
3304                                  const struct pd_message *msg,
3305                                  enum tcpm_transmit_type rx_sop_type)
3306 {
3307         enum pd_ctrl_msg_type type = pd_header_type_le(msg->header);
3308         enum tcpm_state next_state;
3309         unsigned int rev = pd_header_rev_le(msg->header);
3310
3311         /*
3312          * Stop VDM state machine if interrupted by other Messages while NOT_SUPP is allowed in
3313          * VDM AMS if waiting for VDM responses and will be handled later.
3314          */
3315         if (tcpm_vdm_ams(port) && type != PD_CTRL_NOT_SUPP && type != PD_CTRL_GOOD_CRC) {
3316                 port->vdm_state = VDM_STATE_ERR_BUSY;
3317                 tcpm_ams_finish(port);
3318                 mod_vdm_delayed_work(port, 0);
3319         }
3320
3321         switch (type) {
3322         case PD_CTRL_GOOD_CRC:
3323         case PD_CTRL_PING:
3324                 break;
3325         case PD_CTRL_GET_SOURCE_CAP:
3326                 tcpm_pd_handle_msg(port, PD_MSG_DATA_SOURCE_CAP, GET_SOURCE_CAPABILITIES);
3327                 break;
3328         case PD_CTRL_GET_SINK_CAP:
3329                 tcpm_pd_handle_msg(port, PD_MSG_DATA_SINK_CAP, GET_SINK_CAPABILITIES);
3330                 break;
3331         case PD_CTRL_GOTO_MIN:
3332                 break;
3333         case PD_CTRL_PS_RDY:
3334                 switch (port->state) {
3335                 case SNK_TRANSITION_SINK:
3336                         if (port->vbus_present) {
3337                                 tcpm_set_current_limit(port,
3338                                                        port->req_current_limit,
3339                                                        port->req_supply_voltage);
3340                                 port->explicit_contract = true;
3341                                 tcpm_set_auto_vbus_discharge_threshold(port,
3342                                                                        TYPEC_PWR_MODE_PD,
3343                                                                        port->pps_data.active,
3344                                                                        port->supply_voltage);
3345                                 tcpm_set_state(port, SNK_READY, 0);
3346                         } else {
3347                                 /*
3348                                  * Seen after power swap. Keep waiting for VBUS
3349                                  * in a transitional state.
3350                                  */
3351                                 tcpm_set_state(port,
3352                                                SNK_TRANSITION_SINK_VBUS, 0);
3353                         }
3354                         break;
3355                 case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED:
3356                         tcpm_set_state(port, PR_SWAP_SRC_SNK_SINK_ON, 0);
3357                         break;
3358                 case PR_SWAP_SNK_SRC_SINK_OFF:
3359                         tcpm_set_state(port, PR_SWAP_SNK_SRC_SOURCE_ON, 0);
3360                         break;
3361                 case VCONN_SWAP_WAIT_FOR_VCONN:
3362                         tcpm_set_state(port, VCONN_SWAP_TURN_OFF_VCONN, 0);
3363                         break;
3364                 case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF:
3365                         tcpm_set_state(port, FR_SWAP_SNK_SRC_NEW_SINK_READY, 0);
3366                         break;
3367                 default:
3368                         tcpm_pd_handle_state(port,
3369                                              port->pwr_role == TYPEC_SOURCE ?
3370                                              SRC_SOFT_RESET_WAIT_SNK_TX :
3371                                              SNK_SOFT_RESET,
3372                                              NONE_AMS, 0);
3373                         break;
3374                 }
3375                 break;
3376         case PD_CTRL_REJECT:
3377         case PD_CTRL_WAIT:
3378         case PD_CTRL_NOT_SUPP:
3379                 switch (port->state) {
3380                 case SNK_NEGOTIATE_CAPABILITIES:
3381                         /* USB PD specification, Figure 8-43 */
3382                         if (port->explicit_contract)
3383                                 next_state = SNK_READY;
3384                         else
3385                                 next_state = SNK_WAIT_CAPABILITIES;
3386
3387                         /* Threshold was relaxed before sending Request. Restore it back. */
3388                         tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_PD,
3389                                                                port->pps_data.active,
3390                                                                port->supply_voltage);
3391                         tcpm_set_state(port, next_state, 0);
3392                         break;
3393                 case SNK_NEGOTIATE_PPS_CAPABILITIES:
3394                         /* Revert data back from any requested PPS updates */
3395                         port->pps_data.req_out_volt = port->supply_voltage;
3396                         port->pps_data.req_op_curr = port->current_limit;
3397                         port->pps_status = (type == PD_CTRL_WAIT ?
3398                                             -EAGAIN : -EOPNOTSUPP);
3399
3400                         /* Threshold was relaxed before sending Request. Restore it back. */
3401                         tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_PD,
3402                                                                port->pps_data.active,
3403                                                                port->supply_voltage);
3404
3405                         tcpm_set_state(port, SNK_READY, 0);
3406                         break;
3407                 case DR_SWAP_SEND:
3408                         port->swap_status = (type == PD_CTRL_WAIT ?
3409                                              -EAGAIN : -EOPNOTSUPP);
3410                         tcpm_set_state(port, DR_SWAP_CANCEL, 0);
3411                         break;
3412                 case PR_SWAP_SEND:
3413                         port->swap_status = (type == PD_CTRL_WAIT ?
3414                                              -EAGAIN : -EOPNOTSUPP);
3415                         tcpm_set_state(port, PR_SWAP_CANCEL, 0);
3416                         break;
3417                 case VCONN_SWAP_SEND:
3418                         port->swap_status = (type == PD_CTRL_WAIT ?
3419                                              -EAGAIN : -EOPNOTSUPP);
3420                         tcpm_set_state(port, VCONN_SWAP_CANCEL, 0);
3421                         break;
3422                 case FR_SWAP_SEND:
3423                         tcpm_set_state(port, FR_SWAP_CANCEL, 0);
3424                         break;
3425                 case GET_SINK_CAP:
3426                         port->sink_cap_done = true;
3427                         tcpm_set_state(port, ready_state(port), 0);
3428                         break;
3429                 /*
3430                  * Some port partners do not support GET_STATUS, avoid soft reset the link to
3431                  * prevent redundant power re-negotiation
3432                  */
3433                 case GET_STATUS_SEND:
3434                         tcpm_set_state(port, ready_state(port), 0);
3435                         break;
3436                 case SRC_READY:
3437                 case SNK_READY:
3438                         if (port->vdm_state > VDM_STATE_READY) {
3439                                 port->vdm_state = VDM_STATE_DONE;
3440                                 if (tcpm_vdm_ams(port))
3441                                         tcpm_ams_finish(port);
3442                                 mod_vdm_delayed_work(port, 0);
3443                                 break;
3444                         }
3445                         fallthrough;
3446                 default:
3447                         tcpm_pd_handle_state(port,
3448                                              port->pwr_role == TYPEC_SOURCE ?
3449                                              SRC_SOFT_RESET_WAIT_SNK_TX :
3450                                              SNK_SOFT_RESET,
3451                                              NONE_AMS, 0);
3452                         break;
3453                 }
3454                 break;
3455         case PD_CTRL_ACCEPT:
3456                 switch (port->state) {
3457                 case SNK_NEGOTIATE_CAPABILITIES:
3458                         port->pps_data.active = false;
3459                         tcpm_set_state(port, SNK_TRANSITION_SINK, 0);
3460                         break;
3461                 case SNK_NEGOTIATE_PPS_CAPABILITIES:
3462                         port->pps_data.active = true;
3463                         port->pps_data.min_volt = port->pps_data.req_min_volt;
3464                         port->pps_data.max_volt = port->pps_data.req_max_volt;
3465                         port->pps_data.max_curr = port->pps_data.req_max_curr;
3466                         port->req_supply_voltage = port->pps_data.req_out_volt;
3467                         port->req_current_limit = port->pps_data.req_op_curr;
3468                         power_supply_changed(port->psy);
3469                         tcpm_set_state(port, SNK_TRANSITION_SINK, 0);
3470                         break;
3471                 case SOFT_RESET_SEND:
3472                         if (port->ams == SOFT_RESET_AMS)
3473                                 tcpm_ams_finish(port);
3474                         /*
3475                          * SOP' Soft Reset is done after Vconn Swap,
3476                          * which returns to ready state
3477                          */
3478                         if (rx_sop_type == TCPC_TX_SOP_PRIME) {
3479                                 if (rev < port->negotiated_rev_prime)
3480                                         port->negotiated_rev_prime = rev;
3481                                 tcpm_set_state(port, ready_state(port), 0);
3482                                 break;
3483                         }
3484                         if (port->pwr_role == TYPEC_SOURCE) {
3485                                 port->upcoming_state = SRC_SEND_CAPABILITIES;
3486                                 tcpm_ams_start(port, POWER_NEGOTIATION);
3487                         } else {
3488                                 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0);
3489                         }
3490                         break;
3491                 case DR_SWAP_SEND:
3492                         tcpm_set_state(port, DR_SWAP_CHANGE_DR, 0);
3493                         break;
3494                 case PR_SWAP_SEND:
3495                         tcpm_set_state(port, PR_SWAP_START, 0);
3496                         break;
3497                 case VCONN_SWAP_SEND:
3498                         tcpm_set_state(port, VCONN_SWAP_START, 0);
3499                         break;
3500                 case FR_SWAP_SEND:
3501                         tcpm_set_state(port, FR_SWAP_SNK_SRC_TRANSITION_TO_OFF, 0);
3502                         break;
3503                 default:
3504                         tcpm_pd_handle_state(port,
3505                                              port->pwr_role == TYPEC_SOURCE ?
3506                                              SRC_SOFT_RESET_WAIT_SNK_TX :
3507                                              SNK_SOFT_RESET,
3508                                              NONE_AMS, 0);
3509                         break;
3510                 }
3511                 break;
3512         case PD_CTRL_SOFT_RESET:
3513                 port->ams = SOFT_RESET_AMS;
3514                 tcpm_set_state(port, SOFT_RESET, 0);
3515                 break;
3516         case PD_CTRL_DR_SWAP:
3517                 /*
3518                  * XXX
3519                  * 6.3.9: If an alternate mode is active, a request to swap
3520                  * alternate modes shall trigger a port reset.
3521                  */
3522                 if (port->typec_caps.data != TYPEC_PORT_DRD) {
3523                         tcpm_pd_handle_msg(port,
3524                                            port->negotiated_rev < PD_REV30 ?
3525                                            PD_MSG_CTRL_REJECT :
3526                                            PD_MSG_CTRL_NOT_SUPP,
3527                                            NONE_AMS);
3528                 } else {
3529                         if (port->send_discover && port->negotiated_rev < PD_REV30) {
3530                                 tcpm_queue_message(port, PD_MSG_CTRL_WAIT);
3531                                 break;
3532                         }
3533
3534                         tcpm_pd_handle_state(port, DR_SWAP_ACCEPT, DATA_ROLE_SWAP, 0);
3535                 }
3536                 break;
3537         case PD_CTRL_PR_SWAP:
3538                 if (port->port_type != TYPEC_PORT_DRP) {
3539                         tcpm_pd_handle_msg(port,
3540                                            port->negotiated_rev < PD_REV30 ?
3541                                            PD_MSG_CTRL_REJECT :
3542                                            PD_MSG_CTRL_NOT_SUPP,
3543                                            NONE_AMS);
3544                 } else {
3545                         if (port->send_discover && port->negotiated_rev < PD_REV30) {
3546                                 tcpm_queue_message(port, PD_MSG_CTRL_WAIT);
3547                                 break;
3548                         }
3549
3550                         tcpm_pd_handle_state(port, PR_SWAP_ACCEPT, POWER_ROLE_SWAP, 0);
3551                 }
3552                 break;
3553         case PD_CTRL_VCONN_SWAP:
3554                 if (port->send_discover && port->negotiated_rev < PD_REV30) {
3555                         tcpm_queue_message(port, PD_MSG_CTRL_WAIT);
3556                         break;
3557                 }
3558
3559                 tcpm_pd_handle_state(port, VCONN_SWAP_ACCEPT, VCONN_SWAP, 0);
3560                 break;
3561         case PD_CTRL_GET_SOURCE_CAP_EXT:
3562         case PD_CTRL_GET_STATUS:
3563         case PD_CTRL_FR_SWAP:
3564         case PD_CTRL_GET_PPS_STATUS:
3565         case PD_CTRL_GET_COUNTRY_CODES:
3566                 /* Currently not supported */
3567                 tcpm_pd_handle_msg(port,
3568                                    port->negotiated_rev < PD_REV30 ?
3569                                    PD_MSG_CTRL_REJECT :
3570                                    PD_MSG_CTRL_NOT_SUPP,
3571                                    NONE_AMS);
3572                 break;
3573         case PD_CTRL_GET_REVISION:
3574                 if (port->negotiated_rev >= PD_REV30 && port->pd_rev.rev_major)
3575                         tcpm_pd_handle_msg(port, PD_MSG_DATA_REV,
3576                                            REVISION_INFORMATION);
3577                 else
3578                         tcpm_pd_handle_msg(port,
3579                                            port->negotiated_rev < PD_REV30 ?
3580                                            PD_MSG_CTRL_REJECT :
3581                                            PD_MSG_CTRL_NOT_SUPP,
3582                                            NONE_AMS);
3583                 break;
3584         default:
3585                 tcpm_pd_handle_msg(port,
3586                                    port->negotiated_rev < PD_REV30 ?
3587                                    PD_MSG_CTRL_REJECT :
3588                                    PD_MSG_CTRL_NOT_SUPP,
3589                                    NONE_AMS);
3590                 tcpm_log(port, "Unrecognized ctrl message type %#x", type);
3591                 break;
3592         }
3593 }
3594
3595 static void tcpm_pd_ext_msg_request(struct tcpm_port *port,
3596                                     const struct pd_message *msg)
3597 {
3598         enum pd_ext_msg_type type = pd_header_type_le(msg->header);
3599         unsigned int data_size = pd_ext_header_data_size_le(msg->ext_msg.header);
3600
3601         /* stopping VDM state machine if interrupted by other Messages */
3602         if (tcpm_vdm_ams(port)) {
3603                 port->vdm_state = VDM_STATE_ERR_BUSY;
3604                 tcpm_ams_finish(port);
3605                 mod_vdm_delayed_work(port, 0);
3606         }
3607
3608         if (!(le16_to_cpu(msg->ext_msg.header) & PD_EXT_HDR_CHUNKED)) {
3609                 tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS);
3610                 tcpm_log(port, "Unchunked extended messages unsupported");
3611                 return;
3612         }
3613
3614         if (data_size > PD_EXT_MAX_CHUNK_DATA) {
3615                 tcpm_pd_handle_state(port, CHUNK_NOT_SUPP, NONE_AMS, PD_T_CHUNK_NOT_SUPP);
3616                 tcpm_log(port, "Chunk handling not yet supported");
3617                 return;
3618         }
3619
3620         switch (type) {
3621         case PD_EXT_STATUS:
3622         case PD_EXT_PPS_STATUS:
3623                 if (port->ams == GETTING_SOURCE_SINK_STATUS) {
3624                         tcpm_ams_finish(port);
3625                         tcpm_set_state(port, ready_state(port), 0);
3626                 } else {
3627                         /* unexpected Status or PPS_Status Message */
3628                         tcpm_pd_handle_state(port, port->pwr_role == TYPEC_SOURCE ?
3629                                              SRC_SOFT_RESET_WAIT_SNK_TX : SNK_SOFT_RESET,
3630                                              NONE_AMS, 0);
3631                 }
3632                 break;
3633         case PD_EXT_SOURCE_CAP_EXT:
3634         case PD_EXT_GET_BATT_CAP:
3635         case PD_EXT_GET_BATT_STATUS:
3636         case PD_EXT_BATT_CAP:
3637         case PD_EXT_GET_MANUFACTURER_INFO:
3638         case PD_EXT_MANUFACTURER_INFO:
3639         case PD_EXT_SECURITY_REQUEST:
3640         case PD_EXT_SECURITY_RESPONSE:
3641         case PD_EXT_FW_UPDATE_REQUEST:
3642         case PD_EXT_FW_UPDATE_RESPONSE:
3643         case PD_EXT_COUNTRY_INFO:
3644         case PD_EXT_COUNTRY_CODES:
3645                 tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS);
3646                 break;
3647         default:
3648                 tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS);
3649                 tcpm_log(port, "Unrecognized extended message type %#x", type);
3650                 break;
3651         }
3652 }
3653
3654 static void tcpm_pd_rx_handler(struct kthread_work *work)
3655 {
3656         struct pd_rx_event *event = container_of(work,
3657                                                  struct pd_rx_event, work);
3658         const struct pd_message *msg = &event->msg;
3659         unsigned int cnt = pd_header_cnt_le(msg->header);
3660         struct tcpm_port *port = event->port;
3661         enum tcpm_transmit_type rx_sop_type = event->rx_sop_type;
3662
3663         mutex_lock(&port->lock);
3664
3665         tcpm_log(port, "PD RX, header: %#x [%d]", le16_to_cpu(msg->header),
3666                  port->attached);
3667
3668         if (port->attached) {
3669                 enum pd_ctrl_msg_type type = pd_header_type_le(msg->header);
3670                 unsigned int msgid = pd_header_msgid_le(msg->header);
3671
3672                 /*
3673                  * Drop SOP' messages if cannot receive via
3674                  * tcpm_can_communicate_sop_prime
3675                  */
3676                 if (rx_sop_type == TCPC_TX_SOP_PRIME &&
3677                     !tcpm_can_communicate_sop_prime(port))
3678                         goto done;
3679
3680                 /*
3681                  * USB PD standard, 6.6.1.2:
3682                  * "... if MessageID value in a received Message is the
3683                  * same as the stored value, the receiver shall return a
3684                  * GoodCRC Message with that MessageID value and drop
3685                  * the Message (this is a retry of an already received
3686                  * Message). Note: this shall not apply to the Soft_Reset
3687                  * Message which always has a MessageID value of zero."
3688                  */
3689                 switch (rx_sop_type) {
3690                 case TCPC_TX_SOP_PRIME:
3691                         if (msgid == port->rx_msgid_prime)
3692                                 goto done;
3693                         port->rx_msgid_prime = msgid;
3694                         break;
3695                 case TCPC_TX_SOP:
3696                 default:
3697                         if (msgid == port->rx_msgid && type != PD_CTRL_SOFT_RESET)
3698                                 goto done;
3699                         port->rx_msgid = msgid;
3700                         break;
3701                 }
3702
3703                 /*
3704                  * If both ends believe to be DFP/host, we have a data role
3705                  * mismatch.
3706                  */
3707                 if (!!(le16_to_cpu(msg->header) & PD_HEADER_DATA_ROLE) ==
3708                     (port->data_role == TYPEC_HOST) && rx_sop_type == TCPC_TX_SOP) {
3709                         tcpm_log(port,
3710                                  "Data role mismatch, initiating error recovery");
3711                         tcpm_set_state(port, ERROR_RECOVERY, 0);
3712                 } else {
3713                         if (le16_to_cpu(msg->header) & PD_HEADER_EXT_HDR)
3714                                 tcpm_pd_ext_msg_request(port, msg);
3715                         else if (cnt)
3716                                 tcpm_pd_data_request(port, msg, rx_sop_type);
3717                         else
3718                                 tcpm_pd_ctrl_request(port, msg, rx_sop_type);
3719                 }
3720         }
3721
3722 done:
3723         mutex_unlock(&port->lock);
3724         kfree(event);
3725 }
3726
3727 void tcpm_pd_receive(struct tcpm_port *port, const struct pd_message *msg,
3728                      enum tcpm_transmit_type rx_sop_type)
3729 {
3730         struct pd_rx_event *event;
3731
3732         event = kzalloc(sizeof(*event), GFP_ATOMIC);
3733         if (!event)
3734                 return;
3735
3736         kthread_init_work(&event->work, tcpm_pd_rx_handler);
3737         event->port = port;
3738         event->rx_sop_type = rx_sop_type;
3739         memcpy(&event->msg, msg, sizeof(*msg));
3740         kthread_queue_work(port->wq, &event->work);
3741 }
3742 EXPORT_SYMBOL_GPL(tcpm_pd_receive);
3743
3744 static int tcpm_pd_send_control(struct tcpm_port *port,
3745                                 enum pd_ctrl_msg_type type,
3746                                 enum tcpm_transmit_type tx_sop_type)
3747 {
3748         struct pd_message msg;
3749
3750         memset(&msg, 0, sizeof(msg));
3751         switch (tx_sop_type) {
3752         case TCPC_TX_SOP_PRIME:
3753                 msg.header = PD_HEADER_LE(type,
3754                                           0,    /* Cable Plug Indicator for DFP/UFP */
3755                                           0,    /* Reserved */
3756                                           port->negotiated_rev,
3757                                           port->message_id_prime,
3758                                           0);
3759                 break;
3760         case TCPC_TX_SOP:
3761                 msg.header = PD_HEADER_LE(type,
3762                                           port->pwr_role,
3763                                           port->data_role,
3764                                           port->negotiated_rev,
3765                                           port->message_id,
3766                                           0);
3767                 break;
3768         default:
3769                 msg.header = PD_HEADER_LE(type,
3770                                           port->pwr_role,
3771                                           port->data_role,
3772                                           port->negotiated_rev,
3773                                           port->message_id,
3774                                           0);
3775                 break;
3776         }
3777
3778         return tcpm_pd_transmit(port, tx_sop_type, &msg);
3779 }
3780
3781 /*
3782  * Send queued message without affecting state.
3783  * Return true if state machine should go back to sleep,
3784  * false otherwise.
3785  */
3786 static bool tcpm_send_queued_message(struct tcpm_port *port)
3787 {
3788         enum pd_msg_request queued_message;
3789         int ret;
3790
3791         do {
3792                 queued_message = port->queued_message;
3793                 port->queued_message = PD_MSG_NONE;
3794
3795                 switch (queued_message) {
3796                 case PD_MSG_CTRL_WAIT:
3797                         tcpm_pd_send_control(port, PD_CTRL_WAIT, TCPC_TX_SOP);
3798                         break;
3799                 case PD_MSG_CTRL_REJECT:
3800                         tcpm_pd_send_control(port, PD_CTRL_REJECT, TCPC_TX_SOP);
3801                         break;
3802                 case PD_MSG_CTRL_NOT_SUPP:
3803                         tcpm_pd_send_control(port, PD_CTRL_NOT_SUPP, TCPC_TX_SOP);
3804                         break;
3805                 case PD_MSG_DATA_SINK_CAP:
3806                         ret = tcpm_pd_send_sink_caps(port);
3807                         if (ret < 0) {
3808                                 tcpm_log(port, "Unable to send snk caps, ret=%d", ret);
3809                                 tcpm_set_state(port, SNK_SOFT_RESET, 0);
3810                         }
3811                         tcpm_ams_finish(port);
3812                         break;
3813                 case PD_MSG_DATA_SOURCE_CAP:
3814                         ret = tcpm_pd_send_source_caps(port);
3815                         if (ret < 0) {
3816                                 tcpm_log(port,
3817                                          "Unable to send src caps, ret=%d",
3818                                          ret);
3819                                 tcpm_set_state(port, SOFT_RESET_SEND, 0);
3820                         } else if (port->pwr_role == TYPEC_SOURCE) {
3821                                 tcpm_ams_finish(port);
3822                                 tcpm_set_state(port, HARD_RESET_SEND,
3823                                                PD_T_SENDER_RESPONSE);
3824                         } else {
3825                                 tcpm_ams_finish(port);
3826                         }
3827                         break;
3828                 case PD_MSG_DATA_REV:
3829                         ret = tcpm_pd_send_revision(port);
3830                         if (ret)
3831                                 tcpm_log(port,
3832                                          "Unable to send revision msg, ret=%d",
3833                                          ret);
3834                         tcpm_ams_finish(port);
3835                         break;
3836                 default:
3837                         break;
3838                 }
3839         } while (port->queued_message != PD_MSG_NONE);
3840
3841         if (port->delayed_state != INVALID_STATE) {
3842                 if (ktime_after(port->delayed_runtime, ktime_get())) {
3843                         mod_tcpm_delayed_work(port, ktime_to_ms(ktime_sub(port->delayed_runtime,
3844                                                                           ktime_get())));
3845                         return true;
3846                 }
3847                 port->delayed_state = INVALID_STATE;
3848         }
3849         return false;
3850 }
3851
3852 static int tcpm_pd_check_request(struct tcpm_port *port)
3853 {
3854         u32 pdo, rdo = port->sink_request;
3855         unsigned int max, op, pdo_max, index;
3856         enum pd_pdo_type type;
3857
3858         index = rdo_index(rdo);
3859         if (!index || index > port->nr_src_pdo)
3860                 return -EINVAL;
3861
3862         pdo = port->src_pdo[index - 1];
3863         type = pdo_type(pdo);
3864         switch (type) {
3865         case PDO_TYPE_FIXED:
3866         case PDO_TYPE_VAR:
3867                 max = rdo_max_current(rdo);
3868                 op = rdo_op_current(rdo);
3869                 pdo_max = pdo_max_current(pdo);
3870
3871                 if (op > pdo_max)
3872                         return -EINVAL;
3873                 if (max > pdo_max && !(rdo & RDO_CAP_MISMATCH))
3874                         return -EINVAL;
3875
3876                 if (type == PDO_TYPE_FIXED)
3877                         tcpm_log(port,
3878                                  "Requested %u mV, %u mA for %u / %u mA",
3879                                  pdo_fixed_voltage(pdo), pdo_max, op, max);
3880                 else
3881                         tcpm_log(port,
3882                                  "Requested %u -> %u mV, %u mA for %u / %u mA",
3883                                  pdo_min_voltage(pdo), pdo_max_voltage(pdo),
3884                                  pdo_max, op, max);
3885                 break;
3886         case PDO_TYPE_BATT:
3887                 max = rdo_max_power(rdo);
3888                 op = rdo_op_power(rdo);
3889                 pdo_max = pdo_max_power(pdo);
3890
3891                 if (op > pdo_max)
3892                         return -EINVAL;
3893                 if (max > pdo_max && !(rdo & RDO_CAP_MISMATCH))
3894                         return -EINVAL;
3895                 tcpm_log(port,
3896                          "Requested %u -> %u mV, %u mW for %u / %u mW",
3897                          pdo_min_voltage(pdo), pdo_max_voltage(pdo),
3898                          pdo_max, op, max);
3899                 break;
3900         default:
3901                 return -EINVAL;
3902         }
3903
3904         port->op_vsafe5v = index == 1;
3905
3906         return 0;
3907 }
3908
3909 #define min_power(x, y) min(pdo_max_power(x), pdo_max_power(y))
3910 #define min_current(x, y) min(pdo_max_current(x), pdo_max_current(y))
3911
3912 static int tcpm_pd_select_pdo(struct tcpm_port *port, int *sink_pdo,
3913                               int *src_pdo)
3914 {
3915         unsigned int i, j, max_src_mv = 0, min_src_mv = 0, max_mw = 0,
3916                      max_mv = 0, src_mw = 0, src_ma = 0, max_snk_mv = 0,
3917                      min_snk_mv = 0;
3918         int ret = -EINVAL;
3919
3920         port->pps_data.supported = false;
3921         port->usb_type = POWER_SUPPLY_USB_TYPE_PD;
3922         power_supply_changed(port->psy);
3923
3924         /*
3925          * Select the source PDO providing the most power which has a
3926          * matchig sink cap.
3927          */
3928         for (i = 0; i < port->nr_source_caps; i++) {
3929                 u32 pdo = port->source_caps[i];
3930                 enum pd_pdo_type type = pdo_type(pdo);
3931
3932                 switch (type) {
3933                 case PDO_TYPE_FIXED:
3934                         max_src_mv = pdo_fixed_voltage(pdo);
3935                         min_src_mv = max_src_mv;
3936                         break;
3937                 case PDO_TYPE_BATT:
3938                 case PDO_TYPE_VAR:
3939                         max_src_mv = pdo_max_voltage(pdo);
3940                         min_src_mv = pdo_min_voltage(pdo);
3941                         break;
3942                 case PDO_TYPE_APDO:
3943                         if (pdo_apdo_type(pdo) == APDO_TYPE_PPS) {
3944                                 port->pps_data.supported = true;
3945                                 port->usb_type =
3946                                         POWER_SUPPLY_USB_TYPE_PD_PPS;
3947                                 power_supply_changed(port->psy);
3948                         }
3949                         continue;
3950                 default:
3951                         tcpm_log(port, "Invalid source PDO type, ignoring");
3952                         continue;
3953                 }
3954
3955                 switch (type) {
3956                 case PDO_TYPE_FIXED:
3957                 case PDO_TYPE_VAR:
3958                         src_ma = pdo_max_current(pdo);
3959                         src_mw = src_ma * min_src_mv / 1000;
3960                         break;
3961                 case PDO_TYPE_BATT:
3962                         src_mw = pdo_max_power(pdo);
3963                         break;
3964                 case PDO_TYPE_APDO:
3965                         continue;
3966                 default:
3967                         tcpm_log(port, "Invalid source PDO type, ignoring");
3968                         continue;
3969                 }
3970
3971                 for (j = 0; j < port->nr_snk_pdo; j++) {
3972                         pdo = port->snk_pdo[j];
3973
3974                         switch (pdo_type(pdo)) {
3975                         case PDO_TYPE_FIXED:
3976                                 max_snk_mv = pdo_fixed_voltage(pdo);
3977                                 min_snk_mv = max_snk_mv;
3978                                 break;
3979                         case PDO_TYPE_BATT:
3980                         case PDO_TYPE_VAR:
3981                                 max_snk_mv = pdo_max_voltage(pdo);
3982                                 min_snk_mv = pdo_min_voltage(pdo);
3983                                 break;
3984                         case PDO_TYPE_APDO:
3985                                 continue;
3986                         default:
3987                                 tcpm_log(port, "Invalid sink PDO type, ignoring");
3988                                 continue;
3989                         }
3990
3991                         if (max_src_mv <= max_snk_mv &&
3992                                 min_src_mv >= min_snk_mv) {
3993                                 /* Prefer higher voltages if available */
3994                                 if ((src_mw == max_mw && min_src_mv > max_mv) ||
3995                                                         src_mw > max_mw) {
3996                                         *src_pdo = i;
3997                                         *sink_pdo = j;
3998                                         max_mw = src_mw;
3999                                         max_mv = min_src_mv;
4000                                         ret = 0;
4001                                 }
4002                         }
4003                 }
4004         }
4005
4006         return ret;
4007 }
4008
4009 static unsigned int tcpm_pd_select_pps_apdo(struct tcpm_port *port)
4010 {
4011         unsigned int i, src_ma, max_temp_mw = 0, max_op_ma, op_mw;
4012         unsigned int src_pdo = 0;
4013         u32 pdo, src;
4014
4015         for (i = 1; i < port->nr_source_caps; ++i) {
4016                 pdo = port->source_caps[i];
4017
4018                 switch (pdo_type(pdo)) {
4019                 case PDO_TYPE_APDO:
4020                         if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) {
4021                                 tcpm_log(port, "Not PPS APDO (source), ignoring");
4022                                 continue;
4023                         }
4024
4025                         if (port->pps_data.req_out_volt > pdo_pps_apdo_max_voltage(pdo) ||
4026                             port->pps_data.req_out_volt < pdo_pps_apdo_min_voltage(pdo))
4027                                 continue;
4028
4029                         src_ma = pdo_pps_apdo_max_current(pdo);
4030                         max_op_ma = min(src_ma, port->pps_data.req_op_curr);
4031                         op_mw = max_op_ma * port->pps_data.req_out_volt / 1000;
4032                         if (op_mw > max_temp_mw) {
4033                                 src_pdo = i;
4034                                 max_temp_mw = op_mw;
4035                         }
4036                         break;
4037                 default:
4038                         tcpm_log(port, "Not APDO type (source), ignoring");
4039                         continue;
4040                 }
4041         }
4042
4043         if (src_pdo) {
4044                 src = port->source_caps[src_pdo];
4045
4046                 port->pps_data.req_min_volt = pdo_pps_apdo_min_voltage(src);
4047                 port->pps_data.req_max_volt = pdo_pps_apdo_max_voltage(src);
4048                 port->pps_data.req_max_curr = pdo_pps_apdo_max_current(src);
4049                 port->pps_data.req_op_curr = min(port->pps_data.req_max_curr,
4050                                                  port->pps_data.req_op_curr);
4051         }
4052
4053         return src_pdo;
4054 }
4055
4056 static int tcpm_pd_build_request(struct tcpm_port *port, u32 *rdo)
4057 {
4058         unsigned int mv, ma, mw, flags;
4059         unsigned int max_ma, max_mw;
4060         enum pd_pdo_type type;
4061         u32 pdo, matching_snk_pdo;
4062         int src_pdo_index = 0;
4063         int snk_pdo_index = 0;
4064         int ret;
4065
4066         ret = tcpm_pd_select_pdo(port, &snk_pdo_index, &src_pdo_index);
4067         if (ret < 0)
4068                 return ret;
4069
4070         pdo = port->source_caps[src_pdo_index];
4071         matching_snk_pdo = port->snk_pdo[snk_pdo_index];
4072         type = pdo_type(pdo);
4073
4074         switch (type) {
4075         case PDO_TYPE_FIXED:
4076                 mv = pdo_fixed_voltage(pdo);
4077                 break;
4078         case PDO_TYPE_BATT:
4079         case PDO_TYPE_VAR:
4080                 mv = pdo_min_voltage(pdo);
4081                 break;
4082         default:
4083                 tcpm_log(port, "Invalid PDO selected!");
4084                 return -EINVAL;
4085         }
4086
4087         /* Select maximum available current within the sink pdo's limit */
4088         if (type == PDO_TYPE_BATT) {
4089                 mw = min_power(pdo, matching_snk_pdo);
4090                 ma = 1000 * mw / mv;
4091         } else {
4092                 ma = min_current(pdo, matching_snk_pdo);
4093                 mw = ma * mv / 1000;
4094         }
4095
4096         flags = RDO_USB_COMM | RDO_NO_SUSPEND;
4097
4098         /* Set mismatch bit if offered power is less than operating power */
4099         max_ma = ma;
4100         max_mw = mw;
4101         if (mw < port->operating_snk_mw) {
4102                 flags |= RDO_CAP_MISMATCH;
4103                 if (type == PDO_TYPE_BATT &&
4104                     (pdo_max_power(matching_snk_pdo) > pdo_max_power(pdo)))
4105                         max_mw = pdo_max_power(matching_snk_pdo);
4106                 else if (pdo_max_current(matching_snk_pdo) >
4107                          pdo_max_current(pdo))
4108                         max_ma = pdo_max_current(matching_snk_pdo);
4109         }
4110
4111         tcpm_log(port, "cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d",
4112                  port->cc_req, port->cc1, port->cc2, port->vbus_source,
4113                  port->vconn_role == TYPEC_SOURCE ? "source" : "sink",
4114                  port->polarity);
4115
4116         if (type == PDO_TYPE_BATT) {
4117                 *rdo = RDO_BATT(src_pdo_index + 1, mw, max_mw, flags);
4118
4119                 tcpm_log(port, "Requesting PDO %d: %u mV, %u mW%s",
4120                          src_pdo_index, mv, mw,
4121                          flags & RDO_CAP_MISMATCH ? " [mismatch]" : "");
4122         } else {
4123                 *rdo = RDO_FIXED(src_pdo_index + 1, ma, max_ma, flags);
4124
4125                 tcpm_log(port, "Requesting PDO %d: %u mV, %u mA%s",
4126                          src_pdo_index, mv, ma,
4127                          flags & RDO_CAP_MISMATCH ? " [mismatch]" : "");
4128         }
4129
4130         port->req_current_limit = ma;
4131         port->req_supply_voltage = mv;
4132
4133         return 0;
4134 }
4135
4136 static int tcpm_pd_send_request(struct tcpm_port *port)
4137 {
4138         struct pd_message msg;
4139         int ret;
4140         u32 rdo;
4141
4142         ret = tcpm_pd_build_request(port, &rdo);
4143         if (ret < 0)
4144                 return ret;
4145
4146         /*
4147          * Relax the threshold as voltage will be adjusted after Accept Message plus tSrcTransition.
4148          * It is safer to modify the threshold here.
4149          */
4150         tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, 0);
4151
4152         memset(&msg, 0, sizeof(msg));
4153         msg.header = PD_HEADER_LE(PD_DATA_REQUEST,
4154                                   port->pwr_role,
4155                                   port->data_role,
4156                                   port->negotiated_rev,
4157                                   port->message_id, 1);
4158         msg.payload[0] = cpu_to_le32(rdo);
4159
4160         return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
4161 }
4162
4163 static int tcpm_pd_build_pps_request(struct tcpm_port *port, u32 *rdo)
4164 {
4165         unsigned int out_mv, op_ma, op_mw, max_mv, max_ma, flags;
4166         unsigned int src_pdo_index;
4167
4168         src_pdo_index = tcpm_pd_select_pps_apdo(port);
4169         if (!src_pdo_index)
4170                 return -EOPNOTSUPP;
4171
4172         max_mv = port->pps_data.req_max_volt;
4173         max_ma = port->pps_data.req_max_curr;
4174         out_mv = port->pps_data.req_out_volt;
4175         op_ma = port->pps_data.req_op_curr;
4176
4177         flags = RDO_USB_COMM | RDO_NO_SUSPEND;
4178
4179         op_mw = (op_ma * out_mv) / 1000;
4180         if (op_mw < port->operating_snk_mw) {
4181                 /*
4182                  * Try raising current to meet power needs. If that's not enough
4183                  * then try upping the voltage. If that's still not enough
4184                  * then we've obviously chosen a PPS APDO which really isn't
4185                  * suitable so abandon ship.
4186                  */
4187                 op_ma = (port->operating_snk_mw * 1000) / out_mv;
4188                 if ((port->operating_snk_mw * 1000) % out_mv)
4189                         ++op_ma;
4190                 op_ma += RDO_PROG_CURR_MA_STEP - (op_ma % RDO_PROG_CURR_MA_STEP);
4191
4192                 if (op_ma > max_ma) {
4193                         op_ma = max_ma;
4194                         out_mv = (port->operating_snk_mw * 1000) / op_ma;
4195                         if ((port->operating_snk_mw * 1000) % op_ma)
4196                                 ++out_mv;
4197                         out_mv += RDO_PROG_VOLT_MV_STEP -
4198                                   (out_mv % RDO_PROG_VOLT_MV_STEP);
4199
4200                         if (out_mv > max_mv) {
4201                                 tcpm_log(port, "Invalid PPS APDO selected!");
4202                                 return -EINVAL;
4203                         }
4204                 }
4205         }
4206
4207         tcpm_log(port, "cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d",
4208                  port->cc_req, port->cc1, port->cc2, port->vbus_source,
4209                  port->vconn_role == TYPEC_SOURCE ? "source" : "sink",
4210                  port->polarity);
4211
4212         *rdo = RDO_PROG(src_pdo_index + 1, out_mv, op_ma, flags);
4213
4214         tcpm_log(port, "Requesting APDO %d: %u mV, %u mA",
4215                  src_pdo_index, out_mv, op_ma);
4216
4217         port->pps_data.req_op_curr = op_ma;
4218         port->pps_data.req_out_volt = out_mv;
4219
4220         return 0;
4221 }
4222
4223 static int tcpm_pd_send_pps_request(struct tcpm_port *port)
4224 {
4225         struct pd_message msg;
4226         int ret;
4227         u32 rdo;
4228
4229         ret = tcpm_pd_build_pps_request(port, &rdo);
4230         if (ret < 0)
4231                 return ret;
4232
4233         /* Relax the threshold as voltage will be adjusted right after Accept Message. */
4234         tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, 0);
4235
4236         memset(&msg, 0, sizeof(msg));
4237         msg.header = PD_HEADER_LE(PD_DATA_REQUEST,
4238                                   port->pwr_role,
4239                                   port->data_role,
4240                                   port->negotiated_rev,
4241                                   port->message_id, 1);
4242         msg.payload[0] = cpu_to_le32(rdo);
4243
4244         return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
4245 }
4246
4247 static int tcpm_set_vbus(struct tcpm_port *port, bool enable)
4248 {
4249         int ret;
4250
4251         if (enable && port->vbus_charge)
4252                 return -EINVAL;
4253
4254         tcpm_log(port, "vbus:=%d charge=%d", enable, port->vbus_charge);
4255
4256         ret = port->tcpc->set_vbus(port->tcpc, enable, port->vbus_charge);
4257         if (ret < 0)
4258                 return ret;
4259
4260         port->vbus_source = enable;
4261         return 0;
4262 }
4263
4264 static int tcpm_set_charge(struct tcpm_port *port, bool charge)
4265 {
4266         int ret;
4267
4268         if (charge && port->vbus_source)
4269                 return -EINVAL;
4270
4271         if (charge != port->vbus_charge) {
4272                 tcpm_log(port, "vbus=%d charge:=%d", port->vbus_source, charge);
4273                 ret = port->tcpc->set_vbus(port->tcpc, port->vbus_source,
4274                                            charge);
4275                 if (ret < 0)
4276                         return ret;
4277         }
4278         port->vbus_charge = charge;
4279         power_supply_changed(port->psy);
4280         return 0;
4281 }
4282
4283 static bool tcpm_start_toggling(struct tcpm_port *port, enum typec_cc_status cc)
4284 {
4285         int ret;
4286
4287         if (!port->tcpc->start_toggling)
4288                 return false;
4289
4290         tcpm_log_force(port, "Start toggling");
4291         ret = port->tcpc->start_toggling(port->tcpc, port->port_type, cc);
4292         return ret == 0;
4293 }
4294
4295 static int tcpm_init_vbus(struct tcpm_port *port)
4296 {
4297         int ret;
4298
4299         ret = port->tcpc->set_vbus(port->tcpc, false, false);
4300         port->vbus_source = false;
4301         port->vbus_charge = false;
4302         return ret;
4303 }
4304
4305 static int tcpm_init_vconn(struct tcpm_port *port)
4306 {
4307         int ret;
4308
4309         ret = port->tcpc->set_vconn(port->tcpc, false);
4310         port->vconn_role = TYPEC_SINK;
4311         return ret;
4312 }
4313
4314 static void tcpm_typec_connect(struct tcpm_port *port)
4315 {
4316         struct typec_partner *partner;
4317
4318         if (!port->connected) {
4319                 port->connected = true;
4320                 /* Make sure we don't report stale identity information */
4321                 memset(&port->partner_ident, 0, sizeof(port->partner_ident));
4322                 port->partner_desc.usb_pd = port->pd_capable;
4323                 if (tcpm_port_is_debug(port))
4324                         port->partner_desc.accessory = TYPEC_ACCESSORY_DEBUG;
4325                 else if (tcpm_port_is_audio(port))
4326                         port->partner_desc.accessory = TYPEC_ACCESSORY_AUDIO;
4327                 else
4328                         port->partner_desc.accessory = TYPEC_ACCESSORY_NONE;
4329                 partner = typec_register_partner(port->typec_port, &port->partner_desc);
4330                 if (IS_ERR(partner)) {
4331                         dev_err(port->dev, "Failed to register partner (%ld)\n", PTR_ERR(partner));
4332                         return;
4333                 }
4334
4335                 port->partner = partner;
4336                 typec_partner_set_usb_power_delivery(port->partner, port->partner_pd);
4337         }
4338 }
4339
4340 static int tcpm_src_attach(struct tcpm_port *port)
4341 {
4342         enum typec_cc_polarity polarity =
4343                                 port->cc2 == TYPEC_CC_RD ? TYPEC_POLARITY_CC2
4344                                                          : TYPEC_POLARITY_CC1;
4345         int ret;
4346
4347         if (port->attached)
4348                 return 0;
4349
4350         ret = tcpm_set_polarity(port, polarity);
4351         if (ret < 0)
4352                 return ret;
4353
4354         tcpm_enable_auto_vbus_discharge(port, true);
4355
4356         ret = tcpm_set_roles(port, true, TYPEC_SOURCE, tcpm_data_role_for_source(port));
4357         if (ret < 0)
4358                 return ret;
4359
4360         if (port->pd_supported) {
4361                 ret = port->tcpc->set_pd_rx(port->tcpc, true);
4362                 if (ret < 0)
4363                         goto out_disable_mux;
4364         }
4365
4366         /*
4367          * USB Type-C specification, version 1.2,
4368          * chapter 4.5.2.2.8.1 (Attached.SRC Requirements)
4369          * Enable VCONN only if the non-RD port is set to RA.
4370          */
4371         if ((polarity == TYPEC_POLARITY_CC1 && port->cc2 == TYPEC_CC_RA) ||
4372             (polarity == TYPEC_POLARITY_CC2 && port->cc1 == TYPEC_CC_RA)) {
4373                 ret = tcpm_set_vconn(port, true);
4374                 if (ret < 0)
4375                         goto out_disable_pd;
4376         }
4377
4378         ret = tcpm_set_vbus(port, true);
4379         if (ret < 0)
4380                 goto out_disable_vconn;
4381
4382         port->pd_capable = false;
4383
4384         port->partner = NULL;
4385
4386         port->attached = true;
4387         port->send_discover = true;
4388         port->send_discover_prime = false;
4389
4390         return 0;
4391
4392 out_disable_vconn:
4393         tcpm_set_vconn(port, false);
4394 out_disable_pd:
4395         if (port->pd_supported)
4396                 port->tcpc->set_pd_rx(port->tcpc, false);
4397 out_disable_mux:
4398         tcpm_mux_set(port, TYPEC_STATE_SAFE, USB_ROLE_NONE,
4399                      TYPEC_ORIENTATION_NONE);
4400         return ret;
4401 }
4402
4403 static void tcpm_typec_disconnect(struct tcpm_port *port)
4404 {
4405         /*
4406          * Unregister plug/cable outside of port->connected because cable can
4407          * be discovered before SRC_READY/SNK_READY states where port->connected
4408          * is set.
4409          */
4410         typec_unregister_plug(port->plug_prime);
4411         typec_unregister_cable(port->cable);
4412         port->plug_prime = NULL;
4413         port->cable = NULL;
4414         if (port->connected) {
4415                 if (port->partner) {
4416                         typec_partner_set_usb_power_delivery(port->partner, NULL);
4417                         typec_unregister_partner(port->partner);
4418                         port->partner = NULL;
4419                 }
4420                 port->connected = false;
4421         }
4422 }
4423
4424 static void tcpm_unregister_altmodes(struct tcpm_port *port)
4425 {
4426         struct pd_mode_data *modep = &port->mode_data;
4427         struct pd_mode_data *modep_prime = &port->mode_data_prime;
4428         int i;
4429
4430         for (i = 0; i < modep->altmodes; i++) {
4431                 typec_unregister_altmode(port->partner_altmode[i]);
4432                 port->partner_altmode[i] = NULL;
4433         }
4434         for (i = 0; i < modep_prime->altmodes; i++) {
4435                 typec_unregister_altmode(port->plug_prime_altmode[i]);
4436                 port->plug_prime_altmode[i] = NULL;
4437         }
4438
4439         memset(modep, 0, sizeof(*modep));
4440         memset(modep_prime, 0, sizeof(*modep_prime));
4441 }
4442
4443 static void tcpm_set_partner_usb_comm_capable(struct tcpm_port *port, bool capable)
4444 {
4445         tcpm_log(port, "Setting usb_comm capable %s", str_true_false(capable));
4446
4447         if (port->tcpc->set_partner_usb_comm_capable)
4448                 port->tcpc->set_partner_usb_comm_capable(port->tcpc, capable);
4449 }
4450
4451 static void tcpm_reset_port(struct tcpm_port *port)
4452 {
4453         tcpm_enable_auto_vbus_discharge(port, false);
4454         port->in_ams = false;
4455         port->ams = NONE_AMS;
4456         port->vdm_sm_running = false;
4457         tcpm_unregister_altmodes(port);
4458         tcpm_typec_disconnect(port);
4459         port->attached = false;
4460         port->pd_capable = false;
4461         port->pps_data.supported = false;
4462         tcpm_set_partner_usb_comm_capable(port, false);
4463
4464         /*
4465          * First Rx ID should be 0; set this to a sentinel of -1 so that
4466          * we can check tcpm_pd_rx_handler() if we had seen it before.
4467          */
4468         port->rx_msgid = -1;
4469         port->rx_msgid_prime = -1;
4470
4471         port->tcpc->set_pd_rx(port->tcpc, false);
4472         tcpm_init_vbus(port);   /* also disables charging */
4473         tcpm_init_vconn(port);
4474         tcpm_set_current_limit(port, 0, 0);
4475         tcpm_set_polarity(port, TYPEC_POLARITY_CC1);
4476         tcpm_mux_set(port, TYPEC_STATE_SAFE, USB_ROLE_NONE,
4477                      TYPEC_ORIENTATION_NONE);
4478         tcpm_set_attached_state(port, false);
4479         port->try_src_count = 0;
4480         port->try_snk_count = 0;
4481         port->usb_type = POWER_SUPPLY_USB_TYPE_C;
4482         power_supply_changed(port->psy);
4483         port->nr_sink_caps = 0;
4484         port->sink_cap_done = false;
4485         if (port->tcpc->enable_frs)
4486                 port->tcpc->enable_frs(port->tcpc, false);
4487
4488         usb_power_delivery_unregister_capabilities(port->partner_sink_caps);
4489         port->partner_sink_caps = NULL;
4490         usb_power_delivery_unregister_capabilities(port->partner_source_caps);
4491         port->partner_source_caps = NULL;
4492         usb_power_delivery_unregister(port->partner_pd);
4493         port->partner_pd = NULL;
4494 }
4495
4496 static void tcpm_detach(struct tcpm_port *port)
4497 {
4498         if (tcpm_port_is_disconnected(port))
4499                 port->hard_reset_count = 0;
4500
4501         if (!port->attached)
4502                 return;
4503
4504         if (port->tcpc->set_bist_data) {
4505                 tcpm_log(port, "disable BIST MODE TESTDATA");
4506                 port->tcpc->set_bist_data(port->tcpc, false);
4507         }
4508
4509         tcpm_reset_port(port);
4510 }
4511
4512 static void tcpm_src_detach(struct tcpm_port *port)
4513 {
4514         tcpm_detach(port);
4515 }
4516
4517 static int tcpm_snk_attach(struct tcpm_port *port)
4518 {
4519         int ret;
4520
4521         if (port->attached)
4522                 return 0;
4523
4524         ret = tcpm_set_polarity(port, port->cc2 != TYPEC_CC_OPEN ?
4525                                 TYPEC_POLARITY_CC2 : TYPEC_POLARITY_CC1);
4526         if (ret < 0)
4527                 return ret;
4528
4529         tcpm_enable_auto_vbus_discharge(port, true);
4530
4531         ret = tcpm_set_roles(port, true, TYPEC_SINK, tcpm_data_role_for_sink(port));
4532         if (ret < 0)
4533                 return ret;
4534
4535         port->pd_capable = false;
4536
4537         port->partner = NULL;
4538
4539         port->attached = true;
4540         port->send_discover = true;
4541         port->send_discover_prime = false;
4542
4543         return 0;
4544 }
4545
4546 static void tcpm_snk_detach(struct tcpm_port *port)
4547 {
4548         tcpm_detach(port);
4549 }
4550
4551 static int tcpm_acc_attach(struct tcpm_port *port)
4552 {
4553         int ret;
4554
4555         if (port->attached)
4556                 return 0;
4557
4558         ret = tcpm_set_roles(port, true, TYPEC_SOURCE,
4559                              tcpm_data_role_for_source(port));
4560         if (ret < 0)
4561                 return ret;
4562
4563         port->partner = NULL;
4564
4565         tcpm_typec_connect(port);
4566
4567         port->attached = true;
4568
4569         return 0;
4570 }
4571
4572 static void tcpm_acc_detach(struct tcpm_port *port)
4573 {
4574         tcpm_detach(port);
4575 }
4576
4577 static inline enum tcpm_state hard_reset_state(struct tcpm_port *port)
4578 {
4579         if (port->hard_reset_count < PD_N_HARD_RESET_COUNT)
4580                 return HARD_RESET_SEND;
4581         if (port->pd_capable)
4582                 return ERROR_RECOVERY;
4583         if (port->pwr_role == TYPEC_SOURCE)
4584                 return SRC_UNATTACHED;
4585         if (port->state == SNK_WAIT_CAPABILITIES ||
4586             port->state == SNK_WAIT_CAPABILITIES_TIMEOUT)
4587                 return SNK_READY;
4588         return SNK_UNATTACHED;
4589 }
4590
4591 static inline enum tcpm_state unattached_state(struct tcpm_port *port)
4592 {
4593         if (port->port_type == TYPEC_PORT_DRP) {
4594                 if (port->pwr_role == TYPEC_SOURCE)
4595                         return SRC_UNATTACHED;
4596                 else
4597                         return SNK_UNATTACHED;
4598         } else if (port->port_type == TYPEC_PORT_SRC) {
4599                 return SRC_UNATTACHED;
4600         }
4601
4602         return SNK_UNATTACHED;
4603 }
4604
4605 static void tcpm_swap_complete(struct tcpm_port *port, int result)
4606 {
4607         if (port->swap_pending) {
4608                 port->swap_status = result;
4609                 port->swap_pending = false;
4610                 port->non_pd_role_swap = false;
4611                 complete(&port->swap_complete);
4612         }
4613 }
4614
4615 static enum typec_pwr_opmode tcpm_get_pwr_opmode(enum typec_cc_status cc)
4616 {
4617         switch (cc) {
4618         case TYPEC_CC_RP_1_5:
4619                 return TYPEC_PWR_MODE_1_5A;
4620         case TYPEC_CC_RP_3_0:
4621                 return TYPEC_PWR_MODE_3_0A;
4622         case TYPEC_CC_RP_DEF:
4623         default:
4624                 return TYPEC_PWR_MODE_USB;
4625         }
4626 }
4627
4628 static enum typec_cc_status tcpm_pwr_opmode_to_rp(enum typec_pwr_opmode opmode)
4629 {
4630         switch (opmode) {
4631         case TYPEC_PWR_MODE_USB:
4632                 return TYPEC_CC_RP_DEF;
4633         case TYPEC_PWR_MODE_1_5A:
4634                 return TYPEC_CC_RP_1_5;
4635         case TYPEC_PWR_MODE_3_0A:
4636         case TYPEC_PWR_MODE_PD:
4637         default:
4638                 return TYPEC_CC_RP_3_0;
4639         }
4640 }
4641
4642 static void tcpm_set_initial_svdm_version(struct tcpm_port *port)
4643 {
4644         if (!port->partner)
4645                 return;
4646
4647         switch (port->negotiated_rev) {
4648         case PD_REV30:
4649                 break;
4650         /*
4651          * 6.4.4.2.3 Structured VDM Version
4652          * 2.0 states "At this time, there is only one version (1.0) defined.
4653          * This field Shall be set to zero to indicate Version 1.0."
4654          * 3.0 states "This field Shall be set to 01b to indicate Version 2.0."
4655          * To ensure that we follow the Power Delivery revision we are currently
4656          * operating on, downgrade the SVDM version to the highest one supported
4657          * by the Power Delivery revision.
4658          */
4659         case PD_REV20:
4660                 typec_partner_set_svdm_version(port->partner, SVDM_VER_1_0);
4661                 break;
4662         default:
4663                 typec_partner_set_svdm_version(port->partner, SVDM_VER_1_0);
4664                 break;
4665         }
4666 }
4667
4668 static void run_state_machine(struct tcpm_port *port)
4669 {
4670         int ret;
4671         enum typec_pwr_opmode opmode;
4672         unsigned int msecs;
4673         enum tcpm_state upcoming_state;
4674
4675         if (port->tcpc->check_contaminant && port->state != CHECK_CONTAMINANT)
4676                 port->potential_contaminant = ((port->enter_state == SRC_ATTACH_WAIT &&
4677                                                 port->state == SRC_UNATTACHED) ||
4678                                                (port->enter_state == SNK_ATTACH_WAIT &&
4679                                                 port->state == SNK_UNATTACHED) ||
4680                                                (port->enter_state == SNK_DEBOUNCED &&
4681                                                 port->state == SNK_UNATTACHED));
4682
4683         port->enter_state = port->state;
4684         switch (port->state) {
4685         case TOGGLING:
4686                 break;
4687         case CHECK_CONTAMINANT:
4688                 port->tcpc->check_contaminant(port->tcpc);
4689                 break;
4690         /* SRC states */
4691         case SRC_UNATTACHED:
4692                 if (!port->non_pd_role_swap)
4693                         tcpm_swap_complete(port, -ENOTCONN);
4694                 tcpm_src_detach(port);
4695                 if (port->potential_contaminant) {
4696                         tcpm_set_state(port, CHECK_CONTAMINANT, 0);
4697                         break;
4698                 }
4699                 if (tcpm_start_toggling(port, tcpm_rp_cc(port))) {
4700                         tcpm_set_state(port, TOGGLING, 0);
4701                         break;
4702                 }
4703                 tcpm_set_cc(port, tcpm_rp_cc(port));
4704                 if (port->port_type == TYPEC_PORT_DRP)
4705                         tcpm_set_state(port, SNK_UNATTACHED, PD_T_DRP_SNK);
4706                 break;
4707         case SRC_ATTACH_WAIT:
4708                 if (tcpm_port_is_debug(port))
4709                         tcpm_set_state(port, DEBUG_ACC_ATTACHED,
4710                                        port->timings.cc_debounce_time);
4711                 else if (tcpm_port_is_audio(port))
4712                         tcpm_set_state(port, AUDIO_ACC_ATTACHED,
4713                                        port->timings.cc_debounce_time);
4714                 else if (tcpm_port_is_source(port) && port->vbus_vsafe0v)
4715                         tcpm_set_state(port,
4716                                        tcpm_try_snk(port) ? SNK_TRY
4717                                                           : SRC_ATTACHED,
4718                                        port->timings.cc_debounce_time);
4719                 break;
4720
4721         case SNK_TRY:
4722                 port->try_snk_count++;
4723                 /*
4724                  * Requirements:
4725                  * - Do not drive vconn or vbus
4726                  * - Terminate CC pins (both) to Rd
4727                  * Action:
4728                  * - Wait for tDRPTry (PD_T_DRP_TRY).
4729                  *   Until then, ignore any state changes.
4730                  */
4731                 tcpm_set_cc(port, TYPEC_CC_RD);
4732                 tcpm_set_state(port, SNK_TRY_WAIT, PD_T_DRP_TRY);
4733                 break;
4734         case SNK_TRY_WAIT:
4735                 if (tcpm_port_is_sink(port)) {
4736                         tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE, 0);
4737                 } else {
4738                         tcpm_set_state(port, SRC_TRYWAIT, 0);
4739                         port->max_wait = 0;
4740                 }
4741                 break;
4742         case SNK_TRY_WAIT_DEBOUNCE:
4743                 tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS,
4744                                PD_T_TRY_CC_DEBOUNCE);
4745                 break;
4746         case SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS:
4747                 if (port->vbus_present && tcpm_port_is_sink(port))
4748                         tcpm_set_state(port, SNK_ATTACHED, 0);
4749                 else
4750                         port->max_wait = 0;
4751                 break;
4752         case SRC_TRYWAIT:
4753                 tcpm_set_cc(port, tcpm_rp_cc(port));
4754                 if (port->max_wait == 0) {
4755                         port->max_wait = jiffies +
4756                                          msecs_to_jiffies(PD_T_DRP_TRY);
4757                         tcpm_set_state(port, SRC_TRYWAIT_UNATTACHED,
4758                                        PD_T_DRP_TRY);
4759                 } else {
4760                         if (time_is_after_jiffies(port->max_wait))
4761                                 tcpm_set_state(port, SRC_TRYWAIT_UNATTACHED,
4762                                                jiffies_to_msecs(port->max_wait -
4763                                                                 jiffies));
4764                         else
4765                                 tcpm_set_state(port, SNK_UNATTACHED, 0);
4766                 }
4767                 break;
4768         case SRC_TRYWAIT_DEBOUNCE:
4769                 tcpm_set_state(port, SRC_ATTACHED, port->timings.cc_debounce_time);
4770                 break;
4771         case SRC_TRYWAIT_UNATTACHED:
4772                 tcpm_set_state(port, SNK_UNATTACHED, 0);
4773                 break;
4774
4775         case SRC_ATTACHED:
4776                 ret = tcpm_src_attach(port);
4777                 tcpm_set_state(port, SRC_UNATTACHED,
4778                                ret < 0 ? 0 : PD_T_PS_SOURCE_ON);
4779                 break;
4780         case SRC_STARTUP:
4781                 opmode =  tcpm_get_pwr_opmode(tcpm_rp_cc(port));
4782                 typec_set_pwr_opmode(port->typec_port, opmode);
4783                 port->pwr_opmode = TYPEC_PWR_MODE_USB;
4784                 port->caps_count = 0;
4785                 port->negotiated_rev = PD_MAX_REV;
4786                 port->negotiated_rev_prime = PD_MAX_REV;
4787                 port->message_id = 0;
4788                 port->message_id_prime = 0;
4789                 port->rx_msgid = -1;
4790                 port->rx_msgid_prime = -1;
4791                 port->explicit_contract = false;
4792                 /* SNK -> SRC POWER/FAST_ROLE_SWAP finished */
4793                 if (port->ams == POWER_ROLE_SWAP ||
4794                     port->ams == FAST_ROLE_SWAP)
4795                         tcpm_ams_finish(port);
4796                 if (!port->pd_supported) {
4797                         tcpm_set_state(port, SRC_READY, 0);
4798                         break;
4799                 }
4800                 port->upcoming_state = SRC_SEND_CAPABILITIES;
4801                 tcpm_ams_start(port, POWER_NEGOTIATION);
4802                 break;
4803         case SRC_SEND_CAPABILITIES:
4804                 port->caps_count++;
4805                 if (port->caps_count > PD_N_CAPS_COUNT) {
4806                         tcpm_set_state(port, SRC_READY, 0);
4807                         break;
4808                 }
4809                 ret = tcpm_pd_send_source_caps(port);
4810                 if (ret < 0) {
4811                         if (tcpm_can_communicate_sop_prime(port) &&
4812                             IS_ERR_OR_NULL(port->cable))
4813                                 tcpm_set_state(port, SRC_VDM_IDENTITY_REQUEST, 0);
4814                         else
4815                                 tcpm_set_state(port, SRC_SEND_CAPABILITIES,
4816                                                PD_T_SEND_SOURCE_CAP);
4817                 } else {
4818                         /*
4819                          * Per standard, we should clear the reset counter here.
4820                          * However, that can result in state machine hang-ups.
4821                          * Reset it only in READY state to improve stability.
4822                          */
4823                         /* port->hard_reset_count = 0; */
4824                         port->caps_count = 0;
4825                         port->pd_capable = true;
4826                         tcpm_set_state_cond(port, SRC_SEND_CAPABILITIES_TIMEOUT,
4827                                             PD_T_SENDER_RESPONSE);
4828                 }
4829                 break;
4830         case SRC_SEND_CAPABILITIES_TIMEOUT:
4831                 /*
4832                  * Error recovery for a PD_DATA_SOURCE_CAP reply timeout.
4833                  *
4834                  * PD 2.0 sinks are supposed to accept src-capabilities with a
4835                  * 3.0 header and simply ignore any src PDOs which the sink does
4836                  * not understand such as PPS but some 2.0 sinks instead ignore
4837                  * the entire PD_DATA_SOURCE_CAP message, causing contract
4838                  * negotiation to fail.
4839                  *
4840                  * After PD_N_HARD_RESET_COUNT hard-reset attempts, we try
4841                  * sending src-capabilities with a lower PD revision to
4842                  * make these broken sinks work.
4843                  */
4844                 if (port->hard_reset_count < PD_N_HARD_RESET_COUNT) {
4845                         tcpm_set_state(port, HARD_RESET_SEND, 0);
4846                 } else if (port->negotiated_rev > PD_REV20) {
4847                         port->negotiated_rev--;
4848                         port->hard_reset_count = 0;
4849                         tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
4850                 } else {
4851                         tcpm_set_state(port, hard_reset_state(port), 0);
4852                 }
4853                 break;
4854         case SRC_NEGOTIATE_CAPABILITIES:
4855                 ret = tcpm_pd_check_request(port);
4856                 if (ret < 0) {
4857                         tcpm_pd_send_control(port, PD_CTRL_REJECT, TCPC_TX_SOP);
4858                         if (!port->explicit_contract) {
4859                                 tcpm_set_state(port,
4860                                                SRC_WAIT_NEW_CAPABILITIES, 0);
4861                         } else {
4862                                 tcpm_set_state(port, SRC_READY, 0);
4863                         }
4864                 } else {
4865                         tcpm_pd_send_control(port, PD_CTRL_ACCEPT, TCPC_TX_SOP);
4866                         tcpm_set_partner_usb_comm_capable(port,
4867                                                           !!(port->sink_request & RDO_USB_COMM));
4868                         tcpm_set_state(port, SRC_TRANSITION_SUPPLY,
4869                                        PD_T_SRC_TRANSITION);
4870                 }
4871                 break;
4872         case SRC_TRANSITION_SUPPLY:
4873                 /* XXX: regulator_set_voltage(vbus, ...) */
4874                 tcpm_pd_send_control(port, PD_CTRL_PS_RDY, TCPC_TX_SOP);
4875                 port->explicit_contract = true;
4876                 typec_set_pwr_opmode(port->typec_port, TYPEC_PWR_MODE_PD);
4877                 port->pwr_opmode = TYPEC_PWR_MODE_PD;
4878                 tcpm_set_state_cond(port, SRC_READY, 0);
4879                 break;
4880         case SRC_READY:
4881 #if 1
4882                 port->hard_reset_count = 0;
4883 #endif
4884                 port->try_src_count = 0;
4885
4886                 tcpm_swap_complete(port, 0);
4887                 tcpm_typec_connect(port);
4888
4889                 if (port->ams != NONE_AMS)
4890                         tcpm_ams_finish(port);
4891                 if (port->next_ams != NONE_AMS) {
4892                         port->ams = port->next_ams;
4893                         port->next_ams = NONE_AMS;
4894                 }
4895
4896                 /*
4897                  * If previous AMS is interrupted, switch to the upcoming
4898                  * state.
4899                  */
4900                 if (port->upcoming_state != INVALID_STATE) {
4901                         upcoming_state = port->upcoming_state;
4902                         port->upcoming_state = INVALID_STATE;
4903                         tcpm_set_state(port, upcoming_state, 0);
4904                         break;
4905                 }
4906
4907                 /*
4908                  * 6.4.4.3.1 Discover Identity
4909                  * "The Discover Identity Command Shall only be sent to SOP when there is an
4910                  * Explicit Contract."
4911                  *
4912                  * Discover Identity on SOP' should be discovered prior to the
4913                  * ready state, but if done after a Vconn Swap following Discover
4914                  * Identity on SOP then the discovery process can be run here
4915                  * as well.
4916                  */
4917                 if (port->explicit_contract) {
4918                         if (port->send_discover_prime) {
4919                                 port->tx_sop_type = TCPC_TX_SOP_PRIME;
4920                         } else {
4921                                 port->tx_sop_type = TCPC_TX_SOP;
4922                                 tcpm_set_initial_svdm_version(port);
4923                         }
4924                         mod_send_discover_delayed_work(port, 0);
4925                 } else {
4926                         port->send_discover = false;
4927                         port->send_discover_prime = false;
4928                 }
4929
4930                 /*
4931                  * 6.3.5
4932                  * Sending ping messages is not necessary if
4933                  * - the source operates at vSafe5V
4934                  * or
4935                  * - The system is not operating in PD mode
4936                  * or
4937                  * - Both partners are connected using a Type-C connector
4938                  *
4939                  * There is no actual need to send PD messages since the local
4940                  * port type-c and the spec does not clearly say whether PD is
4941                  * possible when type-c is connected to Type-A/B
4942                  */
4943                 break;
4944         case SRC_WAIT_NEW_CAPABILITIES:
4945                 /* Nothing to do... */
4946                 break;
4947
4948         /* SNK states */
4949         case SNK_UNATTACHED:
4950                 if (!port->non_pd_role_swap)
4951                         tcpm_swap_complete(port, -ENOTCONN);
4952                 tcpm_pps_complete(port, -ENOTCONN);
4953                 tcpm_snk_detach(port);
4954                 if (port->potential_contaminant) {
4955                         tcpm_set_state(port, CHECK_CONTAMINANT, 0);
4956                         break;
4957                 }
4958                 if (tcpm_start_toggling(port, TYPEC_CC_RD)) {
4959                         tcpm_set_state(port, TOGGLING, 0);
4960                         break;
4961                 }
4962                 tcpm_set_cc(port, TYPEC_CC_RD);
4963                 if (port->port_type == TYPEC_PORT_DRP)
4964                         tcpm_set_state(port, SRC_UNATTACHED, PD_T_DRP_SRC);
4965                 break;
4966         case SNK_ATTACH_WAIT:
4967                 if ((port->cc1 == TYPEC_CC_OPEN &&
4968                      port->cc2 != TYPEC_CC_OPEN) ||
4969                     (port->cc1 != TYPEC_CC_OPEN &&
4970                      port->cc2 == TYPEC_CC_OPEN))
4971                         tcpm_set_state(port, SNK_DEBOUNCED,
4972                                        port->timings.cc_debounce_time);
4973                 else if (tcpm_port_is_disconnected(port))
4974                         tcpm_set_state(port, SNK_UNATTACHED,
4975                                        PD_T_PD_DEBOUNCE);
4976                 break;
4977         case SNK_DEBOUNCED:
4978                 if (tcpm_port_is_disconnected(port))
4979                         tcpm_set_state(port, SNK_UNATTACHED,
4980                                        PD_T_PD_DEBOUNCE);
4981                 else if (port->vbus_present)
4982                         tcpm_set_state(port,
4983                                        tcpm_try_src(port) ? SRC_TRY
4984                                                           : SNK_ATTACHED,
4985                                        0);
4986                 break;
4987         case SRC_TRY:
4988                 port->try_src_count++;
4989                 tcpm_set_cc(port, tcpm_rp_cc(port));
4990                 port->max_wait = 0;
4991                 tcpm_set_state(port, SRC_TRY_WAIT, 0);
4992                 break;
4993         case SRC_TRY_WAIT:
4994                 if (port->max_wait == 0) {
4995                         port->max_wait = jiffies +
4996                                          msecs_to_jiffies(PD_T_DRP_TRY);
4997                         msecs = PD_T_DRP_TRY;
4998                 } else {
4999                         if (time_is_after_jiffies(port->max_wait))
5000                                 msecs = jiffies_to_msecs(port->max_wait -
5001                                                          jiffies);
5002                         else
5003                                 msecs = 0;
5004                 }
5005                 tcpm_set_state(port, SNK_TRYWAIT, msecs);
5006                 break;
5007         case SRC_TRY_DEBOUNCE:
5008                 tcpm_set_state(port, SRC_ATTACHED, PD_T_PD_DEBOUNCE);
5009                 break;
5010         case SNK_TRYWAIT:
5011                 tcpm_set_cc(port, TYPEC_CC_RD);
5012                 tcpm_set_state(port, SNK_TRYWAIT_VBUS, port->timings.cc_debounce_time);
5013                 break;
5014         case SNK_TRYWAIT_VBUS:
5015                 /*
5016                  * TCPM stays in this state indefinitely until VBUS
5017                  * is detected as long as Rp is not detected for
5018                  * more than a time period of tPDDebounce.
5019                  */
5020                 if (port->vbus_present && tcpm_port_is_sink(port)) {
5021                         tcpm_set_state(port, SNK_ATTACHED, 0);
5022                         break;
5023                 }
5024                 if (!tcpm_port_is_sink(port))
5025                         tcpm_set_state(port, SNK_TRYWAIT_DEBOUNCE, 0);
5026                 break;
5027         case SNK_TRYWAIT_DEBOUNCE:
5028                 tcpm_set_state(port, SNK_UNATTACHED, PD_T_PD_DEBOUNCE);
5029                 break;
5030         case SNK_ATTACHED:
5031                 ret = tcpm_snk_attach(port);
5032                 if (ret < 0)
5033                         tcpm_set_state(port, SNK_UNATTACHED, 0);
5034                 else
5035                         /*
5036                          * For Type C port controllers that use Battery Charging
5037                          * Detection (based on BCv1.2 spec) to detect USB
5038                          * charger type, add a delay of "snk_bc12_cmpletion_time"
5039                          * before transitioning to SNK_STARTUP to allow BC1.2
5040                          * detection to complete before PD is eventually enabled
5041                          * in later states.
5042                          */
5043                         tcpm_set_state(port, SNK_STARTUP,
5044                                        port->timings.snk_bc12_cmpletion_time);
5045                 break;
5046         case SNK_STARTUP:
5047                 opmode =  tcpm_get_pwr_opmode(port->polarity ?
5048                                               port->cc2 : port->cc1);
5049                 typec_set_pwr_opmode(port->typec_port, opmode);
5050                 port->pwr_opmode = TYPEC_PWR_MODE_USB;
5051                 port->negotiated_rev = PD_MAX_REV;
5052                 port->negotiated_rev_prime = PD_MAX_REV;
5053                 port->message_id = 0;
5054                 port->message_id_prime = 0;
5055                 port->rx_msgid = -1;
5056                 port->rx_msgid_prime = -1;
5057                 port->explicit_contract = false;
5058
5059                 if (port->ams == POWER_ROLE_SWAP ||
5060                     port->ams == FAST_ROLE_SWAP)
5061                         /* SRC -> SNK POWER/FAST_ROLE_SWAP finished */
5062                         tcpm_ams_finish(port);
5063
5064                 tcpm_set_state(port, SNK_DISCOVERY, 0);
5065                 break;
5066         case SNK_DISCOVERY:
5067                 if (port->vbus_present) {
5068                         u32 current_lim = tcpm_get_current_limit(port);
5069
5070                         if (port->slow_charger_loop && (current_lim > PD_P_SNK_STDBY_MW / 5))
5071                                 current_lim = PD_P_SNK_STDBY_MW / 5;
5072                         tcpm_set_current_limit(port, current_lim, 5000);
5073                         /* Not sink vbus if operational current is 0mA */
5074                         tcpm_set_charge(port, !port->pd_supported ||
5075                                         pdo_max_current(port->snk_pdo[0]));
5076
5077                         if (!port->pd_supported)
5078                                 tcpm_set_state(port, SNK_READY, 0);
5079                         else
5080                                 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0);
5081                         break;
5082                 }
5083                 /*
5084                  * For DRP, timeouts differ. Also, handling is supposed to be
5085                  * different and much more complex (dead battery detection;
5086                  * see USB power delivery specification, section 8.3.3.6.1.5.1).
5087                  */
5088                 tcpm_set_state(port, hard_reset_state(port),
5089                                port->port_type == TYPEC_PORT_DRP ?
5090                                         PD_T_DB_DETECT : PD_T_NO_RESPONSE);
5091                 break;
5092         case SNK_DISCOVERY_DEBOUNCE:
5093                 tcpm_set_state(port, SNK_DISCOVERY_DEBOUNCE_DONE,
5094                                port->timings.cc_debounce_time);
5095                 break;
5096         case SNK_DISCOVERY_DEBOUNCE_DONE:
5097                 if (!tcpm_port_is_disconnected(port) &&
5098                     tcpm_port_is_sink(port) &&
5099                     ktime_after(port->delayed_runtime, ktime_get())) {
5100                         tcpm_set_state(port, SNK_DISCOVERY,
5101                                        ktime_to_ms(ktime_sub(port->delayed_runtime, ktime_get())));
5102                         break;
5103                 }
5104                 tcpm_set_state(port, unattached_state(port), 0);
5105                 break;
5106         case SNK_WAIT_CAPABILITIES:
5107                 ret = port->tcpc->set_pd_rx(port->tcpc, true);
5108                 if (ret < 0) {
5109                         tcpm_set_state(port, SNK_READY, 0);
5110                         break;
5111                 }
5112                 /*
5113                  * If VBUS has never been low, and we time out waiting
5114                  * for source cap, try a soft reset first, in case we
5115                  * were already in a stable contract before this boot.
5116                  * Do this only once.
5117                  */
5118                 if (port->vbus_never_low) {
5119                         port->vbus_never_low = false;
5120                         tcpm_set_state(port, SNK_SOFT_RESET,
5121                                        port->timings.sink_wait_cap_time);
5122                 } else {
5123                         if (!port->self_powered)
5124                                 upcoming_state = SNK_WAIT_CAPABILITIES_TIMEOUT;
5125                         else
5126                                 upcoming_state = hard_reset_state(port);
5127                         tcpm_set_state(port, SNK_WAIT_CAPABILITIES_TIMEOUT,
5128                                        port->timings.sink_wait_cap_time);
5129                 }
5130                 break;
5131         case SNK_WAIT_CAPABILITIES_TIMEOUT:
5132                 /*
5133                  * There are some USB PD sources in the field, which do not
5134                  * properly implement the specification and fail to start
5135                  * sending Source Capability messages after a soft reset. The
5136                  * specification suggests to do a hard reset when no Source
5137                  * capability message is received within PD_T_SINK_WAIT_CAP,
5138                  * but that might effectively kil the machine's power source.
5139                  *
5140                  * This slightly diverges from the specification and tries to
5141                  * recover from this by explicitly asking for the capabilities
5142                  * using the Get_Source_Cap control message before falling back
5143                  * to a hard reset. The control message should also be supported
5144                  * and handled by all USB PD source and dual role devices
5145                  * according to the specification.
5146                  */
5147                 if (tcpm_pd_send_control(port, PD_CTRL_GET_SOURCE_CAP, TCPC_TX_SOP))
5148                         tcpm_set_state_cond(port, hard_reset_state(port), 0);
5149                 else
5150                         tcpm_set_state(port, hard_reset_state(port),
5151                                        port->timings.sink_wait_cap_time);
5152                 break;
5153         case SNK_NEGOTIATE_CAPABILITIES:
5154                 port->pd_capable = true;
5155                 tcpm_set_partner_usb_comm_capable(port,
5156                                                   !!(port->source_caps[0] & PDO_FIXED_USB_COMM));
5157                 port->hard_reset_count = 0;
5158                 ret = tcpm_pd_send_request(port);
5159                 if (ret < 0) {
5160                         /* Restore back to the original state */
5161                         tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_PD,
5162                                                                port->pps_data.active,
5163                                                                port->supply_voltage);
5164                         /* Let the Source send capabilities again. */
5165                         tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0);
5166                 } else {
5167                         tcpm_set_state_cond(port, hard_reset_state(port),
5168                                             PD_T_SENDER_RESPONSE);
5169                 }
5170                 break;
5171         case SNK_NEGOTIATE_PPS_CAPABILITIES:
5172                 ret = tcpm_pd_send_pps_request(port);
5173                 if (ret < 0) {
5174                         /* Restore back to the original state */
5175                         tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_PD,
5176                                                                port->pps_data.active,
5177                                                                port->supply_voltage);
5178                         port->pps_status = ret;
5179                         /*
5180                          * If this was called due to updates to sink
5181                          * capabilities, and pps is no longer valid, we should
5182                          * safely fall back to a standard PDO.
5183                          */
5184                         if (port->update_sink_caps)
5185                                 tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0);
5186                         else
5187                                 tcpm_set_state(port, SNK_READY, 0);
5188                 } else {
5189                         tcpm_set_state_cond(port, hard_reset_state(port),
5190                                             PD_T_SENDER_RESPONSE);
5191                 }
5192                 break;
5193         case SNK_TRANSITION_SINK:
5194                 /* From the USB PD spec:
5195                  * "The Sink Shall transition to Sink Standby before a positive or
5196                  * negative voltage transition of VBUS. During Sink Standby
5197                  * the Sink Shall reduce its power draw to pSnkStdby."
5198                  *
5199                  * This is not applicable to PPS though as the port can continue
5200                  * to draw negotiated power without switching to standby.
5201                  */
5202                 if (port->supply_voltage != port->req_supply_voltage && !port->pps_data.active &&
5203                     port->current_limit * port->supply_voltage / 1000 > PD_P_SNK_STDBY_MW) {
5204                         u32 stdby_ma = PD_P_SNK_STDBY_MW * 1000 / port->supply_voltage;
5205
5206                         tcpm_log(port, "Setting standby current %u mV @ %u mA",
5207                                  port->supply_voltage, stdby_ma);
5208                         tcpm_set_current_limit(port, stdby_ma, port->supply_voltage);
5209                 }
5210                 fallthrough;
5211         case SNK_TRANSITION_SINK_VBUS:
5212                 tcpm_set_state(port, hard_reset_state(port),
5213                                PD_T_PS_TRANSITION);
5214                 break;
5215         case SNK_READY:
5216                 port->try_snk_count = 0;
5217                 port->update_sink_caps = false;
5218                 if (port->explicit_contract) {
5219                         typec_set_pwr_opmode(port->typec_port,
5220                                              TYPEC_PWR_MODE_PD);
5221                         port->pwr_opmode = TYPEC_PWR_MODE_PD;
5222                 }
5223
5224                 if (!port->pd_capable && port->slow_charger_loop)
5225                         tcpm_set_current_limit(port, tcpm_get_current_limit(port), 5000);
5226                 tcpm_swap_complete(port, 0);
5227                 tcpm_typec_connect(port);
5228                 if (port->pd_capable && port->source_caps[0] & PDO_FIXED_DUAL_ROLE)
5229                         mod_enable_frs_delayed_work(port, 0);
5230                 tcpm_pps_complete(port, port->pps_status);
5231
5232                 if (port->ams != NONE_AMS)
5233                         tcpm_ams_finish(port);
5234                 if (port->next_ams != NONE_AMS) {
5235                         port->ams = port->next_ams;
5236                         port->next_ams = NONE_AMS;
5237                 }
5238
5239                 /*
5240                  * If previous AMS is interrupted, switch to the upcoming
5241                  * state.
5242                  */
5243                 if (port->upcoming_state != INVALID_STATE) {
5244                         upcoming_state = port->upcoming_state;
5245                         port->upcoming_state = INVALID_STATE;
5246                         tcpm_set_state(port, upcoming_state, 0);
5247                         break;
5248                 }
5249
5250                 /*
5251                  * 6.4.4.3.1 Discover Identity
5252                  * "The Discover Identity Command Shall only be sent to SOP when there is an
5253                  * Explicit Contract."
5254                  *
5255                  * Discover Identity on SOP' should be discovered prior to the
5256                  * ready state, but if done after a Vconn Swap following Discover
5257                  * Identity on SOP then the discovery process can be run here
5258                  * as well.
5259                  */
5260                 if (port->explicit_contract) {
5261                         if (port->send_discover_prime) {
5262                                 port->tx_sop_type = TCPC_TX_SOP_PRIME;
5263                         } else {
5264                                 port->tx_sop_type = TCPC_TX_SOP;
5265                                 tcpm_set_initial_svdm_version(port);
5266                         }
5267                         mod_send_discover_delayed_work(port, 0);
5268                 } else {
5269                         port->send_discover = false;
5270                         port->send_discover_prime = false;
5271                 }
5272
5273                 power_supply_changed(port->psy);
5274                 break;
5275
5276         /* Accessory states */
5277         case ACC_UNATTACHED:
5278                 tcpm_acc_detach(port);
5279                 tcpm_set_state(port, SRC_UNATTACHED, 0);
5280                 break;
5281         case DEBUG_ACC_ATTACHED:
5282         case AUDIO_ACC_ATTACHED:
5283                 ret = tcpm_acc_attach(port);
5284                 if (ret < 0)
5285                         tcpm_set_state(port, ACC_UNATTACHED, 0);
5286                 break;
5287         case AUDIO_ACC_DEBOUNCE:
5288                 tcpm_set_state(port, ACC_UNATTACHED, port->timings.cc_debounce_time);
5289                 break;
5290
5291         /* Hard_Reset states */
5292         case HARD_RESET_SEND:
5293                 if (port->ams != NONE_AMS)
5294                         tcpm_ams_finish(port);
5295                 if (!port->self_powered && port->port_type == TYPEC_PORT_SNK)
5296                         dev_err(port->dev, "Initiating hard-reset, which might result in machine power-loss.\n");
5297                 /*
5298                  * State machine will be directed to HARD_RESET_START,
5299                  * thus set upcoming_state to INVALID_STATE.
5300                  */
5301                 port->upcoming_state = INVALID_STATE;
5302                 tcpm_ams_start(port, HARD_RESET);
5303                 break;
5304         case HARD_RESET_START:
5305                 port->sink_cap_done = false;
5306                 if (port->tcpc->enable_frs)
5307                         port->tcpc->enable_frs(port->tcpc, false);
5308                 port->hard_reset_count++;
5309                 port->tcpc->set_pd_rx(port->tcpc, false);
5310                 tcpm_unregister_altmodes(port);
5311                 port->nr_sink_caps = 0;
5312                 port->send_discover = true;
5313                 port->send_discover_prime = false;
5314                 if (port->pwr_role == TYPEC_SOURCE)
5315                         tcpm_set_state(port, SRC_HARD_RESET_VBUS_OFF,
5316                                        PD_T_PS_HARD_RESET);
5317                 else
5318                         tcpm_set_state(port, SNK_HARD_RESET_SINK_OFF, 0);
5319                 break;
5320         case SRC_HARD_RESET_VBUS_OFF:
5321                 /*
5322                  * 7.1.5 Response to Hard Resets
5323                  * Hard Reset Signaling indicates a communication failure has occurred and the
5324                  * Source Shall stop driving VCONN, Shall remove Rp from the VCONN pin and Shall
5325                  * drive VBUS to vSafe0V as shown in Figure 7-9.
5326                  */
5327                 tcpm_set_vconn(port, false);
5328                 tcpm_set_vbus(port, false);
5329                 tcpm_set_roles(port, port->self_powered, TYPEC_SOURCE,
5330                                tcpm_data_role_for_source(port));
5331                 /*
5332                  * If tcpc fails to notify vbus off, TCPM will wait for PD_T_SAFE_0V +
5333                  * PD_T_SRC_RECOVER before turning vbus back on.
5334                  * From Table 7-12 Sequence Description for a Source Initiated Hard Reset:
5335                  * 4. Policy Engine waits tPSHardReset after sending Hard Reset Signaling and then
5336                  * tells the Device Policy Manager to instruct the power supply to perform a
5337                  * Hard Reset. The transition to vSafe0V Shall occur within tSafe0V (t2).
5338                  * 5. After tSrcRecover the Source applies power to VBUS in an attempt to
5339                  * re-establish communication with the Sink and resume USB Default Operation.
5340                  * The transition to vSafe5V Shall occur within tSrcTurnOn(t4).
5341                  */
5342                 tcpm_set_state(port, SRC_HARD_RESET_VBUS_ON, PD_T_SAFE_0V + PD_T_SRC_RECOVER);
5343                 break;
5344         case SRC_HARD_RESET_VBUS_ON:
5345                 tcpm_set_vconn(port, true);
5346                 tcpm_set_vbus(port, true);
5347                 if (port->ams == HARD_RESET)
5348                         tcpm_ams_finish(port);
5349                 if (port->pd_supported)
5350                         port->tcpc->set_pd_rx(port->tcpc, true);
5351                 tcpm_set_attached_state(port, true);
5352                 tcpm_set_state(port, SRC_UNATTACHED, PD_T_PS_SOURCE_ON);
5353                 break;
5354         case SNK_HARD_RESET_SINK_OFF:
5355                 /* Do not discharge/disconnect during hard reset */
5356                 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, 0);
5357                 memset(&port->pps_data, 0, sizeof(port->pps_data));
5358                 tcpm_set_vconn(port, false);
5359                 if (port->pd_capable)
5360                         tcpm_set_charge(port, false);
5361                 tcpm_set_roles(port, port->self_powered, TYPEC_SINK,
5362                                tcpm_data_role_for_sink(port));
5363                 /*
5364                  * VBUS may or may not toggle, depending on the adapter.
5365                  * If it doesn't toggle, transition to SNK_HARD_RESET_SINK_ON
5366                  * directly after timeout.
5367                  */
5368                 tcpm_set_state(port, SNK_HARD_RESET_SINK_ON, PD_T_SAFE_0V);
5369                 break;
5370         case SNK_HARD_RESET_WAIT_VBUS:
5371                 if (port->ams == HARD_RESET)
5372                         tcpm_ams_finish(port);
5373                 /* Assume we're disconnected if VBUS doesn't come back. */
5374                 tcpm_set_state(port, SNK_UNATTACHED,
5375                                PD_T_SRC_RECOVER_MAX + PD_T_SRC_TURN_ON);
5376                 break;
5377         case SNK_HARD_RESET_SINK_ON:
5378                 /* Note: There is no guarantee that VBUS is on in this state */
5379                 /*
5380                  * XXX:
5381                  * The specification suggests that dual mode ports in sink
5382                  * mode should transition to state PE_SRC_Transition_to_default.
5383                  * See USB power delivery specification chapter 8.3.3.6.1.3.
5384                  * This would mean to
5385                  * - turn off VCONN, reset power supply
5386                  * - request hardware reset
5387                  * - turn on VCONN
5388                  * - Transition to state PE_Src_Startup
5389                  * SNK only ports shall transition to state Snk_Startup
5390                  * (see chapter 8.3.3.3.8).
5391                  * Similar, dual-mode ports in source mode should transition
5392                  * to PE_SNK_Transition_to_default.
5393                  */
5394                 if (port->pd_capable) {
5395                         tcpm_set_current_limit(port,
5396                                                tcpm_get_current_limit(port),
5397                                                5000);
5398                         /* Not sink vbus if operational current is 0mA */
5399                         tcpm_set_charge(port, !!pdo_max_current(port->snk_pdo[0]));
5400                 }
5401                 if (port->ams == HARD_RESET)
5402                         tcpm_ams_finish(port);
5403                 tcpm_set_attached_state(port, true);
5404                 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, VSAFE5V);
5405                 tcpm_set_state(port, SNK_STARTUP, 0);
5406                 break;
5407
5408         /* Soft_Reset states */
5409         case SOFT_RESET:
5410                 port->message_id = 0;
5411                 port->rx_msgid = -1;
5412                 /* remove existing capabilities */
5413                 usb_power_delivery_unregister_capabilities(port->partner_source_caps);
5414                 port->partner_source_caps = NULL;
5415                 tcpm_pd_send_control(port, PD_CTRL_ACCEPT, TCPC_TX_SOP);
5416                 tcpm_ams_finish(port);
5417                 if (port->pwr_role == TYPEC_SOURCE) {
5418                         port->upcoming_state = SRC_SEND_CAPABILITIES;
5419                         tcpm_ams_start(port, POWER_NEGOTIATION);
5420                 } else {
5421                         tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0);
5422                 }
5423                 break;
5424         case SRC_SOFT_RESET_WAIT_SNK_TX:
5425         case SNK_SOFT_RESET:
5426                 if (port->ams != NONE_AMS)
5427                         tcpm_ams_finish(port);
5428                 port->upcoming_state = SOFT_RESET_SEND;
5429                 tcpm_ams_start(port, SOFT_RESET_AMS);
5430                 break;
5431         case SOFT_RESET_SEND:
5432                 /*
5433                  * Power Delivery 3.0 Section 6.3.13
5434                  *
5435                  * A Soft_Reset Message Shall be targeted at a specific entity
5436                  * depending on the type of SOP* packet used.
5437                  */
5438                 if (port->tx_sop_type == TCPC_TX_SOP_PRIME) {
5439                         port->message_id_prime = 0;
5440                         port->rx_msgid_prime = -1;
5441                         tcpm_pd_send_control(port, PD_CTRL_SOFT_RESET, TCPC_TX_SOP_PRIME);
5442                         tcpm_set_state_cond(port, ready_state(port), PD_T_SENDER_RESPONSE);
5443                 } else {
5444                         port->message_id = 0;
5445                         port->rx_msgid = -1;
5446                         /* remove existing capabilities */
5447                         usb_power_delivery_unregister_capabilities(port->partner_source_caps);
5448                         port->partner_source_caps = NULL;
5449                         if (tcpm_pd_send_control(port, PD_CTRL_SOFT_RESET, TCPC_TX_SOP))
5450                                 tcpm_set_state_cond(port, hard_reset_state(port), 0);
5451                         else
5452                                 tcpm_set_state_cond(port, hard_reset_state(port),
5453                                                     PD_T_SENDER_RESPONSE);
5454                 }
5455                 break;
5456
5457         /* DR_Swap states */
5458         case DR_SWAP_SEND:
5459                 tcpm_pd_send_control(port, PD_CTRL_DR_SWAP, TCPC_TX_SOP);
5460                 if (port->data_role == TYPEC_DEVICE || port->negotiated_rev > PD_REV20) {
5461                         port->send_discover = true;
5462                         port->send_discover_prime = false;
5463                 }
5464                 tcpm_set_state_cond(port, DR_SWAP_SEND_TIMEOUT,
5465                                     PD_T_SENDER_RESPONSE);
5466                 break;
5467         case DR_SWAP_ACCEPT:
5468                 tcpm_pd_send_control(port, PD_CTRL_ACCEPT, TCPC_TX_SOP);
5469                 if (port->data_role == TYPEC_DEVICE || port->negotiated_rev > PD_REV20) {
5470                         port->send_discover = true;
5471                         port->send_discover_prime = false;
5472                 }
5473                 tcpm_set_state_cond(port, DR_SWAP_CHANGE_DR, 0);
5474                 break;
5475         case DR_SWAP_SEND_TIMEOUT:
5476                 tcpm_swap_complete(port, -ETIMEDOUT);
5477                 port->send_discover = false;
5478                 port->send_discover_prime = false;
5479                 tcpm_ams_finish(port);
5480                 tcpm_set_state(port, ready_state(port), 0);
5481                 break;
5482         case DR_SWAP_CHANGE_DR:
5483                 tcpm_unregister_altmodes(port);
5484                 if (port->data_role == TYPEC_HOST)
5485                         tcpm_set_roles(port, true, port->pwr_role,
5486                                        TYPEC_DEVICE);
5487                 else
5488                         tcpm_set_roles(port, true, port->pwr_role,
5489                                        TYPEC_HOST);
5490                 tcpm_ams_finish(port);
5491                 tcpm_set_state(port, ready_state(port), 0);
5492                 break;
5493
5494         case FR_SWAP_SEND:
5495                 if (tcpm_pd_send_control(port, PD_CTRL_FR_SWAP, TCPC_TX_SOP)) {
5496                         tcpm_set_state(port, ERROR_RECOVERY, 0);
5497                         break;
5498                 }
5499                 tcpm_set_state_cond(port, FR_SWAP_SEND_TIMEOUT, PD_T_SENDER_RESPONSE);
5500                 break;
5501         case FR_SWAP_SEND_TIMEOUT:
5502                 tcpm_set_state(port, ERROR_RECOVERY, 0);
5503                 break;
5504         case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF:
5505                 tcpm_set_state(port, ERROR_RECOVERY, port->timings.ps_src_off_time);
5506                 break;
5507         case FR_SWAP_SNK_SRC_NEW_SINK_READY:
5508                 if (port->vbus_source)
5509                         tcpm_set_state(port, FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED, 0);
5510                 else
5511                         tcpm_set_state(port, ERROR_RECOVERY, PD_T_RECEIVER_RESPONSE);
5512                 break;
5513         case FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED:
5514                 tcpm_set_pwr_role(port, TYPEC_SOURCE);
5515                 if (tcpm_pd_send_control(port, PD_CTRL_PS_RDY, TCPC_TX_SOP)) {
5516                         tcpm_set_state(port, ERROR_RECOVERY, 0);
5517                         break;
5518                 }
5519                 tcpm_set_cc(port, tcpm_rp_cc(port));
5520                 tcpm_set_state(port, SRC_STARTUP, PD_T_SWAP_SRC_START);
5521                 break;
5522
5523         /* PR_Swap states */
5524         case PR_SWAP_ACCEPT:
5525                 tcpm_pd_send_control(port, PD_CTRL_ACCEPT, TCPC_TX_SOP);
5526                 tcpm_set_state(port, PR_SWAP_START, 0);
5527                 break;
5528         case PR_SWAP_SEND:
5529                 tcpm_pd_send_control(port, PD_CTRL_PR_SWAP, TCPC_TX_SOP);
5530                 tcpm_set_state_cond(port, PR_SWAP_SEND_TIMEOUT,
5531                                     PD_T_SENDER_RESPONSE);
5532                 break;
5533         case PR_SWAP_SEND_TIMEOUT:
5534                 tcpm_swap_complete(port, -ETIMEDOUT);
5535                 tcpm_set_state(port, ready_state(port), 0);
5536                 break;
5537         case PR_SWAP_START:
5538                 tcpm_apply_rc(port);
5539                 if (port->pwr_role == TYPEC_SOURCE)
5540                         tcpm_set_state(port, PR_SWAP_SRC_SNK_TRANSITION_OFF,
5541                                        PD_T_SRC_TRANSITION);
5542                 else
5543                         tcpm_set_state(port, PR_SWAP_SNK_SRC_SINK_OFF, 0);
5544                 break;
5545         case PR_SWAP_SRC_SNK_TRANSITION_OFF:
5546                 /*
5547                  * Prevent vbus discharge circuit from turning on during PR_SWAP
5548                  * as this is not a disconnect.
5549                  */
5550                 tcpm_set_vbus(port, false);
5551                 port->explicit_contract = false;
5552                 /* allow time for Vbus discharge, must be < tSrcSwapStdby */
5553                 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF,
5554                                PD_T_SRCSWAPSTDBY);
5555                 break;
5556         case PR_SWAP_SRC_SNK_SOURCE_OFF:
5557                 tcpm_set_cc(port, TYPEC_CC_RD);
5558                 /* allow CC debounce */
5559                 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED,
5560                                port->timings.cc_debounce_time);
5561                 break;
5562         case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED:
5563                 /*
5564                  * USB-PD standard, 6.2.1.4, Port Power Role:
5565                  * "During the Power Role Swap Sequence, for the initial Source
5566                  * Port, the Port Power Role field shall be set to Sink in the
5567                  * PS_RDY Message indicating that the initial Source’s power
5568                  * supply is turned off"
5569                  */
5570                 tcpm_set_pwr_role(port, TYPEC_SINK);
5571                 if (tcpm_pd_send_control(port, PD_CTRL_PS_RDY, TCPC_TX_SOP)) {
5572                         tcpm_set_state(port, ERROR_RECOVERY, 0);
5573                         break;
5574                 }
5575                 tcpm_set_state(port, ERROR_RECOVERY, PD_T_PS_SOURCE_ON_PRS);
5576                 break;
5577         case PR_SWAP_SRC_SNK_SINK_ON:
5578                 tcpm_enable_auto_vbus_discharge(port, true);
5579                 /* Set the vbus disconnect threshold for implicit contract */
5580                 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, VSAFE5V);
5581                 tcpm_set_state(port, SNK_STARTUP, 0);
5582                 break;
5583         case PR_SWAP_SNK_SRC_SINK_OFF:
5584                 /* will be source, remove existing capabilities */
5585                 usb_power_delivery_unregister_capabilities(port->partner_source_caps);
5586                 port->partner_source_caps = NULL;
5587                 /*
5588                  * Prevent vbus discharge circuit from turning on during PR_SWAP
5589                  * as this is not a disconnect.
5590                  */
5591                 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB,
5592                                                        port->pps_data.active, 0);
5593                 tcpm_set_charge(port, false);
5594                 tcpm_set_state(port, ERROR_RECOVERY, port->timings.ps_src_off_time);
5595                 break;
5596         case PR_SWAP_SNK_SRC_SOURCE_ON:
5597                 tcpm_enable_auto_vbus_discharge(port, true);
5598                 tcpm_set_cc(port, tcpm_rp_cc(port));
5599                 tcpm_set_vbus(port, true);
5600                 /*
5601                  * allow time VBUS ramp-up, must be < tNewSrc
5602                  * Also, this window overlaps with CC debounce as well.
5603                  * So, Wait for the max of two which is PD_T_NEWSRC
5604                  */
5605                 tcpm_set_state(port, PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP,
5606                                PD_T_NEWSRC);
5607                 break;
5608         case PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP:
5609                 /*
5610                  * USB PD standard, 6.2.1.4:
5611                  * "Subsequent Messages initiated by the Policy Engine,
5612                  * such as the PS_RDY Message sent to indicate that Vbus
5613                  * is ready, will have the Port Power Role field set to
5614                  * Source."
5615                  */
5616                 tcpm_set_pwr_role(port, TYPEC_SOURCE);
5617                 tcpm_pd_send_control(port, PD_CTRL_PS_RDY, TCPC_TX_SOP);
5618                 tcpm_set_state(port, SRC_STARTUP, PD_T_SWAP_SRC_START);
5619                 break;
5620
5621         case VCONN_SWAP_ACCEPT:
5622                 tcpm_pd_send_control(port, PD_CTRL_ACCEPT, TCPC_TX_SOP);
5623                 tcpm_ams_finish(port);
5624                 tcpm_set_state(port, VCONN_SWAP_START, 0);
5625                 break;
5626         case VCONN_SWAP_SEND:
5627                 tcpm_pd_send_control(port, PD_CTRL_VCONN_SWAP, TCPC_TX_SOP);
5628                 tcpm_set_state(port, VCONN_SWAP_SEND_TIMEOUT,
5629                                PD_T_SENDER_RESPONSE);
5630                 break;
5631         case VCONN_SWAP_SEND_TIMEOUT:
5632                 tcpm_swap_complete(port, -ETIMEDOUT);
5633                 tcpm_set_state(port, ready_state(port), 0);
5634                 break;
5635         case VCONN_SWAP_START:
5636                 if (port->vconn_role == TYPEC_SOURCE)
5637                         tcpm_set_state(port, VCONN_SWAP_WAIT_FOR_VCONN, 0);
5638                 else
5639                         tcpm_set_state(port, VCONN_SWAP_TURN_ON_VCONN, 0);
5640                 break;
5641         case VCONN_SWAP_WAIT_FOR_VCONN:
5642                 tcpm_set_state(port, hard_reset_state(port),
5643                                PD_T_VCONN_SOURCE_ON);
5644                 break;
5645         case VCONN_SWAP_TURN_ON_VCONN:
5646                 ret = tcpm_set_vconn(port, true);
5647                 tcpm_pd_send_control(port, PD_CTRL_PS_RDY, TCPC_TX_SOP);
5648                 /*
5649                  * USB PD 3.0 Section 6.4.4.3.1
5650                  *
5651                  * Note that a Cable Plug or VPD will not be ready for PD
5652                  * Communication until tVCONNStable after VCONN has been applied
5653                  */
5654                 if (!ret)
5655                         tcpm_set_state(port, VCONN_SWAP_SEND_SOFT_RESET,
5656                                        PD_T_VCONN_STABLE);
5657                 else
5658                         tcpm_set_state(port, ready_state(port), 0);
5659                 break;
5660         case VCONN_SWAP_TURN_OFF_VCONN:
5661                 tcpm_set_vconn(port, false);
5662                 tcpm_set_state(port, ready_state(port), 0);
5663                 break;
5664         case VCONN_SWAP_SEND_SOFT_RESET:
5665                 tcpm_swap_complete(port, port->swap_status);
5666                 if (tcpm_can_communicate_sop_prime(port)) {
5667                         port->tx_sop_type = TCPC_TX_SOP_PRIME;
5668                         port->upcoming_state = SOFT_RESET_SEND;
5669                         tcpm_ams_start(port, SOFT_RESET_AMS);
5670                 } else {
5671                         tcpm_set_state(port, ready_state(port), 0);
5672                 }
5673                 break;
5674
5675         case DR_SWAP_CANCEL:
5676         case PR_SWAP_CANCEL:
5677         case VCONN_SWAP_CANCEL:
5678                 tcpm_swap_complete(port, port->swap_status);
5679                 if (port->pwr_role == TYPEC_SOURCE)
5680                         tcpm_set_state(port, SRC_READY, 0);
5681                 else
5682                         tcpm_set_state(port, SNK_READY, 0);
5683                 break;
5684         case FR_SWAP_CANCEL:
5685                 if (port->pwr_role == TYPEC_SOURCE)
5686                         tcpm_set_state(port, SRC_READY, 0);
5687                 else
5688                         tcpm_set_state(port, SNK_READY, 0);
5689                 break;
5690
5691         case BIST_RX:
5692                 switch (BDO_MODE_MASK(port->bist_request)) {
5693                 case BDO_MODE_CARRIER2:
5694                         tcpm_pd_transmit(port, TCPC_TX_BIST_MODE_2, NULL);
5695                         tcpm_set_state(port, unattached_state(port),
5696                                        PD_T_BIST_CONT_MODE);
5697                         break;
5698                 case BDO_MODE_TESTDATA:
5699                         if (port->tcpc->set_bist_data) {
5700                                 tcpm_log(port, "Enable BIST MODE TESTDATA");
5701                                 port->tcpc->set_bist_data(port->tcpc, true);
5702                         }
5703                         break;
5704                 default:
5705                         break;
5706                 }
5707                 break;
5708         case GET_STATUS_SEND:
5709                 tcpm_pd_send_control(port, PD_CTRL_GET_STATUS, TCPC_TX_SOP);
5710                 tcpm_set_state(port, GET_STATUS_SEND_TIMEOUT,
5711                                PD_T_SENDER_RESPONSE);
5712                 break;
5713         case GET_STATUS_SEND_TIMEOUT:
5714                 tcpm_set_state(port, ready_state(port), 0);
5715                 break;
5716         case GET_PPS_STATUS_SEND:
5717                 tcpm_pd_send_control(port, PD_CTRL_GET_PPS_STATUS, TCPC_TX_SOP);
5718                 tcpm_set_state(port, GET_PPS_STATUS_SEND_TIMEOUT,
5719                                PD_T_SENDER_RESPONSE);
5720                 break;
5721         case GET_PPS_STATUS_SEND_TIMEOUT:
5722                 tcpm_set_state(port, ready_state(port), 0);
5723                 break;
5724         case GET_SINK_CAP:
5725                 tcpm_pd_send_control(port, PD_CTRL_GET_SINK_CAP, TCPC_TX_SOP);
5726                 tcpm_set_state(port, GET_SINK_CAP_TIMEOUT, PD_T_SENDER_RESPONSE);
5727                 break;
5728         case GET_SINK_CAP_TIMEOUT:
5729                 port->sink_cap_done = true;
5730                 tcpm_set_state(port, ready_state(port), 0);
5731                 break;
5732         case ERROR_RECOVERY:
5733                 tcpm_swap_complete(port, -EPROTO);
5734                 tcpm_pps_complete(port, -EPROTO);
5735                 tcpm_set_state(port, PORT_RESET, 0);
5736                 break;
5737         case PORT_RESET:
5738                 tcpm_reset_port(port);
5739                 if (port->self_powered)
5740                         tcpm_set_cc(port, TYPEC_CC_OPEN);
5741                 else
5742                         tcpm_set_cc(port, tcpm_default_state(port) == SNK_UNATTACHED ?
5743                                     TYPEC_CC_RD : tcpm_rp_cc(port));
5744                 tcpm_set_state(port, PORT_RESET_WAIT_OFF,
5745                                PD_T_ERROR_RECOVERY);
5746                 break;
5747         case PORT_RESET_WAIT_OFF:
5748                 tcpm_set_state(port,
5749                                tcpm_default_state(port),
5750                                port->vbus_present ? port->timings.ps_src_off_time : 0);
5751                 break;
5752
5753         /* AMS intermediate state */
5754         case AMS_START:
5755                 if (port->upcoming_state == INVALID_STATE) {
5756                         tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ?
5757                                        SRC_READY : SNK_READY, 0);
5758                         break;
5759                 }
5760
5761                 upcoming_state = port->upcoming_state;
5762                 port->upcoming_state = INVALID_STATE;
5763                 tcpm_set_state(port, upcoming_state, 0);
5764                 break;
5765
5766         /* Chunk state */
5767         case CHUNK_NOT_SUPP:
5768                 tcpm_pd_send_control(port, PD_CTRL_NOT_SUPP, TCPC_TX_SOP);
5769                 tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ? SRC_READY : SNK_READY, 0);
5770                 break;
5771
5772         /* Cable states */
5773         case SRC_VDM_IDENTITY_REQUEST:
5774                 port->send_discover_prime = true;
5775                 port->tx_sop_type = TCPC_TX_SOP_PRIME;
5776                 mod_send_discover_delayed_work(port, 0);
5777                 port->upcoming_state = SRC_SEND_CAPABILITIES;
5778                 break;
5779
5780         default:
5781                 WARN(1, "Unexpected port state %d\n", port->state);
5782                 break;
5783         }
5784 }
5785
5786 static void tcpm_state_machine_work(struct kthread_work *work)
5787 {
5788         struct tcpm_port *port = container_of(work, struct tcpm_port, state_machine);
5789         enum tcpm_state prev_state;
5790
5791         mutex_lock(&port->lock);
5792         port->state_machine_running = true;
5793
5794         if (port->queued_message && tcpm_send_queued_message(port))
5795                 goto done;
5796
5797         /* If we were queued due to a delayed state change, update it now */
5798         if (port->delayed_state) {
5799                 tcpm_log(port, "state change %s -> %s [delayed %ld ms]",
5800                          tcpm_states[port->state],
5801                          tcpm_states[port->delayed_state], port->delay_ms);
5802                 port->prev_state = port->state;
5803                 port->state = port->delayed_state;
5804                 port->delayed_state = INVALID_STATE;
5805         }
5806
5807         /*
5808          * Continue running as long as we have (non-delayed) state changes
5809          * to make.
5810          */
5811         do {
5812                 prev_state = port->state;
5813                 run_state_machine(port);
5814                 if (port->queued_message)
5815                         tcpm_send_queued_message(port);
5816         } while (port->state != prev_state && !port->delayed_state);
5817
5818 done:
5819         port->state_machine_running = false;
5820         mutex_unlock(&port->lock);
5821 }
5822
5823 static void _tcpm_cc_change(struct tcpm_port *port, enum typec_cc_status cc1,
5824                             enum typec_cc_status cc2)
5825 {
5826         enum typec_cc_status old_cc1, old_cc2;
5827         enum tcpm_state new_state;
5828
5829         old_cc1 = port->cc1;
5830         old_cc2 = port->cc2;
5831         port->cc1 = cc1;
5832         port->cc2 = cc2;
5833
5834         tcpm_log_force(port,
5835                        "CC1: %u -> %u, CC2: %u -> %u [state %s, polarity %d, %s]",
5836                        old_cc1, cc1, old_cc2, cc2, tcpm_states[port->state],
5837                        port->polarity,
5838                        tcpm_port_is_disconnected(port) ? "disconnected"
5839                                                        : "connected");
5840
5841         switch (port->state) {
5842         case TOGGLING:
5843                 if (tcpm_port_is_debug(port) || tcpm_port_is_audio(port) ||
5844                     tcpm_port_is_source(port))
5845                         tcpm_set_state(port, SRC_ATTACH_WAIT, 0);
5846                 else if (tcpm_port_is_sink(port))
5847                         tcpm_set_state(port, SNK_ATTACH_WAIT, 0);
5848                 break;
5849         case CHECK_CONTAMINANT:
5850                 /* Wait for Toggling to be resumed */
5851                 break;
5852         case SRC_UNATTACHED:
5853         case ACC_UNATTACHED:
5854                 if (tcpm_port_is_debug(port) || tcpm_port_is_audio(port) ||
5855                     tcpm_port_is_source(port))
5856                         tcpm_set_state(port, SRC_ATTACH_WAIT, 0);
5857                 break;
5858         case SRC_ATTACH_WAIT:
5859                 if (tcpm_port_is_disconnected(port) ||
5860                     tcpm_port_is_audio_detached(port))
5861                         tcpm_set_state(port, SRC_UNATTACHED, 0);
5862                 else if (cc1 != old_cc1 || cc2 != old_cc2)
5863                         tcpm_set_state(port, SRC_ATTACH_WAIT, 0);
5864                 break;
5865         case SRC_ATTACHED:
5866         case SRC_STARTUP:
5867         case SRC_SEND_CAPABILITIES:
5868         case SRC_READY:
5869                 if (tcpm_port_is_disconnected(port) ||
5870                     !tcpm_port_is_source(port)) {
5871                         if (port->port_type == TYPEC_PORT_SRC)
5872                                 tcpm_set_state(port, SRC_UNATTACHED, tcpm_wait_for_discharge(port));
5873                         else
5874                                 tcpm_set_state(port, SNK_UNATTACHED, tcpm_wait_for_discharge(port));
5875                 }
5876                 break;
5877         case SNK_UNATTACHED:
5878                 if (tcpm_port_is_sink(port))
5879                         tcpm_set_state(port, SNK_ATTACH_WAIT, 0);
5880                 break;
5881         case SNK_ATTACH_WAIT:
5882                 if ((port->cc1 == TYPEC_CC_OPEN &&
5883                      port->cc2 != TYPEC_CC_OPEN) ||
5884                     (port->cc1 != TYPEC_CC_OPEN &&
5885                      port->cc2 == TYPEC_CC_OPEN))
5886                         new_state = SNK_DEBOUNCED;
5887                 else if (tcpm_port_is_disconnected(port))
5888                         new_state = SNK_UNATTACHED;
5889                 else
5890                         break;
5891                 if (new_state != port->delayed_state)
5892                         tcpm_set_state(port, SNK_ATTACH_WAIT, 0);
5893                 break;
5894         case SNK_DEBOUNCED:
5895                 if (tcpm_port_is_disconnected(port))
5896                         new_state = SNK_UNATTACHED;
5897                 else if (port->vbus_present)
5898                         new_state = tcpm_try_src(port) ? SRC_TRY : SNK_ATTACHED;
5899                 else
5900                         new_state = SNK_UNATTACHED;
5901                 if (new_state != port->delayed_state)
5902                         tcpm_set_state(port, SNK_DEBOUNCED, 0);
5903                 break;
5904         case SNK_READY:
5905                 /*
5906                  * EXIT condition is based primarily on vbus disconnect and CC is secondary.
5907                  * "A port that has entered into USB PD communications with the Source and
5908                  * has seen the CC voltage exceed vRd-USB may monitor the CC pin to detect
5909                  * cable disconnect in addition to monitoring VBUS.
5910                  *
5911                  * A port that is monitoring the CC voltage for disconnect (but is not in
5912                  * the process of a USB PD PR_Swap or USB PD FR_Swap) shall transition to
5913                  * Unattached.SNK within tSinkDisconnect after the CC voltage remains below
5914                  * vRd-USB for tPDDebounce."
5915                  *
5916                  * When set_auto_vbus_discharge_threshold is enabled, CC pins go
5917                  * away before vbus decays to disconnect threshold. Allow
5918                  * disconnect to be driven by vbus disconnect when auto vbus
5919                  * discharge is enabled.
5920                  */
5921                 if (!port->auto_vbus_discharge_enabled && tcpm_port_is_disconnected(port))
5922                         tcpm_set_state(port, unattached_state(port), 0);
5923                 else if (!port->pd_capable &&
5924                          (cc1 != old_cc1 || cc2 != old_cc2))
5925                         tcpm_set_current_limit(port,
5926                                                tcpm_get_current_limit(port),
5927                                                5000);
5928                 break;
5929
5930         case AUDIO_ACC_ATTACHED:
5931                 if (cc1 == TYPEC_CC_OPEN || cc2 == TYPEC_CC_OPEN)
5932                         tcpm_set_state(port, AUDIO_ACC_DEBOUNCE, 0);
5933                 break;
5934         case AUDIO_ACC_DEBOUNCE:
5935                 if (tcpm_port_is_audio(port))
5936                         tcpm_set_state(port, AUDIO_ACC_ATTACHED, 0);
5937                 break;
5938
5939         case DEBUG_ACC_ATTACHED:
5940                 if (cc1 == TYPEC_CC_OPEN || cc2 == TYPEC_CC_OPEN)
5941                         tcpm_set_state(port, ACC_UNATTACHED, 0);
5942                 break;
5943
5944         case SNK_TRY:
5945                 /* Do nothing, waiting for timeout */
5946                 break;
5947
5948         case SNK_DISCOVERY:
5949                 /* CC line is unstable, wait for debounce */
5950                 if (tcpm_port_is_disconnected(port))
5951                         tcpm_set_state(port, SNK_DISCOVERY_DEBOUNCE, 0);
5952                 break;
5953         case SNK_DISCOVERY_DEBOUNCE:
5954                 break;
5955
5956         case SRC_TRYWAIT:
5957                 /* Hand over to state machine if needed */
5958                 if (!port->vbus_present && tcpm_port_is_source(port))
5959                         tcpm_set_state(port, SRC_TRYWAIT_DEBOUNCE, 0);
5960                 break;
5961         case SRC_TRYWAIT_DEBOUNCE:
5962                 if (port->vbus_present || !tcpm_port_is_source(port))
5963                         tcpm_set_state(port, SRC_TRYWAIT, 0);
5964                 break;
5965         case SNK_TRY_WAIT_DEBOUNCE:
5966                 if (!tcpm_port_is_sink(port)) {
5967                         port->max_wait = 0;
5968                         tcpm_set_state(port, SRC_TRYWAIT, 0);
5969                 }
5970                 break;
5971         case SRC_TRY_WAIT:
5972                 if (tcpm_port_is_source(port))
5973                         tcpm_set_state(port, SRC_TRY_DEBOUNCE, 0);
5974                 break;
5975         case SRC_TRY_DEBOUNCE:
5976                 tcpm_set_state(port, SRC_TRY_WAIT, 0);
5977                 break;
5978         case SNK_TRYWAIT_DEBOUNCE:
5979                 if (tcpm_port_is_sink(port))
5980                         tcpm_set_state(port, SNK_TRYWAIT_VBUS, 0);
5981                 break;
5982         case SNK_TRYWAIT_VBUS:
5983                 if (!tcpm_port_is_sink(port))
5984                         tcpm_set_state(port, SNK_TRYWAIT_DEBOUNCE, 0);
5985                 break;
5986         case SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS:
5987                 if (!tcpm_port_is_sink(port))
5988                         tcpm_set_state(port, SRC_TRYWAIT, PD_T_TRY_CC_DEBOUNCE);
5989                 else
5990                         tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS, 0);
5991                 break;
5992         case SNK_TRYWAIT:
5993                 /* Do nothing, waiting for tCCDebounce */
5994                 break;
5995         case PR_SWAP_SNK_SRC_SINK_OFF:
5996         case PR_SWAP_SRC_SNK_TRANSITION_OFF:
5997         case PR_SWAP_SRC_SNK_SOURCE_OFF:
5998         case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED:
5999         case PR_SWAP_SNK_SRC_SOURCE_ON:
6000                 /*
6001                  * CC state change is expected in PR_SWAP
6002                  * Ignore it.
6003                  */
6004                 break;
6005         case FR_SWAP_SEND:
6006         case FR_SWAP_SEND_TIMEOUT:
6007         case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF:
6008         case FR_SWAP_SNK_SRC_NEW_SINK_READY:
6009         case FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED:
6010                 /* Do nothing, CC change expected */
6011                 break;
6012
6013         case PORT_RESET:
6014         case PORT_RESET_WAIT_OFF:
6015                 /*
6016                  * State set back to default mode once the timer completes.
6017                  * Ignore CC changes here.
6018                  */
6019                 break;
6020         default:
6021                 /*
6022                  * While acting as sink and auto vbus discharge is enabled, Allow disconnect
6023                  * to be driven by vbus disconnect.
6024                  */
6025                 if (tcpm_port_is_disconnected(port) && !(port->pwr_role == TYPEC_SINK &&
6026                                                          port->auto_vbus_discharge_enabled))
6027                         tcpm_set_state(port, unattached_state(port), 0);
6028                 break;
6029         }
6030 }
6031
6032 static void _tcpm_pd_vbus_on(struct tcpm_port *port)
6033 {
6034         tcpm_log_force(port, "VBUS on");
6035         port->vbus_present = true;
6036         /*
6037          * When vbus_present is true i.e. Voltage at VBUS is greater than VSAFE5V implicitly
6038          * states that vbus is not at VSAFE0V, hence clear the vbus_vsafe0v flag here.
6039          */
6040         port->vbus_vsafe0v = false;
6041
6042         switch (port->state) {
6043         case SNK_TRANSITION_SINK_VBUS:
6044                 port->explicit_contract = true;
6045                 tcpm_set_state(port, SNK_READY, 0);
6046                 break;
6047         case SNK_DISCOVERY:
6048                 tcpm_set_state(port, SNK_DISCOVERY, 0);
6049                 break;
6050
6051         case SNK_DEBOUNCED:
6052                 tcpm_set_state(port, tcpm_try_src(port) ? SRC_TRY
6053                                                         : SNK_ATTACHED,
6054                                        0);
6055                 break;
6056         case SNK_HARD_RESET_WAIT_VBUS:
6057                 tcpm_set_state(port, SNK_HARD_RESET_SINK_ON, 0);
6058                 break;
6059         case SRC_ATTACHED:
6060                 tcpm_set_state(port, SRC_STARTUP, 0);
6061                 break;
6062         case SRC_HARD_RESET_VBUS_ON:
6063                 tcpm_set_state(port, SRC_STARTUP, 0);
6064                 break;
6065
6066         case SNK_TRY:
6067                 /* Do nothing, waiting for timeout */
6068                 break;
6069         case SRC_TRYWAIT:
6070                 /* Do nothing, Waiting for Rd to be detected */
6071                 break;
6072         case SRC_TRYWAIT_DEBOUNCE:
6073                 tcpm_set_state(port, SRC_TRYWAIT, 0);
6074                 break;
6075         case SNK_TRY_WAIT_DEBOUNCE:
6076                 /* Do nothing, waiting for PD_DEBOUNCE to do be done */
6077                 break;
6078         case SNK_TRYWAIT:
6079                 /* Do nothing, waiting for tCCDebounce */
6080                 break;
6081         case SNK_TRYWAIT_VBUS:
6082                 if (tcpm_port_is_sink(port))
6083                         tcpm_set_state(port, SNK_ATTACHED, 0);
6084                 break;
6085         case SNK_TRYWAIT_DEBOUNCE:
6086                 /* Do nothing, waiting for Rp */
6087                 break;
6088         case SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS:
6089                 if (port->vbus_present && tcpm_port_is_sink(port))
6090                         tcpm_set_state(port, SNK_ATTACHED, 0);
6091                 break;
6092         case SRC_TRY_WAIT:
6093         case SRC_TRY_DEBOUNCE:
6094                 /* Do nothing, waiting for sink detection */
6095                 break;
6096         case FR_SWAP_SEND:
6097         case FR_SWAP_SEND_TIMEOUT:
6098         case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF:
6099         case FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED:
6100                 if (port->tcpc->frs_sourcing_vbus)
6101                         port->tcpc->frs_sourcing_vbus(port->tcpc);
6102                 break;
6103         case FR_SWAP_SNK_SRC_NEW_SINK_READY:
6104                 if (port->tcpc->frs_sourcing_vbus)
6105                         port->tcpc->frs_sourcing_vbus(port->tcpc);
6106                 tcpm_set_state(port, FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED, 0);
6107                 break;
6108
6109         case PORT_RESET:
6110         case PORT_RESET_WAIT_OFF:
6111                 /*
6112                  * State set back to default mode once the timer completes.
6113                  * Ignore vbus changes here.
6114                  */
6115                 break;
6116
6117         default:
6118                 break;
6119         }
6120 }
6121
6122 static void _tcpm_pd_vbus_off(struct tcpm_port *port)
6123 {
6124         tcpm_log_force(port, "VBUS off");
6125         port->vbus_present = false;
6126         port->vbus_never_low = false;
6127         switch (port->state) {
6128         case SNK_HARD_RESET_SINK_OFF:
6129                 tcpm_set_state(port, SNK_HARD_RESET_WAIT_VBUS, 0);
6130                 break;
6131         case HARD_RESET_SEND:
6132                 break;
6133         case SNK_TRY:
6134                 /* Do nothing, waiting for timeout */
6135                 break;
6136         case SRC_TRYWAIT:
6137                 /* Hand over to state machine if needed */
6138                 if (tcpm_port_is_source(port))
6139                         tcpm_set_state(port, SRC_TRYWAIT_DEBOUNCE, 0);
6140                 break;
6141         case SNK_TRY_WAIT_DEBOUNCE:
6142                 /* Do nothing, waiting for PD_DEBOUNCE to do be done */
6143                 break;
6144         case SNK_TRYWAIT:
6145         case SNK_TRYWAIT_VBUS:
6146         case SNK_TRYWAIT_DEBOUNCE:
6147                 break;
6148         case SNK_ATTACH_WAIT:
6149         case SNK_DEBOUNCED:
6150                 /* Do nothing, as TCPM is still waiting for vbus to reach VSAFE5V to connect */
6151                 break;
6152
6153         case SNK_NEGOTIATE_CAPABILITIES:
6154                 break;
6155
6156         case PR_SWAP_SRC_SNK_TRANSITION_OFF:
6157                 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF, 0);
6158                 break;
6159
6160         case PR_SWAP_SNK_SRC_SINK_OFF:
6161                 /* Do nothing, expected */
6162                 break;
6163
6164         case PR_SWAP_SNK_SRC_SOURCE_ON:
6165                 /*
6166                  * Do nothing when vbus off notification is received.
6167                  * TCPM can wait for PD_T_NEWSRC in PR_SWAP_SNK_SRC_SOURCE_ON
6168                  * for the vbus source to ramp up.
6169                  */
6170                 break;
6171
6172         case PORT_RESET_WAIT_OFF:
6173                 tcpm_set_state(port, tcpm_default_state(port), 0);
6174                 break;
6175
6176         case SRC_TRY_WAIT:
6177         case SRC_TRY_DEBOUNCE:
6178                 /* Do nothing, waiting for sink detection */
6179                 break;
6180
6181         case SRC_STARTUP:
6182         case SRC_SEND_CAPABILITIES:
6183         case SRC_SEND_CAPABILITIES_TIMEOUT:
6184         case SRC_NEGOTIATE_CAPABILITIES:
6185         case SRC_TRANSITION_SUPPLY:
6186         case SRC_READY:
6187         case SRC_WAIT_NEW_CAPABILITIES:
6188                 /*
6189                  * Force to unattached state to re-initiate connection.
6190                  * DRP port should move to Unattached.SNK instead of Unattached.SRC if
6191                  * sink removed. Although sink removal here is due to source's vbus collapse,
6192                  * treat it the same way for consistency.
6193                  */
6194                 if (port->port_type == TYPEC_PORT_SRC)
6195                         tcpm_set_state(port, SRC_UNATTACHED, tcpm_wait_for_discharge(port));
6196                 else
6197                         tcpm_set_state(port, SNK_UNATTACHED, tcpm_wait_for_discharge(port));
6198                 break;
6199
6200         case PORT_RESET:
6201                 /*
6202                  * State set back to default mode once the timer completes.
6203                  * Ignore vbus changes here.
6204                  */
6205                 break;
6206
6207         case FR_SWAP_SEND:
6208         case FR_SWAP_SEND_TIMEOUT:
6209         case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF:
6210         case FR_SWAP_SNK_SRC_NEW_SINK_READY:
6211         case FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED:
6212                 /* Do nothing, vbus drop expected */
6213                 break;
6214
6215         case SNK_HARD_RESET_WAIT_VBUS:
6216                 /* Do nothing, its OK to receive vbus off events */
6217                 break;
6218
6219         default:
6220                 if (port->pwr_role == TYPEC_SINK && port->attached)
6221                         tcpm_set_state(port, SNK_UNATTACHED, tcpm_wait_for_discharge(port));
6222                 break;
6223         }
6224 }
6225
6226 static void _tcpm_pd_vbus_vsafe0v(struct tcpm_port *port)
6227 {
6228         tcpm_log_force(port, "VBUS VSAFE0V");
6229         port->vbus_vsafe0v = true;
6230         switch (port->state) {
6231         case SRC_HARD_RESET_VBUS_OFF:
6232                 /*
6233                  * After establishing the vSafe0V voltage condition on VBUS, the Source Shall wait
6234                  * tSrcRecover before re-applying VCONN and restoring VBUS to vSafe5V.
6235                  */
6236                 tcpm_set_state(port, SRC_HARD_RESET_VBUS_ON, PD_T_SRC_RECOVER);
6237                 break;
6238         case SRC_ATTACH_WAIT:
6239                 if (tcpm_port_is_source(port))
6240                         tcpm_set_state(port, tcpm_try_snk(port) ? SNK_TRY : SRC_ATTACHED,
6241                                        port->timings.cc_debounce_time);
6242                 break;
6243         case SRC_STARTUP:
6244         case SRC_SEND_CAPABILITIES:
6245         case SRC_SEND_CAPABILITIES_TIMEOUT:
6246         case SRC_NEGOTIATE_CAPABILITIES:
6247         case SRC_TRANSITION_SUPPLY:
6248         case SRC_READY:
6249         case SRC_WAIT_NEW_CAPABILITIES:
6250                 if (port->auto_vbus_discharge_enabled) {
6251                         if (port->port_type == TYPEC_PORT_SRC)
6252                                 tcpm_set_state(port, SRC_UNATTACHED, 0);
6253                         else
6254                                 tcpm_set_state(port, SNK_UNATTACHED, 0);
6255                 }
6256                 break;
6257         case PR_SWAP_SNK_SRC_SINK_OFF:
6258         case PR_SWAP_SNK_SRC_SOURCE_ON:
6259                 /* Do nothing, vsafe0v is expected during transition */
6260                 break;
6261         case SNK_ATTACH_WAIT:
6262         case SNK_DEBOUNCED:
6263                 /*Do nothing, still waiting for VSAFE5V for connect */
6264                 break;
6265         case SNK_HARD_RESET_WAIT_VBUS:
6266                 /* Do nothing, its OK to receive vbus off events */
6267                 break;
6268         default:
6269                 if (port->pwr_role == TYPEC_SINK && port->auto_vbus_discharge_enabled)
6270                         tcpm_set_state(port, SNK_UNATTACHED, 0);
6271                 break;
6272         }
6273 }
6274
6275 static void _tcpm_pd_hard_reset(struct tcpm_port *port)
6276 {
6277         tcpm_log_force(port, "Received hard reset");
6278         if (port->bist_request == BDO_MODE_TESTDATA && port->tcpc->set_bist_data)
6279                 port->tcpc->set_bist_data(port->tcpc, false);
6280
6281         switch (port->state) {
6282         case TOGGLING:
6283         case ERROR_RECOVERY:
6284         case PORT_RESET:
6285         case PORT_RESET_WAIT_OFF:
6286                 return;
6287         default:
6288                 break;
6289         }
6290
6291         if (port->ams != NONE_AMS)
6292                 port->ams = NONE_AMS;
6293         if (port->hard_reset_count < PD_N_HARD_RESET_COUNT)
6294                 port->ams = HARD_RESET;
6295         /*
6296          * If we keep receiving hard reset requests, executing the hard reset
6297          * must have failed. Revert to error recovery if that happens.
6298          */
6299         tcpm_set_state(port,
6300                        port->hard_reset_count < PD_N_HARD_RESET_COUNT ?
6301                                 HARD_RESET_START : ERROR_RECOVERY,
6302                        0);
6303 }
6304
6305 static void tcpm_pd_event_handler(struct kthread_work *work)
6306 {
6307         struct tcpm_port *port = container_of(work, struct tcpm_port,
6308                                               event_work);
6309         u32 events;
6310
6311         mutex_lock(&port->lock);
6312
6313         spin_lock(&port->pd_event_lock);
6314         while (port->pd_events) {
6315                 events = port->pd_events;
6316                 port->pd_events = 0;
6317                 spin_unlock(&port->pd_event_lock);
6318                 if (events & TCPM_RESET_EVENT)
6319                         _tcpm_pd_hard_reset(port);
6320                 if (events & TCPM_VBUS_EVENT) {
6321                         bool vbus;
6322
6323                         vbus = port->tcpc->get_vbus(port->tcpc);
6324                         if (vbus) {
6325                                 _tcpm_pd_vbus_on(port);
6326                         } else {
6327                                 _tcpm_pd_vbus_off(port);
6328                                 /*
6329                                  * When TCPC does not support detecting vsafe0v voltage level,
6330                                  * treat vbus absent as vsafe0v. Else invoke is_vbus_vsafe0v
6331                                  * to see if vbus has discharge to VSAFE0V.
6332                                  */
6333                                 if (!port->tcpc->is_vbus_vsafe0v ||
6334                                     port->tcpc->is_vbus_vsafe0v(port->tcpc))
6335                                         _tcpm_pd_vbus_vsafe0v(port);
6336                         }
6337                 }
6338                 if (events & TCPM_CC_EVENT) {
6339                         enum typec_cc_status cc1, cc2;
6340
6341                         if (port->tcpc->get_cc(port->tcpc, &cc1, &cc2) == 0)
6342                                 _tcpm_cc_change(port, cc1, cc2);
6343                 }
6344                 if (events & TCPM_FRS_EVENT) {
6345                         if (port->state == SNK_READY) {
6346                                 int ret;
6347
6348                                 port->upcoming_state = FR_SWAP_SEND;
6349                                 ret = tcpm_ams_start(port, FAST_ROLE_SWAP);
6350                                 if (ret == -EAGAIN)
6351                                         port->upcoming_state = INVALID_STATE;
6352                         } else {
6353                                 tcpm_log(port, "Discarding FRS_SIGNAL! Not in sink ready");
6354                         }
6355                 }
6356                 if (events & TCPM_SOURCING_VBUS) {
6357                         tcpm_log(port, "sourcing vbus");
6358                         /*
6359                          * In fast role swap case TCPC autonomously sources vbus. Set vbus_source
6360                          * true as TCPM wouldn't have called tcpm_set_vbus.
6361                          *
6362                          * When vbus is sourced on the command on TCPM i.e. TCPM called
6363                          * tcpm_set_vbus to source vbus, vbus_source would already be true.
6364                          */
6365                         port->vbus_source = true;
6366                         _tcpm_pd_vbus_on(port);
6367                 }
6368                 if (events & TCPM_PORT_CLEAN) {
6369                         tcpm_log(port, "port clean");
6370                         if (port->state == CHECK_CONTAMINANT) {
6371                                 if (tcpm_start_toggling(port, tcpm_rp_cc(port)))
6372                                         tcpm_set_state(port, TOGGLING, 0);
6373                                 else
6374                                         tcpm_set_state(port, tcpm_default_state(port), 0);
6375                         }
6376                 }
6377                 if (events & TCPM_PORT_ERROR) {
6378                         tcpm_log(port, "port triggering error recovery");
6379                         tcpm_set_state(port, ERROR_RECOVERY, 0);
6380                 }
6381
6382                 spin_lock(&port->pd_event_lock);
6383         }
6384         spin_unlock(&port->pd_event_lock);
6385         mutex_unlock(&port->lock);
6386 }
6387
6388 void tcpm_cc_change(struct tcpm_port *port)
6389 {
6390         spin_lock(&port->pd_event_lock);
6391         port->pd_events |= TCPM_CC_EVENT;
6392         spin_unlock(&port->pd_event_lock);
6393         kthread_queue_work(port->wq, &port->event_work);
6394 }
6395 EXPORT_SYMBOL_GPL(tcpm_cc_change);
6396
6397 void tcpm_vbus_change(struct tcpm_port *port)
6398 {
6399         spin_lock(&port->pd_event_lock);
6400         port->pd_events |= TCPM_VBUS_EVENT;
6401         spin_unlock(&port->pd_event_lock);
6402         kthread_queue_work(port->wq, &port->event_work);
6403 }
6404 EXPORT_SYMBOL_GPL(tcpm_vbus_change);
6405
6406 void tcpm_pd_hard_reset(struct tcpm_port *port)
6407 {
6408         spin_lock(&port->pd_event_lock);
6409         port->pd_events = TCPM_RESET_EVENT;
6410         spin_unlock(&port->pd_event_lock);
6411         kthread_queue_work(port->wq, &port->event_work);
6412 }
6413 EXPORT_SYMBOL_GPL(tcpm_pd_hard_reset);
6414
6415 void tcpm_sink_frs(struct tcpm_port *port)
6416 {
6417         spin_lock(&port->pd_event_lock);
6418         port->pd_events |= TCPM_FRS_EVENT;
6419         spin_unlock(&port->pd_event_lock);
6420         kthread_queue_work(port->wq, &port->event_work);
6421 }
6422 EXPORT_SYMBOL_GPL(tcpm_sink_frs);
6423
6424 void tcpm_sourcing_vbus(struct tcpm_port *port)
6425 {
6426         spin_lock(&port->pd_event_lock);
6427         port->pd_events |= TCPM_SOURCING_VBUS;
6428         spin_unlock(&port->pd_event_lock);
6429         kthread_queue_work(port->wq, &port->event_work);
6430 }
6431 EXPORT_SYMBOL_GPL(tcpm_sourcing_vbus);
6432
6433 void tcpm_port_clean(struct tcpm_port *port)
6434 {
6435         spin_lock(&port->pd_event_lock);
6436         port->pd_events |= TCPM_PORT_CLEAN;
6437         spin_unlock(&port->pd_event_lock);
6438         kthread_queue_work(port->wq, &port->event_work);
6439 }
6440 EXPORT_SYMBOL_GPL(tcpm_port_clean);
6441
6442 bool tcpm_port_is_toggling(struct tcpm_port *port)
6443 {
6444         return port->port_type == TYPEC_PORT_DRP && port->state == TOGGLING;
6445 }
6446 EXPORT_SYMBOL_GPL(tcpm_port_is_toggling);
6447
6448 void tcpm_port_error_recovery(struct tcpm_port *port)
6449 {
6450         spin_lock(&port->pd_event_lock);
6451         port->pd_events |= TCPM_PORT_ERROR;
6452         spin_unlock(&port->pd_event_lock);
6453         kthread_queue_work(port->wq, &port->event_work);
6454 }
6455 EXPORT_SYMBOL_GPL(tcpm_port_error_recovery);
6456
6457 static void tcpm_enable_frs_work(struct kthread_work *work)
6458 {
6459         struct tcpm_port *port = container_of(work, struct tcpm_port, enable_frs);
6460         int ret;
6461
6462         mutex_lock(&port->lock);
6463         /* Not FRS capable */
6464         if (!port->connected || port->port_type != TYPEC_PORT_DRP ||
6465             port->pwr_opmode != TYPEC_PWR_MODE_PD ||
6466             !port->tcpc->enable_frs ||
6467             /* Sink caps queried */
6468             port->sink_cap_done || port->negotiated_rev < PD_REV30)
6469                 goto unlock;
6470
6471         /* Send when the state machine is idle */
6472         if (port->state != SNK_READY || port->vdm_sm_running || port->send_discover ||
6473             port->send_discover_prime)
6474                 goto resched;
6475
6476         port->upcoming_state = GET_SINK_CAP;
6477         ret = tcpm_ams_start(port, GET_SINK_CAPABILITIES);
6478         if (ret == -EAGAIN) {
6479                 port->upcoming_state = INVALID_STATE;
6480         } else {
6481                 port->sink_cap_done = true;
6482                 goto unlock;
6483         }
6484 resched:
6485         mod_enable_frs_delayed_work(port, GET_SINK_CAP_RETRY_MS);
6486 unlock:
6487         mutex_unlock(&port->lock);
6488 }
6489
6490 static void tcpm_send_discover_work(struct kthread_work *work)
6491 {
6492         struct tcpm_port *port = container_of(work, struct tcpm_port, send_discover_work);
6493
6494         mutex_lock(&port->lock);
6495         /* No need to send DISCOVER_IDENTITY anymore */
6496         if (!port->send_discover && !port->send_discover_prime)
6497                 goto unlock;
6498
6499         if (port->data_role == TYPEC_DEVICE && port->negotiated_rev < PD_REV30) {
6500                 port->send_discover = false;
6501                 port->send_discover_prime = false;
6502                 goto unlock;
6503         }
6504
6505         /* Retry if the port is not idle */
6506         if ((port->state != SRC_READY && port->state != SNK_READY &&
6507              port->state != SRC_VDM_IDENTITY_REQUEST) || port->vdm_sm_running) {
6508                 mod_send_discover_delayed_work(port, SEND_DISCOVER_RETRY_MS);
6509                 goto unlock;
6510         }
6511
6512         tcpm_send_vdm(port, USB_SID_PD, CMD_DISCOVER_IDENT, NULL, 0, port->tx_sop_type);
6513
6514 unlock:
6515         mutex_unlock(&port->lock);
6516 }
6517
6518 static int tcpm_dr_set(struct typec_port *p, enum typec_data_role data)
6519 {
6520         struct tcpm_port *port = typec_get_drvdata(p);
6521         int ret;
6522
6523         mutex_lock(&port->swap_lock);
6524         mutex_lock(&port->lock);
6525
6526         if (port->typec_caps.data != TYPEC_PORT_DRD) {
6527                 ret = -EINVAL;
6528                 goto port_unlock;
6529         }
6530         if (port->state != SRC_READY && port->state != SNK_READY) {
6531                 ret = -EAGAIN;
6532                 goto port_unlock;
6533         }
6534
6535         if (port->data_role == data) {
6536                 ret = 0;
6537                 goto port_unlock;
6538         }
6539
6540         /*
6541          * XXX
6542          * 6.3.9: If an alternate mode is active, a request to swap
6543          * alternate modes shall trigger a port reset.
6544          * Reject data role swap request in this case.
6545          */
6546
6547         if (!port->pd_capable) {
6548                 /*
6549                  * If the partner is not PD capable, reset the port to
6550                  * trigger a role change. This can only work if a preferred
6551                  * role is configured, and if it matches the requested role.
6552                  */
6553                 if (port->try_role == TYPEC_NO_PREFERRED_ROLE ||
6554                     port->try_role == port->pwr_role) {
6555                         ret = -EINVAL;
6556                         goto port_unlock;
6557                 }
6558                 port->non_pd_role_swap = true;
6559                 tcpm_set_state(port, PORT_RESET, 0);
6560         } else {
6561                 port->upcoming_state = DR_SWAP_SEND;
6562                 ret = tcpm_ams_start(port, DATA_ROLE_SWAP);
6563                 if (ret == -EAGAIN) {
6564                         port->upcoming_state = INVALID_STATE;
6565                         goto port_unlock;
6566                 }
6567         }
6568
6569         port->swap_status = 0;
6570         port->swap_pending = true;
6571         reinit_completion(&port->swap_complete);
6572         mutex_unlock(&port->lock);
6573
6574         if (!wait_for_completion_timeout(&port->swap_complete,
6575                                 msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT)))
6576                 ret = -ETIMEDOUT;
6577         else
6578                 ret = port->swap_status;
6579
6580         port->non_pd_role_swap = false;
6581         goto swap_unlock;
6582
6583 port_unlock:
6584         mutex_unlock(&port->lock);
6585 swap_unlock:
6586         mutex_unlock(&port->swap_lock);
6587         return ret;
6588 }
6589
6590 static int tcpm_pr_set(struct typec_port *p, enum typec_role role)
6591 {
6592         struct tcpm_port *port = typec_get_drvdata(p);
6593         int ret;
6594
6595         mutex_lock(&port->swap_lock);
6596         mutex_lock(&port->lock);
6597
6598         if (port->port_type != TYPEC_PORT_DRP) {
6599                 ret = -EINVAL;
6600                 goto port_unlock;
6601         }
6602         if (port->state != SRC_READY && port->state != SNK_READY) {
6603                 ret = -EAGAIN;
6604                 goto port_unlock;
6605         }
6606
6607         if (role == port->pwr_role) {
6608                 ret = 0;
6609                 goto port_unlock;
6610         }
6611
6612         port->upcoming_state = PR_SWAP_SEND;
6613         ret = tcpm_ams_start(port, POWER_ROLE_SWAP);
6614         if (ret == -EAGAIN) {
6615                 port->upcoming_state = INVALID_STATE;
6616                 goto port_unlock;
6617         }
6618
6619         port->swap_status = 0;
6620         port->swap_pending = true;
6621         reinit_completion(&port->swap_complete);
6622         mutex_unlock(&port->lock);
6623
6624         if (!wait_for_completion_timeout(&port->swap_complete,
6625                                 msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT)))
6626                 ret = -ETIMEDOUT;
6627         else
6628                 ret = port->swap_status;
6629
6630         goto swap_unlock;
6631
6632 port_unlock:
6633         mutex_unlock(&port->lock);
6634 swap_unlock:
6635         mutex_unlock(&port->swap_lock);
6636         return ret;
6637 }
6638
6639 static int tcpm_vconn_set(struct typec_port *p, enum typec_role role)
6640 {
6641         struct tcpm_port *port = typec_get_drvdata(p);
6642         int ret;
6643
6644         mutex_lock(&port->swap_lock);
6645         mutex_lock(&port->lock);
6646
6647         if (port->state != SRC_READY && port->state != SNK_READY) {
6648                 ret = -EAGAIN;
6649                 goto port_unlock;
6650         }
6651
6652         if (role == port->vconn_role) {
6653                 ret = 0;
6654                 goto port_unlock;
6655         }
6656
6657         port->upcoming_state = VCONN_SWAP_SEND;
6658         ret = tcpm_ams_start(port, VCONN_SWAP);
6659         if (ret == -EAGAIN) {
6660                 port->upcoming_state = INVALID_STATE;
6661                 goto port_unlock;
6662         }
6663
6664         port->swap_status = 0;
6665         port->swap_pending = true;
6666         reinit_completion(&port->swap_complete);
6667         mutex_unlock(&port->lock);
6668
6669         if (!wait_for_completion_timeout(&port->swap_complete,
6670                                 msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT)))
6671                 ret = -ETIMEDOUT;
6672         else
6673                 ret = port->swap_status;
6674
6675         goto swap_unlock;
6676
6677 port_unlock:
6678         mutex_unlock(&port->lock);
6679 swap_unlock:
6680         mutex_unlock(&port->swap_lock);
6681         return ret;
6682 }
6683
6684 static int tcpm_try_role(struct typec_port *p, int role)
6685 {
6686         struct tcpm_port *port = typec_get_drvdata(p);
6687         struct tcpc_dev *tcpc = port->tcpc;
6688         int ret = 0;
6689
6690         mutex_lock(&port->lock);
6691         if (tcpc->try_role)
6692                 ret = tcpc->try_role(tcpc, role);
6693         if (!ret)
6694                 port->try_role = role;
6695         port->try_src_count = 0;
6696         port->try_snk_count = 0;
6697         mutex_unlock(&port->lock);
6698
6699         return ret;
6700 }
6701
6702 static int tcpm_pps_set_op_curr(struct tcpm_port *port, u16 req_op_curr)
6703 {
6704         unsigned int target_mw;
6705         int ret;
6706
6707         mutex_lock(&port->swap_lock);
6708         mutex_lock(&port->lock);
6709
6710         if (!port->pps_data.active) {
6711                 ret = -EOPNOTSUPP;
6712                 goto port_unlock;
6713         }
6714
6715         if (port->state != SNK_READY) {
6716                 ret = -EAGAIN;
6717                 goto port_unlock;
6718         }
6719
6720         if (req_op_curr > port->pps_data.max_curr) {
6721                 ret = -EINVAL;
6722                 goto port_unlock;
6723         }
6724
6725         target_mw = (req_op_curr * port->supply_voltage) / 1000;
6726         if (target_mw < port->operating_snk_mw) {
6727                 ret = -EINVAL;
6728                 goto port_unlock;
6729         }
6730
6731         port->upcoming_state = SNK_NEGOTIATE_PPS_CAPABILITIES;
6732         ret = tcpm_ams_start(port, POWER_NEGOTIATION);
6733         if (ret == -EAGAIN) {
6734                 port->upcoming_state = INVALID_STATE;
6735                 goto port_unlock;
6736         }
6737
6738         /* Round down operating current to align with PPS valid steps */
6739         req_op_curr = req_op_curr - (req_op_curr % RDO_PROG_CURR_MA_STEP);
6740
6741         reinit_completion(&port->pps_complete);
6742         port->pps_data.req_op_curr = req_op_curr;
6743         port->pps_status = 0;
6744         port->pps_pending = true;
6745         mutex_unlock(&port->lock);
6746
6747         if (!wait_for_completion_timeout(&port->pps_complete,
6748                                 msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT)))
6749                 ret = -ETIMEDOUT;
6750         else
6751                 ret = port->pps_status;
6752
6753         goto swap_unlock;
6754
6755 port_unlock:
6756         mutex_unlock(&port->lock);
6757 swap_unlock:
6758         mutex_unlock(&port->swap_lock);
6759
6760         return ret;
6761 }
6762
6763 static int tcpm_pps_set_out_volt(struct tcpm_port *port, u16 req_out_volt)
6764 {
6765         unsigned int target_mw;
6766         int ret;
6767
6768         mutex_lock(&port->swap_lock);
6769         mutex_lock(&port->lock);
6770
6771         if (!port->pps_data.active) {
6772                 ret = -EOPNOTSUPP;
6773                 goto port_unlock;
6774         }
6775
6776         if (port->state != SNK_READY) {
6777                 ret = -EAGAIN;
6778                 goto port_unlock;
6779         }
6780
6781         target_mw = (port->current_limit * req_out_volt) / 1000;
6782         if (target_mw < port->operating_snk_mw) {
6783                 ret = -EINVAL;
6784                 goto port_unlock;
6785         }
6786
6787         port->upcoming_state = SNK_NEGOTIATE_PPS_CAPABILITIES;
6788         ret = tcpm_ams_start(port, POWER_NEGOTIATION);
6789         if (ret == -EAGAIN) {
6790                 port->upcoming_state = INVALID_STATE;
6791                 goto port_unlock;
6792         }
6793
6794         /* Round down output voltage to align with PPS valid steps */
6795         req_out_volt = req_out_volt - (req_out_volt % RDO_PROG_VOLT_MV_STEP);
6796
6797         reinit_completion(&port->pps_complete);
6798         port->pps_data.req_out_volt = req_out_volt;
6799         port->pps_status = 0;
6800         port->pps_pending = true;
6801         mutex_unlock(&port->lock);
6802
6803         if (!wait_for_completion_timeout(&port->pps_complete,
6804                                 msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT)))
6805                 ret = -ETIMEDOUT;
6806         else
6807                 ret = port->pps_status;
6808
6809         goto swap_unlock;
6810
6811 port_unlock:
6812         mutex_unlock(&port->lock);
6813 swap_unlock:
6814         mutex_unlock(&port->swap_lock);
6815
6816         return ret;
6817 }
6818
6819 static int tcpm_pps_activate(struct tcpm_port *port, bool activate)
6820 {
6821         int ret = 0;
6822
6823         mutex_lock(&port->swap_lock);
6824         mutex_lock(&port->lock);
6825
6826         if (!port->pps_data.supported) {
6827                 ret = -EOPNOTSUPP;
6828                 goto port_unlock;
6829         }
6830
6831         /* Trying to deactivate PPS when already deactivated so just bail */
6832         if (!port->pps_data.active && !activate)
6833                 goto port_unlock;
6834
6835         if (port->state != SNK_READY) {
6836                 ret = -EAGAIN;
6837                 goto port_unlock;
6838         }
6839
6840         if (activate)
6841                 port->upcoming_state = SNK_NEGOTIATE_PPS_CAPABILITIES;
6842         else
6843                 port->upcoming_state = SNK_NEGOTIATE_CAPABILITIES;
6844         ret = tcpm_ams_start(port, POWER_NEGOTIATION);
6845         if (ret == -EAGAIN) {
6846                 port->upcoming_state = INVALID_STATE;
6847                 goto port_unlock;
6848         }
6849
6850         reinit_completion(&port->pps_complete);
6851         port->pps_status = 0;
6852         port->pps_pending = true;
6853
6854         /* Trigger PPS request or move back to standard PDO contract */
6855         if (activate) {
6856                 port->pps_data.req_out_volt = port->supply_voltage;
6857                 port->pps_data.req_op_curr = port->current_limit;
6858         }
6859         mutex_unlock(&port->lock);
6860
6861         if (!wait_for_completion_timeout(&port->pps_complete,
6862                                 msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT)))
6863                 ret = -ETIMEDOUT;
6864         else
6865                 ret = port->pps_status;
6866
6867         goto swap_unlock;
6868
6869 port_unlock:
6870         mutex_unlock(&port->lock);
6871 swap_unlock:
6872         mutex_unlock(&port->swap_lock);
6873
6874         return ret;
6875 }
6876
6877 static void tcpm_init(struct tcpm_port *port)
6878 {
6879         enum typec_cc_status cc1, cc2;
6880
6881         port->tcpc->init(port->tcpc);
6882
6883         tcpm_reset_port(port);
6884
6885         /*
6886          * XXX
6887          * Should possibly wait for VBUS to settle if it was enabled locally
6888          * since tcpm_reset_port() will disable VBUS.
6889          */
6890         port->vbus_present = port->tcpc->get_vbus(port->tcpc);
6891         if (port->vbus_present)
6892                 port->vbus_never_low = true;
6893
6894         /*
6895          * 1. When vbus_present is true, voltage on VBUS is already at VSAFE5V.
6896          * So implicitly vbus_vsafe0v = false.
6897          *
6898          * 2. When vbus_present is false and TCPC does NOT support querying
6899          * vsafe0v status, then, it's best to assume vbus is at VSAFE0V i.e.
6900          * vbus_vsafe0v is true.
6901          *
6902          * 3. When vbus_present is false and TCPC does support querying vsafe0v,
6903          * then, query tcpc for vsafe0v status.
6904          */
6905         if (port->vbus_present)
6906                 port->vbus_vsafe0v = false;
6907         else if (!port->tcpc->is_vbus_vsafe0v)
6908                 port->vbus_vsafe0v = true;
6909         else
6910                 port->vbus_vsafe0v = port->tcpc->is_vbus_vsafe0v(port->tcpc);
6911
6912         tcpm_set_state(port, tcpm_default_state(port), 0);
6913
6914         if (port->tcpc->get_cc(port->tcpc, &cc1, &cc2) == 0)
6915                 _tcpm_cc_change(port, cc1, cc2);
6916
6917         /*
6918          * Some adapters need a clean slate at startup, and won't recover
6919          * otherwise. So do not try to be fancy and force a clean disconnect.
6920          */
6921         tcpm_set_state(port, PORT_RESET, 0);
6922 }
6923
6924 static int tcpm_port_type_set(struct typec_port *p, enum typec_port_type type)
6925 {
6926         struct tcpm_port *port = typec_get_drvdata(p);
6927
6928         mutex_lock(&port->lock);
6929         if (type == port->port_type)
6930                 goto port_unlock;
6931
6932         port->port_type = type;
6933
6934         if (!port->connected) {
6935                 tcpm_set_state(port, PORT_RESET, 0);
6936         } else if (type == TYPEC_PORT_SNK) {
6937                 if (!(port->pwr_role == TYPEC_SINK &&
6938                       port->data_role == TYPEC_DEVICE))
6939                         tcpm_set_state(port, PORT_RESET, 0);
6940         } else if (type == TYPEC_PORT_SRC) {
6941                 if (!(port->pwr_role == TYPEC_SOURCE &&
6942                       port->data_role == TYPEC_HOST))
6943                         tcpm_set_state(port, PORT_RESET, 0);
6944         }
6945
6946 port_unlock:
6947         mutex_unlock(&port->lock);
6948         return 0;
6949 }
6950
6951 static struct pd_data *tcpm_find_pd_data(struct tcpm_port *port, struct usb_power_delivery *pd)
6952 {
6953         int i;
6954
6955         for (i = 0; port->pd_list[i]; i++) {
6956                 if (port->pd_list[i]->pd == pd)
6957                         return port->pd_list[i];
6958         }
6959
6960         return ERR_PTR(-ENODATA);
6961 }
6962
6963 static struct usb_power_delivery **tcpm_pd_get(struct typec_port *p)
6964 {
6965         struct tcpm_port *port = typec_get_drvdata(p);
6966
6967         return port->pds;
6968 }
6969
6970 static int tcpm_pd_set(struct typec_port *p, struct usb_power_delivery *pd)
6971 {
6972         struct tcpm_port *port = typec_get_drvdata(p);
6973         struct pd_data *data;
6974         int i, ret = 0;
6975
6976         mutex_lock(&port->lock);
6977
6978         if (port->selected_pd == pd)
6979                 goto unlock;
6980
6981         data = tcpm_find_pd_data(port, pd);
6982         if (IS_ERR(data)) {
6983                 ret = PTR_ERR(data);
6984                 goto unlock;
6985         }
6986
6987         if (data->sink_desc.pdo[0]) {
6988                 for (i = 0; i < PDO_MAX_OBJECTS && data->sink_desc.pdo[i]; i++)
6989                         port->snk_pdo[i] = data->sink_desc.pdo[i];
6990                 port->nr_snk_pdo = i;
6991                 port->operating_snk_mw = data->operating_snk_mw;
6992         }
6993
6994         if (data->source_desc.pdo[0]) {
6995                 for (i = 0; i < PDO_MAX_OBJECTS && data->source_desc.pdo[i]; i++)
6996                         port->src_pdo[i] = data->source_desc.pdo[i];
6997                 port->nr_src_pdo = i;
6998         }
6999
7000         switch (port->state) {
7001         case SRC_UNATTACHED:
7002         case SRC_ATTACH_WAIT:
7003         case SRC_TRYWAIT:
7004                 tcpm_set_cc(port, tcpm_rp_cc(port));
7005                 break;
7006         case SRC_SEND_CAPABILITIES:
7007         case SRC_SEND_CAPABILITIES_TIMEOUT:
7008         case SRC_NEGOTIATE_CAPABILITIES:
7009         case SRC_READY:
7010         case SRC_WAIT_NEW_CAPABILITIES:
7011                 port->caps_count = 0;
7012                 port->upcoming_state = SRC_SEND_CAPABILITIES;
7013                 ret = tcpm_ams_start(port, POWER_NEGOTIATION);
7014                 if (ret == -EAGAIN) {
7015                         port->upcoming_state = INVALID_STATE;
7016                         goto unlock;
7017                 }
7018                 break;
7019         case SNK_NEGOTIATE_CAPABILITIES:
7020         case SNK_NEGOTIATE_PPS_CAPABILITIES:
7021         case SNK_READY:
7022         case SNK_TRANSITION_SINK:
7023         case SNK_TRANSITION_SINK_VBUS:
7024                 if (port->pps_data.active)
7025                         port->upcoming_state = SNK_NEGOTIATE_PPS_CAPABILITIES;
7026                 else if (port->pd_capable)
7027                         port->upcoming_state = SNK_NEGOTIATE_CAPABILITIES;
7028                 else
7029                         break;
7030
7031                 port->update_sink_caps = true;
7032
7033                 ret = tcpm_ams_start(port, POWER_NEGOTIATION);
7034                 if (ret == -EAGAIN) {
7035                         port->upcoming_state = INVALID_STATE;
7036                         goto unlock;
7037                 }
7038                 break;
7039         default:
7040                 break;
7041         }
7042
7043         port->port_source_caps = data->source_cap;
7044         port->port_sink_caps = data->sink_cap;
7045         typec_port_set_usb_power_delivery(p, NULL);
7046         port->selected_pd = pd;
7047         typec_port_set_usb_power_delivery(p, port->selected_pd);
7048 unlock:
7049         mutex_unlock(&port->lock);
7050         return ret;
7051 }
7052
7053 static const struct typec_operations tcpm_ops = {
7054         .try_role = tcpm_try_role,
7055         .dr_set = tcpm_dr_set,
7056         .pr_set = tcpm_pr_set,
7057         .vconn_set = tcpm_vconn_set,
7058         .port_type_set = tcpm_port_type_set,
7059         .pd_get = tcpm_pd_get,
7060         .pd_set = tcpm_pd_set
7061 };
7062
7063 void tcpm_tcpc_reset(struct tcpm_port *port)
7064 {
7065         mutex_lock(&port->lock);
7066         /* XXX: Maintain PD connection if possible? */
7067         tcpm_init(port);
7068         mutex_unlock(&port->lock);
7069 }
7070 EXPORT_SYMBOL_GPL(tcpm_tcpc_reset);
7071
7072 static void tcpm_port_unregister_pd(struct tcpm_port *port)
7073 {
7074         int i;
7075
7076         port->port_sink_caps = NULL;
7077         port->port_source_caps = NULL;
7078         for (i = 0; i < port->pd_count; i++) {
7079                 usb_power_delivery_unregister_capabilities(port->pd_list[i]->sink_cap);
7080                 usb_power_delivery_unregister_capabilities(port->pd_list[i]->source_cap);
7081                 devm_kfree(port->dev, port->pd_list[i]);
7082                 port->pd_list[i] = NULL;
7083                 usb_power_delivery_unregister(port->pds[i]);
7084                 port->pds[i] = NULL;
7085         }
7086 }
7087
7088 static int tcpm_port_register_pd(struct tcpm_port *port)
7089 {
7090         u16 pd_revision = port->typec_caps.pd_revision;
7091         u16 pd_version = port->pd_rev.ver_major << 8 | port->pd_rev.ver_minor;
7092         struct usb_power_delivery_desc desc = { pd_revision, pd_version };
7093         struct usb_power_delivery_capabilities *cap;
7094         int ret, i;
7095
7096         if (!port->nr_src_pdo && !port->nr_snk_pdo)
7097                 return 0;
7098
7099         for (i = 0; i < port->pd_count; i++) {
7100                 port->pds[i] = usb_power_delivery_register(port->dev, &desc);
7101                 if (IS_ERR(port->pds[i])) {
7102                         ret = PTR_ERR(port->pds[i]);
7103                         goto err_unregister;
7104                 }
7105                 port->pd_list[i]->pd = port->pds[i];
7106
7107                 if (port->pd_list[i]->source_desc.pdo[0]) {
7108                         cap = usb_power_delivery_register_capabilities(port->pds[i],
7109                                                                 &port->pd_list[i]->source_desc);
7110                         if (IS_ERR(cap)) {
7111                                 ret = PTR_ERR(cap);
7112                                 goto err_unregister;
7113                         }
7114                         port->pd_list[i]->source_cap = cap;
7115                 }
7116
7117                 if (port->pd_list[i]->sink_desc.pdo[0]) {
7118                         cap = usb_power_delivery_register_capabilities(port->pds[i],
7119                                                                 &port->pd_list[i]->sink_desc);
7120                         if (IS_ERR(cap)) {
7121                                 ret = PTR_ERR(cap);
7122                                 goto err_unregister;
7123                         }
7124                         port->pd_list[i]->sink_cap = cap;
7125                 }
7126         }
7127
7128         port->port_source_caps = port->pd_list[0]->source_cap;
7129         port->port_sink_caps = port->pd_list[0]->sink_cap;
7130         port->selected_pd = port->pds[0];
7131         return 0;
7132
7133 err_unregister:
7134         tcpm_port_unregister_pd(port);
7135
7136         return ret;
7137 }
7138
7139 static void tcpm_fw_get_timings(struct tcpm_port *port, struct fwnode_handle *fwnode)
7140 {
7141         int ret;
7142         u32 val;
7143
7144         ret = fwnode_property_read_u32(fwnode, "sink-wait-cap-time-ms", &val);
7145         if (!ret)
7146                 port->timings.sink_wait_cap_time = val;
7147         else
7148                 port->timings.sink_wait_cap_time = PD_T_SINK_WAIT_CAP;
7149
7150         ret = fwnode_property_read_u32(fwnode, "ps-source-off-time-ms", &val);
7151         if (!ret)
7152                 port->timings.ps_src_off_time = val;
7153         else
7154                 port->timings.ps_src_off_time = PD_T_PS_SOURCE_OFF;
7155
7156         ret = fwnode_property_read_u32(fwnode, "cc-debounce-time-ms", &val);
7157         if (!ret)
7158                 port->timings.cc_debounce_time = val;
7159         else
7160                 port->timings.cc_debounce_time = PD_T_CC_DEBOUNCE;
7161
7162         ret = fwnode_property_read_u32(fwnode, "sink-bc12-completion-time-ms", &val);
7163         if (!ret)
7164                 port->timings.snk_bc12_cmpletion_time = val;
7165 }
7166
7167 static int tcpm_fw_get_caps(struct tcpm_port *port, struct fwnode_handle *fwnode)
7168 {
7169         struct fwnode_handle *capabilities, *child, *caps = NULL;
7170         unsigned int nr_src_pdo, nr_snk_pdo;
7171         const char *opmode_str;
7172         u32 *src_pdo, *snk_pdo;
7173         u32 uw, frs_current;
7174         int ret = 0, i;
7175         int mode;
7176
7177         if (!fwnode)
7178                 return -EINVAL;
7179
7180         /*
7181          * This fwnode has a "compatible" property, but is never populated as a
7182          * struct device. Instead we simply parse it to read the properties.
7183          * This it breaks fw_devlink=on. To maintain backward compatibility
7184          * with existing DT files, we work around this by deleting any
7185          * fwnode_links to/from this fwnode.
7186          */
7187         fw_devlink_purge_absent_suppliers(fwnode);
7188
7189         ret = typec_get_fw_cap(&port->typec_caps, fwnode);
7190         if (ret < 0)
7191                 return ret;
7192
7193         mode = 0;
7194
7195         if (fwnode_property_read_bool(fwnode, "accessory-mode-audio"))
7196                 port->typec_caps.accessory[mode++] = TYPEC_ACCESSORY_AUDIO;
7197
7198         if (fwnode_property_read_bool(fwnode, "accessory-mode-debug"))
7199                 port->typec_caps.accessory[mode++] = TYPEC_ACCESSORY_DEBUG;
7200
7201         port->port_type = port->typec_caps.type;
7202         port->pd_supported = !fwnode_property_read_bool(fwnode, "pd-disable");
7203         port->slow_charger_loop = fwnode_property_read_bool(fwnode, "slow-charger-loop");
7204         port->self_powered = fwnode_property_read_bool(fwnode, "self-powered");
7205
7206         if (!port->pd_supported) {
7207                 ret = fwnode_property_read_string(fwnode, "typec-power-opmode", &opmode_str);
7208                 if (ret)
7209                         return ret;
7210                 ret = typec_find_pwr_opmode(opmode_str);
7211                 if (ret < 0)
7212                         return ret;
7213                 port->src_rp = tcpm_pwr_opmode_to_rp(ret);
7214                 return 0;
7215         }
7216
7217         /* The following code are applicable to pd-capable ports, i.e. pd_supported is true. */
7218
7219         /* FRS can only be supported by DRP ports */
7220         if (port->port_type == TYPEC_PORT_DRP) {
7221                 ret = fwnode_property_read_u32(fwnode, "new-source-frs-typec-current",
7222                                                &frs_current);
7223                 if (!ret && frs_current <= FRS_5V_3A)
7224                         port->new_source_frs_current = frs_current;
7225
7226                 if (ret)
7227                         ret = 0;
7228         }
7229
7230         /* For the backward compatibility, "capabilities" node is optional. */
7231         capabilities = fwnode_get_named_child_node(fwnode, "capabilities");
7232         if (!capabilities) {
7233                 port->pd_count = 1;
7234         } else {
7235                 fwnode_for_each_child_node(capabilities, child)
7236                         port->pd_count++;
7237
7238                 if (!port->pd_count) {
7239                         ret = -ENODATA;
7240                         goto put_capabilities;
7241                 }
7242         }
7243
7244         port->pds = devm_kcalloc(port->dev, port->pd_count, sizeof(struct usb_power_delivery *),
7245                                  GFP_KERNEL);
7246         if (!port->pds) {
7247                 ret = -ENOMEM;
7248                 goto put_capabilities;
7249         }
7250
7251         port->pd_list = devm_kcalloc(port->dev, port->pd_count, sizeof(struct pd_data *),
7252                                      GFP_KERNEL);
7253         if (!port->pd_list) {
7254                 ret = -ENOMEM;
7255                 goto put_capabilities;
7256         }
7257
7258         for (i = 0; i < port->pd_count; i++) {
7259                 port->pd_list[i] = devm_kzalloc(port->dev, sizeof(struct pd_data), GFP_KERNEL);
7260                 if (!port->pd_list[i]) {
7261                         ret = -ENOMEM;
7262                         goto put_capabilities;
7263                 }
7264
7265                 src_pdo = port->pd_list[i]->source_desc.pdo;
7266                 port->pd_list[i]->source_desc.role = TYPEC_SOURCE;
7267                 snk_pdo = port->pd_list[i]->sink_desc.pdo;
7268                 port->pd_list[i]->sink_desc.role = TYPEC_SINK;
7269
7270                 /* If "capabilities" is NULL, fall back to single pd cap population. */
7271                 if (!capabilities)
7272                         caps = fwnode;
7273                 else
7274                         caps = fwnode_get_next_child_node(capabilities, caps);
7275
7276                 if (port->port_type != TYPEC_PORT_SNK) {
7277                         ret = fwnode_property_count_u32(caps, "source-pdos");
7278                         if (ret == 0) {
7279                                 ret = -EINVAL;
7280                                 goto put_caps;
7281                         }
7282                         if (ret < 0)
7283                                 goto put_caps;
7284
7285                         nr_src_pdo = min(ret, PDO_MAX_OBJECTS);
7286                         ret = fwnode_property_read_u32_array(caps, "source-pdos", src_pdo,
7287                                                              nr_src_pdo);
7288                         if (ret)
7289                                 goto put_caps;
7290
7291                         ret = tcpm_validate_caps(port, src_pdo, nr_src_pdo);
7292                         if (ret)
7293                                 goto put_caps;
7294
7295                         if (i == 0) {
7296                                 port->nr_src_pdo = nr_src_pdo;
7297                                 memcpy_and_pad(port->src_pdo, sizeof(u32) * PDO_MAX_OBJECTS,
7298                                                port->pd_list[0]->source_desc.pdo,
7299                                                sizeof(u32) * nr_src_pdo,
7300                                                0);
7301                         }
7302                 }
7303
7304                 if (port->port_type != TYPEC_PORT_SRC) {
7305                         ret = fwnode_property_count_u32(caps, "sink-pdos");
7306                         if (ret == 0) {
7307                                 ret = -EINVAL;
7308                                 goto put_caps;
7309                         }
7310
7311                         if (ret < 0)
7312                                 goto put_caps;
7313
7314                         nr_snk_pdo = min(ret, PDO_MAX_OBJECTS);
7315                         ret = fwnode_property_read_u32_array(caps, "sink-pdos", snk_pdo,
7316                                                              nr_snk_pdo);
7317                         if (ret)
7318                                 goto put_caps;
7319
7320                         ret = tcpm_validate_caps(port, snk_pdo, nr_snk_pdo);
7321                         if (ret)
7322                                 goto put_caps;
7323
7324                         if (fwnode_property_read_u32(caps, "op-sink-microwatt", &uw) < 0) {
7325                                 ret = -EINVAL;
7326                                 goto put_caps;
7327                         }
7328
7329                         port->pd_list[i]->operating_snk_mw = uw / 1000;
7330
7331                         if (i == 0) {
7332                                 port->nr_snk_pdo = nr_snk_pdo;
7333                                 memcpy_and_pad(port->snk_pdo, sizeof(u32) * PDO_MAX_OBJECTS,
7334                                                port->pd_list[0]->sink_desc.pdo,
7335                                                sizeof(u32) * nr_snk_pdo,
7336                                                0);
7337                                 port->operating_snk_mw = port->pd_list[0]->operating_snk_mw;
7338                         }
7339                 }
7340         }
7341
7342 put_caps:
7343         if (caps != fwnode)
7344                 fwnode_handle_put(caps);
7345 put_capabilities:
7346         fwnode_handle_put(capabilities);
7347         return ret;
7348 }
7349
7350 static int tcpm_fw_get_snk_vdos(struct tcpm_port *port, struct fwnode_handle *fwnode)
7351 {
7352         int ret;
7353
7354         /* sink-vdos is optional */
7355         ret = fwnode_property_count_u32(fwnode, "sink-vdos");
7356         if (ret < 0)
7357                 return 0;
7358
7359         port->nr_snk_vdo = min(ret, VDO_MAX_OBJECTS);
7360         if (port->nr_snk_vdo) {
7361                 ret = fwnode_property_read_u32_array(fwnode, "sink-vdos",
7362                                                      port->snk_vdo,
7363                                                      port->nr_snk_vdo);
7364                 if (ret < 0)
7365                         return ret;
7366         }
7367
7368         /* If sink-vdos is found, sink-vdos-v1 is expected for backward compatibility. */
7369         if (port->nr_snk_vdo) {
7370                 ret = fwnode_property_count_u32(fwnode, "sink-vdos-v1");
7371                 if (ret < 0)
7372                         return ret;
7373                 else if (ret == 0)
7374                         return -ENODATA;
7375
7376                 port->nr_snk_vdo_v1 = min(ret, VDO_MAX_OBJECTS);
7377                 ret = fwnode_property_read_u32_array(fwnode, "sink-vdos-v1",
7378                                                      port->snk_vdo_v1,
7379                                                      port->nr_snk_vdo_v1);
7380                 if (ret < 0)
7381                         return ret;
7382         }
7383
7384         return 0;
7385 }
7386
7387 static void tcpm_fw_get_pd_revision(struct tcpm_port *port, struct fwnode_handle *fwnode)
7388 {
7389         int ret;
7390         u8 val[4];
7391
7392         ret = fwnode_property_count_u8(fwnode, "pd-revision");
7393         if (!ret || ret != 4) {
7394                 tcpm_log(port, "Unable to find pd-revision property or incorrect array size");
7395                 return;
7396         }
7397
7398         ret = fwnode_property_read_u8_array(fwnode, "pd-revision", val, 4);
7399         if (ret) {
7400                 tcpm_log(port, "Failed to parse pd-revision, ret:(%d)", ret);
7401                 return;
7402         }
7403
7404         port->pd_rev.rev_major = val[0];
7405         port->pd_rev.rev_minor = val[1];
7406         port->pd_rev.ver_major = val[2];
7407         port->pd_rev.ver_minor = val[3];
7408 }
7409
7410 /* Power Supply access to expose source power information */
7411 enum tcpm_psy_online_states {
7412         TCPM_PSY_OFFLINE = 0,
7413         TCPM_PSY_FIXED_ONLINE,
7414         TCPM_PSY_PROG_ONLINE,
7415 };
7416
7417 static enum power_supply_property tcpm_psy_props[] = {
7418         POWER_SUPPLY_PROP_USB_TYPE,
7419         POWER_SUPPLY_PROP_ONLINE,
7420         POWER_SUPPLY_PROP_VOLTAGE_MIN,
7421         POWER_SUPPLY_PROP_VOLTAGE_MAX,
7422         POWER_SUPPLY_PROP_VOLTAGE_NOW,
7423         POWER_SUPPLY_PROP_CURRENT_MAX,
7424         POWER_SUPPLY_PROP_CURRENT_NOW,
7425 };
7426
7427 static int tcpm_psy_get_online(struct tcpm_port *port,
7428                                union power_supply_propval *val)
7429 {
7430         if (port->vbus_charge) {
7431                 if (port->pps_data.active)
7432                         val->intval = TCPM_PSY_PROG_ONLINE;
7433                 else
7434                         val->intval = TCPM_PSY_FIXED_ONLINE;
7435         } else {
7436                 val->intval = TCPM_PSY_OFFLINE;
7437         }
7438
7439         return 0;
7440 }
7441
7442 static int tcpm_psy_get_voltage_min(struct tcpm_port *port,
7443                                     union power_supply_propval *val)
7444 {
7445         if (port->pps_data.active)
7446                 val->intval = port->pps_data.min_volt * 1000;
7447         else
7448                 val->intval = port->supply_voltage * 1000;
7449
7450         return 0;
7451 }
7452
7453 static int tcpm_psy_get_voltage_max(struct tcpm_port *port,
7454                                     union power_supply_propval *val)
7455 {
7456         if (port->pps_data.active)
7457                 val->intval = port->pps_data.max_volt * 1000;
7458         else
7459                 val->intval = port->supply_voltage * 1000;
7460
7461         return 0;
7462 }
7463
7464 static int tcpm_psy_get_voltage_now(struct tcpm_port *port,
7465                                     union power_supply_propval *val)
7466 {
7467         val->intval = port->supply_voltage * 1000;
7468
7469         return 0;
7470 }
7471
7472 static int tcpm_psy_get_current_max(struct tcpm_port *port,
7473                                     union power_supply_propval *val)
7474 {
7475         if (port->pps_data.active)
7476                 val->intval = port->pps_data.max_curr * 1000;
7477         else
7478                 val->intval = port->current_limit * 1000;
7479
7480         return 0;
7481 }
7482
7483 static int tcpm_psy_get_current_now(struct tcpm_port *port,
7484                                     union power_supply_propval *val)
7485 {
7486         val->intval = port->current_limit * 1000;
7487
7488         return 0;
7489 }
7490
7491 static int tcpm_psy_get_input_power_limit(struct tcpm_port *port,
7492                                           union power_supply_propval *val)
7493 {
7494         unsigned int src_mv, src_ma, max_src_uw = 0;
7495         unsigned int i, tmp;
7496
7497         for (i = 0; i < port->nr_source_caps; i++) {
7498                 u32 pdo = port->source_caps[i];
7499
7500                 if (pdo_type(pdo) == PDO_TYPE_FIXED) {
7501                         src_mv = pdo_fixed_voltage(pdo);
7502                         src_ma = pdo_max_current(pdo);
7503                         tmp = src_mv * src_ma;
7504                         max_src_uw = max(tmp, max_src_uw);
7505                 }
7506         }
7507
7508         val->intval = max_src_uw;
7509         return 0;
7510 }
7511
7512 static int tcpm_psy_get_prop(struct power_supply *psy,
7513                              enum power_supply_property psp,
7514                              union power_supply_propval *val)
7515 {
7516         struct tcpm_port *port = power_supply_get_drvdata(psy);
7517         int ret = 0;
7518
7519         switch (psp) {
7520         case POWER_SUPPLY_PROP_USB_TYPE:
7521                 val->intval = port->usb_type;
7522                 break;
7523         case POWER_SUPPLY_PROP_ONLINE:
7524                 ret = tcpm_psy_get_online(port, val);
7525                 break;
7526         case POWER_SUPPLY_PROP_VOLTAGE_MIN:
7527                 ret = tcpm_psy_get_voltage_min(port, val);
7528                 break;
7529         case POWER_SUPPLY_PROP_VOLTAGE_MAX:
7530                 ret = tcpm_psy_get_voltage_max(port, val);
7531                 break;
7532         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
7533                 ret = tcpm_psy_get_voltage_now(port, val);
7534                 break;
7535         case POWER_SUPPLY_PROP_CURRENT_MAX:
7536                 ret = tcpm_psy_get_current_max(port, val);
7537                 break;
7538         case POWER_SUPPLY_PROP_CURRENT_NOW:
7539                 ret = tcpm_psy_get_current_now(port, val);
7540                 break;
7541         case POWER_SUPPLY_PROP_INPUT_POWER_LIMIT:
7542                 tcpm_psy_get_input_power_limit(port, val);
7543                 break;
7544         default:
7545                 ret = -EINVAL;
7546                 break;
7547         }
7548
7549         return ret;
7550 }
7551
7552 static int tcpm_psy_set_online(struct tcpm_port *port,
7553                                const union power_supply_propval *val)
7554 {
7555         int ret;
7556
7557         switch (val->intval) {
7558         case TCPM_PSY_FIXED_ONLINE:
7559                 ret = tcpm_pps_activate(port, false);
7560                 break;
7561         case TCPM_PSY_PROG_ONLINE:
7562                 ret = tcpm_pps_activate(port, true);
7563                 break;
7564         default:
7565                 ret = -EINVAL;
7566                 break;
7567         }
7568
7569         return ret;
7570 }
7571
7572 static int tcpm_psy_set_prop(struct power_supply *psy,
7573                              enum power_supply_property psp,
7574                              const union power_supply_propval *val)
7575 {
7576         struct tcpm_port *port = power_supply_get_drvdata(psy);
7577         int ret;
7578
7579         /*
7580          * All the properties below are related to USB PD. The check needs to be
7581          * property specific when a non-pd related property is added.
7582          */
7583         if (!port->pd_supported)
7584                 return -EOPNOTSUPP;
7585
7586         switch (psp) {
7587         case POWER_SUPPLY_PROP_ONLINE:
7588                 ret = tcpm_psy_set_online(port, val);
7589                 break;
7590         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
7591                 ret = tcpm_pps_set_out_volt(port, val->intval / 1000);
7592                 break;
7593         case POWER_SUPPLY_PROP_CURRENT_NOW:
7594                 if (val->intval > port->pps_data.max_curr * 1000)
7595                         ret = -EINVAL;
7596                 else
7597                         ret = tcpm_pps_set_op_curr(port, val->intval / 1000);
7598                 break;
7599         default:
7600                 ret = -EINVAL;
7601                 break;
7602         }
7603         power_supply_changed(port->psy);
7604         return ret;
7605 }
7606
7607 static int tcpm_psy_prop_writeable(struct power_supply *psy,
7608                                    enum power_supply_property psp)
7609 {
7610         switch (psp) {
7611         case POWER_SUPPLY_PROP_ONLINE:
7612         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
7613         case POWER_SUPPLY_PROP_CURRENT_NOW:
7614                 return 1;
7615         default:
7616                 return 0;
7617         }
7618 }
7619
7620 static const char *tcpm_psy_name_prefix = "tcpm-source-psy-";
7621
7622 static int devm_tcpm_psy_register(struct tcpm_port *port)
7623 {
7624         struct power_supply_config psy_cfg = {};
7625         const char *port_dev_name = dev_name(port->dev);
7626         size_t psy_name_len = strlen(tcpm_psy_name_prefix) +
7627                                      strlen(port_dev_name) + 1;
7628         char *psy_name;
7629
7630         psy_cfg.drv_data = port;
7631         psy_cfg.fwnode = dev_fwnode(port->dev);
7632         psy_name = devm_kzalloc(port->dev, psy_name_len, GFP_KERNEL);
7633         if (!psy_name)
7634                 return -ENOMEM;
7635
7636         snprintf(psy_name, psy_name_len, "%s%s", tcpm_psy_name_prefix,
7637                  port_dev_name);
7638         port->psy_desc.name = psy_name;
7639         port->psy_desc.type = POWER_SUPPLY_TYPE_USB;
7640         port->psy_desc.usb_types = BIT(POWER_SUPPLY_USB_TYPE_C)  |
7641                                    BIT(POWER_SUPPLY_USB_TYPE_PD) |
7642                                    BIT(POWER_SUPPLY_USB_TYPE_PD_PPS);
7643         port->psy_desc.properties = tcpm_psy_props;
7644         port->psy_desc.num_properties = ARRAY_SIZE(tcpm_psy_props);
7645         port->psy_desc.get_property = tcpm_psy_get_prop;
7646         port->psy_desc.set_property = tcpm_psy_set_prop;
7647         port->psy_desc.property_is_writeable = tcpm_psy_prop_writeable;
7648
7649         port->usb_type = POWER_SUPPLY_USB_TYPE_C;
7650
7651         port->psy = devm_power_supply_register(port->dev, &port->psy_desc,
7652                                                &psy_cfg);
7653
7654         return PTR_ERR_OR_ZERO(port->psy);
7655 }
7656
7657 static enum hrtimer_restart state_machine_timer_handler(struct hrtimer *timer)
7658 {
7659         struct tcpm_port *port = container_of(timer, struct tcpm_port, state_machine_timer);
7660
7661         if (port->registered)
7662                 kthread_queue_work(port->wq, &port->state_machine);
7663         return HRTIMER_NORESTART;
7664 }
7665
7666 static enum hrtimer_restart vdm_state_machine_timer_handler(struct hrtimer *timer)
7667 {
7668         struct tcpm_port *port = container_of(timer, struct tcpm_port, vdm_state_machine_timer);
7669
7670         if (port->registered)
7671                 kthread_queue_work(port->wq, &port->vdm_state_machine);
7672         return HRTIMER_NORESTART;
7673 }
7674
7675 static enum hrtimer_restart enable_frs_timer_handler(struct hrtimer *timer)
7676 {
7677         struct tcpm_port *port = container_of(timer, struct tcpm_port, enable_frs_timer);
7678
7679         if (port->registered)
7680                 kthread_queue_work(port->wq, &port->enable_frs);
7681         return HRTIMER_NORESTART;
7682 }
7683
7684 static enum hrtimer_restart send_discover_timer_handler(struct hrtimer *timer)
7685 {
7686         struct tcpm_port *port = container_of(timer, struct tcpm_port, send_discover_timer);
7687
7688         if (port->registered)
7689                 kthread_queue_work(port->wq, &port->send_discover_work);
7690         return HRTIMER_NORESTART;
7691 }
7692
7693 struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc)
7694 {
7695         struct tcpm_port *port;
7696         int err;
7697
7698         if (!dev || !tcpc ||
7699             !tcpc->get_vbus || !tcpc->set_cc || !tcpc->get_cc ||
7700             !tcpc->set_polarity || !tcpc->set_vconn || !tcpc->set_vbus ||
7701             !tcpc->set_pd_rx || !tcpc->set_roles || !tcpc->pd_transmit)
7702                 return ERR_PTR(-EINVAL);
7703
7704         port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL);
7705         if (!port)
7706                 return ERR_PTR(-ENOMEM);
7707
7708         port->dev = dev;
7709         port->tcpc = tcpc;
7710
7711         mutex_init(&port->lock);
7712         mutex_init(&port->swap_lock);
7713
7714         port->wq = kthread_run_worker(0, dev_name(dev));
7715         if (IS_ERR(port->wq))
7716                 return ERR_CAST(port->wq);
7717         sched_set_fifo(port->wq->task);
7718
7719         kthread_init_work(&port->state_machine, tcpm_state_machine_work);
7720         kthread_init_work(&port->vdm_state_machine, vdm_state_machine_work);
7721         kthread_init_work(&port->event_work, tcpm_pd_event_handler);
7722         kthread_init_work(&port->enable_frs, tcpm_enable_frs_work);
7723         kthread_init_work(&port->send_discover_work, tcpm_send_discover_work);
7724         hrtimer_init(&port->state_machine_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
7725         port->state_machine_timer.function = state_machine_timer_handler;
7726         hrtimer_init(&port->vdm_state_machine_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
7727         port->vdm_state_machine_timer.function = vdm_state_machine_timer_handler;
7728         hrtimer_init(&port->enable_frs_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
7729         port->enable_frs_timer.function = enable_frs_timer_handler;
7730         hrtimer_init(&port->send_discover_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
7731         port->send_discover_timer.function = send_discover_timer_handler;
7732
7733         spin_lock_init(&port->pd_event_lock);
7734
7735         init_completion(&port->tx_complete);
7736         init_completion(&port->swap_complete);
7737         init_completion(&port->pps_complete);
7738         tcpm_debugfs_init(port);
7739
7740         err = tcpm_fw_get_caps(port, tcpc->fwnode);
7741         if (err < 0)
7742                 goto out_destroy_wq;
7743         err = tcpm_fw_get_snk_vdos(port, tcpc->fwnode);
7744         if (err < 0)
7745                 goto out_destroy_wq;
7746
7747         tcpm_fw_get_timings(port, tcpc->fwnode);
7748         tcpm_fw_get_pd_revision(port, tcpc->fwnode);
7749
7750         port->try_role = port->typec_caps.prefer_role;
7751
7752         port->typec_caps.revision = 0x0120;     /* Type-C spec release 1.2 */
7753
7754         if (port->pd_rev.rev_major)
7755                 port->typec_caps.pd_revision = port->pd_rev.rev_major << 8 |
7756                                                port->pd_rev.rev_minor;
7757         else
7758                 port->typec_caps.pd_revision = 0x0300;  /* USB-PD spec release 3.0 */
7759
7760         port->typec_caps.svdm_version = SVDM_VER_2_0;
7761         port->typec_caps.driver_data = port;
7762         port->typec_caps.ops = &tcpm_ops;
7763         port->typec_caps.orientation_aware = 1;
7764
7765         port->partner_desc.identity = &port->partner_ident;
7766
7767         port->role_sw = usb_role_switch_get(port->dev);
7768         if (!port->role_sw)
7769                 port->role_sw = fwnode_usb_role_switch_get(tcpc->fwnode);
7770         if (IS_ERR(port->role_sw)) {
7771                 err = PTR_ERR(port->role_sw);
7772                 goto out_destroy_wq;
7773         }
7774
7775         err = devm_tcpm_psy_register(port);
7776         if (err)
7777                 goto out_role_sw_put;
7778         power_supply_changed(port->psy);
7779
7780         err = tcpm_port_register_pd(port);
7781         if (err)
7782                 goto out_role_sw_put;
7783
7784         if (port->pds)
7785                 port->typec_caps.pd = port->pds[0];
7786
7787         port->typec_port = typec_register_port(port->dev, &port->typec_caps);
7788         if (IS_ERR(port->typec_port)) {
7789                 err = PTR_ERR(port->typec_port);
7790                 goto out_unregister_pd;
7791         }
7792
7793         typec_port_register_altmodes(port->typec_port,
7794                                      &tcpm_altmode_ops, port,
7795                                      port->port_altmode, ALTMODE_DISCOVERY_MAX);
7796         typec_port_register_cable_ops(port->port_altmode, ARRAY_SIZE(port->port_altmode),
7797                                       &tcpm_cable_ops);
7798         port->registered = true;
7799
7800         mutex_lock(&port->lock);
7801         tcpm_init(port);
7802         mutex_unlock(&port->lock);
7803
7804         tcpm_log(port, "%s: registered", dev_name(dev));
7805         return port;
7806
7807 out_unregister_pd:
7808         tcpm_port_unregister_pd(port);
7809 out_role_sw_put:
7810         usb_role_switch_put(port->role_sw);
7811 out_destroy_wq:
7812         tcpm_debugfs_exit(port);
7813         kthread_destroy_worker(port->wq);
7814         return ERR_PTR(err);
7815 }
7816 EXPORT_SYMBOL_GPL(tcpm_register_port);
7817
7818 void tcpm_unregister_port(struct tcpm_port *port)
7819 {
7820         int i;
7821
7822         port->registered = false;
7823         kthread_destroy_worker(port->wq);
7824
7825         hrtimer_cancel(&port->send_discover_timer);
7826         hrtimer_cancel(&port->enable_frs_timer);
7827         hrtimer_cancel(&port->vdm_state_machine_timer);
7828         hrtimer_cancel(&port->state_machine_timer);
7829
7830         tcpm_reset_port(port);
7831
7832         tcpm_port_unregister_pd(port);
7833
7834         for (i = 0; i < ARRAY_SIZE(port->port_altmode); i++)
7835                 typec_unregister_altmode(port->port_altmode[i]);
7836         typec_unregister_port(port->typec_port);
7837         usb_role_switch_put(port->role_sw);
7838         tcpm_debugfs_exit(port);
7839 }
7840 EXPORT_SYMBOL_GPL(tcpm_unregister_port);
7841
7842 MODULE_AUTHOR("Guenter Roeck <[email protected]>");
7843 MODULE_DESCRIPTION("USB Type-C Port Manager");
7844 MODULE_LICENSE("GPL");