c36db279b43daa7f2ccb77c02e602e6cf57d57de
[linux-3.10.git] / arch / ppc / syslib / ibm440gx_common.c
1 /*
2  * arch/ppc/kernel/ibm440gx_common.c
3  *
4  * PPC440GX system library
5  *
6  * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
7  * Copyright (c) 2003, 2004 Zultys Technologies
8  *
9  * This program is free software; you can redistribute  it and/or modify it
10  * under  the terms of  the GNU General  Public License as published by the
11  * Free Software Foundation;  either version 2 of the  License, or (at your
12  * option) any later version.
13  *
14  */
15 #include <linux/config.h>
16 #include <linux/kernel.h>
17 #include <linux/interrupt.h>
18 #include <asm/ibm44x.h>
19 #include <asm/mmu.h>
20 #include <asm/processor.h>
21 #include <syslib/ibm440gx_common.h>
22
23 /*
24  * Calculate 440GX clocks
25  */
26 static inline u32 __fix_zero(u32 v, u32 def){
27         return v ? v : def;
28 }
29
30 void __init ibm440gx_get_clocks(struct ibm44x_clocks* p, unsigned int sys_clk,
31         unsigned int ser_clk)
32 {
33         u32 pllc  = CPR_READ(DCRN_CPR_PLLC);
34         u32 plld  = CPR_READ(DCRN_CPR_PLLD);
35         u32 uart0 = SDR_READ(DCRN_SDR_UART0);
36         u32 uart1 = SDR_READ(DCRN_SDR_UART1);
37 #ifdef CONFIG_440EP
38         u32 uart2 = SDR_READ(DCRN_SDR_UART2);
39         u32 uart3 = SDR_READ(DCRN_SDR_UART3);
40 #endif
41
42         /* Dividers */
43         u32 fbdv   = __fix_zero((plld >> 24) & 0x1f, 32);
44         u32 fwdva  = __fix_zero((plld >> 16) & 0xf, 16);
45         u32 fwdvb  = __fix_zero((plld >> 8) & 7, 8);
46         u32 lfbdv  = __fix_zero(plld & 0x3f, 64);
47         u32 pradv0 = __fix_zero((CPR_READ(DCRN_CPR_PRIMAD) >> 24) & 7, 8);
48         u32 prbdv0 = __fix_zero((CPR_READ(DCRN_CPR_PRIMBD) >> 24) & 7, 8);
49         u32 opbdv0 = __fix_zero((CPR_READ(DCRN_CPR_OPBD) >> 24) & 3, 4);
50         u32 perdv0 = __fix_zero((CPR_READ(DCRN_CPR_PERD) >> 24) & 3, 4);
51
52         /* Input clocks for primary dividers */
53         u32 clk_a, clk_b;
54
55         if (pllc & 0x40000000){
56                 u32 m;
57
58                 /* Feedback path */
59                 switch ((pllc >> 24) & 7){
60                 case 0:
61                         /* PLLOUTx */
62                         m = ((pllc & 0x20000000) ? fwdvb : fwdva) * lfbdv;
63                         break;
64                 case 1:
65                         /* CPU */
66                         m = fwdva * pradv0;
67                         break;
68                 case 5:
69                         /* PERClk */
70                         m = fwdvb * prbdv0 * opbdv0 * perdv0;
71                         break;
72                 default:
73                         printk(KERN_EMERG "invalid PLL feedback source\n");
74                         goto bypass;
75                 }
76                 m *= fbdv;
77                 p->vco = sys_clk * m;
78                 clk_a = p->vco / fwdva;
79                 clk_b = p->vco / fwdvb;
80         }
81         else {
82 bypass:
83                 /* Bypass system PLL */
84                 p->vco = 0;
85                 clk_a = clk_b = sys_clk;
86         }
87
88         p->cpu = clk_a / pradv0;
89         p->plb = clk_b / prbdv0;
90         p->opb = p->plb / opbdv0;
91         p->ebc = p->opb / perdv0;
92
93         /* UARTs clock */
94         if (uart0 & 0x00800000)
95                 p->uart0 = ser_clk;
96         else
97                 p->uart0 = p->plb / __fix_zero(uart0 & 0xff, 256);
98
99         if (uart1 & 0x00800000)
100                 p->uart1 = ser_clk;
101         else
102                 p->uart1 = p->plb / __fix_zero(uart1 & 0xff, 256);
103 #ifdef CONFIG_440EP
104         if (uart2 & 0x00800000)
105                 p->uart2 = ser_clk;
106         else
107                 p->uart2 = p->plb / __fix_zero(uart2 & 0xff, 256);
108
109         if (uart3 & 0x00800000)
110                 p->uart3 = ser_clk;
111         else
112                 p->uart3 = p->plb / __fix_zero(uart3 & 0xff, 256);
113 #endif
114 }
115
116 /* Issue L2C diagnostic command */
117 static inline u32 l2c_diag(u32 addr)
118 {
119         mtdcr(DCRN_L2C0_ADDR, addr);
120         mtdcr(DCRN_L2C0_CMD, L2C_CMD_DIAG);
121         while (!(mfdcr(DCRN_L2C0_SR) & L2C_SR_CC)) ;
122         return mfdcr(DCRN_L2C0_DATA);
123 }
124
125 static irqreturn_t l2c_error_handler(int irq, void* dev, struct pt_regs* regs)
126 {
127         u32 sr = mfdcr(DCRN_L2C0_SR);
128         if (sr & L2C_SR_CPE){
129                 /* Read cache trapped address */
130                 u32 addr = l2c_diag(0x42000000);
131                 printk(KERN_EMERG "L2C: Cache Parity Error, addr[16:26] = 0x%08x\n", addr);
132         }
133         if (sr & L2C_SR_TPE){
134                 /* Read tag trapped address */
135                 u32 addr = l2c_diag(0x82000000) >> 16;
136                 printk(KERN_EMERG "L2C: Tag Parity Error, addr[16:26] = 0x%08x\n", addr);
137         }
138
139         /* Clear parity errors */
140         if (sr & (L2C_SR_CPE | L2C_SR_TPE)){
141                 mtdcr(DCRN_L2C0_ADDR, 0);
142                 mtdcr(DCRN_L2C0_CMD, L2C_CMD_CCP | L2C_CMD_CTE);
143         } else
144                 printk(KERN_EMERG "L2C: LRU error\n");
145
146         return IRQ_HANDLED;
147 }
148
149 /* Enable L2 cache */
150 void __init ibm440gx_l2c_enable(void){
151         u32 r;
152         unsigned long flags;
153
154         /* Install error handler */
155         if (request_irq(87, l2c_error_handler, SA_INTERRUPT, "L2C", 0) < 0){
156                 printk(KERN_ERR "Cannot install L2C error handler, cache is not enabled\n");
157                 return;
158         }
159
160         local_irq_save(flags);
161         asm volatile ("sync" ::: "memory");
162
163         /* Disable SRAM */
164         mtdcr(DCRN_SRAM0_DPC,   mfdcr(DCRN_SRAM0_DPC)   & ~SRAM_DPC_ENABLE);
165         mtdcr(DCRN_SRAM0_SB0CR, mfdcr(DCRN_SRAM0_SB0CR) & ~SRAM_SBCR_BU_MASK);
166         mtdcr(DCRN_SRAM0_SB1CR, mfdcr(DCRN_SRAM0_SB1CR) & ~SRAM_SBCR_BU_MASK);
167         mtdcr(DCRN_SRAM0_SB2CR, mfdcr(DCRN_SRAM0_SB2CR) & ~SRAM_SBCR_BU_MASK);
168         mtdcr(DCRN_SRAM0_SB3CR, mfdcr(DCRN_SRAM0_SB3CR) & ~SRAM_SBCR_BU_MASK);
169
170         /* Enable L2_MODE without ICU/DCU */
171         r = mfdcr(DCRN_L2C0_CFG) & ~(L2C_CFG_ICU | L2C_CFG_DCU | L2C_CFG_SS_MASK);
172         r |= L2C_CFG_L2M | L2C_CFG_SS_256;
173         mtdcr(DCRN_L2C0_CFG, r);
174
175         mtdcr(DCRN_L2C0_ADDR, 0);
176
177         /* Hardware Clear Command */
178         mtdcr(DCRN_L2C0_CMD, L2C_CMD_HCC);
179         while (!(mfdcr(DCRN_L2C0_SR) & L2C_SR_CC)) ;
180
181         /* Clear Cache Parity and Tag Errors */
182         mtdcr(DCRN_L2C0_CMD, L2C_CMD_CCP | L2C_CMD_CTE);
183
184         /* Enable 64G snoop region starting at 0 */
185         r = mfdcr(DCRN_L2C0_SNP0) & ~(L2C_SNP_BA_MASK | L2C_SNP_SSR_MASK);
186         r |= L2C_SNP_SSR_32G | L2C_SNP_ESR;
187         mtdcr(DCRN_L2C0_SNP0, r);
188
189         r = mfdcr(DCRN_L2C0_SNP1) & ~(L2C_SNP_BA_MASK | L2C_SNP_SSR_MASK);
190         r |= 0x80000000 | L2C_SNP_SSR_32G | L2C_SNP_ESR;
191         mtdcr(DCRN_L2C0_SNP1, r);
192
193         asm volatile ("sync" ::: "memory");
194
195         /* Enable ICU/DCU ports */
196         r = mfdcr(DCRN_L2C0_CFG);
197         r &= ~(L2C_CFG_DCW_MASK | L2C_CFG_PMUX_MASK | L2C_CFG_PMIM | L2C_CFG_TPEI
198                 | L2C_CFG_CPEI | L2C_CFG_NAM | L2C_CFG_NBRM);
199         r |= L2C_CFG_ICU | L2C_CFG_DCU | L2C_CFG_TPC | L2C_CFG_CPC | L2C_CFG_FRAN
200                 | L2C_CFG_CPIM | L2C_CFG_TPIM | L2C_CFG_LIM | L2C_CFG_SMCM;
201         mtdcr(DCRN_L2C0_CFG, r);
202
203         asm volatile ("sync; isync" ::: "memory");
204         local_irq_restore(flags);
205 }
206
207 /* Disable L2 cache */
208 void __init ibm440gx_l2c_disable(void){
209         u32 r;
210         unsigned long flags;
211
212         local_irq_save(flags);
213         asm volatile ("sync" ::: "memory");
214
215         /* Disable L2C mode */
216         r = mfdcr(DCRN_L2C0_CFG) & ~(L2C_CFG_L2M | L2C_CFG_ICU | L2C_CFG_DCU);
217         mtdcr(DCRN_L2C0_CFG, r);
218
219         /* Enable SRAM */
220         mtdcr(DCRN_SRAM0_DPC, mfdcr(DCRN_SRAM0_DPC) | SRAM_DPC_ENABLE);
221         mtdcr(DCRN_SRAM0_SB0CR,
222               SRAM_SBCR_BAS0 | SRAM_SBCR_BS_64KB | SRAM_SBCR_BU_RW);
223         mtdcr(DCRN_SRAM0_SB1CR,
224               SRAM_SBCR_BAS1 | SRAM_SBCR_BS_64KB | SRAM_SBCR_BU_RW);
225         mtdcr(DCRN_SRAM0_SB2CR,
226               SRAM_SBCR_BAS2 | SRAM_SBCR_BS_64KB | SRAM_SBCR_BU_RW);
227         mtdcr(DCRN_SRAM0_SB3CR,
228               SRAM_SBCR_BAS3 | SRAM_SBCR_BS_64KB | SRAM_SBCR_BU_RW);
229
230         asm volatile ("sync; isync" ::: "memory");
231         local_irq_restore(flags);
232 }
233
234 void __init ibm440gx_l2c_setup(struct ibm44x_clocks* p)
235 {
236         /* Disable L2C on rev.A, rev.B and 800MHz version of rev.C,
237            enable it on all other revisions
238          */
239         if (strcmp(cur_cpu_spec->cpu_name, "440GX Rev. A") == 0 ||
240                         strcmp(cur_cpu_spec->cpu_name, "440GX Rev. B") == 0
241                         || (strcmp(cur_cpu_spec->cpu_name, "440GX Rev. C")
242                                 == 0 && p->cpu > 667000000))
243                 ibm440gx_l2c_disable();
244         else
245                 ibm440gx_l2c_enable();
246 }
247
248 int __init ibm440gx_get_eth_grp(void)
249 {
250         return (SDR_READ(DCRN_SDR_PFC1) & DCRN_SDR_PFC1_EPS) >> DCRN_SDR_PFC1_EPS_SHIFT;
251 }
252
253 void __init ibm440gx_set_eth_grp(int group)
254 {
255         SDR_WRITE(DCRN_SDR_PFC1, (SDR_READ(DCRN_SDR_PFC1) & ~DCRN_SDR_PFC1_EPS) | (group << DCRN_SDR_PFC1_EPS_SHIFT));
256 }
257
258 void __init ibm440gx_tah_enable(void)
259 {
260         /* Enable TAH0 and TAH1 */
261         SDR_WRITE(DCRN_SDR_MFR,SDR_READ(DCRN_SDR_MFR) &
262                         ~DCRN_SDR_MFR_TAH0);
263         SDR_WRITE(DCRN_SDR_MFR,SDR_READ(DCRN_SDR_MFR) &
264                         ~DCRN_SDR_MFR_TAH1);
265 }
266
267 int ibm440gx_show_cpuinfo(struct seq_file *m){
268
269         u32 l2c_cfg = mfdcr(DCRN_L2C0_CFG);
270         const char* s;
271         if (l2c_cfg & L2C_CFG_L2M){
272             switch (l2c_cfg & (L2C_CFG_ICU | L2C_CFG_DCU)){
273                 case L2C_CFG_ICU: s = "I-Cache only";    break;
274                 case L2C_CFG_DCU: s = "D-Cache only";    break;
275                 default:          s = "I-Cache/D-Cache"; break;
276             }
277         }
278         else
279             s = "disabled";
280
281         seq_printf(m, "L2-Cache\t: %s (0x%08x 0x%08x)\n", s,
282             l2c_cfg, mfdcr(DCRN_L2C0_SR));
283
284         return 0;
285 }
286