From mboxrd@z Thu Jan 1 00:00:00 1970 From: mturquette@linaro.org (Daniel Drake) Date: Mon, 05 Aug 2013 15:00:57 -0700 Subject: [PATCH RESEND 2/2] clk: mmp: add support for DT-defined clocks Message-ID: <20130805220057.5348.98721@quantum> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Add support to the existing mmp clock drivers for clocks to be defined in the device tree. This will be used on OLPC MMP2/MMP3-based laptops. If clock info cannot be found in the device tree, we fall back to the static clock initialization already present. Signed-off-by: Daniel Drake --- .../devicetree/bindings/clock/mmp-apbc.txt | 30 ++++++++++ .../devicetree/bindings/clock/mmp-apmu.txt | 30 ++++++++++ drivers/clk/mmp/clk-apbc.c | 66 +++++++++++++++++++++- drivers/clk/mmp/clk-apmu.c | 37 +++++++++++- drivers/clk/mmp/clk-mmp2.c | 19 ++++++- 5 files changed, 179 insertions(+), 3 deletions(-) create mode 100644 Documentation/devicetree/bindings/clock/mmp-apbc.txt create mode 100644 Documentation/devicetree/bindings/clock/mmp-apmu.txt Resending after a month without review. diff --git a/Documentation/devicetree/bindings/clock/mmp-apbc.txt b/Documentation/devicetree/bindings/clock/mmp-apbc.txt new file mode 100644 index 0000000..88e1253 --- /dev/null +++ b/Documentation/devicetree/bindings/clock/mmp-apbc.txt @@ -0,0 +1,30 @@ +* Clock bindings for Marvell MMP Advanced Peripheral Bus clock + +Parent apb-clock node +===================== +Required properties: +- reg: Address and length of the APB clock unit registers + + +Child peripheral clock nodes +============================ +Required properties: +- compatible : shall be "marvell,mmp-apb-clock" +- #clock-cells : from common clock binding; shall be set to 1 +- clocks : parent clock, from common clock binding +- clock-output-names : Array of clock names, from common clock binding +- reg : Array of control register offsets into APB clock unit register space + + +Example: +apbc: apb-clock { + reg = <0xd4015000 0x1000>; + + twsi-clocks { + compatible = "marvell,mmp-apb-clock"; + #clock-cells = <1>; + clocks = <&vctvxo-clock>; + clock-output-names = "TWSI0", "TWSI1"; + reg = <0x04 0x08>; + }; +}; diff --git a/Documentation/devicetree/bindings/clock/mmp-apmu.txt b/Documentation/devicetree/bindings/clock/mmp-apmu.txt new file mode 100644 index 0000000..18bb0f9 --- /dev/null +++ b/Documentation/devicetree/bindings/clock/mmp-apmu.txt @@ -0,0 +1,30 @@ +* Clock bindings for Marvell MMP Application Subsystem Power Management Unit + +Parent apmu-clock node +===================== +Required properties: +- reg: Address and length of the CPU Subsystem PMU registers + + +Child peripheral clock nodes +============================ +Required properties: +- compatible : shall be "marvell,mmp-apmu-clock" +- #clock-cells : from common clock binding; shall be set to 0 +- clocks : parent clock, from common clock binding +- reg : Control register offsets into parent register space +- enable-mask : The bits to be set in the register to enable the clock, or + cleared to disable. + +Example: +apmu-clock { + reg = <0xd4282800 0x1000>; + + usb-clock { + compatible = "marvell,mmp-apmu-clock"; + #clock-cells = <0>; + clocks = <&usb_pll>; + reg = <0x5c>; + enable-mask = <0x09>; + }; +}; diff --git a/drivers/clk/mmp/clk-apbc.c b/drivers/clk/mmp/clk-apbc.c index 89a146a..d53bc79 100644 --- a/drivers/clk/mmp/clk-apbc.c +++ b/drivers/clk/mmp/clk-apbc.c @@ -15,6 +15,8 @@ #include #include #include +#include +#include #include "clk.h" @@ -129,8 +131,70 @@ struct clk *mmp_clk_register_apbc(const char *name, const char *parent_name, apbc->hw.init = &init; clk = clk_register(NULL, &apbc->hw); - if (IS_ERR(clk)) + if (WARN_ON(IS_ERR(clk))) kfree(apbc); return clk; } + +static void __init mmp_apbc_dt_init(struct device_node *node) +{ + struct device_node *parent = of_get_parent(node); + const __be32 *regs; + struct clk *clk; + int rc; + int len; + int num_clocks; + int clock_num; + void __iomem *baseaddr; + const char *clock_name; + const char *parent_name; + struct clk **clks; + struct clk_onecell_data *clk_data; + + regs = of_get_property(node, "reg", &len); + if (WARN_ON(!regs || (len % sizeof(__be32) != 0))) + return; + num_clocks = len / sizeof(__be32); + + baseaddr = of_iomap(parent, 0); + of_node_put(parent); + if (WARN_ON(!baseaddr)) + return; + + clk_data = kzalloc(sizeof(*clk_data), GFP_KERNEL); + if (WARN_ON(!clk_data)) + goto err_clk_data; + + clks = kzalloc(num_clocks * sizeof(*clks), GFP_KERNEL); + if (WARN_ON(!clks)) + goto err_clks; + + clock_name = of_get_property(node, "clock-output-names", NULL); + parent_name = of_clk_get_parent_name(node, 0); + + for (clock_num = 0; clock_num < num_clocks; clock_num++) { + void __iomem *clock_addr; + clock_addr = baseaddr + be32_to_cpup(regs + clock_num); + + clk = mmp_clk_register_apbc(clock_name, parent_name, + clock_addr, 10, 0); Looks like mmp_clk_register_apbc is missing an argument for the spinlock. I'm getting the following: drivers/clk/mmp/clk-apbc.c: In function ?mmp_apbc_dt_init?: drivers/clk/mmp/clk-apbc.c|197 col 10| error: too few arguments to function ?mmp_clk_register_apbc? Regards, Mike + if (IS_ERR(clk)) + return; + clock_name += strlen(clock_name) + 1; + clks[clock_num] = clk; + } + + clk_data->clk_num = num_clocks; + clk_data->clks = clks; + rc = of_clk_add_provider(node, of_clk_src_onecell_get, clk_data); + WARN_ON(rc); + return; + +err_clks: + kfree(clk_data); +err_clk_data: + iounmap(baseaddr); + +} +CLK_OF_DECLARE(mmp2_apbc, "marvell,mmp-apb-clock", mmp_apbc_dt_init); diff --git a/drivers/clk/mmp/clk-apmu.c b/drivers/clk/mmp/clk-apmu.c index 4f4d8c5..dfcecc9 100644 --- a/drivers/clk/mmp/clk-apmu.c +++ b/drivers/clk/mmp/clk-apmu.c @@ -15,6 +15,8 @@ #include #include #include +#include +#include #include "clk.h" @@ -22,7 +24,6 @@ struct clk_apmu { struct clk_hw hw; void __iomem *base; - u32 rst_mask; u32 enable_mask; }; @@ -85,3 +86,37 @@ struct clk *mmp_clk_register_apmu(const char *name, const char *parent_name, return clk; } + +static void __init mmp_apmu_dt_init(struct device_node *node) +{ + struct device_node *parent = of_get_parent(node); + const char *clk_name = node->name; + void __iomem *baseaddr; + struct clk *clk; + u32 reg; + u32 enable_mask; + int rc; + + rc = of_property_read_u32(node, "reg", ®); + if (WARN_ON(rc)) + return; + + rc = of_property_read_u32(node, "enable-mask", &enable_mask); + if (WARN_ON(rc)) + return; + + baseaddr = of_iomap(parent, 0); + of_node_put(parent); + if (WARN_ON(!baseaddr)) + return; + + of_property_read_string(node, "clock-output-names", &clk_name); + clk = mmp_clk_register_apmu(clk_name, of_clk_get_parent_name(node, 0), + baseaddr + reg, enable_mask); + if (WARN_ON(IS_ERR(clk))) + return; + + rc = of_clk_add_provider(node, of_clk_src_simple_get, clk); + WARN_ON(rc); +} +CLK_OF_DECLARE(mmp2_apmu, "marvell,mmp-apmu-clock", mmp_apmu_dt_init); diff --git a/drivers/clk/mmp/clk-mmp2.c b/drivers/clk/mmp/clk-mmp2.c index cb1b0b6..774193b 100644 --- a/drivers/clk/mmp/clk-mmp2.c +++ b/drivers/clk/mmp/clk-mmp2.c @@ -15,6 +15,7 @@ #include #include #include +#include #include @@ -73,7 +74,7 @@ static const char *sdh_parent[] = {"pll1_4", "pll2", "usb_pll", "pll1"}; static const char *disp_parent[] = {"pll1", "pll1_16", "pll2", "vctcxo"}; static const char *ccic_parent[] = {"pll1_2", "pll1_16", "vctcxo"}; -void __init mmp2_clk_init(void) +static void __init mmp2_clk_init_static(void) { struct clk *clk; struct clk *vctcxo; @@ -445,3 +446,19 @@ void __init mmp2_clk_init(void) apmu_base + APMU_CCIC1, 0x300); clk_register_clkdev(clk, "sphyclk", "mmp-ccic.1"); } + +void __init mmp2_clk_init(void) +{ + struct device_node *node; + + /* The presence of the ABP clock node in the device tree indicates + * that we should use the DT for clock setup. */ + node = of_find_compatible_node(NULL, NULL, "marvell,mmp-apb-clock"); + if (node) { + of_node_put(node); + of_clk_init(NULL); + } else { + /* Fallback to static setup */ + mmp2_clk_init_static(); + } +} -- 1.8.1.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Drake Subject: [PATCH RESEND 2/2] clk: mmp: add support for DT-defined clocks Date: Mon, 05 Aug 2013 15:00:57 -0700 Message-ID: <20130805220057.5348.98721@quantum> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=m.gmane.org@lists.infradead.org To: eric.y.miao@gmail.com, haojian.zhuang@gmail.com, mturquette@linaro.org Cc: devicetree-discuss@lists.ozlabs.org, pgf@laptop.org, linux-arm-kernel@lists.infradead.org List-Id: devicetree@vger.kernel.org QWRkIHN1cHBvcnQgdG8gdGhlIGV4aXN0aW5nIG1tcCBjbG9jayBkcml2ZXJzIGZvciBjbG9ja3Mg dG8gYmUgZGVmaW5lZAppbiB0aGUgZGV2aWNlIHRyZWUuIFRoaXMgd2lsbCBiZSB1c2VkIG9uIE9M UEMgTU1QMi9NTVAzLWJhc2VkIGxhcHRvcHMuCgpJZiBjbG9jayBpbmZvIGNhbm5vdCBiZSBmb3Vu ZCBpbiB0aGUgZGV2aWNlIHRyZWUsIHdlIGZhbGwgYmFjayB0byB0aGUKc3RhdGljIGNsb2NrIGlu aXRpYWxpemF0aW9uIGFscmVhZHkgcHJlc2VudC4KClNpZ25lZC1vZmYtYnk6IERhbmllbCBEcmFr ZSA8ZHNkQGxhcHRvcC5vcmc+Ci0tLQogLi4uL2RldmljZXRyZWUvYmluZGluZ3MvY2xvY2svbW1w LWFwYmMudHh0ICAgICAgICAgfCAzMCArKysrKysrKysrCiAuLi4vZGV2aWNldHJlZS9iaW5kaW5n cy9jbG9jay9tbXAtYXBtdS50eHQgICAgICAgICB8IDMwICsrKysrKysrKysKIGRyaXZlcnMvY2xr L21tcC9jbGstYXBiYy5jICAgICAgICAgICAgICAgICAgICAgICAgIHwgNjYgKysrKysrKysrKysr KysrKysrKysrLQogZHJpdmVycy9jbGsvbW1wL2Nsay1hcG11LmMgICAgICAgICAgICAgICAgICAg ICAgICAgfCAzNyArKysrKysrKysrKy0KIGRyaXZlcnMvY2xrL21tcC9jbGstbW1wMi5jICAgICAg ICAgICAgICAgICAgICAgICAgIHwgMTkgKysrKysrLQogNSBmaWxlcyBjaGFuZ2VkLCAxNzkgaW5z ZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0 aW9uL2RldmljZXRyZWUvYmluZGluZ3MvY2xvY2svbW1wLWFwYmMudHh0CiBjcmVhdGUgbW9kZSAx MDA2NDQgRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2Nsb2NrL21tcC1hcG11LnR4 dAoKUmVzZW5kaW5nIGFmdGVyIGEgbW9udGggd2l0aG91dCByZXZpZXcuCgpkaWZmIC0tZ2l0IGEv RG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2Nsb2NrL21tcC1hcGJjLnR4dCBiL0Rv Y3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9jbG9jay9tbXAtYXBiYy50eHQKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODhlMTI1MwotLS0gL2Rldi9udWxsCisrKyBi L0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9jbG9jay9tbXAtYXBiYy50eHQKQEAg LTAsMCArMSwzMCBAQAorKiBDbG9jayBiaW5kaW5ncyBmb3IgTWFydmVsbCBNTVAgQWR2YW5jZWQg UGVyaXBoZXJhbCBCdXMgY2xvY2sKKworUGFyZW50IGFwYi1jbG9jayBub2RlCis9PT09PT09PT09 PT09PT09PT09PT0KK1JlcXVpcmVkIHByb3BlcnRpZXM6CistIHJlZzogQWRkcmVzcyBhbmQgbGVu Z3RoIG9mIHRoZSBBUEIgY2xvY2sgdW5pdCByZWdpc3RlcnMKKworCitDaGlsZCBwZXJpcGhlcmFs IGNsb2NrIG5vZGVzCis9PT09PT09PT09PT09PT09PT09PT09PT09PT09CitSZXF1aXJlZCBwcm9w ZXJ0aWVzOgorLSBjb21wYXRpYmxlIDogc2hhbGwgYmUgIm1hcnZlbGwsbW1wLWFwYi1jbG9jayIK Ky0gI2Nsb2NrLWNlbGxzIDogZnJvbSBjb21tb24gY2xvY2sgYmluZGluZzsgc2hhbGwgYmUgc2V0 IHRvIDEKKy0gY2xvY2tzIDogcGFyZW50IGNsb2NrLCBmcm9tIGNvbW1vbiBjbG9jayBiaW5kaW5n CistIGNsb2NrLW91dHB1dC1uYW1lcyA6IEFycmF5IG9mIGNsb2NrIG5hbWVzLCBmcm9tIGNvbW1v biBjbG9jayBiaW5kaW5nCistIHJlZyA6IEFycmF5IG9mIGNvbnRyb2wgcmVnaXN0ZXIgb2Zmc2V0 cyBpbnRvIEFQQiBjbG9jayB1bml0IHJlZ2lzdGVyIHNwYWNlCisKKworRXhhbXBsZToKK2FwYmM6 IGFwYi1jbG9jayB7CisgICAgICAgcmVnID0gPDB4ZDQwMTUwMDAgMHgxMDAwPjsKKworICAgICAg IHR3c2ktY2xvY2tzIHsKKyAgICAgICAgICAgICAgIGNvbXBhdGlibGUgPSAibWFydmVsbCxtbXAt YXBiLWNsb2NrIjsKKyAgICAgICAgICAgICAgICNjbG9jay1jZWxscyA9IDwxPjsKKyAgICAgICAg ICAgICAgIGNsb2NrcyA9IDwmdmN0dnhvLWNsb2NrPjsKKyAgICAgICAgICAgICAgIGNsb2NrLW91 dHB1dC1uYW1lcyA9ICJUV1NJMCIsICJUV1NJMSI7CisgICAgICAgICAgICAgICByZWcgPSA8MHgw NCAweDA4PjsKKyAgICAgICB9OworfTsKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZGV2aWNl dHJlZS9iaW5kaW5ncy9jbG9jay9tbXAtYXBtdS50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRy ZWUvYmluZGluZ3MvY2xvY2svbW1wLWFwbXUudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAuLjE4YmIwZjkKLS0tIC9kZXYvbnVsbAorKysgYi9Eb2N1bWVudGF0aW9uL2Rldmlj ZXRyZWUvYmluZGluZ3MvY2xvY2svbW1wLWFwbXUudHh0CkBAIC0wLDAgKzEsMzAgQEAKKyogQ2xv Y2sgYmluZGluZ3MgZm9yIE1hcnZlbGwgTU1QIEFwcGxpY2F0aW9uIFN1YnN5c3RlbSBQb3dlciBN YW5hZ2VtZW50IFVuaXQKKworUGFyZW50IGFwbXUtY2xvY2sgbm9kZQorPT09PT09PT09PT09PT09 PT09PT09CitSZXF1aXJlZCBwcm9wZXJ0aWVzOgorLSByZWc6IEFkZHJlc3MgYW5kIGxlbmd0aCBv ZiB0aGUgQ1BVIFN1YnN5c3RlbSBQTVUgcmVnaXN0ZXJzCisKKworQ2hpbGQgcGVyaXBoZXJhbCBj bG9jayBub2RlcworPT09PT09PT09PT09PT09PT09PT09PT09PT09PQorUmVxdWlyZWQgcHJvcGVy dGllczoKKy0gY29tcGF0aWJsZSA6IHNoYWxsIGJlICJtYXJ2ZWxsLG1tcC1hcG11LWNsb2NrIgor LSAjY2xvY2stY2VsbHMgOiBmcm9tIGNvbW1vbiBjbG9jayBiaW5kaW5nOyBzaGFsbCBiZSBzZXQg dG8gMAorLSBjbG9ja3MgOiBwYXJlbnQgY2xvY2ssIGZyb20gY29tbW9uIGNsb2NrIGJpbmRpbmcK Ky0gcmVnIDogQ29udHJvbCByZWdpc3RlciBvZmZzZXRzIGludG8gcGFyZW50IHJlZ2lzdGVyIHNw YWNlCistIGVuYWJsZS1tYXNrIDogVGhlIGJpdHMgdG8gYmUgc2V0IGluIHRoZSByZWdpc3RlciB0 byBlbmFibGUgdGhlIGNsb2NrLCBvcgorICAgICAgICAgICAgICAgIGNsZWFyZWQgdG8gZGlzYWJs ZS4KKworRXhhbXBsZToKK2FwbXUtY2xvY2sgeworICAgICAgIHJlZyA9IDwweGQ0MjgyODAwIDB4 MTAwMD47CisKKyAgICAgICB1c2ItY2xvY2sgeworICAgICAgICAgICAgICAgY29tcGF0aWJsZSA9 ICJtYXJ2ZWxsLG1tcC1hcG11LWNsb2NrIjsKKyAgICAgICAgICAgICAgICNjbG9jay1jZWxscyA9 IDwwPjsKKyAgICAgICAgICAgICAgIGNsb2NrcyA9IDwmdXNiX3BsbD47CisgICAgICAgICAgICAg ICByZWcgPSA8MHg1Yz47CisgICAgICAgICAgICAgICBlbmFibGUtbWFzayA9IDwweDA5PjsKKyAg ICAgICB9OworfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2xrL21tcC9jbGstYXBiYy5jIGIvZHJp dmVycy9jbGsvbW1wL2Nsay1hcGJjLmMKaW5kZXggODlhMTQ2YS4uZDUzYmM3OSAxMDA2NDQKLS0t IGEvZHJpdmVycy9jbGsvbW1wL2Nsay1hcGJjLmMKKysrIGIvZHJpdmVycy9jbGsvbW1wL2Nsay1h cGJjLmMKQEAgLTE1LDYgKzE1LDggQEAKICNpbmNsdWRlIDxsaW51eC9lcnIuaD4KICNpbmNsdWRl IDxsaW51eC9kZWxheS5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51 eC9vZi5oPgorI2luY2x1ZGUgPGxpbnV4L29mX2FkZHJlc3MuaD4KIAogI2luY2x1ZGUgImNsay5o IgogCkBAIC0xMjksOCArMTMxLDcwIEBAIHN0cnVjdCBjbGsgKm1tcF9jbGtfcmVnaXN0ZXJfYXBi Yyhjb25zdCBjaGFyICpuYW1lLCBjb25zdCBjaGFyICpwYXJlbnRfbmFtZSwKICAgICAgICBhcGJj LT5ody5pbml0ID0gJmluaXQ7CiAKICAgICAgICBjbGsgPSBjbGtfcmVnaXN0ZXIoTlVMTCwgJmFw YmMtPmh3KTsKLSAgICAgICBpZiAoSVNfRVJSKGNsaykpCisgICAgICAgaWYgKFdBUk5fT04oSVNf RVJSKGNsaykpKQogICAgICAgICAgICAgICAga2ZyZWUoYXBiYyk7CiAKICAgICAgICByZXR1cm4g Y2xrOwogfQorCitzdGF0aWMgdm9pZCBfX2luaXQgbW1wX2FwYmNfZHRfaW5pdChzdHJ1Y3QgZGV2 aWNlX25vZGUgKm5vZGUpCit7CisgICAgICAgc3RydWN0IGRldmljZV9ub2RlICpwYXJlbnQgPSBv Zl9nZXRfcGFyZW50KG5vZGUpOworICAgICAgIGNvbnN0IF9fYmUzMiAqcmVnczsKKyAgICAgICBz dHJ1Y3QgY2xrICpjbGs7CisgICAgICAgaW50IHJjOworICAgICAgIGludCBsZW47CisgICAgICAg aW50IG51bV9jbG9ja3M7CisgICAgICAgaW50IGNsb2NrX251bTsKKyAgICAgICB2b2lkIF9faW9t ZW0gKmJhc2VhZGRyOworICAgICAgIGNvbnN0IGNoYXIgKmNsb2NrX25hbWU7CisgICAgICAgY29u c3QgY2hhciAqcGFyZW50X25hbWU7CisgICAgICAgc3RydWN0IGNsayAqKmNsa3M7CisgICAgICAg c3RydWN0IGNsa19vbmVjZWxsX2RhdGEgKmNsa19kYXRhOworCisgICAgICAgcmVncyA9IG9mX2dl dF9wcm9wZXJ0eShub2RlLCAicmVnIiwgJmxlbik7CisgICAgICAgaWYgKFdBUk5fT04oIXJlZ3Mg fHwgKGxlbiAlIHNpemVvZihfX2JlMzIpICE9IDApKSkKKyAgICAgICAgICAgICAgIHJldHVybjsK KyAgICAgICBudW1fY2xvY2tzID0gbGVuIC8gc2l6ZW9mKF9fYmUzMik7CisKKyAgICAgICBiYXNl YWRkciA9IG9mX2lvbWFwKHBhcmVudCwgMCk7CisgICAgICAgb2Zfbm9kZV9wdXQocGFyZW50KTsK KyAgICAgICBpZiAoV0FSTl9PTighYmFzZWFkZHIpKQorICAgICAgICAgICAgICAgcmV0dXJuOwor CisgICAgICAgY2xrX2RhdGEgPSBremFsbG9jKHNpemVvZigqY2xrX2RhdGEpLCBHRlBfS0VSTkVM KTsKKyAgICAgICBpZiAoV0FSTl9PTighY2xrX2RhdGEpKQorICAgICAgICAgICAgICAgZ290byBl cnJfY2xrX2RhdGE7CisKKyAgICAgICBjbGtzID0ga3phbGxvYyhudW1fY2xvY2tzICogc2l6ZW9m KCpjbGtzKSwgR0ZQX0tFUk5FTCk7CisgICAgICAgaWYgKFdBUk5fT04oIWNsa3MpKQorICAgICAg ICAgICAgICAgZ290byBlcnJfY2xrczsKKworICAgICAgIGNsb2NrX25hbWUgPSBvZl9nZXRfcHJv cGVydHkobm9kZSwgImNsb2NrLW91dHB1dC1uYW1lcyIsIE5VTEwpOworICAgICAgIHBhcmVudF9u YW1lID0gb2ZfY2xrX2dldF9wYXJlbnRfbmFtZShub2RlLCAwKTsKKworICAgICAgIGZvciAoY2xv Y2tfbnVtID0gMDsgY2xvY2tfbnVtIDwgbnVtX2Nsb2NrczsgY2xvY2tfbnVtKyspIHsKKyAgICAg ICAgICAgICAgIHZvaWQgX19pb21lbSAqY2xvY2tfYWRkcjsKKyAgICAgICAgICAgICAgIGNsb2Nr X2FkZHIgPSBiYXNlYWRkciArIGJlMzJfdG9fY3B1cChyZWdzICsgY2xvY2tfbnVtKTsKKworICAg ICAgICAgICAgICAgY2xrID0gbW1wX2Nsa19yZWdpc3Rlcl9hcGJjKGNsb2NrX25hbWUsIHBhcmVu dF9uYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNsb2Nr X2FkZHIsIDEwLCAwKTsKCkxvb2tzIGxpa2UgbW1wX2Nsa19yZWdpc3Rlcl9hcGJjIGlzIG1pc3Np bmcgYW4gYXJndW1lbnQgZm9yIHRoZQpzcGlubG9jay4gSSdtIGdldHRpbmcgdGhlIGZvbGxvd2lu ZzoKCmRyaXZlcnMvY2xrL21tcC9jbGstYXBiYy5jOiBJbiBmdW5jdGlvbiDigJhtbXBfYXBiY19k dF9pbml04oCZOgpkcml2ZXJzL2Nsay9tbXAvY2xrLWFwYmMuY3wxOTcgY29sIDEwfCBlcnJvcjog dG9vIGZldyBhcmd1bWVudHMgdG8KZnVuY3Rpb24g4oCYbW1wX2Nsa19yZWdpc3Rlcl9hcGJj4oCZ CgpSZWdhcmRzLApNaWtlCgorICAgICAgICAgICAgICAgaWYgKElTX0VSUihjbGspKQorICAgICAg ICAgICAgICAgICAgICAgICByZXR1cm47CisgICAgICAgICAgICAgICBjbG9ja19uYW1lICs9IHN0 cmxlbihjbG9ja19uYW1lKSArIDE7CisgICAgICAgICAgICAgICBjbGtzW2Nsb2NrX251bV0gPSBj bGs7CisgICAgICAgfQorCisgICAgICAgY2xrX2RhdGEtPmNsa19udW0gPSBudW1fY2xvY2tzOwor ICAgICAgIGNsa19kYXRhLT5jbGtzID0gY2xrczsKKyAgICAgICByYyA9IG9mX2Nsa19hZGRfcHJv dmlkZXIobm9kZSwgb2ZfY2xrX3NyY19vbmVjZWxsX2dldCwgY2xrX2RhdGEpOworICAgICAgIFdB Uk5fT04ocmMpOworICAgICAgIHJldHVybjsKKworZXJyX2Nsa3M6CisgICAgICAga2ZyZWUoY2xr X2RhdGEpOworZXJyX2Nsa19kYXRhOgorICAgICAgIGlvdW5tYXAoYmFzZWFkZHIpOworCit9CitD TEtfT0ZfREVDTEFSRShtbXAyX2FwYmMsICJtYXJ2ZWxsLG1tcC1hcGItY2xvY2siLCBtbXBfYXBi Y19kdF9pbml0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2xrL21tcC9jbGstYXBtdS5jIGIvZHJp dmVycy9jbGsvbW1wL2Nsay1hcG11LmMKaW5kZXggNGY0ZDhjNS4uZGZjZWNjOSAxMDA2NDQKLS0t IGEvZHJpdmVycy9jbGsvbW1wL2Nsay1hcG11LmMKKysrIGIvZHJpdmVycy9jbGsvbW1wL2Nsay1h cG11LmMKQEAgLTE1LDYgKzE1LDggQEAKICNpbmNsdWRlIDxsaW51eC9lcnIuaD4KICNpbmNsdWRl IDxsaW51eC9kZWxheS5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51 eC9vZi5oPgorI2luY2x1ZGUgPGxpbnV4L29mX2FkZHJlc3MuaD4KIAogI2luY2x1ZGUgImNsay5o IgogCkBAIC0yMiw3ICsyNCw2IEBACiBzdHJ1Y3QgY2xrX2FwbXUgewogICAgICAgIHN0cnVjdCBj bGtfaHcgICBodzsKICAgICAgICB2b2lkIF9faW9tZW0gICAgKmJhc2U7Ci0gICAgICAgdTMyICAg ICAgICAgICAgIHJzdF9tYXNrOwogICAgICAgIHUzMiAgICAgICAgICAgICBlbmFibGVfbWFzazsK IH07CiAKQEAgLTg1LDMgKzg2LDM3IEBAIHN0cnVjdCBjbGsgKm1tcF9jbGtfcmVnaXN0ZXJfYXBt dShjb25zdCBjaGFyICpuYW1lLCBjb25zdCBjaGFyICpwYXJlbnRfbmFtZSwKIAogICAgICAgIHJl dHVybiBjbGs7CiB9CisKK3N0YXRpYyB2b2lkIF9faW5pdCBtbXBfYXBtdV9kdF9pbml0KHN0cnVj dCBkZXZpY2Vfbm9kZSAqbm9kZSkKK3sKKyAgICAgICBzdHJ1Y3QgZGV2aWNlX25vZGUgKnBhcmVu dCA9IG9mX2dldF9wYXJlbnQobm9kZSk7CisgICAgICAgY29uc3QgY2hhciAqY2xrX25hbWUgPSBu b2RlLT5uYW1lOworICAgICAgIHZvaWQgX19pb21lbSAqYmFzZWFkZHI7CisgICAgICAgc3RydWN0 IGNsayAqY2xrOworICAgICAgIHUzMiByZWc7CisgICAgICAgdTMyIGVuYWJsZV9tYXNrOworICAg ICAgIGludCByYzsKKworICAgICAgIHJjID0gb2ZfcHJvcGVydHlfcmVhZF91MzIobm9kZSwgInJl ZyIsICZyZWcpOworICAgICAgIGlmIChXQVJOX09OKHJjKSkKKyAgICAgICAgICAgICAgIHJldHVy bjsKKworICAgICAgIHJjID0gb2ZfcHJvcGVydHlfcmVhZF91MzIobm9kZSwgImVuYWJsZS1tYXNr IiwgJmVuYWJsZV9tYXNrKTsKKyAgICAgICBpZiAoV0FSTl9PTihyYykpCisgICAgICAgICAgICAg ICByZXR1cm47CisKKyAgICAgICBiYXNlYWRkciA9IG9mX2lvbWFwKHBhcmVudCwgMCk7CisgICAg ICAgb2Zfbm9kZV9wdXQocGFyZW50KTsKKyAgICAgICBpZiAoV0FSTl9PTighYmFzZWFkZHIpKQor ICAgICAgICAgICAgICAgcmV0dXJuOworCisgICAgICAgb2ZfcHJvcGVydHlfcmVhZF9zdHJpbmco bm9kZSwgImNsb2NrLW91dHB1dC1uYW1lcyIsICZjbGtfbmFtZSk7CisgICAgICAgY2xrID0gbW1w X2Nsa19yZWdpc3Rlcl9hcG11KGNsa19uYW1lLCBvZl9jbGtfZ2V0X3BhcmVudF9uYW1lKG5vZGUs IDApLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBiYXNlYWRkciArIHJlZywg ZW5hYmxlX21hc2spOworICAgICAgIGlmIChXQVJOX09OKElTX0VSUihjbGspKSkKKyAgICAgICAg ICAgICAgIHJldHVybjsKKworICAgICAgIHJjID0gb2ZfY2xrX2FkZF9wcm92aWRlcihub2RlLCBv Zl9jbGtfc3JjX3NpbXBsZV9nZXQsIGNsayk7CisgICAgICAgV0FSTl9PTihyYyk7Cit9CitDTEtf T0ZfREVDTEFSRShtbXAyX2FwbXUsICJtYXJ2ZWxsLG1tcC1hcG11LWNsb2NrIiwgbW1wX2FwbXVf ZHRfaW5pdCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Nsay9tbXAvY2xrLW1tcDIuYyBiL2RyaXZl cnMvY2xrL21tcC9jbGstbW1wMi5jCmluZGV4IGNiMWIwYjYuLjc3NDE5M2IgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvY2xrL21tcC9jbGstbW1wMi5jCisrKyBiL2RyaXZlcnMvY2xrL21tcC9jbGstbW1w Mi5jCkBAIC0xNSw2ICsxNSw3IEBACiAjaW5jbHVkZSA8bGludXgvaW8uaD4KICNpbmNsdWRlIDxs aW51eC9kZWxheS5oPgogI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgorI2luY2x1ZGUgPGxpbnV4L29m Lmg+CiAKICNpbmNsdWRlIDxtYWNoL2FkZHItbWFwLmg+CiAKQEAgLTczLDcgKzc0LDcgQEAgc3Rh dGljIGNvbnN0IGNoYXIgKnNkaF9wYXJlbnRbXSA9IHsicGxsMV80IiwgInBsbDIiLCAidXNiX3Bs bCIsICJwbGwxIn07CiBzdGF0aWMgY29uc3QgY2hhciAqZGlzcF9wYXJlbnRbXSA9IHsicGxsMSIs ICJwbGwxXzE2IiwgInBsbDIiLCAidmN0Y3hvIn07CiBzdGF0aWMgY29uc3QgY2hhciAqY2NpY19w YXJlbnRbXSA9IHsicGxsMV8yIiwgInBsbDFfMTYiLCAidmN0Y3hvIn07CiAKLXZvaWQgX19pbml0 IG1tcDJfY2xrX2luaXQodm9pZCkKK3N0YXRpYyB2b2lkIF9faW5pdCBtbXAyX2Nsa19pbml0X3N0 YXRpYyh2b2lkKQogewogICAgICAgIHN0cnVjdCBjbGsgKmNsazsKICAgICAgICBzdHJ1Y3QgY2xr ICp2Y3RjeG87CkBAIC00NDUsMyArNDQ2LDE5IEBAIHZvaWQgX19pbml0IG1tcDJfY2xrX2luaXQo dm9pZCkKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhcG11X2Jhc2UgKyBBUE1VX0ND SUMxLCAweDMwMCk7CiAgICAgICAgY2xrX3JlZ2lzdGVyX2Nsa2RldihjbGssICJzcGh5Y2xrIiwg Im1tcC1jY2ljLjEiKTsKIH0KKwordm9pZCBfX2luaXQgbW1wMl9jbGtfaW5pdCh2b2lkKQorewor ICAgICAgIHN0cnVjdCBkZXZpY2Vfbm9kZSAqbm9kZTsKKworICAgICAgIC8qIFRoZSBwcmVzZW5j ZSBvZiB0aGUgQUJQIGNsb2NrIG5vZGUgaW4gdGhlIGRldmljZSB0cmVlIGluZGljYXRlcworICAg ICAgICAqIHRoYXQgd2Ugc2hvdWxkIHVzZSB0aGUgRFQgZm9yIGNsb2NrIHNldHVwLiAqLworICAg ICAgIG5vZGUgPSBvZl9maW5kX2NvbXBhdGlibGVfbm9kZShOVUxMLCBOVUxMLCAibWFydmVsbCxt bXAtYXBiLWNsb2NrIik7CisgICAgICAgaWYgKG5vZGUpIHsKKyAgICAgICAgICAgICAgIG9mX25v ZGVfcHV0KG5vZGUpOworICAgICAgICAgICAgICAgb2ZfY2xrX2luaXQoTlVMTCk7CisgICAgICAg fSBlbHNlIHsKKyAgICAgICAgICAgICAgIC8qIEZhbGxiYWNrIHRvIHN0YXRpYyBzZXR1cCAqLwor ICAgICAgICAgICAgICAgbW1wMl9jbGtfaW5pdF9zdGF0aWMoKTsKKyAgICAgICB9Cit9Ci0tIAox LjguMS40CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwps aW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJh ZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51 eC1hcm0ta2VybmVsCg==