[ARM] S3C24XX: Merge devel-gpio
[linux-2.6] / arch / arm / mach-s3c6410 / mach-smdk6410.c
1 /* linux/arch/arm/mach-s3c6410/mach-smdk6410.c
2  *
3  * Copyright 2008 Openmoko, Inc.
4  * Copyright 2008 Simtec Electronics
5  *      Ben Dooks <ben@simtec.co.uk>
6  *      http://armlinux.simtec.co.uk/
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12 */
13
14 #include <linux/kernel.h>
15 #include <linux/types.h>
16 #include <linux/interrupt.h>
17 #include <linux/list.h>
18 #include <linux/timer.h>
19 #include <linux/init.h>
20 #include <linux/serial_core.h>
21 #include <linux/platform_device.h>
22 #include <linux/io.h>
23 #include <linux/i2c.h>
24 #include <linux/fb.h>
25 #include <linux/gpio.h>
26 #include <linux/delay.h>
27 #include <linux/smsc911x.h>
28
29 #ifdef CONFIG_SMDK6410_WM1190_EV1
30 #include <linux/mfd/wm8350/core.h>
31 #include <linux/mfd/wm8350/pmic.h>
32 #endif
33
34 #include <video/platform_lcd.h>
35
36 #include <asm/mach/arch.h>
37 #include <asm/mach/map.h>
38 #include <asm/mach/irq.h>
39
40 #include <mach/hardware.h>
41 #include <mach/regs-fb.h>
42 #include <mach/map.h>
43
44 #include <asm/irq.h>
45 #include <asm/mach-types.h>
46
47 #include <plat/regs-serial.h>
48 #include <plat/regs-modem.h>
49 #include <plat/regs-gpio.h>
50 #include <plat/regs-sys.h>
51 #include <plat/iic.h>
52 #include <plat/fb.h>
53 #include <plat/gpio-cfg.h>
54
55 #include <plat/s3c6410.h>
56 #include <plat/clock.h>
57 #include <plat/devs.h>
58 #include <plat/cpu.h>
59
60 #define UCON S3C2410_UCON_DEFAULT | S3C2410_UCON_UCLK
61 #define ULCON S3C2410_LCON_CS8 | S3C2410_LCON_PNONE | S3C2410_LCON_STOPB
62 #define UFCON S3C2410_UFCON_RXTRIG8 | S3C2410_UFCON_FIFOMODE
63
64 static struct s3c2410_uartcfg smdk6410_uartcfgs[] __initdata = {
65         [0] = {
66                 .hwport      = 0,
67                 .flags       = 0,
68                 .ucon        = 0x3c5,
69                 .ulcon       = 0x03,
70                 .ufcon       = 0x51,
71         },
72         [1] = {
73                 .hwport      = 1,
74                 .flags       = 0,
75                 .ucon        = 0x3c5,
76                 .ulcon       = 0x03,
77                 .ufcon       = 0x51,
78         },
79 };
80
81 /* framebuffer and LCD setup. */
82
83 /* GPF15 = LCD backlight control
84  * GPF13 => Panel power
85  * GPN5 = LCD nRESET signal
86  * PWM_TOUT1 => backlight brightness
87  */
88
89 static void smdk6410_lcd_power_set(struct plat_lcd_data *pd,
90                                    unsigned int power)
91 {
92         if (power) {
93                 gpio_direction_output(S3C64XX_GPF(13), 1);
94                 gpio_direction_output(S3C64XX_GPF(15), 1);
95
96                 /* fire nRESET on power up */
97                 gpio_direction_output(S3C64XX_GPN(5), 0);
98                 msleep(10);
99                 gpio_direction_output(S3C64XX_GPN(5), 1);
100                 msleep(1);
101         } else {
102                 gpio_direction_output(S3C64XX_GPF(15), 0);
103                 gpio_direction_output(S3C64XX_GPF(13), 0);
104         }
105 }
106
107 static struct plat_lcd_data smdk6410_lcd_power_data = {
108         .set_power      = smdk6410_lcd_power_set,
109 };
110
111 static struct platform_device smdk6410_lcd_powerdev = {
112         .name                   = "platform-lcd",
113         .dev.parent             = &s3c_device_fb.dev,
114         .dev.platform_data      = &smdk6410_lcd_power_data,
115 };
116
117 static struct s3c_fb_pd_win smdk6410_fb_win0 = {
118         /* this is to ensure we use win0 */
119         .win_mode       = {
120                 .pixclock       = 41094,
121                 .left_margin    = 8,
122                 .right_margin   = 13,
123                 .upper_margin   = 7,
124                 .lower_margin   = 5,
125                 .hsync_len      = 3,
126                 .vsync_len      = 1,
127                 .xres           = 800,
128                 .yres           = 480,
129         },
130         .max_bpp        = 32,
131         .default_bpp    = 16,
132 };
133
134 /* 405566 clocks per frame => 60Hz refresh requires 24333960Hz clock */
135 static struct s3c_fb_platdata smdk6410_lcd_pdata __initdata = {
136         .setup_gpio     = s3c64xx_fb_gpio_setup_24bpp,
137         .win[0]         = &smdk6410_fb_win0,
138         .vidcon0        = VIDCON0_VIDOUT_RGB | VIDCON0_PNRMODE_RGB,
139         .vidcon1        = VIDCON1_INV_HSYNC | VIDCON1_INV_VSYNC,
140 };
141
142 static struct resource smdk6410_smsc911x_resources[] = {
143         [0] = {
144                 .start = 0x18000000,
145                 .end   = 0x18000000 + SZ_64K - 1,
146                 .flags = IORESOURCE_MEM,
147         },
148         [1] = {
149                 .start = S3C_EINT(10),
150                 .end   = S3C_EINT(10),
151                 .flags = IORESOURCE_IRQ | IRQ_TYPE_LEVEL_LOW,
152         },
153 };
154
155 static struct smsc911x_platform_config smdk6410_smsc911x_pdata = {
156         .irq_polarity  = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
157         .irq_type      = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
158         .flags         = SMSC911X_USE_32BIT | SMSC911X_FORCE_INTERNAL_PHY,
159         .phy_interface = PHY_INTERFACE_MODE_MII,
160 };
161
162
163 static struct platform_device smdk6410_smsc911x = {
164         .name          = "smsc911x",
165         .id            = -1,
166         .num_resources = ARRAY_SIZE(smdk6410_smsc911x_resources),
167         .resource      = &smdk6410_smsc911x_resources[0],
168         .dev = {
169                 .platform_data = &smdk6410_smsc911x_pdata,
170         },
171 };
172
173 static struct map_desc smdk6410_iodesc[] = {};
174
175 static struct platform_device *smdk6410_devices[] __initdata = {
176 #ifdef CONFIG_SMDK6410_SD_CH0
177         &s3c_device_hsmmc0,
178 #endif
179 #ifdef CONFIG_SMDK6410_SD_CH1
180         &s3c_device_hsmmc1,
181 #endif
182         &s3c_device_i2c0,
183         &s3c_device_i2c1,
184         &s3c_device_fb,
185         &s3c_device_usb,
186         &s3c_device_usb_hsotg,
187         &smdk6410_lcd_powerdev,
188
189         &smdk6410_smsc911x,
190 };
191
192 #ifdef CONFIG_SMDK6410_WM1190_EV1
193 /* S3C64xx internal logic & PLL */
194 static struct regulator_init_data wm8350_dcdc1_data = {
195         .constraints = {
196                 .name = "PVDD_INT/PVDD_PLL",
197                 .min_uV = 1200000,
198                 .max_uV = 1200000,
199                 .always_on = 1,
200                 .apply_uV = 1,
201         },
202 };
203
204 /* Memory */
205 static struct regulator_init_data wm8350_dcdc3_data = {
206         .constraints = {
207                 .name = "PVDD_MEM",
208                 .min_uV = 1800000,
209                 .max_uV = 1800000,
210                 .always_on = 1,
211                 .state_mem = {
212                          .uV = 1800000,
213                          .mode = REGULATOR_MODE_NORMAL,
214                          .enabled = 1,
215                  },
216                 .initial_state = PM_SUSPEND_MEM,
217         },
218 };
219
220 /* USB, EXT, PCM, ADC/DAC, USB, MMC */
221 static struct regulator_init_data wm8350_dcdc4_data = {
222         .constraints = {
223                 .name = "PVDD_HI/PVDD_EXT/PVDD_SYS/PVCCM2MTV",
224                 .min_uV = 3000000,
225                 .max_uV = 3000000,
226                 .always_on = 1,
227         },
228 };
229
230 /* ARM core */
231 static struct regulator_consumer_supply dcdc6_consumers[] = {
232         {
233                 .supply = "vddarm",
234         }
235 };
236
237 static struct regulator_init_data wm8350_dcdc6_data = {
238         .constraints = {
239                 .name = "PVDD_ARM",
240                 .min_uV = 1000000,
241                 .max_uV = 1300000,
242                 .always_on = 1,
243                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
244         },
245         .num_consumer_supplies = ARRAY_SIZE(dcdc6_consumers),
246         .consumer_supplies = dcdc6_consumers,
247 };
248
249 /* Alive */
250 static struct regulator_init_data wm8350_ldo1_data = {
251         .constraints = {
252                 .name = "PVDD_ALIVE",
253                 .min_uV = 1200000,
254                 .max_uV = 1200000,
255                 .always_on = 1,
256                 .apply_uV = 1,
257         },
258 };
259
260 /* OTG */
261 static struct regulator_init_data wm8350_ldo2_data = {
262         .constraints = {
263                 .name = "PVDD_OTG",
264                 .min_uV = 3300000,
265                 .max_uV = 3300000,
266                 .always_on = 1,
267         },
268 };
269
270 /* LCD */
271 static struct regulator_init_data wm8350_ldo3_data = {
272         .constraints = {
273                 .name = "PVDD_LCD",
274                 .min_uV = 3000000,
275                 .max_uV = 3000000,
276                 .always_on = 1,
277         },
278 };
279
280 /* OTGi/1190-EV1 HPVDD & AVDD */
281 static struct regulator_init_data wm8350_ldo4_data = {
282         .constraints = {
283                 .name = "PVDD_OTGI/HPVDD/AVDD",
284                 .min_uV = 1200000,
285                 .max_uV = 1200000,
286                 .apply_uV = 1,
287                 .always_on = 1,
288         },
289 };
290
291 static struct {
292         int regulator;
293         struct regulator_init_data *initdata;
294 } wm1190_regulators[] = {
295         { WM8350_DCDC_1, &wm8350_dcdc1_data },
296         { WM8350_DCDC_3, &wm8350_dcdc3_data },
297         { WM8350_DCDC_4, &wm8350_dcdc4_data },
298         { WM8350_DCDC_6, &wm8350_dcdc6_data },
299         { WM8350_LDO_1, &wm8350_ldo1_data },
300         { WM8350_LDO_2, &wm8350_ldo2_data },
301         { WM8350_LDO_3, &wm8350_ldo3_data },
302         { WM8350_LDO_4, &wm8350_ldo4_data },
303 };
304
305 static int __init smdk6410_wm8350_init(struct wm8350 *wm8350)
306 {
307         int i;
308
309         /* Instantiate the regulators */
310         for (i = 0; i < ARRAY_SIZE(wm1190_regulators); i++)
311                 wm8350_register_regulator(wm8350,
312                                           wm1190_regulators[i].regulator,
313                                           wm1190_regulators[i].initdata);
314
315         return 0;
316 }
317
318 static struct wm8350_platform_data __initdata smdk6410_wm8350_pdata = {
319         .init = smdk6410_wm8350_init,
320         .irq_high = 1,
321 };
322 #endif
323
324 static struct i2c_board_info i2c_devs0[] __initdata = {
325         { I2C_BOARD_INFO("24c08", 0x50), },
326         { I2C_BOARD_INFO("wm8580", 0x1b), },
327
328 #ifdef CONFIG_SMDK6410_WM1190_EV1
329         { I2C_BOARD_INFO("wm8350", 0x1a),
330           .platform_data = &smdk6410_wm8350_pdata,
331           .irq = S3C_EINT(12),
332         },
333 #endif
334 };
335
336 static struct i2c_board_info i2c_devs1[] __initdata = {
337         { I2C_BOARD_INFO("24c128", 0x57), },    /* Samsung S524AD0XD1 */
338 };
339
340 static void __init smdk6410_map_io(void)
341 {
342         u32 tmp;
343
344         s3c64xx_init_io(smdk6410_iodesc, ARRAY_SIZE(smdk6410_iodesc));
345         s3c24xx_init_clocks(12000000);
346         s3c24xx_init_uarts(smdk6410_uartcfgs, ARRAY_SIZE(smdk6410_uartcfgs));
347
348         /* set the LCD type */
349
350         tmp = __raw_readl(S3C64XX_SPCON);
351         tmp &= ~S3C64XX_SPCON_LCD_SEL_MASK;
352         tmp |= S3C64XX_SPCON_LCD_SEL_RGB;
353         __raw_writel(tmp, S3C64XX_SPCON);
354
355         /* remove the lcd bypass */
356         tmp = __raw_readl(S3C64XX_MODEM_MIFPCON);
357         tmp &= ~MIFPCON_LCD_BYPASS;
358         __raw_writel(tmp, S3C64XX_MODEM_MIFPCON);
359 }
360
361 static void __init smdk6410_machine_init(void)
362 {
363         s3c_i2c0_set_platdata(NULL);
364         s3c_i2c1_set_platdata(NULL);
365         s3c_fb_set_platdata(&smdk6410_lcd_pdata);
366
367         gpio_request(S3C64XX_GPN(5), "LCD power");
368         gpio_request(S3C64XX_GPF(13), "LCD power");
369         gpio_request(S3C64XX_GPF(15), "LCD power");
370
371         i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));
372         i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));
373
374         platform_add_devices(smdk6410_devices, ARRAY_SIZE(smdk6410_devices));
375 }
376
377 MACHINE_START(SMDK6410, "SMDK6410")
378         /* Maintainer: Ben Dooks <ben@fluff.org> */
379         .phys_io        = S3C_PA_UART & 0xfff00000,
380         .io_pg_offst    = (((u32)S3C_VA_UART) >> 18) & 0xfffc,
381         .boot_params    = S3C64XX_PA_SDRAM + 0x100,
382
383         .init_irq       = s3c6410_init_irq,
384         .map_io         = smdk6410_map_io,
385         .init_machine   = smdk6410_machine_init,
386         .timer          = &s3c24xx_timer,
387 MACHINE_END