* [PATCH 1/2] dt-bindings: connector: Add sink properties to comply with PD 3.1 spec
2026-02-11 23:25 [PATCH 0/2] Introduce Sink Cap Extended AMS Amit Sunil Dhamne via B4 Relay
@ 2026-02-11 23:25 ` Amit Sunil Dhamne via B4 Relay
2026-02-23 17:44 ` Rob Herring (Arm)
2026-02-11 23:25 ` [PATCH 2/2] usb: typec: tcpm: add support for Sink Cap Extended msg response Amit Sunil Dhamne via B4 Relay
1 sibling, 1 reply; 7+ messages in thread
From: Amit Sunil Dhamne via B4 Relay @ 2026-02-11 23:25 UTC (permalink / raw)
To: Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Greg Kroah-Hartman, Badhri Jagan Sridharan, Heikki Krogerus
Cc: devicetree, linux-kernel, linux-usb, Kyle Tso, RD Babiera,
Amit Sunil Dhamne
From: Amit Sunil Dhamne <amitsd@google.com>
Add additional properties for ports supporting sink mode. The properties
define certain hardware and electrical properties such as sink load
step, sink load characteristics, sink compliance and charging adapter
Power Delivery Profile (PDP) for the connector. These properties need to
be defined for a Type-C port in compliance with the PD 3.1 spec.
Signed-off-by: Amit Sunil Dhamne <amitsd@google.com>
---
.../bindings/connector/usb-connector.yaml | 34 ++++++++++++++++++++++
.../devicetree/bindings/usb/maxim,max33359.yaml | 4 +++
include/dt-bindings/usb/pd.h | 18 ++++++++++++
3 files changed, 56 insertions(+)
diff --git a/Documentation/devicetree/bindings/connector/usb-connector.yaml b/Documentation/devicetree/bindings/connector/usb-connector.yaml
index 11e40d225b9f..901986de3e2b 100644
--- a/Documentation/devicetree/bindings/connector/usb-connector.yaml
+++ b/Documentation/devicetree/bindings/connector/usb-connector.yaml
@@ -300,6 +300,40 @@ properties:
$ref: /schemas/types.yaml#/definitions/uint8-array
maxItems: 4
+ sink-load-step:
+ description: Indicates the preferred load step slew rate in mA/usec for
+ the port (in sink mode). This property is defined in "6.5.13.7" of
+ "USB Power Delivery Specification Revision 3.1 Version 1.8".
+ $ref: /schemas/types.yaml#/definitions/uint32
+ enum: [150, 500]
+ default: 150
+
+ sink-load-characteristics:
+ description: Indicates the port's (in sink mode) preferred load
+ characteristics. Users can leverage SINK_LOAD_CHAR() defined in
+ dt-bindings/usb/pd.h to populate this field. This property is defined in
+ "6.5.13.8" of "USB Power Delivery Specification Revision 3.1 Version 1.8".
+ $ref: /schemas/types.yaml#/definitions/uint16
+
+ sink-compliance:
+ description: Represents the types of sources the sink device has been tested
+ and certified with. This property is defined in "6.5.13.9" of
+ "USB Power Delivery Specification Revision 3.1 Version 1.8"
+ Bit 0 when set indicates it has been tested on LPS compliant source
+ Bit 1 when set indicates it has been tested on PS1 compliant source
+ Bit 2 when set indicates it has been tested on PS2 compliant source
+ $ref: /schemas/types.yaml#/definitions/uint8
+ maximum: 7
+
+ charging-adapter-pdp-milliwatt:
+ description: This corresponds to the Power Delivery Profile rating of the
+ charging adapter shipped or recommended for use with the connector port.
+ This property is a requirement to infer the USB PD property
+ "SPR Sink Operational PDP" given in "6.5.13.14" of
+ "USB Power Delivery Specification Revision 3.1 Version 1.8".
+ minimum: 0
+ maximum: 100000
+
dependencies:
sink-vdos-v1: [ sink-vdos ]
sink-vdos: [ sink-vdos-v1 ]
diff --git a/Documentation/devicetree/bindings/usb/maxim,max33359.yaml b/Documentation/devicetree/bindings/usb/maxim,max33359.yaml
index 3de4dc40b791..46a3748c8be4 100644
--- a/Documentation/devicetree/bindings/usb/maxim,max33359.yaml
+++ b/Documentation/devicetree/bindings/usb/maxim,max33359.yaml
@@ -75,6 +75,10 @@ examples:
PDO_FIXED(9000, 2000, 0)>;
sink-bc12-completion-time-ms = <500>;
pd-revision = /bits/ 8 <0x03 0x01 0x01 0x08>;
+ sink-load-step = <150>;
+ sink-load-characteristics = /bits/ 16 <SINK_LOAD_CHAR(0, 1, 1, 2)>;
+ sink-compliance = /bits/ 8 <(COMPLIANCE_LPS | COMPLIANCE_PS1)>;
+ charging-adapter-pdp-milliwatt = <18000>;
};
};
};
diff --git a/include/dt-bindings/usb/pd.h b/include/dt-bindings/usb/pd.h
index e6526b138174..6cff2339bda3 100644
--- a/include/dt-bindings/usb/pd.h
+++ b/include/dt-bindings/usb/pd.h
@@ -465,4 +465,22 @@
| ((vbm) & 0x3) << 15 | (curr) << 14 | ((vbi) & 0x3f) << 7 \
| ((gi) & 0x3f) << 1 | (ct))
+/*
+ * Sink Load Characteristics
+ * -------------------------
+ * <15> :: Can tolerate vbus voltage droop
+ * <11:14> :: Duty cycle in 5% increments when bits 4:0 are non-zero
+ * <10:5> :: Overload period in 20ms when bits 4:0 are non-zero
+ * <4:0> :: Percent overload in 10% increments. Values higher than 25 are
+ * clipped to 250%
+ */
+#define SINK_LOAD_CHAR(vdroop, duty_cycle, period, percent_ol) \
+ (((vdroop) & 0x1) << 15 | ((duty_cycle) & 0xf) << 11 | \
+ ((period) & 0x3f) << 5 | ((percent_ol) & 0x1f))
+
+/* Compliance */
+#define COMPLIANCE_LPS (1 << 0)
+#define COMPLIANCE_PS1 (1 << 1)
+#define COMPLIANCE_PS2 (1 << 2)
+
#endif /* __DT_POWER_DELIVERY_H */
--
2.53.0.239.g8d8fc8a987-goog
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH 2/2] usb: typec: tcpm: add support for Sink Cap Extended msg response
2026-02-11 23:25 [PATCH 0/2] Introduce Sink Cap Extended AMS Amit Sunil Dhamne via B4 Relay
2026-02-11 23:25 ` [PATCH 1/2] dt-bindings: connector: Add sink properties to comply with PD 3.1 spec Amit Sunil Dhamne via B4 Relay
@ 2026-02-11 23:25 ` Amit Sunil Dhamne via B4 Relay
2026-02-12 3:56 ` kernel test robot
2026-02-12 5:09 ` kernel test robot
1 sibling, 2 replies; 7+ messages in thread
From: Amit Sunil Dhamne via B4 Relay @ 2026-02-11 23:25 UTC (permalink / raw)
To: Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Greg Kroah-Hartman, Badhri Jagan Sridharan, Heikki Krogerus
Cc: devicetree, linux-kernel, linux-usb, Kyle Tso, RD Babiera,
Amit Sunil Dhamne
From: Amit Sunil Dhamne <amitsd@google.com>
Add support for responding to Sink Cap Extended msg request. To achieve
this, include parsing support for DT properties related to Sink Cap
Extended. The request for Sink Cap Ext is a control message while the
response is an extended message (chunked). As the Sink Caps Extended
Data Block size (24 Byte) is less than MaxExtendedMsgChunkLen (26 Byte),
a single chunk is sufficient to complete this AMS.
Supporting sink cap extended messages while responding to a
Get_Sink_Caps_Extended request when port is in Sink role is required in
order to be compliant with at least USB PD Rev3.1 Ver1.8.
Signed-off-by: Amit Sunil Dhamne <amitsd@google.com>
Reviewed-by: Badhri Jagan Sridharan <badhri@google.com>
---
drivers/usb/typec/tcpm/tcpm.c | 253 +++++++++++++++++++++++++++++++++++++++++-
include/linux/usb/pd.h | 82 +++++++++++++-
2 files changed, 332 insertions(+), 3 deletions(-)
diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c
index be49a976428f..72559d0dbf34 100644
--- a/drivers/usb/typec/tcpm/tcpm.c
+++ b/drivers/usb/typec/tcpm/tcpm.c
@@ -12,6 +12,7 @@
#include <linux/jiffies.h>
#include <linux/kernel.h>
#include <linux/kthread.h>
+#include <linux/minmax.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/power_supply.h>
@@ -188,7 +189,8 @@
S(STRUCTURED_VDMS), \
S(COUNTRY_INFO), \
S(COUNTRY_CODES), \
- S(REVISION_INFORMATION)
+ S(REVISION_INFORMATION), \
+ S(GETTING_SINK_EXTENDED_CAPABILITIES)
#define GENERATE_ENUM(e) e
#define GENERATE_STRING(s) #s
@@ -229,6 +231,7 @@ enum pd_msg_request {
PD_MSG_DATA_SINK_CAP,
PD_MSG_DATA_SOURCE_CAP,
PD_MSG_DATA_REV,
+ PD_MSG_EXT_SINK_CAP_EXT
};
enum adev_actions {
@@ -337,6 +340,42 @@ struct pd_timings {
u32 snk_bc12_cmpletion_time;
};
+/* Convert microwatt to watt */
+#define UW_TO_W(pow) ((pow) / 1000000)
+
+/**
+ * pd_identifier - Contains info about PD identifiers
+ * @vid: Vendor ID (assigned by USB-IF)
+ * @pid: Product ID (assigned by manufacturer)
+ * @xid: Value assigned by USB-IF for product
+ */
+struct pd_identifier {
+ u16 vid;
+ u16 pid;
+ u32 xid;
+};
+
+/**
+ * sink_caps_ext_data - Sink extended capability data
+ * @load_step: Indicates the load step slew rate. Value of 0 indicates 150mA/us
+ * & 1 indicates 500 mA/us
+ * @load_char: Snk overload characteristics
+ * @compliance: Types of sources the sink has been tested & certified on
+ * @modes: Charging caps & power sources supported
+ * @spr_min_pdp: Sink Minimum PDP for SPR mode (in Watts)
+ * @spr_op_pdp: Sink Operational PDP for SPR mode (in Watts)
+ * @spr_max_pdp: Sink Maximum PDP for SPR mode (in Watts)
+ */
+struct sink_caps_ext_data {
+ u8 load_step;
+ u16 load_char;
+ u8 compliance;
+ u8 modes;
+ u8 spr_min_pdp;
+ u8 spr_op_pdp;
+ u8 spr_max_pdp;
+};
+
struct tcpm_port {
struct device *dev;
@@ -585,6 +624,9 @@ struct tcpm_port {
/* Indicates maximum (revision, version) supported */
struct pd_revision_info pd_rev;
+
+ struct pd_identifier pd_ident;
+ struct sink_caps_ext_data sink_caps_ext;
#ifdef CONFIG_DEBUG_FS
struct dentry *dentry;
struct mutex logbuffer_lock; /* log buffer access lock */
@@ -1367,6 +1409,64 @@ static int tcpm_pd_send_sink_caps(struct tcpm_port *port)
return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
}
+static int tcpm_pd_send_sink_cap_ext(struct tcpm_port *port)
+{
+ u16 operating_snk_watt = port->operating_snk_mw / 1000;
+ struct sink_caps_ext_data *data = &port->sink_caps_ext;
+ struct pd_identifier *pd_ident = &port->pd_ident;
+ struct sink_caps_ext_msg skedb = {0};
+ struct pd_message msg;
+ u8 data_obj_cnt;
+
+ if (!port->self_powered)
+ data->spr_op_pdp = operating_snk_watt;
+
+ /*
+ * SPR Sink Minimum PDP indicates the minimum power required to operate
+ * a sink device in its lowest level of functionality without requiring
+ * power from the battery. We can use the operating_snk_watt value to
+ * populate it, as operating_snk_watt indicates device's min operating
+ * power.
+ */
+ data->spr_min_pdp = operating_snk_watt;
+
+ if (data->spr_op_pdp < data->spr_min_pdp ||
+ data->spr_max_pdp < data->spr_op_pdp) {
+ tcpm_log(port,
+ "Invalid PDP values, Min PDP:%u, Op PDP:%u, Max PDP:%u",
+ data->spr_min_pdp, data->spr_op_pdp, data->spr_max_pdp);
+ return -EOPNOTSUPP;
+ }
+
+ memset(&msg, 0, sizeof(msg));
+ skedb.vid = cpu_to_le16(pd_ident->vid);
+ skedb.pid = cpu_to_le16(pd_ident->pid);
+ skedb.xid = cpu_to_le32(pd_ident->xid);
+ skedb.skedb_ver = SKEDB_VER_1_0;
+ skedb.load_step = data->load_step;
+ skedb.load_char = cpu_to_le16(data->load_char);
+ skedb.compliance = data->compliance;
+ skedb.modes = data->modes;
+ skedb.spr_min_pdp = data->spr_min_pdp;
+ skedb.spr_op_pdp = data->spr_op_pdp;
+ skedb.spr_max_pdp = data->spr_max_pdp;
+ memcpy(msg.ext_msg.data, &skedb, sizeof(skedb));
+ msg.ext_msg.header = PD_EXT_HDR_LE(sizeof(skedb),
+ 0, /* Denotes if request chunk */
+ 0, /* Chunk Number */
+ 1 /* Chunked */);
+
+ data_obj_cnt = count_chunked_data_objs(sizeof(skedb));
+ msg.header = cpu_to_le16(PD_HEADER(PD_EXT_SINK_CAP_EXT,
+ port->pwr_role,
+ port->data_role,
+ port->negotiated_rev,
+ port->message_id,
+ data_obj_cnt,
+ 1 /* Denotes if ext header */));
+ return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
+}
+
static void mod_tcpm_delayed_work(struct tcpm_port *port, unsigned int delay_ms)
{
if (delay_ms) {
@@ -3655,6 +3755,19 @@ static void tcpm_pd_ctrl_request(struct tcpm_port *port,
PD_MSG_CTRL_NOT_SUPP,
NONE_AMS);
break;
+ case PD_CTRL_GET_SINK_CAP_EXT:
+ /* This is an unsupported message if port type is SRC */
+ if (port->negotiated_rev >= PD_REV30 &&
+ port->port_type != TYPEC_PORT_SRC)
+ tcpm_pd_handle_msg(port, PD_MSG_EXT_SINK_CAP_EXT,
+ GETTING_SINK_EXTENDED_CAPABILITIES);
+ else
+ tcpm_pd_handle_msg(port,
+ port->negotiated_rev < PD_REV30 ?
+ PD_MSG_CTRL_REJECT :
+ PD_MSG_CTRL_NOT_SUPP,
+ NONE_AMS);
+ break;
default:
tcpm_pd_handle_msg(port,
port->negotiated_rev < PD_REV30 ?
@@ -3907,6 +4020,16 @@ static bool tcpm_send_queued_message(struct tcpm_port *port)
ret);
tcpm_ams_finish(port);
break;
+ case PD_MSG_EXT_SINK_CAP_EXT:
+ ret = tcpm_pd_send_sink_cap_ext(port);
+ if (ret == -EOPNOTSUPP)
+ tcpm_pd_send_control(port, PD_CTRL_NOT_SUPP, TCPC_TX_SOP);
+ else if (ret < 0)
+ tcpm_log(port,
+ "Unable to transmit sink cap extended, ret=%d",
+ ret);
+ tcpm_ams_finish(port);
+ break;
default:
break;
}
@@ -7291,6 +7414,129 @@ static void tcpm_fw_get_timings(struct tcpm_port *port, struct fwnode_handle *fw
port->timings.snk_bc12_cmpletion_time = val;
}
+static void tcpm_fw_get_pd_ident(struct tcpm_port *port)
+{
+ struct pd_identifier *pd_ident = &port->pd_ident;
+ u32 *vdo;
+
+ /* First 3 vdo values contain info regarding USB PID, VID & XID */
+ if (port->nr_snk_vdo >= 3)
+ vdo = port->snk_vdo;
+ else if (port->nr_snk_vdo_v1 >= 3)
+ vdo = port->snk_vdo_v1;
+ else
+ return;
+
+ pd_ident->vid = PD_IDH_VID(vdo[0]);
+ pd_ident->pid = PD_PRODUCT_PID(vdo[2]);
+ pd_ident->xid = PD_CSTAT_XID(vdo[1]);
+ tcpm_log(port, "vid:%#x pid:%#x xid:%#x",
+ pd_ident->vid, pd_ident->pid, pd_ident->xid);
+}
+
+static void tcpm_parse_snk_pdos(struct tcpm_port *port)
+{
+ struct sink_caps_ext_data *caps = &port->sink_caps_ext;
+ u32 max_mv, max_ma;
+ u8 avs_tier1_pdp, avs_tier2_pdp;
+ int i, pdo_itr;
+ u32 *snk_pdos;
+
+ for (i = 0; i < port->pd_count; ++i) {
+ snk_pdos = port->pd_list[i]->sink_desc.pdo;
+ for (pdo_itr = 0; pdo_itr < PDO_MAX_OBJECTS && snk_pdos[pdo_itr];
+ ++pdo_itr) {
+ u32 pdo = snk_pdos[pdo_itr];
+ u8 curr_snk_pdp = 0;
+
+ switch (pdo_type(pdo)) {
+ case PDO_TYPE_FIXED:
+ max_mv = pdo_fixed_voltage(pdo);
+ max_ma = pdo_fixed_current(pdo);
+ curr_snk_pdp = UW_TO_W(max_mv * max_ma);
+ break;
+ case PDO_TYPE_BATT:
+ curr_snk_pdp = UW_TO_W(pdo_max_power(pdo));
+ break;
+ case PDO_TYPE_VAR:
+ max_mv = pdo_max_voltage(pdo);
+ max_ma = pdo_max_current(pdo);
+ curr_snk_pdp = UW_TO_W(max_mv * max_ma);
+ break;
+ case PDO_TYPE_APDO:
+ if (pdo_apdo_type(pdo) == APDO_TYPE_PPS) {
+ max_mv = pdo_pps_apdo_max_voltage(pdo);
+ max_ma = pdo_pps_apdo_max_current(pdo);
+ curr_snk_pdp = UW_TO_W(max_mv * max_ma);
+ caps->modes |= SINK_MODE_PPS;
+ } else if (pdo_apdo_type(pdo) ==
+ APDO_TYPE_SPR_AVS) {
+ avs_tier1_pdp = UW_TO_W(SPR_AVS_TIER1_MAX_VOLT_MV
+ * pdo_spr_avs_apdo_9v_to_15v_max_current_ma(pdo));
+ avs_tier2_pdp = UW_TO_W(SPR_AVS_TIER2_MAX_VOLT_MV
+ * pdo_spr_avs_apdo_15v_to_20v_max_current_ma(pdo));
+ curr_snk_pdp = max(avs_tier1_pdp, avs_tier2_pdp);
+ caps->modes |= SINK_MODE_AVS;
+ }
+ break;
+ default:
+ tcpm_log(port, "Invalid source PDO type, ignoring");
+ continue;
+ }
+
+ caps->spr_max_pdp = max(caps->spr_max_pdp,
+ curr_snk_pdp);
+ }
+ }
+}
+
+static void tcpm_fw_get_sink_caps_ext(struct tcpm_port *port,
+ struct fwnode_handle *fwnode)
+{
+ struct sink_caps_ext_data *caps = &port->sink_caps_ext;
+ int ret;
+ u32 val;
+
+ /*
+ * Load step represents the change in current per usec that a given
+ * source can tolerate while maintaining Vbus within the vSrcValid
+ * range. For a sink this represents the "preferred" load-step value. It
+ * can only have 2 values (150 mA/usec or 500 mA/usec) with 150 mA/usec
+ * being the default.
+ */
+ ret = fwnode_property_read_u32(fwnode, "sink-load-step", &val);
+ if (!ret)
+ caps->load_step = val == 500 ? 1 : 0;
+
+ fwnode_property_read_u16(fwnode, "sink-load-characteristics",
+ &caps->load_char);
+ fwnode_property_read_u8(fwnode, "sink-compliance", &caps->compliance);
+ caps->modes = SINK_MODE_VBUS;
+
+ /*
+ * As per "6.5.13.14" SPR Sink Operational PDP definition, for battery
+ * powered devices, this value will correspond to the PDP of the
+ * charging adapter either shipped or recommended for use with it. For
+ * batteryless sink devices SPR Operational PDP indicates the power
+ * required to operate all the device's functional modes. Hence, this
+ * value may be considered equal to port's operating_snk_mw. As
+ * operating_sink_mw can change as per the pd set used thus, OP PDP
+ * is determined when populating Sink Caps Extended Data Block.
+ */
+ if (port->self_powered) {
+ fwnode_property_read_u32(fwnode, "charging-adapter-pdp-milliwatt",
+ &val);
+ caps->spr_op_pdp = (u8)(val / 1000);
+ caps->modes |= SINK_MODE_BATT;
+ }
+
+ tcpm_parse_snk_pdos(port);
+ tcpm_log(port,
+ "load-step:%#x load-char:%#x compl:%#x op-pdp:%#x max-pdp:%#x",
+ caps->load_step, caps->load_char, caps->compliance,
+ caps->spr_op_pdp, caps->spr_max_pdp);
+}
+
static int tcpm_fw_get_caps(struct tcpm_port *port, struct fwnode_handle *fwnode)
{
struct fwnode_handle *capabilities, *caps = NULL;
@@ -7464,6 +7710,9 @@ static int tcpm_fw_get_caps(struct tcpm_port *port, struct fwnode_handle *fwnode
}
}
+ if (port->port_type != TYPEC_PORT_SRC)
+ tcpm_fw_get_sink_caps_ext(port, fwnode);
+
put_caps:
if (caps != fwnode)
fwnode_handle_put(caps);
@@ -7506,6 +7755,8 @@ static int tcpm_fw_get_snk_vdos(struct tcpm_port *port, struct fwnode_handle *fw
return ret;
}
+ tcpm_fw_get_pd_ident(port);
+
return 0;
}
diff --git a/include/linux/usb/pd.h b/include/linux/usb/pd.h
index 6ccd1b2af993..8f7e44c0d321 100644
--- a/include/linux/usb/pd.h
+++ b/include/linux/usb/pd.h
@@ -34,7 +34,8 @@ enum pd_ctrl_msg_type {
PD_CTRL_FR_SWAP = 19,
PD_CTRL_GET_PPS_STATUS = 20,
PD_CTRL_GET_COUNTRY_CODES = 21,
- /* 22-23 Reserved */
+ PD_CTRL_GET_SINK_CAP_EXT = 22,
+ /* 23 Reserved */
PD_CTRL_GET_REVISION = 24,
/* 25-31 Reserved */
};
@@ -72,7 +73,8 @@ enum pd_ext_msg_type {
PD_EXT_PPS_STATUS = 12,
PD_EXT_COUNTRY_INFO = 13,
PD_EXT_COUNTRY_CODES = 14,
- /* 15-31 Reserved */
+ PD_EXT_SINK_CAP_EXT = 15,
+ /* 16-31 Reserved */
};
#define PD_REV10 0x0
@@ -205,6 +207,72 @@ struct pd_message {
};
} __packed;
+/*
+ * count_chunked_data_objs: Helper to calculate number of Data Objects on a 4
+ * byte boundary.
+ * @size: Size of data block for extended message. Should *not* include extended
+ * header size.
+ */
+static inline u8 count_chunked_data_objs(u32 size)
+{
+ size += offsetof(struct pd_chunked_ext_message_data, data);
+ return ((size / 4) + (size % 4 ? 1 : 0));
+}
+
+/* Sink Caps Extended Data Block Version */
+#define SKEDB_VER_1_0 1
+
+/* Sink Caps Extended Sink Modes */
+#define SINK_MODE_PPS BIT(0)
+#define SINK_MODE_VBUS BIT(1)
+#define SINK_MODE_AC_SUPPLY BIT(2)
+#define SINK_MODE_BATT BIT(3)
+#define SINK_MODE_BATT_UL BIT(4) /* Unlimited battery power supply */
+#define SINK_MODE_AVS BIT(5)
+
+/**
+ * sink_caps_ext_msg - Sink extended capability PD message
+ * @vid: Vendor ID
+ * @pid: Product ID
+ * @xid: Value assigned by USB-IF for product
+ * @fw: Firmware version
+ * @hw: Hardware version
+ * @skedb_ver: Sink Caps Extended Data Block (SKEDB) Version
+ * @load_step: Indicates the load step slew rate.
+ * @load_char: Sink overload characteristics
+ * @compliance: Types of sources the sink has been tested & certified on
+ * @touch_temp: Indicates the IEC standard to which the touch temperature
+ * conforms to (if applicable).
+ * @batt_info: Indicates number batteries and hot swappable ports
+ * @modes: Charging caps & power sources supported
+ * @spr_min_pdp: Sink Minimum PDP for SPR mode
+ * @spr_op_pdp: Sink Operational PDP for SPR mode
+ * @spr_max_pdp: Sink Maximum PDP for SPR mode
+ * @epr_min_pdp: Sink Minimum PDP for EPR mode
+ * @epr_op_pdp: Sink Operational PDP for EPR mode
+ * @epr_max_pdp: Sink Maximum PDP for EPR mode
+ */
+struct sink_caps_ext_msg {
+ __le16 vid;
+ __le16 pid;
+ __le32 xid;
+ u8 fw;
+ u8 hw;
+ u8 skedb_ver;
+ u8 load_step;
+ __le16 load_char;
+ u8 compliance;
+ u8 touch_temp;
+ u8 batt_info;
+ u8 modes;
+ u8 spr_min_pdp;
+ u8 spr_op_pdp;
+ u8 spr_max_pdp;
+ u8 epr_min_pdp;
+ u8 epr_op_pdp;
+ u8 epr_max_pdp;
+} __packed;
+
/* PDO: Power Data Object */
#define PDO_MAX_OBJECTS 7
@@ -329,6 +397,11 @@ enum pd_apdo_type {
#define PDO_SPR_AVS_APDO_9V_TO_15V_MAX_CURR GENMASK(19, 10) /* 10mA unit */
#define PDO_SPR_AVS_APDO_15V_TO_20V_MAX_CURR GENMASK(9, 0) /* 10mA unit */
+/* SPR AVS has two different current ranges 9V - 15V, 15V - 20V */
+#define SPR_AVS_TIER1_MIN_VOLT_MV 9000
+#define SPR_AVS_TIER1_MAX_VOLT_MV 15000
+#define SPR_AVS_TIER2_MAX_VOLT_MV 20000
+
static inline enum pd_pdo_type pdo_type(u32 pdo)
{
return (pdo >> PDO_TYPE_SHIFT) & PDO_TYPE_MASK;
@@ -339,6 +412,11 @@ static inline unsigned int pdo_fixed_voltage(u32 pdo)
return ((pdo >> PDO_FIXED_VOLT_SHIFT) & PDO_VOLT_MASK) * 50;
}
+static inline unsigned int pdo_fixed_current(u32 pdo)
+{
+ return ((pdo >> PDO_FIXED_CURR_SHIFT) & PDO_CURR_MASK) * 10;
+}
+
static inline unsigned int pdo_min_voltage(u32 pdo)
{
return ((pdo >> PDO_VAR_MIN_VOLT_SHIFT) & PDO_VOLT_MASK) * 50;
--
2.53.0.239.g8d8fc8a987-goog
^ permalink raw reply related [flat|nested] 7+ messages in thread