From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Google-Smtp-Source: AG47ELtGNPmiG5pvgag+wTKXGsVa/WfZ9erJvrFyMz3+fflW54MlQ70wfsM9tjbUDDxaqzY6/X9B ARC-Seal: i=1; a=rsa-sha256; t=1520865278; cv=none; d=google.com; s=arc-20160816; b=Qwfi7aIlMvtNEvTo+JGfa4R20gezypluqwy/0eJV/0j2cxHvCSjUaHn9jvEOkt5JXu +rzqgLDccPiAcClP+4BEYLaggccF8xnf08Oq7uz3zlNEH9LT22uWNWQHTA7jDhKFfAar 1Ht4pdDPZDB0PdvCMONpzWHj2nyxlMWZF9dK5GKm0yQ1lnXX/4xdE/mXeYHMVPOr/lDl fx732THwD4ozTtgsllxFCJ3TSvnmsjTnDxrX/khcqtrbBGsAX1FzUd8iHovylU6pF+Ok Ga5Z1wjfBJ5fb41rc2bM9qe3eea46kORoks1L10hLqAAjVZc4ipjbnk5DLVl/X1AC7rc 5qYA== 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=xb4o94N0/NQk9O0emdLCNZ0mAkHvSYV7oeqUr3/85nw=; b=CfBdiURi/E+z3cw6ZvBMrSqIiyQAQcDLO+60a5Pnop+Kt3MWOyWOAde9/bGSSo/0k/ 3eesV5HuEURf4KciVI8Wng4BnexuTJE5T0xCJX599EDhfTokOb8AFJB6hX1n2m21SIjq 6J/Y41lgPvkeu4EEgvForjxNLjSJ/cEV4+S+2xvUkmkoQIb6AG2/Q24tKNXA4ijo+XGs RrokhJXyUdiB7CHoH6ttBTXyJ9zsFrpLDZiR05ZVGhu6i29hpmCw4wYxPJAKJCBWP+0a jEKc1HYmWwyIZ7eQ0oAyPBbZzsCd3NkX1TsnR0UyCNAvUFNgn2w/n3cnh8mlpzq455bm PVrQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: best guess record for domain of heikki.krogerus@linux.intel.com designates 192.55.52.88 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 192.55.52.88 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.47,461,1515484800"; d="scan'208";a="37470763" 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 v7 01/12] drivers: base: Unified device connection lookup Date: Mon, 12 Mar 2018 17:34:20 +0300 Message-Id: <20180312143431.82396-2-heikki.krogerus@linux.intel.com> X-Mailer: git-send-email 2.16.1 In-Reply-To: <20180312143431.82396-1-heikki.krogerus@linux.intel.com> References: <20180312143431.82396-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?1594742830262937131?= 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 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(); + + 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_connection_find_match); + +#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 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_rcu(&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_rcu(&con->list); + mutex_unlock(&devcon_lock); + /* + * The caller may free the device_connection struct immediately + * afterwards. + */ + synchronize_rcu(); +} +EXPORT_SYMBOL_GPL(device_connection_remove); diff --git a/include/linux/device.h b/include/linux/device.h index b093405ed525..ee992f2d47ed 100644 --- a/include/linux/device.h +++ b/include/linux/device.h @@ -729,6 +729,28 @@ struct device_dma_parameters { unsigned long segment_boundary_mask; }; +/** + * struct device_connnection - 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.1 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: <20180312143431.82396-2-heikki.krogerus@linux.intel.com> Date: Mon, 12 Mar 2018 17:34:20 +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 Q2hhbmdlcyBpbiB2NzoKLSBBUEkgbmFtaW5nIGltcHJvdmVtZW50cyBzdWdnZXN0ZWQgYnkgR3Jl ZwotIFByb3RvdHlwZXMgdG8gZGV2aWNlLmgsIGFsc28gc3VnZ2VzdGVkIGJ5IEdyZWcKLSBJIHJl bW92ZWQgdGhlIERFVkNPTigpIG1hY3JvIGFzIGl0IHdhcyBub3QgdXNlZCB5ZXQgYW5kIGl0IG5l ZWRzIHRvIGJlCiAgcmV3cml0dGVuCgpDaGFuZ2VzIGluIHY2OgotRml4IGRhdGEgYW5kIG1hdGNo IGFyZ3VtZW50cyBiZWluZyBzd2FwcGVkIGluIF9fZGV2aWNlX2ZpbmRfY29ubmVjdGlvbigpCiBj YWxsIGluIGRldmljZV9maW5kX2Nvbm5lY3Rpb24oKSAoYXMgbm90aWNlZCBieSBKdW4gTGkpCgpD aGFuZ2VzIGluIHY1OgotQWRkIG1pc3NpbmcgZG9jdW1lbnRhdGlvbiBmb3IgQGxpc3Qgc3RydWN0 IGRldmNvbiBtZW1iZXIKCkNoYW5nZXMgaW4gdjQ6Ci1BZGQgQW5keSdzIFJldmlld2VkLWJ5CgpD aGFuZ2VzIGluIHYzOgotVmFyaW91cyBzcGVsbGluZyBhbmQgZ3JhbWFyIGZpeGVzIGluIHRoZSBk b2NzIHBvaW50ZWQgb3V0IGJ5IFJhbmR5IER1bmxhcAoKQ2hhbmdlcyBpbiB2MjoKLUFkZCBhIChz dHJ1Y3QgZGV2Y29uKSBjYXN0IHRvIHRoZSBERVZDT04oKSBtYWNybwotLS0KIERvY3VtZW50YXRp b24vZHJpdmVyLWFwaS9kZXZpY2VfY29ubmVjdGlvbi5yc3QgfCAgNDMgKysrKysrKysKIGRyaXZl cnMvYmFzZS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDMgKy0KIGRyaXZl cnMvYmFzZS9kZXZjb24uYyAgICAgICAgICAgICAgICAgICAgICAgICAgfCAxNDEgKysrKysrKysr KysrKysrKysrKysrKysrKwogaW5jbHVkZS9saW51eC9kZXZpY2UuaCAgICAgICAgICAgICAgICAg ICAgICAgICB8ICAyMiArKysrCiA0IGZpbGVzIGNoYW5nZWQsIDIwOCBpbnNlcnRpb25zKCspLCAx IGRlbGV0aW9uKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBp L2RldmljZV9jb25uZWN0aW9uLnJzdAogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvYmFzZS9k ZXZjb24uYwoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS9kZXZpY2VfY29u bmVjdGlvbi5yc3QgYi9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZGV2aWNlX2Nvbm5lY3Rpb24u cnN0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uYWZmYmM1NTY2YWIw Ci0tLSAvZGV2L251bGwKKysrIGIvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RldmljZV9jb25u ZWN0aW9uLnJzdApAQCAtMCwwICsxLDQzIEBACis9PT09PT09PT09PT09PT09PT0KK0RldmljZSBj b25uZWN0aW9ucworPT09PT09PT09PT09PT09PT09CisKK0ludHJvZHVjdGlvbgorLS0tLS0tLS0t LS0tCisKK0RldmljZXMgb2Z0ZW4gaGF2ZSBjb25uZWN0aW9ucyB0byBvdGhlciBkZXZpY2VzIHRo YXQgYXJlIG91dHNpZGUgb2YgdGhlIGRpcmVjdAorY2hpbGQvcGFyZW50IHJlbGF0aW9uc2hpcC4g QSBzZXJpYWwgb3IgbmV0d29yayBjb21tdW5pY2F0aW9uIGNvbnRyb2xsZXIsIHdoaWNoCitjb3Vs ZCBiZSBhIFBDSSBkZXZpY2UsIG1heSBuZWVkIHRvIGJlIGFibGUgdG8gZ2V0IGEgcmVmZXJlbmNl IHRvIGl0cyBQSFkKK2NvbXBvbmVudCwgd2hpY2ggY291bGQgYmUgYXR0YWNoZWQgZm9yIGV4YW1w bGUgdG8gdGhlIEkyQyBidXMuIFNvbWUgZGV2aWNlCitkcml2ZXJzIG5lZWQgdG8gYmUgYWJsZSB0 byBjb250cm9sIHRoZSBjbG9ja3Mgb3IgdGhlIEdQSU9zIGZvciB0aGVpciBkZXZpY2VzLAorYW5k IHNvIG9uLgorCitEZXZpY2UgY29ubmVjdGlvbnMgYXJlIGdlbmVyaWMgZGVzY3JpcHRpb25zIG9m IGFueSB0eXBlIG9mIGNvbm5lY3Rpb24gYmV0d2VlbgordHdvIHNlcGFyYXRlIGRldmljZXMuCisK K0RldmljZSBjb25uZWN0aW9ucyBhbG9uZSBkbyBub3QgY3JlYXRlIGEgZGVwZW5kZW5jeSBiZXR3 ZWVuIHRoZSB0d28gZGV2aWNlcy4KK1RoZXkgYXJlIG9ubHkgZGVzY3JpcHRpb25zIHdoaWNoIGFy ZSBub3QgdGllZCB0byBlaXRoZXIgb2YgdGhlIGRldmljZXMgZGlyZWN0bHkuCitBIGRlcGVuZGVu Y3kgYmV0d2VlbiB0aGUgdHdvIGRldmljZXMgZXhpc3RzIG9ubHkgaWYgb25lIG9mIHRoZSB0d28g ZW5kcG9pbnQKK2RldmljZXMgcmVxdWVzdHMgYSByZWZlcmVuY2UgdG8gdGhlIG90aGVyLiBUaGUg ZGVzY3JpcHRpb25zIHRoZW1zZWx2ZXMgY2FuIGJlCitkZWZpbmVkIGluIGZpcm13YXJlIChub3Qg eWV0IHN1cHBvcnRlZCkgb3IgdGhleSBjYW4gYmUgYnVpbHQtaW4uCisKK1VzYWdlCistLS0tLQor CitEZXZpY2UgY29ubmVjdGlvbnMgc2hvdWxkIGV4aXN0IGJlZm9yZSBkZXZpY2UgYGAtPnByb2Jl YGAgY2FsbGJhY2sgaXMgY2FsbGVkIGZvcgorZWl0aGVyIGVuZHBvaW50IGRldmljZSBpbiB0aGUg ZGVzY3JpcHRpb24uIElmIHRoZSBjb25uZWN0aW9ucyBhcmUgZGVmaW5lZCBpbgorZmlybXdhcmUs IHRoaXMgaXMgbm90IGEgcHJvYmxlbS4gSXQgc2hvdWxkIGJlIGNvbnNpZGVyZWQgaWYgdGhlIGNv bm5lY3Rpb24KK2Rlc2NyaXB0aW9ucyBhcmUgImJ1aWx0LWluIiwgYW5kIG5lZWQgdG8gYmUgYWRk ZWQgc2VwYXJhdGVseS4KKworVGhlIGNvbm5lY3Rpb24gZGVzY3JpcHRpb24gY29uc2lzdHMgb2Yg dGhlIG5hbWVzIG9mIHRoZSB0d28gZGV2aWNlcyB3aXRoIHRoZQorY29ubmVjdGlvbiwgaS5lLiB0 aGUgZW5kcG9pbnRzLCBhbmQgdW5pcXVlIGlkZW50aWZpZXIgZm9yIHRoZSBjb25uZWN0aW9uIHdo aWNoCitpcyBuZWVkZWQgaWYgdGhlcmUgYXJlIG11bHRpcGxlIGNvbm5lY3Rpb25zIGJldHdlZW4g dGhlIHR3byBkZXZpY2VzLgorCitBZnRlciBhIGRlc2NyaXB0aW9uIGV4aXN0cywgdGhlIGRldmlj ZXMgaW4gaXQgY2FuIHJlcXVlc3QgcmVmZXJlbmNlIHRvIHRoZSBvdGhlcgorZW5kcG9pbnQgZGV2 aWNlLCBvciB0aGV5IGNhbiByZXF1ZXN0IHRoZSBkZXNjcmlwdGlvbiBpdHNlbGYuCisKK0FQSQor LS0tCisKKy4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL2Jhc2UvZGV2Y29uLmMKKyAgIDogZnVuY3Rp b25zOiBkZXZpY2VfY29ubmVjdGlvbl9maW5kX21hdGNoIGRldmljZV9jb25uZWN0aW9uX2ZpbmQg ZGV2aWNlX2Nvbm5lY3Rpb25fYWRkIGRldmljZV9jb25uZWN0aW9uX3JlbW92ZQpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9iYXNlL01ha2VmaWxlIGIvZHJpdmVycy9iYXNlL01ha2VmaWxlCmluZGV4IGUz MmE1MjQ5MDA1MS4uMTJhN2Y2NGQzNWE5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jhc2UvTWFrZWZp bGUKKysrIGIvZHJpdmVycy9iYXNlL01ha2VmaWxlCkBAIC01LDcgKzUsOCBAQCBvYmoteQkJCTo9 IGNvbXBvbmVudC5vIGNvcmUubyBidXMubyBkZC5vIHN5c2NvcmUubyBcCiAJCQkgICBkcml2ZXIu byBjbGFzcy5vIHBsYXRmb3JtLm8gXAogCQkJICAgY3B1Lm8gZmlybXdhcmUubyBpbml0Lm8gbWFw Lm8gZGV2cmVzLm8gXAogCQkJICAgYXR0cmlidXRlX2NvbnRhaW5lci5vIHRyYW5zcG9ydF9jbGFz cy5vIFwKLQkJCSAgIHRvcG9sb2d5Lm8gY29udGFpbmVyLm8gcHJvcGVydHkubyBjYWNoZWluZm8u bworCQkJICAgdG9wb2xvZ3kubyBjb250YWluZXIubyBwcm9wZXJ0eS5vIGNhY2hlaW5mby5vIFwK KwkJCSAgIGRldmNvbi5vCiBvYmotJChDT05GSUdfREVWVE1QRlMpCSs9IGRldnRtcGZzLm8KIG9i ai0kKENPTkZJR19ETUFfQ01BKSArPSBkbWEtY29udGlndW91cy5vCiBvYmoteQkJCSs9IHBvd2Vy LwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9iYXNlL2RldmNvbi5jIGIvZHJpdmVycy9iYXNlL2RldmNv bi5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZTc4M2MyYzJlZDFh Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9iYXNlL2RldmNvbi5jCkBAIC0wLDAgKzEsMTQx IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorLyoqCisgKiBEZXZpY2Ug Y29ubmVjdGlvbnMKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTggSW50ZWwgQ29ycG9yYXRpb24K KyAqIEF1dGhvcjogSGVpa2tpIEtyb2dlcnVzIDxoZWlra2kua3JvZ2VydXNAbGludXguaW50ZWwu Y29tPgorICovCisKKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KKworc3RhdGljIERFRklORV9N VVRFWChkZXZjb25fbG9jayk7CitzdGF0aWMgTElTVF9IRUFEKGRldmNvbl9saXN0KTsKKworLyoq CisgKiBkZXZpY2VfY29ubmVjdGlvbl9maW5kX21hdGNoIC0gRmluZCBwaHlzaWNhbCBjb25uZWN0 aW9uIHRvIGEgZGV2aWNlCisgKiBAZGV2OiBEZXZpY2Ugd2l0aCB0aGUgY29ubmVjdGlvbgorICog QGNvbl9pZDogSWRlbnRpZmllciBmb3IgdGhlIGNvbm5lY3Rpb24KKyAqIEBkYXRhOiBEYXRhIGZv ciB0aGUgbWF0Y2ggZnVuY3Rpb24KKyAqIEBtYXRjaDogRnVuY3Rpb24gdG8gY2hlY2sgYW5kIGNv bnZlcnQgdGhlIGNvbm5lY3Rpb24gZGVzY3JpcHRpb24KKyAqCisgKiBGaW5kIGEgY29ubmVjdGlv biB3aXRoIHVuaXF1ZSBpZGVudGlmaWVyIEBjb25faWQgYmV0d2VlbiBAZGV2IGFuZCBhbm90aGVy CisgKiBkZXZpY2UuIEBtYXRjaCB3aWxsIGJlIHVzZWQgdG8gY29udmVydCB0aGUgY29ubmVjdGlv biBkZXNjcmlwdGlvbiB0byBkYXRhIHRoZQorICogY2FsbGVyIGlzIGV4cGVjdGluZyB0byBiZSBy ZXR1cm5lZC4KKyAqLwordm9pZCAqZGV2aWNlX2Nvbm5lY3Rpb25fZmluZF9tYXRjaChzdHJ1Y3Qg ZGV2aWNlICpkZXYsIGNvbnN0IGNoYXIgKmNvbl9pZCwKKwkJCSAgICAgICB2b2lkICpkYXRhLAor CQkJICAgICAgIHZvaWQgKigqbWF0Y2gpKHN0cnVjdCBkZXZpY2VfY29ubmVjdGlvbiAqY29uLAor CQkJCQkgICAgICBpbnQgZXAsIHZvaWQgKmRhdGEpKQoreworCWNvbnN0IGNoYXIgKmRldm5hbWUg PSBkZXZfbmFtZShkZXYpOworCXN0cnVjdCBkZXZpY2VfY29ubmVjdGlvbiAqY29uOworCXZvaWQg KnJldCA9IE5VTEw7CisJaW50IGVwOworCisJaWYgKCFtYXRjaCkKKwkJcmV0dXJuIE5VTEw7CisK KwlyY3VfcmVhZF9sb2NrKCk7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShjb24sICZkZXZj b25fbGlzdCwgbGlzdCkgeworCQllcCA9IG1hdGNoX3N0cmluZyhjb24tPmVuZHBvaW50LCAyLCBk ZXZuYW1lKTsKKwkJaWYgKGVwIDwgMCkKKwkJCWNvbnRpbnVlOworCisJCWlmIChjb25faWQgJiYg c3RyY21wKGNvbi0+aWQsIGNvbl9pZCkpCisJCQljb250aW51ZTsKKworCQlyZXQgPSBtYXRjaChj b24sICFlcCwgZGF0YSk7CisJCWlmIChyZXQpCisJCQlicmVhazsKKwl9CisKKwlyY3VfcmVhZF91 bmxvY2soKTsKKworCXJldHVybiByZXQ7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChkZXZpY2VfY29u bmVjdGlvbl9maW5kX21hdGNoKTsKKworI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5o PgorI2luY2x1ZGUgPGxpbnV4L3NwaS9zcGkuaD4KKyNpbmNsdWRlIDxsaW51eC9pMmMuaD4KKyNp bmNsdWRlIDxsaW51eC9wY2kuaD4KKworc3RhdGljIHN0cnVjdCBidXNfdHlwZSAqZ2VuZXJpY19t YXRjaF9idXNlc1tdID0geworCSZwbGF0Zm9ybV9idXNfdHlwZSwKKyNpZmRlZiBDT05GSUdfUENJ CisJJnBjaV9idXNfdHlwZSwKKyNlbmRpZgorI2lmZGVmIENPTkZJR19JMkMKKwkmaTJjX2J1c190 eXBlLAorI2VuZGlmCisjaWZkZWYgQ09ORklHX1NQSV9NQVNURVIKKwkmc3BpX2J1c190eXBlLAor I2VuZGlmCisJTlVMTCwKK307CisKKy8qIFRoaXMgdHJpZXMgdG8gZmluZCB0aGUgZGV2aWNlIGZy b20gdGhlIG1vc3QgY29tbW9uIGJ1cyB0eXBlcyBieSBuYW1lLiAqLworc3RhdGljIHZvaWQgKmdl bmVyaWNfbWF0Y2goc3RydWN0IGRldmljZV9jb25uZWN0aW9uICpjb24sIGludCBlcCwgdm9pZCAq ZGF0YSkKK3sKKwlzdHJ1Y3QgYnVzX3R5cGUgKmJ1czsKKwlzdHJ1Y3QgZGV2aWNlICpkZXY7CisK Kwlmb3IgKGJ1cyA9IGdlbmVyaWNfbWF0Y2hfYnVzZXNbMF07IGJ1czsgYnVzKyspIHsKKwkJZGV2 ID0gYnVzX2ZpbmRfZGV2aWNlX2J5X25hbWUoYnVzLCBOVUxMLCBjb24tPmVuZHBvaW50W2VwXSk7 CisJCWlmIChkZXYpCisJCQlyZXR1cm4gZGV2OworCX0KKworCS8qCisJICogV2Ugb25seSBnZXQg Y2FsbGVkIGlmIGEgY29ubmVjdGlvbiB3YXMgZm91bmQsIHRlbGwgdGhlIGNhbGxlciB0bworCSAq IHdhaXQgZm9yIHRoZSBvdGhlciBkZXZpY2UgdG8gc2hvdyB1cC4KKwkgKi8KKwlyZXR1cm4gRVJS X1BUUigtRVBST0JFX0RFRkVSKTsKK30KKworLyoqCisgKiBkZXZpY2VfY29ubmVjdGlvbl9maW5k IC0gRmluZCB0d28gZGV2aWNlcyBjb25uZWN0ZWQgdG9nZXRoZXIKKyAqIEBkZXY6IERldmljZSB3 aXRoIHRoZSBjb25uZWN0aW9uCisgKiBAY29uX2lkOiBJZGVudGlmaWVyIGZvciB0aGUgY29ubmVj dGlvbgorICoKKyAqIEZpbmQgYSBjb25uZWN0aW9uIHdpdGggdW5pcXVlIGlkZW50aWZpZXIgQGNv bl9pZCBiZXR3ZWVuIEBkZXYgYW5kCisgKiBhbm90aGVyIGRldmljZS4gT24gc3VjY2VzcyByZXR1 cm5zIGhhbmRsZSB0byB0aGUgZGV2aWNlIHRoYXQgaXMgY29ubmVjdGVkCisgKiB0byBAZGV2LCB3 aXRoIHRoZSByZWZlcmVuY2UgY291bnQgZm9yIHRoZSBmb3VuZCBkZXZpY2UgaW5jcmVtZW50ZWQu IFJldHVybnMKKyAqIE5VTEwgaWYgbm8gbWF0Y2hpbmcgY29ubmVjdGlvbiB3YXMgZm91bmQsIG9y IEVSUl9QVFIoLUVQUk9CRV9ERUZFUikgd2hlbiBhCisgKiBjb25uZWN0aW9uIHdhcyBmb3VuZCBi dXQgdGhlIG90aGVyIGRldmljZSBoYXMgbm90IGJlZW4gZW51bWVyYXRlZCB5ZXQuCisgKi8KK3N0 cnVjdCBkZXZpY2UgKmRldmljZV9jb25uZWN0aW9uX2ZpbmQoc3RydWN0IGRldmljZSAqZGV2LCBj b25zdCBjaGFyICpjb25faWQpCit7CisJcmV0dXJuIGRldmljZV9jb25uZWN0aW9uX2ZpbmRfbWF0 Y2goZGV2LCBjb25faWQsIE5VTEwsIGdlbmVyaWNfbWF0Y2gpOworfQorRVhQT1JUX1NZTUJPTF9H UEwoZGV2aWNlX2Nvbm5lY3Rpb25fZmluZCk7CisKKy8qKgorICogZGV2aWNlX2Nvbm5lY3Rpb25f YWRkIC0gUmVnaXN0ZXIgYSBjb25uZWN0aW9uIGRlc2NyaXB0aW9uCisgKiBAY29uOiBUaGUgY29u bmVjdGlvbiBkZXNjcmlwdGlvbiB0byBiZSByZWdpc3RlcmVkCisgKi8KK3ZvaWQgZGV2aWNlX2Nv bm5lY3Rpb25fYWRkKHN0cnVjdCBkZXZpY2VfY29ubmVjdGlvbiAqY29uKQoreworCW11dGV4X2xv Y2soJmRldmNvbl9sb2NrKTsKKwlsaXN0X2FkZF90YWlsX3JjdSgmY29uLT5saXN0LCAmZGV2Y29u X2xpc3QpOworCW11dGV4X3VubG9jaygmZGV2Y29uX2xvY2spOworfQorRVhQT1JUX1NZTUJPTF9H UEwoZGV2aWNlX2Nvbm5lY3Rpb25fYWRkKTsKKworLyoqCisgKiBkZXZpY2VfY29ubmVjdGlvbnNf cmVtb3ZlIC0gVW5yZWdpc3RlciBjb25uZWN0aW9uIGRlc2NyaXB0aW9uCisgKiBAY29uOiBUaGUg Y29ubmVjdGlvbiBkZXNjcmlwdGlvbiB0byBiZSB1bnJlZ2lzdGVyZWQKKyAqLwordm9pZCBkZXZp Y2VfY29ubmVjdGlvbl9yZW1vdmUoc3RydWN0IGRldmljZV9jb25uZWN0aW9uICpjb24pCit7CisJ bXV0ZXhfbG9jaygmZGV2Y29uX2xvY2spOworCWxpc3RfZGVsX3JjdSgmY29uLT5saXN0KTsKKwlt dXRleF91bmxvY2soJmRldmNvbl9sb2NrKTsKKwkvKgorCSAqIFRoZSBjYWxsZXIgbWF5IGZyZWUg dGhlIGRldmljZV9jb25uZWN0aW9uIHN0cnVjdCBpbW1lZGlhdGVseQorCSAqIGFmdGVyd2FyZHMu CisJICovCisJc3luY2hyb25pemVfcmN1KCk7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChkZXZpY2Vf Y29ubmVjdGlvbl9yZW1vdmUpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kZXZpY2UuaCBi L2luY2x1ZGUvbGludXgvZGV2aWNlLmgKaW5kZXggYjA5MzQwNWVkNTI1Li5lZTk5MmYyZDQ3ZWQg MTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZGV2aWNlLmgKKysrIGIvaW5jbHVkZS9saW51eC9k ZXZpY2UuaApAQCAtNzI5LDYgKzcyOSwyOCBAQCBzdHJ1Y3QgZGV2aWNlX2RtYV9wYXJhbWV0ZXJz IHsKIAl1bnNpZ25lZCBsb25nIHNlZ21lbnRfYm91bmRhcnlfbWFzazsKIH07CiAKKy8qKgorICog c3RydWN0IGRldmljZV9jb25ubmVjdGlvbiAtIERldmljZSBDb25uZWN0aW9uIERlc2NyaXB0b3IK KyAqIEBlbmRwb2ludDogVGhlIG5hbWVzIG9mIHRoZSB0d28gZGV2aWNlcyBjb25uZWN0ZWQgdG9n ZXRoZXIKKyAqIEBpZDogVW5pcXVlIGlkZW50aWZpZXIgZm9yIHRoZSBjb25uZWN0aW9uCisgKiBA bGlzdDogTGlzdCBoZWFkLCBwcml2YXRlLCBmb3IgaW50ZXJuYWwgdXNlIG9ubHkKKyAqLworc3Ry dWN0IGRldmljZV9jb25uZWN0aW9uIHsKKwljb25zdCBjaGFyCQkqZW5kcG9pbnRbMl07CisJY29u c3QgY2hhcgkJKmlkOworCXN0cnVjdCBsaXN0X2hlYWQJbGlzdDsKK307CisKK3ZvaWQgKmRldmlj ZV9jb25uZWN0aW9uX2ZpbmRfbWF0Y2goc3RydWN0IGRldmljZSAqZGV2LCBjb25zdCBjaGFyICpj b25faWQsCisJCQkJdm9pZCAqZGF0YSwKKwkJCQl2b2lkICooKm1hdGNoKShzdHJ1Y3QgZGV2aWNl X2Nvbm5lY3Rpb24gKmNvbiwKKwkJCQkJICAgICAgIGludCBlcCwgdm9pZCAqZGF0YSkpOworCitz dHJ1Y3QgZGV2aWNlICpkZXZpY2VfY29ubmVjdGlvbl9maW5kKHN0cnVjdCBkZXZpY2UgKmRldiwg Y29uc3QgY2hhciAqY29uX2lkKTsKKwordm9pZCBkZXZpY2VfY29ubmVjdGlvbl9hZGQoc3RydWN0 IGRldmljZV9jb25uZWN0aW9uICpjb24pOwordm9pZCBkZXZpY2VfY29ubmVjdGlvbl9yZW1vdmUo c3RydWN0IGRldmljZV9jb25uZWN0aW9uICpjb24pOworCiAvKioKICAqIGVudW0gZGV2aWNlX2xp bmtfc3RhdGUgLSBEZXZpY2UgbGluayBzdGF0ZXMuCiAgKiBARExfU1RBVEVfTk9ORTogVGhlIHBy ZXNlbmNlIG9mIHRoZSBkcml2ZXJzIGlzIG5vdCBiZWluZyB0cmFja2VkLgo=