Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/cmarinas...
[linux-2.6.git] / arch / mips / lantiq / xway / clk-xway.c
1 /*
2  *  This program is free software; you can redistribute it and/or modify it
3  *  under the terms of the GNU General Public License version 2 as published
4  *  by the Free Software Foundation.
5  *
6  *  Copyright (C) 2010 John Crispin <blogic@openwrt.org>
7  */
8
9 #include <linux/io.h>
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/clk.h>
13
14 #include <asm/time.h>
15 #include <asm/irq.h>
16 #include <asm/div64.h>
17
18 #include <lantiq_soc.h>
19
20 static unsigned int ltq_ram_clocks[] = {
21         CLOCK_167M, CLOCK_133M, CLOCK_111M, CLOCK_83M };
22 #define DDR_HZ ltq_ram_clocks[ltq_cgu_r32(LTQ_CGU_SYS) & 0x3]
23
24 #define BASIC_FREQUENCY_1       35328000
25 #define BASIC_FREQUENCY_2       36000000
26 #define BASIS_REQUENCY_USB      12000000
27
28 #define GET_BITS(x, msb, lsb) \
29         (((x) & ((1 << ((msb) + 1)) - 1)) >> (lsb))
30
31 #define LTQ_CGU_PLL0_CFG        0x0004
32 #define LTQ_CGU_PLL1_CFG        0x0008
33 #define LTQ_CGU_PLL2_CFG        0x000C
34 #define LTQ_CGU_SYS             0x0010
35 #define LTQ_CGU_UPDATE          0x0014
36 #define LTQ_CGU_IF_CLK          0x0018
37 #define LTQ_CGU_OSC_CON         0x001C
38 #define LTQ_CGU_SMD             0x0020
39 #define LTQ_CGU_CT1SR           0x0028
40 #define LTQ_CGU_CT2SR           0x002C
41 #define LTQ_CGU_PCMCR           0x0030
42 #define LTQ_CGU_PCI_CR          0x0034
43 #define LTQ_CGU_PD_PC           0x0038
44 #define LTQ_CGU_FMR             0x003C
45
46 #define CGU_PLL0_PHASE_DIVIDER_ENABLE   \
47         (ltq_cgu_r32(LTQ_CGU_PLL0_CFG) & (1 << 31))
48 #define CGU_PLL0_BYPASS                 \
49         (ltq_cgu_r32(LTQ_CGU_PLL0_CFG) & (1 << 30))
50 #define CGU_PLL0_CFG_DSMSEL             \
51         (ltq_cgu_r32(LTQ_CGU_PLL0_CFG) & (1 << 28))
52 #define CGU_PLL0_CFG_FRAC_EN            \
53         (ltq_cgu_r32(LTQ_CGU_PLL0_CFG) & (1 << 27))
54 #define CGU_PLL1_SRC                    \
55         (ltq_cgu_r32(LTQ_CGU_PLL1_CFG) & (1 << 31))
56 #define CGU_PLL2_PHASE_DIVIDER_ENABLE   \
57         (ltq_cgu_r32(LTQ_CGU_PLL2_CFG) & (1 << 20))
58 #define CGU_SYS_FPI_SEL                 (1 << 6)
59 #define CGU_SYS_DDR_SEL                 0x3
60 #define CGU_PLL0_SRC                    (1 << 29)
61
62 #define CGU_PLL0_CFG_PLLK       GET_BITS(ltq_cgu_r32(LTQ_CGU_PLL0_CFG), 26, 17)
63 #define CGU_PLL0_CFG_PLLN       GET_BITS(ltq_cgu_r32(LTQ_CGU_PLL0_CFG), 12, 6)
64 #define CGU_PLL0_CFG_PLLM       GET_BITS(ltq_cgu_r32(LTQ_CGU_PLL0_CFG), 5, 2)
65 #define CGU_PLL2_SRC            GET_BITS(ltq_cgu_r32(LTQ_CGU_PLL2_CFG), 18, 17)
66 #define CGU_PLL2_CFG_INPUT_DIV  GET_BITS(ltq_cgu_r32(LTQ_CGU_PLL2_CFG), 16, 13)
67
68 static unsigned int ltq_get_pll0_fdiv(void);
69
70 static inline unsigned int get_input_clock(int pll)
71 {
72         switch (pll) {
73         case 0:
74                 if (ltq_cgu_r32(LTQ_CGU_PLL0_CFG) & CGU_PLL0_SRC)
75                         return BASIS_REQUENCY_USB;
76                 else if (CGU_PLL0_PHASE_DIVIDER_ENABLE)
77                         return BASIC_FREQUENCY_1;
78                 else
79                         return BASIC_FREQUENCY_2;
80         case 1:
81                 if (CGU_PLL1_SRC)
82                         return BASIS_REQUENCY_USB;
83                 else if (CGU_PLL0_PHASE_DIVIDER_ENABLE)
84                         return BASIC_FREQUENCY_1;
85                 else
86                         return BASIC_FREQUENCY_2;
87         case 2:
88                 switch (CGU_PLL2_SRC) {
89                 case 0:
90                         return ltq_get_pll0_fdiv();
91                 case 1:
92                         return CGU_PLL2_PHASE_DIVIDER_ENABLE ?
93                                 BASIC_FREQUENCY_1 :
94                                 BASIC_FREQUENCY_2;
95                 case 2:
96                         return BASIS_REQUENCY_USB;
97                 }
98         default:
99                 return 0;
100         }
101 }
102
103 static inline unsigned int cal_dsm(int pll, unsigned int num, unsigned int den)
104 {
105         u64 res, clock = get_input_clock(pll);
106
107         res = num * clock;
108         do_div(res, den);
109         return res;
110 }
111
112 static inline unsigned int mash_dsm(int pll, unsigned int M, unsigned int N,
113         unsigned int K)
114 {
115         unsigned int num = ((N + 1) << 10) + K;
116         unsigned int den = (M + 1) << 10;
117
118         return cal_dsm(pll, num, den);
119 }
120
121 static inline unsigned int ssff_dsm_1(int pll, unsigned int M, unsigned int N,
122         unsigned int K)
123 {
124         unsigned int num = ((N + 1) << 11) + K + 512;
125         unsigned int den = (M + 1) << 11;
126
127         return cal_dsm(pll, num, den);
128 }
129
130 static inline unsigned int ssff_dsm_2(int pll, unsigned int M, unsigned int N,
131         unsigned int K)
132 {
133         unsigned int num = K >= 512 ?
134                 ((N + 1) << 12) + K - 512 : ((N + 1) << 12) + K + 3584;
135         unsigned int den = (M + 1) << 12;
136
137         return cal_dsm(pll, num, den);
138 }
139
140 static inline unsigned int dsm(int pll, unsigned int M, unsigned int N,
141         unsigned int K, unsigned int dsmsel, unsigned int phase_div_en)
142 {
143         if (!dsmsel)
144                 return mash_dsm(pll, M, N, K);
145         else if (!phase_div_en)
146                 return mash_dsm(pll, M, N, K);
147         else
148                 return ssff_dsm_2(pll, M, N, K);
149 }
150
151 static inline unsigned int ltq_get_pll0_fosc(void)
152 {
153         if (CGU_PLL0_BYPASS)
154                 return get_input_clock(0);
155         else
156                 return !CGU_PLL0_CFG_FRAC_EN
157                         ? dsm(0, CGU_PLL0_CFG_PLLM, CGU_PLL0_CFG_PLLN, 0,
158                                 CGU_PLL0_CFG_DSMSEL,
159                                 CGU_PLL0_PHASE_DIVIDER_ENABLE)
160                         : dsm(0, CGU_PLL0_CFG_PLLM, CGU_PLL0_CFG_PLLN,
161                                 CGU_PLL0_CFG_PLLK, CGU_PLL0_CFG_DSMSEL,
162                                 CGU_PLL0_PHASE_DIVIDER_ENABLE);
163 }
164
165 static unsigned int ltq_get_pll0_fdiv(void)
166 {
167         unsigned int div = CGU_PLL2_CFG_INPUT_DIV + 1;
168
169         return (ltq_get_pll0_fosc() + (div >> 1)) / div;
170 }
171
172 unsigned int ltq_get_io_region_clock(void)
173 {
174         unsigned int ret = ltq_get_pll0_fosc();
175
176         switch (ltq_cgu_r32(LTQ_CGU_PLL2_CFG) & CGU_SYS_DDR_SEL) {
177         default:
178         case 0:
179                 return (ret + 1) / 2;
180         case 1:
181                 return (ret * 2 + 2) / 5;
182         case 2:
183                 return (ret + 1) / 3;
184         case 3:
185                 return (ret + 2) / 4;
186         }
187 }
188 EXPORT_SYMBOL(ltq_get_io_region_clock);
189
190 unsigned int ltq_get_fpi_bus_clock(int fpi)
191 {
192         unsigned int ret = ltq_get_io_region_clock();
193
194         if ((fpi == 2) && (ltq_cgu_r32(LTQ_CGU_SYS) & CGU_SYS_FPI_SEL))
195                 ret >>= 1;
196         return ret;
197 }
198 EXPORT_SYMBOL(ltq_get_fpi_bus_clock);
199
200 unsigned int ltq_get_cpu_hz(void)
201 {
202         switch (ltq_cgu_r32(LTQ_CGU_SYS) & 0xc) {
203         case 0:
204                 return CLOCK_333M;
205         case 4:
206                 return DDR_HZ;
207         case 8:
208                 return DDR_HZ << 1;
209         default:
210                 return DDR_HZ >> 1;
211         }
212 }
213 EXPORT_SYMBOL(ltq_get_cpu_hz);
214
215 unsigned int ltq_get_fpi_hz(void)
216 {
217         unsigned int ddr_clock = DDR_HZ;
218
219         if (ltq_cgu_r32(LTQ_CGU_SYS) & 0x40)
220                 return ddr_clock >> 1;
221         return ddr_clock;
222 }
223 EXPORT_SYMBOL(ltq_get_fpi_hz);