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

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

Version: ~ [ linux-5.6-rc1 ] ~ [ linux-5.5.2 ] ~ [ linux-5.4.17 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.102 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.170 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.213 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.213 ] ~ [ 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.81 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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/tmio.h>
 33 #include <linux/platform_device.h>
 34 #include <linux/regulator/fixed.h>
 35 #include <linux/regulator/machine.h>
 36 #include <linux/smsc911x.h>
 37 #include <linux/usb/r8a66597.h>
 38 #include <linux/usb/renesas_usbhs.h>
 39 #include <linux/videodev2.h>
 40 #include <sound/sh_fsi.h>
 41 #include <sound/simple_card.h>
 42 #include <mach/irqs.h>
 43 #include <mach/sh73a0.h>
 44 #include <mach/common.h>
 45 #include <asm/hardware/cache-l2x0.h>
 46 #include <asm/mach-types.h>
 47 #include <asm/mach/arch.h>
 48 #include <video/sh_mobile_lcdc.h>
 49 
 50 /*
 51  * external GPIO
 52  */
 53 #define GPIO_PCF8575_BASE       (GPIO_NR)
 54 #define GPIO_PCF8575_PORT10     (GPIO_NR + 8)
 55 #define GPIO_PCF8575_PORT11     (GPIO_NR + 9)
 56 #define GPIO_PCF8575_PORT12     (GPIO_NR + 10)
 57 #define GPIO_PCF8575_PORT13     (GPIO_NR + 11)
 58 #define GPIO_PCF8575_PORT14     (GPIO_NR + 12)
 59 #define GPIO_PCF8575_PORT15     (GPIO_NR + 13)
 60 #define GPIO_PCF8575_PORT16     (GPIO_NR + 14)
 61 
 62 /* Dummy supplies, where voltage doesn't matter */
 63 static struct regulator_consumer_supply dummy_supplies[] = {
 64         REGULATOR_SUPPLY("vddvario", "smsc911x"),
 65         REGULATOR_SUPPLY("vdd33a", "smsc911x"),
 66 };
 67 
 68 /*
 69  * FSI-AK4648
 70  *
 71  * this command is required when playback.
 72  *
 73  * # amixer set "LINEOUT Mixer DACL" on
 74  */
 75 
 76 /* SMSC 9221 */
 77 static struct resource smsc9221_resources[] = {
 78         [0] = {
 79                 .start  = 0x10000000, /* CS4 */
 80                 .end    = 0x100000ff,
 81                 .flags  = IORESOURCE_MEM,
 82         },
 83         [1] = {
 84                 .start  = intcs_evt2irq(0x260), /* IRQ3 */
 85                 .flags  = IORESOURCE_IRQ,
 86         },
 87 };
 88 
 89 static struct smsc911x_platform_config smsc9221_platdata = {
 90         .flags          = SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS,
 91         .phy_interface  = PHY_INTERFACE_MODE_MII,
 92         .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
 93         .irq_type       = SMSC911X_IRQ_TYPE_PUSH_PULL,
 94 };
 95 
 96 static struct platform_device smsc_device = {
 97         .name           = "smsc911x",
 98         .dev  = {
 99                 .platform_data = &smsc9221_platdata,
100         },
101         .resource       = smsc9221_resources,
102         .num_resources  = ARRAY_SIZE(smsc9221_resources),
103 };
104 
105 /* USB external chip */
106 static struct r8a66597_platdata usb_host_data = {
107         .on_chip        = 0,
108         .xtal           = R8A66597_PLATDATA_XTAL_48MHZ,
109 };
110 
111 static struct resource usb_resources[] = {
112         [0] = {
113                 .start  = 0x10010000,
114                 .end    = 0x1001ffff - 1,
115                 .flags  = IORESOURCE_MEM,
116         },
117         [1] = {
118                 .start  = intcs_evt2irq(0x220), /* IRQ1 */
119                 .flags  = IORESOURCE_IRQ,
120         },
121 };
122 
123 static struct platform_device usb_host_device = {
124         .name   = "r8a66597_hcd",
125         .dev = {
126                 .platform_data          = &usb_host_data,
127                 .dma_mask               = NULL,
128                 .coherent_dma_mask      = 0xffffffff,
129         },
130         .num_resources  = ARRAY_SIZE(usb_resources),
131         .resource       = usb_resources,
132 };
133 
134 /* USB Func CN17 */
135 struct usbhs_private {
136         void __iomem *phy;
137         void __iomem *cr2;
138         struct renesas_usbhs_platform_info info;
139 };
140 
141 #define IRQ15                   intcs_evt2irq(0x03e0)
142 #define USB_PHY_MODE            (1 << 4)
143 #define USB_PHY_INT_EN          ((1 << 3) | (1 << 2))
144 #define USB_PHY_ON              (1 << 1)
145 #define USB_PHY_OFF             (1 << 0)
146 #define USB_PHY_INT_CLR         (USB_PHY_ON | USB_PHY_OFF)
147 
148 #define usbhs_get_priv(pdev) \
149         container_of(renesas_usbhs_get_info(pdev), struct usbhs_private, info)
150 
151 static int usbhs_get_vbus(struct platform_device *pdev)
152 {
153         struct usbhs_private *priv = usbhs_get_priv(pdev);
154 
155         return !((1 << 7) & __raw_readw(priv->cr2));
156 }
157 
158 static void usbhs_phy_reset(struct platform_device *pdev)
159 {
160         struct usbhs_private *priv = usbhs_get_priv(pdev);
161 
162         /* init phy */
163         __raw_writew(0x8a0a, priv->cr2);
164 }
165 
166 static int usbhs_get_id(struct platform_device *pdev)
167 {
168         return USBHS_GADGET;
169 }
170 
171 static irqreturn_t usbhs_interrupt(int irq, void *data)
172 {
173         struct platform_device *pdev = data;
174         struct usbhs_private *priv = usbhs_get_priv(pdev);
175 
176         renesas_usbhs_call_notify_hotplug(pdev);
177 
178         /* clear status */
179         __raw_writew(__raw_readw(priv->phy) | USB_PHY_INT_CLR, priv->phy);
180 
181         return IRQ_HANDLED;
182 }
183 
184 static int usbhs_hardware_init(struct platform_device *pdev)
185 {
186         struct usbhs_private *priv = usbhs_get_priv(pdev);
187         int ret;
188 
189         /* clear interrupt status */
190         __raw_writew(USB_PHY_MODE | USB_PHY_INT_CLR, priv->phy);
191 
192         ret = request_irq(IRQ15, usbhs_interrupt, IRQF_TRIGGER_HIGH,
193                           dev_name(&pdev->dev), pdev);
194         if (ret) {
195                 dev_err(&pdev->dev, "request_irq err\n");
196                 return ret;
197         }
198 
199         /* enable USB phy interrupt */
200         __raw_writew(USB_PHY_MODE | USB_PHY_INT_EN, priv->phy);
201 
202         return 0;
203 }
204 
205 static void usbhs_hardware_exit(struct platform_device *pdev)
206 {
207         struct usbhs_private *priv = usbhs_get_priv(pdev);
208 
209         /* clear interrupt status */
210         __raw_writew(USB_PHY_MODE | USB_PHY_INT_CLR, priv->phy);
211 
212         free_irq(IRQ15, pdev);
213 }
214 
215 static u32 usbhs_pipe_cfg[] = {
216         USB_ENDPOINT_XFER_CONTROL,
217         USB_ENDPOINT_XFER_ISOC,
218         USB_ENDPOINT_XFER_ISOC,
219         USB_ENDPOINT_XFER_BULK,
220         USB_ENDPOINT_XFER_BULK,
221         USB_ENDPOINT_XFER_BULK,
222         USB_ENDPOINT_XFER_INT,
223         USB_ENDPOINT_XFER_INT,
224         USB_ENDPOINT_XFER_INT,
225         USB_ENDPOINT_XFER_BULK,
226         USB_ENDPOINT_XFER_BULK,
227         USB_ENDPOINT_XFER_BULK,
228         USB_ENDPOINT_XFER_BULK,
229         USB_ENDPOINT_XFER_BULK,
230         USB_ENDPOINT_XFER_BULK,
231         USB_ENDPOINT_XFER_BULK,
232 };
233 
234 static struct usbhs_private usbhs_private = {
235         .phy    = IOMEM(0xe60781e0),            /* USBPHYINT */
236         .cr2    = IOMEM(0xe605810c),            /* USBCR2 */
237         .info = {
238                 .platform_callback = {
239                         .hardware_init  = usbhs_hardware_init,
240                         .hardware_exit  = usbhs_hardware_exit,
241                         .get_id         = usbhs_get_id,
242                         .phy_reset      = usbhs_phy_reset,
243                         .get_vbus       = usbhs_get_vbus,
244                 },
245                 .driver_param = {
246                         .buswait_bwait  = 4,
247                         .has_otg        = 1,
248                         .pipe_type      = usbhs_pipe_cfg,
249                         .pipe_size      = ARRAY_SIZE(usbhs_pipe_cfg),
250                 },
251         },
252 };
253 
254 static struct resource usbhs_resources[] = {
255         [0] = {
256                 .start  = 0xE6890000,
257                 .end    = 0xE68900e6 - 1,
258                 .flags  = IORESOURCE_MEM,
259         },
260         [1] = {
261                 .start  = gic_spi(62),
262                 .end    = gic_spi(62),
263                 .flags  = IORESOURCE_IRQ,
264         },
265 };
266 
267 static struct platform_device usbhs_device = {
268         .name   = "renesas_usbhs",
269         .id     = -1,
270         .dev = {
271                 .dma_mask               = NULL,
272                 .coherent_dma_mask      = 0xffffffff,
273                 .platform_data          = &usbhs_private.info,
274         },
275         .num_resources  = ARRAY_SIZE(usbhs_resources),
276         .resource       = usbhs_resources,
277 };
278 
279 /* LCDC */
280 static struct fb_videomode kzm_lcdc_mode = {
281         .name           = "WVGA Panel",
282         .xres           = 800,
283         .yres           = 480,
284         .left_margin    = 220,
285         .right_margin   = 110,
286         .hsync_len      = 70,
287         .upper_margin   = 20,
288         .lower_margin   = 5,
289         .vsync_len      = 5,
290         .sync           = 0,
291 };
292 
293 static struct sh_mobile_lcdc_info lcdc_info = {
294         .clock_source = LCDC_CLK_BUS,
295         .ch[0] = {
296                 .chan           = LCDC_CHAN_MAINLCD,
297                 .fourcc         = V4L2_PIX_FMT_RGB565,
298                 .interface_type = RGB24,
299                 .lcd_modes      = &kzm_lcdc_mode,
300                 .num_modes      = 1,
301                 .clock_divider  = 5,
302                 .flags          = 0,
303                 .panel_cfg = {
304                         .width  = 152,
305                         .height = 91,
306                 },
307         }
308 };
309 
310 static struct resource lcdc_resources[] = {
311         [0] = {
312                 .name   = "LCDC",
313                 .start  = 0xfe940000,
314                 .end    = 0xfe943fff,
315                 .flags  = IORESOURCE_MEM,
316         },
317         [1] = {
318                 .start  = intcs_evt2irq(0x580),
319                 .flags  = IORESOURCE_IRQ,
320         },
321 };
322 
323 static struct platform_device lcdc_device = {
324         .name           = "sh_mobile_lcdc_fb",
325         .num_resources  = ARRAY_SIZE(lcdc_resources),
326         .resource       = lcdc_resources,
327         .dev    = {
328                 .platform_data  = &lcdc_info,
329                 .coherent_dma_mask = ~0,
330         },
331 };
332 
333 /* Fixed 1.8V regulator to be used by MMCIF */
334 static struct regulator_consumer_supply fixed1v8_power_consumers[] =
335 {
336         REGULATOR_SUPPLY("vmmc", "sh_mmcif.0"),
337         REGULATOR_SUPPLY("vqmmc", "sh_mmcif.0"),
338 };
339 
340 /* MMCIF */
341 static struct resource sh_mmcif_resources[] = {
342         [0] = {
343                 .name   = "MMCIF",
344                 .start  = 0xe6bd0000,
345                 .end    = 0xe6bd00ff,
346                 .flags  = IORESOURCE_MEM,
347         },
348         [1] = {
349                 .start  = gic_spi(140),
350                 .flags  = IORESOURCE_IRQ,
351         },
352         [2] = {
353                 .start  = gic_spi(141),
354                 .flags  = IORESOURCE_IRQ,
355         },
356 };
357 
358 static struct sh_mmcif_plat_data sh_mmcif_platdata = {
359         .ocr            = MMC_VDD_165_195,
360         .caps           = MMC_CAP_8_BIT_DATA | MMC_CAP_NONREMOVABLE,
361         .slave_id_tx    = SHDMA_SLAVE_MMCIF_TX,
362         .slave_id_rx    = SHDMA_SLAVE_MMCIF_RX,
363 };
364 
365 static struct platform_device mmc_device = {
366         .name           = "sh_mmcif",
367         .dev            = {
368                 .dma_mask               = NULL,
369                 .coherent_dma_mask      = 0xffffffff,
370                 .platform_data          = &sh_mmcif_platdata,
371         },
372         .num_resources  = ARRAY_SIZE(sh_mmcif_resources),
373         .resource       = sh_mmcif_resources,
374 };
375 
376 /* Fixed 2.8V regulators to be used by SDHI0 and SDHI2 */
377 static struct regulator_consumer_supply fixed2v8_power_consumers[] =
378 {
379         REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.0"),
380         REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.0"),
381         REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.2"),
382         REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.2"),
383 };
384 
385 /* SDHI */
386 static struct sh_mobile_sdhi_info sdhi0_info = {
387         .dma_slave_tx   = SHDMA_SLAVE_SDHI0_TX,
388         .dma_slave_rx   = SHDMA_SLAVE_SDHI0_RX,
389         .tmio_flags     = TMIO_MMC_HAS_IDLE_WAIT,
390         .tmio_caps      = MMC_CAP_SD_HIGHSPEED,
391         .tmio_ocr_mask  = MMC_VDD_27_28 | MMC_VDD_28_29,
392 };
393 
394 static struct resource sdhi0_resources[] = {
395         [0] = {
396                 .name   = "SDHI0",
397                 .start  = 0xee100000,
398                 .end    = 0xee1000ff,
399                 .flags  = IORESOURCE_MEM,
400         },
401         [1] = {
402                 .name   = SH_MOBILE_SDHI_IRQ_CARD_DETECT,
403                 .start  = gic_spi(83),
404                 .flags  = IORESOURCE_IRQ,
405         },
406         [2] = {
407                 .name   = SH_MOBILE_SDHI_IRQ_SDCARD,
408                 .start  = gic_spi(84),
409                 .flags  = IORESOURCE_IRQ,
410         },
411         [3] = {
412                 .name   = SH_MOBILE_SDHI_IRQ_SDIO,
413                 .start  = gic_spi(85),
414                 .flags  = IORESOURCE_IRQ,
415         },
416 };
417 
418 static struct platform_device sdhi0_device = {
419         .name           = "sh_mobile_sdhi",
420         .num_resources  = ARRAY_SIZE(sdhi0_resources),
421         .resource       = sdhi0_resources,
422         .dev    = {
423                 .platform_data  = &sdhi0_info,
424         },
425 };
426 
427 /* Micro SD */
428 static struct sh_mobile_sdhi_info sdhi2_info = {
429         .dma_slave_tx   = SHDMA_SLAVE_SDHI2_TX,
430         .dma_slave_rx   = SHDMA_SLAVE_SDHI2_RX,
431         .tmio_flags     = TMIO_MMC_HAS_IDLE_WAIT |
432                           TMIO_MMC_USE_GPIO_CD |
433                           TMIO_MMC_WRPROTECT_DISABLE,
434         .tmio_caps      = MMC_CAP_SD_HIGHSPEED,
435         .tmio_ocr_mask  = MMC_VDD_27_28 | MMC_VDD_28_29,
436         .cd_gpio        = GPIO_PORT13,
437 };
438 
439 static struct resource sdhi2_resources[] = {
440         [0] = {
441                 .name   = "SDHI2",
442                 .start  = 0xee140000,
443                 .end    = 0xee1400ff,
444                 .flags  = IORESOURCE_MEM,
445         },
446         [1] = {
447                 .name   = SH_MOBILE_SDHI_IRQ_CARD_DETECT,
448                 .start  = gic_spi(103),
449                 .flags  = IORESOURCE_IRQ,
450         },
451         [2] = {
452                 .name   = SH_MOBILE_SDHI_IRQ_SDCARD,
453                 .start  = gic_spi(104),
454                 .flags  = IORESOURCE_IRQ,
455         },
456         [3] = {
457                 .name   = SH_MOBILE_SDHI_IRQ_SDIO,
458                 .start  = gic_spi(105),
459                 .flags  = IORESOURCE_IRQ,
460         },
461 };
462 
463 static struct platform_device sdhi2_device = {
464         .name           = "sh_mobile_sdhi",
465         .id             = 2,
466         .num_resources  = ARRAY_SIZE(sdhi2_resources),
467         .resource       = sdhi2_resources,
468         .dev    = {
469                 .platform_data  = &sdhi2_info,
470         },
471 };
472 
473 /* KEY */
474 #define GPIO_KEY(c, g, d) { .code = c, .gpio = g, .desc = d, .active_low = 1 }
475 
476 static struct gpio_keys_button gpio_buttons[] = {
477         GPIO_KEY(KEY_BACK,      GPIO_PCF8575_PORT10,    "SW3"),
478         GPIO_KEY(KEY_RIGHT,     GPIO_PCF8575_PORT11,    "SW2-R"),
479         GPIO_KEY(KEY_LEFT,      GPIO_PCF8575_PORT12,    "SW2-L"),
480         GPIO_KEY(KEY_ENTER,     GPIO_PCF8575_PORT13,    "SW2-P"),
481         GPIO_KEY(KEY_UP,        GPIO_PCF8575_PORT14,    "SW2-U"),
482         GPIO_KEY(KEY_DOWN,      GPIO_PCF8575_PORT15,    "SW2-D"),
483         GPIO_KEY(KEY_HOME,      GPIO_PCF8575_PORT16,    "SW1"),
484 };
485 
486 static struct gpio_keys_platform_data gpio_key_info = {
487         .buttons        = gpio_buttons,
488         .nbuttons       = ARRAY_SIZE(gpio_buttons),
489 };
490 
491 static struct platform_device gpio_keys_device = {
492         .name   = "gpio-keys",
493         .dev    = {
494                 .platform_data  = &gpio_key_info,
495         },
496 };
497 
498 /* FSI-AK4648 */
499 static struct sh_fsi_platform_info fsi_info = {
500         .port_a = {
501                 .tx_id = SHDMA_SLAVE_FSI2A_TX,
502         },
503 };
504 
505 static struct resource fsi_resources[] = {
506         [0] = {
507                 .name   = "FSI",
508                 .start  = 0xEC230000,
509                 .end    = 0xEC230400 - 1,
510                 .flags  = IORESOURCE_MEM,
511         },
512         [1] = {
513                 .start  = gic_spi(146),
514                 .flags  = IORESOURCE_IRQ,
515         },
516 };
517 
518 static struct platform_device fsi_device = {
519         .name           = "sh_fsi2",
520         .id             = -1,
521         .num_resources  = ARRAY_SIZE(fsi_resources),
522         .resource       = fsi_resources,
523         .dev    = {
524                 .platform_data  = &fsi_info,
525         },
526 };
527 
528 static struct asoc_simple_card_info fsi2_ak4648_info = {
529         .name           = "AK4648",
530         .card           = "FSI2A-AK4648",
531         .codec          = "ak4642-codec.0-0012",
532         .platform       = "sh_fsi2",
533         .daifmt         = SND_SOC_DAIFMT_LEFT_J,
534         .cpu_dai = {
535                 .name   = "fsia-dai",
536                 .fmt    = SND_SOC_DAIFMT_CBS_CFS,
537         },
538         .codec_dai = {
539                 .name   = "ak4642-hifi",
540                 .fmt    = SND_SOC_DAIFMT_CBM_CFM,
541                 .sysclk = 11289600,
542         },
543 };
544 
545 static struct platform_device fsi_ak4648_device = {
546         .name   = "asoc-simple-card",
547         .dev    = {
548                 .platform_data  = &fsi2_ak4648_info,
549         },
550 };
551 
552 /* I2C */
553 static struct pcf857x_platform_data pcf8575_pdata = {
554         .gpio_base      = GPIO_PCF8575_BASE,
555 };
556 
557 static struct i2c_board_info i2c0_devices[] = {
558         {
559                 I2C_BOARD_INFO("ak4648", 0x12),
560         },
561         {
562                 I2C_BOARD_INFO("r2025sd", 0x32),
563         },
564         {
565                 I2C_BOARD_INFO("ak8975", 0x0c),
566                 .irq = intcs_evt2irq(0x3380), /* IRQ28 */
567         },
568         {
569                 I2C_BOARD_INFO("adxl34x", 0x1d),
570                 .irq = intcs_evt2irq(0x3340), /* IRQ26 */
571         },
572 };
573 
574 static struct i2c_board_info i2c1_devices[] = {
575         {
576                 I2C_BOARD_INFO("st1232-ts", 0x55),
577                 .irq = intcs_evt2irq(0x300), /* IRQ8 */
578         },
579 };
580 
581 static struct i2c_board_info i2c3_devices[] = {
582         {
583                 I2C_BOARD_INFO("pcf8575", 0x20),
584                 .irq            = intcs_evt2irq(0x3260), /* IRQ19 */
585                 .platform_data = &pcf8575_pdata,
586         },
587 };
588 
589 static struct platform_device *kzm_devices[] __initdata = {
590         &smsc_device,
591         &usb_host_device,
592         &usbhs_device,
593         &lcdc_device,
594         &mmc_device,
595         &sdhi0_device,
596         &sdhi2_device,
597         &gpio_keys_device,
598         &fsi_device,
599         &fsi_ak4648_device,
600 };
601 
602 /*
603  * FIXME
604  *
605  * This is quick hack for enabling LCDC backlight
606  */
607 static int __init as3711_enable_lcdc_backlight(void)
608 {
609         struct i2c_adapter *a = i2c_get_adapter(0);
610         struct i2c_msg msg;
611         int i, ret;
612         __u8 magic[] = {
613                 0x40, 0x2a,
614                 0x43, 0x3c,
615                 0x44, 0x3c,
616                 0x45, 0x3c,
617                 0x54, 0x03,
618                 0x51, 0x00,
619                 0x51, 0x01,
620                 0xff, 0x00, /* wait */
621                 0x43, 0xf0,
622                 0x44, 0xf0,
623                 0x45, 0xf0,
624         };
625 
626         if (!of_machine_is_compatible("renesas,kzm9g"))
627                 return 0;
628 
629         if (!a)
630                 return 0;
631 
632         msg.addr        = 0x40;
633         msg.len         = 2;
634         msg.flags       = 0;
635 
636         for (i = 0; i < ARRAY_SIZE(magic); i += 2) {
637                 msg.buf = magic + i;
638 
639                 if (0xff == msg.buf[0]) {
640                         udelay(500);
641                         continue;
642                 }
643 
644                 ret = i2c_transfer(a, &msg, 1);
645                 if (ret < 0) {
646                         pr_err("i2c transfer fail\n");
647                         break;
648                 }
649         }
650 
651         return 0;
652 }
653 device_initcall(as3711_enable_lcdc_backlight);
654 
655 static void __init kzm_init(void)
656 {
657         regulator_register_always_on(0, "fixed-1.8V", fixed1v8_power_consumers,
658                                      ARRAY_SIZE(fixed1v8_power_consumers), 1800000);
659         regulator_register_always_on(1, "fixed-2.8V", fixed2v8_power_consumers,
660                                      ARRAY_SIZE(fixed2v8_power_consumers), 2800000);
661         regulator_register_fixed(2, dummy_supplies, ARRAY_SIZE(dummy_supplies));
662 
663         sh73a0_pinmux_init();
664 
665         /* enable SCIFA4 */
666         gpio_request(GPIO_FN_SCIFA4_TXD, NULL);
667         gpio_request(GPIO_FN_SCIFA4_RXD, NULL);
668         gpio_request(GPIO_FN_SCIFA4_RTS_, NULL);
669         gpio_request(GPIO_FN_SCIFA4_CTS_, NULL);
670 
671         /* CS4 for SMSC/USB */
672         gpio_request(GPIO_FN_CS4_, NULL); /* CS4 */
673 
674         /* SMSC */
675         gpio_request_one(GPIO_PORT224, GPIOF_IN, NULL); /* IRQ3 */
676 
677         /* LCDC */
678         gpio_request(GPIO_FN_LCDD23,    NULL);
679         gpio_request(GPIO_FN_LCDD22,    NULL);
680         gpio_request(GPIO_FN_LCDD21,    NULL);
681         gpio_request(GPIO_FN_LCDD20,    NULL);
682         gpio_request(GPIO_FN_LCDD19,    NULL);
683         gpio_request(GPIO_FN_LCDD18,    NULL);
684         gpio_request(GPIO_FN_LCDD17,    NULL);
685         gpio_request(GPIO_FN_LCDD16,    NULL);
686         gpio_request(GPIO_FN_LCDD15,    NULL);
687         gpio_request(GPIO_FN_LCDD14,    NULL);
688         gpio_request(GPIO_FN_LCDD13,    NULL);
689         gpio_request(GPIO_FN_LCDD12,    NULL);
690         gpio_request(GPIO_FN_LCDD11,    NULL);
691         gpio_request(GPIO_FN_LCDD10,    NULL);
692         gpio_request(GPIO_FN_LCDD9,     NULL);
693         gpio_request(GPIO_FN_LCDD8,     NULL);
694         gpio_request(GPIO_FN_LCDD7,     NULL);
695         gpio_request(GPIO_FN_LCDD6,     NULL);
696         gpio_request(GPIO_FN_LCDD5,     NULL);
697         gpio_request(GPIO_FN_LCDD4,     NULL);
698         gpio_request(GPIO_FN_LCDD3,     NULL);
699         gpio_request(GPIO_FN_LCDD2,     NULL);
700         gpio_request(GPIO_FN_LCDD1,     NULL);
701         gpio_request(GPIO_FN_LCDD0,     NULL);
702         gpio_request(GPIO_FN_LCDDISP,   NULL);
703         gpio_request(GPIO_FN_LCDDCK,    NULL);
704 
705         gpio_request_one(GPIO_PORT222, GPIOF_OUT_INIT_HIGH, NULL); /* LCDCDON */
706         gpio_request_one(GPIO_PORT226, GPIOF_OUT_INIT_HIGH, NULL); /* SC */
707 
708         /* Touchscreen */
709         gpio_request_one(GPIO_PORT223, GPIOF_IN, NULL); /* IRQ8 */
710 
711         /* enable MMCIF */
712         gpio_request(GPIO_FN_MMCCLK0,           NULL);
713         gpio_request(GPIO_FN_MMCCMD0_PU,        NULL);
714         gpio_request(GPIO_FN_MMCD0_0_PU,        NULL);
715         gpio_request(GPIO_FN_MMCD0_1_PU,        NULL);
716         gpio_request(GPIO_FN_MMCD0_2_PU,        NULL);
717         gpio_request(GPIO_FN_MMCD0_3_PU,        NULL);
718         gpio_request(GPIO_FN_MMCD0_4_PU,        NULL);
719         gpio_request(GPIO_FN_MMCD0_5_PU,        NULL);
720         gpio_request(GPIO_FN_MMCD0_6_PU,        NULL);
721         gpio_request(GPIO_FN_MMCD0_7_PU,        NULL);
722 
723         /* enable SD */
724         gpio_request(GPIO_FN_SDHIWP0,           NULL);
725         gpio_request(GPIO_FN_SDHICD0,           NULL);
726         gpio_request(GPIO_FN_SDHICMD0,          NULL);
727         gpio_request(GPIO_FN_SDHICLK0,          NULL);
728         gpio_request(GPIO_FN_SDHID0_3,          NULL);
729         gpio_request(GPIO_FN_SDHID0_2,          NULL);
730         gpio_request(GPIO_FN_SDHID0_1,          NULL);
731         gpio_request(GPIO_FN_SDHID0_0,          NULL);
732         gpio_request(GPIO_FN_SDHI0_VCCQ_MC0_ON, NULL);
733         gpio_request_one(GPIO_PORT15, GPIOF_OUT_INIT_HIGH, NULL); /* power */
734 
735         /* enable Micro SD */
736         gpio_request(GPIO_FN_SDHID2_0,          NULL);
737         gpio_request(GPIO_FN_SDHID2_1,          NULL);
738         gpio_request(GPIO_FN_SDHID2_2,          NULL);
739         gpio_request(GPIO_FN_SDHID2_3,          NULL);
740         gpio_request(GPIO_FN_SDHICMD2,          NULL);
741         gpio_request(GPIO_FN_SDHICLK2,          NULL);
742         gpio_request_one(GPIO_PORT14, GPIOF_OUT_INIT_HIGH, NULL); /* power */
743 
744         /* I2C 3 */
745         gpio_request(GPIO_FN_PORT27_I2C_SCL3, NULL);
746         gpio_request(GPIO_FN_PORT28_I2C_SDA3, NULL);
747 
748         /* enable FSI2 port A (ak4648) */
749         gpio_request(GPIO_FN_FSIACK,    NULL);
750         gpio_request(GPIO_FN_FSIAILR,   NULL);
751         gpio_request(GPIO_FN_FSIAIBT,   NULL);
752         gpio_request(GPIO_FN_FSIAISLD,  NULL);
753         gpio_request(GPIO_FN_FSIAOSLD,  NULL);
754 
755         /* enable USB */
756         gpio_request(GPIO_FN_VBUS_0,    NULL);
757 
758 #ifdef CONFIG_CACHE_L2X0
759         /* Early BRESP enable, Shared attribute override enable, 64K*8way */
760         l2x0_init(IOMEM(0xf0100000), 0x40460000, 0x82000fff);
761 #endif
762 
763         i2c_register_board_info(0, i2c0_devices, ARRAY_SIZE(i2c0_devices));
764         i2c_register_board_info(1, i2c1_devices, ARRAY_SIZE(i2c1_devices));
765         i2c_register_board_info(3, i2c3_devices, ARRAY_SIZE(i2c3_devices));
766 
767         sh73a0_add_standard_devices();
768         platform_add_devices(kzm_devices, ARRAY_SIZE(kzm_devices));
769 
770         sh73a0_pm_init();
771 }
772 
773 static void kzm9g_restart(char mode, const char *cmd)
774 {
775 #define RESCNT2 IOMEM(0xe6188020)
776         /* Do soft power on reset */
777         writel((1 << 31), RESCNT2);
778 }
779 
780 static const char *kzm9g_boards_compat_dt[] __initdata = {
781         "renesas,kzm9g",
782         NULL,
783 };
784 
785 DT_MACHINE_START(KZM9G_DT, "kzm9g")
786         .smp            = smp_ops(sh73a0_smp_ops),
787         .map_io         = sh73a0_map_io,
788         .init_early     = sh73a0_add_early_devices,
789         .nr_irqs        = NR_IRQS_LEGACY,
790         .init_irq       = sh73a0_init_irq,
791         .init_machine   = kzm_init,
792         .init_late      = shmobile_init_late,
793         .init_time      = sh73a0_earlytimer_init,
794         .restart        = kzm9g_restart,
795         .dt_compat      = kzm9g_boards_compat_dt,
796 MACHINE_END
797 

~ [ 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