From mboxrd@z Thu Jan 1 00:00:00 1970 From: robherring2@gmail.com (Rob Herring) Date: Tue, 20 Sep 2011 07:58:58 -0500 Subject: DT vs ARM static mappings In-Reply-To: <1316519479.4611.150.camel@hornet.cambridge.arm.com> References: <1316519479.4611.150.camel@hornet.cambridge.arm.com> Message-ID: <4E788E12.8000801@gmail.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Pawel, On 09/20/2011 06:51 AM, Pawel Moll wrote: > Hi All, > > Apologies for the length of the text below, but the problem is > complex... (or at least it seems to be) > > While working on DT support for ARM Versatile Express I faced an > interesting problem... Some background first, to set a common ground and > test my understanding of the problem ;-) > > ARM machine description contains a "map_io" method, which is used to > create static memory mappings (using iotable_init() function) for things > like peripherals or SRAMs. At least that's the theory, because most of > the platforms are doing much more stuff there, like clocking/GPIOs/UARTs > initialization, hardware probing etc. > > Now the Versatile Express platform: it consists of a motherboard with a > set of peripherals and a processor daughterboard (core tile), both > connected via a static memory bus, which is mapped into processor's > physical address space. The motherboard can be shared between different > types of the tiles (eg. A9, A5, A15 etc.). The present one is probed byt > he motherboard firmware and exposed in "system registers". > > Everything is fine so far. The interesting part starts here: > > http://infocenter.arm.com/help/topic/com.arm.doc.dui0447e/CACIHGFE.html > > In brief, depending on the configuration, the system can have one of > two, totally different, memory maps (please, do spare me the "but why > did they do that" comments - not my idea nor decision, I just have to > live with this ;-), depending on the core tile being used. > > In result, the static mapping as defined currently in > arch/arm/mach-vexpress/v2m.c for A9 variant: > > #define V2M_PA_CS7 0x10000000 > > static struct map_desc v2m_io_desc[] __initdata = { > { > .virtual = __MMIO_P2V(V2M_PA_CS7), > .pfn = __phys_to_pfn(V2M_PA_CS7), > .length = SZ_128K, > .type = MT_DEVICE, > }, > }; > > is no longer valid for A5/A15. It would rather look like this: > > #define V2M_PA_CS3 0x1c000000 > > static struct map_desc v2m_io_desc[] __initdata = { > { > .virtual = __MMIO_P2V(V2M_PA_CS3), > .pfn = __phys_to_pfn(V2M_PA_CS3), > .length = SZ_2M, > .type = MT_DEVICE, > }, > }; > > Not only the peripherals base address is changed but also "internal" > alignment, thus offsets to peripherals. Some of them are not being > ioremap()ed, but directly used via the static mapping and MMIO_P2V macro > (like "readl(MMIO_P2V(V2M_SYS_PROCID0))" in v2m_populate_ct_desc(void) > function). For example, these two: > > #define V2M_SYSREGS (V2M_PA_CS7 + 0x00000000) > #define V2M_SYSCTL (V2M_PA_CS7 + 0x00001000) > > would have to become: > > #define V2M_SYSREGS (V2M_PA_CS3 + 0x00010000) > #define V2M_SYSCTL (V2M_PA_CS3 + 0x00020000) > > My current DTS for the original memory map looks like that (fragments): > > { > motherboard { > ranges = <7 0 0x10000000 0x00020000>; > #address-cells = <2>; // SMB chipselect number and offset > #size-cells = <1>; > > peripherals at 7 { > ranges = <0 7 0 0x20000>; > #address-cells = <1>; > #size-cells = <1>; > > sysreg at 00000 { > reg = <0x00000 0x1000>; > }; > > sysctl at 01000 { > reg = <0x01000 0x1000>; > }; > } > } > } > > DTS for the second memory map would just have the addresses changed. > Unfortunately, because of the static mappings being hardcoded in the > board support file, one kernel won't Just Work (TM) with different DTBs. > > Of course the simplest solution would be to define two different > compatible values, eg. "arm,vexpress-legacy" would execute the current > map_io implementation, while "arm,vexpress-rs1" would use different one, > setting up the other map_desc (the MMIO_P2V macro must die of course, > replaced with a runtime-defined virtual base address for the > peripherals). > > If you believe that's what I should do, say it and stop reading :-) > Yes. Different tiles are fundamentally different boards, so they should have different DTs. Using includes should help minimize duplication though. Think about it this way. How would you solve this without DT? You would have a bunch of duplicated data in the kernel for the different configs. So you're not any worse off in this regard and still have the other advantages of DT. > To my mind it looked like the whole mechanism was not flexible enough, > so I wanted to explore other options... > > The obvious one was to describe the required static mapping in the DTS. > I don't like this idea, though. It can hardly be called "hardware > description". Besides, what node would carry such data? "chosen"? > Hardly... > > Would it contain a "regs" property with the physical address and > "virtual-reg" with the virtual one? Again, doesn't sound right to me > (especially the virtual bit, however the virtual address could be common > between different variants and be defined in the board support code, not > the DTS). > > I have considered a reference (phandle or an alias?) to the node to be > mapped ("peripherals" in my case), but where to define this reference? > Any ideas? In "chosen" like the kernel command line would be the place, but I don't think that is the right approach. Chosen is really for things that change frequently and this doesn't really fall in that category. > > There is an additional problem here... The "map_io" is executed before > the tree is un-flattened, so: > > 1. One can't simply use "of_find_matching_node()" (as in the latest l2x0 > patches) to find the interesting nodes - the only way of going through > the tree is raw of_scan_flat_dt() function. Therefore any conditions > more complex then string comparison with the (full) node name are > problematic. > > 2. The tree mappings (ranges) are not resolved yet, so one can't simply > get the effective address of a node. Only "raw" properties are > available, so all one can get scanning for "peripherals at 7" node is "0 7 > 0 0x20000" array, instead of the "0x10000000 0x00020000" that is really > important. > If you add a compatible field to "motherboard" node, then you can read the ranges. > Initially I wanted to find the mentioned devices and create individual > mappings for them, so the MMIO_P2V would be still valid (if slightly > "abused"), but I failed due to the problems mentioned above. And I can't > delay this operation till the tree is un-flattened, as the core tile > must be probed (via sysreg) in map_io (tile's specific code must be able > to create its own mappings): Do you really need MMIO_P2V? If you have fixed virtual addresses in the kernel and can pull the phys addresses from DT to populate the iotable, is that sufficient? > > static void __init v2m_map_io(void) > { > iotable_init(v2m_io_desc, ARRAY_SIZE(v2m_io_desc)); > v2m_populate_ct_desc(); > ct_desc->map_io(); > } > > Any comments, ideas and suggestions how to tackle this situation are > more than welcome. > Generally, the trend is to get rid of static mappings as much as possible. Doing that first might simplify things. Rob > Cheers! > > Pawe? > > > > > _______________________________________________ > linux-arm-kernel mailing list > linux-arm-kernel at lists.infradead.org > http://lists.infradead.org/mailman/listinfo/linux-arm-kernel From mboxrd@z Thu Jan 1 00:00:00 1970 From: Rob Herring Subject: Re: DT vs ARM static mappings Date: Tue, 20 Sep 2011 07:58:58 -0500 Message-ID: <4E788E12.8000801@gmail.com> References: <1316519479.4611.150.camel@hornet.cambridge.arm.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1316519479.4611.150.camel-okZbbLrgpR/YkXV2EHHjLW3o5bpOHsLO@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: devicetree-discuss-bounces+gldd-devicetree-discuss=m.gmane.org-uLR06cmDAlY/bJ5BZ2RsiQ@public.gmane.org Sender: devicetree-discuss-bounces+gldd-devicetree-discuss=m.gmane.org-uLR06cmDAlY/bJ5BZ2RsiQ@public.gmane.org To: Pawel Moll Cc: devicetree-discuss-uLR06cmDAlY/bJ5BZ2RsiQ@public.gmane.org, linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org List-Id: devicetree@vger.kernel.org UGF3ZWwsCgpPbiAwOS8yMC8yMDExIDA2OjUxIEFNLCBQYXdlbCBNb2xsIHdyb3RlOgo+IEhpIEFs bCwKPiAKPiBBcG9sb2dpZXMgZm9yIHRoZSBsZW5ndGggb2YgdGhlIHRleHQgYmVsb3csIGJ1dCB0 aGUgcHJvYmxlbSBpcwo+IGNvbXBsZXguLi4gKG9yIGF0IGxlYXN0IGl0IHNlZW1zIHRvIGJlKQo+ IAo+IFdoaWxlIHdvcmtpbmcgb24gRFQgc3VwcG9ydCBmb3IgQVJNIFZlcnNhdGlsZSBFeHByZXNz IEkgZmFjZWQgYW4KPiBpbnRlcmVzdGluZyBwcm9ibGVtLi4uIFNvbWUgYmFja2dyb3VuZCBmaXJz dCwgdG8gc2V0IGEgY29tbW9uIGdyb3VuZCBhbmQKPiB0ZXN0IG15IHVuZGVyc3RhbmRpbmcgb2Yg dGhlIHByb2JsZW0gOy0pCj4gCj4gQVJNIG1hY2hpbmUgZGVzY3JpcHRpb24gY29udGFpbnMgYSAi bWFwX2lvIiBtZXRob2QsIHdoaWNoIGlzIHVzZWQgdG8KPiBjcmVhdGUgc3RhdGljIG1lbW9yeSBt YXBwaW5ncyAodXNpbmcgaW90YWJsZV9pbml0KCkgZnVuY3Rpb24pIGZvciB0aGluZ3MKPiBsaWtl IHBlcmlwaGVyYWxzIG9yIFNSQU1zLiBBdCBsZWFzdCB0aGF0J3MgdGhlIHRoZW9yeSwgYmVjYXVz ZSBtb3N0IG9mCj4gdGhlIHBsYXRmb3JtcyBhcmUgZG9pbmcgbXVjaCBtb3JlIHN0dWZmIHRoZXJl LCBsaWtlIGNsb2NraW5nL0dQSU9zL1VBUlRzCj4gaW5pdGlhbGl6YXRpb24sIGhhcmR3YXJlIHBy b2JpbmcgZXRjLgo+IAo+IE5vdyB0aGUgVmVyc2F0aWxlIEV4cHJlc3MgcGxhdGZvcm06IGl0IGNv bnNpc3RzIG9mIGEgbW90aGVyYm9hcmQgd2l0aCBhCj4gc2V0IG9mIHBlcmlwaGVyYWxzIGFuZCBh IHByb2Nlc3NvciBkYXVnaHRlcmJvYXJkIChjb3JlIHRpbGUpLCBib3RoCj4gY29ubmVjdGVkIHZp YSBhIHN0YXRpYyBtZW1vcnkgYnVzLCB3aGljaCBpcyBtYXBwZWQgaW50byBwcm9jZXNzb3Incwo+ IHBoeXNpY2FsIGFkZHJlc3Mgc3BhY2UuIFRoZSBtb3RoZXJib2FyZCBjYW4gYmUgc2hhcmVkIGJl dHdlZW4gZGlmZmVyZW50Cj4gdHlwZXMgb2YgdGhlIHRpbGVzIChlZy4gQTksIEE1LCBBMTUgZXRj LikuIFRoZSBwcmVzZW50IG9uZSBpcyBwcm9iZWQgYnl0Cj4gaGUgbW90aGVyYm9hcmQgZmlybXdh cmUgYW5kIGV4cG9zZWQgaW4gInN5c3RlbSByZWdpc3RlcnMiLgo+IAo+IEV2ZXJ5dGhpbmcgaXMg ZmluZSBzbyBmYXIuIFRoZSBpbnRlcmVzdGluZyBwYXJ0IHN0YXJ0cyBoZXJlOgo+IAo+IGh0dHA6 Ly9pbmZvY2VudGVyLmFybS5jb20vaGVscC90b3BpYy9jb20uYXJtLmRvYy5kdWkwNDQ3ZS9DQUNJ SEdGRS5odG1sCj4gCj4gSW4gYnJpZWYsIGRlcGVuZGluZyBvbiB0aGUgY29uZmlndXJhdGlvbiwg dGhlIHN5c3RlbSBjYW4gaGF2ZSBvbmUgb2YKPiB0d28sIHRvdGFsbHkgZGlmZmVyZW50LCBtZW1v cnkgbWFwcyAocGxlYXNlLCBkbyBzcGFyZSBtZSB0aGUgImJ1dCB3aHkKPiBkaWQgdGhleSBkbyB0 aGF0IiBjb21tZW50cyAtIG5vdCBteSBpZGVhIG5vciBkZWNpc2lvbiwgSSBqdXN0IGhhdmUgdG8K PiBsaXZlIHdpdGggdGhpcyA7LSksIGRlcGVuZGluZyBvbiB0aGUgY29yZSB0aWxlIGJlaW5nIHVz ZWQuCj4gCj4gSW4gcmVzdWx0LCB0aGUgc3RhdGljIG1hcHBpbmcgYXMgZGVmaW5lZCBjdXJyZW50 bHkgaW4KPiBhcmNoL2FybS9tYWNoLXZleHByZXNzL3YybS5jIGZvciBBOSB2YXJpYW50Ogo+IAo+ ICNkZWZpbmUgVjJNX1BBX0NTNyAgICAgIDB4MTAwMDAwMDAKPiAKPiBzdGF0aWMgc3RydWN0IG1h cF9kZXNjIHYybV9pb19kZXNjW10gX19pbml0ZGF0YSA9IHsKPiAgICAgICAgIHsKPiAgICAgICAg ICAgICAgICAgLnZpcnR1YWwgICAgICAgID0gX19NTUlPX1AyVihWMk1fUEFfQ1M3KSwKPiAgICAg ICAgICAgICAgICAgLnBmbiAgICAgICAgICAgID0gX19waHlzX3RvX3BmbihWMk1fUEFfQ1M3KSwK PiAgICAgICAgICAgICAgICAgLmxlbmd0aCAgICAgICAgID0gU1pfMTI4SywKPiAgICAgICAgICAg ICAgICAgLnR5cGUgICAgICAgICAgID0gTVRfREVWSUNFLAo+ICAgICAgICAgfSwKPiB9Owo+IAo+ IGlzIG5vIGxvbmdlciB2YWxpZCBmb3IgQTUvQTE1LiBJdCB3b3VsZCByYXRoZXIgbG9vayBsaWtl IHRoaXM6Cj4gCj4gI2RlZmluZSBWMk1fUEFfQ1MzICAgICAgMHgxYzAwMDAwMAo+IAo+IHN0YXRp YyBzdHJ1Y3QgbWFwX2Rlc2MgdjJtX2lvX2Rlc2NbXSBfX2luaXRkYXRhID0gewo+ICAgICAgICAg ewo+ICAgICAgICAgICAgICAgICAudmlydHVhbCAgICAgICAgPSBfX01NSU9fUDJWKFYyTV9QQV9D UzMpLAo+ICAgICAgICAgICAgICAgICAucGZuICAgICAgICAgICAgPSBfX3BoeXNfdG9fcGZuKFYy TV9QQV9DUzMpLAo+ICAgICAgICAgICAgICAgICAubGVuZ3RoICAgICAgICAgPSBTWl8yTSwKPiAg ICAgICAgICAgICAgICAgLnR5cGUgICAgICAgICAgID0gTVRfREVWSUNFLAo+ICAgICAgICAgfSwK PiB9Owo+IAo+IE5vdCBvbmx5IHRoZSBwZXJpcGhlcmFscyBiYXNlIGFkZHJlc3MgaXMgY2hhbmdl ZCBidXQgYWxzbyAiaW50ZXJuYWwiCj4gYWxpZ25tZW50LCB0aHVzIG9mZnNldHMgdG8gcGVyaXBo ZXJhbHMuIFNvbWUgb2YgdGhlbSBhcmUgbm90IGJlaW5nCj4gaW9yZW1hcCgpZWQsIGJ1dCBkaXJl Y3RseSB1c2VkIHZpYSB0aGUgc3RhdGljIG1hcHBpbmcgYW5kIE1NSU9fUDJWIG1hY3JvCj4gKGxp a2UgInJlYWRsKE1NSU9fUDJWKFYyTV9TWVNfUFJPQ0lEMCkpIiBpbiB2Mm1fcG9wdWxhdGVfY3Rf ZGVzYyh2b2lkKQo+IGZ1bmN0aW9uKS4gRm9yIGV4YW1wbGUsIHRoZXNlIHR3bzoKPiAKPiAjZGVm aW5lIFYyTV9TWVNSRUdTICAgICAgICAgICAgIChWMk1fUEFfQ1M3ICsgMHgwMDAwMDAwMCkKPiAj ZGVmaW5lIFYyTV9TWVNDVEwgICAgICAgICAgICAgIChWMk1fUEFfQ1M3ICsgMHgwMDAwMTAwMCkK PiAKPiB3b3VsZCBoYXZlIHRvIGJlY29tZToKPiAKPiAjZGVmaW5lIFYyTV9TWVNSRUdTICAgICAg ICAgICAgIChWMk1fUEFfQ1MzICsgMHgwMDAxMDAwMCkKPiAjZGVmaW5lIFYyTV9TWVNDVEwgICAg ICAgICAgICAgIChWMk1fUEFfQ1MzICsgMHgwMDAyMDAwMCkKPiAKPiBNeSBjdXJyZW50IERUUyBm b3IgdGhlIG9yaWdpbmFsIG1lbW9yeSBtYXAgbG9va3MgbGlrZSB0aGF0IChmcmFnbWVudHMpOgo+ IAo+IHsKPiAgICAgICAgIG1vdGhlcmJvYXJkIHsKPiAgICAgICAgICAgICAgICAgcmFuZ2VzID0g PDcgMCAweDEwMDAwMDAwIDB4MDAwMjAwMDA+Owo+ICAgICAgICAgICAgICAgICAjYWRkcmVzcy1j ZWxscyA9IDwyPjsgLy8gU01CIGNoaXBzZWxlY3QgbnVtYmVyIGFuZCBvZmZzZXQKPiAgICAgICAg ICAgICAgICAgI3NpemUtY2VsbHMgPSA8MT47Cj4gCQo+ICAgICAgICAgICAgICAgICBwZXJpcGhl cmFsc0A3IHsKPiAJCQlyYW5nZXMgPSA8MCA3IDAgMHgyMDAwMD47Cj4gICAgICAgICAgICAgICAg ICAgICAgICAgI2FkZHJlc3MtY2VsbHMgPSA8MT47Cj4gICAgICAgICAgICAgICAgICAgICAgICAg I3NpemUtY2VsbHMgPSA8MT47Cj4gCj4gICAgICAgICAgICAgICAgICAgICAgICAgc3lzcmVnQDAw MDAwIHsKPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlZyA9IDwweDAwMDAwIDB4 MTAwMD47Cj4gICAgICAgICAgICAgICAgICAgICAgICAgfTsgICAgICAKPiAgICAgICAgICAgICAg ICAgICAgICAgICAKPiAgICAgICAgICAgICAgICAgICAgICAgICBzeXNjdGxAMDEwMDAgewo+ICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVnID0gPDB4MDEwMDAgMHgxMDAwPjsKPiAg ICAgICAgICAgICAgICAgICAgICAgICB9Owo+IAkJfQo+IAl9CQkKPiB9Cj4gCQkKPiBEVFMgZm9y IHRoZSBzZWNvbmQgbWVtb3J5IG1hcCB3b3VsZCBqdXN0IGhhdmUgdGhlIGFkZHJlc3NlcyBjaGFu Z2VkLgo+IFVuZm9ydHVuYXRlbHksIGJlY2F1c2Ugb2YgdGhlIHN0YXRpYyBtYXBwaW5ncyBiZWlu ZyBoYXJkY29kZWQgaW4gdGhlCj4gYm9hcmQgc3VwcG9ydCBmaWxlLCBvbmUga2VybmVsIHdvbid0 IEp1c3QgV29yayAoVE0pIHdpdGggZGlmZmVyZW50IERUQnMuCj4gCj4gT2YgY291cnNlIHRoZSBz aW1wbGVzdCBzb2x1dGlvbiB3b3VsZCBiZSB0byBkZWZpbmUgdHdvIGRpZmZlcmVudAo+IGNvbXBh dGlibGUgdmFsdWVzLCBlZy4gImFybSx2ZXhwcmVzcy1sZWdhY3kiIHdvdWxkIGV4ZWN1dGUgdGhl IGN1cnJlbnQKPiBtYXBfaW8gaW1wbGVtZW50YXRpb24sIHdoaWxlICJhcm0sdmV4cHJlc3MtcnMx IiB3b3VsZCB1c2UgZGlmZmVyZW50IG9uZSwKPiBzZXR0aW5nIHVwIHRoZSBvdGhlciBtYXBfZGVz YyAodGhlIE1NSU9fUDJWIG1hY3JvIG11c3QgZGllIG9mIGNvdXJzZSwKPiByZXBsYWNlZCB3aXRo IGEgcnVudGltZS1kZWZpbmVkIHZpcnR1YWwgYmFzZSBhZGRyZXNzIGZvciB0aGUKPiBwZXJpcGhl cmFscykuCj4gCj4gSWYgeW91IGJlbGlldmUgdGhhdCdzIHdoYXQgSSBzaG91bGQgZG8sIHNheSBp dCBhbmQgc3RvcCByZWFkaW5nIDotKQo+IAoKWWVzLiBEaWZmZXJlbnQgdGlsZXMgYXJlIGZ1bmRh bWVudGFsbHkgZGlmZmVyZW50IGJvYXJkcywgc28gdGhleSBzaG91bGQKaGF2ZSBkaWZmZXJlbnQg RFRzLiBVc2luZyBpbmNsdWRlcyBzaG91bGQgaGVscCBtaW5pbWl6ZSBkdXBsaWNhdGlvbiB0aG91 Z2guCgpUaGluayBhYm91dCBpdCB0aGlzIHdheS4gSG93IHdvdWxkIHlvdSBzb2x2ZSB0aGlzIHdp dGhvdXQgRFQ/IFlvdSB3b3VsZApoYXZlIGEgYnVuY2ggb2YgZHVwbGljYXRlZCBkYXRhIGluIHRo ZSBrZXJuZWwgZm9yIHRoZSBkaWZmZXJlbnQgY29uZmlncy4KU28geW91J3JlIG5vdCBhbnkgd29y c2Ugb2ZmIGluIHRoaXMgcmVnYXJkIGFuZCBzdGlsbCBoYXZlIHRoZSBvdGhlcgphZHZhbnRhZ2Vz IG9mIERULgoKPiBUbyBteSBtaW5kIGl0IGxvb2tlZCBsaWtlIHRoZSB3aG9sZSBtZWNoYW5pc20g d2FzIG5vdCBmbGV4aWJsZSBlbm91Z2gsCj4gc28gSSB3YW50ZWQgdG8gZXhwbG9yZSBvdGhlciBv cHRpb25zLi4uCj4gCj4gVGhlIG9idmlvdXMgb25lIHdhcyB0byBkZXNjcmliZSB0aGUgcmVxdWly ZWQgc3RhdGljIG1hcHBpbmcgaW4gdGhlIERUUy4KPiBJIGRvbid0IGxpa2UgdGhpcyBpZGVhLCB0 aG91Z2guIEl0IGNhbiBoYXJkbHkgYmUgY2FsbGVkICJoYXJkd2FyZQo+IGRlc2NyaXB0aW9uIi4g QmVzaWRlcywgd2hhdCBub2RlIHdvdWxkIGNhcnJ5IHN1Y2ggZGF0YT8gImNob3NlbiI/Cj4gSGFy ZGx5Li4uCj4gCj4gV291bGQgaXQgY29udGFpbiBhICJyZWdzIiBwcm9wZXJ0eSB3aXRoIHRoZSBw aHlzaWNhbCBhZGRyZXNzIGFuZAo+ICJ2aXJ0dWFsLXJlZyIgd2l0aCB0aGUgdmlydHVhbCBvbmU/ IEFnYWluLCBkb2Vzbid0IHNvdW5kIHJpZ2h0IHRvIG1lCj4gKGVzcGVjaWFsbHkgdGhlIHZpcnR1 YWwgYml0LCBob3dldmVyIHRoZSB2aXJ0dWFsIGFkZHJlc3MgY291bGQgYmUgY29tbW9uCj4gYmV0 d2VlbiBkaWZmZXJlbnQgdmFyaWFudHMgYW5kIGJlIGRlZmluZWQgaW4gdGhlIGJvYXJkIHN1cHBv cnQgY29kZSwgbm90Cj4gdGhlIERUUykuCj4gCj4gSSBoYXZlIGNvbnNpZGVyZWQgYSByZWZlcmVu Y2UgKHBoYW5kbGUgb3IgYW4gYWxpYXM/KSB0byB0aGUgbm9kZSB0byBiZQo+IG1hcHBlZCAoInBl cmlwaGVyYWxzIiBpbiBteSBjYXNlKSwgYnV0IHdoZXJlIHRvIGRlZmluZSB0aGlzIHJlZmVyZW5j ZT8KPiBBbnkgaWRlYXM/CgpJbiAiY2hvc2VuIiBsaWtlIHRoZSBrZXJuZWwgY29tbWFuZCBsaW5l IHdvdWxkIGJlIHRoZSBwbGFjZSwgYnV0IEkgZG9uJ3QKdGhpbmsgdGhhdCBpcyB0aGUgcmlnaHQg YXBwcm9hY2guIENob3NlbiBpcyByZWFsbHkgZm9yIHRoaW5ncyB0aGF0CmNoYW5nZSBmcmVxdWVu dGx5IGFuZCB0aGlzIGRvZXNuJ3QgcmVhbGx5IGZhbGwgaW4gdGhhdCBjYXRlZ29yeS4KCj4gCj4g VGhlcmUgaXMgYW4gYWRkaXRpb25hbCBwcm9ibGVtIGhlcmUuLi4gVGhlICJtYXBfaW8iIGlzIGV4 ZWN1dGVkIGJlZm9yZQo+IHRoZSB0cmVlIGlzIHVuLWZsYXR0ZW5lZCwgc286Cj4gCj4gMS4gT25l IGNhbid0IHNpbXBseSB1c2UgIm9mX2ZpbmRfbWF0Y2hpbmdfbm9kZSgpIiAoYXMgaW4gdGhlIGxh dGVzdCBsMngwCj4gcGF0Y2hlcykgdG8gZmluZCB0aGUgaW50ZXJlc3Rpbmcgbm9kZXMgLSB0aGUg b25seSB3YXkgb2YgZ29pbmcgdGhyb3VnaAo+IHRoZSB0cmVlIGlzIHJhdyBvZl9zY2FuX2ZsYXRf ZHQoKSBmdW5jdGlvbi4gVGhlcmVmb3JlIGFueSBjb25kaXRpb25zCj4gbW9yZSBjb21wbGV4IHRo ZW4gc3RyaW5nIGNvbXBhcmlzb24gd2l0aCB0aGUgKGZ1bGwpIG5vZGUgbmFtZSBhcmUKPiBwcm9i bGVtYXRpYy4KPiAKPiAyLiBUaGUgdHJlZSBtYXBwaW5ncyAocmFuZ2VzKSBhcmUgbm90IHJlc29s dmVkIHlldCwgc28gb25lIGNhbid0IHNpbXBseQo+IGdldCB0aGUgZWZmZWN0aXZlIGFkZHJlc3Mg b2YgYSBub2RlLiBPbmx5ICJyYXciIHByb3BlcnRpZXMgYXJlCj4gYXZhaWxhYmxlLCBzbyBhbGwg b25lIGNhbiBnZXQgc2Nhbm5pbmcgZm9yICJwZXJpcGhlcmFsc0A3IiBub2RlIGlzICIwIDcKPiAw IDB4MjAwMDAiIGFycmF5LCBpbnN0ZWFkIG9mIHRoZSAiMHgxMDAwMDAwMCAweDAwMDIwMDAwIiB0 aGF0IGlzIHJlYWxseQo+IGltcG9ydGFudC4KPiAKCklmIHlvdSBhZGQgYSBjb21wYXRpYmxlIGZp ZWxkIHRvICJtb3RoZXJib2FyZCIgbm9kZSwgdGhlbiB5b3UgY2FuIHJlYWQKdGhlIHJhbmdlcy4K Cj4gSW5pdGlhbGx5IEkgd2FudGVkIHRvIGZpbmQgdGhlIG1lbnRpb25lZCBkZXZpY2VzIGFuZCBj cmVhdGUgaW5kaXZpZHVhbAo+IG1hcHBpbmdzIGZvciB0aGVtLCBzbyB0aGUgTU1JT19QMlYgd291 bGQgYmUgc3RpbGwgdmFsaWQgKGlmIHNsaWdodGx5Cj4gImFidXNlZCIpLCBidXQgSSBmYWlsZWQg ZHVlIHRvIHRoZSBwcm9ibGVtcyBtZW50aW9uZWQgYWJvdmUuIEFuZCBJIGNhbid0Cj4gZGVsYXkg dGhpcyBvcGVyYXRpb24gdGlsbCB0aGUgdHJlZSBpcyB1bi1mbGF0dGVuZWQsIGFzIHRoZSBjb3Jl IHRpbGUKPiBtdXN0IGJlIHByb2JlZCAodmlhIHN5c3JlZykgaW4gbWFwX2lvICh0aWxlJ3Mgc3Bl Y2lmaWMgY29kZSBtdXN0IGJlIGFibGUKPiB0byBjcmVhdGUgaXRzIG93biBtYXBwaW5ncyk6CgpE byB5b3UgcmVhbGx5IG5lZWQgTU1JT19QMlY/IElmIHlvdSBoYXZlIGZpeGVkIHZpcnR1YWwgYWRk cmVzc2VzIGluIHRoZQprZXJuZWwgYW5kIGNhbiBwdWxsIHRoZSBwaHlzIGFkZHJlc3NlcyBmcm9t IERUIHRvIHBvcHVsYXRlIHRoZSBpb3RhYmxlLAppcyB0aGF0IHN1ZmZpY2llbnQ/Cgo+IAo+IHN0 YXRpYyB2b2lkIF9faW5pdCB2Mm1fbWFwX2lvKHZvaWQpCj4geyAgICAgICAKPiAgICAgICAgIGlv dGFibGVfaW5pdCh2Mm1faW9fZGVzYywgQVJSQVlfU0laRSh2Mm1faW9fZGVzYykpOyAKPiAgICAg ICAgIHYybV9wb3B1bGF0ZV9jdF9kZXNjKCk7Cj4gICAgICAgICBjdF9kZXNjLT5tYXBfaW8oKTsK PiB9Cj4gCj4gQW55IGNvbW1lbnRzLCBpZGVhcyBhbmQgc3VnZ2VzdGlvbnMgaG93IHRvIHRhY2ts ZSB0aGlzIHNpdHVhdGlvbiBhcmUKPiBtb3JlIHRoYW4gd2VsY29tZS4KPiAKR2VuZXJhbGx5LCB0 aGUgdHJlbmQgaXMgdG8gZ2V0IHJpZCBvZiBzdGF0aWMgbWFwcGluZ3MgYXMgbXVjaCBhcwpwb3Nz aWJsZS4gRG9pbmcgdGhhdCBmaXJzdCBtaWdodCBzaW1wbGlmeSB0aGluZ3MuCgpSb2IKCj4gQ2hl ZXJzIQo+IAo+IFBhd2XFggo+IAo+IAo+IAo+IAo+IF9fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fCj4gbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKPiBs aW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKPiBodHRwOi8vbGlzdHMuaW5mcmFk ZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwKCl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRldmljZXRyZWUtZGlzY3VzcyBtYWls aW5nIGxpc3QKZGV2aWNldHJlZS1kaXNjdXNzQGxpc3RzLm96bGFicy5vcmcKaHR0cHM6Ly9saXN0 cy5vemxhYnMub3JnL2xpc3RpbmZvL2RldmljZXRyZWUtZGlzY3Vzcwo=