From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Date: Tue, 6 Mar 2018 14:02:02 +0200 From: Heikki Krogerus Subject: Re: [PATCH v2 10/12] dt-bindings: connector: add properties for typec power delivery Message-ID: <20180306120202.GA4951@kuha.fi.intel.com> References: <1519645759-12701-1-git-send-email-jun.li@nxp.com> <1519645759-12701-11-git-send-email-jun.li@nxp.com> <20522804-65ab-5d48-716a-c199e4c095fc@samsung.com> <133b5194-26ff-071a-d3d1-2bfca1375cae@samsung.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="opJtzjQTFsWo+cga" Content-Disposition: inline In-Reply-To: To: Jun Li Cc: Andrzej Hajda , "gregkh@linuxfoundation.org" , "robh+dt@kernel.org" , "linux@roeck-us.net" , "mark.rutland@arm.com" , "yueyao@google.com" , Peter Chen , "garsilva@embeddedor.com" , "o_leveque@orange.fr" , "shufan_lee@richtek.com" , "linux-usb@vger.kernel.org" , "devicetree@vger.kernel.org" , dl-linux-imx List-ID: --opJtzjQTFsWo+cga Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi guys, On Tue, Mar 06, 2018 at 09:38:59AM +0000, Jun Li wrote: > > >>> diff --git > > >>> a/Documentation/devicetree/bindings/connector/usb-connector.txt > > >>> b/Documentation/devicetree/bindings/connector/usb-connector.txt > > >>> index e1463f1..242f6df 100644 > > >>> --- a/Documentation/devicetree/bindings/connector/usb-connector.txt > > >>> +++ > > b/Documentation/devicetree/bindings/connector/usb-connector.txt > > >>> @@ -15,6 +15,30 @@ Optional properties: > > >>> - type: size of the connector, should be specified in case of USB-A, > > USB-B > > >>> non-fullsize connectors: "mini", "micro". > > >>> > > >>> +Required properties for usb-c-connector with power delivery support: > > >>> +- port-type: should be one of "source", "sink" or "dual". > > >>> +- default-role: preferred power role if port-type is "dual"(drp), > > >>> +should be > > >>> + "sink" or "source". > > >> Since port carries data and power, it would be better to explicitly > > >> mention it in names of properties which can be ambiguous. > > >> Maybe instead of 'port-type' you can use 'power-role', for example. > > > Port-type is align with the name of typec coding and ABI, 'power-role' > > > is more like for the current role rather than the port's ability. > > > > I am not sure what are you exactly mean by "coding and ABI", but I guess it is > > just about Power-Delivery part of USB-C. And if you want to put this property > > into USB node without mark it is related to PD part of USB connector, you > > risk confusion with possible USB data related properties. > > Understood your concern, I am following typec naming conventions, > for typec, port-type property has the same meaning as > /sys/class/typec/portx/port_type > which is not only for power, also for data, there are dedicated > sys files power_role for power and data_role for data. > > > Simple question, what if somebody wants to add property describing USB > > data capabilities (DFP, UFP, DRD), how should it be named? > > > > Then we may use data-role? > > > > > > >> Other thing is that default-role is required only in case of DRP, so > > >> maybe better would be to squash it in power-role, for example: > > >> ?????? power-role: should be on of "source", "sink", "dual-source", > > >> "dual-sink", in case of dual roles suffix determines preferred role. > > > I don't know how much this squash can benefit, "dual-source/sink" is > > > not directly showing its meaning by name. > > > > Some benefit is simpler binding, no conditionally-required property. > > > > There is already string definition for port type and preferred role parse > static const char * const typec_port_types[] = { > [TYPEC_PORT_DFP] = "source", > [TYPEC_PORT_UFP] = "sink", > [TYPEC_PORT_DRP] = "dual", > }; > And I think there will be other conditionally-required properties > to be extended later, are we going to name all of them by this way? > Either way is OK for me, I am not sure if there is principle like we > should avoid conditionally-required property, if we should, maybe > "dual-preferred-source/sink" is better. > > Hi Heikki, > Do you have any comments/preference here? In the first versions of USB Type-C specification the data and power roles were in practice coupled together. There were no data role specific modes, just DFP, UFP and DRP. However, v1.2 of the spec. introduced separate modes for the data roles as well, and I have a patch for that (attached). If you are asking my opinion, the data role must be handled as separate capability of the port, i.e. you probable want to have separate properties for the power role and data role, even if we did not support that yet in the class code. Don't use "port-type" name, just call them "power-role" and "data-role" from now on. The default-role should tell the state machines whether Try.SNK or Try.SRC states should be used or not. Perhaps you should have boolean property for both: "try-snk" and "try-src" (note: both can not be true). Final note. I think it would make sense to clearly separate the USB Type-C specific properties from USB PD ones. Though it is unlikely that we will see USB PD being used with other connector types besides Type-C anymore, USB Type-C connectors will still definitely not always support USB PD, but when USB PD is not supported, we still need to know the data-role, power-role, default-role (or try-snk, try-src), etc. Br, -- heikki --opJtzjQTFsWo+cga Content-Type: text/plain; charset=us-ascii Content-Disposition: attachment; filename="0001-usb-typec-Separate-the-definitions-for-data-and-powe.patch" >>From 4f7652ba8a3d4e8f7bd30cf7ca8beba6af5ad873 Mon Sep 17 00:00:00 2001 From: Heikki Krogerus Date: Tue, 2 Jan 2018 17:07:58 +0300 Subject: [PATCH] usb: typec: Separate the definitions for data and power roles USB Type-C specification v1.2 separated the power and data roles more clearly. Dual-Role-Data term was introduced, and the meaning of DRP was changed from "Dual-Role-Port" to "Dual-Role-Power". In order to allow the port drivers to describe the capabilities of the ports more clearly according to the newest specifications, introducing separate definitions for the data roles. Signed-off-by: Heikki Krogerus --- drivers/usb/typec/class.c | 56 ++++++++++++++++++++++--------------- drivers/usb/typec/fusb302/fusb302.c | 1 + drivers/usb/typec/tcpm.c | 9 +++--- drivers/usb/typec/tps6598x.c | 26 +++++++++++------ drivers/usb/typec/typec_wcove.c | 1 + drivers/usb/typec/ucsi/ucsi.c | 13 +++++++-- include/linux/usb/tcpm.h | 1 + include/linux/usb/typec.h | 14 ++++++++-- 8 files changed, 80 insertions(+), 41 deletions(-) diff --git a/drivers/usb/typec/class.c b/drivers/usb/typec/class.c index 2620a694704f..53df10df2f9d 100644 --- a/drivers/usb/typec/class.c +++ b/drivers/usb/typec/class.c @@ -282,10 +282,10 @@ typec_altmode_roles_show(struct device *dev, struct device_attribute *attr, ssize_t ret; switch (mode->roles) { - case TYPEC_PORT_DFP: + case TYPEC_PORT_SRC: ret = sprintf(buf, "source\n"); break; - case TYPEC_PORT_UFP: + case TYPEC_PORT_SNK: ret = sprintf(buf, "sink\n"); break; case TYPEC_PORT_DRP: @@ -797,14 +797,14 @@ static const char * const typec_data_roles[] = { }; static const char * const typec_port_types[] = { - [TYPEC_PORT_DFP] = "source", - [TYPEC_PORT_UFP] = "sink", + [TYPEC_PORT_SRC] = "source", + [TYPEC_PORT_SNK] = "sink", [TYPEC_PORT_DRP] = "dual", }; static const char * const typec_port_types_drp[] = { - [TYPEC_PORT_DFP] = "dual [source] sink", - [TYPEC_PORT_UFP] = "dual source [sink]", + [TYPEC_PORT_SRC] = "dual [source] sink", + [TYPEC_PORT_SNK] = "dual source [sink]", [TYPEC_PORT_DRP] = "[dual] source sink", }; @@ -875,9 +875,7 @@ static ssize_t data_role_store(struct device *dev, return ret; mutex_lock(&port->port_type_lock); - if (port->port_type != TYPEC_PORT_DRP) { - dev_dbg(dev, "port type fixed at \"%s\"", - typec_port_types[port->port_type]); + if (port->cap->data != TYPEC_PORT_DRD) { ret = -EOPNOTSUPP; goto unlock_and_ret; } @@ -897,7 +895,7 @@ static ssize_t data_role_show(struct device *dev, { struct typec_port *port = to_typec_port(dev); - if (port->cap->type == TYPEC_PORT_DRP) + if (port->cap->data == TYPEC_PORT_DRD) return sprintf(buf, "%s\n", port->data_role == TYPEC_HOST ? "[host] device" : "host [device]"); @@ -1328,7 +1326,6 @@ struct typec_port *typec_register_port(struct device *parent, const struct typec_capability *cap) { struct typec_port *port; - int role; int ret; int id; @@ -1354,21 +1351,36 @@ struct typec_port *typec_register_port(struct device *parent, goto err_mux; } - if (cap->type == TYPEC_PORT_DFP) - role = TYPEC_SOURCE; - else if (cap->type == TYPEC_PORT_UFP) - role = TYPEC_SINK; - else - role = cap->prefer_role; - - if (role == TYPEC_SOURCE) { - port->data_role = TYPEC_HOST; + switch (cap->type) { + case TYPEC_PORT_SRC: port->pwr_role = TYPEC_SOURCE; port->vconn_role = TYPEC_SOURCE; - } else { - port->data_role = TYPEC_DEVICE; + break; + case TYPEC_PORT_SNK: port->pwr_role = TYPEC_SINK; port->vconn_role = TYPEC_SINK; + break; + case TYPEC_PORT_DRP: + if (cap->prefer_role != TYPEC_NO_PREFERRED_ROLE) + port->pwr_role = cap->prefer_role; + else + port->pwr_role = TYPEC_SINK; + break; + } + + switch (cap->data) { + case TYPEC_PORT_DFP: + port->data_role = TYPEC_HOST; + break; + case TYPEC_PORT_UFP: + port->data_role = TYPEC_DEVICE; + break; + case TYPEC_PORT_DRD: + if (cap->prefer_role == TYPEC_SOURCE) + port->data_role = TYPEC_HOST; + else + port->data_role = TYPEC_DEVICE; + break; } port->id = id; diff --git a/drivers/usb/typec/fusb302/fusb302.c b/drivers/usb/typec/fusb302/fusb302.c index b267b907bf24..76c9d955fa40 100644 --- a/drivers/usb/typec/fusb302/fusb302.c +++ b/drivers/usb/typec/fusb302/fusb302.c @@ -1230,6 +1230,7 @@ static const struct tcpc_config fusb302_tcpc_config = { .max_snk_mw = 15000, .operating_snk_mw = 2500, .type = TYPEC_PORT_DRP, + .data = TYPEC_PORT_DRD, .default_role = TYPEC_SINK, .alt_modes = NULL, }; diff --git a/drivers/usb/typec/tcpm.c b/drivers/usb/typec/tcpm.c index bfcaf6618a1f..0e1d92381522 100644 --- a/drivers/usb/typec/tcpm.c +++ b/drivers/usb/typec/tcpm.c @@ -350,7 +350,7 @@ static enum tcpm_state tcpm_default_state(struct tcpm_port *port) else if (port->tcpc->config->default_role == TYPEC_SINK) return SNK_UNATTACHED; /* Fall through to return SRC_UNATTACHED */ - } else if (port->port_type == TYPEC_PORT_UFP) { + } else if (port->port_type == TYPEC_PORT_SNK) { return SNK_UNATTACHED; } return SRC_UNATTACHED; @@ -2264,7 +2264,7 @@ static inline enum tcpm_state unattached_state(struct tcpm_port *port) return SRC_UNATTACHED; else return SNK_UNATTACHED; - } else if (port->port_type == TYPEC_PORT_DFP) { + } else if (port->port_type == TYPEC_PORT_SRC) { return SRC_UNATTACHED; } @@ -3554,11 +3554,11 @@ static int tcpm_port_type_set(const struct typec_capability *cap, if (!port->connected) { tcpm_set_state(port, PORT_RESET, 0); - } else if (type == TYPEC_PORT_UFP) { + } else if (type == TYPEC_PORT_SNK) { if (!(port->pwr_role == TYPEC_SINK && port->data_role == TYPEC_DEVICE)) tcpm_set_state(port, PORT_RESET, 0); - } else if (type == TYPEC_PORT_DFP) { + } else if (type == TYPEC_PORT_SRC) { if (!(port->pwr_role == TYPEC_SOURCE && port->data_role == TYPEC_HOST)) tcpm_set_state(port, PORT_RESET, 0); @@ -3748,6 +3748,7 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) port->typec_caps.prefer_role = tcpc->config->default_role; port->typec_caps.type = tcpc->config->type; + port->typec_caps.data = tcpc->config->data; port->typec_caps.revision = 0x0120; /* Type-C spec release 1.2 */ port->typec_caps.pd_revision = 0x0200; /* USB-PD spec release 2.0 */ port->typec_caps.dr_set = tcpm_dr_set; diff --git a/drivers/usb/typec/tps6598x.c b/drivers/usb/typec/tps6598x.c index 37a15c14a6c6..8b8406867c02 100644 --- a/drivers/usb/typec/tps6598x.c +++ b/drivers/usb/typec/tps6598x.c @@ -393,31 +393,39 @@ static int tps6598x_probe(struct i2c_client *client) if (ret < 0) return ret; + tps->typec_cap.revision = USB_TYPEC_REV_1_2; + tps->typec_cap.pd_revision = 0x200; + tps->typec_cap.prefer_role = TYPEC_NO_PREFERRED_ROLE; + tps->typec_cap.pr_set = tps6598x_pr_set; + tps->typec_cap.dr_set = tps6598x_dr_set; + switch (TPS_SYSCONF_PORTINFO(conf)) { case TPS_PORTINFO_SINK_ACCESSORY: case TPS_PORTINFO_SINK: - tps->typec_cap.type = TYPEC_PORT_UFP; + tps->typec_cap.type = TYPEC_PORT_SNK; + tps->typec_cap.data = TYPEC_PORT_UFP; break; case TPS_PORTINFO_DRP_UFP_DRD: case TPS_PORTINFO_DRP_DFP_DRD: - tps->typec_cap.dr_set = tps6598x_dr_set; - /* fall through */ + tps->typec_cap.type = TYPEC_PORT_DRP; + tps->typec_cap.data = TYPEC_PORT_DRD; + break; case TPS_PORTINFO_DRP_UFP: + tps->typec_cap.type = TYPEC_PORT_DRP; + tps->typec_cap.data = TYPEC_PORT_UFP; + break; case TPS_PORTINFO_DRP_DFP: - tps->typec_cap.pr_set = tps6598x_pr_set; tps->typec_cap.type = TYPEC_PORT_DRP; + tps->typec_cap.data = TYPEC_PORT_DFP; break; case TPS_PORTINFO_SOURCE: - tps->typec_cap.type = TYPEC_PORT_DFP; + tps->typec_cap.type = TYPEC_PORT_SRC; + tps->typec_cap.data = TYPEC_PORT_DFP; break; default: return -ENODEV; } - tps->typec_cap.revision = USB_TYPEC_REV_1_2; - tps->typec_cap.pd_revision = 0x200; - tps->typec_cap.prefer_role = TYPEC_NO_PREFERRED_ROLE; - tps->port = typec_register_port(&client->dev, &tps->typec_cap); if (IS_ERR(tps->port)) return PTR_ERR(tps->port); diff --git a/drivers/usb/typec/typec_wcove.c b/drivers/usb/typec/typec_wcove.c index 2e990e0d917d..19cca7f1b2c5 100644 --- a/drivers/usb/typec/typec_wcove.c +++ b/drivers/usb/typec/typec_wcove.c @@ -572,6 +572,7 @@ static struct tcpc_config wcove_typec_config = { .operating_snk_mw = 15000, .type = TYPEC_PORT_DRP, + .data = TYPEC_PORT_DRD, .default_role = TYPEC_SINK, }; diff --git a/drivers/usb/typec/ucsi/ucsi.c b/drivers/usb/typec/ucsi/ucsi.c index 69d544cfcd45..bf0977fbd100 100644 --- a/drivers/usb/typec/ucsi/ucsi.c +++ b/drivers/usb/typec/ucsi/ucsi.c @@ -592,11 +592,18 @@ static int ucsi_register_port(struct ucsi *ucsi, int index) return ret; if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DRP) - cap->type = TYPEC_PORT_DRP; + cap->data = TYPEC_PORT_DRD; else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DFP) - cap->type = TYPEC_PORT_DFP; + cap->data = TYPEC_PORT_DFP; else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_UFP) - cap->type = TYPEC_PORT_UFP; + cap->data = TYPEC_PORT_UFP; + + if (con->cap.provider && con->cap.consumer) + cap->type = TYPEC_PORT_DRP; + else if (con->cap.provider) + cap->type = TYPEC_PORT_SRC; + else if (con->cap.consumer) + cap->type = TYPEC_PORT_SNK; cap->revision = ucsi->cap.typec_version; cap->pd_revision = ucsi->cap.pd_version; diff --git a/include/linux/usb/tcpm.h b/include/linux/usb/tcpm.h index fe3508e6e1df..f0d839daeaea 100644 --- a/include/linux/usb/tcpm.h +++ b/include/linux/usb/tcpm.h @@ -91,6 +91,7 @@ struct tcpc_config { unsigned int operating_snk_mw; enum typec_port_type type; + enum typec_port_data data; enum typec_role default_role; bool try_role_hw; /* try.{src,snk} implemented in hardware */ diff --git a/include/linux/usb/typec.h b/include/linux/usb/typec.h index 2408e5c2ed91..672b39bb0adc 100644 --- a/include/linux/usb/typec.h +++ b/include/linux/usb/typec.h @@ -22,9 +22,15 @@ struct typec_port; struct fwnode_handle; enum typec_port_type { + TYPEC_PORT_SRC, + TYPEC_PORT_SNK, + TYPEC_PORT_DRP, +}; + +enum typec_port_data { TYPEC_PORT_DFP, TYPEC_PORT_UFP, - TYPEC_PORT_DRP, + TYPEC_PORT_DRD, }; enum typec_plug_type { @@ -186,10 +192,11 @@ struct typec_partner_desc { /* * struct typec_capability - USB Type-C Port Capabilities - * @role: DFP (Host-only), UFP (Device-only) or DRP (Dual Role) + * @type: Supported power role of the port + * @data: Supported data role of the port * @revision: USB Type-C Specification release. Binary coded decimal * @pd_revision: USB Power Delivery Specification revision if supported - * @prefer_role: Initial role preference + * @prefer_role: Initial role preference (DRP ports). * @accessory: Supported Accessory Modes * @sw: Cable plug orientation switch * @mux: Multiplexer switch for Alternate/Accessory Modes @@ -205,6 +212,7 @@ struct typec_partner_desc { */ struct typec_capability { enum typec_port_type type; + enum typec_port_data data; u16 revision; /* 0120H = "1.2" */ u16 pd_revision; /* 0300H = "3.0" */ int prefer_role; -- 2.16.1 --opJtzjQTFsWo+cga-- 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: [v2,10/12] dt-bindings: connector: add properties for typec power delivery From: Heikki Krogerus Message-Id: <20180306120202.GA4951@kuha.fi.intel.com> Date: Tue, 6 Mar 2018 14:02:02 +0200 To: Jun Li Cc: Andrzej Hajda , "gregkh@linuxfoundation.org" , "robh+dt@kernel.org" , "linux@roeck-us.net" , "mark.rutland@arm.com" , "yueyao@google.com" , Peter Chen , "garsilva@embeddedor.com" , "o_leveque@orange.fr" , "shufan_lee@richtek.com" , "linux-usb@vger.kernel.org" , "devicetree@vger.kernel.org" , dl-linux-imx List-ID: SGkgZ3V5cywKCk9uIFR1ZSwgTWFyIDA2LCAyMDE4IGF0IDA5OjM4OjU5QU0gKzAwMDAsIEp1biBM aSB3cm90ZToKPiA+ID4+PiBkaWZmIC0tZ2l0Cj4gPiA+Pj4gYS9Eb2N1bWVudGF0aW9uL2Rldmlj ZXRyZWUvYmluZGluZ3MvY29ubmVjdG9yL3VzYi1jb25uZWN0b3IudHh0Cj4gPiA+Pj4gYi9Eb2N1 bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvY29ubmVjdG9yL3VzYi1jb25uZWN0b3IudHh0 Cj4gPiA+Pj4gaW5kZXggZTE0NjNmMS4uMjQyZjZkZiAxMDA2NDQKPiA+ID4+PiAtLS0gYS9Eb2N1 bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvY29ubmVjdG9yL3VzYi1jb25uZWN0b3IudHh0 Cj4gPiA+Pj4gKysrCj4gPiBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9jb25u ZWN0b3IvdXNiLWNvbm5lY3Rvci50eHQKPiA+ID4+PiBAQCAtMTUsNiArMTUsMzAgQEAgT3B0aW9u YWwgcHJvcGVydGllczoKPiA+ID4+PiAgLSB0eXBlOiBzaXplIG9mIHRoZSBjb25uZWN0b3IsIHNo b3VsZCBiZSBzcGVjaWZpZWQgaW4gY2FzZSBvZiBVU0ItQSwKPiA+IFVTQi1CCj4gPiA+Pj4gICAg bm9uLWZ1bGxzaXplIGNvbm5lY3RvcnM6ICJtaW5pIiwgIm1pY3JvIi4KPiA+ID4+Pgo+ID4gPj4+ ICtSZXF1aXJlZCBwcm9wZXJ0aWVzIGZvciB1c2ItYy1jb25uZWN0b3Igd2l0aCBwb3dlciBkZWxp dmVyeSBzdXBwb3J0Ogo+ID4gPj4+ICstIHBvcnQtdHlwZTogc2hvdWxkIGJlIG9uZSBvZiAic291 cmNlIiwgInNpbmsiIG9yICJkdWFsIi4KPiA+ID4+PiArLSBkZWZhdWx0LXJvbGU6IHByZWZlcnJl ZCBwb3dlciByb2xlIGlmIHBvcnQtdHlwZSBpcyAiZHVhbCIoZHJwKSwKPiA+ID4+PiArc2hvdWxk IGJlCj4gPiA+Pj4gKyAgInNpbmsiIG9yICJzb3VyY2UiLgo+ID4gPj4gU2luY2UgcG9ydCBjYXJy aWVzIGRhdGEgYW5kIHBvd2VyLCBpdCB3b3VsZCBiZSBiZXR0ZXIgdG8gZXhwbGljaXRseQo+ID4g Pj4gbWVudGlvbiBpdCBpbiBuYW1lcyBvZiBwcm9wZXJ0aWVzIHdoaWNoIGNhbiBiZSBhbWJpZ3Vv dXMuCj4gPiA+PiBNYXliZSBpbnN0ZWFkIG9mICdwb3J0LXR5cGUnIHlvdSBjYW4gdXNlICdwb3dl ci1yb2xlJywgZm9yIGV4YW1wbGUuCj4gPiA+IFBvcnQtdHlwZSBpcyBhbGlnbiB3aXRoIHRoZSBu YW1lIG9mIHR5cGVjIGNvZGluZyBhbmQgQUJJLCAncG93ZXItcm9sZScKPiA+ID4gaXMgbW9yZSBs aWtlIGZvciB0aGUgY3VycmVudCByb2xlIHJhdGhlciB0aGFuIHRoZSBwb3J0J3MgYWJpbGl0eS4K PiA+IAo+ID4gSSBhbSBub3Qgc3VyZSB3aGF0IGFyZSB5b3UgZXhhY3RseSBtZWFuIGJ5ICJjb2Rp bmcgYW5kIEFCSSIsIGJ1dCBJIGd1ZXNzIGl0IGlzCj4gPiBqdXN0IGFib3V0IFBvd2VyLURlbGl2 ZXJ5IHBhcnQgb2YgVVNCLUMuIEFuZCBpZiB5b3Ugd2FudCB0byBwdXQgdGhpcyBwcm9wZXJ0eQo+ ID4gaW50byBVU0Igbm9kZSB3aXRob3V0IG1hcmsgaXQgaXMgcmVsYXRlZCB0byBQRCBwYXJ0IG9m IFVTQiBjb25uZWN0b3IsIHlvdQo+ID4gcmlzayBjb25mdXNpb24gd2l0aCBwb3NzaWJsZSBVU0Ig ZGF0YSByZWxhdGVkIHByb3BlcnRpZXMuCj4gCj4gVW5kZXJzdG9vZCB5b3VyIGNvbmNlcm4sIEkg YW0gZm9sbG93aW5nIHR5cGVjIG5hbWluZyBjb252ZW50aW9ucywKPiBmb3IgdHlwZWMsIHBvcnQt dHlwZSBwcm9wZXJ0eSBoYXMgdGhlIHNhbWUgbWVhbmluZyBhcwo+IC9zeXMvY2xhc3MvdHlwZWMv cG9ydHgvcG9ydF90eXBlCj4gd2hpY2ggaXMgbm90IG9ubHkgZm9yIHBvd2VyLCBhbHNvIGZvciBk YXRhLCB0aGVyZSBhcmUgZGVkaWNhdGVkCj4gc3lzIGZpbGVzIHBvd2VyX3JvbGUgZm9yIHBvd2Vy IGFuZCBkYXRhX3JvbGUgZm9yIGRhdGEuCj4gCj4gPiBTaW1wbGUgcXVlc3Rpb24sIHdoYXQgaWYg c29tZWJvZHkgd2FudHMgdG8gYWRkIHByb3BlcnR5IGRlc2NyaWJpbmcgVVNCCj4gPiBkYXRhIGNh cGFiaWxpdGllcyAoREZQLCBVRlAsIERSRCksIGhvdyBzaG91bGQgaXQgYmUgbmFtZWQ/Cj4gPiAK PiAKPiBUaGVuIHdlIG1heSB1c2UgZGF0YS1yb2xlPwo+IAo+ID4gPgo+ID4gPj4gT3RoZXIgdGhp bmcgaXMgdGhhdCBkZWZhdWx0LXJvbGUgaXMgcmVxdWlyZWQgb25seSBpbiBjYXNlIG9mIERSUCwg c28KPiA+ID4+IG1heWJlIGJldHRlciB3b3VsZCBiZSB0byBzcXVhc2ggaXQgaW4gcG93ZXItcm9s ZSwgZm9yIGV4YW1wbGU6Cj4gPiA+PiA/Pz8/Pz8gcG93ZXItcm9sZTogc2hvdWxkIGJlIG9uIG9m ICJzb3VyY2UiLCAic2luayIsICJkdWFsLXNvdXJjZSIsCj4gPiA+PiAiZHVhbC1zaW5rIiwgaW4g Y2FzZSBvZiBkdWFsIHJvbGVzIHN1ZmZpeCBkZXRlcm1pbmVzIHByZWZlcnJlZCByb2xlLgo+ID4g PiBJIGRvbid0IGtub3cgaG93IG11Y2ggdGhpcyBzcXVhc2ggY2FuIGJlbmVmaXQsICJkdWFsLXNv dXJjZS9zaW5rIiBpcwo+ID4gPiBub3QgZGlyZWN0bHkgc2hvd2luZyBpdHMgbWVhbmluZyBieSBu YW1lLgo+ID4gCj4gPiBTb21lIGJlbmVmaXQgaXMgc2ltcGxlciBiaW5kaW5nLCBubyBjb25kaXRp b25hbGx5LXJlcXVpcmVkIHByb3BlcnR5Lgo+ID4gCj4gCj4gVGhlcmUgaXMgYWxyZWFkeSBzdHJp bmcgZGVmaW5pdGlvbiBmb3IgcG9ydCB0eXBlIGFuZCBwcmVmZXJyZWQgcm9sZSBwYXJzZSAKPiBz dGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHR5cGVjX3BvcnRfdHlwZXNbXSA9IHsKPiAgICAgICAg ICBbVFlQRUNfUE9SVF9ERlBdID0gInNvdXJjZSIsCj4gICAgICAgICAgW1RZUEVDX1BPUlRfVUZQ XSA9ICJzaW5rIiwKPiAgICAgICAgICBbVFlQRUNfUE9SVF9EUlBdID0gImR1YWwiLAo+IH07Cj4g QW5kIEkgdGhpbmsgdGhlcmUgd2lsbCBiZSBvdGhlciBjb25kaXRpb25hbGx5LXJlcXVpcmVkIHBy b3BlcnRpZXMKPiB0byBiZSBleHRlbmRlZCBsYXRlciwgYXJlIHdlIGdvaW5nIHRvIG5hbWUgYWxs IG9mIHRoZW0gYnkgdGhpcyB3YXk/Cj4gRWl0aGVyIHdheSBpcyBPSyBmb3IgbWUsIEkgYW0gbm90 IHN1cmUgaWYgdGhlcmUgaXMgcHJpbmNpcGxlIGxpa2Ugd2UKPiBzaG91bGQgYXZvaWQgY29uZGl0 aW9uYWxseS1yZXF1aXJlZCBwcm9wZXJ0eSwgaWYgd2Ugc2hvdWxkLCBtYXliZQo+ICJkdWFsLXBy ZWZlcnJlZC1zb3VyY2Uvc2luayIgaXMgYmV0dGVyLgo+IAo+IEhpIEhlaWtraSwKPiBEbyB5b3Ug aGF2ZSBhbnkgY29tbWVudHMvcHJlZmVyZW5jZSBoZXJlPwoKSW4gdGhlIGZpcnN0IHZlcnNpb25z IG9mIFVTQiBUeXBlLUMgc3BlY2lmaWNhdGlvbiB0aGUgZGF0YSBhbmQgcG93ZXIKcm9sZXMgd2Vy ZSBpbiBwcmFjdGljZSBjb3VwbGVkIHRvZ2V0aGVyLiBUaGVyZSB3ZXJlIG5vIGRhdGEgcm9sZQpz cGVjaWZpYyBtb2RlcywganVzdCBERlAsIFVGUCBhbmQgRFJQLiBIb3dldmVyLCB2MS4yIG9mIHRo ZSBzcGVjLgppbnRyb2R1Y2VkIHNlcGFyYXRlIG1vZGVzIGZvciB0aGUgZGF0YSByb2xlcyBhcyB3 ZWxsLCBhbmQgSSBoYXZlIGEKcGF0Y2ggZm9yIHRoYXQgKGF0dGFjaGVkKS4KCklmIHlvdSBhcmUg YXNraW5nIG15IG9waW5pb24sIHRoZSBkYXRhIHJvbGUgbXVzdCBiZSBoYW5kbGVkIGFzCnNlcGFy YXRlIGNhcGFiaWxpdHkgb2YgdGhlIHBvcnQsIGkuZS4geW91IHByb2JhYmxlIHdhbnQgdG8gaGF2 ZQpzZXBhcmF0ZSBwcm9wZXJ0aWVzIGZvciB0aGUgcG93ZXIgcm9sZSBhbmQgZGF0YSByb2xlLCBl dmVuIGlmIHdlIGRpZApub3Qgc3VwcG9ydCB0aGF0IHlldCBpbiB0aGUgY2xhc3MgY29kZS4gRG9u J3QgdXNlICJwb3J0LXR5cGUiIG5hbWUsCmp1c3QgY2FsbCB0aGVtICJwb3dlci1yb2xlIiBhbmQg ImRhdGEtcm9sZSIgZnJvbSBub3cgb24uCgpUaGUgZGVmYXVsdC1yb2xlIHNob3VsZCB0ZWxsIHRo ZSBzdGF0ZSBtYWNoaW5lcyB3aGV0aGVyIFRyeS5TTksgb3IKVHJ5LlNSQyBzdGF0ZXMgc2hvdWxk IGJlIHVzZWQgb3Igbm90LiBQZXJoYXBzIHlvdSBzaG91bGQgaGF2ZSBib29sZWFuCnByb3BlcnR5 IGZvciBib3RoOiAidHJ5LXNuayIgYW5kICJ0cnktc3JjIiAobm90ZTogYm90aCBjYW4gbm90IGJl IHRydWUpLgoKRmluYWwgbm90ZS4gSSB0aGluayBpdCB3b3VsZCBtYWtlIHNlbnNlIHRvIGNsZWFy bHkgc2VwYXJhdGUgdGhlIFVTQgpUeXBlLUMgc3BlY2lmaWMgcHJvcGVydGllcyBmcm9tIFVTQiBQ RCBvbmVzLiBUaG91Z2ggaXQgaXMgdW5saWtlbHkKdGhhdCB3ZSB3aWxsIHNlZSBVU0IgUEQgYmVp bmcgdXNlZCB3aXRoIG90aGVyIGNvbm5lY3RvciB0eXBlcyBiZXNpZGVzClR5cGUtQyBhbnltb3Jl LCBVU0IgVHlwZS1DIGNvbm5lY3RvcnMgd2lsbCBzdGlsbCBkZWZpbml0ZWx5IG5vdAphbHdheXMg c3VwcG9ydCBVU0IgUEQsIGJ1dCB3aGVuIFVTQiBQRCBpcyBub3Qgc3VwcG9ydGVkLCB3ZSBzdGls bCBuZWVkCnRvIGtub3cgdGhlIGRhdGEtcm9sZSwgcG93ZXItcm9sZSwgZGVmYXVsdC1yb2xlIChv ciB0cnktc25rLCB0cnktc3JjKSwKZXRjLgoKCkJyLAoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNi L3R5cGVjL2NsYXNzLmMgYi9kcml2ZXJzL3VzYi90eXBlYy9jbGFzcy5jCmluZGV4IDI2MjBhNjk0 NzA0Zi4uNTNkZjEwZGYyZjlkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi90eXBlYy9jbGFzcy5j CisrKyBiL2RyaXZlcnMvdXNiL3R5cGVjL2NsYXNzLmMKQEAgLTI4MiwxMCArMjgyLDEwIEBAIHR5 cGVjX2FsdG1vZGVfcm9sZXNfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2Vf YXR0cmlidXRlICphdHRyLAogCXNzaXplX3QgcmV0OwogCiAJc3dpdGNoIChtb2RlLT5yb2xlcykg ewotCWNhc2UgVFlQRUNfUE9SVF9ERlA6CisJY2FzZSBUWVBFQ19QT1JUX1NSQzoKIAkJcmV0ID0g c3ByaW50ZihidWYsICJzb3VyY2VcbiIpOwogCQlicmVhazsKLQljYXNlIFRZUEVDX1BPUlRfVUZQ OgorCWNhc2UgVFlQRUNfUE9SVF9TTks6CiAJCXJldCA9IHNwcmludGYoYnVmLCAic2lua1xuIik7 CiAJCWJyZWFrOwogCWNhc2UgVFlQRUNfUE9SVF9EUlA6CkBAIC03OTcsMTQgKzc5NywxNCBAQCBz dGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHR5cGVjX2RhdGFfcm9sZXNbXSA9IHsKIH07CiAKIHN0 YXRpYyBjb25zdCBjaGFyICogY29uc3QgdHlwZWNfcG9ydF90eXBlc1tdID0gewotCVtUWVBFQ19Q T1JUX0RGUF0gPSAic291cmNlIiwKLQlbVFlQRUNfUE9SVF9VRlBdID0gInNpbmsiLAorCVtUWVBF Q19QT1JUX1NSQ10gPSAic291cmNlIiwKKwlbVFlQRUNfUE9SVF9TTktdID0gInNpbmsiLAogCVtU WVBFQ19QT1JUX0RSUF0gPSAiZHVhbCIsCiB9OwogCiBzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0 IHR5cGVjX3BvcnRfdHlwZXNfZHJwW10gPSB7Ci0JW1RZUEVDX1BPUlRfREZQXSA9ICJkdWFsIFtz b3VyY2VdIHNpbmsiLAotCVtUWVBFQ19QT1JUX1VGUF0gPSAiZHVhbCBzb3VyY2UgW3NpbmtdIiwK KwlbVFlQRUNfUE9SVF9TUkNdID0gImR1YWwgW3NvdXJjZV0gc2luayIsCisJW1RZUEVDX1BPUlRf U05LXSA9ICJkdWFsIHNvdXJjZSBbc2lua10iLAogCVtUWVBFQ19QT1JUX0RSUF0gPSAiW2R1YWxd IHNvdXJjZSBzaW5rIiwKIH07CiAKQEAgLTg3NSw5ICs4NzUsNyBAQCBzdGF0aWMgc3NpemVfdCBk YXRhX3JvbGVfc3RvcmUoc3RydWN0IGRldmljZSAqZGV2LAogCQlyZXR1cm4gcmV0OwogCiAJbXV0 ZXhfbG9jaygmcG9ydC0+cG9ydF90eXBlX2xvY2spOwotCWlmIChwb3J0LT5wb3J0X3R5cGUgIT0g VFlQRUNfUE9SVF9EUlApIHsKLQkJZGV2X2RiZyhkZXYsICJwb3J0IHR5cGUgZml4ZWQgYXQgXCIl c1wiIiwKLQkJCSAgICAgdHlwZWNfcG9ydF90eXBlc1twb3J0LT5wb3J0X3R5cGVdKTsKKwlpZiAo cG9ydC0+Y2FwLT5kYXRhICE9IFRZUEVDX1BPUlRfRFJEKSB7CiAJCXJldCA9IC1FT1BOT1RTVVBQ OwogCQlnb3RvIHVubG9ja19hbmRfcmV0OwogCX0KQEAgLTg5Nyw3ICs4OTUsNyBAQCBzdGF0aWMg c3NpemVfdCBkYXRhX3JvbGVfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsCiB7CiAJc3RydWN0IHR5 cGVjX3BvcnQgKnBvcnQgPSB0b190eXBlY19wb3J0KGRldik7CiAKLQlpZiAocG9ydC0+Y2FwLT50 eXBlID09IFRZUEVDX1BPUlRfRFJQKQorCWlmIChwb3J0LT5jYXAtPmRhdGEgPT0gVFlQRUNfUE9S VF9EUkQpCiAJCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVzXG4iLCBwb3J0LT5kYXRhX3JvbGUgPT0g VFlQRUNfSE9TVCA/CiAJCQkgICAgICAgIltob3N0XSBkZXZpY2UiIDogImhvc3QgW2RldmljZV0i KTsKIApAQCAtMTMyOCw3ICsxMzI2LDYgQEAgc3RydWN0IHR5cGVjX3BvcnQgKnR5cGVjX3JlZ2lz dGVyX3BvcnQoc3RydWN0IGRldmljZSAqcGFyZW50LAogCQkJCSAgICAgICBjb25zdCBzdHJ1Y3Qg dHlwZWNfY2FwYWJpbGl0eSAqY2FwKQogewogCXN0cnVjdCB0eXBlY19wb3J0ICpwb3J0OwotCWlu dCByb2xlOwogCWludCByZXQ7CiAJaW50IGlkOwogCkBAIC0xMzU0LDIxICsxMzUxLDM2IEBAIHN0 cnVjdCB0eXBlY19wb3J0ICp0eXBlY19yZWdpc3Rlcl9wb3J0KHN0cnVjdCBkZXZpY2UgKnBhcmVu dCwKIAkJZ290byBlcnJfbXV4OwogCX0KIAotCWlmIChjYXAtPnR5cGUgPT0gVFlQRUNfUE9SVF9E RlApCi0JCXJvbGUgPSBUWVBFQ19TT1VSQ0U7Ci0JZWxzZSBpZiAoY2FwLT50eXBlID09IFRZUEVD X1BPUlRfVUZQKQotCQlyb2xlID0gVFlQRUNfU0lOSzsKLQllbHNlCi0JCXJvbGUgPSBjYXAtPnBy ZWZlcl9yb2xlOwotCi0JaWYgKHJvbGUgPT0gVFlQRUNfU09VUkNFKSB7Ci0JCXBvcnQtPmRhdGFf cm9sZSA9IFRZUEVDX0hPU1Q7CisJc3dpdGNoIChjYXAtPnR5cGUpIHsKKwljYXNlIFRZUEVDX1BP UlRfU1JDOgogCQlwb3J0LT5wd3Jfcm9sZSA9IFRZUEVDX1NPVVJDRTsKIAkJcG9ydC0+dmNvbm5f cm9sZSA9IFRZUEVDX1NPVVJDRTsKLQl9IGVsc2UgewotCQlwb3J0LT5kYXRhX3JvbGUgPSBUWVBF Q19ERVZJQ0U7CisJCWJyZWFrOworCWNhc2UgVFlQRUNfUE9SVF9TTks6CiAJCXBvcnQtPnB3cl9y b2xlID0gVFlQRUNfU0lOSzsKIAkJcG9ydC0+dmNvbm5fcm9sZSA9IFRZUEVDX1NJTks7CisJCWJy ZWFrOworCWNhc2UgVFlQRUNfUE9SVF9EUlA6CisJCWlmIChjYXAtPnByZWZlcl9yb2xlICE9IFRZ UEVDX05PX1BSRUZFUlJFRF9ST0xFKQorCQkJcG9ydC0+cHdyX3JvbGUgPSBjYXAtPnByZWZlcl9y b2xlOworCQllbHNlCisJCQlwb3J0LT5wd3Jfcm9sZSA9IFRZUEVDX1NJTks7CisJCWJyZWFrOwor CX0KKworCXN3aXRjaCAoY2FwLT5kYXRhKSB7CisJY2FzZSBUWVBFQ19QT1JUX0RGUDoKKwkJcG9y dC0+ZGF0YV9yb2xlID0gVFlQRUNfSE9TVDsKKwkJYnJlYWs7CisJY2FzZSBUWVBFQ19QT1JUX1VG UDoKKwkJcG9ydC0+ZGF0YV9yb2xlID0gVFlQRUNfREVWSUNFOworCQlicmVhazsKKwljYXNlIFRZ UEVDX1BPUlRfRFJEOgorCQlpZiAoY2FwLT5wcmVmZXJfcm9sZSA9PSBUWVBFQ19TT1VSQ0UpCisJ CQlwb3J0LT5kYXRhX3JvbGUgPSBUWVBFQ19IT1NUOworCQllbHNlCisJCQlwb3J0LT5kYXRhX3Jv bGUgPSBUWVBFQ19ERVZJQ0U7CisJCWJyZWFrOwogCX0KIAogCXBvcnQtPmlkID0gaWQ7CmRpZmYg LS1naXQgYS9kcml2ZXJzL3VzYi90eXBlYy9mdXNiMzAyL2Z1c2IzMDIuYyBiL2RyaXZlcnMvdXNi L3R5cGVjL2Z1c2IzMDIvZnVzYjMwMi5jCmluZGV4IGIyNjdiOTA3YmYyNC4uNzZjOWQ5NTVmYTQw IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi90eXBlYy9mdXNiMzAyL2Z1c2IzMDIuYworKysgYi9k cml2ZXJzL3VzYi90eXBlYy9mdXNiMzAyL2Z1c2IzMDIuYwpAQCAtMTIzMCw2ICsxMjMwLDcgQEAg c3RhdGljIGNvbnN0IHN0cnVjdCB0Y3BjX2NvbmZpZyBmdXNiMzAyX3RjcGNfY29uZmlnID0gewog CS5tYXhfc25rX213ID0gMTUwMDAsCiAJLm9wZXJhdGluZ19zbmtfbXcgPSAyNTAwLAogCS50eXBl ID0gVFlQRUNfUE9SVF9EUlAsCisJLmRhdGEgPSBUWVBFQ19QT1JUX0RSRCwKIAkuZGVmYXVsdF9y b2xlID0gVFlQRUNfU0lOSywKIAkuYWx0X21vZGVzID0gTlVMTCwKIH07CmRpZmYgLS1naXQgYS9k cml2ZXJzL3VzYi90eXBlYy90Y3BtLmMgYi9kcml2ZXJzL3VzYi90eXBlYy90Y3BtLmMKaW5kZXgg YmZjYWY2NjE4YTFmLi4wZTFkOTIzODE1MjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3R5cGVj L3RjcG0uYworKysgYi9kcml2ZXJzL3VzYi90eXBlYy90Y3BtLmMKQEAgLTM1MCw3ICszNTAsNyBA QCBzdGF0aWMgZW51bSB0Y3BtX3N0YXRlIHRjcG1fZGVmYXVsdF9zdGF0ZShzdHJ1Y3QgdGNwbV9w b3J0ICpwb3J0KQogCQllbHNlIGlmIChwb3J0LT50Y3BjLT5jb25maWctPmRlZmF1bHRfcm9sZSA9 PSBUWVBFQ19TSU5LKQogCQkJcmV0dXJuIFNOS19VTkFUVEFDSEVEOwogCQkvKiBGYWxsIHRocm91 Z2ggdG8gcmV0dXJuIFNSQ19VTkFUVEFDSEVEICovCi0JfSBlbHNlIGlmIChwb3J0LT5wb3J0X3R5 cGUgPT0gVFlQRUNfUE9SVF9VRlApIHsKKwl9IGVsc2UgaWYgKHBvcnQtPnBvcnRfdHlwZSA9PSBU WVBFQ19QT1JUX1NOSykgewogCQlyZXR1cm4gU05LX1VOQVRUQUNIRUQ7CiAJfQogCXJldHVybiBT UkNfVU5BVFRBQ0hFRDsKQEAgLTIyNjQsNyArMjI2NCw3IEBAIHN0YXRpYyBpbmxpbmUgZW51bSB0 Y3BtX3N0YXRlIHVuYXR0YWNoZWRfc3RhdGUoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCkKIAkJCXJl dHVybiBTUkNfVU5BVFRBQ0hFRDsKIAkJZWxzZQogCQkJcmV0dXJuIFNOS19VTkFUVEFDSEVEOwot CX0gZWxzZSBpZiAocG9ydC0+cG9ydF90eXBlID09IFRZUEVDX1BPUlRfREZQKSB7CisJfSBlbHNl IGlmIChwb3J0LT5wb3J0X3R5cGUgPT0gVFlQRUNfUE9SVF9TUkMpIHsKIAkJcmV0dXJuIFNSQ19V TkFUVEFDSEVEOwogCX0KIApAQCAtMzU1NCwxMSArMzU1NCwxMSBAQCBzdGF0aWMgaW50IHRjcG1f cG9ydF90eXBlX3NldChjb25zdCBzdHJ1Y3QgdHlwZWNfY2FwYWJpbGl0eSAqY2FwLAogCiAJaWYg KCFwb3J0LT5jb25uZWN0ZWQpIHsKIAkJdGNwbV9zZXRfc3RhdGUocG9ydCwgUE9SVF9SRVNFVCwg MCk7Ci0JfSBlbHNlIGlmICh0eXBlID09IFRZUEVDX1BPUlRfVUZQKSB7CisJfSBlbHNlIGlmICh0 eXBlID09IFRZUEVDX1BPUlRfU05LKSB7CiAJCWlmICghKHBvcnQtPnB3cl9yb2xlID09IFRZUEVD X1NJTksgJiYKIAkJICAgICAgcG9ydC0+ZGF0YV9yb2xlID09IFRZUEVDX0RFVklDRSkpCiAJCQl0 Y3BtX3NldF9zdGF0ZShwb3J0LCBQT1JUX1JFU0VULCAwKTsKLQl9IGVsc2UgaWYgKHR5cGUgPT0g VFlQRUNfUE9SVF9ERlApIHsKKwl9IGVsc2UgaWYgKHR5cGUgPT0gVFlQRUNfUE9SVF9TUkMpIHsK IAkJaWYgKCEocG9ydC0+cHdyX3JvbGUgPT0gVFlQRUNfU09VUkNFICYmCiAJCSAgICAgIHBvcnQt PmRhdGFfcm9sZSA9PSBUWVBFQ19IT1NUKSkKIAkJCXRjcG1fc2V0X3N0YXRlKHBvcnQsIFBPUlRf UkVTRVQsIDApOwpAQCAtMzc0OCw2ICszNzQ4LDcgQEAgc3RydWN0IHRjcG1fcG9ydCAqdGNwbV9y ZWdpc3Rlcl9wb3J0KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHRjcGNfZGV2ICp0Y3BjKQog CiAJcG9ydC0+dHlwZWNfY2Fwcy5wcmVmZXJfcm9sZSA9IHRjcGMtPmNvbmZpZy0+ZGVmYXVsdF9y b2xlOwogCXBvcnQtPnR5cGVjX2NhcHMudHlwZSA9IHRjcGMtPmNvbmZpZy0+dHlwZTsKKwlwb3J0 LT50eXBlY19jYXBzLmRhdGEgPSB0Y3BjLT5jb25maWctPmRhdGE7CiAJcG9ydC0+dHlwZWNfY2Fw cy5yZXZpc2lvbiA9IDB4MDEyMDsJLyogVHlwZS1DIHNwZWMgcmVsZWFzZSAxLjIgKi8KIAlwb3J0 LT50eXBlY19jYXBzLnBkX3JldmlzaW9uID0gMHgwMjAwOwkvKiBVU0ItUEQgc3BlYyByZWxlYXNl IDIuMCAqLwogCXBvcnQtPnR5cGVjX2NhcHMuZHJfc2V0ID0gdGNwbV9kcl9zZXQ7CmRpZmYgLS1n aXQgYS9kcml2ZXJzL3VzYi90eXBlYy90cHM2NTk4eC5jIGIvZHJpdmVycy91c2IvdHlwZWMvdHBz NjU5OHguYwppbmRleCAzN2ExNWMxNGE2YzYuLjhiODQwNjg2N2MwMiAxMDA2NDQKLS0tIGEvZHJp dmVycy91c2IvdHlwZWMvdHBzNjU5OHguYworKysgYi9kcml2ZXJzL3VzYi90eXBlYy90cHM2NTk4 eC5jCkBAIC0zOTMsMzEgKzM5MywzOSBAQCBzdGF0aWMgaW50IHRwczY1OTh4X3Byb2JlKHN0cnVj dCBpMmNfY2xpZW50ICpjbGllbnQpCiAJaWYgKHJldCA8IDApCiAJCXJldHVybiByZXQ7CiAKKwl0 cHMtPnR5cGVjX2NhcC5yZXZpc2lvbiA9IFVTQl9UWVBFQ19SRVZfMV8yOworCXRwcy0+dHlwZWNf Y2FwLnBkX3JldmlzaW9uID0gMHgyMDA7CisJdHBzLT50eXBlY19jYXAucHJlZmVyX3JvbGUgPSBU WVBFQ19OT19QUkVGRVJSRURfUk9MRTsKKwl0cHMtPnR5cGVjX2NhcC5wcl9zZXQgPSB0cHM2NTk4 eF9wcl9zZXQ7CisJdHBzLT50eXBlY19jYXAuZHJfc2V0ID0gdHBzNjU5OHhfZHJfc2V0OworCiAJ c3dpdGNoIChUUFNfU1lTQ09ORl9QT1JUSU5GTyhjb25mKSkgewogCWNhc2UgVFBTX1BPUlRJTkZP X1NJTktfQUNDRVNTT1JZOgogCWNhc2UgVFBTX1BPUlRJTkZPX1NJTks6Ci0JCXRwcy0+dHlwZWNf Y2FwLnR5cGUgPSBUWVBFQ19QT1JUX1VGUDsKKwkJdHBzLT50eXBlY19jYXAudHlwZSA9IFRZUEVD X1BPUlRfU05LOworCQl0cHMtPnR5cGVjX2NhcC5kYXRhID0gVFlQRUNfUE9SVF9VRlA7CiAJCWJy ZWFrOwogCWNhc2UgVFBTX1BPUlRJTkZPX0RSUF9VRlBfRFJEOgogCWNhc2UgVFBTX1BPUlRJTkZP X0RSUF9ERlBfRFJEOgotCQl0cHMtPnR5cGVjX2NhcC5kcl9zZXQgPSB0cHM2NTk4eF9kcl9zZXQ7 Ci0JCS8qIGZhbGwgdGhyb3VnaCAqLworCQl0cHMtPnR5cGVjX2NhcC50eXBlID0gVFlQRUNfUE9S VF9EUlA7CisJCXRwcy0+dHlwZWNfY2FwLmRhdGEgPSBUWVBFQ19QT1JUX0RSRDsKKwkJYnJlYWs7 CiAJY2FzZSBUUFNfUE9SVElORk9fRFJQX1VGUDoKKwkJdHBzLT50eXBlY19jYXAudHlwZSA9IFRZ UEVDX1BPUlRfRFJQOworCQl0cHMtPnR5cGVjX2NhcC5kYXRhID0gVFlQRUNfUE9SVF9VRlA7CisJ CWJyZWFrOwogCWNhc2UgVFBTX1BPUlRJTkZPX0RSUF9ERlA6Ci0JCXRwcy0+dHlwZWNfY2FwLnBy X3NldCA9IHRwczY1OTh4X3ByX3NldDsKIAkJdHBzLT50eXBlY19jYXAudHlwZSA9IFRZUEVDX1BP UlRfRFJQOworCQl0cHMtPnR5cGVjX2NhcC5kYXRhID0gVFlQRUNfUE9SVF9ERlA7CiAJCWJyZWFr OwogCWNhc2UgVFBTX1BPUlRJTkZPX1NPVVJDRToKLQkJdHBzLT50eXBlY19jYXAudHlwZSA9IFRZ UEVDX1BPUlRfREZQOworCQl0cHMtPnR5cGVjX2NhcC50eXBlID0gVFlQRUNfUE9SVF9TUkM7CisJ CXRwcy0+dHlwZWNfY2FwLmRhdGEgPSBUWVBFQ19QT1JUX0RGUDsKIAkJYnJlYWs7CiAJZGVmYXVs dDoKIAkJcmV0dXJuIC1FTk9ERVY7CiAJfQogCi0JdHBzLT50eXBlY19jYXAucmV2aXNpb24gPSBV U0JfVFlQRUNfUkVWXzFfMjsKLQl0cHMtPnR5cGVjX2NhcC5wZF9yZXZpc2lvbiA9IDB4MjAwOwot CXRwcy0+dHlwZWNfY2FwLnByZWZlcl9yb2xlID0gVFlQRUNfTk9fUFJFRkVSUkVEX1JPTEU7Ci0K IAl0cHMtPnBvcnQgPSB0eXBlY19yZWdpc3Rlcl9wb3J0KCZjbGllbnQtPmRldiwgJnRwcy0+dHlw ZWNfY2FwKTsKIAlpZiAoSVNfRVJSKHRwcy0+cG9ydCkpCiAJCXJldHVybiBQVFJfRVJSKHRwcy0+ cG9ydCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi90eXBlYy90eXBlY193Y292ZS5jIGIvZHJp dmVycy91c2IvdHlwZWMvdHlwZWNfd2NvdmUuYwppbmRleCAyZTk5MGUwZDkxN2QuLjE5Y2NhN2Yx YjJjNSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvdHlwZWMvdHlwZWNfd2NvdmUuYworKysgYi9k cml2ZXJzL3VzYi90eXBlYy90eXBlY193Y292ZS5jCkBAIC01NzIsNiArNTcyLDcgQEAgc3RhdGlj IHN0cnVjdCB0Y3BjX2NvbmZpZyB3Y292ZV90eXBlY19jb25maWcgPSB7CiAJLm9wZXJhdGluZ19z bmtfbXcgPSAxNTAwMCwKIAogCS50eXBlID0gVFlQRUNfUE9SVF9EUlAsCisJLmRhdGEgPSBUWVBF Q19QT1JUX0RSRCwKIAkuZGVmYXVsdF9yb2xlID0gVFlQRUNfU0lOSywKIH07CiAKZGlmZiAtLWdp dCBhL2RyaXZlcnMvdXNiL3R5cGVjL3Vjc2kvdWNzaS5jIGIvZHJpdmVycy91c2IvdHlwZWMvdWNz aS91Y3NpLmMKaW5kZXggNjlkNTQ0Y2ZjZDQ1Li5iZjA5NzdmYmQxMDAgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvdXNiL3R5cGVjL3Vjc2kvdWNzaS5jCisrKyBiL2RyaXZlcnMvdXNiL3R5cGVjL3Vjc2kv dWNzaS5jCkBAIC01OTIsMTEgKzU5MiwxOCBAQCBzdGF0aWMgaW50IHVjc2lfcmVnaXN0ZXJfcG9y dChzdHJ1Y3QgdWNzaSAqdWNzaSwgaW50IGluZGV4KQogCQlyZXR1cm4gcmV0OwogCiAJaWYgKGNv bi0+Y2FwLm9wX21vZGUgJiBVQ1NJX0NPTkNBUF9PUE1PREVfRFJQKQotCQljYXAtPnR5cGUgPSBU WVBFQ19QT1JUX0RSUDsKKwkJY2FwLT5kYXRhID0gVFlQRUNfUE9SVF9EUkQ7CiAJZWxzZSBpZiAo Y29uLT5jYXAub3BfbW9kZSAmIFVDU0lfQ09OQ0FQX09QTU9ERV9ERlApCi0JCWNhcC0+dHlwZSA9 IFRZUEVDX1BPUlRfREZQOworCQljYXAtPmRhdGEgPSBUWVBFQ19QT1JUX0RGUDsKIAllbHNlIGlm IChjb24tPmNhcC5vcF9tb2RlICYgVUNTSV9DT05DQVBfT1BNT0RFX1VGUCkKLQkJY2FwLT50eXBl ID0gVFlQRUNfUE9SVF9VRlA7CisJCWNhcC0+ZGF0YSA9IFRZUEVDX1BPUlRfVUZQOworCisJaWYg KGNvbi0+Y2FwLnByb3ZpZGVyICYmIGNvbi0+Y2FwLmNvbnN1bWVyKQorCQljYXAtPnR5cGUgPSBU WVBFQ19QT1JUX0RSUDsKKwllbHNlIGlmIChjb24tPmNhcC5wcm92aWRlcikKKwkJY2FwLT50eXBl ID0gVFlQRUNfUE9SVF9TUkM7CisJZWxzZSBpZiAoY29uLT5jYXAuY29uc3VtZXIpCisJCWNhcC0+ dHlwZSA9IFRZUEVDX1BPUlRfU05LOwogCiAJY2FwLT5yZXZpc2lvbiA9IHVjc2ktPmNhcC50eXBl Y192ZXJzaW9uOwogCWNhcC0+cGRfcmV2aXNpb24gPSB1Y3NpLT5jYXAucGRfdmVyc2lvbjsKZGlm ZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdXNiL3RjcG0uaCBiL2luY2x1ZGUvbGludXgvdXNiL3Rj cG0uaAppbmRleCBmZTM1MDhlNmUxZGYuLmYwZDgzOWRhZWFlYSAxMDA2NDQKLS0tIGEvaW5jbHVk ZS9saW51eC91c2IvdGNwbS5oCisrKyBiL2luY2x1ZGUvbGludXgvdXNiL3RjcG0uaApAQCAtOTEs NiArOTEsNyBAQCBzdHJ1Y3QgdGNwY19jb25maWcgewogCXVuc2lnbmVkIGludCBvcGVyYXRpbmdf c25rX213OwogCiAJZW51bSB0eXBlY19wb3J0X3R5cGUgdHlwZTsKKwllbnVtIHR5cGVjX3BvcnRf ZGF0YSBkYXRhOwogCWVudW0gdHlwZWNfcm9sZSBkZWZhdWx0X3JvbGU7CiAJYm9vbCB0cnlfcm9s ZV9odzsJLyogdHJ5LntzcmMsc25rfSBpbXBsZW1lbnRlZCBpbiBoYXJkd2FyZSAqLwogCmRpZmYg LS1naXQgYS9pbmNsdWRlL2xpbnV4L3VzYi90eXBlYy5oIGIvaW5jbHVkZS9saW51eC91c2IvdHlw ZWMuaAppbmRleCAyNDA4ZTVjMmVkOTEuLjY3MmIzOWJiMGFkYyAxMDA2NDQKLS0tIGEvaW5jbHVk ZS9saW51eC91c2IvdHlwZWMuaAorKysgYi9pbmNsdWRlL2xpbnV4L3VzYi90eXBlYy5oCkBAIC0y Miw5ICsyMiwxNSBAQCBzdHJ1Y3QgdHlwZWNfcG9ydDsKIHN0cnVjdCBmd25vZGVfaGFuZGxlOwog CiBlbnVtIHR5cGVjX3BvcnRfdHlwZSB7CisJVFlQRUNfUE9SVF9TUkMsCisJVFlQRUNfUE9SVF9T TkssCisJVFlQRUNfUE9SVF9EUlAsCit9OworCitlbnVtIHR5cGVjX3BvcnRfZGF0YSB7CiAJVFlQ RUNfUE9SVF9ERlAsCiAJVFlQRUNfUE9SVF9VRlAsCi0JVFlQRUNfUE9SVF9EUlAsCisJVFlQRUNf UE9SVF9EUkQsCiB9OwogCiBlbnVtIHR5cGVjX3BsdWdfdHlwZSB7CkBAIC0xODYsMTAgKzE5Miwx MSBAQCBzdHJ1Y3QgdHlwZWNfcGFydG5lcl9kZXNjIHsKIAogLyoKICAqIHN0cnVjdCB0eXBlY19j YXBhYmlsaXR5IC0gVVNCIFR5cGUtQyBQb3J0IENhcGFiaWxpdGllcwotICogQHJvbGU6IERGUCAo SG9zdC1vbmx5KSwgVUZQIChEZXZpY2Utb25seSkgb3IgRFJQIChEdWFsIFJvbGUpCisgKiBAdHlw ZTogU3VwcG9ydGVkIHBvd2VyIHJvbGUgb2YgdGhlIHBvcnQKKyAqIEBkYXRhOiBTdXBwb3J0ZWQg ZGF0YSByb2xlIG9mIHRoZSBwb3J0CiAgKiBAcmV2aXNpb246IFVTQiBUeXBlLUMgU3BlY2lmaWNh dGlvbiByZWxlYXNlLiBCaW5hcnkgY29kZWQgZGVjaW1hbAogICogQHBkX3JldmlzaW9uOiBVU0Ig UG93ZXIgRGVsaXZlcnkgU3BlY2lmaWNhdGlvbiByZXZpc2lvbiBpZiBzdXBwb3J0ZWQKLSAqIEBw cmVmZXJfcm9sZTogSW5pdGlhbCByb2xlIHByZWZlcmVuY2UKKyAqIEBwcmVmZXJfcm9sZTogSW5p dGlhbCByb2xlIHByZWZlcmVuY2UgKERSUCBwb3J0cykuCiAgKiBAYWNjZXNzb3J5OiBTdXBwb3J0 ZWQgQWNjZXNzb3J5IE1vZGVzCiAgKiBAc3c6IENhYmxlIHBsdWcgb3JpZW50YXRpb24gc3dpdGNo CiAgKiBAbXV4OiBNdWx0aXBsZXhlciBzd2l0Y2ggZm9yIEFsdGVybmF0ZS9BY2Nlc3NvcnkgTW9k ZXMKQEAgLTIwNSw2ICsyMTIsNyBAQCBzdHJ1Y3QgdHlwZWNfcGFydG5lcl9kZXNjIHsKICAqLwog c3RydWN0IHR5cGVjX2NhcGFiaWxpdHkgewogCWVudW0gdHlwZWNfcG9ydF90eXBlCXR5cGU7CisJ ZW51bSB0eXBlY19wb3J0X2RhdGEJZGF0YTsKIAl1MTYJCQlyZXZpc2lvbjsgLyogMDEyMEggPSAi MS4yIiAqLwogCXUxNgkJCXBkX3JldmlzaW9uOyAvKiAwMzAwSCA9ICIzLjAiICovCiAJaW50CQkJ cHJlZmVyX3JvbGU7Cg==