From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-1.1 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,SPF_PASS, URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5D6B5C28CF6 for ; Fri, 3 Aug 2018 10:18:08 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id DB55C2173F for ; Fri, 3 Aug 2018 10:18:07 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=ti.com header.i=@ti.com header.b="dpLuORUj" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org DB55C2173F Authentication-Results: mail.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=ti.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732518AbeHCMNn (ORCPT ); Fri, 3 Aug 2018 08:13:43 -0400 Received: from lelv0142.ext.ti.com ([198.47.23.249]:46912 "EHLO lelv0142.ext.ti.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728122AbeHCMNn (ORCPT ); Fri, 3 Aug 2018 08:13:43 -0400 Received: from dlelxv90.itg.ti.com ([172.17.2.17]) by lelv0142.ext.ti.com (8.15.2/8.15.2) with ESMTP id w73AHvQu110992; Fri, 3 Aug 2018 05:17:57 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ti.com; s=ti-com-17Q1; t=1533291477; bh=jLSCAC1PblXsfTDQ6HXopa3H5Jk3FbXaGDytGgFngMo=; h=Subject:To:CC:References:From:Date:In-Reply-To; b=dpLuORUjzb0OVgP++spox8UGpvuX4wMiTdVAkThSV2+SH/uj508v0IElcqTsMTZqa l/51zwa6a9PFaY3pWQJpq9gK7jiwIlQdNEWIIX0YV2O14wNex6+Nyx6hwcctvxxM8K wIjJpUuVKgRaSIsT9N2fDdOBjVBYrqUr+zogZezM= Received: from DFLE104.ent.ti.com (dfle104.ent.ti.com [10.64.6.25]) by dlelxv90.itg.ti.com (8.14.3/8.13.8) with ESMTP id w73AHvLN030423; Fri, 3 Aug 2018 05:17:57 -0500 Received: from DFLE101.ent.ti.com (10.64.6.22) by DFLE104.ent.ti.com (10.64.6.25) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1466.3; Fri, 3 Aug 2018 05:17:57 -0500 Received: from dflp32.itg.ti.com (10.64.6.15) by DFLE101.ent.ti.com (10.64.6.22) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_RSA_WITH_AES_256_CBC_SHA) id 15.1.1466.3 via Frontend Transport; Fri, 3 Aug 2018 05:17:57 -0500 Received: from [192.168.2.6] (ileax41-snat.itg.ti.com [10.172.224.153]) by dflp32.itg.ti.com (8.14.3/8.13.8) with ESMTP id w73AHtsR016455; Fri, 3 Aug 2018 05:17:55 -0500 Subject: Re: [PATCH 05/31] usb: usbssp: Added first part of initialization sequence. To: Pawel Laszczak CC: Greg Kroah-Hartman , , Felipe Balbi , , , References: <1532023084-28083-1-git-send-email-pawell@cadence.com> <1532023084-28083-6-git-send-email-pawell@cadence.com> From: Roger Quadros Openpgp: preference=signencrypt Autocrypt: addr=rogerq@ti.com; prefer-encrypt=mutual; keydata= xsFNBFT1lPYBEADZlKgOS2lxNkDRlcROza/QPsYrS+V2YAXOd4rO/sshQDt1OgU4E8DD37t0 F4zipBkMVU1nQ6ZSomg2o9w17wD7sL0wNO+QZ0j5V2yy2SJIlK70lgmz90GlL93V3T/BFJNr YdtC6FBWvczrXXz6qIKq+3s9j+gMx4CFsZX8vq35xcsaNdyWzX2J7hqMKQ+vYuLvy3u2UMIc pgkwfx5CHXHmWVr4/qWPB+O9YtN9m1ezfPLwbZ73Ea5LpnvCGO6s4IHFLl2hPpDGUCHHV/1N qg3N5ztm4bhN9C0+1qdmhuFGhkfC3O4h/ncywTUNuxqk2Tux19GX3BeWiJF7QVVJb2iXttdo Zi44vp32I7LbcMcXYifHHGYwS5GeAudx6O19RTS+D7XQ1BkSmw8weaTleLhJwApVBon2KziB NscqXsj6CdKFwLFsDPkkvYCsEpWz3C9UUn8veOna2STk8oyk1GM+iVarBad6gs0n8NFNrR2n nLjIFuZ6GIwec3HNaX5Zk3ap1z7qsZ/BVou8r95FJw7cAQU3H5vgHZkGHy9xl6LmPvAf0tWT sO1a9mbf7gcC2u4ccHJ+hTvGk62/E/+AxbtzUDQI0D2ouS9DnwO92UZDJrJhj6m3u1c8mR45 W2CFvZSVPmDSxbyWm3ADzsjfRQlhLkzsV9BoDq8uRMzWUPd8IQARAQABzTRSb2dlciBRdWFk cm9zIChLZXkgZm9yIExpbnV4IGtlcm5lbCkgPHJvZ2VycUB0aS5jb20+wsF4BBMBAgAiBQJU 9ZT2AhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRDSWmvTvnYwkwP2EACuDMmuKaYm rcMhjVcvrrWF7n1LGI4nrmVH93fAI8wZsLSpUwyHeLGNTwSOvJC6U4qLvJAejttdW/DCvU+8 cETqkeh36IQhvxNdp6HGXPD+hywZiDHZi54mfpLU7DTExGyuyKKbh7leH/5QvhZF/NkEXHIC g9caDvnmg0CI5VI6QsleiQPNFL7VYZ3neGKJRHjUGTbKPc/9InqzTCWH7ZI3W0aZoAFrOOYv 4bWSohSruEEYKwE6ebvflwESOj5ikVJY5cPmscYfR6LIBzXtTL4fg296sqkeNtvU99DMjKGX LTKmxPY5lnPkDY1YJbAJKoQ+8DYB5GnXA3CNscgXDQGIwbq2eKlGgLhMjyDVmjGHB0FOuuFQ 6W+PLP0FfYqQdQwJWbPfvXoku3IlljwxAN+gvzi0xD3Yqpl3VDjbn2n/2aRuqa8pVVCrsUnG 4LeoDJeMIHyddK61HXDhN0SoA4RNLm6ZW8E+2DH8ZbFbw8IkSyh9Op01LMzD9tr47JRcrGgv K4o1QOwSe1NIK7yQ/SrENiMvICTeAq4gqvc/maDWbylNsYZc3VO9VAhCCghbdk7kRfYWhzBg C/2RgkMGBBTAOVgMbPcDpFzD5Dukg+Jy4xn97bA/MSH8CyYcLZos0SaSzrjNVIvm+TN71k9+ Q2EhsrlhWj64+IjYmzVIFHyTmc7BTQRU9ZT2ARAA16PDhYuCNxXwcXAPlgpVIXC5ZxvB3xWK QifhimnqxvJsCNkNWt8I3jfY+GwjsjTldzA4jIbHTuaHhXgMMu9YoUVK/YBp5IZ/NiQ3yVL5 K5XU0q/BtG30yox9CPjWCA7OmT3mF+1vT9UrEEPCs8KpWER5ajk+rQpTc1WuwJqBB5WeIlZJ odjxuL3r1Zpgk7LxPwwaw15WutKPFY8ClvXqlmmkU4zlCC5s4oR39f6E6B31yun621fvgu8X LFY4i7aUkVYUleKd7L/GAV98Dnbrop48bQM+gDtyPODPh8fJylsPvZAYEqiapSsYiHvts3r/ nEw0RASNyjp5pNBWb5/JbBjboKhGCoBJzkDHcr5VbeOXuemymJHqgysbmDZY415olIOrYQGT b9p/zg5U/eGFsxKnAe4LquX9oAoEu6K/zkUbA/1LEjSTxu3xGCczxe2ZsKthdYztDkntsw+t U9bt2DCXhmabMCcYS1YP72ZVITpLk4qRfxcrtzgx/uGfuMZDuN7JVYqCz7AI+xEQBLlQWXhL cJ8dH0d+H/3Zs9LVaJAqoc9CiYo1yz8NUH+yHGxz437ccUic8HPB2lIiL/W6C4wVhUbm2w9F 4VdByWgWCCY5Ynhe188sqNL+mFqLAaIssqyYwTBJM+Go6tOuRnP6jrkf2Va/pIwIltzf9QOW cgEAEQEAAcLBXwQYAQIACQUCVPWU9gIbDAAKCRDSWmvTvnYwk8niEACcwBAfe1tTSqCCHkRj zgIrt+NPBBfxilf9JXPGTYqfUkrcVfiNqLGFgIDZKjkLfArxiSmpmtKf1O1VYO9XDgADUKJO RvmUQM/l3Q99QC5b8yUyZOsgfSBOsV6DeqiULO30cXH/uEpR2fUcbtyYXHouiF2UNdq/BV5h HBQkGYtTf7K26NPp4wXMS+YsBm2Gbms/wywJh4KgRPP6LuA+UE/7l0xqMD3pBQ/L1KLTqOQY CItcZ0YbEvlrJc25PRkCssHf1J2c2MXV+CRqsibW8UamBmOyzKHVK/CwvIndwBmcciJrOf+4 uxegvXEnwvYPuQ3wvBSkgbJRFNJemnp5KSczANr4R/aA5cEbxhbg7peLv0FdFyTFJXCsKeuO 1gKoKtOLyxRhDocprSuEamaDWDCy3TmX+6nWaBIPYXDFT7IcHT6l6TyZ6IMjkXiHSLhynTIj f2xjSrvKPljIUxcqjhyqWe+coe/Xwbqz69DsK150xoAaoS3rbNlhmalbg15HNTipNDI/k81A fwt7ncjxvjXVJnA2nqPBDIW3mZO/ED0blLrVdaMZjf5LvS+vvsMdH7dHtrAXA50egr74sX0A NO7iW+gkmFYwap531ipMXthHPWbo5x9xfb+a48xA80ePBJLBDyw9X+cOe40+N4Ybiwy5Q2La IwrfNkJOLj3CvocMIw== Message-ID: <45dff595-5363-bbef-1240-6b693b4829b2@ti.com> Date: Fri, 3 Aug 2018 13:17:54 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.9.1 MIME-Version: 1.0 In-Reply-To: <1532023084-28083-6-git-send-email-pawell@cadence.com> Content-Type: text/plain; charset="utf-8" Content-Language: en-GB Content-Transfer-Encoding: 8bit X-EXCLAIMER-MD-CONFIG: e1e8a2fd-e40a-4ac6-ac9b-f7e9cc9ee180 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi, On 19/07/18 20:57, Pawel Laszczak wrote: > Patch adds some initialization function. The initialization sequence > is quite complicated and this patch implements it only partially. > Initialization will be completed in next few patches. > > Patch introduce three new files: > 1. gadget-dbg.c - file contains functions used for debugging purpose. > 2. gadget-ext-caps.h - holds macro definition related to > Extended Capabilities > 3. gadget-if - file implements stuff related to upper layer > (e.g usb_ep_ops, usb_gadget_ops interface). > > Signed-off-by: Pawel Laszczak > --- > drivers/usb/usbssp/Makefile | 1 + > drivers/usb/usbssp/gadget-dbg.c | 30 ++++ > drivers/usb/usbssp/gadget-ext-caps.h | 53 ++++++ > drivers/usb/usbssp/gadget-if.c | 24 +++ > drivers/usb/usbssp/gadget.c | 242 +++++++++++++++++++++++++++ > drivers/usb/usbssp/gadget.h | 15 ++ > 6 files changed, 365 insertions(+) > create mode 100644 drivers/usb/usbssp/gadget-dbg.c > create mode 100644 drivers/usb/usbssp/gadget-ext-caps.h > create mode 100644 drivers/usb/usbssp/gadget-if.c > > diff --git a/drivers/usb/usbssp/Makefile b/drivers/usb/usbssp/Makefile > index d85f15afb51c..0606f3c63cd0 100644 > --- a/drivers/usb/usbssp/Makefile > +++ b/drivers/usb/usbssp/Makefile > @@ -5,6 +5,7 @@ CFLAGS_gadget-trace.o := -I$(src) > obj-$(CONFIG_USB_USBSSP_GADGET) += usbssp.o > usbssp-y := usbssp-plat.o gadget-ring.o \ > gadget.o > + gadget-dbg.o > > ifneq ($(CONFIG_TRACING),) > usbssp-y += gadget-trace.o > diff --git a/drivers/usb/usbssp/gadget-dbg.c b/drivers/usb/usbssp/gadget-dbg.c > new file mode 100644 > index 000000000000..277617d1a996 > --- /dev/null > +++ b/drivers/usb/usbssp/gadget-dbg.c > @@ -0,0 +1,30 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * USBSSP device controller driver > + * > + * Copyright (C) 2018 Cadence. > + * > + * Author: Pawel Laszczak > + * > + * A lot of code based on Linux XHCI driver. > + * Origin: Copyright (C) 2008 Intel Corp > + */ > + > +#include "gadget.h" > + > +void usbssp_dbg_trace(struct usbssp_udc *usbssp_data, > + void (*trace)(struct va_format *), > + const char *fmt, ...) > +{ > + struct va_format vaf; > + va_list args; > + > + va_start(args, fmt); > + vaf.fmt = fmt; > + vaf.va = &args; > + dev_dbg(usbssp_data->dev, "%pV\n", &vaf); dev_dbg will mess up with timings to be useful. Why not just use one of the trace events you defined in gadget-trace.h? > + trace(&vaf); > + va_end(args); > +} > +EXPORT_SYMBOL_GPL(usbssp_dbg_trace); > + > diff --git a/drivers/usb/usbssp/gadget-ext-caps.h b/drivers/usb/usbssp/gadget-ext-caps.h > new file mode 100644 > index 000000000000..2bf327046376 > --- /dev/null > +++ b/drivers/usb/usbssp/gadget-ext-caps.h > @@ -0,0 +1,53 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * USBSSP device controller driver > + * > + * Copyright (C) 2018 Cadence. > + * > + * Author: Pawel Laszczak > + * > + * A lot of code based on Linux XHCI driver. > + * Origin: Copyright (C) 2008 Intel Corp > + */ > + > +/* Up to 16 ms to halt an DC */ > +#define USBSSP_MAX_HALT_USEC (16*1000) > + > +/* DC not running - set to 1 when run/stop bit is cleared. */ > +#define USBSSP_STS_HALT BIT(0) > + > +/* HCCPARAMS offset from PCI base address */ > +#define USBSSP_HCC_PARAMS_OFFSET 0x10 > +/* HCCPARAMS contains the first extended capability pointer */ > +#define USBSSP_HCC_EXT_CAPS(p) (((p)>>16)&0xffff) > + > +/* Command and Status registers offset from the Operational Registers address */ > +#define USBSSP_CMD_OFFSET 0x00 > +#define USBSSP_STS_OFFSET 0x04 > + > +/* Capability Register */ > +/* bits 7:0 - how long is the Capabilities register */ > +#define USBSSP_HC_LENGTH(p) (((p)>>00)&0x00ff) > + > +/* Extended capability register fields */ > +#define USBSSP_EXT_CAPS_ID(p) (((p)>>0)&0xff) > +#define USBSSP_EXT_CAPS_NEXT(p) (((p)>>8)&0xff) > +#define v_EXT_CAPS_VAL(p) ((p)>>16) > +/* Extended capability IDs - ID 0 reserved */ > +#define USBSSP_EXT_CAPS_PROTOCOL 2 > + > +/* USB 2.0 hardware LMP capability*/ > +#define USBSSP_HLC BIT(19) > +#define USBSSP_BLC BIT(20) > + > +/* command register values to disable interrupts and halt the DC */ > +/* start/stop DC execution - do not write unless DC is halted*/ > +#define USBSSP_CMD_RUN BIT(0) > +/* Event Interrupt Enable - get irq when EINT bit is set in USBSTS register */ > +#define USBSSP_CMD_EIE BIT(2) > +/* Host System Error Interrupt Enable - get irq when HSEIE bit set in USBSTS */ > +#define USBSSP_CMD_HSEIE BIT(3) > +/* Enable Wrap Event - '1' means DC generates an event when MFINDEX wraps. */ > +#define USBSSP_CMD_EWE BIT(10) > + > +#define USBSSP_IRQS (USBSSP_CMD_EIE | USBSSP_CMD_HSEIE | USBSSP_CMD_EWE) > diff --git a/drivers/usb/usbssp/gadget-if.c b/drivers/usb/usbssp/gadget-if.c > new file mode 100644 > index 000000000000..d53e0fb65299 > --- /dev/null > +++ b/drivers/usb/usbssp/gadget-if.c > @@ -0,0 +1,24 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * USBSSP device controller driver > + * > + * Copyright (C) 2018 Cadence. > + * > + * Author: Pawel Laszczak > + * > + */ > + > +#include > +#include > +#include "gadget.h" > + > +int usbssp_gadget_init_endpoint(struct usbssp_udc *usbssp_data) > +{ > + /*TODO: it has to be implemented*/ > + return 0; > +} > + > +void usbssp_gadget_free_endpoint(struct usbssp_udc *usbssp_data) > +{ > + /*TODO: it has to be implemented*/ > +} > diff --git a/drivers/usb/usbssp/gadget.c b/drivers/usb/usbssp/gadget.c > index 2f60d7dd1fe4..338ec2ec18b1 100644 > --- a/drivers/usb/usbssp/gadget.c > +++ b/drivers/usb/usbssp/gadget.c > @@ -23,6 +23,107 @@ > #include "gadget-trace.h" > #include "gadget.h" > > + > +/* /** > + * usbssp_handshake - spin reading dc until handshake completes or fails > + * @ptr: address of dc register to be read > + * @mask: bits to look at in result of read > + * @done: value of those bits when handshake succeeds > + * @usec: timeout in microseconds > + * > + * Returns negative errno, or zero on success > + * > + * Success happens when the "mask" bits have the specified value (hardware > + * handshake done). There are two failure modes: "usec" have passed (major > + * hardware flakeout), or the register reads as all-ones (hardware removed). > + */ > +int usbssp_handshake(void __iomem *ptr, u32 mask, u32 done, int usec) > +{ > + u32 result; > + > + do { > + result = readl(ptr); > + if (result == ~(u32)0) /* card removed */ > + return -ENODEV; > + result &= mask; > + if (result == done) > + return 0; > + udelay(1); > + usec--; > + } while (usec > 0); > + return -ETIMEDOUT; > +} > + > +/* > + * Disable interrupts and begin the DC halting process. > + */ > +void usbssp_quiesce(struct usbssp_udc *usbssp_data) > +{ > + u32 halted; > + u32 cmd; > + u32 mask; > + > + mask = ~(u32)(USBSSP_IRQS); > + > + halted = readl(&usbssp_data->op_regs->status) & STS_HALT; > + if (!halted) > + mask &= ~CMD_RUN; > + > + cmd = readl(&usbssp_data->op_regs->command); > + cmd &= mask; > + writel(cmd, &usbssp_data->op_regs->command); > +} > + > +/* > + * Force DC into halt state. > + * > + * Disable any IRQs and clear the run/stop bit. > + * USBSSP will complete any current and actively pipelined transactions, and > + * should halt within 16 ms of the run/stop bit being cleared. > + * Read DC Halted bit in the status register to see when the DC is finished. > + */ > +int usbssp_halt(struct usbssp_udc *usbssp_data) > +{ > + int ret; > + > + usbssp_dbg_trace(usbssp_data, trace_usbssp_dbg_init, > + "// Halt the USBSSP"); > + usbssp_quiesce(usbssp_data); > + > + ret = usbssp_handshake(&usbssp_data->op_regs->status, > + STS_HALT, STS_HALT, USBSSP_MAX_HALT_USEC); > + > + if (!ret) { > + dev_warn(usbssp_data->dev, "Device halt failed, %d\n", ret); > + return ret; > + } > + > + usbssp_data->usbssp_state |= USBSSP_STATE_HALTED; > + usbssp_data->cmd_ring_state = CMD_RING_STATE_STOPPED; > + return ret; > +} > + > + > +/* > + * Initialize memory for gadget driver and USBSSP (one-time init). > + * > + * Program the PAGESIZE register, initialize the device context array, create > + * device contexts, set up a command ring segment (or two?), create event > + * ring (one for now). > + */ > +int usbssp_init(struct usbssp_udc *usbssp_data) > +{ > + int retval = 0; > + > + spin_lock_init(&usbssp_data->lock); > + spin_lock_init(&usbssp_data->irq_thread_lock); > + > + /*TODO: memory initialization*/ > + //retval = usbssp_mem_init(usbssp_data, GFP_KERNEL); > + > + return retval; > +} > + > #ifdef CONFIG_PM > /* > * Stop DC (not bus-specific) > @@ -50,9 +151,146 @@ int usbssp_resume(struct usbssp_udc *usbssp_data, bool hibernated) > > #endif /* CONFIG_PM */ > > +int usbssp_gen_setup(struct usbssp_udc *usbssp_data) > +{ > + int retval; > + > + mutex_init(&usbssp_data->mutex); > + > + usbssp_data->cap_regs = usbssp_data->regs; > + usbssp_data->op_regs = usbssp_data->regs + > + HC_LENGTH(readl(&usbssp_data->cap_regs->hc_capbase)); > + > + usbssp_data->run_regs = usbssp_data->regs + > + (readl(&usbssp_data->cap_regs->run_regs_off) & RTSOFF_MASK); > + /* Cache read-only capability registers */ > + usbssp_data->hcs_params1 = readl(&usbssp_data->cap_regs->hcs_params1); > + usbssp_data->hcs_params2 = readl(&usbssp_data->cap_regs->hcs_params2); > + usbssp_data->hcs_params3 = readl(&usbssp_data->cap_regs->hcs_params3); > + usbssp_data->hcc_params = readl(&usbssp_data->cap_regs->hc_capbase); > + usbssp_data->hci_version = HC_VERSION(usbssp_data->hcc_params); > + usbssp_data->hcc_params = readl(&usbssp_data->cap_regs->hcc_params); > + usbssp_data->hcc_params2 = readl(&usbssp_data->cap_regs->hcc_params2); > + > + /* Make sure the Device Controller is halted. */ > + retval = usbssp_halt(usbssp_data); > + if (retval) > + return retval; > + > + dev_dbg(usbssp_data->dev, "Resetting Device Controller\n"); do you really need all these dev_dbg prints? You should just fit them to one of the trace event classes that you already have or add a new one if needed. > + /* Reset the internal DC memory state and registers. */ > + /*TODO: add implementation of usbssp_reset function*/ > + //retval = usbssp_reset(usbssp_data); > + if (retval) > + return retval; > + dev_dbg(usbssp_data->dev, "Reset complete\n"); > + > + /* Set dma_mask and coherent_dma_mask to 64-bits, > + * if USBSSP supports 64-bit addressing > + */ > + if (HCC_64BIT_ADDR(usbssp_data->hcc_params) && > + !dma_set_mask(usbssp_data->dev, DMA_BIT_MASK(64))) { > + dev_dbg(usbssp_data->dev, "Enabling 64-bit DMA addresses.\n"); > + dma_set_coherent_mask(usbssp_data->dev, DMA_BIT_MASK(64)); > + } else { > + /* > + * This is to avoid error in cases where a 32-bit USB > + * controller is used on a 64-bit capable system. > + */ > + retval = dma_set_mask(usbssp_data->dev, DMA_BIT_MASK(32)); > + if (retval) > + return retval; > + dev_dbg(usbssp_data->dev, "Enabling 32-bit DMA addresses.\n"); > + dma_set_coherent_mask(usbssp_data->dev, DMA_BIT_MASK(32)); > + } > + > + /* Initialize USBSSP controller data structures. */ > + retval = usbssp_init(usbssp_data); > + if (retval) > + return retval; > + > + dev_info(usbssp_data->dev, "USBSSP params 0x%08x USBSSP version 0x%x\n", > + usbssp_data->hcc_params, usbssp_data->hci_version); > + > + return 0; > +} > + > +/* > + * gadget-if.c file is part of gadget.c file and implements interface > + * for gadget driver > + */ > +#include "gadget-if.c" > + All includes should be together at the beginning of the file. > int usbssp_gadget_init(struct usbssp_udc *usbssp_data) > { > int ret; > + > + /* > + * Check the compiler generated sizes of structures that must be laid > + * out in specific ways for hardware access. > + */ > + BUILD_BUG_ON(sizeof(struct usbssp_doorbell_array) != 2*32/8); > + BUILD_BUG_ON(sizeof(struct usbssp_slot_ctx) != 8*32/8); > + BUILD_BUG_ON(sizeof(struct usbssp_ep_ctx) != 8*32/8); > + /* usbssp_device has eight fields, and also > + * embeds one usbssp_slot_ctx and 31 usbssp_ep_ctx > + */ > + BUILD_BUG_ON(sizeof(struct usbssp_stream_ctx) != 4*32/8); > + BUILD_BUG_ON(sizeof(union usbssp_trb) != 4*32/8); > + BUILD_BUG_ON(sizeof(struct usbssp_erst_entry) != 4*32/8); > + BUILD_BUG_ON(sizeof(struct usbssp_cap_regs) != 8*32/8); > + BUILD_BUG_ON(sizeof(struct usbssp_intr_reg) != 8*32/8); > + /* usbssp_run_regs has eight fields and embeds 128 usbssp_intr_regs */ > + BUILD_BUG_ON(sizeof(struct usbssp_run_regs) != (8+8*128)*32/8); > + > + /* fill gadget fields */ > + /*TODO: implements usbssp_gadget_ops object*/ > + //usbssp_data->gadget.ops = &usbssp_gadget_ops; > + usbssp_data->gadget.name = "usbssp-gadget"; > + usbssp_data->gadget.max_speed = USB_SPEED_SUPER_PLUS; > + usbssp_data->gadget.speed = USB_SPEED_UNKNOWN; > + usbssp_data->gadget.sg_supported = true; > + usbssp_data->gadget.lpm_capable = 1; > + > + usbssp_data->setup_buf = kzalloc(USBSSP_EP0_SETUP_SIZE, GFP_KERNEL); > + if (!usbssp_data->setup_buf) > + return -ENOMEM; > + > + /*USBSSP support not aligned buffer but this option > + * improve performance of this controller. > + */ Multi-line comment formatting. Checkpach should complain. > + usbssp_data->gadget.quirk_ep_out_aligned_size = true; > + ret = usbssp_gen_setup(usbssp_data); > + if (ret < 0) { > + dev_err(usbssp_data->dev, > + "Generic initialization failed with error code%d\n", > + ret); > + goto err3; > + } > + > + ret = usbssp_gadget_init_endpoint(usbssp_data); > + if (ret < 0) { > + dev_err(usbssp_data->dev, "failed to initialize endpoints\n"); > + goto err1; > + } > + > + ret = usb_add_gadget_udc(usbssp_data->dev, &usbssp_data->gadget); > + > + if (ret) { > + dev_err(usbssp_data->dev, "failed to register udc\n"); > + goto err2; > + } > + > + return ret; > +err2: > + usbssp_gadget_free_endpoint(usbssp_data); > +err1: > + usbssp_halt(usbssp_data); > + /*TODO add implementation of usbssp_reset function*/ > + //usbssp_reset(usbssp_data); > + /*TODO add implementation of freeing memory*/ > + //usbssp_mem_cleanup(usbssp_data); > +err3: > return ret; > } > > @@ -60,5 +298,9 @@ int usbssp_gadget_exit(struct usbssp_udc *usbssp_data) > { > int ret = 0; > > + usb_del_gadget_udc(&usbssp_data->gadget); > + usbssp_gadget_free_endpoint(usbssp_data); > + /*TODO: add usbssp_stop implementation*/ > + //usbssp_stop(usbssp_data); > return ret; > } > diff --git a/drivers/usb/usbssp/gadget.h b/drivers/usb/usbssp/gadget.h > index 55e20795d900..5d8918f8da84 100644 > --- a/drivers/usb/usbssp/gadget.h > +++ b/drivers/usb/usbssp/gadget.h > @@ -12,8 +12,10 @@ > #ifndef __LINUX_USBSSP_GADGET_H > #define __LINUX_USBSSP_GADGET_H > > +#include > #include > #include > +#include "gadget-ext-caps.h" > > /* Max number slots - only 1 is allowed */ > #define DEV_MAX_SLOTS 1 > @@ -1676,7 +1678,18 @@ static inline void usbssp_write_64(struct usbssp_udc *usbssp_data, > lo_hi_writeq(val, regs); > } > > +/* USBSSP memory management */ > +void usbssp_dbg_trace(struct usbssp_udc *usbssp_data, > + void (*trace)(struct va_format *), > + const char *fmt, ...); what has this function to do with memory management? > /* USBSSP Device controller glue */ > +void usbssp_bottom_irq(struct work_struct *work); usbssp_bottom_irq() wasn't defined in this patch. > +int usbssp_init(struct usbssp_udc *usbssp_data); > +void usbssp_stop(struct usbssp_udc *usbssp_data); > +int usbssp_handshake(void __iomem *ptr, u32 mask, u32 done, int usec); > +void usbssp_quiesce(struct usbssp_udc *usbssp_data); > +extern int usbssp_reset(struct usbssp_udc *usbssp_data); > + > int usbssp_suspend(struct usbssp_udc *usbssp_data, bool do_wakeup); > int usbssp_resume(struct usbssp_udc *usbssp_data, bool hibernated); > > @@ -1689,6 +1702,8 @@ dma_addr_t usbssp_trb_virt_to_dma(struct usbssp_segment *seg, > /* USBSSP gadget interface*/ > int usbssp_gadget_init(struct usbssp_udc *usbssp_data); > int usbssp_gadget_exit(struct usbssp_udc *usbssp_data); > +void usbssp_gadget_free_endpoint(struct usbssp_udc *usbssp_data); > +int usbssp_gadget_init_endpoint(struct usbssp_udc *usbssp_data); > > static inline char *usbssp_slot_state_string(u32 state) > { > -- cheers, -roger Texas Instruments Finland Oy, Porkkalankatu 22, 00180 Helsinki. Y-tunnus/Business ID: 0615521-4. Kotipaikka/Domicile: Helsinki 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: [05/31] usb: usbssp: Added first part of initialization sequence. From: Roger Quadros Message-Id: <45dff595-5363-bbef-1240-6b693b4829b2@ti.com> Date: Fri, 3 Aug 2018 13:17:54 +0300 To: Pawel Laszczak Cc: Greg Kroah-Hartman , linux-usb@vger.kernel.org, Felipe Balbi , linux-kernel@vger.kernel.org, ltyrala@cadence.com, adouglas@cadence.com List-ID: SGksCgpPbiAxOS8wNy8xOCAyMDo1NywgUGF3ZWwgTGFzemN6YWsgd3JvdGU6Cj4gUGF0Y2ggYWRk cyBzb21lIGluaXRpYWxpemF0aW9uIGZ1bmN0aW9uLiBUaGUgaW5pdGlhbGl6YXRpb24gc2VxdWVu Y2UKPiBpcyBxdWl0ZSBjb21wbGljYXRlZCBhbmQgdGhpcyBwYXRjaCBpbXBsZW1lbnRzIGl0IG9u bHkgcGFydGlhbGx5Lgo+IEluaXRpYWxpemF0aW9uIHdpbGwgYmUgY29tcGxldGVkIGluIG5leHQg ZmV3IHBhdGNoZXMuCj4gCj4gUGF0Y2ggaW50cm9kdWNlIHRocmVlIG5ldyBmaWxlczoKPiAxLiBn YWRnZXQtZGJnLmMgLSBmaWxlIGNvbnRhaW5zIGZ1bmN0aW9ucyB1c2VkIGZvciBkZWJ1Z2dpbmcg cHVycG9zZS4KPiAyLiBnYWRnZXQtZXh0LWNhcHMuaCAtIGhvbGRzIG1hY3JvIGRlZmluaXRpb24g cmVsYXRlZCB0bwo+IAkJICAgICAgIEV4dGVuZGVkIENhcGFiaWxpdGllcwo+IDMuIGdhZGdldC1p ZiAtIGZpbGUgaW1wbGVtZW50cyBzdHVmZiByZWxhdGVkIHRvIHVwcGVyIGxheWVyCj4gCShlLmcg dXNiX2VwX29wcywgdXNiX2dhZGdldF9vcHMgaW50ZXJmYWNlKS4KPiAKPiBTaWduZWQtb2ZmLWJ5 OiBQYXdlbCBMYXN6Y3phayA8cGF3ZWxsQGNhZGVuY2UuY29tPgo+IC0tLQo+ICBkcml2ZXJzL3Vz Yi91c2Jzc3AvTWFrZWZpbGUgICAgICAgICAgfCAgIDEgKwo+ICBkcml2ZXJzL3VzYi91c2Jzc3Av Z2FkZ2V0LWRiZy5jICAgICAgfCAgMzAgKysrKwo+ICBkcml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0 LWV4dC1jYXBzLmggfCAgNTMgKysrKysrCj4gIGRyaXZlcnMvdXNiL3VzYnNzcC9nYWRnZXQtaWYu YyAgICAgICB8ICAyNCArKysKPiAgZHJpdmVycy91c2IvdXNic3NwL2dhZGdldC5jICAgICAgICAg IHwgMjQyICsrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICBkcml2ZXJzL3VzYi91c2Jzc3Av Z2FkZ2V0LmggICAgICAgICAgfCAgMTUgKysKPiAgNiBmaWxlcyBjaGFuZ2VkLCAzNjUgaW5zZXJ0 aW9ucygrKQo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy91c2IvdXNic3NwL2dhZGdldC1k YmcuYwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy91c2IvdXNic3NwL2dhZGdldC1leHQt Y2Fwcy5oCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LWlm LmMKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvdXNic3NwL01ha2VmaWxlIGIvZHJpdmVy cy91c2IvdXNic3NwL01ha2VmaWxlCj4gaW5kZXggZDg1ZjE1YWZiNTFjLi4wNjA2ZjNjNjNjZDAg MTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy91c2IvdXNic3NwL01ha2VmaWxlCj4gKysrIGIvZHJpdmVy cy91c2IvdXNic3NwL01ha2VmaWxlCj4gQEAgLTUsNiArNSw3IEBAIENGTEFHU19nYWRnZXQtdHJh Y2UubyA6PSAtSSQoc3JjKQo+ICBvYmotJChDT05GSUdfVVNCX1VTQlNTUF9HQURHRVQpICs9IHVz YnNzcC5vCj4gIHVzYnNzcC15IAkJCTo9IHVzYnNzcC1wbGF0Lm8gZ2FkZ2V0LXJpbmcubyBcCj4g IAkJCQkgICBnYWRnZXQubwo+ICsJCQkJICAgIGdhZGdldC1kYmcubwo+ICAKPiAgaWZuZXEgKCQo Q09ORklHX1RSQUNJTkcpLCkKPiAgCXVzYnNzcC15CQkrPSBnYWRnZXQtdHJhY2Uubwo+IGRpZmYg LS1naXQgYS9kcml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LWRiZy5jIGIvZHJpdmVycy91c2IvdXNi c3NwL2dhZGdldC1kYmcuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAw MDAwLi4yNzc2MTdkMWE5OTYKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy91c2IvdXNi c3NwL2dhZGdldC1kYmcuYwo+IEBAIC0wLDAgKzEsMzAgQEAKPiArLy8gU1BEWC1MaWNlbnNlLUlk ZW50aWZpZXI6IEdQTC0yLjAKPiArLyoKPiArICogVVNCU1NQIGRldmljZSBjb250cm9sbGVyIGRy aXZlcgo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTggQ2FkZW5jZS4KPiArICoKPiArICog QXV0aG9yOiBQYXdlbCBMYXN6Y3phawo+ICsgKgo+ICsgKiBBIGxvdCBvZiBjb2RlIGJhc2VkIG9u IExpbnV4IFhIQ0kgZHJpdmVyLgo+ICsgKiBPcmlnaW46IENvcHlyaWdodCAoQykgMjAwOCBJbnRl bCBDb3JwCj4gKyAqLwo+ICsKPiArI2luY2x1ZGUgImdhZGdldC5oIgo+ICsKPiArdm9pZCB1c2Jz c3BfZGJnX3RyYWNlKHN0cnVjdCB1c2Jzc3BfdWRjICp1c2Jzc3BfZGF0YSwKPiArCQkgICAgICB2 b2lkICgqdHJhY2UpKHN0cnVjdCB2YV9mb3JtYXQgKiksCj4gKwkJICAgICAgY29uc3QgY2hhciAq Zm10LCAuLi4pCj4gK3sKPiArCXN0cnVjdCB2YV9mb3JtYXQgdmFmOwo+ICsJdmFfbGlzdCBhcmdz Owo+ICsKPiArCXZhX3N0YXJ0KGFyZ3MsIGZtdCk7Cj4gKwl2YWYuZm10ID0gZm10Owo+ICsJdmFm LnZhID0gJmFyZ3M7Cj4gKwlkZXZfZGJnKHVzYnNzcF9kYXRhLT5kZXYsICIlcFZcbiIsICZ2YWYp OwoKZGV2X2RiZyB3aWxsIG1lc3MgdXAgd2l0aCB0aW1pbmdzIHRvIGJlIHVzZWZ1bC4KV2h5IG5v dCBqdXN0IHVzZSBvbmUgb2YgdGhlIHRyYWNlIGV2ZW50cyB5b3UgZGVmaW5lZCBpbiBnYWRnZXQt dHJhY2UuaD8KCj4gKwl0cmFjZSgmdmFmKTsKPiArCXZhX2VuZChhcmdzKTsKPiArfQo+ICtFWFBP UlRfU1lNQk9MX0dQTCh1c2Jzc3BfZGJnX3RyYWNlKTsKPiArCj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvdXNiL3VzYnNzcC9nYWRnZXQtZXh0LWNhcHMuaCBiL2RyaXZlcnMvdXNiL3VzYnNzcC9nYWRn ZXQtZXh0LWNhcHMuaAo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAw Li4yYmYzMjcwNDYzNzYKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy91c2IvdXNic3Nw L2dhZGdldC1leHQtY2Fwcy5oCj4gQEAgLTAsMCArMSw1MyBAQAo+ICsvLyBTUERYLUxpY2Vuc2Ut SWRlbnRpZmllcjogR1BMLTIuMAo+ICsvKgo+ICsgKiBVU0JTU1AgZGV2aWNlIGNvbnRyb2xsZXIg ZHJpdmVyCj4gKyAqCj4gKyAqIENvcHlyaWdodCAoQykgMjAxOCBDYWRlbmNlLgo+ICsgKgo+ICsg KiBBdXRob3I6IFBhd2VsIExhc3pjemFrCj4gKyAqCj4gKyAqIEEgbG90IG9mIGNvZGUgYmFzZWQg b24gTGludXggWEhDSSBkcml2ZXIuCj4gKyAqIE9yaWdpbjogQ29weXJpZ2h0IChDKSAyMDA4IElu dGVsIENvcnAKPiArICovCj4gKwo+ICsvKiBVcCB0byAxNiBtcyB0byBoYWx0IGFuIERDICovCj4g KyNkZWZpbmUgVVNCU1NQX01BWF9IQUxUX1VTRUMJCSgxNioxMDAwKQo+ICsKPiArLyogREMgbm90 IHJ1bm5pbmcgLSBzZXQgdG8gMSB3aGVuIHJ1bi9zdG9wIGJpdCBpcyBjbGVhcmVkLiAqLwo+ICsj ZGVmaW5lIFVTQlNTUF9TVFNfSEFMVAkJCUJJVCgwKQo+ICsKPiArLyogSENDUEFSQU1TIG9mZnNl dCBmcm9tIFBDSSBiYXNlIGFkZHJlc3MgKi8KPiArI2RlZmluZSBVU0JTU1BfSENDX1BBUkFNU19P RkZTRVQJMHgxMAo+ICsvKiBIQ0NQQVJBTVMgY29udGFpbnMgdGhlIGZpcnN0IGV4dGVuZGVkIGNh cGFiaWxpdHkgcG9pbnRlciAqLwo+ICsjZGVmaW5lIFVTQlNTUF9IQ0NfRVhUX0NBUFMocCkJCSgo KHApPj4xNikmMHhmZmZmKQo+ICsKPiArLyogQ29tbWFuZCBhbmQgU3RhdHVzIHJlZ2lzdGVycyBv ZmZzZXQgZnJvbSB0aGUgT3BlcmF0aW9uYWwgUmVnaXN0ZXJzIGFkZHJlc3MgKi8KPiArI2RlZmlu ZSBVU0JTU1BfQ01EX09GRlNFVAkJMHgwMAo+ICsjZGVmaW5lIFVTQlNTUF9TVFNfT0ZGU0VUCQkw eDA0Cj4gKwo+ICsvKiBDYXBhYmlsaXR5IFJlZ2lzdGVyICovCj4gKy8qIGJpdHMgNzowIC0gaG93 IGxvbmcgaXMgdGhlIENhcGFiaWxpdGllcyByZWdpc3RlciAqLwo+ICsjZGVmaW5lIFVTQlNTUF9I Q19MRU5HVEgocCkJCSgoKHApPj4wMCkmMHgwMGZmKQo+ICsKPiArLyogRXh0ZW5kZWQgY2FwYWJp bGl0eSByZWdpc3RlciBmaWVsZHMgKi8KPiArI2RlZmluZSBVU0JTU1BfRVhUX0NBUFNfSUQocCkJ CSgoKHApPj4wKSYweGZmKQo+ICsjZGVmaW5lIFVTQlNTUF9FWFRfQ0FQU19ORVhUKHApCQkoKChw KT4+OCkmMHhmZikKPiArI2RlZmluZQl2X0VYVF9DQVBTX1ZBTChwKQkJKChwKT4+MTYpCj4gKy8q IEV4dGVuZGVkIGNhcGFiaWxpdHkgSURzIC0gSUQgMCByZXNlcnZlZCAqLwo+ICsjZGVmaW5lIFVT QlNTUF9FWFRfQ0FQU19QUk9UT0NPTAkyCj4gKwo+ICsvKiBVU0IgMi4wIGhhcmR3YXJlIExNUCBj YXBhYmlsaXR5Ki8KPiArI2RlZmluZSBVU0JTU1BfSExDCQkJQklUKDE5KQo+ICsjZGVmaW5lIFVT QlNTUF9CTEMJCQlCSVQoMjApCj4gKwo+ICsvKiBjb21tYW5kIHJlZ2lzdGVyIHZhbHVlcyB0byBk aXNhYmxlIGludGVycnVwdHMgYW5kIGhhbHQgdGhlIERDICovCj4gKy8qIHN0YXJ0L3N0b3AgREMg ZXhlY3V0aW9uIC0gZG8gbm90IHdyaXRlIHVubGVzcyBEQyBpcyBoYWx0ZWQqLwo+ICsjZGVmaW5l IFVTQlNTUF9DTURfUlVOCQkJQklUKDApCj4gKy8qIEV2ZW50IEludGVycnVwdCBFbmFibGUgLSBn ZXQgaXJxIHdoZW4gRUlOVCBiaXQgaXMgc2V0IGluIFVTQlNUUyByZWdpc3RlciAqLwo+ICsjZGVm aW5lIFVTQlNTUF9DTURfRUlFCQkJQklUKDIpCj4gKy8qIEhvc3QgU3lzdGVtIEVycm9yIEludGVy cnVwdCBFbmFibGUgLSBnZXQgaXJxIHdoZW4gSFNFSUUgYml0IHNldCBpbiBVU0JTVFMgKi8KPiAr I2RlZmluZSBVU0JTU1BfQ01EX0hTRUlFCQlCSVQoMykKPiArLyogRW5hYmxlIFdyYXAgRXZlbnQg LSAnMScgbWVhbnMgREMgZ2VuZXJhdGVzIGFuIGV2ZW50IHdoZW4gTUZJTkRFWCB3cmFwcy4gKi8K PiArI2RlZmluZSBVU0JTU1BfQ01EX0VXRQkJCUJJVCgxMCkKPiArCj4gKyNkZWZpbmUgVVNCU1NQ X0lSUVMJKFVTQlNTUF9DTURfRUlFIHwgVVNCU1NQX0NNRF9IU0VJRSB8IFVTQlNTUF9DTURfRVdF KQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LWlmLmMgYi9kcml2ZXJz L3VzYi91c2Jzc3AvZ2FkZ2V0LWlmLmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAw MDAwMDAwMDAwMC4uZDUzZTBmYjY1Mjk5Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMv dXNiL3VzYnNzcC9nYWRnZXQtaWYuYwo+IEBAIC0wLDAgKzEsMjQgQEAKPiArLy8gU1BEWC1MaWNl bnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKPiArLyoKPiArICogVVNCU1NQIGRldmljZSBjb250cm9s bGVyIGRyaXZlcgo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTggQ2FkZW5jZS4KPiArICoK PiArICogQXV0aG9yOiBQYXdlbCBMYXN6Y3phawo+ICsgKgo+ICsgKi8KPiArCj4gKyNpbmNsdWRl IDxsaW51eC91c2IvZ2FkZ2V0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC91c2IvY29tcG9zaXRlLmg+ Cj4gKyNpbmNsdWRlICJnYWRnZXQuaCIKPiArCj4gK2ludCB1c2Jzc3BfZ2FkZ2V0X2luaXRfZW5k cG9pbnQoc3RydWN0IHVzYnNzcF91ZGMgKnVzYnNzcF9kYXRhKQo+ICt7Cj4gKwkvKlRPRE86IGl0 IGhhcyB0byBiZSBpbXBsZW1lbnRlZCovCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArdm9pZCB1 c2Jzc3BfZ2FkZ2V0X2ZyZWVfZW5kcG9pbnQoc3RydWN0IHVzYnNzcF91ZGMgKnVzYnNzcF9kYXRh KQo+ICt7Cj4gKwkvKlRPRE86IGl0IGhhcyB0byBiZSBpbXBsZW1lbnRlZCovCj4gK30KPiBkaWZm IC0tZ2l0IGEvZHJpdmVycy91c2IvdXNic3NwL2dhZGdldC5jIGIvZHJpdmVycy91c2IvdXNic3Nw L2dhZGdldC5jCj4gaW5kZXggMmY2MGQ3ZGQxZmU0Li4zMzhlYzJlYzE4YjEgMTAwNjQ0Cj4gLS0t IGEvZHJpdmVycy91c2IvdXNic3NwL2dhZGdldC5jCj4gKysrIGIvZHJpdmVycy91c2IvdXNic3Nw L2dhZGdldC5jCj4gQEAgLTIzLDYgKzIzLDEwNyBAQAo+ICAjaW5jbHVkZSAiZ2FkZ2V0LXRyYWNl LmgiCj4gICNpbmNsdWRlICJnYWRnZXQuaCIKPiAgCj4gKwo+ICsvKgoKLyoqCgo+ICsgKiB1c2Jz c3BfaGFuZHNoYWtlIC0gc3BpbiByZWFkaW5nIGRjIHVudGlsIGhhbmRzaGFrZSBjb21wbGV0ZXMg b3IgZmFpbHMKPiArICogQHB0cjogYWRkcmVzcyBvZiBkYyByZWdpc3RlciB0byBiZSByZWFkCj4g KyAqIEBtYXNrOiBiaXRzIHRvIGxvb2sgYXQgaW4gcmVzdWx0IG9mIHJlYWQKPiArICogQGRvbmU6 IHZhbHVlIG9mIHRob3NlIGJpdHMgd2hlbiBoYW5kc2hha2Ugc3VjY2VlZHMKPiArICogQHVzZWM6 IHRpbWVvdXQgaW4gbWljcm9zZWNvbmRzCj4gKyAqCj4gKyAqIFJldHVybnMgbmVnYXRpdmUgZXJy bm8sIG9yIHplcm8gb24gc3VjY2Vzcwo+ICsgKgo+ICsgKiBTdWNjZXNzIGhhcHBlbnMgd2hlbiB0 aGUgIm1hc2siIGJpdHMgaGF2ZSB0aGUgc3BlY2lmaWVkIHZhbHVlIChoYXJkd2FyZQo+ICsgKiBo YW5kc2hha2UgZG9uZSkuIFRoZXJlIGFyZSB0d28gZmFpbHVyZSBtb2RlczogInVzZWMiIGhhdmUg cGFzc2VkIChtYWpvcgo+ICsgKiBoYXJkd2FyZSBmbGFrZW91dCksIG9yIHRoZSByZWdpc3RlciBy ZWFkcyBhcyBhbGwtb25lcyAoaGFyZHdhcmUgcmVtb3ZlZCkuCj4gKyAqLwo+ICtpbnQgdXNic3Nw X2hhbmRzaGFrZSh2b2lkIF9faW9tZW0gKnB0ciwgdTMyIG1hc2ssIHUzMiBkb25lLCBpbnQgdXNl YykKPiArewo+ICsJdTMyCXJlc3VsdDsKPiArCj4gKwlkbyB7Cj4gKwkJcmVzdWx0ID0gcmVhZGwo cHRyKTsKPiArCQlpZiAocmVzdWx0ID09IH4odTMyKTApCS8qIGNhcmQgcmVtb3ZlZCAqLwo+ICsJ CQlyZXR1cm4gLUVOT0RFVjsKPiArCQlyZXN1bHQgJj0gbWFzazsKPiArCQlpZiAocmVzdWx0ID09 IGRvbmUpCj4gKwkJCXJldHVybiAwOwo+ICsJCXVkZWxheSgxKTsKPiArCQl1c2VjLS07Cj4gKwl9 IHdoaWxlICh1c2VjID4gMCk7Cj4gKwlyZXR1cm4gLUVUSU1FRE9VVDsKPiArfQo+ICsKPiArLyoK PiArICogRGlzYWJsZSBpbnRlcnJ1cHRzIGFuZCBiZWdpbiB0aGUgREMgaGFsdGluZyBwcm9jZXNz Lgo+ICsgKi8KPiArdm9pZCB1c2Jzc3BfcXVpZXNjZShzdHJ1Y3QgdXNic3NwX3VkYyAqdXNic3Nw X2RhdGEpCj4gK3sKPiArCXUzMiBoYWx0ZWQ7Cj4gKwl1MzIgY21kOwo+ICsJdTMyIG1hc2s7Cj4g Kwo+ICsJbWFzayA9IH4odTMyKShVU0JTU1BfSVJRUyk7Cj4gKwo+ICsJaGFsdGVkID0gcmVhZGwo JnVzYnNzcF9kYXRhLT5vcF9yZWdzLT5zdGF0dXMpICYgU1RTX0hBTFQ7Cj4gKwlpZiAoIWhhbHRl ZCkKPiArCQltYXNrICY9IH5DTURfUlVOOwo+ICsKPiArCWNtZCA9IHJlYWRsKCZ1c2Jzc3BfZGF0 YS0+b3BfcmVncy0+Y29tbWFuZCk7Cj4gKwljbWQgJj0gbWFzazsKPiArCXdyaXRlbChjbWQsICZ1 c2Jzc3BfZGF0YS0+b3BfcmVncy0+Y29tbWFuZCk7Cj4gK30KPiArCj4gKy8qCj4gKyAqIEZvcmNl IERDIGludG8gaGFsdCBzdGF0ZS4KPiArICoKPiArICogRGlzYWJsZSBhbnkgSVJRcyBhbmQgY2xl YXIgdGhlIHJ1bi9zdG9wIGJpdC4KPiArICogVVNCU1NQIHdpbGwgY29tcGxldGUgYW55IGN1cnJl bnQgYW5kIGFjdGl2ZWx5IHBpcGVsaW5lZCB0cmFuc2FjdGlvbnMsIGFuZAo+ICsgKiBzaG91bGQg aGFsdCB3aXRoaW4gMTYgbXMgb2YgdGhlIHJ1bi9zdG9wIGJpdCBiZWluZyBjbGVhcmVkLgo+ICsg KiBSZWFkIERDIEhhbHRlZCBiaXQgaW4gdGhlIHN0YXR1cyByZWdpc3RlciB0byBzZWUgd2hlbiB0 aGUgREMgaXMgZmluaXNoZWQuCj4gKyAqLwo+ICtpbnQgdXNic3NwX2hhbHQoc3RydWN0IHVzYnNz cF91ZGMgKnVzYnNzcF9kYXRhKQo+ICt7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXVzYnNzcF9kYmdf dHJhY2UodXNic3NwX2RhdGEsIHRyYWNlX3VzYnNzcF9kYmdfaW5pdCwKPiArCQkJIi8vIEhhbHQg dGhlIFVTQlNTUCIpOwo+ICsJdXNic3NwX3F1aWVzY2UodXNic3NwX2RhdGEpOwo+ICsKPiArCXJl dCA9IHVzYnNzcF9oYW5kc2hha2UoJnVzYnNzcF9kYXRhLT5vcF9yZWdzLT5zdGF0dXMsCj4gKwkJ U1RTX0hBTFQsIFNUU19IQUxULCBVU0JTU1BfTUFYX0hBTFRfVVNFQyk7Cj4gKwo+ICsJaWYgKCFy ZXQpIHsKPiArCQlkZXZfd2Fybih1c2Jzc3BfZGF0YS0+ZGV2LCAiRGV2aWNlIGhhbHQgZmFpbGVk LCAlZFxuIiwgcmV0KTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsKPiArCXVzYnNzcF9kYXRh LT51c2Jzc3Bfc3RhdGUgfD0gVVNCU1NQX1NUQVRFX0hBTFRFRDsKPiArCXVzYnNzcF9kYXRhLT5j bWRfcmluZ19zdGF0ZSA9IENNRF9SSU5HX1NUQVRFX1NUT1BQRUQ7Cj4gKwlyZXR1cm4gcmV0Owo+ ICt9Cj4gKwo+ICsKPiArLyoKPiArICogSW5pdGlhbGl6ZSBtZW1vcnkgZm9yIGdhZGdldCBkcml2 ZXIgYW5kIFVTQlNTUCAob25lLXRpbWUgaW5pdCkuCj4gKyAqCj4gKyAqIFByb2dyYW0gdGhlIFBB R0VTSVpFIHJlZ2lzdGVyLCBpbml0aWFsaXplIHRoZSBkZXZpY2UgY29udGV4dCBhcnJheSwgY3Jl YXRlCj4gKyAqIGRldmljZSBjb250ZXh0cywgc2V0IHVwIGEgY29tbWFuZCByaW5nIHNlZ21lbnQg KG9yIHR3bz8pLCBjcmVhdGUgZXZlbnQKPiArICogcmluZyAob25lIGZvciBub3cpLgo+ICsgKi8K PiAraW50IHVzYnNzcF9pbml0KHN0cnVjdCB1c2Jzc3BfdWRjICp1c2Jzc3BfZGF0YSkKPiArewo+ ICsJaW50IHJldHZhbCA9IDA7Cj4gKwo+ICsJc3Bpbl9sb2NrX2luaXQoJnVzYnNzcF9kYXRhLT5s b2NrKTsKPiArCXNwaW5fbG9ja19pbml0KCZ1c2Jzc3BfZGF0YS0+aXJxX3RocmVhZF9sb2NrKTsK PiArCj4gKwkvKlRPRE86IG1lbW9yeSBpbml0aWFsaXphdGlvbiovCj4gKwkvL3JldHZhbCA9IHVz YnNzcF9tZW1faW5pdCh1c2Jzc3BfZGF0YSwgR0ZQX0tFUk5FTCk7Cj4gKwo+ICsJcmV0dXJuIHJl dHZhbDsKPiArfQo+ICsKPiAgI2lmZGVmIENPTkZJR19QTQo+ICAvKgo+ICAgKiBTdG9wIERDIChu b3QgYnVzLXNwZWNpZmljKQo+IEBAIC01MCw5ICsxNTEsMTQ2IEBAIGludCB1c2Jzc3BfcmVzdW1l KHN0cnVjdCB1c2Jzc3BfdWRjICp1c2Jzc3BfZGF0YSwgYm9vbCBoaWJlcm5hdGVkKQo+ICAKPiAg I2VuZGlmCS8qIENPTkZJR19QTSAqLwo+ICAKPiAraW50IHVzYnNzcF9nZW5fc2V0dXAoc3RydWN0 IHVzYnNzcF91ZGMgKnVzYnNzcF9kYXRhKQo+ICt7Cj4gKwlpbnQgcmV0dmFsOwo+ICsKPiArCW11 dGV4X2luaXQoJnVzYnNzcF9kYXRhLT5tdXRleCk7Cj4gKwo+ICsJdXNic3NwX2RhdGEtPmNhcF9y ZWdzID0gdXNic3NwX2RhdGEtPnJlZ3M7Cj4gKwl1c2Jzc3BfZGF0YS0+b3BfcmVncyA9IHVzYnNz cF9kYXRhLT5yZWdzICsKPiArCQlIQ19MRU5HVEgocmVhZGwoJnVzYnNzcF9kYXRhLT5jYXBfcmVn cy0+aGNfY2FwYmFzZSkpOwo+ICsKPiArCXVzYnNzcF9kYXRhLT5ydW5fcmVncyA9IHVzYnNzcF9k YXRhLT5yZWdzICsKPiArCQkocmVhZGwoJnVzYnNzcF9kYXRhLT5jYXBfcmVncy0+cnVuX3JlZ3Nf b2ZmKSAmIFJUU09GRl9NQVNLKTsKPiArCS8qIENhY2hlIHJlYWQtb25seSBjYXBhYmlsaXR5IHJl Z2lzdGVycyAqLwo+ICsJdXNic3NwX2RhdGEtPmhjc19wYXJhbXMxID0gcmVhZGwoJnVzYnNzcF9k YXRhLT5jYXBfcmVncy0+aGNzX3BhcmFtczEpOwo+ICsJdXNic3NwX2RhdGEtPmhjc19wYXJhbXMy ID0gcmVhZGwoJnVzYnNzcF9kYXRhLT5jYXBfcmVncy0+aGNzX3BhcmFtczIpOwo+ICsJdXNic3Nw X2RhdGEtPmhjc19wYXJhbXMzID0gcmVhZGwoJnVzYnNzcF9kYXRhLT5jYXBfcmVncy0+aGNzX3Bh cmFtczMpOwo+ICsJdXNic3NwX2RhdGEtPmhjY19wYXJhbXMgPSByZWFkbCgmdXNic3NwX2RhdGEt PmNhcF9yZWdzLT5oY19jYXBiYXNlKTsKPiArCXVzYnNzcF9kYXRhLT5oY2lfdmVyc2lvbiA9IEhD X1ZFUlNJT04odXNic3NwX2RhdGEtPmhjY19wYXJhbXMpOwo+ICsJdXNic3NwX2RhdGEtPmhjY19w YXJhbXMgPSByZWFkbCgmdXNic3NwX2RhdGEtPmNhcF9yZWdzLT5oY2NfcGFyYW1zKTsKPiArCXVz YnNzcF9kYXRhLT5oY2NfcGFyYW1zMiA9IHJlYWRsKCZ1c2Jzc3BfZGF0YS0+Y2FwX3JlZ3MtPmhj Y19wYXJhbXMyKTsKPiArCj4gKwkvKiBNYWtlIHN1cmUgdGhlIERldmljZSBDb250cm9sbGVyIGlz IGhhbHRlZC4gKi8KPiArCXJldHZhbCA9IHVzYnNzcF9oYWx0KHVzYnNzcF9kYXRhKTsKPiArCWlm IChyZXR2YWwpCj4gKwkJcmV0dXJuIHJldHZhbDsKPiArCj4gKwlkZXZfZGJnKHVzYnNzcF9kYXRh LT5kZXYsICJSZXNldHRpbmcgRGV2aWNlIENvbnRyb2xsZXJcbiIpOwoKZG8geW91IHJlYWxseSBu ZWVkIGFsbCB0aGVzZSBkZXZfZGJnIHByaW50cz8gWW91IHNob3VsZCBqdXN0IGZpdCB0aGVtIHRv IG9uZQpvZiB0aGUgdHJhY2UgZXZlbnQgY2xhc3NlcyB0aGF0IHlvdSBhbHJlYWR5IGhhdmUgb3Ig YWRkIGEgbmV3IG9uZSBpZiBuZWVkZWQuCgo+ICsJLyogUmVzZXQgdGhlIGludGVybmFsIERDIG1l bW9yeSBzdGF0ZSBhbmQgcmVnaXN0ZXJzLiAqLwo+ICsJLypUT0RPOiBhZGQgaW1wbGVtZW50YXRp b24gb2YgdXNic3NwX3Jlc2V0IGZ1bmN0aW9uKi8KPiArCS8vcmV0dmFsID0gdXNic3NwX3Jlc2V0 KHVzYnNzcF9kYXRhKTsKPiArCWlmIChyZXR2YWwpCj4gKwkJcmV0dXJuIHJldHZhbDsKPiArCWRl dl9kYmcodXNic3NwX2RhdGEtPmRldiwgIlJlc2V0IGNvbXBsZXRlXG4iKTsKPiArCj4gKwkvKiBT ZXQgZG1hX21hc2sgYW5kIGNvaGVyZW50X2RtYV9tYXNrIHRvIDY0LWJpdHMsCj4gKwkgKiBpZiBV U0JTU1Agc3VwcG9ydHMgNjQtYml0IGFkZHJlc3NpbmcKPiArCSAqLwo+ICsJaWYgKEhDQ182NEJJ VF9BRERSKHVzYnNzcF9kYXRhLT5oY2NfcGFyYW1zKSAmJgo+ICsJICAgICFkbWFfc2V0X21hc2so dXNic3NwX2RhdGEtPmRldiwgRE1BX0JJVF9NQVNLKDY0KSkpIHsKPiArCQlkZXZfZGJnKHVzYnNz cF9kYXRhLT5kZXYsICJFbmFibGluZyA2NC1iaXQgRE1BIGFkZHJlc3Nlcy5cbiIpOwo+ICsJCWRt YV9zZXRfY29oZXJlbnRfbWFzayh1c2Jzc3BfZGF0YS0+ZGV2LCBETUFfQklUX01BU0soNjQpKTsK PiArCX0gZWxzZSB7Cj4gKwkJLyoKPiArCQkgKiBUaGlzIGlzIHRvIGF2b2lkIGVycm9yIGluIGNh c2VzIHdoZXJlIGEgMzItYml0IFVTQgo+ICsJCSAqIGNvbnRyb2xsZXIgaXMgdXNlZCBvbiBhIDY0 LWJpdCBjYXBhYmxlIHN5c3RlbS4KPiArCQkgKi8KPiArCQlyZXR2YWwgPSBkbWFfc2V0X21hc2so dXNic3NwX2RhdGEtPmRldiwgRE1BX0JJVF9NQVNLKDMyKSk7Cj4gKwkJaWYgKHJldHZhbCkKPiAr CQkJcmV0dXJuIHJldHZhbDsKPiArCQlkZXZfZGJnKHVzYnNzcF9kYXRhLT5kZXYsICJFbmFibGlu ZyAzMi1iaXQgRE1BIGFkZHJlc3Nlcy5cbiIpOwo+ICsJCWRtYV9zZXRfY29oZXJlbnRfbWFzayh1 c2Jzc3BfZGF0YS0+ZGV2LCBETUFfQklUX01BU0soMzIpKTsKPiArCX0KPiArCj4gKwkvKiBJbml0 aWFsaXplIFVTQlNTUCBjb250cm9sbGVyIGRhdGEgc3RydWN0dXJlcy4gKi8KPiArCXJldHZhbCA9 IHVzYnNzcF9pbml0KHVzYnNzcF9kYXRhKTsKPiArCWlmIChyZXR2YWwpCj4gKwkJcmV0dXJuIHJl dHZhbDsKPiArCj4gKwlkZXZfaW5mbyh1c2Jzc3BfZGF0YS0+ZGV2LCAiVVNCU1NQIHBhcmFtcyAw eCUwOHggVVNCU1NQIHZlcnNpb24gMHgleFxuIiwKPiArCQl1c2Jzc3BfZGF0YS0+aGNjX3BhcmFt cywgdXNic3NwX2RhdGEtPmhjaV92ZXJzaW9uKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsK PiArLyoKPiArICogZ2FkZ2V0LWlmLmMgZmlsZSBpcyBwYXJ0IG9mIGdhZGdldC5jIGZpbGUgYW5k IGltcGxlbWVudHMgaW50ZXJmYWNlCj4gKyAqIGZvciBnYWRnZXQgZHJpdmVyCj4gKyAqLwo+ICsj aW5jbHVkZSAiZ2FkZ2V0LWlmLmMiCj4gKwoKQWxsIGluY2x1ZGVzIHNob3VsZCBiZSB0b2dldGhl ciBhdCB0aGUgYmVnaW5uaW5nIG9mIHRoZSBmaWxlLgoKPiAgaW50IHVzYnNzcF9nYWRnZXRfaW5p dChzdHJ1Y3QgdXNic3NwX3VkYyAqdXNic3NwX2RhdGEpCj4gIHsKPiAgCWludCByZXQ7Cj4gKwo+ ICsJLyoKPiArCSAqIENoZWNrIHRoZSBjb21waWxlciBnZW5lcmF0ZWQgc2l6ZXMgb2Ygc3RydWN0 dXJlcyB0aGF0IG11c3QgYmUgbGFpZAo+ICsJICogb3V0IGluIHNwZWNpZmljIHdheXMgZm9yIGhh cmR3YXJlIGFjY2Vzcy4KPiArCSAqLwo+ICsJQlVJTERfQlVHX09OKHNpemVvZihzdHJ1Y3QgdXNi c3NwX2Rvb3JiZWxsX2FycmF5KSAhPSAyKjMyLzgpOwo+ICsJQlVJTERfQlVHX09OKHNpemVvZihz dHJ1Y3QgdXNic3NwX3Nsb3RfY3R4KSAhPSA4KjMyLzgpOwo+ICsJQlVJTERfQlVHX09OKHNpemVv ZihzdHJ1Y3QgdXNic3NwX2VwX2N0eCkgIT0gOCozMi84KTsKPiArCS8qIHVzYnNzcF9kZXZpY2Ug aGFzIGVpZ2h0IGZpZWxkcywgYW5kIGFsc28KPiArCSAqIGVtYmVkcyBvbmUgdXNic3NwX3Nsb3Rf Y3R4IGFuZCAzMSB1c2Jzc3BfZXBfY3R4Cj4gKwkgKi8KPiArCUJVSUxEX0JVR19PTihzaXplb2Yo c3RydWN0IHVzYnNzcF9zdHJlYW1fY3R4KSAhPSA0KjMyLzgpOwo+ICsJQlVJTERfQlVHX09OKHNp emVvZih1bmlvbiB1c2Jzc3BfdHJiKSAhPSA0KjMyLzgpOwo+ICsJQlVJTERfQlVHX09OKHNpemVv ZihzdHJ1Y3QgdXNic3NwX2Vyc3RfZW50cnkpICE9IDQqMzIvOCk7Cj4gKwlCVUlMRF9CVUdfT04o c2l6ZW9mKHN0cnVjdCB1c2Jzc3BfY2FwX3JlZ3MpICE9IDgqMzIvOCk7Cj4gKwlCVUlMRF9CVUdf T04oc2l6ZW9mKHN0cnVjdCB1c2Jzc3BfaW50cl9yZWcpICE9IDgqMzIvOCk7Cj4gKwkvKiB1c2Jz c3BfcnVuX3JlZ3MgaGFzIGVpZ2h0IGZpZWxkcyBhbmQgZW1iZWRzIDEyOCB1c2Jzc3BfaW50cl9y ZWdzICovCj4gKwlCVUlMRF9CVUdfT04oc2l6ZW9mKHN0cnVjdCB1c2Jzc3BfcnVuX3JlZ3MpICE9 ICg4KzgqMTI4KSozMi84KTsKPiArCj4gKwkvKiBmaWxsIGdhZGdldCBmaWVsZHMgKi8KPiArCS8q VE9ETzogaW1wbGVtZW50cyB1c2Jzc3BfZ2FkZ2V0X29wcyBvYmplY3QqLwo+ICsJLy91c2Jzc3Bf ZGF0YS0+Z2FkZ2V0Lm9wcyA9ICZ1c2Jzc3BfZ2FkZ2V0X29wczsKPiArCXVzYnNzcF9kYXRhLT5n YWRnZXQubmFtZSA9ICJ1c2Jzc3AtZ2FkZ2V0IjsKPiArCXVzYnNzcF9kYXRhLT5nYWRnZXQubWF4 X3NwZWVkID0gVVNCX1NQRUVEX1NVUEVSX1BMVVM7Cj4gKwl1c2Jzc3BfZGF0YS0+Z2FkZ2V0LnNw ZWVkID0gVVNCX1NQRUVEX1VOS05PV047Cj4gKwl1c2Jzc3BfZGF0YS0+Z2FkZ2V0LnNnX3N1cHBv cnRlZCA9IHRydWU7Cj4gKwl1c2Jzc3BfZGF0YS0+Z2FkZ2V0LmxwbV9jYXBhYmxlID0gMTsKPiAr Cj4gKwl1c2Jzc3BfZGF0YS0+c2V0dXBfYnVmID0ga3phbGxvYyhVU0JTU1BfRVAwX1NFVFVQX1NJ WkUsIEdGUF9LRVJORUwpOwo+ICsJaWYgKCF1c2Jzc3BfZGF0YS0+c2V0dXBfYnVmKQo+ICsJCXJl dHVybiAtRU5PTUVNOwo+ICsKPiArCS8qVVNCU1NQIHN1cHBvcnQgbm90IGFsaWduZWQgYnVmZmVy IGJ1dCB0aGlzIG9wdGlvbgo+ICsJICogaW1wcm92ZSBwZXJmb3JtYW5jZSBvZiB0aGlzIGNvbnRy b2xsZXIuCj4gKwkgKi8KCk11bHRpLWxpbmUgY29tbWVudCBmb3JtYXR0aW5nLiBDaGVja3BhY2gg c2hvdWxkIGNvbXBsYWluLgoKPiArCXVzYnNzcF9kYXRhLT5nYWRnZXQucXVpcmtfZXBfb3V0X2Fs aWduZWRfc2l6ZSA9IHRydWU7Cj4gKwlyZXQgPSB1c2Jzc3BfZ2VuX3NldHVwKHVzYnNzcF9kYXRh KTsKPiArCWlmIChyZXQgPCAwKSB7Cj4gKwkJZGV2X2Vycih1c2Jzc3BfZGF0YS0+ZGV2LAo+ICsJ CQkJIkdlbmVyaWMgaW5pdGlhbGl6YXRpb24gZmFpbGVkIHdpdGggZXJyb3IgY29kZSVkXG4iLAo+ ICsJCQkJcmV0KTsKPiArCQlnb3RvIGVycjM7Cj4gKwl9Cj4gKwo+ICsJcmV0ID0gdXNic3NwX2dh ZGdldF9pbml0X2VuZHBvaW50KHVzYnNzcF9kYXRhKTsKPiArCWlmIChyZXQgPCAwKSB7Cj4gKwkJ ZGV2X2Vycih1c2Jzc3BfZGF0YS0+ZGV2LCAiZmFpbGVkIHRvIGluaXRpYWxpemUgZW5kcG9pbnRz XG4iKTsKPiArCQlnb3RvIGVycjE7Cj4gKwl9Cj4gKwo+ICsJcmV0ID0gdXNiX2FkZF9nYWRnZXRf dWRjKHVzYnNzcF9kYXRhLT5kZXYsICZ1c2Jzc3BfZGF0YS0+Z2FkZ2V0KTsKPiArCj4gKwlpZiAo cmV0KSB7Cj4gKwkJZGV2X2Vycih1c2Jzc3BfZGF0YS0+ZGV2LCAiZmFpbGVkIHRvIHJlZ2lzdGVy IHVkY1xuIik7Cj4gKwkJZ290byBlcnIyOwo+ICsJfQo+ICsKPiArCXJldHVybiByZXQ7Cj4gK2Vy cjI6Cj4gKwl1c2Jzc3BfZ2FkZ2V0X2ZyZWVfZW5kcG9pbnQodXNic3NwX2RhdGEpOwo+ICtlcnIx Ogo+ICsJdXNic3NwX2hhbHQodXNic3NwX2RhdGEpOwo+ICsJLypUT0RPIGFkZCBpbXBsZW1lbnRh dGlvbiBvZiB1c2Jzc3BfcmVzZXQgZnVuY3Rpb24qLwo+ICsJLy91c2Jzc3BfcmVzZXQodXNic3Nw X2RhdGEpOwo+ICsJLypUT0RPIGFkZCBpbXBsZW1lbnRhdGlvbiBvZiBmcmVlaW5nIG1lbW9yeSov Cj4gKwkvL3VzYnNzcF9tZW1fY2xlYW51cCh1c2Jzc3BfZGF0YSk7Cj4gK2VycjM6Cj4gIAlyZXR1 cm4gcmV0Owo+ICB9Cj4gIAo+IEBAIC02MCw1ICsyOTgsOSBAQCBpbnQgdXNic3NwX2dhZGdldF9l eGl0KHN0cnVjdCB1c2Jzc3BfdWRjICp1c2Jzc3BfZGF0YSkKPiAgewo+ICAJaW50IHJldCA9IDA7 Cj4gIAo+ICsJdXNiX2RlbF9nYWRnZXRfdWRjKCZ1c2Jzc3BfZGF0YS0+Z2FkZ2V0KTsKPiArCXVz YnNzcF9nYWRnZXRfZnJlZV9lbmRwb2ludCh1c2Jzc3BfZGF0YSk7Cj4gKwkvKlRPRE86IGFkZCB1 c2Jzc3Bfc3RvcCBpbXBsZW1lbnRhdGlvbiovCj4gKwkvL3VzYnNzcF9zdG9wKHVzYnNzcF9kYXRh KTsKPiAgCXJldHVybiByZXQ7Cj4gIH0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvdXNic3Nw L2dhZGdldC5oIGIvZHJpdmVycy91c2IvdXNic3NwL2dhZGdldC5oCj4gaW5kZXggNTVlMjA3OTVk OTAwLi41ZDg5MThmOGRhODQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy91c2IvdXNic3NwL2dhZGdl dC5oCj4gKysrIGIvZHJpdmVycy91c2IvdXNic3NwL2dhZGdldC5oCj4gQEAgLTEyLDggKzEyLDEw IEBACj4gICNpZm5kZWYgX19MSU5VWF9VU0JTU1BfR0FER0VUX0gKPiAgI2RlZmluZSBfX0xJTlVY X1VTQlNTUF9HQURHRVRfSAo+ICAKPiArI2luY2x1ZGUgPGxpbnV4L2lycS5oPgo+ICAjaW5jbHVk ZSA8bGludXgvaW8tNjQtbm9uYXRvbWljLWxvLWhpLmg+Cj4gICNpbmNsdWRlIDxsaW51eC91c2Iv Z2FkZ2V0Lmg+Cj4gKyNpbmNsdWRlICJnYWRnZXQtZXh0LWNhcHMuaCIKPiAgCj4gIC8qIE1heCBu dW1iZXIgc2xvdHMgLSBvbmx5IDEgaXMgYWxsb3dlZCAqLwo+ICAjZGVmaW5lIERFVl9NQVhfU0xP VFMJCTEKPiBAQCAtMTY3Niw3ICsxNjc4LDE4IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCB1c2Jzc3Bf d3JpdGVfNjQoc3RydWN0IHVzYnNzcF91ZGMgKnVzYnNzcF9kYXRhLAo+ICAJbG9faGlfd3JpdGVx KHZhbCwgcmVncyk7Cj4gIH0KPiAgCj4gKy8qIFVTQlNTUCBtZW1vcnkgbWFuYWdlbWVudCAqLwo+ ICt2b2lkIHVzYnNzcF9kYmdfdHJhY2Uoc3RydWN0IHVzYnNzcF91ZGMgKnVzYnNzcF9kYXRhLAo+ ICsJCXZvaWQgKCp0cmFjZSkoc3RydWN0IHZhX2Zvcm1hdCAqKSwKPiArCQljb25zdCBjaGFyICpm bXQsIC4uLik7Cgp3aGF0IGhhcyB0aGlzIGZ1bmN0aW9uIHRvIGRvIHdpdGggbWVtb3J5IG1hbmFn ZW1lbnQ/Cgo+ICAvKiBVU0JTU1AgRGV2aWNlIGNvbnRyb2xsZXIgZ2x1ZSAqLwo+ICt2b2lkIHVz YnNzcF9ib3R0b21faXJxKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yayk7Cgp1c2Jzc3BfYm90dG9t X2lycSgpIHdhc24ndCBkZWZpbmVkIGluIHRoaXMgcGF0Y2guCgo+ICtpbnQgdXNic3NwX2luaXQo c3RydWN0IHVzYnNzcF91ZGMgKnVzYnNzcF9kYXRhKTsKPiArdm9pZCB1c2Jzc3Bfc3RvcChzdHJ1 Y3QgdXNic3NwX3VkYyAqdXNic3NwX2RhdGEpOwo+ICtpbnQgdXNic3NwX2hhbmRzaGFrZSh2b2lk IF9faW9tZW0gKnB0ciwgdTMyIG1hc2ssIHUzMiBkb25lLCBpbnQgdXNlYyk7Cj4gK3ZvaWQgdXNi c3NwX3F1aWVzY2Uoc3RydWN0IHVzYnNzcF91ZGMgKnVzYnNzcF9kYXRhKTsKPiArZXh0ZXJuIGlu dCB1c2Jzc3BfcmVzZXQoc3RydWN0IHVzYnNzcF91ZGMgKnVzYnNzcF9kYXRhKTsKPiArCj4gIGlu dCB1c2Jzc3Bfc3VzcGVuZChzdHJ1Y3QgdXNic3NwX3VkYyAqdXNic3NwX2RhdGEsIGJvb2wgZG9f d2FrZXVwKTsKPiAgaW50IHVzYnNzcF9yZXN1bWUoc3RydWN0IHVzYnNzcF91ZGMgKnVzYnNzcF9k YXRhLCBib29sIGhpYmVybmF0ZWQpOwo+ICAKPiBAQCAtMTY4OSw2ICsxNzAyLDggQEAgZG1hX2Fk ZHJfdCB1c2Jzc3BfdHJiX3ZpcnRfdG9fZG1hKHN0cnVjdCB1c2Jzc3Bfc2VnbWVudCAqc2VnLAo+ ICAvKiBVU0JTU1AgZ2FkZ2V0IGludGVyZmFjZSovCj4gIGludCB1c2Jzc3BfZ2FkZ2V0X2luaXQo c3RydWN0IHVzYnNzcF91ZGMgKnVzYnNzcF9kYXRhKTsKPiAgaW50IHVzYnNzcF9nYWRnZXRfZXhp dChzdHJ1Y3QgdXNic3NwX3VkYyAqdXNic3NwX2RhdGEpOwo+ICt2b2lkIHVzYnNzcF9nYWRnZXRf ZnJlZV9lbmRwb2ludChzdHJ1Y3QgdXNic3NwX3VkYyAqdXNic3NwX2RhdGEpOwo+ICtpbnQgdXNi c3NwX2dhZGdldF9pbml0X2VuZHBvaW50KHN0cnVjdCB1c2Jzc3BfdWRjICp1c2Jzc3BfZGF0YSk7 Cj4gIAo+ICBzdGF0aWMgaW5saW5lIGNoYXIgKnVzYnNzcF9zbG90X3N0YXRlX3N0cmluZyh1MzIg c3RhdGUpCj4gIHsKPgo=