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