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