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 CBAB4CDB474 for ; Fri, 20 Oct 2023 13:19:54 +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:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=nsdakx/hg8+tUJnmaLn6dSalPF+ZVdF9tTMslHcVXFI=; b=RdfGj31URXs7bF rzCbCJ+bCYndb2MJMnwtl+rPDV5p6O9kLnrVrUingZCNJs7YFvxeO18SdrC2l7yVPS6OX5TIsD2Z6 ScvWpzRfO0PcozLGI7XnzmK6Pp59Seuer+VQkSyO1b5R9S4JMaKb+UW9cJPG0/8FFIuZYUrF0B5A3 sUXN8pErTZsAnb//Z8FJ/KanZoGR9qFKHIzpq8qzht/fhXYlFS/PaV9hAOi3QdQ5wK4BXINSAo4MR lHnI/2ym5HN/XOpNBcjCt0Lyezhz5/cjKyUZETvW2fjI0b3xvu+5TR8kBtccI0HwmPI/Z+1b1/7a5 vUu6crz76ArR/cTAl+vQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1qtpPp-002M6o-2f; Fri, 20 Oct 2023 13:19:49 +0000 Received: from ams.source.kernel.org ([145.40.68.75]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1qtpPl-002M1h-0J for linux-riscv@lists.infradead.org; Fri, 20 Oct 2023 13:19:48 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by ams.source.kernel.org (Postfix) with ESMTP id 1DDECB8325C; Fri, 20 Oct 2023 13:19:40 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6BCAAC433CD; Fri, 20 Oct 2023 13:19:36 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1697807979; bh=KyvRKjuZbIzW96MYXWomBp5JSUyvdeq+e4kdZAAGY28=; h=From:List-Id:To:Cc:Subject:Date:In-Reply-To:References:From; b=aJbVndt61mMfOR+16ofqHv/wGeQHNoA5I8xepzJ1cJ5tPuWnGSaYYXja4Znh1iKxY ROJV8Cu4xWoO8S7X+1u7r5bmXSWuW5ZyWbQeFTncpOde437OZTXJSTwh6ZjXeQwQJe t6yzGrNPG7/GaurbVeBpk2qazv/mZFxYN99I8UbYBu9nNGqEzVb/fYTo0Z5pOHNcvV FxZzTpImgEY8YRGrl4fypmJsj9cKgWaAkeWUMhz0p1aqfYleTgrjrlww85c4UH5G3T 60W9X1dpLhQp4jXkug7K6+vT2zttUwHtnx+pd/O7k/xN9HINLsoWwaacm6weK+VeLE E8ZdzfxiYY0Rg== From: Conor Dooley To: soc@kernel.org Cc: conor@kernel.org, Conor Dooley , Arnd Bergmann , Daire McNamara , Rob Herring , Krzysztof Kozlowski , Moritz Fischer , Wu Hao , Xu Yilun , Tom Rix , Russ Weight , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-fpga@vger.kernel.org Subject: [PATCH v3 5/6] firmware: microchip: add PolarFire SoC Auto Update support Date: Fri, 20 Oct 2023 14:18:43 +0100 Message-Id: <20231020-series-uncooked-077b107af3ae@spud> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20231020-agreeably-filing-3d48708e6262@spud> References: <20231020-agreeably-filing-3d48708e6262@spud> MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=20165; i=conor.dooley@microchip.com; h=from:subject:message-id; bh=IUxB212bhJw2GUh3upA8XEBjT8HzAbuMhcRm4E4G/Ok=; b=owGbwMvMwCFWscWwfUFT0iXG02pJDKlGdbouMWWhX/RZjU+G39tgL5e70nunoc+Rf9q7Ne8nz ZGcnezQUcrCIMbBICumyJJ4u69Fav0flx3OPW9h5rAygQxh4OIUgIls7mZkuLxAb3mezbxE83nf hQo/yi1SaFudp1CcvTkw8uCOlKfqTAz/9PjN5AMKDwZHLZfn8hM0OCim/X2C3KyIiekKcTk+6/i YAA== X-Developer-Key: i=conor.dooley@microchip.com; a=openpgp; fpr=F9ECA03CF54F12CD01F1655722E2C55B37CF380C X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20231020_061945_444325_52ECAD83 X-CRM114-Status: GOOD ( 37.51 ) X-BeenThere: linux-riscv@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-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org RnJvbTogQ29ub3IgRG9vbGV5IDxjb25vci5kb29sZXlAbWljcm9jaGlwLmNvbT4KCkFkZCBzdXBw b3J0IGZvciBBdXRvIFVwZGF0ZSByZXByb2dyYW1taW5nIG9mIHRoZSBGUEdBIGZhYnJpYyBvbgpQ b2xhckZpcmUgU29DLCB1c2luZyB0aGUgZndfdXBsb2FkIG1lY2hhbmlzbSBhIGxhIHRoZQppbnRl bC1tMTAtYm1jLXNlYy11cGRhdGUgZHJpdmVyLgoKVGhpcyBkcml2ZXIgb25seSB3cml0ZXMgdGhl IGltYWdlIHRvIHRoZSBzcGkgZmxhc2ggJiBwZXJmb3Jtcwp2YWxpZGF0aW9uIG9uIGl0LCBhcyB0 aGUgZW50aXJlIEZQR0EgYmVjb21lcyB1bnVzYWJsZSBkdXJpbmcgdGhlIGFjdHVhbApyZXByb2dy YW1taW5nIG9mIGEgYml0c3RyZWFtLiBUbyBpbml0aWF0ZSB0aGUgcmVwcm9ncmFtbWluZyBpdHNl bGYsIGEKZGV2aWNlIHJlc2V0IGlzIHJlcXVpcmVkLiBUaGUgU0JJIFNSU1QgZXh0ZW5zaW9uJ3Mg ImNvbGQgcmVib290IiBjYW4KdHJpZ2dlciBzdWNoIGEgZGV2aWNlIHJlc2V0LCBwcm92aWRlZCBj b3JyZXNwb25kaW5nIHN1cHBvcnQgaGFzIGJlZW4KZW5hYmxlZCBpbiB0aGUgSFNTIChIYXJ0IFNv ZnR3YXJlIFNlcnZpY2VzKSwgdGhlIHByb3ZpZGVyIG9mIFNCSSBydW50aW1lCnNlcnZpY2VzIG9u IFBvbGFyRmlyZSBTb0MuCgpXaGlsZSB0aGlzIGlzIGEgZHJpdmVyIHJlc3BvbnNpYmxlIGZvciB0 aGUgcmVwcm9ncmFtbWluZyBvZiBhbiBGUEdBLAp0aGVyZSBpcyBubyBkeW5hbWljIGRpc2NvdmVy eSBvZiBkZXZpY2VzIGludm9sdmVkLCBhcyBydW50aW1lCnJlY29uZmlndXJhdGlvbiBpcyBub3Qg cG9zc2libGUgZHVlIHRvIHRoZSBkZXZpY2UgcmVzZXQgcmVxdWlyZW1lbnRzLgpUaGVyZWZvcmUg RlBHQSBtYW5hZ2VyIHN1YnN5c3RlbSBpcyBub3QgdXNlZCBieSB0aGlzIGRyaXZlciBhbmQgdGhl IEZQR0EKc3Vic3lzdGVtIG1haW50YWluZXJzIHdlcmUgdW53aWxsaW5nIHRvIGFjY2VwdCBpdCB0 aGVyZS4KClNpZ25lZC1vZmYtYnk6IENvbm9yIERvb2xleSA8Y29ub3IuZG9vbGV5QG1pY3JvY2hp cC5jb20+Ci0tLQogZHJpdmVycy9maXJtd2FyZS9LY29uZmlnICAgICAgICAgICAgICAgICAgICAg IHwgICAxICsKIGRyaXZlcnMvZmlybXdhcmUvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICB8 ICAgMSArCiBkcml2ZXJzL2Zpcm13YXJlL21pY3JvY2hpcC9LY29uZmlnICAgICAgICAgICAgfCAg MTIgKwogZHJpdmVycy9maXJtd2FyZS9taWNyb2NoaXAvTWFrZWZpbGUgICAgICAgICAgIHwgICAz ICsKIGRyaXZlcnMvZmlybXdhcmUvbWljcm9jaGlwL21wZnMtYXV0by11cGRhdGUuYyB8IDQ5NCAr KysrKysrKysrKysrKysrKysKIDUgZmlsZXMgY2hhbmdlZCwgNTExIGluc2VydGlvbnMoKykKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2Zpcm13YXJlL21pY3JvY2hpcC9LY29uZmlnCiBjcmVh dGUgbW9kZSAxMDA2NDQgZHJpdmVycy9maXJtd2FyZS9taWNyb2NoaXAvTWFrZWZpbGUKIGNyZWF0 ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2Zpcm13YXJlL21pY3JvY2hpcC9tcGZzLWF1dG8tdXBkYXRl LmMKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Zpcm13YXJlL0tjb25maWcgYi9kcml2ZXJzL2Zpcm13 YXJlL0tjb25maWcKaW5kZXggYjU5ZTMwNDFmZDYyLi5mMjQ3YWMzM2M3NWIgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvZmlybXdhcmUvS2NvbmZpZworKysgYi9kcml2ZXJzL2Zpcm13YXJlL0tjb25maWcK QEAgLTMxMCw2ICszMTAsNyBAQCBzb3VyY2UgImRyaXZlcnMvZmlybXdhcmUvZ29vZ2xlL0tjb25m aWciCiBzb3VyY2UgImRyaXZlcnMvZmlybXdhcmUvZWZpL0tjb25maWciCiBzb3VyY2UgImRyaXZl cnMvZmlybXdhcmUvaW14L0tjb25maWciCiBzb3VyY2UgImRyaXZlcnMvZmlybXdhcmUvbWVzb24v S2NvbmZpZyIKK3NvdXJjZSAiZHJpdmVycy9maXJtd2FyZS9taWNyb2NoaXAvS2NvbmZpZyIKIHNv dXJjZSAiZHJpdmVycy9maXJtd2FyZS9wc2NpL0tjb25maWciCiBzb3VyY2UgImRyaXZlcnMvZmly bXdhcmUvc21jY2MvS2NvbmZpZyIKIHNvdXJjZSAiZHJpdmVycy9maXJtd2FyZS90ZWdyYS9LY29u ZmlnIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9maXJtd2FyZS9NYWtlZmlsZSBiL2RyaXZlcnMvZmly bXdhcmUvTWFrZWZpbGUKaW5kZXggMjhmY2RkY2Q2ODhmLi45MDE3NzFkMmJkNDcgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvZmlybXdhcmUvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9maXJtd2FyZS9NYWtl ZmlsZQpAQCAtMzEsNiArMzEsNyBAQCBvYmoteQkJCQkrPSBhcm1fc2NtaS8KIG9iai15CQkJCSs9 IGJyb2FkY29tLwogb2JqLXkJCQkJKz0gY2lycnVzLwogb2JqLXkJCQkJKz0gbWVzb24vCitvYmot eQkJCQkrPSBtaWNyb2NoaXAvCiBvYmotJChDT05GSUdfR09PR0xFX0ZJUk1XQVJFKQkrPSBnb29n bGUvCiBvYmoteQkJCQkrPSBlZmkvCiBvYmoteQkJCQkrPSBpbXgvCmRpZmYgLS1naXQgYS9kcml2 ZXJzL2Zpcm13YXJlL21pY3JvY2hpcC9LY29uZmlnIGIvZHJpdmVycy9maXJtd2FyZS9taWNyb2No aXAvS2NvbmZpZwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjQzNGI5 MjNlMDhjMgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZmlybXdhcmUvbWljcm9jaGlwL0tj b25maWcKQEAgLTAsMCArMSwxMiBAQAorIyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIu MC1vbmx5CisKK2NvbmZpZyBQT0xBUkZJUkVfU09DX0FVVE9fVVBEQVRFCisJdHJpc3RhdGUgIk1p Y3JvY2hpcCBQb2xhckZpcmUgU29DIEFVVE8gVVBEQVRFIgorCWRlcGVuZHMgb24gUE9MQVJGSVJF X1NPQ19TWVNfQ1RSTAorCXNlbGVjdCBGV19MT0FERVIKKwlzZWxlY3QgRldfVVBMT0FECisJaGVs cAorCSAgU3VwcG9ydCBmb3IgcmVwcm9ncmFtbWluZyBQb2xhckZpcmUgU29DIGZyb20gd2l0aGlu IExpbnV4LCB1c2luZyB0aGUKKwkgIEF1dG8gVXBncmFkZSBmZWF0dXJlIG9mIHRoZSBzeXN0ZW0g Y29udHJvbGxlci4KKworCSAgSWYgYnVpbHQgYXMgYSBtb2R1bGUsIGl0IHdpbGwgYmUgY2FsbGVk IG1wZnMtYXV0by11cGRhdGUuCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Zpcm13YXJlL21pY3JvY2hp cC9NYWtlZmlsZSBiL2RyaXZlcnMvZmlybXdhcmUvbWljcm9jaGlwL01ha2VmaWxlCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMzg3OTZmZDgyODkzCi0tLSAvZGV2L251 bGwKKysrIGIvZHJpdmVycy9maXJtd2FyZS9taWNyb2NoaXAvTWFrZWZpbGUKQEAgLTAsMCArMSwz IEBACisjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisKK29iai0kKENPTkZJR19Q T0xBUkZJUkVfU09DX0FVVE9fVVBEQVRFKSArPSBtcGZzLWF1dG8tdXBkYXRlLm8KZGlmZiAtLWdp dCBhL2RyaXZlcnMvZmlybXdhcmUvbWljcm9jaGlwL21wZnMtYXV0by11cGRhdGUuYyBiL2RyaXZl cnMvZmlybXdhcmUvbWljcm9jaGlwL21wZnMtYXV0by11cGRhdGUuYwpuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmEzN2FhODQ1NmU5NAotLS0gL2Rldi9udWxsCisrKyBi L2RyaXZlcnMvZmlybXdhcmUvbWljcm9jaGlwL21wZnMtYXV0by11cGRhdGUuYwpAQCAtMCwwICsx LDQ5NCBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKy8qCisgKiBNaWNy b2NoaXAgUG9sYXJmaXJlIFNvQyAiQXV0byBVcGRhdGUiIEZQR0EgcmVwcm9ncmFtbWluZy4KKyAq CisgKiBEb2N1bWVudGF0aW9uIG9mIHRoaXMgZnVuY3Rpb25hbGl0eSBpcyBhdmFpbGFibGUgaW4g dGhlICJQb2xhckZpcmXCriBGUEdBIGFuZAorICogUG9sYXJGaXJlIFNvQyBGUEdBIFByb2dyYW1t aW5nIiBVc2VyIEd1aWRlLgorICoKKyAqIENvcHlyaWdodCAoYykgMjAyMi0yMDIzIE1pY3JvY2hp cCBDb3Jwb3JhdGlvbi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBBdXRob3I6IENvbm9y IERvb2xleSA8Y29ub3IuZG9vbGV5QG1pY3JvY2hpcC5jb20+CisgKi8KKyNpbmNsdWRlIDxsaW51 eC9kZWJ1Z2ZzLmg+CisjaW5jbHVkZSA8bGludXgvZmlybXdhcmUuaD4KKyNpbmNsdWRlIDxsaW51 eC9tYXRoLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvbXRk L210ZC5oPgorI2luY2x1ZGUgPGxpbnV4L29mX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3Np emVzLmg+CisKKyNpbmNsdWRlIDxzb2MvbWljcm9jaGlwL21wZnMuaD4KKworI2RlZmluZSBBVVRP X1VQREFURV9ERUZBVUxUX01CT1hfT0ZGU0VUCQkwdQorI2RlZmluZSBBVVRPX1VQREFURV9ERUZB VUxUX1JFU1BfT0ZGU0VUCQkwdQorCisjZGVmaW5lIEFVVE9fVVBEQVRFX0ZFQVRVUkVfQ01EX09Q Q09ERQkJMHgwNXUKKyNkZWZpbmUgQVVUT19VUERBVEVfRkVBVFVSRV9DTURfREFUQV9TSVpFCTB1 CisjZGVmaW5lIEFVVE9fVVBEQVRFX0ZFQVRVUkVfUkVTUF9TSVpFCQkzM3UKKyNkZWZpbmUgQVVU T19VUERBVEVfRkVBVFVSRV9DTURfREFUQQkJTlVMTAorI2RlZmluZSBBVVRPX1VQREFURV9GRUFU VVJFX0VOQUJMRUQJCUJJVCg1KQorCisjZGVmaW5lIEFVVE9fVVBEQVRFX0FVVEhFTlRJQ0FURV9D TURfT1BDT0RFCTB4MjJ1CisjZGVmaW5lIEFVVE9fVVBEQVRFX0FVVEhFTlRJQ0FURV9DTURfREFU QV9TSVpFCTB1CisjZGVmaW5lIEFVVE9fVVBEQVRFX0FVVEhFTlRJQ0FURV9SRVNQX1NJWkUJMXUK KyNkZWZpbmUgQVVUT19VUERBVEVfQVVUSEVOVElDQVRFX0NNRF9EQVRBCU5VTEwKKworI2RlZmlu ZSBBVVRPX1VQREFURV9QUk9HUkFNX0NNRF9PUENPREUJCTB4NDZ1CisjZGVmaW5lIEFVVE9fVVBE QVRFX1BST0dSQU1fQ01EX0RBVEFfU0laRQkwdQorI2RlZmluZSBBVVRPX1VQREFURV9QUk9HUkFN X1JFU1BfU0laRQkJMXUKKyNkZWZpbmUgQVVUT19VUERBVEVfUFJPR1JBTV9DTURfREFUQQkJTlVM TAorCisvKgorICogU1BJIEZsYXNoIGxheW91dCBleGFtcGxlOgorICogfC0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLXwgMHgwMDAwMDAwCisgKiB8IDEgS2lCICAgICAgICAgICAgICAgICAg ICAgICAgfAorICogfCBTUEkgImRpcmVjdG9yaWVzIiAgICAgICAgICAgIHwKKyAqIHwtLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS18IDB4MDAwMDQwMAorICogfCAxIE1pQiAgICAgICAgICAg ICAgICAgICAgICAgIHwKKyAqIHwgUmVzZXJ2ZWQgYXJlYSAgICAgICAgICAgICAgICB8CisgKiB8 IFVzZWQgZm9yIGJpdHN0cmVhbSBpbmZvICAgICAgfAorICogfC0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLXwgMHgwMTAwNDAwCisgKiB8IDIwIE1pQiAgICAgICAgICAgICAgICAgICAgICAg fAorICogfCBHb2xkZW4gSW1hZ2UgICAgICAgICAgICAgICAgIHwKKyAqIHwtLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS18IDB4MTUwMDQwMAorICogfCAyMCBNaUIgICAgICAgICAgICAgICAg ICAgICAgIHwKKyAqIHwgQXV0byBVcGdyYWRlIEltYWdlICAgICAgICAgICB8CisgKiB8LS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tfCAweDI5MDA0MDAKKyAqIHwgMjAgTWlCICAgICAgICAg ICAgICAgICAgICAgICB8CisgKiB8IFJlc2VydmVkIGZvciBtdWx0aS1pbWFnZSBJQVAgfAorICog fCBVbnVzZWQgZm9yIEF1dG8gVXBncmFkZSAgICAgIHwKKyAqIHwtLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS18IDB4M0QwMDQwMAorICogfCA/IEIgICAgICAgICAgICAgICAgICAgICAgICAg IHwKKyAqIHwgVW51c2VkICAgICAgICAgICAgICAgICAgICAgICB8CisgKiB8LS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tfCAweD8KKyAqLworI2RlZmluZSBBVVRPX1VQREFURV9ESVJFQ1RP UllfQkFTRQkwdQorI2RlZmluZSBBVVRPX1VQREFURV9ESVJFQ1RPUllfV0lEVEgJNHUKKyNkZWZp bmUgQVVUT19VUERBVEVfR09MREVOX0lOREVYCTB1CisjZGVmaW5lIEFVVE9fVVBEQVRFX1VQR1JB REVfSU5ERVgJMXUKKyNkZWZpbmUgQVVUT19VUERBVEVfQkxBTktfSU5ERVgJCTJ1CisjZGVmaW5l IEFVVE9fVVBEQVRFX0dPTERFTl9ESVJFQ1RPUlkJKEFVVE9fVVBEQVRFX0RJUkVDVE9SWV9XSURU SCAqIEFVVE9fVVBEQVRFX0dPTERFTl9JTkRFWCkKKyNkZWZpbmUgQVVUT19VUERBVEVfVVBHUkFE RV9ESVJFQ1RPUlkJKEFVVE9fVVBEQVRFX0RJUkVDVE9SWV9XSURUSCAqIEFVVE9fVVBEQVRFX1VQ R1JBREVfSU5ERVgpCisjZGVmaW5lIEFVVE9fVVBEQVRFX0JMQU5LX0RJUkVDVE9SWQkoQVVUT19V UERBVEVfRElSRUNUT1JZX1dJRFRIICogQVVUT19VUERBVEVfQkxBTktfSU5ERVgpCisjZGVmaW5l IEFVVE9fVVBEQVRFX0RJUkVDVE9SWV9TSVpFCVNaXzFLCisjZGVmaW5lIEFVVE9fVVBEQVRFX1JF U0VSVkVEX1NJWkUJU1pfMU0KKyNkZWZpbmUgQVVUT19VUERBVEVfQklUU1RSRUFNX0JBU0UJKEFV VE9fVVBEQVRFX0RJUkVDVE9SWV9TSVpFICsgQVVUT19VUERBVEVfUkVTRVJWRURfU0laRSkKKwor I2RlZmluZSBBVVRPX1VQREFURV9USU1FT1VUX01TCQk2MDAwMAorCitzdHJ1Y3QgbXBmc19hdXRv X3VwZGF0ZV9wcml2IHsKKwlzdHJ1Y3QgbXBmc19zeXNfY29udHJvbGxlciAqc3lzX2NvbnRyb2xs ZXI7CisJc3RydWN0IGRldmljZSAqZGV2OworCXN0cnVjdCBtdGRfaW5mbyAqZmxhc2g7CisJc3Ry dWN0IGZ3X3VwbG9hZCAqZndfdXBsb2FkZXI7CisJc3RydWN0IGNvbXBsZXRpb24gcHJvZ3JhbW1p bmdfY29tcGxldGU7CisJc2l6ZV90IHNpemVfcGVyX2JpdHN0cmVhbTsKKwlib29sIGNhbmNlbF9y ZXF1ZXN0OworfTsKKworc3RhdGljIGVudW0gZndfdXBsb2FkX2VyciBtcGZzX2F1dG9fdXBkYXRl X3ByZXBhcmUoc3RydWN0IGZ3X3VwbG9hZCAqZndfdXBsb2FkZXIsIGNvbnN0IHU4ICpkYXRhLAor CQkJCQkJICAgdTMyIHNpemUpCit7CisJc3RydWN0IG1wZnNfYXV0b191cGRhdGVfcHJpdiAqcHJp diA9IGZ3X3VwbG9hZGVyLT5kZF9oYW5kbGU7CisJc2l6ZV90IGVyYXNlX3NpemUgPSBBVVRPX1VQ REFURV9ESVJFQ1RPUllfU0laRTsKKworCS8qCisJICogVmVyaWZ5aW5nIHRoZSBHb2xkZW4gSW1h Z2UgaXMgaWRlYWxpc3RpYy4gSXQgd2lsbCBiZSBldmFsdWF0ZWQKKwkgKiBhZ2FpbnN0IHRoZSBj dXJyZW50bHkgcHJvZ3JhbW1lZCBpbWFnZSBhbmQgdGh1cyBtYXkgZmFpbCAtIGR1ZSB0bworCSAq IGVpdGhlciByb2xsYmFjayBwcm90ZWN0aW9uIChpZiBpdHMgYW4gb2xkZXIgdmVyc2lvbiB0aGFu IHRoYXQgaW4gdXNlKQorCSAqIG9yIGlmIHRoZSB2ZXJzaW9uIGlzIHRoZSBzYW1lIGFzIHRoYXQg b2YgdGhlIGluLXVzZSBpbWFnZS4KKwkgKiBFeHRyYWN0aW5nIHRoZSBpbmZvcm1hdGlvbiBhcyB0 byB3aHkgYSBmYWlsdXJlIG9jY3VycmVkIGlzIG5vdAorCSAqIGN1cnJlbnRseSBwb3NzaWJsZSBk dWUgdG8gbGltaXRhdGlvbnMgb2YgdGhlIHN5c3RlbSBjb250cm9sbGVyCisJICogZHJpdmVyLiBJ ZiB0aG9zZSBhcmUgZml4ZWQsIHZlcmlmaWNhdGlvbiBvZiB0aGUgR29sZGVuIEltYWdlIHNob3Vs ZAorCSAqIGJlIGFkZGVkIGhlcmUuCisJICovCisKKwlwcml2LT5mbGFzaCA9IG1wZnNfc3lzX2Nv bnRyb2xsZXJfZ2V0X2ZsYXNoKHByaXYtPnN5c19jb250cm9sbGVyKTsKKwlpZiAoIXByaXYtPmZs YXNoKQorCQlyZXR1cm4gRldfVVBMT0FEX0VSUl9IV19FUlJPUjsKKworCWVyYXNlX3NpemUgPSBy b3VuZF91cChlcmFzZV9zaXplLCAodTY0KXByaXYtPmZsYXNoLT5lcmFzZXNpemUpOworCisJLyoK KwkgKiBXZSBuZWVkIHRvIGNhbGN1bGF0ZSBpZiB3ZSBoYXZlIGVub3VnaCBzcGFjZSBpbiB0aGUg Zmxhc2ggZm9yIHRoZQorCSAqIG5ldyBpbWFnZS4KKwkgKiBGaXJzdCwgY2hvcCBvZmYgdGhlIGZp cnN0IDEgS2lCIGFzIGl0J3MgcmVzZXJ2ZWQgZm9yIHRoZSBkaXJlY3RvcnkuCisJICogVGhlIDEg TWlCIHJlc2VydmVkIGZvciBkZXNpZ24gaW5mbyBuZWVkcyB0byBiZSBpZ25vcmVkIGFsc28uCisJ ICogQWxsIHRoYXQgcmVtYWlucyBpcyBjYXJ2ZWQgaW50byAzICYgcm91bmRlZCBkb3duIHRvIHRo ZSBlcmFzZXNpemUuCisJICogSWYgdGhpcyBpcyBzbWFsbGVyIHRoYW4gdGhlIGltYWdlIHNpemUs IHdlIGFib3J0LgorCSAqIFRoZXJlJ3MgYWxzbyBubyBuZWVkIHRvIGNvbnN1bWUgbW9yZSB0aGFu IDIwIE1pQiBwZXIgaW1hZ2UuCisJICovCisJcHJpdi0+c2l6ZV9wZXJfYml0c3RyZWFtID0gcHJp di0+Zmxhc2gtPnNpemUgLSBTWl8xSyAtIFNaXzFNOworCXByaXYtPnNpemVfcGVyX2JpdHN0cmVh bSA9IHJvdW5kX2Rvd24ocHJpdi0+c2l6ZV9wZXJfYml0c3RyZWFtIC8gMywgZXJhc2Vfc2l6ZSk7 CisJaWYgKHByaXYtPnNpemVfcGVyX2JpdHN0cmVhbSA+IDIwICogU1pfMU0pCisJCXByaXYtPnNp emVfcGVyX2JpdHN0cmVhbSA9IDIwICogU1pfMU07CisKKwlpZiAocHJpdi0+c2l6ZV9wZXJfYml0 c3RyZWFtIDwgc2l6ZSkgeworCQlkZXZfZXJyKHByaXYtPmRldiwKKwkJCSJmbGFzaCBkZXZpY2Ug aGFzIGluc3VmZmljaWVudCBjYXBhY2l0eSB0byBzdG9yZSB0aGlzIGJpdHN0cmVhbVxuIik7CisJ CXJldHVybiBGV19VUExPQURfRVJSX0lOVkFMSURfU0laRTsKKwl9CisKKwlwcml2LT5jYW5jZWxf cmVxdWVzdCA9IGZhbHNlOworCisJcmV0dXJuIEZXX1VQTE9BRF9FUlJfTk9ORTsKK30KKworc3Rh dGljIHZvaWQgbXBmc19hdXRvX3VwZGF0ZV9jYW5jZWwoc3RydWN0IGZ3X3VwbG9hZCAqZndfdXBs b2FkZXIpCit7CisJc3RydWN0IG1wZnNfYXV0b191cGRhdGVfcHJpdiAqcHJpdiA9IGZ3X3VwbG9h ZGVyLT5kZF9oYW5kbGU7CisKKwlwcml2LT5jYW5jZWxfcmVxdWVzdCA9IHRydWU7Cit9CisKK3N0 YXRpYyBlbnVtIGZ3X3VwbG9hZF9lcnIgbXBmc19hdXRvX3VwZGF0ZV9wb2xsX2NvbXBsZXRlKHN0 cnVjdCBmd191cGxvYWQgKmZ3X3VwbG9hZGVyKQoreworCXN0cnVjdCBtcGZzX2F1dG9fdXBkYXRl X3ByaXYgKnByaXYgPSBmd191cGxvYWRlci0+ZGRfaGFuZGxlOworCWludCByZXQ7CisKKwkvKgor CSAqIFRoZXJlIGlzIG5vIG1lYW5pbmdmdWwgd2F5IHRvIGdldCB0aGUgc3RhdHVzIG9mIHRoZSBw cm9ncmFtbWluZyB3aGlsZQorCSAqIGl0IGlzIGluIHByb2dyZXNzLCBzbyBhdHRlbXB0aW5nIGFu eXRoaW5nIG90aGVyIHRoYW4gd2FpdGluZyBmb3IgaXQKKwkgKiB0byBjb21wbGV0ZSB3b3VsZCBi ZSBtaXNwbGFjZWQuCisJICovCisJcmV0ID0gd2FpdF9mb3JfY29tcGxldGlvbl90aW1lb3V0KCZw cml2LT5wcm9ncmFtbWluZ19jb21wbGV0ZSwKKwkJCQkJICBtc2Vjc190b19qaWZmaWVzKEFVVE9f VVBEQVRFX1RJTUVPVVRfTVMpKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gRldfVVBMT0FEX0VSUl9U SU1FT1VUOworCisJcmV0dXJuIEZXX1VQTE9BRF9FUlJfTk9ORTsKK30KKworc3RhdGljIGludCBt cGZzX2F1dG9fdXBkYXRlX3ZlcmlmeV9pbWFnZShzdHJ1Y3QgZndfdXBsb2FkICpmd191cGxvYWRl cikKK3sKKwlzdHJ1Y3QgbXBmc19hdXRvX3VwZGF0ZV9wcml2ICpwcml2ID0gZndfdXBsb2FkZXIt PmRkX2hhbmRsZTsKKwlzdHJ1Y3QgbXBmc19tc3NfcmVzcG9uc2UgKnJlc3BvbnNlOworCXN0cnVj dCBtcGZzX21zc19tc2cgKm1lc3NhZ2U7CisJdTMyICpyZXNwb25zZV9tc2c7CisJaW50IHJldDsK KworCXJlc3BvbnNlX21zZyA9IGRldm1fa3phbGxvYyhwcml2LT5kZXYsIEFVVE9fVVBEQVRFX0ZF QVRVUkVfUkVTUF9TSVpFICogc2l6ZW9mKHJlc3BvbnNlX21zZyksCisJCQkJICAgIEdGUF9LRVJO RUwpOworCWlmICghcmVzcG9uc2VfbXNnKQorCQlyZXR1cm4gLUVOT01FTTsKKworCXJlc3BvbnNl ID0gZGV2bV9remFsbG9jKHByaXYtPmRldiwgc2l6ZW9mKHN0cnVjdCBtcGZzX21zc19yZXNwb25z ZSksIEdGUF9LRVJORUwpOworCWlmICghcmVzcG9uc2UpIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJ Z290byBmcmVlX3Jlc3BvbnNlX21zZzsKKwl9CisKKwltZXNzYWdlID0gZGV2bV9remFsbG9jKHBy aXYtPmRldiwgc2l6ZW9mKHN0cnVjdCBtcGZzX21zc19tc2cpLCBHRlBfS0VSTkVMKTsKKwlpZiAo IW1lc3NhZ2UpIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBmcmVlX3Jlc3BvbnNlOworCX0K KworCS8qCisJICogVGhlIHN5c3RlbSBjb250cm9sbGVyIGNhbiB2ZXJpZnkgdGhhdCBhbiBpbWFn ZSBpbiB0aGUgZmxhc2ggaXMgdmFsaWQuCisJICogUmF0aGVyIHRoYW4gZHVwbGljYXRlIHRoZSBj aGVjayBpbiB0aGlzIGRyaXZlciwgY2FsbCB0aGUgcmVsZXZhbnQKKwkgKiBzZXJ2aWNlIGZyb20g dGhlIHN5c3RlbSBjb250cm9sbGVyIGluc3RlYWQuCisJICogVGhpcyBzZXJ2aWNlIGhhcyBubyBj b21tYW5kIGRhdGEgYW5kIG5vIHJlc3BvbnNlIGRhdGEuIEl0IG92ZXJsb2FkcworCSAqIG1ib3hf b2Zmc2V0IHdpdGggdGhlIGltYWdlIGluZGV4IGluIHRoZSBmbGFzaCdzIFNQSSBkaXJlY3Rvcnkg d2hlcmUKKwkgKiB0aGUgYml0c3RyZWFtIGlzIGxvY2F0ZWQuCisJICovCisJcmVzcG9uc2UtPnJl c3BfbXNnID0gcmVzcG9uc2VfbXNnOworCXJlc3BvbnNlLT5yZXNwX3NpemUgPSBBVVRPX1VQREFU RV9BVVRIRU5USUNBVEVfUkVTUF9TSVpFOworCW1lc3NhZ2UtPmNtZF9vcGNvZGUgPSBBVVRPX1VQ REFURV9BVVRIRU5USUNBVEVfQ01EX09QQ09ERTsKKwltZXNzYWdlLT5jbWRfZGF0YV9zaXplID0g QVVUT19VUERBVEVfQVVUSEVOVElDQVRFX0NNRF9EQVRBX1NJWkU7CisJbWVzc2FnZS0+cmVzcG9u c2UgPSByZXNwb25zZTsKKwltZXNzYWdlLT5jbWRfZGF0YSA9IEFVVE9fVVBEQVRFX0FVVEhFTlRJ Q0FURV9DTURfREFUQTsKKwltZXNzYWdlLT5tYm94X29mZnNldCA9IEFVVE9fVVBEQVRFX1VQR1JB REVfSU5ERVg7CisJbWVzc2FnZS0+cmVzcF9vZmZzZXQgPSBBVVRPX1VQREFURV9ERUZBVUxUX1JF U1BfT0ZGU0VUOworCisJZGV2X2luZm8ocHJpdi0+ZGV2LCAiUnVubmluZyB2ZXJpZmljYXRpb24g b2YgVXBncmFkZSBJbWFnZVxuIik7CisJcmV0ID0gbXBmc19ibG9ja2luZ190cmFuc2FjdGlvbihw cml2LT5zeXNfY29udHJvbGxlciwgbWVzc2FnZSk7CisJaWYgKHJldCB8IHJlc3BvbnNlLT5yZXNw X3N0YXR1cykgeworCQlkZXZfd2Fybihwcml2LT5kZXYsICJWZXJpZmljYXRpb24gb2YgVXBncmFk ZSBJbWFnZSBmYWlsZWQhXG4iKTsKKwkJcmV0ID0gcmV0ID8gcmV0IDogLUVCQURNU0c7CisJfQor CisJZGV2X2luZm8ocHJpdi0+ZGV2LCAiVmVyaWZpY2F0aW9uIG9mIFVwZ3JhZGUgSW1hZ2UgcGFz c2VkIVxuIik7CisKKwlkZXZtX2tmcmVlKHByaXYtPmRldiwgbWVzc2FnZSk7CitmcmVlX3Jlc3Bv bnNlOgorCWRldm1fa2ZyZWUocHJpdi0+ZGV2LCByZXNwb25zZSk7CitmcmVlX3Jlc3BvbnNlX21z ZzoKKwlkZXZtX2tmcmVlKHByaXYtPmRldiwgcmVzcG9uc2VfbXNnKTsKKworCXJldHVybiByZXQ7 Cit9CisKK3N0YXRpYyBpbnQgbXBmc19hdXRvX3VwZGF0ZV9zZXRfaW1hZ2VfYWRkcmVzcyhzdHJ1 Y3QgbXBmc19hdXRvX3VwZGF0ZV9wcml2ICpwcml2LCBjaGFyICpidWZmZXIsCisJCQkJCSAgICAg IHUzMiBpbWFnZV9hZGRyZXNzLCBsb2ZmX3QgZGlyZWN0b3J5X2FkZHJlc3MpCit7CisJc3RydWN0 IGVyYXNlX2luZm8gZXJhc2U7CisJc2l6ZV90IGVyYXNlX3NpemUgPSBBVVRPX1VQREFURV9ESVJF Q1RPUllfU0laRTsKKwlzaXplX3QgYnl0ZXNfd3JpdHRlbiA9IDAsIGJ5dGVzX3JlYWQgPSAwOwor CWludCByZXQ7CisKKwllcmFzZV9zaXplID0gcm91bmRfdXAoZXJhc2Vfc2l6ZSwgKHU2NClwcml2 LT5mbGFzaC0+ZXJhc2VzaXplKTsKKworCWVyYXNlLmFkZHIgPSBBVVRPX1VQREFURV9ESVJFQ1RP UllfQkFTRTsKKwllcmFzZS5sZW4gPSBlcmFzZV9zaXplOworCisJLyoKKwkgKiBXZSBuZWVkIHRv IHdyaXRlIHRoZSAiU1BJIERJUkVDVE9SWSIgdG8gdGhlIGZpcnN0IDEgS2lCLCB0ZWxsaW5nCisJ ICogdGhlIHN5c3RlbSBjb250cm9sbGVyIHdoZXJlIHRvIGZpbmQgdGhlIGFjdHVhbCBiaXRzdHJl YW0uIFNpbmNlCisJICogdGhpcyBpcyBzcGktbm9yLCB3ZSBoYXZlIHRvIHJlYWQgdGhlIGZpcnN0 IGVyYXNlYmxvY2ssIGVyYXNlIHRoYXQKKwkgKiBwb3J0aW9uIG9mIHRoZSBmbGFzaCwgbW9kaWZ5 IHRoZSBkYXRhIGFuZCB0aGVuIHdyaXRlIGl0IGJhY2suCisJICogVGhlcmUncyBubyBuZWVkIHRv IGRvIHRoaXMgdGhvdWdoIGlmIHRoaW5ncyBhcmUgYWxyZWFkeSB0aGUgd2F5IHRoZXkKKwkgKiBz aG91bGQgYmUsIHNvIGNoZWNrIGFuZCBzYXZlIHRoZSB3cml0ZSBpbiB0aGF0IGNhc2UuCisJICov CisJcmV0ID0gbXRkX3JlYWQocHJpdi0+Zmxhc2gsIEFVVE9fVVBEQVRFX0RJUkVDVE9SWV9CQVNF LCBlcmFzZV9zaXplLCAmYnl0ZXNfcmVhZCwKKwkJICAgICAgICh1X2NoYXIgKilidWZmZXIpOwor CWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlpZiAoYnl0ZXNfcmVhZCAhPSBlcmFzZV9zaXpl KQorCQlyZXR1cm4gLUVJTzsKKworCWlmICgoKih1MzIgKikoYnVmZmVyICsgQVVUT19VUERBVEVf VVBHUkFERV9ESVJFQ1RPUlkpID09IGltYWdlX2FkZHJlc3MpICYmCisJICAgICEoKih1MzIgKiko YnVmZmVyICsgQVVUT19VUERBVEVfQkxBTktfRElSRUNUT1JZKSkpCisJCXJldHVybiAwOworCisJ cmV0ID0gbXRkX2VyYXNlKHByaXYtPmZsYXNoLCAmZXJhc2UpOworCWlmIChyZXQpCisJCXJldHVy biByZXQ7CisKKwkvKgorCSAqIFBvcHVsYXRlIHRoZSBpbWFnZSBhZGRyZXNzIGFuZCB0aGVuIHpl cm8gb3V0IHRoZSBuZXh0IGRpcmVjdG9yeSBzbworCSAqIHRoYXQgdGhlIHN5c3RlbSBjb250cm9s bGVyIGRvZXNuJ3QgY29tcGxhaW4gaWYgaW4gIlNpbmdsZSBJbWFnZSIKKwkgKiBtb2RlLgorCSAq LworCW1lbWNweShidWZmZXIgKyBBVVRPX1VQREFURV9VUEdSQURFX0RJUkVDVE9SWSwgJmltYWdl X2FkZHJlc3MsCisJICAgICAgIEFVVE9fVVBEQVRFX0RJUkVDVE9SWV9XSURUSCk7CisJbWVtc2V0 KGJ1ZmZlciArIEFVVE9fVVBEQVRFX0JMQU5LX0RJUkVDVE9SWSwgMHgwLCBBVVRPX1VQREFURV9E SVJFQ1RPUllfV0lEVEgpOworCisJZGV2X2luZm8ocHJpdi0+ZGV2LCAiV3JpdGluZyB0aGUgaW1h Z2UgYWRkcmVzcyAoJXgpIHRvIHRoZSBmbGFzaCBkaXJlY3RvcnkgKCVsbHgpXG4iLAorCQkgaW1h Z2VfYWRkcmVzcywgZGlyZWN0b3J5X2FkZHJlc3MpOworCisJcmV0ID0gbXRkX3dyaXRlKHByaXYt PmZsYXNoLCAweDAsIGVyYXNlX3NpemUsICZieXRlc193cml0dGVuLCAodV9jaGFyICopYnVmZmVy KTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJaWYgKGJ5dGVzX3dyaXR0ZW4gIT0gZXJh c2Vfc2l6ZSkKKwkJcmV0dXJuIHJldDsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IG1w ZnNfYXV0b191cGRhdGVfd3JpdGVfYml0c3RyZWFtKHN0cnVjdCBmd191cGxvYWQgKmZ3X3VwbG9h ZGVyLCBjb25zdCB1OCAqZGF0YSwKKwkJCQkJICAgIHUzMiBvZmZzZXQsIHUzMiBzaXplLCB1MzIg KndyaXR0ZW4pCit7CisJc3RydWN0IG1wZnNfYXV0b191cGRhdGVfcHJpdiAqcHJpdiA9IGZ3X3Vw bG9hZGVyLT5kZF9oYW5kbGU7CisJc3RydWN0IGVyYXNlX2luZm8gZXJhc2U7CisJY2hhciAqYnVm ZmVyOworCWxvZmZfdCBkaXJlY3RvcnlfYWRkcmVzcyA9IEFVVE9fVVBEQVRFX1VQR1JBREVfRElS RUNUT1JZOworCXNpemVfdCBlcmFzZV9zaXplID0gQVVUT19VUERBVEVfRElSRUNUT1JZX1NJWkU7 CisJc2l6ZV90IGJ5dGVzX3dyaXR0ZW4gPSAwOworCXUzMiBpbWFnZV9hZGRyZXNzOworCWludCBy ZXQ7CisKKwllcmFzZV9zaXplID0gcm91bmRfdXAoZXJhc2Vfc2l6ZSwgKHU2NClwcml2LT5mbGFz aC0+ZXJhc2VzaXplKTsKKworCWltYWdlX2FkZHJlc3MgPSBBVVRPX1VQREFURV9CSVRTVFJFQU1f QkFTRSArCisJCUFVVE9fVVBEQVRFX1VQR1JBREVfSU5ERVggKiBwcml2LT5zaXplX3Blcl9iaXRz dHJlYW07CisKKwlidWZmZXIgPSBkZXZtX2t6YWxsb2MocHJpdi0+ZGV2LCBlcmFzZV9zaXplLCBH RlBfS0VSTkVMKTsKKwlpZiAoIWJ1ZmZlcikKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlyZXQgPSBt cGZzX2F1dG9fdXBkYXRlX3NldF9pbWFnZV9hZGRyZXNzKHByaXYsIGJ1ZmZlciwgaW1hZ2VfYWRk cmVzcywgZGlyZWN0b3J5X2FkZHJlc3MpOworCWlmIChyZXQpIHsKKwkJZGV2X2Vycihwcml2LT5k ZXYsICJmYWlsZWQgdG8gc2V0IGltYWdlIGFkZHJlc3MgaW4gdGhlIFNQSSBkaXJlY3Rvcnk6ICVk XG4iLCByZXQpOworCQlnb3RvIG91dDsKKwl9CisKKwkvKgorCSAqIE5vdyB0aGUgLnNwaSBpbWFn ZSBpdHNlbGYgY2FuIGJlIHdyaXR0ZW4gdG8gdGhlIGZsYXNoLiBQcmVzZXJ2YXRpb24KKwkgKiBv ZiBjb250ZW50cyBoZXJlIGlzIG5vdCBpbXBvcnRhbnQgaGVyZSwgdW5saWtlIHRoZSBzcGkgImRp cmVjdG9yeSIKKwkgKiB3aGljaCBtdXN0IGJlIFJNV2VkLgorCSAqLworCWVyYXNlLmxlbiA9IHJv dW5kX3VwKHNpemUsIChzaXplX3QpcHJpdi0+Zmxhc2gtPmVyYXNlc2l6ZSk7CisJZXJhc2UuYWRk ciA9IGltYWdlX2FkZHJlc3M7CisKKwlkZXZfaW5mbyhwcml2LT5kZXYsICJFcmFzaW5nIHRoZSBm bGFzaCBhdCBhZGRyZXNzICgleClcbiIsIGltYWdlX2FkZHJlc3MpOworCXJldCA9IG10ZF9lcmFz ZShwcml2LT5mbGFzaCwgJmVyYXNlKTsKKwlpZiAocmV0KQorCQlnb3RvIG91dDsKKworCS8qCisJ ICogTm8gcGFyc2luZyBldGMgb2YgdGhlIGJpdHN0cmVhbSBpcyByZXF1aXJlZC4gVGhlIHN5c3Rl bSBjb250cm9sbGVyCisJICogd2lsbCBkbyBhbGwgb2YgdGhhdCBpdHNlbGYgLSBpbmNsdWRpbmcg dmVyaWZ5aW5nIHRoYXQgdGhlIGJpdHN0cmVhbQorCSAqIGlzIHZhbGlkLgorCSAqLworCWRldl9p bmZvKHByaXYtPmRldiwgIldyaXRpbmcgdGhlIGltYWdlIHRvIHRoZSBmbGFzaCBhdCBhZGRyZXNz ICgleClcbiIsIGltYWdlX2FkZHJlc3MpOworCXJldCA9IG10ZF93cml0ZShwcml2LT5mbGFzaCwg KGxvZmZfdClpbWFnZV9hZGRyZXNzLCBzaXplLCAmYnl0ZXNfd3JpdHRlbiwgZGF0YSk7CisJaWYg KHJldCkKKwkJZ290byBvdXQ7CisKKwlpZiAoYnl0ZXNfd3JpdHRlbiAhPSBzaXplKSB7CisJCXJl dCA9IC1FSU87CisJCWdvdG8gb3V0OworCX0KKworCSp3cml0dGVuID0gYnl0ZXNfd3JpdHRlbjsK Kworb3V0OgorCWRldm1fa2ZyZWUocHJpdi0+ZGV2LCBidWZmZXIpOworCXJldHVybiByZXQ7Cit9 CisKK3N0YXRpYyBlbnVtIGZ3X3VwbG9hZF9lcnIgbXBmc19hdXRvX3VwZGF0ZV93cml0ZShzdHJ1 Y3QgZndfdXBsb2FkICpmd191cGxvYWRlciwgY29uc3QgdTggKmRhdGEsCisJCQkJCQkgdTMyIG9m ZnNldCwgdTMyIHNpemUsIHUzMiAqd3JpdHRlbikKK3sKKwlzdHJ1Y3QgbXBmc19hdXRvX3VwZGF0 ZV9wcml2ICpwcml2ID0gZndfdXBsb2FkZXItPmRkX2hhbmRsZTsKKwllbnVtIGZ3X3VwbG9hZF9l cnIgZXJyID0gRldfVVBMT0FEX0VSUl9OT05FOworCWludCByZXQ7CisKKwlyZWluaXRfY29tcGxl dGlvbigmcHJpdi0+cHJvZ3JhbW1pbmdfY29tcGxldGUpOworCisJcmV0ID0gbXBmc19hdXRvX3Vw ZGF0ZV93cml0ZV9iaXRzdHJlYW0oZndfdXBsb2FkZXIsIGRhdGEsIG9mZnNldCwgc2l6ZSwgd3Jp dHRlbik7CisJaWYgKHJldCkgeworCQllcnIgPSBGV19VUExPQURfRVJSX1JXX0VSUk9SOworCQln b3RvIG91dDsKKwl9CisKKwlpZiAocHJpdi0+Y2FuY2VsX3JlcXVlc3QpIHsKKwkJZXJyID0gRldf VVBMT0FEX0VSUl9DQU5DRUxFRDsKKwkJZ290byBvdXQ7CisJfQorCisJcmV0ID0gbXBmc19hdXRv X3VwZGF0ZV92ZXJpZnlfaW1hZ2UoZndfdXBsb2FkZXIpOworCWlmIChyZXQpCisJCWVyciA9IEZX X1VQTE9BRF9FUlJfSFdfRVJST1I7CisKK291dDoKKwljb21wbGV0ZSgmcHJpdi0+cHJvZ3JhbW1p bmdfY29tcGxldGUpOworCisJcmV0dXJuIGVycjsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBm d191cGxvYWRfb3BzIG1wZnNfYXV0b191cGRhdGVfb3BzID0geworCS5wcmVwYXJlID0gbXBmc19h dXRvX3VwZGF0ZV9wcmVwYXJlLAorCS53cml0ZSA9IG1wZnNfYXV0b191cGRhdGVfd3JpdGUsCisJ LnBvbGxfY29tcGxldGUgPSBtcGZzX2F1dG9fdXBkYXRlX3BvbGxfY29tcGxldGUsCisJLmNhbmNl bCA9IG1wZnNfYXV0b191cGRhdGVfY2FuY2VsLAorfTsKKworc3RhdGljIGludCBtcGZzX2F1dG9f dXBkYXRlX2F2YWlsYWJsZShzdHJ1Y3QgbXBmc19hdXRvX3VwZGF0ZV9wcml2ICpwcml2KQorewor CXN0cnVjdCBtcGZzX21zc19yZXNwb25zZSAqcmVzcG9uc2U7CisJc3RydWN0IG1wZnNfbXNzX21z ZyAqbWVzc2FnZTsKKwl1MzIgKnJlc3BvbnNlX21zZzsKKwlpbnQgcmV0OworCisJcmVzcG9uc2Vf bXNnID0gZGV2bV9remFsbG9jKHByaXYtPmRldiwgQVVUT19VUERBVEVfRkVBVFVSRV9SRVNQX1NJ WkUgKiBzaXplb2YocmVzcG9uc2VfbXNnKSwKKwkJCQkgICAgR0ZQX0tFUk5FTCk7CisJaWYgKCFy ZXNwb25zZV9tc2cpCisJCXJldHVybiAtRU5PTUVNOworCisJcmVzcG9uc2UgPSBkZXZtX2t6YWxs b2MocHJpdi0+ZGV2LCBzaXplb2Yoc3RydWN0IG1wZnNfbXNzX3Jlc3BvbnNlKSwgR0ZQX0tFUk5F TCk7CisJaWYgKCFyZXNwb25zZSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwltZXNzYWdlID0gZGV2 bV9remFsbG9jKHByaXYtPmRldiwgc2l6ZW9mKHN0cnVjdCBtcGZzX21zc19tc2cpLCBHRlBfS0VS TkVMKTsKKwlpZiAoIW1lc3NhZ2UpCisJCXJldHVybiAtRU5PTUVNOworCisJLyoKKwkgKiBUbyB2 ZXJpZnkgdGhhdCBBdXRvIFVwZGF0ZSBpcyBwb3NzaWJsZSwgdGhlICJRdWVyeSBTZWN1cml0eSBT ZXJ2aWNlCisJICogUmVxdWVzdCIgaXMgcGVyZm9ybWVkLgorCSAqIFRoaXMgc2VydmljZSBoYXMg bm8gY29tbWFuZCBkYXRhICYgZG9lcyBub3Qgb3ZlcmxvYWQgbWJveF9vZmZzZXQuCisJICovCisJ cmVzcG9uc2UtPnJlc3BfbXNnID0gcmVzcG9uc2VfbXNnOworCXJlc3BvbnNlLT5yZXNwX3NpemUg PSBBVVRPX1VQREFURV9GRUFUVVJFX1JFU1BfU0laRTsKKwltZXNzYWdlLT5jbWRfb3Bjb2RlID0g QVVUT19VUERBVEVfRkVBVFVSRV9DTURfT1BDT0RFOworCW1lc3NhZ2UtPmNtZF9kYXRhX3NpemUg PSBBVVRPX1VQREFURV9GRUFUVVJFX0NNRF9EQVRBX1NJWkU7CisJbWVzc2FnZS0+cmVzcG9uc2Ug PSByZXNwb25zZTsKKwltZXNzYWdlLT5jbWRfZGF0YSA9IEFVVE9fVVBEQVRFX0ZFQVRVUkVfQ01E X0RBVEE7CisJbWVzc2FnZS0+bWJveF9vZmZzZXQgPSBBVVRPX1VQREFURV9ERUZBVUxUX01CT1hf T0ZGU0VUOworCW1lc3NhZ2UtPnJlc3Bfb2Zmc2V0ID0gQVVUT19VUERBVEVfREVGQVVMVF9SRVNQ X09GRlNFVDsKKworCXJldCA9IG1wZnNfYmxvY2tpbmdfdHJhbnNhY3Rpb24ocHJpdi0+c3lzX2Nv bnRyb2xsZXIsIG1lc3NhZ2UpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwkvKgorCSAq IEN1cnJlbnRseSwgdGhlIHN5c3RlbSBjb250cm9sbGVyJ3MgZmlybXdhcmUgZG9lcyBub3QgZ2Vu ZXJhdGUgYW55CisJICogaW50ZXJydXB0cyBmb3IgZmFpbGVkIHNlcnZpY2VzLCBzbyBtcGZzX2Js b2NraW5nX3RyYW5zYWN0aW9uKCkgc2hvdWxkCisJICogdGltZSBvdXQgJiB0aGVyZWZvcmUgcmV0 dXJuIGFuIGVycm9yLgorCSAqIEhpdHRpbmcgdGhpcyBjaGVjayBpcyBoaWdobHkgdW5saWtlbHkg YXQgcHJlc2VudCwgYnV0IGlmIHRoZSBzeXN0ZW0KKwkgKiBjb250cm9sbGVyJ3MgYmVoYXZpb3Vy IGNoYW5nZXMgc28gdGhhdCBpdCBkb2VzIGdlbmVyYXRlIGludGVycnVwdHMKKwkgKiBmb3IgZmFp bGVkIHNlcnZpY2VzLCBpdCB3aWxsIGJlIHJlcXVpcmVkLgorCSAqLworCWlmIChyZXNwb25zZS0+ cmVzcF9zdGF0dXMpCisJCXJldHVybiAtRUlPOworCisJLyoKKwkgKiBCaXQgNSBvZiBieXRlIDEg aXMgIlVMX0F1dG8gVXBkYXRlIiAmIGlmIGl0IGlzIHNldCwgQXV0byBVcGRhdGUgaXMKKwkgKiBu b3QgcG9zc2libGUuCisJICovCisJaWYgKHJlc3BvbnNlX21zZ1sxXSAmIEFVVE9fVVBEQVRFX0ZF QVRVUkVfRU5BQkxFRCkKKwkJcmV0dXJuIC1FUEVSTTsKKworCXJldHVybiAwOworfQorCitzdGF0 aWMgaW50IG1wZnNfYXV0b191cGRhdGVfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRl dikKK3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ZGV2OworCXN0cnVjdCBtcGZzX2F1 dG9fdXBkYXRlX3ByaXYgKnByaXY7CisJc3RydWN0IGZ3X3VwbG9hZCAqZndfdXBsb2FkZXI7CisJ aW50IHJldDsKKworCXByaXYgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKnByaXYpLCBHRlBf S0VSTkVMKTsKKwlpZiAoIXByaXYpCisJCXJldHVybiAtRU5PTUVNOworCisJcHJpdi0+c3lzX2Nv bnRyb2xsZXIgPSBtcGZzX3N5c19jb250cm9sbGVyX2dldChkZXYpOworCWlmIChJU19FUlIocHJp di0+c3lzX2NvbnRyb2xsZXIpKQorCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShkZXYsIFBUUl9FUlIo cHJpdi0+c3lzX2NvbnRyb2xsZXIpLAorCQkJCSAgICAgIkNvdWxkIG5vdCByZWdpc3RlciBhcyBh IHN1YiBkZXZpY2Ugb2YgdGhlIHN5c3RlbSBjb250cm9sbGVyXG4iKTsKKworCXByaXYtPmRldiA9 IGRldjsKKwlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBwcml2KTsKKworCXJldCA9IG1wZnNf YXV0b191cGRhdGVfYXZhaWxhYmxlKHByaXYpOworCWlmIChyZXQpCisJCXJldHVybiBkZXZfZXJy X3Byb2JlKGRldiwgcmV0LAorCQkJCSAgICAgIlRoZSBjdXJyZW50IGJpdHN0cmVhbSBkb2VzIG5v dCBzdXBwb3J0IGF1dG8tdXBkYXRlXG4iKTsKKworCWluaXRfY29tcGxldGlvbigmcHJpdi0+cHJv Z3JhbW1pbmdfY29tcGxldGUpOworCisJZndfdXBsb2FkZXIgPSBmaXJtd2FyZV91cGxvYWRfcmVn aXN0ZXIoVEhJU19NT0RVTEUsIGRldiwgIm1wZnMtYXV0by11cGRhdGUiLAorCQkJCQkgICAgICAg Jm1wZnNfYXV0b191cGRhdGVfb3BzLCBwcml2KTsKKwlpZiAoSVNfRVJSKGZ3X3VwbG9hZGVyKSkK KwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoZGV2LCBQVFJfRVJSKGZ3X3VwbG9hZGVyKSwKKwkJCQkg ICAgICJGYWlsZWQgdG8gcmVnaXN0ZXIgdGhlIGJpdHN0cmVhbSB1cGxvYWRlclxuIik7CisKKwlw cml2LT5md191cGxvYWRlciA9IGZ3X3VwbG9hZGVyOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRp YyB2b2lkIG1wZnNfYXV0b191cGRhdGVfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBk ZXYpCit7CisJc3RydWN0IG1wZnNfYXV0b191cGRhdGVfcHJpdiAqcHJpdiA9IHBsYXRmb3JtX2dl dF9kcnZkYXRhKHBkZXYpOworCisJZmlybXdhcmVfdXBsb2FkX3VucmVnaXN0ZXIocHJpdi0+Zndf dXBsb2FkZXIpOworfQorCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBtcGZzX2F1dG9f dXBkYXRlX2RyaXZlciA9IHsKKwkuZHJpdmVyID0geworCQkubmFtZSA9ICJtcGZzLWF1dG8tdXBk YXRlIiwKKwl9LAorCS5wcm9iZSA9IG1wZnNfYXV0b191cGRhdGVfcHJvYmUsCisJLnJlbW92ZV9u ZXcgPSBtcGZzX2F1dG9fdXBkYXRlX3JlbW92ZSwKK307Cittb2R1bGVfcGxhdGZvcm1fZHJpdmVy KG1wZnNfYXV0b191cGRhdGVfZHJpdmVyKTsKKworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9E VUxFX0FVVEhPUigiQ29ub3IgRG9vbGV5IDxjb25vci5kb29sZXlAbWljcm9jaGlwLmNvbT4iKTsK K01PRFVMRV9ERVNDUklQVElPTigiUG9sYXJGaXJlIFNvQyBBdXRvIFVwZGF0ZSBGUEdBIHJlcHJv Z3JhbW1pbmciKTsKLS0gCjIuMzkuMgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fCmxpbnV4LXJpc2N2IG1haWxpbmcgbGlzdApsaW51eC1yaXNjdkBsaXN0 cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGlu Zm8vbGludXgtcmlzY3YK 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 smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 CF450C001DF for ; Fri, 20 Oct 2023 13:19:39 +0000 (UTC) Received: by smtp.kernel.org (Postfix) id 8E299C433C8; Fri, 20 Oct 2023 13:19:39 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6BCAAC433CD; Fri, 20 Oct 2023 13:19:36 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1697807979; bh=KyvRKjuZbIzW96MYXWomBp5JSUyvdeq+e4kdZAAGY28=; h=From:List-Id:To:Cc:Subject:Date:In-Reply-To:References:From; b=aJbVndt61mMfOR+16ofqHv/wGeQHNoA5I8xepzJ1cJ5tPuWnGSaYYXja4Znh1iKxY ROJV8Cu4xWoO8S7X+1u7r5bmXSWuW5ZyWbQeFTncpOde437OZTXJSTwh6ZjXeQwQJe t6yzGrNPG7/GaurbVeBpk2qazv/mZFxYN99I8UbYBu9nNGqEzVb/fYTo0Z5pOHNcvV FxZzTpImgEY8YRGrl4fypmJsj9cKgWaAkeWUMhz0p1aqfYleTgrjrlww85c4UH5G3T 60W9X1dpLhQp4jXkug7K6+vT2zttUwHtnx+pd/O7k/xN9HINLsoWwaacm6weK+VeLE E8ZdzfxiYY0Rg== From: Conor Dooley List-Id: To: soc@kernel.org Cc: conor@kernel.org, Conor Dooley , Arnd Bergmann , Daire McNamara , Rob Herring , Krzysztof Kozlowski , Moritz Fischer , Wu Hao , Xu Yilun , Tom Rix , Russ Weight , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-fpga@vger.kernel.org Subject: [PATCH v3 5/6] firmware: microchip: add PolarFire SoC Auto Update support Date: Fri, 20 Oct 2023 14:18:43 +0100 Message-Id: <20231020-series-uncooked-077b107af3ae@spud> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20231020-agreeably-filing-3d48708e6262@spud> References: <20231020-agreeably-filing-3d48708e6262@spud> MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=20165; i=conor.dooley@microchip.com; h=from:subject:message-id; bh=IUxB212bhJw2GUh3upA8XEBjT8HzAbuMhcRm4E4G/Ok=; b=owGbwMvMwCFWscWwfUFT0iXG02pJDKlGdbouMWWhX/RZjU+G39tgL5e70nunoc+Rf9q7Ne8nz ZGcnezQUcrCIMbBICumyJJ4u69Fav0flx3OPW9h5rAygQxh4OIUgIls7mZkuLxAb3mezbxE83nf hQo/yi1SaFudp1CcvTkw8uCOlKfqTAz/9PjN5AMKDwZHLZfn8hM0OCim/X2C3KyIiekKcTk+6/i YAA== X-Developer-Key: i=conor.dooley@microchip.com; a=openpgp; fpr=F9ECA03CF54F12CD01F1655722E2C55B37CF380C Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit From: Conor Dooley Add support for Auto Update reprogramming of the FPGA fabric on PolarFire SoC, using the fw_upload mechanism a la the intel-m10-bmc-sec-update driver. This driver only writes the image to the spi flash & performs validation on it, as the entire FPGA becomes unusable during the actual reprogramming of a bitstream. To initiate the reprogramming itself, a device reset is required. The SBI SRST extension's "cold reboot" can trigger such a device reset, provided corresponding support has been enabled in the HSS (Hart Software Services), the provider of SBI runtime services on PolarFire SoC. While this is a driver responsible for the reprogramming of an FPGA, there is no dynamic discovery of devices involved, as runtime reconfiguration is not possible due to the device reset requirements. Therefore FPGA manager subsystem is not used by this driver and the FPGA subsystem maintainers were unwilling to accept it there. Signed-off-by: Conor Dooley --- drivers/firmware/Kconfig | 1 + drivers/firmware/Makefile | 1 + drivers/firmware/microchip/Kconfig | 12 + drivers/firmware/microchip/Makefile | 3 + drivers/firmware/microchip/mpfs-auto-update.c | 494 ++++++++++++++++++ 5 files changed, 511 insertions(+) create mode 100644 drivers/firmware/microchip/Kconfig create mode 100644 drivers/firmware/microchip/Makefile create mode 100644 drivers/firmware/microchip/mpfs-auto-update.c diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig index b59e3041fd62..f247ac33c75b 100644 --- a/drivers/firmware/Kconfig +++ b/drivers/firmware/Kconfig @@ -310,6 +310,7 @@ source "drivers/firmware/google/Kconfig" source "drivers/firmware/efi/Kconfig" source "drivers/firmware/imx/Kconfig" source "drivers/firmware/meson/Kconfig" +source "drivers/firmware/microchip/Kconfig" source "drivers/firmware/psci/Kconfig" source "drivers/firmware/smccc/Kconfig" source "drivers/firmware/tegra/Kconfig" diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile index 28fcddcd688f..901771d2bd47 100644 --- a/drivers/firmware/Makefile +++ b/drivers/firmware/Makefile @@ -31,6 +31,7 @@ obj-y += arm_scmi/ obj-y += broadcom/ obj-y += cirrus/ obj-y += meson/ +obj-y += microchip/ obj-$(CONFIG_GOOGLE_FIRMWARE) += google/ obj-y += efi/ obj-y += imx/ diff --git a/drivers/firmware/microchip/Kconfig b/drivers/firmware/microchip/Kconfig new file mode 100644 index 000000000000..434b923e08c2 --- /dev/null +++ b/drivers/firmware/microchip/Kconfig @@ -0,0 +1,12 @@ +# SPDX-License-Identifier: GPL-2.0-only + +config POLARFIRE_SOC_AUTO_UPDATE + tristate "Microchip PolarFire SoC AUTO UPDATE" + depends on POLARFIRE_SOC_SYS_CTRL + select FW_LOADER + select FW_UPLOAD + help + Support for reprogramming PolarFire SoC from within Linux, using the + Auto Upgrade feature of the system controller. + + If built as a module, it will be called mpfs-auto-update. diff --git a/drivers/firmware/microchip/Makefile b/drivers/firmware/microchip/Makefile new file mode 100644 index 000000000000..38796fd82893 --- /dev/null +++ b/drivers/firmware/microchip/Makefile @@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-$(CONFIG_POLARFIRE_SOC_AUTO_UPDATE) += mpfs-auto-update.o diff --git a/drivers/firmware/microchip/mpfs-auto-update.c b/drivers/firmware/microchip/mpfs-auto-update.c new file mode 100644 index 000000000000..a37aa8456e94 --- /dev/null +++ b/drivers/firmware/microchip/mpfs-auto-update.c @@ -0,0 +1,494 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Microchip Polarfire SoC "Auto Update" FPGA reprogramming. + * + * Documentation of this functionality is available in the "PolarFire® FPGA and + * PolarFire SoC FPGA Programming" User Guide. + * + * Copyright (c) 2022-2023 Microchip Corporation. All rights reserved. + * + * Author: Conor Dooley + */ +#include +#include +#include +#include +#include +#include +#include + +#include + +#define AUTO_UPDATE_DEFAULT_MBOX_OFFSET 0u +#define AUTO_UPDATE_DEFAULT_RESP_OFFSET 0u + +#define AUTO_UPDATE_FEATURE_CMD_OPCODE 0x05u +#define AUTO_UPDATE_FEATURE_CMD_DATA_SIZE 0u +#define AUTO_UPDATE_FEATURE_RESP_SIZE 33u +#define AUTO_UPDATE_FEATURE_CMD_DATA NULL +#define AUTO_UPDATE_FEATURE_ENABLED BIT(5) + +#define AUTO_UPDATE_AUTHENTICATE_CMD_OPCODE 0x22u +#define AUTO_UPDATE_AUTHENTICATE_CMD_DATA_SIZE 0u +#define AUTO_UPDATE_AUTHENTICATE_RESP_SIZE 1u +#define AUTO_UPDATE_AUTHENTICATE_CMD_DATA NULL + +#define AUTO_UPDATE_PROGRAM_CMD_OPCODE 0x46u +#define AUTO_UPDATE_PROGRAM_CMD_DATA_SIZE 0u +#define AUTO_UPDATE_PROGRAM_RESP_SIZE 1u +#define AUTO_UPDATE_PROGRAM_CMD_DATA NULL + +/* + * SPI Flash layout example: + * |------------------------------| 0x0000000 + * | 1 KiB | + * | SPI "directories" | + * |------------------------------| 0x0000400 + * | 1 MiB | + * | Reserved area | + * | Used for bitstream info | + * |------------------------------| 0x0100400 + * | 20 MiB | + * | Golden Image | + * |------------------------------| 0x1500400 + * | 20 MiB | + * | Auto Upgrade Image | + * |------------------------------| 0x2900400 + * | 20 MiB | + * | Reserved for multi-image IAP | + * | Unused for Auto Upgrade | + * |------------------------------| 0x3D00400 + * | ? B | + * | Unused | + * |------------------------------| 0x? + */ +#define AUTO_UPDATE_DIRECTORY_BASE 0u +#define AUTO_UPDATE_DIRECTORY_WIDTH 4u +#define AUTO_UPDATE_GOLDEN_INDEX 0u +#define AUTO_UPDATE_UPGRADE_INDEX 1u +#define AUTO_UPDATE_BLANK_INDEX 2u +#define AUTO_UPDATE_GOLDEN_DIRECTORY (AUTO_UPDATE_DIRECTORY_WIDTH * AUTO_UPDATE_GOLDEN_INDEX) +#define AUTO_UPDATE_UPGRADE_DIRECTORY (AUTO_UPDATE_DIRECTORY_WIDTH * AUTO_UPDATE_UPGRADE_INDEX) +#define AUTO_UPDATE_BLANK_DIRECTORY (AUTO_UPDATE_DIRECTORY_WIDTH * AUTO_UPDATE_BLANK_INDEX) +#define AUTO_UPDATE_DIRECTORY_SIZE SZ_1K +#define AUTO_UPDATE_RESERVED_SIZE SZ_1M +#define AUTO_UPDATE_BITSTREAM_BASE (AUTO_UPDATE_DIRECTORY_SIZE + AUTO_UPDATE_RESERVED_SIZE) + +#define AUTO_UPDATE_TIMEOUT_MS 60000 + +struct mpfs_auto_update_priv { + struct mpfs_sys_controller *sys_controller; + struct device *dev; + struct mtd_info *flash; + struct fw_upload *fw_uploader; + struct completion programming_complete; + size_t size_per_bitstream; + bool cancel_request; +}; + +static enum fw_upload_err mpfs_auto_update_prepare(struct fw_upload *fw_uploader, const u8 *data, + u32 size) +{ + struct mpfs_auto_update_priv *priv = fw_uploader->dd_handle; + size_t erase_size = AUTO_UPDATE_DIRECTORY_SIZE; + + /* + * Verifying the Golden Image is idealistic. It will be evaluated + * against the currently programmed image and thus may fail - due to + * either rollback protection (if its an older version than that in use) + * or if the version is the same as that of the in-use image. + * Extracting the information as to why a failure occurred is not + * currently possible due to limitations of the system controller + * driver. If those are fixed, verification of the Golden Image should + * be added here. + */ + + priv->flash = mpfs_sys_controller_get_flash(priv->sys_controller); + if (!priv->flash) + return FW_UPLOAD_ERR_HW_ERROR; + + erase_size = round_up(erase_size, (u64)priv->flash->erasesize); + + /* + * We need to calculate if we have enough space in the flash for the + * new image. + * First, chop off the first 1 KiB as it's reserved for the directory. + * The 1 MiB reserved for design info needs to be ignored also. + * All that remains is carved into 3 & rounded down to the erasesize. + * If this is smaller than the image size, we abort. + * There's also no need to consume more than 20 MiB per image. + */ + priv->size_per_bitstream = priv->flash->size - SZ_1K - SZ_1M; + priv->size_per_bitstream = round_down(priv->size_per_bitstream / 3, erase_size); + if (priv->size_per_bitstream > 20 * SZ_1M) + priv->size_per_bitstream = 20 * SZ_1M; + + if (priv->size_per_bitstream < size) { + dev_err(priv->dev, + "flash device has insufficient capacity to store this bitstream\n"); + return FW_UPLOAD_ERR_INVALID_SIZE; + } + + priv->cancel_request = false; + + return FW_UPLOAD_ERR_NONE; +} + +static void mpfs_auto_update_cancel(struct fw_upload *fw_uploader) +{ + struct mpfs_auto_update_priv *priv = fw_uploader->dd_handle; + + priv->cancel_request = true; +} + +static enum fw_upload_err mpfs_auto_update_poll_complete(struct fw_upload *fw_uploader) +{ + struct mpfs_auto_update_priv *priv = fw_uploader->dd_handle; + int ret; + + /* + * There is no meaningful way to get the status of the programming while + * it is in progress, so attempting anything other than waiting for it + * to complete would be misplaced. + */ + ret = wait_for_completion_timeout(&priv->programming_complete, + msecs_to_jiffies(AUTO_UPDATE_TIMEOUT_MS)); + if (ret) + return FW_UPLOAD_ERR_TIMEOUT; + + return FW_UPLOAD_ERR_NONE; +} + +static int mpfs_auto_update_verify_image(struct fw_upload *fw_uploader) +{ + struct mpfs_auto_update_priv *priv = fw_uploader->dd_handle; + struct mpfs_mss_response *response; + struct mpfs_mss_msg *message; + u32 *response_msg; + int ret; + + response_msg = devm_kzalloc(priv->dev, AUTO_UPDATE_FEATURE_RESP_SIZE * sizeof(response_msg), + GFP_KERNEL); + if (!response_msg) + return -ENOMEM; + + response = devm_kzalloc(priv->dev, sizeof(struct mpfs_mss_response), GFP_KERNEL); + if (!response) { + ret = -ENOMEM; + goto free_response_msg; + } + + message = devm_kzalloc(priv->dev, sizeof(struct mpfs_mss_msg), GFP_KERNEL); + if (!message) { + ret = -ENOMEM; + goto free_response; + } + + /* + * The system controller can verify that an image in the flash is valid. + * Rather than duplicate the check in this driver, call the relevant + * service from the system controller instead. + * This service has no command data and no response data. It overloads + * mbox_offset with the image index in the flash's SPI directory where + * the bitstream is located. + */ + response->resp_msg = response_msg; + response->resp_size = AUTO_UPDATE_AUTHENTICATE_RESP_SIZE; + message->cmd_opcode = AUTO_UPDATE_AUTHENTICATE_CMD_OPCODE; + message->cmd_data_size = AUTO_UPDATE_AUTHENTICATE_CMD_DATA_SIZE; + message->response = response; + message->cmd_data = AUTO_UPDATE_AUTHENTICATE_CMD_DATA; + message->mbox_offset = AUTO_UPDATE_UPGRADE_INDEX; + message->resp_offset = AUTO_UPDATE_DEFAULT_RESP_OFFSET; + + dev_info(priv->dev, "Running verification of Upgrade Image\n"); + ret = mpfs_blocking_transaction(priv->sys_controller, message); + if (ret | response->resp_status) { + dev_warn(priv->dev, "Verification of Upgrade Image failed!\n"); + ret = ret ? ret : -EBADMSG; + } + + dev_info(priv->dev, "Verification of Upgrade Image passed!\n"); + + devm_kfree(priv->dev, message); +free_response: + devm_kfree(priv->dev, response); +free_response_msg: + devm_kfree(priv->dev, response_msg); + + return ret; +} + +static int mpfs_auto_update_set_image_address(struct mpfs_auto_update_priv *priv, char *buffer, + u32 image_address, loff_t directory_address) +{ + struct erase_info erase; + size_t erase_size = AUTO_UPDATE_DIRECTORY_SIZE; + size_t bytes_written = 0, bytes_read = 0; + int ret; + + erase_size = round_up(erase_size, (u64)priv->flash->erasesize); + + erase.addr = AUTO_UPDATE_DIRECTORY_BASE; + erase.len = erase_size; + + /* + * We need to write the "SPI DIRECTORY" to the first 1 KiB, telling + * the system controller where to find the actual bitstream. Since + * this is spi-nor, we have to read the first eraseblock, erase that + * portion of the flash, modify the data and then write it back. + * There's no need to do this though if things are already the way they + * should be, so check and save the write in that case. + */ + ret = mtd_read(priv->flash, AUTO_UPDATE_DIRECTORY_BASE, erase_size, &bytes_read, + (u_char *)buffer); + if (ret) + return ret; + + if (bytes_read != erase_size) + return -EIO; + + if ((*(u32 *)(buffer + AUTO_UPDATE_UPGRADE_DIRECTORY) == image_address) && + !(*(u32 *)(buffer + AUTO_UPDATE_BLANK_DIRECTORY))) + return 0; + + ret = mtd_erase(priv->flash, &erase); + if (ret) + return ret; + + /* + * Populate the image address and then zero out the next directory so + * that the system controller doesn't complain if in "Single Image" + * mode. + */ + memcpy(buffer + AUTO_UPDATE_UPGRADE_DIRECTORY, &image_address, + AUTO_UPDATE_DIRECTORY_WIDTH); + memset(buffer + AUTO_UPDATE_BLANK_DIRECTORY, 0x0, AUTO_UPDATE_DIRECTORY_WIDTH); + + dev_info(priv->dev, "Writing the image address (%x) to the flash directory (%llx)\n", + image_address, directory_address); + + ret = mtd_write(priv->flash, 0x0, erase_size, &bytes_written, (u_char *)buffer); + if (ret) + return ret; + + if (bytes_written != erase_size) + return ret; + + return 0; +} + +static int mpfs_auto_update_write_bitstream(struct fw_upload *fw_uploader, const u8 *data, + u32 offset, u32 size, u32 *written) +{ + struct mpfs_auto_update_priv *priv = fw_uploader->dd_handle; + struct erase_info erase; + char *buffer; + loff_t directory_address = AUTO_UPDATE_UPGRADE_DIRECTORY; + size_t erase_size = AUTO_UPDATE_DIRECTORY_SIZE; + size_t bytes_written = 0; + u32 image_address; + int ret; + + erase_size = round_up(erase_size, (u64)priv->flash->erasesize); + + image_address = AUTO_UPDATE_BITSTREAM_BASE + + AUTO_UPDATE_UPGRADE_INDEX * priv->size_per_bitstream; + + buffer = devm_kzalloc(priv->dev, erase_size, GFP_KERNEL); + if (!buffer) + return -ENOMEM; + + ret = mpfs_auto_update_set_image_address(priv, buffer, image_address, directory_address); + if (ret) { + dev_err(priv->dev, "failed to set image address in the SPI directory: %d\n", ret); + goto out; + } + + /* + * Now the .spi image itself can be written to the flash. Preservation + * of contents here is not important here, unlike the spi "directory" + * which must be RMWed. + */ + erase.len = round_up(size, (size_t)priv->flash->erasesize); + erase.addr = image_address; + + dev_info(priv->dev, "Erasing the flash at address (%x)\n", image_address); + ret = mtd_erase(priv->flash, &erase); + if (ret) + goto out; + + /* + * No parsing etc of the bitstream is required. The system controller + * will do all of that itself - including verifying that the bitstream + * is valid. + */ + dev_info(priv->dev, "Writing the image to the flash at address (%x)\n", image_address); + ret = mtd_write(priv->flash, (loff_t)image_address, size, &bytes_written, data); + if (ret) + goto out; + + if (bytes_written != size) { + ret = -EIO; + goto out; + } + + *written = bytes_written; + +out: + devm_kfree(priv->dev, buffer); + return ret; +} + +static enum fw_upload_err mpfs_auto_update_write(struct fw_upload *fw_uploader, const u8 *data, + u32 offset, u32 size, u32 *written) +{ + struct mpfs_auto_update_priv *priv = fw_uploader->dd_handle; + enum fw_upload_err err = FW_UPLOAD_ERR_NONE; + int ret; + + reinit_completion(&priv->programming_complete); + + ret = mpfs_auto_update_write_bitstream(fw_uploader, data, offset, size, written); + if (ret) { + err = FW_UPLOAD_ERR_RW_ERROR; + goto out; + } + + if (priv->cancel_request) { + err = FW_UPLOAD_ERR_CANCELED; + goto out; + } + + ret = mpfs_auto_update_verify_image(fw_uploader); + if (ret) + err = FW_UPLOAD_ERR_HW_ERROR; + +out: + complete(&priv->programming_complete); + + return err; +} + +static const struct fw_upload_ops mpfs_auto_update_ops = { + .prepare = mpfs_auto_update_prepare, + .write = mpfs_auto_update_write, + .poll_complete = mpfs_auto_update_poll_complete, + .cancel = mpfs_auto_update_cancel, +}; + +static int mpfs_auto_update_available(struct mpfs_auto_update_priv *priv) +{ + struct mpfs_mss_response *response; + struct mpfs_mss_msg *message; + u32 *response_msg; + int ret; + + response_msg = devm_kzalloc(priv->dev, AUTO_UPDATE_FEATURE_RESP_SIZE * sizeof(response_msg), + GFP_KERNEL); + if (!response_msg) + return -ENOMEM; + + response = devm_kzalloc(priv->dev, sizeof(struct mpfs_mss_response), GFP_KERNEL); + if (!response) + return -ENOMEM; + + message = devm_kzalloc(priv->dev, sizeof(struct mpfs_mss_msg), GFP_KERNEL); + if (!message) + return -ENOMEM; + + /* + * To verify that Auto Update is possible, the "Query Security Service + * Request" is performed. + * This service has no command data & does not overload mbox_offset. + */ + response->resp_msg = response_msg; + response->resp_size = AUTO_UPDATE_FEATURE_RESP_SIZE; + message->cmd_opcode = AUTO_UPDATE_FEATURE_CMD_OPCODE; + message->cmd_data_size = AUTO_UPDATE_FEATURE_CMD_DATA_SIZE; + message->response = response; + message->cmd_data = AUTO_UPDATE_FEATURE_CMD_DATA; + message->mbox_offset = AUTO_UPDATE_DEFAULT_MBOX_OFFSET; + message->resp_offset = AUTO_UPDATE_DEFAULT_RESP_OFFSET; + + ret = mpfs_blocking_transaction(priv->sys_controller, message); + if (ret) + return ret; + + /* + * Currently, the system controller's firmware does not generate any + * interrupts for failed services, so mpfs_blocking_transaction() should + * time out & therefore return an error. + * Hitting this check is highly unlikely at present, but if the system + * controller's behaviour changes so that it does generate interrupts + * for failed services, it will be required. + */ + if (response->resp_status) + return -EIO; + + /* + * Bit 5 of byte 1 is "UL_Auto Update" & if it is set, Auto Update is + * not possible. + */ + if (response_msg[1] & AUTO_UPDATE_FEATURE_ENABLED) + return -EPERM; + + return 0; +} + +static int mpfs_auto_update_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct mpfs_auto_update_priv *priv; + struct fw_upload *fw_uploader; + int ret; + + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + priv->sys_controller = mpfs_sys_controller_get(dev); + if (IS_ERR(priv->sys_controller)) + return dev_err_probe(dev, PTR_ERR(priv->sys_controller), + "Could not register as a sub device of the system controller\n"); + + priv->dev = dev; + platform_set_drvdata(pdev, priv); + + ret = mpfs_auto_update_available(priv); + if (ret) + return dev_err_probe(dev, ret, + "The current bitstream does not support auto-update\n"); + + init_completion(&priv->programming_complete); + + fw_uploader = firmware_upload_register(THIS_MODULE, dev, "mpfs-auto-update", + &mpfs_auto_update_ops, priv); + if (IS_ERR(fw_uploader)) + return dev_err_probe(dev, PTR_ERR(fw_uploader), + "Failed to register the bitstream uploader\n"); + + priv->fw_uploader = fw_uploader; + + return 0; +} + +static void mpfs_auto_update_remove(struct platform_device *pdev) +{ + struct mpfs_auto_update_priv *priv = platform_get_drvdata(pdev); + + firmware_upload_unregister(priv->fw_uploader); +} + +static struct platform_driver mpfs_auto_update_driver = { + .driver = { + .name = "mpfs-auto-update", + }, + .probe = mpfs_auto_update_probe, + .remove_new = mpfs_auto_update_remove, +}; +module_platform_driver(mpfs_auto_update_driver); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Conor Dooley "); +MODULE_DESCRIPTION("PolarFire SoC Auto Update FPGA reprogramming"); -- 2.39.2