37debb70c4494848b29aa25281396817df4320ce
[linux-2.6.git] / arch / arm / mach-tegra / board-cardhu.c
1 /*
2  * arch/arm/mach-tegra/board-cardhu.c
3  *
4  * Copyright (c) 2011-2012, NVIDIA Corporation.  All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14  * more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with this program; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/ctype.h>
25 #include <linux/platform_device.h>
26 #include <linux/clk.h>
27 #include <linux/serial_8250.h>
28 #include <linux/i2c.h>
29 #include <linux/i2c/panjit_ts.h>
30 #include <linux/dma-mapping.h>
31 #include <linux/delay.h>
32 #include <linux/i2c-tegra.h>
33 #include <linux/gpio.h>
34 #include <linux/input.h>
35 #include <linux/platform_data/tegra_usb.h>
36 #include <linux/spi/spi.h>
37 #include <linux/i2c/atmel_mxt_ts.h>
38 #include <linux/tegra_uart.h>
39 #include <linux/memblock.h>
40 #include <linux/spi-tegra.h>
41 #include <linux/nfc/pn544.h>
42 #include <linux/rfkill-gpio.h>
43
44 #include <sound/wm8903.h>
45 #include <sound/max98095.h>
46 #include <media/tegra_dtv.h>
47
48 #include <asm/hardware/gic.h>
49
50 #include <mach/clk.h>
51 #include <mach/iomap.h>
52 #include <mach/irqs.h>
53 #include <mach/pinmux.h>
54 #include <mach/iomap.h>
55 #include <mach/io_dpd.h>
56 #include <mach/io.h>
57 #include <mach/i2s.h>
58 #include <mach/tegra_asoc_pdata.h>
59 #include <mach/tegra_wm8903_pdata.h>
60 #include <mach/usb_phy.h>
61 #include <mach/thermal.h>
62 #include <mach/pci.h>
63 #include <mach/gpio-tegra.h>
64 #include <mach/tegra_fiq_debugger.h>
65
66 #include <asm/hardware/gic.h>
67 #include <asm/mach-types.h>
68 #include <asm/mach/arch.h>
69
70 #include "board.h"
71 #include "clock.h"
72 #include "board-cardhu.h"
73 #include "board-touch.h"
74 #include "devices.h"
75 #include "gpio-names.h"
76 #include "fuse.h"
77 #include "pm.h"
78 #include "baseband-xmm-power.h"
79 #include "wdt-recovery.h"
80 #include "common.h"
81
82 static struct balanced_throttle throttle_list[] = {
83 #ifdef CONFIG_TEGRA_THERMAL_THROTTLE
84         {
85                 .id = BALANCED_THROTTLE_ID_TJ,
86                 .throt_tab_size = 10,
87                 .throt_tab = {
88                         {      0, 1000 },
89                         { 640000, 1000 },
90                         { 640000, 1000 },
91                         { 640000, 1000 },
92                         { 640000, 1000 },
93                         { 640000, 1000 },
94                         { 760000, 1000 },
95                         { 760000, 1050 },
96                         {1000000, 1050 },
97                         {1000000, 1100 },
98                 },
99         },
100 #endif
101 #ifdef CONFIG_TEGRA_SKIN_THROTTLE
102         {
103                 .id = BALANCED_THROTTLE_ID_SKIN,
104                 .throt_tab_size = 6,
105                 .throt_tab = {
106                         { 640000, 1200 },
107                         { 640000, 1200 },
108                         { 760000, 1200 },
109                         { 760000, 1200 },
110                         {1000000, 1200 },
111                         {1000000, 1200 },
112                 },
113         },
114 #endif
115 };
116
117 /* All units are in millicelsius */
118 static struct tegra_thermal_data thermal_data = {
119         .shutdown_device_id = THERMAL_DEVICE_ID_NCT_EXT,
120         .temp_shutdown = 90000,
121
122 #if defined(CONFIG_TEGRA_EDP_LIMITS) || defined(CONFIG_TEGRA_THERMAL_THROTTLE)
123         .throttle_edp_device_id = THERMAL_DEVICE_ID_NCT_EXT,
124 #endif
125 #ifdef CONFIG_TEGRA_EDP_LIMITS
126         .edp_offset = TDIODE_OFFSET,  /* edp based on tdiode */
127         .hysteresis_edp = 3000,
128 #endif
129 #ifdef CONFIG_TEGRA_THERMAL_THROTTLE
130         .temp_throttle = 85000,
131         .tc1 = 0,
132         .tc2 = 1,
133         .passive_delay = 2000,
134 #endif
135 #ifdef CONFIG_TEGRA_SKIN_THROTTLE
136         .skin_device_id = THERMAL_DEVICE_ID_SKIN,
137         .temp_throttle_skin = 43000,
138         .tc1_skin = 0,
139         .tc2_skin = 1,
140         .passive_delay_skin = 5000,
141
142         .skin_temp_offset = 9793,
143         .skin_period = 1100,
144         .skin_devs_size = 2,
145         .skin_devs = {
146                 {
147                         THERMAL_DEVICE_ID_NCT_EXT,
148                         {
149                                 2, 1, 1, 1,
150                                 1, 1, 1, 1,
151                                 1, 1, 1, 0,
152                                 1, 1, 0, 0,
153                                 0, 0, -1, -7
154                         }
155                 },
156                 {
157                         THERMAL_DEVICE_ID_NCT_INT,
158                         {
159                                 -11, -7, -5, -3,
160                                 -3, -2, -1, 0,
161                                 0, 0, 1, 1,
162                                 1, 2, 2, 3,
163                                 4, 6, 11, 18
164                         }
165                 },
166         },
167 #endif
168 };
169
170 static struct rfkill_gpio_platform_data cardhu_bt_rfkill_pdata[] = {
171         {
172                 .name           = "bt_rfkill",
173                 .shutdown_gpio  = TEGRA_GPIO_PU0,
174                 .reset_gpio     = TEGRA_GPIO_INVALID,
175                 .type           = RFKILL_TYPE_BLUETOOTH,
176         },
177 };
178
179 static struct platform_device cardhu_bt_rfkill_device = {
180         .name = "rfkill_gpio",
181         .id             = -1,
182         .dev = {
183                 .platform_data = &cardhu_bt_rfkill_pdata,
184         },
185 };
186
187 static struct resource cardhu_bluesleep_resources[] = {
188         [0] = {
189                 .name = "gpio_host_wake",
190                         .start  = TEGRA_GPIO_PU6,
191                         .end    = TEGRA_GPIO_PU6,
192                         .flags  = IORESOURCE_IO,
193         },
194         [1] = {
195                 .name = "gpio_ext_wake",
196                         .start  = TEGRA_GPIO_PU1,
197                         .end    = TEGRA_GPIO_PU1,
198                         .flags  = IORESOURCE_IO,
199         },
200         [2] = {
201                 .name = "host_wake",
202                         .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE,
203         },
204 };
205
206 static struct platform_device cardhu_bluesleep_device = {
207         .name           = "bluesleep",
208         .id             = -1,
209         .num_resources  = ARRAY_SIZE(cardhu_bluesleep_resources),
210         .resource       = cardhu_bluesleep_resources,
211 };
212
213 static noinline void __init cardhu_setup_bluesleep(void)
214 {
215         cardhu_bluesleep_resources[2].start =
216                 cardhu_bluesleep_resources[2].end =
217                         gpio_to_irq(TEGRA_GPIO_PU6);
218         platform_device_register(&cardhu_bluesleep_device);
219         return;
220 }
221
222 static __initdata struct tegra_clk_init_table cardhu_clk_init_table[] = {
223         /* name         parent          rate            enabled */
224         { "pll_m",      NULL,           0,              false},
225         { "hda",        "pll_p",        108000000,      false},
226         { "hda2codec_2x","pll_p",       48000000,       false},
227         { "pwm",        "pll_p",        3187500,        false},
228         { "blink",      "clk_32k",      32768,          true},
229         { "i2s0",       "pll_a_out0",   0,              false},
230         { "i2s1",       "pll_a_out0",   0,              false},
231         { "i2s3",       "pll_a_out0",   0,              false},
232         { "spdif_out",  "pll_a_out0",   0,              false},
233         { "d_audio",    "clk_m",        12000000,       false},
234         { "dam0",       "clk_m",        12000000,       false},
235         { "dam1",       "clk_m",        12000000,       false},
236         { "dam2",       "clk_m",        12000000,       false},
237         { "audio1",     "i2s1_sync",    0,              false},
238         { "audio3",     "i2s3_sync",    0,              false},
239         { "vi_sensor",  "pll_p",        150000000,      false},
240         { "i2c1",       "pll_p",        3200000,        false},
241         { "i2c2",       "pll_p",        3200000,        false},
242         { "i2c3",       "pll_p",        3200000,        false},
243         { "i2c4",       "pll_p",        3200000,        false},
244         { "i2c5",       "pll_p",        3200000,        false},
245         { "vi",         "pll_p",        0,              false},
246         { NULL,         NULL,           0,              0},
247 };
248
249 static struct pn544_i2c_platform_data nfc_pdata = {
250         .irq_gpio = TEGRA_GPIO_PX0,
251         .ven_gpio = TEGRA_GPIO_PP3,
252         .firm_gpio = TEGRA_GPIO_PO7,
253         };
254
255 static struct i2c_board_info __initdata cardhu_i2c_bus3_board_info[] = {
256         {
257                 I2C_BOARD_INFO("pn544", 0x28),
258                 .platform_data = &nfc_pdata,
259         },
260 };
261 static struct tegra_i2c_platform_data cardhu_i2c1_platform_data = {
262         .adapter_nr     = 0,
263         .bus_count      = 1,
264         .bus_clk_rate   = { 100000, 0 },
265         .scl_gpio               = {TEGRA_GPIO_PC4, 0},
266         .sda_gpio               = {TEGRA_GPIO_PC5, 0},
267         .arb_recovery = arb_lost_recovery,
268 };
269
270 static struct tegra_i2c_platform_data cardhu_i2c2_platform_data = {
271         .adapter_nr     = 1,
272         .bus_count      = 1,
273         .bus_clk_rate   = { 400000, 0 },
274         .is_clkon_always = true,
275         .scl_gpio               = {TEGRA_GPIO_PT5, 0},
276         .sda_gpio               = {TEGRA_GPIO_PT6, 0},
277         .arb_recovery = arb_lost_recovery,
278 };
279
280 static struct tegra_i2c_platform_data cardhu_i2c3_platform_data = {
281         .adapter_nr     = 2,
282         .bus_count      = 1,
283         .bus_clk_rate   = { 100000, 0 },
284         .scl_gpio               = {TEGRA_GPIO_PBB1, 0},
285         .sda_gpio               = {TEGRA_GPIO_PBB2, 0},
286         .arb_recovery = arb_lost_recovery,
287 };
288
289 static struct tegra_i2c_platform_data cardhu_i2c4_platform_data = {
290         .adapter_nr     = 3,
291         .bus_count      = 1,
292         .bus_clk_rate   = { 10000, 0 },
293         .scl_gpio               = {TEGRA_GPIO_PV4, 0},
294         .sda_gpio               = {TEGRA_GPIO_PV5, 0},
295         .arb_recovery = arb_lost_recovery,
296 };
297
298 static struct tegra_i2c_platform_data cardhu_i2c5_platform_data = {
299         .adapter_nr     = 4,
300         .bus_count      = 1,
301         .bus_clk_rate   = { 400000, 0 },
302         .scl_gpio               = {TEGRA_GPIO_PZ6, 0},
303         .sda_gpio               = {TEGRA_GPIO_PZ7, 0},
304         .arb_recovery = arb_lost_recovery,
305 };
306
307
308 #if 0
309 struct tegra_wired_jack_conf audio_wr_jack_conf = {
310         .hp_det_n = TEGRA_GPIO_PW2,
311         .en_mic_ext = TEGRA_GPIO_PX1,
312         .en_mic_int = TEGRA_GPIO_PX0,
313 };
314 #endif
315
316 static struct wm8903_platform_data cardhu_wm8903_pdata = {
317         .irq_active_low = 0,
318         .micdet_cfg = 0,
319         .micdet_delay = 100,
320         .gpio_base = CARDHU_GPIO_WM8903(0),
321         .gpio_cfg = {
322                 (WM8903_GPn_FN_DMIC_LR_CLK_OUTPUT << WM8903_GP1_FN_SHIFT),
323                 (WM8903_GPn_FN_DMIC_LR_CLK_OUTPUT << WM8903_GP2_FN_SHIFT) |
324                         WM8903_GP2_DIR,
325                 WM8903_GPIO_CONFIG_ZERO,
326                 0,
327                 0,
328         },
329 };
330
331 /* Equalizer filter coefs generated from the MAXIM MAX98095
332  * evkit software tool */
333 static struct max98095_eq_cfg max98095_eq_cfg[] = {
334         {
335                 .name = "FLAT",
336                 .rate = 44100,
337                 .band1 = {0x2000, 0xC002, 0x4000, 0x00E9, 0x0000},
338                 .band2 = {0x2000, 0xC00F, 0x4000, 0x02BC, 0x0000},
339                 .band3 = {0x2000, 0xC0A7, 0x4000, 0x0916, 0x0000},
340                 .band4 = {0x2000, 0xC5C2, 0x4000, 0x1A87, 0x0000},
341                 .band5 = {0x2000, 0xF6B0, 0x4000, 0x3F51, 0x0000},
342         },
343         {
344                 .name = "LOWPASS1K",
345                 .rate = 44100,
346                 .band1 = {0x205D, 0xC001, 0x3FEF, 0x002E, 0x02E0},
347                 .band2 = {0x5B9A, 0xC093, 0x3AB2, 0x088B, 0x1981},
348                 .band3 = {0x0D22, 0xC170, 0x26EA, 0x0D79, 0x32CF},
349                 .band4 = {0x0894, 0xC612, 0x01B3, 0x1B34, 0x3FFA},
350                 .band5 = {0x0815, 0x3FFF, 0xCF78, 0x0000, 0x29B7},
351         },
352         { /* BASS=-12dB, TREBLE=+9dB, Fc=5KHz */
353                 .name = "HIBOOST",
354                 .rate = 44100,
355                 .band1 = {0x0815, 0xC001, 0x3AA4, 0x0003, 0x19A2},
356                 .band2 = {0x0815, 0xC103, 0x092F, 0x0B55, 0x3F56},
357                 .band3 = {0x0E0A, 0xC306, 0x1E5C, 0x136E, 0x3856},
358                 .band4 = {0x2459, 0xF665, 0x0CAA, 0x3F46, 0x3EBB},
359                 .band5 = {0x5BBB, 0x3FFF, 0xCEB0, 0x0000, 0x28CA},
360         },
361         { /* BASS=12dB, TREBLE=+12dB */
362                 .name = "LOUD12DB",
363                 .rate = 44100,
364                 .band1 = {0x7FC1, 0xC001, 0x3EE8, 0x0020, 0x0BC7},
365                 .band2 = {0x51E9, 0xC016, 0x3C7C, 0x033F, 0x14E9},
366                 .band3 = {0x1745, 0xC12C, 0x1680, 0x0C2F, 0x3BE9},
367                 .band4 = {0x4536, 0xD7E2, 0x0ED4, 0x31DD, 0x3E42},
368                 .band5 = {0x7FEF, 0x3FFF, 0x0BAB, 0x0000, 0x3EED},
369         },
370         {
371                 .name = "FLAT",
372                 .rate = 16000,
373                 .band1 = {0x2000, 0xC004, 0x4000, 0x0141, 0x0000},
374                 .band2 = {0x2000, 0xC033, 0x4000, 0x0505, 0x0000},
375                 .band3 = {0x2000, 0xC268, 0x4000, 0x115F, 0x0000},
376                 .band4 = {0x2000, 0xDA62, 0x4000, 0x33C6, 0x0000},
377                 .band5 = {0x2000, 0x4000, 0x4000, 0x0000, 0x0000},
378         },
379         {
380                 .name = "LOWPASS1K",
381                 .rate = 16000,
382                 .band1 = {0x2000, 0xC004, 0x4000, 0x0141, 0x0000},
383                 .band2 = {0x5BE8, 0xC3E0, 0x3307, 0x15ED, 0x26A0},
384                 .band3 = {0x0F71, 0xD15A, 0x08B3, 0x2BD0, 0x3F67},
385                 .band4 = {0x0815, 0x3FFF, 0xCF78, 0x0000, 0x29B7},
386                 .band5 = {0x0815, 0x3FFF, 0xCF78, 0x0000, 0x29B7},
387         },
388         { /* BASS=-12dB, TREBLE=+9dB, Fc=2KHz */
389                 .name = "HIBOOST",
390                 .rate = 16000,
391                 .band1 = {0x0815, 0xC001, 0x3BD2, 0x0009, 0x16BF},
392                 .band2 = {0x080E, 0xC17E, 0xF653, 0x0DBD, 0x3F43},
393                 .band3 = {0x0F80, 0xDF45, 0xEE33, 0x36FE, 0x3D79},
394                 .band4 = {0x590B, 0x3FF0, 0xE882, 0x02BD, 0x3B87},
395                 .band5 = {0x4C87, 0xF3D0, 0x063F, 0x3ED4, 0x3FB1},
396         },
397         { /* BASS=12dB, TREBLE=+12dB */
398                 .name = "LOUD12DB",
399                 .rate = 16000,
400                 .band1 = {0x7FC1, 0xC001, 0x3D07, 0x0058, 0x1344},
401                 .band2 = {0x2DA6, 0xC013, 0x3CF1, 0x02FF, 0x138B},
402                 .band3 = {0x18F1, 0xC08E, 0x244D, 0x0863, 0x34B5},
403                 .band4 = {0x2BE0, 0xF385, 0x04FD, 0x3EC5, 0x3FCE},
404                 .band5 = {0x7FEF, 0x4000, 0x0BAB, 0x0000, 0x3EED},
405         },
406 };
407
408 static struct max98095_pdata cardhu_max98095_pdata = {
409         /* equalizer configuration */
410         .eq_cfg = max98095_eq_cfg,
411         .eq_cfgcnt = ARRAY_SIZE(max98095_eq_cfg),
412
413         /* Biquad filter response configuration */
414         .bq_cfg = NULL,
415         .bq_cfgcnt = 0,
416
417         /* microphone configuration */
418         .digmic_left_mode = 1,
419         .digmic_right_mode = 1,
420 };
421
422 static struct i2c_board_info __initdata cardhu_codec_wm8903_info = {
423         I2C_BOARD_INFO("wm8903", 0x1a),
424         .platform_data = &cardhu_wm8903_pdata,
425 };
426
427 static struct i2c_board_info __initdata cardhu_codec_aic326x_info = {
428         I2C_BOARD_INFO("aic3262-codec", 0x18),
429 };
430
431 static struct i2c_board_info __initdata cardhu_codec_max98095_info = {
432         I2C_BOARD_INFO("max98095", 0x10),
433         .platform_data = &cardhu_max98095_pdata,
434 };
435
436 static void cardhu_i2c_init(void)
437 {
438         tegra_i2c_device1.dev.platform_data = &cardhu_i2c1_platform_data;
439         tegra_i2c_device2.dev.platform_data = &cardhu_i2c2_platform_data;
440         tegra_i2c_device3.dev.platform_data = &cardhu_i2c3_platform_data;
441         tegra_i2c_device4.dev.platform_data = &cardhu_i2c4_platform_data;
442         tegra_i2c_device5.dev.platform_data = &cardhu_i2c5_platform_data;
443
444         platform_device_register(&tegra_i2c_device5);
445         platform_device_register(&tegra_i2c_device4);
446         platform_device_register(&tegra_i2c_device3);
447         platform_device_register(&tegra_i2c_device2);
448         platform_device_register(&tegra_i2c_device1);
449
450         cardhu_codec_wm8903_info.irq = cardhu_codec_max98095_info.irq =
451                 cardhu_codec_aic326x_info.irq = gpio_to_irq(TEGRA_GPIO_CDC_IRQ);
452         i2c_register_board_info(4, &cardhu_codec_wm8903_info, 1);
453         i2c_register_board_info(4, &cardhu_codec_max98095_info, 1);
454         i2c_register_board_info(4, &cardhu_codec_aic326x_info, 1);
455
456         cardhu_i2c_bus3_board_info[0].irq = gpio_to_irq(TEGRA_GPIO_PX0);
457         i2c_register_board_info(2, cardhu_i2c_bus3_board_info, 1);
458 }
459
460 static struct platform_device *cardhu_uart_devices[] __initdata = {
461         &tegra_uarta_device,
462         &tegra_uartb_device,
463         &tegra_uartc_device,
464         &tegra_uartd_device,
465         &tegra_uarte_device,
466 };
467 static struct uart_clk_parent uart_parent_clk[] = {
468         [0] = {.name = "clk_m"},
469         [1] = {.name = "pll_p"},
470 #ifndef CONFIG_TEGRA_PLLM_RESTRICTED
471         [2] = {.name = "pll_m"},
472 #endif
473 };
474
475 static struct tegra_uart_platform_data cardhu_uart_pdata;
476 static struct tegra_uart_platform_data cardhu_loopback_uart_pdata;
477
478 static void __init uart_debug_init(void)
479 {
480         struct board_info board_info;
481         int debug_port_id;
482
483         tegra_get_board_info(&board_info);
484
485         debug_port_id = get_tegra_uart_debug_port_id();
486         if (debug_port_id < 0) {
487                 debug_port_id = 0;
488                         /* UARTB is debug port
489                          *       for SLT - E1186/E1187/PM269
490                          *       for E1256/E1257
491                          */
492                 if (((board_info.sku & SKU_SLT_ULPI_SUPPORT) &&
493                         ((board_info.board_id == BOARD_E1186) ||
494                         (board_info.board_id == BOARD_E1187) ||
495                         (board_info.board_id == BOARD_PM269))) ||
496                         (board_info.board_id == BOARD_E1256) ||
497                         (board_info.board_id == BOARD_E1257))
498                                 debug_port_id = 1;
499         }
500
501 #ifdef CONFIG_TEGRA_IRDA
502         if ((board_info.board_id == BOARD_E1186) ||
503                 (board_info.board_id == BOARD_E1198)) {
504                 if (debug_port_id == 1) {
505                         cardhu_irda_pdata.is_irda = false;
506                         pr_err("UARTB is not available for IrDA\n");
507                 }
508         }
509 #endif
510
511         switch (debug_port_id) {
512         case 0:
513                 /* UARTA is the debug port. */
514                 pr_info("Selecting UARTA as the debug console\n");
515                 cardhu_uart_devices[0] = &debug_uarta_device;
516                 debug_uart_clk = clk_get_sys("serial8250.0", "uarta");
517                 debug_uart_port_base = ((struct plat_serial8250_port *)(
518                         debug_uarta_device.dev.platform_data))->mapbase;
519                 break;
520
521         case 1:
522                 /* UARTB is the debug port. */
523                 pr_info("Selecting UARTB as the debug console\n");
524                 cardhu_uart_devices[1] = &debug_uartb_device;
525                 debug_uart_clk =  clk_get_sys("serial8250.0", "uartb");
526                 debug_uart_port_base = ((struct plat_serial8250_port *)(
527                         debug_uartb_device.dev.platform_data))->mapbase;
528                 break;
529
530         case 2:
531                 /* UARTC is the debug port. */
532                 pr_info("Selecting UARTC as the debug console\n");
533                 cardhu_uart_devices[2] = &debug_uartc_device;
534                 debug_uart_clk =  clk_get_sys("serial8250.0", "uartc");
535                 debug_uart_port_base = ((struct plat_serial8250_port *)(
536                         debug_uartc_device.dev.platform_data))->mapbase;
537                 break;
538
539         case 3:
540                 /* UARTD is the debug port. */
541                 pr_info("Selecting UARTD as the debug console\n");
542                 cardhu_uart_devices[3] = &debug_uartd_device;
543                 debug_uart_clk =  clk_get_sys("serial8250.0", "uartd");
544                 debug_uart_port_base = ((struct plat_serial8250_port *)(
545                         debug_uartd_device.dev.platform_data))->mapbase;
546                 break;
547
548         case 4:
549                 /* UARTE is the debug port. */
550                 pr_info("Selecting UARTE as the debug console\n");
551                 cardhu_uart_devices[4] = &debug_uarte_device;
552                 debug_uart_clk =  clk_get_sys("serial8250.0", "uarte");
553                 debug_uart_port_base = ((struct plat_serial8250_port *)(
554                         debug_uarte_device.dev.platform_data))->mapbase;
555                 break;
556
557         default:
558                 pr_info("The debug console id %d is invalid, Assuming UARTA", debug_port_id);
559                 cardhu_uart_devices[0] = &debug_uarta_device;
560                 debug_uart_clk = clk_get_sys("serial8250.0", "uarta");
561                 debug_uart_port_base = ((struct plat_serial8250_port *)(
562                         debug_uarta_device.dev.platform_data))->mapbase;
563                 break;
564         }
565         return;
566 }
567
568 static void __init cardhu_uart_init(void)
569 {
570         struct clk *c;
571         int i;
572         struct board_info board_info;
573
574         tegra_get_board_info(&board_info);
575
576         for (i = 0; i < ARRAY_SIZE(uart_parent_clk); ++i) {
577                 c = tegra_get_clock_by_name(uart_parent_clk[i].name);
578                 if (IS_ERR_OR_NULL(c)) {
579                         pr_err("Not able to get the clock for %s\n",
580                                                 uart_parent_clk[i].name);
581                         continue;
582                 }
583                 uart_parent_clk[i].parent_clk = c;
584                 uart_parent_clk[i].fixed_clk_rate = clk_get_rate(c);
585         }
586         cardhu_uart_pdata.parent_clk_list = uart_parent_clk;
587         cardhu_uart_pdata.parent_clk_count = ARRAY_SIZE(uart_parent_clk);
588         cardhu_loopback_uart_pdata.parent_clk_list = uart_parent_clk;
589         cardhu_loopback_uart_pdata.parent_clk_count =
590                                                 ARRAY_SIZE(uart_parent_clk);
591         cardhu_loopback_uart_pdata.is_loopback = true;
592         tegra_uarta_device.dev.platform_data = &cardhu_uart_pdata;
593         tegra_uartb_device.dev.platform_data = &cardhu_uart_pdata;
594         tegra_uartc_device.dev.platform_data = &cardhu_uart_pdata;
595         tegra_uartd_device.dev.platform_data = &cardhu_uart_pdata;
596         /* UARTE is used for loopback test purpose */
597         tegra_uarte_device.dev.platform_data = &cardhu_loopback_uart_pdata;
598
599         /* Register low speed only if it is selected */
600         if (!is_tegra_debug_uartport_hs()) {
601                 uart_debug_init();
602                 /* Clock enable for the debug channel */
603                 if (!IS_ERR_OR_NULL(debug_uart_clk)) {
604                         pr_info("The debug console clock name is %s\n",
605                                                 debug_uart_clk->name);
606                         c = tegra_get_clock_by_name("pll_p");
607                         if (IS_ERR_OR_NULL(c))
608                                 pr_err("Not getting the parent clock pll_p\n");
609                         else
610                                 clk_set_parent(debug_uart_clk, c);
611
612                         clk_enable(debug_uart_clk);
613                         clk_set_rate(debug_uart_clk, clk_get_rate(c));
614                 } else {
615                         pr_err("Not getting the clock %s for debug console\n",
616                                         debug_uart_clk->name);
617                 }
618         }
619
620 #ifdef CONFIG_TEGRA_IRDA
621         if (((board_info.board_id == BOARD_E1186) ||
622                 (board_info.board_id == BOARD_E1198)) &&
623                         cardhu_irda_pdata.is_irda) {
624                 cardhu_irda_pdata.parent_clk_list = uart_parent_clk;
625                 cardhu_irda_pdata.parent_clk_count =
626                                         ARRAY_SIZE(uart_parent_clk);
627
628                 tegra_uartb_device.dev.platform_data = &cardhu_irda_pdata;
629         }
630 #endif
631
632         platform_add_devices(cardhu_uart_devices,
633                                 ARRAY_SIZE(cardhu_uart_devices));
634 }
635
636 static struct platform_device tegra_camera = {
637         .name = "tegra_camera",
638         .id = -1,
639 };
640
641 static struct platform_device *cardhu_spi_devices[] __initdata = {
642         &tegra_spi_device4,
643 };
644
645 static struct platform_device *touch_spi_device[] __initdata = {
646         &tegra_spi_device1,
647 };
648
649 struct spi_clk_parent spi_parent_clk[] = {
650         [0] = {.name = "pll_p"},
651 #ifndef CONFIG_TEGRA_PLLM_RESTRICTED
652         [1] = {.name = "pll_m"},
653         [2] = {.name = "clk_m"},
654 #else
655         [1] = {.name = "clk_m"},
656 #endif
657 };
658
659 static struct tegra_spi_platform_data cardhu_spi_pdata = {
660         .is_dma_based           = true,
661         .max_dma_buffer         = (16 * 1024),
662         .is_clkon_always        = false,
663         .max_rate               = 100000000,
664 };
665
666 static void __init cardhu_spi_init(void)
667 {
668         int i;
669         struct clk *c;
670         struct board_info board_info, display_board_info;
671
672         tegra_get_board_info(&board_info);
673         tegra_get_display_board_info(&display_board_info);
674
675         for (i = 0; i < ARRAY_SIZE(spi_parent_clk); ++i) {
676                 c = tegra_get_clock_by_name(spi_parent_clk[i].name);
677                 if (IS_ERR_OR_NULL(c)) {
678                         pr_err("Not able to get the clock for %s\n",
679                                                 spi_parent_clk[i].name);
680                         continue;
681                 }
682                 spi_parent_clk[i].parent_clk = c;
683                 spi_parent_clk[i].fixed_clk_rate = clk_get_rate(c);
684         }
685         cardhu_spi_pdata.parent_clk_list = spi_parent_clk;
686         cardhu_spi_pdata.parent_clk_count = ARRAY_SIZE(spi_parent_clk);
687         tegra_spi_device4.dev.platform_data = &cardhu_spi_pdata;
688         platform_add_devices(cardhu_spi_devices,
689                                 ARRAY_SIZE(cardhu_spi_devices));
690
691         if (display_board_info.board_id == BOARD_DISPLAY_PM313) {
692                 platform_add_devices(touch_spi_device,
693                                 ARRAY_SIZE(touch_spi_device));
694         }
695         if (board_info.board_id == BOARD_E1198) {
696                 tegra_spi_device2.dev.platform_data = &cardhu_spi_pdata;
697                 platform_device_register(&tegra_spi_device2);
698                 tegra_spi_slave_device1.dev.platform_data = &cardhu_spi_pdata;
699                 platform_device_register(&tegra_spi_slave_device1);
700         }
701 }
702
703 static void __init cardhu_dtv_init(void)
704 {
705         struct board_info board_info;
706
707         tegra_get_board_info(&board_info);
708
709         if (board_info.board_id == BOARD_E1186)
710                 platform_device_register(&tegra_dtv_device);
711 }
712
713 static struct resource tegra_rtc_resources[] = {
714         [0] = {
715                 .start = TEGRA_RTC_BASE,
716                 .end = TEGRA_RTC_BASE + TEGRA_RTC_SIZE - 1,
717                 .flags = IORESOURCE_MEM,
718         },
719         [1] = {
720                 .start = INT_RTC,
721                 .end = INT_RTC,
722                 .flags = IORESOURCE_IRQ,
723         },
724 };
725
726 static struct platform_device tegra_rtc_device = {
727         .name = "tegra_rtc",
728         .id   = -1,
729         .resource = tegra_rtc_resources,
730         .num_resources = ARRAY_SIZE(tegra_rtc_resources),
731 };
732
733 static struct tegra_wm8903_platform_data cardhu_audio_wm8903_pdata = {
734         .gpio_spkr_en           = TEGRA_GPIO_SPKR_EN,
735         .gpio_hp_det            = TEGRA_GPIO_HP_DET,
736         .gpio_hp_mute           = -1,
737         .gpio_int_mic_en        = -1,
738         .gpio_ext_mic_en        = -1,
739 };
740
741 static struct tegra_asoc_platform_data cardhu_audio_max98095_pdata = {
742         .gpio_spkr_en           = -1,
743         .gpio_hp_det            = TEGRA_GPIO_HP_DET,
744         .gpio_hp_mute           = -1,
745         .gpio_int_mic_en        = -1,
746         .gpio_ext_mic_en        = -1,
747 };
748
749 static struct platform_device cardhu_audio_wm8903_device = {
750         .name   = "tegra-snd-wm8903",
751         .id     = 0,
752         .dev    = {
753                 .platform_data = &cardhu_audio_wm8903_pdata,
754         },
755 };
756
757 static struct platform_device cardhu_audio_max98095_device = {
758         .name   = "tegra-snd-max98095",
759         .id     = 0,
760         .dev    = {
761                 .platform_data = &cardhu_audio_max98095_pdata,
762         },
763 };
764
765 static struct tegra_asoc_platform_data cardhu_audio_aic326x_pdata = {
766         .gpio_spkr_en           = -1,
767         .gpio_hp_det            = TEGRA_GPIO_HP_DET,
768         .gpio_hp_mute           = -1,
769         .gpio_int_mic_en        = -1,
770         .gpio_ext_mic_en        = -1,
771         /*defaults for Verbier-Cardhu board with TI AIC326X codec*/
772         .audio_port_id          = {
773                 [HIFI_CODEC] = 0,
774                 [BASEBAND] = -1,
775                 [BT_SCO] = 3,
776         },
777         .baseband_param         = {
778                 .rate = -1,
779                 .channels = -1,
780         },
781 };
782
783 static struct platform_device cardhu_audio_aic326x_device = {
784         .name   = "tegra-snd-aic326x",
785         .id     = 0,
786         .dev    = {
787                 .platform_data  = &cardhu_audio_aic326x_pdata,
788         },
789 };
790
791 static struct platform_device *cardhu_devices[] __initdata = {
792         &tegra_pmu_device,
793         &tegra_rtc_device,
794         &tegra_udc_device,
795 #if defined(CONFIG_TEGRA_IOVMM_SMMU) ||  defined(CONFIG_TEGRA_IOMMU_SMMU)
796         &tegra_smmu_device,
797 #endif
798         &tegra_wdt0_device,
799         &tegra_wdt1_device,
800         &tegra_wdt2_device,
801 #if defined(CONFIG_TEGRA_AVP)
802         &tegra_avp_device,
803 #endif
804         &tegra_camera,
805 #if defined(CONFIG_CRYPTO_DEV_TEGRA_SE)
806         &tegra_se_device,
807 #endif
808         &tegra_ahub_device,
809         &tegra_dam_device0,
810         &tegra_dam_device1,
811         &tegra_dam_device2,
812         &tegra_i2s_device0,
813         &tegra_i2s_device1,
814         &tegra_i2s_device3,
815         &tegra_spdif_device,
816         &spdif_dit_device,
817         &bluetooth_dit_device,
818         &baseband_dit_device,
819         &cardhu_bt_rfkill_device,
820         &tegra_pcm_device,
821         &cardhu_audio_wm8903_device,
822         &cardhu_audio_max98095_device,
823         &cardhu_audio_aic326x_device,
824         &tegra_hda_device,
825         &tegra_cec_device,
826 #if defined(CONFIG_CRYPTO_DEV_TEGRA_AES)
827         &tegra_aes_device,
828 #endif
829 };
830
831 #define E1506_MXT_CONFIG_CRC 0x62F903
832 static const u8 e1506_config[] = {
833         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
834         0xFF, 0xFF, 0x32, 0x0A, 0x00, 0x05, 0x01, 0x00,
835         0x00, 0x1E, 0x0A, 0x8B, 0x00, 0x00, 0x13, 0x0B,
836         0x00, 0x10, 0x32, 0x03, 0x03, 0x00, 0x03, 0x01,
837         0x00, 0x0A, 0x0A, 0x0A, 0x0A, 0xBF, 0x03, 0x1B,
838         0x02, 0x00, 0x00, 0x37, 0x37, 0x00, 0x00, 0x00,
839         0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
840         0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
841         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
842         0x00, 0x00, 0x00, 0xA9, 0x7F, 0x9A, 0x0E, 0x00,
843         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
844         0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
845         0x00, 0x00, 0x03, 0x23, 0x00, 0x00, 0x00, 0x0A,
846         0x0F, 0x14, 0x19, 0x03, 0x00, 0x00, 0x00, 0x00,
847         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
848         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
849         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
850         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
851         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
852         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
853         0x00, 0x00, 0x00, 0x01, 0x00, 0x03, 0x08, 0x10,
854         0x00
855 };
856
857 #define MXT_CONFIG_CRC  0xD62DE8
858 static const u8 config[] = {
859         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
860         0xFF, 0xFF, 0x32, 0x0A, 0x00, 0x14, 0x14, 0x00,
861         0x00, 0x00, 0x00, 0x00, 0x00, 0x8B, 0x00, 0x00,
862         0x1B, 0x2A, 0x00, 0x20, 0x3C, 0x04, 0x05, 0x00,
863         0x02, 0x01, 0x00, 0x0A, 0x0A, 0x0A, 0x0A, 0xFF,
864         0x02, 0x55, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
865         0x00, 0x00, 0x00, 0x64, 0x02, 0x00, 0x00, 0x00,
866         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
867         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
868         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
869         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23,
870         0x00, 0x00, 0x00, 0x05, 0x0A, 0x15, 0x1E, 0x00,
871         0x00, 0x04, 0xFF, 0x03, 0x3F, 0x64, 0x64, 0x01,
872         0x0A, 0x14, 0x28, 0x4B, 0x00, 0x02, 0x00, 0x64,
873         0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
874         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
875         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
876         0x00, 0x00, 0x00, 0x08, 0x10, 0x3C, 0x00, 0x00,
877         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
878         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
879 };
880
881 #define MXT_CONFIG_CRC_SKU2000  0xA24D9A
882 static const u8 config_sku2000[] = {
883         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
884         0xFF, 0xFF, 0x32, 0x0A, 0x00, 0x14, 0x14, 0x19,
885         0x00, 0x00, 0x00, 0x00, 0x00, 0x8B, 0x00, 0x00,
886         0x1B, 0x2A, 0x00, 0x20, 0x3A, 0x04, 0x05, 0x00,  //23=thr  2 di
887         0x04, 0x04, 0x41, 0x0A, 0x0A, 0x0A, 0x0A, 0xFF,
888         0x02, 0x55, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
889         0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00,  //0A=limit
890         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
891         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
892         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
893         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23,
894         0x00, 0x00, 0x00, 0x05, 0x0A, 0x15, 0x1E, 0x00,
895         0x00, 0x04, 0x00, 0x03, 0x3F, 0x64, 0x64, 0x01,
896         0x0A, 0x14, 0x28, 0x4B, 0x00, 0x02, 0x00, 0x64,
897         0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
898         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
899         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
900         0x00, 0x00, 0x00, 0x08, 0x10, 0x3C, 0x00, 0x00,
901         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
902         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
903 };
904
905 static struct mxt_platform_data atmel_mxt_info = {
906         .x_line         = 27,
907         .y_line         = 42,
908         .x_size         = 768,
909         .y_size         = 1366,
910         .blen           = 0x20,
911         .threshold      = 0x3C,
912         .voltage        = 3300000,              /* 3.3V */
913         .orient         = 5,
914         .config         = config,
915         .config_length  = 157,
916         .config_crc     = MXT_CONFIG_CRC,
917         .irqflags       = IRQF_TRIGGER_FALLING,
918 /*      .read_chg       = &read_chg, */
919         .read_chg       = NULL,
920 };
921
922 static struct mxt_platform_data e1506_atmel_mxt_info = {
923         .x_line         = 19,
924         .y_line         = 11,
925         .x_size         = 960,
926         .y_size         = 540,
927         .blen           = 0x10,
928         .threshold      = 0x32,
929         .voltage        = 3300000,              /* 3.3V */
930         .orient         = 3,
931         .config         = e1506_config,
932         .config_length  = 168,
933         .config_crc     = E1506_MXT_CONFIG_CRC,
934         .irqflags       = IRQF_TRIGGER_FALLING,
935 /*      .read_chg       = &read_chg, */
936         .read_chg       = NULL,
937 };
938
939 static struct i2c_board_info __initdata atmel_i2c_info[] = {
940         {
941                 I2C_BOARD_INFO("atmel_mxt_ts", 0x5A),
942                 .platform_data = &atmel_mxt_info,
943         }
944 };
945
946 static struct i2c_board_info __initdata e1506_atmel_i2c_info[] = {
947         {
948                 I2C_BOARD_INFO("atmel_mxt_ts", 0x4A),
949                 .platform_data = &e1506_atmel_mxt_info,
950         }
951 };
952
953 static __initdata struct tegra_clk_init_table spi_clk_init_table[] = {
954         /* name         parent          rate            enabled */
955         { "sbc1",       "pll_p",        52000000,       true},
956         { NULL,         NULL,           0,              0},
957 };
958
959 static int __init cardhu_touch_init(void)
960 {
961         struct board_info BoardInfo, DisplayBoardInfo;
962
963         tegra_get_board_info(&BoardInfo);
964         tegra_get_display_board_info(&DisplayBoardInfo);
965         if (DisplayBoardInfo.board_id == BOARD_DISPLAY_PM313) {
966                 tegra_clk_init_from_table(spi_clk_init_table);
967
968                 touch_init_raydium(TEGRA_GPIO_PH4, TEGRA_GPIO_PH6, 2);
969         } else {
970                 gpio_request(TEGRA_GPIO_PH4, "atmel-irq");
971                 gpio_direction_input(TEGRA_GPIO_PH4);
972
973                 gpio_request(TEGRA_GPIO_PH6, "atmel-reset");
974                 gpio_direction_output(TEGRA_GPIO_PH6, 0);
975                 msleep(1);
976                 gpio_set_value(TEGRA_GPIO_PH6, 1);
977                 msleep(100);
978
979                 if ((BoardInfo.sku & SKU_TOUCH_MASK) == SKU_TOUCH_2000) {
980                         atmel_mxt_info.config = config_sku2000;
981                         atmel_mxt_info.config_crc = MXT_CONFIG_CRC_SKU2000;
982                 }
983
984                 if (DisplayBoardInfo.board_id == BOARD_DISPLAY_E1506) {
985                         e1506_atmel_i2c_info[0].irq = gpio_to_irq(TEGRA_GPIO_PH4);
986                         i2c_register_board_info(1, e1506_atmel_i2c_info, 1);
987                 } else {
988                         atmel_i2c_info[0].irq = gpio_to_irq(TEGRA_GPIO_PH4);
989                         i2c_register_board_info(1, atmel_i2c_info, 1);
990                 }
991         }
992
993         return 0;
994 }
995
996 #if defined(CONFIG_USB_SUPPORT)
997
998 static void cardu_usb_hsic_postsupend(void)
999 {
1000 #ifdef CONFIG_TEGRA_BB_XMM_POWER
1001         baseband_xmm_set_power_status(BBXMM_PS_L2);
1002 #endif
1003 }
1004
1005 static void cardu_usb_hsic_preresume(void)
1006 {
1007 #ifdef CONFIG_TEGRA_BB_XMM_POWER
1008         baseband_xmm_set_power_status(BBXMM_PS_L2TOL0);
1009 #endif
1010 }
1011
1012 static void cardu_usb_hsic_phy_ready(void)
1013 {
1014 #ifdef CONFIG_TEGRA_BB_XMM_POWER
1015         baseband_xmm_set_power_status(BBXMM_PS_L0);
1016 #endif
1017 }
1018
1019 static void cardu_usb_hsic_phy_off(void)
1020 {
1021 #ifdef CONFIG_TEGRA_BB_XMM_POWER
1022         baseband_xmm_set_power_status(BBXMM_PS_L3);
1023 #endif
1024 }
1025
1026 static struct tegra_usb_phy_platform_ops hsic_xmm_plat_ops = {
1027         .post_suspend = cardu_usb_hsic_postsupend,
1028         .pre_resume = cardu_usb_hsic_preresume,
1029         .port_power = cardu_usb_hsic_phy_ready,
1030         .post_phy_off = cardu_usb_hsic_phy_off,
1031 };
1032
1033 static struct tegra_usb_platform_data tegra_ehci2_hsic_xmm_pdata = {
1034         .port_otg = false,
1035         .has_hostpc = true,
1036         .phy_intf = TEGRA_USB_PHY_INTF_HSIC,
1037         .op_mode        = TEGRA_USB_OPMODE_HOST,
1038         .u_data.host = {
1039                 .vbus_gpio = -1,
1040                 .hot_plug = false,
1041                 .remote_wakeup_supported = false,
1042                 .power_off_on_suspend = false,
1043         },
1044         .u_cfg.hsic = {
1045                 .sync_start_delay = 9,
1046                 .idle_wait_delay = 17,
1047                 .term_range_adj = 0,
1048                 .elastic_underrun_limit = 16,
1049                 .elastic_overrun_limit = 16,
1050         },
1051         .ops = &hsic_xmm_plat_ops,
1052 };
1053 #endif
1054
1055 static int hsic_enable_gpio = -1;
1056 static int hsic_reset_gpio = -1;
1057
1058 void hsic_platform_open(void)
1059 {
1060         int reset_gpio = 0, enable_gpio = 0;
1061
1062         if (hsic_enable_gpio != -1)
1063                 enable_gpio = gpio_request(hsic_enable_gpio, "uhsic_enable");
1064         if (hsic_reset_gpio != -1)
1065                 reset_gpio = gpio_request(hsic_reset_gpio, "uhsic_reset");
1066         /* hsic enable signal deasserted, hsic reset asserted */
1067         if (!enable_gpio)
1068                 gpio_direction_output(hsic_enable_gpio, 0 /* deasserted */);
1069         if (!reset_gpio)
1070                 gpio_direction_output(hsic_reset_gpio, 0 /* asserted */);
1071         if (!enable_gpio)
1072                 tegra_gpio_enable(hsic_enable_gpio);
1073         if (!reset_gpio)
1074                 tegra_gpio_enable(hsic_reset_gpio);
1075         /* keep hsic reset asserted for 1 ms */
1076         udelay(1000);
1077         /* enable (power on) hsic */
1078         if (!enable_gpio)
1079                 gpio_set_value_cansleep(hsic_enable_gpio, 1);
1080         udelay(1000);
1081         /* deassert reset */
1082         if (!reset_gpio)
1083                 gpio_set_value_cansleep(hsic_reset_gpio, 1);
1084
1085 }
1086
1087 void hsic_platform_close(void)
1088 {
1089         if (hsic_enable_gpio != -1) {
1090                 gpio_set_value(hsic_enable_gpio, 0);
1091                 gpio_free(hsic_enable_gpio);
1092         }
1093         if (hsic_reset_gpio != -1) {
1094                 gpio_set_value(hsic_reset_gpio, 0);
1095                 gpio_free(hsic_reset_gpio);
1096         }
1097 }
1098
1099 void hsic_power_on(void)
1100 {
1101         if (hsic_enable_gpio != -1) {
1102                 gpio_set_value_cansleep(hsic_enable_gpio, 1);
1103                 udelay(1000);
1104         }
1105 }
1106
1107 void hsic_power_off(void)
1108 {
1109         if (hsic_enable_gpio != -1) {
1110                 gpio_set_value_cansleep(hsic_enable_gpio, 0);
1111                 udelay(1000);
1112         }
1113 }
1114
1115 #if defined(CONFIG_USB_SUPPORT)
1116 static struct tegra_usb_phy_platform_ops hsic_plat_ops = {
1117         .open = hsic_platform_open,
1118         .close = hsic_platform_close,
1119         .pre_phy_on = hsic_power_on,
1120         .post_phy_off = hsic_power_off,
1121 };
1122
1123 static struct tegra_usb_platform_data tegra_ehci2_hsic_pdata = {
1124         .port_otg = false,
1125         .has_hostpc = true,
1126         .phy_intf = TEGRA_USB_PHY_INTF_HSIC,
1127         .op_mode        = TEGRA_USB_OPMODE_HOST,
1128         .u_data.host = {
1129                 .vbus_gpio = -1,
1130                 .hot_plug = false,
1131                 .remote_wakeup_supported = false,
1132                 .power_off_on_suspend = false,
1133         },
1134         .u_cfg.hsic = {
1135                 .sync_start_delay = 9,
1136                 .idle_wait_delay = 17,
1137                 .term_range_adj = 0,
1138                 .elastic_underrun_limit = 16,
1139                 .elastic_overrun_limit = 16,
1140         },
1141         .ops = &hsic_plat_ops,
1142 };
1143
1144 static struct tegra_usb_platform_data tegra_udc_pdata = {
1145         .port_otg = true,
1146         .has_hostpc = true,
1147         .phy_intf = TEGRA_USB_PHY_INTF_UTMI,
1148         .op_mode = TEGRA_USB_OPMODE_DEVICE,
1149         .u_data.dev = {
1150                 .vbus_pmu_irq = 0,
1151                 .vbus_gpio = -1,
1152                 .charging_supported = false,
1153                 .remote_wakeup_supported = false,
1154         },
1155         .u_cfg.utmi = {
1156                 .hssync_start_delay = 0,
1157                 .elastic_limit = 16,
1158                 .idle_wait_delay = 17,
1159                 .term_range_adj = 6,
1160                 .xcvr_setup = 8,
1161                 .xcvr_lsfslew = 2,
1162                 .xcvr_lsrslew = 2,
1163                 .xcvr_setup_offset = 0,
1164                 .xcvr_use_fuses = 1,
1165         },
1166 };
1167
1168 static struct tegra_usb_platform_data tegra_ehci2_utmi_pdata = {
1169         .port_otg = false,
1170         .has_hostpc = true,
1171         .phy_intf = TEGRA_USB_PHY_INTF_UTMI,
1172         .op_mode        = TEGRA_USB_OPMODE_HOST,
1173         .u_data.host = {
1174                 .vbus_gpio = -1,
1175                 .hot_plug = false,
1176                 .remote_wakeup_supported = true,
1177                 .power_off_on_suspend = true,
1178         },
1179         .u_cfg.utmi = {
1180                 .hssync_start_delay = 0,
1181                 .elastic_limit = 16,
1182                 .idle_wait_delay = 17,
1183                 .term_range_adj = 6,
1184                 .xcvr_setup = 15,
1185                 .xcvr_lsfslew = 2,
1186                 .xcvr_lsrslew = 2,
1187                 .xcvr_setup_offset = 0,
1188                 .xcvr_use_fuses = 1,
1189         },
1190 };
1191
1192 static struct tegra_usb_platform_data tegra_ehci3_utmi_pdata = {
1193         .port_otg = false,
1194         .has_hostpc = true,
1195         .phy_intf = TEGRA_USB_PHY_INTF_UTMI,
1196         .op_mode = TEGRA_USB_OPMODE_HOST,
1197         .u_data.host = {
1198                 .vbus_gpio = -1,
1199                 .vbus_reg = "vdd_vbus_typea_usb",
1200                 .hot_plug = true,
1201                 .remote_wakeup_supported = true,
1202                 .power_off_on_suspend = true,
1203         },
1204         .u_cfg.utmi = {
1205                 .hssync_start_delay = 0,
1206                 .elastic_limit = 16,
1207                 .idle_wait_delay = 17,
1208                 .term_range_adj = 6,
1209                 .xcvr_setup = 8,
1210                 .xcvr_lsfslew = 2,
1211                 .xcvr_lsrslew = 2,
1212                 .xcvr_setup_offset = 0,
1213                 .xcvr_use_fuses = 1,
1214         },
1215 };
1216
1217 static struct tegra_usb_platform_data tegra_ehci1_utmi_pdata = {
1218         .port_otg = true,
1219         .has_hostpc = true,
1220         .phy_intf = TEGRA_USB_PHY_INTF_UTMI,
1221         .op_mode = TEGRA_USB_OPMODE_HOST,
1222         .u_data.host = {
1223                 .vbus_gpio = -1,
1224                 .vbus_reg = "vdd_vbus_micro_usb",
1225                 .hot_plug = true,
1226                 .remote_wakeup_supported = true,
1227                 .power_off_on_suspend = true,
1228         },
1229         .u_cfg.utmi = {
1230                 .hssync_start_delay = 0,
1231                 .elastic_limit = 16,
1232                 .idle_wait_delay = 17,
1233                 .term_range_adj = 6,
1234                 .xcvr_setup = 15,
1235                 .xcvr_lsfslew = 2,
1236                 .xcvr_lsrslew = 2,
1237                 .xcvr_setup_offset = 0,
1238                 .xcvr_use_fuses = 1,
1239         },
1240 };
1241
1242 static struct tegra_usb_otg_data tegra_otg_pdata = {
1243         .ehci_device = &tegra_ehci1_device,
1244         .ehci_pdata = &tegra_ehci1_utmi_pdata,
1245 };
1246 #endif
1247
1248 #if defined(CONFIG_USB_SUPPORT)
1249 static void cardhu_usb_init(void)
1250 {
1251         struct board_info bi;
1252
1253         tegra_get_board_info(&bi);
1254
1255         /* OTG should be the first to be registered */
1256         tegra_otg_device.dev.platform_data = &tegra_otg_pdata;
1257         platform_device_register(&tegra_otg_device);
1258
1259         /* setup the udc platform data */
1260         tegra_udc_device.dev.platform_data = &tegra_udc_pdata;
1261
1262         if (bi.board_id == BOARD_PM267) {
1263                 hsic_enable_gpio = EN_HSIC_GPIO;
1264                 hsic_reset_gpio = PM267_SMSC4640_HSIC_HUB_RESET_GPIO;
1265                 tegra_ehci2_device.dev.platform_data = &tegra_ehci2_hsic_pdata;
1266                 platform_device_register(&tegra_ehci2_device);
1267         } else if (bi.board_id == BOARD_E1256) {
1268                 hsic_enable_gpio = EN_HSIC_GPIO;
1269                 tegra_ehci2_device.dev.platform_data = &tegra_ehci2_hsic_pdata;
1270                 platform_device_register(&tegra_ehci2_device);
1271         } else if (bi.board_id == BOARD_E1186) {
1272                 tegra_ehci2_device.dev.platform_data =
1273                                                 &tegra_ehci2_hsic_xmm_pdata;
1274                 /* ehci2 registration happens in baseband-xmm-power  */
1275         } else {
1276                 tegra_ehci2_device.dev.platform_data = &tegra_ehci2_utmi_pdata;
1277                 platform_device_register(&tegra_ehci2_device);
1278         }
1279
1280         tegra_ehci3_device.dev.platform_data = &tegra_ehci3_utmi_pdata;
1281         platform_device_register(&tegra_ehci3_device);
1282
1283 }
1284 #else
1285 static void cardhu_usb_init(void) { }
1286 #endif
1287
1288 static struct baseband_power_platform_data tegra_baseband_power_data = {
1289         .baseband_type = BASEBAND_XMM,
1290         .modem = {
1291         .xmm = {
1292                         .bb_rst = XMM_GPIO_BB_RST,
1293                         .bb_on = XMM_GPIO_BB_ON,
1294                         .ipc_bb_wake = XMM_GPIO_IPC_BB_WAKE,
1295                         .ipc_ap_wake = XMM_GPIO_IPC_AP_WAKE,
1296                         .ipc_hsic_active = XMM_GPIO_IPC_HSIC_ACTIVE,
1297                         .ipc_hsic_sus_req = XMM_GPIO_IPC_HSIC_SUS_REQ,
1298                         .hsic_device = &tegra_ehci2_device,
1299                 },
1300         },
1301 };
1302
1303 static struct platform_device tegra_baseband_power_device = {
1304         .name = "baseband_xmm_power",
1305         .id = -1,
1306         .dev = {
1307                 .platform_data = &tegra_baseband_power_data,
1308         },
1309 };
1310
1311 static struct platform_device tegra_baseband_power2_device = {
1312         .name = "baseband_xmm_power2",
1313         .id = -1,
1314         .dev = {
1315                 .platform_data = &tegra_baseband_power_data,
1316         },
1317 };
1318
1319
1320 static struct tegra_pci_platform_data cardhu_pci_platform_data = {
1321         .port_status[0] = 1,
1322         .port_status[1] = 1,
1323         .port_status[2] = 1,
1324         .use_dock_detect        = 0,
1325         .gpio           = 0,
1326 };
1327
1328 static void cardhu_pci_init(void)
1329 {
1330         struct board_info board_info;
1331
1332         tegra_get_board_info(&board_info);
1333         if (board_info.board_id == BOARD_E1291) {
1334                 cardhu_pci_platform_data.port_status[0] = 0;
1335                 cardhu_pci_platform_data.port_status[1] = 0;
1336                 cardhu_pci_platform_data.port_status[2] = 1;
1337                 cardhu_pci_platform_data.use_dock_detect = 1;
1338                 cardhu_pci_platform_data.gpio = DOCK_DETECT_GPIO;
1339         }
1340         if ((board_info.board_id == BOARD_E1186) ||
1341                 (board_info.board_id == BOARD_E1187) ||
1342                 (board_info.board_id == BOARD_E1291)) {
1343                 tegra_pci_device.dev.platform_data = &cardhu_pci_platform_data;
1344                 platform_device_register(&tegra_pci_device);
1345         }
1346 }
1347
1348 static void cardhu_modem_init(void)
1349 {
1350         struct board_info board_info;
1351         int w_disable_gpio, ret;
1352
1353         tegra_get_board_info(&board_info);
1354         switch (board_info.board_id) {
1355         case BOARD_E1291:
1356         case BOARD_E1198:
1357                 if (((board_info.board_id == BOARD_E1291) &&
1358                                 (board_info.fab < BOARD_FAB_A03)) ||
1359                         ((board_info.board_id == BOARD_E1198) &&
1360                                         (board_info.fab < BOARD_FAB_A02))) {
1361                         w_disable_gpio = TEGRA_GPIO_PH5;
1362                 } else {
1363                         w_disable_gpio = TEGRA_GPIO_PDD5;
1364                 }
1365
1366                 ret = gpio_request(w_disable_gpio, "w_disable_gpio");
1367                 if (ret < 0)
1368                         pr_err("%s: gpio_request failed for gpio %d\n",
1369                                 __func__, w_disable_gpio);
1370                 else
1371                         gpio_direction_input(w_disable_gpio);
1372
1373                 /* E1291-A04 & E1198:A02: Set PERST signal to high */
1374                 if (((board_info.board_id == BOARD_E1291) &&
1375                                 (board_info.fab >= BOARD_FAB_A04)) ||
1376                         ((board_info.board_id == BOARD_E1198) &&
1377                                         (board_info.fab >= BOARD_FAB_A02))) {
1378                         ret = gpio_request(TEGRA_GPIO_PH7, "modem_perst");
1379                         if (ret < 0) {
1380                                 pr_err("%s(): Error in allocating gpio "
1381                                         "TEGRA_GPIO_PH7\n", __func__);
1382                                 break;
1383                         }
1384                         gpio_direction_output(TEGRA_GPIO_PH7, 1);
1385                 }
1386                 break;
1387         case BOARD_E1186:
1388                 platform_device_register(&tegra_baseband_power_device);
1389                 platform_device_register(&tegra_baseband_power2_device);
1390                 break;
1391         default:
1392                 break;
1393         }
1394
1395 }
1396
1397 #ifdef CONFIG_SATA_AHCI_TEGRA
1398 static void cardhu_sata_init(void)
1399 {
1400         platform_device_register(&tegra_sata_device);
1401 }
1402 #else
1403 static void cardhu_sata_init(void) { }
1404 #endif
1405
1406 static void __init tegra_cardhu_init(void)
1407 {
1408         tegra_thermal_init(&thermal_data,
1409                                 throttle_list,
1410                                 ARRAY_SIZE(throttle_list));
1411         tegra_clk_init_from_table(cardhu_clk_init_table);
1412         tegra_enable_pinmux();
1413         cardhu_pinmux_init();
1414         cardhu_i2c_init();
1415         cardhu_spi_init();
1416         cardhu_usb_init();
1417 #ifdef CONFIG_TEGRA_EDP_LIMITS
1418         cardhu_edp_init();
1419 #endif
1420         cardhu_uart_init();
1421         platform_add_devices(cardhu_devices, ARRAY_SIZE(cardhu_devices));
1422         tegra_ram_console_debug_init();
1423         tegra_io_dpd_init();
1424         cardhu_sdhci_init();
1425         cardhu_regulator_init();
1426         cardhu_dtv_init();
1427         cardhu_suspend_init();
1428         cardhu_touch_init();
1429         cardhu_modem_init();
1430         cardhu_kbc_init();
1431         cardhu_scroll_init();
1432         cardhu_keys_init();
1433         cardhu_panel_init();
1434         cardhu_pmon_init();
1435         cardhu_sensors_init();
1436         cardhu_setup_bluesleep();
1437         cardhu_sata_init();
1438         //audio_wired_jack_init();
1439         cardhu_pins_state_init();
1440         cardhu_emc_init();
1441         tegra_release_bootloader_fb();
1442         cardhu_pci_init();
1443 #ifdef CONFIG_TEGRA_WDT_RECOVERY
1444         tegra_wdt_recovery_init();
1445 #endif
1446         tegra_serial_debug_init(TEGRA_UARTD_BASE, INT_WDT_CPU, NULL, -1, -1);
1447 }
1448
1449 static void __init tegra_cardhu_reserve(void)
1450 {
1451 #if defined(CONFIG_NVMAP_CONVERT_CARVEOUT_TO_IOVMM)
1452         /* support 1920X1200 with 24bpp */
1453         tegra_reserve(0, SZ_8M + SZ_1M, SZ_8M + SZ_1M);
1454 #else
1455         tegra_reserve(SZ_128M, SZ_8M, SZ_8M);
1456 #endif
1457         tegra_ram_console_debug_reserve(SZ_1M);
1458 }
1459
1460 MACHINE_START(CARDHU, "cardhu")
1461         .atag_offset    = 0x100,
1462         .soc            = &tegra_soc_desc,
1463         .map_io         = tegra_map_common_io,
1464         .reserve        = tegra_cardhu_reserve,
1465         .init_early     = tegra30_init_early,
1466         .init_irq       = tegra_init_irq,
1467         .handle_irq     = gic_handle_irq,
1468         .timer          = &tegra_timer,
1469         .init_machine   = tegra_cardhu_init,
1470         .restart        = tegra_assert_system_reset,
1471 MACHINE_END