From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Google-Smtp-Source: AG47ELvdW7KaMkiOmKDX8ABP/BRtlK8C60I59H3pDxM6E4Exzdy+E1A5wcMk6dXrEYfBgWxIVHxP ARC-Seal: i=1; a=rsa-sha256; t=1521029608; cv=none; d=google.com; s=arc-20160816; b=0SF8RFHN/sCZugIR3uePGkcY20X/AF7gNpzOw1Ed+7qBtpHIaGZN6Z2YXUekOy13qp nZe7dCcrU9T5RlLHiMYsMMKBxW9VzaLHccf4+a1REIJkKUiExm84lHYHGM3I6wz2Y6dy mmdPtgVatzuVj3INLBJdgjNi9vgEw+RakNNhU6bhINJYsllL6rPVQ7HRkvhw2B1qQ6n9 hp31Oz5AQ/Qt7LWnK5m31fzNvzAaqiVxlgpbXPrZfLEbV9P3DGbYZvlewin4NVDiL0VG kGduLajn7mDl2WoTkq625wyTIhbsxbB6zVLN9NS0VGC7xYCsaVEuDvnI1maMzLncS6vC izeg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=user-agent:in-reply-to:content-disposition:mime-version:references :message-id:subject:cc:to:from:date:arc-authentication-results; bh=B4qO/Jvd17rJFeOUBTds+Wr15CkuB/VtpS813wGxZz0=; b=H4pCMD1RaF0Q+SiDfqnzAqwmE6k7r6M3NXvFUfTPVqBkKcuhSa2p2e+JeNTb/faMdL QhjzJcNqe1SzdjhPjWfaKUKc+v1bSFruekVGZ4urBOM5oaRN+j1jwv34ACCS6s4qqexT 7dwT3DSvbMp48O9G1sNaWZf4wd4U5p5283yhvtmJJJu0tNtvA0or4d+RvPh80jUsUjoJ m19NaoHKSdHVQmWwo39TKsuT8RC+PWt7R8V62TPFdbug4a7pmblhutmW4TmzjaPDLN3a 2adaBbcJTJ3wvgugFcsqzMJdb3kwMpMzaPsNgWH/QL41cyuOpW0B001EAV/AuaYJ61Wk KfQA== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: best guess record for domain of heikki.krogerus@linux.intel.com designates 134.134.136.126 as permitted sender) smtp.mailfrom=heikki.krogerus@linux.intel.com Authentication-Results: mx.google.com; spf=pass (google.com: best guess record for domain of heikki.krogerus@linux.intel.com designates 134.134.136.126 as permitted sender) smtp.mailfrom=heikki.krogerus@linux.intel.com X-Amp-Result: UNSCANNABLE X-Amp-File-Uploaded: False X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.47,470,1515484800"; d="scan'208";a="37985071" Date: Wed, 14 Mar 2018 14:13:23 +0200 From: Heikki Krogerus To: Greg Kroah-Hartman Cc: Hans de Goede , Darren Hart , Andy Shevchenko , MyungJoo Ham , Chanwoo Choi , Mathias Nyman , Guenter Roeck , Jun Li , platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org Subject: Re: [PATCH v7 01/12] drivers: base: Unified device connection lookup Message-ID: <20180314121323.GA10347@kuha.fi.intel.com> References: <20180312143431.82396-1-heikki.krogerus@linux.intel.com> <20180312143431.82396-2-heikki.krogerus@linux.intel.com> <20180314111605.GA21241@kroah.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20180314111605.GA21241@kroah.com> User-Agent: Mutt/1.9.2 (2017-12-15) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: =?utf-8?q?1593820906030657716?= X-GMAIL-MSGID: =?utf-8?q?1594915142996769013?= X-Mailing-List: linux-kernel@vger.kernel.org List-ID: On Wed, Mar 14, 2018 at 12:16:05PM +0100, Greg Kroah-Hartman wrote: > On Mon, Mar 12, 2018 at 05:34:20PM +0300, Heikki Krogerus wrote: > > Several frameworks - clk, gpio, phy, pmw, etc. - maintain > > lookup tables for describing connections and provide custom > > API for handling them. This introduces a single generic > > lookup table and API for the connections. > > > > The motivation for this commit is centralizing the > > connection lookup, but the goal is to ultimately extract the > > connection descriptions also from firmware by using the > > fwnode_graph_* functions and other mechanisms that are > > available. > > > > Reviewed-by: Hans de Goede > > Reviewed-by: Andy Shevchenko > > Signed-off-by: Heikki Krogerus > > --- > > Changes in v7: > > - API naming improvements suggested by Greg > > - Prototypes to device.h, also suggested by Greg > > - I removed the DEVCON() macro as it was not used yet and it needs to be > > rewritten > > > > Changes in v6: > > -Fix data and match arguments being swapped in __device_find_connection() > > call in device_find_connection() (as noticed by Jun Li) > > > > Changes in v5: > > -Add missing documentation for @list struct devcon member > > > > Changes in v4: > > -Add Andy's Reviewed-by > > > > Changes in v3: > > -Various spelling and gramar fixes in the docs pointed out by Randy Dunlap > > > > Changes in v2: > > -Add a (struct devcon) cast to the DEVCON() macro > > --- > > Documentation/driver-api/device_connection.rst | 43 ++++++++ > > drivers/base/Makefile | 3 +- > > drivers/base/devcon.c | 141 +++++++++++++++++++++++++ > > include/linux/device.h | 22 ++++ > > 4 files changed, 208 insertions(+), 1 deletion(-) > > create mode 100644 Documentation/driver-api/device_connection.rst > > create mode 100644 drivers/base/devcon.c > > > > diff --git a/Documentation/driver-api/device_connection.rst b/Documentation/driver-api/device_connection.rst > > new file mode 100644 > > index 000000000000..affbc5566ab0 > > --- /dev/null > > +++ b/Documentation/driver-api/device_connection.rst > > @@ -0,0 +1,43 @@ > > +================== > > +Device connections > > +================== > > + > > +Introduction > > +------------ > > + > > +Devices often have connections to other devices that are outside of the direct > > +child/parent relationship. A serial or network communication controller, which > > +could be a PCI device, may need to be able to get a reference to its PHY > > +component, which could be attached for example to the I2C bus. Some device > > +drivers need to be able to control the clocks or the GPIOs for their devices, > > +and so on. > > + > > +Device connections are generic descriptions of any type of connection between > > +two separate devices. > > + > > +Device connections alone do not create a dependency between the two devices. > > +They are only descriptions which are not tied to either of the devices directly. > > +A dependency between the two devices exists only if one of the two endpoint > > +devices requests a reference to the other. The descriptions themselves can be > > +defined in firmware (not yet supported) or they can be built-in. > > + > > +Usage > > +----- > > + > > +Device connections should exist before device ``->probe`` callback is called for > > +either endpoint device in the description. If the connections are defined in > > +firmware, this is not a problem. It should be considered if the connection > > +descriptions are "built-in", and need to be added separately. > > + > > +The connection description consists of the names of the two devices with the > > +connection, i.e. the endpoints, and unique identifier for the connection which > > +is needed if there are multiple connections between the two devices. > > + > > +After a description exists, the devices in it can request reference to the other > > +endpoint device, or they can request the description itself. > > + > > +API > > +--- > > + > > +.. kernel-doc:: drivers/base/devcon.c > > + : functions: device_connection_find_match device_connection_find device_connection_add device_connection_remove > > diff --git a/drivers/base/Makefile b/drivers/base/Makefile > > index e32a52490051..12a7f64d35a9 100644 > > --- a/drivers/base/Makefile > > +++ b/drivers/base/Makefile > > @@ -5,7 +5,8 @@ obj-y := component.o core.o bus.o dd.o syscore.o \ > > driver.o class.o platform.o \ > > cpu.o firmware.o init.o map.o devres.o \ > > attribute_container.o transport_class.o \ > > - topology.o container.o property.o cacheinfo.o > > + topology.o container.o property.o cacheinfo.o \ > > + devcon.o > > obj-$(CONFIG_DEVTMPFS) += devtmpfs.o > > obj-$(CONFIG_DMA_CMA) += dma-contiguous.o > > obj-y += power/ > > diff --git a/drivers/base/devcon.c b/drivers/base/devcon.c > > new file mode 100644 > > index 000000000000..e783c2c2ed1a > > --- /dev/null > > +++ b/drivers/base/devcon.c > > @@ -0,0 +1,141 @@ > > +// SPDX-License-Identifier: GPL-2.0 > > +/** > > + * Device connections > > + * > > + * Copyright (C) 2018 Intel Corporation > > + * Author: Heikki Krogerus > > + */ > > + > > +#include > > + > > +static DEFINE_MUTEX(devcon_lock); > > +static LIST_HEAD(devcon_list); > > + > > +/** > > + * device_connection_find_match - Find physical connection to a device > > + * @dev: Device with the connection > > + * @con_id: Identifier for the connection > > + * @data: Data for the match function > > + * @match: Function to check and convert the connection description > > + * > > + * Find a connection with unique identifier @con_id between @dev and another > > + * device. @match will be used to convert the connection description to data the > > + * caller is expecting to be returned. > > + */ > > +void *device_connection_find_match(struct device *dev, const char *con_id, > > + void *data, > > + void *(*match)(struct device_connection *con, > > + int ep, void *data)) > > +{ > > + const char *devname = dev_name(dev); > > + struct device_connection *con; > > + void *ret = NULL; > > + int ep; > > + > > + if (!match) > > + return NULL; > > + > > + rcu_read_lock(); > > Wait, why are you using rcu at all for this? This is not a "heavy" > operation that you need to care about speed for, right? Why get rcu > involved at all in this type of thing? > > Yes, the links in the driver core seem to be using rcu, which I didn't > notice until right now, and I can't remember why or when that happened. > Let's not make this more complex than it has to be please. OK. Makes sense. > Sorry I missed this the last review cycles. Np. I'll prepare v8. This will not affect the other patches, so is it enough if I just update this patch? Or do you prefer that I re-send the whole series? Thanks, -- heikki From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v7,01/12] drivers: base: Unified device connection lookup From: Heikki Krogerus Message-Id: <20180314121323.GA10347@kuha.fi.intel.com> Date: Wed, 14 Mar 2018 14:13:23 +0200 To: Greg Kroah-Hartman Cc: Hans de Goede , Darren Hart , Andy Shevchenko , MyungJoo Ham , Chanwoo Choi , Mathias Nyman , Guenter Roeck , Jun Li , platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org List-ID: T24gV2VkLCBNYXIgMTQsIDIwMTggYXQgMTI6MTY6MDVQTSArMDEwMCwgR3JlZyBLcm9haC1IYXJ0 bWFuIHdyb3RlOgo+IE9uIE1vbiwgTWFyIDEyLCAyMDE4IGF0IDA1OjM0OjIwUE0gKzAzMDAsIEhl aWtraSBLcm9nZXJ1cyB3cm90ZToKPiA+IFNldmVyYWwgZnJhbWV3b3JrcyAtIGNsaywgZ3Bpbywg cGh5LCBwbXcsIGV0Yy4gLSBtYWludGFpbgo+ID4gbG9va3VwIHRhYmxlcyBmb3IgZGVzY3JpYmlu ZyBjb25uZWN0aW9ucyBhbmQgcHJvdmlkZSBjdXN0b20KPiA+IEFQSSBmb3IgaGFuZGxpbmcgdGhl bS4gVGhpcyBpbnRyb2R1Y2VzIGEgc2luZ2xlIGdlbmVyaWMKPiA+IGxvb2t1cCB0YWJsZSBhbmQg QVBJIGZvciB0aGUgY29ubmVjdGlvbnMuCj4gPiAKPiA+IFRoZSBtb3RpdmF0aW9uIGZvciB0aGlz IGNvbW1pdCBpcyBjZW50cmFsaXppbmcgdGhlCj4gPiBjb25uZWN0aW9uIGxvb2t1cCwgYnV0IHRo ZSBnb2FsIGlzIHRvIHVsdGltYXRlbHkgZXh0cmFjdCB0aGUKPiA+IGNvbm5lY3Rpb24gZGVzY3Jp cHRpb25zIGFsc28gZnJvbSBmaXJtd2FyZSBieSB1c2luZyB0aGUKPiA+IGZ3bm9kZV9ncmFwaF8q IGZ1bmN0aW9ucyBhbmQgb3RoZXIgbWVjaGFuaXNtcyB0aGF0IGFyZQo+ID4gYXZhaWxhYmxlLgo+ ID4gCj4gPiBSZXZpZXdlZC1ieTogSGFucyBkZSBHb2VkZSA8aGRlZ29lZGVAcmVkaGF0LmNvbT4K PiA+IFJldmlld2VkLWJ5OiBBbmR5IFNoZXZjaGVua28gPGFuZHkuc2hldmNoZW5rb0BnbWFpbC5j b20+Cj4gPiBTaWduZWQtb2ZmLWJ5OiBIZWlra2kgS3JvZ2VydXMgPGhlaWtraS5rcm9nZXJ1c0Bs aW51eC5pbnRlbC5jb20+Cj4gPiAtLS0KPiA+IENoYW5nZXMgaW4gdjc6Cj4gPiAtIEFQSSBuYW1p bmcgaW1wcm92ZW1lbnRzIHN1Z2dlc3RlZCBieSBHcmVnCj4gPiAtIFByb3RvdHlwZXMgdG8gZGV2 aWNlLmgsIGFsc28gc3VnZ2VzdGVkIGJ5IEdyZWcKPiA+IC0gSSByZW1vdmVkIHRoZSBERVZDT04o KSBtYWNybyBhcyBpdCB3YXMgbm90IHVzZWQgeWV0IGFuZCBpdCBuZWVkcyB0byBiZQo+ID4gICBy ZXdyaXR0ZW4KPiA+IAo+ID4gQ2hhbmdlcyBpbiB2NjoKPiA+IC1GaXggZGF0YSBhbmQgbWF0Y2gg YXJndW1lbnRzIGJlaW5nIHN3YXBwZWQgaW4gX19kZXZpY2VfZmluZF9jb25uZWN0aW9uKCkKPiA+ ICBjYWxsIGluIGRldmljZV9maW5kX2Nvbm5lY3Rpb24oKSAoYXMgbm90aWNlZCBieSBKdW4gTGkp Cj4gPiAKPiA+IENoYW5nZXMgaW4gdjU6Cj4gPiAtQWRkIG1pc3NpbmcgZG9jdW1lbnRhdGlvbiBm b3IgQGxpc3Qgc3RydWN0IGRldmNvbiBtZW1iZXIKPiA+IAo+ID4gQ2hhbmdlcyBpbiB2NDoKPiA+ IC1BZGQgQW5keSdzIFJldmlld2VkLWJ5Cj4gPiAKPiA+IENoYW5nZXMgaW4gdjM6Cj4gPiAtVmFy aW91cyBzcGVsbGluZyBhbmQgZ3JhbWFyIGZpeGVzIGluIHRoZSBkb2NzIHBvaW50ZWQgb3V0IGJ5 IFJhbmR5IER1bmxhcAo+ID4gCj4gPiBDaGFuZ2VzIGluIHYyOgo+ID4gLUFkZCBhIChzdHJ1Y3Qg ZGV2Y29uKSBjYXN0IHRvIHRoZSBERVZDT04oKSBtYWNybwo+ID4gLS0tCj4gPiAgRG9jdW1lbnRh dGlvbi9kcml2ZXItYXBpL2RldmljZV9jb25uZWN0aW9uLnJzdCB8ICA0MyArKysrKysrKwo+ID4g IGRyaXZlcnMvYmFzZS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDMgKy0K PiA+ICBkcml2ZXJzL2Jhc2UvZGV2Y29uLmMgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMTQx ICsrKysrKysrKysrKysrKysrKysrKysrKysKPiA+ICBpbmNsdWRlL2xpbnV4L2RldmljZS5oICAg ICAgICAgICAgICAgICAgICAgICAgIHwgIDIyICsrKysKPiA+ICA0IGZpbGVzIGNoYW5nZWQsIDIw OCBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCj4gPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IERv Y3VtZW50YXRpb24vZHJpdmVyLWFwaS9kZXZpY2VfY29ubmVjdGlvbi5yc3QKPiA+ICBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9iYXNlL2RldmNvbi5jCj4gPiAKPiA+IGRpZmYgLS1naXQgYS9E b2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZGV2aWNlX2Nvbm5lY3Rpb24ucnN0IGIvRG9jdW1lbnRh dGlvbi9kcml2ZXItYXBpL2RldmljZV9jb25uZWN0aW9uLnJzdAo+ID4gbmV3IGZpbGUgbW9kZSAx MDA2NDQKPiA+IGluZGV4IDAwMDAwMDAwMDAwMC4uYWZmYmM1NTY2YWIwCj4gPiAtLS0gL2Rldi9u dWxsCj4gPiArKysgYi9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZGV2aWNlX2Nvbm5lY3Rpb24u cnN0Cj4gPiBAQCAtMCwwICsxLDQzIEBACj4gPiArPT09PT09PT09PT09PT09PT09Cj4gPiArRGV2 aWNlIGNvbm5lY3Rpb25zCj4gPiArPT09PT09PT09PT09PT09PT09Cj4gPiArCj4gPiArSW50cm9k dWN0aW9uCj4gPiArLS0tLS0tLS0tLS0tCj4gPiArCj4gPiArRGV2aWNlcyBvZnRlbiBoYXZlIGNv bm5lY3Rpb25zIHRvIG90aGVyIGRldmljZXMgdGhhdCBhcmUgb3V0c2lkZSBvZiB0aGUgZGlyZWN0 Cj4gPiArY2hpbGQvcGFyZW50IHJlbGF0aW9uc2hpcC4gQSBzZXJpYWwgb3IgbmV0d29yayBjb21t dW5pY2F0aW9uIGNvbnRyb2xsZXIsIHdoaWNoCj4gPiArY291bGQgYmUgYSBQQ0kgZGV2aWNlLCBt YXkgbmVlZCB0byBiZSBhYmxlIHRvIGdldCBhIHJlZmVyZW5jZSB0byBpdHMgUEhZCj4gPiArY29t cG9uZW50LCB3aGljaCBjb3VsZCBiZSBhdHRhY2hlZCBmb3IgZXhhbXBsZSB0byB0aGUgSTJDIGJ1 cy4gU29tZSBkZXZpY2UKPiA+ICtkcml2ZXJzIG5lZWQgdG8gYmUgYWJsZSB0byBjb250cm9sIHRo ZSBjbG9ja3Mgb3IgdGhlIEdQSU9zIGZvciB0aGVpciBkZXZpY2VzLAo+ID4gK2FuZCBzbyBvbi4K PiA+ICsKPiA+ICtEZXZpY2UgY29ubmVjdGlvbnMgYXJlIGdlbmVyaWMgZGVzY3JpcHRpb25zIG9m IGFueSB0eXBlIG9mIGNvbm5lY3Rpb24gYmV0d2Vlbgo+ID4gK3R3byBzZXBhcmF0ZSBkZXZpY2Vz Lgo+ID4gKwo+ID4gK0RldmljZSBjb25uZWN0aW9ucyBhbG9uZSBkbyBub3QgY3JlYXRlIGEgZGVw ZW5kZW5jeSBiZXR3ZWVuIHRoZSB0d28gZGV2aWNlcy4KPiA+ICtUaGV5IGFyZSBvbmx5IGRlc2Ny aXB0aW9ucyB3aGljaCBhcmUgbm90IHRpZWQgdG8gZWl0aGVyIG9mIHRoZSBkZXZpY2VzIGRpcmVj dGx5Lgo+ID4gK0EgZGVwZW5kZW5jeSBiZXR3ZWVuIHRoZSB0d28gZGV2aWNlcyBleGlzdHMgb25s eSBpZiBvbmUgb2YgdGhlIHR3byBlbmRwb2ludAo+ID4gK2RldmljZXMgcmVxdWVzdHMgYSByZWZl cmVuY2UgdG8gdGhlIG90aGVyLiBUaGUgZGVzY3JpcHRpb25zIHRoZW1zZWx2ZXMgY2FuIGJlCj4g PiArZGVmaW5lZCBpbiBmaXJtd2FyZSAobm90IHlldCBzdXBwb3J0ZWQpIG9yIHRoZXkgY2FuIGJl IGJ1aWx0LWluLgo+ID4gKwo+ID4gK1VzYWdlCj4gPiArLS0tLS0KPiA+ICsKPiA+ICtEZXZpY2Ug Y29ubmVjdGlvbnMgc2hvdWxkIGV4aXN0IGJlZm9yZSBkZXZpY2UgYGAtPnByb2JlYGAgY2FsbGJh Y2sgaXMgY2FsbGVkIGZvcgo+ID4gK2VpdGhlciBlbmRwb2ludCBkZXZpY2UgaW4gdGhlIGRlc2Ny aXB0aW9uLiBJZiB0aGUgY29ubmVjdGlvbnMgYXJlIGRlZmluZWQgaW4KPiA+ICtmaXJtd2FyZSwg dGhpcyBpcyBub3QgYSBwcm9ibGVtLiBJdCBzaG91bGQgYmUgY29uc2lkZXJlZCBpZiB0aGUgY29u bmVjdGlvbgo+ID4gK2Rlc2NyaXB0aW9ucyBhcmUgImJ1aWx0LWluIiwgYW5kIG5lZWQgdG8gYmUg YWRkZWQgc2VwYXJhdGVseS4KPiA+ICsKPiA+ICtUaGUgY29ubmVjdGlvbiBkZXNjcmlwdGlvbiBj b25zaXN0cyBvZiB0aGUgbmFtZXMgb2YgdGhlIHR3byBkZXZpY2VzIHdpdGggdGhlCj4gPiArY29u bmVjdGlvbiwgaS5lLiB0aGUgZW5kcG9pbnRzLCBhbmQgdW5pcXVlIGlkZW50aWZpZXIgZm9yIHRo ZSBjb25uZWN0aW9uIHdoaWNoCj4gPiAraXMgbmVlZGVkIGlmIHRoZXJlIGFyZSBtdWx0aXBsZSBj b25uZWN0aW9ucyBiZXR3ZWVuIHRoZSB0d28gZGV2aWNlcy4KPiA+ICsKPiA+ICtBZnRlciBhIGRl c2NyaXB0aW9uIGV4aXN0cywgdGhlIGRldmljZXMgaW4gaXQgY2FuIHJlcXVlc3QgcmVmZXJlbmNl IHRvIHRoZSBvdGhlcgo+ID4gK2VuZHBvaW50IGRldmljZSwgb3IgdGhleSBjYW4gcmVxdWVzdCB0 aGUgZGVzY3JpcHRpb24gaXRzZWxmLgo+ID4gKwo+ID4gK0FQSQo+ID4gKy0tLQo+ID4gKwo+ID4g Ky4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL2Jhc2UvZGV2Y29uLmMKPiA+ICsgICA6IGZ1bmN0aW9u czogZGV2aWNlX2Nvbm5lY3Rpb25fZmluZF9tYXRjaCBkZXZpY2VfY29ubmVjdGlvbl9maW5kIGRl dmljZV9jb25uZWN0aW9uX2FkZCBkZXZpY2VfY29ubmVjdGlvbl9yZW1vdmUKPiA+IGRpZmYgLS1n aXQgYS9kcml2ZXJzL2Jhc2UvTWFrZWZpbGUgYi9kcml2ZXJzL2Jhc2UvTWFrZWZpbGUKPiA+IGlu ZGV4IGUzMmE1MjQ5MDA1MS4uMTJhN2Y2NGQzNWE5IDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9i YXNlL01ha2VmaWxlCj4gPiArKysgYi9kcml2ZXJzL2Jhc2UvTWFrZWZpbGUKPiA+IEBAIC01LDcg KzUsOCBAQCBvYmoteQkJCTo9IGNvbXBvbmVudC5vIGNvcmUubyBidXMubyBkZC5vIHN5c2NvcmUu byBcCj4gPiAgCQkJICAgZHJpdmVyLm8gY2xhc3MubyBwbGF0Zm9ybS5vIFwKPiA+ICAJCQkgICBj cHUubyBmaXJtd2FyZS5vIGluaXQubyBtYXAubyBkZXZyZXMubyBcCj4gPiAgCQkJICAgYXR0cmli dXRlX2NvbnRhaW5lci5vIHRyYW5zcG9ydF9jbGFzcy5vIFwKPiA+IC0JCQkgICB0b3BvbG9neS5v IGNvbnRhaW5lci5vIHByb3BlcnR5Lm8gY2FjaGVpbmZvLm8KPiA+ICsJCQkgICB0b3BvbG9neS5v IGNvbnRhaW5lci5vIHByb3BlcnR5Lm8gY2FjaGVpbmZvLm8gXAo+ID4gKwkJCSAgIGRldmNvbi5v Cj4gPiAgb2JqLSQoQ09ORklHX0RFVlRNUEZTKQkrPSBkZXZ0bXBmcy5vCj4gPiAgb2JqLSQoQ09O RklHX0RNQV9DTUEpICs9IGRtYS1jb250aWd1b3VzLm8KPiA+ICBvYmoteQkJCSs9IHBvd2VyLwo+ ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmFzZS9kZXZjb24uYyBiL2RyaXZlcnMvYmFzZS9kZXZj b24uYwo+ID4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiA+IGluZGV4IDAwMDAwMDAwMDAwMC4uZTc4 M2MyYzJlZDFhCj4gPiAtLS0gL2Rldi9udWxsCj4gPiArKysgYi9kcml2ZXJzL2Jhc2UvZGV2Y29u LmMKPiA+IEBAIC0wLDAgKzEsMTQxIEBACj4gPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6 IEdQTC0yLjAKPiA+ICsvKioKPiA+ICsgKiBEZXZpY2UgY29ubmVjdGlvbnMKPiA+ICsgKgo+ID4g KyAqIENvcHlyaWdodCAoQykgMjAxOCBJbnRlbCBDb3Jwb3JhdGlvbgo+ID4gKyAqIEF1dGhvcjog SGVpa2tpIEtyb2dlcnVzIDxoZWlra2kua3JvZ2VydXNAbGludXguaW50ZWwuY29tPgo+ID4gKyAq Lwo+ID4gKwo+ID4gKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KPiA+ICsKPiA+ICtzdGF0aWMg REVGSU5FX01VVEVYKGRldmNvbl9sb2NrKTsKPiA+ICtzdGF0aWMgTElTVF9IRUFEKGRldmNvbl9s aXN0KTsKPiA+ICsKPiA+ICsvKioKPiA+ICsgKiBkZXZpY2VfY29ubmVjdGlvbl9maW5kX21hdGNo IC0gRmluZCBwaHlzaWNhbCBjb25uZWN0aW9uIHRvIGEgZGV2aWNlCj4gPiArICogQGRldjogRGV2 aWNlIHdpdGggdGhlIGNvbm5lY3Rpb24KPiA+ICsgKiBAY29uX2lkOiBJZGVudGlmaWVyIGZvciB0 aGUgY29ubmVjdGlvbgo+ID4gKyAqIEBkYXRhOiBEYXRhIGZvciB0aGUgbWF0Y2ggZnVuY3Rpb24K PiA+ICsgKiBAbWF0Y2g6IEZ1bmN0aW9uIHRvIGNoZWNrIGFuZCBjb252ZXJ0IHRoZSBjb25uZWN0 aW9uIGRlc2NyaXB0aW9uCj4gPiArICoKPiA+ICsgKiBGaW5kIGEgY29ubmVjdGlvbiB3aXRoIHVu aXF1ZSBpZGVudGlmaWVyIEBjb25faWQgYmV0d2VlbiBAZGV2IGFuZCBhbm90aGVyCj4gPiArICog ZGV2aWNlLiBAbWF0Y2ggd2lsbCBiZSB1c2VkIHRvIGNvbnZlcnQgdGhlIGNvbm5lY3Rpb24gZGVz Y3JpcHRpb24gdG8gZGF0YSB0aGUKPiA+ICsgKiBjYWxsZXIgaXMgZXhwZWN0aW5nIHRvIGJlIHJl dHVybmVkLgo+ID4gKyAqLwo+ID4gK3ZvaWQgKmRldmljZV9jb25uZWN0aW9uX2ZpbmRfbWF0Y2go c3RydWN0IGRldmljZSAqZGV2LCBjb25zdCBjaGFyICpjb25faWQsCj4gPiArCQkJICAgICAgIHZv aWQgKmRhdGEsCj4gPiArCQkJICAgICAgIHZvaWQgKigqbWF0Y2gpKHN0cnVjdCBkZXZpY2VfY29u bmVjdGlvbiAqY29uLAo+ID4gKwkJCQkJICAgICAgaW50IGVwLCB2b2lkICpkYXRhKSkKPiA+ICt7 Cj4gPiArCWNvbnN0IGNoYXIgKmRldm5hbWUgPSBkZXZfbmFtZShkZXYpOwo+ID4gKwlzdHJ1Y3Qg ZGV2aWNlX2Nvbm5lY3Rpb24gKmNvbjsKPiA+ICsJdm9pZCAqcmV0ID0gTlVMTDsKPiA+ICsJaW50 IGVwOwo+ID4gKwo+ID4gKwlpZiAoIW1hdGNoKQo+ID4gKwkJcmV0dXJuIE5VTEw7Cj4gPiArCj4g PiArCXJjdV9yZWFkX2xvY2soKTsKPiAKPiBXYWl0LCB3aHkgYXJlIHlvdSB1c2luZyByY3UgYXQg YWxsIGZvciB0aGlzPyAgVGhpcyBpcyBub3QgYSAiaGVhdnkiCj4gb3BlcmF0aW9uIHRoYXQgeW91 IG5lZWQgdG8gY2FyZSBhYm91dCBzcGVlZCBmb3IsIHJpZ2h0PyAgV2h5IGdldCByY3UKPiBpbnZv bHZlZCBhdCBhbGwgaW4gdGhpcyB0eXBlIG9mIHRoaW5nPwo+IAo+IFllcywgdGhlIGxpbmtzIGlu IHRoZSBkcml2ZXIgY29yZSBzZWVtIHRvIGJlIHVzaW5nIHJjdSwgd2hpY2ggSSBkaWRuJ3QKPiBu b3RpY2UgdW50aWwgcmlnaHQgbm93LCBhbmQgSSBjYW4ndCByZW1lbWJlciB3aHkgb3Igd2hlbiB0 aGF0IGhhcHBlbmVkLgo+IExldCdzIG5vdCBtYWtlIHRoaXMgbW9yZSBjb21wbGV4IHRoYW4gaXQg aGFzIHRvIGJlIHBsZWFzZS4KCk9LLiBNYWtlcyBzZW5zZS4KCj4gU29ycnkgSSBtaXNzZWQgdGhp cyB0aGUgbGFzdCByZXZpZXcgY3ljbGVzLgoKTnAuIEknbGwgcHJlcGFyZSB2OC4gVGhpcyB3aWxs IG5vdCBhZmZlY3QgdGhlIG90aGVyIHBhdGNoZXMsIHNvIGlzIGl0CmVub3VnaCBpZiBJIGp1c3Qg dXBkYXRlIHRoaXMgcGF0Y2g/IE9yIGRvIHlvdSBwcmVmZXIgdGhhdCBJIHJlLXNlbmQKdGhlIHdo b2xlIHNlcmllcz8KCgpUaGFua3MsCg==