rtc: tps80031: register as mfd sub device
[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 struct tegra_asoc_platform_data harmony_audio_pdata = {
227         .gpio_spkr_en           = TEGRA_GPIO_SPKR_EN,
228         .gpio_hp_det            = TEGRA_GPIO_HP_DET,
229         .gpio_hp_mute           = -1,
230         .gpio_int_mic_en        = TEGRA_GPIO_INT_MIC_EN,
231         .gpio_ext_mic_en        = TEGRA_GPIO_EXT_MIC_EN,
232         .i2s_param[HIFI_CODEC]  = {
233                 .audio_port_id  = 0,
234                 .is_i2s_master  = 1,
235                 .i2s_mode       = TEGRA_DAIFMT_I2S,
236         },
237         .i2s_param[BASEBAND]    = {
238                 .audio_port_id  = -1,
239         },
240         .i2s_param[BT_SCO]      = {
241                 .audio_port_id  = 3,
242                 .is_i2s_master  = 1,
243                 .i2s_mode       = TEGRA_DAIFMT_DSP_A,
244         },
245 };
246
247 static struct platform_device harmony_audio_device = {
248         .name   = "tegra-snd-wm8903",
249         .id     = 0,
250         .dev    = {
251                 .platform_data  = &harmony_audio_pdata,
252         },
253 };
254
255 static struct tegra_i2c_platform_data harmony_i2c1_platform_data = {
256         .adapter_nr     = 0,
257         .bus_count      = 1,
258         .bus_clk_rate   = { 400000, 0 },
259 };
260
261 static const struct tegra_pingroup_config i2c2_ddc = {
262         .pingroup       = TEGRA_PINGROUP_DDC,
263         .func           = TEGRA_MUX_I2C2,
264 };
265
266 static const struct tegra_pingroup_config i2c2_gen2 = {
267         .pingroup       = TEGRA_PINGROUP_PTA,
268         .func           = TEGRA_MUX_I2C2,
269 };
270
271 static struct tegra_i2c_platform_data harmony_i2c2_platform_data = {
272         .adapter_nr     = 1,
273         .bus_count      = 2,
274         .bus_clk_rate   = { 100000, 100000 },
275         .bus_mux        = { &i2c2_ddc, &i2c2_gen2 },
276         .bus_mux_len    = { 1, 1 },
277 };
278
279 static struct tegra_i2c_platform_data harmony_i2c3_platform_data = {
280         .adapter_nr     = 3,
281         .bus_count      = 1,
282         .bus_clk_rate   = { 400000, 0 },
283 };
284
285 static struct tegra_i2c_platform_data harmony_dvc_platform_data = {
286         .adapter_nr     = 4,
287         .bus_count      = 1,
288         .bus_clk_rate   = { 400000, 0 },
289         .is_dvc         = true,
290 };
291
292 static struct wm8903_platform_data harmony_wm8903_pdata = {
293         .irq_active_low = 0,
294         .micdet_cfg = 0,
295         .micdet_delay = 100,
296         .gpio_base = HARMONY_GPIO_WM8903(0),
297         .gpio_cfg = {
298                 WM8903_GPIO_NO_CONFIG,
299                 WM8903_GPIO_NO_CONFIG,
300                 0,
301                 WM8903_GPIO_NO_CONFIG,
302                 WM8903_GPIO_NO_CONFIG,
303         },
304 };
305
306 static struct i2c_board_info __initdata wm8903_board_info = {
307         I2C_BOARD_INFO("wm8903", 0x1a),
308         .platform_data = &harmony_wm8903_pdata,
309         .irq = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_CDC_IRQ),
310 };
311
312 static void __init harmony_i2c_init(void)
313 {
314         tegra_i2c_device1.dev.platform_data = &harmony_i2c1_platform_data;
315         tegra_i2c_device2.dev.platform_data = &harmony_i2c2_platform_data;
316         tegra_i2c_device3.dev.platform_data = &harmony_i2c3_platform_data;
317         tegra_i2c_device4.dev.platform_data = &harmony_dvc_platform_data;
318
319         platform_device_register(&tegra_i2c_device1);
320         platform_device_register(&tegra_i2c_device2);
321         platform_device_register(&tegra_i2c_device3);
322         platform_device_register(&tegra_i2c_device4);
323
324         i2c_register_board_info(0, &wm8903_board_info, 1);
325 }
326
327
328 /* PDA power */
329 static struct pda_power_pdata pda_power_pdata = {
330 };
331
332 static struct platform_device pda_power_device = {
333         .name   = "pda_power",
334         .id     = -1,
335         .dev    = {
336                 .platform_data  = &pda_power_pdata,
337         },
338 };
339
340 static struct platform_device *harmony_uart_devices[] __initdata = {
341         &tegra_uartd_device,
342 };
343
344 static struct uart_clk_parent uart_parent_clk[] __initdata = {
345         [0] = {.name = "pll_p"},
346         [1] = {.name = "pll_m"},
347         [2] = {.name = "clk_m"},
348 };
349
350 static struct tegra_uart_platform_data harmony_uart_pdata;
351
352 static void __init uart_debug_init(void)
353 {
354         unsigned long rate;
355         struct clk *c;
356
357         /* UARTD is the debug port. */
358         pr_info("Selecting UARTD as the debug console\n");
359         harmony_uart_devices[0] = &debug_uartd_device;
360         debug_uart_port_base = ((struct plat_serial8250_port *)(
361                         debug_uartd_device.dev.platform_data))->mapbase;
362         debug_uart_clk = clk_get_sys("serial8250.0", "uartd");
363
364         /* Clock enable for the debug channel */
365         if (!IS_ERR_OR_NULL(debug_uart_clk)) {
366                 rate = ((struct plat_serial8250_port *)(
367                         debug_uartd_device.dev.platform_data))->uartclk;
368                 pr_info("The debug console clock name is %s\n",
369                                                 debug_uart_clk->name);
370                 c = tegra_get_clock_by_name("pll_p");
371                 if (IS_ERR_OR_NULL(c))
372                         pr_err("Not getting the parent clock pll_p\n");
373                 else
374                         clk_set_parent(debug_uart_clk, c);
375
376                 clk_enable(debug_uart_clk);
377                 clk_set_rate(debug_uart_clk, rate);
378         } else {
379                 pr_err("Not getting the clock %s for debug console\n",
380                                         debug_uart_clk->name);
381         }
382 }
383
384 static void __init harmony_uart_init(void)
385 {
386         int i;
387         struct clk *c;
388
389         for (i = 0; i < ARRAY_SIZE(uart_parent_clk); ++i) {
390                 c = tegra_get_clock_by_name(uart_parent_clk[i].name);
391                 if (IS_ERR_OR_NULL(c)) {
392                         pr_err("Not able to get the clock for %s\n",
393                                                 uart_parent_clk[i].name);
394                         continue;
395                 }
396                 uart_parent_clk[i].parent_clk = c;
397                 uart_parent_clk[i].fixed_clk_rate = clk_get_rate(c);
398         }
399         harmony_uart_pdata.parent_clk_list = uart_parent_clk;
400         harmony_uart_pdata.parent_clk_count = ARRAY_SIZE(uart_parent_clk);
401         tegra_uartd_device.dev.platform_data = &harmony_uart_pdata;
402
403         /* Register low speed only if it is selected */
404         if (!is_tegra_debug_uartport_hs())
405                 uart_debug_init();
406
407         platform_add_devices(harmony_uart_devices,
408                                 ARRAY_SIZE(harmony_uart_devices));
409 }
410
411 static struct platform_device *harmony_devices[] __initdata = {
412         &tegra_sdhci_device1,
413         &tegra_sdhci_device2,
414         &tegra_sdhci_device4,
415         &tegra_i2s_device1,
416         &tegra_i2s_device2,
417         &tegra_spdif_device,
418         &tegra_das_device,
419         &spdif_dit_device,
420         &bluetooth_dit_device,
421         &tegra_pcm_device,
422         &harmony_audio_device,
423         &tegra_pmu_device,
424         &tegra_nand_device,
425         &tegra_udc_device,
426         &harmony_gpio_keys_device,
427         &pda_power_device,
428         &tegra_ehci3_device,
429         &tegra_spi_device1,
430         &tegra_spi_device2,
431         &tegra_spi_device3,
432         &tegra_spi_device4,
433         &tegra_gart_device,
434         &tegra_avp_device,
435 };
436
437 static void __init tegra_harmony_fixup(struct machine_desc *desc,
438         struct tag *tags, char **cmdline, struct meminfo *mi)
439 {
440         mi->nr_banks = 2;
441         mi->bank[0].start = PHYS_OFFSET;
442         mi->bank[0].size = 448 * SZ_1M;
443         mi->bank[1].start = SZ_512M;
444         mi->bank[1].size = SZ_512M;
445 }
446
447 static __initdata struct tegra_clk_init_table harmony_clk_init_table[] = {
448         /* name         parent          rate            enabled */
449         { "uartd",      "pll_p",        216000000,      true },
450         { "i2s1",       "pll_a_out0",   0,              false},
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                 /* toggle in this order as per spec */
496                 gpio_direction_output(TEGRA_GPIO_WLAN_PWR_LOW, 0);
497                 gpio_direction_output(TEGRA_GPIO_WLAN_RST_LOW, 0);
498                 udelay(5);
499                 gpio_direction_output(TEGRA_GPIO_WLAN_PWR_LOW, 1);
500                 gpio_direction_output(TEGRA_GPIO_WLAN_RST_LOW, 1);
501         }
502
503         return 0;
504 }
505
506 /*
507  * subsys_initcall_sync is good synch point to call harmony_wifi_init
508  * This makes sure that the required regulators (LDO3
509  * supply of external PMU and 1.2V regulator) are properly enabled,
510  * and mmc driver has not yet probed for a device on SDIO bus.
511  */
512 subsys_initcall_sync(harmony_wifi_prepower);
513 #endif
514
515 static void __init tegra_harmony_init(void)
516 {
517         tegra_clk_init_from_table(harmony_clk_init_table);
518
519         harmony_pinmux_init();
520
521         harmony_uart_init();
522
523         tegra_sdhci_device1.dev.platform_data = &sdhci_pdata1;
524         tegra_sdhci_device2.dev.platform_data = &sdhci_pdata2;
525         tegra_sdhci_device4.dev.platform_data = &sdhci_pdata4;
526
527         tegra_udc_device.dev.platform_data = &tegra_udc_pdata;
528         tegra_ehci3_device.dev.platform_data = &tegra_ehci3_utmi_pdata;
529
530         platform_add_devices(harmony_devices, ARRAY_SIZE(harmony_devices));
531         harmony_i2c_init();
532         harmony_regulator_init();
533         harmony_suspend_init();
534         harmony_panel_init();
535 #ifdef CONFIG_KEYBOARD_TEGRA
536         harmony_kbc_init();
537 #endif
538         harmony_pcie_init();
539 }
540
541 void __init tegra_harmony_reserve(void)
542 {
543         if (memblock_reserve(0x0, 4096) < 0)
544                 pr_warn("Cannot reserve first 4K of memory for safety\n");
545
546         tegra_reserve(SZ_128M, SZ_8M, SZ_16M);
547 }
548
549 MACHINE_START(HARMONY, "harmony")
550         .boot_params  = 0x00000100,
551         .fixup          = tegra_harmony_fixup,
552         .map_io         = tegra_map_common_io,
553         .reserve        = tegra_harmony_reserve,
554         .init_early     = tegra_init_early,
555         .init_irq       = tegra_init_irq,
556         .timer          = &tegra_timer,
557         .init_machine   = tegra_harmony_init,
558 MACHINE_END