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/platform_data/st1232_pdata.h>
28#include <linux/irq.h>
29#include <linux/platform_device.h>
30#include <linux/gpio.h>
31#include <linux/gpio_keys.h>
32#include <linux/regulator/driver.h>
33#include <linux/pinctrl/machine.h>
34#include <linux/platform_data/pwm-renesas-tpu.h>
35#include <linux/pwm_backlight.h>
36#include <linux/regulator/fixed.h>
37#include <linux/regulator/gpio-regulator.h>
38#include <linux/regulator/machine.h>
39#include <linux/sh_eth.h>
40#include <linux/videodev2.h>
41#include <linux/usb/renesas_usbhs.h>
42#include <linux/mfd/tmio.h>
43#include <linux/mmc/host.h>
44#include <linux/mmc/sh_mmcif.h>
45#include <linux/mmc/sh_mobile_sdhi.h>
46#include <linux/i2c-gpio.h>
47#include <linux/reboot.h>
48#include <mach/common.h>
49#include <mach/irqs.h>
50#include <mach/r8a7740.h>
51#include <media/mt9t112.h>
52#include <media/sh_mobile_ceu.h>
53#include <media/soc_camera.h>
54#include <asm/page.h>
55#include <asm/mach-types.h>
56#include <asm/mach/arch.h>
57#include <asm/mach/map.h>
58#include <asm/mach/time.h>
59#include <asm/hardware/cache-l2x0.h>
60#include <video/sh_mobile_lcdc.h>
61#include <video/sh_mobile_hdmi.h>
62#include <sound/sh_fsi.h>
63#include <sound/simple_card.h>
64
65#include "sh-gpio.h"
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155#define IRQ7 irq_pin(7)
156#define USBCR1 IOMEM(0xe605810a)
157#define USBH 0xC6700000
158#define USBH_USBCTR 0x10834
159
160struct usbhsf_private {
161 struct clk *phy;
162 struct clk *usb24;
163 struct clk *pci;
164 struct clk *func;
165 struct clk *host;
166 void __iomem *usbh_base;
167 struct renesas_usbhs_platform_info info;
168};
169
170#define usbhsf_get_priv(pdev) \
171 container_of(renesas_usbhs_get_info(pdev), \
172 struct usbhsf_private, info)
173
174static int usbhsf_get_id(struct platform_device *pdev)
175{
176 return USBHS_GADGET;
177}
178
179static int usbhsf_power_ctrl(struct platform_device *pdev,
180 void __iomem *base, int enable)
181{
182 struct usbhsf_private *priv = usbhsf_get_priv(pdev);
183
184
185
186
187
188 if (enable) {
189
190
191
192
193 clk_enable(priv->usb24);
194 clk_enable(priv->pci);
195 clk_enable(priv->host);
196 clk_enable(priv->func);
197 clk_enable(priv->phy);
198
199
200
201
202
203
204
205
206
207 __raw_writew(0xd750, USBCR1);
208 mdelay(1);
209
210
211
212
213 __raw_writel(0x0000000c, priv->usbh_base + USBH_USBCTR);
214 __raw_writel(0x00000008, priv->usbh_base + USBH_USBCTR);
215 mdelay(10);
216
217
218
219
220 __raw_writew(0xd770, USBCR1);
221 __raw_writew(0x4000, base + 0x102);
222
223 } else {
224 __raw_writel(0x0000010f, priv->usbh_base + USBH_USBCTR);
225 __raw_writew(0xd7c0, USBCR1);
226
227 clk_disable(priv->phy);
228 clk_disable(priv->func);
229 clk_disable(priv->host);
230 clk_disable(priv->pci);
231 clk_disable(priv->usb24);
232 }
233
234 return 0;
235}
236
237static int usbhsf_get_vbus(struct platform_device *pdev)
238{
239 return gpio_get_value(209);
240}
241
242static irqreturn_t usbhsf_interrupt(int irq, void *data)
243{
244 struct platform_device *pdev = data;
245
246 renesas_usbhs_call_notify_hotplug(pdev);
247
248 return IRQ_HANDLED;
249}
250
251static int usbhsf_hardware_exit(struct platform_device *pdev)
252{
253 struct usbhsf_private *priv = usbhsf_get_priv(pdev);
254
255 if (!IS_ERR(priv->phy))
256 clk_put(priv->phy);
257 if (!IS_ERR(priv->usb24))
258 clk_put(priv->usb24);
259 if (!IS_ERR(priv->pci))
260 clk_put(priv->pci);
261 if (!IS_ERR(priv->host))
262 clk_put(priv->host);
263 if (!IS_ERR(priv->func))
264 clk_put(priv->func);
265 if (priv->usbh_base)
266 iounmap(priv->usbh_base);
267
268 priv->phy = NULL;
269 priv->usb24 = NULL;
270 priv->pci = NULL;
271 priv->host = NULL;
272 priv->func = NULL;
273 priv->usbh_base = NULL;
274
275 free_irq(IRQ7, pdev);
276
277 return 0;
278}
279
280static int usbhsf_hardware_init(struct platform_device *pdev)
281{
282 struct usbhsf_private *priv = usbhsf_get_priv(pdev);
283 int ret;
284
285 priv->phy = clk_get(&pdev->dev, "phy");
286 priv->usb24 = clk_get(&pdev->dev, "usb24");
287 priv->pci = clk_get(&pdev->dev, "pci");
288 priv->func = clk_get(&pdev->dev, "func");
289 priv->host = clk_get(&pdev->dev, "host");
290 priv->usbh_base = ioremap_nocache(USBH, 0x20000);
291
292 if (IS_ERR(priv->phy) ||
293 IS_ERR(priv->usb24) ||
294 IS_ERR(priv->pci) ||
295 IS_ERR(priv->host) ||
296 IS_ERR(priv->func) ||
297 !priv->usbh_base) {
298 dev_err(&pdev->dev, "USB clock setting failed\n");
299 usbhsf_hardware_exit(pdev);
300 return -EIO;
301 }
302
303 ret = request_irq(IRQ7, usbhsf_interrupt, IRQF_TRIGGER_NONE,
304 dev_name(&pdev->dev), pdev);
305 if (ret) {
306 dev_err(&pdev->dev, "request_irq err\n");
307 return ret;
308 }
309 irq_set_irq_type(IRQ7, IRQ_TYPE_EDGE_BOTH);
310
311
312 clk_set_rate(priv->usb24,
313 clk_get_rate(clk_get_parent(priv->usb24)));
314
315 return 0;
316}
317
318static struct usbhsf_private usbhsf_private = {
319 .info = {
320 .platform_callback = {
321 .get_id = usbhsf_get_id,
322 .get_vbus = usbhsf_get_vbus,
323 .hardware_init = usbhsf_hardware_init,
324 .hardware_exit = usbhsf_hardware_exit,
325 .power_ctrl = usbhsf_power_ctrl,
326 },
327 .driver_param = {
328 .buswait_bwait = 5,
329 .detection_delay = 5,
330 .d0_rx_id = SHDMA_SLAVE_USBHS_RX,
331 .d1_tx_id = SHDMA_SLAVE_USBHS_TX,
332 },
333 }
334};
335
336static struct resource usbhsf_resources[] = {
337 {
338 .name = "USBHS",
339 .start = 0xe6890000,
340 .end = 0xe6890104 - 1,
341 .flags = IORESOURCE_MEM,
342 },
343 {
344 .start = gic_spi(51),
345 .flags = IORESOURCE_IRQ,
346 },
347};
348
349static struct platform_device usbhsf_device = {
350 .name = "renesas_usbhs",
351 .dev = {
352 .platform_data = &usbhsf_private.info,
353 },
354 .id = -1,
355 .num_resources = ARRAY_SIZE(usbhsf_resources),
356 .resource = usbhsf_resources,
357};
358
359
360static struct sh_eth_plat_data sh_eth_platdata = {
361 .phy = 0x00,
362 .edmac_endian = EDMAC_LITTLE_ENDIAN,
363 .phy_interface = PHY_INTERFACE_MODE_MII,
364};
365
366static struct resource sh_eth_resources[] = {
367 {
368 .start = 0xe9a00000,
369 .end = 0xe9a00800 - 1,
370 .flags = IORESOURCE_MEM,
371 }, {
372 .start = 0xe9a01800,
373 .end = 0xe9a02000 - 1,
374 .flags = IORESOURCE_MEM,
375 }, {
376 .start = gic_spi(110),
377 .flags = IORESOURCE_IRQ,
378 },
379};
380
381static struct platform_device sh_eth_device = {
382 .name = "r8a7740-gether",
383 .id = -1,
384 .dev = {
385 .platform_data = &sh_eth_platdata,
386 },
387 .resource = sh_eth_resources,
388 .num_resources = ARRAY_SIZE(sh_eth_resources),
389};
390
391
392static struct resource pwm_resources[] = {
393 [0] = {
394 .start = 0xe6600000,
395 .end = 0xe66000ff,
396 .flags = IORESOURCE_MEM,
397 },
398};
399
400static struct tpu_pwm_platform_data pwm_device_data = {
401 .channels[2] = {
402 .polarity = PWM_POLARITY_INVERSED,
403 }
404};
405
406static struct platform_device pwm_device = {
407 .name = "renesas-tpu-pwm",
408 .id = -1,
409 .dev = {
410 .platform_data = &pwm_device_data,
411 },
412 .num_resources = ARRAY_SIZE(pwm_resources),
413 .resource = pwm_resources,
414};
415
416static struct pwm_lookup pwm_lookup[] = {
417 PWM_LOOKUP("renesas-tpu-pwm", 2, "pwm-backlight.0", NULL),
418};
419
420
421static struct platform_pwm_backlight_data pwm_backlight_data = {
422 .lth_brightness = 50,
423 .max_brightness = 255,
424 .dft_brightness = 255,
425 .pwm_period_ns = 33333,
426};
427
428static struct platform_device pwm_backlight_device = {
429 .name = "pwm-backlight",
430 .dev = {
431 .platform_data = &pwm_backlight_data,
432 },
433};
434
435static struct fb_videomode lcdc0_mode = {
436 .name = "AMPIER/AM-800480",
437 .xres = 800,
438 .yres = 480,
439 .left_margin = 88,
440 .right_margin = 40,
441 .hsync_len = 128,
442 .upper_margin = 20,
443 .lower_margin = 5,
444 .vsync_len = 5,
445 .sync = 0,
446};
447
448static struct sh_mobile_lcdc_info lcdc0_info = {
449 .clock_source = LCDC_CLK_BUS,
450 .ch[0] = {
451 .chan = LCDC_CHAN_MAINLCD,
452 .fourcc = V4L2_PIX_FMT_RGB565,
453 .interface_type = RGB24,
454 .clock_divider = 5,
455 .flags = 0,
456 .lcd_modes = &lcdc0_mode,
457 .num_modes = 1,
458 .panel_cfg = {
459 .width = 111,
460 .height = 68,
461 },
462 },
463};
464
465static struct resource lcdc0_resources[] = {
466 [0] = {
467 .name = "LCD0",
468 .start = 0xfe940000,
469 .end = 0xfe943fff,
470 .flags = IORESOURCE_MEM,
471 },
472 [1] = {
473 .start = gic_spi(177),
474 .flags = IORESOURCE_IRQ,
475 },
476};
477
478static struct platform_device lcdc0_device = {
479 .name = "sh_mobile_lcdc_fb",
480 .num_resources = ARRAY_SIZE(lcdc0_resources),
481 .resource = lcdc0_resources,
482 .id = 0,
483 .dev = {
484 .platform_data = &lcdc0_info,
485 .coherent_dma_mask = ~0,
486 },
487};
488
489
490
491
492static struct sh_mobile_hdmi_info hdmi_info = {
493 .flags = HDMI_OUTPUT_PUSH_PULL |
494 HDMI_OUTPUT_POLARITY_HI |
495 HDMI_32BIT_REG |
496 HDMI_HAS_HTOP1 |
497 HDMI_SND_SRC_SPDIF,
498};
499
500static struct resource hdmi_resources[] = {
501 [0] = {
502 .name = "HDMI",
503 .start = 0xe6be0000,
504 .end = 0xe6be03ff,
505 .flags = IORESOURCE_MEM,
506 },
507 [1] = {
508 .start = gic_spi(131),
509 .flags = IORESOURCE_IRQ,
510 },
511 [2] = {
512 .name = "HDMI emma3pf",
513 .start = 0xe6be4000,
514 .end = 0xe6be43ff,
515 .flags = IORESOURCE_MEM,
516 },
517};
518
519static struct platform_device hdmi_device = {
520 .name = "sh-mobile-hdmi",
521 .num_resources = ARRAY_SIZE(hdmi_resources),
522 .resource = hdmi_resources,
523 .id = -1,
524 .dev = {
525 .platform_data = &hdmi_info,
526 },
527};
528
529static const struct fb_videomode lcdc1_mode = {
530 .name = "HDMI 720p",
531 .xres = 1280,
532 .yres = 720,
533 .pixclock = 13468,
534 .left_margin = 220,
535 .right_margin = 110,
536 .hsync_len = 40,
537 .upper_margin = 20,
538 .lower_margin = 5,
539 .vsync_len = 5,
540 .refresh = 60,
541 .sync = FB_SYNC_VERT_HIGH_ACT | FB_SYNC_HOR_HIGH_ACT,
542};
543
544static struct sh_mobile_lcdc_info hdmi_lcdc_info = {
545 .clock_source = LCDC_CLK_PERIPHERAL,
546 .ch[0] = {
547 .chan = LCDC_CHAN_MAINLCD,
548 .fourcc = V4L2_PIX_FMT_RGB565,
549 .interface_type = RGB24,
550 .clock_divider = 1,
551 .flags = LCDC_FLAGS_DWPOL,
552 .lcd_modes = &lcdc1_mode,
553 .num_modes = 1,
554 .tx_dev = &hdmi_device,
555 .panel_cfg = {
556 .width = 1280,
557 .height = 720,
558 },
559 },
560};
561
562static struct resource hdmi_lcdc_resources[] = {
563 [0] = {
564 .name = "LCDC1",
565 .start = 0xfe944000,
566 .end = 0xfe948000 - 1,
567 .flags = IORESOURCE_MEM,
568 },
569 [1] = {
570 .start = gic_spi(178),
571 .flags = IORESOURCE_IRQ,
572 },
573};
574
575static struct platform_device hdmi_lcdc_device = {
576 .name = "sh_mobile_lcdc_fb",
577 .num_resources = ARRAY_SIZE(hdmi_lcdc_resources),
578 .resource = hdmi_lcdc_resources,
579 .id = 1,
580 .dev = {
581 .platform_data = &hdmi_lcdc_info,
582 .coherent_dma_mask = ~0,
583 },
584};
585
586
587#define GPIO_KEY(c, g, d, ...) \
588 { .code = c, .gpio = g, .desc = d, .active_low = 1, __VA_ARGS__ }
589
590static struct gpio_keys_button gpio_buttons[] = {
591 GPIO_KEY(KEY_POWER, 99, "SW3", .wakeup = 1),
592 GPIO_KEY(KEY_BACK, 100, "SW4"),
593 GPIO_KEY(KEY_MENU, 97, "SW5"),
594 GPIO_KEY(KEY_HOME, 98, "SW6"),
595};
596
597static struct gpio_keys_platform_data gpio_key_info = {
598 .buttons = gpio_buttons,
599 .nbuttons = ARRAY_SIZE(gpio_buttons),
600};
601
602static struct platform_device gpio_keys_device = {
603 .name = "gpio-keys",
604 .id = -1,
605 .dev = {
606 .platform_data = &gpio_key_info,
607 },
608};
609
610
611static struct regulator_consumer_supply fixed3v3_power_consumers[] = {
612 REGULATOR_SUPPLY("vmmc", "sh_mmcif"),
613 REGULATOR_SUPPLY("vqmmc", "sh_mmcif"),
614};
615
616
617static struct regulator_consumer_supply vcc_sdhi0_consumers[] = {
618 REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.0"),
619};
620
621static struct regulator_init_data vcc_sdhi0_init_data = {
622 .constraints = {
623 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
624 },
625 .num_consumer_supplies = ARRAY_SIZE(vcc_sdhi0_consumers),
626 .consumer_supplies = vcc_sdhi0_consumers,
627};
628
629static struct fixed_voltage_config vcc_sdhi0_info = {
630 .supply_name = "SDHI0 Vcc",
631 .microvolts = 3300000,
632 .gpio = 75,
633 .enable_high = 1,
634 .init_data = &vcc_sdhi0_init_data,
635};
636
637static struct platform_device vcc_sdhi0 = {
638 .name = "reg-fixed-voltage",
639 .id = 1,
640 .dev = {
641 .platform_data = &vcc_sdhi0_info,
642 },
643};
644
645
646static struct regulator_consumer_supply vccq_sdhi0_consumers[] = {
647 REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.0"),
648};
649
650static struct regulator_init_data vccq_sdhi0_init_data = {
651 .constraints = {
652 .input_uV = 3300000,
653 .min_uV = 1800000,
654 .max_uV = 3300000,
655 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE |
656 REGULATOR_CHANGE_STATUS,
657 },
658 .num_consumer_supplies = ARRAY_SIZE(vccq_sdhi0_consumers),
659 .consumer_supplies = vccq_sdhi0_consumers,
660};
661
662static struct gpio vccq_sdhi0_gpios[] = {
663 {17, GPIOF_OUT_INIT_LOW, "vccq-sdhi0" },
664};
665
666static struct gpio_regulator_state vccq_sdhi0_states[] = {
667 { .value = 3300000, .gpios = (0 << 0) },
668 { .value = 1800000, .gpios = (1 << 0) },
669};
670
671static struct gpio_regulator_config vccq_sdhi0_info = {
672 .supply_name = "vqmmc",
673
674 .enable_gpio = 74,
675 .enable_high = 1,
676 .enabled_at_boot = 0,
677
678 .gpios = vccq_sdhi0_gpios,
679 .nr_gpios = ARRAY_SIZE(vccq_sdhi0_gpios),
680
681 .states = vccq_sdhi0_states,
682 .nr_states = ARRAY_SIZE(vccq_sdhi0_states),
683
684 .type = REGULATOR_VOLTAGE,
685 .init_data = &vccq_sdhi0_init_data,
686};
687
688static struct platform_device vccq_sdhi0 = {
689 .name = "gpio-regulator",
690 .id = -1,
691 .dev = {
692 .platform_data = &vccq_sdhi0_info,
693 },
694};
695
696
697static struct regulator_consumer_supply vcc_sdhi1_consumers[] = {
698 REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.1"),
699};
700
701static struct regulator_init_data vcc_sdhi1_init_data = {
702 .constraints = {
703 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
704 },
705 .num_consumer_supplies = ARRAY_SIZE(vcc_sdhi1_consumers),
706 .consumer_supplies = vcc_sdhi1_consumers,
707};
708
709static struct fixed_voltage_config vcc_sdhi1_info = {
710 .supply_name = "SDHI1 Vcc",
711 .microvolts = 3300000,
712 .gpio = 16,
713 .enable_high = 1,
714 .init_data = &vcc_sdhi1_init_data,
715};
716
717static struct platform_device vcc_sdhi1 = {
718 .name = "reg-fixed-voltage",
719 .id = 2,
720 .dev = {
721 .platform_data = &vcc_sdhi1_info,
722 },
723};
724
725
726static struct sh_mobile_sdhi_info sdhi0_info = {
727 .dma_slave_tx = SHDMA_SLAVE_SDHI0_TX,
728 .dma_slave_rx = SHDMA_SLAVE_SDHI0_RX,
729 .tmio_caps = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ |
730 MMC_CAP_POWER_OFF_CARD,
731 .tmio_flags = TMIO_MMC_HAS_IDLE_WAIT | TMIO_MMC_USE_GPIO_CD,
732 .cd_gpio = 167,
733};
734
735static struct resource sdhi0_resources[] = {
736 {
737 .name = "SDHI0",
738 .start = 0xe6850000,
739 .end = 0xe6850100 - 1,
740 .flags = IORESOURCE_MEM,
741 },
742
743
744
745 {
746 .name = SH_MOBILE_SDHI_IRQ_SDCARD,
747 .start = gic_spi(118),
748 .flags = IORESOURCE_IRQ,
749 },
750 {
751 .name = SH_MOBILE_SDHI_IRQ_SDIO,
752 .start = gic_spi(119),
753 .flags = IORESOURCE_IRQ,
754 },
755};
756
757static struct platform_device sdhi0_device = {
758 .name = "sh_mobile_sdhi",
759 .id = 0,
760 .dev = {
761 .platform_data = &sdhi0_info,
762 },
763 .num_resources = ARRAY_SIZE(sdhi0_resources),
764 .resource = sdhi0_resources,
765};
766
767
768static struct sh_mobile_sdhi_info sdhi1_info = {
769 .dma_slave_tx = SHDMA_SLAVE_SDHI1_TX,
770 .dma_slave_rx = SHDMA_SLAVE_SDHI1_RX,
771 .tmio_caps = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ |
772 MMC_CAP_POWER_OFF_CARD,
773 .tmio_flags = TMIO_MMC_HAS_IDLE_WAIT | TMIO_MMC_USE_GPIO_CD,
774
775 .cd_gpio = 72,
776};
777
778static struct resource sdhi1_resources[] = {
779 [0] = {
780 .name = "SDHI1",
781 .start = 0xe6860000,
782 .end = 0xe6860100 - 1,
783 .flags = IORESOURCE_MEM,
784 },
785 [1] = {
786 .start = gic_spi(121),
787 .flags = IORESOURCE_IRQ,
788 },
789 [2] = {
790 .start = gic_spi(122),
791 .flags = IORESOURCE_IRQ,
792 },
793 [3] = {
794 .start = gic_spi(123),
795 .flags = IORESOURCE_IRQ,
796 },
797};
798
799static struct platform_device sdhi1_device = {
800 .name = "sh_mobile_sdhi",
801 .id = 1,
802 .dev = {
803 .platform_data = &sdhi1_info,
804 },
805 .num_resources = ARRAY_SIZE(sdhi1_resources),
806 .resource = sdhi1_resources,
807};
808
809static const struct pinctrl_map eva_sdhi1_pinctrl_map[] = {
810 PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.1", "pfc-r8a7740",
811 "sdhi1_data4", "sdhi1"),
812 PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.1", "pfc-r8a7740",
813 "sdhi1_ctrl", "sdhi1"),
814 PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.1", "pfc-r8a7740",
815 "sdhi1_cd", "sdhi1"),
816 PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.1", "pfc-r8a7740",
817 "sdhi1_wp", "sdhi1"),
818};
819
820
821static struct sh_mmcif_plat_data sh_mmcif_plat = {
822 .sup_pclk = 0,
823 .caps = MMC_CAP_4_BIT_DATA |
824 MMC_CAP_8_BIT_DATA |
825 MMC_CAP_NONREMOVABLE,
826 .slave_id_tx = SHDMA_SLAVE_MMCIF_TX,
827 .slave_id_rx = SHDMA_SLAVE_MMCIF_RX,
828};
829
830static struct resource sh_mmcif_resources[] = {
831 [0] = {
832 .name = "MMCIF",
833 .start = 0xe6bd0000,
834 .end = 0xe6bd0100 - 1,
835 .flags = IORESOURCE_MEM,
836 },
837 [1] = {
838
839 .start = gic_spi(56),
840 .flags = IORESOURCE_IRQ,
841 },
842 [2] = {
843
844 .start = gic_spi(57),
845 .flags = IORESOURCE_IRQ,
846 },
847};
848
849static struct platform_device sh_mmcif_device = {
850 .name = "sh_mmcif",
851 .id = -1,
852 .dev = {
853 .platform_data = &sh_mmcif_plat,
854 },
855 .num_resources = ARRAY_SIZE(sh_mmcif_resources),
856 .resource = sh_mmcif_resources,
857};
858
859
860static int mt9t111_power(struct device *dev, int mode)
861{
862 struct clk *mclk = clk_get(NULL, "video1");
863
864 if (IS_ERR(mclk)) {
865 dev_err(dev, "can't get video1 clock\n");
866 return -EINVAL;
867 }
868
869 if (mode) {
870
871 clk_set_rate(mclk, clk_round_rate(mclk, 24000000));
872 clk_enable(mclk);
873 gpio_set_value(158, 1);
874 } else {
875 gpio_set_value(158, 0);
876 clk_disable(mclk);
877 }
878
879 clk_put(mclk);
880
881 return 0;
882}
883
884static struct i2c_board_info i2c_camera_mt9t111 = {
885 I2C_BOARD_INFO("mt9t112", 0x3d),
886};
887
888static struct mt9t112_camera_info mt9t111_info = {
889 .divider = { 16, 0, 0, 7, 0, 10, 14, 7, 7 },
890};
891
892static struct soc_camera_link mt9t111_link = {
893 .i2c_adapter_id = 0,
894 .bus_id = 0,
895 .board_info = &i2c_camera_mt9t111,
896 .power = mt9t111_power,
897 .priv = &mt9t111_info,
898};
899
900static struct platform_device camera_device = {
901 .name = "soc-camera-pdrv",
902 .id = 0,
903 .dev = {
904 .platform_data = &mt9t111_link,
905 },
906};
907
908
909static struct sh_mobile_ceu_info sh_mobile_ceu0_info = {
910 .flags = SH_CEU_FLAG_LOWER_8BIT,
911};
912
913static struct resource ceu0_resources[] = {
914 [0] = {
915 .name = "CEU",
916 .start = 0xfe910000,
917 .end = 0xfe91009f,
918 .flags = IORESOURCE_MEM,
919 },
920 [1] = {
921 .start = gic_spi(160),
922 .flags = IORESOURCE_IRQ,
923 },
924 [2] = {
925
926 },
927};
928
929static struct platform_device ceu0_device = {
930 .name = "sh_mobile_ceu",
931 .id = 0,
932 .num_resources = ARRAY_SIZE(ceu0_resources),
933 .resource = ceu0_resources,
934 .dev = {
935 .platform_data = &sh_mobile_ceu0_info,
936 .coherent_dma_mask = 0xffffffff,
937 },
938};
939
940
941static struct sh_fsi_platform_info fsi_info = {
942
943 .port_a = {
944 .tx_id = SHDMA_SLAVE_FSIA_TX,
945 },
946
947 .port_b = {
948 .flags = SH_FSI_FMT_SPDIF |
949 SH_FSI_ENABLE_STREAM_MODE |
950 SH_FSI_CLK_CPG,
951 .tx_id = SHDMA_SLAVE_FSIB_TX,
952 }
953};
954
955static struct resource fsi_resources[] = {
956 [0] = {
957 .name = "FSI",
958 .start = 0xfe1f0000,
959 .end = 0xfe1f8400 - 1,
960 .flags = IORESOURCE_MEM,
961 },
962 [1] = {
963 .start = gic_spi(9),
964 .flags = IORESOURCE_IRQ,
965 },
966};
967
968static struct platform_device fsi_device = {
969 .name = "sh_fsi2",
970 .id = -1,
971 .num_resources = ARRAY_SIZE(fsi_resources),
972 .resource = fsi_resources,
973 .dev = {
974 .platform_data = &fsi_info,
975 },
976};
977
978
979static struct asoc_simple_card_info fsi_wm8978_info = {
980 .name = "wm8978",
981 .card = "FSI2A-WM8978",
982 .codec = "wm8978.0-001a",
983 .platform = "sh_fsi2",
984 .daifmt = SND_SOC_DAIFMT_I2S,
985 .cpu_dai = {
986 .name = "fsia-dai",
987 .fmt = SND_SOC_DAIFMT_CBS_CFS | SND_SOC_DAIFMT_IB_NF,
988 },
989 .codec_dai = {
990 .name = "wm8978-hifi",
991 .fmt = SND_SOC_DAIFMT_CBM_CFM | SND_SOC_DAIFMT_NB_NF,
992 .sysclk = 12288000,
993 },
994};
995
996static struct platform_device fsi_wm8978_device = {
997 .name = "asoc-simple-card",
998 .id = 0,
999 .dev = {
1000 .platform_data = &fsi_wm8978_info,
1001 },
1002};
1003
1004
1005static struct asoc_simple_card_info fsi2_hdmi_info = {
1006 .name = "HDMI",
1007 .card = "FSI2B-HDMI",
1008 .codec = "sh-mobile-hdmi",
1009 .platform = "sh_fsi2",
1010 .cpu_dai = {
1011 .name = "fsib-dai",
1012 .fmt = SND_SOC_DAIFMT_CBM_CFM,
1013 },
1014 .codec_dai = {
1015 .name = "sh_mobile_hdmi-hifi",
1016 },
1017};
1018
1019static struct platform_device fsi_hdmi_device = {
1020 .name = "asoc-simple-card",
1021 .id = 1,
1022 .dev = {
1023 .platform_data = &fsi2_hdmi_info,
1024 },
1025};
1026
1027
1028static struct i2c_gpio_platform_data i2c_gpio_data = {
1029 .sda_pin = 208,
1030 .scl_pin = 91,
1031 .udelay = 5,
1032};
1033
1034static struct platform_device i2c_gpio_device = {
1035 .name = "i2c-gpio",
1036 .id = 2,
1037 .dev = {
1038 .platform_data = &i2c_gpio_data,
1039 },
1040};
1041
1042
1043static struct st1232_pdata st1232_i2c0_pdata = {
1044 .reset_gpio = 166,
1045};
1046
1047static struct i2c_board_info i2c0_devices[] = {
1048 {
1049 I2C_BOARD_INFO("st1232-ts", 0x55),
1050 .irq = irq_pin(10),
1051 .platform_data = &st1232_i2c0_pdata,
1052 },
1053 {
1054 I2C_BOARD_INFO("wm8978", 0x1a),
1055 },
1056};
1057
1058static struct i2c_board_info i2c2_devices[] = {
1059 {
1060 I2C_BOARD_INFO("s35390a", 0x30),
1061 .type = "s35390a",
1062 },
1063};
1064
1065
1066
1067
1068static struct platform_device *eva_devices[] __initdata = {
1069 &lcdc0_device,
1070 &pwm_device,
1071 &pwm_backlight_device,
1072 &gpio_keys_device,
1073 &sh_eth_device,
1074 &vcc_sdhi0,
1075 &vccq_sdhi0,
1076 &sdhi0_device,
1077 &sh_mmcif_device,
1078 &hdmi_device,
1079 &hdmi_lcdc_device,
1080 &camera_device,
1081 &ceu0_device,
1082 &fsi_device,
1083 &fsi_wm8978_device,
1084 &fsi_hdmi_device,
1085 &i2c_gpio_device,
1086};
1087
1088static const struct pinctrl_map eva_pinctrl_map[] = {
1089
1090 PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_ceu.0", "pfc-r8a7740",
1091 "ceu0_data_0_7", "ceu0"),
1092 PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_ceu.0", "pfc-r8a7740",
1093 "ceu0_clk_0", "ceu0"),
1094 PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_ceu.0", "pfc-r8a7740",
1095 "ceu0_sync", "ceu0"),
1096 PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_ceu.0", "pfc-r8a7740",
1097 "ceu0_field", "ceu0"),
1098
1099 PIN_MAP_MUX_GROUP_DEFAULT("asoc-simple-card.0", "pfc-r8a7740",
1100 "fsia_sclk_in", "fsia"),
1101 PIN_MAP_MUX_GROUP_DEFAULT("asoc-simple-card.0", "pfc-r8a7740",
1102 "fsia_mclk_out", "fsia"),
1103 PIN_MAP_MUX_GROUP_DEFAULT("asoc-simple-card.0", "pfc-r8a7740",
1104 "fsia_data_in_1", "fsia"),
1105 PIN_MAP_MUX_GROUP_DEFAULT("asoc-simple-card.0", "pfc-r8a7740",
1106 "fsia_data_out_0", "fsia"),
1107
1108 PIN_MAP_MUX_GROUP_DEFAULT("asoc-simple-card.1", "pfc-r8a7740",
1109 "fsib_mclk_in", "fsib"),
1110
1111 PIN_MAP_MUX_GROUP_DEFAULT("r8a7740-gether", "pfc-r8a7740",
1112 "gether_mii", "gether"),
1113 PIN_MAP_MUX_GROUP_DEFAULT("r8a7740-gether", "pfc-r8a7740",
1114 "gether_int", "gether"),
1115
1116 PIN_MAP_MUX_GROUP_DEFAULT("sh-mobile-hdmi", "pfc-r8a7740",
1117 "hdmi", "hdmi"),
1118
1119 PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_lcdc_fb.0", "pfc-r8a7740",
1120 "lcd0_data24_0", "lcd0"),
1121 PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_lcdc_fb.0", "pfc-r8a7740",
1122 "lcd0_lclk_1", "lcd0"),
1123 PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_lcdc_fb.0", "pfc-r8a7740",
1124 "lcd0_sync", "lcd0"),
1125
1126 PIN_MAP_MUX_GROUP_DEFAULT("sh_mmcif.0", "pfc-r8a7740",
1127 "mmc0_data8_1", "mmc0"),
1128 PIN_MAP_MUX_GROUP_DEFAULT("sh_mmcif.0", "pfc-r8a7740",
1129 "mmc0_ctrl_1", "mmc0"),
1130
1131 PIN_MAP_MUX_GROUP_DEFAULT("sh-sci.1", "pfc-r8a7740",
1132 "scifa1_data", "scifa1"),
1133
1134 PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-r8a7740",
1135 "sdhi0_data4", "sdhi0"),
1136 PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-r8a7740",
1137 "sdhi0_ctrl", "sdhi0"),
1138 PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-r8a7740",
1139 "sdhi0_wp", "sdhi0"),
1140
1141 PIN_MAP_MUX_GROUP_DEFAULT("0-0055", "pfc-r8a7740",
1142 "intc_irq10", "intc"),
1143
1144 PIN_MAP_MUX_GROUP_DEFAULT("renesas-tpu-pwm", "pfc-r8a7740",
1145 "tpu0_to2_1", "tpu0"),
1146
1147 PIN_MAP_MUX_GROUP_DEFAULT("renesas_usbhs", "pfc-r8a7740",
1148 "intc_irq7_1", "intc"),
1149};
1150
1151static void __init eva_clock_init(void)
1152{
1153 struct clk *system = clk_get(NULL, "system_clk");
1154 struct clk *xtal1 = clk_get(NULL, "extal1");
1155 struct clk *usb24s = clk_get(NULL, "usb24s");
1156 struct clk *fsibck = clk_get(NULL, "fsibck");
1157
1158 if (IS_ERR(system) ||
1159 IS_ERR(xtal1) ||
1160 IS_ERR(usb24s) ||
1161 IS_ERR(fsibck)) {
1162 pr_err("armadillo800eva board clock init failed\n");
1163 goto clock_error;
1164 }
1165
1166
1167 clk_set_rate(xtal1, 24000000);
1168
1169
1170 clk_set_parent(usb24s, system);
1171
1172
1173 clk_set_rate(fsibck, 12288000);
1174
1175clock_error:
1176 if (!IS_ERR(system))
1177 clk_put(system);
1178 if (!IS_ERR(xtal1))
1179 clk_put(xtal1);
1180 if (!IS_ERR(usb24s))
1181 clk_put(usb24s);
1182 if (!IS_ERR(fsibck))
1183 clk_put(fsibck);
1184}
1185
1186
1187
1188
1189#define GPIO_PORT7CR IOMEM(0xe6050007)
1190#define GPIO_PORT8CR IOMEM(0xe6050008)
1191static void __init eva_init(void)
1192{
1193 struct platform_device *usb = NULL;
1194
1195 regulator_register_always_on(0, "fixed-3.3V", fixed3v3_power_consumers,
1196 ARRAY_SIZE(fixed3v3_power_consumers), 3300000);
1197
1198 pinctrl_register_mappings(eva_pinctrl_map, ARRAY_SIZE(eva_pinctrl_map));
1199 pwm_add_table(pwm_lookup, ARRAY_SIZE(pwm_lookup));
1200
1201 r8a7740_pinmux_init();
1202 r8a7740_meram_workaround();
1203
1204
1205 gpio_request_one(61, GPIOF_OUT_INIT_HIGH, NULL);
1206
1207
1208 gpio_request_one(18, GPIOF_OUT_INIT_HIGH, NULL);
1209
1210
1211 gpio_request_one(159, GPIOF_IN, NULL);
1212
1213 if (gpio_get_value(159)) {
1214
1215 } else {
1216
1217
1218
1219
1220
1221
1222
1223 gpio_request_one(209, GPIOF_IN, NULL);
1224
1225 platform_device_register(&usbhsf_device);
1226 usb = &usbhsf_device;
1227 }
1228
1229
1230 gpio_request_one(173, GPIOF_OUT_INIT_LOW, NULL);
1231 gpio_request_one(172, GPIOF_OUT_INIT_HIGH, NULL);
1232
1233 gpio_request_one(158, GPIOF_OUT_INIT_LOW, NULL);
1234
1235
1236 gpio_request(7, NULL);
1237 gpio_request(8, NULL);
1238 gpio_direction_none(GPIO_PORT7CR);
1239 gpio_direction_none(GPIO_PORT8CR);
1240
1241
1242
1243
1244
1245
1246
1247 gpio_request_one(176, GPIOF_OUT_INIT_HIGH, NULL);
1248
1249
1250
1251
1252
1253 gpio_request_one(6, GPIOF_IN, NULL);
1254 if (gpio_get_value(6)) {
1255
1256 } else {
1257
1258 pinctrl_register_mappings(eva_sdhi1_pinctrl_map,
1259 ARRAY_SIZE(eva_sdhi1_pinctrl_map));
1260
1261 platform_device_register(&vcc_sdhi1);
1262 platform_device_register(&sdhi1_device);
1263 }
1264
1265
1266#ifdef CONFIG_CACHE_L2X0
1267
1268 l2x0_init(IOMEM(0xf0002000), 0x40440000, 0x82000fff);
1269#endif
1270
1271 i2c_register_board_info(0, i2c0_devices, ARRAY_SIZE(i2c0_devices));
1272 i2c_register_board_info(2, i2c2_devices, ARRAY_SIZE(i2c2_devices));
1273
1274 r8a7740_add_standard_devices();
1275
1276 platform_add_devices(eva_devices,
1277 ARRAY_SIZE(eva_devices));
1278
1279 rmobile_add_device_to_domain("A4LC", &lcdc0_device);
1280 rmobile_add_device_to_domain("A4LC", &hdmi_lcdc_device);
1281 if (usb)
1282 rmobile_add_device_to_domain("A3SP", usb);
1283
1284 r8a7740_pm_init();
1285}
1286
1287static void __init eva_earlytimer_init(void)
1288{
1289 r8a7740_clock_init(MD_CK0 | MD_CK2);
1290 shmobile_earlytimer_init();
1291
1292
1293 eva_clock_init();
1294}
1295
1296static void __init eva_add_early_devices(void)
1297{
1298 r8a7740_add_early_devices();
1299}
1300
1301#define RESCNT2 IOMEM(0xe6188020)
1302static void eva_restart(enum reboot_mode mode, const char *cmd)
1303{
1304
1305 writel((1 << 31), RESCNT2);
1306}
1307
1308static const char *eva_boards_compat_dt[] __initdata = {
1309 "renesas,armadillo800eva",
1310 NULL,
1311};
1312
1313DT_MACHINE_START(ARMADILLO800EVA_DT, "armadillo800eva")
1314 .map_io = r8a7740_map_io,
1315 .init_early = eva_add_early_devices,
1316 .init_irq = r8a7740_init_irq_of,
1317 .init_machine = eva_init,
1318 .init_late = shmobile_init_late,
1319 .init_time = eva_earlytimer_init,
1320 .dt_compat = eva_boards_compat_dt,
1321 .restart = eva_restart,
1322MACHINE_END
1323
