1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <linux/delay.h>
25#include <linux/kernel.h>
26#include <linux/init.h>
27#include <linux/interrupt.h>
28#include <linux/irq.h>
29#include <linux/platform_device.h>
30#include <linux/gpio.h>
31#include <linux/input.h>
32#include <linux/io.h>
33#include <linux/i2c.h>
34#include <linux/leds.h>
35#include <linux/mfd/tmio.h>
36#include <linux/mmc/host.h>
37#include <linux/mmc/sh_mmcif.h>
38#include <linux/mmc/sh_mobile_sdhi.h>
39#include <linux/mtd/mtd.h>
40#include <linux/mtd/partitions.h>
41#include <linux/mtd/physmap.h>
42#include <linux/mtd/sh_flctl.h>
43#include <linux/pm_clock.h>
44#include <linux/regulator/fixed.h>
45#include <linux/regulator/machine.h>
46#include <linux/smsc911x.h>
47#include <linux/sh_intc.h>
48#include <linux/tca6416_keypad.h>
49#include <linux/usb/renesas_usbhs.h>
50#include <linux/dma-mapping.h>
51
52#include <video/sh_mobile_hdmi.h>
53#include <video/sh_mobile_lcdc.h>
54#include <media/sh_mobile_ceu.h>
55#include <media/soc_camera.h>
56#include <media/soc_camera_platform.h>
57#include <sound/sh_fsi.h>
58#include <sound/simple_card.h>
59
60#include <mach/common.h>
61#include <mach/irqs.h>
62#include <mach/sh7372.h>
63
64#include <asm/mach/arch.h>
65#include <asm/mach-types.h>
66
67#include "sh-gpio.h"
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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209static struct regulator_consumer_supply fixed1v8_power_consumers[] =
210{
211
212
213
214
215 REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.1"),
216 REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.1"),
217 REGULATOR_SUPPLY("vmmc", "sh_mmcif.0"),
218 REGULATOR_SUPPLY("vqmmc", "sh_mmcif.0"),
219};
220
221static struct regulator_consumer_supply fixed3v3_power_consumers[] =
222{
223 REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.0"),
224 REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.0"),
225 REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.2"),
226 REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.2"),
227};
228
229
230static struct regulator_consumer_supply dummy_supplies[] = {
231 REGULATOR_SUPPLY("vddvario", "smsc911x"),
232 REGULATOR_SUPPLY("vdd33a", "smsc911x"),
233};
234
235
236static struct mtd_partition nor_flash_partitions[] = {
237 {
238 .name = "loader",
239 .offset = 0x00000000,
240 .size = 512 * 1024,
241 .mask_flags = MTD_WRITEABLE,
242 },
243 {
244 .name = "bootenv",
245 .offset = MTDPART_OFS_APPEND,
246 .size = 512 * 1024,
247 .mask_flags = MTD_WRITEABLE,
248 },
249 {
250 .name = "kernel_ro",
251 .offset = MTDPART_OFS_APPEND,
252 .size = 8 * 1024 * 1024,
253 .mask_flags = MTD_WRITEABLE,
254 },
255 {
256 .name = "kernel",
257 .offset = MTDPART_OFS_APPEND,
258 .size = 8 * 1024 * 1024,
259 },
260 {
261 .name = "data",
262 .offset = MTDPART_OFS_APPEND,
263 .size = MTDPART_SIZ_FULL,
264 },
265};
266
267static struct physmap_flash_data nor_flash_data = {
268 .width = 2,
269 .parts = nor_flash_partitions,
270 .nr_parts = ARRAY_SIZE(nor_flash_partitions),
271};
272
273static struct resource nor_flash_resources[] = {
274 [0] = {
275 .start = 0x20000000,
276 .end = 0x28000000 - 1,
277 .flags = IORESOURCE_MEM,
278 }
279};
280
281static struct platform_device nor_flash_device = {
282 .name = "physmap-flash",
283 .dev = {
284 .platform_data = &nor_flash_data,
285 },
286 .num_resources = ARRAY_SIZE(nor_flash_resources),
287 .resource = nor_flash_resources,
288};
289
290
291static struct resource smc911x_resources[] = {
292 {
293 .start = 0x14000000,
294 .end = 0x16000000 - 1,
295 .flags = IORESOURCE_MEM,
296 }, {
297 .start = evt2irq(0x02c0) ,
298 .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
299 },
300};
301
302static struct smsc911x_platform_config smsc911x_info = {
303 .flags = SMSC911X_USE_16BIT | SMSC911X_SAVE_MAC_ADDRESS,
304 .irq_polarity = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
305 .irq_type = SMSC911X_IRQ_TYPE_PUSH_PULL,
306};
307
308static struct platform_device smc911x_device = {
309 .name = "smsc911x",
310 .id = -1,
311 .num_resources = ARRAY_SIZE(smc911x_resources),
312 .resource = smc911x_resources,
313 .dev = {
314 .platform_data = &smsc911x_info,
315 },
316};
317
318
319static struct sh_mobile_meram_info mackerel_meram_info = {
320 .addr_mode = SH_MOBILE_MERAM_MODE1,
321};
322
323static struct resource meram_resources[] = {
324 [0] = {
325 .name = "regs",
326 .start = 0xe8000000,
327 .end = 0xe807ffff,
328 .flags = IORESOURCE_MEM,
329 },
330 [1] = {
331 .name = "meram",
332 .start = 0xe8080000,
333 .end = 0xe81fffff,
334 .flags = IORESOURCE_MEM,
335 },
336};
337
338static struct platform_device meram_device = {
339 .name = "sh_mobile_meram",
340 .id = 0,
341 .num_resources = ARRAY_SIZE(meram_resources),
342 .resource = meram_resources,
343 .dev = {
344 .platform_data = &mackerel_meram_info,
345 },
346};
347
348
349static struct fb_videomode mackerel_lcdc_modes[] = {
350 {
351 .name = "WVGA Panel",
352 .xres = 800,
353 .yres = 480,
354 .left_margin = 220,
355 .right_margin = 110,
356 .hsync_len = 70,
357 .upper_margin = 20,
358 .lower_margin = 5,
359 .vsync_len = 5,
360 .sync = 0,
361 },
362};
363
364static int mackerel_set_brightness(int brightness)
365{
366 gpio_set_value(GPIO_PORT31, brightness);
367
368 return 0;
369}
370
371static const struct sh_mobile_meram_cfg lcd_meram_cfg = {
372 .icb[0] = {
373 .meram_size = 0x40,
374 },
375 .icb[1] = {
376 .meram_size = 0x40,
377 },
378};
379
380static struct sh_mobile_lcdc_info lcdc_info = {
381 .meram_dev = &mackerel_meram_info,
382 .clock_source = LCDC_CLK_BUS,
383 .ch[0] = {
384 .chan = LCDC_CHAN_MAINLCD,
385 .fourcc = V4L2_PIX_FMT_RGB565,
386 .lcd_modes = mackerel_lcdc_modes,
387 .num_modes = ARRAY_SIZE(mackerel_lcdc_modes),
388 .interface_type = RGB24,
389 .clock_divider = 3,
390 .flags = 0,
391 .panel_cfg = {
392 .width = 152,
393 .height = 91,
394 },
395 .bl_info = {
396 .name = "sh_mobile_lcdc_bl",
397 .max_brightness = 1,
398 .set_brightness = mackerel_set_brightness,
399 },
400 .meram_cfg = &lcd_meram_cfg,
401 }
402};
403
404static struct resource lcdc_resources[] = {
405 [0] = {
406 .name = "LCDC",
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 lcdc_device = {
418 .name = "sh_mobile_lcdc_fb",
419 .num_resources = ARRAY_SIZE(lcdc_resources),
420 .resource = lcdc_resources,
421 .dev = {
422 .platform_data = &lcdc_info,
423 .coherent_dma_mask = ~0,
424 },
425};
426
427
428static struct sh_mobile_hdmi_info hdmi_info = {
429 .flags = HDMI_SND_SRC_SPDIF,
430};
431
432static struct resource hdmi_resources[] = {
433 [0] = {
434 .name = "HDMI",
435 .start = 0xe6be0000,
436 .end = 0xe6be00ff,
437 .flags = IORESOURCE_MEM,
438 },
439 [1] = {
440
441 .start = evt2irq(0x17e0),
442 .flags = IORESOURCE_IRQ,
443 },
444};
445
446static struct platform_device hdmi_device = {
447 .name = "sh-mobile-hdmi",
448 .num_resources = ARRAY_SIZE(hdmi_resources),
449 .resource = hdmi_resources,
450 .id = -1,
451 .dev = {
452 .platform_data = &hdmi_info,
453 },
454};
455
456static const struct sh_mobile_meram_cfg hdmi_meram_cfg = {
457 .icb[0] = {
458 .meram_size = 0x100,
459 },
460 .icb[1] = {
461 .meram_size = 0x100,
462 },
463};
464
465static struct sh_mobile_lcdc_info hdmi_lcdc_info = {
466 .meram_dev = &mackerel_meram_info,
467 .clock_source = LCDC_CLK_EXTERNAL,
468 .ch[0] = {
469 .chan = LCDC_CHAN_MAINLCD,
470 .fourcc = V4L2_PIX_FMT_RGB565,
471 .interface_type = RGB24,
472 .clock_divider = 1,
473 .flags = LCDC_FLAGS_DWPOL,
474 .meram_cfg = &hdmi_meram_cfg,
475 .tx_dev = &hdmi_device,
476 }
477};
478
479static struct resource hdmi_lcdc_resources[] = {
480 [0] = {
481 .name = "LCDC1",
482 .start = 0xfe944000,
483 .end = 0xfe947fff,
484 .flags = IORESOURCE_MEM,
485 },
486 [1] = {
487 .start = intcs_evt2irq(0x1780),
488 .flags = IORESOURCE_IRQ,
489 },
490};
491
492static struct platform_device hdmi_lcdc_device = {
493 .name = "sh_mobile_lcdc_fb",
494 .num_resources = ARRAY_SIZE(hdmi_lcdc_resources),
495 .resource = hdmi_lcdc_resources,
496 .id = 1,
497 .dev = {
498 .platform_data = &hdmi_lcdc_info,
499 .coherent_dma_mask = ~0,
500 },
501};
502
503static struct asoc_simple_card_info fsi2_hdmi_info = {
504 .name = "HDMI",
505 .card = "FSI2B-HDMI",
506 .codec = "sh-mobile-hdmi",
507 .platform = "sh_fsi2",
508 .cpu_dai = {
509 .name = "fsib-dai",
510 .fmt = SND_SOC_DAIFMT_CBM_CFM | SND_SOC_DAIFMT_IB_NF,
511 },
512 .codec_dai = {
513 .name = "sh_mobile_hdmi-hifi",
514 },
515};
516
517static struct platform_device fsi_hdmi_device = {
518 .name = "asoc-simple-card",
519 .id = 1,
520 .dev = {
521 .platform_data = &fsi2_hdmi_info,
522 },
523};
524
525static void __init hdmi_init_pm_clock(void)
526{
527 struct clk *hdmi_ick = clk_get(&hdmi_device.dev, "ick");
528 int ret;
529 long rate;
530
531 if (IS_ERR(hdmi_ick)) {
532 ret = PTR_ERR(hdmi_ick);
533 pr_err("Cannot get HDMI ICK: %d\n", ret);
534 goto out;
535 }
536
537 ret = clk_set_parent(&sh7372_pllc2_clk, &sh7372_dv_clki_div2_clk);
538 if (ret < 0) {
539 pr_err("Cannot set PLLC2 parent: %d, %d users\n",
540 ret, sh7372_pllc2_clk.usecount);
541 goto out;
542 }
543
544 pr_debug("PLLC2 initial frequency %lu\n",
545 clk_get_rate(&sh7372_pllc2_clk));
546
547 rate = clk_round_rate(&sh7372_pllc2_clk, 594000000);
548 if (rate < 0) {
549 pr_err("Cannot get suitable rate: %ld\n", rate);
550 ret = rate;
551 goto out;
552 }
553
554 ret = clk_set_rate(&sh7372_pllc2_clk, rate);
555 if (ret < 0) {
556 pr_err("Cannot set rate %ld: %d\n", rate, ret);
557 goto out;
558 }
559
560 pr_debug("PLLC2 set frequency %lu\n", rate);
561
562 ret = clk_set_parent(hdmi_ick, &sh7372_pllc2_clk);
563 if (ret < 0)
564 pr_err("Cannot set HDMI parent: %d\n", ret);
565
566out:
567 if (!IS_ERR(hdmi_ick))
568 clk_put(hdmi_ick);
569}
570
571
572
573
574
575
576
577#define USBHS0_POLL_INTERVAL (HZ * 5)
578
579struct usbhs_private {
580 void __iomem *usbphyaddr;
581 void __iomem *usbcrcaddr;
582 struct renesas_usbhs_platform_info info;
583 struct delayed_work work;
584 struct platform_device *pdev;
585};
586
587#define usbhs_get_priv(pdev) \
588 container_of(renesas_usbhs_get_info(pdev), \
589 struct usbhs_private, info)
590
591#define usbhs_is_connected(priv) \
592 (!((1 << 7) & __raw_readw(priv->usbcrcaddr)))
593
594static int usbhs_get_vbus(struct platform_device *pdev)
595{
596 return usbhs_is_connected(usbhs_get_priv(pdev));
597}
598
599static void usbhs_phy_reset(struct platform_device *pdev)
600{
601 struct usbhs_private *priv = usbhs_get_priv(pdev);
602
603
604 __raw_writew(0x8a0a, priv->usbcrcaddr);
605}
606
607static int usbhs0_get_id(struct platform_device *pdev)
608{
609 return USBHS_GADGET;
610}
611
612static void usbhs0_work_function(struct work_struct *work)
613{
614 struct usbhs_private *priv = container_of(work, struct usbhs_private,
615 work.work);
616
617 renesas_usbhs_call_notify_hotplug(priv->pdev);
618 schedule_delayed_work(&priv->work, USBHS0_POLL_INTERVAL);
619}
620
621static int usbhs0_hardware_init(struct platform_device *pdev)
622{
623 struct usbhs_private *priv = usbhs_get_priv(pdev);
624
625 priv->pdev = pdev;
626 INIT_DELAYED_WORK(&priv->work, usbhs0_work_function);
627 schedule_delayed_work(&priv->work, USBHS0_POLL_INTERVAL);
628 return 0;
629}
630
631static void usbhs0_hardware_exit(struct platform_device *pdev)
632{
633 struct usbhs_private *priv = usbhs_get_priv(pdev);
634
635 cancel_delayed_work_sync(&priv->work);
636}
637
638static struct usbhs_private usbhs0_private = {
639 .usbcrcaddr = IOMEM(0xe605810c),
640 .info = {
641 .platform_callback = {
642 .hardware_init = usbhs0_hardware_init,
643 .hardware_exit = usbhs0_hardware_exit,
644 .phy_reset = usbhs_phy_reset,
645 .get_id = usbhs0_get_id,
646 .get_vbus = usbhs_get_vbus,
647 },
648 .driver_param = {
649 .buswait_bwait = 4,
650 .d0_tx_id = SHDMA_SLAVE_USB0_TX,
651 .d1_rx_id = SHDMA_SLAVE_USB0_RX,
652 },
653 },
654};
655
656static struct resource usbhs0_resources[] = {
657 [0] = {
658 .name = "USBHS0",
659 .start = 0xe6890000,
660 .end = 0xe68900e6 - 1,
661 .flags = IORESOURCE_MEM,
662 },
663 [1] = {
664 .start = evt2irq(0x1ca0) ,
665 .flags = IORESOURCE_IRQ,
666 },
667};
668
669static struct platform_device usbhs0_device = {
670 .name = "renesas_usbhs",
671 .id = 0,
672 .dev = {
673 .platform_data = &usbhs0_private.info,
674 },
675 .num_resources = ARRAY_SIZE(usbhs0_resources),
676 .resource = usbhs0_resources,
677};
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694#define IRQ8 evt2irq(0x0300)
695#define USB_PHY_MODE (1 << 4)
696#define USB_PHY_INT_EN ((1 << 3) | (1 << 2))
697#define USB_PHY_ON (1 << 1)
698#define USB_PHY_OFF (1 << 0)
699#define USB_PHY_INT_CLR (USB_PHY_ON | USB_PHY_OFF)
700
701static irqreturn_t usbhs1_interrupt(int irq, void *data)
702{
703 struct platform_device *pdev = data;
704 struct usbhs_private *priv = usbhs_get_priv(pdev);
705
706 dev_dbg(&pdev->dev, "%s\n", __func__);
707
708 renesas_usbhs_call_notify_hotplug(pdev);
709
710
711 __raw_writew(__raw_readw(priv->usbphyaddr) | USB_PHY_INT_CLR,
712 priv->usbphyaddr);
713
714 return IRQ_HANDLED;
715}
716
717static int usbhs1_hardware_init(struct platform_device *pdev)
718{
719 struct usbhs_private *priv = usbhs_get_priv(pdev);
720 int ret;
721
722
723 __raw_writew(USB_PHY_MODE | USB_PHY_INT_CLR, priv->usbphyaddr);
724
725 ret = request_irq(IRQ8, usbhs1_interrupt, IRQF_TRIGGER_HIGH,
726 dev_name(&pdev->dev), pdev);
727 if (ret) {
728 dev_err(&pdev->dev, "request_irq err\n");
729 return ret;
730 }
731
732
733 __raw_writew(USB_PHY_MODE | USB_PHY_INT_EN, priv->usbphyaddr);
734
735 return 0;
736}
737
738static void usbhs1_hardware_exit(struct platform_device *pdev)
739{
740 struct usbhs_private *priv = usbhs_get_priv(pdev);
741
742
743 __raw_writew(USB_PHY_MODE | USB_PHY_INT_CLR, priv->usbphyaddr);
744
745 free_irq(IRQ8, pdev);
746}
747
748static int usbhs1_get_id(struct platform_device *pdev)
749{
750 return USBHS_HOST;
751}
752
753static u32 usbhs1_pipe_cfg[] = {
754 USB_ENDPOINT_XFER_CONTROL,
755 USB_ENDPOINT_XFER_ISOC,
756 USB_ENDPOINT_XFER_ISOC,
757 USB_ENDPOINT_XFER_BULK,
758 USB_ENDPOINT_XFER_BULK,
759 USB_ENDPOINT_XFER_BULK,
760 USB_ENDPOINT_XFER_INT,
761 USB_ENDPOINT_XFER_INT,
762 USB_ENDPOINT_XFER_INT,
763 USB_ENDPOINT_XFER_BULK,
764 USB_ENDPOINT_XFER_BULK,
765 USB_ENDPOINT_XFER_BULK,
766 USB_ENDPOINT_XFER_BULK,
767 USB_ENDPOINT_XFER_BULK,
768 USB_ENDPOINT_XFER_BULK,
769 USB_ENDPOINT_XFER_BULK,
770};
771
772static struct usbhs_private usbhs1_private = {
773 .usbphyaddr = IOMEM(0xe60581e2),
774 .usbcrcaddr = IOMEM(0xe6058130),
775 .info = {
776 .platform_callback = {
777 .hardware_init = usbhs1_hardware_init,
778 .hardware_exit = usbhs1_hardware_exit,
779 .get_id = usbhs1_get_id,
780 .phy_reset = usbhs_phy_reset,
781 },
782 .driver_param = {
783 .buswait_bwait = 4,
784 .has_otg = 1,
785 .pipe_type = usbhs1_pipe_cfg,
786 .pipe_size = ARRAY_SIZE(usbhs1_pipe_cfg),
787 .d0_tx_id = SHDMA_SLAVE_USB1_TX,
788 .d1_rx_id = SHDMA_SLAVE_USB1_RX,
789 },
790 },
791};
792
793static struct resource usbhs1_resources[] = {
794 [0] = {
795 .name = "USBHS1",
796 .start = 0xe68b0000,
797 .end = 0xe68b00e6 - 1,
798 .flags = IORESOURCE_MEM,
799 },
800 [1] = {
801 .start = evt2irq(0x1ce0) ,
802 .flags = IORESOURCE_IRQ,
803 },
804};
805
806static struct platform_device usbhs1_device = {
807 .name = "renesas_usbhs",
808 .id = 1,
809 .dev = {
810 .platform_data = &usbhs1_private.info,
811 .dma_mask = &usbhs1_device.dev.coherent_dma_mask,
812 .coherent_dma_mask = DMA_BIT_MASK(32),
813 },
814 .num_resources = ARRAY_SIZE(usbhs1_resources),
815 .resource = usbhs1_resources,
816};
817
818
819static struct gpio_led mackerel_leds[] = {
820 {
821 .name = "led0",
822 .gpio = GPIO_PORT0,
823 .default_state = LEDS_GPIO_DEFSTATE_ON,
824 },
825 {
826 .name = "led1",
827 .gpio = GPIO_PORT1,
828 .default_state = LEDS_GPIO_DEFSTATE_ON,
829 },
830 {
831 .name = "led2",
832 .gpio = GPIO_PORT2,
833 .default_state = LEDS_GPIO_DEFSTATE_ON,
834 },
835 {
836 .name = "led3",
837 .gpio = GPIO_PORT159,
838 .default_state = LEDS_GPIO_DEFSTATE_ON,
839 }
840};
841
842static struct gpio_led_platform_data mackerel_leds_pdata = {
843 .leds = mackerel_leds,
844 .num_leds = ARRAY_SIZE(mackerel_leds),
845};
846
847static struct platform_device leds_device = {
848 .name = "leds-gpio",
849 .id = 0,
850 .dev = {
851 .platform_data = &mackerel_leds_pdata,
852 },
853};
854
855
856#define IRQ_FSI evt2irq(0x1840)
857static struct sh_fsi_platform_info fsi_info = {
858 .port_a = {
859 .tx_id = SHDMA_SLAVE_FSIA_TX,
860 .rx_id = SHDMA_SLAVE_FSIA_RX,
861 },
862 .port_b = {
863 .flags = SH_FSI_CLK_CPG |
864 SH_FSI_FMT_SPDIF,
865 }
866};
867
868static struct resource fsi_resources[] = {
869 [0] = {
870
871
872 .name = "FSI",
873 .start = 0xFE1F0000,
874 .end = 0xFE1F0400 - 1,
875 .flags = IORESOURCE_MEM,
876 },
877 [1] = {
878 .start = IRQ_FSI,
879 .flags = IORESOURCE_IRQ,
880 },
881};
882
883static struct platform_device fsi_device = {
884 .name = "sh_fsi2",
885 .id = -1,
886 .num_resources = ARRAY_SIZE(fsi_resources),
887 .resource = fsi_resources,
888 .dev = {
889 .platform_data = &fsi_info,
890 },
891};
892
893static struct asoc_simple_card_info fsi2_ak4643_info = {
894 .name = "AK4643",
895 .card = "FSI2A-AK4643",
896 .codec = "ak4642-codec.0-0013",
897 .platform = "sh_fsi2",
898 .daifmt = SND_SOC_DAIFMT_LEFT_J,
899 .cpu_dai = {
900 .name = "fsia-dai",
901 .fmt = SND_SOC_DAIFMT_CBS_CFS,
902 },
903 .codec_dai = {
904 .name = "ak4642-hifi",
905 .fmt = SND_SOC_DAIFMT_CBM_CFM,
906 .sysclk = 11289600,
907 },
908};
909
910static struct platform_device fsi_ak4643_device = {
911 .name = "asoc-simple-card",
912 .dev = {
913 .platform_data = &fsi2_ak4643_info,
914 },
915};
916
917
918static struct mtd_partition nand_partition_info[] = {
919 {
920 .name = "system",
921 .offset = 0,
922 .size = 128 * 1024 * 1024,
923 },
924 {
925 .name = "userdata",
926 .offset = MTDPART_OFS_APPEND,
927 .size = 256 * 1024 * 1024,
928 },
929 {
930 .name = "cache",
931 .offset = MTDPART_OFS_APPEND,
932 .size = 128 * 1024 * 1024,
933 },
934};
935
936static struct resource nand_flash_resources[] = {
937 [0] = {
938 .start = 0xe6a30000,
939 .end = 0xe6a3009b,
940 .flags = IORESOURCE_MEM,
941 },
942 [1] = {
943 .start = evt2irq(0x0d80),
944 .flags = IORESOURCE_IRQ,
945 },
946};
947
948static struct sh_flctl_platform_data nand_flash_data = {
949 .parts = nand_partition_info,
950 .nr_parts = ARRAY_SIZE(nand_partition_info),
951 .flcmncr_val = CLK_16B_12L_4H | TYPESEL_SET
952 | SHBUSSEL | SEL_16BIT | SNAND_E,
953 .use_holden = 1,
954};
955
956static struct platform_device nand_flash_device = {
957 .name = "sh_flctl",
958 .resource = nand_flash_resources,
959 .num_resources = ARRAY_SIZE(nand_flash_resources),
960 .dev = {
961 .platform_data = &nand_flash_data,
962 },
963};
964
965
966
967
968
969static int slot_cn7_get_cd(struct platform_device *pdev)
970{
971 return !gpio_get_value(GPIO_PORT41);
972}
973
974
975static struct sh_mobile_sdhi_info sdhi0_info = {
976 .dma_slave_tx = SHDMA_SLAVE_SDHI0_TX,
977 .dma_slave_rx = SHDMA_SLAVE_SDHI0_RX,
978 .tmio_flags = TMIO_MMC_USE_GPIO_CD,
979 .tmio_caps = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ,
980 .cd_gpio = GPIO_PORT172,
981};
982
983static struct resource sdhi0_resources[] = {
984 [0] = {
985 .name = "SDHI0",
986 .start = 0xe6850000,
987 .end = 0xe68500ff,
988 .flags = IORESOURCE_MEM,
989 },
990 [1] = {
991 .start = evt2irq(0x0e00) ,
992 .flags = IORESOURCE_IRQ,
993 },
994 [2] = {
995 .start = evt2irq(0x0e20) ,
996 .flags = IORESOURCE_IRQ,
997 },
998 [3] = {
999 .start = evt2irq(0x0e40) ,
1000 .flags = IORESOURCE_IRQ,
1001 },
1002};
1003
1004static struct platform_device sdhi0_device = {
1005 .name = "sh_mobile_sdhi",
1006 .num_resources = ARRAY_SIZE(sdhi0_resources),
1007 .resource = sdhi0_resources,
1008 .id = 0,
1009 .dev = {
1010 .platform_data = &sdhi0_info,
1011 },
1012};
1013
1014#if !defined(CONFIG_MMC_SH_MMCIF) && !defined(CONFIG_MMC_SH_MMCIF_MODULE)
1015
1016static struct sh_mobile_sdhi_info sdhi1_info = {
1017 .dma_slave_tx = SHDMA_SLAVE_SDHI1_TX,
1018 .dma_slave_rx = SHDMA_SLAVE_SDHI1_RX,
1019 .tmio_ocr_mask = MMC_VDD_165_195,
1020 .tmio_flags = TMIO_MMC_WRPROTECT_DISABLE,
1021 .tmio_caps = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ |
1022 MMC_CAP_NEEDS_POLL,
1023 .get_cd = slot_cn7_get_cd,
1024};
1025
1026static struct resource sdhi1_resources[] = {
1027 [0] = {
1028 .name = "SDHI1",
1029 .start = 0xe6860000,
1030 .end = 0xe68600ff,
1031 .flags = IORESOURCE_MEM,
1032 },
1033 [1] = {
1034 .name = SH_MOBILE_SDHI_IRQ_CARD_DETECT,
1035 .start = evt2irq(0x0e80),
1036 .flags = IORESOURCE_IRQ,
1037 },
1038 [2] = {
1039 .name = SH_MOBILE_SDHI_IRQ_SDCARD,
1040 .start = evt2irq(0x0ea0),
1041 .flags = IORESOURCE_IRQ,
1042 },
1043 [3] = {
1044 .name = SH_MOBILE_SDHI_IRQ_SDIO,
1045 .start = evt2irq(0x0ec0),
1046 .flags = IORESOURCE_IRQ,
1047 },
1048};
1049
1050static struct platform_device sdhi1_device = {
1051 .name = "sh_mobile_sdhi",
1052 .num_resources = ARRAY_SIZE(sdhi1_resources),
1053 .resource = sdhi1_resources,
1054 .id = 1,
1055 .dev = {
1056 .platform_data = &sdhi1_info,
1057 },
1058};
1059#endif
1060
1061
1062
1063
1064
1065static int slot_cn23_get_cd(struct platform_device *pdev)
1066{
1067 return !gpio_get_value(GPIO_PORT162);
1068}
1069
1070
1071static struct sh_mobile_sdhi_info sdhi2_info = {
1072 .dma_slave_tx = SHDMA_SLAVE_SDHI2_TX,
1073 .dma_slave_rx = SHDMA_SLAVE_SDHI2_RX,
1074 .tmio_flags = TMIO_MMC_WRPROTECT_DISABLE,
1075 .tmio_caps = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ |
1076 MMC_CAP_NEEDS_POLL,
1077 .get_cd = slot_cn23_get_cd,
1078};
1079
1080static struct resource sdhi2_resources[] = {
1081 [0] = {
1082 .name = "SDHI2",
1083 .start = 0xe6870000,
1084 .end = 0xe68700ff,
1085 .flags = IORESOURCE_MEM,
1086 },
1087 [1] = {
1088 .name = SH_MOBILE_SDHI_IRQ_CARD_DETECT,
1089 .start = evt2irq(0x1200),
1090 .flags = IORESOURCE_IRQ,
1091 },
1092 [2] = {
1093 .name = SH_MOBILE_SDHI_IRQ_SDCARD,
1094 .start = evt2irq(0x1220),
1095 .flags = IORESOURCE_IRQ,
1096 },
1097 [3] = {
1098 .name = SH_MOBILE_SDHI_IRQ_SDIO,
1099 .start = evt2irq(0x1240),
1100 .flags = IORESOURCE_IRQ,
1101 },
1102};
1103
1104static struct platform_device sdhi2_device = {
1105 .name = "sh_mobile_sdhi",
1106 .num_resources = ARRAY_SIZE(sdhi2_resources),
1107 .resource = sdhi2_resources,
1108 .id = 2,
1109 .dev = {
1110 .platform_data = &sdhi2_info,
1111 },
1112};
1113
1114
1115static struct resource sh_mmcif_resources[] = {
1116 [0] = {
1117 .name = "MMCIF",
1118 .start = 0xE6BD0000,
1119 .end = 0xE6BD00FF,
1120 .flags = IORESOURCE_MEM,
1121 },
1122 [1] = {
1123
1124 .start = evt2irq(0x1ac0),
1125 .flags = IORESOURCE_IRQ,
1126 },
1127 [2] = {
1128
1129 .start = evt2irq(0x1ae0),
1130 .flags = IORESOURCE_IRQ,
1131 },
1132};
1133
1134static struct sh_mmcif_plat_data sh_mmcif_plat = {
1135 .sup_pclk = 0,
1136 .ocr = MMC_VDD_165_195 | MMC_VDD_32_33 | MMC_VDD_33_34,
1137 .caps = MMC_CAP_4_BIT_DATA |
1138 MMC_CAP_8_BIT_DATA |
1139 MMC_CAP_NEEDS_POLL,
1140 .get_cd = slot_cn7_get_cd,
1141 .slave_id_tx = SHDMA_SLAVE_MMCIF_TX,
1142 .slave_id_rx = SHDMA_SLAVE_MMCIF_RX,
1143};
1144
1145static struct platform_device sh_mmcif_device = {
1146 .name = "sh_mmcif",
1147 .id = 0,
1148 .dev = {
1149 .dma_mask = NULL,
1150 .coherent_dma_mask = 0xffffffff,
1151 .platform_data = &sh_mmcif_plat,
1152 },
1153 .num_resources = ARRAY_SIZE(sh_mmcif_resources),
1154 .resource = sh_mmcif_resources,
1155};
1156
1157
1158static int mackerel_camera_add(struct soc_camera_device *icd);
1159static void mackerel_camera_del(struct soc_camera_device *icd);
1160
1161static int camera_set_capture(struct soc_camera_platform_info *info,
1162 int enable)
1163{
1164 return 0;
1165}
1166
1167static struct soc_camera_platform_info camera_info = {
1168 .format_name = "UYVY",
1169 .format_depth = 16,
1170 .format = {
1171 .code = V4L2_MBUS_FMT_UYVY8_2X8,
1172 .colorspace = V4L2_COLORSPACE_SMPTE170M,
1173 .field = V4L2_FIELD_NONE,
1174 .width = 640,
1175 .height = 480,
1176 },
1177 .mbus_param = V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_MASTER |
1178 V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_HIGH |
1179 V4L2_MBUS_DATA_ACTIVE_HIGH,
1180 .mbus_type = V4L2_MBUS_PARALLEL,
1181 .set_capture = camera_set_capture,
1182};
1183
1184static struct soc_camera_link camera_link = {
1185 .bus_id = 0,
1186 .add_device = mackerel_camera_add,
1187 .del_device = mackerel_camera_del,
1188 .module_name = "soc_camera_platform",
1189 .priv = &camera_info,
1190};
1191
1192static struct platform_device *camera_device;
1193
1194static void mackerel_camera_release(struct device *dev)
1195{
1196 soc_camera_platform_release(&camera_device);
1197}
1198
1199static int mackerel_camera_add(struct soc_camera_device *icd)
1200{
1201 return soc_camera_platform_add(icd, &camera_device, &camera_link,
1202 mackerel_camera_release, 0);
1203}
1204
1205static void mackerel_camera_del(struct soc_camera_device *icd)
1206{
1207 soc_camera_platform_del(icd, camera_device, &camera_link);
1208}
1209
1210static struct sh_mobile_ceu_info sh_mobile_ceu_info = {
1211 .flags = SH_CEU_FLAG_USE_8BIT_BUS,
1212 .max_width = 8188,
1213 .max_height = 8188,
1214};
1215
1216static struct resource ceu_resources[] = {
1217 [0] = {
1218 .name = "CEU",
1219 .start = 0xfe910000,
1220 .end = 0xfe91009f,
1221 .flags = IORESOURCE_MEM,
1222 },
1223 [1] = {
1224 .start = intcs_evt2irq(0x880),
1225 .flags = IORESOURCE_IRQ,
1226 },
1227 [2] = {
1228
1229 },
1230};
1231
1232static struct platform_device ceu_device = {
1233 .name = "sh_mobile_ceu",
1234 .id = 0,
1235 .num_resources = ARRAY_SIZE(ceu_resources),
1236 .resource = ceu_resources,
1237 .dev = {
1238 .platform_data = &sh_mobile_ceu_info,
1239 .coherent_dma_mask = 0xffffffff,
1240 },
1241};
1242
1243static struct platform_device mackerel_camera = {
1244 .name = "soc-camera-pdrv",
1245 .id = 0,
1246 .dev = {
1247 .platform_data = &camera_link,
1248 },
1249};
1250
1251static struct platform_device *mackerel_devices[] __initdata = {
1252 &nor_flash_device,
1253 &smc911x_device,
1254 &lcdc_device,
1255 &usbhs0_device,
1256 &usbhs1_device,
1257 &leds_device,
1258 &fsi_device,
1259 &fsi_ak4643_device,
1260 &fsi_hdmi_device,
1261 &nand_flash_device,
1262 &sdhi0_device,
1263#if !defined(CONFIG_MMC_SH_MMCIF) && !defined(CONFIG_MMC_SH_MMCIF_MODULE)
1264 &sdhi1_device,
1265#endif
1266 &sdhi2_device,
1267 &sh_mmcif_device,
1268 &ceu_device,
1269 &mackerel_camera,
1270 &hdmi_device,
1271 &hdmi_lcdc_device,
1272 &meram_device,
1273};
1274
1275
1276#define KEYPAD_BUTTON(ev_type, ev_code, act_low) \
1277{ \
1278 .type = ev_type, \
1279 .code = ev_code, \
1280 .active_low = act_low, \
1281}
1282
1283#define KEYPAD_BUTTON_LOW(event_code) KEYPAD_BUTTON(EV_KEY, event_code, 1)
1284
1285static struct tca6416_button mackerel_gpio_keys[] = {
1286 KEYPAD_BUTTON_LOW(KEY_HOME),
1287 KEYPAD_BUTTON_LOW(KEY_MENU),
1288 KEYPAD_BUTTON_LOW(KEY_BACK),
1289 KEYPAD_BUTTON_LOW(KEY_POWER),
1290};
1291
1292static struct tca6416_keys_platform_data mackerel_tca6416_keys_info = {
1293 .buttons = mackerel_gpio_keys,
1294 .nbuttons = ARRAY_SIZE(mackerel_gpio_keys),
1295 .rep = 1,
1296 .use_polling = 0,
1297 .pinmask = 0x000F,
1298};
1299
1300
1301#define IRQ7 evt2irq(0x02e0)
1302#define IRQ9 evt2irq(0x0320)
1303
1304static struct i2c_board_info i2c0_devices[] = {
1305 {
1306 I2C_BOARD_INFO("ak4643", 0x13),
1307 },
1308
1309 {
1310 I2C_BOARD_INFO("tca6408-keys", 0x20),
1311 .platform_data = &mackerel_tca6416_keys_info,
1312 .irq = IRQ9,
1313 },
1314
1315 {
1316 I2C_BOARD_INFO("st1232-ts", 0x55),
1317 .irq = IRQ7,
1318 },
1319};
1320
1321#define IRQ21 evt2irq(0x32a0)
1322
1323static struct i2c_board_info i2c1_devices[] = {
1324
1325 {
1326 I2C_BOARD_INFO("adxl34x", 0x53),
1327 .irq = IRQ21,
1328 },
1329};
1330
1331#define GPIO_PORT9CR IOMEM(0xE6051009)
1332#define GPIO_PORT10CR IOMEM(0xE605100A)
1333#define GPIO_PORT167CR IOMEM(0xE60520A7)
1334#define GPIO_PORT168CR IOMEM(0xE60520A8)
1335#define SRCR4 IOMEM(0xe61580bc)
1336#define USCCR1 IOMEM(0xE6058144)
1337static void __init mackerel_init(void)
1338{
1339 struct pm_domain_device domain_devices[] = {
1340 { "A4LC", &lcdc_device, },
1341 { "A4LC", &hdmi_lcdc_device, },
1342 { "A4LC", &meram_device, },
1343 { "A4MP", &fsi_device, },
1344 { "A3SP", &usbhs0_device, },
1345 { "A3SP", &usbhs1_device, },
1346 { "A3SP", &nand_flash_device, },
1347 { "A3SP", &sh_mmcif_device, },
1348 { "A3SP", &sdhi0_device, },
1349#if !defined(CONFIG_MMC_SH_MMCIF) && !defined(CONFIG_MMC_SH_MMCIF_MODULE)
1350 { "A3SP", &sdhi1_device, },
1351#endif
1352 { "A3SP", &sdhi2_device, },
1353 { "A4R", &ceu_device, },
1354 };
1355 u32 srcr4;
1356 struct clk *clk;
1357
1358 regulator_register_always_on(0, "fixed-1.8V", fixed1v8_power_consumers,
1359 ARRAY_SIZE(fixed1v8_power_consumers), 1800000);
1360 regulator_register_always_on(1, "fixed-3.3V", fixed3v3_power_consumers,
1361 ARRAY_SIZE(fixed3v3_power_consumers), 3300000);
1362 regulator_register_fixed(2, dummy_supplies, ARRAY_SIZE(dummy_supplies));
1363
1364
1365 clk_set_rate(&sh7372_dv_clki_clk, 27000000);
1366
1367 sh7372_pinmux_init();
1368
1369
1370 gpio_request(GPIO_FN_SCIFA0_TXD, NULL);
1371 gpio_request(GPIO_FN_SCIFA0_RXD, NULL);
1372
1373
1374 gpio_request(GPIO_FN_CS5A, NULL);
1375 gpio_request(GPIO_FN_IRQ6_39, NULL);
1376
1377
1378 gpio_request(GPIO_FN_LCDD23, NULL);
1379 gpio_request(GPIO_FN_LCDD22, NULL);
1380 gpio_request(GPIO_FN_LCDD21, NULL);
1381 gpio_request(GPIO_FN_LCDD20, NULL);
1382 gpio_request(GPIO_FN_LCDD19, NULL);
1383 gpio_request(GPIO_FN_LCDD18, NULL);
1384 gpio_request(GPIO_FN_LCDD17, NULL);
1385 gpio_request(GPIO_FN_LCDD16, NULL);
1386 gpio_request(GPIO_FN_LCDD15, NULL);
1387 gpio_request(GPIO_FN_LCDD14, NULL);
1388 gpio_request(GPIO_FN_LCDD13, NULL);
1389 gpio_request(GPIO_FN_LCDD12, NULL);
1390 gpio_request(GPIO_FN_LCDD11, NULL);
1391 gpio_request(GPIO_FN_LCDD10, NULL);
1392 gpio_request(GPIO_FN_LCDD9, NULL);
1393 gpio_request(GPIO_FN_LCDD8, NULL);
1394 gpio_request(GPIO_FN_LCDD7, NULL);
1395 gpio_request(GPIO_FN_LCDD6, NULL);
1396 gpio_request(GPIO_FN_LCDD5, NULL);
1397 gpio_request(GPIO_FN_LCDD4, NULL);
1398 gpio_request(GPIO_FN_LCDD3, NULL);
1399 gpio_request(GPIO_FN_LCDD2, NULL);
1400 gpio_request(GPIO_FN_LCDD1, NULL);
1401 gpio_request(GPIO_FN_LCDD0, NULL);
1402 gpio_request(GPIO_FN_LCDDISP, NULL);
1403 gpio_request(GPIO_FN_LCDDCK, NULL);
1404
1405
1406 gpio_request_one(GPIO_PORT31, GPIOF_OUT_INIT_LOW, NULL);
1407
1408 gpio_request_one(GPIO_PORT151, GPIOF_OUT_INIT_HIGH, NULL);
1409
1410
1411 gpio_request(GPIO_FN_VBUS0_0, NULL);
1412 gpio_request_pulldown(GPIO_PORT168CR);
1413
1414
1415 gpio_request(GPIO_FN_VBUS0_1, NULL);
1416 gpio_request_pulldown(GPIO_PORT167CR);
1417 gpio_request(GPIO_FN_IDIN_1_113, NULL);
1418
1419
1420 gpio_request(GPIO_FN_FSIAIBT, NULL);
1421 gpio_request(GPIO_FN_FSIAILR, NULL);
1422 gpio_request(GPIO_FN_FSIAISLD, NULL);
1423 gpio_request(GPIO_FN_FSIAOSLD, NULL);
1424 gpio_request_one(GPIO_PORT161, GPIOF_OUT_INIT_LOW, NULL);
1425
1426 gpio_request(GPIO_PORT9, NULL);
1427 gpio_request(GPIO_PORT10, NULL);
1428 gpio_direction_none(GPIO_PORT9CR);
1429 gpio_direction_none(GPIO_PORT10CR);
1430
1431 intc_set_priority(IRQ_FSI, 3);
1432
1433
1434 gpio_request(GPIO_FN_FSIBCK, NULL);
1435 __raw_writew(__raw_readw(USCCR1) & ~(1 << 6), USCCR1);
1436
1437
1438 clk = clk_get(NULL, "spu_clk");
1439 if (!IS_ERR(clk)) {
1440 clk_set_rate(clk, clk_round_rate(clk, 119600000));
1441 clk_put(clk);
1442 }
1443
1444
1445 gpio_request(GPIO_FN_IRQ9_42, NULL);
1446 irq_set_irq_type(IRQ9, IRQ_TYPE_LEVEL_HIGH);
1447
1448
1449 gpio_request(GPIO_FN_IRQ7_40, NULL);
1450 irq_set_irq_type(IRQ7, IRQ_TYPE_LEVEL_LOW);
1451
1452
1453 gpio_request(GPIO_FN_IRQ21, NULL);
1454 irq_set_irq_type(IRQ21, IRQ_TYPE_LEVEL_HIGH);
1455
1456
1457 gpio_request(GPIO_FN_SDHIWP0, NULL);
1458 gpio_request(GPIO_FN_SDHICMD0, NULL);
1459 gpio_request(GPIO_FN_SDHICLK0, NULL);
1460 gpio_request(GPIO_FN_SDHID0_3, NULL);
1461 gpio_request(GPIO_FN_SDHID0_2, NULL);
1462 gpio_request(GPIO_FN_SDHID0_1, NULL);
1463 gpio_request(GPIO_FN_SDHID0_0, NULL);
1464
1465
1466 gpio_request(GPIO_FN_IRQ26_172, NULL);
1467
1468#if !defined(CONFIG_MMC_SH_MMCIF) && !defined(CONFIG_MMC_SH_MMCIF_MODULE)
1469
1470 gpio_request(GPIO_FN_SDHICMD1, NULL);
1471 gpio_request(GPIO_FN_SDHICLK1, NULL);
1472 gpio_request(GPIO_FN_SDHID1_3, NULL);
1473 gpio_request(GPIO_FN_SDHID1_2, NULL);
1474 gpio_request(GPIO_FN_SDHID1_1, NULL);
1475 gpio_request(GPIO_FN_SDHID1_0, NULL);
1476#endif
1477
1478 gpio_request_one(GPIO_PORT41, GPIOF_IN, NULL);
1479
1480
1481 gpio_request(GPIO_FN_SDHICMD2, NULL);
1482 gpio_request(GPIO_FN_SDHICLK2, NULL);
1483 gpio_request(GPIO_FN_SDHID2_3, NULL);
1484 gpio_request(GPIO_FN_SDHID2_2, NULL);
1485 gpio_request(GPIO_FN_SDHID2_1, NULL);
1486 gpio_request(GPIO_FN_SDHID2_0, NULL);
1487
1488
1489 gpio_request_one(GPIO_PORT162, GPIOF_IN, NULL);
1490
1491
1492 gpio_request(GPIO_FN_MMCD0_0, NULL);
1493 gpio_request(GPIO_FN_MMCD0_1, NULL);
1494 gpio_request(GPIO_FN_MMCD0_2, NULL);
1495 gpio_request(GPIO_FN_MMCD0_3, NULL);
1496 gpio_request(GPIO_FN_MMCD0_4, NULL);
1497 gpio_request(GPIO_FN_MMCD0_5, NULL);
1498 gpio_request(GPIO_FN_MMCD0_6, NULL);
1499 gpio_request(GPIO_FN_MMCD0_7, NULL);
1500 gpio_request(GPIO_FN_MMCCMD0, NULL);
1501 gpio_request(GPIO_FN_MMCCLK0, NULL);
1502
1503
1504 gpio_request(GPIO_FN_D0_NAF0, NULL);
1505 gpio_request(GPIO_FN_D1_NAF1, NULL);
1506 gpio_request(GPIO_FN_D2_NAF2, NULL);
1507 gpio_request(GPIO_FN_D3_NAF3, NULL);
1508 gpio_request(GPIO_FN_D4_NAF4, NULL);
1509 gpio_request(GPIO_FN_D5_NAF5, NULL);
1510 gpio_request(GPIO_FN_D6_NAF6, NULL);
1511 gpio_request(GPIO_FN_D7_NAF7, NULL);
1512 gpio_request(GPIO_FN_D8_NAF8, NULL);
1513 gpio_request(GPIO_FN_D9_NAF9, NULL);
1514 gpio_request(GPIO_FN_D10_NAF10, NULL);
1515 gpio_request(GPIO_FN_D11_NAF11, NULL);
1516 gpio_request(GPIO_FN_D12_NAF12, NULL);
1517 gpio_request(GPIO_FN_D13_NAF13, NULL);
1518 gpio_request(GPIO_FN_D14_NAF14, NULL);
1519 gpio_request(GPIO_FN_D15_NAF15, NULL);
1520 gpio_request(GPIO_FN_FCE0, NULL);
1521 gpio_request(GPIO_FN_WE0_FWE, NULL);
1522 gpio_request(GPIO_FN_FRB, NULL);
1523 gpio_request(GPIO_FN_A4_FOE, NULL);
1524 gpio_request(GPIO_FN_A5_FCDE, NULL);
1525 gpio_request(GPIO_FN_RD_FSC, NULL);
1526
1527
1528 gpio_request(GPIO_FN_SCIFA2_TXD1, NULL);
1529 gpio_request(GPIO_FN_SCIFA2_RXD1, NULL);
1530
1531
1532 gpio_request(GPIO_FN_VIO_CLK, NULL);
1533 gpio_request(GPIO_FN_VIO_VD, NULL);
1534 gpio_request(GPIO_FN_VIO_HD, NULL);
1535 gpio_request(GPIO_FN_VIO_FIELD, NULL);
1536 gpio_request(GPIO_FN_VIO_CKO, NULL);
1537 gpio_request(GPIO_FN_VIO_D7, NULL);
1538 gpio_request(GPIO_FN_VIO_D6, NULL);
1539 gpio_request(GPIO_FN_VIO_D5, NULL);
1540 gpio_request(GPIO_FN_VIO_D4, NULL);
1541 gpio_request(GPIO_FN_VIO_D3, NULL);
1542 gpio_request(GPIO_FN_VIO_D2, NULL);
1543 gpio_request(GPIO_FN_VIO_D1, NULL);
1544 gpio_request(GPIO_FN_VIO_D0, NULL);
1545
1546
1547 gpio_request(GPIO_FN_HDMI_HPD, NULL);
1548 gpio_request(GPIO_FN_HDMI_CEC, NULL);
1549
1550
1551 srcr4 = __raw_readl(SRCR4);
1552 __raw_writel(srcr4 | (1 << 13), SRCR4);
1553 udelay(50);
1554 __raw_writel(srcr4 & ~(1 << 13), SRCR4);
1555
1556 i2c_register_board_info(0, i2c0_devices,
1557 ARRAY_SIZE(i2c0_devices));
1558 i2c_register_board_info(1, i2c1_devices,
1559 ARRAY_SIZE(i2c1_devices));
1560
1561 sh7372_add_standard_devices();
1562
1563 platform_add_devices(mackerel_devices, ARRAY_SIZE(mackerel_devices));
1564
1565 rmobile_add_devices_to_domains(domain_devices,
1566 ARRAY_SIZE(domain_devices));
1567
1568 hdmi_init_pm_clock();
1569 sh7372_pm_init();
1570 pm_clk_add(&fsi_device.dev, "spu2");
1571 pm_clk_add(&hdmi_lcdc_device.dev, "hdmi");
1572}
1573
1574static const char *mackerel_boards_compat_dt[] __initdata = {
1575 "renesas,mackerel",
1576 NULL,
1577};
1578
1579DT_MACHINE_START(MACKEREL_DT, "mackerel")
1580 .map_io = sh7372_map_io,
1581 .init_early = sh7372_add_early_devices,
1582 .init_irq = sh7372_init_irq,
1583 .handle_irq = shmobile_handle_irq_intc,
1584 .init_machine = mackerel_init,
1585 .init_late = sh7372_pm_init_late,
1586 .init_time = sh7372_earlytimer_init,
1587 .dt_compat = mackerel_boards_compat_dt,
1588MACHINE_END
1589
