ARM: tegra: integration of slave mode support.
[linux-2.6.git] / arch / arm / mach-tegra / board-harmony.c
1 /*
2  * arch/arm/mach-tegra/board-harmony.c
3  *
4  * Copyright (C) 2010 Google, Inc.
5  * Copyright (C) 2011 NVIDIA, Inc.
6  * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
7  *
8  * This software is licensed under the terms of the GNU General Public
9  * License version 2, as published by the Free Software Foundation, and
10  * may be copied, distributed, and modified under those terms.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  */
18
19 #include <linux/kernel.h>
20 #include <linux/init.h>
21 #include <linux/platform_device.h>
22 #include <linux/serial_8250.h>
23 #include <linux/clk.h>
24 #include <linux/mtd/mtd.h>
25 #include <linux/mtd/partitions.h>
26 #include <linux/dma-mapping.h>
27 #include <linux/pda_power.h>
28 #include <linux/input.h>
29 #include <linux/io.h>
30 #include <linux/gpio.h>
31 #include <linux/gpio_keys.h>
32 #include <linux/i2c.h>
33 #include <linux/i2c-tegra.h>
34 #include <linux/memblock.h>
35 #include <linux/delay.h>
36 #include <linux/mfd/tps6586x.h>
37 #include <linux/platform_data/tegra_usb.h>
38 #include <linux/tegra_uart.h>
39
40 #include <sound/wm8903.h>
41
42 #include <asm/mach-types.h>
43 #include <asm/mach/arch.h>
44 #include <asm/mach/time.h>
45 #include <asm/hardware/gic.h>
46 #include <asm/setup.h>
47
48 #include <mach/tegra_asoc_pdata.h>
49 #include <mach/iomap.h>
50 #include <mach/irqs.h>
51 #include <mach/sdhci.h>
52 #include <mach/nand.h>
53 #include <mach/clk.h>
54 #include <mach/usb_phy.h>
55 #include <mach/pinmux-tegra20.h>
56
57 #include "clock.h"
58 #include "board.h"
59 #include "board-harmony.h"
60 #include "clock.h"
61 #include "devices.h"
62 #include "gpio-names.h"
63 #include "pm.h"
64 #include "common.h"
65
66 /* NVidia bootloader tags */
67 #define ATAG_NVIDIA             0x41000801
68
69 #define ATAG_NVIDIA_RM                  0x1
70 #define ATAG_NVIDIA_DISPLAY             0x2
71 #define ATAG_NVIDIA_FRAMEBUFFER         0x3
72 #define ATAG_NVIDIA_CHIPSHMOO           0x4
73 #define ATAG_NVIDIA_CHIPSHMOOPHYS       0x5
74 #define ATAG_NVIDIA_PRESERVED_MEM_0     0x10000
75 #define ATAG_NVIDIA_PRESERVED_MEM_N     2
76 #define ATAG_NVIDIA_FORCE_32            0x7fffffff
77
78 struct tag_tegra {
79         __u32 bootarg_key;
80         __u32 bootarg_len;
81         char bootarg[1];
82 };
83
84 static int __init parse_tag_nvidia(const struct tag *tag)
85 {
86
87         return 0;
88 }
89 __tagtable(ATAG_NVIDIA, parse_tag_nvidia);
90
91
92 static struct tegra_usb_platform_data tegra_udc_pdata = {
93         .port_otg = false,
94         .has_hostpc = false,
95         .phy_intf = TEGRA_USB_PHY_INTF_UTMI,
96         .op_mode = TEGRA_USB_OPMODE_DEVICE,
97         .u_data.dev = {
98                 .vbus_pmu_irq = 0,
99                 .vbus_gpio = -1,
100                 .charging_supported = false,
101                 .remote_wakeup_supported = false,
102         },
103         .u_cfg.utmi = {
104                 .hssync_start_delay = 0,
105                 .elastic_limit = 16,
106                 .idle_wait_delay = 17,
107                 .term_range_adj = 6,
108                 .xcvr_setup = 8,
109                 .xcvr_lsfslew = 2,
110                 .xcvr_lsrslew = 2,
111                 .xcvr_setup_offset = 0,
112                 .xcvr_use_fuses = 1,
113         },
114 };
115
116 static struct tegra_usb_platform_data tegra_ehci3_utmi_pdata = {
117         .port_otg = false,
118         .has_hostpc = false,
119         .phy_intf = TEGRA_USB_PHY_INTF_UTMI,
120         .op_mode        = TEGRA_USB_OPMODE_HOST,
121         .u_data.host = {
122                 .vbus_gpio = TEGRA_GPIO_PD3,
123                 .vbus_reg = NULL,
124                 .hot_plug = true,
125                 .remote_wakeup_supported = false,
126                 .power_off_on_suspend = true,
127         },
128         .u_cfg.utmi = {
129                 .hssync_start_delay = 9,
130                 .elastic_limit = 16,
131                 .idle_wait_delay = 17,
132                 .term_range_adj = 6,
133                 .xcvr_setup = 8,
134                 .xcvr_lsfslew = 2,
135                 .xcvr_lsrslew = 2,
136         },
137 };
138
139 static struct tegra_nand_chip_parms nand_chip_parms[] = {
140         /* Samsung K5E2G1GACM */
141         [0] = {
142                .vendor_id = 0xEC,
143                .device_id = 0xAA,
144                .read_id_fourth_byte = 0x15,
145                .capacity  = 256,
146                .timing = {
147                           .trp = 21,
148                           .trh = 15,
149                           .twp = 21,
150                           .twh = 15,
151                           .tcs = 31,
152                           .twhr = 60,
153                           .tcr_tar_trr = 20,
154                           .twb = 100,
155                           .trp_resp = 30,
156                           .tadl = 100,
157                           },
158                },
159         /* Hynix H5PS1GB3EFR */
160         [1] = {
161                .vendor_id = 0xAD,
162                .device_id = 0xDC,
163                .read_id_fourth_byte = 0x95,
164                .capacity  = 512,
165                .timing = {
166                           .trp = 12,
167                           .trh = 10,
168                           .twp = 12,
169                           .twh = 10,
170                           .tcs = 20,
171                           .twhr = 80,
172                           .tcr_tar_trr = 20,
173                           .twb = 100,
174                           .trp_resp = 20,
175                           .tadl = 70,
176                           },
177                },
178 };
179
180 struct tegra_nand_platform harmony_nand_data = {
181         .max_chips = 8,
182         .chip_parms = nand_chip_parms,
183         .nr_chip_parms = ARRAY_SIZE(nand_chip_parms),
184         .wp_gpio = TEGRA_GPIO_PC7,
185 };
186
187 static struct resource resources_nand[] = {
188         [0] = {
189                .start = INT_NANDFLASH,
190                .end = INT_NANDFLASH,
191                .flags = IORESOURCE_IRQ,
192                },
193 };
194
195 struct platform_device tegra_nand_device = {
196         .name = "tegra_nand",
197         .id = -1,
198         .num_resources = ARRAY_SIZE(resources_nand),
199         .resource = resources_nand,
200         .dev = {
201                 .platform_data = &harmony_nand_data,
202                 },
203 };
204
205 static struct gpio_keys_button harmony_gpio_keys_buttons[] = {
206         {
207                 .code           = KEY_POWER,
208                 .gpio           = TEGRA_GPIO_POWERKEY,
209                 .active_low     = 1,
210                 .desc           = "Power",
211                 .type           = EV_KEY,
212                 .wakeup         = 1,
213         },
214 };
215
216 static struct gpio_keys_platform_data harmony_gpio_keys = {
217         .buttons        = harmony_gpio_keys_buttons,
218         .nbuttons       = ARRAY_SIZE(harmony_gpio_keys_buttons),
219 };
220
221 static struct platform_device harmony_gpio_keys_device = {
222         .name           = "gpio-keys",
223         .id             = -1,
224         .dev            = {
225                 .platform_data = &harmony_gpio_keys,
226         }
227 };
228
229 static void harmony_keys_init(void)
230 {
231         int i;
232
233         for (i = 0; i < ARRAY_SIZE(harmony_gpio_keys_buttons); i++)
234                 tegra_gpio_enable(harmony_gpio_keys_buttons[i].gpio);
235 }
236
237 static struct tegra_asoc_platform_data harmony_audio_pdata = {
238         .gpio_spkr_en           = TEGRA_GPIO_SPKR_EN,
239         .gpio_hp_det            = TEGRA_GPIO_HP_DET,
240         .gpio_hp_mute           = -1,
241         .gpio_int_mic_en        = TEGRA_GPIO_INT_MIC_EN,
242         .gpio_ext_mic_en        = TEGRA_GPIO_EXT_MIC_EN,
243         .i2s_param[HIFI_CODEC]  = {
244                 .audio_port_id  = 0,
245                 .is_i2s_master  = 1,
246                 .i2s_mode       = TEGRA_DAIFMT_I2S,
247         },
248         .i2s_param[BASEBAND]    = {
249                 .audio_port_id  = -1,
250         },
251         .i2s_param[BT_SCO]      = {
252                 .audio_port_id  = 3,
253                 .is_i2s_master  = 1,
254                 .i2s_mode       = TEGRA_DAIFMT_DSP_A,
255         },
256 };
257
258 static struct platform_device harmony_audio_device = {
259         .name   = "tegra-snd-wm8903",
260         .id     = 0,
261         .dev    = {
262                 .platform_data  = &harmony_audio_pdata,
263         },
264 };
265
266 static struct tegra_i2c_platform_data harmony_i2c1_platform_data = {
267         .adapter_nr     = 0,
268         .bus_count      = 1,
269         .bus_clk_rate   = { 400000, 0 },
270 };
271
272 static const struct tegra_pingroup_config i2c2_ddc = {
273         .pingroup       = TEGRA_PINGROUP_DDC,
274         .func           = TEGRA_MUX_I2C2,
275 };
276
277 static const struct tegra_pingroup_config i2c2_gen2 = {
278         .pingroup       = TEGRA_PINGROUP_PTA,
279         .func           = TEGRA_MUX_I2C2,
280 };
281
282 static struct tegra_i2c_platform_data harmony_i2c2_platform_data = {
283         .adapter_nr     = 1,
284         .bus_count      = 2,
285         .bus_clk_rate   = { 100000, 100000 },
286         .bus_mux        = { &i2c2_ddc, &i2c2_gen2 },
287         .bus_mux_len    = { 1, 1 },
288 };
289
290 static struct tegra_i2c_platform_data harmony_i2c3_platform_data = {
291         .adapter_nr     = 3,
292         .bus_count      = 1,
293         .bus_clk_rate   = { 400000, 0 },
294 };
295
296 static struct tegra_i2c_platform_data harmony_dvc_platform_data = {
297         .adapter_nr     = 4,
298         .bus_count      = 1,
299         .bus_clk_rate   = { 400000, 0 },
300         .is_dvc         = true,
301 };
302
303 static struct wm8903_platform_data harmony_wm8903_pdata = {
304         .irq_active_low = 0,
305         .micdet_cfg = 0,
306         .micdet_delay = 100,
307         .gpio_base = HARMONY_GPIO_WM8903(0),
308         .gpio_cfg = {
309                 0,
310                 0,
311                 WM8903_GPIO_CONFIG_ZERO,
312                 0,
313                 0,
314         },
315 };
316
317 static struct i2c_board_info __initdata wm8903_board_info = {
318         I2C_BOARD_INFO("wm8903", 0x1a),
319         .platform_data = &harmony_wm8903_pdata,
320 };
321
322 static void __init harmony_i2c_init(void)
323 {
324         tegra_i2c_device1.dev.platform_data = &harmony_i2c1_platform_data;
325         tegra_i2c_device2.dev.platform_data = &harmony_i2c2_platform_data;
326         tegra_i2c_device3.dev.platform_data = &harmony_i2c3_platform_data;
327         tegra_i2c_device4.dev.platform_data = &harmony_dvc_platform_data;
328
329         platform_device_register(&tegra_i2c_device1);
330         platform_device_register(&tegra_i2c_device2);
331         platform_device_register(&tegra_i2c_device3);
332         platform_device_register(&tegra_i2c_device4);
333
334         wm8903_board_info.irq = gpio_to_irq(TEGRA_GPIO_CDC_IRQ);
335         i2c_register_board_info(0, &wm8903_board_info, 1);
336 }
337
338
339 /* PDA power */
340 static struct pda_power_pdata pda_power_pdata = {
341 };
342
343 static struct platform_device pda_power_device = {
344         .name   = "pda_power",
345         .id     = -1,
346         .dev    = {
347                 .platform_data  = &pda_power_pdata,
348         },
349 };
350
351 static struct platform_device *harmony_uart_devices[] __initdata = {
352         &tegra_uartd_device,
353 };
354
355 static struct uart_clk_parent uart_parent_clk[] __initdata = {
356         [0] = {.name = "pll_p"},
357         [1] = {.name = "pll_m"},
358         [2] = {.name = "clk_m"},
359 };
360
361 static struct tegra_uart_platform_data harmony_uart_pdata;
362
363 static void __init uart_debug_init(void)
364 {
365         unsigned long rate;
366         struct clk *c;
367
368         /* UARTD is the debug port. */
369         pr_info("Selecting UARTD as the debug console\n");
370         harmony_uart_devices[0] = &debug_uartd_device;
371         debug_uart_port_base = ((struct plat_serial8250_port *)(
372                         debug_uartd_device.dev.platform_data))->mapbase;
373         debug_uart_clk = clk_get_sys("serial8250.0", "uartd");
374
375         /* Clock enable for the debug channel */
376         if (!IS_ERR_OR_NULL(debug_uart_clk)) {
377                 rate = ((struct plat_serial8250_port *)(
378                         debug_uartd_device.dev.platform_data))->uartclk;
379                 pr_info("The debug console clock name is %s\n",
380                                                 debug_uart_clk->name);
381                 c = tegra_get_clock_by_name("pll_p");
382                 if (IS_ERR_OR_NULL(c))
383                         pr_err("Not getting the parent clock pll_p\n");
384                 else
385                         clk_set_parent(debug_uart_clk, c);
386
387                 clk_enable(debug_uart_clk);
388                 clk_set_rate(debug_uart_clk, rate);
389         } else {
390                 pr_err("Not getting the clock %s for debug console\n",
391                                         debug_uart_clk->name);
392         }
393 }
394
395 static void __init harmony_uart_init(void)
396 {
397         int i;
398         struct clk *c;
399
400         for (i = 0; i < ARRAY_SIZE(uart_parent_clk); ++i) {
401                 c = tegra_get_clock_by_name(uart_parent_clk[i].name);
402                 if (IS_ERR_OR_NULL(c)) {
403                         pr_err("Not able to get the clock for %s\n",
404                                                 uart_parent_clk[i].name);
405                         continue;
406                 }
407                 uart_parent_clk[i].parent_clk = c;
408                 uart_parent_clk[i].fixed_clk_rate = clk_get_rate(c);
409         }
410         harmony_uart_pdata.parent_clk_list = uart_parent_clk;
411         harmony_uart_pdata.parent_clk_count = ARRAY_SIZE(uart_parent_clk);
412         tegra_uartd_device.dev.platform_data = &harmony_uart_pdata;
413
414         /* Register low speed only if it is selected */
415         if (!is_tegra_debug_uartport_hs())
416                 uart_debug_init();
417
418         platform_add_devices(harmony_uart_devices,
419                                 ARRAY_SIZE(harmony_uart_devices));
420 }
421
422 static struct platform_device *harmony_devices[] __initdata = {
423         &tegra_sdhci_device1,
424         &tegra_sdhci_device2,
425         &tegra_sdhci_device4,
426         &tegra_ehci3_device,
427         &tegra_i2s_device1,
428         &tegra_i2s_device2,
429         &tegra_spdif_device,
430         &tegra_das_device,
431         &spdif_dit_device,
432         &bluetooth_dit_device,
433         &tegra_pcm_device,
434         &harmony_audio_device,
435         &tegra_pmu_device,
436         &tegra_nand_device,
437         &tegra_udc_device,
438         &harmony_gpio_keys_device,
439         &pda_power_device,
440         &tegra_ehci3_device,
441         &tegra_spi_device1,
442         &tegra_spi_device2,
443         &tegra_spi_device3,
444         &tegra_spi_device4,
445         &tegra_gart_device,
446         &tegra_avp_device,
447         &tegra_emc_device,
448 };
449
450 static void __init tegra_harmony_fixup(struct tag *tags, char **cmdline,
451         struct meminfo *mi)
452 {
453         mi->nr_banks = 2;
454         mi->bank[0].start = PHYS_OFFSET;
455         mi->bank[0].size = 448 * SZ_1M;
456         mi->bank[1].start = SZ_512M;
457         mi->bank[1].size = SZ_512M;
458 }
459
460 static __initdata struct tegra_clk_init_table harmony_clk_init_table[] = {
461         /* name         parent          rate            enabled */
462         { "uartd",      "pll_p",        216000000,      true },
463         { "i2s1",       "pll_a_out0",   0,              false},
464         { "usb3",       "clk_m",        12000000,       true },
465         { "spdif_out",  "pll_a_out0",   0,              false},
466         { "sdmmc1",     "clk_m",        48000000,       true },
467         { "sdmmc2",     "clk_m",        48000000,       true },
468         { "sdmmc4",     "clk_m",        48000000,       true },
469         { "ndflash",    "pll_p",        108000000,      true},
470         { "pwm",        "clk_32k",      32768,          false},
471         { NULL,         NULL,           0,              0},
472 };
473
474
475 static struct tegra_sdhci_platform_data sdhci_pdata1 = {
476         .cd_gpio        = -1,
477         .wp_gpio        = -1,
478         .power_gpio     = -1,
479 };
480
481 static struct tegra_sdhci_platform_data sdhci_pdata2 = {
482         .cd_gpio        = TEGRA_GPIO_SD2_CD,
483         .wp_gpio        = TEGRA_GPIO_SD2_WP,
484         .power_gpio     = TEGRA_GPIO_SD2_POWER,
485 };
486
487 static struct tegra_sdhci_platform_data sdhci_pdata4 = {
488         .cd_gpio        = TEGRA_GPIO_SD4_CD,
489         .wp_gpio        = TEGRA_GPIO_SD4_WP,
490         .power_gpio     = TEGRA_GPIO_SD4_POWER,
491         .is_8bit        = 1,
492 };
493
494 #ifdef CONFIG_TEGRA_PREPOWER_WIFI
495 static int __init harmony_wifi_prepower(void)
496 {
497         int gpio_pwr, gpio_rst;
498
499         if (!machine_is_harmony())
500                 return 0;
501
502         /* WLAN - Power up (low) and Reset (low) */
503         gpio_pwr = gpio_request(TEGRA_GPIO_WLAN_PWR_LOW, "wlan_pwr");
504         gpio_rst = gpio_request(TEGRA_GPIO_WLAN_RST_LOW, "wlan_rst");
505         if (gpio_pwr < 0 || gpio_rst < 0)
506                 pr_warning("Unable to get gpio for WLAN Power and Reset\n");
507         else {
508
509                 tegra_gpio_enable(TEGRA_GPIO_WLAN_PWR_LOW);
510                 tegra_gpio_enable(TEGRA_GPIO_WLAN_RST_LOW);
511                 /* toggle in this order as per spec */
512                 gpio_direction_output(TEGRA_GPIO_WLAN_PWR_LOW, 0);
513                 gpio_direction_output(TEGRA_GPIO_WLAN_RST_LOW, 0);
514                 udelay(5);
515                 gpio_direction_output(TEGRA_GPIO_WLAN_PWR_LOW, 1);
516                 gpio_direction_output(TEGRA_GPIO_WLAN_RST_LOW, 1);
517         }
518
519         return 0;
520 }
521
522 /*
523  * subsys_initcall_sync is good synch point to call harmony_wifi_init
524  * This makes sure that the required regulators (LDO3
525  * supply of external PMU and 1.2V regulator) are properly enabled,
526  * and mmc driver has not yet probed for a device on SDIO bus.
527  */
528 subsys_initcall_sync(harmony_wifi_prepower);
529 #endif
530
531 static void __init tegra_harmony_init(void)
532 {
533         tegra_clk_init_from_table(harmony_clk_init_table);
534
535         harmony_pinmux_init();
536
537         harmony_keys_init();
538
539         harmony_uart_init();
540
541         tegra_sdhci_device1.dev.platform_data = &sdhci_pdata1;
542         tegra_sdhci_device2.dev.platform_data = &sdhci_pdata2;
543         tegra_sdhci_device4.dev.platform_data = &sdhci_pdata4;
544
545         tegra_udc_device.dev.platform_data = &tegra_udc_pdata;
546         tegra_ehci3_device.dev.platform_data = &tegra_ehci3_utmi_pdata;
547
548         platform_add_devices(harmony_devices, ARRAY_SIZE(harmony_devices));
549         harmony_i2c_init();
550         harmony_regulator_init();
551         harmony_suspend_init();
552         harmony_panel_init();
553 #ifdef CONFIG_KEYBOARD_TEGRA
554         harmony_kbc_init();
555 #endif
556 #ifdef CONFIG_TEGRA_PCI
557         harmony_pcie_init();
558 #endif
559 }
560
561 void __init tegra_harmony_reserve(void)
562 {
563         if (memblock_reserve(0x0, 4096) < 0)
564                 pr_warn("Cannot reserve first 4K of memory for safety\n");
565
566         tegra_reserve(SZ_128M, SZ_8M, SZ_16M);
567 }
568
569 MACHINE_START(HARMONY, "harmony")
570         .atag_offset    = 0x100,
571         .soc            = &tegra_soc_desc,
572         .fixup          = tegra_harmony_fixup,
573         .map_io         = tegra_map_common_io,
574         .reserve        = tegra_harmony_reserve,
575         .init_early     = tegra20_init_early,
576         .init_irq       = tegra_init_irq,
577         .handle_irq     = gic_handle_irq,
578         .timer          = &tegra_timer,
579         .init_machine   = tegra_harmony_init,
580         .restart        = tegra_assert_system_reset,
581 MACHINE_END