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