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 882CDC55174 for ; Sun, 2 Aug 2026 20:34:35 +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:Cc:To:In-Reply-To:References:Message-Id :MIME-Version:Subject:Date:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=EeZRUYn6k/izMVLltL8HoX8UwqCCZKwAQal52iKGpXc=; b=JY6eDjfRS+AfB8 qboD37Wz2dE5vwWVxK4rXvWmFheDVgivwYCeHRPXw/M3Jmk0IDrMcQc0sY/rqTtdom02fTO4BWfIP IymD5B7QaR+sMXqzWqU1DmE/6/f4URpKcQ7zuOwl/dfhz4TR9COim+TojCvJ1KhNzQTIIzKed3ai4 iRFUYEffYz7KtpWuv54S28xA3e7O7lk8a3OHodZ2kMvjquHNQhct8bpb8gSNQngYlbQc5OVFsXR1O tFgqSUx2ERpD2sf5+BkVG4ZOAEyR7eiAgIgPkE9776wI0+0+5meEP7ARAn0Iy7wVVpLU8qquhWf/q wJm0B5FAL9fMPfCtMdnQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wqctH-0000000G1cl-0qmh; Sun, 02 Aug 2026 20:34:35 +0000 Received: from mail-wm1-x330.google.com ([2a00:1450:4864:20::330]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wqctD-0000000G1Zz-3vdW for linux-phy@lists.infradead.org; Sun, 02 Aug 2026 20:34:33 +0000 Received: by mail-wm1-x330.google.com with SMTP id 5b1f17b1804b1-490cf322ed0so7136935e9.1 for ; Sun, 02 Aug 2026 13:34:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1785702870; x=1786307670; darn=lists.infradead.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=g/uJ9rgeBYsc4vYHFy//xAr9TRI8XAnYRm6j0VRl8+k=; b=OMp6DUqRg7/V4BoLbXSuQuAdIotTrUL13mSbYwHJNswT6Yvc2DeMHCuqJauDfbgWfW EDBt3i4iIWgAT3s4fEyg496ayHKDs/Ehef45kJqKJcYqHGYxbBbwPJi5n+Kc0BDbVIzO PZOHy7BkBgiWkRFxLxC/ePAHDwV1ar85uBPJQ1kR9to3CWhybRWp7QWQ8Apt+NtkMkl6 jBe7tz1CO1z0aHmN77pg50DmyhbNexDeTT6JOkNP9Eu8wZ4pNh7ES3xr4e+C6MOlR+Tp vYPESacsYCAf/xJ8bmSy+zEmCwYcTAhMcIDS6s9hVApH/16bgyT3YRGxS5yU8NxSkK6p EA8Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1785702870; x=1786307670; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to :content-type; bh=g/uJ9rgeBYsc4vYHFy//xAr9TRI8XAnYRm6j0VRl8+k=; b=pa3F2y5cyuMxC3aY68dsI3Vry5s9Nx429/mE2xgMgdDmP1xnAlh3xa7naT+w0tluV5 jydld2KW8zHn+Kk+FY4Zh8OSz3jxhXmmB0Qu6c800wRY4LjpT8DEWqhS0fdwmqETMABy 9lC0CAfQo4/XJIj1YKHqgWSlMRsUGcQ73XrQVUTRdVI4tgchi6DO0+lgnIgRjv5qsTZ1 4TGLDR8ujmLgZa66zghIknzklZXLI/70XlFRUc4UZ40nHDs2y6Wisuiryq+4cyEZaT7O P3VE4vWVe5voWPyuLswWpmDGXF6P4HkJR0u4LzJKDB2nZRE9T797usZkZIq2+Moiyk1Y o0xA== X-Forwarded-Encrypted: i=1; AHgh+Rr/CgizilMzi6TLE7HZ/wy38y78da1xYlx/7Ki1IAIKnpWuC9hAU/D5E+tBo9BMfYflDWfck+o7aVw=@lists.infradead.org X-Gm-Message-State: AOJu0YygRs1QBwa/hzjmbwb8fiOjA5duPAJT4VCAlIWWQCx5iAprn4at 5UEb6mu+g/9YUoMfrf9wNFGmzIAq518L8QAzz52u7mazMZXB2x+3VnWe X-Gm-Gg: AR+sD13mUVVOiyXp0eyC7UQcNJR/mzfND9m9GpPW2Tp0/ucDXCPnq/64XSkmjVxyWj0 RaHtKgWyw5J5225brw/UHCqTxQHuUpAhy3UBilSYMS+wYdlmzuzRqNuogXxMsICUVVixqkQ01mM CCza/uBNFClC0ViNe6fzYhRKyyjMteGG1o33+YyJGsgfGdnOgdvB73o3KtrgneBqe56TMci26TY eo242iGdAD0HQPnhBaG7eZiLcCo5bhpnIk1dXR1TsMQWyUM1/JY/OwU2BvbzGkU9ToWwTYvQE4c GAP3TYT6UxEcSUt/u1hq1caYMI9yRqTKHCcqeKg3wFdqyCZel57/XRlSQ+uQ3D3pNs23KcihJ/b 34WKnouHRWX9BAG4gPAb/ZPfwMhPsx9FuhU+7FU+cm3LFQ32RRTSQdT5DVkGs7Hx9UhnI3e6mxv 7vn9nuYXUthdOfaXKq9gZyUqf4UYEGsVJCGLlReFY1yoviDj2tJdda7RuGLRWw2WtiIKoNA254 X-Received: by 2002:a05:600d:640f:20b0:495:503f:cf9a with SMTP id 5b1f17b1804b1-4980c672adbmr123140795e9.9.1785702870100; Sun, 02 Aug 2026 13:34:30 -0700 (PDT) Received: from [192.168.0.2] ([197.250.226.155]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49807bb45ebsm118499905e9.4.2026.08.02.13.34.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 02 Aug 2026 13:34:28 -0700 (PDT) From: =?utf-8?q?Stefan_D=C3=B6singer?= Date: Sun, 02 Aug 2026 23:33:37 +0300 Subject: [PATCH v9 05/12] clk: zte: Add Clock registration infrastructure MIME-Version: 1.0 Message-Id: <20260802-zx29clk-v9-5-d05530d85d28@gmail.com> References: <20260802-zx29clk-v9-0-d05530d85d28@gmail.com> In-Reply-To: <20260802-zx29clk-v9-0-d05530d85d28@gmail.com> To: Michael Turquette , Stephen Boyd , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel , Brian Masney , Vinod Koul , Neil Armstrong , Russell King , Lee Jones Cc: linux-clk@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-phy@lists.infradead.org, mfd@lists.linux.dev, =?utf-8?q?Stefan_D=C3=B6singer?= X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=15082; i=stefandoesinger@gmail.com; h=from:subject:message-id; bh=bliMqz9DYmlGJpuJakC365hV2+7POVwzt1MUpR8IO5k=; b=owEBiQJ2/ZANAwAIAT0TvMhUTxoiAcsmYgBqb6mykflOEFiu71wc1GczjZPa68Y6TmIpQB2Mi +T4HtQvzsGJAk8EAAEIADkWIQRDFvS2qgVbJ5UyXWw9E7zIVE8aIgUCam+pshsUgAAAAAAEAA5t YW51MiwyLjUrMS4xMiwyLDIACgkQPRO8yFRPGiLobQ//TXe/dYXrjElj9++NCXYloN0vSBLejV0 gEMP3s9qlzMUblSd87qnT4CQkb50Tv30FnyNj7pjkzsQ2I3kCiyl6C/PqIOurRFybJ/SQtGXvPh YcrzMC8fyhCqZCkvaGiJv0c45pNM9Q3efQ/Rg9+5g27Bv9+RA/JbRm7/MDQVQlmDqnLZV3rE+ba 8aQ2SOXJq60FWZE1apDJ4sRXa/17kMCK0sbzmH4YVHzY7IAOyhxHV/TCzibbNfw0Ats8+JGAMuv rTd8U1uYSHwMsHHGlSs5NdnymCzHOfz+obA/rOJPK4g3T/vpqBHPsxcKAWQENKgDwSy5DWw8+Vd hOHXYUXraoGA1EjBDiDFitCG9BdRIUCAQKoXfCNtdNYLuG61eumzhUrSkj0r0FTx0XcS+eLvrAK WSmB9dYyCzwt+AUZDxMT0zGcwkP8smqbn+bMu1HlzKOO/LHBZ7nkxY8vvlPQMHuC0BuCflLCI3N amHObSt4JrYdmJ54i5Nsbw2TymFkq0a35qUXgFc6VVrm0YXyjxhMjARoKYgc9i5srpvhka/Lxkv LyoJe90wuHCx6pLUPjLP8YBKI288PF6iaPscAiY6P8c5ck5Ol0QQ83jmF0zcRuTEx52yFJo4Xp8 CRp/E4uaFLrtJrFIrKNzMMLEFxFS+SvlDQuXKl61ruoKZAo3HZv8= X-Developer-Key: i=stefandoesinger@gmail.com; a=openpgp; fpr=4F9C2C8728019633893EBBB98CB81F9A72BBA155 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.9.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260802_133432_125154_3C582C54 X-CRM114-Status: GOOD ( 30.37 ) X-BeenThere: linux-phy@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux Phy Mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-phy" Errors-To: linux-phy-bounces+linux-phy=archiver.kernel.org@lists.infradead.org VGhlIG5leHQgcGF0Y2hlcyB3aWxsIGltcGxlbWVudCB0aGUgcmVnbWFwIGNsb2NrcyBhbmQgUExM IGRyaXZlci4gVGhlCmFjdHVhbCBoYXJkd2FyZSBzcGVjaWZpYyBjbG9jayBsaXN0aW5nIHdpbGwg bGl2ZSBpbiBhIHNlcGFyYXRlIG1vZHVsZS4KClNpZ25lZC1vZmYtYnk6IFN0ZWZhbiBEw7ZzaW5n ZXIgPHN0ZWZhbmRvZXNpbmdlckBnbWFpbC5jb20+CgotLS0KClZlcnNpb24gOToKUmV3b3JrIHBh cmVudCBtYXRjaGluZyBhbmQgY2xvY2sgZXhwb3J0IGNvbnRyb2wuIE1vc3Qgb2YgdGhlIGNoYW5n ZXMKd2lsbCBiZSBpbiB0aGUgbmV4dCBwYXRjaGVzLiBUaGUgdmlzaWJsZSBjaGFuZ2UgaGVyZSBp cyB0aGF0IHRoZSBjbG9jawphcnJheSBpcyB1bmlmaWVkIHdpdGggc2luZ2xlIGNsb2NrcyBoYXZp bmcgYSB0eXBlIHJhdGhlciB0aGFuIG9uZSBhcnJheQpwZXIgdHlwZS4KCkRlcGVuZCBvbiBIQVNf SU9NRU0sIHNpbWlsYXJseSB0byBTYXNoaWtvJ3MgZmxhZ2dlZCBpc3N1ZSBpbiB0aGUgUmVzZXQK cGF0Y2gKClpYMjk3NTIwVjNfQ0xLX05PX0VYUE9SVCBpcyBnb25lIGFnYWluLgoKVGhlIGV4cGxp Y2l0IGNsb2NrIGlucHV0IGFycmF5IGFuZCBlbmFibGluZyBvZiBMU1AncyBwY2xrIGlzIHJlbW92 ZWQKZnJvbSB0aGUgY2xvY2sgZHJpdmVyLiBUaGUgTUZEIHBhcmVudCB0YWtlcyBjYXJlIG9mIHRo aXMgaW5zdGVhZC4gVGhlCmNsb2NrIGRyaXZlciBkb2VzIHNvbWUgc2FuaXR5IGNoZWNraW5nIG9u IHRoZSBzdGF0aWMgY2xvY2sgZGF0YSB0aG91Z2guCgpWZXJzaW9uIDg6ClVzZSBaWDI5NzUyMFYz X0NMS19OT19FWFBPUlQ9KH4wdSkgZm9yIHVuZXhwb3J0ZWQgY2xvY2tzLiBXaGlsZSB1c2luZyAw LAphbmQgc3RhcnRpbmcgY2xvY2sgaW5kaWNlcyBhdCAxLCBpcyBhIGNvbW1vbiBwYXR0ZXJuIGlu IGV4aXN0aW5nCmRyaXZlcnMsIGl0IGV4cG9zZXMgYSBkcml2ZXIgaW1wbGVtZW50YXRpb24gZGV0 YWlsIGluIHRoZSBoYXJkd2FyZQpiaW5kaW5nIGludGVyZmFjZS4KCklmIGRlc2lyZWQsIEkgY2Fu IGNoYW5nZSB0aGUgc3BlY2lhbCBpbmRleCB0byBhIHNlcGFyYXRlIGZpZWxkIGluIHRoZQpzdHJ1 Y3RzLgoKRml4IHRoZSByZXR1cm4gdmFsdWUgaWYgdGhlIC0+aW5pdCgpIGNhbGxiYWNrIGZhaWxz LiAoU2FzaGlrbykKClZlcnNpb24gNzoKKikgQWRkIGZpeGVkIGRpdmlkZXJzIHRvIGhhbmRsZSBQ TEwgc3ViZGl2aXNpb25zCiopIE5ldmVyIHJlZ2lzdGVyIFBMTHMgZGlyZWN0bHkgYXMgZXhwb3J0 ZWQgY2xvY2tzIC0gZXZlcnl0aGluZyBvbiB0aGlzClNvQyBnb2VzIHRocm91Z2ggYSBnYXRlIGJl Zm9yZSBpdCBsZWF2ZXMgYSBjb250cm9sbGVyLgoKVmVyc2lvbiA2OgoqKSBSZW1vdmUgYXV4ZGV2 IG5vdyB0aGF0IExTUCBjbG9ja3MgYWxzbyB1c2UgTUZECiopIEVycm9yIGNvZGVwYXRoIGZpeGVz IHBvaW50ZWQgb3V0IGJ5IFNhc2hpa28uCgpWZXJzaW9uIDU6CgoqKSBQYXNzIHRoZSBzdGF0aWMg Y2xrIGRhdGEgaW5zdGVhZCBvZiBjYWxsaW5nIGdldF9tYXRjaF9kYXRhIHRvIHByZXBhcmUKZm9y IG9wZXJhdGluZyBhcyBhbiBNRkQgY2hpbGQuCgoqKSBEb24ndCB1c2UgZGV2bV9remFsbG9jIHRv IGFsbG9jYXRlIHRoZSBhdXhpbGlhcnlfZGV2aWNlCnN0cnVjdHVyZS4gSSBndWVzcyBTYXNoaWtv IGlzIHJpZ2h0LCBhbmQgdGhhdCdzIHdoYXQgIkJlY2F1c2Ugb25jZSB0aGUKZGV2aWNlIGlzIHBs YWNlZCBvbiB0aGUgYnVzIHRoZSBwYXJlbnQgZHJpdmVyIGNhbiBub3QgdGVsbCB3aGF0IG90aGVy CmNvZGUgbWF5IGhhdmUgYSByZWZlcmVuY2UgdG8gdGhpcyBkYXRhIiBpcyB0cnlpbmcgdG8gdGVs bCBtZS4KCiopIEZpeCBlcnJvciBjaGVjayBmb3IgZGV2aWNlX25vZGVfdG9fcmVnbWFwLgotLS0K IE1BSU5UQUlORVJTICAgICAgICAgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9jbGsvS2NvbmZp ZyAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL2Nsay9NYWtlZmlsZSAgICAgICAgIHwgICAxICsK IGRyaXZlcnMvY2xrL3p0ZS9LY29uZmlnICAgICAgfCAgMTcgKysrKwogZHJpdmVycy9jbGsvenRl L01ha2VmaWxlICAgICB8ICAgNSArKwogZHJpdmVycy9jbGsvenRlL2Nsay1yZWdtYXAuYyB8ICAz MiArKysrKysrKwogZHJpdmVycy9jbGsvenRlL2Nsay16eC5jICAgICB8IDE4OSArKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBkcml2ZXJzL2Nsay96dGUvY2xrLXp4 LmggICAgIHwgMTQyICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBkcml2ZXJzL2Ns ay96dGUvcGxsLXp4LmMgICAgIHwgIDE4ICsrKysrCiA5IGZpbGVzIGNoYW5nZWQsIDQwNiBpbnNl cnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvTUFJTlRBSU5FUlMgYi9NQUlOVEFJTkVSUwppbmRleCBi OWY5NjQ1NWJjYTcuLjc3ZmE4NmM2NzFiOCAxMDA2NDQKLS0tIGEvTUFJTlRBSU5FUlMKKysrIGIv TUFJTlRBSU5FUlMKQEAgLTM5MTUsNiArMzkxNSw3IEBAIEY6CURvY3VtZW50YXRpb24vZGV2aWNl dHJlZS9iaW5kaW5ncy9jbG9jay96dGUsengyOTc1MjB2My1tYXRyaXhjcm0ueWFtbAogRjoJRG9j dW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2Nsb2NrL3p0ZSx6eDI5NzUyMHYzLXRvcGNy bS55YW1sCiBGOglhcmNoL2FybS9ib290L2R0cy96dGUvCiBGOglhcmNoL2FybS9tYWNoLXp0ZS8K K0Y6CWRyaXZlcnMvY2xrL3p0ZS8KIEY6CWRyaXZlcnMvbWZkL3p0ZS16eDI5NzUyMHYzLWNybS5j CiBGOglpbmNsdWRlL2R0LWJpbmRpbmdzL2Nsb2NrL3p0ZSx6eDI5NzUyMHYzLWNsay5oCiBGOglp bmNsdWRlL2R0LWJpbmRpbmdzL3BoeS96dGUsengyOTc1MjB2My10b3Bjcm0uaApkaWZmIC0tZ2l0 IGEvZHJpdmVycy9jbGsvS2NvbmZpZyBiL2RyaXZlcnMvY2xrL0tjb25maWcKaW5kZXggMTcxN2Nl NzVhOTA3Li42ZjBhODYzOTUxY2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2xrL0tjb25maWcKKysr IGIvZHJpdmVycy9jbGsvS2NvbmZpZwpAQCAtNTQ1LDYgKzU0NSw3IEBAIHNvdXJjZSAiZHJpdmVy cy9jbGsvdW5pcGhpZXIvS2NvbmZpZyIKIHNvdXJjZSAiZHJpdmVycy9jbGsvdmlzY29udGkvS2Nv bmZpZyIKIHNvdXJjZSAiZHJpdmVycy9jbGsveDg2L0tjb25maWciCiBzb3VyY2UgImRyaXZlcnMv Y2xrL3hpbGlueC9LY29uZmlnIgorc291cmNlICJkcml2ZXJzL2Nsay96dGUvS2NvbmZpZyIKIHNv dXJjZSAiZHJpdmVycy9jbGsvenlucW1wL0tjb25maWciCiAKICMgS3VuaXQgdGVzdCBjYXNlcwpk aWZmIC0tZ2l0IGEvZHJpdmVycy9jbGsvTWFrZWZpbGUgYi9kcml2ZXJzL2Nsay9NYWtlZmlsZQpp bmRleCA2ODk5ZTMyZTE0YWEuLjY1MWZlODY2ZGRhZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9jbGsv TWFrZWZpbGUKKysrIGIvZHJpdmVycy9jbGsvTWFrZWZpbGUKQEAgLTE2Nyw1ICsxNjcsNiBAQCBp ZmVxICgkKENPTkZJR19DT01NT05fQ0xLKSwgeSkKIG9iai0kKENPTkZJR19YODYpCQkJKz0geDg2 LwogZW5kaWYKIG9iai15CQkJCQkrPSB4aWxpbngvCitvYmotJChDT05GSUdfQ09NTU9OX0NMS19a VEUpCQkrPSB6dGUvCiBvYmotJChDT05GSUdfQVJDSF9aWU5RKQkJCSs9IHp5bnEvCiBvYmotJChD T05GSUdfQ09NTU9OX0NMS19aWU5RTVApICAgICAgICAgKz0genlucW1wLwpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9jbGsvenRlL0tjb25maWcgYi9kcml2ZXJzL2Nsay96dGUvS2NvbmZpZwpuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjE1MmMyNDIzYjhmMAotLS0gL2Rldi9u dWxsCisrKyBiL2RyaXZlcnMvY2xrL3p0ZS9LY29uZmlnCkBAIC0wLDAgKzEsMTcgQEAKKyMgU1BE WC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb25seQorIworIyBaVEUgQ2xvY2sgRHJpdmVy cworIworCitjb25maWcgQ09NTU9OX0NMS19aVEUKKwl0cmlzdGF0ZSAiQ2xvY2sgZHJpdmVyIGZv ciBaVEUgU29DcyIKKwlkZXBlbmRzIG9uIEhBU19JT01FTQorCWRlcGVuZHMgb24gQVJDSF9aVEUg fHwgQ09NUElMRV9URVNUCisJZGVmYXVsdCBBUkNIX1pURQorCXNlbGVjdCBNRkRfU1lTQ09OCisJ aGVscAorCSAgVGhpcyBvcHRpb24gc2VsZWN0cyBjb21tb24gY2xvY2sgaW5mcmFzdHJ1Y3R1cmUg Zm9yIFpURSBiYXNlZCBTb0NzLgorCSAgWW91IHdpbGwgbmVlZCB0byBlbmFibGUgb25lIG9yIG1v cmUgU29DIHNwZWNpZmljIGRyaXZlcnMgdG8gbWFrZSB1c2UKKwkgIG9mIHRoaXMuCisKKwkgIEVu YWJsZSB0aGlzIGlmIHlvdSBhcmUgYnVpbGRpbmcgYSBrZXJuZWwgZm9yIGEgWlRFIGRlc2lnbmVk IGJvYXJkLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jbGsvenRlL01ha2VmaWxlIGIvZHJpdmVycy9j bGsvenRlL01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4u MjdkYjA3MjkzMTY1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9jbGsvenRlL01ha2VmaWxl CkBAIC0wLDAgKzEsNSBAQAorIyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5 CisKK29iai0kKENPTkZJR19DT01NT05fQ0xLX1pURSkgKz0gY2xrLXp0ZS5vCisKK2Nsay16dGUt eSArPSBjbGstengubyBwbGwtengubyBjbGstcmVnbWFwLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMv Y2xrL3p0ZS9jbGstcmVnbWFwLmMgYi9kcml2ZXJzL2Nsay96dGUvY2xrLXJlZ21hcC5jCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uODAzMzJkYmE5N2Y2Ci0tLSAvZGV2 L251bGwKKysrIGIvZHJpdmVycy9jbGsvenRlL2Nsay1yZWdtYXAuYwpAQCAtMCwwICsxLDMyIEBA CisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorLyoKKyAqIENvcHlyaWdodCAo YykgMjAyNiBTdGVmYW4gRMO2c2luZ2VyCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2Nsay1wcm92 aWRlci5oPgorI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L2Vycm5v Lmg+CisjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+CisKKyNpbmNsdWRlICJjbGstenguaCIKKwor c3RydWN0IGNsa19odyAqenhfY2xrX3JlZ2lzdGVyX2dhdGUoc3RydWN0IGRldmljZSAqZGV2LCBz dHJ1Y3QgcmVnbWFwICpyZWdtYXAsCisJCQkJICAgIGNvbnN0IHN0cnVjdCB6eF9nYXRlX2Rlc2Mg KmRlc2MsCisJCQkJICAgIHN0cnVjdCBjbGtfaHcgKiBjb25zdCAqY2xvY2tzKQoreworCXJldHVy biBFUlJfUFRSKC1FTk9ERVYpOworfQorCitzdHJ1Y3QgY2xrX2h3ICp6eF9jbGtfcmVnaXN0ZXJf ZGl2aWRlcihzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCByZWdtYXAgKnJlZ21hcCwKKwkJCQkg ICAgICAgY29uc3Qgc3RydWN0IHp4X2Rpdl9kZXNjICpkZXNjLAorCQkJCSAgICAgICBzdHJ1Y3Qg Y2xrX2h3ICogY29uc3QgKmNsb2NrcykKK3sKKwlyZXR1cm4gRVJSX1BUUigtRU5PREVWKTsKK30K Kworc3RydWN0IGNsa19odyAqenhfY2xrX3JlZ2lzdGVyX211eChzdHJ1Y3QgZGV2aWNlICpkZXYs IHN0cnVjdCByZWdtYXAgKnJlZ21hcCwKKwkJCQkgICBjb25zdCBzdHJ1Y3QgenhfbXV4X2Rlc2Mg KmRlc2MsCisJCQkJICAgc3RydWN0IGNsa19odyAqIGNvbnN0ICpjbG9ja3MpCit7CisJcmV0dXJu IEVSUl9QVFIoLUVOT0RFVik7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Nsay96dGUvY2xrLXp4 LmMgYi9kcml2ZXJzL2Nsay96dGUvY2xrLXp4LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwLi4yN2JiYWZkOGNlNGQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2Ns ay96dGUvY2xrLXp4LmMKQEAgLTAsMCArMSwxODkgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlm aWVyOiBHUEwtMi4wLW9ubHkKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjYgU3RlZmFuIETDtnNp bmdlcgorICovCisKKyNpbmNsdWRlIDxsaW51eC9jbGstcHJvdmlkZXIuaD4KKyNpbmNsdWRlIDxs aW51eC9jbGsuaD4KKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KKyNpbmNsdWRlIDxsaW51eC9lcnJu by5oPgorI2luY2x1ZGUgPGxpbnV4L21mZC9zeXNjb24uaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1 bGUuaD4KKworI2luY2x1ZGUgImNsay16eC5oIgorCitzdGF0aWMgc3RydWN0IGNsa19odyAqenhf Y2xrX3JlZ2lzdGVyX2ZpeGVkX2RpdihzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJCQljb25zdCBz dHJ1Y3QgenhfZml4ZWRfZGl2aWRlcl9kZXNjICpkZXNjLAorCQkJCQkJc3RydWN0IGNsa19odyAq IGNvbnN0ICpjbG9ja3MpCit7CisJY29uc3Qgc3RydWN0IHp4X3BhcmVudF9kZXNjICpwID0gJmRl c2MtPnBhcmVudDsKKworCXN3aXRjaCAocC0+dHlwZSkgeworCWNhc2UgWlhfUEFSRU5UX0ZXOgor CQlyZXR1cm4gZGV2bV9jbGtfaHdfcmVnaXN0ZXJfZml4ZWRfZmFjdG9yX2Z3bmFtZShkZXYsIE5V TEwsIGRlc2MtPm5hbWUsIHAtPmZ3X25hbWUsCisJCQkJCQkJCUNMS19TRVRfUkFURV9QQVJFTlQs IDEsIGRlc2MtPmRpdik7CisKKwljYXNlIFpYX1BBUkVOVF9JRDoKKwkJcmV0dXJuIGRldm1fY2xr X2h3X3JlZ2lzdGVyX2ZpeGVkX2ZhY3Rvcl9wYXJlbnRfaHcoZGV2LCBkZXNjLT5uYW1lLCBjbG9j a3NbcC0+aWRdLAorCQkJCQkJCQkgICBDTEtfU0VUX1JBVEVfUEFSRU5ULCAxLAorCQkJCQkJCQkg ICBkZXNjLT5kaXYpOworCX0KKwlXQVJOX09OX09OQ0UoMSk7CisJcmV0dXJuIEVSUl9QVFIoLUVJ TlZBTCk7Cit9CisKK3N0YXRpYyBpbnQgenhfY2xrX3ZhbGlkYXRlKHN0cnVjdCBkZXZpY2UgKmRl diwgc3RydWN0IGRldmljZV9ub2RlICpvZl9ub2RlLAorCQkJICAgY29uc3Qgc3RydWN0IHp4X2Ns a19kYXRhICpkYXRhKQoreworCWNvbnN0IHN0cnVjdCB6eF9wYXJlbnRfZGVzYyAqcGFyZW50czsK Kwl1bnNpZ25lZCBpbnQgaSwgcCwgbnVtX3BhcmVudHM7CisJc3RydWN0IGNsayAqY2xrOworCisJ LyoKKwkgKiBTYW5pdHkgY2hlY2s6IE1ha2Ugc3VyZSBhbGwgcGFyZW50cyBhcmUgdGhlcmUgYW5k IHdyaXRlIGEgY2xlYXIgbWVzc2FnZSByYXRoZXIgdGhhbgorCSAqIGxlYXZlIHBvdGVudGlhbCBv cnBoYW5zLgorCSAqLworCWZvciAoaSA9IDA7IGkgPCBkYXRhLT5udW1fY2xvY2tzOyArK2kpIHsK KwkJc3dpdGNoIChkYXRhLT5jbG9ja3NbaV0udHlwZSkgeworCQljYXNlIFpYX0NMT0NLX1BMTDoK KwkJCXBhcmVudHMgPSBkYXRhLT5jbG9ja3NbaV0ucGxsLnBhcmVudHM7CisJCQludW1fcGFyZW50 cyA9IGRhdGEtPmNsb2Nrc1tpXS5wbGwubnVtX3BhcmVudHM7CisJCQlicmVhazsKKworCQljYXNl IFpYX0NMT0NLX0ZJWEVEX0RJVjoKKwkJCXBhcmVudHMgPSAmZGF0YS0+Y2xvY2tzW2ldLmZpeGVk X2Rpdi5wYXJlbnQ7CisJCQludW1fcGFyZW50cyA9IDE7CisJCQlicmVhazsKKworCQljYXNlIFpY X0NMT0NLX01VWDoKKwkJCXBhcmVudHMgPSBkYXRhLT5jbG9ja3NbaV0ubXV4LnBhcmVudHM7CisJ CQludW1fcGFyZW50cyA9IGRhdGEtPmNsb2Nrc1tpXS5tdXgubnVtX3BhcmVudHM7CisJCQlicmVh azsKKworCQljYXNlIFpYX0NMT0NLX0RJVjoKKwkJCXBhcmVudHMgPSAmZGF0YS0+Y2xvY2tzW2ld LmRpdi5wYXJlbnQ7CisJCQludW1fcGFyZW50cyA9IDE7CisJCQlicmVhazsKKworCQljYXNlIFpY X0NMT0NLX0dBVEU6CisJCQlwYXJlbnRzID0gJmRhdGEtPmNsb2Nrc1tpXS5nYXRlLnBhcmVudDsK KwkJCW51bV9wYXJlbnRzID0gMTsKKwkJCWJyZWFrOworCisJCWRlZmF1bHQ6CisJCQlyZXR1cm4g ZGV2X2Vycl9wcm9iZShkZXYsIC1FSU5WQUwsICJJbnZhbGlkIGNsb2NrIGVudHJ5ICV1XG4iLCBp KTsKKwkJfQorCisJCWZvciAocCA9IDA7IHAgPCBudW1fcGFyZW50czsgKytwKSB7CisJCQlzd2l0 Y2ggKHBhcmVudHNbcF0udHlwZSkgeworCQkJY2FzZSBaWF9QQVJFTlRfRlc6CisJCQkJY2xrID0g b2ZfY2xrX2dldF9ieV9uYW1lKG9mX25vZGUsIHBhcmVudHNbcF0uZndfbmFtZSk7CisJCQkJaWYg KElTX0VSUihjbGspKQorCQkJCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShkZXYsIFBUUl9FUlIoY2xr KSwKKwkJCQkJCQkgICAgICJJbnB1dCBjbGsgJXMgZmFpbHVyZVxuIiwKKwkJCQkJCQkgICAgIHBh cmVudHNbcF0uZndfbmFtZSk7CisJCQkJY2xrX3B1dChjbGspOworCQkJCWJyZWFrOworCisJCQlj YXNlIFpYX1BBUkVOVF9JRDoKKwkJCQlpZiAocGFyZW50c1twXS5pZCA+PSBpKQorCQkJCQlyZXR1 cm4gZGV2X2Vycl9wcm9iZShkZXYsIC1FSU5WQUwsCisJCQkJCQkJICAgICAiQ2xvY2sgJXUgaGFz IHBhcmVudCAldVxuIiwKKwkJCQkJCQkgICAgIGksIHBhcmVudHNbcF0uaWQpOworCQkJCWJyZWFr OworCisJCQlkZWZhdWx0OgorCQkJCXJldHVybiBkZXZfZXJyX3Byb2JlKGRldiwgLUVJTlZBTCwK KwkJCQkJCSAgICAgIkNsb2NrICV1IGhhcyB1bmV4cGVjdGVkIHBhcmVudCBvZiB0eXBlICV1XG4i LAorCQkJCQkJICAgICBpLCBwYXJlbnRzW3BdLnR5cGUpOworCQkJfQorCQl9CisJfQorCisJcmV0 dXJuIDA7Cit9CisKK2ludCB6eF9jbGtfY29tbW9uX3Byb2JlKHN0cnVjdCBkZXZpY2UgKmRldiwg c3RydWN0IGRldmljZV9ub2RlICpvZl9ub2RlLAorCQkJY29uc3Qgc3RydWN0IHp4X2Nsa19kYXRh ICpkYXRhKQoreworCXN0cnVjdCBjbGtfaHdfb25lY2VsbF9kYXRhICpleHBvcnRzOworCXN0cnVj dCBjbGtfaHcgKipjbG9ja3M7CisJc3RydWN0IHJlZ21hcCAqbWFwOworCXVuc2lnbmVkIGludCBp OworCWludCByZXM7CisKKwlyZXMgPSB6eF9jbGtfdmFsaWRhdGUoZGV2LCBvZl9ub2RlLCBkYXRh KTsKKwlpZiAocmVzKQorCQlyZXR1cm4gcmVzOworCisJbWFwID0gZGV2aWNlX25vZGVfdG9fcmVn bWFwKG9mX25vZGUpOworCWlmIChJU19FUlIobWFwKSkKKwkJcmV0dXJuIFBUUl9FUlIobWFwKTsK KworCWNsb2NrcyA9IGRldm1fa2NhbGxvYyhkZXYsIGRhdGEtPm51bV9jbG9ja3MsIHNpemVvZigq Y2xvY2tzKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFjbG9ja3MpCisJCXJldHVybiAtRU5PTUVNOwor CisJaWYgKGRhdGEtPmluaXQpIHsKKwkJcmVzID0gZGF0YS0+aW5pdChtYXApOworCQlpZiAocmVz KQorCQkJcmV0dXJuIHJlczsKKwl9CisKKwlmb3IgKGkgPSAwOyBpIDwgZGF0YS0+bnVtX2Nsb2Nr czsgKytpKSB7CisJCXN0cnVjdCBjbGtfaHcgKmh3OworCisJCXN3aXRjaCAoZGF0YS0+Y2xvY2tz W2ldLnR5cGUpIHsKKwkJY2FzZSBaWF9DTE9DS19QTEw6CisJCQlodyA9IHp4X2Nsa19yZWdpc3Rl cl9wbGwoZGV2LCBtYXAsICZkYXRhLT5jbG9ja3NbaV0ucGxsLCBjbG9ja3MpOworCQkJYnJlYWs7 CisKKwkJY2FzZSBaWF9DTE9DS19GSVhFRF9ESVY6CisJCQlodyA9IHp4X2Nsa19yZWdpc3Rlcl9m aXhlZF9kaXYoZGV2LCAmZGF0YS0+Y2xvY2tzW2ldLmZpeGVkX2RpdiwgY2xvY2tzKTsKKwkJCWJy ZWFrOworCisJCWNhc2UgWlhfQ0xPQ0tfTVVYOgorCQkJaHcgPSB6eF9jbGtfcmVnaXN0ZXJfbXV4 KGRldiwgbWFwLCAmZGF0YS0+Y2xvY2tzW2ldLm11eCwgY2xvY2tzKTsKKwkJCWJyZWFrOworCisJ CWNhc2UgWlhfQ0xPQ0tfRElWOgorCQkJaHcgPSB6eF9jbGtfcmVnaXN0ZXJfZGl2aWRlcihkZXYs IG1hcCwgJmRhdGEtPmNsb2Nrc1tpXS5kaXYsIGNsb2Nrcyk7CisJCQlicmVhazsKKworCQljYXNl IFpYX0NMT0NLX0dBVEU6CisJCQlodyA9IHp4X2Nsa19yZWdpc3Rlcl9nYXRlKGRldiwgbWFwLCAm ZGF0YS0+Y2xvY2tzW2ldLmdhdGUsIGNsb2Nrcyk7CisJCQlicmVhazsKKworCQlkZWZhdWx0Ogor CQkJcmV0dXJuIC1FSU5WQUw7CisJCX0KKworCQlpZiAoSVNfRVJSKGh3KSkKKwkJCXJldHVybiBk ZXZfZXJyX3Byb2JlKGRldiwgUFRSX0VSUihodyksICJGYWlsZWQgdG8gcmVnaXN0ZXIgY2xrICV1 XG4iLCBpKTsKKworCQljbG9ja3NbaV0gPSBodzsKKwl9CisKKwlleHBvcnRzID0gZGV2bV9remFs bG9jKGRldiwgc3RydWN0X3NpemUoZXhwb3J0cywgaHdzLCBkYXRhLT5udW1fZXhwb3J0cyksIEdG UF9LRVJORUwpOworCWlmICghZXhwb3J0cykKKwkJcmV0dXJuIC1FTk9NRU07CisJZXhwb3J0cy0+ bnVtID0gZGF0YS0+bnVtX2V4cG9ydHM7CisKKwlmb3IgKGkgPSAwOyBpIDwgZGF0YS0+bnVtX2V4 cG9ydHM7ICsraSkgeworCQlpZiAoZGF0YS0+ZXhwb3J0c1tpXSA+PSBkYXRhLT5udW1fY2xvY2tz KQorCQkJcmV0dXJuIGRldl9lcnJfcHJvYmUoZGV2LCAtRUlOVkFMLAorCQkJCQkgICAgICJFeHBv cnQgJXUgcG9pbnRzIHRvIG91dCBvZiByYW5nZSBjbG9jayAldVxuIiwKKwkJCQkJICAgICBpLCBk YXRhLT5leHBvcnRzW2ldKTsKKworCQlleHBvcnRzLT5od3NbaV0gPSBjbG9ja3NbZGF0YS0+ZXhw b3J0c1tpXV07CisJfQorCisJZGV2bV9rZnJlZShkZXYsIGNsb2Nrcyk7CisKKwlyZXR1cm4gZGV2 bV9vZl9jbGtfYWRkX2h3X3Byb3ZpZGVyKGRldiwgb2ZfY2xrX2h3X29uZWNlbGxfZ2V0LCBleHBv cnRzKTsKK30KK0VYUE9SVF9TWU1CT0xfTlNfR1BMKHp4X2Nsa19jb21tb25fcHJvYmUsICJaVEVf Q0xLIik7CisKK01PRFVMRV9BVVRIT1IoIlN0ZWZhbiBEw7ZzaW5nZXIgPHN0ZWZhbmRvZXNpbmdl ckBnbWFpbC5jb20+Iik7CitNT0RVTEVfREVTQ1JJUFRJT04oIlpURSBjb21tb24gY2xvY2sgZHJp dmVyIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Nsay96 dGUvY2xrLXp4LmggYi9kcml2ZXJzL2Nsay96dGUvY2xrLXp4LmgKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xNzVmYmJhM2UwYjMKLS0tIC9kZXYvbnVsbAorKysgYi9k cml2ZXJzL2Nsay96dGUvY2xrLXp4LmgKQEAgLTAsMCArMSwxNDIgQEAKKy8qIFNQRFgtTGljZW5z ZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkgKi8KKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjYg U3RlZmFuIETDtnNpbmdlcgorICovCisKKyNpZm5kZWYgX19EUlZfQ0xLX1pYX0gKKyNkZWZpbmUg X19EUlZfQ0xLX1pYX0gKKworI2luY2x1ZGUgPGxpbnV4L2Nsay1wcm92aWRlci5oPgorI2luY2x1 ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgor I2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisKKyNkZWZpbmUgQ0xLX1pYX1BMTF9QUkVQQVJFX0lT X0VOQUJMRQkxCisjZGVmaW5lIENMS19aWF9NQVhfUEFSRU5UUwkJOAorCitlbnVtIHp4X3BhcmVu dF90eXBlIHsKKwlaWF9QQVJFTlRfRlcsCisJWlhfUEFSRU5UX0lELAorfTsKKworc3RydWN0IHp4 X3BhcmVudF9kZXNjIHsKKwllbnVtIHp4X3BhcmVudF90eXBlCQl0eXBlOworCXVuaW9uIHsKKwkJ Y29uc3QgY2hhcgkJKmZ3X25hbWU7CisJCXVuc2lnbmVkIGludAkJaWQ7CisJfTsKK307CisKKyNk ZWZpbmUgUEFSRU5UX0ZXKF9uYW1lKSB7IC50eXBlID0gWlhfUEFSRU5UX0ZXLCAuZndfbmFtZSA9 IChfbmFtZSkgfQorCisjZGVmaW5lIFBBUkVOVF9JRChfaWQpIHsgLnR5cGUgPSBaWF9QQVJFTlRf SUQsIC5pZCA9IChfaWQpIH0KKworc3RhdGljIGlubGluZSBzdHJ1Y3QgY2xrX3BhcmVudF9kYXRh IHp4X2dldF9wYXJlbnQoY29uc3Qgc3RydWN0IHp4X3BhcmVudF9kZXNjICpwLAorCQkJCQkJICAg c3RydWN0IGNsa19odyAqIGNvbnN0ICpjbG9ja3MpCit7CisJc3RydWN0IGNsa19wYXJlbnRfZGF0 YSByZXQgPSB7fTsKKworCXN3aXRjaCAocC0+dHlwZSkgeworCWNhc2UgWlhfUEFSRU5UX0ZXOgor CQlyZXQuZndfbmFtZSA9IHAtPmZ3X25hbWU7CisJCXJldC5pbmRleCA9IC0xOworCQlyZXR1cm4g cmV0OworCisJY2FzZSBaWF9QQVJFTlRfSUQ6CisJCXJldC5odyA9IGNsb2Nrc1twLT5pZF07CisJ CXJldC5pbmRleCA9IC0xOworCQlyZXR1cm4gcmV0OworCX07CisKKwlXQVJOX09OX09OQ0UoMSk7 CisJcmV0dXJuIHJldDsKK30KKworc3RydWN0IHp4X3BsbF9kZXNjIHsKKwljb25zdCBjaGFyCQkJ Km5hbWU7CisJY29uc3Qgc3RydWN0IHp4X3BhcmVudF9kZXNjCSpwYXJlbnRzOworCXVuc2lnbmVk IGludAkJCW51bV9wYXJlbnRzOworCXVuc2lnbmVkIGxvbmcJCQlyYXRlOworCXUxNgkJCQlyZWc7 CisJdTE2CQkJCWZsYWdzOworfTsKKworc3RydWN0IHp4X2ZpeGVkX2RpdmlkZXJfZGVzYyB7CisJ Y29uc3QgY2hhcgkJCSpuYW1lOworCXN0cnVjdCB6eF9wYXJlbnRfZGVzYwkJcGFyZW50OworCXVu c2lnbmVkIGludAkJCWRpdjsKK307CisKK3N0cnVjdCB6eF9tdXhfZGVzYyB7CisJY29uc3QgY2hh cgkJCSpuYW1lOworCWNvbnN0IHN0cnVjdCB6eF9wYXJlbnRfZGVzYwkqcGFyZW50czsKKwl1bnNp Z25lZCBpbnQJCQludW1fcGFyZW50czsKKwl1MTYJCQkJcmVnOworCXU4CQkJCXNoaWZ0LCBzaXpl OworfTsKKworc3RydWN0IHp4X2Rpdl9kZXNjIHsKKwljb25zdCBjaGFyCQkJKm5hbWU7CisJc3Ry dWN0IHp4X3BhcmVudF9kZXNjCQlwYXJlbnQ7CisJdTE2CQkJCXJlZzsKKwl1OAkJCQlzaGlmdCwg c2l6ZTsKK307CisKK3N0cnVjdCB6eF9nYXRlX2Rlc2MgeworCWNvbnN0IGNoYXIJCQkqbmFtZTsK KwlzdHJ1Y3QgenhfcGFyZW50X2Rlc2MJCXBhcmVudDsKKwl1bnNpZ25lZCBsb25nCQkJZmxhZ3M7 CisJdTE2CQkJCXJlZzsKKwl1OAkJCQlzaGlmdDsKK307CisKK2VudW0genhfY2xvY2tfdHlwZSB7 CisJWlhfQ0xPQ0tfSU5WQUxJRCA9IDAsCisJWlhfQ0xPQ0tfUExMLAorCVpYX0NMT0NLX0ZJWEVE X0RJViwKKwlaWF9DTE9DS19NVVgsCisJWlhfQ0xPQ0tfRElWLAorCVpYX0NMT0NLX0dBVEUsCit9 OworCitzdHJ1Y3QgenhfY2xvY2sgeworCWVudW0genhfY2xvY2tfdHlwZSB0eXBlOworCXVuaW9u IHsKKwkJc3RydWN0IHp4X3BsbF9kZXNjIHBsbDsKKwkJc3RydWN0IHp4X2ZpeGVkX2RpdmlkZXJf ZGVzYyBmaXhlZF9kaXY7CisJCXN0cnVjdCB6eF9tdXhfZGVzYyBtdXg7CisJCXN0cnVjdCB6eF9k aXZfZGVzYyBkaXY7CisJCXN0cnVjdCB6eF9nYXRlX2Rlc2MgZ2F0ZTsKKwl9OworfTsKKworc3Ry dWN0IGNsa19odyAqenhfY2xrX3JlZ2lzdGVyX3BsbChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVj dCByZWdtYXAgKnJlZ21hcCwKKwkJCQkgICBjb25zdCBzdHJ1Y3QgenhfcGxsX2Rlc2MgKmRlc2Ms CisJCQkJICAgc3RydWN0IGNsa19odyAqIGNvbnN0ICpjbG9ja3MpOworc3RydWN0IGNsa19odyAq enhfY2xrX3JlZ2lzdGVyX211eChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCByZWdtYXAgKnJl Z21hcCwKKwkJCQkgICBjb25zdCBzdHJ1Y3QgenhfbXV4X2Rlc2MgKmRlc2MsCisJCQkJICAgc3Ry dWN0IGNsa19odyAqIGNvbnN0ICpjbG9ja3MpOworc3RydWN0IGNsa19odyAqenhfY2xrX3JlZ2lz dGVyX2RpdmlkZXIoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcmVnbWFwICpyZWdtYXAsCisJ CQkJICAgICAgIGNvbnN0IHN0cnVjdCB6eF9kaXZfZGVzYyAqZGVzYywKKwkJCQkgICAgICAgc3Ry dWN0IGNsa19odyAqIGNvbnN0ICpjbG9ja3MpOworc3RydWN0IGNsa19odyAqenhfY2xrX3JlZ2lz dGVyX2dhdGUoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcmVnbWFwICpyZWdtYXAsCisJCQkJ ICAgIGNvbnN0IHN0cnVjdCB6eF9nYXRlX2Rlc2MgKmRlc2MsCisJCQkJICAgIHN0cnVjdCBjbGtf aHcgKiBjb25zdCAqY2xvY2tzKTsKKworc3RydWN0IHp4X2Nsa19leHBvcnQgeworCXVuc2lnbmVk IGludCBwcml2OworCXVuc2lnbmVkIGludCBiaW5kaW5nOworfTsKKworc3RydWN0IHp4X2Nsa19k YXRhIHsKKwlpbnQgKCppbml0KShzdHJ1Y3QgcmVnbWFwICptYXApOworCWNvbnN0IHN0cnVjdCB6 eF9jbG9jayAqY2xvY2tzOworCXVuc2lnbmVkIGludCBudW1fY2xvY2tzOworCXVuc2lnbmVkIGlu dCAqZXhwb3J0czsKKwl1bnNpZ25lZCBpbnQgbnVtX2V4cG9ydHM7Cit9OworCitpbnQgenhfY2xr X2NvbW1vbl9wcm9iZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2Vfbm9kZSAqb2Zf bm9kZSwKKwkJCWNvbnN0IHN0cnVjdCB6eF9jbGtfZGF0YSAqZGF0YSk7CisKKyNlbmRpZiAvKiBf X0RSVl9DTEtfWlhfSCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jbGsvenRlL3BsbC16eC5jIGIv ZHJpdmVycy9jbGsvenRlL3BsbC16eC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMC4uZmM3NmM2NTI0YTE2Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9jbGsvenRl L3BsbC16eC5jCkBAIC0wLDAgKzEsMTggQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBH UEwtMi4wLW9ubHkKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjYgU3RlZmFuIETDtnNpbmdlcgor ICovCisKKyNpbmNsdWRlIDxsaW51eC9jbGstcHJvdmlkZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9k ZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgorI2luY2x1ZGUgPGxpbnV4L3JlZ21h cC5oPgorCisjaW5jbHVkZSAiY2xrLXp4LmgiCisKK3N0cnVjdCBjbGtfaHcgKnp4X2Nsa19yZWdp c3Rlcl9wbGwoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcmVnbWFwICpyZWdtYXAsCisJCQkJ ICAgY29uc3Qgc3RydWN0IHp4X3BsbF9kZXNjICpkZXNjLAorCQkJCSAgIHN0cnVjdCBjbGtfaHcg KiBjb25zdCAqY2xvY2tzKQoreworCXJldHVybiBFUlJfUFRSKC1FTk9ERVYpOworfQoKLS0gCjIu NTQuMAoKCi0tIApsaW51eC1waHkgbWFpbGluZyBsaXN0CmxpbnV4LXBoeUBsaXN0cy5pbmZyYWRl YWQub3JnCmh0dHBzOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4 LXBoeQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-wm1-f50.google.com (mail-wm1-f50.google.com [209.85.128.50]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id F2FB62E7BB6 for ; Sun, 2 Aug 2026 20:34:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.50 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1785702873; cv=none; b=XrTUWsDziN4yjx0hU+icaoQMBLt2FegdZUtz+E0oeQQ/PXZ4psH3VWMfdH6BavnaDy4e8ReNTITAIoZXTnlTA+rat17D5y2yPGlD97EcdA2j0tCWWM1UcCKNHu170j9dhDnCMW7CEfJ4kYr6xRN1MdUfOq2QaBx3c81cPkjfC2A= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1785702873; c=relaxed/simple; bh=bliMqz9DYmlGJpuJakC365hV2+7POVwzt1MUpR8IO5k=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=uxfJEP+SGfEdr807iu33uwJolFfCW9cF/ZEHXpJPQOcJ5rff33MwC9i6Wz+ATjCnXSB+/RYvXF360RW1yQ5hes436x9EFNZJXEFzzBZ8tWX6/itch8vuj2WrWv9+YlaHjoSOR4jjW8IxCmfTptikP2yWFrlZ6bDeFLmLCvp69b4= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=bXwnSrMn; arc=none smtp.client-ip=209.85.128.50 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="bXwnSrMn" Received: by mail-wm1-f50.google.com with SMTP id 5b1f17b1804b1-4954a32cf1eso5921665e9.3 for ; Sun, 02 Aug 2026 13:34:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1785702870; x=1786307670; darn=lists.linux.dev; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=g/uJ9rgeBYsc4vYHFy//xAr9TRI8XAnYRm6j0VRl8+k=; b=bXwnSrMnTQe7egI/YwWG+kF91v5PXRfgopGjvBVqbt8tdYYhpd1jDUIIwqtFJyDW9+ bk0oYNqZ/GFiX+2Pe3VNVaDlhAbn/uzd47VkjtkWE4VJEiPvTsDVDbcXKv07G7RgnNTC Z6RDAqb/QUJYaaut4FwxQ0klFiGQzsP3QwkVc3fvpagnPLLgKtOR8tc9Qr1TXNsVPsyG 2XyoAXuDrqGos36qEPRRpPJ6HXVNtaxHAxaWxQAWqq8cLDJCOlI4YPhKG0vBwYvYtJdC SeIxEc/EkhBoij3E/CsMkW+qZbQbnZuBQONzbgY9RBzvmF8CC6y7G9i9ZnXmVGGIv8PZ xUUg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1785702870; x=1786307670; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to :content-type; bh=g/uJ9rgeBYsc4vYHFy//xAr9TRI8XAnYRm6j0VRl8+k=; b=HiQIG1t04qwziYyZhOupzEvb0sqgQNGgP+7CVvkJpYBQvENJxLsI4MrnkqOvo83nBn dbBbba8h61QgTjPN8P0ho145SYNFPX7EVCl6ceeH70S9sOmIdVx37v0ZILRLj5wZuI8X Z76bv7REblJRNKagYagslSZUptszrPoLq3tV1BgTpgtubQyLQD+iZ8QQqHK7CfKymwKd IcrpNO2fHWIywPJoiF00I4KkK871eVpfmVtfMxAcN7KxkGu35/H7OYLyHB61Yk/s41pi YAnMIZnJ6gezjmnYSfpA0I73ft3JKTiliacfSls++C6FuEeItjLdjCm9Bn5lVnytSJUg su1w== X-Forwarded-Encrypted: i=1; AHgh+RqcuJSJkGb1SW3J7kRhBgDQamykVlz1x4ufdJX1KHNMfCkoG7ZV2lhxBr5wet2eMIbH2dU=@lists.linux.dev X-Gm-Message-State: AOJu0YznrzJNmoanMfE66OTdLIh7WUXl7NshsuCTI/KMsG9RV34VR5dO UTWR5Ilbsjrb2N0eZ3Caa7CdckaF1aB/16JjAGw6YSrfPzF3V2c2CYtp X-Gm-Gg: AR+sD10tDvBheaEFjuxLPD5hChvVHSO4bHXoQS5H/6COGbvCWWIAVeVgFGXNXKhv5uj mbdaX6No+WpxoIrtokiegLBhWNA8r1zam2k687eCxSbmGTNrhObYInzecnkQoGPd/sIe+mfCNw6 bdM3eD8N5qWUz3HUVZvcgYoH2yBlpZ/U1tigId4MEfEJHmn87pZPSGDQtQCiPsHzODfAgrv3aiF qyxgeK+OkYAMCWSjNqS541ynvfIF8rEgCsAeKtlon/b1BFpBeifyVkH8T9m+JG+Sb+zoEXaHQ1N mzOyaxhTpftV7Ebf98Vg+xMp1+Q482BID0TU5VNGdf4BvSg7pd6jiD+mPXyIXGz2kkHwE60MOC5 8uY+J0KhPS2SqJeSAJPe89axSyORzVJ7AoQhHUgNBbDxcP2nkVfYJbG0+ELMFgKRB8/kyepoHis Ck+xBecE6o0DXe1fOK4pWNslIlvhdnMRwizgZGtNpN2tX7dUkIfEEsPhZUcRyazodLyJUlRgbw X-Received: by 2002:a05:600d:640f:20b0:495:503f:cf9a with SMTP id 5b1f17b1804b1-4980c672adbmr123140795e9.9.1785702870100; Sun, 02 Aug 2026 13:34:30 -0700 (PDT) Received: from [192.168.0.2] ([197.250.226.155]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49807bb45ebsm118499905e9.4.2026.08.02.13.34.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 02 Aug 2026 13:34:28 -0700 (PDT) From: =?utf-8?q?Stefan_D=C3=B6singer?= Date: Sun, 02 Aug 2026 23:33:37 +0300 Subject: [PATCH v9 05/12] clk: zte: Add Clock registration infrastructure Precedence: bulk X-Mailing-List: mfd@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 8bit Message-Id: <20260802-zx29clk-v9-5-d05530d85d28@gmail.com> References: <20260802-zx29clk-v9-0-d05530d85d28@gmail.com> In-Reply-To: <20260802-zx29clk-v9-0-d05530d85d28@gmail.com> To: Michael Turquette , Stephen Boyd , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel , Brian Masney , Vinod Koul , Neil Armstrong , Russell King , Lee Jones Cc: linux-clk@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-phy@lists.infradead.org, mfd@lists.linux.dev, =?utf-8?q?Stefan_D=C3=B6singer?= X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=15082; i=stefandoesinger@gmail.com; h=from:subject:message-id; bh=bliMqz9DYmlGJpuJakC365hV2+7POVwzt1MUpR8IO5k=; b=owEBiQJ2/ZANAwAIAT0TvMhUTxoiAcsmYgBqb6mykflOEFiu71wc1GczjZPa68Y6TmIpQB2Mi +T4HtQvzsGJAk8EAAEIADkWIQRDFvS2qgVbJ5UyXWw9E7zIVE8aIgUCam+pshsUgAAAAAAEAA5t YW51MiwyLjUrMS4xMiwyLDIACgkQPRO8yFRPGiLobQ//TXe/dYXrjElj9++NCXYloN0vSBLejV0 gEMP3s9qlzMUblSd87qnT4CQkb50Tv30FnyNj7pjkzsQ2I3kCiyl6C/PqIOurRFybJ/SQtGXvPh YcrzMC8fyhCqZCkvaGiJv0c45pNM9Q3efQ/Rg9+5g27Bv9+RA/JbRm7/MDQVQlmDqnLZV3rE+ba 8aQ2SOXJq60FWZE1apDJ4sRXa/17kMCK0sbzmH4YVHzY7IAOyhxHV/TCzibbNfw0Ats8+JGAMuv rTd8U1uYSHwMsHHGlSs5NdnymCzHOfz+obA/rOJPK4g3T/vpqBHPsxcKAWQENKgDwSy5DWw8+Vd hOHXYUXraoGA1EjBDiDFitCG9BdRIUCAQKoXfCNtdNYLuG61eumzhUrSkj0r0FTx0XcS+eLvrAK WSmB9dYyCzwt+AUZDxMT0zGcwkP8smqbn+bMu1HlzKOO/LHBZ7nkxY8vvlPQMHuC0BuCflLCI3N amHObSt4JrYdmJ54i5Nsbw2TymFkq0a35qUXgFc6VVrm0YXyjxhMjARoKYgc9i5srpvhka/Lxkv LyoJe90wuHCx6pLUPjLP8YBKI288PF6iaPscAiY6P8c5ck5Ol0QQ83jmF0zcRuTEx52yFJo4Xp8 CRp/E4uaFLrtJrFIrKNzMMLEFxFS+SvlDQuXKl61ruoKZAo3HZv8= X-Developer-Key: i=stefandoesinger@gmail.com; a=openpgp; fpr=4F9C2C8728019633893EBBB98CB81F9A72BBA155 The next patches will implement the regmap clocks and PLL driver. The actual hardware specific clock listing will live in a separate module. Signed-off-by: Stefan Dösinger --- Version 9: Rework parent matching and clock export control. Most of the changes will be in the next patches. The visible change here is that the clock array is unified with single clocks having a type rather than one array per type. Depend on HAS_IOMEM, similarly to Sashiko's flagged issue in the Reset patch ZX297520V3_CLK_NO_EXPORT is gone again. The explicit clock input array and enabling of LSP's pclk is removed from the clock driver. The MFD parent takes care of this instead. The clock driver does some sanity checking on the static clock data though. Version 8: Use ZX297520V3_CLK_NO_EXPORT=(~0u) for unexported clocks. While using 0, and starting clock indices at 1, is a common pattern in existing drivers, it exposes a driver implementation detail in the hardware binding interface. If desired, I can change the special index to a separate field in the structs. Fix the return value if the ->init() callback fails. (Sashiko) Version 7: *) Add fixed dividers to handle PLL subdivisions *) Never register PLLs directly as exported clocks - everything on this SoC goes through a gate before it leaves a controller. Version 6: *) Remove auxdev now that LSP clocks also use MFD *) Error codepath fixes pointed out by Sashiko. Version 5: *) Pass the static clk data instead of calling get_match_data to prepare for operating as an MFD child. *) Don't use devm_kzalloc to allocate the auxiliary_device structure. I guess Sashiko is right, and that's what "Because once the device is placed on the bus the parent driver can not tell what other code may have a reference to this data" is trying to tell me. *) Fix error check for device_node_to_regmap. --- MAINTAINERS | 1 + drivers/clk/Kconfig | 1 + drivers/clk/Makefile | 1 + drivers/clk/zte/Kconfig | 17 ++++ drivers/clk/zte/Makefile | 5 ++ drivers/clk/zte/clk-regmap.c | 32 ++++++++ drivers/clk/zte/clk-zx.c | 189 +++++++++++++++++++++++++++++++++++++++++++ drivers/clk/zte/clk-zx.h | 142 ++++++++++++++++++++++++++++++++ drivers/clk/zte/pll-zx.c | 18 +++++ 9 files changed, 406 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index b9f96455bca7..77fa86c671b8 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -3915,6 +3915,7 @@ F: Documentation/devicetree/bindings/clock/zte,zx297520v3-matrixcrm.yaml F: Documentation/devicetree/bindings/clock/zte,zx297520v3-topcrm.yaml F: arch/arm/boot/dts/zte/ F: arch/arm/mach-zte/ +F: drivers/clk/zte/ F: drivers/mfd/zte-zx297520v3-crm.c F: include/dt-bindings/clock/zte,zx297520v3-clk.h F: include/dt-bindings/phy/zte,zx297520v3-topcrm.h diff --git a/drivers/clk/Kconfig b/drivers/clk/Kconfig index 1717ce75a907..6f0a863951ca 100644 --- a/drivers/clk/Kconfig +++ b/drivers/clk/Kconfig @@ -545,6 +545,7 @@ source "drivers/clk/uniphier/Kconfig" source "drivers/clk/visconti/Kconfig" source "drivers/clk/x86/Kconfig" source "drivers/clk/xilinx/Kconfig" +source "drivers/clk/zte/Kconfig" source "drivers/clk/zynqmp/Kconfig" # Kunit test cases diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile index 6899e32e14aa..651fe866ddad 100644 --- a/drivers/clk/Makefile +++ b/drivers/clk/Makefile @@ -167,5 +167,6 @@ ifeq ($(CONFIG_COMMON_CLK), y) obj-$(CONFIG_X86) += x86/ endif obj-y += xilinx/ +obj-$(CONFIG_COMMON_CLK_ZTE) += zte/ obj-$(CONFIG_ARCH_ZYNQ) += zynq/ obj-$(CONFIG_COMMON_CLK_ZYNQMP) += zynqmp/ diff --git a/drivers/clk/zte/Kconfig b/drivers/clk/zte/Kconfig new file mode 100644 index 000000000000..152c2423b8f0 --- /dev/null +++ b/drivers/clk/zte/Kconfig @@ -0,0 +1,17 @@ +# SPDX-License-Identifier: GPL-2.0-only +# +# ZTE Clock Drivers +# + +config COMMON_CLK_ZTE + tristate "Clock driver for ZTE SoCs" + depends on HAS_IOMEM + depends on ARCH_ZTE || COMPILE_TEST + default ARCH_ZTE + select MFD_SYSCON + help + This option selects common clock infrastructure for ZTE based SoCs. + You will need to enable one or more SoC specific drivers to make use + of this. + + Enable this if you are building a kernel for a ZTE designed board. diff --git a/drivers/clk/zte/Makefile b/drivers/clk/zte/Makefile new file mode 100644 index 000000000000..27db07293165 --- /dev/null +++ b/drivers/clk/zte/Makefile @@ -0,0 +1,5 @@ +# SPDX-License-Identifier: GPL-2.0-only + +obj-$(CONFIG_COMMON_CLK_ZTE) += clk-zte.o + +clk-zte-y += clk-zx.o pll-zx.o clk-regmap.o diff --git a/drivers/clk/zte/clk-regmap.c b/drivers/clk/zte/clk-regmap.c new file mode 100644 index 000000000000..80332dba97f6 --- /dev/null +++ b/drivers/clk/zte/clk-regmap.c @@ -0,0 +1,32 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2026 Stefan Dösinger + */ + +#include +#include +#include +#include + +#include "clk-zx.h" + +struct clk_hw *zx_clk_register_gate(struct device *dev, struct regmap *regmap, + const struct zx_gate_desc *desc, + struct clk_hw * const *clocks) +{ + return ERR_PTR(-ENODEV); +} + +struct clk_hw *zx_clk_register_divider(struct device *dev, struct regmap *regmap, + const struct zx_div_desc *desc, + struct clk_hw * const *clocks) +{ + return ERR_PTR(-ENODEV); +} + +struct clk_hw *zx_clk_register_mux(struct device *dev, struct regmap *regmap, + const struct zx_mux_desc *desc, + struct clk_hw * const *clocks) +{ + return ERR_PTR(-ENODEV); +} diff --git a/drivers/clk/zte/clk-zx.c b/drivers/clk/zte/clk-zx.c new file mode 100644 index 000000000000..27bbafd8ce4d --- /dev/null +++ b/drivers/clk/zte/clk-zx.c @@ -0,0 +1,189 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2026 Stefan Dösinger + */ + +#include +#include +#include +#include +#include +#include + +#include "clk-zx.h" + +static struct clk_hw *zx_clk_register_fixed_div(struct device *dev, + const struct zx_fixed_divider_desc *desc, + struct clk_hw * const *clocks) +{ + const struct zx_parent_desc *p = &desc->parent; + + switch (p->type) { + case ZX_PARENT_FW: + return devm_clk_hw_register_fixed_factor_fwname(dev, NULL, desc->name, p->fw_name, + CLK_SET_RATE_PARENT, 1, desc->div); + + case ZX_PARENT_ID: + return devm_clk_hw_register_fixed_factor_parent_hw(dev, desc->name, clocks[p->id], + CLK_SET_RATE_PARENT, 1, + desc->div); + } + WARN_ON_ONCE(1); + return ERR_PTR(-EINVAL); +} + +static int zx_clk_validate(struct device *dev, struct device_node *of_node, + const struct zx_clk_data *data) +{ + const struct zx_parent_desc *parents; + unsigned int i, p, num_parents; + struct clk *clk; + + /* + * Sanity check: Make sure all parents are there and write a clear message rather than + * leave potential orphans. + */ + for (i = 0; i < data->num_clocks; ++i) { + switch (data->clocks[i].type) { + case ZX_CLOCK_PLL: + parents = data->clocks[i].pll.parents; + num_parents = data->clocks[i].pll.num_parents; + break; + + case ZX_CLOCK_FIXED_DIV: + parents = &data->clocks[i].fixed_div.parent; + num_parents = 1; + break; + + case ZX_CLOCK_MUX: + parents = data->clocks[i].mux.parents; + num_parents = data->clocks[i].mux.num_parents; + break; + + case ZX_CLOCK_DIV: + parents = &data->clocks[i].div.parent; + num_parents = 1; + break; + + case ZX_CLOCK_GATE: + parents = &data->clocks[i].gate.parent; + num_parents = 1; + break; + + default: + return dev_err_probe(dev, -EINVAL, "Invalid clock entry %u\n", i); + } + + for (p = 0; p < num_parents; ++p) { + switch (parents[p].type) { + case ZX_PARENT_FW: + clk = of_clk_get_by_name(of_node, parents[p].fw_name); + if (IS_ERR(clk)) + return dev_err_probe(dev, PTR_ERR(clk), + "Input clk %s failure\n", + parents[p].fw_name); + clk_put(clk); + break; + + case ZX_PARENT_ID: + if (parents[p].id >= i) + return dev_err_probe(dev, -EINVAL, + "Clock %u has parent %u\n", + i, parents[p].id); + break; + + default: + return dev_err_probe(dev, -EINVAL, + "Clock %u has unexpected parent of type %u\n", + i, parents[p].type); + } + } + } + + return 0; +} + +int zx_clk_common_probe(struct device *dev, struct device_node *of_node, + const struct zx_clk_data *data) +{ + struct clk_hw_onecell_data *exports; + struct clk_hw **clocks; + struct regmap *map; + unsigned int i; + int res; + + res = zx_clk_validate(dev, of_node, data); + if (res) + return res; + + map = device_node_to_regmap(of_node); + if (IS_ERR(map)) + return PTR_ERR(map); + + clocks = devm_kcalloc(dev, data->num_clocks, sizeof(*clocks), GFP_KERNEL); + if (!clocks) + return -ENOMEM; + + if (data->init) { + res = data->init(map); + if (res) + return res; + } + + for (i = 0; i < data->num_clocks; ++i) { + struct clk_hw *hw; + + switch (data->clocks[i].type) { + case ZX_CLOCK_PLL: + hw = zx_clk_register_pll(dev, map, &data->clocks[i].pll, clocks); + break; + + case ZX_CLOCK_FIXED_DIV: + hw = zx_clk_register_fixed_div(dev, &data->clocks[i].fixed_div, clocks); + break; + + case ZX_CLOCK_MUX: + hw = zx_clk_register_mux(dev, map, &data->clocks[i].mux, clocks); + break; + + case ZX_CLOCK_DIV: + hw = zx_clk_register_divider(dev, map, &data->clocks[i].div, clocks); + break; + + case ZX_CLOCK_GATE: + hw = zx_clk_register_gate(dev, map, &data->clocks[i].gate, clocks); + break; + + default: + return -EINVAL; + } + + if (IS_ERR(hw)) + return dev_err_probe(dev, PTR_ERR(hw), "Failed to register clk %u\n", i); + + clocks[i] = hw; + } + + exports = devm_kzalloc(dev, struct_size(exports, hws, data->num_exports), GFP_KERNEL); + if (!exports) + return -ENOMEM; + exports->num = data->num_exports; + + for (i = 0; i < data->num_exports; ++i) { + if (data->exports[i] >= data->num_clocks) + return dev_err_probe(dev, -EINVAL, + "Export %u points to out of range clock %u\n", + i, data->exports[i]); + + exports->hws[i] = clocks[data->exports[i]]; + } + + devm_kfree(dev, clocks); + + return devm_of_clk_add_hw_provider(dev, of_clk_hw_onecell_get, exports); +} +EXPORT_SYMBOL_NS_GPL(zx_clk_common_probe, "ZTE_CLK"); + +MODULE_AUTHOR("Stefan Dösinger "); +MODULE_DESCRIPTION("ZTE common clock driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/clk/zte/clk-zx.h b/drivers/clk/zte/clk-zx.h new file mode 100644 index 000000000000..175fbba3e0b3 --- /dev/null +++ b/drivers/clk/zte/clk-zx.h @@ -0,0 +1,142 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (C) 2026 Stefan Dösinger + */ + +#ifndef __DRV_CLK_ZX_H +#define __DRV_CLK_ZX_H + +#include +#include +#include +#include + +#define CLK_ZX_PLL_PREPARE_IS_ENABLE 1 +#define CLK_ZX_MAX_PARENTS 8 + +enum zx_parent_type { + ZX_PARENT_FW, + ZX_PARENT_ID, +}; + +struct zx_parent_desc { + enum zx_parent_type type; + union { + const char *fw_name; + unsigned int id; + }; +}; + +#define PARENT_FW(_name) { .type = ZX_PARENT_FW, .fw_name = (_name) } + +#define PARENT_ID(_id) { .type = ZX_PARENT_ID, .id = (_id) } + +static inline struct clk_parent_data zx_get_parent(const struct zx_parent_desc *p, + struct clk_hw * const *clocks) +{ + struct clk_parent_data ret = {}; + + switch (p->type) { + case ZX_PARENT_FW: + ret.fw_name = p->fw_name; + ret.index = -1; + return ret; + + case ZX_PARENT_ID: + ret.hw = clocks[p->id]; + ret.index = -1; + return ret; + }; + + WARN_ON_ONCE(1); + return ret; +} + +struct zx_pll_desc { + const char *name; + const struct zx_parent_desc *parents; + unsigned int num_parents; + unsigned long rate; + u16 reg; + u16 flags; +}; + +struct zx_fixed_divider_desc { + const char *name; + struct zx_parent_desc parent; + unsigned int div; +}; + +struct zx_mux_desc { + const char *name; + const struct zx_parent_desc *parents; + unsigned int num_parents; + u16 reg; + u8 shift, size; +}; + +struct zx_div_desc { + const char *name; + struct zx_parent_desc parent; + u16 reg; + u8 shift, size; +}; + +struct zx_gate_desc { + const char *name; + struct zx_parent_desc parent; + unsigned long flags; + u16 reg; + u8 shift; +}; + +enum zx_clock_type { + ZX_CLOCK_INVALID = 0, + ZX_CLOCK_PLL, + ZX_CLOCK_FIXED_DIV, + ZX_CLOCK_MUX, + ZX_CLOCK_DIV, + ZX_CLOCK_GATE, +}; + +struct zx_clock { + enum zx_clock_type type; + union { + struct zx_pll_desc pll; + struct zx_fixed_divider_desc fixed_div; + struct zx_mux_desc mux; + struct zx_div_desc div; + struct zx_gate_desc gate; + }; +}; + +struct clk_hw *zx_clk_register_pll(struct device *dev, struct regmap *regmap, + const struct zx_pll_desc *desc, + struct clk_hw * const *clocks); +struct clk_hw *zx_clk_register_mux(struct device *dev, struct regmap *regmap, + const struct zx_mux_desc *desc, + struct clk_hw * const *clocks); +struct clk_hw *zx_clk_register_divider(struct device *dev, struct regmap *regmap, + const struct zx_div_desc *desc, + struct clk_hw * const *clocks); +struct clk_hw *zx_clk_register_gate(struct device *dev, struct regmap *regmap, + const struct zx_gate_desc *desc, + struct clk_hw * const *clocks); + +struct zx_clk_export { + unsigned int priv; + unsigned int binding; +}; + +struct zx_clk_data { + int (*init)(struct regmap *map); + const struct zx_clock *clocks; + unsigned int num_clocks; + unsigned int *exports; + unsigned int num_exports; +}; + +int zx_clk_common_probe(struct device *dev, struct device_node *of_node, + const struct zx_clk_data *data); + +#endif /* __DRV_CLK_ZX_H */ diff --git a/drivers/clk/zte/pll-zx.c b/drivers/clk/zte/pll-zx.c new file mode 100644 index 000000000000..fc76c6524a16 --- /dev/null +++ b/drivers/clk/zte/pll-zx.c @@ -0,0 +1,18 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2026 Stefan Dösinger + */ + +#include +#include +#include +#include + +#include "clk-zx.h" + +struct clk_hw *zx_clk_register_pll(struct device *dev, struct regmap *regmap, + const struct zx_pll_desc *desc, + struct clk_hw * const *clocks) +{ + return ERR_PTR(-ENODEV); +} -- 2.54.0