968601201fb5b33ff58c96d97fabbb1044195379
[linux-2.6.git] / arch / arm / mach-shmobile / board-ap4evb.c
1 /*
2  * AP4EVB board support
3  *
4  * Copyright (C) 2010  Magnus Damm
5  * Copyright (C) 2008  Yoshihiro Shimoda
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; version 2 of the License.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  */
20 #include <linux/clk.h>
21 #include <linux/kernel.h>
22 #include <linux/init.h>
23 #include <linux/interrupt.h>
24 #include <linux/irq.h>
25 #include <linux/platform_device.h>
26 #include <linux/delay.h>
27 #include <linux/mfd/sh_mobile_sdhi.h>
28 #include <linux/mmc/host.h>
29 #include <linux/mtd/mtd.h>
30 #include <linux/mtd/partitions.h>
31 #include <linux/mtd/physmap.h>
32 #include <linux/mmc/host.h>
33 #include <linux/mmc/sh_mmcif.h>
34 #include <linux/i2c.h>
35 #include <linux/i2c/tsc2007.h>
36 #include <linux/io.h>
37 #include <linux/smsc911x.h>
38 #include <linux/sh_intc.h>
39 #include <linux/sh_clk.h>
40 #include <linux/gpio.h>
41 #include <linux/input.h>
42 #include <linux/input/sh_keysc.h>
43 #include <linux/usb/r8a66597.h>
44
45 #include <sound/sh_fsi.h>
46
47 #include <video/sh_mobile_lcdc.h>
48 #include <video/sh_mipi_dsi.h>
49
50 #include <mach/common.h>
51 #include <mach/irqs.h>
52 #include <mach/sh7372.h>
53
54 #include <asm/mach-types.h>
55 #include <asm/mach/arch.h>
56 #include <asm/mach/map.h>
57 #include <asm/mach/time.h>
58
59 /*
60  * Address      Interface               BusWidth        note
61  * ------------------------------------------------------------------
62  * 0x0000_0000  NOR Flash ROM (MCP)     16bit           SW7 : bit1 = ON
63  * 0x0800_0000  user area               -
64  * 0x1000_0000  NOR Flash ROM (MCP)     16bit           SW7 : bit1 = OFF
65  * 0x1400_0000  Ether (LAN9220)         16bit
66  * 0x1600_0000  user area               -               cannot use with NAND
67  * 0x1800_0000  user area               -
68  * 0x1A00_0000  -
69  * 0x4000_0000  LPDDR2-SDRAM (POP)      32bit
70  */
71
72 /*
73  * NOR Flash ROM
74  *
75  *  SW1  |     SW2    | SW7  | NOR Flash ROM
76  *  bit1 | bit1  bit2 | bit1 | Memory allocation
77  * ------+------------+------+------------------
78  *  OFF  | ON     OFF | ON   |    Area 0
79  *  OFF  | ON     OFF | OFF  |    Area 4
80  */
81
82 /*
83  * NAND Flash ROM
84  *
85  *  SW1  |     SW2    | SW7  | NAND Flash ROM
86  *  bit1 | bit1  bit2 | bit2 | Memory allocation
87  * ------+------------+------+------------------
88  *  OFF  | ON     OFF | ON   |    FCE 0
89  *  OFF  | ON     OFF | OFF  |    FCE 1
90  */
91
92 /*
93  * SMSC 9220
94  *
95  *  SW1         SMSC 9220
96  * -----------------------
97  *  ON          access disable
98  *  OFF         access enable
99  */
100
101 /*
102  * LCD / IRQ / KEYSC / IrDA
103  *
104  * IRQ = IRQ26 (TS), IRQ27 (VIO), IRQ28 (QHD-TouchScreen)
105  * LCD = 2nd LCDC (WVGA)
106  *
107  *              |               SW43                    |
108  * SW3          |       ON              |       OFF     |
109  * -------------+-----------------------+---------------+
110  * ON           | KEY / IrDA            | LCD           |
111  * OFF          | KEY / IrDA / IRQ      | IRQ           |
112  *
113  *
114  * QHD / WVGA display
115  *
116  * You can choice display type on menuconfig.
117  * Then, check above dip-switch.
118  */
119
120 /*
121  * USB
122  *
123  * J7 : 1-2  MAX3355E VBUS
124  *      2-3  DC 5.0V
125  *
126  * S39: bit2: off
127  */
128
129 /*
130  * FSI/FSMI
131  *
132  * SW41 :  ON : SH-Mobile AP4 Audio Mode
133  *      : OFF : Bluetooth Audio Mode
134  */
135
136 /*
137  * MMC0/SDHI1 (CN7)
138  *
139  * J22 : select card voltage
140  *       1-2 pin : 1.8v
141  *       2-3 pin : 3.3v
142  *
143  *        SW1  |             SW33
144  *             | bit1 | bit2 | bit3 | bit4
145  * ------------+------+------+------+-------
146  * MMC0   OFF  |  OFF |  ON  |  ON  |  X
147  * SDHI1  OFF  |  ON  |   X  |  OFF | ON
148  *
149  * voltage lebel
150  * CN7 : 1.8v
151  * CN12: 3.3v
152  */
153
154 /* MTD */
155 static struct mtd_partition nor_flash_partitions[] = {
156         {
157                 .name           = "loader",
158                 .offset         = 0x00000000,
159                 .size           = 512 * 1024,
160         },
161         {
162                 .name           = "bootenv",
163                 .offset         = MTDPART_OFS_APPEND,
164                 .size           = 512 * 1024,
165         },
166         {
167                 .name           = "kernel_ro",
168                 .offset         = MTDPART_OFS_APPEND,
169                 .size           = 8 * 1024 * 1024,
170                 .mask_flags     = MTD_WRITEABLE,
171         },
172         {
173                 .name           = "kernel",
174                 .offset         = MTDPART_OFS_APPEND,
175                 .size           = 8 * 1024 * 1024,
176         },
177         {
178                 .name           = "data",
179                 .offset         = MTDPART_OFS_APPEND,
180                 .size           = MTDPART_SIZ_FULL,
181         },
182 };
183
184 static struct physmap_flash_data nor_flash_data = {
185         .width          = 2,
186         .parts          = nor_flash_partitions,
187         .nr_parts       = ARRAY_SIZE(nor_flash_partitions),
188 };
189
190 static struct resource nor_flash_resources[] = {
191         [0]     = {
192                 .start  = 0x00000000,
193                 .end    = 0x08000000 - 1,
194                 .flags  = IORESOURCE_MEM,
195         }
196 };
197
198 static struct platform_device nor_flash_device = {
199         .name           = "physmap-flash",
200         .dev            = {
201                 .platform_data  = &nor_flash_data,
202         },
203         .num_resources  = ARRAY_SIZE(nor_flash_resources),
204         .resource       = nor_flash_resources,
205 };
206
207 /* SMSC 9220 */
208 static struct resource smc911x_resources[] = {
209         {
210                 .start  = 0x14000000,
211                 .end    = 0x16000000 - 1,
212                 .flags  = IORESOURCE_MEM,
213         }, {
214                 .start  = evt2irq(0x02c0) /* IRQ6A */,
215                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
216         },
217 };
218
219 static struct smsc911x_platform_config smsc911x_info = {
220         .flags          = SMSC911X_USE_16BIT | SMSC911X_SAVE_MAC_ADDRESS,
221         .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
222         .irq_type       = SMSC911X_IRQ_TYPE_PUSH_PULL,
223 };
224
225 static struct platform_device smc911x_device = {
226         .name           = "smsc911x",
227         .id             = -1,
228         .num_resources  = ARRAY_SIZE(smc911x_resources),
229         .resource       = smc911x_resources,
230         .dev            = {
231                 .platform_data = &smsc911x_info,
232         },
233 };
234
235 /* SH_MMCIF */
236 static struct resource sh_mmcif_resources[] = {
237         [0] = {
238                 .name   = "SH_MMCIF",
239                 .start  = 0xE6BD0000,
240                 .end    = 0xE6BD00FF,
241                 .flags  = IORESOURCE_MEM,
242         },
243         [1] = {
244                 /* MMC ERR */
245                 .start  = evt2irq(0x1ac0),
246                 .flags  = IORESOURCE_IRQ,
247         },
248         [2] = {
249                 /* MMC NOR */
250                 .start  = evt2irq(0x1ae0),
251                 .flags  = IORESOURCE_IRQ,
252         },
253 };
254
255 static struct sh_mmcif_plat_data sh_mmcif_plat = {
256         .sup_pclk       = 0,
257         .ocr            = MMC_VDD_165_195 | MMC_VDD_32_33 | MMC_VDD_33_34,
258         .caps           = MMC_CAP_4_BIT_DATA |
259                           MMC_CAP_8_BIT_DATA |
260                           MMC_CAP_NEEDS_POLL,
261 };
262
263 static struct platform_device sh_mmcif_device = {
264         .name           = "sh_mmcif",
265         .id             = 0,
266         .dev            = {
267                 .dma_mask               = NULL,
268                 .coherent_dma_mask      = 0xffffffff,
269                 .platform_data          = &sh_mmcif_plat,
270         },
271         .num_resources  = ARRAY_SIZE(sh_mmcif_resources),
272         .resource       = sh_mmcif_resources,
273 };
274
275 /* SDHI0 */
276 static struct sh_mobile_sdhi_info sdhi0_info = {
277         .dma_slave_tx   = SHDMA_SLAVE_SDHI0_TX,
278         .dma_slave_rx   = SHDMA_SLAVE_SDHI0_RX,
279 };
280
281 static struct resource sdhi0_resources[] = {
282         [0] = {
283                 .name   = "SDHI0",
284                 .start  = 0xe6850000,
285                 .end    = 0xe68501ff,
286                 .flags  = IORESOURCE_MEM,
287         },
288         [1] = {
289                 .start  = evt2irq(0x0e00) /* SDHI0 */,
290                 .flags  = IORESOURCE_IRQ,
291         },
292 };
293
294 static struct platform_device sdhi0_device = {
295         .name           = "sh_mobile_sdhi",
296         .num_resources  = ARRAY_SIZE(sdhi0_resources),
297         .resource       = sdhi0_resources,
298         .id             = 0,
299         .dev    = {
300                 .platform_data  = &sdhi0_info,
301         },
302 };
303
304 /* SDHI1 */
305 static struct sh_mobile_sdhi_info sdhi1_info = {
306         .dma_slave_tx   = SHDMA_SLAVE_SDHI1_TX,
307         .dma_slave_rx   = SHDMA_SLAVE_SDHI1_RX,
308         .tmio_ocr_mask  = MMC_VDD_165_195,
309 };
310
311 static struct resource sdhi1_resources[] = {
312         [0] = {
313                 .name   = "SDHI1",
314                 .start  = 0xe6860000,
315                 .end    = 0xe68601ff,
316                 .flags  = IORESOURCE_MEM,
317         },
318         [1] = {
319                 .start  = evt2irq(0x0e80),
320                 .flags  = IORESOURCE_IRQ,
321         },
322 };
323
324 static struct platform_device sdhi1_device = {
325         .name           = "sh_mobile_sdhi",
326         .num_resources  = ARRAY_SIZE(sdhi1_resources),
327         .resource       = sdhi1_resources,
328         .id             = 1,
329         .dev    = {
330                 .platform_data  = &sdhi1_info,
331         },
332 };
333
334 /* USB1 */
335 static void usb1_host_port_power(int port, int power)
336 {
337         if (!power) /* only power-on supported for now */
338                 return;
339
340         /* set VBOUT/PWEN and EXTLP1 in DVSTCTR */
341         __raw_writew(__raw_readw(0xE68B0008) | 0x600, 0xE68B0008);
342 }
343
344 static struct r8a66597_platdata usb1_host_data = {
345         .on_chip        = 1,
346         .port_power     = usb1_host_port_power,
347 };
348
349 static struct resource usb1_host_resources[] = {
350         [0] = {
351                 .name   = "USBHS",
352                 .start  = 0xE68B0000,
353                 .end    = 0xE68B00E6 - 1,
354                 .flags  = IORESOURCE_MEM,
355         },
356         [1] = {
357                 .start  = evt2irq(0x1ce0) /* USB1_USB1I0 */,
358                 .flags  = IORESOURCE_IRQ,
359         },
360 };
361
362 static struct platform_device usb1_host_device = {
363         .name   = "r8a66597_hcd",
364         .id     = 1,
365         .dev = {
366                 .dma_mask               = NULL,         /*  not use dma */
367                 .coherent_dma_mask      = 0xffffffff,
368                 .platform_data          = &usb1_host_data,
369         },
370         .num_resources  = ARRAY_SIZE(usb1_host_resources),
371         .resource       = usb1_host_resources,
372 };
373
374 static struct sh_mobile_lcdc_info lcdc_info = {
375         .ch[0] = {
376                 .chan = LCDC_CHAN_MAINLCD,
377                 .bpp = 16,
378         }
379 };
380
381 static struct resource lcdc_resources[] = {
382         [0] = {
383                 .name   = "LCDC",
384                 .start  = 0xfe940000, /* P4-only space */
385                 .end    = 0xfe943fff,
386                 .flags  = IORESOURCE_MEM,
387         },
388         [1] = {
389                 .start  = intcs_evt2irq(0x580),
390                 .flags  = IORESOURCE_IRQ,
391         },
392 };
393
394 static struct platform_device lcdc_device = {
395         .name           = "sh_mobile_lcdc_fb",
396         .num_resources  = ARRAY_SIZE(lcdc_resources),
397         .resource       = lcdc_resources,
398         .dev    = {
399                 .platform_data  = &lcdc_info,
400                 .coherent_dma_mask = ~0,
401         },
402 };
403
404 /*
405  * QHD display
406  */
407 #ifdef CONFIG_AP4EVB_QHD
408
409 /* KEYSC (Needs SW43 set to ON) */
410 static struct sh_keysc_info keysc_info = {
411         .mode           = SH_KEYSC_MODE_1,
412         .scan_timing    = 3,
413         .delay          = 2500,
414         .keycodes = {
415                 KEY_0, KEY_1, KEY_2, KEY_3, KEY_4,
416                 KEY_5, KEY_6, KEY_7, KEY_8, KEY_9,
417                 KEY_A, KEY_B, KEY_C, KEY_D, KEY_E,
418                 KEY_F, KEY_G, KEY_H, KEY_I, KEY_J,
419                 KEY_K, KEY_L, KEY_M, KEY_N, KEY_O,
420         },
421 };
422
423 static struct resource keysc_resources[] = {
424         [0] = {
425                 .name   = "KEYSC",
426                 .start  = 0xe61b0000,
427                 .end    = 0xe61b0063,
428                 .flags  = IORESOURCE_MEM,
429         },
430         [1] = {
431                 .start  = evt2irq(0x0be0), /* KEYSC_KEY */
432                 .flags  = IORESOURCE_IRQ,
433         },
434 };
435
436 static struct platform_device keysc_device = {
437         .name           = "sh_keysc",
438         .id             = 0, /* "keysc0" clock */
439         .num_resources  = ARRAY_SIZE(keysc_resources),
440         .resource       = keysc_resources,
441         .dev    = {
442                 .platform_data  = &keysc_info,
443         },
444 };
445
446 /* MIPI-DSI */
447 static struct resource mipidsi0_resources[] = {
448         [0] = {
449                 .start  = 0xffc60000,
450                 .end    = 0xffc68fff,
451                 .flags  = IORESOURCE_MEM,
452         },
453 };
454
455 static struct sh_mipi_dsi_info mipidsi0_info = {
456         .data_format    = MIPI_RGB888,
457         .lcd_chan       = &lcdc_info.ch[0],
458 };
459
460 static struct platform_device mipidsi0_device = {
461         .name           = "sh-mipi-dsi",
462         .num_resources  = ARRAY_SIZE(mipidsi0_resources),
463         .resource       = mipidsi0_resources,
464         .id             = 0,
465         .dev    = {
466                 .platform_data  = &mipidsi0_info,
467         },
468 };
469
470 /* This function will disappear when we switch to (runtime) PM */
471 static int __init ap4evb_init_display_clk(void)
472 {
473         struct clk *lcdc_clk;
474         struct clk *dsitx_clk;
475         int ret;
476
477         lcdc_clk = clk_get(&lcdc_device.dev, "sh_mobile_lcdc_fb.0");
478         if (IS_ERR(lcdc_clk))
479                 return PTR_ERR(lcdc_clk);
480
481         dsitx_clk = clk_get(&mipidsi0_device.dev, "sh-mipi-dsi.0");
482         if (IS_ERR(dsitx_clk)) {
483                 ret = PTR_ERR(dsitx_clk);
484                 goto eclkdsitxget;
485         }
486
487         ret = clk_enable(lcdc_clk);
488         if (ret < 0)
489                 goto eclklcdcon;
490
491         ret = clk_enable(dsitx_clk);
492         if (ret < 0)
493                 goto eclkdsitxon;
494
495         return 0;
496
497 eclkdsitxon:
498         clk_disable(lcdc_clk);
499 eclklcdcon:
500         clk_put(dsitx_clk);
501 eclkdsitxget:
502         clk_put(lcdc_clk);
503
504         return ret;
505 }
506 device_initcall(ap4evb_init_display_clk);
507
508 static struct platform_device *qhd_devices[] __initdata = {
509         &mipidsi0_device,
510         &keysc_device,
511 };
512 #endif /* CONFIG_AP4EVB_QHD */
513
514 /* FSI */
515 #define IRQ_FSI         evt2irq(0x1840)
516 #define FSIACKCR        0xE6150018
517 static void fsiackcr_init(struct clk *clk)
518 {
519         u32 status = __raw_readl(clk->enable_reg);
520
521         /* use external clock */
522         status &= ~0x000000ff;
523         status |= 0x00000080;
524         __raw_writel(status, clk->enable_reg);
525 }
526
527 static struct clk_ops fsiackcr_clk_ops = {
528         .init = fsiackcr_init,
529 };
530
531 static struct clk fsiackcr_clk = {
532         .ops            = &fsiackcr_clk_ops,
533         .enable_reg     = (void __iomem *)FSIACKCR,
534         .rate           = 0, /* unknown */
535 };
536
537 static struct sh_fsi_platform_info fsi_info = {
538         .porta_flags = SH_FSI_BRS_INV |
539                        SH_FSI_OUT_SLAVE_MODE |
540                        SH_FSI_IN_SLAVE_MODE |
541                        SH_FSI_OFMT(PCM) |
542                        SH_FSI_IFMT(PCM),
543 };
544
545 static struct resource fsi_resources[] = {
546         [0] = {
547                 .name   = "FSI",
548                 .start  = 0xFE3C0000,
549                 .end    = 0xFE3C0400 - 1,
550                 .flags  = IORESOURCE_MEM,
551         },
552         [1] = {
553                 .start  = IRQ_FSI,
554                 .flags  = IORESOURCE_IRQ,
555         },
556 };
557
558 static struct platform_device fsi_device = {
559         .name           = "sh_fsi2",
560         .id             = 0,
561         .num_resources  = ARRAY_SIZE(fsi_resources),
562         .resource       = fsi_resources,
563         .dev    = {
564                 .platform_data  = &fsi_info,
565         },
566 };
567
568 static struct platform_device *ap4evb_devices[] __initdata = {
569         &nor_flash_device,
570         &smc911x_device,
571         &sdhi0_device,
572         &sdhi1_device,
573         &usb1_host_device,
574         &lcdc_device,
575         &fsi_device,
576         &sh_mmcif_device
577 };
578
579 /*
580  * FIXME !!
581  *
582  * gpio_no_direction
583  * gpio_pull_up
584  * are quick_hack.
585  *
586  * current gpio frame work doesn't have
587  * the method to control only pull up/down/free.
588  * this function should be replaced by correct gpio function
589  */
590 static void __init gpio_no_direction(u32 addr)
591 {
592         __raw_writeb(0x00, addr);
593 }
594
595 static void __init gpio_pull_up(u32 addr)
596 {
597         u8 data = __raw_readb(addr);
598
599         data &= 0x0F;
600         data |= 0xC0;
601         __raw_writeb(data, addr);
602 }
603
604 /* TouchScreen */
605 #define IRQ28   evt2irq(0x3380) /* IRQ28A */
606 #define IRQ7    evt2irq(0x02e0) /* IRQ7A */
607 static int ts_get_pendown_state(void)
608 {
609         int val1, val2;
610
611         gpio_free(GPIO_FN_IRQ28_123);
612         gpio_free(GPIO_FN_IRQ7_40);
613
614         gpio_request(GPIO_PORT123, NULL);
615         gpio_request(GPIO_PORT40, NULL);
616
617         gpio_direction_input(GPIO_PORT123);
618         gpio_direction_input(GPIO_PORT40);
619
620         val1 = gpio_get_value(GPIO_PORT123);
621         val2 = gpio_get_value(GPIO_PORT40);
622
623         gpio_request(GPIO_FN_IRQ28_123, NULL);  /* for QHD */
624         gpio_request(GPIO_FN_IRQ7_40, NULL);    /* for WVGA */
625
626         return val1 ^ val2;
627 }
628
629 #define PORT40CR        0xE6051028
630 #define PORT123CR       0xE605007B
631 static int ts_init(void)
632 {
633         gpio_request(GPIO_FN_IRQ28_123, NULL);  /* for QHD */
634         gpio_request(GPIO_FN_IRQ7_40, NULL);    /* for WVGA */
635
636         gpio_pull_up(PORT40CR);
637         gpio_pull_up(PORT123CR);
638
639         return 0;
640 }
641
642 static struct tsc2007_platform_data tsc2007_info = {
643         .model                  = 2007,
644         .x_plate_ohms           = 180,
645         .get_pendown_state      = ts_get_pendown_state,
646         .init_platform_hw       = ts_init,
647 };
648
649 static struct i2c_board_info tsc_device = {
650         I2C_BOARD_INFO("tsc2007", 0x48),
651         .type           = "tsc2007",
652         .platform_data  = &tsc2007_info,
653         /*.irq is selected on ap4evb_init */
654 };
655
656 /* I2C */
657 static struct i2c_board_info i2c0_devices[] = {
658         {
659                 I2C_BOARD_INFO("ak4643", 0x13),
660         },
661 };
662
663 static struct i2c_board_info i2c1_devices[] = {
664         {
665                 I2C_BOARD_INFO("r2025sd", 0x32),
666         },
667 };
668
669 static struct map_desc ap4evb_io_desc[] __initdata = {
670         /* create a 1:1 entity map for 0xe6xxxxxx
671          * used by CPGA, INTC and PFC.
672          */
673         {
674                 .virtual        = 0xe6000000,
675                 .pfn            = __phys_to_pfn(0xe6000000),
676                 .length         = 256 << 20,
677                 .type           = MT_DEVICE_NONSHARED
678         },
679 };
680
681 static void __init ap4evb_map_io(void)
682 {
683         iotable_init(ap4evb_io_desc, ARRAY_SIZE(ap4evb_io_desc));
684
685         /* setup early devices and console here as well */
686         sh7372_add_early_devices();
687         shmobile_setup_console();
688 }
689
690 #define GPIO_PORT9CR    0xE6051009
691 #define GPIO_PORT10CR   0xE605100A
692
693 static void __init ap4evb_init(void)
694 {
695         struct clk *clk;
696
697         sh7372_pinmux_init();
698
699         /* enable SCIFA0 */
700         gpio_request(GPIO_FN_SCIFA0_TXD, NULL);
701         gpio_request(GPIO_FN_SCIFA0_RXD, NULL);
702
703         /* enable SMSC911X */
704         gpio_request(GPIO_FN_CS5A,      NULL);
705         gpio_request(GPIO_FN_IRQ6_39,   NULL);
706
707         /* enable LED 1 - 4 */
708         gpio_request(GPIO_PORT185, NULL);
709         gpio_request(GPIO_PORT186, NULL);
710         gpio_request(GPIO_PORT187, NULL);
711         gpio_request(GPIO_PORT188, NULL);
712         gpio_direction_output(GPIO_PORT185, 1);
713         gpio_direction_output(GPIO_PORT186, 1);
714         gpio_direction_output(GPIO_PORT187, 1);
715         gpio_direction_output(GPIO_PORT188, 1);
716         gpio_export(GPIO_PORT185, 0);
717         gpio_export(GPIO_PORT186, 0);
718         gpio_export(GPIO_PORT187, 0);
719         gpio_export(GPIO_PORT188, 0);
720
721         /* enable Debug switch (S6) */
722         gpio_request(GPIO_PORT32, NULL);
723         gpio_request(GPIO_PORT33, NULL);
724         gpio_request(GPIO_PORT34, NULL);
725         gpio_request(GPIO_PORT35, NULL);
726         gpio_direction_input(GPIO_PORT32);
727         gpio_direction_input(GPIO_PORT33);
728         gpio_direction_input(GPIO_PORT34);
729         gpio_direction_input(GPIO_PORT35);
730         gpio_export(GPIO_PORT32, 0);
731         gpio_export(GPIO_PORT33, 0);
732         gpio_export(GPIO_PORT34, 0);
733         gpio_export(GPIO_PORT35, 0);
734
735         /* SDHI0 */
736         gpio_request(GPIO_FN_SDHICD0, NULL);
737         gpio_request(GPIO_FN_SDHIWP0, NULL);
738         gpio_request(GPIO_FN_SDHICMD0, NULL);
739         gpio_request(GPIO_FN_SDHICLK0, NULL);
740         gpio_request(GPIO_FN_SDHID0_3, NULL);
741         gpio_request(GPIO_FN_SDHID0_2, NULL);
742         gpio_request(GPIO_FN_SDHID0_1, NULL);
743         gpio_request(GPIO_FN_SDHID0_0, NULL);
744
745         /* SDHI1 */
746         gpio_request(GPIO_FN_SDHICMD1, NULL);
747         gpio_request(GPIO_FN_SDHICLK1, NULL);
748         gpio_request(GPIO_FN_SDHID1_3, NULL);
749         gpio_request(GPIO_FN_SDHID1_2, NULL);
750         gpio_request(GPIO_FN_SDHID1_1, NULL);
751         gpio_request(GPIO_FN_SDHID1_0, NULL);
752
753         /* MMCIF */
754         gpio_request(GPIO_FN_MMCD0_0, NULL);
755         gpio_request(GPIO_FN_MMCD0_1, NULL);
756         gpio_request(GPIO_FN_MMCD0_2, NULL);
757         gpio_request(GPIO_FN_MMCD0_3, NULL);
758         gpio_request(GPIO_FN_MMCD0_4, NULL);
759         gpio_request(GPIO_FN_MMCD0_5, NULL);
760         gpio_request(GPIO_FN_MMCD0_6, NULL);
761         gpio_request(GPIO_FN_MMCD0_7, NULL);
762         gpio_request(GPIO_FN_MMCCMD0, NULL);
763         gpio_request(GPIO_FN_MMCCLK0, NULL);
764
765         /* USB enable */
766         gpio_request(GPIO_FN_VBUS0_1,    NULL);
767         gpio_request(GPIO_FN_IDIN_1_18,  NULL);
768         gpio_request(GPIO_FN_PWEN_1_115, NULL);
769         gpio_request(GPIO_FN_OVCN_1_114, NULL);
770         gpio_request(GPIO_FN_EXTLP_1,    NULL);
771         gpio_request(GPIO_FN_OVCN2_1,    NULL);
772
773         /* setup USB phy */
774         __raw_writew(0x8a0a, 0xE6058130);       /* USBCR2 */
775
776         /* enable FSI2 */
777         gpio_request(GPIO_FN_FSIAIBT,   NULL);
778         gpio_request(GPIO_FN_FSIAILR,   NULL);
779         gpio_request(GPIO_FN_FSIAISLD,  NULL);
780         gpio_request(GPIO_FN_FSIAOSLD,  NULL);
781         gpio_request(GPIO_PORT161,      NULL);
782         gpio_direction_output(GPIO_PORT161, 0); /* slave */
783
784         gpio_request(GPIO_PORT9, NULL);
785         gpio_request(GPIO_PORT10, NULL);
786         gpio_no_direction(GPIO_PORT9CR);  /* FSIAOBT needs no direction */
787         gpio_no_direction(GPIO_PORT10CR); /* FSIAOLR needs no direction */
788
789         /* set SPU2 clock to 119.6 MHz */
790         clk = clk_get(NULL, "spu_clk");
791         if (!IS_ERR(clk)) {
792                 clk_set_rate(clk, clk_round_rate(clk, 119600000));
793                 clk_put(clk);
794         }
795
796         /* change parent of FSI A */
797         clk = clk_get(NULL, "fsia_clk");
798         if (!IS_ERR(clk)) {
799                 clk_register(&fsiackcr_clk);
800                 clk_set_parent(clk, &fsiackcr_clk);
801                 clk_put(clk);
802         }
803
804         /*
805          * set irq priority, to avoid sound chopping
806          * when NFS rootfs is used
807          *  FSI(3) > SMSC911X(2)
808          */
809         intc_set_priority(IRQ_FSI, 3);
810
811         i2c_register_board_info(0, i2c0_devices,
812                                 ARRAY_SIZE(i2c0_devices));
813
814         i2c_register_board_info(1, i2c1_devices,
815                                 ARRAY_SIZE(i2c1_devices));
816
817 #ifdef CONFIG_AP4EVB_QHD
818         /*
819          * QHD
820          */
821
822         /* enable KEYSC */
823         gpio_request(GPIO_FN_KEYOUT0, NULL);
824         gpio_request(GPIO_FN_KEYOUT1, NULL);
825         gpio_request(GPIO_FN_KEYOUT2, NULL);
826         gpio_request(GPIO_FN_KEYOUT3, NULL);
827         gpio_request(GPIO_FN_KEYOUT4, NULL);
828         gpio_request(GPIO_FN_KEYIN0_136, NULL);
829         gpio_request(GPIO_FN_KEYIN1_135, NULL);
830         gpio_request(GPIO_FN_KEYIN2_134, NULL);
831         gpio_request(GPIO_FN_KEYIN3_133, NULL);
832         gpio_request(GPIO_FN_KEYIN4,     NULL);
833
834         /* enable TouchScreen */
835         set_irq_type(IRQ28, IRQ_TYPE_LEVEL_LOW);
836
837         tsc_device.irq = IRQ28;
838         i2c_register_board_info(1, &tsc_device, 1);
839
840         /* LCDC0 */
841         lcdc_info.clock_source                  = LCDC_CLK_PERIPHERAL;
842         lcdc_info.ch[0].interface_type          = RGB24;
843         lcdc_info.ch[0].clock_divider           = 1;
844         lcdc_info.ch[0].flags                   = LCDC_FLAGS_DWPOL;
845         lcdc_info.ch[0].lcd_cfg.name            = "R63302(QHD)";
846         lcdc_info.ch[0].lcd_cfg.xres            = 544;
847         lcdc_info.ch[0].lcd_cfg.yres            = 961;
848         lcdc_info.ch[0].lcd_cfg.left_margin     = 72;
849         lcdc_info.ch[0].lcd_cfg.right_margin    = 600;
850         lcdc_info.ch[0].lcd_cfg.hsync_len       = 16;
851         lcdc_info.ch[0].lcd_cfg.upper_margin    = 8;
852         lcdc_info.ch[0].lcd_cfg.lower_margin    = 8;
853         lcdc_info.ch[0].lcd_cfg.vsync_len       = 2;
854         lcdc_info.ch[0].lcd_cfg.sync            = FB_SYNC_VERT_HIGH_ACT |
855                                                   FB_SYNC_HOR_HIGH_ACT;
856         lcdc_info.ch[0].lcd_size_cfg.width      = 44;
857         lcdc_info.ch[0].lcd_size_cfg.height     = 79;
858
859         platform_add_devices(qhd_devices, ARRAY_SIZE(qhd_devices));
860
861 #else
862         /*
863          * WVGA
864          */
865         gpio_request(GPIO_FN_LCDD17,   NULL);
866         gpio_request(GPIO_FN_LCDD16,   NULL);
867         gpio_request(GPIO_FN_LCDD15,   NULL);
868         gpio_request(GPIO_FN_LCDD14,   NULL);
869         gpio_request(GPIO_FN_LCDD13,   NULL);
870         gpio_request(GPIO_FN_LCDD12,   NULL);
871         gpio_request(GPIO_FN_LCDD11,   NULL);
872         gpio_request(GPIO_FN_LCDD10,   NULL);
873         gpio_request(GPIO_FN_LCDD9,    NULL);
874         gpio_request(GPIO_FN_LCDD8,    NULL);
875         gpio_request(GPIO_FN_LCDD7,    NULL);
876         gpio_request(GPIO_FN_LCDD6,    NULL);
877         gpio_request(GPIO_FN_LCDD5,    NULL);
878         gpio_request(GPIO_FN_LCDD4,    NULL);
879         gpio_request(GPIO_FN_LCDD3,    NULL);
880         gpio_request(GPIO_FN_LCDD2,    NULL);
881         gpio_request(GPIO_FN_LCDD1,    NULL);
882         gpio_request(GPIO_FN_LCDD0,    NULL);
883         gpio_request(GPIO_FN_LCDDISP,  NULL);
884         gpio_request(GPIO_FN_LCDDCK,   NULL);
885
886         gpio_request(GPIO_PORT189, NULL); /* backlight */
887         gpio_direction_output(GPIO_PORT189, 1);
888
889         gpio_request(GPIO_PORT151, NULL); /* LCDDON */
890         gpio_direction_output(GPIO_PORT151, 1);
891
892         lcdc_info.clock_source                  = LCDC_CLK_BUS;
893         lcdc_info.ch[0].interface_type          = RGB18;
894         lcdc_info.ch[0].clock_divider           = 2;
895         lcdc_info.ch[0].flags                   = 0;
896         lcdc_info.ch[0].lcd_cfg.name            = "WVGA Panel";
897         lcdc_info.ch[0].lcd_cfg.xres            = 800;
898         lcdc_info.ch[0].lcd_cfg.yres            = 480;
899         lcdc_info.ch[0].lcd_cfg.left_margin     = 220;
900         lcdc_info.ch[0].lcd_cfg.right_margin    = 110;
901         lcdc_info.ch[0].lcd_cfg.hsync_len       = 70;
902         lcdc_info.ch[0].lcd_cfg.upper_margin    = 20;
903         lcdc_info.ch[0].lcd_cfg.lower_margin    = 5;
904         lcdc_info.ch[0].lcd_cfg.vsync_len       = 5;
905         lcdc_info.ch[0].lcd_cfg.sync            = 0;
906         lcdc_info.ch[0].lcd_size_cfg.width      = 152;
907         lcdc_info.ch[0].lcd_size_cfg.height     = 91;
908
909         /* enable TouchScreen */
910         set_irq_type(IRQ7, IRQ_TYPE_LEVEL_LOW);
911
912         tsc_device.irq = IRQ7;
913         i2c_register_board_info(0, &tsc_device, 1);
914 #endif /* CONFIG_AP4EVB_QHD */
915
916         sh7372_add_standard_devices();
917
918         platform_add_devices(ap4evb_devices, ARRAY_SIZE(ap4evb_devices));
919 }
920
921 static void __init ap4evb_timer_init(void)
922 {
923         sh7372_clock_init();
924         shmobile_timer.init();
925 }
926
927 static struct sys_timer ap4evb_timer = {
928         .init           = ap4evb_timer_init,
929 };
930
931 MACHINE_START(AP4EVB, "ap4evb")
932         .phys_io        = 0xe6000000,
933         .io_pg_offst    = ((0xe6000000) >> 18) & 0xfffc,
934         .map_io         = ap4evb_map_io,
935         .init_irq       = sh7372_init_irq,
936         .init_machine   = ap4evb_init,
937         .timer          = &ap4evb_timer,
938 MACHINE_END