Skip to content

Commit 94087c3

Browse files
UtsavAgarwalADIUtsavAgarwalADI
committed
clk: adi: SC58x: Adding support for sc58x devices
Currently only supported for sc589-mini Signed-off-by: Utsav Agarwal <utsav.agarwal@analog.com>
1 parent d7660e4 commit 94087c3

File tree

4 files changed

+236
-0
lines changed

4 files changed

+236
-0
lines changed

‎arch/arm/mach-sc5xx/Kconfig

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -40,3 +40,10 @@ config ARCH_SC58X
4040
SoCs, like the SC589. It does not include the 64-bit Cortex-A55-based
4141
SoCs (see ARCH_SC58X_64 for those).
4242

43+
config MACH_SC589_MINI
44+
bool "ADI sc589-mini board"
45+
depends on ARCH_SC58X
46+
select MIGHT_HAVE_PCI
47+
help
48+
Say 'Y' here if you want your kernel to run on the ADI
49+
SC589-MINI board.

‎drivers/clk/adi/Kconfig

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,12 @@
11
# SPDX-License-Identifier: GPL-2.0-only
2+
config COMMON_CLK_ADI_SC58X
3+
bool "ADI SC589 clock driver"
4+
help
5+
This enables the ADI SC589 clock driver. The driver provides
6+
support for the clock controller on the ADI SC589 SoC.
7+
If you are using the ADI SC589 SoC, say Y here.
8+
If unsure, say N.
9+
210
config COMMON_CLK_ADI_SC594
311
bool "ADI SC594 clock driver"
412
help

‎drivers/clk/adi/Makefile

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -7,3 +7,7 @@ obj-$(CONFIG_COMMON_CLK_ADI_SC598) += clk-adi-sc598.o
77
#SC594
88
obj-$(CONFIG_COMMON_CLK_ADI_SC594) += clk-adi-pll.o
99
obj-$(CONFIG_COMMON_CLK_ADI_SC594) += clk-adi-sc594.o
10+
11+
#SC58X
12+
obj-$(CONFIG_COMMON_CLK_ADI_SC58X) += clk-adi-pll.o
13+
obj-$(CONFIG_COMMON_CLK_ADI_SC58X) += clk-adi-sc58x.o

‎drivers/clk/adi/clk-adi-sc58x.c

Lines changed: 217 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,217 @@
1+
// SPDX-License-Identifier: GPL-2.0-or-later
2+
/*
3+
* Clock support for ADI processor
4+
*
5+
* (C) Copyright 2022 - Analog Devices, Inc.
6+
*
7+
* Written and/or maintained by Timesys Corporation
8+
*
9+
* Author: Greg Malysa <greg.malysa@timesys.com>
10+
* Contact: Nathan Barrett-Morrison <nathan.morrison@timesys.com>
11+
*
12+
*/
13+
14+
#include <dt-bindings/clock/adi-sc5xx-clock.h>
15+
#include <linux/err.h>
16+
#include <linux/clk.h>
17+
#include <linux/clk-provider.h>
18+
#include <linux/module.h>
19+
#include <linux/of.h>
20+
#include <linux/of_address.h>
21+
#include <linux/types.h>
22+
#include <linux/spinlock.h>
23+
24+
#include "clk.h"
25+
26+
static DEFINE_SPINLOCK(cdu_lock);
27+
28+
static struct clk *clks[ADSP_SC58X_CLK_END];
29+
static struct clk_onecell_data clk_data;
30+
31+
static const char * const cgu1_in_sels[] = {"sys_clkin0", "sys_clkin1"};
32+
static const char * const sharc0_sels[] = {"cclk0_0", "sysclk_0", "dummy", "dummy"};
33+
static const char * const sharc1_sels[] = {"cclk0_0", "sysclk_0", "dummy", "dummy"};
34+
static const char * const arm_sels[] = {"cclk1_0", "sysclk_0", "dummy", "dummy"};
35+
static const char * const cdu_ddr_sels[] = {"dclk_0", "dclk_1", "dummy", "dummy"};
36+
static const char * const can_sels[] = {"oclk_0", "oclk_1", "dclk_1", "dummy"};
37+
static const char * const spdif_sels[] = {"oclk_0", "oclk_1", "dclk_1", "dclk_0"};
38+
static const char * const reserved_sels[] = {"sclk0_0", "oclk_0", "dummy", "dummy"};
39+
static const char * const gige_sels[] = {"sclk0_0", "sclk1_1", "cclk0_1", "oclk_0"};
40+
static const char * const lp_sels[] = {"sclk0_0", "sclk0_1", "cclk1_1", "dclk_1"};
41+
static const char * const sdio_sels[] = {"oclk_0_half", "cclk1_1_half", "cclk1_1", "dclk_1"};
42+
43+
static void sc58x_clock_probe(struct device_node *np)
44+
{
45+
void __iomem *cgu0;
46+
void __iomem *cgu1;
47+
void __iomem *cdu;
48+
int ret;
49+
int i;
50+
51+
cgu0 = of_iomap(np, 0);
52+
if (IS_ERR(cgu0)) {
53+
pr_err("Unable to remap CGU0 address (resource 0)\n");
54+
return;
55+
}
56+
57+
cgu1 = of_iomap(np, 1);
58+
if (IS_ERR(cgu1)) {
59+
pr_err("Unable to remap CGU1 address (resource 1)\n");
60+
return;
61+
}
62+
63+
cdu = of_iomap(np, 2);
64+
if (IS_ERR(cdu)) {
65+
pr_err("Unable to remap CDU address (resource 2)\n");
66+
return;
67+
}
68+
69+
// Input clock configuration
70+
clks[ADSP_SC58X_CLK_DUMMY] = clk_register_fixed_rate(NULL, "dummy", NULL, 0, 0);
71+
clks[ADSP_SC58X_CLK_SYS_CLKIN0] = of_clk_get_by_name(np, "sys_clkin0");
72+
clks[ADSP_SC58X_CLK_SYS_CLKIN1] = of_clk_get_by_name(np, "sys_clkin1");
73+
clks[ADSP_SC58X_CLK_CGU1_IN] = clk_register_mux(NULL, "cgu1_in_sel",
74+
cgu1_in_sels, 2, CLK_SET_RATE_PARENT, cdu + CDU_CLKINSEL, 0, 1, 0,
75+
&cdu_lock);
76+
77+
// CGU configuration and internal clocks
78+
clks[ADSP_SC58X_CLK_CGU0_PLL_IN] = clk_register_divider(NULL, "cgu0_df",
79+
"sys_clkin0", CLK_SET_RATE_PARENT, cgu0 + CGU_CTL, 0, 1, 0, &cdu_lock);
80+
clks[ADSP_SC58X_CLK_CGU1_PLL_IN] = clk_register_divider(NULL, "cgu1_df",
81+
"cgu1_in_sel", CLK_SET_RATE_PARENT, cgu1 + CGU_CTL, 0, 1, 0, &cdu_lock);
82+
83+
// VCO output inside PLL
84+
clks[ADSP_SC58X_CLK_CGU0_VCO_OUT] = sc5xx_cgu_pll("cgu0_vco", "cgu0_df",
85+
cgu0 + CGU_CTL, CGU_MSEL_SHIFT, CGU_MSEL_WIDTH, 0, false, &cdu_lock);
86+
clks[ADSP_SC58X_CLK_CGU1_VCO_OUT] = sc5xx_cgu_pll("cgu1_vco", "cgu1_df",
87+
cgu1 + CGU_CTL, CGU_MSEL_SHIFT, CGU_MSEL_WIDTH, 0, false, &cdu_lock);
88+
89+
// Final PLL output
90+
clks[ADSP_SC58X_CLK_CGU0_PLLCLK] = clk_register_fixed_factor(NULL,
91+
"cgu0_pllclk", "cgu0_vco", CLK_SET_RATE_PARENT, 1, 1);
92+
clks[ADSP_SC58X_CLK_CGU1_PLLCLK] = clk_register_fixed_factor(NULL,
93+
"cgu1_pllclk", "cgu1_vco", CLK_SET_RATE_PARENT, 1, 1);
94+
95+
// Dividers from pll output
96+
clks[ADSP_SC58X_CLK_CGU0_CDIV] = cgu_divider("cgu0_cdiv", "cgu0_pllclk",
97+
cgu0 + CGU_DIV, 0, 5, 0, &cdu_lock);
98+
clks[ADSP_SC58X_CLK_CGU0_SYSCLK] = cgu_divider("sysclk_0", "cgu0_pllclk",
99+
cgu0 + CGU_DIV, 8, 5, 0, &cdu_lock);
100+
clks[ADSP_SC58X_CLK_CGU0_DDIV] = cgu_divider("cgu0_ddiv", "cgu0_pllclk",
101+
cgu0 + CGU_DIV, 16, 5, 0, &cdu_lock);
102+
clks[ADSP_SC58X_CLK_CGU0_ODIV] = cgu_divider("cgu0_odiv", "cgu0_pllclk",
103+
cgu0 + CGU_DIV, 22, 7, 0, &cdu_lock);
104+
clks[ADSP_SC58X_CLK_CGU0_S0SELDIV] = cgu_divider("cgu0_s0seldiv",
105+
"sysclk_0", cgu0 + CGU_DIV, 5, 3, 0, &cdu_lock);
106+
clks[ADSP_SC58X_CLK_CGU0_S1SELDIV] = cgu_divider("cgu0_s1seldiv",
107+
"sysclk_0", cgu0 + CGU_DIV, 13, 3, 0, &cdu_lock);
108+
109+
clks[ADSP_SC58X_CLK_CGU1_CDIV] = cgu_divider("cgu1_cdiv", "cgu1_pllclk",
110+
cgu1 + CGU_DIV, 0, 5, 0, &cdu_lock);
111+
clks[ADSP_SC58X_CLK_CGU1_SYSCLK] = cgu_divider("sysclk_1", "cgu1_pllclk",
112+
cgu1 + CGU_DIV, 8, 5, 0, &cdu_lock);
113+
clks[ADSP_SC58X_CLK_CGU1_DDIV] = cgu_divider("cgu1_ddiv", "cgu1_pllclk",
114+
cgu1 + CGU_DIV, 16, 5, 0, &cdu_lock);
115+
clks[ADSP_SC58X_CLK_CGU1_ODIV] = cgu_divider("cgu1_odiv", "cgu1_pllclk",
116+
cgu1 + CGU_DIV, 22, 7, 0, &cdu_lock);
117+
clks[ADSP_SC58X_CLK_CGU1_S0SELDIV] = cgu_divider("cgu1_s0seldiv",
118+
"sysclk_1", cgu1 + CGU_DIV, 5, 3, 0, &cdu_lock);
119+
clks[ADSP_SC58X_CLK_CGU1_S1SELDIV] = cgu_divider("cgu1_s1seldiv",
120+
"sysclk_1", cgu1 + CGU_DIV, 13, 3, 0, &cdu_lock);
121+
122+
// Gates to enable CGU outputs
123+
clks[ADSP_SC58X_CLK_CGU0_CCLK0] = cgu_gate("cclk0_0", "cgu0_cdiv",
124+
cgu0 + CGU_CCBF_DIS, 0, &cdu_lock);
125+
clks[ADSP_SC58X_CLK_CGU0_CCLK1] = cgu_gate("cclk1_0", "cgu0_cdiv",
126+
cgu1 + CGU_CCBF_DIS, 1, &cdu_lock);
127+
clks[ADSP_SC58X_CLK_CGU0_OCLK] = cgu_gate("oclk_0", "cgu0_odiv",
128+
cgu0 + CGU_SCBF_DIS, 3, &cdu_lock);
129+
clks[ADSP_SC58X_CLK_CGU0_DCLK] = cgu_gate("dclk_0", "cgu0_ddiv",
130+
cgu0 + CGU_SCBF_DIS, 2, &cdu_lock);
131+
clks[ADSP_SC58X_CLK_CGU0_SCLK1] = cgu_gate("sclk1_0", "cgu0_s1seldiv",
132+
cgu0 + CGU_SCBF_DIS, 1, &cdu_lock);
133+
clks[ADSP_SC58X_CLK_CGU0_SCLK0] = cgu_gate("sclk0_0", "cgu0_s0seldiv",
134+
cgu0 + CGU_SCBF_DIS, 0, &cdu_lock);
135+
136+
clks[ADSP_SC58X_CLK_CGU1_CCLK0] = cgu_gate("cclk0_1", "cgu1_cdiv",
137+
cgu1 + CGU_CCBF_DIS, 0, &cdu_lock);
138+
clks[ADSP_SC58X_CLK_CGU1_CCLK1] = cgu_gate("cclk1_1", "cgu1_cdiv",
139+
cgu1 + CGU_CCBF_DIS, 1, &cdu_lock);
140+
clks[ADSP_SC58X_CLK_CGU1_OCLK] = cgu_gate("oclk_1", "cgu1_odiv",
141+
cgu1 + CGU_SCBF_DIS, 3, &cdu_lock);
142+
clks[ADSP_SC58X_CLK_CGU1_DCLK] = cgu_gate("dclk_1", "cgu1_ddiv",
143+
cgu1 + CGU_SCBF_DIS, 2, &cdu_lock);
144+
clks[ADSP_SC58X_CLK_CGU1_SCLK1] = cgu_gate("sclk1_1", "cgu1_s1seldiv",
145+
cgu1 + CGU_SCBF_DIS, 1, &cdu_lock);
146+
clks[ADSP_SC58X_CLK_CGU1_SCLK0] = cgu_gate("sclk0_1", "cgu1_s0seldiv",
147+
cgu1 + CGU_SCBF_DIS, 0, &cdu_lock);
148+
149+
// Extra half rate clocks generated in the CDU
150+
clks[ADSP_SC58X_CLK_OCLK0_HALF] = clk_register_fixed_factor(NULL, "oclk_0_half",
151+
"oclk_0", CLK_SET_RATE_PARENT, 1, 2);
152+
clks[ADSP_SC58X_CLK_CCLK1_1_HALF] = clk_register_fixed_factor(NULL, "cclk1_1_half",
153+
"cclk1_1", CLK_SET_RATE_PARENT, 1, 2);
154+
155+
// CDU output muxes
156+
clks[ADSP_SC58X_CLK_SHARC0_SEL] = cdu_mux("sharc0_sel", cdu + CDU_CFG0,
157+
sharc0_sels, &cdu_lock);
158+
clks[ADSP_SC58X_CLK_SHARC1_SEL] = cdu_mux("sharc1_sel", cdu + CDU_CFG1,
159+
sharc1_sels, &cdu_lock);
160+
clks[ADSP_SC58X_CLK_ARM_SEL] = cdu_mux("arm_sel", cdu + CDU_CFG2,
161+
arm_sels, &cdu_lock);
162+
clks[ADSP_SC58X_CLK_CDU_DDR_SEL] = cdu_mux("cdu_ddr_sel", cdu + CDU_CFG3,
163+
cdu_ddr_sels, &cdu_lock);
164+
clks[ADSP_SC58X_CLK_CAN_SEL] = cdu_mux("can_sel", cdu + CDU_CFG4,
165+
can_sels, &cdu_lock);
166+
clks[ADSP_SC58X_CLK_SPDIF_SEL] = cdu_mux("spdif_sel", cdu + CDU_CFG5,
167+
spdif_sels, &cdu_lock);
168+
clks[ADSP_SC58X_CLK_RESERVED_SEL] = cdu_mux("reserved_sel", cdu + CDU_CFG6,
169+
reserved_sels, &cdu_lock);
170+
clks[ADSP_SC58X_CLK_GIGE_SEL] = cdu_mux("gige_sel", cdu + CDU_CFG7,
171+
gige_sels, &cdu_lock);
172+
clks[ADSP_SC58X_CLK_LP_SEL] = cdu_mux("lp_sel", cdu + CDU_CFG8, lp_sels,
173+
&cdu_lock);
174+
clks[ADSP_SC58X_CLK_SDIO_SEL] = cdu_mux("sdio_sel", cdu + CDU_CFG9, sdio_sels,
175+
&cdu_lock);
176+
177+
// CDU output enable gates
178+
clks[ADSP_SC58X_CLK_SHARC0] = cdu_gate("sharc0", "sharc0_sel",
179+
cdu + CDU_CFG0, CLK_IS_CRITICAL, &cdu_lock);
180+
clks[ADSP_SC58X_CLK_SHARC1] = cdu_gate("sharc1", "sharc1_sel",
181+
cdu + CDU_CFG1, CLK_IS_CRITICAL, &cdu_lock);
182+
clks[ADSP_SC58X_CLK_ARM] = cdu_gate("arm", "arm_sel", cdu + CDU_CFG2,
183+
CLK_IS_CRITICAL, &cdu_lock);
184+
clks[ADSP_SC58X_CLK_CDU_DDR] = cdu_gate("cdu_ddr", "cdu_ddr_sel",
185+
cdu + CDU_CFG3, CLK_IS_CRITICAL, &cdu_lock);
186+
clks[ADSP_SC58X_CLK_CAN] = cdu_gate("can", "can_sel", cdu + CDU_CFG4, 0,
187+
&cdu_lock);
188+
clks[ADSP_SC58X_CLK_SPDIF] = cdu_gate("spdif", "spdif_sel", cdu + CDU_CFG5,
189+
0, &cdu_lock);
190+
clks[ADSP_SC58X_CLK_RESERVED] = cdu_gate("reserved", "reserved_sel",
191+
cdu + CDU_CFG6, 0, &cdu_lock);
192+
clks[ADSP_SC58X_CLK_GIGE] = cdu_gate("gige", "gige_sel", cdu + CDU_CFG7, 0,
193+
&cdu_lock);
194+
clks[ADSP_SC58X_CLK_LP] = cdu_gate("lp", "lp_sel", cdu + CDU_CFG8, 0, &cdu_lock);
195+
clks[ADSP_SC58X_CLK_SDIO] = cdu_gate("sdio", "sdio_sel", cdu + CDU_CFG9, 0,
196+
&cdu_lock);
197+
198+
ret = cdu_check_clocks(clks, ARRAY_SIZE(clks));
199+
if (ret)
200+
goto cleanup;
201+
202+
clk_data.clks = clks;
203+
clk_data.clk_num = ARRAY_SIZE(clks);
204+
ret = of_clk_add_provider(np, of_clk_src_onecell_get, &clk_data);
205+
if (ret < 0) {
206+
pr_err("Failed to register SoC clock information\n");
207+
goto cleanup;
208+
}
209+
210+
return;
211+
212+
cleanup:
213+
for (i = 0; i < ARRAY_SIZE(clks); i++)
214+
clk_unregister(clks[i]);
215+
}
216+
217+
CLK_OF_DECLARE(sc58x_clocks, "adi,sc58x-clocks", sc58x_clock_probe);

0 commit comments

Comments
 (0)