From mboxrd@z Thu Jan 1 00:00:00 1970 From: florian@openwrt.org (Florian Fainelli) Date: Mon, 16 Jul 2012 14:43:25 +0200 Subject: [PATCH 1/8] ARM: support for Moschip MCS814x SoCs In-Reply-To: <20120716142941.666d928c@skate> References: <1342363754-30808-1-git-send-email-florian@openwrt.org> <1342363754-30808-2-git-send-email-florian@openwrt.org> <20120716142941.666d928c@skate> Message-ID: <7233708.5ojzueYxjb@flexo> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Hi Thomas, On Monday 16 July 2012 14:29:41 Thomas Petazzoni wrote: > Hello Florian, > > Le Sun, 15 Jul 2012 16:49:07 +0200, > Florian Fainelli a ?crit : > > > diff --git a/arch/arm/mach-mcs814x/Makefile.boot b/arch/arm/mach- mcs814x/Makefile.boot > > new file mode 100644 > > index 0000000..414db8b > > --- /dev/null > > +++ b/arch/arm/mach-mcs814x/Makefile.boot > > @@ -0,0 +1,3 @@ > > + zreladdr-y := 0x00008000 > > + params_phys-y := 0x00000008 > > + initrd_phys-y := 0x00400000 > > params_phys-y and initrd_phys-y are useless for DT-based platforms, if > I'm correct. Indeed, only zreladdr is actually required. > > > diff --git a/arch/arm/mach-mcs814x/clock.c b/arch/arm/mach-mcs814x/clock.c > > new file mode 100644 > > index 0000000..eb30ae2 > > --- /dev/null > > +++ b/arch/arm/mach-mcs814x/clock.c [snip] > > You should rather use the new clock framework instead of providing your > own implementation of the clk_*() API. And therefore your clock driver > should be in drivers/clk/ instead. Since I was targetting 3.6 initially I more or less used what was existing by the time I wrote the patches, but I will do this. > > > +struct cpu_mode { > > + const char *name; > > + int gpio_start; > > + int gpio_end; > > +}; > > + > > +static const struct cpu_mode cpu_modes[] = { > > + { > > + .name = "I2S", > > + .gpio_start = 4, > > + .gpio_end = 8, > > + }, > > + { > > + .name = "UART", > > + .gpio_start = 4, > > + .gpio_end = 9, > > + }, > > + { > > + .name = "External MII", > > + .gpio_start = 0, > > + .gpio_end = 16, > > + }, > > + { > > + .name = "Normal", > > + .gpio_start = -1, > > + .gpio_end = -1, > > + }, > > +}; > > + > > +void __init mcs814x_init_machine(void) > > +{ > > + u32 bs2, cpu_mode; > > + int gpio; > > + > > + bs2 = __raw_readl(mcs814x_sysdbg_base + SYSDBG_BS2); > > + cpu_mode = (bs2 >> CPU_MODE_SHIFT) & CPU_MODE_MASK; > > + > > + pr_info("CPU mode: %s\n", cpu_modes[cpu_mode].name); > > + > > + /* request the gpios since the pins are muxed for functionnality */ > > + for (gpio = cpu_modes[cpu_mode].gpio_start; > > + gpio == cpu_modes[cpu_mode].gpio_end; gpio++) { > > + if (gpio != -1) > > + gpio_request(gpio, cpu_modes[cpu_mode].name); > > I am not sure here, but shouldn't this be done with the pinctrl > subsystem instead? This muxing is actually hardwired with the bootstrap register setting. I could also even remove this because the underlying hardware block actually does not need to use the GPIOs, they will be configured as pins for the corresponding functions directly. This is also not runtime modifiable. I just thought that marking these GPIOs as reserved by the corresponding functionnality could help the user figuring out what is happening with them. > > > +void __init mcs814x_map_io(void) > > +{ > > + iotable_init(mcs814x_io_desc, ARRAY_SIZE(mcs814x_io_desc)); > > + > > + mcs814x_sysdbg_base = ioremap(MCS814X_IO_START + MCS814X_SYSDBG, > > + MCS814X_SYSDBG_SIZE); > > + if (!mcs814x_sysdbg_base) > > + panic("unable to remap sysdbg base"); > > Any reason to have a static mapping initialized with iotable_init() and > then a dynamic mapping initialized with ioremap() ? I thought that > ioremap() wasn't ready at the ->map_io() time, and it was therefore the > reason we had static mappings. There are no particular reasons, I could use the the define for the virtual address directly. > > > diff --git a/arch/arm/mach-mcs814x/include/mach/entry-macro.S b/arch/arm/mach-mcs814x/include/mach/entry-macro.S > > new file mode 100644 > > index 0000000..cbad566 > > --- /dev/null > > +++ b/arch/arm/mach-mcs814x/include/mach/entry-macro.S > > @@ -0,0 +1,29 @@ > > +#include > > + .macro disable_fiq > > + .endm > > + > > + .macro arch_ret_to_user, tmp1, tmp2 > > + .endm > > + > > + .macro get_irqnr_preamble, base, tmp > > + ldr \base, =mcs814x_intc_base@ base virtual address of INTC > > + ldr \base, [\base] > > + .endm > > + > > + .macro get_irqnr_and_base, irqnr, irqstat, base, tmp > > + mov \tmp, #MCS814X_IRQ_STS0 @ load tmp with STS0 register offset > > + ldr \irqstat, [\base, \tmp] @ load value at base + tmp > > + tst \irqstat, \irqstat @ test if no active IRQ's > > + beq 1002f @ if no active irqs return with status 0 > > + mov \irqnr, #0 @ start from irq zero > > + mov \tmp, #1 @ the mask initially 1 > > +1001: > > + tst \irqstat, \tmp @ and with mask > > + addeq \irqnr, \irqnr, #1 @ if zero then add one to nr > > + moveq \tmp, \tmp, lsl #1 @ shift mask one to left > > + beq 1001b @ if zero then loop again > > + mov \irqstat, \tmp @ save the return mask > > + mov \tmp, #MCS814X_IRQ_STS0 @ load tmp with ICR offset > > + str \irqstat, [\base, \tmp] @ clear irq with selected mask > > +1002: > > + .endm > > Hum, you should instead use the MULTI_IRQ_HANDLER feature so that this > can be written in C. Last I did this, I managed to get interrupt handling issues with Ethernet, but I will try to address this. So far, since we support only MCS8140 this is not a problem, MCS8142 also has the same interrupt controller. > > > diff --git a/arch/arm/mach-mcs814x/include/mach/hardware.h b/arch/arm/mach- mcs814x/include/mach/hardware.h > > new file mode 100644 > > index 0000000..529f648 > > --- /dev/null > > +++ b/arch/arm/mach-mcs814x/include/mach/hardware.h > > @@ -0,0 +1,16 @@ > > +/* > > + * Copyright (C) 2003 Artec Design Ltd. > > + * > > + * 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 __ASM_ARCH_HARDWARE_H > > +#define __ASM_ARCH_HARDWARE_H > > This #define name no longer looks consistent with where the file is > located. Right, thanks! > > > +#include "mcs814x.h" > > + > > +#endif > > + > > diff --git a/arch/arm/mach-mcs814x/include/mach/irqs.h b/arch/arm/mach- mcs814x/include/mach/irqs.h > > new file mode 100644 > > index 0000000..78021d1 > > --- /dev/null > > +++ b/arch/arm/mach-mcs814x/include/mach/irqs.h > > @@ -0,0 +1,22 @@ > > +/* > > + * Copyright (C) 2003 Artec Design Ltd. > > + * > > + * 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 __ASM_ARCH_IRQS_H > > +#define __ASM_ARCH_IRQS_H > > + > > +#define FIQ_START 0 > > + > > +#define NR_IRQS 32 > > I think this shouldn't be needed if you use SPARSE_IRQ support. > > > +#define IRQ_PCI_INTA 22 > > +#define IRQ_PCI_INTB 23 > > +#define IRQ_PCI_INTC 24 > > +#define IRQ_PCI_INTD 26 > > And these probably belong to the DT somehow? This would need a complete PCI irq mapping representation, so far we have the DT properties, but not the corresponding code to parse them. I would not qualify this as a major blocker. > > > diff --git a/arch/arm/mach-mcs814x/timer.c b/arch/arm/mach-mcs814x/timer.c > > new file mode 100644 > > index 0000000..e8408e4 [snip] > > + > > +static void __init mcs814x_timer_init(void) > > +{ > > + struct clk *clk; > > + > > + clk = clk_get_sys("timer0", NULL); > > + if (IS_ERR_OR_NULL(clk)) > > + panic("unable to get timer0 clock"); > > + > > + clock_rate = clk_get_rate(clk); > > + clk_put(clk); > > + > > + mcs814x_of_timer_init(); > > + > > + pr_info("Timer frequency: %d (kHz)\n", clock_rate / 1000); > > + > > + timer_reload_value = 0xffffffff - (clock_rate / HZ); > > + > > + /* disable timer */ > > + __raw_writel(0, mcs814x_timer_base + TIMER_CTL); > > + __raw_writel(timer_reload_value, mcs814x_timer_base + TIMER_VAL); > > + last_reload = timer_reload_value; > > + > > + setup_irq(mcs814x_timer_irq.irq, &mcs814x_timer_irq); > > + /* enable timer, stop timer in debug mode */ > > + __raw_writel(0x03, mcs814x_timer_base + TIMER_CTL); > > +} > > + > > +struct sys_timer mcs814x_timer = { > > + .init = mcs814x_timer_init, > > + .offset = mcs814x_gettimeoffset, > > +}; > > I am surprised that this doesn't use the clocksource and clockevents > infrastructure. It probably should, and be implemented in > drivers/clocksource/. I will look into this, considering that we still have 2 timers left available (64-bits and 16-bits) this should be doable. Thank you for your comments, I will wait a little more for other people to come up before coming up with a patch respin. -- Florian From mboxrd@z Thu Jan 1 00:00:00 1970 From: Florian Fainelli Subject: Re: [PATCH 1/8] ARM: support for Moschip MCS814x SoCs Date: Mon, 16 Jul 2012 14:43:25 +0200 Message-ID: <7233708.5ojzueYxjb@flexo> References: <1342363754-30808-1-git-send-email-florian@openwrt.org> <1342363754-30808-2-git-send-email-florian@openwrt.org> <20120716142941.666d928c@skate> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20120716142941.666d928c@skate> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: linux-arm-kernel-bounces@lists.infradead.org Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=m.gmane.org@lists.infradead.org To: Thomas Petazzoni Cc: olof@lixom.net, devicetree-discuss@lists.ozlabs.org, arnd@arndb.de, linux-arm-kernel@lists.infradead.org List-Id: devicetree@vger.kernel.org SGkgVGhvbWFzLAoKT24gTW9uZGF5IDE2IEp1bHkgMjAxMiAxNDoyOTo0MSBUaG9tYXMgUGV0YXp6 b25pIHdyb3RlOgo+IEhlbGxvIEZsb3JpYW4sCj4gCj4gTGUgU3VuLCAxNSBKdWwgMjAxMiAxNjo0 OTowNyArMDIwMCwKPiBGbG9yaWFuIEZhaW5lbGxpIDxmbG9yaWFuQG9wZW53cnQub3JnPiBhIMOp Y3JpdCA6Cj4gCj4gPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1tY3M4MTR4L01ha2VmaWxl LmJvb3QgYi9hcmNoL2FybS9tYWNoLQptY3M4MTR4L01ha2VmaWxlLmJvb3QKPiA+IG5ldyBmaWxl IG1vZGUgMTAwNjQ0Cj4gPiBpbmRleCAwMDAwMDAwLi40MTRkYjhiCj4gPiAtLS0gL2Rldi9udWxs Cj4gPiArKysgYi9hcmNoL2FybS9tYWNoLW1jczgxNHgvTWFrZWZpbGUuYm9vdAo+ID4gQEAgLTAs MCArMSwzIEBACj4gPiArICAgIHpyZWxhZGRyLXkgOj0gMHgwMDAwODAwMAo+ID4gKyBwYXJhbXNf cGh5cy15IDo9IDB4MDAwMDAwMDgKPiA+ICsgaW5pdHJkX3BoeXMteSA6PSAweDAwNDAwMDAwCj4g Cj4gcGFyYW1zX3BoeXMteSBhbmQgaW5pdHJkX3BoeXMteSBhcmUgdXNlbGVzcyBmb3IgRFQtYmFz ZWQgcGxhdGZvcm1zLCBpZgo+IEknbSBjb3JyZWN0LgoKSW5kZWVkLCBvbmx5IHpyZWxhZGRyIGlz IGFjdHVhbGx5IHJlcXVpcmVkLgoKPiAKPiA+IGRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW1j czgxNHgvY2xvY2suYyBiL2FyY2gvYXJtL21hY2gtbWNzODE0eC9jbG9jay5jCj4gPiBuZXcgZmls ZSBtb2RlIDEwMDY0NAo+ID4gaW5kZXggMDAwMDAwMC4uZWIzMGFlMgo+ID4gLS0tIC9kZXYvbnVs bAo+ID4gKysrIGIvYXJjaC9hcm0vbWFjaC1tY3M4MTR4L2Nsb2NrLmMKW3NuaXBdCj4gCj4gWW91 IHNob3VsZCByYXRoZXIgdXNlIHRoZSBuZXcgY2xvY2sgZnJhbWV3b3JrIGluc3RlYWQgb2YgcHJv dmlkaW5nIHlvdXIKPiBvd24gaW1wbGVtZW50YXRpb24gb2YgdGhlIGNsa18qKCkgQVBJLiBBbmQg dGhlcmVmb3JlIHlvdXIgY2xvY2sgZHJpdmVyCj4gc2hvdWxkIGJlIGluIGRyaXZlcnMvY2xrLyBp bnN0ZWFkLgoKU2luY2UgSSB3YXMgdGFyZ2V0dGluZyAzLjYgaW5pdGlhbGx5IEkgbW9yZSBvciBs ZXNzIHVzZWQgd2hhdCB3YXMgZXhpc3RpbmcgYnkgCnRoZSB0aW1lIEkgd3JvdGUgdGhlIHBhdGNo ZXMsIGJ1dCBJIHdpbGwgZG8gdGhpcy4KCj4gCj4gPiArc3RydWN0IGNwdV9tb2RlIHsKPiA+ICsJ Y29uc3QgY2hhciAqbmFtZTsKPiA+ICsJaW50IGdwaW9fc3RhcnQ7Cj4gPiArCWludCBncGlvX2Vu ZDsKPiA+ICt9Owo+ID4gKwo+ID4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgY3B1X21vZGUgY3B1X21v ZGVzW10gPSB7Cj4gPiArCXsKPiA+ICsJCS5uYW1lCQk9ICJJMlMiLAo+ID4gKwkJLmdwaW9fc3Rh cnQJPSA0LAo+ID4gKwkJLmdwaW9fZW5kCT0gOCwKPiA+ICsJfSwKPiA+ICsJewo+ID4gKwkJLm5h bWUJCT0gIlVBUlQiLAo+ID4gKwkJLmdwaW9fc3RhcnQJPSA0LAo+ID4gKwkJLmdwaW9fZW5kCT0g OSwKPiA+ICsJfSwKPiA+ICsJewo+ID4gKwkJLm5hbWUJCT0gIkV4dGVybmFsIE1JSSIsCj4gPiAr CQkuZ3Bpb19zdGFydAk9IDAsCj4gPiArCQkuZ3Bpb19lbmQJPSAxNiwKPiA+ICsJfSwKPiA+ICsJ ewo+ID4gKwkJLm5hbWUJCT0gIk5vcm1hbCIsCj4gPiArCQkuZ3Bpb19zdGFydAk9IC0xLAo+ID4g KwkJLmdwaW9fZW5kCT0gLTEsCj4gPiArCX0sCj4gPiArfTsKPiA+ICsKPiA+ICt2b2lkIF9faW5p dCBtY3M4MTR4X2luaXRfbWFjaGluZSh2b2lkKQo+ID4gK3sKPiA+ICsJdTMyIGJzMiwgY3B1X21v ZGU7Cj4gPiArCWludCBncGlvOwo+ID4gKwo+ID4gKwliczIgPSBfX3Jhd19yZWFkbChtY3M4MTR4 X3N5c2RiZ19iYXNlICsgU1lTREJHX0JTMik7Cj4gPiArCWNwdV9tb2RlID0gKGJzMiA+PiBDUFVf TU9ERV9TSElGVCkgJiBDUFVfTU9ERV9NQVNLOwo+ID4gKwo+ID4gKwlwcl9pbmZvKCJDUFUgbW9k ZTogJXNcbiIsIGNwdV9tb2Rlc1tjcHVfbW9kZV0ubmFtZSk7Cj4gPiArCj4gPiArCS8qIHJlcXVl c3QgdGhlIGdwaW9zIHNpbmNlIHRoZSBwaW5zIGFyZSBtdXhlZCBmb3IgZnVuY3Rpb25uYWxpdHkg Ki8KPiA+ICsJZm9yIChncGlvID0gY3B1X21vZGVzW2NwdV9tb2RlXS5ncGlvX3N0YXJ0Owo+ID4g KwkJZ3BpbyA9PSBjcHVfbW9kZXNbY3B1X21vZGVdLmdwaW9fZW5kOyBncGlvKyspIHsKPiA+ICsJ CWlmIChncGlvICE9IC0xKQo+ID4gKwkJCWdwaW9fcmVxdWVzdChncGlvLCBjcHVfbW9kZXNbY3B1 X21vZGVdLm5hbWUpOwo+IAo+IEkgYW0gbm90IHN1cmUgaGVyZSwgYnV0IHNob3VsZG4ndCB0aGlz IGJlIGRvbmUgd2l0aCB0aGUgcGluY3RybAo+IHN1YnN5c3RlbSBpbnN0ZWFkPwoKVGhpcyBtdXhp bmcgaXMgYWN0dWFsbHkgaGFyZHdpcmVkIHdpdGggdGhlIGJvb3RzdHJhcCByZWdpc3RlciBzZXR0 aW5nLiBJIGNvdWxkIAphbHNvIGV2ZW4gcmVtb3ZlIHRoaXMgYmVjYXVzZSB0aGUgdW5kZXJseWlu ZyBoYXJkd2FyZSBibG9jayBhY3R1YWxseSBkb2VzIG5vdCAKbmVlZCB0byB1c2UgdGhlIEdQSU9z LCB0aGV5IHdpbGwgYmUgY29uZmlndXJlZCBhcyBwaW5zIGZvciB0aGUgY29ycmVzcG9uZGluZyAK ZnVuY3Rpb25zIGRpcmVjdGx5LiBUaGlzIGlzIGFsc28gbm90IHJ1bnRpbWUgbW9kaWZpYWJsZS4g SSBqdXN0IHRob3VnaHQgdGhhdCAKbWFya2luZyB0aGVzZSBHUElPcyBhcyByZXNlcnZlZCBieSB0 aGUgY29ycmVzcG9uZGluZyBmdW5jdGlvbm5hbGl0eSBjb3VsZCBoZWxwIAp0aGUgdXNlciBmaWd1 cmluZyBvdXQgd2hhdCBpcyBoYXBwZW5pbmcgd2l0aCB0aGVtLgoKPiAKPiA+ICt2b2lkIF9faW5p dCBtY3M4MTR4X21hcF9pbyh2b2lkKQo+ID4gK3sKPiA+ICsJaW90YWJsZV9pbml0KG1jczgxNHhf aW9fZGVzYywgQVJSQVlfU0laRShtY3M4MTR4X2lvX2Rlc2MpKTsKPiA+ICsKPiA+ICsJbWNzODE0 eF9zeXNkYmdfYmFzZSA9IGlvcmVtYXAoTUNTODE0WF9JT19TVEFSVCArIE1DUzgxNFhfU1lTREJH LAo+ID4gKwkJCQkJTUNTODE0WF9TWVNEQkdfU0laRSk7Cj4gPiArCWlmICghbWNzODE0eF9zeXNk YmdfYmFzZSkKPiA+ICsJCXBhbmljKCJ1bmFibGUgdG8gcmVtYXAgc3lzZGJnIGJhc2UiKTsKPiAK PiBBbnkgcmVhc29uIHRvIGhhdmUgYSBzdGF0aWMgbWFwcGluZyBpbml0aWFsaXplZCB3aXRoIGlv dGFibGVfaW5pdCgpIGFuZAo+IHRoZW4gYSBkeW5hbWljIG1hcHBpbmcgaW5pdGlhbGl6ZWQgd2l0 aCBpb3JlbWFwKCkgPyBJIHRob3VnaHQgdGhhdAo+IGlvcmVtYXAoKSB3YXNuJ3QgcmVhZHkgYXQg dGhlIC0+bWFwX2lvKCkgdGltZSwgYW5kIGl0IHdhcyB0aGVyZWZvcmUgdGhlCj4gcmVhc29uIHdl IGhhZCBzdGF0aWMgbWFwcGluZ3MuCgpUaGVyZSBhcmUgbm8gcGFydGljdWxhciByZWFzb25zLCBJ IGNvdWxkIHVzZSB0aGUgdGhlIGRlZmluZSBmb3IgdGhlIHZpcnR1YWwgCmFkZHJlc3MgZGlyZWN0 bHkuCgo+IAo+ID4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbWNzODE0eC9pbmNsdWRlL21h Y2gvZW50cnktbWFjcm8uUyAKYi9hcmNoL2FybS9tYWNoLW1jczgxNHgvaW5jbHVkZS9tYWNoL2Vu dHJ5LW1hY3JvLlMKPiA+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gPiBpbmRleCAwMDAwMDAwLi5j YmFkNTY2Cj4gPiAtLS0gL2Rldi9udWxsCj4gPiArKysgYi9hcmNoL2FybS9tYWNoLW1jczgxNHgv aW5jbHVkZS9tYWNoL2VudHJ5LW1hY3JvLlMKPiA+IEBAIC0wLDAgKzEsMjkgQEAKPiA+ICsjaW5j bHVkZSA8bWFjaC9tY3M4MTR4Lmg+Cj4gPiArICAgICAgICAgICAgICAgIC5tYWNybyAgZGlzYWJs ZV9maXEKPiA+ICsgICAgICAgICAgICAgICAgLmVuZG0KPiA+ICsKPiA+ICsJCS5tYWNybyBhcmNo X3JldF90b191c2VyLCB0bXAxLCB0bXAyCj4gPiArCQkuZW5kbQo+ID4gKwo+ID4gKwkJLm1hY3Jv ICBnZXRfaXJxbnJfcHJlYW1ibGUsIGJhc2UsIHRtcAo+ID4gKwkJbGRyCVxiYXNlLCA9bWNzODE0 eF9pbnRjX2Jhc2VAIGJhc2UgdmlydHVhbCBhZGRyZXNzIG9mIElOVEMKPiA+ICsJCWxkcglcYmFz ZSwgW1xiYXNlXQo+ID4gKwkJLmVuZG0KPiA+ICsKPiA+ICsJCS5tYWNybyAgZ2V0X2lycW5yX2Fu ZF9iYXNlLCBpcnFuciwgaXJxc3RhdCwgYmFzZSwgdG1wCj4gPiArCQltb3YJXHRtcCwgI01DUzgx NFhfSVJRX1NUUzAJIEAgbG9hZCB0bXAgd2l0aCBTVFMwIHJlZ2lzdGVyIApvZmZzZXQKPiA+ICsJ CWxkcglcaXJxc3RhdCwgW1xiYXNlLCBcdG1wXQkgQCBsb2FkIHZhbHVlIGF0IGJhc2UgKyB0bXAK PiA+ICsJCXRzdAlcaXJxc3RhdCwgXGlycXN0YXQgICAgICAgQCB0ZXN0IGlmIG5vIGFjdGl2ZSBJ UlEncwo+ID4gKwkJYmVxCTEwMDJmICAgICAgICAgICAgICAgICAgICBAIGlmIG5vIGFjdGl2ZSBp cnFzIHJldHVybiB3aXRoIApzdGF0dXMgMAo+ID4gKwkJbW92CVxpcnFuciwgIzAgICAgICAgICAg ICAgICBAIHN0YXJ0IGZyb20gaXJxIHplcm8KPiA+ICsJCW1vdglcdG1wLCAgICMxICAgICAgICAg ICAgICAgQCB0aGUgbWFzayBpbml0aWFsbHkgMQo+ID4gKzEwMDE6Cj4gPiArCQl0c3QgICAgIFxp cnFzdGF0LCBcdG1wICAgICAgICAgICBAIGFuZCB3aXRoIG1hc2sKPiA+ICsJCWFkZGVxICAgXGly cW5yLCBcaXJxbnIsICMxICAgICAgIEAgaWYgIHplcm8gdGhlbiBhZGQgb25lIHRvIG5yCj4gPiAr CQltb3ZlcSAgIFx0bXAsICAgXHRtcCwgbHNsICMxICAgICBAIHNoaWZ0IG1hc2sgb25lIHRvIGxl ZnQKPiA+ICsJCWJlcSAgICAgMTAwMWIgICAgICAgICAgICAgICAgICAgIEAgaWYgIHplcm8gdGhl biBsb29wIGFnYWluCj4gPiArCQltb3YgICAgIFxpcnFzdGF0LCBcdG1wICAgICAgICAgICBAIHNh dmUgdGhlIHJldHVybiBtYXNrCj4gPiArCQltb3YJXHRtcCwgI01DUzgxNFhfSVJRX1NUUzAgIEAg bG9hZCB0bXAgd2l0aCBJQ1Igb2Zmc2V0Cj4gPiArCQlzdHIgICAgIFxpcnFzdGF0LCAgW1xiYXNl LCBcdG1wXSBAIGNsZWFyIGlycSB3aXRoIHNlbGVjdGVkIAptYXNrCj4gPiArMTAwMjoKPiA+ICsg ICAgICAgICAgICAgICAgLmVuZG0KPiAKPiBIdW0sIHlvdSBzaG91bGQgaW5zdGVhZCB1c2UgdGhl IE1VTFRJX0lSUV9IQU5ETEVSIGZlYXR1cmUgc28gdGhhdCB0aGlzCj4gY2FuIGJlIHdyaXR0ZW4g aW4gQy4KCkxhc3QgSSBkaWQgdGhpcywgSSBtYW5hZ2VkIHRvIGdldCBpbnRlcnJ1cHQgaGFuZGxp bmcgaXNzdWVzIHdpdGggRXRoZXJuZXQsIGJ1dCAKSSB3aWxsIHRyeSB0byBhZGRyZXNzIHRoaXMu IFNvIGZhciwgc2luY2Ugd2Ugc3VwcG9ydCBvbmx5IE1DUzgxNDAgdGhpcyBpcyBub3QgCmEgcHJv YmxlbSwgTUNTODE0MiBhbHNvIGhhcyB0aGUgc2FtZSBpbnRlcnJ1cHQgY29udHJvbGxlci4KCj4g Cj4gPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1tY3M4MTR4L2luY2x1ZGUvbWFjaC9oYXJk d2FyZS5oIGIvYXJjaC9hcm0vbWFjaC0KbWNzODE0eC9pbmNsdWRlL21hY2gvaGFyZHdhcmUuaAo+ ID4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiA+IGluZGV4IDAwMDAwMDAuLjUyOWY2NDgKPiA+IC0t LSAvZGV2L251bGwKPiA+ICsrKyBiL2FyY2gvYXJtL21hY2gtbWNzODE0eC9pbmNsdWRlL21hY2gv aGFyZHdhcmUuaAo+ID4gQEAgLTAsMCArMSwxNiBAQAo+ID4gKy8qCj4gPiArICogQ29weXJpZ2h0 IChDKSAyMDAzIEFydGVjIERlc2lnbiBMdGQuCj4gPiArICoKPiA+ICsgKiBUaGlzIHByb2dyYW0g aXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQo+ ID4gKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vu c2UgdmVyc2lvbiAyIGFzCj4gPiArICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZv dW5kYXRpb24uCj4gPiArICoKPiA+ICsgKi8KPiA+ICsKPiA+ICsjaWZuZGVmIF9fQVNNX0FSQ0hf SEFSRFdBUkVfSAo+ID4gKyNkZWZpbmUgX19BU01fQVJDSF9IQVJEV0FSRV9ICj4gCj4gVGhpcyAj ZGVmaW5lIG5hbWUgbm8gbG9uZ2VyIGxvb2tzIGNvbnNpc3RlbnQgd2l0aCB3aGVyZSB0aGUgZmls ZSBpcwo+IGxvY2F0ZWQuCgpSaWdodCwgdGhhbmtzIQoKPiAKPiA+ICsjaW5jbHVkZSAibWNzODE0 eC5oIgo+ID4gKwo+ID4gKyNlbmRpZgo+ID4gKwo+ID4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21h Y2gtbWNzODE0eC9pbmNsdWRlL21hY2gvaXJxcy5oIGIvYXJjaC9hcm0vbWFjaC0KbWNzODE0eC9p bmNsdWRlL21hY2gvaXJxcy5oCj4gPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+ID4gaW5kZXggMDAw MDAwMC4uNzgwMjFkMQo+ID4gLS0tIC9kZXYvbnVsbAo+ID4gKysrIGIvYXJjaC9hcm0vbWFjaC1t Y3M4MTR4L2luY2x1ZGUvbWFjaC9pcnFzLmgKPiA+IEBAIC0wLDAgKzEsMjIgQEAKPiA+ICsvKgo+ ID4gKyAqIENvcHlyaWdodCAoQykgMjAwMyBBcnRlYyBEZXNpZ24gTHRkLgo+ID4gKyAqCj4gPiAr ICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vciBtb2RpZnkKPiA+ICsgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwo+ID4gKyAqIHB1Ymxpc2hlZCBieSB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgo+ID4gKyAqCj4gPiArICovCj4gPiArCj4gPiArI2lm bmRlZiBfX0FTTV9BUkNIX0lSUVNfSAo+ID4gKyNkZWZpbmUgX19BU01fQVJDSF9JUlFTX0gKPiA+ ICsKPiA+ICsjZGVmaW5lIEZJUV9TVEFSVAkwCj4gPiArCj4gPiArI2RlZmluZSBOUl9JUlFTCQkz Mgo+IAo+IEkgdGhpbmsgdGhpcyBzaG91bGRuJ3QgYmUgbmVlZGVkIGlmIHlvdSB1c2UgU1BBUlNF X0lSUSBzdXBwb3J0Lgo+IAo+ID4gKyNkZWZpbmUgSVJRX1BDSV9JTlRBICAgICAgICAgICAgMjIK PiA+ICsjZGVmaW5lIElSUV9QQ0lfSU5UQiAgICAgICAgICAgIDIzCj4gPiArI2RlZmluZSBJUlFf UENJX0lOVEMgICAgICAgICAgICAyNAo+ID4gKyNkZWZpbmUgSVJRX1BDSV9JTlREICAgICAgICAg ICAgMjYKPiAKPiBBbmQgdGhlc2UgcHJvYmFibHkgYmVsb25nIHRvIHRoZSBEVCBzb21laG93PwoK VGhpcyB3b3VsZCBuZWVkIGEgY29tcGxldGUgUENJIGlycSBtYXBwaW5nIHJlcHJlc2VudGF0aW9u LCBzbyBmYXIgd2UgaGF2ZSB0aGUgCkRUIHByb3BlcnRpZXMsIGJ1dCBub3QgdGhlIGNvcnJlc3Bv bmRpbmcgY29kZSB0byBwYXJzZSB0aGVtLiBJIHdvdWxkIG5vdCAKcXVhbGlmeSB0aGlzIGFzIGEg bWFqb3IgYmxvY2tlci4KCj4gCj4gPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1tY3M4MTR4 L3RpbWVyLmMgYi9hcmNoL2FybS9tYWNoLW1jczgxNHgvdGltZXIuYwo+ID4gbmV3IGZpbGUgbW9k ZSAxMDA2NDQKPiA+IGluZGV4IDAwMDAwMDAuLmU4NDA4ZTQKCltzbmlwXQoKPiA+ICsKPiA+ICtz dGF0aWMgdm9pZCBfX2luaXQgbWNzODE0eF90aW1lcl9pbml0KHZvaWQpCj4gPiArewo+ID4gKwlz dHJ1Y3QgY2xrICpjbGs7Cj4gPiArCj4gPiArCWNsayA9IGNsa19nZXRfc3lzKCJ0aW1lcjAiLCBO VUxMKTsKPiA+ICsJaWYgKElTX0VSUl9PUl9OVUxMKGNsaykpCj4gPiArCQlwYW5pYygidW5hYmxl IHRvIGdldCB0aW1lcjAgY2xvY2siKTsKPiA+ICsKPiA+ICsJY2xvY2tfcmF0ZSA9IGNsa19nZXRf cmF0ZShjbGspOwo+ID4gKwljbGtfcHV0KGNsayk7Cj4gPiArCj4gPiArCW1jczgxNHhfb2ZfdGlt ZXJfaW5pdCgpOwo+ID4gKwo+ID4gKwlwcl9pbmZvKCJUaW1lciBmcmVxdWVuY3k6ICVkIChrSHop XG4iLCBjbG9ja19yYXRlIC8gMTAwMCk7Cj4gPiArCj4gPiArCXRpbWVyX3JlbG9hZF92YWx1ZSA9 IDB4ZmZmZmZmZmYgLSAoY2xvY2tfcmF0ZSAvIEhaKTsKPiA+ICsKPiA+ICsJLyogZGlzYWJsZSB0 aW1lciAqLwo+ID4gKwlfX3Jhd193cml0ZWwoMCwgbWNzODE0eF90aW1lcl9iYXNlICsgVElNRVJf Q1RMKTsKPiA+ICsJX19yYXdfd3JpdGVsKHRpbWVyX3JlbG9hZF92YWx1ZSwgbWNzODE0eF90aW1l cl9iYXNlICsgVElNRVJfVkFMKTsKPiA+ICsJbGFzdF9yZWxvYWQgPSB0aW1lcl9yZWxvYWRfdmFs dWU7Cj4gPiArCj4gPiArCXNldHVwX2lycShtY3M4MTR4X3RpbWVyX2lycS5pcnEsICZtY3M4MTR4 X3RpbWVyX2lycSk7Cj4gPiArCS8qIGVuYWJsZSB0aW1lciwgc3RvcCB0aW1lciBpbiBkZWJ1ZyBt b2RlICovCj4gPiArCV9fcmF3X3dyaXRlbCgweDAzLCBtY3M4MTR4X3RpbWVyX2Jhc2UgKyBUSU1F Ul9DVEwpOwo+ID4gK30KPiA+ICsKPiA+ICtzdHJ1Y3Qgc3lzX3RpbWVyIG1jczgxNHhfdGltZXIg PSB7Cj4gPiArCS5pbml0CT0gbWNzODE0eF90aW1lcl9pbml0LAo+ID4gKwkub2Zmc2V0CT0gbWNz ODE0eF9nZXR0aW1lb2Zmc2V0LAo+ID4gK307Cj4gCj4gSSBhbSBzdXJwcmlzZWQgdGhhdCB0aGlz IGRvZXNuJ3QgdXNlIHRoZSBjbG9ja3NvdXJjZSBhbmQgY2xvY2tldmVudHMKPiBpbmZyYXN0cnVj dHVyZS4gSXQgcHJvYmFibHkgc2hvdWxkLCBhbmQgYmUgaW1wbGVtZW50ZWQgaW4KPiBkcml2ZXJz L2Nsb2Nrc291cmNlLy4KCkkgd2lsbCBsb29rIGludG8gdGhpcywgY29uc2lkZXJpbmcgdGhhdCB3 ZSBzdGlsbCBoYXZlIDIgdGltZXJzIGxlZnQgYXZhaWxhYmxlIAooNjQtYml0cyBhbmQgMTYtYml0 cykgdGhpcyBzaG91bGQgYmUgZG9hYmxlLgoKVGhhbmsgeW91IGZvciB5b3VyIGNvbW1lbnRzLCBJ IHdpbGwgd2FpdCBhIGxpdHRsZSBtb3JlIGZvciBvdGhlciBwZW9wbGUgdG8gCmNvbWUgdXAgYmVm b3JlIGNvbWluZyB1cCB3aXRoIGEgcGF0Y2ggcmVzcGluLgotLQpGbG9yaWFuCgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1h aWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xp c3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==