* [PATCH v2 0/2] Introduce Sink Cap Extended AMS
@ 2026-02-23 20:05 Amit Sunil Dhamne via B4 Relay
2026-02-23 20:05 ` [PATCH v2 1/2] dt-bindings: connector: Add sink properties to comply with PD 3.1 spec Amit Sunil Dhamne via B4 Relay
2026-02-23 20:05 ` [PATCH v2 2/2] usb: typec: tcpm: add support for Sink Cap Extended msg response Amit Sunil Dhamne via B4 Relay
0 siblings, 2 replies; 4+ messages in thread
From: Amit Sunil Dhamne via B4 Relay @ 2026-02-23 20:05 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
This patchset adds support for Sink Cap Extended AMS. This is a
"required" AMS for PD 3.1 compliance for Sink or DRP ports and a
pre-requisite for Battery Caps and Battery Status AMSes.
Signed-off-by: Amit Sunil Dhamne <amitsd@google.com>
---
Changes in v2:
- Fixed comment for `struct sink_caps_ext_msg`, `struct pd_identifier` and
`struct sink_caps_ext_data`. (Linux Test Robot)
- Added Reviewed-by tag for DT binding patch. (Rob Herring)
- Link to v1: https://lore.kernel.org/r/20260211-skedb-v1-0-616340426cdc@google.com
---
Amit Sunil Dhamne (2):
dt-bindings: connector: Add sink properties to comply with PD 3.1 spec
usb: typec: tcpm: add support for Sink Cap Extended msg response
.../bindings/connector/usb-connector.yaml | 34 +++
.../devicetree/bindings/usb/maxim,max33359.yaml | 4 +
drivers/usb/typec/tcpm/tcpm.c | 253 ++++++++++++++++++++-
include/dt-bindings/usb/pd.h | 18 ++
include/linux/usb/pd.h | 82 ++++++-
5 files changed, 388 insertions(+), 3 deletions(-)
---
base-commit: 8bf22c33e7a172fbc72464f4cc484d23a6b412ba
change-id: 20260210-skedb-5aebb944c35f
Best regards,
--
Amit Sunil Dhamne <amitsd@google.com>
^ permalink raw reply [flat|nested] 4+ messages in thread* [PATCH v2 1/2] dt-bindings: connector: Add sink properties to comply with PD 3.1 spec 2026-02-23 20:05 [PATCH v2 0/2] Introduce Sink Cap Extended AMS Amit Sunil Dhamne via B4 Relay @ 2026-02-23 20:05 ` Amit Sunil Dhamne via B4 Relay 2026-02-23 20:05 ` [PATCH v2 2/2] usb: typec: tcpm: add support for Sink Cap Extended msg response Amit Sunil Dhamne via B4 Relay 1 sibling, 0 replies; 4+ messages in thread From: Amit Sunil Dhamne via B4 Relay @ 2026-02-23 20:05 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> Reviewed-by: Rob Herring (Arm) <robh@kernel.org> --- .../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 11e40d225b9f3a0d0aeea7bf764f1c00a719d615..901986de3e2b2734452c99eea8076f4b03c4a688 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 3de4dc40b79192b60443421b557bd2fb18683bf7..46a3748c8be4dd1972c69cac6f90a990f7315953 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 e6526b13817452abd7ec74bc64e94183feddd39e..6cff2339bda3967e017166cc3cc3bd24e2f7d4b0 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.371.g1d285c8824-goog ^ permalink raw reply related [flat|nested] 4+ messages in thread
* [PATCH v2 2/2] usb: typec: tcpm: add support for Sink Cap Extended msg response 2026-02-23 20:05 [PATCH v2 0/2] Introduce Sink Cap Extended AMS Amit Sunil Dhamne via B4 Relay 2026-02-23 20:05 ` [PATCH v2 1/2] dt-bindings: connector: Add sink properties to comply with PD 3.1 spec Amit Sunil Dhamne via B4 Relay @ 2026-02-23 20:05 ` Amit Sunil Dhamne via B4 Relay 2026-02-24 10:11 ` Heikki Krogerus 1 sibling, 1 reply; 4+ messages in thread From: Amit Sunil Dhamne via B4 Relay @ 2026-02-23 20:05 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 b7828160b81d31294a58aa10578e9d8b84f05ac1..bf32d33c606e2e51421034433b251e918f0571bf 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) + +/* + * struct 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; +}; + +/* + * struct 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 6ccd1b2af993e60d2c68fcd3cef928858d9dd7e3..5a98983195cbb99735d7c5cf10cc43f69fd1b9bd 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) + +/** + * struct 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.371.g1d285c8824-goog ^ permalink raw reply related [flat|nested] 4+ messages in thread
* Re: [PATCH v2 2/2] usb: typec: tcpm: add support for Sink Cap Extended msg response 2026-02-23 20:05 ` [PATCH v2 2/2] usb: typec: tcpm: add support for Sink Cap Extended msg response Amit Sunil Dhamne via B4 Relay @ 2026-02-24 10:11 ` Heikki Krogerus 0 siblings, 0 replies; 4+ messages in thread From: Heikki Krogerus @ 2026-02-24 10:11 UTC (permalink / raw) To: amitsd Cc: Rob Herring, Krzysztof Kozlowski, Conor Dooley, Greg Kroah-Hartman, Badhri Jagan Sridharan, devicetree, linux-kernel, linux-usb, Kyle Tso, RD Babiera Mon, Feb 23, 2026 at 08:05:38PM +0000, Amit Sunil Dhamne via B4 Relay kirjoitti: > 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> Reviewed-by: Heikki Krogerus <heikki.krogerus@linux.intel.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 b7828160b81d31294a58aa10578e9d8b84f05ac1..bf32d33c606e2e51421034433b251e918f0571bf 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) > + > +/* > + * struct 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; > +}; > + > +/* > + * struct 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 6ccd1b2af993e60d2c68fcd3cef928858d9dd7e3..5a98983195cbb99735d7c5cf10cc43f69fd1b9bd 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) > + > +/** > + * struct 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.371.g1d285c8824-goog > -- heikki ^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2026-02-24 10:11 UTC | newest] Thread overview: 4+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2026-02-23 20:05 [PATCH v2 0/2] Introduce Sink Cap Extended AMS Amit Sunil Dhamne via B4 Relay 2026-02-23 20:05 ` [PATCH v2 1/2] dt-bindings: connector: Add sink properties to comply with PD 3.1 spec Amit Sunil Dhamne via B4 Relay 2026-02-23 20:05 ` [PATCH v2 2/2] usb: typec: tcpm: add support for Sink Cap Extended msg response Amit Sunil Dhamne via B4 Relay 2026-02-24 10:11 ` Heikki Krogerus
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox