xref: /openbmc/u-boot/arch/arm/mach-imx/mx7ulp/pcc.c (revision f77d4410) 
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2016 Freescale Semiconductor, Inc.
4  */
5 
6 #include <common.h>
7 #include <div64.h>
8 #include <asm/io.h>
9 #include <errno.h>
10 #include <asm/arch/imx-regs.h>
11 #include <asm/arch/pcc.h>
12 #include <asm/arch/sys_proto.h>
13 
14 #define PCC_CLKSRC_TYPES 2
15 #define PCC_CLKSRC_NUM 7
16 
17 static enum scg_clk pcc_clksrc[PCC_CLKSRC_TYPES][PCC_CLKSRC_NUM] = {
18 	{	SCG_NIC1_BUS_CLK,
19 		SCG_NIC1_CLK,
20 		SCG_DDR_CLK,
21 		SCG_APLL_PFD2_CLK,
22 		SCG_APLL_PFD1_CLK,
23 		SCG_APLL_PFD0_CLK,
24 		USB_PLL_OUT,
25 	},
26 	{	SCG_SOSC_DIV2_CLK,  /* SOSC BUS clock */
27 		MIPI_PLL_OUT,
28 		SCG_FIRC_DIV2_CLK,  /* FIRC BUS clock */
29 		SCG_ROSC_CLK,
30 		SCG_NIC1_BUS_CLK,
31 		SCG_NIC1_CLK,
32 		SCG_APLL_PFD3_CLK,
33 	},
34 };
35 
36 static struct pcc_entry pcc_arrays[] = {
37 	{PCC2_RBASE, DMA1_PCC2_SLOT,		CLKSRC_NO_PCS, PCC_NO_DIV},
38 	{PCC2_RBASE, RGPIO1_PCC2_SLOT,		CLKSRC_NO_PCS, PCC_NO_DIV},
39 	{PCC2_RBASE, FLEXBUS0_PCC2_SLOT,	CLKSRC_NO_PCS, PCC_NO_DIV},
40 	{PCC2_RBASE, SEMA42_1_PCC2_SLOT,	CLKSRC_NO_PCS, PCC_NO_DIV},
41 	{PCC2_RBASE, DMA1_CH_MUX0_PCC2_SLOT,	CLKSRC_NO_PCS, PCC_NO_DIV},
42 	{PCC2_RBASE, SNVS_PCC2_SLOT,		CLKSRC_NO_PCS, PCC_NO_DIV},
43 	{PCC2_RBASE, CAAM_PCC2_SLOT,		CLKSRC_NO_PCS, PCC_NO_DIV},
44 	{PCC2_RBASE, LPTPM4_PCC2_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
45 	{PCC2_RBASE, LPTPM5_PCC2_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
46 	{PCC2_RBASE, LPIT1_PCC2_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
47 	{PCC2_RBASE, LPSPI2_PCC2_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
48 	{PCC2_RBASE, LPSPI3_PCC2_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
49 	{PCC2_RBASE, LPI2C4_PCC2_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
50 	{PCC2_RBASE, LPI2C5_PCC2_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
51 	{PCC2_RBASE, LPUART4_PCC2_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
52 	{PCC2_RBASE, LPUART5_PCC2_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
53 	{PCC2_RBASE, FLEXIO1_PCC2_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
54 	{PCC2_RBASE, USBOTG0_PCC2_SLOT,		CLKSRC_PER_PLAT, PCC_HAS_DIV},
55 	{PCC2_RBASE, USBOTG1_PCC2_SLOT,		CLKSRC_PER_PLAT, PCC_HAS_DIV},
56 	{PCC2_RBASE, USBPHY_PCC2_SLOT,		CLKSRC_NO_PCS, PCC_NO_DIV},
57 	{PCC2_RBASE, USB_PL301_PCC2_SLOT,	CLKSRC_NO_PCS, PCC_NO_DIV},
58 	{PCC2_RBASE, USDHC0_PCC2_SLOT,		CLKSRC_PER_PLAT, PCC_HAS_DIV},
59 	{PCC2_RBASE, USDHC1_PCC2_SLOT,		CLKSRC_PER_PLAT, PCC_HAS_DIV},
60 	{PCC2_RBASE, WDG1_PCC2_SLOT,		CLKSRC_PER_BUS,	PCC_HAS_DIV},
61 	{PCC2_RBASE, WDG2_PCC2_SLOT,		CLKSRC_PER_BUS, PCC_HAS_DIV},
62 
63 	{PCC3_RBASE, LPTPM6_PCC3_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
64 	{PCC3_RBASE, LPTPM7_PCC3_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
65 	{PCC3_RBASE, LPI2C6_PCC3_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
66 	{PCC3_RBASE, LPI2C7_PCC3_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
67 	{PCC3_RBASE, LPUART6_PCC3_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
68 	{PCC3_RBASE, LPUART7_PCC3_SLOT,		CLKSRC_PER_BUS, PCC_NO_DIV},
69 	{PCC3_RBASE, VIU0_PCC3_SLOT,		CLKSRC_NO_PCS, PCC_NO_DIV},
70 	{PCC3_RBASE, DSI0_PCC3_SLOT,		CLKSRC_PER_BUS, PCC_HAS_DIV},
71 	{PCC3_RBASE, LCDIF0_PCC3_SLOT,		CLKSRC_PER_PLAT, PCC_HAS_DIV},
72 	{PCC3_RBASE, MMDC0_PCC3_SLOT,		CLKSRC_NO_PCS, PCC_NO_DIV},
73 	{PCC3_RBASE, PORTC_PCC3_SLOT,		CLKSRC_NO_PCS, PCC_NO_DIV},
74 	{PCC3_RBASE, PORTD_PCC3_SLOT,		CLKSRC_NO_PCS, PCC_NO_DIV},
75 	{PCC3_RBASE, PORTE_PCC3_SLOT,		CLKSRC_NO_PCS, PCC_NO_DIV},
76 	{PCC3_RBASE, PORTF_PCC3_SLOT,		CLKSRC_NO_PCS, PCC_NO_DIV},
77 	{PCC3_RBASE, GPU3D_PCC3_SLOT,		CLKSRC_PER_PLAT, PCC_NO_DIV},
78 	{PCC3_RBASE, GPU2D_PCC3_SLOT,		CLKSRC_PER_PLAT, PCC_NO_DIV},
79 };
80 
81 int pcc_clock_enable(enum pcc_clk clk, bool enable)
82 {
83 	u32 reg, val;
84 
85 	if (clk >= ARRAY_SIZE(pcc_arrays))
86 		return -EINVAL;
87 
88 	reg = pcc_arrays[clk].pcc_base + pcc_arrays[clk].pcc_slot * 4;
89 
90 	val = readl(reg);
91 
92 	clk_debug("pcc_clock_enable: clk %d, reg 0x%x, val 0x%x, enable %d\n",
93 		  clk, reg, val, enable);
94 
95 	if (!(val & PCC_PR_MASK) || (val & PCC_INUSE_MASK))
96 		return -EPERM;
97 
98 	if (enable)
99 		val |= PCC_CGC_MASK;
100 	else
101 		val &= ~PCC_CGC_MASK;
102 
103 	writel(val, reg);
104 
105 	clk_debug("pcc_clock_enable: val 0x%x\n", val);
106 
107 	return 0;
108 }
109 
110 /* The clock source select needs clock is disabled */
111 int pcc_clock_sel(enum pcc_clk clk, enum scg_clk src)
112 {
113 	u32 reg, val, i, clksrc_type;
114 
115 	if (clk >= ARRAY_SIZE(pcc_arrays))
116 		return -EINVAL;
117 
118 	clksrc_type = pcc_arrays[clk].clksrc;
119 	if (clksrc_type >= CLKSRC_NO_PCS) {
120 		printf("No PCS field for the PCC %d, clksrc type %d\n",
121 		       clk, clksrc_type);
122 		return -EPERM;
123 	}
124 
125 	for (i = 0; i < PCC_CLKSRC_NUM; i++) {
126 		if (pcc_clksrc[clksrc_type][i] == src) {
127 			/* Find the clock src, then set it to PCS */
128 			break;
129 		}
130 	}
131 
132 	if (i == PCC_CLKSRC_NUM) {
133 		printf("Not find the parent scg_clk in PCS of PCC %d, invalid scg_clk %d\n", clk, src);
134 		return -EINVAL;
135 	}
136 
137 	reg = pcc_arrays[clk].pcc_base + pcc_arrays[clk].pcc_slot * 4;
138 
139 	val = readl(reg);
140 
141 	clk_debug("pcc_clock_sel: clk %d, reg 0x%x, val 0x%x, clksrc_type %d\n",
142 		  clk, reg, val, clksrc_type);
143 
144 	if (!(val & PCC_PR_MASK) || (val & PCC_INUSE_MASK) ||
145 	    (val & PCC_CGC_MASK)) {
146 		printf("Not permit to select clock source val = 0x%x\n", val);
147 		return -EPERM;
148 	}
149 
150 	val &= ~PCC_PCS_MASK;
151 	val |= ((i + 1) << PCC_PCS_OFFSET);
152 
153 	writel(val, reg);
154 
155 	clk_debug("pcc_clock_sel: val 0x%x\n", val);
156 
157 	return 0;
158 }
159 
160 int pcc_clock_div_config(enum pcc_clk clk, bool frac, u8 div)
161 {
162 	u32 reg, val;
163 
164 	if (clk >= ARRAY_SIZE(pcc_arrays) || div > 8 ||
165 	    (div == 1 && frac != 0))
166 		return -EINVAL;
167 
168 	if (pcc_arrays[clk].div >= PCC_NO_DIV) {
169 		printf("No DIV/FRAC field for the PCC %d\n", clk);
170 		return -EPERM;
171 	}
172 
173 	reg = pcc_arrays[clk].pcc_base + pcc_arrays[clk].pcc_slot * 4;
174 
175 	val = readl(reg);
176 
177 	if (!(val & PCC_PR_MASK) || (val & PCC_INUSE_MASK) ||
178 	    (val & PCC_CGC_MASK)) {
179 		printf("Not permit to set div/frac val = 0x%x\n", val);
180 		return -EPERM;
181 	}
182 
183 	if (frac)
184 		val |= PCC_FRAC_MASK;
185 	else
186 		val &= ~PCC_FRAC_MASK;
187 
188 	val &= ~PCC_PCD_MASK;
189 	val |= (div - 1) & PCC_PCD_MASK;
190 
191 	writel(val, reg);
192 
193 	return 0;
194 }
195 
196 bool pcc_clock_is_enable(enum pcc_clk clk)
197 {
198 	u32 reg, val;
199 
200 	if (clk >= ARRAY_SIZE(pcc_arrays))
201 		return -EINVAL;
202 
203 	reg = pcc_arrays[clk].pcc_base + pcc_arrays[clk].pcc_slot * 4;
204 	val = readl(reg);
205 
206 	if ((val & PCC_INUSE_MASK) || (val & PCC_CGC_MASK))
207 		return true;
208 
209 	return false;
210 }
211 
212 int pcc_clock_get_clksrc(enum pcc_clk clk, enum scg_clk *src)
213 {
214 	u32 reg, val, clksrc_type;
215 
216 	if (clk >= ARRAY_SIZE(pcc_arrays))
217 		return -EINVAL;
218 
219 	clksrc_type = pcc_arrays[clk].clksrc;
220 	if (clksrc_type >= CLKSRC_NO_PCS) {
221 		printf("No PCS field for the PCC %d, clksrc type %d\n",
222 		       clk, clksrc_type);
223 		return -EPERM;
224 	}
225 
226 	reg = pcc_arrays[clk].pcc_base + pcc_arrays[clk].pcc_slot * 4;
227 
228 	val = readl(reg);
229 
230 	clk_debug("pcc_clock_get_clksrc: clk %d, reg 0x%x, val 0x%x, type %d\n",
231 		  clk, reg, val, clksrc_type);
232 
233 	if (!(val & PCC_PR_MASK)) {
234 		printf("This pcc slot is not present = 0x%x\n", val);
235 		return -EPERM;
236 	}
237 
238 	val &= PCC_PCS_MASK;
239 	val = (val >> PCC_PCS_OFFSET);
240 
241 	if (!val) {
242 		printf("Clock source is off\n");
243 		return -EIO;
244 	}
245 
246 	*src = pcc_clksrc[clksrc_type][val - 1];
247 
248 	clk_debug("pcc_clock_get_clksrc: parent scg clk %d\n", *src);
249 
250 	return 0;
251 }
252 
253 u32 pcc_clock_get_rate(enum pcc_clk clk)
254 {
255 	u32 reg, val, rate, frac, div;
256 	enum scg_clk parent;
257 	int ret;
258 
259 	ret = pcc_clock_get_clksrc(clk, &parent);
260 	if (ret)
261 		return 0;
262 
263 	rate = scg_clk_get_rate(parent);
264 
265 	clk_debug("pcc_clock_get_rate: parent rate %u\n", rate);
266 
267 	if (pcc_arrays[clk].div == PCC_HAS_DIV) {
268 		reg = pcc_arrays[clk].pcc_base + pcc_arrays[clk].pcc_slot * 4;
269 		val = readl(reg);
270 
271 		frac = (val & PCC_FRAC_MASK) >> PCC_FRAC_OFFSET;
272 		div = (val & PCC_PCD_MASK) >> PCC_PCD_OFFSET;
273 
274 		/*
275 		 * Theoretically don't have overflow in the calc,
276 		 * the rate won't exceed 2G
277 		 */
278 		rate = rate * (frac + 1) / (div + 1);
279 	}
280 
281 	clk_debug("pcc_clock_get_rate: rate %u\n", rate);
282 	return rate;
283 }
284