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