From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-eopbgr00087.outbound.protection.outlook.com ([40.107.0.87]:41092 "EHLO EUR02-AM5-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1753137AbeE1DJq (ORCPT ); Sun, 27 May 2018 23:09:46 -0400 From: Li Jun Subject: [PATCH v6 06/15] usb: typec: tcpm: support get typec and pd config from device properties Date: Mon, 28 May 2018 10:52:38 +0800 Message-Id: <1527475967-15201-7-git-send-email-jun.li@nxp.com> In-Reply-To: <1527475967-15201-1-git-send-email-jun.li@nxp.com> References: <1527475967-15201-1-git-send-email-jun.li@nxp.com> MIME-Version: 1.0 Content-Type: text/plain Sender: devicetree-owner@vger.kernel.org To: robh+dt@kernel.org, gregkh@linuxfoundation.org, heikki.krogerus@linux.intel.com, linux@roeck-us.net Cc: cw00.choi@samsung.com, a.hajda@samsung.com, shufan_lee@richtek.com, peter.chen@nxp.com, garsilva@embeddedor.com, gsomlo@gmail.com, jun.li@nxp.com, linux-usb@vger.kernel.org, devicetree@vger.kernel.org, linux-imx@nxp.com List-ID: This patch adds support of get typec and power delivery config from firmware description. Signed-off-by: Li Jun --- drivers/usb/typec/tcpm.c | 132 +++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 110 insertions(+), 22 deletions(-) diff --git a/drivers/usb/typec/tcpm.c b/drivers/usb/typec/tcpm.c index fcd22e8..aa17cd5 100644 --- a/drivers/usb/typec/tcpm.c +++ b/drivers/usb/typec/tcpm.c @@ -4241,6 +4241,81 @@ static int tcpm_copy_vdos(u32 *dest_vdo, const u32 *src_vdo, return nr_vdo; } +static int tcpm_fw_get_caps(struct tcpm_port *port, + struct fwnode_handle *fwnode) +{ + const char *cap_str; + int ret; + u32 mw; + + if (!port || !fwnode) + return -EINVAL; + + /* USB data support is optional */ + ret = fwnode_property_read_string(fwnode, "data-role", &cap_str); + if (ret == 0) { + port->typec_caps.data = typec_find_port_data_role(cap_str); + if (port->typec_caps.data < 0) + return -EINVAL; + } + + ret = fwnode_property_read_string(fwnode, "power-role", &cap_str); + if (ret < 0) + return ret; + + port->typec_caps.type = typec_find_port_power_role(cap_str); + if (port->typec_caps.type < 0) + return -EINVAL; + port->port_type = port->typec_caps.type; + + if (port->port_type == TYPEC_PORT_SNK) + goto sink; + + /* Get soruce pdos */ + ret = fwnode_property_read_u32_array(fwnode, "source-pdos", + NULL, 0); + if (ret <= 0) + return -EINVAL; + + port->nr_src_pdo = min(ret, PDO_MAX_OBJECTS); + ret = fwnode_property_read_u32_array(fwnode, "source-pdos", + port->src_pdo, port->nr_src_pdo); + if ((ret < 0) || tcpm_validate_caps(port, port->src_pdo, + port->nr_src_pdo)) + return -EINVAL; + + if (port->port_type == TYPEC_PORT_SRC) + return 0; + + /* Get the preferred power role for DRP */ + ret = fwnode_property_read_string(fwnode, "try-power-role", &cap_str); + if (ret < 0) + return ret; + + port->typec_caps.prefer_role = typec_find_power_role(cap_str); + if (port->typec_caps.prefer_role < 0) + return -EINVAL; +sink: + /* Get sink pdos */ + ret = fwnode_property_read_u32_array(fwnode, "sink-pdos", + NULL, 0); + if (ret <= 0) + return -EINVAL; + + port->nr_snk_pdo = min(ret, PDO_MAX_OBJECTS); + ret = fwnode_property_read_u32_array(fwnode, "sink-pdos", + port->snk_pdo, port->nr_snk_pdo); + if ((ret < 0) || tcpm_validate_caps(port, port->snk_pdo, + port->nr_snk_pdo)) + return -EINVAL; + + if (fwnode_property_read_u32(fwnode, "op-sink-microwatt", &mw) < 0) + return -EINVAL; + port->operating_snk_mw = mw / 1000; + + return 0; +} + int tcpm_update_source_capabilities(struct tcpm_port *port, const u32 *pdo, unsigned int nr_pdo) { @@ -4526,12 +4601,36 @@ static int devm_tcpm_psy_register(struct tcpm_port *port) return PTR_ERR_OR_ZERO(port->psy); } +static int tcpm_copy_caps(struct tcpm_port *port, + const struct tcpc_config *tcfg) +{ + if (tcpm_validate_caps(port, tcfg->src_pdo, tcfg->nr_src_pdo) || + tcpm_validate_caps(port, tcfg->snk_pdo, tcfg->nr_snk_pdo)) + return -EINVAL; + + port->nr_src_pdo = tcpm_copy_pdos(port->src_pdo, tcfg->src_pdo, + tcfg->nr_src_pdo); + port->nr_snk_pdo = tcpm_copy_pdos(port->snk_pdo, tcfg->snk_pdo, + tcfg->nr_snk_pdo); + + port->nr_snk_vdo = tcpm_copy_vdos(port->snk_vdo, tcfg->snk_vdo, + tcfg->nr_snk_vdo); + + port->operating_snk_mw = tcfg->operating_snk_mw; + + port->typec_caps.prefer_role = tcfg->default_role; + port->typec_caps.type = tcfg->type; + port->typec_caps.data = tcfg->data; + + return 0; +} + struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) { struct tcpm_port *port; int i, err; - if (!dev || !tcpc || !tcpc->config || + if (!dev || !tcpc || !tcpc->get_vbus || !tcpc->set_cc || !tcpc->get_cc || !tcpc->set_polarity || !tcpc->set_vconn || !tcpc->set_vbus || !tcpc->set_pd_rx || !tcpc->set_roles || !tcpc->pd_transmit) @@ -4561,30 +4660,19 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) init_completion(&port->pps_complete); tcpm_debugfs_init(port); - if (tcpm_validate_caps(port, tcpc->config->src_pdo, - tcpc->config->nr_src_pdo) || - tcpm_validate_caps(port, tcpc->config->snk_pdo, - tcpc->config->nr_snk_pdo)) { - err = -EINVAL; + if (tcpc->config) + err = tcpm_copy_caps(port, tcpc->config); + else + err = tcpm_fw_get_caps(port, tcpc->fwnode); + if (err < 0) goto out_destroy_wq; - } - port->nr_src_pdo = tcpm_copy_pdos(port->src_pdo, tcpc->config->src_pdo, - tcpc->config->nr_src_pdo); - port->nr_snk_pdo = tcpm_copy_pdos(port->snk_pdo, tcpc->config->snk_pdo, - tcpc->config->nr_snk_pdo); - port->nr_snk_vdo = tcpm_copy_vdos(port->snk_vdo, tcpc->config->snk_vdo, - tcpc->config->nr_snk_vdo); - - port->operating_snk_mw = tcpc->config->operating_snk_mw; - if (!tcpc->config->try_role_hw) - port->try_role = tcpc->config->default_role; + + if (!tcpc->config || !tcpc->config->try_role_hw) + port->try_role = port->typec_caps.prefer_role; else port->try_role = TYPEC_NO_PREFERRED_ROLE; port->typec_caps.fwnode = tcpc->fwnode; - 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 = 0x0300; /* USB-PD spec release 3.0 */ port->typec_caps.dr_set = tcpm_dr_set; @@ -4594,7 +4682,7 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) port->typec_caps.port_type_set = tcpm_port_type_set; port->partner_desc.identity = &port->partner_ident; - port->port_type = tcpc->config->type; + port->port_type = port->typec_caps.type; port->role_sw = usb_role_switch_get(port->dev); if (IS_ERR(port->role_sw)) { @@ -4612,7 +4700,7 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) goto out_destroy_wq; } - if (tcpc->config->alt_modes) { + if (tcpc->config && tcpc->config->alt_modes) { const struct typec_altmode_desc *paltmode = tcpc->config->alt_modes; i = 0; -- 2.7.4 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: [v6,06/15] usb: typec: tcpm: support get typec and pd config from device properties From: Jun Li Message-Id: <1527475967-15201-7-git-send-email-jun.li@nxp.com> Date: Mon, 28 May 2018 10:52:38 +0800 To: robh+dt@kernel.org, gregkh@linuxfoundation.org, heikki.krogerus@linux.intel.com, linux@roeck-us.net Cc: cw00.choi@samsung.com, a.hajda@samsung.com, shufan_lee@richtek.com, peter.chen@nxp.com, garsilva@embeddedor.com, gsomlo@gmail.com, jun.li@nxp.com, linux-usb@vger.kernel.org, devicetree@vger.kernel.org, linux-imx@nxp.com List-ID: VGhpcyBwYXRjaCBhZGRzIHN1cHBvcnQgb2YgZ2V0IHR5cGVjIGFuZCBwb3dlciBkZWxpdmVyeSBj b25maWcgZnJvbQpmaXJtd2FyZSBkZXNjcmlwdGlvbi4KClNpZ25lZC1vZmYtYnk6IExpIEp1biA8 anVuLmxpQG54cC5jb20+Ci0tLQogZHJpdmVycy91c2IvdHlwZWMvdGNwbS5jIHwgMTMyICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tCiAxIGZpbGUgY2hhbmdl ZCwgMTEwIGluc2VydGlvbnMoKyksIDIyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZl cnMvdXNiL3R5cGVjL3RjcG0uYyBiL2RyaXZlcnMvdXNiL3R5cGVjL3RjcG0uYwppbmRleCBmY2Qy MmU4Li5hYTE3Y2Q1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi90eXBlYy90Y3BtLmMKKysrIGIv ZHJpdmVycy91c2IvdHlwZWMvdGNwbS5jCkBAIC00MjQxLDYgKzQyNDEsODEgQEAgc3RhdGljIGlu dCB0Y3BtX2NvcHlfdmRvcyh1MzIgKmRlc3RfdmRvLCBjb25zdCB1MzIgKnNyY192ZG8sCiAJcmV0 dXJuIG5yX3ZkbzsKIH0KIAorc3RhdGljIGludCB0Y3BtX2Z3X2dldF9jYXBzKHN0cnVjdCB0Y3Bt X3BvcnQgKnBvcnQsCisJCQkgICAgc3RydWN0IGZ3bm9kZV9oYW5kbGUgKmZ3bm9kZSkKK3sKKwlj b25zdCBjaGFyICpjYXBfc3RyOworCWludCByZXQ7CisJdTMyIG13OworCisJaWYgKCFwb3J0IHx8 ICFmd25vZGUpCisJCXJldHVybiAtRUlOVkFMOworCisJLyogVVNCIGRhdGEgc3VwcG9ydCBpcyBv cHRpb25hbCAqLworCXJldCA9IGZ3bm9kZV9wcm9wZXJ0eV9yZWFkX3N0cmluZyhmd25vZGUsICJk YXRhLXJvbGUiLCAmY2FwX3N0cik7CisJaWYgKHJldCA9PSAwKSB7CisJCXBvcnQtPnR5cGVjX2Nh cHMuZGF0YSA9IHR5cGVjX2ZpbmRfcG9ydF9kYXRhX3JvbGUoY2FwX3N0cik7CisJCWlmIChwb3J0 LT50eXBlY19jYXBzLmRhdGEgPCAwKQorCQkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJcmV0ID0g Zndub2RlX3Byb3BlcnR5X3JlYWRfc3RyaW5nKGZ3bm9kZSwgInBvd2VyLXJvbGUiLCAmY2FwX3N0 cik7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlwb3J0LT50eXBlY19jYXBzLnR5 cGUgPSB0eXBlY19maW5kX3BvcnRfcG93ZXJfcm9sZShjYXBfc3RyKTsKKwlpZiAocG9ydC0+dHlw ZWNfY2Fwcy50eXBlIDwgMCkKKwkJcmV0dXJuIC1FSU5WQUw7CisJcG9ydC0+cG9ydF90eXBlID0g cG9ydC0+dHlwZWNfY2Fwcy50eXBlOworCisJaWYgKHBvcnQtPnBvcnRfdHlwZSA9PSBUWVBFQ19Q T1JUX1NOSykKKwkJZ290byBzaW5rOworCisJLyogR2V0IHNvcnVjZSBwZG9zICovCisJcmV0ID0g Zndub2RlX3Byb3BlcnR5X3JlYWRfdTMyX2FycmF5KGZ3bm9kZSwgInNvdXJjZS1wZG9zIiwKKwkJ CQkJICAgICBOVUxMLCAwKTsKKwlpZiAocmV0IDw9IDApCisJCXJldHVybiAtRUlOVkFMOworCisJ cG9ydC0+bnJfc3JjX3BkbyA9IG1pbihyZXQsIFBET19NQVhfT0JKRUNUUyk7CisJcmV0ID0gZndu b2RlX3Byb3BlcnR5X3JlYWRfdTMyX2FycmF5KGZ3bm9kZSwgInNvdXJjZS1wZG9zIiwKKwkJCQkJ ICAgICBwb3J0LT5zcmNfcGRvLCBwb3J0LT5ucl9zcmNfcGRvKTsKKwlpZiAoKHJldCA8IDApIHx8 IHRjcG1fdmFsaWRhdGVfY2Fwcyhwb3J0LCBwb3J0LT5zcmNfcGRvLAorCQkJCQkgICAgcG9ydC0+ bnJfc3JjX3BkbykpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKHBvcnQtPnBvcnRfdHlwZSA9 PSBUWVBFQ19QT1JUX1NSQykKKwkJcmV0dXJuIDA7CisKKwkvKiBHZXQgdGhlIHByZWZlcnJlZCBw b3dlciByb2xlIGZvciBEUlAgKi8KKwlyZXQgPSBmd25vZGVfcHJvcGVydHlfcmVhZF9zdHJpbmco Zndub2RlLCAidHJ5LXBvd2VyLXJvbGUiLCAmY2FwX3N0cik7CisJaWYgKHJldCA8IDApCisJCXJl dHVybiByZXQ7CisKKwlwb3J0LT50eXBlY19jYXBzLnByZWZlcl9yb2xlID0gdHlwZWNfZmluZF9w b3dlcl9yb2xlKGNhcF9zdHIpOworCWlmIChwb3J0LT50eXBlY19jYXBzLnByZWZlcl9yb2xlIDwg MCkKKwkJcmV0dXJuIC1FSU5WQUw7CitzaW5rOgorCS8qIEdldCBzaW5rIHBkb3MgKi8KKwlyZXQg PSBmd25vZGVfcHJvcGVydHlfcmVhZF91MzJfYXJyYXkoZndub2RlLCAic2luay1wZG9zIiwKKwkJ CQkJICAgICBOVUxMLCAwKTsKKwlpZiAocmV0IDw9IDApCisJCXJldHVybiAtRUlOVkFMOworCisJ cG9ydC0+bnJfc25rX3BkbyA9IG1pbihyZXQsIFBET19NQVhfT0JKRUNUUyk7CisJcmV0ID0gZndu b2RlX3Byb3BlcnR5X3JlYWRfdTMyX2FycmF5KGZ3bm9kZSwgInNpbmstcGRvcyIsCisJCQkJCSAg ICAgcG9ydC0+c25rX3BkbywgcG9ydC0+bnJfc25rX3Bkbyk7CisJaWYgKChyZXQgPCAwKSB8fCB0 Y3BtX3ZhbGlkYXRlX2NhcHMocG9ydCwgcG9ydC0+c25rX3BkbywKKwkJCQkJICAgIHBvcnQtPm5y X3Nua19wZG8pKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWlmIChmd25vZGVfcHJvcGVydHlfcmVh ZF91MzIoZndub2RlLCAib3Atc2luay1taWNyb3dhdHQiLCAmbXcpIDwgMCkKKwkJcmV0dXJuIC1F SU5WQUw7CisJcG9ydC0+b3BlcmF0aW5nX3Nua19tdyA9IG13IC8gMTAwMDsKKworCXJldHVybiAw OworfQorCiBpbnQgdGNwbV91cGRhdGVfc291cmNlX2NhcGFiaWxpdGllcyhzdHJ1Y3QgdGNwbV9w b3J0ICpwb3J0LCBjb25zdCB1MzIgKnBkbywKIAkJCQkgICAgdW5zaWduZWQgaW50IG5yX3BkbykK IHsKQEAgLTQ1MjYsMTIgKzQ2MDEsMzYgQEAgc3RhdGljIGludCBkZXZtX3RjcG1fcHN5X3JlZ2lz dGVyKHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQpCiAJcmV0dXJuIFBUUl9FUlJfT1JfWkVSTyhwb3J0 LT5wc3kpOwogfQogCitzdGF0aWMgaW50IHRjcG1fY29weV9jYXBzKHN0cnVjdCB0Y3BtX3BvcnQg KnBvcnQsCisJCQkgIGNvbnN0IHN0cnVjdCB0Y3BjX2NvbmZpZyAqdGNmZykKK3sKKwlpZiAodGNw bV92YWxpZGF0ZV9jYXBzKHBvcnQsIHRjZmctPnNyY19wZG8sIHRjZmctPm5yX3NyY19wZG8pIHx8 CisJICAgIHRjcG1fdmFsaWRhdGVfY2Fwcyhwb3J0LCB0Y2ZnLT5zbmtfcGRvLCB0Y2ZnLT5ucl9z bmtfcGRvKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlwb3J0LT5ucl9zcmNfcGRvID0gdGNwbV9j b3B5X3Bkb3MocG9ydC0+c3JjX3BkbywgdGNmZy0+c3JjX3BkbywKKwkJCQkJICB0Y2ZnLT5ucl9z cmNfcGRvKTsKKwlwb3J0LT5ucl9zbmtfcGRvID0gdGNwbV9jb3B5X3Bkb3MocG9ydC0+c25rX3Bk bywgdGNmZy0+c25rX3BkbywKKwkJCQkJICB0Y2ZnLT5ucl9zbmtfcGRvKTsKKworCXBvcnQtPm5y X3Nua192ZG8gPSB0Y3BtX2NvcHlfdmRvcyhwb3J0LT5zbmtfdmRvLCB0Y2ZnLT5zbmtfdmRvLAor CQkJCQkgIHRjZmctPm5yX3Nua192ZG8pOworCisJcG9ydC0+b3BlcmF0aW5nX3Nua19tdyA9IHRj ZmctPm9wZXJhdGluZ19zbmtfbXc7CisKKwlwb3J0LT50eXBlY19jYXBzLnByZWZlcl9yb2xlID0g dGNmZy0+ZGVmYXVsdF9yb2xlOworCXBvcnQtPnR5cGVjX2NhcHMudHlwZSA9IHRjZmctPnR5cGU7 CisJcG9ydC0+dHlwZWNfY2Fwcy5kYXRhID0gdGNmZy0+ZGF0YTsKKworCXJldHVybiAwOworfQor CiBzdHJ1Y3QgdGNwbV9wb3J0ICp0Y3BtX3JlZ2lzdGVyX3BvcnQoc3RydWN0IGRldmljZSAqZGV2 LCBzdHJ1Y3QgdGNwY19kZXYgKnRjcGMpCiB7CiAJc3RydWN0IHRjcG1fcG9ydCAqcG9ydDsKIAlp bnQgaSwgZXJyOwogCi0JaWYgKCFkZXYgfHwgIXRjcGMgfHwgIXRjcGMtPmNvbmZpZyB8fAorCWlm ICghZGV2IHx8ICF0Y3BjIHx8CiAJICAgICF0Y3BjLT5nZXRfdmJ1cyB8fCAhdGNwYy0+c2V0X2Nj IHx8ICF0Y3BjLT5nZXRfY2MgfHwKIAkgICAgIXRjcGMtPnNldF9wb2xhcml0eSB8fCAhdGNwYy0+ c2V0X3Zjb25uIHx8ICF0Y3BjLT5zZXRfdmJ1cyB8fAogCSAgICAhdGNwYy0+c2V0X3BkX3J4IHx8 ICF0Y3BjLT5zZXRfcm9sZXMgfHwgIXRjcGMtPnBkX3RyYW5zbWl0KQpAQCAtNDU2MSwzMCArNDY2 MCwxOSBAQCBzdHJ1Y3QgdGNwbV9wb3J0ICp0Y3BtX3JlZ2lzdGVyX3BvcnQoc3RydWN0IGRldmlj ZSAqZGV2LCBzdHJ1Y3QgdGNwY19kZXYgKnRjcGMpCiAJaW5pdF9jb21wbGV0aW9uKCZwb3J0LT5w cHNfY29tcGxldGUpOwogCXRjcG1fZGVidWdmc19pbml0KHBvcnQpOwogCi0JaWYgKHRjcG1fdmFs aWRhdGVfY2Fwcyhwb3J0LCB0Y3BjLT5jb25maWctPnNyY19wZG8sCi0JCQkgICAgICAgdGNwYy0+ Y29uZmlnLT5ucl9zcmNfcGRvKSB8fAotCSAgICB0Y3BtX3ZhbGlkYXRlX2NhcHMocG9ydCwgdGNw Yy0+Y29uZmlnLT5zbmtfcGRvLAotCQkJICAgICAgIHRjcGMtPmNvbmZpZy0+bnJfc25rX3Bkbykp IHsKLQkJZXJyID0gLUVJTlZBTDsKKwlpZiAodGNwYy0+Y29uZmlnKQorCQllcnIgPSB0Y3BtX2Nv cHlfY2Fwcyhwb3J0LCB0Y3BjLT5jb25maWcpOworCWVsc2UKKwkJZXJyID0gdGNwbV9md19nZXRf Y2Fwcyhwb3J0LCB0Y3BjLT5md25vZGUpOworCWlmIChlcnIgPCAwKQogCQlnb3RvIG91dF9kZXN0 cm95X3dxOwotCX0KLQlwb3J0LT5ucl9zcmNfcGRvID0gdGNwbV9jb3B5X3Bkb3MocG9ydC0+c3Jj X3BkbywgdGNwYy0+Y29uZmlnLT5zcmNfcGRvLAotCQkJCQkgIHRjcGMtPmNvbmZpZy0+bnJfc3Jj X3Bkbyk7Ci0JcG9ydC0+bnJfc25rX3BkbyA9IHRjcG1fY29weV9wZG9zKHBvcnQtPnNua19wZG8s IHRjcGMtPmNvbmZpZy0+c25rX3BkbywKLQkJCQkJICB0Y3BjLT5jb25maWctPm5yX3Nua19wZG8p OwotCXBvcnQtPm5yX3Nua192ZG8gPSB0Y3BtX2NvcHlfdmRvcyhwb3J0LT5zbmtfdmRvLCB0Y3Bj LT5jb25maWctPnNua192ZG8sCi0JCQkJCSAgdGNwYy0+Y29uZmlnLT5ucl9zbmtfdmRvKTsKLQot CXBvcnQtPm9wZXJhdGluZ19zbmtfbXcgPSB0Y3BjLT5jb25maWctPm9wZXJhdGluZ19zbmtfbXc7 Ci0JaWYgKCF0Y3BjLT5jb25maWctPnRyeV9yb2xlX2h3KQotCQlwb3J0LT50cnlfcm9sZSA9IHRj cGMtPmNvbmZpZy0+ZGVmYXVsdF9yb2xlOworCisJaWYgKCF0Y3BjLT5jb25maWcgfHwgIXRjcGMt PmNvbmZpZy0+dHJ5X3JvbGVfaHcpCisJCXBvcnQtPnRyeV9yb2xlID0gcG9ydC0+dHlwZWNfY2Fw cy5wcmVmZXJfcm9sZTsKIAllbHNlCiAJCXBvcnQtPnRyeV9yb2xlID0gVFlQRUNfTk9fUFJFRkVS UkVEX1JPTEU7CiAKIAlwb3J0LT50eXBlY19jYXBzLmZ3bm9kZSA9IHRjcGMtPmZ3bm9kZTsKLQlw b3J0LT50eXBlY19jYXBzLnByZWZlcl9yb2xlID0gdGNwYy0+Y29uZmlnLT5kZWZhdWx0X3JvbGU7 Ci0JcG9ydC0+dHlwZWNfY2Fwcy50eXBlID0gdGNwYy0+Y29uZmlnLT50eXBlOwotCXBvcnQtPnR5 cGVjX2NhcHMuZGF0YSA9IHRjcGMtPmNvbmZpZy0+ZGF0YTsKIAlwb3J0LT50eXBlY19jYXBzLnJl dmlzaW9uID0gMHgwMTIwOwkvKiBUeXBlLUMgc3BlYyByZWxlYXNlIDEuMiAqLwogCXBvcnQtPnR5 cGVjX2NhcHMucGRfcmV2aXNpb24gPSAweDAzMDA7CS8qIFVTQi1QRCBzcGVjIHJlbGVhc2UgMy4w ICovCiAJcG9ydC0+dHlwZWNfY2Fwcy5kcl9zZXQgPSB0Y3BtX2RyX3NldDsKQEAgLTQ1OTQsNyAr NDY4Miw3IEBAIHN0cnVjdCB0Y3BtX3BvcnQgKnRjcG1fcmVnaXN0ZXJfcG9ydChzdHJ1Y3QgZGV2 aWNlICpkZXYsIHN0cnVjdCB0Y3BjX2RldiAqdGNwYykKIAlwb3J0LT50eXBlY19jYXBzLnBvcnRf dHlwZV9zZXQgPSB0Y3BtX3BvcnRfdHlwZV9zZXQ7CiAKIAlwb3J0LT5wYXJ0bmVyX2Rlc2MuaWRl bnRpdHkgPSAmcG9ydC0+cGFydG5lcl9pZGVudDsKLQlwb3J0LT5wb3J0X3R5cGUgPSB0Y3BjLT5j b25maWctPnR5cGU7CisJcG9ydC0+cG9ydF90eXBlID0gcG9ydC0+dHlwZWNfY2Fwcy50eXBlOwog CiAJcG9ydC0+cm9sZV9zdyA9IHVzYl9yb2xlX3N3aXRjaF9nZXQocG9ydC0+ZGV2KTsKIAlpZiAo SVNfRVJSKHBvcnQtPnJvbGVfc3cpKSB7CkBAIC00NjEyLDcgKzQ3MDAsNyBAQCBzdHJ1Y3QgdGNw bV9wb3J0ICp0Y3BtX3JlZ2lzdGVyX3BvcnQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgdGNw Y19kZXYgKnRjcGMpCiAJCWdvdG8gb3V0X2Rlc3Ryb3lfd3E7CiAJfQogCi0JaWYgKHRjcGMtPmNv bmZpZy0+YWx0X21vZGVzKSB7CisJaWYgKHRjcGMtPmNvbmZpZyAmJiB0Y3BjLT5jb25maWctPmFs dF9tb2RlcykgewogCQljb25zdCBzdHJ1Y3QgdHlwZWNfYWx0bW9kZV9kZXNjICpwYWx0bW9kZSA9 IHRjcGMtPmNvbmZpZy0+YWx0X21vZGVzOwogCiAJCWkgPSAwOwo=