ARM: shmobile: kota2: Register pinctrl mappings for KEYSC
[linux-3.10.git] / arch / arm / mach-shmobile / board-kota2.c
1 /*
2  * kota2 board support
3  *
4  * Copyright (C) 2011  Renesas Solutions Corp.
5  * Copyright (C) 2011  Magnus Damm
6  * Copyright (C) 2010  Takashi Yoshii <yoshii.takashi.zj@renesas.com>
7  * Copyright (C) 2009  Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; version 2 of the License.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
21  */
22
23 #include <linux/kernel.h>
24 #include <linux/init.h>
25 #include <linux/interrupt.h>
26 #include <linux/irq.h>
27 #include <linux/pinctrl/machine.h>
28 #include <linux/pinctrl/pinconf-generic.h>
29 #include <linux/platform_device.h>
30 #include <linux/delay.h>
31 #include <linux/io.h>
32 #include <linux/regulator/fixed.h>
33 #include <linux/regulator/machine.h>
34 #include <linux/smsc911x.h>
35 #include <linux/gpio.h>
36 #include <linux/input.h>
37 #include <linux/input/sh_keysc.h>
38 #include <linux/gpio_keys.h>
39 #include <linux/leds.h>
40 #include <linux/irqchip/arm-gic.h>
41 #include <linux/platform_data/leds-renesas-tpu.h>
42 #include <linux/mmc/host.h>
43 #include <linux/mmc/sh_mmcif.h>
44 #include <linux/mfd/tmio.h>
45 #include <linux/mmc/sh_mobile_sdhi.h>
46 #include <mach/hardware.h>
47 #include <mach/irqs.h>
48 #include <mach/sh73a0.h>
49 #include <mach/common.h>
50 #include <asm/mach-types.h>
51 #include <asm/mach/arch.h>
52 #include <asm/mach/time.h>
53 #include <asm/hardware/cache-l2x0.h>
54 #include <asm/traps.h>
55
56 /* Dummy supplies, where voltage doesn't matter */
57 static struct regulator_consumer_supply dummy_supplies[] = {
58         REGULATOR_SUPPLY("vddvario", "smsc911x"),
59         REGULATOR_SUPPLY("vdd33a", "smsc911x"),
60 };
61
62 /* SMSC 9220 */
63 static struct resource smsc9220_resources[] = {
64         [0] = {
65                 .start          = 0x14000000, /* CS5A */
66                 .end            = 0x140000ff, /* A1->A7 */
67                 .flags          = IORESOURCE_MEM,
68         },
69         [1] = {
70                 .start          = SH73A0_PINT0_IRQ(2), /* PINTA2 */
71                 .flags          = IORESOURCE_IRQ,
72         },
73 };
74
75 static struct smsc911x_platform_config smsc9220_platdata = {
76         .flags          = SMSC911X_USE_32BIT, /* 32-bit SW on 16-bit HW bus */
77         .phy_interface  = PHY_INTERFACE_MODE_MII,
78         .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
79         .irq_type       = SMSC911X_IRQ_TYPE_PUSH_PULL,
80 };
81
82 static struct platform_device eth_device = {
83         .name           = "smsc911x",
84         .id             = 0,
85         .dev  = {
86                 .platform_data = &smsc9220_platdata,
87         },
88         .resource       = smsc9220_resources,
89         .num_resources  = ARRAY_SIZE(smsc9220_resources),
90 };
91
92 /* KEYSC */
93 static struct sh_keysc_info keysc_platdata = {
94         .mode           = SH_KEYSC_MODE_6,
95         .scan_timing    = 3,
96         .delay          = 100,
97         .keycodes       = {
98                 KEY_NUMERIC_STAR, KEY_NUMERIC_0, KEY_NUMERIC_POUND,
99                 0, 0, 0, 0, 0,
100                 KEY_NUMERIC_7, KEY_NUMERIC_8, KEY_NUMERIC_9,
101                 0, KEY_DOWN, 0, 0, 0,
102                 KEY_NUMERIC_4, KEY_NUMERIC_5, KEY_NUMERIC_6,
103                 KEY_LEFT, KEY_ENTER, KEY_RIGHT, 0, 0,
104                 KEY_NUMERIC_1, KEY_NUMERIC_2, KEY_NUMERIC_3,
105                 0, KEY_UP, 0, 0, 0,
106                 0, 0, 0, 0, 0, 0, 0, 0,
107                 0, 0, 0, 0, 0, 0, 0, 0,
108                 0, 0, 0, 0, 0, 0, 0, 0,
109                 0, 0, 0, 0, 0, 0, 0, 0,
110         },
111 };
112
113 static struct resource keysc_resources[] = {
114         [0] = {
115                 .name   = "KEYSC",
116                 .start  = 0xe61b0000,
117                 .end    = 0xe61b0098 - 1,
118                 .flags  = IORESOURCE_MEM,
119         },
120         [1] = {
121                 .start  = gic_spi(71),
122                 .flags  = IORESOURCE_IRQ,
123         },
124 };
125
126 static struct platform_device keysc_device = {
127         .name           = "sh_keysc",
128         .id             = 0,
129         .num_resources  = ARRAY_SIZE(keysc_resources),
130         .resource       = keysc_resources,
131         .dev            = {
132                 .platform_data  = &keysc_platdata,
133         },
134 };
135
136 /* GPIO KEY */
137 #define GPIO_KEY(c, g, d) { .code = c, .gpio = g, .desc = d, .active_low = 1 }
138
139 static struct gpio_keys_button gpio_buttons[] = {
140         GPIO_KEY(KEY_VOLUMEUP, 56, "+"), /* S2: VOL+ [IRQ9] */
141         GPIO_KEY(KEY_VOLUMEDOWN, 54, "-"), /* S3: VOL- [IRQ10] */
142         GPIO_KEY(KEY_MENU, 27, "Menu"), /* S4: MENU [IRQ30] */
143         GPIO_KEY(KEY_HOMEPAGE, 26, "Home"), /* S5: HOME [IRQ31] */
144         GPIO_KEY(KEY_BACK, 11, "Back"), /* S6: BACK [IRQ0] */
145         GPIO_KEY(KEY_PHONE, 238, "Tel"), /* S7: TEL [IRQ11] */
146         GPIO_KEY(KEY_POWER, 239, "C1"), /* S8: CAM [IRQ13] */
147         GPIO_KEY(KEY_MAIL, 224, "Mail"), /* S9: MAIL [IRQ3] */
148         /* Omitted button "C3?": 223 - S10: CUST [IRQ8] */
149         GPIO_KEY(KEY_CAMERA, 164, "C2"), /* S11: CAM_HALF [IRQ25] */
150         /* Omitted button "?": 152 - S12: CAM_FULL [No IRQ] */
151 };
152
153 static struct gpio_keys_platform_data gpio_key_info = {
154         .buttons        = gpio_buttons,
155         .nbuttons       = ARRAY_SIZE(gpio_buttons),
156 };
157
158 static struct platform_device gpio_keys_device = {
159         .name   = "gpio-keys",
160         .id     = -1,
161         .dev    = {
162                 .platform_data  = &gpio_key_info,
163         },
164 };
165
166 /* GPIO LED */
167 #define GPIO_LED(n, g) { .name = n, .gpio = g }
168
169 static struct gpio_led gpio_leds[] = {
170         GPIO_LED("G", 20), /* PORT20 [GPO0] -> LED7 -> "G" */
171         GPIO_LED("H", 21), /* PORT21 [GPO1] -> LED8 -> "H" */
172         GPIO_LED("J", 22), /* PORT22 [GPO2] -> LED9 -> "J" */
173 };
174
175 static struct gpio_led_platform_data gpio_leds_info = {
176         .leds           = gpio_leds,
177         .num_leds       = ARRAY_SIZE(gpio_leds),
178 };
179
180 static struct platform_device gpio_leds_device = {
181         .name   = "leds-gpio",
182         .id     = -1,
183         .dev    = {
184                 .platform_data  = &gpio_leds_info,
185         },
186 };
187
188 /* TPU LED */
189 static struct led_renesas_tpu_config led_renesas_tpu12_pdata = {
190         .name           = "V2513",
191         .pin_gpio_fn    = GPIO_FN_TPU1TO2,
192         .pin_gpio       = 153,
193         .channel_offset = 0x90,
194         .timer_bit = 2,
195         .max_brightness = 1000,
196 };
197
198 static struct resource tpu12_resources[] = {
199         [0] = {
200                 .name   = "TPU12",
201                 .start  = 0xe6610090,
202                 .end    = 0xe66100b5,
203                 .flags  = IORESOURCE_MEM,
204         },
205 };
206
207 static struct platform_device leds_tpu12_device = {
208         .name = "leds-renesas-tpu",
209         .id = 12,
210         .dev = {
211                 .platform_data  = &led_renesas_tpu12_pdata,
212         },
213         .num_resources  = ARRAY_SIZE(tpu12_resources),
214         .resource       = tpu12_resources,
215 };
216
217 static struct led_renesas_tpu_config led_renesas_tpu41_pdata = {
218         .name           = "V2514",
219         .pin_gpio_fn    = GPIO_FN_TPU4TO1,
220         .pin_gpio       = 199,
221         .channel_offset = 0x50,
222         .timer_bit = 1,
223         .max_brightness = 1000,
224 };
225
226 static struct resource tpu41_resources[] = {
227         [0] = {
228                 .name   = "TPU41",
229                 .start  = 0xe6640050,
230                 .end    = 0xe6640075,
231                 .flags  = IORESOURCE_MEM,
232         },
233 };
234
235 static struct platform_device leds_tpu41_device = {
236         .name = "leds-renesas-tpu",
237         .id = 41,
238         .dev = {
239                 .platform_data  = &led_renesas_tpu41_pdata,
240         },
241         .num_resources  = ARRAY_SIZE(tpu41_resources),
242         .resource       = tpu41_resources,
243 };
244
245 static struct led_renesas_tpu_config led_renesas_tpu21_pdata = {
246         .name           = "V2515",
247         .pin_gpio_fn    = GPIO_FN_TPU2TO1,
248         .pin_gpio       = 197,
249         .channel_offset = 0x50,
250         .timer_bit = 1,
251         .max_brightness = 1000,
252 };
253
254 static struct resource tpu21_resources[] = {
255         [0] = {
256                 .name   = "TPU21",
257                 .start  = 0xe6620050,
258                 .end    = 0xe6620075,
259                 .flags  = IORESOURCE_MEM,
260         },
261 };
262
263 static struct platform_device leds_tpu21_device = {
264         .name = "leds-renesas-tpu",
265         .id = 21,
266         .dev = {
267                 .platform_data  = &led_renesas_tpu21_pdata,
268         },
269         .num_resources  = ARRAY_SIZE(tpu21_resources),
270         .resource       = tpu21_resources,
271 };
272
273 static struct led_renesas_tpu_config led_renesas_tpu30_pdata = {
274         .name           = "KEYLED",
275         .pin_gpio_fn    = GPIO_FN_TPU3TO0,
276         .pin_gpio       = 163,
277         .channel_offset = 0x10,
278         .timer_bit = 0,
279         .max_brightness = 1000,
280 };
281
282 static struct resource tpu30_resources[] = {
283         [0] = {
284                 .name   = "TPU30",
285                 .start  = 0xe6630010,
286                 .end    = 0xe6630035,
287                 .flags  = IORESOURCE_MEM,
288         },
289 };
290
291 static struct platform_device leds_tpu30_device = {
292         .name = "leds-renesas-tpu",
293         .id = 30,
294         .dev = {
295                 .platform_data  = &led_renesas_tpu30_pdata,
296         },
297         .num_resources  = ARRAY_SIZE(tpu30_resources),
298         .resource       = tpu30_resources,
299 };
300
301 /* Fixed 1.8V regulator to be used by MMCIF */
302 static struct regulator_consumer_supply fixed1v8_power_consumers[] =
303 {
304         REGULATOR_SUPPLY("vmmc", "sh_mmcif.0"),
305         REGULATOR_SUPPLY("vqmmc", "sh_mmcif.0"),
306 };
307
308 /* MMCIF */
309 static struct resource mmcif_resources[] = {
310         [0] = {
311                 .name   = "MMCIF",
312                 .start  = 0xe6bd0000,
313                 .end    = 0xe6bd00ff,
314                 .flags  = IORESOURCE_MEM,
315         },
316         [1] = {
317                 .start  = gic_spi(140),
318                 .flags  = IORESOURCE_IRQ,
319         },
320         [2] = {
321                 .start  = gic_spi(141),
322                 .flags  = IORESOURCE_IRQ,
323         },
324 };
325
326 static struct sh_mmcif_plat_data mmcif_info = {
327         .ocr            = MMC_VDD_165_195,
328         .caps           = MMC_CAP_8_BIT_DATA | MMC_CAP_NONREMOVABLE,
329 };
330
331 static struct platform_device mmcif_device = {
332         .name           = "sh_mmcif",
333         .id             = 0,
334         .dev            = {
335                 .platform_data          = &mmcif_info,
336         },
337         .num_resources  = ARRAY_SIZE(mmcif_resources),
338         .resource       = mmcif_resources,
339 };
340
341 /* Fixed 3.3V regulator to be used by SDHI0 and SDHI1 */
342 static struct regulator_consumer_supply fixed3v3_power_consumers[] =
343 {
344         REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.0"),
345         REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.0"),
346         REGULATOR_SUPPLY("vmmc", "sh_mobile_sdhi.1"),
347         REGULATOR_SUPPLY("vqmmc", "sh_mobile_sdhi.1"),
348 };
349
350 /* SDHI0 */
351 static struct sh_mobile_sdhi_info sdhi0_info = {
352         .tmio_caps      = MMC_CAP_SD_HIGHSPEED,
353         .tmio_flags     = TMIO_MMC_WRPROTECT_DISABLE | TMIO_MMC_HAS_IDLE_WAIT,
354 };
355
356 static struct resource sdhi0_resources[] = {
357         [0] = {
358                 .name   = "SDHI0",
359                 .start  = 0xee100000,
360                 .end    = 0xee1000ff,
361                 .flags  = IORESOURCE_MEM,
362         },
363         [1] = {
364                 .start  = gic_spi(83),
365                 .flags  = IORESOURCE_IRQ,
366         },
367         [2] = {
368                 .start  = gic_spi(84),
369                 .flags  = IORESOURCE_IRQ,
370         },
371         [3] = {
372                 .start  = gic_spi(85),
373                 .flags  = IORESOURCE_IRQ,
374         },
375 };
376
377 static struct platform_device sdhi0_device = {
378         .name           = "sh_mobile_sdhi",
379         .id             = 0,
380         .num_resources  = ARRAY_SIZE(sdhi0_resources),
381         .resource       = sdhi0_resources,
382         .dev    = {
383                 .platform_data  = &sdhi0_info,
384         },
385 };
386
387 /* SDHI1 */
388 static struct sh_mobile_sdhi_info sdhi1_info = {
389         .tmio_caps      = MMC_CAP_NONREMOVABLE | MMC_CAP_SDIO_IRQ,
390         .tmio_flags     = TMIO_MMC_WRPROTECT_DISABLE | TMIO_MMC_HAS_IDLE_WAIT,
391 };
392
393 static struct resource sdhi1_resources[] = {
394         [0] = {
395                 .name   = "SDHI1",
396                 .start  = 0xee120000,
397                 .end    = 0xee1200ff,
398                 .flags  = IORESOURCE_MEM,
399         },
400         [1] = {
401                 .start  = gic_spi(87),
402                 .flags  = IORESOURCE_IRQ,
403         },
404         [2] = {
405                 .start  = gic_spi(88),
406                 .flags  = IORESOURCE_IRQ,
407         },
408         [3] = {
409                 .start  = gic_spi(89),
410                 .flags  = IORESOURCE_IRQ,
411         },
412 };
413
414 static struct platform_device sdhi1_device = {
415         .name           = "sh_mobile_sdhi",
416         .id             = 1,
417         .num_resources  = ARRAY_SIZE(sdhi1_resources),
418         .resource       = sdhi1_resources,
419         .dev    = {
420                 .platform_data  = &sdhi1_info,
421         },
422 };
423
424 static struct platform_device *kota2_devices[] __initdata = {
425         &eth_device,
426         &keysc_device,
427         &gpio_keys_device,
428         &gpio_leds_device,
429         &leds_tpu12_device,
430         &leds_tpu41_device,
431         &leds_tpu21_device,
432         &leds_tpu30_device,
433         &mmcif_device,
434         &sdhi0_device,
435         &sdhi1_device,
436 };
437
438 static unsigned long pin_pullup_conf[] = {
439         PIN_CONF_PACKED(PIN_CONFIG_BIAS_PULL_UP, 0),
440 };
441
442 static const struct pinctrl_map kota2_pinctrl_map[] = {
443         /* KEYSC */
444         PIN_MAP_MUX_GROUP_DEFAULT("sh_keysc.0", "pfc-sh73a0",
445                                   "keysc_in8", "keysc"),
446         PIN_MAP_MUX_GROUP_DEFAULT("sh_keysc.0", "pfc-sh73a0",
447                                   "keysc_out04", "keysc"),
448         PIN_MAP_MUX_GROUP_DEFAULT("sh_keysc.0", "pfc-sh73a0",
449                                   "keysc_out5", "keysc"),
450         PIN_MAP_MUX_GROUP_DEFAULT("sh_keysc.0", "pfc-sh73a0",
451                                   "keysc_out6_0", "keysc"),
452         PIN_MAP_MUX_GROUP_DEFAULT("sh_keysc.0", "pfc-sh73a0",
453                                   "keysc_out7_0", "keysc"),
454         PIN_MAP_MUX_GROUP_DEFAULT("sh_keysc.0", "pfc-sh73a0",
455                                   "keysc_out8_0", "keysc"),
456         PIN_MAP_CONFIGS_GROUP_DEFAULT("sh_keysc.0", "pfc-sh73a0",
457                                       "keysc_in8", pin_pullup_conf),
458         /* MMCIF */
459         PIN_MAP_MUX_GROUP_DEFAULT("sh_mmcif.0", "pfc-sh73a0",
460                                   "mmc0_data8_0", "mmc0"),
461         PIN_MAP_MUX_GROUP_DEFAULT("sh_mmcif.0", "pfc-sh73a0",
462                                   "mmc0_ctrl_0", "mmc0"),
463         PIN_MAP_CONFIGS_PIN_DEFAULT("sh_mmcif.0", "pfc-sh73a0",
464                                     "PORT279", pin_pullup_conf),
465         PIN_MAP_CONFIGS_GROUP_DEFAULT("sh_mmcif.0", "pfc-sh73a0",
466                                       "mmc0_data8_0", pin_pullup_conf),
467         /* SCIFA2 (UART2) */
468         PIN_MAP_MUX_GROUP_DEFAULT("sh-sci.2", "pfc-sh73a0",
469                                   "scifa2_data_0", "scifa2"),
470         PIN_MAP_MUX_GROUP_DEFAULT("sh-sci.2", "pfc-sh73a0",
471                                   "scifa2_ctrl_0", "scifa2"),
472         /* SCIFA4 (UART1) */
473         PIN_MAP_MUX_GROUP_DEFAULT("sh-sci.4", "pfc-sh73a0",
474                                   "scifa4_data", "scifa4"),
475         PIN_MAP_MUX_GROUP_DEFAULT("sh-sci.4", "pfc-sh73a0",
476                                   "scifa4_ctrl", "scifa4"),
477         /* SCIFB (BT) */
478         PIN_MAP_MUX_GROUP_DEFAULT("sh-sci.8", "pfc-sh73a0",
479                                   "scifb_data_0", "scifb"),
480         PIN_MAP_MUX_GROUP_DEFAULT("sh-sci.8", "pfc-sh73a0",
481                                   "scifb_clk_0", "scifb"),
482         PIN_MAP_MUX_GROUP_DEFAULT("sh-sci.8", "pfc-sh73a0",
483                                   "scifb_ctrl_0", "scifb"),
484         /* SDHI0 (microSD) */
485         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-sh73a0",
486                                   "sdhi0_data4", "sdhi0"),
487         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-sh73a0",
488                                   "sdhi0_ctrl", "sdhi0"),
489         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-sh73a0",
490                                   "sdhi0_cd", "sdhi0"),
491         PIN_MAP_CONFIGS_GROUP_DEFAULT("sh_mobile_sdhi.0", "pfc-sh73a0",
492                                       "sdhi0_data4", pin_pullup_conf),
493         PIN_MAP_CONFIGS_PIN_DEFAULT("sh_mobile_sdhi.0", "pfc-sh73a0",
494                                     "PORT256", pin_pullup_conf),
495         PIN_MAP_CONFIGS_PIN_DEFAULT("sh_mobile_sdhi.0", "pfc-sh73a0",
496                                     "PORT251", pin_pullup_conf),
497         /* SDHI1 (BCM4330) */
498         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.1", "pfc-sh73a0",
499                                   "sdhi1_data4", "sdhi1"),
500         PIN_MAP_MUX_GROUP_DEFAULT("sh_mobile_sdhi.1", "pfc-sh73a0",
501                                   "sdhi1_ctrl", "sdhi1"),
502         PIN_MAP_CONFIGS_GROUP_DEFAULT("sh_mobile_sdhi.1", "pfc-sh73a0",
503                                       "sdhi1_data4", pin_pullup_conf),
504         PIN_MAP_CONFIGS_PIN_DEFAULT("sh_mobile_sdhi.1", "pfc-sh73a0",
505                                     "PORT263", pin_pullup_conf),
506 };
507
508 static void __init kota2_init(void)
509 {
510         regulator_register_always_on(0, "fixed-1.8V", fixed1v8_power_consumers,
511                                      ARRAY_SIZE(fixed1v8_power_consumers), 1800000);
512         regulator_register_always_on(1, "fixed-3.3V", fixed3v3_power_consumers,
513                                      ARRAY_SIZE(fixed3v3_power_consumers), 3300000);
514         regulator_register_fixed(2, dummy_supplies, ARRAY_SIZE(dummy_supplies));
515
516         pinctrl_register_mappings(kota2_pinctrl_map,
517                                   ARRAY_SIZE(kota2_pinctrl_map));
518         sh73a0_pinmux_init();
519
520         /* SMSC911X */
521         gpio_request(GPIO_FN_D0_NAF0, NULL);
522         gpio_request(GPIO_FN_D1_NAF1, NULL);
523         gpio_request(GPIO_FN_D2_NAF2, NULL);
524         gpio_request(GPIO_FN_D3_NAF3, NULL);
525         gpio_request(GPIO_FN_D4_NAF4, NULL);
526         gpio_request(GPIO_FN_D5_NAF5, NULL);
527         gpio_request(GPIO_FN_D6_NAF6, NULL);
528         gpio_request(GPIO_FN_D7_NAF7, NULL);
529         gpio_request(GPIO_FN_D8_NAF8, NULL);
530         gpio_request(GPIO_FN_D9_NAF9, NULL);
531         gpio_request(GPIO_FN_D10_NAF10, NULL);
532         gpio_request(GPIO_FN_D11_NAF11, NULL);
533         gpio_request(GPIO_FN_D12_NAF12, NULL);
534         gpio_request(GPIO_FN_D13_NAF13, NULL);
535         gpio_request(GPIO_FN_D14_NAF14, NULL);
536         gpio_request(GPIO_FN_D15_NAF15, NULL);
537         gpio_request(GPIO_FN_CS5A_, NULL);
538         gpio_request(GPIO_FN_WE0__FWE, NULL);
539         gpio_request_one(144, GPIOF_IN, NULL); /* PINTA2 */
540         gpio_request_one(145, GPIOF_OUT_INIT_HIGH, NULL); /* RESET */
541
542         /* MMCIF */
543         gpio_request_one(208, GPIOF_OUT_INIT_HIGH, NULL); /* Reset */
544
545 #ifdef CONFIG_CACHE_L2X0
546         /* Early BRESP enable, Shared attribute override enable, 64K*8way */
547         l2x0_init(IOMEM(0xf0100000), 0x40460000, 0x82000fff);
548 #endif
549         sh73a0_add_standard_devices();
550         platform_add_devices(kota2_devices, ARRAY_SIZE(kota2_devices));
551 }
552
553 MACHINE_START(KOTA2, "kota2")
554         .smp            = smp_ops(sh73a0_smp_ops),
555         .map_io         = sh73a0_map_io,
556         .init_early     = sh73a0_add_early_devices,
557         .nr_irqs        = NR_IRQS_LEGACY,
558         .init_irq       = sh73a0_init_irq,
559         .init_machine   = kota2_init,
560         .init_late      = shmobile_init_late,
561         .init_time      = sh73a0_earlytimer_init,
562 MACHINE_END