From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Cyrus-Session-Id: sloti22d1t05-3021914-1524574043-2-18266961814532309530 X-Sieve: CMU Sieve 3.0 X-Spam-known-sender: no X-Spam-score: 0.0 X-Spam-hits: BAYES_00 -1.9, HEADER_FROM_DIFFERENT_DOMAINS 0.25, MAILING_LIST_MULTI -1, ME_NOAUTH 0.01, RCVD_IN_DNSWL_HI -5, LANGUAGES en, BAYES_USED global, SA_VERSION 3.4.0 X-Spam-source: IP='209.132.180.67', Host='vger.kernel.org', Country='US', FromHeader='com', MailFrom='org' X-Spam-charsets: plain='us-ascii' X-Resolved-to: greg@kroah.com X-Delivered-to: greg@kroah.com X-Mail-from: linux-usb-owner@vger.kernel.org ARC-Seal: i=1; a=rsa-sha256; cv=none; d=messagingengine.com; s=fm2; t= 1524574042; b=Svz27RgOwHLuPQYy5ON9J0jBofQmo3DC/zIpn93g0bzayyIU7y 2YjvQzFRQcbE0AIhi08C99BUiAq68UX6N+fEzjQ75fQSJuYUFS1tnOVAueWirikv FXdAvZn5nMm7z/48JuuWJN7g3lxaYdA4kzHkHkX5YhF4ttSYqDn7S/08bGgRJJ1/ owBoEg3oCSGDlCsaVLpqQfaenzyvOL3jj1K9No3D5LxrU3uqrmrUS/fJzug4KaSG gmM7RKF1fleCsb5DYFCZvcqLPVMswovRAbi/QyBfZZAx4TWVfWqINqsFLo9ECh0g Xm946dTnxwiwpHkuvInTQW8v3zwq6Q2vYKgA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=date:from:to:cc:subject:message-id :references:mime-version:content-type:in-reply-to:sender :list-id; s=fm2; t=1524574042; bh=LeA3alL3ZnYqRqQwUw2bgPCqwkgSHx zIS0QjD3Y0eAk=; b=mAgwonKGp6+O9GZr/ZugW2F6/JjCXETQBxJKusPX5piZ1X vu7Ek7xsdmrYrabfVCZKpkORv863HzahlirA1sP+zRPjind7pYGxkDZ/J08eUMEp iWb7OKKjCPZQLpy7xdbIPB0m/pvc3glGlRzf6o9Mry62mLkM6dorPW81KtYTJ28O knnUJCiuIa3MAWl+++gAFqSFqUue8IflYyGyqQgRUNSwplceAst/mxXD2vVqyGk5 UVHk/FGKTZmvKTyDOIhIqInlFis+4wIGm4gWSTYQDyKWt5umuUYr6Io9+GuUHLW5 PrryPBh4CFfRllCEI+IzUHI+O7XQxuGD2JuOsORg== ARC-Authentication-Results: i=1; mx3.messagingengine.com; arc=none (no signatures found); dkim=none (no signatures found); dmarc=none (p=none,has-list-id=yes,d=none) header.from=linux.intel.com; iprev=pass policy.iprev=209.132.180.67 (vger.kernel.org); spf=none smtp.mailfrom=linux-usb-owner@vger.kernel.org smtp.helo=vger.kernel.org; x-aligned-from=fail; x-cm=none score=0; x-ptr=pass x-ptr-helo=vger.kernel.org x-ptr-lookup=vger.kernel.org; x-return-mx=pass smtp.domain=vger.kernel.org smtp.result=pass smtp_org.domain=kernel.org smtp_org.result=pass smtp_is_org_domain=no header.domain=linux.intel.com header.result=pass header_org.domain=intel.com header_org.result=pass header_is_org_domain=no; x-vs=clean score=-100 state=0 Authentication-Results: mx3.messagingengine.com; arc=none (no signatures found); dkim=none (no signatures found); dmarc=none (p=none,has-list-id=yes,d=none) header.from=linux.intel.com; iprev=pass policy.iprev=209.132.180.67 (vger.kernel.org); spf=none smtp.mailfrom=linux-usb-owner@vger.kernel.org smtp.helo=vger.kernel.org; x-aligned-from=fail; x-cm=none score=0; x-ptr=pass x-ptr-helo=vger.kernel.org x-ptr-lookup=vger.kernel.org; x-return-mx=pass smtp.domain=vger.kernel.org smtp.result=pass smtp_org.domain=kernel.org smtp_org.result=pass smtp_is_org_domain=no header.domain=linux.intel.com header.result=pass header_org.domain=intel.com header_org.result=pass header_is_org_domain=no; x-vs=clean score=-100 state=0 X-ME-VSCategory: clean X-CM-Envelope: MS4wfDus2fB27oooDnMTcVs2bX9fEGKNC0vsiDuTYyC2X5SOKgOc3o1rp07deCQzZIAz5RAGtdKrBImZ1hKR3KkwT93zIT5Htg8Lt9+L1LMzldjBKu3vpZyf aiVMN1UOP8r1tIAZZZr112zqbSx9n5zSKw6ZzeliPH7PIVawetMfOKlQBraoQ6+x5Ma2mrMOHi/aIe80kVud9naiYOjbA5H3PK4N92AjDKcyrv1LTNjVNDLG X-CM-Analysis: v=2.3 cv=Tq3Iegfh c=1 sm=1 tr=0 a=UK1r566ZdBxH71SXbqIOeA==:117 a=UK1r566ZdBxH71SXbqIOeA==:17 a=kj9zAlcOel0A:10 a=Kd1tUaAdevIA:10 a=X3a0BiUdAAAA:8 a=QyXUC8HyAAAA:8 a=VwQbUJbxAAAA:8 a=8eAF7N-IxLA0nCDghUoA:9 a=M2jAZWLrBn7CPHyj:21 a=lPTVjhLeC9vJCjLT:21 a=CjuIK1q_8ugA:10 a=d24Ss_oZLtcA:10 a=x8gzFH9gYPwA:10 a=aWu3muFgq6otJbhCXpL5:22 a=AjGcO6oz07-iQ99wixmX:22 X-ME-CMScore: 0 X-ME-CMCategory: none Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933146AbeDXMrN (ORCPT ); Tue, 24 Apr 2018 08:47:13 -0400 Received: from mga12.intel.com ([192.55.52.136]:3527 "EHLO mga12.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S933110AbeDXMqo (ORCPT ); Tue, 24 Apr 2018 08:46:44 -0400 X-Amp-Result: UNKNOWN X-Amp-Original-Verdict: FILE UNKNOWN X-Amp-File-Uploaded: False X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.49,323,1520924400"; d="scan'208";a="49491238" Date: Tue, 24 Apr 2018 15:46:39 +0300 From: Heikki Krogerus To: Adam Thomson Cc: Guenter Roeck , Greg Kroah-Hartman , Sebastian Reichel , Hans de Goede , Jun Li , linux-usb@vger.kernel.org, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org, support.opensource@diasemi.com Subject: Re: [PATCH v8 4/6] power: supply: Add 'usb_type' property and supporting code Message-ID: <20180424124639.GF25723@kuha.fi.intel.com> References: <36488aeca4c870e24ddbcf8bc9d3064c9973413f.1524490253.git.Adam.Thomson.Opensource@diasemi.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <36488aeca4c870e24ddbcf8bc9d3064c9973413f.1524490253.git.Adam.Thomson.Opensource@diasemi.com> User-Agent: Mutt/1.9.2 (2017-12-15) Sender: linux-usb-owner@vger.kernel.org X-Mailing-List: linux-usb@vger.kernel.org X-getmail-retrieved-from-mailbox: INBOX X-Mailing-List: linux-kernel@vger.kernel.org List-ID: On Mon, Apr 23, 2018 at 03:10:59PM +0100, Adam Thomson wrote: > This commit adds the 'usb_type' property to represent USB supplies > which can report a number of different types based on a connection > event. > > Examples of this already exist in drivers whereby the existing 'type' > property is updated, based on an event, to represent what was > connected (e.g. USB, USB_DCP, USB_ACA, ...). Current implementations > however don't show all supported connectable types, so this knowledge > has to be exlicitly known for each driver that supports this. > > The 'usb_type' property is intended to fill this void and show users > all possible USB types supported by a driver. The property, when read, > shows all available types for the driver, and the one currently chosen > is highlighted/bracketed. It is expected that the 'type' property > would then just show the top-level type 'USB', and this would be > static. > > Currently the 'usb_type' enum contains all of the USB variant types > that exist for the 'type' enum at this time, and in addition has > SDP and PPS types. The mirroring is intentional so as to not impact > existing usage of the 'type' property. > > Signed-off-by: Adam Thomson Reviewed-by: Heikki Krogerus > --- > Documentation/ABI/testing/sysfs-class-power | 12 ++++++++ > drivers/power/supply/power_supply_core.c | 8 ++++- > drivers/power/supply/power_supply_sysfs.c | 45 +++++++++++++++++++++++++++++ > include/linux/power_supply.h | 16 ++++++++++ > 4 files changed, 80 insertions(+), 1 deletion(-) > > diff --git a/Documentation/ABI/testing/sysfs-class-power b/Documentation/ABI/testing/sysfs-class-power > index e046566..5e23e22 100644 > --- a/Documentation/ABI/testing/sysfs-class-power > +++ b/Documentation/ABI/testing/sysfs-class-power > @@ -409,6 +409,18 @@ Description: > Access: Read > Valid values: Represented in 1/10 Degrees Celsius > > +What: /sys/class/power_supply//usb_type > +Date: March 2018 > +Contact: linux-pm@vger.kernel.org > +Description: > + Reports what type of USB connection is currently active for > + the supply, for example it can show if USB-PD capable source > + is attached. > + > + Access: Read-Only > + Valid values: "Unknown", "SDP", "DCP", "CDP", "ACA", "C", "PD", > + "PD_DRP", "PD_PPS", "BrickID" > + > What: /sys/class/power_supply//voltage_max > Date: January 2008 > Contact: linux-pm@vger.kernel.org > diff --git a/drivers/power/supply/power_supply_core.c b/drivers/power/supply/power_supply_core.c > index a7984af..ecd68c2 100644 > --- a/drivers/power/supply/power_supply_core.c > +++ b/drivers/power/supply/power_supply_core.c > @@ -843,7 +843,7 @@ static void psy_unregister_cooler(struct power_supply *psy) > { > struct device *dev; > struct power_supply *psy; > - int rc; > + int i, rc; > > if (!parent) > pr_warn("%s: Expected proper parent device for '%s'\n", > @@ -852,6 +852,12 @@ static void psy_unregister_cooler(struct power_supply *psy) > if (!desc || !desc->name || !desc->properties || !desc->num_properties) > return ERR_PTR(-EINVAL); > > + for (i = 0; i < desc->num_properties; ++i) { > + if ((desc->properties[i] == POWER_SUPPLY_PROP_USB_TYPE) && > + (!desc->usb_types || !desc->num_usb_types)) > + return ERR_PTR(-EINVAL); > + } > + > psy = kzalloc(sizeof(*psy), GFP_KERNEL); > if (!psy) > return ERR_PTR(-ENOMEM); > diff --git a/drivers/power/supply/power_supply_sysfs.c b/drivers/power/supply/power_supply_sysfs.c > index 5204f11..1350068 100644 > --- a/drivers/power/supply/power_supply_sysfs.c > +++ b/drivers/power/supply/power_supply_sysfs.c > @@ -46,6 +46,11 @@ > "USB_PD", "USB_PD_DRP", "BrickID" > }; > > +static const char * const power_supply_usb_type_text[] = { > + "Unknown", "SDP", "DCP", "CDP", "ACA", "C", > + "PD", "PD_DRP", "PD_PPS", "BrickID" > +}; > + > static const char * const power_supply_status_text[] = { > "Unknown", "Charging", "Discharging", "Not charging", "Full" > }; > @@ -73,6 +78,41 @@ > "Unknown", "System", "Device" > }; > > +static ssize_t power_supply_show_usb_type(struct device *dev, > + enum power_supply_usb_type *usb_types, > + ssize_t num_usb_types, > + union power_supply_propval *value, > + char *buf) > +{ > + enum power_supply_usb_type usb_type; > + ssize_t count = 0; > + bool match = false; > + int i; > + > + for (i = 0; i < num_usb_types; ++i) { > + usb_type = usb_types[i]; > + > + if (value->intval == usb_type) { > + count += sprintf(buf + count, "[%s] ", > + power_supply_usb_type_text[usb_type]); > + match = true; > + } else { > + count += sprintf(buf + count, "%s ", > + power_supply_usb_type_text[usb_type]); > + } > + } > + > + if (!match) { > + dev_warn(dev, "driver reporting unsupported connected type\n"); > + return -EINVAL; > + } > + > + if (count) > + buf[count - 1] = '\n'; > + > + return count; > +} > + > static ssize_t power_supply_show_property(struct device *dev, > struct device_attribute *attr, > char *buf) { > @@ -115,6 +155,10 @@ static ssize_t power_supply_show_property(struct device *dev, > else if (off == POWER_SUPPLY_PROP_TYPE) > return sprintf(buf, "%s\n", > power_supply_type_text[value.intval]); > + else if (off == POWER_SUPPLY_PROP_USB_TYPE) > + return power_supply_show_usb_type(dev, psy->desc->usb_types, > + psy->desc->num_usb_types, > + &value, buf); > else if (off == POWER_SUPPLY_PROP_SCOPE) > return sprintf(buf, "%s\n", > power_supply_scope_text[value.intval]); > @@ -241,6 +285,7 @@ static ssize_t power_supply_store_property(struct device *dev, > POWER_SUPPLY_ATTR(time_to_full_now), > POWER_SUPPLY_ATTR(time_to_full_avg), > POWER_SUPPLY_ATTR(type), > + POWER_SUPPLY_ATTR(usb_type), > POWER_SUPPLY_ATTR(scope), > POWER_SUPPLY_ATTR(precharge_current), > POWER_SUPPLY_ATTR(charge_term_current), > diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h > index f0139b4..0c9a572 100644 > --- a/include/linux/power_supply.h > +++ b/include/linux/power_supply.h > @@ -145,6 +145,7 @@ enum power_supply_property { > POWER_SUPPLY_PROP_TIME_TO_FULL_NOW, > POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, > POWER_SUPPLY_PROP_TYPE, /* use power_supply.type instead */ > + POWER_SUPPLY_PROP_USB_TYPE, > POWER_SUPPLY_PROP_SCOPE, > POWER_SUPPLY_PROP_PRECHARGE_CURRENT, > POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT, > @@ -170,6 +171,19 @@ enum power_supply_type { > POWER_SUPPLY_TYPE_APPLE_BRICK_ID, /* Apple Charging Method */ > }; > > +enum power_supply_usb_type { > + POWER_SUPPLY_USB_TYPE_UNKNOWN = 0, > + POWER_SUPPLY_USB_TYPE_SDP, /* Standard Downstream Port */ > + POWER_SUPPLY_USB_TYPE_DCP, /* Dedicated Charging Port */ > + POWER_SUPPLY_USB_TYPE_CDP, /* Charging Downstream Port */ > + POWER_SUPPLY_USB_TYPE_ACA, /* Accessory Charger Adapters */ > + POWER_SUPPLY_USB_TYPE_C, /* Type C Port */ > + POWER_SUPPLY_USB_TYPE_PD, /* Power Delivery Port */ > + POWER_SUPPLY_USB_TYPE_PD_DRP, /* PD Dual Role Port */ > + POWER_SUPPLY_USB_TYPE_PD_PPS, /* PD Programmable Power Supply */ > + POWER_SUPPLY_USB_TYPE_APPLE_BRICK_ID, /* Apple Charging Method */ > +}; > + > enum power_supply_notifier_events { > PSY_EVENT_PROP_CHANGED, > }; > @@ -196,6 +210,8 @@ struct power_supply_config { > struct power_supply_desc { > const char *name; > enum power_supply_type type; > + enum power_supply_usb_type *usb_types; > + size_t num_usb_types; > enum power_supply_property *properties; > size_t num_properties; > > -- > 1.9.1 -- heikki From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v8,4/6] power: supply: Add 'usb_type' property and supporting code From: Heikki Krogerus Message-Id: <20180424124639.GF25723@kuha.fi.intel.com> Date: Tue, 24 Apr 2018 15:46:39 +0300 To: Adam Thomson Cc: Guenter Roeck , Greg Kroah-Hartman , Sebastian Reichel , Hans de Goede , Jun Li , linux-usb@vger.kernel.org, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org, support.opensource@diasemi.com List-ID: T24gTW9uLCBBcHIgMjMsIDIwMTggYXQgMDM6MTA6NTlQTSArMDEwMCwgQWRhbSBUaG9tc29uIHdy b3RlOgo+IFRoaXMgY29tbWl0IGFkZHMgdGhlICd1c2JfdHlwZScgcHJvcGVydHkgdG8gcmVwcmVz ZW50IFVTQiBzdXBwbGllcwo+IHdoaWNoIGNhbiByZXBvcnQgYSBudW1iZXIgb2YgZGlmZmVyZW50 IHR5cGVzIGJhc2VkIG9uIGEgY29ubmVjdGlvbgo+IGV2ZW50Lgo+IAo+IEV4YW1wbGVzIG9mIHRo aXMgYWxyZWFkeSBleGlzdCBpbiBkcml2ZXJzIHdoZXJlYnkgdGhlIGV4aXN0aW5nICd0eXBlJwo+ IHByb3BlcnR5IGlzIHVwZGF0ZWQsIGJhc2VkIG9uIGFuIGV2ZW50LCB0byByZXByZXNlbnQgd2hh dCB3YXMKPiBjb25uZWN0ZWQgKGUuZy4gVVNCLCBVU0JfRENQLCBVU0JfQUNBLCAuLi4pLiBDdXJy ZW50IGltcGxlbWVudGF0aW9ucwo+IGhvd2V2ZXIgZG9uJ3Qgc2hvdyBhbGwgc3VwcG9ydGVkIGNv bm5lY3RhYmxlIHR5cGVzLCBzbyB0aGlzIGtub3dsZWRnZQo+IGhhcyB0byBiZSBleGxpY2l0bHkg a25vd24gZm9yIGVhY2ggZHJpdmVyIHRoYXQgc3VwcG9ydHMgdGhpcy4KPiAKPiBUaGUgJ3VzYl90 eXBlJyBwcm9wZXJ0eSBpcyBpbnRlbmRlZCB0byBmaWxsIHRoaXMgdm9pZCBhbmQgc2hvdyB1c2Vy cwo+IGFsbCBwb3NzaWJsZSBVU0IgdHlwZXMgc3VwcG9ydGVkIGJ5IGEgZHJpdmVyLiBUaGUgcHJv cGVydHksIHdoZW4gcmVhZCwKPiBzaG93cyBhbGwgYXZhaWxhYmxlIHR5cGVzIGZvciB0aGUgZHJp dmVyLCBhbmQgdGhlIG9uZSBjdXJyZW50bHkgY2hvc2VuCj4gaXMgaGlnaGxpZ2h0ZWQvYnJhY2tl dGVkLiBJdCBpcyBleHBlY3RlZCB0aGF0IHRoZSAndHlwZScgcHJvcGVydHkKPiB3b3VsZCB0aGVu IGp1c3Qgc2hvdyB0aGUgdG9wLWxldmVsIHR5cGUgJ1VTQicsIGFuZCB0aGlzIHdvdWxkIGJlCj4g c3RhdGljLgo+IAo+IEN1cnJlbnRseSB0aGUgJ3VzYl90eXBlJyBlbnVtIGNvbnRhaW5zIGFsbCBv ZiB0aGUgVVNCIHZhcmlhbnQgdHlwZXMKPiB0aGF0IGV4aXN0IGZvciB0aGUgJ3R5cGUnIGVudW0g YXQgdGhpcyB0aW1lLCBhbmQgaW4gYWRkaXRpb24gaGFzCj4gU0RQIGFuZCBQUFMgdHlwZXMuIFRo ZSBtaXJyb3JpbmcgaXMgaW50ZW50aW9uYWwgc28gYXMgdG8gbm90IGltcGFjdAo+IGV4aXN0aW5n IHVzYWdlIG9mIHRoZSAndHlwZScgcHJvcGVydHkuCj4gCj4gU2lnbmVkLW9mZi1ieTogQWRhbSBU aG9tc29uIDxBZGFtLlRob21zb24uT3BlbnNvdXJjZUBkaWFzZW1pLmNvbT4KClJldmlld2VkLWJ5 OiBIZWlra2kgS3JvZ2VydXMgPGhlaWtraS5rcm9nZXJ1c0BsaW51eC5pbnRlbC5jb20+Cgo+IC0t LQo+ICBEb2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL3N5c2ZzLWNsYXNzLXBvd2VyIHwgMTIgKysr KysrKysKPiAgZHJpdmVycy9wb3dlci9zdXBwbHkvcG93ZXJfc3VwcGx5X2NvcmUuYyAgICB8ICA4 ICsrKystCj4gIGRyaXZlcnMvcG93ZXIvc3VwcGx5L3Bvd2VyX3N1cHBseV9zeXNmcy5jICAgfCA0 NSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICBpbmNsdWRlL2xpbnV4L3Bvd2VyX3N1 cHBseS5oICAgICAgICAgICAgICAgIHwgMTYgKysrKysrKysrKwo+ICA0IGZpbGVzIGNoYW5nZWQs IDgwIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKPiAKPiBkaWZmIC0tZ2l0IGEvRG9jdW1l bnRhdGlvbi9BQkkvdGVzdGluZy9zeXNmcy1jbGFzcy1wb3dlciBiL0RvY3VtZW50YXRpb24vQUJJ L3Rlc3Rpbmcvc3lzZnMtY2xhc3MtcG93ZXIKPiBpbmRleCBlMDQ2NTY2Li41ZTIzZTIyIDEwMDY0 NAo+IC0tLSBhL0RvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lzZnMtY2xhc3MtcG93ZXIKPiAr KysgYi9Eb2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL3N5c2ZzLWNsYXNzLXBvd2VyCj4gQEAgLTQw OSw2ICs0MDksMTggQEAgRGVzY3JpcHRpb246Cj4gIAkJQWNjZXNzOiBSZWFkCj4gIAkJVmFsaWQg dmFsdWVzOiBSZXByZXNlbnRlZCBpbiAxLzEwIERlZ3JlZXMgQ2Vsc2l1cwo+ICAKPiArV2hhdDog CQkvc3lzL2NsYXNzL3Bvd2VyX3N1cHBseS88c3VwcGx5X25hbWU+L3VzYl90eXBlCj4gK0RhdGU6 CQlNYXJjaCAyMDE4Cj4gK0NvbnRhY3Q6CWxpbnV4LXBtQHZnZXIua2VybmVsLm9yZwo+ICtEZXNj cmlwdGlvbjoKPiArCQlSZXBvcnRzIHdoYXQgdHlwZSBvZiBVU0IgY29ubmVjdGlvbiBpcyBjdXJy ZW50bHkgYWN0aXZlIGZvcgo+ICsJCXRoZSBzdXBwbHksIGZvciBleGFtcGxlIGl0IGNhbiBzaG93 IGlmIFVTQi1QRCBjYXBhYmxlIHNvdXJjZQo+ICsJCWlzIGF0dGFjaGVkLgo+ICsKPiArCQlBY2Nl c3M6IFJlYWQtT25seQo+ICsJCVZhbGlkIHZhbHVlczogIlVua25vd24iLCAiU0RQIiwgIkRDUCIs ICJDRFAiLCAiQUNBIiwgIkMiLCAiUEQiLAo+ICsJCQkgICAgICAiUERfRFJQIiwgIlBEX1BQUyIs ICJCcmlja0lEIgo+ICsKPiAgV2hhdDogCQkvc3lzL2NsYXNzL3Bvd2VyX3N1cHBseS88c3VwcGx5 X25hbWU+L3ZvbHRhZ2VfbWF4Cj4gIERhdGU6CQlKYW51YXJ5IDIwMDgKPiAgQ29udGFjdDoJbGlu dXgtcG1Admdlci5rZXJuZWwub3JnCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvcG93ZXIvc3VwcGx5 L3Bvd2VyX3N1cHBseV9jb3JlLmMgYi9kcml2ZXJzL3Bvd2VyL3N1cHBseS9wb3dlcl9zdXBwbHlf Y29yZS5jCj4gaW5kZXggYTc5ODRhZi4uZWNkNjhjMiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3Bv d2VyL3N1cHBseS9wb3dlcl9zdXBwbHlfY29yZS5jCj4gKysrIGIvZHJpdmVycy9wb3dlci9zdXBw bHkvcG93ZXJfc3VwcGx5X2NvcmUuYwo+IEBAIC04NDMsNyArODQzLDcgQEAgc3RhdGljIHZvaWQg cHN5X3VucmVnaXN0ZXJfY29vbGVyKHN0cnVjdCBwb3dlcl9zdXBwbHkgKnBzeSkKPiAgewo+ICAJ c3RydWN0IGRldmljZSAqZGV2Owo+ICAJc3RydWN0IHBvd2VyX3N1cHBseSAqcHN5Owo+IC0JaW50 IHJjOwo+ICsJaW50IGksIHJjOwo+ICAKPiAgCWlmICghcGFyZW50KQo+ICAJCXByX3dhcm4oIiVz OiBFeHBlY3RlZCBwcm9wZXIgcGFyZW50IGRldmljZSBmb3IgJyVzJ1xuIiwKPiBAQCAtODUyLDYg Kzg1MiwxMiBAQCBzdGF0aWMgdm9pZCBwc3lfdW5yZWdpc3Rlcl9jb29sZXIoc3RydWN0IHBvd2Vy X3N1cHBseSAqcHN5KQo+ICAJaWYgKCFkZXNjIHx8ICFkZXNjLT5uYW1lIHx8ICFkZXNjLT5wcm9w ZXJ0aWVzIHx8ICFkZXNjLT5udW1fcHJvcGVydGllcykKPiAgCQlyZXR1cm4gRVJSX1BUUigtRUlO VkFMKTsKPiAgCj4gKwlmb3IgKGkgPSAwOyBpIDwgZGVzYy0+bnVtX3Byb3BlcnRpZXM7ICsraSkg ewo+ICsJCWlmICgoZGVzYy0+cHJvcGVydGllc1tpXSA9PSBQT1dFUl9TVVBQTFlfUFJPUF9VU0Jf VFlQRSkgJiYKPiArCQkgICAgKCFkZXNjLT51c2JfdHlwZXMgfHwgIWRlc2MtPm51bV91c2JfdHlw ZXMpKQo+ICsJCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKPiArCX0KPiArCj4gIAlwc3kgPSBr emFsbG9jKHNpemVvZigqcHN5KSwgR0ZQX0tFUk5FTCk7Cj4gIAlpZiAoIXBzeSkKPiAgCQlyZXR1 cm4gRVJSX1BUUigtRU5PTUVNKTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9wb3dlci9zdXBwbHkv cG93ZXJfc3VwcGx5X3N5c2ZzLmMgYi9kcml2ZXJzL3Bvd2VyL3N1cHBseS9wb3dlcl9zdXBwbHlf c3lzZnMuYwo+IGluZGV4IDUyMDRmMTEuLjEzNTAwNjggMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9w b3dlci9zdXBwbHkvcG93ZXJfc3VwcGx5X3N5c2ZzLmMKPiArKysgYi9kcml2ZXJzL3Bvd2VyL3N1 cHBseS9wb3dlcl9zdXBwbHlfc3lzZnMuYwo+IEBAIC00Niw2ICs0NiwxMSBAQAo+ICAJIlVTQl9Q RCIsICJVU0JfUERfRFJQIiwgIkJyaWNrSUQiCj4gIH07Cj4gIAo+ICtzdGF0aWMgY29uc3QgY2hh ciAqIGNvbnN0IHBvd2VyX3N1cHBseV91c2JfdHlwZV90ZXh0W10gPSB7Cj4gKwkiVW5rbm93biIs ICJTRFAiLCAiRENQIiwgIkNEUCIsICJBQ0EiLCAiQyIsCj4gKwkiUEQiLCAiUERfRFJQIiwgIlBE X1BQUyIsICJCcmlja0lEIgo+ICt9Owo+ICsKPiAgc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBw b3dlcl9zdXBwbHlfc3RhdHVzX3RleHRbXSA9IHsKPiAgCSJVbmtub3duIiwgIkNoYXJnaW5nIiwg IkRpc2NoYXJnaW5nIiwgIk5vdCBjaGFyZ2luZyIsICJGdWxsIgo+ICB9Owo+IEBAIC03Myw2ICs3 OCw0MSBAQAo+ICAJIlVua25vd24iLCAiU3lzdGVtIiwgIkRldmljZSIKPiAgfTsKPiAgCj4gK3N0 YXRpYyBzc2l6ZV90IHBvd2VyX3N1cHBseV9zaG93X3VzYl90eXBlKHN0cnVjdCBkZXZpY2UgKmRl diwKPiArCQkJCQkgIGVudW0gcG93ZXJfc3VwcGx5X3VzYl90eXBlICp1c2JfdHlwZXMsCj4gKwkJ CQkJICBzc2l6ZV90IG51bV91c2JfdHlwZXMsCj4gKwkJCQkJICB1bmlvbiBwb3dlcl9zdXBwbHlf cHJvcHZhbCAqdmFsdWUsCj4gKwkJCQkJICBjaGFyICpidWYpCj4gK3sKPiArCWVudW0gcG93ZXJf c3VwcGx5X3VzYl90eXBlIHVzYl90eXBlOwo+ICsJc3NpemVfdCBjb3VudCA9IDA7Cj4gKwlib29s IG1hdGNoID0gZmFsc2U7Cj4gKwlpbnQgaTsKPiArCj4gKwlmb3IgKGkgPSAwOyBpIDwgbnVtX3Vz Yl90eXBlczsgKytpKSB7Cj4gKwkJdXNiX3R5cGUgPSB1c2JfdHlwZXNbaV07Cj4gKwo+ICsJCWlm ICh2YWx1ZS0+aW50dmFsID09IHVzYl90eXBlKSB7Cj4gKwkJCWNvdW50ICs9IHNwcmludGYoYnVm ICsgY291bnQsICJbJXNdICIsCj4gKwkJCQkJIHBvd2VyX3N1cHBseV91c2JfdHlwZV90ZXh0W3Vz Yl90eXBlXSk7Cj4gKwkJCW1hdGNoID0gdHJ1ZTsKPiArCQl9IGVsc2Ugewo+ICsJCQljb3VudCAr PSBzcHJpbnRmKGJ1ZiArIGNvdW50LCAiJXMgIiwKPiArCQkJCQkgcG93ZXJfc3VwcGx5X3VzYl90 eXBlX3RleHRbdXNiX3R5cGVdKTsKPiArCQl9Cj4gKwl9Cj4gKwo+ICsJaWYgKCFtYXRjaCkgewo+ ICsJCWRldl93YXJuKGRldiwgImRyaXZlciByZXBvcnRpbmcgdW5zdXBwb3J0ZWQgY29ubmVjdGVk IHR5cGVcbiIpOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICsKPiArCWlmIChjb3VudCkK PiArCQlidWZbY291bnQgLSAxXSA9ICdcbic7Cj4gKwo+ICsJcmV0dXJuIGNvdW50Owo+ICt9Cj4g Kwo+ICBzdGF0aWMgc3NpemVfdCBwb3dlcl9zdXBwbHlfc2hvd19wcm9wZXJ0eShzdHJ1Y3QgZGV2 aWNlICpkZXYsCj4gIAkJCQkJICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPiAgCQkJ CQkgIGNoYXIgKmJ1Zikgewo+IEBAIC0xMTUsNiArMTU1LDEwIEBAIHN0YXRpYyBzc2l6ZV90IHBv d2VyX3N1cHBseV9zaG93X3Byb3BlcnR5KHN0cnVjdCBkZXZpY2UgKmRldiwKPiAgCWVsc2UgaWYg KG9mZiA9PSBQT1dFUl9TVVBQTFlfUFJPUF9UWVBFKQo+ICAJCXJldHVybiBzcHJpbnRmKGJ1Ziwg IiVzXG4iLAo+ICAJCQkgICAgICAgcG93ZXJfc3VwcGx5X3R5cGVfdGV4dFt2YWx1ZS5pbnR2YWxd KTsKPiArCWVsc2UgaWYgKG9mZiA9PSBQT1dFUl9TVVBQTFlfUFJPUF9VU0JfVFlQRSkKPiArCQly ZXR1cm4gcG93ZXJfc3VwcGx5X3Nob3dfdXNiX3R5cGUoZGV2LCBwc3ktPmRlc2MtPnVzYl90eXBl cywKPiArCQkJCQkJICBwc3ktPmRlc2MtPm51bV91c2JfdHlwZXMsCj4gKwkJCQkJCSAgJnZhbHVl LCBidWYpOwo+ICAJZWxzZSBpZiAob2ZmID09IFBPV0VSX1NVUFBMWV9QUk9QX1NDT1BFKQo+ICAJ CXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVzXG4iLAo+ICAJCQkgICAgICAgcG93ZXJfc3VwcGx5X3Nj b3BlX3RleHRbdmFsdWUuaW50dmFsXSk7Cj4gQEAgLTI0MSw2ICsyODUsNyBAQCBzdGF0aWMgc3Np emVfdCBwb3dlcl9zdXBwbHlfc3RvcmVfcHJvcGVydHkoc3RydWN0IGRldmljZSAqZGV2LAo+ICAJ UE9XRVJfU1VQUExZX0FUVFIodGltZV90b19mdWxsX25vdyksCj4gIAlQT1dFUl9TVVBQTFlfQVRU Uih0aW1lX3RvX2Z1bGxfYXZnKSwKPiAgCVBPV0VSX1NVUFBMWV9BVFRSKHR5cGUpLAo+ICsJUE9X RVJfU1VQUExZX0FUVFIodXNiX3R5cGUpLAo+ICAJUE9XRVJfU1VQUExZX0FUVFIoc2NvcGUpLAo+ ICAJUE9XRVJfU1VQUExZX0FUVFIocHJlY2hhcmdlX2N1cnJlbnQpLAo+ICAJUE9XRVJfU1VQUExZ X0FUVFIoY2hhcmdlX3Rlcm1fY3VycmVudCksCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgv cG93ZXJfc3VwcGx5LmggYi9pbmNsdWRlL2xpbnV4L3Bvd2VyX3N1cHBseS5oCj4gaW5kZXggZjAx MzliNC4uMGM5YTU3MiAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2xpbnV4L3Bvd2VyX3N1cHBseS5o Cj4gKysrIGIvaW5jbHVkZS9saW51eC9wb3dlcl9zdXBwbHkuaAo+IEBAIC0xNDUsNiArMTQ1LDcg QEAgZW51bSBwb3dlcl9zdXBwbHlfcHJvcGVydHkgewo+ICAJUE9XRVJfU1VQUExZX1BST1BfVElN RV9UT19GVUxMX05PVywKPiAgCVBPV0VSX1NVUFBMWV9QUk9QX1RJTUVfVE9fRlVMTF9BVkcsCj4g IAlQT1dFUl9TVVBQTFlfUFJPUF9UWVBFLCAvKiB1c2UgcG93ZXJfc3VwcGx5LnR5cGUgaW5zdGVh ZCAqLwo+ICsJUE9XRVJfU1VQUExZX1BST1BfVVNCX1RZUEUsCj4gIAlQT1dFUl9TVVBQTFlfUFJP UF9TQ09QRSwKPiAgCVBPV0VSX1NVUFBMWV9QUk9QX1BSRUNIQVJHRV9DVVJSRU5ULAo+ICAJUE9X RVJfU1VQUExZX1BST1BfQ0hBUkdFX1RFUk1fQ1VSUkVOVCwKPiBAQCAtMTcwLDYgKzE3MSwxOSBA QCBlbnVtIHBvd2VyX3N1cHBseV90eXBlIHsKPiAgCVBPV0VSX1NVUFBMWV9UWVBFX0FQUExFX0JS SUNLX0lELAkvKiBBcHBsZSBDaGFyZ2luZyBNZXRob2QgKi8KPiAgfTsKPiAgCj4gK2VudW0gcG93 ZXJfc3VwcGx5X3VzYl90eXBlIHsKPiArCVBPV0VSX1NVUFBMWV9VU0JfVFlQRV9VTktOT1dOID0g MCwKPiArCVBPV0VSX1NVUFBMWV9VU0JfVFlQRV9TRFAsCQkvKiBTdGFuZGFyZCBEb3duc3RyZWFt IFBvcnQgKi8KPiArCVBPV0VSX1NVUFBMWV9VU0JfVFlQRV9EQ1AsCQkvKiBEZWRpY2F0ZWQgQ2hh cmdpbmcgUG9ydCAqLwo+ICsJUE9XRVJfU1VQUExZX1VTQl9UWVBFX0NEUCwJCS8qIENoYXJnaW5n IERvd25zdHJlYW0gUG9ydCAqLwo+ICsJUE9XRVJfU1VQUExZX1VTQl9UWVBFX0FDQSwJCS8qIEFj Y2Vzc29yeSBDaGFyZ2VyIEFkYXB0ZXJzICovCj4gKwlQT1dFUl9TVVBQTFlfVVNCX1RZUEVfQywJ CS8qIFR5cGUgQyBQb3J0ICovCj4gKwlQT1dFUl9TVVBQTFlfVVNCX1RZUEVfUEQsCQkvKiBQb3dl ciBEZWxpdmVyeSBQb3J0ICovCj4gKwlQT1dFUl9TVVBQTFlfVVNCX1RZUEVfUERfRFJQLAkJLyog UEQgRHVhbCBSb2xlIFBvcnQgKi8KPiArCVBPV0VSX1NVUFBMWV9VU0JfVFlQRV9QRF9QUFMsCQkv KiBQRCBQcm9ncmFtbWFibGUgUG93ZXIgU3VwcGx5ICovCj4gKwlQT1dFUl9TVVBQTFlfVVNCX1RZ UEVfQVBQTEVfQlJJQ0tfSUQsCS8qIEFwcGxlIENoYXJnaW5nIE1ldGhvZCAqLwo+ICt9Owo+ICsK PiAgZW51bSBwb3dlcl9zdXBwbHlfbm90aWZpZXJfZXZlbnRzIHsKPiAgCVBTWV9FVkVOVF9QUk9Q X0NIQU5HRUQsCj4gIH07Cj4gQEAgLTE5Niw2ICsyMTAsOCBAQCBzdHJ1Y3QgcG93ZXJfc3VwcGx5 X2NvbmZpZyB7Cj4gIHN0cnVjdCBwb3dlcl9zdXBwbHlfZGVzYyB7Cj4gIAljb25zdCBjaGFyICpu YW1lOwo+ICAJZW51bSBwb3dlcl9zdXBwbHlfdHlwZSB0eXBlOwo+ICsJZW51bSBwb3dlcl9zdXBw bHlfdXNiX3R5cGUgKnVzYl90eXBlczsKPiArCXNpemVfdCBudW1fdXNiX3R5cGVzOwo+ICAJZW51 bSBwb3dlcl9zdXBwbHlfcHJvcGVydHkgKnByb3BlcnRpZXM7Cj4gIAlzaXplX3QgbnVtX3Byb3Bl cnRpZXM7Cj4gIAo+IC0tIAo+IDEuOS4xCg==