From mboxrd@z Thu Jan 1 00:00:00 1970 From: robherring2@gmail.com (Rob Herring) Date: Tue, 20 Sep 2011 09:37:58 -0500 Subject: DT vs ARM static mappings In-Reply-To: <1316527365.4611.354.camel@hornet.cambridge.arm.com> References: <1316519479.4611.150.camel@hornet.cambridge.arm.com> <4E788E12.8000801@gmail.com> <1316527365.4611.354.camel@hornet.cambridge.arm.com> Message-ID: <4E78A546.9040604@gmail.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Pawel, On 09/20/2011 09:02 AM, Pawel Moll wrote: >>> 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. > > You've misunderstood me or (most likely ;-) probably I wasn't clear > enough. > > There is no doubt the DTs will be different across the "portfolio". > > We already have (patches soon) vexpress-v2p-ca9.dts that includes > vexpress-v2m-legacy.dtsi. > > A5 will be vexpress-v2p-ca5p.dts+vexpress-v2m-rs1.dtsi, A15 > vexpress-v2p-ca15.dts+vexpress-v2m-rs1.dtsi (notice that the A5/A15 are > sharing the v2m bit, as the motherboard is common). > > My point is that we should be able to handle _all_ of them using one > DT_MACHINE_START with a single compat value "arm,vexpress". The only > problem with this (so far) is the mapping. > Yes, you should have 1 DT_MACHINE_START, but arm,vexpress is too generic. You can and should have a list of compatible strings for each board/machine. >> 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. > > Exactly my point :-) I want to have as little duplication as possible. > And the static mapping issue is in the way. > >>> 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. > > Again, no argument from me here :-) > > The question is - where should it be? > Nowhere. It's an OS specific issue, not a h/w issue. >>> 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. > > ... and then and then scan for the sysregs, and add the offset and base > together... Sounds to me like duplication of the of_translate_*()? > >>> 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? > > For the third time, 100% agree :-) Well, 90%. > > What I need is: > > 1. Get the phys address from DT. But how? This is getting as back to my > complaints about still-flat tree and ranges, the node to be used to > describe the mapping. > > 2. The offset inside the mapping will be different (for sysregs it will > be 0 for old mapping, 0x10000 for the new one), so I have to work it out > from the tree as well. And as we are in map_io, the tree is still flat > and... read 1 :-) So create a mapping per peripheral rather than per chip select. Then the virtual address can always be the same. > >> Generally, the trend is to get rid of static mappings as much as >> possible. Doing that first might simplify things. > > You can't do ioremap() before kmalloc() is up and running (correct me if > I am wrong), at least you can't do this in map_io. So the static mapping > is a must sometimes. And actually, with the latest Nico's changes: > Correct. You can't do ioremap until init_irq. map_io and init_early are too early. My point was if you can delay h/w access then you can remove the static mappings. But yes, we generally can't remove them all. SCU and LL debug uart are 2 examples. For the short term, I would just have 2 static iotables and select the right one based on the board's (or motherboard's) compatible string. Long term, we should look into implementing a common early DT address parsing function. Rob > http://thread.gmane.org/gmane.linux.ports.arm.kernel/132762 > > it may even be preferred for peripherals (one mapping shared across all > users). > > Cheers! > > Pawe? > > 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 09:37:58 -0500 Message-ID: <4E78A546.9040604@gmail.com> References: <1316519479.4611.150.camel@hornet.cambridge.arm.com> <4E788E12.8000801@gmail.com> <1316527365.4611.354.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: <1316527365.4611.354.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 UGF3ZWwsCgpPbiAwOS8yMC8yMDExIDA5OjAyIEFNLCBQYXdlbCBNb2xsIHdyb3RlOgo+Pj4gT2Yg Y291cnNlIHRoZSBzaW1wbGVzdCBzb2x1dGlvbiB3b3VsZCBiZSB0byBkZWZpbmUgdHdvIGRpZmZl cmVudAo+Pj4gY29tcGF0aWJsZSB2YWx1ZXMsIGVnLiAiYXJtLHZleHByZXNzLWxlZ2FjeSIgd291 bGQgZXhlY3V0ZSB0aGUgY3VycmVudAo+Pj4gbWFwX2lvIGltcGxlbWVudGF0aW9uLCB3aGlsZSAi YXJtLHZleHByZXNzLXJzMSIgd291bGQgdXNlIGRpZmZlcmVudCBvbmUsCj4+PiBzZXR0aW5nIHVw IHRoZSBvdGhlciBtYXBfZGVzYyAodGhlIE1NSU9fUDJWIG1hY3JvIG11c3QgZGllIG9mIGNvdXJz ZSwKPj4+IHJlcGxhY2VkIHdpdGggYSBydW50aW1lLWRlZmluZWQgdmlydHVhbCBiYXNlIGFkZHJl c3MgZm9yIHRoZQo+Pj4gcGVyaXBoZXJhbHMpLgo+Pj4KPj4+IElmIHlvdSBiZWxpZXZlIHRoYXQn cyB3aGF0IEkgc2hvdWxkIGRvLCBzYXkgaXQgYW5kIHN0b3AgcmVhZGluZyA6LSkKPj4KPj4gWWVz LiBEaWZmZXJlbnQgdGlsZXMgYXJlIGZ1bmRhbWVudGFsbHkgZGlmZmVyZW50IGJvYXJkcywgc28g dGhleSBzaG91bGQKPj4gaGF2ZSBkaWZmZXJlbnQgRFRzLiBVc2luZyBpbmNsdWRlcyBzaG91bGQg aGVscCBtaW5pbWl6ZSBkdXBsaWNhdGlvbiB0aG91Z2guCj4gCj4gWW91J3ZlIG1pc3VuZGVyc3Rv b2QgbWUgb3IgKG1vc3QgbGlrZWx5IDstKSBwcm9iYWJseSBJIHdhc24ndCBjbGVhcgo+IGVub3Vn aC4KPiAKPiBUaGVyZSBpcyBubyBkb3VidCB0aGUgRFRzIHdpbGwgYmUgZGlmZmVyZW50IGFjcm9z cyB0aGUgInBvcnRmb2xpbyIuCj4gCj4gV2UgYWxyZWFkeSBoYXZlIChwYXRjaGVzIHNvb24pIHZl eHByZXNzLXYycC1jYTkuZHRzIHRoYXQgaW5jbHVkZXMKPiB2ZXhwcmVzcy12Mm0tbGVnYWN5LmR0 c2kuCj4gCj4gQTUgd2lsbCBiZSB2ZXhwcmVzcy12MnAtY2E1cC5kdHMrdmV4cHJlc3MtdjJtLXJz MS5kdHNpLCBBMTUKPiB2ZXhwcmVzcy12MnAtY2ExNS5kdHMrdmV4cHJlc3MtdjJtLXJzMS5kdHNp IChub3RpY2UgdGhhdCB0aGUgQTUvQTE1IGFyZQo+IHNoYXJpbmcgdGhlIHYybSBiaXQsIGFzIHRo ZSBtb3RoZXJib2FyZCBpcyBjb21tb24pLgo+IAo+IE15IHBvaW50IGlzIHRoYXQgd2Ugc2hvdWxk IGJlIGFibGUgdG8gaGFuZGxlIF9hbGxfIG9mIHRoZW0gdXNpbmcgb25lCj4gRFRfTUFDSElORV9T VEFSVCB3aXRoIGEgc2luZ2xlIGNvbXBhdCB2YWx1ZSAiYXJtLHZleHByZXNzIi4gVGhlIG9ubHkK PiBwcm9ibGVtIHdpdGggdGhpcyAoc28gZmFyKSBpcyB0aGUgbWFwcGluZy4KPiAKClllcywgeW91 IHNob3VsZCBoYXZlIDEgRFRfTUFDSElORV9TVEFSVCwgYnV0IGFybSx2ZXhwcmVzcyBpcyB0b28K Z2VuZXJpYy4gWW91IGNhbiBhbmQgc2hvdWxkIGhhdmUgYSBsaXN0IG9mIGNvbXBhdGlibGUgc3Ry aW5ncyBmb3IgZWFjaApib2FyZC9tYWNoaW5lLgoKPj4gVGhpbmsgYWJvdXQgaXQgdGhpcyB3YXku IEhvdyB3b3VsZCB5b3Ugc29sdmUgdGhpcyB3aXRob3V0IERUPyBZb3UKPj4gd291bGQgaGF2ZSBh IGJ1bmNoIG9mIGR1cGxpY2F0ZWQgZGF0YSBpbiB0aGUga2VybmVsIGZvciB0aGUgZGlmZmVyZW50 Cj4+IGNvbmZpZ3MuIFNvIHlvdSdyZSBub3QgYW55IHdvcnNlIG9mZiBpbiB0aGlzIHJlZ2FyZCBh bmQgc3RpbGwgaGF2ZSB0aGUKPj4gb3RoZXIgYWR2YW50YWdlcyBvZiBEVC4KPiAKPiBFeGFjdGx5 IG15IHBvaW50IDotKSBJIHdhbnQgdG8gaGF2ZSBhcyBsaXR0bGUgZHVwbGljYXRpb24gYXMgcG9z c2libGUuCj4gQW5kIHRoZSBzdGF0aWMgbWFwcGluZyBpc3N1ZSBpcyBpbiB0aGUgd2F5Lgo+IAo+ Pj4gVG8gbXkgbWluZCBpdCBsb29rZWQgbGlrZSB0aGUgd2hvbGUgbWVjaGFuaXNtIHdhcyBub3Qg ZmxleGlibGUgZW5vdWdoLAo+Pj4gc28gSSB3YW50ZWQgdG8gZXhwbG9yZSBvdGhlciBvcHRpb25z Li4uCj4+Pgo+Pj4gVGhlIG9idmlvdXMgb25lIHdhcyB0byBkZXNjcmliZSB0aGUgcmVxdWlyZWQg c3RhdGljIG1hcHBpbmcgaW4gdGhlIERUUy4KPj4+IEkgZG9uJ3QgbGlrZSB0aGlzIGlkZWEsIHRo b3VnaC4gSXQgY2FuIGhhcmRseSBiZSBjYWxsZWQgImhhcmR3YXJlCj4+PiBkZXNjcmlwdGlvbiIu IEJlc2lkZXMsIHdoYXQgbm9kZSB3b3VsZCBjYXJyeSBzdWNoIGRhdGE/ICJjaG9zZW4iPwo+Pj4g SGFyZGx5Li4uCj4+Pgo+Pj4gV291bGQgaXQgY29udGFpbiBhICJyZWdzIiBwcm9wZXJ0eSB3aXRo IHRoZSBwaHlzaWNhbCBhZGRyZXNzIGFuZAo+Pj4gInZpcnR1YWwtcmVnIiB3aXRoIHRoZSB2aXJ0 dWFsIG9uZT8gQWdhaW4sIGRvZXNuJ3Qgc291bmQgcmlnaHQgdG8gbWUKPj4+IChlc3BlY2lhbGx5 IHRoZSB2aXJ0dWFsIGJpdCwgaG93ZXZlciB0aGUgdmlydHVhbCBhZGRyZXNzIGNvdWxkIGJlIGNv bW1vbgo+Pj4gYmV0d2VlbiBkaWZmZXJlbnQgdmFyaWFudHMgYW5kIGJlIGRlZmluZWQgaW4gdGhl IGJvYXJkIHN1cHBvcnQgY29kZSwgbm90Cj4+PiB0aGUgRFRTKS4KPj4+Cj4+PiBJIGhhdmUgY29u c2lkZXJlZCBhIHJlZmVyZW5jZSAocGhhbmRsZSBvciBhbiBhbGlhcz8pIHRvIHRoZSBub2RlIHRv IGJlCj4+PiBtYXBwZWQgKCJwZXJpcGhlcmFscyIgaW4gbXkgY2FzZSksIGJ1dCB3aGVyZSB0byBk ZWZpbmUgdGhpcyByZWZlcmVuY2U/Cj4+PiBBbnkgaWRlYXM/Cj4+Cj4+IEluICJjaG9zZW4iIGxp a2UgdGhlIGtlcm5lbCBjb21tYW5kIGxpbmUgd291bGQgYmUgdGhlIHBsYWNlLCBidXQgSSBkb24n dAo+PiB0aGluayB0aGF0IGlzIHRoZSByaWdodCBhcHByb2FjaC4gQ2hvc2VuIGlzIHJlYWxseSBm b3IgdGhpbmdzIHRoYXQKPj4gY2hhbmdlIGZyZXF1ZW50bHkgYW5kIHRoaXMgZG9lc24ndCByZWFs bHkgZmFsbCBpbiB0aGF0IGNhdGVnb3J5Lgo+IAo+IEFnYWluLCBubyBhcmd1bWVudCBmcm9tIG1l IGhlcmUgOi0pCj4gCj4gVGhlIHF1ZXN0aW9uIGlzIC0gd2hlcmUgc2hvdWxkIGl0IGJlPwo+IAoK Tm93aGVyZS4gSXQncyBhbiBPUyBzcGVjaWZpYyBpc3N1ZSwgbm90IGEgaC93IGlzc3VlLgoKPj4+ IFRoZXJlIGlzIGFuIGFkZGl0aW9uYWwgcHJvYmxlbSBoZXJlLi4uIFRoZSAibWFwX2lvIiBpcyBl eGVjdXRlZCBiZWZvcmUKPj4+IHRoZSB0cmVlIGlzIHVuLWZsYXR0ZW5lZCwgc286Cj4+Pgo+Pj4g MS4gT25lIGNhbid0IHNpbXBseSB1c2UgIm9mX2ZpbmRfbWF0Y2hpbmdfbm9kZSgpIiAoYXMgaW4g dGhlIGxhdGVzdCBsMngwCj4+PiBwYXRjaGVzKSB0byBmaW5kIHRoZSBpbnRlcmVzdGluZyBub2Rl cyAtIHRoZSBvbmx5IHdheSBvZiBnb2luZyB0aHJvdWdoCj4+PiB0aGUgdHJlZSBpcyByYXcgb2Zf c2Nhbl9mbGF0X2R0KCkgZnVuY3Rpb24uIFRoZXJlZm9yZSBhbnkgY29uZGl0aW9ucwo+Pj4gbW9y ZSBjb21wbGV4IHRoZW4gc3RyaW5nIGNvbXBhcmlzb24gd2l0aCB0aGUgKGZ1bGwpIG5vZGUgbmFt ZSBhcmUKPj4+IHByb2JsZW1hdGljLgo+Pj4KPj4+IDIuIFRoZSB0cmVlIG1hcHBpbmdzIChyYW5n ZXMpIGFyZSBub3QgcmVzb2x2ZWQgeWV0LCBzbyBvbmUgY2FuJ3Qgc2ltcGx5Cj4+PiBnZXQgdGhl IGVmZmVjdGl2ZSBhZGRyZXNzIG9mIGEgbm9kZS4gT25seSAicmF3IiBwcm9wZXJ0aWVzIGFyZQo+ Pj4gYXZhaWxhYmxlLCBzbyBhbGwgb25lIGNhbiBnZXQgc2Nhbm5pbmcgZm9yICJwZXJpcGhlcmFs c0A3IiBub2RlIGlzICIwIDcKPj4+IDAgMHgyMDAwMCIgYXJyYXksIGluc3RlYWQgb2YgdGhlICIw eDEwMDAwMDAwIDB4MDAwMjAwMDAiIHRoYXQgaXMgcmVhbGx5Cj4+PiBpbXBvcnRhbnQuIAo+Pgo+ PiBJZiB5b3UgYWRkIGEgY29tcGF0aWJsZSBmaWVsZCB0byAibW90aGVyYm9hcmQiIG5vZGUsIHRo ZW4geW91IGNhbiByZWFkCj4+IHRoZSByYW5nZXMuCj4gCj4gLi4uIGFuZCB0aGVuIGFuZCB0aGVu IHNjYW4gZm9yIHRoZSBzeXNyZWdzLCBhbmQgYWRkIHRoZSBvZmZzZXQgYW5kIGJhc2UKPiB0b2dl dGhlci4uLiBTb3VuZHMgdG8gbWUgbGlrZSBkdXBsaWNhdGlvbiBvZiB0aGUgb2ZfdHJhbnNsYXRl XyooKT8KPiAKPj4+IEluaXRpYWxseSBJIHdhbnRlZCB0byBmaW5kIHRoZSBtZW50aW9uZWQgZGV2 aWNlcyBhbmQgY3JlYXRlIGluZGl2aWR1YWwKPj4+IG1hcHBpbmdzIGZvciB0aGVtLCBzbyB0aGUg TU1JT19QMlYgd291bGQgYmUgc3RpbGwgdmFsaWQgKGlmIHNsaWdodGx5Cj4+PiAiYWJ1c2VkIiks IGJ1dCBJIGZhaWxlZCBkdWUgdG8gdGhlIHByb2JsZW1zIG1lbnRpb25lZCBhYm92ZS4gQW5kIEkg Y2FuJ3QKPj4+IGRlbGF5IHRoaXMgb3BlcmF0aW9uIHRpbGwgdGhlIHRyZWUgaXMgdW4tZmxhdHRl bmVkLCBhcyB0aGUgY29yZSB0aWxlCj4+PiBtdXN0IGJlIHByb2JlZCAodmlhIHN5c3JlZykgaW4g bWFwX2lvICh0aWxlJ3Mgc3BlY2lmaWMgY29kZSBtdXN0IGJlIGFibGUKPj4+IHRvIGNyZWF0ZSBp dHMgb3duIG1hcHBpbmdzKToKPj4KPj4gRG8geW91IHJlYWxseSBuZWVkIE1NSU9fUDJWPyBJZiB5 b3UgaGF2ZSBmaXhlZCB2aXJ0dWFsIGFkZHJlc3NlcyBpbiB0aGUKPj4ga2VybmVsIGFuZCBjYW4g cHVsbCB0aGUgcGh5cyBhZGRyZXNzZXMgZnJvbSBEVCB0byBwb3B1bGF0ZSB0aGUgaW90YWJsZSwK Pj4gaXMgdGhhdCBzdWZmaWNpZW50Pwo+IAo+IEZvciB0aGUgdGhpcmQgdGltZSwgMTAwJSBhZ3Jl ZSA6LSkgV2VsbCwgOTAlLgo+IAo+IFdoYXQgSSBuZWVkIGlzOgo+IAo+IDEuIEdldCB0aGUgcGh5 cyBhZGRyZXNzIGZyb20gRFQuIEJ1dCBob3c/IFRoaXMgaXMgZ2V0dGluZyBhcyBiYWNrIHRvIG15 Cj4gY29tcGxhaW50cyBhYm91dCBzdGlsbC1mbGF0IHRyZWUgYW5kIHJhbmdlcywgdGhlIG5vZGUg dG8gYmUgdXNlZCB0bwo+IGRlc2NyaWJlIHRoZSBtYXBwaW5nLgo+IAo+IDIuIFRoZSBvZmZzZXQg aW5zaWRlIHRoZSBtYXBwaW5nIHdpbGwgYmUgZGlmZmVyZW50IChmb3Igc3lzcmVncyBpdCB3aWxs Cj4gYmUgMCBmb3Igb2xkIG1hcHBpbmcsIDB4MTAwMDAgZm9yIHRoZSBuZXcgb25lKSwgc28gSSBo YXZlIHRvIHdvcmsgaXQgb3V0Cj4gZnJvbSB0aGUgdHJlZSBhcyB3ZWxsLiBBbmQgYXMgd2UgYXJl IGluIG1hcF9pbywgdGhlIHRyZWUgaXMgc3RpbGwgZmxhdAo+IGFuZC4uLiByZWFkIDEgOi0pCgpT byBjcmVhdGUgYSBtYXBwaW5nIHBlciBwZXJpcGhlcmFsIHJhdGhlciB0aGFuIHBlciBjaGlwIHNl bGVjdC4gVGhlbiB0aGUKdmlydHVhbCBhZGRyZXNzIGNhbiBhbHdheXMgYmUgdGhlIHNhbWUuCgo+ IAo+PiBHZW5lcmFsbHksIHRoZSB0cmVuZCBpcyB0byBnZXQgcmlkIG9mIHN0YXRpYyBtYXBwaW5n cyBhcyBtdWNoIGFzCj4+IHBvc3NpYmxlLiBEb2luZyB0aGF0IGZpcnN0IG1pZ2h0IHNpbXBsaWZ5 IHRoaW5ncy4KPiAKPiBZb3UgY2FuJ3QgZG8gaW9yZW1hcCgpIGJlZm9yZSBrbWFsbG9jKCkgaXMg dXAgYW5kIHJ1bm5pbmcgKGNvcnJlY3QgbWUgaWYKPiBJIGFtIHdyb25nKSwgYXQgbGVhc3QgeW91 IGNhbid0IGRvIHRoaXMgaW4gbWFwX2lvLiBTbyB0aGUgc3RhdGljIG1hcHBpbmcKPiBpcyBhIG11 c3Qgc29tZXRpbWVzLiBBbmQgYWN0dWFsbHksIHdpdGggdGhlIGxhdGVzdCBOaWNvJ3MgY2hhbmdl czoKPiAKQ29ycmVjdC4gWW91IGNhbid0IGRvIGlvcmVtYXAgdW50aWwgaW5pdF9pcnEuIG1hcF9p byBhbmQgaW5pdF9lYXJseSBhcmUKdG9vIGVhcmx5LiBNeSBwb2ludCB3YXMgaWYgeW91IGNhbiBk ZWxheSBoL3cgYWNjZXNzIHRoZW4geW91IGNhbiByZW1vdmUKdGhlIHN0YXRpYyBtYXBwaW5ncy4g QnV0IHllcywgd2UgZ2VuZXJhbGx5IGNhbid0IHJlbW92ZSB0aGVtIGFsbC4gU0NVCmFuZCBMTCBk ZWJ1ZyB1YXJ0IGFyZSAyIGV4YW1wbGVzLgoKRm9yIHRoZSBzaG9ydCB0ZXJtLCBJIHdvdWxkIGp1 c3QgaGF2ZSAyIHN0YXRpYyBpb3RhYmxlcyBhbmQgc2VsZWN0IHRoZQpyaWdodCBvbmUgYmFzZWQg b24gdGhlIGJvYXJkJ3MgKG9yIG1vdGhlcmJvYXJkJ3MpIGNvbXBhdGlibGUgc3RyaW5nLgoKTG9u ZyB0ZXJtLCB3ZSBzaG91bGQgbG9vayBpbnRvIGltcGxlbWVudGluZyBhIGNvbW1vbiBlYXJseSBE VCBhZGRyZXNzCnBhcnNpbmcgZnVuY3Rpb24uCgpSb2IKCj4gaHR0cDovL3RocmVhZC5nbWFuZS5v cmcvZ21hbmUubGludXgucG9ydHMuYXJtLmtlcm5lbC8xMzI3NjIKPiAKPiBpdCBtYXkgZXZlbiBi ZSBwcmVmZXJyZWQgZm9yIHBlcmlwaGVyYWxzIChvbmUgbWFwcGluZyBzaGFyZWQgYWNyb3NzIGFs bAo+IHVzZXJzKS4KPiAKPiBDaGVlcnMhCj4gCj4gUGF3ZcWCCj4gCj4gCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkZXZpY2V0cmVlLWRpc2N1c3MgbWFp bGluZyBsaXN0CmRldmljZXRyZWUtZGlzY3Vzc0BsaXN0cy5vemxhYnMub3JnCmh0dHBzOi8vbGlz dHMub3psYWJzLm9yZy9saXN0aW5mby9kZXZpY2V0cmVlLWRpc2N1c3MK