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 E7851C28CF6 for ; Fri, 3 Aug 2018 10:42:34 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 74C6A2174D for ; Fri, 3 Aug 2018 10:42:34 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=ti.com header.i=@ti.com header.b="ZSdaXxKW" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 74C6A2174D 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 S1732607AbeHCMiP (ORCPT ); Fri, 3 Aug 2018 08:38:15 -0400 Received: from fllv0016.ext.ti.com ([198.47.19.142]:44000 "EHLO fllv0016.ext.ti.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1732233AbeHCMiP (ORCPT ); Fri, 3 Aug 2018 08:38:15 -0400 Received: from dlelxv90.itg.ti.com ([172.17.2.17]) by fllv0016.ext.ti.com (8.15.2/8.15.2) with ESMTP id w73AgRr5049494; Fri, 3 Aug 2018 05:42:27 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ti.com; s=ti-com-17Q1; t=1533292947; bh=wGRrBmuD894yylpUIPisP8FyiD5YOTn9Jki1pfM9rmE=; h=Subject:To:CC:References:From:Date:In-Reply-To; b=ZSdaXxKWj3O7opQE1CieAB5+cCewGisCm2Hr9N2IchlXgPzCOYCem5tuTBqeSFi7s Ky5K7kxByYSiSU+r+Y4IygpAGfS8knXwNf6SHrK/3idaxtu+D8FWqftT8dQ7iYz9Ve 5+BkGPPxL0lfnSw8NHftVjrBS0FhyhnWJUMd11lI= Received: from DFLE102.ent.ti.com (dfle102.ent.ti.com [10.64.6.23]) by dlelxv90.itg.ti.com (8.14.3/8.13.8) with ESMTP id w73AgQdc004452; Fri, 3 Aug 2018 05:42:26 -0500 Received: from DFLE104.ent.ti.com (10.64.6.25) by DFLE102.ent.ti.com (10.64.6.23) 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:42:26 -0500 Received: from dlep33.itg.ti.com (157.170.170.75) by DFLE104.ent.ti.com (10.64.6.25) 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:42:26 -0500 Received: from [192.168.2.6] (ileax41-snat.itg.ti.com [10.172.224.153]) by dlep33.itg.ti.com (8.14.3/8.13.8) with ESMTP id w73AgObQ032644; Fri, 3 Aug 2018 05:42:24 -0500 Subject: Re: [PATCH 06/31] usb: usbssp: added template functions used by upper layer. To: Pawel Laszczak CC: Greg Kroah-Hartman , , Felipe Balbi , , , References: <1532023084-28083-1-git-send-email-pawell@cadence.com> <1532023084-28083-7-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: <0aad2e70-c630-feac-24a9-35d66360e4b2@ti.com> Date: Fri, 3 Aug 2018 13:42:23 +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-7-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 On 19/07/18 20:57, Pawel Laszczak wrote: > Patch adds some functionality for initialization process. > It adds to driver usbssp_reset and usbssp_start function. > > Next elements added are objects usbssp_gadget_ep0_ops, > usbssp_gadget_ep_ops and usbssp_gadget_ops. These objects > constitute the interface used by gadget subsystem. > At this moment functions related to these objects are empty > and do nothing. > > This patch also implements usbssp_gadget_init_endpoint and > usbssp_gadget_free_endpoint used during initialization. > > Signed-off-by: Pawel Laszczak > --- > drivers/usb/usbssp/gadget-ext-caps.h | 3 + > drivers/usb/usbssp/gadget-if.c | 269 ++++++++++++++++++++++++++- > drivers/usb/usbssp/gadget.c | 84 ++++++++- > 3 files changed, 350 insertions(+), 6 deletions(-) > > diff --git a/drivers/usb/usbssp/gadget-ext-caps.h b/drivers/usb/usbssp/gadget-ext-caps.h > index 2bf327046376..86c0ce331037 100644 > --- a/drivers/usb/usbssp/gadget-ext-caps.h > +++ b/drivers/usb/usbssp/gadget-ext-caps.h > @@ -51,3 +51,6 @@ > #define USBSSP_CMD_EWE BIT(10) > > #define USBSSP_IRQS (USBSSP_CMD_EIE | USBSSP_CMD_HSEIE | USBSSP_CMD_EWE) > + > +/* true: Controller Not Ready to accept doorbell or op reg writes after reset */ > +#define USBSSP_STS_CNR BIT(11) > diff --git a/drivers/usb/usbssp/gadget-if.c b/drivers/usb/usbssp/gadget-if.c > index d53e0fb65299..70def978b085 100644 > --- a/drivers/usb/usbssp/gadget-if.c > +++ b/drivers/usb/usbssp/gadget-if.c > @@ -12,13 +12,278 @@ > #include > #include "gadget.h" > > +static int usbssp_gadget_ep_enable(struct usb_ep *ep, > + const struct usb_endpoint_descriptor *desc) > +{ > + struct usbssp_ep *ep_priv = to_usbssp_ep(ep); > + int ret = 0; > + > + if (!ep_priv) > + return -EINVAL; > + > + /*TODO: implements this function*/ > + return ret; > +} > + > +int usbssp_gadget_ep_disable(struct usb_ep *ep) > +{ > + struct usbssp_ep *ep_priv = to_usbssp_ep(ep); > + int ret = 0; > + > + if (!ep_priv) > + return -EINVAL; > + > + /*TODO: implements this function*/ > + return ret; > +} > + > +static struct usb_request *usbssp_gadget_ep_alloc_request(struct usb_ep *ep, > + gfp_t gfp_flags) > +{ > + struct usbssp_ep *ep_priv = to_usbssp_ep(ep); > + > + if (!ep_priv) > + return NULL; > + > + /*TODO: implements this function*/ > + return NULL; > +} > + > +static void usbssp_gadget_ep_free_request(struct usb_ep *ep, > + struct usb_request *request) > +{ > + struct usbssp_ep *ep_priv = to_usbssp_ep(ep); > + > + if (!ep_priv) > + return; > + > + /*TODO: implements this function*/ > +} > + > +static int usbssp_gadget_ep_queue(struct usb_ep *ep, > + struct usb_request *request, > + gfp_t gfp_flags) > +{ > + struct usbssp_ep *ep_priv = to_usbssp_ep(ep); > + int ret = 0; > + > + if (!ep_priv) > + return -EINVAL; > + > + /*TODO: implements this function*/ > + return ret; > +} > + > +static int usbssp_gadget_ep_dequeue(struct usb_ep *ep, > + struct usb_request *request) > +{ > + struct usbssp_ep *ep_priv = to_usbssp_ep(ep); > + int ret = 0; > + > + if (!ep_priv) > + return -EINVAL; > + > + /*TODO: implements this function*/ > + return ret; > +} > + > +static int usbssp_gadget_ep_set_halt(struct usb_ep *ep, int value) > +{ > + struct usbssp_ep *ep_priv = to_usbssp_ep(ep); > + int ret = 0; > + > + if (!ep_priv) > + return -EINVAL; > + > + /*TODO: implements this function*/ > + return ret; > +} > + > +static int usbssp_gadget_ep_set_wedge(struct usb_ep *ep) > +{ > + struct usbssp_ep *ep_priv = to_usbssp_ep(ep); > + int ret = 0; > + > + if (!ep_priv) > + return -EINVAL; > + > + /*TODO: implements this function*/ > + return ret; > +} > + > +static const struct usb_ep_ops usbssp_gadget_ep0_ops = { > + .enable = usbssp_gadget_ep_enable, > + .disable = usbssp_gadget_ep_disable, > + .alloc_request = usbssp_gadget_ep_alloc_request, > + .free_request = usbssp_gadget_ep_free_request, > + .queue = usbssp_gadget_ep_queue, > + .dequeue = usbssp_gadget_ep_dequeue, > + .set_halt = usbssp_gadget_ep_set_halt, > + .set_wedge = usbssp_gadget_ep_set_wedge, > +}; > + > +static const struct usb_ep_ops usbssp_gadget_ep_ops = { > + .enable = usbssp_gadget_ep_enable, > + .disable = usbssp_gadget_ep_disable, > + .alloc_request = usbssp_gadget_ep_alloc_request, > + .free_request = usbssp_gadget_ep_free_request, > + .queue = usbssp_gadget_ep_queue, > + .dequeue = usbssp_gadget_ep_dequeue, > + .set_halt = usbssp_gadget_ep_set_halt, > + .set_wedge = usbssp_gadget_ep_set_wedge, > +}; > + > +static struct usb_endpoint_descriptor usbssp_gadget_ep0_desc = { > + .bLength = USB_DT_ENDPOINT_SIZE, > + .bDescriptorType = USB_DT_ENDPOINT, > + .bmAttributes = USB_ENDPOINT_XFER_CONTROL, > +}; > + > +static int usbssp_gadget_start(struct usb_gadget *g, > + struct usb_gadget_driver *driver) > +{ > + struct usbssp_udc *usbssp_data = gadget_to_usbssp(g); > + int ret = 0; > + > + if (usbssp_data->gadget_driver) { > + dev_err(usbssp_data->dev, "%s is already bound to %s\n", > + usbssp_data->gadget.name, > + usbssp_data->gadget_driver->driver.name); > + ret = -EBUSY; > + } > + > + /*TODO: add implementation*/ > + return ret; > +} > + > +static int usbssp_gadget_stop(struct usb_gadget *g) > +{ > + struct usbssp_udc *usbssp_data = gadget_to_usbssp(g); > + > + if (!usbssp_data) > + return -EINVAL; > + /*TODO: add implementation*/ > + return 0; > +} > + > +static int usbssp_gadget_get_frame(struct usb_gadget *g) > +{ > + struct usbssp_udc *usbssp_data = gadget_to_usbssp(g); > + > + if (!usbssp_data) > + return -EINVAL; > + > + /*TODO: add implementation*/ > + return 0; > +} > + > +static int usbssp_gadget_wakeup(struct usb_gadget *g) > +{ > + struct usbssp_udc *usbssp_data = gadget_to_usbssp(g); > + > + if (!usbssp_data) > + return -EINVAL; > + > + /*TODO: add implementation*/ > + return 0; > +} > + > +static int usbssp_gadget_set_selfpowered(struct usb_gadget *g, > + int is_selfpowered) > +{ > + struct usbssp_udc *usbssp_data = gadget_to_usbssp(g); > + > + if (!usbssp_data) > + return -EINVAL; > + > + /*TODO: add implementation*/ > + return 0; > +} > + > +static const struct usb_gadget_ops usbssp_gadget_ops = { > + .get_frame = usbssp_gadget_get_frame, > + .wakeup = usbssp_gadget_wakeup, > + .set_selfpowered = usbssp_gadget_set_selfpowered, > + .udc_start = usbssp_gadget_start, > + .udc_stop = usbssp_gadget_stop, > +}; > + > int usbssp_gadget_init_endpoint(struct usbssp_udc *usbssp_data) Since we're initializing all endpoints this function should be named usbssp_gadget_init_endpoints(). > { > - /*TODO: it has to be implemented*/ > + int i = 0; > + struct usbssp_ep *ep_priv; > + > + usbssp_data->num_endpoints = USBSSP_ENDPOINTS_NUM; > + INIT_LIST_HEAD(&usbssp_data->gadget.ep_list); > + > + for (i = 1; i < usbssp_data->num_endpoints; i++) { > + bool direction = i & 1; /*start from OUT endpoint*/ > + u8 epnum = (i >> 1); > + > + ep_priv = &usbssp_data->devs.eps[i-1]; > + ep_priv->usbssp_data = usbssp_data; > + ep_priv->number = epnum; > + ep_priv->direction = direction; /*0 for OUT, 1 for IN*/ > + > + snprintf(ep_priv->name, sizeof(ep_priv->name), "ep%d%s", epnum, > + (ep_priv->direction) ? "in" : "out"); > + > + ep_priv->endpoint.name = ep_priv->name; > + > + if (ep_priv->number < 2) { > + ep_priv->endpoint.desc = &usbssp_gadget_ep0_desc; > + ep_priv->endpoint.comp_desc = NULL; > + } > + > + if (epnum == 0) { > + /*EP0 is bidirectional endpoint*/ > + usb_ep_set_maxpacket_limit(&ep_priv->endpoint, 512); > + dev_dbg(usbssp_data->dev, > + "Initializing %s, MaxPack: %04x Type: Ctrl\n", > + ep_priv->name, 512); > + ep_priv->endpoint.maxburst = 1; > + ep_priv->endpoint.ops = &usbssp_gadget_ep0_ops; > + ep_priv->endpoint.caps.type_control = true; > + > + usbssp_data->usb_req_ep0_in.epnum = ep_priv->number; > + usbssp_data->usb_req_ep0_in.dep = ep_priv; > + > + if (!epnum) > + usbssp_data->gadget.ep0 = &ep_priv->endpoint; > + } else { > + usb_ep_set_maxpacket_limit(&ep_priv->endpoint, 1024); > + ep_priv->endpoint.maxburst = 15; > + ep_priv->endpoint.ops = &usbssp_gadget_ep_ops; > + list_add_tail(&ep_priv->endpoint.ep_list, > + &usbssp_data->gadget.ep_list); > + ep_priv->endpoint.caps.type_iso = true; > + ep_priv->endpoint.caps.type_bulk = true; > + ep_priv->endpoint.caps.type_int = true; > + > + } > + > + ep_priv->endpoint.caps.dir_in = direction; > + ep_priv->endpoint.caps.dir_out = !direction; Since you start from 1, ep0 will only be initialized as dir_in. Is it better to represent EP0in and EP0out separately? If so you can start i from 0 and use ep_priv = &usbssp_data->devs.eps[i]; This should fix the direction. eps[0] will be ep0out and eps[1] will be ep0in. > + > + dev_dbg(usbssp_data->dev, "Init %s, MaxPack: %04x SupType:" > + " INT/BULK/ISOC , SupDir %s\n", > + ep_priv->name, 1024, > + (ep_priv->endpoint.caps.dir_in) ? "IN" : "OUT"); > + > + INIT_LIST_HEAD(&ep_priv->pending_list); > + } > return 0; > } > > void usbssp_gadget_free_endpoint(struct usbssp_udc *usbssp_data) > { > - /*TODO: it has to be implemented*/ > + int i; > + struct usbssp_ep *ep_priv; > + > + for (i = 0; i < usbssp_data->num_endpoints; i++) { > + ep_priv = &usbssp_data->devs.eps[i]; > + if you start i from 1 then you can skip the if(). > + if (ep_priv->number != 0) > + list_del(&ep_priv->endpoint.ep_list); > + } > } > diff --git a/drivers/usb/usbssp/gadget.c b/drivers/usb/usbssp/gadget.c > index 338ec2ec18b1..195f5777cf8a 100644 > --- a/drivers/usb/usbssp/gadget.c > +++ b/drivers/usb/usbssp/gadget.c > @@ -103,6 +103,83 @@ int usbssp_halt(struct usbssp_udc *usbssp_data) > return ret; > } > > +/* > + * Set the run bit and wait for the device to be running. > + */ > +int usbssp_start(struct usbssp_udc *usbssp_data) > +{ > + u32 temp; > + int ret; > + > + temp = readl(&usbssp_data->op_regs->command); > + temp |= (CMD_RUN | CMD_DEVEN); > + usbssp_dbg_trace(usbssp_data, trace_usbssp_dbg_init, > + "// Turn on USBSSP, cmd = 0x%x.", temp); > + writel(temp, &usbssp_data->op_regs->command); > + > + /* > + * Wait for the HCHalted Staus bit to be 0 to indicate the device is > + * running. > + */ > + ret = usbssp_handshake(&usbssp_data->op_regs->status, > + STS_HALT, 0, USBSSP_MAX_HALT_USEC); > + > + if (ret == -ETIMEDOUT) > + dev_err(usbssp_data->dev, "Device took too long to start, waited %u microseconds.\n", > + USBSSP_MAX_HALT_USEC); > + if (!ret) > + /* clear state flags. Including dying, halted or removing */ > + usbssp_data->usbssp_state = 0; > + > + return ret; > +} > + > +/* > + * Reset a halted DC. > + * > + * This resets pipelines, timers, counters, state machines, etc. > + * Transactions will be terminated immediately, and operational registers > + * will be set to their defaults. > + */ > +int usbssp_reset(struct usbssp_udc *usbssp_data) > +{ > + u32 command; > + u32 state; > + int ret; > + > + state = readl(&usbssp_data->op_regs->status); > + > + if (state == ~(u32)0) { > + dev_warn(usbssp_data->dev, "Device not accessible, reset failed.\n"); > + return -ENODEV; > + } > + > + if ((state & STS_HALT) == 0) { > + dev_warn(usbssp_data->dev, "DC not halted, aborting reset.\n"); DC is not a familiar abbreviation. Mabe just use Controller? or Device controller. > + return 0; > + } > + > + usbssp_dbg_trace(usbssp_data, trace_usbssp_dbg_init, "// Reset the DC"); > + command = readl(&usbssp_data->op_regs->command); > + command |= CMD_RESET; > + writel(command, &usbssp_data->op_regs->command); > + > + ret = usbssp_handshake(&usbssp_data->op_regs->command, > + CMD_RESET, 0, 10 * 1000 * 1000); > + > + if (ret) > + return ret; > + usbssp_dbg_trace(usbssp_data, trace_usbssp_dbg_init, > + "Wait for controller to be ready for doorbell rings"); > + /* > + * USBSSP cannot write to any doorbells or operational registers other > + * than status until the "Controller Not Ready" flag is cleared. > + */ > + ret = usbssp_handshake(&usbssp_data->op_regs->status, > + STS_CNR, 0, 10 * 1000 * 1000); > + > + return ret; > +} > > /* > * Initialize memory for gadget driver and USBSSP (one-time init). > @@ -179,8 +256,7 @@ int usbssp_gen_setup(struct usbssp_udc *usbssp_data) > > dev_dbg(usbssp_data->dev, "Resetting Device Controller\n"); > /* Reset the internal DC memory state and registers. */ > - /*TODO: add implementation of usbssp_reset function*/ > - //retval = usbssp_reset(usbssp_data); > + retval = usbssp_reset(usbssp_data); > if (retval) > return retval; > dev_dbg(usbssp_data->dev, "Reset complete\n"); > @@ -244,8 +320,7 @@ int usbssp_gadget_init(struct usbssp_udc *usbssp_data) > 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.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; > @@ -288,6 +363,7 @@ int usbssp_gadget_init(struct usbssp_udc *usbssp_data) > usbssp_halt(usbssp_data); > /*TODO add implementation of usbssp_reset function*/ > //usbssp_reset(usbssp_data); > + usbssp_reset(usbssp_data); > /*TODO add implementation of freeing memory*/ > //usbssp_mem_cleanup(usbssp_data); > err3: > -- 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: [06/31] usb: usbssp: added template functions used by upper layer. From: Roger Quadros Message-Id: <0aad2e70-c630-feac-24a9-35d66360e4b2@ti.com> Date: Fri, 3 Aug 2018 13:42:23 +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: T24gMTkvMDcvMTggMjA6NTcsIFBhd2VsIExhc3pjemFrIHdyb3RlOgo+IFBhdGNoIGFkZHMgc29t ZSBmdW5jdGlvbmFsaXR5IGZvciBpbml0aWFsaXphdGlvbiBwcm9jZXNzLgo+IEl0IGFkZHMgdG8g ZHJpdmVyIHVzYnNzcF9yZXNldCBhbmQgdXNic3NwX3N0YXJ0IGZ1bmN0aW9uLgo+IAo+IE5leHQg ZWxlbWVudHMgYWRkZWQgYXJlIG9iamVjdHMgdXNic3NwX2dhZGdldF9lcDBfb3BzLAo+IHVzYnNz cF9nYWRnZXRfZXBfb3BzIGFuZCB1c2Jzc3BfZ2FkZ2V0X29wcy4gVGhlc2Ugb2JqZWN0cwo+IGNv bnN0aXR1dGUgdGhlIGludGVyZmFjZSB1c2VkIGJ5IGdhZGdldCBzdWJzeXN0ZW0uCj4gQXQgdGhp cyBtb21lbnQgZnVuY3Rpb25zIHJlbGF0ZWQgdG8gdGhlc2Ugb2JqZWN0cyBhcmUgZW1wdHkKPiBh bmQgZG8gbm90aGluZy4KPiAKPiBUaGlzIHBhdGNoIGFsc28gaW1wbGVtZW50cyB1c2Jzc3BfZ2Fk Z2V0X2luaXRfZW5kcG9pbnQgYW5kCj4gdXNic3NwX2dhZGdldF9mcmVlX2VuZHBvaW50IHVzZWQg ZHVyaW5nIGluaXRpYWxpemF0aW9uLgo+IAo+IFNpZ25lZC1vZmYtYnk6IFBhd2VsIExhc3pjemFr IDxwYXdlbGxAY2FkZW5jZS5jb20+Cj4gLS0tCj4gIGRyaXZlcnMvdXNiL3VzYnNzcC9nYWRnZXQt ZXh0LWNhcHMuaCB8ICAgMyArCj4gIGRyaXZlcnMvdXNiL3VzYnNzcC9nYWRnZXQtaWYuYyAgICAg ICB8IDI2OSArKysrKysrKysrKysrKysrKysrKysrKysrKy0KPiAgZHJpdmVycy91c2IvdXNic3Nw L2dhZGdldC5jICAgICAgICAgIHwgIDg0ICsrKysrKysrLQo+ICAzIGZpbGVzIGNoYW5nZWQsIDM1 MCBpbnNlcnRpb25zKCspLCA2IGRlbGV0aW9ucygtKQo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJz L3VzYi91c2Jzc3AvZ2FkZ2V0LWV4dC1jYXBzLmggYi9kcml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0 LWV4dC1jYXBzLmgKPiBpbmRleCAyYmYzMjcwNDYzNzYuLjg2YzBjZTMzMTAzNyAxMDA2NDQKPiAt LS0gYS9kcml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LWV4dC1jYXBzLmgKPiArKysgYi9kcml2ZXJz L3VzYi91c2Jzc3AvZ2FkZ2V0LWV4dC1jYXBzLmgKPiBAQCAtNTEsMyArNTEsNiBAQAo+ICAjZGVm aW5lIFVTQlNTUF9DTURfRVdFCQkJQklUKDEwKQo+ICAKPiAgI2RlZmluZSBVU0JTU1BfSVJRUwko VVNCU1NQX0NNRF9FSUUgfCBVU0JTU1BfQ01EX0hTRUlFIHwgVVNCU1NQX0NNRF9FV0UpCj4gKwo+ ICsvKiB0cnVlOiBDb250cm9sbGVyIE5vdCBSZWFkeSB0byBhY2NlcHQgZG9vcmJlbGwgb3Igb3Ag cmVnIHdyaXRlcyBhZnRlciByZXNldCAqLwo+ICsjZGVmaW5lIFVTQlNTUF9TVFNfQ05SCQkJQklU KDExKQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LWlmLmMgYi9kcml2 ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LWlmLmMKPiBpbmRleCBkNTNlMGZiNjUyOTkuLjcwZGVmOTc4 YjA4NSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LWlmLmMKPiArKysg Yi9kcml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LWlmLmMKPiBAQCAtMTIsMTMgKzEyLDI3OCBAQAo+ ICAjaW5jbHVkZSA8bGludXgvdXNiL2NvbXBvc2l0ZS5oPgo+ICAjaW5jbHVkZSAiZ2FkZ2V0Lmgi Cj4gIAo+ICtzdGF0aWMgaW50IHVzYnNzcF9nYWRnZXRfZXBfZW5hYmxlKHN0cnVjdCB1c2JfZXAg KmVwLAo+ICsJCQkJICAgY29uc3Qgc3RydWN0IHVzYl9lbmRwb2ludF9kZXNjcmlwdG9yICpkZXNj KQo+ICt7Cj4gKwlzdHJ1Y3QgdXNic3NwX2VwICplcF9wcml2ID0gdG9fdXNic3NwX2VwKGVwKTsK PiArCWludCByZXQgPSAwOwo+ICsKPiArCWlmICghZXBfcHJpdikKPiArCQlyZXR1cm4gLUVJTlZB TDsKPiArCj4gKwkvKlRPRE86IGltcGxlbWVudHMgdGhpcyBmdW5jdGlvbiovCj4gKwlyZXR1cm4g cmV0Owo+ICt9Cj4gKwo+ICtpbnQgdXNic3NwX2dhZGdldF9lcF9kaXNhYmxlKHN0cnVjdCB1c2Jf ZXAgKmVwKQo+ICt7Cj4gKwlzdHJ1Y3QgdXNic3NwX2VwICplcF9wcml2ID0gdG9fdXNic3NwX2Vw KGVwKTsKPiArCWludCByZXQgPSAwOwo+ICsKPiArCWlmICghZXBfcHJpdikKPiArCQlyZXR1cm4g LUVJTlZBTDsKPiArCj4gKwkvKlRPRE86IGltcGxlbWVudHMgdGhpcyBmdW5jdGlvbiovCj4gKwly ZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgc3RydWN0IHVzYl9yZXF1ZXN0ICp1c2Jzc3Bf Z2FkZ2V0X2VwX2FsbG9jX3JlcXVlc3Qoc3RydWN0IHVzYl9lcCAqZXAsCj4gKwkJCQkJCQkgIGdm cF90IGdmcF9mbGFncykKPiArewo+ICsJc3RydWN0IHVzYnNzcF9lcCAqZXBfcHJpdiA9IHRvX3Vz YnNzcF9lcChlcCk7Cj4gKwo+ICsJaWYgKCFlcF9wcml2KQo+ICsJCXJldHVybiBOVUxMOwo+ICsK PiArCS8qVE9ETzogaW1wbGVtZW50cyB0aGlzIGZ1bmN0aW9uKi8KPiArCXJldHVybiBOVUxMOwo+ ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB1c2Jzc3BfZ2FkZ2V0X2VwX2ZyZWVfcmVxdWVzdChzdHJ1 Y3QgdXNiX2VwICplcCwKPiArCQkJCQkgIHN0cnVjdCB1c2JfcmVxdWVzdCAqcmVxdWVzdCkKPiAr ewo+ICsJc3RydWN0IHVzYnNzcF9lcCAqZXBfcHJpdiA9IHRvX3VzYnNzcF9lcChlcCk7Cj4gKwo+ ICsJaWYgKCFlcF9wcml2KQo+ICsJCXJldHVybjsKPiArCj4gKwkvKlRPRE86IGltcGxlbWVudHMg dGhpcyBmdW5jdGlvbiovCj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdXNic3NwX2dhZGdldF9lcF9x dWV1ZShzdHJ1Y3QgdXNiX2VwICplcCwKPiArCQkJCSAgc3RydWN0IHVzYl9yZXF1ZXN0ICpyZXF1 ZXN0LAo+ICsJCQkJICBnZnBfdCBnZnBfZmxhZ3MpCj4gK3sKPiArCXN0cnVjdCB1c2Jzc3BfZXAg KmVwX3ByaXYgPSB0b191c2Jzc3BfZXAoZXApOwo+ICsJaW50IHJldCA9IDA7Cj4gKwo+ICsJaWYg KCFlcF9wcml2KQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCS8qVE9ETzogaW1wbGVtZW50 cyB0aGlzIGZ1bmN0aW9uKi8KPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQg dXNic3NwX2dhZGdldF9lcF9kZXF1ZXVlKHN0cnVjdCB1c2JfZXAgKmVwLAo+ICsJCQkJICAgIHN0 cnVjdCB1c2JfcmVxdWVzdCAqcmVxdWVzdCkKPiArewo+ICsJc3RydWN0IHVzYnNzcF9lcCAqZXBf cHJpdiA9IHRvX3VzYnNzcF9lcChlcCk7Cj4gKwlpbnQgcmV0ID0gMDsKPiArCj4gKwlpZiAoIWVw X3ByaXYpCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJLypUT0RPOiBpbXBsZW1lbnRzIHRo aXMgZnVuY3Rpb24qLwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIGludCB1c2Jz c3BfZ2FkZ2V0X2VwX3NldF9oYWx0KHN0cnVjdCB1c2JfZXAgKmVwLCBpbnQgdmFsdWUpCj4gK3sK PiArCXN0cnVjdCB1c2Jzc3BfZXAgKmVwX3ByaXYgPSB0b191c2Jzc3BfZXAoZXApOwo+ICsJaW50 IHJldCA9IDA7Cj4gKwo+ICsJaWYgKCFlcF9wcml2KQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsK PiArCS8qVE9ETzogaW1wbGVtZW50cyB0aGlzIGZ1bmN0aW9uKi8KPiArCXJldHVybiByZXQ7Cj4g K30KPiArCj4gK3N0YXRpYyBpbnQgdXNic3NwX2dhZGdldF9lcF9zZXRfd2VkZ2Uoc3RydWN0IHVz Yl9lcCAqZXApCj4gK3sKPiArCXN0cnVjdCB1c2Jzc3BfZXAgKmVwX3ByaXYgPSB0b191c2Jzc3Bf ZXAoZXApOwo+ICsJaW50IHJldCA9IDA7Cj4gKwo+ICsJaWYgKCFlcF9wcml2KQo+ICsJCXJldHVy biAtRUlOVkFMOwo+ICsKPiArCS8qVE9ETzogaW1wbGVtZW50cyB0aGlzIGZ1bmN0aW9uKi8KPiAr CXJldHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2VwX29wcyB1 c2Jzc3BfZ2FkZ2V0X2VwMF9vcHMgPSB7Cj4gKwkuZW5hYmxlCQk9IHVzYnNzcF9nYWRnZXRfZXBf ZW5hYmxlLAo+ICsJLmRpc2FibGUJPSB1c2Jzc3BfZ2FkZ2V0X2VwX2Rpc2FibGUsCj4gKwkuYWxs b2NfcmVxdWVzdAk9IHVzYnNzcF9nYWRnZXRfZXBfYWxsb2NfcmVxdWVzdCwKPiArCS5mcmVlX3Jl cXVlc3QJPSB1c2Jzc3BfZ2FkZ2V0X2VwX2ZyZWVfcmVxdWVzdCwKPiArCS5xdWV1ZQkJPSB1c2Jz c3BfZ2FkZ2V0X2VwX3F1ZXVlLAo+ICsJLmRlcXVldWUJPSB1c2Jzc3BfZ2FkZ2V0X2VwX2RlcXVl dWUsCj4gKwkuc2V0X2hhbHQJPSB1c2Jzc3BfZ2FkZ2V0X2VwX3NldF9oYWx0LAo+ICsJLnNldF93 ZWRnZQk9IHVzYnNzcF9nYWRnZXRfZXBfc2V0X3dlZGdlLAo+ICt9Owo+ICsKPiArc3RhdGljIGNv bnN0IHN0cnVjdCB1c2JfZXBfb3BzIHVzYnNzcF9nYWRnZXRfZXBfb3BzID0gewo+ICsJLmVuYWJs ZQkJPSB1c2Jzc3BfZ2FkZ2V0X2VwX2VuYWJsZSwKPiArCS5kaXNhYmxlCT0gdXNic3NwX2dhZGdl dF9lcF9kaXNhYmxlLAo+ICsJLmFsbG9jX3JlcXVlc3QJPSB1c2Jzc3BfZ2FkZ2V0X2VwX2FsbG9j X3JlcXVlc3QsCj4gKwkuZnJlZV9yZXF1ZXN0CT0gdXNic3NwX2dhZGdldF9lcF9mcmVlX3JlcXVl c3QsCj4gKwkucXVldWUJCT0gdXNic3NwX2dhZGdldF9lcF9xdWV1ZSwKPiArCS5kZXF1ZXVlCT0g dXNic3NwX2dhZGdldF9lcF9kZXF1ZXVlLAo+ICsJLnNldF9oYWx0CT0gdXNic3NwX2dhZGdldF9l cF9zZXRfaGFsdCwKPiArCS5zZXRfd2VkZ2UJPSB1c2Jzc3BfZ2FkZ2V0X2VwX3NldF93ZWRnZSwK PiArfTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3QgdXNiX2VuZHBvaW50X2Rlc2NyaXB0b3IgdXNic3Nw X2dhZGdldF9lcDBfZGVzYyA9IHsKPiArCS5iTGVuZ3RoID0JCVVTQl9EVF9FTkRQT0lOVF9TSVpF LAo+ICsJLmJEZXNjcmlwdG9yVHlwZSA9CVVTQl9EVF9FTkRQT0lOVCwKPiArCS5ibUF0dHJpYnV0 ZXMgPQkJVVNCX0VORFBPSU5UX1hGRVJfQ09OVFJPTCwKPiArfTsKPiArCj4gK3N0YXRpYyBpbnQg dXNic3NwX2dhZGdldF9zdGFydChzdHJ1Y3QgdXNiX2dhZGdldCAqZywKPiArCQkJICAgICAgIHN0 cnVjdCB1c2JfZ2FkZ2V0X2RyaXZlciAqZHJpdmVyKQo+ICt7Cj4gKwlzdHJ1Y3QgdXNic3NwX3Vk YyAqdXNic3NwX2RhdGEgPSBnYWRnZXRfdG9fdXNic3NwKGcpOwo+ICsJaW50IHJldCA9IDA7Cj4g Kwo+ICsJaWYgKHVzYnNzcF9kYXRhLT5nYWRnZXRfZHJpdmVyKSB7Cj4gKwkJZGV2X2Vycih1c2Jz c3BfZGF0YS0+ZGV2LCAiJXMgaXMgYWxyZWFkeSBib3VuZCB0byAlc1xuIiwKPiArCQkJCXVzYnNz cF9kYXRhLT5nYWRnZXQubmFtZSwKPiArCQkJCXVzYnNzcF9kYXRhLT5nYWRnZXRfZHJpdmVyLT5k cml2ZXIubmFtZSk7Cj4gKwkJcmV0ID0gLUVCVVNZOwo+ICsJfQo+ICsKPiArCS8qVE9ETzogYWRk IGltcGxlbWVudGF0aW9uKi8KPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQg dXNic3NwX2dhZGdldF9zdG9wKHN0cnVjdCB1c2JfZ2FkZ2V0ICpnKQo+ICt7Cj4gKwlzdHJ1Y3Qg dXNic3NwX3VkYyAqdXNic3NwX2RhdGEgPSBnYWRnZXRfdG9fdXNic3NwKGcpOwo+ICsKPiArCWlm ICghdXNic3NwX2RhdGEpCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwkvKlRPRE86IGFkZCBpbXBs ZW1lbnRhdGlvbiovCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGludCB1c2Jzc3Bf Z2FkZ2V0X2dldF9mcmFtZShzdHJ1Y3QgdXNiX2dhZGdldCAqZykKPiArewo+ICsJc3RydWN0IHVz YnNzcF91ZGMgKnVzYnNzcF9kYXRhID0gZ2FkZ2V0X3RvX3VzYnNzcChnKTsKPiArCj4gKwlpZiAo IXVzYnNzcF9kYXRhKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCS8qVE9ETzogYWRkIGlt cGxlbWVudGF0aW9uKi8KPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHVzYnNz cF9nYWRnZXRfd2FrZXVwKHN0cnVjdCB1c2JfZ2FkZ2V0ICpnKQo+ICt7Cj4gKwlzdHJ1Y3QgdXNi c3NwX3VkYyAqdXNic3NwX2RhdGEgPSBnYWRnZXRfdG9fdXNic3NwKGcpOwo+ICsKPiArCWlmICgh dXNic3NwX2RhdGEpCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJLypUT0RPOiBhZGQgaW1w bGVtZW50YXRpb24qLwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdXNic3Nw X2dhZGdldF9zZXRfc2VsZnBvd2VyZWQoc3RydWN0IHVzYl9nYWRnZXQgKmcsCj4gKwkJCQkJIGlu dCBpc19zZWxmcG93ZXJlZCkKPiArewo+ICsJc3RydWN0IHVzYnNzcF91ZGMgKnVzYnNzcF9kYXRh ID0gZ2FkZ2V0X3RvX3VzYnNzcChnKTsKPiArCj4gKwlpZiAoIXVzYnNzcF9kYXRhKQo+ICsJCXJl dHVybiAtRUlOVkFMOwo+ICsKPiArCS8qVE9ETzogYWRkIGltcGxlbWVudGF0aW9uKi8KPiArCXJl dHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9nYWRnZXRfb3BzIHVz YnNzcF9nYWRnZXRfb3BzID0gewo+ICsJLmdldF9mcmFtZQkJPSB1c2Jzc3BfZ2FkZ2V0X2dldF9m cmFtZSwKPiArCS53YWtldXAJCQk9IHVzYnNzcF9nYWRnZXRfd2FrZXVwLAo+ICsJLnNldF9zZWxm cG93ZXJlZAk9IHVzYnNzcF9nYWRnZXRfc2V0X3NlbGZwb3dlcmVkLAo+ICsJLnVkY19zdGFydAkJ PSB1c2Jzc3BfZ2FkZ2V0X3N0YXJ0LAo+ICsJLnVkY19zdG9wCQk9IHVzYnNzcF9nYWRnZXRfc3Rv cCwKPiArfTsKPiArCj4gIGludCB1c2Jzc3BfZ2FkZ2V0X2luaXRfZW5kcG9pbnQoc3RydWN0IHVz YnNzcF91ZGMgKnVzYnNzcF9kYXRhKQoKU2luY2Ugd2UncmUgaW5pdGlhbGl6aW5nIGFsbCBlbmRw b2ludHMgdGhpcyBmdW5jdGlvbiBzaG91bGQgYmUgbmFtZWQgdXNic3NwX2dhZGdldF9pbml0X2Vu ZHBvaW50cygpLgoKPiAgewo+IC0JLypUT0RPOiBpdCBoYXMgdG8gYmUgaW1wbGVtZW50ZWQqLwo+ ICsJaW50IGkgPSAwOwo+ICsJc3RydWN0IHVzYnNzcF9lcCAqZXBfcHJpdjsKPiArCj4gKwl1c2Jz c3BfZGF0YS0+bnVtX2VuZHBvaW50cyA9IFVTQlNTUF9FTkRQT0lOVFNfTlVNOwo+ICsJSU5JVF9M SVNUX0hFQUQoJnVzYnNzcF9kYXRhLT5nYWRnZXQuZXBfbGlzdCk7Cj4gKwo+ICsJZm9yIChpID0g MTsgaSA8IHVzYnNzcF9kYXRhLT5udW1fZW5kcG9pbnRzOyBpKyspIHsKPiArCQlib29sIGRpcmVj dGlvbiA9IGkgJiAxOyAvKnN0YXJ0IGZyb20gT1VUIGVuZHBvaW50Ki8KPiArCQl1OCBlcG51bSA9 IChpID4+IDEpOwo+ICsKPiArCQllcF9wcml2ID0gJnVzYnNzcF9kYXRhLT5kZXZzLmVwc1tpLTFd Owo+ICsJCWVwX3ByaXYtPnVzYnNzcF9kYXRhID0gdXNic3NwX2RhdGE7Cj4gKwkJZXBfcHJpdi0+ bnVtYmVyID0gZXBudW07Cj4gKwkJZXBfcHJpdi0+ZGlyZWN0aW9uID0gZGlyZWN0aW9uOyAvKjAg Zm9yIE9VVCwgMSBmb3IgSU4qLwo+ICsKPiArCQlzbnByaW50ZihlcF9wcml2LT5uYW1lLCBzaXpl b2YoZXBfcHJpdi0+bmFtZSksICJlcCVkJXMiLCBlcG51bSwKPiArCQkJCShlcF9wcml2LT5kaXJl Y3Rpb24pID8gImluIiA6ICJvdXQiKTsKPiArCj4gKwkJZXBfcHJpdi0+ZW5kcG9pbnQubmFtZSA9 IGVwX3ByaXYtPm5hbWU7Cj4gKwo+ICsJCWlmIChlcF9wcml2LT5udW1iZXIgPCAyKSB7Cj4gKwkJ CWVwX3ByaXYtPmVuZHBvaW50LmRlc2MgPSAmdXNic3NwX2dhZGdldF9lcDBfZGVzYzsKPiArCQkJ ZXBfcHJpdi0+ZW5kcG9pbnQuY29tcF9kZXNjID0gTlVMTDsKPiArCQl9Cj4gKwo+ICsJCWlmIChl cG51bSA9PSAwKSB7Cj4gKwkJCS8qRVAwIGlzIGJpZGlyZWN0aW9uYWwgZW5kcG9pbnQqLwo+ICsJ CQl1c2JfZXBfc2V0X21heHBhY2tldF9saW1pdCgmZXBfcHJpdi0+ZW5kcG9pbnQsIDUxMik7Cj4g KwkJCWRldl9kYmcodXNic3NwX2RhdGEtPmRldiwKPiArCQkJCSJJbml0aWFsaXppbmcgJXMsIE1h eFBhY2s6ICUwNHggVHlwZTogQ3RybFxuIiwKPiArCQkJCWVwX3ByaXYtPm5hbWUsIDUxMik7Cj4g KwkJCWVwX3ByaXYtPmVuZHBvaW50Lm1heGJ1cnN0ID0gMTsKPiArCQkJZXBfcHJpdi0+ZW5kcG9p bnQub3BzID0gJnVzYnNzcF9nYWRnZXRfZXAwX29wczsKPiArCQkJZXBfcHJpdi0+ZW5kcG9pbnQu Y2Fwcy50eXBlX2NvbnRyb2wgPSB0cnVlOwo+ICsKPiArCQkJdXNic3NwX2RhdGEtPnVzYl9yZXFf ZXAwX2luLmVwbnVtID0gZXBfcHJpdi0+bnVtYmVyOwo+ICsJCQl1c2Jzc3BfZGF0YS0+dXNiX3Jl cV9lcDBfaW4uZGVwID0gZXBfcHJpdjsKPiArCj4gKwkJCWlmICghZXBudW0pCj4gKwkJCQl1c2Jz c3BfZGF0YS0+Z2FkZ2V0LmVwMCA9ICZlcF9wcml2LT5lbmRwb2ludDsKPiArCQl9IGVsc2Ugewo+ ICsJCQl1c2JfZXBfc2V0X21heHBhY2tldF9saW1pdCgmZXBfcHJpdi0+ZW5kcG9pbnQsIDEwMjQp Owo+ICsJCQllcF9wcml2LT5lbmRwb2ludC5tYXhidXJzdCA9IDE1Owo+ICsJCQllcF9wcml2LT5l bmRwb2ludC5vcHMgPSAmdXNic3NwX2dhZGdldF9lcF9vcHM7Cj4gKwkJCWxpc3RfYWRkX3RhaWwo JmVwX3ByaXYtPmVuZHBvaW50LmVwX2xpc3QsCj4gKwkJCQkJJnVzYnNzcF9kYXRhLT5nYWRnZXQu ZXBfbGlzdCk7Cj4gKwkJCWVwX3ByaXYtPmVuZHBvaW50LmNhcHMudHlwZV9pc28gPSB0cnVlOwo+ ICsJCQllcF9wcml2LT5lbmRwb2ludC5jYXBzLnR5cGVfYnVsayA9IHRydWU7Cj4gKwkJCWVwX3By aXYtPmVuZHBvaW50LmNhcHMudHlwZV9pbnQgPSB0cnVlOwo+ICsKPiArCQl9Cj4gKwo+ICsJCWVw X3ByaXYtPmVuZHBvaW50LmNhcHMuZGlyX2luID0gZGlyZWN0aW9uOwo+ICsJCWVwX3ByaXYtPmVu ZHBvaW50LmNhcHMuZGlyX291dCA9ICFkaXJlY3Rpb247CgpTaW5jZSB5b3Ugc3RhcnQgZnJvbSAx LCBlcDAgd2lsbCBvbmx5IGJlIGluaXRpYWxpemVkIGFzIGRpcl9pbi4KSXMgaXQgYmV0dGVyIHRv IHJlcHJlc2VudCBFUDBpbiBhbmQgRVAwb3V0IHNlcGFyYXRlbHk/CklmIHNvIHlvdSBjYW4gc3Rh cnQgaSBmcm9tIDAgYW5kIHVzZQoJZXBfcHJpdiA9ICZ1c2Jzc3BfZGF0YS0+ZGV2cy5lcHNbaV07 CgpUaGlzIHNob3VsZCBmaXggdGhlIGRpcmVjdGlvbi4gZXBzWzBdIHdpbGwgYmUgZXAwb3V0IGFu ZCBlcHNbMV0gd2lsbCBiZSBlcDBpbi4KCj4gKwo+ICsJCWRldl9kYmcodXNic3NwX2RhdGEtPmRl diwgIkluaXQgJXMsIE1heFBhY2s6ICUwNHggU3VwVHlwZToiCj4gKwkJCQkiIElOVC9CVUxLL0lT T0MgLCBTdXBEaXIgJXNcbiIsCj4gKwkJCQllcF9wcml2LT5uYW1lLCAxMDI0LAo+ICsJCQkJKGVw X3ByaXYtPmVuZHBvaW50LmNhcHMuZGlyX2luKSA/ICJJTiIgOiAiT1VUIik7Cj4gKwo+ICsJCUlO SVRfTElTVF9IRUFEKCZlcF9wcml2LT5wZW5kaW5nX2xpc3QpOwo+ICsJfQo+ICAJcmV0dXJuIDA7 Cj4gIH0KPiAgCj4gIHZvaWQgdXNic3NwX2dhZGdldF9mcmVlX2VuZHBvaW50KHN0cnVjdCB1c2Jz c3BfdWRjICp1c2Jzc3BfZGF0YSkKPiAgewo+IC0JLypUT0RPOiBpdCBoYXMgdG8gYmUgaW1wbGVt ZW50ZWQqLwo+ICsJaW50IGk7Cj4gKwlzdHJ1Y3QgdXNic3NwX2VwICplcF9wcml2Owo+ICsKPiAr CWZvciAoaSA9IDA7IGkgPCB1c2Jzc3BfZGF0YS0+bnVtX2VuZHBvaW50czsgaSsrKSB7Cj4gKwkJ ZXBfcHJpdiA9ICZ1c2Jzc3BfZGF0YS0+ZGV2cy5lcHNbaV07Cj4gKwoKaWYgeW91IHN0YXJ0IGkg ZnJvbSAxIHRoZW4geW91IGNhbiBza2lwIHRoZSBpZigpLgoKPiArCQlpZiAoZXBfcHJpdi0+bnVt YmVyICE9IDApCj4gKwkJCWxpc3RfZGVsKCZlcF9wcml2LT5lbmRwb2ludC5lcF9saXN0KTsKPiAr CX0KPiAgfQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LmMgYi9kcml2 ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LmMKPiBpbmRleCAzMzhlYzJlYzE4YjEuLjE5NWY1Nzc3Y2Y4 YSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LmMKPiArKysgYi9kcml2 ZXJzL3VzYi91c2Jzc3AvZ2FkZ2V0LmMKPiBAQCAtMTAzLDYgKzEwMyw4MyBAQCBpbnQgdXNic3Nw X2hhbHQoc3RydWN0IHVzYnNzcF91ZGMgKnVzYnNzcF9kYXRhKQo+ICAJcmV0dXJuIHJldDsKPiAg fQo+ICAKPiArLyoKPiArICogU2V0IHRoZSBydW4gYml0IGFuZCB3YWl0IGZvciB0aGUgZGV2aWNl IHRvIGJlIHJ1bm5pbmcuCj4gKyAqLwo+ICtpbnQgdXNic3NwX3N0YXJ0KHN0cnVjdCB1c2Jzc3Bf dWRjICp1c2Jzc3BfZGF0YSkKPiArewo+ICsJdTMyIHRlbXA7Cj4gKwlpbnQgcmV0Owo+ICsKPiAr CXRlbXAgPSByZWFkbCgmdXNic3NwX2RhdGEtPm9wX3JlZ3MtPmNvbW1hbmQpOwo+ICsJdGVtcCB8 PSAoQ01EX1JVTiB8IENNRF9ERVZFTik7Cj4gKwl1c2Jzc3BfZGJnX3RyYWNlKHVzYnNzcF9kYXRh LCB0cmFjZV91c2Jzc3BfZGJnX2luaXQsCj4gKwkJCSIvLyBUdXJuIG9uIFVTQlNTUCwgY21kID0g MHgleC4iLCB0ZW1wKTsKPiArCXdyaXRlbCh0ZW1wLCAmdXNic3NwX2RhdGEtPm9wX3JlZ3MtPmNv bW1hbmQpOwo+ICsKPiArCS8qCj4gKwkgKiBXYWl0IGZvciB0aGUgSENIYWx0ZWQgU3RhdXMgYml0 IHRvIGJlIDAgdG8gaW5kaWNhdGUgdGhlIGRldmljZSBpcwo+ICsJICogcnVubmluZy4KPiArCSAq Lwo+ICsJcmV0ID0gdXNic3NwX2hhbmRzaGFrZSgmdXNic3NwX2RhdGEtPm9wX3JlZ3MtPnN0YXR1 cywKPiArCQkJU1RTX0hBTFQsIDAsIFVTQlNTUF9NQVhfSEFMVF9VU0VDKTsKPiArCj4gKwlpZiAo cmV0ID09IC1FVElNRURPVVQpCj4gKwkJZGV2X2Vycih1c2Jzc3BfZGF0YS0+ZGV2LCAiRGV2aWNl IHRvb2sgdG9vIGxvbmcgdG8gc3RhcnQsIHdhaXRlZCAldSBtaWNyb3NlY29uZHMuXG4iLAo+ICsJ CQlVU0JTU1BfTUFYX0hBTFRfVVNFQyk7Cj4gKwlpZiAoIXJldCkKPiArCQkvKiBjbGVhciBzdGF0 ZSBmbGFncy4gSW5jbHVkaW5nIGR5aW5nLCBoYWx0ZWQgb3IgcmVtb3ZpbmcgKi8KPiArCQl1c2Jz c3BfZGF0YS0+dXNic3NwX3N0YXRlID0gMDsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ ICsvKgo+ICsgKiBSZXNldCBhIGhhbHRlZCBEQy4KPiArICoKPiArICogVGhpcyByZXNldHMgcGlw ZWxpbmVzLCB0aW1lcnMsIGNvdW50ZXJzLCBzdGF0ZSBtYWNoaW5lcywgZXRjLgo+ICsgKiBUcmFu c2FjdGlvbnMgd2lsbCBiZSB0ZXJtaW5hdGVkIGltbWVkaWF0ZWx5LCBhbmQgb3BlcmF0aW9uYWwg cmVnaXN0ZXJzCj4gKyAqIHdpbGwgYmUgc2V0IHRvIHRoZWlyIGRlZmF1bHRzLgo+ICsgKi8KPiAr aW50IHVzYnNzcF9yZXNldChzdHJ1Y3QgdXNic3NwX3VkYyAqdXNic3NwX2RhdGEpCj4gK3sKPiAr CXUzMiBjb21tYW5kOwo+ICsJdTMyIHN0YXRlOwo+ICsJaW50IHJldDsKPiArCj4gKwlzdGF0ZSA9 IHJlYWRsKCZ1c2Jzc3BfZGF0YS0+b3BfcmVncy0+c3RhdHVzKTsKPiArCj4gKwlpZiAoc3RhdGUg PT0gfih1MzIpMCkgewo+ICsJCWRldl93YXJuKHVzYnNzcF9kYXRhLT5kZXYsICJEZXZpY2Ugbm90 IGFjY2Vzc2libGUsIHJlc2V0IGZhaWxlZC5cbiIpOwo+ICsJCXJldHVybiAtRU5PREVWOwo+ICsJ fQo+ICsKPiArCWlmICgoc3RhdGUgJiBTVFNfSEFMVCkgPT0gMCkgewo+ICsJCWRldl93YXJuKHVz YnNzcF9kYXRhLT5kZXYsICJEQyBub3QgaGFsdGVkLCBhYm9ydGluZyByZXNldC5cbiIpOwoKREMg aXMgbm90IGEgZmFtaWxpYXIgYWJicmV2aWF0aW9uLiBNYWJlIGp1c3QgdXNlIENvbnRyb2xsZXI/ IG9yIERldmljZSBjb250cm9sbGVyLgoKPiArCQlyZXR1cm4gMDsKPiArCX0KPiArCj4gKwl1c2Jz c3BfZGJnX3RyYWNlKHVzYnNzcF9kYXRhLCB0cmFjZV91c2Jzc3BfZGJnX2luaXQsICIvLyBSZXNl dCB0aGUgREMiKTsKPiArCWNvbW1hbmQgPSByZWFkbCgmdXNic3NwX2RhdGEtPm9wX3JlZ3MtPmNv bW1hbmQpOwo+ICsJY29tbWFuZCB8PSBDTURfUkVTRVQ7Cj4gKwl3cml0ZWwoY29tbWFuZCwgJnVz YnNzcF9kYXRhLT5vcF9yZWdzLT5jb21tYW5kKTsKPiArCj4gKwlyZXQgPSB1c2Jzc3BfaGFuZHNo YWtlKCZ1c2Jzc3BfZGF0YS0+b3BfcmVncy0+Y29tbWFuZCwKPiArCQkJQ01EX1JFU0VULCAwLCAx MCAqIDEwMDAgKiAxMDAwKTsKPiArCj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwl1 c2Jzc3BfZGJnX3RyYWNlKHVzYnNzcF9kYXRhLCB0cmFjZV91c2Jzc3BfZGJnX2luaXQsCj4gKwkJ IldhaXQgZm9yIGNvbnRyb2xsZXIgdG8gYmUgcmVhZHkgZm9yIGRvb3JiZWxsIHJpbmdzIik7Cj4g KwkvKgo+ICsJICogVVNCU1NQIGNhbm5vdCB3cml0ZSB0byBhbnkgZG9vcmJlbGxzIG9yIG9wZXJh dGlvbmFsIHJlZ2lzdGVycyBvdGhlcgo+ICsJICogdGhhbiBzdGF0dXMgdW50aWwgdGhlICJDb250 cm9sbGVyIE5vdCBSZWFkeSIgZmxhZyBpcyBjbGVhcmVkLgo+ICsJICovCj4gKwlyZXQgPSB1c2Jz c3BfaGFuZHNoYWtlKCZ1c2Jzc3BfZGF0YS0+b3BfcmVncy0+c3RhdHVzLAo+ICsJCQlTVFNfQ05S LCAwLCAxMCAqIDEwMDAgKiAxMDAwKTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gIAo+ICAv Kgo+ICAgKiBJbml0aWFsaXplIG1lbW9yeSBmb3IgZ2FkZ2V0IGRyaXZlciBhbmQgVVNCU1NQIChv bmUtdGltZSBpbml0KS4KPiBAQCAtMTc5LDggKzI1Niw3IEBAIGludCB1c2Jzc3BfZ2VuX3NldHVw KHN0cnVjdCB1c2Jzc3BfdWRjICp1c2Jzc3BfZGF0YSkKPiAgCj4gIAlkZXZfZGJnKHVzYnNzcF9k YXRhLT5kZXYsICJSZXNldHRpbmcgRGV2aWNlIENvbnRyb2xsZXJcbiIpOwo+ICAJLyogUmVzZXQg dGhlIGludGVybmFsIERDIG1lbW9yeSBzdGF0ZSBhbmQgcmVnaXN0ZXJzLiAqLwo+IC0JLypUT0RP OiBhZGQgaW1wbGVtZW50YXRpb24gb2YgdXNic3NwX3Jlc2V0IGZ1bmN0aW9uKi8KPiAtCS8vcmV0 dmFsID0gdXNic3NwX3Jlc2V0KHVzYnNzcF9kYXRhKTsKPiArCXJldHZhbCA9IHVzYnNzcF9yZXNl dCh1c2Jzc3BfZGF0YSk7Cj4gIAlpZiAocmV0dmFsKQo+ICAJCXJldHVybiByZXR2YWw7Cj4gIAlk ZXZfZGJnKHVzYnNzcF9kYXRhLT5kZXYsICJSZXNldCBjb21wbGV0ZVxuIik7Cj4gQEAgLTI0NCw4 ICszMjAsNyBAQCBpbnQgdXNic3NwX2dhZGdldF9pbml0KHN0cnVjdCB1c2Jzc3BfdWRjICp1c2Jz c3BfZGF0YSkKPiAgCUJVSUxEX0JVR19PTihzaXplb2Yoc3RydWN0IHVzYnNzcF9ydW5fcmVncykg IT0gKDgrOCoxMjgpKjMyLzgpOwo+ICAKPiAgCS8qIGZpbGwgZ2FkZ2V0IGZpZWxkcyAqLwo+IC0J LypUT0RPOiBpbXBsZW1lbnRzIHVzYnNzcF9nYWRnZXRfb3BzIG9iamVjdCovCj4gLQkvL3VzYnNz cF9kYXRhLT5nYWRnZXQub3BzID0gJnVzYnNzcF9nYWRnZXRfb3BzOwo+ICsJdXNic3NwX2RhdGEt PmdhZGdldC5vcHMgPSAmdXNic3NwX2dhZGdldF9vcHM7Cj4gIAl1c2Jzc3BfZGF0YS0+Z2FkZ2V0 Lm5hbWUgPSAidXNic3NwLWdhZGdldCI7Cj4gIAl1c2Jzc3BfZGF0YS0+Z2FkZ2V0Lm1heF9zcGVl ZCA9IFVTQl9TUEVFRF9TVVBFUl9QTFVTOwo+ICAJdXNic3NwX2RhdGEtPmdhZGdldC5zcGVlZCA9 IFVTQl9TUEVFRF9VTktOT1dOOwo+IEBAIC0yODgsNiArMzYzLDcgQEAgaW50IHVzYnNzcF9nYWRn ZXRfaW5pdChzdHJ1Y3QgdXNic3NwX3VkYyAqdXNic3NwX2RhdGEpCj4gIAl1c2Jzc3BfaGFsdCh1 c2Jzc3BfZGF0YSk7Cj4gIAkvKlRPRE8gYWRkIGltcGxlbWVudGF0aW9uIG9mIHVzYnNzcF9yZXNl dCBmdW5jdGlvbiovCj4gIAkvL3VzYnNzcF9yZXNldCh1c2Jzc3BfZGF0YSk7Cj4gKwl1c2Jzc3Bf cmVzZXQodXNic3NwX2RhdGEpOwo+ICAJLypUT0RPIGFkZCBpbXBsZW1lbnRhdGlvbiBvZiBmcmVl aW5nIG1lbW9yeSovCj4gIAkvL3VzYnNzcF9tZW1fY2xlYW51cCh1c2Jzc3BfZGF0YSk7Cj4gIGVy cjM6Cj4K