From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Cyrus-Session-Id: sloti22d1t05-3021914-1524574084-2-14322192637088408127 X-Sieve: CMU Sieve 3.0 X-Spam-known-sender: no X-Spam-score: 0.0 X-Spam-hits: BAYES_00 -1.9, HEADER_FROM_DIFFERENT_DOMAINS 0.25, MAILING_LIST_MULTI -1, ME_NOAUTH 0.01, RCVD_IN_DNSWL_HI -5, LANGUAGES enro, BAYES_USED global, SA_VERSION 3.4.0 X-Spam-source: IP='209.132.180.67', Host='vger.kernel.org', Country='US', FromHeader='com', MailFrom='org' X-Spam-charsets: plain='us-ascii' X-Resolved-to: greg@kroah.com X-Delivered-to: greg@kroah.com X-Mail-from: linux-usb-owner@vger.kernel.org ARC-Seal: i=1; a=rsa-sha256; cv=none; d=messagingengine.com; s=fm2; t= 1524574083; b=Pn+AxBfzNG9vP8rFMQ+JtqXlxSoz+Hwk9Ko9sMoj5ovBzuwWm0 4jofbGv0BZIIcazaqvCRYHbtdC/nNAhWc7QhcLoMAJP7pFAkBM4PZe0DzQuuGXGp Kk+/jJDeU1KYfASdyi8gdTZl4lWJ0nJ/XEf7hreoM3iNkko6VUPbYCL+a61R+uwa PjJ2zP6pHigWmo/8pEtukl2iaqjTa30KZY6vnW4uidyweZ6426W6pWatn6NHWeCz H2G/jnaGizSE6DnoQBbWOjCbdQ2fqedWQUv4DvDotPfwXt5Ie2XSDq8BI4Lh+a6s bHZ+xvp7XyfJRzs6W0u6dfJ0NRZ5jz1f3YFw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=date:from:to:cc:subject:message-id :references:mime-version:content-type:in-reply-to:sender :list-id; s=fm2; t=1524574083; bh=cR/LKn5JC0GxbSufMdIVXTawPfXDPY ponuNO913Ccls=; b=eUX1Scv/RPlVCvnL08pAZ/pukfeLWHIUiut1YoD6qvBzqD uN688RpESshszoqdkPYzgy0B92YAzh/d2j3vkXMQMcRC1Lm5CY1uPqTpJf5IhS0I T82A6VNvzFNaMYlgHuRI2yyJBbfkGFnLLzvFq+OSNpydQopWlB0ciGA0Y6paZLRX bO9HxmYYjsSlsDkJiNsFYTnE9k38wmGyegmvZrvkXRJCxXauF2DdckAqs9FX/6R+ cZV9cFA8VZBvCM4Ht1EMFBB/rwO3+ohJBdfVnWm0NOVZzuNfZu0+kVnmfC/QMB6S 0qV8M9+5uJZli5o67DAM76zmCilwfjQLHSn8T7LQ== ARC-Authentication-Results: i=1; mx2.messagingengine.com; arc=none (no signatures found); dkim=none (no signatures found); dmarc=none (p=none,has-list-id=yes,d=none) header.from=linux.intel.com; iprev=pass policy.iprev=209.132.180.67 (vger.kernel.org); spf=none smtp.mailfrom=linux-usb-owner@vger.kernel.org smtp.helo=vger.kernel.org; x-aligned-from=fail; x-cm=none score=0; x-ptr=pass x-ptr-helo=vger.kernel.org x-ptr-lookup=vger.kernel.org; x-return-mx=pass smtp.domain=vger.kernel.org smtp.result=pass smtp_org.domain=kernel.org smtp_org.result=pass smtp_is_org_domain=no header.domain=linux.intel.com header.result=pass header_org.domain=intel.com header_org.result=pass header_is_org_domain=no; x-vs=clean score=-100 state=0 Authentication-Results: mx2.messagingengine.com; arc=none (no signatures found); dkim=none (no signatures found); dmarc=none (p=none,has-list-id=yes,d=none) header.from=linux.intel.com; iprev=pass policy.iprev=209.132.180.67 (vger.kernel.org); spf=none smtp.mailfrom=linux-usb-owner@vger.kernel.org smtp.helo=vger.kernel.org; x-aligned-from=fail; x-cm=none score=0; x-ptr=pass x-ptr-helo=vger.kernel.org x-ptr-lookup=vger.kernel.org; x-return-mx=pass smtp.domain=vger.kernel.org smtp.result=pass smtp_org.domain=kernel.org smtp_org.result=pass smtp_is_org_domain=no header.domain=linux.intel.com header.result=pass header_org.domain=intel.com header_org.result=pass header_is_org_domain=no; x-vs=clean score=-100 state=0 X-ME-VSCategory: clean X-CM-Envelope: MS4wfJLD9lnbRWeLV8+FjUW9pvxDZtZvOoMJts80ESdI/m6x5V+eNShMqjLu9Mr3dRdb/eZnt269vTHaueIv29p9nXofs/WdMfeRIFXY8o41XJHvOQBtlIFN iR7j+RjrxlI3PWmWI//kGrCVqEjUSXXSNRq5OEgTuC7Lp6kQBMQIM9hX6SS2uSs/bPVOzGsuiqwP2d9+eA5dpzNH/zPKbd7GoS0gUZXKq+B/frB0Yzsguzaz X-CM-Analysis: v=2.3 cv=E8HjW5Vl c=1 sm=1 tr=0 a=UK1r566ZdBxH71SXbqIOeA==:117 a=UK1r566ZdBxH71SXbqIOeA==:17 a=kj9zAlcOel0A:10 a=Kd1tUaAdevIA:10 a=X3a0BiUdAAAA:8 a=_jlGtV7tAAAA:8 a=QyXUC8HyAAAA:8 a=VwQbUJbxAAAA:8 a=na-uLiM3hikIN6ezXy0A:9 a=ePL-3qfncj7jVLHf:21 a=d1I3BtqSfNPrhnBi:21 a=CjuIK1q_8ugA:10 a=x8gzFH9gYPwA:10 a=aWu3muFgq6otJbhCXpL5:22 a=nlm17XC03S6CtCLSeiRr:22 a=AjGcO6oz07-iQ99wixmX:22 X-ME-CMScore: 0 X-ME-CMCategory: none Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933161AbeDXMrp (ORCPT ); Tue, 24 Apr 2018 08:47:45 -0400 Received: from mga17.intel.com ([192.55.52.151]:48900 "EHLO mga17.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756801AbeDXMrM (ORCPT ); Tue, 24 Apr 2018 08:47:12 -0400 X-Amp-Result: UNKNOWN X-Amp-Original-Verdict: FILE UNKNOWN X-Amp-File-Uploaded: False X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.49,323,1520924400"; d="scan'208";a="49491364" Date: Tue, 24 Apr 2018 15:47:07 +0300 From: Heikki Krogerus To: Adam Thomson Cc: Guenter Roeck , Greg Kroah-Hartman , Sebastian Reichel , Hans de Goede , Jun Li , linux-usb@vger.kernel.org, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org, support.opensource@diasemi.com Subject: Re: [PATCH v8 5/6] typec: tcpm: Represent source supply through power_supply Message-ID: <20180424124707.GG25723@kuha.fi.intel.com> References: MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: User-Agent: Mutt/1.9.2 (2017-12-15) Sender: linux-usb-owner@vger.kernel.org X-Mailing-List: linux-usb@vger.kernel.org X-getmail-retrieved-from-mailbox: INBOX X-Mailing-List: linux-kernel@vger.kernel.org List-ID: On Mon, Apr 23, 2018 at 03:11:00PM +0100, Adam Thomson wrote: > This commit adds a power_supply class instance to represent a > PD source's voltage and current properties. This provides an > interface for reading these properties from user-space or other > drivers. > > For PPS enabled Sources, this also provides write access to set > the current and voltage and allows for swapping between standard > PDO and PPS APDO. > > As this represents a superset of the information provided in the > fusb302 driver, the power_supply instance in that code is removed > as part of this change, so reverting the commit titled > 'typec: tcpm: Represent source supply through power_supply class' > > Signed-off-by: Adam Thomson > Reviewed-by: Guenter Roeck Reviewed-by: Heikki Krogerus > --- > drivers/usb/typec/Kconfig | 1 + > drivers/usb/typec/fusb302/Kconfig | 2 +- > drivers/usb/typec/fusb302/fusb302.c | 63 +-------- > drivers/usb/typec/tcpm.c | 251 +++++++++++++++++++++++++++++++++++- > 4 files changed, 251 insertions(+), 66 deletions(-) > > diff --git a/drivers/usb/typec/Kconfig b/drivers/usb/typec/Kconfig > index 030f88c..2c8eab1 100644 > --- a/drivers/usb/typec/Kconfig > +++ b/drivers/usb/typec/Kconfig > @@ -49,6 +49,7 @@ config TYPEC_TCPM > tristate "USB Type-C Port Controller Manager" > depends on USB > select USB_ROLE_SWITCH > + select POWER_SUPPLY > help > The Type-C Port Controller Manager provides a USB PD and USB Type-C > state machine for use with Type-C Port Controllers. > diff --git a/drivers/usb/typec/fusb302/Kconfig b/drivers/usb/typec/fusb302/Kconfig > index 48a4f2f..fce099f 100644 > --- a/drivers/usb/typec/fusb302/Kconfig > +++ b/drivers/usb/typec/fusb302/Kconfig > @@ -1,6 +1,6 @@ > config TYPEC_FUSB302 > tristate "Fairchild FUSB302 Type-C chip driver" > - depends on I2C && POWER_SUPPLY > + depends on I2C > help > The Fairchild FUSB302 Type-C chip driver that works with > Type-C Port Controller Manager to provide USB PD and USB > diff --git a/drivers/usb/typec/fusb302/fusb302.c b/drivers/usb/typec/fusb302/fusb302.c > index 664463d..eba6bb8 100644 > --- a/drivers/usb/typec/fusb302/fusb302.c > +++ b/drivers/usb/typec/fusb302/fusb302.c > @@ -18,7 +18,6 @@ > #include > #include > #include > -#include > #include > #include > #include > @@ -99,11 +98,6 @@ struct fusb302_chip { > /* lock for sharing chip states */ > struct mutex lock; > > - /* psy + psy status */ > - struct power_supply *psy; > - u32 current_limit; > - u32 supply_voltage; > - > /* chip status */ > enum toggling_mode toggling_mode; > enum src_current_status src_current_status; > @@ -862,13 +856,11 @@ static int tcpm_set_vbus(struct tcpc_dev *dev, bool on, bool charge) > chip->vbus_on = on; > fusb302_log(chip, "vbus := %s", on ? "On" : "Off"); > } > - if (chip->charge_on == charge) { > + if (chip->charge_on == charge) > fusb302_log(chip, "charge is already %s", > charge ? "On" : "Off"); > - } else { > + else > chip->charge_on = charge; > - power_supply_changed(chip->psy); > - } > > done: > mutex_unlock(&chip->lock); > @@ -884,11 +876,6 @@ static int tcpm_set_current_limit(struct tcpc_dev *dev, u32 max_ma, u32 mv) > fusb302_log(chip, "current limit: %d ma, %d mv (not implemented)", > max_ma, mv); > > - chip->supply_voltage = mv; > - chip->current_limit = max_ma; > - > - power_supply_changed(chip->psy); > - > return 0; > } > > @@ -1682,43 +1669,6 @@ static irqreturn_t fusb302_irq_intn(int irq, void *dev_id) > return IRQ_HANDLED; > } > > -static int fusb302_psy_get_property(struct power_supply *psy, > - enum power_supply_property psp, > - union power_supply_propval *val) > -{ > - struct fusb302_chip *chip = power_supply_get_drvdata(psy); > - > - switch (psp) { > - case POWER_SUPPLY_PROP_ONLINE: > - val->intval = chip->charge_on; > - break; > - case POWER_SUPPLY_PROP_VOLTAGE_NOW: > - val->intval = chip->supply_voltage * 1000; /* mV -> ??V */ > - break; > - case POWER_SUPPLY_PROP_CURRENT_MAX: > - val->intval = chip->current_limit * 1000; /* mA -> ??A */ > - break; > - default: > - return -ENODATA; > - } > - > - return 0; > -} > - > -static enum power_supply_property fusb302_psy_properties[] = { > - POWER_SUPPLY_PROP_ONLINE, > - POWER_SUPPLY_PROP_VOLTAGE_NOW, > - POWER_SUPPLY_PROP_CURRENT_MAX, > -}; > - > -static const struct power_supply_desc fusb302_psy_desc = { > - .name = "fusb302-typec-source", > - .type = POWER_SUPPLY_TYPE_USB_TYPE_C, > - .properties = fusb302_psy_properties, > - .num_properties = ARRAY_SIZE(fusb302_psy_properties), > - .get_property = fusb302_psy_get_property, > -}; > - > static int init_gpio(struct fusb302_chip *chip) > { > struct device_node *node; > @@ -1781,7 +1731,6 @@ static int fusb302_probe(struct i2c_client *client, > struct fusb302_chip *chip; > struct i2c_adapter *adapter; > struct device *dev = &client->dev; > - struct power_supply_config cfg = {}; > const char *name; > int ret = 0; > u32 v; > @@ -1823,14 +1772,6 @@ static int fusb302_probe(struct i2c_client *client, > return -EPROBE_DEFER; > } > > - cfg.drv_data = chip; > - chip->psy = devm_power_supply_register(dev, &fusb302_psy_desc, &cfg); > - if (IS_ERR(chip->psy)) { > - ret = PTR_ERR(chip->psy); > - dev_err(chip->dev, "Error registering power-supply: %d\n", ret); > - return ret; > - } > - > ret = fusb302_debugfs_init(chip); > if (ret < 0) > return ret; > diff --git a/drivers/usb/typec/tcpm.c b/drivers/usb/typec/tcpm.c > index b160da3..7547097 100644 > --- a/drivers/usb/typec/tcpm.c > +++ b/drivers/usb/typec/tcpm.c > @@ -12,6 +12,7 @@ > #include > #include > #include > +#include > #include > #include > #include > @@ -276,6 +277,11 @@ struct tcpm_port { > u32 current_limit; > u32 supply_voltage; > > + /* Used to export TA voltage and current */ > + struct power_supply *psy; > + struct power_supply_desc psy_desc; > + enum power_supply_usb_type usb_type; > + > u32 bist_request; > > /* PD state for Vendor Defined Messages */ > @@ -1895,6 +1901,7 @@ static int tcpm_pd_select_pdo(struct tcpm_port *port, int *sink_pdo, > int ret = -EINVAL; > > port->pps_data.supported = false; > + port->usb_type = POWER_SUPPLY_USB_TYPE_PD; > > /* > * Select the source PDO providing the most power which has a > @@ -1915,8 +1922,11 @@ static int tcpm_pd_select_pdo(struct tcpm_port *port, int *sink_pdo, > min_src_mv = pdo_min_voltage(pdo); > break; > case PDO_TYPE_APDO: > - if (pdo_apdo_type(pdo) == APDO_TYPE_PPS) > + if (pdo_apdo_type(pdo) == APDO_TYPE_PPS) { > port->pps_data.supported = true; > + port->usb_type = > + POWER_SUPPLY_USB_TYPE_PD_PPS; > + } > continue; > default: > tcpm_log(port, "Invalid source PDO type, ignoring"); > @@ -2472,6 +2482,9 @@ static void tcpm_reset_port(struct tcpm_port *port) > port->try_snk_count = 0; > port->supply_voltage = 0; > port->current_limit = 0; > + port->usb_type = POWER_SUPPLY_USB_TYPE_C; > + > + power_supply_changed(port->psy); > } > > static void tcpm_detach(struct tcpm_port *port) > @@ -2999,6 +3012,8 @@ static void run_state_machine(struct tcpm_port *port) > tcpm_check_send_discover(port); > tcpm_pps_complete(port, port->pps_status); > > + power_supply_changed(port->psy); > + > break; > > /* Accessory states */ > @@ -3849,7 +3864,7 @@ static int tcpm_try_role(const struct typec_capability *cap, int role) > return ret; > } > > -static int __maybe_unused tcpm_pps_set_op_curr(struct tcpm_port *port, u16 op_curr) > +static int tcpm_pps_set_op_curr(struct tcpm_port *port, u16 op_curr) > { > unsigned int target_mw; > int ret; > @@ -3901,7 +3916,7 @@ static int __maybe_unused tcpm_pps_set_op_curr(struct tcpm_port *port, u16 op_cu > return ret; > } > > -static int __maybe_unused tcpm_pps_set_out_volt(struct tcpm_port *port, u16 out_volt) > +static int tcpm_pps_set_out_volt(struct tcpm_port *port, u16 out_volt) > { > unsigned int target_mw; > int ret; > @@ -3954,7 +3969,7 @@ static int __maybe_unused tcpm_pps_set_out_volt(struct tcpm_port *port, u16 out_ > return ret; > } > > -static int __maybe_unused tcpm_pps_activate(struct tcpm_port *port, bool activate) > +static int tcpm_pps_activate(struct tcpm_port *port, bool activate) > { > int ret = 0; > > @@ -4159,6 +4174,230 @@ int tcpm_update_sink_capabilities(struct tcpm_port *port, const u32 *pdo, > } > EXPORT_SYMBOL_GPL(tcpm_update_sink_capabilities); > > +/* Power Supply access to expose source power information */ > +enum tcpm_psy_online_states { > + TCPM_PSY_OFFLINE = 0, > + TCPM_PSY_FIXED_ONLINE, > + TCPM_PSY_PROG_ONLINE, > +}; > + > +static enum power_supply_property tcpm_psy_props[] = { > + POWER_SUPPLY_PROP_USB_TYPE, > + POWER_SUPPLY_PROP_ONLINE, > + POWER_SUPPLY_PROP_VOLTAGE_MIN, > + POWER_SUPPLY_PROP_VOLTAGE_MAX, > + POWER_SUPPLY_PROP_VOLTAGE_NOW, > + POWER_SUPPLY_PROP_CURRENT_MAX, > + POWER_SUPPLY_PROP_CURRENT_NOW, > +}; > + > +static int tcpm_psy_get_online(struct tcpm_port *port, > + union power_supply_propval *val) > +{ > + if (port->vbus_charge) { > + if (port->pps_data.active) > + val->intval = TCPM_PSY_PROG_ONLINE; > + else > + val->intval = TCPM_PSY_FIXED_ONLINE; > + } else { > + val->intval = TCPM_PSY_OFFLINE; > + } > + > + return 0; > +} > + > +static int tcpm_psy_get_voltage_min(struct tcpm_port *port, > + union power_supply_propval *val) > +{ > + if (port->pps_data.active) > + val->intval = port->pps_data.min_volt * 1000; > + else > + val->intval = port->supply_voltage * 1000; > + > + return 0; > +} > + > +static int tcpm_psy_get_voltage_max(struct tcpm_port *port, > + union power_supply_propval *val) > +{ > + if (port->pps_data.active) > + val->intval = port->pps_data.max_volt * 1000; > + else > + val->intval = port->supply_voltage * 1000; > + > + return 0; > +} > + > +static int tcpm_psy_get_voltage_now(struct tcpm_port *port, > + union power_supply_propval *val) > +{ > + val->intval = port->supply_voltage * 1000; > + > + return 0; > +} > + > +static int tcpm_psy_get_current_max(struct tcpm_port *port, > + union power_supply_propval *val) > +{ > + if (port->pps_data.active) > + val->intval = port->pps_data.max_curr * 1000; > + else > + val->intval = port->current_limit * 1000; > + > + return 0; > +} > + > +static int tcpm_psy_get_current_now(struct tcpm_port *port, > + union power_supply_propval *val) > +{ > + val->intval = port->current_limit * 1000; > + > + return 0; > +} > + > +static int tcpm_psy_get_prop(struct power_supply *psy, > + enum power_supply_property psp, > + union power_supply_propval *val) > +{ > + struct tcpm_port *port = power_supply_get_drvdata(psy); > + int ret = 0; > + > + switch (psp) { > + case POWER_SUPPLY_PROP_USB_TYPE: > + val->intval = port->usb_type; > + break; > + case POWER_SUPPLY_PROP_ONLINE: > + ret = tcpm_psy_get_online(port, val); > + break; > + case POWER_SUPPLY_PROP_VOLTAGE_MIN: > + ret = tcpm_psy_get_voltage_min(port, val); > + break; > + case POWER_SUPPLY_PROP_VOLTAGE_MAX: > + ret = tcpm_psy_get_voltage_max(port, val); > + break; > + case POWER_SUPPLY_PROP_VOLTAGE_NOW: > + ret = tcpm_psy_get_voltage_now(port, val); > + break; > + case POWER_SUPPLY_PROP_CURRENT_MAX: > + ret = tcpm_psy_get_current_max(port, val); > + break; > + case POWER_SUPPLY_PROP_CURRENT_NOW: > + ret = tcpm_psy_get_current_now(port, val); > + break; > + default: > + ret = -EINVAL; > + break; > + } > + > + return ret; > +} > + > +static int tcpm_psy_set_online(struct tcpm_port *port, > + const union power_supply_propval *val) > +{ > + int ret; > + > + switch (val->intval) { > + case TCPM_PSY_FIXED_ONLINE: > + ret = tcpm_pps_activate(port, false); > + break; > + case TCPM_PSY_PROG_ONLINE: > + ret = tcpm_pps_activate(port, true); > + break; > + default: > + ret = -EINVAL; > + break; > + } > + > + return ret; > +} > + > +static int tcpm_psy_set_prop(struct power_supply *psy, > + enum power_supply_property psp, > + const union power_supply_propval *val) > +{ > + struct tcpm_port *port = power_supply_get_drvdata(psy); > + int ret; > + > + switch (psp) { > + case POWER_SUPPLY_PROP_ONLINE: > + ret = tcpm_psy_set_online(port, val); > + break; > + case POWER_SUPPLY_PROP_VOLTAGE_NOW: > + if (val->intval < port->pps_data.min_volt * 1000 || > + val->intval > port->pps_data.max_volt * 1000) > + ret = -EINVAL; > + else > + ret = tcpm_pps_set_out_volt(port, val->intval / 1000); > + break; > + case POWER_SUPPLY_PROP_CURRENT_NOW: > + if (val->intval > port->pps_data.max_curr * 1000) > + ret = -EINVAL; > + else > + ret = tcpm_pps_set_op_curr(port, val->intval / 1000); > + break; > + default: > + ret = -EINVAL; > + break; > + } > + > + return ret; > +} > + > +static int tcpm_psy_prop_writeable(struct power_supply *psy, > + enum power_supply_property psp) > +{ > + switch (psp) { > + case POWER_SUPPLY_PROP_ONLINE: > + case POWER_SUPPLY_PROP_VOLTAGE_NOW: > + case POWER_SUPPLY_PROP_CURRENT_NOW: > + return 1; > + default: > + return 0; > + } > +} > + > +static enum power_supply_usb_type tcpm_psy_usb_types[] = { > + POWER_SUPPLY_USB_TYPE_C, > + POWER_SUPPLY_USB_TYPE_PD, > + POWER_SUPPLY_USB_TYPE_PD_PPS, > +}; > + > +static const char *tcpm_psy_name_prefix = "tcpm-source-psy-"; > + > +static int devm_tcpm_psy_register(struct tcpm_port *port) > +{ > + struct power_supply_config psy_cfg = {}; > + const char *port_dev_name = dev_name(port->dev); > + size_t psy_name_len = strlen(tcpm_psy_name_prefix) + > + strlen(port_dev_name) + 1; > + char *psy_name; > + > + psy_cfg.drv_data = port; > + psy_name = devm_kzalloc(port->dev, psy_name_len, GFP_KERNEL); > + if (!psy_name) > + return -ENOMEM; > + > + snprintf(psy_name, psy_name_len, "%s%s", tcpm_psy_name_prefix, > + port_dev_name); > + port->psy_desc.name = psy_name; > + port->psy_desc.type = POWER_SUPPLY_TYPE_USB, > + port->psy_desc.usb_types = tcpm_psy_usb_types; > + port->psy_desc.num_usb_types = ARRAY_SIZE(tcpm_psy_usb_types); > + port->psy_desc.properties = tcpm_psy_props, > + port->psy_desc.num_properties = ARRAY_SIZE(tcpm_psy_props), > + port->psy_desc.get_property = tcpm_psy_get_prop, > + port->psy_desc.set_property = tcpm_psy_set_prop, > + port->psy_desc.property_is_writeable = tcpm_psy_prop_writeable, > + > + port->usb_type = POWER_SUPPLY_USB_TYPE_C; > + > + port->psy = devm_power_supply_register(port->dev, &port->psy_desc, > + &psy_cfg); > + > + return PTR_ERR_OR_ZERO(port->psy); > +} > + > struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) > { > struct tcpm_port *port; > @@ -4234,6 +4473,10 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) > goto out_destroy_wq; > } > > + err = devm_tcpm_psy_register(port); > + if (err) > + goto out_destroy_wq; > + > port->typec_port = typec_register_port(port->dev, &port->typec_caps); > if (IS_ERR(port->typec_port)) { > err = PTR_ERR(port->typec_port); > -- > 1.9.1 -- heikki From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v8,5/6] typec: tcpm: Represent source supply through power_supply From: Heikki Krogerus Message-Id: <20180424124707.GG25723@kuha.fi.intel.com> Date: Tue, 24 Apr 2018 15:47:07 +0300 To: Adam Thomson Cc: Guenter Roeck , Greg Kroah-Hartman , Sebastian Reichel , Hans de Goede , Jun Li , linux-usb@vger.kernel.org, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org, support.opensource@diasemi.com List-ID: T24gTW9uLCBBcHIgMjMsIDIwMTggYXQgMDM6MTE6MDBQTSArMDEwMCwgQWRhbSBUaG9tc29uIHdy b3RlOgo+IFRoaXMgY29tbWl0IGFkZHMgYSBwb3dlcl9zdXBwbHkgY2xhc3MgaW5zdGFuY2UgdG8g cmVwcmVzZW50IGEKPiBQRCBzb3VyY2UncyB2b2x0YWdlIGFuZCBjdXJyZW50IHByb3BlcnRpZXMu IFRoaXMgcHJvdmlkZXMgYW4KPiBpbnRlcmZhY2UgZm9yIHJlYWRpbmcgdGhlc2UgcHJvcGVydGll cyBmcm9tIHVzZXItc3BhY2Ugb3Igb3RoZXIKPiBkcml2ZXJzLgo+IAo+IEZvciBQUFMgZW5hYmxl ZCBTb3VyY2VzLCB0aGlzIGFsc28gcHJvdmlkZXMgd3JpdGUgYWNjZXNzIHRvIHNldAo+IHRoZSBj dXJyZW50IGFuZCB2b2x0YWdlIGFuZCBhbGxvd3MgZm9yIHN3YXBwaW5nIGJldHdlZW4gc3RhbmRh cmQKPiBQRE8gYW5kIFBQUyBBUERPLgo+IAo+IEFzIHRoaXMgcmVwcmVzZW50cyBhIHN1cGVyc2V0 IG9mIHRoZSBpbmZvcm1hdGlvbiBwcm92aWRlZCBpbiB0aGUKPiBmdXNiMzAyIGRyaXZlciwgdGhl IHBvd2VyX3N1cHBseSBpbnN0YW5jZSBpbiB0aGF0IGNvZGUgaXMgcmVtb3ZlZAo+IGFzIHBhcnQg b2YgdGhpcyBjaGFuZ2UsIHNvIHJldmVydGluZyB0aGUgY29tbWl0IHRpdGxlZAo+ICd0eXBlYzog dGNwbTogUmVwcmVzZW50IHNvdXJjZSBzdXBwbHkgdGhyb3VnaCBwb3dlcl9zdXBwbHkgY2xhc3Mn Cj4gCj4gU2lnbmVkLW9mZi1ieTogQWRhbSBUaG9tc29uIDxBZGFtLlRob21zb24uT3BlbnNvdXJj ZUBkaWFzZW1pLmNvbT4KPiBSZXZpZXdlZC1ieTogR3VlbnRlciBSb2VjayA8bGludXhAcm9lY2st dXMubmV0PgoKUmV2aWV3ZWQtYnk6IEhlaWtraSBLcm9nZXJ1cyA8aGVpa2tpLmtyb2dlcnVzQGxp bnV4LmludGVsLmNvbT4KCj4gLS0tCj4gIGRyaXZlcnMvdXNiL3R5cGVjL0tjb25maWcgICAgICAg ICAgIHwgICAxICsKPiAgZHJpdmVycy91c2IvdHlwZWMvZnVzYjMwMi9LY29uZmlnICAgfCAgIDIg Ky0KPiAgZHJpdmVycy91c2IvdHlwZWMvZnVzYjMwMi9mdXNiMzAyLmMgfCAgNjMgKy0tLS0tLS0t Cj4gIGRyaXZlcnMvdXNiL3R5cGVjL3RjcG0uYyAgICAgICAgICAgIHwgMjUxICsrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrLQo+ICA0IGZpbGVzIGNoYW5nZWQsIDI1MSBpbnNlcnRp b25zKCspLCA2NiBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvdHlw ZWMvS2NvbmZpZyBiL2RyaXZlcnMvdXNiL3R5cGVjL0tjb25maWcKPiBpbmRleCAwMzBmODhjLi4y YzhlYWIxIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvdXNiL3R5cGVjL0tjb25maWcKPiArKysgYi9k cml2ZXJzL3VzYi90eXBlYy9LY29uZmlnCj4gQEAgLTQ5LDYgKzQ5LDcgQEAgY29uZmlnIFRZUEVD X1RDUE0KPiAgCXRyaXN0YXRlICJVU0IgVHlwZS1DIFBvcnQgQ29udHJvbGxlciBNYW5hZ2VyIgo+ ICAJZGVwZW5kcyBvbiBVU0IKPiAgCXNlbGVjdCBVU0JfUk9MRV9TV0lUQ0gKPiArCXNlbGVjdCBQ T1dFUl9TVVBQTFkKPiAgCWhlbHAKPiAgCSAgVGhlIFR5cGUtQyBQb3J0IENvbnRyb2xsZXIgTWFu YWdlciBwcm92aWRlcyBhIFVTQiBQRCBhbmQgVVNCIFR5cGUtQwo+ICAJICBzdGF0ZSBtYWNoaW5l IGZvciB1c2Ugd2l0aCBUeXBlLUMgUG9ydCBDb250cm9sbGVycy4KPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy91c2IvdHlwZWMvZnVzYjMwMi9LY29uZmlnIGIvZHJpdmVycy91c2IvdHlwZWMvZnVzYjMw Mi9LY29uZmlnCj4gaW5kZXggNDhhNGYyZi4uZmNlMDk5ZiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L3VzYi90eXBlYy9mdXNiMzAyL0tjb25maWcKPiArKysgYi9kcml2ZXJzL3VzYi90eXBlYy9mdXNi MzAyL0tjb25maWcKPiBAQCAtMSw2ICsxLDYgQEAKPiAgY29uZmlnIFRZUEVDX0ZVU0IzMDIKPiAg CXRyaXN0YXRlICJGYWlyY2hpbGQgRlVTQjMwMiBUeXBlLUMgY2hpcCBkcml2ZXIiCj4gLQlkZXBl bmRzIG9uIEkyQyAmJiBQT1dFUl9TVVBQTFkKPiArCWRlcGVuZHMgb24gSTJDCj4gIAloZWxwCj4g IAkgIFRoZSBGYWlyY2hpbGQgRlVTQjMwMiBUeXBlLUMgY2hpcCBkcml2ZXIgdGhhdCB3b3JrcyB3 aXRoCj4gIAkgIFR5cGUtQyBQb3J0IENvbnRyb2xsZXIgTWFuYWdlciB0byBwcm92aWRlIFVTQiBQ RCBhbmQgVVNCCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3R5cGVjL2Z1c2IzMDIvZnVzYjMw Mi5jIGIvZHJpdmVycy91c2IvdHlwZWMvZnVzYjMwMi9mdXNiMzAyLmMKPiBpbmRleCA2NjQ0NjNk Li5lYmE2YmI4IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvdXNiL3R5cGVjL2Z1c2IzMDIvZnVzYjMw Mi5jCj4gKysrIGIvZHJpdmVycy91c2IvdHlwZWMvZnVzYjMwMi9mdXNiMzAyLmMKPiBAQCAtMTgs NyArMTgsNiBAQAo+ICAjaW5jbHVkZSA8bGludXgvb2ZfZGV2aWNlLmg+Cj4gICNpbmNsdWRlIDxs aW51eC9vZl9ncGlvLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9waW5jdHJsL2NvbnN1bWVyLmg+Cj4g LSNpbmNsdWRlIDxsaW51eC9wb3dlcl9zdXBwbHkuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L3Byb2Nf ZnMuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L3JlZ3VsYXRvci9jb25zdW1lci5oPgo+ICAjaW5jbHVk ZSA8bGludXgvc2NoZWQvY2xvY2suaD4KPiBAQCAtOTksMTEgKzk4LDYgQEAgc3RydWN0IGZ1c2Iz MDJfY2hpcCB7Cj4gIAkvKiBsb2NrIGZvciBzaGFyaW5nIGNoaXAgc3RhdGVzICovCj4gIAlzdHJ1 Y3QgbXV0ZXggbG9jazsKPiAgCj4gLQkvKiBwc3kgKyBwc3kgc3RhdHVzICovCj4gLQlzdHJ1Y3Qg cG93ZXJfc3VwcGx5ICpwc3k7Cj4gLQl1MzIgY3VycmVudF9saW1pdDsKPiAtCXUzMiBzdXBwbHlf dm9sdGFnZTsKPiAtCj4gIAkvKiBjaGlwIHN0YXR1cyAqLwo+ICAJZW51bSB0b2dnbGluZ19tb2Rl IHRvZ2dsaW5nX21vZGU7Cj4gIAllbnVtIHNyY19jdXJyZW50X3N0YXR1cyBzcmNfY3VycmVudF9z dGF0dXM7Cj4gQEAgLTg2MiwxMyArODU2LDExIEBAIHN0YXRpYyBpbnQgdGNwbV9zZXRfdmJ1cyhz dHJ1Y3QgdGNwY19kZXYgKmRldiwgYm9vbCBvbiwgYm9vbCBjaGFyZ2UpCj4gIAkJY2hpcC0+dmJ1 c19vbiA9IG9uOwo+ICAJCWZ1c2IzMDJfbG9nKGNoaXAsICJ2YnVzIDo9ICVzIiwgb24gPyAiT24i IDogIk9mZiIpOwo+ICAJfQo+IC0JaWYgKGNoaXAtPmNoYXJnZV9vbiA9PSBjaGFyZ2UpIHsKPiAr CWlmIChjaGlwLT5jaGFyZ2Vfb24gPT0gY2hhcmdlKQo+ICAJCWZ1c2IzMDJfbG9nKGNoaXAsICJj aGFyZ2UgaXMgYWxyZWFkeSAlcyIsCj4gIAkJCSAgICBjaGFyZ2UgPyAiT24iIDogIk9mZiIpOwo+ IC0JfSBlbHNlIHsKPiArCWVsc2UKPiAgCQljaGlwLT5jaGFyZ2Vfb24gPSBjaGFyZ2U7Cj4gLQkJ cG93ZXJfc3VwcGx5X2NoYW5nZWQoY2hpcC0+cHN5KTsKPiAtCX0KPiAgCj4gIGRvbmU6Cj4gIAlt dXRleF91bmxvY2soJmNoaXAtPmxvY2spOwo+IEBAIC04ODQsMTEgKzg3Niw2IEBAIHN0YXRpYyBp bnQgdGNwbV9zZXRfY3VycmVudF9saW1pdChzdHJ1Y3QgdGNwY19kZXYgKmRldiwgdTMyIG1heF9t YSwgdTMyIG12KQo+ICAJZnVzYjMwMl9sb2coY2hpcCwgImN1cnJlbnQgbGltaXQ6ICVkIG1hLCAl ZCBtdiAobm90IGltcGxlbWVudGVkKSIsCj4gIAkJICAgIG1heF9tYSwgbXYpOwo+ICAKPiAtCWNo aXAtPnN1cHBseV92b2x0YWdlID0gbXY7Cj4gLQljaGlwLT5jdXJyZW50X2xpbWl0ID0gbWF4X21h Owo+IC0KPiAtCXBvd2VyX3N1cHBseV9jaGFuZ2VkKGNoaXAtPnBzeSk7Cj4gLQo+ICAJcmV0dXJu IDA7Cj4gIH0KPiAgCj4gQEAgLTE2ODIsNDMgKzE2NjksNiBAQCBzdGF0aWMgaXJxcmV0dXJuX3Qg ZnVzYjMwMl9pcnFfaW50bihpbnQgaXJxLCB2b2lkICpkZXZfaWQpCj4gIAlyZXR1cm4gSVJRX0hB TkRMRUQ7Cj4gIH0KPiAgCj4gLXN0YXRpYyBpbnQgZnVzYjMwMl9wc3lfZ2V0X3Byb3BlcnR5KHN0 cnVjdCBwb3dlcl9zdXBwbHkgKnBzeSwKPiAtCQkJCSAgICBlbnVtIHBvd2VyX3N1cHBseV9wcm9w ZXJ0eSBwc3AsCj4gLQkJCQkgICAgdW5pb24gcG93ZXJfc3VwcGx5X3Byb3B2YWwgKnZhbCkKPiAt ewo+IC0Jc3RydWN0IGZ1c2IzMDJfY2hpcCAqY2hpcCA9IHBvd2VyX3N1cHBseV9nZXRfZHJ2ZGF0 YShwc3kpOwo+IC0KPiAtCXN3aXRjaCAocHNwKSB7Cj4gLQljYXNlIFBPV0VSX1NVUFBMWV9QUk9Q X09OTElORToKPiAtCQl2YWwtPmludHZhbCA9IGNoaXAtPmNoYXJnZV9vbjsKPiAtCQlicmVhazsK PiAtCWNhc2UgUE9XRVJfU1VQUExZX1BST1BfVk9MVEFHRV9OT1c6Cj4gLQkJdmFsLT5pbnR2YWwg PSBjaGlwLT5zdXBwbHlfdm9sdGFnZSAqIDEwMDA7IC8qIG1WIC0+ID8/ViAqLwo+IC0JCWJyZWFr Owo+IC0JY2FzZSBQT1dFUl9TVVBQTFlfUFJPUF9DVVJSRU5UX01BWDoKPiAtCQl2YWwtPmludHZh bCA9IGNoaXAtPmN1cnJlbnRfbGltaXQgKiAxMDAwOyAvKiBtQSAtPiA/P0EgKi8KPiAtCQlicmVh azsKPiAtCWRlZmF1bHQ6Cj4gLQkJcmV0dXJuIC1FTk9EQVRBOwo+IC0JfQo+IC0KPiAtCXJldHVy biAwOwo+IC19Cj4gLQo+IC1zdGF0aWMgZW51bSBwb3dlcl9zdXBwbHlfcHJvcGVydHkgZnVzYjMw Ml9wc3lfcHJvcGVydGllc1tdID0gewo+IC0JUE9XRVJfU1VQUExZX1BST1BfT05MSU5FLAo+IC0J UE9XRVJfU1VQUExZX1BST1BfVk9MVEFHRV9OT1csCj4gLQlQT1dFUl9TVVBQTFlfUFJPUF9DVVJS RU5UX01BWCwKPiAtfTsKPiAtCj4gLXN0YXRpYyBjb25zdCBzdHJ1Y3QgcG93ZXJfc3VwcGx5X2Rl c2MgZnVzYjMwMl9wc3lfZGVzYyA9IHsKPiAtCS5uYW1lCQk9ICJmdXNiMzAyLXR5cGVjLXNvdXJj ZSIsCj4gLQkudHlwZQkJPSBQT1dFUl9TVVBQTFlfVFlQRV9VU0JfVFlQRV9DLAo+IC0JLnByb3Bl cnRpZXMJPSBmdXNiMzAyX3BzeV9wcm9wZXJ0aWVzLAo+IC0JLm51bV9wcm9wZXJ0aWVzCT0gQVJS QVlfU0laRShmdXNiMzAyX3BzeV9wcm9wZXJ0aWVzKSwKPiAtCS5nZXRfcHJvcGVydHkJPSBmdXNi MzAyX3BzeV9nZXRfcHJvcGVydHksCj4gLX07Cj4gLQo+ICBzdGF0aWMgaW50IGluaXRfZ3Bpbyhz dHJ1Y3QgZnVzYjMwMl9jaGlwICpjaGlwKQo+ICB7Cj4gIAlzdHJ1Y3QgZGV2aWNlX25vZGUgKm5v ZGU7Cj4gQEAgLTE3ODEsNyArMTczMSw2IEBAIHN0YXRpYyBpbnQgZnVzYjMwMl9wcm9iZShzdHJ1 Y3QgaTJjX2NsaWVudCAqY2xpZW50LAo+ICAJc3RydWN0IGZ1c2IzMDJfY2hpcCAqY2hpcDsKPiAg CXN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcHRlcjsKPiAgCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZj bGllbnQtPmRldjsKPiAtCXN0cnVjdCBwb3dlcl9zdXBwbHlfY29uZmlnIGNmZyA9IHt9Owo+ICAJ Y29uc3QgY2hhciAqbmFtZTsKPiAgCWludCByZXQgPSAwOwo+ICAJdTMyIHY7Cj4gQEAgLTE4MjMs MTQgKzE3NzIsNiBAQCBzdGF0aWMgaW50IGZ1c2IzMDJfcHJvYmUoc3RydWN0IGkyY19jbGllbnQg KmNsaWVudCwKPiAgCQkJcmV0dXJuIC1FUFJPQkVfREVGRVI7Cj4gIAl9Cj4gIAo+IC0JY2ZnLmRy dl9kYXRhID0gY2hpcDsKPiAtCWNoaXAtPnBzeSA9IGRldm1fcG93ZXJfc3VwcGx5X3JlZ2lzdGVy KGRldiwgJmZ1c2IzMDJfcHN5X2Rlc2MsICZjZmcpOwo+IC0JaWYgKElTX0VSUihjaGlwLT5wc3kp KSB7Cj4gLQkJcmV0ID0gUFRSX0VSUihjaGlwLT5wc3kpOwo+IC0JCWRldl9lcnIoY2hpcC0+ZGV2 LCAiRXJyb3IgcmVnaXN0ZXJpbmcgcG93ZXItc3VwcGx5OiAlZFxuIiwgcmV0KTsKPiAtCQlyZXR1 cm4gcmV0Owo+IC0JfQo+IC0KPiAgCXJldCA9IGZ1c2IzMDJfZGVidWdmc19pbml0KGNoaXApOwo+ ICAJaWYgKHJldCA8IDApCj4gIAkJcmV0dXJuIHJldDsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy91 c2IvdHlwZWMvdGNwbS5jIGIvZHJpdmVycy91c2IvdHlwZWMvdGNwbS5jCj4gaW5kZXggYjE2MGRh My4uNzU0NzA5NyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3VzYi90eXBlYy90Y3BtLmMKPiArKysg Yi9kcml2ZXJzL3VzYi90eXBlYy90Y3BtLmMKPiBAQCAtMTIsNiArMTIsNyBAQAo+ICAjaW5jbHVk ZSA8bGludXgva2VybmVsLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KPiAgI2luY2x1 ZGUgPGxpbnV4L211dGV4Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9wb3dlcl9zdXBwbHkuaD4KPiAg I2luY2x1ZGUgPGxpbnV4L3Byb2NfZnMuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L3NjaGVkL2Nsb2Nr Lmg+Cj4gICNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgo+IEBAIC0yNzYsNiArMjc3LDExIEBA IHN0cnVjdCB0Y3BtX3BvcnQgewo+ICAJdTMyIGN1cnJlbnRfbGltaXQ7Cj4gIAl1MzIgc3VwcGx5 X3ZvbHRhZ2U7Cj4gIAo+ICsJLyogVXNlZCB0byBleHBvcnQgVEEgdm9sdGFnZSBhbmQgY3VycmVu dCAqLwo+ICsJc3RydWN0IHBvd2VyX3N1cHBseSAqcHN5Owo+ICsJc3RydWN0IHBvd2VyX3N1cHBs eV9kZXNjIHBzeV9kZXNjOwo+ICsJZW51bSBwb3dlcl9zdXBwbHlfdXNiX3R5cGUgdXNiX3R5cGU7 Cj4gKwo+ICAJdTMyIGJpc3RfcmVxdWVzdDsKPiAgCj4gIAkvKiBQRCBzdGF0ZSBmb3IgVmVuZG9y IERlZmluZWQgTWVzc2FnZXMgKi8KPiBAQCAtMTg5NSw2ICsxOTAxLDcgQEAgc3RhdGljIGludCB0 Y3BtX3BkX3NlbGVjdF9wZG8oc3RydWN0IHRjcG1fcG9ydCAqcG9ydCwgaW50ICpzaW5rX3BkbywK PiAgCWludCByZXQgPSAtRUlOVkFMOwo+ICAKPiAgCXBvcnQtPnBwc19kYXRhLnN1cHBvcnRlZCA9 IGZhbHNlOwo+ICsJcG9ydC0+dXNiX3R5cGUgPSBQT1dFUl9TVVBQTFlfVVNCX1RZUEVfUEQ7Cj4g IAo+ICAJLyoKPiAgCSAqIFNlbGVjdCB0aGUgc291cmNlIFBETyBwcm92aWRpbmcgdGhlIG1vc3Qg cG93ZXIgd2hpY2ggaGFzIGEKPiBAQCAtMTkxNSw4ICsxOTIyLDExIEBAIHN0YXRpYyBpbnQgdGNw bV9wZF9zZWxlY3RfcGRvKHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQsIGludCAqc2lua19wZG8sCj4g IAkJCW1pbl9zcmNfbXYgPSBwZG9fbWluX3ZvbHRhZ2UocGRvKTsKPiAgCQkJYnJlYWs7Cj4gIAkJ Y2FzZSBQRE9fVFlQRV9BUERPOgo+IC0JCQlpZiAocGRvX2FwZG9fdHlwZShwZG8pID09IEFQRE9f VFlQRV9QUFMpCj4gKwkJCWlmIChwZG9fYXBkb190eXBlKHBkbykgPT0gQVBET19UWVBFX1BQUykg ewo+ICAJCQkJcG9ydC0+cHBzX2RhdGEuc3VwcG9ydGVkID0gdHJ1ZTsKPiArCQkJCXBvcnQtPnVz Yl90eXBlID0KPiArCQkJCQlQT1dFUl9TVVBQTFlfVVNCX1RZUEVfUERfUFBTOwo+ICsJCQl9Cj4g IAkJCWNvbnRpbnVlOwo+ICAJCWRlZmF1bHQ6Cj4gIAkJCXRjcG1fbG9nKHBvcnQsICJJbnZhbGlk IHNvdXJjZSBQRE8gdHlwZSwgaWdub3JpbmciKTsKPiBAQCAtMjQ3Miw2ICsyNDgyLDkgQEAgc3Rh dGljIHZvaWQgdGNwbV9yZXNldF9wb3J0KHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQpCj4gIAlwb3J0 LT50cnlfc25rX2NvdW50ID0gMDsKPiAgCXBvcnQtPnN1cHBseV92b2x0YWdlID0gMDsKPiAgCXBv cnQtPmN1cnJlbnRfbGltaXQgPSAwOwo+ICsJcG9ydC0+dXNiX3R5cGUgPSBQT1dFUl9TVVBQTFlf VVNCX1RZUEVfQzsKPiArCj4gKwlwb3dlcl9zdXBwbHlfY2hhbmdlZChwb3J0LT5wc3kpOwo+ICB9 Cj4gIAo+ICBzdGF0aWMgdm9pZCB0Y3BtX2RldGFjaChzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0KQo+ IEBAIC0yOTk5LDYgKzMwMTIsOCBAQCBzdGF0aWMgdm9pZCBydW5fc3RhdGVfbWFjaGluZShzdHJ1 Y3QgdGNwbV9wb3J0ICpwb3J0KQo+ICAJCXRjcG1fY2hlY2tfc2VuZF9kaXNjb3Zlcihwb3J0KTsK PiAgCQl0Y3BtX3Bwc19jb21wbGV0ZShwb3J0LCBwb3J0LT5wcHNfc3RhdHVzKTsKPiAgCj4gKwkJ cG93ZXJfc3VwcGx5X2NoYW5nZWQocG9ydC0+cHN5KTsKPiArCj4gIAkJYnJlYWs7Cj4gIAo+ICAJ LyogQWNjZXNzb3J5IHN0YXRlcyAqLwo+IEBAIC0zODQ5LDcgKzM4NjQsNyBAQCBzdGF0aWMgaW50 IHRjcG1fdHJ5X3JvbGUoY29uc3Qgc3RydWN0IHR5cGVjX2NhcGFiaWxpdHkgKmNhcCwgaW50IHJv bGUpCj4gIAlyZXR1cm4gcmV0Owo+ICB9Cj4gIAo+IC1zdGF0aWMgaW50IF9fbWF5YmVfdW51c2Vk IHRjcG1fcHBzX3NldF9vcF9jdXJyKHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQsIHUxNiBvcF9jdXJy KQo+ICtzdGF0aWMgaW50IHRjcG1fcHBzX3NldF9vcF9jdXJyKHN0cnVjdCB0Y3BtX3BvcnQgKnBv cnQsIHUxNiBvcF9jdXJyKQo+ICB7Cj4gIAl1bnNpZ25lZCBpbnQgdGFyZ2V0X213Owo+ICAJaW50 IHJldDsKPiBAQCAtMzkwMSw3ICszOTE2LDcgQEAgc3RhdGljIGludCBfX21heWJlX3VudXNlZCB0 Y3BtX3Bwc19zZXRfb3BfY3VycihzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LCB1MTYgb3BfY3UKPiAg CXJldHVybiByZXQ7Cj4gIH0KPiAgCj4gLXN0YXRpYyBpbnQgX19tYXliZV91bnVzZWQgdGNwbV9w cHNfc2V0X291dF92b2x0KHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQsIHUxNiBvdXRfdm9sdCkKPiAr c3RhdGljIGludCB0Y3BtX3Bwc19zZXRfb3V0X3ZvbHQoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCwg dTE2IG91dF92b2x0KQo+ICB7Cj4gIAl1bnNpZ25lZCBpbnQgdGFyZ2V0X213Owo+ICAJaW50IHJl dDsKPiBAQCAtMzk1NCw3ICszOTY5LDcgQEAgc3RhdGljIGludCBfX21heWJlX3VudXNlZCB0Y3Bt X3Bwc19zZXRfb3V0X3ZvbHQoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCwgdTE2IG91dF8KPiAgCXJl dHVybiByZXQ7Cj4gIH0KPiAgCj4gLXN0YXRpYyBpbnQgX19tYXliZV91bnVzZWQgdGNwbV9wcHNf YWN0aXZhdGUoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCwgYm9vbCBhY3RpdmF0ZSkKPiArc3RhdGlj IGludCB0Y3BtX3Bwc19hY3RpdmF0ZShzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LCBib29sIGFjdGl2 YXRlKQo+ICB7Cj4gIAlpbnQgcmV0ID0gMDsKPiAgCj4gQEAgLTQxNTksNiArNDE3NCwyMzAgQEAg aW50IHRjcG1fdXBkYXRlX3NpbmtfY2FwYWJpbGl0aWVzKHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQs IGNvbnN0IHUzMiAqcGRvLAo+ICB9Cj4gIEVYUE9SVF9TWU1CT0xfR1BMKHRjcG1fdXBkYXRlX3Np bmtfY2FwYWJpbGl0aWVzKTsKPiAgCj4gKy8qIFBvd2VyIFN1cHBseSBhY2Nlc3MgdG8gZXhwb3Nl IHNvdXJjZSBwb3dlciBpbmZvcm1hdGlvbiAqLwo+ICtlbnVtIHRjcG1fcHN5X29ubGluZV9zdGF0 ZXMgewo+ICsJVENQTV9QU1lfT0ZGTElORSA9IDAsCj4gKwlUQ1BNX1BTWV9GSVhFRF9PTkxJTkUs Cj4gKwlUQ1BNX1BTWV9QUk9HX09OTElORSwKPiArfTsKPiArCj4gK3N0YXRpYyBlbnVtIHBvd2Vy X3N1cHBseV9wcm9wZXJ0eSB0Y3BtX3BzeV9wcm9wc1tdID0gewo+ICsJUE9XRVJfU1VQUExZX1BS T1BfVVNCX1RZUEUsCj4gKwlQT1dFUl9TVVBQTFlfUFJPUF9PTkxJTkUsCj4gKwlQT1dFUl9TVVBQ TFlfUFJPUF9WT0xUQUdFX01JTiwKPiArCVBPV0VSX1NVUFBMWV9QUk9QX1ZPTFRBR0VfTUFYLAo+ ICsJUE9XRVJfU1VQUExZX1BST1BfVk9MVEFHRV9OT1csCj4gKwlQT1dFUl9TVVBQTFlfUFJPUF9D VVJSRU5UX01BWCwKPiArCVBPV0VSX1NVUFBMWV9QUk9QX0NVUlJFTlRfTk9XLAo+ICt9Owo+ICsK PiArc3RhdGljIGludCB0Y3BtX3BzeV9nZXRfb25saW5lKHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQs Cj4gKwkJCSAgICAgICB1bmlvbiBwb3dlcl9zdXBwbHlfcHJvcHZhbCAqdmFsKQo+ICt7Cj4gKwlp ZiAocG9ydC0+dmJ1c19jaGFyZ2UpIHsKPiArCQlpZiAocG9ydC0+cHBzX2RhdGEuYWN0aXZlKQo+ ICsJCQl2YWwtPmludHZhbCA9IFRDUE1fUFNZX1BST0dfT05MSU5FOwo+ICsJCWVsc2UKPiArCQkJ dmFsLT5pbnR2YWwgPSBUQ1BNX1BTWV9GSVhFRF9PTkxJTkU7Cj4gKwl9IGVsc2Ugewo+ICsJCXZh bC0+aW50dmFsID0gVENQTV9QU1lfT0ZGTElORTsKPiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiAr fQo+ICsKPiArc3RhdGljIGludCB0Y3BtX3BzeV9nZXRfdm9sdGFnZV9taW4oc3RydWN0IHRjcG1f cG9ydCAqcG9ydCwKPiArCQkJCSAgICB1bmlvbiBwb3dlcl9zdXBwbHlfcHJvcHZhbCAqdmFsKQo+ ICt7Cj4gKwlpZiAocG9ydC0+cHBzX2RhdGEuYWN0aXZlKQo+ICsJCXZhbC0+aW50dmFsID0gcG9y dC0+cHBzX2RhdGEubWluX3ZvbHQgKiAxMDAwOwo+ICsJZWxzZQo+ICsJCXZhbC0+aW50dmFsID0g cG9ydC0+c3VwcGx5X3ZvbHRhZ2UgKiAxMDAwOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ ICtzdGF0aWMgaW50IHRjcG1fcHN5X2dldF92b2x0YWdlX21heChzdHJ1Y3QgdGNwbV9wb3J0ICpw b3J0LAo+ICsJCQkJICAgIHVuaW9uIHBvd2VyX3N1cHBseV9wcm9wdmFsICp2YWwpCj4gK3sKPiAr CWlmIChwb3J0LT5wcHNfZGF0YS5hY3RpdmUpCj4gKwkJdmFsLT5pbnR2YWwgPSBwb3J0LT5wcHNf ZGF0YS5tYXhfdm9sdCAqIDEwMDA7Cj4gKwllbHNlCj4gKwkJdmFsLT5pbnR2YWwgPSBwb3J0LT5z dXBwbHlfdm9sdGFnZSAqIDEwMDA7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRp YyBpbnQgdGNwbV9wc3lfZ2V0X3ZvbHRhZ2Vfbm93KHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQsCj4g KwkJCQkgICAgdW5pb24gcG93ZXJfc3VwcGx5X3Byb3B2YWwgKnZhbCkKPiArewo+ICsJdmFsLT5p bnR2YWwgPSBwb3J0LT5zdXBwbHlfdm9sdGFnZSAqIDEwMDA7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4g K30KPiArCj4gK3N0YXRpYyBpbnQgdGNwbV9wc3lfZ2V0X2N1cnJlbnRfbWF4KHN0cnVjdCB0Y3Bt X3BvcnQgKnBvcnQsCj4gKwkJCQkgICAgdW5pb24gcG93ZXJfc3VwcGx5X3Byb3B2YWwgKnZhbCkK PiArewo+ICsJaWYgKHBvcnQtPnBwc19kYXRhLmFjdGl2ZSkKPiArCQl2YWwtPmludHZhbCA9IHBv cnQtPnBwc19kYXRhLm1heF9jdXJyICogMTAwMDsKPiArCWVsc2UKPiArCQl2YWwtPmludHZhbCA9 IHBvcnQtPmN1cnJlbnRfbGltaXQgKiAxMDAwOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ ICtzdGF0aWMgaW50IHRjcG1fcHN5X2dldF9jdXJyZW50X25vdyhzdHJ1Y3QgdGNwbV9wb3J0ICpw b3J0LAo+ICsJCQkJICAgIHVuaW9uIHBvd2VyX3N1cHBseV9wcm9wdmFsICp2YWwpCj4gK3sKPiAr CXZhbC0+aW50dmFsID0gcG9ydC0+Y3VycmVudF9saW1pdCAqIDEwMDA7Cj4gKwo+ICsJcmV0dXJu IDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdGNwbV9wc3lfZ2V0X3Byb3Aoc3RydWN0IHBvd2Vy X3N1cHBseSAqcHN5LAo+ICsJCQkgICAgIGVudW0gcG93ZXJfc3VwcGx5X3Byb3BlcnR5IHBzcCwK PiArCQkJICAgICB1bmlvbiBwb3dlcl9zdXBwbHlfcHJvcHZhbCAqdmFsKQo+ICt7Cj4gKwlzdHJ1 Y3QgdGNwbV9wb3J0ICpwb3J0ID0gcG93ZXJfc3VwcGx5X2dldF9kcnZkYXRhKHBzeSk7Cj4gKwlp bnQgcmV0ID0gMDsKPiArCj4gKwlzd2l0Y2ggKHBzcCkgewo+ICsJY2FzZSBQT1dFUl9TVVBQTFlf UFJPUF9VU0JfVFlQRToKPiArCQl2YWwtPmludHZhbCA9IHBvcnQtPnVzYl90eXBlOwo+ICsJCWJy ZWFrOwo+ICsJY2FzZSBQT1dFUl9TVVBQTFlfUFJPUF9PTkxJTkU6Cj4gKwkJcmV0ID0gdGNwbV9w c3lfZ2V0X29ubGluZShwb3J0LCB2YWwpOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBQT1dFUl9TVVBQ TFlfUFJPUF9WT0xUQUdFX01JTjoKPiArCQlyZXQgPSB0Y3BtX3BzeV9nZXRfdm9sdGFnZV9taW4o cG9ydCwgdmFsKTsKPiArCQlicmVhazsKPiArCWNhc2UgUE9XRVJfU1VQUExZX1BST1BfVk9MVEFH RV9NQVg6Cj4gKwkJcmV0ID0gdGNwbV9wc3lfZ2V0X3ZvbHRhZ2VfbWF4KHBvcnQsIHZhbCk7Cj4g KwkJYnJlYWs7Cj4gKwljYXNlIFBPV0VSX1NVUFBMWV9QUk9QX1ZPTFRBR0VfTk9XOgo+ICsJCXJl dCA9IHRjcG1fcHN5X2dldF92b2x0YWdlX25vdyhwb3J0LCB2YWwpOwo+ICsJCWJyZWFrOwo+ICsJ Y2FzZSBQT1dFUl9TVVBQTFlfUFJPUF9DVVJSRU5UX01BWDoKPiArCQlyZXQgPSB0Y3BtX3BzeV9n ZXRfY3VycmVudF9tYXgocG9ydCwgdmFsKTsKPiArCQlicmVhazsKPiArCWNhc2UgUE9XRVJfU1VQ UExZX1BST1BfQ1VSUkVOVF9OT1c6Cj4gKwkJcmV0ID0gdGNwbV9wc3lfZ2V0X2N1cnJlbnRfbm93 KHBvcnQsIHZhbCk7Cj4gKwkJYnJlYWs7Cj4gKwlkZWZhdWx0Ogo+ICsJCXJldCA9IC1FSU5WQUw7 Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGlj IGludCB0Y3BtX3BzeV9zZXRfb25saW5lKHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQsCj4gKwkJCSAg ICAgICBjb25zdCB1bmlvbiBwb3dlcl9zdXBwbHlfcHJvcHZhbCAqdmFsKQo+ICt7Cj4gKwlpbnQg cmV0Owo+ICsKPiArCXN3aXRjaCAodmFsLT5pbnR2YWwpIHsKPiArCWNhc2UgVENQTV9QU1lfRklY RURfT05MSU5FOgo+ICsJCXJldCA9IHRjcG1fcHBzX2FjdGl2YXRlKHBvcnQsIGZhbHNlKTsKPiAr CQlicmVhazsKPiArCWNhc2UgVENQTV9QU1lfUFJPR19PTkxJTkU6Cj4gKwkJcmV0ID0gdGNwbV9w cHNfYWN0aXZhdGUocG9ydCwgdHJ1ZSk7Cj4gKwkJYnJlYWs7Cj4gKwlkZWZhdWx0Ogo+ICsJCXJl dCA9IC1FSU5WQUw7Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ ICsKPiArc3RhdGljIGludCB0Y3BtX3BzeV9zZXRfcHJvcChzdHJ1Y3QgcG93ZXJfc3VwcGx5ICpw c3ksCj4gKwkJCSAgICAgZW51bSBwb3dlcl9zdXBwbHlfcHJvcGVydHkgcHNwLAo+ICsJCQkgICAg IGNvbnN0IHVuaW9uIHBvd2VyX3N1cHBseV9wcm9wdmFsICp2YWwpCj4gK3sKPiArCXN0cnVjdCB0 Y3BtX3BvcnQgKnBvcnQgPSBwb3dlcl9zdXBwbHlfZ2V0X2RydmRhdGEocHN5KTsKPiArCWludCBy ZXQ7Cj4gKwo+ICsJc3dpdGNoIChwc3ApIHsKPiArCWNhc2UgUE9XRVJfU1VQUExZX1BST1BfT05M SU5FOgo+ICsJCXJldCA9IHRjcG1fcHN5X3NldF9vbmxpbmUocG9ydCwgdmFsKTsKPiArCQlicmVh azsKPiArCWNhc2UgUE9XRVJfU1VQUExZX1BST1BfVk9MVEFHRV9OT1c6Cj4gKwkJaWYgKHZhbC0+ aW50dmFsIDwgcG9ydC0+cHBzX2RhdGEubWluX3ZvbHQgKiAxMDAwIHx8Cj4gKwkJICAgIHZhbC0+ aW50dmFsID4gcG9ydC0+cHBzX2RhdGEubWF4X3ZvbHQgKiAxMDAwKQo+ICsJCQlyZXQgPSAtRUlO VkFMOwo+ICsJCWVsc2UKPiArCQkJcmV0ID0gdGNwbV9wcHNfc2V0X291dF92b2x0KHBvcnQsIHZh bC0+aW50dmFsIC8gMTAwMCk7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIFBPV0VSX1NVUFBMWV9QUk9Q X0NVUlJFTlRfTk9XOgo+ICsJCWlmICh2YWwtPmludHZhbCA+IHBvcnQtPnBwc19kYXRhLm1heF9j dXJyICogMTAwMCkKPiArCQkJcmV0ID0gLUVJTlZBTDsKPiArCQllbHNlCj4gKwkJCXJldCA9IHRj cG1fcHBzX3NldF9vcF9jdXJyKHBvcnQsIHZhbC0+aW50dmFsIC8gMTAwMCk7Cj4gKwkJYnJlYWs7 Cj4gKwlkZWZhdWx0Ogo+ICsJCXJldCA9IC1FSU5WQUw7Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwo+ ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIGludCB0Y3BtX3BzeV9wcm9wX3dyaXRl YWJsZShzdHJ1Y3QgcG93ZXJfc3VwcGx5ICpwc3ksCj4gKwkJCQkgICBlbnVtIHBvd2VyX3N1cHBs eV9wcm9wZXJ0eSBwc3ApCj4gK3sKPiArCXN3aXRjaCAocHNwKSB7Cj4gKwljYXNlIFBPV0VSX1NV UFBMWV9QUk9QX09OTElORToKPiArCWNhc2UgUE9XRVJfU1VQUExZX1BST1BfVk9MVEFHRV9OT1c6 Cj4gKwljYXNlIFBPV0VSX1NVUFBMWV9QUk9QX0NVUlJFTlRfTk9XOgo+ICsJCXJldHVybiAxOwo+ ICsJZGVmYXVsdDoKPiArCQlyZXR1cm4gMDsKPiArCX0KPiArfQo+ICsKPiArc3RhdGljIGVudW0g cG93ZXJfc3VwcGx5X3VzYl90eXBlIHRjcG1fcHN5X3VzYl90eXBlc1tdID0gewo+ICsJUE9XRVJf U1VQUExZX1VTQl9UWVBFX0MsCj4gKwlQT1dFUl9TVVBQTFlfVVNCX1RZUEVfUEQsCj4gKwlQT1dF Ul9TVVBQTFlfVVNCX1RZUEVfUERfUFBTLAo+ICt9Owo+ICsKPiArc3RhdGljIGNvbnN0IGNoYXIg KnRjcG1fcHN5X25hbWVfcHJlZml4ID0gInRjcG0tc291cmNlLXBzeS0iOwo+ICsKPiArc3RhdGlj IGludCBkZXZtX3RjcG1fcHN5X3JlZ2lzdGVyKHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQpCj4gK3sK PiArCXN0cnVjdCBwb3dlcl9zdXBwbHlfY29uZmlnIHBzeV9jZmcgPSB7fTsKPiArCWNvbnN0IGNo YXIgKnBvcnRfZGV2X25hbWUgPSBkZXZfbmFtZShwb3J0LT5kZXYpOwo+ICsJc2l6ZV90IHBzeV9u YW1lX2xlbiA9IHN0cmxlbih0Y3BtX3BzeV9uYW1lX3ByZWZpeCkgKwo+ICsJCQkJICAgICBzdHJs ZW4ocG9ydF9kZXZfbmFtZSkgKyAxOwo+ICsJY2hhciAqcHN5X25hbWU7Cj4gKwo+ICsJcHN5X2Nm Zy5kcnZfZGF0YSA9IHBvcnQ7Cj4gKwlwc3lfbmFtZSA9IGRldm1fa3phbGxvYyhwb3J0LT5kZXYs IHBzeV9uYW1lX2xlbiwgR0ZQX0tFUk5FTCk7Cj4gKwlpZiAoIXBzeV9uYW1lKQo+ICsJCXJldHVy biAtRU5PTUVNOwo+ICsKPiArCXNucHJpbnRmKHBzeV9uYW1lLCBwc3lfbmFtZV9sZW4sICIlcyVz IiwgdGNwbV9wc3lfbmFtZV9wcmVmaXgsCj4gKwkJIHBvcnRfZGV2X25hbWUpOwo+ICsJcG9ydC0+ cHN5X2Rlc2MubmFtZSA9IHBzeV9uYW1lOwo+ICsJcG9ydC0+cHN5X2Rlc2MudHlwZSA9IFBPV0VS X1NVUFBMWV9UWVBFX1VTQiwKPiArCXBvcnQtPnBzeV9kZXNjLnVzYl90eXBlcyA9IHRjcG1fcHN5 X3VzYl90eXBlczsKPiArCXBvcnQtPnBzeV9kZXNjLm51bV91c2JfdHlwZXMgPSBBUlJBWV9TSVpF KHRjcG1fcHN5X3VzYl90eXBlcyk7Cj4gKwlwb3J0LT5wc3lfZGVzYy5wcm9wZXJ0aWVzID0gdGNw bV9wc3lfcHJvcHMsCj4gKwlwb3J0LT5wc3lfZGVzYy5udW1fcHJvcGVydGllcyA9IEFSUkFZX1NJ WkUodGNwbV9wc3lfcHJvcHMpLAo+ICsJcG9ydC0+cHN5X2Rlc2MuZ2V0X3Byb3BlcnR5ID0gdGNw bV9wc3lfZ2V0X3Byb3AsCj4gKwlwb3J0LT5wc3lfZGVzYy5zZXRfcHJvcGVydHkgPSB0Y3BtX3Bz eV9zZXRfcHJvcCwKPiArCXBvcnQtPnBzeV9kZXNjLnByb3BlcnR5X2lzX3dyaXRlYWJsZSA9IHRj cG1fcHN5X3Byb3Bfd3JpdGVhYmxlLAo+ICsKPiArCXBvcnQtPnVzYl90eXBlID0gUE9XRVJfU1VQ UExZX1VTQl9UWVBFX0M7Cj4gKwo+ICsJcG9ydC0+cHN5ID0gZGV2bV9wb3dlcl9zdXBwbHlfcmVn aXN0ZXIocG9ydC0+ZGV2LCAmcG9ydC0+cHN5X2Rlc2MsCj4gKwkJCQkJICAgICAgICZwc3lfY2Zn KTsKPiArCj4gKwlyZXR1cm4gUFRSX0VSUl9PUl9aRVJPKHBvcnQtPnBzeSk7Cj4gK30KPiArCj4g IHN0cnVjdCB0Y3BtX3BvcnQgKnRjcG1fcmVnaXN0ZXJfcG9ydChzdHJ1Y3QgZGV2aWNlICpkZXYs IHN0cnVjdCB0Y3BjX2RldiAqdGNwYykKPiAgewo+ICAJc3RydWN0IHRjcG1fcG9ydCAqcG9ydDsK PiBAQCAtNDIzNCw2ICs0NDczLDEwIEBAIHN0cnVjdCB0Y3BtX3BvcnQgKnRjcG1fcmVnaXN0ZXJf cG9ydChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCB0Y3BjX2RldiAqdGNwYykKPiAgCQlnb3Rv IG91dF9kZXN0cm95X3dxOwo+ICAJfQo+ICAKPiArCWVyciA9IGRldm1fdGNwbV9wc3lfcmVnaXN0 ZXIocG9ydCk7Cj4gKwlpZiAoZXJyKQo+ICsJCWdvdG8gb3V0X2Rlc3Ryb3lfd3E7Cj4gKwo+ICAJ cG9ydC0+dHlwZWNfcG9ydCA9IHR5cGVjX3JlZ2lzdGVyX3BvcnQocG9ydC0+ZGV2LCAmcG9ydC0+ dHlwZWNfY2Fwcyk7Cj4gIAlpZiAoSVNfRVJSKHBvcnQtPnR5cGVjX3BvcnQpKSB7Cj4gIAkJZXJy ID0gUFRSX0VSUihwb3J0LT50eXBlY19wb3J0KTsKPiAtLSAKPiAxLjkuMQo=