arch/arm/mach-shmobile/board-armadillo800eva.c

   1 /*
   2  * armadillo 800 eva board support
   3  *
   4  * Copyright (C) 2012 Renesas Solutions Corp.
   5  * Copyright (C) 2012 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; version 2 of the License.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 #include <linux/clk.h>
  18 #include <linux/delay.h>
  19 #include <linux/err.h>
  20 #include <linux/gpio.h>
  21 #include <linux/gpio_keys.h>
  22 #include <linux/i2c-gpio.h>
  23 #include <linux/input.h>
  24 #include <linux/irq.h>
  25 #include <linux/kernel.h>
  26 #include <linux/mfd/tmio.h>
  27 #include <linux/mmc/host.h>
  28 #include <linux/mmc/sh_mmcif.h>
  29 #include <linux/mmc/sh_mobile_sdhi.h>
  30 #include <linux/pinctrl/machine.h>
  31 #include <linux/platform_data/st1232_pdata.h>
  32 #include <linux/platform_device.h>
  33 #include <linux/pwm.h>
  34 #include <linux/pwm_backlight.h>
  35 #include <linux/reboot.h>
  36 #include <linux/regulator/driver.h>
  37 #include <linux/regulator/fixed.h>
  38 #include <linux/regulator/gpio-regulator.h>
  39 #include <linux/regulator/machine.h>
  40 #include <linux/sh_eth.h>
  41 #include <linux/usb/renesas_usbhs.h>
  42 #include <linux/videodev2.h>
  43
  44 #include <asm/hardware/cache-l2x0.h>
  45 #include <asm/mach-types.h>
  46 #include <asm/mach/arch.h>
  47 #include <asm/mach/map.h>
  48 #include <asm/mach/time.h>
  49 #include <asm/page.h>
  50 #include <media/mt9t112.h>
  51 #include <media/sh_mobile_ceu.h>
  52 #include <media/soc_camera.h>
  53 #include <sound/sh_fsi.h>
  54 #include <sound/simple_card.h>
  55 #include <video/sh_mobile_hdmi.h>
  56 #include <video/sh_mobile_lcdc.h>
  57
  58 #include "common.h"
  59 #include "irqs.h"
  60 #include "pm-rmobile.h"
  61 #include "r8a7740.h"
  62 #include "sh-gpio.h"
  63
  64 /*
  65  * CON1         Camera Module
  66  * CON2         Extension Bus
  67  * CON3         HDMI Output
  68  * CON4         Composite Video Output
  69  * CON5         H-UDI JTAG
  70  * CON6         ARM JTAG
  71  * CON7         SD1
  72  * CON8         SD2
  73  * CON9         RTC BackUp
  74  * CON10        Monaural Mic Input
  75  * CON11        Stereo Headphone Output
  76  * CON12        Audio Line Output(L)
  77  * CON13        Audio Line Output(R)
  78  * CON14        AWL13 Module
  79  * CON15        Extension
  80  * CON16        LCD1
  81  * CON17        LCD2
  82  * CON19        Power Input
  83  * CON20        USB1
  84  * CON21        USB2
  85  * CON22        Serial
  86  * CON23        LAN
  87  * CON24        USB3
  88  * LED1         Camera LED(Yellow)
  89  * LED2         Power LED (Green)
  90  * ED3-LED6     User LED(Yellow)
  91  * LED7         LAN link LED(Green)
  92  * LED8         LAN activity LED(Yellow)
  93  */
  94
  95 /*
  96  * DipSwitch
  97  *
  98  *                    SW1
  99  *
 100  * -12345678-+---------------+----------------------------
 101  *  1        | boot          | hermit
 102  *  0        | boot          | OS auto boot
 103  * -12345678-+---------------+----------------------------
 104  *   00      | boot device   | eMMC
 105  *   10      | boot device   | SDHI0 (CON7)
 106  *   01      | boot device   | -
 107  *   11      | boot device   | Extension Buss (CS0)
 108  * -12345678-+---------------+----------------------------
 109  *     0     | Extension Bus | D8-D15 disable, eMMC enable
 110  *     1     | Extension Bus | D8-D15 enable,  eMMC disable
 111  * -12345678-+---------------+----------------------------
 112  *      0    | SDHI1         | COM8 disable, COM14 enable
 113  *      1    | SDHI1         | COM8 enable,  COM14 disable
 114  * -12345678-+---------------+----------------------------
 115  *       0   | USB0          | COM20 enable,  COM24 disable
 116  *       1   | USB0          | COM20 disable, COM24 enable
 117  * -12345678-+---------------+----------------------------
 118  *        00 | JTAG          | SH-X2
 119  *        10 | JTAG          | ARM
 120  *        01 | JTAG          | -
 121  *        11 | JTAG          | Boundary Scan
 122  *-----------+---------------+----------------------------
 123  */
 124
 125 /*
 126  * FSI-WM8978
 127  *
 128  * this command is required when playback.
 129  *
 130  * # amixer set "Headphone" 50
 131  *
 132  * this command is required when capture.
 133  *
 134  * # amixer set "Input PGA" 15
 135  * # amixer set "Left Input Mixer MicP" on
 136  * # amixer set "Left Input Mixer MicN" on
 137  * # amixer set "Right Input Mixer MicN" on
 138  * # amixer set "Right Input Mixer MicP" on
 139  */
 140
 141 /*
 142  * USB function
 143  *
 144  * When you use USB Function,
 145  * set SW1.6 ON, and connect cable to CN24.
 146  *
 147  * USBF needs workaround on R8A7740 chip.
 148  * These are a little bit complex.
 149  * see
 150  *      usbhsf_power_ctrl()
 151  */
 152 #define IRQ7            irq_pin(7)
 153 #define USBCR1          IOMEM(0xe605810a)
 154 #define USBH            0xC6700000
 155 #define USBH_USBCTR     0x10834
 156
 157 struct usbhsf_private {
 158         struct clk *phy;
 159         struct clk *usb24;
 160         struct clk *pci;
 161         struct clk *func;
 162         struct clk *host;
 163         void __iomem *usbh_base;
 164         struct renesas_usbhs_platform_info info;
 165 };
 166
 167 #define usbhsf_get_priv(pdev)                           \
 168         container_of(renesas_usbhs_get_info(pdev),      \
 169                      struct usbhsf_private, info)
 170
 171 static int usbhsf_get_id(struct platform_device *pdev)
 172 {
 173         return USBHS_GADGET;
 174 }
 175
 176 static int usbhsf_power_ctrl(struct platform_device *pdev,
 177                               void __iomem *base, int enable)
 178 {
 179         struct usbhsf_private *priv = usbhsf_get_priv(pdev);
 180
 181         /*
 182          * Work around for USB Function.
 183          * It needs USB host clock, and settings
 184          */
 185         if (enable) {
 186                 /*
 187                  * enable all the related usb clocks
 188                  * for usb workaround
 189                  */
 190                 clk_enable(priv->usb24);
 191                 clk_enable(priv->pci);
 192                 clk_enable(priv->host);
 193                 clk_enable(priv->func);
 194                 clk_enable(priv->phy);
 195
 196                 /*
 197                  * set USBCR1
 198                  *
 199                  * Port1 is driven by USB function,
 200                  * Port2 is driven by USB HOST
 201                  * One HOST (Port1 or Port2 is HOST)
 202                  * USB PLL input clock = 24MHz
 203                  */
 204                 __raw_writew(0xd750, USBCR1);
 205                 mdelay(1);
 206
 207                 /*
 208                  * start USB Host
 209                  */
 210                 __raw_writel(0x0000000c, priv->usbh_base + USBH_USBCTR);
 211                 __raw_writel(0x00000008, priv->usbh_base + USBH_USBCTR);
 212                 mdelay(10);
 213
 214                 /*
 215                  * USB PHY Power ON
 216                  */
 217                 __raw_writew(0xd770, USBCR1);
 218                 __raw_writew(0x4000, base + 0x102); /* USBF :: SUSPMODE */
 219
 220         } else {
 221                 __raw_writel(0x0000010f, priv->usbh_base + USBH_USBCTR);
 222                 __raw_writew(0xd7c0, USBCR1); /* GPIO */
 223
 224                 clk_disable(priv->phy);
 225                 clk_disable(priv->func);        /* usb work around */
 226                 clk_disable(priv->host);        /* usb work around */
 227                 clk_disable(priv->pci);         /* usb work around */
 228                 clk_disable(priv->usb24);       /* usb work around */
 229         }
 230
 231         return 0;
 232 }
 233
 234 static int usbhsf_get_vbus(struct platform_device *pdev)
 235 {
 236         return gpio_get_value(209);
 237 }
 238
 239 static irqreturn_t usbhsf_interrupt(int irq, void *data)
 240 {
 241         struct platform_device *pdev = data;
 242
 243         renesas_usbhs_call_notify_hotplug(pdev);
 244
 245         return IRQ_HANDLED;
 246 }
 247
 248 static int usbhsf_hardware_exit(struct platform_device *pdev)
 249 {
 250         struct usbhsf_private *priv = usbhsf_get_priv(pdev);
 251
 252         if (!IS_ERR(priv->phy))
 253                 clk_put(priv->phy);
 254         if (!IS_ERR(priv->usb24))
 255                 clk_put(priv->usb24);
 256         if (!IS_ERR(priv->pci))
 257                 clk_put(priv->pci);
 258         if (!IS_ERR(priv->host))
 259                 clk_put(priv->host);
 260         if (!IS_ERR(priv->func))
 261                 clk_put(priv->func);
 262         if (priv->usbh_base)
 263                 iounmap(priv->usbh_base);
 264
 265         priv->phy       = NULL;
 266         priv->usb24     = NULL;
 267         priv->pci       = NULL;
 268         priv->host      = NULL;
 269         priv->func      = NULL;
 270         priv->usbh_base = NULL;
 271
 272         free_irq(IRQ7, pdev);
 273
 274         return 0;
 275 }
 276
 277 static int usbhsf_hardware_init(struct platform_device *pdev)
 278 {
 279         struct usbhsf_private *priv = usbhsf_get_priv(pdev);
 280         int ret;
 281
 282         priv->phy       = clk_get(&pdev->dev, "phy");
 283         priv->usb24     = clk_get(&pdev->dev, "usb24");
 284         priv->pci       = clk_get(&pdev->dev, "pci");
 285         priv->func      = clk_get(&pdev->dev, "func");
 286         priv->host      = clk_get(&pdev->dev, "host");
 287         priv->usbh_base = ioremap_nocache(USBH, 0x20000);
 288
 289         if (IS_ERR(priv->phy)           ||
 290             IS_ERR(priv->usb24)         ||
 291             IS_ERR(priv->pci)           ||
 292             IS_ERR(priv->host)          ||
 293             IS_ERR(priv->func)          ||
 294             !priv->usbh_base) {
 295                 dev_err(&pdev->dev, "USB clock setting failed\n");
 296                 usbhsf_hardware_exit(pdev);
 297                 return -EIO;
 298         }
 299
 300         ret = request_irq(IRQ7, usbhsf_interrupt, IRQF_TRIGGER_NONE,
 301                           dev_name(&pdev->dev), pdev);
 302         if (ret) {
 303                 dev_err(&pdev->dev, "request_irq err\n");
 304                 return ret;
 305         }
 306         irq_set_irq_type(IRQ7, IRQ_TYPE_EDGE_BOTH);
 307
 308         /* usb24 use 1/1 of parent clock (= usb24s = 24MHz) */
 309         clk_set_rate(priv->usb24,
 310                      clk_get_rate(clk_get_parent(priv->usb24)));
 311
 312         return 0;
 313 }
 314
 315 static struct usbhsf_private usbhsf_private = {
 316         .info = {
 317                 .platform_callback = {
 318                         .get_id         = usbhsf_get_id,
 319                         .get_vbus       = usbhsf_get_vbus,
 320                         .hardware_init  = usbhsf_hardware_init,
 321                         .hardware_exit  = usbhsf_hardware_exit,
 322                         .power_ctrl     = usbhsf_power_ctrl,
 323                 },
 324                 .driver_param = {
 325                         .buswait_bwait          = 5,
 326                         .detection_delay        = 5,
 327                         .d0_rx_id       = SHDMA_SLAVE_USBHS_RX,
 328                         .d1_tx_id       = SHDMA_SLAVE_USBHS_TX,
 329                 },
 330         }
 331 };
 332
 333 static struct resource usbhsf_resources[] = {
 334         {
 335                 .name   = "USBHS",
 336                 .start  = 0xe6890000,
 337                 .end    = 0xe6890104 - 1,
 338                 .flags  = IORESOURCE_MEM,
 339         },
 340         {
 341                 .start  = gic_spi(51),
 342                 .flags  = IORESOURCE_IRQ,
 343         },
 344 };
 345
 346 static struct platform_device usbhsf_device = {
 347         .name   = "renesas_usbhs",
 348         .dev = {
 349                 .platform_data = &usbhsf_private.info,
 350         },
 351         .id = -1,
 352         .num_resources  = ARRAY_SIZE(usbhsf_resources),
 353         .resource       = usbhsf_resources,
 354 };
 355
 356 /* Ether */
 357 static struct sh_eth_plat_data sh_eth_platdata = {
 358         .phy                    = 0x00, /* LAN8710A */
 359         .edmac_endian           = EDMAC_LITTLE_ENDIAN,
 360         .phy_interface          = PHY_INTERFACE_MODE_MII,
 361 };
 362
 363 static struct resource sh_eth_resources[] = {
 364         {
 365                 .start  = 0xe9a00000,
 366                 .end    = 0xe9a00800 - 1,
 367                 .flags  = IORESOURCE_MEM,
 368         }, {
 369                 .start  = 0xe9a01800,
 370                 .end    = 0xe9a02000 - 1,
 371                 .flags  = IORESOURCE_MEM,
 372         }, {
 373                 .start  = gic_spi(110),
 374                 .flags  = IORESOURCE_IRQ,
 375         },
 376 };
 377
 378 static struct platform_device sh_eth_device = {
 379         .name = "r8a7740-gether",
 380         .id = -1,
 381         .dev = {
 382                 .platform_data = &sh_eth_platdata,
 383                 .dma_mask = &sh_eth_device.dev.coherent_dma_mask,
 384                 .coherent_dma_mask = DMA_BIT_MASK(32),
 385         },
 386         .resource = sh_eth_resources,
 387         .num_resources = ARRAY_SIZE(sh_eth_resources),
 388 };
 389
 390 /* PWM */
 391 static struct resource pwm_resources[] = {
 392         [0] = {
 393                 .start = 0xe6600000,
 394                 .end = 0xe66000ff,
 395                 .flags = IORESOURCE_MEM,
 396         },
 397 };
 398
 399 static struct platform_device pwm_device = {
 400         .name = "renesas-tpu-pwm",
 401         .id = -1,
 402         .num_resources = ARRAY_SIZE(pwm_resources),
 403         .resource = pwm_resources,
 404 };
 405
 406 static struct pwm_lookup pwm_lookup[] = {
 407         PWM_LOOKUP("renesas-tpu-pwm", 2, "pwm-backlight.0", NULL,
 408                    33333, PWM_POLARITY_INVERSED),
 409 };
 410
 411 /* LCDC and backlight */
 412 static struct platform_pwm_backlight_data pwm_backlight_data = {
 413         .lth_brightness = 50,
 414         .max_brightness = 255,
 415         .dft_brightness = 255,
 416         .pwm_period_ns = 33333, /* 30kHz */
 417         .enable_gpio = 61,
 418 };
 419
 420 static struct platform_device pwm_backlight_device = {
 421         .name = "pwm-backlight",
 422         .dev = {
 423                 .platform_data = &pwm_backlight_data,
 424         },
 425 };
 426
 427 static struct fb_videomode lcdc0_mode = {
 428         .name           = "AMPIER/AM-800480",
 429         .xres           = 800,
 430         .yres           = 480,
 431         .left_margin    = 88,
 432         .right_margin   = 40,
 433         .hsync_len      = 128,
 434         .upper_margin   = 20,
 435         .lower_margin   = 5,
 436         .vsync_len      = 5,
 437         .sync           = 0,
 438 };
 439
 440 static struct sh_mobile_lcdc_info lcdc0_info = {
 441         .clock_source   = LCDC_CLK_BUS,
 442         .ch[0] = {
 443                 .chan           = LCDC_CHAN_MAINLCD,
 444                 .fourcc         = V4L2_PIX_FMT_RGB565,
 445                 .interface_type = RGB24,
 446                 .clock_divider  = 5,
 447                 .flags          = 0,
 448                 .lcd_modes      = &lcdc0_mode,
 449                 .num_modes      = 1,
 450                 .panel_cfg = {
 451                         .width  = 111,
 452                         .height = 68,
 453                 },
 454         },
 455 };
 456
 457 static struct resource lcdc0_resources[] = {
 458         [0] = {
 459                 .name   = "LCD0",
 460                 .start  = 0xfe940000,
 461                 .end    = 0xfe943fff,
 462                 .flags  = IORESOURCE_MEM,
 463         },
 464         [1] = {
 465                 .start  = gic_spi(177),
 466                 .flags  = IORESOURCE_IRQ,
 467         },
 468 };
 469
 470 static struct platform_device lcdc0_device = {
 471         .name           = "sh_mobile_lcdc_fb",
 472         .num_resources  = ARRAY_SIZE(lcdc0_resources),
 473         .resource       = lcdc0_resources,
 474         .id             = 0,
 475         .dev    = {
 476                 .platform_data  = &lcdc0_info,
 477                 .coherent_dma_mask = DMA_BIT_MASK(32),
 478         },
 479 };
 480
 481 /*
 482  * LCDC1/HDMI
 483  */
 484 static struct sh_mobile_hdmi_info hdmi_info = {
 485         .flags          = HDMI_OUTPUT_PUSH_PULL |
 486                           HDMI_OUTPUT_POLARITY_HI |
 487                           HDMI_32BIT_REG |
 488                           HDMI_HAS_HTOP1 |
 489                           HDMI_SND_SRC_SPDIF,
 490 };
 491
 492 static struct resource hdmi_resources[] = {
 493         [0] = {
 494                 .name   = "HDMI",
 495                 .start  = 0xe6be0000,
 496                 .end    = 0xe6be03ff,
 497                 .flags  = IORESOURCE_MEM,
 498         },
 499         [1] = {
 500                 .start  = gic_spi(131),
 501                 .flags  = IORESOURCE_IRQ,
 502         },
 503         [2] = {
 504                 .name   = "HDMI emma3pf",
 505                 .start  = 0xe6be4000,
 506                 .end    = 0xe6be43ff,
 507                 .flags  = IORESOURCE_MEM,
 508         },
 509 };
 510
 511 static struct platform_device hdmi_device = {
 512         .name           = "sh-mobile-hdmi",
 513         .num_resources  = ARRAY_SIZE(hdmi_resources),
 514         .resource       = hdmi_resources,
 515         .id             = -1,
 516         .dev    = {
 517                 .platform_data  = &hdmi_info,
 518         },
 519 };
 520
 521 static const struct fb_videomode lcdc1_mode = {
 522         .name           = "HDMI 720p",
 523         .xres           = 1280,
 524         .yres           = 720,
 525         .pixclock       = 13468,
 526         .left_margin    = 220,
 527         .right_margin   = 110,
 528         .hsync_len      = 40,
 529         .upper_margin   = 20,
 530         .lower_margin   = 5,
 531         .vsync_len      = 5,
 532         .refresh        = 60,
 533         .sync           = FB_SYNC_VERT_HIGH_ACT | FB_SYNC_HOR_HIGH_ACT,
 534 };
 535
 536 static struct sh_mobile_lcdc_info hdmi_lcdc_info = {
 537         .clock_source   = LCDC_CLK_PERIPHERAL, /* HDMI clock */
 538         .ch[0] = {
 539                 .chan                   = LCDC_CHAN_MAINLCD,
 540                 .fourcc                 = V4L2_PIX_FMT_RGB565,
 541                 .interface_type         = RGB24,
 542                 .clock_divider          = 1,
 543                 .flags                  = LCDC_FLAGS_DWPOL,
 544                 .lcd_modes              = &lcdc1_mode,
 545                 .num_modes              = 1,
 546                 .tx_dev                 = &hdmi_device,
 547                 .panel_cfg = {
 548                         .width  = 1280,
 549                         .height = 720,
 550                 },
 551         },
 552 };
 553
 554 static struct resource hdmi_lcdc_resources[] = {
 555         [0] = {
 556                 .name   = "LCDC1",
 557                 .start  = 0xfe944000,
 558                 .end    = 0xfe948000 - 1,
 559                 .flags  = IORESOURCE_MEM,
 560         },
 561         [1] = {
 562                 .start  = gic_spi(178),
 563                 .flags  = IORESOURCE_IRQ,
 564         },
 565 };
 566
 567 static struct platform_device hdmi_lcdc_device = {
 568         .name           = "sh_mobile_lcdc_fb",
 569         .num_resources  = ARRAY_SIZE(hdmi_lcdc_resources),
 570         .resource       = hdmi_lcdc_resources,
 571         .id             = 1,
 572         .dev    = {
 573                 .platform_data  = &hdmi_lcdc_info,
 574                 .coherent_dma_mask = DMA_BIT_MASK(32),
 575         },
 576 };
 577
 578 /* LEDS */
 579 static struct gpio_led gpio_leds[] = {
 580         {
 581                 .name           = "LED3",
 582                 .gpio           = 102,
 583                 .default_state  = LEDS_GPIO_DEFSTATE_ON,
 584         }, {
 585                 .name           = "LED4",
 586                 .gpio           = 111,
 587                 .default_state  = LEDS_GPIO_DEFSTATE_ON,
 588         }, {
 589                 .name           = "LED5",
 590                 .gpio           = 110,
 591                 .default_state  = LEDS_GPIO_DEFSTATE_ON,
 592         }, {
 593                 .name           = "LED6",
 594                 .gpio           = 177,
 595                 .default_state  = LEDS_GPIO_DEFSTATE_ON,
 596         },
 597 };
 598
 599 static struct gpio_led_platform_data leds_gpio_info = {
 600         .leds           = gpio_leds,
 601         .num_leds       = ARRAY_SIZE(gpio_leds),
 602 };
 603
 604 static struct platform_device leds_gpio_device = {
 605         .name   = "leds-gpio",
 606         .id     = -1,
 607         .dev    = {
 608                 .platform_data  = &leds_gpio_info,
 609         },
 610 };
 611
 612 /* GPIO KEY */
 613 #define GPIO_KEY(c, g, d, ...) \
 614         { .code = c, .gpio = g, .desc = d, .active_low = 1, __VA_ARGS__ }
 615
 616 static struct gpio_keys_button gpio_buttons[] = {
 617         GPIO_KEY(KEY_POWER,     99,     "SW3", .wakeup = 1),
 618         GPIO_KEY(KEY_BACK,      100,    "SW4"),
 619         GPIO_KEY(KEY_MENU,      97,     "SW5"),
 620         GPIO_KEY(KEY_HOME,      98,     "SW6"),
 621 };
 622
 623 static struct gpio_keys_platform_data gpio_key_info = {
 624         .buttons        = gpio_buttons,
 625         .nbuttons       = ARRAY_SIZE(gpio_buttons),
 626 };
 627
 628 static struct platform_device gpio_keys_device = {
 629         .name   = "gpio-keys",
 630         .id     = -1,
 631         .dev    = {
 632                 .platform_data  = &gpio_key_info,
 633         },
 634 };
 635
 636 /* Fixed 3.3V regulator to be used by SDHI1, MMCIF */
 637 static struct regulator_consumer_supply fixed3v3_power_consumers[] = {
 638         REGULATOR_SUPPLY("vmmc", "sh_mmcif"),
 639         REGULATOR_SUPPLY("vqmmc", "sh_mmcif"),
 640 };
 641
 642 /* Fixed 3.3V regulator used by LCD backlight */
 643 static struct regulator_consumer_supply fixed5v0_power_consumers[] = {
 644         REGULATOR_SUPPLY("power", "pwm-backlight.0"),
 645 };
 646
 647 /* Fixed 3.3V regulator to be used by SDHI0 */
 648 static struct regulator_consumer_supply vcc_sdhi0_consumers[] = {
 649         REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.0"),
 650 };
 651
 652 static struct regulator_init_data vcc_sdhi0_init_data = {
 653         .constraints = {
 654                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
 655         },
 656         .num_consumer_supplies  = ARRAY_SIZE(vcc_sdhi0_consumers),
 657         .consumer_supplies      = vcc_sdhi0_consumers,
 658 };
 659
 660 static struct fixed_voltage_config vcc_sdhi0_info = {
 661         .supply_name = "SDHI0 Vcc",
 662         .microvolts = 3300000,
 663         .gpio = 75,
 664         .enable_high = 1,
 665         .init_data = &vcc_sdhi0_init_data,
 666 };
 667
 668 static struct platform_device vcc_sdhi0 = {
 669         .name = "reg-fixed-voltage",
 670         .id   = 1,
 671         .dev  = {
 672                 .platform_data = &vcc_sdhi0_info,
 673         },
 674 };
 675
 676 /* 1.8 / 3.3V SDHI0 VccQ regulator */
 677 static struct regulator_consumer_supply vccq_sdhi0_consumers[] = {
 678         REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.0"),
 679 };
 680
 681 static struct regulator_init_data vccq_sdhi0_init_data = {
 682         .constraints = {
 683                 .input_uV       = 3300000,
 684                 .min_uV         = 1800000,
 685                 .max_uV         = 3300000,
 686                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE |
 687                                   REGULATOR_CHANGE_STATUS,
 688         },
 689         .num_consumer_supplies  = ARRAY_SIZE(vccq_sdhi0_consumers),
 690         .consumer_supplies      = vccq_sdhi0_consumers,
 691 };
 692
 693 static struct gpio vccq_sdhi0_gpios[] = {
 694         {17, GPIOF_OUT_INIT_LOW, "vccq-sdhi0" },
 695 };
 696
 697 static struct gpio_regulator_state vccq_sdhi0_states[] = {
 698         { .value = 3300000, .gpios = (0 << 0) },
 699         { .value = 1800000, .gpios = (1 << 0) },
 700 };
 701
 702 static struct gpio_regulator_config vccq_sdhi0_info = {
 703         .supply_name = "vqmmc",
 704
 705         .enable_gpio = 74,
 706         .enable_high = 1,
 707         .enabled_at_boot = 0,
 708
 709         .gpios = vccq_sdhi0_gpios,
 710         .nr_gpios = ARRAY_SIZE(vccq_sdhi0_gpios),
 711
 712         .states = vccq_sdhi0_states,
 713         .nr_states = ARRAY_SIZE(vccq_sdhi0_states),
 714
 715         .type = REGULATOR_VOLTAGE,
 716         .init_data = &vccq_sdhi0_init_data,
 717 };
 718
 719 static struct platform_device vccq_sdhi0 = {
 720         .name = "gpio-regulator",
 721         .id   = -1,
 722         .dev  = {
 723                 .platform_data = &vccq_sdhi0_info,
 724         },
 725 };
 726
 727 /* Fixed 3.3V regulator to be used by SDHI1 */
 728 static struct regulator_consumer_supply vcc_sdhi1_consumers[] = {
 729         REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.1"),
 730 };
 731
 732 static struct regulator_init_data vcc_sdhi1_init_data = {
 733         .constraints = {
 734                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
 735         },
 736         .num_consumer_supplies  = ARRAY_SIZE(vcc_sdhi1_consumers),
 737         .consumer_supplies      = vcc_sdhi1_consumers,
 738 };
 739
 740 static struct fixed_voltage_config vcc_sdhi1_info = {
 741         .supply_name = "SDHI1 Vcc",
 742         .microvolts = 3300000,
 743         .gpio = 16,
 744         .enable_high = 1,
 745         .init_data = &vcc_sdhi1_init_data,
 746 };
 747
 748 static struct platform_device vcc_sdhi1 = {
 749         .name = "reg-fixed-voltage",
 750         .id   = 2,
 751         .dev  = {
 752                 .platform_data = &vcc_sdhi1_info,
 753         },
 754 };
 755
 756 /* SDHI0 */
 757 static struct tmio_mmc_data sdhi0_info = {
 758         .chan_priv_tx   = (void *)SHDMA_SLAVE_SDHI0_TX,
 759         .chan_priv_rx   = (void *)SHDMA_SLAVE_SDHI0_RX,
 760         .capabilities   = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ |
 761                           MMC_CAP_POWER_OFF_CARD,
 762         .flags          = TMIO_MMC_HAS_IDLE_WAIT | TMIO_MMC_USE_GPIO_CD,
 763         .cd_gpio        = 167,
 764 };
 765
 766 static struct resource sdhi0_resources[] = {
 767         {
 768                 .name   = "SDHI0",
 769                 .start  = 0xe6850000,
 770                 .end    = 0xe6850100 - 1,
 771                 .flags  = IORESOURCE_MEM,
 772         },
 773         /*
 774          * no SH_MOBILE_SDHI_IRQ_CARD_DETECT here
 775          */
 776         {
 777                 .name   = SH_MOBILE_SDHI_IRQ_SDCARD,
 778                 .start  = gic_spi(118),
 779                 .flags  = IORESOURCE_IRQ,
 780         },
 781         {
 782                 .name   = SH_MOBILE_SDHI_IRQ_SDIO,
 783                 .start  = gic_spi(119),
 784                 .flags  = IORESOURCE_IRQ,
 785         },
 786 };
 787
 788 static struct platform_device sdhi0_device = {
 789         .name           = "sh_mobile_sdhi",
 790         .id             = 0,
 791         .dev            = {
 792                 .platform_data  = &sdhi0_info,
 793         },
 794         .num_resources  = ARRAY_SIZE(sdhi0_resources),
 795         .resource       = sdhi0_resources,
 796 };
 797
 798 /* SDHI1 */
 799 static struct tmio_mmc_data sdhi1_info = {
 800         .chan_priv_tx   = (void *)SHDMA_SLAVE_SDHI1_TX,
 801         .chan_priv_rx   = (void *)SHDMA_SLAVE_SDHI1_RX,
 802         .capabilities   = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ |
 803                           MMC_CAP_POWER_OFF_CARD,
 804         .flags          = TMIO_MMC_HAS_IDLE_WAIT | TMIO_MMC_USE_GPIO_CD,
 805         /* Port72 cannot generate IRQs, will be used in polling mode. */
 806         .cd_gpio        = 72,
 807 };
 808
 809 static struct resource sdhi1_resources[] = {
 810         [0] = {
 811                 .name   = "SDHI1",
 812                 .start  = 0xe6860000,
 813                 .end    = 0xe6860100 - 1,
 814                 .flags  = IORESOURCE_MEM,
 815         },
 816         [1] = {
 817                 .start  = gic_spi(121),
 818                 .flags  = IORESOURCE_IRQ,
 819         },
 820         [2] = {
 821                 .start  = gic_spi(122),
 822                 .flags  = IORESOURCE_IRQ,
 823         },
 824         [3] = {
 825                 .start  = gic_spi(123),
 826                 .flags  = IORESOURCE_IRQ,
 827         },
 828 };
 829
 830 static struct platform_device sdhi1_device = {
 831         .name           = "sh_mobile_sdhi",
 832         .id             = 1,
 833         .dev            = {
 834                 .platform_data  = &sdhi1_info,
 835         },
 836         .num_resources  = ARRAY_SIZE(sdhi1_resources),
 837         .resource       = sdhi1_resources,
 838 };
 839
 840 static const struct pinctrl_map eva_sdhi1_pinctrl_map[] = {
 841         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.1", "pfc-r8a7740",
 842                                   "sdhi1_data4", "sdhi1"),
 843         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.1", "pfc-r8a7740",
 844                                   "sdhi1_ctrl", "sdhi1"),
 845         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.1", "pfc-r8a7740",
 846                                   "sdhi1_cd", "sdhi1"),
 847         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.1", "pfc-r8a7740",
 848                                   "sdhi1_wp", "sdhi1"),
 849 };
 850
 851 /* MMCIF */
 852 static struct sh_mmcif_plat_data sh_mmcif_plat = {
 853         .sup_pclk       = 0,
 854         .caps           = MMC_CAP_4_BIT_DATA |
 855                           MMC_CAP_8_BIT_DATA |
 856                           MMC_CAP_NONREMOVABLE,
 857         .ccs_unsupported = true,
 858         .slave_id_tx    = SHDMA_SLAVE_MMCIF_TX,
 859         .slave_id_rx    = SHDMA_SLAVE_MMCIF_RX,
 860 };
 861
 862 static struct resource sh_mmcif_resources[] = {
 863         [0] = {
 864                 .name   = "MMCIF",
 865                 .start  = 0xe6bd0000,
 866                 .end    = 0xe6bd0100 - 1,
 867                 .flags  = IORESOURCE_MEM,
 868         },
 869         [1] = {
 870                 /* MMC ERR */
 871                 .start  = gic_spi(56),
 872                 .flags  = IORESOURCE_IRQ,
 873         },
 874         [2] = {
 875                 /* MMC NOR */
 876                 .start  = gic_spi(57),
 877                 .flags  = IORESOURCE_IRQ,
 878         },
 879 };
 880
 881 static struct platform_device sh_mmcif_device = {
 882         .name           = "sh_mmcif",
 883         .id             = -1,
 884         .dev            = {
 885                 .platform_data  = &sh_mmcif_plat,
 886         },
 887         .num_resources  = ARRAY_SIZE(sh_mmcif_resources),
 888         .resource       = sh_mmcif_resources,
 889 };
 890
 891 /* Camera */
 892 static int mt9t111_power(struct device *dev, int mode)
 893 {
 894         struct clk *mclk = clk_get(NULL, "video1");
 895
 896         if (IS_ERR(mclk)) {
 897                 dev_err(dev, "can't get video1 clock\n");
 898                 return -EINVAL;
 899         }
 900
 901         if (mode) {
 902                 /* video1 (= CON1 camera) expect 24MHz */
 903                 clk_set_rate(mclk, clk_round_rate(mclk, 24000000));
 904                 clk_enable(mclk);
 905                 gpio_set_value(158, 1);
 906         } else {
 907                 gpio_set_value(158, 0);
 908                 clk_disable(mclk);
 909         }
 910
 911         clk_put(mclk);
 912
 913         return 0;
 914 }
 915
 916 static struct i2c_board_info i2c_camera_mt9t111 = {
 917         I2C_BOARD_INFO("mt9t112", 0x3d),
 918 };
 919
 920 static struct mt9t112_camera_info mt9t111_info = {
 921         .divider = { 16, 0, 0, 7, 0, 10, 14, 7, 7 },
 922 };
 923
 924 static struct soc_camera_link mt9t111_link = {
 925         .i2c_adapter_id = 0,
 926         .bus_id         = 0,
 927         .board_info     = &i2c_camera_mt9t111,
 928         .power          = mt9t111_power,
 929         .priv           = &mt9t111_info,
 930 };
 931
 932 static struct platform_device camera_device = {
 933         .name   = "soc-camera-pdrv",
 934         .id     = 0,
 935         .dev    = {
 936                 .platform_data = &mt9t111_link,
 937         },
 938 };
 939
 940 /* CEU0 */
 941 static struct sh_mobile_ceu_info sh_mobile_ceu0_info = {
 942         .flags = SH_CEU_FLAG_LOWER_8BIT,
 943 };
 944
 945 static struct resource ceu0_resources[] = {
 946         [0] = {
 947                 .name   = "CEU",
 948                 .start  = 0xfe910000,
 949                 .end    = 0xfe91009f,
 950                 .flags  = IORESOURCE_MEM,
 951         },
 952         [1] = {
 953                 .start  = gic_spi(160),
 954                 .flags  = IORESOURCE_IRQ,
 955         },
 956         [2] = {
 957                 /* place holder for contiguous memory */
 958         },
 959 };
 960
 961 static struct platform_device ceu0_device = {
 962         .name           = "sh_mobile_ceu",
 963         .id             = 0,
 964         .num_resources  = ARRAY_SIZE(ceu0_resources),
 965         .resource       = ceu0_resources,
 966         .dev    = {
 967                 .platform_data          = &sh_mobile_ceu0_info,
 968                 .coherent_dma_mask      = 0xffffffff,
 969         },
 970 };
 971
 972 /* FSI */
 973 static struct sh_fsi_platform_info fsi_info = {
 974         /* FSI-WM8978 */
 975         .port_a = {
 976                 .tx_id = SHDMA_SLAVE_FSIA_TX,
 977         },
 978         /* FSI-HDMI */
 979         .port_b = {
 980                 .flags          = SH_FSI_FMT_SPDIF |
 981                                   SH_FSI_ENABLE_STREAM_MODE |
 982                                   SH_FSI_CLK_CPG,
 983                 .tx_id          = SHDMA_SLAVE_FSIB_TX,
 984         }
 985 };
 986
 987 static struct resource fsi_resources[] = {
 988         [0] = {
 989                 .name   = "FSI",
 990                 .start  = 0xfe1f0000,
 991                 .end    = 0xfe1f0400 - 1,
 992                 .flags  = IORESOURCE_MEM,
 993         },
 994         [1] = {
 995                 .start  = gic_spi(9),
 996                 .flags  = IORESOURCE_IRQ,
 997         },
 998 };
 999
