From nobody Wed Dec 31 18:57:42 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 51287C4332F for ; Mon, 30 Oct 2023 17:14:07 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233732AbjJ3ROH (ORCPT ); Mon, 30 Oct 2023 13:14:07 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42138 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232864AbjJ3ROD (ORCPT ); Mon, 30 Oct 2023 13:14:03 -0400 Received: from mail-yw1-x114a.google.com (mail-yw1-x114a.google.com [IPv6:2607:f8b0:4864:20::114a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8AAB29F for ; Mon, 30 Oct 2023 10:14:00 -0700 (PDT) Received: by mail-yw1-x114a.google.com with SMTP id 00721157ae682-5afe220cadeso35034967b3.3 for ; Mon, 30 Oct 2023 10:14:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1698686040; x=1699290840; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=z8iKDVNsfQwoRxvvaiYCTHXcr4RTujdFfq5CMELZsH0=; b=dnkuBXmBEng6TyQi9oKbkeeiXz7SZVRKOHuqElRgAZQy+14HPuTf4oUstfyka50zht B2WX87SkdQQD6IdvwD+miiJHLvg0u4d5+aVDO0vBu1hXEwOtlpWqEcSsx8be5pZPHmY1 dCCJYU5xmWzVb0OxJ2N/ojYorcCuuahlUH+d09sVTwkm04PYgSIEEGs7gvYZRyN4N1eP e3bv+yX6xuDLUfvIHG1nmv5PDkstz7KoiMAKe/47yPsM3P1hn7GzJ2XZ2veppQr0kEN+ n5W2F/BfIWBaYh1ZC19Yi/j9h2ACUIXLJJjvMI9JVfxE9z6nLiFWvNYy8nghTdjLYU8J qBqw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698686040; x=1699290840; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=z8iKDVNsfQwoRxvvaiYCTHXcr4RTujdFfq5CMELZsH0=; b=ZjjaN3CYgIOjn6qLfwZXTDO/KOkU7gfM1bVSIIlsOxvqTb2FG/wWd2Dx8iCTRu1qsO VGMSRiJh6ypYiEWslPcMPGtTBcI/WdzobTk5at+4ic7mG2wRVBlHWl5PHyUdy6LoTxNK gZkKqXNTv2eUB1M1etGmO3trEIvOIcmrpjUQt5RjGzSLYpTnwd23MrHo8NIfQU5Y93Ct aY9pw2JZshgoT0CTiN+r++xukNk7l57TdNO/npEvvZsF3OQoWz6/E3bY6nFSNGyHRvHg Q7jU+V/XwYVpB2GekcEiWE69c8LdBxomiQUOUAwyejWui1A9CqQRA8b/bbSMNOhyw2rQ jrSQ== X-Gm-Message-State: AOJu0Yw6pEIRmt+dqZbZG+hGDJhyuiqOGqdteDZe9pvqucZioBRmpDLy Xaj4MJjlDm6qxSl8zDH+P9G+ADn3tm1/ X-Google-Smtp-Source: AGHT+IFCobSs7f7lUn7grteQL7zVQdPUD6EkBGNh9TaVbwF6QkbcBHQPOXcg4Ka4yeDKsnRZpGaTk4xXD+dN X-Received: from kyletso-p620lin01.ntc.corp.google.com ([2401:fa00:fc:202:99ae:e3b5:518:c5b4]) (user=kyletso job=sendgmr) by 2002:a25:9841:0:b0:d9a:3a14:a5a2 with SMTP id k1-20020a259841000000b00d9a3a14a5a2mr212052ybo.13.1698686039808; Mon, 30 Oct 2023 10:13:59 -0700 (PDT) Date: Tue, 31 Oct 2023 01:13:47 +0800 In-Reply-To: <20231030171348.600621-1-kyletso@google.com> Mime-Version: 1.0 References: <20231030171348.600621-1-kyletso@google.com> X-Mailer: git-send-email 2.42.0.820.g83a721a137-goog Message-ID: <20231030171348.600621-2-kyletso@google.com> Subject: [PATCH v3 1/2] dt-bindings: connector: Add child nodes for multiple PD capabilities From: Kyle Tso To: robh+dt@kernel.org, krzysztof.kozlowski+dt@linaro.org, conor+dt@kernel.org, linux@roeck-us.net, heikki.krogerus@linux.intel.com, gregkh@linuxfoundation.org Cc: badhri@google.com, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org, Kyle Tso Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Commit 662a60102c12 ("usb: typec: Separate USB Power Delivery from USB Type-C") allows userspace to configure the PD of a port by selecting different set of predefined PD capabilities. Define the PD capability sets in DT for better configurability in device modules. Define a child node "capabilities" to contain multiple USB Power Delivery capabilities. Define a child node with pattern (e.g. caps-0, caps-1) under "capabilities". Each node contains PDO data of a selectable Power Delivery capability. Also define common properties for source-pdos, sink-pdos, and op-sink-microwatt that can be referenced. Signed-off-by: Kyle Tso --- v2 -> v3 - Updated the commit message - Remain unchanged for the comments about the property/node refactor .../bindings/connector/usb-connector.yaml | 80 +++++++++++++------ 1 file changed, 57 insertions(+), 23 deletions(-) diff --git a/Documentation/devicetree/bindings/connector/usb-connector.yaml= b/Documentation/devicetree/bindings/connector/usb-connector.yaml index 7c8a3e8430d3..d7ece063cb2c 100644 --- a/Documentation/devicetree/bindings/connector/usb-connector.yaml +++ b/Documentation/devicetree/bindings/connector/usb-connector.yaml @@ -120,28 +120,10 @@ properties: # The following are optional properties for "usb-c-connector" with power # delivery support. source-pdos: - description: An array of u32 with each entry providing supported power - source data object(PDO), the detailed bit definitions of PDO can be = found - in "Universal Serial Bus Power Delivery Specification" chapter 6.4.1= .2 - Source_Capabilities Message, the order of each entry(PDO) should fol= low - the PD spec chapter 6.4.1. Required for power source and power dual = role. - User can specify the source PDO array via PDO_FIXED/BATT/VAR/PPS_APD= O() - defined in dt-bindings/usb/pd.h. - minItems: 1 - maxItems: 7 - $ref: /schemas/types.yaml#/definitions/uint32-array + $ref: "#/$defs/source-pdos" =20 sink-pdos: - description: An array of u32 with each entry providing supported power= sink - data object(PDO), the detailed bit definitions of PDO can be found in - "Universal Serial Bus Power Delivery Specification" chapter 6.4.1.3 - Sink Capabilities Message, the order of each entry(PDO) should follo= w the - PD spec chapter 6.4.1. Required for power sink and power dual role. = User - can specify the sink PDO array via PDO_FIXED/BATT/VAR/PPS_APDO() def= ined - in dt-bindings/usb/pd.h. - minItems: 1 - maxItems: 7 - $ref: /schemas/types.yaml#/definitions/uint32-array + $ref: "#/$defs/sink-pdos" =20 sink-vdos: description: An array of u32 with each entry, a Vendor Defined Message= Object (VDO), @@ -167,9 +149,7 @@ properties: $ref: /schemas/types.yaml#/definitions/uint32-array =20 op-sink-microwatt: - description: Sink required operating power in microwatt, if source can= 't - offer the power, Capability Mismatch is set. Required for power sink= and - power dual role. + $ref: "#/$defs/op-sink-microwatt" =20 port: $ref: /schemas/graph.yaml#/properties/port @@ -231,6 +211,30 @@ properties: SNK_READY for non-pd link. type: boolean =20 + capabilities: + description: A child node to contain all the selectable USB Power Deli= very capabilities. + type: object + + patternProperties: + "^caps-[0-9]+$": + description: Child nodes under "capabilities" node. Each node cont= ains a selectable USB + Power Delivery capability. + type: object + + properties: + source-pdos: + $ref: "#/$defs/source-pdos" + + sink-pdos: + $ref: "#/$defs/sink-pdos" + + op-sink-microwatt: + $ref: "#/$defs/op-sink-microwatt" + + additionalProperties: false + + additionalProperties: false + dependencies: sink-vdos-v1: [ sink-vdos ] sink-vdos: [ sink-vdos-v1 ] @@ -238,6 +242,36 @@ dependencies: required: - compatible =20 +$defs: + source-pdos: + description: An array of u32 with each entry providing supported power + source data object(PDO), the detailed bit definitions of PDO can be = found + in "Universal Serial Bus Power Delivery Specification" chapter 6.4.1= .2 + Source_Capabilities Message, the order of each entry(PDO) should fol= low + the PD spec chapter 6.4.1. Required for power source and power dual = role. + User can specify the source PDO array via PDO_FIXED/BATT/VAR/PPS_APD= O() + defined in dt-bindings/usb/pd.h. + minItems: 1 + maxItems: 7 + $ref: /schemas/types.yaml#/definitions/uint32-array + + sink-pdos: + description: An array of u32 with each entry providing supported power= sink + data object(PDO), the detailed bit definitions of PDO can be found in + "Universal Serial Bus Power Delivery Specification" chapter 6.4.1.3 + Sink Capabilities Message, the order of each entry(PDO) should follo= w the + PD spec chapter 6.4.1. Required for power sink and power dual role. = User + can specify the sink PDO array via PDO_FIXED/BATT/VAR/PPS_APDO() def= ined + in dt-bindings/usb/pd.h. + minItems: 1 + maxItems: 7 + $ref: /schemas/types.yaml#/definitions/uint32-array + + op-sink-microwatt: + description: Sink required operating power in microwatt, if source can= 't + offer the power, Capability Mismatch is set. Required for power sink= and + power dual role. + allOf: - if: properties: --=20 2.42.0.820.g83a721a137-goog From nobody Wed Dec 31 18:57:42 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3A7B5C4332F for ; Mon, 30 Oct 2023 17:14:15 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233844AbjJ3ROO (ORCPT ); Mon, 30 Oct 2023 13:14:14 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57980 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231433AbjJ3ROI (ORCPT ); Mon, 30 Oct 2023 13:14:08 -0400 Received: from mail-yw1-x114a.google.com (mail-yw1-x114a.google.com [IPv6:2607:f8b0:4864:20::114a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 448579F for ; Mon, 30 Oct 2023 10:14:04 -0700 (PDT) Received: by mail-yw1-x114a.google.com with SMTP id 00721157ae682-5aecf6e30e9so53504927b3.1 for ; Mon, 30 Oct 2023 10:14:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1698686043; x=1699290843; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=a0M+8JkDaZ+daR5xVVJcC+er9LCAMFNDy74JqKTTRiQ=; b=f8orMY2wv9ZHS639ebQj1BWRPr/6RY15sxecwWqmiteT+pPjiKA7odAcmmhw3u0eID FaXBKhdjBN3rgfgTzQ18Gk6uhrpzEgGsgLJtM25BL83qvp2ehAPlQB3LPbOqsEc5WJdO wNUb9wiqOgRx+jPqK7EAeKAz40ymmndM9Y/W2XVovjRB5neIbTkZlhOab95jpKE0aa96 69Emvtbreoq/MpJJGjWPDwV1VJq+RUwu0CEJCET6JEByXFS/g0R8l+mgQ6n7KYWMyL3v aPDVEnnriZWZQ4bO4mGTqaSODf5LC9tF7HsYmlc6MtPAJiWXuwnhFNpmJB0mDcC+5TzM G0BQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698686043; x=1699290843; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=a0M+8JkDaZ+daR5xVVJcC+er9LCAMFNDy74JqKTTRiQ=; b=NG8eQeGPZwaDFIleLTDaEat8x3fmgGIt1i/qjqCRaT/BT164hVEO7LaV7PlYM7GEpO yadJWVuupvYci5Wr59SMYSSAhf4LmI7R55V9d8UU0mQevwzmZM5GPKxE8hJ9UVwvVVsq +0FG+d6j+p/fD4ZJrpkVFjIbqjyBzzEP3xB5oiBVNyvzuaLnG1736ga65DJgdXYSGQXX uLdKfcDgZFHpmRYNELqkAzH9geJM98vNaZWFoAmZYOmycHTVLLWcO/5P8/9QnALrnXBf u9/+E4u40HY99K4QWNvcMVMokKxF6eFuy/g6kdfowhdv7mK8T1uyA50p5yLT5N+Vhmw+ PZPg== X-Gm-Message-State: AOJu0YzgZoXR6TVRKDl2Jqvw261+UnXiOFUQ80chSIWOY8W/VahtHjwu lkiEhKlXd2x7EqS2oLSGQ2nOn0xMl/Eh X-Google-Smtp-Source: AGHT+IE3OxKOpgUIqMLAMXLF+vg8x8XkXxDZnr0QmTLpCmJZlZF8XFhcfbDw91VwMvGlTcTQjPuH5txAspoz X-Received: from kyletso-p620lin01.ntc.corp.google.com ([2401:fa00:fc:202:99ae:e3b5:518:c5b4]) (user=kyletso job=sendgmr) by 2002:a0d:e246:0:b0:5a7:aa51:c08e with SMTP id l67-20020a0de246000000b005a7aa51c08emr219577ywe.1.1698686043516; Mon, 30 Oct 2023 10:14:03 -0700 (PDT) Date: Tue, 31 Oct 2023 01:13:48 +0800 In-Reply-To: <20231030171348.600621-1-kyletso@google.com> Mime-Version: 1.0 References: <20231030171348.600621-1-kyletso@google.com> X-Mailer: git-send-email 2.42.0.820.g83a721a137-goog Message-ID: <20231030171348.600621-3-kyletso@google.com> Subject: [PATCH v3 2/2] usb: typec: tcpm: Support multiple capabilities From: Kyle Tso To: robh+dt@kernel.org, krzysztof.kozlowski+dt@linaro.org, conor+dt@kernel.org, linux@roeck-us.net, heikki.krogerus@linux.intel.com, gregkh@linuxfoundation.org Cc: badhri@google.com, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org, Kyle Tso Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Refactor tcpm_fw_get_caps to support the multiple pd capabilities got from fwnode. For backward compatibility, the original single capability is still applicable. The fetched data is stored in the newly defined structure "pd_data" and there is an array "pd_list" to store the pointers to them. A dedicated array "pds" is used to store the handles of the registered usb_power_delivery instances. Also implement the .pd_get and .pd_set ops which are introduced in commit a7cff92f0635 ("usb: typec: USB Power Delivery helpers for ports and partners"). Once the .pd_set is called, the current capability will be updated and state machine will re-negotiate the power contract if possible. Signed-off-by: Kyle Tso --- v2 -> v3 - Changed the error handling and the usage of the APIs - Updated the commit message drivers/usb/typec/tcpm/tcpm.c | 389 ++++++++++++++++++++++++++-------- 1 file changed, 303 insertions(+), 86 deletions(-) diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c index 058d5b853b57..3250a1535aca 100644 --- a/drivers/usb/typec/tcpm/tcpm.c +++ b/drivers/usb/typec/tcpm/tcpm.c @@ -296,6 +296,15 @@ struct pd_pps_data { bool active; }; =20 +struct pd_data { + struct usb_power_delivery *pd; + struct usb_power_delivery_capabilities *source_cap; + struct usb_power_delivery_capabilities_desc source_desc; + struct usb_power_delivery_capabilities *sink_cap; + struct usb_power_delivery_capabilities_desc sink_desc; + unsigned int operating_snk_mw; +}; + struct tcpm_port { struct device *dev; =20 @@ -397,12 +406,14 @@ struct tcpm_port { unsigned int rx_msgid; =20 /* USB PD objects */ - struct usb_power_delivery *pd; + struct usb_power_delivery **pds; + struct pd_data **pd_list; struct usb_power_delivery_capabilities *port_source_caps; struct usb_power_delivery_capabilities *port_sink_caps; struct usb_power_delivery *partner_pd; struct usb_power_delivery_capabilities *partner_source_caps; struct usb_power_delivery_capabilities *partner_sink_caps; + struct usb_power_delivery *selected_pd; =20 /* Partner capabilities/requests */ u32 sink_request; @@ -412,6 +423,7 @@ struct tcpm_port { unsigned int nr_sink_caps; =20 /* Local capabilities */ + unsigned int pd_count; u32 src_pdo[PDO_MAX_OBJECTS]; unsigned int nr_src_pdo; u32 snk_pdo[PDO_MAX_OBJECTS]; @@ -6035,12 +6047,114 @@ static int tcpm_port_type_set(struct typec_port *p= , enum typec_port_type type) return 0; } =20 +static struct pd_data *tcpm_find_pd_data(struct tcpm_port *port, struct us= b_power_delivery *pd) +{ + int i; + + for (i =3D 0; port->pd_list[i]; i++) { + if (port->pd_list[i]->pd =3D=3D pd) + return port->pd_list[i]; + } + + return ERR_PTR(-ENODATA); +} + +static struct usb_power_delivery **tcpm_pd_get(struct typec_port *p) +{ + struct tcpm_port *port =3D typec_get_drvdata(p); + + return port->pds; +} + +static int tcpm_pd_set(struct typec_port *p, struct usb_power_delivery *pd) +{ + struct tcpm_port *port =3D typec_get_drvdata(p); + struct pd_data *data; + int i, ret =3D 0; + + mutex_lock(&port->lock); + + if (port->selected_pd =3D=3D pd) + goto unlock; + + data =3D tcpm_find_pd_data(port, pd); + if (IS_ERR(data)) { + ret =3D PTR_ERR(data); + goto unlock; + } + + if (data->sink_desc.pdo[0]) { + for (i =3D 0; i < PDO_MAX_OBJECTS && data->sink_desc.pdo[i]; i++) + port->snk_pdo[i] =3D data->sink_desc.pdo[i]; + port->nr_snk_pdo =3D i + 1; + port->operating_snk_mw =3D data->operating_snk_mw; + } + + if (data->source_desc.pdo[0]) { + for (i =3D 0; i < PDO_MAX_OBJECTS && data->source_desc.pdo[i]; i++) + port->snk_pdo[i] =3D data->source_desc.pdo[i]; + port->nr_src_pdo =3D i + 1; + } + + switch (port->state) { + case SRC_UNATTACHED: + case SRC_ATTACH_WAIT: + case SRC_TRYWAIT: + tcpm_set_cc(port, tcpm_rp_cc(port)); + break; + case SRC_SEND_CAPABILITIES: + case SRC_SEND_CAPABILITIES_TIMEOUT: + case SRC_NEGOTIATE_CAPABILITIES: + case SRC_READY: + case SRC_WAIT_NEW_CAPABILITIES: + port->caps_count =3D 0; + port->upcoming_state =3D SRC_SEND_CAPABILITIES; + ret =3D tcpm_ams_start(port, POWER_NEGOTIATION); + if (ret =3D=3D -EAGAIN) { + port->upcoming_state =3D INVALID_STATE; + goto unlock; + } + break; + case SNK_NEGOTIATE_CAPABILITIES: + case SNK_NEGOTIATE_PPS_CAPABILITIES: + case SNK_READY: + case SNK_TRANSITION_SINK: + case SNK_TRANSITION_SINK_VBUS: + if (port->pps_data.active) + port->upcoming_state =3D SNK_NEGOTIATE_PPS_CAPABILITIES; + else if (port->pd_capable) + port->upcoming_state =3D SNK_NEGOTIATE_CAPABILITIES; + else + break; + + port->update_sink_caps =3D true; + + ret =3D tcpm_ams_start(port, POWER_NEGOTIATION); + if (ret =3D=3D -EAGAIN) { + port->upcoming_state =3D INVALID_STATE; + goto unlock; + } + break; + default: + break; + } + + port->port_source_caps =3D data->source_cap; + port->port_sink_caps =3D data->sink_cap; + port->selected_pd =3D pd; +unlock: + mutex_unlock(&port->lock); + return ret; +} + static const struct typec_operations tcpm_ops =3D { .try_role =3D tcpm_try_role, .dr_set =3D tcpm_dr_set, .pr_set =3D tcpm_pr_set, .vconn_set =3D tcpm_vconn_set, - .port_type_set =3D tcpm_port_type_set + .port_type_set =3D tcpm_port_type_set, + .pd_get =3D tcpm_pd_get, + .pd_set =3D tcpm_pd_set }; =20 void tcpm_tcpc_reset(struct tcpm_port *port) @@ -6054,58 +6168,63 @@ EXPORT_SYMBOL_GPL(tcpm_tcpc_reset); =20 static void tcpm_port_unregister_pd(struct tcpm_port *port) { - usb_power_delivery_unregister_capabilities(port->port_sink_caps); + int i; + port->port_sink_caps =3D NULL; - usb_power_delivery_unregister_capabilities(port->port_source_caps); port->port_source_caps =3D NULL; - usb_power_delivery_unregister(port->pd); - port->pd =3D NULL; + for (i =3D 0; i < port->pd_count; i++) { + usb_power_delivery_unregister_capabilities(port->pd_list[i]->sink_cap); + kfree(port->pd_list[i]->sink_cap); + usb_power_delivery_unregister_capabilities(port->pd_list[i]->source_cap); + kfree(port->pd_list[i]->source_cap); + devm_kfree(port->dev, port->pd_list[i]); + port->pd_list[i] =3D NULL; + usb_power_delivery_unregister(port->pds[i]); + port->pds[i] =3D NULL; + } } =20 static int tcpm_port_register_pd(struct tcpm_port *port) { struct usb_power_delivery_desc desc =3D { port->typec_caps.pd_revision }; - struct usb_power_delivery_capabilities_desc caps =3D { }; struct usb_power_delivery_capabilities *cap; - int ret; + int ret, i; =20 if (!port->nr_src_pdo && !port->nr_snk_pdo) return 0; =20 - port->pd =3D usb_power_delivery_register(port->dev, &desc); - if (IS_ERR(port->pd)) { - ret =3D PTR_ERR(port->pd); - goto err_unregister; - } - - if (port->nr_src_pdo) { - memcpy_and_pad(caps.pdo, sizeof(caps.pdo), port->src_pdo, - port->nr_src_pdo * sizeof(u32), 0); - caps.role =3D TYPEC_SOURCE; - - cap =3D usb_power_delivery_register_capabilities(port->pd, &caps); - if (IS_ERR(cap)) { - ret =3D PTR_ERR(cap); + for (i =3D 0; i < port->pd_count; i++) { + port->pds[i] =3D usb_power_delivery_register(port->dev, &desc); + if (IS_ERR(port->pds[i])) { + ret =3D PTR_ERR(port->pds[i]); goto err_unregister; } - - port->port_source_caps =3D cap; - } - - if (port->nr_snk_pdo) { - memcpy_and_pad(caps.pdo, sizeof(caps.pdo), port->snk_pdo, - port->nr_snk_pdo * sizeof(u32), 0); - caps.role =3D TYPEC_SINK; - - cap =3D usb_power_delivery_register_capabilities(port->pd, &caps); - if (IS_ERR(cap)) { - ret =3D PTR_ERR(cap); - goto err_unregister; + port->pd_list[i]->pd =3D port->pds[i]; + + if (port->pd_list[i]->source_desc.pdo[0]) { + cap =3D usb_power_delivery_register_capabilities(port->pds[i], + &port->pd_list[i]->source_desc); + if (IS_ERR(cap)) { + ret =3D PTR_ERR(cap); + goto err_unregister; + } + port->pd_list[i]->source_cap =3D cap; } =20 - port->port_sink_caps =3D cap; + if (port->pd_list[i]->sink_desc.pdo[0]) { + cap =3D usb_power_delivery_register_capabilities(port->pds[i], + &port->pd_list[i]->sink_desc); + if (IS_ERR(cap)) { + ret =3D PTR_ERR(cap); + goto err_unregister; + } + port->pd_list[i]->sink_cap =3D cap; + } } =20 + port->port_source_caps =3D port->pd_list[0]->source_cap; + port->port_sink_caps =3D port->pd_list[0]->sink_cap; + port->selected_pd =3D port->pds[0]; return 0; =20 err_unregister: @@ -6114,12 +6233,11 @@ static int tcpm_port_register_pd(struct tcpm_port *= port) return ret; } =20 -static int tcpm_fw_get_caps(struct tcpm_port *port, - struct fwnode_handle *fwnode) +static int tcpm_fw_get_properties(struct tcpm_port *port, struct fwnode_ha= ndle *fwnode) { const char *opmode_str; + u32 frs_current; int ret; - u32 mw, frs_current; =20 if (!fwnode) return -EINVAL; @@ -6139,28 +6257,10 @@ static int tcpm_fw_get_caps(struct tcpm_port *port, =20 port->port_type =3D port->typec_caps.type; port->pd_supported =3D !fwnode_property_read_bool(fwnode, "pd-disable"); - port->slow_charger_loop =3D fwnode_property_read_bool(fwnode, "slow-charg= er-loop"); - if (port->port_type =3D=3D TYPEC_PORT_SNK) - goto sink; - - /* Get Source PDOs for the PD port or Source Rp value for the non-PD port= */ - if (port->pd_supported) { - ret =3D fwnode_property_count_u32(fwnode, "source-pdos"); - if (ret =3D=3D 0) - return -EINVAL; - else if (ret < 0) - return ret; + port->self_powered =3D fwnode_property_read_bool(fwnode, "self-powered"); =20 - port->nr_src_pdo =3D min(ret, PDO_MAX_OBJECTS); - ret =3D fwnode_property_read_u32_array(fwnode, "source-pdos", - port->src_pdo, port->nr_src_pdo); - if (ret) - return ret; - ret =3D tcpm_validate_caps(port, port->src_pdo, port->nr_src_pdo); - if (ret) - return ret; - } else { + if (!port->pd_supported) { ret =3D fwnode_property_read_string(fwnode, "typec-power-opmode", &opmod= e_str); if (ret) return ret; @@ -6170,43 +6270,156 @@ static int tcpm_fw_get_caps(struct tcpm_port *port, port->src_rp =3D tcpm_pwr_opmode_to_rp(ret); } =20 - if (port->port_type =3D=3D TYPEC_PORT_SRC) - return 0; + /* FRS can only be supported by DRP ports */ + if (port->port_type =3D=3D TYPEC_PORT_DRP) { + ret =3D fwnode_property_read_u32(fwnode, "new-source-frs-typec-current", + &frs_current); + if (!ret && frs_current <=3D FRS_5V_3A) + port->new_source_frs_current =3D frs_current; + } =20 -sink: - port->self_powered =3D fwnode_property_read_bool(fwnode, "self-powered"); + return 0; +} + +static int tcpm_fw_get_caps(struct tcpm_port *port, struct fwnode_handle *= fwnode) +{ + struct fwnode_handle *capabilities, *child, *caps =3D NULL; + unsigned int nr_src_pdo, nr_snk_pdo; + u32 *src_pdo, *snk_pdo; + u32 uw; + int ret =3D 0, i; =20 if (!port->pd_supported) return 0; =20 - /* Get sink pdos */ - ret =3D fwnode_property_count_u32(fwnode, "sink-pdos"); - if (ret <=3D 0) - return -EINVAL; + /* For the backward compatibility, "capabilities" node is optional. */ + capabilities =3D fwnode_get_named_child_node(fwnode, "capabilities"); + if (!capabilities) { + port->pd_count =3D 1; + } else { + fwnode_for_each_child_node(capabilities, child) + port->pd_count++; =20 - port->nr_snk_pdo =3D min(ret, PDO_MAX_OBJECTS); - ret =3D fwnode_property_read_u32_array(fwnode, "sink-pdos", - port->snk_pdo, port->nr_snk_pdo); - if ((ret < 0) || tcpm_validate_caps(port, port->snk_pdo, - port->nr_snk_pdo)) - return -EINVAL; + if (!port->pd_count) { + ret =3D -ENODATA; + goto put_capabilities; + } + } =20 - if (fwnode_property_read_u32(fwnode, "op-sink-microwatt", &mw) < 0) - return -EINVAL; - port->operating_snk_mw =3D mw / 1000; + port->pds =3D devm_kcalloc(port->dev, port->pd_count, sizeof(struct usb_p= ower_delivery *), + GFP_KERNEL); + if (!port->pds) { + ret =3D -ENOMEM; + goto put_capabilities; + } =20 - /* FRS can only be supported by DRP ports */ - if (port->port_type =3D=3D TYPEC_PORT_DRP) { - ret =3D fwnode_property_read_u32(fwnode, "new-source-frs-typec-current", - &frs_current); - if (ret >=3D 0 && frs_current <=3D FRS_5V_3A) - port->new_source_frs_current =3D frs_current; + port->pd_list =3D devm_kcalloc(port->dev, port->pd_count, sizeof(struct p= d_data *), + GFP_KERNEL); + if (!port->pd_list) { + ret =3D -ENOMEM; + goto put_capabilities; } =20 + for (i =3D 0; i < port->pd_count; i++) { + port->pd_list[i] =3D devm_kzalloc(port->dev, sizeof(struct pd_data), GFP= _KERNEL); + if (!port->pd_list[i]) { + ret =3D -ENOMEM; + goto put_capabilities; + } + + src_pdo =3D port->pd_list[i]->source_desc.pdo; + port->pd_list[i]->source_desc.role =3D TYPEC_SOURCE; + snk_pdo =3D port->pd_list[i]->sink_desc.pdo; + port->pd_list[i]->sink_desc.role =3D TYPEC_SINK; + + /* If "capabilities" is NULL, fall back to single pd cap population. */ + if (!capabilities) + caps =3D fwnode; + else + caps =3D fwnode_get_next_child_node(capabilities, caps); + + if (port->port_type !=3D TYPEC_PORT_SNK) { + ret =3D fwnode_property_count_u32(caps, "source-pdos"); + if (ret =3D=3D 0) { + ret =3D -EINVAL; + goto put_caps; + } + if (ret < 0) + goto put_caps; + + nr_src_pdo =3D min(ret, PDO_MAX_OBJECTS); + ret =3D fwnode_property_read_u32_array(caps, "source-pdos", src_pdo, + nr_src_pdo); + if (ret) + goto put_caps; + + ret =3D tcpm_validate_caps(port, src_pdo, nr_src_pdo); + if (ret) + goto put_caps; + + if (i =3D=3D 0) { + port->nr_src_pdo =3D nr_src_pdo; + memcpy_and_pad(port->src_pdo, sizeof(u32) * PDO_MAX_OBJECTS, + port->pd_list[0]->source_desc.pdo, + sizeof(u32) * nr_src_pdo, + 0); + } + } + + if (port->port_type !=3D TYPEC_PORT_SRC) { + ret =3D fwnode_property_count_u32(caps, "sink-pdos"); + if (ret =3D=3D 0) { + ret =3D -EINVAL; + goto put_caps; + } + + if (ret < 0) + goto put_caps; + + nr_snk_pdo =3D min(ret, PDO_MAX_OBJECTS); + ret =3D fwnode_property_read_u32_array(caps, "sink-pdos", snk_pdo, + nr_snk_pdo); + if (ret) + goto put_caps; + + ret =3D tcpm_validate_caps(port, snk_pdo, nr_snk_pdo); + if (ret) + goto put_caps; + + if (fwnode_property_read_u32(caps, "op-sink-microwatt", &uw) < 0) { + ret =3D -EINVAL; + goto put_caps; + } + + port->pd_list[i]->operating_snk_mw =3D uw / 1000; + + if (i =3D=3D 0) { + port->nr_snk_pdo =3D nr_snk_pdo; + memcpy_and_pad(port->snk_pdo, sizeof(u32) * PDO_MAX_OBJECTS, + port->pd_list[0]->sink_desc.pdo, + sizeof(u32) * nr_snk_pdo, + 0); + port->operating_snk_mw =3D port->pd_list[0]->operating_snk_mw; + } + } + } + +put_caps: + if (caps !=3D fwnode) + fwnode_handle_put(caps); +put_capabilities: + fwnode_handle_put(capabilities); + return ret; +} + +static int tcpm_fw_get_snk_vdos(struct tcpm_port *port, struct fwnode_hand= le *fwnode) +{ + int ret; + /* sink-vdos is optional */ ret =3D fwnode_property_count_u32(fwnode, "sink-vdos"); if (ret < 0) - ret =3D 0; + return 0; =20 port->nr_snk_vdo =3D min(ret, VDO_MAX_OBJECTS); if (port->nr_snk_vdo) { @@ -6571,13 +6784,18 @@ struct tcpm_port *tcpm_register_port(struct device = *dev, struct tcpc_dev *tcpc) init_completion(&port->pps_complete); tcpm_debugfs_init(port); =20 + err =3D tcpm_fw_get_properties(port, tcpc->fwnode); + if (err < 0) + goto out_destroy_wq; err =3D tcpm_fw_get_caps(port, tcpc->fwnode); + if (err < 0) + goto out_destroy_wq; + err =3D tcpm_fw_get_snk_vdos(port, tcpc->fwnode); if (err < 0) goto out_destroy_wq; =20 port->try_role =3D port->typec_caps.prefer_role; =20 - port->typec_caps.fwnode =3D tcpc->fwnode; port->typec_caps.revision =3D 0x0120; /* Type-C spec release 1.2 */ port->typec_caps.pd_revision =3D 0x0300; /* USB-PD spec release 3.0 */ port->typec_caps.svdm_version =3D SVDM_VER_2_0; @@ -6586,7 +6804,6 @@ struct tcpm_port *tcpm_register_port(struct device *d= ev, struct tcpc_dev *tcpc) port->typec_caps.orientation_aware =3D 1; =20 port->partner_desc.identity =3D &port->partner_ident; - port->port_type =3D port->typec_caps.type; =20 port->role_sw =3D usb_role_switch_get(port->dev); if (!port->role_sw) @@ -6605,7 +6822,7 @@ struct tcpm_port *tcpm_register_port(struct device *d= ev, struct tcpc_dev *tcpc) if (err) goto out_role_sw_put; =20 - port->typec_caps.pd =3D port->pd; + port->typec_caps.pd =3D port->pds[0]; =20 port->typec_port =3D typec_register_port(port->dev, &port->typec_caps); if (IS_ERR(port->typec_port)) { --=20 2.42.0.820.g83a721a137-goog