Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / arch / arm / mach-pxa / pxa25x.c
1 /*
2  *  linux/arch/arm/mach-pxa/pxa25x.c
3  *
4  *  Author:     Nicolas Pitre
5  *  Created:    Jun 15, 2001
6  *  Copyright:  MontaVista Software Inc.
7  *
8  * Code specific to PXA21x/25x/26x variants.
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License version 2 as
12  * published by the Free Software Foundation.
13  *
14  * Since this file should be linked before any other machine specific file,
15  * the __initcall() here will be executed first.  This serves as default
16  * initialization stuff for PXA machines which can be overridden later if
17  * need be.
18  */
19 #include <linux/module.h>
20 #include <linux/kernel.h>
21 #include <linux/init.h>
22 #include <linux/platform_device.h>
23 #include <linux/pm.h>
24
25 #include <asm/hardware.h>
26 #include <asm/arch/irqs.h>
27 #include <asm/arch/pxa-regs.h>
28 #include <asm/arch/pm.h>
29 #include <asm/arch/dma.h>
30
31 #include "generic.h"
32 #include "devices.h"
33
34 /*
35  * Various clock factors driven by the CCCR register.
36  */
37
38 /* Crystal Frequency to Memory Frequency Multiplier (L) */
39 static unsigned char L_clk_mult[32] = { 0, 27, 32, 36, 40, 45, 0, };
40
41 /* Memory Frequency to Run Mode Frequency Multiplier (M) */
42 static unsigned char M_clk_mult[4] = { 0, 1, 2, 4 };
43
44 /* Run Mode Frequency to Turbo Mode Frequency Multiplier (N) */
45 /* Note: we store the value N * 2 here. */
46 static unsigned char N2_clk_mult[8] = { 0, 0, 2, 3, 4, 0, 6, 0 };
47
48 /* Crystal clock */
49 #define BASE_CLK        3686400
50
51 /*
52  * Get the clock frequency as reflected by CCCR and the turbo flag.
53  * We assume these values have been applied via a fcs.
54  * If info is not 0 we also display the current settings.
55  */
56 unsigned int get_clk_frequency_khz(int info)
57 {
58         unsigned long cccr, turbo;
59         unsigned int l, L, m, M, n2, N;
60
61         cccr = CCCR;
62         asm( "mrc\tp14, 0, %0, c6, c0, 0" : "=r" (turbo) );
63
64         l  =  L_clk_mult[(cccr >> 0) & 0x1f];
65         m  =  M_clk_mult[(cccr >> 5) & 0x03];
66         n2 = N2_clk_mult[(cccr >> 7) & 0x07];
67
68         L = l * BASE_CLK;
69         M = m * L;
70         N = n2 * M / 2;
71
72         if(info)
73         {
74                 L += 5000;
75                 printk( KERN_INFO "Memory clock: %d.%02dMHz (*%d)\n",
76                         L / 1000000, (L % 1000000) / 10000, l );
77                 M += 5000;
78                 printk( KERN_INFO "Run Mode clock: %d.%02dMHz (*%d)\n",
79                         M / 1000000, (M % 1000000) / 10000, m );
80                 N += 5000;
81                 printk( KERN_INFO "Turbo Mode clock: %d.%02dMHz (*%d.%d, %sactive)\n",
82                         N / 1000000, (N % 1000000) / 10000, n2 / 2, (n2 % 2) * 5,
83                         (turbo & 1) ? "" : "in" );
84         }
85
86         return (turbo & 1) ? (N/1000) : (M/1000);
87 }
88
89 EXPORT_SYMBOL(get_clk_frequency_khz);
90
91 /*
92  * Return the current memory clock frequency in units of 10kHz
93  */
94 unsigned int get_memclk_frequency_10khz(void)
95 {
96         return L_clk_mult[(CCCR >> 0) & 0x1f] * BASE_CLK / 10000;
97 }
98
99 EXPORT_SYMBOL(get_memclk_frequency_10khz);
100
101 /*
102  * Return the current LCD clock frequency in units of 10kHz
103  */
104 unsigned int get_lcdclk_frequency_10khz(void)
105 {
106         return get_memclk_frequency_10khz();
107 }
108
109 EXPORT_SYMBOL(get_lcdclk_frequency_10khz);
110
111 #ifdef CONFIG_PM
112
113 #define SAVE(x)         sleep_save[SLEEP_SAVE_##x] = x
114 #define RESTORE(x)      x = sleep_save[SLEEP_SAVE_##x]
115
116 #define RESTORE_GPLEVEL(n) do { \
117         GPSR##n = sleep_save[SLEEP_SAVE_GPLR##n]; \
118         GPCR##n = ~sleep_save[SLEEP_SAVE_GPLR##n]; \
119 } while (0)
120
121 /*
122  * List of global PXA peripheral registers to preserve.
123  * More ones like CP and general purpose register values are preserved
124  * with the stack pointer in sleep.S.
125  */
126 enum {  SLEEP_SAVE_START = 0,
127
128         SLEEP_SAVE_GPLR0, SLEEP_SAVE_GPLR1, SLEEP_SAVE_GPLR2,
129         SLEEP_SAVE_GPDR0, SLEEP_SAVE_GPDR1, SLEEP_SAVE_GPDR2,
130         SLEEP_SAVE_GRER0, SLEEP_SAVE_GRER1, SLEEP_SAVE_GRER2,
131         SLEEP_SAVE_GFER0, SLEEP_SAVE_GFER1, SLEEP_SAVE_GFER2,
132         SLEEP_SAVE_PGSR0, SLEEP_SAVE_PGSR1, SLEEP_SAVE_PGSR2,
133
134         SLEEP_SAVE_GAFR0_L, SLEEP_SAVE_GAFR0_U,
135         SLEEP_SAVE_GAFR1_L, SLEEP_SAVE_GAFR1_U,
136         SLEEP_SAVE_GAFR2_L, SLEEP_SAVE_GAFR2_U,
137
138         SLEEP_SAVE_PSTR,
139
140         SLEEP_SAVE_ICMR,
141         SLEEP_SAVE_CKEN,
142
143         SLEEP_SAVE_SIZE
144 };
145
146
147 static void pxa25x_cpu_pm_save(unsigned long *sleep_save)
148 {
149         SAVE(GPLR0); SAVE(GPLR1); SAVE(GPLR2);
150         SAVE(GPDR0); SAVE(GPDR1); SAVE(GPDR2);
151         SAVE(GRER0); SAVE(GRER1); SAVE(GRER2);
152         SAVE(GFER0); SAVE(GFER1); SAVE(GFER2);
153         SAVE(PGSR0); SAVE(PGSR1); SAVE(PGSR2);
154
155         SAVE(GAFR0_L); SAVE(GAFR0_U);
156         SAVE(GAFR1_L); SAVE(GAFR1_U);
157         SAVE(GAFR2_L); SAVE(GAFR2_U);
158
159         SAVE(ICMR);
160         SAVE(CKEN);
161         SAVE(PSTR);
162 }
163
164 static void pxa25x_cpu_pm_restore(unsigned long *sleep_save)
165 {
166         /* restore registers */
167         RESTORE_GPLEVEL(0); RESTORE_GPLEVEL(1); RESTORE_GPLEVEL(2);
168         RESTORE(GPDR0); RESTORE(GPDR1); RESTORE(GPDR2);
169         RESTORE(GAFR0_L); RESTORE(GAFR0_U);
170         RESTORE(GAFR1_L); RESTORE(GAFR1_U);
171         RESTORE(GAFR2_L); RESTORE(GAFR2_U);
172         RESTORE(GRER0); RESTORE(GRER1); RESTORE(GRER2);
173         RESTORE(GFER0); RESTORE(GFER1); RESTORE(GFER2);
174         RESTORE(PGSR0); RESTORE(PGSR1); RESTORE(PGSR2);
175
176         RESTORE(CKEN);
177         RESTORE(ICMR);
178         RESTORE(PSTR);
179 }
180
181 static void pxa25x_cpu_pm_enter(suspend_state_t state)
182 {
183         CKEN = 0;
184
185         switch (state) {
186         case PM_SUSPEND_MEM:
187                 /* set resume return address */
188                 PSPR = virt_to_phys(pxa_cpu_resume);
189                 pxa25x_cpu_suspend(PWRMODE_SLEEP);
190                 break;
191         }
192 }
193
194 static struct pxa_cpu_pm_fns pxa25x_cpu_pm_fns = {
195         .save_size      = SLEEP_SAVE_SIZE,
196         .valid          = pm_valid_only_mem,
197         .save           = pxa25x_cpu_pm_save,
198         .restore        = pxa25x_cpu_pm_restore,
199         .enter          = pxa25x_cpu_pm_enter,
200 };
201
202 static void __init pxa25x_init_pm(void)
203 {
204         pxa_cpu_pm_fns = &pxa25x_cpu_pm_fns;
205 }
206 #endif
207
208 void __init pxa25x_init_irq(void)
209 {
210         pxa_init_irq_low();
211         pxa_init_irq_gpio(85);
212 }
213
214 static struct platform_device *pxa25x_devices[] __initdata = {
215         &pxa_device_mci,
216         &pxa_device_udc,
217         &pxa_device_fb,
218         &pxa_device_ffuart,
219         &pxa_device_btuart,
220         &pxa_device_stuart,
221         &pxa_device_i2c,
222         &pxa_device_i2s,
223         &pxa_device_ficp,
224         &pxa_device_rtc,
225 };
226
227 static int __init pxa25x_init(void)
228 {
229         int ret = 0;
230
231         if (cpu_is_pxa21x() || cpu_is_pxa25x()) {
232                 if ((ret = pxa_init_dma(16)))
233                         return ret;
234 #ifdef CONFIG_PM
235                 pxa25x_init_pm();
236 #endif
237                 ret = platform_add_devices(pxa25x_devices,
238                                            ARRAY_SIZE(pxa25x_devices));
239         }
240         /* Only add HWUART for PXA255/26x; PXA210/250/27x do not have it. */
241         if (cpu_is_pxa25x())
242                 ret = platform_device_register(&pxa_device_hwuart);
243
244         return ret;
245 }
246
247 subsys_initcall(pxa25x_init);