arm: tegra: Updated i2c platform data
[linux-2.6.git] / arch / arm / mach-tegra / board-ventana.c
1 /*
2  * arch/arm/mach-tegra/board-ventana.c
3  *
4  * Copyright (c) 2010-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/gpio_keys.h>
35 #include <linux/input.h>
36 #include <linux/platform_data/tegra_usb.h>
37 #include <linux/mfd/tps6586x.h>
38 #include <linux/memblock.h>
39 #include <linux/i2c/atmel_mxt_ts.h>
40 #include <linux/tegra_uart.h>
41
42 #include <sound/wm8903.h>
43
44 #include <mach/clk.h>
45 #include <mach/iomap.h>
46 #include <mach/irqs.h>
47 #include <mach/pinmux.h>
48 #include <mach/iomap.h>
49 #include <mach/io.h>
50 #include <mach/i2s.h>
51 #include <mach/tegra_wm8903_pdata.h>
52
53 #include <asm/mach-types.h>
54 #include <asm/mach/arch.h>
55 #include <mach/usb_phy.h>
56
57 #include "board.h"
58 #include "clock.h"
59 #include "board-ventana.h"
60 #include "devices.h"
61 #include "gpio-names.h"
62 #include "fuse.h"
63 #include "wakeups-t2.h"
64 #include "pm.h"
65
66 static struct tegra_utmip_config utmi_phy_config[] = {
67         [0] = {
68                         .hssync_start_delay = 9,
69                         .idle_wait_delay = 17,
70                         .elastic_limit = 16,
71                         .term_range_adj = 6,
72                         .xcvr_setup = 15,
73                         .xcvr_setup_offset = 0,
74                         .xcvr_use_fuses = 1,
75                         .xcvr_lsfslew = 2,
76                         .xcvr_lsrslew = 2,
77         },
78         [1] = {
79                         .hssync_start_delay = 9,
80                         .idle_wait_delay = 17,
81                         .elastic_limit = 16,
82                         .term_range_adj = 6,
83                         .xcvr_setup = 8,
84                         .xcvr_setup_offset = 0,
85                         .xcvr_use_fuses = 1,
86                         .xcvr_lsfslew = 2,
87                         .xcvr_lsrslew = 2,
88         },
89 };
90
91 static struct tegra_ulpi_config ulpi_phy_config = {
92         .reset_gpio = TEGRA_GPIO_PG2,
93         .clk = "cdev2",
94 };
95
96 static struct resource ventana_bcm4329_rfkill_resources[] = {
97         {
98                 .name   = "bcm4329_nshutdown_gpio",
99                 .start  = TEGRA_GPIO_PU0,
100                 .end    = TEGRA_GPIO_PU0,
101                 .flags  = IORESOURCE_IO,
102         },
103 };
104
105 static struct platform_device ventana_bcm4329_rfkill_device = {
106         .name = "bcm4329_rfkill",
107         .id             = -1,
108         .num_resources  = ARRAY_SIZE(ventana_bcm4329_rfkill_resources),
109         .resource       = ventana_bcm4329_rfkill_resources,
110 };
111
112 static void __init ventana_bt_rfkill(void)
113 {
114         /*Add Clock Resource*/
115         clk_add_alias("bcm4329_32k_clk", ventana_bcm4329_rfkill_device.name, \
116                                 "blink", NULL);
117         return;
118 }
119
120 static struct resource ventana_bluesleep_resources[] = {
121         [0] = {
122                 .name = "gpio_host_wake",
123                         .start  = TEGRA_GPIO_PU6,
124                         .end    = TEGRA_GPIO_PU6,
125                         .flags  = IORESOURCE_IO,
126         },
127         [1] = {
128                 .name = "gpio_ext_wake",
129                         .start  = TEGRA_GPIO_PU1,
130                         .end    = TEGRA_GPIO_PU1,
131                         .flags  = IORESOURCE_IO,
132         },
133         [2] = {
134                 .name = "host_wake",
135                         .start  = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_PU6),
136                         .end    = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_PU6),
137                         .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE,
138         },
139 };
140
141 static struct platform_device ventana_bluesleep_device = {
142         .name           = "bluesleep",
143         .id             = -1,
144         .num_resources  = ARRAY_SIZE(ventana_bluesleep_resources),
145         .resource       = ventana_bluesleep_resources,
146 };
147
148 static void __init ventana_setup_bluesleep(void)
149 {
150         platform_device_register(&ventana_bluesleep_device);
151         tegra_gpio_enable(TEGRA_GPIO_PU6);
152         tegra_gpio_enable(TEGRA_GPIO_PU1);
153         return;
154 }
155
156 static __initdata struct tegra_clk_init_table ventana_clk_init_table[] = {
157         /* name         parent          rate            enabled */
158         { "blink",      "clk_32k",      32768,          false},
159         { "pll_p_out4", "pll_p",        24000000,       true },
160         { "pwm",        "clk_32k",      32768,          false},
161         { "i2s1",       "pll_a_out0",   0,              false},
162         { "i2s2",       "pll_a_out0",   0,              false},
163         { "spdif_out",  "pll_a_out0",   0,              false},
164         { NULL,         NULL,           0,              0},
165 };
166
167 static struct tegra_ulpi_config ventana_ehci2_ulpi_phy_config = {
168         .reset_gpio = TEGRA_GPIO_PV1,
169         .clk = "cdev2",
170 };
171
172 static struct tegra_ehci_platform_data ventana_ehci2_ulpi_platform_data = {
173         .operating_mode = TEGRA_USB_HOST,
174         .power_down_on_bus_suspend = 1,
175         .phy_config = &ventana_ehci2_ulpi_phy_config,
176         .phy_type = TEGRA_USB_PHY_TYPE_LINK_ULPI,
177 };
178
179 static struct tegra_i2c_platform_data ventana_i2c1_platform_data = {
180         .adapter_nr     = 0,
181         .bus_count      = 1,
182         .bus_clk_rate   = { 400000, 0 },
183         .slave_addr = 0x00FC,
184         .scl_gpio               = {TEGRA_GPIO_PC4, 0},
185         .sda_gpio               = {TEGRA_GPIO_PC5, 0},
186         .arb_recovery = arb_lost_recovery,
187 };
188
189 static const struct tegra_pingroup_config i2c2_ddc = {
190         .pingroup       = TEGRA_PINGROUP_DDC,
191         .func           = TEGRA_MUX_I2C2,
192 };
193
194 static const struct tegra_pingroup_config i2c2_gen2 = {
195         .pingroup       = TEGRA_PINGROUP_PTA,
196         .func           = TEGRA_MUX_I2C2,
197 };
198
199 static struct tegra_i2c_platform_data ventana_i2c2_platform_data = {
200         .adapter_nr     = 1,
201         .bus_count      = 2,
202         .bus_clk_rate   = { 100000, 10000 },
203         .bus_mux        = { &i2c2_ddc, &i2c2_gen2 },
204         .bus_mux_len    = { 1, 1 },
205         .slave_addr = 0x00FC,
206         .scl_gpio               = {0, TEGRA_GPIO_PT5},
207         .sda_gpio               = {0, TEGRA_GPIO_PT6},
208         .arb_recovery = arb_lost_recovery,
209 };
210
211 static struct tegra_i2c_platform_data ventana_i2c3_platform_data = {
212         .adapter_nr     = 3,
213         .bus_count      = 1,
214         .bus_clk_rate   = { 400000, 0 },
215         .slave_addr = 0x00FC,
216         .scl_gpio               = {TEGRA_GPIO_PBB2, 0},
217         .sda_gpio               = {TEGRA_GPIO_PBB3, 0},
218         .arb_recovery = arb_lost_recovery,
219 };
220
221 static struct tegra_i2c_platform_data ventana_dvc_platform_data = {
222         .adapter_nr     = 4,
223         .bus_count      = 1,
224         .bus_clk_rate   = { 400000, 0 },
225         .is_dvc         = true,
226         .scl_gpio               = {TEGRA_GPIO_PZ6, 0},
227         .sda_gpio               = {TEGRA_GPIO_PZ7, 0},
228         .arb_recovery = arb_lost_recovery,
229 };
230
231 static struct wm8903_platform_data ventana_wm8903_pdata = {
232         .irq_active_low = 0,
233         .micdet_cfg = 0,
234         .micdet_delay = 100,
235         .gpio_base = VENTANA_GPIO_WM8903(0),
236         .gpio_cfg = {
237                 (WM8903_GPn_FN_DMIC_LR_CLK_OUTPUT << WM8903_GP1_FN_SHIFT),
238                 (WM8903_GPn_FN_DMIC_LR_CLK_OUTPUT << WM8903_GP2_FN_SHIFT) |
239                         WM8903_GP2_DIR,
240                 0,
241                 WM8903_GPIO_NO_CONFIG,
242                 WM8903_GPIO_NO_CONFIG,
243         },
244 };
245
246 static struct i2c_board_info __initdata wm8903_board_info = {
247         I2C_BOARD_INFO("wm8903", 0x1a),
248         .platform_data = &ventana_wm8903_pdata,
249         .irq = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_CDC_IRQ),
250 };
251
252 static void ventana_i2c_init(void)
253 {
254         tegra_i2c_device1.dev.platform_data = &ventana_i2c1_platform_data;
255         tegra_i2c_device2.dev.platform_data = &ventana_i2c2_platform_data;
256         tegra_i2c_device3.dev.platform_data = &ventana_i2c3_platform_data;
257         tegra_i2c_device4.dev.platform_data = &ventana_dvc_platform_data;
258
259         platform_device_register(&tegra_i2c_device1);
260         platform_device_register(&tegra_i2c_device2);
261         platform_device_register(&tegra_i2c_device3);
262         platform_device_register(&tegra_i2c_device4);
263
264         i2c_register_board_info(0, &wm8903_board_info, 1);
265 }
266 static struct platform_device *ventana_uart_devices[] __initdata = {
267         &tegra_uartb_device,
268         &tegra_uartc_device,
269         &tegra_uartd_device,
270 };
271
272 static struct uart_clk_parent uart_parent_clk[] = {
273         [0] = {.name = "pll_p"},
274         [1] = {.name = "pll_m"},
275         [2] = {.name = "clk_m"},
276 };
277
278 static struct tegra_uart_platform_data ventana_uart_pdata;
279
280 static void __init uart_debug_init(void)
281 {
282         unsigned long rate;
283         struct clk *c;
284
285         /* UARTD is the debug port. */
286         pr_info("Selecting UARTD as the debug console\n");
287         ventana_uart_devices[2] = &debug_uartd_device;
288         debug_uart_port_base = ((struct plat_serial8250_port *)(
289                         debug_uartd_device.dev.platform_data))->mapbase;
290         debug_uart_clk = clk_get_sys("serial8250.0", "uartd");
291
292         /* Clock enable for the debug channel */
293         if (!IS_ERR_OR_NULL(debug_uart_clk)) {
294                 rate = ((struct plat_serial8250_port *)(
295                         debug_uartd_device.dev.platform_data))->uartclk;
296                 pr_info("The debug console clock name is %s\n",
297                                                 debug_uart_clk->name);
298                 c = tegra_get_clock_by_name("pll_p");
299                 if (IS_ERR_OR_NULL(c))
300                         pr_err("Not getting the parent clock pll_p\n");
301                 else
302                         clk_set_parent(debug_uart_clk, c);
303
304                 clk_enable(debug_uart_clk);
305                 clk_set_rate(debug_uart_clk, rate);
306         } else {
307                 pr_err("Not getting the clock %s for debug console\n",
308                                         debug_uart_clk->name);
309         }
310 }
311
312 static void __init ventana_uart_init(void)
313 {
314         int i;
315         struct clk *c;
316
317         for (i = 0; i < ARRAY_SIZE(uart_parent_clk); ++i) {
318                 c = tegra_get_clock_by_name(uart_parent_clk[i].name);
319                 if (IS_ERR_OR_NULL(c)) {
320                         pr_err("Not able to get the clock for %s\n",
321                                                 uart_parent_clk[i].name);
322                         continue;
323                 }
324                 uart_parent_clk[i].parent_clk = c;
325                 uart_parent_clk[i].fixed_clk_rate = clk_get_rate(c);
326         }
327         ventana_uart_pdata.parent_clk_list = uart_parent_clk;
328         ventana_uart_pdata.parent_clk_count = ARRAY_SIZE(uart_parent_clk);
329         tegra_uartb_device.dev.platform_data = &ventana_uart_pdata;
330         tegra_uartc_device.dev.platform_data = &ventana_uart_pdata;
331         tegra_uartd_device.dev.platform_data = &ventana_uart_pdata;
332
333         /* Register low speed only if it is selected */
334         if (!is_tegra_debug_uartport_hs())
335                 uart_debug_init();
336
337         platform_add_devices(ventana_uart_devices,
338                                 ARRAY_SIZE(ventana_uart_devices));
339 }
340
341 #ifdef CONFIG_KEYBOARD_GPIO
342 #define GPIO_KEY(_id, _gpio, _iswake)           \
343         {                                       \
344                 .code = _id,                    \
345                 .gpio = TEGRA_GPIO_##_gpio,     \
346                 .active_low = 1,                \
347                 .desc = #_id,                   \
348                 .type = EV_KEY,                 \
349                 .wakeup = _iswake,              \
350                 .debounce_interval = 10,        \
351         }
352
353 static struct gpio_keys_button ventana_keys[] = {
354         [0] = GPIO_KEY(KEY_FIND, PQ3, 0),
355         [1] = GPIO_KEY(KEY_HOME, PQ1, 0),
356         [2] = GPIO_KEY(KEY_BACK, PQ2, 0),
357         [3] = GPIO_KEY(KEY_VOLUMEUP, PQ5, 0),
358         [4] = GPIO_KEY(KEY_VOLUMEDOWN, PQ4, 0),
359         [5] = GPIO_KEY(KEY_POWER, PV2, 1),
360         [6] = GPIO_KEY(KEY_MENU, PC7, 0),
361 };
362
363 #define PMC_WAKE_STATUS 0x14
364
365 static int ventana_wakeup_key(void)
366 {
367         unsigned long status =
368                 readl(IO_ADDRESS(TEGRA_PMC_BASE) + PMC_WAKE_STATUS);
369
370         return status & TEGRA_WAKE_GPIO_PV2 ? KEY_POWER : KEY_RESERVED;
371 }
372
373 static struct gpio_keys_platform_data ventana_keys_platform_data = {
374         .buttons        = ventana_keys,
375         .nbuttons       = ARRAY_SIZE(ventana_keys),
376         .wakeup_key     = ventana_wakeup_key,
377 };
378
379 static struct platform_device ventana_keys_device = {
380         .name   = "gpio-keys",
381         .id     = 0,
382         .dev    = {
383                 .platform_data  = &ventana_keys_platform_data,
384         },
385 };
386
387 static void ventana_keys_init(void)
388 {
389         int i;
390
391         for (i = 0; i < ARRAY_SIZE(ventana_keys); i++)
392                 tegra_gpio_enable(ventana_keys[i].gpio);
393 }
394 #endif
395
396 static struct platform_device tegra_camera = {
397         .name = "tegra_camera",
398         .id = -1,
399 };
400
401 static struct tegra_wm8903_platform_data ventana_audio_pdata = {
402         .gpio_spkr_en           = TEGRA_GPIO_SPKR_EN,
403         .gpio_hp_det            = TEGRA_GPIO_HP_DET,
404         .gpio_hp_mute           = -1,
405         .gpio_int_mic_en        = TEGRA_GPIO_INT_MIC_EN,
406         .gpio_ext_mic_en        = TEGRA_GPIO_EXT_MIC_EN,
407 };
408
409 static struct platform_device ventana_audio_device = {
410         .name   = "tegra-snd-wm8903",
411         .id     = 0,
412         .dev    = {
413                 .platform_data  = &ventana_audio_pdata,
414         },
415 };
416
417 static struct platform_device *ventana_devices[] __initdata = {
418         &tegra_pmu_device,
419         &tegra_gart_device,
420         &tegra_aes_device,
421 #ifdef CONFIG_KEYBOARD_GPIO
422         &ventana_keys_device,
423 #endif
424         &tegra_wdt_device,
425         &tegra_avp_device,
426         &tegra_camera,
427         &tegra_i2s_device1,
428         &tegra_i2s_device2,
429         &tegra_spdif_device,
430         &tegra_das_device,
431         &spdif_dit_device,
432         &bluetooth_dit_device,
433         &ventana_bcm4329_rfkill_device,
434         &tegra_pcm_device,
435         &ventana_audio_device,
436 };
437
438
439 static struct mxt_platform_data atmel_mxt_info = {
440         .x_line         = 27,
441         .y_line         = 42,
442         .x_size         = 768,
443         .y_size         = 1366,
444         .blen           = 0x20,
445         .threshold      = 0x3C,
446         .voltage        = 3300000,
447         .orient         = MXT_ROTATED_90,
448         .irqflags       = IRQF_TRIGGER_FALLING,
449 };
450
451 static struct i2c_board_info __initdata i2c_info[] = {
452         {
453          I2C_BOARD_INFO("atmel_mxt_ts", 0x5A),
454          .irq = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_PV6),
455          .platform_data = &atmel_mxt_info,
456          },
457 };
458
459 static int __init ventana_touch_init_atmel(void)
460 {
461         tegra_gpio_enable(TEGRA_GPIO_PV6);
462         tegra_gpio_enable(TEGRA_GPIO_PQ7);
463
464         gpio_request(TEGRA_GPIO_PV6, "atmel-irq");
465         gpio_direction_input(TEGRA_GPIO_PV6);
466
467         gpio_request(TEGRA_GPIO_PQ7, "atmel-reset");
468         gpio_direction_output(TEGRA_GPIO_PQ7, 0);
469         msleep(1);
470         gpio_set_value(TEGRA_GPIO_PQ7, 1);
471         msleep(100);
472
473         i2c_register_board_info(0, i2c_info, 1);
474
475         return 0;
476 }
477
478 static struct panjit_i2c_ts_platform_data panjit_data = {
479         .gpio_reset = TEGRA_GPIO_PQ7,
480 };
481
482 static struct i2c_board_info __initdata ventana_i2c_bus1_touch_info[] = {
483         {
484                 I2C_BOARD_INFO("panjit_touch", 0x3),
485                 .irq = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_PV6),
486                 .platform_data = &panjit_data,
487         },
488 };
489
490 static int __init ventana_touch_init_panjit(void)
491 {
492         tegra_gpio_enable(TEGRA_GPIO_PV6);
493
494         tegra_gpio_enable(TEGRA_GPIO_PQ7);
495         i2c_register_board_info(0, ventana_i2c_bus1_touch_info, 1);
496
497         return 0;
498 }
499
500 static struct usb_phy_plat_data tegra_usb_phy_pdata[] = {
501         [0] = {
502                         .instance = 0,
503                         .vbus_irq = TPS6586X_INT_BASE + TPS6586X_INT_USB_DET,
504                         .vbus_gpio = TEGRA_GPIO_PD0,
505         },
506         [1] = {
507                         .instance = 1,
508                         .vbus_gpio = -1,
509         },
510         [2] = {
511                         .instance = 2,
512                         .vbus_gpio = TEGRA_GPIO_PD3,
513         },
514 };
515
516 static struct tegra_ehci_platform_data tegra_ehci_pdata[] = {
517         [0] = {
518                         .phy_config = &utmi_phy_config[0],
519                         .operating_mode = TEGRA_USB_HOST,
520                         .power_down_on_bus_suspend = 1,
521         },
522         [1] = {
523                         .phy_config = &ulpi_phy_config,
524                         .operating_mode = TEGRA_USB_HOST,
525                         .power_down_on_bus_suspend = 1,
526                         .phy_type = TEGRA_USB_PHY_TYPE_LINK_ULPI,
527         },
528         [2] = {
529                         .phy_config = &utmi_phy_config[1],
530                         .operating_mode = TEGRA_USB_HOST,
531                         .power_down_on_bus_suspend = 1,
532                         .hotplug = 1,
533         },
534 };
535
536 static struct tegra_otg_platform_data tegra_otg_pdata = {
537         .ehci_device = &tegra_ehci1_device,
538         .ehci_pdata = &tegra_ehci_pdata[0],
539 };
540
541 static int __init ventana_gps_init(void)
542 {
543         struct clk *clk32 = clk_get_sys(NULL, "blink");
544         if (!IS_ERR(clk32)) {
545                 clk_set_rate(clk32,clk32->parent->rate);
546                 clk_enable(clk32);
547         }
548
549         tegra_gpio_enable(TEGRA_GPIO_PZ3);
550         return 0;
551 }
552
553 static void ventana_power_off(void)
554 {
555         int ret;
556
557         ret = tps6586x_power_off();
558         if (ret)
559                 pr_err("ventana: failed to power off\n");
560
561         while(1);
562 }
563
564 static void __init ventana_power_off_init(void)
565 {
566         pm_power_off = ventana_power_off;
567 }
568
569 static void ventana_usb_init(void)
570 {
571         tegra_usb_phy_init(tegra_usb_phy_pdata, ARRAY_SIZE(tegra_usb_phy_pdata));
572         /* OTG should be the first to be registered */
573         tegra_otg_device.dev.platform_data = &tegra_otg_pdata;
574         platform_device_register(&tegra_otg_device);
575
576         platform_device_register(&tegra_udc_device);
577         platform_device_register(&tegra_ehci2_device);
578
579         tegra_ehci3_device.dev.platform_data=&tegra_ehci_pdata[2];
580         platform_device_register(&tegra_ehci3_device);
581 }
582
583 static void __init tegra_ventana_init(void)
584 {
585         struct board_info BoardInfo;
586
587         tegra_clk_init_from_table(ventana_clk_init_table);
588         ventana_pinmux_init();
589         ventana_i2c_init();
590         ventana_uart_init();
591         tegra_ehci2_device.dev.platform_data
592                 = &ventana_ehci2_ulpi_platform_data;
593         platform_add_devices(ventana_devices, ARRAY_SIZE(ventana_devices));
594
595         ventana_sdhci_init();
596         ventana_charge_init();
597         ventana_regulator_init();
598         ventana_charger_init();
599
600         tegra_get_board_info(&BoardInfo);
601
602         /* boards with sku > 0 have atmel touch panels */
603         if (BoardInfo.sku) {
604                 pr_info("Initializing Atmel touch driver\n");
605                 ventana_touch_init_atmel();
606         } else {
607                 pr_info("Initializing Panjit touch driver\n");
608                 ventana_touch_init_panjit();
609         }
610
611 #ifdef CONFIG_KEYBOARD_GPIO
612         ventana_keys_init();
613 #endif
614
615         ventana_usb_init();
616         ventana_gps_init();
617         ventana_panel_init();
618         ventana_sensors_init();
619         ventana_bt_rfkill();
620         ventana_power_off_init();
621         ventana_emc_init();
622
623         ventana_setup_bluesleep();
624         tegra_release_bootloader_fb();
625 }
626
627 int __init tegra_ventana_protected_aperture_init(void)
628 {
629         if (!machine_is_ventana())
630                 return 0;
631
632         tegra_protected_aperture_init(tegra_grhost_aperture);
633         return 0;
634 }
635 late_initcall(tegra_ventana_protected_aperture_init);
636
637 void __init tegra_ventana_reserve(void)
638 {
639         if (memblock_reserve(0x0, 4096) < 0)
640                 pr_warn("Cannot reserve first 4K of memory for safety\n");
641
642         tegra_reserve(SZ_256M, SZ_8M, SZ_16M);
643 }
644
645 MACHINE_START(VENTANA, "ventana")
646         .boot_params    = 0x00000100,
647         .map_io         = tegra_map_common_io,
648         .reserve        = tegra_ventana_reserve,
649         .init_early     = tegra_init_early,
650         .init_irq       = tegra_init_irq,
651         .timer          = &tegra_timer,
652         .init_machine   = tegra_ventana_init,
653 MACHINE_END