typec/tcpm/tcpm.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * Copyright 2015-2017 Google, Inc
0004  *
0005  * USB Power Delivery protocol stack.
0006  */
0007
0008 #include <linux/completion.h>
0009 #include <linux/debugfs.h>
0010 #include <linux/device.h>
0011 #include <linux/hrtimer.h>
0012 #include <linux/jiffies.h>
0013 #include <linux/kernel.h>
0014 #include <linux/kthread.h>
0015 #include <linux/module.h>
0016 #include <linux/mutex.h>
0017 #include <linux/power_supply.h>
0018 #include <linux/proc_fs.h>
0019 #include <linux/property.h>
0020 #include <linux/sched/clock.h>
0021 #include <linux/seq_file.h>
0022 #include <linux/slab.h>
0023 #include <linux/spinlock.h>
0024 #include <linux/usb.h>
0025 #include <linux/usb/pd.h>
0026 #include <linux/usb/pd_ado.h>
0027 #include <linux/usb/pd_bdo.h>
0028 #include <linux/usb/pd_ext_sdb.h>
0029 #include <linux/usb/pd_vdo.h>
0030 #include <linux/usb/role.h>
0031 #include <linux/usb/tcpm.h>
0032 #include <linux/usb/typec_altmode.h>
0033
0034 #include <uapi/linux/sched/types.h>
0035
0036 #define FOREACH_STATE(S)            \
0037     S(INVALID_STATE),           \
0038     S(TOGGLING),            \
0039     S(SRC_UNATTACHED),          \
0040     S(SRC_ATTACH_WAIT),         \
0041     S(SRC_ATTACHED),            \
0042     S(SRC_STARTUP),             \
0043     S(SRC_SEND_CAPABILITIES),       \
0044     S(SRC_SEND_CAPABILITIES_TIMEOUT),   \
0045     S(SRC_NEGOTIATE_CAPABILITIES),      \
0046     S(SRC_TRANSITION_SUPPLY),       \
0047     S(SRC_READY),               \
0048     S(SRC_WAIT_NEW_CAPABILITIES),       \
0049                         \
0050     S(SNK_UNATTACHED),          \
0051     S(SNK_ATTACH_WAIT),         \
0052     S(SNK_DEBOUNCED),           \
0053     S(SNK_ATTACHED),            \
0054     S(SNK_STARTUP),             \
0055     S(SNK_DISCOVERY),           \
0056     S(SNK_DISCOVERY_DEBOUNCE),      \
0057     S(SNK_DISCOVERY_DEBOUNCE_DONE),     \
0058     S(SNK_WAIT_CAPABILITIES),       \
0059     S(SNK_NEGOTIATE_CAPABILITIES),      \
0060     S(SNK_NEGOTIATE_PPS_CAPABILITIES),  \
0061     S(SNK_TRANSITION_SINK),         \
0062     S(SNK_TRANSITION_SINK_VBUS),        \
0063     S(SNK_READY),               \
0064                         \
0065     S(ACC_UNATTACHED),          \
0066     S(DEBUG_ACC_ATTACHED),          \
0067     S(AUDIO_ACC_ATTACHED),          \
0068     S(AUDIO_ACC_DEBOUNCE),          \
0069                         \
0070     S(HARD_RESET_SEND),         \
0071     S(HARD_RESET_START),            \
0072     S(SRC_HARD_RESET_VBUS_OFF),     \
0073     S(SRC_HARD_RESET_VBUS_ON),      \
0074     S(SNK_HARD_RESET_SINK_OFF),     \
0075     S(SNK_HARD_RESET_WAIT_VBUS),        \
0076     S(SNK_HARD_RESET_SINK_ON),      \
0077                         \
0078     S(SOFT_RESET),              \
0079     S(SRC_SOFT_RESET_WAIT_SNK_TX),      \
0080     S(SNK_SOFT_RESET),          \
0081     S(SOFT_RESET_SEND),         \
0082                         \
0083     S(DR_SWAP_ACCEPT),          \
0084     S(DR_SWAP_SEND),            \
0085     S(DR_SWAP_SEND_TIMEOUT),        \
0086     S(DR_SWAP_CANCEL),          \
0087     S(DR_SWAP_CHANGE_DR),           \
0088                         \
0089     S(PR_SWAP_ACCEPT),          \
0090     S(PR_SWAP_SEND),            \
0091     S(PR_SWAP_SEND_TIMEOUT),        \
0092     S(PR_SWAP_CANCEL),          \
0093     S(PR_SWAP_START),           \
0094     S(PR_SWAP_SRC_SNK_TRANSITION_OFF),  \
0095     S(PR_SWAP_SRC_SNK_SOURCE_OFF),      \
0096     S(PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED), \
0097     S(PR_SWAP_SRC_SNK_SINK_ON),     \
0098     S(PR_SWAP_SNK_SRC_SINK_OFF),        \
0099     S(PR_SWAP_SNK_SRC_SOURCE_ON),       \
0100     S(PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP),    \
0101                         \
0102     S(VCONN_SWAP_ACCEPT),           \
0103     S(VCONN_SWAP_SEND),         \
0104     S(VCONN_SWAP_SEND_TIMEOUT),     \
0105     S(VCONN_SWAP_CANCEL),           \
0106     S(VCONN_SWAP_START),            \
0107     S(VCONN_SWAP_WAIT_FOR_VCONN),       \
0108     S(VCONN_SWAP_TURN_ON_VCONN),        \
0109     S(VCONN_SWAP_TURN_OFF_VCONN),       \
0110                         \
0111     S(FR_SWAP_SEND),            \
0112     S(FR_SWAP_SEND_TIMEOUT),        \
0113     S(FR_SWAP_SNK_SRC_TRANSITION_TO_OFF),           \
0114     S(FR_SWAP_SNK_SRC_NEW_SINK_READY),      \
0115     S(FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED), \
0116     S(FR_SWAP_CANCEL),          \
0117                         \
0118     S(SNK_TRY),             \
0119     S(SNK_TRY_WAIT),            \
0120     S(SNK_TRY_WAIT_DEBOUNCE),               \
0121     S(SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS),    \
0122     S(SRC_TRYWAIT),             \
0123     S(SRC_TRYWAIT_DEBOUNCE),        \
0124     S(SRC_TRYWAIT_UNATTACHED),      \
0125                         \
0126     S(SRC_TRY),             \
0127     S(SRC_TRY_WAIT),                        \
0128     S(SRC_TRY_DEBOUNCE),            \
0129     S(SNK_TRYWAIT),             \
0130     S(SNK_TRYWAIT_DEBOUNCE),        \
0131     S(SNK_TRYWAIT_VBUS),            \
0132     S(BIST_RX),             \
0133                         \
0134     S(GET_STATUS_SEND),         \
0135     S(GET_STATUS_SEND_TIMEOUT),     \
0136     S(GET_PPS_STATUS_SEND),         \
0137     S(GET_PPS_STATUS_SEND_TIMEOUT),     \
0138                         \
0139     S(GET_SINK_CAP),            \
0140     S(GET_SINK_CAP_TIMEOUT),        \
0141                         \
0142     S(ERROR_RECOVERY),          \
0143     S(PORT_RESET),              \
0144     S(PORT_RESET_WAIT_OFF),         \
0145                         \
0146     S(AMS_START),               \
0147     S(CHUNK_NOT_SUPP)
0148
0149 #define FOREACH_AMS(S)              \
0150     S(NONE_AMS),                \
0151     S(POWER_NEGOTIATION),           \
0152     S(GOTOMIN),             \
0153     S(SOFT_RESET_AMS),          \
0154     S(HARD_RESET),              \
0155     S(CABLE_RESET),             \
0156     S(GET_SOURCE_CAPABILITIES),     \
0157     S(GET_SINK_CAPABILITIES),       \
0158     S(POWER_ROLE_SWAP),         \
0159     S(FAST_ROLE_SWAP),          \
0160     S(DATA_ROLE_SWAP),          \
0161     S(VCONN_SWAP),              \
0162     S(SOURCE_ALERT),            \
0163     S(GETTING_SOURCE_EXTENDED_CAPABILITIES),\
0164     S(GETTING_SOURCE_SINK_STATUS),      \
0165     S(GETTING_BATTERY_CAPABILITIES),    \
0166     S(GETTING_BATTERY_STATUS),      \
0167     S(GETTING_MANUFACTURER_INFORMATION),    \
0168     S(SECURITY),                \
0169     S(FIRMWARE_UPDATE),         \
0170     S(DISCOVER_IDENTITY),           \
0171     S(SOURCE_STARTUP_CABLE_PLUG_DISCOVER_IDENTITY), \
0172     S(DISCOVER_SVIDS),          \
0173     S(DISCOVER_MODES),          \
0174     S(DFP_TO_UFP_ENTER_MODE),       \
0175     S(DFP_TO_UFP_EXIT_MODE),        \
0176     S(DFP_TO_CABLE_PLUG_ENTER_MODE),    \
0177     S(DFP_TO_CABLE_PLUG_EXIT_MODE),     \
0178     S(ATTENTION),               \
0179     S(BIST),                \
0180     S(UNSTRUCTURED_VDMS),           \
0181     S(STRUCTURED_VDMS),         \
0182     S(COUNTRY_INFO),            \
0183     S(COUNTRY_CODES)
0184
0185 #define GENERATE_ENUM(e)    e
0186 #define GENERATE_STRING(s)  #s
0187
0188 enum tcpm_state {
0189     FOREACH_STATE(GENERATE_ENUM)
0190 };
0191
0192 static const char * const tcpm_states[] = {
0193     FOREACH_STATE(GENERATE_STRING)
0194 };
0195
0196 enum tcpm_ams {
0197     FOREACH_AMS(GENERATE_ENUM)
0198 };
0199
0200 static const char * const tcpm_ams_str[] = {
0201     FOREACH_AMS(GENERATE_STRING)
0202 };
0203
0204 enum vdm_states {
0205     VDM_STATE_ERR_BUSY = -3,
0206     VDM_STATE_ERR_SEND = -2,
0207     VDM_STATE_ERR_TMOUT = -1,
0208     VDM_STATE_DONE = 0,
0209     /* Anything >0 represents an active state */
0210     VDM_STATE_READY = 1,
0211     VDM_STATE_BUSY = 2,
0212     VDM_STATE_WAIT_RSP_BUSY = 3,
0213     VDM_STATE_SEND_MESSAGE = 4,
0214 };
0215
0216 enum pd_msg_request {
0217     PD_MSG_NONE = 0,
0218     PD_MSG_CTRL_REJECT,
0219     PD_MSG_CTRL_WAIT,
0220     PD_MSG_CTRL_NOT_SUPP,
0221     PD_MSG_DATA_SINK_CAP,
0222     PD_MSG_DATA_SOURCE_CAP,
0223 };
0224
0225 enum adev_actions {
0226     ADEV_NONE = 0,
0227     ADEV_NOTIFY_USB_AND_QUEUE_VDM,
0228     ADEV_QUEUE_VDM,
0229     ADEV_QUEUE_VDM_SEND_EXIT_MODE_ON_FAIL,
0230     ADEV_ATTENTION,
0231 };
0232
0233 /*
0234  * Initial current capability of the new source when vSafe5V is applied during PD3.0 Fast Role Swap.
0235  * Based on "Table 6-14 Fixed Supply PDO - Sink" of "USB Power Delivery Specification Revision 3.0,
0236  * Version 1.2"
0237  */
0238 enum frs_typec_current {
0239     FRS_NOT_SUPPORTED,
0240     FRS_DEFAULT_POWER,
0241     FRS_5V_1P5A,
0242     FRS_5V_3A,
0243 };
0244
0245 /* Events from low level driver */
0246
0247 #define TCPM_CC_EVENT       BIT(0)
0248 #define TCPM_VBUS_EVENT     BIT(1)
0249 #define TCPM_RESET_EVENT    BIT(2)
0250 #define TCPM_FRS_EVENT      BIT(3)
0251 #define TCPM_SOURCING_VBUS  BIT(4)
0252
0253 #define LOG_BUFFER_ENTRIES  1024
0254 #define LOG_BUFFER_ENTRY_SIZE   128
0255
0256 /* Alternate mode support */
0257
0258 #define SVID_DISCOVERY_MAX  16
0259 #define ALTMODE_DISCOVERY_MAX   (SVID_DISCOVERY_MAX * MODE_DISCOVERY_MAX)
0260
0261 #define GET_SINK_CAP_RETRY_MS   100
0262 #define SEND_DISCOVER_RETRY_MS  100
0263
0264 struct pd_mode_data {
0265     int svid_index;     /* current SVID index       */
0266     int nsvids;
0267     u16 svids[SVID_DISCOVERY_MAX];
0268     int altmodes;       /* number of alternate modes    */
0269     struct typec_altmode_desc altmode_desc[ALTMODE_DISCOVERY_MAX];
0270 };
0271
0272 /*
0273  * @min_volt: Actual min voltage at the local port
0274  * @req_min_volt: Requested min voltage to the port partner
0275  * @max_volt: Actual max voltage at the local port
0276  * @req_max_volt: Requested max voltage to the port partner
0277  * @max_curr: Actual max current at the local port
0278  * @req_max_curr: Requested max current of the port partner
0279  * @req_out_volt: Requested output voltage to the port partner
0280  * @req_op_curr: Requested operating current to the port partner
0281  * @supported: Parter has at least one APDO hence supports PPS
0282  * @active: PPS mode is active
0283  */
0284 struct pd_pps_data {
0285     u32 min_volt;
0286     u32 req_min_volt;
0287     u32 max_volt;
0288     u32 req_max_volt;
0289     u32 max_curr;
0290     u32 req_max_curr;
0291     u32 req_out_volt;
0292     u32 req_op_curr;
0293     bool supported;
0294     bool active;
0295 };
0296
0297 struct tcpm_port {
0298     struct device *dev;
0299
0300     struct mutex lock;      /* tcpm state machine lock */
0301     struct kthread_worker *wq;
0302
0303     struct typec_capability typec_caps;
0304     struct typec_port *typec_port;
0305
0306     struct tcpc_dev *tcpc;
0307     struct usb_role_switch *role_sw;
0308
0309     enum typec_role vconn_role;
0310     enum typec_role pwr_role;
0311     enum typec_data_role data_role;
0312     enum typec_pwr_opmode pwr_opmode;
0313
0314     struct usb_pd_identity partner_ident;
0315     struct typec_partner_desc partner_desc;
0316     struct typec_partner *partner;
0317
0318     enum typec_cc_status cc_req;
0319     enum typec_cc_status src_rp;    /* work only if pd_supported == false */
0320
0321     enum typec_cc_status cc1;
0322     enum typec_cc_status cc2;
0323     enum typec_cc_polarity polarity;
0324
0325     bool attached;
0326     bool connected;
0327     bool registered;
0328     bool pd_supported;
0329     enum typec_port_type port_type;
0330
0331     /*
0332      * Set to true when vbus is greater than VSAFE5V min.
0333      * Set to false when vbus falls below vSinkDisconnect max threshold.
0334      */
0335     bool vbus_present;
0336
0337     /*
0338      * Set to true when vbus is less than VSAFE0V max.
0339      * Set to false when vbus is greater than VSAFE0V max.
0340      */
0341     bool vbus_vsafe0v;
0342
0343     bool vbus_never_low;
0344     bool vbus_source;
0345     bool vbus_charge;
0346
0347     /* Set to true when Discover_Identity Command is expected to be sent in Ready states. */
0348     bool send_discover;
0349     bool op_vsafe5v;
0350
0351     int try_role;
0352     int try_snk_count;
0353     int try_src_count;
0354
0355     enum pd_msg_request queued_message;
0356
0357     enum tcpm_state enter_state;
0358     enum tcpm_state prev_state;
0359     enum tcpm_state state;
0360     enum tcpm_state delayed_state;
0361     ktime_t delayed_runtime;
0362     unsigned long delay_ms;
0363
0364     spinlock_t pd_event_lock;
0365     u32 pd_events;
0366
0367     struct kthread_work event_work;
0368     struct hrtimer state_machine_timer;
0369     struct kthread_work state_machine;
0370     struct hrtimer vdm_state_machine_timer;
0371     struct kthread_work vdm_state_machine;
0372     struct hrtimer enable_frs_timer;
0373     struct kthread_work enable_frs;
0374     struct hrtimer send_discover_timer;
0375     struct kthread_work send_discover_work;
0376     bool state_machine_running;
0377     /* Set to true when VDM State Machine has following actions. */
0378     bool vdm_sm_running;
0379
0380     struct completion tx_complete;
0381     enum tcpm_transmit_status tx_status;
0382
0383     struct mutex swap_lock;     /* swap command lock */
0384     bool swap_pending;
0385     bool non_pd_role_swap;
0386     struct completion swap_complete;
0387     int swap_status;
0388
0389     unsigned int negotiated_rev;
0390     unsigned int message_id;
0391     unsigned int caps_count;
0392     unsigned int hard_reset_count;
0393     bool pd_capable;
0394     bool explicit_contract;
0395     unsigned int rx_msgid;
0396
0397     /* USB PD objects */
0398     struct usb_power_delivery *pd;
0399     struct usb_power_delivery_capabilities *port_source_caps;
0400     struct usb_power_delivery_capabilities *port_sink_caps;
0401     struct usb_power_delivery *partner_pd;
0402     struct usb_power_delivery_capabilities *partner_source_caps;
0403     struct usb_power_delivery_capabilities *partner_sink_caps;
0404
0405     /* Partner capabilities/requests */
0406     u32 sink_request;
0407     u32 source_caps[PDO_MAX_OBJECTS];
0408     unsigned int nr_source_caps;
0409     u32 sink_caps[PDO_MAX_OBJECTS];
0410     unsigned int nr_sink_caps;
0411
0412     /* Local capabilities */
0413     u32 src_pdo[PDO_MAX_OBJECTS];
0414     unsigned int nr_src_pdo;
0415     u32 snk_pdo[PDO_MAX_OBJECTS];
0416     unsigned int nr_snk_pdo;
0417     u32 snk_vdo_v1[VDO_MAX_OBJECTS];
0418     unsigned int nr_snk_vdo_v1;
0419     u32 snk_vdo[VDO_MAX_OBJECTS];
0420     unsigned int nr_snk_vdo;
0421
0422     unsigned int operating_snk_mw;
0423     bool update_sink_caps;
0424
0425     /* Requested current / voltage to the port partner */
0426     u32 req_current_limit;
0427     u32 req_supply_voltage;
0428     /* Actual current / voltage limit of the local port */
0429     u32 current_limit;
0430     u32 supply_voltage;
0431
0432     /* Used to export TA voltage and current */
0433     struct power_supply *psy;
0434     struct power_supply_desc psy_desc;
0435     enum power_supply_usb_type usb_type;
0436
0437     u32 bist_request;
0438
0439     /* PD state for Vendor Defined Messages */
0440     enum vdm_states vdm_state;
0441     u32 vdm_retries;
0442     /* next Vendor Defined Message to send */
0443     u32 vdo_data[VDO_MAX_SIZE];
0444     u8 vdo_count;
0445     /* VDO to retry if UFP responder replied busy */
0446     u32 vdo_retry;
0447
0448     /* PPS */
0449     struct pd_pps_data pps_data;
0450     struct completion pps_complete;
0451     bool pps_pending;
0452     int pps_status;
0453
0454     /* Alternate mode data */
0455     struct pd_mode_data mode_data;
0456     struct typec_altmode *partner_altmode[ALTMODE_DISCOVERY_MAX];
0457     struct typec_altmode *port_altmode[ALTMODE_DISCOVERY_MAX];
0458
0459     /* Deadline in jiffies to exit src_try_wait state */
0460     unsigned long max_wait;
0461
0462     /* port belongs to a self powered device */
0463     bool self_powered;
0464
0465     /* Sink FRS */
0466     enum frs_typec_current new_source_frs_current;
0467
0468     /* Sink caps have been queried */
0469     bool sink_cap_done;
0470
0471     /* Collision Avoidance and Atomic Message Sequence */
0472     enum tcpm_state upcoming_state;
0473     enum tcpm_ams ams;
0474     enum tcpm_ams next_ams;
0475     bool in_ams;
0476
0477     /* Auto vbus discharge status */
0478     bool auto_vbus_discharge_enabled;
0479
0480     /*
0481      * When set, port requests PD_P_SNK_STDBY_MW upon entering SNK_DISCOVERY and
0482      * the actual current limit after RX of PD_CTRL_PSRDY for PD link,
0483      * SNK_READY for non-pd link.
0484      */
0485     bool slow_charger_loop;
0486 #ifdef CONFIG_DEBUG_FS
0487     struct dentry *dentry;
0488     struct mutex logbuffer_lock;    /* log buffer access lock */
0489     int logbuffer_head;
0490     int logbuffer_tail;
0491     u8 *logbuffer[LOG_BUFFER_ENTRIES];
0492 #endif
0493 };
0494
0495 struct pd_rx_event {
0496     struct kthread_work work;
0497     struct tcpm_port *port;
0498     struct pd_message msg;
0499 };
0500
0501 static const char * const pd_rev[] = {
0502     [PD_REV10]      = "rev1",
0503     [PD_REV20]      = "rev2",
0504     [PD_REV30]      = "rev3",
0505 };
0506
0507 #define tcpm_cc_is_sink(cc) \
0508     ((cc) == TYPEC_CC_RP_DEF || (cc) == TYPEC_CC_RP_1_5 || \
0509      (cc) == TYPEC_CC_RP_3_0)
0510
0511 #define tcpm_port_is_sink(port) \
0512     ((tcpm_cc_is_sink((port)->cc1) && !tcpm_cc_is_sink((port)->cc2)) || \
0513      (tcpm_cc_is_sink((port)->cc2) && !tcpm_cc_is_sink((port)->cc1)))
0514
0515 #define tcpm_cc_is_source(cc) ((cc) == TYPEC_CC_RD)
0516 #define tcpm_cc_is_audio(cc) ((cc) == TYPEC_CC_RA)
0517 #define tcpm_cc_is_open(cc) ((cc) == TYPEC_CC_OPEN)
0518
0519 #define tcpm_port_is_source(port) \
0520     ((tcpm_cc_is_source((port)->cc1) && \
0521      !tcpm_cc_is_source((port)->cc2)) || \
0522      (tcpm_cc_is_source((port)->cc2) && \
0523       !tcpm_cc_is_source((port)->cc1)))
0524
0525 #define tcpm_port_is_debug(port) \
0526     (tcpm_cc_is_source((port)->cc1) && tcpm_cc_is_source((port)->cc2))
0527
0528 #define tcpm_port_is_audio(port) \
0529     (tcpm_cc_is_audio((port)->cc1) && tcpm_cc_is_audio((port)->cc2))
0530
0531 #define tcpm_port_is_audio_detached(port) \
0532     ((tcpm_cc_is_audio((port)->cc1) && tcpm_cc_is_open((port)->cc2)) || \
0533      (tcpm_cc_is_audio((port)->cc2) && tcpm_cc_is_open((port)->cc1)))
0534
0535 #define tcpm_try_snk(port) \
0536     ((port)->try_snk_count == 0 && (port)->try_role == TYPEC_SINK && \
0537     (port)->port_type == TYPEC_PORT_DRP)
0538
0539 #define tcpm_try_src(port) \
0540     ((port)->try_src_count == 0 && (port)->try_role == TYPEC_SOURCE && \
0541     (port)->port_type == TYPEC_PORT_DRP)
0542
0543 #define tcpm_data_role_for_source(port) \
0544     ((port)->typec_caps.data == TYPEC_PORT_UFP ? \
0545     TYPEC_DEVICE : TYPEC_HOST)
0546
0547 #define tcpm_data_role_for_sink(port) \
0548     ((port)->typec_caps.data == TYPEC_PORT_DFP ? \
0549     TYPEC_HOST : TYPEC_DEVICE)
0550
0551 #define tcpm_sink_tx_ok(port) \
0552     (tcpm_port_is_sink(port) && \
0553     ((port)->cc1 == TYPEC_CC_RP_3_0 || (port)->cc2 == TYPEC_CC_RP_3_0))
0554
0555 #define tcpm_wait_for_discharge(port) \
0556     (((port)->auto_vbus_discharge_enabled && !(port)->vbus_vsafe0v) ? PD_T_SAFE_0V : 0)
0557
0558 static enum tcpm_state tcpm_default_state(struct tcpm_port *port)
0559 {
0560     if (port->port_type == TYPEC_PORT_DRP) {
0561         if (port->try_role == TYPEC_SINK)
0562             return SNK_UNATTACHED;
0563         else if (port->try_role == TYPEC_SOURCE)
0564             return SRC_UNATTACHED;
0565         /* Fall through to return SRC_UNATTACHED */
0566     } else if (port->port_type == TYPEC_PORT_SNK) {
0567         return SNK_UNATTACHED;
0568     }
0569     return SRC_UNATTACHED;
0570 }
0571
0572 static bool tcpm_port_is_disconnected(struct tcpm_port *port)
0573 {
0574     return (!port->attached && port->cc1 == TYPEC_CC_OPEN &&
0575         port->cc2 == TYPEC_CC_OPEN) ||
0576            (port->attached && ((port->polarity == TYPEC_POLARITY_CC1 &&
0577                     port->cc1 == TYPEC_CC_OPEN) ||
0578                    (port->polarity == TYPEC_POLARITY_CC2 &&
0579                     port->cc2 == TYPEC_CC_OPEN)));
0580 }
0581
0582 /*
0583  * Logging
0584  */
0585
0586 #ifdef CONFIG_DEBUG_FS
0587
0588 static bool tcpm_log_full(struct tcpm_port *port)
0589 {
0590     return port->logbuffer_tail ==
0591         (port->logbuffer_head + 1) % LOG_BUFFER_ENTRIES;
0592 }
0593
0594 __printf(2, 0)
0595 static void _tcpm_log(struct tcpm_port *port, const char *fmt, va_list args)
0596 {
0597     char tmpbuffer[LOG_BUFFER_ENTRY_SIZE];
0598     u64 ts_nsec = local_clock();
0599     unsigned long rem_nsec;
0600
0601     mutex_lock(&port->logbuffer_lock);
0602     if (!port->logbuffer[port->logbuffer_head]) {
0603         port->logbuffer[port->logbuffer_head] =
0604                 kzalloc(LOG_BUFFER_ENTRY_SIZE, GFP_KERNEL);
0605         if (!port->logbuffer[port->logbuffer_head]) {
0606             mutex_unlock(&port->logbuffer_lock);
0607             return;
0608         }
0609     }
0610
0611     vsnprintf(tmpbuffer, sizeof(tmpbuffer), fmt, args);
0612
0613     if (tcpm_log_full(port)) {
0614         port->logbuffer_head = max(port->logbuffer_head - 1, 0);
0615         strcpy(tmpbuffer, "overflow");
0616     }
0617
0618     if (port->logbuffer_head < 0 ||
0619         port->logbuffer_head >= LOG_BUFFER_ENTRIES) {
0620         dev_warn(port->dev,
0621              "Bad log buffer index %d\n", port->logbuffer_head);
0622         goto abort;
0623     }
0624
0625     if (!port->logbuffer[port->logbuffer_head]) {
0626         dev_warn(port->dev,
0627              "Log buffer index %d is NULL\n", port->logbuffer_head);
0628         goto abort;
0629     }
0630
0631     rem_nsec = do_div(ts_nsec, 1000000000);
0632     scnprintf(port->logbuffer[port->logbuffer_head],
0633           LOG_BUFFER_ENTRY_SIZE, "[%5lu.%06lu] %s",
0634           (unsigned long)ts_nsec, rem_nsec / 1000,
0635           tmpbuffer);
0636     port->logbuffer_head = (port->logbuffer_head + 1) % LOG_BUFFER_ENTRIES;
0637
0638 abort:
0639     mutex_unlock(&port->logbuffer_lock);
0640 }
0641
0642 __printf(2, 3)
0643 static void tcpm_log(struct tcpm_port *port, const char *fmt, ...)
0644 {
0645     va_list args;
0646
0647     /* Do not log while disconnected and unattached */
0648     if (tcpm_port_is_disconnected(port) &&
0649         (port->state == SRC_UNATTACHED || port->state == SNK_UNATTACHED ||
0650          port->state == TOGGLING))
0651         return;
0652
0653     va_start(args, fmt);
0654     _tcpm_log(port, fmt, args);
0655     va_end(args);
0656 }
0657
0658 __printf(2, 3)
0659 static void tcpm_log_force(struct tcpm_port *port, const char *fmt, ...)
0660 {
0661     va_list args;
0662
0663     va_start(args, fmt);
0664     _tcpm_log(port, fmt, args);
0665     va_end(args);
0666 }
0667
0668 static void tcpm_log_source_caps(struct tcpm_port *port)
0669 {
0670     int i;
0671
0672     for (i = 0; i < port->nr_source_caps; i++) {
0673         u32 pdo = port->source_caps[i];
0674         enum pd_pdo_type type = pdo_type(pdo);
0675         char msg[64];
0676
0677         switch (type) {
0678         case PDO_TYPE_FIXED:
0679             scnprintf(msg, sizeof(msg),
0680                   "%u mV, %u mA [%s%s%s%s%s%s]",
0681                   pdo_fixed_voltage(pdo),
0682                   pdo_max_current(pdo),
0683                   (pdo & PDO_FIXED_DUAL_ROLE) ?
0684                             "R" : "",
0685                   (pdo & PDO_FIXED_SUSPEND) ?
0686                             "S" : "",
0687                   (pdo & PDO_FIXED_HIGHER_CAP) ?
0688                             "H" : "",
0689                   (pdo & PDO_FIXED_USB_COMM) ?
0690                             "U" : "",
0691                   (pdo & PDO_FIXED_DATA_SWAP) ?
0692                             "D" : "",
0693                   (pdo & PDO_FIXED_EXTPOWER) ?
0694                             "E" : "");
0695             break;
0696         case PDO_TYPE_VAR:
0697             scnprintf(msg, sizeof(msg),
0698                   "%u-%u mV, %u mA",
0699                   pdo_min_voltage(pdo),
0700                   pdo_max_voltage(pdo),
0701                   pdo_max_current(pdo));
0702             break;
0703         case PDO_TYPE_BATT:
0704             scnprintf(msg, sizeof(msg),
0705                   "%u-%u mV, %u mW",
0706                   pdo_min_voltage(pdo),
0707                   pdo_max_voltage(pdo),
0708                   pdo_max_power(pdo));
0709             break;
0710         case PDO_TYPE_APDO:
0711             if (pdo_apdo_type(pdo) == APDO_TYPE_PPS)
0712                 scnprintf(msg, sizeof(msg),
0713                       "%u-%u mV, %u mA",
0714                       pdo_pps_apdo_min_voltage(pdo),
0715                       pdo_pps_apdo_max_voltage(pdo),
0716                       pdo_pps_apdo_max_current(pdo));
0717             else
0718                 strcpy(msg, "undefined APDO");
0719             break;
0720         default:
0721             strcpy(msg, "undefined");
0722             break;
0723         }
0724         tcpm_log(port, " PDO %d: type %d, %s",
0725              i, type, msg);
0726     }
0727 }
0728
0729 static int tcpm_debug_show(struct seq_file *s, void *v)
0730 {
0731     struct tcpm_port *port = (struct tcpm_port *)s->private;
0732     int tail;
0733
0734     mutex_lock(&port->logbuffer_lock);
0735     tail = port->logbuffer_tail;
0736     while (tail != port->logbuffer_head) {
0737         seq_printf(s, "%s\n", port->logbuffer[tail]);
0738         tail = (tail + 1) % LOG_BUFFER_ENTRIES;
0739     }
0740     if (!seq_has_overflowed(s))
0741         port->logbuffer_tail = tail;
0742     mutex_unlock(&port->logbuffer_lock);
0743
0744     return 0;
0745 }
0746 DEFINE_SHOW_ATTRIBUTE(tcpm_debug);
0747
0748 static void tcpm_debugfs_init(struct tcpm_port *port)
0749 {
0750     char name[NAME_MAX];
0751
0752     mutex_init(&port->logbuffer_lock);
0753     snprintf(name, NAME_MAX, "tcpm-%s", dev_name(port->dev));
0754     port->dentry = debugfs_create_dir(name, usb_debug_root);
0755     debugfs_create_file("log", S_IFREG | 0444, port->dentry, port,
0756                 &tcpm_debug_fops);
0757 }
0758
0759 static void tcpm_debugfs_exit(struct tcpm_port *port)
0760 {
0761     int i;
0762
0763     mutex_lock(&port->logbuffer_lock);
0764     for (i = 0; i < LOG_BUFFER_ENTRIES; i++) {
0765         kfree(port->logbuffer[i]);
0766         port->logbuffer[i] = NULL;
0767     }
0768     mutex_unlock(&port->logbuffer_lock);
0769
0770     debugfs_remove(port->dentry);
0771 }
0772
0773 #else
0774
0775 __printf(2, 3)
0776 static void tcpm_log(const struct tcpm_port *port, const char *fmt, ...) { }
0777 __printf(2, 3)
0778 static void tcpm_log_force(struct tcpm_port *port, const char *fmt, ...) { }
0779 static void tcpm_log_source_caps(struct tcpm_port *port) { }
0780 static void tcpm_debugfs_init(const struct tcpm_port *port) { }
0781 static void tcpm_debugfs_exit(const struct tcpm_port *port) { }
0782
0783 #endif
0784
0785 static void tcpm_set_cc(struct tcpm_port *port, enum typec_cc_status cc)
0786 {
0787     tcpm_log(port, "cc:=%d", cc);
0788     port->cc_req = cc;
0789     port->tcpc->set_cc(port->tcpc, cc);
0790 }
0791
0792 static int tcpm_enable_auto_vbus_discharge(struct tcpm_port *port, bool enable)
0793 {
0794     int ret = 0;
0795
0796     if (port->tcpc->enable_auto_vbus_discharge) {
0797         ret = port->tcpc->enable_auto_vbus_discharge(port->tcpc, enable);
0798         tcpm_log_force(port, "%s vbus discharge ret:%d", enable ? "enable" : "disable",
0799                    ret);
0800         if (!ret)
0801             port->auto_vbus_discharge_enabled = enable;
0802     }
0803
0804     return ret;
0805 }
0806
0807 static void tcpm_apply_rc(struct tcpm_port *port)
0808 {
0809     /*
0810      * TCPCI: Move to APPLY_RC state to prevent disconnect during PR_SWAP
0811      * when Vbus auto discharge on disconnect is enabled.
0812      */
0813     if (port->tcpc->enable_auto_vbus_discharge && port->tcpc->apply_rc) {
0814         tcpm_log(port, "Apply_RC");
0815         port->tcpc->apply_rc(port->tcpc, port->cc_req, port->polarity);
0816         tcpm_enable_auto_vbus_discharge(port, false);
0817     }
0818 }
0819
0820 /*
0821  * Determine RP value to set based on maximum current supported
0822  * by a port if configured as source.
0823  * Returns CC value to report to link partner.
0824  */
0825 static enum typec_cc_status tcpm_rp_cc(struct tcpm_port *port)
0826 {
0827     const u32 *src_pdo = port->src_pdo;
0828     int nr_pdo = port->nr_src_pdo;
0829     int i;
0830
0831     if (!port->pd_supported)
0832         return port->src_rp;
0833
0834     /*
0835      * Search for first entry with matching voltage.
0836      * It should report the maximum supported current.
0837      */
0838     for (i = 0; i < nr_pdo; i++) {
0839         const u32 pdo = src_pdo[i];
0840
0841         if (pdo_type(pdo) == PDO_TYPE_FIXED &&
0842             pdo_fixed_voltage(pdo) == 5000) {
0843             unsigned int curr = pdo_max_current(pdo);
0844
0845             if (curr >= 3000)
0846                 return TYPEC_CC_RP_3_0;
0847             else if (curr >= 1500)
0848                 return TYPEC_CC_RP_1_5;
0849             return TYPEC_CC_RP_DEF;
0850         }
0851     }
0852
0853     return TYPEC_CC_RP_DEF;
0854 }
0855
0856 static void tcpm_ams_finish(struct tcpm_port *port)
0857 {
0858     tcpm_log(port, "AMS %s finished", tcpm_ams_str[port->ams]);
0859
0860     if (port->pd_capable && port->pwr_role == TYPEC_SOURCE) {
0861         if (port->negotiated_rev >= PD_REV30)
0862             tcpm_set_cc(port, SINK_TX_OK);
0863         else
0864             tcpm_set_cc(port, SINK_TX_NG);
0865     } else if (port->pwr_role == TYPEC_SOURCE) {
0866         tcpm_set_cc(port, tcpm_rp_cc(port));
0867     }
0868
0869     port->in_ams = false;
0870     port->ams = NONE_AMS;
0871 }
0872
0873 static int tcpm_pd_transmit(struct tcpm_port *port,
0874                 enum tcpm_transmit_type type,
0875                 const struct pd_message *msg)
0876 {
0877     unsigned long timeout;
0878     int ret;
0879
0880     if (msg)
0881         tcpm_log(port, "PD TX, header: %#x", le16_to_cpu(msg->header));
0882     else
0883         tcpm_log(port, "PD TX, type: %#x", type);
0884
0885     reinit_completion(&port->tx_complete);
0886     ret = port->tcpc->pd_transmit(port->tcpc, type, msg, port->negotiated_rev);
0887     if (ret < 0)
0888         return ret;
0889
0890     mutex_unlock(&port->lock);
0891     timeout = wait_for_completion_timeout(&port->tx_complete,
0892                 msecs_to_jiffies(PD_T_TCPC_TX_TIMEOUT));
0893     mutex_lock(&port->lock);
0894     if (!timeout)
0895         return -ETIMEDOUT;
0896
0897     switch (port->tx_status) {
0898     case TCPC_TX_SUCCESS:
0899         port->message_id = (port->message_id + 1) & PD_HEADER_ID_MASK;
0900         /*
0901          * USB PD rev 2.0, 8.3.2.2.1:
0902          * USB PD rev 3.0, 8.3.2.1.3:
0903          * "... Note that every AMS is Interruptible until the first
0904          * Message in the sequence has been successfully sent (GoodCRC
0905          * Message received)."
0906          */
0907         if (port->ams != NONE_AMS)
0908             port->in_ams = true;
0909         break;
0910     case TCPC_TX_DISCARDED:
0911         ret = -EAGAIN;
0912         break;
0913     case TCPC_TX_FAILED:
0914     default:
0915         ret = -EIO;
0916         break;
0917     }
0918
0919     /* Some AMS don't expect responses. Finish them here. */
0920     if (port->ams == ATTENTION || port->ams == SOURCE_ALERT)
0921         tcpm_ams_finish(port);
0922
0923     return ret;
0924 }
0925
0926 void tcpm_pd_transmit_complete(struct tcpm_port *port,
0927                    enum tcpm_transmit_status status)
0928 {
0929     tcpm_log(port, "PD TX complete, status: %u", status);
0930     port->tx_status = status;
0931     complete(&port->tx_complete);
0932 }
0933 EXPORT_SYMBOL_GPL(tcpm_pd_transmit_complete);
0934
0935 static int tcpm_mux_set(struct tcpm_port *port, int state,
0936             enum usb_role usb_role,
0937             enum typec_orientation orientation)
0938 {
0939     int ret;
0940
0941     tcpm_log(port, "Requesting mux state %d, usb-role %d, orientation %d",
0942          state, usb_role, orientation);
0943
0944     ret = typec_set_orientation(port->typec_port, orientation);
0945     if (ret)
0946         return ret;
0947
0948     if (port->role_sw) {
0949         ret = usb_role_switch_set_role(port->role_sw, usb_role);
0950         if (ret)
0951             return ret;
0952     }
0953
0954     return typec_set_mode(port->typec_port, state);
0955 }
0956
0957 static int tcpm_set_polarity(struct tcpm_port *port,
0958                  enum typec_cc_polarity polarity)
0959 {
0960     int ret;
0961
0962     tcpm_log(port, "polarity %d", polarity);
0963
0964     ret = port->tcpc->set_polarity(port->tcpc, polarity);
0965     if (ret < 0)
0966         return ret;
0967
0968     port->polarity = polarity;
0969
0970     return 0;
0971 }
0972
0973 static int tcpm_set_vconn(struct tcpm_port *port, bool enable)
0974 {
0975     int ret;
0976
0977     tcpm_log(port, "vconn:=%d", enable);
0978
0979     ret = port->tcpc->set_vconn(port->tcpc, enable);
0980     if (!ret) {
0981         port->vconn_role = enable ? TYPEC_SOURCE : TYPEC_SINK;
0982         typec_set_vconn_role(port->typec_port, port->vconn_role);
0983     }
0984
0985     return ret;
0986 }
0987
0988 static u32 tcpm_get_current_limit(struct tcpm_port *port)
0989 {
0990     enum typec_cc_status cc;
0991     u32 limit;
0992
0993     cc = port->polarity ? port->cc2 : port->cc1;
0994     switch (cc) {
0995     case TYPEC_CC_RP_1_5:
0996         limit = 1500;
0997         break;
0998     case TYPEC_CC_RP_3_0:
0999         limit = 3000;
1000         break;
1001     case TYPEC_CC_RP_DEF:
1002     default:
1003         if (port->tcpc->get_current_limit)
1004             limit = port->tcpc->get_current_limit(port->tcpc);
1005         else
1006             limit = 0;
1007         break;
1008     }
1009
1010     return limit;
1011 }
1012
1013 static int tcpm_set_current_limit(struct tcpm_port *port, u32 max_ma, u32 mv)
1014 {
1015     int ret = -EOPNOTSUPP;
1016
1017     tcpm_log(port, "Setting voltage/current limit %u mV %u mA", mv, max_ma);
1018
1019     port->supply_voltage = mv;
1020     port->current_limit = max_ma;
1021     power_supply_changed(port->psy);
1022
1023     if (port->tcpc->set_current_limit)
1024         ret = port->tcpc->set_current_limit(port->tcpc, max_ma, mv);
1025
1026     return ret;
1027 }
1028
1029 static int tcpm_set_attached_state(struct tcpm_port *port, bool attached)
1030 {
1031     return port->tcpc->set_roles(port->tcpc, attached, port->pwr_role,
1032                      port->data_role);
1033 }
1034
1035 static int tcpm_set_roles(struct tcpm_port *port, bool attached,
1036               enum typec_role role, enum typec_data_role data)
1037 {
1038     enum typec_orientation orientation;
1039     enum usb_role usb_role;
1040     int ret;
1041
1042     if (port->polarity == TYPEC_POLARITY_CC1)
1043         orientation = TYPEC_ORIENTATION_NORMAL;
1044     else
1045         orientation = TYPEC_ORIENTATION_REVERSE;
1046
1047     if (port->typec_caps.data == TYPEC_PORT_DRD) {
1048         if (data == TYPEC_HOST)
1049             usb_role = USB_ROLE_HOST;
1050         else
1051             usb_role = USB_ROLE_DEVICE;
1052     } else if (port->typec_caps.data == TYPEC_PORT_DFP) {
1053         if (data == TYPEC_HOST) {
1054             if (role == TYPEC_SOURCE)
1055                 usb_role = USB_ROLE_HOST;
1056             else
1057                 usb_role = USB_ROLE_NONE;
1058         } else {
1059             return -ENOTSUPP;
1060         }
1061     } else {
1062         if (data == TYPEC_DEVICE) {
1063             if (role == TYPEC_SINK)
1064                 usb_role = USB_ROLE_DEVICE;
1065             else
1066                 usb_role = USB_ROLE_NONE;
1067         } else {
1068             return -ENOTSUPP;
1069         }
1070     }
1071
1072     ret = tcpm_mux_set(port, TYPEC_STATE_USB, usb_role, orientation);
1073     if (ret < 0)
1074         return ret;
1075
1076     ret = port->tcpc->set_roles(port->tcpc, attached, role, data);
1077     if (ret < 0)
1078         return ret;
1079
1080     port->pwr_role = role;
1081     port->data_role = data;
1082     typec_set_data_role(port->typec_port, data);
1083     typec_set_pwr_role(port->typec_port, role);
1084
1085     return 0;
1086 }
1087
1088 static int tcpm_set_pwr_role(struct tcpm_port *port, enum typec_role role)
1089 {
1090     int ret;
1091
1092     ret = port->tcpc->set_roles(port->tcpc, true, role,
1093                     port->data_role);
1094     if (ret < 0)
1095         return ret;
1096
1097     port->pwr_role = role;
1098     typec_set_pwr_role(port->typec_port, role);
1099
1100     return 0;
1101 }
1102
1103 /*
1104  * Transform the PDO to be compliant to PD rev2.0.
1105  * Return 0 if the PDO type is not defined in PD rev2.0.
1106  * Otherwise, return the converted PDO.
1107  */
1108 static u32 tcpm_forge_legacy_pdo(struct tcpm_port *port, u32 pdo, enum typec_role role)
1109 {
1110     switch (pdo_type(pdo)) {
1111     case PDO_TYPE_FIXED:
1112         if (role == TYPEC_SINK)
1113             return pdo & ~PDO_FIXED_FRS_CURR_MASK;
1114         else
1115             return pdo & ~PDO_FIXED_UNCHUNK_EXT;
1116     case PDO_TYPE_VAR:
1117     case PDO_TYPE_BATT:
1118         return pdo;
1119     case PDO_TYPE_APDO:
1120     default:
1121         return 0;
1122     }
1123 }
1124
1125 static int tcpm_pd_send_source_caps(struct tcpm_port *port)
1126 {
1127     struct pd_message msg;
1128     u32 pdo;
1129     unsigned int i, nr_pdo = 0;
1130
1131     memset(&msg, 0, sizeof(msg));
1132
1133     for (i = 0; i < port->nr_src_pdo; i++) {
1134         if (port->negotiated_rev >= PD_REV30) {
1135             msg.payload[nr_pdo++] = cpu_to_le32(port->src_pdo[i]);
1136         } else {
1137             pdo = tcpm_forge_legacy_pdo(port, port->src_pdo[i], TYPEC_SOURCE);
1138             if (pdo)
1139                 msg.payload[nr_pdo++] = cpu_to_le32(pdo);
1140         }
1141     }
1142
1143     if (!nr_pdo) {
1144         /* No source capabilities defined, sink only */
1145         msg.header = PD_HEADER_LE(PD_CTRL_REJECT,
1146                       port->pwr_role,
1147                       port->data_role,
1148                       port->negotiated_rev,
1149                       port->message_id, 0);
1150     } else {
1151         msg.header = PD_HEADER_LE(PD_DATA_SOURCE_CAP,
1152                       port->pwr_role,
1153                       port->data_role,
1154                       port->negotiated_rev,
1155                       port->message_id,
1156                       nr_pdo);
1157     }
1158
1159     return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
1160 }
1161
1162 static int tcpm_pd_send_sink_caps(struct tcpm_port *port)
1163 {
1164     struct pd_message msg;
1165     u32 pdo;
1166     unsigned int i, nr_pdo = 0;
1167
1168     memset(&msg, 0, sizeof(msg));
1169
1170     for (i = 0; i < port->nr_snk_pdo; i++) {
1171         if (port->negotiated_rev >= PD_REV30) {
1172             msg.payload[nr_pdo++] = cpu_to_le32(port->snk_pdo[i]);
1173         } else {
1174             pdo = tcpm_forge_legacy_pdo(port, port->snk_pdo[i], TYPEC_SINK);
1175             if (pdo)
1176                 msg.payload[nr_pdo++] = cpu_to_le32(pdo);
1177         }
1178     }
1179
1180     if (!nr_pdo) {
1181         /* No sink capabilities defined, source only */
1182         msg.header = PD_HEADER_LE(PD_CTRL_REJECT,
1183                       port->pwr_role,
1184                       port->data_role,
1185                       port->negotiated_rev,
1186                       port->message_id, 0);
1187     } else {
1188         msg.header = PD_HEADER_LE(PD_DATA_SINK_CAP,
1189                       port->pwr_role,
1190                       port->data_role,
1191                       port->negotiated_rev,
1192                       port->message_id,
1193                       nr_pdo);
1194     }
1195
1196     return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
1197 }
1198
1199 static void mod_tcpm_delayed_work(struct tcpm_port *port, unsigned int delay_ms)
1200 {
1201     if (delay_ms) {
1202         hrtimer_start(&port->state_machine_timer, ms_to_ktime(delay_ms), HRTIMER_MODE_REL);
1203     } else {
1204         hrtimer_cancel(&port->state_machine_timer);
1205         kthread_queue_work(port->wq, &port->state_machine);
1206     }
1207 }
1208
1209 static void mod_vdm_delayed_work(struct tcpm_port *port, unsigned int delay_ms)
1210 {
1211     if (delay_ms) {
1212         hrtimer_start(&port->vdm_state_machine_timer, ms_to_ktime(delay_ms),
1213                   HRTIMER_MODE_REL);
1214     } else {
1215         hrtimer_cancel(&port->vdm_state_machine_timer);
1216         kthread_queue_work(port->wq, &port->vdm_state_machine);
1217     }
1218 }
1219
1220 static void mod_enable_frs_delayed_work(struct tcpm_port *port, unsigned int delay_ms)
1221 {
1222     if (delay_ms) {
1223         hrtimer_start(&port->enable_frs_timer, ms_to_ktime(delay_ms), HRTIMER_MODE_REL);
1224     } else {
1225         hrtimer_cancel(&port->enable_frs_timer);
1226         kthread_queue_work(port->wq, &port->enable_frs);
1227     }
1228 }
1229
1230 static void mod_send_discover_delayed_work(struct tcpm_port *port, unsigned int delay_ms)
1231 {
1232     if (delay_ms) {
1233         hrtimer_start(&port->send_discover_timer, ms_to_ktime(delay_ms), HRTIMER_MODE_REL);
1234     } else {
1235         hrtimer_cancel(&port->send_discover_timer);
1236         kthread_queue_work(port->wq, &port->send_discover_work);
1237     }
1238 }
1239
1240 static void tcpm_set_state(struct tcpm_port *port, enum tcpm_state state,
1241                unsigned int delay_ms)
1242 {
1243     if (delay_ms) {
1244         tcpm_log(port, "pending state change %s -> %s @ %u ms [%s %s]",
1245              tcpm_states[port->state], tcpm_states[state], delay_ms,
1246              pd_rev[port->negotiated_rev], tcpm_ams_str[port->ams]);
1247         port->delayed_state = state;
1248         mod_tcpm_delayed_work(port, delay_ms);
1249         port->delayed_runtime = ktime_add(ktime_get(), ms_to_ktime(delay_ms));
1250         port->delay_ms = delay_ms;
1251     } else {
1252         tcpm_log(port, "state change %s -> %s [%s %s]",
1253              tcpm_states[port->state], tcpm_states[state],
1254              pd_rev[port->negotiated_rev], tcpm_ams_str[port->ams]);
1255         port->delayed_state = INVALID_STATE;
1256         port->prev_state = port->state;
1257         port->state = state;
1258         /*
1259          * Don't re-queue the state machine work item if we're currently
1260          * in the state machine and we're immediately changing states.
1261          * tcpm_state_machine_work() will continue running the state
1262          * machine.
1263          */
1264         if (!port->state_machine_running)
1265             mod_tcpm_delayed_work(port, 0);
1266     }
1267 }
1268
1269 static void tcpm_set_state_cond(struct tcpm_port *port, enum tcpm_state state,
1270                 unsigned int delay_ms)
1271 {
1272     if (port->enter_state == port->state)
1273         tcpm_set_state(port, state, delay_ms);
1274     else
1275         tcpm_log(port,
1276              "skipped %sstate change %s -> %s [%u ms], context state %s [%s %s]",
1277              delay_ms ? "delayed " : "",
1278              tcpm_states[port->state], tcpm_states[state],
1279              delay_ms, tcpm_states[port->enter_state],
1280              pd_rev[port->negotiated_rev], tcpm_ams_str[port->ams]);
1281 }
1282
1283 static void tcpm_queue_message(struct tcpm_port *port,
1284                    enum pd_msg_request message)
1285 {
1286     port->queued_message = message;
1287     mod_tcpm_delayed_work(port, 0);
1288 }
1289
1290 static bool tcpm_vdm_ams(struct tcpm_port *port)
1291 {
1292     switch (port->ams) {
1293     case DISCOVER_IDENTITY:
1294     case SOURCE_STARTUP_CABLE_PLUG_DISCOVER_IDENTITY:
1295     case DISCOVER_SVIDS:
1296     case DISCOVER_MODES:
1297     case DFP_TO_UFP_ENTER_MODE:
1298     case DFP_TO_UFP_EXIT_MODE:
1299     case DFP_TO_CABLE_PLUG_ENTER_MODE:
1300     case DFP_TO_CABLE_PLUG_EXIT_MODE:
1301     case ATTENTION:
1302     case UNSTRUCTURED_VDMS:
1303     case STRUCTURED_VDMS:
1304         break;
1305     default:
1306         return false;
1307     }
1308
1309     return true;
1310 }
1311
1312 static bool tcpm_ams_interruptible(struct tcpm_port *port)
1313 {
1314     switch (port->ams) {
1315     /* Interruptible AMS */
1316     case NONE_AMS:
1317     case SECURITY:
1318     case FIRMWARE_UPDATE:
1319     case DISCOVER_IDENTITY:
1320     case SOURCE_STARTUP_CABLE_PLUG_DISCOVER_IDENTITY:
1321     case DISCOVER_SVIDS:
1322     case DISCOVER_MODES:
1323     case DFP_TO_UFP_ENTER_MODE:
1324     case DFP_TO_UFP_EXIT_MODE:
1325     case DFP_TO_CABLE_PLUG_ENTER_MODE:
1326     case DFP_TO_CABLE_PLUG_EXIT_MODE:
1327     case UNSTRUCTURED_VDMS:
1328     case STRUCTURED_VDMS:
1329     case COUNTRY_INFO:
1330     case COUNTRY_CODES:
1331         break;
1332     /* Non-Interruptible AMS */
1333     default:
1334         if (port->in_ams)
1335             return false;
1336         break;
1337     }
1338
1339     return true;
1340 }
1341
1342 static int tcpm_ams_start(struct tcpm_port *port, enum tcpm_ams ams)
1343 {
1344     int ret = 0;
1345
1346     tcpm_log(port, "AMS %s start", tcpm_ams_str[ams]);
1347
1348     if (!tcpm_ams_interruptible(port) &&
1349         !(ams == HARD_RESET || ams == SOFT_RESET_AMS)) {
1350         port->upcoming_state = INVALID_STATE;
1351         tcpm_log(port, "AMS %s not interruptible, aborting",
1352              tcpm_ams_str[port->ams]);
1353         return -EAGAIN;
1354     }
1355
1356     if (port->pwr_role == TYPEC_SOURCE) {
1357         enum typec_cc_status cc_req = port->cc_req;
1358
1359         port->ams = ams;
1360
1361         if (ams == HARD_RESET) {
1362             tcpm_set_cc(port, tcpm_rp_cc(port));
1363             tcpm_pd_transmit(port, TCPC_TX_HARD_RESET, NULL);
1364             tcpm_set_state(port, HARD_RESET_START, 0);
1365             return ret;
1366         } else if (ams == SOFT_RESET_AMS) {
1367             if (!port->explicit_contract)
1368                 tcpm_set_cc(port, tcpm_rp_cc(port));
1369             tcpm_set_state(port, SOFT_RESET_SEND, 0);
1370             return ret;
1371         } else if (tcpm_vdm_ams(port)) {
1372             /* tSinkTx is enforced in vdm_run_state_machine */
1373             if (port->negotiated_rev >= PD_REV30)
1374                 tcpm_set_cc(port, SINK_TX_NG);
1375             return ret;
1376         }
1377
1378         if (port->negotiated_rev >= PD_REV30)
1379             tcpm_set_cc(port, SINK_TX_NG);
1380
1381         switch (port->state) {
1382         case SRC_READY:
1383         case SRC_STARTUP:
1384         case SRC_SOFT_RESET_WAIT_SNK_TX:
1385         case SOFT_RESET:
1386         case SOFT_RESET_SEND:
1387             if (port->negotiated_rev >= PD_REV30)
1388                 tcpm_set_state(port, AMS_START,
1389                            cc_req == SINK_TX_OK ?
1390                            PD_T_SINK_TX : 0);
1391             else
1392                 tcpm_set_state(port, AMS_START, 0);
1393             break;
1394         default:
1395             if (port->negotiated_rev >= PD_REV30)
1396                 tcpm_set_state(port, SRC_READY,
1397                            cc_req == SINK_TX_OK ?
1398                            PD_T_SINK_TX : 0);
1399             else
1400                 tcpm_set_state(port, SRC_READY, 0);
1401             break;
1402         }
1403     } else {
1404         if (port->negotiated_rev >= PD_REV30 &&
1405             !tcpm_sink_tx_ok(port) &&
1406             ams != SOFT_RESET_AMS &&
1407             ams != HARD_RESET) {
1408             port->upcoming_state = INVALID_STATE;
1409             tcpm_log(port, "Sink TX No Go");
1410             return -EAGAIN;
1411         }
1412
1413         port->ams = ams;
1414
1415         if (ams == HARD_RESET) {
1416             tcpm_pd_transmit(port, TCPC_TX_HARD_RESET, NULL);
1417             tcpm_set_state(port, HARD_RESET_START, 0);
1418             return ret;
1419         } else if (tcpm_vdm_ams(port)) {
1420             return ret;
1421         }
1422
1423         if (port->state == SNK_READY ||
1424             port->state == SNK_SOFT_RESET)
1425             tcpm_set_state(port, AMS_START, 0);
1426         else
1427             tcpm_set_state(port, SNK_READY, 0);
1428     }
1429
1430     return ret;
1431 }
1432
1433 /*
1434  * VDM/VDO handling functions
1435  */
1436 static void tcpm_queue_vdm(struct tcpm_port *port, const u32 header,
1437                const u32 *data, int cnt)
1438 {
1439     WARN_ON(!mutex_is_locked(&port->lock));
1440
1441     /* Make sure we are not still processing a previous VDM packet */
1442     WARN_ON(port->vdm_state > VDM_STATE_DONE);
1443
1444     port->vdo_count = cnt + 1;
1445     port->vdo_data[0] = header;
1446     memcpy(&port->vdo_data[1], data, sizeof(u32) * cnt);
1447     /* Set ready, vdm state machine will actually send */
1448     port->vdm_retries = 0;
1449     port->vdm_state = VDM_STATE_READY;
1450     port->vdm_sm_running = true;
1451
1452     mod_vdm_delayed_work(port, 0);
1453 }
1454
1455 static void tcpm_queue_vdm_unlocked(struct tcpm_port *port, const u32 header,
1456                     const u32 *data, int cnt)
1457 {
1458     mutex_lock(&port->lock);
1459     tcpm_queue_vdm(port, header, data, cnt);
1460     mutex_unlock(&port->lock);
1461 }
1462
1463 static void svdm_consume_identity(struct tcpm_port *port, const u32 *p, int cnt)
1464 {
1465     u32 vdo = p[VDO_INDEX_IDH];
1466     u32 product = p[VDO_INDEX_PRODUCT];
1467
1468     memset(&port->mode_data, 0, sizeof(port->mode_data));
1469
1470     port->partner_ident.id_header = vdo;
1471     port->partner_ident.cert_stat = p[VDO_INDEX_CSTAT];
1472     port->partner_ident.product = product;
1473
1474     typec_partner_set_identity(port->partner);
1475
1476     tcpm_log(port, "Identity: %04x:%04x.%04x",
1477          PD_IDH_VID(vdo),
1478          PD_PRODUCT_PID(product), product & 0xffff);
1479 }
1480
1481 static bool svdm_consume_svids(struct tcpm_port *port, const u32 *p, int cnt)
1482 {
1483     struct pd_mode_data *pmdata = &port->mode_data;
1484     int i;
1485
1486     for (i = 1; i < cnt; i++) {
1487         u16 svid;
1488
1489         svid = (p[i] >> 16) & 0xffff;
1490         if (!svid)
1491             return false;
1492
1493         if (pmdata->nsvids >= SVID_DISCOVERY_MAX)
1494             goto abort;
1495
1496         pmdata->svids[pmdata->nsvids++] = svid;
1497         tcpm_log(port, "SVID %d: 0x%x", pmdata->nsvids, svid);
1498
1499         svid = p[i] & 0xffff;
1500         if (!svid)
1501             return false;
1502
1503         if (pmdata->nsvids >= SVID_DISCOVERY_MAX)
1504             goto abort;
1505
1506         pmdata->svids[pmdata->nsvids++] = svid;
1507         tcpm_log(port, "SVID %d: 0x%x", pmdata->nsvids, svid);
1508     }
1509     return true;
1510 abort:
1511     tcpm_log(port, "SVID_DISCOVERY_MAX(%d) too low!", SVID_DISCOVERY_MAX);
1512     return false;
1513 }
1514
1515 static void svdm_consume_modes(struct tcpm_port *port, const u32 *p, int cnt)
1516 {
1517     struct pd_mode_data *pmdata = &port->mode_data;
1518     struct typec_altmode_desc *paltmode;
1519     int i;
1520
1521     if (pmdata->altmodes >= ARRAY_SIZE(port->partner_altmode)) {
1522         /* Already logged in svdm_consume_svids() */
1523         return;
1524     }
1525
1526     for (i = 1; i < cnt; i++) {
1527         paltmode = &pmdata->altmode_desc[pmdata->altmodes];
1528         memset(paltmode, 0, sizeof(*paltmode));
1529
1530         paltmode->svid = pmdata->svids[pmdata->svid_index];
1531         paltmode->mode = i;
1532         paltmode->vdo = p[i];
1533
1534         tcpm_log(port, " Alternate mode %d: SVID 0x%04x, VDO %d: 0x%08x",
1535              pmdata->altmodes, paltmode->svid,
1536              paltmode->mode, paltmode->vdo);
1537
1538         pmdata->altmodes++;
1539     }
1540 }
1541
1542 static void tcpm_register_partner_altmodes(struct tcpm_port *port)
1543 {
1544     struct pd_mode_data *modep = &port->mode_data;
1545     struct typec_altmode *altmode;
1546     int i;
1547
1548     for (i = 0; i < modep->altmodes; i++) {
1549         altmode = typec_partner_register_altmode(port->partner,
1550                         &modep->altmode_desc[i]);
1551         if (IS_ERR(altmode)) {
1552             tcpm_log(port, "Failed to register partner SVID 0x%04x",
1553                  modep->altmode_desc[i].svid);
1554             altmode = NULL;
1555         }
1556         port->partner_altmode[i] = altmode;
1557     }
1558 }
1559
1560 #define supports_modal(port)    PD_IDH_MODAL_SUPP((port)->partner_ident.id_header)
1561
1562 static int tcpm_pd_svdm(struct tcpm_port *port, struct typec_altmode *adev,
1563             const u32 *p, int cnt, u32 *response,
1564             enum adev_actions *adev_action)
1565 {
1566     struct typec_port *typec = port->typec_port;
1567     struct typec_altmode *pdev;
1568     struct pd_mode_data *modep;
1569     int svdm_version;
1570     int rlen = 0;
1571     int cmd_type;
1572     int cmd;
1573     int i;
1574
1575     cmd_type = PD_VDO_CMDT(p[0]);
1576     cmd = PD_VDO_CMD(p[0]);
1577
1578     tcpm_log(port, "Rx VDM cmd 0x%x type %d cmd %d len %d",
1579          p[0], cmd_type, cmd, cnt);
1580
1581     modep = &port->mode_data;
1582
1583     pdev = typec_match_altmode(port->partner_altmode, ALTMODE_DISCOVERY_MAX,
1584                    PD_VDO_VID(p[0]), PD_VDO_OPOS(p[0]));
1585
1586     svdm_version = typec_get_negotiated_svdm_version(typec);
1587     if (svdm_version < 0)
1588         return 0;
1589
1590     switch (cmd_type) {
1591     case CMDT_INIT:
1592         switch (cmd) {
1593         case CMD_DISCOVER_IDENT:
1594             if (PD_VDO_VID(p[0]) != USB_SID_PD)
1595                 break;
1596
1597             if (PD_VDO_SVDM_VER(p[0]) < svdm_version) {
1598                 typec_partner_set_svdm_version(port->partner,
1599                                    PD_VDO_SVDM_VER(p[0]));
1600                 svdm_version = PD_VDO_SVDM_VER(p[0]);
1601             }
1602
1603             port->ams = DISCOVER_IDENTITY;
1604             /*
1605              * PD2.0 Spec 6.10.3: respond with NAK as DFP (data host)
1606              * PD3.1 Spec 6.4.4.2.5.1: respond with NAK if "invalid field" or
1607              * "wrong configuation" or "Unrecognized"
1608              */
1609             if ((port->data_role == TYPEC_DEVICE || svdm_version >= SVDM_VER_2_0) &&
1610                 port->nr_snk_vdo) {
1611                 if (svdm_version < SVDM_VER_2_0) {
1612                     for (i = 0; i < port->nr_snk_vdo_v1; i++)
1613                         response[i + 1] = port->snk_vdo_v1[i];
1614                     rlen = port->nr_snk_vdo_v1 + 1;
1615
1616                 } else {
1617                     for (i = 0; i < port->nr_snk_vdo; i++)
1618                         response[i + 1] = port->snk_vdo[i];
1619                     rlen = port->nr_snk_vdo + 1;
1620                 }
1621             }
1622             break;
1623         case CMD_DISCOVER_SVID:
1624             port->ams = DISCOVER_SVIDS;
1625             break;
1626         case CMD_DISCOVER_MODES:
1627             port->ams = DISCOVER_MODES;
1628             break;
1629         case CMD_ENTER_MODE:
1630             port->ams = DFP_TO_UFP_ENTER_MODE;
1631             break;
1632         case CMD_EXIT_MODE:
1633             port->ams = DFP_TO_UFP_EXIT_MODE;
1634             break;
1635         case CMD_ATTENTION:
1636             /* Attention command does not have response */
1637             *adev_action = ADEV_ATTENTION;
1638             return 0;
1639         default:
1640             break;
1641         }
1642         if (rlen >= 1) {
1643             response[0] = p[0] | VDO_CMDT(CMDT_RSP_ACK);
1644         } else if (rlen == 0) {
1645             response[0] = p[0] | VDO_CMDT(CMDT_RSP_NAK);
1646             rlen = 1;
1647         } else {
1648             response[0] = p[0] | VDO_CMDT(CMDT_RSP_BUSY);
1649             rlen = 1;
1650         }
1651         response[0] = (response[0] & ~VDO_SVDM_VERS_MASK) |
1652                   (VDO_SVDM_VERS(typec_get_negotiated_svdm_version(typec)));
1653         break;
1654     case CMDT_RSP_ACK:
1655         /* silently drop message if we are not connected */
1656         if (IS_ERR_OR_NULL(port->partner))
1657             break;
1658
1659         tcpm_ams_finish(port);
1660
1661         switch (cmd) {
1662         case CMD_DISCOVER_IDENT:
1663             if (PD_VDO_SVDM_VER(p[0]) < svdm_version)
1664                 typec_partner_set_svdm_version(port->partner,
1665                                    PD_VDO_SVDM_VER(p[0]));
1666             /* 6.4.4.3.1 */
1667             svdm_consume_identity(port, p, cnt);
1668             response[0] = VDO(USB_SID_PD, 1, typec_get_negotiated_svdm_version(typec),
1669                       CMD_DISCOVER_SVID);
1670             rlen = 1;
1671             break;
1672         case CMD_DISCOVER_SVID:
1673             /* 6.4.4.3.2 */
1674             if (svdm_consume_svids(port, p, cnt)) {
1675                 response[0] = VDO(USB_SID_PD, 1, svdm_version, CMD_DISCOVER_SVID);
1676                 rlen = 1;
1677             } else if (modep->nsvids && supports_modal(port)) {
1678                 response[0] = VDO(modep->svids[0], 1, svdm_version,
1679                           CMD_DISCOVER_MODES);
1680                 rlen = 1;
1681             }
1682             break;
1683         case CMD_DISCOVER_MODES:
1684             /* 6.4.4.3.3 */
1685             svdm_consume_modes(port, p, cnt);
1686             modep->svid_index++;
1687             if (modep->svid_index < modep->nsvids) {
1688                 u16 svid = modep->svids[modep->svid_index];
1689                 response[0] = VDO(svid, 1, svdm_version, CMD_DISCOVER_MODES);
1690                 rlen = 1;
1691             } else {
1692                 tcpm_register_partner_altmodes(port);
1693             }
1694             break;
1695         case CMD_ENTER_MODE:
1696             if (adev && pdev) {
1697                 typec_altmode_update_active(pdev, true);
1698                 *adev_action = ADEV_QUEUE_VDM_SEND_EXIT_MODE_ON_FAIL;
1699             }
1700             return 0;
1701         case CMD_EXIT_MODE:
1702             if (adev && pdev) {
1703                 typec_altmode_update_active(pdev, false);
1704                 /* Back to USB Operation */
1705                 *adev_action = ADEV_NOTIFY_USB_AND_QUEUE_VDM;
1706                 return 0;
1707             }
1708             break;
1709         case VDO_CMD_VENDOR(0) ... VDO_CMD_VENDOR(15):
1710             break;
1711         default:
1712             /* Unrecognized SVDM */
1713             response[0] = p[0] | VDO_CMDT(CMDT_RSP_NAK);
1714             rlen = 1;
1715             response[0] = (response[0] & ~VDO_SVDM_VERS_MASK) |
1716                       (VDO_SVDM_VERS(svdm_version));
1717             break;
1718         }
1719         break;
1720     case CMDT_RSP_NAK:
1721         tcpm_ams_finish(port);
1722         switch (cmd) {
1723         case CMD_DISCOVER_IDENT:
1724         case CMD_DISCOVER_SVID:
1725         case CMD_DISCOVER_MODES:
1726         case VDO_CMD_VENDOR(0) ... VDO_CMD_VENDOR(15):
1727             break;
1728         case CMD_ENTER_MODE:
1729             /* Back to USB Operation */
1730             *adev_action = ADEV_NOTIFY_USB_AND_QUEUE_VDM;
1731             return 0;
1732         default:
1733             /* Unrecognized SVDM */
1734             response[0] = p[0] | VDO_CMDT(CMDT_RSP_NAK);
1735             rlen = 1;
1736             response[0] = (response[0] & ~VDO_SVDM_VERS_MASK) |
1737                       (VDO_SVDM_VERS(svdm_version));
1738             break;
1739         }
1740         break;
1741     default:
1742         response[0] = p[0] | VDO_CMDT(CMDT_RSP_NAK);
1743         rlen = 1;
1744         response[0] = (response[0] & ~VDO_SVDM_VERS_MASK) |
1745                   (VDO_SVDM_VERS(svdm_version));
1746         break;
1747     }
1748
1749     /* Informing the alternate mode drivers about everything */
1750     *adev_action = ADEV_QUEUE_VDM;
1751     return rlen;
1752 }
1753
1754 static void tcpm_pd_handle_msg(struct tcpm_port *port,
1755                    enum pd_msg_request message,
1756                    enum tcpm_ams ams);
1757
1758 static void tcpm_handle_vdm_request(struct tcpm_port *port,
1759                     const __le32 *payload, int cnt)
1760 {
1761     enum adev_actions adev_action = ADEV_NONE;
1762     struct typec_altmode *adev;
1763     u32 p[PD_MAX_PAYLOAD];
1764     u32 response[8] = { };
1765     int i, rlen = 0;
1766
1767     for (i = 0; i < cnt; i++)
1768         p[i] = le32_to_cpu(payload[i]);
1769
1770     adev = typec_match_altmode(port->port_altmode, ALTMODE_DISCOVERY_MAX,
1771                    PD_VDO_VID(p[0]), PD_VDO_OPOS(p[0]));
1772
1773     if (port->vdm_state == VDM_STATE_BUSY) {
1774         /* If UFP responded busy retry after timeout */
1775         if (PD_VDO_CMDT(p[0]) == CMDT_RSP_BUSY) {
1776             port->vdm_state = VDM_STATE_WAIT_RSP_BUSY;
1777             port->vdo_retry = (p[0] & ~VDO_CMDT_MASK) |
1778                 CMDT_INIT;
1779             mod_vdm_delayed_work(port, PD_T_VDM_BUSY);
1780             return;
1781         }
1782         port->vdm_state = VDM_STATE_DONE;
1783     }
1784
1785     if (PD_VDO_SVDM(p[0]) && (adev || tcpm_vdm_ams(port) || port->nr_snk_vdo)) {
1786         /*
1787          * Here a SVDM is received (INIT or RSP or unknown). Set the vdm_sm_running in
1788          * advance because we are dropping the lock but may send VDMs soon.
1789          * For the cases of INIT received:
1790          *  - If no response to send, it will be cleared later in this function.
1791          *  - If there are responses to send, it will be cleared in the state machine.
1792          * For the cases of RSP received:
1793          *  - If no further INIT to send, it will be cleared later in this function.
1794          *  - Otherwise, it will be cleared in the state machine if timeout or it will go
1795          *    back here until no further INIT to send.
1796          * For the cases of unknown type received:
1797          *  - We will send NAK and the flag will be cleared in the state machine.
1798          */
1799         port->vdm_sm_running = true;
1800         rlen = tcpm_pd_svdm(port, adev, p, cnt, response, &adev_action);
1801     } else {
1802         if (port->negotiated_rev >= PD_REV30)
1803             tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS);
1804     }
1805
1806     /*
1807      * We are done with any state stored in the port struct now, except
1808      * for any port struct changes done by the tcpm_queue_vdm() call
1809      * below, which is a separate operation.
1810      *
1811      * So we can safely release the lock here; and we MUST release the
1812      * lock here to avoid an AB BA lock inversion:
1813      *
1814      * If we keep the lock here then the lock ordering in this path is:
1815      * 1. tcpm_pd_rx_handler take the tcpm port lock
1816      * 2. One of the typec_altmode_* calls below takes the alt-mode's lock
1817      *
1818      * And we also have this ordering:
1819      * 1. alt-mode driver takes the alt-mode's lock
1820      * 2. alt-mode driver calls tcpm_altmode_enter which takes the
1821      *    tcpm port lock
1822      *
1823      * Dropping our lock here avoids this.
1824      */
1825     mutex_unlock(&port->lock);
1826
1827     if (adev) {
1828         switch (adev_action) {
1829         case ADEV_NONE:
1830             break;
1831         case ADEV_NOTIFY_USB_AND_QUEUE_VDM:
1832             WARN_ON(typec_altmode_notify(adev, TYPEC_STATE_USB, NULL));
1833             typec_altmode_vdm(adev, p[0], &p[1], cnt);
1834             break;
1835         case ADEV_QUEUE_VDM:
1836             typec_altmode_vdm(adev, p[0], &p[1], cnt);
1837             break;
1838         case ADEV_QUEUE_VDM_SEND_EXIT_MODE_ON_FAIL:
1839             if (typec_altmode_vdm(adev, p[0], &p[1], cnt)) {
1840                 int svdm_version = typec_get_negotiated_svdm_version(
1841                                     port->typec_port);
1842                 if (svdm_version < 0)
1843                     break;
1844
1845                 response[0] = VDO(adev->svid, 1, svdm_version,
1846                           CMD_EXIT_MODE);
1847                 response[0] |= VDO_OPOS(adev->mode);
1848                 rlen = 1;
1849             }
1850             break;
1851         case ADEV_ATTENTION:
1852             typec_altmode_attention(adev, p[1]);
1853             break;
1854         }
1855     }
1856
1857     /*
1858      * We must re-take the lock here to balance the unlock in
1859      * tcpm_pd_rx_handler, note that no changes, other then the
1860      * tcpm_queue_vdm call, are made while the lock is held again.
1861      * All that is done after the call is unwinding the call stack until
1862      * we return to tcpm_pd_rx_handler and do the unlock there.
1863      */
1864     mutex_lock(&port->lock);
1865
1866     if (rlen > 0)
1867         tcpm_queue_vdm(port, response[0], &response[1], rlen - 1);
1868     else
1869         port->vdm_sm_running = false;
1870 }
1871
1872 static void tcpm_send_vdm(struct tcpm_port *port, u32 vid, int cmd,
1873               const u32 *data, int count)
1874 {
1875     int svdm_version = typec_get_negotiated_svdm_version(port->typec_port);
1876     u32 header;
1877
1878     if (svdm_version < 0)
1879         return;
1880
1881     if (WARN_ON(count > VDO_MAX_SIZE - 1))
1882         count = VDO_MAX_SIZE - 1;
1883
1884     /* set VDM header with VID & CMD */
1885     header = VDO(vid, ((vid & USB_SID_PD) == USB_SID_PD) ?
1886             1 : (PD_VDO_CMD(cmd) <= CMD_ATTENTION),
1887             svdm_version, cmd);
1888     tcpm_queue_vdm(port, header, data, count);
1889 }
1890
1891 static unsigned int vdm_ready_timeout(u32 vdm_hdr)
1892 {
1893     unsigned int timeout;
1894     int cmd = PD_VDO_CMD(vdm_hdr);
1895
1896     /* its not a structured VDM command */
1897     if (!PD_VDO_SVDM(vdm_hdr))
1898         return PD_T_VDM_UNSTRUCTURED;
1899
1900     switch (PD_VDO_CMDT(vdm_hdr)) {
1901     case CMDT_INIT:
1902         if (cmd == CMD_ENTER_MODE || cmd == CMD_EXIT_MODE)
1903             timeout = PD_T_VDM_WAIT_MODE_E;
1904         else
1905             timeout = PD_T_VDM_SNDR_RSP;
1906         break;
1907     default:
1908         if (cmd == CMD_ENTER_MODE || cmd == CMD_EXIT_MODE)
1909             timeout = PD_T_VDM_E_MODE;
1910         else
1911             timeout = PD_T_VDM_RCVR_RSP;
1912         break;
1913     }
1914     return timeout;
1915 }
1916
1917 static void vdm_run_state_machine(struct tcpm_port *port)
1918 {
1919     struct pd_message msg;
1920     int i, res = 0;
1921     u32 vdo_hdr = port->vdo_data[0];
1922
1923     switch (port->vdm_state) {
1924     case VDM_STATE_READY:
1925         /* Only transmit VDM if attached */
1926         if (!port->attached) {
1927             port->vdm_state = VDM_STATE_ERR_BUSY;
1928             break;
1929         }
1930
1931         /*
1932          * if there's traffic or we're not in PDO ready state don't send
1933          * a VDM.
1934          */
1935         if (port->state != SRC_READY && port->state != SNK_READY) {
1936             port->vdm_sm_running = false;
1937             break;
1938         }
1939
1940         /* TODO: AMS operation for Unstructured VDM */
1941         if (PD_VDO_SVDM(vdo_hdr) && PD_VDO_CMDT(vdo_hdr) == CMDT_INIT) {
1942             switch (PD_VDO_CMD(vdo_hdr)) {
1943             case CMD_DISCOVER_IDENT:
1944                 res = tcpm_ams_start(port, DISCOVER_IDENTITY);
1945                 if (res == 0)
1946                     port->send_discover = false;
1947                 else if (res == -EAGAIN)
1948                     mod_send_discover_delayed_work(port,
1949                                        SEND_DISCOVER_RETRY_MS);
1950                 break;
1951             case CMD_DISCOVER_SVID:
1952                 res = tcpm_ams_start(port, DISCOVER_SVIDS);
1953                 break;
1954             case CMD_DISCOVER_MODES:
1955                 res = tcpm_ams_start(port, DISCOVER_MODES);
1956                 break;
1957             case CMD_ENTER_MODE:
1958                 res = tcpm_ams_start(port, DFP_TO_UFP_ENTER_MODE);
1959                 break;
1960             case CMD_EXIT_MODE:
1961                 res = tcpm_ams_start(port, DFP_TO_UFP_EXIT_MODE);
1962                 break;
1963             case CMD_ATTENTION:
1964                 res = tcpm_ams_start(port, ATTENTION);
1965                 break;
1966             case VDO_CMD_VENDOR(0) ... VDO_CMD_VENDOR(15):
1967                 res = tcpm_ams_start(port, STRUCTURED_VDMS);
1968                 break;
1969             default:
1970                 res = -EOPNOTSUPP;
1971                 break;
1972             }
1973
1974             if (res < 0) {
1975                 port->vdm_state = VDM_STATE_ERR_BUSY;
1976                 return;
1977             }
1978         }
1979
1980         port->vdm_state = VDM_STATE_SEND_MESSAGE;
1981         mod_vdm_delayed_work(port, (port->negotiated_rev >= PD_REV30 &&
1982                         port->pwr_role == TYPEC_SOURCE &&
1983                         PD_VDO_SVDM(vdo_hdr) &&
1984                         PD_VDO_CMDT(vdo_hdr) == CMDT_INIT) ?
1985                        PD_T_SINK_TX : 0);
1986         break;
1987     case VDM_STATE_WAIT_RSP_BUSY:
1988         port->vdo_data[0] = port->vdo_retry;
1989         port->vdo_count = 1;
1990         port->vdm_state = VDM_STATE_READY;
1991         tcpm_ams_finish(port);
1992         break;
1993     case VDM_STATE_BUSY:
1994         port->vdm_state = VDM_STATE_ERR_TMOUT;
1995         if (port->ams != NONE_AMS)
1996             tcpm_ams_finish(port);
1997         break;
1998     case VDM_STATE_ERR_SEND:
1999         /*
2000          * A partner which does not support USB PD will not reply,
2001          * so this is not a fatal error. At the same time, some
2002          * devices may not return GoodCRC under some circumstances,
2003          * so we need to retry.
2004          */
2005         if (port->vdm_retries < 3) {
2006             tcpm_log(port, "VDM Tx error, retry");
2007             port->vdm_retries++;
2008             port->vdm_state = VDM_STATE_READY;
2009             if (PD_VDO_SVDM(vdo_hdr) && PD_VDO_CMDT(vdo_hdr) == CMDT_INIT)
2010                 tcpm_ams_finish(port);
2011         } else {
2012             tcpm_ams_finish(port);
2013         }
2014         break;
2015     case VDM_STATE_SEND_MESSAGE:
2016         /* Prepare and send VDM */
2017         memset(&msg, 0, sizeof(msg));
2018         msg.header = PD_HEADER_LE(PD_DATA_VENDOR_DEF,
2019                       port->pwr_role,
2020                       port->data_role,
2021                       port->negotiated_rev,
2022                       port->message_id, port->vdo_count);
2023         for (i = 0; i < port->vdo_count; i++)
2024             msg.payload[i] = cpu_to_le32(port->vdo_data[i]);
2025         res = tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
2026         if (res < 0) {
2027             port->vdm_state = VDM_STATE_ERR_SEND;
2028         } else {
2029             unsigned long timeout;
2030
2031             port->vdm_retries = 0;
2032             port->vdm_state = VDM_STATE_BUSY;
2033             timeout = vdm_ready_timeout(vdo_hdr);
2034             mod_vdm_delayed_work(port, timeout);
2035         }
2036         break;
2037     default:
2038         break;
2039     }
2040 }
2041
2042 static void vdm_state_machine_work(struct kthread_work *work)
2043 {
2044     struct tcpm_port *port = container_of(work, struct tcpm_port, vdm_state_machine);
2045     enum vdm_states prev_state;
2046
2047     mutex_lock(&port->lock);
2048
2049     /*
2050      * Continue running as long as the port is not busy and there was
2051      * a state change.
2052      */
2053     do {
2054         prev_state = port->vdm_state;
2055         vdm_run_state_machine(port);
2056     } while (port->vdm_state != prev_state &&
2057          port->vdm_state != VDM_STATE_BUSY &&
2058          port->vdm_state != VDM_STATE_SEND_MESSAGE);
2059
2060     if (port->vdm_state < VDM_STATE_READY)
2061         port->vdm_sm_running = false;
2062
2063     mutex_unlock(&port->lock);
2064 }
2065
2066 enum pdo_err {
2067     PDO_NO_ERR,
2068     PDO_ERR_NO_VSAFE5V,
2069     PDO_ERR_VSAFE5V_NOT_FIRST,
2070     PDO_ERR_PDO_TYPE_NOT_IN_ORDER,
2071     PDO_ERR_FIXED_NOT_SORTED,
2072     PDO_ERR_VARIABLE_BATT_NOT_SORTED,
2073     PDO_ERR_DUPE_PDO,
2074     PDO_ERR_PPS_APDO_NOT_SORTED,
2075     PDO_ERR_DUPE_PPS_APDO,
2076 };
2077
2078 static const char * const pdo_err_msg[] = {
2079     [PDO_ERR_NO_VSAFE5V] =
2080     " err: source/sink caps should at least have vSafe5V",
2081     [PDO_ERR_VSAFE5V_NOT_FIRST] =
2082     " err: vSafe5V Fixed Supply Object Shall always be the first object",
2083     [PDO_ERR_PDO_TYPE_NOT_IN_ORDER] =
2084     " err: PDOs should be in the following order: Fixed; Battery; Variable",
2085     [PDO_ERR_FIXED_NOT_SORTED] =
2086     " err: Fixed supply pdos should be in increasing order of their fixed voltage",
2087     [PDO_ERR_VARIABLE_BATT_NOT_SORTED] =
2088     " err: Variable/Battery supply pdos should be in increasing order of their minimum voltage",
2089     [PDO_ERR_DUPE_PDO] =
2090     " err: Variable/Batt supply pdos cannot have same min/max voltage",
2091     [PDO_ERR_PPS_APDO_NOT_SORTED] =
2092     " err: Programmable power supply apdos should be in increasing order of their maximum voltage",
2093     [PDO_ERR_DUPE_PPS_APDO] =
2094     " err: Programmable power supply apdos cannot have same min/max voltage and max current",
2095 };
2096
2097 static enum pdo_err tcpm_caps_err(struct tcpm_port *port, const u32 *pdo,
2098                   unsigned int nr_pdo)
2099 {
2100     unsigned int i;
2101
2102     /* Should at least contain vSafe5v */
2103     if (nr_pdo < 1)
2104         return PDO_ERR_NO_VSAFE5V;
2105
2106     /* The vSafe5V Fixed Supply Object Shall always be the first object */
2107     if (pdo_type(pdo[0]) != PDO_TYPE_FIXED ||
2108         pdo_fixed_voltage(pdo[0]) != VSAFE5V)
2109         return PDO_ERR_VSAFE5V_NOT_FIRST;
2110
2111     for (i = 1; i < nr_pdo; i++) {
2112         if (pdo_type(pdo[i]) < pdo_type(pdo[i - 1])) {
2113             return PDO_ERR_PDO_TYPE_NOT_IN_ORDER;
2114         } else if (pdo_type(pdo[i]) == pdo_type(pdo[i - 1])) {
2115             enum pd_pdo_type type = pdo_type(pdo[i]);
2116
2117             switch (type) {
2118             /*
2119              * The remaining Fixed Supply Objects, if
2120              * present, shall be sent in voltage order;
2121              * lowest to highest.
2122              */
2123             case PDO_TYPE_FIXED:
2124                 if (pdo_fixed_voltage(pdo[i]) <=
2125                     pdo_fixed_voltage(pdo[i - 1]))
2126                     return PDO_ERR_FIXED_NOT_SORTED;
2127                 break;
2128             /*
2129              * The Battery Supply Objects and Variable
2130              * supply, if present shall be sent in Minimum
2131              * Voltage order; lowest to highest.
2132              */
2133             case PDO_TYPE_VAR:
2134             case PDO_TYPE_BATT:
2135                 if (pdo_min_voltage(pdo[i]) <
2136                     pdo_min_voltage(pdo[i - 1]))
2137                     return PDO_ERR_VARIABLE_BATT_NOT_SORTED;
2138                 else if ((pdo_min_voltage(pdo[i]) ==
2139                       pdo_min_voltage(pdo[i - 1])) &&
2140                      (pdo_max_voltage(pdo[i]) ==
2141                       pdo_max_voltage(pdo[i - 1])))
2142                     return PDO_ERR_DUPE_PDO;
2143                 break;
2144             /*
2145              * The Programmable Power Supply APDOs, if present,
2146              * shall be sent in Maximum Voltage order;
2147              * lowest to highest.
2148              */
2149             case PDO_TYPE_APDO:
2150                 if (pdo_apdo_type(pdo[i]) != APDO_TYPE_PPS)
2151                     break;
2152
2153                 if (pdo_pps_apdo_max_voltage(pdo[i]) <
2154                     pdo_pps_apdo_max_voltage(pdo[i - 1]))
2155                     return PDO_ERR_PPS_APDO_NOT_SORTED;
2156                 else if (pdo_pps_apdo_min_voltage(pdo[i]) ==
2157                       pdo_pps_apdo_min_voltage(pdo[i - 1]) &&
2158                      pdo_pps_apdo_max_voltage(pdo[i]) ==
2159                       pdo_pps_apdo_max_voltage(pdo[i - 1]) &&
2160                      pdo_pps_apdo_max_current(pdo[i]) ==
2161                       pdo_pps_apdo_max_current(pdo[i - 1]))
2162                     return PDO_ERR_DUPE_PPS_APDO;
2163                 break;
2164             default:
2165                 tcpm_log_force(port, " Unknown pdo type");
2166             }
2167         }
2168     }
2169
2170     return PDO_NO_ERR;
2171 }
2172
2173 static int tcpm_validate_caps(struct tcpm_port *port, const u32 *pdo,
2174                   unsigned int nr_pdo)
2175 {
2176     enum pdo_err err_index = tcpm_caps_err(port, pdo, nr_pdo);
2177
2178     if (err_index != PDO_NO_ERR) {
2179         tcpm_log_force(port, " %s", pdo_err_msg[err_index]);
2180         return -EINVAL;
2181     }
2182
2183     return 0;
2184 }
2185
2186 static int tcpm_altmode_enter(struct typec_altmode *altmode, u32 *vdo)
2187 {
2188     struct tcpm_port *port = typec_altmode_get_drvdata(altmode);
2189     int svdm_version;
2190     u32 header;
2191
2192     svdm_version = typec_get_negotiated_svdm_version(port->typec_port);
2193     if (svdm_version < 0)
2194         return svdm_version;
2195
2196     header = VDO(altmode->svid, vdo ? 2 : 1, svdm_version, CMD_ENTER_MODE);
2197     header |= VDO_OPOS(altmode->mode);
2198
2199     tcpm_queue_vdm_unlocked(port, header, vdo, vdo ? 1 : 0);
2200     return 0;
2201 }
2202
2203 static int tcpm_altmode_exit(struct typec_altmode *altmode)
2204 {
2205     struct tcpm_port *port = typec_altmode_get_drvdata(altmode);
2206     int svdm_version;
2207     u32 header;
2208
2209     svdm_version = typec_get_negotiated_svdm_version(port->typec_port);
2210     if (svdm_version < 0)
2211         return svdm_version;
2212
2213     header = VDO(altmode->svid, 1, svdm_version, CMD_EXIT_MODE);
2214     header |= VDO_OPOS(altmode->mode);
2215
2216     tcpm_queue_vdm_unlocked(port, header, NULL, 0);
2217     return 0;
2218 }
2219
2220 static int tcpm_altmode_vdm(struct typec_altmode *altmode,
2221                 u32 header, const u32 *data, int count)
2222 {
2223     struct tcpm_port *port = typec_altmode_get_drvdata(altmode);
2224
2225     tcpm_queue_vdm_unlocked(port, header, data, count - 1);
2226
2227     return 0;
2228 }
2229
2230 static const struct typec_altmode_ops tcpm_altmode_ops = {
2231     .enter = tcpm_altmode_enter,
2232     .exit = tcpm_altmode_exit,
2233     .vdm = tcpm_altmode_vdm,
2234 };
2235
2236 /*
2237  * PD (data, control) command handling functions
2238  */
2239 static inline enum tcpm_state ready_state(struct tcpm_port *port)
2240 {
2241     if (port->pwr_role == TYPEC_SOURCE)
2242         return SRC_READY;
2243     else
2244         return SNK_READY;
2245 }
2246
2247 static int tcpm_pd_send_control(struct tcpm_port *port,
2248                 enum pd_ctrl_msg_type type);
2249
2250 static void tcpm_handle_alert(struct tcpm_port *port, const __le32 *payload,
2251                   int cnt)
2252 {
2253     u32 p0 = le32_to_cpu(payload[0]);
2254     unsigned int type = usb_pd_ado_type(p0);
2255
2256     if (!type) {
2257         tcpm_log(port, "Alert message received with no type");
2258         tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP);
2259         return;
2260     }
2261
2262     /* Just handling non-battery alerts for now */
2263     if (!(type & USB_PD_ADO_TYPE_BATT_STATUS_CHANGE)) {
2264         if (port->pwr_role == TYPEC_SOURCE) {
2265             port->upcoming_state = GET_STATUS_SEND;
2266             tcpm_ams_start(port, GETTING_SOURCE_SINK_STATUS);
2267         } else {
2268             /*
2269              * Do not check SinkTxOk here in case the Source doesn't set its Rp to
2270              * SinkTxOk in time.
2271              */
2272             port->ams = GETTING_SOURCE_SINK_STATUS;
2273             tcpm_set_state(port, GET_STATUS_SEND, 0);
2274         }
2275     } else {
2276         tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP);
2277     }
2278 }
2279
2280 static int tcpm_set_auto_vbus_discharge_threshold(struct tcpm_port *port,
2281                           enum typec_pwr_opmode mode, bool pps_active,
2282                           u32 requested_vbus_voltage)
2283 {
2284     int ret;
2285
2286     if (!port->tcpc->set_auto_vbus_discharge_threshold)
2287         return 0;
2288
2289     ret = port->tcpc->set_auto_vbus_discharge_threshold(port->tcpc, mode, pps_active,
2290                                 requested_vbus_voltage);
2291     tcpm_log_force(port,
2292                "set_auto_vbus_discharge_threshold mode:%d pps_active:%c vbus:%u ret:%d",
2293                mode, pps_active ? 'y' : 'n', requested_vbus_voltage, ret);
2294
2295     return ret;
2296 }
2297
2298 static void tcpm_pd_handle_state(struct tcpm_port *port,
2299                  enum tcpm_state state,
2300                  enum tcpm_ams ams,
2301                  unsigned int delay_ms)
2302 {
2303     switch (port->state) {
2304     case SRC_READY:
2305     case SNK_READY:
2306         port->ams = ams;
2307         tcpm_set_state(port, state, delay_ms);
2308         break;
2309     /* 8.3.3.4.1.1 and 6.8.1 power transitioning */
2310     case SNK_TRANSITION_SINK:
2311     case SNK_TRANSITION_SINK_VBUS:
2312     case SRC_TRANSITION_SUPPLY:
2313         tcpm_set_state(port, HARD_RESET_SEND, 0);
2314         break;
2315     default:
2316         if (!tcpm_ams_interruptible(port)) {
2317             tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ?
2318                        SRC_SOFT_RESET_WAIT_SNK_TX :
2319                        SNK_SOFT_RESET,
2320                        0);
2321         } else {
2322             /* process the Message 6.8.1 */
2323             port->upcoming_state = state;
2324             port->next_ams = ams;
2325             tcpm_set_state(port, ready_state(port), delay_ms);
2326         }
2327         break;
2328     }
2329 }
2330
2331 static void tcpm_pd_handle_msg(struct tcpm_port *port,
2332                    enum pd_msg_request message,
2333                    enum tcpm_ams ams)
2334 {
2335     switch (port->state) {
2336     case SRC_READY:
2337     case SNK_READY:
2338         port->ams = ams;
2339         tcpm_queue_message(port, message);
2340         break;
2341     /* PD 3.0 Spec 8.3.3.4.1.1 and 6.8.1 */
2342     case SNK_TRANSITION_SINK:
2343     case SNK_TRANSITION_SINK_VBUS:
2344     case SRC_TRANSITION_SUPPLY:
2345         tcpm_set_state(port, HARD_RESET_SEND, 0);
2346         break;
2347     default:
2348         if (!tcpm_ams_interruptible(port)) {
2349             tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ?
2350                        SRC_SOFT_RESET_WAIT_SNK_TX :
2351                        SNK_SOFT_RESET,
2352                        0);
2353         } else {
2354             port->next_ams = ams;
2355             tcpm_set_state(port, ready_state(port), 0);
2356             /* 6.8.1 process the Message */
2357             tcpm_queue_message(port, message);
2358         }
2359         break;
2360     }
2361 }
2362
2363 static int tcpm_register_source_caps(struct tcpm_port *port)
2364 {
2365     struct usb_power_delivery_desc desc = { port->negotiated_rev };
2366     struct usb_power_delivery_capabilities_desc caps = { };
2367     struct usb_power_delivery_capabilities *cap;
2368
2369     if (!port->partner_pd)
2370         port->partner_pd = usb_power_delivery_register(NULL, &desc);
2371     if (IS_ERR(port->partner_pd))
2372         return PTR_ERR(port->partner_pd);
2373
2374     memcpy(caps.pdo, port->source_caps, sizeof(u32) * port->nr_source_caps);
2375     caps.role = TYPEC_SOURCE;
2376
2377     cap = usb_power_delivery_register_capabilities(port->partner_pd, &caps);
2378     if (IS_ERR(cap))
2379         return PTR_ERR(cap);
2380
2381     port->partner_source_caps = cap;
2382
2383     return 0;
2384 }
2385
2386 static int tcpm_register_sink_caps(struct tcpm_port *port)
2387 {
2388     struct usb_power_delivery_desc desc = { port->negotiated_rev };
2389     struct usb_power_delivery_capabilities_desc caps = { };
2390     struct usb_power_delivery_capabilities *cap;
2391
2392     if (!port->partner_pd)
2393         port->partner_pd = usb_power_delivery_register(NULL, &desc);
2394     if (IS_ERR(port->partner_pd))
2395         return PTR_ERR(port->partner_pd);
2396
2397     memcpy(caps.pdo, port->sink_caps, sizeof(u32) * port->nr_sink_caps);
2398     caps.role = TYPEC_SINK;
2399
2400     cap = usb_power_delivery_register_capabilities(port->partner_pd, &caps);
2401     if (IS_ERR(cap))
2402         return PTR_ERR(cap);
2403
2404     port->partner_sink_caps = cap;
2405
2406     return 0;
2407 }
2408
2409 static void tcpm_pd_data_request(struct tcpm_port *port,
2410                  const struct pd_message *msg)
2411 {
2412     enum pd_data_msg_type type = pd_header_type_le(msg->header);
2413     unsigned int cnt = pd_header_cnt_le(msg->header);
2414     unsigned int rev = pd_header_rev_le(msg->header);
2415     unsigned int i;
2416     enum frs_typec_current partner_frs_current;
2417     bool frs_enable;
2418     int ret;
2419
2420     if (tcpm_vdm_ams(port) && type != PD_DATA_VENDOR_DEF) {
2421         port->vdm_state = VDM_STATE_ERR_BUSY;
2422         tcpm_ams_finish(port);
2423         mod_vdm_delayed_work(port, 0);
2424     }
2425
2426     switch (type) {
2427     case PD_DATA_SOURCE_CAP:
2428         for (i = 0; i < cnt; i++)
2429             port->source_caps[i] = le32_to_cpu(msg->payload[i]);
2430
2431         port->nr_source_caps = cnt;
2432
2433         tcpm_log_source_caps(port);
2434
2435         tcpm_validate_caps(port, port->source_caps,
2436                    port->nr_source_caps);
2437
2438         tcpm_register_source_caps(port);
2439
2440         /*
2441          * Adjust revision in subsequent message headers, as required,
2442          * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't
2443          * support Rev 1.0 so just do nothing in that scenario.
2444          */
2445         if (rev == PD_REV10) {
2446             if (port->ams == GET_SOURCE_CAPABILITIES)
2447                 tcpm_ams_finish(port);
2448             break;
2449         }
2450
2451         if (rev < PD_MAX_REV)
2452             port->negotiated_rev = rev;
2453
2454         if (port->pwr_role == TYPEC_SOURCE) {
2455             if (port->ams == GET_SOURCE_CAPABILITIES)
2456                 tcpm_pd_handle_state(port, SRC_READY, NONE_AMS, 0);
2457             /* Unexpected Source Capabilities */
2458             else
2459                 tcpm_pd_handle_msg(port,
2460                            port->negotiated_rev < PD_REV30 ?
2461                            PD_MSG_CTRL_REJECT :
2462                            PD_MSG_CTRL_NOT_SUPP,
2463                            NONE_AMS);
2464         } else if (port->state == SNK_WAIT_CAPABILITIES) {
2465         /*
2466          * This message may be received even if VBUS is not
2467          * present. This is quite unexpected; see USB PD
2468          * specification, sections 8.3.3.6.3.1 and 8.3.3.6.3.2.
2469          * However, at the same time, we must be ready to
2470          * receive this message and respond to it 15ms after
2471          * receiving PS_RDY during power swap operations, no matter
2472          * if VBUS is available or not (USB PD specification,
2473          * section 6.5.9.2).
2474          * So we need to accept the message either way,
2475          * but be prepared to keep waiting for VBUS after it was
2476          * handled.
2477          */
2478             port->ams = POWER_NEGOTIATION;
2479             port->in_ams = true;
2480             tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0);
2481         } else {
2482             if (port->ams == GET_SOURCE_CAPABILITIES)
2483                 tcpm_ams_finish(port);
2484             tcpm_pd_handle_state(port, SNK_NEGOTIATE_CAPABILITIES,
2485                          POWER_NEGOTIATION, 0);
2486         }
2487         break;
2488     case PD_DATA_REQUEST:
2489         /*
2490          * Adjust revision in subsequent message headers, as required,
2491          * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't
2492          * support Rev 1.0 so just reject in that scenario.
2493          */
2494         if (rev == PD_REV10) {
2495             tcpm_pd_handle_msg(port,
2496                        port->negotiated_rev < PD_REV30 ?
2497                        PD_MSG_CTRL_REJECT :
2498                        PD_MSG_CTRL_NOT_SUPP,
2499                        NONE_AMS);
2500             break;
2501         }
2502
2503         if (rev < PD_MAX_REV)
2504             port->negotiated_rev = rev;
2505
2506         if (port->pwr_role != TYPEC_SOURCE || cnt != 1) {
2507             tcpm_pd_handle_msg(port,
2508                        port->negotiated_rev < PD_REV30 ?
2509                        PD_MSG_CTRL_REJECT :
2510                        PD_MSG_CTRL_NOT_SUPP,
2511                        NONE_AMS);
2512             break;
2513         }
2514
2515         port->sink_request = le32_to_cpu(msg->payload[0]);
2516
2517         if (port->vdm_sm_running && port->explicit_contract) {
2518             tcpm_pd_handle_msg(port, PD_MSG_CTRL_WAIT, port->ams);
2519             break;
2520         }
2521
2522         if (port->state == SRC_SEND_CAPABILITIES)
2523             tcpm_set_state(port, SRC_NEGOTIATE_CAPABILITIES, 0);
2524         else
2525             tcpm_pd_handle_state(port, SRC_NEGOTIATE_CAPABILITIES,
2526                          POWER_NEGOTIATION, 0);
2527         break;
2528     case PD_DATA_SINK_CAP:
2529         /* We don't do anything with this at the moment... */
2530         for (i = 0; i < cnt; i++)
2531             port->sink_caps[i] = le32_to_cpu(msg->payload[i]);
2532
2533         partner_frs_current = (port->sink_caps[0] & PDO_FIXED_FRS_CURR_MASK) >>
2534             PDO_FIXED_FRS_CURR_SHIFT;
2535         frs_enable = partner_frs_current && (partner_frs_current <=
2536                              port->new_source_frs_current);
2537         tcpm_log(port,
2538              "Port partner FRS capable partner_frs_current:%u port_frs_current:%u enable:%c",
2539              partner_frs_current, port->new_source_frs_current, frs_enable ? 'y' : 'n');
2540         if (frs_enable) {
2541             ret  = port->tcpc->enable_frs(port->tcpc, true);
2542             tcpm_log(port, "Enable FRS %s, ret:%d\n", ret ? "fail" : "success", ret);
2543         }
2544
2545         port->nr_sink_caps = cnt;
2546         port->sink_cap_done = true;
2547         tcpm_register_sink_caps(port);
2548
2549         if (port->ams == GET_SINK_CAPABILITIES)
2550             tcpm_set_state(port, ready_state(port), 0);
2551         /* Unexpected Sink Capabilities */
2552         else
2553             tcpm_pd_handle_msg(port,
2554                        port->negotiated_rev < PD_REV30 ?
2555                        PD_MSG_CTRL_REJECT :
2556                        PD_MSG_CTRL_NOT_SUPP,
2557                        NONE_AMS);
2558         break;
2559     case PD_DATA_VENDOR_DEF:
2560         tcpm_handle_vdm_request(port, msg->payload, cnt);
2561         break;
2562     case PD_DATA_BIST:
2563         port->bist_request = le32_to_cpu(msg->payload[0]);
2564         tcpm_pd_handle_state(port, BIST_RX, BIST, 0);
2565         break;
2566     case PD_DATA_ALERT:
2567         if (port->state != SRC_READY && port->state != SNK_READY)
2568             tcpm_pd_handle_state(port, port->pwr_role == TYPEC_SOURCE ?
2569                          SRC_SOFT_RESET_WAIT_SNK_TX : SNK_SOFT_RESET,
2570                          NONE_AMS, 0);
2571         else
2572             tcpm_handle_alert(port, msg->payload, cnt);
2573         break;
2574     case PD_DATA_BATT_STATUS:
2575     case PD_DATA_GET_COUNTRY_INFO:
2576         /* Currently unsupported */
2577         tcpm_pd_handle_msg(port, port->negotiated_rev < PD_REV30 ?
2578                    PD_MSG_CTRL_REJECT :
2579                    PD_MSG_CTRL_NOT_SUPP,
2580                    NONE_AMS);
2581         break;
2582     default:
2583         tcpm_pd_handle_msg(port, port->negotiated_rev < PD_REV30 ?
2584                    PD_MSG_CTRL_REJECT :
2585                    PD_MSG_CTRL_NOT_SUPP,
2586                    NONE_AMS);
2587         tcpm_log(port, "Unrecognized data message type %#x", type);
2588         break;
2589     }
2590 }
2591
2592 static void tcpm_pps_complete(struct tcpm_port *port, int result)
2593 {
2594     if (port->pps_pending) {
2595         port->pps_status = result;
2596         port->pps_pending = false;
2597         complete(&port->pps_complete);
2598     }
2599 }
2600
2601 static void tcpm_pd_ctrl_request(struct tcpm_port *port,
2602                  const struct pd_message *msg)
2603 {
2604     enum pd_ctrl_msg_type type = pd_header_type_le(msg->header);
2605     enum tcpm_state next_state;
2606
2607     /*
2608      * Stop VDM state machine if interrupted by other Messages while NOT_SUPP is allowed in
2609      * VDM AMS if waiting for VDM responses and will be handled later.
2610      */
2611     if (tcpm_vdm_ams(port) && type != PD_CTRL_NOT_SUPP && type != PD_CTRL_GOOD_CRC) {
2612         port->vdm_state = VDM_STATE_ERR_BUSY;
2613         tcpm_ams_finish(port);
2614         mod_vdm_delayed_work(port, 0);
2615     }
2616
2617     switch (type) {
2618     case PD_CTRL_GOOD_CRC:
2619     case PD_CTRL_PING:
2620         break;
2621     case PD_CTRL_GET_SOURCE_CAP:
2622         tcpm_pd_handle_msg(port, PD_MSG_DATA_SOURCE_CAP, GET_SOURCE_CAPABILITIES);
2623         break;
2624     case PD_CTRL_GET_SINK_CAP:
2625         tcpm_pd_handle_msg(port, PD_MSG_DATA_SINK_CAP, GET_SINK_CAPABILITIES);
2626         break;
2627     case PD_CTRL_GOTO_MIN:
2628         break;
2629     case PD_CTRL_PS_RDY:
2630         switch (port->state) {
2631         case SNK_TRANSITION_SINK:
2632             if (port->vbus_present) {
2633                 tcpm_set_current_limit(port,
2634                                port->req_current_limit,
2635                                port->req_supply_voltage);
2636                 port->explicit_contract = true;
2637                 tcpm_set_auto_vbus_discharge_threshold(port,
2638                                        TYPEC_PWR_MODE_PD,
2639                                        port->pps_data.active,
2640                                        port->supply_voltage);
2641                 tcpm_set_state(port, SNK_READY, 0);
2642             } else {
2643                 /*
2644                  * Seen after power swap. Keep waiting for VBUS
2645                  * in a transitional state.
2646                  */
2647                 tcpm_set_state(port,
2648                            SNK_TRANSITION_SINK_VBUS, 0);
2649             }
2650             break;
2651         case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED:
2652             tcpm_set_state(port, PR_SWAP_SRC_SNK_SINK_ON, 0);
2653             break;
2654         case PR_SWAP_SNK_SRC_SINK_OFF:
2655             tcpm_set_state(port, PR_SWAP_SNK_SRC_SOURCE_ON, 0);
2656             break;
2657         case VCONN_SWAP_WAIT_FOR_VCONN:
2658             tcpm_set_state(port, VCONN_SWAP_TURN_OFF_VCONN, 0);
2659             break;
2660         case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF:
2661             tcpm_set_state(port, FR_SWAP_SNK_SRC_NEW_SINK_READY, 0);
2662             break;
2663         default:
2664             tcpm_pd_handle_state(port,
2665                          port->pwr_role == TYPEC_SOURCE ?
2666                          SRC_SOFT_RESET_WAIT_SNK_TX :
2667                          SNK_SOFT_RESET,
2668                          NONE_AMS, 0);
2669             break;
2670         }
2671         break;
2672     case PD_CTRL_REJECT:
2673     case PD_CTRL_WAIT:
2674     case PD_CTRL_NOT_SUPP:
2675         switch (port->state) {
2676         case SNK_NEGOTIATE_CAPABILITIES:
2677             /* USB PD specification, Figure 8-43 */
2678             if (port->explicit_contract)
2679                 next_state = SNK_READY;
2680             else
2681                 next_state = SNK_WAIT_CAPABILITIES;
2682
2683             /* Threshold was relaxed before sending Request. Restore it back. */
2684             tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_PD,
2685                                    port->pps_data.active,
2686                                    port->supply_voltage);
2687             tcpm_set_state(port, next_state, 0);
2688             break;
2689         case SNK_NEGOTIATE_PPS_CAPABILITIES:
2690             /* Revert data back from any requested PPS updates */
2691             port->pps_data.req_out_volt = port->supply_voltage;
2692             port->pps_data.req_op_curr = port->current_limit;
2693             port->pps_status = (type == PD_CTRL_WAIT ?
2694                         -EAGAIN : -EOPNOTSUPP);
2695
2696             /* Threshold was relaxed before sending Request. Restore it back. */
2697             tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_PD,
2698                                    port->pps_data.active,
2699                                    port->supply_voltage);
2700
2701             tcpm_set_state(port, SNK_READY, 0);
2702             break;
2703         case DR_SWAP_SEND:
2704             port->swap_status = (type == PD_CTRL_WAIT ?
2705                          -EAGAIN : -EOPNOTSUPP);
2706             tcpm_set_state(port, DR_SWAP_CANCEL, 0);
2707             break;
2708         case PR_SWAP_SEND:
2709             port->swap_status = (type == PD_CTRL_WAIT ?
2710                          -EAGAIN : -EOPNOTSUPP);
2711             tcpm_set_state(port, PR_SWAP_CANCEL, 0);
2712             break;
2713         case VCONN_SWAP_SEND:
2714             port->swap_status = (type == PD_CTRL_WAIT ?
2715                          -EAGAIN : -EOPNOTSUPP);
2716             tcpm_set_state(port, VCONN_SWAP_CANCEL, 0);
2717             break;
2718         case FR_SWAP_SEND:
2719             tcpm_set_state(port, FR_SWAP_CANCEL, 0);
2720             break;
2721         case GET_SINK_CAP:
2722             port->sink_cap_done = true;
2723             tcpm_set_state(port, ready_state(port), 0);
2724             break;
2725         case SRC_READY:
2726         case SNK_READY:
2727             if (port->vdm_state > VDM_STATE_READY) {
2728                 port->vdm_state = VDM_STATE_DONE;
2729                 if (tcpm_vdm_ams(port))
2730                     tcpm_ams_finish(port);
2731                 mod_vdm_delayed_work(port, 0);
2732                 break;
2733             }
2734             fallthrough;
2735         default:
2736             tcpm_pd_handle_state(port,
2737                          port->pwr_role == TYPEC_SOURCE ?
2738                          SRC_SOFT_RESET_WAIT_SNK_TX :
2739                          SNK_SOFT_RESET,
2740                          NONE_AMS, 0);
2741             break;
2742         }
2743         break;
2744     case PD_CTRL_ACCEPT:
2745         switch (port->state) {
2746         case SNK_NEGOTIATE_CAPABILITIES:
2747             port->pps_data.active = false;
2748             tcpm_set_state(port, SNK_TRANSITION_SINK, 0);
2749             break;
2750         case SNK_NEGOTIATE_PPS_CAPABILITIES:
2751             port->pps_data.active = true;
2752             port->pps_data.min_volt = port->pps_data.req_min_volt;
2753             port->pps_data.max_volt = port->pps_data.req_max_volt;
2754             port->pps_data.max_curr = port->pps_data.req_max_curr;
2755             port->req_supply_voltage = port->pps_data.req_out_volt;
2756             port->req_current_limit = port->pps_data.req_op_curr;
2757             power_supply_changed(port->psy);
2758             tcpm_set_state(port, SNK_TRANSITION_SINK, 0);
2759             break;
2760         case SOFT_RESET_SEND:
2761             if (port->ams == SOFT_RESET_AMS)
2762                 tcpm_ams_finish(port);
2763             if (port->pwr_role == TYPEC_SOURCE) {
2764                 port->upcoming_state = SRC_SEND_CAPABILITIES;
2765                 tcpm_ams_start(port, POWER_NEGOTIATION);
2766             } else {
2767                 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0);
2768             }
2769             break;
2770         case DR_SWAP_SEND:
2771             tcpm_set_state(port, DR_SWAP_CHANGE_DR, 0);
2772             break;
2773         case PR_SWAP_SEND:
2774             tcpm_set_state(port, PR_SWAP_START, 0);
2775             break;
2776         case VCONN_SWAP_SEND:
2777             tcpm_set_state(port, VCONN_SWAP_START, 0);
2778             break;
2779         case FR_SWAP_SEND:
2780             tcpm_set_state(port, FR_SWAP_SNK_SRC_TRANSITION_TO_OFF, 0);
2781             break;
2782         default:
2783             tcpm_pd_handle_state(port,
2784                          port->pwr_role == TYPEC_SOURCE ?
2785                          SRC_SOFT_RESET_WAIT_SNK_TX :
2786                          SNK_SOFT_RESET,
2787                          NONE_AMS, 0);
2788             break;
2789         }
2790         break;
2791     case PD_CTRL_SOFT_RESET:
2792         port->ams = SOFT_RESET_AMS;
2793         tcpm_set_state(port, SOFT_RESET, 0);
2794         break;
2795     case PD_CTRL_DR_SWAP:
2796         /*
2797          * XXX
2798          * 6.3.9: If an alternate mode is active, a request to swap
2799          * alternate modes shall trigger a port reset.
2800          */
2801         if (port->typec_caps.data != TYPEC_PORT_DRD) {
2802             tcpm_pd_handle_msg(port,
2803                        port->negotiated_rev < PD_REV30 ?
2804                        PD_MSG_CTRL_REJECT :
2805                        PD_MSG_CTRL_NOT_SUPP,
2806                        NONE_AMS);
2807         } else {
2808             if (port->send_discover) {
2809                 tcpm_queue_message(port, PD_MSG_CTRL_WAIT);
2810                 break;
2811             }
2812
2813             tcpm_pd_handle_state(port, DR_SWAP_ACCEPT, DATA_ROLE_SWAP, 0);
2814         }
2815         break;
2816     case PD_CTRL_PR_SWAP:
2817         if (port->port_type != TYPEC_PORT_DRP) {
2818             tcpm_pd_handle_msg(port,
2819                        port->negotiated_rev < PD_REV30 ?
2820                        PD_MSG_CTRL_REJECT :
2821                        PD_MSG_CTRL_NOT_SUPP,
2822                        NONE_AMS);
2823         } else {
2824             if (port->send_discover) {
2825                 tcpm_queue_message(port, PD_MSG_CTRL_WAIT);
2826                 break;
2827             }
2828
2829             tcpm_pd_handle_state(port, PR_SWAP_ACCEPT, POWER_ROLE_SWAP, 0);
2830         }
2831         break;
2832     case PD_CTRL_VCONN_SWAP:
2833         if (port->send_discover) {
2834             tcpm_queue_message(port, PD_MSG_CTRL_WAIT);
2835             break;
2836         }
2837
2838         tcpm_pd_handle_state(port, VCONN_SWAP_ACCEPT, VCONN_SWAP, 0);
2839         break;
2840     case PD_CTRL_GET_SOURCE_CAP_EXT:
2841     case PD_CTRL_GET_STATUS:
2842     case PD_CTRL_FR_SWAP:
2843     case PD_CTRL_GET_PPS_STATUS:
2844     case PD_CTRL_GET_COUNTRY_CODES:
2845         /* Currently not supported */
2846         tcpm_pd_handle_msg(port,
2847                    port->negotiated_rev < PD_REV30 ?
2848                    PD_MSG_CTRL_REJECT :
2849                    PD_MSG_CTRL_NOT_SUPP,
2850                    NONE_AMS);
2851         break;
2852     default:
2853         tcpm_pd_handle_msg(port,
2854                    port->negotiated_rev < PD_REV30 ?
2855                    PD_MSG_CTRL_REJECT :
2856                    PD_MSG_CTRL_NOT_SUPP,
2857                    NONE_AMS);
2858         tcpm_log(port, "Unrecognized ctrl message type %#x", type);
2859         break;
2860     }
2861 }
2862
2863 static void tcpm_pd_ext_msg_request(struct tcpm_port *port,
2864                     const struct pd_message *msg)
2865 {
2866     enum pd_ext_msg_type type = pd_header_type_le(msg->header);
2867     unsigned int data_size = pd_ext_header_data_size_le(msg->ext_msg.header);
2868
2869     /* stopping VDM state machine if interrupted by other Messages */
2870     if (tcpm_vdm_ams(port)) {
2871         port->vdm_state = VDM_STATE_ERR_BUSY;
2872         tcpm_ams_finish(port);
2873         mod_vdm_delayed_work(port, 0);
2874     }
2875
2876     if (!(le16_to_cpu(msg->ext_msg.header) & PD_EXT_HDR_CHUNKED)) {
2877         tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS);
2878         tcpm_log(port, "Unchunked extended messages unsupported");
2879         return;
2880     }
2881
2882     if (data_size > PD_EXT_MAX_CHUNK_DATA) {
2883         tcpm_pd_handle_state(port, CHUNK_NOT_SUPP, NONE_AMS, PD_T_CHUNK_NOT_SUPP);
2884         tcpm_log(port, "Chunk handling not yet supported");
2885         return;
2886     }
2887
2888     switch (type) {
2889     case PD_EXT_STATUS:
2890     case PD_EXT_PPS_STATUS:
2891         if (port->ams == GETTING_SOURCE_SINK_STATUS) {
2892             tcpm_ams_finish(port);
2893             tcpm_set_state(port, ready_state(port), 0);
2894         } else {
2895             /* unexpected Status or PPS_Status Message */
2896             tcpm_pd_handle_state(port, port->pwr_role == TYPEC_SOURCE ?
2897                          SRC_SOFT_RESET_WAIT_SNK_TX : SNK_SOFT_RESET,
2898                          NONE_AMS, 0);
2899         }
2900         break;
2901     case PD_EXT_SOURCE_CAP_EXT:
2902     case PD_EXT_GET_BATT_CAP:
2903     case PD_EXT_GET_BATT_STATUS:
2904     case PD_EXT_BATT_CAP:
2905     case PD_EXT_GET_MANUFACTURER_INFO:
2906     case PD_EXT_MANUFACTURER_INFO:
2907     case PD_EXT_SECURITY_REQUEST:
2908     case PD_EXT_SECURITY_RESPONSE:
2909     case PD_EXT_FW_UPDATE_REQUEST:
2910     case PD_EXT_FW_UPDATE_RESPONSE:
2911     case PD_EXT_COUNTRY_INFO:
2912     case PD_EXT_COUNTRY_CODES:
2913         tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS);
2914         break;
2915     default:
2916         tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS);
2917         tcpm_log(port, "Unrecognized extended message type %#x", type);
2918         break;
2919     }
2920 }
2921
2922 static void tcpm_pd_rx_handler(struct kthread_work *work)
2923 {
2924     struct pd_rx_event *event = container_of(work,
2925                          struct pd_rx_event, work);
2926     const struct pd_message *msg = &event->msg;
2927     unsigned int cnt = pd_header_cnt_le(msg->header);
2928     struct tcpm_port *port = event->port;
2929
2930     mutex_lock(&port->lock);
2931
2932     tcpm_log(port, "PD RX, header: %#x [%d]", le16_to_cpu(msg->header),
2933          port->attached);
2934
2935     if (port->attached) {
2936         enum pd_ctrl_msg_type type = pd_header_type_le(msg->header);
2937         unsigned int msgid = pd_header_msgid_le(msg->header);
2938
2939         /*
2940          * USB PD standard, 6.6.1.2:
2941          * "... if MessageID value in a received Message is the
2942          * same as the stored value, the receiver shall return a
2943          * GoodCRC Message with that MessageID value and drop
2944          * the Message (this is a retry of an already received
2945          * Message). Note: this shall not apply to the Soft_Reset
2946          * Message which always has a MessageID value of zero."
2947          */
2948         if (msgid == port->rx_msgid && type != PD_CTRL_SOFT_RESET)
2949             goto done;
2950         port->rx_msgid = msgid;
2951
2952         /*
2953          * If both ends believe to be DFP/host, we have a data role
2954          * mismatch.
2955          */
2956         if (!!(le16_to_cpu(msg->header) & PD_HEADER_DATA_ROLE) ==
2957             (port->data_role == TYPEC_HOST)) {
2958             tcpm_log(port,
2959                  "Data role mismatch, initiating error recovery");
2960             tcpm_set_state(port, ERROR_RECOVERY, 0);
2961         } else {
2962             if (le16_to_cpu(msg->header) & PD_HEADER_EXT_HDR)
2963                 tcpm_pd_ext_msg_request(port, msg);
2964             else if (cnt)
2965                 tcpm_pd_data_request(port, msg);
2966             else
2967                 tcpm_pd_ctrl_request(port, msg);
2968         }
2969     }
2970
2971 done:
2972     mutex_unlock(&port->lock);
2973     kfree(event);
2974 }
2975
2976 void tcpm_pd_receive(struct tcpm_port *port, const struct pd_message *msg)
2977 {
2978     struct pd_rx_event *event;
2979
2980     event = kzalloc(sizeof(*event), GFP_ATOMIC);
2981     if (!event)
2982         return;
2983
2984     kthread_init_work(&event->work, tcpm_pd_rx_handler);
2985     event->port = port;
2986     memcpy(&event->msg, msg, sizeof(*msg));
2987     kthread_queue_work(port->wq, &event->work);
2988 }
2989 EXPORT_SYMBOL_GPL(tcpm_pd_receive);
2990
2991 static int tcpm_pd_send_control(struct tcpm_port *port,
2992                 enum pd_ctrl_msg_type type)
2993 {
2994     struct pd_message msg;
2995
2996     memset(&msg, 0, sizeof(msg));
2997     msg.header = PD_HEADER_LE(type, port->pwr_role,
2998                   port->data_role,
2999                   port->negotiated_rev,
3000                   port->message_id, 0);
3001
3002     return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
3003 }
3004
3005 /*
3006  * Send queued message without affecting state.
3007  * Return true if state machine should go back to sleep,
3008  * false otherwise.
3009  */
3010 static bool tcpm_send_queued_message(struct tcpm_port *port)
3011 {
3012     enum pd_msg_request queued_message;
3013     int ret;
3014
3015     do {
3016         queued_message = port->queued_message;
3017         port->queued_message = PD_MSG_NONE;
3018
3019         switch (queued_message) {
3020         case PD_MSG_CTRL_WAIT:
3021             tcpm_pd_send_control(port, PD_CTRL_WAIT);
3022             break;
3023         case PD_MSG_CTRL_REJECT:
3024             tcpm_pd_send_control(port, PD_CTRL_REJECT);
3025             break;
3026         case PD_MSG_CTRL_NOT_SUPP:
3027             tcpm_pd_send_control(port, PD_CTRL_NOT_SUPP);
3028             break;
3029         case PD_MSG_DATA_SINK_CAP:
3030             ret = tcpm_pd_send_sink_caps(port);
3031             if (ret < 0) {
3032                 tcpm_log(port, "Unable to send snk caps, ret=%d", ret);
3033                 tcpm_set_state(port, SNK_SOFT_RESET, 0);
3034             }
3035             tcpm_ams_finish(port);
3036             break;
3037         case PD_MSG_DATA_SOURCE_CAP:
3038             ret = tcpm_pd_send_source_caps(port);
3039             if (ret < 0) {
3040                 tcpm_log(port,
3041                      "Unable to send src caps, ret=%d",
3042                      ret);
3043                 tcpm_set_state(port, SOFT_RESET_SEND, 0);
3044             } else if (port->pwr_role == TYPEC_SOURCE) {
3045                 tcpm_ams_finish(port);
3046                 tcpm_set_state(port, HARD_RESET_SEND,
3047                            PD_T_SENDER_RESPONSE);
3048             } else {
3049                 tcpm_ams_finish(port);
3050             }
3051             break;
3052         default:
3053             break;
3054         }
3055     } while (port->queued_message != PD_MSG_NONE);
3056
3057     if (port->delayed_state != INVALID_STATE) {
3058         if (ktime_after(port->delayed_runtime, ktime_get())) {
3059             mod_tcpm_delayed_work(port, ktime_to_ms(ktime_sub(port->delayed_runtime,
3060                                       ktime_get())));
3061             return true;
3062         }
3063         port->delayed_state = INVALID_STATE;
3064     }
3065     return false;
3066 }
3067
3068 static int tcpm_pd_check_request(struct tcpm_port *port)
3069 {
3070     u32 pdo, rdo = port->sink_request;
3071     unsigned int max, op, pdo_max, index;
3072     enum pd_pdo_type type;
3073
3074     index = rdo_index(rdo);
3075     if (!index || index > port->nr_src_pdo)
3076         return -EINVAL;
3077
3078     pdo = port->src_pdo[index - 1];
3079     type = pdo_type(pdo);
3080     switch (type) {
3081     case PDO_TYPE_FIXED:
3082     case PDO_TYPE_VAR:
3083         max = rdo_max_current(rdo);
3084         op = rdo_op_current(rdo);
3085         pdo_max = pdo_max_current(pdo);
3086
3087         if (op > pdo_max)
3088             return -EINVAL;
3089         if (max > pdo_max && !(rdo & RDO_CAP_MISMATCH))
3090             return -EINVAL;
3091
3092         if (type == PDO_TYPE_FIXED)
3093             tcpm_log(port,
3094                  "Requested %u mV, %u mA for %u / %u mA",
3095                  pdo_fixed_voltage(pdo), pdo_max, op, max);
3096         else
3097             tcpm_log(port,
3098                  "Requested %u -> %u mV, %u mA for %u / %u mA",
3099                  pdo_min_voltage(pdo), pdo_max_voltage(pdo),
3100                  pdo_max, op, max);
3101         break;
3102     case PDO_TYPE_BATT:
3103         max = rdo_max_power(rdo);
3104         op = rdo_op_power(rdo);
3105         pdo_max = pdo_max_power(pdo);
3106
3107         if (op > pdo_max)
3108             return -EINVAL;
3109         if (max > pdo_max && !(rdo & RDO_CAP_MISMATCH))
3110             return -EINVAL;
3111         tcpm_log(port,
3112              "Requested %u -> %u mV, %u mW for %u / %u mW",
3113              pdo_min_voltage(pdo), pdo_max_voltage(pdo),
3114              pdo_max, op, max);
3115         break;
3116     default:
3117         return -EINVAL;
3118     }
3119
3120     port->op_vsafe5v = index == 1;
3121
3122     return 0;
3123 }
3124
3125 #define min_power(x, y) min(pdo_max_power(x), pdo_max_power(y))
3126 #define min_current(x, y) min(pdo_max_current(x), pdo_max_current(y))
3127
3128 static int tcpm_pd_select_pdo(struct tcpm_port *port, int *sink_pdo,
3129                   int *src_pdo)
3130 {
3131     unsigned int i, j, max_src_mv = 0, min_src_mv = 0, max_mw = 0,
3132              max_mv = 0, src_mw = 0, src_ma = 0, max_snk_mv = 0,
3133              min_snk_mv = 0;
3134     int ret = -EINVAL;
3135
3136     port->pps_data.supported = false;
3137     port->usb_type = POWER_SUPPLY_USB_TYPE_PD;
3138     power_supply_changed(port->psy);
3139
3140     /*
3141      * Select the source PDO providing the most power which has a
3142      * matchig sink cap.
3143      */
3144     for (i = 0; i < port->nr_source_caps; i++) {
3145         u32 pdo = port->source_caps[i];
3146         enum pd_pdo_type type = pdo_type(pdo);
3147
3148         switch (type) {
3149         case PDO_TYPE_FIXED:
3150             max_src_mv = pdo_fixed_voltage(pdo);
3151             min_src_mv = max_src_mv;
3152             break;
3153         case PDO_TYPE_BATT:
3154         case PDO_TYPE_VAR:
3155             max_src_mv = pdo_max_voltage(pdo);
3156             min_src_mv = pdo_min_voltage(pdo);
3157             break;
3158         case PDO_TYPE_APDO:
3159             if (pdo_apdo_type(pdo) == APDO_TYPE_PPS) {
3160                 port->pps_data.supported = true;
3161                 port->usb_type =
3162                     POWER_SUPPLY_USB_TYPE_PD_PPS;
3163                 power_supply_changed(port->psy);
3164             }
3165             continue;
3166         default:
3167             tcpm_log(port, "Invalid source PDO type, ignoring");
3168             continue;
3169         }
3170
3171         switch (type) {
3172         case PDO_TYPE_FIXED:
3173         case PDO_TYPE_VAR:
3174             src_ma = pdo_max_current(pdo);
3175             src_mw = src_ma * min_src_mv / 1000;
3176             break;
3177         case PDO_TYPE_BATT:
3178             src_mw = pdo_max_power(pdo);
3179             break;
3180         case PDO_TYPE_APDO:
3181             continue;
3182         default:
3183             tcpm_log(port, "Invalid source PDO type, ignoring");
3184             continue;
3185         }
3186
3187         for (j = 0; j < port->nr_snk_pdo; j++) {
3188             pdo = port->snk_pdo[j];
3189
3190             switch (pdo_type(pdo)) {
3191             case PDO_TYPE_FIXED:
3192                 max_snk_mv = pdo_fixed_voltage(pdo);
3193                 min_snk_mv = max_snk_mv;
3194                 break;
3195             case PDO_TYPE_BATT:
3196             case PDO_TYPE_VAR:
3197                 max_snk_mv = pdo_max_voltage(pdo);
3198                 min_snk_mv = pdo_min_voltage(pdo);
3199                 break;
3200             case PDO_TYPE_APDO:
3201                 continue;
3202             default:
3203                 tcpm_log(port, "Invalid sink PDO type, ignoring");
3204                 continue;
3205             }
3206
3207             if (max_src_mv <= max_snk_mv &&
3208                 min_src_mv >= min_snk_mv) {
3209                 /* Prefer higher voltages if available */
3210                 if ((src_mw == max_mw && min_src_mv > max_mv) ||
3211                             src_mw > max_mw) {
3212                     *src_pdo = i;
3213                     *sink_pdo = j;
3214                     max_mw = src_mw;
3215                     max_mv = min_src_mv;
3216                     ret = 0;
3217                 }
3218             }
3219         }
3220     }
3221
3222     return ret;
3223 }
3224
3225 #define min_pps_apdo_current(x, y)  \
3226     min(pdo_pps_apdo_max_current(x), pdo_pps_apdo_max_current(y))
3227
3228 static unsigned int tcpm_pd_select_pps_apdo(struct tcpm_port *port)
3229 {
3230     unsigned int i, j, max_mw = 0, max_mv = 0;
3231     unsigned int min_src_mv, max_src_mv, src_ma, src_mw;
3232     unsigned int min_snk_mv, max_snk_mv;
3233     unsigned int max_op_mv;
3234     u32 pdo, src, snk;
3235     unsigned int src_pdo = 0, snk_pdo = 0;
3236
3237     /*
3238      * Select the source PPS APDO providing the most power while staying
3239      * within the board's limits. We skip the first PDO as this is always
3240      * 5V 3A.
3241      */
3242     for (i = 1; i < port->nr_source_caps; ++i) {
3243         pdo = port->source_caps[i];
3244
3245         switch (pdo_type(pdo)) {
3246         case PDO_TYPE_APDO:
3247             if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) {
3248                 tcpm_log(port, "Not PPS APDO (source), ignoring");
3249                 continue;
3250             }
3251
3252             min_src_mv = pdo_pps_apdo_min_voltage(pdo);
3253             max_src_mv = pdo_pps_apdo_max_voltage(pdo);
3254             src_ma = pdo_pps_apdo_max_current(pdo);
3255             src_mw = (src_ma * max_src_mv) / 1000;
3256
3257             /*
3258              * Now search through the sink PDOs to find a matching
3259              * PPS APDO. Again skip the first sink PDO as this will
3260              * always be 5V 3A.
3261              */
3262             for (j = 1; j < port->nr_snk_pdo; j++) {
3263                 pdo = port->snk_pdo[j];
3264
3265                 switch (pdo_type(pdo)) {
3266                 case PDO_TYPE_APDO:
3267                     if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) {
3268                         tcpm_log(port,
3269                              "Not PPS APDO (sink), ignoring");
3270                         continue;
3271                     }
3272
3273                     min_snk_mv =
3274                         pdo_pps_apdo_min_voltage(pdo);
3275                     max_snk_mv =
3276                         pdo_pps_apdo_max_voltage(pdo);
3277                     break;
3278                 default:
3279                     tcpm_log(port,
3280                          "Not APDO type (sink), ignoring");
3281                     continue;
3282                 }
3283
3284                 if (min_src_mv <= max_snk_mv &&
3285                     max_src_mv >= min_snk_mv) {
3286                     max_op_mv = min(max_src_mv, max_snk_mv);
3287                     src_mw = (max_op_mv * src_ma) / 1000;
3288                     /* Prefer higher voltages if available */
3289                     if ((src_mw == max_mw &&
3290                          max_op_mv > max_mv) ||
3291                         src_mw > max_mw) {
3292                         src_pdo = i;
3293                         snk_pdo = j;
3294                         max_mw = src_mw;
3295                         max_mv = max_op_mv;
3296                     }
3297                 }
3298             }
3299
3300             break;
3301         default:
3302             tcpm_log(port, "Not APDO type (source), ignoring");
3303             continue;
3304         }
3305     }
3306
3307     if (src_pdo) {
3308         src = port->source_caps[src_pdo];
3309         snk = port->snk_pdo[snk_pdo];
3310
3311         port->pps_data.req_min_volt = max(pdo_pps_apdo_min_voltage(src),
3312                           pdo_pps_apdo_min_voltage(snk));
3313         port->pps_data.req_max_volt = min(pdo_pps_apdo_max_voltage(src),
3314                           pdo_pps_apdo_max_voltage(snk));
3315         port->pps_data.req_max_curr = min_pps_apdo_current(src, snk);
3316         port->pps_data.req_out_volt = min(port->pps_data.req_max_volt,
3317                           max(port->pps_data.req_min_volt,
3318                               port->pps_data.req_out_volt));
3319         port->pps_data.req_op_curr = min(port->pps_data.req_max_curr,
3320                          port->pps_data.req_op_curr);
3321     }
3322
3323     return src_pdo;
3324 }
3325
3326 static int tcpm_pd_build_request(struct tcpm_port *port, u32 *rdo)
3327 {
3328     unsigned int mv, ma, mw, flags;
3329     unsigned int max_ma, max_mw;
3330     enum pd_pdo_type type;
3331     u32 pdo, matching_snk_pdo;
3332     int src_pdo_index = 0;
3333     int snk_pdo_index = 0;
3334     int ret;
3335
3336     ret = tcpm_pd_select_pdo(port, &snk_pdo_index, &src_pdo_index);
3337     if (ret < 0)
3338         return ret;
3339
3340     pdo = port->source_caps[src_pdo_index];
3341     matching_snk_pdo = port->snk_pdo[snk_pdo_index];
3342     type = pdo_type(pdo);
3343
3344     switch (type) {
3345     case PDO_TYPE_FIXED:
3346         mv = pdo_fixed_voltage(pdo);
3347         break;
3348     case PDO_TYPE_BATT:
3349     case PDO_TYPE_VAR:
3350         mv = pdo_min_voltage(pdo);
3351         break;
3352     default:
3353         tcpm_log(port, "Invalid PDO selected!");
3354         return -EINVAL;
3355     }
3356
3357     /* Select maximum available current within the sink pdo's limit */
3358     if (type == PDO_TYPE_BATT) {
3359         mw = min_power(pdo, matching_snk_pdo);
3360         ma = 1000 * mw / mv;
3361     } else {
3362         ma = min_current(pdo, matching_snk_pdo);
3363         mw = ma * mv / 1000;
3364     }
3365
3366     flags = RDO_USB_COMM | RDO_NO_SUSPEND;
3367
3368     /* Set mismatch bit if offered power is less than operating power */
3369     max_ma = ma;
3370     max_mw = mw;
3371     if (mw < port->operating_snk_mw) {
3372         flags |= RDO_CAP_MISMATCH;
3373         if (type == PDO_TYPE_BATT &&
3374             (pdo_max_power(matching_snk_pdo) > pdo_max_power(pdo)))
3375             max_mw = pdo_max_power(matching_snk_pdo);
3376         else if (pdo_max_current(matching_snk_pdo) >
3377              pdo_max_current(pdo))
3378             max_ma = pdo_max_current(matching_snk_pdo);
3379     }
3380
3381     tcpm_log(port, "cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d",
3382          port->cc_req, port->cc1, port->cc2, port->vbus_source,
3383          port->vconn_role == TYPEC_SOURCE ? "source" : "sink",
3384          port->polarity);
3385
3386     if (type == PDO_TYPE_BATT) {
3387         *rdo = RDO_BATT(src_pdo_index + 1, mw, max_mw, flags);
3388
3389         tcpm_log(port, "Requesting PDO %d: %u mV, %u mW%s",
3390              src_pdo_index, mv, mw,
3391              flags & RDO_CAP_MISMATCH ? " [mismatch]" : "");
3392     } else {
3393         *rdo = RDO_FIXED(src_pdo_index + 1, ma, max_ma, flags);
3394
3395         tcpm_log(port, "Requesting PDO %d: %u mV, %u mA%s",
3396              src_pdo_index, mv, ma,
3397              flags & RDO_CAP_MISMATCH ? " [mismatch]" : "");
3398     }
3399
3400     port->req_current_limit = ma;
3401     port->req_supply_voltage = mv;
3402
3403     return 0;
3404 }
3405
3406 static int tcpm_pd_send_request(struct tcpm_port *port)
3407 {
3408     struct pd_message msg;
3409     int ret;
3410     u32 rdo;
3411
3412     ret = tcpm_pd_build_request(port, &rdo);
3413     if (ret < 0)
3414         return ret;
3415
3416     /*
3417      * Relax the threshold as voltage will be adjusted after Accept Message plus tSrcTransition.
3418      * It is safer to modify the threshold here.
3419      */
3420     tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, 0);
3421
3422     memset(&msg, 0, sizeof(msg));
3423     msg.header = PD_HEADER_LE(PD_DATA_REQUEST,
3424                   port->pwr_role,
3425                   port->data_role,
3426                   port->negotiated_rev,
3427                   port->message_id, 1);
3428     msg.payload[0] = cpu_to_le32(rdo);
3429
3430     return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
3431 }
3432
3433 static int tcpm_pd_build_pps_request(struct tcpm_port *port, u32 *rdo)
3434 {
3435     unsigned int out_mv, op_ma, op_mw, max_mv, max_ma, flags;
3436     enum pd_pdo_type type;
3437     unsigned int src_pdo_index;
3438     u32 pdo;
3439
3440     src_pdo_index = tcpm_pd_select_pps_apdo(port);
3441     if (!src_pdo_index)
3442         return -EOPNOTSUPP;
3443
3444     pdo = port->source_caps[src_pdo_index];
3445     type = pdo_type(pdo);
3446
3447     switch (type) {
3448     case PDO_TYPE_APDO:
3449         if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) {
3450             tcpm_log(port, "Invalid APDO selected!");
3451             return -EINVAL;
3452         }
3453         max_mv = port->pps_data.req_max_volt;
3454         max_ma = port->pps_data.req_max_curr;
3455         out_mv = port->pps_data.req_out_volt;
3456         op_ma = port->pps_data.req_op_curr;
3457         break;
3458     default:
3459         tcpm_log(port, "Invalid PDO selected!");
3460         return -EINVAL;
3461     }
3462
3463     flags = RDO_USB_COMM | RDO_NO_SUSPEND;
3464
3465     op_mw = (op_ma * out_mv) / 1000;
3466     if (op_mw < port->operating_snk_mw) {
3467         /*
3468          * Try raising current to meet power needs. If that's not enough
3469          * then try upping the voltage. If that's still not enough
3470          * then we've obviously chosen a PPS APDO which really isn't
3471          * suitable so abandon ship.
3472          */
3473         op_ma = (port->operating_snk_mw * 1000) / out_mv;
3474         if ((port->operating_snk_mw * 1000) % out_mv)
3475             ++op_ma;
3476         op_ma += RDO_PROG_CURR_MA_STEP - (op_ma % RDO_PROG_CURR_MA_STEP);
3477
3478         if (op_ma > max_ma) {
3479             op_ma = max_ma;
3480             out_mv = (port->operating_snk_mw * 1000) / op_ma;
3481             if ((port->operating_snk_mw * 1000) % op_ma)
3482                 ++out_mv;
3483             out_mv += RDO_PROG_VOLT_MV_STEP -
3484                   (out_mv % RDO_PROG_VOLT_MV_STEP);
3485
3486             if (out_mv > max_mv) {
3487                 tcpm_log(port, "Invalid PPS APDO selected!");
3488                 return -EINVAL;
3489             }
3490         }
3491     }
3492
3493     tcpm_log(port, "cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d",
3494          port->cc_req, port->cc1, port->cc2, port->vbus_source,
3495          port->vconn_role == TYPEC_SOURCE ? "source" : "sink",
3496          port->polarity);
3497
3498     *rdo = RDO_PROG(src_pdo_index + 1, out_mv, op_ma, flags);
3499
3500     tcpm_log(port, "Requesting APDO %d: %u mV, %u mA",
3501          src_pdo_index, out_mv, op_ma);
3502
3503     port->pps_data.req_op_curr = op_ma;
3504     port->pps_data.req_out_volt = out_mv;
3505
3506     return 0;
3507 }
3508
3509 static int tcpm_pd_send_pps_request(struct tcpm_port *port)
3510 {
3511     struct pd_message msg;
3512     int ret;
3513     u32 rdo;
3514
3515     ret = tcpm_pd_build_pps_request(port, &rdo);
3516     if (ret < 0)
3517         return ret;
3518
3519     /* Relax the threshold as voltage will be adjusted right after Accept Message. */
3520     tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, 0);
3521
3522     memset(&msg, 0, sizeof(msg));
3523     msg.header = PD_HEADER_LE(PD_DATA_REQUEST,
3524                   port->pwr_role,
3525                   port->data_role,
3526                   port->negotiated_rev,
3527                   port->message_id, 1);
3528     msg.payload[0] = cpu_to_le32(rdo);
3529
3530     return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
3531 }
3532
3533 static int tcpm_set_vbus(struct tcpm_port *port, bool enable)
3534 {
3535     int ret;
3536
3537     if (enable && port->vbus_charge)
3538         return -EINVAL;
3539
3540     tcpm_log(port, "vbus:=%d charge=%d", enable, port->vbus_charge);
3541
3542     ret = port->tcpc->set_vbus(port->tcpc, enable, port->vbus_charge);
3543     if (ret < 0)
3544         return ret;
3545
3546     port->vbus_source = enable;
3547     return 0;
3548 }
3549
3550 static int tcpm_set_charge(struct tcpm_port *port, bool charge)
3551 {
3552     int ret;
3553
3554     if (charge && port->vbus_source)
3555         return -EINVAL;
3556
3557     if (charge != port->vbus_charge) {
3558         tcpm_log(port, "vbus=%d charge:=%d", port->vbus_source, charge);
3559         ret = port->tcpc->set_vbus(port->tcpc, port->vbus_source,
3560                        charge);
3561         if (ret < 0)
3562             return ret;
3563     }
3564     port->vbus_charge = charge;
3565     power_supply_changed(port->psy);
3566     return 0;
3567 }
3568
3569 static bool tcpm_start_toggling(struct tcpm_port *port, enum typec_cc_status cc)
3570 {
3571     int ret;
3572
3573     if (!port->tcpc->start_toggling)
3574         return false;
3575
3576     tcpm_log_force(port, "Start toggling");
3577     ret = port->tcpc->start_toggling(port->tcpc, port->port_type, cc);
3578     return ret == 0;
3579 }
3580
3581 static int tcpm_init_vbus(struct tcpm_port *port)
3582 {
3583     int ret;
3584
3585     ret = port->tcpc->set_vbus(port->tcpc, false, false);
3586     port->vbus_source = false;
3587     port->vbus_charge = false;
3588     return ret;
3589 }
3590
3591 static int tcpm_init_vconn(struct tcpm_port *port)
3592 {
3593     int ret;
3594
3595     ret = port->tcpc->set_vconn(port->tcpc, false);
3596     port->vconn_role = TYPEC_SINK;
3597     return ret;
3598 }
3599
3600 static void tcpm_typec_connect(struct tcpm_port *port)
3601 {
3602     if (!port->connected) {
3603         /* Make sure we don't report stale identity information */
3604         memset(&port->partner_ident, 0, sizeof(port->partner_ident));
3605         port->partner_desc.usb_pd = port->pd_capable;
3606         if (tcpm_port_is_debug(port))
3607             port->partner_desc.accessory = TYPEC_ACCESSORY_DEBUG;
3608         else if (tcpm_port_is_audio(port))
3609             port->partner_desc.accessory = TYPEC_ACCESSORY_AUDIO;
3610         else
3611             port->partner_desc.accessory = TYPEC_ACCESSORY_NONE;
3612         port->partner = typec_register_partner(port->typec_port,
3613                                &port->partner_desc);
3614         port->connected = true;
3615         typec_partner_set_usb_power_delivery(port->partner, port->partner_pd);
3616     }
3617 }
3618
3619 static int tcpm_src_attach(struct tcpm_port *port)
3620 {
3621     enum typec_cc_polarity polarity =
3622                 port->cc2 == TYPEC_CC_RD ? TYPEC_POLARITY_CC2
3623                              : TYPEC_POLARITY_CC1;
3624     int ret;
3625
3626     if (port->attached)
3627         return 0;
3628
3629     ret = tcpm_set_polarity(port, polarity);
3630     if (ret < 0)
3631         return ret;
3632
3633     tcpm_enable_auto_vbus_discharge(port, true);
3634
3635     ret = tcpm_set_roles(port, true, TYPEC_SOURCE, tcpm_data_role_for_source(port));
3636     if (ret < 0)
3637         return ret;
3638
3639     if (port->pd_supported) {
3640         ret = port->tcpc->set_pd_rx(port->tcpc, true);
3641         if (ret < 0)
3642             goto out_disable_mux;
3643     }
3644
3645     /*
3646      * USB Type-C specification, version 1.2,
3647      * chapter 4.5.2.2.8.1 (Attached.SRC Requirements)
3648      * Enable VCONN only if the non-RD port is set to RA.
3649      */
3650     if ((polarity == TYPEC_POLARITY_CC1 && port->cc2 == TYPEC_CC_RA) ||
3651         (polarity == TYPEC_POLARITY_CC2 && port->cc1 == TYPEC_CC_RA)) {
3652         ret = tcpm_set_vconn(port, true);
3653         if (ret < 0)
3654             goto out_disable_pd;
3655     }
3656
3657     ret = tcpm_set_vbus(port, true);
3658     if (ret < 0)
3659         goto out_disable_vconn;
3660
3661     port->pd_capable = false;
3662
3663     port->partner = NULL;
3664
3665     port->attached = true;
3666     port->send_discover = true;
3667
3668     return 0;
3669
3670 out_disable_vconn:
3671     tcpm_set_vconn(port, false);
3672 out_disable_pd:
3673     if (port->pd_supported)
3674         port->tcpc->set_pd_rx(port->tcpc, false);
3675 out_disable_mux:
3676     tcpm_mux_set(port, TYPEC_STATE_SAFE, USB_ROLE_NONE,
3677              TYPEC_ORIENTATION_NONE);
3678     return ret;
3679 }
3680
3681 static void tcpm_typec_disconnect(struct tcpm_port *port)
3682 {
3683     if (port->connected) {
3684         typec_partner_set_usb_power_delivery(port->partner, NULL);
3685         typec_unregister_partner(port->partner);
3686         port->partner = NULL;
3687         port->connected = false;
3688     }
3689 }
3690
3691 static void tcpm_unregister_altmodes(struct tcpm_port *port)
3692 {
3693     struct pd_mode_data *modep = &port->mode_data;
3694     int i;
3695
3696     for (i = 0; i < modep->altmodes; i++) {
3697         typec_unregister_altmode(port->partner_altmode[i]);
3698         port->partner_altmode[i] = NULL;
3699     }
3700
3701     memset(modep, 0, sizeof(*modep));
3702 }
3703
3704 static void tcpm_set_partner_usb_comm_capable(struct tcpm_port *port, bool capable)
3705 {
3706     tcpm_log(port, "Setting usb_comm capable %s", capable ? "true" : "false");
3707
3708     if (port->tcpc->set_partner_usb_comm_capable)
3709         port->tcpc->set_partner_usb_comm_capable(port->tcpc, capable);
3710 }
3711
3712 static void tcpm_reset_port(struct tcpm_port *port)
3713 {
3714     tcpm_enable_auto_vbus_discharge(port, false);
3715     port->in_ams = false;
3716     port->ams = NONE_AMS;
3717     port->vdm_sm_running = false;
3718     tcpm_unregister_altmodes(port);
3719     tcpm_typec_disconnect(port);
3720     port->attached = false;
3721     port->pd_capable = false;
3722     port->pps_data.supported = false;
3723     tcpm_set_partner_usb_comm_capable(port, false);
3724
3725     /*
3726      * First Rx ID should be 0; set this to a sentinel of -1 so that
3727      * we can check tcpm_pd_rx_handler() if we had seen it before.
3728      */
3729     port->rx_msgid = -1;
3730
3731     port->tcpc->set_pd_rx(port->tcpc, false);
3732     tcpm_init_vbus(port);   /* also disables charging */
3733     tcpm_init_vconn(port);
3734     tcpm_set_current_limit(port, 0, 0);
3735     tcpm_set_polarity(port, TYPEC_POLARITY_CC1);
3736     tcpm_mux_set(port, TYPEC_STATE_SAFE, USB_ROLE_NONE,
3737              TYPEC_ORIENTATION_NONE);
3738     tcpm_set_attached_state(port, false);
3739     port->try_src_count = 0;
3740     port->try_snk_count = 0;
3741     port->usb_type = POWER_SUPPLY_USB_TYPE_C;
3742     power_supply_changed(port->psy);
3743     port->nr_sink_caps = 0;
3744     port->sink_cap_done = false;
3745     if (port->tcpc->enable_frs)
3746         port->tcpc->enable_frs(port->tcpc, false);
3747
3748     usb_power_delivery_unregister_capabilities(port->partner_sink_caps);
3749     port->partner_sink_caps = NULL;
3750     usb_power_delivery_unregister_capabilities(port->partner_source_caps);
3751     port->partner_source_caps = NULL;
3752     usb_power_delivery_unregister(port->partner_pd);
3753     port->partner_pd = NULL;
3754 }
3755
3756 static void tcpm_detach(struct tcpm_port *port)
3757 {
3758     if (tcpm_port_is_disconnected(port))
3759         port->hard_reset_count = 0;
3760
3761     if (!port->attached)
3762         return;
3763
3764     if (port->tcpc->set_bist_data) {
3765         tcpm_log(port, "disable BIST MODE TESTDATA");
3766         port->tcpc->set_bist_data(port->tcpc, false);
3767     }
3768
3769     tcpm_reset_port(port);
3770 }
3771
3772 static void tcpm_src_detach(struct tcpm_port *port)
3773 {
3774     tcpm_detach(port);
3775 }
3776
3777 static int tcpm_snk_attach(struct tcpm_port *port)
3778 {
3779     int ret;
3780
3781     if (port->attached)
3782         return 0;
3783
3784     ret = tcpm_set_polarity(port, port->cc2 != TYPEC_CC_OPEN ?
3785                 TYPEC_POLARITY_CC2 : TYPEC_POLARITY_CC1);
3786     if (ret < 0)
3787         return ret;
3788
3789     tcpm_enable_auto_vbus_discharge(port, true);
3790
3791     ret = tcpm_set_roles(port, true, TYPEC_SINK, tcpm_data_role_for_sink(port));
3792     if (ret < 0)
3793         return ret;
3794
3795     port->pd_capable = false;
3796
3797     port->partner = NULL;
3798
3799     port->attached = true;
3800     port->send_discover = true;
3801
3802     return 0;
3803 }
3804
3805 static void tcpm_snk_detach(struct tcpm_port *port)
3806 {
3807     tcpm_detach(port);
3808 }
3809
3810 static int tcpm_acc_attach(struct tcpm_port *port)
3811 {
3812     int ret;
3813
3814     if (port->attached)
3815         return 0;
3816
3817     ret = tcpm_set_roles(port, true, TYPEC_SOURCE,
3818                  tcpm_data_role_for_source(port));
3819     if (ret < 0)
3820         return ret;
3821
3822     port->partner = NULL;
3823
3824     tcpm_typec_connect(port);
3825
3826     port->attached = true;
3827
3828     return 0;
3829 }
3830
3831 static void tcpm_acc_detach(struct tcpm_port *port)
3832 {
3833     tcpm_detach(port);
3834 }
3835
3836 static inline enum tcpm_state hard_reset_state(struct tcpm_port *port)
3837 {
3838     if (port->hard_reset_count < PD_N_HARD_RESET_COUNT)
3839         return HARD_RESET_SEND;
3840     if (port->pd_capable)
3841         return ERROR_RECOVERY;
3842     if (port->pwr_role == TYPEC_SOURCE)
3843         return SRC_UNATTACHED;
3844     if (port->state == SNK_WAIT_CAPABILITIES)
3845         return SNK_READY;
3846     return SNK_UNATTACHED;
3847 }
3848
3849 static inline enum tcpm_state unattached_state(struct tcpm_port *port)
3850 {
3851     if (port->port_type == TYPEC_PORT_DRP) {
3852         if (port->pwr_role == TYPEC_SOURCE)
3853             return SRC_UNATTACHED;
3854         else
3855             return SNK_UNATTACHED;
3856     } else if (port->port_type == TYPEC_PORT_SRC) {
3857         return SRC_UNATTACHED;
3858     }
3859
3860     return SNK_UNATTACHED;
3861 }
3862
3863 static void tcpm_swap_complete(struct tcpm_port *port, int result)
3864 {
3865     if (port->swap_pending) {
3866         port->swap_status = result;
3867         port->swap_pending = false;
3868         port->non_pd_role_swap = false;
3869         complete(&port->swap_complete);
3870     }
3871 }
3872
3873 static enum typec_pwr_opmode tcpm_get_pwr_opmode(enum typec_cc_status cc)
3874 {
3875     switch (cc) {
3876     case TYPEC_CC_RP_1_5:
3877         return TYPEC_PWR_MODE_1_5A;
3878     case TYPEC_CC_RP_3_0:
3879         return TYPEC_PWR_MODE_3_0A;
3880     case TYPEC_CC_RP_DEF:
3881     default:
3882         return TYPEC_PWR_MODE_USB;
3883     }
3884 }
3885
3886 static enum typec_cc_status tcpm_pwr_opmode_to_rp(enum typec_pwr_opmode opmode)
3887 {
3888     switch (opmode) {
3889     case TYPEC_PWR_MODE_USB:
3890         return TYPEC_CC_RP_DEF;
3891     case TYPEC_PWR_MODE_1_5A:
3892         return TYPEC_CC_RP_1_5;
3893     case TYPEC_PWR_MODE_3_0A:
3894     case TYPEC_PWR_MODE_PD:
3895     default:
3896         return TYPEC_CC_RP_3_0;
3897     }
3898 }
3899
3900 static void run_state_machine(struct tcpm_port *port)
3901 {
3902     int ret;
3903     enum typec_pwr_opmode opmode;
3904     unsigned int msecs;
3905     enum tcpm_state upcoming_state;
3906
3907     port->enter_state = port->state;
3908     switch (port->state) {
3909     case TOGGLING:
3910         break;
3911     /* SRC states */
3912     case SRC_UNATTACHED:
3913         if (!port->non_pd_role_swap)
3914             tcpm_swap_complete(port, -ENOTCONN);
3915         tcpm_src_detach(port);
3916         if (tcpm_start_toggling(port, tcpm_rp_cc(port))) {
3917             tcpm_set_state(port, TOGGLING, 0);
3918             break;
3919         }
3920         tcpm_set_cc(port, tcpm_rp_cc(port));
3921         if (port->port_type == TYPEC_PORT_DRP)
3922             tcpm_set_state(port, SNK_UNATTACHED, PD_T_DRP_SNK);
3923         break;
3924     case SRC_ATTACH_WAIT:
3925         if (tcpm_port_is_debug(port))
3926             tcpm_set_state(port, DEBUG_ACC_ATTACHED,
3927                        PD_T_CC_DEBOUNCE);
3928         else if (tcpm_port_is_audio(port))
3929             tcpm_set_state(port, AUDIO_ACC_ATTACHED,
3930                        PD_T_CC_DEBOUNCE);
3931         else if (tcpm_port_is_source(port) && port->vbus_vsafe0v)
3932             tcpm_set_state(port,
3933                        tcpm_try_snk(port) ? SNK_TRY
3934                               : SRC_ATTACHED,
3935                        PD_T_CC_DEBOUNCE);
3936         break;
3937
3938     case SNK_TRY:
3939         port->try_snk_count++;
3940         /*
3941          * Requirements:
3942          * - Do not drive vconn or vbus
3943          * - Terminate CC pins (both) to Rd
3944          * Action:
3945          * - Wait for tDRPTry (PD_T_DRP_TRY).
3946          *   Until then, ignore any state changes.
3947          */
3948         tcpm_set_cc(port, TYPEC_CC_RD);
3949         tcpm_set_state(port, SNK_TRY_WAIT, PD_T_DRP_TRY);
3950         break;
3951     case SNK_TRY_WAIT:
3952         if (tcpm_port_is_sink(port)) {
3953             tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE, 0);
3954         } else {
3955             tcpm_set_state(port, SRC_TRYWAIT, 0);
3956             port->max_wait = 0;
3957         }
3958         break;
3959     case SNK_TRY_WAIT_DEBOUNCE:
3960         tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS,
3961                    PD_T_TRY_CC_DEBOUNCE);
3962         break;
3963     case SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS:
3964         if (port->vbus_present && tcpm_port_is_sink(port))
3965             tcpm_set_state(port, SNK_ATTACHED, 0);
3966         else
3967             port->max_wait = 0;
3968         break;
3969     case SRC_TRYWAIT:
3970         tcpm_set_cc(port, tcpm_rp_cc(port));
3971         if (port->max_wait == 0) {
3972             port->max_wait = jiffies +
3973                      msecs_to_jiffies(PD_T_DRP_TRY);
3974             tcpm_set_state(port, SRC_TRYWAIT_UNATTACHED,
3975                        PD_T_DRP_TRY);
3976         } else {
3977             if (time_is_after_jiffies(port->max_wait))
3978                 tcpm_set_state(port, SRC_TRYWAIT_UNATTACHED,
3979                            jiffies_to_msecs(port->max_wait -
3980                                 jiffies));
3981             else
3982                 tcpm_set_state(port, SNK_UNATTACHED, 0);
3983         }
3984         break;
3985     case SRC_TRYWAIT_DEBOUNCE:
3986         tcpm_set_state(port, SRC_ATTACHED, PD_T_CC_DEBOUNCE);
3987         break;
3988     case SRC_TRYWAIT_UNATTACHED:
3989         tcpm_set_state(port, SNK_UNATTACHED, 0);
3990         break;
3991
3992     case SRC_ATTACHED:
3993         ret = tcpm_src_attach(port);
3994         tcpm_set_state(port, SRC_UNATTACHED,
3995                    ret < 0 ? 0 : PD_T_PS_SOURCE_ON);
3996         break;
3997     case SRC_STARTUP:
3998         opmode =  tcpm_get_pwr_opmode(tcpm_rp_cc(port));
3999         typec_set_pwr_opmode(port->typec_port, opmode);
4000         port->pwr_opmode = TYPEC_PWR_MODE_USB;
4001         port->caps_count = 0;
4002         port->negotiated_rev = PD_MAX_REV;
4003         port->message_id = 0;
4004         port->rx_msgid = -1;
4005         port->explicit_contract = false;
4006         /* SNK -> SRC POWER/FAST_ROLE_SWAP finished */
4007         if (port->ams == POWER_ROLE_SWAP ||
4008             port->ams == FAST_ROLE_SWAP)
4009             tcpm_ams_finish(port);
4010         if (!port->pd_supported) {
4011             tcpm_set_state(port, SRC_READY, 0);
4012             break;
4013         }
4014         port->upcoming_state = SRC_SEND_CAPABILITIES;
4015         tcpm_ams_start(port, POWER_NEGOTIATION);
4016         break;
4017     case SRC_SEND_CAPABILITIES:
4018         port->caps_count++;
4019         if (port->caps_count > PD_N_CAPS_COUNT) {
4020             tcpm_set_state(port, SRC_READY, 0);
4021             break;
4022         }
4023         ret = tcpm_pd_send_source_caps(port);
4024         if (ret < 0) {
4025             tcpm_set_state(port, SRC_SEND_CAPABILITIES,
4026                        PD_T_SEND_SOURCE_CAP);
4027         } else {
4028             /*
4029              * Per standard, we should clear the reset counter here.
4030              * However, that can result in state machine hang-ups.
4031              * Reset it only in READY state to improve stability.
4032              */
4033             /* port->hard_reset_count = 0; */
4034             port->caps_count = 0;
4035             port->pd_capable = true;
4036             tcpm_set_state_cond(port, SRC_SEND_CAPABILITIES_TIMEOUT,
4037                         PD_T_SEND_SOURCE_CAP);
4038         }
4039         break;
4040     case SRC_SEND_CAPABILITIES_TIMEOUT:
4041         /*
4042          * Error recovery for a PD_DATA_SOURCE_CAP reply timeout.
4043          *
4044          * PD 2.0 sinks are supposed to accept src-capabilities with a
4045          * 3.0 header and simply ignore any src PDOs which the sink does
4046          * not understand such as PPS but some 2.0 sinks instead ignore
4047          * the entire PD_DATA_SOURCE_CAP message, causing contract
4048          * negotiation to fail.
4049          *
4050          * After PD_N_HARD_RESET_COUNT hard-reset attempts, we try
4051          * sending src-capabilities with a lower PD revision to
4052          * make these broken sinks work.
4053          */
4054         if (port->hard_reset_count < PD_N_HARD_RESET_COUNT) {
4055             tcpm_set_state(port, HARD_RESET_SEND, 0);
4056         } else if (port->negotiated_rev > PD_REV20) {
4057             port->negotiated_rev--;
4058             port->hard_reset_count = 0;
4059             tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
4060         } else {
4061             tcpm_set_state(port, hard_reset_state(port), 0);
4062         }
4063         break;
4064     case SRC_NEGOTIATE_CAPABILITIES:
4065         ret = tcpm_pd_check_request(port);
4066         if (ret < 0) {
4067             tcpm_pd_send_control(port, PD_CTRL_REJECT);
4068             if (!port->explicit_contract) {
4069                 tcpm_set_state(port,
4070                            SRC_WAIT_NEW_CAPABILITIES, 0);
4071             } else {
4072                 tcpm_set_state(port, SRC_READY, 0);
4073             }
4074         } else {
4075             tcpm_pd_send_control(port, PD_CTRL_ACCEPT);
4076             tcpm_set_partner_usb_comm_capable(port,
4077                               !!(port->sink_request & RDO_USB_COMM));
4078             tcpm_set_state(port, SRC_TRANSITION_SUPPLY,
4079                        PD_T_SRC_TRANSITION);
4080         }
4081         break;
4082     case SRC_TRANSITION_SUPPLY:
4083         /* XXX: regulator_set_voltage(vbus, ...) */
4084         tcpm_pd_send_control(port, PD_CTRL_PS_RDY);
4085         port->explicit_contract = true;
4086         typec_set_pwr_opmode(port->typec_port, TYPEC_PWR_MODE_PD);
4087         port->pwr_opmode = TYPEC_PWR_MODE_PD;
4088         tcpm_set_state_cond(port, SRC_READY, 0);
4089         break;
4090     case SRC_READY:
4091 #if 1
4092         port->hard_reset_count = 0;
4093 #endif
4094         port->try_src_count = 0;
4095
4096         tcpm_swap_complete(port, 0);
4097         tcpm_typec_connect(port);
4098
4099         if (port->ams != NONE_AMS)
4100             tcpm_ams_finish(port);
4101         if (port->next_ams != NONE_AMS) {
4102             port->ams = port->next_ams;
4103             port->next_ams = NONE_AMS;
4104         }
4105
4106         /*
4107          * If previous AMS is interrupted, switch to the upcoming
4108          * state.
4109          */
4110         if (port->upcoming_state != INVALID_STATE) {
4111             upcoming_state = port->upcoming_state;
4112             port->upcoming_state = INVALID_STATE;
4113             tcpm_set_state(port, upcoming_state, 0);
4114             break;
4115         }
4116
4117         /*
4118          * 6.4.4.3.1 Discover Identity
4119          * "The Discover Identity Command Shall only be sent to SOP when there is an
4120          * Explicit Contract."
4121          * For now, this driver only supports SOP for DISCOVER_IDENTITY, thus using
4122          * port->explicit_contract to decide whether to send the command.
4123          */
4124         if (port->explicit_contract)
4125             mod_send_discover_delayed_work(port, 0);
4126         else
4127             port->send_discover = false;
4128
4129         /*
4130          * 6.3.5
4131          * Sending ping messages is not necessary if
4132          * - the source operates at vSafe5V
4133          * or
4134          * - The system is not operating in PD mode
4135          * or
4136          * - Both partners are connected using a Type-C connector
4137          *
4138          * There is no actual need to send PD messages since the local
4139          * port type-c and the spec does not clearly say whether PD is
4140          * possible when type-c is connected to Type-A/B
4141          */
4142         break;
4143     case SRC_WAIT_NEW_CAPABILITIES:
4144         /* Nothing to do... */
4145         break;
4146
4147     /* SNK states */
4148     case SNK_UNATTACHED:
4149         if (!port->non_pd_role_swap)
4150             tcpm_swap_complete(port, -ENOTCONN);
4151         tcpm_pps_complete(port, -ENOTCONN);
4152         tcpm_snk_detach(port);
4153         if (tcpm_start_toggling(port, TYPEC_CC_RD)) {
4154             tcpm_set_state(port, TOGGLING, 0);
4155             break;
4156         }
4157         tcpm_set_cc(port, TYPEC_CC_RD);
4158         if (port->port_type == TYPEC_PORT_DRP)
4159             tcpm_set_state(port, SRC_UNATTACHED, PD_T_DRP_SRC);
4160         break;
4161     case SNK_ATTACH_WAIT:
4162         if ((port->cc1 == TYPEC_CC_OPEN &&
4163              port->cc2 != TYPEC_CC_OPEN) ||
4164             (port->cc1 != TYPEC_CC_OPEN &&
4165              port->cc2 == TYPEC_CC_OPEN))
4166             tcpm_set_state(port, SNK_DEBOUNCED,
4167                        PD_T_CC_DEBOUNCE);
4168         else if (tcpm_port_is_disconnected(port))
4169             tcpm_set_state(port, SNK_UNATTACHED,
4170                        PD_T_PD_DEBOUNCE);
4171         break;
4172     case SNK_DEBOUNCED:
4173         if (tcpm_port_is_disconnected(port))
4174             tcpm_set_state(port, SNK_UNATTACHED,
4175                        PD_T_PD_DEBOUNCE);
4176         else if (port->vbus_present)
4177             tcpm_set_state(port,
4178                        tcpm_try_src(port) ? SRC_TRY
4179                               : SNK_ATTACHED,
4180                        0);
4181         break;
4182     case SRC_TRY:
4183         port->try_src_count++;
4184         tcpm_set_cc(port, tcpm_rp_cc(port));
4185         port->max_wait = 0;
4186         tcpm_set_state(port, SRC_TRY_WAIT, 0);
4187         break;
4188     case SRC_TRY_WAIT:
4189         if (port->max_wait == 0) {
4190             port->max_wait = jiffies +
4191                      msecs_to_jiffies(PD_T_DRP_TRY);
4192             msecs = PD_T_DRP_TRY;
4193         } else {
4194             if (time_is_after_jiffies(port->max_wait))
4195                 msecs = jiffies_to_msecs(port->max_wait -
4196                              jiffies);
4197             else
4198                 msecs = 0;
4199         }
4200         tcpm_set_state(port, SNK_TRYWAIT, msecs);
4201         break;
4202     case SRC_TRY_DEBOUNCE:
4203         tcpm_set_state(port, SRC_ATTACHED, PD_T_PD_DEBOUNCE);
4204         break;
4205     case SNK_TRYWAIT:
4206         tcpm_set_cc(port, TYPEC_CC_RD);
4207         tcpm_set_state(port, SNK_TRYWAIT_VBUS, PD_T_CC_DEBOUNCE);
4208         break;
4209     case SNK_TRYWAIT_VBUS:
4210         /*
4211          * TCPM stays in this state indefinitely until VBUS
4212          * is detected as long as Rp is not detected for
4213          * more than a time period of tPDDebounce.
4214          */
4215         if (port->vbus_present && tcpm_port_is_sink(port)) {
4216             tcpm_set_state(port, SNK_ATTACHED, 0);
4217             break;
4218         }
4219         if (!tcpm_port_is_sink(port))
4220             tcpm_set_state(port, SNK_TRYWAIT_DEBOUNCE, 0);
4221         break;
4222     case SNK_TRYWAIT_DEBOUNCE:
4223         tcpm_set_state(port, SNK_UNATTACHED, PD_T_PD_DEBOUNCE);
4224         break;
4225     case SNK_ATTACHED:
4226         ret = tcpm_snk_attach(port);
4227         if (ret < 0)
4228             tcpm_set_state(port, SNK_UNATTACHED, 0);
4229         else
4230             tcpm_set_state(port, SNK_STARTUP, 0);
4231         break;
4232     case SNK_STARTUP:
4233         opmode =  tcpm_get_pwr_opmode(port->polarity ?
4234                           port->cc2 : port->cc1);
4235         typec_set_pwr_opmode(port->typec_port, opmode);
4236         port->pwr_opmode = TYPEC_PWR_MODE_USB;
4237         port->negotiated_rev = PD_MAX_REV;
4238         port->message_id = 0;
4239         port->rx_msgid = -1;
4240         port->explicit_contract = false;
4241
4242         if (port->ams == POWER_ROLE_SWAP ||
4243             port->ams == FAST_ROLE_SWAP)
4244             /* SRC -> SNK POWER/FAST_ROLE_SWAP finished */
4245             tcpm_ams_finish(port);
4246
4247         tcpm_set_state(port, SNK_DISCOVERY, 0);
4248         break;
4249     case SNK_DISCOVERY:
4250         if (port->vbus_present) {
4251             u32 current_lim = tcpm_get_current_limit(port);
4252
4253             if (port->slow_charger_loop && (current_lim > PD_P_SNK_STDBY_MW / 5))
4254                 current_lim = PD_P_SNK_STDBY_MW / 5;
4255             tcpm_set_current_limit(port, current_lim, 5000);
4256             tcpm_set_charge(port, true);
4257             if (!port->pd_supported)
4258                 tcpm_set_state(port, SNK_READY, 0);
4259             else
4260                 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0);
4261             break;
4262         }
4263         /*
4264          * For DRP, timeouts differ. Also, handling is supposed to be
4265          * different and much more complex (dead battery detection;
4266          * see USB power delivery specification, section 8.3.3.6.1.5.1).
4267          */
4268         tcpm_set_state(port, hard_reset_state(port),
4269                    port->port_type == TYPEC_PORT_DRP ?
4270                     PD_T_DB_DETECT : PD_T_NO_RESPONSE);
4271         break;
4272     case SNK_DISCOVERY_DEBOUNCE:
4273         tcpm_set_state(port, SNK_DISCOVERY_DEBOUNCE_DONE,
4274                    PD_T_CC_DEBOUNCE);
4275         break;
4276     case SNK_DISCOVERY_DEBOUNCE_DONE:
4277         if (!tcpm_port_is_disconnected(port) &&
4278             tcpm_port_is_sink(port) &&
4279             ktime_after(port->delayed_runtime, ktime_get())) {
4280             tcpm_set_state(port, SNK_DISCOVERY,
4281                        ktime_to_ms(ktime_sub(port->delayed_runtime, ktime_get())));
4282             break;
4283         }
4284         tcpm_set_state(port, unattached_state(port), 0);
4285         break;
4286     case SNK_WAIT_CAPABILITIES:
4287         ret = port->tcpc->set_pd_rx(port->tcpc, true);
4288         if (ret < 0) {
4289             tcpm_set_state(port, SNK_READY, 0);
4290             break;
4291         }
4292         /*
4293          * If VBUS has never been low, and we time out waiting
4294          * for source cap, try a soft reset first, in case we
4295          * were already in a stable contract before this boot.
4296          * Do this only once.
4297          */
4298         if (port->vbus_never_low) {
4299             port->vbus_never_low = false;
4300             tcpm_set_state(port, SNK_SOFT_RESET,
4301                        PD_T_SINK_WAIT_CAP);
4302         } else {
4303             tcpm_set_state(port, hard_reset_state(port),
4304                        PD_T_SINK_WAIT_CAP);
4305         }
4306         break;
4307     case SNK_NEGOTIATE_CAPABILITIES:
4308         port->pd_capable = true;
4309         tcpm_set_partner_usb_comm_capable(port,
4310                           !!(port->source_caps[0] & PDO_FIXED_USB_COMM));
4311         port->hard_reset_count = 0;
4312         ret = tcpm_pd_send_request(port);
4313         if (ret < 0) {
4314             /* Restore back to the original state */
4315             tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_PD,
4316                                    port->pps_data.active,
4317                                    port->supply_voltage);
4318             /* Let the Source send capabilities again. */
4319             tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0);
4320         } else {
4321             tcpm_set_state_cond(port, hard_reset_state(port),
4322                         PD_T_SENDER_RESPONSE);
4323         }
4324         break;
4325     case SNK_NEGOTIATE_PPS_CAPABILITIES:
4326         ret = tcpm_pd_send_pps_request(port);
4327         if (ret < 0) {
4328             /* Restore back to the original state */
4329             tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_PD,
4330                                    port->pps_data.active,
4331                                    port->supply_voltage);
4332             port->pps_status = ret;
4333             /*
4334              * If this was called due to updates to sink
4335              * capabilities, and pps is no longer valid, we should
4336              * safely fall back to a standard PDO.
4337              */
4338             if (port->update_sink_caps)
4339                 tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0);
4340             else
4341                 tcpm_set_state(port, SNK_READY, 0);
4342         } else {
4343             tcpm_set_state_cond(port, hard_reset_state(port),
4344                         PD_T_SENDER_RESPONSE);
4345         }
4346         break;
4347     case SNK_TRANSITION_SINK:
4348         /* From the USB PD spec:
4349          * "The Sink Shall transition to Sink Standby before a positive or
4350          * negative voltage transition of VBUS. During Sink Standby
4351          * the Sink Shall reduce its power draw to pSnkStdby."
4352          *
4353          * This is not applicable to PPS though as the port can continue
4354          * to draw negotiated power without switching to standby.
4355          */
4356         if (port->supply_voltage != port->req_supply_voltage && !port->pps_data.active &&
4357             port->current_limit * port->supply_voltage / 1000 > PD_P_SNK_STDBY_MW) {
4358             u32 stdby_ma = PD_P_SNK_STDBY_MW * 1000 / port->supply_voltage;
4359
4360             tcpm_log(port, "Setting standby current %u mV @ %u mA",
4361                  port->supply_voltage, stdby_ma);
4362             tcpm_set_current_limit(port, stdby_ma, port->supply_voltage);
4363         }
4364         fallthrough;
4365     case SNK_TRANSITION_SINK_VBUS:
4366         tcpm_set_state(port, hard_reset_state(port),
4367                    PD_T_PS_TRANSITION);
4368         break;
4369     case SNK_READY:
4370         port->try_snk_count = 0;
4371         port->update_sink_caps = false;
4372         if (port->explicit_contract) {
4373             typec_set_pwr_opmode(port->typec_port,
4374                          TYPEC_PWR_MODE_PD);
4375             port->pwr_opmode = TYPEC_PWR_MODE_PD;
4376         }
4377
4378         if (!port->pd_capable && port->slow_charger_loop)
4379             tcpm_set_current_limit(port, tcpm_get_current_limit(port), 5000);
4380         tcpm_swap_complete(port, 0);
4381         tcpm_typec_connect(port);
4382         mod_enable_frs_delayed_work(port, 0);
4383         tcpm_pps_complete(port, port->pps_status);
4384
4385         if (port->ams != NONE_AMS)
4386             tcpm_ams_finish(port);
4387         if (port->next_ams != NONE_AMS) {
4388             port->ams = port->next_ams;
4389             port->next_ams = NONE_AMS;
4390         }
4391
4392         /*
4393          * If previous AMS is interrupted, switch to the upcoming
4394          * state.
4395          */
4396         if (port->upcoming_state != INVALID_STATE) {
4397             upcoming_state = port->upcoming_state;
4398             port->upcoming_state = INVALID_STATE;
4399             tcpm_set_state(port, upcoming_state, 0);
4400             break;
4401         }
4402
4403         /*
4404          * 6.4.4.3.1 Discover Identity
4405          * "The Discover Identity Command Shall only be sent to SOP when there is an
4406          * Explicit Contract."
4407          * For now, this driver only supports SOP for DISCOVER_IDENTITY, thus using
4408          * port->explicit_contract.
4409          */
4410         if (port->explicit_contract)
4411             mod_send_discover_delayed_work(port, 0);
4412         else
4413             port->send_discover = false;
4414
4415         power_supply_changed(port->psy);
4416         break;
4417
4418     /* Accessory states */
4419     case ACC_UNATTACHED:
4420         tcpm_acc_detach(port);
4421         tcpm_set_state(port, SRC_UNATTACHED, 0);
4422         break;
4423     case DEBUG_ACC_ATTACHED:
4424     case AUDIO_ACC_ATTACHED:
4425         ret = tcpm_acc_attach(port);
4426         if (ret < 0)
4427             tcpm_set_state(port, ACC_UNATTACHED, 0);
4428         break;
4429     case AUDIO_ACC_DEBOUNCE:
4430         tcpm_set_state(port, ACC_UNATTACHED, PD_T_CC_DEBOUNCE);
4431         break;
4432
4433     /* Hard_Reset states */
4434     case HARD_RESET_SEND:
4435         if (port->ams != NONE_AMS)
4436             tcpm_ams_finish(port);
4437         /*
4438          * State machine will be directed to HARD_RESET_START,
4439          * thus set upcoming_state to INVALID_STATE.
4440          */
4441         port->upcoming_state = INVALID_STATE;
4442         tcpm_ams_start(port, HARD_RESET);
4443         break;
4444     case HARD_RESET_START:
4445         port->sink_cap_done = false;
4446         if (port->tcpc->enable_frs)
4447             port->tcpc->enable_frs(port->tcpc, false);
4448         port->hard_reset_count++;
4449         port->tcpc->set_pd_rx(port->tcpc, false);
4450         tcpm_unregister_altmodes(port);
4451         port->nr_sink_caps = 0;
4452         port->send_discover = true;
4453         if (port->pwr_role == TYPEC_SOURCE)
4454             tcpm_set_state(port, SRC_HARD_RESET_VBUS_OFF,
4455                        PD_T_PS_HARD_RESET);
4456         else
4457             tcpm_set_state(port, SNK_HARD_RESET_SINK_OFF, 0);
4458         break;
4459     case SRC_HARD_RESET_VBUS_OFF:
4460         /*
4461          * 7.1.5 Response to Hard Resets
4462          * Hard Reset Signaling indicates a communication failure has occurred and the
4463          * Source Shall stop driving VCONN, Shall remove Rp from the VCONN pin and Shall
4464          * drive VBUS to vSafe0V as shown in Figure 7-9.
4465          */
4466         tcpm_set_vconn(port, false);
4467         tcpm_set_vbus(port, false);
4468         tcpm_set_roles(port, port->self_powered, TYPEC_SOURCE,
4469                    tcpm_data_role_for_source(port));
4470         /*
4471          * If tcpc fails to notify vbus off, TCPM will wait for PD_T_SAFE_0V +
4472          * PD_T_SRC_RECOVER before turning vbus back on.
4473          * From Table 7-12 Sequence Description for a Source Initiated Hard Reset:
4474          * 4. Policy Engine waits tPSHardReset after sending Hard Reset Signaling and then
4475          * tells the Device Policy Manager to instruct the power supply to perform a
4476          * Hard Reset. The transition to vSafe0V Shall occur within tSafe0V (t2).
4477          * 5. After tSrcRecover the Source applies power to VBUS in an attempt to
4478          * re-establish communication with the Sink and resume USB Default Operation.
4479          * The transition to vSafe5V Shall occur within tSrcTurnOn(t4).
4480          */
4481         tcpm_set_state(port, SRC_HARD_RESET_VBUS_ON, PD_T_SAFE_0V + PD_T_SRC_RECOVER);
4482         break;
4483     case SRC_HARD_RESET_VBUS_ON:
4484         tcpm_set_vconn(port, true);
4485         tcpm_set_vbus(port, true);
4486         if (port->ams == HARD_RESET)
4487             tcpm_ams_finish(port);
4488         if (port->pd_supported)
4489             port->tcpc->set_pd_rx(port->tcpc, true);
4490         tcpm_set_attached_state(port, true);
4491         tcpm_set_state(port, SRC_UNATTACHED, PD_T_PS_SOURCE_ON);
4492         break;
4493     case SNK_HARD_RESET_SINK_OFF:
4494         /* Do not discharge/disconnect during hard reseet */
4495         tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, 0);
4496         memset(&port->pps_data, 0, sizeof(port->pps_data));
4497         tcpm_set_vconn(port, false);
4498         if (port->pd_capable)
4499             tcpm_set_charge(port, false);
4500         tcpm_set_roles(port, port->self_powered, TYPEC_SINK,
4501                    tcpm_data_role_for_sink(port));
4502         /*
4503          * VBUS may or may not toggle, depending on the adapter.
4504          * If it doesn't toggle, transition to SNK_HARD_RESET_SINK_ON
4505          * directly after timeout.
4506          */
4507         tcpm_set_state(port, SNK_HARD_RESET_SINK_ON, PD_T_SAFE_0V);
4508         break;
4509     case SNK_HARD_RESET_WAIT_VBUS:
4510         if (port->ams == HARD_RESET)
4511             tcpm_ams_finish(port);
4512         /* Assume we're disconnected if VBUS doesn't come back. */
4513         tcpm_set_state(port, SNK_UNATTACHED,
4514                    PD_T_SRC_RECOVER_MAX + PD_T_SRC_TURN_ON);
4515         break;
4516     case SNK_HARD_RESET_SINK_ON:
4517         /* Note: There is no guarantee that VBUS is on in this state */
4518         /*
4519          * XXX:
4520          * The specification suggests that dual mode ports in sink
4521          * mode should transition to state PE_SRC_Transition_to_default.
4522          * See USB power delivery specification chapter 8.3.3.6.1.3.
4523          * This would mean to
4524          * - turn off VCONN, reset power supply
4525          * - request hardware reset
4526          * - turn on VCONN
4527          * - Transition to state PE_Src_Startup
4528          * SNK only ports shall transition to state Snk_Startup
4529          * (see chapter 8.3.3.3.8).
4530          * Similar, dual-mode ports in source mode should transition
4531          * to PE_SNK_Transition_to_default.
4532          */
4533         if (port->pd_capable) {
4534             tcpm_set_current_limit(port,
4535                            tcpm_get_current_limit(port),
4536                            5000);
4537             tcpm_set_charge(port, true);
4538         }
4539         if (port->ams == HARD_RESET)
4540             tcpm_ams_finish(port);
4541         tcpm_set_attached_state(port, true);
4542         tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, VSAFE5V);
4543         tcpm_set_state(port, SNK_STARTUP, 0);
4544         break;
4545
4546     /* Soft_Reset states */
4547     case SOFT_RESET:
4548         port->message_id = 0;
4549         port->rx_msgid = -1;
4550         tcpm_pd_send_control(port, PD_CTRL_ACCEPT);
4551         tcpm_ams_finish(port);
4552         if (port->pwr_role == TYPEC_SOURCE) {
4553             port->upcoming_state = SRC_SEND_CAPABILITIES;
4554             tcpm_ams_start(port, POWER_NEGOTIATION);
4555         } else {
4556             tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0);
4557         }
4558         break;
4559     case SRC_SOFT_RESET_WAIT_SNK_TX:
4560     case SNK_SOFT_RESET:
4561         if (port->ams != NONE_AMS)
4562             tcpm_ams_finish(port);
4563         port->upcoming_state = SOFT_RESET_SEND;
4564         tcpm_ams_start(port, SOFT_RESET_AMS);
4565         break;
4566     case SOFT_RESET_SEND:
4567         port->message_id = 0;
4568         port->rx_msgid = -1;
4569         if (tcpm_pd_send_control(port, PD_CTRL_SOFT_RESET))
4570             tcpm_set_state_cond(port, hard_reset_state(port), 0);
4571         else
4572             tcpm_set_state_cond(port, hard_reset_state(port),
4573                         PD_T_SENDER_RESPONSE);
4574         break;
4575
4576     /* DR_Swap states */
4577     case DR_SWAP_SEND:
4578         tcpm_pd_send_control(port, PD_CTRL_DR_SWAP);
4579         if (port->data_role == TYPEC_DEVICE || port->negotiated_rev > PD_REV20)
4580             port->send_discover = true;
4581         tcpm_set_state_cond(port, DR_SWAP_SEND_TIMEOUT,
4582                     PD_T_SENDER_RESPONSE);
4583         break;
4584     case DR_SWAP_ACCEPT:
4585         tcpm_pd_send_control(port, PD_CTRL_ACCEPT);
4586         if (port->data_role == TYPEC_DEVICE || port->negotiated_rev > PD_REV20)
4587             port->send_discover = true;
4588         tcpm_set_state_cond(port, DR_SWAP_CHANGE_DR, 0);
4589         break;
4590     case DR_SWAP_SEND_TIMEOUT:
4591         tcpm_swap_complete(port, -ETIMEDOUT);
4592         port->send_discover = false;
4593         tcpm_ams_finish(port);
4594         tcpm_set_state(port, ready_state(port), 0);
4595         break;
4596     case DR_SWAP_CHANGE_DR:
4597         if (port->data_role == TYPEC_HOST) {
4598             tcpm_unregister_altmodes(port);
4599             tcpm_set_roles(port, true, port->pwr_role,
4600                        TYPEC_DEVICE);
4601         } else {
4602             tcpm_set_roles(port, true, port->pwr_role,
4603                        TYPEC_HOST);
4604         }
4605         tcpm_ams_finish(port);
4606         tcpm_set_state(port, ready_state(port), 0);
4607         break;
4608
4609     case FR_SWAP_SEND:
4610         if (tcpm_pd_send_control(port, PD_CTRL_FR_SWAP)) {
4611             tcpm_set_state(port, ERROR_RECOVERY, 0);
4612             break;
4613         }
4614         tcpm_set_state_cond(port, FR_SWAP_SEND_TIMEOUT, PD_T_SENDER_RESPONSE);
4615         break;
4616     case FR_SWAP_SEND_TIMEOUT:
4617         tcpm_set_state(port, ERROR_RECOVERY, 0);
4618         break;
4619     case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF:
4620         tcpm_set_state(port, ERROR_RECOVERY, PD_T_PS_SOURCE_OFF);
4621         break;
4622     case FR_SWAP_SNK_SRC_NEW_SINK_READY:
4623         if (port->vbus_source)
4624             tcpm_set_state(port, FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED, 0);
4625         else
4626             tcpm_set_state(port, ERROR_RECOVERY, PD_T_RECEIVER_RESPONSE);
4627         break;
4628     case FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED:
4629         tcpm_set_pwr_role(port, TYPEC_SOURCE);
4630         if (tcpm_pd_send_control(port, PD_CTRL_PS_RDY)) {
4631             tcpm_set_state(port, ERROR_RECOVERY, 0);
4632             break;
4633         }
4634         tcpm_set_cc(port, tcpm_rp_cc(port));
4635         tcpm_set_state(port, SRC_STARTUP, PD_T_SWAP_SRC_START);
4636         break;
4637
4638     /* PR_Swap states */
4639     case PR_SWAP_ACCEPT:
4640         tcpm_pd_send_control(port, PD_CTRL_ACCEPT);
4641         tcpm_set_state(port, PR_SWAP_START, 0);
4642         break;
4643     case PR_SWAP_SEND:
4644         tcpm_pd_send_control(port, PD_CTRL_PR_SWAP);
4645         tcpm_set_state_cond(port, PR_SWAP_SEND_TIMEOUT,
4646                     PD_T_SENDER_RESPONSE);
4647         break;
4648     case PR_SWAP_SEND_TIMEOUT:
4649         tcpm_swap_complete(port, -ETIMEDOUT);
4650         tcpm_set_state(port, ready_state(port), 0);
4651         break;
4652     case PR_SWAP_START:
4653         tcpm_apply_rc(port);
4654         if (port->pwr_role == TYPEC_SOURCE)
4655             tcpm_set_state(port, PR_SWAP_SRC_SNK_TRANSITION_OFF,
4656                        PD_T_SRC_TRANSITION);
4657         else
4658             tcpm_set_state(port, PR_SWAP_SNK_SRC_SINK_OFF, 0);
4659         break;
4660     case PR_SWAP_SRC_SNK_TRANSITION_OFF:
4661         /*
4662          * Prevent vbus discharge circuit from turning on during PR_SWAP
4663          * as this is not a disconnect.
4664          */
4665         tcpm_set_vbus(port, false);
4666         port->explicit_contract = false;
4667         /* allow time for Vbus discharge, must be < tSrcSwapStdby */
4668         tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF,
4669                    PD_T_SRCSWAPSTDBY);
4670         break;
4671     case PR_SWAP_SRC_SNK_SOURCE_OFF:
4672         tcpm_set_cc(port, TYPEC_CC_RD);
4673         /* allow CC debounce */
4674         tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED,
4675                    PD_T_CC_DEBOUNCE);
4676         break;
4677     case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED:
4678         /*
4679          * USB-PD standard, 6.2.1.4, Port Power Role:
4680          * "During the Power Role Swap Sequence, for the initial Source
4681          * Port, the Port Power Role field shall be set to Sink in the
4682          * PS_RDY Message indicating that the initial Source’s power
4683          * supply is turned off"
4684          */
4685         tcpm_set_pwr_role(port, TYPEC_SINK);
4686         if (tcpm_pd_send_control(port, PD_CTRL_PS_RDY)) {
4687             tcpm_set_state(port, ERROR_RECOVERY, 0);
4688             break;
4689         }
4690         tcpm_set_state(port, ERROR_RECOVERY, PD_T_PS_SOURCE_ON_PRS);
4691         break;
4692     case PR_SWAP_SRC_SNK_SINK_ON:
4693         tcpm_enable_auto_vbus_discharge(port, true);
4694         /* Set the vbus disconnect threshold for implicit contract */
4695         tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, VSAFE5V);
4696         tcpm_set_state(port, SNK_STARTUP, 0);
4697         break;
4698     case PR_SWAP_SNK_SRC_SINK_OFF:
4699         /*
4700          * Prevent vbus discharge circuit from turning on during PR_SWAP
4701          * as this is not a disconnect.
4702          */
4703         tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB,
4704                                port->pps_data.active, 0);
4705         tcpm_set_charge(port, false);
4706         tcpm_set_state(port, hard_reset_state(port),
4707                    PD_T_PS_SOURCE_OFF);
4708         break;
4709     case PR_SWAP_SNK_SRC_SOURCE_ON:
4710         tcpm_enable_auto_vbus_discharge(port, true);
4711         tcpm_set_cc(port, tcpm_rp_cc(port));
4712         tcpm_set_vbus(port, true);
4713         /*
4714          * allow time VBUS ramp-up, must be < tNewSrc
4715          * Also, this window overlaps with CC debounce as well.
4716          * So, Wait for the max of two which is PD_T_NEWSRC
4717          */
4718         tcpm_set_state(port, PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP,
4719                    PD_T_NEWSRC);
4720         break;
4721     case PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP:
4722         /*
4723          * USB PD standard, 6.2.1.4:
4724          * "Subsequent Messages initiated by the Policy Engine,
4725          * such as the PS_RDY Message sent to indicate that Vbus
4726          * is ready, will have the Port Power Role field set to
4727          * Source."
4728          */
4729         tcpm_set_pwr_role(port, TYPEC_SOURCE);
4730         tcpm_pd_send_control(port, PD_CTRL_PS_RDY);
4731         tcpm_set_state(port, SRC_STARTUP, PD_T_SWAP_SRC_START);
4732         break;
4733
4734     case VCONN_SWAP_ACCEPT:
4735         tcpm_pd_send_control(port, PD_CTRL_ACCEPT);
4736         tcpm_ams_finish(port);
4737         tcpm_set_state(port, VCONN_SWAP_START, 0);
4738         break;
4739     case VCONN_SWAP_SEND:
4740         tcpm_pd_send_control(port, PD_CTRL_VCONN_SWAP);
4741         tcpm_set_state(port, VCONN_SWAP_SEND_TIMEOUT,
4742                    PD_T_SENDER_RESPONSE);
4743         break;
4744     case VCONN_SWAP_SEND_TIMEOUT:
4745         tcpm_swap_complete(port, -ETIMEDOUT);
4746         tcpm_set_state(port, ready_state(port), 0);
4747         break;
4748     case VCONN_SWAP_START:
4749         if (port->vconn_role == TYPEC_SOURCE)
4750             tcpm_set_state(port, VCONN_SWAP_WAIT_FOR_VCONN, 0);
4751         else
4752             tcpm_set_state(port, VCONN_SWAP_TURN_ON_VCONN, 0);
4753         break;
4754     case VCONN_SWAP_WAIT_FOR_VCONN:
4755         tcpm_set_state(port, hard_reset_state(port),
4756                    PD_T_VCONN_SOURCE_ON);
4757         break;
4758     case VCONN_SWAP_TURN_ON_VCONN:
4759         tcpm_set_vconn(port, true);
4760         tcpm_pd_send_control(port, PD_CTRL_PS_RDY);
4761         tcpm_set_state(port, ready_state(port), 0);
4762         break;
4763     case VCONN_SWAP_TURN_OFF_VCONN:
4764         tcpm_set_vconn(port, false);
4765         tcpm_set_state(port, ready_state(port), 0);
4766         break;
4767
4768     case DR_SWAP_CANCEL:
4769     case PR_SWAP_CANCEL:
4770     case VCONN_SWAP_CANCEL:
4771         tcpm_swap_complete(port, port->swap_status);
4772         if (port->pwr_role == TYPEC_SOURCE)
4773             tcpm_set_state(port, SRC_READY, 0);
4774         else
4775             tcpm_set_state(port, SNK_READY, 0);
4776         break;
4777     case FR_SWAP_CANCEL:
4778         if (port->pwr_role == TYPEC_SOURCE)
4779             tcpm_set_state(port, SRC_READY, 0);
4780         else
4781             tcpm_set_state(port, SNK_READY, 0);
4782         break;
4783
4784     case BIST_RX:
4785         switch (BDO_MODE_MASK(port->bist_request)) {
4786         case BDO_MODE_CARRIER2:
4787             tcpm_pd_transmit(port, TCPC_TX_BIST_MODE_2, NULL);
4788             tcpm_set_state(port, unattached_state(port),
4789                        PD_T_BIST_CONT_MODE);
4790             break;
4791         case BDO_MODE_TESTDATA:
4792             if (port->tcpc->set_bist_data) {
4793                 tcpm_log(port, "Enable BIST MODE TESTDATA");
4794                 port->tcpc->set_bist_data(port->tcpc, true);
4795             }
4796             break;
4797         default:
4798             break;
4799         }
4800         break;
4801     case GET_STATUS_SEND:
4802         tcpm_pd_send_control(port, PD_CTRL_GET_STATUS);
4803         tcpm_set_state(port, GET_STATUS_SEND_TIMEOUT,
4804                    PD_T_SENDER_RESPONSE);
4805         break;
4806     case GET_STATUS_SEND_TIMEOUT:
4807         tcpm_set_state(port, ready_state(port), 0);
4808         break;
4809     case GET_PPS_STATUS_SEND:
4810         tcpm_pd_send_control(port, PD_CTRL_GET_PPS_STATUS);
4811         tcpm_set_state(port, GET_PPS_STATUS_SEND_TIMEOUT,
4812                    PD_T_SENDER_RESPONSE);
4813         break;
4814     case GET_PPS_STATUS_SEND_TIMEOUT:
4815         tcpm_set_state(port, ready_state(port), 0);
4816         break;
4817     case GET_SINK_CAP:
4818         tcpm_pd_send_control(port, PD_CTRL_GET_SINK_CAP);
4819         tcpm_set_state(port, GET_SINK_CAP_TIMEOUT, PD_T_SENDER_RESPONSE);
4820         break;
4821     case GET_SINK_CAP_TIMEOUT:
4822         port->sink_cap_done = true;
4823         tcpm_set_state(port, ready_state(port), 0);
4824         break;
4825     case ERROR_RECOVERY:
4826         tcpm_swap_complete(port, -EPROTO);
4827         tcpm_pps_complete(port, -EPROTO);
4828         tcpm_set_state(port, PORT_RESET, 0);
4829         break;
4830     case PORT_RESET:
4831         tcpm_reset_port(port);
4832         tcpm_set_cc(port, TYPEC_CC_OPEN);
4833         tcpm_set_state(port, PORT_RESET_WAIT_OFF,
4834                    PD_T_ERROR_RECOVERY);
4835         break;
4836     case PORT_RESET_WAIT_OFF:
4837         tcpm_set_state(port,
4838                    tcpm_default_state(port),
4839                    port->vbus_present ? PD_T_PS_SOURCE_OFF : 0);
4840         break;
4841
4842     /* AMS intermediate state */
4843     case AMS_START:
4844         if (port->upcoming_state == INVALID_STATE) {
4845             tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ?
4846                        SRC_READY : SNK_READY, 0);
4847             break;
4848         }
4849
4850         upcoming_state = port->upcoming_state;
4851         port->upcoming_state = INVALID_STATE;
4852         tcpm_set_state(port, upcoming_state, 0);
4853         break;
4854
4855     /* Chunk state */
4856     case CHUNK_NOT_SUPP:
4857         tcpm_pd_send_control(port, PD_CTRL_NOT_SUPP);
4858         tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ? SRC_READY : SNK_READY, 0);
4859         break;
4860     default:
4861         WARN(1, "Unexpected port state %d\n", port->state);
4862         break;
4863     }
4864 }
4865
4866 static void tcpm_state_machine_work(struct kthread_work *work)
4867 {
4868     struct tcpm_port *port = container_of(work, struct tcpm_port, state_machine);
4869     enum tcpm_state prev_state;
4870
4871     mutex_lock(&port->lock);
4872     port->state_machine_running = true;
4873
4874     if (port->queued_message && tcpm_send_queued_message(port))
4875         goto done;
4876
4877     /* If we were queued due to a delayed state change, update it now */
4878     if (port->delayed_state) {
4879         tcpm_log(port, "state change %s -> %s [delayed %ld ms]",
4880              tcpm_states[port->state],
4881              tcpm_states[port->delayed_state], port->delay_ms);
4882         port->prev_state = port->state;
4883         port->state = port->delayed_state;
4884         port->delayed_state = INVALID_STATE;
4885     }
4886
4887     /*
4888      * Continue running as long as we have (non-delayed) state changes
4889      * to make.
4890      */
4891     do {
4892         prev_state = port->state;
4893         run_state_machine(port);
4894         if (port->queued_message)
4895             tcpm_send_queued_message(port);
4896     } while (port->state != prev_state && !port->delayed_state);
4897
4898 done:
4899     port->state_machine_running = false;
4900     mutex_unlock(&port->lock);
4901 }
4902
4903 static void _tcpm_cc_change(struct tcpm_port *port, enum typec_cc_status cc1,
4904                 enum typec_cc_status cc2)
4905 {
4906     enum typec_cc_status old_cc1, old_cc2;
4907     enum tcpm_state new_state;
4908
4909     old_cc1 = port->cc1;
4910     old_cc2 = port->cc2;
4911     port->cc1 = cc1;
4912     port->cc2 = cc2;
4913
4914     tcpm_log_force(port,
4915                "CC1: %u -> %u, CC2: %u -> %u [state %s, polarity %d, %s]",
4916                old_cc1, cc1, old_cc2, cc2, tcpm_states[port->state],
4917                port->polarity,
4918                tcpm_port_is_disconnected(port) ? "disconnected"
4919                                : "connected");
4920
4921     switch (port->state) {
4922     case TOGGLING:
4923         if (tcpm_port_is_debug(port) || tcpm_port_is_audio(port) ||
4924             tcpm_port_is_source(port))
4925             tcpm_set_state(port, SRC_ATTACH_WAIT, 0);
4926         else if (tcpm_port_is_sink(port))
4927             tcpm_set_state(port, SNK_ATTACH_WAIT, 0);
4928         break;
4929     case SRC_UNATTACHED:
4930     case ACC_UNATTACHED:
4931         if (tcpm_port_is_debug(port) || tcpm_port_is_audio(port) ||
4932             tcpm_port_is_source(port))
4933             tcpm_set_state(port, SRC_ATTACH_WAIT, 0);
4934         break;
4935     case SRC_ATTACH_WAIT:
4936         if (tcpm_port_is_disconnected(port) ||
4937             tcpm_port_is_audio_detached(port))
4938             tcpm_set_state(port, SRC_UNATTACHED, 0);
4939         else if (cc1 != old_cc1 || cc2 != old_cc2)
4940             tcpm_set_state(port, SRC_ATTACH_WAIT, 0);
4941         break;
4942     case SRC_ATTACHED:
4943     case SRC_STARTUP:
4944     case SRC_SEND_CAPABILITIES:
4945     case SRC_READY:
4946         if (tcpm_port_is_disconnected(port) ||
4947             !tcpm_port_is_source(port)) {
4948             if (port->port_type == TYPEC_PORT_SRC)
4949                 tcpm_set_state(port, SRC_UNATTACHED, tcpm_wait_for_discharge(port));
4950             else
4951                 tcpm_set_state(port, SNK_UNATTACHED, tcpm_wait_for_discharge(port));
4952         }
4953         break;
4954     case SNK_UNATTACHED:
4955         if (tcpm_port_is_sink(port))
4956             tcpm_set_state(port, SNK_ATTACH_WAIT, 0);
4957         break;
4958     case SNK_ATTACH_WAIT:
4959         if ((port->cc1 == TYPEC_CC_OPEN &&
4960              port->cc2 != TYPEC_CC_OPEN) ||
4961             (port->cc1 != TYPEC_CC_OPEN &&
4962              port->cc2 == TYPEC_CC_OPEN))
4963             new_state = SNK_DEBOUNCED;
4964         else if (tcpm_port_is_disconnected(port))
4965             new_state = SNK_UNATTACHED;
4966         else
4967             break;
4968         if (new_state != port->delayed_state)
4969             tcpm_set_state(port, SNK_ATTACH_WAIT, 0);
4970         break;
4971     case SNK_DEBOUNCED:
4972         if (tcpm_port_is_disconnected(port))
4973             new_state = SNK_UNATTACHED;
4974         else if (port->vbus_present)
4975             new_state = tcpm_try_src(port) ? SRC_TRY : SNK_ATTACHED;
4976         else
4977             new_state = SNK_UNATTACHED;
4978         if (new_state != port->delayed_state)
4979             tcpm_set_state(port, SNK_DEBOUNCED, 0);
4980         break;
4981     case SNK_READY:
4982         /*
4983          * EXIT condition is based primarily on vbus disconnect and CC is secondary.
4984          * "A port that has entered into USB PD communications with the Source and
4985          * has seen the CC voltage exceed vRd-USB may monitor the CC pin to detect
4986          * cable disconnect in addition to monitoring VBUS.
4987          *
4988          * A port that is monitoring the CC voltage for disconnect (but is not in
4989          * the process of a USB PD PR_Swap or USB PD FR_Swap) shall transition to
4990          * Unattached.SNK within tSinkDisconnect after the CC voltage remains below
4991          * vRd-USB for tPDDebounce."
4992          *
4993          * When set_auto_vbus_discharge_threshold is enabled, CC pins go
4994          * away before vbus decays to disconnect threshold. Allow
4995          * disconnect to be driven by vbus disconnect when auto vbus
4996          * discharge is enabled.
4997          */
4998         if (!port->auto_vbus_discharge_enabled && tcpm_port_is_disconnected(port))
4999             tcpm_set_state(port, unattached_state(port), 0);
5000         else if (!port->pd_capable &&
5001              (cc1 != old_cc1 || cc2 != old_cc2))
5002             tcpm_set_current_limit(port,
5003                            tcpm_get_current_limit(port),
5004                            5000);
5005         break;
5006
5007     case AUDIO_ACC_ATTACHED:
5008         if (cc1 == TYPEC_CC_OPEN || cc2 == TYPEC_CC_OPEN)
5009             tcpm_set_state(port, AUDIO_ACC_DEBOUNCE, 0);
5010         break;
5011     case AUDIO_ACC_DEBOUNCE:
5012         if (tcpm_port_is_audio(port))
5013             tcpm_set_state(port, AUDIO_ACC_ATTACHED, 0);
5014         break;
5015
5016     case DEBUG_ACC_ATTACHED:
5017         if (cc1 == TYPEC_CC_OPEN || cc2 == TYPEC_CC_OPEN)
5018             tcpm_set_state(port, ACC_UNATTACHED, 0);
5019         break;
5020
5021     case SNK_TRY:
5022         /* Do nothing, waiting for timeout */
5023         break;
5024
5025     case SNK_DISCOVERY:
5026         /* CC line is unstable, wait for debounce */
5027         if (tcpm_port_is_disconnected(port))
5028             tcpm_set_state(port, SNK_DISCOVERY_DEBOUNCE, 0);
5029         break;
5030     case SNK_DISCOVERY_DEBOUNCE:
5031         break;
5032
5033     case SRC_TRYWAIT:
5034         /* Hand over to state machine if needed */
5035         if (!port->vbus_present && tcpm_port_is_source(port))
5036             tcpm_set_state(port, SRC_TRYWAIT_DEBOUNCE, 0);
5037         break;
5038     case SRC_TRYWAIT_DEBOUNCE:
5039         if (port->vbus_present || !tcpm_port_is_source(port))
5040             tcpm_set_state(port, SRC_TRYWAIT, 0);
5041         break;
5042     case SNK_TRY_WAIT_DEBOUNCE:
5043         if (!tcpm_port_is_sink(port)) {
5044             port->max_wait = 0;
5045             tcpm_set_state(port, SRC_TRYWAIT, 0);
5046         }
5047         break;
5048     case SRC_TRY_WAIT:
5049         if (tcpm_port_is_source(port))
5050             tcpm_set_state(port, SRC_TRY_DEBOUNCE, 0);
5051         break;
5052     case SRC_TRY_DEBOUNCE:
5053         tcpm_set_state(port, SRC_TRY_WAIT, 0);
5054         break;
5055     case SNK_TRYWAIT_DEBOUNCE:
5056         if (tcpm_port_is_sink(port))
5057             tcpm_set_state(port, SNK_TRYWAIT_VBUS, 0);
5058         break;
5059     case SNK_TRYWAIT_VBUS:
5060         if (!tcpm_port_is_sink(port))
5061             tcpm_set_state(port, SNK_TRYWAIT_DEBOUNCE, 0);
5062         break;
5063     case SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS:
5064         if (!tcpm_port_is_sink(port))
5065             tcpm_set_state(port, SRC_TRYWAIT, PD_T_TRY_CC_DEBOUNCE);
5066         else
5067             tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS, 0);
5068         break;
5069     case SNK_TRYWAIT:
5070         /* Do nothing, waiting for tCCDebounce */
5071         break;
5072     case PR_SWAP_SNK_SRC_SINK_OFF:
5073     case PR_SWAP_SRC_SNK_TRANSITION_OFF:
5074     case PR_SWAP_SRC_SNK_SOURCE_OFF:
5075     case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED:
5076     case PR_SWAP_SNK_SRC_SOURCE_ON:
5077         /*
5078          * CC state change is expected in PR_SWAP
5079          * Ignore it.
5080          */
5081         break;
5082     case FR_SWAP_SEND:
5083     case FR_SWAP_SEND_TIMEOUT:
5084     case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF:
5085     case FR_SWAP_SNK_SRC_NEW_SINK_READY:
5086     case FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED:
5087         /* Do nothing, CC change expected */
5088         break;
5089
5090     case PORT_RESET:
5091     case PORT_RESET_WAIT_OFF:
5092         /*
5093          * State set back to default mode once the timer completes.
5094          * Ignore CC changes here.
5095          */
5096         break;
5097     default:
5098         /*
5099          * While acting as sink and auto vbus discharge is enabled, Allow disconnect
5100          * to be driven by vbus disconnect.
5101          */
5102         if (tcpm_port_is_disconnected(port) && !(port->pwr_role == TYPEC_SINK &&
5103                              port->auto_vbus_discharge_enabled))
5104             tcpm_set_state(port, unattached_state(port), 0);
5105         break;
5106     }
5107 }
5108
5109 static void _tcpm_pd_vbus_on(struct tcpm_port *port)
5110 {
5111     tcpm_log_force(port, "VBUS on");
5112     port->vbus_present = true;
5113     /*
5114      * When vbus_present is true i.e. Voltage at VBUS is greater than VSAFE5V implicitly
5115      * states that vbus is not at VSAFE0V, hence clear the vbus_vsafe0v flag here.
5116      */
5117     port->vbus_vsafe0v = false;
5118
5119     switch (port->state) {
5120     case SNK_TRANSITION_SINK_VBUS:
5121         port->explicit_contract = true;
5122         tcpm_set_state(port, SNK_READY, 0);
5123         break;
5124     case SNK_DISCOVERY:
5125         tcpm_set_state(port, SNK_DISCOVERY, 0);
5126         break;
5127
5128     case SNK_DEBOUNCED:
5129         tcpm_set_state(port, tcpm_try_src(port) ? SRC_TRY
5130                             : SNK_ATTACHED,
5131                        0);
5132         break;
5133     case SNK_HARD_RESET_WAIT_VBUS:
5134         tcpm_set_state(port, SNK_HARD_RESET_SINK_ON, 0);
5135         break;
5136     case SRC_ATTACHED:
5137         tcpm_set_state(port, SRC_STARTUP, 0);
5138         break;
5139     case SRC_HARD_RESET_VBUS_ON:
5140         tcpm_set_state(port, SRC_STARTUP, 0);
5141         break;
5142
5143     case SNK_TRY:
5144         /* Do nothing, waiting for timeout */
5145         break;
5146     case SRC_TRYWAIT:
5147         /* Do nothing, Waiting for Rd to be detected */
5148         break;
5149     case SRC_TRYWAIT_DEBOUNCE:
5150         tcpm_set_state(port, SRC_TRYWAIT, 0);
5151         break;
5152     case SNK_TRY_WAIT_DEBOUNCE:
5153         /* Do nothing, waiting for PD_DEBOUNCE to do be done */
5154         break;
5155     case SNK_TRYWAIT:
5156         /* Do nothing, waiting for tCCDebounce */
5157         break;
5158     case SNK_TRYWAIT_VBUS:
5159         if (tcpm_port_is_sink(port))
5160             tcpm_set_state(port, SNK_ATTACHED, 0);
5161         break;
5162     case SNK_TRYWAIT_DEBOUNCE:
5163         /* Do nothing, waiting for Rp */
5164         break;
5165     case SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS:
5166         if (port->vbus_present && tcpm_port_is_sink(port))
5167             tcpm_set_state(port, SNK_ATTACHED, 0);
5168         break;
5169     case SRC_TRY_WAIT:
5170     case SRC_TRY_DEBOUNCE:
5171         /* Do nothing, waiting for sink detection */
5172         break;
5173     case FR_SWAP_SEND:
5174     case FR_SWAP_SEND_TIMEOUT:
5175     case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF:
5176     case FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED:
5177         if (port->tcpc->frs_sourcing_vbus)
5178             port->tcpc->frs_sourcing_vbus(port->tcpc);
5179         break;
5180     case FR_SWAP_SNK_SRC_NEW_SINK_READY:
5181         if (port->tcpc->frs_sourcing_vbus)
5182             port->tcpc->frs_sourcing_vbus(port->tcpc);
5183         tcpm_set_state(port, FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED, 0);
5184         break;
5185
5186     case PORT_RESET:
5187     case PORT_RESET_WAIT_OFF:
5188         /*
5189          * State set back to default mode once the timer completes.
5190          * Ignore vbus changes here.
5191          */
5192         break;
5193
5194     default:
5195         break;
5196     }
5197 }
5198
5199 static void _tcpm_pd_vbus_off(struct tcpm_port *port)
5200 {
5201     tcpm_log_force(port, "VBUS off");
5202     port->vbus_present = false;
5203     port->vbus_never_low = false;
5204     switch (port->state) {
5205     case SNK_HARD_RESET_SINK_OFF:
5206         tcpm_set_state(port, SNK_HARD_RESET_WAIT_VBUS, 0);
5207         break;
5208     case HARD_RESET_SEND:
5209         break;
5210     case SNK_TRY:
5211         /* Do nothing, waiting for timeout */
5212         break;
5213     case SRC_TRYWAIT:
5214         /* Hand over to state machine if needed */
5215         if (tcpm_port_is_source(port))
5216             tcpm_set_state(port, SRC_TRYWAIT_DEBOUNCE, 0);
5217         break;
5218     case SNK_TRY_WAIT_DEBOUNCE:
5219         /* Do nothing, waiting for PD_DEBOUNCE to do be done */
5220         break;
5221     case SNK_TRYWAIT:
5222     case SNK_TRYWAIT_VBUS:
5223     case SNK_TRYWAIT_DEBOUNCE:
5224         break;
5225     case SNK_ATTACH_WAIT:
5226     case SNK_DEBOUNCED:
5227         /* Do nothing, as TCPM is still waiting for vbus to reaach VSAFE5V to connect */
5228         break;
5229
5230     case SNK_NEGOTIATE_CAPABILITIES:
5231         break;
5232
5233     case PR_SWAP_SRC_SNK_TRANSITION_OFF:
5234         tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF, 0);
5235         break;
5236
5237     case PR_SWAP_SNK_SRC_SINK_OFF:
5238         /* Do nothing, expected */
5239         break;
5240
5241     case PR_SWAP_SNK_SRC_SOURCE_ON:
5242         /*
5243          * Do nothing when vbus off notification is received.
5244          * TCPM can wait for PD_T_NEWSRC in PR_SWAP_SNK_SRC_SOURCE_ON
5245          * for the vbus source to ramp up.
5246          */
5247         break;
5248
5249     case PORT_RESET_WAIT_OFF:
5250         tcpm_set_state(port, tcpm_default_state(port), 0);
5251         break;
5252
5253     case SRC_TRY_WAIT:
5254     case SRC_TRY_DEBOUNCE:
5255         /* Do nothing, waiting for sink detection */
5256         break;
5257
5258     case SRC_STARTUP:
5259     case SRC_SEND_CAPABILITIES:
5260     case SRC_SEND_CAPABILITIES_TIMEOUT:
5261     case SRC_NEGOTIATE_CAPABILITIES:
5262     case SRC_TRANSITION_SUPPLY:
5263     case SRC_READY:
5264     case SRC_WAIT_NEW_CAPABILITIES:
5265         /*
5266          * Force to unattached state to re-initiate connection.
5267          * DRP port should move to Unattached.SNK instead of Unattached.SRC if
5268          * sink removed. Although sink removal here is due to source's vbus collapse,
5269          * treat it the same way for consistency.
5270          */
5271         if (port->port_type == TYPEC_PORT_SRC)
5272             tcpm_set_state(port, SRC_UNATTACHED, tcpm_wait_for_discharge(port));
5273         else
5274             tcpm_set_state(port, SNK_UNATTACHED, tcpm_wait_for_discharge(port));
5275         break;
5276
5277     case PORT_RESET:
5278         /*
5279          * State set back to default mode once the timer completes.
5280          * Ignore vbus changes here.
5281          */
5282         break;
5283
5284     case FR_SWAP_SEND:
5285     case FR_SWAP_SEND_TIMEOUT:
5286     case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF:
5287     case FR_SWAP_SNK_SRC_NEW_SINK_READY:
5288     case FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED:
5289         /* Do nothing, vbus drop expected */
5290         break;
5291
5292     default:
5293         if (port->pwr_role == TYPEC_SINK && port->attached)
5294             tcpm_set_state(port, SNK_UNATTACHED, tcpm_wait_for_discharge(port));
5295         break;
5296     }
5297 }
5298
5299 static void _tcpm_pd_vbus_vsafe0v(struct tcpm_port *port)
5300 {
5301     tcpm_log_force(port, "VBUS VSAFE0V");
5302     port->vbus_vsafe0v = true;
5303     switch (port->state) {
5304     case SRC_HARD_RESET_VBUS_OFF:
5305         /*
5306          * After establishing the vSafe0V voltage condition on VBUS, the Source Shall wait
5307          * tSrcRecover before re-applying VCONN and restoring VBUS to vSafe5V.
5308          */
5309         tcpm_set_state(port, SRC_HARD_RESET_VBUS_ON, PD_T_SRC_RECOVER);
5310         break;
5311     case SRC_ATTACH_WAIT:
5312         if (tcpm_port_is_source(port))
5313             tcpm_set_state(port, tcpm_try_snk(port) ? SNK_TRY : SRC_ATTACHED,
5314                        PD_T_CC_DEBOUNCE);
5315         break;
5316     case SRC_STARTUP:
5317     case SRC_SEND_CAPABILITIES:
5318     case SRC_SEND_CAPABILITIES_TIMEOUT:
5319     case SRC_NEGOTIATE_CAPABILITIES:
5320     case SRC_TRANSITION_SUPPLY:
5321     case SRC_READY:
5322     case SRC_WAIT_NEW_CAPABILITIES:
5323         if (port->auto_vbus_discharge_enabled) {
5324             if (port->port_type == TYPEC_PORT_SRC)
5325                 tcpm_set_state(port, SRC_UNATTACHED, 0);
5326             else
5327                 tcpm_set_state(port, SNK_UNATTACHED, 0);
5328         }
5329         break;
5330     case PR_SWAP_SNK_SRC_SINK_OFF:
5331     case PR_SWAP_SNK_SRC_SOURCE_ON:
5332         /* Do nothing, vsafe0v is expected during transition */
5333         break;
5334     case SNK_ATTACH_WAIT:
5335     case SNK_DEBOUNCED:
5336         /*Do nothing, still waiting for VSAFE5V for connect */
5337         break;
5338     default:
5339         if (port->pwr_role == TYPEC_SINK && port->auto_vbus_discharge_enabled)
5340             tcpm_set_state(port, SNK_UNATTACHED, 0);
5341         break;
5342     }
5343 }
5344
5345 static void _tcpm_pd_hard_reset(struct tcpm_port *port)
5346 {
5347     tcpm_log_force(port, "Received hard reset");
5348     if (port->bist_request == BDO_MODE_TESTDATA && port->tcpc->set_bist_data)
5349         port->tcpc->set_bist_data(port->tcpc, false);
5350
5351     if (port->ams != NONE_AMS)
5352         port->ams = NONE_AMS;
5353     if (port->hard_reset_count < PD_N_HARD_RESET_COUNT)
5354         port->ams = HARD_RESET;
5355     /*
5356      * If we keep receiving hard reset requests, executing the hard reset
5357      * must have failed. Revert to error recovery if that happens.
5358      */
5359     tcpm_set_state(port,
5360                port->hard_reset_count < PD_N_HARD_RESET_COUNT ?
5361                 HARD_RESET_START : ERROR_RECOVERY,
5362                0);
5363 }
5364
5365 static void tcpm_pd_event_handler(struct kthread_work *work)
5366 {
5367     struct tcpm_port *port = container_of(work, struct tcpm_port,
5368                           event_work);
5369     u32 events;
5370
5371     mutex_lock(&port->lock);
5372
5373     spin_lock(&port->pd_event_lock);
5374     while (port->pd_events) {
5375         events = port->pd_events;
5376         port->pd_events = 0;
5377         spin_unlock(&port->pd_event_lock);
5378         if (events & TCPM_RESET_EVENT)
5379             _tcpm_pd_hard_reset(port);
5380         if (events & TCPM_VBUS_EVENT) {
5381             bool vbus;
5382
5383             vbus = port->tcpc->get_vbus(port->tcpc);
5384             if (vbus) {
5385                 _tcpm_pd_vbus_on(port);
5386             } else {
5387                 _tcpm_pd_vbus_off(port);
5388                 /*
5389                  * When TCPC does not support detecting vsafe0v voltage level,
5390                  * treat vbus absent as vsafe0v. Else invoke is_vbus_vsafe0v
5391                  * to see if vbus has discharge to VSAFE0V.
5392                  */
5393                 if (!port->tcpc->is_vbus_vsafe0v ||
5394                     port->tcpc->is_vbus_vsafe0v(port->tcpc))
5395                     _tcpm_pd_vbus_vsafe0v(port);
5396             }
5397         }
5398         if (events & TCPM_CC_EVENT) {
5399             enum typec_cc_status cc1, cc2;
5400
5401             if (port->tcpc->get_cc(port->tcpc, &cc1, &cc2) == 0)
5402                 _tcpm_cc_change(port, cc1, cc2);
5403         }
5404         if (events & TCPM_FRS_EVENT) {
5405             if (port->state == SNK_READY) {
5406                 int ret;
5407
5408                 port->upcoming_state = FR_SWAP_SEND;
5409                 ret = tcpm_ams_start(port, FAST_ROLE_SWAP);
5410                 if (ret == -EAGAIN)
5411                     port->upcoming_state = INVALID_STATE;
5412             } else {
5413                 tcpm_log(port, "Discarding FRS_SIGNAL! Not in sink ready");
5414             }
5415         }
5416         if (events & TCPM_SOURCING_VBUS) {
5417             tcpm_log(port, "sourcing vbus");
5418             /*
5419              * In fast role swap case TCPC autonomously sources vbus. Set vbus_source
5420              * true as TCPM wouldn't have called tcpm_set_vbus.
5421              *
5422              * When vbus is sourced on the command on TCPM i.e. TCPM called
5423              * tcpm_set_vbus to source vbus, vbus_source would already be true.
5424              */
5425             port->vbus_source = true;
5426             _tcpm_pd_vbus_on(port);
5427         }
5428
5429         spin_lock(&port->pd_event_lock);
5430     }
5431     spin_unlock(&port->pd_event_lock);
5432     mutex_unlock(&port->lock);
5433 }
5434
5435 void tcpm_cc_change(struct tcpm_port *port)
5436 {
5437     spin_lock(&port->pd_event_lock);
5438     port->pd_events |= TCPM_CC_EVENT;
5439     spin_unlock(&port->pd_event_lock);
5440     kthread_queue_work(port->wq, &port->event_work);
5441 }
5442 EXPORT_SYMBOL_GPL(tcpm_cc_change);
5443
5444 void tcpm_vbus_change(struct tcpm_port *port)
5445 {
5446     spin_lock(&port->pd_event_lock);
5447     port->pd_events |= TCPM_VBUS_EVENT;
5448     spin_unlock(&port->pd_event_lock);
5449     kthread_queue_work(port->wq, &port->event_work);
5450 }
5451 EXPORT_SYMBOL_GPL(tcpm_vbus_change);
5452
5453 void tcpm_pd_hard_reset(struct tcpm_port *port)
5454 {
5455     spin_lock(&port->pd_event_lock);
5456     port->pd_events = TCPM_RESET_EVENT;
5457     spin_unlock(&port->pd_event_lock);
5458     kthread_queue_work(port->wq, &port->event_work);
5459 }
5460 EXPORT_SYMBOL_GPL(tcpm_pd_hard_reset);
5461
5462 void tcpm_sink_frs(struct tcpm_port *port)
5463 {
5464     spin_lock(&port->pd_event_lock);
5465     port->pd_events |= TCPM_FRS_EVENT;
5466     spin_unlock(&port->pd_event_lock);
5467     kthread_queue_work(port->wq, &port->event_work);
5468 }
5469 EXPORT_SYMBOL_GPL(tcpm_sink_frs);
5470
5471 void tcpm_sourcing_vbus(struct tcpm_port *port)
5472 {
5473     spin_lock(&port->pd_event_lock);
5474     port->pd_events |= TCPM_SOURCING_VBUS;
5475     spin_unlock(&port->pd_event_lock);
5476     kthread_queue_work(port->wq, &port->event_work);
5477 }
5478 EXPORT_SYMBOL_GPL(tcpm_sourcing_vbus);
5479
5480 static void tcpm_enable_frs_work(struct kthread_work *work)
5481 {
5482     struct tcpm_port *port = container_of(work, struct tcpm_port, enable_frs);
5483     int ret;
5484
5485     mutex_lock(&port->lock);
5486     /* Not FRS capable */
5487     if (!port->connected || port->port_type != TYPEC_PORT_DRP ||
5488         port->pwr_opmode != TYPEC_PWR_MODE_PD ||
5489         !port->tcpc->enable_frs ||
5490         /* Sink caps queried */
5491         port->sink_cap_done || port->negotiated_rev < PD_REV30)
5492         goto unlock;
5493
5494     /* Send when the state machine is idle */
5495     if (port->state != SNK_READY || port->vdm_sm_running || port->send_discover)
5496         goto resched;
5497
5498     port->upcoming_state = GET_SINK_CAP;
5499     ret = tcpm_ams_start(port, GET_SINK_CAPABILITIES);
5500     if (ret == -EAGAIN) {
5501         port->upcoming_state = INVALID_STATE;
5502     } else {
5503         port->sink_cap_done = true;
5504         goto unlock;
5505     }
5506 resched:
5507     mod_enable_frs_delayed_work(port, GET_SINK_CAP_RETRY_MS);
5508 unlock:
5509     mutex_unlock(&port->lock);
5510 }
5511
5512 static void tcpm_send_discover_work(struct kthread_work *work)
5513 {
5514     struct tcpm_port *port = container_of(work, struct tcpm_port, send_discover_work);
5515
5516     mutex_lock(&port->lock);
5517     /* No need to send DISCOVER_IDENTITY anymore */
5518     if (!port->send_discover)
5519         goto unlock;
5520
5521     if (port->data_role == TYPEC_DEVICE && port->negotiated_rev < PD_REV30) {
5522         port->send_discover = false;
5523         goto unlock;
5524     }
5525
5526     /* Retry if the port is not idle */
5527     if ((port->state != SRC_READY && port->state != SNK_READY) || port->vdm_sm_running) {
5528         mod_send_discover_delayed_work(port, SEND_DISCOVER_RETRY_MS);
5529         goto unlock;
5530     }
5531
5532     tcpm_send_vdm(port, USB_SID_PD, CMD_DISCOVER_IDENT, NULL, 0);
5533
5534 unlock:
5535     mutex_unlock(&port->lock);
5536 }
5537
5538 static int tcpm_dr_set(struct typec_port *p, enum typec_data_role data)
5539 {
5540     struct tcpm_port *port = typec_get_drvdata(p);
5541     int ret;
5542
5543     mutex_lock(&port->swap_lock);
5544     mutex_lock(&port->lock);
5545
5546     if (port->typec_caps.data != TYPEC_PORT_DRD) {
5547         ret = -EINVAL;
5548         goto port_unlock;
5549     }
5550     if (port->state != SRC_READY && port->state != SNK_READY) {
5551         ret = -EAGAIN;
5552         goto port_unlock;
5553     }
5554
5555     if (port->data_role == data) {
5556         ret = 0;
5557         goto port_unlock;
5558     }
5559
5560     /*
5561      * XXX
5562      * 6.3.9: If an alternate mode is active, a request to swap
5563      * alternate modes shall trigger a port reset.
5564      * Reject data role swap request in this case.
5565      */
5566
5567     if (!port->pd_capable) {
5568         /*
5569          * If the partner is not PD capable, reset the port to
5570          * trigger a role change. This can only work if a preferred
5571          * role is configured, and if it matches the requested role.
5572          */
5573         if (port->try_role == TYPEC_NO_PREFERRED_ROLE ||
5574             port->try_role == port->pwr_role) {
5575             ret = -EINVAL;
5576             goto port_unlock;
5577         }
5578         port->non_pd_role_swap = true;
5579         tcpm_set_state(port, PORT_RESET, 0);
5580     } else {
5581         port->upcoming_state = DR_SWAP_SEND;
5582         ret = tcpm_ams_start(port, DATA_ROLE_SWAP);
5583         if (ret == -EAGAIN) {
5584             port->upcoming_state = INVALID_STATE;
5585             goto port_unlock;
5586         }
5587     }
5588
5589     port->swap_status = 0;
5590     port->swap_pending = true;
5591     reinit_completion(&port->swap_complete);
5592     mutex_unlock(&port->lock);
5593
5594     if (!wait_for_completion_timeout(&port->swap_complete,
5595                 msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT)))
5596         ret = -ETIMEDOUT;
5597     else
5598         ret = port->swap_status;
5599
5600     port->non_pd_role_swap = false;
5601     goto swap_unlock;
5602
5603 port_unlock:
5604     mutex_unlock(&port->lock);
5605 swap_unlock:
5606     mutex_unlock(&port->swap_lock);
5607     return ret;
5608 }
5609
5610 static int tcpm_pr_set(struct typec_port *p, enum typec_role role)
5611 {
5612     struct tcpm_port *port = typec_get_drvdata(p);
5613     int ret;
5614
5615     mutex_lock(&port->swap_lock);
5616     mutex_lock(&port->lock);
5617
5618     if (port->port_type != TYPEC_PORT_DRP) {
5619         ret = -EINVAL;
5620         goto port_unlock;
5621     }
5622     if (port->state != SRC_READY && port->state != SNK_READY) {
5623         ret = -EAGAIN;
5624         goto port_unlock;
5625     }
5626
5627     if (role == port->pwr_role) {
5628         ret = 0;
5629         goto port_unlock;
5630     }
5631
5632     port->upcoming_state = PR_SWAP_SEND;
5633     ret = tcpm_ams_start(port, POWER_ROLE_SWAP);
5634     if (ret == -EAGAIN) {
5635         port->upcoming_state = INVALID_STATE;
5636         goto port_unlock;
5637     }
5638
5639     port->swap_status = 0;
5640     port->swap_pending = true;
5641     reinit_completion(&port->swap_complete);
5642     mutex_unlock(&port->lock);
5643
5644     if (!wait_for_completion_timeout(&port->swap_complete,
5645                 msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT)))
5646         ret = -ETIMEDOUT;
5647     else
5648         ret = port->swap_status;
5649
5650     goto swap_unlock;
5651
5652 port_unlock:
5653     mutex_unlock(&port->lock);
5654 swap_unlock:
5655     mutex_unlock(&port->swap_lock);
5656     return ret;
5657 }
5658
5659 static int tcpm_vconn_set(struct typec_port *p, enum typec_role role)
5660 {
5661     struct tcpm_port *port = typec_get_drvdata(p);
5662     int ret;
5663
5664     mutex_lock(&port->swap_lock);
5665     mutex_lock(&port->lock);
5666
5667     if (port->state != SRC_READY && port->state != SNK_READY) {
5668         ret = -EAGAIN;
5669         goto port_unlock;
5670     }
5671
5672     if (role == port->vconn_role) {
5673         ret = 0;
5674         goto port_unlock;
5675     }
5676
5677     port->upcoming_state = VCONN_SWAP_SEND;
5678     ret = tcpm_ams_start(port, VCONN_SWAP);
5679     if (ret == -EAGAIN) {
5680         port->upcoming_state = INVALID_STATE;
5681         goto port_unlock;
5682     }
5683
5684     port->swap_status = 0;
5685     port->swap_pending = true;
5686     reinit_completion(&port->swap_complete);
5687     mutex_unlock(&port->lock);
5688
5689     if (!wait_for_completion_timeout(&port->swap_complete,
5690                 msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT)))
5691         ret = -ETIMEDOUT;
5692     else
5693         ret = port->swap_status;
5694
5695     goto swap_unlock;
5696
5697 port_unlock:
5698     mutex_unlock(&port->lock);
5699 swap_unlock:
5700     mutex_unlock(&port->swap_lock);
5701     return ret;
5702 }
5703
5704 static int tcpm_try_role(struct typec_port *p, int role)
5705 {
5706     struct tcpm_port *port = typec_get_drvdata(p);
5707     struct tcpc_dev *tcpc = port->tcpc;
5708     int ret = 0;
5709
5710     mutex_lock(&port->lock);
5711     if (tcpc->try_role)
5712         ret = tcpc->try_role(tcpc, role);
5713     if (!ret)
5714         port->try_role = role;
5715     port->try_src_count = 0;
5716     port->try_snk_count = 0;
5717     mutex_unlock(&port->lock);
5718
5719     return ret;
5720 }
5721
5722 static int tcpm_pps_set_op_curr(struct tcpm_port *port, u16 req_op_curr)
5723 {
5724     unsigned int target_mw;
5725     int ret;
5726
5727     mutex_lock(&port->swap_lock);
5728     mutex_lock(&port->lock);
5729
5730     if (!port->pps_data.active) {
5731         ret = -EOPNOTSUPP;
5732         goto port_unlock;
5733     }
5734
5735     if (port->state != SNK_READY) {
5736         ret = -EAGAIN;
5737         goto port_unlock;
5738     }
5739
5740     if (req_op_curr > port->pps_data.max_curr) {
5741         ret = -EINVAL;
5742         goto port_unlock;
5743     }
5744
5745     target_mw = (req_op_curr * port->supply_voltage) / 1000;
5746     if (target_mw < port->operating_snk_mw) {
5747         ret = -EINVAL;
5748         goto port_unlock;
5749     }
5750
5751     port->upcoming_state = SNK_NEGOTIATE_PPS_CAPABILITIES;
5752     ret = tcpm_ams_start(port, POWER_NEGOTIATION);
5753     if (ret == -EAGAIN) {
5754         port->upcoming_state = INVALID_STATE;
5755         goto port_unlock;
5756     }
5757
5758     /* Round down operating current to align with PPS valid steps */
5759     req_op_curr = req_op_curr - (req_op_curr % RDO_PROG_CURR_MA_STEP);
5760
5761     reinit_completion(&port->pps_complete);
5762     port->pps_data.req_op_curr = req_op_curr;
5763     port->pps_status = 0;
5764     port->pps_pending = true;
5765     mutex_unlock(&port->lock);
5766
5767     if (!wait_for_completion_timeout(&port->pps_complete,
5768                 msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT)))
5769         ret = -ETIMEDOUT;
5770     else
5771         ret = port->pps_status;
5772
5773     goto swap_unlock;
5774
5775 port_unlock:
5776     mutex_unlock(&port->lock);
5777 swap_unlock:
5778     mutex_unlock(&port->swap_lock);
5779
5780     return ret;
5781 }
5782
5783 static int tcpm_pps_set_out_volt(struct tcpm_port *port, u16 req_out_volt)
5784 {
5785     unsigned int target_mw;
5786     int ret;
5787
5788     mutex_lock(&port->swap_lock);
5789     mutex_lock(&port->lock);
5790
5791     if (!port->pps_data.active) {
5792         ret = -EOPNOTSUPP;
5793         goto port_unlock;
5794     }
5795
5796     if (port->state != SNK_READY) {
5797         ret = -EAGAIN;
5798         goto port_unlock;
5799     }
5800
5801     if (req_out_volt < port->pps_data.min_volt ||
5802         req_out_volt > port->pps_data.max_volt) {
5803         ret = -EINVAL;
5804         goto port_unlock;
5805     }
5806
5807     target_mw = (port->current_limit * req_out_volt) / 1000;
5808     if (target_mw < port->operating_snk_mw) {
5809         ret = -EINVAL;
5810         goto port_unlock;
5811     }
5812
5813     port->upcoming_state = SNK_NEGOTIATE_PPS_CAPABILITIES;
5814     ret = tcpm_ams_start(port, POWER_NEGOTIATION);
5815     if (ret == -EAGAIN) {
5816         port->upcoming_state = INVALID_STATE;
5817         goto port_unlock;
5818     }
5819
5820     /* Round down output voltage to align with PPS valid steps */
5821     req_out_volt = req_out_volt - (req_out_volt % RDO_PROG_VOLT_MV_STEP);
5822
5823     reinit_completion(&port->pps_complete);
5824     port->pps_data.req_out_volt = req_out_volt;
5825     port->pps_status = 0;
5826     port->pps_pending = true;
5827     mutex_unlock(&port->lock);
5828
5829     if (!wait_for_completion_timeout(&port->pps_complete,
5830                 msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT)))
5831         ret = -ETIMEDOUT;
5832     else
5833         ret = port->pps_status;
5834
5835     goto swap_unlock;
5836
5837 port_unlock:
5838     mutex_unlock(&port->lock);
5839 swap_unlock:
5840     mutex_unlock(&port->swap_lock);
5841
5842     return ret;
5843 }
5844
5845 static int tcpm_pps_activate(struct tcpm_port *port, bool activate)
5846 {
5847     int ret = 0;
5848
5849     mutex_lock(&port->swap_lock);
5850     mutex_lock(&port->lock);
5851
5852     if (!port->pps_data.supported) {
5853         ret = -EOPNOTSUPP;
5854         goto port_unlock;
5855     }
5856
5857     /* Trying to deactivate PPS when already deactivated so just bail */
5858     if (!port->pps_data.active && !activate)
5859         goto port_unlock;
5860
5861     if (port->state != SNK_READY) {
5862         ret = -EAGAIN;
5863         goto port_unlock;
5864     }
5865
5866     if (activate)
5867         port->upcoming_state = SNK_NEGOTIATE_PPS_CAPABILITIES;
5868     else
5869         port->upcoming_state = SNK_NEGOTIATE_CAPABILITIES;
5870     ret = tcpm_ams_start(port, POWER_NEGOTIATION);
5871     if (ret == -EAGAIN) {
5872         port->upcoming_state = INVALID_STATE;
5873         goto port_unlock;
5874     }
5875
5876     reinit_completion(&port->pps_complete);
5877     port->pps_status = 0;
5878     port->pps_pending = true;
5879
5880     /* Trigger PPS request or move back to standard PDO contract */
5881     if (activate) {
5882         port->pps_data.req_out_volt = port->supply_voltage;
5883         port->pps_data.req_op_curr = port->current_limit;
5884     }
5885     mutex_unlock(&port->lock);
5886
5887     if (!wait_for_completion_timeout(&port->pps_complete,
5888                 msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT)))
5889         ret = -ETIMEDOUT;
5890     else
5891         ret = port->pps_status;
5892
5893     goto swap_unlock;
5894
5895 port_unlock:
5896     mutex_unlock(&port->lock);
5897 swap_unlock:
5898     mutex_unlock(&port->swap_lock);
5899
5900     return ret;
5901 }
5902
5903 static void tcpm_init(struct tcpm_port *port)
5904 {
5905     enum typec_cc_status cc1, cc2;
5906
5907     port->tcpc->init(port->tcpc);
5908
5909     tcpm_reset_port(port);
5910
5911     /*
5912      * XXX
5913      * Should possibly wait for VBUS to settle if it was enabled locally
5914      * since tcpm_reset_port() will disable VBUS.
5915      */
5916     port->vbus_present = port->tcpc->get_vbus(port->tcpc);
5917     if (port->vbus_present)
5918         port->vbus_never_low = true;
5919
5920     /*
5921      * 1. When vbus_present is true, voltage on VBUS is already at VSAFE5V.
5922      * So implicitly vbus_vsafe0v = false.
5923      *
5924      * 2. When vbus_present is false and TCPC does NOT support querying
5925      * vsafe0v status, then, it's best to assume vbus is at VSAFE0V i.e.
5926      * vbus_vsafe0v is true.
5927      *
5928      * 3. When vbus_present is false and TCPC does support querying vsafe0v,
5929      * then, query tcpc for vsafe0v status.
5930      */
5931     if (port->vbus_present)
5932         port->vbus_vsafe0v = false;
5933     else if (!port->tcpc->is_vbus_vsafe0v)
5934         port->vbus_vsafe0v = true;
5935     else
5936         port->vbus_vsafe0v = port->tcpc->is_vbus_vsafe0v(port->tcpc);
5937
5938     tcpm_set_state(port, tcpm_default_state(port), 0);
5939
5940     if (port->tcpc->get_cc(port->tcpc, &cc1, &cc2) == 0)
5941         _tcpm_cc_change(port, cc1, cc2);
5942
5943     /*
5944      * Some adapters need a clean slate at startup, and won't recover
5945      * otherwise. So do not try to be fancy and force a clean disconnect.
5946      */
5947     tcpm_set_state(port, PORT_RESET, 0);
5948 }
5949
5950 static int tcpm_port_type_set(struct typec_port *p, enum typec_port_type type)
5951 {
5952     struct tcpm_port *port = typec_get_drvdata(p);
5953
5954     mutex_lock(&port->lock);
5955     if (type == port->port_type)
5956         goto port_unlock;
5957
5958     port->port_type = type;
5959
5960     if (!port->connected) {
5961         tcpm_set_state(port, PORT_RESET, 0);
5962     } else if (type == TYPEC_PORT_SNK) {
5963         if (!(port->pwr_role == TYPEC_SINK &&
5964               port->data_role == TYPEC_DEVICE))
5965             tcpm_set_state(port, PORT_RESET, 0);
5966     } else if (type == TYPEC_PORT_SRC) {
5967         if (!(port->pwr_role == TYPEC_SOURCE &&
5968               port->data_role == TYPEC_HOST))
5969             tcpm_set_state(port, PORT_RESET, 0);
5970     }
5971
5972 port_unlock:
5973     mutex_unlock(&port->lock);
5974     return 0;
5975 }
5976
5977 static const struct typec_operations tcpm_ops = {
5978     .try_role = tcpm_try_role,
5979     .dr_set = tcpm_dr_set,
5980     .pr_set = tcpm_pr_set,
5981     .vconn_set = tcpm_vconn_set,
5982     .port_type_set = tcpm_port_type_set
5983 };
5984
5985 void tcpm_tcpc_reset(struct tcpm_port *port)
5986 {
5987     mutex_lock(&port->lock);
5988     /* XXX: Maintain PD connection if possible? */
5989     tcpm_init(port);
5990     mutex_unlock(&port->lock);
5991 }
5992 EXPORT_SYMBOL_GPL(tcpm_tcpc_reset);
5993
5994 static void tcpm_port_unregister_pd(struct tcpm_port *port)
5995 {
5996     usb_power_delivery_unregister_capabilities(port->port_sink_caps);
5997     port->port_sink_caps = NULL;
5998     usb_power_delivery_unregister_capabilities(port->port_source_caps);
5999     port->port_source_caps = NULL;
6000     usb_power_delivery_unregister(port->pd);
6001     port->pd = NULL;
6002 }
6003
6004 static int tcpm_port_register_pd(struct tcpm_port *port)
6005 {
6006     struct usb_power_delivery_desc desc = { port->typec_caps.pd_revision };
6007     struct usb_power_delivery_capabilities_desc caps = { };
6008     struct usb_power_delivery_capabilities *cap;
6009     int ret;
6010
6011     if (!port->nr_src_pdo && !port->nr_snk_pdo)
6012         return 0;
6013
6014     port->pd = usb_power_delivery_register(port->dev, &desc);
6015     if (IS_ERR(port->pd)) {
6016         ret = PTR_ERR(port->pd);
6017         goto err_unregister;
6018     }
6019
6020     if (port->nr_src_pdo) {
6021         memcpy_and_pad(caps.pdo, sizeof(caps.pdo), port->src_pdo,
6022                    port->nr_src_pdo * sizeof(u32), 0);
6023         caps.role = TYPEC_SOURCE;
6024
6025         cap = usb_power_delivery_register_capabilities(port->pd, &caps);
6026         if (IS_ERR(cap)) {
6027             ret = PTR_ERR(cap);
6028             goto err_unregister;
6029         }
6030
6031         port->port_source_caps = cap;
6032     }
6033
6034     if (port->nr_snk_pdo) {
6035         memcpy_and_pad(caps.pdo, sizeof(caps.pdo), port->snk_pdo,
6036                    port->nr_snk_pdo * sizeof(u32), 0);
6037         caps.role = TYPEC_SINK;
6038
6039         cap = usb_power_delivery_register_capabilities(port->pd, &caps);
6040         if (IS_ERR(cap)) {
6041             ret = PTR_ERR(cap);
6042             goto err_unregister;
6043         }
6044
6045         port->port_sink_caps = cap;
6046     }
6047
6048     return 0;
6049
6050 err_unregister:
6051     tcpm_port_unregister_pd(port);
6052
6053     return ret;
6054 }
6055
6056 static int tcpm_fw_get_caps(struct tcpm_port *port,
6057                 struct fwnode_handle *fwnode)
6058 {
6059     const char *opmode_str;
6060     int ret;
6061     u32 mw, frs_current;
6062
6063     if (!fwnode)
6064         return -EINVAL;
6065
6066     /*
6067      * This fwnode has a "compatible" property, but is never populated as a
6068      * struct device. Instead we simply parse it to read the properties.
6069      * This it breaks fw_devlink=on. To maintain backward compatibility
6070      * with existing DT files, we work around this by deleting any
6071      * fwnode_links to/from this fwnode.
6072      */
6073     fw_devlink_purge_absent_suppliers(fwnode);
6074
6075     ret = typec_get_fw_cap(&port->typec_caps, fwnode);
6076     if (ret < 0)
6077         return ret;
6078
6079     port->port_type = port->typec_caps.type;
6080     port->pd_supported = !fwnode_property_read_bool(fwnode, "pd-disable");
6081
6082     port->slow_charger_loop = fwnode_property_read_bool(fwnode, "slow-charger-loop");
6083     if (port->port_type == TYPEC_PORT_SNK)
6084         goto sink;
6085
6086     /* Get Source PDOs for the PD port or Source Rp value for the non-PD port */
6087     if (port->pd_supported) {
6088         ret = fwnode_property_count_u32(fwnode, "source-pdos");
6089         if (ret == 0)
6090             return -EINVAL;
6091         else if (ret < 0)
6092             return ret;
6093
6094         port->nr_src_pdo = min(ret, PDO_MAX_OBJECTS);
6095         ret = fwnode_property_read_u32_array(fwnode, "source-pdos",
6096                              port->src_pdo, port->nr_src_pdo);
6097         if (ret)
6098             return ret;
6099         ret = tcpm_validate_caps(port, port->src_pdo, port->nr_src_pdo);
6100         if (ret)
6101             return ret;
6102     } else {
6103         ret = fwnode_property_read_string(fwnode, "typec-power-opmode", &opmode_str);
6104         if (ret)
6105             return ret;
6106         ret = typec_find_pwr_opmode(opmode_str);
6107         if (ret < 0)
6108             return ret;
6109         port->src_rp = tcpm_pwr_opmode_to_rp(ret);
6110     }
6111
6112     if (port->port_type == TYPEC_PORT_SRC)
6113         return 0;
6114
6115 sink:
6116     port->self_powered = fwnode_property_read_bool(fwnode, "self-powered");
6117
6118     if (!port->pd_supported)
6119         return 0;
6120
6121     /* Get sink pdos */
6122     ret = fwnode_property_count_u32(fwnode, "sink-pdos");
6123     if (ret <= 0)
6124         return -EINVAL;
6125
6126     port->nr_snk_pdo = min(ret, PDO_MAX_OBJECTS);
6127     ret = fwnode_property_read_u32_array(fwnode, "sink-pdos",
6128                          port->snk_pdo, port->nr_snk_pdo);
6129     if ((ret < 0) || tcpm_validate_caps(port, port->snk_pdo,
6130                         port->nr_snk_pdo))
6131         return -EINVAL;
6132
6133     if (fwnode_property_read_u32(fwnode, "op-sink-microwatt", &mw) < 0)
6134         return -EINVAL;
6135     port->operating_snk_mw = mw / 1000;
6136
6137     /* FRS can only be supported by DRP ports */
6138     if (port->port_type == TYPEC_PORT_DRP) {
6139         ret = fwnode_property_read_u32(fwnode, "new-source-frs-typec-current",
6140                            &frs_current);
6141         if (ret >= 0 && frs_current <= FRS_5V_3A)
6142             port->new_source_frs_current = frs_current;
6143     }
6144
6145     /* sink-vdos is optional */
6146     ret = fwnode_property_count_u32(fwnode, "sink-vdos");
6147     if (ret < 0)
6148         ret = 0;
6149
6150     port->nr_snk_vdo = min(ret, VDO_MAX_OBJECTS);
6151     if (port->nr_snk_vdo) {
6152         ret = fwnode_property_read_u32_array(fwnode, "sink-vdos",
6153                              port->snk_vdo,
6154                              port->nr_snk_vdo);
6155         if (ret < 0)
6156             return ret;
6157     }
6158
6159     /* If sink-vdos is found, sink-vdos-v1 is expected for backward compatibility. */
6160     if (port->nr_snk_vdo) {
6161         ret = fwnode_property_count_u32(fwnode, "sink-vdos-v1");
6162         if (ret < 0)
6163             return ret;
6164         else if (ret == 0)
6165             return -ENODATA;
6166
6167         port->nr_snk_vdo_v1 = min(ret, VDO_MAX_OBJECTS);
6168         ret = fwnode_property_read_u32_array(fwnode, "sink-vdos-v1",
6169                              port->snk_vdo_v1,
6170                              port->nr_snk_vdo_v1);
6171         if (ret < 0)
6172             return ret;
6173     }
6174
6175     return 0;
6176 }
6177
6178 /* Power Supply access to expose source power information */
6179 enum tcpm_psy_online_states {
6180     TCPM_PSY_OFFLINE = 0,
6181     TCPM_PSY_FIXED_ONLINE,
6182     TCPM_PSY_PROG_ONLINE,
6183 };
6184
6185 static enum power_supply_property tcpm_psy_props[] = {
6186     POWER_SUPPLY_PROP_USB_TYPE,
6187     POWER_SUPPLY_PROP_ONLINE,
6188     POWER_SUPPLY_PROP_VOLTAGE_MIN,
6189     POWER_SUPPLY_PROP_VOLTAGE_MAX,
6190     POWER_SUPPLY_PROP_VOLTAGE_NOW,
6191     POWER_SUPPLY_PROP_CURRENT_MAX,
6192     POWER_SUPPLY_PROP_CURRENT_NOW,
6193 };
6194
6195 static int tcpm_psy_get_online(struct tcpm_port *port,
6196                    union power_supply_propval *val)
6197 {
6198     if (port->vbus_charge) {
6199         if (port->pps_data.active)
6200             val->intval = TCPM_PSY_PROG_ONLINE;
6201         else
6202             val->intval = TCPM_PSY_FIXED_ONLINE;
6203     } else {
6204         val->intval = TCPM_PSY_OFFLINE;
6205     }
6206
6207     return 0;
6208 }
6209
6210 static int tcpm_psy_get_voltage_min(struct tcpm_port *port,
6211                     union power_supply_propval *val)
6212 {
6213     if (port->pps_data.active)
6214         val->intval = port->pps_data.min_volt * 1000;
6215     else
6216         val->intval = port->supply_voltage * 1000;
6217
6218     return 0;
6219 }
6220
6221 static int tcpm_psy_get_voltage_max(struct tcpm_port *port,
6222                     union power_supply_propval *val)
6223 {
6224     if (port->pps_data.active)
6225         val->intval = port->pps_data.max_volt * 1000;
6226     else
6227         val->intval = port->supply_voltage * 1000;
6228
6229     return 0;
6230 }
6231
6232 static int tcpm_psy_get_voltage_now(struct tcpm_port *port,
6233                     union power_supply_propval *val)
6234 {
6235     val->intval = port->supply_voltage * 1000;
6236
6237     return 0;
6238 }
6239
6240 static int tcpm_psy_get_current_max(struct tcpm_port *port,
6241                     union power_supply_propval *val)
6242 {
6243     if (port->pps_data.active)
6244         val->intval = port->pps_data.max_curr * 1000;
6245     else
6246         val->intval = port->current_limit * 1000;
6247
6248     return 0;
6249 }
6250
6251 static int tcpm_psy_get_current_now(struct tcpm_port *port,
6252                     union power_supply_propval *val)
6253 {
6254     val->intval = port->current_limit * 1000;
6255
6256     return 0;
6257 }
6258
6259 static int tcpm_psy_get_prop(struct power_supply *psy,
6260                  enum power_supply_property psp,
6261                  union power_supply_propval *val)
6262 {
6263     struct tcpm_port *port = power_supply_get_drvdata(psy);
6264     int ret = 0;
6265
6266     switch (psp) {
6267     case POWER_SUPPLY_PROP_USB_TYPE:
6268         val->intval = port->usb_type;
6269         break;
6270     case POWER_SUPPLY_PROP_ONLINE:
6271         ret = tcpm_psy_get_online(port, val);
6272         break;
6273     case POWER_SUPPLY_PROP_VOLTAGE_MIN:
6274         ret = tcpm_psy_get_voltage_min(port, val);
6275         break;
6276     case POWER_SUPPLY_PROP_VOLTAGE_MAX:
6277         ret = tcpm_psy_get_voltage_max(port, val);
6278         break;
6279     case POWER_SUPPLY_PROP_VOLTAGE_NOW:
6280         ret = tcpm_psy_get_voltage_now(port, val);
6281         break;
6282     case POWER_SUPPLY_PROP_CURRENT_MAX:
6283         ret = tcpm_psy_get_current_max(port, val);
6284         break;
6285     case POWER_SUPPLY_PROP_CURRENT_NOW:
6286         ret = tcpm_psy_get_current_now(port, val);
6287         break;
6288     default:
6289         ret = -EINVAL;
6290         break;
6291     }
6292
6293     return ret;
6294 }
6295
6296 static int tcpm_psy_set_online(struct tcpm_port *port,
6297                    const union power_supply_propval *val)
6298 {
6299     int ret;
6300
6301     switch (val->intval) {
6302     case TCPM_PSY_FIXED_ONLINE:
6303         ret = tcpm_pps_activate(port, false);
6304         break;
6305     case TCPM_PSY_PROG_ONLINE:
6306         ret = tcpm_pps_activate(port, true);
6307         break;
6308     default:
6309         ret = -EINVAL;
6310         break;
6311     }
6312
6313     return ret;
6314 }
6315
6316 static int tcpm_psy_set_prop(struct power_supply *psy,
6317                  enum power_supply_property psp,
6318                  const union power_supply_propval *val)
6319 {
6320     struct tcpm_port *port = power_supply_get_drvdata(psy);
6321     int ret;
6322
6323     /*
6324      * All the properties below are related to USB PD. The check needs to be
6325      * property specific when a non-pd related property is added.
6326      */
6327     if (!port->pd_supported)
6328         return -EOPNOTSUPP;
6329
6330     switch (psp) {
6331     case POWER_SUPPLY_PROP_ONLINE:
6332         ret = tcpm_psy_set_online(port, val);
6333         break;
6334     case POWER_SUPPLY_PROP_VOLTAGE_NOW:
6335         if (val->intval < port->pps_data.min_volt * 1000 ||
6336             val->intval > port->pps_data.max_volt * 1000)
6337             ret = -EINVAL;
6338         else
6339             ret = tcpm_pps_set_out_volt(port, val->intval / 1000);
6340         break;
6341     case POWER_SUPPLY_PROP_CURRENT_NOW:
6342         if (val->intval > port->pps_data.max_curr * 1000)
6343             ret = -EINVAL;
6344         else
6345             ret = tcpm_pps_set_op_curr(port, val->intval / 1000);
6346         break;
6347     default:
6348         ret = -EINVAL;
6349         break;
6350     }
6351     power_supply_changed(port->psy);
6352     return ret;
6353 }
6354
6355 static int tcpm_psy_prop_writeable(struct power_supply *psy,
6356                    enum power_supply_property psp)
6357 {
6358     switch (psp) {
6359     case POWER_SUPPLY_PROP_ONLINE:
6360     case POWER_SUPPLY_PROP_VOLTAGE_NOW:
6361     case POWER_SUPPLY_PROP_CURRENT_NOW:
6362         return 1;
6363     default:
6364         return 0;
6365     }
6366 }
6367
6368 static enum power_supply_usb_type tcpm_psy_usb_types[] = {
6369     POWER_SUPPLY_USB_TYPE_C,
6370     POWER_SUPPLY_USB_TYPE_PD,
6371     POWER_SUPPLY_USB_TYPE_PD_PPS,
6372 };
6373
6374 static const char *tcpm_psy_name_prefix = "tcpm-source-psy-";
6375
6376 static int devm_tcpm_psy_register(struct tcpm_port *port)
6377 {
6378     struct power_supply_config psy_cfg = {};
6379     const char *port_dev_name = dev_name(port->dev);
6380     size_t psy_name_len = strlen(tcpm_psy_name_prefix) +
6381                      strlen(port_dev_name) + 1;
6382     char *psy_name;
6383
6384     psy_cfg.drv_data = port;
6385     psy_cfg.fwnode = dev_fwnode(port->dev);
6386     psy_name = devm_kzalloc(port->dev, psy_name_len, GFP_KERNEL);
6387     if (!psy_name)
6388         return -ENOMEM;
6389
6390     snprintf(psy_name, psy_name_len, "%s%s", tcpm_psy_name_prefix,
6391          port_dev_name);
6392     port->psy_desc.name = psy_name;
6393     port->psy_desc.type = POWER_SUPPLY_TYPE_USB;
6394     port->psy_desc.usb_types = tcpm_psy_usb_types;
6395     port->psy_desc.num_usb_types = ARRAY_SIZE(tcpm_psy_usb_types);
6396     port->psy_desc.properties = tcpm_psy_props;
6397     port->psy_desc.num_properties = ARRAY_SIZE(tcpm_psy_props);
6398     port->psy_desc.get_property = tcpm_psy_get_prop;
6399     port->psy_desc.set_property = tcpm_psy_set_prop;
6400     port->psy_desc.property_is_writeable = tcpm_psy_prop_writeable;
6401
6402     port->usb_type = POWER_SUPPLY_USB_TYPE_C;
6403
6404     port->psy = devm_power_supply_register(port->dev, &port->psy_desc,
6405                            &psy_cfg);
6406
6407     return PTR_ERR_OR_ZERO(port->psy);
6408 }
6409
6410 static enum hrtimer_restart state_machine_timer_handler(struct hrtimer *timer)
6411 {
6412     struct tcpm_port *port = container_of(timer, struct tcpm_port, state_machine_timer);
6413
6414     if (port->registered)
6415         kthread_queue_work(port->wq, &port->state_machine);
6416     return HRTIMER_NORESTART;
6417 }
6418
6419 static enum hrtimer_restart vdm_state_machine_timer_handler(struct hrtimer *timer)
6420 {
6421     struct tcpm_port *port = container_of(timer, struct tcpm_port, vdm_state_machine_timer);
6422
6423     if (port->registered)
6424         kthread_queue_work(port->wq, &port->vdm_state_machine);
6425     return HRTIMER_NORESTART;
6426 }
6427
6428 static enum hrtimer_restart enable_frs_timer_handler(struct hrtimer *timer)
6429 {
6430     struct tcpm_port *port = container_of(timer, struct tcpm_port, enable_frs_timer);
6431
6432     if (port->registered)
6433         kthread_queue_work(port->wq, &port->enable_frs);
6434     return HRTIMER_NORESTART;
6435 }
6436
6437 static enum hrtimer_restart send_discover_timer_handler(struct hrtimer *timer)
6438 {
6439     struct tcpm_port *port = container_of(timer, struct tcpm_port, send_discover_timer);
6440
6441     if (port->registered)
6442         kthread_queue_work(port->wq, &port->send_discover_work);
6443     return HRTIMER_NORESTART;
6444 }
6445
6446 struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc)
6447 {
6448     struct tcpm_port *port;
6449     int err;
6450
6451     if (!dev || !tcpc ||
6452         !tcpc->get_vbus || !tcpc->set_cc || !tcpc->get_cc ||
6453         !tcpc->set_polarity || !tcpc->set_vconn || !tcpc->set_vbus ||
6454         !tcpc->set_pd_rx || !tcpc->set_roles || !tcpc->pd_transmit)
6455         return ERR_PTR(-EINVAL);
6456
6457     port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL);
6458     if (!port)
6459         return ERR_PTR(-ENOMEM);
6460
6461     port->dev = dev;
6462     port->tcpc = tcpc;
6463
6464     mutex_init(&port->lock);
6465     mutex_init(&port->swap_lock);
6466
6467     port->wq = kthread_create_worker(0, dev_name(dev));
6468     if (IS_ERR(port->wq))
6469         return ERR_CAST(port->wq);
6470     sched_set_fifo(port->wq->task);
6471
6472     kthread_init_work(&port->state_machine, tcpm_state_machine_work);
6473     kthread_init_work(&port->vdm_state_machine, vdm_state_machine_work);
6474     kthread_init_work(&port->event_work, tcpm_pd_event_handler);
6475     kthread_init_work(&port->enable_frs, tcpm_enable_frs_work);
6476     kthread_init_work(&port->send_discover_work, tcpm_send_discover_work);
6477     hrtimer_init(&port->state_machine_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
6478     port->state_machine_timer.function = state_machine_timer_handler;
6479     hrtimer_init(&port->vdm_state_machine_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
6480     port->vdm_state_machine_timer.function = vdm_state_machine_timer_handler;
6481     hrtimer_init(&port->enable_frs_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
6482     port->enable_frs_timer.function = enable_frs_timer_handler;
6483     hrtimer_init(&port->send_discover_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
6484     port->send_discover_timer.function = send_discover_timer_handler;
6485
6486     spin_lock_init(&port->pd_event_lock);
6487
6488     init_completion(&port->tx_complete);
6489     init_completion(&port->swap_complete);
6490     init_completion(&port->pps_complete);
6491     tcpm_debugfs_init(port);
6492
6493     err = tcpm_fw_get_caps(port, tcpc->fwnode);
6494     if (err < 0)
6495         goto out_destroy_wq;
6496
6497     port->try_role = port->typec_caps.prefer_role;
6498
6499     port->typec_caps.fwnode = tcpc->fwnode;
6500     port->typec_caps.revision = 0x0120; /* Type-C spec release 1.2 */
6501     port->typec_caps.pd_revision = 0x0300;  /* USB-PD spec release 3.0 */
6502     port->typec_caps.svdm_version = SVDM_VER_2_0;
6503     port->typec_caps.driver_data = port;
6504     port->typec_caps.ops = &tcpm_ops;
6505     port->typec_caps.orientation_aware = 1;
6506
6507     port->partner_desc.identity = &port->partner_ident;
6508     port->port_type = port->typec_caps.type;
6509
6510     port->role_sw = usb_role_switch_get(port->dev);
6511     if (IS_ERR(port->role_sw)) {
6512         err = PTR_ERR(port->role_sw);
6513         goto out_destroy_wq;
6514     }
6515
6516     err = devm_tcpm_psy_register(port);
6517     if (err)
6518         goto out_role_sw_put;
6519     power_supply_changed(port->psy);
6520
6521     err = tcpm_port_register_pd(port);
6522     if (err)
6523         goto out_role_sw_put;
6524
6525     port->typec_caps.pd = port->pd;
6526
6527     port->typec_port = typec_register_port(port->dev, &port->typec_caps);
6528     if (IS_ERR(port->typec_port)) {
6529         err = PTR_ERR(port->typec_port);
6530         goto out_unregister_pd;
6531     }
6532
6533     typec_port_register_altmodes(port->typec_port,
6534                      &tcpm_altmode_ops, port,
6535                      port->port_altmode, ALTMODE_DISCOVERY_MAX);
6536     port->registered = true;
6537
6538     mutex_lock(&port->lock);
6539     tcpm_init(port);
6540     mutex_unlock(&port->lock);
6541
6542     tcpm_log(port, "%s: registered", dev_name(dev));
6543     return port;
6544
6545 out_unregister_pd:
6546     tcpm_port_unregister_pd(port);
6547 out_role_sw_put:
6548     usb_role_switch_put(port->role_sw);
6549 out_destroy_wq:
6550     tcpm_debugfs_exit(port);
6551     kthread_destroy_worker(port->wq);
6552     return ERR_PTR(err);
6553 }
6554 EXPORT_SYMBOL_GPL(tcpm_register_port);
6555
6556 void tcpm_unregister_port(struct tcpm_port *port)
6557 {
6558     int i;
6559
6560     port->registered = false;
6561     kthread_destroy_worker(port->wq);
6562
6563     hrtimer_cancel(&port->send_discover_timer);
6564     hrtimer_cancel(&port->enable_frs_timer);
6565     hrtimer_cancel(&port->vdm_state_machine_timer);
6566     hrtimer_cancel(&port->state_machine_timer);
6567
6568     tcpm_reset_port(port);
6569
6570     tcpm_port_unregister_pd(port);
6571
6572     for (i = 0; i < ARRAY_SIZE(port->port_altmode); i++)
6573         typec_unregister_altmode(port->port_altmode[i]);
6574     typec_unregister_port(port->typec_port);
6575     usb_role_switch_put(port->role_sw);
6576     tcpm_debugfs_exit(port);
6577 }
6578 EXPORT_SYMBOL_GPL(tcpm_unregister_port);
6579
6580 MODULE_AUTHOR("Guenter Roeck <groeck@chromium.org>");
6581 MODULE_DESCRIPTION("USB Type-C Port Manager");
6582 MODULE_LICENSE("GPL");