Automatic merge of rsync://rsync.kernel.org/pub/scm/linux/kernel/git/davem/sparc...
[linux-2.6] / arch / arm / mach-imx / generic.c
1 /*
2  *  arch/arm/mach-imx/generic.c
3  *
4  *  author: Sascha Hauer
5  *  Created: april 20th, 2004
6  *  Copyright: Synertronixx GmbH
7  *
8  *  Common code for i.MX machines
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 as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
23  *
24  */
25 #include <linux/device.h>
26 #include <linux/init.h>
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <asm/arch/imxfb.h>
30 #include <asm/hardware.h>
31
32 #include <asm/mach/map.h>
33
34 void imx_gpio_mode(int gpio_mode)
35 {
36         unsigned int pin = gpio_mode & GPIO_PIN_MASK;
37         unsigned int port = (gpio_mode & GPIO_PORT_MASK) >> 5;
38         unsigned int ocr = (gpio_mode & GPIO_OCR_MASK) >> 10;
39         unsigned int tmp;
40
41         /* Pullup enable */
42         if(gpio_mode & GPIO_PUEN)
43                 PUEN(port) |= (1<<pin);
44         else
45                 PUEN(port) &= ~(1<<pin);
46
47         /* Data direction */
48         if(gpio_mode & GPIO_OUT)
49                 DDIR(port) |= 1<<pin;
50         else
51                 DDIR(port) &= ~(1<<pin);
52
53         /* Primary / alternate function */
54         if(gpio_mode & GPIO_AF)
55                 GPR(port) |= (1<<pin);
56         else
57                 GPR(port) &= ~(1<<pin);
58
59         /* use as gpio? */
60         if( ocr == 3 )
61                 GIUS(port) |= (1<<pin);
62         else
63                 GIUS(port) &= ~(1<<pin);
64
65         /* Output / input configuration */
66         /* FIXME: I'm not very sure about OCR and ICONF, someone
67          * should have a look over it
68          */
69         if(pin<16) {
70                 tmp = OCR1(port);
71                 tmp &= ~( 3<<(pin*2));
72                 tmp |= (ocr << (pin*2));
73                 OCR1(port) = tmp;
74
75                 if( gpio_mode & GPIO_AOUT )
76                         ICONFA1(port) &= ~( 3<<(pin*2));
77                 if( gpio_mode & GPIO_BOUT )
78                         ICONFB1(port) &= ~( 3<<(pin*2));
79         } else {
80                 tmp = OCR2(port);
81                 tmp &= ~( 3<<((pin-16)*2));
82                 tmp |= (ocr << ((pin-16)*2));
83                 OCR2(port) = tmp;
84
85                 if( gpio_mode & GPIO_AOUT )
86                         ICONFA2(port) &= ~( 3<<((pin-16)*2));
87                 if( gpio_mode & GPIO_BOUT )
88                         ICONFB2(port) &= ~( 3<<((pin-16)*2));
89         }
90 }
91
92 EXPORT_SYMBOL(imx_gpio_mode);
93
94 /*
95  *  get the system pll clock in Hz
96  *
97  *                  mfi + mfn / (mfd +1)
98  *  f = 2 * f_ref * --------------------
99  *                        pd + 1
100  */
101 static unsigned int imx_decode_pll(unsigned int pll)
102 {
103         u32 mfi = (pll >> 10) & 0xf;
104         u32 mfn = pll & 0x3ff;
105         u32 mfd = (pll >> 16) & 0x3ff;
106         u32 pd =  (pll >> 26) & 0xf;
107         u32 f_ref = (CSCR & CSCR_SYSTEM_SEL) ? 16000000 : (CLK32 * 512);
108
109         mfi = mfi <= 5 ? 5 : mfi;
110
111         return (2 * (f_ref>>10) * ( (mfi<<10) + (mfn<<10) / (mfd+1) )) / (pd+1);
112 }
113
114 unsigned int imx_get_system_clk(void)
115 {
116         return imx_decode_pll(SPCTL0);
117 }
118 EXPORT_SYMBOL(imx_get_system_clk);
119
120 unsigned int imx_get_mcu_clk(void)
121 {
122         return imx_decode_pll(MPCTL0);
123 }
124 EXPORT_SYMBOL(imx_get_mcu_clk);
125
126 /*
127  *  get peripheral clock 1 ( UART[12], Timer[12], PWM )
128  */
129 unsigned int imx_get_perclk1(void)
130 {
131         return imx_get_system_clk() / (((PCDR) & 0xf)+1);
132 }
133 EXPORT_SYMBOL(imx_get_perclk1);
134
135 /*
136  *  get peripheral clock 2 ( LCD, SD, SPI[12] )
137  */
138 unsigned int imx_get_perclk2(void)
139 {
140         return imx_get_system_clk() / (((PCDR>>4) & 0xf)+1);
141 }
142 EXPORT_SYMBOL(imx_get_perclk2);
143
144 /*
145  *  get peripheral clock 3 ( SSI )
146  */
147 unsigned int imx_get_perclk3(void)
148 {
149         return imx_get_system_clk() / (((PCDR>>16) & 0x7f)+1);
150 }
151 EXPORT_SYMBOL(imx_get_perclk3);
152
153 /*
154  *  get hclk ( SDRAM, CSI, Memory Stick, I2C, DMA )
155  */
156 unsigned int imx_get_hclk(void)
157 {
158         return imx_get_system_clk() / (((CSCR>>10) & 0xf)+1);
159 }
160 EXPORT_SYMBOL(imx_get_hclk);
161
162 static struct resource imx_mmc_resources[] = {
163         [0] = {
164                 .start  = 0x00214000,
165                 .end    = 0x002140FF,
166                 .flags  = IORESOURCE_MEM,
167         },
168         [1] = {
169                 .start  = (SDHC_INT),
170                 .end    = (SDHC_INT),
171                 .flags  = IORESOURCE_IRQ,
172         },
173 };
174
175 static struct platform_device imx_mmc_device = {
176         .name           = "imx-mmc",
177         .id             = 0,
178         .num_resources  = ARRAY_SIZE(imx_mmc_resources),
179         .resource       = imx_mmc_resources,
180 };
181
182 static struct resource imx_uart1_resources[] = {
183         [0] = {
184                 .start  = 0x00206000,
185                 .end    = 0x002060FF,
186                 .flags  = IORESOURCE_MEM,
187         },
188         [1] = {
189                 .start  = (UART1_MINT_RX),
190                 .end    = (UART1_MINT_RX),
191                 .flags  = IORESOURCE_IRQ,
192         },
193         [2] = {
194                 .start  = (UART1_MINT_TX),
195                 .end    = (UART1_MINT_TX),
196                 .flags  = IORESOURCE_IRQ,
197         },
198 };
199
200 static struct platform_device imx_uart1_device = {
201         .name           = "imx-uart",
202         .id             = 0,
203         .num_resources  = ARRAY_SIZE(imx_uart1_resources),
204         .resource       = imx_uart1_resources,
205 };
206
207 static struct resource imx_uart2_resources[] = {
208         [0] = {
209                 .start  = 0x00207000,
210                 .end    = 0x002070FF,
211                 .flags  = IORESOURCE_MEM,
212         },
213         [1] = {
214                 .start  = (UART2_MINT_RX),
215                 .end    = (UART2_MINT_RX),
216                 .flags  = IORESOURCE_IRQ,
217         },
218         [2] = {
219                 .start  = (UART2_MINT_TX),
220                 .end    = (UART2_MINT_TX),
221                 .flags  = IORESOURCE_IRQ,
222         },
223 };
224
225 static struct platform_device imx_uart2_device = {
226         .name           = "imx-uart",
227         .id             = 1,
228         .num_resources  = ARRAY_SIZE(imx_uart2_resources),
229         .resource       = imx_uart2_resources,
230 };
231
232 static struct imxfb_mach_info imx_fb_info;
233
234 void __init set_imx_fb_info(struct imxfb_mach_info *hard_imx_fb_info)
235 {
236         memcpy(&imx_fb_info,hard_imx_fb_info,sizeof(struct imxfb_mach_info));
237 }
238 EXPORT_SYMBOL(set_imx_fb_info);
239
240 static struct resource imxfb_resources[] = {
241         [0] = {
242                 .start  = 0x00205000,
243                 .end    = 0x002050FF,
244                 .flags  = IORESOURCE_MEM,
245         },
246         [1] = {
247                 .start  = LCDC_INT,
248                 .end    = LCDC_INT,
249                 .flags  = IORESOURCE_IRQ,
250         },
251 };
252
253 static u64 fb_dma_mask = ~(u64)0;
254
255 static struct platform_device imxfb_device = {
256         .name           = "imx-fb",
257         .id             = 0,
258         .dev            = {
259                 .platform_data  = &imx_fb_info,
260                 .dma_mask       = &fb_dma_mask,
261                 .coherent_dma_mask = 0xffffffff,
262         },
263         .num_resources  = ARRAY_SIZE(imxfb_resources),
264         .resource       = imxfb_resources,
265 };
266
267 static struct platform_device *devices[] __initdata = {
268         &imx_mmc_device,
269         &imxfb_device,
270         &imx_uart1_device,
271         &imx_uart2_device,
272 };
273
274 static struct map_desc imx_io_desc[] __initdata = {
275         /* virtual     physical    length      type */
276         {IMX_IO_BASE, IMX_IO_PHYS, IMX_IO_SIZE, MT_DEVICE},
277 };
278
279 void __init
280 imx_map_io(void)
281 {
282         iotable_init(imx_io_desc, ARRAY_SIZE(imx_io_desc));
283 }
284
285 static int __init imx_init(void)
286 {
287         return platform_add_devices(devices, ARRAY_SIZE(devices));
288 }
289
290 subsys_initcall(imx_init);