1000 static struct platform_device fsi_device = {
1001         .name           = "sh_fsi2",
1002         .id             = -1,
1003         .num_resources  = ARRAY_SIZE(fsi_resources),
1004         .resource       = fsi_resources,
1005         .dev    = {
1006                 .platform_data  = &fsi_info,
1007         },
1008 };
1009
1010 /* FSI-WM8978 */
1011 static struct asoc_simple_card_info fsi_wm8978_info = {
1012         .name           = "wm8978",
1013         .card           = "FSI2A-WM8978",
1014         .codec          = "wm8978.0-001a",
1015         .platform       = "sh_fsi2",
1016         .daifmt         = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBM_CFM,
1017         .cpu_dai = {
1018                 .name   = "fsia-dai",
1019         },
1020         .codec_dai = {
1021                 .name   = "wm8978-hifi",
1022                 .sysclk = 12288000,
1023         },
1024 };
1025
1026 static struct platform_device fsi_wm8978_device = {
1027         .name   = "asoc-simple-card",
1028         .id     = 0,
1029         .dev    = {
1030                 .platform_data  = &fsi_wm8978_info,
1031                 .coherent_dma_mask = DMA_BIT_MASK(32),
1032                 .dma_mask = &fsi_wm8978_device.dev.coherent_dma_mask,
1033         },
1034 };
1035
1036 /* FSI-HDMI */
1037 static struct asoc_simple_card_info fsi2_hdmi_info = {
1038         .name           = "HDMI",
1039         .card           = "FSI2B-HDMI",
1040         .codec          = "sh-mobile-hdmi",
1041         .platform       = "sh_fsi2",
1042         .daifmt         = SND_SOC_DAIFMT_CBS_CFS,
1043         .cpu_dai = {
1044                 .name   = "fsib-dai",
1045         },
1046         .codec_dai = {
1047                 .name = "sh_mobile_hdmi-hifi",
1048         },
1049 };
1050
1051 static struct platform_device fsi_hdmi_device = {
1052         .name   = "asoc-simple-card",
1053         .id     = 1,
1054         .dev    = {
1055                 .platform_data  = &fsi2_hdmi_info,
1056                 .coherent_dma_mask = DMA_BIT_MASK(32),
1057                 .dma_mask = &fsi_hdmi_device.dev.coherent_dma_mask,
1058         },
1059 };
1060
1061 /* RTC: RTC connects i2c-gpio. */
1062 static struct i2c_gpio_platform_data i2c_gpio_data = {
1063         .sda_pin        = 208,
1064         .scl_pin        = 91,
1065         .udelay         = 5, /* 100 kHz */
1066 };
1067
1068 static struct platform_device i2c_gpio_device = {
1069         .name = "i2c-gpio",
1070         .id = 2,
1071         .dev = {
1072                 .platform_data = &i2c_gpio_data,
1073         },
1074 };
1075
1076 /* I2C */
1077 static struct st1232_pdata st1232_i2c0_pdata = {
1078         .reset_gpio = 166,
1079 };
1080
1081 static struct i2c_board_info i2c0_devices[] = {
1082         {
1083                 I2C_BOARD_INFO("st1232-ts", 0x55),
1084                 .irq = irq_pin(10),
1085                 .platform_data = &st1232_i2c0_pdata,
1086         },
1087         {
1088                 I2C_BOARD_INFO("wm8978", 0x1a),
1089         },
1090 };
1091
1092 static struct i2c_board_info i2c2_devices[] = {
1093         {
1094                 I2C_BOARD_INFO("s35390a", 0x30),
1095                 .type = "s35390a",
1096         },
1097 };
1098
1099 /*
1100  * board devices
1101  */
1102 static struct platform_device *eva_devices[] __initdata = {
1103         &lcdc0_device,
1104         &pwm_device,
1105         &pwm_backlight_device,
1106         &leds_gpio_device,
1107         &gpio_keys_device,
1108         &sh_eth_device,
1109         &vcc_sdhi0,
1110         &vccq_sdhi0,
1111         &sdhi0_device,
1112         &sh_mmcif_device,
1113         &hdmi_device,
1114         &hdmi_lcdc_device,
1115         &camera_device,
1116         &ceu0_device,
1117         &fsi_device,
1118         &fsi_wm8978_device,
1119         &fsi_hdmi_device,
1120         &i2c_gpio_device,
1121 };
1122
1123 static const struct pinctrl_map eva_pinctrl_map[] = {
1124         /* CEU0 */
1125         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_ceu.0", "pfc-r8a7740",
1126                                   "ceu0_data_0_7", "ceu0"),
1127         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_ceu.0", "pfc-r8a7740",
1128                                   "ceu0_clk_0", "ceu0"),
1129         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_ceu.0", "pfc-r8a7740",
1130                                   "ceu0_sync", "ceu0"),
1131         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_ceu.0", "pfc-r8a7740",
1132                                   "ceu0_field", "ceu0"),
1133         /* FSIA */
1134         PIN_MAP_MUX_GROUP_DEFAULT("asoc-simple-card.0", "pfc-r8a7740",
1135                                   "fsia_sclk_in", "fsia"),
1136         PIN_MAP_MUX_GROUP_DEFAULT("asoc-simple-card.0", "pfc-r8a7740",
1137                                   "fsia_mclk_out", "fsia"),
1138         PIN_MAP_MUX_GROUP_DEFAULT("asoc-simple-card.0", "pfc-r8a7740",
1139                                   "fsia_data_in_1", "fsia"),
1140         PIN_MAP_MUX_GROUP_DEFAULT("asoc-simple-card.0", "pfc-r8a7740",
1141                                   "fsia_data_out_0", "fsia"),
1142         /* FSIB */
1143         PIN_MAP_MUX_GROUP_DEFAULT("asoc-simple-card.1", "pfc-r8a7740",
1144                                   "fsib_mclk_in", "fsib"),
1145         /* GETHER */
1146         PIN_MAP_MUX_GROUP_DEFAULT("r8a7740-gether", "pfc-r8a7740",
1147                                   "gether_mii", "gether"),
1148         PIN_MAP_MUX_GROUP_DEFAULT("r8a7740-gether", "pfc-r8a7740",
1149                                   "gether_int", "gether"),
1150         /* HDMI */
1151         PIN_MAP_MUX_GROUP_DEFAULT("sh-mobile-hdmi", "pfc-r8a7740",
1152                                   "hdmi", "hdmi"),
1153         /* LCD0 */
1154         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_lcdc_fb.0", "pfc-r8a7740",
1155                                   "lcd0_data24_0", "lcd0"),
1156         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_lcdc_fb.0", "pfc-r8a7740",
1157                                   "lcd0_lclk_1", "lcd0"),
1158         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_lcdc_fb.0", "pfc-r8a7740",
1159                                   "lcd0_sync", "lcd0"),
1160         /* MMCIF */
1161         PIN_MAP_MUX_GROUP_DEFAULT("sh_mmcif.0", "pfc-r8a7740",
1162                                   "mmc0_data8_1", "mmc0"),
1163         PIN_MAP_MUX_GROUP_DEFAULT("sh_mmcif.0", "pfc-r8a7740",
1164                                   "mmc0_ctrl_1", "mmc0"),
1165         /* SCIFA1 */
1166         PIN_MAP_MUX_GROUP_DEFAULT("sh-sci.1", "pfc-r8a7740",
1167                                   "scifa1_data", "scifa1"),
1168         /* SDHI0 */
1169         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-r8a7740",
1170                                   "sdhi0_data4", "sdhi0"),
1171         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-r8a7740",
1172                                   "sdhi0_ctrl", "sdhi0"),
1173         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-r8a7740",
1174                                   "sdhi0_wp", "sdhi0"),
1175         /* ST1232 */
1176         PIN_MAP_MUX_GROUP_DEFAULT("0-0055", "pfc-r8a7740",
1177                                   "intc_irq10", "intc"),
1178         /* TPU0 */
1179         PIN_MAP_MUX_GROUP_DEFAULT("renesas-tpu-pwm", "pfc-r8a7740",
1180                                   "tpu0_to2_1", "tpu0"),
1181         /* USBHS */
1182         PIN_MAP_MUX_GROUP_DEFAULT("renesas_usbhs", "pfc-r8a7740",
1183                                   "intc_irq7_1", "intc"),
1184 };
1185
1186 static void __init eva_clock_init(void)
1187 {
1188         struct clk *system      = clk_get(NULL, "system_clk");
1189         struct clk *xtal1       = clk_get(NULL, "extal1");
1190         struct clk *usb24s      = clk_get(NULL, "usb24s");
1191         struct clk *fsibck      = clk_get(NULL, "fsibck");
1192
1193         if (IS_ERR(system)      ||
1194             IS_ERR(xtal1)       ||
1195             IS_ERR(usb24s)      ||
1196             IS_ERR(fsibck)) {
1197                 pr_err("armadillo800eva board clock init failed\n");
1198                 goto clock_error;
1199         }
1200
1201         /* armadillo 800 eva extal1 is 24MHz */
1202         clk_set_rate(xtal1, 24000000);
1203
1204         /* usb24s use extal1 (= system) clock (= 24MHz) */
1205         clk_set_parent(usb24s, system);
1206
1207         /* FSIBCK is 12.288MHz, and it is parent of FSI-B */
1208         clk_set_rate(fsibck, 12288000);
1209
1210 clock_error:
1211         if (!IS_ERR(system))
1212                 clk_put(system);
1213         if (!IS_ERR(xtal1))
1214                 clk_put(xtal1);
1215         if (!IS_ERR(usb24s))
1216                 clk_put(usb24s);
1217         if (!IS_ERR(fsibck))
1218                 clk_put(fsibck);
1219 }
1220
1221 /*
1222  * board init
1223  */
1224 #define GPIO_PORT7CR    IOMEM(0xe6050007)
1225 #define GPIO_PORT8CR    IOMEM(0xe6050008)
1226 static void __init eva_init(void)
1227 {
1228         static struct pm_domain_device domain_devices[] __initdata = {
1229                 { "A4LC", &lcdc0_device },
1230                 { "A4LC", &hdmi_lcdc_device },
1231                 { "A4MP", &hdmi_device },
1232                 { "A4MP", &fsi_device },
1233                 { "A4R",  &ceu0_device },
1234                 { "A4S",  &sh_eth_device },
1235                 { "A3SP", &pwm_device },
1236                 { "A3SP", &sdhi0_device },
1237                 { "A3SP", &sh_mmcif_device },
1238         };
1239         struct platform_device *usb = NULL, *sdhi1 = NULL;
1240
1241         regulator_register_always_on(0, "fixed-3.3V", fixed3v3_power_consumers,
1242                                      ARRAY_SIZE(fixed3v3_power_consumers), 3300000);
1243         regulator_register_always_on(3, "fixed-5.0V", fixed5v0_power_consumers,
1244                                      ARRAY_SIZE(fixed5v0_power_consumers), 5000000);
1245
1246         pinctrl_register_mappings(eva_pinctrl_map, ARRAY_SIZE(eva_pinctrl_map));
1247         pwm_add_table(pwm_lookup, ARRAY_SIZE(pwm_lookup));
1248
1249         r8a7740_pinmux_init();
1250         r8a7740_meram_workaround();
1251
1252         /* GETHER */
1253         gpio_request_one(18, GPIOF_OUT_INIT_HIGH, NULL); /* PHY_RST */
1254
1255         /* USB */
1256         gpio_request_one(159, GPIOF_IN, NULL); /* USB_DEVICE_MODE */
1257
1258         if (gpio_get_value(159)) {
1259                 /* USB Host */
1260         } else {
1261                 /* USB Func */
1262                 /*
1263                  * The USBHS interrupt handlers needs to read the IRQ pin value
1264                  * (HI/LOW) to diffentiate USB connection and disconnection
1265                  * events (usbhsf_get_vbus()). We thus need to select both the
1266                  * intc_irq7_1 pin group and GPIO 209 here.
1267                  */
1268                 gpio_request_one(209, GPIOF_IN, NULL);
1269
1270                 platform_device_register(&usbhsf_device);
1271                 usb = &usbhsf_device;
1272         }
1273
1274         /* CON1/CON15 Camera */
1275         gpio_request_one(173, GPIOF_OUT_INIT_LOW, NULL);  /* STANDBY */
1276         gpio_request_one(172, GPIOF_OUT_INIT_HIGH, NULL); /* RST */
1277         /* see mt9t111_power() */
1278         gpio_request_one(158, GPIOF_OUT_INIT_LOW, NULL);  /* CAM_PON */
1279
1280         /* FSI-WM8978 */
1281         gpio_request(7, NULL);
1282         gpio_request(8, NULL);
1283         gpio_direction_none(GPIO_PORT7CR); /* FSIAOBT needs no direction */
1284         gpio_direction_none(GPIO_PORT8CR); /* FSIAOLR needs no direction */
1285
1286         /*
1287          * CAUTION
1288          *
1289          * DBGMD/LCDC0/FSIA MUX
1290          * DBGMD_SELECT_B should be set after setting PFC Function.
1291          */
1292         gpio_request_one(176, GPIOF_OUT_INIT_HIGH, NULL);
1293
1294         /*
1295          * We can switch CON8/CON14 by SW1.5,
1296          * but it needs after DBGMD_SELECT_B
1297          */
1298         gpio_request_one(6, GPIOF_IN, NULL);
1299         if (gpio_get_value(6)) {
1300                 /* CON14 enable */
1301         } else {
1302                 /* CON8 (SDHI1) enable */
1303                 pinctrl_register_mappings(eva_sdhi1_pinctrl_map,
1304                                           ARRAY_SIZE(eva_sdhi1_pinctrl_map));
1305
1306                 platform_device_register(&vcc_sdhi1);
1307                 platform_device_register(&sdhi1_device);
1308                 sdhi1 = &sdhi1_device;
1309         }
1310
1311
1312 #ifdef CONFIG_CACHE_L2X0
1313         /* Shared attribute override enable, 32K*8way */
1314         l2x0_init(IOMEM(0xf0002000), 0x00400000, 0xc20f0fff);
1315 #endif
1316
1317         i2c_register_board_info(0, i2c0_devices, ARRAY_SIZE(i2c0_devices));
1318         i2c_register_board_info(2, i2c2_devices, ARRAY_SIZE(i2c2_devices));
1319
1320         r8a7740_add_standard_devices();
1321
1322         platform_add_devices(eva_devices,
1323                              ARRAY_SIZE(eva_devices));
1324
1325         rmobile_add_devices_to_domains(domain_devices,
1326                                        ARRAY_SIZE(domain_devices));
1327         if (usb)
1328                 rmobile_add_device_to_domain("A3SP", usb);
1329         if (sdhi1)
1330                 rmobile_add_device_to_domain("A3SP", sdhi1);
1331
1332         r8a7740_pm_init();
1333 }
1334
1335 static void __init eva_earlytimer_init(void)
1336 {
1337         r8a7740_clock_init(MD_CK0 | MD_CK2);
1338         shmobile_earlytimer_init();
1339
1340         /* the rate of extal1 clock must be set before late_time_init */
1341         eva_clock_init();
1342 }
1343
1344 #define RESCNT2 IOMEM(0xe6188020)
1345 static void eva_restart(enum reboot_mode mode, const char *cmd)
1346 {
1347         /* Do soft power on reset */
1348         writel((1 << 31), RESCNT2);
1349 }
1350
1351 static const char *eva_boards_compat_dt[] __initdata = {
1352         "renesas,armadillo800eva",
1353         NULL,
1354 };
1355
1356 DT_MACHINE_START(ARMADILLO800EVA_DT, "armadillo800eva")
1357         .map_io         = r8a7740_map_io,
1358         .init_early     = r8a7740_add_early_devices,
1359         .init_irq       = r8a7740_init_irq_of,
1360         .init_machine   = eva_init,
1361         .init_late      = shmobile_init_late,
1362         .init_time      = eva_earlytimer_init,
1363         .dt_compat      = eva_boards_compat_dt,
1364         .restart        = eva_restart,
1365 MACHINE_END