From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Google-Smtp-Source: AG47ELswbJZxVTUQr2E1Cj0QG9xF5hWdmhoU3BO88Xz+nURkcFFfLibRdoIcLX9ACtksrtZDvzkZ ARC-Seal: i=1; a=rsa-sha256; t=1519830488; cv=none; d=google.com; s=arc-20160816; b=DPlWs3aI6c5zQmvZSNiLwBcVv4hibbYQ/0i92IAFsuQrjgy7M52Hk+GVJFYABKVukw aadU6Y1ZVzxFxCeSvSbij9e9MGNFODJ9KHoz7J5eEBLUuI3pykdVWa8FhfHxOPvr2g18 19VGgZzt+aoQKVlKPqTsXTMayK9+IucT5UHETVPV58ux9abnz7Wp6ZRsl7P1wLRgBy+z L3eq4gio3/N8rZ2zQR8JOwSocAGinGPhWJB8aBTBA1F3X6ik4j/PoFQtZrPT5p0NpcGk 9DkujlzvGKKyIpaklrbWpGfywOMci8oHEQZdceSrJ/hgq4iU+fBGdxuQM9kgijv+5EOE 8MQQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :arc-authentication-results; bh=gZebkKycGcunNzCAZKgdO5HoudSFuLVfYQLO8Whu+Ho=; b=TRC+xDJ3sr+8aGFEX/4pb9OdJri0t8VbUvdeM9kT2/n1b9PcKiknFXsRHaO83dol3z upVS4WHjF8guefJ5P53uqx8WJoQoLpv7heKHdm23g24z42oMO4ETBnXzXz2coPKo9A/3 rCIXUGVMKiPjhb2dOdQxA+4SQhAX1gb05hBLMLIcl4tPIeuqBPnVAQJOhWihhICN/z6J 7mePQnAu8f9Z9KrWxmDzV7aLMx5vOBAuMPXlhGVxoxY6HmxpaMZglJaEnfYUksU4VC9h r5cyfRVPct0T9RxYSkaDCpxGEn/2kLOjapgoUMwpzNL9y/xmn9Lh6XIzsFMQ96zh6kug hbIw== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of hdegoede@redhat.com designates 66.187.233.73 as permitted sender) smtp.mailfrom=hdegoede@redhat.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com Authentication-Results: mx.google.com; spf=pass (google.com: domain of hdegoede@redhat.com designates 66.187.233.73 as permitted sender) smtp.mailfrom=hdegoede@redhat.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com From: Hans de Goede To: Darren Hart , Andy Shevchenko , MyungJoo Ham , Chanwoo Choi , Mathias Nyman , Heikki Krogerus , Greg Kroah-Hartman , Guenter Roeck Cc: Hans de Goede , platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org Subject: [PATCH v5 06/12] usb: typec: tcpm: Use new Type-C switch/mux and usb-role-switch functions Date: Wed, 28 Feb 2018 16:07:43 +0100 Message-Id: <20180228150749.26831-7-hdegoede@redhat.com> In-Reply-To: <20180228150749.26831-1-hdegoede@redhat.com> References: <20180228150749.26831-1-hdegoede@redhat.com> X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: =?utf-8?q?1593657774131363188?= X-GMAIL-MSGID: =?utf-8?q?1593657774131363188?= X-Mailing-List: linux-kernel@vger.kernel.org List-ID: Remove the unused (not implemented anywhere) tcpc_mux_dev abstraction and replace it with calling the new typec_set_orientation, usb_role_switch_set and typec_set_mode functions. Reviewed-by: Heikki Krogerus Reviewed-by: Guenter Roeck Reviewed-by: Andy Shevchenko Signed-off-by: Hans de Goede --- Changes in v4: -Add Andy's Reviewed-by Changes in v3: -Add Guenter's Reviewed-by Changes in v2: -Added Heikki's Reviewed-by --- drivers/usb/typec/Kconfig | 1 + drivers/usb/typec/fusb302/fusb302.c | 1 - drivers/usb/typec/tcpm.c | 46 ++++++++++++++++++++++++++++--------- include/linux/usb/tcpm.h | 10 -------- 4 files changed, 36 insertions(+), 22 deletions(-) diff --git a/drivers/usb/typec/Kconfig b/drivers/usb/typec/Kconfig index bcb2744c5977..a2a0684e7c82 100644 --- a/drivers/usb/typec/Kconfig +++ b/drivers/usb/typec/Kconfig @@ -48,6 +48,7 @@ if TYPEC config TYPEC_TCPM tristate "USB Type-C Port Controller Manager" depends on USB + select USB_ROLE_SWITCH help The Type-C Port Controller Manager provides a USB PD and USB Type-C state machine for use with Type-C Port Controllers. diff --git a/drivers/usb/typec/fusb302/fusb302.c b/drivers/usb/typec/fusb302/fusb302.c index dcd8ef085b30..a7b06053a538 100644 --- a/drivers/usb/typec/fusb302/fusb302.c +++ b/drivers/usb/typec/fusb302/fusb302.c @@ -1249,7 +1249,6 @@ static void init_tcpc_dev(struct tcpc_dev *fusb302_tcpc_dev) fusb302_tcpc_dev->set_roles = tcpm_set_roles; fusb302_tcpc_dev->start_drp_toggling = tcpm_start_drp_toggling; fusb302_tcpc_dev->pd_transmit = tcpm_pd_transmit; - fusb302_tcpc_dev->mux = NULL; } static const char * const cc_polarity_name[] = { diff --git a/drivers/usb/typec/tcpm.c b/drivers/usb/typec/tcpm.c index 00ca2822432f..bfcaf6618a1f 100644 --- a/drivers/usb/typec/tcpm.c +++ b/drivers/usb/typec/tcpm.c @@ -20,6 +20,7 @@ #include #include #include +#include #include #include #include @@ -176,6 +177,7 @@ struct tcpm_port { struct typec_port *typec_port; struct tcpc_dev *tcpc; + struct usb_role_switch *role_sw; enum typec_role vconn_role; enum typec_role pwr_role; @@ -618,18 +620,25 @@ void tcpm_pd_transmit_complete(struct tcpm_port *port, EXPORT_SYMBOL_GPL(tcpm_pd_transmit_complete); static int tcpm_mux_set(struct tcpm_port *port, enum tcpc_mux_mode mode, - enum usb_role usb_role) + enum usb_role usb_role, + enum typec_orientation orientation) { - int ret = 0; + int ret; - tcpm_log(port, "Requesting mux mode %d, usb-role %d, polarity %d", - mode, usb_role, port->polarity); + tcpm_log(port, "Requesting mux mode %d, usb-role %d, orientation %d", + mode, usb_role, orientation); - if (port->tcpc->mux) - ret = port->tcpc->mux->set(port->tcpc->mux, mode, usb_role, - port->polarity); + ret = typec_set_orientation(port->typec_port, orientation); + if (ret) + return ret; - return ret; + if (port->role_sw) { + ret = usb_role_switch_set_role(port->role_sw, usb_role); + if (ret) + return ret; + } + + return typec_set_mode(port->typec_port, mode); } static int tcpm_set_polarity(struct tcpm_port *port, @@ -742,15 +751,21 @@ static int tcpm_set_attached_state(struct tcpm_port *port, bool attached) static int tcpm_set_roles(struct tcpm_port *port, bool attached, enum typec_role role, enum typec_data_role data) { + enum typec_orientation orientation; enum usb_role usb_role; int ret; + if (port->polarity == TYPEC_POLARITY_CC1) + orientation = TYPEC_ORIENTATION_NORMAL; + else + orientation = TYPEC_ORIENTATION_REVERSE; + if (data == TYPEC_HOST) usb_role = USB_ROLE_HOST; else usb_role = USB_ROLE_DEVICE; - ret = tcpm_mux_set(port, TYPEC_MUX_USB, usb_role); + ret = tcpm_mux_set(port, TYPEC_MUX_USB, usb_role, orientation); if (ret < 0) return ret; @@ -2097,7 +2112,8 @@ static int tcpm_src_attach(struct tcpm_port *port) out_disable_pd: port->tcpc->set_pd_rx(port->tcpc, false); out_disable_mux: - tcpm_mux_set(port, TYPEC_MUX_NONE, USB_ROLE_NONE); + tcpm_mux_set(port, TYPEC_MUX_NONE, USB_ROLE_NONE, + TYPEC_ORIENTATION_NONE); return ret; } @@ -2141,7 +2157,8 @@ static void tcpm_reset_port(struct tcpm_port *port) tcpm_init_vconn(port); tcpm_set_current_limit(port, 0, 0); tcpm_set_polarity(port, TYPEC_POLARITY_CC1); - tcpm_mux_set(port, TYPEC_MUX_NONE, USB_ROLE_NONE); + tcpm_mux_set(port, TYPEC_MUX_NONE, USB_ROLE_NONE, + TYPEC_ORIENTATION_NONE); tcpm_set_attached_state(port, false); port->try_src_count = 0; port->try_snk_count = 0; @@ -3742,6 +3759,12 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) port->partner_desc.identity = &port->partner_ident; port->port_type = tcpc->config->type; + port->role_sw = usb_role_switch_get(port->dev); + if (IS_ERR(port->role_sw)) { + err = PTR_ERR(port->role_sw); + goto out_destroy_wq; + } + port->typec_port = typec_register_port(port->dev, &port->typec_caps); if (IS_ERR(port->typec_port)) { err = PTR_ERR(port->typec_port); @@ -3777,6 +3800,7 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) return port; out_destroy_wq: + usb_role_switch_put(port->role_sw); destroy_workqueue(port->wq); return ERR_PTR(err); } diff --git a/include/linux/usb/tcpm.h b/include/linux/usb/tcpm.h index 268721bff2c1..fe3508e6e1df 100644 --- a/include/linux/usb/tcpm.h +++ b/include/linux/usb/tcpm.h @@ -16,7 +16,6 @@ #define __LINUX_USB_TCPM_H #include -#include #include #include "pd.h" @@ -112,14 +111,6 @@ enum tcpc_mux_mode { TCPC_MUX_DP_ENABLED, }; -struct tcpc_mux_dev { - int (*set)(struct tcpc_mux_dev *dev, enum tcpc_mux_mode mux_mode, - enum usb_role usb_role, - enum typec_cc_polarity polarity); - bool dfp_only; - void *priv_data; -}; - /** * struct tcpc_dev - Port configuration and callback functions * @config: Pointer to port configuration @@ -171,7 +162,6 @@ struct tcpc_dev { int (*try_role)(struct tcpc_dev *dev, int role); int (*pd_transmit)(struct tcpc_dev *dev, enum tcpm_transmit_type type, const struct pd_message *msg); - struct tcpc_mux_dev *mux; }; struct tcpm_port; -- 2.14.3 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: [v5,06/12] usb: typec: tcpm: Use new Type-C switch/mux and usb-role-switch functions From: Hans de Goede Message-Id: <20180228150749.26831-7-hdegoede@redhat.com> Date: Wed, 28 Feb 2018 16:07:43 +0100 To: Darren Hart , Andy Shevchenko , MyungJoo Ham , Chanwoo Choi , Mathias Nyman , Heikki Krogerus , Greg Kroah-Hartman , Guenter Roeck Cc: Hans de Goede , platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org List-ID: UmVtb3ZlIHRoZSB1bnVzZWQgKG5vdCBpbXBsZW1lbnRlZCBhbnl3aGVyZSkgdGNwY19tdXhfZGV2 IGFic3RyYWN0aW9uCmFuZCByZXBsYWNlIGl0IHdpdGggY2FsbGluZyB0aGUgbmV3IHR5cGVjX3Nl dF9vcmllbnRhdGlvbiwKdXNiX3JvbGVfc3dpdGNoX3NldCBhbmQgdHlwZWNfc2V0X21vZGUgZnVu Y3Rpb25zLgoKUmV2aWV3ZWQtYnk6IEhlaWtraSBLcm9nZXJ1cyA8aGVpa2tpLmtyb2dlcnVzQGxp bnV4LmludGVsLmNvbT4KUmV2aWV3ZWQtYnk6IEd1ZW50ZXIgUm9lY2sgPGxpbnV4QHJvZWNrLXVz Lm5ldD4KUmV2aWV3ZWQtYnk6IEFuZHkgU2hldmNoZW5rbyA8YW5keS5zaGV2Y2hlbmtvQGdtYWls LmNvbT4KU2lnbmVkLW9mZi1ieTogSGFucyBkZSBHb2VkZSA8aGRlZ29lZGVAcmVkaGF0LmNvbT4K LS0tCkNoYW5nZXMgaW4gdjQ6Ci1BZGQgQW5keSdzIFJldmlld2VkLWJ5CgpDaGFuZ2VzIGluIHYz OgotQWRkIEd1ZW50ZXIncyBSZXZpZXdlZC1ieQoKQ2hhbmdlcyBpbiB2MjoKLUFkZGVkIEhlaWtr aSdzIFJldmlld2VkLWJ5Ci0tLQogZHJpdmVycy91c2IvdHlwZWMvS2NvbmZpZyAgICAgICAgICAg fCAgMSArCiBkcml2ZXJzL3VzYi90eXBlYy9mdXNiMzAyL2Z1c2IzMDIuYyB8ICAxIC0KIGRyaXZl cnMvdXNiL3R5cGVjL3RjcG0uYyAgICAgICAgICAgIHwgNDYgKysrKysrKysrKysrKysrKysrKysr KysrKysrKy0tLS0tLS0tLQogaW5jbHVkZS9saW51eC91c2IvdGNwbS5oICAgICAgICAgICAgfCAx MCAtLS0tLS0tLQogNCBmaWxlcyBjaGFuZ2VkLCAzNiBpbnNlcnRpb25zKCspLCAyMiBkZWxldGlv bnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi90eXBlYy9LY29uZmlnIGIvZHJpdmVycy91 c2IvdHlwZWMvS2NvbmZpZwppbmRleCBiY2IyNzQ0YzU5NzcuLmEyYTA2ODRlN2M4MiAxMDA2NDQK LS0tIGEvZHJpdmVycy91c2IvdHlwZWMvS2NvbmZpZworKysgYi9kcml2ZXJzL3VzYi90eXBlYy9L Y29uZmlnCkBAIC00OCw2ICs0OCw3IEBAIGlmIFRZUEVDCiBjb25maWcgVFlQRUNfVENQTQogCXRy aXN0YXRlICJVU0IgVHlwZS1DIFBvcnQgQ29udHJvbGxlciBNYW5hZ2VyIgogCWRlcGVuZHMgb24g VVNCCisJc2VsZWN0IFVTQl9ST0xFX1NXSVRDSAogCWhlbHAKIAkgIFRoZSBUeXBlLUMgUG9ydCBD b250cm9sbGVyIE1hbmFnZXIgcHJvdmlkZXMgYSBVU0IgUEQgYW5kIFVTQiBUeXBlLUMKIAkgIHN0 YXRlIG1hY2hpbmUgZm9yIHVzZSB3aXRoIFR5cGUtQyBQb3J0IENvbnRyb2xsZXJzLgpkaWZmIC0t Z2l0IGEvZHJpdmVycy91c2IvdHlwZWMvZnVzYjMwMi9mdXNiMzAyLmMgYi9kcml2ZXJzL3VzYi90 eXBlYy9mdXNiMzAyL2Z1c2IzMDIuYwppbmRleCBkY2Q4ZWYwODViMzAuLmE3YjA2MDUzYTUzOCAx MDA2NDQKLS0tIGEvZHJpdmVycy91c2IvdHlwZWMvZnVzYjMwMi9mdXNiMzAyLmMKKysrIGIvZHJp dmVycy91c2IvdHlwZWMvZnVzYjMwMi9mdXNiMzAyLmMKQEAgLTEyNDksNyArMTI0OSw2IEBAIHN0 YXRpYyB2b2lkIGluaXRfdGNwY19kZXYoc3RydWN0IHRjcGNfZGV2ICpmdXNiMzAyX3RjcGNfZGV2 KQogCWZ1c2IzMDJfdGNwY19kZXYtPnNldF9yb2xlcyA9IHRjcG1fc2V0X3JvbGVzOwogCWZ1c2Iz MDJfdGNwY19kZXYtPnN0YXJ0X2RycF90b2dnbGluZyA9IHRjcG1fc3RhcnRfZHJwX3RvZ2dsaW5n OwogCWZ1c2IzMDJfdGNwY19kZXYtPnBkX3RyYW5zbWl0ID0gdGNwbV9wZF90cmFuc21pdDsKLQlm dXNiMzAyX3RjcGNfZGV2LT5tdXggPSBOVUxMOwogfQogCiBzdGF0aWMgY29uc3QgY2hhciAqIGNv bnN0IGNjX3BvbGFyaXR5X25hbWVbXSA9IHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3R5cGVj L3RjcG0uYyBiL2RyaXZlcnMvdXNiL3R5cGVjL3RjcG0uYwppbmRleCAwMGNhMjgyMjQzMmYuLmJm Y2FmNjYxOGExZiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvdHlwZWMvdGNwbS5jCisrKyBiL2Ry aXZlcnMvdXNiL3R5cGVjL3RjcG0uYwpAQCAtMjAsNiArMjAsNyBAQAogI2luY2x1ZGUgPGxpbnV4 L3VzYi9wZC5oPgogI2luY2x1ZGUgPGxpbnV4L3VzYi9wZF9iZG8uaD4KICNpbmNsdWRlIDxsaW51 eC91c2IvcGRfdmRvLmg+CisjaW5jbHVkZSA8bGludXgvdXNiL3JvbGUuaD4KICNpbmNsdWRlIDxs aW51eC91c2IvdGNwbS5oPgogI2luY2x1ZGUgPGxpbnV4L3VzYi90eXBlYy5oPgogI2luY2x1ZGUg PGxpbnV4L3dvcmtxdWV1ZS5oPgpAQCAtMTc2LDYgKzE3Nyw3IEBAIHN0cnVjdCB0Y3BtX3BvcnQg ewogCXN0cnVjdCB0eXBlY19wb3J0ICp0eXBlY19wb3J0OwogCiAJc3RydWN0IHRjcGNfZGV2CSp0 Y3BjOworCXN0cnVjdCB1c2Jfcm9sZV9zd2l0Y2ggKnJvbGVfc3c7CiAKIAllbnVtIHR5cGVjX3Jv bGUgdmNvbm5fcm9sZTsKIAllbnVtIHR5cGVjX3JvbGUgcHdyX3JvbGU7CkBAIC02MTgsMTggKzYy MCwyNSBAQCB2b2lkIHRjcG1fcGRfdHJhbnNtaXRfY29tcGxldGUoc3RydWN0IHRjcG1fcG9ydCAq cG9ydCwKIEVYUE9SVF9TWU1CT0xfR1BMKHRjcG1fcGRfdHJhbnNtaXRfY29tcGxldGUpOwogCiBz dGF0aWMgaW50IHRjcG1fbXV4X3NldChzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LCBlbnVtIHRjcGNf bXV4X21vZGUgbW9kZSwKLQkJCWVudW0gdXNiX3JvbGUgdXNiX3JvbGUpCisJCQllbnVtIHVzYl9y b2xlIHVzYl9yb2xlLAorCQkJZW51bSB0eXBlY19vcmllbnRhdGlvbiBvcmllbnRhdGlvbikKIHsK LQlpbnQgcmV0ID0gMDsKKwlpbnQgcmV0OwogCi0JdGNwbV9sb2cocG9ydCwgIlJlcXVlc3Rpbmcg bXV4IG1vZGUgJWQsIHVzYi1yb2xlICVkLCBwb2xhcml0eSAlZCIsCi0JCSBtb2RlLCB1c2Jfcm9s ZSwgcG9ydC0+cG9sYXJpdHkpOworCXRjcG1fbG9nKHBvcnQsICJSZXF1ZXN0aW5nIG11eCBtb2Rl ICVkLCB1c2Itcm9sZSAlZCwgb3JpZW50YXRpb24gJWQiLAorCQkgbW9kZSwgdXNiX3JvbGUsIG9y aWVudGF0aW9uKTsKIAotCWlmIChwb3J0LT50Y3BjLT5tdXgpCi0JCXJldCA9IHBvcnQtPnRjcGMt Pm11eC0+c2V0KHBvcnQtPnRjcGMtPm11eCwgbW9kZSwgdXNiX3JvbGUsCi0JCQkJCSAgIHBvcnQt PnBvbGFyaXR5KTsKKwlyZXQgPSB0eXBlY19zZXRfb3JpZW50YXRpb24ocG9ydC0+dHlwZWNfcG9y dCwgb3JpZW50YXRpb24pOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CiAKLQlyZXR1cm4gcmV0 OworCWlmIChwb3J0LT5yb2xlX3N3KSB7CisJCXJldCA9IHVzYl9yb2xlX3N3aXRjaF9zZXRfcm9s ZShwb3J0LT5yb2xlX3N3LCB1c2Jfcm9sZSk7CisJCWlmIChyZXQpCisJCQlyZXR1cm4gcmV0Owor CX0KKworCXJldHVybiB0eXBlY19zZXRfbW9kZShwb3J0LT50eXBlY19wb3J0LCBtb2RlKTsKIH0K IAogc3RhdGljIGludCB0Y3BtX3NldF9wb2xhcml0eShzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LApA QCAtNzQyLDE1ICs3NTEsMjEgQEAgc3RhdGljIGludCB0Y3BtX3NldF9hdHRhY2hlZF9zdGF0ZShz dHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LCBib29sIGF0dGFjaGVkKQogc3RhdGljIGludCB0Y3BtX3Nl dF9yb2xlcyhzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LCBib29sIGF0dGFjaGVkLAogCQkJICBlbnVt IHR5cGVjX3JvbGUgcm9sZSwgZW51bSB0eXBlY19kYXRhX3JvbGUgZGF0YSkKIHsKKwllbnVtIHR5 cGVjX29yaWVudGF0aW9uIG9yaWVudGF0aW9uOwogCWVudW0gdXNiX3JvbGUgdXNiX3JvbGU7CiAJ aW50IHJldDsKIAorCWlmIChwb3J0LT5wb2xhcml0eSA9PSBUWVBFQ19QT0xBUklUWV9DQzEpCisJ CW9yaWVudGF0aW9uID0gVFlQRUNfT1JJRU5UQVRJT05fTk9STUFMOworCWVsc2UKKwkJb3JpZW50 YXRpb24gPSBUWVBFQ19PUklFTlRBVElPTl9SRVZFUlNFOworCiAJaWYgKGRhdGEgPT0gVFlQRUNf SE9TVCkKIAkJdXNiX3JvbGUgPSBVU0JfUk9MRV9IT1NUOwogCWVsc2UKIAkJdXNiX3JvbGUgPSBV U0JfUk9MRV9ERVZJQ0U7CiAKLQlyZXQgPSB0Y3BtX211eF9zZXQocG9ydCwgVFlQRUNfTVVYX1VT QiwgdXNiX3JvbGUpOworCXJldCA9IHRjcG1fbXV4X3NldChwb3J0LCBUWVBFQ19NVVhfVVNCLCB1 c2Jfcm9sZSwgb3JpZW50YXRpb24pOwogCWlmIChyZXQgPCAwKQogCQlyZXR1cm4gcmV0OwogCkBA IC0yMDk3LDcgKzIxMTIsOCBAQCBzdGF0aWMgaW50IHRjcG1fc3JjX2F0dGFjaChzdHJ1Y3QgdGNw bV9wb3J0ICpwb3J0KQogb3V0X2Rpc2FibGVfcGQ6CiAJcG9ydC0+dGNwYy0+c2V0X3BkX3J4KHBv cnQtPnRjcGMsIGZhbHNlKTsKIG91dF9kaXNhYmxlX211eDoKLQl0Y3BtX211eF9zZXQocG9ydCwg VFlQRUNfTVVYX05PTkUsIFVTQl9ST0xFX05PTkUpOworCXRjcG1fbXV4X3NldChwb3J0LCBUWVBF Q19NVVhfTk9ORSwgVVNCX1JPTEVfTk9ORSwKKwkJICAgICBUWVBFQ19PUklFTlRBVElPTl9OT05F KTsKIAlyZXR1cm4gcmV0OwogfQogCkBAIC0yMTQxLDcgKzIxNTcsOCBAQCBzdGF0aWMgdm9pZCB0 Y3BtX3Jlc2V0X3BvcnQoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCkKIAl0Y3BtX2luaXRfdmNvbm4o cG9ydCk7CiAJdGNwbV9zZXRfY3VycmVudF9saW1pdChwb3J0LCAwLCAwKTsKIAl0Y3BtX3NldF9w b2xhcml0eShwb3J0LCBUWVBFQ19QT0xBUklUWV9DQzEpOwotCXRjcG1fbXV4X3NldChwb3J0LCBU WVBFQ19NVVhfTk9ORSwgVVNCX1JPTEVfTk9ORSk7CisJdGNwbV9tdXhfc2V0KHBvcnQsIFRZUEVD X01VWF9OT05FLCBVU0JfUk9MRV9OT05FLAorCQkgICAgIFRZUEVDX09SSUVOVEFUSU9OX05PTkUp OwogCXRjcG1fc2V0X2F0dGFjaGVkX3N0YXRlKHBvcnQsIGZhbHNlKTsKIAlwb3J0LT50cnlfc3Jj X2NvdW50ID0gMDsKIAlwb3J0LT50cnlfc25rX2NvdW50ID0gMDsKQEAgLTM3NDIsNiArMzc1OSwx MiBAQCBzdHJ1Y3QgdGNwbV9wb3J0ICp0Y3BtX3JlZ2lzdGVyX3BvcnQoc3RydWN0IGRldmljZSAq ZGV2LCBzdHJ1Y3QgdGNwY19kZXYgKnRjcGMpCiAJcG9ydC0+cGFydG5lcl9kZXNjLmlkZW50aXR5 ID0gJnBvcnQtPnBhcnRuZXJfaWRlbnQ7CiAJcG9ydC0+cG9ydF90eXBlID0gdGNwYy0+Y29uZmln LT50eXBlOwogCisJcG9ydC0+cm9sZV9zdyA9IHVzYl9yb2xlX3N3aXRjaF9nZXQocG9ydC0+ZGV2 KTsKKwlpZiAoSVNfRVJSKHBvcnQtPnJvbGVfc3cpKSB7CisJCWVyciA9IFBUUl9FUlIocG9ydC0+ cm9sZV9zdyk7CisJCWdvdG8gb3V0X2Rlc3Ryb3lfd3E7CisJfQorCiAJcG9ydC0+dHlwZWNfcG9y dCA9IHR5cGVjX3JlZ2lzdGVyX3BvcnQocG9ydC0+ZGV2LCAmcG9ydC0+dHlwZWNfY2Fwcyk7CiAJ aWYgKElTX0VSUihwb3J0LT50eXBlY19wb3J0KSkgewogCQllcnIgPSBQVFJfRVJSKHBvcnQtPnR5 cGVjX3BvcnQpOwpAQCAtMzc3Nyw2ICszODAwLDcgQEAgc3RydWN0IHRjcG1fcG9ydCAqdGNwbV9y ZWdpc3Rlcl9wb3J0KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHRjcGNfZGV2ICp0Y3BjKQog CXJldHVybiBwb3J0OwogCiBvdXRfZGVzdHJveV93cToKKwl1c2Jfcm9sZV9zd2l0Y2hfcHV0KHBv cnQtPnJvbGVfc3cpOwogCWRlc3Ryb3lfd29ya3F1ZXVlKHBvcnQtPndxKTsKIAlyZXR1cm4gRVJS X1BUUihlcnIpOwogfQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC91c2IvdGNwbS5oIGIvaW5j bHVkZS9saW51eC91c2IvdGNwbS5oCmluZGV4IDI2ODcyMWJmZjJjMS4uZmUzNTA4ZTZlMWRmIDEw MDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3VzYi90Y3BtLmgKKysrIGIvaW5jbHVkZS9saW51eC91 c2IvdGNwbS5oCkBAIC0xNiw3ICsxNiw2IEBACiAjZGVmaW5lIF9fTElOVVhfVVNCX1RDUE1fSAog CiAjaW5jbHVkZSA8bGludXgvYml0b3BzLmg+Ci0jaW5jbHVkZSA8bGludXgvdXNiL3JvbGUuaD4K ICNpbmNsdWRlIDxsaW51eC91c2IvdHlwZWMuaD4KICNpbmNsdWRlICJwZC5oIgogCkBAIC0xMTIs MTQgKzExMSw2IEBAIGVudW0gdGNwY19tdXhfbW9kZSB7CiAJCQkgIFRDUENfTVVYX0RQX0VOQUJM RUQsCiB9OwogCi1zdHJ1Y3QgdGNwY19tdXhfZGV2IHsKLQlpbnQgKCpzZXQpKHN0cnVjdCB0Y3Bj X211eF9kZXYgKmRldiwgZW51bSB0Y3BjX211eF9tb2RlIG11eF9tb2RlLAotCQkgICBlbnVtIHVz Yl9yb2xlIHVzYl9yb2xlLAotCQkgICBlbnVtIHR5cGVjX2NjX3BvbGFyaXR5IHBvbGFyaXR5KTsK LQlib29sIGRmcF9vbmx5OwotCXZvaWQgKnByaXZfZGF0YTsKLX07Ci0KIC8qKgogICogc3RydWN0 IHRjcGNfZGV2IC0gUG9ydCBjb25maWd1cmF0aW9uIGFuZCBjYWxsYmFjayBmdW5jdGlvbnMKICAq IEBjb25maWc6CVBvaW50ZXIgdG8gcG9ydCBjb25maWd1cmF0aW9uCkBAIC0xNzEsNyArMTYyLDYg QEAgc3RydWN0IHRjcGNfZGV2IHsKIAlpbnQgKCp0cnlfcm9sZSkoc3RydWN0IHRjcGNfZGV2ICpk ZXYsIGludCByb2xlKTsKIAlpbnQgKCpwZF90cmFuc21pdCkoc3RydWN0IHRjcGNfZGV2ICpkZXYs IGVudW0gdGNwbV90cmFuc21pdF90eXBlIHR5cGUsCiAJCQkgICBjb25zdCBzdHJ1Y3QgcGRfbWVz c2FnZSAqbXNnKTsKLQlzdHJ1Y3QgdGNwY19tdXhfZGV2ICptdXg7CiB9OwogCiBzdHJ1Y3QgdGNw bV9wb3J0Owo=