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