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