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