From mboxrd@z Thu Jan 1 00:00:00 1970 From: Heikki Krogerus Subject: Re: [PATCH v4 4/7] typec: tcpm: Add core support for sink side PPS Date: Tue, 30 Jan 2018 14:46:53 +0200 Message-ID: <20180130124653.GD14922@kuha.fi.intel.com> References: <26195a73c6f2f379b47dd39f23db9c2feec20371.1514904982.git.Adam.Thomson.Opensource@diasemi.com> Mime-Version: 1.0 Content-Type: text/plain; charset=us-ascii Return-path: Content-Disposition: inline In-Reply-To: <26195a73c6f2f379b47dd39f23db9c2feec20371.1514904982.git.Adam.Thomson.Opensource@diasemi.com> Sender: linux-kernel-owner@vger.kernel.org To: Adam Thomson Cc: Guenter Roeck , Greg Kroah-Hartman , Sebastian Reichel , Hans de Goede , Yueyao Zhu , Rui Miguel Silva , linux-usb@vger.kernel.org, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org, support.opensource@diasemi.com List-Id: linux-pm@vger.kernel.org On Tue, Jan 02, 2018 at 03:50:52PM +0000, Adam Thomson wrote: > This commit adds code to handle requesting of PPS APDOs. Switching > between standard PDOs and APDOs, and re-requesting an APDO to > modify operating voltage/current will be triggered by an > external call into TCPM. > > Signed-off-by: Adam Thomson > --- > drivers/usb/typec/tcpm.c | 533 ++++++++++++++++++++++++++++++++++++++++++++++- > include/linux/usb/pd.h | 4 +- > include/linux/usb/tcpm.h | 2 +- > 3 files changed, 525 insertions(+), 14 deletions(-) > > diff --git a/drivers/usb/typec/tcpm.c b/drivers/usb/typec/tcpm.c > index f4d563e..b66d26c 100644 > --- a/drivers/usb/typec/tcpm.c > +++ b/drivers/usb/typec/tcpm.c > @@ -47,6 +47,7 @@ > S(SNK_DISCOVERY_DEBOUNCE_DONE), \ > S(SNK_WAIT_CAPABILITIES), \ > S(SNK_NEGOTIATE_CAPABILITIES), \ > + S(SNK_NEGOTIATE_PPS_CAPABILITIES), \ > S(SNK_TRANSITION_SINK), \ > S(SNK_TRANSITION_SINK_VBUS), \ > S(SNK_READY), \ > @@ -166,6 +167,16 @@ struct pd_mode_data { > struct typec_altmode_desc altmode_desc[SVID_DISCOVERY_MAX]; > }; > > +struct pd_pps_data { > + u32 min_volt; > + u32 max_volt; > + u32 max_curr; > + u32 out_volt; > + u32 op_curr; > + bool supported; > + bool active; > +}; > + > struct tcpm_port { > struct device *dev; > > @@ -233,6 +244,7 @@ struct tcpm_port { > struct completion swap_complete; > int swap_status; > > + unsigned int negotiated_rev; > unsigned int message_id; > unsigned int caps_count; > unsigned int hard_reset_count; > @@ -255,6 +267,7 @@ struct tcpm_port { > unsigned int nr_fixed; /* number of fixed sink PDOs */ > unsigned int nr_var; /* number of variable sink PDOs */ > unsigned int nr_batt; /* number of battery sink PDOs */ > + unsigned int nr_apdo; /* number of APDO type PDOs */ > u32 snk_vdo[VDO_MAX_OBJECTS]; > unsigned int nr_snk_vdo; > > @@ -262,6 +275,7 @@ struct tcpm_port { > unsigned int max_snk_ma; > unsigned int max_snk_mw; > unsigned int operating_snk_mw; > + bool update_sink_caps; > > /* Requested current / voltage */ > u32 current_limit; > @@ -278,8 +292,13 @@ struct tcpm_port { > /* VDO to retry if UFP responder replied busy */ > u32 vdo_retry; > > - /* Alternate mode data */ > + /* PPS */ > + struct pd_pps_data pps_data; > + struct completion pps_complete; > + bool pps_pending; > + int pps_status; > > + /* Alternate mode data */ > struct pd_mode_data mode_data; > struct typec_altmode *partner_altmode[SVID_DISCOVERY_MAX]; > struct typec_altmode *port_altmode[SVID_DISCOVERY_MAX]; > @@ -497,6 +516,16 @@ static void tcpm_log_source_caps(struct tcpm_port *port) > pdo_max_voltage(pdo), > pdo_max_power(pdo)); > break; > + case PDO_TYPE_APDO: > + if (pdo_apdo_type(pdo) == APDO_TYPE_PPS) > + scnprintf(msg, sizeof(msg), > + "%u-%u mV, %u mA", > + pdo_pps_apdo_min_voltage(pdo), > + pdo_pps_apdo_max_voltage(pdo), > + pdo_pps_apdo_max_current(pdo)); > + else > + strcpy(msg, "undefined APDO"); > + break; > default: > strcpy(msg, "undefined"); > break; > @@ -791,11 +820,13 @@ static int tcpm_pd_send_source_caps(struct tcpm_port *port) > msg.header = PD_HEADER_LE(PD_CTRL_REJECT, > port->pwr_role, > port->data_role, > + port->negotiated_rev, > port->message_id, 0); > } else { > msg.header = PD_HEADER_LE(PD_DATA_SOURCE_CAP, > port->pwr_role, > port->data_role, > + port->negotiated_rev, > port->message_id, > port->nr_src_pdo); > } > @@ -816,11 +847,13 @@ static int tcpm_pd_send_sink_caps(struct tcpm_port *port) > msg.header = PD_HEADER_LE(PD_CTRL_REJECT, > port->pwr_role, > port->data_role, > + port->negotiated_rev, > port->message_id, 0); > } else { > msg.header = PD_HEADER_LE(PD_DATA_SINK_CAP, > port->pwr_role, > port->data_role, > + port->negotiated_rev, > port->message_id, > port->nr_snk_pdo); > } > @@ -1187,6 +1220,7 @@ static void vdm_run_state_machine(struct tcpm_port *port) > msg.header = PD_HEADER_LE(PD_DATA_VENDOR_DEF, > port->pwr_role, > port->data_role, > + port->negotiated_rev, > port->message_id, port->vdo_count); > for (i = 0; i < port->vdo_count; i++) > msg.payload[i] = cpu_to_le32(port->vdo_data[i]); > @@ -1258,6 +1292,8 @@ enum pdo_err { > PDO_ERR_FIXED_NOT_SORTED, > PDO_ERR_VARIABLE_BATT_NOT_SORTED, > PDO_ERR_DUPE_PDO, > + PDO_ERR_PPS_APDO_NOT_SORTED, > + PDO_ERR_DUPE_PPS_APDO, > }; > > static const char * const pdo_err_msg[] = { > @@ -1273,6 +1309,10 @@ enum pdo_err { > " err: Variable/Battery supply pdos should be in increasing order of their minimum voltage", > [PDO_ERR_DUPE_PDO] = > " err: Variable/Batt supply pdos cannot have same min/max voltage", > + [PDO_ERR_PPS_APDO_NOT_SORTED] = > + " err: Programmable power supply apdos should be in increasing order of their maximum voltage", > + [PDO_ERR_DUPE_PPS_APDO] = > + " err: Programmable power supply apdos cannot have same min/max voltage and max current", > }; > > static enum pdo_err tcpm_caps_err(struct tcpm_port *port, const u32 *pdo, > @@ -1322,6 +1362,26 @@ static enum pdo_err tcpm_caps_err(struct tcpm_port *port, const u32 *pdo, > pdo_min_voltage(pdo[i - 1]))) > return PDO_ERR_DUPE_PDO; > break; > + /* > + * The Programmable Power Supply APDOs, if present, > + * shall be sent in Maximum Voltage order; > + * lowest to highest. > + */ > + case PDO_TYPE_APDO: > + if (pdo_apdo_type(pdo[i]) != APDO_TYPE_PPS) > + break; > + > + if (pdo_pps_apdo_max_current(pdo[i]) < > + pdo_pps_apdo_max_current(pdo[i - 1])) > + return PDO_ERR_PPS_APDO_NOT_SORTED; > + else if ((pdo_pps_apdo_min_voltage(pdo[i]) == > + pdo_pps_apdo_min_voltage(pdo[i - 1])) && > + (pdo_pps_apdo_max_voltage(pdo[i]) == > + pdo_pps_apdo_max_voltage(pdo[i - 1])) && > + (pdo_pps_apdo_max_current(pdo[i]) == > + pdo_pps_apdo_max_current(pdo[i - 1]))) > + return PDO_ERR_DUPE_PPS_APDO; > + break; > default: > tcpm_log_force(port, " Unknown pdo type"); > } > @@ -1347,11 +1407,16 @@ static int tcpm_validate_caps(struct tcpm_port *port, const u32 *pdo, > /* > * PD (data, control) command handling functions > */ > + > +static int tcpm_pd_send_control(struct tcpm_port *port, > + enum pd_ctrl_msg_type type); > + > static void tcpm_pd_data_request(struct tcpm_port *port, > const struct pd_message *msg) > { > enum pd_data_msg_type type = pd_header_type_le(msg->header); > unsigned int cnt = pd_header_cnt_le(msg->header); > + unsigned int rev = pd_header_rev_le(msg->header); > unsigned int i; > > switch (type) { > @@ -1370,6 +1435,16 @@ static void tcpm_pd_data_request(struct tcpm_port *port, > port->nr_source_caps); > > /* > + * Adjust revision in subsequent message headers, as required, > + * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't > + * support Rev 1.0 so just do nothing in that scenario. > + */ > + if (rev == PD_REV10) > + break; > + else if (rev < PD_MAX_REV) > + port->negotiated_rev = rev; > + > + /* > * This message may be received even if VBUS is not > * present. This is quite unexpected; see USB PD > * specification, sections 8.3.3.6.3.1 and 8.3.3.6.3.2. > @@ -1390,6 +1465,19 @@ static void tcpm_pd_data_request(struct tcpm_port *port, > tcpm_queue_message(port, PD_MSG_CTRL_REJECT); > break; > } > + > + /* > + * Adjust revision in subsequent message headers, as required, > + * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't > + * support Rev 1.0 so just reject in that scenario. > + */ > + if (rev == PD_REV10) { > + tcpm_queue_message(port, PD_MSG_CTRL_REJECT); > + break; > + } else if (rev < PD_MAX_REV) { > + port->negotiated_rev = rev; > + } > + > port->sink_request = le32_to_cpu(msg->payload[0]); > tcpm_set_state(port, SRC_NEGOTIATE_CAPABILITIES, 0); > break; > @@ -1414,6 +1502,15 @@ static void tcpm_pd_data_request(struct tcpm_port *port, > } > } > > +static void tcpm_pps_complete(struct tcpm_port *port, int result) > +{ > + if (port->pps_pending) { > + port->pps_status = result; > + port->pps_pending = false; > + complete(&port->pps_complete); > + } > +} > + > static void tcpm_pd_ctrl_request(struct tcpm_port *port, > const struct pd_message *msg) > { > @@ -1490,6 +1587,14 @@ static void tcpm_pd_ctrl_request(struct tcpm_port *port, > next_state = SNK_WAIT_CAPABILITIES; > tcpm_set_state(port, next_state, 0); > break; > + case SNK_NEGOTIATE_PPS_CAPABILITIES: > + /* Revert data back from any requested PPS updates */ > + port->pps_data.out_volt = port->supply_voltage; > + port->pps_data.op_curr = port->current_limit; > + port->pps_status = (type == PD_CTRL_WAIT ? > + -EAGAIN : -EOPNOTSUPP); > + tcpm_set_state(port, SNK_READY, 0); > + break; > case DR_SWAP_SEND: > port->swap_status = (type == PD_CTRL_WAIT ? > -EAGAIN : -EOPNOTSUPP); > @@ -1512,6 +1617,13 @@ static void tcpm_pd_ctrl_request(struct tcpm_port *port, > case PD_CTRL_ACCEPT: > switch (port->state) { > case SNK_NEGOTIATE_CAPABILITIES: > + port->pps_data.active = false; > + tcpm_set_state(port, SNK_TRANSITION_SINK, 0); > + break; > + case SNK_NEGOTIATE_PPS_CAPABILITIES: > + port->pps_data.active = true; > + port->supply_voltage = port->pps_data.out_volt; > + port->current_limit = port->pps_data.op_curr; > tcpm_set_state(port, SNK_TRANSITION_SINK, 0); > break; > case SOFT_RESET_SEND: > @@ -1666,6 +1778,7 @@ static int tcpm_pd_send_control(struct tcpm_port *port, > memset(&msg, 0, sizeof(msg)); > msg.header = PD_HEADER_LE(type, port->pwr_role, > port->data_role, > + port->negotiated_rev, > port->message_id, 0); > > return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); > @@ -1779,6 +1892,8 @@ static int tcpm_pd_select_pdo(struct tcpm_port *port, int *sink_pdo, > unsigned int i, j, max_mw = 0, max_mv = 0, mw = 0, mv = 0, ma = 0; > int ret = -EINVAL; > > + port->pps_data.supported = false; > + > /* > * Select the source PDO providing the most power which has a > * matchig sink cap. > @@ -1787,7 +1902,8 @@ static int tcpm_pd_select_pdo(struct tcpm_port *port, int *sink_pdo, > u32 pdo = port->source_caps[i]; > enum pd_pdo_type type = pdo_type(pdo); > > - if (type == PDO_TYPE_FIXED) { > + switch (type) { > + case PDO_TYPE_FIXED: > for (j = 0; j < port->nr_fixed; j++) { > if (pdo_fixed_voltage(pdo) == > pdo_fixed_voltage(port->snk_pdo[j])) { > @@ -1809,7 +1925,8 @@ static int tcpm_pd_select_pdo(struct tcpm_port *port, int *sink_pdo, > break; > } > } > - } else if (type == PDO_TYPE_BATT) { > + break; > + case PDO_TYPE_BATT: > for (j = port->nr_fixed; > j < port->nr_fixed + > port->nr_batt; > @@ -1830,7 +1947,8 @@ static int tcpm_pd_select_pdo(struct tcpm_port *port, int *sink_pdo, > } > } > } > - } else if (type == PDO_TYPE_VAR) { > + break; > + case PDO_TYPE_VAR: > for (j = port->nr_fixed + > port->nr_batt; > j < port->nr_fixed + > @@ -1854,12 +1972,98 @@ static int tcpm_pd_select_pdo(struct tcpm_port *port, int *sink_pdo, > } > } > } > + break; > + case PDO_TYPE_APDO: > + if (pdo_apdo_type(pdo) == APDO_TYPE_PPS) > + port->pps_data.supported = true; > + continue; > + default: > + tcpm_log(port, "Invalid PDO type, ignoring"); > + continue; > } > } > > return ret; > } > > +#define min_pps_apdo_current(x, y) \ > + min(pdo_pps_apdo_max_current(x), pdo_pps_apdo_max_current(y)) > + > +static unsigned int tcpm_pd_select_pps_apdo(struct tcpm_port *port, > + int *snk_pdo, int *src_pdo) > +{ > + unsigned int i, j, max_mw = 0, max_mv = 0, mw = 0, mv = 0, ma = 0; > + enum pd_pdo_type type; > + u32 pdo; > + int ret = -EOPNOTSUPP; > + > + /* > + * Select the source PPS APDO providing the most power while staying > + * within the board's limits. We skip the first PDO as this is always > + * 5V 3A. > + */ > + *src_pdo = 0; > + for (i = 1; i < port->nr_source_caps; ++i) { > + pdo = port->source_caps[i]; > + type = pdo_type(pdo); > + > + switch (type) { > + case PDO_TYPE_APDO: > + if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) { > + tcpm_log(port, "Not PPS APDO, ignoring"); > + continue; > + } > + > + for (j = port->nr_fixed + > + port->nr_batt + > + port->nr_var; > + j < port->nr_fixed + > + port->nr_batt + > + port->nr_var + > + port->nr_apdo; > + ++j) { > + if ((pdo_pps_apdo_min_voltage(pdo) >= > + pdo_pps_apdo_min_voltage(port->snk_pdo[j])) && > + (pdo_pps_apdo_max_voltage(pdo) <= > + pdo_pps_apdo_max_voltage(port->snk_pdo[j]))) { > + ma = min_pps_apdo_current(pdo, > + port->snk_pdo[j]); > + mv = pdo_pps_apdo_max_voltage(pdo); > + mw = (ma * mv) / 1000; > + if ((mw > max_mw) || > + ((mw == max_mw) && (mv > max_mv))) { > + ret = 0; > + *src_pdo = i; > + *snk_pdo = j; > + max_mw = mw; > + max_mv = mv; > + } > + } > + } > + > + break; > + default: > + tcpm_log(port, "Not APDO type, ignoring"); > + continue; > + } > + } > + > + if (*src_pdo > 0) { > + pdo = port->source_caps[*src_pdo]; > + > + port->pps_data.min_volt = pdo_pps_apdo_min_voltage(pdo); > + port->pps_data.max_volt = pdo_pps_apdo_max_voltage(pdo); > + port->pps_data.max_curr = > + min_pps_apdo_current(pdo, port->snk_pdo[*snk_pdo]); > + port->pps_data.out_volt = > + min(port->pps_data.out_volt, pdo_pps_apdo_max_voltage(pdo)); > + port->pps_data.op_curr = > + min(port->pps_data.op_curr, pdo_pps_apdo_max_current(pdo)); > + } > + > + return ret; > +} > + > static int tcpm_pd_build_request(struct tcpm_port *port, u32 *rdo) > { > unsigned int mv, ma, mw, flags; > @@ -1875,10 +2079,18 @@ static int tcpm_pd_build_request(struct tcpm_port *port, u32 *rdo) > matching_snk_pdo = port->snk_pdo[snk_pdo_index]; > type = pdo_type(pdo); > > - if (type == PDO_TYPE_FIXED) > + switch (type) { > + case PDO_TYPE_FIXED: > mv = pdo_fixed_voltage(pdo); > - else > + break; > + case PDO_TYPE_BATT: > + case PDO_TYPE_VAR: > mv = pdo_min_voltage(pdo); > + break; > + default: > + tcpm_log(port, "Invalid PDO selected!"); > + return -EINVAL; > + } > > /* Select maximum available current within the sink pdo's limit */ > if (type == PDO_TYPE_BATT) { > @@ -1943,6 +2155,107 @@ static int tcpm_pd_send_request(struct tcpm_port *port) > msg.header = PD_HEADER_LE(PD_DATA_REQUEST, > port->pwr_role, > port->data_role, > + port->negotiated_rev, > + port->message_id, 1); > + msg.payload[0] = cpu_to_le32(rdo); > + > + return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg); > +} > + > +static int tcpm_pd_build_pps_request(struct tcpm_port *port, u32 *rdo) > +{ > + unsigned int out_mv, op_ma, op_mw, min_mv, max_mv, max_ma, flags; > + enum pd_pdo_type type; > + int src_pdo_index, snk_pdo_index; > + u32 pdo, matching_snk_pdo; > + int ret; > + > + ret = tcpm_pd_select_pps_apdo(port, &snk_pdo_index, &src_pdo_index); > + if (ret) > + return ret; > + > + pdo = port->source_caps[src_pdo_index]; > + matching_snk_pdo = port->snk_pdo[snk_pdo_index]; > + type = pdo_type(pdo); > + > + switch (type) { > + case PDO_TYPE_APDO: > + if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) { > + tcpm_log(port, "Invalid APDO selected!"); > + return -EINVAL; > + } > + min_mv = pdo_pps_apdo_min_voltage(pdo); > + max_mv = pdo_pps_apdo_max_voltage(pdo); > + max_ma = pdo_pps_apdo_max_current(pdo); > + out_mv = port->pps_data.out_volt; > + op_ma = port->pps_data.op_curr; > + break; > + default: > + tcpm_log(port, "Invalid PDO selected!"); > + return -EINVAL; > + } > + > + flags = RDO_USB_COMM | RDO_NO_SUSPEND; > + > + op_mw = (op_ma * out_mv) / 1000; > + if (op_mw < port->operating_snk_mw) { > + /* > + * Try raising current to meet power needs. If that's not enough > + * then try upping the voltage. If that's still not enoguh > + * then we've obviously chosen a PPS APDO which really isn't > + * suitable so abandon ship. > + */ > + op_ma = ((port->operating_snk_mw * 1000) / out_mv); > + if ((port->operating_snk_mw * 1000) % out_mv) > + ++op_ma; > + op_ma += RDO_PROG_CURR_MA_STEP - (op_ma % RDO_PROG_CURR_MA_STEP); > + > + if (op_ma > max_ma) { > + op_ma = max_ma; > + out_mv = ((port->operating_snk_mw * 1000) / op_ma); > + if ((port->operating_snk_mw * 1000) % op_ma) > + ++out_mv; > + out_mv += RDO_PROG_VOLT_MV_STEP - > + (out_mv % RDO_PROG_VOLT_MV_STEP); > + > + if (out_mv > max_mv) { > + tcpm_log(port, "Invalid PPS APDO selected!"); > + return -EINVAL; > + } > + } > + } > + > + tcpm_log(port, "cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d", > + port->cc_req, port->cc1, port->cc2, port->vbus_source, > + port->vconn_role == TYPEC_SOURCE ? "source" : "sink", > + port->polarity); > + > + *rdo = RDO_PROG(src_pdo_index + 1, out_mv, op_ma, flags); > + > + tcpm_log(port, "Requesting APDO %d: %u mV, %u mA", > + src_pdo_index, out_mv, op_ma); > + > + port->pps_data.op_curr = op_ma; > + port->pps_data.out_volt = out_mv; > + > + return 0; > +} > + > +static int tcpm_pd_send_pps_request(struct tcpm_port *port) > +{ > + struct pd_message msg; > + int ret; > + u32 rdo; > + > + ret = tcpm_pd_build_pps_request(port, &rdo); > + if (ret < 0) > + return ret; > + > + memset(&msg, 0, sizeof(msg)); > + msg.header = PD_HEADER_LE(PD_DATA_REQUEST, > + port->pwr_role, > + port->data_role, > + port->negotiated_rev, > port->message_id, 1); > msg.payload[0] = cpu_to_le32(rdo); > > @@ -2128,6 +2441,7 @@ static void tcpm_reset_port(struct tcpm_port *port) > tcpm_typec_disconnect(port); > port->attached = false; > port->pd_capable = false; > + port->pps_data.supported = false; > > /* > * First Rx ID should be 0; set this to a sentinel of -1 so that > @@ -2143,6 +2457,8 @@ static void tcpm_reset_port(struct tcpm_port *port) > tcpm_set_attached_state(port, false); > port->try_src_count = 0; > port->try_snk_count = 0; > + port->supply_voltage = 0; > + port->current_limit = 0; > } > > static void tcpm_detach(struct tcpm_port *port) > @@ -2389,6 +2705,7 @@ static void run_state_machine(struct tcpm_port *port) > typec_set_pwr_opmode(port->typec_port, opmode); > port->pwr_opmode = TYPEC_PWR_MODE_USB; > port->caps_count = 0; > + port->negotiated_rev = PD_MAX_REV; > port->message_id = 0; > port->rx_msgid = -1; > port->explicit_contract = false; > @@ -2449,6 +2766,7 @@ static void run_state_machine(struct tcpm_port *port) > > tcpm_swap_complete(port, 0); > tcpm_typec_connect(port); > + > tcpm_check_send_discover(port); > /* > * 6.3.5 > @@ -2472,6 +2790,7 @@ static void run_state_machine(struct tcpm_port *port) > case SNK_UNATTACHED: > if (!port->non_pd_role_swap) > tcpm_swap_complete(port, -ENOTCONN); > + tcpm_pps_complete(port, -ENOTCONN); > tcpm_snk_detach(port); > if (tcpm_start_drp_toggling(port)) { > tcpm_set_state(port, DRP_TOGGLING, 0); > @@ -2480,6 +2799,7 @@ static void run_state_machine(struct tcpm_port *port) > tcpm_set_cc(port, TYPEC_CC_RD); > if (port->port_type == TYPEC_PORT_DRP) > tcpm_set_state(port, SRC_UNATTACHED, PD_T_DRP_SRC); > + > break; > case SNK_ATTACH_WAIT: > if ((port->cc1 == TYPEC_CC_OPEN && > @@ -2561,6 +2881,7 @@ static void run_state_machine(struct tcpm_port *port) > port->cc2 : port->cc1); > typec_set_pwr_opmode(port->typec_port, opmode); > port->pwr_opmode = TYPEC_PWR_MODE_USB; > + port->negotiated_rev = PD_MAX_REV; > port->message_id = 0; > port->rx_msgid = -1; > port->explicit_contract = false; > @@ -2631,6 +2952,24 @@ static void run_state_machine(struct tcpm_port *port) > PD_T_SENDER_RESPONSE); > } > break; > + case SNK_NEGOTIATE_PPS_CAPABILITIES: > + ret = tcpm_pd_send_pps_request(port); > + if (ret < 0) { > + port->pps_status = ret; > + /* > + * If this was called due to updates to sink > + * capabilities, and pps is no longer valid, we should > + * safely fall back to a standard PDO. > + */ > + if (port->update_sink_caps) > + tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0); > + else > + tcpm_set_state(port, SNK_READY, 0); > + } else { > + tcpm_set_state_cond(port, hard_reset_state(port), > + PD_T_SENDER_RESPONSE); > + } > + break; > case SNK_TRANSITION_SINK: > case SNK_TRANSITION_SINK_VBUS: > tcpm_set_state(port, hard_reset_state(port), > @@ -2638,6 +2977,7 @@ static void run_state_machine(struct tcpm_port *port) > break; > case SNK_READY: > port->try_snk_count = 0; > + port->update_sink_caps = false; > if (port->explicit_contract) { > typec_set_pwr_opmode(port->typec_port, > TYPEC_PWR_MODE_PD); > @@ -2646,7 +2986,11 @@ static void run_state_machine(struct tcpm_port *port) > > tcpm_swap_complete(port, 0); > tcpm_typec_connect(port); > + > tcpm_check_send_discover(port); > + > + tcpm_pps_complete(port, port->pps_status); > + > break; > > /* Accessory states */ > @@ -2693,6 +3037,7 @@ static void run_state_machine(struct tcpm_port *port) > tcpm_set_state(port, SRC_UNATTACHED, PD_T_PS_SOURCE_ON); > break; > case SNK_HARD_RESET_SINK_OFF: > + memset(&port->pps_data, 0, sizeof(port->pps_data)); > tcpm_set_vconn(port, false); > tcpm_set_charge(port, false); > tcpm_set_roles(port, false, TYPEC_SINK, TYPEC_DEVICE); > @@ -2913,6 +3258,7 @@ static void run_state_machine(struct tcpm_port *port) > break; > case ERROR_RECOVERY: > tcpm_swap_complete(port, -EPROTO); > + tcpm_pps_complete(port, -EPROTO); > tcpm_set_state(port, PORT_RESET, 0); > break; > case PORT_RESET: > @@ -3378,7 +3724,7 @@ static int tcpm_dr_set(const struct typec_capability *cap, > mutex_unlock(&port->lock); > > if (!wait_for_completion_timeout(&port->swap_complete, > - msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT))) > + msecs_to_jiffies(PD_STATE_MACHINE_TIMEOUT))) > ret = -ETIMEDOUT; > else > ret = port->swap_status; > @@ -3423,7 +3769,7 @@ static int tcpm_pr_set(const struct typec_capability *cap, > mutex_unlock(&port->lock); > > if (!wait_for_completion_timeout(&port->swap_complete, > - msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT))) > + msecs_to_jiffies(PD_STATE_MACHINE_TIMEOUT))) > ret = -ETIMEDOUT; > else > ret = port->swap_status; > @@ -3463,7 +3809,7 @@ static int tcpm_vconn_set(const struct typec_capability *cap, > mutex_unlock(&port->lock); > > if (!wait_for_completion_timeout(&port->swap_complete, > - msecs_to_jiffies(PD_ROLE_SWAP_TIMEOUT))) > + msecs_to_jiffies(PD_STATE_MACHINE_TIMEOUT))) > ret = -ETIMEDOUT; > else > ret = port->swap_status; > @@ -3495,6 +3841,162 @@ static int tcpm_try_role(const struct typec_capability *cap, int role) > return ret; > } > > +static int tcpm_pps_set_op_curr(struct tcpm_port *port, u16 op_curr) > +{ > + unsigned int target_mw; > + int ret = 0; > + > + mutex_lock(&port->swap_lock); > + mutex_lock(&port->lock); > + > + if (!port->pps_data.active) { > + ret = -EOPNOTSUPP; > + goto port_unlock; > + } > + > + if (port->state != SNK_READY) { > + ret = -EAGAIN; > + goto port_unlock; > + } > + > + if (op_curr > port->pps_data.max_curr) { > + ret = -EINVAL; > + goto port_unlock; > + } > + > + target_mw = (op_curr * port->pps_data.out_volt) / 1000; > + if (target_mw < port->operating_snk_mw) { > + ret = -EINVAL; > + goto port_unlock; > + } > + > + reinit_completion(&port->pps_complete); > + port->pps_data.op_curr = op_curr; > + port->pps_status = 0; > + port->pps_pending = true; > + tcpm_set_state(port, SNK_NEGOTIATE_PPS_CAPABILITIES, 0); Why not just take the swap_lock here.. > + mutex_unlock(&port->lock); > + > + if (!wait_for_completion_timeout(&port->pps_complete, > + msecs_to_jiffies(PD_STATE_MACHINE_TIMEOUT))) > + ret = -ETIMEDOUT; > + else > + ret = port->pps_status; > + > + goto swap_unlock; and you don't need that goto.. > +port_unlock: > + mutex_unlock(&port->lock); > +swap_unlock: > + mutex_unlock(&port->swap_lock); and this becomes.. mutex_unlock(&port->swap_lock); return ret; port_unlock: mutex_unlock(&port->lock); return ret; > + return ret; > +} > + > +static int tcpm_pps_set_out_volt(struct tcpm_port *port, u16 out_volt) > +{ > + unsigned int target_mw; > + int ret = 0; > + > + mutex_lock(&port->swap_lock); > + mutex_lock(&port->lock); > + > + if (!port->pps_data.active) { > + ret = -EOPNOTSUPP; > + goto port_unlock; Or, on top of what I said above, you could actually consider releasing the port lock here and just returning. Then you would not need those port_unlock and swap_unlock labels at all.. mutex_unlock(&port->lock); return -EOPNOTSUPP; > + } > + > + if (port->state != SNK_READY) { > + ret = -EAGAIN; > + goto port_unlock; mutex_unlock(&port->lock); return -EAGAIN; > + } > + > + if ((out_volt < port->pps_data.min_volt) || > + (out_volt > port->pps_data.max_volt)) { > + ret = -EINVAL; > + goto port_unlock; mutex_unlock(&port->lock); return -EINVAL; > + } > + > + target_mw = (port->pps_data.op_curr * out_volt) / 1000; > + if (target_mw < port->operating_snk_mw) { > + ret = -EINVAL; > + goto port_unlock; mutex_unlock(&port->lock); return -EINVAL; > + } > + > + reinit_completion(&port->pps_complete); > + port->pps_data.out_volt = out_volt; > + port->pps_status = 0; > + port->pps_pending = true; > + tcpm_set_state(port, SNK_NEGOTIATE_PPS_CAPABILITIES, 0); mutex_lock(&port->swap_lock); > + mutex_unlock(&port->lock); > + > + if (!wait_for_completion_timeout(&port->pps_complete, > + msecs_to_jiffies(PD_STATE_MACHINE_TIMEOUT))) > + ret = -ETIMEDOUT; > + else > + ret = port->pps_status; mutex_unlock(&port->swap_lock); return ret; > + goto swap_unlock; > + > +port_unlock: > + mutex_unlock(&port->lock); > +swap_unlock: > + mutex_unlock(&port->swap_lock); > + > + return ret; > +} > + > +static int tcpm_pps_activate(struct tcpm_port *port, bool activate) > +{ > + int ret = 0; > + > + mutex_lock(&port->swap_lock); > + mutex_lock(&port->lock); > + > + if (!port->pps_data.supported) { > + ret = -EOPNOTSUPP; > + goto port_unlock; > + } > + > + /* Trying to deactivate PPS when already deactivated so just bail */ > + if ((!port->pps_data.active) && (!activate)) > + goto port_unlock; > + > + if (port->state != SNK_READY) { > + ret = -EAGAIN; > + goto port_unlock; > + } > + > + reinit_completion(&port->pps_complete); > + port->pps_status = 0; > + port->pps_pending = true; > + > + /* Trigger PPS request or move back to standard PDO contract */ > + if (activate) { > + port->pps_data.out_volt = port->supply_voltage; > + port->pps_data.op_curr = port->current_limit; > + tcpm_set_state(port, SNK_NEGOTIATE_PPS_CAPABILITIES, 0); > + } else { > + tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0); > + } > + mutex_unlock(&port->lock); > + > + if (!wait_for_completion_timeout(&port->pps_complete, > + msecs_to_jiffies(PD_STATE_MACHINE_TIMEOUT))) > + ret = -ETIMEDOUT; > + else > + ret = port->pps_status; > + > + goto swap_unlock; > + > +port_unlock: > + mutex_unlock(&port->lock); > +swap_unlock: > + mutex_unlock(&port->swap_lock); You can do the same as above here as well. > + return ret; > +} > + > static void tcpm_init(struct tcpm_port *port) > { > enum typec_cc_status cc1, cc2; > @@ -3634,13 +4136,18 @@ int tcpm_update_sink_capabilities(struct tcpm_port *port, const u32 *pdo, > port->max_snk_ma = max_snk_ma; > port->max_snk_mw = max_snk_mw; > port->operating_snk_mw = operating_snk_mw; > + port->update_sink_caps = true; > > switch (port->state) { > case SNK_NEGOTIATE_CAPABILITIES: > + case SNK_NEGOTIATE_PPS_CAPABILITIES: > case SNK_READY: > case SNK_TRANSITION_SINK: > case SNK_TRANSITION_SINK_VBUS: > - tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0); > + if (port->pps_data.active) > + tcpm_set_state(port, SNK_NEGOTIATE_PPS_CAPABILITIES, 0); > + else > + tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0); > break; > default: > break; > @@ -3695,6 +4202,7 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) > > init_completion(&port->tx_complete); > init_completion(&port->swap_complete); > + init_completion(&port->pps_complete); > tcpm_debugfs_init(port); > > if (tcpm_validate_caps(port, tcpc->config->src_pdo, > @@ -3717,6 +4225,9 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) > port->nr_batt = nr_type_pdos(port->snk_pdo, > port->nr_snk_pdo, > PDO_TYPE_BATT); > + port->nr_apdo = nr_type_pdos(port->snk_pdo, > + port->nr_snk_pdo, > + PDO_TYPE_APDO); > port->nr_snk_vdo = tcpm_copy_vdos(port->snk_vdo, tcpc->config->snk_vdo, > tcpc->config->nr_snk_vdo); > > @@ -3732,7 +4243,7 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc) > port->typec_caps.prefer_role = tcpc->config->default_role; > port->typec_caps.type = tcpc->config->type; > port->typec_caps.revision = 0x0120; /* Type-C spec release 1.2 */ > - port->typec_caps.pd_revision = 0x0200; /* USB-PD spec release 2.0 */ > + port->typec_caps.pd_revision = 0x0300; /* USB-PD spec release 3.0 */ > port->typec_caps.dr_set = tcpm_dr_set; > port->typec_caps.pr_set = tcpm_pr_set; > port->typec_caps.vconn_set = tcpm_vconn_set; > diff --git a/include/linux/usb/pd.h b/include/linux/usb/pd.h > index ff359bdf..09b570f 100644 > --- a/include/linux/usb/pd.h > +++ b/include/linux/usb/pd.h > @@ -103,8 +103,8 @@ enum pd_ext_msg_type { > (((cnt) & PD_HEADER_CNT_MASK) << PD_HEADER_CNT_SHIFT) | \ > ((ext_hdr) ? PD_HEADER_EXT_HDR : 0)) > > -#define PD_HEADER_LE(type, pwr, data, id, cnt) \ > - cpu_to_le16(PD_HEADER((type), (pwr), (data), PD_REV20, (id), (cnt), (0))) > +#define PD_HEADER_LE(type, pwr, data, rev, id, cnt) \ > + cpu_to_le16(PD_HEADER((type), (pwr), (data), (rev), (id), (cnt), (0))) > > static inline unsigned int pd_header_cnt(u16 header) > { > diff --git a/include/linux/usb/tcpm.h b/include/linux/usb/tcpm.h > index ca1c0b5..d6673f7 100644 > --- a/include/linux/usb/tcpm.h > +++ b/include/linux/usb/tcpm.h > @@ -35,7 +35,7 @@ enum typec_cc_polarity { > > /* Time to wait for TCPC to complete transmit */ > #define PD_T_TCPC_TX_TIMEOUT 100 /* in ms */ > -#define PD_ROLE_SWAP_TIMEOUT (MSEC_PER_SEC * 10) > +#define PD_STATE_MACHINE_TIMEOUT (MSEC_PER_SEC * 10) > > enum tcpm_transmit_status { > TCPC_TX_SUCCESS = 0, > -- > 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: [v4,4/7] typec: tcpm: Add core support for sink side PPS From: Heikki Krogerus Message-Id: <20180130124653.GD14922@kuha.fi.intel.com> Date: Tue, 30 Jan 2018 14:46:53 +0200 To: Adam Thomson Cc: Guenter Roeck , Greg Kroah-Hartman , Sebastian Reichel , Hans de Goede , Yueyao Zhu , Rui Miguel Silva , linux-usb@vger.kernel.org, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org, support.opensource@diasemi.com List-ID: T24gVHVlLCBKYW4gMDIsIDIwMTggYXQgMDM6NTA6NTJQTSArMDAwMCwgQWRhbSBUaG9tc29uIHdy b3RlOgo+IFRoaXMgY29tbWl0IGFkZHMgY29kZSB0byBoYW5kbGUgcmVxdWVzdGluZyBvZiBQUFMg QVBET3MuIFN3aXRjaGluZwo+IGJldHdlZW4gc3RhbmRhcmQgUERPcyBhbmQgQVBET3MsIGFuZCBy ZS1yZXF1ZXN0aW5nIGFuIEFQRE8gdG8KPiBtb2RpZnkgb3BlcmF0aW5nIHZvbHRhZ2UvY3VycmVu dCB3aWxsIGJlIHRyaWdnZXJlZCBieSBhbgo+IGV4dGVybmFsIGNhbGwgaW50byBUQ1BNLgo+IAo+ IFNpZ25lZC1vZmYtYnk6IEFkYW0gVGhvbXNvbiA8QWRhbS5UaG9tc29uLk9wZW5zb3VyY2VAZGlh c2VtaS5jb20+Cj4gLS0tCj4gIGRyaXZlcnMvdXNiL3R5cGVjL3RjcG0uYyB8IDUzMyArKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLQo+ICBpbmNsdWRlL2xpbnV4 L3VzYi9wZC5oICAgfCAgIDQgKy0KPiAgaW5jbHVkZS9saW51eC91c2IvdGNwbS5oIHwgICAyICst Cj4gIDMgZmlsZXMgY2hhbmdlZCwgNTI1IGluc2VydGlvbnMoKyksIDE0IGRlbGV0aW9ucygtKQo+ IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi90eXBlYy90Y3BtLmMgYi9kcml2ZXJzL3VzYi90 eXBlYy90Y3BtLmMKPiBpbmRleCBmNGQ1NjNlLi5iNjZkMjZjIDEwMDY0NAo+IC0tLSBhL2RyaXZl cnMvdXNiL3R5cGVjL3RjcG0uYwo+ICsrKyBiL2RyaXZlcnMvdXNiL3R5cGVjL3RjcG0uYwo+IEBA IC00Nyw2ICs0Nyw3IEBACj4gIAlTKFNOS19ESVNDT1ZFUllfREVCT1VOQ0VfRE9ORSksCQlcCj4g IAlTKFNOS19XQUlUX0NBUEFCSUxJVElFUyksCQlcCj4gIAlTKFNOS19ORUdPVElBVEVfQ0FQQUJJ TElUSUVTKSwJCVwKPiArCVMoU05LX05FR09USUFURV9QUFNfQ0FQQUJJTElUSUVTKSwJXAo+ICAJ UyhTTktfVFJBTlNJVElPTl9TSU5LKSwJCQlcCj4gIAlTKFNOS19UUkFOU0lUSU9OX1NJTktfVkJV UyksCQlcCj4gIAlTKFNOS19SRUFEWSksCQkJCVwKPiBAQCAtMTY2LDYgKzE2NywxNiBAQCBzdHJ1 Y3QgcGRfbW9kZV9kYXRhIHsKPiAgCXN0cnVjdCB0eXBlY19hbHRtb2RlX2Rlc2MgYWx0bW9kZV9k ZXNjW1NWSURfRElTQ09WRVJZX01BWF07Cj4gIH07Cj4gIAo+ICtzdHJ1Y3QgcGRfcHBzX2RhdGEg ewo+ICsJdTMyIG1pbl92b2x0Owo+ICsJdTMyIG1heF92b2x0Owo+ICsJdTMyIG1heF9jdXJyOwo+ ICsJdTMyIG91dF92b2x0Owo+ICsJdTMyIG9wX2N1cnI7Cj4gKwlib29sIHN1cHBvcnRlZDsKPiAr CWJvb2wgYWN0aXZlOwo+ICt9Owo+ICsKPiAgc3RydWN0IHRjcG1fcG9ydCB7Cj4gIAlzdHJ1Y3Qg ZGV2aWNlICpkZXY7Cj4gIAo+IEBAIC0yMzMsNiArMjQ0LDcgQEAgc3RydWN0IHRjcG1fcG9ydCB7 Cj4gIAlzdHJ1Y3QgY29tcGxldGlvbiBzd2FwX2NvbXBsZXRlOwo+ICAJaW50IHN3YXBfc3RhdHVz Owo+ICAKPiArCXVuc2lnbmVkIGludCBuZWdvdGlhdGVkX3JldjsKPiAgCXVuc2lnbmVkIGludCBt ZXNzYWdlX2lkOwo+ICAJdW5zaWduZWQgaW50IGNhcHNfY291bnQ7Cj4gIAl1bnNpZ25lZCBpbnQg aGFyZF9yZXNldF9jb3VudDsKPiBAQCAtMjU1LDYgKzI2Nyw3IEBAIHN0cnVjdCB0Y3BtX3BvcnQg ewo+ICAJdW5zaWduZWQgaW50IG5yX2ZpeGVkOyAvKiBudW1iZXIgb2YgZml4ZWQgc2luayBQRE9z ICovCj4gIAl1bnNpZ25lZCBpbnQgbnJfdmFyOyAvKiBudW1iZXIgb2YgdmFyaWFibGUgc2luayBQ RE9zICovCj4gIAl1bnNpZ25lZCBpbnQgbnJfYmF0dDsgLyogbnVtYmVyIG9mIGJhdHRlcnkgc2lu ayBQRE9zICovCj4gKwl1bnNpZ25lZCBpbnQgbnJfYXBkbzsgLyogbnVtYmVyIG9mIEFQRE8gdHlw ZSBQRE9zICovCj4gIAl1MzIgc25rX3Zkb1tWRE9fTUFYX09CSkVDVFNdOwo+ICAJdW5zaWduZWQg aW50IG5yX3Nua192ZG87Cj4gIAo+IEBAIC0yNjIsNiArMjc1LDcgQEAgc3RydWN0IHRjcG1fcG9y dCB7Cj4gIAl1bnNpZ25lZCBpbnQgbWF4X3Nua19tYTsKPiAgCXVuc2lnbmVkIGludCBtYXhfc25r X213Owo+ICAJdW5zaWduZWQgaW50IG9wZXJhdGluZ19zbmtfbXc7Cj4gKwlib29sIHVwZGF0ZV9z aW5rX2NhcHM7Cj4gIAo+ICAJLyogUmVxdWVzdGVkIGN1cnJlbnQgLyB2b2x0YWdlICovCj4gIAl1 MzIgY3VycmVudF9saW1pdDsKPiBAQCAtMjc4LDggKzI5MiwxMyBAQCBzdHJ1Y3QgdGNwbV9wb3J0 IHsKPiAgCS8qIFZETyB0byByZXRyeSBpZiBVRlAgcmVzcG9uZGVyIHJlcGxpZWQgYnVzeSAqLwo+ ICAJdTMyIHZkb19yZXRyeTsKPiAgCj4gLQkvKiBBbHRlcm5hdGUgbW9kZSBkYXRhICovCj4gKwkv KiBQUFMgKi8KPiArCXN0cnVjdCBwZF9wcHNfZGF0YSBwcHNfZGF0YTsKPiArCXN0cnVjdCBjb21w bGV0aW9uIHBwc19jb21wbGV0ZTsKPiArCWJvb2wgcHBzX3BlbmRpbmc7Cj4gKwlpbnQgcHBzX3N0 YXR1czsKPiAgCj4gKwkvKiBBbHRlcm5hdGUgbW9kZSBkYXRhICovCj4gIAlzdHJ1Y3QgcGRfbW9k ZV9kYXRhIG1vZGVfZGF0YTsKPiAgCXN0cnVjdCB0eXBlY19hbHRtb2RlICpwYXJ0bmVyX2FsdG1v ZGVbU1ZJRF9ESVNDT1ZFUllfTUFYXTsKPiAgCXN0cnVjdCB0eXBlY19hbHRtb2RlICpwb3J0X2Fs dG1vZGVbU1ZJRF9ESVNDT1ZFUllfTUFYXTsKPiBAQCAtNDk3LDYgKzUxNiwxNiBAQCBzdGF0aWMg dm9pZCB0Y3BtX2xvZ19zb3VyY2VfY2FwcyhzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0KQo+ICAJCQkJ ICBwZG9fbWF4X3ZvbHRhZ2UocGRvKSwKPiAgCQkJCSAgcGRvX21heF9wb3dlcihwZG8pKTsKPiAg CQkJYnJlYWs7Cj4gKwkJY2FzZSBQRE9fVFlQRV9BUERPOgo+ICsJCQlpZiAocGRvX2FwZG9fdHlw ZShwZG8pID09IEFQRE9fVFlQRV9QUFMpCj4gKwkJCQlzY25wcmludGYobXNnLCBzaXplb2YobXNn KSwKPiArCQkJCQkgICIldS0ldSBtViwgJXUgbUEiLAo+ICsJCQkJCSAgcGRvX3Bwc19hcGRvX21p bl92b2x0YWdlKHBkbyksCj4gKwkJCQkJICBwZG9fcHBzX2FwZG9fbWF4X3ZvbHRhZ2UocGRvKSwK PiArCQkJCQkgIHBkb19wcHNfYXBkb19tYXhfY3VycmVudChwZG8pKTsKPiArCQkJZWxzZQo+ICsJ CQkJc3RyY3B5KG1zZywgInVuZGVmaW5lZCBBUERPIik7Cj4gKwkJCWJyZWFrOwo+ICAJCWRlZmF1 bHQ6Cj4gIAkJCXN0cmNweShtc2csICJ1bmRlZmluZWQiKTsKPiAgCQkJYnJlYWs7Cj4gQEAgLTc5 MSwxMSArODIwLDEzIEBAIHN0YXRpYyBpbnQgdGNwbV9wZF9zZW5kX3NvdXJjZV9jYXBzKHN0cnVj dCB0Y3BtX3BvcnQgKnBvcnQpCj4gIAkJbXNnLmhlYWRlciA9IFBEX0hFQURFUl9MRShQRF9DVFJM X1JFSkVDVCwKPiAgCQkJCQkgIHBvcnQtPnB3cl9yb2xlLAo+ICAJCQkJCSAgcG9ydC0+ZGF0YV9y b2xlLAo+ICsJCQkJCSAgcG9ydC0+bmVnb3RpYXRlZF9yZXYsCj4gIAkJCQkJICBwb3J0LT5tZXNz YWdlX2lkLCAwKTsKPiAgCX0gZWxzZSB7Cj4gIAkJbXNnLmhlYWRlciA9IFBEX0hFQURFUl9MRShQ RF9EQVRBX1NPVVJDRV9DQVAsCj4gIAkJCQkJICBwb3J0LT5wd3Jfcm9sZSwKPiAgCQkJCQkgIHBv cnQtPmRhdGFfcm9sZSwKPiArCQkJCQkgIHBvcnQtPm5lZ290aWF0ZWRfcmV2LAo+ICAJCQkJCSAg cG9ydC0+bWVzc2FnZV9pZCwKPiAgCQkJCQkgIHBvcnQtPm5yX3NyY19wZG8pOwo+ICAJfQo+IEBA IC04MTYsMTEgKzg0NywxMyBAQCBzdGF0aWMgaW50IHRjcG1fcGRfc2VuZF9zaW5rX2NhcHMoc3Ry dWN0IHRjcG1fcG9ydCAqcG9ydCkKPiAgCQltc2cuaGVhZGVyID0gUERfSEVBREVSX0xFKFBEX0NU UkxfUkVKRUNULAo+ICAJCQkJCSAgcG9ydC0+cHdyX3JvbGUsCj4gIAkJCQkJICBwb3J0LT5kYXRh X3JvbGUsCj4gKwkJCQkJICBwb3J0LT5uZWdvdGlhdGVkX3JldiwKPiAgCQkJCQkgIHBvcnQtPm1l c3NhZ2VfaWQsIDApOwo+ICAJfSBlbHNlIHsKPiAgCQltc2cuaGVhZGVyID0gUERfSEVBREVSX0xF KFBEX0RBVEFfU0lOS19DQVAsCj4gIAkJCQkJICBwb3J0LT5wd3Jfcm9sZSwKPiAgCQkJCQkgIHBv cnQtPmRhdGFfcm9sZSwKPiArCQkJCQkgIHBvcnQtPm5lZ290aWF0ZWRfcmV2LAo+ICAJCQkJCSAg cG9ydC0+bWVzc2FnZV9pZCwKPiAgCQkJCQkgIHBvcnQtPm5yX3Nua19wZG8pOwo+ICAJfQo+IEBA IC0xMTg3LDYgKzEyMjAsNyBAQCBzdGF0aWMgdm9pZCB2ZG1fcnVuX3N0YXRlX21hY2hpbmUoc3Ry dWN0IHRjcG1fcG9ydCAqcG9ydCkKPiAgCQltc2cuaGVhZGVyID0gUERfSEVBREVSX0xFKFBEX0RB VEFfVkVORE9SX0RFRiwKPiAgCQkJCQkgIHBvcnQtPnB3cl9yb2xlLAo+ICAJCQkJCSAgcG9ydC0+ ZGF0YV9yb2xlLAo+ICsJCQkJCSAgcG9ydC0+bmVnb3RpYXRlZF9yZXYsCj4gIAkJCQkJICBwb3J0 LT5tZXNzYWdlX2lkLCBwb3J0LT52ZG9fY291bnQpOwo+ICAJCWZvciAoaSA9IDA7IGkgPCBwb3J0 LT52ZG9fY291bnQ7IGkrKykKPiAgCQkJbXNnLnBheWxvYWRbaV0gPSBjcHVfdG9fbGUzMihwb3J0 LT52ZG9fZGF0YVtpXSk7Cj4gQEAgLTEyNTgsNiArMTI5Miw4IEBAIGVudW0gcGRvX2VyciB7Cj4g IAlQRE9fRVJSX0ZJWEVEX05PVF9TT1JURUQsCj4gIAlQRE9fRVJSX1ZBUklBQkxFX0JBVFRfTk9U X1NPUlRFRCwKPiAgCVBET19FUlJfRFVQRV9QRE8sCj4gKwlQRE9fRVJSX1BQU19BUERPX05PVF9T T1JURUQsCj4gKwlQRE9fRVJSX0RVUEVfUFBTX0FQRE8sCj4gIH07Cj4gIAo+ICBzdGF0aWMgY29u c3QgY2hhciAqIGNvbnN0IHBkb19lcnJfbXNnW10gPSB7Cj4gQEAgLTEyNzMsNiArMTMwOSwxMCBA QCBlbnVtIHBkb19lcnIgewo+ICAJIiBlcnI6IFZhcmlhYmxlL0JhdHRlcnkgc3VwcGx5IHBkb3Mg c2hvdWxkIGJlIGluIGluY3JlYXNpbmcgb3JkZXIgb2YgdGhlaXIgbWluaW11bSB2b2x0YWdlIiwK PiAgCVtQRE9fRVJSX0RVUEVfUERPXSA9Cj4gIAkiIGVycjogVmFyaWFibGUvQmF0dCBzdXBwbHkg cGRvcyBjYW5ub3QgaGF2ZSBzYW1lIG1pbi9tYXggdm9sdGFnZSIsCj4gKwlbUERPX0VSUl9QUFNf QVBET19OT1RfU09SVEVEXSA9Cj4gKwkiIGVycjogUHJvZ3JhbW1hYmxlIHBvd2VyIHN1cHBseSBh cGRvcyBzaG91bGQgYmUgaW4gaW5jcmVhc2luZyBvcmRlciBvZiB0aGVpciBtYXhpbXVtIHZvbHRh Z2UiLAo+ICsJW1BET19FUlJfRFVQRV9QUFNfQVBET10gPQo+ICsJIiBlcnI6IFByb2dyYW1tYWJs ZSBwb3dlciBzdXBwbHkgYXBkb3MgY2Fubm90IGhhdmUgc2FtZSBtaW4vbWF4IHZvbHRhZ2UgYW5k IG1heCBjdXJyZW50IiwKPiAgfTsKPiAgCj4gIHN0YXRpYyBlbnVtIHBkb19lcnIgdGNwbV9jYXBz X2VycihzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LCBjb25zdCB1MzIgKnBkbywKPiBAQCAtMTMyMiw2 ICsxMzYyLDI2IEBAIHN0YXRpYyBlbnVtIHBkb19lcnIgdGNwbV9jYXBzX2VycihzdHJ1Y3QgdGNw bV9wb3J0ICpwb3J0LCBjb25zdCB1MzIgKnBkbywKPiAgCQkJCQkgIHBkb19taW5fdm9sdGFnZShw ZG9baSAtIDFdKSkpCj4gIAkJCQkJcmV0dXJuIFBET19FUlJfRFVQRV9QRE87Cj4gIAkJCQlicmVh azsKPiArCQkJLyoKPiArCQkJICogVGhlIFByb2dyYW1tYWJsZSBQb3dlciBTdXBwbHkgQVBET3Ms IGlmIHByZXNlbnQsCj4gKwkJCSAqIHNoYWxsIGJlIHNlbnQgaW4gTWF4aW11bSBWb2x0YWdlIG9y ZGVyOwo+ICsJCQkgKiBsb3dlc3QgdG8gaGlnaGVzdC4KPiArCQkJICovCj4gKwkJCWNhc2UgUERP X1RZUEVfQVBETzoKPiArCQkJCWlmIChwZG9fYXBkb190eXBlKHBkb1tpXSkgIT0gQVBET19UWVBF X1BQUykKPiArCQkJCQlicmVhazsKPiArCj4gKwkJCQlpZiAocGRvX3Bwc19hcGRvX21heF9jdXJy ZW50KHBkb1tpXSkgPAo+ICsJCQkJICAgIHBkb19wcHNfYXBkb19tYXhfY3VycmVudChwZG9baSAt IDFdKSkKPiArCQkJCQlyZXR1cm4gUERPX0VSUl9QUFNfQVBET19OT1RfU09SVEVEOwo+ICsJCQkJ ZWxzZSBpZiAoKHBkb19wcHNfYXBkb19taW5fdm9sdGFnZShwZG9baV0pID09Cj4gKwkJCQkJICBw ZG9fcHBzX2FwZG9fbWluX3ZvbHRhZ2UocGRvW2kgLSAxXSkpICYmCj4gKwkJCQkJIChwZG9fcHBz X2FwZG9fbWF4X3ZvbHRhZ2UocGRvW2ldKSA9PQo+ICsJCQkJCSAgcGRvX3Bwc19hcGRvX21heF92 b2x0YWdlKHBkb1tpIC0gMV0pKSAmJgo+ICsJCQkJCSAocGRvX3Bwc19hcGRvX21heF9jdXJyZW50 KHBkb1tpXSkgPT0KPiArCQkJCQkgIHBkb19wcHNfYXBkb19tYXhfY3VycmVudChwZG9baSAtIDFd KSkpCj4gKwkJCQkJcmV0dXJuIFBET19FUlJfRFVQRV9QUFNfQVBETzsKPiArCQkJCWJyZWFrOwo+ ICAJCQlkZWZhdWx0Ogo+ICAJCQkJdGNwbV9sb2dfZm9yY2UocG9ydCwgIiBVbmtub3duIHBkbyB0 eXBlIik7Cj4gIAkJCX0KPiBAQCAtMTM0NywxMSArMTQwNywxNiBAQCBzdGF0aWMgaW50IHRjcG1f dmFsaWRhdGVfY2FwcyhzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LCBjb25zdCB1MzIgKnBkbywKPiAg LyoKPiAgICogUEQgKGRhdGEsIGNvbnRyb2wpIGNvbW1hbmQgaGFuZGxpbmcgZnVuY3Rpb25zCj4g ICAqLwo+ICsKPiArc3RhdGljIGludCB0Y3BtX3BkX3NlbmRfY29udHJvbChzdHJ1Y3QgdGNwbV9w b3J0ICpwb3J0LAo+ICsJCQkJZW51bSBwZF9jdHJsX21zZ190eXBlIHR5cGUpOwo+ICsKPiAgc3Rh dGljIHZvaWQgdGNwbV9wZF9kYXRhX3JlcXVlc3Qoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCwKPiAg CQkJCSBjb25zdCBzdHJ1Y3QgcGRfbWVzc2FnZSAqbXNnKQo+ICB7Cj4gIAllbnVtIHBkX2RhdGFf bXNnX3R5cGUgdHlwZSA9IHBkX2hlYWRlcl90eXBlX2xlKG1zZy0+aGVhZGVyKTsKPiAgCXVuc2ln bmVkIGludCBjbnQgPSBwZF9oZWFkZXJfY250X2xlKG1zZy0+aGVhZGVyKTsKPiArCXVuc2lnbmVk IGludCByZXYgPSBwZF9oZWFkZXJfcmV2X2xlKG1zZy0+aGVhZGVyKTsKPiAgCXVuc2lnbmVkIGlu dCBpOwo+ICAKPiAgCXN3aXRjaCAodHlwZSkgewo+IEBAIC0xMzcwLDYgKzE0MzUsMTYgQEAgc3Rh dGljIHZvaWQgdGNwbV9wZF9kYXRhX3JlcXVlc3Qoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCwKPiAg CQkJCSAgIHBvcnQtPm5yX3NvdXJjZV9jYXBzKTsKPiAgCj4gIAkJLyoKPiArCQkgKiBBZGp1c3Qg cmV2aXNpb24gaW4gc3Vic2VxdWVudCBtZXNzYWdlIGhlYWRlcnMsIGFzIHJlcXVpcmVkLAo+ICsJ CSAqIHRvIGNvbXBseSB3aXRoIDYuMi4xLjEuNSBvZiB0aGUgVVNCIFBEIDMuMCBzcGVjLiBXZSBk b24ndAo+ICsJCSAqIHN1cHBvcnQgUmV2IDEuMCBzbyBqdXN0IGRvIG5vdGhpbmcgaW4gdGhhdCBz Y2VuYXJpby4KPiArCQkgKi8KPiArCQlpZiAocmV2ID09IFBEX1JFVjEwKQo+ICsJCQlicmVhazsK PiArCQllbHNlIGlmIChyZXYgPCBQRF9NQVhfUkVWKQo+ICsJCQlwb3J0LT5uZWdvdGlhdGVkX3Jl diA9IHJldjsKPiArCj4gKwkJLyoKPiAgCQkgKiBUaGlzIG1lc3NhZ2UgbWF5IGJlIHJlY2VpdmVk IGV2ZW4gaWYgVkJVUyBpcyBub3QKPiAgCQkgKiBwcmVzZW50LiBUaGlzIGlzIHF1aXRlIHVuZXhw ZWN0ZWQ7IHNlZSBVU0IgUEQKPiAgCQkgKiBzcGVjaWZpY2F0aW9uLCBzZWN0aW9ucyA4LjMuMy42 LjMuMSBhbmQgOC4zLjMuNi4zLjIuCj4gQEAgLTEzOTAsNiArMTQ2NSwxOSBAQCBzdGF0aWMgdm9p ZCB0Y3BtX3BkX2RhdGFfcmVxdWVzdChzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LAo+ICAJCQl0Y3Bt X3F1ZXVlX21lc3NhZ2UocG9ydCwgUERfTVNHX0NUUkxfUkVKRUNUKTsKPiAgCQkJYnJlYWs7Cj4g IAkJfQo+ICsKPiArCQkvKgo+ICsJCSAqIEFkanVzdCByZXZpc2lvbiBpbiBzdWJzZXF1ZW50IG1l c3NhZ2UgaGVhZGVycywgYXMgcmVxdWlyZWQsCj4gKwkJICogdG8gY29tcGx5IHdpdGggNi4yLjEu MS41IG9mIHRoZSBVU0IgUEQgMy4wIHNwZWMuIFdlIGRvbid0Cj4gKwkJICogc3VwcG9ydCBSZXYg MS4wIHNvIGp1c3QgcmVqZWN0IGluIHRoYXQgc2NlbmFyaW8uCj4gKwkJICovCj4gKwkJaWYgKHJl diA9PSBQRF9SRVYxMCkgewo+ICsJCQl0Y3BtX3F1ZXVlX21lc3NhZ2UocG9ydCwgUERfTVNHX0NU UkxfUkVKRUNUKTsKPiArCQkJYnJlYWs7Cj4gKwkJfSBlbHNlIGlmIChyZXYgPCBQRF9NQVhfUkVW KSB7Cj4gKwkJCXBvcnQtPm5lZ290aWF0ZWRfcmV2ID0gcmV2Owo+ICsJCX0KPiArCj4gIAkJcG9y dC0+c2lua19yZXF1ZXN0ID0gbGUzMl90b19jcHUobXNnLT5wYXlsb2FkWzBdKTsKPiAgCQl0Y3Bt X3NldF9zdGF0ZShwb3J0LCBTUkNfTkVHT1RJQVRFX0NBUEFCSUxJVElFUywgMCk7Cj4gIAkJYnJl YWs7Cj4gQEAgLTE0MTQsNiArMTUwMiwxNSBAQCBzdGF0aWMgdm9pZCB0Y3BtX3BkX2RhdGFfcmVx dWVzdChzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LAo+ICAJfQo+ICB9Cj4gIAo+ICtzdGF0aWMgdm9p ZCB0Y3BtX3Bwc19jb21wbGV0ZShzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LCBpbnQgcmVzdWx0KQo+ ICt7Cj4gKwlpZiAocG9ydC0+cHBzX3BlbmRpbmcpIHsKPiArCQlwb3J0LT5wcHNfc3RhdHVzID0g cmVzdWx0Owo+ICsJCXBvcnQtPnBwc19wZW5kaW5nID0gZmFsc2U7Cj4gKwkJY29tcGxldGUoJnBv cnQtPnBwc19jb21wbGV0ZSk7Cj4gKwl9Cj4gK30KPiArCj4gIHN0YXRpYyB2b2lkIHRjcG1fcGRf Y3RybF9yZXF1ZXN0KHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQsCj4gIAkJCQkgY29uc3Qgc3RydWN0 IHBkX21lc3NhZ2UgKm1zZykKPiAgewo+IEBAIC0xNDkwLDYgKzE1ODcsMTQgQEAgc3RhdGljIHZv aWQgdGNwbV9wZF9jdHJsX3JlcXVlc3Qoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCwKPiAgCQkJCW5l eHRfc3RhdGUgPSBTTktfV0FJVF9DQVBBQklMSVRJRVM7Cj4gIAkJCXRjcG1fc2V0X3N0YXRlKHBv cnQsIG5leHRfc3RhdGUsIDApOwo+ICAJCQlicmVhazsKPiArCQljYXNlIFNOS19ORUdPVElBVEVf UFBTX0NBUEFCSUxJVElFUzoKPiArCQkJLyogUmV2ZXJ0IGRhdGEgYmFjayBmcm9tIGFueSByZXF1 ZXN0ZWQgUFBTIHVwZGF0ZXMgKi8KPiArCQkJcG9ydC0+cHBzX2RhdGEub3V0X3ZvbHQgPSBwb3J0 LT5zdXBwbHlfdm9sdGFnZTsKPiArCQkJcG9ydC0+cHBzX2RhdGEub3BfY3VyciA9IHBvcnQtPmN1 cnJlbnRfbGltaXQ7Cj4gKwkJCXBvcnQtPnBwc19zdGF0dXMgPSAodHlwZSA9PSBQRF9DVFJMX1dB SVQgPwo+ICsJCQkJCSAgICAtRUFHQUlOIDogLUVPUE5PVFNVUFApOwo+ICsJCQl0Y3BtX3NldF9z dGF0ZShwb3J0LCBTTktfUkVBRFksIDApOwo+ICsJCQlicmVhazsKPiAgCQljYXNlIERSX1NXQVBf U0VORDoKPiAgCQkJcG9ydC0+c3dhcF9zdGF0dXMgPSAodHlwZSA9PSBQRF9DVFJMX1dBSVQgPwo+ ICAJCQkJCSAgICAgLUVBR0FJTiA6IC1FT1BOT1RTVVBQKTsKPiBAQCAtMTUxMiw2ICsxNjE3LDEz IEBAIHN0YXRpYyB2b2lkIHRjcG1fcGRfY3RybF9yZXF1ZXN0KHN0cnVjdCB0Y3BtX3BvcnQgKnBv cnQsCj4gIAljYXNlIFBEX0NUUkxfQUNDRVBUOgo+ICAJCXN3aXRjaCAocG9ydC0+c3RhdGUpIHsK PiAgCQljYXNlIFNOS19ORUdPVElBVEVfQ0FQQUJJTElUSUVTOgo+ICsJCQlwb3J0LT5wcHNfZGF0 YS5hY3RpdmUgPSBmYWxzZTsKPiArCQkJdGNwbV9zZXRfc3RhdGUocG9ydCwgU05LX1RSQU5TSVRJ T05fU0lOSywgMCk7Cj4gKwkJCWJyZWFrOwo+ICsJCWNhc2UgU05LX05FR09USUFURV9QUFNfQ0FQ QUJJTElUSUVTOgo+ICsJCQlwb3J0LT5wcHNfZGF0YS5hY3RpdmUgPSB0cnVlOwo+ICsJCQlwb3J0 LT5zdXBwbHlfdm9sdGFnZSA9IHBvcnQtPnBwc19kYXRhLm91dF92b2x0Owo+ICsJCQlwb3J0LT5j dXJyZW50X2xpbWl0ID0gcG9ydC0+cHBzX2RhdGEub3BfY3VycjsKPiAgCQkJdGNwbV9zZXRfc3Rh dGUocG9ydCwgU05LX1RSQU5TSVRJT05fU0lOSywgMCk7Cj4gIAkJCWJyZWFrOwo+ICAJCWNhc2Ug U09GVF9SRVNFVF9TRU5EOgo+IEBAIC0xNjY2LDYgKzE3NzgsNyBAQCBzdGF0aWMgaW50IHRjcG1f cGRfc2VuZF9jb250cm9sKHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQsCj4gIAltZW1zZXQoJm1zZywg MCwgc2l6ZW9mKG1zZykpOwo+ICAJbXNnLmhlYWRlciA9IFBEX0hFQURFUl9MRSh0eXBlLCBwb3J0 LT5wd3Jfcm9sZSwKPiAgCQkJCSAgcG9ydC0+ZGF0YV9yb2xlLAo+ICsJCQkJICBwb3J0LT5uZWdv dGlhdGVkX3JldiwKPiAgCQkJCSAgcG9ydC0+bWVzc2FnZV9pZCwgMCk7Cj4gIAo+ICAJcmV0dXJu IHRjcG1fcGRfdHJhbnNtaXQocG9ydCwgVENQQ19UWF9TT1AsICZtc2cpOwo+IEBAIC0xNzc5LDYg KzE4OTIsOCBAQCBzdGF0aWMgaW50IHRjcG1fcGRfc2VsZWN0X3BkbyhzdHJ1Y3QgdGNwbV9wb3J0 ICpwb3J0LCBpbnQgKnNpbmtfcGRvLAo+ICAJdW5zaWduZWQgaW50IGksIGosIG1heF9tdyA9IDAs IG1heF9tdiA9IDAsIG13ID0gMCwgbXYgPSAwLCBtYSA9IDA7Cj4gIAlpbnQgcmV0ID0gLUVJTlZB TDsKPiAgCj4gKwlwb3J0LT5wcHNfZGF0YS5zdXBwb3J0ZWQgPSBmYWxzZTsKPiArCj4gIAkvKgo+ ICAJICogU2VsZWN0IHRoZSBzb3VyY2UgUERPIHByb3ZpZGluZyB0aGUgbW9zdCBwb3dlciB3aGlj aCBoYXMgYQo+ICAJICogbWF0Y2hpZyBzaW5rIGNhcC4KPiBAQCAtMTc4Nyw3ICsxOTAyLDggQEAg c3RhdGljIGludCB0Y3BtX3BkX3NlbGVjdF9wZG8oc3RydWN0IHRjcG1fcG9ydCAqcG9ydCwgaW50 ICpzaW5rX3BkbywKPiAgCQl1MzIgcGRvID0gcG9ydC0+c291cmNlX2NhcHNbaV07Cj4gIAkJZW51 bSBwZF9wZG9fdHlwZSB0eXBlID0gcGRvX3R5cGUocGRvKTsKPiAgCj4gLQkJaWYgKHR5cGUgPT0g UERPX1RZUEVfRklYRUQpIHsKPiArCQlzd2l0Y2ggKHR5cGUpIHsKPiArCQljYXNlIFBET19UWVBF X0ZJWEVEOgo+ICAJCQlmb3IgKGogPSAwOyBqIDwgcG9ydC0+bnJfZml4ZWQ7IGorKykgewo+ICAJ CQkJaWYgKHBkb19maXhlZF92b2x0YWdlKHBkbykgPT0KPiAgCQkJCSAgICBwZG9fZml4ZWRfdm9s dGFnZShwb3J0LT5zbmtfcGRvW2pdKSkgewo+IEBAIC0xODA5LDcgKzE5MjUsOCBAQCBzdGF0aWMg aW50IHRjcG1fcGRfc2VsZWN0X3BkbyhzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LCBpbnQgKnNpbmtf cGRvLAo+ICAJCQkJCWJyZWFrOwo+ICAJCQkJfQo+ICAJCQl9Cj4gLQkJfSBlbHNlIGlmICh0eXBl ID09IFBET19UWVBFX0JBVFQpIHsKPiArCQkJYnJlYWs7Cj4gKwkJY2FzZSBQRE9fVFlQRV9CQVRU Ogo+ICAJCQlmb3IgKGogPSBwb3J0LT5ucl9maXhlZDsKPiAgCQkJICAgICBqIDwgcG9ydC0+bnJf Zml4ZWQgKwo+ICAJCQkJIHBvcnQtPm5yX2JhdHQ7Cj4gQEAgLTE4MzAsNyArMTk0Nyw4IEBAIHN0 YXRpYyBpbnQgdGNwbV9wZF9zZWxlY3RfcGRvKHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQsIGludCAq c2lua19wZG8sCj4gIAkJCQkJfQo+ICAJCQkJfQo+ICAJCQl9Cj4gLQkJfSBlbHNlIGlmICh0eXBl ID09IFBET19UWVBFX1ZBUikgewo+ICsJCQlicmVhazsKPiArCQljYXNlIFBET19UWVBFX1ZBUjoK PiAgCQkJZm9yIChqID0gcG9ydC0+bnJfZml4ZWQgKwo+ICAJCQkJIHBvcnQtPm5yX2JhdHQ7Cj4g IAkJCSAgICAgaiA8IHBvcnQtPm5yX2ZpeGVkICsKPiBAQCAtMTg1NCwxMiArMTk3Miw5OCBAQCBz dGF0aWMgaW50IHRjcG1fcGRfc2VsZWN0X3BkbyhzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LCBpbnQg KnNpbmtfcGRvLAo+ICAJCQkJCX0KPiAgCQkJCX0KPiAgCQkJfQo+ICsJCQlicmVhazsKPiArCQlj YXNlIFBET19UWVBFX0FQRE86Cj4gKwkJCWlmIChwZG9fYXBkb190eXBlKHBkbykgPT0gQVBET19U WVBFX1BQUykKPiArCQkJCXBvcnQtPnBwc19kYXRhLnN1cHBvcnRlZCA9IHRydWU7Cj4gKwkJCWNv bnRpbnVlOwo+ICsJCWRlZmF1bHQ6Cj4gKwkJCXRjcG1fbG9nKHBvcnQsICJJbnZhbGlkIFBETyB0 eXBlLCBpZ25vcmluZyIpOwo+ICsJCQljb250aW51ZTsKPiAgCQl9Cj4gIAl9Cj4gIAo+ICAJcmV0 dXJuIHJldDsKPiAgfQo+ICAKPiArI2RlZmluZSBtaW5fcHBzX2FwZG9fY3VycmVudCh4LCB5KQlc Cj4gKwltaW4ocGRvX3Bwc19hcGRvX21heF9jdXJyZW50KHgpLCBwZG9fcHBzX2FwZG9fbWF4X2N1 cnJlbnQoeSkpCj4gKwo+ICtzdGF0aWMgdW5zaWduZWQgaW50IHRjcG1fcGRfc2VsZWN0X3Bwc19h cGRvKHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQsCj4gKwkJCQkJICAgIGludCAqc25rX3BkbywgaW50 ICpzcmNfcGRvKQo+ICt7Cj4gKwl1bnNpZ25lZCBpbnQgaSwgaiwgbWF4X213ID0gMCwgbWF4X212 ID0gMCwgbXcgPSAwLCBtdiA9IDAsIG1hID0gMDsKPiArCWVudW0gcGRfcGRvX3R5cGUgdHlwZTsK PiArCXUzMiBwZG87Cj4gKwlpbnQgcmV0ID0gLUVPUE5PVFNVUFA7Cj4gKwo+ICsJLyoKPiArCSAq IFNlbGVjdCB0aGUgc291cmNlIFBQUyBBUERPIHByb3ZpZGluZyB0aGUgbW9zdCBwb3dlciB3aGls ZSBzdGF5aW5nCj4gKwkgKiB3aXRoaW4gdGhlIGJvYXJkJ3MgbGltaXRzLiBXZSBza2lwIHRoZSBm aXJzdCBQRE8gYXMgdGhpcyBpcyBhbHdheXMKPiArCSAqIDVWIDNBLgo+ICsJICovCj4gKwkqc3Jj X3BkbyA9IDA7Cj4gKwlmb3IgKGkgPSAxOyBpIDwgcG9ydC0+bnJfc291cmNlX2NhcHM7ICsraSkg ewo+ICsJCXBkbyA9IHBvcnQtPnNvdXJjZV9jYXBzW2ldOwo+ICsJCXR5cGUgPSBwZG9fdHlwZShw ZG8pOwo+ICsKPiArCQlzd2l0Y2ggKHR5cGUpIHsKPiArCQljYXNlIFBET19UWVBFX0FQRE86Cj4g KwkJCWlmIChwZG9fYXBkb190eXBlKHBkbykgIT0gQVBET19UWVBFX1BQUykgewo+ICsJCQkJdGNw bV9sb2cocG9ydCwgIk5vdCBQUFMgQVBETywgaWdub3JpbmciKTsKPiArCQkJCWNvbnRpbnVlOwo+ ICsJCQl9Cj4gKwo+ICsJCQlmb3IgKGogPSBwb3J0LT5ucl9maXhlZCArCj4gKwkJCQkgcG9ydC0+ bnJfYmF0dCArCj4gKwkJCQkgcG9ydC0+bnJfdmFyOwo+ICsJCQkgICAgIGogPCBwb3J0LT5ucl9m aXhlZCArCj4gKwkJCQkgcG9ydC0+bnJfYmF0dCArCj4gKwkJCQkgcG9ydC0+bnJfdmFyICsKPiAr CQkJCSBwb3J0LT5ucl9hcGRvOwo+ICsJCQkgICAgICsraikgewo+ICsJCQkJaWYgKChwZG9fcHBz X2FwZG9fbWluX3ZvbHRhZ2UocGRvKSA+PQo+ICsJCQkJICAgICBwZG9fcHBzX2FwZG9fbWluX3Zv bHRhZ2UocG9ydC0+c25rX3Bkb1tqXSkpICYmCj4gKwkJCQkgICAgKHBkb19wcHNfYXBkb19tYXhf dm9sdGFnZShwZG8pIDw9Cj4gKwkJCQkgICAgIHBkb19wcHNfYXBkb19tYXhfdm9sdGFnZShwb3J0 LT5zbmtfcGRvW2pdKSkpIHsKPiArCQkJCQltYSA9IG1pbl9wcHNfYXBkb19jdXJyZW50KHBkbywK PiArCQkJCQkJCQkgIHBvcnQtPnNua19wZG9bal0pOwo+ICsJCQkJCW12ID0gcGRvX3Bwc19hcGRv X21heF92b2x0YWdlKHBkbyk7Cj4gKwkJCQkJbXcgPSAobWEgKiBtdikgLyAxMDAwOwo+ICsJCQkJ CWlmICgobXcgPiBtYXhfbXcpIHx8Cj4gKwkJCQkJICAgICgobXcgPT0gbWF4X213KSAmJiAobXYg PiBtYXhfbXYpKSkgewo+ICsJCQkJCQlyZXQgPSAwOwo+ICsJCQkJCQkqc3JjX3BkbyA9IGk7Cj4g KwkJCQkJCSpzbmtfcGRvID0gajsKPiArCQkJCQkJbWF4X213ID0gbXc7Cj4gKwkJCQkJCW1heF9t diA9IG12Owo+ICsJCQkJCX0KPiArCQkJCX0KPiArCQkJfQo+ICsKPiArCQkJYnJlYWs7Cj4gKwkJ ZGVmYXVsdDoKPiArCQkJdGNwbV9sb2cocG9ydCwgIk5vdCBBUERPIHR5cGUsIGlnbm9yaW5nIik7 Cj4gKwkJCWNvbnRpbnVlOwo+ICsJCX0KPiArCX0KPiArCj4gKwlpZiAoKnNyY19wZG8gPiAwKSB7 Cj4gKwkJcGRvID0gcG9ydC0+c291cmNlX2NhcHNbKnNyY19wZG9dOwo+ICsKPiArCQlwb3J0LT5w cHNfZGF0YS5taW5fdm9sdCA9IHBkb19wcHNfYXBkb19taW5fdm9sdGFnZShwZG8pOwo+ICsJCXBv cnQtPnBwc19kYXRhLm1heF92b2x0ID0gcGRvX3Bwc19hcGRvX21heF92b2x0YWdlKHBkbyk7Cj4g KwkJcG9ydC0+cHBzX2RhdGEubWF4X2N1cnIgPQo+ICsJCQltaW5fcHBzX2FwZG9fY3VycmVudChw ZG8sIHBvcnQtPnNua19wZG9bKnNua19wZG9dKTsKPiArCQlwb3J0LT5wcHNfZGF0YS5vdXRfdm9s dCA9Cj4gKwkJCW1pbihwb3J0LT5wcHNfZGF0YS5vdXRfdm9sdCwgcGRvX3Bwc19hcGRvX21heF92 b2x0YWdlKHBkbykpOwo+ICsJCXBvcnQtPnBwc19kYXRhLm9wX2N1cnIgPQo+ICsJCQltaW4ocG9y dC0+cHBzX2RhdGEub3BfY3VyciwgcGRvX3Bwc19hcGRvX21heF9jdXJyZW50KHBkbykpOwo+ICsJ fQo+ICsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gIHN0YXRpYyBpbnQgdGNwbV9wZF9idWls ZF9yZXF1ZXN0KHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQsIHUzMiAqcmRvKQo+ICB7Cj4gIAl1bnNp Z25lZCBpbnQgbXYsIG1hLCBtdywgZmxhZ3M7Cj4gQEAgLTE4NzUsMTAgKzIwNzksMTggQEAgc3Rh dGljIGludCB0Y3BtX3BkX2J1aWxkX3JlcXVlc3Qoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCwgdTMy ICpyZG8pCj4gIAltYXRjaGluZ19zbmtfcGRvID0gcG9ydC0+c25rX3Bkb1tzbmtfcGRvX2luZGV4 XTsKPiAgCXR5cGUgPSBwZG9fdHlwZShwZG8pOwo+ICAKPiAtCWlmICh0eXBlID09IFBET19UWVBF X0ZJWEVEKQo+ICsJc3dpdGNoICh0eXBlKSB7Cj4gKwljYXNlIFBET19UWVBFX0ZJWEVEOgo+ICAJ CW12ID0gcGRvX2ZpeGVkX3ZvbHRhZ2UocGRvKTsKPiAtCWVsc2UKPiArCQlicmVhazsKPiArCWNh c2UgUERPX1RZUEVfQkFUVDoKPiArCWNhc2UgUERPX1RZUEVfVkFSOgo+ICAJCW12ID0gcGRvX21p bl92b2x0YWdlKHBkbyk7Cj4gKwkJYnJlYWs7Cj4gKwlkZWZhdWx0Ogo+ICsJCXRjcG1fbG9nKHBv cnQsICJJbnZhbGlkIFBETyBzZWxlY3RlZCEiKTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCX0K PiAgCj4gIAkvKiBTZWxlY3QgbWF4aW11bSBhdmFpbGFibGUgY3VycmVudCB3aXRoaW4gdGhlIHNp bmsgcGRvJ3MgbGltaXQgKi8KPiAgCWlmICh0eXBlID09IFBET19UWVBFX0JBVFQpIHsKPiBAQCAt MTk0Myw2ICsyMTU1LDEwNyBAQCBzdGF0aWMgaW50IHRjcG1fcGRfc2VuZF9yZXF1ZXN0KHN0cnVj dCB0Y3BtX3BvcnQgKnBvcnQpCj4gIAltc2cuaGVhZGVyID0gUERfSEVBREVSX0xFKFBEX0RBVEFf UkVRVUVTVCwKPiAgCQkJCSAgcG9ydC0+cHdyX3JvbGUsCj4gIAkJCQkgIHBvcnQtPmRhdGFfcm9s ZSwKPiArCQkJCSAgcG9ydC0+bmVnb3RpYXRlZF9yZXYsCj4gKwkJCQkgIHBvcnQtPm1lc3NhZ2Vf aWQsIDEpOwo+ICsJbXNnLnBheWxvYWRbMF0gPSBjcHVfdG9fbGUzMihyZG8pOwo+ICsKPiArCXJl dHVybiB0Y3BtX3BkX3RyYW5zbWl0KHBvcnQsIFRDUENfVFhfU09QLCAmbXNnKTsKPiArfQo+ICsK PiArc3RhdGljIGludCB0Y3BtX3BkX2J1aWxkX3Bwc19yZXF1ZXN0KHN0cnVjdCB0Y3BtX3BvcnQg KnBvcnQsIHUzMiAqcmRvKQo+ICt7Cj4gKwl1bnNpZ25lZCBpbnQgb3V0X212LCBvcF9tYSwgb3Bf bXcsIG1pbl9tdiwgbWF4X212LCBtYXhfbWEsIGZsYWdzOwo+ICsJZW51bSBwZF9wZG9fdHlwZSB0 eXBlOwo+ICsJaW50IHNyY19wZG9faW5kZXgsIHNua19wZG9faW5kZXg7Cj4gKwl1MzIgcGRvLCBt YXRjaGluZ19zbmtfcGRvOwo+ICsJaW50IHJldDsKPiArCj4gKwlyZXQgPSB0Y3BtX3BkX3NlbGVj dF9wcHNfYXBkbyhwb3J0LCAmc25rX3Bkb19pbmRleCwgJnNyY19wZG9faW5kZXgpOwo+ICsJaWYg KHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXBkbyA9IHBvcnQtPnNvdXJjZV9jYXBzW3Ny Y19wZG9faW5kZXhdOwo+ICsJbWF0Y2hpbmdfc25rX3BkbyA9IHBvcnQtPnNua19wZG9bc25rX3Bk b19pbmRleF07Cj4gKwl0eXBlID0gcGRvX3R5cGUocGRvKTsKPiArCj4gKwlzd2l0Y2ggKHR5cGUp IHsKPiArCWNhc2UgUERPX1RZUEVfQVBETzoKPiArCQlpZiAocGRvX2FwZG9fdHlwZShwZG8pICE9 IEFQRE9fVFlQRV9QUFMpIHsKPiArCQkJdGNwbV9sb2cocG9ydCwgIkludmFsaWQgQVBETyBzZWxl Y3RlZCEiKTsKPiArCQkJcmV0dXJuIC1FSU5WQUw7Cj4gKwkJfQo+ICsJCW1pbl9tdiA9IHBkb19w cHNfYXBkb19taW5fdm9sdGFnZShwZG8pOwo+ICsJCW1heF9tdiA9IHBkb19wcHNfYXBkb19tYXhf dm9sdGFnZShwZG8pOwo+ICsJCW1heF9tYSA9IHBkb19wcHNfYXBkb19tYXhfY3VycmVudChwZG8p Owo+ICsJCW91dF9tdiA9IHBvcnQtPnBwc19kYXRhLm91dF92b2x0Owo+ICsJCW9wX21hID0gcG9y dC0+cHBzX2RhdGEub3BfY3VycjsKPiArCQlicmVhazsKPiArCWRlZmF1bHQ6Cj4gKwkJdGNwbV9s b2cocG9ydCwgIkludmFsaWQgUERPIHNlbGVjdGVkISIpOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ ICsJfQo+ICsKPiArCWZsYWdzID0gUkRPX1VTQl9DT01NIHwgUkRPX05PX1NVU1BFTkQ7Cj4gKwo+ ICsJb3BfbXcgPSAob3BfbWEgKiBvdXRfbXYpIC8gMTAwMDsKPiArCWlmIChvcF9tdyA8IHBvcnQt Pm9wZXJhdGluZ19zbmtfbXcpIHsKPiArCQkvKgo+ICsJCSAqIFRyeSByYWlzaW5nIGN1cnJlbnQg dG8gbWVldCBwb3dlciBuZWVkcy4gSWYgdGhhdCdzIG5vdCBlbm91Z2gKPiArCQkgKiB0aGVuIHRy eSB1cHBpbmcgdGhlIHZvbHRhZ2UuIElmIHRoYXQncyBzdGlsbCBub3QgZW5vZ3VoCj4gKwkJICog dGhlbiB3ZSd2ZSBvYnZpb3VzbHkgY2hvc2VuIGEgUFBTIEFQRE8gd2hpY2ggcmVhbGx5IGlzbid0 Cj4gKwkJICogc3VpdGFibGUgc28gYWJhbmRvbiBzaGlwLgo+ICsJCSAqLwo+ICsJCW9wX21hID0g KChwb3J0LT5vcGVyYXRpbmdfc25rX213ICogMTAwMCkgLyBvdXRfbXYpOwo+ICsJCWlmICgocG9y dC0+b3BlcmF0aW5nX3Nua19tdyAqIDEwMDApICUgb3V0X212KQo+ICsJCQkrK29wX21hOwo+ICsJ CW9wX21hICs9IFJET19QUk9HX0NVUlJfTUFfU1RFUCAtIChvcF9tYSAlIFJET19QUk9HX0NVUlJf TUFfU1RFUCk7Cj4gKwo+ICsJCWlmIChvcF9tYSA+IG1heF9tYSkgewo+ICsJCQlvcF9tYSA9IG1h eF9tYTsKPiArCQkJb3V0X212ID0gKChwb3J0LT5vcGVyYXRpbmdfc25rX213ICogMTAwMCkgLyBv cF9tYSk7Cj4gKwkJCWlmICgocG9ydC0+b3BlcmF0aW5nX3Nua19tdyAqIDEwMDApICUgb3BfbWEp Cj4gKwkJCQkrK291dF9tdjsKPiArCQkJb3V0X212ICs9IFJET19QUk9HX1ZPTFRfTVZfU1RFUCAt Cj4gKwkJCQkgIChvdXRfbXYgJSBSRE9fUFJPR19WT0xUX01WX1NURVApOwo+ICsKPiArCQkJaWYg KG91dF9tdiA+IG1heF9tdikgewo+ICsJCQkJdGNwbV9sb2cocG9ydCwgIkludmFsaWQgUFBTIEFQ RE8gc2VsZWN0ZWQhIik7Cj4gKwkJCQlyZXR1cm4gLUVJTlZBTDsKPiArCQkJfQo+ICsJCX0KPiAr CX0KPiArCj4gKwl0Y3BtX2xvZyhwb3J0LCAiY2M9JWQgY2MxPSVkIGNjMj0lZCB2YnVzPSVkIHZj b25uPSVzIHBvbGFyaXR5PSVkIiwKPiArCQkgcG9ydC0+Y2NfcmVxLCBwb3J0LT5jYzEsIHBvcnQt PmNjMiwgcG9ydC0+dmJ1c19zb3VyY2UsCj4gKwkJIHBvcnQtPnZjb25uX3JvbGUgPT0gVFlQRUNf U09VUkNFID8gInNvdXJjZSIgOiAic2luayIsCj4gKwkJIHBvcnQtPnBvbGFyaXR5KTsKPiArCj4g KwkqcmRvID0gUkRPX1BST0coc3JjX3Bkb19pbmRleCArIDEsIG91dF9tdiwgb3BfbWEsIGZsYWdz KTsKPiArCj4gKwl0Y3BtX2xvZyhwb3J0LCAiUmVxdWVzdGluZyBBUERPICVkOiAldSBtViwgJXUg bUEiLAo+ICsJCSBzcmNfcGRvX2luZGV4LCBvdXRfbXYsIG9wX21hKTsKPiArCj4gKwlwb3J0LT5w cHNfZGF0YS5vcF9jdXJyID0gb3BfbWE7Cj4gKwlwb3J0LT5wcHNfZGF0YS5vdXRfdm9sdCA9IG91 dF9tdjsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGludCB0Y3BtX3BkX3Nl bmRfcHBzX3JlcXVlc3Qoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCkKPiArewo+ICsJc3RydWN0IHBk X21lc3NhZ2UgbXNnOwo+ICsJaW50IHJldDsKPiArCXUzMiByZG87Cj4gKwo+ICsJcmV0ID0gdGNw bV9wZF9idWlsZF9wcHNfcmVxdWVzdChwb3J0LCAmcmRvKTsKPiArCWlmIChyZXQgPCAwKQo+ICsJ CXJldHVybiByZXQ7Cj4gKwo+ICsJbWVtc2V0KCZtc2csIDAsIHNpemVvZihtc2cpKTsKPiArCW1z Zy5oZWFkZXIgPSBQRF9IRUFERVJfTEUoUERfREFUQV9SRVFVRVNULAo+ICsJCQkJICBwb3J0LT5w d3Jfcm9sZSwKPiArCQkJCSAgcG9ydC0+ZGF0YV9yb2xlLAo+ICsJCQkJICBwb3J0LT5uZWdvdGlh dGVkX3JldiwKPiAgCQkJCSAgcG9ydC0+bWVzc2FnZV9pZCwgMSk7Cj4gIAltc2cucGF5bG9hZFsw XSA9IGNwdV90b19sZTMyKHJkbyk7Cj4gIAo+IEBAIC0yMTI4LDYgKzI0NDEsNyBAQCBzdGF0aWMg dm9pZCB0Y3BtX3Jlc2V0X3BvcnQoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCkKPiAgCXRjcG1fdHlw ZWNfZGlzY29ubmVjdChwb3J0KTsKPiAgCXBvcnQtPmF0dGFjaGVkID0gZmFsc2U7Cj4gIAlwb3J0 LT5wZF9jYXBhYmxlID0gZmFsc2U7Cj4gKwlwb3J0LT5wcHNfZGF0YS5zdXBwb3J0ZWQgPSBmYWxz ZTsKPiAgCj4gIAkvKgo+ICAJICogRmlyc3QgUnggSUQgc2hvdWxkIGJlIDA7IHNldCB0aGlzIHRv IGEgc2VudGluZWwgb2YgLTEgc28gdGhhdAo+IEBAIC0yMTQzLDYgKzI0NTcsOCBAQCBzdGF0aWMg dm9pZCB0Y3BtX3Jlc2V0X3BvcnQoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCkKPiAgCXRjcG1fc2V0 X2F0dGFjaGVkX3N0YXRlKHBvcnQsIGZhbHNlKTsKPiAgCXBvcnQtPnRyeV9zcmNfY291bnQgPSAw Owo+ICAJcG9ydC0+dHJ5X3Nua19jb3VudCA9IDA7Cj4gKwlwb3J0LT5zdXBwbHlfdm9sdGFnZSA9 IDA7Cj4gKwlwb3J0LT5jdXJyZW50X2xpbWl0ID0gMDsKPiAgfQo+ICAKPiAgc3RhdGljIHZvaWQg dGNwbV9kZXRhY2goc3RydWN0IHRjcG1fcG9ydCAqcG9ydCkKPiBAQCAtMjM4OSw2ICsyNzA1LDcg QEAgc3RhdGljIHZvaWQgcnVuX3N0YXRlX21hY2hpbmUoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCkK PiAgCQl0eXBlY19zZXRfcHdyX29wbW9kZShwb3J0LT50eXBlY19wb3J0LCBvcG1vZGUpOwo+ICAJ CXBvcnQtPnB3cl9vcG1vZGUgPSBUWVBFQ19QV1JfTU9ERV9VU0I7Cj4gIAkJcG9ydC0+Y2Fwc19j b3VudCA9IDA7Cj4gKwkJcG9ydC0+bmVnb3RpYXRlZF9yZXYgPSBQRF9NQVhfUkVWOwo+ICAJCXBv cnQtPm1lc3NhZ2VfaWQgPSAwOwo+ICAJCXBvcnQtPnJ4X21zZ2lkID0gLTE7Cj4gIAkJcG9ydC0+ ZXhwbGljaXRfY29udHJhY3QgPSBmYWxzZTsKPiBAQCAtMjQ0OSw2ICsyNzY2LDcgQEAgc3RhdGlj IHZvaWQgcnVuX3N0YXRlX21hY2hpbmUoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCkKPiAgCj4gIAkJ dGNwbV9zd2FwX2NvbXBsZXRlKHBvcnQsIDApOwo+ICAJCXRjcG1fdHlwZWNfY29ubmVjdChwb3J0 KTsKPiArCj4gIAkJdGNwbV9jaGVja19zZW5kX2Rpc2NvdmVyKHBvcnQpOwo+ICAJCS8qCj4gIAkJ ICogNi4zLjUKPiBAQCAtMjQ3Miw2ICsyNzkwLDcgQEAgc3RhdGljIHZvaWQgcnVuX3N0YXRlX21h Y2hpbmUoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCkKPiAgCWNhc2UgU05LX1VOQVRUQUNIRUQ6Cj4g IAkJaWYgKCFwb3J0LT5ub25fcGRfcm9sZV9zd2FwKQo+ICAJCQl0Y3BtX3N3YXBfY29tcGxldGUo cG9ydCwgLUVOT1RDT05OKTsKPiArCQl0Y3BtX3Bwc19jb21wbGV0ZShwb3J0LCAtRU5PVENPTk4p Owo+ICAJCXRjcG1fc25rX2RldGFjaChwb3J0KTsKPiAgCQlpZiAodGNwbV9zdGFydF9kcnBfdG9n Z2xpbmcocG9ydCkpIHsKPiAgCQkJdGNwbV9zZXRfc3RhdGUocG9ydCwgRFJQX1RPR0dMSU5HLCAw KTsKPiBAQCAtMjQ4MCw2ICsyNzk5LDcgQEAgc3RhdGljIHZvaWQgcnVuX3N0YXRlX21hY2hpbmUo c3RydWN0IHRjcG1fcG9ydCAqcG9ydCkKPiAgCQl0Y3BtX3NldF9jYyhwb3J0LCBUWVBFQ19DQ19S RCk7Cj4gIAkJaWYgKHBvcnQtPnBvcnRfdHlwZSA9PSBUWVBFQ19QT1JUX0RSUCkKPiAgCQkJdGNw bV9zZXRfc3RhdGUocG9ydCwgU1JDX1VOQVRUQUNIRUQsIFBEX1RfRFJQX1NSQyk7Cj4gKwo+ICAJ CWJyZWFrOwo+ICAJY2FzZSBTTktfQVRUQUNIX1dBSVQ6Cj4gIAkJaWYgKChwb3J0LT5jYzEgPT0g VFlQRUNfQ0NfT1BFTiAmJgo+IEBAIC0yNTYxLDYgKzI4ODEsNyBAQCBzdGF0aWMgdm9pZCBydW5f c3RhdGVfbWFjaGluZShzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0KQo+ICAJCQkJCSAgICAgIHBvcnQt PmNjMiA6IHBvcnQtPmNjMSk7Cj4gIAkJdHlwZWNfc2V0X3B3cl9vcG1vZGUocG9ydC0+dHlwZWNf cG9ydCwgb3Btb2RlKTsKPiAgCQlwb3J0LT5wd3Jfb3Btb2RlID0gVFlQRUNfUFdSX01PREVfVVNC Owo+ICsJCXBvcnQtPm5lZ290aWF0ZWRfcmV2ID0gUERfTUFYX1JFVjsKPiAgCQlwb3J0LT5tZXNz YWdlX2lkID0gMDsKPiAgCQlwb3J0LT5yeF9tc2dpZCA9IC0xOwo+ICAJCXBvcnQtPmV4cGxpY2l0 X2NvbnRyYWN0ID0gZmFsc2U7Cj4gQEAgLTI2MzEsNiArMjk1MiwyNCBAQCBzdGF0aWMgdm9pZCBy dW5fc3RhdGVfbWFjaGluZShzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0KQo+ICAJCQkJCSAgICBQRF9U X1NFTkRFUl9SRVNQT05TRSk7Cj4gIAkJfQo+ICAJCWJyZWFrOwo+ICsJY2FzZSBTTktfTkVHT1RJ QVRFX1BQU19DQVBBQklMSVRJRVM6Cj4gKwkJcmV0ID0gdGNwbV9wZF9zZW5kX3Bwc19yZXF1ZXN0 KHBvcnQpOwo+ICsJCWlmIChyZXQgPCAwKSB7Cj4gKwkJCXBvcnQtPnBwc19zdGF0dXMgPSByZXQ7 Cj4gKwkJCS8qCj4gKwkJCSAqIElmIHRoaXMgd2FzIGNhbGxlZCBkdWUgdG8gdXBkYXRlcyB0byBz aW5rCj4gKwkJCSAqIGNhcGFiaWxpdGllcywgYW5kIHBwcyBpcyBubyBsb25nZXIgdmFsaWQsIHdl IHNob3VsZAo+ICsJCQkgKiBzYWZlbHkgZmFsbCBiYWNrIHRvIGEgc3RhbmRhcmQgUERPLgo+ICsJ CQkgKi8KPiArCQkJaWYgKHBvcnQtPnVwZGF0ZV9zaW5rX2NhcHMpCj4gKwkJCQl0Y3BtX3NldF9z dGF0ZShwb3J0LCBTTktfTkVHT1RJQVRFX0NBUEFCSUxJVElFUywgMCk7Cj4gKwkJCWVsc2UKPiAr CQkJCXRjcG1fc2V0X3N0YXRlKHBvcnQsIFNOS19SRUFEWSwgMCk7Cj4gKwkJfSBlbHNlIHsKPiAr CQkJdGNwbV9zZXRfc3RhdGVfY29uZChwb3J0LCBoYXJkX3Jlc2V0X3N0YXRlKHBvcnQpLAo+ICsJ CQkJCSAgICBQRF9UX1NFTkRFUl9SRVNQT05TRSk7Cj4gKwkJfQo+ICsJCWJyZWFrOwo+ICAJY2Fz ZSBTTktfVFJBTlNJVElPTl9TSU5LOgo+ICAJY2FzZSBTTktfVFJBTlNJVElPTl9TSU5LX1ZCVVM6 Cj4gIAkJdGNwbV9zZXRfc3RhdGUocG9ydCwgaGFyZF9yZXNldF9zdGF0ZShwb3J0KSwKPiBAQCAt MjYzOCw2ICsyOTc3LDcgQEAgc3RhdGljIHZvaWQgcnVuX3N0YXRlX21hY2hpbmUoc3RydWN0IHRj cG1fcG9ydCAqcG9ydCkKPiAgCQlicmVhazsKPiAgCWNhc2UgU05LX1JFQURZOgo+ICAJCXBvcnQt PnRyeV9zbmtfY291bnQgPSAwOwo+ICsJCXBvcnQtPnVwZGF0ZV9zaW5rX2NhcHMgPSBmYWxzZTsK PiAgCQlpZiAocG9ydC0+ZXhwbGljaXRfY29udHJhY3QpIHsKPiAgCQkJdHlwZWNfc2V0X3B3cl9v cG1vZGUocG9ydC0+dHlwZWNfcG9ydCwKPiAgCQkJCQkgICAgIFRZUEVDX1BXUl9NT0RFX1BEKTsK PiBAQCAtMjY0Niw3ICsyOTg2LDExIEBAIHN0YXRpYyB2b2lkIHJ1bl9zdGF0ZV9tYWNoaW5lKHN0 cnVjdCB0Y3BtX3BvcnQgKnBvcnQpCj4gIAo+ICAJCXRjcG1fc3dhcF9jb21wbGV0ZShwb3J0LCAw KTsKPiAgCQl0Y3BtX3R5cGVjX2Nvbm5lY3QocG9ydCk7Cj4gKwo+ICAJCXRjcG1fY2hlY2tfc2Vu ZF9kaXNjb3Zlcihwb3J0KTsKPiArCj4gKwkJdGNwbV9wcHNfY29tcGxldGUocG9ydCwgcG9ydC0+ cHBzX3N0YXR1cyk7Cj4gKwo+ICAJCWJyZWFrOwo+ICAKPiAgCS8qIEFjY2Vzc29yeSBzdGF0ZXMg Ki8KPiBAQCAtMjY5Myw2ICszMDM3LDcgQEAgc3RhdGljIHZvaWQgcnVuX3N0YXRlX21hY2hpbmUo c3RydWN0IHRjcG1fcG9ydCAqcG9ydCkKPiAgCQl0Y3BtX3NldF9zdGF0ZShwb3J0LCBTUkNfVU5B VFRBQ0hFRCwgUERfVF9QU19TT1VSQ0VfT04pOwo+ICAJCWJyZWFrOwo+ICAJY2FzZSBTTktfSEFS RF9SRVNFVF9TSU5LX09GRjoKPiArCQltZW1zZXQoJnBvcnQtPnBwc19kYXRhLCAwLCBzaXplb2Yo cG9ydC0+cHBzX2RhdGEpKTsKPiAgCQl0Y3BtX3NldF92Y29ubihwb3J0LCBmYWxzZSk7Cj4gIAkJ dGNwbV9zZXRfY2hhcmdlKHBvcnQsIGZhbHNlKTsKPiAgCQl0Y3BtX3NldF9yb2xlcyhwb3J0LCBm YWxzZSwgVFlQRUNfU0lOSywgVFlQRUNfREVWSUNFKTsKPiBAQCAtMjkxMyw2ICszMjU4LDcgQEAg c3RhdGljIHZvaWQgcnVuX3N0YXRlX21hY2hpbmUoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCkKPiAg CQlicmVhazsKPiAgCWNhc2UgRVJST1JfUkVDT1ZFUlk6Cj4gIAkJdGNwbV9zd2FwX2NvbXBsZXRl KHBvcnQsIC1FUFJPVE8pOwo+ICsJCXRjcG1fcHBzX2NvbXBsZXRlKHBvcnQsIC1FUFJPVE8pOwo+ ICAJCXRjcG1fc2V0X3N0YXRlKHBvcnQsIFBPUlRfUkVTRVQsIDApOwo+ICAJCWJyZWFrOwo+ICAJ Y2FzZSBQT1JUX1JFU0VUOgo+IEBAIC0zMzc4LDcgKzM3MjQsNyBAQCBzdGF0aWMgaW50IHRjcG1f ZHJfc2V0KGNvbnN0IHN0cnVjdCB0eXBlY19jYXBhYmlsaXR5ICpjYXAsCj4gIAltdXRleF91bmxv Y2soJnBvcnQtPmxvY2spOwo+ICAKPiAgCWlmICghd2FpdF9mb3JfY29tcGxldGlvbl90aW1lb3V0 KCZwb3J0LT5zd2FwX2NvbXBsZXRlLAo+IC0JCQkJbXNlY3NfdG9famlmZmllcyhQRF9ST0xFX1NX QVBfVElNRU9VVCkpKQo+ICsJCQkJbXNlY3NfdG9famlmZmllcyhQRF9TVEFURV9NQUNISU5FX1RJ TUVPVVQpKSkKPiAgCQlyZXQgPSAtRVRJTUVET1VUOwo+ICAJZWxzZQo+ICAJCXJldCA9IHBvcnQt PnN3YXBfc3RhdHVzOwo+IEBAIC0zNDIzLDcgKzM3NjksNyBAQCBzdGF0aWMgaW50IHRjcG1fcHJf c2V0KGNvbnN0IHN0cnVjdCB0eXBlY19jYXBhYmlsaXR5ICpjYXAsCj4gIAltdXRleF91bmxvY2so JnBvcnQtPmxvY2spOwo+ICAKPiAgCWlmICghd2FpdF9mb3JfY29tcGxldGlvbl90aW1lb3V0KCZw b3J0LT5zd2FwX2NvbXBsZXRlLAo+IC0JCQkJbXNlY3NfdG9famlmZmllcyhQRF9ST0xFX1NXQVBf VElNRU9VVCkpKQo+ICsJCQkJbXNlY3NfdG9famlmZmllcyhQRF9TVEFURV9NQUNISU5FX1RJTUVP VVQpKSkKPiAgCQlyZXQgPSAtRVRJTUVET1VUOwo+ICAJZWxzZQo+ICAJCXJldCA9IHBvcnQtPnN3 YXBfc3RhdHVzOwo+IEBAIC0zNDYzLDcgKzM4MDksNyBAQCBzdGF0aWMgaW50IHRjcG1fdmNvbm5f c2V0KGNvbnN0IHN0cnVjdCB0eXBlY19jYXBhYmlsaXR5ICpjYXAsCj4gIAltdXRleF91bmxvY2so JnBvcnQtPmxvY2spOwo+ICAKPiAgCWlmICghd2FpdF9mb3JfY29tcGxldGlvbl90aW1lb3V0KCZw b3J0LT5zd2FwX2NvbXBsZXRlLAo+IC0JCQkJbXNlY3NfdG9famlmZmllcyhQRF9ST0xFX1NXQVBf VElNRU9VVCkpKQo+ICsJCQkJbXNlY3NfdG9famlmZmllcyhQRF9TVEFURV9NQUNISU5FX1RJTUVP VVQpKSkKPiAgCQlyZXQgPSAtRVRJTUVET1VUOwo+ICAJZWxzZQo+ICAJCXJldCA9IHBvcnQtPnN3 YXBfc3RhdHVzOwo+IEBAIC0zNDk1LDYgKzM4NDEsMTYyIEBAIHN0YXRpYyBpbnQgdGNwbV90cnlf cm9sZShjb25zdCBzdHJ1Y3QgdHlwZWNfY2FwYWJpbGl0eSAqY2FwLCBpbnQgcm9sZSkKPiAgCXJl dHVybiByZXQ7Cj4gIH0KPiAgCj4gK3N0YXRpYyBpbnQgdGNwbV9wcHNfc2V0X29wX2N1cnIoc3Ry dWN0IHRjcG1fcG9ydCAqcG9ydCwgdTE2IG9wX2N1cnIpCj4gK3sKPiArCXVuc2lnbmVkIGludCB0 YXJnZXRfbXc7Cj4gKwlpbnQgcmV0ID0gMDsKPiArCj4gKwltdXRleF9sb2NrKCZwb3J0LT5zd2Fw X2xvY2spOwo+ICsJbXV0ZXhfbG9jaygmcG9ydC0+bG9jayk7Cj4gKwo+ICsJaWYgKCFwb3J0LT5w cHNfZGF0YS5hY3RpdmUpIHsKPiArCQlyZXQgPSAtRU9QTk9UU1VQUDsKPiArCQlnb3RvIHBvcnRf dW5sb2NrOwo+ICsJfQo+ICsKPiArCWlmIChwb3J0LT5zdGF0ZSAhPSBTTktfUkVBRFkpIHsKPiAr CQlyZXQgPSAtRUFHQUlOOwo+ICsJCWdvdG8gcG9ydF91bmxvY2s7Cj4gKwl9Cj4gKwo+ICsJaWYg KG9wX2N1cnIgPiBwb3J0LT5wcHNfZGF0YS5tYXhfY3Vycikgewo+ICsJCXJldCA9IC1FSU5WQUw7 Cj4gKwkJZ290byBwb3J0X3VubG9jazsKPiArCX0KPiArCj4gKwl0YXJnZXRfbXcgPSAob3BfY3Vy ciAqIHBvcnQtPnBwc19kYXRhLm91dF92b2x0KSAvIDEwMDA7Cj4gKwlpZiAodGFyZ2V0X213IDwg cG9ydC0+b3BlcmF0aW5nX3Nua19tdykgewo+ICsJCXJldCA9IC1FSU5WQUw7Cj4gKwkJZ290byBw b3J0X3VubG9jazsKPiArCX0KPiArCj4gKwlyZWluaXRfY29tcGxldGlvbigmcG9ydC0+cHBzX2Nv bXBsZXRlKTsKPiArCXBvcnQtPnBwc19kYXRhLm9wX2N1cnIgPSBvcF9jdXJyOwo+ICsJcG9ydC0+ cHBzX3N0YXR1cyA9IDA7Cj4gKwlwb3J0LT5wcHNfcGVuZGluZyA9IHRydWU7Cj4gKwl0Y3BtX3Nl dF9zdGF0ZShwb3J0LCBTTktfTkVHT1RJQVRFX1BQU19DQVBBQklMSVRJRVMsIDApOwoKV2h5IG5v dCBqdXN0IHRha2UgdGhlIHN3YXBfbG9jayBoZXJlLi4KCj4gKwltdXRleF91bmxvY2soJnBvcnQt PmxvY2spOwo+ICsKPiArCWlmICghd2FpdF9mb3JfY29tcGxldGlvbl90aW1lb3V0KCZwb3J0LT5w cHNfY29tcGxldGUsCj4gKwkJCQltc2Vjc190b19qaWZmaWVzKFBEX1NUQVRFX01BQ0hJTkVfVElN RU9VVCkpKQo+ICsJCXJldCA9IC1FVElNRURPVVQ7Cj4gKwllbHNlCj4gKwkJcmV0ID0gcG9ydC0+ cHBzX3N0YXR1czsKPiArCj4gKwlnb3RvIHN3YXBfdW5sb2NrOwoKYW5kIHlvdSBkb24ndCBuZWVk IHRoYXQgZ290by4uCgo+ICtwb3J0X3VubG9jazoKPiArCW11dGV4X3VubG9jaygmcG9ydC0+bG9j ayk7Cj4gK3N3YXBfdW5sb2NrOgo+ICsJbXV0ZXhfdW5sb2NrKCZwb3J0LT5zd2FwX2xvY2spOwoK YW5kIHRoaXMgYmVjb21lcy4uCgoJbXV0ZXhfdW5sb2NrKCZwb3J0LT5zd2FwX2xvY2spOwogICAg ICAgIHJldHVybiByZXQ7Cgpwb3J0X3VubG9jazoKCW11dGV4X3VubG9jaygmcG9ydC0+bG9jayk7 CiAgICAgICAgcmV0dXJuIHJldDsKCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMg aW50IHRjcG1fcHBzX3NldF9vdXRfdm9sdChzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LCB1MTYgb3V0 X3ZvbHQpCj4gK3sKPiArCXVuc2lnbmVkIGludCB0YXJnZXRfbXc7Cj4gKwlpbnQgcmV0ID0gMDsK PiArCj4gKwltdXRleF9sb2NrKCZwb3J0LT5zd2FwX2xvY2spOwo+ICsJbXV0ZXhfbG9jaygmcG9y dC0+bG9jayk7Cj4gKwo+ICsJaWYgKCFwb3J0LT5wcHNfZGF0YS5hY3RpdmUpIHsKPiArCQlyZXQg PSAtRU9QTk9UU1VQUDsKPiArCQlnb3RvIHBvcnRfdW5sb2NrOwoKT3IsIG9uIHRvcCBvZiB3aGF0 IEkgc2FpZCBhYm92ZSwgeW91IGNvdWxkIGFjdHVhbGx5IGNvbnNpZGVyIHJlbGVhc2luZwp0aGUg cG9ydCBsb2NrIGhlcmUgYW5kIGp1c3QgcmV0dXJuaW5nLiBUaGVuIHlvdSB3b3VsZCBub3QgbmVl ZCB0aG9zZQpwb3J0X3VubG9jayBhbmQgc3dhcF91bmxvY2sgbGFiZWxzIGF0IGFsbC4uCgogICAg ICAgICAgICAgICAgbXV0ZXhfdW5sb2NrKCZwb3J0LT5sb2NrKTsKICAgICAgICAgICAgICAgIHJl dHVybiAtRU9QTk9UU1VQUDsKCj4gKwl9Cj4gKwo+ICsJaWYgKHBvcnQtPnN0YXRlICE9IFNOS19S RUFEWSkgewo+ICsJCXJldCA9IC1FQUdBSU47Cj4gKwkJZ290byBwb3J0X3VubG9jazsKCiAgICAg ICAgICAgICAgICBtdXRleF91bmxvY2soJnBvcnQtPmxvY2spOwogICAgICAgICAgICAgICAgcmV0 dXJuIC1FQUdBSU47Cj4gKwl9Cj4gKwo+ICsJaWYgKChvdXRfdm9sdCA8IHBvcnQtPnBwc19kYXRh Lm1pbl92b2x0KSB8fAo+ICsJICAgIChvdXRfdm9sdCA+IHBvcnQtPnBwc19kYXRhLm1heF92b2x0 KSkgewo+ICsJCXJldCA9IC1FSU5WQUw7Cj4gKwkJZ290byBwb3J0X3VubG9jazsKCiAgICAgICAg ICAgICAgICBtdXRleF91bmxvY2soJnBvcnQtPmxvY2spOwogICAgICAgICAgICAgICAgcmV0dXJu IC1FSU5WQUw7Cgo+ICsJfQo+ICsKPiArCXRhcmdldF9tdyA9IChwb3J0LT5wcHNfZGF0YS5vcF9j dXJyICogb3V0X3ZvbHQpIC8gMTAwMDsKPiArCWlmICh0YXJnZXRfbXcgPCBwb3J0LT5vcGVyYXRp bmdfc25rX213KSB7Cj4gKwkJcmV0ID0gLUVJTlZBTDsKPiArCQlnb3RvIHBvcnRfdW5sb2NrOwoK ICAgICAgICAgICAgICAgIG11dGV4X3VubG9jaygmcG9ydC0+bG9jayk7CiAgICAgICAgICAgICAg ICByZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArCj4gKwlyZWluaXRfY29tcGxldGlvbigmcG9ydC0+ cHBzX2NvbXBsZXRlKTsKPiArCXBvcnQtPnBwc19kYXRhLm91dF92b2x0ID0gb3V0X3ZvbHQ7Cj4g Kwlwb3J0LT5wcHNfc3RhdHVzID0gMDsKPiArCXBvcnQtPnBwc19wZW5kaW5nID0gdHJ1ZTsKPiAr CXRjcG1fc2V0X3N0YXRlKHBvcnQsIFNOS19ORUdPVElBVEVfUFBTX0NBUEFCSUxJVElFUywgMCk7 CgogICAgICAgIG11dGV4X2xvY2soJnBvcnQtPnN3YXBfbG9jayk7Cgo+ICsJbXV0ZXhfdW5sb2Nr KCZwb3J0LT5sb2NrKTsKPiArCj4gKwlpZiAoIXdhaXRfZm9yX2NvbXBsZXRpb25fdGltZW91dCgm cG9ydC0+cHBzX2NvbXBsZXRlLAo+ICsJCQkJbXNlY3NfdG9famlmZmllcyhQRF9TVEFURV9NQUNI SU5FX1RJTUVPVVQpKSkKPiArCQlyZXQgPSAtRVRJTUVET1VUOwo+ICsJZWxzZQo+ICsJCXJldCA9 IHBvcnQtPnBwc19zdGF0dXM7CgogICAgICAgIG11dGV4X3VubG9jaygmcG9ydC0+c3dhcF9sb2Nr KTsKCiAgICAgICAgcmV0dXJuIHJldDsKCj4gKwlnb3RvIHN3YXBfdW5sb2NrOwo+ICsKPiArcG9y dF91bmxvY2s6Cj4gKwltdXRleF91bmxvY2soJnBvcnQtPmxvY2spOwo+ICtzd2FwX3VubG9jazoK PiArCW11dGV4X3VubG9jaygmcG9ydC0+c3dhcF9sb2NrKTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHRjcG1fcHBzX2FjdGl2YXRlKHN0cnVjdCB0Y3BtX3BvcnQg KnBvcnQsIGJvb2wgYWN0aXZhdGUpCj4gK3sKPiArCWludCByZXQgPSAwOwo+ICsKPiArCW11dGV4 X2xvY2soJnBvcnQtPnN3YXBfbG9jayk7Cj4gKwltdXRleF9sb2NrKCZwb3J0LT5sb2NrKTsKPiAr Cj4gKwlpZiAoIXBvcnQtPnBwc19kYXRhLnN1cHBvcnRlZCkgewo+ICsJCXJldCA9IC1FT1BOT1RT VVBQOwo+ICsJCWdvdG8gcG9ydF91bmxvY2s7Cj4gKwl9Cj4gKwo+ICsJLyogVHJ5aW5nIHRvIGRl YWN0aXZhdGUgUFBTIHdoZW4gYWxyZWFkeSBkZWFjdGl2YXRlZCBzbyBqdXN0IGJhaWwgKi8KPiAr CWlmICgoIXBvcnQtPnBwc19kYXRhLmFjdGl2ZSkgJiYgKCFhY3RpdmF0ZSkpCj4gKwkJZ290byBw b3J0X3VubG9jazsKPiArCj4gKwlpZiAocG9ydC0+c3RhdGUgIT0gU05LX1JFQURZKSB7Cj4gKwkJ cmV0ID0gLUVBR0FJTjsKPiArCQlnb3RvIHBvcnRfdW5sb2NrOwo+ICsJfQo+ICsKPiArCXJlaW5p dF9jb21wbGV0aW9uKCZwb3J0LT5wcHNfY29tcGxldGUpOwo+ICsJcG9ydC0+cHBzX3N0YXR1cyA9 IDA7Cj4gKwlwb3J0LT5wcHNfcGVuZGluZyA9IHRydWU7Cj4gKwo+ICsJLyogVHJpZ2dlciBQUFMg cmVxdWVzdCBvciBtb3ZlIGJhY2sgdG8gc3RhbmRhcmQgUERPIGNvbnRyYWN0ICovCj4gKwlpZiAo YWN0aXZhdGUpIHsKPiArCQlwb3J0LT5wcHNfZGF0YS5vdXRfdm9sdCA9IHBvcnQtPnN1cHBseV92 b2x0YWdlOwo+ICsJCXBvcnQtPnBwc19kYXRhLm9wX2N1cnIgPSBwb3J0LT5jdXJyZW50X2xpbWl0 Owo+ICsJCXRjcG1fc2V0X3N0YXRlKHBvcnQsIFNOS19ORUdPVElBVEVfUFBTX0NBUEFCSUxJVElF UywgMCk7Cj4gKwl9IGVsc2Ugewo+ICsJCXRjcG1fc2V0X3N0YXRlKHBvcnQsIFNOS19ORUdPVElB VEVfQ0FQQUJJTElUSUVTLCAwKTsKPiArCX0KPiArCW11dGV4X3VubG9jaygmcG9ydC0+bG9jayk7 Cj4gKwo+ICsJaWYgKCF3YWl0X2Zvcl9jb21wbGV0aW9uX3RpbWVvdXQoJnBvcnQtPnBwc19jb21w bGV0ZSwKPiArCQkJCW1zZWNzX3RvX2ppZmZpZXMoUERfU1RBVEVfTUFDSElORV9USU1FT1VUKSkp Cj4gKwkJcmV0ID0gLUVUSU1FRE9VVDsKPiArCWVsc2UKPiArCQlyZXQgPSBwb3J0LT5wcHNfc3Rh dHVzOwo+ICsKPiArCWdvdG8gc3dhcF91bmxvY2s7Cj4gKwo+ICtwb3J0X3VubG9jazoKPiArCW11 dGV4X3VubG9jaygmcG9ydC0+bG9jayk7Cj4gK3N3YXBfdW5sb2NrOgo+ICsJbXV0ZXhfdW5sb2Nr KCZwb3J0LT5zd2FwX2xvY2spOwoKWW91IGNhbiBkbyB0aGUgc2FtZSBhcyBhYm92ZSBoZXJlIGFz IHdlbGwuCgo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiAgc3RhdGljIHZvaWQgdGNwbV9pbml0 KHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQpCj4gIHsKPiAgCWVudW0gdHlwZWNfY2Nfc3RhdHVzIGNj MSwgY2MyOwo+IEBAIC0zNjM0LDEzICs0MTM2LDE4IEBAIGludCB0Y3BtX3VwZGF0ZV9zaW5rX2Nh cGFiaWxpdGllcyhzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LCBjb25zdCB1MzIgKnBkbywKPiAgCXBv cnQtPm1heF9zbmtfbWEgPSBtYXhfc25rX21hOwo+ICAJcG9ydC0+bWF4X3Nua19tdyA9IG1heF9z bmtfbXc7Cj4gIAlwb3J0LT5vcGVyYXRpbmdfc25rX213ID0gb3BlcmF0aW5nX3Nua19tdzsKPiAr CXBvcnQtPnVwZGF0ZV9zaW5rX2NhcHMgPSB0cnVlOwo+ICAKPiAgCXN3aXRjaCAocG9ydC0+c3Rh dGUpIHsKPiAgCWNhc2UgU05LX05FR09USUFURV9DQVBBQklMSVRJRVM6Cj4gKwljYXNlIFNOS19O RUdPVElBVEVfUFBTX0NBUEFCSUxJVElFUzoKPiAgCWNhc2UgU05LX1JFQURZOgo+ICAJY2FzZSBT TktfVFJBTlNJVElPTl9TSU5LOgo+ICAJY2FzZSBTTktfVFJBTlNJVElPTl9TSU5LX1ZCVVM6Cj4g LQkJdGNwbV9zZXRfc3RhdGUocG9ydCwgU05LX05FR09USUFURV9DQVBBQklMSVRJRVMsIDApOwo+ ICsJCWlmIChwb3J0LT5wcHNfZGF0YS5hY3RpdmUpCj4gKwkJCXRjcG1fc2V0X3N0YXRlKHBvcnQs IFNOS19ORUdPVElBVEVfUFBTX0NBUEFCSUxJVElFUywgMCk7Cj4gKwkJZWxzZQo+ICsJCQl0Y3Bt X3NldF9zdGF0ZShwb3J0LCBTTktfTkVHT1RJQVRFX0NBUEFCSUxJVElFUywgMCk7Cj4gIAkJYnJl YWs7Cj4gIAlkZWZhdWx0Ogo+ICAJCWJyZWFrOwo+IEBAIC0zNjk1LDYgKzQyMDIsNyBAQCBzdHJ1 Y3QgdGNwbV9wb3J0ICp0Y3BtX3JlZ2lzdGVyX3BvcnQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1 Y3QgdGNwY19kZXYgKnRjcGMpCj4gIAo+ICAJaW5pdF9jb21wbGV0aW9uKCZwb3J0LT50eF9jb21w bGV0ZSk7Cj4gIAlpbml0X2NvbXBsZXRpb24oJnBvcnQtPnN3YXBfY29tcGxldGUpOwo+ICsJaW5p dF9jb21wbGV0aW9uKCZwb3J0LT5wcHNfY29tcGxldGUpOwo+ICAJdGNwbV9kZWJ1Z2ZzX2luaXQo cG9ydCk7Cj4gIAo+ICAJaWYgKHRjcG1fdmFsaWRhdGVfY2Fwcyhwb3J0LCB0Y3BjLT5jb25maWct PnNyY19wZG8sCj4gQEAgLTM3MTcsNiArNDIyNSw5IEBAIHN0cnVjdCB0Y3BtX3BvcnQgKnRjcG1f cmVnaXN0ZXJfcG9ydChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCB0Y3BjX2RldiAqdGNwYykK PiAgCXBvcnQtPm5yX2JhdHQgPSBucl90eXBlX3Bkb3MocG9ydC0+c25rX3BkbywKPiAgCQkJCSAg ICAgcG9ydC0+bnJfc25rX3BkbywKPiAgCQkJCSAgICAgUERPX1RZUEVfQkFUVCk7Cj4gKwlwb3J0 LT5ucl9hcGRvID0gbnJfdHlwZV9wZG9zKHBvcnQtPnNua19wZG8sCj4gKwkJCQkgICAgIHBvcnQt Pm5yX3Nua19wZG8sCj4gKwkJCQkgICAgIFBET19UWVBFX0FQRE8pOwo+ICAJcG9ydC0+bnJfc25r X3ZkbyA9IHRjcG1fY29weV92ZG9zKHBvcnQtPnNua192ZG8sIHRjcGMtPmNvbmZpZy0+c25rX3Zk bywKPiAgCQkJCQkgIHRjcGMtPmNvbmZpZy0+bnJfc25rX3Zkbyk7Cj4gIAo+IEBAIC0zNzMyLDcg KzQyNDMsNyBAQCBzdHJ1Y3QgdGNwbV9wb3J0ICp0Y3BtX3JlZ2lzdGVyX3BvcnQoc3RydWN0IGRl dmljZSAqZGV2LCBzdHJ1Y3QgdGNwY19kZXYgKnRjcGMpCj4gIAlwb3J0LT50eXBlY19jYXBzLnBy ZWZlcl9yb2xlID0gdGNwYy0+Y29uZmlnLT5kZWZhdWx0X3JvbGU7Cj4gIAlwb3J0LT50eXBlY19j YXBzLnR5cGUgPSB0Y3BjLT5jb25maWctPnR5cGU7Cj4gIAlwb3J0LT50eXBlY19jYXBzLnJldmlz aW9uID0gMHgwMTIwOwkvKiBUeXBlLUMgc3BlYyByZWxlYXNlIDEuMiAqLwo+IC0JcG9ydC0+dHlw ZWNfY2Fwcy5wZF9yZXZpc2lvbiA9IDB4MDIwMDsJLyogVVNCLVBEIHNwZWMgcmVsZWFzZSAyLjAg Ki8KPiArCXBvcnQtPnR5cGVjX2NhcHMucGRfcmV2aXNpb24gPSAweDAzMDA7CS8qIFVTQi1QRCBz cGVjIHJlbGVhc2UgMy4wICovCj4gIAlwb3J0LT50eXBlY19jYXBzLmRyX3NldCA9IHRjcG1fZHJf c2V0Owo+ICAJcG9ydC0+dHlwZWNfY2Fwcy5wcl9zZXQgPSB0Y3BtX3ByX3NldDsKPiAgCXBvcnQt PnR5cGVjX2NhcHMudmNvbm5fc2V0ID0gdGNwbV92Y29ubl9zZXQ7Cj4gZGlmZiAtLWdpdCBhL2lu Y2x1ZGUvbGludXgvdXNiL3BkLmggYi9pbmNsdWRlL2xpbnV4L3VzYi9wZC5oCj4gaW5kZXggZmYz NTliZGYuLjA5YjU3MGYgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9saW51eC91c2IvcGQuaAo+ICsr KyBiL2luY2x1ZGUvbGludXgvdXNiL3BkLmgKPiBAQCAtMTAzLDggKzEwMyw4IEBAIGVudW0gcGRf ZXh0X21zZ190eXBlIHsKPiAgCSAoKChjbnQpICYgUERfSEVBREVSX0NOVF9NQVNLKSA8PCBQRF9I RUFERVJfQ05UX1NISUZUKSB8CVwKPiAgCSAoKGV4dF9oZHIpID8gUERfSEVBREVSX0VYVF9IRFIg OiAwKSkKPiAgCj4gLSNkZWZpbmUgUERfSEVBREVSX0xFKHR5cGUsIHB3ciwgZGF0YSwgaWQsIGNu dCkgXAo+IC0JY3B1X3RvX2xlMTYoUERfSEVBREVSKCh0eXBlKSwgKHB3ciksIChkYXRhKSwgUERf UkVWMjAsIChpZCksIChjbnQpLCAoMCkpKQo+ICsjZGVmaW5lIFBEX0hFQURFUl9MRSh0eXBlLCBw d3IsIGRhdGEsIHJldiwgaWQsIGNudCkgXAo+ICsJY3B1X3RvX2xlMTYoUERfSEVBREVSKCh0eXBl KSwgKHB3ciksIChkYXRhKSwgKHJldiksIChpZCksIChjbnQpLCAoMCkpKQo+ICAKPiAgc3RhdGlj IGlubGluZSB1bnNpZ25lZCBpbnQgcGRfaGVhZGVyX2NudCh1MTYgaGVhZGVyKQo+ICB7Cj4gZGlm ZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdXNiL3RjcG0uaCBiL2luY2x1ZGUvbGludXgvdXNiL3Rj cG0uaAo+IGluZGV4IGNhMWMwYjUuLmQ2NjczZjcgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9saW51 eC91c2IvdGNwbS5oCj4gKysrIGIvaW5jbHVkZS9saW51eC91c2IvdGNwbS5oCj4gQEAgLTM1LDcg KzM1LDcgQEAgZW51bSB0eXBlY19jY19wb2xhcml0eSB7Cj4gIAo+ICAvKiBUaW1lIHRvIHdhaXQg Zm9yIFRDUEMgdG8gY29tcGxldGUgdHJhbnNtaXQgKi8KPiAgI2RlZmluZSBQRF9UX1RDUENfVFhf VElNRU9VVAkxMDAJCS8qIGluIG1zCSovCj4gLSNkZWZpbmUgUERfUk9MRV9TV0FQX1RJTUVPVVQJ KE1TRUNfUEVSX1NFQyAqIDEwKQo+ICsjZGVmaW5lIFBEX1NUQVRFX01BQ0hJTkVfVElNRU9VVAko TVNFQ19QRVJfU0VDICogMTApCj4gIAo+ICBlbnVtIHRjcG1fdHJhbnNtaXRfc3RhdHVzIHsKPiAg CVRDUENfVFhfU1VDQ0VTUyA9IDAsCj4gLS0gCj4gMS45LjEK