Merge tag 'usb-4.17-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb

Pull USB/PHY updates from Greg KH:
 "Here is the big set of USB and PHY driver patches for 4.17-rc1.

  Lots of USB typeC work happened this round, with code moving from the
  staging directory into the "real" part of the kernel, as well as new
  infrastructure being added to be able to handle the different types of
  "roles" that typeC requires.

  There is also the normal huge set of USB gadget controller and driver
  updates, along with XHCI changes, and a raft of other tiny fixes all
  over the USB tree. And the PHY driver updates are merged in here as
  well as they interacted with the USB drivers in some places.

  All of these have been in linux-next for a while with no reported
  issues"

* tag 'usb-4.17-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: (250 commits)
  Revert "USB: serial: ftdi_sio: add Id for Physik Instrumente E-870"
  usb: musb: gadget: misplaced out of bounds check
  usb: chipidea: imx: Fix ULPI on imx53
  usb: chipidea: imx: Cleanup ci_hdrc_imx_platform_flag
  usb: chipidea: usbmisc: small clean up
  usb: chipidea: usbmisc: evdo can be set e/o reset
  usb: chipidea: usbmisc: evdo is only specific to OTG port
  USB: serial: ftdi_sio: add Id for Physik Instrumente E-870
  usb: dwc3: gadget: never call ->complete() from ->ep_queue()
  usb: gadget: udc: core: update usb_ep_queue() documentation
  usb: host: Remove the deprecated ATH79 USB host config options
  usb: roles: Fix return value check in intel_xhci_usb_probe()
  USB: gadget: f_midi: fixing a possible double-free in f_midi
  usb: core: Add USB_QUIRK_DELAY_CTRL_MSG to usbcore quirks
  usb: core: Copy parameter string correctly and remove superfluous null check
  USB: announce bcdDevice as well as idVendor, idProduct.
  USB:fix USB3 devices behind USB3 hubs not resuming at hibernate thaw
  usb: hub: Reduce warning to notice on power loss
  USB: serial: ftdi_sio: add support for Harman FirmwareHubEmulator
  USB: serial: cp210x: add ELDAT Easywave RX09 id
  ...

12 files changed, 443 insertions, 31 deletions

