ARM: tegra: integration of slave mode support.
[linux-2.6.git] / arch / arm / mach-tegra / board-enterprise.c
1 /*
2  * arch/arm/mach-tegra/board-enterprise.c
3  *
4  * Copyright (c) 2011-2012, NVIDIA Corporation.
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/dma-mapping.h>
30 #include <linux/delay.h>
31 #include <linux/i2c-tegra.h>
32 #include <linux/gpio.h>
33 #include <linux/input.h>
34 #include <linux/platform_data/tegra_usb.h>
35 #include <linux/spi/spi.h>
36 #include <linux/tegra_uart.h>
37 #include <linux/fsl_devices.h>
38 #include <linux/i2c/atmel_mxt_ts.h>
39 #include <linux/memblock.h>
40 #include <linux/rfkill-gpio.h>
41 #include <linux/nfc/pn544.h>
42
43 #include <sound/max98088.h>
44
45 #include <asm/hardware/gic.h>
46
47 #include <mach/clk.h>
48 #include <mach/iomap.h>
49 #include <mach/irqs.h>
50 #include <mach/pinmux.h>
51 #include <mach/iomap.h>
52 #include <mach/io.h>
53 #include <mach/io_dpd.h>
54 #include <mach/usb_phy.h>
55 #include <mach/i2s.h>
56 #include <mach/tegra_asoc_pdata.h>
57 #include <mach/thermal.h>
58 #include <mach/tegra-bb-power.h>
59 #include <mach/gpio-tegra.h>
60 #include <mach/tegra_fiq_debugger.h>
61
62 #include <asm/mach-types.h>
63 #include <asm/hardware/gic.h>
64 #include <asm/mach/arch.h>
65
66 #include "board.h"
67 #include "clock.h"
68 #include "board-enterprise.h"
69 #include "baseband-xmm-power.h"
70 #include "devices.h"
71 #include "gpio-names.h"
72 #include "fuse.h"
73 #include "pm.h"
74 #include "common.h"
75
76 static struct balanced_throttle throttle_list[] = {
77         {
78                 .id = BALANCED_THROTTLE_ID_TJ,
79                 .throt_tab_size = 10,
80                 .throt_tab = {
81                         {      0, 1000 },
82                         { 640000, 1000 },
83                         { 640000, 1000 },
84                         { 640000, 1000 },
85                         { 640000, 1000 },
86                         { 640000, 1000 },
87                         { 760000, 1000 },
88                         { 760000, 1050 },
89                         {1000000, 1050 },
90                         {1000000, 1100 },
91                 },
92         },
93 #ifdef CONFIG_TEGRA_SKIN_THROTTLE
94         {
95                 .id = BALANCED_THROTTLE_ID_SKIN,
96                 .throt_tab_size = 6,
97                 .throt_tab = {
98                         { 640000, 1200 },
99                         { 640000, 1200 },
100                         { 760000, 1200 },
101                         { 760000, 1200 },
102                         {1000000, 1200 },
103                         {1000000, 1200 },
104                 },
105         },
106 #endif
107 };
108
109 /* All units are in millicelsius */
110 static struct tegra_thermal_data thermal_data = {
111         .shutdown_device_id = THERMAL_DEVICE_ID_NCT_EXT,
112         .temp_shutdown = 90000,
113 #if defined(CONFIG_TEGRA_EDP_LIMITS) || defined(CONFIG_TEGRA_THERMAL_THROTTLE)
114         .throttle_edp_device_id = THERMAL_DEVICE_ID_NCT_EXT,
115 #endif
116 #ifdef CONFIG_TEGRA_EDP_LIMITS
117         .edp_offset = TDIODE_OFFSET,  /* edp based on tdiode */
118         .hysteresis_edp = 3000,
119 #endif
120 #ifdef CONFIG_TEGRA_THERMAL_THROTTLE
121         .temp_throttle = 85000,
122         .tc1 = 0,
123         .tc2 = 1,
124         .passive_delay = 2000,
125 #endif
126 #ifdef CONFIG_TEGRA_SKIN_THROTTLE
127         .skin_device_id = THERMAL_DEVICE_ID_SKIN,
128         .temp_throttle_skin = 43000,
129 #endif
130 };
131
132 static struct rfkill_gpio_platform_data enterprise_bt_rfkill_pdata[] = {
133         {
134                 .name           = "bt_rfkill",
135                 .shutdown_gpio  = TEGRA_GPIO_PE6,
136                 .reset_gpio     = TEGRA_GPIO_INVALID,
137                 .type           = RFKILL_TYPE_BLUETOOTH,
138         },
139 };
140
141 static struct platform_device enterprise_bt_rfkill_device = {
142         .name = "rfkill_gpio",
143         .id             = -1,
144         .dev = {
145                 .platform_data = &enterprise_bt_rfkill_pdata,
146         },
147 };
148
149 static struct resource enterprise_bluesleep_resources[] = {
150         [0] = {
151                 .name = "gpio_host_wake",
152                         .start  = TEGRA_GPIO_PS2,
153                         .end    = TEGRA_GPIO_PS2,
154                         .flags  = IORESOURCE_IO,
155         },
156         [1] = {
157                 .name = "gpio_ext_wake",
158                         .start  = TEGRA_GPIO_PE7,
159                         .end    = TEGRA_GPIO_PE7,
160                         .flags  = IORESOURCE_IO,
161         },
162         [2] = {
163                 .name = "host_wake",
164                         .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE,
165         },
166 };
167
168 static struct platform_device enterprise_bluesleep_device = {
169         .name           = "bluesleep",
170         .id             = -1,
171         .num_resources  = ARRAY_SIZE(enterprise_bluesleep_resources),
172         .resource       = enterprise_bluesleep_resources,
173 };
174
175 static void __init enterprise_setup_bluesleep(void)
176 {
177         enterprise_bluesleep_resources[2].start =
178                 enterprise_bluesleep_resources[2].end =
179                         gpio_to_irq(TEGRA_GPIO_PS2);
180         platform_device_register(&enterprise_bluesleep_device);
181         return;
182 }
183
184 static __initdata struct tegra_clk_init_table enterprise_clk_init_table[] = {
185         /* name         parent          rate            enabled */
186         { "pll_m",      NULL,           0,              false},
187         { "hda",        "pll_p",        108000000,      false},
188         { "hda2codec_2x","pll_p",       48000000,       false},
189         { "pwm",        "pll_p",        3187500,        false},
190         { "blink",      "clk_32k",      32768,          true},
191         { "i2s0",       "pll_a_out0",   0,              false},
192         { "i2s1",       "pll_a_out0",   0,              false},
193         { "i2s2",       "pll_a_out0",   0,              false},
194         { "i2s3",       "pll_a_out0",   0,              false},
195         { "spdif_out",  "pll_a_out0",   0,              false},
196         { "d_audio",    "clk_m",        12000000,       false},
197         { "dam0",       "clk_m",        12000000,       false},
198         { "dam1",       "clk_m",        12000000,       false},
199         { "dam2",       "clk_m",        12000000,       false},
200         { "audio0",     "i2s0_sync",    0,              false},
201         { "audio1",     "i2s1_sync",    0,              false},
202         { "audio2",     "i2s2_sync",    0,              false},
203         { "audio3",     "i2s3_sync",    0,              false},
204         { "vi",         "pll_p",        0,              false},
205         { "vi_sensor",  "pll_p",        0,              false},
206         { NULL,         NULL,           0,              0},
207 };
208
209 static struct tegra_i2c_platform_data enterprise_i2c1_platform_data = {
210         .adapter_nr     = 0,
211         .bus_count      = 1,
212         .bus_clk_rate   = { 100000, 0 },
213         .scl_gpio               = {TEGRA_GPIO_PC4, 0},
214         .sda_gpio               = {TEGRA_GPIO_PC5, 0},
215         .arb_recovery = arb_lost_recovery,
216 };
217
218 static struct tegra_i2c_platform_data enterprise_i2c2_platform_data = {
219         .adapter_nr     = 1,
220         .bus_count      = 1,
221         .bus_clk_rate   = { 400000, 0 },
222         .is_clkon_always = true,
223         .scl_gpio               = {TEGRA_GPIO_PT5, 0},
224         .sda_gpio               = {TEGRA_GPIO_PT6, 0},
225         .arb_recovery = arb_lost_recovery,
226 };
227
228 static struct tegra_i2c_platform_data enterprise_i2c3_platform_data = {
229         .adapter_nr     = 2,
230         .bus_count      = 1,
231         .bus_clk_rate   = { 271000, 0 },
232         .scl_gpio               = {TEGRA_GPIO_PBB1, 0},
233         .sda_gpio               = {TEGRA_GPIO_PBB2, 0},
234         .arb_recovery = arb_lost_recovery,
235 };
236
237 static struct tegra_i2c_platform_data enterprise_i2c4_platform_data = {
238         .adapter_nr     = 3,
239         .bus_count      = 1,
240         .bus_clk_rate   = { 10000, 0 },
241         .scl_gpio               = {TEGRA_GPIO_PV4, 0},
242         .sda_gpio               = {TEGRA_GPIO_PV5, 0},
243         .arb_recovery = arb_lost_recovery,
244 };
245
246 static struct tegra_i2c_platform_data enterprise_i2c5_platform_data = {
247         .adapter_nr     = 4,
248         .bus_count      = 1,
249         .bus_clk_rate   = { 400000, 0 },
250         .scl_gpio               = {TEGRA_GPIO_PZ6, 0},
251         .sda_gpio               = {TEGRA_GPIO_PZ7, 0},
252         .arb_recovery = arb_lost_recovery,
253 };
254
255 /* Equalizer filter coefs generated from the MAXIM MAX98088
256  * evkit software tool */
257 static struct max98088_eq_cfg max98088_eq_cfg[] = {
258         {
259                 .name = "FLAT",
260                 .rate = 44100,
261                 .band1 = {0x2000, 0xC002, 0x4000, 0x00E9, 0x0000},
262                 .band2 = {0x2000, 0xC00F, 0x4000, 0x02BC, 0x0000},
263                 .band3 = {0x2000, 0xC0A7, 0x4000, 0x0916, 0x0000},
264                 .band4 = {0x2000, 0xC5C2, 0x4000, 0x1A87, 0x0000},
265                 .band5 = {0x2000, 0xF6B0, 0x4000, 0x3F51, 0x0000},
266         },
267         {
268                 .name = "LOWPASS1K",
269                 .rate = 44100,
270                 .band1 = {0x205D, 0xC001, 0x3FEF, 0x002E, 0x02E0},
271                 .band2 = {0x5B9A, 0xC093, 0x3AB2, 0x088B, 0x1981},
272                 .band3 = {0x0D22, 0xC170, 0x26EA, 0x0D79, 0x32CF},
273                 .band4 = {0x0894, 0xC612, 0x01B3, 0x1B34, 0x3FFA},
274                 .band5 = {0x0815, 0x3FFF, 0xCF78, 0x0000, 0x29B7},
275         },
276         { /* BASS=-12dB, TREBLE=+9dB, Fc=5KHz */
277                 .name = "HIBOOST",
278                 .rate = 44100,
279                 .band1 = {0x0815, 0xC001, 0x3AA4, 0x0003, 0x19A2},
280                 .band2 = {0x0815, 0xC103, 0x092F, 0x0B55, 0x3F56},
281                 .band3 = {0x0E0A, 0xC306, 0x1E5C, 0x136E, 0x3856},
282                 .band4 = {0x2459, 0xF665, 0x0CAA, 0x3F46, 0x3EBB},
283                 .band5 = {0x5BBB, 0x3FFF, 0xCEB0, 0x0000, 0x28CA},
284         },
285         { /* BASS=12dB, TREBLE=+12dB */
286                 .name = "LOUD12DB",
287                 .rate = 44100,
288                 .band1 = {0x7FC1, 0xC001, 0x3EE8, 0x0020, 0x0BC7},
289                 .band2 = {0x51E9, 0xC016, 0x3C7C, 0x033F, 0x14E9},
290                 .band3 = {0x1745, 0xC12C, 0x1680, 0x0C2F, 0x3BE9},
291                 .band4 = {0x4536, 0xD7E2, 0x0ED4, 0x31DD, 0x3E42},
292                 .band5 = {0x7FEF, 0x3FFF, 0x0BAB, 0x0000, 0x3EED},
293         },
294         {
295                 .name = "FLAT",
296                 .rate = 16000,
297                 .band1 = {0x2000, 0xC004, 0x4000, 0x0141, 0x0000},
298                 .band2 = {0x2000, 0xC033, 0x4000, 0x0505, 0x0000},
299                 .band3 = {0x2000, 0xC268, 0x4000, 0x115F, 0x0000},
300                 .band4 = {0x2000, 0xDA62, 0x4000, 0x33C6, 0x0000},
301                 .band5 = {0x2000, 0x4000, 0x4000, 0x0000, 0x0000},
302         },
303         {
304                 .name = "LOWPASS1K",
305                 .rate = 16000,
306                 .band1 = {0x2000, 0xC004, 0x4000, 0x0141, 0x0000},
307                 .band2 = {0x5BE8, 0xC3E0, 0x3307, 0x15ED, 0x26A0},
308                 .band3 = {0x0F71, 0xD15A, 0x08B3, 0x2BD0, 0x3F67},
309                 .band4 = {0x0815, 0x3FFF, 0xCF78, 0x0000, 0x29B7},
310                 .band5 = {0x0815, 0x3FFF, 0xCF78, 0x0000, 0x29B7},
311         },
312         { /* BASS=-12dB, TREBLE=+9dB, Fc=2KHz */
313                 .name = "HIBOOST",
314                 .rate = 16000,
315                 .band1 = {0x0815, 0xC001, 0x3BD2, 0x0009, 0x16BF},
316                 .band2 = {0x080E, 0xC17E, 0xF653, 0x0DBD, 0x3F43},
317                 .band3 = {0x0F80, 0xDF45, 0xEE33, 0x36FE, 0x3D79},
318                 .band4 = {0x590B, 0x3FF0, 0xE882, 0x02BD, 0x3B87},
319                 .band5 = {0x4C87, 0xF3D0, 0x063F, 0x3ED4, 0x3FB1},
320         },
321         { /* BASS=12dB, TREBLE=+12dB */
322                 .name = "LOUD12DB",
323                 .rate = 16000,
324                 .band1 = {0x7FC1, 0xC001, 0x3D07, 0x0058, 0x1344},
325                 .band2 = {0x2DA6, 0xC013, 0x3CF1, 0x02FF, 0x138B},
326                 .band3 = {0x18F1, 0xC08E, 0x244D, 0x0863, 0x34B5},
327                 .band4 = {0x2BE0, 0xF385, 0x04FD, 0x3EC5, 0x3FCE},
328                 .band5 = {0x7FEF, 0x4000, 0x0BAB, 0x0000, 0x3EED},
329         },
330 };
331
332
333 static struct max98088_pdata enterprise_max98088_pdata = {
334         /* equalizer configuration */
335         .eq_cfg = max98088_eq_cfg,
336         .eq_cfgcnt = ARRAY_SIZE(max98088_eq_cfg),
337
338         /* debounce time */
339         .debounce_time_ms = 200,
340
341         /* microphone configuration */
342         .digmic_left_mode = 1,
343         .digmic_right_mode = 1,
344
345         /* receiver output configuration */
346         .receiver_mode = 0,     /* 0 = amplifier, 1 = line output */
347 };
348
349 static struct pn544_i2c_platform_data nfc_pdata = {
350                 .irq_gpio = TEGRA_GPIO_PS4,
351                 .ven_gpio = TEGRA_GPIO_PM6,
352                 .firm_gpio = 0,
353 };
354
355
356 static struct i2c_board_info __initdata max98088_board_info = {
357         I2C_BOARD_INFO("max98088", 0x10),
358         .platform_data = &enterprise_max98088_pdata,
359 };
360
361 static struct i2c_board_info __initdata enterprise_codec_aic326x_info = {
362         I2C_BOARD_INFO("aic3262-codec", 0x18),
363 };
364
365 static struct i2c_board_info __initdata nfc_board_info = {
366         I2C_BOARD_INFO("pn544", 0x28),
367         .platform_data = &nfc_pdata,
368 };
369
370 static void enterprise_i2c_init(void)
371 {
372         tegra_i2c_device1.dev.platform_data = &enterprise_i2c1_platform_data;
373         tegra_i2c_device2.dev.platform_data = &enterprise_i2c2_platform_data;
374         tegra_i2c_device3.dev.platform_data = &enterprise_i2c3_platform_data;
375         tegra_i2c_device4.dev.platform_data = &enterprise_i2c4_platform_data;
376         tegra_i2c_device5.dev.platform_data = &enterprise_i2c5_platform_data;
377
378         platform_device_register(&tegra_i2c_device5);
379         platform_device_register(&tegra_i2c_device4);
380         platform_device_register(&tegra_i2c_device3);
381         platform_device_register(&tegra_i2c_device2);
382         platform_device_register(&tegra_i2c_device1);
383
384         max98088_board_info.irq = enterprise_codec_aic326x_info.irq =
385                 gpio_to_irq(TEGRA_GPIO_HP_DET);
386         i2c_register_board_info(0, &max98088_board_info, 1);
387         i2c_register_board_info(0, &enterprise_codec_aic326x_info, 1);
388         nfc_board_info.irq = gpio_to_irq(TEGRA_GPIO_PS4);
389         i2c_register_board_info(0, &nfc_board_info, 1);
390 }
391
392 static struct platform_device *enterprise_uart_devices[] __initdata = {
393         &tegra_uarta_device,
394         &tegra_uartb_device,
395         &tegra_uartc_device,
396         &tegra_uartd_device,
397         &tegra_uarte_device,
398 };
399
400 static struct uart_clk_parent uart_parent_clk[] = {
401         [0] = {.name = "clk_m"},
402         [1] = {.name = "pll_p"},
403 #ifndef CONFIG_TEGRA_PLLM_RESTRICTED
404         [2] = {.name = "pll_m"},
405 #endif
406 };
407 static struct tegra_uart_platform_data enterprise_uart_pdata;
408 static struct tegra_uart_platform_data enterprise_loopback_uart_pdata;
409
410 static void __init uart_debug_init(void)
411 {
412         unsigned long rate;
413         struct clk *c;
414
415         /* UARTD is the debug port. */
416         pr_info("Selecting UARTD as the debug console\n");
417         enterprise_uart_devices[3] = &debug_uartd_device;
418         debug_uart_port_base = ((struct plat_serial8250_port *)(
419                         debug_uartd_device.dev.platform_data))->mapbase;
420         debug_uart_clk = clk_get_sys("serial8250.0", "uartd");
421
422         /* Clock enable for the debug channel */
423         if (!IS_ERR_OR_NULL(debug_uart_clk)) {
424                 rate = ((struct plat_serial8250_port *)(
425                         debug_uartd_device.dev.platform_data))->uartclk;
426                 pr_info("The debug console clock name is %s\n",
427                                                 debug_uart_clk->name);
428                 c = tegra_get_clock_by_name("pll_p");
429                 if (IS_ERR_OR_NULL(c))
430                         pr_err("Not getting the parent clock pll_p\n");
431                 else
432                         clk_set_parent(debug_uart_clk, c);
433
434                 clk_enable(debug_uart_clk);
435                 clk_set_rate(debug_uart_clk, rate);
436         } else {
437                 pr_err("Not getting the clock %s for debug console\n",
438                                 debug_uart_clk->name);
439         }
440 }
441
442 static void __init enterprise_uart_init(void)
443 {
444         int i;
445         struct clk *c;
446
447         for (i = 0; i < ARRAY_SIZE(uart_parent_clk); ++i) {
448                 c = tegra_get_clock_by_name(uart_parent_clk[i].name);
449                 if (IS_ERR_OR_NULL(c)) {
450                         pr_err("Not able to get the clock for %s\n",
451                                                 uart_parent_clk[i].name);
452                         continue;
453                 }
454                 uart_parent_clk[i].parent_clk = c;
455                 uart_parent_clk[i].fixed_clk_rate = clk_get_rate(c);
456         }
457         enterprise_uart_pdata.parent_clk_list = uart_parent_clk;
458         enterprise_uart_pdata.parent_clk_count = ARRAY_SIZE(uart_parent_clk);
459         enterprise_loopback_uart_pdata.parent_clk_list = uart_parent_clk;
460         enterprise_loopback_uart_pdata.parent_clk_count =
461                                                 ARRAY_SIZE(uart_parent_clk);
462         enterprise_loopback_uart_pdata.is_loopback = true;
463         tegra_uarta_device.dev.platform_data = &enterprise_uart_pdata;
464         tegra_uartb_device.dev.platform_data = &enterprise_uart_pdata;
465         tegra_uartc_device.dev.platform_data = &enterprise_uart_pdata;
466         tegra_uartd_device.dev.platform_data = &enterprise_uart_pdata;
467         /* UARTE is used for loopback test purpose */
468         tegra_uarte_device.dev.platform_data = &enterprise_loopback_uart_pdata;
469
470         /* Register low speed only if it is selected */
471         if (!is_tegra_debug_uartport_hs())
472                 uart_debug_init();
473
474         platform_add_devices(enterprise_uart_devices,
475                                 ARRAY_SIZE(enterprise_uart_devices));
476 }
477
478 static struct resource tegra_rtc_resources[] = {
479         [0] = {
480                 .start = TEGRA_RTC_BASE,
481                 .end = TEGRA_RTC_BASE + TEGRA_RTC_SIZE - 1,
482                 .flags = IORESOURCE_MEM,
483         },
484         [1] = {
485                 .start = INT_RTC,
486                 .end = INT_RTC,
487                 .flags = IORESOURCE_IRQ,
488         },
489 };
490
491 static struct platform_device tegra_rtc_device = {
492         .name = "tegra_rtc",
493         .id   = -1,
494         .resource = tegra_rtc_resources,
495         .num_resources = ARRAY_SIZE(tegra_rtc_resources),
496 };
497
498 static struct platform_device tegra_camera = {
499         .name = "tegra_camera",
500         .id = -1,
501 };
502
503 static struct tegra_asoc_platform_data enterprise_audio_pdata = {
504         .gpio_spkr_en           = -1,
505         .gpio_hp_det            = TEGRA_GPIO_HP_DET,
506         .gpio_hp_mute           = -1,
507         .gpio_int_mic_en        = -1,
508         .gpio_ext_mic_en        = -1,
509         .debounce_time_hp       = -1,
510         /*defaults for Enterprise board*/
511         .i2s_param[HIFI_CODEC]  = {
512                 .audio_port_id  = 0,
513                 .is_i2s_master  = 1,
514                 .i2s_mode       = TEGRA_DAIFMT_I2S,
515                 .sample_size    = 16,
516         },
517         .i2s_param[BASEBAND]    = {
518                 .audio_port_id  = 2,
519                 .is_i2s_master  = 1,
520                 .i2s_mode       = TEGRA_DAIFMT_DSP_A,
521                 .sample_size    = 16,
522                 .rate           = 8000,
523                 .channels       = 1,
524         },
525         .i2s_param[BT_SCO]      = {
526                 .audio_port_id  = 3,
527                 .is_i2s_master  = 1,
528                 .i2s_mode       = TEGRA_DAIFMT_DSP_A,
529                 .sample_size    = 16,
530         },
531 };
532
533 static struct platform_device enterprise_audio_device = {
534         .name   = "tegra-snd-max98088",
535         .id     = 0,
536         .dev    = {
537                 .platform_data  = &enterprise_audio_pdata,
538         },
539 };
540
541 static struct tegra_asoc_platform_data enterprise_audio_aic326x_pdata = {
542         .gpio_spkr_en           = -1,
543         .gpio_hp_det            = TEGRA_GPIO_HP_DET,
544         .gpio_hp_mute           = -1,
545         .gpio_int_mic_en        = -1,
546         .gpio_ext_mic_en        = -1,
547         /*defaults for Verbier-Enterprise (E1197) board with TI AIC326X codec*/
548         .i2s_param[HIFI_CODEC]  = {
549                 .audio_port_id  = 0,
550                 .is_i2s_master  = 1,
551                 .i2s_mode       = TEGRA_DAIFMT_I2S,
552                 .sample_size    = 16,
553         },
554         .i2s_param[BASEBAND]    = {
555                 .audio_port_id  = 2,
556                 .is_i2s_master  = 1,
557                 .i2s_mode       = TEGRA_DAIFMT_DSP_A,
558                 .sample_size    = 16,
559                 .rate           = 8000,
560                 .channels       = 1,
561         },
562         .i2s_param[BT_SCO]      = {
563                 .sample_size    = 16,
564                 .audio_port_id  = 3,
565                 .is_i2s_master  = 1,
566                 .i2s_mode       = TEGRA_DAIFMT_DSP_A,
567         },
568 };
569
570 static struct platform_device enterprise_audio_aic326x_device = {
571         .name   = "tegra-snd-aic326x",
572         .id     = 0,
573         .dev    = {
574                 .platform_data  = &enterprise_audio_aic326x_pdata,
575         },
576 };
577
578 static struct platform_device *enterprise_devices[] __initdata = {
579         &tegra_pmu_device,
580         &tegra_rtc_device,
581         &tegra_udc_device,
582 #if defined(CONFIG_TEGRA_IOVMM_SMMU) || defined(CONFIG_TEGRA_IOMMU_SMMU)
583         &tegra_smmu_device,
584 #endif
585         &tegra_wdt0_device,
586         &tegra_wdt1_device,
587         &tegra_wdt2_device,
588 #if defined(CONFIG_TEGRA_AVP)
589         &tegra_avp_device,
590 #endif
591         &tegra_camera,
592         &enterprise_bt_rfkill_device,
593         &tegra_spi_device4,
594         &tegra_hda_device,
595 #if defined(CONFIG_CRYPTO_DEV_TEGRA_SE)
596         &tegra_se_device,
597 #endif
598 #if defined(CONFIG_CRYPTO_DEV_TEGRA_AES)
599         &tegra_aes_device,
600 #endif
601 };
602
603 #define MXT_CONFIG_CRC 0x62F903
604 /*
605  * Config converted from memory-mapped cfg-file with
606  * following version information:
607  *
608  *
609  *
610  *      FAMILY_ID=128
611  *      VARIANT=1
612  *      VERSION=32
613  *      BUILD=170
614  *      VENDOR_ID=255
615  *      PRODUCT_ID=TBD
616  *      CHECKSUM=0xC189B6
617  *
618  *
619  */
620
621 static const u8 config[] = {
622         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
623         0xFF, 0xFF, 0x32, 0x0A, 0x00, 0x05, 0x01, 0x00,
624         0x00, 0x1E, 0x0A, 0x8B, 0x00, 0x00, 0x13, 0x0B,
625         0x00, 0x10, 0x32, 0x03, 0x03, 0x00, 0x03, 0x01,
626         0x00, 0x0A, 0x0A, 0x0A, 0x0A, 0xBF, 0x03, 0x1B,
627         0x02, 0x00, 0x00, 0x37, 0x37, 0x00, 0x00, 0x00,
628         0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
629         0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
630         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
631         0x00, 0x00, 0x00, 0xA9, 0x7F, 0x9A, 0x0E, 0x00,
632         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
633         0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
634         0x00, 0x00, 0x03, 0x23, 0x00, 0x00, 0x00, 0x0A,
635         0x0F, 0x14, 0x19, 0x03, 0x00, 0x00, 0x00, 0x00,
636         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
637         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
638         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
639         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
640         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
641         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
642         0x00, 0x00, 0x00, 0x01, 0x00, 0x03, 0x08, 0x10,
643         0x00
644 };
645
646 static struct mxt_platform_data atmel_mxt_info = {
647         .x_line         = 19,
648         .y_line         = 11,
649         .x_size         = 960,
650         .y_size         = 540,
651         .blen           = 0x10,
652         .threshold      = 0x32,
653         .voltage        = 3300000,              /* 3.3V */
654         .orient         = 3,
655         .config         = config,
656         .config_length  = 168,
657         .config_crc     = MXT_CONFIG_CRC,
658         .irqflags       = IRQF_TRIGGER_FALLING,
659 /*      .read_chg       = &read_chg, */
660         .read_chg       = NULL,
661 };
662
663 static struct i2c_board_info __initdata atmel_i2c_info[] = {
664         {
665                 I2C_BOARD_INFO("atmel_mxt_ts", MXT224_I2C_ADDR1),
666                 .platform_data = &atmel_mxt_info,
667         }
668 };
669
670 static int __init enterprise_touch_init(void)
671 {
672         gpio_request(TEGRA_GPIO_PH6, "atmel-irq");
673         gpio_direction_input(TEGRA_GPIO_PH6);
674
675         gpio_request(TEGRA_GPIO_PF5, "atmel-reset");
676         gpio_direction_output(TEGRA_GPIO_PF5, 0);
677         msleep(1);
678         gpio_set_value(TEGRA_GPIO_PF5, 1);
679         msleep(100);
680
681         atmel_i2c_info[0].irq = gpio_to_irq(TEGRA_GPIO_PH6);
682         i2c_register_board_info(1, atmel_i2c_info, 1);
683
684         return 0;
685 }
686
687 static void enterprise_usb_hsic_postsupend(void)
688 {
689         pr_debug("%s\n", __func__);
690 #ifdef CONFIG_TEGRA_BB_XMM_POWER
691         baseband_xmm_set_power_status(BBXMM_PS_L2);
692 #endif
693 }
694
695 static void enterprise_usb_hsic_preresume(void)
696 {
697         pr_debug("%s\n", __func__);
698 #ifdef CONFIG_TEGRA_BB_XMM_POWER
699         baseband_xmm_set_power_status(BBXMM_PS_L2TOL0);
700 #endif
701 }
702
703 static void enterprise_usb_hsic_phy_power(void)
704 {
705         pr_debug("%s\n", __func__);
706 #ifdef CONFIG_TEGRA_BB_XMM_POWER
707         baseband_xmm_set_power_status(BBXMM_PS_L0);
708 #endif
709 }
710
711 static void enterprise_usb_hsic_post_phy_off(void)
712 {
713         pr_debug("%s\n", __func__);
714 #ifdef CONFIG_TEGRA_BB_XMM_POWER
715         baseband_xmm_set_power_status(BBXMM_PS_L2);
716 #endif
717 }
718
719 static struct tegra_usb_phy_platform_ops hsic_xmm_plat_ops = {
720         .post_suspend = enterprise_usb_hsic_postsupend,
721         .pre_resume = enterprise_usb_hsic_preresume,
722         .port_power = enterprise_usb_hsic_phy_power,
723         .post_phy_off = enterprise_usb_hsic_post_phy_off,
724 };
725
726 static struct tegra_usb_platform_data tegra_ehci2_hsic_xmm_pdata = {
727         .port_otg = false,
728         .has_hostpc = true,
729         .phy_intf = TEGRA_USB_PHY_INTF_HSIC,
730         .op_mode        = TEGRA_USB_OPMODE_HOST,
731         .u_data.host = {
732                 .vbus_gpio = -1,
733                 .hot_plug = false,
734                 .remote_wakeup_supported = false,
735                 .power_off_on_suspend = false,
736         },
737         .u_cfg.hsic = {
738                 .sync_start_delay = 9,
739                 .idle_wait_delay = 17,
740                 .term_range_adj = 0,
741                 .elastic_underrun_limit = 16,
742                 .elastic_overrun_limit = 16,
743         },
744         .ops = &hsic_xmm_plat_ops,
745 };
746
747
748
749 static struct tegra_usb_platform_data tegra_udc_pdata = {
750         .port_otg = true,
751         .has_hostpc = true,
752         .builtin_host_disabled = true,
753         .phy_intf = TEGRA_USB_PHY_INTF_UTMI,
754         .op_mode = TEGRA_USB_OPMODE_DEVICE,
755         .u_data.dev = {
756                 .vbus_pmu_irq = ENT_TPS80031_IRQ_BASE +
757                                 TPS80031_INT_VBUS_DET,
758                 .vbus_gpio = -1,
759                 .charging_supported = false,
760                 .remote_wakeup_supported = false,
761         },
762         .u_cfg.utmi = {
763                 .hssync_start_delay = 0,
764                 .elastic_limit = 16,
765                 .idle_wait_delay = 17,
766                 .term_range_adj = 6,
767                 .xcvr_setup = 8,
768                 .xcvr_lsfslew = 2,
769                 .xcvr_lsrslew = 2,
770                 .xcvr_setup_offset = 0,
771                 .xcvr_use_fuses = 1,
772         },
773 };
774
775 static struct tegra_usb_platform_data tegra_ehci1_utmi_pdata = {
776         .port_otg = true,
777         .has_hostpc = true,
778         .builtin_host_disabled = true,
779         .phy_intf = TEGRA_USB_PHY_INTF_UTMI,
780         .op_mode = TEGRA_USB_OPMODE_HOST,
781         .u_data.host = {
782                 .vbus_gpio = -1,
783                 .vbus_reg = "usb_vbus",
784                 .hot_plug = true,
785                 .remote_wakeup_supported = true,
786                 .power_off_on_suspend = true,
787         },
788         .u_cfg.utmi = {
789                 .hssync_start_delay = 0,
790                 .elastic_limit = 16,
791                 .idle_wait_delay = 17,
792                 .term_range_adj = 6,
793                 .xcvr_setup = 15,
794                 .xcvr_lsfslew = 2,
795                 .xcvr_lsrslew = 2,
796                 .xcvr_setup_offset = 0,
797                 .xcvr_use_fuses = 1,
798         },
799 };
800
801 static struct tegra_usb_otg_data tegra_otg_pdata = {
802         .ehci_device = &tegra_ehci1_device,
803         .ehci_pdata = &tegra_ehci1_utmi_pdata,
804 };
805
806 struct platform_device *tegra_usb_hsic_host_register(void)
807 {
808         struct platform_device *pdev;
809         int val;
810
811         pdev = platform_device_alloc(tegra_ehci2_device.name,
812                 tegra_ehci2_device.id);
813         if (!pdev)
814                 return NULL;
815
816         val = platform_device_add_resources(pdev, tegra_ehci2_device.resource,
817                 tegra_ehci2_device.num_resources);
818         if (val)
819                 goto error;
820
821         pdev->dev.dma_mask =  tegra_ehci2_device.dev.dma_mask;
822         pdev->dev.coherent_dma_mask = tegra_ehci2_device.dev.coherent_dma_mask;
823
824         val = platform_device_add_data(pdev, &tegra_ehci2_hsic_xmm_pdata,
825                         sizeof(struct tegra_usb_platform_data));
826         if (val)
827                 goto error;
828
829         val = platform_device_add(pdev);
830         if (val)
831                 goto error;
832
833         return pdev;
834
835 error:
836         pr_err("%s: failed to add the host contoller device\n", __func__);
837         platform_device_put(pdev);
838         return NULL;
839 }
840
841 void tegra_usb_hsic_host_unregister(struct platform_device *pdev)
842 {
843         platform_device_unregister(pdev);
844 }
845
846 static void enterprise_usb_init(void)
847 {
848         tegra_udc_device.dev.platform_data = &tegra_udc_pdata;
849
850         tegra_otg_device.dev.platform_data = &tegra_otg_pdata;
851         platform_device_register(&tegra_otg_device);
852 }
853
854 static struct platform_device *enterprise_audio_devices[] __initdata = {
855         &tegra_ahub_device,
856         &tegra_dam_device0,
857         &tegra_dam_device1,
858         &tegra_dam_device2,
859         &tegra_i2s_device0,
860         &tegra_i2s_device1,
861         &tegra_i2s_device2,
862         &tegra_i2s_device3,
863         &tegra_spdif_device,
864         &spdif_dit_device,
865         &bluetooth_dit_device,
866         &baseband_dit_device,
867         &tegra_pcm_device,
868         &enterprise_audio_device,
869         &enterprise_audio_aic326x_device,
870 };
871
872 static void enterprise_audio_init(void)
873 {
874         struct board_info board_info;
875
876         tegra_get_board_info(&board_info);
877
878         if (board_info.board_id == BOARD_E1197)
879                 enterprise_audio_pdata.i2s_param[HIFI_CODEC].audio_port_id = 1;
880
881         platform_add_devices(enterprise_audio_devices,
882                         ARRAY_SIZE(enterprise_audio_devices));
883 }
884
885
886 static struct baseband_power_platform_data tegra_baseband_power_data = {
887         .baseband_type = BASEBAND_XMM,
888         .modem = {
889                 .xmm = {
890                         .bb_rst = XMM_GPIO_BB_RST,
891                         .bb_on = XMM_GPIO_BB_ON,
892                         .ipc_bb_wake = XMM_GPIO_IPC_BB_WAKE,
893                         .ipc_ap_wake = XMM_GPIO_IPC_AP_WAKE,
894                         .ipc_hsic_active = XMM_GPIO_IPC_HSIC_ACTIVE,
895                         .ipc_hsic_sus_req = XMM_GPIO_IPC_HSIC_SUS_REQ,
896                 },
897         },
898 };
899
900 static struct platform_device tegra_baseband_power_device = {
901         .name = "baseband_xmm_power",
902         .id = -1,
903         .dev = {
904                 .platform_data = &tegra_baseband_power_data,
905         },
906 };
907
908 static struct platform_device tegra_baseband_power2_device = {
909         .name = "baseband_xmm_power2",
910         .id = -1,
911         .dev = {
912                 .platform_data = &tegra_baseband_power_data,
913         },
914 };
915
916 #ifdef CONFIG_TEGRA_BB_M7400
917 static union tegra_bb_gpio_id m7400_gpio_id = {
918         .m7400 = {
919                 .pwr_status = GPIO_BB_RESET,
920                 .pwr_on = GPIO_BB_PWRON,
921                 .uart_awr = GPIO_BB_APACK,
922                 .uart_cwr = GPIO_BB_CPACK,
923                 .usb_awr = GPIO_BB_APACK2,
924                 .usb_cwr = GPIO_BB_CPACK2,
925                 .service = GPIO_BB_RSVD2,
926                 .resout2 = GPIO_BB_RSVD1,
927         },
928 };
929
930 static struct tegra_bb_pdata m7400_pdata = {
931         .id = &m7400_gpio_id,
932         .device = &tegra_ehci2_device,
933         .ehci_register = tegra_usb_hsic_host_register,
934         .ehci_unregister = tegra_usb_hsic_host_unregister,
935         .bb_id = TEGRA_BB_M7400,
936 };
937
938 static struct platform_device tegra_baseband_m7400_device = {
939         .name = "tegra_baseband_power",
940         .id = -1,
941         .dev = {
942                 .platform_data = &m7400_pdata,
943         },
944 };
945 #endif
946
947 static void enterprise_baseband_init(void)
948 {
949         int modem_id = tegra_get_modem_id();
950
951         switch (modem_id) {
952         case TEGRA_BB_PH450: /* PH450 ULPI */
953                 enterprise_modem_init();
954                 break;
955         case TEGRA_BB_XMM6260: /* XMM6260 HSIC */
956                 /* baseband-power.ko will register ehci2 device */
957                 tegra_ehci2_device.dev.platform_data =
958                                         &tegra_ehci2_hsic_xmm_pdata;
959                 tegra_baseband_power_data.hsic_register =
960                                                 &tegra_usb_hsic_host_register;
961                 tegra_baseband_power_data.hsic_unregister =
962                                                 &tegra_usb_hsic_host_unregister;
963
964                 platform_device_register(&tegra_baseband_power_device);
965                 platform_device_register(&tegra_baseband_power2_device);
966                 break;
967 #ifdef CONFIG_TEGRA_BB_M7400
968         case TEGRA_BB_M7400: /* M7400 HSIC */
969                 tegra_ehci2_hsic_xmm_pdata.u_data.host.power_off_on_suspend = 0;
970                 tegra_ehci2_device.dev.platform_data
971                         = &tegra_ehci2_hsic_xmm_pdata;
972                 platform_device_register(&tegra_baseband_m7400_device);
973                 break;
974 #endif
975         }
976 }
977 static void enterprise_nfc_init(void)
978 {
979         struct board_info bi;
980
981         /* Enable firmware GPIO PX7 for board E1205 */
982         tegra_get_board_info(&bi);
983         if (bi.board_id == BOARD_E1205 && bi.fab >= BOARD_FAB_A03) {
984                 nfc_pdata.firm_gpio = TEGRA_GPIO_PX7;
985         }
986 }
987
988 static void __init tegra_enterprise_init(void)
989 {
990         tegra_thermal_init(&thermal_data,
991                                 throttle_list,
992                                 ARRAY_SIZE(throttle_list));
993         tegra_clk_init_from_table(enterprise_clk_init_table);
994         tegra_enable_pinmux();
995         enterprise_pinmux_init();
996         enterprise_i2c_init();
997         enterprise_uart_init();
998         enterprise_usb_init();
999         platform_add_devices(enterprise_devices, ARRAY_SIZE(enterprise_devices));
1000         tegra_ram_console_debug_init();
1001         enterprise_regulator_init();
1002         tegra_io_dpd_init();
1003         enterprise_sdhci_init();
1004 #ifdef CONFIG_TEGRA_EDP_LIMITS
1005         enterprise_edp_init();
1006 #endif
1007         enterprise_kbc_init();
1008         enterprise_nfc_init();
1009         enterprise_touch_init();
1010         enterprise_audio_init();
1011         enterprise_baseband_init();
1012         enterprise_panel_init();
1013         enterprise_setup_bluesleep();
1014         enterprise_emc_init();
1015         enterprise_sensors_init();
1016         enterprise_suspend_init();
1017         enterprise_bpc_mgmt_init();
1018         tegra_release_bootloader_fb();
1019         tegra_serial_debug_init(TEGRA_UARTD_BASE, INT_WDT_CPU, NULL, -1, -1);
1020 }
1021
1022 static void __init tegra_enterprise_reserve(void)
1023 {
1024 #if defined(CONFIG_NVMAP_CONVERT_CARVEOUT_TO_IOVMM)
1025         tegra_reserve(0, SZ_4M, SZ_8M);
1026 #else
1027         tegra_reserve(SZ_128M, SZ_4M, SZ_8M);
1028 #endif
1029         tegra_ram_console_debug_reserve(SZ_1M);
1030 }
1031
1032 MACHINE_START(TEGRA_ENTERPRISE, "tegra_enterprise")
1033         .atag_offset    = 0x100,
1034         .soc            = &tegra_soc_desc,
1035         .map_io         = tegra_map_common_io,
1036         .reserve        = tegra_enterprise_reserve,
1037         .init_early     = tegra30_init_early,
1038         .init_irq       = tegra_init_irq,
1039         .handle_irq     = gic_handle_irq,
1040         .timer          = &tegra_timer,
1041         .init_machine   = tegra_enterprise_init,
1042         .restart        = tegra_assert_system_reset,
1043 MACHINE_END