dalmore: E1627 calibrated backlight
[linux-2.6.git] / arch / arm / mach-tegra / board-dalmore-panel.c
1 /*
2  * arch/arm/mach-tegra/board-dalmore-panel.c
3  *
4  * Copyright (c) 2011-2012, 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 #include <linux/ioport.h>
21 #include <linux/fb.h>
22 #include <linux/nvmap.h>
23 #include <linux/nvhost.h>
24 #include <linux/init.h>
25 #include <linux/delay.h>
26 #include <linux/gpio.h>
27 #include <linux/tegra_pwm_bl.h>
28 #include <linux/regulator/consumer.h>
29
30 #include <mach/irqs.h>
31 #include <mach/iomap.h>
32 #include <mach/dc.h>
33
34 #include "board.h"
35 #include "devices.h"
36 #include "gpio-names.h"
37 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
38 #include "tegra3_host1x_devices.h"
39 #else
40 #include "tegra11_host1x_devices.h"
41 #endif
42
43 #define TEGRA_PANEL_ENABLE      1
44
45 #if TEGRA_PANEL_ENABLE
46
47 #define TEGRA_DSI_GANGED_MODE   0
48 #define IS_EXTERNAL_PWM         1
49
50 /* PANEL_<diagonal length in inches>_<vendor name>_<resolution> */
51 #define PANEL_10_1_PANASONIC_1920_1200  1
52 #define PANEL_11_6_AUO_1920_1080        0
53 #define PANEL_10_1_SHARP_2560_1600      0
54
55 #define DSI_PANEL_RESET         1
56 #define DSI_PANEL_RST_GPIO      TEGRA_GPIO_PH3
57 #define DSI_PANEL_BL_EN_GPIO    TEGRA_GPIO_PH2
58
59 #define DC_CTRL_MODE    TEGRA_DC_OUT_CONTINUOUS_MODE
60
61 /* HDMI Hotplug detection pin */
62 #define dalmore_hdmi_hpd        TEGRA_GPIO_PN7
63
64 static atomic_t sd_brightness = ATOMIC_INIT(255);
65
66 static bool reg_requested;
67 static bool gpio_requested;
68
69 /* for PANEL_10_1_PANASONIC_1920_1200, PANEL_11_6_AUO_1920_1080
70  * and PANEL_10_1_SHARP_2560_1600
71  */
72 static struct regulator *avdd_lcd_3v3;
73 static struct regulator *vdd_lcd_bl_12v;
74
75 /* for PANEL_11_6_AUO_1920_1080 and PANEL_10_1_SHARP_2560_1600 */
76 static struct regulator *dvdd_lcd_1v8;
77
78 /* for PANEL_11_6_AUO_1920_1080 */
79 static struct regulator *vdd_ds_1v8;
80 #define en_vdd_bl       TEGRA_GPIO_PG0
81 #define lvds_en         TEGRA_GPIO_PG3
82
83 #ifdef CONFIG_TEGRA_DC
84 static struct regulator *dalmore_hdmi_reg;
85 static struct regulator *dalmore_hdmi_pll;
86 static struct regulator *dalmore_hdmi_vddio;
87 #endif
88
89 static struct resource dalmore_disp1_resources[] = {
90         {
91                 .name   = "irq",
92                 .start  = INT_DISPLAY_GENERAL,
93                 .end    = INT_DISPLAY_GENERAL,
94                 .flags  = IORESOURCE_IRQ,
95         },
96         {
97                 .name   = "regs",
98                 .start  = TEGRA_DISPLAY_BASE,
99                 .end    = TEGRA_DISPLAY_BASE + TEGRA_DISPLAY_SIZE - 1,
100                 .flags  = IORESOURCE_MEM,
101         },
102         {
103                 .name   = "fbmem",
104                 .start  = 0, /* Filled in by dalmore_panel_init() */
105                 .end    = 0, /* Filled in by dalmore_panel_init() */
106                 .flags  = IORESOURCE_MEM,
107         },
108 #if TEGRA_DSI_GANGED_MODE
109         {
110                 .name   = "ganged_dsia_regs",
111                 .start  = TEGRA_DSI_BASE,
112                 .end    = TEGRA_DSI_BASE + TEGRA_DSI_SIZE - 1,
113                 .flags  = IORESOURCE_MEM,
114         },
115         {
116                 .name   = "ganged_dsib_regs",
117                 .start  = TEGRA_DSIB_BASE,
118                 .end    = TEGRA_DSIB_BASE + TEGRA_DSIB_SIZE - 1,
119                 .flags  = IORESOURCE_MEM,
120         },
121 #else
122         {
123                 .name   = "dsi_regs",
124                 .start  = TEGRA_DSI_BASE,
125                 .end    = TEGRA_DSI_BASE + TEGRA_DSI_SIZE - 1,
126                 .flags  = IORESOURCE_MEM,
127         },
128 #endif
129 };
130
131 static struct resource dalmore_disp2_resources[] = {
132         {
133                 .name   = "irq",
134                 .start  = INT_DISPLAY_B_GENERAL,
135                 .end    = INT_DISPLAY_B_GENERAL,
136                 .flags  = IORESOURCE_IRQ,
137         },
138         {
139                 .name   = "regs",
140                 .start  = TEGRA_DISPLAY2_BASE,
141                 .end    = TEGRA_DISPLAY2_BASE + TEGRA_DISPLAY2_SIZE - 1,
142                 .flags  = IORESOURCE_MEM,
143         },
144         {
145                 .name   = "fbmem",
146                 .start  = 0, /* Filled in by dalmore_panel_init() */
147                 .end    = 0, /* Filled in by dalmore_panel_init() */
148                 .flags  = IORESOURCE_MEM,
149         },
150         {
151                 .name   = "hdmi_regs",
152                 .start  = TEGRA_HDMI_BASE,
153                 .end    = TEGRA_HDMI_BASE + TEGRA_HDMI_SIZE - 1,
154                 .flags  = IORESOURCE_MEM,
155         },
156 };
157
158 #if PANEL_10_1_PANASONIC_1920_1200
159 static tegra_dc_bl_output dalmore_bl_output_measured = {
160         0, 0, 1, 2, 3, 4, 5, 6,
161         7, 8, 9, 9, 10, 11, 12, 13,
162         13, 14, 15, 16, 17, 17, 18, 19,
163         20, 21, 22, 22, 23, 24, 25, 26,
164         27, 27, 28, 29, 30, 31, 32, 32,
165         33, 34, 35, 36, 37, 37, 38, 39,
166         40, 41, 42, 42, 43, 44, 45, 46,
167         47, 48, 48, 49, 50, 51, 52, 53,
168         54, 55, 56, 57, 57, 58, 59, 60,
169         61, 62, 63, 64, 65, 66, 67, 68,
170         69, 70, 71, 71, 72, 73, 74, 75,
171         76, 77, 77, 78, 79, 80, 81, 82,
172         83, 84, 85, 87, 88, 89, 90, 91,
173         92, 93, 94, 95, 96, 97, 98, 99,
174         100, 101, 102, 103, 104, 105, 106, 107,
175         108, 109, 110, 111, 112, 113, 115, 116,
176         117, 118, 119, 120, 121, 122, 123, 124,
177         125, 126, 127, 128, 129, 130, 131, 132,
178         133, 134, 135, 136, 137, 138, 139, 141,
179         142, 143, 144, 146, 147, 148, 149, 151,
180         152, 153, 154, 155, 156, 157, 158, 158,
181         159, 160, 161, 162, 163, 165, 166, 167,
182         168, 169, 170, 171, 172, 173, 174, 176,
183         177, 178, 179, 180, 182, 183, 184, 185,
184         186, 187, 188, 189, 190, 191, 192, 194,
185         195, 196, 197, 198, 199, 200, 201, 202,
186         203, 204, 205, 206, 207, 208, 209, 210,
187         211, 212, 213, 214, 215, 216, 217, 219,
188         220, 221, 222, 224, 225, 226, 227, 229,
189         230, 231, 232, 233, 234, 235, 236, 238,
190         239, 240, 241, 242, 243, 244, 245, 246,
191         247, 248, 249, 250, 251, 252, 253, 255
192 };
193 #elif PANEL_11_6_AUO_1920_1080
194 /* TODO: Calibrate for AUO panel */
195 static tegra_dc_bl_output dalmore_bl_output_measured = {
196         0, 0, 1, 2, 3, 4, 5, 6,
197         7, 8, 9, 9, 10, 11, 12, 13,
198         13, 14, 15, 16, 17, 17, 18, 19,
199         20, 21, 22, 22, 23, 24, 25, 26,
200         27, 27, 28, 29, 30, 31, 32, 32,
201         33, 34, 35, 36, 37, 37, 38, 39,
202         40, 41, 42, 42, 43, 44, 45, 46,
203         47, 48, 48, 49, 50, 51, 52, 53,
204         54, 55, 56, 57, 57, 58, 59, 60,
205         61, 62, 63, 64, 65, 66, 67, 68,
206         69, 70, 71, 71, 72, 73, 74, 75,
207         76, 77, 77, 78, 79, 80, 81, 82,
208         83, 84, 85, 87, 88, 89, 90, 91,
209         92, 93, 94, 95, 96, 97, 98, 99,
210         100, 101, 102, 103, 104, 105, 106, 107,
211         108, 109, 110, 111, 112, 113, 115, 116,
212         117, 118, 119, 120, 121, 122, 123, 124,
213         125, 126, 127, 128, 129, 130, 131, 132,
214         133, 134, 135, 136, 137, 138, 139, 141,
215         142, 143, 144, 146, 147, 148, 149, 151,
216         152, 153, 154, 155, 156, 157, 158, 158,
217         159, 160, 161, 162, 163, 165, 166, 167,
218         168, 169, 170, 171, 172, 173, 174, 176,
219         177, 178, 179, 180, 182, 183, 184, 185,
220         186, 187, 188, 189, 190, 191, 192, 194,
221         195, 196, 197, 198, 199, 200, 201, 202,
222         203, 204, 205, 206, 207, 208, 209, 210,
223         211, 212, 213, 214, 215, 216, 217, 219,
224         220, 221, 222, 224, 225, 226, 227, 229,
225         230, 231, 232, 233, 234, 235, 236, 238,
226         239, 240, 241, 242, 243, 244, 245, 246,
227         247, 248, 249, 250, 251, 252, 253, 255
228 };
229 #elif PANEL_10_1_SHARP_2560_1600
230 /* TODO: Calibrate for SHARP panel */
231 static tegra_dc_bl_output dalmore_bl_output_measured = {
232         0, 0, 1, 2, 3, 4, 5, 6,
233         7, 8, 9, 9, 10, 11, 12, 13,
234         13, 14, 15, 16, 17, 17, 18, 19,
235         20, 21, 22, 22, 23, 24, 25, 26,
236         27, 27, 28, 29, 30, 31, 32, 32,
237         33, 34, 35, 36, 37, 37, 38, 39,
238         40, 41, 42, 42, 43, 44, 45, 46,
239         47, 48, 48, 49, 50, 51, 52, 53,
240         54, 55, 56, 57, 57, 58, 59, 60,
241         61, 62, 63, 64, 65, 66, 67, 68,
242         69, 70, 71, 71, 72, 73, 74, 75,
243         76, 77, 77, 78, 79, 80, 81, 82,
244         83, 84, 85, 87, 88, 89, 90, 91,
245         92, 93, 94, 95, 96, 97, 98, 99,
246         100, 101, 102, 103, 104, 105, 106, 107,
247         108, 109, 110, 111, 112, 113, 115, 116,
248         117, 118, 119, 120, 121, 122, 123, 124,
249         125, 126, 127, 128, 129, 130, 131, 132,
250         133, 134, 135, 136, 137, 138, 139, 141,
251         142, 143, 144, 146, 147, 148, 149, 151,
252         152, 153, 154, 155, 156, 157, 158, 158,
253         159, 160, 161, 162, 163, 165, 166, 167,
254         168, 169, 170, 171, 172, 173, 174, 176,
255         177, 178, 179, 180, 182, 183, 184, 185,
256         186, 187, 188, 189, 190, 191, 192, 194,
257         195, 196, 197, 198, 199, 200, 201, 202,
258         203, 204, 205, 206, 207, 208, 209, 210,
259         211, 212, 213, 214, 215, 216, 217, 219,
260         220, 221, 222, 224, 225, 226, 227, 229,
261         230, 231, 232, 233, 234, 235, 236, 238,
262         239, 240, 241, 242, 243, 244, 245, 246,
263         247, 248, 249, 250, 251, 252, 253, 255
264 };
265 #endif
266
267 static p_tegra_dc_bl_output bl_output = dalmore_bl_output_measured;
268
269 static struct tegra_dsi_cmd dsi_init_cmd[] = {
270 #if PANEL_10_1_PANASONIC_1920_1200
271         /* no init command required */
272 #endif
273 #if PANEL_11_6_AUO_1920_1080
274         /* no init command required */
275 #endif
276 #if PANEL_10_1_SHARP_2560_1600
277         /* TODO */
278 #endif
279 };
280
281 static struct tegra_dsi_out dalmore_dsi = {
282 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
283         .n_data_lanes = 2,
284         .controller_vs = DSI_VS_0,
285 #else
286         .n_data_lanes = 4,
287         .controller_vs = DSI_VS_1,
288 #endif
289 #if PANEL_11_6_AUO_1920_1080
290         .dsi2edp_bridge_enable = true,
291 #endif
292         .pixel_format = TEGRA_DSI_PIXEL_FORMAT_24BIT_P,
293         .refresh_rate = 59,
294         .virtual_channel = TEGRA_DSI_VIRTUAL_CHANNEL_0,
295
296         .dsi_instance = DSI_INSTANCE_0,
297
298         .panel_reset = DSI_PANEL_RESET,
299         .power_saving_suspend = true,
300 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
301         .video_data_type = TEGRA_DSI_VIDEO_TYPE_COMMAND_MODE,
302 #else
303         .video_data_type = TEGRA_DSI_VIDEO_TYPE_VIDEO_MODE,
304         .video_clock_mode = TEGRA_DSI_VIDEO_CLOCK_TX_ONLY,
305         .video_burst_mode = TEGRA_DSI_VIDEO_NONE_BURST_MODE_WITH_SYNC_END,
306 #endif
307         .dsi_init_cmd = dsi_init_cmd,
308         .n_init_cmd = ARRAY_SIZE(dsi_init_cmd),
309 };
310
311 static int dalmore_dsi_regulator_get(struct device *dev)
312 {
313         int err = 0;
314
315         if (reg_requested)
316                 return 0;
317
318 #if PANEL_11_6_AUO_1920_1080 || \
319         PANEL_10_1_SHARP_2560_1600
320         dvdd_lcd_1v8 = regulator_get(dev, "dvdd_lcd");
321         if (IS_ERR_OR_NULL(dvdd_lcd_1v8)) {
322                 pr_err("dvdd_lcd regulator get failed\n");
323                 err = PTR_ERR(dvdd_lcd_1v8);
324                 dvdd_lcd_1v8 = NULL;
325                 goto fail;
326         }
327 #endif
328 #if PANEL_11_6_AUO_1920_1080
329         vdd_ds_1v8 = regulator_get(dev, "vdd_ds_1v8");
330         if (IS_ERR_OR_NULL(vdd_ds_1v8)) {
331                 pr_err("vdd_ds_1v8 regulator get failed\n");
332                 err = PTR_ERR(vdd_ds_1v8);
333                 vdd_ds_1v8 = NULL;
334                 goto fail;
335         }
336 #endif
337 #if PANEL_10_1_PANASONIC_1920_1200 || \
338         PANEL_11_6_AUO_1920_1080 || \
339         PANEL_10_1_SHARP_2560_1600
340         avdd_lcd_3v3 = regulator_get(dev, "avdd_lcd");
341         if (IS_ERR_OR_NULL(avdd_lcd_3v3)) {
342                 pr_err("avdd_lcd regulator get failed\n");
343                 err = PTR_ERR(avdd_lcd_3v3);
344                 avdd_lcd_3v3 = NULL;
345                 goto fail;
346         }
347
348         vdd_lcd_bl_12v = regulator_get(dev, "vdd_lcd_bl");
349         if (IS_ERR_OR_NULL(vdd_lcd_bl_12v)) {
350                 pr_err("vdd_lcd_bl regulator get failed\n");
351                 err = PTR_ERR(vdd_lcd_bl_12v);
352                 vdd_lcd_bl_12v = NULL;
353                 goto fail;
354         }
355 #endif
356         reg_requested = true;
357         return 0;
358 fail:
359         return err;
360 }
361
362 static int dalmore_dsi_gpio_get(void)
363 {
364         int err = 0;
365
366         if (gpio_requested)
367                 return 0;
368
369         err = gpio_request(DSI_PANEL_RST_GPIO, "panel rst");
370         if (err < 0) {
371                 pr_err("panel reset gpio request failed\n");
372                 goto fail;
373         }
374
375         err = gpio_request(DSI_PANEL_BL_EN_GPIO, "panel backlight");
376         if (err < 0) {
377                 pr_err("panel backlight gpio request failed\n");
378                 goto fail;
379         }
380
381 #if PANEL_11_6_AUO_1920_1080
382         err = gpio_request(en_vdd_bl, "edp bridge 1v2 enable");
383         if (err < 0) {
384                 pr_err("edp bridge 1v2 enable gpio request failed\n");
385                 goto fail;
386         }
387
388         err = gpio_request(lvds_en, "edp bridge 1v8 enable");
389         if (err < 0) {
390                 pr_err("edp bridge 1v8 enable gpio request failed\n");
391                 goto fail;
392         }
393 #endif
394         gpio_requested = true;
395         return 0;
396 fail:
397         return err;
398 }
399
400 static int dalmore_dsi_panel_enable(struct device *dev)
401 {
402         int err = 0;
403
404         err = dalmore_dsi_regulator_get(dev);
405         if (err < 0) {
406                 pr_err("dsi regulator get failed\n");
407                 goto fail;
408         }
409         err = dalmore_dsi_gpio_get();
410         if (err < 0) {
411                 pr_err("dsi gpio request failed\n");
412                 goto fail;
413         }
414
415         if (vdd_ds_1v8) {
416                 err = regulator_enable(vdd_ds_1v8);
417                 if (err < 0) {
418                         pr_err("vdd_ds_1v8 regulator enable failed\n");
419                         goto fail;
420                 }
421         }
422
423         if (dvdd_lcd_1v8) {
424                 err = regulator_enable(dvdd_lcd_1v8);
425                 if (err < 0) {
426                         pr_err("dvdd_lcd regulator enable failed\n");
427                         goto fail;
428                 }
429         }
430
431         if (avdd_lcd_3v3) {
432                 err = regulator_enable(avdd_lcd_3v3);
433                 if (err < 0) {
434                         pr_err("avdd_lcd regulator enable failed\n");
435                         goto fail;
436                 }
437         }
438
439         if (vdd_lcd_bl_12v) {
440                 err = regulator_enable(vdd_lcd_bl_12v);
441                 if (err < 0) {
442                         pr_err("vdd_lcd_bl regulator enable failed\n");
443                         goto fail;
444                 }
445         }
446
447         msleep(100);
448 #if DSI_PANEL_RESET
449         gpio_direction_output(DSI_PANEL_RST_GPIO, 1);
450         usleep_range(1000, 5000);
451         gpio_set_value(DSI_PANEL_RST_GPIO, 0);
452         msleep(150);
453         gpio_set_value(DSI_PANEL_RST_GPIO, 1);
454         msleep(1500);
455 #endif
456
457         gpio_direction_output(DSI_PANEL_BL_EN_GPIO, 1);
458         gpio_direction_output(57, 1);
459
460 #if PANEL_11_6_AUO_1920_1080
461         gpio_direction_output(en_vdd_bl, 1);
462         msleep(100);
463         gpio_direction_output(lvds_en, 1);
464 #endif
465         return 0;
466 fail:
467         return err;
468 }
469
470 static int dalmore_dsi_panel_disable(void)
471 {
472         gpio_set_value(DSI_PANEL_BL_EN_GPIO, 0);
473
474 #if PANEL_11_6_AUO_1920_1080
475         gpio_set_value(lvds_en, 0);
476         msleep(100);
477         gpio_set_value(en_vdd_bl, 0);
478 #endif
479         if (vdd_lcd_bl_12v)
480                 regulator_disable(vdd_lcd_bl_12v);
481
482         if (avdd_lcd_3v3)
483                 regulator_disable(avdd_lcd_3v3);
484
485         if (dvdd_lcd_1v8)
486                 regulator_disable(dvdd_lcd_1v8);
487
488         if (vdd_ds_1v8)
489                 regulator_disable(vdd_ds_1v8);
490
491         return 0;
492 }
493
494 static int dalmore_dsi_panel_postsuspend(void)
495 {
496         return 0;
497 }
498
499 static struct tegra_dc_mode dalmore_dsi_modes[] = {
500 #if PANEL_10_1_PANASONIC_1920_1200
501         {
502                 .pclk = 10000000,
503                 .h_ref_to_sync = 4,
504                 .v_ref_to_sync = 1,
505                 .h_sync_width = 16,
506                 .v_sync_width = 2,
507                 .h_back_porch = 32,
508                 .v_back_porch = 16,
509                 .h_active = 1920,
510                 .v_active = 1200,
511                 .h_front_porch = 120,
512                 .v_front_porch = 17,
513         },
514 #endif
515 #if PANEL_11_6_AUO_1920_1080
516         {
517                 .pclk = 10000000,
518                 .h_ref_to_sync = 4,
519                 .v_ref_to_sync = 1,
520                 .h_sync_width = 28,
521                 .v_sync_width = 5,
522                 .h_back_porch = 148,
523                 .v_back_porch = 23,
524                 .h_active = 1920,
525                 .v_active = 1080,
526                 .h_front_porch = 66,
527                 .v_front_porch = 4,
528         },
529 #endif
530 #if PANEL_10_1_SHARP_2560_1600
531         {
532                 .pclk = 10000000,
533                 .h_ref_to_sync = 4,
534                 .v_ref_to_sync = 1,
535                 .h_sync_width = 16,
536                 .v_sync_width = 2,
537                 .h_back_porch = 16,
538                 .v_back_porch = 33,
539                 .h_active = 2560,
540                 .v_active = 1600,
541                 .h_front_porch = 128,
542                 .v_front_porch = 10,
543         },
544 #endif
545 };
546
547 static struct tegra_dc_out dalmore_disp1_out = {
548         .type           = TEGRA_DC_OUT_DSI,
549         .dsi            = &dalmore_dsi,
550
551         .flags          = DC_CTRL_MODE,
552
553         .modes          = dalmore_dsi_modes,
554         .n_modes        = ARRAY_SIZE(dalmore_dsi_modes),
555
556         .enable         = dalmore_dsi_panel_enable,
557         .disable        = dalmore_dsi_panel_disable,
558         .postsuspend    = dalmore_dsi_panel_postsuspend,
559
560 #if PANEL_10_1_PANASONIC_1920_1200
561         .width          = 217,
562         .height         = 135,
563 #endif
564 #if PANEL_11_6_AUO_1920_1080
565         .width          = 256,
566         .height         = 144,
567 #endif
568 #if PANEL_10_1_SHARP_2560_1600
569         .width          = 216,
570         .height         = 135,
571 #endif
572 };
573
574 static int dalmore_hdmi_enable(struct device *dev)
575 {
576         int ret;
577         if (!dalmore_hdmi_reg) {
578                         dalmore_hdmi_reg = regulator_get(dev, "avdd_hdmi");
579                         if (IS_ERR_OR_NULL(dalmore_hdmi_reg)) {
580                                 pr_err("hdmi: couldn't get regulator avdd_hdmi\n");
581                                 dalmore_hdmi_reg = NULL;
582                                 return PTR_ERR(dalmore_hdmi_reg);
583                         }
584         }
585         ret = regulator_enable(dalmore_hdmi_reg);
586         if (ret < 0) {
587                 pr_err("hdmi: couldn't enable regulator avdd_hdmi\n");
588                 return ret;
589         }
590         if (!dalmore_hdmi_pll) {
591                 dalmore_hdmi_pll = regulator_get(dev, "avdd_hdmi_pll");
592                 if (IS_ERR_OR_NULL(dalmore_hdmi_pll)) {
593                         pr_err("hdmi: couldn't get regulator avdd_hdmi_pll\n");
594                         dalmore_hdmi_pll = NULL;
595                         regulator_put(dalmore_hdmi_reg);
596                         dalmore_hdmi_reg = NULL;
597                         return PTR_ERR(dalmore_hdmi_pll);
598                 }
599         }
600         ret = regulator_enable(dalmore_hdmi_pll);
601         if (ret < 0) {
602                 pr_err("hdmi: couldn't enable regulator avdd_hdmi_pll\n");
603                 return ret;
604         }
605         return 0;
606 }
607
608 static int dalmore_hdmi_disable(void)
609 {
610         if (dalmore_hdmi_reg) {
611                 regulator_disable(dalmore_hdmi_reg);
612                 regulator_put(dalmore_hdmi_reg);
613                 dalmore_hdmi_reg = NULL;
614         }
615
616         if (dalmore_hdmi_pll) {
617                 regulator_disable(dalmore_hdmi_pll);
618                 regulator_put(dalmore_hdmi_pll);
619                 dalmore_hdmi_pll = NULL;
620         }
621
622         return 0;
623 }
624
625 static int dalmore_hdmi_postsuspend(void)
626 {
627         if (dalmore_hdmi_vddio) {
628                 regulator_disable(dalmore_hdmi_vddio);
629                 regulator_put(dalmore_hdmi_vddio);
630                 dalmore_hdmi_vddio = NULL;
631         }
632         return 0;
633 }
634
635 static int dalmore_hdmi_hotplug_init(struct device *dev)
636 {
637         if (!dalmore_hdmi_vddio) {
638                 dalmore_hdmi_vddio = regulator_get(dev, "vdd_hdmi_5v0");
639                 if (WARN_ON(IS_ERR(dalmore_hdmi_vddio))) {
640                         pr_err("%s: couldn't get regulator vdd_hdmi_5v0: %ld\n",
641                                 __func__, PTR_ERR(dalmore_hdmi_vddio));
642                                 dalmore_hdmi_vddio = NULL;
643                 } else {
644                         regulator_enable(dalmore_hdmi_vddio);
645                 }
646         }
647
648         return 0;
649 }
650
651 static struct tegra_dc_out dalmore_disp2_out = {
652         .type           = TEGRA_DC_OUT_HDMI,
653         .flags          = TEGRA_DC_OUT_HOTPLUG_HIGH,
654         .parent_clk     = "pll_d2_out0",
655
656         .dcc_bus        = 3,
657         .hotplug_gpio   = dalmore_hdmi_hpd,
658
659         .max_pixclock   = KHZ2PICOS(148500),
660
661         .align          = TEGRA_DC_ALIGN_MSB,
662         .order          = TEGRA_DC_ORDER_RED_BLUE,
663
664         .enable         = dalmore_hdmi_enable,
665         .disable        = dalmore_hdmi_disable,
666         .postsuspend    = dalmore_hdmi_postsuspend,
667         .hotplug_init   = dalmore_hdmi_hotplug_init,
668 };
669
670 static struct tegra_fb_data dalmore_disp1_fb_data = {
671         .win            = 0,
672         .bits_per_pixel = 32,
673         .flags          = TEGRA_FB_FLIP_ON_PROBE,
674 #if PANEL_10_1_PANASONIC_1920_1200
675         .xres           = 1920,
676         .yres           = 1200,
677 #endif
678 #if PANEL_11_6_AUO_1920_1080
679         .xres           = 1920,
680         .yres           = 1080,
681 #endif
682 #if PANEL_10_1_SHARP_2560_1600
683         .xres           = 2560,
684         .yres           = 1600,
685 #endif
686 };
687
688 static struct tegra_dc_platform_data dalmore_disp1_pdata = {
689         .flags          = TEGRA_DC_FLAG_ENABLED,
690         .default_out    = &dalmore_disp1_out,
691         .fb             = &dalmore_disp1_fb_data,
692         .emc_clk_rate   = 204000000,
693 };
694
695 static struct tegra_fb_data dalmore_disp2_fb_data = {
696         .win            = 0,
697         .xres           = 1024,
698         .yres           = 600,
699         .bits_per_pixel = 32,
700         .flags          = TEGRA_FB_FLIP_ON_PROBE,
701 };
702
703 static struct tegra_dc_platform_data dalmore_disp2_pdata = {
704         .flags          = TEGRA_DC_FLAG_ENABLED,
705         .default_out    = &dalmore_disp2_out,
706         .fb             = &dalmore_disp2_fb_data,
707         .emc_clk_rate   = 300000000,
708 };
709
710 static struct nvhost_device dalmore_disp2_device = {
711         .name           = "tegradc",
712         .id             = 1,
713         .resource       = dalmore_disp2_resources,
714         .num_resources  = ARRAY_SIZE(dalmore_disp2_resources),
715         .dev = {
716                 .platform_data = &dalmore_disp2_pdata,
717         },
718 };
719
720 static struct nvhost_device dalmore_disp1_device = {
721         .name           = "tegradc",
722         .id             = 0,
723         .resource       = dalmore_disp1_resources,
724         .num_resources  = ARRAY_SIZE(dalmore_disp1_resources),
725         .dev = {
726                 .platform_data = &dalmore_disp1_pdata,
727         },
728 };
729
730 static struct nvmap_platform_carveout dalmore_carveouts[] = {
731         [0] = {
732                 .name           = "iram",
733                 .usage_mask     = NVMAP_HEAP_CARVEOUT_IRAM,
734                 .base           = TEGRA_IRAM_BASE + TEGRA_RESET_HANDLER_SIZE,
735                 .size           = TEGRA_IRAM_SIZE - TEGRA_RESET_HANDLER_SIZE,
736                 .buddy_size     = 0, /* no buddy allocation for IRAM */
737         },
738         [1] = {
739                 .name           = "generic-0",
740                 .usage_mask     = NVMAP_HEAP_CARVEOUT_GENERIC,
741                 .base           = 0, /* Filled in by dalmore_panel_init() */
742                 .size           = 0, /* Filled in by dalmore_panel_init() */
743                 .buddy_size     = SZ_32K,
744         },
745         [2] = {
746                 .name           = "vpr",
747                 .usage_mask     = NVMAP_HEAP_CARVEOUT_VPR,
748                 .base           = 0, /* Filled in by dalmore_panel_init() */
749                 .size           = 0, /* Filled in by dalmore_panel_init() */
750                 .buddy_size     = SZ_32K,
751         },
752 };
753
754 static struct nvmap_platform_data dalmore_nvmap_data = {
755         .carveouts      = dalmore_carveouts,
756         .nr_carveouts   = ARRAY_SIZE(dalmore_carveouts),
757 };
758
759 static struct platform_device dalmore_nvmap_device __initdata = {
760         .name   = "tegra-nvmap",
761         .id     = -1,
762         .dev    = {
763                 .platform_data = &dalmore_nvmap_data,
764         },
765 };
766
767 static int dalmore_disp1_bl_notify(struct device *unused, int brightness)
768 {
769         int cur_sd_brightness = atomic_read(&sd_brightness);
770
771         /* SD brightness is a percentage */
772         brightness = (brightness * cur_sd_brightness) / 255;
773
774         /* Apply any backlight response curve */
775         if (brightness > 255)
776                 pr_info("Error: Brightness > 255!\n");
777         else
778                 brightness = bl_output[brightness];
779
780         return brightness;
781 }
782
783 static int dalmore_disp1_check_fb(struct device *dev, struct fb_info *info)
784 {
785         return info->device == &dalmore_disp1_device.dev;
786 }
787
788 static struct platform_tegra_pwm_backlight_data dalmore_disp1_bl_data = {
789         .which_dc               = 0,
790         .which_pwm              = TEGRA_PWM_PM1,
791         .gpio_conf_to_sfio      = TEGRA_GPIO_PH1,
792         .max_brightness         = 255,
793         .dft_brightness         = 224,
794         .notify                 = dalmore_disp1_bl_notify,
795         .period                 = 0x3F,
796         .clk_div                = 0x3FF,
797         .clk_select             = 0,
798         /* Only toggle backlight on fb blank notifications for disp1 */
799         .check_fb               = dalmore_disp1_check_fb,
800 };
801
802 static struct platform_device __maybe_unused
803                 dalmore_disp1_bl_device __initdata = {
804         .name   = "tegra-pwm-bl",
805         .id     = -1,
806         .dev    = {
807                 .platform_data = &dalmore_disp1_bl_data,
808         },
809 };
810
811 #if PANEL_11_6_AUO_1920_1080
812 static struct i2c_board_info dalmore_tc358770_dsi2edp_board_info __initdata = {
813                 I2C_BOARD_INFO("tc358770_dsi2edp", 0x68),
814 };
815 #endif
816
817 int __init dalmore_panel_init(void)
818 {
819         int err = 0;
820         struct resource __maybe_unused *res;
821
822 #ifdef CONFIG_TEGRA_NVMAP
823         dalmore_carveouts[1].base = tegra_carveout_start;
824         dalmore_carveouts[1].size = tegra_carveout_size;
825         dalmore_carveouts[2].base = tegra_vpr_start;
826         dalmore_carveouts[2].size = tegra_vpr_size;
827
828         err = platform_device_register(&dalmore_nvmap_device);
829         if (err) {
830                 pr_err("nvmap device registration failed\n");
831                 return err;
832         }
833 #endif
834
835         gpio_request(dalmore_hdmi_hpd, "hdmi_hpd");
836         gpio_direction_input(dalmore_hdmi_hpd);
837
838 #ifdef CONFIG_TEGRA_GRHOST
839 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
840         err = tegra3_register_host1x_devices();
841 #else
842         err = tegra11_register_host1x_devices();
843 #endif
844         if (err) {
845                 pr_err("host1x devices registration failed\n");
846                 return err;
847         }
848
849 #ifdef CONFIG_TEGRA_DC
850         res = nvhost_get_resource_byname(&dalmore_disp1_device,
851                                          IORESOURCE_MEM, "fbmem");
852         res->start = tegra_fb_start;
853         res->end = tegra_fb_start + tegra_fb_size - 1;
854
855         res = nvhost_get_resource_byname(&dalmore_disp2_device,
856                                          IORESOURCE_MEM, "fbmem");
857         res->start = tegra_fb2_start;
858         res->end = tegra_fb2_start + tegra_fb2_size - 1;
859
860         err = nvhost_device_register(&dalmore_disp1_device);
861         if (err) {
862                 pr_err("disp1 device registration failed\n");
863                 return err;
864         }
865
866         err = nvhost_device_register(&dalmore_disp2_device);
867         if (err) {
868                 pr_err("disp2 device registration failed\n");
869                 return err;
870         }
871
872 #if !IS_EXTERNAL_PWM
873         err = platform_device_register(&dalmore_disp1_bl_device);
874         if (err) {
875                 pr_err("disp1 bl device registration failed");
876                 return err;
877         }
878 #endif
879 #if PANEL_11_6_AUO_1920_1080
880         i2c_register_board_info(0, &dalmore_tc358770_dsi2edp_board_info, 1);
881 #endif
882 #endif
883
884 #ifdef CONFIG_TEGRA_NVAVP
885         err = nvhost_device_register(&nvavp_device);
886         if (err) {
887                 pr_err("nvavp device registration failed\n");
888                 return err;
889         }
890 #endif
891 #endif
892         return err;
893 }
894 #else
895 int __init dalmore_panel_init(void)
896 {
897         return -ENODEV;
898 }
899 #endif