From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Google-Smtp-Source: AG47ELu6IsLm3mFN1ARhXHIQzKbDzeGYXUiFjZPemi5+ZrYRMwcM4ReFCFuzKetRyNdRfzP5MISH ARC-Seal: i=1; a=rsa-sha256; t=1520865283; cv=none; d=google.com; s=arc-20160816; b=esqEfzKEwkQVqIkLVpyz/lZPbWwwqZEU4VNFPFGdx1XwkLrQVfYTbpxX5RI/IuHAQW /rjABvYUnVAS3X/lByWVgRlcuLlxVMAQipJ2gjAcINSLpAsRZUdMHKzI09B7cScZTW9H mQDoh7KwCCTyjEqdxJR8pFMzYpiOS+4/8ndNcWOm0xI+PCvZBMkIqDn+SpOuc9T9jMS/ 6CI/K8YAeOl7QxIHmvi1N0Wxmlo1Zp2wupAlvMpeBmuKOQ2BSDIZew3+KEbR1gEeS4tW iJPPlP8o8pyHTBVobnl+yqI/jmW20+ppZtapUy6LihZfcPD8MfTKc7Np3iZ46TTJGnw3 szXg== 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=EuC9rYDbh+gPCc7elugWLtRRb9SDA6j/ylnzG5UQKCw=; b=pe9Pr49maL/AV+e2jBsTRGTH417OOB1aGdl+QqOHYrCu57ILCn9b71qvcvxUIOm3ek SeHj3JFT71FPTS5cAf3/988Ug/C1T3bABR/PJ7wnXL2h+q17wdNrhsnJfUz9ZoLIu2ZP 0hgdVWqqtGL7LnrvQeApQIdPvaOnft75zkzpb8bE6uBgSv/l3I7q1sHQF4JrWv1olDeB VtziQPvD8a+l63eFos4XoBFI6XV2X2XcaTMV2/KXPsTW/zzJwsKloyL9IoF3/HneX/cl d9Qt+LY3X2B4lKhV7vgUKvxFhrIazkmfUE2emKuAHKuq8RY9TQpGKDXlocA1Iiki91nJ LQ0Q== 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="37470787" 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 02/12] usb: typec: API for controlling USB Type-C Multiplexers Date: Mon, 12 Mar 2018 17:34:21 +0300 Message-Id: <20180312143431.82396-3-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?1594742835132228164?= X-GMAIL-MSGID: =?utf-8?q?1594742835132228164?= X-Mailing-List: linux-kernel@vger.kernel.org List-ID: USB Type-C connectors consist of various muxes and switches that route the pins on the connector to the right locations. The USB Type-C drivers need to be able to control the muxes, as they are the ones that know things like the cable plug orientation, and the current mode that was negotiated with the partner. This introduces a small API for registering and controlling cable plug orientation switches, and separate small API for registering and controlling pin multiplexer/demultiplexer switches that are needed with Accessory/Alternate Modes. Reviewed-by: Hans de Goede Reviewed-by: Andy Shevchenko Signed-off-by: Heikki Krogerus --- Changes in v4: -Add Andy's Reviewed-by Changes in v3: -Add #include-s for a few missing headers to drivers/usb/typec/mux.c -Various spelling and gramar fixes in the docs pointed out by Randy Dunlap --- Documentation/driver-api/usb/typec.rst | 73 +++++++++++-- drivers/usb/typec/Makefile | 1 + drivers/usb/typec/{typec.c => class.c} | 70 ++++++++++++ drivers/usb/typec/mux.c | 191 +++++++++++++++++++++++++++++++++ include/linux/usb/typec.h | 14 +++ include/linux/usb/typec_mux.h | 55 ++++++++++ 6 files changed, 393 insertions(+), 11 deletions(-) rename drivers/usb/typec/{typec.c => class.c} (95%) create mode 100644 drivers/usb/typec/mux.c create mode 100644 include/linux/usb/typec_mux.h diff --git a/Documentation/driver-api/usb/typec.rst b/Documentation/driver-api/usb/typec.rst index 8a7249f2ff04..feb31946490b 100644 --- a/Documentation/driver-api/usb/typec.rst +++ b/Documentation/driver-api/usb/typec.rst @@ -61,7 +61,7 @@ Registering the ports The port drivers will describe every Type-C port they control with struct typec_capability data structure, and register them with the following API: -.. kernel-doc:: drivers/usb/typec/typec.c +.. kernel-doc:: drivers/usb/typec/class.c :functions: typec_register_port typec_unregister_port When registering the ports, the prefer_role member in struct typec_capability @@ -80,7 +80,7 @@ typec_partner_desc. The class copies the details of the partner during registration. The class offers the following API for registering/unregistering partners. -.. kernel-doc:: drivers/usb/typec/typec.c +.. kernel-doc:: drivers/usb/typec/class.c :functions: typec_register_partner typec_unregister_partner The class will provide a handle to struct typec_partner if the registration was @@ -92,7 +92,7 @@ should include handle to struct usb_pd_identity instance. The class will then create a sysfs directory for the identity under the partner device. The result of Discover Identity command can then be reported with the following API: -.. kernel-doc:: drivers/usb/typec/typec.c +.. kernel-doc:: drivers/usb/typec/class.c :functions: typec_partner_set_identity Registering Cables @@ -113,7 +113,7 @@ typec_cable_desc and about a plug in struct typec_plug_desc. The class copies the details during registration. The class offers the following API for registering/unregistering cables and their plugs: -.. kernel-doc:: drivers/usb/typec/typec.c +.. kernel-doc:: drivers/usb/typec/class.c :functions: typec_register_cable typec_unregister_cable typec_register_plug typec_unregister_plug The class will provide a handle to struct typec_cable and struct typec_plug if @@ -125,7 +125,7 @@ include handle to struct usb_pd_identity instance. The class will then create a sysfs directory for the identity under the cable device. The result of Discover Identity command can then be reported with the following API: -.. kernel-doc:: drivers/usb/typec/typec.c +.. kernel-doc:: drivers/usb/typec/class.c :functions: typec_cable_set_identity Notifications @@ -135,7 +135,7 @@ When the partner has executed a role change, or when the default roles change during connection of a partner or cable, the port driver must use the following APIs to report it to the class: -.. kernel-doc:: drivers/usb/typec/typec.c +.. kernel-doc:: drivers/usb/typec/class.c :functions: typec_set_data_role typec_set_pwr_role typec_set_vconn_role typec_set_pwr_opmode Alternate Modes @@ -150,7 +150,7 @@ and struct typec_altmode_desc which is a container for all the supported modes. Ports that support Alternate Modes need to register each SVID they support with the following API: -.. kernel-doc:: drivers/usb/typec/typec.c +.. kernel-doc:: drivers/usb/typec/class.c :functions: typec_port_register_altmode If a partner or cable plug provides a list of SVIDs as response to USB Power @@ -159,12 +159,12 @@ registered. API for the partners: -.. kernel-doc:: drivers/usb/typec/typec.c +.. kernel-doc:: drivers/usb/typec/class.c :functions: typec_partner_register_altmode API for the Cable Plugs: -.. kernel-doc:: drivers/usb/typec/typec.c +.. kernel-doc:: drivers/usb/typec/class.c :functions: typec_plug_register_altmode So ports, partners and cable plugs will register the alternate modes with their @@ -172,11 +172,62 @@ own functions, but the registration will always return a handle to struct typec_altmode on success, or NULL. The unregistration will happen with the same function: -.. kernel-doc:: drivers/usb/typec/typec.c +.. kernel-doc:: drivers/usb/typec/class.c :functions: typec_unregister_altmode If a partner or cable plug enters or exits a mode, the port driver needs to notify the class with the following API: -.. kernel-doc:: drivers/usb/typec/typec.c +.. kernel-doc:: drivers/usb/typec/class.c :functions: typec_altmode_update_active + +Multiplexer/DeMultiplexer Switches +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +USB Type-C connectors may have one or more mux/demux switches behind them. Since +the plugs can be inserted right-side-up or upside-down, a switch is needed to +route the correct data pairs from the connector to the USB controllers. If +Alternate or Accessory Modes are supported, another switch is needed that can +route the pins on the connector to some other component besides USB. USB Type-C +Connector Class supplies an API for registering those switches. + +.. kernel-doc:: drivers/usb/typec/mux.c + :functions: typec_switch_register typec_switch_unregister typec_mux_register typec_mux_unregister + +In most cases the same physical mux will handle both the orientation and mode. +However, as the port drivers will be responsible for the orientation, and the +alternate mode drivers for the mode, the two are always separated into their +own logical components: "mux" for the mode and "switch" for the orientation. + +When a port is registered, USB Type-C Connector Class requests both the mux and +the switch for the port. The drivers can then use the following API for +controlling them: + +.. kernel-doc:: drivers/usb/typec/class.c + :functions: typec_set_orientation typec_set_mode + +If the connector is dual-role capable, there may also be a switch for the data +role. USB Type-C Connector Class does not supply separate API for them. The +port drivers can use USB Role Class API with those. + +Illustration of the muxes behind a connector that supports an alternate mode: + + ------------------------ + | Connector | + ------------------------ + | | + ------------------------ + \ Orientation / + -------------------- + | + -------------------- + / Mode \ + ------------------------ + / \ + ------------------------ -------------------- + | Alt Mode | / USB Role \ + ------------------------ ------------------------ + / \ + ------------------------ ------------------------ + | USB Host | | USB Device | + ------------------------ ------------------------ diff --git a/drivers/usb/typec/Makefile b/drivers/usb/typec/Makefile index bb3138a6eaac..56b2e9516ec1 100644 --- a/drivers/usb/typec/Makefile +++ b/drivers/usb/typec/Makefile @@ -1,5 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_TYPEC) += typec.o +typec-y := class.o mux.o obj-$(CONFIG_TYPEC_TCPM) += tcpm.o obj-y += fusb302/ obj-$(CONFIG_TYPEC_WCOVE) += typec_wcove.o diff --git a/drivers/usb/typec/typec.c b/drivers/usb/typec/class.c similarity index 95% rename from drivers/usb/typec/typec.c rename to drivers/usb/typec/class.c index dc28ad868d93..2620a694704f 100644 --- a/drivers/usb/typec/typec.c +++ b/drivers/usb/typec/class.c @@ -11,6 +11,7 @@ #include #include #include +#include struct typec_mode { int index; @@ -70,6 +71,10 @@ struct typec_port { enum typec_port_type port_type; struct mutex port_type_lock; + enum typec_orientation orientation; + struct typec_switch *sw; + struct typec_mux *mux; + const struct typec_capability *cap; }; @@ -92,6 +97,7 @@ static const struct device_type typec_port_dev_type; static DEFINE_IDA(typec_index_ida); static struct class *typec_class; +/* ------------------------------------------------------------------------- */ /* Common attributes */ static const char * const typec_accessory_modes[] = { @@ -1137,6 +1143,8 @@ static void typec_release(struct device *dev) struct typec_port *port = to_typec_port(dev); ida_simple_remove(&typec_index_ida, port->id); + typec_switch_put(port->sw); + typec_mux_put(port->mux); kfree(port); } @@ -1246,6 +1254,47 @@ void typec_set_pwr_opmode(struct typec_port *port, } EXPORT_SYMBOL_GPL(typec_set_pwr_opmode); +/* ------------------------------------------ */ +/* API for Multiplexer/DeMultiplexer Switches */ + +/** + * typec_set_orientation - Set USB Type-C cable plug orientation + * @port: USB Type-C Port + * @orientation: USB Type-C cable plug orientation + * + * Set cable plug orientation for @port. + */ +int typec_set_orientation(struct typec_port *port, + enum typec_orientation orientation) +{ + int ret; + + if (port->sw) { + ret = port->sw->set(port->sw, orientation); + if (ret) + return ret; + } + + port->orientation = orientation; + + return 0; +} +EXPORT_SYMBOL_GPL(typec_set_orientation); + +/** + * typec_set_mode - Set mode of operation for USB Type-C connector + * @port: USB Type-C port for the connector + * @mode: Operation mode for the connector + * + * Set mode @mode for @port. This function will configure the muxes needed to + * enter @mode. + */ +int typec_set_mode(struct typec_port *port, int mode) +{ + return port->mux ? port->mux->set(port->mux, mode) : 0; +} +EXPORT_SYMBOL_GPL(typec_set_mode); + /* --------------------------------------- */ /** @@ -1293,6 +1342,18 @@ struct typec_port *typec_register_port(struct device *parent, return ERR_PTR(id); } + port->sw = typec_switch_get(cap->fwnode ? &port->dev : parent); + if (IS_ERR(port->sw)) { + ret = PTR_ERR(port->sw); + goto err_switch; + } + + port->mux = typec_mux_get(cap->fwnode ? &port->dev : parent); + if (IS_ERR(port->mux)) { + ret = PTR_ERR(port->mux); + goto err_mux; + } + if (cap->type == TYPEC_PORT_DFP) role = TYPEC_SOURCE; else if (cap->type == TYPEC_PORT_UFP) @@ -1330,6 +1391,15 @@ struct typec_port *typec_register_port(struct device *parent, } return port; + +err_mux: + typec_switch_put(port->sw); + +err_switch: + ida_simple_remove(&typec_index_ida, port->id); + kfree(port); + + return ERR_PTR(ret); } EXPORT_SYMBOL_GPL(typec_register_port); diff --git a/drivers/usb/typec/mux.c b/drivers/usb/typec/mux.c new file mode 100644 index 000000000000..f89093bd7185 --- /dev/null +++ b/drivers/usb/typec/mux.c @@ -0,0 +1,191 @@ +// SPDX-License-Identifier: GPL-2.0 +/** + * USB Type-C Multiplexer/DeMultiplexer Switch support + * + * Copyright (C) 2018 Intel Corporation + * Author: Heikki Krogerus + * Hans de Goede + */ + +#include +#include +#include +#include + +static DEFINE_MUTEX(switch_lock); +static DEFINE_MUTEX(mux_lock); +static LIST_HEAD(switch_list); +static LIST_HEAD(mux_list); + +static void *typec_switch_match(struct device_connection *con, int ep, + void *data) +{ + struct typec_switch *sw; + + list_for_each_entry(sw, &switch_list, entry) + if (!strcmp(con->endpoint[ep], dev_name(sw->dev))) + return sw; + + /* + * We only get called if a connection was found, tell the caller to + * wait for the switch to show up. + */ + return ERR_PTR(-EPROBE_DEFER); +} + +/** + * typec_switch_get - Find USB Type-C orientation switch + * @dev: The caller device + * + * Finds a switch linked with @dev. Returns a reference to the switch on + * success, NULL if no matching connection was found, or + * ERR_PTR(-EPROBE_DEFER) when a connection was found but the switch + * has not been enumerated yet. + */ +struct typec_switch *typec_switch_get(struct device *dev) +{ + struct typec_switch *sw; + + mutex_lock(&switch_lock); + sw = device_connection_find_match(dev, "typec-switch", NULL, + typec_switch_match); + if (!IS_ERR_OR_NULL(sw)) + get_device(sw->dev); + mutex_unlock(&switch_lock); + + return sw; +} +EXPORT_SYMBOL_GPL(typec_switch_get); + +/** + * typec_put_switch - Release USB Type-C orientation switch + * @sw: USB Type-C orientation switch + * + * Decrement reference count for @sw. + */ +void typec_switch_put(struct typec_switch *sw) +{ + if (!IS_ERR_OR_NULL(sw)) + put_device(sw->dev); +} +EXPORT_SYMBOL_GPL(typec_switch_put); + +/** + * typec_switch_register - Register USB Type-C orientation switch + * @sw: USB Type-C orientation switch + * + * This function registers a switch that can be used for routing the correct + * data pairs depending on the cable plug orientation from the USB Type-C + * connector to the USB controllers. USB Type-C plugs can be inserted + * right-side-up or upside-down. + */ +int typec_switch_register(struct typec_switch *sw) +{ + mutex_lock(&switch_lock); + list_add_tail(&sw->entry, &switch_list); + mutex_unlock(&switch_lock); + + return 0; +} +EXPORT_SYMBOL_GPL(typec_switch_register); + +/** + * typec_switch_unregister - Unregister USB Type-C orientation switch + * @sw: USB Type-C orientation switch + * + * Unregister switch that was registered with typec_switch_register(). + */ +void typec_switch_unregister(struct typec_switch *sw) +{ + mutex_lock(&switch_lock); + list_del(&sw->entry); + mutex_unlock(&switch_lock); +} +EXPORT_SYMBOL_GPL(typec_switch_unregister); + +/* ------------------------------------------------------------------------- */ + +static void *typec_mux_match(struct device_connection *con, int ep, void *data) +{ + struct typec_mux *mux; + + list_for_each_entry(mux, &mux_list, entry) + if (!strcmp(con->endpoint[ep], dev_name(mux->dev))) + return mux; + + /* + * We only get called if a connection was found, tell the caller to + * wait for the switch to show up. + */ + return ERR_PTR(-EPROBE_DEFER); +} + +/** + * typec_mux_get - Find USB Type-C Multiplexer + * @dev: The caller device + * + * Finds a mux linked to the caller. This function is primarily meant for the + * Type-C drivers. Returns a reference to the mux on success, NULL if no + * matching connection was found, or ERR_PTR(-EPROBE_DEFER) when a connection + * was found but the mux has not been enumerated yet. + */ +struct typec_mux *typec_mux_get(struct device *dev) +{ + struct typec_mux *mux; + + mutex_lock(&mux_lock); + mux = device_connection_find_match(dev, "typec-mux", NULL, + typec_mux_match); + if (!IS_ERR_OR_NULL(mux)) + get_device(mux->dev); + mutex_unlock(&mux_lock); + + return mux; +} +EXPORT_SYMBOL_GPL(typec_mux_get); + +/** + * typec_mux_put - Release handle to a Multiplexer + * @mux: USB Type-C Connector Multiplexer/DeMultiplexer + * + * Decrements reference count for @mux. + */ +void typec_mux_put(struct typec_mux *mux) +{ + if (!IS_ERR_OR_NULL(mux)) + put_device(mux->dev); +} +EXPORT_SYMBOL_GPL(typec_mux_put); + +/** + * typec_mux_register - Register Multiplexer routing USB Type-C pins + * @mux: USB Type-C Connector Multiplexer/DeMultiplexer + * + * USB Type-C connectors can be used for alternate modes of operation besides + * USB when Accessory/Alternate Modes are supported. With some of those modes, + * the pins on the connector need to be reconfigured. This function registers + * multiplexer switches routing the pins on the connector. + */ +int typec_mux_register(struct typec_mux *mux) +{ + mutex_lock(&mux_lock); + list_add_tail(&mux->entry, &mux_list); + mutex_unlock(&mux_lock); + + return 0; +} +EXPORT_SYMBOL_GPL(typec_mux_register); + +/** + * typec_mux_unregister - Unregister Multiplexer Switch + * @sw: USB Type-C Connector Multiplexer/DeMultiplexer + * + * Unregister mux that was registered with typec_mux_register(). + */ +void typec_mux_unregister(struct typec_mux *mux) +{ + mutex_lock(&mux_lock); + list_del(&mux->entry); + mutex_unlock(&mux_lock); +} +EXPORT_SYMBOL_GPL(typec_mux_unregister); diff --git a/include/linux/usb/typec.h b/include/linux/usb/typec.h index 0d44ce6af08f..2408e5c2ed91 100644 --- a/include/linux/usb/typec.h +++ b/include/linux/usb/typec.h @@ -60,6 +60,12 @@ enum typec_accessory { #define TYPEC_MAX_ACCESSORY 3 +enum typec_orientation { + TYPEC_ORIENTATION_NONE, + TYPEC_ORIENTATION_NORMAL, + TYPEC_ORIENTATION_REVERSE, +}; + /* * struct usb_pd_identity - USB Power Delivery identity data * @id_header: ID Header VDO @@ -185,6 +191,8 @@ struct typec_partner_desc { * @pd_revision: USB Power Delivery Specification revision if supported * @prefer_role: Initial role preference * @accessory: Supported Accessory Modes + * @sw: Cable plug orientation switch + * @mux: Multiplexer switch for Alternate/Accessory Modes * @fwnode: Optional fwnode of the port * @try_role: Set data role preference for DRP port * @dr_set: Set Data Role @@ -202,6 +210,8 @@ struct typec_capability { int prefer_role; enum typec_accessory accessory[TYPEC_MAX_ACCESSORY]; + struct typec_switch *sw; + struct typec_mux *mux; struct fwnode_handle *fwnode; int (*try_role)(const struct typec_capability *, @@ -245,4 +255,8 @@ void typec_set_pwr_role(struct typec_port *port, enum typec_role role); void typec_set_vconn_role(struct typec_port *port, enum typec_role role); void typec_set_pwr_opmode(struct typec_port *port, enum typec_pwr_opmode mode); +int typec_set_orientation(struct typec_port *port, + enum typec_orientation orientation); +int typec_set_mode(struct typec_port *port, int mode); + #endif /* __LINUX_USB_TYPEC_H */ diff --git a/include/linux/usb/typec_mux.h b/include/linux/usb/typec_mux.h new file mode 100644 index 000000000000..12c1b057834b --- /dev/null +++ b/include/linux/usb/typec_mux.h @@ -0,0 +1,55 @@ +// SPDX-License-Identifier: GPL-2.0 + +#ifndef __USB_TYPEC_MUX +#define __USB_TYPEC_MUX + +#include +#include + +struct device; + +/** + * struct typec_switch - USB Type-C cable orientation switch + * @dev: Switch device + * @entry: List entry + * @set: Callback to the driver for setting the orientation + * + * USB Type-C pin flipper switch routing the correct data pairs from the + * connector to the USB controller depending on the orientation of the cable + * plug. + */ +struct typec_switch { + struct device *dev; + struct list_head entry; + + int (*set)(struct typec_switch *sw, enum typec_orientation orientation); +}; + +/** + * struct typec_switch - USB Type-C connector pin mux + * @dev: Mux device + * @entry: List entry + * @set: Callback to the driver for setting the state of the mux + * + * Pin Multiplexer/DeMultiplexer switch routing the USB Type-C connector pins to + * different components depending on the requested mode of operation. Used with + * Accessory/Alternate modes. + */ +struct typec_mux { + struct device *dev; + struct list_head entry; + + int (*set)(struct typec_mux *mux, int state); +}; + +struct typec_switch *typec_switch_get(struct device *dev); +void typec_switch_put(struct typec_switch *sw); +int typec_switch_register(struct typec_switch *sw); +void typec_switch_unregister(struct typec_switch *sw); + +struct typec_mux *typec_mux_get(struct device *dev); +void typec_mux_put(struct typec_mux *mux); +int typec_mux_register(struct typec_mux *mux); +void typec_mux_unregister(struct typec_mux *mux); + +#endif /* __USB_TYPEC_MUX */ -- 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,02/12] usb: typec: API for controlling USB Type-C Multiplexers From: Heikki Krogerus Message-Id: <20180312143431.82396-3-heikki.krogerus@linux.intel.com> Date: Mon, 12 Mar 2018 17:34:21 +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: VVNCIFR5cGUtQyBjb25uZWN0b3JzIGNvbnNpc3Qgb2YgdmFyaW91cyBtdXhlcyBhbmQgc3dpdGNo ZXMKdGhhdCByb3V0ZSB0aGUgcGlucyBvbiB0aGUgY29ubmVjdG9yIHRvIHRoZSByaWdodCBsb2Nh dGlvbnMuClRoZSBVU0IgVHlwZS1DIGRyaXZlcnMgbmVlZCB0byBiZSBhYmxlIHRvIGNvbnRyb2wg dGhlIG11eGVzLAphcyB0aGV5IGFyZSB0aGUgb25lcyB0aGF0IGtub3cgdGhpbmdzIGxpa2UgdGhl IGNhYmxlIHBsdWcKb3JpZW50YXRpb24sIGFuZCB0aGUgY3VycmVudCBtb2RlIHRoYXQgd2FzIG5l Z290aWF0ZWQgd2l0aAp0aGUgcGFydG5lci4KClRoaXMgaW50cm9kdWNlcyBhIHNtYWxsIEFQSSBm b3IgcmVnaXN0ZXJpbmcgYW5kIGNvbnRyb2xsaW5nCmNhYmxlIHBsdWcgb3JpZW50YXRpb24gc3dp dGNoZXMsIGFuZCBzZXBhcmF0ZSBzbWFsbCBBUEkgZm9yCnJlZ2lzdGVyaW5nIGFuZCBjb250cm9s bGluZyBwaW4gbXVsdGlwbGV4ZXIvZGVtdWx0aXBsZXhlcgpzd2l0Y2hlcyB0aGF0IGFyZSBuZWVk ZWQgd2l0aCBBY2Nlc3NvcnkvQWx0ZXJuYXRlIE1vZGVzLgoKUmV2aWV3ZWQtYnk6IEhhbnMgZGUg R29lZGUgPGhkZWdvZWRlQHJlZGhhdC5jb20+ClJldmlld2VkLWJ5OiBBbmR5IFNoZXZjaGVua28g PGFuZHkuc2hldmNoZW5rb0BnbWFpbC5jb20+ClNpZ25lZC1vZmYtYnk6IEhlaWtraSBLcm9nZXJ1 cyA8aGVpa2tpLmtyb2dlcnVzQGxpbnV4LmludGVsLmNvbT4KLS0tCkNoYW5nZXMgaW4gdjQ6Ci1B ZGQgQW5keSdzIFJldmlld2VkLWJ5CgpDaGFuZ2VzIGluIHYzOgotQWRkICNpbmNsdWRlLXMgZm9y IGEgZmV3IG1pc3NpbmcgaGVhZGVycyB0byBkcml2ZXJzL3VzYi90eXBlYy9tdXguYwotVmFyaW91 cyBzcGVsbGluZyBhbmQgZ3JhbWFyIGZpeGVzIGluIHRoZSBkb2NzIHBvaW50ZWQgb3V0IGJ5IFJh bmR5IER1bmxhcAotLS0KIERvY3VtZW50YXRpb24vZHJpdmVyLWFwaS91c2IvdHlwZWMucnN0IHwg IDczICsrKysrKysrKysrLS0KIGRyaXZlcnMvdXNiL3R5cGVjL01ha2VmaWxlICAgICAgICAgICAg IHwgICAxICsKIGRyaXZlcnMvdXNiL3R5cGVjL3t0eXBlYy5jID0+IGNsYXNzLmN9IHwgIDcwICsr KysrKysrKysrKwogZHJpdmVycy91c2IvdHlwZWMvbXV4LmMgICAgICAgICAgICAgICAgfCAxOTEg KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBpbmNsdWRlL2xpbnV4L3VzYi90eXBl Yy5oICAgICAgICAgICAgICB8ICAxNCArKysKIGluY2x1ZGUvbGludXgvdXNiL3R5cGVjX211eC5o ICAgICAgICAgIHwgIDU1ICsrKysrKysrKysKIDYgZmlsZXMgY2hhbmdlZCwgMzkzIGluc2VydGlv bnMoKyksIDExIGRlbGV0aW9ucygtKQogcmVuYW1lIGRyaXZlcnMvdXNiL3R5cGVjL3t0eXBlYy5j ID0+IGNsYXNzLmN9ICg5NSUpCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy91c2IvdHlwZWMv bXV4LmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2xpbnV4L3VzYi90eXBlY19tdXguaAoK ZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS91c2IvdHlwZWMucnN0IGIvRG9j dW1lbnRhdGlvbi9kcml2ZXItYXBpL3VzYi90eXBlYy5yc3QKaW5kZXggOGE3MjQ5ZjJmZjA0Li5m ZWIzMTk0NjQ5MGIgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS91c2IvdHlw ZWMucnN0CisrKyBiL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS91c2IvdHlwZWMucnN0CkBAIC02 MSw3ICs2MSw3IEBAIFJlZ2lzdGVyaW5nIHRoZSBwb3J0cwogVGhlIHBvcnQgZHJpdmVycyB3aWxs IGRlc2NyaWJlIGV2ZXJ5IFR5cGUtQyBwb3J0IHRoZXkgY29udHJvbCB3aXRoIHN0cnVjdAogdHlw ZWNfY2FwYWJpbGl0eSBkYXRhIHN0cnVjdHVyZSwgYW5kIHJlZ2lzdGVyIHRoZW0gd2l0aCB0aGUg Zm9sbG93aW5nIEFQSToKIAotLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvdXNiL3R5cGVjL3R5cGVj LmMKKy4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL3VzYi90eXBlYy9jbGFzcy5jCiAgICA6ZnVuY3Rp b25zOiB0eXBlY19yZWdpc3Rlcl9wb3J0IHR5cGVjX3VucmVnaXN0ZXJfcG9ydAogCiBXaGVuIHJl Z2lzdGVyaW5nIHRoZSBwb3J0cywgdGhlIHByZWZlcl9yb2xlIG1lbWJlciBpbiBzdHJ1Y3QgdHlw ZWNfY2FwYWJpbGl0eQpAQCAtODAsNyArODAsNyBAQCB0eXBlY19wYXJ0bmVyX2Rlc2MuIFRoZSBj bGFzcyBjb3BpZXMgdGhlIGRldGFpbHMgb2YgdGhlIHBhcnRuZXIgZHVyaW5nCiByZWdpc3RyYXRp b24uIFRoZSBjbGFzcyBvZmZlcnMgdGhlIGZvbGxvd2luZyBBUEkgZm9yIHJlZ2lzdGVyaW5nL3Vu cmVnaXN0ZXJpbmcKIHBhcnRuZXJzLgogCi0uLiBrZXJuZWwtZG9jOjogZHJpdmVycy91c2IvdHlw ZWMvdHlwZWMuYworLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvdXNiL3R5cGVjL2NsYXNzLmMKICAg IDpmdW5jdGlvbnM6IHR5cGVjX3JlZ2lzdGVyX3BhcnRuZXIgdHlwZWNfdW5yZWdpc3Rlcl9wYXJ0 bmVyCiAKIFRoZSBjbGFzcyB3aWxsIHByb3ZpZGUgYSBoYW5kbGUgdG8gc3RydWN0IHR5cGVjX3Bh cnRuZXIgaWYgdGhlIHJlZ2lzdHJhdGlvbiB3YXMKQEAgLTkyLDcgKzkyLDcgQEAgc2hvdWxkIGlu Y2x1ZGUgaGFuZGxlIHRvIHN0cnVjdCB1c2JfcGRfaWRlbnRpdHkgaW5zdGFuY2UuIFRoZSBjbGFz cyB3aWxsIHRoZW4KIGNyZWF0ZSBhIHN5c2ZzIGRpcmVjdG9yeSBmb3IgdGhlIGlkZW50aXR5IHVu ZGVyIHRoZSBwYXJ0bmVyIGRldmljZS4gVGhlIHJlc3VsdAogb2YgRGlzY292ZXIgSWRlbnRpdHkg Y29tbWFuZCBjYW4gdGhlbiBiZSByZXBvcnRlZCB3aXRoIHRoZSBmb2xsb3dpbmcgQVBJOgogCi0u LiBrZXJuZWwtZG9jOjogZHJpdmVycy91c2IvdHlwZWMvdHlwZWMuYworLi4ga2VybmVsLWRvYzo6 IGRyaXZlcnMvdXNiL3R5cGVjL2NsYXNzLmMKICAgIDpmdW5jdGlvbnM6IHR5cGVjX3BhcnRuZXJf c2V0X2lkZW50aXR5CiAKIFJlZ2lzdGVyaW5nIENhYmxlcwpAQCAtMTEzLDcgKzExMyw3IEBAIHR5 cGVjX2NhYmxlX2Rlc2MgYW5kIGFib3V0IGEgcGx1ZyBpbiBzdHJ1Y3QgdHlwZWNfcGx1Z19kZXNj LiBUaGUgY2xhc3MgY29waWVzCiB0aGUgZGV0YWlscyBkdXJpbmcgcmVnaXN0cmF0aW9uLiBUaGUg Y2xhc3Mgb2ZmZXJzIHRoZSBmb2xsb3dpbmcgQVBJIGZvcgogcmVnaXN0ZXJpbmcvdW5yZWdpc3Rl cmluZyBjYWJsZXMgYW5kIHRoZWlyIHBsdWdzOgogCi0uLiBrZXJuZWwtZG9jOjogZHJpdmVycy91 c2IvdHlwZWMvdHlwZWMuYworLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvdXNiL3R5cGVjL2NsYXNz LmMKICAgIDpmdW5jdGlvbnM6IHR5cGVjX3JlZ2lzdGVyX2NhYmxlIHR5cGVjX3VucmVnaXN0ZXJf Y2FibGUgdHlwZWNfcmVnaXN0ZXJfcGx1ZyB0eXBlY191bnJlZ2lzdGVyX3BsdWcKIAogVGhlIGNs YXNzIHdpbGwgcHJvdmlkZSBhIGhhbmRsZSB0byBzdHJ1Y3QgdHlwZWNfY2FibGUgYW5kIHN0cnVj dCB0eXBlY19wbHVnIGlmCkBAIC0xMjUsNyArMTI1LDcgQEAgaW5jbHVkZSBoYW5kbGUgdG8gc3Ry dWN0IHVzYl9wZF9pZGVudGl0eSBpbnN0YW5jZS4gVGhlIGNsYXNzIHdpbGwgdGhlbiBjcmVhdGUg YQogc3lzZnMgZGlyZWN0b3J5IGZvciB0aGUgaWRlbnRpdHkgdW5kZXIgdGhlIGNhYmxlIGRldmlj ZS4gVGhlIHJlc3VsdCBvZiBEaXNjb3ZlcgogSWRlbnRpdHkgY29tbWFuZCBjYW4gdGhlbiBiZSBy ZXBvcnRlZCB3aXRoIHRoZSBmb2xsb3dpbmcgQVBJOgogCi0uLiBrZXJuZWwtZG9jOjogZHJpdmVy cy91c2IvdHlwZWMvdHlwZWMuYworLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvdXNiL3R5cGVjL2Ns YXNzLmMKICAgIDpmdW5jdGlvbnM6IHR5cGVjX2NhYmxlX3NldF9pZGVudGl0eQogCiBOb3RpZmlj YXRpb25zCkBAIC0xMzUsNyArMTM1LDcgQEAgV2hlbiB0aGUgcGFydG5lciBoYXMgZXhlY3V0ZWQg YSByb2xlIGNoYW5nZSwgb3Igd2hlbiB0aGUgZGVmYXVsdCByb2xlcyBjaGFuZ2UKIGR1cmluZyBj b25uZWN0aW9uIG9mIGEgcGFydG5lciBvciBjYWJsZSwgdGhlIHBvcnQgZHJpdmVyIG11c3QgdXNl IHRoZSBmb2xsb3dpbmcKIEFQSXMgdG8gcmVwb3J0IGl0IHRvIHRoZSBjbGFzczoKIAotLi4ga2Vy bmVsLWRvYzo6IGRyaXZlcnMvdXNiL3R5cGVjL3R5cGVjLmMKKy4uIGtlcm5lbC1kb2M6OiBkcml2 ZXJzL3VzYi90eXBlYy9jbGFzcy5jCiAgICA6ZnVuY3Rpb25zOiB0eXBlY19zZXRfZGF0YV9yb2xl IHR5cGVjX3NldF9wd3Jfcm9sZSB0eXBlY19zZXRfdmNvbm5fcm9sZSB0eXBlY19zZXRfcHdyX29w bW9kZQogCiBBbHRlcm5hdGUgTW9kZXMKQEAgLTE1MCw3ICsxNTAsNyBAQCBhbmQgc3RydWN0IHR5 cGVjX2FsdG1vZGVfZGVzYyB3aGljaCBpcyBhIGNvbnRhaW5lciBmb3IgYWxsIHRoZSBzdXBwb3J0 ZWQgbW9kZXMuCiBQb3J0cyB0aGF0IHN1cHBvcnQgQWx0ZXJuYXRlIE1vZGVzIG5lZWQgdG8gcmVn aXN0ZXIgZWFjaCBTVklEIHRoZXkgc3VwcG9ydCB3aXRoCiB0aGUgZm9sbG93aW5nIEFQSToKIAot Li4ga2VybmVsLWRvYzo6IGRyaXZlcnMvdXNiL3R5cGVjL3R5cGVjLmMKKy4uIGtlcm5lbC1kb2M6 OiBkcml2ZXJzL3VzYi90eXBlYy9jbGFzcy5jCiAgICA6ZnVuY3Rpb25zOiB0eXBlY19wb3J0X3Jl Z2lzdGVyX2FsdG1vZGUKIAogSWYgYSBwYXJ0bmVyIG9yIGNhYmxlIHBsdWcgcHJvdmlkZXMgYSBs aXN0IG9mIFNWSURzIGFzIHJlc3BvbnNlIHRvIFVTQiBQb3dlcgpAQCAtMTU5LDEyICsxNTksMTIg QEAgcmVnaXN0ZXJlZC4KIAogQVBJIGZvciB0aGUgcGFydG5lcnM6CiAKLS4uIGtlcm5lbC1kb2M6 OiBkcml2ZXJzL3VzYi90eXBlYy90eXBlYy5jCisuLiBrZXJuZWwtZG9jOjogZHJpdmVycy91c2Iv dHlwZWMvY2xhc3MuYwogICAgOmZ1bmN0aW9uczogdHlwZWNfcGFydG5lcl9yZWdpc3Rlcl9hbHRt b2RlCiAKIEFQSSBmb3IgdGhlIENhYmxlIFBsdWdzOgogCi0uLiBrZXJuZWwtZG9jOjogZHJpdmVy cy91c2IvdHlwZWMvdHlwZWMuYworLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvdXNiL3R5cGVjL2Ns YXNzLmMKICAgIDpmdW5jdGlvbnM6IHR5cGVjX3BsdWdfcmVnaXN0ZXJfYWx0bW9kZQogCiBTbyBw b3J0cywgcGFydG5lcnMgYW5kIGNhYmxlIHBsdWdzIHdpbGwgcmVnaXN0ZXIgdGhlIGFsdGVybmF0 ZSBtb2RlcyB3aXRoIHRoZWlyCkBAIC0xNzIsMTEgKzE3Miw2MiBAQCBvd24gZnVuY3Rpb25zLCBi dXQgdGhlIHJlZ2lzdHJhdGlvbiB3aWxsIGFsd2F5cyByZXR1cm4gYSBoYW5kbGUgdG8gc3RydWN0 CiB0eXBlY19hbHRtb2RlIG9uIHN1Y2Nlc3MsIG9yIE5VTEwuIFRoZSB1bnJlZ2lzdHJhdGlvbiB3 aWxsIGhhcHBlbiB3aXRoIHRoZSBzYW1lCiBmdW5jdGlvbjoKIAotLi4ga2VybmVsLWRvYzo6IGRy aXZlcnMvdXNiL3R5cGVjL3R5cGVjLmMKKy4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL3VzYi90eXBl Yy9jbGFzcy5jCiAgICA6ZnVuY3Rpb25zOiB0eXBlY191bnJlZ2lzdGVyX2FsdG1vZGUKIAogSWYg YSBwYXJ0bmVyIG9yIGNhYmxlIHBsdWcgZW50ZXJzIG9yIGV4aXRzIGEgbW9kZSwgdGhlIHBvcnQg ZHJpdmVyIG5lZWRzIHRvCiBub3RpZnkgdGhlIGNsYXNzIHdpdGggdGhlIGZvbGxvd2luZyBBUEk6 CiAKLS4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL3VzYi90eXBlYy90eXBlYy5jCisuLiBrZXJuZWwt ZG9jOjogZHJpdmVycy91c2IvdHlwZWMvY2xhc3MuYwogICAgOmZ1bmN0aW9uczogdHlwZWNfYWx0 bW9kZV91cGRhdGVfYWN0aXZlCisKK011bHRpcGxleGVyL0RlTXVsdGlwbGV4ZXIgU3dpdGNoZXMK K35+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKworVVNCIFR5cGUtQyBjb25uZWN0 b3JzIG1heSBoYXZlIG9uZSBvciBtb3JlIG11eC9kZW11eCBzd2l0Y2hlcyBiZWhpbmQgdGhlbS4g U2luY2UKK3RoZSBwbHVncyBjYW4gYmUgaW5zZXJ0ZWQgcmlnaHQtc2lkZS11cCBvciB1cHNpZGUt ZG93biwgYSBzd2l0Y2ggaXMgbmVlZGVkIHRvCityb3V0ZSB0aGUgY29ycmVjdCBkYXRhIHBhaXJz IGZyb20gdGhlIGNvbm5lY3RvciB0byB0aGUgVVNCIGNvbnRyb2xsZXJzLiBJZgorQWx0ZXJuYXRl IG9yIEFjY2Vzc29yeSBNb2RlcyBhcmUgc3VwcG9ydGVkLCBhbm90aGVyIHN3aXRjaCBpcyBuZWVk ZWQgdGhhdCBjYW4KK3JvdXRlIHRoZSBwaW5zIG9uIHRoZSBjb25uZWN0b3IgdG8gc29tZSBvdGhl ciBjb21wb25lbnQgYmVzaWRlcyBVU0IuIFVTQiBUeXBlLUMKK0Nvbm5lY3RvciBDbGFzcyBzdXBw bGllcyBhbiBBUEkgZm9yIHJlZ2lzdGVyaW5nIHRob3NlIHN3aXRjaGVzLgorCisuLiBrZXJuZWwt ZG9jOjogZHJpdmVycy91c2IvdHlwZWMvbXV4LmMKKyAgIDpmdW5jdGlvbnM6IHR5cGVjX3N3aXRj aF9yZWdpc3RlciB0eXBlY19zd2l0Y2hfdW5yZWdpc3RlciB0eXBlY19tdXhfcmVnaXN0ZXIgdHlw ZWNfbXV4X3VucmVnaXN0ZXIKKworSW4gbW9zdCBjYXNlcyB0aGUgc2FtZSBwaHlzaWNhbCBtdXgg d2lsbCBoYW5kbGUgYm90aCB0aGUgb3JpZW50YXRpb24gYW5kIG1vZGUuCitIb3dldmVyLCBhcyB0 aGUgcG9ydCBkcml2ZXJzIHdpbGwgYmUgcmVzcG9uc2libGUgZm9yIHRoZSBvcmllbnRhdGlvbiwg YW5kIHRoZQorYWx0ZXJuYXRlIG1vZGUgZHJpdmVycyBmb3IgdGhlIG1vZGUsIHRoZSB0d28gYXJl IGFsd2F5cyBzZXBhcmF0ZWQgaW50byB0aGVpcgorb3duIGxvZ2ljYWwgY29tcG9uZW50czogIm11 eCIgZm9yIHRoZSBtb2RlIGFuZCAic3dpdGNoIiBmb3IgdGhlIG9yaWVudGF0aW9uLgorCitXaGVu IGEgcG9ydCBpcyByZWdpc3RlcmVkLCBVU0IgVHlwZS1DIENvbm5lY3RvciBDbGFzcyByZXF1ZXN0 cyBib3RoIHRoZSBtdXggYW5kCit0aGUgc3dpdGNoIGZvciB0aGUgcG9ydC4gVGhlIGRyaXZlcnMg Y2FuIHRoZW4gdXNlIHRoZSBmb2xsb3dpbmcgQVBJIGZvcgorY29udHJvbGxpbmcgdGhlbToKKwor Li4ga2VybmVsLWRvYzo6IGRyaXZlcnMvdXNiL3R5cGVjL2NsYXNzLmMKKyAgIDpmdW5jdGlvbnM6 IHR5cGVjX3NldF9vcmllbnRhdGlvbiB0eXBlY19zZXRfbW9kZQorCitJZiB0aGUgY29ubmVjdG9y IGlzIGR1YWwtcm9sZSBjYXBhYmxlLCB0aGVyZSBtYXkgYWxzbyBiZSBhIHN3aXRjaCBmb3IgdGhl IGRhdGEKK3JvbGUuIFVTQiBUeXBlLUMgQ29ubmVjdG9yIENsYXNzIGRvZXMgbm90IHN1cHBseSBz ZXBhcmF0ZSBBUEkgZm9yIHRoZW0uIFRoZQorcG9ydCBkcml2ZXJzIGNhbiB1c2UgVVNCIFJvbGUg Q2xhc3MgQVBJIHdpdGggdGhvc2UuCisKK0lsbHVzdHJhdGlvbiBvZiB0aGUgbXV4ZXMgYmVoaW5k IGEgY29ubmVjdG9yIHRoYXQgc3VwcG9ydHMgYW4gYWx0ZXJuYXRlIG1vZGU6CisKKyAgICAgICAg ICAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICAgICAgICAgICAgICAgICAg ICAgfCAgICAgICBDb25uZWN0b3IgICAgICB8CisgICAgICAgICAgICAgICAgICAgICAtLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgICAgICAg fAorICAgICAgICAgICAgICAgICAgICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgICAgICAg ICAgICAgICAgICAgICAgXCAgICAgT3JpZW50YXRpb24gICAgLworICAgICAgICAgICAgICAgICAg ICAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB8CisgICAgICAgICAgICAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tCisgICAgICAg ICAgICAgICAgICAgICAgLyAgICAgICAgTW9kZSAgICAgICAgXAorICAgICAgICAgICAgICAgICAg ICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgICAgICAgICAgICAgICAgICAgICAgICAgLyAg ICAgICAgICAgICAgXAorICAgICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICAgICAgICAtLS0t LS0tLS0tLS0tLS0tLS0tLQorICAgICAgfCAgICAgICBBbHQgTW9kZSAgICAgICB8ICAgICAgIC8g ICAgICBVU0IgUm9sZSAgICAgIFwKKyAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAgICAg IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAvICAgICAgICAgICAgXAorICAgICAgICAgICAgICAgICAgICAgLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tICAgICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgICAgICAgICAg ICAgICAgICAgICB8ICAgICAgIFVTQiBIb3N0ICAgICAgIHwgICAgICB8ICAgICAgIFVTQiBEZXZp Y2UgICAgIHwKKyAgICAgICAgICAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAg ICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvdHlw ZWMvTWFrZWZpbGUgYi9kcml2ZXJzL3VzYi90eXBlYy9NYWtlZmlsZQppbmRleCBiYjMxMzhhNmVh YWMuLjU2YjJlOTUxNmVjMSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvdHlwZWMvTWFrZWZpbGUK KysrIGIvZHJpdmVycy91c2IvdHlwZWMvTWFrZWZpbGUKQEAgLTEsNSArMSw2IEBACiAjIFNQRFgt TGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCiBvYmotJChDT05GSUdfVFlQRUMpCQkrPSB0eXBl Yy5vCit0eXBlYy15CQkJCTo9IGNsYXNzLm8gbXV4Lm8KIG9iai0kKENPTkZJR19UWVBFQ19UQ1BN KQkrPSB0Y3BtLm8KIG9iai15CQkJCSs9IGZ1c2IzMDIvCiBvYmotJChDT05GSUdfVFlQRUNfV0NP VkUpCSs9IHR5cGVjX3djb3ZlLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3R5cGVjL3R5cGVj LmMgYi9kcml2ZXJzL3VzYi90eXBlYy9jbGFzcy5jCnNpbWlsYXJpdHkgaW5kZXggOTUlCnJlbmFt ZSBmcm9tIGRyaXZlcnMvdXNiL3R5cGVjL3R5cGVjLmMKcmVuYW1lIHRvIGRyaXZlcnMvdXNiL3R5 cGVjL2NsYXNzLmMKaW5kZXggZGMyOGFkODY4ZDkzLi4yNjIwYTY5NDcwNGYgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvdXNiL3R5cGVjL3R5cGVjLmMKKysrIGIvZHJpdmVycy91c2IvdHlwZWMvY2xhc3Mu YwpAQCAtMTEsNiArMTEsNyBAQAogI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+CiAjaW5jbHVkZSA8 bGludXgvc2xhYi5oPgogI2luY2x1ZGUgPGxpbnV4L3VzYi90eXBlYy5oPgorI2luY2x1ZGUgPGxp bnV4L3VzYi90eXBlY19tdXguaD4KIAogc3RydWN0IHR5cGVjX21vZGUgewogCWludAkJCQlpbmRl eDsKQEAgLTcwLDYgKzcxLDEwIEBAIHN0cnVjdCB0eXBlY19wb3J0IHsKIAllbnVtIHR5cGVjX3Bv cnRfdHlwZQkJcG9ydF90eXBlOwogCXN0cnVjdCBtdXRleAkJCXBvcnRfdHlwZV9sb2NrOwogCisJ ZW51bSB0eXBlY19vcmllbnRhdGlvbgkJb3JpZW50YXRpb247CisJc3RydWN0IHR5cGVjX3N3aXRj aAkJKnN3OworCXN0cnVjdCB0eXBlY19tdXgJCSptdXg7CisKIAljb25zdCBzdHJ1Y3QgdHlwZWNf Y2FwYWJpbGl0eQkqY2FwOwogfTsKIApAQCAtOTIsNiArOTcsNyBAQCBzdGF0aWMgY29uc3Qgc3Ry dWN0IGRldmljZV90eXBlIHR5cGVjX3BvcnRfZGV2X3R5cGU7CiBzdGF0aWMgREVGSU5FX0lEQSh0 eXBlY19pbmRleF9pZGEpOwogc3RhdGljIHN0cnVjdCBjbGFzcyAqdHlwZWNfY2xhc3M7CiAKKy8q IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0gKi8KIC8qIENvbW1vbiBhdHRyaWJ1dGVzICovCiAKIHN0YXRpYyBj b25zdCBjaGFyICogY29uc3QgdHlwZWNfYWNjZXNzb3J5X21vZGVzW10gPSB7CkBAIC0xMTM3LDYg KzExNDMsOCBAQCBzdGF0aWMgdm9pZCB0eXBlY19yZWxlYXNlKHN0cnVjdCBkZXZpY2UgKmRldikK IAlzdHJ1Y3QgdHlwZWNfcG9ydCAqcG9ydCA9IHRvX3R5cGVjX3BvcnQoZGV2KTsKIAogCWlkYV9z aW1wbGVfcmVtb3ZlKCZ0eXBlY19pbmRleF9pZGEsIHBvcnQtPmlkKTsKKwl0eXBlY19zd2l0Y2hf cHV0KHBvcnQtPnN3KTsKKwl0eXBlY19tdXhfcHV0KHBvcnQtPm11eCk7CiAJa2ZyZWUocG9ydCk7 CiB9CiAKQEAgLTEyNDYsNiArMTI1NCw0NyBAQCB2b2lkIHR5cGVjX3NldF9wd3Jfb3Btb2RlKHN0 cnVjdCB0eXBlY19wb3J0ICpwb3J0LAogfQogRVhQT1JUX1NZTUJPTF9HUEwodHlwZWNfc2V0X3B3 cl9vcG1vZGUpOwogCisvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0gKi8KKy8qIEFQSSBmb3IgTXVsdGlwbGV4ZXIvRGVNdWx0aXBsZXhlciBTd2l0Y2hlcyAqLwor CisvKioKKyAqIHR5cGVjX3NldF9vcmllbnRhdGlvbiAtIFNldCBVU0IgVHlwZS1DIGNhYmxlIHBs dWcgb3JpZW50YXRpb24KKyAqIEBwb3J0OiBVU0IgVHlwZS1DIFBvcnQKKyAqIEBvcmllbnRhdGlv bjogVVNCIFR5cGUtQyBjYWJsZSBwbHVnIG9yaWVudGF0aW9uCisgKgorICogU2V0IGNhYmxlIHBs dWcgb3JpZW50YXRpb24gZm9yIEBwb3J0LgorICovCitpbnQgdHlwZWNfc2V0X29yaWVudGF0aW9u KHN0cnVjdCB0eXBlY19wb3J0ICpwb3J0LAorCQkJICBlbnVtIHR5cGVjX29yaWVudGF0aW9uIG9y aWVudGF0aW9uKQoreworCWludCByZXQ7CisKKwlpZiAocG9ydC0+c3cpIHsKKwkJcmV0ID0gcG9y dC0+c3ctPnNldChwb3J0LT5zdywgb3JpZW50YXRpb24pOworCQlpZiAocmV0KQorCQkJcmV0dXJu IHJldDsKKwl9CisKKwlwb3J0LT5vcmllbnRhdGlvbiA9IG9yaWVudGF0aW9uOworCisJcmV0dXJu IDA7Cit9CitFWFBPUlRfU1lNQk9MX0dQTCh0eXBlY19zZXRfb3JpZW50YXRpb24pOworCisvKioK KyAqIHR5cGVjX3NldF9tb2RlIC0gU2V0IG1vZGUgb2Ygb3BlcmF0aW9uIGZvciBVU0IgVHlwZS1D IGNvbm5lY3RvcgorICogQHBvcnQ6IFVTQiBUeXBlLUMgcG9ydCBmb3IgdGhlIGNvbm5lY3Rvcgor ICogQG1vZGU6IE9wZXJhdGlvbiBtb2RlIGZvciB0aGUgY29ubmVjdG9yCisgKgorICogU2V0IG1v ZGUgQG1vZGUgZm9yIEBwb3J0LiBUaGlzIGZ1bmN0aW9uIHdpbGwgY29uZmlndXJlIHRoZSBtdXhl cyBuZWVkZWQgdG8KKyAqIGVudGVyIEBtb2RlLgorICovCitpbnQgdHlwZWNfc2V0X21vZGUoc3Ry dWN0IHR5cGVjX3BvcnQgKnBvcnQsIGludCBtb2RlKQoreworCXJldHVybiBwb3J0LT5tdXggPyBw b3J0LT5tdXgtPnNldChwb3J0LT5tdXgsIG1vZGUpIDogMDsKK30KK0VYUE9SVF9TWU1CT0xfR1BM KHR5cGVjX3NldF9tb2RlKTsKKwogLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tICovCiAKIC8qKgpAQCAtMTI5Myw2ICsxMzQyLDE4IEBAIHN0cnVjdCB0eXBlY19wb3J0 ICp0eXBlY19yZWdpc3Rlcl9wb3J0KHN0cnVjdCBkZXZpY2UgKnBhcmVudCwKIAkJcmV0dXJuIEVS Ul9QVFIoaWQpOwogCX0KIAorCXBvcnQtPnN3ID0gdHlwZWNfc3dpdGNoX2dldChjYXAtPmZ3bm9k ZSA/ICZwb3J0LT5kZXYgOiBwYXJlbnQpOworCWlmIChJU19FUlIocG9ydC0+c3cpKSB7CisJCXJl dCA9IFBUUl9FUlIocG9ydC0+c3cpOworCQlnb3RvIGVycl9zd2l0Y2g7CisJfQorCisJcG9ydC0+ bXV4ID0gdHlwZWNfbXV4X2dldChjYXAtPmZ3bm9kZSA/ICZwb3J0LT5kZXYgOiBwYXJlbnQpOwor CWlmIChJU19FUlIocG9ydC0+bXV4KSkgeworCQlyZXQgPSBQVFJfRVJSKHBvcnQtPm11eCk7CisJ CWdvdG8gZXJyX211eDsKKwl9CisKIAlpZiAoY2FwLT50eXBlID09IFRZUEVDX1BPUlRfREZQKQog CQlyb2xlID0gVFlQRUNfU09VUkNFOwogCWVsc2UgaWYgKGNhcC0+dHlwZSA9PSBUWVBFQ19QT1JU X1VGUCkKQEAgLTEzMzAsNiArMTM5MSwxNSBAQCBzdHJ1Y3QgdHlwZWNfcG9ydCAqdHlwZWNfcmVn aXN0ZXJfcG9ydChzdHJ1Y3QgZGV2aWNlICpwYXJlbnQsCiAJfQogCiAJcmV0dXJuIHBvcnQ7CisK K2Vycl9tdXg6CisJdHlwZWNfc3dpdGNoX3B1dChwb3J0LT5zdyk7CisKK2Vycl9zd2l0Y2g6CisJ aWRhX3NpbXBsZV9yZW1vdmUoJnR5cGVjX2luZGV4X2lkYSwgcG9ydC0+aWQpOworCWtmcmVlKHBv cnQpOworCisJcmV0dXJuIEVSUl9QVFIocmV0KTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKHR5cGVj X3JlZ2lzdGVyX3BvcnQpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi90eXBlYy9tdXguYyBi L2RyaXZlcnMvdXNiL3R5cGVjL211eC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMC4uZjg5MDkzYmQ3MTg1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy91c2IvdHlw ZWMvbXV4LmMKQEAgLTAsMCArMSwxOTEgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBH UEwtMi4wCisvKioKKyAqIFVTQiBUeXBlLUMgTXVsdGlwbGV4ZXIvRGVNdWx0aXBsZXhlciBTd2l0 Y2ggc3VwcG9ydAorICoKKyAqIENvcHlyaWdodCAoQykgMjAxOCBJbnRlbCBDb3Jwb3JhdGlvbgor ICogQXV0aG9yOiBIZWlra2kgS3JvZ2VydXMgPGhlaWtraS5rcm9nZXJ1c0BsaW51eC5pbnRlbC5j b20+CisgKiAgICAgICAgIEhhbnMgZGUgR29lZGUgPGhkZWdvZWRlQHJlZGhhdC5jb20+CisgKi8K KworI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KKyNp bmNsdWRlIDxsaW51eC9tdXRleC5oPgorI2luY2x1ZGUgPGxpbnV4L3VzYi90eXBlY19tdXguaD4K Kworc3RhdGljIERFRklORV9NVVRFWChzd2l0Y2hfbG9jayk7CitzdGF0aWMgREVGSU5FX01VVEVY KG11eF9sb2NrKTsKK3N0YXRpYyBMSVNUX0hFQUQoc3dpdGNoX2xpc3QpOworc3RhdGljIExJU1Rf SEVBRChtdXhfbGlzdCk7CisKK3N0YXRpYyB2b2lkICp0eXBlY19zd2l0Y2hfbWF0Y2goc3RydWN0 IGRldmljZV9jb25uZWN0aW9uICpjb24sIGludCBlcCwKKwkJCQl2b2lkICpkYXRhKQoreworCXN0 cnVjdCB0eXBlY19zd2l0Y2ggKnN3OworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShzdywgJnN3aXRj aF9saXN0LCBlbnRyeSkKKwkJaWYgKCFzdHJjbXAoY29uLT5lbmRwb2ludFtlcF0sIGRldl9uYW1l KHN3LT5kZXYpKSkKKwkJCXJldHVybiBzdzsKKworCS8qCisJICogV2Ugb25seSBnZXQgY2FsbGVk IGlmIGEgY29ubmVjdGlvbiB3YXMgZm91bmQsIHRlbGwgdGhlIGNhbGxlciB0bworCSAqIHdhaXQg Zm9yIHRoZSBzd2l0Y2ggdG8gc2hvdyB1cC4KKwkgKi8KKwlyZXR1cm4gRVJSX1BUUigtRVBST0JF X0RFRkVSKTsKK30KKworLyoqCisgKiB0eXBlY19zd2l0Y2hfZ2V0IC0gRmluZCBVU0IgVHlwZS1D IG9yaWVudGF0aW9uIHN3aXRjaAorICogQGRldjogVGhlIGNhbGxlciBkZXZpY2UKKyAqCisgKiBG aW5kcyBhIHN3aXRjaCBsaW5rZWQgd2l0aCBAZGV2LiBSZXR1cm5zIGEgcmVmZXJlbmNlIHRvIHRo ZSBzd2l0Y2ggb24KKyAqIHN1Y2Nlc3MsIE5VTEwgaWYgbm8gbWF0Y2hpbmcgY29ubmVjdGlvbiB3 YXMgZm91bmQsIG9yCisgKiBFUlJfUFRSKC1FUFJPQkVfREVGRVIpIHdoZW4gYSBjb25uZWN0aW9u IHdhcyBmb3VuZCBidXQgdGhlIHN3aXRjaAorICogaGFzIG5vdCBiZWVuIGVudW1lcmF0ZWQgeWV0 LgorICovCitzdHJ1Y3QgdHlwZWNfc3dpdGNoICp0eXBlY19zd2l0Y2hfZ2V0KHN0cnVjdCBkZXZp Y2UgKmRldikKK3sKKwlzdHJ1Y3QgdHlwZWNfc3dpdGNoICpzdzsKKworCW11dGV4X2xvY2soJnN3 aXRjaF9sb2NrKTsKKwlzdyA9IGRldmljZV9jb25uZWN0aW9uX2ZpbmRfbWF0Y2goZGV2LCAidHlw ZWMtc3dpdGNoIiwgTlVMTCwKKwkJCQkJICB0eXBlY19zd2l0Y2hfbWF0Y2gpOworCWlmICghSVNf RVJSX09SX05VTEwoc3cpKQorCQlnZXRfZGV2aWNlKHN3LT5kZXYpOworCW11dGV4X3VubG9jaygm c3dpdGNoX2xvY2spOworCisJcmV0dXJuIHN3OworfQorRVhQT1JUX1NZTUJPTF9HUEwodHlwZWNf c3dpdGNoX2dldCk7CisKKy8qKgorICogdHlwZWNfcHV0X3N3aXRjaCAtIFJlbGVhc2UgVVNCIFR5 cGUtQyBvcmllbnRhdGlvbiBzd2l0Y2gKKyAqIEBzdzogVVNCIFR5cGUtQyBvcmllbnRhdGlvbiBz d2l0Y2gKKyAqCisgKiBEZWNyZW1lbnQgcmVmZXJlbmNlIGNvdW50IGZvciBAc3cuCisgKi8KK3Zv aWQgdHlwZWNfc3dpdGNoX3B1dChzdHJ1Y3QgdHlwZWNfc3dpdGNoICpzdykKK3sKKwlpZiAoIUlT X0VSUl9PUl9OVUxMKHN3KSkKKwkJcHV0X2RldmljZShzdy0+ZGV2KTsKK30KK0VYUE9SVF9TWU1C T0xfR1BMKHR5cGVjX3N3aXRjaF9wdXQpOworCisvKioKKyAqIHR5cGVjX3N3aXRjaF9yZWdpc3Rl ciAtIFJlZ2lzdGVyIFVTQiBUeXBlLUMgb3JpZW50YXRpb24gc3dpdGNoCisgKiBAc3c6IFVTQiBU eXBlLUMgb3JpZW50YXRpb24gc3dpdGNoCisgKgorICogVGhpcyBmdW5jdGlvbiByZWdpc3RlcnMg YSBzd2l0Y2ggdGhhdCBjYW4gYmUgdXNlZCBmb3Igcm91dGluZyB0aGUgY29ycmVjdAorICogZGF0 YSBwYWlycyBkZXBlbmRpbmcgb24gdGhlIGNhYmxlIHBsdWcgb3JpZW50YXRpb24gZnJvbSB0aGUg VVNCIFR5cGUtQworICogY29ubmVjdG9yIHRvIHRoZSBVU0IgY29udHJvbGxlcnMuIFVTQiBUeXBl LUMgcGx1Z3MgY2FuIGJlIGluc2VydGVkCisgKiByaWdodC1zaWRlLXVwIG9yIHVwc2lkZS1kb3du LgorICovCitpbnQgdHlwZWNfc3dpdGNoX3JlZ2lzdGVyKHN0cnVjdCB0eXBlY19zd2l0Y2ggKnN3 KQoreworCW11dGV4X2xvY2soJnN3aXRjaF9sb2NrKTsKKwlsaXN0X2FkZF90YWlsKCZzdy0+ZW50 cnksICZzd2l0Y2hfbGlzdCk7CisJbXV0ZXhfdW5sb2NrKCZzd2l0Y2hfbG9jayk7CisKKwlyZXR1 cm4gMDsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKHR5cGVjX3N3aXRjaF9yZWdpc3Rlcik7CisKKy8q KgorICogdHlwZWNfc3dpdGNoX3VucmVnaXN0ZXIgLSBVbnJlZ2lzdGVyIFVTQiBUeXBlLUMgb3Jp ZW50YXRpb24gc3dpdGNoCisgKiBAc3c6IFVTQiBUeXBlLUMgb3JpZW50YXRpb24gc3dpdGNoCisg KgorICogVW5yZWdpc3RlciBzd2l0Y2ggdGhhdCB3YXMgcmVnaXN0ZXJlZCB3aXRoIHR5cGVjX3N3 aXRjaF9yZWdpc3RlcigpLgorICovCit2b2lkIHR5cGVjX3N3aXRjaF91bnJlZ2lzdGVyKHN0cnVj dCB0eXBlY19zd2l0Y2ggKnN3KQoreworCW11dGV4X2xvY2soJnN3aXRjaF9sb2NrKTsKKwlsaXN0 X2RlbCgmc3ctPmVudHJ5KTsKKwltdXRleF91bmxvY2soJnN3aXRjaF9sb2NrKTsKK30KK0VYUE9S VF9TWU1CT0xfR1BMKHR5cGVjX3N3aXRjaF91bnJlZ2lzdGVyKTsKKworLyogLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLSAqLworCitzdGF0aWMgdm9pZCAqdHlwZWNfbXV4X21hdGNoKHN0cnVjdCBkZXZpY2VfY29u bmVjdGlvbiAqY29uLCBpbnQgZXAsIHZvaWQgKmRhdGEpCit7CisJc3RydWN0IHR5cGVjX211eCAq bXV4OworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShtdXgsICZtdXhfbGlzdCwgZW50cnkpCisJCWlm ICghc3RyY21wKGNvbi0+ZW5kcG9pbnRbZXBdLCBkZXZfbmFtZShtdXgtPmRldikpKQorCQkJcmV0 dXJuIG11eDsKKworCS8qCisJICogV2Ugb25seSBnZXQgY2FsbGVkIGlmIGEgY29ubmVjdGlvbiB3 YXMgZm91bmQsIHRlbGwgdGhlIGNhbGxlciB0bworCSAqIHdhaXQgZm9yIHRoZSBzd2l0Y2ggdG8g c2hvdyB1cC4KKwkgKi8KKwlyZXR1cm4gRVJSX1BUUigtRVBST0JFX0RFRkVSKTsKK30KKworLyoq CisgKiB0eXBlY19tdXhfZ2V0IC0gRmluZCBVU0IgVHlwZS1DIE11bHRpcGxleGVyCisgKiBAZGV2 OiBUaGUgY2FsbGVyIGRldmljZQorICoKKyAqIEZpbmRzIGEgbXV4IGxpbmtlZCB0byB0aGUgY2Fs bGVyLiBUaGlzIGZ1bmN0aW9uIGlzIHByaW1hcmlseSBtZWFudCBmb3IgdGhlCisgKiBUeXBlLUMg ZHJpdmVycy4gUmV0dXJucyBhIHJlZmVyZW5jZSB0byB0aGUgbXV4IG9uIHN1Y2Nlc3MsIE5VTEwg aWYgbm8KKyAqIG1hdGNoaW5nIGNvbm5lY3Rpb24gd2FzIGZvdW5kLCBvciBFUlJfUFRSKC1FUFJP QkVfREVGRVIpIHdoZW4gYSBjb25uZWN0aW9uCisgKiB3YXMgZm91bmQgYnV0IHRoZSBtdXggaGFz IG5vdCBiZWVuIGVudW1lcmF0ZWQgeWV0LgorICovCitzdHJ1Y3QgdHlwZWNfbXV4ICp0eXBlY19t dXhfZ2V0KHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgdHlwZWNfbXV4ICptdXg7CisK KwltdXRleF9sb2NrKCZtdXhfbG9jayk7CisJbXV4ID0gZGV2aWNlX2Nvbm5lY3Rpb25fZmluZF9t YXRjaChkZXYsICJ0eXBlYy1tdXgiLCBOVUxMLAorCQkJCQkgICB0eXBlY19tdXhfbWF0Y2gpOwor CWlmICghSVNfRVJSX09SX05VTEwobXV4KSkKKwkJZ2V0X2RldmljZShtdXgtPmRldik7CisJbXV0 ZXhfdW5sb2NrKCZtdXhfbG9jayk7CisKKwlyZXR1cm4gbXV4OworfQorRVhQT1JUX1NZTUJPTF9H UEwodHlwZWNfbXV4X2dldCk7CisKKy8qKgorICogdHlwZWNfbXV4X3B1dCAtIFJlbGVhc2UgaGFu ZGxlIHRvIGEgTXVsdGlwbGV4ZXIKKyAqIEBtdXg6IFVTQiBUeXBlLUMgQ29ubmVjdG9yIE11bHRp cGxleGVyL0RlTXVsdGlwbGV4ZXIKKyAqCisgKiBEZWNyZW1lbnRzIHJlZmVyZW5jZSBjb3VudCBm b3IgQG11eC4KKyAqLwordm9pZCB0eXBlY19tdXhfcHV0KHN0cnVjdCB0eXBlY19tdXggKm11eCkK K3sKKwlpZiAoIUlTX0VSUl9PUl9OVUxMKG11eCkpCisJCXB1dF9kZXZpY2UobXV4LT5kZXYpOwor fQorRVhQT1JUX1NZTUJPTF9HUEwodHlwZWNfbXV4X3B1dCk7CisKKy8qKgorICogdHlwZWNfbXV4 X3JlZ2lzdGVyIC0gUmVnaXN0ZXIgTXVsdGlwbGV4ZXIgcm91dGluZyBVU0IgVHlwZS1DIHBpbnMK KyAqIEBtdXg6IFVTQiBUeXBlLUMgQ29ubmVjdG9yIE11bHRpcGxleGVyL0RlTXVsdGlwbGV4ZXIK KyAqCisgKiBVU0IgVHlwZS1DIGNvbm5lY3RvcnMgY2FuIGJlIHVzZWQgZm9yIGFsdGVybmF0ZSBt b2RlcyBvZiBvcGVyYXRpb24gYmVzaWRlcworICogVVNCIHdoZW4gQWNjZXNzb3J5L0FsdGVybmF0 ZSBNb2RlcyBhcmUgc3VwcG9ydGVkLiBXaXRoIHNvbWUgb2YgdGhvc2UgbW9kZXMsCisgKiB0aGUg cGlucyBvbiB0aGUgY29ubmVjdG9yIG5lZWQgdG8gYmUgcmVjb25maWd1cmVkLiBUaGlzIGZ1bmN0 aW9uIHJlZ2lzdGVycworICogbXVsdGlwbGV4ZXIgc3dpdGNoZXMgcm91dGluZyB0aGUgcGlucyBv biB0aGUgY29ubmVjdG9yLgorICovCitpbnQgdHlwZWNfbXV4X3JlZ2lzdGVyKHN0cnVjdCB0eXBl Y19tdXggKm11eCkKK3sKKwltdXRleF9sb2NrKCZtdXhfbG9jayk7CisJbGlzdF9hZGRfdGFpbCgm bXV4LT5lbnRyeSwgJm11eF9saXN0KTsKKwltdXRleF91bmxvY2soJm11eF9sb2NrKTsKKworCXJl dHVybiAwOworfQorRVhQT1JUX1NZTUJPTF9HUEwodHlwZWNfbXV4X3JlZ2lzdGVyKTsKKworLyoq CisgKiB0eXBlY19tdXhfdW5yZWdpc3RlciAtIFVucmVnaXN0ZXIgTXVsdGlwbGV4ZXIgU3dpdGNo CisgKiBAc3c6IFVTQiBUeXBlLUMgQ29ubmVjdG9yIE11bHRpcGxleGVyL0RlTXVsdGlwbGV4ZXIK KyAqCisgKiBVbnJlZ2lzdGVyIG11eCB0aGF0IHdhcyByZWdpc3RlcmVkIHdpdGggdHlwZWNfbXV4 X3JlZ2lzdGVyKCkuCisgKi8KK3ZvaWQgdHlwZWNfbXV4X3VucmVnaXN0ZXIoc3RydWN0IHR5cGVj X211eCAqbXV4KQoreworCW11dGV4X2xvY2soJm11eF9sb2NrKTsKKwlsaXN0X2RlbCgmbXV4LT5l bnRyeSk7CisJbXV0ZXhfdW5sb2NrKCZtdXhfbG9jayk7Cit9CitFWFBPUlRfU1lNQk9MX0dQTCh0 eXBlY19tdXhfdW5yZWdpc3Rlcik7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3VzYi90eXBl Yy5oIGIvaW5jbHVkZS9saW51eC91c2IvdHlwZWMuaAppbmRleCAwZDQ0Y2U2YWYwOGYuLjI0MDhl NWMyZWQ5MSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC91c2IvdHlwZWMuaAorKysgYi9pbmNs dWRlL2xpbnV4L3VzYi90eXBlYy5oCkBAIC02MCw2ICs2MCwxMiBAQCBlbnVtIHR5cGVjX2FjY2Vz c29yeSB7CiAKICNkZWZpbmUgVFlQRUNfTUFYX0FDQ0VTU09SWQkzCiAKK2VudW0gdHlwZWNfb3Jp ZW50YXRpb24geworCVRZUEVDX09SSUVOVEFUSU9OX05PTkUsCisJVFlQRUNfT1JJRU5UQVRJT05f Tk9STUFMLAorCVRZUEVDX09SSUVOVEFUSU9OX1JFVkVSU0UsCit9OworCiAvKgogICogc3RydWN0 IHVzYl9wZF9pZGVudGl0eSAtIFVTQiBQb3dlciBEZWxpdmVyeSBpZGVudGl0eSBkYXRhCiAgKiBA aWRfaGVhZGVyOiBJRCBIZWFkZXIgVkRPCkBAIC0xODUsNiArMTkxLDggQEAgc3RydWN0IHR5cGVj X3BhcnRuZXJfZGVzYyB7CiAgKiBAcGRfcmV2aXNpb246IFVTQiBQb3dlciBEZWxpdmVyeSBTcGVj aWZpY2F0aW9uIHJldmlzaW9uIGlmIHN1cHBvcnRlZAogICogQHByZWZlcl9yb2xlOiBJbml0aWFs IHJvbGUgcHJlZmVyZW5jZQogICogQGFjY2Vzc29yeTogU3VwcG9ydGVkIEFjY2Vzc29yeSBNb2Rl cworICogQHN3OiBDYWJsZSBwbHVnIG9yaWVudGF0aW9uIHN3aXRjaAorICogQG11eDogTXVsdGlw bGV4ZXIgc3dpdGNoIGZvciBBbHRlcm5hdGUvQWNjZXNzb3J5IE1vZGVzCiAgKiBAZndub2RlOiBP cHRpb25hbCBmd25vZGUgb2YgdGhlIHBvcnQKICAqIEB0cnlfcm9sZTogU2V0IGRhdGEgcm9sZSBw cmVmZXJlbmNlIGZvciBEUlAgcG9ydAogICogQGRyX3NldDogU2V0IERhdGEgUm9sZQpAQCAtMjAy LDYgKzIxMCw4IEBAIHN0cnVjdCB0eXBlY19jYXBhYmlsaXR5IHsKIAlpbnQJCQlwcmVmZXJfcm9s ZTsKIAllbnVtIHR5cGVjX2FjY2Vzc29yeQlhY2Nlc3NvcnlbVFlQRUNfTUFYX0FDQ0VTU09SWV07 CiAKKwlzdHJ1Y3QgdHlwZWNfc3dpdGNoCSpzdzsKKwlzdHJ1Y3QgdHlwZWNfbXV4CSptdXg7CiAJ c3RydWN0IGZ3bm9kZV9oYW5kbGUJKmZ3bm9kZTsKIAogCWludAkJKCp0cnlfcm9sZSkoY29uc3Qg c3RydWN0IHR5cGVjX2NhcGFiaWxpdHkgKiwKQEAgLTI0NSw0ICsyNTUsOCBAQCB2b2lkIHR5cGVj X3NldF9wd3Jfcm9sZShzdHJ1Y3QgdHlwZWNfcG9ydCAqcG9ydCwgZW51bSB0eXBlY19yb2xlIHJv bGUpOwogdm9pZCB0eXBlY19zZXRfdmNvbm5fcm9sZShzdHJ1Y3QgdHlwZWNfcG9ydCAqcG9ydCwg ZW51bSB0eXBlY19yb2xlIHJvbGUpOwogdm9pZCB0eXBlY19zZXRfcHdyX29wbW9kZShzdHJ1Y3Qg dHlwZWNfcG9ydCAqcG9ydCwgZW51bSB0eXBlY19wd3Jfb3Btb2RlIG1vZGUpOwogCitpbnQgdHlw ZWNfc2V0X29yaWVudGF0aW9uKHN0cnVjdCB0eXBlY19wb3J0ICpwb3J0LAorCQkJICBlbnVtIHR5 cGVjX29yaWVudGF0aW9uIG9yaWVudGF0aW9uKTsKK2ludCB0eXBlY19zZXRfbW9kZShzdHJ1Y3Qg dHlwZWNfcG9ydCAqcG9ydCwgaW50IG1vZGUpOworCiAjZW5kaWYgLyogX19MSU5VWF9VU0JfVFlQ RUNfSCAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC91c2IvdHlwZWNfbXV4LmggYi9pbmNs dWRlL2xpbnV4L3VzYi90eXBlY19tdXguaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAuLjEyYzFiMDU3ODM0YgotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUvbGludXgv dXNiL3R5cGVjX211eC5oCkBAIC0wLDAgKzEsNTUgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlm aWVyOiBHUEwtMi4wCisKKyNpZm5kZWYgX19VU0JfVFlQRUNfTVVYCisjZGVmaW5lIF9fVVNCX1RZ UEVDX01VWAorCisjaW5jbHVkZSA8bGludXgvbGlzdC5oPgorI2luY2x1ZGUgPGxpbnV4L3VzYi90 eXBlYy5oPgorCitzdHJ1Y3QgZGV2aWNlOworCisvKioKKyAqIHN0cnVjdCB0eXBlY19zd2l0Y2gg LSBVU0IgVHlwZS1DIGNhYmxlIG9yaWVudGF0aW9uIHN3aXRjaAorICogQGRldjogU3dpdGNoIGRl dmljZQorICogQGVudHJ5OiBMaXN0IGVudHJ5CisgKiBAc2V0OiBDYWxsYmFjayB0byB0aGUgZHJp dmVyIGZvciBzZXR0aW5nIHRoZSBvcmllbnRhdGlvbgorICoKKyAqIFVTQiBUeXBlLUMgcGluIGZs aXBwZXIgc3dpdGNoIHJvdXRpbmcgdGhlIGNvcnJlY3QgZGF0YSBwYWlycyBmcm9tIHRoZQorICog Y29ubmVjdG9yIHRvIHRoZSBVU0IgY29udHJvbGxlciBkZXBlbmRpbmcgb24gdGhlIG9yaWVudGF0 aW9uIG9mIHRoZSBjYWJsZQorICogcGx1Zy4KKyAqLworc3RydWN0IHR5cGVjX3N3aXRjaCB7CisJ c3RydWN0IGRldmljZSAqZGV2OworCXN0cnVjdCBsaXN0X2hlYWQgZW50cnk7CisKKwlpbnQgKCpz ZXQpKHN0cnVjdCB0eXBlY19zd2l0Y2ggKnN3LCBlbnVtIHR5cGVjX29yaWVudGF0aW9uIG9yaWVu dGF0aW9uKTsKK307CisKKy8qKgorICogc3RydWN0IHR5cGVjX3N3aXRjaCAtIFVTQiBUeXBlLUMg Y29ubmVjdG9yIHBpbiBtdXgKKyAqIEBkZXY6IE11eCBkZXZpY2UKKyAqIEBlbnRyeTogTGlzdCBl bnRyeQorICogQHNldDogQ2FsbGJhY2sgdG8gdGhlIGRyaXZlciBmb3Igc2V0dGluZyB0aGUgc3Rh dGUgb2YgdGhlIG11eAorICoKKyAqIFBpbiBNdWx0aXBsZXhlci9EZU11bHRpcGxleGVyIHN3aXRj aCByb3V0aW5nIHRoZSBVU0IgVHlwZS1DIGNvbm5lY3RvciBwaW5zIHRvCisgKiBkaWZmZXJlbnQg Y29tcG9uZW50cyBkZXBlbmRpbmcgb24gdGhlIHJlcXVlc3RlZCBtb2RlIG9mIG9wZXJhdGlvbi4g VXNlZCB3aXRoCisgKiBBY2Nlc3NvcnkvQWx0ZXJuYXRlIG1vZGVzLgorICovCitzdHJ1Y3QgdHlw ZWNfbXV4IHsKKwlzdHJ1Y3QgZGV2aWNlICpkZXY7CisJc3RydWN0IGxpc3RfaGVhZCBlbnRyeTsK KworCWludCAoKnNldCkoc3RydWN0IHR5cGVjX211eCAqbXV4LCBpbnQgc3RhdGUpOworfTsKKwor c3RydWN0IHR5cGVjX3N3aXRjaCAqdHlwZWNfc3dpdGNoX2dldChzdHJ1Y3QgZGV2aWNlICpkZXYp Owordm9pZCB0eXBlY19zd2l0Y2hfcHV0KHN0cnVjdCB0eXBlY19zd2l0Y2ggKnN3KTsKK2ludCB0 eXBlY19zd2l0Y2hfcmVnaXN0ZXIoc3RydWN0IHR5cGVjX3N3aXRjaCAqc3cpOwordm9pZCB0eXBl Y19zd2l0Y2hfdW5yZWdpc3RlcihzdHJ1Y3QgdHlwZWNfc3dpdGNoICpzdyk7CisKK3N0cnVjdCB0 eXBlY19tdXggKnR5cGVjX211eF9nZXQoc3RydWN0IGRldmljZSAqZGV2KTsKK3ZvaWQgdHlwZWNf bXV4X3B1dChzdHJ1Y3QgdHlwZWNfbXV4ICptdXgpOworaW50IHR5cGVjX211eF9yZWdpc3Rlcihz dHJ1Y3QgdHlwZWNfbXV4ICptdXgpOwordm9pZCB0eXBlY19tdXhfdW5yZWdpc3RlcihzdHJ1Y3Qg dHlwZWNfbXV4ICptdXgpOworCisjZW5kaWYgLyogX19VU0JfVFlQRUNfTVVYICovCg==