ARM: tegra12: set CPU rate to 2.2GHz for sku 0x87
[linux-3.10.git] / arch / arm / mach-tegra / board-bonaire-panel.c
1 /*
2  * arch/arm/mach-tegra/board-bonaire-panel.c
3  *
4  * Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
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/delay.h>
22 #include <linux/gpio.h>
23 #include <linux/regulator/consumer.h>
24 #include <linux/resource.h>
25 #include <asm/mach-types.h>
26 #include <linux/platform_device.h>
27 #include <linux/pwm_backlight.h>
28 #include <linux/nvhost.h>
29 #include <linux/nvmap.h>
30 #include <linux/tegra-soc.h>
31 #include <mach/gpio-tegra.h>
32 #include <mach/irqs.h>
33 #include <mach/dc.h>
34 #include <mach/fb.h>
35
36 #include "board.h"
37 #include "board-bonaire.h"
38 #include "devices.h"
39 #include "gpio-names.h"
40 #include "tegra12_host1x_devices.h"
41 #include "iomap.h"
42
43 /* Select panel to be used. */
44 #define DSI_PANEL_219 0
45 #define DSI_PANEL_218 1
46 #define AVDD_LCD PMU_TCA6416_GPIO_PORT17
47 #define DSI_PANEL_RESET 0
48
49 #define bonaire_lvds_shutdown   TEGRA_GPIO_PB2
50 #define bonaire_bl_enb          TEGRA_GPIO_PW1
51 #define bonaire_bl_pwm          TEGRA_GPIO_PH0
52
53 #if defined(DSI_PANEL_219) || defined(DSI_PANEL_218)
54 #define bonaire_dsia_bl_enb     TEGRA_GPIO_PW1
55 #define bonaire_dsib_bl_enb     TEGRA_GPIO_PW0
56 #define bonaire_dsi_panel_reset TEGRA_GPIO_PD2
57 #endif
58
59 struct platform_device * __init bonaire_host1x_init(void)
60 {
61         struct platform_device *pdev = NULL;
62
63 #ifdef CONFIG_TEGRA_GRHOST
64         if (!of_have_populated_dt())
65                 pdev = tegra12_register_host1x_devices();
66         else
67                 pdev = to_platform_device(bus_find_device_by_name(
68                         &platform_bus_type, NULL, "host1x"));
69
70         if (!pdev) {
71                 pr_err("host1x devices registration failed\n");
72                 return NULL;
73         }
74 #endif
75         return pdev;
76 }
77
78 static struct regulator *bonaire_dsi_reg;
79
80 static int bonaire_backlight_init(struct device *dev)
81 {
82         int ret;
83
84 #ifndef CONFIG_TEGRA_BONAIRE_DSI
85
86         ret = gpio_request(bonaire_bl_enb, "backlight_enb");
87         if (ret < 0)
88                 return ret;
89
90         ret = gpio_direction_output(bonaire_bl_enb, 1);
91         if (ret < 0)
92                 gpio_free(bonaire_bl_enb);
93
94         return ret;
95 #endif
96
97 #if DSI_PANEL_219 || DSI_PANEL_218
98         /* Enable back light for DSIa panel */
99         printk("bonaire_dsi_backlight_init\n");
100         ret = gpio_request(bonaire_dsia_bl_enb, "dsia_bl_enable");
101         if (ret < 0)
102                 return ret;
103
104         ret = gpio_direction_output(bonaire_dsia_bl_enb, 1);
105         if (ret < 0)
106                 gpio_free(bonaire_dsia_bl_enb);
107
108         /* Enable back light for DSIb panel */
109         ret = gpio_request(bonaire_dsib_bl_enb, "dsib_bl_enable");
110         if (ret < 0)
111                 return ret;
112
113         ret = gpio_direction_output(bonaire_dsib_bl_enb, 1);
114         if (ret < 0)
115                 gpio_free(bonaire_dsib_bl_enb);
116
117 #endif
118
119         return ret;
120 };
121
122 static void bonaire_backlight_exit(struct device *dev)
123 {
124 #ifndef CONFIG_TEGRA_BONAIRE_DSI
125         gpio_set_value(bonaire_bl_enb, 0);
126         gpio_free(bonaire_bl_enb);
127
128         return;
129 #endif
130 #if DSI_PANEL_219 || DSI_PANEL_218
131         /* Disable back light for DSIa panel */
132         gpio_set_value(bonaire_dsia_bl_enb, 0);
133         gpio_free(bonaire_dsia_bl_enb);
134
135         /* Disable back light for DSIb panel */
136         gpio_set_value(bonaire_dsib_bl_enb, 0);
137         gpio_free(bonaire_dsib_bl_enb);
138
139         gpio_set_value(bonaire_lvds_shutdown, 1);
140         mdelay(20);
141 #endif
142 }
143
144 static int bonaire_backlight_notify(struct device *unused, int brightness)
145 {
146         int cur_sd_brightness = atomic_read(&sd_brightness);
147         int orig_brightness = brightness;
148
149 #ifndef CONFIG_TEGRA_BONAIRE_DSI
150         /* Set the backlight GPIO pin mode to 'backlight_enable' */
151         gpio_request(bonaire_bl_enb, "backlight_enb");
152         gpio_set_value(bonaire_bl_enb, !!brightness);
153         goto final;
154 #endif
155 #if DSI_PANEL_219 || DSI_PANEL_218
156         /* DSIa */
157         gpio_set_value(bonaire_dsia_bl_enb, !!brightness);
158
159         /* DSIb */
160         gpio_set_value(bonaire_dsib_bl_enb, !!brightness);
161 #endif
162
163 final:
164         /* SD brightness is a percentage, 8-bit value. */
165         brightness = (brightness * cur_sd_brightness) / 255;
166         if (cur_sd_brightness != 255) {
167                 printk("NVSD BL - in: %d, sd: %d, out: %d\n",
168                         orig_brightness, cur_sd_brightness, brightness);
169         }
170
171         return brightness;
172 }
173
174 static struct platform_pwm_backlight_data bonaire_backlight_data = {
175         .pwm_id         = 2,
176         .max_brightness = 255,
177         .dft_brightness = 224,
178         .pwm_period_ns  = 5000000,
179         .pwm_gpio       = TEGRA_GPIO_INVALID,
180         .init           = bonaire_backlight_init,
181         .exit           = bonaire_backlight_exit,
182         .notify         = bonaire_backlight_notify,
183 };
184
185 static struct platform_device bonaire_backlight_device = {
186         .name   = "pwm-backlight",
187         .id     = -1,
188         .dev    = {
189                 .platform_data = &bonaire_backlight_data,
190         },
191 };
192
193 static int bonaire_panel_enable(struct device *dev)
194 {
195         static struct regulator *reg;
196
197         if (reg == NULL) {
198                 reg = regulator_get(NULL, "avdd_lvds");
199                 if (WARN_ON(IS_ERR(reg)))
200                         pr_err("%s: couldn't get regulator avdd_lvds: %ld\n",
201                                __func__, PTR_ERR(reg));
202                 else
203                         regulator_enable(reg);
204         }
205
206         gpio_set_value(bonaire_lvds_shutdown, 1);
207         return 0;
208 }
209
210 static int bonaire_panel_disable(void)
211 {
212         gpio_set_value(bonaire_lvds_shutdown, 0);
213         return 0;
214 }
215
216 #if defined(CONFIG_TEGRA_DP)
217 static struct tegra_dc_out_pin edp_out_pins[] = {
218         {
219                 .name   = TEGRA_DC_OUT_PIN_H_SYNC,
220                 .pol    = TEGRA_DC_OUT_PIN_POL_HIGH,
221         },
222         {
223                 .name   = TEGRA_DC_OUT_PIN_V_SYNC,
224                 .pol    = TEGRA_DC_OUT_PIN_POL_LOW,
225         },
226         {
227                 .name   = TEGRA_DC_OUT_PIN_PIXEL_CLOCK,
228                 .pol    = TEGRA_DC_OUT_PIN_POL_LOW,
229         },
230         {
231                 .name   = TEGRA_DC_OUT_PIN_DATA_ENABLE,
232                 .pol    = TEGRA_DC_OUT_PIN_POL_HIGH,
233         },
234 };
235 #endif
236
237 #if defined(CONFIG_TEGRA_LVDS)
238 static struct tegra_dc_out_pin lvds_out_pins[] = {
239         {
240                 .name   = TEGRA_DC_OUT_PIN_H_SYNC,
241                 .pol    = TEGRA_DC_OUT_PIN_POL_LOW,
242         },
243         {
244                 .name   = TEGRA_DC_OUT_PIN_V_SYNC,
245                 .pol    = TEGRA_DC_OUT_PIN_POL_LOW,
246         },
247         {
248                 .name   = TEGRA_DC_OUT_PIN_PIXEL_CLOCK,
249                 .pol    = TEGRA_DC_OUT_PIN_POL_HIGH,
250         },
251         {
252                 .name   = TEGRA_DC_OUT_PIN_DATA_ENABLE,
253                 .pol    = TEGRA_DC_OUT_PIN_POL_HIGH,
254         },
255 };
256 #endif
257
258 static struct resource bonaire_disp1_resources[] = {
259         {
260                 .name   = "irq",
261                 .start  = INT_DISPLAY_GENERAL,
262                 .end    = INT_DISPLAY_GENERAL,
263                 .flags  = IORESOURCE_IRQ,
264         },
265         {
266                 .name   = "regs",
267                 .start  = TEGRA_DISPLAY_BASE,
268                 .end    = TEGRA_DISPLAY_BASE + TEGRA_DISPLAY_SIZE-1,
269                 .flags  = IORESOURCE_MEM,
270         },
271         {
272                 .name   = "fbmem",
273                 .start  = 0,    /* Filled in by bonaire_panel_init() */
274                 .end    = 0,    /* Filled in by bonaire_panel_init() */
275                 .flags  = IORESOURCE_MEM,
276         },
277 #ifdef CONFIG_TEGRA_DSI_INSTANCE_1
278         {
279                 .name   = "dsi_regs",
280                 .start  = TEGRA_DSIB_BASE,
281                 .end    = TEGRA_DSIB_BASE + TEGRA_DSIB_SIZE - 1,
282                 .flags  = IORESOURCE_MEM,
283         },
284 #else
285         {
286                 .name   = "dsi_regs",
287                 .start  = TEGRA_DSI_BASE,
288                 .end    = TEGRA_DSI_BASE + TEGRA_DSI_SIZE - 1,
289                 .flags  = IORESOURCE_MEM,
290         },
291 #endif
292 #if defined(CONFIG_TEGRA_DP) || defined(CONFIG_TEGRA_LVDS)
293         {
294                 .name   = "sor",
295                 .start  = TEGRA_SOR_BASE,
296                 .end    = TEGRA_SOR_BASE + TEGRA_SOR_SIZE - 1,
297                 .flags  = IORESOURCE_MEM,
298         },
299 #endif
300 #if defined(CONFIG_TEGRA_DP)
301         {
302                 .name   = "dpaux",
303                 .start  = TEGRA_DPAUX_BASE,
304                 .end    = TEGRA_DPAUX_BASE + TEGRA_DPAUX_SIZE - 1,
305                 .flags  = IORESOURCE_MEM,
306         },
307 #endif
308 };
309
310 static struct resource bonaire_disp2_resources[] = {
311         {
312                 .name   = "irq",
313                 .start  = INT_DISPLAY_B_GENERAL,
314                 .end    = INT_DISPLAY_B_GENERAL,
315                 .flags  = IORESOURCE_IRQ,
316         },
317         {
318                 .name   = "regs",
319                 .start  = TEGRA_DISPLAY2_BASE,
320                 .end    = TEGRA_DISPLAY2_BASE + TEGRA_DISPLAY2_SIZE-1,
321                 .flags  = IORESOURCE_MEM,
322         },
323         {
324                 .name   = "fbmem",
325                 .start  = 0,    /* Filled in by bonaire_panel_init() */
326                 .end    = 0,    /* Filled in by bonaire_panel_init() */
327                 .flags  = IORESOURCE_MEM,
328         },
329 #ifdef CONFIG_TEGRA_DSI_INSTANCE_1
330         {
331                 .name   = "dsi_regs",
332                 .start  = TEGRA_DSIB_BASE,
333                 .end    = TEGRA_DSIB_BASE + TEGRA_DSIB_SIZE - 1,
334                 .flags  = IORESOURCE_MEM,
335         },
336 #else
337         {
338                 .name   = "dsi_regs",
339                 .start  = TEGRA_DSI_BASE,
340                 .end    = TEGRA_DSI_BASE + TEGRA_DSI_SIZE - 1,
341                 .flags  = IORESOURCE_MEM,
342         },
343 #endif
344 #if defined(CONFIG_TEGRA_DP) || defined(CONFIG_TEGRA_LVDS)
345         {
346                 .name   = "sor",
347                 .start  = TEGRA_SOR_BASE,
348                 .end    = TEGRA_SOR_BASE + TEGRA_SOR_SIZE - 1,
349
350                 .flags  = IORESOURCE_MEM,
351         },
352 #endif
353 #if defined(CONFIG_TEGRA_DP)
354         {
355                 .name   = "dpaux",
356                 .start  = TEGRA_DPAUX_BASE,
357                 .end    = TEGRA_DPAUX_BASE + TEGRA_DPAUX_SIZE - 1,
358                 .flags  = IORESOURCE_MEM,
359         },
360 #endif
361 };
362
363 static struct tegra_dc_mode bonaire_panel_modes[] = {
364         {
365                 .pclk = 27000000,
366                 .h_ref_to_sync = 1,
367                 .v_ref_to_sync = 1,
368                 .h_sync_width = 34,
369                 .v_sync_width = 6,
370                 .h_back_porch = 64,
371                 .v_back_porch = 4,
372                 .h_active = 1366,
373                 .v_active = 768,
374                 .h_front_porch = 16,
375                 .v_front_porch = 2,
376         },
377 };
378
379 #if defined(CONFIG_TEGRA_LVDS)
380 static struct tegra_dc_mode bonaire_lvds_panel_modes[] = {
381         {
382                 .pclk          = 27000000,
383                 .h_ref_to_sync = 1,
384                 .v_ref_to_sync = 1,
385                 .h_sync_width  = 32,
386                 .v_sync_width  = 5,
387                 .h_back_porch  = 20,
388                 .v_back_porch  = 12,
389                 .h_active      = 1366,
390                 .v_active      = 768,
391                 .h_front_porch = 48,
392                 .v_front_porch = 3,
393         },
394 };
395 #endif
396
397 static struct tegra_fb_data bonaire_fb_data_linsim = {
398         .win            = 0,
399         .xres           = 120,
400         .yres           = 160,
401         .bits_per_pixel = 16,
402         .flags          = 0,
403 };
404
405 static struct tegra_fb_data bonaire_fb_data = {
406         .win            = 0,
407         .xres           = 1366,
408         .yres           = 768,
409         .bits_per_pixel = 16,
410         .flags          = TEGRA_FB_FLIP_ON_PROBE,
411 };
412
413 static int bonaire_dsi_panel_enable(void)
414 {
415         int ret;
416
417         if (bonaire_dsi_reg == NULL) {
418                 bonaire_dsi_reg = regulator_get(NULL, "avdd_dsi_csi");
419                 if (IS_ERR(bonaire_dsi_reg)) {
420                 pr_err("dsi: Could not get regulator avdd_dsi_csi\n");
421                         bonaire_dsi_reg = NULL;
422                         return PTR_ERR(bonaire_dsi_reg);
423                 }
424         }
425         regulator_enable(bonaire_dsi_reg);
426
427         ret = gpio_request(TEGRA_GPIO_PJ1, "DSI TE");
428         if (ret < 0)
429                 return ret;
430
431         ret = gpio_direction_input(TEGRA_GPIO_PJ1);
432         if (ret < 0) {
433                 gpio_free(TEGRA_GPIO_PJ1);
434                 return ret;
435         }
436
437
438 #if DSI_PANEL_219
439
440         ret = gpio_request(TEGRA_GPIO_PH0, "ph0");
441         if (ret < 0)
442                 return ret;
443         ret = gpio_direction_output(TEGRA_GPIO_PH0, 0);
444         if (ret < 0) {
445                 gpio_free(TEGRA_GPIO_PH0);
446                 return ret;
447         }
448
449         ret = gpio_request(TEGRA_GPIO_PH2, "ph2");
450         if (ret < 0)
451                 return ret;
452         ret = gpio_direction_output(TEGRA_GPIO_PH2, 0);
453         if (ret < 0) {
454                 gpio_free(TEGRA_GPIO_PH2);
455                 return ret;
456         }
457
458         ret = gpio_request(TEGRA_GPIO_PU2, "pu2");
459         if (ret < 0)
460                 return ret;
461         ret = gpio_direction_output(TEGRA_GPIO_PU2, 0);
462         if (ret < 0) {
463                 gpio_free(TEGRA_GPIO_PU2);
464                 return ret;
465         }
466
467         gpio_set_value(bonaire_lvds_shutdown, 1);
468         mdelay(20);
469         gpio_set_value(TEGRA_GPIO_PH0, 1);
470         mdelay(10);
471         gpio_set_value(TEGRA_GPIO_PH2, 1);
472         mdelay(15);
473         gpio_set_value(TEGRA_GPIO_PU2, 0);
474         gpio_set_value(TEGRA_GPIO_PU2, 1);
475         mdelay(10);
476         gpio_set_value(TEGRA_GPIO_PU2, 0);
477         mdelay(10);
478         gpio_set_value(TEGRA_GPIO_PU2, 1);
479         mdelay(15);
480 #endif
481
482 #if DSI_PANEL_218
483         printk("DSI_PANEL_218 is enabled\n");
484         ret = gpio_request(AVDD_LCD, "avdd_lcd");
485         if (ret < 0)
486                 gpio_free(AVDD_LCD);
487         ret = gpio_direction_output(AVDD_LCD, 1);
488         if (ret < 0)
489                 gpio_free(AVDD_LCD);
490
491
492 #if DSI_PANEL_RESET
493         ret = gpio_request(TEGRA_GPIO_PD2, "pd2");
494         if (ret < 0) {
495                 return ret;
496         }
497         ret = gpio_direction_output(TEGRA_GPIO_PD2, 0);
498         if (ret < 0) {
499                 gpio_free(TEGRA_GPIO_PD2);
500                 return ret;
501         }
502
503         gpio_set_value(TEGRA_GPIO_PD2, 1);
504         gpio_set_value(TEGRA_GPIO_PD2, 0);
505         mdelay(2);
506         gpio_set_value(TEGRA_GPIO_PD2, 1);
507         mdelay(2);
508 #endif
509 #endif
510
511         return 0;
512 }
513
514 static int bonaire_dsi_panel_disable(void)
515 {
516         int err;
517
518         err = 0;
519         printk(KERN_INFO "DSI panel disable\n");
520
521 #if DSI_PANEL_219
522         gpio_free(TEGRA_GPIO_PU2);
523         gpio_free(TEGRA_GPIO_PH2);
524         gpio_free(TEGRA_GPIO_PH0);
525         gpio_free(TEGRA_GPIO_PL2);
526 #endif
527
528 #if DSI_PANEL_218
529         gpio_free(TEGRA_GPIO_PD2);
530 #endif
531
532         return err;
533 }
534
535 static int bonaire_dsi_panel_postsuspend(void)
536 {
537         int err;
538
539         err = 0;
540         printk(KERN_INFO "DSI panel postsuspend\n");
541
542         if (bonaire_dsi_reg) {
543                 err = regulator_disable(bonaire_dsi_reg);
544                 if (err < 0)
545                         printk(KERN_ERR
546                         "DSI regulator avdd_dsi_csi disable failed\n");
547                 regulator_put(bonaire_dsi_reg);
548                 bonaire_dsi_reg = NULL;
549         }
550
551 #if DSI_PANEL_218
552         gpio_free(AVDD_LCD);
553 #endif
554
555         return err;
556 }
557
558 static struct tegra_dsi_cmd dsi_init_cmd[] = {
559         DSI_CMD_SHORT(0x05, 0x11, 0x00),
560         DSI_DLY_MS(150),
561         DSI_CMD_SHORT(0x05, 0x29, 0x00),
562         DSI_DLY_MS(20),
563 };
564
565 static struct tegra_dsi_cmd dsi_suspend_cmd[] = {
566         DSI_CMD_SHORT(0x05, 0x28, 0x00),
567         DSI_DLY_MS(20),
568         DSI_CMD_SHORT(0x05, 0x10, 0x00),
569         DSI_DLY_MS(5),
570 };
571
572 struct tegra_dsi_out bonaire_dsi = {
573         .n_data_lanes = 2,
574         .pixel_format = TEGRA_DSI_PIXEL_FORMAT_24BIT_P,
575         .refresh_rate = 60,
576         .virtual_channel = TEGRA_DSI_VIRTUAL_CHANNEL_0,
577
578         .panel_has_frame_buffer = true,
579 #ifdef CONFIG_TEGRA_DSI_INSTANCE_1
580         .dsi_instance = 1,
581 #else
582         .dsi_instance = 0,
583 #endif
584         .panel_reset = DSI_PANEL_RESET,
585
586         .n_init_cmd = ARRAY_SIZE(dsi_init_cmd),
587         .dsi_init_cmd = dsi_init_cmd,
588
589         .n_suspend_cmd = ARRAY_SIZE(dsi_suspend_cmd),
590         .dsi_suspend_cmd = dsi_suspend_cmd,
591
592         .video_data_type = TEGRA_DSI_VIDEO_TYPE_COMMAND_MODE,
593         .lp_cmd_mode_freq_khz = 430000,
594 };
595
596 static struct tegra_dc_mode bonaire_dsi_modes[] = {
597 #if DSI_PANEL_219
598         {
599                 .pclk = 10000000,
600                 .h_ref_to_sync = 4,
601                 .v_ref_to_sync = 1,
602                 .h_sync_width = 16,
603                 .v_sync_width = 1,
604                 .h_back_porch = 32,
605                 .v_back_porch = 1,
606                 .h_active = 540,
607                 .v_active = 960,
608                 .h_front_porch = 32,
609                 .v_front_porch = 2,
610         },
611 #endif
612
613 #if DSI_PANEL_218
614         {
615                 .pclk = 323000000,
616                 .h_ref_to_sync = 11,
617                 .v_ref_to_sync = 1,
618                 .h_sync_width = 16,
619                 .v_sync_width = 4,
620                 .h_back_porch = 16,
621                 .v_back_porch = 4,
622                 .h_active = 864,
623                 .v_active = 480,
624                 .h_front_porch = 16,
625                 .v_front_porch = 4,
626         },
627 #endif
628
629 };
630
631 static struct tegra_fb_data bonaire_dsi_fb_data = {
632 #if DSI_PANEL_219
633         .win            = 0,
634         .xres           = 540,
635         .yres           = 960,
636         .bits_per_pixel = 32,
637 #endif
638
639 #if DSI_PANEL_218
640         .win            = 0,
641         .xres           = 864,
642         .yres           = 480,
643         .bits_per_pixel = 32,
644 #endif
645 };
646
647 static struct tegra_dc_out bonaire_disp_out = {
648         .align          = TEGRA_DC_ALIGN_MSB,
649         .order          = TEGRA_DC_ORDER_RED_BLUE,
650         .flags          = TEGRA_DC_OUT_CONTINUOUS_MODE,
651
652 #if defined(CONFIG_TEGRA_DP)
653         .type           = TEGRA_DC_OUT_DP,
654
655         .modes          = bonaire_panel_modes,
656         .n_modes        = ARRAY_SIZE(bonaire_panel_modes),
657         .out_pins       = edp_out_pins,
658         .n_out_pins     = ARRAY_SIZE(edp_out_pins),
659         .depth          = 18,
660 #elif defined(CONFIG_TEGRA_LVDS)
661         .type           = TEGRA_DC_OUT_LVDS,
662
663         .modes          = bonaire_lvds_panel_modes,
664         .n_modes        = ARRAY_SIZE(bonaire_lvds_panel_modes),
665         .out_pins       = lvds_out_pins,
666         .n_out_pins     = ARRAY_SIZE(lvds_out_pins),
667 #elif defined(CONFIG_TEGRA_BONAIRE_DSI)
668         .type           = TEGRA_DC_OUT_DSI,
669
670         .modes          = bonaire_dsi_modes,
671         .n_modes        = ARRAY_SIZE(bonaire_dsi_modes),
672
673         .dsi            = &bonaire_dsi,
674
675         .enable         = bonaire_dsi_panel_enable,
676         .disable        = bonaire_dsi_panel_disable,
677         .postsuspend    = bonaire_dsi_panel_postsuspend,
678 #else
679         .type           = TEGRA_DC_OUT_RGB,
680
681         .modes          = bonaire_panel_modes,
682         .n_modes        = ARRAY_SIZE(bonaire_panel_modes),
683
684         .enable         = bonaire_panel_enable,
685         .disable        = bonaire_panel_disable,
686 #endif
687 };
688
689 static struct tegra_dc_platform_data bonaire_disp_pdata = {
690         .flags          = TEGRA_DC_FLAG_ENABLED,
691         .default_out    = &bonaire_disp_out,
692         .emc_clk_rate   = 300000000,
693 #ifndef CONFIG_TEGRA_BONAIRE_DSI
694         .fb             = &bonaire_fb_data,
695 #else
696         .fb             = &bonaire_dsi_fb_data,
697 #endif
698 };
699
700 static struct platform_device bonaire_disp1_device = {
701         .name           = "tegradc",
702         .id             = 0,
703         .resource       = bonaire_disp1_resources,
704         .num_resources  = ARRAY_SIZE(bonaire_disp1_resources),
705         .dev = {
706                 .platform_data = &bonaire_disp_pdata,
707         },
708 };
709
710 static struct platform_device bonaire_disp2_device = {
711         .name           = "tegradc",
712         .id             = 1,
713         .resource       = bonaire_disp2_resources,
714         .num_resources  = ARRAY_SIZE(bonaire_disp2_resources),
715         .dev = {
716                 .platform_data = &bonaire_disp_pdata,
717         },
718 };
719
720 static struct nvmap_platform_carveout bonaire_carveouts[] = {
721         [0] = {
722                 .name           = "iram",
723                 .usage_mask     = NVMAP_HEAP_CARVEOUT_IRAM,
724                 .base           = TEGRA_IRAM_BASE,
725                 .size           = TEGRA_IRAM_SIZE,
726                 .buddy_size     = 0, /* no buddy allocation for IRAM */
727         },
728         [1] = {
729                 .name           = "generic-0",
730                 .usage_mask     = NVMAP_HEAP_CARVEOUT_GENERIC,
731                 .base           = 0,    /* Filled in by bonaire_panel_init() */
732                 .size           = 0,    /* Filled in by bonaire_panel_init() */
733                 .buddy_size     = SZ_32K,
734         },
735         [2] = {
736                 .name           = "vpr",
737                 .usage_mask     = NVMAP_HEAP_CARVEOUT_VPR,
738                 .base           = 0,    /* Filled in by bonaire_panel_init() */
739                 .size           = 0,    /* Filled in by bonaire_panel_init() */
740                 .buddy_size     = SZ_32K,
741         },
742 };
743
744 static struct nvmap_platform_data bonaire_nvmap_data = {
745         .carveouts      = bonaire_carveouts,
746         .nr_carveouts   = ARRAY_SIZE(bonaire_carveouts),
747 };
748
749 static struct platform_device bonaire_nvmap_device = {
750         .name   = "tegra-nvmap",
751         .id     = -1,
752         .dev    = {
753                 .platform_data = &bonaire_nvmap_data,
754         },
755 };
756
757 static struct platform_device *bonaire_gfx_devices[] __initdata = {
758         &bonaire_nvmap_device,
759         &tegra_pwfm_device,
760         &bonaire_backlight_device,
761 };
762
763 int __init bonaire_panel_init(void)
764 {
765         int err;
766         struct resource *res;
767 #if defined(CONFIG_TEGRA_GRHOST)
768         struct platform_device *phost1x;
769 #endif
770
771 #ifdef CONFIG_TEGRA_PRE_SILICON_SUPPORT
772         if (tegra_platform_is_linsim()) {
773                 bonaire_panel_modes[0].h_active = 120;
774                 bonaire_panel_modes[0].v_active = 160;
775                 bonaire_fb_data = bonaire_fb_data_linsim;
776                 bonaire_dsi.pixel_format = TEGRA_DSI_PIXEL_FORMAT_16BIT_P;
777                 bonaire_dsi.video_data_type = TEGRA_DSI_VIDEO_TYPE_VIDEO_MODE;
778 #if DSI_PANEL_218
779                 bonaire_dsi_modes[0].h_active = 320;
780                 bonaire_dsi_modes[0].v_active = 240;
781                 bonaire_dsi_fb_data.xres = 320;
782                 bonaire_dsi_fb_data.yres = 240;
783                 bonaire_dsi_fb_data.bits_per_pixel = 16;
784 #endif
785                 bonaire_carveouts[0].size = 0;
786         }
787 #endif
788
789         bonaire_carveouts[1].base = tegra_carveout_start;
790         bonaire_carveouts[1].size = tegra_carveout_size;
791         bonaire_carveouts[2].base = tegra_vpr_start;
792         bonaire_carveouts[2].size = tegra_vpr_size;
793
794         err = platform_add_devices(bonaire_gfx_devices,
795                                    ARRAY_SIZE(bonaire_gfx_devices));
796
797 #ifdef CONFIG_TEGRA_GRHOST
798         phost1x = bonaire_host1x_init();
799         if (!phost1x)
800                 return -EINVAL;
801 #endif
802
803 #if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
804         if (!tegra_platform_is_fpga()) {
805                 res = platform_get_resource_byname(&bonaire_disp1_device,
806                         IORESOURCE_MEM, "fbmem");
807                 res->start = tegra_fb_start;
808                 res->end = tegra_fb_start + tegra_fb_size - 1;
809
810 #ifdef CONFIG_TEGRA_IOMMU_SMMU
811                 /* Copy the bootloader fb to the fb. */
812                 __tegra_move_framebuffer(&bonaire_nvmap_device,
813                         tegra_fb_start, tegra_bootloader_fb_start,
814                         tegra_fb_size);
815 #endif
816
817                 if (!err) {
818                         bonaire_disp1_device.dev.parent = &phost1x->dev;
819                         err = platform_device_register(&bonaire_disp1_device);
820                 }
821         } else {
822                 /* FPGA only has disp2 support */
823                 res = platform_get_resource_byname(&bonaire_disp2_device,
824                         IORESOURCE_MEM, "fbmem");
825                 res->start = tegra_fb_start;
826                 res->end = tegra_fb_start + tegra_fb_size - 1;
827
828 #ifdef CONFIG_TEGRA_IOMMU_SMMU
829                 /* Copy the bootloader fb to the fb. */
830                 __tegra_move_framebuffer(&bonaire_nvmap_device,
831                         tegra_fb_start, tegra_bootloader_fb_start,
832                         tegra_fb_size);
833 #endif
834
835                 if (!err) {
836                         bonaire_disp2_device.dev.parent = &phost1x->dev;
837                         err = platform_device_register(&bonaire_disp2_device);
838                 }
839         }
840
841 #endif
842
843 #ifdef CONFIG_TEGRA_NVAVP
844         nvavp_device.dev.parent = &phost1x->dev;
845         err = platform_device_register(&nvavp_device);
846         if (err) {
847                 pr_err("nvavp device registration failed\n");
848                 return err;
849         }
850 #endif
851         return err;
852 }