From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Google-Smtp-Source: AG47ELvDagE22MxrNuBTR9kuSK4CovbFwrtb9ojTsgEzWnt0H4QfuBNA7TwHLAqEqFozQHhZqPvh ARC-Seal: i=1; a=rsa-sha256; t=1521550641; cv=none; d=google.com; s=arc-20160816; b=diJ5ZsqiN6IT7J9ZWq1lu1UbVbP1vcUcJNHWBpn5nkzN2uxeXI1jbs1gm6XlEZOQX3 z1Nuv1mjY547Au7HpNMLh+jFafKnh0hiPFR8f1SkOOK5u/K2ew1PJ8sUAPOhIPtHWKgk Z0PL2A4RJL/V/7+zQVFCtsQTTeqwnmbtxVAAL5mcyOlx8+fitCzWd176aG0l3hT7W2Mu wWyPkDnNPtDuI60pnOTkDyf2qDBCJSJdn6KU1ZETW4/eFTa+NEZUEGZ1MgY2GMITYVo3 KWbQjJaO2TFj/XN1Ne1AFmj9/LUDo2hT6jrM/W7c9EPjOW+/9i0QIYAmzF5AoYLvPZns XekQ== 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=CAFxkDKNbZisVBlgbw+JSXCOyxQkS11dACa8uecO0cE=; b=nhUdCFqgecBGJQPl0Ikn9JPSrr4jGpdd4w+HPOHRJlT24vv/SQ7enKgd6wN2IW1cS1 aL3z6tjFjx1EK3wHOh/i0nNjW5hP6pOQqkO12VBdrav9utkkl30ZnckF8bpZVXPeeUqk LE7IeKZgN50mo2NR40WawYWuJkqpbRfH5G49zb1iU3RRmBwgAVCUaCqZ7zqAEIdAhkCN HzntAVbF8may8h6nyHQ5tgMKLWw+ExIEqbDOZlw6LdQ29xYFmu1IiXluUQGecXIbk2D7 9YZpJqysmDLV0ZON/XJap3sKHp/usNboA87NenTbnWTwknJqwC0c2Ys85Z+XPlwN4KNa 2dqQ== 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.31 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.31 as permitted sender) smtp.mailfrom=heikki.krogerus@linux.intel.com X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.48,335,1517904000"; d="scan'208";a="39592493" From: Heikki Krogerus To: Greg Kroah-Hartman , Hans de Goede Cc: 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: [PATCH v9 01/12] drivers: base: Unified device connection lookup Date: Tue, 20 Mar 2018 15:57:02 +0300 Message-Id: <20180320125713.85465-2-heikki.krogerus@linux.intel.com> X-Mailer: git-send-email 2.16.2 In-Reply-To: <20180320125713.85465-1-heikki.krogerus@linux.intel.com> References: <20180320125713.85465-1-heikki.krogerus@linux.intel.com> X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: =?utf-8?q?1593820906030657716?= X-GMAIL-MSGID: =?utf-8?q?1595461485373556910?= X-Mailing-List: linux-kernel@vger.kernel.org List-ID: 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 v9 - Now really stop using rcu. - Decalaring the bus types as extern so we don't have to include the header files. Changes in v8: - No longer using rcu. 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 | 136 +++++++++++++++++++++++++ include/linux/device.h | 22 ++++ 4 files changed, 203 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 f261143fafbf..888725ad59f7 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..d427e806cd73 --- /dev/null +++ b/drivers/base/devcon.c @@ -0,0 +1,136 @@ +// 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; + + mutex_lock(&devcon_lock); + + list_for_each_entry(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; + } + + mutex_unlock(&devcon_lock); + + return ret; +} +EXPORT_SYMBOL_GPL(device_connection_find_match); + +extern struct bus_type platform_bus_type; +extern struct bus_type pci_bus_type; +extern struct bus_type i2c_bus_type; +extern struct bus_type spi_bus_type; + +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 device_connection *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_connection_find - 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_connection_find(struct device *dev, const char *con_id) +{ + return device_connection_find_match(dev, con_id, NULL, generic_match); +} +EXPORT_SYMBOL_GPL(device_connection_find); + +/** + * device_connection_add - Register a connection description + * @con: The connection description to be registered + */ +void device_connection_add(struct device_connection *con) +{ + mutex_lock(&devcon_lock); + list_add_tail(&con->list, &devcon_list); + mutex_unlock(&devcon_lock); +} +EXPORT_SYMBOL_GPL(device_connection_add); + +/** + * device_connections_remove - Unregister connection description + * @con: The connection description to be unregistered + */ +void device_connection_remove(struct device_connection *con) +{ + mutex_lock(&devcon_lock); + list_del(&con->list); + mutex_unlock(&devcon_lock); +} +EXPORT_SYMBOL_GPL(device_connection_remove); diff --git a/include/linux/device.h b/include/linux/device.h index e81fcea5d8a0..0059b99e1f25 100644 --- a/include/linux/device.h +++ b/include/linux/device.h @@ -730,6 +730,28 @@ struct device_dma_parameters { unsigned long segment_boundary_mask; }; +/** + * struct device_connection - Device Connection Descriptor + * @endpoint: The names of the two devices connected together + * @id: Unique identifier for the connection + * @list: List head, private, for internal use only + */ +struct device_connection { + const char *endpoint[2]; + const char *id; + struct list_head list; +}; + +void *device_connection_find_match(struct device *dev, const char *con_id, + void *data, + void *(*match)(struct device_connection *con, + int ep, void *data)); + +struct device *device_connection_find(struct device *dev, const char *con_id); + +void device_connection_add(struct device_connection *con); +void device_connection_remove(struct device_connection *con); + /** * enum device_link_state - Device link states. * @DL_STATE_NONE: The presence of the drivers is not being tracked. -- 2.16.2 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: [v9,01/12] drivers: base: Unified device connection lookup From: Heikki Krogerus Message-Id: <20180320125713.85465-2-heikki.krogerus@linux.intel.com> Date: Tue, 20 Mar 2018 15:57:02 +0300 To: Greg Kroah-Hartman , Hans de Goede Cc: 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: U2V2ZXJhbCBmcmFtZXdvcmtzIC0gY2xrLCBncGlvLCBwaHksIHBtdywgZXRjLiAtIG1haW50YWlu Cmxvb2t1cCB0YWJsZXMgZm9yIGRlc2NyaWJpbmcgY29ubmVjdGlvbnMgYW5kIHByb3ZpZGUgY3Vz dG9tCkFQSSBmb3IgaGFuZGxpbmcgdGhlbS4gVGhpcyBpbnRyb2R1Y2VzIGEgc2luZ2xlIGdlbmVy aWMKbG9va3VwIHRhYmxlIGFuZCBBUEkgZm9yIHRoZSBjb25uZWN0aW9ucy4KClRoZSBtb3RpdmF0 aW9uIGZvciB0aGlzIGNvbW1pdCBpcyBjZW50cmFsaXppbmcgdGhlCmNvbm5lY3Rpb24gbG9va3Vw LCBidXQgdGhlIGdvYWwgaXMgdG8gdWx0aW1hdGVseSBleHRyYWN0IHRoZQpjb25uZWN0aW9uIGRl c2NyaXB0aW9ucyBhbHNvIGZyb20gZmlybXdhcmUgYnkgdXNpbmcgdGhlCmZ3bm9kZV9ncmFwaF8q IGZ1bmN0aW9ucyBhbmQgb3RoZXIgbWVjaGFuaXNtcyB0aGF0IGFyZQphdmFpbGFibGUuCgpSZXZp ZXdlZC1ieTogSGFucyBkZSBHb2VkZSA8aGRlZ29lZGVAcmVkaGF0LmNvbT4KUmV2aWV3ZWQtYnk6 IEFuZHkgU2hldmNoZW5rbyA8YW5keS5zaGV2Y2hlbmtvQGdtYWlsLmNvbT4KU2lnbmVkLW9mZi1i eTogSGVpa2tpIEtyb2dlcnVzIDxoZWlra2kua3JvZ2VydXNAbGludXguaW50ZWwuY29tPgotLS0K Q2hhbmdlcyBpbiB2OQotIE5vdyByZWFsbHkgc3RvcCB1c2luZyByY3UuCi0gRGVjYWxhcmluZyB0 aGUgYnVzIHR5cGVzIGFzIGV4dGVybiBzbyB3ZSBkb24ndCBoYXZlIHRvIGluY2x1ZGUgdGhlIGhl YWRlcgogIGZpbGVzLgoKQ2hhbmdlcyBpbiB2ODoKLSBObyBsb25nZXIgdXNpbmcgcmN1LgoKQ2hh bmdlcyBpbiB2NzoKLSBBUEkgbmFtaW5nIGltcHJvdmVtZW50cyBzdWdnZXN0ZWQgYnkgR3JlZwot IFByb3RvdHlwZXMgdG8gZGV2aWNlLmgsIGFsc28gc3VnZ2VzdGVkIGJ5IEdyZWcKLSBJIHJlbW92 ZWQgdGhlIERFVkNPTigpIG1hY3JvIGFzIGl0IHdhcyBub3QgdXNlZCB5ZXQgYW5kIGl0IG5lZWRz IHRvIGJlCiAgcmV3cml0dGVuCgpDaGFuZ2VzIGluIHY2OgotRml4IGRhdGEgYW5kIG1hdGNoIGFy Z3VtZW50cyBiZWluZyBzd2FwcGVkIGluIF9fZGV2aWNlX2ZpbmRfY29ubmVjdGlvbigpCiBjYWxs IGluIGRldmljZV9maW5kX2Nvbm5lY3Rpb24oKSAoYXMgbm90aWNlZCBieSBKdW4gTGkpCgpDaGFu Z2VzIGluIHY1OgotQWRkIG1pc3NpbmcgZG9jdW1lbnRhdGlvbiBmb3IgQGxpc3Qgc3RydWN0IGRl dmNvbiBtZW1iZXIKCkNoYW5nZXMgaW4gdjQ6Ci1BZGQgQW5keSdzIFJldmlld2VkLWJ5CgpDaGFu Z2VzIGluIHYzOgotVmFyaW91cyBzcGVsbGluZyBhbmQgZ3JhbWFyIGZpeGVzIGluIHRoZSBkb2Nz IHBvaW50ZWQgb3V0IGJ5IFJhbmR5IER1bmxhcAoKQ2hhbmdlcyBpbiB2MjoKLUFkZCBhIChzdHJ1 Y3QgZGV2Y29uKSBjYXN0IHRvIHRoZSBERVZDT04oKSBtYWNybwotLS0KIERvY3VtZW50YXRpb24v ZHJpdmVyLWFwaS9kZXZpY2VfY29ubmVjdGlvbi5yc3QgfCAgNDMgKysrKysrKysKIGRyaXZlcnMv YmFzZS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDMgKy0KIGRyaXZlcnMv YmFzZS9kZXZjb24uYyAgICAgICAgICAgICAgICAgICAgICAgICAgfCAxMzYgKysrKysrKysrKysr KysrKysrKysrKysrKwogaW5jbHVkZS9saW51eC9kZXZpY2UuaCAgICAgICAgICAgICAgICAgICAg ICAgICB8ICAyMiArKysrCiA0IGZpbGVzIGNoYW5nZWQsIDIwMyBpbnNlcnRpb25zKCspLCAxIGRl bGV0aW9uKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2Rl dmljZV9jb25uZWN0aW9uLnJzdAogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvYmFzZS9kZXZj b24uYwoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS9kZXZpY2VfY29ubmVj dGlvbi5yc3QgYi9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZGV2aWNlX2Nvbm5lY3Rpb24ucnN0 Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uYWZmYmM1NTY2YWIwCi0t LSAvZGV2L251bGwKKysrIGIvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RldmljZV9jb25uZWN0 aW9uLnJzdApAQCAtMCwwICsxLDQzIEBACis9PT09PT09PT09PT09PT09PT0KK0RldmljZSBjb25u ZWN0aW9ucworPT09PT09PT09PT09PT09PT09CisKK0ludHJvZHVjdGlvbgorLS0tLS0tLS0tLS0t CisKK0RldmljZXMgb2Z0ZW4gaGF2ZSBjb25uZWN0aW9ucyB0byBvdGhlciBkZXZpY2VzIHRoYXQg YXJlIG91dHNpZGUgb2YgdGhlIGRpcmVjdAorY2hpbGQvcGFyZW50IHJlbGF0aW9uc2hpcC4gQSBz ZXJpYWwgb3IgbmV0d29yayBjb21tdW5pY2F0aW9uIGNvbnRyb2xsZXIsIHdoaWNoCitjb3VsZCBi ZSBhIFBDSSBkZXZpY2UsIG1heSBuZWVkIHRvIGJlIGFibGUgdG8gZ2V0IGEgcmVmZXJlbmNlIHRv IGl0cyBQSFkKK2NvbXBvbmVudCwgd2hpY2ggY291bGQgYmUgYXR0YWNoZWQgZm9yIGV4YW1wbGUg dG8gdGhlIEkyQyBidXMuIFNvbWUgZGV2aWNlCitkcml2ZXJzIG5lZWQgdG8gYmUgYWJsZSB0byBj b250cm9sIHRoZSBjbG9ja3Mgb3IgdGhlIEdQSU9zIGZvciB0aGVpciBkZXZpY2VzLAorYW5kIHNv IG9uLgorCitEZXZpY2UgY29ubmVjdGlvbnMgYXJlIGdlbmVyaWMgZGVzY3JpcHRpb25zIG9mIGFu eSB0eXBlIG9mIGNvbm5lY3Rpb24gYmV0d2VlbgordHdvIHNlcGFyYXRlIGRldmljZXMuCisKK0Rl dmljZSBjb25uZWN0aW9ucyBhbG9uZSBkbyBub3QgY3JlYXRlIGEgZGVwZW5kZW5jeSBiZXR3ZWVu IHRoZSB0d28gZGV2aWNlcy4KK1RoZXkgYXJlIG9ubHkgZGVzY3JpcHRpb25zIHdoaWNoIGFyZSBu b3QgdGllZCB0byBlaXRoZXIgb2YgdGhlIGRldmljZXMgZGlyZWN0bHkuCitBIGRlcGVuZGVuY3kg YmV0d2VlbiB0aGUgdHdvIGRldmljZXMgZXhpc3RzIG9ubHkgaWYgb25lIG9mIHRoZSB0d28gZW5k cG9pbnQKK2RldmljZXMgcmVxdWVzdHMgYSByZWZlcmVuY2UgdG8gdGhlIG90aGVyLiBUaGUgZGVz Y3JpcHRpb25zIHRoZW1zZWx2ZXMgY2FuIGJlCitkZWZpbmVkIGluIGZpcm13YXJlIChub3QgeWV0 IHN1cHBvcnRlZCkgb3IgdGhleSBjYW4gYmUgYnVpbHQtaW4uCisKK1VzYWdlCistLS0tLQorCitE ZXZpY2UgY29ubmVjdGlvbnMgc2hvdWxkIGV4aXN0IGJlZm9yZSBkZXZpY2UgYGAtPnByb2JlYGAg Y2FsbGJhY2sgaXMgY2FsbGVkIGZvcgorZWl0aGVyIGVuZHBvaW50IGRldmljZSBpbiB0aGUgZGVz Y3JpcHRpb24uIElmIHRoZSBjb25uZWN0aW9ucyBhcmUgZGVmaW5lZCBpbgorZmlybXdhcmUsIHRo aXMgaXMgbm90IGEgcHJvYmxlbS4gSXQgc2hvdWxkIGJlIGNvbnNpZGVyZWQgaWYgdGhlIGNvbm5l Y3Rpb24KK2Rlc2NyaXB0aW9ucyBhcmUgImJ1aWx0LWluIiwgYW5kIG5lZWQgdG8gYmUgYWRkZWQg c2VwYXJhdGVseS4KKworVGhlIGNvbm5lY3Rpb24gZGVzY3JpcHRpb24gY29uc2lzdHMgb2YgdGhl IG5hbWVzIG9mIHRoZSB0d28gZGV2aWNlcyB3aXRoIHRoZQorY29ubmVjdGlvbiwgaS5lLiB0aGUg ZW5kcG9pbnRzLCBhbmQgdW5pcXVlIGlkZW50aWZpZXIgZm9yIHRoZSBjb25uZWN0aW9uIHdoaWNo CitpcyBuZWVkZWQgaWYgdGhlcmUgYXJlIG11bHRpcGxlIGNvbm5lY3Rpb25zIGJldHdlZW4gdGhl IHR3byBkZXZpY2VzLgorCitBZnRlciBhIGRlc2NyaXB0aW9uIGV4aXN0cywgdGhlIGRldmljZXMg aW4gaXQgY2FuIHJlcXVlc3QgcmVmZXJlbmNlIHRvIHRoZSBvdGhlcgorZW5kcG9pbnQgZGV2aWNl LCBvciB0aGV5IGNhbiByZXF1ZXN0IHRoZSBkZXNjcmlwdGlvbiBpdHNlbGYuCisKK0FQSQorLS0t CisKKy4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL2Jhc2UvZGV2Y29uLmMKKyAgIDogZnVuY3Rpb25z OiBkZXZpY2VfY29ubmVjdGlvbl9maW5kX21hdGNoIGRldmljZV9jb25uZWN0aW9uX2ZpbmQgZGV2 aWNlX2Nvbm5lY3Rpb25fYWRkIGRldmljZV9jb25uZWN0aW9uX3JlbW92ZQpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9iYXNlL01ha2VmaWxlIGIvZHJpdmVycy9iYXNlL01ha2VmaWxlCmluZGV4IGYyNjEx NDNmYWZiZi4uODg4NzI1YWQ1OWY3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jhc2UvTWFrZWZpbGUK KysrIGIvZHJpdmVycy9iYXNlL01ha2VmaWxlCkBAIC01LDcgKzUsOCBAQCBvYmoteQkJCTo9IGNv bXBvbmVudC5vIGNvcmUubyBidXMubyBkZC5vIHN5c2NvcmUubyBcCiAJCQkgICBkcml2ZXIubyBj bGFzcy5vIHBsYXRmb3JtLm8gXAogCQkJICAgY3B1Lm8gZmlybXdhcmUubyBpbml0Lm8gbWFwLm8g ZGV2cmVzLm8gXAogCQkJICAgYXR0cmlidXRlX2NvbnRhaW5lci5vIHRyYW5zcG9ydF9jbGFzcy5v IFwKLQkJCSAgIHRvcG9sb2d5Lm8gY29udGFpbmVyLm8gcHJvcGVydHkubyBjYWNoZWluZm8ubwor CQkJICAgdG9wb2xvZ3kubyBjb250YWluZXIubyBwcm9wZXJ0eS5vIGNhY2hlaW5mby5vIFwKKwkJ CSAgIGRldmNvbi5vCiBvYmotJChDT05GSUdfREVWVE1QRlMpCSs9IGRldnRtcGZzLm8KIG9iai0k KENPTkZJR19ETUFfQ01BKSArPSBkbWEtY29udGlndW91cy5vCiBvYmoteQkJCSs9IHBvd2VyLwpk aWZmIC0tZ2l0IGEvZHJpdmVycy9iYXNlL2RldmNvbi5jIGIvZHJpdmVycy9iYXNlL2RldmNvbi5j Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZDQyN2U4MDZjZDczCi0t LSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9iYXNlL2RldmNvbi5jCkBAIC0wLDAgKzEsMTM2IEBA CisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorLyoqCisgKiBEZXZpY2UgY29u bmVjdGlvbnMKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTggSW50ZWwgQ29ycG9yYXRpb24KKyAq IEF1dGhvcjogSGVpa2tpIEtyb2dlcnVzIDxoZWlra2kua3JvZ2VydXNAbGludXguaW50ZWwuY29t PgorICovCisKKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KKworc3RhdGljIERFRklORV9NVVRF WChkZXZjb25fbG9jayk7CitzdGF0aWMgTElTVF9IRUFEKGRldmNvbl9saXN0KTsKKworLyoqCisg KiBkZXZpY2VfY29ubmVjdGlvbl9maW5kX21hdGNoIC0gRmluZCBwaHlzaWNhbCBjb25uZWN0aW9u IHRvIGEgZGV2aWNlCisgKiBAZGV2OiBEZXZpY2Ugd2l0aCB0aGUgY29ubmVjdGlvbgorICogQGNv bl9pZDogSWRlbnRpZmllciBmb3IgdGhlIGNvbm5lY3Rpb24KKyAqIEBkYXRhOiBEYXRhIGZvciB0 aGUgbWF0Y2ggZnVuY3Rpb24KKyAqIEBtYXRjaDogRnVuY3Rpb24gdG8gY2hlY2sgYW5kIGNvbnZl cnQgdGhlIGNvbm5lY3Rpb24gZGVzY3JpcHRpb24KKyAqCisgKiBGaW5kIGEgY29ubmVjdGlvbiB3 aXRoIHVuaXF1ZSBpZGVudGlmaWVyIEBjb25faWQgYmV0d2VlbiBAZGV2IGFuZCBhbm90aGVyCisg KiBkZXZpY2UuIEBtYXRjaCB3aWxsIGJlIHVzZWQgdG8gY29udmVydCB0aGUgY29ubmVjdGlvbiBk ZXNjcmlwdGlvbiB0byBkYXRhIHRoZQorICogY2FsbGVyIGlzIGV4cGVjdGluZyB0byBiZSByZXR1 cm5lZC4KKyAqLwordm9pZCAqZGV2aWNlX2Nvbm5lY3Rpb25fZmluZF9tYXRjaChzdHJ1Y3QgZGV2 aWNlICpkZXYsIGNvbnN0IGNoYXIgKmNvbl9pZCwKKwkJCSAgICAgICB2b2lkICpkYXRhLAorCQkJ ICAgICAgIHZvaWQgKigqbWF0Y2gpKHN0cnVjdCBkZXZpY2VfY29ubmVjdGlvbiAqY29uLAorCQkJ CQkgICAgICBpbnQgZXAsIHZvaWQgKmRhdGEpKQoreworCWNvbnN0IGNoYXIgKmRldm5hbWUgPSBk ZXZfbmFtZShkZXYpOworCXN0cnVjdCBkZXZpY2VfY29ubmVjdGlvbiAqY29uOworCXZvaWQgKnJl dCA9IE5VTEw7CisJaW50IGVwOworCisJaWYgKCFtYXRjaCkKKwkJcmV0dXJuIE5VTEw7CisKKwlt dXRleF9sb2NrKCZkZXZjb25fbG9jayk7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNvbiwgJmRl dmNvbl9saXN0LCBsaXN0KSB7CisJCWVwID0gbWF0Y2hfc3RyaW5nKGNvbi0+ZW5kcG9pbnQsIDIs IGRldm5hbWUpOworCQlpZiAoZXAgPCAwKQorCQkJY29udGludWU7CisKKwkJaWYgKGNvbl9pZCAm JiBzdHJjbXAoY29uLT5pZCwgY29uX2lkKSkKKwkJCWNvbnRpbnVlOworCisJCXJldCA9IG1hdGNo KGNvbiwgIWVwLCBkYXRhKTsKKwkJaWYgKHJldCkKKwkJCWJyZWFrOworCX0KKworCW11dGV4X3Vu bG9jaygmZGV2Y29uX2xvY2spOworCisJcmV0dXJuIHJldDsKK30KK0VYUE9SVF9TWU1CT0xfR1BM KGRldmljZV9jb25uZWN0aW9uX2ZpbmRfbWF0Y2gpOworCitleHRlcm4gc3RydWN0IGJ1c190eXBl IHBsYXRmb3JtX2J1c190eXBlOworZXh0ZXJuIHN0cnVjdCBidXNfdHlwZSBwY2lfYnVzX3R5cGU7 CitleHRlcm4gc3RydWN0IGJ1c190eXBlIGkyY19idXNfdHlwZTsKK2V4dGVybiBzdHJ1Y3QgYnVz X3R5cGUgc3BpX2J1c190eXBlOworCitzdGF0aWMgc3RydWN0IGJ1c190eXBlICpnZW5lcmljX21h dGNoX2J1c2VzW10gPSB7CisJJnBsYXRmb3JtX2J1c190eXBlLAorI2lmZGVmIENPTkZJR19QQ0kK KwkmcGNpX2J1c190eXBlLAorI2VuZGlmCisjaWZkZWYgQ09ORklHX0kyQworCSZpMmNfYnVzX3R5 cGUsCisjZW5kaWYKKyNpZmRlZiBDT05GSUdfU1BJX01BU1RFUgorCSZzcGlfYnVzX3R5cGUsCisj ZW5kaWYKKwlOVUxMLAorfTsKKworLyogVGhpcyB0cmllcyB0byBmaW5kIHRoZSBkZXZpY2UgZnJv bSB0aGUgbW9zdCBjb21tb24gYnVzIHR5cGVzIGJ5IG5hbWUuICovCitzdGF0aWMgdm9pZCAqZ2Vu ZXJpY19tYXRjaChzdHJ1Y3QgZGV2aWNlX2Nvbm5lY3Rpb24gKmNvbiwgaW50IGVwLCB2b2lkICpk YXRhKQoreworCXN0cnVjdCBidXNfdHlwZSAqYnVzOworCXN0cnVjdCBkZXZpY2UgKmRldjsKKwor CWZvciAoYnVzID0gZ2VuZXJpY19tYXRjaF9idXNlc1swXTsgYnVzOyBidXMrKykgeworCQlkZXYg PSBidXNfZmluZF9kZXZpY2VfYnlfbmFtZShidXMsIE5VTEwsIGNvbi0+ZW5kcG9pbnRbZXBdKTsK KwkJaWYgKGRldikKKwkJCXJldHVybiBkZXY7CisJfQorCisJLyoKKwkgKiBXZSBvbmx5IGdldCBj YWxsZWQgaWYgYSBjb25uZWN0aW9uIHdhcyBmb3VuZCwgdGVsbCB0aGUgY2FsbGVyIHRvCisJICog d2FpdCBmb3IgdGhlIG90aGVyIGRldmljZSB0byBzaG93IHVwLgorCSAqLworCXJldHVybiBFUlJf UFRSKC1FUFJPQkVfREVGRVIpOworfQorCisvKioKKyAqIGRldmljZV9jb25uZWN0aW9uX2ZpbmQg LSBGaW5kIHR3byBkZXZpY2VzIGNvbm5lY3RlZCB0b2dldGhlcgorICogQGRldjogRGV2aWNlIHdp dGggdGhlIGNvbm5lY3Rpb24KKyAqIEBjb25faWQ6IElkZW50aWZpZXIgZm9yIHRoZSBjb25uZWN0 aW9uCisgKgorICogRmluZCBhIGNvbm5lY3Rpb24gd2l0aCB1bmlxdWUgaWRlbnRpZmllciBAY29u X2lkIGJldHdlZW4gQGRldiBhbmQKKyAqIGFub3RoZXIgZGV2aWNlLiBPbiBzdWNjZXNzIHJldHVy bnMgaGFuZGxlIHRvIHRoZSBkZXZpY2UgdGhhdCBpcyBjb25uZWN0ZWQKKyAqIHRvIEBkZXYsIHdp dGggdGhlIHJlZmVyZW5jZSBjb3VudCBmb3IgdGhlIGZvdW5kIGRldmljZSBpbmNyZW1lbnRlZC4g UmV0dXJucworICogTlVMTCBpZiBubyBtYXRjaGluZyBjb25uZWN0aW9uIHdhcyBmb3VuZCwgb3Ig RVJSX1BUUigtRVBST0JFX0RFRkVSKSB3aGVuIGEKKyAqIGNvbm5lY3Rpb24gd2FzIGZvdW5kIGJ1 dCB0aGUgb3RoZXIgZGV2aWNlIGhhcyBub3QgYmVlbiBlbnVtZXJhdGVkIHlldC4KKyAqLworc3Ry dWN0IGRldmljZSAqZGV2aWNlX2Nvbm5lY3Rpb25fZmluZChzdHJ1Y3QgZGV2aWNlICpkZXYsIGNv bnN0IGNoYXIgKmNvbl9pZCkKK3sKKwlyZXR1cm4gZGV2aWNlX2Nvbm5lY3Rpb25fZmluZF9tYXRj aChkZXYsIGNvbl9pZCwgTlVMTCwgZ2VuZXJpY19tYXRjaCk7Cit9CitFWFBPUlRfU1lNQk9MX0dQ TChkZXZpY2VfY29ubmVjdGlvbl9maW5kKTsKKworLyoqCisgKiBkZXZpY2VfY29ubmVjdGlvbl9h ZGQgLSBSZWdpc3RlciBhIGNvbm5lY3Rpb24gZGVzY3JpcHRpb24KKyAqIEBjb246IFRoZSBjb25u ZWN0aW9uIGRlc2NyaXB0aW9uIHRvIGJlIHJlZ2lzdGVyZWQKKyAqLwordm9pZCBkZXZpY2VfY29u bmVjdGlvbl9hZGQoc3RydWN0IGRldmljZV9jb25uZWN0aW9uICpjb24pCit7CisJbXV0ZXhfbG9j aygmZGV2Y29uX2xvY2spOworCWxpc3RfYWRkX3RhaWwoJmNvbi0+bGlzdCwgJmRldmNvbl9saXN0 KTsKKwltdXRleF91bmxvY2soJmRldmNvbl9sb2NrKTsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKGRl dmljZV9jb25uZWN0aW9uX2FkZCk7CisKKy8qKgorICogZGV2aWNlX2Nvbm5lY3Rpb25zX3JlbW92 ZSAtIFVucmVnaXN0ZXIgY29ubmVjdGlvbiBkZXNjcmlwdGlvbgorICogQGNvbjogVGhlIGNvbm5l Y3Rpb24gZGVzY3JpcHRpb24gdG8gYmUgdW5yZWdpc3RlcmVkCisgKi8KK3ZvaWQgZGV2aWNlX2Nv bm5lY3Rpb25fcmVtb3ZlKHN0cnVjdCBkZXZpY2VfY29ubmVjdGlvbiAqY29uKQoreworCW11dGV4 X2xvY2soJmRldmNvbl9sb2NrKTsKKwlsaXN0X2RlbCgmY29uLT5saXN0KTsKKwltdXRleF91bmxv Y2soJmRldmNvbl9sb2NrKTsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKGRldmljZV9jb25uZWN0aW9u X3JlbW92ZSk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2RldmljZS5oIGIvaW5jbHVkZS9s aW51eC9kZXZpY2UuaAppbmRleCBlODFmY2VhNWQ4YTAuLjAwNTliOTllMWYyNSAxMDA2NDQKLS0t IGEvaW5jbHVkZS9saW51eC9kZXZpY2UuaAorKysgYi9pbmNsdWRlL2xpbnV4L2RldmljZS5oCkBA IC03MzAsNiArNzMwLDI4IEBAIHN0cnVjdCBkZXZpY2VfZG1hX3BhcmFtZXRlcnMgewogCXVuc2ln bmVkIGxvbmcgc2VnbWVudF9ib3VuZGFyeV9tYXNrOwogfTsKIAorLyoqCisgKiBzdHJ1Y3QgZGV2 aWNlX2Nvbm5lY3Rpb24gLSBEZXZpY2UgQ29ubmVjdGlvbiBEZXNjcmlwdG9yCisgKiBAZW5kcG9p bnQ6IFRoZSBuYW1lcyBvZiB0aGUgdHdvIGRldmljZXMgY29ubmVjdGVkIHRvZ2V0aGVyCisgKiBA aWQ6IFVuaXF1ZSBpZGVudGlmaWVyIGZvciB0aGUgY29ubmVjdGlvbgorICogQGxpc3Q6IExpc3Qg aGVhZCwgcHJpdmF0ZSwgZm9yIGludGVybmFsIHVzZSBvbmx5CisgKi8KK3N0cnVjdCBkZXZpY2Vf Y29ubmVjdGlvbiB7CisJY29uc3QgY2hhcgkJKmVuZHBvaW50WzJdOworCWNvbnN0IGNoYXIJCSpp ZDsKKwlzdHJ1Y3QgbGlzdF9oZWFkCWxpc3Q7Cit9OworCit2b2lkICpkZXZpY2VfY29ubmVjdGlv bl9maW5kX21hdGNoKHN0cnVjdCBkZXZpY2UgKmRldiwgY29uc3QgY2hhciAqY29uX2lkLAorCQkJ CXZvaWQgKmRhdGEsCisJCQkJdm9pZCAqKCptYXRjaCkoc3RydWN0IGRldmljZV9jb25uZWN0aW9u ICpjb24sCisJCQkJCSAgICAgICBpbnQgZXAsIHZvaWQgKmRhdGEpKTsKKworc3RydWN0IGRldmlj ZSAqZGV2aWNlX2Nvbm5lY3Rpb25fZmluZChzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IGNoYXIg KmNvbl9pZCk7CisKK3ZvaWQgZGV2aWNlX2Nvbm5lY3Rpb25fYWRkKHN0cnVjdCBkZXZpY2VfY29u bmVjdGlvbiAqY29uKTsKK3ZvaWQgZGV2aWNlX2Nvbm5lY3Rpb25fcmVtb3ZlKHN0cnVjdCBkZXZp Y2VfY29ubmVjdGlvbiAqY29uKTsKKwogLyoqCiAgKiBlbnVtIGRldmljZV9saW5rX3N0YXRlIC0g RGV2aWNlIGxpbmsgc3RhdGVzLgogICogQERMX1NUQVRFX05PTkU6IFRoZSBwcmVzZW5jZSBvZiB0 aGUgZHJpdmVycyBpcyBub3QgYmVpbmcgdHJhY2tlZC4K