1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <linux/clk.h>
23#include <linux/delay.h>
24#include <linux/err.h>
25#include <linux/kernel.h>
26#include <linux/input.h>
27#include <linux/irq.h>
28#include <linux/platform_device.h>
29#include <linux/gpio.h>
30#include <linux/gpio_keys.h>
31#include <linux/regulator/fixed.h>
32#include <linux/regulator/machine.h>
33#include <linux/sh_eth.h>
34#include <linux/videodev2.h>
35#include <linux/usb/renesas_usbhs.h>
36#include <linux/mfd/tmio.h>
37#include <linux/mmc/host.h>
38#include <linux/mmc/sh_mmcif.h>
39#include <linux/mmc/sh_mobile_sdhi.h>
40#include <linux/i2c-gpio.h>
41#include <mach/common.h>
42#include <mach/irqs.h>
43#include <mach/r8a7740.h>
44#include <media/mt9t112.h>
45#include <media/sh_mobile_ceu.h>
46#include <media/soc_camera.h>
47#include <asm/page.h>
48#include <asm/mach-types.h>
49#include <asm/mach/arch.h>
50#include <asm/mach/map.h>
51#include <asm/mach/time.h>
52#include <asm/hardware/cache-l2x0.h>
53#include <video/sh_mobile_lcdc.h>
54#include <video/sh_mobile_hdmi.h>
55#include <sound/sh_fsi.h>
56#include <sound/simple_card.h>
57
58#include "sh-gpio.h"
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140#define IRQ7 evt2irq(0x02e0)
141#define USBCR1 IOMEM(0xe605810a)
142#define USBH 0xC6700000
143#define USBH_USBCTR 0x10834
144
145struct usbhsf_private {
146 struct clk *phy;
147 struct clk *usb24;
148 struct clk *pci;
149 struct clk *func;
150 struct clk *host;
151 void __iomem *usbh_base;
152 struct renesas_usbhs_platform_info info;
153};
154
155#define usbhsf_get_priv(pdev) \
156 container_of(renesas_usbhs_get_info(pdev), \
157 struct usbhsf_private, info)
158
159static int usbhsf_get_id(struct platform_device *pdev)
160{
161 return USBHS_GADGET;
162}
163
164static void usbhsf_power_ctrl(struct platform_device *pdev,
165 void __iomem *base, int enable)
166{
167 struct usbhsf_private *priv = usbhsf_get_priv(pdev);
168
169
170
171
172
173 if (enable) {
174
175
176
177
178 clk_enable(priv->usb24);
179 clk_enable(priv->pci);
180 clk_enable(priv->host);
181 clk_enable(priv->func);
182 clk_enable(priv->phy);
183
184
185
186
187
188
189
190
191
192 __raw_writew(0xd750, USBCR1);
193 mdelay(1);
194
195
196
197
198 __raw_writel(0x0000000c, priv->usbh_base + USBH_USBCTR);
199 __raw_writel(0x00000008, priv->usbh_base + USBH_USBCTR);
200 mdelay(10);
201
202
203
204
205 __raw_writew(0xd770, USBCR1);
206 __raw_writew(0x4000, base + 0x102);
207
208 } else {
209 __raw_writel(0x0000010f, priv->usbh_base + USBH_USBCTR);
210 __raw_writew(0xd7c0, USBCR1);
211
212 clk_disable(priv->phy);
213 clk_disable(priv->func);
214 clk_disable(priv->host);
215 clk_disable(priv->pci);
216 clk_disable(priv->usb24);
217 }
218}
219
220static int usbhsf_get_vbus(struct platform_device *pdev)
221{
222 return gpio_get_value(GPIO_PORT209);
223}
224
225static irqreturn_t usbhsf_interrupt(int irq, void *data)
226{
227 struct platform_device *pdev = data;
228
229 renesas_usbhs_call_notify_hotplug(pdev);
230
231 return IRQ_HANDLED;
232}
233
234static void usbhsf_hardware_exit(struct platform_device *pdev)
235{
236 struct usbhsf_private *priv = usbhsf_get_priv(pdev);
237
238 if (!IS_ERR(priv->phy))
239 clk_put(priv->phy);
240 if (!IS_ERR(priv->usb24))
241 clk_put(priv->usb24);
242 if (!IS_ERR(priv->pci))
243 clk_put(priv->pci);
244 if (!IS_ERR(priv->host))
245 clk_put(priv->host);
246 if (!IS_ERR(priv->func))
247 clk_put(priv->func);
248 if (priv->usbh_base)
249 iounmap(priv->usbh_base);
250
251 priv->phy = NULL;
252 priv->usb24 = NULL;
253 priv->pci = NULL;
254 priv->host = NULL;
255 priv->func = NULL;
256 priv->usbh_base = NULL;
257
258 free_irq(IRQ7, pdev);
259}
260
261static int usbhsf_hardware_init(struct platform_device *pdev)
262{
263 struct usbhsf_private *priv = usbhsf_get_priv(pdev);
264 int ret;
265
266 priv->phy = clk_get(&pdev->dev, "phy");
267 priv->usb24 = clk_get(&pdev->dev, "usb24");
268 priv->pci = clk_get(&pdev->dev, "pci");
269 priv->func = clk_get(&pdev->dev, "func");
270 priv->host = clk_get(&pdev->dev, "host");
271 priv->usbh_base = ioremap_nocache(USBH, 0x20000);
272
273 if (IS_ERR(priv->phy) ||
274 IS_ERR(priv->usb24) ||
275 IS_ERR(priv->pci) ||
276 IS_ERR(priv->host) ||
277 IS_ERR(priv->func) ||
278 !priv->usbh_base) {
279 dev_err(&pdev->dev, "USB clock setting failed\n");
280 usbhsf_hardware_exit(pdev);
281 return -EIO;
282 }
283
284 ret = request_irq(IRQ7, usbhsf_interrupt, IRQF_TRIGGER_NONE,
285 dev_name(&pdev->dev), pdev);
286 if (ret) {
287 dev_err(&pdev->dev, "request_irq err\n");
288 return ret;
289 }
290 irq_set_irq_type(IRQ7, IRQ_TYPE_EDGE_BOTH);
291
292
293 clk_set_rate(priv->usb24,
294 clk_get_rate(clk_get_parent(priv->usb24)));
295
296 return 0;
297}
298
299static struct usbhsf_private usbhsf_private = {
300 .info = {
301 .platform_callback = {
302 .get_id = usbhsf_get_id,
303 .get_vbus = usbhsf_get_vbus,
304 .hardware_init = usbhsf_hardware_init,
305 .hardware_exit = usbhsf_hardware_exit,
306 .power_ctrl = usbhsf_power_ctrl,
307 },
308 .driver_param = {
309 .buswait_bwait = 5,
310 .detection_delay = 5,
311 .d0_rx_id = SHDMA_SLAVE_USBHS_RX,
312 .d1_tx_id = SHDMA_SLAVE_USBHS_TX,
313 },
314 }
315};
316
317static struct resource usbhsf_resources[] = {
318 {
319 .name = "USBHS",
320 .start = 0xe6890000,
321 .end = 0xe6890104 - 1,
322 .flags = IORESOURCE_MEM,
323 },
324 {
325 .start = evt2irq(0x0A20),
326 .flags = IORESOURCE_IRQ,
327 },
328};
329
330static struct platform_device usbhsf_device = {
331 .name = "renesas_usbhs",
332 .dev = {
333 .platform_data = &usbhsf_private.info,
334 },
335 .id = -1,
336 .num_resources = ARRAY_SIZE(usbhsf_resources),
337 .resource = usbhsf_resources,
338};
339
340
341static struct sh_eth_plat_data sh_eth_platdata = {
342 .phy = 0x00,
343 .edmac_endian = EDMAC_LITTLE_ENDIAN,
344 .register_type = SH_ETH_REG_GIGABIT,
345 .phy_interface = PHY_INTERFACE_MODE_MII,
346};
347
348static struct resource sh_eth_resources[] = {
349 {
350 .start = 0xe9a00000,
351 .end = 0xe9a00800 - 1,
352 .flags = IORESOURCE_MEM,
353 }, {
354 .start = 0xe9a01800,
355 .end = 0xe9a02000 - 1,
356 .flags = IORESOURCE_MEM,
357 }, {
358 .start = evt2irq(0x0500),
359 .flags = IORESOURCE_IRQ,
360 },
361};
362
363static struct platform_device sh_eth_device = {
364 .name = "sh-eth",
365 .id = -1,
366 .dev = {
367 .platform_data = &sh_eth_platdata,
368 },
369 .resource = sh_eth_resources,
370 .num_resources = ARRAY_SIZE(sh_eth_resources),
371};
372
373
374static struct fb_videomode lcdc0_mode = {
375 .name = "AMPIER/AM-800480",
376 .xres = 800,
377 .yres = 480,
378 .left_margin = 88,
379 .right_margin = 40,
380 .hsync_len = 128,
381 .upper_margin = 20,
382 .lower_margin = 5,
383 .vsync_len = 5,
384 .sync = 0,
385};
386
387static struct sh_mobile_lcdc_info lcdc0_info = {
388 .clock_source = LCDC_CLK_BUS,
389 .ch[0] = {
390 .chan = LCDC_CHAN_MAINLCD,
391 .fourcc = V4L2_PIX_FMT_RGB565,
392 .interface_type = RGB24,
393 .clock_divider = 5,
394 .flags = 0,
395 .lcd_modes = &lcdc0_mode,
396 .num_modes = 1,
397 .panel_cfg = {
398 .width = 111,
399 .height = 68,
400 },
401 },
402};
403
404static struct resource lcdc0_resources[] = {
405 [0] = {
406 .name = "LCD0",
407 .start = 0xfe940000,
408 .end = 0xfe943fff,
409 .flags = IORESOURCE_MEM,
410 },
411 [1] = {
412 .start = intcs_evt2irq(0x580),
413 .flags = IORESOURCE_IRQ,
414 },
415};
416
417static struct platform_device lcdc0_device = {
418 .name = "sh_mobile_lcdc_fb",
419 .num_resources = ARRAY_SIZE(lcdc0_resources),
420 .resource = lcdc0_resources,
421 .id = 0,
422 .dev = {
423 .platform_data = &lcdc0_info,
424 .coherent_dma_mask = ~0,
425 },
426};
427
428
429
430
431static struct sh_mobile_hdmi_info hdmi_info = {
432 .flags = HDMI_OUTPUT_PUSH_PULL |
433 HDMI_OUTPUT_POLARITY_HI |
434 HDMI_32BIT_REG |
435 HDMI_HAS_HTOP1 |
436 HDMI_SND_SRC_SPDIF,
437};
438
439static struct resource hdmi_resources[] = {
440 [0] = {
441 .name = "HDMI",
442 .start = 0xe6be0000,
443 .end = 0xe6be03ff,
444 .flags = IORESOURCE_MEM,
445 },
446 [1] = {
447 .start = evt2irq(0x1700),
448 .flags = IORESOURCE_IRQ,
449 },
450 [2] = {
451 .name = "HDMI emma3pf",
452 .start = 0xe6be4000,
453 .end = 0xe6be43ff,
454 .flags = IORESOURCE_MEM,
455 },
456};
457
458static struct platform_device hdmi_device = {
459 .name = "sh-mobile-hdmi",
460 .num_resources = ARRAY_SIZE(hdmi_resources),
461 .resource = hdmi_resources,
462 .id = -1,
463 .dev = {
464 .platform_data = &hdmi_info,
465 },
466};
467
468static const struct fb_videomode lcdc1_mode = {
469 .name = "HDMI 720p",
470 .xres = 1280,
471 .yres = 720,
472 .pixclock = 13468,
473 .left_margin = 220,
474 .right_margin = 110,
475 .hsync_len = 40,
476 .upper_margin = 20,
477 .lower_margin = 5,
478 .vsync_len = 5,
479 .refresh = 60,
480 .sync = FB_SYNC_VERT_HIGH_ACT | FB_SYNC_HOR_HIGH_ACT,
481};
482
483static struct sh_mobile_lcdc_info hdmi_lcdc_info = {
484 .clock_source = LCDC_CLK_PERIPHERAL,
485 .ch[0] = {
486 .chan = LCDC_CHAN_MAINLCD,
487 .fourcc = V4L2_PIX_FMT_RGB565,
488 .interface_type = RGB24,
489 .clock_divider = 1,
490 .flags = LCDC_FLAGS_DWPOL,
491 .lcd_modes = &lcdc1_mode,
492 .num_modes = 1,
493 .tx_dev = &hdmi_device,
494 .panel_cfg = {
495 .width = 1280,
496 .height = 720,
497 },
498 },
499};
500
501static struct resource hdmi_lcdc_resources[] = {
502 [0] = {
503 .name = "LCDC1",
504 .start = 0xfe944000,
505 .end = 0xfe948000 - 1,
506 .flags = IORESOURCE_MEM,
507 },
508 [1] = {
509 .start = intcs_evt2irq(0x1780),
510 .flags = IORESOURCE_IRQ,
511 },
512};
513
514static struct platform_device hdmi_lcdc_device = {
515 .name = "sh_mobile_lcdc_fb",
516 .num_resources = ARRAY_SIZE(hdmi_lcdc_resources),
517 .resource = hdmi_lcdc_resources,
518 .id = 1,
519 .dev = {
520 .platform_data = &hdmi_lcdc_info,
521 .coherent_dma_mask = ~0,
522 },
523};
524
525
526#define GPIO_KEY(c, g, d, ...) \
527 { .code = c, .gpio = g, .desc = d, .active_low = 1, __VA_ARGS__ }
528
529static struct gpio_keys_button gpio_buttons[] = {
530 GPIO_KEY(KEY_POWER, GPIO_PORT99, "SW3", .wakeup = 1),
531 GPIO_KEY(KEY_BACK, GPIO_PORT100, "SW4"),
532 GPIO_KEY(KEY_MENU, GPIO_PORT97, "SW5"),
533 GPIO_KEY(KEY_HOME, GPIO_PORT98, "SW6"),
534};
535
536static struct gpio_keys_platform_data gpio_key_info = {
537 .buttons = gpio_buttons,
538 .nbuttons = ARRAY_SIZE(gpio_buttons),
539};
540
541static struct platform_device gpio_keys_device = {
542 .name = "gpio-keys",
543 .id = -1,
544 .dev = {
545 .platform_data = &gpio_key_info,
546 },
547};
548
549
550static struct regulator_consumer_supply fixed3v3_power_consumers[] =
551{
552 REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.0"),
553 REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.0"),
554 REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.1"),
555 REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.1"),
556 REGULATOR_SUPPLY("vmmc", "sh_mmcif"),
557 REGULATOR_SUPPLY("vqmmc", "sh_mmcif"),
558};
559
560
561
562
563
564
565
566
567
568
569#define IRQ31 evt2irq(0x33E0)
570static struct sh_mobile_sdhi_info sdhi0_info = {
571 .dma_slave_tx = SHDMA_SLAVE_SDHI0_TX,
572 .dma_slave_rx = SHDMA_SLAVE_SDHI0_RX,
573 .tmio_caps = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ |\
574 MMC_CAP_NEEDS_POLL,
575 .tmio_ocr_mask = MMC_VDD_165_195 | MMC_VDD_32_33 | MMC_VDD_33_34,
576 .tmio_flags = TMIO_MMC_HAS_IDLE_WAIT,
577};
578
579static struct resource sdhi0_resources[] = {
580 {
581 .name = "SDHI0",
582 .start = 0xe6850000,
583 .end = 0xe6850100 - 1,
584 .flags = IORESOURCE_MEM,
585 },
586
587
588
589 {
590 .name = SH_MOBILE_SDHI_IRQ_SDCARD,
591 .start = evt2irq(0x0E20),
592 .flags = IORESOURCE_IRQ,
593 },
594 {
595 .name = SH_MOBILE_SDHI_IRQ_SDIO,
596 .start = evt2irq(0x0E40),
597 .flags = IORESOURCE_IRQ,
598 },
599};
600
601static struct platform_device sdhi0_device = {
602 .name = "sh_mobile_sdhi",
603 .id = 0,
604 .dev = {
605 .platform_data = &sdhi0_info,
606 },
607 .num_resources = ARRAY_SIZE(sdhi0_resources),
608 .resource = sdhi0_resources,
609};
610
611
612static struct sh_mobile_sdhi_info sdhi1_info = {
613 .dma_slave_tx = SHDMA_SLAVE_SDHI1_TX,
614 .dma_slave_rx = SHDMA_SLAVE_SDHI1_RX,
615 .tmio_caps = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ,
616 .tmio_ocr_mask = MMC_VDD_165_195 | MMC_VDD_32_33 | MMC_VDD_33_34,
617 .tmio_flags = TMIO_MMC_HAS_IDLE_WAIT,
618};
619
620static struct resource sdhi1_resources[] = {
621 [0] = {
622 .name = "SDHI1",
623 .start = 0xe6860000,
624 .end = 0xe6860100 - 1,
625 .flags = IORESOURCE_MEM,
626 },
627 [1] = {
628 .start = evt2irq(0x0E80),
629 .flags = IORESOURCE_IRQ,
630 },
631 [2] = {
632 .start = evt2irq(0x0EA0),
633 .flags = IORESOURCE_IRQ,
634 },
635 [3] = {
636 .start = evt2irq(0x0EC0),
637 .flags = IORESOURCE_IRQ,
638 },
639};
640
641static struct platform_device sdhi1_device = {
642 .name = "sh_mobile_sdhi",
643 .id = 1,
644 .dev = {
645 .platform_data = &sdhi1_info,
646 },
647 .num_resources = ARRAY_SIZE(sdhi1_resources),
648 .resource = sdhi1_resources,
649};
650
651
652static struct sh_mmcif_plat_data sh_mmcif_plat = {
653 .sup_pclk = 0,
654 .ocr = MMC_VDD_165_195 | MMC_VDD_32_33 | MMC_VDD_33_34,
655 .caps = MMC_CAP_4_BIT_DATA |
656 MMC_CAP_8_BIT_DATA |
657 MMC_CAP_NONREMOVABLE,
658};
659
660static struct resource sh_mmcif_resources[] = {
661 [0] = {
662 .name = "MMCIF",
663 .start = 0xe6bd0000,
664 .end = 0xe6bd0100 - 1,
665 .flags = IORESOURCE_MEM,
666 },
667 [1] = {
668
669 .start = evt2irq(0x1AC0),
670 .flags = IORESOURCE_IRQ,
671 },
672 [2] = {
673
674 .start = evt2irq(0x1AE0),
675 .flags = IORESOURCE_IRQ,
676 },
677};
678
679static struct platform_device sh_mmcif_device = {
680 .name = "sh_mmcif",
681 .id = -1,
682 .dev = {
683 .platform_data = &sh_mmcif_plat,
684 },
685 .num_resources = ARRAY_SIZE(sh_mmcif_resources),
686 .resource = sh_mmcif_resources,
687};
688
689
690static int mt9t111_power(struct device *dev, int mode)
691{
692 struct clk *mclk = clk_get(NULL, "video1");
693
694 if (IS_ERR(mclk)) {
695 dev_err(dev, "can't get video1 clock\n");
696 return -EINVAL;
697 }
698
699 if (mode) {
700
701 clk_set_rate(mclk, clk_round_rate(mclk, 24000000));
702 clk_enable(mclk);
703 gpio_direction_output(GPIO_PORT158, 1);
704 } else {
705 gpio_direction_output(GPIO_PORT158, 0);
706 clk_disable(mclk);
707 }
708
709 clk_put(mclk);
710
711 return 0;
712}
713
714static struct i2c_board_info i2c_camera_mt9t111 = {
715 I2C_BOARD_INFO("mt9t112", 0x3d),
716};
717
718static struct mt9t112_camera_info mt9t111_info = {
719 .divider = { 16, 0, 0, 7, 0, 10, 14, 7, 7 },
720};
721
722static struct soc_camera_link mt9t111_link = {
723 .i2c_adapter_id = 0,
724 .bus_id = 0,
725 .board_info = &i2c_camera_mt9t111,
726 .power = mt9t111_power,
727 .priv = &mt9t111_info,
728};
729
730static struct platform_device camera_device = {
731 .name = "soc-camera-pdrv",
732 .id = 0,
733 .dev = {
734 .platform_data = &mt9t111_link,
735 },
736};
737
738
739static struct sh_mobile_ceu_info sh_mobile_ceu0_info = {
740 .flags = SH_CEU_FLAG_LOWER_8BIT,
741};
742
743static struct resource ceu0_resources[] = {
744 [0] = {
745 .name = "CEU",
746 .start = 0xfe910000,
747 .end = 0xfe91009f,
748 .flags = IORESOURCE_MEM,
749 },
750 [1] = {
751 .start = intcs_evt2irq(0x0500),
752 .flags = IORESOURCE_IRQ,
753 },
754 [2] = {
755
756 },
757};
758
759static struct platform_device ceu0_device = {
760 .name = "sh_mobile_ceu",
761 .id = 0,
762 .num_resources = ARRAY_SIZE(ceu0_resources),
763 .resource = ceu0_resources,
764 .dev = {
765 .platform_data = &sh_mobile_ceu0_info,
766 .coherent_dma_mask = 0xffffffff,
767 },
768};
769
770
771static int fsi_hdmi_set_rate(struct device *dev, int rate, int enable)
772{
773 struct clk *fsib;
774 int ret;
775
776
777 if (48000 != rate)
778 return -EINVAL;
779
780 fsib = clk_get(dev, "ickb");
781 if (IS_ERR(fsib))
782 return -EINVAL;
783
784 if (enable) {
785 ret = SH_FSI_ACKMD_256 | SH_FSI_BPFMD_64;
786 clk_enable(fsib);
787 } else {
788 ret = 0;
789 clk_disable(fsib);
790 }
791
792 clk_put(fsib);
793
794 return ret;
795}
796
797static struct sh_fsi_platform_info fsi_info = {
798
799 .port_a = {
800 .tx_id = SHDMA_SLAVE_FSIA_TX,
801 },
802
803 .port_b = {
804 .flags = SH_FSI_FMT_SPDIF |
805 SH_FSI_ENABLE_STREAM_MODE,
806 .set_rate = fsi_hdmi_set_rate,
807 .tx_id = SHDMA_SLAVE_FSIB_TX,
808 }
809};
810
811static struct resource fsi_resources[] = {
812 [0] = {
813 .name = "FSI",
814 .start = 0xfe1f0000,
815 .end = 0xfe1f8400 - 1,
816 .flags = IORESOURCE_MEM,
817 },
818 [1] = {
819 .start = evt2irq(0x1840),
820 .flags = IORESOURCE_IRQ,
821 },
822};
823
824static struct platform_device fsi_device = {
825 .name = "sh_fsi2",
826 .id = -1,
827 .num_resources = ARRAY_SIZE(fsi_resources),
828 .resource = fsi_resources,
829 .dev = {
830 .platform_data = &fsi_info,
831 },
832};
833
834
835static struct asoc_simple_dai_init_info fsi_wm8978_init_info = {
836 .fmt = SND_SOC_DAIFMT_I2S,
837 .codec_daifmt = SND_SOC_DAIFMT_CBM_CFM | SND_SOC_DAIFMT_NB_NF,
838 .cpu_daifmt = SND_SOC_DAIFMT_CBS_CFS,
839 .sysclk = 12288000,
840};
841
842static struct asoc_simple_card_info fsi_wm8978_info = {
843 .name = "wm8978",
844 .card = "FSI2A-WM8978",
845 .cpu_dai = "fsia-dai",
846 .codec = "wm8978.0-001a",
847 .platform = "sh_fsi2",
848 .codec_dai = "wm8978-hifi",
849 .init = &fsi_wm8978_init_info,
850};
851
852static struct platform_device fsi_wm8978_device = {
853 .name = "asoc-simple-card",
854 .id = 0,
855 .dev = {
856 .platform_data = &fsi_wm8978_info,
857 },
858};
859
860
861static struct asoc_simple_dai_init_info fsi2_hdmi_init_info = {
862 .cpu_daifmt = SND_SOC_DAIFMT_CBM_CFM,
863};
864
865static struct asoc_simple_card_info fsi2_hdmi_info = {
866 .name = "HDMI",
867 .card = "FSI2B-HDMI",
868 .cpu_dai = "fsib-dai",
869 .codec = "sh-mobile-hdmi",
870 .platform = "sh_fsi2",
871 .codec_dai = "sh_mobile_hdmi-hifi",
872 .init = &fsi2_hdmi_init_info,
873};
874
875static struct platform_device fsi_hdmi_device = {
876 .name = "asoc-simple-card",
877 .id = 1,
878 .dev = {
879 .platform_data = &fsi2_hdmi_info,
880 },
881};
882
883
884static struct i2c_gpio_platform_data i2c_gpio_data = {
885 .sda_pin = GPIO_PORT208,
886 .scl_pin = GPIO_PORT91,
887 .udelay = 5,
888};
889
890static struct platform_device i2c_gpio_device = {
891 .name = "i2c-gpio",
892 .id = 2,
893 .dev = {
894 .platform_data = &i2c_gpio_data,
895 },
896};
897
898
899static struct i2c_board_info i2c0_devices[] = {
900 {
901 I2C_BOARD_INFO("st1232-ts", 0x55),
902 .irq = evt2irq(0x0340),
903 },
904 {
905 I2C_BOARD_INFO("wm8978", 0x1a),
906 },
907};
908
909static struct i2c_board_info i2c2_devices[] = {
910 {
911 I2C_BOARD_INFO("s35390a", 0x30),
912 .type = "s35390a",
913 },
914};
915
916
917
918
919static struct platform_device *eva_devices[] __initdata = {
920 &lcdc0_device,
921 &gpio_keys_device,
922 &sh_eth_device,
923 &sdhi0_device,
924 &sh_mmcif_device,
925 &hdmi_device,
926 &hdmi_lcdc_device,
927 &camera_device,
928 &ceu0_device,
929 &fsi_device,
930 &fsi_wm8978_device,
931 &fsi_hdmi_device,
932 &i2c_gpio_device,
933};
934
935static void __init eva_clock_init(void)
936{
937 struct clk *system = clk_get(NULL, "system_clk");
938 struct clk *xtal1 = clk_get(NULL, "extal1");
939 struct clk *usb24s = clk_get(NULL, "usb24s");
940 struct clk *fsibck = clk_get(NULL, "fsibck");
941 struct clk *fsib = clk_get(&fsi_device.dev, "ickb");
942
943 if (IS_ERR(system) ||
944 IS_ERR(xtal1) ||
945 IS_ERR(usb24s) ||
946 IS_ERR(fsibck) ||
947 IS_ERR(fsib)) {
948 pr_err("armadillo800eva board clock init failed\n");
949 goto clock_error;
950 }
951
952
953 clk_set_rate(xtal1, 24000000);
954
955
956 clk_set_parent(usb24s, system);
957
958
959 clk_set_parent(fsib, fsibck);
960 clk_set_rate(fsibck, 12288000);
961 clk_set_rate(fsib, 12288000);
962
963clock_error:
964 if (!IS_ERR(system))
965 clk_put(system);
966 if (!IS_ERR(xtal1))
967 clk_put(xtal1);
968 if (!IS_ERR(usb24s))
969 clk_put(usb24s);
970 if (!IS_ERR(fsibck))
971 clk_put(fsibck);
972 if (!IS_ERR(fsib))
973 clk_put(fsib);
974}
975
976
977
978
979#define GPIO_PORT7CR IOMEM(0xe6050007)
980#define GPIO_PORT8CR IOMEM(0xe6050008)
981static void __init eva_init(void)
982{
983 struct platform_device *usb = NULL;
984
985 regulator_register_always_on(0, "fixed-3.3V", fixed3v3_power_consumers,
986 ARRAY_SIZE(fixed3v3_power_consumers), 3300000);
987
988 r8a7740_pinmux_init();
989 r8a7740_meram_workaround();
990
991
992 gpio_request(GPIO_FN_SCIFA1_RXD, NULL);
993 gpio_request(GPIO_FN_SCIFA1_TXD, NULL);
994
995
996 gpio_request(GPIO_FN_LCDC0_SELECT, NULL);
997 gpio_request(GPIO_FN_LCD0_D0, NULL);
998 gpio_request(GPIO_FN_LCD0_D1, NULL);
999 gpio_request(GPIO_FN_LCD0_D2, NULL);
1000 gpio_request(GPIO_FN_LCD0_D3, NULL);
1001 gpio_request(GPIO_FN_LCD0_D4, NULL);
1002 gpio_request(GPIO_FN_LCD0_D5, NULL);
1003 gpio_request(GPIO_FN_LCD0_D6, NULL);
1004 gpio_request(GPIO_FN_LCD0_D7, NULL);
1005 gpio_request(GPIO_FN_LCD0_D8, NULL);
1006 gpio_request(GPIO_FN_LCD0_D9, NULL);
1007 gpio_request(GPIO_FN_LCD0_D10, NULL);
1008 gpio_request(GPIO_FN_LCD0_D11, NULL);
1009 gpio_request(GPIO_FN_LCD0_D12, NULL);
1010 gpio_request(GPIO_FN_LCD0_D13, NULL);
1011 gpio_request(GPIO_FN_LCD0_D14, NULL);
1012 gpio_request(GPIO_FN_LCD0_D15, NULL);
1013 gpio_request(GPIO_FN_LCD0_D16, NULL);
1014 gpio_request(GPIO_FN_LCD0_D17, NULL);
1015 gpio_request(GPIO_FN_LCD0_D18_PORT40, NULL);
1016 gpio_request(GPIO_FN_LCD0_D19_PORT4, NULL);
1017 gpio_request(GPIO_FN_LCD0_D20_PORT3, NULL);
1018 gpio_request(GPIO_FN_LCD0_D21_PORT2, NULL);
1019 gpio_request(GPIO_FN_LCD0_D22_PORT0, NULL);
1020 gpio_request(GPIO_FN_LCD0_D23_PORT1, NULL);
1021 gpio_request(GPIO_FN_LCD0_DCK, NULL);
1022 gpio_request(GPIO_FN_LCD0_VSYN, NULL);
1023 gpio_request(GPIO_FN_LCD0_HSYN, NULL);
1024 gpio_request(GPIO_FN_LCD0_DISP, NULL);
1025 gpio_request(GPIO_FN_LCD0_LCLK_PORT165, NULL);
1026
1027 gpio_request(GPIO_PORT61, NULL);
1028 gpio_direction_output(GPIO_PORT61, 1);
1029
1030 gpio_request(GPIO_PORT202, NULL);
1031 gpio_direction_output(GPIO_PORT202, 0);
1032
1033
1034 gpio_request(GPIO_FN_IRQ10, NULL);
1035 gpio_request(GPIO_PORT166, NULL);
1036 gpio_direction_output(GPIO_PORT166, 1);
1037
1038
1039 gpio_request(GPIO_FN_ET_CRS, NULL);
1040 gpio_request(GPIO_FN_ET_MDC, NULL);
1041 gpio_request(GPIO_FN_ET_MDIO, NULL);
1042 gpio_request(GPIO_FN_ET_TX_ER, NULL);
1043 gpio_request(GPIO_FN_ET_RX_ER, NULL);
1044 gpio_request(GPIO_FN_ET_ERXD0, NULL);
1045 gpio_request(GPIO_FN_ET_ERXD1, NULL);
1046 gpio_request(GPIO_FN_ET_ERXD2, NULL);
1047 gpio_request(GPIO_FN_ET_ERXD3, NULL);
1048 gpio_request(GPIO_FN_ET_TX_CLK, NULL);
1049 gpio_request(GPIO_FN_ET_TX_EN, NULL);
1050 gpio_request(GPIO_FN_ET_ETXD0, NULL);
1051 gpio_request(GPIO_FN_ET_ETXD1, NULL);
1052 gpio_request(GPIO_FN_ET_ETXD2, NULL);
1053 gpio_request(GPIO_FN_ET_ETXD3, NULL);
1054 gpio_request(GPIO_FN_ET_PHY_INT, NULL);
1055 gpio_request(GPIO_FN_ET_COL, NULL);
1056 gpio_request(GPIO_FN_ET_RX_DV, NULL);
1057 gpio_request(GPIO_FN_ET_RX_CLK, NULL);
1058
1059 gpio_request(GPIO_PORT18, NULL);
1060 gpio_direction_output(GPIO_PORT18, 1);
1061
1062
1063 gpio_request(GPIO_PORT159, NULL);
1064 gpio_direction_input(GPIO_PORT159);
1065
1066 if (gpio_get_value(GPIO_PORT159)) {
1067
1068 } else {
1069
1070
1071
1072
1073
1074
1075
1076
1077 gpio_request(GPIO_FN_IRQ7_PORT209, NULL);
1078 gpio_request(GPIO_PORT209, NULL);
1079 gpio_direction_input(GPIO_PORT209);
1080
1081 platform_device_register(&usbhsf_device);
1082 usb = &usbhsf_device;
1083 }
1084
1085
1086 gpio_request(GPIO_FN_SDHI0_CMD, NULL);
1087 gpio_request(GPIO_FN_SDHI0_CLK, NULL);
1088 gpio_request(GPIO_FN_SDHI0_D0, NULL);
1089 gpio_request(GPIO_FN_SDHI0_D1, NULL);
1090 gpio_request(GPIO_FN_SDHI0_D2, NULL);
1091 gpio_request(GPIO_FN_SDHI0_D3, NULL);
1092 gpio_request(GPIO_FN_SDHI0_WP, NULL);
1093
1094 gpio_request(GPIO_PORT17, NULL);
1095 gpio_request(GPIO_PORT74, NULL);
1096 gpio_request(GPIO_PORT75, NULL);
1097 gpio_direction_output(GPIO_PORT17, 0);
1098 gpio_direction_output(GPIO_PORT74, 1);
1099 gpio_direction_output(GPIO_PORT75, 1);
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109 gpio_request(GPIO_FN_MMC1_CLK_PORT103, NULL);
1110 gpio_request(GPIO_FN_MMC1_CMD_PORT104, NULL);
1111 gpio_request(GPIO_FN_MMC1_D0_PORT149, NULL);
1112 gpio_request(GPIO_FN_MMC1_D1_PORT148, NULL);
1113 gpio_request(GPIO_FN_MMC1_D2_PORT147, NULL);
1114 gpio_request(GPIO_FN_MMC1_D3_PORT146, NULL);
1115 gpio_request(GPIO_FN_MMC1_D4_PORT145, NULL);
1116 gpio_request(GPIO_FN_MMC1_D5_PORT144, NULL);
1117 gpio_request(GPIO_FN_MMC1_D6_PORT143, NULL);
1118 gpio_request(GPIO_FN_MMC1_D7_PORT142, NULL);
1119
1120
1121 gpio_request(GPIO_FN_VIO0_D7, NULL);
1122 gpio_request(GPIO_FN_VIO0_D6, NULL);
1123 gpio_request(GPIO_FN_VIO0_D5, NULL);
1124 gpio_request(GPIO_FN_VIO0_D4, NULL);
1125 gpio_request(GPIO_FN_VIO0_D3, NULL);
1126 gpio_request(GPIO_FN_VIO0_D2, NULL);
1127 gpio_request(GPIO_FN_VIO0_D1, NULL);
1128 gpio_request(GPIO_FN_VIO0_D0, NULL);
1129 gpio_request(GPIO_FN_VIO0_CLK, NULL);
1130 gpio_request(GPIO_FN_VIO0_HD, NULL);
1131 gpio_request(GPIO_FN_VIO0_VD, NULL);
1132 gpio_request(GPIO_FN_VIO0_FIELD, NULL);
1133 gpio_request(GPIO_FN_VIO_CKO, NULL);
1134
1135
1136 gpio_request(GPIO_PORT173, NULL);
1137 gpio_request(GPIO_PORT172, NULL);
1138 gpio_request(GPIO_PORT158, NULL);
1139 gpio_direction_output(GPIO_PORT173, 0);
1140 gpio_direction_output(GPIO_PORT172, 1);
1141 gpio_direction_output(GPIO_PORT158, 0);
1142
1143
1144 gpio_request(GPIO_FN_FSIAIBT, NULL);
1145 gpio_request(GPIO_FN_FSIAILR, NULL);
1146 gpio_request(GPIO_FN_FSIAOMC, NULL);
1147 gpio_request(GPIO_FN_FSIAOSLD, NULL);
1148 gpio_request(GPIO_FN_FSIAISLD_PORT5, NULL);
1149
1150 gpio_request(GPIO_PORT7, NULL);
1151 gpio_request(GPIO_PORT8, NULL);
1152 gpio_direction_none(GPIO_PORT7CR);
1153 gpio_direction_none(GPIO_PORT8CR);
1154
1155
1156 gpio_request(GPIO_FN_FSIBCK, NULL);
1157
1158
1159 gpio_request(GPIO_FN_HDMI_HPD, NULL);
1160 gpio_request(GPIO_FN_HDMI_CEC, NULL);
1161
1162
1163
1164
1165
1166
1167
1168 gpio_request(GPIO_PORT176, NULL);
1169 gpio_direction_output(GPIO_PORT176, 1);
1170
1171
1172
1173
1174
1175 gpio_request(GPIO_PORT6, NULL);
1176 gpio_direction_input(GPIO_PORT6);
1177 if (gpio_get_value(GPIO_PORT6)) {
1178
1179 } else {
1180
1181 gpio_request(GPIO_FN_SDHI1_CLK, NULL);
1182 gpio_request(GPIO_FN_SDHI1_CMD, NULL);
1183 gpio_request(GPIO_FN_SDHI1_D0, NULL);
1184 gpio_request(GPIO_FN_SDHI1_D1, NULL);
1185 gpio_request(GPIO_FN_SDHI1_D2, NULL);
1186 gpio_request(GPIO_FN_SDHI1_D3, NULL);
1187 gpio_request(GPIO_FN_SDHI1_CD, NULL);
1188 gpio_request(GPIO_FN_SDHI1_WP, NULL);
1189
1190 gpio_request(GPIO_PORT16, NULL);
1191 gpio_direction_output(GPIO_PORT16, 1);
1192
1193 platform_device_register(&sdhi1_device);
1194 }
1195
1196
1197#ifdef CONFIG_CACHE_L2X0
1198
1199 l2x0_init(IOMEM(0xf0002000), 0x40440000, 0x82000fff);
1200#endif
1201
1202 i2c_register_board_info(0, i2c0_devices, ARRAY_SIZE(i2c0_devices));
1203 i2c_register_board_info(2, i2c2_devices, ARRAY_SIZE(i2c2_devices));
1204
1205 r8a7740_add_standard_devices();
1206
1207 platform_add_devices(eva_devices,
1208 ARRAY_SIZE(eva_devices));
1209
1210 eva_clock_init();
1211
1212 rmobile_add_device_to_domain("A4LC", &lcdc0_device);
1213 rmobile_add_device_to_domain("A4LC", &hdmi_lcdc_device);
1214 if (usb)
1215 rmobile_add_device_to_domain("A3SP", usb);
1216}
1217
1218static void __init eva_earlytimer_init(void)
1219{
1220 r8a7740_clock_init(MD_CK0 | MD_CK2);
1221 shmobile_earlytimer_init();
1222}
1223
1224static void __init eva_add_early_devices(void)
1225{
1226 r8a7740_add_early_devices();
1227
1228
1229 shmobile_timer.init = eva_earlytimer_init;
1230}
1231
1232static const char *eva_boards_compat_dt[] __initdata = {
1233 "renesas,armadillo800eva",
1234 NULL,
1235};
1236
1237DT_MACHINE_START(ARMADILLO800EVA_DT, "armadillo800eva")
1238 .map_io = r8a7740_map_io,
1239 .init_early = eva_add_early_devices,
1240 .init_irq = r8a7740_init_irq,
1241 .handle_irq = shmobile_handle_irq_intc,
1242 .init_machine = eva_init,
1243 .init_late = shmobile_init_late,
1244 .timer = &shmobile_timer,
1245 .dt_compat = eva_boards_compat_dt,
1246MACHINE_END
1247
