From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-pg1-f176.google.com (mail-pg1-f176.google.com [209.85.215.176]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A60E32D7B7 for ; Tue, 17 Oct 2023 18:37:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linaro.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="GfKi3qlh" Received: by mail-pg1-f176.google.com with SMTP id 41be03b00d2f7-578b4997decso4455235a12.0 for ; Tue, 17 Oct 2023 11:37:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1697567850; x=1698172650; darn=lists.linux.dev; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date:from:to :cc:subject:date:message-id:reply-to; bh=fDIMPqihTJidR00sawm2Nr6O1yAKRnZhnAyaqVDW0po=; b=GfKi3qlhgZC7BZMcS/SJ3eunANRtODwoV8uoqiFcJY64W5WB0UhnLUJcrXKMh4B88K l3bO0qYSAWQQiO6OGzYNTn3AL1puYYDOZoJ4DQpcip+4OosH0AEzj0WeyaCi6DL0Z+7P Mfqv1udiF0Vz3rJgweloYulaRZDu5qr4uJb28q4BXnp9Lc2gD58AqM3Ml0cy5rFIZMcP 3FiC8xDSjkM1wFzv4qmciR1YZKKiV5HkZVxCaripQetl2253WviCkBVIAYgfZyElWgtp Zc64oCWM2Bv4o5VNGDAU3hN05dAAKMqAge4P7Bzn9VkjzhwlpABH3ql7zTDQrpz74zC+ z/5w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1697567850; x=1698172650; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=fDIMPqihTJidR00sawm2Nr6O1yAKRnZhnAyaqVDW0po=; b=w9JZs1yyr875XVc7PQog06M0+MMITCg1zoZwui5xFEPjBcmsmui4iaE4RRK11qb2Zp kXIabvOxla+8Hh3YygLkCUwWOoyesUZM8R4czYKChZTItPS15bZAQ/N+AcduV+FABJyQ X/glVbfPDoMT3XSRJnRwhk2t7erA4XeFsTtZDoRHdTDSbQM+OJNiP6COPolT+C57IeI8 1ZkHTafWyEoP6LPdYeK/nWJv6EpbDI+7qynQp+czQSZlnZ6mKR5dL1C3I2sO7Arv+mrj LKzENge2+tQ/CvrptwKdWo6RvFo/j4ea0VHH7oaPhS7HeU8v5DxOtmIov2c2VPyOYhAn hqZA== X-Gm-Message-State: AOJu0YwHg7XpMHcsQ+bfiItRd4+8d5e1ZT+Q1Uiu+DC6xXVDJ1dUSeNI CjKrP+TwyrwCy/2tHOg9RunF X-Google-Smtp-Source: AGHT+IGZc+AgmoxdQbyFgHaq0HpMKMawgaGe+zQRacb1kYCqnv0STvUbAj7qgu4yUBj9NSvPcrfVDw== X-Received: by 2002:a05:6a20:1608:b0:14d:d9f8:83f8 with SMTP id l8-20020a056a20160800b0014dd9f883f8mr3663772pzj.1.1697567849901; Tue, 17 Oct 2023 11:37:29 -0700 (PDT) Received: from thinkpad ([117.202.186.25]) by smtp.gmail.com with ESMTPSA id i2-20020a63e442000000b00577d53c50f7sm211772pgk.75.2023.10.17.11.37.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 17 Oct 2023 11:37:29 -0700 (PDT) Date: Wed, 18 Oct 2023 00:07:22 +0530 From: Manivannan Sadhasivam To: Frank Li Cc: aisheng.dong@nxp.com, bhelgaas@google.com, devicetree@vger.kernel.org, festevam@gmail.com, imx@lists.linux.dev, jdmason@kudzu.us, kernel@pengutronix.de, kishon@kernel.org, kw@linux.com, linux-arm-kernel@lists.infradead.org, linux-imx@nxp.com, linux-kernel@vger.kernel.org, linux-pci@vger.kernel.org, lorenzo.pieralisi@arm.com, lpieralisi@kernel.org, maz@kernel.org, s.hauer@pengutronix.de, shawnguo@kernel.org, tglx@linutronix.de Subject: Re: [PATCH v2 1/5] PCI: endpoint: Add RC-to-EP doorbell support using platform MSI controller Message-ID: <20231017183722.GB137137@thinkpad> References: <20230911220920.1817033-1-Frank.Li@nxp.com> <20230911220920.1817033-2-Frank.Li@nxp.com> Precedence: bulk X-Mailing-List: imx@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20230911220920.1817033-2-Frank.Li@nxp.com> On Mon, Sep 11, 2023 at 06:09:16PM -0400, Frank Li wrote: > This commit introduces a common method for sending messages from the Root > Complex (RC) to the Endpoint (EP) by utilizing the platform MSI interrupt > controller, such as ARM GIC, as an EP doorbell. Maps the memory assigned > for the BAR region by the PCI host to the message address of the platform > MSI interrupt controller in the PCI EP. As a result, when the PCI RC writes "Doorbell feature is implemented by mapping the EP's MSI interrupt controller message address to a dedicated BAR in the EPC core. It is the responsibility of the EPF driver to pass the actual message data to be written by the host to the doorbell BAR region through its own logic." > to the BAR region, it triggers an IRQ at the EP. This implementation serves > as a common method for all endpoint function drivers. > > However, it currently supports only one EP physical function due to > limitations in ARM MSI/IMS readiness. > > Signed-off-by: Frank Li > --- > drivers/pci/endpoint/pci-epc-core.c | 192 ++++++++++++++++++++++++++++ > drivers/pci/endpoint/pci-epf-core.c | 44 +++++++ > include/linux/pci-epc.h | 6 + > include/linux/pci-epf.h | 7 + > 4 files changed, 249 insertions(+) > > diff --git a/drivers/pci/endpoint/pci-epc-core.c b/drivers/pci/endpoint/pci-epc-core.c > index 5a4a8b0be6262..d336a99c6a94f 100644 > --- a/drivers/pci/endpoint/pci-epc-core.c > +++ b/drivers/pci/endpoint/pci-epc-core.c > @@ -10,6 +10,7 @@ > #include > #include > > +#include > #include > #include > #include > @@ -783,6 +784,197 @@ void pci_epc_bme_notify(struct pci_epc *epc) > } > EXPORT_SYMBOL_GPL(pci_epc_bme_notify); > > +/** > + * pci_epc_alloc_doorbell() - alloc an address space to let RC trigger EP side IRQ by write data to > + * the space. "Allocate platform specific doorbell IRQs to be used by the host to trigger doorbells on EP." > + * > + * @epc: the EPC device that need doorbell address and data from RC. EPC device for which the doorbell needs to be allocated > + * @func_no: the physical endpoint function number in the EPC device. > + * @vfunc_no: the virtual endpoint function number in the physical function. > + * @num_msgs: the total number of doorbell messages s/num_msgs/num_db > + * > + * Return: 0 success, other is failure > + */ > +int pci_epc_alloc_doorbell(struct pci_epc *epc, u8 func_no, u8 vfunc_no, int num_msgs) > +{ > + int ret; > + > + if (IS_ERR_OR_NULL(epc) || func_no >= epc->max_functions) > + return -EINVAL; > + > + if (vfunc_no > 0 && (!epc->max_vfs || vfunc_no > epc->max_vfs[func_no])) > + return -EINVAL; > + > + if (!epc->ops->alloc_doorbell) > + return 0; You mentioned 0 is a success. So if there is no callback, you want to return success? > + > + mutex_lock(&epc->lock); > + ret = epc->ops->alloc_doorbell(epc, func_no, vfunc_no, num_msgs); Why can't you just call the generic function here and in other places instead of implementing callbacks? I do not see a necessity for EPC specific callbacks. If there is one, please specify. > + mutex_unlock(&epc->lock); > + > + return ret; > +} > +EXPORT_SYMBOL_GPL(pci_epc_alloc_doorbell); > + > +/** > + * pci_epc_free_doorbell() - free resource allocated by pci_epc_alloc_doorbell() > + * > + * @epc: the EPC device that need doorbell address and data from RC. Same as above. > + * @func_no: the physical endpoint function number in the EPC device. > + * @vfunc_no: the virtual endpoint function number in the physical function. > + * > + * Return: 0 success, other is failure > + */ > +void pci_epc_free_doorbell(struct pci_epc *epc, u8 func_no, u8 vfunc_no) > +{ > + if (IS_ERR_OR_NULL(epc) || func_no >= epc->max_functions) > + return; > + > + if (vfunc_no > 0 && (!epc->max_vfs || vfunc_no > epc->max_vfs[func_no])) > + return; > + > + if (!epc->ops->free_doorbell) > + return; > + > + mutex_lock(&epc->lock); > + epc->ops->free_doorbell(epc, func_no, vfunc_no); Same as suggested above. > + mutex_unlock(&epc->lock); > +} > +EXPORT_SYMBOL_GPL(pci_epc_free_doorbell); > + > +static irqreturn_t pci_epf_generic_doorbell_handler(int irq, void *data) > +{ > + struct pci_epf *epf = data; > + > + if (epf->event_ops && epf->event_ops->doorbell) > + epf->event_ops->doorbell(epf, irq - epf->virq_base); Same as suggested above. > + > + return IRQ_HANDLED; > +} > + > +static void pci_epc_generic_write_msi_msg(struct msi_desc *desc, struct msi_msg *msg) > +{ > + struct pci_epc *epc = NULL; > + struct class_dev_iter iter; > + struct pci_epf *epf; > + struct device *dev; > + > + class_dev_iter_init(&iter, pci_epc_class, NULL, NULL); > + while ((dev = class_dev_iter_next(&iter))) { > + if (dev->parent != desc->dev) > + continue; > + > + epc = to_pci_epc(dev); > + > + class_dev_iter_exit(&iter); > + break; > + } > + > + if (!epc) > + return; > + > + /* Only support one EPF for doorbell */ > + epf = list_first_entry_or_null(&epc->pci_epf, struct pci_epf, list); > + No need of this newline > + if (!epf) > + return; > + > + if (epf->msg && desc->msi_index < epf->num_msgs) > + epf->msg[desc->msi_index] = *msg; > +} > + > + Remove extra newline > +/** > + * pci_epc_generic_alloc_doorbell() - Common help function. Allocate address space from MSI > + * controller > + * > + * @epc: the EPC device that need doorbell address and data from RC. > + * @func_no: the physical endpoint function number in the EPC device. > + * @vfunc_no: the virtual endpoint function number in the physical function. > + * @num_msgs: the total number of doorbell messages > + * Same comment as for pci_epc_alloc_doorbell() > + * Remark: use this function only if EPC driver just register one EPC device. > + * > + * Return: 0 success, other is failure > + */ > +int pci_epc_generic_alloc_doorbell(struct pci_epc *epc, u8 func_no, u8 vfunc_no, int num_msgs) > +{ > + struct pci_epf *epf; > + struct device *dev; > + int virq, last; > + int ret; > + int i; > + > + if (IS_ERR_OR_NULL(epc)) > + return -EINVAL; > + > + /* Currently only support one func and one vfunc for doorbell */ > + if (func_no || vfunc_no) > + return -EINVAL; > + > + epf = list_first_entry_or_null(&epc->pci_epf, struct pci_epf, list); > + if (!epf) > + return -EINVAL; > + > + dev = epc->dev.parent; > + ret = platform_msi_domain_alloc_irqs(dev, num_msgs, pci_epc_generic_write_msi_msg); > + if (ret) { > + dev_err(dev, "Failed to allocate MSI\n"); > + return -ENOMEM; > + } > + > + last = -1; > + for (i = 0; i < num_msgs; i++) { You should iterate over msi_desc as below: msi_lock_descs(dev); msi_for_each_desc(desc, dev, MSI_DESC_ALL) { ... } msi_unlock_descs(dev); > + virq = msi_get_virq(dev, i); > + if (i == 0) > + epf->virq_base = virq; > + > + ret = request_irq(virq, pci_epf_generic_doorbell_handler, 0, request_irq(desc->irq, ...) > + kasprintf(GFP_KERNEL, "pci-epc-doorbell%d", i), epf); > + > + if (ret) { > + dev_err(dev, "Failed to request doorbell\n"); > + goto err_free_irq; > + } > + last = i; > + } > + > + return 0; > + > +err_free_irq: > + for (i = 0; i < last; i++) > + kfree(free_irq(epf->virq_base + i, epf)); > + platform_msi_domain_free_irqs(dev); > + > + return -EINVAL; return ret; > +} > +EXPORT_SYMBOL_GPL(pci_epc_generic_alloc_doorbell); > + [...] > diff --git a/include/linux/pci-epf.h b/include/linux/pci-epf.h > index 3f44b6aec4770..485c146a5efe2 100644 > --- a/include/linux/pci-epf.h > +++ b/include/linux/pci-epf.h > @@ -79,6 +79,7 @@ struct pci_epc_event_ops { > int (*link_up)(struct pci_epf *epf); > int (*link_down)(struct pci_epf *epf); > int (*bme)(struct pci_epf *epf); > + int (*doorbell)(struct pci_epf *epf, int index); kdoc missing. > }; > > /** > @@ -180,6 +181,9 @@ struct pci_epf { > unsigned long vfunction_num_map; > struct list_head pci_vepf; > const struct pci_epc_event_ops *event_ops; > + struct msi_msg *msg; > + u16 num_msgs; num_db You also need to add kdoc for each new member. - Mani -- மணிவண்ணன் சதாசிவம் 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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 6742BCDB483 for ; Tue, 17 Oct 2023 18:38:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=QTlxG3Zyb+Lj+/KUKuTK3eb7nFB0iDvKFsKuJ9h88Tg=; b=v7aywOl3sNuGlA WRpdDycmMyfn7rxBzznruNVxmxTIQDAWk4UuShlAHqiDR9wkop2XebLe31GEQfAZln0HDUh78v7Ab 3CJd+UfjTqdVHu+IHSYJBWR0kcVvJpUyqXnVEm9RCZEAr7QnEEb+ymgrLnTTrgGpJpaUIxqiYyu3d n0Yr1FP25wcJygCKfNhTEO3+7j/wXRefdGigldwMhHd1s9RFmGX5L4n1XxYR0aAyZytOpcTtt81h2 zCznq+eiI6aYurcXKYVWJ95CD83G0/2lcTMQWq4maX6Z8N+s1oKe2hDe67FDy/W+/WQDRWRSnfdxe 55mgwpj5o9Yi+WNcOcaQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1qsowh-00CzM7-1w; Tue, 17 Oct 2023 18:37:35 +0000 Received: from mail-pg1-x530.google.com ([2607:f8b0:4864:20::530]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1qsowf-00CzLk-0s for linux-arm-kernel@lists.infradead.org; Tue, 17 Oct 2023 18:37:35 +0000 Received: by mail-pg1-x530.google.com with SMTP id 41be03b00d2f7-5ad5178d1bfso3121899a12.2 for ; Tue, 17 Oct 2023 11:37:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1697567850; x=1698172650; darn=lists.infradead.org; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date:from:to :cc:subject:date:message-id:reply-to; bh=fDIMPqihTJidR00sawm2Nr6O1yAKRnZhnAyaqVDW0po=; b=aAMUAe+PNZ3/3Foj7Tk3vuyj1qwMo2WmAeCEPDzrg2I+j6Bx9BFSe7+7sAo77aU70L +ubwrNbERYpBUg2jAZgV3yeiUGiQ4I6fRS4aKcioLVJyrmKiruBK09cIahsOUpCc96Ze ybgqTE63wdDPwvfvJhS5M1B5ZIXWau/t6I34QLvAf/iior8ME9fY9uKWCXfGipycG7MH uSupId1a6nGd2FrZdvd425BXOcanEe0TMqzx8v7SKo0DjS0JntCPc7eirRgd3O8BJjKt oy80l3adj7TdSWGZdMfgFYDLuhwos7AecjSI3Z15EGuqLudTM6xJ6qtfcNzQ31xpuEgi HdJA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1697567850; x=1698172650; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=fDIMPqihTJidR00sawm2Nr6O1yAKRnZhnAyaqVDW0po=; b=rMcBHdDi1avsqtQc42BalO41VRE+zFeSQlmseiXbbjmEaK2AcwjRBSS0VxN9/TLipL U9mASruqJzOV6H791D2Lf6pKtxVj4osxLwF/LkGV467LVhdjZdEZylNvKfkEH0bRyM59 B5KFIJi3nQXs+PQUuVl31kstuLWZVUsAKdwa3Iii0fceLQhDxHkjGG5e7b0Quk3CClqj lbCQAUKjOw8IG0bYuuW9oINwk8graKyp7X885UA41xTwhc5cnl3VOMjBB2lMxFMGuR7k U6uZcRbu9EJRYYbhvcOkf74LKQ174UQUjwiL29wsJ+vEGkqk/3xr6ozlA4zltGVR+hgZ E6xw== X-Gm-Message-State: AOJu0Yz/WzmmnEnfKDBx09G36THsS1BUruTA5yUdAPl3nryGD+BRm3RE OQNZYv7URjfnMe9XeCgPhxTC X-Google-Smtp-Source: AGHT+IGZc+AgmoxdQbyFgHaq0HpMKMawgaGe+zQRacb1kYCqnv0STvUbAj7qgu4yUBj9NSvPcrfVDw== X-Received: by 2002:a05:6a20:1608:b0:14d:d9f8:83f8 with SMTP id l8-20020a056a20160800b0014dd9f883f8mr3663772pzj.1.1697567849901; Tue, 17 Oct 2023 11:37:29 -0700 (PDT) Received: from thinkpad ([117.202.186.25]) by smtp.gmail.com with ESMTPSA id i2-20020a63e442000000b00577d53c50f7sm211772pgk.75.2023.10.17.11.37.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 17 Oct 2023 11:37:29 -0700 (PDT) Date: Wed, 18 Oct 2023 00:07:22 +0530 From: Manivannan Sadhasivam To: Frank Li Cc: aisheng.dong@nxp.com, bhelgaas@google.com, devicetree@vger.kernel.org, festevam@gmail.com, imx@lists.linux.dev, jdmason@kudzu.us, kernel@pengutronix.de, kishon@kernel.org, kw@linux.com, linux-arm-kernel@lists.infradead.org, linux-imx@nxp.com, linux-kernel@vger.kernel.org, linux-pci@vger.kernel.org, lorenzo.pieralisi@arm.com, lpieralisi@kernel.org, maz@kernel.org, s.hauer@pengutronix.de, shawnguo@kernel.org, tglx@linutronix.de Subject: Re: [PATCH v2 1/5] PCI: endpoint: Add RC-to-EP doorbell support using platform MSI controller Message-ID: <20231017183722.GB137137@thinkpad> References: <20230911220920.1817033-1-Frank.Li@nxp.com> <20230911220920.1817033-2-Frank.Li@nxp.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20230911220920.1817033-2-Frank.Li@nxp.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20231017_113733_340848_7ADB820C X-CRM114-Status: GOOD ( 39.90 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org T24gTW9uLCBTZXAgMTEsIDIwMjMgYXQgMDY6MDk6MTZQTSAtMDQwMCwgRnJhbmsgTGkgd3JvdGU6 Cj4gVGhpcyBjb21taXQgaW50cm9kdWNlcyBhIGNvbW1vbiBtZXRob2QgZm9yIHNlbmRpbmcgbWVz c2FnZXMgZnJvbSB0aGUgUm9vdAo+IENvbXBsZXggKFJDKSB0byB0aGUgRW5kcG9pbnQgKEVQKSBi eSB1dGlsaXppbmcgdGhlIHBsYXRmb3JtIE1TSSBpbnRlcnJ1cHQKPiBjb250cm9sbGVyLCBzdWNo IGFzIEFSTSBHSUMsIGFzIGFuIEVQIGRvb3JiZWxsLiBNYXBzIHRoZSBtZW1vcnkgYXNzaWduZWQK PiBmb3IgdGhlIEJBUiByZWdpb24gYnkgdGhlIFBDSSBob3N0IHRvIHRoZSBtZXNzYWdlIGFkZHJl c3Mgb2YgdGhlIHBsYXRmb3JtCj4gTVNJIGludGVycnVwdCBjb250cm9sbGVyIGluIHRoZSBQQ0kg RVAuIEFzIGEgcmVzdWx0LCB3aGVuIHRoZSBQQ0kgUkMgd3JpdGVzCgoiRG9vcmJlbGwgZmVhdHVy ZSBpcyBpbXBsZW1lbnRlZCBieSBtYXBwaW5nIHRoZSBFUCdzIE1TSSBpbnRlcnJ1cHQgY29udHJv bGxlcgptZXNzYWdlIGFkZHJlc3MgdG8gYSBkZWRpY2F0ZWQgQkFSIGluIHRoZSBFUEMgY29yZS4g SXQgaXMgdGhlIHJlc3BvbnNpYmlsaXR5Cm9mIHRoZSBFUEYgZHJpdmVyIHRvIHBhc3MgdGhlIGFj dHVhbCBtZXNzYWdlIGRhdGEgdG8gYmUgd3JpdHRlbiBieSB0aGUgaG9zdCB0bwp0aGUgZG9vcmJl bGwgQkFSIHJlZ2lvbiB0aHJvdWdoIGl0cyBvd24gbG9naWMuIgoKPiB0byB0aGUgQkFSIHJlZ2lv biwgaXQgdHJpZ2dlcnMgYW4gSVJRIGF0IHRoZSBFUC4gVGhpcyBpbXBsZW1lbnRhdGlvbiBzZXJ2 ZXMKPiBhcyBhIGNvbW1vbiBtZXRob2QgZm9yIGFsbCBlbmRwb2ludCBmdW5jdGlvbiBkcml2ZXJz Lgo+IAo+IEhvd2V2ZXIsIGl0IGN1cnJlbnRseSBzdXBwb3J0cyBvbmx5IG9uZSBFUCBwaHlzaWNh bCBmdW5jdGlvbiBkdWUgdG8KPiBsaW1pdGF0aW9ucyBpbiBBUk0gTVNJL0lNUyByZWFkaW5lc3Mu Cj4gCj4gU2lnbmVkLW9mZi1ieTogRnJhbmsgTGkgPEZyYW5rLkxpQG54cC5jb20+Cj4gLS0tCj4g IGRyaXZlcnMvcGNpL2VuZHBvaW50L3BjaS1lcGMtY29yZS5jIHwgMTkyICsrKysrKysrKysrKysr KysrKysrKysrKysrKysKPiAgZHJpdmVycy9wY2kvZW5kcG9pbnQvcGNpLWVwZi1jb3JlLmMgfCAg NDQgKysrKysrKwo+ICBpbmNsdWRlL2xpbnV4L3BjaS1lcGMuaCAgICAgICAgICAgICB8ICAgNiAr Cj4gIGluY2x1ZGUvbGludXgvcGNpLWVwZi5oICAgICAgICAgICAgIHwgICA3ICsKPiAgNCBmaWxl cyBjaGFuZ2VkLCAyNDkgaW5zZXJ0aW9ucygrKQo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3Bj aS9lbmRwb2ludC9wY2ktZXBjLWNvcmUuYyBiL2RyaXZlcnMvcGNpL2VuZHBvaW50L3BjaS1lcGMt Y29yZS5jCj4gaW5kZXggNWE0YThiMGJlNjI2Mi4uZDMzNmE5OWM2YTk0ZiAxMDA2NDQKPiAtLS0g YS9kcml2ZXJzL3BjaS9lbmRwb2ludC9wY2ktZXBjLWNvcmUuYwo+ICsrKyBiL2RyaXZlcnMvcGNp L2VuZHBvaW50L3BjaS1lcGMtY29yZS5jCj4gQEAgLTEwLDYgKzEwLDcgQEAKPiAgI2luY2x1ZGUg PGxpbnV4L3NsYWIuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+ICAKPiArI2luY2x1 ZGUgPGxpbnV4L21zaS5oPgo+ICAjaW5jbHVkZSA8bGludXgvcGNpLWVwYy5oPgo+ICAjaW5jbHVk ZSA8bGludXgvcGNpLWVwZi5oPgo+ICAjaW5jbHVkZSA8bGludXgvcGNpLWVwLWNmcy5oPgo+IEBA IC03ODMsNiArNzg0LDE5NyBAQCB2b2lkIHBjaV9lcGNfYm1lX25vdGlmeShzdHJ1Y3QgcGNpX2Vw YyAqZXBjKQo+ICB9Cj4gIEVYUE9SVF9TWU1CT0xfR1BMKHBjaV9lcGNfYm1lX25vdGlmeSk7Cj4g IAo+ICsvKioKPiArICogcGNpX2VwY19hbGxvY19kb29yYmVsbCgpIC0gYWxsb2MgYW4gYWRkcmVz cyBzcGFjZSB0byBsZXQgUkMgdHJpZ2dlciBFUCBzaWRlIElSUSBieSB3cml0ZSBkYXRhIHRvCj4g KyAqCQkJICAgICAgdGhlIHNwYWNlLgoKIkFsbG9jYXRlIHBsYXRmb3JtIHNwZWNpZmljIGRvb3Ji ZWxsIElSUXMgdG8gYmUgdXNlZCBieSB0aGUgaG9zdCB0byB0cmlnZ2VyCmRvb3JiZWxscyBvbiBF UC4iCgo+ICsgKgo+ICsgKiBAZXBjOiB0aGUgRVBDIGRldmljZSB0aGF0IG5lZWQgZG9vcmJlbGwg YWRkcmVzcyBhbmQgZGF0YSBmcm9tIFJDLgoKRVBDIGRldmljZSBmb3Igd2hpY2ggdGhlIGRvb3Ji ZWxsIG5lZWRzIHRvIGJlIGFsbG9jYXRlZAoKPiArICogQGZ1bmNfbm86IHRoZSBwaHlzaWNhbCBl bmRwb2ludCBmdW5jdGlvbiBudW1iZXIgaW4gdGhlIEVQQyBkZXZpY2UuCj4gKyAqIEB2ZnVuY19u bzogdGhlIHZpcnR1YWwgZW5kcG9pbnQgZnVuY3Rpb24gbnVtYmVyIGluIHRoZSBwaHlzaWNhbCBm dW5jdGlvbi4KPiArICogQG51bV9tc2dzOiB0aGUgdG90YWwgbnVtYmVyIG9mIGRvb3JiZWxsIG1l c3NhZ2VzCgpzL251bV9tc2dzL251bV9kYgoKPiArICoKPiArICogUmV0dXJuOiAwIHN1Y2Nlc3Ms IG90aGVyIGlzIGZhaWx1cmUKPiArICovCj4gK2ludCBwY2lfZXBjX2FsbG9jX2Rvb3JiZWxsKHN0 cnVjdCBwY2lfZXBjICplcGMsIHU4IGZ1bmNfbm8sIHU4IHZmdW5jX25vLCBpbnQgbnVtX21zZ3Mp Cj4gK3sKPiArCWludCByZXQ7Cj4gKwo+ICsJaWYgKElTX0VSUl9PUl9OVUxMKGVwYykgfHwgZnVu Y19ubyA+PSBlcGMtPm1heF9mdW5jdGlvbnMpCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJ aWYgKHZmdW5jX25vID4gMCAmJiAoIWVwYy0+bWF4X3ZmcyB8fCB2ZnVuY19ubyA+IGVwYy0+bWF4 X3Zmc1tmdW5jX25vXSkpCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJaWYgKCFlcGMtPm9w cy0+YWxsb2NfZG9vcmJlbGwpCj4gKwkJcmV0dXJuIDA7CgpZb3UgbWVudGlvbmVkIDAgaXMgYSBz dWNjZXNzLiBTbyBpZiB0aGVyZSBpcyBubyBjYWxsYmFjaywgeW91IHdhbnQgdG8gcmV0dXJuCnN1 Y2Nlc3M/Cgo+ICsKPiArCW11dGV4X2xvY2soJmVwYy0+bG9jayk7Cj4gKwlyZXQgPSBlcGMtPm9w cy0+YWxsb2NfZG9vcmJlbGwoZXBjLCBmdW5jX25vLCB2ZnVuY19ubywgbnVtX21zZ3MpOwoKV2h5 IGNhbid0IHlvdSBqdXN0IGNhbGwgdGhlIGdlbmVyaWMgZnVuY3Rpb24gaGVyZSBhbmQgaW4gb3Ro ZXIgcGxhY2VzIGluc3RlYWQgb2YKaW1wbGVtZW50aW5nIGNhbGxiYWNrcz8gSSBkbyBub3Qgc2Vl IGEgbmVjZXNzaXR5IGZvciBFUEMgc3BlY2lmaWMgY2FsbGJhY2tzLiBJZgp0aGVyZSBpcyBvbmUs IHBsZWFzZSBzcGVjaWZ5LgoKPiArCW11dGV4X3VubG9jaygmZXBjLT5sb2NrKTsKPiArCj4gKwly ZXR1cm4gcmV0Owo+ICt9Cj4gK0VYUE9SVF9TWU1CT0xfR1BMKHBjaV9lcGNfYWxsb2NfZG9vcmJl bGwpOwo+ICsKPiArLyoqCj4gKyAqIHBjaV9lcGNfZnJlZV9kb29yYmVsbCgpIC0gZnJlZSByZXNv dXJjZSBhbGxvY2F0ZWQgYnkgcGNpX2VwY19hbGxvY19kb29yYmVsbCgpCj4gKyAqCj4gKyAqIEBl cGM6IHRoZSBFUEMgZGV2aWNlIHRoYXQgbmVlZCBkb29yYmVsbCBhZGRyZXNzIGFuZCBkYXRhIGZy b20gUkMuCgpTYW1lIGFzIGFib3ZlLgoKPiArICogQGZ1bmNfbm86IHRoZSBwaHlzaWNhbCBlbmRw b2ludCBmdW5jdGlvbiBudW1iZXIgaW4gdGhlIEVQQyBkZXZpY2UuCj4gKyAqIEB2ZnVuY19ubzog dGhlIHZpcnR1YWwgZW5kcG9pbnQgZnVuY3Rpb24gbnVtYmVyIGluIHRoZSBwaHlzaWNhbCBmdW5j dGlvbi4KPiArICoKPiArICogUmV0dXJuOiAwIHN1Y2Nlc3MsIG90aGVyIGlzIGZhaWx1cmUKPiAr ICovCj4gK3ZvaWQgcGNpX2VwY19mcmVlX2Rvb3JiZWxsKHN0cnVjdCBwY2lfZXBjICplcGMsIHU4 IGZ1bmNfbm8sIHU4IHZmdW5jX25vKQo+ICt7Cj4gKwlpZiAoSVNfRVJSX09SX05VTEwoZXBjKSB8 fCBmdW5jX25vID49IGVwYy0+bWF4X2Z1bmN0aW9ucykKPiArCQlyZXR1cm47Cj4gKwo+ICsJaWYg KHZmdW5jX25vID4gMCAmJiAoIWVwYy0+bWF4X3ZmcyB8fCB2ZnVuY19ubyA+IGVwYy0+bWF4X3Zm c1tmdW5jX25vXSkpCj4gKwkJcmV0dXJuOwo+ICsKPiArCWlmICghZXBjLT5vcHMtPmZyZWVfZG9v cmJlbGwpCj4gKwkJcmV0dXJuOwo+ICsKPiArCW11dGV4X2xvY2soJmVwYy0+bG9jayk7Cj4gKwll cGMtPm9wcy0+ZnJlZV9kb29yYmVsbChlcGMsIGZ1bmNfbm8sIHZmdW5jX25vKTsKClNhbWUgYXMg c3VnZ2VzdGVkIGFib3ZlLgoKPiArCW11dGV4X3VubG9jaygmZXBjLT5sb2NrKTsKPiArfQo+ICtF WFBPUlRfU1lNQk9MX0dQTChwY2lfZXBjX2ZyZWVfZG9vcmJlbGwpOwo+ICsKPiArc3RhdGljIGly cXJldHVybl90IHBjaV9lcGZfZ2VuZXJpY19kb29yYmVsbF9oYW5kbGVyKGludCBpcnEsIHZvaWQg KmRhdGEpCj4gK3sKPiArCXN0cnVjdCBwY2lfZXBmICplcGYgPSBkYXRhOwo+ICsKPiArCWlmIChl cGYtPmV2ZW50X29wcyAmJiBlcGYtPmV2ZW50X29wcy0+ZG9vcmJlbGwpCj4gKwkJZXBmLT5ldmVu dF9vcHMtPmRvb3JiZWxsKGVwZiwgaXJxIC0gZXBmLT52aXJxX2Jhc2UpOwoKU2FtZSBhcyBzdWdn ZXN0ZWQgYWJvdmUuCgo+ICsKPiArCXJldHVybiBJUlFfSEFORExFRDsKPiArfQo+ICsKPiArc3Rh dGljIHZvaWQgcGNpX2VwY19nZW5lcmljX3dyaXRlX21zaV9tc2coc3RydWN0IG1zaV9kZXNjICpk ZXNjLCBzdHJ1Y3QgbXNpX21zZyAqbXNnKQo+ICt7Cj4gKwlzdHJ1Y3QgcGNpX2VwYyAqZXBjID0g TlVMTDsKPiArCXN0cnVjdCBjbGFzc19kZXZfaXRlciBpdGVyOwo+ICsJc3RydWN0IHBjaV9lcGYg KmVwZjsKPiArCXN0cnVjdCBkZXZpY2UgKmRldjsKPiArCj4gKwljbGFzc19kZXZfaXRlcl9pbml0 KCZpdGVyLCBwY2lfZXBjX2NsYXNzLCBOVUxMLCBOVUxMKTsKPiArCXdoaWxlICgoZGV2ID0gY2xh c3NfZGV2X2l0ZXJfbmV4dCgmaXRlcikpKSB7Cj4gKwkJaWYgKGRldi0+cGFyZW50ICE9IGRlc2Mt PmRldikKPiArCQkJY29udGludWU7Cj4gKwo+ICsJCWVwYyA9IHRvX3BjaV9lcGMoZGV2KTsKPiAr Cj4gKwkJY2xhc3NfZGV2X2l0ZXJfZXhpdCgmaXRlcik7Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwo+ ICsJaWYgKCFlcGMpCj4gKwkJcmV0dXJuOwo+ICsKPiArCS8qIE9ubHkgc3VwcG9ydCBvbmUgRVBG IGZvciBkb29yYmVsbCAqLwo+ICsJZXBmID0gbGlzdF9maXJzdF9lbnRyeV9vcl9udWxsKCZlcGMt PnBjaV9lcGYsIHN0cnVjdCBwY2lfZXBmLCBsaXN0KTsKPiArCgpObyBuZWVkIG9mIHRoaXMgbmV3 bGluZQoKPiArCWlmICghZXBmKQo+ICsJCXJldHVybjsKPiArCj4gKwlpZiAoZXBmLT5tc2cgJiYg ZGVzYy0+bXNpX2luZGV4IDwgZXBmLT5udW1fbXNncykKPiArCQllcGYtPm1zZ1tkZXNjLT5tc2lf aW5kZXhdID0gKm1zZzsKPiArfQo+ICsKPiArCgpSZW1vdmUgZXh0cmEgbmV3bGluZQoKPiArLyoq Cj4gKyAqIHBjaV9lcGNfZ2VuZXJpY19hbGxvY19kb29yYmVsbCgpIC0gQ29tbW9uIGhlbHAgZnVu Y3Rpb24uIEFsbG9jYXRlIGFkZHJlc3Mgc3BhY2UgZnJvbSBNU0kKPiArICogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBjb250cm9sbGVyCj4gKyAqCj4gKyAqIEBlcGM6IHRoZSBF UEMgZGV2aWNlIHRoYXQgbmVlZCBkb29yYmVsbCBhZGRyZXNzIGFuZCBkYXRhIGZyb20gUkMuCj4g KyAqIEBmdW5jX25vOiB0aGUgcGh5c2ljYWwgZW5kcG9pbnQgZnVuY3Rpb24gbnVtYmVyIGluIHRo ZSBFUEMgZGV2aWNlLgo+ICsgKiBAdmZ1bmNfbm86IHRoZSB2aXJ0dWFsIGVuZHBvaW50IGZ1bmN0 aW9uIG51bWJlciBpbiB0aGUgcGh5c2ljYWwgZnVuY3Rpb24uCj4gKyAqIEBudW1fbXNnczogdGhl IHRvdGFsIG51bWJlciBvZiBkb29yYmVsbCBtZXNzYWdlcwo+ICsgKgoKU2FtZSBjb21tZW50IGFz IGZvciBwY2lfZXBjX2FsbG9jX2Rvb3JiZWxsKCkKCj4gKyAqIFJlbWFyazogdXNlIHRoaXMgZnVu Y3Rpb24gb25seSBpZiBFUEMgZHJpdmVyIGp1c3QgcmVnaXN0ZXIgb25lIEVQQyBkZXZpY2UuCj4g KyAqCj4gKyAqIFJldHVybjogMCBzdWNjZXNzLCBvdGhlciBpcyBmYWlsdXJlCj4gKyAqLwo+ICtp bnQgcGNpX2VwY19nZW5lcmljX2FsbG9jX2Rvb3JiZWxsKHN0cnVjdCBwY2lfZXBjICplcGMsIHU4 IGZ1bmNfbm8sIHU4IHZmdW5jX25vLCBpbnQgbnVtX21zZ3MpCj4gK3sKPiArCXN0cnVjdCBwY2lf ZXBmICplcGY7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXY7Cj4gKwlpbnQgdmlycSwgbGFzdDsKPiAr CWludCByZXQ7Cj4gKwlpbnQgaTsKPiArCj4gKwlpZiAoSVNfRVJSX09SX05VTEwoZXBjKSkKPiAr CQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwkvKiBDdXJyZW50bHkgb25seSBzdXBwb3J0IG9uZSBm dW5jIGFuZCBvbmUgdmZ1bmMgZm9yIGRvb3JiZWxsICovCj4gKwlpZiAoZnVuY19ubyB8fCB2ZnVu Y19ubykKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwllcGYgPSBsaXN0X2ZpcnN0X2VudHJ5 X29yX251bGwoJmVwYy0+cGNpX2VwZiwgc3RydWN0IHBjaV9lcGYsIGxpc3QpOwo+ICsJaWYgKCFl cGYpCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJZGV2ID0gZXBjLT5kZXYucGFyZW50Owo+ ICsJcmV0ID0gcGxhdGZvcm1fbXNpX2RvbWFpbl9hbGxvY19pcnFzKGRldiwgbnVtX21zZ3MsIHBj aV9lcGNfZ2VuZXJpY193cml0ZV9tc2lfbXNnKTsKPiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJy KGRldiwgIkZhaWxlZCB0byBhbGxvY2F0ZSBNU0lcbiIpOwo+ICsJCXJldHVybiAtRU5PTUVNOwo+ ICsJfQo+ICsKPiArCWxhc3QgPSAtMTsKPiArCWZvciAoaSA9IDA7IGkgPCBudW1fbXNnczsgaSsr KSB7CgpZb3Ugc2hvdWxkIGl0ZXJhdGUgb3ZlciBtc2lfZGVzYyBhcyBiZWxvdzoKCiAgICAgICAg bXNpX2xvY2tfZGVzY3MoZGV2KTsKICAgICAgICBtc2lfZm9yX2VhY2hfZGVzYyhkZXNjLCBkZXYs IE1TSV9ERVNDX0FMTCkgewoJCS4uLgoJfQoJbXNpX3VubG9ja19kZXNjcyhkZXYpOwoKPiArCQl2 aXJxID0gbXNpX2dldF92aXJxKGRldiwgaSk7Cj4gKwkJaWYgKGkgPT0gMCkKPiArCQkJZXBmLT52 aXJxX2Jhc2UgPSB2aXJxOwo+ICsKPiArCQlyZXQgPSByZXF1ZXN0X2lycSh2aXJxLCBwY2lfZXBm X2dlbmVyaWNfZG9vcmJlbGxfaGFuZGxlciwgMCwKCglyZXF1ZXN0X2lycShkZXNjLT5pcnEsIC4u LikKCj4gKwkJCQkgIGthc3ByaW50ZihHRlBfS0VSTkVMLCAicGNpLWVwYy1kb29yYmVsbCVkIiwg aSksIGVwZik7Cj4gKwo+ICsJCWlmIChyZXQpIHsKPiArCQkJZGV2X2VycihkZXYsICJGYWlsZWQg dG8gcmVxdWVzdCBkb29yYmVsbFxuIik7Cj4gKwkJCWdvdG8gZXJyX2ZyZWVfaXJxOwo+ICsJCX0K PiArCQlsYXN0ID0gaTsKPiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiArCj4gK2Vycl9mcmVlX2ly cToKPiArCWZvciAoaSA9IDA7IGkgPCBsYXN0OyBpKyspCj4gKwkJa2ZyZWUoZnJlZV9pcnEoZXBm LT52aXJxX2Jhc2UgKyBpLCBlcGYpKTsKPiArCXBsYXRmb3JtX21zaV9kb21haW5fZnJlZV9pcnFz KGRldik7Cj4gKwo+ICsJcmV0dXJuIC1FSU5WQUw7CgoJcmV0dXJuIHJldDsKCj4gK30KPiArRVhQ T1JUX1NZTUJPTF9HUEwocGNpX2VwY19nZW5lcmljX2FsbG9jX2Rvb3JiZWxsKTsKPiArCgpbLi4u XQoKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9wY2ktZXBmLmggYi9pbmNsdWRlL2xpbnV4 L3BjaS1lcGYuaAo+IGluZGV4IDNmNDRiNmFlYzQ3NzAuLjQ4NWMxNDZhNWVmZTIgMTAwNjQ0Cj4g LS0tIGEvaW5jbHVkZS9saW51eC9wY2ktZXBmLmgKPiArKysgYi9pbmNsdWRlL2xpbnV4L3BjaS1l cGYuaAo+IEBAIC03OSw2ICs3OSw3IEBAIHN0cnVjdCBwY2lfZXBjX2V2ZW50X29wcyB7Cj4gIAlp bnQgKCpsaW5rX3VwKShzdHJ1Y3QgcGNpX2VwZiAqZXBmKTsKPiAgCWludCAoKmxpbmtfZG93biko c3RydWN0IHBjaV9lcGYgKmVwZik7Cj4gIAlpbnQgKCpibWUpKHN0cnVjdCBwY2lfZXBmICplcGYp Owo+ICsJaW50ICgqZG9vcmJlbGwpKHN0cnVjdCBwY2lfZXBmICplcGYsIGludCBpbmRleCk7Cgpr ZG9jIG1pc3NpbmcuCgo+ICB9Owo+ICAKPiAgLyoqCj4gQEAgLTE4MCw2ICsxODEsOSBAQCBzdHJ1 Y3QgcGNpX2VwZiB7Cj4gIAl1bnNpZ25lZCBsb25nCQl2ZnVuY3Rpb25fbnVtX21hcDsKPiAgCXN0 cnVjdCBsaXN0X2hlYWQJcGNpX3ZlcGY7Cj4gIAljb25zdCBzdHJ1Y3QgcGNpX2VwY19ldmVudF9v cHMgKmV2ZW50X29wczsKPiArCXN0cnVjdCBtc2lfbXNnICptc2c7Cj4gKwl1MTYgbnVtX21zZ3M7 CgpudW1fZGIKCllvdSBhbHNvIG5lZWQgdG8gYWRkIGtkb2MgZm9yIGVhY2ggbmV3IG1lbWJlci4K Ci0gTWFuaQoKLS0gCuCuruCuo+Cuv+CuteCuo+CvjeCuo+CuqeCvjSDgrprgrqTgrr7grprgrr/g rrXgrq7gr40KCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5m cmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xp bnV4LWFybS1rZXJuZWwK