From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753338AbdHOUF6 (ORCPT ); Tue, 15 Aug 2017 16:05:58 -0400 Received: from mx1.redhat.com ([209.132.183.28]:38632 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753114AbdHOUFx (ORCPT ); Tue, 15 Aug 2017 16:05:53 -0400 DMARC-Filter: OpenDMARC Filter v1.3.2 mx1.redhat.com 495D3C9D2F Authentication-Results: ext-mx05.extmail.prod.ext.phx2.redhat.com; dmarc=none (p=none dis=none) header.from=redhat.com Authentication-Results: ext-mx05.extmail.prod.ext.phx2.redhat.com; spf=fail smtp.mailfrom=hdegoede@redhat.com From: Hans de Goede To: Wolfram Sang , Guenter Roeck , Heikki Krogerus , Sebastian Reichel , Darren Hart , Andy Shevchenko , Greg Kroah-Hartman Cc: Hans de Goede , Liam Breck , Tony Lindgren , linux-i2c@vger.kernel.org, linux-pm@vger.kernel.org, platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, devel@driverdev.osuosl.org, "Yueyao (Nathan) Zhu" Subject: [PATCH v2 07/14] staging: typec: fusb302: Export current-limit through a power_supply class dev Date: Tue, 15 Aug 2017 22:04:55 +0200 Message-Id: <20170815200502.17339-8-hdegoede@redhat.com> In-Reply-To: <20170815200502.17339-1-hdegoede@redhat.com> References: <20170815200502.17339-1-hdegoede@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.29]); Tue, 15 Aug 2017 20:05:53 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The fusb302 Type-C port-controller cannot control the current-limit directly, so we need to exported the limit so that another driver (e.g. the charger driver) can pick the limit up and configure the system accordingly. The power-supply subsys already provides infrastructure for this, power-supply devices have the notion of being supplied by another power-supply and have properties through which we can export the current-limit. Register a power_supply and export the current-limit through the power_supply's current-max property. Cc: "Yueyao (Nathan) Zhu" Signed-off-by: Hans de Goede --- Changes in v2: -Put the psy class device code directly in fusb302.c rather then introducing helpers which are only used by fusb302.c -Add an online property to the psy so that upower does not mistake it for a second battery in the system --- drivers/staging/typec/fusb302/Kconfig | 2 +- drivers/staging/typec/fusb302/fusb302.c | 63 +++++++++++++++++++++++++++++++-- 2 files changed, 62 insertions(+), 3 deletions(-) diff --git a/drivers/staging/typec/fusb302/Kconfig b/drivers/staging/typec/fusb302/Kconfig index fce099f..48a4f2f 100644 --- a/drivers/staging/typec/fusb302/Kconfig +++ b/drivers/staging/typec/fusb302/Kconfig @@ -1,6 +1,6 @@ config TYPEC_FUSB302 tristate "Fairchild FUSB302 Type-C chip driver" - depends on I2C + depends on I2C && POWER_SUPPLY help The Fairchild FUSB302 Type-C chip driver that works with Type-C Port Controller Manager to provide USB PD and USB diff --git a/drivers/staging/typec/fusb302/fusb302.c b/drivers/staging/typec/fusb302/fusb302.c index 870f8078..36fde36 100644 --- a/drivers/staging/typec/fusb302/fusb302.c +++ b/drivers/staging/typec/fusb302/fusb302.c @@ -28,6 +28,7 @@ #include #include #include +#include #include #include #include @@ -108,6 +109,11 @@ struct fusb302_chip { /* lock for sharing chip states */ struct mutex lock; + /* psy + psy status */ + struct power_supply *psy; + u32 current_limit; + u32 supply_voltage; + /* chip status */ enum toggling_mode toggling_mode; enum src_current_status src_current_status; @@ -876,11 +882,13 @@ static int tcpm_set_vbus(struct tcpc_dev *dev, bool on, bool charge) chip->vbus_on = on; fusb302_log(chip, "vbus := %s", on ? "On" : "Off"); } - if (chip->charge_on == charge) + if (chip->charge_on == charge) { fusb302_log(chip, "charge is already %s", charge ? "On" : "Off"); - else + } else { chip->charge_on = charge; + power_supply_changed(chip->psy); + } done: mutex_unlock(&chip->lock); @@ -896,6 +904,11 @@ static int tcpm_set_current_limit(struct tcpc_dev *dev, u32 max_ma, u32 mv) fusb302_log(chip, "current limit: %d ma, %d mv (not implemented)", max_ma, mv); + chip->supply_voltage = mv; + chip->current_limit = max_ma; + + power_supply_changed(chip->psy); + return 0; } @@ -1681,6 +1694,43 @@ static irqreturn_t fusb302_irq_intn(int irq, void *dev_id) return IRQ_HANDLED; } +static int fusb302_psy_get_property(struct power_supply *psy, + enum power_supply_property psp, + union power_supply_propval *val) +{ + struct fusb302_chip *chip = power_supply_get_drvdata(psy); + + switch (psp) { + case POWER_SUPPLY_PROP_ONLINE: + val->intval = chip->charge_on; + break; + case POWER_SUPPLY_PROP_VOLTAGE_NOW: + val->intval = chip->supply_voltage * 1000; /* mV -> µV */ + break; + case POWER_SUPPLY_PROP_CURRENT_MAX: + val->intval = chip->current_limit * 1000; /* mA -> µA */ + break; + default: + return -ENODATA; + } + + return 0; +} + +static enum power_supply_property fusb302_psy_properties[] = { + POWER_SUPPLY_PROP_ONLINE, + POWER_SUPPLY_PROP_VOLTAGE_NOW, + POWER_SUPPLY_PROP_CURRENT_MAX, +}; + +const struct power_supply_desc fusb302_psy_desc = { + .name = "fusb302-typec-source", + .type = POWER_SUPPLY_TYPE_USB_TYPE_C, + .properties = fusb302_psy_properties, + .num_properties = ARRAY_SIZE(fusb302_psy_properties), + .get_property = fusb302_psy_get_property, +}; + static int init_gpio(struct fusb302_chip *chip) { struct device_node *node; @@ -1720,6 +1770,7 @@ static int fusb302_probe(struct i2c_client *client, struct fusb302_chip *chip; struct i2c_adapter *adapter; struct device *dev = &client->dev; + struct power_supply_config cfg = {}; const char *name; int ret = 0; u32 val; @@ -1766,6 +1817,14 @@ static int fusb302_probe(struct i2c_client *client, return -EPROBE_DEFER; } + cfg.drv_data = chip; + chip->psy = devm_power_supply_register(dev, &fusb302_psy_desc, &cfg); + if (IS_ERR(chip->psy)) { + ret = PTR_ERR(chip->psy); + dev_err(chip->dev, "Error registering power-supply: %d\n", ret); + return ret; + } + ret = fusb302_debugfs_init(chip); if (ret < 0) return ret; -- 2.9.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Hans de Goede Subject: [PATCH v2 07/14] staging: typec: fusb302: Export current-limit through a power_supply class dev Date: Tue, 15 Aug 2017 22:04:55 +0200 Message-ID: <20170815200502.17339-8-hdegoede@redhat.com> References: <20170815200502.17339-1-hdegoede@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20170815200502.17339-1-hdegoede@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: driverdev-devel-bounces@linuxdriverproject.org Sender: "devel" To: Wolfram Sang , Guenter Roeck , Heikki Krogerus , Sebastian Reichel , Darren Hart , Andy Shevchenko , Greg Kroah-Hartman Cc: devel@driverdev.osuosl.org, linux-pm@vger.kernel.org, Tony Lindgren , "Yueyao (Nathan) Zhu" , linux-kernel@vger.kernel.org, platform-driver-x86@vger.kernel.org, Hans de Goede , Liam Breck , linux-i2c@vger.kernel.org List-Id: linux-i2c@vger.kernel.org VGhlIGZ1c2IzMDIgVHlwZS1DIHBvcnQtY29udHJvbGxlciBjYW5ub3QgY29udHJvbCB0aGUgY3Vy cmVudC1saW1pdApkaXJlY3RseSwgc28gd2UgbmVlZCB0byBleHBvcnRlZCB0aGUgbGltaXQgc28g dGhhdCBhbm90aGVyIGRyaXZlcgooZS5nLiB0aGUgY2hhcmdlciBkcml2ZXIpIGNhbiBwaWNrIHRo ZSBsaW1pdCB1cCBhbmQgY29uZmlndXJlIHRoZQpzeXN0ZW0gYWNjb3JkaW5nbHkuCgpUaGUgcG93 ZXItc3VwcGx5IHN1YnN5cyBhbHJlYWR5IHByb3ZpZGVzIGluZnJhc3RydWN0dXJlIGZvciB0aGlz LApwb3dlci1zdXBwbHkgZGV2aWNlcyBoYXZlIHRoZSBub3Rpb24gb2YgYmVpbmcgc3VwcGxpZWQg YnkgYW5vdGhlcgpwb3dlci1zdXBwbHkgYW5kIGhhdmUgcHJvcGVydGllcyB0aHJvdWdoIHdoaWNo IHdlIGNhbiBleHBvcnQgdGhlCmN1cnJlbnQtbGltaXQuCgpSZWdpc3RlciBhIHBvd2VyX3N1cHBs eSBhbmQgZXhwb3J0IHRoZSBjdXJyZW50LWxpbWl0IHRocm91Z2ggdGhlCnBvd2VyX3N1cHBseSdz IGN1cnJlbnQtbWF4IHByb3BlcnR5LgoKQ2M6ICJZdWV5YW8gKE5hdGhhbikgWmh1IiA8eXVleWFv QGdvb2dsZS5jb20+ClNpZ25lZC1vZmYtYnk6IEhhbnMgZGUgR29lZGUgPGhkZWdvZWRlQHJlZGhh dC5jb20+Ci0tLQpDaGFuZ2VzIGluIHYyOgotUHV0IHRoZSBwc3kgY2xhc3MgZGV2aWNlIGNvZGUg ZGlyZWN0bHkgaW4gZnVzYjMwMi5jIHJhdGhlciB0aGVuIGludHJvZHVjaW5nCiBoZWxwZXJzIHdo aWNoIGFyZSBvbmx5IHVzZWQgYnkgZnVzYjMwMi5jCi1BZGQgYW4gb25saW5lIHByb3BlcnR5IHRv IHRoZSBwc3kgc28gdGhhdCB1cG93ZXIgZG9lcyBub3QgbWlzdGFrZSBpdCBmb3IgYQogc2Vjb25k IGJhdHRlcnkgaW4gdGhlIHN5c3RlbQotLS0KIGRyaXZlcnMvc3RhZ2luZy90eXBlYy9mdXNiMzAy L0tjb25maWcgICB8ICAyICstCiBkcml2ZXJzL3N0YWdpbmcvdHlwZWMvZnVzYjMwMi9mdXNiMzAy LmMgfCA2MyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0KIDIgZmlsZXMgY2hhbmdl ZCwgNjIgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJz L3N0YWdpbmcvdHlwZWMvZnVzYjMwMi9LY29uZmlnIGIvZHJpdmVycy9zdGFnaW5nL3R5cGVjL2Z1 c2IzMDIvS2NvbmZpZwppbmRleCBmY2UwOTlmLi40OGE0ZjJmIDEwMDY0NAotLS0gYS9kcml2ZXJz L3N0YWdpbmcvdHlwZWMvZnVzYjMwMi9LY29uZmlnCisrKyBiL2RyaXZlcnMvc3RhZ2luZy90eXBl Yy9mdXNiMzAyL0tjb25maWcKQEAgLTEsNiArMSw2IEBACiBjb25maWcgVFlQRUNfRlVTQjMwMgog CXRyaXN0YXRlICJGYWlyY2hpbGQgRlVTQjMwMiBUeXBlLUMgY2hpcCBkcml2ZXIiCi0JZGVwZW5k cyBvbiBJMkMKKwlkZXBlbmRzIG9uIEkyQyAmJiBQT1dFUl9TVVBQTFkKIAloZWxwCiAJICBUaGUg RmFpcmNoaWxkIEZVU0IzMDIgVHlwZS1DIGNoaXAgZHJpdmVyIHRoYXQgd29ya3Mgd2l0aAogCSAg VHlwZS1DIFBvcnQgQ29udHJvbGxlciBNYW5hZ2VyIHRvIHByb3ZpZGUgVVNCIFBEIGFuZCBVU0IK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy90eXBlYy9mdXNiMzAyL2Z1c2IzMDIuYyBiL2Ry aXZlcnMvc3RhZ2luZy90eXBlYy9mdXNiMzAyL2Z1c2IzMDIuYwppbmRleCA4NzBmODA3OC4uMzZm ZGUzNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3R5cGVjL2Z1c2IzMDIvZnVzYjMwMi5j CisrKyBiL2RyaXZlcnMvc3RhZ2luZy90eXBlYy9mdXNiMzAyL2Z1c2IzMDIuYwpAQCAtMjgsNiAr MjgsNyBAQAogI2luY2x1ZGUgPGxpbnV4L29mX2RldmljZS5oPgogI2luY2x1ZGUgPGxpbnV4L29m X2dwaW8uaD4KICNpbmNsdWRlIDxsaW51eC9waW5jdHJsL2NvbnN1bWVyLmg+CisjaW5jbHVkZSA8 bGludXgvcG93ZXJfc3VwcGx5Lmg+CiAjaW5jbHVkZSA8bGludXgvcHJvY19mcy5oPgogI2luY2x1 ZGUgPGxpbnV4L3JlZ3VsYXRvci9jb25zdW1lci5oPgogI2luY2x1ZGUgPGxpbnV4L3NjaGVkL2Ns b2NrLmg+CkBAIC0xMDgsNiArMTA5LDExIEBAIHN0cnVjdCBmdXNiMzAyX2NoaXAgewogCS8qIGxv Y2sgZm9yIHNoYXJpbmcgY2hpcCBzdGF0ZXMgKi8KIAlzdHJ1Y3QgbXV0ZXggbG9jazsKIAorCS8q IHBzeSArIHBzeSBzdGF0dXMgKi8KKwlzdHJ1Y3QgcG93ZXJfc3VwcGx5ICpwc3k7CisJdTMyIGN1 cnJlbnRfbGltaXQ7CisJdTMyIHN1cHBseV92b2x0YWdlOworCiAJLyogY2hpcCBzdGF0dXMgKi8K IAllbnVtIHRvZ2dsaW5nX21vZGUgdG9nZ2xpbmdfbW9kZTsKIAllbnVtIHNyY19jdXJyZW50X3N0 YXR1cyBzcmNfY3VycmVudF9zdGF0dXM7CkBAIC04NzYsMTEgKzg4MiwxMyBAQCBzdGF0aWMgaW50 IHRjcG1fc2V0X3ZidXMoc3RydWN0IHRjcGNfZGV2ICpkZXYsIGJvb2wgb24sIGJvb2wgY2hhcmdl KQogCQljaGlwLT52YnVzX29uID0gb247CiAJCWZ1c2IzMDJfbG9nKGNoaXAsICJ2YnVzIDo9ICVz Iiwgb24gPyAiT24iIDogIk9mZiIpOwogCX0KLQlpZiAoY2hpcC0+Y2hhcmdlX29uID09IGNoYXJn ZSkKKwlpZiAoY2hpcC0+Y2hhcmdlX29uID09IGNoYXJnZSkgewogCQlmdXNiMzAyX2xvZyhjaGlw LCAiY2hhcmdlIGlzIGFscmVhZHkgJXMiLAogCQkJICAgIGNoYXJnZSA/ICJPbiIgOiAiT2ZmIik7 Ci0JZWxzZQorCX0gZWxzZSB7CiAJCWNoaXAtPmNoYXJnZV9vbiA9IGNoYXJnZTsKKwkJcG93ZXJf c3VwcGx5X2NoYW5nZWQoY2hpcC0+cHN5KTsKKwl9CiAKIGRvbmU6CiAJbXV0ZXhfdW5sb2NrKCZj aGlwLT5sb2NrKTsKQEAgLTg5Niw2ICs5MDQsMTEgQEAgc3RhdGljIGludCB0Y3BtX3NldF9jdXJy ZW50X2xpbWl0KHN0cnVjdCB0Y3BjX2RldiAqZGV2LCB1MzIgbWF4X21hLCB1MzIgbXYpCiAJZnVz YjMwMl9sb2coY2hpcCwgImN1cnJlbnQgbGltaXQ6ICVkIG1hLCAlZCBtdiAobm90IGltcGxlbWVu dGVkKSIsCiAJCSAgICBtYXhfbWEsIG12KTsKIAorCWNoaXAtPnN1cHBseV92b2x0YWdlID0gbXY7 CisJY2hpcC0+Y3VycmVudF9saW1pdCA9IG1heF9tYTsKKworCXBvd2VyX3N1cHBseV9jaGFuZ2Vk KGNoaXAtPnBzeSk7CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtMTY4MSw2ICsxNjk0LDQzIEBAIHN0 YXRpYyBpcnFyZXR1cm5fdCBmdXNiMzAyX2lycV9pbnRuKGludCBpcnEsIHZvaWQgKmRldl9pZCkK IAlyZXR1cm4gSVJRX0hBTkRMRUQ7CiB9CiAKK3N0YXRpYyBpbnQgZnVzYjMwMl9wc3lfZ2V0X3By b3BlcnR5KHN0cnVjdCBwb3dlcl9zdXBwbHkgKnBzeSwKKwkJCQkgICAgZW51bSBwb3dlcl9zdXBw bHlfcHJvcGVydHkgcHNwLAorCQkJCSAgICB1bmlvbiBwb3dlcl9zdXBwbHlfcHJvcHZhbCAqdmFs KQoreworCXN0cnVjdCBmdXNiMzAyX2NoaXAgKmNoaXAgPSBwb3dlcl9zdXBwbHlfZ2V0X2RydmRh dGEocHN5KTsKKworCXN3aXRjaCAocHNwKSB7CisJY2FzZSBQT1dFUl9TVVBQTFlfUFJPUF9PTkxJ TkU6CisJCXZhbC0+aW50dmFsID0gY2hpcC0+Y2hhcmdlX29uOworCQlicmVhazsKKwljYXNlIFBP V0VSX1NVUFBMWV9QUk9QX1ZPTFRBR0VfTk9XOgorCQl2YWwtPmludHZhbCA9IGNoaXAtPnN1cHBs eV92b2x0YWdlICogMTAwMDsgLyogbVYgLT4gwrVWICovCisJCWJyZWFrOworCWNhc2UgUE9XRVJf U1VQUExZX1BST1BfQ1VSUkVOVF9NQVg6CisJCXZhbC0+aW50dmFsID0gY2hpcC0+Y3VycmVudF9s aW1pdCAqIDEwMDA7IC8qIG1BIC0+IMK1QSAqLworCQlicmVhazsKKwlkZWZhdWx0OgorCQlyZXR1 cm4gLUVOT0RBVEE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBlbnVtIHBvd2VyX3N1 cHBseV9wcm9wZXJ0eSBmdXNiMzAyX3BzeV9wcm9wZXJ0aWVzW10gPSB7CisJUE9XRVJfU1VQUExZ X1BST1BfT05MSU5FLAorCVBPV0VSX1NVUFBMWV9QUk9QX1ZPTFRBR0VfTk9XLAorCVBPV0VSX1NV UFBMWV9QUk9QX0NVUlJFTlRfTUFYLAorfTsKKworY29uc3Qgc3RydWN0IHBvd2VyX3N1cHBseV9k ZXNjIGZ1c2IzMDJfcHN5X2Rlc2MgPSB7CisJLm5hbWUJCT0gImZ1c2IzMDItdHlwZWMtc291cmNl IiwKKwkudHlwZQkJPSBQT1dFUl9TVVBQTFlfVFlQRV9VU0JfVFlQRV9DLAorCS5wcm9wZXJ0aWVz CT0gZnVzYjMwMl9wc3lfcHJvcGVydGllcywKKwkubnVtX3Byb3BlcnRpZXMJPSBBUlJBWV9TSVpF KGZ1c2IzMDJfcHN5X3Byb3BlcnRpZXMpLAorCS5nZXRfcHJvcGVydHkJPSBmdXNiMzAyX3BzeV9n ZXRfcHJvcGVydHksCit9OworCiBzdGF0aWMgaW50IGluaXRfZ3BpbyhzdHJ1Y3QgZnVzYjMwMl9j aGlwICpjaGlwKQogewogCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbm9kZTsKQEAgLTE3MjAsNiArMTc3 MCw3IEBAIHN0YXRpYyBpbnQgZnVzYjMwMl9wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50 LAogCXN0cnVjdCBmdXNiMzAyX2NoaXAgKmNoaXA7CiAJc3RydWN0IGkyY19hZGFwdGVyICphZGFw dGVyOwogCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZjbGllbnQtPmRldjsKKwlzdHJ1Y3QgcG93ZXJf c3VwcGx5X2NvbmZpZyBjZmcgPSB7fTsKIAljb25zdCBjaGFyICpuYW1lOwogCWludCByZXQgPSAw OwogCXUzMiB2YWw7CkBAIC0xNzY2LDYgKzE4MTcsMTQgQEAgc3RhdGljIGludCBmdXNiMzAyX3By b2JlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsCiAJCQlyZXR1cm4gLUVQUk9CRV9ERUZFUjsK IAl9CiAKKwljZmcuZHJ2X2RhdGEgPSBjaGlwOworCWNoaXAtPnBzeSA9IGRldm1fcG93ZXJfc3Vw cGx5X3JlZ2lzdGVyKGRldiwgJmZ1c2IzMDJfcHN5X2Rlc2MsICZjZmcpOworCWlmIChJU19FUlIo Y2hpcC0+cHN5KSkgeworCQlyZXQgPSBQVFJfRVJSKGNoaXAtPnBzeSk7CisJCWRldl9lcnIoY2hp cC0+ZGV2LCAiRXJyb3IgcmVnaXN0ZXJpbmcgcG93ZXItc3VwcGx5OiAlZFxuIiwgcmV0KTsKKwkJ cmV0dXJuIHJldDsKKwl9CisKIAlyZXQgPSBmdXNiMzAyX2RlYnVnZnNfaW5pdChjaGlwKTsKIAlp ZiAocmV0IDwgMCkKIAkJcmV0dXJuIHJldDsKLS0gCjIuOS40CgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkZXZlbCBtYWlsaW5nIGxpc3QKZGV2ZWxAbGlu dXhkcml2ZXJwcm9qZWN0Lm9yZwpodHRwOi8vZHJpdmVyZGV2LmxpbnV4ZHJpdmVycHJvamVjdC5v cmcvbWFpbG1hbi9saXN0aW5mby9kcml2ZXJkZXYtZGV2ZWwK