~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/arm/mach-shmobile/board-kzm9g.c

Version: ~ [ linux-5.9-rc6 ] ~ [ linux-5.8.10 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.66 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.146 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.198 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.236 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.236 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * KZM-A9-GT board support
  3  *
  4  * Copyright (C) 2012   Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License as published by
  8  * the Free Software Foundation; version 2 of the License.
  9  *
 10  * This program is distributed in the hope that it will be useful,
 11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13  * GNU General Public License for more details.
 14  *
 15  * You should have received a copy of the GNU General Public License
 16  * along with this program; if not, write to the Free Software
 17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 18  */
 19 
 20 #include <linux/delay.h>
 21 #include <linux/gpio.h>
 22 #include <linux/gpio_keys.h>
 23 #include <linux/io.h>
 24 #include <linux/irq.h>
 25 #include <linux/i2c.h>
 26 #include <linux/i2c/pcf857x.h>
 27 #include <linux/input.h>
 28 #include <linux/irqchip/arm-gic.h>
 29 #include <linux/mmc/host.h>
 30 #include <linux/mmc/sh_mmcif.h>
 31 #include <linux/mmc/sh_mobile_sdhi.h>
 32 #include <linux/mfd/as3711.h>
 33 #include <linux/mfd/tmio.h>
 34 #include <linux/pinctrl/machine.h>
 35 #include <linux/pinctrl/pinconf-generic.h>
 36 #include <linux/platform_device.h>
 37 #include <linux/reboot.h>
 38 #include <linux/regulator/fixed.h>
 39 #include <linux/regulator/machine.h>
 40 #include <linux/smsc911x.h>
 41 #include <linux/usb/r8a66597.h>
 42 #include <linux/usb/renesas_usbhs.h>
 43 #include <linux/videodev2.h>
 44 #include <sound/sh_fsi.h>
 45 #include <sound/simple_card.h>
 46 #include <mach/irqs.h>
 47 #include <mach/sh73a0.h>
 48 #include <mach/common.h>
 49 #include <asm/hardware/cache-l2x0.h>
 50 #include <asm/mach-types.h>
 51 #include <asm/mach/arch.h>
 52 #include <video/sh_mobile_lcdc.h>
 53 
 54 /*
 55  * external GPIO
 56  */
 57 #define GPIO_PCF8575_BASE       (310)
 58 #define GPIO_PCF8575_PORT10     (GPIO_PCF8575_BASE + 8)
 59 #define GPIO_PCF8575_PORT11     (GPIO_PCF8575_BASE + 9)
 60 #define GPIO_PCF8575_PORT12     (GPIO_PCF8575_BASE + 10)
 61 #define GPIO_PCF8575_PORT13     (GPIO_PCF8575_BASE + 11)
 62 #define GPIO_PCF8575_PORT14     (GPIO_PCF8575_BASE + 12)
 63 #define GPIO_PCF8575_PORT15     (GPIO_PCF8575_BASE + 13)
 64 #define GPIO_PCF8575_PORT16     (GPIO_PCF8575_BASE + 14)
 65 
 66 /* Dummy supplies, where voltage doesn't matter */
 67 static struct regulator_consumer_supply dummy_supplies[] = {
 68         REGULATOR_SUPPLY("vddvario", "smsc911x.0"),
 69         REGULATOR_SUPPLY("vdd33a", "smsc911x.0"),
 70 };
 71 
 72 /*
 73  * FSI-AK4648
 74  *
 75  * this command is required when playback.
 76  *
 77  * # amixer set "LINEOUT Mixer DACL" on
 78  */
 79 
 80 /* SMSC 9221 */
 81 static struct resource smsc9221_resources[] = {
 82         [0] = {
 83                 .start  = 0x10000000, /* CS4 */
 84                 .end    = 0x100000ff,
 85                 .flags  = IORESOURCE_MEM,
 86         },
 87         [1] = {
 88                 .start  = irq_pin(3), /* IRQ3 */
 89                 .flags  = IORESOURCE_IRQ,
 90         },
 91 };
 92 
 93 static struct smsc911x_platform_config smsc9221_platdata = {
 94         .flags          = SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS,
 95         .phy_interface  = PHY_INTERFACE_MODE_MII,
 96         .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
 97         .irq_type       = SMSC911X_IRQ_TYPE_PUSH_PULL,
 98 };
 99 
100 static struct platform_device smsc_device = {
101         .name           = "smsc911x",
102         .dev  = {
103                 .platform_data = &smsc9221_platdata,
104         },
105         .resource       = smsc9221_resources,
106         .num_resources  = ARRAY_SIZE(smsc9221_resources),
107 };
108 
109 /* USB external chip */
110 static struct r8a66597_platdata usb_host_data = {
111         .on_chip        = 0,
112         .xtal           = R8A66597_PLATDATA_XTAL_48MHZ,
113 };
114 
115 static struct resource usb_resources[] = {
116         [0] = {
117                 .start  = 0x10010000,
118                 .end    = 0x1001ffff - 1,
119                 .flags  = IORESOURCE_MEM,
120         },
121         [1] = {
122                 .start  = irq_pin(1), /* IRQ1 */
123                 .flags  = IORESOURCE_IRQ,
124         },
125 };
126 
127 static struct platform_device usb_host_device = {
128         .name   = "r8a66597_hcd",
129         .dev = {
130                 .platform_data          = &usb_host_data,
131                 .dma_mask               = NULL,
132                 .coherent_dma_mask      = 0xffffffff,
133         },
134         .num_resources  = ARRAY_SIZE(usb_resources),
135         .resource       = usb_resources,
136 };
137 
138 /* USB Func CN17 */
139 struct usbhs_private {
140         void __iomem *phy;
141         void __iomem *cr2;
142         struct renesas_usbhs_platform_info info;
143 };
144 
145 #define IRQ15                   irq_pin(15)
146 #define USB_PHY_MODE            (1 << 4)
147 #define USB_PHY_INT_EN          ((1 << 3) | (1 << 2))
148 #define USB_PHY_ON              (1 << 1)
149 #define USB_PHY_OFF             (1 << 0)
150 #define USB_PHY_INT_CLR         (USB_PHY_ON | USB_PHY_OFF)
151 
152 #define usbhs_get_priv(pdev) \
153         container_of(renesas_usbhs_get_info(pdev), struct usbhs_private, info)
154 
155 static int usbhs_get_vbus(struct platform_device *pdev)
156 {
157         struct usbhs_private *priv = usbhs_get_priv(pdev);
158 
159         return !((1 << 7) & __raw_readw(priv->cr2));
160 }
161 
162 static int usbhs_phy_reset(struct platform_device *pdev)
163 {
164         struct usbhs_private *priv = usbhs_get_priv(pdev);
165 
166         /* init phy */
167         __raw_writew(0x8a0a, priv->cr2);
168 
169         return 0;
170 }
171 
172 static int usbhs_get_id(struct platform_device *pdev)
173 {
174         return USBHS_GADGET;
175 }
176 
177 static irqreturn_t usbhs_interrupt(int irq, void *data)
178 {
179         struct platform_device *pdev = data;
180         struct usbhs_private *priv = usbhs_get_priv(pdev);
181 
182         renesas_usbhs_call_notify_hotplug(pdev);
183 
184         /* clear status */
185         __raw_writew(__raw_readw(priv->phy) | USB_PHY_INT_CLR, priv->phy);
186 
187         return IRQ_HANDLED;
188 }
189 
190 static int usbhs_hardware_init(struct platform_device *pdev)
191 {
192         struct usbhs_private *priv = usbhs_get_priv(pdev);
193         int ret;
194 
195         /* clear interrupt status */
196         __raw_writew(USB_PHY_MODE | USB_PHY_INT_CLR, priv->phy);
197 
198         ret = request_irq(IRQ15, usbhs_interrupt, IRQF_TRIGGER_HIGH,
199                           dev_name(&pdev->dev), pdev);
200         if (ret) {
201                 dev_err(&pdev->dev, "request_irq err\n");
202                 return ret;
203         }
204 
205         /* enable USB phy interrupt */
206         __raw_writew(USB_PHY_MODE | USB_PHY_INT_EN, priv->phy);
207 
208         return 0;
209 }
210 
211 static int usbhs_hardware_exit(struct platform_device *pdev)
212 {
213         struct usbhs_private *priv = usbhs_get_priv(pdev);
214 
215         /* clear interrupt status */
216         __raw_writew(USB_PHY_MODE | USB_PHY_INT_CLR, priv->phy);
217 
218         free_irq(IRQ15, pdev);
219 
220         return 0;
221 }
222 
223 static u32 usbhs_pipe_cfg[] = {
224         USB_ENDPOINT_XFER_CONTROL,
225         USB_ENDPOINT_XFER_ISOC,
226         USB_ENDPOINT_XFER_ISOC,
227         USB_ENDPOINT_XFER_BULK,
228         USB_ENDPOINT_XFER_BULK,
229         USB_ENDPOINT_XFER_BULK,
230         USB_ENDPOINT_XFER_INT,
231         USB_ENDPOINT_XFER_INT,
232         USB_ENDPOINT_XFER_INT,
233         USB_ENDPOINT_XFER_BULK,
234         USB_ENDPOINT_XFER_BULK,
235         USB_ENDPOINT_XFER_BULK,
236         USB_ENDPOINT_XFER_BULK,
237         USB_ENDPOINT_XFER_BULK,
238         USB_ENDPOINT_XFER_BULK,
239         USB_ENDPOINT_XFER_BULK,
240 };
241 
242 static struct usbhs_private usbhs_private = {
243         .phy    = IOMEM(0xe60781e0),            /* USBPHYINT */
244         .cr2    = IOMEM(0xe605810c),            /* USBCR2 */
245         .info = {
246                 .platform_callback = {
247                         .hardware_init  = usbhs_hardware_init,
248                         .hardware_exit  = usbhs_hardware_exit,
249                         .get_id         = usbhs_get_id,
250                         .phy_reset      = usbhs_phy_reset,
251                         .get_vbus       = usbhs_get_vbus,
252                 },
253                 .driver_param = {
254                         .buswait_bwait  = 4,
255                         .has_otg        = 1,
256                         .pipe_type      = usbhs_pipe_cfg,
257                         .pipe_size      = ARRAY_SIZE(usbhs_pipe_cfg),
258                 },
259         },
260 };
261 
262 static struct resource usbhs_resources[] = {
263         [0] = {
264                 .start  = 0xE6890000,
265                 .end    = 0xE68900e6 - 1,
266                 .flags  = IORESOURCE_MEM,
267         },
268         [1] = {
269                 .start  = gic_spi(62),
270                 .end    = gic_spi(62),
271                 .flags  = IORESOURCE_IRQ,
272         },
273 };
274 
275 static struct platform_device usbhs_device = {
276         .name   = "renesas_usbhs",
277         .id     = -1,
278         .dev = {
279                 .dma_mask               = NULL,
280                 .coherent_dma_mask      = 0xffffffff,
281                 .platform_data          = &usbhs_private.info,
282         },
283         .num_resources  = ARRAY_SIZE(usbhs_resources),
284         .resource       = usbhs_resources,
285 };
286 
287 /* LCDC */
288 static struct fb_videomode kzm_lcdc_mode = {
289         .name           = "WVGA Panel",
290         .xres           = 800,
291         .yres           = 480,
292         .left_margin    = 220,
293         .right_margin   = 110,
294         .hsync_len      = 70,
295         .upper_margin   = 20,
296         .lower_margin   = 5,
297         .vsync_len      = 5,
298         .sync           = 0,
299 };
300 
301 static struct sh_mobile_lcdc_info lcdc_info = {
302         .clock_source = LCDC_CLK_BUS,
303         .ch[0] = {
304                 .chan           = LCDC_CHAN_MAINLCD,
305                 .fourcc         = V4L2_PIX_FMT_RGB565,
306                 .interface_type = RGB24,
307                 .lcd_modes      = &kzm_lcdc_mode,
308                 .num_modes      = 1,
309                 .clock_divider  = 5,
310                 .flags          = 0,
311                 .panel_cfg = {
312                         .width  = 152,
313                         .height = 91,
314                 },
315         }
316 };
317 
318 static struct resource lcdc_resources[] = {
319         [0] = {
320                 .name   = "LCDC",
321                 .start  = 0xfe940000,
322                 .end    = 0xfe943fff,
323                 .flags  = IORESOURCE_MEM,
324         },
325         [1] = {
326                 .start  = intcs_evt2irq(0x580),
327                 .flags  = IORESOURCE_IRQ,
328         },
329 };
330 
331 static struct platform_device lcdc_device = {
332         .name           = "sh_mobile_lcdc_fb",
333         .num_resources  = ARRAY_SIZE(lcdc_resources),
334         .resource       = lcdc_resources,
335         .dev    = {
336                 .platform_data  = &lcdc_info,
337                 .coherent_dma_mask = DMA_BIT_MASK(32),
338         },
339 };
340 
341 /* Fixed 1.8V regulator to be used by MMCIF */
342 static struct regulator_consumer_supply fixed1v8_power_consumers[] =
343 {
344         REGULATOR_SUPPLY("vmmc", "sh_mmcif.0"),
345         REGULATOR_SUPPLY("vqmmc", "sh_mmcif.0"),
346 };
347 
348 /* MMCIF */
349 static struct resource sh_mmcif_resources[] = {
350         [0] = {
351                 .name   = "MMCIF",
352                 .start  = 0xe6bd0000,
353                 .end    = 0xe6bd00ff,
354                 .flags  = IORESOURCE_MEM,
355         },
356         [1] = {
357                 .start  = gic_spi(140),
358                 .flags  = IORESOURCE_IRQ,
359         },
360         [2] = {
361                 .start  = gic_spi(141),
362                 .flags  = IORESOURCE_IRQ,
363         },
364 };
365 
366 static struct sh_mmcif_plat_data sh_mmcif_platdata = {
367         .ocr            = MMC_VDD_165_195,
368         .caps           = MMC_CAP_8_BIT_DATA | MMC_CAP_NONREMOVABLE,
369         .ccs_unsupported = true,
370         .slave_id_tx    = SHDMA_SLAVE_MMCIF_TX,
371         .slave_id_rx    = SHDMA_SLAVE_MMCIF_RX,
372 };
373 
374 static struct platform_device mmc_device = {
375         .name           = "sh_mmcif",
376         .dev            = {
377                 .dma_mask               = NULL,
378                 .coherent_dma_mask      = 0xffffffff,
379                 .platform_data          = &sh_mmcif_platdata,
380         },
381         .num_resources  = ARRAY_SIZE(sh_mmcif_resources),
382         .resource       = sh_mmcif_resources,
383 };
384 
385 /* Fixed 3.3V regulators to be used by SDHI0 */
386 static struct regulator_consumer_supply vcc_sdhi0_consumers[] =
387 {
388         REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.0"),
389 };
390 
391 static struct regulator_init_data vcc_sdhi0_init_data = {
392         .constraints = {
393                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
394         },
395         .num_consumer_supplies  = ARRAY_SIZE(vcc_sdhi0_consumers),
396         .consumer_supplies      = vcc_sdhi0_consumers,
397 };
398 
399 static struct fixed_voltage_config vcc_sdhi0_info = {
400         .supply_name = "SDHI0 Vcc",
401         .microvolts = 3300000,
402         .gpio = 15,
403         .enable_high = 1,
404         .init_data = &vcc_sdhi0_init_data,
405 };
406 
407 static struct platform_device vcc_sdhi0 = {
408         .name = "reg-fixed-voltage",
409         .id   = 0,
410         .dev  = {
411                 .platform_data = &vcc_sdhi0_info,
412         },
413 };
414 
415 /* Fixed 3.3V regulators to be used by SDHI2 */
416 static struct regulator_consumer_supply vcc_sdhi2_consumers[] =
417 {
418         REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.2"),
419 };
420 
421 static struct regulator_init_data vcc_sdhi2_init_data = {
422         .constraints = {
423                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
424         },
425         .num_consumer_supplies  = ARRAY_SIZE(vcc_sdhi2_consumers),
426         .consumer_supplies      = vcc_sdhi2_consumers,
427 };
428 
429 static struct fixed_voltage_config vcc_sdhi2_info = {
430         .supply_name = "SDHI2 Vcc",
431         .microvolts = 3300000,
432         .gpio = 14,
433         .enable_high = 1,
434         .init_data = &vcc_sdhi2_init_data,
435 };
436 
437 static struct platform_device vcc_sdhi2 = {
438         .name = "reg-fixed-voltage",
439         .id   = 1,
440         .dev  = {
441                 .platform_data = &vcc_sdhi2_info,
442         },
443 };
444 
445 /* SDHI */
446 static struct sh_mobile_sdhi_info sdhi0_info = {
447         .dma_slave_tx   = SHDMA_SLAVE_SDHI0_TX,
448         .dma_slave_rx   = SHDMA_SLAVE_SDHI0_RX,
449         .tmio_flags     = TMIO_MMC_HAS_IDLE_WAIT,
450         .tmio_caps      = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ |
451                           MMC_CAP_POWER_OFF_CARD,
452 };
453 
454 static struct resource sdhi0_resources[] = {
455         [0] = {
456                 .name   = "SDHI0",
457                 .start  = 0xee100000,
458                 .end    = 0xee1000ff,
459                 .flags  = IORESOURCE_MEM,
460         },
461         [1] = {
462                 .name   = SH_MOBILE_SDHI_IRQ_CARD_DETECT,
463                 .start  = gic_spi(83),
464                 .flags  = IORESOURCE_IRQ,
465         },
466         [2] = {
467                 .name   = SH_MOBILE_SDHI_IRQ_SDCARD,
468                 .start  = gic_spi(84),
469                 .flags  = IORESOURCE_IRQ,
470         },
471         [3] = {
472                 .name   = SH_MOBILE_SDHI_IRQ_SDIO,
473                 .start  = gic_spi(85),
474                 .flags  = IORESOURCE_IRQ,
475         },
476 };
477 
478 static struct platform_device sdhi0_device = {
479         .name           = "sh_mobile_sdhi",
480         .num_resources  = ARRAY_SIZE(sdhi0_resources),
481         .resource       = sdhi0_resources,
482         .dev    = {
483                 .platform_data  = &sdhi0_info,
484         },
485 };
486 
487 /* Micro SD */
488 static struct sh_mobile_sdhi_info sdhi2_info = {
489         .dma_slave_tx   = SHDMA_SLAVE_SDHI2_TX,
490         .dma_slave_rx   = SHDMA_SLAVE_SDHI2_RX,
491         .tmio_flags     = TMIO_MMC_HAS_IDLE_WAIT |
492                           TMIO_MMC_USE_GPIO_CD |
493                           TMIO_MMC_WRPROTECT_DISABLE,
494         .tmio_caps      = MMC_CAP_SD_HIGHSPEED | MMC_CAP_POWER_OFF_CARD,
495         .cd_gpio        = 13,
496 };
497 
498 static struct resource sdhi2_resources[] = {
499         [0] = {
500                 .name   = "SDHI2",
501                 .start  = 0xee140000,
502                 .end    = 0xee1400ff,
503                 .flags  = IORESOURCE_MEM,
504         },
505         [1] = {
506                 .name   = SH_MOBILE_SDHI_IRQ_CARD_DETECT,
507                 .start  = gic_spi(103),
508                 .flags  = IORESOURCE_IRQ,
509         },
510         [2] = {
511                 .name   = SH_MOBILE_SDHI_IRQ_SDCARD,
512                 .start  = gic_spi(104),
513                 .flags  = IORESOURCE_IRQ,
514         },
515         [3] = {
516                 .name   = SH_MOBILE_SDHI_IRQ_SDIO,
517                 .start  = gic_spi(105),
518                 .flags  = IORESOURCE_IRQ,
519         },
520 };
521 
522 static struct platform_device sdhi2_device = {
523         .name           = "sh_mobile_sdhi",
524         .id             = 2,
525         .num_resources  = ARRAY_SIZE(sdhi2_resources),
526         .resource       = sdhi2_resources,
527         .dev    = {
528                 .platform_data  = &sdhi2_info,
529         },
530 };
531 
532 /* KEY */
533 #define GPIO_KEY(c, g, d) { .code = c, .gpio = g, .desc = d, .active_low = 1 }
534 
535 static struct gpio_keys_button gpio_buttons[] = {
536         GPIO_KEY(KEY_BACK,      GPIO_PCF8575_PORT10,    "SW3"),
537         GPIO_KEY(KEY_RIGHT,     GPIO_PCF8575_PORT11,    "SW2-R"),
538         GPIO_KEY(KEY_LEFT,      GPIO_PCF8575_PORT12,    "SW2-L"),
539         GPIO_KEY(KEY_ENTER,     GPIO_PCF8575_PORT13,    "SW2-P"),
540         GPIO_KEY(KEY_UP,        GPIO_PCF8575_PORT14,    "SW2-U"),
541         GPIO_KEY(KEY_DOWN,      GPIO_PCF8575_PORT15,    "SW2-D"),
542         GPIO_KEY(KEY_HOME,      GPIO_PCF8575_PORT16,    "SW1"),
543 };
544 
545 static struct gpio_keys_platform_data gpio_key_info = {
546         .buttons        = gpio_buttons,
547         .nbuttons       = ARRAY_SIZE(gpio_buttons),
548 };
549 
550 static struct platform_device gpio_keys_device = {
551         .name   = "gpio-keys",
552         .dev    = {
553                 .platform_data  = &gpio_key_info,
554         },
555 };
556 
557 /* FSI-AK4648 */
558 static struct sh_fsi_platform_info fsi_info = {
559         .port_a = {
560                 .tx_id = SHDMA_SLAVE_FSI2A_TX,
561         },
562 };
563 
564 static struct resource fsi_resources[] = {
565         [0] = {
566                 .name   = "FSI",
567                 .start  = 0xEC230000,
568                 .end    = 0xEC230400 - 1,
569                 .flags  = IORESOURCE_MEM,
570         },
571         [1] = {
572                 .start  = gic_spi(146),
573                 .flags  = IORESOURCE_IRQ,
574         },
575 };
576 
577 static struct platform_device fsi_device = {
578         .name           = "sh_fsi2",
579         .id             = -1,
580         .num_resources  = ARRAY_SIZE(fsi_resources),
581         .resource       = fsi_resources,
582         .dev    = {
583                 .platform_data  = &fsi_info,
584         },
585 };
586 
587 static struct asoc_simple_card_info fsi2_ak4648_info = {
588         .name           = "AK4648",
589         .card           = "FSI2A-AK4648",
590         .codec          = "ak4642-codec.0-0012",
591         .platform       = "sh_fsi2",
592         .daifmt         = SND_SOC_DAIFMT_LEFT_J | SND_SOC_DAIFMT_CBM_CFM,
593         .cpu_dai = {
594                 .name   = "fsia-dai",
595         },
596         .codec_dai = {
597                 .name   = "ak4642-hifi",
598                 .sysclk = 11289600,
599         },
600 };
601 
602 static struct platform_device fsi_ak4648_device = {
603         .name   = "asoc-simple-card",
604         .dev    = {
605                 .platform_data  = &fsi2_ak4648_info,
606         },
607 };
608 
609 /* I2C */
610 
611 /* StepDown1 is used to supply 1.315V to the CPU */
612 static struct regulator_init_data as3711_sd1 = {
613         .constraints = {
614                 .name = "1.315V CPU",
615                 .boot_on = 1,
616                 .always_on = 1,
617                 .min_uV = 1315000,
618                 .max_uV = 1335000,
619         },
620 };
621 
622 /* StepDown2 is used to supply 1.8V to the CPU and to the board */
623 static struct regulator_init_data as3711_sd2 = {
624         .constraints = {
625                 .name = "1.8V",
626                 .boot_on = 1,
627                 .always_on = 1,
628                 .min_uV = 1800000,
629                 .max_uV = 1800000,
630         },
631 };
632 
633 /*
634  * StepDown3 is switched in parallel with StepDown2, seems to be off,
635  * according to read-back pre-set register values
636  */
637 
638 /* StepDown4 is used to supply 1.215V to the CPU and to the board */
639 static struct regulator_init_data as3711_sd4 = {
640         .constraints = {
641                 .name = "1.215V",
642                 .boot_on = 1,
643                 .always_on = 1,
644                 .min_uV = 1215000,
645                 .max_uV = 1235000,
646         },
647 };
648 
649 /* LDO1 is unused and unconnected */
650 
651 /* LDO2 is used to supply 2.8V to the CPU */
652 static struct regulator_init_data as3711_ldo2 = {
653         .constraints = {
654                 .name = "2.8V CPU",
655                 .boot_on = 1,
656                 .always_on = 1,
657                 .min_uV = 2800000,
658                 .max_uV = 2800000,
659         },
660 };
661 
662 /* LDO3 is used to supply 3.0V to the CPU */
663 static struct regulator_init_data as3711_ldo3 = {
664         .constraints = {
665                 .name = "3.0V CPU",
666                 .boot_on = 1,
667                 .always_on = 1,
668                 .min_uV = 3000000,
669                 .max_uV = 3000000,
670         },
671 };
672 
673 /* LDO4 is used to supply 2.8V to the board */
674 static struct regulator_init_data as3711_ldo4 = {
675         .constraints = {
676                 .name = "2.8V",
677                 .boot_on = 1,
678                 .always_on = 1,
679                 .min_uV = 2800000,
680                 .max_uV = 2800000,
681         },
682 };
683 
684 /* LDO5 is switched parallel to LDO4, also set to 2.8V */
685 static struct regulator_init_data as3711_ldo5 = {
686         .constraints = {
687                 .name = "2.8V #2",
688                 .boot_on = 1,
689                 .always_on = 1,
690                 .min_uV = 2800000,
691                 .max_uV = 2800000,
692         },
693 };
694 
695 /* LDO6 is unused and unconnected */
696 
697 /* LDO7 is used to supply 1.15V to the CPU */
698 static struct regulator_init_data as3711_ldo7 = {
699         .constraints = {
700                 .name = "1.15V CPU",
701                 .boot_on = 1,
702                 .always_on = 1,
703                 .min_uV = 1150000,
704                 .max_uV = 1150000,
705         },
706 };
707 
708 /* LDO8 is switched parallel to LDO7, also set to 1.15V */
709 static struct regulator_init_data as3711_ldo8 = {
710         .constraints = {
711                 .name = "1.15V CPU #2",
712                 .boot_on = 1,
713                 .always_on = 1,
714                 .min_uV = 1150000,
715                 .max_uV = 1150000,
716         },
717 };
718 
719 static struct as3711_platform_data as3711_pdata = {
720         .regulator      = {
721                 .init_data      = {
722                         [AS3711_REGULATOR_SD_1] = &as3711_sd1,
723                         [AS3711_REGULATOR_SD_2] = &as3711_sd2,
724                         [AS3711_REGULATOR_SD_4] = &as3711_sd4,
725                         [AS3711_REGULATOR_LDO_2] = &as3711_ldo2,
726                         [AS3711_REGULATOR_LDO_3] = &as3711_ldo3,
727                         [AS3711_REGULATOR_LDO_4] = &as3711_ldo4,
728                         [AS3711_REGULATOR_LDO_5] = &as3711_ldo5,
729                         [AS3711_REGULATOR_LDO_7] = &as3711_ldo7,
730                         [AS3711_REGULATOR_LDO_8] = &as3711_ldo8,
731                 },
732         },
733         .backlight      = {
734                 .su2_fb = "sh_mobile_lcdc_fb.0",
735                 .su2_max_uA = 36000,
736                 .su2_feedback = AS3711_SU2_CURR_AUTO,
737                 .su2_fbprot = AS3711_SU2_GPIO4,
738                 .su2_auto_curr1 = true,
739                 .su2_auto_curr2 = true,
740                 .su2_auto_curr3 = true,
741         },
742 };
743 
744 static struct pcf857x_platform_data pcf8575_pdata = {
745         .gpio_base      = GPIO_PCF8575_BASE,
746 };
747 
748 static struct i2c_board_info i2c0_devices[] = {
749         {
750                 I2C_BOARD_INFO("ak4648", 0x12),
751         },
752         {
753                 I2C_BOARD_INFO("r2025sd", 0x32),
754         },
755         {
756                 I2C_BOARD_INFO("ak8975", 0x0c),
757                 .irq = irq_pin(28), /* IRQ28 */
758         },
759         {
760                 I2C_BOARD_INFO("adxl34x", 0x1d),
761                 .irq = irq_pin(26), /* IRQ26 */
762         },
763         {
764                 I2C_BOARD_INFO("as3711", 0x40),
765                 .irq = intcs_evt2irq(0x3300), /* IRQ24 */
766                 .platform_data = &as3711_pdata,
767         },
768 };
769 
770 static struct i2c_board_info i2c1_devices[] = {
771         {
772                 I2C_BOARD_INFO("st1232-ts", 0x55),
773                 .irq = irq_pin(8), /* IRQ8 */
774         },
775 };
776 
777 static struct i2c_board_info i2c3_devices[] = {
778         {
779                 I2C_BOARD_INFO("pcf8575", 0x20),
780                 .irq = irq_pin(19), /* IRQ19 */
781                 .platform_data = &pcf8575_pdata,
782         },
783 };
784 
785 static struct platform_device *kzm_devices[] __initdata = {
786         &smsc_device,
787         &usb_host_device,
788         &usbhs_device,
789         &lcdc_device,
790         &mmc_device,
791         &vcc_sdhi0,
792         &vcc_sdhi2,
793         &sdhi0_device,
794         &sdhi2_device,
795         &gpio_keys_device,
796         &fsi_device,
797         &fsi_ak4648_device,
798 };
799 
800 static unsigned long pin_pullup_conf[] = {
801         PIN_CONF_PACKED(PIN_CONFIG_BIAS_PULL_UP, 0),
802 };
803 
804 static const struct pinctrl_map kzm_pinctrl_map[] = {
805         /* FSIA (AK4648) */
806         PIN_MAP_MUX_GROUP_DEFAULT("sh_fsi2", "pfc-sh73a0",
807                                   "fsia_mclk_in", "fsia"),
808         PIN_MAP_MUX_GROUP_DEFAULT("sh_fsi2", "pfc-sh73a0",
809                                   "fsia_sclk_in", "fsia"),
810         PIN_MAP_MUX_GROUP_DEFAULT("sh_fsi2", "pfc-sh73a0",
811                                   "fsia_data_in", "fsia"),
812         PIN_MAP_MUX_GROUP_DEFAULT("sh_fsi2", "pfc-sh73a0",
813                                   "fsia_data_out", "fsia"),
814         /* I2C3 */
815         PIN_MAP_MUX_GROUP_DEFAULT("i2c-sh_mobile.3", "pfc-sh73a0",
816                                   "i2c3_1", "i2c3"),
817         /* LCD */
818         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_lcdc_fb.0", "pfc-sh73a0",
819                                   "lcd_data24", "lcd"),
820         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_lcdc_fb.0", "pfc-sh73a0",
821                                   "lcd_sync", "lcd"),
822         /* MMCIF */
823         PIN_MAP_MUX_GROUP_DEFAULT("sh_mmcif.0", "pfc-sh73a0",
824                                   "mmc0_data8_0", "mmc0"),
825         PIN_MAP_MUX_GROUP_DEFAULT("sh_mmcif.0", "pfc-sh73a0",
826                                   "mmc0_ctrl_0", "mmc0"),
827         PIN_MAP_CONFIGS_PIN_DEFAULT("sh_mmcif.0", "pfc-sh73a0",
828                                     "PORT279", pin_pullup_conf),
829         PIN_MAP_CONFIGS_GROUP_DEFAULT("sh_mmcif.0", "pfc-sh73a0",
830                                       "mmc0_data8_0", pin_pullup_conf),
831         /* SCIFA4 */
832         PIN_MAP_MUX_GROUP_DEFAULT("sh-sci.4", "pfc-sh73a0",
833                                   "scifa4_data", "scifa4"),
834         PIN_MAP_MUX_GROUP_DEFAULT("sh-sci.4", "pfc-sh73a0",
835                                   "scifa4_ctrl", "scifa4"),
836         /* SDHI0 */
837         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-sh73a0",
838                                   "sdhi0_data4", "sdhi0"),
839         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-sh73a0",
840                                   "sdhi0_ctrl", "sdhi0"),
841         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-sh73a0",
842                                   "sdhi0_cd", "sdhi0"),
843         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-sh73a0",
844                                   "sdhi0_wp", "sdhi0"),
845         /* SDHI2 */
846         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.2", "pfc-sh73a0",
847                                   "sdhi2_data4", "sdhi2"),
848         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.2", "pfc-sh73a0",
849                                   "sdhi2_ctrl", "sdhi2"),
850         /* SMSC */
851         PIN_MAP_MUX_GROUP_DEFAULT("smsc911x.0", "pfc-sh73a0",
852                                   "bsc_cs4", "bsc"),
853         /* USB */
854         PIN_MAP_MUX_GROUP_DEFAULT("renesas_usbhs", "pfc-sh73a0",
855                                   "usb_vbus", "usb"),
856 };
857 
858 static void __init kzm_init(void)
859 {
860         regulator_register_always_on(2, "fixed-1.8V", fixed1v8_power_consumers,
861                                      ARRAY_SIZE(fixed1v8_power_consumers), 1800000);
862         regulator_register_fixed(3, dummy_supplies, ARRAY_SIZE(dummy_supplies));
863 
864         pinctrl_register_mappings(kzm_pinctrl_map, ARRAY_SIZE(kzm_pinctrl_map));
865 
866         sh73a0_pinmux_init();
867 
868         /* SMSC */
869         gpio_request_one(224, GPIOF_IN, NULL); /* IRQ3 */
870 
871         /* LCDC */
872         gpio_request_one(222, GPIOF_OUT_INIT_HIGH, NULL); /* LCDCDON */
873         gpio_request_one(226, GPIOF_OUT_INIT_HIGH, NULL); /* SC */
874 
875         /* Touchscreen */
876         gpio_request_one(223, GPIOF_IN, NULL); /* IRQ8 */
877 
878 #ifdef CONFIG_CACHE_L2X0
879         /* Early BRESP enable, Shared attribute override enable, 64K*8way */
880         l2x0_init(IOMEM(0xf0100000), 0x40460000, 0x82000fff);
881 #endif
882 
883         i2c_register_board_info(0, i2c0_devices, ARRAY_SIZE(i2c0_devices));
884         i2c_register_board_info(1, i2c1_devices, ARRAY_SIZE(i2c1_devices));
885         i2c_register_board_info(3, i2c3_devices, ARRAY_SIZE(i2c3_devices));
886 
887         sh73a0_add_standard_devices();
888         platform_add_devices(kzm_devices, ARRAY_SIZE(kzm_devices));
889 
890         sh73a0_pm_init();
891 }
892 
893 static void kzm9g_restart(enum reboot_mode mode, const char *cmd)
894 {
895 #define RESCNT2 IOMEM(0xe6188020)
896         /* Do soft power on reset */
897         writel((1 << 31), RESCNT2);
898 }
899 
900 static const char *kzm9g_boards_compat_dt[] __initdata = {
901         "renesas,kzm9g",
902         NULL,
903 };
904 
905 DT_MACHINE_START(KZM9G_DT, "kzm9g")
906         .smp            = smp_ops(sh73a0_smp_ops),
907         .map_io         = sh73a0_map_io,
908         .init_early     = sh73a0_add_early_devices,
909         .nr_irqs        = NR_IRQS_LEGACY,
910         .init_irq       = sh73a0_init_irq,
911         .init_machine   = kzm_init,
912         .init_late      = shmobile_init_late,
913         .init_time      = sh73a0_earlytimer_init,
914         .restart        = kzm9g_restart,
915         .dt_compat      = kzm9g_boards_compat_dt,
916 MACHINE_END
917 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp