From mboxrd@z Thu Jan 1 00:00:00 1970 From: jonathan.austin@arm.com (Jonathan Austin) Date: Wed, 12 Jun 2013 11:10:49 +0100 Subject: [PATCH] of: Add missing node iteration stubs for disabled CONFIG_OF In-Reply-To: <20130611215147.199B13E0D8D@localhost> References: <1362860154-3089-1-git-send-email-tomasz.figa@gmail.com> <5159F9E6.50508@gmail.com> <51B74EDF.2090504@arm.com> <20130611215147.199B13E0D8D@localhost> Message-ID: <51B84929.4050802@arm.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On 11/06/13 22:51, Grant Likely wrote: > On Tue, 11 Jun 2013 17:22:55 +0100, Jonathan Austin wrote: >> Hi Rob, Thomasz, >> >> (dredging up an oldish thread as I just ran in to this issue) >> >> On 01/04/13 22:19, Rob Herring wrote: >>> On 03/09/2013 02:15 PM, Tomasz Figa wrote: >>>> This patch moves several for_each macros out of the #ifdef CONFIG_OF >>>> block and adds inline stubs for functions used by these macros, compiled >>>> conditionally when CONFIG_OF is not enabled. >>>> >>>> This eliminates the need to explicitly check for CONFIG_OF in driver >>>> code using mentioned functions and macros. >>> >>> Do you have some users of this? >> >> I do! >> >> Or at least I might. >> >> I'm not certain as perhaps the fix to what I describe below is to add >> dependencies on CONFIG_OF - it isn't clear to me either way: >> >> With both psci and arch_timers (CONFIG_ARM_PSCI, CONFIG_ARM_ARCH_TIMER) >> and without CONFIG_OF we get a build failure because we lack the definition >> of of_find_matching_node(): >> >> eg: >> arch/arm/kernel/psci.c:167:2: error: implicit declaration of function ???of_find_matching_node??? [-Werror=implicit-function-declaration] >> >> The same happens with arm_arch_timer.c (well, there's a patch required to >> include linux/of.h first, after which Thomasz's patch is relevant). > > That code path is completely broken if CONFIG_OF is not set. psci_init() > is nothing but calls to CONFIG_OF infrastructure! I think that code Well, it looks like the intention of that code was to just behave like there was no relevant node in the case the CONFIG_OF was disabled: np = of_find_matching_node(NULL, psci_of_match); if (!np) return 0; If of_find_matching() node behaved like of_match_node() then nothing would be 'broken' per se, but we would have a bunch of useless code compiled in to our kernel. > needs to depend on CONFIG_OF, or at least be wrapped with > "if (IS_ENABLED(CONFIG_OF))" if there are still usable parts when > CONFIG_OF is disabled. Frankly I don't see that as being a real concern. Indeed, despite the clarification above, I think it'd be fine to not build these without CONFIG_OF. I'm happy to submit a patches to add dependencies on CONFIG_OF for ARM_ARCH_TIMER and ARM_PSCI - I don't think either of those will get any complaints because as you say, neither makes very much sense without a DT to specify them. Thanks, Jonny > > That said, Arnd has posted a patch that moves at least some of the function > prototypes out from under the #ifdef block so that GCC can do syntax > checking on disabled code. That overlaps a bit with this patch. > > Regardless, I'm not going to apply it without a legitimate (as opposed > to theoretical) user. > > g. > >> So, I guess the question is whether we should expect PSCI and ARM_ARCH_TIMER >> to depend on CONFIG_OF, or whether we'd like them to fail gracefully in the >> case that we *don't* have CONFIG_OF. I think the current situation is broken >> either way... >> >> Thoughts? >> >> Jonny >> >>> >>> Rob >>> >>>> >>>> Signed-off-by: Tomasz Figa >>>> --- >>>> include/linux/of.h | 92 +++++++++++++++++++++++++++++++++++++----------------- >>>> 1 file changed, 63 insertions(+), 29 deletions(-) >>>> >>>> diff --git a/include/linux/of.h b/include/linux/of.h >>>> index a0f1292..7a736b8 100644 >>>> --- a/include/linux/of.h >>>> +++ b/include/linux/of.h >>>> @@ -86,6 +86,31 @@ static inline struct device_node *of_node_get(struct device_node *node) >>>> static inline void of_node_put(struct device_node *node) { } >>>> #endif /* !CONFIG_OF_DYNAMIC */ >>>> >>>> +#define for_each_node_by_name(dn, name) \ >>>> + for (dn = of_find_node_by_name(NULL, name); dn; \ >>>> + dn = of_find_node_by_name(dn, name)) >>>> +#define for_each_node_by_type(dn, type) \ >>>> + for (dn = of_find_node_by_type(NULL, type); dn; \ >>>> + dn = of_find_node_by_type(dn, type)) >>>> +#define for_each_compatible_node(dn, type, compatible) \ >>>> + for (dn = of_find_compatible_node(NULL, type, compatible); dn; \ >>>> + dn = of_find_compatible_node(dn, type, compatible)) >>>> +#define for_each_matching_node(dn, matches) \ >>>> + for (dn = of_find_matching_node(NULL, matches); dn; \ >>>> + dn = of_find_matching_node(dn, matches)) >>>> +#define for_each_matching_node_and_match(dn, matches, match) \ >>>> + for (dn = of_find_matching_node_and_match(NULL, matches, match); \ >>>> + dn; dn = of_find_matching_node_and_match(dn, matches, match)) >>>> +#define for_each_child_of_node(parent, child) \ >>>> + for (child = of_get_next_child(parent, NULL); child != NULL; \ >>>> + child = of_get_next_child(parent, child)) >>>> +#define for_each_available_child_of_node(parent, child) \ >>>> + for (child = of_get_next_available_child(parent, NULL); child != NULL; \ >>>> + child = of_get_next_available_child(parent, child)) >>>> +#define for_each_node_with_property(dn, prop_name) \ >>>> + for (dn = of_find_node_with_property(NULL, prop_name); dn; \ >>>> + dn = of_find_node_with_property(dn, prop_name)) >>>> + >>>> #ifdef CONFIG_OF >>>> >>>> /* Pointer for first entry in chain of all nodes. */ >>>> @@ -167,19 +192,10 @@ static inline const char *of_node_full_name(const struct device_node *np) >>>> >>>> extern struct device_node *of_find_node_by_name(struct device_node *from, >>>> const char *name); >>>> -#define for_each_node_by_name(dn, name) \ >>>> - for (dn = of_find_node_by_name(NULL, name); dn; \ >>>> - dn = of_find_node_by_name(dn, name)) >>>> extern struct device_node *of_find_node_by_type(struct device_node *from, >>>> const char *type); >>>> -#define for_each_node_by_type(dn, type) \ >>>> - for (dn = of_find_node_by_type(NULL, type); dn; \ >>>> - dn = of_find_node_by_type(dn, type)) >>>> extern struct device_node *of_find_compatible_node(struct device_node *from, >>>> const char *type, const char *compat); >>>> -#define for_each_compatible_node(dn, type, compatible) \ >>>> - for (dn = of_find_compatible_node(NULL, type, compatible); dn; \ >>>> - dn = of_find_compatible_node(dn, type, compatible)) >>>> extern struct device_node *of_find_matching_node_and_match( >>>> struct device_node *from, >>>> const struct of_device_id *matches, >>>> @@ -190,12 +206,6 @@ static inline struct device_node *of_find_matching_node( >>>> { >>>> return of_find_matching_node_and_match(from, matches, NULL); >>>> } >>>> -#define for_each_matching_node(dn, matches) \ >>>> - for (dn = of_find_matching_node(NULL, matches); dn; \ >>>> - dn = of_find_matching_node(dn, matches)) >>>> -#define for_each_matching_node_and_match(dn, matches, match) \ >>>> - for (dn = of_find_matching_node_and_match(NULL, matches, match); \ >>>> - dn; dn = of_find_matching_node_and_match(dn, matches, match)) >>>> extern struct device_node *of_find_node_by_path(const char *path); >>>> extern struct device_node *of_find_node_by_phandle(phandle handle); >>>> extern struct device_node *of_get_parent(const struct device_node *node); >>>> @@ -207,14 +217,6 @@ extern struct device_node *of_get_next_available_child( >>>> >>>> extern struct device_node *of_get_child_by_name(const struct device_node *node, >>>> const char *name); >>>> -#define for_each_child_of_node(parent, child) \ >>>> - for (child = of_get_next_child(parent, NULL); child != NULL; \ >>>> - child = of_get_next_child(parent, child)) >>>> - >>>> -#define for_each_available_child_of_node(parent, child) \ >>>> - for (child = of_get_next_available_child(parent, NULL); child != NULL; \ >>>> - child = of_get_next_available_child(parent, child)) >>>> - >>>> static inline int of_get_child_count(const struct device_node *np) >>>> { >>>> struct device_node *child; >>>> @@ -228,10 +230,6 @@ static inline int of_get_child_count(const struct device_node *np) >>>> >>>> extern struct device_node *of_find_node_with_property( >>>> struct device_node *from, const char *prop_name); >>>> -#define for_each_node_with_property(dn, prop_name) \ >>>> - for (dn = of_find_node_with_property(NULL, prop_name); dn; \ >>>> - dn = of_find_node_with_property(dn, prop_name)) >>>> - >>>> extern struct property *of_find_property(const struct device_node *np, >>>> const char *name, >>>> int *lenp); >>>> @@ -353,13 +351,28 @@ static inline struct device_node *of_find_node_by_name(struct device_node *from, >>>> return NULL; >>>> } >>>> >>>> +static inline struct device_node *of_find_node_by_type(struct device_node *from, >>>> + const char *type) >>>> +{ >>>> + return NULL; >>>> +} >>>> + >>>> static inline bool of_have_populated_dt(void) >>>> { >>>> return false; >>>> } >>>> >>>> -#define for_each_child_of_node(parent, child) \ >>>> - while (0) >>>> +static inline struct device_node *of_get_next_child(const struct device_node *node, >>>> + struct device_node *prev) >>>> +{ >>>> + return NULL; >>>> +} >>>> + >>>> +static inline struct device_node *of_get_next_available_child( >>>> + const struct device_node *node, struct device_node *prev) >>>> +{ >>>> + return NULL; >>>> +} >>>> >>>> static inline struct device_node *of_get_child_by_name( >>>> const struct device_node *node, >>>> @@ -373,6 +386,12 @@ static inline int of_get_child_count(const struct device_node *np) >>>> return 0; >>>> } >>>> >>>> +static inline struct device_node *of_find_node_with_property( >>>> + struct device_node *from, const char *prop_name) >>>> +{ >>>> + return NULL; >>>> +} >>>> + >>>> static inline int of_device_is_compatible(const struct device_node *device, >>>> const char *name) >>>> { >>>> @@ -394,6 +413,21 @@ static inline struct device_node *of_find_compatible_node( >>>> return NULL; >>>> } >>>> >>>> +static inline struct device_node *of_find_matching_node_and_match( >>>> + struct device_node *from, >>>> + const struct of_device_id *matches, >>>> + const struct of_device_id **match) >>>> +{ >>>> + return NULL; >>>> +} >>>> + >>>> +static inline struct device_node *of_find_matching_node( >>>> + struct device_node *from, >>>> + const struct of_device_id *matches) >>>> +{ >>>> + return NULL; >>>> +} >>>> + >>>> static inline int of_property_read_u8_array(const struct device_node *np, >>>> const char *propname, u8 *out_values, size_t sz) >>>> { >>>> >>> >>> >>> _______________________________________________ >>> linux-arm-kernel mailing list >>> linux-arm-kernel at lists.infradead.org >>> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel >>> >> >> >> >> _______________________________________________ >> 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: Jonathan Austin Subject: Re: [PATCH] of: Add missing node iteration stubs for disabled CONFIG_OF Date: Wed, 12 Jun 2013 11:10:49 +0100 Message-ID: <51B84929.4050802@arm.com> References: <1362860154-3089-1-git-send-email-tomasz.figa@gmail.com> <5159F9E6.50508@gmail.com> <51B74EDF.2090504@arm.com> <20130611215147.199B13E0D8D@localhost> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20130611215147.199B13E0D8D@localhost> 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: Grant Likely Cc: Mark Rutland , Kukjin Kim , "devicetree-discuss@lists.ozlabs.org" , Will Deacon , Tomasz Figa , "rob.herring@calxeda.com" , "linux-arm-kernel@lists.infradead.org" List-Id: devicetree@vger.kernel.org T24gMTEvMDYvMTMgMjI6NTEsIEdyYW50IExpa2VseSB3cm90ZToKPiBPbiBUdWUsIDExIEp1biAy MDEzIDE3OjIyOjU1ICswMTAwLCBKb25hdGhhbiBBdXN0aW4gPGpvbmF0aGFuLmF1c3RpbkBhcm0u Y29tPiB3cm90ZToKPj4gSGkgUm9iLCBUaG9tYXN6LAo+Pgo+PiAoZHJlZGdpbmcgdXAgYW4gb2xk aXNoIHRocmVhZCBhcyBJIGp1c3QgcmFuIGluIHRvIHRoaXMgaXNzdWUpCj4+Cj4+IE9uIDAxLzA0 LzEzIDIyOjE5LCBSb2IgSGVycmluZyB3cm90ZToKPj4+IE9uIDAzLzA5LzIwMTMgMDI6MTUgUE0s IFRvbWFzeiBGaWdhIHdyb3RlOgo+Pj4+IFRoaXMgcGF0Y2ggbW92ZXMgc2V2ZXJhbCBmb3JfZWFj aCBtYWNyb3Mgb3V0IG9mIHRoZSAjaWZkZWYgQ09ORklHX09GCj4+Pj4gYmxvY2sgYW5kIGFkZHMg aW5saW5lIHN0dWJzIGZvciBmdW5jdGlvbnMgdXNlZCBieSB0aGVzZSBtYWNyb3MsIGNvbXBpbGVk Cj4+Pj4gY29uZGl0aW9uYWxseSB3aGVuIENPTkZJR19PRiBpcyBub3QgZW5hYmxlZC4KPj4+Pgo+ Pj4+IFRoaXMgZWxpbWluYXRlcyB0aGUgbmVlZCB0byBleHBsaWNpdGx5IGNoZWNrIGZvciBDT05G SUdfT0YgaW4gZHJpdmVyCj4+Pj4gY29kZSB1c2luZyBtZW50aW9uZWQgZnVuY3Rpb25zIGFuZCBt YWNyb3MuCj4+Pgo+Pj4gRG8geW91IGhhdmUgc29tZSB1c2VycyBvZiB0aGlzPwo+Pgo+PiBJIGRv IQo+Pgo+PiBPciBhdCBsZWFzdCBJIG1pZ2h0Lgo+Pgo+PiBJJ20gbm90IGNlcnRhaW4gYXMgcGVy aGFwcyB0aGUgZml4IHRvIHdoYXQgSSBkZXNjcmliZSBiZWxvdyBpcyB0byBhZGQKPj4gZGVwZW5k ZW5jaWVzIG9uIENPTkZJR19PRiAtIGl0IGlzbid0IGNsZWFyIHRvIG1lIGVpdGhlciB3YXk6Cj4+ Cj4+IFdpdGggYm90aCBwc2NpIGFuZCBhcmNoX3RpbWVycyAoQ09ORklHX0FSTV9QU0NJLCBDT05G SUdfQVJNX0FSQ0hfVElNRVIpCj4+IGFuZCB3aXRob3V0IENPTkZJR19PRiB3ZSBnZXQgYSBidWls ZCBmYWlsdXJlIGJlY2F1c2Ugd2UgbGFjayB0aGUgZGVmaW5pdGlvbgo+PiBvZiBvZl9maW5kX21h dGNoaW5nX25vZGUoKToKPj4KPj4gZWc6Cj4+IGFyY2gvYXJtL2tlcm5lbC9wc2NpLmM6MTY3OjI6 IGVycm9yOiBpbXBsaWNpdCBkZWNsYXJhdGlvbiBvZiBmdW5jdGlvbiDDouKCrMucb2ZfZmluZF9t YXRjaGluZ19ub2Rlw6LigqzihKIgWy1XZXJyb3I9aW1wbGljaXQtZnVuY3Rpb24tZGVjbGFyYXRp b25dCj4+Cj4+IFRoZSBzYW1lIGhhcHBlbnMgd2l0aCBhcm1fYXJjaF90aW1lci5jICh3ZWxsLCB0 aGVyZSdzIGEgcGF0Y2ggcmVxdWlyZWQgdG8KPj4gaW5jbHVkZSBsaW51eC9vZi5oIGZpcnN0LCBh ZnRlciB3aGljaCBUaG9tYXN6J3MgcGF0Y2ggaXMgcmVsZXZhbnQpLgo+Cj4gVGhhdCBjb2RlIHBh dGggaXMgY29tcGxldGVseSBicm9rZW4gaWYgQ09ORklHX09GIGlzIG5vdCBzZXQuIHBzY2lfaW5p dCgpCj4gaXMgbm90aGluZyBidXQgY2FsbHMgdG8gQ09ORklHX09GIGluZnJhc3RydWN0dXJlISBJ IHRoaW5rIHRoYXQgY29kZQoKV2VsbCwgaXQgbG9va3MgbGlrZSB0aGUgaW50ZW50aW9uIG9mIHRo YXQgY29kZSB3YXMgdG8ganVzdCBiZWhhdmUgbGlrZSAKdGhlcmUgd2FzIG5vIHJlbGV2YW50IG5v ZGUgaW4gdGhlIGNhc2UgdGhlIENPTkZJR19PRiB3YXMgZGlzYWJsZWQ6CgoJbnAgPSBvZl9maW5k X21hdGNoaW5nX25vZGUoTlVMTCwgcHNjaV9vZl9tYXRjaCk7CglpZiAoIW5wKQoJCXJldHVybiAw OwoKSWYgb2ZfZmluZF9tYXRjaGluZygpIG5vZGUgYmVoYXZlZCBsaWtlIG9mX21hdGNoX25vZGUo KSB0aGVuIG5vdGhpbmcgCndvdWxkIGJlICdicm9rZW4nIHBlciBzZSwgYnV0IHdlIHdvdWxkIGhh dmUgYSBidW5jaCBvZiB1c2VsZXNzIGNvZGUgCmNvbXBpbGVkIGluIHRvIG91ciBrZXJuZWwuCgo+ IG5lZWRzIHRvIGRlcGVuZCBvbiBDT05GSUdfT0YsIG9yIGF0IGxlYXN0IGJlIHdyYXBwZWQgd2l0 aAo+ICJpZiAoSVNfRU5BQkxFRChDT05GSUdfT0YpKSIgaWYgdGhlcmUgYXJlIHN0aWxsIHVzYWJs ZSBwYXJ0cyB3aGVuCj4gQ09ORklHX09GIGlzIGRpc2FibGVkLiBGcmFua2x5IEkgZG9uJ3Qgc2Vl IHRoYXQgYXMgYmVpbmcgYSByZWFsIGNvbmNlcm4uCgpJbmRlZWQsIGRlc3BpdGUgdGhlIGNsYXJp ZmljYXRpb24gYWJvdmUsIEkgdGhpbmsgaXQnZCBiZSBmaW5lIHRvIG5vdCAKYnVpbGQgdGhlc2Ug d2l0aG91dCBDT05GSUdfT0YuCgpJJ20gaGFwcHkgdG8gc3VibWl0IGEgcGF0Y2hlcyB0byBhZGQg ZGVwZW5kZW5jaWVzIG9uIENPTkZJR19PRiBmb3IgCkFSTV9BUkNIX1RJTUVSIGFuZCBBUk1fUFND SSAtIEkgZG9uJ3QgdGhpbmsgZWl0aGVyIG9mIHRob3NlIHdpbGwgZ2V0IGFueSAKY29tcGxhaW50 cyBiZWNhdXNlIGFzIHlvdSBzYXksIG5laXRoZXIgbWFrZXMgdmVyeSBtdWNoIHNlbnNlIHdpdGhv dXQgYSAKRFQgdG8gc3BlY2lmeSB0aGVtLgoKVGhhbmtzLApKb25ueQoKPgo+IFRoYXQgc2FpZCwg QXJuZCBoYXMgcG9zdGVkIGEgcGF0Y2ggdGhhdCBtb3ZlcyBhdCBsZWFzdCBzb21lIG9mIHRoZSBm dW5jdGlvbgo+IHByb3RvdHlwZXMgb3V0IGZyb20gdW5kZXIgdGhlICNpZmRlZiBibG9jayBzbyB0 aGF0IEdDQyBjYW4gZG8gc3ludGF4Cj4gY2hlY2tpbmcgb24gZGlzYWJsZWQgY29kZS4gVGhhdCBv dmVybGFwcyBhIGJpdCB3aXRoIHRoaXMgcGF0Y2guCj4KPiBSZWdhcmRsZXNzLCBJJ20gbm90IGdv aW5nIHRvIGFwcGx5IGl0IHdpdGhvdXQgYSBsZWdpdGltYXRlIChhcyBvcHBvc2VkCj4gdG8gdGhl b3JldGljYWwpIHVzZXIuCj4KPiBnLgo+Cj4+IFNvLCBJIGd1ZXNzIHRoZSBxdWVzdGlvbiBpcyB3 aGV0aGVyIHdlIHNob3VsZCBleHBlY3QgUFNDSSBhbmQgQVJNX0FSQ0hfVElNRVIKPj4gdG8gZGVw ZW5kIG9uIENPTkZJR19PRiwgb3Igd2hldGhlciB3ZSdkIGxpa2UgdGhlbSB0byBmYWlsIGdyYWNl ZnVsbHkgaW4gdGhlCj4+IGNhc2UgdGhhdCB3ZSAqZG9uJ3QqIGhhdmUgQ09ORklHX09GLiBJIHRo aW5rIHRoZSBjdXJyZW50IHNpdHVhdGlvbiBpcyBicm9rZW4KPj4gZWl0aGVyIHdheS4uLgo+Pgo+ PiBUaG91Z2h0cz8KPj4KPj4gSm9ubnkKPj4KPj4+Cj4+PiBSb2IKPj4+Cj4+Pj4KPj4+PiBTaWdu ZWQtb2ZmLWJ5OiBUb21hc3ogRmlnYSA8dG9tYXN6LmZpZ2FAZ21haWwuY29tPgo+Pj4+IC0tLQo+ Pj4+ICAgIGluY2x1ZGUvbGludXgvb2YuaCB8IDkyICsrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKystLS0tLS0tLS0tLS0tLS0tLQo+Pj4+ICAgIDEgZmlsZSBjaGFuZ2VkLCA2MyBp bnNlcnRpb25zKCspLCAyOSBkZWxldGlvbnMoLSkKPj4+Pgo+Pj4+IGRpZmYgLS1naXQgYS9pbmNs dWRlL2xpbnV4L29mLmggYi9pbmNsdWRlL2xpbnV4L29mLmgKPj4+PiBpbmRleCBhMGYxMjkyLi43 YTczNmI4IDEwMDY0NAo+Pj4+IC0tLSBhL2luY2x1ZGUvbGludXgvb2YuaAo+Pj4+ICsrKyBiL2lu Y2x1ZGUvbGludXgvb2YuaAo+Pj4+IEBAIC04Niw2ICs4NiwzMSBAQCBzdGF0aWMgaW5saW5lIHN0 cnVjdCBkZXZpY2Vfbm9kZSAqb2Zfbm9kZV9nZXQoc3RydWN0IGRldmljZV9ub2RlICpub2RlKQo+ Pj4+ICAgIHN0YXRpYyBpbmxpbmUgdm9pZCBvZl9ub2RlX3B1dChzdHJ1Y3QgZGV2aWNlX25vZGUg Km5vZGUpIHsgfQo+Pj4+ICAgICNlbmRpZiAvKiAhQ09ORklHX09GX0RZTkFNSUMgKi8KPj4+Pgo+ Pj4+ICsjZGVmaW5lIGZvcl9lYWNoX25vZGVfYnlfbmFtZShkbiwgbmFtZSkgXAo+Pj4+ICsgICAg IGZvciAoZG4gPSBvZl9maW5kX25vZGVfYnlfbmFtZShOVUxMLCBuYW1lKTsgZG47IFwKPj4+PiAr ICAgICAgICAgIGRuID0gb2ZfZmluZF9ub2RlX2J5X25hbWUoZG4sIG5hbWUpKQo+Pj4+ICsjZGVm aW5lIGZvcl9lYWNoX25vZGVfYnlfdHlwZShkbiwgdHlwZSkgXAo+Pj4+ICsgICAgIGZvciAoZG4g PSBvZl9maW5kX25vZGVfYnlfdHlwZShOVUxMLCB0eXBlKTsgZG47IFwKPj4+PiArICAgICAgICAg IGRuID0gb2ZfZmluZF9ub2RlX2J5X3R5cGUoZG4sIHR5cGUpKQo+Pj4+ICsjZGVmaW5lIGZvcl9l YWNoX2NvbXBhdGlibGVfbm9kZShkbiwgdHlwZSwgY29tcGF0aWJsZSkgXAo+Pj4+ICsgICAgIGZv ciAoZG4gPSBvZl9maW5kX2NvbXBhdGlibGVfbm9kZShOVUxMLCB0eXBlLCBjb21wYXRpYmxlKTsg ZG47IFwKPj4+PiArICAgICAgICAgIGRuID0gb2ZfZmluZF9jb21wYXRpYmxlX25vZGUoZG4sIHR5 cGUsIGNvbXBhdGlibGUpKQo+Pj4+ICsjZGVmaW5lIGZvcl9lYWNoX21hdGNoaW5nX25vZGUoZG4s IG1hdGNoZXMpIFwKPj4+PiArICAgICBmb3IgKGRuID0gb2ZfZmluZF9tYXRjaGluZ19ub2RlKE5V TEwsIG1hdGNoZXMpOyBkbjsgXAo+Pj4+ICsgICAgICAgICAgZG4gPSBvZl9maW5kX21hdGNoaW5n X25vZGUoZG4sIG1hdGNoZXMpKQo+Pj4+ICsjZGVmaW5lIGZvcl9lYWNoX21hdGNoaW5nX25vZGVf YW5kX21hdGNoKGRuLCBtYXRjaGVzLCBtYXRjaCkgXAo+Pj4+ICsgICAgIGZvciAoZG4gPSBvZl9m aW5kX21hdGNoaW5nX25vZGVfYW5kX21hdGNoKE5VTEwsIG1hdGNoZXMsIG1hdGNoKTsgXAo+Pj4+ ICsgICAgICAgICAgZG47IGRuID0gb2ZfZmluZF9tYXRjaGluZ19ub2RlX2FuZF9tYXRjaChkbiwg bWF0Y2hlcywgbWF0Y2gpKQo+Pj4+ICsjZGVmaW5lIGZvcl9lYWNoX2NoaWxkX29mX25vZGUocGFy ZW50LCBjaGlsZCkgXAo+Pj4+ICsgICAgIGZvciAoY2hpbGQgPSBvZl9nZXRfbmV4dF9jaGlsZChw YXJlbnQsIE5VTEwpOyBjaGlsZCAhPSBOVUxMOyBcCj4+Pj4gKyAgICAgICAgICBjaGlsZCA9IG9m X2dldF9uZXh0X2NoaWxkKHBhcmVudCwgY2hpbGQpKQo+Pj4+ICsjZGVmaW5lIGZvcl9lYWNoX2F2 YWlsYWJsZV9jaGlsZF9vZl9ub2RlKHBhcmVudCwgY2hpbGQpIFwKPj4+PiArICAgICBmb3IgKGNo aWxkID0gb2ZfZ2V0X25leHRfYXZhaWxhYmxlX2NoaWxkKHBhcmVudCwgTlVMTCk7IGNoaWxkICE9 IE5VTEw7IFwKPj4+PiArICAgICAgICAgIGNoaWxkID0gb2ZfZ2V0X25leHRfYXZhaWxhYmxlX2No aWxkKHBhcmVudCwgY2hpbGQpKQo+Pj4+ICsjZGVmaW5lIGZvcl9lYWNoX25vZGVfd2l0aF9wcm9w ZXJ0eShkbiwgcHJvcF9uYW1lKSBcCj4+Pj4gKyAgICAgZm9yIChkbiA9IG9mX2ZpbmRfbm9kZV93 aXRoX3Byb3BlcnR5KE5VTEwsIHByb3BfbmFtZSk7IGRuOyBcCj4+Pj4gKyAgICAgICAgICBkbiA9 IG9mX2ZpbmRfbm9kZV93aXRoX3Byb3BlcnR5KGRuLCBwcm9wX25hbWUpKQo+Pj4+ICsKPj4+PiAg ICAjaWZkZWYgQ09ORklHX09GCj4+Pj4KPj4+PiAgICAvKiBQb2ludGVyIGZvciBmaXJzdCBlbnRy eSBpbiBjaGFpbiBvZiBhbGwgbm9kZXMuICovCj4+Pj4gQEAgLTE2NywxOSArMTkyLDEwIEBAIHN0 YXRpYyBpbmxpbmUgY29uc3QgY2hhciAqb2Zfbm9kZV9mdWxsX25hbWUoY29uc3Qgc3RydWN0IGRl dmljZV9ub2RlICpucCkKPj4+Pgo+Pj4+ICAgIGV4dGVybiBzdHJ1Y3QgZGV2aWNlX25vZGUgKm9m X2ZpbmRfbm9kZV9ieV9uYW1lKHN0cnVjdCBkZXZpY2Vfbm9kZSAqZnJvbSwKPj4+PiAgICAgICAg IGNvbnN0IGNoYXIgKm5hbWUpOwo+Pj4+IC0jZGVmaW5lIGZvcl9lYWNoX25vZGVfYnlfbmFtZShk biwgbmFtZSkgXAo+Pj4+IC0gICAgIGZvciAoZG4gPSBvZl9maW5kX25vZGVfYnlfbmFtZShOVUxM LCBuYW1lKTsgZG47IFwKPj4+PiAtICAgICAgICAgIGRuID0gb2ZfZmluZF9ub2RlX2J5X25hbWUo ZG4sIG5hbWUpKQo+Pj4+ICAgIGV4dGVybiBzdHJ1Y3QgZGV2aWNlX25vZGUgKm9mX2ZpbmRfbm9k ZV9ieV90eXBlKHN0cnVjdCBkZXZpY2Vfbm9kZSAqZnJvbSwKPj4+PiAgICAgICAgIGNvbnN0IGNo YXIgKnR5cGUpOwo+Pj4+IC0jZGVmaW5lIGZvcl9lYWNoX25vZGVfYnlfdHlwZShkbiwgdHlwZSkg XAo+Pj4+IC0gICAgIGZvciAoZG4gPSBvZl9maW5kX25vZGVfYnlfdHlwZShOVUxMLCB0eXBlKTsg ZG47IFwKPj4+PiAtICAgICAgICAgIGRuID0gb2ZfZmluZF9ub2RlX2J5X3R5cGUoZG4sIHR5cGUp KQo+Pj4+ICAgIGV4dGVybiBzdHJ1Y3QgZGV2aWNlX25vZGUgKm9mX2ZpbmRfY29tcGF0aWJsZV9u b2RlKHN0cnVjdCBkZXZpY2Vfbm9kZSAqZnJvbSwKPj4+PiAgICAgICAgIGNvbnN0IGNoYXIgKnR5 cGUsIGNvbnN0IGNoYXIgKmNvbXBhdCk7Cj4+Pj4gLSNkZWZpbmUgZm9yX2VhY2hfY29tcGF0aWJs ZV9ub2RlKGRuLCB0eXBlLCBjb21wYXRpYmxlKSBcCj4+Pj4gLSAgICAgZm9yIChkbiA9IG9mX2Zp bmRfY29tcGF0aWJsZV9ub2RlKE5VTEwsIHR5cGUsIGNvbXBhdGlibGUpOyBkbjsgXAo+Pj4+IC0g ICAgICAgICAgZG4gPSBvZl9maW5kX2NvbXBhdGlibGVfbm9kZShkbiwgdHlwZSwgY29tcGF0aWJs ZSkpCj4+Pj4gICAgZXh0ZXJuIHN0cnVjdCBkZXZpY2Vfbm9kZSAqb2ZfZmluZF9tYXRjaGluZ19u b2RlX2FuZF9tYXRjaCgKPj4+PiAgICAgICAgIHN0cnVjdCBkZXZpY2Vfbm9kZSAqZnJvbSwKPj4+ PiAgICAgICAgIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgKm1hdGNoZXMsCj4+Pj4gQEAgLTE5 MCwxMiArMjA2LDYgQEAgc3RhdGljIGlubGluZSBzdHJ1Y3QgZGV2aWNlX25vZGUgKm9mX2ZpbmRf bWF0Y2hpbmdfbm9kZSgKPj4+PiAgICB7Cj4+Pj4gICAgICAgICByZXR1cm4gb2ZfZmluZF9tYXRj aGluZ19ub2RlX2FuZF9tYXRjaChmcm9tLCBtYXRjaGVzLCBOVUxMKTsKPj4+PiAgICB9Cj4+Pj4g LSNkZWZpbmUgZm9yX2VhY2hfbWF0Y2hpbmdfbm9kZShkbiwgbWF0Y2hlcykgXAo+Pj4+IC0gICAg IGZvciAoZG4gPSBvZl9maW5kX21hdGNoaW5nX25vZGUoTlVMTCwgbWF0Y2hlcyk7IGRuOyBcCj4+ Pj4gLSAgICAgICAgICBkbiA9IG9mX2ZpbmRfbWF0Y2hpbmdfbm9kZShkbiwgbWF0Y2hlcykpCj4+ Pj4gLSNkZWZpbmUgZm9yX2VhY2hfbWF0Y2hpbmdfbm9kZV9hbmRfbWF0Y2goZG4sIG1hdGNoZXMs IG1hdGNoKSBcCj4+Pj4gLSAgICAgZm9yIChkbiA9IG9mX2ZpbmRfbWF0Y2hpbmdfbm9kZV9hbmRf bWF0Y2goTlVMTCwgbWF0Y2hlcywgbWF0Y2gpOyBcCj4+Pj4gLSAgICAgICAgICBkbjsgZG4gPSBv Zl9maW5kX21hdGNoaW5nX25vZGVfYW5kX21hdGNoKGRuLCBtYXRjaGVzLCBtYXRjaCkpCj4+Pj4g ICAgZXh0ZXJuIHN0cnVjdCBkZXZpY2Vfbm9kZSAqb2ZfZmluZF9ub2RlX2J5X3BhdGgoY29uc3Qg Y2hhciAqcGF0aCk7Cj4+Pj4gICAgZXh0ZXJuIHN0cnVjdCBkZXZpY2Vfbm9kZSAqb2ZfZmluZF9u b2RlX2J5X3BoYW5kbGUocGhhbmRsZSBoYW5kbGUpOwo+Pj4+ICAgIGV4dGVybiBzdHJ1Y3QgZGV2 aWNlX25vZGUgKm9mX2dldF9wYXJlbnQoY29uc3Qgc3RydWN0IGRldmljZV9ub2RlICpub2RlKTsK Pj4+PiBAQCAtMjA3LDE0ICsyMTcsNiBAQCBleHRlcm4gc3RydWN0IGRldmljZV9ub2RlICpvZl9n ZXRfbmV4dF9hdmFpbGFibGVfY2hpbGQoCj4+Pj4KPj4+PiAgICBleHRlcm4gc3RydWN0IGRldmlj ZV9ub2RlICpvZl9nZXRfY2hpbGRfYnlfbmFtZShjb25zdCBzdHJ1Y3QgZGV2aWNlX25vZGUgKm5v ZGUsCj4+Pj4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNo YXIgKm5hbWUpOwo+Pj4+IC0jZGVmaW5lIGZvcl9lYWNoX2NoaWxkX29mX25vZGUocGFyZW50LCBj aGlsZCkgXAo+Pj4+IC0gICAgIGZvciAoY2hpbGQgPSBvZl9nZXRfbmV4dF9jaGlsZChwYXJlbnQs IE5VTEwpOyBjaGlsZCAhPSBOVUxMOyBcCj4+Pj4gLSAgICAgICAgICBjaGlsZCA9IG9mX2dldF9u ZXh0X2NoaWxkKHBhcmVudCwgY2hpbGQpKQo+Pj4+IC0KPj4+PiAtI2RlZmluZSBmb3JfZWFjaF9h dmFpbGFibGVfY2hpbGRfb2Zfbm9kZShwYXJlbnQsIGNoaWxkKSBcCj4+Pj4gLSAgICAgZm9yIChj aGlsZCA9IG9mX2dldF9uZXh0X2F2YWlsYWJsZV9jaGlsZChwYXJlbnQsIE5VTEwpOyBjaGlsZCAh PSBOVUxMOyBcCj4+Pj4gLSAgICAgICAgICBjaGlsZCA9IG9mX2dldF9uZXh0X2F2YWlsYWJsZV9j aGlsZChwYXJlbnQsIGNoaWxkKSkKPj4+PiAtCj4+Pj4gICAgc3RhdGljIGlubGluZSBpbnQgb2Zf Z2V0X2NoaWxkX2NvdW50KGNvbnN0IHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnApCj4+Pj4gICAgewo+ Pj4+ICAgICAgICAgc3RydWN0IGRldmljZV9ub2RlICpjaGlsZDsKPj4+PiBAQCAtMjI4LDEwICsy MzAsNiBAQCBzdGF0aWMgaW5saW5lIGludCBvZl9nZXRfY2hpbGRfY291bnQoY29uc3Qgc3RydWN0 IGRldmljZV9ub2RlICpucCkKPj4+Pgo+Pj4+ICAgIGV4dGVybiBzdHJ1Y3QgZGV2aWNlX25vZGUg Km9mX2ZpbmRfbm9kZV93aXRoX3Byb3BlcnR5KAo+Pj4+ICAgICAgICAgc3RydWN0IGRldmljZV9u b2RlICpmcm9tLCBjb25zdCBjaGFyICpwcm9wX25hbWUpOwo+Pj4+IC0jZGVmaW5lIGZvcl9lYWNo X25vZGVfd2l0aF9wcm9wZXJ0eShkbiwgcHJvcF9uYW1lKSBcCj4+Pj4gLSAgICAgZm9yIChkbiA9 IG9mX2ZpbmRfbm9kZV93aXRoX3Byb3BlcnR5KE5VTEwsIHByb3BfbmFtZSk7IGRuOyBcCj4+Pj4g LSAgICAgICAgICBkbiA9IG9mX2ZpbmRfbm9kZV93aXRoX3Byb3BlcnR5KGRuLCBwcm9wX25hbWUp KQo+Pj4+IC0KPj4+PiAgICBleHRlcm4gc3RydWN0IHByb3BlcnR5ICpvZl9maW5kX3Byb3BlcnR5 KGNvbnN0IHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAsCj4+Pj4gICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICpuYW1lLAo+Pj4+ICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgaW50ICpsZW5wKTsKPj4+PiBAQCAtMzUzLDEzICsz NTEsMjggQEAgc3RhdGljIGlubGluZSBzdHJ1Y3QgZGV2aWNlX25vZGUgKm9mX2ZpbmRfbm9kZV9i eV9uYW1lKHN0cnVjdCBkZXZpY2Vfbm9kZSAqZnJvbSwKPj4+PiAgICAgICAgIHJldHVybiBOVUxM Owo+Pj4+ICAgIH0KPj4+Pgo+Pj4+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCBkZXZpY2Vfbm9kZSAq b2ZfZmluZF9ub2RlX2J5X3R5cGUoc3RydWN0IGRldmljZV9ub2RlICpmcm9tLAo+Pj4+ICsgICAg IGNvbnN0IGNoYXIgKnR5cGUpCj4+Pj4gK3sKPj4+PiArICAgICByZXR1cm4gTlVMTDsKPj4+PiAr fQo+Pj4+ICsKPj4+PiAgICBzdGF0aWMgaW5saW5lIGJvb2wgb2ZfaGF2ZV9wb3B1bGF0ZWRfZHQo dm9pZCkKPj4+PiAgICB7Cj4+Pj4gICAgICAgICByZXR1cm4gZmFsc2U7Cj4+Pj4gICAgfQo+Pj4+ Cj4+Pj4gLSNkZWZpbmUgZm9yX2VhY2hfY2hpbGRfb2Zfbm9kZShwYXJlbnQsIGNoaWxkKSBcCj4+ Pj4gLSAgICAgd2hpbGUgKDApCj4+Pj4gK3N0YXRpYyBpbmxpbmUgc3RydWN0IGRldmljZV9ub2Rl ICpvZl9nZXRfbmV4dF9jaGlsZChjb25zdCBzdHJ1Y3QgZGV2aWNlX25vZGUgKm5vZGUsCj4+Pj4g KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBkZXZpY2Vf bm9kZSAqcHJldikKPj4+PiArewo+Pj4+ICsgICAgIHJldHVybiBOVUxMOwo+Pj4+ICt9Cj4+Pj4g Kwo+Pj4+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCBkZXZpY2Vfbm9kZSAqb2ZfZ2V0X25leHRfYXZh aWxhYmxlX2NoaWxkKAo+Pj4+ICsgICAgIGNvbnN0IHN0cnVjdCBkZXZpY2Vfbm9kZSAqbm9kZSwg c3RydWN0IGRldmljZV9ub2RlICpwcmV2KQo+Pj4+ICt7Cj4+Pj4gKyAgICAgcmV0dXJuIE5VTEw7 Cj4+Pj4gK30KPj4+Pgo+Pj4+ICAgIHN0YXRpYyBpbmxpbmUgc3RydWN0IGRldmljZV9ub2RlICpv Zl9nZXRfY2hpbGRfYnlfbmFtZSgKPj4+PiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgY29uc3Qgc3RydWN0IGRldmljZV9ub2RlICpub2RlLAo+Pj4+IEBAIC0zNzMsNiAr Mzg2LDEyIEBAIHN0YXRpYyBpbmxpbmUgaW50IG9mX2dldF9jaGlsZF9jb3VudChjb25zdCBzdHJ1 Y3QgZGV2aWNlX25vZGUgKm5wKQo+Pj4+ICAgICAgICAgcmV0dXJuIDA7Cj4+Pj4gICAgfQo+Pj4+ Cj4+Pj4gK3N0YXRpYyBpbmxpbmUgc3RydWN0IGRldmljZV9ub2RlICpvZl9maW5kX25vZGVfd2l0 aF9wcm9wZXJ0eSgKPj4+PiArICAgICBzdHJ1Y3QgZGV2aWNlX25vZGUgKmZyb20sIGNvbnN0IGNo YXIgKnByb3BfbmFtZSkKPj4+PiArewo+Pj4+ICsgICAgIHJldHVybiBOVUxMOwo+Pj4+ICt9Cj4+ Pj4gKwo+Pj4+ICAgIHN0YXRpYyBpbmxpbmUgaW50IG9mX2RldmljZV9pc19jb21wYXRpYmxlKGNv bnN0IHN0cnVjdCBkZXZpY2Vfbm9kZSAqZGV2aWNlLAo+Pj4+ICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKm5hbWUpCj4+Pj4gICAgewo+Pj4+IEBA IC0zOTQsNiArNDEzLDIxIEBAIHN0YXRpYyBpbmxpbmUgc3RydWN0IGRldmljZV9ub2RlICpvZl9m aW5kX2NvbXBhdGlibGVfbm9kZSgKPj4+PiAgICAgICAgIHJldHVybiBOVUxMOwo+Pj4+ICAgIH0K Pj4+Pgo+Pj4+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCBkZXZpY2Vfbm9kZSAqb2ZfZmluZF9tYXRj aGluZ19ub2RlX2FuZF9tYXRjaCgKPj4+PiArICAgICBzdHJ1Y3QgZGV2aWNlX25vZGUgKmZyb20s Cj4+Pj4gKyAgICAgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCAqbWF0Y2hlcywKPj4+PiArICAg ICBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkICoqbWF0Y2gpCj4+Pj4gK3sKPj4+PiArICAgICBy ZXR1cm4gTlVMTDsKPj4+PiArfQo+Pj4+ICsKPj4+PiArc3RhdGljIGlubGluZSBzdHJ1Y3QgZGV2 aWNlX25vZGUgKm9mX2ZpbmRfbWF0Y2hpbmdfbm9kZSgKPj4+PiArICAgICBzdHJ1Y3QgZGV2aWNl X25vZGUgKmZyb20sCj4+Pj4gKyAgICAgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCAqbWF0Y2hl cykKPj4+PiArewo+Pj4+ICsgICAgIHJldHVybiBOVUxMOwo+Pj4+ICt9Cj4+Pj4gKwo+Pj4+ICAg IHN0YXRpYyBpbmxpbmUgaW50IG9mX3Byb3BlcnR5X3JlYWRfdThfYXJyYXkoY29uc3Qgc3RydWN0 IGRldmljZV9ub2RlICpucCwKPj4+PiAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBjaGFy ICpwcm9wbmFtZSwgdTggKm91dF92YWx1ZXMsIHNpemVfdCBzeikKPj4+PiAgICB7Cj4+Pj4KPj4+ Cj4+Pgo+Pj4gX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K Pj4+IGxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0Cj4+PiBsaW51eC1hcm0ta2VybmVsQGxp c3RzLmluZnJhZGVhZC5vcmcKPj4+IGh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4v bGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo+Pj4KPj4KPj4KPj4KPj4gX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KPj4gbGludXgtYXJtLWtlcm5lbCBtYWls aW5nIGxpc3QKPj4gbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCj4+IGh0dHA6 Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo+ CgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4 LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFk Lm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFy bS1rZXJuZWwK