typec: tcpm: Move out of staging

Move tcpm (USB Type-C Port Manager) out of staging.

Signed-off-by: Guenter Roeck <linux@roeck-us.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

4 files changed, 784 insertions, 0 deletions

diff --git a/include/linux/usb/pd.h b/include/linux/usb/pd.h
new file mode 100644
index 000000000000..e00051ced806
--- /dev/null
+++ b/include/linux/usb/pd.h
@@ -0,0 +1,298 @@
+/*
+ * Copyright 2015-2017 Google, Inc
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef __LINUX_USB_PD_H
+#define __LINUX_USB_PD_H
+
+#include <linux/types.h>
+#include <linux/usb/typec.h>
+
+/* USB PD Messages */
+enum pd_ctrl_msg_type {
+        /* 0 Reserved */
+        PD_CTRL_GOOD_CRC = 1,
+        PD_CTRL_GOTO_MIN = 2,
+        PD_CTRL_ACCEPT = 3,
+        PD_CTRL_REJECT = 4,
+        PD_CTRL_PING = 5,
+        PD_CTRL_PS_RDY = 6,
+        PD_CTRL_GET_SOURCE_CAP = 7,
+        PD_CTRL_GET_SINK_CAP = 8,
+        PD_CTRL_DR_SWAP = 9,
+        PD_CTRL_PR_SWAP = 10,
+        PD_CTRL_VCONN_SWAP = 11,
+        PD_CTRL_WAIT = 12,
+        PD_CTRL_SOFT_RESET = 13,
+        /* 14-15 Reserved */
+};
+
+enum pd_data_msg_type {
+        /* 0 Reserved */
+        PD_DATA_SOURCE_CAP = 1,
+        PD_DATA_REQUEST = 2,
+        PD_DATA_BIST = 3,
+        PD_DATA_SINK_CAP = 4,
+        /* 5-14 Reserved */
+        PD_DATA_VENDOR_DEF = 15,
+};
+
+#define PD_REV10        0x0
+#define PD_REV20        0x1
+
+#define PD_HEADER_CNT_SHIFT     12
+#define PD_HEADER_CNT_MASK      0x7
+#define PD_HEADER_ID_SHIFT      9
+#define PD_HEADER_ID_MASK       0x7
+#define PD_HEADER_PWR_ROLE      BIT(8)
+#define PD_HEADER_REV_SHIFT     6
+#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, pwr, data, id, cnt)                             \
+        ((((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) |                            \
+         (((id) & PD_HEADER_ID_MASK) << PD_HEADER_ID_SHIFT) |           \
+         (((cnt) & PD_HEADER_CNT_MASK) << PD_HEADER_CNT_SHIFT))
+
+#define PD_HEADER_LE(type, pwr, data, id, cnt) \
+        cpu_to_le16(PD_HEADER((type), (pwr), (data), (id), (cnt)))
+
+static inline unsigned int pd_header_cnt(u16 header)
+{
+        return (header >> PD_HEADER_CNT_SHIFT) & PD_HEADER_CNT_MASK;
+}
+
+static inline unsigned int pd_header_cnt_le(__le16 header)
+{
+        return pd_header_cnt(le16_to_cpu(header));
+}
+
+static inline unsigned int pd_header_type(u16 header)
+{
+        return (header >> PD_HEADER_TYPE_SHIFT) & PD_HEADER_TYPE_MASK;
+}
+
+static inline unsigned int pd_header_type_le(__le16 header)
+{
+        return pd_header_type(le16_to_cpu(header));
+}
+
+static inline unsigned int pd_header_msgid(u16 header)
+{
+        return (header >> PD_HEADER_ID_SHIFT) & PD_HEADER_ID_MASK;
+}
+
+static inline unsigned int pd_header_msgid_le(__le16 header)
+{
+        return pd_header_msgid(le16_to_cpu(header));
+}
+
+#define PD_MAX_PAYLOAD          7
+
+/**
+ * struct pd_message - PD message as seen on wire
+ * @header:     PD message header
+ * @payload:    PD message payload
+ */
+struct pd_message {
+        __le16 header;
+        __le32 payload[PD_MAX_PAYLOAD];
+} __packed;
+
+/* PDO: Power Data Object */
+#define PDO_MAX_OBJECTS         7
+
+enum pd_pdo_type {
+        PDO_TYPE_FIXED = 0,
+        PDO_TYPE_BATT = 1,
+        PDO_TYPE_VAR = 2,
+};
+
+#define PDO_TYPE_SHIFT          30
+#define PDO_TYPE_MASK           0x3
+
+#define PDO_TYPE(t)     ((t) << PDO_TYPE_SHIFT)
+
+#define PDO_VOLT_MASK           0x3ff
+#define PDO_CURR_MASK           0x3ff
+#define PDO_PWR_MASK            0x3ff
+
+#define PDO_FIXED_DUAL_ROLE     BIT(29) /* Power role swap supported */
+#define PDO_FIXED_SUSPEND       BIT(28) /* USB Suspend supported (Source) */
+#define PDO_FIXED_HIGHER_CAP    BIT(28) /* Requires more than vSafe5V (Sink) */
+#define PDO_FIXED_EXTPOWER      BIT(27) /* Externally powered */
+#define PDO_FIXED_USB_COMM      BIT(26) /* USB communications capable */
+#define PDO_FIXED_DATA_SWAP     BIT(25) /* Data role swap supported */
+#define PDO_FIXED_VOLT_SHIFT    10      /* 50mV units */
+#define PDO_FIXED_CURR_SHIFT    0       /* 10mA units */
+
+#define PDO_FIXED_VOLT(mv)      ((((mv) / 50) & PDO_VOLT_MASK) << PDO_FIXED_VOLT_SHIFT)
+#define PDO_FIXED_CURR(ma)      ((((ma) / 10) & PDO_CURR_MASK) << PDO_FIXED_CURR_SHIFT)
+
+#define PDO_FIXED(mv, ma, flags)                        \
+        (PDO_TYPE(PDO_TYPE_FIXED) | (flags) |           \
+         PDO_FIXED_VOLT(mv) | PDO_FIXED_CURR(ma))
+
+#define PDO_BATT_MAX_VOLT_SHIFT 20      /* 50mV units */
+#define PDO_BATT_MIN_VOLT_SHIFT 10      /* 50mV units */
+#define PDO_BATT_MAX_PWR_SHIFT  0       /* 250mW units */
+
+#define PDO_BATT_MIN_VOLT(mv) ((((mv) / 50) & PDO_VOLT_MASK) << PDO_BATT_MIN_VOLT_SHIFT)
+#define PDO_BATT_MAX_VOLT(mv) ((((mv) / 50) & PDO_VOLT_MASK) << PDO_BATT_MAX_VOLT_SHIFT)
+#define PDO_BATT_MAX_POWER(mw) ((((mw) / 250) & PDO_PWR_MASK) << PDO_BATT_MAX_PWR_SHIFT)
+
+#define PDO_BATT(min_mv, max_mv, max_mw)                        \
+        (PDO_TYPE(PDO_TYPE_BATT) | PDO_BATT_MIN_VOLT(min_mv) |  \
+         PDO_BATT_MAX_VOLT(max_mv) | PDO_BATT_MAX_POWER(max_mw))
+
+#define PDO_VAR_MAX_VOLT_SHIFT  20      /* 50mV units */
+#define PDO_VAR_MIN_VOLT_SHIFT  10      /* 50mV units */
+#define PDO_VAR_MAX_CURR_SHIFT  0       /* 10mA units */
+
+#define PDO_VAR_MIN_VOLT(mv) ((((mv) / 50) & PDO_VOLT_MASK) << PDO_VAR_MIN_VOLT_SHIFT)
+#define PDO_VAR_MAX_VOLT(mv) ((((mv) / 50) & PDO_VOLT_MASK) << PDO_VAR_MAX_VOLT_SHIFT)
+#define PDO_VAR_MAX_CURR(ma) ((((ma) / 10) & PDO_CURR_MASK) << PDO_VAR_MAX_CURR_SHIFT)
+
+#define PDO_VAR(min_mv, max_mv, max_ma)                         \
+        (PDO_TYPE(PDO_TYPE_VAR) | PDO_VAR_MIN_VOLT(min_mv) |    \
+         PDO_VAR_MAX_VOLT(max_mv) | PDO_VAR_MAX_CURR(max_ma))
+
+static inline enum pd_pdo_type pdo_type(u32 pdo)
+{
+        return (pdo >> PDO_TYPE_SHIFT) & PDO_TYPE_MASK;
+}
+
+static inline unsigned int pdo_fixed_voltage(u32 pdo)
+{
+        return ((pdo >> PDO_FIXED_VOLT_SHIFT) & PDO_VOLT_MASK) * 50;
+}
+
+static inline unsigned int pdo_min_voltage(u32 pdo)
+{
+        return ((pdo >> PDO_VAR_MIN_VOLT_SHIFT) & PDO_VOLT_MASK) * 50;
+}
+
+static inline unsigned int pdo_max_voltage(u32 pdo)
+{
+        return ((pdo >> PDO_VAR_MAX_VOLT_SHIFT) & PDO_VOLT_MASK) * 50;
+}
+
+static inline unsigned int pdo_max_current(u32 pdo)
+{
+        return ((pdo >> PDO_VAR_MAX_CURR_SHIFT) & PDO_CURR_MASK) * 10;
+}
+
+static inline unsigned int pdo_max_power(u32 pdo)
+{
+        return ((pdo >> PDO_BATT_MAX_PWR_SHIFT) & PDO_PWR_MASK) * 250;
+}
+
+/* RDO: Request Data Object */
+#define RDO_OBJ_POS_SHIFT       28
+#define RDO_OBJ_POS_MASK        0x7
+#define RDO_GIVE_BACK           BIT(27) /* Supports reduced operating current */
+#define RDO_CAP_MISMATCH        BIT(26) /* Not satisfied by source caps */
+#define RDO_USB_COMM            BIT(25) /* USB communications capable */
+#define RDO_NO_SUSPEND          BIT(24) /* USB Suspend not supported */
+
+#define RDO_PWR_MASK                    0x3ff
+#define RDO_CURR_MASK                   0x3ff
+
+#define RDO_FIXED_OP_CURR_SHIFT         10
+#define RDO_FIXED_MAX_CURR_SHIFT        0
+
+#define RDO_OBJ(idx) (((idx) & RDO_OBJ_POS_MASK) << RDO_OBJ_POS_SHIFT)
+
+#define PDO_FIXED_OP_CURR(ma) ((((ma) / 10) & RDO_CURR_MASK) << RDO_FIXED_OP_CURR_SHIFT)
+#define PDO_FIXED_MAX_CURR(ma) ((((ma) / 10) & RDO_CURR_MASK) << RDO_FIXED_MAX_CURR_SHIFT)
+
+#define RDO_FIXED(idx, op_ma, max_ma, flags)                    \
+        (RDO_OBJ(idx) | (flags) |                               \
+         PDO_FIXED_OP_CURR(op_ma) | PDO_FIXED_MAX_CURR(max_ma))
+
+#define RDO_BATT_OP_PWR_SHIFT           10      /* 250mW units */
+#define RDO_BATT_MAX_PWR_SHIFT          0       /* 250mW units */
+
+#define RDO_BATT_OP_PWR(mw) ((((mw) / 250) & RDO_PWR_MASK) << RDO_BATT_OP_PWR_SHIFT)
+#define RDO_BATT_MAX_PWR(mw) ((((mw) / 250) & RDO_PWR_MASK) << RDO_BATT_MAX_PWR_SHIFT)
+
+#define RDO_BATT(idx, op_mw, max_mw, flags)                     \
+        (RDO_OBJ(idx) | (flags) |                               \
+         RDO_BATT_OP_PWR(op_mw) | RDO_BATT_MAX_PWR(max_mw))
+
+static inline unsigned int rdo_index(u32 rdo)
+{
+        return (rdo >> RDO_OBJ_POS_SHIFT) & RDO_OBJ_POS_MASK;
+}
+
+static inline unsigned int rdo_op_current(u32 rdo)
+{
+        return ((rdo >> RDO_FIXED_OP_CURR_SHIFT) & RDO_CURR_MASK) * 10;
+}
+
+static inline unsigned int rdo_max_current(u32 rdo)
+{
+        return ((rdo >> RDO_FIXED_MAX_CURR_SHIFT) &
+                RDO_CURR_MASK) * 10;
+}
+
+static inline unsigned int rdo_op_power(u32 rdo)
+{
+        return ((rdo >> RDO_BATT_OP_PWR_SHIFT) & RDO_PWR_MASK) * 250;
+}
+
+static inline unsigned int rdo_max_power(u32 rdo)
+{
+        return ((rdo >> RDO_BATT_MAX_PWR_SHIFT) & RDO_PWR_MASK) * 250;
+}
+
+/* USB PD timers and counters */
+#define PD_T_NO_RESPONSE        5000    /* 4.5 - 5.5 seconds */
+#define PD_T_DB_DETECT          10000   /* 10 - 15 seconds */
+#define PD_T_SEND_SOURCE_CAP    150     /* 100 - 200 ms */
+#define PD_T_SENDER_RESPONSE    60      /* 24 - 30 ms, relaxed */
+#define PD_T_SOURCE_ACTIVITY    45
+#define PD_T_SINK_ACTIVITY      135
+#define PD_T_SINK_WAIT_CAP      240
+#define PD_T_PS_TRANSITION      500
+#define PD_T_SRC_TRANSITION     35
+#define PD_T_DRP_SNK            40
+#define PD_T_DRP_SRC            30
+#define PD_T_PS_SOURCE_OFF      920
+#define PD_T_PS_SOURCE_ON       480
+#define PD_T_PS_HARD_RESET      30
+#define PD_T_SRC_RECOVER        760
+#define PD_T_SRC_RECOVER_MAX    1000
+#define PD_T_SRC_TURN_ON        275
+#define PD_T_SAFE_0V            650
+#define PD_T_VCONN_SOURCE_ON    100
+#define PD_T_SINK_REQUEST       100     /* 100 ms minimum */
+#define PD_T_ERROR_RECOVERY     100     /* minimum 25 is insufficient */
+#define PD_T_SRCSWAPSTDBY      625     /* Maximum of 650ms */
+#define PD_T_NEWSRC            250     /* Maximum of 275ms */
+
+#define PD_T_DRP_TRY            100     /* 75 - 150 ms */
+#define PD_T_DRP_TRYWAIT        600     /* 400 - 800 ms */
+
+#define PD_T_CC_DEBOUNCE        200     /* 100 - 200 ms */
+#define PD_T_PD_DEBOUNCE        20      /* 10 - 20 ms */
+
+#define PD_N_CAPS_COUNT         (PD_T_NO_RESPONSE / PD_T_SEND_SOURCE_CAP)
+#define PD_N_HARD_RESET_COUNT   2
+
+#endif /* __LINUX_USB_PD_H */
diff --git a/include/linux/usb/pd_bdo.h b/include/linux/usb/pd_bdo.h
new file mode 100644
index 000000000000..90b94d9fea5d
--- /dev/null
+++ b/include/linux/usb/pd_bdo.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2015-2017 Google, Inc
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef __LINUX_USB_PD_BDO_H
+#define __LINUX_USB_PD_BDO_H
+
+/* BDO : BIST Data Object */
+#define BDO_MODE_RECV           (0 << 28)
+#define BDO_MODE_TRANSMIT       (1 << 28)
+#define BDO_MODE_COUNTERS       (2 << 28)
+#define BDO_MODE_CARRIER0       (3 << 28)
+#define BDO_MODE_CARRIER1       (4 << 28)
+#define BDO_MODE_CARRIER2       (5 << 28)
+#define BDO_MODE_CARRIER3       (6 << 28)
+#define BDO_MODE_EYE            (7 << 28)
+#define BDO_MODE_TESTDATA       (8 << 28)
+
+#define BDO_MODE_MASK(mode)     ((mode) & 0xf0000000)
+
+#endif
diff --git a/include/linux/usb/pd_vdo.h b/include/linux/usb/pd_vdo.h
new file mode 100644
index 000000000000..d92259f8de0a
--- /dev/null
+++ b/include/linux/usb/pd_vdo.h
@@ -0,0 +1,251 @@
+/*
+ * Copyright 2015-2017 Google, Inc
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef __LINUX_USB_PD_VDO_H
+#define __LINUX_USB_PD_VDO_H
+
+#include "pd.h"
+
+/*
+ * VDO : Vendor Defined Message Object
+ * VDM object is minimum of VDM header + 6 additional data objects.
+ */
+
+#define VDO_MAX_OBJECTS         6
+#define VDO_MAX_SIZE            (VDO_MAX_OBJECTS + 1)
+
+/*
+ * VDM header
+ * ----------
+ * <31:16>  :: SVID
+ * <15>     :: VDM type ( 1b == structured, 0b == unstructured )
+ * <14:13>  :: Structured VDM version (can only be 00 == 1.0 currently)
+ * <12:11>  :: reserved
+ * <10:8>   :: object position (1-7 valid ... used for enter/exit mode only)
+ * <7:6>    :: command type (SVDM only?)
+ * <5>      :: reserved (SVDM), command type (UVDM)
+ * <4:0>    :: command
+ */
+#define VDO(vid, type, custom)                          \
+        (((vid) << 16) |                                \
+         ((type) << 15) |                               \
+         ((custom) & 0x7FFF))
+
+#define VDO_SVDM_TYPE           (1 << 15)
+#define VDO_SVDM_VERS(x)        ((x) << 13)
+#define VDO_OPOS(x)             ((x) << 8)
+#define VDO_CMDT(x)             ((x) << 6)
+#define VDO_OPOS_MASK           VDO_OPOS(0x7)
+#define VDO_CMDT_MASK           VDO_CMDT(0x3)
+
+#define CMDT_INIT               0
+#define CMDT_RSP_ACK            1
+#define CMDT_RSP_NAK            2
+#define CMDT_RSP_BUSY           3
+
+/* reserved for SVDM ... for Google UVDM */
+#define VDO_SRC_INITIATOR       (0 << 5)
+#define VDO_SRC_RESPONDER       (1 << 5)
+
+#define CMD_DISCOVER_IDENT      1
+#define CMD_DISCOVER_SVID       2
+#define CMD_DISCOVER_MODES      3
+#define CMD_ENTER_MODE          4
+#define CMD_EXIT_MODE           5
+#define CMD_ATTENTION           6
+
+#define VDO_CMD_VENDOR(x)    (((10 + (x)) & 0x1f))
+
+/* ChromeOS specific commands */
+#define VDO_CMD_VERSION         VDO_CMD_VENDOR(0)
+#define VDO_CMD_SEND_INFO       VDO_CMD_VENDOR(1)
+#define VDO_CMD_READ_INFO       VDO_CMD_VENDOR(2)
+#define VDO_CMD_REBOOT          VDO_CMD_VENDOR(5)
+#define VDO_CMD_FLASH_ERASE     VDO_CMD_VENDOR(6)
+#define VDO_CMD_FLASH_WRITE     VDO_CMD_VENDOR(7)
+#define VDO_CMD_ERASE_SIG       VDO_CMD_VENDOR(8)
+#define VDO_CMD_PING_ENABLE     VDO_CMD_VENDOR(10)
+#define VDO_CMD_CURRENT         VDO_CMD_VENDOR(11)
+#define VDO_CMD_FLIP            VDO_CMD_VENDOR(12)
+#define VDO_CMD_GET_LOG         VDO_CMD_VENDOR(13)
+#define VDO_CMD_CCD_EN          VDO_CMD_VENDOR(14)
+
+#define PD_VDO_VID(vdo)         ((vdo) >> 16)
+#define PD_VDO_SVDM(vdo)        (((vdo) >> 15) & 1)
+#define PD_VDO_OPOS(vdo)        (((vdo) >> 8) & 0x7)
+#define PD_VDO_CMD(vdo)         ((vdo) & 0x1f)
+#define PD_VDO_CMDT(vdo)        (((vdo) >> 6) & 0x3)
+
+/*
+ * SVDM Identity request -> response
+ *
+ * Request is simply properly formatted SVDM header
+ *
+ * Response is 4 data objects:
+ * [0] :: SVDM header
+ * [1] :: Identitiy header
+ * [2] :: Cert Stat VDO
+ * [3] :: (Product | Cable) VDO
+ * [4] :: AMA VDO
+ *
+ */
+#define VDO_INDEX_HDR           0
+#define VDO_INDEX_IDH           1
+#define VDO_INDEX_CSTAT         2
+#define VDO_INDEX_CABLE         3
+#define VDO_INDEX_PRODUCT       3
+#define VDO_INDEX_AMA           4
+
+/*
+ * SVDM Identity Header
+ * --------------------
+ * <31>     :: data capable as a USB host
+ * <30>     :: data capable as a USB device
+ * <29:27>  :: product type
+ * <26>     :: modal operation supported (1b == yes)
+ * <25:16>  :: Reserved, Shall be set to zero
+ * <15:0>   :: USB-IF assigned VID for this cable vendor
+ */
+#define IDH_PTYPE_UNDEF         0
+#define IDH_PTYPE_HUB           1
+#define IDH_PTYPE_PERIPH        2
+#define IDH_PTYPE_PCABLE        3
+#define IDH_PTYPE_ACABLE        4
+#define IDH_PTYPE_AMA           5
+
+#define VDO_IDH(usbh, usbd, ptype, is_modal, vid)               \
+        ((usbh) << 31 | (usbd) << 30 | ((ptype) & 0x7) << 27    \
+         | (is_modal) << 26 | ((vid) & 0xffff))
+
+#define PD_IDH_PTYPE(vdo)       (((vdo) >> 27) & 0x7)
+#define PD_IDH_VID(vdo)         ((vdo) & 0xffff)
+#define PD_IDH_MODAL_SUPP(vdo)  ((vdo) & (1 << 26))
+
+/*
+ * Cert Stat VDO
+ * -------------
+ * <31:0>  : USB-IF assigned XID for this cable
+ */
+#define PD_CSTAT_XID(vdo)       (vdo)
+
+/*
+ * Product VDO
+ * -----------
+ * <31:16> : USB Product ID
+ * <15:0>  : USB bcdDevice
+ */
+#define VDO_PRODUCT(pid, bcd)   (((pid) & 0xffff) << 16 | ((bcd) & 0xffff))
+#define PD_PRODUCT_PID(vdo)     (((vdo) >> 16) & 0xffff)
+
+/*
+ * Cable VDO
+ * ---------
+ * <31:28> :: Cable HW version
+ * <27:24> :: Cable FW version
+ * <23:20> :: Reserved, Shall be set to zero
+ * <19:18> :: type-C to Type-A/B/C (00b == A, 01 == B, 10 == C)
+ * <17>    :: Type-C to Plug/Receptacle (0b == plug, 1b == receptacle)
+ * <16:13> :: cable latency (0001 == <10ns(~1m length))
+ * <12:11> :: cable termination type (11b == both ends active VCONN req)
+ * <10>    :: SSTX1 Directionality support (0b == fixed, 1b == cfgable)
+ * <9>     :: SSTX2 Directionality support
+ * <8>     :: SSRX1 Directionality support
+ * <7>     :: SSRX2 Directionality support
+ * <6:5>   :: Vbus current handling capability
+ * <4>     :: Vbus through cable (0b == no, 1b == yes)
+ * <3>     :: SOP" controller present? (0b == no, 1b == yes)
+ * <2:0>   :: USB SS Signaling support
+ */
+#define CABLE_ATYPE             0
+#define CABLE_BTYPE             1
+#define CABLE_CTYPE             2
+#define CABLE_PLUG              0
+#define CABLE_RECEPTACLE        1
+#define CABLE_CURR_1A5          0
+#define CABLE_CURR_3A           1
+#define CABLE_CURR_5A           2
+#define CABLE_USBSS_U2_ONLY     0
+#define CABLE_USBSS_U31_GEN1    1
+#define CABLE_USBSS_U31_GEN2    2
+#define VDO_CABLE(hw, fw, cbl, gdr, lat, term, tx1d, tx2d, rx1d, rx2d, cur,\
+                  vps, sopp, usbss) \
+        (((hw) & 0x7) << 28 | ((fw) & 0x7) << 24 | ((cbl) & 0x3) << 18  \
+         | (gdr) << 17 | ((lat) & 0x7) << 13 | ((term) & 0x3) << 11     \
+         | (tx1d) << 10 | (tx2d) << 9 | (rx1d) << 8 | (rx2d) << 7       \
+         | ((cur) & 0x3) << 5 | (vps) << 4 | (sopp) << 3                \
+         | ((usbss) & 0x7))
+
+/*
+ * AMA VDO
+ * ---------
+ * <31:28> :: Cable HW version
+ * <27:24> :: Cable FW version
+ * <23:12> :: Reserved, Shall be set to zero
+ * <11>    :: SSTX1 Directionality support (0b == fixed, 1b == cfgable)
+ * <10>    :: SSTX2 Directionality support
+ * <9>     :: SSRX1 Directionality support
+ * <8>     :: SSRX2 Directionality support
+ * <7:5>   :: Vconn power
+ * <4>     :: Vconn power required
+ * <3>     :: Vbus power required
+ * <2:0>   :: USB SS Signaling support
+ */
+#define VDO_AMA(hw, fw, tx1d, tx2d, rx1d, rx2d, vcpwr, vcr, vbr, usbss) \
+        (((hw) & 0x7) << 28 | ((fw) & 0x7) << 24                        \
+         | (tx1d) << 11 | (tx2d) << 10 | (rx1d) << 9 | (rx2d) << 8      \
+         | ((vcpwr) & 0x7) << 5 | (vcr) << 4 | (vbr) << 3               \
+         | ((usbss) & 0x7))
+
+#define PD_VDO_AMA_VCONN_REQ(vdo)       (((vdo) >> 4) & 1)
+#define PD_VDO_AMA_VBUS_REQ(vdo)        (((vdo) >> 3) & 1)
+
+#define AMA_VCONN_PWR_1W        0
+#define AMA_VCONN_PWR_1W5       1
+#define AMA_VCONN_PWR_2W        2
+#define AMA_VCONN_PWR_3W        3
+#define AMA_VCONN_PWR_4W        4
+#define AMA_VCONN_PWR_5W        5
+#define AMA_VCONN_PWR_6W        6
+#define AMA_USBSS_U2_ONLY       0
+#define AMA_USBSS_U31_GEN1      1
+#define AMA_USBSS_U31_GEN2      2
+#define AMA_USBSS_BBONLY        3
+
+/*
+ * SVDM Discover SVIDs request -> response
+ *
+ * Request is properly formatted VDM Header with discover SVIDs command.
+ * Response is a set of SVIDs of all all supported SVIDs with all zero's to
+ * mark the end of SVIDs.  If more than 12 SVIDs are supported command SHOULD be
+ * repeated.
+ */
+#define VDO_SVID(svid0, svid1)  (((svid0) & 0xffff) << 16 | ((svid1) & 0xffff))
+#define PD_VDO_SVID_SVID0(vdo)  ((vdo) >> 16)
+#define PD_VDO_SVID_SVID1(vdo)  ((vdo) & 0xffff)
+
+/* USB-IF SIDs */
+#define USB_SID_PD              0xff00 /* power delivery */
+#define USB_SID_DISPLAYPORT     0xff01
+#define USB_SID_MHL             0xff02  /* Mobile High-Definition Link */
+
+/* VDM command timeouts (in ms) */
+
+#define PD_T_VDM_UNSTRUCTURED   500
+#define PD_T_VDM_BUSY           100
+#define PD_T_VDM_WAIT_MODE_E    100
+#define PD_T_VDM_SNDR_RSP       30
+#define PD_T_VDM_E_MODE         25
+#define PD_T_VDM_RCVR_RSP       15
+
+#endif /* __LINUX_USB_PD_VDO_H */
diff --git a/include/linux/usb/tcpm.h b/include/linux/usb/tcpm.h
new file mode 100644
index 000000000000..073197f0d2bb
--- /dev/null
+++ b/include/linux/usb/tcpm.h
@@ -0,0 +1,204 @@
+/*
+ * Copyright 2015-2017 Google, Inc
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef __LINUX_USB_TCPM_H
+#define __LINUX_USB_TCPM_H
+
+#include <linux/bitops.h>
+#include <linux/usb/typec.h>
+#include "pd.h"
+
+enum typec_cc_status {
+        TYPEC_CC_OPEN,
+        TYPEC_CC_RA,
+        TYPEC_CC_RD,
+        TYPEC_CC_RP_DEF,
+        TYPEC_CC_RP_1_5,
+        TYPEC_CC_RP_3_0,
+};
+
+enum typec_cc_polarity {
+        TYPEC_POLARITY_CC1,
+        TYPEC_POLARITY_CC2,
+};
+
+/* Time to wait for TCPC to complete transmit */
+#define PD_T_TCPC_TX_TIMEOUT    100             /* in ms        */
+#define PD_ROLE_SWAP_TIMEOUT    (MSEC_PER_SEC * 10)
+
+enum tcpm_transmit_status {
+        TCPC_TX_SUCCESS = 0,
+        TCPC_TX_DISCARDED = 1,
+        TCPC_TX_FAILED = 2,
+};
+
+enum tcpm_transmit_type {
+        TCPC_TX_SOP = 0,
+        TCPC_TX_SOP_PRIME = 1,
+        TCPC_TX_SOP_PRIME_PRIME = 2,
+        TCPC_TX_SOP_DEBUG_PRIME = 3,
+        TCPC_TX_SOP_DEBUG_PRIME_PRIME = 4,
+        TCPC_TX_HARD_RESET = 5,
+        TCPC_TX_CABLE_RESET = 6,
+        TCPC_TX_BIST_MODE_2 = 7
+};
+
+/**
+ * struct tcpc_config - Port configuration
+ * @src_pdo:    PDO parameters sent to port partner as response to
+ *              PD_CTRL_GET_SOURCE_CAP message
+ * @nr_src_pdo: Number of entries in @src_pdo
+ * @snk_pdo:    PDO parameters sent to partner as response to
+ *              PD_CTRL_GET_SINK_CAP message
+ * @nr_snk_pdo: Number of entries in @snk_pdo
+ * @max_snk_mv: Maximum acceptable sink voltage in mV
+ * @max_snk_ma: Maximum sink current in mA
+ * @max_snk_mw: Maximum required sink power in mW
+ * @operating_snk_mw:
+ *              Required operating sink power in mW
+ * @type:       Port type (TYPEC_PORT_DFP, TYPEC_PORT_UFP, or
+ *              TYPEC_PORT_DRP)
+ * @default_role:
+ *              Default port role (TYPEC_SINK or TYPEC_SOURCE).
+ *              Set to TYPEC_NO_PREFERRED_ROLE if no default role.
+ * @try_role_hw:True if try.{Src,Snk} is implemented in hardware
+ * @alt_modes:  List of supported alternate modes
+ */
+struct tcpc_config {
+        const u32 *src_pdo;
+        unsigned int nr_src_pdo;
+
+        const u32 *snk_pdo;
+        unsigned int nr_snk_pdo;
+
+        const u32 *snk_vdo;
+        unsigned int nr_snk_vdo;
+
+        unsigned int max_snk_mv;
+        unsigned int max_snk_ma;
+        unsigned int max_snk_mw;
+        unsigned int operating_snk_mw;
+
+        enum typec_port_type type;
+        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 */
+#define TCPC_MUX_POLARITY_INVERTED      BIT(2)  /* Polarity inverted */
+
+/* Mux modes, decoded to attributes */
+enum tcpc_mux_mode {
+        TYPEC_MUX_NONE  = 0,                            /* Open switch */
+        TYPEC_MUX_USB   = TCPC_MUX_USB_ENABLED,         /* USB only */
+        TYPEC_MUX_DP    = TCPC_MUX_DP_ENABLED,          /* DP only */
+        TYPEC_MUX_DOCK  = TCPC_MUX_USB_ENABLED |        /* Both USB and DP */
+                          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
+ * @get_vbus:   Called to read current VBUS state
+ * @get_current_limit:
+ *              Optional; called by the tcpm core when configured as a snk
+ *              and cc=Rp-def. This allows the tcpm to provide a fallback
+ *              current-limit detection method for the cc=Rp-def case.
+ *              For example, some tcpcs may include BC1.2 charger detection
+ *              and use that in this case.
+ * @set_cc:     Called to set value of CC pins
+ * @get_cc:     Called to read current CC pin values
+ * @set_polarity:
+ *              Called to set polarity
+ * @set_vconn:  Called to enable or disable VCONN
+ * @set_vbus:   Called to enable or disable VBUS
+ * @set_current_limit:
+ *              Optional; called to set current limit as negotiated
+ *              with partner.
+ * @set_pd_rx:  Called to enable or disable reception of PD messages
+ * @set_roles:  Called to set power and data roles
+ * @start_drp_toggling:
+ *              Optional; if supported by hardware, called to start DRP
+ *              toggling. DRP toggling is stopped automatically if
+ *              a connection is established.
+ * @try_role:   Optional; called to set a preferred role
+ * @pd_transmit:Called to transmit PD message
+ * @mux:        Pointer to multiplexer data
+ */
+struct tcpc_dev {
+        const struct tcpc_config *config;
+
+        int (*init)(struct tcpc_dev *dev);
+        int (*get_vbus)(struct tcpc_dev *dev);
+        int (*get_current_limit)(struct tcpc_dev *dev);
+        int (*set_cc)(struct tcpc_dev *dev, enum typec_cc_status cc);
+        int (*get_cc)(struct tcpc_dev *dev, enum typec_cc_status *cc1,
+                      enum typec_cc_status *cc2);
+        int (*set_polarity)(struct tcpc_dev *dev,
+                            enum typec_cc_polarity polarity);
+        int (*set_vconn)(struct tcpc_dev *dev, bool on);
+        int (*set_vbus)(struct tcpc_dev *dev, bool on, bool charge);
+        int (*set_current_limit)(struct tcpc_dev *dev, u32 max_ma, u32 mv);
+        int (*set_pd_rx)(struct tcpc_dev *dev, bool on);
+        int (*set_roles)(struct tcpc_dev *dev, bool attached,
+                         enum typec_role role, enum typec_data_role data);
+        int (*start_drp_toggling)(struct tcpc_dev *dev,
+                                  enum typec_cc_status cc);
+        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;
+
+struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc);
+void tcpm_unregister_port(struct tcpm_port *port);
+
+void tcpm_update_source_capabilities(struct tcpm_port *port, const u32 *pdo,
+                                     unsigned int nr_pdo);
+void tcpm_update_sink_capabilities(struct tcpm_port *port, const u32 *pdo,
+                                   unsigned int nr_pdo,
+                                   unsigned int max_snk_mv,
+                                   unsigned int max_snk_ma,
+                                   unsigned int max_snk_mw,
+                                   unsigned int operating_snk_mw);
+
+void tcpm_vbus_change(struct tcpm_port *port);
+void tcpm_cc_change(struct tcpm_port *port);
+void tcpm_pd_receive(struct tcpm_port *port,
+                     const struct pd_message *msg);
+void tcpm_pd_transmit_complete(struct tcpm_port *port,
+                               enum tcpm_transmit_status status);
+void tcpm_pd_hard_reset(struct tcpm_port *port);
+void tcpm_tcpc_reset(struct tcpm_port *port);
+
+#endif /* __LINUX_USB_TCPM_H */