From patchwork Mon Feb 7 04:39:06 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Badhri Jagan Sridharan X-Patchwork-Id: 540720 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 A9992C433EF for ; Mon, 7 Feb 2022 06:14:49 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244668AbiBGGNU (ORCPT ); Mon, 7 Feb 2022 01:13:20 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48406 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1351822AbiBGEjQ (ORCPT ); Sun, 6 Feb 2022 23:39:16 -0500 Received: from mail-yb1-xb49.google.com (mail-yb1-xb49.google.com [IPv6:2607:f8b0:4864:20::b49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 97A23C043181 for ; Sun, 6 Feb 2022 20:39:13 -0800 (PST) Received: by mail-yb1-xb49.google.com with SMTP id z15-20020a25bb0f000000b00613388c7d99so26043798ybg.8 for ; Sun, 06 Feb 2022 20:39:13 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:message-id:mime-version:subject:from:to:cc; bh=ZGBcS7JWV4jEm41Ieg0bh/DWDMa+jid9L2vZwRwLPsQ=; b=hTi2MIRuc/XCPJdsJ8EBR8xE/nfUcnqO/pcV2L0/Vx4Muy05JpQDhrmhezGgIVhPV8 G6etzRvhkLJ/XS074ODg978oyePc62d5Hwywtt24jXa5rivawKxCYakQnlJOdTZdMWbp S1bO7TV0OaXcoTVKm6WBLjTfYvhKrZ3lQJMEZw1+59aZhZR8ogcuHZpwn7zAWGo0nvJj D1mF1Ch86HwaduTjHGN9jlHC3MYC/bkEeWtDbmwzRmpqZGCLbiAnL5xPJcFQ2qpE8ksY WWs2wyHZ5LKrq0VY5TefuETmU0Ui72bJJ4aoXZY/WeoF6WUFzkHYqaRQleJ7vKTeu2Q1 x5aA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:message-id:mime-version:subject:from:to:cc; bh=ZGBcS7JWV4jEm41Ieg0bh/DWDMa+jid9L2vZwRwLPsQ=; b=5go+JEigJ/Vd5q4jhplbcQp4g/BHzZcZqniB4PFA7dlsjCkW0JRPhYMH1IKOMdQqKf zSrNXVF4jZ6y8lY5xtIJChxnLCzPpjAIhkftTNbkRGF3gzixRkVXge3J120E62z5TMqs bjtibNBFNexRDBAPR9yfEQLMlBwBTZuFDJSvmzvX7asdCShtbrQafxOsnVyboZhFUYdN 2c47Py+fJ4iX7f5p/ZzEWfyJNGppMGR2a8TAtMRgENcxMR1JouvS8Qm23rBQAUEg92lj SP15mFAS9iuz/EmG/HX0v+AF2Nr45We91eH7LV8s2luJl931Lzxk76BftT4C9jPa6XeG +hfw== X-Gm-Message-State: AOAM5306m09BoBgI5Aa+7VhBeS8LdCWZkb2FluwTZPGlb1Pmd8uHYjhx oUlhX5vNRvi3HP2wMuU6fwTckXLg5zg= X-Google-Smtp-Source: ABdhPJyKen1NvGRKRRF5JJSfuC0xiMhzV6FqmDa7uRHf2FY/+bd89jMaurQm8wBzbpZx9FYb+xTlwVIwGvs= X-Received: from badhri.mtv.corp.google.com ([2620:15c:211:201:55d1:a045:9816:1433]) (user=badhri job=sendgmr) by 2002:a5b:bcd:: with SMTP id c13mr251353ybr.303.1644208752853; Sun, 06 Feb 2022 20:39:12 -0800 (PST) Date: Sun, 6 Feb 2022 20:39:06 -0800 Message-Id: <20220207043907.2758424-1-badhri@google.com> Mime-Version: 1.0 X-Mailer: git-send-email 2.35.0.263.gb82422642f-goog Subject: [PATCH v1 1/2] usb: typec: Introduce typec attributes for limiting source current From: Badhri Jagan Sridharan To: Guenter Roeck , Heikki Krogerus , Greg Kroah-Hartman Cc: linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org, Kyle Tso , Badhri Jagan Sridharan Precedence: bulk List-ID: X-Mailing-List: linux-usb@vger.kernel.org This change introduces the following two attributes to the typec sysfs class which allows userspace to limit the power advertised while acting as source. This is useful to mitigate battery drain in portable devices when the battery SOC is low. New attibutes introduced: 1. limit_src_current_active 2. limit_src_current_ma The port while in PD contract and acting as source would only advertise vSafe5V fixed PDO with current set through limit_src_current_ma when limit_src_current_active is set to 1. When limit_src_current_active is set to 0, the port would publish the default source capabilities. limit_src_current_ma would limit the current to the Maximum current published by vSafe5V fixed pdo of the default source capabilities of the port. Signed-off-by: Badhri Jagan Sridharan --- Documentation/ABI/testing/sysfs-class-typec | 25 ++++++ drivers/usb/typec/class.c | 99 +++++++++++++++++++++ drivers/usb/typec/class.h | 5 ++ include/linux/usb/typec.h | 4 + 4 files changed, 133 insertions(+) diff --git a/Documentation/ABI/testing/sysfs-class-typec b/Documentation/ABI/testing/sysfs-class-typec index 75088ecad202..dd2240632172 100644 --- a/Documentation/ABI/testing/sysfs-class-typec +++ b/Documentation/ABI/testing/sysfs-class-typec @@ -141,6 +141,31 @@ Description: - "reverse": CC2 orientation - "unknown": Orientation cannot be determined. +What: /sys/class/typec//limit_src_current_active +Date: February 2022 +Contact: Badhri Jagan Sridharan +Description: + This attribute can be used to make the port only publish + vSafe5V fixed pdo with Maximum current limited to the + current limit set by limit_src_current_ma when the port + is acting as source. + Valid values: + - write(2) "1" limits source capabilities to vSafe5V + with max current specified by limit_src_current_ma + - write(2) "0" publishes the default source capabilities + of the port. + +What: /sys/class/typec//limit_src_current_ma +Date: February 2022 +Contact: Badhri Jagan Sridharan +Description: + This attribute allows write(2) to set the Maximum + current published when limit_src_current_active is set + to 1. When limit_src_current_active is already set + to 1, if the port is already acting as source with + explicit contract in place, write(2) will make the port + renegotiate the pd contract. + USB Type-C partner devices (eg. /sys/class/typec/port0-partner/) What: /sys/class/typec/-partner/accessory_mode diff --git a/drivers/usb/typec/class.c b/drivers/usb/typec/class.c index 45a6f0c807cb..3b3c7b080ad1 100644 --- a/drivers/usb/typec/class.c +++ b/drivers/usb/typec/class.c @@ -1403,6 +1403,102 @@ port_type_show(struct device *dev, struct device_attribute *attr, } static DEVICE_ATTR_RW(port_type); +static ssize_t +limit_src_current_active_store(struct device *dev, struct device_attribute *attr, const char *buf, + size_t size) +{ + struct typec_port *port = to_typec_port(dev); + int ret; + u8 active; + + if (port->cap->type == TYPEC_PORT_SNK || !port->ops || !port->ops->limit_src_current_set || + !port->cap->pd_revision) { + dev_dbg(dev, "Limiting source current not supported\n"); + return -EOPNOTSUPP; + } + + if (kstrtou8(buf, 0, &active)) + return -EINVAL; + + if (active != 1 && active != 0) + return -EINVAL; + + mutex_lock(&port->limit_src_current_lock); + + if (port->limit_src_current_active == (bool)active) { + ret = size; + goto unlock_and_ret; + } + + ret = port->ops->limit_src_current_set(port, port->limit_src_current_ma, active); + if (ret) + goto unlock_and_ret; + + port->limit_src_current_active = active; + ret = size; + +unlock_and_ret: + mutex_unlock(&port->limit_src_current_lock); + return ret; +} + +static ssize_t +limit_src_current_active_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + struct typec_port *port = to_typec_port(dev); + + return sysfs_emit(buf, "%d\n", port->limit_src_current_active ? 1 : 0); +} +static DEVICE_ATTR_RW(limit_src_current_active); + +static ssize_t +limit_src_current_ma_store(struct device *dev, struct device_attribute *attr, const char *buf, + size_t size) +{ + struct typec_port *port = to_typec_port(dev); + int ret; + u32 src_current_ma; + + if (port->cap->type == TYPEC_PORT_SNK || !port->ops || !port->ops->limit_src_current_set || + !port->cap->pd_revision) { + dev_dbg(dev, "Limiting source current not supported\n"); + return -EOPNOTSUPP; + } + + if (kstrtou32(buf, 0, &src_current_ma)) + return -EINVAL; + + mutex_lock(&port->limit_src_current_lock); + + if (port->limit_src_current_ma == src_current_ma) { + ret = size; + goto unlock_and_ret; + } + + if (port->limit_src_current_active) { + ret = port->ops->limit_src_current_set(port, src_current_ma, + port->limit_src_current_active); + if (ret) + goto unlock_and_ret; + } + + port->limit_src_current_ma = src_current_ma; + ret = size; + +unlock_and_ret: + mutex_unlock(&port->limit_src_current_lock); + return ret; +} + +static ssize_t +limit_src_current_ma_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + struct typec_port *port = to_typec_port(dev); + + return sysfs_emit(buf, "%u\n", port->limit_src_current_ma); +} +static DEVICE_ATTR_RW(limit_src_current_ma); + static const char * const typec_pwr_opmodes[] = { [TYPEC_PWR_MODE_USB] = "default", [TYPEC_PWR_MODE_1_5A] = "1.5A", @@ -1536,6 +1632,8 @@ static struct attribute *typec_attrs[] = { &dev_attr_vconn_source.attr, &dev_attr_port_type.attr, &dev_attr_orientation.attr, + &dev_attr_limit_src_current_active.attr, + &dev_attr_limit_src_current_ma.attr, NULL, }; @@ -2039,6 +2137,7 @@ struct typec_port *typec_register_port(struct device *parent, ida_init(&port->mode_ids); mutex_init(&port->port_type_lock); + mutex_init(&port->limit_src_current_lock); port->id = id; port->ops = cap->ops; diff --git a/drivers/usb/typec/class.h b/drivers/usb/typec/class.h index 0f1bd6d19d67..3856bc058444 100644 --- a/drivers/usb/typec/class.h +++ b/drivers/usb/typec/class.h @@ -54,6 +54,11 @@ struct typec_port { const struct typec_capability *cap; const struct typec_operations *ops; + + /* lock to protect limit_src_current_*_store operation */ + struct mutex limit_src_current_lock; + u32 limit_src_current_ma; + bool limit_src_current_active; }; #define to_typec_port(_dev_) container_of(_dev_, struct typec_port, dev) diff --git a/include/linux/usb/typec.h b/include/linux/usb/typec.h index 7ba45a97eeae..1b1958ae4c16 100644 --- a/include/linux/usb/typec.h +++ b/include/linux/usb/typec.h @@ -213,6 +213,8 @@ struct typec_partner_desc { * @pr_set: Set Power Role * @vconn_set: Source VCONN * @port_type_set: Set port type + * @limit_src_current_set: Used to limit source current advertisement while + * acting as source */ struct typec_operations { int (*try_role)(struct typec_port *port, int role); @@ -221,6 +223,8 @@ struct typec_operations { int (*vconn_set)(struct typec_port *port, enum typec_role role); int (*port_type_set)(struct typec_port *port, enum typec_port_type type); + int (*limit_src_current_set)(struct typec_port *port, u32 limit_src_current_ma, + bool enable); }; enum usb_pd_svdm_ver {