From mboxrd@z Thu Jan 1 00:00:00 1970 From: alex.aring@gmail.com (Alexander Aring) Date: Wed, 28 Oct 2015 21:40:10 +0100 Subject: [RFC] rpi: add support to enable usb power domain Message-ID: <1446064810-5064-1-git-send-email-alex.aring@gmail.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org This patch adds support for RPi several Power Domains and enable support to enable the USB Power Domain when it's not enabled before. This patch based on Eric Anholt's patch to support Power Domains. He had an issue about -EPROBE_DEFER inside the power domain subsystem, this issue was solved by commit <311fa6a> ("PM / Domains: Return -EPROBE_DEFER if we fail to init or turn-on domain"). It was tested with barebox and the following scripts before booting linux: /env/a_off: # cat /env/a_off #turn off which are enabled by default regulator -n bcm2835_mci0 -s disable regulator -n uart0-pl0110 -s disable /env/a_on: # cat /env/a_on #turn off which are enabled by default regulator -n bcm2835_mci0 -s disable regulator -n uart0-pl0110 -s disable regulator -n bcm2835_mci0 -s enable regulator -n uart0-pl0110 -s enable regulator -n uart0-pl0111 -s enable regulator -n bcm2835_usb -s enable regulator -n bcm2835_i2c0 -s enable regulator -n bcm2835_i2c1 -s enable regulator -n bcm2835_i2c2 -s enable regulator -n bcm2835_spi -s enable regulator -n bcm2835_ccp2tx -s enable regulator -n bcm2835_dsi -s enable /env/b: # cat /env/b sh /env/a_on regulator -n bcm2835_mci0 -s disable regulator -n uart0-pl0110 -s disable regulator -n uart0-pl0111 -s disable regulator -n bcm2835_usb -s disable regulator -n bcm2835_i2c0 -s disable regulator -n bcm2835_i2c1 -s disable regulator -n bcm2835_i2c2 -s disable regulator -n bcm2835_spi -s disable regulator -n bcm2835_ccp2tx -s disable regulator -n bcm2835_dsi -s disable /env/c: # cat /env/c sh ./env/b regulator -n bcm2835_mci0 -s enable regulator -n uart0-pl0110 -s enable regulator -n uart0-pl0111 -s enable regulator -n bcm2835_usb -s enable regulator -n bcm2835_i2c0 -s enable regulator -n bcm2835_i2c1 -s enable regulator -n bcm2835_i2c2 -s enable regulator -n bcm2835_spi -s enable regulator -n bcm2835_ccp2tx -s enable regulator -n bcm2835_dsi -s enable These scripts enables/disable all regulators inside the bootloader. It was running with a "hard" and "soft" reset without any issues. These testcases should fit to Stephen Warren suggestions: "(a) before having explicitly turned the power domain on or off at all (b) after having turned it on (c) after having turned it off, and for all power domains." Cc: Stephen Warren Cc: Lee Jones Cc: Eric Anholt Cc: Andy Whitcroft Cc: Joe Perches Signed-off-by: Alexander Aring --- First: I cc'ed Andy Whitcroft and Joe Perches here, because this patch will generate a false positive for checkpatch and checkpatch told me to cc checkpatch maintainers if this occurs: ERROR: Macros with complex values should be enclosed in parentheses #191: FILE: drivers/firmware/raspberrypi.c:26: +#define RPI_POWER_DOMAIN(_domain, _name) \ + [_domain] = \ + { \ ... Second: This patch based on linus/master and requires the rpi-firmware patch. Third: The barebox regulator doesn't support right now to enable/disable regulators at runtime but I want to bring this mainline in the next days. So you can't check yourself if the above scripts working right now. I describe it here to show you what exactly I tested. changes since Eric Anholts "power domain" patch: - add for me all known power domains of the RPi, it contains the domains 0 - 9. - Add devicetree documentation. - move implementation to drivers/firmware/... (also Kconfig dependencies) - add macro RPI_POWER_DOMAIN. - add function "raspberrypi_firmware_power_is_on" to get the initial value for a "power domain", which can be assign over the "is_off" parameter, while power domain init. - Put generic_pm_domain on the heap with amount of entries which comes from ARRAY_SIZE(rpi_power_domains). So we don't need to care about both arrays anymore. But only works so far rpi_power_domains has not empty entries in the middle. I added a note about that, if it's too ugly I will remove it or accept other solutions. Maybe make rpi_power_domains as double pointer (and care about NULL entries, anyway. It should working and I think there are no other domains and if there are other domains and we have missing entries then something is wrong. Notes: I wonder myself when I disable domain 0 (SDHC) I can still access the card, as well uart is also still working after turn off power. .../arm/bcm/raspberrypi,bcm2835-firmware.txt | 15 +++ arch/arm/boot/dts/bcm2835-rpi.dtsi | 6 + arch/arm/boot/dts/bcm2835.dtsi | 2 +- drivers/firmware/Kconfig | 2 + drivers/firmware/raspberrypi.c | 133 +++++++++++++++++++++ .../dt-bindings/arm/raspberrypi-firmware-power.h | 23 ++++ 6 files changed, 180 insertions(+), 1 deletion(-) create mode 100644 include/dt-bindings/arm/raspberrypi-firmware-power.h diff --git a/Documentation/devicetree/bindings/arm/bcm/raspberrypi,bcm2835-firmware.txt b/Documentation/devicetree/bindings/arm/bcm/raspberrypi,bcm2835-firmware.txt index 6824b31..2727ca16 100644 --- a/Documentation/devicetree/bindings/arm/bcm/raspberrypi,bcm2835-firmware.txt +++ b/Documentation/devicetree/bindings/arm/bcm/raspberrypi,bcm2835-firmware.txt @@ -5,10 +5,25 @@ Required properties: - compatible: Should be "raspberrypi,bcm2835-firmware" - mboxes: Phandle to the firmware device's Mailbox. (See: ../mailbox/mailbox.txt for more information) +- #power-domain-cells: Should be <1>, we providing multiple power domains. + +The valid defines for power domain are: + + RPI_POWER_DOMAIN_SDCARD, RPI_POWER_DOMAIN_UART0, RPI_POWER_DOMAIN_UART1, + RPI_POWER_DOMAIN_USB, RPI_POWER_DOMAIN_I2C0, RPI_POWER_DOMAIN_I2C1, + RPI_POWER_DOMAIN_I2C2, RPI_POWER_DOMAIN_SPI, RPI_POWER_DOMAIN_CCP2TX, + RPI_POWER_DOMAIN_DSI Example: firmware { compatible = "raspberrypi,bcm2835-firmware"; mboxes = <&mailbox>; + #power-domain-cells = <1>; +}; + +Example for using power domain: + +&usb { + power-domains = <&firmware RPI_POWER_DOMAIN_USB>; }; diff --git a/arch/arm/boot/dts/bcm2835-rpi.dtsi b/arch/arm/boot/dts/bcm2835-rpi.dtsi index ab5474e..7f19352 100644 --- a/arch/arm/boot/dts/bcm2835-rpi.dtsi +++ b/arch/arm/boot/dts/bcm2835-rpi.dtsi @@ -1,3 +1,4 @@ +#include #include "bcm2835.dtsi" / { @@ -19,6 +20,7 @@ firmware: firmware { compatible = "raspberrypi,bcm2835-firmware"; mboxes = <&mailbox>; + #power-domain-cells = <1>; }; }; }; @@ -56,3 +58,7 @@ status = "okay"; bus-width = <4>; }; + +&usb { + power-domains = <&firmware RPI_POWER_DOMAIN_USB>; +}; diff --git a/arch/arm/boot/dts/bcm2835.dtsi b/arch/arm/boot/dts/bcm2835.dtsi index 301c73f..3c899b3 100644 --- a/arch/arm/boot/dts/bcm2835.dtsi +++ b/arch/arm/boot/dts/bcm2835.dtsi @@ -149,7 +149,7 @@ status = "disabled"; }; - usb at 7e980000 { + usb: usb at 7e980000 { compatible = "brcm,bcm2835-usb"; reg = <0x7e980000 0x10000>; interrupts = <1 9>; diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig index 7181126..8981599 100644 --- a/drivers/firmware/Kconfig +++ b/drivers/firmware/Kconfig @@ -150,6 +150,8 @@ config QCOM_SCM_64 config RASPBERRYPI_FIRMWARE tristate "Raspberry Pi Firmware Driver" depends on BCM2835_MBOX + select PM_GENERIC_DOMAINS if PM + select PM_GENERIC_DOMAINS_OF if PM help This option enables support for communicating with the firmware on the Raspberry Pi. diff --git a/drivers/firmware/raspberrypi.c b/drivers/firmware/raspberrypi.c index dd506cd3..e8db75e 100644 --- a/drivers/firmware/raspberrypi.c +++ b/drivers/firmware/raspberrypi.c @@ -14,6 +14,8 @@ #include #include #include +#include +#include #include #define MBOX_MSG(chan, data28) (((data28) & ~0xf) | ((chan) & 0xf)) @@ -21,7 +23,19 @@ #define MBOX_DATA28(msg) ((msg) & ~0xf) #define MBOX_CHAN_PROPERTY 8 +#define RPI_POWER_DOMAIN(_domain, _name) \ + [_domain] = \ + { \ + .domain = _domain, \ + .base = { \ + .name = _name, \ + .power_off = raspberrypi_domain_off, \ + .power_on = raspberrypi_domain_on, \ + }, \ + } + struct rpi_firmware { + struct genpd_onecell_data genpd_xlate; struct mbox_client cl; struct mbox_chan *chan; /* The property channel. */ struct completion c; @@ -30,6 +44,17 @@ struct rpi_firmware { static DEFINE_MUTEX(transaction_lock); +struct raspberrypi_power_domain { + struct rpi_firmware *fw; + u32 domain; + struct generic_pm_domain base; +}; + +struct rpi_power_domain_packet { + u32 domain; + u32 on; +} __packet; + static void response_callback(struct mbox_client *cl, void *msg) { struct rpi_firmware *fw = container_of(cl, struct rpi_firmware, cl); @@ -183,10 +208,84 @@ rpi_firmware_print_firmware_revision(struct rpi_firmware *fw) } } +/* + * Asks the firmware to enable or disable power on a specific power + * domain. + */ +static int raspberrypi_firmware_set_power(struct rpi_firmware *fw, + u32 domain, bool on) +{ + struct rpi_power_domain_packet packet; + int ret; + + packet.domain = domain; + packet.on = on; + ret = rpi_firmware_property(fw, RPI_FIRMWARE_SET_POWER_STATE, &packet, + sizeof(packet)); + if (!ret && !packet.on) + ret = -EINVAL; + + return ret; +} + +/* Asks the firmware to if power is on for a specific power domain. */ +static int raspberrypi_firmware_power_is_on(struct rpi_firmware *fw, + u32 domain) +{ + struct rpi_power_domain_packet packet; + int ret; + + packet.domain = domain; + ret = rpi_firmware_property(fw, RPI_FIRMWARE_GET_POWER_STATE, &packet, + sizeof(packet)); + if (ret < 0) + return ret; + + return packet.on & BIT(0); +} + +static int raspberrypi_domain_off(struct generic_pm_domain *domain) +{ + struct raspberrypi_power_domain *raspberrpi_domain = + container_of(domain, struct raspberrypi_power_domain, base); + + return raspberrypi_firmware_set_power(raspberrpi_domain->fw, + raspberrpi_domain->domain, false); +} + +static int raspberrypi_domain_on(struct generic_pm_domain *domain) +{ + struct raspberrypi_power_domain *raspberrpi_domain = + container_of(domain, struct raspberrypi_power_domain, base); + + return raspberrypi_firmware_set_power(raspberrpi_domain->fw, + raspberrpi_domain->domain, true); +} + +/* + * IMPORTANT: be sure this array has no entries which are not specified + * between others by RPI_POWER_DOMAIN, otherwise mapping between + * generic_pm_domain array doesn't work anymore. + */ +static struct raspberrypi_power_domain rpi_power_domains[] = { + RPI_POWER_DOMAIN(RPI_POWER_DOMAIN_SDCARD, "SDCARD"), + RPI_POWER_DOMAIN(RPI_POWER_DOMAIN_UART0, "UART0"), + RPI_POWER_DOMAIN(RPI_POWER_DOMAIN_UART1, "UART1"), + RPI_POWER_DOMAIN(RPI_POWER_DOMAIN_USB, "USB"), + RPI_POWER_DOMAIN(RPI_POWER_DOMAIN_I2C0, "I2C0"), + RPI_POWER_DOMAIN(RPI_POWER_DOMAIN_I2C1, "I2C1"), + RPI_POWER_DOMAIN(RPI_POWER_DOMAIN_I2C2, "I2C2"), + RPI_POWER_DOMAIN(RPI_POWER_DOMAIN_SPI, "SPI"), + RPI_POWER_DOMAIN(RPI_POWER_DOMAIN_CCP2TX, "CCP2TX"), + RPI_POWER_DOMAIN(RPI_POWER_DOMAIN_DSI, "DSI"), +}; + static int rpi_firmware_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct rpi_firmware *fw; + struct generic_pm_domain **power_domains; + int i, ret, num_domains = ARRAY_SIZE(rpi_power_domains); fw = devm_kzalloc(dev, sizeof(*fw), GFP_KERNEL); if (!fw) @@ -196,6 +295,11 @@ static int rpi_firmware_probe(struct platform_device *pdev) fw->cl.rx_callback = response_callback; fw->cl.tx_block = true; + power_domains = devm_kzalloc(dev, sizeof(*power_domains) * num_domains, + GFP_KERNEL); + if (!power_domains) + return -ENOMEM; + fw->chan = mbox_request_channel(&fw->cl, 0); if (IS_ERR(fw->chan)) { int ret = PTR_ERR(fw->chan); @@ -208,15 +312,44 @@ static int rpi_firmware_probe(struct platform_device *pdev) platform_set_drvdata(pdev, fw); + fw->genpd_xlate.domains = power_domains; + fw->genpd_xlate.num_domains = num_domains; + + for (i = 0; i < num_domains; i++) { + bool is_off; + + rpi_power_domains[i].fw = fw; + power_domains[i] = &rpi_power_domains[i].base; + + /* get the initial state */ + ret = raspberrypi_firmware_power_is_on(fw, i); + if (ret < 0) + goto mbox; + + /* pm_genpd_init needs is_off, invert the logic here */ + is_off = !ret; + pm_genpd_init(power_domains[i], NULL, is_off); + } + + ret = of_genpd_add_provider_onecell(dev->of_node, &fw->genpd_xlate); + if (ret < 0) + goto mbox; + rpi_firmware_print_firmware_revision(fw); return 0; + +mbox: + mbox_free_channel(fw->chan); + return ret; } static int rpi_firmware_remove(struct platform_device *pdev) { struct rpi_firmware *fw = platform_get_drvdata(pdev); + struct device *dev = &pdev->dev; + of_genpd_del_provider(dev->of_node); mbox_free_channel(fw->chan); return 0; diff --git a/include/dt-bindings/arm/raspberrypi-firmware-power.h b/include/dt-bindings/arm/raspberrypi-firmware-power.h new file mode 100644 index 0000000..c363a1f --- /dev/null +++ b/include/dt-bindings/arm/raspberrypi-firmware-power.h @@ -0,0 +1,23 @@ +/* + * Copyright ? 2015 Broadcom + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#ifndef _DT_BINDINGS_ARM_BCM2835_MBOX_POWER_H +#define _DT_BINDINGS_ARM_BCM2835_MBOX_POWER_H + +#define RPI_POWER_DOMAIN_SDCARD 0 +#define RPI_POWER_DOMAIN_UART0 1 +#define RPI_POWER_DOMAIN_UART1 2 +#define RPI_POWER_DOMAIN_USB 3 +#define RPI_POWER_DOMAIN_I2C0 4 +#define RPI_POWER_DOMAIN_I2C1 5 +#define RPI_POWER_DOMAIN_I2C2 6 +#define RPI_POWER_DOMAIN_SPI 7 +#define RPI_POWER_DOMAIN_CCP2TX 8 +#define RPI_POWER_DOMAIN_DSI 9 + +#endif /* _DT_BINDINGS_ARM_BCM2835_MBOX_POWER_H */ -- 2.6.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alexander Aring Subject: [RFC] rpi: add support to enable usb power domain Date: Wed, 28 Oct 2015 21:40:10 +0100 Message-ID: <1446064810-5064-1-git-send-email-alex.aring@gmail.com> 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: linux-rpi-kernel@lists.infradead.org Cc: mark.rutland@arm.com, devicetree@vger.kernel.org, paul@pwsan.com, lee@kernel.org, linux@arm.linux.org.uk, pawel.moll@arm.com, swarren@wwwdotorg.org, ijc+devicetree@hellion.org.uk, Alexander Aring , eric@anholt.net, robh+dt@kernel.org, zajec5@gmail.com, kernel@pengutronix.de, galak@codeaurora.org, apw@canonical.com, joe@perches.com, linux-arm-kernel@lists.infradead.org, agross@codeaurora.org List-Id: devicetree@vger.kernel.org VGhpcyBwYXRjaCBhZGRzIHN1cHBvcnQgZm9yIFJQaSBzZXZlcmFsIFBvd2VyIERvbWFpbnMgYW5k IGVuYWJsZSBzdXBwb3J0CnRvIGVuYWJsZSB0aGUgVVNCIFBvd2VyIERvbWFpbiB3aGVuIGl0J3Mg bm90IGVuYWJsZWQgYmVmb3JlLgoKVGhpcyBwYXRjaCBiYXNlZCBvbiBFcmljIEFuaG9sdCdzIHBh dGNoIHRvIHN1cHBvcnQgUG93ZXIgRG9tYWlucy4gSGUgaGFkCmFuIGlzc3VlIGFib3V0IC1FUFJP QkVfREVGRVIgaW5zaWRlIHRoZSBwb3dlciBkb21haW4gc3Vic3lzdGVtLCB0aGlzCmlzc3VlIHdh cyBzb2x2ZWQgYnkgY29tbWl0IDwzMTFmYTZhPiAoIlBNIC8gRG9tYWluczogUmV0dXJuIC1FUFJP QkVfREVGRVIKaWYgd2UgZmFpbCB0byBpbml0IG9yIHR1cm4tb24gZG9tYWluIikuCgpJdCB3YXMg dGVzdGVkIHdpdGggYmFyZWJveCBhbmQgdGhlIGZvbGxvd2luZyBzY3JpcHRzIGJlZm9yZSBib290 aW5nCmxpbnV4OgoKL2Vudi9hX29mZjoKCiAjIGNhdCAvZW52L2Ffb2ZmCiAjdHVybiBvZmYgd2hp Y2ggYXJlIGVuYWJsZWQgYnkgZGVmYXVsdAogcmVndWxhdG9yIC1uIGJjbTI4MzVfbWNpMCAtcyBk aXNhYmxlCiByZWd1bGF0b3IgLW4gdWFydDAtcGwwMTEwIC1zIGRpc2FibGUKCi9lbnYvYV9vbjoK CiAjIGNhdCAvZW52L2Ffb24KICN0dXJuIG9mZiB3aGljaCBhcmUgZW5hYmxlZCBieSBkZWZhdWx0 CiByZWd1bGF0b3IgLW4gYmNtMjgzNV9tY2kwIC1zIGRpc2FibGUKIHJlZ3VsYXRvciAtbiB1YXJ0 MC1wbDAxMTAgLXMgZGlzYWJsZQoKIHJlZ3VsYXRvciAtbiBiY20yODM1X21jaTAgLXMgZW5hYmxl CiByZWd1bGF0b3IgLW4gdWFydDAtcGwwMTEwIC1zIGVuYWJsZQogcmVndWxhdG9yIC1uIHVhcnQw LXBsMDExMSAtcyBlbmFibGUKIHJlZ3VsYXRvciAtbiBiY20yODM1X3VzYiAtcyBlbmFibGUKIHJl Z3VsYXRvciAtbiBiY20yODM1X2kyYzAgLXMgZW5hYmxlCiByZWd1bGF0b3IgLW4gYmNtMjgzNV9p MmMxIC1zIGVuYWJsZQogcmVndWxhdG9yIC1uIGJjbTI4MzVfaTJjMiAtcyBlbmFibGUKIHJlZ3Vs YXRvciAtbiBiY20yODM1X3NwaSAtcyBlbmFibGUKIHJlZ3VsYXRvciAtbiBiY20yODM1X2NjcDJ0 eCAtcyBlbmFibGUKIHJlZ3VsYXRvciAtbiBiY20yODM1X2RzaSAtcyBlbmFibGUKCi9lbnYvYjoK CiAjIGNhdCAvZW52L2IKIHNoIC9lbnYvYV9vbgoKIHJlZ3VsYXRvciAtbiBiY20yODM1X21jaTAg LXMgZGlzYWJsZQogcmVndWxhdG9yIC1uIHVhcnQwLXBsMDExMCAtcyBkaXNhYmxlCiByZWd1bGF0 b3IgLW4gdWFydDAtcGwwMTExIC1zIGRpc2FibGUKIHJlZ3VsYXRvciAtbiBiY20yODM1X3VzYiAt cyBkaXNhYmxlCiByZWd1bGF0b3IgLW4gYmNtMjgzNV9pMmMwIC1zIGRpc2FibGUKIHJlZ3VsYXRv ciAtbiBiY20yODM1X2kyYzEgLXMgZGlzYWJsZQogcmVndWxhdG9yIC1uIGJjbTI4MzVfaTJjMiAt cyBkaXNhYmxlCiByZWd1bGF0b3IgLW4gYmNtMjgzNV9zcGkgLXMgZGlzYWJsZQogcmVndWxhdG9y IC1uIGJjbTI4MzVfY2NwMnR4IC1zIGRpc2FibGUKIHJlZ3VsYXRvciAtbiBiY20yODM1X2RzaSAt cyBkaXNhYmxlCgovZW52L2M6CgogIyBjYXQgL2Vudi9jCiBzaCAuL2Vudi9iCgogcmVndWxhdG9y IC1uIGJjbTI4MzVfbWNpMCAtcyBlbmFibGUKIHJlZ3VsYXRvciAtbiB1YXJ0MC1wbDAxMTAgLXMg ZW5hYmxlCiByZWd1bGF0b3IgLW4gdWFydDAtcGwwMTExIC1zIGVuYWJsZQogcmVndWxhdG9yIC1u IGJjbTI4MzVfdXNiIC1zIGVuYWJsZQogcmVndWxhdG9yIC1uIGJjbTI4MzVfaTJjMCAtcyBlbmFi bGUKIHJlZ3VsYXRvciAtbiBiY20yODM1X2kyYzEgLXMgZW5hYmxlCiByZWd1bGF0b3IgLW4gYmNt MjgzNV9pMmMyIC1zIGVuYWJsZQogcmVndWxhdG9yIC1uIGJjbTI4MzVfc3BpIC1zIGVuYWJsZQog cmVndWxhdG9yIC1uIGJjbTI4MzVfY2NwMnR4IC1zIGVuYWJsZQogcmVndWxhdG9yIC1uIGJjbTI4 MzVfZHNpIC1zIGVuYWJsZQoKVGhlc2Ugc2NyaXB0cyBlbmFibGVzL2Rpc2FibGUgYWxsIHJlZ3Vs YXRvcnMgaW5zaWRlIHRoZSBib290bG9hZGVyLiBJdAp3YXMgcnVubmluZyB3aXRoIGEgImhhcmQi IGFuZCAic29mdCIgcmVzZXQgd2l0aG91dCBhbnkgaXNzdWVzLiBUaGVzZQp0ZXN0Y2FzZXMgc2hv dWxkIGZpdCB0byBTdGVwaGVuIFdhcnJlbiBzdWdnZXN0aW9uczoKCiIoYSkgYmVmb3JlIGhhdmlu ZyBleHBsaWNpdGx5IHR1cm5lZCB0aGUgcG93ZXIgZG9tYWluIG9uIG9yIG9mZiBhdCBhbGwgKGIp CmFmdGVyIGhhdmluZyB0dXJuZWQgaXQgb24gKGMpIGFmdGVyIGhhdmluZyB0dXJuZWQgaXQgb2Zm LCBhbmQgZm9yIGFsbApwb3dlciBkb21haW5zLiIKCkNjOiBTdGVwaGVuIFdhcnJlbiA8c3dhcnJl bkB3d3dkb3Rvcmcub3JnPgpDYzogTGVlIEpvbmVzIDxsZWVAa2VybmVsLm9yZz4KQ2M6IEVyaWMg QW5ob2x0IDxlcmljQGFuaG9sdC5uZXQ+CkNjOiBBbmR5IFdoaXRjcm9mdCA8YXB3QGNhbm9uaWNh bC5jb20+CkNjOiBKb2UgUGVyY2hlcyA8am9lQHBlcmNoZXMuY29tPgpTaWduZWQtb2ZmLWJ5OiBB bGV4YW5kZXIgQXJpbmcgPGFsZXguYXJpbmdAZ21haWwuY29tPgotLS0KRmlyc3Q6CkkgY2MnZWQg QW5keSBXaGl0Y3JvZnQgYW5kIEpvZSBQZXJjaGVzIGhlcmUsIGJlY2F1c2UgdGhpcyBwYXRjaCB3 aWxsCmdlbmVyYXRlIGEgZmFsc2UgcG9zaXRpdmUgZm9yIGNoZWNrcGF0Y2ggYW5kIGNoZWNrcGF0 Y2ggdG9sZCBtZSB0bwpjYyBjaGVja3BhdGNoIG1haW50YWluZXJzIGlmIHRoaXMgb2NjdXJzOgoK RVJST1I6IE1hY3JvcyB3aXRoIGNvbXBsZXggdmFsdWVzIHNob3VsZCBiZSBlbmNsb3NlZCBpbiBw YXJlbnRoZXNlcwojMTkxOiBGSUxFOiBkcml2ZXJzL2Zpcm13YXJlL3Jhc3BiZXJyeXBpLmM6MjY6 CisjZGVmaW5lIFJQSV9QT1dFUl9ET01BSU4oX2RvbWFpbiwgX25hbWUpCQkJXAorCVtfZG9tYWlu XSA9CQkJCQkJXAorCXsJCQkJCQkJXAouLi4KClNlY29uZDoKVGhpcyBwYXRjaCBiYXNlZCBvbiBs aW51cy9tYXN0ZXIgYW5kIHJlcXVpcmVzIHRoZSBycGktZmlybXdhcmUgcGF0Y2guCgpUaGlyZDoK VGhlIGJhcmVib3ggcmVndWxhdG9yIGRvZXNuJ3Qgc3VwcG9ydCByaWdodCBub3cgdG8gZW5hYmxl L2Rpc2FibGUKcmVndWxhdG9ycyBhdCBydW50aW1lIGJ1dCBJIHdhbnQgdG8gYnJpbmcgdGhpcyBt YWlubGluZSBpbiB0aGUgbmV4dApkYXlzLiBTbyB5b3UgY2FuJ3QgY2hlY2sgeW91cnNlbGYgaWYg dGhlIGFib3ZlIHNjcmlwdHMgd29ya2luZyByaWdodApub3cuIEkgZGVzY3JpYmUgaXQgaGVyZSB0 byBzaG93IHlvdSB3aGF0IGV4YWN0bHkgSSB0ZXN0ZWQuCgpjaGFuZ2VzIHNpbmNlIEVyaWMgQW5o b2x0cyAicG93ZXIgZG9tYWluIiBwYXRjaDoKIC0gYWRkIGZvciBtZSBhbGwga25vd24gcG93ZXIg ZG9tYWlucyBvZiB0aGUgUlBpLCBpdCBjb250YWlucyB0aGUgZG9tYWlucwogICAwIC0gOS4KIC0g QWRkIGRldmljZXRyZWUgZG9jdW1lbnRhdGlvbi4KIC0gbW92ZSBpbXBsZW1lbnRhdGlvbiB0byBk cml2ZXJzL2Zpcm13YXJlLy4uLiAoYWxzbyBLY29uZmlnIGRlcGVuZGVuY2llcykKIC0gYWRkIG1h Y3JvIFJQSV9QT1dFUl9ET01BSU4uCiAtIGFkZCBmdW5jdGlvbiAicmFzcGJlcnJ5cGlfZmlybXdh cmVfcG93ZXJfaXNfb24iIHRvIGdldCB0aGUgaW5pdGlhbCB2YWx1ZQogICBmb3IgYSAicG93ZXIg ZG9tYWluIiwgd2hpY2ggY2FuIGJlIGFzc2lnbiBvdmVyIHRoZSAiaXNfb2ZmIiBwYXJhbWV0ZXIs CiAgIHdoaWxlIHBvd2VyIGRvbWFpbiBpbml0LgogLSBQdXQgZ2VuZXJpY19wbV9kb21haW4gb24g dGhlIGhlYXAgd2l0aCBhbW91bnQgb2YgZW50cmllcyB3aGljaAogICBjb21lcyBmcm9tIEFSUkFZ X1NJWkUocnBpX3Bvd2VyX2RvbWFpbnMpLiBTbyB3ZSBkb24ndCBuZWVkIHRvIGNhcmUKICAgYWJv dXQgYm90aCBhcnJheXMgYW55bW9yZS4gQnV0IG9ubHkgd29ya3Mgc28gZmFyIHJwaV9wb3dlcl9k b21haW5zIGhhcwogICBub3QgZW1wdHkgZW50cmllcyBpbiB0aGUgbWlkZGxlLiBJIGFkZGVkIGEg bm90ZSBhYm91dCB0aGF0LCBpZiBpdCdzCiAgIHRvbyB1Z2x5IEkgd2lsbCByZW1vdmUgaXQgb3Ig YWNjZXB0IG90aGVyIHNvbHV0aW9ucy4gTWF5YmUgbWFrZQogICBycGlfcG93ZXJfZG9tYWlucyBh cyBkb3VibGUgcG9pbnRlciAoYW5kIGNhcmUgYWJvdXQgTlVMTCBlbnRyaWVzLCBhbnl3YXkuCiAg IEl0IHNob3VsZCB3b3JraW5nIGFuZCBJIHRoaW5rIHRoZXJlIGFyZSBubyBvdGhlciBkb21haW5z IGFuZCBpZiB0aGVyZSBhcmUKICAgb3RoZXIgZG9tYWlucyBhbmQgd2UgaGF2ZSBtaXNzaW5nIGVu dHJpZXMgdGhlbiBzb21ldGhpbmcgaXMgd3JvbmcuCgpOb3RlczoKCkkgd29uZGVyIG15c2VsZiB3 aGVuIEkgZGlzYWJsZSBkb21haW4gMCAoU0RIQykgSSBjYW4gc3RpbGwgYWNjZXNzIHRoZSBjYXJk LAphcyB3ZWxsIHVhcnQgaXMgYWxzbyBzdGlsbCB3b3JraW5nIGFmdGVyIHR1cm4gb2ZmIHBvd2Vy LgoKIC4uLi9hcm0vYmNtL3Jhc3BiZXJyeXBpLGJjbTI4MzUtZmlybXdhcmUudHh0ICAgICAgIHwg IDE1ICsrKwogYXJjaC9hcm0vYm9vdC9kdHMvYmNtMjgzNS1ycGkuZHRzaSAgICAgICAgICAgICAg ICAgfCAgIDYgKwogYXJjaC9hcm0vYm9vdC9kdHMvYmNtMjgzNS5kdHNpICAgICAgICAgICAgICAg ICAgICAgfCAgIDIgKy0KIGRyaXZlcnMvZmlybXdhcmUvS2NvbmZpZyAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgICAyICsKIGRyaXZlcnMvZmlybXdhcmUvcmFzcGJlcnJ5cGkuYyAgICAgICAg ICAgICAgICAgICAgIHwgMTMzICsrKysrKysrKysrKysrKysrKysrKwogLi4uL2R0LWJpbmRpbmdz L2FybS9yYXNwYmVycnlwaS1maXJtd2FyZS1wb3dlci5oICAgfCAgMjMgKysrKwogNiBmaWxlcyBj aGFuZ2VkLCAxODAgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQogY3JlYXRlIG1vZGUgMTAw NjQ0IGluY2x1ZGUvZHQtYmluZGluZ3MvYXJtL3Jhc3BiZXJyeXBpLWZpcm13YXJlLXBvd2VyLmgK CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvYXJtL2JjbS9y YXNwYmVycnlwaSxiY20yODM1LWZpcm13YXJlLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJl ZS9iaW5kaW5ncy9hcm0vYmNtL3Jhc3BiZXJyeXBpLGJjbTI4MzUtZmlybXdhcmUudHh0CmluZGV4 IDY4MjRiMzEuLjI3MjdjYTE2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUv YmluZGluZ3MvYXJtL2JjbS9yYXNwYmVycnlwaSxiY20yODM1LWZpcm13YXJlLnR4dAorKysgYi9E b2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvYXJtL2JjbS9yYXNwYmVycnlwaSxiY20y ODM1LWZpcm13YXJlLnR4dApAQCAtNSwxMCArNSwyNSBAQCBSZXF1aXJlZCBwcm9wZXJ0aWVzOgog LSBjb21wYXRpYmxlOgkJU2hvdWxkIGJlICJyYXNwYmVycnlwaSxiY20yODM1LWZpcm13YXJlIgog LSBtYm94ZXM6CQlQaGFuZGxlIHRvIHRoZSBmaXJtd2FyZSBkZXZpY2UncyBNYWlsYm94LgogCQkJ ICAoU2VlOiAuLi9tYWlsYm94L21haWxib3gudHh0IGZvciBtb3JlIGluZm9ybWF0aW9uKQorLSAj cG93ZXItZG9tYWluLWNlbGxzOglTaG91bGQgYmUgPDE+LCB3ZSBwcm92aWRpbmcgbXVsdGlwbGUg cG93ZXIgZG9tYWlucy4KKworVGhlIHZhbGlkIGRlZmluZXMgZm9yIHBvd2VyIGRvbWFpbiBhcmU6 CisKKyBSUElfUE9XRVJfRE9NQUlOX1NEQ0FSRCwgUlBJX1BPV0VSX0RPTUFJTl9VQVJUMCwgUlBJ X1BPV0VSX0RPTUFJTl9VQVJUMSwKKyBSUElfUE9XRVJfRE9NQUlOX1VTQiwgUlBJX1BPV0VSX0RP TUFJTl9JMkMwLCBSUElfUE9XRVJfRE9NQUlOX0kyQzEsCisgUlBJX1BPV0VSX0RPTUFJTl9JMkMy LCBSUElfUE9XRVJfRE9NQUlOX1NQSSwgUlBJX1BPV0VSX0RPTUFJTl9DQ1AyVFgsCisgUlBJX1BP V0VSX0RPTUFJTl9EU0kKIAogRXhhbXBsZToKIAogZmlybXdhcmUgewogCWNvbXBhdGlibGUgPSAi cmFzcGJlcnJ5cGksYmNtMjgzNS1maXJtd2FyZSI7CiAJbWJveGVzID0gPCZtYWlsYm94PjsKKwkj cG93ZXItZG9tYWluLWNlbGxzID0gPDE+OworfTsKKworRXhhbXBsZSBmb3IgdXNpbmcgcG93ZXIg ZG9tYWluOgorCismdXNiIHsKKyAgICAgICBwb3dlci1kb21haW5zID0gPCZmaXJtd2FyZSBSUElf UE9XRVJfRE9NQUlOX1VTQj47CiB9OwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vYm9vdC9kdHMvYmNt MjgzNS1ycGkuZHRzaSBiL2FyY2gvYXJtL2Jvb3QvZHRzL2JjbTI4MzUtcnBpLmR0c2kKaW5kZXgg YWI1NDc0ZS4uN2YxOTM1MiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vYm9vdC9kdHMvYmNtMjgzNS1y cGkuZHRzaQorKysgYi9hcmNoL2FybS9ib290L2R0cy9iY20yODM1LXJwaS5kdHNpCkBAIC0xLDMg KzEsNCBAQAorI2luY2x1ZGUgPGR0LWJpbmRpbmdzL2FybS9yYXNwYmVycnlwaS1maXJtd2FyZS1w b3dlci5oPgogI2luY2x1ZGUgImJjbTI4MzUuZHRzaSIKIAogLyB7CkBAIC0xOSw2ICsyMCw3IEBA CiAJCWZpcm13YXJlOiBmaXJtd2FyZSB7CiAJCQljb21wYXRpYmxlID0gInJhc3BiZXJyeXBpLGJj bTI4MzUtZmlybXdhcmUiOwogCQkJbWJveGVzID0gPCZtYWlsYm94PjsKKwkJCSNwb3dlci1kb21h aW4tY2VsbHMgPSA8MT47CiAJCX07CiAJfTsKIH07CkBAIC01NiwzICs1OCw3IEBACiAJc3RhdHVz ID0gIm9rYXkiOwogCWJ1cy13aWR0aCA9IDw0PjsKIH07CisKKyZ1c2IgeworCXBvd2VyLWRvbWFp bnMgPSA8JmZpcm13YXJlIFJQSV9QT1dFUl9ET01BSU5fVVNCPjsKK307CmRpZmYgLS1naXQgYS9h cmNoL2FybS9ib290L2R0cy9iY20yODM1LmR0c2kgYi9hcmNoL2FybS9ib290L2R0cy9iY20yODM1 LmR0c2kKaW5kZXggMzAxYzczZi4uM2M4OTliMyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vYm9vdC9k dHMvYmNtMjgzNS5kdHNpCisrKyBiL2FyY2gvYXJtL2Jvb3QvZHRzL2JjbTI4MzUuZHRzaQpAQCAt MTQ5LDcgKzE0OSw3IEBACiAJCQlzdGF0dXMgPSAiZGlzYWJsZWQiOwogCQl9OwogCi0JCXVzYkA3 ZTk4MDAwMCB7CisJCXVzYjogdXNiQDdlOTgwMDAwIHsKIAkJCWNvbXBhdGlibGUgPSAiYnJjbSxi Y20yODM1LXVzYiI7CiAJCQlyZWcgPSA8MHg3ZTk4MDAwMCAweDEwMDAwPjsKIAkJCWludGVycnVw dHMgPSA8MSA5PjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZmlybXdhcmUvS2NvbmZpZyBiL2RyaXZl cnMvZmlybXdhcmUvS2NvbmZpZwppbmRleCA3MTgxMTI2Li44OTgxNTk5IDEwMDY0NAotLS0gYS9k cml2ZXJzL2Zpcm13YXJlL0tjb25maWcKKysrIGIvZHJpdmVycy9maXJtd2FyZS9LY29uZmlnCkBA IC0xNTAsNiArMTUwLDggQEAgY29uZmlnIFFDT01fU0NNXzY0CiBjb25maWcgUkFTUEJFUlJZUElf RklSTVdBUkUKIAl0cmlzdGF0ZSAiUmFzcGJlcnJ5IFBpIEZpcm13YXJlIERyaXZlciIKIAlkZXBl bmRzIG9uIEJDTTI4MzVfTUJPWAorCXNlbGVjdCBQTV9HRU5FUklDX0RPTUFJTlMgaWYgUE0KKwlz ZWxlY3QgUE1fR0VORVJJQ19ET01BSU5TX09GIGlmIFBNCiAJaGVscAogCSAgVGhpcyBvcHRpb24g ZW5hYmxlcyBzdXBwb3J0IGZvciBjb21tdW5pY2F0aW5nIHdpdGggdGhlIGZpcm13YXJlIG9uIHRo ZQogCSAgUmFzcGJlcnJ5IFBpLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9maXJtd2FyZS9yYXNwYmVy cnlwaS5jIGIvZHJpdmVycy9maXJtd2FyZS9yYXNwYmVycnlwaS5jCmluZGV4IGRkNTA2Y2QzLi5l OGRiNzVlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Zpcm13YXJlL3Jhc3BiZXJyeXBpLmMKKysrIGIv ZHJpdmVycy9maXJtd2FyZS9yYXNwYmVycnlwaS5jCkBAIC0xNCw2ICsxNCw4IEBACiAjaW5jbHVk ZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvb2ZfcGxhdGZvcm0uaD4KICNpbmNs dWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9wbV9kb21haW4u aD4KKyNpbmNsdWRlIDxkdC1iaW5kaW5ncy9hcm0vcmFzcGJlcnJ5cGktZmlybXdhcmUtcG93ZXIu aD4KICNpbmNsdWRlIDxzb2MvYmNtMjgzNS9yYXNwYmVycnlwaS1maXJtd2FyZS5oPgogCiAjZGVm aW5lIE1CT1hfTVNHKGNoYW4sIGRhdGEyOCkJCSgoKGRhdGEyOCkgJiB+MHhmKSB8ICgoY2hhbikg JiAweGYpKQpAQCAtMjEsNyArMjMsMTkgQEAKICNkZWZpbmUgTUJPWF9EQVRBMjgobXNnKQkJKCht c2cpICYgfjB4ZikKICNkZWZpbmUgTUJPWF9DSEFOX1BST1BFUlRZCQk4CiAKKyNkZWZpbmUgUlBJ X1BPV0VSX0RPTUFJTihfZG9tYWluLCBfbmFtZSkJCQlcCisJW19kb21haW5dID0JCQkJCQlcCisJ ewkJCQkJCQlcCisJCS5kb21haW4gPSBfZG9tYWluLAkJCQlcCisJCS5iYXNlID0gewkJCQkJXAor CQkJLm5hbWUgPSBfbmFtZSwJCQkJXAorCQkJLnBvd2VyX29mZiA9IHJhc3BiZXJyeXBpX2RvbWFp bl9vZmYsCVwKKwkJCS5wb3dlcl9vbiA9IHJhc3BiZXJyeXBpX2RvbWFpbl9vbiwJXAorCQl9LAkJ CQkJCVwKKwl9CisKIHN0cnVjdCBycGlfZmlybXdhcmUgeworCXN0cnVjdCBnZW5wZF9vbmVjZWxs X2RhdGEgZ2VucGRfeGxhdGU7CiAJc3RydWN0IG1ib3hfY2xpZW50IGNsOwogCXN0cnVjdCBtYm94 X2NoYW4gKmNoYW47IC8qIFRoZSBwcm9wZXJ0eSBjaGFubmVsLiAqLwogCXN0cnVjdCBjb21wbGV0 aW9uIGM7CkBAIC0zMCw2ICs0NCwxNyBAQCBzdHJ1Y3QgcnBpX2Zpcm13YXJlIHsKIAogc3RhdGlj IERFRklORV9NVVRFWCh0cmFuc2FjdGlvbl9sb2NrKTsKIAorc3RydWN0IHJhc3BiZXJyeXBpX3Bv d2VyX2RvbWFpbiB7CisJc3RydWN0IHJwaV9maXJtd2FyZSAqZnc7CisJdTMyIGRvbWFpbjsKKwlz dHJ1Y3QgZ2VuZXJpY19wbV9kb21haW4gYmFzZTsKK307CisKK3N0cnVjdCBycGlfcG93ZXJfZG9t YWluX3BhY2tldCB7CisJdTMyIGRvbWFpbjsKKwl1MzIgb247Cit9IF9fcGFja2V0OworCiBzdGF0 aWMgdm9pZCByZXNwb25zZV9jYWxsYmFjayhzdHJ1Y3QgbWJveF9jbGllbnQgKmNsLCB2b2lkICpt c2cpCiB7CiAJc3RydWN0IHJwaV9maXJtd2FyZSAqZncgPSBjb250YWluZXJfb2YoY2wsIHN0cnVj dCBycGlfZmlybXdhcmUsIGNsKTsKQEAgLTE4MywxMCArMjA4LDg0IEBAIHJwaV9maXJtd2FyZV9w cmludF9maXJtd2FyZV9yZXZpc2lvbihzdHJ1Y3QgcnBpX2Zpcm13YXJlICpmdykKIAl9CiB9CiAK Ky8qCisgKiBBc2tzIHRoZSBmaXJtd2FyZSB0byBlbmFibGUgb3IgZGlzYWJsZSBwb3dlciBvbiBh IHNwZWNpZmljIHBvd2VyCisgKiBkb21haW4uCisgKi8KK3N0YXRpYyBpbnQgcmFzcGJlcnJ5cGlf ZmlybXdhcmVfc2V0X3Bvd2VyKHN0cnVjdCBycGlfZmlybXdhcmUgKmZ3LAorCQkJCQkgIHUzMiBk b21haW4sIGJvb2wgb24pCit7CisJc3RydWN0IHJwaV9wb3dlcl9kb21haW5fcGFja2V0IHBhY2tl dDsKKwlpbnQgcmV0OworCisJcGFja2V0LmRvbWFpbiA9IGRvbWFpbjsKKwlwYWNrZXQub24gPSBv bjsKKwlyZXQgPSBycGlfZmlybXdhcmVfcHJvcGVydHkoZncsIFJQSV9GSVJNV0FSRV9TRVRfUE9X RVJfU1RBVEUsICZwYWNrZXQsCisJCQkJICAgIHNpemVvZihwYWNrZXQpKTsKKwlpZiAoIXJldCAm JiAhcGFja2V0Lm9uKQorCQlyZXQgPSAtRUlOVkFMOworCisJcmV0dXJuIHJldDsKK30KKworLyog QXNrcyB0aGUgZmlybXdhcmUgdG8gaWYgcG93ZXIgaXMgb24gZm9yIGEgc3BlY2lmaWMgcG93ZXIg ZG9tYWluLiAqLworc3RhdGljIGludCByYXNwYmVycnlwaV9maXJtd2FyZV9wb3dlcl9pc19vbihz dHJ1Y3QgcnBpX2Zpcm13YXJlICpmdywKKwkJCQkJICAgIHUzMiBkb21haW4pCit7CisJc3RydWN0 IHJwaV9wb3dlcl9kb21haW5fcGFja2V0IHBhY2tldDsKKwlpbnQgcmV0OworCisJcGFja2V0LmRv bWFpbiA9IGRvbWFpbjsKKwlyZXQgPSBycGlfZmlybXdhcmVfcHJvcGVydHkoZncsIFJQSV9GSVJN V0FSRV9HRVRfUE9XRVJfU1RBVEUsICZwYWNrZXQsCisJCQkJICAgIHNpemVvZihwYWNrZXQpKTsK KwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCXJldHVybiBwYWNrZXQub24gJiBCSVQo MCk7Cit9CisKK3N0YXRpYyBpbnQgcmFzcGJlcnJ5cGlfZG9tYWluX29mZihzdHJ1Y3QgZ2VuZXJp Y19wbV9kb21haW4gKmRvbWFpbikKK3sKKwlzdHJ1Y3QgcmFzcGJlcnJ5cGlfcG93ZXJfZG9tYWlu ICpyYXNwYmVycnBpX2RvbWFpbiA9CisJCWNvbnRhaW5lcl9vZihkb21haW4sIHN0cnVjdCByYXNw YmVycnlwaV9wb3dlcl9kb21haW4sIGJhc2UpOworCisJcmV0dXJuIHJhc3BiZXJyeXBpX2Zpcm13 YXJlX3NldF9wb3dlcihyYXNwYmVycnBpX2RvbWFpbi0+ZncsCisJCQkJCSAgICAgIHJhc3BiZXJy cGlfZG9tYWluLT5kb21haW4sIGZhbHNlKTsKK30KKworc3RhdGljIGludCByYXNwYmVycnlwaV9k b21haW5fb24oc3RydWN0IGdlbmVyaWNfcG1fZG9tYWluICpkb21haW4pCit7CisJc3RydWN0IHJh c3BiZXJyeXBpX3Bvd2VyX2RvbWFpbiAqcmFzcGJlcnJwaV9kb21haW4gPQorCQljb250YWluZXJf b2YoZG9tYWluLCBzdHJ1Y3QgcmFzcGJlcnJ5cGlfcG93ZXJfZG9tYWluLCBiYXNlKTsKKworCXJl dHVybiByYXNwYmVycnlwaV9maXJtd2FyZV9zZXRfcG93ZXIocmFzcGJlcnJwaV9kb21haW4tPmZ3 LAorCQkJCQkgICAgICByYXNwYmVycnBpX2RvbWFpbi0+ZG9tYWluLCB0cnVlKTsKK30KKworLyoK KyAqIElNUE9SVEFOVDogYmUgc3VyZSB0aGlzIGFycmF5IGhhcyBubyBlbnRyaWVzIHdoaWNoIGFy ZSBub3Qgc3BlY2lmaWVkCisgKiBiZXR3ZWVuIG90aGVycyBieSBSUElfUE9XRVJfRE9NQUlOLCBv dGhlcndpc2UgbWFwcGluZyBiZXR3ZWVuCisgKiBnZW5lcmljX3BtX2RvbWFpbiBhcnJheSBkb2Vz bid0IHdvcmsgYW55bW9yZS4KKyAqLworc3RhdGljIHN0cnVjdCByYXNwYmVycnlwaV9wb3dlcl9k b21haW4gcnBpX3Bvd2VyX2RvbWFpbnNbXSA9IHsKKwlSUElfUE9XRVJfRE9NQUlOKFJQSV9QT1dF Ul9ET01BSU5fU0RDQVJELCAiU0RDQVJEIiksCisJUlBJX1BPV0VSX0RPTUFJTihSUElfUE9XRVJf RE9NQUlOX1VBUlQwLCAiVUFSVDAiKSwKKwlSUElfUE9XRVJfRE9NQUlOKFJQSV9QT1dFUl9ET01B SU5fVUFSVDEsICJVQVJUMSIpLAorCVJQSV9QT1dFUl9ET01BSU4oUlBJX1BPV0VSX0RPTUFJTl9V U0IsICJVU0IiKSwKKwlSUElfUE9XRVJfRE9NQUlOKFJQSV9QT1dFUl9ET01BSU5fSTJDMCwgIkky QzAiKSwKKwlSUElfUE9XRVJfRE9NQUlOKFJQSV9QT1dFUl9ET01BSU5fSTJDMSwgIkkyQzEiKSwK KwlSUElfUE9XRVJfRE9NQUlOKFJQSV9QT1dFUl9ET01BSU5fSTJDMiwgIkkyQzIiKSwKKwlSUElf UE9XRVJfRE9NQUlOKFJQSV9QT1dFUl9ET01BSU5fU1BJLCAiU1BJIiksCisJUlBJX1BPV0VSX0RP TUFJTihSUElfUE9XRVJfRE9NQUlOX0NDUDJUWCwgIkNDUDJUWCIpLAorCVJQSV9QT1dFUl9ET01B SU4oUlBJX1BPV0VSX0RPTUFJTl9EU0ksICJEU0kiKSwKK307CisKIHN0YXRpYyBpbnQgcnBpX2Zp cm13YXJlX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiB7CiAJc3RydWN0IGRl dmljZSAqZGV2ID0gJnBkZXYtPmRldjsKIAlzdHJ1Y3QgcnBpX2Zpcm13YXJlICpmdzsKKwlzdHJ1 Y3QgZ2VuZXJpY19wbV9kb21haW4gKipwb3dlcl9kb21haW5zOworCWludCBpLCByZXQsIG51bV9k b21haW5zID0gQVJSQVlfU0laRShycGlfcG93ZXJfZG9tYWlucyk7CiAKIAlmdyA9IGRldm1fa3ph bGxvYyhkZXYsIHNpemVvZigqZncpLCBHRlBfS0VSTkVMKTsKIAlpZiAoIWZ3KQpAQCAtMTk2LDYg KzI5NSwxMSBAQCBzdGF0aWMgaW50IHJwaV9maXJtd2FyZV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1f ZGV2aWNlICpwZGV2KQogCWZ3LT5jbC5yeF9jYWxsYmFjayA9IHJlc3BvbnNlX2NhbGxiYWNrOwog CWZ3LT5jbC50eF9ibG9jayA9IHRydWU7CiAKKwlwb3dlcl9kb21haW5zID0gZGV2bV9remFsbG9j KGRldiwgc2l6ZW9mKCpwb3dlcl9kb21haW5zKSAqIG51bV9kb21haW5zLAorCQkJCSAgICAgR0ZQ X0tFUk5FTCk7CisJaWYgKCFwb3dlcl9kb21haW5zKQorCQlyZXR1cm4gLUVOT01FTTsKKwogCWZ3 LT5jaGFuID0gbWJveF9yZXF1ZXN0X2NoYW5uZWwoJmZ3LT5jbCwgMCk7CiAJaWYgKElTX0VSUihm dy0+Y2hhbikpIHsKIAkJaW50IHJldCA9IFBUUl9FUlIoZnctPmNoYW4pOwpAQCAtMjA4LDE1ICsz MTIsNDQgQEAgc3RhdGljIGludCBycGlfZmlybXdhcmVfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGRldikKIAogCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIGZ3KTsKIAorCWZ3LT5n ZW5wZF94bGF0ZS5kb21haW5zID0gcG93ZXJfZG9tYWluczsKKwlmdy0+Z2VucGRfeGxhdGUubnVt X2RvbWFpbnMgPSBudW1fZG9tYWluczsKKworCWZvciAoaSA9IDA7IGkgPCBudW1fZG9tYWluczsg aSsrKSB7CisJCWJvb2wgaXNfb2ZmOworCisJCXJwaV9wb3dlcl9kb21haW5zW2ldLmZ3ID0gZnc7 CisJCXBvd2VyX2RvbWFpbnNbaV0gPSAmcnBpX3Bvd2VyX2RvbWFpbnNbaV0uYmFzZTsKKworCQkv KiBnZXQgdGhlIGluaXRpYWwgc3RhdGUgKi8KKwkJcmV0ID0gcmFzcGJlcnJ5cGlfZmlybXdhcmVf cG93ZXJfaXNfb24oZncsIGkpOworCQlpZiAocmV0IDwgMCkKKwkJCWdvdG8gbWJveDsKKworCQkv KiBwbV9nZW5wZF9pbml0IG5lZWRzIGlzX29mZiwgaW52ZXJ0IHRoZSBsb2dpYyBoZXJlICovCisJ CWlzX29mZiA9ICFyZXQ7CisJCXBtX2dlbnBkX2luaXQocG93ZXJfZG9tYWluc1tpXSwgTlVMTCwg aXNfb2ZmKTsKKwl9CisKKwlyZXQgPSBvZl9nZW5wZF9hZGRfcHJvdmlkZXJfb25lY2VsbChkZXYt Pm9mX25vZGUsICZmdy0+Z2VucGRfeGxhdGUpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIG1ib3g7 CisKIAlycGlfZmlybXdhcmVfcHJpbnRfZmlybXdhcmVfcmV2aXNpb24oZncpOwogCiAJcmV0dXJu IDA7CisKK21ib3g6CisJbWJveF9mcmVlX2NoYW5uZWwoZnctPmNoYW4pOworCXJldHVybiByZXQ7 CiB9CiAKIHN0YXRpYyBpbnQgcnBpX2Zpcm13YXJlX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2 aWNlICpwZGV2KQogewogCXN0cnVjdCBycGlfZmlybXdhcmUgKmZ3ID0gcGxhdGZvcm1fZ2V0X2Ry dmRhdGEocGRldik7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKIAorCW9mX2dl bnBkX2RlbF9wcm92aWRlcihkZXYtPm9mX25vZGUpOwogCW1ib3hfZnJlZV9jaGFubmVsKGZ3LT5j aGFuKTsKIAogCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kdC1iaW5kaW5ncy9hcm0v cmFzcGJlcnJ5cGktZmlybXdhcmUtcG93ZXIuaCBiL2luY2x1ZGUvZHQtYmluZGluZ3MvYXJtL3Jh c3BiZXJyeXBpLWZpcm13YXJlLXBvd2VyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMC4uYzM2M2ExZgotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUvZHQtYmluZGluZ3MvYXJt L3Jhc3BiZXJyeXBpLWZpcm13YXJlLXBvd2VyLmgKQEAgLTAsMCArMSwyMyBAQAorLyoKKyAqICBD b3B5cmlnaHQgwqkgMjAxNSBCcm9hZGNvbQorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNv ZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRl ciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBh cworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKi8KKwor I2lmbmRlZiBfRFRfQklORElOR1NfQVJNX0JDTTI4MzVfTUJPWF9QT1dFUl9ICisjZGVmaW5lIF9E VF9CSU5ESU5HU19BUk1fQkNNMjgzNV9NQk9YX1BPV0VSX0gKKworI2RlZmluZSBSUElfUE9XRVJf RE9NQUlOX1NEQ0FSRAkwCisjZGVmaW5lIFJQSV9QT1dFUl9ET01BSU5fVUFSVDAJMQorI2RlZmlu ZSBSUElfUE9XRVJfRE9NQUlOX1VBUlQxCTIKKyNkZWZpbmUgUlBJX1BPV0VSX0RPTUFJTl9VU0IJ MworI2RlZmluZSBSUElfUE9XRVJfRE9NQUlOX0kyQzAJNAorI2RlZmluZSBSUElfUE9XRVJfRE9N QUlOX0kyQzEJNQorI2RlZmluZSBSUElfUE9XRVJfRE9NQUlOX0kyQzIJNgorI2RlZmluZSBSUElf UE9XRVJfRE9NQUlOX1NQSQk3CisjZGVmaW5lIFJQSV9QT1dFUl9ET01BSU5fQ0NQMlRYCTgKKyNk ZWZpbmUgUlBJX1BPV0VSX0RPTUFJTl9EU0kJOQorCisjZW5kaWYgLyogX0RUX0JJTkRJTkdTX0FS TV9CQ00yODM1X01CT1hfUE9XRVJfSCAqLwotLSAKMi42LjEKCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlz dApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJh ZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==