From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Google-Smtp-Source: AH8x225P02RlXTjV7wF6CJTAvh9ryGJTleKkQmLEv0NzK2Mf1xQTpr5gfAaBSldhgNA2KaRBn8tg ARC-Seal: i=1; a=rsa-sha256; t=1519830475; cv=none; d=google.com; s=arc-20160816; b=meM+9NqSRuehXipb1e3FYEPLWDHP3zPU5Y5plrbTWIezdF0fw3vgkZit6YHFTHKoUm nfHMzy+Bqyaf1tlcRqt9Mt+Gi8c28HRVEHhUXpeuHbL6qPmuDpFDokL0yogFwOmtX+JP U3VfJhuQ+SqprHmUJD/blAkPBWyDaaZEU5TwKM+ByPhWErOYfcIznjoVS4cAj7Y6TxZR SB/St5xjZ6HmMXzyhG2/Kodq12TK446y1PRomejf7W+UFxgrCQD9XInHfbJyCML8Mug7 81RWrxFkJZgRentxhVWPzdXA3AA+wZcalxPcPI5PFAaof/AoGIgH949GiWC/i1s1fEWy jK4w== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :arc-authentication-results; bh=5TGzL2MjsEURwb52t8IwsiSf48xSFZ9gbd+K7I4lm04=; b=FhGi1RnwlMheE8//eTk6bLP3G3rulaLkFaucSQCw4bo36Oej0a6uyeoTEhwD8TcHxw lpnQJGhDKihv5Y6Htg/VRyMtO0ymzKZK4wdwzi+0pxQRzPikeK1fujAU1dkppKyghfus Oz6lOVdDN+Dmy/kNsjQTfKJxUgXUBLZnhloCJadei4xjBpRujkGKVTYHQ2wSckjLiF/v r+BNMtZKtccKK/QvGCCqCRgu0rCjUMJ3UpxmhAp1a66m84z9W7R94X8iTNDe1tEhDaFl xcXQgDZc1nrY8PgMIGNX8AV9i1jJzymYApmZmrx9Rq1C3mXmxHDqHRREfYhdxEvI5mD3 3Vww== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of hdegoede@redhat.com designates 66.187.233.73 as permitted sender) smtp.mailfrom=hdegoede@redhat.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com Authentication-Results: mx.google.com; spf=pass (google.com: domain of hdegoede@redhat.com designates 66.187.233.73 as permitted sender) smtp.mailfrom=hdegoede@redhat.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com From: Hans de Goede To: Darren Hart , Andy Shevchenko , MyungJoo Ham , Chanwoo Choi , Mathias Nyman , Heikki Krogerus , Greg Kroah-Hartman , Guenter Roeck Cc: Hans de Goede , platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org Subject: [PATCH v5 01/12] drivers: base: Unified device connection lookup Date: Wed, 28 Feb 2018 16:07:38 +0100 Message-Id: <20180228150749.26831-2-hdegoede@redhat.com> In-Reply-To: <20180228150749.26831-1-hdegoede@redhat.com> References: <20180228150749.26831-1-hdegoede@redhat.com> X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: =?utf-8?q?1593454017476208824?= X-GMAIL-MSGID: =?utf-8?q?1593657760523901085?= X-Mailing-List: linux-kernel@vger.kernel.org List-ID: From: Heikki Krogerus 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. Signed-off-by: Heikki Krogerus Reviewed-by: Hans de Goede Reviewed-by: Andy Shevchenko Signed-off-by: Hans de Goede --- 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 | 139 +++++++++++++++++++++++++ include/linux/connection.h | 34 ++++++ 4 files changed, 218 insertions(+), 1 deletion(-) create mode 100644 Documentation/driver-api/device_connection.rst create mode 100644 drivers/base/devcon.c create mode 100644 include/linux/connection.h diff --git a/Documentation/driver-api/device_connection.rst b/Documentation/driver-api/device_connection.rst new file mode 100644 index 000000000000..64a3e5e9bb7c --- /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_find_connection device_find_connection add_device_connection remove_device_connection 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..1628dcb34709 --- /dev/null +++ b/drivers/base/devcon.c @@ -0,0 +1,139 @@ +// SPDX-License-Identifier: GPL-2.0 +/** + * Device connections + * + * Copyright (C) 2018 Intel Corporation + * Author: Heikki Krogerus + */ + +#include +#include + +static DEFINE_MUTEX(devcon_lock); +static LIST_HEAD(devcon_list); + +/** + * __device_find_connection - 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_find_connection(struct device *dev, const char *con_id, + void *data, + void *(*match)(struct devcon *con, int ep, + void *data)) +{ + const char *devname = dev_name(dev); + struct devcon *con; + void *ret = NULL; + int ep; + + if (!match) + return NULL; + + rcu_read_lock(); + + list_for_each_entry_rcu(con, &devcon_list, list) { + ep = match_string(con->endpoint, 2, devname); + if (ep < 0) + continue; + + if (con_id && strcmp(con->id, con_id)) + continue; + + ret = match(con, !ep, data); + if (ret) + break; + } + + rcu_read_unlock(); + + return ret; +} +EXPORT_SYMBOL_GPL(__device_find_connection); + +#include +#include +#include +#include + +static struct bus_type *generic_match_buses[] = { + &platform_bus_type, +#ifdef CONFIG_PCI + &pci_bus_type, +#endif +#ifdef CONFIG_I2C + &i2c_bus_type, +#endif +#ifdef CONFIG_SPI_MASTER + &spi_bus_type, +#endif + NULL, +}; + +/* This tries to find the device from the most common bus types by name. */ +static void *generic_match(struct devcon *con, int ep, void *data) +{ + struct bus_type *bus; + struct device *dev; + + for (bus = generic_match_buses[0]; bus; bus++) { + dev = bus_find_device_by_name(bus, NULL, con->endpoint[ep]); + if (dev) + return dev; + } + + /* + * We only get called if a connection was found, tell the caller to + * wait for the other device to show up. + */ + return ERR_PTR(-EPROBE_DEFER); +} + +/** + * device_find_connection - Find two devices connected together + * @dev: Device with the connection + * @con_id: Identifier for the connection + * + * Find a connection with unique identifier @con_id between @dev and + * another device. On success returns handle to the device that is connected + * to @dev, with the reference count for the found device incremented. Returns + * NULL if no matching connection was found, or ERR_PTR(-EPROBE_DEFER) when a + * connection was found but the other device has not been enumerated yet. + */ +struct device *device_find_connection(struct device *dev, const char *con_id) +{ + return __device_find_connection(dev, con_id, generic_match, NULL); +} +EXPORT_SYMBOL_GPL(device_find_connection); + +/** + * add_device_connection - Register a collection of connection descriptions + * @con: Collection of connection descriptions to be registered + */ +void add_device_connection(struct devcon *con) +{ + mutex_lock(&devcon_lock); + list_add_tail_rcu(&con->list, &devcon_list); + mutex_unlock(&devcon_lock); +} +EXPORT_SYMBOL_GPL(add_device_connection); + +/** + * remove_device_connections - Unregister collection of connection descriptions + * @con: Collection of connection descriptions to be unregistered + */ +void remove_device_connection(struct devcon *con) +{ + mutex_lock(&devcon_lock); + list_del_rcu(&con->list); + mutex_unlock(&devcon_lock); + /* The caller may free the devcon struct immediately afterwards. */ + synchronize_rcu(); +} +EXPORT_SYMBOL_GPL(remove_device_connection); diff --git a/include/linux/connection.h b/include/linux/connection.h new file mode 100644 index 000000000000..b2af70df5a97 --- /dev/null +++ b/include/linux/connection.h @@ -0,0 +1,34 @@ +// SPDX-License-Identifier: GPL-2.0 + +#ifndef _LINUX_CONNECTION_H_ +#define _LINUX_CONNECTION_H_ + +#include + +struct device; + +/** + * struct devcon - Device Connection Descriptor + * @endpoint: The names of the two devices connected together + * @id: Unique identifier for the connection + * @list: List head, private for devcon internal use only + */ +struct devcon { + const char *endpoint[2]; + const char *id; + struct list_head list; +}; + +void *__device_find_connection(struct device *dev, const char *con_id, + void *data, + void *(*match)(struct devcon *con, int ep, + void *data)); + +struct device *device_find_connection(struct device *dev, const char *con_id); + +#define DEVCON(_ep0, _ep1, _id) (struct devcon) { { _ep0, _ep1 }, _id, } + +void add_device_connection(struct devcon *con); +void remove_device_connection(struct devcon *con); + +#endif /* _LINUX_CONNECTION_H_ */ -- 2.14.3 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: [v5,01/12] drivers: base: Unified device connection lookup From: Hans de Goede Message-Id: <20180228150749.26831-2-hdegoede@redhat.com> Date: Wed, 28 Feb 2018 16:07:38 +0100 To: Darren Hart , Andy Shevchenko , MyungJoo Ham , Chanwoo Choi , Mathias Nyman , Heikki Krogerus , Greg Kroah-Hartman , Guenter Roeck Cc: Hans de Goede , platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org List-ID: RnJvbTogSGVpa2tpIEtyb2dlcnVzIDxoZWlra2kua3JvZ2VydXNAbGludXguaW50ZWwuY29tPgoK U2V2ZXJhbCBmcmFtZXdvcmtzIC0gY2xrLCBncGlvLCBwaHksIHBtdywgZXRjLiAtIG1haW50YWlu Cmxvb2t1cCB0YWJsZXMgZm9yIGRlc2NyaWJpbmcgY29ubmVjdGlvbnMgYW5kIHByb3ZpZGUgY3Vz dG9tCkFQSSBmb3IgaGFuZGxpbmcgdGhlbS4gVGhpcyBpbnRyb2R1Y2VzIGEgc2luZ2xlIGdlbmVy aWMKbG9va3VwIHRhYmxlIGFuZCBBUEkgZm9yIHRoZSBjb25uZWN0aW9ucy4KClRoZSBtb3RpdmF0 aW9uIGZvciB0aGlzIGNvbW1pdCBpcyBjZW50cmFsaXppbmcgdGhlCmNvbm5lY3Rpb24gbG9va3Vw LCBidXQgdGhlIGdvYWwgaXMgdG8gdWx0aW1hdGVseSBleHRyYWN0IHRoZQpjb25uZWN0aW9uIGRl c2NyaXB0aW9ucyBhbHNvIGZyb20gZmlybXdhcmUgYnkgdXNpbmcgdGhlCmZ3bm9kZV9ncmFwaF8q IGZ1bmN0aW9ucyBhbmQgb3RoZXIgbWVjaGFuaXNtcyB0aGF0IGFyZQphdmFpbGFibGUuCgpTaWdu ZWQtb2ZmLWJ5OiBIZWlra2kgS3JvZ2VydXMgPGhlaWtraS5rcm9nZXJ1c0BsaW51eC5pbnRlbC5j b20+ClJldmlld2VkLWJ5OiBIYW5zIGRlIEdvZWRlIDxoZGVnb2VkZUByZWRoYXQuY29tPgpSZXZp ZXdlZC1ieTogQW5keSBTaGV2Y2hlbmtvIDxhbmR5LnNoZXZjaGVua29AZ21haWwuY29tPgpTaWdu ZWQtb2ZmLWJ5OiBIYW5zIGRlIEdvZWRlIDxoZGVnb2VkZUByZWRoYXQuY29tPgotLS0KQ2hhbmdl cyBpbiB2NToKLUFkZCBtaXNzaW5nIGRvY3VtZW50YXRpb24gZm9yIEBsaXN0IHN0cnVjdCBkZXZj b24gbWVtYmVyCgpDaGFuZ2VzIGluIHY0OgotQWRkIEFuZHkncyBSZXZpZXdlZC1ieQoKQ2hhbmdl cyBpbiB2MzoKLVZhcmlvdXMgc3BlbGxpbmcgYW5kIGdyYW1hciBmaXhlcyBpbiB0aGUgZG9jcyBw b2ludGVkIG91dCBieSBSYW5keSBEdW5sYXAKCkNoYW5nZXMgaW4gdjI6Ci1BZGQgYSAoc3RydWN0 IGRldmNvbikgY2FzdCB0byB0aGUgREVWQ09OKCkgbWFjcm8KLS0tCiBEb2N1bWVudGF0aW9uL2Ry aXZlci1hcGkvZGV2aWNlX2Nvbm5lY3Rpb24ucnN0IHwgIDQzICsrKysrKysrCiBkcml2ZXJzL2Jh c2UvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAzICstCiBkcml2ZXJzL2Jh c2UvZGV2Y29uLmMgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMTM5ICsrKysrKysrKysrKysr KysrKysrKysrKysKIGluY2x1ZGUvbGludXgvY29ubmVjdGlvbi5oICAgICAgICAgICAgICAgICAg ICAgfCAgMzQgKysrKysrCiA0IGZpbGVzIGNoYW5nZWQsIDIxOCBpbnNlcnRpb25zKCspLCAxIGRl bGV0aW9uKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2Rl dmljZV9jb25uZWN0aW9uLnJzdAogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvYmFzZS9kZXZj b24uYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvbGludXgvY29ubmVjdGlvbi5oCgpkaWZm IC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RldmljZV9jb25uZWN0aW9uLnJzdCBi L0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS9kZXZpY2VfY29ubmVjdGlvbi5yc3QKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi42NGEzZTVlOWJiN2MKLS0tIC9kZXYvbnVs bAorKysgYi9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZGV2aWNlX2Nvbm5lY3Rpb24ucnN0CkBA IC0wLDAgKzEsNDMgQEAKKz09PT09PT09PT09PT09PT09PQorRGV2aWNlIGNvbm5lY3Rpb25zCis9 PT09PT09PT09PT09PT09PT0KKworSW50cm9kdWN0aW9uCistLS0tLS0tLS0tLS0KKworRGV2aWNl cyBvZnRlbiBoYXZlIGNvbm5lY3Rpb25zIHRvIG90aGVyIGRldmljZXMgdGhhdCBhcmUgb3V0c2lk ZSBvZiB0aGUgZGlyZWN0CitjaGlsZC9wYXJlbnQgcmVsYXRpb25zaGlwLiBBIHNlcmlhbCBvciBu ZXR3b3JrIGNvbW11bmljYXRpb24gY29udHJvbGxlciwgd2hpY2gKK2NvdWxkIGJlIGEgUENJIGRl dmljZSwgbWF5IG5lZWQgdG8gYmUgYWJsZSB0byBnZXQgYSByZWZlcmVuY2UgdG8gaXRzIFBIWQor Y29tcG9uZW50LCB3aGljaCBjb3VsZCBiZSBhdHRhY2hlZCBmb3IgZXhhbXBsZSB0byB0aGUgSTJD IGJ1cy4gU29tZSBkZXZpY2UKK2RyaXZlcnMgbmVlZCB0byBiZSBhYmxlIHRvIGNvbnRyb2wgdGhl IGNsb2NrcyBvciB0aGUgR1BJT3MgZm9yIHRoZWlyIGRldmljZXMsCithbmQgc28gb24uCisKK0Rl dmljZSBjb25uZWN0aW9ucyBhcmUgZ2VuZXJpYyBkZXNjcmlwdGlvbnMgb2YgYW55IHR5cGUgb2Yg Y29ubmVjdGlvbiBiZXR3ZWVuCit0d28gc2VwYXJhdGUgZGV2aWNlcy4KKworRGV2aWNlIGNvbm5l Y3Rpb25zIGFsb25lIGRvIG5vdCBjcmVhdGUgYSBkZXBlbmRlbmN5IGJldHdlZW4gdGhlIHR3byBk ZXZpY2VzLgorVGhleSBhcmUgb25seSBkZXNjcmlwdGlvbnMgd2hpY2ggYXJlIG5vdCB0aWVkIHRv IGVpdGhlciBvZiB0aGUgZGV2aWNlcyBkaXJlY3RseS4KK0EgZGVwZW5kZW5jeSBiZXR3ZWVuIHRo ZSB0d28gZGV2aWNlcyBleGlzdHMgb25seSBpZiBvbmUgb2YgdGhlIHR3byBlbmRwb2ludAorZGV2 aWNlcyByZXF1ZXN0cyBhIHJlZmVyZW5jZSB0byB0aGUgb3RoZXIuIFRoZSBkZXNjcmlwdGlvbnMg dGhlbXNlbHZlcyBjYW4gYmUKK2RlZmluZWQgaW4gZmlybXdhcmUgKG5vdCB5ZXQgc3VwcG9ydGVk KSBvciB0aGV5IGNhbiBiZSBidWlsdC1pbi4KKworVXNhZ2UKKy0tLS0tCisKK0RldmljZSBjb25u ZWN0aW9ucyBzaG91bGQgZXhpc3QgYmVmb3JlIGRldmljZSBgYC0+cHJvYmVgYCBjYWxsYmFjayBp cyBjYWxsZWQgZm9yCitlaXRoZXIgZW5kcG9pbnQgZGV2aWNlIGluIHRoZSBkZXNjcmlwdGlvbi4g SWYgdGhlIGNvbm5lY3Rpb25zIGFyZSBkZWZpbmVkIGluCitmaXJtd2FyZSwgdGhpcyBpcyBub3Qg YSBwcm9ibGVtLiBJdCBzaG91bGQgYmUgY29uc2lkZXJlZCBpZiB0aGUgY29ubmVjdGlvbgorZGVz Y3JpcHRpb25zIGFyZSAiYnVpbHQtaW4iLCBhbmQgbmVlZCB0byBiZSBhZGRlZCBzZXBhcmF0ZWx5 LgorCitUaGUgY29ubmVjdGlvbiBkZXNjcmlwdGlvbiBjb25zaXN0cyBvZiB0aGUgbmFtZXMgb2Yg dGhlIHR3byBkZXZpY2VzIHdpdGggdGhlCitjb25uZWN0aW9uLCBpLmUuIHRoZSBlbmRwb2ludHMs IGFuZCB1bmlxdWUgaWRlbnRpZmllciBmb3IgdGhlIGNvbm5lY3Rpb24gd2hpY2gKK2lzIG5lZWRl ZCBpZiB0aGVyZSBhcmUgbXVsdGlwbGUgY29ubmVjdGlvbnMgYmV0d2VlbiB0aGUgdHdvIGRldmlj ZXMuCisKK0FmdGVyIGEgZGVzY3JpcHRpb24gZXhpc3RzLCB0aGUgZGV2aWNlcyBpbiBpdCBjYW4g cmVxdWVzdCByZWZlcmVuY2UgdG8gdGhlIG90aGVyCitlbmRwb2ludCBkZXZpY2UsIG9yIHRoZXkg Y2FuIHJlcXVlc3QgdGhlIGRlc2NyaXB0aW9uIGl0c2VsZi4KKworQVBJCistLS0KKworLi4ga2Vy bmVsLWRvYzo6IGRyaXZlcnMvYmFzZS9kZXZjb24uYworICAgOiBmdW5jdGlvbnM6IF9fZGV2aWNl X2ZpbmRfY29ubmVjdGlvbiBkZXZpY2VfZmluZF9jb25uZWN0aW9uIGFkZF9kZXZpY2VfY29ubmVj dGlvbiByZW1vdmVfZGV2aWNlX2Nvbm5lY3Rpb24KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmFzZS9N YWtlZmlsZSBiL2RyaXZlcnMvYmFzZS9NYWtlZmlsZQppbmRleCBlMzJhNTI0OTAwNTEuLjEyYTdm NjRkMzVhOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9iYXNlL01ha2VmaWxlCisrKyBiL2RyaXZlcnMv YmFzZS9NYWtlZmlsZQpAQCAtNSw3ICs1LDggQEAgb2JqLXkJCQk6PSBjb21wb25lbnQubyBjb3Jl Lm8gYnVzLm8gZGQubyBzeXNjb3JlLm8gXAogCQkJICAgZHJpdmVyLm8gY2xhc3MubyBwbGF0Zm9y bS5vIFwKIAkJCSAgIGNwdS5vIGZpcm13YXJlLm8gaW5pdC5vIG1hcC5vIGRldnJlcy5vIFwKIAkJ CSAgIGF0dHJpYnV0ZV9jb250YWluZXIubyB0cmFuc3BvcnRfY2xhc3MubyBcCi0JCQkgICB0b3Bv bG9neS5vIGNvbnRhaW5lci5vIHByb3BlcnR5Lm8gY2FjaGVpbmZvLm8KKwkJCSAgIHRvcG9sb2d5 Lm8gY29udGFpbmVyLm8gcHJvcGVydHkubyBjYWNoZWluZm8ubyBcCisJCQkgICBkZXZjb24ubwog b2JqLSQoQ09ORklHX0RFVlRNUEZTKQkrPSBkZXZ0bXBmcy5vCiBvYmotJChDT05GSUdfRE1BX0NN QSkgKz0gZG1hLWNvbnRpZ3VvdXMubwogb2JqLXkJCQkrPSBwb3dlci8KZGlmZiAtLWdpdCBhL2Ry aXZlcnMvYmFzZS9kZXZjb24uYyBiL2RyaXZlcnMvYmFzZS9kZXZjb24uYwpuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjE2MjhkY2IzNDcwOQotLS0gL2Rldi9udWxsCisr KyBiL2RyaXZlcnMvYmFzZS9kZXZjb24uYwpAQCAtMCwwICsxLDEzOSBAQAorLy8gU1BEWC1MaWNl bnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKy8qKgorICogRGV2aWNlIGNvbm5lY3Rpb25zCisgKgor ICogQ29weXJpZ2h0IChDKSAyMDE4IEludGVsIENvcnBvcmF0aW9uCisgKiBBdXRob3I6IEhlaWtr aSBLcm9nZXJ1cyA8aGVpa2tpLmtyb2dlcnVzQGxpbnV4LmludGVsLmNvbT4KKyAqLworCisjaW5j bHVkZSA8bGludXgvY29ubmVjdGlvbi5oPgorI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgorCitz dGF0aWMgREVGSU5FX01VVEVYKGRldmNvbl9sb2NrKTsKK3N0YXRpYyBMSVNUX0hFQUQoZGV2Y29u X2xpc3QpOworCisvKioKKyAqIF9fZGV2aWNlX2ZpbmRfY29ubmVjdGlvbiAtIEZpbmQgcGh5c2lj YWwgY29ubmVjdGlvbiB0byBhIGRldmljZQorICogQGRldjogRGV2aWNlIHdpdGggdGhlIGNvbm5l Y3Rpb24KKyAqIEBjb25faWQ6IElkZW50aWZpZXIgZm9yIHRoZSBjb25uZWN0aW9uCisgKiBAZGF0 YTogRGF0YSBmb3IgdGhlIG1hdGNoIGZ1bmN0aW9uCisgKiBAbWF0Y2g6IEZ1bmN0aW9uIHRvIGNo ZWNrIGFuZCBjb252ZXJ0IHRoZSBjb25uZWN0aW9uIGRlc2NyaXB0aW9uCisgKgorICogRmluZCBh IGNvbm5lY3Rpb24gd2l0aCB1bmlxdWUgaWRlbnRpZmllciBAY29uX2lkIGJldHdlZW4gQGRldiBh bmQgYW5vdGhlcgorICogZGV2aWNlLiBAbWF0Y2ggd2lsbCBiZSB1c2VkIHRvIGNvbnZlcnQgdGhl IGNvbm5lY3Rpb24gZGVzY3JpcHRpb24gdG8gZGF0YSB0aGUKKyAqIGNhbGxlciBpcyBleHBlY3Rp bmcgdG8gYmUgcmV0dXJuZWQuCisgKi8KK3ZvaWQgKl9fZGV2aWNlX2ZpbmRfY29ubmVjdGlvbihz dHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IGNoYXIgKmNvbl9pZCwKKwkJCSAgICAgICB2b2lkICpk YXRhLAorCQkJICAgICAgIHZvaWQgKigqbWF0Y2gpKHN0cnVjdCBkZXZjb24gKmNvbiwgaW50IGVw LAorCQkJCQkgICAgICB2b2lkICpkYXRhKSkKK3sKKwljb25zdCBjaGFyICpkZXZuYW1lID0gZGV2 X25hbWUoZGV2KTsKKwlzdHJ1Y3QgZGV2Y29uICpjb247CisJdm9pZCAqcmV0ID0gTlVMTDsKKwlp bnQgZXA7CisKKwlpZiAoIW1hdGNoKQorCQlyZXR1cm4gTlVMTDsKKworCXJjdV9yZWFkX2xvY2so KTsKKworCWxpc3RfZm9yX2VhY2hfZW50cnlfcmN1KGNvbiwgJmRldmNvbl9saXN0LCBsaXN0KSB7 CisJCWVwID0gbWF0Y2hfc3RyaW5nKGNvbi0+ZW5kcG9pbnQsIDIsIGRldm5hbWUpOworCQlpZiAo ZXAgPCAwKQorCQkJY29udGludWU7CisKKwkJaWYgKGNvbl9pZCAmJiBzdHJjbXAoY29uLT5pZCwg Y29uX2lkKSkKKwkJCWNvbnRpbnVlOworCisJCXJldCA9IG1hdGNoKGNvbiwgIWVwLCBkYXRhKTsK KwkJaWYgKHJldCkKKwkJCWJyZWFrOworCX0KKworCXJjdV9yZWFkX3VubG9jaygpOworCisJcmV0 dXJuIHJldDsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKF9fZGV2aWNlX2ZpbmRfY29ubmVjdGlvbik7 CisKKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9z cGkvc3BpLmg+CisjaW5jbHVkZSA8bGludXgvaTJjLmg+CisjaW5jbHVkZSA8bGludXgvcGNpLmg+ CisKK3N0YXRpYyBzdHJ1Y3QgYnVzX3R5cGUgKmdlbmVyaWNfbWF0Y2hfYnVzZXNbXSA9IHsKKwkm cGxhdGZvcm1fYnVzX3R5cGUsCisjaWZkZWYgQ09ORklHX1BDSQorCSZwY2lfYnVzX3R5cGUsCisj ZW5kaWYKKyNpZmRlZiBDT05GSUdfSTJDCisJJmkyY19idXNfdHlwZSwKKyNlbmRpZgorI2lmZGVm IENPTkZJR19TUElfTUFTVEVSCisJJnNwaV9idXNfdHlwZSwKKyNlbmRpZgorCU5VTEwsCit9Owor CisvKiBUaGlzIHRyaWVzIHRvIGZpbmQgdGhlIGRldmljZSBmcm9tIHRoZSBtb3N0IGNvbW1vbiBi dXMgdHlwZXMgYnkgbmFtZS4gKi8KK3N0YXRpYyB2b2lkICpnZW5lcmljX21hdGNoKHN0cnVjdCBk ZXZjb24gKmNvbiwgaW50IGVwLCB2b2lkICpkYXRhKQoreworCXN0cnVjdCBidXNfdHlwZSAqYnVz OworCXN0cnVjdCBkZXZpY2UgKmRldjsKKworCWZvciAoYnVzID0gZ2VuZXJpY19tYXRjaF9idXNl c1swXTsgYnVzOyBidXMrKykgeworCQlkZXYgPSBidXNfZmluZF9kZXZpY2VfYnlfbmFtZShidXMs IE5VTEwsIGNvbi0+ZW5kcG9pbnRbZXBdKTsKKwkJaWYgKGRldikKKwkJCXJldHVybiBkZXY7CisJ fQorCisJLyoKKwkgKiBXZSBvbmx5IGdldCBjYWxsZWQgaWYgYSBjb25uZWN0aW9uIHdhcyBmb3Vu ZCwgdGVsbCB0aGUgY2FsbGVyIHRvCisJICogd2FpdCBmb3IgdGhlIG90aGVyIGRldmljZSB0byBz aG93IHVwLgorCSAqLworCXJldHVybiBFUlJfUFRSKC1FUFJPQkVfREVGRVIpOworfQorCisvKioK KyAqIGRldmljZV9maW5kX2Nvbm5lY3Rpb24gLSBGaW5kIHR3byBkZXZpY2VzIGNvbm5lY3RlZCB0 b2dldGhlcgorICogQGRldjogRGV2aWNlIHdpdGggdGhlIGNvbm5lY3Rpb24KKyAqIEBjb25faWQ6 IElkZW50aWZpZXIgZm9yIHRoZSBjb25uZWN0aW9uCisgKgorICogRmluZCBhIGNvbm5lY3Rpb24g d2l0aCB1bmlxdWUgaWRlbnRpZmllciBAY29uX2lkIGJldHdlZW4gQGRldiBhbmQKKyAqIGFub3Ro ZXIgZGV2aWNlLiBPbiBzdWNjZXNzIHJldHVybnMgaGFuZGxlIHRvIHRoZSBkZXZpY2UgdGhhdCBp cyBjb25uZWN0ZWQKKyAqIHRvIEBkZXYsIHdpdGggdGhlIHJlZmVyZW5jZSBjb3VudCBmb3IgdGhl IGZvdW5kIGRldmljZSBpbmNyZW1lbnRlZC4gUmV0dXJucworICogTlVMTCBpZiBubyBtYXRjaGlu ZyBjb25uZWN0aW9uIHdhcyBmb3VuZCwgb3IgRVJSX1BUUigtRVBST0JFX0RFRkVSKSB3aGVuIGEK KyAqIGNvbm5lY3Rpb24gd2FzIGZvdW5kIGJ1dCB0aGUgb3RoZXIgZGV2aWNlIGhhcyBub3QgYmVl biBlbnVtZXJhdGVkIHlldC4KKyAqLworc3RydWN0IGRldmljZSAqZGV2aWNlX2ZpbmRfY29ubmVj dGlvbihzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IGNoYXIgKmNvbl9pZCkKK3sKKwlyZXR1cm4g X19kZXZpY2VfZmluZF9jb25uZWN0aW9uKGRldiwgY29uX2lkLCBnZW5lcmljX21hdGNoLCBOVUxM KTsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKGRldmljZV9maW5kX2Nvbm5lY3Rpb24pOworCisvKioK KyAqIGFkZF9kZXZpY2VfY29ubmVjdGlvbiAtIFJlZ2lzdGVyIGEgY29sbGVjdGlvbiBvZiBjb25u ZWN0aW9uIGRlc2NyaXB0aW9ucworICogQGNvbjogQ29sbGVjdGlvbiBvZiBjb25uZWN0aW9uIGRl c2NyaXB0aW9ucyB0byBiZSByZWdpc3RlcmVkCisgKi8KK3ZvaWQgYWRkX2RldmljZV9jb25uZWN0 aW9uKHN0cnVjdCBkZXZjb24gKmNvbikKK3sKKwltdXRleF9sb2NrKCZkZXZjb25fbG9jayk7CisJ bGlzdF9hZGRfdGFpbF9yY3UoJmNvbi0+bGlzdCwgJmRldmNvbl9saXN0KTsKKwltdXRleF91bmxv Y2soJmRldmNvbl9sb2NrKTsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKGFkZF9kZXZpY2VfY29ubmVj dGlvbik7CisKKy8qKgorICogcmVtb3ZlX2RldmljZV9jb25uZWN0aW9ucyAtIFVucmVnaXN0ZXIg Y29sbGVjdGlvbiBvZiBjb25uZWN0aW9uIGRlc2NyaXB0aW9ucworICogQGNvbjogQ29sbGVjdGlv biBvZiBjb25uZWN0aW9uIGRlc2NyaXB0aW9ucyB0byBiZSB1bnJlZ2lzdGVyZWQKKyAqLwordm9p ZCByZW1vdmVfZGV2aWNlX2Nvbm5lY3Rpb24oc3RydWN0IGRldmNvbiAqY29uKQoreworCW11dGV4 X2xvY2soJmRldmNvbl9sb2NrKTsKKwlsaXN0X2RlbF9yY3UoJmNvbi0+bGlzdCk7CisJbXV0ZXhf dW5sb2NrKCZkZXZjb25fbG9jayk7CisJLyogVGhlIGNhbGxlciBtYXkgZnJlZSB0aGUgZGV2Y29u IHN0cnVjdCBpbW1lZGlhdGVseSBhZnRlcndhcmRzLiAqLworCXN5bmNocm9uaXplX3JjdSgpOwor fQorRVhQT1JUX1NZTUJPTF9HUEwocmVtb3ZlX2RldmljZV9jb25uZWN0aW9uKTsKZGlmZiAtLWdp dCBhL2luY2x1ZGUvbGludXgvY29ubmVjdGlvbi5oIGIvaW5jbHVkZS9saW51eC9jb25uZWN0aW9u LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5iMmFmNzBkZjVhOTcK LS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL2xpbnV4L2Nvbm5lY3Rpb24uaApAQCAtMCwwICsx LDM0IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorCisjaWZuZGVmIF9M SU5VWF9DT05ORUNUSU9OX0hfCisjZGVmaW5lIF9MSU5VWF9DT05ORUNUSU9OX0hfCisKKyNpbmNs dWRlIDxsaW51eC9saXN0Lmg+CisKK3N0cnVjdCBkZXZpY2U7CisKKy8qKgorICogc3RydWN0IGRl dmNvbiAtIERldmljZSBDb25uZWN0aW9uIERlc2NyaXB0b3IKKyAqIEBlbmRwb2ludDogVGhlIG5h bWVzIG9mIHRoZSB0d28gZGV2aWNlcyBjb25uZWN0ZWQgdG9nZXRoZXIKKyAqIEBpZDogVW5pcXVl IGlkZW50aWZpZXIgZm9yIHRoZSBjb25uZWN0aW9uCisgKiBAbGlzdDogTGlzdCBoZWFkLCBwcml2 YXRlIGZvciBkZXZjb24gaW50ZXJuYWwgdXNlIG9ubHkKKyAqLworc3RydWN0IGRldmNvbiB7CisJ Y29uc3QgY2hhcgkJKmVuZHBvaW50WzJdOworCWNvbnN0IGNoYXIJCSppZDsKKwlzdHJ1Y3QgbGlz dF9oZWFkCWxpc3Q7Cit9OworCit2b2lkICpfX2RldmljZV9maW5kX2Nvbm5lY3Rpb24oc3RydWN0 IGRldmljZSAqZGV2LCBjb25zdCBjaGFyICpjb25faWQsCisJCQkgICAgICAgdm9pZCAqZGF0YSwK KwkJCSAgICAgICB2b2lkICooKm1hdGNoKShzdHJ1Y3QgZGV2Y29uICpjb24sIGludCBlcCwKKwkJ CQkJICAgICAgdm9pZCAqZGF0YSkpOworCitzdHJ1Y3QgZGV2aWNlICpkZXZpY2VfZmluZF9jb25u ZWN0aW9uKHN0cnVjdCBkZXZpY2UgKmRldiwgY29uc3QgY2hhciAqY29uX2lkKTsKKworI2RlZmlu ZSBERVZDT04oX2VwMCwgX2VwMSwgX2lkKSAgICAoc3RydWN0IGRldmNvbikgeyB7IF9lcDAsIF9l cDEgfSwgX2lkLCB9CisKK3ZvaWQgYWRkX2RldmljZV9jb25uZWN0aW9uKHN0cnVjdCBkZXZjb24g KmNvbik7Cit2b2lkIHJlbW92ZV9kZXZpY2VfY29ubmVjdGlvbihzdHJ1Y3QgZGV2Y29uICpjb24p OworCisjZW5kaWYgLyogX0xJTlVYX0NPTk5FQ1RJT05fSF8gKi8K