Ventana: KBC: Removing the KBC usage on ventana
[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, 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
40 #include <sound/max98088.h>
41
42 #include <mach/clk.h>
43 #include <mach/iomap.h>
44 #include <mach/irqs.h>
45 #include <mach/pinmux.h>
46 #include <mach/iomap.h>
47 #include <mach/io.h>
48 #include <asm/mach-types.h>
49 #include <asm/mach/arch.h>
50 #include <mach/usb_phy.h>
51 #include <mach/i2s.h>
52 #include <mach/tegra_max98088_pdata.h>
53
54 #include "board.h"
55 #include "clock.h"
56 #include "board-enterprise.h"
57 #include "devices.h"
58 #include "gpio-names.h"
59 #include "fuse.h"
60 #include "pm.h"
61
62 /* !!!TODO: Change for enterprise (Taken from Cardhu) */
63 static struct tegra_utmip_config utmi_phy_config[] = {
64         [0] = {
65                         .hssync_start_delay = 0,
66                         .idle_wait_delay = 17,
67                         .elastic_limit = 16,
68                         .term_range_adj = 6,
69                         .xcvr_setup = 15,
70                         .xcvr_setup_offset = 0,
71                         .xcvr_use_fuses = 1,
72                         .xcvr_lsfslew = 2,
73                         .xcvr_lsrslew = 2,
74         },
75         [1] = {
76                         .hssync_start_delay = 0,
77                         .idle_wait_delay = 17,
78                         .elastic_limit = 16,
79                         .term_range_adj = 6,
80                         .xcvr_setup = 15,
81                         .xcvr_setup_offset = 0,
82                         .xcvr_use_fuses = 1,
83                         .xcvr_lsfslew = 2,
84                         .xcvr_lsrslew = 2,
85         },
86         [2] = {
87                         .hssync_start_delay = 0,
88                         .idle_wait_delay = 17,
89                         .elastic_limit = 16,
90                         .term_range_adj = 6,
91                         .xcvr_setup = 8,
92                         .xcvr_setup_offset = 0,
93                         .xcvr_use_fuses = 1,
94                         .xcvr_lsfslew = 2,
95                         .xcvr_lsrslew = 2,
96         },
97 };
98
99 #ifdef CONFIG_BCM4329_RFKILL
100 static struct resource enterprise_bcm4329_rfkill_resources[] = {
101         {
102                 .name   = "bcm4329_nshutdown_gpio",
103                 .start  = TEGRA_GPIO_PE6,
104                 .end    = TEGRA_GPIO_PE6,
105                 .flags  = IORESOURCE_IO,
106         },
107 };
108
109 static struct platform_device enterprise_bcm4329_rfkill_device = {
110         .name = "bcm4329_rfkill",
111         .id             = -1,
112         .num_resources  = ARRAY_SIZE(enterprise_bcm4329_rfkill_resources),
113         .resource       = enterprise_bcm4329_rfkill_resources,
114 };
115
116 static noinline void __init enterprise_bt_rfkill(void)
117 {
118         platform_device_register(&enterprise_bcm4329_rfkill_device);
119
120         return;
121 }
122 #else
123 static inline void enterprise_bt_rfkill(void) { }
124 #endif
125
126 static void __init enterprise_setup_bluesleep(void)
127 {
128         struct platform_device *pdev = NULL;
129         struct resource *res;
130
131         pdev = platform_device_alloc("bluesleep", 0);
132         if (!pdev) {
133                 pr_err("unable to allocate platform device for bluesleep");
134                 return;
135         }
136
137         res = kzalloc(sizeof(struct resource) * 3, GFP_KERNEL);
138         if (!res) {
139                 pr_err("unable to allocate resource for bluesleep\n");
140                 goto err_free_dev;
141         }
142
143         res[0].name   = "gpio_host_wake";
144         res[0].start  = TEGRA_GPIO_PS2;
145         res[0].end    = TEGRA_GPIO_PS2;
146         res[0].flags  = IORESOURCE_IO;
147
148         res[1].name   = "gpio_ext_wake";
149         res[1].start  = TEGRA_GPIO_PE7;
150         res[1].end    = TEGRA_GPIO_PE7;
151         res[1].flags  = IORESOURCE_IO;
152
153         res[2].name   = "host_wake";
154         res[2].start  = gpio_to_irq(TEGRA_GPIO_PS2);
155         res[2].end    = gpio_to_irq(TEGRA_GPIO_PS2);
156         res[2].flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE ;
157
158         if (platform_device_add_resources(pdev, res, 3)) {
159                 pr_err("unable to add resources to bluesleep device\n");
160                 goto err_free_res;
161         }
162
163         if (platform_device_add(pdev)) {
164                 pr_err("unable to add bluesleep device\n");
165                 goto err_free_res;
166         }
167         tegra_gpio_enable(TEGRA_GPIO_PS2);
168         tegra_gpio_enable(TEGRA_GPIO_PE7);
169
170         return;
171
172 err_free_res:
173         kfree(res);
174 err_free_dev:
175         platform_device_put(pdev);
176         return;
177 }
178
179 static __initdata struct tegra_clk_init_table enterprise_clk_init_table[] = {
180         /* name         parent          rate            enabled */
181         { "pll_m",      NULL,           0,              true},
182         { "hda",        "pll_p",        108000000,      false},
183         { "hda2codec_2x","pll_p",       48000000,       false},
184         { "pwm",        "clk_32k",      32768,          false},
185         { "blink",      "clk_32k",      32768,          true},
186         { "pll_a",      NULL,           564480000,      false},
187         { "pll_a_out0", NULL,           11289600,       false},
188         { "i2s0",       "pll_a_out0",   0,              false},
189         { NULL,         NULL,           0,              0},
190 };
191
192 static struct tegra_i2c_platform_data enterprise_i2c1_platform_data = {
193         .adapter_nr     = 0,
194         .bus_count      = 1,
195         .bus_clk_rate   = { 100000, 0 },
196         .scl_gpio               = {TEGRA_GPIO_PC4, 0},
197         .sda_gpio               = {TEGRA_GPIO_PC5, 0},
198         .arb_recovery = arb_lost_recovery,
199 };
200
201 static struct tegra_i2c_platform_data enterprise_i2c2_platform_data = {
202         .adapter_nr     = 1,
203         .bus_count      = 1,
204         .bus_clk_rate   = { 100000, 0 },
205         .is_clkon_always = true,
206         .scl_gpio               = {TEGRA_GPIO_PT5, 0},
207         .sda_gpio               = {TEGRA_GPIO_PT6, 0},
208         .arb_recovery = arb_lost_recovery,
209 };
210
211 static struct tegra_i2c_platform_data enterprise_i2c3_platform_data = {
212         .adapter_nr     = 2,
213         .bus_count      = 1,
214         .bus_clk_rate   = { 100000, 0 },
215         .scl_gpio               = {TEGRA_GPIO_PBB1, 0},
216         .sda_gpio               = {TEGRA_GPIO_PBB2, 0},
217         .arb_recovery = arb_lost_recovery,
218 };
219
220 static struct tegra_i2c_platform_data enterprise_i2c4_platform_data = {
221         .adapter_nr     = 3,
222         .bus_count      = 1,
223         .bus_clk_rate   = { 100000, 0 },
224         .scl_gpio               = {TEGRA_GPIO_PV4, 0},
225         .sda_gpio               = {TEGRA_GPIO_PV5, 0},
226         .arb_recovery = arb_lost_recovery,
227 };
228
229 static struct tegra_i2c_platform_data enterprise_i2c5_platform_data = {
230         .adapter_nr     = 4,
231         .bus_count      = 1,
232         .bus_clk_rate   = { 100000, 0 },
233         .scl_gpio               = {TEGRA_GPIO_PZ6, 0},
234         .sda_gpio               = {TEGRA_GPIO_PZ7, 0},
235         .arb_recovery = arb_lost_recovery,
236 };
237
238 /* Equalizer filter coefs generated from the MAXIM MAX98088
239  * evkit software tool */
240 static struct max98088_eq_cfg max98088_eq_cfg[] = {
241         {
242                 .name = "FLAT",
243                 .rate = 44100,
244                 .band1 = {0x2000, 0xC002, 0x4000, 0x00E9, 0x0000},
245                 .band2 = {0x2000, 0xC00F, 0x4000, 0x02BC, 0x0000},
246                 .band3 = {0x2000, 0xC0A7, 0x4000, 0x0916, 0x0000},
247                 .band4 = {0x2000, 0xC5C2, 0x4000, 0x1A87, 0x0000},
248                 .band5 = {0x2000, 0xF6B0, 0x4000, 0x3F51, 0x0000},
249         },
250         {
251                 .name = "LOWPASS1K",
252                 .rate = 44100,
253                 .band1 = {0x205D, 0xC001, 0x3FEF, 0x002E, 0x02E0},
254                 .band2 = {0x5B9A, 0xC093, 0x3AB2, 0x088B, 0x1981},
255                 .band3 = {0x0D22, 0xC170, 0x26EA, 0x0D79, 0x32CF},
256                 .band4 = {0x0894, 0xC612, 0x01B3, 0x1B34, 0x3FFA},
257                 .band5 = {0x0815, 0x3FFF, 0xCF78, 0x0000, 0x29B7},
258         },
259         { /* BASS=-12dB, TREBLE=+9dB, Fc=5KHz */
260                 .name = "HIBOOST",
261                 .rate = 44100,
262                 .band1 = {0x0815, 0xC001, 0x3AA4, 0x0003, 0x19A2},
263                 .band2 = {0x0815, 0xC103, 0x092F, 0x0B55, 0x3F56},
264                 .band3 = {0x0E0A, 0xC306, 0x1E5C, 0x136E, 0x3856},
265                 .band4 = {0x2459, 0xF665, 0x0CAA, 0x3F46, 0x3EBB},
266                 .band5 = {0x5BBB, 0x3FFF, 0xCEB0, 0x0000, 0x28CA},
267         },
268         { /* BASS=12dB, TREBLE=+12dB */
269                 .name = "LOUD12DB",
270                 .rate = 44100,
271                 .band1 = {0x7FC1, 0xC001, 0x3EE8, 0x0020, 0x0BC7},
272                 .band2 = {0x51E9, 0xC016, 0x3C7C, 0x033F, 0x14E9},
273                 .band3 = {0x1745, 0xC12C, 0x1680, 0x0C2F, 0x3BE9},
274                 .band4 = {0x4536, 0xD7E2, 0x0ED4, 0x31DD, 0x3E42},
275                 .band5 = {0x7FEF, 0x3FFF, 0x0BAB, 0x0000, 0x3EED},
276         },
277         {
278                 .name = "FLAT",
279                 .rate = 16000,
280                 .band1 = {0x2000, 0xC004, 0x4000, 0x0141, 0x0000},
281                 .band2 = {0x2000, 0xC033, 0x4000, 0x0505, 0x0000},
282                 .band3 = {0x2000, 0xC268, 0x4000, 0x115F, 0x0000},
283                 .band4 = {0x2000, 0xDA62, 0x4000, 0x33C6, 0x0000},
284                 .band5 = {0x2000, 0x4000, 0x4000, 0x0000, 0x0000},
285         },
286         {
287                 .name = "LOWPASS1K",
288                 .rate = 16000,
289                 .band1 = {0x2000, 0xC004, 0x4000, 0x0141, 0x0000},
290                 .band2 = {0x5BE8, 0xC3E0, 0x3307, 0x15ED, 0x26A0},
291                 .band3 = {0x0F71, 0xD15A, 0x08B3, 0x2BD0, 0x3F67},
292                 .band4 = {0x0815, 0x3FFF, 0xCF78, 0x0000, 0x29B7},
293                 .band5 = {0x0815, 0x3FFF, 0xCF78, 0x0000, 0x29B7},
294         },
295         { /* BASS=-12dB, TREBLE=+9dB, Fc=2KHz */
296                 .name = "HIBOOST",
297                 .rate = 16000,
298                 .band1 = {0x0815, 0xC001, 0x3BD2, 0x0009, 0x16BF},
299                 .band2 = {0x080E, 0xC17E, 0xF653, 0x0DBD, 0x3F43},
300                 .band3 = {0x0F80, 0xDF45, 0xEE33, 0x36FE, 0x3D79},
301                 .band4 = {0x590B, 0x3FF0, 0xE882, 0x02BD, 0x3B87},
302                 .band5 = {0x4C87, 0xF3D0, 0x063F, 0x3ED4, 0x3FB1},
303         },
304         { /* BASS=12dB, TREBLE=+12dB */
305                 .name = "LOUD12DB",
306                 .rate = 16000,
307                 .band1 = {0x7FC1, 0xC001, 0x3D07, 0x0058, 0x1344},
308                 .band2 = {0x2DA6, 0xC013, 0x3CF1, 0x02FF, 0x138B},
309                 .band3 = {0x18F1, 0xC08E, 0x244D, 0x0863, 0x34B5},
310                 .band4 = {0x2BE0, 0xF385, 0x04FD, 0x3EC5, 0x3FCE},
311                 .band5 = {0x7FEF, 0x4000, 0x0BAB, 0x0000, 0x3EED},
312         },
313 };
314
315
316 static struct max98088_pdata enterprise_max98088_pdata = {
317         /* equalizer configuration */
318         .eq_cfg = max98088_eq_cfg,
319         .eq_cfgcnt = ARRAY_SIZE(max98088_eq_cfg),
320
321         /* microphone configuration */
322         .digmic_left_mode = 1,
323         .digmic_right_mode = 1,
324
325         /* receiver output configuration */
326         .receiver_mode = 0,     /* 0 = amplifier, 1 = line output */
327 };
328
329
330 static struct i2c_board_info __initdata max98088_board_info = {
331         I2C_BOARD_INFO("max98088", 0x10),
332         .platform_data = &enterprise_max98088_pdata,
333         .irq = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_HP_DET),
334 };
335
336 static void enterprise_i2c_init(void)
337 {
338         tegra_i2c_device1.dev.platform_data = &enterprise_i2c1_platform_data;
339         tegra_i2c_device2.dev.platform_data = &enterprise_i2c2_platform_data;
340         tegra_i2c_device3.dev.platform_data = &enterprise_i2c3_platform_data;
341         tegra_i2c_device4.dev.platform_data = &enterprise_i2c4_platform_data;
342         tegra_i2c_device5.dev.platform_data = &enterprise_i2c5_platform_data;
343
344         platform_device_register(&tegra_i2c_device5);
345         platform_device_register(&tegra_i2c_device4);
346         platform_device_register(&tegra_i2c_device3);
347         platform_device_register(&tegra_i2c_device2);
348         platform_device_register(&tegra_i2c_device1);
349
350         i2c_register_board_info(0, &max98088_board_info, 1);
351 }
352
353 static struct platform_device *enterprise_uart_devices[] __initdata = {
354         &tegra_uarta_device,
355         &tegra_uartb_device,
356         &tegra_uartc_device,
357         &tegra_uartd_device,
358         &tegra_uarte_device,
359 };
360
361 static struct uart_clk_parent uart_parent_clk[] = {
362         [0] = {.name = "clk_m"},
363         [1] = {.name = "pll_p"},
364         [2] = {.name = "pll_m"},
365 };
366 static struct tegra_uart_platform_data enterprise_uart_pdata;
367
368 static void __init uart_debug_init(void)
369 {
370         unsigned long rate;
371         struct clk *c;
372
373         /* UARTD is the debug port. */
374         pr_info("Selecting UARTD as the debug console\n");
375         enterprise_uart_devices[3] = &debug_uartd_device;
376         debug_uart_port_base = ((struct plat_serial8250_port *)(
377                         debug_uartd_device.dev.platform_data))->mapbase;
378         debug_uart_clk = clk_get_sys("serial8250.0", "uartd");
379
380         /* Clock enable for the debug channel */
381         if (!IS_ERR_OR_NULL(debug_uart_clk)) {
382                 rate = ((struct plat_serial8250_port *)(
383                         debug_uartd_device.dev.platform_data))->uartclk;
384                 pr_info("The debug console clock name is %s\n",
385                                                 debug_uart_clk->name);
386                 c = tegra_get_clock_by_name("pll_p");
387                 if (IS_ERR_OR_NULL(c))
388                         pr_err("Not getting the parent clock pll_p\n");
389                 else
390                         clk_set_parent(debug_uart_clk, c);
391
392                 clk_enable(debug_uart_clk);
393                 clk_set_rate(debug_uart_clk, rate);
394         } else {
395                 pr_err("Not getting the clock %s for debug console\n",
396                                 debug_uart_clk->name);
397         }
398 }
399
400 static void __init enterprise_uart_init(void)
401 {
402         int i;
403         struct clk *c;
404
405         for (i = 0; i < ARRAY_SIZE(uart_parent_clk); ++i) {
406                 c = tegra_get_clock_by_name(uart_parent_clk[i].name);
407                 if (IS_ERR_OR_NULL(c)) {
408                         pr_err("Not able to get the clock for %s\n",
409                                                 uart_parent_clk[i].name);
410                         continue;
411                 }
412                 uart_parent_clk[i].parent_clk = c;
413                 uart_parent_clk[i].fixed_clk_rate = clk_get_rate(c);
414         }
415         enterprise_uart_pdata.parent_clk_list = uart_parent_clk;
416         enterprise_uart_pdata.parent_clk_count = ARRAY_SIZE(uart_parent_clk);
417         tegra_uarta_device.dev.platform_data = &enterprise_uart_pdata;
418         tegra_uartb_device.dev.platform_data = &enterprise_uart_pdata;
419         tegra_uartc_device.dev.platform_data = &enterprise_uart_pdata;
420         tegra_uartd_device.dev.platform_data = &enterprise_uart_pdata;
421         tegra_uarte_device.dev.platform_data = &enterprise_uart_pdata;
422
423         /* Register low speed only if it is selected */
424         if (!is_tegra_debug_uartport_hs())
425                 uart_debug_init();
426
427         platform_add_devices(enterprise_uart_devices,
428                                 ARRAY_SIZE(enterprise_uart_devices));
429 }
430
431
432
433 static struct resource tegra_rtc_resources[] = {
434         [0] = {
435                 .start = TEGRA_RTC_BASE,
436                 .end = TEGRA_RTC_BASE + TEGRA_RTC_SIZE - 1,
437                 .flags = IORESOURCE_MEM,
438         },
439         [1] = {
440                 .start = INT_RTC,
441                 .end = INT_RTC,
442                 .flags = IORESOURCE_IRQ,
443         },
444 };
445
446 static struct platform_device tegra_rtc_device = {
447         .name = "tegra_rtc",
448         .id   = -1,
449         .resource = tegra_rtc_resources,
450         .num_resources = ARRAY_SIZE(tegra_rtc_resources),
451 };
452
453 static struct platform_device tegra_camera = {
454         .name = "tegra_camera",
455         .id = -1,
456 };
457
458 static struct tegra_max98088_platform_data enterprise_audio_pdata = {
459         .gpio_spkr_en           = -1,
460         .gpio_hp_det            = TEGRA_GPIO_HP_DET,
461         .gpio_hp_mute           = -1,
462         .gpio_int_mic_en        = -1,
463         .gpio_ext_mic_en        = -1,
464 };
465
466 static struct platform_device enterprise_audio_device = {
467         .name   = "tegra-snd-max98088",
468         .id     = 0,
469         .dev    = {
470                 .platform_data  = &enterprise_audio_pdata,
471         },
472 };
473
474 static struct platform_device *enterprise_devices[] __initdata = {
475         &tegra_pmu_device,
476         &tegra_rtc_device,
477         &tegra_udc_device,
478 #if defined(CONFIG_SND_HDA_TEGRA)
479         &tegra_hda_device,
480 #endif
481 #if defined(CONFIG_TEGRA_IOVMM_SMMU)
482         &tegra_smmu_device,
483 #endif
484         &tegra_wdt_device,
485 #if defined(CONFIG_TEGRA_AVP)
486         &tegra_avp_device,
487 #endif
488         &tegra_camera,
489         &tegra_ahub_device,
490         &tegra_i2s_device0,
491         &tegra_pcm_device,
492         &enterprise_audio_device,
493         &tegra_spi_device4,
494 #if defined(CONFIG_CRYPTO_DEV_TEGRA_SE)
495         &tegra_se_device,
496 #endif
497 #if defined(CONFIG_CRYPTO_DEV_TEGRA_AES)
498         &tegra_aes_device,
499 #endif
500 };
501
502 #define MXT_CONFIG_CRC 0x62F903
503 /*
504  * Config converted from memory-mapped cfg-file with
505  * following version information:
506  *
507  *
508  *
509  *      FAMILY_ID=128
510  *      VARIANT=1
511  *      VERSION=32
512  *      BUILD=170
513  *      VENDOR_ID=255
514  *      PRODUCT_ID=TBD
515  *      CHECKSUM=0xC189B6
516  *
517  *
518  */
519
520 static const u8 config[] = {
521         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
522         0xFF, 0xFF, 0x32, 0x0A, 0x00, 0x05, 0x01, 0x00,
523         0x00, 0x1E, 0x0A, 0x8B, 0x00, 0x00, 0x13, 0x0B,
524         0x00, 0x10, 0x32, 0x03, 0x03, 0x00, 0x03, 0x01,
525         0x00, 0x0A, 0x0A, 0x0A, 0x0A, 0xBF, 0x03, 0x1B,
526         0x02, 0x00, 0x00, 0x37, 0x37, 0x00, 0x00, 0x00,
527         0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
528         0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
529         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
530         0x00, 0x00, 0x00, 0xA9, 0x7F, 0x9A, 0x0E, 0x00,
531         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
532         0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
533         0x00, 0x00, 0x03, 0x23, 0x00, 0x00, 0x00, 0x0A,
534         0x0F, 0x14, 0x19, 0x03, 0x00, 0x00, 0x00, 0x00,
535         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
536         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
537         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
538         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
539         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
540         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
541         0x00, 0x00, 0x00, 0x01, 0x00, 0x03, 0x08, 0x10,
542         0x00
543 };
544
545 static struct mxt_platform_data atmel_mxt_info = {
546         .x_line         = 19,
547         .y_line         = 11,
548         .x_size         = 960,
549         .y_size         = 540,
550         .blen           = 0x10,
551         .threshold      = 0x32,
552         .voltage        = 3300000,              /* 3.3V */
553         .orient         = 3,
554         .config         = config,
555         .config_length  = 168,
556         .config_crc     = MXT_CONFIG_CRC,
557         .irqflags       = IRQF_TRIGGER_FALLING,
558 /*      .read_chg       = &read_chg, */
559         .read_chg       = NULL,
560 };
561
562 static struct i2c_board_info __initdata atmel_i2c_info[] = {
563         {
564                 I2C_BOARD_INFO("atmel_mxt_ts", MXT224_I2C_ADDR1),
565                 .irq = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_PH6),
566                 .platform_data = &atmel_mxt_info,
567         }
568 };
569
570 static int __init enterprise_touch_init(void)
571 {
572         tegra_gpio_enable(TEGRA_GPIO_PH6);
573         tegra_gpio_enable(TEGRA_GPIO_PF5);
574
575         gpio_request(TEGRA_GPIO_PH6, "atmel-irq");
576         gpio_direction_input(TEGRA_GPIO_PH6);
577
578         gpio_request(TEGRA_GPIO_PF5, "atmel-reset");
579         gpio_direction_output(TEGRA_GPIO_PF5, 0);
580         msleep(1);
581         gpio_set_value(TEGRA_GPIO_PF5, 1);
582         msleep(100);
583
584         i2c_register_board_info(1, atmel_i2c_info, 1);
585
586         return 0;
587 }
588
589 static struct usb_phy_plat_data tegra_usb_phy_pdata[] = {
590         [0] = {
591                         .instance = 0,
592                         .vbus_gpio = -1,
593                         .vbus_reg_supply = "usb_vbus",
594                         .vbus_irq = ENT_TPS80031_IRQ_BASE +
595                                                         TPS80031_INT_VBUS_DET,
596         },
597         [1] = {
598                         .instance = 1,
599                         .vbus_gpio = -1,
600         },
601         [2] = {
602                         .instance = 2,
603                         .vbus_gpio = -1,
604         },
605 };
606
607
608 static struct tegra_ehci_platform_data tegra_ehci_pdata[] = {
609         [0] = {
610                         .phy_config = &utmi_phy_config[0],
611                         .operating_mode = TEGRA_USB_HOST,
612                         .power_down_on_bus_suspend = 1,
613         },
614         [1] = {
615                         .phy_config = &utmi_phy_config[1],
616                         .operating_mode = TEGRA_USB_HOST,
617                         .power_down_on_bus_suspend = 1,
618         },
619         [2] = {
620                         .phy_config = &utmi_phy_config[2],
621                         .operating_mode = TEGRA_USB_HOST,
622                         .power_down_on_bus_suspend = 1,
623         },
624 };
625
626 static struct platform_device *tegra_usb_otg_host_register(void)
627 {
628         struct platform_device *pdev;
629         void *platform_data;
630         int val;
631
632         pdev = platform_device_alloc(tegra_ehci1_device.name,
633                 tegra_ehci1_device.id);
634         if (!pdev)
635                 return NULL;
636
637         val = platform_device_add_resources(pdev, tegra_ehci1_device.resource,
638                 tegra_ehci1_device.num_resources);
639         if (val)
640                 goto error;
641
642         pdev->dev.dma_mask =  tegra_ehci1_device.dev.dma_mask;
643         pdev->dev.coherent_dma_mask = tegra_ehci1_device.dev.coherent_dma_mask;
644
645         platform_data = kmalloc(sizeof(struct tegra_ehci_platform_data),
646                 GFP_KERNEL);
647         if (!platform_data)
648                 goto error;
649
650         memcpy(platform_data, &tegra_ehci_pdata[0],
651                                 sizeof(struct tegra_ehci_platform_data));
652         pdev->dev.platform_data = platform_data;
653
654         val = platform_device_add(pdev);
655         if (val)
656                 goto error_add;
657
658         return pdev;
659
660 error_add:
661         kfree(platform_data);
662 error:
663         pr_err("%s: failed to add the host contoller device\n", __func__);
664         platform_device_put(pdev);
665         return NULL;
666 }
667
668 static void tegra_usb_otg_host_unregister(struct platform_device *pdev)
669 {
670         platform_device_unregister(pdev);
671 }
672
673 static struct tegra_otg_platform_data tegra_otg_pdata = {
674         .host_register = &tegra_usb_otg_host_register,
675         .host_unregister = &tegra_usb_otg_host_unregister,
676 };
677
678 static void enterprise_usb_init(void)
679 {
680         struct  fsl_usb2_platform_data *udc_pdata;
681
682         tegra_usb_phy_init(tegra_usb_phy_pdata, ARRAY_SIZE(tegra_usb_phy_pdata));
683
684         tegra_otg_device.dev.platform_data = &tegra_otg_pdata;
685         platform_device_register(&tegra_otg_device);
686
687         tegra_ehci3_device.dev.platform_data = &tegra_ehci_pdata[2];
688         platform_device_register(&tegra_ehci3_device);
689
690         udc_pdata = tegra_udc_device.dev.platform_data;
691         udc_pdata->charge_regulator ="usb_bat_chg";
692 }
693
694 static void enterprise_gps_init(void)
695 {
696         tegra_gpio_enable(TEGRA_GPIO_PE4);
697         tegra_gpio_enable(TEGRA_GPIO_PE5);
698 }
699
700 static void enterprise_baseband_init(void)
701 {
702         int modem_id = tegra_get_modem_id();
703
704         switch (modem_id) {
705         case 1: /* PH450 ULPI */
706                 enterprise_modem_init();
707                 break;
708         case 2: /* 6260 HSIC */
709                 break;
710         }
711 }
712
713 static void __init tegra_enterprise_init(void)
714 {
715         tegra_clk_init_from_table(enterprise_clk_init_table);
716         enterprise_pinmux_init();
717         enterprise_i2c_init();
718         enterprise_uart_init();
719         enterprise_usb_init();
720         enterprise_tsensor_init();
721         platform_add_devices(enterprise_devices, ARRAY_SIZE(enterprise_devices));
722         enterprise_regulator_init();
723         enterprise_sdhci_init();
724 #ifdef CONFIG_TEGRA_EDP_LIMITS
725         enterprise_edp_init();
726 #endif
727         enterprise_kbc_init();
728         enterprise_touch_init();
729         enterprise_gps_init();
730         enterprise_baseband_init();
731         enterprise_panel_init();
732         enterprise_bt_rfkill();
733         enterprise_setup_bluesleep();
734         enterprise_emc_init();
735         enterprise_sensors_init();
736         enterprise_suspend_init();
737         tegra_release_bootloader_fb();
738 }
739
740 static void __init tegra_enterprise_reserve(void)
741 {
742 #if defined(CONFIG_NVMAP_CONVERT_CARVEOUT_TO_IOVMM)
743         tegra_reserve(0, SZ_4M, SZ_8M);
744 #else
745         tegra_reserve(SZ_128M, SZ_4M, SZ_8M);
746 #endif
747 }
748
749 MACHINE_START(TEGRA_ENTERPRISE, "tegra_enterprise")
750         .boot_params    = 0x80000100,
751         .map_io         = tegra_map_common_io,
752         .reserve        = tegra_enterprise_reserve,
753         .init_early     = tegra_init_early,
754         .init_irq       = tegra_init_irq,
755         .timer          = &tegra_timer,
756         .init_machine   = tegra_enterprise_init,
757 MACHINE_END