From nobody Sun Feb 8 08:48:54 2026 Received: from rtits2.realtek.com.tw (rtits2.realtek.com [211.75.126.72]) (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 9FEF2438FF4; Thu, 22 Jan 2026 11:09:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=211.75.126.72 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080163; cv=none; b=i/fXCPfSEWZJV8WuDwrpfD0frsuYF5+d0bM9Ntp4DuyqVxVRH8kNHNO/IBvOPun2jiZVczUxgAxFYZAqC25l7ii0qJNW0qDH7pseyM6Ky4oQDymEg/FfCQwYovflg1ldgqGCxzUftz7BUUL1W89eL7VC5F3rbV0I6AlmL+78x8s= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080163; c=relaxed/simple; bh=alFGWgp1p5BkR6sYIUcurmq7uXxgelDcXc1YPhczYSM=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=lW3/c1c2ogL1kB4Es5JGa/cOzBzY8mlJ397CHgr6XIdTiUp/7leoldOhLCanemPh3PcyQAQe/sOWiIlbe6aQvYbJd+aeMIF3yQcxKYiae43IA9YQk1uOuX29g6P/9YTxqQinoffohSk00RgP6/NwqCVm4B4/uhTbBMLpoV6KZiU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com; spf=pass smtp.mailfrom=realtek.com; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b=lS7bXC9t; arc=none smtp.client-ip=211.75.126.72 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=realtek.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b="lS7bXC9t" X-SpamFilter-By: ArmorX SpamTrap 5.80 with qID 60MB8w6H2913366, This message is accepted by code: ctloc85258 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=realtek.com; s=dkim; t=1769080138; bh=hRDO13CEjX8/4NXU7fRKODOIQya82AKMnc1f5T5xtiE=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Transfer-Encoding:Content-Type; b=lS7bXC9t7FYLztrj4XHeUQseT6u8aEtOwGRTbefnV4wcGeGdzmWcHfy5S6UG4ltd2 wdaHPbhCX9AtpOoA0Gb9rqICFzgkqy/xXNuIMVFxfn5j8NO38UqFZ+YggiHGtX2/eE QxiQGejy+vDYWxgDGE7l51WNV5hzNEE2SOU7vOy2keQFPUrJeYCls2Xd89WU54CIWD zzPOK7UL8R52YBJOa1It9pb/tSwb1cGjUYaUE+9/7Mfn5w20/A0jlAbepee9WKTAZS m2QQPIWFvf02BfYDxyI7FwHwaRi8aKdJpd91ptHuMkNY90M2BG8tFzaNGaIMj9nt/w mLgl6elSwawYw== Received: from mail.realtek.com (rtkexhmbs03.realtek.com.tw[10.21.1.53]) by rtits2.realtek.com.tw (8.15.2/3.21/5.94) with ESMTPS id 60MB8w6H2913366 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Thu, 22 Jan 2026 19:08:58 +0800 Received: from RTKEXHMBS03.realtek.com.tw (10.21.1.53) by RTKEXHMBS03.realtek.com.tw (10.21.1.53) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.10; Thu, 22 Jan 2026 19:08:58 +0800 Received: from cn1dhc-k02 (172.21.252.101) by RTKEXHMBS03.realtek.com.tw (10.21.1.53) with Microsoft SMTP Server id 15.2.1748.10 via Frontend Transport; Thu, 22 Jan 2026 19:08:58 +0800 From: Yu-Chun Lin To: , , , , , , , CC: , , , , , , , Krzysztof Kozlowski Subject: [PATCH v3 1/9] dt-bindings: clock: Add Realtek RTD1625 Clock & Reset Controller Date: Thu, 22 Jan 2026 19:08:49 +0800 Message-ID: <20260122110857.12995-2-eleanor.lin@realtek.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260122110857.12995-1-eleanor.lin@realtek.com> References: <20260122110857.12995-1-eleanor.lin@realtek.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add DT binding schema for Realtek RTD1625 clock and reset controller Co-developed-by: Cheng-Yu Lee Signed-off-by: Cheng-Yu Lee Signed-off-by: Yu-Chun Lin Reviewed-by: Krzysztof Kozlowski --- Changes in v3: - Converted header file path to the full path. --- .../bindings/clock/realtek,rtd1625-clk.yaml | 51 ++++++ MAINTAINERS | 9 + .../dt-bindings/clock/realtek,rtd1625-clk.h | 164 ++++++++++++++++++ 3 files changed, 224 insertions(+) create mode 100644 Documentation/devicetree/bindings/clock/realtek,rtd1625= -clk.yaml create mode 100644 include/dt-bindings/clock/realtek,rtd1625-clk.h diff --git a/Documentation/devicetree/bindings/clock/realtek,rtd1625-clk.ya= ml b/Documentation/devicetree/bindings/clock/realtek,rtd1625-clk.yaml new file mode 100644 index 000000000000..dae03c17af40 --- /dev/null +++ b/Documentation/devicetree/bindings/clock/realtek,rtd1625-clk.yaml @@ -0,0 +1,51 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/clock/realtek,rtd1625-clk.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Realtek RTD1625 Clock & Reset Controller + +maintainers: + - Yu-Chun Lin + +description: | + The Realtek RTD1625 Clock Controller manages and distributes clock + signals to various controllers and implements a Reset Controller for the + SoC peripherals. + + Clocks are referenced by unique identifiers, which are defined as + preprocessor macros in include/dt-bindings/clock/realtek,rtd1625-clk.h. + +properties: + compatible: + enum: + - realtek,rtd1625-crt-clk + - realtek,rtd1625-iso-clk + - realtek,rtd1625-iso-s-clk + + reg: + maxItems: 1 + + "#clock-cells": + const: 1 + + "#reset-cells": + const: 1 + +required: + - compatible + - reg + - "#clock-cells" + - "#reset-cells" + +additionalProperties: false + +examples: + - | + clock-controller@98000000 { + compatible =3D "realtek,rtd1625-crt-clk"; + reg =3D <98000000 0x1000>; + #clock-cells =3D <1>; + #reset-cells =3D <1>; + }; diff --git a/MAINTAINERS b/MAINTAINERS index 12f49de7fe03..66c0f4924c1e 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -21968,6 +21968,15 @@ S: Maintained F: Documentation/devicetree/bindings/net/dsa/realtek.yaml F: drivers/net/dsa/realtek/* =20 +REALTEK SOC CLOCK AND RESET DRIVERS +M: Cheng-Yu Lee +M: Yu-Chun Lin +L: devicetree@vger.kernel.org +L: linux-clk@vger.kernel.org +S: Supported +F: Documentation/devicetree/bindings/clock/realtek* +F: include/dt-bindings/clock/realtek* + REALTEK SPI-NAND M: Chris Packham S: Maintained diff --git a/include/dt-bindings/clock/realtek,rtd1625-clk.h b/include/dt-b= indings/clock/realtek,rtd1625-clk.h new file mode 100644 index 000000000000..61ca652d6880 --- /dev/null +++ b/include/dt-bindings/clock/realtek,rtd1625-clk.h @@ -0,0 +1,164 @@ +/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) */ +/* + * Copyright (C) 2025 Realtek Semiconductor Corp. + */ +#ifndef __DT_BINDINGS_RTK_CLOCK_RTD1625_H +#define __DT_BINDINGS_RTK_CLOCK_RTD1625_H + +#define RTD1625_CRT_CLK_EN_MISC 0 +#define RTD1625_CRT_CLK_EN_PCIE0 1 +#define RTD1625_CRT_CLK_EN_DIP 2 +#define RTD1625_CRT_CLK_EN_GSPI 3 +#define RTD1625_CRT_CLK_EN_ISO_MISC 5 +#define RTD1625_CRT_CLK_EN_SDS 6 +#define RTD1625_CRT_CLK_EN_HDMI 7 +#define RTD1625_CRT_CLK_EN_GPU 9 +#define RTD1625_CRT_CLK_EN_VE1 10 +#define RTD1625_CRT_CLK_EN_VE2 11 +#define RTD1625_CRT_CLK_EN_MD 18 +#define RTD1625_CRT_CLK_EN_TP 19 +#define RTD1625_CRT_CLK_EN_RCIC 20 +#define RTD1625_CRT_CLK_EN_NF 21 +#define RTD1625_CRT_CLK_EN_EMMC 22 +#define RTD1625_CRT_CLK_EN_SD 23 +#define RTD1625_CRT_CLK_EN_SDIO_IP 24 +#define RTD1625_CRT_CLK_EN_MIPI_CSI 25 +#define RTD1625_CRT_CLK_EN_EMMC_IP 26 +#define RTD1625_CRT_CLK_EN_SDIO 27 +#define RTD1625_CRT_CLK_EN_SD_IP 28 +#define RTD1625_CRT_CLK_EN_TPB 30 +#define RTD1625_CRT_CLK_EN_MISC_SC1 31 +#define RTD1625_CRT_CLK_EN_MISC_I2C_3 32 +#define RTD1625_CRT_CLK_EN_ACPU 33 +#define RTD1625_CRT_CLK_EN_JPEG 34 +#define RTD1625_CRT_CLK_EN_MISC_SC0 37 +#define RTD1625_CRT_CLK_EN_HDMIRX 45 +#define RTD1625_CRT_CLK_EN_HSE 46 +#define RTD1625_CRT_CLK_EN_FAN 49 +#define RTD1625_CRT_CLK_EN_SATA_WRAP_SYS 52 +#define RTD1625_CRT_CLK_EN_SATA_WRAP_SYSH 53 +#define RTD1625_CRT_CLK_EN_SATA_MAC_SYSH 54 +#define RTD1625_CRT_CLK_EN_R2RDSC 55 +#define RTD1625_CRT_CLK_EN_TPC 56 +#define RTD1625_CRT_CLK_EN_PCIE1 57 +#define RTD1625_CRT_CLK_EN_MISC_I2C_4 58 +#define RTD1625_CRT_CLK_EN_MISC_I2C_5 59 +#define RTD1625_CRT_CLK_EN_TSIO 60 +#define RTD1625_CRT_CLK_EN_VE4 61 +#define RTD1625_CRT_CLK_EN_EDP 62 +#define RTD1625_CRT_CLK_EN_TSIO_TRX 63 +#define RTD1625_CRT_CLK_EN_PCIE2 64 +#define RTD1625_CRT_CLK_EN_EARC 66 +#define RTD1625_CRT_CLK_EN_LITE 67 +#define RTD1625_CRT_CLK_EN_MIPI_DSI 68 +#define RTD1625_CRT_CLK_EN_NPUPP 69 +#define RTD1625_CRT_CLK_EN_NPU 70 +#define RTD1625_CRT_CLK_EN_AUCPU0 71 +#define RTD1625_CRT_CLK_EN_AUCPU1 72 +#define RTD1625_CRT_CLK_EN_NSRAM 73 +#define RTD1625_CRT_CLK_EN_HDMITOP 74 +#define RTD1625_CRT_CLK_EN_AUCPU_ISO_NPU 76 +#define RTD1625_CRT_CLK_EN_KEYLADDER 77 +#define RTD1625_CRT_CLK_EN_IFCP_KLM 78 +#define RTD1625_CRT_CLK_EN_IFCP 79 +#define RTD1625_CRT_CLK_EN_MDL_GENPW 80 +#define RTD1625_CRT_CLK_EN_MDL_CHIP 81 +#define RTD1625_CRT_CLK_EN_MDL_IP 82 +#define RTD1625_CRT_CLK_EN_MDLM2M 83 +#define RTD1625_CRT_CLK_EN_MDL_XTAL 84 +#define RTD1625_CRT_CLK_EN_TEST_MUX 85 +#define RTD1625_CRT_CLK_EN_DLA 86 +#define RTD1625_CRT_CLK_EN_TPCW 88 +#define RTD1625_CRT_CLK_EN_GPU_TS_SRC 89 +#define RTD1625_CRT_CLK_EN_VI 91 +#define RTD1625_CRT_CLK_EN_LVDS1 92 +#define RTD1625_CRT_CLK_EN_LVDS2 93 +#define RTD1625_CRT_CLK_EN_AUCPU 94 +#define RTD1625_CRT_CLK_EN_UR1 96 +#define RTD1625_CRT_CLK_EN_UR2 97 +#define RTD1625_CRT_CLK_EN_UR3 98 +#define RTD1625_CRT_CLK_EN_UR4 99 +#define RTD1625_CRT_CLK_EN_UR5 100 +#define RTD1625_CRT_CLK_EN_UR6 101 +#define RTD1625_CRT_CLK_EN_UR7 102 +#define RTD1625_CRT_CLK_EN_UR8 103 +#define RTD1625_CRT_CLK_EN_UR9 104 +#define RTD1625_CRT_CLK_EN_UR_TOP 105 +#define RTD1625_CRT_CLK_EN_MISC_I2C_7 110 +#define RTD1625_CRT_CLK_EN_MISC_I2C_6 111 +#define RTD1625_CRT_CLK_EN_SPI0 112 +#define RTD1625_CRT_CLK_EN_SPI1 113 +#define RTD1625_CRT_CLK_EN_SPI2 114 +#define RTD1625_CRT_CLK_EN_LSADC0 120 +#define RTD1625_CRT_CLK_EN_LSADC1 121 +#define RTD1625_CRT_CLK_EN_ISOMIS_DMA 122 +#define RTD1625_CRT_CLK_EN_DPTX 124 +#define RTD1625_CRT_CLK_EN_NPU_MIPI_CSI 125 +#define RTD1625_CRT_CLK_EN_EDPTX 126 +#define RTD1625_CRT_CLK_HIFI 128 +#define RTD1625_CRT_CLK_NPU_MIPI_CSI 129 +#define RTD1625_CRT_CLK_NPU 130 +#define RTD1625_CRT_CLK_NPU_SYSH 132 +#define RTD1625_CRT_CLK_HIFI_SCPU 133 +#define RTD1625_CRT_CLK_GPU 134 +#define RTD1625_CRT_CLK_GPU2D 135 +#define RTD1625_CRT_CLK_MIPI_DSI_PCLK 136 +#define RTD1625_CRT_CLK_VE1 137 +#define RTD1625_CRT_CLK_VE2 138 +#define RTD1625_CRT_CLK_VE4 139 +#define RTD1625_CRT_CLK_SYS 141 +#define RTD1625_CRT_CLK_SYSH 142 +#define RTD1625_CRT_PLL_SDIO_REF 145 +#define RTD1625_CRT_PLL_CR_REF 146 +#define RTD1625_CRT_PLL_EMMC_REF 147 +#define RTD1625_CRT_CLK_MIS_SC0 148 +#define RTD1625_CRT_CLK_MIS_SC1 149 +#define RTD1625_CRT_PLL_SCPU 150 +#define RTD1625_CRT_PLL_VE1 151 +#define RTD1625_CRT_PLL_DDSA 152 +#define RTD1625_CRT_PLL_PSAUDA1 153 +#define RTD1625_CRT_PLL_PSAUDA2 154 +#define RTD1625_CRT_PLL_BUS 155 +#define RTD1625_CRT_PLL_SDIO 156 +#define RTD1625_CRT_PLL_SDIO_VP0 157 +#define RTD1625_CRT_PLL_SDIO_VP1 158 +#define RTD1625_CRT_PLL_DCSB 159 +#define RTD1625_CRT_PLL_GPU 160 +#define RTD1625_CRT_PLL_NPU 161 +#define RTD1625_CRT_PLL_VE2 162 +#define RTD1625_CRT_PLL_HIFI 163 +#define RTD1625_CRT_PLL_SD 164 +#define RTD1625_CRT_PLL_SD_VP0 165 +#define RTD1625_CRT_PLL_SD_VP1 166 +#define RTD1625_CRT_PLL_EMMC 167 +#define RTD1625_CRT_PLL_EMMC_VP0 168 +#define RTD1625_CRT_PLL_EMMC_VP1 169 +#define RTD1625_CRT_PLL_ACPU 170 +#define RTD1625_CRT_CLK_DET 171 + +#define RTD1625_ISO_CLK_EN_USB_P4 0 +#define RTD1625_ISO_CLK_EN_USB_P3 1 +#define RTD1625_ISO_CLK_EN_MISC_CEC0 2 +#define RTD1625_ISO_CLK_EN_CBUSRX_SYS 3 +#define RTD1625_ISO_CLK_EN_CBUSTX_SYS 4 +#define RTD1625_ISO_CLK_EN_CBUS_SYS 5 +#define RTD1625_ISO_CLK_EN_CBUS_OSC 6 +#define RTD1625_ISO_CLK_EN_MISC_UR0 8 +#define RTD1625_ISO_CLK_EN_I2C0 9 +#define RTD1625_ISO_CLK_EN_I2C1 10 +#define RTD1625_ISO_CLK_EN_ETN_250M 11 +#define RTD1625_ISO_CLK_EN_ETN_SYS 12 +#define RTD1625_ISO_CLK_EN_USB_DRD 13 +#define RTD1625_ISO_CLK_EN_USB_HOST 14 +#define RTD1625_ISO_CLK_EN_USB_U3_HOST 15 +#define RTD1625_ISO_CLK_EN_USB 16 +#define RTD1625_ISO_CLK_EN_VTC 17 +#define RTD1625_ISO_CLK_EN_MISC_VFD 18 + +#define RTD1625_ISO_S_CLK_EN_ISOM_MIS 0 +#define RTD1625_ISO_S_CLK_EN_ISOM_GPIOM 1 +#define RTD1625_ISO_S_CLK_EN_TIMER7 2 +#define RTD1625_ISO_S_CLK_EN_IRDA 3 +#define RTD1625_ISO_S_CLK_EN_UR10 4 + +#endif /* __DT_BINDINGS_RTK_CLOCK_RTD1625_H */ --=20 2.34.1 From nobody Sun Feb 8 08:48:54 2026 Received: from rtits2.realtek.com.tw (rtits2.realtek.com [211.75.126.72]) (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 435E2355044; Thu, 22 Jan 2026 11:09:15 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=211.75.126.72 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080159; cv=none; b=N0HYYUllaZHrAq7laJgAs2hUdoiogQP0O1GKhgvO4f7tMzFbSr1RTTAOS3ZLxgG4whz3ZVEeIG2ROQNo0bvMNXW8P9Da2WmvFxdVnKlSh12I7Igb0p14p6ANlDGkyvWkltjfuVD51CvwesW+bPzWooMhGfb816E0tC/+yve/lCc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080159; c=relaxed/simple; bh=LdvNZ3fiRfVBdcevPEyq1yoH5DQnCSVZ07/fJlEf40I=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=UuR0KxFGdmEduf510a4zpwifWXEngSEVdr1Br3V62V6SkxSvHGKhsaU2VXOMKAD9Q03IoJ28NqVsGHLN9ROps1tTKxoCUMlC5CZmlb8ziOsrAErzvJR1jTiWtMmzlm6DAzBaUMFrSYGUVRx9vdk42sewUm32UNoa4nu4SpE2AQ8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com; spf=pass smtp.mailfrom=realtek.com; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b=ZtAoo31N; arc=none smtp.client-ip=211.75.126.72 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=realtek.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b="ZtAoo31N" X-SpamFilter-By: ArmorX SpamTrap 5.80 with qID 60MB8wZT2913368, This message is accepted by code: ctloc85258 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=realtek.com; s=dkim; t=1769080138; bh=WvcX7Bz904aJMwRrxCICNXyfuFBUFM8BsCtX/ffQhvQ=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Transfer-Encoding:Content-Type; b=ZtAoo31NkDfO2AYz6K2fxu/gBYddi+suyRWZIi/GH6voNDQ0IUnoyi+Eee0lDY16S lTjMx8LNNSRT2GOfuawOmsD0ZVHxv05BpaVl51MjPNbYVy+VyEaEHn3zCDUWcr9NY2 OyMHbdGADsQ79A3SrfE6RxuiiVyHH9d4/EyUEqZKRsnJXJtwsTHN6lcIOf4YTgaCk7 IVpuKAi7sLu+ZoB89qx3LLWCgG+9DVkxvCcCpkY8g2D8kpLUoyxLyiYoeCqn/E6ZGf opU4oF/VkTLITde8BckQsiyCrnhEY5HCZlX7PCcZm9pl92xct+DVg15H6zpPr6ZrG3 q2BpkxFnr4gJQ== Received: from mail.realtek.com (rtkexhmbs04.realtek.com.tw[10.21.1.54]) by rtits2.realtek.com.tw (8.15.2/3.21/5.94) with ESMTPS id 60MB8wZT2913368 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Thu, 22 Jan 2026 19:08:58 +0800 Received: from RTKEXHMBS03.realtek.com.tw (10.21.1.53) by RTKEXHMBS04.realtek.com.tw (10.21.1.54) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.10; Thu, 22 Jan 2026 19:08:58 +0800 Received: from cn1dhc-k02 (172.21.252.101) by RTKEXHMBS03.realtek.com.tw (10.21.1.53) with Microsoft SMTP Server id 15.2.1748.10 via Frontend Transport; Thu, 22 Jan 2026 19:08:58 +0800 From: Yu-Chun Lin To: , , , , , , , CC: , , , , , , Subject: [PATCH v3 2/9] clk: realtek: Add basic reset support Date: Thu, 22 Jan 2026 19:08:50 +0800 Message-ID: <20260122110857.12995-3-eleanor.lin@realtek.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260122110857.12995-1-eleanor.lin@realtek.com> References: <20260122110857.12995-1-eleanor.lin@realtek.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Cheng-Yu Lee Define the reset operations backed by a regmap-based register interface and prepare the reset controller to be registered through the reset framework. Signed-off-by: Cheng-Yu Lee Co-developed-by: Yu-Chun Lin Signed-off-by: Yu-Chun Lin --- Changes in v3: - Reduced the number of IDs per bank from 256 to 32, eliminating unnecessary gaps. - Converted macro to static inline function. - Removed redundant functions. - Used UL() to prevent undefined behavior. --- MAINTAINERS | 1 + drivers/clk/Kconfig | 1 + drivers/clk/Makefile | 1 + drivers/clk/realtek/Kconfig | 28 +++++++++ drivers/clk/realtek/Makefile | 4 ++ drivers/clk/realtek/reset.c | 111 +++++++++++++++++++++++++++++++++++ drivers/clk/realtek/reset.h | 36 +++++++++++ 7 files changed, 183 insertions(+) create mode 100644 drivers/clk/realtek/Kconfig create mode 100644 drivers/clk/realtek/Makefile create mode 100644 drivers/clk/realtek/reset.c create mode 100644 drivers/clk/realtek/reset.h diff --git a/MAINTAINERS b/MAINTAINERS index 66c0f4924c1e..de772e0026de 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -21975,6 +21975,7 @@ L: devicetree@vger.kernel.org L: linux-clk@vger.kernel.org S: Supported F: Documentation/devicetree/bindings/clock/realtek* +F: drivers/clk/realtek/* F: include/dt-bindings/clock/realtek* =20 REALTEK SPI-NAND diff --git a/drivers/clk/Kconfig b/drivers/clk/Kconfig index 3a1611008e48..2f2cacf87c38 100644 --- a/drivers/clk/Kconfig +++ b/drivers/clk/Kconfig @@ -530,6 +530,7 @@ source "drivers/clk/nuvoton/Kconfig" source "drivers/clk/pistachio/Kconfig" source "drivers/clk/qcom/Kconfig" source "drivers/clk/ralink/Kconfig" +source "drivers/clk/realtek/Kconfig" source "drivers/clk/renesas/Kconfig" source "drivers/clk/rockchip/Kconfig" source "drivers/clk/samsung/Kconfig" diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile index 61ec08404442..075a1c410b90 100644 --- a/drivers/clk/Makefile +++ b/drivers/clk/Makefile @@ -141,6 +141,7 @@ obj-$(CONFIG_COMMON_CLK_PISTACHIO) +=3D pistachio/ obj-$(CONFIG_COMMON_CLK_PXA) +=3D pxa/ obj-$(CONFIG_COMMON_CLK_QCOM) +=3D qcom/ obj-y +=3D ralink/ +obj-$(CONFIG_COMMON_CLK_REALTEK) +=3D realtek/ obj-y +=3D renesas/ obj-$(CONFIG_ARCH_ROCKCHIP) +=3D rockchip/ obj-$(CONFIG_COMMON_CLK_SAMSUNG) +=3D samsung/ diff --git a/drivers/clk/realtek/Kconfig b/drivers/clk/realtek/Kconfig new file mode 100644 index 000000000000..121158f11dd1 --- /dev/null +++ b/drivers/clk/realtek/Kconfig @@ -0,0 +1,28 @@ +# SPDX-License-Identifier: GPL-2.0-only +config COMMON_CLK_REALTEK + bool "Clock driver for Realtek SoCs" + depends on ARCH_REALTEK || COMPILE_TEST + select MFD_SYSCON + default y + help + Enable the common clock framework infrastructure for Realtek + system-on-chip platforms. + + This provides the base support required by individual Realtek + clock controller drivers to expose clocks to peripheral devices. + + If you have a Realtek-based platform, say Y. + +if COMMON_CLK_REALTEK + +config RTK_CLK_COMMON + tristate "Realtek Clock Common" + select RESET_CONTROLLER + help + Common helper code shared by Realtek clock controller drivers. + + This provides utility functions and data structures used by + multiple Realtek clock implementations, and include integration + with reset controllers where required. + +endif diff --git a/drivers/clk/realtek/Makefile b/drivers/clk/realtek/Makefile new file mode 100644 index 000000000000..52267de2eef4 --- /dev/null +++ b/drivers/clk/realtek/Makefile @@ -0,0 +1,4 @@ +# SPDX-License-Identifier: GPL-2.0-only +obj-$(CONFIG_RTK_CLK_COMMON) +=3D clk-rtk.o + +clk-rtk-y +=3D reset.o diff --git a/drivers/clk/realtek/reset.c b/drivers/clk/realtek/reset.c new file mode 100644 index 000000000000..4d60a73fc335 --- /dev/null +++ b/drivers/clk/realtek/reset.c @@ -0,0 +1,111 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2019 Realtek Semiconductor Corporation + */ + +#include +#include +#include "reset.h" + +#define RTK_RESET_BANK_SHIFT 5 +#define RTK_RESET_ID_MASK 0x1f + +static inline struct rtk_reset_data *to_rtk_reset_controller(struct reset_= controller_dev *r) +{ + return container_of(r, struct rtk_reset_data, rcdev); +} + +static inline struct rtk_reset_bank * +rtk_reset_get_bank(struct rtk_reset_data *data, unsigned long idx) +{ + int bank_id =3D idx >> RTK_RESET_BANK_SHIFT; + + return &data->banks[bank_id]; +} + +static inline int rtk_reset_get_id(struct rtk_reset_data *data, + unsigned long idx) +{ + return idx & RTK_RESET_ID_MASK; +} + +static int rtk_reset_assert(struct reset_controller_dev *rcdev, + unsigned long idx) +{ + struct rtk_reset_data *data =3D to_rtk_reset_controller(rcdev); + struct rtk_reset_bank *bank =3D rtk_reset_get_bank(data, idx); + u32 id =3D rtk_reset_get_id(data, idx); + u32 mask =3D bank->write_en ? (UL(0x3) << id) : BIT(id); + u32 val =3D bank->write_en ? (UL(0x2) << id) : 0; + + return regmap_update_bits(data->regmap, bank->ofs, mask, val); +} + +static int rtk_reset_deassert(struct reset_controller_dev *rcdev, + unsigned long idx) +{ + struct rtk_reset_data *data =3D to_rtk_reset_controller(rcdev); + struct rtk_reset_bank *bank =3D rtk_reset_get_bank(data, idx); + u32 id =3D rtk_reset_get_id(data, idx); + u32 mask =3D bank->write_en ? (0x3 << id) : BIT(id); + u32 val =3D mask; + + return regmap_update_bits(data->regmap, bank->ofs, mask, val); +} + +static int rtk_reset_reset(struct reset_controller_dev *rcdev, + unsigned long idx) +{ + int ret; + + ret =3D rtk_reset_assert(rcdev, idx); + if (ret) + return ret; + return rtk_reset_deassert(rcdev, idx); +} + +static int rtk_reset_status(struct reset_controller_dev *rcdev, + unsigned long idx) +{ + struct rtk_reset_data *data =3D to_rtk_reset_controller(rcdev); + struct rtk_reset_bank *bank =3D &data->banks[idx >> RTK_RESET_BANK_SHIFT]; + u32 id =3D idx & RTK_RESET_ID_MASK; + u32 val; + int ret; + + ret =3D regmap_read(data->regmap, bank->ofs, &val); + if (ret) + return ret; + + return !((val >> id) & 1); +} + +static const struct reset_control_ops rtk_reset_ops =3D { + .reset =3D rtk_reset_reset, + .assert =3D rtk_reset_assert, + .deassert =3D rtk_reset_deassert, + .status =3D rtk_reset_status, +}; + +int rtk_reset_controller_add(struct device *dev, + struct rtk_reset_initdata *initdata) +{ + struct rtk_reset_data *data; + + data =3D devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); + if (!data) + return -ENOMEM; + + data->dev =3D dev; + data->num_banks =3D initdata->num_banks; + data->banks =3D initdata->banks; + data->regmap =3D initdata->regmap; + data->rcdev.owner =3D THIS_MODULE; + data->rcdev.ops =3D &rtk_reset_ops; + data->rcdev.dev =3D dev; + data->rcdev.of_node =3D dev->of_node; + data->rcdev.nr_resets =3D initdata->num_banks * 32; + + return devm_reset_controller_register(dev, &data->rcdev); +} +EXPORT_SYMBOL_GPL(rtk_reset_controller_add); diff --git a/drivers/clk/realtek/reset.h b/drivers/clk/realtek/reset.h new file mode 100644 index 000000000000..cd446b098429 --- /dev/null +++ b/drivers/clk/realtek/reset.h @@ -0,0 +1,36 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (C) 2019 Realtek Semiconductor Corporation + * Author: Cheng-Yu Lee + */ + +#ifndef __CLK_REALTEK_RESET_H +#define __CLK_REALTEK_RESET_H + +#include +#include +#include + +struct rtk_reset_bank { + u32 ofs; + u32 write_en; +}; + +struct rtk_reset_data { + struct device *dev; + struct reset_controller_dev rcdev; + struct rtk_reset_bank *banks; + u32 num_banks; + struct regmap *regmap; +}; + +struct rtk_reset_initdata { + struct rtk_reset_bank *banks; + u32 num_banks; + struct regmap *regmap; +}; + +int rtk_reset_controller_add(struct device *dev, + struct rtk_reset_initdata *initdata); + +#endif /* __CLK_REALTEK_RESET_H */ --=20 2.34.1 From nobody Sun Feb 8 08:48:54 2026 Received: from rtits2.realtek.com.tw (rtits2.realtek.com [211.75.126.72]) (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 43360332EAF; Thu, 22 Jan 2026 11:09:15 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=211.75.126.72 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080158; cv=none; b=QgZBfs/3ZkecaqXTRk9yqBxQhq7900L8mTRZfwKpvpNghmHg008VyRTwcDlCt7hZ1zLwZivL1ybS2MRyqRcjUmTFFpZLoOiHqcJKHIC9TDndAUqF6csIbh0YK7xcRjeu5JSdq/YJo7mH+yYT1yGvM/LmHH/8PGgA0Uq4b6ee/dk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080158; c=relaxed/simple; bh=cB5FCqLMYPosl//x4hFfDY7sLLOPq5OziY+AyOsIQHY=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=aJNYXPWL6S5q+sY+to6O0hWVdKbcJt4xB3vBp21bF1+hUViUrGhMSJsfAPIglet0rugQBkbyjHiAaddqkR5J3EvR5RjZRw+KJUdNEJdpnAuwCue4eCQasMJDRSot5sm6tr6/HrqYxy/eLis2GQHZ9zvacUaucLCaVD/MVLbPbB0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com; spf=pass smtp.mailfrom=realtek.com; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b=MuFpldoi; arc=none smtp.client-ip=211.75.126.72 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=realtek.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b="MuFpldoi" X-SpamFilter-By: ArmorX SpamTrap 5.80 with qID 60MB8wj36913370, This message is accepted by code: ctloc85258 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=realtek.com; s=dkim; t=1769080138; bh=C49V+bKpMIX5oRf9GDZOGvdktiUHOYIk5vTUR3yTe9c=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Transfer-Encoding:Content-Type; b=MuFpldoiTPH8L+geYNG5mFQ0s3S6foTkZQu84fDuGUu6Q+b3QvHbC4EB1bb1yIM80 6u//Nu/h0evgYqZBfAF5uQCsKNf6GfNQ9PJ+B+CoamZQlNWNi/Hb6TEmqz0ZTzstMP Xj5HHtC0DfOZU6TiWK4eRYhifbpBXN6Z1eR+awxtzjv99Y/Zwm9rvrf5lj5VmbX5cN /3mb3DtQzIg1FE237GVc17bXND54V0G5dbxuhQaWUaZ3sLhAHWQDqKPt4l5iMe/2c1 b51IcEzH/KtSpsApbcJ5dqFBfTaE2zk5u8rDxGXeHi5t8fKbetW3y/FE++lOtqMAGn 6hZy4P1mA9JZg== Received: from mail.realtek.com (rtkexhmbs04.realtek.com.tw[10.21.1.54]) by rtits2.realtek.com.tw (8.15.2/3.21/5.94) with ESMTPS id 60MB8wj36913370 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Thu, 22 Jan 2026 19:08:58 +0800 Received: from RTKEXHMBS03.realtek.com.tw (10.21.1.53) by RTKEXHMBS04.realtek.com.tw (10.21.1.54) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.10; Thu, 22 Jan 2026 19:08:58 +0800 Received: from cn1dhc-k02 (172.21.252.101) by RTKEXHMBS03.realtek.com.tw (10.21.1.53) with Microsoft SMTP Server id 15.2.1748.10 via Frontend Transport; Thu, 22 Jan 2026 19:08:58 +0800 From: Yu-Chun Lin To: , , , , , , , CC: , , , , , , Subject: [PATCH v3 3/9] clk: realtek: Introduce a common probe() Date: Thu, 22 Jan 2026 19:08:51 +0800 Message-ID: <20260122110857.12995-4-eleanor.lin@realtek.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260122110857.12995-1-eleanor.lin@realtek.com> References: <20260122110857.12995-1-eleanor.lin@realtek.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Cheng-Yu Lee Add rtk_clk_probe() to set up the shared regmap, register clock hardware, add the clock provider, and optionally register a reset controller when reset bank data is provided. Signed-off-by: Cheng-Yu Lee Co-developed-by: Yu-Chun Lin Signed-off-by: Yu-Chun Lin --- Changes in v3: - Converted macro to static inline function. - Removed the redundant header. --- drivers/clk/realtek/Makefile | 1 + drivers/clk/realtek/common.c | 64 ++++++++++++++++++++++++++++++++++++ drivers/clk/realtek/common.h | 43 ++++++++++++++++++++++++ 3 files changed, 108 insertions(+) create mode 100644 drivers/clk/realtek/common.c create mode 100644 drivers/clk/realtek/common.h diff --git a/drivers/clk/realtek/Makefile b/drivers/clk/realtek/Makefile index 52267de2eef4..4041951b7c62 100644 --- a/drivers/clk/realtek/Makefile +++ b/drivers/clk/realtek/Makefile @@ -1,4 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-only obj-$(CONFIG_RTK_CLK_COMMON) +=3D clk-rtk.o =20 +clk-rtk-y +=3D common.o clk-rtk-y +=3D reset.o diff --git a/drivers/clk/realtek/common.c b/drivers/clk/realtek/common.c new file mode 100644 index 000000000000..c6540d36560c --- /dev/null +++ b/drivers/clk/realtek/common.c @@ -0,0 +1,64 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2019 Realtek Semiconductor Corporation + * Author: Cheng-Yu Lee + */ + +#include +#include +#include +#include +#include "common.h" + +int rtk_clk_probe(struct platform_device *pdev, const struct rtk_clk_desc = *desc) +{ + int i, ret; + struct regmap *regmap; + struct device *dev =3D &pdev->dev; + struct rtk_reset_initdata reset_initdata =3D {0}; + + regmap =3D device_node_to_regmap(pdev->dev.of_node); + if (IS_ERR(regmap)) + return dev_err_probe(dev, PTR_ERR(regmap), "failed to get regmap\n"); + + for (i =3D 0; i < desc->num_clks; i++) + desc->clks[i]->regmap =3D regmap; + + for (i =3D 0; i < desc->clk_data->num; i++) { + struct clk_hw *hw =3D desc->clk_data->hws[i]; + + if (!hw) + continue; + + ret =3D devm_clk_hw_register(dev, hw); + + if (ret) { + dev_warn(dev, "failed to register hw of clk%d: %d\n", i, + ret); + desc->clk_data->hws[i] =3D NULL; + } + } + + ret =3D devm_of_clk_add_hw_provider(dev, of_clk_hw_onecell_get, + desc->clk_data); + if (ret) + return dev_err_probe(dev, ret, "failed to add clock provider\n"); + + if (!desc->num_reset_banks) + return 0; + + if (!desc->reset_banks) + return dev_err_probe(dev, -EINVAL, + "Missing reset banks data though num_reset_banks is %zu\n", + desc->num_reset_banks); + + reset_initdata.regmap =3D regmap; + reset_initdata.num_banks =3D desc->num_reset_banks; + reset_initdata.banks =3D desc->reset_banks; + + return rtk_reset_controller_add(dev, &reset_initdata); +} +EXPORT_SYMBOL_GPL(rtk_clk_probe); + +MODULE_DESCRIPTION("Realtek clock infrastructure"); +MODULE_LICENSE("GPL"); diff --git a/drivers/clk/realtek/common.h b/drivers/clk/realtek/common.h new file mode 100644 index 000000000000..4e2cc9650a23 --- /dev/null +++ b/drivers/clk/realtek/common.h @@ -0,0 +1,43 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (C) 2016-2019 Realtek Semiconductor Corporation + * Author: Cheng-Yu Lee + */ + +#ifndef __CLK_REALTEK_COMMON_H +#define __CLK_REALTEK_COMMON_H + +#include +#include +#include +#include +#include +#include "reset.h" + +#define __clk_regmap_hw(_p) ((_p)->hw) + +struct device; +struct platform_device; + +struct clk_regmap { + struct clk_hw hw; + struct regmap *regmap; +}; + +struct rtk_clk_desc { + struct clk_hw_onecell_data *clk_data; + struct clk_regmap **clks; + size_t num_clks; + struct rtk_reset_bank *reset_banks; + size_t num_reset_banks; +}; + +static inline struct clk_regmap *to_clk_regmap(struct clk_hw *hw) +{ + return container_of(hw, struct clk_regmap, hw); +} + +int rtk_clk_probe(struct platform_device *pdev, + const struct rtk_clk_desc *desc); + +#endif /* __CLK_REALTEK_COMMON_H */ --=20 2.34.1 From nobody Sun Feb 8 08:48:54 2026 Received: from rtits2.realtek.com.tw (rtits2.realtek.com [211.75.126.72]) (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 5E087357708; Thu, 22 Jan 2026 11:09:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=211.75.126.72 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080159; cv=none; b=gcYuYMQ6OJ4RSskLLPWKda3HB06AV6sW+CeHkOHxWYD+jKwujb8igO0U6Okw5wUk8Jz8v0Kqg/j26uCHy3PTvxK3glYteXHTaUycm4upwSdRnSWC3voQX32NVZ3YbK4dRfIZU0hlfaV7BntOgLwXLanqEO+Di5oWb7ij1MgekcE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080159; c=relaxed/simple; bh=aAbgNN9SALEn2fChz6CqjV7dqN0AhIzrgqG1Pnp13Uk=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=YEjwC85MTfCD1pJt3WEYm+b+U0pHlhSDgByskKn2jCnQKQxKF6voVgXZ8bFQcWaFl5z3s1bYeS7UMOLpa2C5invxtzJBuAiCTRZfLidQM3cdFheORNZGneyO9LAQ3tV02Q8DUS5S+xMw1IkiLuqd1pPBpnKg807CUO1tO3zwMQ0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com; spf=pass smtp.mailfrom=realtek.com; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b=eJ4IgP3f; arc=none smtp.client-ip=211.75.126.72 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=realtek.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b="eJ4IgP3f" X-SpamFilter-By: ArmorX SpamTrap 5.80 with qID 60MB8wqaE913374, This message is accepted by code: ctloc85258 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=realtek.com; s=dkim; t=1769080138; bh=KTKcIZIOss9PaQowWpp2+g7OLWhLwICORzy4CB8Grqk=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Transfer-Encoding:Content-Type; b=eJ4IgP3frV/NdiWhbhYlYYVRWti9e8WcMWhOlbWZ8XgQA2i4oaUtWeo8UPduVNZ5N N+RIGrOObAmPf1IScclC5u8CDYWL/nVnM0Fhvr1jZTIeaZ/xFC2IpgrQnf5+ZVRajj 3fMSpr5nobQpjtlOKJ+qIXCWNDkBUnRwM4shStK9O8CVxHf5foSl/AodXWSer4/RCD ZvmxvWYRgW/iAdHbrixCCt9TeoaCghcLywiH2zPMMqTNIPBYLcl6VRhXbXf9XtY/tY pUL83o3Dl/gCkZ4STixjRYFa/XHc2by+gEYFFvdppkm2HAfqJdrf4AmCnuqtNS8QHv AJGCEu8K2Rxdg== Received: from mail.realtek.com (rtkexhmbs04.realtek.com.tw[10.21.1.54]) by rtits2.realtek.com.tw (8.15.2/3.21/5.94) with ESMTPS id 60MB8wqaE913374 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Thu, 22 Jan 2026 19:08:58 +0800 Received: from RTKEXHMBS03.realtek.com.tw (10.21.1.53) by RTKEXHMBS04.realtek.com.tw (10.21.1.54) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.10; Thu, 22 Jan 2026 19:08:58 +0800 Received: from cn1dhc-k02 (172.21.252.101) by RTKEXHMBS03.realtek.com.tw (10.21.1.53) with Microsoft SMTP Server id 15.2.1748.10 via Frontend Transport; Thu, 22 Jan 2026 19:08:58 +0800 From: Yu-Chun Lin To: , , , , , , , CC: , , , , , , Subject: [PATCH v3 4/9] clk: realtek: Add support for phase locked loops (PLLs) Date: Thu, 22 Jan 2026 19:08:52 +0800 Message-ID: <20260122110857.12995-5-eleanor.lin@realtek.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260122110857.12995-1-eleanor.lin@realtek.com> References: <20260122110857.12995-1-eleanor.lin@realtek.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Cheng-Yu Lee Provide a full set of PLL operations for programmable PLLs and a read-only variant for fixed or hardware-managed PLLs. Signed-off-by: Cheng-Yu Lee Co-developed-by: Yu-Chun Lin Signed-off-by: Yu-Chun Lin --- Changes in v3: - Removed redundant functions. - Replaced Read-Modify-Write operations in clk_pll_set_rate with regmap_update_bits() - Added prefix "rtk_" in operation names to avoid duplicate symbol problem. --- drivers/clk/realtek/Makefile | 2 + drivers/clk/realtek/clk-pll.c | 156 +++++++++++++++++++++++++++++++ drivers/clk/realtek/clk-pll.h | 47 ++++++++++ drivers/clk/realtek/freq_table.c | 35 +++++++ drivers/clk/realtek/freq_table.h | 23 +++++ 5 files changed, 263 insertions(+) create mode 100644 drivers/clk/realtek/clk-pll.c create mode 100644 drivers/clk/realtek/clk-pll.h create mode 100644 drivers/clk/realtek/freq_table.c create mode 100644 drivers/clk/realtek/freq_table.h diff --git a/drivers/clk/realtek/Makefile b/drivers/clk/realtek/Makefile index 4041951b7c62..c173ea3b10e3 100644 --- a/drivers/clk/realtek/Makefile +++ b/drivers/clk/realtek/Makefile @@ -2,4 +2,6 @@ obj-$(CONFIG_RTK_CLK_COMMON) +=3D clk-rtk.o =20 clk-rtk-y +=3D common.o +clk-rtk-y +=3D clk-pll.o +clk-rtk-y +=3D freq_table.o clk-rtk-y +=3D reset.o diff --git a/drivers/clk/realtek/clk-pll.c b/drivers/clk/realtek/clk-pll.c new file mode 100644 index 000000000000..6bb9084956b8 --- /dev/null +++ b/drivers/clk/realtek/clk-pll.c @@ -0,0 +1,156 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2024 Realtek Semiconductor Corporation + * Author: Cheng-Yu Lee + */ + +#include "clk-pll.h" + +#define TIMEOUT 2000 + +static int wait_freq_ready(struct clk_pll *clkp) +{ + u32 pollval; + + if (!clkp->freq_ready_valid) + return 0; + + return regmap_read_poll_timeout_atomic(clkp->clkr.regmap, clkp->freq_read= y_reg, pollval, + (pollval & clkp->freq_ready_mask) + =3D=3D clkp->freq_ready_val, 0, TIMEOUT); +} + +static bool is_power_on(struct clk_pll *clkp) +{ + u32 val; + + if (!clkp->power_reg) + return true; + + if (regmap_read(clkp->clkr.regmap, clkp->power_reg, &val)) + return true; + + return (val & clkp->power_mask) =3D=3D clkp->power_val_on; +} + +static void clk_pll_disable(struct clk_hw *hw) +{ + struct clk_pll *clkp =3D to_clk_pll(hw); + + if (!clkp->seq_power_off) + return; + + regmap_multi_reg_write(clkp->clkr.regmap, clkp->seq_power_off, + clkp->num_seq_power_off); +} + +static int clk_pll_is_enabled(struct clk_hw *hw) +{ + struct clk_pll *clkp =3D to_clk_pll(hw); + + return is_power_on(clkp); +} + +static int clk_pll_determine_rate(struct clk_hw *hw, + struct clk_rate_request *req) +{ + struct clk_pll *clkp =3D to_clk_pll(hw); + const struct freq_table *ftblv =3D NULL; + + ftblv =3D ftbl_find_by_rate(clkp->freq_tbl, req->rate); + if (!ftblv) + return -EINVAL; + + req->rate =3D ftblv->rate; + return 0; +} + +static unsigned long clk_pll_recalc_rate(struct clk_hw *hw, + unsigned long parent_rate) +{ + struct clk_pll *clkp =3D to_clk_pll(hw); + const struct freq_table *fv; + u32 freq_val; + + if (regmap_read(clkp->clkr.regmap, clkp->freq_reg, &freq_val)) + return 0; + + freq_val &=3D clkp->freq_mask; + + fv =3D ftbl_find_by_val_with_mask(clkp->freq_tbl, clkp->freq_mask, + freq_val); + return fv ? fv->rate : 0; +} + +static int clk_pll_set_rate(struct clk_hw *hw, unsigned long rate, + unsigned long parent_rate) +{ + struct clk_pll *clkp =3D to_clk_pll(hw); + const struct freq_table *fv; + int ret; + + fv =3D ftbl_find_by_rate(clkp->freq_tbl, rate); + if (!fv || fv->rate !=3D rate) + return -EINVAL; + + if (clkp->seq_pre_set_freq) { + ret =3D regmap_multi_reg_write(clkp->clkr.regmap, clkp->seq_pre_set_freq, + clkp->num_seq_pre_set_freq); + if (ret) + return ret; + } + + ret =3D regmap_update_bits(clkp->clkr.regmap, clkp->freq_reg, + clkp->freq_mask, fv->val); + if (ret) + return ret; + + if (clkp->seq_post_set_freq) { + ret =3D regmap_multi_reg_write(clkp->clkr.regmap, clkp->seq_post_set_fre= q, + clkp->num_seq_post_set_freq); + if (ret) + return ret; + } + + if (is_power_on(clkp)) { + ret =3D wait_freq_ready(clkp); + if (ret) + return ret; + } + + return 0; +} + +static int clk_pll_enable(struct clk_hw *hw) +{ + struct clk_pll *clkp =3D to_clk_pll(hw); + int ret; + + if (!clkp->seq_power_on) + return 0; + + if (is_power_on(clkp)) + return 0; + + ret =3D regmap_multi_reg_write(clkp->clkr.regmap, clkp->seq_power_on, + clkp->num_seq_power_on); + if (ret) + return ret; + + return wait_freq_ready(clkp); +} + +const struct clk_ops rtk_clk_pll_ops =3D { + .enable =3D clk_pll_enable, + .disable =3D clk_pll_disable, + .is_enabled =3D clk_pll_is_enabled, + .recalc_rate =3D clk_pll_recalc_rate, + .determine_rate =3D clk_pll_determine_rate, + .set_rate =3D clk_pll_set_rate, +}; +EXPORT_SYMBOL_GPL(rtk_clk_pll_ops); + +const struct clk_ops rtk_clk_pll_ro_ops =3D { + .recalc_rate =3D clk_pll_recalc_rate, +}; +EXPORT_SYMBOL_GPL(rtk_clk_pll_ro_ops); diff --git a/drivers/clk/realtek/clk-pll.h b/drivers/clk/realtek/clk-pll.h new file mode 100644 index 000000000000..2d27a44a270c --- /dev/null +++ b/drivers/clk/realtek/clk-pll.h @@ -0,0 +1,47 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (C) 2017-2019 Realtek Semiconductor Corporation + * Author: Cheng-Yu Lee + */ + +#ifndef __CLK_REALTEK_CLK_PLL_H +#define __CLK_REALTEK_CLK_PLL_H + +#include "common.h" +#include "freq_table.h" + +struct clk_pll { + struct clk_regmap clkr; + const struct reg_sequence *seq_power_on; + u32 num_seq_power_on; + const struct reg_sequence *seq_power_off; + u32 num_seq_power_off; + const struct reg_sequence *seq_pre_set_freq; + u32 num_seq_pre_set_freq; + const struct reg_sequence *seq_post_set_freq; + u32 num_seq_post_set_freq; + const struct freq_table *freq_tbl; + u32 freq_reg; + u32 freq_mask; + u32 freq_ready_valid; + u32 freq_ready_mask; + u32 freq_ready_reg; + u32 freq_ready_val; + u32 power_reg; + u32 power_mask; + u32 power_val_on; +}; + +#define __clk_pll_hw(_ptr) __clk_regmap_hw(&(_ptr)->clkr) + +static inline struct clk_pll *to_clk_pll(struct clk_hw *hw) +{ + struct clk_regmap *clkr =3D to_clk_regmap(hw); + + return container_of(clkr, struct clk_pll, clkr); +} + +extern const struct clk_ops rtk_clk_pll_ops; +extern const struct clk_ops rtk_clk_pll_ro_ops; + +#endif /* __CLK_REALTEK_CLK_PLL_H */ diff --git a/drivers/clk/realtek/freq_table.c b/drivers/clk/realtek/freq_ta= ble.c new file mode 100644 index 000000000000..26a0d2d3e851 --- /dev/null +++ b/drivers/clk/realtek/freq_table.c @@ -0,0 +1,35 @@ +// SPDX-License-Identifier: GPL-2.0-only + +#include "freq_table.h" + +const struct freq_table *ftbl_find_by_rate(const struct freq_table *ftbl, + unsigned long rate) +{ + unsigned long best_rate =3D 0; + const struct freq_table *best =3D NULL; + + for (; !IS_FREQ_TABLE_END(ftbl); ftbl++) { + if (ftbl->rate =3D=3D rate) + return ftbl; + + if (ftbl->rate > rate) + continue; + + if (ftbl->rate > best_rate) { + best_rate =3D ftbl->rate; + best =3D ftbl; + } + } + + return best; +} + +const struct freq_table * +ftbl_find_by_val_with_mask(const struct freq_table *ftbl, u32 mask, u32 va= lue) +{ + for (; !IS_FREQ_TABLE_END(ftbl); ftbl++) { + if ((ftbl->val & mask) =3D=3D (value & mask)) + return ftbl; + } + return NULL; +}; diff --git a/drivers/clk/realtek/freq_table.h b/drivers/clk/realtek/freq_ta= ble.h new file mode 100644 index 000000000000..383ae939fd1e --- /dev/null +++ b/drivers/clk/realtek/freq_table.h @@ -0,0 +1,23 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +#include + +struct freq_table { + u32 val; + unsigned long rate; +}; + +/* ofs check */ +#define CLK_OFS_INVALID -1 +#define CLK_OFS_IS_VALID(_ofs) ((_ofs) !=3D CLK_OFS_INVALID) + +#define FREQ_TABLE_END \ + { \ + .rate =3D 0 \ + } +#define IS_FREQ_TABLE_END(_f) ((_f)->rate =3D=3D 0) + +const struct freq_table *ftbl_find_by_rate(const struct freq_table *ftbl, + unsigned long rate); +const struct freq_table * +ftbl_find_by_val_with_mask(const struct freq_table *ftbl, u32 mask, u32 va= lue); --=20 2.34.1 From nobody Sun Feb 8 08:48:54 2026 Received: from rtits2.realtek.com.tw (rtits2.realtek.com [211.75.126.72]) (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 4328B32D45C; Thu, 22 Jan 2026 11:09:15 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=211.75.126.72 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080158; cv=none; b=T4Y0vBMhlppV7xZrPBpxGyNSqRT9KFz4ocuJTbh2I5iaeIeTg3/2MrgsLQ3sU9I4vC1FRG3Lcw6wiFyywrnn8LL6dWyJT6Svl9+eHczbPhxBbDZWqfXSaBq/y7Q1BsvTWvEa2k+G9dqq0hUx8B5KbdTRGLQDShadJ00fHGQM4BI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080158; c=relaxed/simple; bh=UWN3KUh5QJPwDmN/mDTQ/7mSa2zu+dylTwu6JO+CqXo=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=ho5OZS1chSqjLMV6GetGC7qX8J4NsaWxFtdruT9otToS2YwAvM4Qrhx//M7Jt5pTMZy5+/EWxD9IXBWLL5RP6fjwBMis91Br9K97aYHfWKTTLZcHFjcwMy3WK+YvDmlq4hRY7X4ipdWW0ru3uECO5lDqm3ZeNaeX70Txon54r/8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com; spf=pass smtp.mailfrom=realtek.com; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b=aOmXVB/J; arc=none smtp.client-ip=211.75.126.72 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=realtek.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b="aOmXVB/J" X-SpamFilter-By: ArmorX SpamTrap 5.80 with qID 60MB8xbqE913376, This message is accepted by code: ctloc85258 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=realtek.com; s=dkim; t=1769080139; bh=2Hr0SVkGdLxP6gyEWjIqZZOW+w18/vvplNsMPRZvYBY=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Transfer-Encoding:Content-Type; b=aOmXVB/Jc41VnnsUKx3M3/7wBPOm3DoyVqoY6lS2vdgvAYQ1dpqpXgCmvPJJcpAKv 8ZctugDh+hYS7XUxP9lMy2pNWHzs5lOTRh2sfVWTixo2UbrBd5z7XsCN9g6bNerT4e p/mZqggitxhdryCkiQghf4O6g1uLjXetLb7mnj9LDlJny83/13HxHktI/LW8PGYWUZ tBMMP11Zmigm/B3W1zRUVhEqK96EWdmaG60OIpV2zPPUAK2qPsuhIT9MaJO+4she2C c8WE29xw2iSKUpcC4kA3NdQRSJJhDsEhX+HAur5QNronKnOAy9wgbNNgJs5qr2Ow92 J1x/APYbHERZQ== Received: from mail.realtek.com (rtkexhmbs03.realtek.com.tw[10.21.1.53]) by rtits2.realtek.com.tw (8.15.2/3.21/5.94) with ESMTPS id 60MB8xbqE913376 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Thu, 22 Jan 2026 19:08:59 +0800 Received: from RTKEXHMBS03.realtek.com.tw (10.21.1.53) by RTKEXHMBS03.realtek.com.tw (10.21.1.53) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.10; Thu, 22 Jan 2026 19:08:59 +0800 Received: from cn1dhc-k02 (172.21.252.101) by RTKEXHMBS03.realtek.com.tw (10.21.1.53) with Microsoft SMTP Server id 15.2.1748.10 via Frontend Transport; Thu, 22 Jan 2026 19:08:59 +0800 From: Yu-Chun Lin To: , , , , , , , CC: , , , , , , Subject: [PATCH v3 5/9] clk: realtek: Add support for gate clock Date: Thu, 22 Jan 2026 19:08:53 +0800 Message-ID: <20260122110857.12995-6-eleanor.lin@realtek.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260122110857.12995-1-eleanor.lin@realtek.com> References: <20260122110857.12995-1-eleanor.lin@realtek.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Cheng-Yu Lee Introduce clk_regmap_gate_ops supporting enable, disable, is_enabled, and disable_unused for standard regmap gate clocks. Add clk_regmap_gate_ro_ops as a read-only variant exposing only is_enabled. Signed-off-by: Cheng-Yu Lee Co-developed-by: Yu-Chun Lin Signed-off-by: Yu-Chun Lin --- Changes in v3: - Added prefix "rtk_" in operation names to avoid duplicate symbol problem. --- drivers/clk/realtek/Makefile | 2 + drivers/clk/realtek/clk-regmap-gate.c | 66 +++++++++++++++++++++++++++ drivers/clk/realtek/clk-regmap-gate.h | 65 ++++++++++++++++++++++++++ 3 files changed, 133 insertions(+) create mode 100644 drivers/clk/realtek/clk-regmap-gate.c create mode 100644 drivers/clk/realtek/clk-regmap-gate.h diff --git a/drivers/clk/realtek/Makefile b/drivers/clk/realtek/Makefile index c173ea3b10e3..97058d48a176 100644 --- a/drivers/clk/realtek/Makefile +++ b/drivers/clk/realtek/Makefile @@ -2,6 +2,8 @@ obj-$(CONFIG_RTK_CLK_COMMON) +=3D clk-rtk.o =20 clk-rtk-y +=3D common.o + clk-rtk-y +=3D clk-pll.o +clk-rtk-y +=3D clk-regmap-gate.o clk-rtk-y +=3D freq_table.o clk-rtk-y +=3D reset.o diff --git a/drivers/clk/realtek/clk-regmap-gate.c b/drivers/clk/realtek/cl= k-regmap-gate.c new file mode 100644 index 000000000000..5174283c2c21 --- /dev/null +++ b/drivers/clk/realtek/clk-regmap-gate.c @@ -0,0 +1,66 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2017 Realtek Semiconductor Corporation + * Author: Cheng-Yu Lee + */ + +#include "clk-regmap-gate.h" + +static int clk_regmap_gate_enable(struct clk_hw *hw) +{ + struct clk_regmap_gate *clkg =3D to_clk_regmap_gate(hw); + unsigned int mask; + unsigned int val; + + mask =3D BIT(clkg->bit_idx); + val =3D BIT(clkg->bit_idx); + + if (clkg->write_en) { + mask |=3D BIT(clkg->bit_idx + 1); + val |=3D BIT(clkg->bit_idx + 1); + } + + return regmap_update_bits(clkg->clkr.regmap, clkg->gate_ofs, mask, val); +} + +static void clk_regmap_gate_disable(struct clk_hw *hw) +{ + struct clk_regmap_gate *clkg =3D to_clk_regmap_gate(hw); + unsigned int mask; + unsigned int val; + + mask =3D BIT(clkg->bit_idx); + val =3D 0; + + if (clkg->write_en) { + mask |=3D BIT(clkg->bit_idx + 1); + val |=3D BIT(clkg->bit_idx + 1); + } + + regmap_update_bits(clkg->clkr.regmap, clkg->gate_ofs, mask, val); +} + +static int clk_regmap_gate_is_enabled(struct clk_hw *hw) +{ + struct clk_regmap_gate *clkg =3D to_clk_regmap_gate(hw); + int ret; + u32 val; + + ret =3D regmap_read(clkg->clkr.regmap, clkg->gate_ofs, &val); + if (ret < 0) + return ret; + + return !!(val & BIT(clkg->bit_idx)); +} + +const struct clk_ops rtk_clk_regmap_gate_ops =3D { + .enable =3D clk_regmap_gate_enable, + .disable =3D clk_regmap_gate_disable, + .is_enabled =3D clk_regmap_gate_is_enabled, +}; +EXPORT_SYMBOL_GPL(rtk_clk_regmap_gate_ops); + +const struct clk_ops rtk_clk_regmap_gate_ro_ops =3D { + .is_enabled =3D clk_regmap_gate_is_enabled, +}; +EXPORT_SYMBOL_GPL(rtk_clk_regmap_gate_ro_ops); diff --git a/drivers/clk/realtek/clk-regmap-gate.h b/drivers/clk/realtek/cl= k-regmap-gate.h new file mode 100644 index 000000000000..b93357bd5a0d --- /dev/null +++ b/drivers/clk/realtek/clk-regmap-gate.h @@ -0,0 +1,65 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (C) 2017 Realtek Semiconductor Corporation + * Author: Cheng-Yu Lee + */ + +#ifndef __CLK_REALTEK_CLK_REGMAP_GATE_H +#define __CLK_REALTEK_CLK_REGMAP_GATE_H + +#include "common.h" + +struct clk_regmap_gate { + struct clk_regmap clkr; + int gate_ofs; + u8 bit_idx; + u32 write_en : 1; +}; + +#define __clk_regmap_gate_hw(_p) __clk_regmap_hw(&(_p)->clkr) + +#define __CLK_REGMAP_GATE(_name, _parent, _ops, _flags, _ofs, _bit_idx, = \ + _write_en) \ + struct clk_regmap_gate _name =3D { \ + .clkr.hw.init =3D CLK_HW_INIT(#_name, _parent, _ops, _flags), \ + .gate_ofs =3D _ofs, \ + .bit_idx =3D _bit_idx, \ + .write_en =3D _write_en, \ + } + +#define CLK_REGMAP_GATE(_name, _parent, _flags, _ofs, _bit_idx, _write_en)= \ + __CLK_REGMAP_GATE(_name, _parent, &rtk_clk_regmap_gate_ops, _flags, _ofs,= \ + _bit_idx, _write_en) + +#define CLK_REGMAP_GATE_RO(_name, _parent, _flags, _ofs, _bit_idx, _write_= en) \ + __CLK_REGMAP_GATE(_name, _parent, &rtk_clk_regmap_gate_ro_ops, _flags, = \ + _ofs, _bit_idx, _write_en) + +#define __CLK_REGMAP_GATE_NO_PARENT(_name, _ops, _flags, _ofs, _bit_idx, = \ + _write_en) \ + struct clk_regmap_gate _name =3D { \ + .clkr.hw.init =3D CLK_HW_INIT_NO_PARENT(#_name, _ops, _flags), \ + .gate_ofs =3D _ofs, \ + .bit_idx =3D _bit_idx, \ + .write_en =3D _write_en, \ + } + +#define CLK_REGMAP_GATE_NO_PARENT(_name, _flags, _ofs, _bit_idx, _write_en= ) \ + __CLK_REGMAP_GATE_NO_PARENT(_name, &rtk_clk_regmap_gate_ops, _flags, _ofs= , \ + _bit_idx, _write_en) + +#define CLK_REGMAP_GATE_NO_PARENT_RO(_name, _flags, _ofs, _bit_idx, _write= _en) \ + __CLK_REGMAP_GATE_NO_PARENT(_name, &rtk_clk_regmap_gate_ro_ops, _flags, = \ + _ofs, _bit_idx, _write_en) + +static inline struct clk_regmap_gate *to_clk_regmap_gate(struct clk_hw *hw) +{ + struct clk_regmap *clkr =3D to_clk_regmap(hw); + + return container_of(clkr, struct clk_regmap_gate, clkr); +} + +extern const struct clk_ops rtk_clk_regmap_gate_ops; +extern const struct clk_ops rtk_clk_regmap_gate_ro_ops; + +#endif /* __CLK_REALTEK_CLK_REGMAP_GATE_H */ --=20 2.34.1 From nobody Sun Feb 8 08:48:54 2026 Received: from rtits2.realtek.com.tw (rtits2.realtek.com [211.75.126.72]) (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 4342634FF7D; Thu, 22 Jan 2026 11:09:15 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=211.75.126.72 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080158; cv=none; b=WE2AAlxL6Ma2yCjPvpVvloo+RGukejxAXo7Mluz8UXlVC+4BVCxxzforvtKX5ynjEn+n6+SC33A+LD6sc+O91Sjo2beNugfR744IAQKzkthCYoLhBXgITMAbY4360LfVaLQlBVEnLtAWelaCTyCSVpyrp4umyUpRcpd/NBNxnGg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080158; c=relaxed/simple; bh=/JYwT+m4z0xzlhaHr6MbOU8ks66lEYSBa6ahDncfZUQ=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=DzW9r37sWslUfaMnZjU4cQ+DnJZc/84RXp2rrszmxTr7F+BBHjNTepSAFLp2U/IokFYAKtsR976RemtBJAWwvrym5cyYjESd2NvudxC43cXi8bIBNyGUdEW8ucLs9aPYsaAnR41zRnKd6FG/d23/A2d173NWj7awOA0RrUfUQKk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com; spf=pass smtp.mailfrom=realtek.com; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b=NLqGfp+p; arc=none smtp.client-ip=211.75.126.72 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=realtek.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b="NLqGfp+p" X-SpamFilter-By: ArmorX SpamTrap 5.80 with qID 60MB8xvmE913378, This message is accepted by code: ctloc85258 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=realtek.com; s=dkim; t=1769080139; bh=qebyPywROpho6QC+bM/2rjzPYcqbnnu7SqXdd+Jqmq0=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Transfer-Encoding:Content-Type; b=NLqGfp+pbIyGPhG3B9yR5UXB5g/74WQn7HZ3qSwAQDZhQfHjqakF5gOjDFXzraQnb KGdgu/iL3KO39f8LZfQ50xF1iuIzq4rek15qFmMp+duvydrrpWG5gY+/CuXC03hvTJ oA5kLxOX84Z3DvJyj8kkHwbWuG829pNHr0b+g5/VAwSbfvKOra8/6+/WHvOBZb8ARM KTH0qgCJk4qsH4RwCd+5owQ4n6Sb3wKerOdgQzcPNOIAUiRW+xws2/dNwlHcpWV198 8xsYJRgRGX0rsv/s7dk/QClDVcI5R3dKqa4f+EqIF2Zu67QdSwMKm6ofrNDBYQqfps U+qXvO26/hotA== Received: from mail.realtek.com (rtkexhmbs02.realtek.com.tw[172.21.6.41]) by rtits2.realtek.com.tw (8.15.2/3.21/5.94) with ESMTPS id 60MB8xvmE913378 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Thu, 22 Jan 2026 19:08:59 +0800 Received: from RTKEXHMBS05.realtek.com.tw (10.21.1.55) by RTKEXHMBS02.realtek.com.tw (172.21.6.41) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.10; Thu, 22 Jan 2026 19:08:59 +0800 Received: from RTKEXHMBS03.realtek.com.tw (10.21.1.53) by RTKEXHMBS05.realtek.com.tw (10.21.1.55) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.10; Thu, 22 Jan 2026 19:08:59 +0800 Received: from cn1dhc-k02 (172.21.252.101) by RTKEXHMBS03.realtek.com.tw (10.21.1.53) with Microsoft SMTP Server id 15.2.1748.10 via Frontend Transport; Thu, 22 Jan 2026 19:08:59 +0800 From: Yu-Chun Lin To: , , , , , , , CC: , , , , , , Subject: [PATCH v3 6/9] clk: realtek: Add support for mux clock Date: Thu, 22 Jan 2026 19:08:54 +0800 Message-ID: <20260122110857.12995-7-eleanor.lin@realtek.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260122110857.12995-1-eleanor.lin@realtek.com> References: <20260122110857.12995-1-eleanor.lin@realtek.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Cheng-Yu Lee Add a simple regmap-based clk_ops implementation for Realtek mux clocks. The implementation supports parent selection and rate determination through regmap-backed register access. Signed-off-by: Cheng-Yu Lee Co-developed-by: Yu-Chun Lin Signed-off-by: Yu-Chun Lin --- Changes in v3: - Added prefix "rtk_" in operation names to avoid duplicate symbol problem. --- drivers/clk/realtek/Makefile | 1 + drivers/clk/realtek/clk-regmap-mux.c | 46 ++++++++++++++++++++++++++++ drivers/clk/realtek/clk-regmap-mux.h | 43 ++++++++++++++++++++++++++ 3 files changed, 90 insertions(+) create mode 100644 drivers/clk/realtek/clk-regmap-mux.c create mode 100644 drivers/clk/realtek/clk-regmap-mux.h diff --git a/drivers/clk/realtek/Makefile b/drivers/clk/realtek/Makefile index 97058d48a176..b40dd5a26653 100644 --- a/drivers/clk/realtek/Makefile +++ b/drivers/clk/realtek/Makefile @@ -5,5 +5,6 @@ clk-rtk-y +=3D common.o =20 clk-rtk-y +=3D clk-pll.o clk-rtk-y +=3D clk-regmap-gate.o +clk-rtk-y +=3D clk-regmap-mux.o clk-rtk-y +=3D freq_table.o clk-rtk-y +=3D reset.o diff --git a/drivers/clk/realtek/clk-regmap-mux.c b/drivers/clk/realtek/clk= -regmap-mux.c new file mode 100644 index 000000000000..d1612de2e2bc --- /dev/null +++ b/drivers/clk/realtek/clk-regmap-mux.c @@ -0,0 +1,46 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2017 Realtek Semiconductor Corporation + * Author: Cheng-Yu Lee + */ + +#include "clk-regmap-mux.h" + +static u8 clk_regmap_mux_get_parent(struct clk_hw *hw) +{ + struct clk_regmap_mux *clkm =3D to_clk_regmap_mux(hw); + int num_parents =3D clk_hw_get_num_parents(hw); + u32 val; + int ret; + + ret =3D regmap_read(clkm->clkr.regmap, clkm->mux_ofs, &val); + if (ret) + return 0; + + val =3D val >> clkm->shift & clkm->mask; + + if (val >=3D num_parents) + return 0; + + return val; +} + +static int clk_regmap_mux_set_parent(struct clk_hw *hw, u8 index) +{ + struct clk_regmap_mux *clkm =3D to_clk_regmap_mux(hw); + + return regmap_update_bits(clkm->clkr.regmap, clkm->mux_ofs, + clkm->mask << clkm->shift, index << clkm->shift); +} + +const struct clk_ops rtk_clk_regmap_mux_ops =3D { + .set_parent =3D clk_regmap_mux_set_parent, + .get_parent =3D clk_regmap_mux_get_parent, + .determine_rate =3D __clk_mux_determine_rate, +}; +EXPORT_SYMBOL_GPL(rtk_clk_regmap_mux_ops); + +const struct clk_ops rtk_clk_regmap_mux_ro_ops =3D { + .get_parent =3D clk_regmap_mux_get_parent, +}; +EXPORT_SYMBOL_GPL(rtk_clk_regmap_mux_ro_ops); diff --git a/drivers/clk/realtek/clk-regmap-mux.h b/drivers/clk/realtek/clk= -regmap-mux.h new file mode 100644 index 000000000000..cf7ab6a0604c --- /dev/null +++ b/drivers/clk/realtek/clk-regmap-mux.h @@ -0,0 +1,43 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (C) 2017 Realtek Semiconductor Corporation + * Author: Cheng-Yu Lee + */ + +#ifndef __CLK_REALTEK_CLK_REGMAP_MUX_H +#define __CLK_REALTEK_CLK_REGMAP_MUX_H + +#include "common.h" + +struct clk_regmap_mux { + struct clk_regmap clkr; + int mux_ofs; + unsigned int mask; + unsigned int shift; +}; + +#define __clk_regmap_mux_hw(_p) __clk_regmap_hw(&(_p)->clkr) + +#define __CLK_REGMAP_MUX(_name, _parents, _ops, _flags, _ofs, _sft, _mask)= \ + struct clk_regmap_mux _name =3D { \ + .clkr.hw.init =3D \ + CLK_HW_INIT_PARENTS(#_name, _parents, _ops, _flags), \ + .mux_ofs =3D _ofs, \ + .shift =3D _sft, \ + .mask =3D _mask, \ + } + +#define CLK_REGMAP_MUX(_name, _parents, _flags, _ofs, _sft, _mask) = \ + __CLK_REGMAP_MUX(_name, _parents, &rtk_clk_regmap_mux_ops, _flags, _ofs, \ + _sft, _mask) + +static inline struct clk_regmap_mux *to_clk_regmap_mux(struct clk_hw *hw) +{ + struct clk_regmap *clkr =3D to_clk_regmap(hw); + + return container_of(clkr, struct clk_regmap_mux, clkr); +} + +extern const struct clk_ops rtk_clk_regmap_mux_ops; + +#endif /* __CLK_REALTEK_CLK_REGMAP_MUX_H */ --=20 2.34.1 From nobody Sun Feb 8 08:48:54 2026 Received: from rtits2.realtek.com.tw (rtits2.realtek.com [211.75.126.72]) (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 B95463B8D4E; Thu, 22 Jan 2026 11:09:17 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=211.75.126.72 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080161; cv=none; b=VgrcKcg4rOznqI0y7m9kY+q1l/J7lBUhF4xne2LXyhyswW/H06aA5w/h3CLl8qK0TNDo64sFRJTBne22Rf4l5zkMpQXCKe770/O/8KwQ0+Dj3BHSZQEwjWp1/DsuBKOiY98tEV7PCYvFjns4jxjkM12wPGHfhZyAEv81Kyrhuds= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080161; c=relaxed/simple; bh=IEsLQpoh6ZRrron3Ez/vLvm/TMw8y+eEtUr4GS+fgJY=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=droLzc1xg90Jh6tgtWs7pOUWiOSxOgKjYllpaDhUubOpou4t4ZbG7jzlTi8Idr58xtj7+Bz+AODKV4ffNNWt6M3UYRIuy3xly1VTfAXCQoJdRy8nTCbBuXWELU1AqIqIlQJiBAemEXXQa3qsIEgyL26+FR62HrVl35MqJMbqi38= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com; spf=pass smtp.mailfrom=realtek.com; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b=Imkse55o; arc=none smtp.client-ip=211.75.126.72 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=realtek.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b="Imkse55o" X-SpamFilter-By: ArmorX SpamTrap 5.80 with qID 60MB8xvS6913381, This message is accepted by code: ctloc85258 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=realtek.com; s=dkim; t=1769080140; bh=QJeqLrY+Rt5ThncP4gODehPVu6yh1M97vozwQkT/D/o=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Transfer-Encoding:Content-Type; b=Imkse55ozpVMw/vwunTewUuLGVtmvLVUfxYXgibsL7SS2jLlR/YlmWLxXNyLNcsw6 cLjG+j+6MkxOZcyFVR6lee234xUcz+hRYkHc56hjPe687fjVhvfWls7LGcq5rB/o2K J3pdI4+hn/rUaR1Md9THwdQ2IJDoxM4Moym8cZfMEJxRG51NBlrWlZGp/x4hbqUPn5 ExyTR15h8GOXNK9qB4/mZE5Z1y0a2IAP6w+5erbZlEVML2OuX3vhbY1t1GzzmVY9KX 9hHD6i6FjQOt4aD0/DieTLOM+OSmPVAW7N/1FpqwrfhtF95VQuceSlEcgF81VEb70I hzD+gJ34h6stA== Received: from mail.realtek.com (rtkexhmbs04.realtek.com.tw[10.21.1.54]) by rtits2.realtek.com.tw (8.15.2/3.21/5.94) with ESMTPS id 60MB8xvS6913381 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Thu, 22 Jan 2026 19:08:59 +0800 Received: from RTKEXHMBS05.realtek.com.tw (10.21.1.55) by RTKEXHMBS04.realtek.com.tw (10.21.1.54) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.10; Thu, 22 Jan 2026 19:09:00 +0800 Received: from RTKEXHMBS03.realtek.com.tw (10.21.1.53) by RTKEXHMBS05.realtek.com.tw (10.21.1.55) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.10; Thu, 22 Jan 2026 19:08:59 +0800 Received: from cn1dhc-k02 (172.21.252.101) by RTKEXHMBS03.realtek.com.tw (10.21.1.53) with Microsoft SMTP Server id 15.2.1748.10 via Frontend Transport; Thu, 22 Jan 2026 19:08:59 +0800 From: Yu-Chun Lin To: , , , , , , , CC: , , , , , , Subject: [PATCH v3 7/9] clk: realtek: Add support for MMC-tuned PLL clocks Date: Thu, 22 Jan 2026 19:08:55 +0800 Message-ID: <20260122110857.12995-8-eleanor.lin@realtek.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260122110857.12995-1-eleanor.lin@realtek.com> References: <20260122110857.12995-1-eleanor.lin@realtek.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Cheng-Yu Lee Add clk_pll_mmc_ops for enable/disable, prepare, rate control, and status operations on MMC PLL clocks. Also add clk_pll_mmc_phase_ops to support phase get/set operations. Signed-off-by: Cheng-Yu Lee Co-developed-by: Jyan Chou Signed-off-by: Jyan Chou Co-developed-by: Yu-Chun Lin Signed-off-by: Yu-Chun Lin --- Changes in v3: - Added prefix "rtk_" in operation names to avoid duplicate symbol problem. --- MAINTAINERS | 8 + drivers/clk/realtek/Kconfig | 3 + drivers/clk/realtek/Makefile | 2 + drivers/clk/realtek/clk-pll-mmc.c | 399 ++++++++++++++++++++++++++++++ drivers/clk/realtek/clk-pll.h | 21 ++ 5 files changed, 433 insertions(+) create mode 100644 drivers/clk/realtek/clk-pll-mmc.c diff --git a/MAINTAINERS b/MAINTAINERS index de772e0026de..5b8c0d9eebaa 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -21978,6 +21978,14 @@ F: Documentation/devicetree/bindings/clock/realtek* F: drivers/clk/realtek/* F: include/dt-bindings/clock/realtek* =20 +REALTEK SOC PLL CLOCK FOR MMC SUPPORT +M: Cheng-Yu Lee +M: Jyan Chou +M: Yu-Chun Lin +L: linux-clk@vger.kernel.org +S: Supported +F: drivers/clk/realtek/clk-pll-mmc.c + REALTEK SPI-NAND M: Chris Packham S: Maintained diff --git a/drivers/clk/realtek/Kconfig b/drivers/clk/realtek/Kconfig index 121158f11dd1..de462c2bb892 100644 --- a/drivers/clk/realtek/Kconfig +++ b/drivers/clk/realtek/Kconfig @@ -25,4 +25,7 @@ config RTK_CLK_COMMON multiple Realtek clock implementations, and include integration with reset controllers where required. =20 +config RTK_CLK_PLL_MMC + bool + endif diff --git a/drivers/clk/realtek/Makefile b/drivers/clk/realtek/Makefile index b40dd5a26653..3d5c93e79dbd 100644 --- a/drivers/clk/realtek/Makefile +++ b/drivers/clk/realtek/Makefile @@ -8,3 +8,5 @@ clk-rtk-y +=3D clk-regmap-gate.o clk-rtk-y +=3D clk-regmap-mux.o clk-rtk-y +=3D freq_table.o clk-rtk-y +=3D reset.o + +clk-rtk-$(CONFIG_RTK_CLK_PLL_MMC) +=3D clk-pll-mmc.o diff --git a/drivers/clk/realtek/clk-pll-mmc.c b/drivers/clk/realtek/clk-pl= l-mmc.c new file mode 100644 index 000000000000..017663738c1f --- /dev/null +++ b/drivers/clk/realtek/clk-pll-mmc.c @@ -0,0 +1,399 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2021 Realtek Semiconductor Corporation + * Author: Cheng-Yu Lee + */ + +#include "clk-pll.h" + +#define PLL_EMMC1_OFFSET 0x0 +#define PLL_EMMC2_OFFSET 0x4 +#define PLL_EMMC3_OFFSET 0x8 +#define PLL_EMMC4_OFFSET 0xc +#define PLL_SSC_DIG_EMMC1_OFFSET 0x0 +#define PLL_SSC_DIG_EMMC3_OFFSET 0xc +#define PLL_SSC_DIG_EMMC4_OFFSET 0x10 + +#define PLL_MMC_SSC_DIV_N_VAL 0x1b + +#define PLL_PHRT0_MASK BIT(1) +#define PLL_PHSEL_MASK GENMASK(4, 0) +#define PLL_SSCPLL_RS_MASK GENMASK(12, 10) +#define PLL_SSCPLL_ICP_MASK GENMASK(9, 5) +#define PLL_SSC_DIV_EXT_F_MASK GENMASK(25, 13) +#define PLL_PI_IBSELH_MASK GENMASK(28, 27) +#define PLL_SSC_DIV_N_MASK GENMASK(23, 16) +#define PLL_NCODE_SSC_EMMC_MASK GENMASK(20, 13) +#define PLL_FCODE_SSC_EMMC_MASK GENMASK(12, 0) +#define PLL_GRAN_EST_EM_MC_MASK GENMASK(20, 0) +#define PLL_EN_SSC_EMMC_MASK BIT(0) +#define PLL_FLAG_INITAL_EMMC_MASK BIT(1) + +#define PLL_PHRT0_SHIFT 1 +#define PLL_SSCPLL_RS_SHIFT 10 +#define PLL_SSCPLL_ICP_SHIFT 5 +#define PLL_SSC_DIV_EXT_F_SHIFT 13 +#define PLL_PI_IBSELH_SHIFT 27 +#define PLL_SSC_DIV_N_SHIFT 16 +#define PLL_NCODE_SSC_EMMC_SHIFT 13 +#define PLL_FLAG_INITAL_EMMC_SHIFT 8 + +#define CYCLE_DEGREES 360 +#define PHASE_STEPS 32 +#define PHASE_SCALE_FACTOR 1125 + +static inline int get_phrt0(struct clk_pll_mmc *clkm, u32 *val) +{ + u32 reg; + int ret; + + ret =3D regmap_read(clkm->clkr.regmap, clkm->pll_ofs + PLL_EMMC1_OFFSET, = ®); + if (ret) + return ret; + + *val =3D (reg >> PLL_PHRT0_SHIFT) & PLL_PHRT0_MASK; + return 0; +} + +static inline int set_phrt0(struct clk_pll_mmc *clkm, u32 val) +{ + return regmap_update_bits(clkm->clkr.regmap, clkm->pll_ofs + PLL_EMMC1_OF= FSET, + PLL_PHRT0_MASK, val << PLL_PHRT0_SHIFT); +} + +static inline int get_phsel(struct clk_pll_mmc *clkm, int id, u32 *val) +{ + int ret; + u32 raw_val; + u32 sft =3D id ? 8 : 3; + + ret =3D regmap_read(clkm->clkr.regmap, clkm->pll_ofs + PLL_EMMC1_OFFSET, = &raw_val); + if (ret) + return ret; + + *val =3D (raw_val >> sft) & PLL_PHSEL_MASK; + return 0; +} + +static inline int set_phsel(struct clk_pll_mmc *clkm, int id, u32 val) +{ + u32 sft =3D id ? 8 : 3; + + return regmap_update_bits(clkm->clkr.regmap, clkm->pll_ofs + PLL_EMMC1_OF= FSET, + PLL_PHSEL_MASK << sft, val << sft); +} + +static inline int set_sscpll_rs(struct clk_pll_mmc *clkm, u32 val) +{ + return regmap_update_bits(clkm->clkr.regmap, clkm->pll_ofs + PLL_EMMC2_OF= FSET, + PLL_SSCPLL_RS_MASK, val << PLL_SSCPLL_RS_SHIFT); +} + +static inline int set_sscpll_icp(struct clk_pll_mmc *clkm, u32 val) +{ + return regmap_update_bits(clkm->clkr.regmap, clkm->pll_ofs + PLL_EMMC2_OF= FSET, + PLL_SSCPLL_ICP_MASK, val << PLL_SSCPLL_ICP_SHIFT); +} + +static inline int get_ssc_div_ext_f(struct clk_pll_mmc *clkm, u32 *val) +{ + u32 raw_val; + int ret; + + ret =3D regmap_read(clkm->clkr.regmap, clkm->pll_ofs + PLL_EMMC2_OFFSET, = &raw_val); + if (ret) + return ret; + + *val =3D (raw_val & PLL_SSC_DIV_EXT_F_MASK) >> PLL_SSC_DIV_EXT_F_SHIFT; + return 0; +} + +static inline int set_ssc_div_ext_f(struct clk_pll_mmc *clkm, u32 val) +{ + return regmap_update_bits(clkm->clkr.regmap, clkm->pll_ofs + PLL_EMMC2_OF= FSET, + PLL_SSC_DIV_EXT_F_MASK, + val << PLL_SSC_DIV_EXT_F_SHIFT); +} + +static inline int set_pi_ibselh(struct clk_pll_mmc *clkm, u32 val) +{ + return regmap_update_bits(clkm->clkr.regmap, clkm->pll_ofs + PLL_EMMC2_OF= FSET, + PLL_PI_IBSELH_MASK, val << PLL_PI_IBSELH_SHIFT); +} + +static inline int set_ssc_div_n(struct clk_pll_mmc *clkm, u32 val) +{ + return regmap_update_bits(clkm->clkr.regmap, clkm->pll_ofs + PLL_EMMC3_OF= FSET, + PLL_SSC_DIV_N_MASK, val << PLL_SSC_DIV_N_SHIFT); +} + +static inline int get_ssc_div_n(struct clk_pll_mmc *clkm, u32 *val) +{ + int ret; + u32 raw_val; + + ret =3D regmap_read(clkm->clkr.regmap, clkm->pll_ofs + PLL_EMMC3_OFFSET, = &raw_val); + if (ret) + return ret; + + *val =3D (raw_val & PLL_SSC_DIV_N_MASK) >> PLL_SSC_DIV_N_SHIFT; + return 0; +} + +static inline int set_pow_ctl(struct clk_pll_mmc *clkm, u32 val) +{ + return regmap_write(clkm->clkr.regmap, clkm->pll_ofs + PLL_EMMC4_OFFSET, = val); +} + +static inline int get_pow_ctl(struct clk_pll_mmc *clkm, u32 *val) +{ + int ret; + u32 raw_val; + + ret =3D regmap_read(clkm->clkr.regmap, clkm->pll_ofs + PLL_EMMC4_OFFSET, = &raw_val); + + *val =3D raw_val; + + return ret; +} + +static int clk_pll_mmc_phase_set_phase(struct clk_hw *hw, int degrees) +{ + struct clk_hw *hwp =3D clk_hw_get_parent(hw); + struct clk_pll_mmc *clkm; + int phase_id; + u32 val; + int ret; + + if (!hwp) + return -ENOENT; + + clkm =3D to_clk_pll_mmc(hwp); + phase_id =3D (hw - &clkm->phase0_hw) ? 1 : 0; + val =3D DIV_ROUND_CLOSEST(degrees * 100, PHASE_SCALE_FACTOR); + ret =3D set_phsel(clkm, phase_id, val); + if (ret) + return ret; + + usleep_range(10, 20); + return 0; +} + +static int clk_pll_mmc_phase_get_phase(struct clk_hw *hw) +{ + struct clk_hw *hwp; + struct clk_pll_mmc *clkm; + int phase_id; + int ret; + u32 val; + + hwp =3D clk_hw_get_parent(hw); + if (!hwp) + return -ENOENT; + + clkm =3D to_clk_pll_mmc(hwp); + phase_id =3D (hw - &clkm->phase0_hw) ? 1 : 0; + ret =3D get_phsel(clkm, phase_id, &val); + if (ret) + return ret; + + val =3D DIV_ROUND_CLOSEST(val * CYCLE_DEGREES, PHASE_STEPS); + + return val; +} + +const struct clk_ops rtk_clk_pll_mmc_phase_ops =3D { + .set_phase =3D clk_pll_mmc_phase_set_phase, + .get_phase =3D clk_pll_mmc_phase_get_phase, +}; +EXPORT_SYMBOL_GPL(rtk_clk_pll_mmc_phase_ops); + +static int clk_pll_mmc_prepare(struct clk_hw *hw) +{ + struct clk_pll_mmc *clkm =3D to_clk_pll_mmc(hw); + + return set_pow_ctl(clkm, 7); +} + +static void clk_pll_mmc_unprepare(struct clk_hw *hw) +{ + struct clk_pll_mmc *clkm =3D to_clk_pll_mmc(hw); + + set_pow_ctl(clkm, 0); +} + +static int clk_pll_mmc_is_prepared(struct clk_hw *hw) +{ + struct clk_pll_mmc *clkm =3D to_clk_pll_mmc(hw); + u32 val; + int ret; + + ret =3D get_pow_ctl(clkm, &val); + if (ret) + return 1; + + return val !=3D 0x0; +} + +static int clk_pll_mmc_enable(struct clk_hw *hw) +{ + struct clk_pll_mmc *clkm =3D to_clk_pll_mmc(hw); + int ret; + + ret =3D set_phrt0(clkm, 1); + if (ret) + return ret; + + udelay(10); + return 0; +} + +static void clk_pll_mmc_disable(struct clk_hw *hw) +{ + struct clk_pll_mmc *clkm =3D to_clk_pll_mmc(hw); + + set_phrt0(clkm, 0); + udelay(10); +} + +static int clk_pll_mmc_is_enabled(struct clk_hw *hw) +{ + struct clk_pll_mmc *clkm =3D to_clk_pll_mmc(hw); + u32 val; + int ret; + + ret =3D get_phrt0(clkm, &val); + if (ret) + return 1; + + return val =3D=3D 0x1; +} + +static unsigned long clk_pll_mmc_recalc_rate(struct clk_hw *hw, unsigned l= ong parent_rate) +{ + struct clk_pll_mmc *clkm =3D to_clk_pll_mmc(hw); + u32 val, ext_f; + int ret; + + ret =3D get_ssc_div_n(clkm, &val); + if (ret) + return ret; + + ret =3D get_ssc_div_ext_f(clkm, &ext_f); + if (ret) + return ret; + + return parent_rate / 4 * (val + 2) + (parent_rate / 4 * ext_f) / 8192; +} + +static int clk_pll_mmc_determine_rate(struct clk_hw *hw, struct clk_rate_r= equest *req) +{ + u32 val =3D DIV_ROUND_CLOSEST(req->rate * 4, req->best_parent_rate); + + req->rate =3D req->best_parent_rate * val / 4; + return 0; +} + +static int clk_pll_mmc_set_rate(struct clk_hw *hw, unsigned long rate, uns= igned long parent_rate) +{ + struct clk_pll_mmc *clkm =3D to_clk_pll_mmc(hw); + u32 val =3D PLL_MMC_SSC_DIV_N_VAL; + int ret; + + ret =3D regmap_update_bits(clkm->clkr.regmap, + clkm->ssc_dig_ofs + PLL_SSC_DIG_EMMC1_OFFSET, + PLL_FLAG_INITAL_EMMC_MASK, 0x0 << PLL_FLAG_INITAL_EMMC_SHIFT); + if (ret) + return ret; + + ret =3D set_ssc_div_n(clkm, val); + if (ret) + return ret; + + ret =3D set_ssc_div_ext_f(clkm, 1517); + if (ret) + return ret; + + switch (val) { + case 31 ... 46: + ret |=3D set_pi_ibselh(clkm, 3); + ret |=3D set_sscpll_rs(clkm, 3); + ret |=3D set_sscpll_icp(clkm, 2); + break; + + case 20 ... 30: + ret |=3D set_pi_ibselh(clkm, 2); + ret |=3D set_sscpll_rs(clkm, 3); + ret |=3D set_sscpll_icp(clkm, 1); + break; + + case 10 ... 19: + ret |=3D set_pi_ibselh(clkm, 1); + ret |=3D set_sscpll_rs(clkm, 2); + ret |=3D set_sscpll_icp(clkm, 1); + break; + + case 5 ... 9: + ret |=3D set_pi_ibselh(clkm, 0); + ret |=3D set_sscpll_rs(clkm, 2); + ret |=3D set_sscpll_icp(clkm, 0); + break; + } + if (ret) + return ret; + + ret =3D regmap_update_bits(clkm->clkr.regmap, + clkm->ssc_dig_ofs + PLL_SSC_DIG_EMMC3_OFFSET, + PLL_NCODE_SSC_EMMC_MASK, + 27 << PLL_NCODE_SSC_EMMC_SHIFT); + if (ret) + return ret; + + ret =3D regmap_update_bits(clkm->clkr.regmap, + clkm->ssc_dig_ofs + PLL_SSC_DIG_EMMC3_OFFSET, + PLL_FCODE_SSC_EMMC_MASK, 321); + if (ret) + return ret; + + ret =3D regmap_update_bits(clkm->clkr.regmap, + clkm->ssc_dig_ofs + PLL_SSC_DIG_EMMC4_OFFSET, + PLL_GRAN_EST_EM_MC_MASK, 5985); + if (ret) + return ret; + + ret =3D regmap_update_bits(clkm->clkr.regmap, + clkm->ssc_dig_ofs + PLL_SSC_DIG_EMMC1_OFFSET, + PLL_EN_SSC_EMMC_MASK, 0x1); + if (ret) + return ret; + + ret =3D regmap_update_bits(clkm->clkr.regmap, + clkm->ssc_dig_ofs + PLL_SSC_DIG_EMMC1_OFFSET, + PLL_EN_SSC_EMMC_MASK, 0x0); + if (ret) + return ret; + + ret =3D regmap_update_bits(clkm->clkr.regmap, + clkm->ssc_dig_ofs + PLL_SSC_DIG_EMMC1_OFFSET, + PLL_FLAG_INITAL_EMMC_MASK, + 0x1 << PLL_FLAG_INITAL_EMMC_SHIFT); + if (ret) + return ret; + + usleep_range(10, 20); + return 0; +} + +const struct clk_ops rtk_clk_pll_mmc_ops =3D { + .prepare =3D clk_pll_mmc_prepare, + .unprepare =3D clk_pll_mmc_unprepare, + .is_prepared =3D clk_pll_mmc_is_prepared, + .enable =3D clk_pll_mmc_enable, + .disable =3D clk_pll_mmc_disable, + .is_enabled =3D clk_pll_mmc_is_enabled, + .recalc_rate =3D clk_pll_mmc_recalc_rate, + .determine_rate =3D clk_pll_mmc_determine_rate, + .set_rate =3D clk_pll_mmc_set_rate, +}; +EXPORT_SYMBOL_GPL(rtk_clk_pll_mmc_ops); +MODULE_LICENSE("GPL"); diff --git a/drivers/clk/realtek/clk-pll.h b/drivers/clk/realtek/clk-pll.h index 2d27a44a270c..9cf219871218 100644 --- a/drivers/clk/realtek/clk-pll.h +++ b/drivers/clk/realtek/clk-pll.h @@ -44,4 +44,25 @@ static inline struct clk_pll *to_clk_pll(struct clk_hw *= hw) extern const struct clk_ops rtk_clk_pll_ops; extern const struct clk_ops rtk_clk_pll_ro_ops; =20 +struct clk_pll_mmc { + struct clk_regmap clkr; + int pll_ofs; + int ssc_dig_ofs; + struct clk_hw phase0_hw; + struct clk_hw phase1_hw; + u32 set_rate_val_53_97_set_ipc: 1; +}; + +#define __clk_pll_mmc_hw(_ptr) __clk_regmap_hw(&(_ptr)->clkr) + +static inline struct clk_pll_mmc *to_clk_pll_mmc(struct clk_hw *hw) +{ + struct clk_regmap *clkr =3D to_clk_regmap(hw); + + return container_of(clkr, struct clk_pll_mmc, clkr); +} + +extern const struct clk_ops rtk_clk_pll_mmc_ops; +extern const struct clk_ops rtk_clk_pll_mmc_phase_ops; + #endif /* __CLK_REALTEK_CLK_PLL_H */ --=20 2.34.1 From nobody Sun Feb 8 08:48:54 2026 Received: from rtits2.realtek.com.tw (rtits2.realtek.com [211.75.126.72]) (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 A66EA426D3C; Thu, 22 Jan 2026 11:09:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=211.75.126.72 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080163; cv=none; b=D3/vSpbRkrAg10KCexRiUmCPRRaGSkmB2RclhQIER567TT7+NvGl8cgEylBlgDTMrkLxJyfXQZRF3m1yRRTmM/eqyzbs/kC1qM83/TfV7WlHmGbqW3ct7g7r1Wh82+Uf/pnwL9G0QZqjB2cWwSCFf1AjLYmAFuoKZ8VTx1uwOWQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080163; c=relaxed/simple; bh=LwHil34WU6B2FDqXHxOXrUV6OmN/hfU+o2qHouzhCVw=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=BbDyRjpAFbJJZIgxpeh2CmUd44yjE/DA4BZRNZZRZ0OVGs/S1a04XrW6b5mUPNzFvbsVgwdZ6tfOU+3xiJJXiRB5FCQaKhIXaetosabkt+S9pUBSJXNepmrbl4Zbb9g/+FpQ0DgWrtPFcWYHZRqeB8wPddDMF0f67K7aE58NQbY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com; spf=pass smtp.mailfrom=realtek.com; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b=RZXUOYdt; arc=none smtp.client-ip=211.75.126.72 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=realtek.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b="RZXUOYdt" X-SpamFilter-By: ArmorX SpamTrap 5.80 with qID 60MB90qU4913388, This message is accepted by code: ctloc85258 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=realtek.com; s=dkim; t=1769080140; bh=xLGlM56za0BDDLWSJhcrMaMLkwY99PjLLkMZ0smA1/4=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Transfer-Encoding:Content-Type; b=RZXUOYdtnrLD2qsHm7x/WC5vlfPYiBUrVzlXJ5qT1t901JgH4kDT2DaWkhvA3kb56 vSqcgW+1GPYT1Len7MnjOppd0BJG/NaNdS4fjFFgTuc3oBGRG5MZlZHqEPbgCliHig uzYEaeiE6/zrKLhmig7ESKErGCV3+VNfzR0tLurl8kaD10FtFlavGsbNWaXiK6B3SF /GaKjtcfY2n6puWEgUAdJDUt9BfrNzjL+sBMLWwoRuqDndQBt3AnzMX9AKHDk96DjL u21p53iGW56J5YV1RUECsYO/VyRll5hJI/ucP346HuC3ERXg/emcM3FU2AzHAs2kUZ pPGYyO9IQryZQ== Received: from mail.realtek.com (rtkexhmbs03.realtek.com.tw[10.21.1.53]) by rtits2.realtek.com.tw (8.15.2/3.21/5.94) with ESMTPS id 60MB90qU4913388 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Thu, 22 Jan 2026 19:09:00 +0800 Received: from RTKEXHMBS05.realtek.com.tw (10.21.1.55) by RTKEXHMBS03.realtek.com.tw (10.21.1.53) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.10; Thu, 22 Jan 2026 19:09:00 +0800 Received: from RTKEXHMBS03.realtek.com.tw (10.21.1.53) by RTKEXHMBS05.realtek.com.tw (10.21.1.55) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.10; Thu, 22 Jan 2026 19:09:00 +0800 Received: from cn1dhc-k02 (172.21.252.101) by RTKEXHMBS03.realtek.com.tw (10.21.1.53) with Microsoft SMTP Server id 15.2.1748.10 via Frontend Transport; Thu, 22 Jan 2026 19:08:59 +0800 From: Yu-Chun Lin To: , , , , , , , CC: , , , , , , Subject: [PATCH v3 8/9] clk: realtek: Add RTD1625-CRT clock controller driver Date: Thu, 22 Jan 2026 19:08:56 +0800 Message-ID: <20260122110857.12995-9-eleanor.lin@realtek.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260122110857.12995-1-eleanor.lin@realtek.com> References: <20260122110857.12995-1-eleanor.lin@realtek.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Cheng-Yu Lee Add support for the CRT (Clock, Reset, and Test) controller on the Realtek RTD1625 SoC. This driver provides clock and reset management for the system, allowing peripheral clients to request necessary resources for operation. Signed-off-by: Cheng-Yu Lee Co-developed-by: Yu-Chun Lin Signed-off-by: Yu-Chun Lin --- Changes in v3: - Added prefix "rtk_" in operation names to avoid duplicate symbol problem. --- drivers/clk/realtek/Kconfig | 14 + drivers/clk/realtek/Makefile | 1 + drivers/clk/realtek/clk-rtd1625-crt.c | 788 ++++++++++++++++++++++++++ 3 files changed, 803 insertions(+) create mode 100644 drivers/clk/realtek/clk-rtd1625-crt.c diff --git a/drivers/clk/realtek/Kconfig b/drivers/clk/realtek/Kconfig index de462c2bb892..34a7607a9e7e 100644 --- a/drivers/clk/realtek/Kconfig +++ b/drivers/clk/realtek/Kconfig @@ -28,4 +28,18 @@ config RTK_CLK_COMMON config RTK_CLK_PLL_MMC bool =20 +config COMMON_CLK_RTD1625 + tristate "RTD1625 Clock Controller" + select RTK_CLK_COMMON + select RTK_CLK_PLL_MMC + default y + help + Support for the clock controller on Realtek RTD1625 SoCs. + + This driver provides clock sources, gating, multiplexing, and + reset control for peripherals on the RTD1625 platform. + + Say Y here if your system is based on the RTD1625 and you need + its peripheral devices to function. + endif diff --git a/drivers/clk/realtek/Makefile b/drivers/clk/realtek/Makefile index 3d5c93e79dbd..3cda1e600172 100644 --- a/drivers/clk/realtek/Makefile +++ b/drivers/clk/realtek/Makefile @@ -10,3 +10,4 @@ clk-rtk-y +=3D freq_table.o clk-rtk-y +=3D reset.o =20 clk-rtk-$(CONFIG_RTK_CLK_PLL_MMC) +=3D clk-pll-mmc.o +obj-$(CONFIG_COMMON_CLK_RTD1625) +=3D clk-rtd1625-crt.o diff --git a/drivers/clk/realtek/clk-rtd1625-crt.c b/drivers/clk/realtek/cl= k-rtd1625-crt.c new file mode 100644 index 000000000000..a2938fe147c8 --- /dev/null +++ b/drivers/clk/realtek/clk-rtd1625-crt.c @@ -0,0 +1,788 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2022 Realtek Semiconductor Corporation + * Author: Cheng-Yu Lee + */ + +#include +#include +#include "clk-pll.h" +#include "clk-regmap-gate.h" +#include "clk-regmap-mux.h" + +#define RTD1625_CRT_CLK_MAX 172 + +#define RTD1625_REG_PLL_ACPU1 0x10c +#define RTD1625_REG_PLL_ACPU2 0x110 +#define RTD1625_REG_PLL_SSC_DIG_ACPU0 0x5c0 +#define RTD1625_REG_PLL_SSC_DIG_ACPU1 0x5c4 +#define RTD1625_REG_PLL_SSC_DIG_ACPU2 0x5c8 +#define RTD1625_REG_PLL_SSC_DIG_ACPU_DBG2 0x5dc + +#define RTD1625_REG_PLL_VE1_1 0x114 +#define RTD1625_REG_PLL_VE1_2 0x118 +#define RTD1625_REG_PLL_SSC_DIG_VE1_0 0x580 +#define RTD1625_REG_PLL_SSC_DIG_VE1_1 0x584 +#define RTD1625_REG_PLL_SSC_DIG_VE1_2 0x588 +#define RTD1625_REG_PLL_SSC_DIG_VE1_DBG2 0x59c + +#define RTD1625_REG_PLL_GPU1 0x1c0 +#define RTD1625_REG_PLL_GPU2 0x1c4 +#define RTD1625_REG_PLL_SSC_DIG_GPU0 0x5a0 +#define RTD1625_REG_PLL_SSC_DIG_GPU1 0x5a4 +#define RTD1625_REG_PLL_SSC_DIG_GPU2 0x5a8 +#define RTD1625_REG_PLL_SSC_DIG_GPU_DBG2 0x5bc + +#define RTD1625_REG_PLL_NPU1 0x1c8 +#define RTD1625_REG_PLL_NPU2 0x1cc +#define RTD1625_REG_PLL_SSC_DIG_NPU0 0x800 +#define RTD1625_REG_PLL_SSC_DIG_NPU1 0x804 +#define RTD1625_REG_PLL_SSC_DIG_NPU2 0x808 +#define RTD1625_REG_PLL_SSC_DIG_NPU_DBG2 0x81c + +#define RTD1625_REG_PLL_VE2_1 0x1d0 +#define RTD1625_REG_PLL_VE2_2 0x1d4 +#define RTD1625_REG_PLL_SSC_DIG_VE2_0 0x5e0 +#define RTD1625_REG_PLL_SSC_DIG_VE2_1 0x5e4 +#define RTD1625_REG_PLL_SSC_DIG_VE2_2 0x5e8 +#define RTD1625_REG_PLL_SSC_DIG_VE2_DBG2 0x5fc + +#define RTD1625_REG_PLL_HIFI1 0x1d8 +#define RTD1625_REG_PLL_HIFI2 0x1dc +#define RTD1625_REG_PLL_SSC_DIG_HIFI0 0x6e0 +#define RTD1625_REG_PLL_SSC_DIG_HIFI1 0x6e4 +#define RTD1625_REG_PLL_SSC_DIG_HIFI2 0x6e8 +#define RTD1625_REG_PLL_SSC_DIG_HIFI_DBG2 0x6fc + +#define RTD1625_REG_PLL_BUS1 0x524 + +#define RTD1625_REG_PLL_SSC_DIG_DDSA1 0x564 + +#define RTD1625_REG_PLL_SSC_DIG_DCSB1 0x544 + +static const char * const clk_gpu_parents[] =3D {"pll_gpu", "clk_sys"}; +static CLK_REGMAP_MUX(clk_gpu, clk_gpu_parents, CLK_SET_RATE_PARENT | CLK_= SET_RATE_NO_REPARENT, + 0x28, 12, 0x1); +static const char * const clk_ve_parents[] =3D {"pll_vo", "clk_sysh", "pll= _ve1", "pll_ve2"}; +static CLK_REGMAP_MUX(clk_ve1, clk_ve_parents, CLK_SET_RATE_PARENT | CLK_S= ET_RATE_NO_REPARENT, + 0x4c, 0, 0x3); +static CLK_REGMAP_MUX(clk_ve2, clk_ve_parents, CLK_SET_RATE_PARENT | CLK_S= ET_RATE_NO_REPARENT, + 0x4c, 3, 0x3); +static CLK_REGMAP_MUX(clk_ve4, clk_ve_parents, CLK_SET_RATE_PARENT | CLK_S= ET_RATE_NO_REPARENT, + 0x4c, 6, 0x3); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_misc, CLK_IS_CRITICAL, 0x50, 0, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_pcie0, 0, 0x50, 2, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_gspi, 0, 0x50, 6, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_iso_misc, 0, 0x50, 10, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_sds, 0, 0x50, 12, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_hdmi, 0, 0x50, 14, 1); +static CLK_REGMAP_GATE(clk_en_gpu, "clk_gpu", CLK_SET_RATE_PARENT, 0x50, 1= 8, 1); +static CLK_REGMAP_GATE(clk_en_ve1, "clk_ve1", CLK_SET_RATE_PARENT, 0x50, 2= 0, 1); +static CLK_REGMAP_GATE(clk_en_ve2, "clk_ve2", CLK_SET_RATE_PARENT, 0x50, 2= 2, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_se, 0, 0x50, 30, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_md, 0, 0x54, 4, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_tp, CLK_IS_CRITICAL, 0x54, 6, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_rcic, 0, 0x54, 8, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_nf, 0, 0x54, 10, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_emmc, 0, 0x54, 12, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_sd, 0, 0x54, 14, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_sdio_ip, 0, 0x54, 16, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_mipi_csi, 0, 0x54, 18, 1); +static CLK_REGMAP_GATE(clk_en_emmc_ip, "pll_emmc", CLK_SET_RATE_PARENT, 0x= 54, 20, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_sdio, 0, 0x54, 22, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_sd_ip, 0, 0x54, 24, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_tpb, 0, 0x54, 28, 1); +static CLK_REGMAP_GATE(clk_en_misc_sc1, "clk_en_misc", 0, 0x54, 30, 1); +static CLK_REGMAP_GATE(clk_en_misc_i2c_3, "clk_en_misc", 0, 0x58, 0, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_jpeg, 0, 0x58, 4, 1); +static CLK_REGMAP_GATE(clk_en_acpu, "pll_acpu", CLK_SET_RATE_PARENT, + 0x58, 6, 1); +static CLK_REGMAP_GATE(clk_en_misc_sc0, "clk_en_misc", 0, 0x58, 10, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_hdmirx, 0, 0x58, 26, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_hse, CLK_IS_CRITICAL, 0x58, 28, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_fan, 0, 0x5c, 2, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_sata_wrap_sys, 0, 0x5c, 8, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_sata_wrap_sysh, 0, 0x5c, 10, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_sata_mac_sysh, 0, 0x5c, 12, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_r2rdsc, 0, 0x5c, 14, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_pcie1, 0, 0x5c, 18, 1); +static CLK_REGMAP_GATE(clk_en_misc_i2c_4, "clk_en_misc", 0, 0x5c, 20, 1); +static CLK_REGMAP_GATE(clk_en_misc_i2c_5, "clk_en_misc", 0, 0x5c, 22, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_tsio, 0, 0x5c, 24, 1); +static CLK_REGMAP_GATE(clk_en_ve4, "clk_ve4", CLK_SET_RATE_PARENT, + 0x5c, 26, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_edp, 0, 0x5c, 28, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_tsio_trx, 0, 0x5c, 30, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_pcie2, 0, 0x8c, 0, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_earc, 0, 0x8c, 4, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_lite, 0, 0x8c, 6, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_mipi_dsi, 0, 0x8c, 8, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_npupp, 0, 0x8c, 10, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_npu, 0, 0x8c, 12, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_aucpu0, 0, 0x8c, 14, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_aucpu1, 0, 0x8c, 16, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_nsram, 0, 0x8c, 18, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_hdmitop, 0, 0x8c, 20, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_aucpu_iso_npu, 0, 0x8c, 24, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_keyladder, 0, 0x8c, 26, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_ifcp_klm, 0, 0x8c, 28, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_ifcp, 0, 0x8c, 30, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_mdl_genpw, 0, 0xb0, 0, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_mdl_chip, 0, 0xb0, 2, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_mdl_ip, 0, 0xb0, 4, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_mdlm2m, 0, 0xb0, 6, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_mdl_xtal, 0, 0xb0, 8, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_test_mux, 0, 0xb0, 10, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_dla, 0, 0xb0, 12, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_tpcw, 0, 0xb0, 16, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_gpu_ts_src, 0, 0xb0, 18, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_vi, 0, 0xb0, 22, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_lvds1, 0, 0xb0, 24, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_lvds2, 0, 0xb0, 26, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_aucpu, 0, 0xb0, 28, 1); +static CLK_REGMAP_GATE(clk_en_ur1, "clk_en_ur_top", 0, 0x884, 0, 1); +static CLK_REGMAP_GATE(clk_en_ur2, "clk_en_ur_top", 0, 0x884, 2, 1); +static CLK_REGMAP_GATE(clk_en_ur3, "clk_en_ur_top", 0, 0x884, 4, 1); +static CLK_REGMAP_GATE(clk_en_ur4, "clk_en_ur_top", 0, 0x884, 6, 1); +static CLK_REGMAP_GATE(clk_en_ur5, "clk_en_ur_top", 0, 0x884, 8, 1); +static CLK_REGMAP_GATE(clk_en_ur6, "clk_en_ur_top", 0, 0x884, 10, 1); +static CLK_REGMAP_GATE(clk_en_ur7, "clk_en_ur_top", 0, 0x884, 12, 1); +static CLK_REGMAP_GATE(clk_en_ur8, "clk_en_ur_top", 0, 0x884, 14, 1); +static CLK_REGMAP_GATE(clk_en_ur9, "clk_en_ur_top", 0, 0x884, 16, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_ur_top, CLK_IS_CRITICAL, 0x884, 18= , 1); +static CLK_REGMAP_GATE(clk_en_misc_i2c_7, "clk_en_misc", 0, 0x884, 28, 1); +static CLK_REGMAP_GATE(clk_en_misc_i2c_6, "clk_en_misc", 0, 0x884, 30, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_spi0, 0, 0x894, 0, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_spi1, 0, 0x894, 2, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_spi2, 0, 0x894, 4, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_lsadc0, 0, 0x894, 16, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_lsadc1, 0, 0x894, 18, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_isomis_dma, 0, 0x894, 20, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_dptx, 0, 0x894, 24, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_npu_mipi_csi, 0, 0x894, 26, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_edptx, 0, 0x894, 28, 1); + +#define FREQ_NF_MASK 0x7ffff +#define FREQ_NF(_r, _nf) {.rate =3D _r, .val =3D (_nf),} + +static const struct freq_table acpu_tbl[] =3D { + FREQ_NF(513000000, 0x11000), + FREQ_TABLE_END +}; + +static const struct freq_table ve_tbl[] =3D { + FREQ_NF(553500000, 0x12800), + FREQ_NF(661500000, 0x16800), + FREQ_NF(688500000, 0x17800), + FREQ_TABLE_END +}; + +static const struct freq_table bus_tbl[] =3D { + FREQ_NF(513000000, 0x11000), + FREQ_NF(540000000, 0x12000), + FREQ_NF(553500000, 0x12800), + FREQ_TABLE_END +}; + +static const struct freq_table ddsa_tbl[] =3D { + FREQ_NF(432000000, 0xe000), + FREQ_TABLE_END +}; + +static const struct freq_table gpu_tbl[] =3D { + FREQ_NF(405000000, 0xd000), + FREQ_NF(540000000, 0x12000), + FREQ_NF(661500000, 0x16800), + FREQ_NF(729000000, 0x19000), + FREQ_NF(810000000, 0x1c000), + FREQ_NF(850500000, 0x1d800), + FREQ_TABLE_END +}; + +static const struct freq_table hifi_tbl[] =3D { + FREQ_NF(756000000, 0x1a000), + FREQ_NF(810000000, 0x1c000), + FREQ_TABLE_END +}; + +static const struct freq_table npu_tbl[] =3D { + FREQ_NF(661500000, 0x16800), + FREQ_NF(729000000, 0x19000), + FREQ_NF(810000000, 0x1c000), + FREQ_TABLE_END +}; + +static const struct reg_sequence pll_acpu_seq_power_on[] =3D { + {RTD1625_REG_PLL_ACPU2, 0x5}, + {RTD1625_REG_PLL_ACPU2, 0x7}, + {RTD1625_REG_PLL_ACPU1, 0x54000}, + {RTD1625_REG_PLL_SSC_DIG_ACPU2, 0x1e1f8e}, + {RTD1625_REG_PLL_SSC_DIG_ACPU0, 0x4}, + {RTD1625_REG_PLL_SSC_DIG_ACPU0, 0x5, 200}, + {RTD1625_REG_PLL_ACPU2, 0x3}, +}; + +static const struct reg_sequence pll_acpu_seq_power_off[] =3D { + {RTD1625_REG_PLL_ACPU2, 0x4}, +}; + +static const struct reg_sequence pll_acpu_seq_pre_set_freq[] =3D { + {RTD1625_REG_PLL_SSC_DIG_ACPU0, 0x4}, +}; + +static const struct reg_sequence pll_acpu_seq_post_set_freq[] =3D { + {RTD1625_REG_PLL_SSC_DIG_ACPU0, 0x5}, +}; + +static struct clk_pll pll_acpu =3D { + .clkr.hw.init =3D CLK_HW_INIT("pll_acpu", "osc27m", &rtk_clk_pll_ops, CLK= _GET_RATE_NOCACHE), + .seq_power_on =3D pll_acpu_seq_power_on, + .num_seq_power_on =3D ARRAY_SIZE(pll_acpu_seq_power_on), + .seq_power_off =3D pll_acpu_seq_power_off, + .num_seq_power_off =3D ARRAY_SIZE(pll_acpu_seq_power_off), + .seq_pre_set_freq =3D pll_acpu_seq_pre_set_freq, + .num_seq_pre_set_freq =3D ARRAY_SIZE(pll_acpu_seq_pre_set_freq), + .seq_post_set_freq =3D pll_acpu_seq_post_set_freq, + .num_seq_post_set_freq =3D ARRAY_SIZE(pll_acpu_seq_post_set_freq), + .freq_reg =3D RTD1625_REG_PLL_SSC_DIG_ACPU1, + .freq_tbl =3D acpu_tbl, + .freq_mask =3D FREQ_NF_MASK, + .freq_ready_reg =3D RTD1625_REG_PLL_SSC_DIG_ACPU_DBG2, + .freq_ready_mask =3D BIT(20), + .freq_ready_val =3D BIT(20), + .power_reg =3D RTD1625_REG_PLL_ACPU2, + .power_mask =3D 0x7, + .power_val_on =3D 0x3, +}; + +static const struct reg_sequence pll_ve1_seq_power_on[] =3D { + {RTD1625_REG_PLL_VE1_2, 0x5}, + {RTD1625_REG_PLL_VE1_2, 0x7}, + {RTD1625_REG_PLL_VE1_1, 0x54000}, + {RTD1625_REG_PLL_SSC_DIG_VE1_0, 0x4}, + {RTD1625_REG_PLL_SSC_DIG_VE1_0, 0x5, 200}, + {RTD1625_REG_PLL_VE1_2, 0x3}, +}; + +static const struct reg_sequence pll_ve1_seq_power_off[] =3D { + {RTD1625_REG_PLL_VE1_2, 0x4}, +}; + +static const struct reg_sequence pll_ve1_seq_pre_set_freq[] =3D { + {RTD1625_REG_PLL_SSC_DIG_VE1_0, 0x4}, +}; + +static const struct reg_sequence pll_ve1_seq_post_set_freq[] =3D { + {RTD1625_REG_PLL_SSC_DIG_VE1_0, 0x5}, +}; + +static struct clk_pll pll_ve1 =3D { + .clkr.hw.init =3D CLK_HW_INIT("pll_ve1", "osc27m", &rtk_clk_pll_ops, CLK_= GET_RATE_NOCACHE), + .seq_power_on =3D pll_ve1_seq_power_on, + .num_seq_power_on =3D ARRAY_SIZE(pll_ve1_seq_power_on), + .seq_power_off =3D pll_ve1_seq_power_off, + .num_seq_power_off =3D ARRAY_SIZE(pll_ve1_seq_power_off), + .seq_pre_set_freq =3D pll_ve1_seq_pre_set_freq, + .num_seq_pre_set_freq =3D ARRAY_SIZE(pll_ve1_seq_pre_set_freq), + .seq_post_set_freq =3D pll_ve1_seq_post_set_freq, + .num_seq_post_set_freq =3D ARRAY_SIZE(pll_ve1_seq_post_set_freq), + .freq_reg =3D RTD1625_REG_PLL_SSC_DIG_VE1_1, + .freq_tbl =3D ve_tbl, + .freq_mask =3D FREQ_NF_MASK, + .freq_ready_reg =3D RTD1625_REG_PLL_SSC_DIG_VE1_DBG2, + .freq_ready_mask =3D BIT(20), + .freq_ready_val =3D BIT(20), + .power_reg =3D RTD1625_REG_PLL_VE1_2, + .power_mask =3D 0x7, + .power_val_on =3D 0x3, +}; + +static struct clk_pll pll_ddsa =3D { + .clkr.hw.init =3D CLK_HW_INIT("pll_ddsa", "osc27m", &rtk_clk_pll_ro_ops, + CLK_GET_RATE_NOCACHE), + .freq_reg =3D RTD1625_REG_PLL_SSC_DIG_DDSA1, + .freq_tbl =3D ddsa_tbl, + .freq_mask =3D FREQ_NF_MASK, +}; + +static struct clk_pll pll_bus =3D { + .clkr.hw.init =3D CLK_HW_INIT("pll_bus", "osc27m", &rtk_clk_pll_ro_ops, C= LK_GET_RATE_NOCACHE), + .freq_reg =3D RTD1625_REG_PLL_BUS1, + .freq_tbl =3D bus_tbl, + .freq_mask =3D FREQ_NF_MASK, +}; + +static CLK_FIXED_FACTOR(clk_sys, "clk_sys", "pll_bus", 2, 1, 0); + +static struct clk_pll pll_dcsb =3D { + .clkr.hw.init =3D CLK_HW_INIT("pll_dcsb", "osc27m", &rtk_clk_pll_ro_ops, + CLK_GET_RATE_NOCACHE), + .freq_reg =3D RTD1625_REG_PLL_SSC_DIG_DCSB1, + .freq_tbl =3D bus_tbl, + .freq_mask =3D FREQ_NF_MASK, +}; + +static CLK_FIXED_FACTOR(clk_sysh, "clk_sysh", "pll_dcsb", 1, 1, 0); + +static const struct reg_sequence pll_gpu_seq_power_on[] =3D { + {RTD1625_REG_PLL_GPU2, 0x5}, + {RTD1625_REG_PLL_GPU2, 0x7}, + {RTD1625_REG_PLL_GPU1, 0x54000}, + {RTD1625_REG_PLL_SSC_DIG_GPU0, 0x4}, + {RTD1625_REG_PLL_SSC_DIG_GPU0, 0x5, 200}, + {RTD1625_REG_PLL_GPU2, 0x3}, +}; + +static const struct reg_sequence pll_gpu_seq_power_off[] =3D { + {RTD1625_REG_PLL_GPU2, 0x4}, +}; + +static const struct reg_sequence pll_gpu_seq_pre_set_freq[] =3D { + {RTD1625_REG_PLL_SSC_DIG_GPU0, 0x4}, +}; + +static const struct reg_sequence pll_gpu_seq_post_set_freq[] =3D { + {RTD1625_REG_PLL_SSC_DIG_GPU0, 0x5}, +}; + +static struct clk_pll pll_gpu =3D { + .clkr.hw.init =3D CLK_HW_INIT("pll_gpu", "osc27m", &rtk_clk_pll_ops, CLK_= GET_RATE_NOCACHE), + .seq_power_on =3D pll_gpu_seq_power_on, + .num_seq_power_on =3D ARRAY_SIZE(pll_gpu_seq_power_on), + .seq_power_off =3D pll_gpu_seq_power_off, + .num_seq_power_off =3D ARRAY_SIZE(pll_gpu_seq_power_off), + .seq_pre_set_freq =3D pll_gpu_seq_pre_set_freq, + .num_seq_pre_set_freq =3D ARRAY_SIZE(pll_gpu_seq_pre_set_freq), + .seq_post_set_freq =3D pll_gpu_seq_post_set_freq, + .num_seq_post_set_freq =3D ARRAY_SIZE(pll_gpu_seq_post_set_freq), + .freq_reg =3D RTD1625_REG_PLL_SSC_DIG_GPU1, + .freq_tbl =3D gpu_tbl, + .freq_mask =3D FREQ_NF_MASK, + .freq_ready_reg =3D RTD1625_REG_PLL_SSC_DIG_GPU_DBG2, + .freq_ready_mask =3D BIT(20), + .freq_ready_val =3D BIT(20), + .power_reg =3D RTD1625_REG_PLL_GPU2, + .power_mask =3D 0x7, + .power_val_on =3D 0x3, +}; + +static const struct reg_sequence pll_npu_seq_power_on[] =3D { + {RTD1625_REG_PLL_NPU2, 0x5}, + {RTD1625_REG_PLL_NPU2, 0x7}, + {RTD1625_REG_PLL_NPU1, 0x54000}, + {RTD1625_REG_PLL_SSC_DIG_NPU0, 0x4}, + {RTD1625_REG_PLL_SSC_DIG_NPU0, 0x5, 200}, + {RTD1625_REG_PLL_NPU2, 0x3}, +}; + +static const struct reg_sequence pll_npu_seq_power_off[] =3D { + {RTD1625_REG_PLL_NPU2, 0x4}, + {RTD1625_REG_PLL_NPU1, 0x54010}, +}; + +static const struct reg_sequence pll_npu_seq_pre_set_freq[] =3D { + {RTD1625_REG_PLL_SSC_DIG_NPU0, 0x4}, +}; + +static const struct reg_sequence pll_npu_seq_post_set_freq[] =3D { + {RTD1625_REG_PLL_SSC_DIG_NPU0, 0x5}, +}; + +static struct clk_pll pll_npu =3D { + .clkr.hw.init =3D CLK_HW_INIT("pll_npu", "osc27m", &rtk_clk_pll_ops, CLK_= GET_RATE_NOCACHE), + .seq_power_on =3D pll_npu_seq_power_on, + .num_seq_power_on =3D ARRAY_SIZE(pll_npu_seq_power_on), + .seq_power_off =3D pll_npu_seq_power_off, + .num_seq_power_off =3D ARRAY_SIZE(pll_npu_seq_power_off), + .seq_pre_set_freq =3D pll_npu_seq_pre_set_freq, + .num_seq_pre_set_freq =3D ARRAY_SIZE(pll_npu_seq_pre_set_freq), + .seq_post_set_freq =3D pll_npu_seq_post_set_freq, + .num_seq_post_set_freq =3D ARRAY_SIZE(pll_npu_seq_post_set_freq), + .freq_reg =3D RTD1625_REG_PLL_SSC_DIG_NPU1, + .freq_tbl =3D npu_tbl, + .freq_mask =3D FREQ_NF_MASK, + .freq_ready_reg =3D RTD1625_REG_PLL_SSC_DIG_NPU_DBG2, + .freq_ready_mask =3D BIT(20), + .freq_ready_val =3D BIT(20), + .power_reg =3D RTD1625_REG_PLL_NPU2, + .power_mask =3D 0x7, + .power_val_on =3D 0x3, +}; + +static CLK_FIXED_FACTOR(clk_npu, "clk_npu", "pll_npu", 1, 1, CLK_SET_RATE_= PARENT); +static CLK_FIXED_FACTOR(clk_npu_mipi_csi, "clk_npu_mipi_csi", "pll_npu", 1= , 1, + CLK_SET_RATE_PARENT); + +static const struct reg_sequence pll_ve2_seq_power_on[] =3D { + {RTD1625_REG_PLL_VE2_2, 0x5}, + {RTD1625_REG_PLL_VE2_2, 0x7}, + {RTD1625_REG_PLL_VE2_1, 0x54000}, + {RTD1625_REG_PLL_SSC_DIG_VE2_0, 0x4}, + {RTD1625_REG_PLL_SSC_DIG_VE2_0, 0x5, 200}, + {RTD1625_REG_PLL_VE2_2, 0x3}, +}; + +static const struct reg_sequence pll_ve2_seq_power_off[] =3D { + {RTD1625_REG_PLL_VE2_2, 0x4}, +}; + +static const struct reg_sequence pll_ve2_seq_pre_set_freq[] =3D { + {RTD1625_REG_PLL_SSC_DIG_VE2_0, 0x4}, +}; + +static const struct reg_sequence pll_ve2_seq_post_set_freq[] =3D { + {RTD1625_REG_PLL_SSC_DIG_VE2_0, 0x5}, +}; + +static struct clk_pll pll_ve2 =3D { + .clkr.hw.init =3D CLK_HW_INIT("pll_ve2", "osc27m", &rtk_clk_pll_ops, CLK_= GET_RATE_NOCACHE), + .seq_power_on =3D pll_ve2_seq_power_on, + .num_seq_power_on =3D ARRAY_SIZE(pll_ve2_seq_power_on), + .seq_power_off =3D pll_ve2_seq_power_off, + .num_seq_power_off =3D ARRAY_SIZE(pll_ve2_seq_power_off), + .seq_pre_set_freq =3D pll_ve2_seq_pre_set_freq, + .num_seq_pre_set_freq =3D ARRAY_SIZE(pll_ve2_seq_pre_set_freq), + .seq_post_set_freq =3D pll_ve2_seq_post_set_freq, + .num_seq_post_set_freq =3D ARRAY_SIZE(pll_ve2_seq_post_set_freq), + .freq_reg =3D RTD1625_REG_PLL_SSC_DIG_VE2_1, + .freq_tbl =3D ve_tbl, + .freq_mask =3D FREQ_NF_MASK, + .freq_ready_reg =3D RTD1625_REG_PLL_SSC_DIG_VE2_DBG2, + .freq_ready_mask =3D BIT(20), + .freq_ready_val =3D BIT(20), + .power_reg =3D RTD1625_REG_PLL_VE2_2, + .power_mask =3D 0x7, + .power_val_on =3D 0x3, +}; + +static const struct reg_sequence pll_hifi_seq_power_on[] =3D { + {RTD1625_REG_PLL_HIFI2, 0x5}, + {RTD1625_REG_PLL_HIFI2, 0x7}, + {RTD1625_REG_PLL_HIFI1, 0x54000}, + {RTD1625_REG_PLL_SSC_DIG_HIFI0, 0x4}, + {RTD1625_REG_PLL_SSC_DIG_HIFI0, 0x5, 200}, + {RTD1625_REG_PLL_HIFI2, 0x3}, +}; + +static const struct reg_sequence pll_hifi_seq_power_off[] =3D { + {RTD1625_REG_PLL_HIFI2, 0x4}, +}; + +static const struct reg_sequence pll_hifi_seq_pre_set_freq[] =3D { + {RTD1625_REG_PLL_SSC_DIG_HIFI0, 0x4}, +}; + +static const struct reg_sequence pll_hifi_seq_post_set_freq[] =3D { + {RTD1625_REG_PLL_SSC_DIG_HIFI0, 0x5}, +}; + +static struct clk_pll pll_hifi =3D { + .clkr.hw.init =3D CLK_HW_INIT("pll_hifi", "osc27m", &rtk_clk_pll_ops, CLK= _GET_RATE_NOCACHE), + .seq_power_on =3D pll_hifi_seq_power_on, + .num_seq_power_on =3D ARRAY_SIZE(pll_hifi_seq_power_on), + .seq_power_off =3D pll_hifi_seq_power_off, + .num_seq_power_off =3D ARRAY_SIZE(pll_hifi_seq_power_off), + .seq_pre_set_freq =3D pll_hifi_seq_pre_set_freq, + .num_seq_pre_set_freq =3D ARRAY_SIZE(pll_hifi_seq_pre_set_freq), + .seq_post_set_freq =3D pll_hifi_seq_post_set_freq, + .num_seq_post_set_freq =3D ARRAY_SIZE(pll_hifi_seq_post_set_freq), + .freq_reg =3D RTD1625_REG_PLL_SSC_DIG_HIFI1, + .freq_tbl =3D hifi_tbl, + .freq_mask =3D FREQ_NF_MASK, + .freq_ready_reg =3D RTD1625_REG_PLL_SSC_DIG_HIFI_DBG2, + .freq_ready_mask =3D BIT(20), + .freq_ready_val =3D BIT(20), + .power_reg =3D RTD1625_REG_PLL_HIFI2, + .power_mask =3D 0x7, + .power_val_on =3D 0x3, +}; + +static CLK_FIXED_FACTOR(pll_emmc_ref, "pll_emmc_ref", "osc27m", 1, 1, 0); + +static struct clk_pll_mmc pll_emmc =3D { + .pll_ofs =3D 0x1f0, + .ssc_dig_ofs =3D 0x6b0, + .clkr.hw.init =3D CLK_HW_INIT("pll_emmc", "pll_emmc_ref", &rtk_clk_pll_= mmc_ops, 0), + .phase0_hw.init =3D CLK_HW_INIT("pll_emmc_vp0", "pll_emmc", &rtk_clk_pll_= mmc_phase_ops, 0), + .phase1_hw.init =3D CLK_HW_INIT("pll_emmc_vp1", "pll_emmc", &rtk_clk_pll_= mmc_phase_ops, 0), +}; + +static struct clk_regmap *rtd1625_crt_regmap_clks[] =3D { + &clk_en_misc.clkr, + &clk_en_pcie0.clkr, + &clk_en_gspi.clkr, + &clk_en_iso_misc.clkr, + &clk_en_sds.clkr, + &clk_en_hdmi.clkr, + &clk_en_gpu.clkr, + &clk_en_ve1.clkr, + &clk_en_ve2.clkr, + &clk_en_se.clkr, + &clk_en_md.clkr, + &clk_en_tp.clkr, + &clk_en_rcic.clkr, + &clk_en_nf.clkr, + &clk_en_emmc.clkr, + &clk_en_sd.clkr, + &clk_en_sdio_ip.clkr, + &clk_en_mipi_csi.clkr, + &clk_en_emmc_ip.clkr, + &clk_en_sdio.clkr, + &clk_en_sd_ip.clkr, + &clk_en_tpb.clkr, + &clk_en_misc_sc1.clkr, + &clk_en_misc_i2c_3.clkr, + &clk_en_jpeg.clkr, + &clk_en_acpu.clkr, + &clk_en_misc_sc0.clkr, + &clk_en_hdmirx.clkr, + &clk_en_hse.clkr, + &clk_en_fan.clkr, + &clk_en_sata_wrap_sys.clkr, + &clk_en_sata_wrap_sysh.clkr, + &clk_en_sata_mac_sysh.clkr, + &clk_en_r2rdsc.clkr, + &clk_en_pcie1.clkr, + &clk_en_misc_i2c_4.clkr, + &clk_en_misc_i2c_5.clkr, + &clk_en_tsio.clkr, + &clk_en_ve4.clkr, + &clk_en_edp.clkr, + &clk_en_tsio_trx.clkr, + &clk_en_pcie2.clkr, + &clk_en_earc.clkr, + &clk_en_lite.clkr, + &clk_en_mipi_dsi.clkr, + &clk_en_npupp.clkr, + &clk_en_npu.clkr, + &clk_en_aucpu0.clkr, + &clk_en_aucpu1.clkr, + &clk_en_nsram.clkr, + &clk_en_hdmitop.clkr, + &clk_en_aucpu_iso_npu.clkr, + &clk_en_keyladder.clkr, + &clk_en_ifcp_klm.clkr, + &clk_en_ifcp.clkr, + &clk_en_mdl_genpw.clkr, + &clk_en_mdl_chip.clkr, + &clk_en_mdl_ip.clkr, + &clk_en_mdlm2m.clkr, + &clk_en_mdl_xtal.clkr, + &clk_en_test_mux.clkr, + &clk_en_dla.clkr, + &clk_en_tpcw.clkr, + &clk_en_gpu_ts_src.clkr, + &clk_en_vi.clkr, + &clk_en_lvds1.clkr, + &clk_en_lvds2.clkr, + &clk_en_aucpu.clkr, + &clk_en_ur1.clkr, + &clk_en_ur2.clkr, + &clk_en_ur3.clkr, + &clk_en_ur4.clkr, + &clk_en_ur5.clkr, + &clk_en_ur6.clkr, + &clk_en_ur7.clkr, + &clk_en_ur8.clkr, + &clk_en_ur9.clkr, + &clk_en_ur_top.clkr, + &clk_en_misc_i2c_7.clkr, + &clk_en_misc_i2c_6.clkr, + &clk_en_spi0.clkr, + &clk_en_spi1.clkr, + &clk_en_spi2.clkr, + &clk_en_lsadc0.clkr, + &clk_en_lsadc1.clkr, + &clk_en_isomis_dma.clkr, + &clk_en_dptx.clkr, + &clk_en_npu_mipi_csi.clkr, + &clk_en_edptx.clkr, + &clk_gpu.clkr, + &clk_ve1.clkr, + &clk_ve2.clkr, + &clk_ve4.clkr, + &pll_ve1.clkr, + &pll_ddsa.clkr, + &pll_bus.clkr, + &pll_dcsb.clkr, + &pll_gpu.clkr, + &pll_npu.clkr, + &pll_ve2.clkr, + &pll_hifi.clkr, + &pll_emmc.clkr, + &pll_acpu.clkr, +}; + +static struct rtk_reset_bank rtd1625_crt_reset_banks[] =3D { + {.ofs =3D 0x0, .write_en =3D 1,}, + {.ofs =3D 0x4, .write_en =3D 1,}, + {.ofs =3D 0x8, .write_en =3D 1,}, + {.ofs =3D 0xc, .write_en =3D 1,}, + {.ofs =3D 0x68, .write_en =3D 1,}, + {.ofs =3D 0x90, .write_en =3D 1,}, + {.ofs =3D 0xb8, .write_en =3D 1,}, + {.ofs =3D 0x454,}, + {.ofs =3D 0x458,}, + {.ofs =3D 0x464,}, + {.ofs =3D 0x880, .write_en =3D 1,}, + {.ofs =3D 0x890, .write_en =3D 1,}, +}; + +static struct clk_hw_onecell_data rtd1625_crt_hw_data =3D { + .num =3D RTD1625_CRT_CLK_MAX, + .hws =3D { + [RTD1625_CRT_CLK_EN_MISC] =3D &__clk_regmap_gate_hw(&clk_en_misc), + [RTD1625_CRT_CLK_EN_PCIE0] =3D &__clk_regmap_gate_hw(&clk_en_pcie0), + [RTD1625_CRT_CLK_EN_GSPI] =3D &__clk_regmap_gate_hw(&clk_en_gspi), + [RTD1625_CRT_CLK_EN_ISO_MISC] =3D &__clk_regmap_gate_hw(&clk_en_iso_misc= ), + [RTD1625_CRT_CLK_EN_SDS] =3D &__clk_regmap_gate_hw(&clk_en_sds), + [RTD1625_CRT_CLK_EN_HDMI] =3D &__clk_regmap_gate_hw(&clk_en_hdmi), + [RTD1625_CRT_CLK_EN_GPU] =3D &__clk_regmap_gate_hw(&clk_en_gpu), + [RTD1625_CRT_CLK_EN_VE1] =3D &__clk_regmap_gate_hw(&clk_en_ve1), + [RTD1625_CRT_CLK_EN_VE2] =3D &__clk_regmap_gate_hw(&clk_en_ve2), + [RTD1625_CRT_CLK_EN_MD] =3D &__clk_regmap_gate_hw(&clk_en_md), + [RTD1625_CRT_CLK_EN_TP] =3D &__clk_regmap_gate_hw(&clk_en_tp), + [RTD1625_CRT_CLK_EN_RCIC] =3D &__clk_regmap_gate_hw(&clk_en_rcic), + [RTD1625_CRT_CLK_EN_NF] =3D &__clk_regmap_gate_hw(&clk_en_nf), + [RTD1625_CRT_CLK_EN_EMMC] =3D &__clk_regmap_gate_hw(&clk_en_emmc), + [RTD1625_CRT_CLK_EN_SD] =3D &__clk_regmap_gate_hw(&clk_en_sd), + [RTD1625_CRT_CLK_EN_SDIO_IP] =3D &__clk_regmap_gate_hw(&clk_en_sdio_ip), + [RTD1625_CRT_CLK_EN_MIPI_CSI] =3D &__clk_regmap_gate_hw(&clk_en_mipi_csi= ), + [RTD1625_CRT_CLK_EN_EMMC_IP] =3D &__clk_regmap_gate_hw(&clk_en_emmc_ip), + [RTD1625_CRT_CLK_EN_SDIO] =3D &__clk_regmap_gate_hw(&clk_en_sdio), + [RTD1625_CRT_CLK_EN_SD_IP] =3D &__clk_regmap_gate_hw(&clk_en_sd_ip), + [RTD1625_CRT_CLK_EN_TPB] =3D &__clk_regmap_gate_hw(&clk_en_tpb), + [RTD1625_CRT_CLK_EN_MISC_SC1] =3D &__clk_regmap_gate_hw(&clk_en_misc_sc1= ), + [RTD1625_CRT_CLK_EN_MISC_I2C_3] =3D &__clk_regmap_gate_hw(&clk_en_misc_i= 2c_3), + [RTD1625_CRT_CLK_EN_ACPU] =3D &__clk_regmap_gate_hw(&clk_en_acpu), + [RTD1625_CRT_CLK_EN_JPEG] =3D &__clk_regmap_gate_hw(&clk_en_jpeg), + [RTD1625_CRT_CLK_EN_MISC_SC0] =3D &__clk_regmap_gate_hw(&clk_en_misc_sc0= ), + [RTD1625_CRT_CLK_EN_HDMIRX] =3D &__clk_regmap_gate_hw(&clk_en_hdmirx), + [RTD1625_CRT_CLK_EN_HSE] =3D &__clk_regmap_gate_hw(&clk_en_hse), + [RTD1625_CRT_CLK_EN_FAN] =3D &__clk_regmap_gate_hw(&clk_en_fan), + [RTD1625_CRT_CLK_EN_SATA_WRAP_SYS] =3D &__clk_regmap_gate_hw(&clk_en_sat= a_wrap_sys), + [RTD1625_CRT_CLK_EN_SATA_WRAP_SYSH] =3D &__clk_regmap_gate_hw(&clk_en_sa= ta_wrap_sysh), + [RTD1625_CRT_CLK_EN_SATA_MAC_SYSH] =3D &__clk_regmap_gate_hw(&clk_en_sat= a_mac_sysh), + [RTD1625_CRT_CLK_EN_R2RDSC] =3D &__clk_regmap_gate_hw(&clk_en_r2rdsc), + [RTD1625_CRT_CLK_EN_PCIE1] =3D &__clk_regmap_gate_hw(&clk_en_pcie1), + [RTD1625_CRT_CLK_EN_MISC_I2C_4] =3D &__clk_regmap_gate_hw(&clk_en_misc_i= 2c_4), + [RTD1625_CRT_CLK_EN_MISC_I2C_5] =3D &__clk_regmap_gate_hw(&clk_en_misc_i= 2c_5), + [RTD1625_CRT_CLK_EN_TSIO] =3D &__clk_regmap_gate_hw(&clk_en_tsio), + [RTD1625_CRT_CLK_EN_VE4] =3D &__clk_regmap_gate_hw(&clk_en_ve4), + [RTD1625_CRT_CLK_EN_EDP] =3D &__clk_regmap_gate_hw(&clk_en_edp), + [RTD1625_CRT_CLK_EN_TSIO_TRX] =3D &__clk_regmap_gate_hw(&clk_en_tsio_trx= ), + [RTD1625_CRT_CLK_EN_PCIE2] =3D &__clk_regmap_gate_hw(&clk_en_pcie2), + [RTD1625_CRT_CLK_EN_EARC] =3D &__clk_regmap_gate_hw(&clk_en_earc), + [RTD1625_CRT_CLK_EN_LITE] =3D &__clk_regmap_gate_hw(&clk_en_lite), + [RTD1625_CRT_CLK_EN_MIPI_DSI] =3D &__clk_regmap_gate_hw(&clk_en_mipi_dsi= ), + [RTD1625_CRT_CLK_EN_NPUPP] =3D &__clk_regmap_gate_hw(&clk_en_npupp), + [RTD1625_CRT_CLK_EN_NPU] =3D &__clk_regmap_gate_hw(&clk_en_npu), + [RTD1625_CRT_CLK_EN_AUCPU0] =3D &__clk_regmap_gate_hw(&clk_en_aucpu0), + [RTD1625_CRT_CLK_EN_AUCPU1] =3D &__clk_regmap_gate_hw(&clk_en_aucpu1), + [RTD1625_CRT_CLK_EN_NSRAM] =3D &__clk_regmap_gate_hw(&clk_en_nsram), + [RTD1625_CRT_CLK_EN_HDMITOP] =3D &__clk_regmap_gate_hw(&clk_en_hdmitop), + [RTD1625_CRT_CLK_EN_AUCPU_ISO_NPU] =3D &__clk_regmap_gate_hw(&clk_en_auc= pu_iso_npu), + [RTD1625_CRT_CLK_EN_KEYLADDER] =3D &__clk_regmap_gate_hw(&clk_en_keyladd= er), + [RTD1625_CRT_CLK_EN_IFCP_KLM] =3D &__clk_regmap_gate_hw(&clk_en_ifcp_kl= m), + [RTD1625_CRT_CLK_EN_IFCP] =3D &__clk_regmap_gate_hw(&clk_en_ifcp), + [RTD1625_CRT_CLK_EN_MDL_GENPW] =3D &__clk_regmap_gate_hw(&clk_en_mdl_gen= pw), + [RTD1625_CRT_CLK_EN_MDL_CHIP] =3D &__clk_regmap_gate_hw(&clk_en_mdl_chi= p), + [RTD1625_CRT_CLK_EN_MDL_IP] =3D &__clk_regmap_gate_hw(&clk_en_mdl_ip), + [RTD1625_CRT_CLK_EN_MDLM2M] =3D &__clk_regmap_gate_hw(&clk_en_mdlm2m), + [RTD1625_CRT_CLK_EN_MDL_XTAL] =3D &__clk_regmap_gate_hw(&clk_en_mdl_xta= l), + [RTD1625_CRT_CLK_EN_TEST_MUX] =3D &__clk_regmap_gate_hw(&clk_en_test_mu= x), + [RTD1625_CRT_CLK_EN_DLA] =3D &__clk_regmap_gate_hw(&clk_en_dla), + [RTD1625_CRT_CLK_EN_TPCW] =3D &__clk_regmap_gate_hw(&clk_en_tpcw), + [RTD1625_CRT_CLK_EN_GPU_TS_SRC] =3D &__clk_regmap_gate_hw(&clk_en_gpu_ts= _src), + [RTD1625_CRT_CLK_EN_VI] =3D &__clk_regmap_gate_hw(&clk_en_vi), + [RTD1625_CRT_CLK_EN_LVDS1] =3D &__clk_regmap_gate_hw(&clk_en_lvds1), + [RTD1625_CRT_CLK_EN_LVDS2] =3D &__clk_regmap_gate_hw(&clk_en_lvds2), + [RTD1625_CRT_CLK_EN_AUCPU] =3D &__clk_regmap_gate_hw(&clk_en_aucpu), + [RTD1625_CRT_CLK_EN_UR1] =3D &__clk_regmap_gate_hw(&clk_en_ur1), + [RTD1625_CRT_CLK_EN_UR2] =3D &__clk_regmap_gate_hw(&clk_en_ur2), + [RTD1625_CRT_CLK_EN_UR3] =3D &__clk_regmap_gate_hw(&clk_en_ur3), + [RTD1625_CRT_CLK_EN_UR4] =3D &__clk_regmap_gate_hw(&clk_en_ur4), + [RTD1625_CRT_CLK_EN_UR5] =3D &__clk_regmap_gate_hw(&clk_en_ur5), + [RTD1625_CRT_CLK_EN_UR6] =3D &__clk_regmap_gate_hw(&clk_en_ur6), + [RTD1625_CRT_CLK_EN_UR7] =3D &__clk_regmap_gate_hw(&clk_en_ur7), + [RTD1625_CRT_CLK_EN_UR8] =3D &__clk_regmap_gate_hw(&clk_en_ur8), + [RTD1625_CRT_CLK_EN_UR9] =3D &__clk_regmap_gate_hw(&clk_en_ur9), + [RTD1625_CRT_CLK_EN_UR_TOP] =3D &__clk_regmap_gate_hw(&clk_en_ur_top), + [RTD1625_CRT_CLK_EN_MISC_I2C_7] =3D &__clk_regmap_gate_hw(&clk_en_misc_i= 2c_7), + [RTD1625_CRT_CLK_EN_MISC_I2C_6] =3D &__clk_regmap_gate_hw(&clk_en_misc_i= 2c_6), + [RTD1625_CRT_CLK_EN_SPI0] =3D &__clk_regmap_gate_hw(&clk_en_spi0), + [RTD1625_CRT_CLK_EN_SPI1] =3D &__clk_regmap_gate_hw(&clk_en_spi1), + [RTD1625_CRT_CLK_EN_SPI2] =3D &__clk_regmap_gate_hw(&clk_en_spi2), + [RTD1625_CRT_CLK_EN_LSADC0] =3D &__clk_regmap_gate_hw(&clk_en_lsadc0), + [RTD1625_CRT_CLK_EN_LSADC1] =3D &__clk_regmap_gate_hw(&clk_en_lsadc1), + [RTD1625_CRT_CLK_EN_ISOMIS_DMA] =3D &__clk_regmap_gate_hw(&clk_en_isomis= _dma), + [RTD1625_CRT_CLK_EN_DPTX] =3D &__clk_regmap_gate_hw(&clk_en_dptx), + [RTD1625_CRT_CLK_EN_NPU_MIPI_CSI] =3D &__clk_regmap_gate_hw(&clk_en_npu_= mipi_csi), + [RTD1625_CRT_CLK_EN_EDPTX] =3D &__clk_regmap_gate_hw(&clk_en_edptx), + [RTD1625_CRT_CLK_GPU] =3D &__clk_regmap_mux_hw(&clk_gpu), + [RTD1625_CRT_CLK_VE1] =3D &__clk_regmap_mux_hw(&clk_ve1), + [RTD1625_CRT_CLK_VE2] =3D &__clk_regmap_mux_hw(&clk_ve2), + [RTD1625_CRT_CLK_VE4] =3D &__clk_regmap_mux_hw(&clk_ve4), + [RTD1625_CRT_PLL_VE1] =3D &__clk_pll_hw(&pll_ve1), + [RTD1625_CRT_PLL_DDSA] =3D &__clk_pll_hw(&pll_ddsa), + [RTD1625_CRT_PLL_BUS] =3D &__clk_pll_hw(&pll_bus), + [RTD1625_CRT_CLK_SYS] =3D &clk_sys.hw, + [RTD1625_CRT_PLL_DCSB] =3D &__clk_pll_hw(&pll_dcsb), + [RTD1625_CRT_CLK_SYSH] =3D &clk_sysh.hw, + [RTD1625_CRT_PLL_GPU] =3D &__clk_pll_hw(&pll_gpu), + [RTD1625_CRT_PLL_NPU] =3D &__clk_pll_hw(&pll_npu), + [RTD1625_CRT_PLL_VE2] =3D &__clk_pll_hw(&pll_ve2), + [RTD1625_CRT_PLL_HIFI] =3D &__clk_pll_hw(&pll_hifi), + [RTD1625_CRT_PLL_EMMC_REF] =3D &pll_emmc_ref.hw, + [RTD1625_CRT_PLL_EMMC] =3D &__clk_pll_mmc_hw(&pll_emmc), + [RTD1625_CRT_PLL_EMMC_VP0] =3D &pll_emmc.phase0_hw, + [RTD1625_CRT_PLL_EMMC_VP1] =3D &pll_emmc.phase1_hw, + [RTD1625_CRT_PLL_ACPU] =3D &__clk_pll_hw(&pll_acpu), + [RTD1625_CRT_CLK_NPU] =3D &clk_npu.hw, + [RTD1625_CRT_CLK_NPU_MIPI_CSI] =3D &clk_npu_mipi_csi.hw, + + [RTD1625_CRT_CLK_MAX] =3D NULL, + }, +}; + +static const struct rtk_clk_desc rtd1625_crt_desc =3D { + .clk_data =3D &rtd1625_crt_hw_data, + .clks =3D rtd1625_crt_regmap_clks, + .num_clks =3D ARRAY_SIZE(rtd1625_crt_regmap_clks), + .reset_banks =3D rtd1625_crt_reset_banks, + .num_reset_banks =3D ARRAY_SIZE(rtd1625_crt_reset_banks), +}; + +static int rtd1625_crt_probe(struct platform_device *pdev) +{ + const struct rtk_clk_desc *desc; + + desc =3D of_device_get_match_data(&pdev->dev); + if (!desc) + return -EINVAL; + + return rtk_clk_probe(pdev, desc); +} + +static const struct of_device_id rtd1625_crt_match[] =3D { + {.compatible =3D "realtek,rtd1625-crt-clk", .data =3D &rtd1625_crt_desc,}, + {/* sentinel */} +}; + +static struct platform_driver rtd1625_crt_driver =3D { + .probe =3D rtd1625_crt_probe, + .driver =3D { + .name =3D "rtk-rtd1625-crt-clk", + .of_match_table =3D rtd1625_crt_match, + }, +}; + +static int __init rtd1625_crt_init(void) +{ + return platform_driver_register(&rtd1625_crt_driver); +} +subsys_initcall(rtd1625_crt_init); + +MODULE_DESCRIPTION("Reatek RTD1625 CRT Controller Driver"); +MODULE_AUTHOR("Cheng-Yu Lee "); +MODULE_LICENSE("GPL"); --=20 2.34.1 From nobody Sun Feb 8 08:48:54 2026 Received: from rtits2.realtek.com.tw (rtits2.realtek.com [211.75.126.72]) (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 78CF62DAFA4; Thu, 22 Jan 2026 11:09:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=211.75.126.72 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080160; cv=none; b=eHf8glxzo2QVUx+KIN6r2NuoYC0ckL1UMmk8rBnfaSJqM5f+lvRii2IFW9/lGxbASGyfBoy2vTIDSDzsKSG1JjJTr+GSOA4ROaBs81+4N4f66+rRMBbsa3oLY7gFkB59qJ9bv4Gv5u4qFD0p+3Nqc4qw4+x8CaXQ1Js4eDX66wk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769080160; c=relaxed/simple; bh=IsWn/3vOPCYRknA0LMIG68fisubCVp3CsGFIEpdrZu8=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=ad59Ny2LwT14zvP3qDTCCq5uCs/X/wNJmFSN6z/O+Cxv5e0ao24T7lBaubdHtgadd6xsb4lbBaI8kJI8BAYnU7C4ZLAVClFpfSlaNCfxvqCDttKfMQgAu/EkyNaD7CHDfgwrxaSFRxD11zYgGQyW+wFAH5sYAu5rMluGe//ldUU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com; spf=pass smtp.mailfrom=realtek.com; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b=XYIu4iv+; arc=none smtp.client-ip=211.75.126.72 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=realtek.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=realtek.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=realtek.com header.i=@realtek.com header.b="XYIu4iv+" X-SpamFilter-By: ArmorX SpamTrap 5.80 with qID 60MB90vlC913389, This message is accepted by code: ctloc85258 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=realtek.com; s=dkim; t=1769080140; bh=Mx116ntBY9w2btL+Wb4TvqmggYWOjR5VB3+xYYaVSLE=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Transfer-Encoding:Content-Type; b=XYIu4iv+6ifkwD91ZlNPmdws0uyW7jXoinhCsMAJZ/p2Ccn1nGI/0VO2fST76EwcW /pMtsxSa+HvZD8wibH+UgCZGwTYpZv2FCZbPGJTknjUjY10ms9SpMQ3us6Z+7SJP9n Q3Ct9fd/r3G8VycFpAgnlKi6wYb/siDn5yCQYNO1X4n4WQL8KBByouN3qoxRRDZegD X7N2XcNaIcitq4EKf5L/OfuPaSSE0cvTGT5v6GB0Ko8JPgcQBFP/tizMm1ZDxK8Ssr /f3IE/jI+baXlCqwUMHuVV3/ZzUVUEgju4AMlkms7fWFeJhs7suj97ZAElmr4x3oAY Etvo7THCkKMcA== Received: from mail.realtek.com (rtkexhmbs04.realtek.com.tw[10.21.1.54]) by rtits2.realtek.com.tw (8.15.2/3.21/5.94) with ESMTPS id 60MB90vlC913389 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Thu, 22 Jan 2026 19:09:00 +0800 Received: from RTKEXHMBS03.realtek.com.tw (10.21.1.53) by RTKEXHMBS04.realtek.com.tw (10.21.1.54) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.10; Thu, 22 Jan 2026 19:09:00 +0800 Received: from cn1dhc-k02 (172.21.252.101) by RTKEXHMBS03.realtek.com.tw (10.21.1.53) with Microsoft SMTP Server id 15.2.1748.10 via Frontend Transport; Thu, 22 Jan 2026 19:09:00 +0800 From: Yu-Chun Lin To: , , , , , , , CC: , , , , , , Subject: [PATCH v3 9/9] clk: realtek: Add RTD1625-ISO clock controller driver Date: Thu, 22 Jan 2026 19:08:57 +0800 Message-ID: <20260122110857.12995-10-eleanor.lin@realtek.com> X-Mailer: git-send-email 2.50.1 In-Reply-To: <20260122110857.12995-1-eleanor.lin@realtek.com> References: <20260122110857.12995-1-eleanor.lin@realtek.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Cheng-Yu Lee Add support for the ISO (Isolation) domain clock controller on the Realtek RTD1625 SoC. This controller manages clocks in the always-on power domain, ensuring essential services remain functional even when the main system power is gated. Signed-off-by: Cheng-Yu Lee Co-developed-by: Yu-Chun Lin Signed-off-by: Yu-Chun Lin --- Changes in v3: - None. --- drivers/clk/realtek/Makefile | 1 + drivers/clk/realtek/clk-rtd1625-iso.c | 153 ++++++++++++++++++++++++++ 2 files changed, 154 insertions(+) create mode 100644 drivers/clk/realtek/clk-rtd1625-iso.c diff --git a/drivers/clk/realtek/Makefile b/drivers/clk/realtek/Makefile index 3cda1e600172..e90fce42a85e 100644 --- a/drivers/clk/realtek/Makefile +++ b/drivers/clk/realtek/Makefile @@ -11,3 +11,4 @@ clk-rtk-y +=3D reset.o =20 clk-rtk-$(CONFIG_RTK_CLK_PLL_MMC) +=3D clk-pll-mmc.o obj-$(CONFIG_COMMON_CLK_RTD1625) +=3D clk-rtd1625-crt.o +obj-$(CONFIG_COMMON_CLK_RTD1625) +=3D clk-rtd1625-iso.o diff --git a/drivers/clk/realtek/clk-rtd1625-iso.c b/drivers/clk/realtek/cl= k-rtd1625-iso.c new file mode 100644 index 000000000000..fe268745812e --- /dev/null +++ b/drivers/clk/realtek/clk-rtd1625-iso.c @@ -0,0 +1,153 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2024 Realtek Semiconductor Corporation + * Author: Cheng-Yu Lee + */ + +#include +#include +#include +#include +#include +#include +#include "clk-regmap-gate.h" + +#define RTD1625_ISO_CLK_MAX 19 +#define RTD1625_ISO_S_CLK_MAX 5 + +static CLK_REGMAP_GATE_NO_PARENT(clk_en_usb_p4, 0, 0x08c, 0, 0); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_usb_p3, 0, 0x08c, 1, 0); +static CLK_REGMAP_GATE(clk_en_misc_cec0, "clk_en_misc", 0, 0x08c, 2, 0); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_cbusrx_sys, 0, 0x08c, 3, 0); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_cbustx_sys, 0, 0x08c, 4, 0); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_cbus_sys, 0, 0x08c, 5, 0); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_cbus_osc, 0, 0x08c, 6, 0); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_i2c0, 0, 0x08c, 9, 0); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_i2c1, 0, 0x08c, 10, 0); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_etn_250m, 0, 0x08c, 11, 0); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_etn_sys, 0, 0x08c, 12, 0); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_usb_drd, 0, 0x08c, 13, 0); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_usb_host, 0, 0x08c, 14, 0); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_usb_u3_host, 0, 0x08c, 15, 0); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_usb, 0, 0x08c, 16, 0); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_vtc, 0, 0x08c, 17, 0); +static CLK_REGMAP_GATE(clk_en_misc_vfd, "clk_en_misc", 0, 0x08c, 18, 0); + +static struct clk_regmap *rtd1625_clk_regmap_list[] =3D { + &clk_en_usb_p4.clkr, + &clk_en_usb_p3.clkr, + &clk_en_misc_cec0.clkr, + &clk_en_cbusrx_sys.clkr, + &clk_en_cbustx_sys.clkr, + &clk_en_cbus_sys.clkr, + &clk_en_cbus_osc.clkr, + &clk_en_i2c0.clkr, + &clk_en_i2c1.clkr, + &clk_en_etn_250m.clkr, + &clk_en_etn_sys.clkr, + &clk_en_usb_drd.clkr, + &clk_en_usb_host.clkr, + &clk_en_usb_u3_host.clkr, + &clk_en_usb.clkr, + &clk_en_vtc.clkr, + &clk_en_misc_vfd.clkr, +}; + +static struct clk_hw_onecell_data rtd1625_iso_clk_data =3D { + .num =3D RTD1625_ISO_CLK_MAX, + .hws =3D { + [RTD1625_ISO_CLK_EN_USB_P4] =3D &__clk_regmap_gate_hw(&clk_en_usb_p= 4), + [RTD1625_ISO_CLK_EN_USB_P3] =3D &__clk_regmap_gate_hw(&clk_en_usb_p= 3), + [RTD1625_ISO_CLK_EN_MISC_CEC0] =3D &__clk_regmap_gate_hw(&clk_en_misc_= cec0), + [RTD1625_ISO_CLK_EN_CBUSRX_SYS] =3D &__clk_regmap_gate_hw(&clk_en_cbusr= x_sys), + [RTD1625_ISO_CLK_EN_CBUSTX_SYS] =3D &__clk_regmap_gate_hw(&clk_en_cbust= x_sys), + [RTD1625_ISO_CLK_EN_CBUS_SYS] =3D &__clk_regmap_gate_hw(&clk_en_cbus_= sys), + [RTD1625_ISO_CLK_EN_CBUS_OSC] =3D &__clk_regmap_gate_hw(&clk_en_cbus_= osc), + [RTD1625_ISO_CLK_EN_I2C0] =3D &__clk_regmap_gate_hw(&clk_en_i2c0), + [RTD1625_ISO_CLK_EN_I2C1] =3D &__clk_regmap_gate_hw(&clk_en_i2c1), + [RTD1625_ISO_CLK_EN_ETN_250M] =3D &__clk_regmap_gate_hw(&clk_en_etn_2= 50m), + [RTD1625_ISO_CLK_EN_ETN_SYS] =3D &__clk_regmap_gate_hw(&clk_en_etn_s= ys), + [RTD1625_ISO_CLK_EN_USB_DRD] =3D &__clk_regmap_gate_hw(&clk_en_usb_d= rd), + [RTD1625_ISO_CLK_EN_USB_HOST] =3D &__clk_regmap_gate_hw(&clk_en_usb_h= ost), + [RTD1625_ISO_CLK_EN_USB_U3_HOST] =3D &__clk_regmap_gate_hw(&clk_en_usb_u= 3_host), + [RTD1625_ISO_CLK_EN_USB] =3D &__clk_regmap_gate_hw(&clk_en_usb), + [RTD1625_ISO_CLK_EN_VTC] =3D &__clk_regmap_gate_hw(&clk_en_vtc), + [RTD1625_ISO_CLK_EN_MISC_VFD] =3D &__clk_regmap_gate_hw(&clk_en_misc_= vfd), + [RTD1625_ISO_CLK_MAX] =3D NULL, + }, +}; + +static struct rtk_reset_bank rtd1625_iso_reset_banks[] =3D { + {.ofs =3D 0x88,}, +}; + +static const struct rtk_clk_desc rtd1625_iso_desc =3D { + .clk_data =3D &rtd1625_iso_clk_data, + .clks =3D rtd1625_clk_regmap_list, + .num_clks =3D ARRAY_SIZE(rtd1625_clk_regmap_list), + .reset_banks =3D rtd1625_iso_reset_banks, + .num_reset_banks =3D ARRAY_SIZE(rtd1625_iso_reset_banks), +}; + +static CLK_REGMAP_GATE_NO_PARENT(clk_en_irda, 0, 0x314, 6, 1); +static CLK_REGMAP_GATE_NO_PARENT(clk_en_ur10, 0, 0x314, 8, 1); + +static struct clk_regmap *rtd1625_iso_s_clk_regmap_list[] =3D { + &clk_en_irda.clkr, + &clk_en_ur10.clkr, +}; + +static struct clk_hw_onecell_data rtd1625_iso_s_clk_data =3D { + .num =3D RTD1625_ISO_S_CLK_MAX, + .hws =3D { + [RTD1625_ISO_S_CLK_EN_IRDA] =3D &__clk_regmap_gate_hw(&clk_en_irda), + [RTD1625_ISO_S_CLK_EN_UR10] =3D &__clk_regmap_gate_hw(&clk_en_ur10), + [RTD1625_ISO_S_CLK_MAX] =3D NULL, + }, +}; + +static struct rtk_reset_bank rtd1625_iso_s_reset_banks[] =3D { + {.ofs =3D 0x310, .write_en =3D 1,}, +}; + +static const struct rtk_clk_desc rtd1625_iso_s_desc =3D { + .clk_data =3D &rtd1625_iso_s_clk_data, + .clks =3D rtd1625_iso_s_clk_regmap_list, + .num_clks =3D ARRAY_SIZE(rtd1625_iso_s_clk_regmap_list), + .reset_banks =3D rtd1625_iso_s_reset_banks, + .num_reset_banks =3D ARRAY_SIZE(rtd1625_iso_s_reset_banks), +}; + +static int rtd1625_iso_probe(struct platform_device *pdev) +{ + const struct rtk_clk_desc *desc; + + desc =3D of_device_get_match_data(&pdev->dev); + if (!desc) + return -EINVAL; + return rtk_clk_probe(pdev, desc); +} + +static const struct of_device_id rtd1625_iso_match[] =3D { + {.compatible =3D "realtek,rtd1625-iso-clk", .data =3D &rtd1625_iso_desc}, + {.compatible =3D "realtek,rtd1625-iso-s-clk", .data =3D &rtd1625_iso_s_de= sc}, + {/* sentinel */} +}; + +static struct platform_driver rtd1625_iso_driver =3D { + .probe =3D rtd1625_iso_probe, + .driver =3D { + .name =3D "rtk-rtd1625-iso-clk", + .of_match_table =3D rtd1625_iso_match, + }, +}; + +static int __init rtd1625_iso_init(void) +{ + return platform_driver_register(&rtd1625_iso_driver); +} +subsys_initcall(rtd1625_iso_init); + +MODULE_DESCRIPTION("Realtek RTD1625 ISO Controller Driver"); +MODULE_AUTHOR("Cheng-Yu Lee "); +MODULE_LICENSE("GPL"); --=20 2.34.1