From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 380F2606A319 for ; Thu, 22 Oct 2026 05:53:59 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key, unprotected) header.d=lists.infradead.org header.i=@lists.infradead.org header.a=rsa-sha256 header.s=bombadil.20210309 header.b=h82UsO+L; dkim=fail reason="signature verification failed" (2048-bit key, unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=V8FcSFW2 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:MIME-Version:Reply-To:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:Date:References: In-Reply-To:Cc:To:Subject:From:Message-ID:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=Cr3SOa8XZ5xelLpWE/7VZsa5w6ilrvsXLQDUTY3qdjE=; b=h82UsO+L6Wj4z+ hicV2zuaxsUH1uRmTca6Y1Xoai3aM95J6KhNAhjoZIoO6eAc13jHoAse/jUJ6/NoWzeuSf1okC51q clbAf2UDescjJNeT+XHP1bJyBn9kgvqAznMpASU6XkaoIakkvFJKqPmXyl40jv+a9tSk8o/Kxj/eH FiyRtJRPYn2OU1BQLG4MCQES6zGtCzExT4m0iXH90p2Uyheeyqh46d6V1tf94/OsQH/4bH2hGnBDX 5CLeJtJKAX4OhCm3c4tAaDRZfbCdNbx7cMeQgfCx37yeEwNB5dV+4VS5yNP70UfIvpyteVAogBds4 eaaGjUZ4Ij+Q/ZlfDjOA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1xJlkS-0000000DQfO-3yv2; Thu, 22 Oct 2026 05:53:56 +0000 Received: from tor.source.kernel.org ([2600:3c04:e001:324:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1xJlkR-0000000DQfI-3exU for linux-amlogic@lists.infradead.org; Thu, 22 Oct 2026 05:53:55 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id 90CEA60018; Thu, 22 Oct 2026 05:53:54 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0AE181F000C1; Thu, 22 Oct 2026 05:53:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1792648434; bh=1ElKY0kmh0e852o+L2kly0As0zw7JarN4pKMgpjOj1E=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=V8FcSFW2wQJgkXuUlgMnIup8ghcrfZ31+kbaWlTvwaRXwAhkOHqGITLYLQRBHK8qy pSJvH9L8IsrsbVjcQdFYRVjsqf9mC+/jxxlW50u+Z0khtEV+FWPzj+CzK9EgBd47hb cLu7TVRPiwOvibQ8Kl+wX8txX737TpH6iRwGk75+kbxJT5q/VwlrFBxR1S5Q7tNT+B FXfGRWmllFSijw3YygJvriX5vZhA+t3hx4+nr001NzI9lqdDlLK1ElhHUHXQVBx5VL xbB+PrHIrVx2KebiAfInJXSRHceCH5ApYdt+mm5U0/juzslhOXIQZcXeLa4kUmReWj VNsFf6DmIeG1w== Message-ID: From: sashiko-bot@kernel.org Subject: Re: [PATCH v12 6/6] arm64: defconfig: Enable CONFIG_VIDEO_AMLOGIC_VDEC To: "Zhentao Guo" Cc: linux-amlogic@lists.infradead.org, devicetree@vger.kernel.org, robh@kernel.org, conor+dt@kernel.org, neil.armstrong@linaro.org, media-ci@linuxtv.org In-Reply-To: <20261022-b4-s4-vdec-upstream-v12-6-616240978792@amlogic.com> References: <20261022-b4-s4-vdec-upstream-v12-0-616240978792@amlogic.com> <20261022-b4-s4-vdec-upstream-v12-6-616240978792@amlogic.com> Date: Thu, 22 Oct 2026 05:53:53 +0000 X-BeenThere: linux-amlogic@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: sashiko-reviews@lists.linux.dev X-Archived-By: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-amlogic" X-Spam-Status: No, score=-8.9 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_EF,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=4.0.1 X-Spam-Checker-Version: SpamAssassin 4.0.1 (2024-03-26) on aws-us-west-2-korg-listserv-alma10-1 VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg OSBwb3RlbnRpYWwgaXNzdWUocykgdG8gY29uc2lkZXI6Ci0gW0NyaXRpY2FsXSBtZWRpYTogYW1s b2dpYzogdmRlYzogdW5jaGVja2VkIHJlZl9saXN0IGJvdW5kcyBhbmQgY2FudmFzIGxpZmVjeWNs ZSBpbiBoMjY0Ci0gW0hpZ2hdIG1lZGlhOiBhbWxvZ2ljOiB2ZGVjOiBhbWxfdmRlY19pbml0X2Rl Y19pbnN0KCkgcmV0dXJucyAtMSBvbiBvdXRwdXQgcmVzdGFydAotIFtIaWdoXSBtZWRpYTogYW1s b2dpYzogdmRlYzogY2hlY2sgRFBCIGVudHJ5IGZsYWdzIGluIHBvY19pc19pbl9kcGIoKSBhbmQg Z2V0X2RwYl9ieV9wb2MoKQotIFtIaWdoXSBtZWRpYTogYW1sb2dpYzogdmRlYzogb3V0LW9mLWJv dW5kcyBTUFMgd29ya3NwYWNlIHdyaXRlIGluIGgyNjRfY29uZmlnX3BhcmFtcygpCi0gW0hpZ2hd IG1lZGlhOiBhbWxvZ2ljOiB2ZGVjOiBpZ25vcmVkIHBtLWRvbWFpbiBlcnJvciwgdW5lbmFibGVk IGNsaywgZWFybHkgdmRldiByZWcKLSBbSGlnaF0gbWVkaWE6IGFtbG9naWM6IHZkZWM6IHdyb25n IElTX0VSUigpIGNoZWNrIG9uIG1lc29uX3NtX2dldCgpIHJldHVybgotIFtNZWRpdW1dIG1lZGlh OiBhbWxvZ2ljOiB2ZGVjOiB1bmluaXRpYWxpemVkIHBpY19pbmZvLCBwcmVtYXR1cmVzaXplaW1h Z2UgY2FsYywgYW5kIHNwbGl0IGxvY2tzCi0gW01lZGl1bV0gbWVkaWE6IGFtbG9naWM6IHZkZWM6 IG1pc3NpbmcgZXJyb3IgdW53aW5kIGFuZCBwcm9wYWdhdGlvbiBpbiB2ZGVjX3Bvd2Vyb24oKQot IFtMb3ddIG1lZGlhOiBhbWxvZ2ljOiB2ZGVjOiBtaXNzaW5nIHNlbGVjdCBSRUdNQVBfTU1JTyBp biBLY29uZmlnCi0tCgpjb21taXQgMDU0OTFjMWM3MmI4NTA0MGIwNzFiMTUyYjc5YTkwOGQ0MDNk OTVmMApBdXRob3I6IFpoZW50YW8gR3VvIDx6aGVudGFvLmd1b0BhbWxvZ2ljLmNvbT4KCmFybTY0 OiBkZWZjb25maWc6IEVuYWJsZSBDT05GSUdfVklERU9fQU1MT0dJQ19WREVDCgpUaGlzIGNvbW1p dCBlbmFibGVzIHRoZSBBbWxvZ2ljIFY0TDIgc3RhdGVsZXNzIHZpZGVvIGRlY29kZXIgZHJpdmVy CihDT05GSUdfVklERU9fQU1MT0dJQ19WREVDPW0pIGFzIGEgbW9kdWxlIGluIHRoZSBhcm02NCBk ZWZjb25maWcgZm9yCkFtbG9naWMgU29DcyBzdWNoIGFzIHRoZSBTNCAoUzgwNVgyKSBwbGF0Zm9y bS4KCj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQvY29uZmlncy9kZWZjb25maWcgYi9hcmNoL2Fy bTY0L2NvbmZpZ3MvZGVmY29uZmlnCj4gaW5kZXggN2I0OTg1YjI5YjIxYy4uZjAwYzhhNDE4YTQ2 NCAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybTY0L2NvbmZpZ3MvZGVmY29uZmlnCj4gKysrIGIvYXJj aC9hcm02NC9jb25maWdzL2RlZmNvbmZpZwo+IEBAIC05MjksNiArOTI5LDcgQEAgQ09ORklHX1VT Ql9WSURFT19DTEFTUz1tCj4gIENPTkZJR19WNExfUExBVEZPUk1fRFJJVkVSUz15Cj4gIENPTkZJ R19TRFJfUExBVEZPUk1fRFJJVkVSUz15Cj4gIENPTkZJR19WNExfTUVNMk1FTV9EUklWRVJTPXkK PiArQ09ORklHX1ZJREVPX0FNTE9HSUNfVkRFQz1tCgpbU2V2ZXJpdHk6IENyaXRpY2FsXQpDYW4g aDI2NF9jb25maWdfcmVmX2xpc3RzKCkgYW5kIGgyNjRfcmVvcmRlcl9yZWZsaXN0cygpIGluCmRy aXZlcnMvbWVkaWEvcGxhdGZvcm0vYW1sb2dpYy92ZGVjL2gyNjQuYyBvdmVyZmxvdyByZWZfbGlz dDAgYW5kIHJlZl9saXN0MQphbmQgbGVhayBtZXNvbl9jYW52YXMgaW5kaWNlcz8KCkZpcnN0LCBp biBzdHJ1Y3QgYW1sX2gyNjRfY3R4LCByZWZfbGlzdDAgYW5kIHJlZl9saXN0MSBhcmUgc2l6ZWQg dG8KVjRMMl9IMjY0X05VTV9EUEJfRU5UUklFUyArIDEgKDE3IGVsZW1lbnRzKS4gSG93ZXZlciwg aW4KaDI2NF9jb25maWdfcmVmX2xpc3RzKCksIHY0bDJfaDI2NF9pbml0X3JlZmxpc3RfYnVpbGRl cigpIHNldHMKYnVpbGRlci5udW1fdmFsaWQgdXAgdG8gVjRMMl9IMjY0X1JFRl9MSVNUX0xFTiAo MzIpIHdoZW4KVjRMMl9IMjY0X0RFQ09ERV9QQVJBTV9GTEFHX0ZJRUxEX1BJQyBpcyBzZXQgaW4g ZGVjb2RlLT5mbGFncywgYW5kIHBhc3NlcwpidWlsZGVyLm51bV92YWxpZCBhcyBsaXN0X3NpemUg dG8gY29uZmlnX3BfcmVmbGlzdCgpIGFuZCBjb25maWdfYl9yZWZsaXN0KCk6Cgpkcml2ZXJzL21l ZGlhL3BsYXRmb3JtL2FtbG9naWMvdmRlYy9oMjY0LmM6Y29uZmlnX3BfcmVmbGlzdCgpIHsKCWZv ciAoaSA9IDA7IGkgPCBsaXN0X3NpemU7IGkrKykgewoJCWluZGV4ID0gdjRsMl9wMF9yZWZsaXN0 W2ldLmluZGV4OwoJCWgyNjRfY3R4LT5yZWZfbGlzdDBbaV0udXNlZCA9IDE7CgkJLi4uCgl9Cn0K Cldvbid0IGxpc3Rfc2l6ZSA+IDE3IHdyaXRlIHBhc3QgdGhlIGVuZCBvZiByZWZfbGlzdDAgYW5k IHJlZl9saXN0MSBpbgpjb25maWdfcF9yZWZsaXN0KCkgYW5kIGNvbmZpZ19iX3JlZmxpc3QoKSwg YXMgd2VsbCBhcyBpbiB0aGUgbG9vcHMgdXNpbmcKaDI2NF9jdHgtPmxpc3Rfc2l6ZVtdIGluIGgy NjRfY29uZmlnX2RlY29kZV9zcGVjKCksIGdldF9jYW52YXNfaW5kZXgoKSwgYW5kCmgyNjRfcmVs ZWFzZV9kZWNvZGVfc3BlYygpPwoKU2Vjb25kLCB3aGVuIGFsbCAxNiBkcGIgZW50cmllcyBhcmUg YWN0aXZlIGFuZCBudW1fcmVmX2lkeF9seF9hY3RpdmUgaXMgMTYsCnJlb3JkZXJfc2hvcnRfdGVy bSgpIGFuZCByZW9yZGVyX2xvbmdfdGVybSgpIHNoaWZ0IHJlZl9saXN0X3Jlb3JkZXJlZFsxNV0g aW50bwp0aGUgc2VudGluZWwgc2xvdCByZWZfbGlzdF9yZW9yZGVyZWRbMTZdIHdpdGhvdXQgY2xl YXJpbmcgdGhlIHNlbnRpbmVsCmFmdGVyd2FyZDoKCmRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vYW1s b2dpYy92ZGVjL2gyNjQuYzpyZW9yZGVyX3Nob3J0X3Rlcm0oKSB7Cglmb3IgKGNfaWR4ID0gbnVt X3JlZl9pZHhfbHhfYWN0aXZlOyBjX2lkeCA+ICpyZWZfaWR4X2x4OyBjX2lkeC0tKQoJCW1lbWNw eSgmcmVmX2xpc3RfcmVvcmRlcmVkW2NfaWR4XSwgJnJlZl9saXN0X3Jlb3JkZXJlZFtjX2lkeCAt IDFdLAoJCSAgICAgICBzaXplb2Yoc3RydWN0IGgyNjRfZGVjb2RlX2J1Zl9zcGVjKSk7CgkuLi4K CWgyNjRfY3R4LT5saXN0X3NpemVbY3VyX2xpc3RdID0gbnVtX3JlZl9pZHhfbHhfYWN0aXZlOwp9 CgpTaW5jZSBnZXRfcmVmaWR4X2J5X3BpY251bSgpLCBnZXRfc3RfcmVmcGljX2J5X251bSgpLCBh bmQKZ2V0X2x0X3JlZnBpY19ieV9udW0oKSBpdGVyYXRlIHVudGlsIHJlZl9saXN0W2ldLmRwYiBp cyBOVUxMIHdpdGggbm8gdXBwZXIKYm91bmQgb24gaToKCmRyaXZlcnMvbWVkaWEvcGxhdGZvcm0v YW1sb2dpYy92ZGVjL2gyNjQuYzpnZXRfcmVmaWR4X2J5X3BpY251bSgpIHsKCWZvciAoaSA9IDA7 IHJlZl9saXN0W2ldLmRwYjsgaSsrKSB7CgkJaWYgKHBpY19udW0gPT0gcmVmX2xpc3RbaV0uZHBi LT5waWNfbnVtKQoJCQlyZXR1cm4gaTsKCX0KfQoKY2FuIG92ZXJ3cml0aW5nIHJlZl9saXN0WzE2 XS5kcGIgY2F1c2UgdGhlc2UgaGVscGVycyB0byByZWFkIHBhc3QgdGhlIGVuZCBvZgpyZWZfbGlz dDAgYW5kIHJlZl9saXN0MSBvbiBzdWJzZXF1ZW50IHJlb3JkZXJpbmcgY29tbWFuZHM/CgpUaGly ZCwgcmVvcmRlcl9zaG9ydF90ZXJtKCkgYW5kIHJlb3JkZXJfbG9uZ190ZXJtKCkgb3ZlcndyaXRl CmgyNjRfY3R4LT5saXN0X3NpemVbY3VyX2xpc3RdIHdpdGggbnVtX3JlZl9pZHhfbHhfYWN0aXZl LiBJbgpnZXRfY2FudmFzX2luZGV4KCksIGNvbmZpZ19kZWNvZGVfY2FudmFzKCkgaXMgY2FsbGVk IGZvciBldmVyeSBlbnRyeSBiZWxvdwpsaXN0X3NpemUgd2l0aG91dCBjaGVja2luZyBidWYtPnVz ZWQgb3IgYnVmLT52YWxpZCwgd2hpbGUKaDI2NF9yZWxlYXNlX2RlY29kZV9zcGVjKCkgb25seSBj YWxscyByZWxlYXNlX2NhbnZhc19pbmRleCgpIHdoZW4gYnVmLT51c2VkIGlzCm5vbi16ZXJvOgoK ZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9hbWxvZ2ljL3ZkZWMvaDI2NC5jOmdldF9jYW52YXNfaW5k ZXgoKSB7CglpZiAoaDI2NF9jdHgtPmxpc3Rfc2l6ZVswXSA+IDApIHsKCQlmb3IgKGkgPSAwOyBp IDwgaDI2NF9jdHgtPmxpc3Rfc2l6ZVswXTsgaSsrKSB7CgkJCWJ1ZiA9ICZoMjY0X2N0eC0+cmVm X2xpc3QwW2ldOwoJCQlyZXQgPSBjb25maWdfZGVjb2RlX2NhbnZhcyhodywgYnVmLCBoMjY0X2N0 eC0+bWJfd2lkdGgsCgkJCQkJCSAgIGgyNjRfY3R4LT5tYl9oZWlnaHQpOwoJCQkuLi4KCQl9Cgl9 Cn0KCmRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vYW1sb2dpYy92ZGVjL2gyNjQuYzpoMjY0X3JlbGVh c2VfZGVjb2RlX3NwZWMoKSB7CglpZiAoaDI2NF9jdHgtPmxpc3Rfc2l6ZVswXSA+IDApIHsKCQlm b3IgKGkgPSAwOyBpIDwgaDI2NF9jdHgtPmxpc3Rfc2l6ZVswXTsgaSsrKSB7CgkJCWJ1ZiA9ICZo MjY0X2N0eC0+cmVmX2xpc3QwW2ldOwoJCQlidWYtPnZhbGlkID0gMDsKCQkJaWYgKGJ1Zi0+dXNl ZCkgewoJCQkJYnVmLT5kcGIgPSBOVUxMOwoJCQkJcmVsZWFzZV9jYW52YXNfaW5kZXgoaHcsIGJ1 Zik7CgkJCQlidWYtPnVzZWQgPSAwOwoJCQl9CgkJfQoJCWgyNjRfY3R4LT5saXN0X3NpemVbMF0g PSAwOwoJfQp9CgpJZiBudW1fcmVmX2lkeF9seF9hY3RpdmUgaXMgbGFyZ2VyIHRoYW4gdGhlIGlu aXRpYWwgbGlzdF9zaXplLCB3b24ndApnZXRfY2FudmFzX2luZGV4KCkgYWxsb2NhdGUgbWVzb24g Y2FudmFzZXMgZm9yIGVudHJpZXMgd2l0aCBidWYtPnVzZWQgPT0gMAp0aGF0IGgyNjRfcmVsZWFz ZV9kZWNvZGVfc3BlYygpIG5ldmVyIGZyZWVzLCBhbmQgaWYgbnVtX3JlZl9pZHhfbHhfYWN0aXZl IGlzCnNtYWxsZXIsIHdvbid0IGVudHJpZXMgYWJvdmUgdGhlIG5ldyBsaXN0X3NpemUgcmV0YWlu IHN0YWxlIHN0YXRlPwoKW1NldmVyaXR5OiBIaWdoXQpXaGF0IGhhcHBlbnMgaW4gZHJpdmVycy9t ZWRpYS9wbGF0Zm9ybS9hbWxvZ2ljL3ZkZWMvYW1sX3ZkZWMuYyB3aGVuIHRoZSBvdXRwdXQKcXVl dWUgaXMgc3RvcHBlZCBhbmQgcmVzdGFydGVkIHdoaWxlIHRoZSBjYXB0dXJlIHF1ZXVlIHJlbWFp bnMgc3RyZWFtaW5nPwoKV2hlbiBhIGNsaWVudCBzdG9wcyB0aGUgb3V0cHV0IHF1ZXVlIHZpYSB2 YjJvcHNfdmRlY19zdG9wX3N0cmVhbWluZygpIHdoaWxlCmN0eC0+aXNfY2FwX3N0cmVhbW9uIGlz IHN0aWxsIHNldCwgYW1sX3ZkZWNfcmVsZWFzZV9pbnN0YW5jZSgpIGlzIG5vdCBjYWxsZWQKYW5k IGN0eC0+Y29kZWNfcHJpdiByZW1haW5zIG5vbi1OVUxMOgoKZHJpdmVycy9tZWRpYS9wbGF0Zm9y bS9hbWxvZ2ljL3ZkZWMvYW1sX3ZkZWMuYzp2YjJvcHNfdmRlY19zdG9wX3N0cmVhbWluZygpIHsK CWlmICghY3R4LT5pc19vdXRwdXRfc3RyZWFtb24gJiYgIWN0eC0+aXNfY2FwX3N0cmVhbW9uKQoJ CWFtbF92ZGVjX3JlbGVhc2VfaW5zdGFuY2UoY3R4KTsKfQoKV2hlbiB0aGUgb3V0cHV0IHF1ZXVl IGlzIHN1YnNlcXVlbnRseSByZXN0YXJ0ZWQsIHZiMm9wc192ZGVjX3N0YXJ0X3N0cmVhbWluZygp CmNhbGxzIGFtbF92ZGVjX2luaXRfZGVjX2luc3QoKSwgd2hpY2ggaW5pdGlhbGl6ZXMgcmV0IHRv IC0xIGFuZCBza2lwcwpjdHgtPmNvZGVjX29wcy0+aW5pdChjdHgpIGJlY2F1c2UgY3R4LT5jb2Rl Y19wcml2IGlzIGFscmVhZHkgYWxsb2NhdGVkOgoKZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9hbWxv Z2ljL3ZkZWMvYW1sX3ZkZWMuYzphbWxfdmRlY19pbml0X2RlY19pbnN0KCkgewoJaW50IHJldCA9 IC0xOwoJLi4uCglpZiAoY3R4LT5jb2RlY19vcHMtPmluaXQgJiYgIWN0eC0+Y29kZWNfcHJpdikg ewoJCXJldCA9IGN0eC0+Y29kZWNfb3BzLT5pbml0KGN0eCk7CgkJaWYgKHJldCA8IDApCgkJCXJl dHVybiByZXQ7Cgl9CgljdHgtPmN1cnJfZGVjX3R5cGUgPSBmbXRfb3V0LT5jb2RlY190eXBlOwoJ Li4uCglyZXR1cm4gcmV0Owp9CgpCZWNhdXNlIHJldCBzdGF5cyAtMSwgdmIyb3BzX3ZkZWNfc3Rh cnRfc3RyZWFtaW5nKCkgdHJlYXRzIHRoZSBjYWxsIGFzIGEKZmFpbHVyZSwgcmV0dXJucyBhbGwg cXVldWVkIHNvdXJjZSBidWZmZXJzIHZpYSB2NGwyX20ybV9zcmNfYnVmX3JlbW92ZSgpIGFuZAp2 NGwyX20ybV9idWZfZG9uZSgpLCBhbmQgZmFpbHMgVklESU9DX1NUUkVBTU9OIHdpdGggLUVJTlZB TDoKCmRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vYW1sb2dpYy92ZGVjL2FtbF92ZGVjLmM6dmIyb3Bz X3ZkZWNfc3RhcnRfc3RyZWFtaW5nKCkgewoJCWlmIChhbWxfdmRlY19pbml0X2RlY19pbnN0KGN0 eCkgPCAwKSB7CgkJCXdoaWxlICgoc3JjX2J1ZiA9IHY0bDJfbTJtX3NyY19idWZfcmVtb3ZlKGN0 eC0+bTJtX2N0eCkpKQoJCQkJdjRsMl9tMm1fYnVmX2RvbmUoc3JjX2J1ZiwgVkIyX0JVRl9TVEFU RV9RVUVVRUQpOwoJCQlyZXR1cm4gLUVJTlZBTDsKCQl9Cn0KClNob3VsZCByZXQgYmUgaW5pdGlh bGl6ZWQgdG8gMCBpbiBhbWxfdmRlY19pbml0X2RlY19pbnN0KCkgc28gcmVzdGFydGluZyB0aGUK b3V0cHV0IHF1ZXVlIHN1Y2NlZWRzIHdoZW4gY3R4LT5jb2RlY19wcml2IGlzIGFscmVhZHkgcHJl c2VudD8KCltTZXZlcml0eTogSGlnaF0KU2hvdWxkIHBvY19pc19pbl9kcGIoKSBhbmQgZ2V0X2Rw Yl9ieV9wb2MoKSBpbgpkcml2ZXJzL21lZGlhL3BsYXRmb3JtL2FtbG9naWMvdmRlYy9oMjY0LmMg Y2hlY2sgd2hldGhlciBhIGRwYiBlbnRyeSBpcyBhY3RpdmUKYmVmb3JlIG1hdGNoaW5nIHRvcF9m aWVsZF9vcmRlcl9jbnQ/CgpEdXJpbmcgSDI2NF9TTElDRV9IRUFERVJfRE9ORSBoYW5kbGluZyBp bgpoMjY0X3RocmVhZGVkX2lzcl9mdW5jKCktPmgyNjRfY29uZmlnX2RlY29kZV9zcGVjKCktPmNs ZWFyX3VudXNlZF9jb2xfYnVmKCksCnBvY19pc19pbl9kcGIoKSBpcyBjYWxsZWQgdG8gZGVjaWRl IHdoZXRoZXIgdG8gcmVsZWFzZSBjb2xvY2F0ZWRfYnVmIGFuZApjYW52YXNfcG9zIHNsb3RzOgoK ZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9hbWxvZ2ljL3ZkZWMvaDI2NC5jOnBvY19pc19pbl9kcGIo KSB7Cglmb3IgKGkgPSAwOyBpIDwgVjRMMl9IMjY0X05VTV9EUEJfRU5UUklFUzsgaSsrKSB7CgkJ aWYgKHBvYyA9PSBkcGJbaV0udG9wX2ZpZWxkX29yZGVyX2NudCkgewoJCQlyZXQgPSAxOwoJCQli cmVhazsKCQl9Cgl9Cn0KCkJlY2F1c2UgZGVjb2RlLT5kcGIgaGFzIDE2IGZpeGVkIGVudHJpZXMg YW5kIHBvY19pc19pbl9kcGIoKSBkb2VzIG5vdCBjaGVjawpkcGJbaV0uZmxhZ3MgZm9yIFY0TDJf SDI2NF9EUEJfRU5UUllfRkxBR19BQ1RJVkUgKG9yClY0TDJfSDI2NF9EUEJfRU5UUllfRkxBR19W QUxJRCksIGFueSB1bnVzZWQgemVyb2VkIGRwYiBlbnRyeSBoYXMKdG9wX2ZpZWxkX29yZGVyX2Nu dCA9PSAwLCBjYXVzaW5nIHBvY19pc19pbl9kcGIoMCwgZGVjb2RlLT5kcGIpIHRvIGFsd2F5cwpy ZXR1cm4gMSBhbmQgbGVhayB0aGUgY29sb2NhdGVkX2J1ZiBhbmQgY2FudmFzX3BvcyBzbG90cyBm b3IgcG9jIDAgaW4KY2xlYXJfdW51c2VkX2NvbF9idWYoKToKCmRyaXZlcnMvbWVkaWEvcGxhdGZv cm0vYW1sb2dpYy92ZGVjL2gyNjQuYzpjbGVhcl91bnVzZWRfY29sX2J1ZigpIHsKCWZvciAoaSA9 IDA7IGkgPCBoMjY0X2N0eC0+Y29sb2NhdGVkX2J1Zl9udW07IGkrKykgewoJCWlmICghKChoMjY0 X2N0eC0+Y29sb2NhdGVkX2J1Zl9tYXAgPj4gaSkgJiAweDEpKQoJCQljb250aW51ZTsKCQljb2xf cG9jID0gaDI2NF9jdHgtPmNvbG9jYXRlZF9idWZfcG9jW2ldOwoJCWlmIChwb2NfaXNfaW5fZHBi KGNvbF9wb2MsIGRlY29kZS0+ZHBiKSAhPSAxKQoJCQlyZWxlYXNlX2NvbG9jYXRlX2J1ZihoMjY0 X2N0eCwgaSk7Cgl9CgoJZm9yIChpID0gMDsgaSA8IChWNEwyX0gyNjRfTlVNX0RQQl9FTlRSSUVT ICsgMSk7IGkrKykgewoJCWlmICghKChoMjY0X2N0eC0+Y2FudmFzX3Bvc19tYXAgPj4gaSkgJiAw eDEpKQoJCQljb250aW51ZTsKCQljb2xfcG9jID0gaDI2NF9jdHgtPnJlZl9jYW52YXNbaV0ucG9j OwoJCWlmIChwb2NfaXNfaW5fZHBiKGNvbF9wb2MsIGRlY29kZS0+ZHBiKSAhPSAxKQoJCQlyZWxl YXNlX2NhbnZhc19wb3MoaDI2NF9jdHgsIGkpOwoJfQp9CgpTaW1pbGFybHksIGlmIHVzZXJzcGFj ZSBjbGVhcnMgZmxhZ3Mgb24gcmV0aXJlZCBkcGIgZW50cmllcyB3aXRob3V0IHplcm9pbmcKdG9w X2ZpZWxkX29yZGVyX2NudCwgdGhlaXIgY29sb2NhdGVkX2J1ZiBhbmQgY2FudmFzX3BvcyBzbG90 cyBhcmUgbmV2ZXIgZnJlZWQKdW50aWwgYWxsIHNsb3RzIGFyZSBleGhhdXN0ZWQuCgpJbiBhZGRp dGlvbiwgaDI2NF9jb25maWdfZGVjb2RlX2J1ZigpIGxvb2tzIHVwIHJlZmVyZW5jZSBlbnRyaWVz IHdpdGgKZ2V0X2RwYl9ieV9wb2MoKToKCmRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vYW1sb2dpYy92 ZGVjL2gyNjQuYzpnZXRfZHBiX2J5X3BvYygpIHsKCWZvciAoaSA9IDA7IGkgPCBWNEwyX0gyNjRf TlVNX0RQQl9FTlRSSUVTOyBpKyspIHsKCQlpZiAoZGVjb2RlLT5kcGJbaV0udG9wX2ZpZWxkX29y ZGVyX2NudCA9PSBwb2MpCgkJCXJldHVybiAmZGVjb2RlLT5kcGJbaV07Cgl9CglyZXR1cm4gTlVM TDsKfQoKZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9hbWxvZ2ljL3ZkZWMvaDI2NC5jOmgyNjRfY29u ZmlnX2RlY29kZV9idWYoKSB7CgkJCWRwYiA9IGdldF9kcGJfYnlfcG9jKGRlY29kZSwgcG9jKTsK CQkJaWYgKGRwYiAmJiAoZHBiLT5mbGFncyAmIFY0TDJfSDI2NF9EUEJfRU5UUllfRkxBR19BQ1RJ VkUpKSB7Cn0KCklmIGFuIGVhcmxpZXIgaW5hY3RpdmUgZHBiIHNsb3QgaGFzIHRoZSBzYW1lIHRv cF9maWVsZF9vcmRlcl9jbnQgYXMgYSBsYXRlcgphY3RpdmUgZHBiIHNsb3QgKGZvciBpbnN0YW5j ZSwgYW4gdW51c2VkIHplcm9lZCBzbG90IGJlZm9yZSBhbiBhY3RpdmUgcG9jIDAKZW50cnkpLCB3 b24ndCBnZXRfZHBiX2J5X3BvYygpIHJldHVybiB0aGUgaW5hY3RpdmUgc2xvdCBhbmQgY2F1c2UK aDI2NF9jb25maWdfZGVjb2RlX2J1ZigpIHRvIHNraXAgd3JpdGluZyB0aGUgYWN0aXZlIHJlZmVy ZW5jZSBmcmFtZSdzIGluZm8KaW50byBIMjY0X0JVRkZFUl9JTkZPX0RBVEE/CgpbU2V2ZXJpdHk6 IEhpZ2hdCkNhbiBhIHVzZXJzcGFjZSBWNEwyX0NJRF9TVEFURUxFU1NfSDI2NF9TUFMgY29udHJv bCB3aXRoCnNwcy0+c2VxX3BhcmFtZXRlcl9zZXRfaWQgPj0gMzIgY2F1c2UgYW4gb3V0LW9mLWJv dW5kcyB3cml0ZSBpbgpoMjY0X2NvbmZpZ19wYXJhbXMoKSBpbiBkcml2ZXJzL21lZGlhL3BsYXRm b3JtL2FtbG9naWMvdmRlYy9oMjY0LmM/CgpJbiBkcml2ZXJzL21lZGlhL3Y0bDItY29yZS92NGwy LWN0cmxzLWNvcmUuYywgc3RkX3ZhbGlkYXRlX2NvbXBvdW5kKCkgZG9lcyBub3QKdmFsaWRhdGUg dGhhdCBwX2gyNjRfc3BzLT5zZXFfcGFyYW1ldGVyX3NldF9pZCBpcyB3aXRoaW4gMC4uMzEsIGFu ZAphbWxfdmRlY19jdHJsc19zZXR1cCgpIGluIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vYW1sb2dp Yy92ZGVjL2FtbF92ZGVjLmMgZG9lcwpub3QgcHJvdmlkZSBjdXN0b20gdmFsaWRhdGlvbi4gV2hl biBhbWxfaDI2NF9kZWNfcnVuKCkgY2FsbHMKaDI2NF9jb25maWdfcGFyYW1zKCktPmNvbmZpZ19z cHNfcGFyYW1zKCksIHBfc3BzX2Jhc2UgaXMgY2FsY3VsYXRlZCBkaXJlY3RseQpmcm9tIHNwcy0+ c2VxX3BhcmFtZXRlcl9zZXRfaWQgKGEgdTggdXAgdG8gMjU1KToKCmRyaXZlcnMvbWVkaWEvcGxh dGZvcm0vYW1sb2dpYy92ZGVjL2gyNjQuYzpoMjY0X2NvbmZpZ19wYXJhbXMoKSB7CglwX3Nwc19i YXNlID0gKHVuc2lnbmVkIHNob3J0ICopKGgyNjRfY3R4LT53b3Jrc3BhY2VfdmFkZHIgKwoJCU1F TV9TUFNfQkFTRSArIHNwcy0+c2VxX3BhcmFtZXRlcl9zZXRfaWQgKiAweDQwMCk7CglwX3Bwc19i YXNlID0gKHVuc2lnbmVkIHNob3J0ICopKGgyNjRfY3R4LT53b3Jrc3BhY2VfdmFkZHIgKwoJCU1F TV9QUFNfQkFTRSArIHBwcy0+cGljX3BhcmFtZXRlcl9zZXRfaWQgKiAweDIwMCk7Cn0KCmRyaXZl cnMvbWVkaWEvcGxhdGZvcm0vYW1sb2dpYy92ZGVjL2gyNjQuYzpjb25maWdfc3BzX3BhcmFtcygp IHsKCW1lbXNldChzcHNfYmFzZSwgMCwgMHgxMDApOwoJbWVtc2V0KGRhdGFfdG1wLCAwLCBzaXpl b2YoZGF0YV90bXApKTsKfQoKU2luY2UgTUVNX1NQU19CQVNFICgweDAxYzNjMDApIHRvIE1FTV9Q UFNfQkFTRSAoMHgwMWNiYzAwKSBvbmx5IGhhcyByb29tIGZvcgozMiBlbnRyaWVzIG9mIDB4NDAw IGJ5dGVzLCB3b24ndCBzZXFfcGFyYW1ldGVyX3NldF9pZCA+PSAzMiBjYXVzZQpjb25maWdfc3Bz X3BhcmFtcygpIHRvIG92ZXJ3cml0ZSB0aGUgTUVNX1BQU19CQVNFIHRhYmxlIGFuZCBhZGphY2Vu dCByZWdpb25zCm9mIGgyNjRfY3R4LT53b3Jrc3BhY2VfdmFkZHI/CgpbU2V2ZXJpdHk6IEhpZ2hd CkNvdWxkIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vYW1sb2dpYy92ZGVjL2FtbF92ZGVjX2h3LmMg YW5kCmRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vYW1sb2dpYy92ZGVjL2FtbF92ZGVjX2Rydi5jIGFj Y2VzcyB1bmNsb2NrZWQgb3IKdW5wb3dlcmVkIERPU19CVVMgcmVnaXN0ZXJzIGlmIHBvd2VyIGRv bWFpbiBhdHRhY2htZW50IGZhaWxzIG9yIGJlZm9yZQp2ZGVjX2VuYWJsZSgpIHJ1bnM/CgpJbiBw bV92ZGVjX3Bvd2VyX2RvbWFpbl9pbml0KCksIGVycm9ycyBmcm9tIGRldl9wbV9kb21haW5fYXR0 YWNoX2J5X25hbWUoKQooaW5jbHVkaW5nIC1FUFJPQkVfREVGRVIpIGFyZSBpZ25vcmVkIGFuZCBw ZFtpXS5kZXYgaXMgc2V0IHRvIE5VTEw6Cgpkcml2ZXJzL21lZGlhL3BsYXRmb3JtL2FtbG9naWMv dmRlYy9hbWxfdmRlY19ody5jOnBtX3ZkZWNfcG93ZXJfZG9tYWluX2luaXQoKSB7CgkJcGRbaV0u ZGV2ID0gZGV2X3BtX2RvbWFpbl9hdHRhY2hfYnlfbmFtZShody0+ZGV2LCBwZFtpXS5uYW1lKTsK CQlpZiAoSVNfRVJSX09SX05VTEwocGRbaV0uZGV2KSkgewoJCQllcnIgPSBQVFJfRVJSKHBkW2ld LmRldik7CgkJCWRldl9kYmcoaHctPmRldiwgIkdldCAlcyBmYWlsZWQsIHBtLWRvbWFpbjogJWRc biIsCgkJCQlwZFtpXS5uYW1lLCBlcnIpOwoJCQlwZFtpXS5kZXYgPSBOVUxMOwoJCQljb250aW51 ZTsKCQl9Cn0KCldoZW4gcGRfZGF0YVtjb3JlXS5kZXYgaXMgTlVMTCwgdmRlY19wb3dlcm9uKCkg c2tpcHMgaHctPnBtLT5wb3dlcl9vbihodywgY29yZSkKYW5kIGxlYXZlcyBib3RoIHRoZSB2ZGVj IHBvd2VyIGRvbWFpbiBhbmQgdmRlYyBjbG9jayBkaXNhYmxlZCwgc28gc3Vic2VxdWVudApET1Nf QlVTIHJlZ2lzdGVyIGFjY2Vzc2VzIGluIG0ybW9wc192ZGVjX2RldmljZV9ydW4oKS0+ZG9zX2Vu YWJsZSgpIGNhbgp0cmlnZ2VyIGEgc3luY2hyb25vdXMgZXh0ZXJuYWwgYWJvcnQ6Cgpkcml2ZXJz L21lZGlhL3BsYXRmb3JtL2FtbG9naWMvdmRlYy9hbWxfdmRlY19ody5jOnZkZWNfcG93ZXJvbigp IHsKCW11dGV4X2xvY2soJmh3LT5wbV9tdXRleCk7CglpZiAoIWh3LT5wbS0+cGRfZGF0YVtjb3Jl XS5kZXYpCgkJZ290byBvdXQ7CgkuLi4KCWh3LT5wbS0+cG93ZXJfb24oaHcsIGNvcmUpOwp9CgpJ biBhZGRpdGlvbiwgdmRlY19jbG9ja19nYXRlX2luaXQoKSBhY3F1aXJlcyB0aGUgZG9zIGNsb2Nr IGluCmh3LT5nYXRlc1tDTEtfRE9TXToKCmRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vYW1sb2dpYy92 ZGVjL2FtbF92ZGVjX2h3LmM6dmRlY19jbG9ja19nYXRlX2luaXQoKSB7Cglody0+Z2F0ZXNbQ0xL X0RPU10uaWQgPSAiZG9zIjsKCWh3LT5nYXRlc1tDTEtfVkRFQ10uaWQgPSAidmRlYyI7Cglody0+ Z2F0ZXNbQ0xLX0hWREVDXS5pZCA9ICJodmRlYyI7CgoJcmV0dXJuIGRldm1fY2xrX2J1bGtfZ2V0 KGh3LT5kZXYsIENMS19NQVgsIGh3LT5nYXRlcyk7Cn0KCllldCBwbV92ZGVjX3Bvd2VyX2RvbWFp bl9wb3dlcl9vbigpIG9ubHkgZW5hYmxlcyB2ZGVjIGFuZCBodmRlYyBhbmQgbmV2ZXIKZW5hYmxl cyBody0+Z2F0ZXNbQ0xLX0RPU10uY2xrLgoKRnVydGhlcm1vcmUsIGluIGFtbF92ZGVjX2Rydl9w cm9iZSgpIGluCmRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vYW1sb2dpYy92ZGVjL2FtbF92ZGVjX2Ry di5jLCB2aWRlb19yZWdpc3Rlcl9kZXZpY2UoKSBpcwpjYWxsZWQgYmVmb3JlIGRldi0+djRsMl9k ZXYubWRldiBpcyBpbml0aWFsaXplZCBhbmQgYmVmb3JlCnZkZWNfZW5hYmxlKGRldi0+ZGVjX2h3 KSBpcyBjYWxsZWQ6Cgpkcml2ZXJzL21lZGlhL3BsYXRmb3JtL2FtbG9naWMvdmRlYy9hbWxfdmRl Y19kcnYuYzphbWxfdmRlY19kcnZfcHJvYmUoKSB7CglyZXQgPSB2aWRlb19yZWdpc3Rlcl9kZXZp Y2UodmZkX2RlYywgVkZMX1RZUEVfVklERU8sIC0xKTsKCWlmIChyZXQpIHsKCQl2NGwyX2Vycigm ZGV2LT52NGwyX2RldiwgIkZhaWxlZCB0byByZWdpc3RlciB2aWRlbyBkZXZpY2UiKTsKCQlnb3Rv IGVycl92aWRfZGV2X3JlZ2lzdGVyOwoJfQoKCWRldi0+bWRldi5kZXYgPSAmcGRldi0+ZGV2OwoJ c3Ryc2NweShkZXYtPm1kZXYubW9kZWwsIEFNTF9WREVDX0RSVl9OQU1FLCBzaXplb2YoZGV2LT5t ZGV2Lm1vZGVsKSk7CgltZWRpYV9kZXZpY2VfaW5pdCgmZGV2LT5tZGV2KTsKCWRldi0+bWRldi5v cHMgPSAmYW1sX20ybV9tZWRpYV9vcHM7CglkZXYtPnY0bDJfZGV2Lm1kZXYgPSAmZGV2LT5tZGV2 OwoJLi4uCgl2ZGVjX2VuYWJsZShkZXYtPmRlY19odyk7Cn0KClNob3VsZCBwbV92ZGVjX3Bvd2Vy X2RvbWFpbl9pbml0KCkgcHJvcGFnYXRlIGVycm9ycyBmcm9tCmRldl9wbV9kb21haW5fYXR0YWNo X2J5X25hbWUoKSwgc2hvdWxkIENMS19ET1MgYmUgZW5hYmxlZCBiZWZvcmUgYWNjZXNzaW5nCkRP U19CVVMgcmVnaXN0ZXJzLCBhbmQgc2hvdWxkIHZkZWNfZW5hYmxlKCkgYW5kIG1lZGlhX2Rldmlj ZV9pbml0KCkgcnVuIGJlZm9yZQp2aWRlb19yZWdpc3Rlcl9kZXZpY2UoKSBwdWJsaXNoZXMgdGhl IGRldmljZSBub2RlPwoKW1NldmVyaXR5OiBIaWdoXQpXaHkgZG9lcyBkZXZfcmVxdWVzdF9od19y ZXNvdXJjZXMoKSBpbgpkcml2ZXJzL21lZGlhL3BsYXRmb3JtL2FtbG9naWMvdmRlYy9hbWxfdmRl Y19ody5jIGNoZWNrIG1lc29uX3NtX2dldCgpIHdpdGgKSVNfRVJSKCkgaW5zdGVhZCBvZiBjaGVj a2luZyBmb3IgTlVMTD8KCkluIGRyaXZlcnMvZmlybXdhcmUvbWVzb24vbWVzb25fc20uYywgbWVz b25fc21fZ2V0KCkgcmV0dXJucyBOVUxMIHdoZW4gdGhlCnNlY3VyZS1tb25pdG9yIGRldmljZSBp cyBtaXNzaW5nIG9yIGhhcyBub3QgZmluaXNoZWQgcHJvYmluZzoKCmRyaXZlcnMvZmlybXdhcmUv bWVzb24vbWVzb25fc20uYzptZXNvbl9zbV9nZXQoKSB7CglpZiAoIXBkZXYpCgkJcmV0dXJuIE5V TEw7CgoJZncgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKCglwdXRfZGV2aWNlKCZwZGV2 LT5kZXYpOwoKCXJldHVybiBmdzsKfQoKSG93ZXZlciwgZGV2X3JlcXVlc3RfaHdfcmVzb3VyY2Vz KCkgb25seSBjaGVja3MgSVNfRVJSKGh3LT5zZWNfZncpOgoKZHJpdmVycy9tZWRpYS9wbGF0Zm9y bS9hbWxvZ2ljL3ZkZWMvYW1sX3ZkZWNfaHcuYzpkZXZfcmVxdWVzdF9od19yZXNvdXJjZXMoKSB7 Cglody0+c2VjX2Z3ID0gbWVzb25fc21fZ2V0KHNtX25wKTsKCW9mX25vZGVfcHV0KHNtX25wKTsK CWlmIChJU19FUlIoaHctPnNlY19mdykpCgkJcmV0dXJuIFBUUl9FUlIoaHctPnNlY19mdyk7Cn0K CklmIG1lc29uX3NtX2dldCgpIHJldHVybnMgTlVMTCwgcHJvYmUgc3VjY2VlZHMgd2l0aCBody0+ c2VjX2Z3ID09IE5VTEwsIGFuZAp3aGVuIGEgZGVjb2RlIGpvYiBydW5zIG0ybW9wc192ZGVjX2Rl dmljZV9ydW4oKS0+bG9hZF9maXJtd2FyZSgpIGluCmRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vYW1s b2dpYy92ZGVjL2FtbF92ZGVjX3RlZV9mdy5jOgoKZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9hbWxv Z2ljL3ZkZWMvYW1sX3ZkZWNfdGVlX2Z3LmM6bG9hZF9maXJtd2FyZSgpIHsKCW1lc29uX3NtX2Nh bGwoaHctPnNlY19mdywgU01fTE9BRF9WSURFT19GVywgJnJldCwKCQkgICAgICB2aWRlb19mdy0+ ZndfZm9ybWF0LCB2aWRlb19mdy0+Y29yZSwKCQkgICAgICB2aWRlb19mdy0+aXNfc3dhcCwgMCwg MCk7Cn0KCndvbid0IG1lc29uX3NtX2NhbGwoKSBkZXJlZmVyZW5jZSBhIE5VTEwgaHctPnNlY19m dyBwb2ludGVyIGluc3RlYWQgb2YgcHJvYmUKcmV0dXJuaW5nIC1FUFJPQkVfREVGRVI/CgpbU2V2 ZXJpdHk6IE1lZGl1bV0KQXJlIGN0eC0+cGljX2luZm8sIHBsYW5lX2ZtdFswXS5zaXplaW1hZ2Us IGFuZCB0aGUgZm9ybWF0L3F1ZXVlIGxvY2tzIGluCmRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vYW1s b2dpYy92ZGVjL2FtbF92ZGVjLmMgaW5pdGlhbGl6ZWQgaW4gdGhlIHJpZ2h0IG9yZGVyPwoKRmly c3QsIHdoZW4gYSBmaWxlIGhhbmRsZSBpcyBvcGVuZWQsIGZvcHNfdmNvZGVjX29wZW4oKS0+YW1s X3ZkZWNfcmVzZXRfZm10cygpCmNhbGxzIHJlc2V0X291dHB1dF9mbXRzKCksIHdoaWNoIHNldHMg Y3R4LT5waXhfZm10W0FNTF9GTVRfU1JDXSB3aXRob3V0CmNhbGxpbmcgc2V0X3BpY19pbmZvKCk6 Cgpkcml2ZXJzL21lZGlhL3BsYXRmb3JtL2FtbG9naWMvdmRlYy9hbWxfdmRlYy5jOnJlc2V0X291 dHB1dF9mbXRzKCkgewoJdmRlY190cnlfZm10X21wKGN0eCwgVjRMMl9CVUZfVFlQRV9WSURFT19P VVRQVVRfTVBMQU5FLCAmZm10LAoJCQlvdXRfZm10KTsKCgljdHgtPnBpeF9mbXRbQU1MX0ZNVF9T UkNdID0gZm10Owp9CgpJZiB1c2Vyc3BhY2Ugc3RhcnRzIHN0cmVhbWluZyB3aXRoIHRoZSBkZWZh dWx0IGZvcm1hdCB3aXRob3V0IGNhbGxpbmcKVklESU9DX1NfRk1UIG9uIFY0TDJfQlVGX1RZUEVf VklERU9fT1VUUFVUX01QTEFORSwgY3R4LT5waWNfaW5mby5mYl9zaXplWzBdCnJlbWFpbnMgMCwg c28gaDI2NF9jb25maWdfZGVjb2RlX3NwZWMoKSBhbmQgaDI2NF9jb25maWdfcmVmX3NwZWMoKSBp bgpkcml2ZXJzL21lZGlhL3BsYXRmb3JtL2FtbG9naWMvdmRlYy9oMjY0LmMgc2V0IGNfZG1hX2Fk ZHIgZXF1YWwgdG8geV9kbWFfYWRkcgpmb3Igc2luZ2xlLXBsYW5hciBjYXB0dXJlIGZvcm1hdHM6 Cgpkcml2ZXJzL21lZGlhL3BsYXRmb3JtL2FtbG9naWMvdmRlYy9oMjY0LmM6aDI2NF9jb25maWdf ZGVjb2RlX3NwZWMoKSB7CgloMjY0X2N0eC0+Y3Vycl9zcGVjLnlfZG1hX2FkZHIgPSB2YjJfZG1h X2NvbnRpZ19wbGFuZV9kbWFfYWRkcih2YiwgMCk7CglpZiAoY3R4LT5waXhfZm10W0FNTF9GTVRf RFNUXS5udW1fcGxhbmVzID4gMSkKCQloMjY0X2N0eC0+Y3Vycl9zcGVjLmNfZG1hX2FkZHIgPQoJ CSAgICB2YjJfZG1hX2NvbnRpZ19wbGFuZV9kbWFfYWRkcih2YiwgMSk7CgllbHNlCgkJaDI2NF9j dHgtPmN1cnJfc3BlYy5jX2RtYV9hZGRyID0KCQkgICAgaDI2NF9jdHgtPmN1cnJfc3BlYy55X2Rt YV9hZGRyICsgY3R4LT5waWNfaW5mby5mYl9zaXplWzBdOwp9CgpTZWNvbmQsIGluIHZkZWNfdHJ5 X2ZtdF9tcCgpLCBwbGFuZV9mbXRbMF0uc2l6ZWltYWdlIGZvciB0aGUgb3V0cHV0IHF1ZXVlIGlz CmNvbXB1dGVkIGZyb20gcGl4X21wLT5oZWlnaHQgYW5kIHBpeF9tcC0+d2lkdGggYmVmb3JlIEFM SUdOKCkgYW5kCnY0bDJfYXBwbHlfZnJtc2l6ZV9jb25zdHJhaW50cygpIGNsYW1wIGFuZCBhbGln biB0aGVtOgoKZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9hbWxvZ2ljL3ZkZWMvYW1sX3ZkZWMuYzp2 ZGVjX3RyeV9mbXRfbXAoKSB7CglpZiAoVjRMMl9UWVBFX0lTX09VVFBVVCh0eXBlKSkgewoJCXBp eF9tcC0+bnVtX3BsYW5lcyA9IGRlY19mbXQtPm51bV9wbGFuZXM7CgkJcGl4X21wLT5waXhlbGZv cm1hdCA9IGRlY19mbXQtPmZvdXJjYzsKCQlpZiAoIXBpeF9tcC0+cGxhbmVfZm10WzBdLnNpemVp bWFnZSkKCQkJcGl4X21wLT5wbGFuZV9mbXRbMF0uc2l6ZWltYWdlID0KCQkJICAgIChwaXhfbXAt PmhlaWdodCAqIHBpeF9tcC0+d2lkdGggKiAzKSAvIDI7CgkJcGl4X21wLT5oZWlnaHQgPSBBTElH TihwaXhfbXAtPmhlaWdodCwgYWxpZ24pOwoJCXBpeF9tcC0+d2lkdGggPSBBTElHTihwaXhfbXAt PndpZHRoLCBhbGlnbik7Cgl9IGVsc2UgewoJCS4uLgoJfQoKCXY0bDJfYXBwbHlfZnJtc2l6ZV9j b25zdHJhaW50cygmcGl4X21wLT53aWR0aCwgJnBpeF9tcC0+aGVpZ2h0LAoJCQkJICAgICAgICZk ZWNfZm10LT5zdGVwd2lzZSk7Cn0KCklmIHVzZXJzcGFjZSBwYXNzZXMgd2lkdGggPT0gMCBvciBo ZWlnaHQgPT0gMCB3aXRoIHNpemVpbWFnZSA9PSAwLCBzaXplaW1hZ2UKcmVtYWlucyAwIGV2ZW4g YWZ0ZXIgd2lkdGggYW5kIGhlaWdodCBhcmUgY2xhbXBlZCB0byB0aGUgbWluaW11bSBmcmFtZSBz aXplLgoKVGhpcmQsIGFtbF92ZGVjX3Jlc2V0X2ZtdHMoKSBhbmQgYW1sX3ZkZWNfcXVldWVfaW5p dCgpIHNldApjdHgtPm0ybV9jdHgtPnFfbG9jaywgc3JjX3ZxLT5sb2NrLCBhbmQgZHN0X3ZxLT5s b2NrIHRvICZjdHgtPnY0bDJfaW50Zl9sb2NrLAp3aGVyZWFzIGFtbF92ZGVjX2Rydl9wcm9iZSgp IHNldHMgdmZkX2RlYy0+bG9jayB0byAmZGV2LT5kZXZfbXV0ZXg6Cgpkcml2ZXJzL21lZGlhL3Bs YXRmb3JtL2FtbG9naWMvdmRlYy9hbWxfdmRlYy5jOmFtbF92ZGVjX3Jlc2V0X2ZtdHMoKSB7Cglj dHgtPm0ybV9jdHgtPnFfbG9jayA9ICZjdHgtPnY0bDJfaW50Zl9sb2NrOwoJcmVzZXRfb3V0cHV0 X2ZtdHMoY3R4KTsKCXJlc2V0X2NhcHR1cmVfZm10cyhjdHgpOwp9CgpEb2Vzbid0IHVzaW5nIHR3 byBkaWZmZXJlbnQgbXV0ZXhlcyBhbGxvdyBWSURJT0NfU19GTVQgYW5kIFZJRElPQ19HX0ZNVCB0 bwpyYWNlIHdpdGggcXVldWUgaW9jdGxzIHN1Y2ggYXMgVklESU9DX1JFUUJVRlMsIFZJRElPQ19R QlVGLCBhbmQKVklESU9DX1NUUkVBTU9OPwoKW1NldmVyaXR5OiBNZWRpdW1dCldoYXQgaGFwcGVu cyBpbiBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL2FtbG9naWMvdmRlYy9hbWxfdmRlY19ody5jIHdo ZW4KcG1fcnVudGltZV9yZXN1bWVfYW5kX2dldCgpIG9yIGNsa19wcmVwYXJlX2VuYWJsZSgpIGZh aWxzIGR1cmluZwp2ZGVjX3Bvd2Vyb24oKT8KCkluIHBtX3ZkZWNfcG93ZXJfZG9tYWluX3Bvd2Vy X29uKCksIGlmIGNsa19wcmVwYXJlX2VuYWJsZShnYXRlX25vZGUtPmNsaykKc3VjY2VlZHMgYW5k IHBtX3J1bnRpbWVfcmVzdW1lX2FuZF9nZXQoZGV2KSBmYWlscywgZ2F0ZV9ub2RlLT5jbGsgaXMg bm90CmRpc2FibGVkIGFuZCB1bnByZXBhcmVkLCBhbmQgdGhlIGVycm9yIGlzIG5vdCByZXR1cm5l ZCB0byB0aGUgY2FsbGVyOgoKZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9hbWxvZ2ljL3ZkZWMvYW1s X3ZkZWNfaHcuYzpwbV92ZGVjX3Bvd2VyX2RvbWFpbl9wb3dlcl9vbigpIHsKCWlmIChnYXRlX25v ZGUpIHsKCQlyZXQgPSBjbGtfcHJlcGFyZV9lbmFibGUoZ2F0ZV9ub2RlLT5jbGspOwoJLi4uCglp ZiAoIXJldCAmJiBkZXYpIHsKCQlyZXQgPSBwbV9ydW50aW1lX3Jlc3VtZV9hbmRfZ2V0KGRldik7 CgkJaWYgKHJldCA8IDApCgkJCWRldl9lcnIoaHctPmRldiwgImZhaWxlZCB0byBwb3dlciBvbiAl cyBkb21haW46ICVkXG4iLAoJCQkJcG0tPnBkX2RhdGFbaWRdLm5hbWUsIHJldCk7CgkuLi4KCWlm ICghcmV0KQoJCWRvc19sb2NhbF9jb25maWcoaHcsIDEsIGlkKTsKfQoKQmVjYXVzZSB2ZGVjX3Bv d2Vyb24oKSBpbmNyZW1lbnRzIGh3LT5wbS0+cGRfZGF0YVtjb3JlXS5yZWZfY291bnQgYmVmb3Jl CmNhbGxpbmcgaHctPnBtLT5wb3dlcl9vbihodywgY29yZSkgYW5kIHZkZWNfZW5hYmxlKCkgYWx3 YXlzIHJldHVybnMgMCB0bwphbWxfdmRlY19kcnZfcHJvYmUoKToKCmRyaXZlcnMvbWVkaWEvcGxh dGZvcm0vYW1sb2dpYy92ZGVjL2FtbF92ZGVjX2h3LmM6dmRlY19wb3dlcm9uKCkgewoJaHctPnBt LT5wZF9kYXRhW2NvcmVdLnJlZl9jb3VudCsrOwoJaWYgKGh3LT5wbS0+cGRfZGF0YVtjb3JlXS5y ZWZfY291bnQgPiAxKQoJCWdvdG8gb3V0OwoKCWh3LT5wbS0+cG93ZXJfb24oaHcsIGNvcmUpOwp9 Cgp3aGVuIGFtbF92ZGVjX2Rydl9yZW1vdmUoKSBsYXRlciBjYWxscwp2ZGVjX2Rpc2FibGUoKS0+ dmRlY19wb3dlcm9mZigpLT5wbV92ZGVjX3Bvd2VyX2RvbWFpbl9wb3dlcl9vZmYoKToKCmRyaXZl cnMvbWVkaWEvcGxhdGZvcm0vYW1sb2dpYy92ZGVjL2FtbF92ZGVjX2h3LmM6cG1fdmRlY19wb3dl cl9kb21haW5fcG93ZXJfb2ZmKCkgewoJZG9zX2xvY2FsX2NvbmZpZyhodywgMCwgaWQpOwoKCWlm IChkZXYpIHsKCQlwbV9ydW50aW1lX3B1dF9zeW5jKGRldik7Cn0KCndvbid0IHBtX3ZkZWNfcG93 ZXJfZG9tYWluX3Bvd2VyX29mZigpIGFjY2VzcyB1bnBvd2VyZWQgRE9TX0JVUyByZWdpc3RlcnMg aW4KZG9zX2xvY2FsX2NvbmZpZyhodywgMCwgaWQpIGFuZCBjYXVzZSB1bmJhbGFuY2VkIHBtX3J1 bnRpbWVfcHV0X3N5bmMoKSBhbmQKY2xrX2Rpc2FibGVfdW5wcmVwYXJlKCkgY2FsbHM/CgpbU2V2 ZXJpdHk6IExvd10KU2hvdWxkIFZJREVPX0FNTE9HSUNfVkRFQyBpbiBkcml2ZXJzL21lZGlhL3Bs YXRmb3JtL2FtbG9naWMvdmRlYy9LY29uZmlnCnNlbGVjdCBSRUdNQVBfTU1JTz8KCkluIGRyaXZl cnMvbWVkaWEvcGxhdGZvcm0vYW1sb2dpYy92ZGVjL2FtbF92ZGVjX2h3LmMsCmRldl9yZXF1ZXN0 X2h3X3Jlc291cmNlcygpIGluaXRpYWxpemVzIHJlZ21hcHMgdmlhIGRldm1fcmVnbWFwX2luaXRf bW1pbygpOgoKZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9hbWxvZ2ljL3ZkZWMvYW1sX3ZkZWNfaHcu YzpkZXZfcmVxdWVzdF9od19yZXNvdXJjZXMoKSB7CgkJaWYgKGkgPT0gRE9TX0JVUykgewoJCQlo dy0+bWFwW2ldID0gZGV2bV9yZWdtYXBfaW5pdF9tbWlvKCZwZGV2LT5kZXYsIHJlZ19iYXNlW2ld LAoJCQkJCQkJICAgJmRvc19yZWdtYXBfY29uZik7CgkJfSBlbHNlIGlmIChpID09IERNQ19CVVMp IHsKCQkJaHctPm1hcFtpXSA9IGRldm1fcmVnbWFwX2luaXRfbW1pbygmcGRldi0+ZGV2LCByZWdf YmFzZVtpXSwKCQkJCQkJCSAgICZkbWNfcmVnbWFwX2NvbmYpOwoJCX0KfQoKSG93ZXZlciwgVklE RU9fQU1MT0dJQ19WREVDIGluIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vYW1sb2dpYy92ZGVjL0tj b25maWcKZG9lcyBub3Qgc2VsZWN0IFJFR01BUF9NTUlPOgoKZHJpdmVycy9tZWRpYS9wbGF0Zm9y bS9hbWxvZ2ljL3ZkZWMvS2NvbmZpZzogewpjb25maWcgVklERU9fQU1MT0dJQ19WREVDCiAgICB0 cmlzdGF0ZSAiQW1sb2dpYyBWaWRlbyBEZWNvZGVyIERyaXZlciIKICAgIC4uLgogICAgc2VsZWN0 IFZJREVPQlVGMl9ETUFfQ09OVElHCiAgICBzZWxlY3QgVjRMMl9IMjY0CiAgICBzZWxlY3QgVjRM Ml9NRU0yTUVNX0RFVgogICAgc2VsZWN0IE1FU09OX0NBTlZBUwp9CgpDb3VsZCBjb25maWd1cmF0 aW9ucyBlbmFibGluZyBDT05GSUdfVklERU9fQU1MT0dJQ19WREVDIHdpdGhvdXQgYW5vdGhlciBk cml2ZXIKc2VsZWN0aW5nIENPTkZJR19SRUdNQVBfTU1JTyBmYWlsIHRvIGJ1aWxkIG9yIGxpbms/ Cgo+ICBDT05GSUdfVklERU9fQU1QSElPTl9WUFU9bQo+ICBDT05GSUdfVklERU9fQ0FERU5DRV9D U0kyUlg9bQo+ICBDT05GSUdfVklERU9fV0FWRV9WUFU9bQoKLS0gClNhc2hpa28gQUkgcmV2aWV3 IMK3IGh0dHBzOi8vc2FzaGlrby5kZXYvIy9wYXRjaHNldC8yMDI2MTAyMi1iNC1zNC12ZGVjLXVw c3RyZWFtLXYxMi0wLTYxNjI0MDk3ODc5MkBhbWxvZ2ljLmNvbT9wYXJ0PTYKCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFtbG9naWMgbWFpbGlu ZyBsaXN0CmxpbnV4LWFtbG9naWNAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5m cmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFtbG9naWMK From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=100.103.45.18 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1792648435; b=pt/koKSbkdQfMbq32Yfrhf+NyE8SMC3M9Np57TwNBWQeB/6aG9z+Nya7HIKbBS0CPyoY p+F9ZCFHF6gx61RJ0EbgnXGTeoDzOZU5cy1pRvOWyRu3wH3syYeCxYRmNUZIOsYS+n1X2 XU4OseEL5R/xFGbe1i7Kdx+eH5VGzzGYovlY/Zq5bdA0oibGm8S/y3iy1nJH75hmV6aNb QYdaKMwqELjZrPDpuiUDUzLSedQWsvXUHjzZYKUONkiCaqNfBRK984Ql4ySiUr0OZUA8c SQTlnByKTy4l9TAbMRNQK358MiGj2QieYYu5QuiDB4jN+2ooIIvixQ8qH9ywxR89QVQ== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1792648435; h=Received:DKIM-Signature:Message-ID:From:Subject:Reply-To:To:Cc: In-Reply-To:References:Content-Type:Content-Transfer-Encoding:Date; bh=1ElKY0kmh0e852o+L2kly0As0zw7JarN4pKMgpjOj1E=; b=tsSlU88M7y1M5WANJ2Lw+OL0+lDrCEcJUHGUknM/M1C8En3W7tKW6FJVHBoXwFRfXoOH +XX+crACpi1FfkNoYOAK+Px/zNbvBRBHQircohQdTeLKs53tLmU487eVSKoBLciFE8k1S Zcy5HT5SQJZzkeYFsmftcAa5Cxjevj/gUjyFx3lI6c7srfFQzByv62L6LtfZAKpEYjNg8 RMQ10T74sVPKMoOOpsFIyZ9XLqth4eqBh6j8zk9rdRi2x4YXSywfASx/5Vowgm2aKrpUR eGtqUemh2EwiHZ7j2NOv72XrYeE6HLp31VjCBaA6BPaYQ01zecU9AsIiQlWjPP/Sz7Q== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=V8FcSFW2; arc=none smtp.remote-ip=100.103.45.18 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id ACC01606A319 for ; Thu, 22 Oct 2026 05:53:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key, unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=V8FcSFW2 Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0AE181F000C1; Thu, 22 Oct 2026 05:53:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1792648434; bh=1ElKY0kmh0e852o+L2kly0As0zw7JarN4pKMgpjOj1E=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=V8FcSFW2wQJgkXuUlgMnIup8ghcrfZ31+kbaWlTvwaRXwAhkOHqGITLYLQRBHK8qy pSJvH9L8IsrsbVjcQdFYRVjsqf9mC+/jxxlW50u+Z0khtEV+FWPzj+CzK9EgBd47hb cLu7TVRPiwOvibQ8Kl+wX8txX737TpH6iRwGk75+kbxJT5q/VwlrFBxR1S5Q7tNT+B FXfGRWmllFSijw3YygJvriX5vZhA+t3hx4+nr001NzI9lqdDlLK1ElhHUHXQVBx5VL xbB+PrHIrVx2KebiAfInJXSRHceCH5ApYdt+mm5U0/juzslhOXIQZcXeLa4kUmReWj VNsFf6DmIeG1w== Message-ID: From: sashiko-bot@kernel.org Subject: Re: [PATCH v12 6/6] arm64: defconfig: Enable CONFIG_VIDEO_AMLOGIC_VDEC Reply-To: sashiko-reviews@lists.linux.dev To: "Zhentao Guo" Cc: linux-amlogic@lists.infradead.org, devicetree@vger.kernel.org, robh@kernel.org, conor+dt@kernel.org, neil.armstrong@linaro.org, media-ci@linuxtv.org In-Reply-To: <20261022-b4-s4-vdec-upstream-v12-6-616240978792@amlogic.com> References: <20261022-b4-s4-vdec-upstream-v12-0-616240978792@amlogic.com> <20261022-b4-s4-vdec-upstream-v12-6-616240978792@amlogic.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Thu, 22 Oct 2026 05:53:53 +0000 X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list Thank you for your contribution! Sashiko AI review found 9 potential issue(= s) to consider: - [Critical] media: amlogic: vdec: unchecked ref_list bounds and canvas lif= ecycle in h264 - [High] media: amlogic: vdec: aml_vdec_init_dec_inst() returns -1 on outpu= t restart - [High] media: amlogic: vdec: check DPB entry flags in poc_is_in_dpb() and= get_dpb_by_poc() - [High] media: amlogic: vdec: out-of-bounds SPS workspace write in h264_co= nfig_params() - [High] media: amlogic: vdec: ignored pm-domain error, unenabled clk, earl= y vdev reg - [High] media: amlogic: vdec: wrong IS_ERR() check on meson_sm_get() return - [Medium] media: amlogic: vdec: uninitialized pic_info, prematuresizeimage= calc, and split locks - [Medium] media: amlogic: vdec: missing error unwind and propagation in vd= ec_poweron() - [Low] media: amlogic: vdec: missing select REGMAP_MMIO in Kconfig -- commit 05491c1c72b85040b071b152b79a908d403d95f0 Author: Zhentao Guo arm64: defconfig: Enable CONFIG_VIDEO_AMLOGIC_VDEC This commit enables the Amlogic V4L2 stateless video decoder driver (CONFIG_VIDEO_AMLOGIC_VDEC=3Dm) as a module in the arm64 defconfig for Amlogic SoCs such as the S4 (S805X2) platform. > diff --git a/arch/arm64/configs/defconfig b/arch/arm64/configs/defconfig > index 7b4985b29b21c..f00c8a418a464 100644 > --- a/arch/arm64/configs/defconfig > +++ b/arch/arm64/configs/defconfig > @@ -929,6 +929,7 @@ CONFIG_USB_VIDEO_CLASS=3Dm > CONFIG_V4L_PLATFORM_DRIVERS=3Dy > CONFIG_SDR_PLATFORM_DRIVERS=3Dy > CONFIG_V4L_MEM2MEM_DRIVERS=3Dy > +CONFIG_VIDEO_AMLOGIC_VDEC=3Dm [Severity: Critical] Can h264_config_ref_lists() and h264_reorder_reflists() in drivers/media/platform/amlogic/vdec/h264.c overflow ref_list0 and ref_list1 and leak meson_canvas indices? First, in struct aml_h264_ctx, ref_list0 and ref_list1 are sized to V4L2_H264_NUM_DPB_ENTRIES + 1 (17 elements). However, in h264_config_ref_lists(), v4l2_h264_init_reflist_builder() sets builder.num_valid up to V4L2_H264_REF_LIST_LEN (32) when V4L2_H264_DECODE_PARAM_FLAG_FIELD_PIC is set in decode->flags, and passes builder.num_valid as list_size to config_p_reflist() and config_b_reflist(): drivers/media/platform/amlogic/vdec/h264.c:config_p_reflist() { for (i =3D 0; i < list_size; i++) { index =3D v4l2_p0_reflist[i].index; h264_ctx->ref_list0[i].used =3D 1; ... } } Won't list_size > 17 write past the end of ref_list0 and ref_list1 in config_p_reflist() and config_b_reflist(), as well as in the loops using h264_ctx->list_size[] in h264_config_decode_spec(), get_canvas_index(), and h264_release_decode_spec()? Second, when all 16 dpb entries are active and num_ref_idx_lx_active is 16, reorder_short_term() and reorder_long_term() shift ref_list_reordered[15] i= nto the sentinel slot ref_list_reordered[16] without clearing the sentinel afterward: drivers/media/platform/amlogic/vdec/h264.c:reorder_short_term() { for (c_idx =3D num_ref_idx_lx_active; c_idx > *ref_idx_lx; c_idx--) memcpy(&ref_list_reordered[c_idx], &ref_list_reordered[c_idx - 1], sizeof(struct h264_decode_buf_spec)); ... h264_ctx->list_size[cur_list] =3D num_ref_idx_lx_active; } Since get_refidx_by_picnum(), get_st_refpic_by_num(), and get_lt_refpic_by_num() iterate until ref_list[i].dpb is NULL with no upper bound on i: drivers/media/platform/amlogic/vdec/h264.c:get_refidx_by_picnum() { for (i =3D 0; ref_list[i].dpb; i++) { if (pic_num =3D=3D ref_list[i].dpb->pic_num) return i; } } can overwriting ref_list[16].dpb cause these helpers to read past the end of ref_list0 and ref_list1 on subsequent reordering commands? Third, reorder_short_term() and reorder_long_term() overwrite h264_ctx->list_size[cur_list] with num_ref_idx_lx_active. In get_canvas_index(), config_decode_canvas() is called for every entry below list_size without checking buf->used or buf->valid, while h264_release_decode_spec() only calls release_canvas_index() when buf->used= is non-zero: drivers/media/platform/amlogic/vdec/h264.c:get_canvas_index() { if (h264_ctx->list_size[0] > 0) { for (i =3D 0; i < h264_ctx->list_size[0]; i++) { buf =3D &h264_ctx->ref_list0[i]; ret =3D config_decode_canvas(hw, buf, h264_ctx->mb_width, h264_ctx->mb_height); ... } } } drivers/media/platform/amlogic/vdec/h264.c:h264_release_decode_spec() { if (h264_ctx->list_size[0] > 0) { for (i =3D 0; i < h264_ctx->list_size[0]; i++) { buf =3D &h264_ctx->ref_list0[i]; buf->valid =3D 0; if (buf->used) { buf->dpb =3D NULL; release_canvas_index(hw, buf); buf->used =3D 0; } } h264_ctx->list_size[0] =3D 0; } } If num_ref_idx_lx_active is larger than the initial list_size, won't get_canvas_index() allocate meson canvases for entries with buf->used =3D= =3D 0 that h264_release_decode_spec() never frees, and if num_ref_idx_lx_active is smaller, won't entries above the new list_size retain stale state? [Severity: High] What happens in drivers/media/platform/amlogic/vdec/aml_vdec.c when the out= put queue is stopped and restarted while the capture queue remains streaming? When a client stops the output queue via vb2ops_vdec_stop_streaming() while ctx->is_cap_streamon is still set, aml_vdec_release_instance() is not called and ctx->codec_priv remains non-NULL: drivers/media/platform/amlogic/vdec/aml_vdec.c:vb2ops_vdec_stop_streaming()= { if (!ctx->is_output_streamon && !ctx->is_cap_streamon) aml_vdec_release_instance(ctx); } When the output queue is subsequently restarted, vb2ops_vdec_start_streamin= g() calls aml_vdec_init_dec_inst(), which initializes ret to -1 and skips ctx->codec_ops->init(ctx) because ctx->codec_priv is already allocated: drivers/media/platform/amlogic/vdec/aml_vdec.c:aml_vdec_init_dec_inst() { int ret =3D -1; ... if (ctx->codec_ops->init && !ctx->codec_priv) { ret =3D ctx->codec_ops->init(ctx); if (ret < 0) return ret; } ctx->curr_dec_type =3D fmt_out->codec_type; ... return ret; } Because ret stays -1, vb2ops_vdec_start_streaming() treats the call as a failure, returns all queued source buffers via v4l2_m2m_src_buf_remove() and v4l2_m2m_buf_done(), and fails VIDIOC_STREAMON with -EINVAL: drivers/media/platform/amlogic/vdec/aml_vdec.c:vb2ops_vdec_start_streaming(= ) { if (aml_vdec_init_dec_inst(ctx) < 0) { while ((src_buf =3D v4l2_m2m_src_buf_remove(ctx->m2m_ctx))) v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_QUEUED); return -EINVAL; } } Should ret be initialized to 0 in aml_vdec_init_dec_inst() so restarting the output queue succeeds when ctx->codec_priv is already present? [Severity: High] Should poc_is_in_dpb() and get_dpb_by_poc() in drivers/media/platform/amlogic/vdec/h264.c check whether a dpb entry is act= ive before matching top_field_order_cnt? During H264_SLICE_HEADER_DONE handling in h264_threaded_isr_func()->h264_config_decode_spec()->clear_unused_col_buf(), poc_is_in_dpb() is called to decide whether to release colocated_buf and canvas_pos slots: drivers/media/platform/amlogic/vdec/h264.c:poc_is_in_dpb() { for (i =3D 0; i < V4L2_H264_NUM_DPB_ENTRIES; i++) { if (poc =3D=3D dpb[i].top_field_order_cnt) { ret =3D 1; break; } } } Because decode->dpb has 16 fixed entries and poc_is_in_dpb() does not check dpb[i].flags for V4L2_H264_DPB_ENTRY_FLAG_ACTIVE (or V4L2_H264_DPB_ENTRY_FLAG_VALID), any unused zeroed dpb entry has top_field_order_cnt =3D=3D 0, causing poc_is_in_dpb(0, decode->dpb) to alwa= ys return 1 and leak the colocated_buf and canvas_pos slots for poc 0 in clear_unused_col_buf(): drivers/media/platform/amlogic/vdec/h264.c:clear_unused_col_buf() { for (i =3D 0; i < h264_ctx->colocated_buf_num; i++) { if (!((h264_ctx->colocated_buf_map >> i) & 0x1)) continue; col_poc =3D h264_ctx->colocated_buf_poc[i]; if (poc_is_in_dpb(col_poc, decode->dpb) !=3D 1) release_colocate_buf(h264_ctx, i); } for (i =3D 0; i < (V4L2_H264_NUM_DPB_ENTRIES + 1); i++) { if (!((h264_ctx->canvas_pos_map >> i) & 0x1)) continue; col_poc =3D h264_ctx->ref_canvas[i].poc; if (poc_is_in_dpb(col_poc, decode->dpb) !=3D 1) release_canvas_pos(h264_ctx, i); } } Similarly, if userspace clears flags on retired dpb entries without zeroing top_field_order_cnt, their colocated_buf and canvas_pos slots are never fre= ed until all slots are exhausted. In addition, h264_config_decode_buf() looks up reference entries with get_dpb_by_poc(): drivers/media/platform/amlogic/vdec/h264.c:get_dpb_by_poc() { for (i =3D 0; i < V4L2_H264_NUM_DPB_ENTRIES; i++) { if (decode->dpb[i].top_field_order_cnt =3D=3D poc) return &decode->dpb[i]; } return NULL; } drivers/media/platform/amlogic/vdec/h264.c:h264_config_decode_buf() { dpb =3D get_dpb_by_poc(decode, poc); if (dpb && (dpb->flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE)) { } If an earlier inactive dpb slot has the same top_field_order_cnt as a later active dpb slot (for instance, an unused zeroed slot before an active poc 0 entry), won't get_dpb_by_poc() return the inactive slot and cause h264_config_decode_buf() to skip writing the active reference frame's info into H264_BUFFER_INFO_DATA? [Severity: High] Can a userspace V4L2_CID_STATELESS_H264_SPS control with sps->seq_parameter_set_id >=3D 32 cause an out-of-bounds write in h264_config_params() in drivers/media/platform/amlogic/vdec/h264.c? In drivers/media/v4l2-core/v4l2-ctrls-core.c, std_validate_compound() does = not validate that p_h264_sps->seq_parameter_set_id is within 0..31, and aml_vdec_ctrls_setup() in drivers/media/platform/amlogic/vdec/aml_vdec.c do= es not provide custom validation. When aml_h264_dec_run() calls h264_config_params()->config_sps_params(), p_sps_base is calculated directly from sps->seq_parameter_set_id (a u8 up to 255): drivers/media/platform/amlogic/vdec/h264.c:h264_config_params() { p_sps_base =3D (unsigned short *)(h264_ctx->workspace_vaddr + MEM_SPS_BASE + sps->seq_parameter_set_id * 0x400); p_pps_base =3D (unsigned short *)(h264_ctx->workspace_vaddr + MEM_PPS_BASE + pps->pic_parameter_set_id * 0x200); } drivers/media/platform/amlogic/vdec/h264.c:config_sps_params() { memset(sps_base, 0, 0x100); memset(data_tmp, 0, sizeof(data_tmp)); } Since MEM_SPS_BASE (0x01c3c00) to MEM_PPS_BASE (0x01cbc00) only has room for 32 entries of 0x400 bytes, won't seq_parameter_set_id >=3D 32 cause config_sps_params() to overwrite the MEM_PPS_BASE table and adjacent regions of h264_ctx->workspace_vaddr? [Severity: High] Could drivers/media/platform/amlogic/vdec/aml_vdec_hw.c and drivers/media/platform/amlogic/vdec/aml_vdec_drv.c access unclocked or unpowered DOS_BUS registers if power domain attachment fails or before vdec_enable() runs? In pm_vdec_power_domain_init(), errors from dev_pm_domain_attach_by_name() (including -EPROBE_DEFER) are ignored and pd[i].dev is set to NULL: drivers/media/platform/amlogic/vdec/aml_vdec_hw.c:pm_vdec_power_domain_init= () { pd[i].dev =3D dev_pm_domain_attach_by_name(hw->dev, pd[i].name); if (IS_ERR_OR_NULL(pd[i].dev)) { err =3D PTR_ERR(pd[i].dev); dev_dbg(hw->dev, "Get %s failed, pm-domain: %d\n", pd[i].name, err); pd[i].dev =3D NULL; continue; } } When pd_data[core].dev is NULL, vdec_poweron() skips hw->pm->power_on(hw, c= ore) and leaves both the vdec power domain and vdec clock disabled, so subsequent DOS_BUS register accesses in m2mops_vdec_device_run()->dos_enable() can trigger a synchronous external abort: drivers/media/platform/amlogic/vdec/aml_vdec_hw.c:vdec_poweron() { mutex_lock(&hw->pm_mutex); if (!hw->pm->pd_data[core].dev) goto out; ... hw->pm->power_on(hw, core); } In addition, vdec_clock_gate_init() acquires the dos clock in hw->gates[CLK_DOS]: drivers/media/platform/amlogic/vdec/aml_vdec_hw.c:vdec_clock_gate_init() { hw->gates[CLK_DOS].id =3D "dos"; hw->gates[CLK_VDEC].id =3D "vdec"; hw->gates[CLK_HVDEC].id =3D "hvdec"; return devm_clk_bulk_get(hw->dev, CLK_MAX, hw->gates); } Yet pm_vdec_power_domain_power_on() only enables vdec and hvdec and never enables hw->gates[CLK_DOS].clk. Furthermore, in aml_vdec_drv_probe() in drivers/media/platform/amlogic/vdec/aml_vdec_drv.c, video_register_device()= is called before dev->v4l2_dev.mdev is initialized and before vdec_enable(dev->dec_hw) is called: drivers/media/platform/amlogic/vdec/aml_vdec_drv.c:aml_vdec_drv_probe() { ret =3D video_register_device(vfd_dec, VFL_TYPE_VIDEO, -1); if (ret) { v4l2_err(&dev->v4l2_dev, "Failed to register video device"); goto err_vid_dev_register; } dev->mdev.dev =3D &pdev->dev; strscpy(dev->mdev.model, AML_VDEC_DRV_NAME, sizeof(dev->mdev.model)); media_device_init(&dev->mdev); dev->mdev.ops =3D &aml_m2m_media_ops; dev->v4l2_dev.mdev =3D &dev->mdev; ... vdec_enable(dev->dec_hw); } Should pm_vdec_power_domain_init() propagate errors from dev_pm_domain_attach_by_name(), should CLK_DOS be enabled before accessing DOS_BUS registers, and should vdec_enable() and media_device_init() run bef= ore video_register_device() publishes the device node? [Severity: High] Why does dev_request_hw_resources() in drivers/media/platform/amlogic/vdec/aml_vdec_hw.c check meson_sm_get() with IS_ERR() instead of checking for NULL? In drivers/firmware/meson/meson_sm.c, meson_sm_get() returns NULL when the secure-monitor device is missing or has not finished probing: drivers/firmware/meson/meson_sm.c:meson_sm_get() { if (!pdev) return NULL; fw =3D platform_get_drvdata(pdev); put_device(&pdev->dev); return fw; } However, dev_request_hw_resources() only checks IS_ERR(hw->sec_fw): drivers/media/platform/amlogic/vdec/aml_vdec_hw.c:dev_request_hw_resources(= ) { hw->sec_fw =3D meson_sm_get(sm_np); of_node_put(sm_np); if (IS_ERR(hw->sec_fw)) return PTR_ERR(hw->sec_fw); } If meson_sm_get() returns NULL, probe succeeds with hw->sec_fw =3D=3D NULL,= and when a decode job runs m2mops_vdec_device_run()->load_firmware() in drivers/media/platform/amlogic/vdec/aml_vdec_tee_fw.c: drivers/media/platform/amlogic/vdec/aml_vdec_tee_fw.c:load_firmware() { meson_sm_call(hw->sec_fw, SM_LOAD_VIDEO_FW, &ret, video_fw->fw_format, video_fw->core, video_fw->is_swap, 0, 0); } won't meson_sm_call() dereference a NULL hw->sec_fw pointer instead of probe returning -EPROBE_DEFER? [Severity: Medium] Are ctx->pic_info, plane_fmt[0].sizeimage, and the format/queue locks in drivers/media/platform/amlogic/vdec/aml_vdec.c initialized in the right ord= er? First, when a file handle is opened, fops_vcodec_open()->aml_vdec_reset_fmt= s() calls reset_output_fmts(), which sets ctx->pix_fmt[AML_FMT_SRC] without calling set_pic_info(): drivers/media/platform/amlogic/vdec/aml_vdec.c:reset_output_fmts() { vdec_try_fmt_mp(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, &fmt, out_fmt); ctx->pix_fmt[AML_FMT_SRC] =3D fmt; } If userspace starts streaming with the default format without calling VIDIOC_S_FMT on V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, ctx->pic_info.fb_size[0] remains 0, so h264_config_decode_spec() and h264_config_ref_spec() in drivers/media/platform/amlogic/vdec/h264.c set c_dma_addr equal to y_dma_ad= dr for single-planar capture formats: drivers/media/platform/amlogic/vdec/h264.c:h264_config_decode_spec() { h264_ctx->curr_spec.y_dma_addr =3D vb2_dma_contig_plane_dma_addr(vb, 0); if (ctx->pix_fmt[AML_FMT_DST].num_planes > 1) h264_ctx->curr_spec.c_dma_addr =3D vb2_dma_contig_plane_dma_addr(vb, 1); else h264_ctx->curr_spec.c_dma_addr =3D h264_ctx->curr_spec.y_dma_addr + ctx->pic_info.fb_size[0]; } Second, in vdec_try_fmt_mp(), plane_fmt[0].sizeimage for the output queue is computed from pix_mp->height and pix_mp->width before ALIGN() and v4l2_apply_frmsize_constraints() clamp and align them: drivers/media/platform/amlogic/vdec/aml_vdec.c:vdec_try_fmt_mp() { if (V4L2_TYPE_IS_OUTPUT(type)) { pix_mp->num_planes =3D dec_fmt->num_planes; pix_mp->pixelformat =3D dec_fmt->fourcc; if (!pix_mp->plane_fmt[0].sizeimage) pix_mp->plane_fmt[0].sizeimage =3D (pix_mp->height * pix_mp->width * 3) / 2; pix_mp->height =3D ALIGN(pix_mp->height, align); pix_mp->width =3D ALIGN(pix_mp->width, align); } else { ... } v4l2_apply_frmsize_constraints(&pix_mp->width, &pix_mp->height, &dec_fmt->stepwise); } If userspace passes width =3D=3D 0 or height =3D=3D 0 with sizeimage =3D=3D= 0, sizeimage remains 0 even after width and height are clamped to the minimum frame size. Third, aml_vdec_reset_fmts() and aml_vdec_queue_init() set ctx->m2m_ctx->q_lock, src_vq->lock, and dst_vq->lock to &ctx->v4l2_intf_loc= k, whereas aml_vdec_drv_probe() sets vfd_dec->lock to &dev->dev_mutex: drivers/media/platform/amlogic/vdec/aml_vdec.c:aml_vdec_reset_fmts() { ctx->m2m_ctx->q_lock =3D &ctx->v4l2_intf_lock; reset_output_fmts(ctx); reset_capture_fmts(ctx); } Doesn't using two different mutexes allow VIDIOC_S_FMT and VIDIOC_G_FMT to race with queue ioctls such as VIDIOC_REQBUFS, VIDIOC_QBUF, and VIDIOC_STREAMON? [Severity: Medium] What happens in drivers/media/platform/amlogic/vdec/aml_vdec_hw.c when pm_runtime_resume_and_get() or clk_prepare_enable() fails during vdec_poweron()? In pm_vdec_power_domain_power_on(), if clk_prepare_enable(gate_node->clk) succeeds and pm_runtime_resume_and_get(dev) fails, gate_node->clk is not disabled and unprepared, and the error is not returned to the caller: drivers/media/platform/amlogic/vdec/aml_vdec_hw.c:pm_vdec_power_domain_powe= r_on() { if (gate_node) { ret =3D clk_prepare_enable(gate_node->clk); ... if (!ret && dev) { ret =3D pm_runtime_resume_and_get(dev); if (ret < 0) dev_err(hw->dev, "failed to power on %s domain: %d\n", pm->pd_data[id].name, ret); ... if (!ret) dos_local_config(hw, 1, id); } Because vdec_poweron() increments hw->pm->pd_data[core].ref_count before calling hw->pm->power_on(hw, core) and vdec_enable() always returns 0 to aml_vdec_drv_probe(): drivers/media/platform/amlogic/vdec/aml_vdec_hw.c:vdec_poweron() { hw->pm->pd_data[core].ref_count++; if (hw->pm->pd_data[core].ref_count > 1) goto out; hw->pm->power_on(hw, core); } when aml_vdec_drv_remove() later calls vdec_disable()->vdec_poweroff()->pm_vdec_power_domain_power_off(): drivers/media/platform/amlogic/vdec/aml_vdec_hw.c:pm_vdec_power_domain_powe= r_off() { dos_local_config(hw, 0, id); if (dev) { pm_runtime_put_sync(dev); } won't pm_vdec_power_domain_power_off() access unpowered DOS_BUS registers in dos_local_config(hw, 0, id) and cause unbalanced pm_runtime_put_sync() and clk_disable_unprepare() calls? [Severity: Low] Should VIDEO_AMLOGIC_VDEC in drivers/media/platform/amlogic/vdec/Kconfig select REGMAP_MMIO? In drivers/media/platform/amlogic/vdec/aml_vdec_hw.c, dev_request_hw_resources() initializes regmaps via devm_regmap_init_mmio(): drivers/media/platform/amlogic/vdec/aml_vdec_hw.c:dev_request_hw_resources(= ) { if (i =3D=3D DOS_BUS) { hw->map[i] =3D devm_regmap_init_mmio(&pdev->dev, reg_base[i], &dos_regmap_conf); } else if (i =3D=3D DMC_BUS) { hw->map[i] =3D devm_regmap_init_mmio(&pdev->dev, reg_base[i], &dmc_regmap_conf); } } However, VIDEO_AMLOGIC_VDEC in drivers/media/platform/amlogic/vdec/Kconfig does not select REGMAP_MMIO: drivers/media/platform/amlogic/vdec/Kconfig: { config VIDEO_AMLOGIC_VDEC tristate "Amlogic Video Decoder Driver" ... select VIDEOBUF2_DMA_CONTIG select V4L2_H264 select V4L2_MEM2MEM_DEV select MESON_CANVAS } Could configurations enabling CONFIG_VIDEO_AMLOGIC_VDEC without another dri= ver selecting CONFIG_REGMAP_MMIO fail to build or link? > CONFIG_VIDEO_AMPHION_VPU=3Dm > CONFIG_VIDEO_CADENCE_CSI2RX=3Dm > CONFIG_VIDEO_WAVE_VPU=3Dm --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20261022-b4-s4-vdec= -upstream-v12-0-616240978792@amlogic.com?part=3D6