arm: tegra: cardhu: Modify modem w_disable control.
[linux-2.6.git] / arch / arm / mach-tegra / board-cardhu.c
1 /*
2  * arch/arm/mach-tegra/board-cardhu.c
3  *
4  * Copyright (c) 2011, 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/i2c/panjit_ts.h>
30 #include <linux/dma-mapping.h>
31 #include <linux/delay.h>
32 #include <linux/i2c-tegra.h>
33 #include <linux/gpio.h>
34 #include <linux/input.h>
35 #include <linux/platform_data/tegra_usb.h>
36 #include <linux/spi/spi.h>
37 #include <linux/i2c/atmel_mxt_ts.h>
38
39 #include <sound/wm8903.h>
40
41 #include <mach/clk.h>
42 #include <mach/iomap.h>
43 #include <mach/irqs.h>
44 #include <mach/pinmux.h>
45 #include <mach/iomap.h>
46 #include <mach/io.h>
47 #include <mach/i2s.h>
48 #include <mach/tegra_wm8903_pdata.h>
49 #include <asm/mach-types.h>
50 #include <asm/mach/arch.h>
51 #include <mach/usb_phy.h>
52
53 #include "board.h"
54 #include "clock.h"
55 #include "board-cardhu.h"
56 #include "devices.h"
57 #include "gpio-names.h"
58 #include "fuse.h"
59
60
61 /* !!!TODO: Change for cardhu (Taken from Ventana) */
62 static struct tegra_utmip_config utmi_phy_config[] = {
63         [0] = {
64                         .hssync_start_delay = 0,
65                         .idle_wait_delay = 17,
66                         .elastic_limit = 16,
67                         .term_range_adj = 6,
68                         .xcvr_setup = 15,
69                         .xcvr_lsfslew = 2,
70                         .xcvr_lsrslew = 2,
71         },
72         [1] = {
73                         .hssync_start_delay = 0,
74                         .idle_wait_delay = 17,
75                         .elastic_limit = 16,
76                         .term_range_adj = 6,
77                         .xcvr_setup = 15,
78                         .xcvr_lsfslew = 2,
79                         .xcvr_lsrslew = 2,
80         },
81         [2] = {
82                         .hssync_start_delay = 0,
83                         .idle_wait_delay = 17,
84                         .elastic_limit = 16,
85                         .term_range_adj = 6,
86                         .xcvr_setup = 8,
87                         .xcvr_lsfslew = 2,
88                         .xcvr_lsrslew = 2,
89         },
90 };
91
92 #ifdef CONFIG_BCM4329_RFKILL
93 static struct resource cardhu_bcm4329_rfkill_resources[] = {
94         {
95                 .name   = "bcm4329_nshutdown_gpio",
96                 .start  = TEGRA_GPIO_PU0,
97                 .end    = TEGRA_GPIO_PU0,
98                 .flags  = IORESOURCE_IO,
99         },
100 };
101
102 static struct platform_device cardhu_bcm4329_rfkill_device = {
103         .name = "bcm4329_rfkill",
104         .id             = -1,
105         .num_resources  = ARRAY_SIZE(cardhu_bcm4329_rfkill_resources),
106         .resource       = cardhu_bcm4329_rfkill_resources,
107 };
108
109 static noinline void __init cardhu_bt_rfkill(void)
110 {
111         platform_device_register(&cardhu_bcm4329_rfkill_device);
112
113         return;
114 }
115 #else
116 static inline void cardhu_bt_rfkill(void) { }
117 #endif
118
119 #ifdef CONFIG_BT_BLUESLEEP
120 static noinline void __init tegra_setup_bluesleep(void)
121 {
122         struct platform_device *pdev = NULL;
123         struct resource *res;
124
125         pdev = platform_device_alloc("bluesleep", 0);
126         if (!pdev) {
127                 pr_err("unable to allocate platform device for bluesleep");
128                 return;
129         }
130
131         res = kzalloc(sizeof(struct resource) * 3, GFP_KERNEL);
132         if (!res) {
133                 pr_err("unable to allocate resource for bluesleep\n");
134                 goto err_free_dev;
135         }
136
137         res[0].name   = "gpio_host_wake";
138         res[0].start  = TEGRA_GPIO_PU6;
139         res[0].end    = TEGRA_GPIO_PU6;
140         res[0].flags  = IORESOURCE_IO;
141
142         res[1].name   = "gpio_ext_wake";
143         res[1].start  = TEGRA_GPIO_PU1;
144         res[1].end    = TEGRA_GPIO_PU1;
145         res[1].flags  = IORESOURCE_IO;
146
147         res[2].name   = "host_wake";
148         res[2].start  = gpio_to_irq(TEGRA_GPIO_PU6);
149         res[2].end    = gpio_to_irq(TEGRA_GPIO_PU6);
150         res[2].flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE ;
151
152         if (platform_device_add_resources(pdev, res, 3)) {
153                 pr_err("unable to add resources to bluesleep device\n");
154                 goto err_free_res;
155         }
156
157         if (platform_device_add(pdev)) {
158                 pr_err("unable to add bluesleep device\n");
159                 goto err_free_res;
160         }
161         tegra_gpio_enable(TEGRA_GPIO_PU6);
162         tegra_gpio_enable(TEGRA_GPIO_PU1);
163
164 return;
165
166 err_free_res:
167         kfree(res);
168 err_free_dev:
169         platform_device_put(pdev);
170         return;
171 }
172 #else
173 static inline void tegra_setup_bluesleep(void) { }
174 #endif
175
176 static __initdata struct tegra_clk_init_table cardhu_clk_init_table[] = {
177         /* name         parent          rate            enabled */
178         { "pll_m",      NULL,           0,              true},
179         { "hda",        "pll_p",        108000000,      false},
180         { "hda2codec_2x","pll_p",       48000000,       false},
181         { "pwm",        "clk_32k",      32768,          false},
182         { "blink",      "clk_32k",      32768,          true},
183         { "i2s1",       "pll_a_out0",   0,              false},
184         { NULL,         NULL,           0,              0},
185 };
186
187 static struct tegra_i2c_platform_data cardhu_i2c1_platform_data = {
188         .adapter_nr     = 0,
189         .bus_count      = 1,
190         .bus_clk_rate   = { 100000, 0 },
191 };
192
193 static struct tegra_i2c_platform_data cardhu_i2c2_platform_data = {
194         .adapter_nr     = 1,
195         .bus_count      = 1,
196         .bus_clk_rate   = { 100000, 0 },
197         .is_clkon_always = true,
198 };
199
200 static struct tegra_i2c_platform_data cardhu_i2c3_platform_data = {
201         .adapter_nr     = 2,
202         .bus_count      = 1,
203         .bus_clk_rate   = { 100000, 0 },
204 };
205
206 static struct tegra_i2c_platform_data cardhu_i2c4_platform_data = {
207         .adapter_nr     = 3,
208         .bus_count      = 1,
209         .bus_clk_rate   = { 100000, 0 },
210 };
211
212 static struct tegra_i2c_platform_data cardhu_i2c5_platform_data = {
213         .adapter_nr     = 4,
214         .bus_count      = 1,
215         .bus_clk_rate   = { 100000, 0 },
216 };
217
218
219 #if 0
220 struct tegra_wired_jack_conf audio_wr_jack_conf = {
221         .hp_det_n = TEGRA_GPIO_PW2,
222         .en_mic_ext = TEGRA_GPIO_PX1,
223         .en_mic_int = TEGRA_GPIO_PX0,
224 };
225 #endif
226
227 static struct wm8903_platform_data cardhu_wm8903_pdata = {
228         .irq_active_low = 0,
229         .micdet_cfg = 0,
230         .micdet_delay = 100,
231         .gpio_base = CARDHU_GPIO_WM8903(0),
232         .gpio_cfg = {
233                 WM8903_GPIO_NO_CONFIG,
234                 WM8903_GPIO_NO_CONFIG,
235                 0,
236                 WM8903_GPIO_NO_CONFIG,
237                 WM8903_GPIO_NO_CONFIG,
238         },
239 };
240
241 static struct i2c_board_info __initdata wm8903_board_info = {
242         I2C_BOARD_INFO("wm8903", 0x1a),
243         .platform_data = &cardhu_wm8903_pdata,
244         .irq = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_CDC_IRQ),
245 };
246
247 static void cardhu_i2c_init(void)
248 {
249         tegra_i2c_device1.dev.platform_data = &cardhu_i2c1_platform_data;
250         tegra_i2c_device2.dev.platform_data = &cardhu_i2c2_platform_data;
251         tegra_i2c_device3.dev.platform_data = &cardhu_i2c3_platform_data;
252         tegra_i2c_device4.dev.platform_data = &cardhu_i2c4_platform_data;
253         tegra_i2c_device5.dev.platform_data = &cardhu_i2c5_platform_data;
254
255         platform_device_register(&tegra_i2c_device5);
256         platform_device_register(&tegra_i2c_device4);
257         platform_device_register(&tegra_i2c_device3);
258         platform_device_register(&tegra_i2c_device2);
259         platform_device_register(&tegra_i2c_device1);
260
261         i2c_register_board_info(4, &wm8903_board_info, 1);
262 }
263
264 static struct platform_device *cardhu_uart_devices[] __initdata = {
265         &tegra_uarta_device,
266         &tegra_uartb_device,
267         &tegra_uartc_device,
268         &tegra_uartd_device,
269         &tegra_uarte_device,
270 };
271 static struct clk *debug_uart_clk;
272
273 static void __init uart_debug_init(void)
274 {
275         struct board_info board_info;
276
277         tegra_get_board_info(&board_info);
278         if (board_info.sku & SKU_SLT_ULPI_SUPPORT) {
279                 if ((board_info.board_id == BOARD_E1186) ||
280                         (board_info.board_id == BOARD_E1187) ||
281                         (board_info.board_id == BOARD_PM269)) {
282                                 /* UARTB is the debug port. */
283                                 pr_info("Selecting UARTB as the debug console\n");
284                                 cardhu_uart_devices[1] = &debug_uartb_device;
285                                 debug_uart_clk =
286                                         clk_get_sys("serial8250.0", "uartb");
287                                 return;
288                 }
289                 pr_err("%s(): Unhandled SKU information for Board 0x%04x\n",
290                                 __func__, board_info.board_id);
291         }
292         /* UARTA is the debug port. */
293         pr_info("Selecting UARTA as the debug console\n");
294         cardhu_uart_devices[0] = &debug_uarta_device;
295         debug_uart_clk = clk_get_sys("serial8250.0", "uarta");
296 }
297
298 static void __init cardhu_uart_init(void)
299 {
300         /* Register low speed only if it is selected */
301         if (!is_tegra_debug_uartport_hs()) {
302                 uart_debug_init();
303                 /* Clock enable for the debug channel */
304                 if (!IS_ERR_OR_NULL(debug_uart_clk)) {
305                         pr_info("The debug console clock name is %s\n",
306                                                 debug_uart_clk->name);
307                         clk_enable(debug_uart_clk);
308                         clk_set_rate(debug_uart_clk, 408000000);
309                 } else {
310                         pr_err("Not getting the clock %s for debug console\n",
311                                         debug_uart_clk->name);
312                 }
313         }
314
315         platform_add_devices(cardhu_uart_devices,
316                                 ARRAY_SIZE(cardhu_uart_devices));
317 }
318
319 static struct platform_device tegra_camera = {
320         .name = "tegra_camera",
321         .id = -1,
322 };
323
324 static struct tegra_wm8903_platform_data cardhu_audio_pdata = {
325         .gpio_spkr_en           = TEGRA_GPIO_SPKR_EN,
326         .gpio_hp_det            = TEGRA_GPIO_HP_DET,
327         .gpio_hp_mute           = -1,
328         .gpio_int_mic_en        = -1,
329         .gpio_ext_mic_en        = -1,
330 };
331
332 static struct platform_device cardhu_audio_device = {
333         .name   = "tegra-snd-wm8903",
334         .id     = 0,
335         .dev    = {
336                 .platform_data  = &cardhu_audio_pdata,
337         },
338 };
339
340 static struct platform_device *cardhu_devices[] __initdata = {
341         &tegra_pmu_device,
342         &tegra_udc_device,
343 #if defined(CONFIG_SND_HDA_TEGRA)
344         &tegra_hda_device,
345 #endif
346 #if defined(CONFIG_TEGRA_IOVMM_SMMU)
347         &tegra_smmu_device,
348 #endif
349         &tegra_wdt_device,
350         &tegra_avp_device,
351         &tegra_camera,
352         &tegra_spi_device4,
353 #if defined(CONFIG_CRYPTO_DEV_TEGRA_SE)
354         &tegra_se_device,
355 #endif
356         &tegra_ahub_device,
357         &tegra_i2s_device1,
358         &tegra_pcm_device,
359         &cardhu_audio_device,
360 };
361
362 #define MXT_CONFIG_CRC  0xD62DE8
363 static const u8 config[] = {
364         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365         0xFF, 0xFF, 0x32, 0x0A, 0x00, 0x14, 0x14, 0x00,
366         0x00, 0x00, 0x00, 0x00, 0x00, 0x8B, 0x00, 0x00,
367         0x1B, 0x2A, 0x00, 0x20, 0x3C, 0x04, 0x05, 0x00,
368         0x02, 0x01, 0x00, 0x0A, 0x0A, 0x0A, 0x0A, 0xFF,
369         0x02, 0x55, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
370         0x00, 0x00, 0x00, 0x64, 0x02, 0x00, 0x00, 0x00,
371         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
372         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
373         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
374         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23,
375         0x00, 0x00, 0x00, 0x05, 0x0A, 0x15, 0x1E, 0x00,
376         0x00, 0x04, 0xFF, 0x03, 0x3F, 0x64, 0x64, 0x01,
377         0x0A, 0x14, 0x28, 0x4B, 0x00, 0x02, 0x00, 0x64,
378         0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
379         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
380         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
381         0x00, 0x00, 0x00, 0x08, 0x10, 0x3C, 0x00, 0x00,
382         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
383         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
384 };
385
386 static struct mxt_platform_data atmel_mxt_info = {
387         .x_line         = 27,
388         .y_line         = 42,
389         .x_size         = 768,
390         .y_size         = 1366,
391         .blen           = 0x20,
392         .threshold      = 0x3C,
393         .voltage        = 3300000,              /* 3.3V */
394         .orient         = 5,
395         .config         = config,
396         .config_length  = 157,
397         .config_crc     = MXT_CONFIG_CRC,
398         .irqflags       = IRQF_TRIGGER_FALLING,
399 /*      .read_chg       = &read_chg, */
400         .read_chg       = NULL,
401 };
402
403 static struct i2c_board_info __initdata atmel_i2c_info[] = {
404         {
405                 I2C_BOARD_INFO("atmel_mxt_ts", 0x5A),
406                 .irq = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_PH4),
407                 .platform_data = &atmel_mxt_info,
408         }
409 };
410
411 static int __init cardhu_touch_init(void)
412 {
413         tegra_gpio_enable(TEGRA_GPIO_PH4);
414         tegra_gpio_enable(TEGRA_GPIO_PH6);
415
416         gpio_request(TEGRA_GPIO_PH4, "atmel-irq");
417         gpio_direction_input(TEGRA_GPIO_PH4);
418
419         gpio_request(TEGRA_GPIO_PH6, "atmel-reset");
420         gpio_direction_output(TEGRA_GPIO_PH6, 0);
421         msleep(1);
422         gpio_set_value(TEGRA_GPIO_PH6, 1);
423         msleep(100);
424
425         i2c_register_board_info(1, atmel_i2c_info, 1);
426
427         return 0;
428 }
429
430 static struct usb_phy_plat_data tegra_usb_phy_pdata[] = {
431         [0] = {
432                         .instance = 0,
433                         .vbus_gpio = -1,
434                         .vbus_reg_supply = "vdd_vbus_micro_usb",
435         },
436         [1] = {
437                         .instance = 1,
438                         .vbus_gpio = -1,
439         },
440         [2] = {
441                         .instance = 2,
442                         .vbus_gpio = -1,
443                         .vbus_reg_supply = "vdd_vbus_typea_usb",
444         },
445 };
446
447 static struct tegra_ulpi_config uhsic_phy_config = {
448         .enable_gpio = EN_HSIC_GPIO,
449         .reset_gpio = -1,
450 };
451
452 static struct tegra_ehci_platform_data tegra_ehci_uhsic_pdata = {
453         .phy_type = TEGRA_USB_PHY_TYPE_HSIC,
454         .phy_config = &uhsic_phy_config,
455         .operating_mode = TEGRA_USB_HOST,
456         .power_down_on_bus_suspend = 1,
457 };
458
459 static struct tegra_ehci_platform_data tegra_ehci_pdata[] = {
460         [0] = {
461                         .phy_config = &utmi_phy_config[0],
462                         .operating_mode = TEGRA_USB_HOST,
463                         .power_down_on_bus_suspend = 1,
464         },
465         [1] = {
466                         .phy_config = &utmi_phy_config[1],
467                         .operating_mode = TEGRA_USB_HOST,
468                         .power_down_on_bus_suspend = 1,
469         },
470         [2] = {
471                         .phy_config = &utmi_phy_config[2],
472                         .operating_mode = TEGRA_USB_HOST,
473                         .power_down_on_bus_suspend = 1,
474         },
475 };
476
477 static struct platform_device *tegra_usb_otg_host_register(void)
478 {
479         struct platform_device *pdev;
480         void *platform_data;
481         int val;
482
483         pdev = platform_device_alloc(tegra_ehci1_device.name,
484                 tegra_ehci1_device.id);
485         if (!pdev)
486                 return NULL;
487
488         val = platform_device_add_resources(pdev, tegra_ehci1_device.resource,
489                 tegra_ehci1_device.num_resources);
490         if (val)
491                 goto error;
492
493         pdev->dev.dma_mask =  tegra_ehci1_device.dev.dma_mask;
494         pdev->dev.coherent_dma_mask = tegra_ehci1_device.dev.coherent_dma_mask;
495
496         platform_data = kmalloc(sizeof(struct tegra_ehci_platform_data),
497                 GFP_KERNEL);
498         if (!platform_data)
499                 goto error;
500
501         memcpy(platform_data, &tegra_ehci_pdata[0],
502                                 sizeof(struct tegra_ehci_platform_data));
503         pdev->dev.platform_data = platform_data;
504
505         val = platform_device_add(pdev);
506         if (val)
507                 goto error_add;
508
509         return pdev;
510
511 error_add:
512         kfree(platform_data);
513 error:
514         pr_err("%s: failed to add the host contoller device\n", __func__);
515         platform_device_put(pdev);
516         return NULL;
517 }
518
519 static void tegra_usb_otg_host_unregister(struct platform_device *pdev)
520 {
521         platform_device_unregister(pdev);
522 }
523
524 static struct tegra_otg_platform_data tegra_otg_pdata = {
525         .host_register = &tegra_usb_otg_host_register,
526         .host_unregister = &tegra_usb_otg_host_unregister,
527 };
528
529 static void cardhu_usb_init(void)
530 {
531         struct board_info bi;
532
533         tegra_get_board_info(&bi);
534
535         tegra_usb_phy_init(tegra_usb_phy_pdata, ARRAY_SIZE(tegra_usb_phy_pdata));
536
537         tegra_otg_device.dev.platform_data = &tegra_otg_pdata;
538         platform_device_register(&tegra_otg_device);
539
540         if (bi.board_id == BOARD_PM267) {
541                 uhsic_phy_config.reset_gpio =
542                         PM267_SMSC4640_HSIC_HUB_RESET_GPIO;
543                 tegra_ehci2_device.dev.platform_data = &tegra_ehci_uhsic_pdata;
544         } else if ((bi.board_id == BOARD_PM269) ||
545                 (bi.board_id == BOARD_E1186)) {
546                 tegra_ehci2_device.dev.platform_data = &tegra_ehci_uhsic_pdata;
547         } else {
548                 tegra_ehci2_device.dev.platform_data = &tegra_ehci_pdata[1];
549         }
550         platform_device_register(&tegra_ehci2_device);
551
552         tegra_ehci3_device.dev.platform_data = &tegra_ehci_pdata[2];
553         platform_device_register(&tegra_ehci3_device);
554
555 }
556
557 static void cardhu_gps_init(void)
558 {
559         tegra_gpio_enable(TEGRA_GPIO_PU2);
560         tegra_gpio_enable(TEGRA_GPIO_PU3);
561 }
562
563 static void cardhu_modem_init(void)
564 {
565         struct board_info board_info;
566         int w_disable_gpio;
567
568         tegra_get_board_info(&board_info);
569         switch (board_info.board_id) {
570         case BOARD_E1291:
571                 if (board_info.fab < 0x3) {
572                         w_disable_gpio = TEGRA_GPIO_PH5;
573                 } else {
574                         w_disable_gpio = TEGRA_GPIO_PDD5;
575                 }
576                 tegra_gpio_enable(w_disable_gpio);
577                 gpio_direction_input(w_disable_gpio);
578                 break;
579         default:
580                 break;
581         }
582 }
583
584 #ifdef CONFIG_SATA_AHCI_TEGRA
585 static void cardhu_sata_init(void)
586 {
587         platform_device_register(&tegra_sata_device);
588 }
589 #else
590 static void cardhu_sata_init(void) { }
591 #endif
592
593 static void __init tegra_cardhu_init(void)
594 {
595         tegra_clk_init_from_table(cardhu_clk_init_table);
596         cardhu_pinmux_init();
597         cardhu_i2c_init();
598         cardhu_usb_init();
599 #ifdef CONFIG_TEGRA_EDP_LIMITS
600         cardhu_edp_init();
601 #endif
602         cardhu_uart_init();
603         platform_add_devices(cardhu_devices, ARRAY_SIZE(cardhu_devices));
604         cardhu_sdhci_init();
605         cardhu_regulator_init();
606         cardhu_gpio_switch_regulator_init();
607         cardhu_suspend_init();
608         cardhu_power_off_init();
609         cardhu_touch_init();
610         cardhu_gps_init();
611         cardhu_modem_init();
612         cardhu_kbc_init();
613         cardhu_scroll_init();
614         cardhu_keys_init();
615         cardhu_panel_init();
616         cardhu_pmon_init();
617         cardhu_sensors_init();
618         cardhu_bt_rfkill();
619         tegra_setup_bluesleep();
620         cardhu_sata_init();
621         //audio_wired_jack_init();
622         cardhu_pins_state_init();
623         cardhu_emc_init();
624 }
625
626 static void __init tegra_cardhu_reserve(void)
627 {
628 #if defined(CONFIG_NVMAP_CONVERT_CARVEOUT_TO_IOVMM)
629         tegra_reserve(0, SZ_8M, SZ_8M);
630 #else
631         tegra_reserve(SZ_128M, SZ_8M, SZ_8M);
632 #endif
633 }
634
635 MACHINE_START(CARDHU, "cardhu")
636         .boot_params    = 0x80000100,
637         .map_io         = tegra_map_common_io,
638         .reserve        = tegra_cardhu_reserve,
639         .init_early     = tegra_init_early,
640         .init_irq       = tegra_init_irq,
641         .timer          = &tegra_timer,
642         .init_machine   = tegra_cardhu_init,
643 MACHINE_END