From mboxrd@z Thu Jan 1 00:00:00 1970 From: Heikki Krogerus Subject: Re: [PATCH v4 5/7] power: supply: Add 'connected_type' property and supporting code Date: Tue, 30 Jan 2018 14:54:38 +0200 Message-ID: <20180130125438.GE14922@kuha.fi.intel.com> References: <3af7db87e0e6bdfa46ef3c1c9053297f711aee5a.1514904983.git.Adam.Thomson.Opensource@diasemi.com> Mime-Version: 1.0 Content-Type: text/plain; charset=us-ascii Return-path: Received: from mga11.intel.com ([192.55.52.93]:51142 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751451AbeA3Myn (ORCPT ); Tue, 30 Jan 2018 07:54:43 -0500 Content-Disposition: inline In-Reply-To: <3af7db87e0e6bdfa46ef3c1c9053297f711aee5a.1514904983.git.Adam.Thomson.Opensource@diasemi.com> Sender: linux-pm-owner@vger.kernel.org List-Id: linux-pm@vger.kernel.org To: Adam Thomson Cc: Guenter Roeck , Greg Kroah-Hartman , Sebastian Reichel , Hans de Goede , Yueyao Zhu , Rui Miguel Silva , linux-usb@vger.kernel.org, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org, support.opensource@diasemi.com On Tue, Jan 02, 2018 at 03:50:53PM +0000, Adam Thomson wrote: > This commit adds the 'connected_type' property to represent supplies > which can report a number of different types of supply 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_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 'connected_type' property is intended to fill this void and show > users all possible 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, such as 'USB', and > this would be static. > > Currently the 'conn_type' enum contains all of the USB variant types > that exist for the 'type' enum at this time, and in addition has > the PPS type. In the future this can be extended further for other > types which have multiple connected types supported. The mirroring > is intentional so as to not impact existing usage of the 'type' > property. > > Signed-off-by: Adam Thomson Looks good to me: Reviewed-by: Heikki Krogerus > --- > drivers/power/supply/power_supply_sysfs.c | 50 +++++++++++++++++++++++++++++++ > include/linux/power_supply.h | 15 ++++++++++ > 2 files changed, 65 insertions(+) > > diff --git a/drivers/power/supply/power_supply_sysfs.c b/drivers/power/supply/power_supply_sysfs.c > index 5204f11..1b3b202 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_conn_type_text[] = { > + "Unknown", "USB_DCP", "USB_CDP", "USB_ACA", "USB_C", > + "USB_PD", "USB_PD_DRP", "USB_PD_PPS", "BrickID" > +}; > + > static const char * const power_supply_status_text[] = { > "Unknown", "Charging", "Discharging", "Not charging", "Full" > }; > @@ -73,6 +78,46 @@ > "Unknown", "System", "Device" > }; > > +static ssize_t power_supply_show_conn_type(struct device *dev, > + enum power_supply_conn_type *conn_types, > + ssize_t num_conn_types, > + union power_supply_propval *value, > + char *buf) > +{ > + enum power_supply_conn_type conn_type; > + ssize_t count = 0; > + bool match = false; > + int i; > + > + if ((!conn_types) || (num_conn_types <= 0)) { > + dev_warn(dev, "driver has no valid connected types\n"); > + return -ENODATA; > + } > + > + for (i = 0; i < num_conn_types; ++i) { > + conn_type = conn_types[i]; > + > + if (value->intval == conn_type) { > + count += sprintf(buf + count, "[%s] ", > + power_supply_conn_type_text[conn_type]); > + match = true; > + } else { > + count += sprintf(buf + count, "%s ", > + power_supply_conn_type_text[conn_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 +160,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_CONNECTED_TYPE) > + return power_supply_show_conn_type(dev, psy->desc->conn_types, > + psy->desc->num_conn_types, > + &value, buf); > else if (off == POWER_SUPPLY_PROP_SCOPE) > return sprintf(buf, "%s\n", > power_supply_scope_text[value.intval]); > @@ -241,6 +290,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(connected_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 79e90b3..e15a629 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_CONNECTED_TYPE, > POWER_SUPPLY_PROP_SCOPE, > POWER_SUPPLY_PROP_PRECHARGE_CURRENT, > POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT, > @@ -170,6 +171,18 @@ enum power_supply_type { > POWER_SUPPLY_TYPE_APPLE_BRICK_ID, /* Apple Charging Method */ > }; > > +enum power_supply_conn_type { > + POWER_SUPPLY_CONN_TYPE_UNKNOWN = 0, > + POWER_SUPPLY_CONN_TYPE_USB_DCP, /* Dedicated Charging Port */ > + POWER_SUPPLY_CONN_TYPE_USB_CDP, /* Charging Downstream Port */ > + POWER_SUPPLY_CONN_TYPE_USB_ACA, /* Accessory Charger Adapters */ > + POWER_SUPPLY_CONN_TYPE_USB_TYPE_C, /* Type C Port */ > + POWER_SUPPLY_CONN_TYPE_USB_PD, /* Power Delivery Port */ > + POWER_SUPPLY_CONN_TYPE_USB_PD_DRP, /* PD Dual Role Port */ > + POWER_SUPPLY_CONN_TYPE_USB_PD_PPS, /* PD Programmable Power Supply */ > + POWER_SUPPLY_CONN_TYPE_APPLE_BRICK_ID, /* Apple Charging Method */ > +}; > + > enum power_supply_notifier_events { > PSY_EVENT_PROP_CHANGED, > }; > @@ -196,6 +209,8 @@ struct power_supply_config { > struct power_supply_desc { > const char *name; > enum power_supply_type type; > + enum power_supply_conn_type *conn_types; > + size_t num_conn_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: [v4,5/7] power: supply: Add 'connected_type' property and supporting code From: Heikki Krogerus Message-Id: <20180130125438.GE14922@kuha.fi.intel.com> Date: Tue, 30 Jan 2018 14:54:38 +0200 To: Adam Thomson Cc: Guenter Roeck , Greg Kroah-Hartman , Sebastian Reichel , Hans de Goede , Yueyao Zhu , Rui Miguel Silva , linux-usb@vger.kernel.org, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org, support.opensource@diasemi.com List-ID: T24gVHVlLCBKYW4gMDIsIDIwMTggYXQgMDM6NTA6NTNQTSArMDAwMCwgQWRhbSBUaG9tc29uIHdy b3RlOgo+IFRoaXMgY29tbWl0IGFkZHMgdGhlICdjb25uZWN0ZWRfdHlwZScgcHJvcGVydHkgdG8g cmVwcmVzZW50IHN1cHBsaWVzCj4gd2hpY2ggY2FuIHJlcG9ydCBhIG51bWJlciBvZiBkaWZmZXJl bnQgdHlwZXMgb2Ygc3VwcGx5IGJhc2VkIG9uIGEKPiBjb25uZWN0aW9uIGV2ZW50Lgo+IAo+IEV4 YW1wbGVzIG9mIHRoaXMgYWxyZWFkeSBleGlzdCBpbiBkcml2ZXJzIHdoZXJlYnkgdGhlIGV4aXN0 aW5nICd0eXBlJwo+IHByb3BlcnR5IGlzIHVwZGF0ZWQsIGJhc2VkIG9uIGFuIGV2ZW50LCB0byBy ZXByZXNlbnQgd2hhdCB3YXMKPiBjb25uZWN0ZWQgKGUuZy4gVVNCX0RDUCwgVVNCX0FDQSwgLi4u KS4gQ3VycmVudCBpbXBsZW1lbnRhdGlvbnMKPiBob3dldmVyIGRvbid0IHNob3cgYWxsIHN1cHBv cnRlZCBjb25uZWN0YWJsZSB0eXBlcywgc28gdGhpcyBrbm93bGVkZ2UKPiBoYXMgdG8gYmUgZXhs aWNpdGx5IGtub3duIGZvciBlYWNoIGRyaXZlciB0aGF0IHN1cHBvcnRzIHRoaXMuCj4gCj4gVGhl ICdjb25uZWN0ZWRfdHlwZScgcHJvcGVydHkgaXMgaW50ZW5kZWQgdG8gZmlsbCB0aGlzIHZvaWQg YW5kIHNob3cKPiB1c2VycyBhbGwgcG9zc2libGUgdHlwZXMgc3VwcG9ydGVkIGJ5IGEgZHJpdmVy LiBUaGUgcHJvcGVydHksIHdoZW4KPiByZWFkLCBzaG93cyBhbGwgYXZhaWxhYmxlIHR5cGVzIGZv ciB0aGUgZHJpdmVyLCBhbmQgdGhlIG9uZSBjdXJyZW50bHkKPiBjaG9zZW4gaXMgaGlnaGxpZ2h0 ZWQvYnJhY2tldGVkLiBJdCBpcyBleHBlY3RlZCB0aGF0IHRoZSAndHlwZScKPiBwcm9wZXJ0eSB3 b3VsZCB0aGVuIGp1c3Qgc2hvdyB0aGUgdG9wLWxldmVsIHR5cGUsIHN1Y2ggYXMgJ1VTQicsIGFu ZAo+IHRoaXMgd291bGQgYmUgc3RhdGljLgo+IAo+IEN1cnJlbnRseSB0aGUgJ2Nvbm5fdHlwZScg ZW51bSBjb250YWlucyBhbGwgb2YgdGhlIFVTQiB2YXJpYW50IHR5cGVzCj4gdGhhdCBleGlzdCBm b3IgdGhlICd0eXBlJyBlbnVtIGF0IHRoaXMgdGltZSwgYW5kIGluIGFkZGl0aW9uIGhhcwo+IHRo ZSBQUFMgdHlwZS4gSW4gdGhlIGZ1dHVyZSB0aGlzIGNhbiBiZSBleHRlbmRlZCBmdXJ0aGVyIGZv ciBvdGhlcgo+IHR5cGVzIHdoaWNoIGhhdmUgbXVsdGlwbGUgY29ubmVjdGVkIHR5cGVzIHN1cHBv cnRlZC4gVGhlIG1pcnJvcmluZwo+IGlzIGludGVudGlvbmFsIHNvIGFzIHRvIG5vdCBpbXBhY3Qg ZXhpc3RpbmcgdXNhZ2Ugb2YgdGhlICd0eXBlJwo+IHByb3BlcnR5Lgo+IAo+IFNpZ25lZC1vZmYt Ynk6IEFkYW0gVGhvbXNvbiA8QWRhbS5UaG9tc29uLk9wZW5zb3VyY2VAZGlhc2VtaS5jb20+CgpM b29rcyBnb29kIHRvIG1lOgoKUmV2aWV3ZWQtYnk6IEhlaWtraSBLcm9nZXJ1cyA8aGVpa2tpLmty b2dlcnVzQGxpbnV4LmludGVsLmNvbT4KCgo+IC0tLQo+ICBkcml2ZXJzL3Bvd2VyL3N1cHBseS9w b3dlcl9zdXBwbHlfc3lzZnMuYyB8IDUwICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysK PiAgaW5jbHVkZS9saW51eC9wb3dlcl9zdXBwbHkuaCAgICAgICAgICAgICAgfCAxNSArKysrKysr KysrCj4gIDIgZmlsZXMgY2hhbmdlZCwgNjUgaW5zZXJ0aW9ucygrKQo+IAo+IGRpZmYgLS1naXQg YS9kcml2ZXJzL3Bvd2VyL3N1cHBseS9wb3dlcl9zdXBwbHlfc3lzZnMuYyBiL2RyaXZlcnMvcG93 ZXIvc3VwcGx5L3Bvd2VyX3N1cHBseV9zeXNmcy5jCj4gaW5kZXggNTIwNGYxMS4uMWIzYjIwMiAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL3Bvd2VyL3N1cHBseS9wb3dlcl9zdXBwbHlfc3lzZnMuYwo+ ICsrKyBiL2RyaXZlcnMvcG93ZXIvc3VwcGx5L3Bvd2VyX3N1cHBseV9zeXNmcy5jCj4gQEAgLTQ2 LDYgKzQ2LDExIEBACj4gIAkiVVNCX1BEIiwgIlVTQl9QRF9EUlAiLCAiQnJpY2tJRCIKPiAgfTsK PiAgCj4gK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgcG93ZXJfc3VwcGx5X2Nvbm5fdHlwZV90 ZXh0W10gPSB7Cj4gKwkiVW5rbm93biIsICJVU0JfRENQIiwgIlVTQl9DRFAiLCAiVVNCX0FDQSIs ICJVU0JfQyIsCj4gKwkiVVNCX1BEIiwgIlVTQl9QRF9EUlAiLCAiVVNCX1BEX1BQUyIsICJCcmlj a0lEIgo+ICt9Owo+ICsKPiAgc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBwb3dlcl9zdXBwbHlf c3RhdHVzX3RleHRbXSA9IHsKPiAgCSJVbmtub3duIiwgIkNoYXJnaW5nIiwgIkRpc2NoYXJnaW5n IiwgIk5vdCBjaGFyZ2luZyIsICJGdWxsIgo+ICB9Owo+IEBAIC03Myw2ICs3OCw0NiBAQAo+ICAJ IlVua25vd24iLCAiU3lzdGVtIiwgIkRldmljZSIKPiAgfTsKPiAgCj4gK3N0YXRpYyBzc2l6ZV90 IHBvd2VyX3N1cHBseV9zaG93X2Nvbm5fdHlwZShzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gKwkJCQkJ ICAgZW51bSBwb3dlcl9zdXBwbHlfY29ubl90eXBlICpjb25uX3R5cGVzLAo+ICsJCQkJCSAgIHNz aXplX3QgbnVtX2Nvbm5fdHlwZXMsCj4gKwkJCQkJICAgdW5pb24gcG93ZXJfc3VwcGx5X3Byb3B2 YWwgKnZhbHVlLAo+ICsJCQkJCSAgIGNoYXIgKmJ1ZikKPiArewo+ICsJZW51bSBwb3dlcl9zdXBw bHlfY29ubl90eXBlIGNvbm5fdHlwZTsKPiArCXNzaXplX3QgY291bnQgPSAwOwo+ICsJYm9vbCBt YXRjaCA9IGZhbHNlOwo+ICsJaW50IGk7Cj4gKwo+ICsJaWYgKCghY29ubl90eXBlcykgfHwgKG51 bV9jb25uX3R5cGVzIDw9IDApKSB7Cj4gKwkJZGV2X3dhcm4oZGV2LCAiZHJpdmVyIGhhcyBubyB2 YWxpZCBjb25uZWN0ZWQgdHlwZXNcbiIpOwo+ICsJCXJldHVybiAtRU5PREFUQTsKPiArCX0KPiAr Cj4gKwlmb3IgKGkgPSAwOyBpIDwgbnVtX2Nvbm5fdHlwZXM7ICsraSkgewo+ICsJCWNvbm5fdHlw ZSA9IGNvbm5fdHlwZXNbaV07Cj4gKwo+ICsJCWlmICh2YWx1ZS0+aW50dmFsID09IGNvbm5fdHlw ZSkgewo+ICsJCQljb3VudCArPSBzcHJpbnRmKGJ1ZiArIGNvdW50LCAiWyVzXSAiLAo+ICsJCQkJ CSBwb3dlcl9zdXBwbHlfY29ubl90eXBlX3RleHRbY29ubl90eXBlXSk7Cj4gKwkJCW1hdGNoID0g dHJ1ZTsKPiArCQl9IGVsc2Ugewo+ICsJCQljb3VudCArPSBzcHJpbnRmKGJ1ZiArIGNvdW50LCAi JXMgIiwKPiArCQkJCQkgcG93ZXJfc3VwcGx5X2Nvbm5fdHlwZV90ZXh0W2Nvbm5fdHlwZV0pOwo+ ICsJCX0KPiArCX0KPiArCj4gKwlpZiAoIW1hdGNoKSB7Cj4gKwkJZGV2X3dhcm4oZGV2LCAiZHJp dmVyIHJlcG9ydGluZyB1bnN1cHBvcnRlZCBjb25uZWN0ZWQgdHlwZVxuIik7Cj4gKwkJcmV0dXJu IC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJaWYgKGNvdW50KQo+ICsJCWJ1Zltjb3VudCAtIDFdID0g J1xuJzsKPiArCj4gKwlyZXR1cm4gY291bnQ7Cj4gK30KPiArCj4gIHN0YXRpYyBzc2l6ZV90IHBv d2VyX3N1cHBseV9zaG93X3Byb3BlcnR5KHN0cnVjdCBkZXZpY2UgKmRldiwKPiAgCQkJCQkgIHN0 cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAo+ICAJCQkJCSAgY2hhciAqYnVmKSB7Cj4gQEAg LTExNSw2ICsxNjAsMTAgQEAgc3RhdGljIHNzaXplX3QgcG93ZXJfc3VwcGx5X3Nob3dfcHJvcGVy dHkoc3RydWN0IGRldmljZSAqZGV2LAo+ICAJZWxzZSBpZiAob2ZmID09IFBPV0VSX1NVUFBMWV9Q Uk9QX1RZUEUpCj4gIAkJcmV0dXJuIHNwcmludGYoYnVmLCAiJXNcbiIsCj4gIAkJCSAgICAgICBw b3dlcl9zdXBwbHlfdHlwZV90ZXh0W3ZhbHVlLmludHZhbF0pOwo+ICsJZWxzZSBpZiAob2ZmID09 IFBPV0VSX1NVUFBMWV9QUk9QX0NPTk5FQ1RFRF9UWVBFKQo+ICsJCXJldHVybiBwb3dlcl9zdXBw bHlfc2hvd19jb25uX3R5cGUoZGV2LCBwc3ktPmRlc2MtPmNvbm5fdHlwZXMsCj4gKwkJCQkJCSAg IHBzeS0+ZGVzYy0+bnVtX2Nvbm5fdHlwZXMsCj4gKwkJCQkJCSAgICZ2YWx1ZSwgYnVmKTsKPiAg CWVsc2UgaWYgKG9mZiA9PSBQT1dFUl9TVVBQTFlfUFJPUF9TQ09QRSkKPiAgCQlyZXR1cm4gc3By aW50ZihidWYsICIlc1xuIiwKPiAgCQkJICAgICAgIHBvd2VyX3N1cHBseV9zY29wZV90ZXh0W3Zh bHVlLmludHZhbF0pOwo+IEBAIC0yNDEsNiArMjkwLDcgQEAgc3RhdGljIHNzaXplX3QgcG93ZXJf c3VwcGx5X3N0b3JlX3Byb3BlcnR5KHN0cnVjdCBkZXZpY2UgKmRldiwKPiAgCVBPV0VSX1NVUFBM WV9BVFRSKHRpbWVfdG9fZnVsbF9ub3cpLAo+ICAJUE9XRVJfU1VQUExZX0FUVFIodGltZV90b19m dWxsX2F2ZyksCj4gIAlQT1dFUl9TVVBQTFlfQVRUUih0eXBlKSwKPiArCVBPV0VSX1NVUFBMWV9B VFRSKGNvbm5lY3RlZF90eXBlKSwKPiAgCVBPV0VSX1NVUFBMWV9BVFRSKHNjb3BlKSwKPiAgCVBP V0VSX1NVUFBMWV9BVFRSKHByZWNoYXJnZV9jdXJyZW50KSwKPiAgCVBPV0VSX1NVUFBMWV9BVFRS KGNoYXJnZV90ZXJtX2N1cnJlbnQpLAo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3Bvd2Vy X3N1cHBseS5oIGIvaW5jbHVkZS9saW51eC9wb3dlcl9zdXBwbHkuaAo+IGluZGV4IDc5ZTkwYjMu LmUxNWE2MjkgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9saW51eC9wb3dlcl9zdXBwbHkuaAo+ICsr KyBiL2luY2x1ZGUvbGludXgvcG93ZXJfc3VwcGx5LmgKPiBAQCAtMTQ1LDYgKzE0NSw3IEBAIGVu dW0gcG93ZXJfc3VwcGx5X3Byb3BlcnR5IHsKPiAgCVBPV0VSX1NVUFBMWV9QUk9QX1RJTUVfVE9f RlVMTF9OT1csCj4gIAlQT1dFUl9TVVBQTFlfUFJPUF9USU1FX1RPX0ZVTExfQVZHLAo+ICAJUE9X RVJfU1VQUExZX1BST1BfVFlQRSwgLyogdXNlIHBvd2VyX3N1cHBseS50eXBlIGluc3RlYWQgKi8K PiArCVBPV0VSX1NVUFBMWV9QUk9QX0NPTk5FQ1RFRF9UWVBFLAo+ICAJUE9XRVJfU1VQUExZX1BS T1BfU0NPUEUsCj4gIAlQT1dFUl9TVVBQTFlfUFJPUF9QUkVDSEFSR0VfQ1VSUkVOVCwKPiAgCVBP V0VSX1NVUFBMWV9QUk9QX0NIQVJHRV9URVJNX0NVUlJFTlQsCj4gQEAgLTE3MCw2ICsxNzEsMTgg QEAgZW51bSBwb3dlcl9zdXBwbHlfdHlwZSB7Cj4gIAlQT1dFUl9TVVBQTFlfVFlQRV9BUFBMRV9C UklDS19JRCwJLyogQXBwbGUgQ2hhcmdpbmcgTWV0aG9kICovCj4gIH07Cj4gIAo+ICtlbnVtIHBv d2VyX3N1cHBseV9jb25uX3R5cGUgewo+ICsJUE9XRVJfU1VQUExZX0NPTk5fVFlQRV9VTktOT1dO ID0gMCwKPiArCVBPV0VSX1NVUFBMWV9DT05OX1RZUEVfVVNCX0RDUCwJCS8qIERlZGljYXRlZCBD aGFyZ2luZyBQb3J0ICovCj4gKwlQT1dFUl9TVVBQTFlfQ09OTl9UWVBFX1VTQl9DRFAsCQkvKiBD aGFyZ2luZyBEb3duc3RyZWFtIFBvcnQgKi8KPiArCVBPV0VSX1NVUFBMWV9DT05OX1RZUEVfVVNC X0FDQSwJCS8qIEFjY2Vzc29yeSBDaGFyZ2VyIEFkYXB0ZXJzICovCj4gKwlQT1dFUl9TVVBQTFlf Q09OTl9UWVBFX1VTQl9UWVBFX0MsCS8qIFR5cGUgQyBQb3J0ICovCj4gKwlQT1dFUl9TVVBQTFlf Q09OTl9UWVBFX1VTQl9QRCwJCS8qIFBvd2VyIERlbGl2ZXJ5IFBvcnQgKi8KPiArCVBPV0VSX1NV UFBMWV9DT05OX1RZUEVfVVNCX1BEX0RSUCwJLyogUEQgRHVhbCBSb2xlIFBvcnQgKi8KPiArCVBP V0VSX1NVUFBMWV9DT05OX1RZUEVfVVNCX1BEX1BQUywJLyogUEQgUHJvZ3JhbW1hYmxlIFBvd2Vy IFN1cHBseSAqLwo+ICsJUE9XRVJfU1VQUExZX0NPTk5fVFlQRV9BUFBMRV9CUklDS19JRCwJLyog QXBwbGUgQ2hhcmdpbmcgTWV0aG9kICovCj4gK307Cj4gKwo+ICBlbnVtIHBvd2VyX3N1cHBseV9u b3RpZmllcl9ldmVudHMgewo+ICAJUFNZX0VWRU5UX1BST1BfQ0hBTkdFRCwKPiAgfTsKPiBAQCAt MTk2LDYgKzIwOSw4IEBAIHN0cnVjdCBwb3dlcl9zdXBwbHlfY29uZmlnIHsKPiAgc3RydWN0IHBv d2VyX3N1cHBseV9kZXNjIHsKPiAgCWNvbnN0IGNoYXIgKm5hbWU7Cj4gIAllbnVtIHBvd2VyX3N1 cHBseV90eXBlIHR5cGU7Cj4gKwllbnVtIHBvd2VyX3N1cHBseV9jb25uX3R5cGUgKmNvbm5fdHlw ZXM7Cj4gKwlzaXplX3QgbnVtX2Nvbm5fdHlwZXM7Cj4gIAllbnVtIHBvd2VyX3N1cHBseV9wcm9w ZXJ0eSAqcHJvcGVydGllczsKPiAgCXNpemVfdCBudW1fcHJvcGVydGllczsKPiAgCj4gLS0gCj4g MS45LjEK