diff --git a/include/linux/device.h b/include/linux/device.h
index abf952c82c6d..4b5a4925b780 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -730,6 +730,28 @@ struct device_dma_parameters {
 };
 
 /**
+ * struct device_connection - Device Connection Descriptor
+ * @endpoint: The names of the two devices connected together
+ * @id: Unique identifier for the connection
+ * @list: List head, private, for internal use only
+ */
+struct device_connection {
+        const char              *endpoint[2];
+        const char              *id;
+        struct list_head        list;
+};
+
+void *device_connection_find_match(struct device *dev, const char *con_id,
+                                void *data,
+                                void *(*match)(struct device_connection *con,
+                                               int ep, void *data));
+
+struct device *device_connection_find(struct device *dev, const char *con_id);
+
+void device_connection_add(struct device_connection *con);
+void device_connection_remove(struct device_connection *con);
+
+/**
  * enum device_link_state - Device link states.
  * @DL_STATE_NONE: The presence of the drivers is not being tracked.
  * @DL_STATE_DORMANT: None of the supplier/consumer drivers is present.
diff --git a/include/linux/phy/phy.h b/include/linux/phy/phy.h
index 4f8423a948d5..c9d14eeee7f5 100644
--- a/include/linux/phy/phy.h
+++ b/include/linux/phy/phy.h
@@ -25,7 +25,15 @@ struct phy;
 enum phy_mode {
         PHY_MODE_INVALID,
         PHY_MODE_USB_HOST,
+        PHY_MODE_USB_HOST_LS,
+        PHY_MODE_USB_HOST_FS,
+        PHY_MODE_USB_HOST_HS,
+        PHY_MODE_USB_HOST_SS,
         PHY_MODE_USB_DEVICE,
+        PHY_MODE_USB_DEVICE_LS,
+        PHY_MODE_USB_DEVICE_FS,
+        PHY_MODE_USB_DEVICE_HS,
+        PHY_MODE_USB_DEVICE_SS,
         PHY_MODE_USB_OTG,
         PHY_MODE_SGMII,
         PHY_MODE_10GKR,
@@ -61,6 +69,7 @@ struct phy_ops {
  */
 struct phy_attrs {
         u32                     bus_width;
+        enum phy_mode           mode;
 };
 
 /**
@@ -72,7 +81,8 @@ struct phy_attrs {
  * @mutex: mutex to protect phy_ops
  * @init_count: used to protect when the PHY is used by multiple consumers
  * @power_count: used to protect when the PHY is used by multiple consumers
- * @phy_attrs: used to specify PHY specific attributes
+ * @attrs: used to specify PHY specific attributes
+ * @pwr: power regulator associated with the phy
  */
 struct phy {
         struct device           dev;
@@ -88,9 +98,10 @@ struct phy {
 /**
  * struct phy_provider - represents the phy provider
  * @dev: phy provider device
+ * @children: can be used to override the default (dev->of_node) child node
  * @owner: the module owner having of_xlate
- * @of_xlate: function pointer to obtain phy instance from phy pointer
  * @list: to maintain a linked list of PHY providers
+ * @of_xlate: function pointer to obtain phy instance from phy pointer
  */
 struct phy_provider {
         struct device           *dev;
@@ -101,6 +112,13 @@ struct phy_provider {
                 struct of_phandle_args *args);
 };
 
+/**
+ * struct phy_lookup - PHY association in list of phys managed by the phy driver
+ * @node: list node
+ * @dev_id: the device of the association
+ * @con_id: connection ID string on device
+ * @phy: the phy of the association
+ */
 struct phy_lookup {
         struct list_head node;
         const char *dev_id;
@@ -144,6 +162,10 @@ int phy_exit(struct phy *phy);
 int phy_power_on(struct phy *phy);
 int phy_power_off(struct phy *phy);
 int phy_set_mode(struct phy *phy, enum phy_mode mode);
+static inline enum phy_mode phy_get_mode(struct phy *phy)
+{
+        return phy->attrs.mode;
+}
 int phy_reset(struct phy *phy);
 int phy_calibrate(struct phy *phy);
 static inline int phy_get_bus_width(struct phy *phy)
@@ -260,6 +282,11 @@ static inline int phy_set_mode(struct phy *phy, enum phy_mode mode)
         return -ENOSYS;
 }
 
+static inline enum phy_mode phy_get_mode(struct phy *phy)
+{
+        return PHY_MODE_INVALID;
+}
+
 static inline int phy_reset(struct phy *phy)
 {
         if (!phy)
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
index cef0e44601f8..4b6b9283fa7b 100644
--- a/include/linux/usb/composite.h
+++ b/include/linux/usb/composite.h
@@ -54,6 +54,9 @@
 /* big enough to hold our biggest descriptor */
 #define USB_COMP_EP0_BUFSIZ     1024
 
+/* OS feature descriptor length <= 4kB */
+#define USB_COMP_EP0_OS_DESC_BUFSIZ     4096
+
 #define USB_MS_TO_HS_INTERVAL(x)        (ilog2((x * 1000 / 125)) + 1)
 struct usb_configuration;
 
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index 66a5cff7ee14..e3424234b23a 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -129,6 +129,7 @@ struct usb_ep_ops {
         int (*enable) (struct usb_ep *ep,
                 const struct usb_endpoint_descriptor *desc);
         int (*disable) (struct usb_ep *ep);
+        void (*dispose) (struct usb_ep *ep);
 
         struct usb_request *(*alloc_request) (struct usb_ep *ep,
                 gfp_t gfp_flags);
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index 176900528822..aef50cb2ed1b 100644
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -103,7 +103,7 @@ struct usb_hcd {
          * other external phys should be software-transparent
          */
         struct usb_phy          *usb_phy;
-        struct phy              *phy;
+        struct usb_phy_roothub  *phy_roothub;
 
         /* Flags that need to be manipulated atomically because they can
          * change while the host controller is running.  Always use
@@ -151,6 +151,12 @@ struct usb_hcd {
         unsigned                msix_enabled:1; /* driver has MSI-X enabled? */
         unsigned                msi_enabled:1;  /* driver has MSI enabled? */
         unsigned                remove_phy:1;   /* auto-remove USB phy */
+        /*
+         * do not manage the PHY state in the HCD core, instead let the driver
+         * handle this (for example if the PHY can only be turned on after a
+         * specific event)
+         */
+        unsigned                skip_phy_initialization:1;
 
         /* The next flag is a stopgap, to be removed when all the HCDs
          * support the new root-hub polling mechanism. */
diff --git a/include/linux/usb/pd.h b/include/linux/usb/pd.h
index b3d41d7409b3..ff359bdfdc7b 100644
--- a/include/linux/usb/pd.h
+++ b/include/linux/usb/pd.h
@@ -35,6 +35,13 @@ enum pd_ctrl_msg_type {
         PD_CTRL_WAIT = 12,
         PD_CTRL_SOFT_RESET = 13,
         /* 14-15 Reserved */
+        PD_CTRL_NOT_SUPP = 16,
+        PD_CTRL_GET_SOURCE_CAP_EXT = 17,
+        PD_CTRL_GET_STATUS = 18,
+        PD_CTRL_FR_SWAP = 19,
+        PD_CTRL_GET_PPS_STATUS = 20,
+        PD_CTRL_GET_COUNTRY_CODES = 21,
+        /* 22-31 Reserved */
 };
 
 enum pd_data_msg_type {
@@ -43,13 +50,39 @@ enum pd_data_msg_type {
         PD_DATA_REQUEST = 2,
         PD_DATA_BIST = 3,
         PD_DATA_SINK_CAP = 4,
-        /* 5-14 Reserved */
+        PD_DATA_BATT_STATUS = 5,
+        PD_DATA_ALERT = 6,
+        PD_DATA_GET_COUNTRY_INFO = 7,
+        /* 8-14 Reserved */
         PD_DATA_VENDOR_DEF = 15,
+        /* 16-31 Reserved */
+};
+
+enum pd_ext_msg_type {
+        /* 0 Reserved */
+        PD_EXT_SOURCE_CAP_EXT = 1,
+        PD_EXT_STATUS = 2,
+        PD_EXT_GET_BATT_CAP = 3,
+        PD_EXT_GET_BATT_STATUS = 4,
+        PD_EXT_BATT_CAP = 5,
+        PD_EXT_GET_MANUFACTURER_INFO = 6,
+        PD_EXT_MANUFACTURER_INFO = 7,
+        PD_EXT_SECURITY_REQUEST = 8,
+        PD_EXT_SECURITY_RESPONSE = 9,
+        PD_EXT_FW_UPDATE_REQUEST = 10,
+        PD_EXT_FW_UPDATE_RESPONSE = 11,
+        PD_EXT_PPS_STATUS = 12,
+        PD_EXT_COUNTRY_INFO = 13,
+        PD_EXT_COUNTRY_CODES = 14,
+        /* 15-31 Reserved */
 };
 
 #define PD_REV10        0x0
 #define PD_REV20        0x1
+#define PD_REV30        0x2
+#define PD_MAX_REV      PD_REV30
 
+#define PD_HEADER_EXT_HDR       BIT(15)
 #define PD_HEADER_CNT_SHIFT     12
 #define PD_HEADER_CNT_MASK      0x7
 #define PD_HEADER_ID_SHIFT      9
@@ -59,18 +92,19 @@ enum pd_data_msg_type {
 #define PD_HEADER_REV_MASK      0x3
 #define PD_HEADER_DATA_ROLE     BIT(5)
 #define PD_HEADER_TYPE_SHIFT    0
-#define PD_HEADER_TYPE_MASK     0xf
+#define PD_HEADER_TYPE_MASK     0x1f
 
-#define PD_HEADER(type, pwr, data, id, cnt)                             \
+#define PD_HEADER(type, pwr, data, rev, id, cnt, ext_hdr)               \
         ((((type) & PD_HEADER_TYPE_MASK) << PD_HEADER_TYPE_SHIFT) |     \
          ((pwr) == TYPEC_SOURCE ? PD_HEADER_PWR_ROLE : 0) |             \
          ((data) == TYPEC_HOST ? PD_HEADER_DATA_ROLE : 0) |             \
-         (PD_REV20 << PD_HEADER_REV_SHIFT) |                            \
+         (rev << PD_HEADER_REV_SHIFT) |                                 \
          (((id) & PD_HEADER_ID_MASK) << PD_HEADER_ID_SHIFT) |           \
-         (((cnt) & PD_HEADER_CNT_MASK) << PD_HEADER_CNT_SHIFT))
+         (((cnt) & PD_HEADER_CNT_MASK) << PD_HEADER_CNT_SHIFT) |        \
+         ((ext_hdr) ? PD_HEADER_EXT_HDR : 0))
 
 #define PD_HEADER_LE(type, pwr, data, id, cnt) \
-        cpu_to_le16(PD_HEADER((type), (pwr), (data), (id), (cnt)))
+        cpu_to_le16(PD_HEADER((type), (pwr), (data), PD_REV20, (id), (cnt), (0)))
 
 static inline unsigned int pd_header_cnt(u16 header)
 {
@@ -102,16 +136,75 @@ static inline unsigned int pd_header_msgid_le(__le16 header)
         return pd_header_msgid(le16_to_cpu(header));
 }
 
+static inline unsigned int pd_header_rev(u16 header)
+{
+        return (header >> PD_HEADER_REV_SHIFT) & PD_HEADER_REV_MASK;
+}
+
+static inline unsigned int pd_header_rev_le(__le16 header)
+{
+        return pd_header_rev(le16_to_cpu(header));
+}
+
+#define PD_EXT_HDR_CHUNKED              BIT(15)
+#define PD_EXT_HDR_CHUNK_NUM_SHIFT      11
+#define PD_EXT_HDR_CHUNK_NUM_MASK       0xf
+#define PD_EXT_HDR_REQ_CHUNK            BIT(10)
+#define PD_EXT_HDR_DATA_SIZE_SHIFT      0
+#define PD_EXT_HDR_DATA_SIZE_MASK       0x1ff
+
+#define PD_EXT_HDR(data_size, req_chunk, chunk_num, chunked)                            \
+        ((((data_size) & PD_EXT_HDR_DATA_SIZE_MASK) << PD_EXT_HDR_DATA_SIZE_SHIFT) |    \
+         ((req_chunk) ? PD_EXT_HDR_REQ_CHUNK : 0) |                                     \
+         (((chunk_num) & PD_EXT_HDR_CHUNK_NUM_MASK) << PD_EXT_HDR_CHUNK_NUM_SHIFT) |    \
+         ((chunked) ? PD_EXT_HDR_CHUNKED : 0))
+
+#define PD_EXT_HDR_LE(data_size, req_chunk, chunk_num, chunked) \
+        cpu_to_le16(PD_EXT_HDR((data_size), (req_chunk), (chunk_num), (chunked)))
+
+static inline unsigned int pd_ext_header_chunk_num(u16 ext_header)
+{
+        return (ext_header >> PD_EXT_HDR_CHUNK_NUM_SHIFT) &
+                PD_EXT_HDR_CHUNK_NUM_MASK;
+}
+
+static inline unsigned int pd_ext_header_data_size(u16 ext_header)
+{
+        return (ext_header >> PD_EXT_HDR_DATA_SIZE_SHIFT) &
+                PD_EXT_HDR_DATA_SIZE_MASK;
+}
+
+static inline unsigned int pd_ext_header_data_size_le(__le16 ext_header)
+{
+        return pd_ext_header_data_size(le16_to_cpu(ext_header));
+}
+
 #define PD_MAX_PAYLOAD          7
+#define PD_EXT_MAX_CHUNK_DATA   26
 
 /**
- * struct pd_message - PD message as seen on wire
- * @header:     PD message header
- * @payload:    PD message payload
- */
+  * struct pd_chunked_ext_message_data - PD chunked extended message data as
+  *                                      seen on wire
+  * @header:    PD extended message header
+  * @data:      PD extended message data
+  */
+struct pd_chunked_ext_message_data {
+        __le16 header;
+        u8 data[PD_EXT_MAX_CHUNK_DATA];
+} __packed;
+
+/**
+  * struct pd_message - PD message as seen on wire
+  * @header:    PD message header
+  * @payload:   PD message payload
+  * @ext_msg:   PD message chunked extended message data
+  */
 struct pd_message {
         __le16 header;
-        __le32 payload[PD_MAX_PAYLOAD];
+        union {
+                __le32 payload[PD_MAX_PAYLOAD];
+                struct pd_chunked_ext_message_data ext_msg;
+        };
 } __packed;
 
 /* PDO: Power Data Object */
@@ -121,6 +214,7 @@ enum pd_pdo_type {
         PDO_TYPE_FIXED = 0,
         PDO_TYPE_BATT = 1,
         PDO_TYPE_VAR = 2,
+        PDO_TYPE_APDO = 3,
 };
 
 #define PDO_TYPE_SHIFT          30
@@ -174,6 +268,34 @@ enum pd_pdo_type {
         (PDO_TYPE(PDO_TYPE_VAR) | PDO_VAR_MIN_VOLT(min_mv) |    \
          PDO_VAR_MAX_VOLT(max_mv) | PDO_VAR_MAX_CURR(max_ma))
 
+enum pd_apdo_type {
+        APDO_TYPE_PPS = 0,
+};
+
+#define PDO_APDO_TYPE_SHIFT     28      /* Only valid value currently is 0x0 - PPS */
+#define PDO_APDO_TYPE_MASK      0x3
+
+#define PDO_APDO_TYPE(t)        ((t) << PDO_APDO_TYPE_SHIFT)
+
+#define PDO_PPS_APDO_MAX_VOLT_SHIFT     17      /* 100mV units */
+#define PDO_PPS_APDO_MIN_VOLT_SHIFT     8       /* 100mV units */
+#define PDO_PPS_APDO_MAX_CURR_SHIFT     0       /* 50mA units */
+
+#define PDO_PPS_APDO_VOLT_MASK  0xff
+#define PDO_PPS_APDO_CURR_MASK  0x7f
+
+#define PDO_PPS_APDO_MIN_VOLT(mv)       \
+        ((((mv) / 100) & PDO_PPS_APDO_VOLT_MASK) << PDO_PPS_APDO_MIN_VOLT_SHIFT)
+#define PDO_PPS_APDO_MAX_VOLT(mv)       \
+        ((((mv) / 100) & PDO_PPS_APDO_VOLT_MASK) << PDO_PPS_APDO_MAX_VOLT_SHIFT)
+#define PDO_PPS_APDO_MAX_CURR(ma)       \
+        ((((ma) / 50) & PDO_PPS_APDO_CURR_MASK) << PDO_PPS_APDO_MAX_CURR_SHIFT)
+
+#define PDO_PPS_APDO(min_mv, max_mv, max_ma)                            \
+        (PDO_TYPE(PDO_TYPE_APDO) | PDO_APDO_TYPE(APDO_TYPE_PPS) |       \
+        PDO_PPS_APDO_MIN_VOLT(min_mv) | PDO_PPS_APDO_MAX_VOLT(max_mv) | \
+        PDO_PPS_APDO_MAX_CURR(max_ma))
+
 static inline enum pd_pdo_type pdo_type(u32 pdo)
 {
         return (pdo >> PDO_TYPE_SHIFT) & PDO_TYPE_MASK;
@@ -204,6 +326,29 @@ static inline unsigned int pdo_max_power(u32 pdo)
         return ((pdo >> PDO_BATT_MAX_PWR_SHIFT) & PDO_PWR_MASK) * 250;
 }
 
+static inline enum pd_apdo_type pdo_apdo_type(u32 pdo)
+{
+        return (pdo >> PDO_APDO_TYPE_SHIFT) & PDO_APDO_TYPE_MASK;
+}
+
+static inline unsigned int pdo_pps_apdo_min_voltage(u32 pdo)
+{
+        return ((pdo >> PDO_PPS_APDO_MIN_VOLT_SHIFT) &
+                PDO_PPS_APDO_VOLT_MASK) * 100;
+}
+
+static inline unsigned int pdo_pps_apdo_max_voltage(u32 pdo)
+{
+        return ((pdo >> PDO_PPS_APDO_MAX_VOLT_SHIFT) &
+                PDO_PPS_APDO_VOLT_MASK) * 100;
+}
+
+static inline unsigned int pdo_pps_apdo_max_current(u32 pdo)
+{
+        return ((pdo >> PDO_PPS_APDO_MAX_CURR_SHIFT) &
+                PDO_PPS_APDO_CURR_MASK) * 50;
+}
+
 /* RDO: Request Data Object */
 #define RDO_OBJ_POS_SHIFT       28
 #define RDO_OBJ_POS_MASK        0x7
@@ -237,6 +382,24 @@ static inline unsigned int pdo_max_power(u32 pdo)
         (RDO_OBJ(idx) | (flags) |                               \
          RDO_BATT_OP_PWR(op_mw) | RDO_BATT_MAX_PWR(max_mw))
 
+#define RDO_PROG_VOLT_MASK      0x7ff
+#define RDO_PROG_CURR_MASK      0x7f
+
+#define RDO_PROG_VOLT_SHIFT     9
+#define RDO_PROG_CURR_SHIFT     0
+
+#define RDO_PROG_VOLT_MV_STEP   20
+#define RDO_PROG_CURR_MA_STEP   50
+
+#define PDO_PROG_OUT_VOLT(mv)   \
+        ((((mv) / RDO_PROG_VOLT_MV_STEP) & RDO_PROG_VOLT_MASK) << RDO_PROG_VOLT_SHIFT)
+#define PDO_PROG_OP_CURR(ma)    \
+        ((((ma) / RDO_PROG_CURR_MA_STEP) & RDO_PROG_CURR_MASK) << RDO_PROG_CURR_SHIFT)
+
+#define RDO_PROG(idx, out_mv, op_ma, flags)                     \
+        (RDO_OBJ(idx) | (flags) |                               \
+         PDO_PROG_OUT_VOLT(out_mv) | PDO_PROG_OP_CURR(op_ma))
+
 static inline unsigned int rdo_index(u32 rdo)
 {
         return (rdo >> RDO_OBJ_POS_SHIFT) & RDO_OBJ_POS_MASK;
diff --git a/include/linux/usb/pd_ado.h b/include/linux/usb/pd_ado.h
new file mode 100644
index 000000000000..9aa1cf31c93c
--- /dev/null
+++ b/include/linux/usb/pd_ado.h
@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (c) 2017 Dialog Semiconductor
+ *
+ * Author: Adam Thomson <Adam.Thomson.Opensource@diasemi.com>
+ */
+
+#ifndef __LINUX_USB_PD_ADO_H
+#define __LINUX_USB_PD_ADO_H
+
+/* ADO : Alert Data Object */
+#define USB_PD_ADO_TYPE_SHIFT                   24
+#define USB_PD_ADO_TYPE_MASK                    0xff
+#define USB_PD_ADO_FIXED_BATT_SHIFT             20
+#define USB_PD_ADO_FIXED_BATT_MASK              0xf
+#define USB_PD_ADO_HOT_SWAP_BATT_SHIFT          16
+#define USB_PD_ADO_HOT_SWAP_BATT_MASK           0xf
+
+#define USB_PD_ADO_TYPE_BATT_STATUS_CHANGE      BIT(1)
+#define USB_PD_ADO_TYPE_OCP                     BIT(2)
+#define USB_PD_ADO_TYPE_OTP                     BIT(3)
+#define USB_PD_ADO_TYPE_OP_COND_CHANGE          BIT(4)
+#define USB_PD_ADO_TYPE_SRC_INPUT_CHANGE        BIT(5)
+#define USB_PD_ADO_TYPE_OVP                     BIT(6)
+
+static inline unsigned int usb_pd_ado_type(u32 ado)
+{
+        return (ado >> USB_PD_ADO_TYPE_SHIFT) & USB_PD_ADO_TYPE_MASK;
+}
+
+static inline unsigned int usb_pd_ado_fixed_batt(u32 ado)
+{
+        return (ado >> USB_PD_ADO_FIXED_BATT_SHIFT) &
+               USB_PD_ADO_FIXED_BATT_MASK;
+}
+
+static inline unsigned int usb_pd_ado_hot_swap_batt(u32 ado)
+{
+        return (ado >> USB_PD_ADO_HOT_SWAP_BATT_SHIFT) &
+               USB_PD_ADO_HOT_SWAP_BATT_MASK;
+}
+#endif /* __LINUX_USB_PD_ADO_H */
diff --git a/include/linux/usb/pd_ext_sdb.h b/include/linux/usb/pd_ext_sdb.h
new file mode 100644
index 000000000000..0eb83ce19597
--- /dev/null
+++ b/include/linux/usb/pd_ext_sdb.h
@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (c) 2017 Dialog Semiconductor
+ *
+ * Author: Adam Thomson <Adam.Thomson.Opensource@diasemi.com>
+ */
+
+#ifndef __LINUX_USB_PD_EXT_SDB_H
+#define __LINUX_USB_PD_EXT_SDB_H
+
+/* SDB : Status Data Block */
+enum usb_pd_ext_sdb_fields {
+        USB_PD_EXT_SDB_INTERNAL_TEMP = 0,
+        USB_PD_EXT_SDB_PRESENT_INPUT,
+        USB_PD_EXT_SDB_PRESENT_BATT_INPUT,
+        USB_PD_EXT_SDB_EVENT_FLAGS,
+        USB_PD_EXT_SDB_TEMP_STATUS,
+        USB_PD_EXT_SDB_DATA_SIZE,
+};
+
+/* Event Flags */
+#define USB_PD_EXT_SDB_EVENT_OCP                BIT(1)
+#define USB_PD_EXT_SDB_EVENT_OTP                BIT(2)
+#define USB_PD_EXT_SDB_EVENT_OVP                BIT(3)
+#define USB_PD_EXT_SDB_EVENT_CF_CV_MODE         BIT(4)
+
+#define USB_PD_EXT_SDB_PPS_EVENTS       (USB_PD_EXT_SDB_EVENT_OCP |     \
+                                         USB_PD_EXT_SDB_EVENT_OTP |     \
+                                         USB_PD_EXT_SDB_EVENT_OVP)
+
+#endif /* __LINUX_USB_PD_EXT_SDB_H */
diff --git a/include/linux/usb/role.h b/include/linux/usb/role.h
new file mode 100644
index 000000000000..edc51be4a77c
--- /dev/null
+++ b/include/linux/usb/role.h
@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#ifndef __LINUX_USB_ROLE_H
+#define __LINUX_USB_ROLE_H
+
+#include <linux/device.h>
+
+struct usb_role_switch;
+
+enum usb_role {
+        USB_ROLE_NONE,
+        USB_ROLE_HOST,
+        USB_ROLE_DEVICE,
+};
+
+typedef int (*usb_role_switch_set_t)(struct device *dev, enum usb_role role);
+typedef enum usb_role (*usb_role_switch_get_t)(struct device *dev);
+
+/**
+ * struct usb_role_switch_desc - USB Role Switch Descriptor
+ * @usb2_port: Optional reference to the host controller port device (USB2)
+ * @usb3_port: Optional reference to the host controller port device (USB3)
+ * @udc: Optional reference to the peripheral controller device
+ * @set: Callback for setting the role
+ * @get: Callback for getting the role (optional)
+ * @allow_userspace_control: If true userspace may change the role through sysfs
+ *
+ * @usb2_port and @usb3_port will point to the USB host port and @udc to the USB
+ * device controller behind the USB connector with the role switch. If
+ * @usb2_port, @usb3_port and @udc are included in the description, the
+ * reference count for them should be incremented by the caller of
+ * usb_role_switch_register() before registering the switch.
+ */
+struct usb_role_switch_desc {
+        struct device *usb2_port;
+        struct device *usb3_port;
+        struct device *udc;
+        usb_role_switch_set_t set;
+        usb_role_switch_get_t get;
+        bool allow_userspace_control;
+};
+
+int usb_role_switch_set_role(struct usb_role_switch *sw, enum usb_role role);
+enum usb_role usb_role_switch_get_role(struct usb_role_switch *sw);
+struct usb_role_switch *usb_role_switch_get(struct device *dev);
+void usb_role_switch_put(struct usb_role_switch *sw);
+
+struct usb_role_switch *
+usb_role_switch_register(struct device *parent,
+                         const struct usb_role_switch_desc *desc);
+void usb_role_switch_unregister(struct usb_role_switch *sw);
+
+#endif /* __LINUX_USB_ROLE_H */
diff --git a/include/linux/usb/tcpm.h b/include/linux/usb/tcpm.h
index ca1c0b57f03f..f0d839daeaea 100644
--- a/include/linux/usb/tcpm.h
+++ b/include/linux/usb/tcpm.h
@@ -91,17 +91,13 @@ struct tcpc_config {
         unsigned int operating_snk_mw;
 
         enum typec_port_type type;
+        enum typec_port_data data;
         enum typec_role default_role;
         bool try_role_hw;       /* try.{src,snk} implemented in hardware */
 
         const struct typec_altmode_desc *alt_modes;
 };
 
-enum tcpc_usb_switch {
-        TCPC_USB_SWITCH_CONNECT,
-        TCPC_USB_SWITCH_DISCONNECT,
-};
-
 /* Mux state attributes */
 #define TCPC_MUX_USB_ENABLED            BIT(0)  /* USB enabled */
 #define TCPC_MUX_DP_ENABLED             BIT(1)  /* DP enabled */
@@ -116,14 +112,6 @@ enum tcpc_mux_mode {
                           TCPC_MUX_DP_ENABLED,
 };
 
-struct tcpc_mux_dev {
-        int (*set)(struct tcpc_mux_dev *dev, enum tcpc_mux_mode mux_mode,
-                   enum tcpc_usb_switch usb_config,
-                   enum typec_cc_polarity polarity);
-        bool dfp_only;
-        void *priv_data;
-};
-
 /**
  * struct tcpc_dev - Port configuration and callback functions
  * @config:     Pointer to port configuration
@@ -175,7 +163,6 @@ struct tcpc_dev {
         int (*try_role)(struct tcpc_dev *dev, int role);
         int (*pd_transmit)(struct tcpc_dev *dev, enum tcpm_transmit_type type,
                            const struct pd_message *msg);
-        struct tcpc_mux_dev *mux;
 };
 
 struct tcpm_port;
diff --git a/include/linux/usb/typec.h b/include/linux/usb/typec.h
index 0d44ce6af08f..672b39bb0adc 100644
--- a/include/linux/usb/typec.h
+++ b/include/linux/usb/typec.h
@@ -22,9 +22,15 @@ struct typec_port;
 struct fwnode_handle;
 
 enum typec_port_type {
+        TYPEC_PORT_SRC,
+        TYPEC_PORT_SNK,
+        TYPEC_PORT_DRP,
+};
+
+enum typec_port_data {
         TYPEC_PORT_DFP,
         TYPEC_PORT_UFP,
-        TYPEC_PORT_DRP,
+        TYPEC_PORT_DRD,
 };
 
 enum typec_plug_type {
@@ -60,6 +66,12 @@ enum typec_accessory {
 
 #define TYPEC_MAX_ACCESSORY     3
 
+enum typec_orientation {
+        TYPEC_ORIENTATION_NONE,
+        TYPEC_ORIENTATION_NORMAL,
+        TYPEC_ORIENTATION_REVERSE,
+};
+
 /*
  * struct usb_pd_identity - USB Power Delivery identity data
  * @id_header: ID Header VDO
@@ -180,11 +192,14 @@ struct typec_partner_desc {
 
 /*
  * struct typec_capability - USB Type-C Port Capabilities
- * @role: DFP (Host-only), UFP (Device-only) or DRP (Dual Role)
+ * @type: Supported power role of the port
+ * @data: Supported data role of the port
  * @revision: USB Type-C Specification release. Binary coded decimal
  * @pd_revision: USB Power Delivery Specification revision if supported
- * @prefer_role: Initial role preference
+ * @prefer_role: Initial role preference (DRP ports).
  * @accessory: Supported Accessory Modes
+ * @sw: Cable plug orientation switch
+ * @mux: Multiplexer switch for Alternate/Accessory Modes
  * @fwnode: Optional fwnode of the port
  * @try_role: Set data role preference for DRP port
  * @dr_set: Set Data Role
@@ -197,11 +212,14 @@ struct typec_partner_desc {
  */
 struct typec_capability {
         enum typec_port_type    type;
+        enum typec_port_data    data;
         u16                     revision; /* 0120H = "1.2" */
         u16                     pd_revision; /* 0300H = "3.0" */
         int                     prefer_role;
         enum typec_accessory    accessory[TYPEC_MAX_ACCESSORY];
 
+        struct typec_switch     *sw;
+        struct typec_mux        *mux;
         struct fwnode_handle    *fwnode;
 
         int             (*try_role)(const struct typec_capability *,
@@ -245,4 +263,8 @@ void typec_set_pwr_role(struct typec_port *port, enum typec_role role);
 void typec_set_vconn_role(struct typec_port *port, enum typec_role role);
 void typec_set_pwr_opmode(struct typec_port *port, enum typec_pwr_opmode mode);
 
+int typec_set_orientation(struct typec_port *port,
+                          enum typec_orientation orientation);
+int typec_set_mode(struct typec_port *port, int mode);
+
 #endif /* __LINUX_USB_TYPEC_H */
diff --git a/include/linux/usb/typec_mux.h b/include/linux/usb/typec_mux.h
new file mode 100644
index 000000000000..12c1b057834b
--- /dev/null
+++ b/include/linux/usb/typec_mux.h
@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#ifndef __USB_TYPEC_MUX
+#define __USB_TYPEC_MUX
+
+#include <linux/list.h>
+#include <linux/usb/typec.h>
+
+struct device;
+
+/**
+ * struct typec_switch - USB Type-C cable orientation switch
+ * @dev: Switch device
+ * @entry: List entry
+ * @set: Callback to the driver for setting the orientation
+ *
+ * USB Type-C pin flipper switch routing the correct data pairs from the
+ * connector to the USB controller depending on the orientation of the cable
+ * plug.
+ */
+struct typec_switch {
+        struct device *dev;
+        struct list_head entry;
+
+        int (*set)(struct typec_switch *sw, enum typec_orientation orientation);
+};
+
+/**
+ * struct typec_switch - USB Type-C connector pin mux
+ * @dev: Mux device
+ * @entry: List entry
+ * @set: Callback to the driver for setting the state of the mux
+ *
+ * Pin Multiplexer/DeMultiplexer switch routing the USB Type-C connector pins to
+ * different components depending on the requested mode of operation. Used with
+ * Accessory/Alternate modes.
+ */
+struct typec_mux {
+        struct device *dev;
+        struct list_head entry;
+
+        int (*set)(struct typec_mux *mux, int state);
+};
+
+struct typec_switch *typec_switch_get(struct device *dev);
+void typec_switch_put(struct typec_switch *sw);
+int typec_switch_register(struct typec_switch *sw);
+void typec_switch_unregister(struct typec_switch *sw);
+
+struct typec_mux *typec_mux_get(struct device *dev);
+void typec_mux_put(struct typec_mux *mux);
+int typec_mux_register(struct typec_mux *mux);
+void typec_mux_unregister(struct typec_mux *mux);
+
+#endif /* __USB_TYPEC_MUX */