d6b6f5df0dc1e0463a290ba408ae0a1b2bde91f5
[linux-3.10.git] / drivers / video / tegra / dc / dc.c
1 /*
2  * drivers/video/tegra/dc/dc.c
3  *
4  * Copyright (C) 2010 Google, Inc.
5  * Author: Erik Gilling <konkers@android.com>
6  *
7  * Copyright (c) 2010-2013, NVIDIA CORPORATION, All rights reserved.
8  *
9  * This software is licensed under the terms of the GNU General Public
10  * License version 2, as published by the Free Software Foundation, and
11  * may be copied, distributed, and modified under those terms.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  */
19
20 #include <linux/module.h>
21 #include <linux/kernel.h>
22 #include <linux/err.h>
23 #include <linux/errno.h>
24 #include <linux/interrupt.h>
25 #include <linux/slab.h>
26 #include <linux/io.h>
27 #include <linux/pm.h>
28 #include <linux/pm_runtime.h>
29 #include <linux/clk.h>
30 #include <linux/mutex.h>
31 #include <linux/delay.h>
32 #include <linux/dma-mapping.h>
33 #include <linux/workqueue.h>
34 #include <linux/ktime.h>
35 #include <linux/debugfs.h>
36 #include <linux/seq_file.h>
37 #include <linux/backlight.h>
38 #include <linux/gpio.h>
39 #include <linux/nvhost.h>
40 #include <video/tegrafb.h>
41 #include <drm/drm_fixed.h>
42 #ifdef CONFIG_SWITCH
43 #include <linux/switch.h>
44 #endif
45
46 #define CREATE_TRACE_POINTS
47 #include <trace/events/display.h>
48
49 #include <mach/clk.h>
50 #include <mach/dc.h>
51 #include <mach/fb.h>
52 #include <mach/mc.h>
53 #include <linux/nvhost.h>
54 #include <mach/latency_allowance.h>
55 #include <mach/pm_domains.h>
56
57 #include "dc_reg.h"
58 #include "dc_config.h"
59 #include "dc_priv.h"
60 #include "dev.h"
61 #include "nvsd.h"
62
63 /* HACK! This needs to come from DT */
64 #include "../../../../arch/arm/mach-tegra/iomap.h"
65
66 #define TEGRA_CRC_LATCHED_DELAY         34
67
68 #define DC_COM_PIN_OUTPUT_POLARITY1_INIT_VAL    0x01000000
69 #define DC_COM_PIN_OUTPUT_POLARITY3_INIT_VAL    0x0
70
71 static struct fb_videomode tegra_dc_hdmi_fallback_mode = {
72         .refresh = 60,
73         .xres = 640,
74         .yres = 480,
75         .pixclock = KHZ2PICOS(25200),
76         .hsync_len = 96,        /* h_sync_width */
77         .vsync_len = 2,         /* v_sync_width */
78         .left_margin = 48,      /* h_back_porch */
79         .upper_margin = 33,     /* v_back_porch */
80         .right_margin = 16,     /* h_front_porch */
81         .lower_margin = 10,     /* v_front_porch */
82         .vmode = 0,
83         .sync = 0,
84 };
85
86 static struct tegra_dc_mode override_disp_mode[3];
87
88 static void _tegra_dc_controller_disable(struct tegra_dc *dc);
89
90 struct tegra_dc *tegra_dcs[TEGRA_MAX_DC];
91
92 DEFINE_MUTEX(tegra_dc_lock);
93 DEFINE_MUTEX(shared_lock);
94
95 static const struct {
96         bool h;
97         bool v;
98 } can_filter[] = {
99         /* Window A has no filtering */
100         { false, false },
101         /* Window B has both H and V filtering */
102         { true,  true  },
103         /* Window C has only H filtering */
104         { false, true  },
105 };
106
107 #ifdef CONFIG_TEGRA_DC_CMU
108 static struct tegra_dc_cmu default_cmu = {
109         /* lut1 maps sRGB to linear space. */
110         {
111                 0,    1,    2,    4,    5,    6,    7,    9,
112                 10,   11,   12,   14,   15,   16,   18,   20,
113                 21,   23,   25,   27,   29,   31,   33,   35,
114                 37,   40,   42,   45,   48,   50,   53,   56,
115                 59,   62,   66,   69,   72,   76,   79,   83,
116                 87,   91,   95,   99,   103,  107,  112,  116,
117                 121,  126,  131,  136,  141,  146,  151,  156,
118                 162,  168,  173,  179,  185,  191,  197,  204,
119                 210,  216,  223,  230,  237,  244,  251,  258,
120                 265,  273,  280,  288,  296,  304,  312,  320,
121                 329,  337,  346,  354,  363,  372,  381,  390,
122                 400,  409,  419,  428,  438,  448,  458,  469,
123                 479,  490,  500,  511,  522,  533,  544,  555,
124                 567,  578,  590,  602,  614,  626,  639,  651,
125                 664,  676,  689,  702,  715,  728,  742,  755,
126                 769,  783,  797,  811,  825,  840,  854,  869,
127                 884,  899,  914,  929,  945,  960,  976,  992,
128                 1008, 1024, 1041, 1057, 1074, 1091, 1108, 1125,
129                 1142, 1159, 1177, 1195, 1213, 1231, 1249, 1267,
130                 1286, 1304, 1323, 1342, 1361, 1381, 1400, 1420,
131                 1440, 1459, 1480, 1500, 1520, 1541, 1562, 1582,
132                 1603, 1625, 1646, 1668, 1689, 1711, 1733, 1755,
133                 1778, 1800, 1823, 1846, 1869, 1892, 1916, 1939,
134                 1963, 1987, 2011, 2035, 2059, 2084, 2109, 2133,
135                 2159, 2184, 2209, 2235, 2260, 2286, 2312, 2339,
136                 2365, 2392, 2419, 2446, 2473, 2500, 2527, 2555,
137                 2583, 2611, 2639, 2668, 2696, 2725, 2754, 2783,
138                 2812, 2841, 2871, 2901, 2931, 2961, 2991, 3022,
139                 3052, 3083, 3114, 3146, 3177, 3209, 3240, 3272,
140                 3304, 3337, 3369, 3402, 3435, 3468, 3501, 3535,
141                 3568, 3602, 3636, 3670, 3705, 3739, 3774, 3809,
142                 3844, 3879, 3915, 3950, 3986, 4022, 4059, 4095,
143         },
144         /* csc */
145         {
146                 0x100, 0x0,   0x0,
147                 0x0,   0x100, 0x0,
148                 0x0,   0x0,   0x100,
149         },
150         /* lut2 maps linear space to sRGB*/
151         {
152                 0,    1,    2,    2,    3,    4,    5,    6,
153                 6,    7,    8,    9,    10,   10,   11,   12,
154                 13,   13,   14,   15,   15,   16,   16,   17,
155                 18,   18,   19,   19,   20,   20,   21,   21,
156                 22,   22,   23,   23,   23,   24,   24,   25,
157                 25,   25,   26,   26,   27,   27,   27,   28,
158                 28,   29,   29,   29,   30,   30,   30,   31,
159                 31,   31,   32,   32,   32,   33,   33,   33,
160                 34,   34,   34,   34,   35,   35,   35,   36,
161                 36,   36,   37,   37,   37,   37,   38,   38,
162                 38,   38,   39,   39,   39,   40,   40,   40,
163                 40,   41,   41,   41,   41,   42,   42,   42,
164                 42,   43,   43,   43,   43,   43,   44,   44,
165                 44,   44,   45,   45,   45,   45,   46,   46,
166                 46,   46,   46,   47,   47,   47,   47,   48,
167                 48,   48,   48,   48,   49,   49,   49,   49,
168                 49,   50,   50,   50,   50,   50,   51,   51,
169                 51,   51,   51,   52,   52,   52,   52,   52,
170                 53,   53,   53,   53,   53,   54,   54,   54,
171                 54,   54,   55,   55,   55,   55,   55,   55,
172                 56,   56,   56,   56,   56,   57,   57,   57,
173                 57,   57,   57,   58,   58,   58,   58,   58,
174                 58,   59,   59,   59,   59,   59,   59,   60,
175                 60,   60,   60,   60,   60,   61,   61,   61,
176                 61,   61,   61,   62,   62,   62,   62,   62,
177                 62,   63,   63,   63,   63,   63,   63,   64,
178                 64,   64,   64,   64,   64,   64,   65,   65,
179                 65,   65,   65,   65,   66,   66,   66,   66,
180                 66,   66,   66,   67,   67,   67,   67,   67,
181                 67,   67,   68,   68,   68,   68,   68,   68,
182                 68,   69,   69,   69,   69,   69,   69,   69,
183                 70,   70,   70,   70,   70,   70,   70,   71,
184                 71,   71,   71,   71,   71,   71,   72,   72,
185                 72,   72,   72,   72,   72,   72,   73,   73,
186                 73,   73,   73,   73,   73,   74,   74,   74,
187                 74,   74,   74,   74,   74,   75,   75,   75,
188                 75,   75,   75,   75,   75,   76,   76,   76,
189                 76,   76,   76,   76,   77,   77,   77,   77,
190                 77,   77,   77,   77,   78,   78,   78,   78,
191                 78,   78,   78,   78,   78,   79,   79,   79,
192                 79,   79,   79,   79,   79,   80,   80,   80,
193                 80,   80,   80,   80,   80,   81,   81,   81,
194                 81,   81,   81,   81,   81,   81,   82,   82,
195                 82,   82,   82,   82,   82,   82,   83,   83,
196                 83,   83,   83,   83,   83,   83,   83,   84,
197                 84,   84,   84,   84,   84,   84,   84,   84,
198                 85,   85,   85,   85,   85,   85,   85,   85,
199                 85,   86,   86,   86,   86,   86,   86,   86,
200                 86,   86,   87,   87,   87,   87,   87,   87,
201                 87,   87,   87,   88,   88,   88,   88,   88,
202                 88,   88,   88,   88,   88,   89,   89,   89,
203                 89,   89,   89,   89,   89,   89,   90,   90,
204                 90,   90,   90,   90,   90,   90,   90,   90,
205                 91,   91,   91,   91,   91,   91,   91,   91,
206                 91,   91,   92,   92,   92,   92,   92,   92,
207                 92,   92,   92,   92,   93,   93,   93,   93,
208                 93,   93,   93,   93,   93,   93,   94,   94,
209                 94,   94,   94,   94,   94,   94,   94,   94,
210                 95,   95,   95,   95,   95,   95,   95,   95,
211                 95,   95,   96,   96,   96,   96,   96,   96,
212                 96,   96,   96,   96,   96,   97,   97,   97,
213                 97,   97,   97,   97,   97,   97,   97,   98,
214                 98,   98,   98,   98,   98,   98,   98,   98,
215                 98,   98,   99,   99,   99,   99,   99,   99,
216                 99,   100,  101,  101,  102,  103,  103,  104,
217                 105,  105,  106,  107,  107,  108,  109,  109,
218                 110,  111,  111,  112,  113,  113,  114,  115,
219                 115,  116,  116,  117,  118,  118,  119,  119,
220                 120,  120,  121,  122,  122,  123,  123,  124,
221                 124,  125,  126,  126,  127,  127,  128,  128,
222                 129,  129,  130,  130,  131,  131,  132,  132,
223                 133,  133,  134,  134,  135,  135,  136,  136,
224                 137,  137,  138,  138,  139,  139,  140,  140,
225                 141,  141,  142,  142,  143,  143,  144,  144,
226                 145,  145,  145,  146,  146,  147,  147,  148,
227                 148,  149,  149,  150,  150,  150,  151,  151,
228                 152,  152,  153,  153,  153,  154,  154,  155,
229                 155,  156,  156,  156,  157,  157,  158,  158,
230                 158,  159,  159,  160,  160,  160,  161,  161,
231                 162,  162,  162,  163,  163,  164,  164,  164,
232                 165,  165,  166,  166,  166,  167,  167,  167,
233                 168,  168,  169,  169,  169,  170,  170,  170,
234                 171,  171,  172,  172,  172,  173,  173,  173,
235                 174,  174,  174,  175,  175,  176,  176,  176,
236                 177,  177,  177,  178,  178,  178,  179,  179,
237                 179,  180,  180,  180,  181,  181,  182,  182,
238                 182,  183,  183,  183,  184,  184,  184,  185,
239                 185,  185,  186,  186,  186,  187,  187,  187,
240                 188,  188,  188,  189,  189,  189,  189,  190,
241                 190,  190,  191,  191,  191,  192,  192,  192,
242                 193,  193,  193,  194,  194,  194,  195,  195,
243                 195,  196,  196,  196,  196,  197,  197,  197,
244                 198,  198,  198,  199,  199,  199,  200,  200,
245                 200,  200,  201,  201,  201,  202,  202,  202,
246                 202,  203,  203,  203,  204,  204,  204,  205,
247                 205,  205,  205,  206,  206,  206,  207,  207,
248                 207,  207,  208,  208,  208,  209,  209,  209,
249                 209,  210,  210,  210,  211,  211,  211,  211,
250                 212,  212,  212,  213,  213,  213,  213,  214,
251                 214,  214,  214,  215,  215,  215,  216,  216,
252                 216,  216,  217,  217,  217,  217,  218,  218,
253                 218,  219,  219,  219,  219,  220,  220,  220,
254                 220,  221,  221,  221,  221,  222,  222,  222,
255                 223,  223,  223,  223,  224,  224,  224,  224,
256                 225,  225,  225,  225,  226,  226,  226,  226,
257                 227,  227,  227,  227,  228,  228,  228,  228,
258                 229,  229,  229,  229,  230,  230,  230,  230,
259                 231,  231,  231,  231,  232,  232,  232,  232,
260                 233,  233,  233,  233,  234,  234,  234,  234,
261                 235,  235,  235,  235,  236,  236,  236,  236,
262                 237,  237,  237,  237,  238,  238,  238,  238,
263                 239,  239,  239,  239,  240,  240,  240,  240,
264                 240,  241,  241,  241,  241,  242,  242,  242,
265                 242,  243,  243,  243,  243,  244,  244,  244,
266                 244,  244,  245,  245,  245,  245,  246,  246,
267                 246,  246,  247,  247,  247,  247,  247,  248,
268                 248,  248,  248,  249,  249,  249,  249,  249,
269                 250,  250,  250,  250,  251,  251,  251,  251,
270                 251,  252,  252,  252,  252,  253,  253,  253,
271                 253,  253,  254,  254,  254,  254,  255,  255,
272         },
273 };
274
275 static struct tegra_dc_cmu default_limited_cmu = {
276         /* lut1 maps sRGB to linear space. */
277         {
278                 0,    1,    2,    4,    5,    6,    7,    9,
279                 10,   11,   12,   14,   15,   16,   18,   20,
280                 21,   23,   25,   27,   29,   31,   33,   35,
281                 37,   40,   42,   45,   48,   50,   53,   56,
282                 59,   62,   66,   69,   72,   76,   79,   83,
283                 87,   91,   95,   99,   103,  107,  112,  116,
284                 121,  126,  131,  136,  141,  146,  151,  156,
285                 162,  168,  173,  179,  185,  191,  197,  204,
286                 210,  216,  223,  230,  237,  244,  251,  258,
287                 265,  273,  280,  288,  296,  304,  312,  320,
288                 329,  337,  346,  354,  363,  372,  381,  390,
289                 400,  409,  419,  428,  438,  448,  458,  469,
290                 479,  490,  500,  511,  522,  533,  544,  555,
291                 567,  578,  590,  602,  614,  626,  639,  651,
292                 664,  676,  689,  702,  715,  728,  742,  755,
293                 769,  783,  797,  811,  825,  840,  854,  869,
294                 884,  899,  914,  929,  945,  960,  976,  992,
295                 1008, 1024, 1041, 1057, 1074, 1091, 1108, 1125,
296                 1142, 1159, 1177, 1195, 1213, 1231, 1249, 1267,
297                 1286, 1304, 1323, 1342, 1361, 1381, 1400, 1420,
298                 1440, 1459, 1480, 1500, 1520, 1541, 1562, 1582,
299                 1603, 1625, 1646, 1668, 1689, 1711, 1733, 1755,
300                 1778, 1800, 1823, 1846, 1869, 1892, 1916, 1939,
301                 1963, 1987, 2011, 2035, 2059, 2084, 2109, 2133,
302                 2159, 2184, 2209, 2235, 2260, 2286, 2312, 2339,
303                 2365, 2392, 2419, 2446, 2473, 2500, 2527, 2555,
304                 2583, 2611, 2639, 2668, 2696, 2725, 2754, 2783,
305                 2812, 2841, 2871, 2901, 2931, 2961, 2991, 3022,
306                 3052, 3083, 3114, 3146, 3177, 3209, 3240, 3272,
307                 3304, 3337, 3369, 3402, 3435, 3468, 3501, 3535,
308                 3568, 3602, 3636, 3670, 3705, 3739, 3774, 3809,
309                 3844, 3879, 3915, 3950, 3986, 4022, 4059, 4095,
310         },
311         /* csc */
312         {
313                 0x100, 0x000, 0x000,
314                 0x000, 0x100, 0x000,
315                 0x000, 0x000, 0x100,
316         },
317         /*
318          * lut2 maps linear space back to sRGB, where
319          * the output range is [16...235] (limited).
320          */
321         {
322                 16,  17,  17,  18,  19,  19,  20,  21,
323                 22,  22,  23,  24,  24,  25,  26,  26,
324                 27,  27,  28,  29,  29,  30,  30,  31,
325                 31,  32,  32,  32,  33,  33,  34,  34,
326                 35,  35,  35,  36,  36,  36,  37,  37,
327                 38,  38,  38,  39,  39,  39,  40,  40,
328                 40,  41,  41,  41,  41,  42,  42,  42,
329                 43,  43,  43,  43,  44,  44,  44,  45,
330                 45,  45,  45,  46,  46,  46,  46,  47,
331                 47,  47,  47,  48,  48,  48,  48,  49,
332                 49,  49,  49,  49,  50,  50,  50,  50,
333                 51,  51,  51,  51,  51,  52,  52,  52,
334                 52,  53,  53,  53,  53,  53,  54,  54,
335                 54,  54,  54,  55,  55,  55,  55,  55,
336                 56,  56,  56,  56,  56,  56,  57,  57,
337                 57,  57,  57,  58,  58,  58,  58,  58,
338                 58,  59,  59,  59,  59,  59,  60,  60,
339                 60,  60,  60,  60,  61,  61,  61,  61,
340                 61,  61,  62,  62,  62,  62,  62,  62,
341                 63,  63,  63,  63,  63,  63,  63,  64,
342                 64,  64,  64,  64,  64,  65,  65,  65,
343                 65,  65,  65,  65,  66,  66,  66,  66,
344                 66,  66,  67,  67,  67,  67,  67,  67,
345                 67,  68,  68,  68,  68,  68,  68,  68,
346                 69,  69,  69,  69,  69,  69,  69,  69,
347                 70,  70,  70,  70,  70,  70,  70,  71,
348                 71,  71,  71,  71,  71,  71,  72,  72,
349                 72,  72,  72,  72,  72,  72,  73,  73,
350                 73,  73,  73,  73,  73,  73,  74,  74,
351                 74,  74,  74,  74,  74,  74,  75,  75,
352                 75,  75,  75,  75,  75,  75,  76,  76,
353                 76,  76,  76,  76,  76,  76,  76,  77,
354                 77,  77,  77,  77,  77,  77,  77,  78,
355                 78,  78,  78,  78,  78,  78,  78,  78,
356                 79,  79,  79,  79,  79,  79,  79,  79,
357                 80,  80,  80,  80,  80,  80,  80,  80,
358                 80,  81,  81,  81,  81,  81,  81,  81,
359                 81,  81,  81,  82,  82,  82,  82,  82,
360                 82,  82,  82,  82,  83,  83,  83,  83,
361                 83,  83,  83,  83,  83,  84,  84,  84,
362                 84,  84,  84,  84,  84,  84,  84,  85,
363                 85,  85,  85,  85,  85,  85,  85,  85,
364                 85,  86,  86,  86,  86,  86,  86,  86,
365                 86,  86,  86,  87,  87,  87,  87,  87,
366                 87,  87,  87,  87,  87,  88,  88,  88,
367                 88,  88,  88,  88,  88,  88,  88,  89,
368                 89,  89,  89,  89,  89,  89,  89,  89,
369                 89,  89,  90,  90,  90,  90,  90,  90,
370                 90,  90,  90,  90,  91,  91,  91,  91,
371                 91,  91,  91,  91,  91,  91,  91,  92,
372                 92,  92,  92,  92,  92,  92,  92,  92,
373                 92,  92,  93,  93,  93,  93,  93,  93,
374                 93,  93,  93,  93,  93,  94,  94,  94,
375                 94,  94,  94,  94,  94,  94,  94,  94,
376                 94,  95,  95,  95,  95,  95,  95,  95,
377                 95,  95,  95,  95,  96,  96,  96,  96,
378                 96,  96,  96,  96,  96,  96,  96,  96,
379                 97,  97,  97,  97,  97,  97,  97,  97,
380                 97,  97,  97,  97,  98,  98,  98,  98,
381                 98,  98,  98,  98,  98,  98,  98,  98,
382                 99,  99,  99,  99,  99,  99,  99,  99,
383                 99,  99,  99,  99, 100, 100, 100, 100,
384                 100, 100, 100, 100, 100, 100, 100, 100,
385                 100, 101, 101, 101, 101, 101, 101, 101,
386                 102, 102, 103, 104, 104, 105, 105, 106,
387                 107, 107, 108, 108, 109, 109, 110, 111,
388                 111, 112, 112, 113, 113, 114, 114, 115,
389                 115, 116, 116, 117, 117, 118, 118, 119,
390                 119, 120, 120, 121, 121, 122, 122, 123,
391                 123, 124, 124, 125, 125, 126, 126, 127,
392                 127, 127, 128, 128, 129, 129, 130, 130,
393                 131, 131, 131, 132, 132, 133, 133, 134,
394                 134, 134, 135, 135, 136, 136, 136, 137,
395                 137, 138, 138, 139, 139, 139, 140, 140,
396                 141, 141, 141, 142, 142, 142, 143, 143,
397                 144, 144, 144, 145, 145, 145, 146, 146,
398                 147, 147, 147, 148, 148, 148, 149, 149,
399                 150, 150, 150, 151, 151, 151, 152, 152,
400                 152, 153, 153, 153, 154, 154, 154, 155,
401                 155, 155, 156, 156, 156, 157, 157, 157,
402                 158, 158, 158, 159, 159, 159, 160, 160,
403                 160, 161, 161, 161, 162, 162, 162, 163,
404                 163, 163, 164, 164, 164, 165, 165, 165,
405                 166, 166, 166, 166, 167, 167, 167, 168,
406                 168, 168, 169, 169, 169, 169, 170, 170,
407                 170, 171, 171, 171, 172, 172, 172, 172,
408                 173, 173, 173, 174, 174, 174, 174, 175,
409                 175, 175, 176, 176, 176, 176, 177, 177,
410                 177, 178, 178, 178, 178, 179, 179, 179,
411                 180, 180, 180, 180, 181, 181, 181, 181,
412                 182, 182, 182, 183, 183, 183, 183, 184,
413                 184, 184, 184, 185, 185, 185, 185, 186,
414                 186, 186, 187, 187, 187, 187, 188, 188,
415                 188, 188, 189, 189, 189, 189, 190, 190,
416                 190, 190, 191, 191, 191, 191, 192, 192,
417                 192, 192, 193, 193, 193, 193, 194, 194,
418                 194, 194, 195, 195, 195, 195, 196, 196,
419                 196, 196, 197, 197, 197, 197, 198, 198,
420                 198, 198, 199, 199, 199, 199, 199, 200,
421                 200, 200, 200, 201, 201, 201, 201, 202,
422                 202, 202, 202, 203, 203, 203, 203, 203,
423                 204, 204, 204, 204, 205, 205, 205, 205,
424                 206, 206, 206, 206, 206, 207, 207, 207,
425                 207, 208, 208, 208, 208, 208, 209, 209,
426                 209, 209, 210, 210, 210, 210, 210, 211,
427                 211, 211, 211, 212, 212, 212, 212, 212,
428                 213, 213, 213, 213, 213, 214, 214, 214,
429                 214, 215, 215, 215, 215, 215, 216, 216,
430                 216, 216, 216, 217, 217, 217, 217, 218,
431                 218, 218, 218, 218, 219, 219, 219, 219,
432                 219, 220, 220, 220, 220, 220, 221, 221,
433                 221, 221, 221, 222, 222, 222, 222, 222,
434                 223, 223, 223, 223, 224, 224, 224, 224,
435                 224, 225, 225, 225, 225, 225, 226, 226,
436                 226, 226, 226, 227, 227, 227, 227, 227,
437                 227, 228, 228, 228, 228, 228, 229, 229,
438                 229, 229, 229, 230, 230, 230, 230, 230,
439                 231, 231, 231, 231, 231, 232, 232, 232,
440                 232, 232, 233, 233, 233, 233, 233, 233,
441                 234, 234, 234, 234, 234, 235, 235, 235,
442         },
443 };
444 #endif
445
446 void tegra_dc_clk_enable(struct tegra_dc *dc)
447 {
448         if (!tegra_is_clk_enabled(dc->clk)) {
449                 clk_prepare_enable(dc->clk);
450                 tegra_dvfs_set_rate(dc->clk, dc->mode.pclk);
451         }
452 }
453
454 void tegra_dc_clk_disable(struct tegra_dc *dc)
455 {
456         if (tegra_is_clk_enabled(dc->clk)) {
457                 clk_disable_unprepare(dc->clk);
458                 tegra_dvfs_set_rate(dc->clk, 0);
459         }
460 }
461
462 void tegra_dc_get(struct tegra_dc *dc)
463 {
464         tegra_dc_io_start(dc);
465
466         /* extra reference to dc clk */
467         clk_prepare_enable(dc->clk);
468 }
469
470 void tegra_dc_put(struct tegra_dc *dc)
471 {
472         /* balance extra dc clk reference */
473         clk_disable_unprepare(dc->clk);
474
475         tegra_dc_io_end(dc);
476 }
477
478 void tegra_dc_hold_dc_out(struct tegra_dc *dc)
479 {
480         tegra_dc_get(dc);
481         if (dc->out_ops->hold)
482                 dc->out_ops->hold(dc);
483 }
484
485 void tegra_dc_release_dc_out(struct tegra_dc *dc)
486 {
487         if (dc->out_ops->release)
488                 dc->out_ops->release(dc);
489         tegra_dc_put(dc);
490 }
491
492 #define DUMP_REG(a) do {                        \
493         snprintf(buff, sizeof(buff), "%-32s\t%03x\t%08lx\n",  \
494                  #a, a, tegra_dc_readl(dc, a));               \
495         print(data, buff);                                    \
496         } while (0)
497
498 static void _dump_regs(struct tegra_dc *dc, void *data,
499                        void (* print)(void *data, const char *str))
500 {
501         int i;
502         char buff[256];
503
504         mutex_lock(&dc->lock);
505         tegra_dc_get(dc);
506
507         DUMP_REG(DC_CMD_DISPLAY_COMMAND_OPTION0);
508         DUMP_REG(DC_CMD_DISPLAY_COMMAND);
509         DUMP_REG(DC_CMD_SIGNAL_RAISE);
510         DUMP_REG(DC_CMD_INT_STATUS);
511         DUMP_REG(DC_CMD_INT_MASK);
512         DUMP_REG(DC_CMD_INT_ENABLE);
513         DUMP_REG(DC_CMD_INT_TYPE);
514         DUMP_REG(DC_CMD_INT_POLARITY);
515         DUMP_REG(DC_CMD_SIGNAL_RAISE1);
516         DUMP_REG(DC_CMD_SIGNAL_RAISE2);
517         DUMP_REG(DC_CMD_SIGNAL_RAISE3);
518         DUMP_REG(DC_CMD_STATE_ACCESS);
519         DUMP_REG(DC_CMD_STATE_CONTROL);
520         DUMP_REG(DC_CMD_DISPLAY_WINDOW_HEADER);
521         DUMP_REG(DC_CMD_REG_ACT_CONTROL);
522
523         DUMP_REG(DC_DISP_DISP_SIGNAL_OPTIONS0);
524         DUMP_REG(DC_DISP_DISP_SIGNAL_OPTIONS1);
525         DUMP_REG(DC_DISP_DISP_WIN_OPTIONS);
526         DUMP_REG(DC_DISP_MEM_HIGH_PRIORITY);
527         DUMP_REG(DC_DISP_MEM_HIGH_PRIORITY_TIMER);
528         DUMP_REG(DC_DISP_DISP_TIMING_OPTIONS);
529         DUMP_REG(DC_DISP_REF_TO_SYNC);
530         DUMP_REG(DC_DISP_SYNC_WIDTH);
531         DUMP_REG(DC_DISP_BACK_PORCH);
532         DUMP_REG(DC_DISP_DISP_ACTIVE);
533         DUMP_REG(DC_DISP_FRONT_PORCH);
534         DUMP_REG(DC_DISP_H_PULSE0_CONTROL);
535         DUMP_REG(DC_DISP_H_PULSE0_POSITION_A);
536         DUMP_REG(DC_DISP_H_PULSE0_POSITION_B);
537         DUMP_REG(DC_DISP_H_PULSE0_POSITION_C);
538         DUMP_REG(DC_DISP_H_PULSE0_POSITION_D);
539         DUMP_REG(DC_DISP_H_PULSE1_CONTROL);
540         DUMP_REG(DC_DISP_H_PULSE1_POSITION_A);
541         DUMP_REG(DC_DISP_H_PULSE1_POSITION_B);
542         DUMP_REG(DC_DISP_H_PULSE1_POSITION_C);
543         DUMP_REG(DC_DISP_H_PULSE1_POSITION_D);
544         DUMP_REG(DC_DISP_H_PULSE2_CONTROL);
545         DUMP_REG(DC_DISP_H_PULSE2_POSITION_A);
546         DUMP_REG(DC_DISP_H_PULSE2_POSITION_B);
547         DUMP_REG(DC_DISP_H_PULSE2_POSITION_C);
548         DUMP_REG(DC_DISP_H_PULSE2_POSITION_D);
549         DUMP_REG(DC_DISP_V_PULSE0_CONTROL);
550         DUMP_REG(DC_DISP_V_PULSE0_POSITION_A);
551         DUMP_REG(DC_DISP_V_PULSE0_POSITION_B);
552         DUMP_REG(DC_DISP_V_PULSE0_POSITION_C);
553         DUMP_REG(DC_DISP_V_PULSE1_CONTROL);
554         DUMP_REG(DC_DISP_V_PULSE1_POSITION_A);
555         DUMP_REG(DC_DISP_V_PULSE1_POSITION_B);
556         DUMP_REG(DC_DISP_V_PULSE1_POSITION_C);
557         DUMP_REG(DC_DISP_V_PULSE2_CONTROL);
558         DUMP_REG(DC_DISP_V_PULSE2_POSITION_A);
559         DUMP_REG(DC_DISP_V_PULSE3_CONTROL);
560         DUMP_REG(DC_DISP_V_PULSE3_POSITION_A);
561         DUMP_REG(DC_DISP_M0_CONTROL);
562         DUMP_REG(DC_DISP_M1_CONTROL);
563         DUMP_REG(DC_DISP_DI_CONTROL);
564         DUMP_REG(DC_DISP_PP_CONTROL);
565         DUMP_REG(DC_DISP_PP_SELECT_A);
566         DUMP_REG(DC_DISP_PP_SELECT_B);
567         DUMP_REG(DC_DISP_PP_SELECT_C);
568         DUMP_REG(DC_DISP_PP_SELECT_D);
569         DUMP_REG(DC_DISP_DISP_CLOCK_CONTROL);
570         DUMP_REG(DC_DISP_DISP_INTERFACE_CONTROL);
571         DUMP_REG(DC_DISP_DISP_COLOR_CONTROL);
572         DUMP_REG(DC_DISP_SHIFT_CLOCK_OPTIONS);
573         DUMP_REG(DC_DISP_DATA_ENABLE_OPTIONS);
574         DUMP_REG(DC_DISP_SERIAL_INTERFACE_OPTIONS);
575         DUMP_REG(DC_DISP_LCD_SPI_OPTIONS);
576         DUMP_REG(DC_DISP_BORDER_COLOR);
577         DUMP_REG(DC_DISP_COLOR_KEY0_LOWER);
578         DUMP_REG(DC_DISP_COLOR_KEY0_UPPER);
579         DUMP_REG(DC_DISP_COLOR_KEY1_LOWER);
580         DUMP_REG(DC_DISP_COLOR_KEY1_UPPER);
581         DUMP_REG(DC_DISP_CURSOR_FOREGROUND);
582         DUMP_REG(DC_DISP_CURSOR_BACKGROUND);
583         DUMP_REG(DC_DISP_CURSOR_START_ADDR);
584         DUMP_REG(DC_DISP_CURSOR_START_ADDR_NS);
585         DUMP_REG(DC_DISP_CURSOR_POSITION);
586         DUMP_REG(DC_DISP_CURSOR_POSITION_NS);
587         DUMP_REG(DC_DISP_INIT_SEQ_CONTROL);
588         DUMP_REG(DC_DISP_SPI_INIT_SEQ_DATA_A);
589         DUMP_REG(DC_DISP_SPI_INIT_SEQ_DATA_B);
590         DUMP_REG(DC_DISP_SPI_INIT_SEQ_DATA_C);
591         DUMP_REG(DC_DISP_SPI_INIT_SEQ_DATA_D);
592         DUMP_REG(DC_DISP_DC_MCCIF_FIFOCTRL);
593         DUMP_REG(DC_DISP_MCCIF_DISPLAY0A_HYST);
594         DUMP_REG(DC_DISP_MCCIF_DISPLAY0B_HYST);
595         DUMP_REG(DC_DISP_MCCIF_DISPLAY0C_HYST);
596 #if defined(CONFIG_ARCH_TEGRA_2x_SOC) || defined(CONFIG_ARCH_TEGRA_3x_SOC)
597         DUMP_REG(DC_DISP_MCCIF_DISPLAY1B_HYST);
598 #endif
599         DUMP_REG(DC_DISP_DAC_CRT_CTRL);
600         DUMP_REG(DC_DISP_DISP_MISC_CONTROL);
601
602
603         for (i = 0; i < 3; i++) {
604                 print(data, "\n");
605                 snprintf(buff, sizeof(buff), "WINDOW %c:\n", 'A' + i);
606                 print(data, buff);
607
608                 tegra_dc_writel(dc, WINDOW_A_SELECT << i,
609                                 DC_CMD_DISPLAY_WINDOW_HEADER);
610                 DUMP_REG(DC_CMD_DISPLAY_WINDOW_HEADER);
611                 DUMP_REG(DC_WIN_WIN_OPTIONS);
612                 DUMP_REG(DC_WIN_BYTE_SWAP);
613                 DUMP_REG(DC_WIN_BUFFER_CONTROL);
614                 DUMP_REG(DC_WIN_COLOR_DEPTH);
615                 DUMP_REG(DC_WIN_POSITION);
616                 DUMP_REG(DC_WIN_SIZE);
617                 DUMP_REG(DC_WIN_PRESCALED_SIZE);
618                 DUMP_REG(DC_WIN_H_INITIAL_DDA);
619                 DUMP_REG(DC_WIN_V_INITIAL_DDA);
620                 DUMP_REG(DC_WIN_DDA_INCREMENT);
621                 DUMP_REG(DC_WIN_LINE_STRIDE);
622 #if defined(CONFIG_ARCH_TEGRA_2x_SOC) || defined(CONFIG_ARCH_TEGRA_3x_SOC)
623                 DUMP_REG(DC_WIN_BUF_STRIDE);
624                 DUMP_REG(DC_WIN_UV_BUF_STRIDE);
625 #endif
626                 DUMP_REG(DC_WIN_BLEND_NOKEY);
627                 DUMP_REG(DC_WIN_BLEND_1WIN);
628                 DUMP_REG(DC_WIN_BLEND_2WIN_X);
629                 DUMP_REG(DC_WIN_BLEND_2WIN_Y);
630                 DUMP_REG(DC_WIN_BLEND_3WIN_XY);
631                 DUMP_REG(DC_WINBUF_START_ADDR);
632                 DUMP_REG(DC_WINBUF_START_ADDR_U);
633                 DUMP_REG(DC_WINBUF_START_ADDR_V);
634                 DUMP_REG(DC_WINBUF_ADDR_H_OFFSET);
635                 DUMP_REG(DC_WINBUF_ADDR_V_OFFSET);
636                 DUMP_REG(DC_WINBUF_UFLOW_STATUS);
637                 DUMP_REG(DC_WIN_CSC_YOF);
638                 DUMP_REG(DC_WIN_CSC_KYRGB);
639                 DUMP_REG(DC_WIN_CSC_KUR);
640                 DUMP_REG(DC_WIN_CSC_KVR);
641                 DUMP_REG(DC_WIN_CSC_KUG);
642                 DUMP_REG(DC_WIN_CSC_KVG);
643                 DUMP_REG(DC_WIN_CSC_KUB);
644                 DUMP_REG(DC_WIN_CSC_KVB);
645         }
646
647         DUMP_REG(DC_CMD_DISPLAY_POWER_CONTROL);
648         DUMP_REG(DC_COM_PIN_OUTPUT_ENABLE2);
649         DUMP_REG(DC_COM_PIN_OUTPUT_POLARITY2);
650         DUMP_REG(DC_COM_PIN_OUTPUT_DATA2);
651         DUMP_REG(DC_COM_PIN_INPUT_ENABLE2);
652         DUMP_REG(DC_COM_PIN_OUTPUT_SELECT5);
653         DUMP_REG(DC_DISP_DISP_SIGNAL_OPTIONS0);
654         DUMP_REG(DC_DISP_M1_CONTROL);
655         DUMP_REG(DC_COM_PM1_CONTROL);
656         DUMP_REG(DC_COM_PM1_DUTY_CYCLE);
657         DUMP_REG(DC_DISP_SD_CONTROL);
658 #ifdef CONFIG_TEGRA_DC_CMU
659         DUMP_REG(DC_COM_CMU_CSC_KRR);
660         DUMP_REG(DC_COM_CMU_CSC_KGR);
661         DUMP_REG(DC_COM_CMU_CSC_KBR);
662         DUMP_REG(DC_COM_CMU_CSC_KRG);
663         DUMP_REG(DC_COM_CMU_CSC_KGG);
664         DUMP_REG(DC_COM_CMU_CSC_KBR);
665         DUMP_REG(DC_COM_CMU_CSC_KRB);
666         DUMP_REG(DC_COM_CMU_CSC_KGB);
667         DUMP_REG(DC_COM_CMU_CSC_KBB);
668 #endif
669
670         tegra_dc_put(dc);
671         mutex_unlock(&dc->lock);
672 }
673
674 #undef DUMP_REG
675
676 #ifdef DEBUG
677 static void dump_regs_print(void *data, const char *str)
678 {
679         struct tegra_dc *dc = data;
680         dev_dbg(&dc->ndev->dev, "%s", str);
681 }
682
683 static void dump_regs(struct tegra_dc *dc)
684 {
685         _dump_regs(dc, dc, dump_regs_print);
686 }
687 #else /* !DEBUG */
688
689 static void dump_regs(struct tegra_dc *dc) {}
690
691 #endif /* DEBUG */
692
693 #ifdef CONFIG_DEBUG_FS
694
695 static void dbg_regs_print(void *data, const char *str)
696 {
697         struct seq_file *s = data;
698
699         seq_printf(s, "%s", str);
700 }
701
702 #undef DUMP_REG
703
704 static int dbg_dc_show(struct seq_file *s, void *unused)
705 {
706         struct tegra_dc *dc = s->private;
707
708         _dump_regs(dc, s, dbg_regs_print);
709
710         return 0;
711 }
712
713
714 static int dbg_dc_open(struct inode *inode, struct file *file)
715 {
716         return single_open(file, dbg_dc_show, inode->i_private);
717 }
718
719 static const struct file_operations regs_fops = {
720         .open           = dbg_dc_open,
721         .read           = seq_read,
722         .llseek         = seq_lseek,
723         .release        = single_release,
724 };
725
726 static int dbg_dc_mode_show(struct seq_file *s, void *unused)
727 {
728         struct tegra_dc *dc = s->private;
729         struct tegra_dc_mode *m;
730
731         mutex_lock(&dc->lock);
732         m = &dc->mode;
733         seq_printf(s,
734                 "pclk: %d\n"
735                 "h_ref_to_sync: %d\n"
736                 "v_ref_to_sync: %d\n"
737                 "h_sync_width: %d\n"
738                 "v_sync_width: %d\n"
739                 "h_back_porch: %d\n"
740                 "v_back_porch: %d\n"
741                 "h_active: %d\n"
742                 "v_active: %d\n"
743                 "h_front_porch: %d\n"
744                 "v_front_porch: %d\n"
745                 "stereo_mode: %d\n",
746                 m->pclk, m->h_ref_to_sync, m->v_ref_to_sync,
747                 m->h_sync_width, m->v_sync_width,
748                 m->h_back_porch, m->v_back_porch,
749                 m->h_active, m->v_active,
750                 m->h_front_porch, m->v_front_porch,
751                 m->stereo_mode);
752         mutex_unlock(&dc->lock);
753         return 0;
754 }
755
756 static int dbg_dc_mode_open(struct inode *inode, struct file *file)
757 {
758         return single_open(file, dbg_dc_mode_show, inode->i_private);
759 }
760
761 static const struct file_operations mode_fops = {
762         .open           = dbg_dc_mode_open,
763         .read           = seq_read,
764         .llseek         = seq_lseek,
765         .release        = single_release,
766 };
767
768 static int dbg_dc_stats_show(struct seq_file *s, void *unused)
769 {
770         struct tegra_dc *dc = s->private;
771
772         mutex_lock(&dc->lock);
773         seq_printf(s,
774                 "underflows: %llu\n"
775                 "underflows_a: %llu\n"
776                 "underflows_b: %llu\n"
777                 "underflows_c: %llu\n",
778                 dc->stats.underflows,
779                 dc->stats.underflows_a,
780                 dc->stats.underflows_b,
781                 dc->stats.underflows_c);
782 #if defined(CONFIG_ARCH_TEGRA_14x_SOC)
783         seq_printf(s,
784                 "underflows_d: %llu\n"
785                 "underflows_h: %llu\n"
786                 "underflows_t: %llu\n",
787                 dc->stats.underflows_d,
788                 dc->stats.underflows_h,
789                 dc->stats.underflows_t);
790 #endif
791         mutex_unlock(&dc->lock);
792
793         return 0;
794 }
795
796 static int dbg_dc_stats_open(struct inode *inode, struct file *file)
797 {
798         return single_open(file, dbg_dc_stats_show, inode->i_private);
799 }
800
801 static int dbg_dc_event_inject_show(struct seq_file *s, void *unused)
802 {
803         return 0;
804 }
805
806 static int dbg_dc_event_inject_write(struct file *file, const char __user *addr,
807         size_t len, loff_t *pos)
808 {
809         struct seq_file *m = file->private_data; /* single_open() initialized */
810         struct tegra_dc *dc = m ? m->private : NULL;
811         long event;
812         int ret;
813
814         if (!dc)
815                 return -EINVAL;
816
817         ret = kstrtol_from_user(addr, len, 10, &event);
818         if (ret < 0)
819                 return ret;
820
821         if (event == 0x1) /* TEGRA_DC_EXT_EVENT_HOTPLUG */
822                 tegra_dc_ext_process_hotplug(dc->ndev->id);
823         else if (event == 0x2) /* TEGRA_DC_EXT_EVENT_BANDWIDTH */
824                 tegra_dc_ext_process_bandwidth_renegotiate(dc->ndev->id);
825         else {
826                 dev_err(&dc->ndev->dev, "Unknown event 0x%lx\n", event);
827                 return -EINVAL; /* unknown event number */
828         }
829         return len;
830 }
831
832 static const struct file_operations stats_fops = {
833         .open           = dbg_dc_stats_open,
834         .read           = seq_read,
835         .llseek         = seq_lseek,
836         .release        = single_release,
837 };
838
839 static int dbg_dc_event_inject_open(struct inode *inode, struct file *file)
840 {
841         return single_open(file, dbg_dc_event_inject_show, inode->i_private);
842 }
843
844 static const struct file_operations event_inject_fops = {
845         .open           = dbg_dc_event_inject_open,
846         .read           = seq_read,
847         .write          = dbg_dc_event_inject_write,
848         .llseek         = seq_lseek,
849         .release        = single_release,
850 };
851
852 static void tegra_dc_remove_debugfs(struct tegra_dc *dc)
853 {
854         if (dc->debugdir)
855                 debugfs_remove_recursive(dc->debugdir);
856         dc->debugdir = NULL;
857 }
858
859 static void tegra_dc_create_debugfs(struct tegra_dc *dc)
860 {
861         struct dentry *retval;
862
863         dc->debugdir = debugfs_create_dir(dev_name(&dc->ndev->dev), NULL);
864         if (!dc->debugdir)
865                 goto remove_out;
866
867         retval = debugfs_create_file("regs", S_IRUGO, dc->debugdir, dc,
868                 &regs_fops);
869         if (!retval)
870                 goto remove_out;
871
872         retval = debugfs_create_file("mode", S_IRUGO, dc->debugdir, dc,
873                 &mode_fops);
874         if (!retval)
875                 goto remove_out;
876
877         retval = debugfs_create_file("stats", S_IRUGO, dc->debugdir, dc,
878                 &stats_fops);
879         if (!retval)
880                 goto remove_out;
881
882         retval = debugfs_create_file("event_inject", S_IRUGO, dc->debugdir, dc,
883                 &event_inject_fops);
884         if (!retval)
885                 goto remove_out;
886
887         return;
888 remove_out:
889         dev_err(&dc->ndev->dev, "could not create debugfs\n");
890         tegra_dc_remove_debugfs(dc);
891 }
892
893 #else /* !CONFIG_DEBUGFS */
894 static inline void tegra_dc_create_debugfs(struct tegra_dc *dc) { };
895 static inline void tegra_dc_remove_debugfs(struct tegra_dc *dc) { };
896 #endif /* CONFIG_DEBUGFS */
897
898 static int tegra_dc_set(struct tegra_dc *dc, int index)
899 {
900         int ret = 0;
901
902         mutex_lock(&tegra_dc_lock);
903         if (index >= TEGRA_MAX_DC) {
904                 ret = -EINVAL;
905                 goto out;
906         }
907
908         if (dc != NULL && tegra_dcs[index] != NULL) {
909                 ret = -EBUSY;
910                 goto out;
911         }
912
913         tegra_dcs[index] = dc;
914
915 out:
916         mutex_unlock(&tegra_dc_lock);
917
918         return ret;
919 }
920
921 unsigned int tegra_dc_has_multiple_dc(void)
922 {
923         unsigned int idx;
924         unsigned int cnt = 0;
925         struct tegra_dc *dc;
926
927         mutex_lock(&tegra_dc_lock);
928         for (idx = 0; idx < TEGRA_MAX_DC; idx++)
929                 cnt += ((dc = tegra_dcs[idx]) != NULL && dc->enabled) ? 1 : 0;
930         mutex_unlock(&tegra_dc_lock);
931
932         return (cnt > 1);
933 }
934
935 /* get the stride size of a window.
936  * return: stride size in bytes for window win. or 0 if unavailble. */
937 int tegra_dc_get_stride(struct tegra_dc *dc, unsigned win)
938 {
939         u32 stride;
940
941         if (!dc->enabled)
942                 return 0;
943         BUG_ON(win > DC_N_WINDOWS);
944         mutex_lock(&dc->lock);
945         tegra_dc_get(dc);
946         tegra_dc_writel(dc, WINDOW_A_SELECT << win,
947                 DC_CMD_DISPLAY_WINDOW_HEADER);
948         stride = tegra_dc_readl(dc, DC_WIN_LINE_STRIDE);
949         tegra_dc_put(dc);
950         mutex_unlock(&dc->lock);
951         return GET_LINE_STRIDE(stride);
952 }
953 EXPORT_SYMBOL(tegra_dc_get_stride);
954
955 struct tegra_dc *tegra_dc_get_dc(unsigned idx)
956 {
957         if (idx < TEGRA_MAX_DC)
958                 return tegra_dcs[idx];
959         else
960                 return NULL;
961 }
962 EXPORT_SYMBOL(tegra_dc_get_dc);
963
964 struct tegra_dc_win *tegra_dc_get_window(struct tegra_dc *dc, unsigned win)
965 {
966         if (win >= dc->n_windows)
967                 return NULL;
968
969         return &dc->windows[win];
970 }
971 EXPORT_SYMBOL(tegra_dc_get_window);
972
973 bool tegra_dc_get_connected(struct tegra_dc *dc)
974 {
975         return dc->connected;
976 }
977 EXPORT_SYMBOL(tegra_dc_get_connected);
978
979 bool tegra_dc_hpd(struct tegra_dc *dc)
980 {
981         int sense;
982         int level;
983
984         if (WARN_ON(!dc || !dc->out))
985                 return false;
986
987         if (dc->out->hotplug_state != 0) {
988                 if (dc->out->hotplug_state == 1) /* force on */
989                         return true;
990                 if (dc->out->hotplug_state == -1) /* force off */
991                         return false;
992         }
993         level = gpio_get_value_cansleep(dc->out->hotplug_gpio);
994
995         sense = dc->out->flags & TEGRA_DC_OUT_HOTPLUG_MASK;
996
997         return (sense == TEGRA_DC_OUT_HOTPLUG_HIGH && level) ||
998                 (sense == TEGRA_DC_OUT_HOTPLUG_LOW && !level);
999 }
1000 EXPORT_SYMBOL(tegra_dc_hpd);
1001
1002 static void tegra_dc_set_scaling_filter(struct tegra_dc *dc)
1003 {
1004         unsigned i;
1005         unsigned v0 = 128;
1006         unsigned v1 = 0;
1007
1008         /* linear horizontal and vertical filters */
1009         for (i = 0; i < 16; i++) {
1010                 tegra_dc_writel(dc, (v1 << 16) | (v0 << 8),
1011                                 DC_WIN_H_FILTER_P(i));
1012
1013                 tegra_dc_writel(dc, v0,
1014                                 DC_WIN_V_FILTER_P(i));
1015                 v0 -= 8;
1016                 v1 += 8;
1017         }
1018 }
1019
1020 #ifdef CONFIG_TEGRA_DC_CMU
1021 static void tegra_dc_cache_cmu(struct tegra_dc_cmu *dst_cmu,
1022                                         struct tegra_dc_cmu *src_cmu)
1023 {
1024         memcpy(dst_cmu, src_cmu, sizeof(struct tegra_dc_cmu));
1025 }
1026
1027 static void tegra_dc_set_cmu(struct tegra_dc *dc, struct tegra_dc_cmu *cmu)
1028 {
1029         u32 val;
1030         u32 i;
1031
1032         for (i = 0; i < 256; i++) {
1033                 val = LUT1_ADDR(i) | LUT1_DATA(cmu->lut1[i]);
1034                 tegra_dc_writel(dc, val, DC_COM_CMU_LUT1);
1035         }
1036
1037         tegra_dc_writel(dc, cmu->csc.krr, DC_COM_CMU_CSC_KRR);
1038         tegra_dc_writel(dc, cmu->csc.kgr, DC_COM_CMU_CSC_KGR);
1039         tegra_dc_writel(dc, cmu->csc.kbr, DC_COM_CMU_CSC_KBR);
1040         tegra_dc_writel(dc, cmu->csc.krg, DC_COM_CMU_CSC_KRG);
1041         tegra_dc_writel(dc, cmu->csc.kgg, DC_COM_CMU_CSC_KGG);
1042         tegra_dc_writel(dc, cmu->csc.kbg, DC_COM_CMU_CSC_KBG);
1043         tegra_dc_writel(dc, cmu->csc.krb, DC_COM_CMU_CSC_KRB);
1044         tegra_dc_writel(dc, cmu->csc.kgb, DC_COM_CMU_CSC_KGB);
1045         tegra_dc_writel(dc, cmu->csc.kbb, DC_COM_CMU_CSC_KBB);
1046
1047         for (i = 0; i < 960; i++) {
1048                 val = LUT2_ADDR(i) | LUT1_DATA(cmu->lut2[i]);
1049                 tegra_dc_writel(dc, val, DC_COM_CMU_LUT2);
1050         }
1051 }
1052
1053 void tegra_dc_get_cmu(struct tegra_dc *dc, struct tegra_dc_cmu *cmu)
1054 {
1055         u32 val;
1056         u32 i;
1057         bool flags;
1058
1059         val = tegra_dc_readl(dc, DC_DISP_DISP_COLOR_CONTROL);
1060         if (val & CMU_ENABLE)
1061                 flags = true;
1062
1063         val &= ~CMU_ENABLE;
1064         tegra_dc_writel(dc, val, DC_DISP_DISP_COLOR_CONTROL);
1065         tegra_dc_writel(dc, GENERAL_UPDATE, DC_CMD_STATE_CONTROL);
1066         tegra_dc_writel(dc, GENERAL_ACT_REQ, DC_CMD_STATE_CONTROL);
1067
1068         /*TODO: Sync up with frame end */
1069         mdelay(20);
1070
1071         for (i = 0; i < 256; i++) {
1072                 val = LUT1_READ_EN | LUT1_READ_ADDR(i);
1073                 tegra_dc_writel(dc, val, DC_COM_CMU_LUT1_READ);
1074                 val = tegra_dc_readl(dc, DC_COM_CMU_LUT1);
1075                 cmu->lut1[i] = LUT1_READ_DATA(val);
1076         }
1077
1078         cmu->csc.krr = tegra_dc_readl(dc, DC_COM_CMU_CSC_KRR);
1079         cmu->csc.kgr = tegra_dc_readl(dc, DC_COM_CMU_CSC_KGR);
1080         cmu->csc.kbr = tegra_dc_readl(dc, DC_COM_CMU_CSC_KBR);
1081         cmu->csc.krg = tegra_dc_readl(dc, DC_COM_CMU_CSC_KRG);
1082         cmu->csc.kgg = tegra_dc_readl(dc, DC_COM_CMU_CSC_KGG);
1083         cmu->csc.kbg = tegra_dc_readl(dc, DC_COM_CMU_CSC_KBG);
1084         cmu->csc.krb = tegra_dc_readl(dc, DC_COM_CMU_CSC_KRB);
1085         cmu->csc.kgb = tegra_dc_readl(dc, DC_COM_CMU_CSC_KGB);
1086         cmu->csc.kbb = tegra_dc_readl(dc, DC_COM_CMU_CSC_KBB);
1087
1088         for (i = 0; i < 960; i++) {
1089                 val = LUT2_READ_EN | LUT2_READ_ADDR(i);
1090                 tegra_dc_writel(dc, val, DC_COM_CMU_LUT2_READ);
1091                 val = tegra_dc_readl(dc, DC_COM_CMU_LUT2);
1092                 cmu->lut2[i] = LUT2_READ_DATA(val);
1093         }
1094 }
1095 EXPORT_SYMBOL(tegra_dc_get_cmu);
1096
1097 int _tegra_dc_update_cmu(struct tegra_dc *dc, struct tegra_dc_cmu *cmu)
1098 {
1099         u32 val;
1100
1101         if (dc->pdata->cmu_enable) {
1102                 dc->pdata->flags |= TEGRA_DC_FLAG_CMU_ENABLE;
1103         } else {
1104                 dc->pdata->flags &= ~TEGRA_DC_FLAG_CMU_ENABLE;
1105                 return 0;
1106         }
1107
1108 #ifdef CONFIG_TEGRA_DC_CMU
1109         if (cmu != &dc->cmu) {
1110                 tegra_dc_cache_cmu(&dc->cmu, cmu);
1111
1112                 /* Disable CMU */
1113                 val = tegra_dc_readl(dc, DC_DISP_DISP_COLOR_CONTROL);
1114                 if (val & CMU_ENABLE) {
1115                         val &= ~CMU_ENABLE;
1116                         tegra_dc_writel(dc, val, DC_DISP_DISP_COLOR_CONTROL);
1117                         val = GENERAL_UPDATE;
1118                         tegra_dc_writel(dc, val, DC_CMD_STATE_CONTROL);
1119                         val = GENERAL_ACT_REQ;
1120                         tegra_dc_writel(dc, val, DC_CMD_STATE_CONTROL);
1121                         /*TODO: Sync up with vsync */
1122                         mdelay(20);
1123                 }
1124
1125                 tegra_dc_set_cmu(dc, &dc->cmu);
1126         }
1127 #endif
1128
1129         return 0;
1130 }
1131
1132 int tegra_dc_update_cmu(struct tegra_dc *dc, struct tegra_dc_cmu *cmu)
1133 {
1134         int ret;
1135
1136         mutex_lock(&dc->lock);
1137         if (!dc->enabled) {
1138                 mutex_unlock(&dc->lock);
1139                 return 0;
1140         }
1141
1142         tegra_dc_get(dc);
1143
1144         ret = _tegra_dc_update_cmu(dc, cmu);
1145         tegra_dc_set_color_control(dc);
1146
1147         tegra_dc_put(dc);
1148         mutex_unlock(&dc->lock);
1149
1150         return ret;
1151 }
1152 EXPORT_SYMBOL(tegra_dc_update_cmu);
1153
1154 void tegra_dc_cmu_enable(struct tegra_dc *dc, bool cmu_enable)
1155 {
1156         dc->pdata->cmu_enable = cmu_enable;
1157         if (dc->pdata->cmu)
1158                 tegra_dc_update_cmu(dc, dc->pdata->cmu);
1159         else
1160                 tegra_dc_update_cmu(dc, &default_cmu);
1161 }
1162 #else
1163 #define tegra_dc_cache_cmu(dst_cmu, src_cmu)
1164 #define tegra_dc_set_cmu(dc, cmu)
1165 #define tegra_dc_update_cmu(dc, cmu)
1166 #endif
1167
1168 /* disable_irq() blocks until handler completes, calling this function while
1169  * holding dc->lock can deadlock. */
1170 static inline void disable_dc_irq(const struct tegra_dc *dc)
1171 {
1172         disable_irq(dc->irq);
1173 }
1174
1175 u32 tegra_dc_get_syncpt_id(const struct tegra_dc *dc, int i)
1176 {
1177         return dc->syncpt[i].id;
1178 }
1179 EXPORT_SYMBOL(tegra_dc_get_syncpt_id);
1180
1181 u32 tegra_dc_incr_syncpt_max(struct tegra_dc *dc, int i)
1182 {
1183         u32 max;
1184
1185         mutex_lock(&dc->lock);
1186         tegra_dc_get(dc);
1187         max = nvhost_syncpt_incr_max_ext(dc->ndev,
1188                 dc->syncpt[i].id, ((dc->enabled) ? 1 : 0));
1189         dc->syncpt[i].max = max;
1190         tegra_dc_put(dc);
1191         mutex_unlock(&dc->lock);
1192
1193         return max;
1194 }
1195
1196 void tegra_dc_incr_syncpt_min(struct tegra_dc *dc, int i, u32 val)
1197 {
1198         mutex_lock(&dc->lock);
1199         if (dc->enabled) {
1200                 tegra_dc_get(dc);
1201                 while (dc->syncpt[i].min < val) {
1202                         dc->syncpt[i].min++;
1203                         nvhost_syncpt_cpu_incr_ext(dc->ndev, dc->syncpt[i].id);
1204                 }
1205                 tegra_dc_put(dc);
1206         }
1207         mutex_unlock(&dc->lock);
1208 }
1209
1210 void
1211 tegra_dc_config_pwm(struct tegra_dc *dc, struct tegra_dc_pwm_params *cfg)
1212 {
1213         unsigned int ctrl;
1214         unsigned long out_sel;
1215         unsigned long cmd_state;
1216
1217         mutex_lock(&dc->lock);
1218         if (!dc->enabled) {
1219                 mutex_unlock(&dc->lock);
1220                 return;
1221         }
1222
1223         tegra_dc_get(dc);
1224
1225         ctrl = ((cfg->period << PM_PERIOD_SHIFT) |
1226                 (cfg->clk_div << PM_CLK_DIVIDER_SHIFT) |
1227                 cfg->clk_select);
1228
1229         /* The new value should be effected immediately */
1230         cmd_state = tegra_dc_readl(dc, DC_CMD_STATE_ACCESS);
1231         tegra_dc_writel(dc, (cmd_state | (1 << 2)), DC_CMD_STATE_ACCESS);
1232
1233         switch (cfg->which_pwm) {
1234         case TEGRA_PWM_PM0:
1235                 /* Select the LM0 on PM0 */
1236                 out_sel = tegra_dc_readl(dc, DC_COM_PIN_OUTPUT_SELECT5);
1237                 out_sel &= ~(7 << 0);
1238                 out_sel |= (3 << 0);
1239                 tegra_dc_writel(dc, out_sel, DC_COM_PIN_OUTPUT_SELECT5);
1240                 tegra_dc_writel(dc, ctrl, DC_COM_PM0_CONTROL);
1241                 tegra_dc_writel(dc, cfg->duty_cycle, DC_COM_PM0_DUTY_CYCLE);
1242                 break;
1243         case TEGRA_PWM_PM1:
1244                 /* Select the LM1 on PM1 */
1245                 out_sel = tegra_dc_readl(dc, DC_COM_PIN_OUTPUT_SELECT5);
1246                 out_sel &= ~(7 << 4);
1247                 out_sel |= (3 << 4);
1248                 tegra_dc_writel(dc, out_sel, DC_COM_PIN_OUTPUT_SELECT5);
1249                 tegra_dc_writel(dc, ctrl, DC_COM_PM1_CONTROL);
1250                 tegra_dc_writel(dc, cfg->duty_cycle, DC_COM_PM1_DUTY_CYCLE);
1251                 break;
1252         default:
1253                 dev_err(&dc->ndev->dev, "Error: Need which_pwm\n");
1254                 break;
1255         }
1256         tegra_dc_writel(dc, cmd_state, DC_CMD_STATE_ACCESS);
1257         tegra_dc_put(dc);
1258         mutex_unlock(&dc->lock);
1259 }
1260 EXPORT_SYMBOL(tegra_dc_config_pwm);
1261
1262 void tegra_dc_set_out_pin_polars(struct tegra_dc *dc,
1263                                 const struct tegra_dc_out_pin *pins,
1264                                 const unsigned int n_pins)
1265 {
1266         unsigned int i;
1267
1268         int name;
1269         int pol;
1270
1271         u32 pol1, pol3;
1272
1273         u32 set1, unset1;
1274         u32 set3, unset3;
1275
1276         set1 = set3 = unset1 = unset3 = 0;
1277
1278         for (i = 0; i < n_pins; i++) {
1279                 name = (pins + i)->name;
1280                 pol  = (pins + i)->pol;
1281
1282                 /* set polarity by name */
1283                 switch (name) {
1284                 case TEGRA_DC_OUT_PIN_DATA_ENABLE:
1285                         if (pol == TEGRA_DC_OUT_PIN_POL_LOW)
1286                                 set3 |= LSPI_OUTPUT_POLARITY_LOW;
1287                         else
1288                                 unset3 |= LSPI_OUTPUT_POLARITY_LOW;
1289                         break;
1290                 case TEGRA_DC_OUT_PIN_H_SYNC:
1291                         if (pol == TEGRA_DC_OUT_PIN_POL_LOW)
1292                                 set1 |= LHS_OUTPUT_POLARITY_LOW;
1293                         else
1294                                 unset1 |= LHS_OUTPUT_POLARITY_LOW;
1295                         break;
1296                 case TEGRA_DC_OUT_PIN_V_SYNC:
1297                         if (pol == TEGRA_DC_OUT_PIN_POL_LOW)
1298                                 set1 |= LVS_OUTPUT_POLARITY_LOW;
1299                         else
1300                                 unset1 |= LVS_OUTPUT_POLARITY_LOW;
1301                         break;
1302                 case TEGRA_DC_OUT_PIN_PIXEL_CLOCK:
1303                         if (pol == TEGRA_DC_OUT_PIN_POL_LOW)
1304                                 set1 |= LSC0_OUTPUT_POLARITY_LOW;
1305                         else
1306                                 unset1 |= LSC0_OUTPUT_POLARITY_LOW;
1307                         break;
1308                 default:
1309                         printk("Invalid argument in function %s\n",
1310                                __FUNCTION__);
1311                         break;
1312                 }
1313         }
1314
1315         pol1 = DC_COM_PIN_OUTPUT_POLARITY1_INIT_VAL;
1316         pol3 = DC_COM_PIN_OUTPUT_POLARITY3_INIT_VAL;
1317
1318         pol1 |= set1;
1319         pol1 &= ~unset1;
1320
1321         pol3 |= set3;
1322         pol3 &= ~unset3;
1323
1324         tegra_dc_writel(dc, pol1, DC_COM_PIN_OUTPUT_POLARITY1);
1325         tegra_dc_writel(dc, pol3, DC_COM_PIN_OUTPUT_POLARITY3);
1326 }
1327
1328 static struct tegra_dc_mode *tegra_dc_get_override_mode(struct tegra_dc *dc)
1329 {
1330         if (dc->out->type == TEGRA_DC_OUT_RGB ||
1331                 dc->out->type == TEGRA_DC_OUT_HDMI ||
1332                 dc->out->type == TEGRA_DC_OUT_DSI)
1333                 return override_disp_mode[dc->out->type].pclk ?
1334                         &override_disp_mode[dc->out->type] : NULL;
1335         else
1336                 return NULL;
1337 }
1338
1339 static void tegra_dc_set_out(struct tegra_dc *dc, struct tegra_dc_out *out)
1340 {
1341         struct tegra_dc_mode *mode;
1342
1343         dc->out = out;
1344         mode = tegra_dc_get_override_mode(dc);
1345
1346         if (mode)
1347                 tegra_dc_set_mode(dc, mode);
1348         else if (out->n_modes > 0)
1349                 tegra_dc_set_mode(dc, &dc->out->modes[0]);
1350
1351         switch (out->type) {
1352         case TEGRA_DC_OUT_RGB:
1353                 dc->out_ops = &tegra_dc_rgb_ops;
1354                 break;
1355
1356         case TEGRA_DC_OUT_HDMI:
1357                 dc->out_ops = &tegra_dc_hdmi_ops;
1358                 break;
1359
1360         case TEGRA_DC_OUT_DSI:
1361                 dc->out_ops = &tegra_dc_dsi_ops;
1362                 break;
1363
1364         default:
1365                 dc->out_ops = NULL;
1366                 break;
1367         }
1368
1369         if (dc->out_ops && dc->out_ops->init)
1370                 dc->out_ops->init(dc);
1371 }
1372
1373 /* returns on error: -EINVAL
1374  * on success: TEGRA_DC_OUT_RGB, TEGRA_DC_OUT_HDMI, or TEGRA_DC_OUT_DSI. */
1375 int tegra_dc_get_out(const struct tegra_dc *dc)
1376 {
1377         if (dc && dc->out)
1378                 return dc->out->type;
1379         return -EINVAL;
1380 }
1381
1382 unsigned tegra_dc_get_out_height(const struct tegra_dc *dc)
1383 {
1384         if (dc->out)
1385                 return dc->out->height;
1386         else
1387                 return 0;
1388 }
1389 EXPORT_SYMBOL(tegra_dc_get_out_height);
1390
1391 unsigned tegra_dc_get_out_width(const struct tegra_dc *dc)
1392 {
1393         if (dc->out)
1394                 return dc->out->width;
1395         else
1396                 return 0;
1397 }
1398 EXPORT_SYMBOL(tegra_dc_get_out_width);
1399
1400 unsigned tegra_dc_get_out_max_pixclock(const struct tegra_dc *dc)
1401 {
1402         if (dc->out && dc->out->max_pixclock)
1403                 return dc->out->max_pixclock;
1404         else
1405                 return 0;
1406 }
1407 EXPORT_SYMBOL(tegra_dc_get_out_max_pixclock);
1408
1409 void tegra_dc_enable_crc(struct tegra_dc *dc)
1410 {
1411         u32 val;
1412
1413         mutex_lock(&dc->lock);
1414         tegra_dc_get(dc);
1415
1416         val = CRC_ALWAYS_ENABLE | CRC_INPUT_DATA_ACTIVE_DATA |
1417                 CRC_ENABLE_ENABLE;
1418         tegra_dc_writel(dc, val, DC_COM_CRC_CONTROL);
1419         tegra_dc_writel(dc, GENERAL_UPDATE, DC_CMD_STATE_CONTROL);
1420         tegra_dc_writel(dc, GENERAL_ACT_REQ, DC_CMD_STATE_CONTROL);
1421         tegra_dc_put(dc);
1422         mutex_unlock(&dc->lock);
1423 }
1424
1425 void tegra_dc_disable_crc(struct tegra_dc *dc)
1426 {
1427         mutex_lock(&dc->lock);
1428         tegra_dc_get(dc);
1429         tegra_dc_writel(dc, 0x0, DC_COM_CRC_CONTROL);
1430         tegra_dc_writel(dc, GENERAL_UPDATE, DC_CMD_STATE_CONTROL);
1431         tegra_dc_writel(dc, GENERAL_ACT_REQ, DC_CMD_STATE_CONTROL);
1432
1433         tegra_dc_put(dc);
1434         mutex_unlock(&dc->lock);
1435 }
1436
1437 u32 tegra_dc_read_checksum_latched(struct tegra_dc *dc)
1438 {
1439         int crc = 0;
1440
1441         if (!dc) {
1442                 pr_err("Failed to get dc: NULL parameter.\n");
1443                 goto crc_error;
1444         }
1445
1446         if (!tegra_platform_is_linsim())
1447                 /* TODO: Replace mdelay with code to sync VBlANK, since
1448                  * DC_COM_CRC_CHECKSUM_LATCHED is available after VBLANK */
1449                 mdelay(TEGRA_CRC_LATCHED_DELAY);
1450
1451         mutex_lock(&dc->lock);
1452         tegra_dc_get(dc);
1453         crc = tegra_dc_readl(dc, DC_COM_CRC_CHECKSUM_LATCHED);
1454         tegra_dc_put(dc);
1455         mutex_unlock(&dc->lock);
1456 crc_error:
1457         return crc;
1458 }
1459
1460 static bool tegra_dc_windows_are_dirty(struct tegra_dc *dc)
1461 {
1462         u32 val;
1463
1464         if (tegra_platform_is_linsim())
1465                 return false;
1466
1467         val = tegra_dc_readl(dc, DC_CMD_STATE_CONTROL);
1468         if (val & WIN_ALL_ACT_REQ)
1469                 return true;
1470
1471         return false;
1472 }
1473
1474 static inline void enable_dc_irq(const struct tegra_dc *dc)
1475 {
1476         if (tegra_platform_is_fpga())
1477                 /* Always disable DC interrupts on FPGA. */
1478                 disable_irq(dc->irq);
1479         else
1480                 enable_irq(dc->irq);
1481 }
1482
1483 void tegra_dc_get_fbvblank(struct tegra_dc *dc, struct fb_vblank *vblank)
1484 {
1485         if (dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE)
1486                 vblank->flags = FB_VBLANK_HAVE_VSYNC;
1487 }
1488
1489 int tegra_dc_wait_for_vsync(struct tegra_dc *dc)
1490 {
1491         int ret = -ENOTTY;
1492
1493         if (!(dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE) || !dc->enabled)
1494                 return ret;
1495
1496         /*
1497          * Logic is as follows
1498          * a) Indicate we need a vblank.
1499          * b) Wait for completion to be signalled from isr.
1500          * c) Initialize completion for next iteration.
1501          */
1502
1503         tegra_dc_get(dc);
1504         dc->out->user_needs_vblank = true;
1505         tegra_dc_unmask_interrupt(dc, MSF_INT);
1506
1507         ret = wait_for_completion_interruptible(&dc->out->user_vblank_comp);
1508         init_completion(&dc->out->user_vblank_comp);
1509         tegra_dc_mask_interrupt(dc, MSF_INT);
1510         tegra_dc_put(dc);
1511
1512         return ret;
1513 }
1514
1515 static void tegra_dc_prism_update_backlight(struct tegra_dc *dc)
1516 {
1517         /* Do the actual brightness update outside of the mutex dc->lock */
1518         if (dc->out->sd_settings && !dc->out->sd_settings->bl_device &&
1519                 dc->out->sd_settings->bl_device_name) {
1520                 char *bl_device_name =
1521                         dc->out->sd_settings->bl_device_name;
1522                 dc->out->sd_settings->bl_device =
1523                         get_backlight_device_by_name(bl_device_name);
1524         }
1525
1526         if (dc->out->sd_settings && dc->out->sd_settings->bl_device) {
1527                 struct backlight_device *bl = dc->out->sd_settings->bl_device;
1528                 backlight_update_status(bl);
1529         }
1530 }
1531
1532 static void tegra_dc_vblank(struct work_struct *work)
1533 {
1534         struct tegra_dc *dc = container_of(work, struct tegra_dc, vblank_work);
1535         bool nvsd_updated = false;
1536
1537         mutex_lock(&dc->lock);
1538
1539         if (!dc->enabled) {
1540                 mutex_unlock(&dc->lock);
1541                 return;
1542         }
1543
1544         tegra_dc_get(dc);
1545         /* use the new frame's bandwidth setting instead of max(current, new),
1546          * skip this if we're using tegra_dc_one_shot_worker() */
1547         if (!(dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE))
1548                 tegra_dc_program_bandwidth(dc, true);
1549
1550         /* Clear the V_BLANK_FLIP bit of vblank ref-count if update is clean. */
1551         if (!tegra_dc_windows_are_dirty(dc))
1552                 clear_bit(V_BLANK_FLIP, &dc->vblank_ref_count);
1553
1554         /* Update the SD brightness */
1555         if (dc->out->sd_settings && !dc->out->sd_settings->use_vpulse2) {
1556                 nvsd_updated = nvsd_update_brightness(dc);
1557                 /* Ref-count vblank if nvsd is on-going. Otherwise, clean the
1558                  * V_BLANK_NVSD bit of vblank ref-count. */
1559                 if (nvsd_updated) {
1560                         set_bit(V_BLANK_NVSD, &dc->vblank_ref_count);
1561                         tegra_dc_unmask_interrupt(dc, V_BLANK_INT);
1562                 } else {
1563                         clear_bit(V_BLANK_NVSD, &dc->vblank_ref_count);
1564                 }
1565         }
1566
1567         /* Mask vblank interrupt if ref-count is zero. */
1568         if (!dc->vblank_ref_count)
1569                 tegra_dc_mask_interrupt(dc, V_BLANK_INT);
1570
1571         tegra_dc_put(dc);
1572         mutex_unlock(&dc->lock);
1573
1574         /* Do the actual brightness update outside of the mutex dc->lock */
1575         if (nvsd_updated)
1576                 tegra_dc_prism_update_backlight(dc);
1577 }
1578
1579 static void tegra_dc_one_shot_worker(struct work_struct *work)
1580 {
1581         struct tegra_dc *dc = container_of(
1582                 to_delayed_work(work), struct tegra_dc, one_shot_work);
1583         mutex_lock(&dc->lock);
1584
1585         /* memory client has gone idle */
1586         tegra_dc_clear_bandwidth(dc);
1587
1588         if (dc->out_ops->idle) {
1589                 tegra_dc_io_start(dc);
1590                 dc->out_ops->idle(dc);
1591                 tegra_dc_io_end(dc);
1592         }
1593
1594         mutex_unlock(&dc->lock);
1595 }
1596
1597 /* return an arbitrarily large number if count overflow occurs.
1598  * make it a nice base-10 number to show up in stats output */
1599 static u64 tegra_dc_underflow_count(struct tegra_dc *dc, unsigned reg)
1600 {
1601         unsigned count = tegra_dc_readl(dc, reg);
1602
1603         tegra_dc_writel(dc, 0, reg);
1604         return ((count & 0x80000000) == 0) ? count : 10000000000ll;
1605 }
1606
1607 static void tegra_dc_underflow_handler(struct tegra_dc *dc)
1608 {
1609         int i;
1610
1611         dc->stats.underflows++;
1612         if (dc->underflow_mask & WIN_A_UF_INT)
1613                 dc->stats.underflows_a += tegra_dc_underflow_count(dc,
1614                         DC_WINBUF_AD_UFLOW_STATUS);
1615         if (dc->underflow_mask & WIN_B_UF_INT)
1616                 dc->stats.underflows_b += tegra_dc_underflow_count(dc,
1617                         DC_WINBUF_BD_UFLOW_STATUS);
1618         if (dc->underflow_mask & WIN_C_UF_INT)
1619                 dc->stats.underflows_c += tegra_dc_underflow_count(dc,
1620                         DC_WINBUF_CD_UFLOW_STATUS);
1621 #if defined(CONFIG_ARCH_TEGRA_14x_SOC)
1622         if (dc->underflow_mask & HC_UF_INT)
1623                 dc->stats.underflows_h += tegra_dc_underflow_count(dc,
1624                         DC_WINBUF_HD_UFLOW_STATUS);
1625         if (dc->underflow_mask & WIN_D_UF_INT)
1626                 dc->stats.underflows_d += tegra_dc_underflow_count(dc,
1627                         DC_WINBUF_DD_UFLOW_STATUS);
1628         if (dc->underflow_mask & WIN_T_UF_INT)
1629                 dc->stats.underflows_t += tegra_dc_underflow_count(dc,
1630                         DC_WINBUF_TD_UFLOW_STATUS);
1631 #endif
1632
1633         /* Check for any underflow reset conditions */
1634         for (i = 0; i < DC_N_WINDOWS; i++) {
1635                 u32 masks[] = {
1636                         WIN_A_UF_INT,
1637                         WIN_B_UF_INT,
1638                         WIN_C_UF_INT,
1639 #if defined(CONFIG_ARCH_TEGRA_14x_SOC)
1640                         WIN_D_UF_INT,
1641                         HC_UF_INT,
1642                         WIN_T_UF_INT,
1643 #endif
1644                 };
1645
1646                 if (WARN_ONCE(i >= ARRAY_SIZE(masks),
1647                         "underflow stats unsupported"))
1648                         break; /* bail if the table above is missing entries */
1649                 if (!masks[i])
1650                         continue; /* skip empty entries */
1651
1652                 if (dc->underflow_mask & masks[i]) {
1653                         dc->windows[i].underflows++;
1654
1655 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
1656                         if (i < 3 && dc->windows[i].underflows > 4) {
1657                                 schedule_work(&dc->reset_work);
1658                                 /* reset counter */
1659                                 dc->windows[i].underflows = 0;
1660                                 trace_display_reset(dc);
1661                         }
1662 #endif
1663 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
1664                         if (i < 3 && dc->windows[i].underflows > 4) {
1665                                 trace_display_reset(dc);
1666                                 tegra_dc_writel(dc, UF_LINE_FLUSH,
1667                                                 DC_DISP_DISP_MISC_CONTROL);
1668                                 tegra_dc_writel(dc, GENERAL_UPDATE,
1669                                                 DC_CMD_STATE_CONTROL);
1670                                 tegra_dc_writel(dc, GENERAL_ACT_REQ,
1671                                                 DC_CMD_STATE_CONTROL);
1672
1673                                 tegra_dc_writel(dc, 0,
1674                                                 DC_DISP_DISP_MISC_CONTROL);
1675                                 tegra_dc_writel(dc, GENERAL_UPDATE,
1676                                                 DC_CMD_STATE_CONTROL);
1677                                 tegra_dc_writel(dc, GENERAL_ACT_REQ,
1678                                                 DC_CMD_STATE_CONTROL);
1679                         }
1680 #endif
1681                 } else {
1682                         dc->windows[i].underflows = 0;
1683                 }
1684         }
1685
1686         /* Clear the underflow mask now that we've checked it. */
1687         tegra_dc_writel(dc, dc->underflow_mask, DC_CMD_INT_STATUS);
1688         dc->underflow_mask = 0;
1689         tegra_dc_unmask_interrupt(dc, ALL_UF_INT());
1690         trace_underflow(dc);
1691 }
1692
1693 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC) && !defined(CONFIG_ARCH_TEGRA_3x_SOC)
1694 static void tegra_dc_vpulse2(struct work_struct *work)
1695 {
1696         struct tegra_dc *dc = container_of(work, struct tegra_dc, vpulse2_work);
1697         bool nvsd_updated = false;
1698
1699         mutex_lock(&dc->lock);
1700
1701         if (!dc->enabled) {
1702                 mutex_unlock(&dc->lock);
1703                 return;
1704         }
1705
1706         tegra_dc_get(dc);
1707
1708         /* Clear the V_PULSE2_FLIP if no update */
1709         if (!tegra_dc_windows_are_dirty(dc))
1710                 clear_bit(V_PULSE2_FLIP, &dc->vpulse2_ref_count);
1711
1712         /* Update the SD brightness */
1713         if (dc->out->sd_settings && dc->out->sd_settings->use_vpulse2) {
1714                 nvsd_updated = nvsd_update_brightness(dc);
1715                 if (nvsd_updated) {
1716                         set_bit(V_PULSE2_NVSD, &dc->vpulse2_ref_count);
1717                         tegra_dc_unmask_interrupt(dc, V_PULSE2_INT);
1718                 } else {
1719                         clear_bit(V_PULSE2_NVSD, &dc->vpulse2_ref_count);
1720                 }
1721         }
1722
1723         /* Mask vpulse2 interrupt if ref-count is zero. */
1724         if (!dc->vpulse2_ref_count)
1725                 tegra_dc_mask_interrupt(dc, V_PULSE2_INT);
1726
1727         tegra_dc_put(dc);
1728         mutex_unlock(&dc->lock);
1729
1730         /* Do the actual brightness update outside of the mutex dc->lock */
1731         if (nvsd_updated)
1732                 tegra_dc_prism_update_backlight(dc);
1733 }
1734 #endif
1735
1736 static void tegra_dc_one_shot_irq(struct tegra_dc *dc, unsigned long status)
1737 {
1738         /* pending user vblank, so wakeup */
1739         if ((status & (V_BLANK_INT | MSF_INT)) &&
1740             (dc->out->user_needs_vblank)) {
1741                 dc->out->user_needs_vblank = false;
1742                 complete(&dc->out->user_vblank_comp);
1743         }
1744
1745         if (status & V_BLANK_INT) {
1746                 /* Sync up windows. */
1747                 tegra_dc_trigger_windows(dc);
1748
1749                 /* Schedule any additional bottom-half vblank actvities. */
1750                 queue_work(system_freezable_wq, &dc->vblank_work);
1751         }
1752
1753         if (status & FRAME_END_INT) {
1754                 /* Mark the frame_end as complete. */
1755                 if (!completion_done(&dc->frame_end_complete))
1756                         complete(&dc->frame_end_complete);
1757         }
1758
1759 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC) && !defined(CONFIG_ARCH_TEGRA_3x_SOC)
1760         if (status & V_PULSE2_INT)
1761                 queue_work(system_freezable_wq, &dc->vpulse2_work);
1762 #endif
1763 }
1764
1765 static void tegra_dc_continuous_irq(struct tegra_dc *dc, unsigned long status)
1766 {
1767         /* Schedule any additional bottom-half vblank actvities. */
1768         if (status & V_BLANK_INT)
1769                 queue_work(system_freezable_wq, &dc->vblank_work);
1770
1771         if (status & FRAME_END_INT) {
1772                 struct timespec tm = CURRENT_TIME;
1773                 dc->frame_end_timestamp = timespec_to_ns(&tm);
1774                 wake_up(&dc->timestamp_wq);
1775
1776                 /* Mark the frame_end as complete. */
1777                 if (!completion_done(&dc->frame_end_complete))
1778                         complete(&dc->frame_end_complete);
1779
1780                 tegra_dc_trigger_windows(dc);
1781         }
1782
1783 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC) && !defined(CONFIG_ARCH_TEGRA_3x_SOC)
1784         if (status & V_PULSE2_INT)
1785                 queue_work(system_freezable_wq, &dc->vpulse2_work);
1786 #endif
1787 }
1788
1789 /* XXX: Not sure if we limit look ahead to 1 frame */
1790 bool tegra_dc_is_within_n_vsync(struct tegra_dc *dc, s64 ts)
1791 {
1792         BUG_ON(!dc->frametime_ns);
1793         return ((ts - dc->frame_end_timestamp) < dc->frametime_ns);
1794 }
1795
1796 bool tegra_dc_does_vsync_separate(struct tegra_dc *dc, s64 new_ts, s64 old_ts)
1797 {
1798         BUG_ON(!dc->frametime_ns);
1799         return (((new_ts - old_ts) > dc->frametime_ns)
1800                 || (div_s64((new_ts - dc->frame_end_timestamp), dc->frametime_ns)
1801                         != div_s64((old_ts - dc->frame_end_timestamp),
1802                                 dc->frametime_ns)));
1803 }
1804
1805 static irqreturn_t tegra_dc_irq(int irq, void *ptr)
1806 {
1807         struct tegra_dc *dc = ptr;
1808         unsigned long status;
1809         unsigned long underflow_mask;
1810         u32 val;
1811         int need_disable = 0;
1812
1813         if (tegra_platform_is_fpga())
1814                 return IRQ_NONE;
1815
1816         mutex_lock(&dc->lock);
1817         if (!dc->enabled || !tegra_dc_is_powered(dc)) {
1818                 mutex_unlock(&dc->lock);
1819                 return IRQ_HANDLED;
1820         }
1821
1822         tegra_dc_get(dc);
1823
1824         if (!nvhost_module_powered_ext(dc->ndev)) {
1825                 WARN(1, "IRQ when DC not powered!\n");
1826                 status = tegra_dc_readl(dc, DC_CMD_INT_STATUS);
1827                 tegra_dc_writel(dc, status, DC_CMD_INT_STATUS);
1828                 tegra_dc_put(dc);
1829                 mutex_unlock(&dc->lock);
1830                 return IRQ_HANDLED;
1831         }
1832
1833         /* clear all status flags except underflow, save those for the worker */
1834         status = tegra_dc_readl(dc, DC_CMD_INT_STATUS);
1835         tegra_dc_writel(dc, status & ~ALL_UF_INT(), DC_CMD_INT_STATUS);
1836         val = tegra_dc_readl(dc, DC_CMD_INT_MASK);
1837         tegra_dc_writel(dc, val & ~ALL_UF_INT(), DC_CMD_INT_MASK);
1838
1839         /*
1840          * Overlays can get thier internal state corrupted during and underflow
1841          * condition.  The only way to fix this state is to reset the DC.
1842          * if we get 4 consecutive frames with underflows, assume we're
1843          * hosed and reset.
1844          */
1845         underflow_mask = status & ALL_UF_INT();
1846
1847         /* Check underflow */
1848         if (underflow_mask) {
1849                 dc->underflow_mask |= underflow_mask;
1850                 schedule_delayed_work(&dc->underflow_work,
1851                         msecs_to_jiffies(1));
1852         }
1853
1854         if (dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE)
1855                 tegra_dc_one_shot_irq(dc, status);
1856         else
1857                 tegra_dc_continuous_irq(dc, status);
1858
1859         /* update video mode if it has changed since the last frame */
1860         if (status & (FRAME_END_INT | V_BLANK_INT))
1861                 if (tegra_dc_update_mode(dc))
1862                         need_disable = 1; /* force display off on error */
1863
1864         tegra_dc_put(dc);
1865         mutex_unlock(&dc->lock);
1866
1867         if (need_disable)
1868                 tegra_dc_disable(dc);
1869         return IRQ_HANDLED;
1870 }
1871
1872 void tegra_dc_set_color_control(struct tegra_dc *dc)
1873 {
1874         u32 color_control;
1875
1876         switch (dc->out->depth) {
1877         case 3:
1878                 color_control = BASE_COLOR_SIZE111;
1879                 break;
1880
1881         case 6:
1882                 color_control = BASE_COLOR_SIZE222;
1883                 break;
1884
1885         case 8:
1886                 color_control = BASE_COLOR_SIZE332;
1887                 break;
1888
1889         case 9:
1890                 color_control = BASE_COLOR_SIZE333;
1891                 break;
1892
1893         case 12:
1894                 color_control = BASE_COLOR_SIZE444;
1895                 break;
1896
1897         case 15:
1898                 color_control = BASE_COLOR_SIZE555;
1899                 break;
1900
1901         case 16:
1902                 color_control = BASE_COLOR_SIZE565;
1903                 break;
1904
1905         case 18:
1906                 color_control = BASE_COLOR_SIZE666;
1907                 break;
1908
1909         default:
1910                 color_control = BASE_COLOR_SIZE888;
1911                 break;
1912         }
1913
1914         switch (dc->out->dither) {
1915         case TEGRA_DC_DISABLE_DITHER:
1916                 color_control |= DITHER_CONTROL_DISABLE;
1917                 break;
1918         case TEGRA_DC_ORDERED_DITHER:
1919                 color_control |= DITHER_CONTROL_ORDERED;
1920                 break;
1921         case TEGRA_DC_ERRDIFF_DITHER:
1922                 /* The line buffer for error-diffusion dither is limited
1923                  * to 1280 pixels per line. This limits the maximum
1924                  * horizontal active area size to 1280 pixels when error
1925                  * diffusion is enabled.
1926                  */
1927                 BUG_ON(dc->mode.h_active > 1280);
1928                 color_control |= DITHER_CONTROL_ERRDIFF;
1929                 break;
1930         }
1931
1932 #ifdef CONFIG_TEGRA_DC_CMU
1933         if (dc->pdata->flags & TEGRA_DC_FLAG_CMU_ENABLE)
1934                 color_control |= CMU_ENABLE;
1935 #endif
1936
1937         tegra_dc_writel(dc, color_control, DC_DISP_DISP_COLOR_CONTROL);
1938 }
1939
1940 static u32 get_syncpt(struct tegra_dc *dc, int idx)
1941 {
1942         if (idx >= 0 && idx < ARRAY_SIZE(dc->win_syncpt))
1943                 return dc->win_syncpt[idx];
1944         BUG();
1945 }
1946
1947 static void tegra_dc_init_vpulse2_int(struct tegra_dc *dc)
1948 {
1949 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC) && !defined(CONFIG_ARCH_TEGRA_3x_SOC)
1950         u32 start, end;
1951         unsigned long val;
1952
1953         val = V_PULSE2_H_POSITION(0) | V_PULSE2_LAST(0x1);
1954         tegra_dc_writel(dc, val, DC_DISP_V_PULSE2_CONTROL);
1955
1956         start = dc->mode.v_ref_to_sync + dc->mode.v_sync_width +
1957                 dc->mode.v_back_porch + dc->mode.v_active;
1958         end = start + 1;
1959         val = V_PULSE2_START_A(start) + V_PULSE2_END_A(end);
1960         tegra_dc_writel(dc, val, DC_DISP_V_PULSE2_POSITION_A);
1961
1962         val = tegra_dc_readl(dc, DC_CMD_INT_ENABLE);
1963         val |= V_PULSE2_INT;
1964         tegra_dc_writel(dc, val , DC_CMD_INT_ENABLE);
1965
1966         tegra_dc_mask_interrupt(dc, V_PULSE2_INT);
1967         tegra_dc_writel(dc, V_PULSE_2_ENABLE, DC_DISP_DISP_SIGNAL_OPTIONS0);
1968 #endif
1969 }
1970
1971 static int tegra_dc_init(struct tegra_dc *dc)
1972 {
1973         int i;
1974         int int_enable;
1975
1976         tegra_dc_io_start(dc);
1977         tegra_dc_writel(dc, 0x00000100, DC_CMD_GENERAL_INCR_SYNCPT_CNTRL);
1978         if (dc->ndev->id == 0) {
1979                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY0A,
1980                                       TEGRA_MC_PRIO_MED);
1981                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY0B,
1982                                       TEGRA_MC_PRIO_MED);
1983                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY0C,
1984                                       TEGRA_MC_PRIO_MED);
1985 #if defined(CONFIG_ARCH_TEGRA_2x_SOC) || defined(CONFIG_ARCH_TEGRA_3x_SOC)
1986                 /* only present on Tegra2 and 3 */
1987                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY1B,
1988                                       TEGRA_MC_PRIO_MED);
1989 #endif
1990                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAYHC,
1991                                       TEGRA_MC_PRIO_HIGH);
1992         } else if (dc->ndev->id == 1) {
1993                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY0AB,
1994                                       TEGRA_MC_PRIO_MED);
1995                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY0BB,
1996                                       TEGRA_MC_PRIO_MED);
1997                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY0CB,
1998                                       TEGRA_MC_PRIO_MED);
1999 #if defined(CONFIG_ARCH_TEGRA_2x_SOC) || defined(CONFIG_ARCH_TEGRA_3x_SOC)
2000                 /* only present on Tegra2 and 3 */
2001                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY1BB,
2002                                       TEGRA_MC_PRIO_MED);
2003 #endif
2004                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAYHCB,
2005                                       TEGRA_MC_PRIO_HIGH);
2006         }
2007         tegra_dc_writel(dc, 0x00000100 | dc->vblank_syncpt,
2008                         DC_CMD_CONT_SYNCPT_VSYNC);
2009
2010         tegra_dc_writel(dc, 0x00004700, DC_CMD_INT_TYPE);
2011         tegra_dc_writel(dc, 0x0001c700, DC_CMD_INT_POLARITY);
2012         tegra_dc_writel(dc, 0x00202020, DC_DISP_MEM_HIGH_PRIORITY);
2013         tegra_dc_writel(dc, 0x00010101, DC_DISP_MEM_HIGH_PRIORITY_TIMER);
2014 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
2015         tegra_dc_writel(dc, 0x00000000, DC_DISP_DISP_MISC_CONTROL);
2016 #endif
2017         /* enable interrupts for vblank, frame_end and underflows */
2018         int_enable = (FRAME_END_INT | V_BLANK_INT | ALL_UF_INT());
2019         /* for panels with one-shot mode enable tearing effect interrupt */
2020         if (dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE)
2021                 int_enable |= MSF_INT;
2022
2023         tegra_dc_writel(dc, int_enable, DC_CMD_INT_ENABLE);
2024         tegra_dc_writel(dc, ALL_UF_INT(), DC_CMD_INT_MASK);
2025         tegra_dc_init_vpulse2_int(dc);
2026
2027         tegra_dc_writel(dc, 0x00000000, DC_DISP_BORDER_COLOR);
2028
2029 #ifdef CONFIG_TEGRA_DC_CMU
2030         if (dc->pdata->cmu) {
2031                 _tegra_dc_update_cmu(dc, dc->pdata->cmu);
2032         } else {
2033                 if (dc->out->type == TEGRA_DC_OUT_HDMI)
2034                         _tegra_dc_update_cmu(dc, &default_limited_cmu);
2035                 else
2036                         _tegra_dc_update_cmu(dc, &default_cmu);
2037         }
2038 #endif
2039         tegra_dc_set_color_control(dc);
2040         for (i = 0; i < DC_N_WINDOWS; i++) {
2041                 struct tegra_dc_win *win = &dc->windows[i];
2042                 tegra_dc_writel(dc, WINDOW_A_SELECT << i,
2043                                 DC_CMD_DISPLAY_WINDOW_HEADER);
2044                 tegra_dc_set_csc(dc, &win->csc);
2045                 tegra_dc_set_lut(dc, win);
2046                 tegra_dc_set_scaling_filter(dc);
2047         }
2048
2049 #ifdef CONFIG_TEGRA_DC_WIN_H
2050         /* Window H is set to window mode by default for t14x. */
2051         tegra_dc_writel(dc, WINH_CURS_SELECT(1),
2052                         DC_DISP_BLEND_CURSOR_CONTROL);
2053 #endif
2054
2055         for (i = 0; i < dc->n_windows; i++) {
2056                 u32 syncpt = get_syncpt(dc, i);
2057
2058                 dc->syncpt[i].id = syncpt;
2059
2060                 dc->syncpt[i].min = dc->syncpt[i].max =
2061                         nvhost_syncpt_read_ext(dc->ndev, syncpt);
2062         }
2063
2064         trace_display_mode(dc, &dc->mode);
2065
2066         if (dc->mode.pclk) {
2067                 if (tegra_dc_program_mode(dc, &dc->mode)) {
2068                         tegra_dc_io_end(dc);
2069                         return -EINVAL;
2070                 }
2071         }
2072
2073         /* Initialize SD AFTER the modeset.
2074            nvsd_init handles the sd_settings = NULL case. */
2075         nvsd_init(dc, dc->out->sd_settings);
2076
2077         tegra_dc_io_end(dc);
2078
2079         return 0;
2080 }
2081
2082 static bool _tegra_dc_controller_enable(struct tegra_dc *dc)
2083 {
2084         int failed_init = 0;
2085
2086         tegra_dc_unpowergate_locked(dc);
2087
2088         if (dc->out->enable)
2089                 dc->out->enable(&dc->ndev->dev);
2090
2091         tegra_dc_setup_clk(dc, dc->clk);
2092         tegra_dc_clk_enable(dc);
2093         tegra_dc_io_start(dc);
2094
2095         tegra_dc_power_on(dc);
2096
2097         /* do not accept interrupts during initialization */
2098         tegra_dc_writel(dc, 0, DC_CMD_INT_MASK);
2099
2100         enable_dc_irq(dc);
2101
2102         failed_init = tegra_dc_init(dc);
2103         if (failed_init) {
2104                 tegra_dc_writel(dc, 0, DC_CMD_INT_MASK);
2105                 disable_irq_nosync(dc->irq);
2106                 tegra_dc_clear_bandwidth(dc);
2107                 tegra_dc_clk_disable(dc);
2108                 if (dc->out && dc->out->disable)
2109                         dc->out->disable();
2110                 tegra_dc_io_end(dc);
2111                 return false;
2112         }
2113
2114         if (dc->out_ops && dc->out_ops->enable)
2115                 dc->out_ops->enable(dc);
2116
2117         /* force a full blending update */
2118         dc->blend.z[0] = -1;
2119
2120         tegra_dc_ext_enable(dc->ext);
2121
2122         trace_display_enable(dc);
2123
2124         tegra_dc_writel(dc, GENERAL_UPDATE, DC_CMD_STATE_CONTROL);
2125         tegra_dc_writel(dc, GENERAL_ACT_REQ, DC_CMD_STATE_CONTROL);
2126
2127         if (dc->out->postpoweron)
2128                 dc->out->postpoweron();
2129
2130         tegra_log_resume_time();
2131
2132         tegra_dc_io_end(dc);
2133         return true;
2134 }
2135
2136 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
2137 static bool _tegra_dc_controller_reset_enable(struct tegra_dc *dc)
2138 {
2139         bool ret = true;
2140
2141         if (dc->out->enable)
2142                 dc->out->enable(&dc->ndev->dev);
2143
2144         tegra_dc_setup_clk(dc, dc->clk);
2145         tegra_dc_clk_enable(dc);
2146
2147         if (dc->ndev->id == 0 && tegra_dcs[1] != NULL) {
2148                 mutex_lock(&tegra_dcs[1]->lock);
2149                 disable_irq_nosync(tegra_dcs[1]->irq);
2150         } else if (dc->ndev->id == 1 && tegra_dcs[0] != NULL) {
2151                 mutex_lock(&tegra_dcs[0]->lock);
2152                 disable_irq_nosync(tegra_dcs[0]->irq);
2153         }
2154
2155         msleep(5);
2156         tegra_periph_reset_assert(dc->clk);
2157         msleep(2);
2158         if (tegra_platform_is_silicon()) {
2159                 tegra_periph_reset_deassert(dc->clk);
2160                 msleep(1);
2161         }
2162
2163         if (dc->ndev->id == 0 && tegra_dcs[1] != NULL) {
2164                 enable_dc_irq(tegra_dcs[1]);
2165                 mutex_unlock(&tegra_dcs[1]->lock);
2166         } else if (dc->ndev->id == 1 && tegra_dcs[0] != NULL) {
2167                 enable_dc_irq(tegra_dcs[0]);
2168                 mutex_unlock(&tegra_dcs[0]->lock);
2169         }
2170
2171         enable_dc_irq(dc);
2172
2173         if (tegra_dc_init(dc)) {
2174                 dev_err(&dc->ndev->dev, "cannot initialize\n");
2175                 ret = false;
2176         }
2177
2178         if (dc->out_ops && dc->out_ops->enable)
2179                 dc->out_ops->enable(dc);
2180
2181         if (dc->out->postpoweron)
2182                 dc->out->postpoweron();
2183
2184         /* force a full blending update */
2185         dc->blend.z[0] = -1;
2186
2187         tegra_dc_ext_enable(dc->ext);
2188
2189         if (!ret) {
2190                 dev_err(&dc->ndev->dev, "initialization failed,disabling");
2191                 _tegra_dc_controller_disable(dc);
2192         }
2193
2194         trace_display_reset(dc);
2195         return ret;
2196 }
2197 #endif
2198
2199 static int _tegra_dc_set_default_videomode(struct tegra_dc *dc)
2200 {
2201         if (dc->mode.pclk == 0) {
2202                 switch (dc->out->type) {
2203                 case TEGRA_DC_OUT_HDMI:
2204                 /* DC enable called but no videomode is loaded.
2205                      Check if HDMI is connected, then set fallback mdoe */
2206                 if (tegra_dc_hpd(dc)) {
2207                         return tegra_dc_set_fb_mode(dc,
2208                                         &tegra_dc_hdmi_fallback_mode, 0);
2209                 } else
2210                         return false;
2211
2212                 break;
2213
2214                 /* Do nothing for other outputs for now */
2215                 case TEGRA_DC_OUT_RGB:
2216
2217                 case TEGRA_DC_OUT_DSI:
2218
2219                 default:
2220                         return false;
2221                 }
2222         }
2223
2224         return false;
2225 }
2226
2227 int tegra_dc_set_default_videomode(struct tegra_dc *dc)
2228 {
2229         return _tegra_dc_set_default_videomode(dc);
2230 }
2231
2232 static bool _tegra_dc_enable(struct tegra_dc *dc)
2233 {
2234         if (dc->mode.pclk == 0)
2235                 return false;
2236
2237         if (!dc->out)
2238                 return false;
2239
2240         if (dc->enabled)
2241                 return true;
2242
2243         pm_runtime_get_sync(&dc->ndev->dev);
2244
2245         if (!_tegra_dc_controller_enable(dc)) {
2246                 pm_runtime_put_sync(&dc->ndev->dev);
2247                 return false;
2248         }
2249
2250         return true;
2251 }
2252
2253 void tegra_dc_enable(struct tegra_dc *dc)
2254 {
2255         mutex_lock(&dc->lock);
2256
2257         if (!dc->enabled)
2258                 dc->enabled = _tegra_dc_enable(dc);
2259
2260         mutex_unlock(&dc->lock);
2261         trace_display_mode(dc, &dc->mode);
2262 }
2263
2264 static void _tegra_dc_controller_disable(struct tegra_dc *dc)
2265 {
2266         unsigned i;
2267
2268         tegra_dc_get(dc);
2269
2270         if (dc->out && dc->out->prepoweroff)
2271                 dc->out->prepoweroff();
2272
2273         if (dc->out_ops && dc->out_ops->disable)
2274                 dc->out_ops->disable(dc);
2275
2276         tegra_dc_writel(dc, 0, DC_CMD_INT_MASK);
2277
2278         disable_irq_nosync(dc->irq);
2279
2280         tegra_dc_clear_bandwidth(dc);
2281
2282         if (dc->out && dc->out->disable)
2283                 dc->out->disable();
2284
2285         for (i = 0; i < dc->n_windows; i++) {
2286                 struct tegra_dc_win *w = &dc->windows[i];
2287
2288                 /* reset window bandwidth */
2289                 w->bandwidth = 0;
2290                 w->new_bandwidth = 0;
2291
2292                 /* disable windows */
2293                 w->flags &= ~TEGRA_WIN_FLAG_ENABLED;
2294
2295                 /* flush any pending syncpt waits */
2296                 while (dc->syncpt[i].min < dc->syncpt[i].max) {
2297                         trace_display_syncpt_flush(dc, dc->syncpt[i].id,
2298                                 dc->syncpt[i].min, dc->syncpt[i].max);
2299                         dc->syncpt[i].min++;
2300                         nvhost_syncpt_cpu_incr_ext(dc->ndev, dc->syncpt[i].id);
2301                 }
2302         }
2303         trace_display_disable(dc);
2304
2305         tegra_dc_clk_disable(dc);
2306         tegra_dc_put(dc);
2307 }
2308
2309 void tegra_dc_stats_enable(struct tegra_dc *dc, bool enable)
2310 {
2311 #if 0 /* underflow interrupt is already enabled by dc reset worker */
2312         u32 val;
2313         if (dc->enabled)  {
2314                 val = tegra_dc_readl(dc, DC_CMD_INT_ENABLE);
2315                 if (enable)
2316                         val |= (WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT);
2317                 else
2318                         val &= ~(WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT);
2319                 tegra_dc_writel(dc, val, DC_CMD_INT_ENABLE);
2320         }
2321 #endif
2322 }
2323
2324 bool tegra_dc_stats_get(struct tegra_dc *dc)
2325 {
2326 #if 0 /* right now it is always enabled */
2327         u32 val;
2328         bool res;
2329
2330         if (dc->enabled)  {
2331                 val = tegra_dc_readl(dc, DC_CMD_INT_ENABLE);
2332                 res = !!(val & (WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT));
2333         } else {
2334                 res = false;
2335         }
2336
2337         return res;
2338 #endif
2339         return true;
2340 }
2341
2342 /* make the screen blank by disabling all windows */
2343 void tegra_dc_blank(struct tegra_dc *dc)
2344 {
2345         struct tegra_dc_win *dcwins[DC_N_WINDOWS];
2346         unsigned i;
2347
2348         for (i = 0; i < DC_N_WINDOWS; i++) {
2349                 dcwins[i] = tegra_dc_get_window(dc, i);
2350                 dcwins[i]->flags &= ~TEGRA_WIN_FLAG_ENABLED;
2351         }
2352
2353         tegra_dc_update_windows(dcwins, DC_N_WINDOWS);
2354         tegra_dc_sync_windows(dcwins, DC_N_WINDOWS);
2355 }
2356
2357 static void _tegra_dc_disable(struct tegra_dc *dc)
2358 {
2359         if (dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE) {
2360                 mutex_lock(&dc->one_shot_lock);
2361                 cancel_delayed_work_sync(&dc->one_shot_work);
2362         }
2363
2364         tegra_dc_io_start(dc);
2365         _tegra_dc_controller_disable(dc);
2366         tegra_dc_io_end(dc);
2367
2368         tegra_dc_powergate_locked(dc);
2369
2370         if (dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE)
2371                 mutex_unlock(&dc->one_shot_lock);
2372         pm_runtime_put(&dc->ndev->dev);
2373
2374         /*
2375          * We will need to reinitialize the display the next time panel
2376          * is enabled.
2377          */
2378         dc->out->flags &= ~TEGRA_DC_OUT_INITIALIZED_MODE;
2379 }
2380
2381 void tegra_dc_disable(struct tegra_dc *dc)
2382 {
2383         tegra_dc_ext_disable(dc->ext);
2384
2385         /* it's important that new underflow work isn't scheduled before the
2386          * lock is acquired. */
2387         cancel_delayed_work_sync(&dc->underflow_work);
2388
2389         mutex_lock(&dc->lock);
2390
2391         if (dc->enabled) {
2392                 dc->enabled = false;
2393
2394                 if (!dc->suspended)
2395                         _tegra_dc_disable(dc);
2396         }
2397
2398 #ifdef CONFIG_SWITCH
2399         switch_set_state(&dc->modeset_switch, 0);
2400 #endif
2401
2402         mutex_unlock(&dc->lock);
2403         synchronize_irq(dc->irq);
2404         trace_display_mode(dc, &dc->mode);
2405 }
2406
2407 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
2408 static void tegra_dc_reset_worker(struct work_struct *work)
2409 {
2410         struct tegra_dc *dc =
2411                 container_of(work, struct tegra_dc, reset_work);
2412
2413         unsigned long val = 0;
2414
2415         mutex_lock(&shared_lock);
2416
2417         dev_warn(&dc->ndev->dev,
2418                 "overlay stuck in underflow state.  resetting.\n");
2419
2420         tegra_dc_ext_disable(dc->ext);
2421
2422         mutex_lock(&dc->lock);
2423
2424         if (dc->enabled == false)
2425                 goto unlock;
2426
2427         dc->enabled = false;
2428
2429         /*
2430          * off host read bus
2431          */
2432         val = tegra_dc_readl(dc, DC_CMD_CONT_SYNCPT_VSYNC);
2433         val &= ~(0x00000100);
2434         tegra_dc_writel(dc, val, DC_CMD_CONT_SYNCPT_VSYNC);
2435
2436         /*
2437          * set DC to STOP mode
2438          */
2439         tegra_dc_writel(dc, DISP_CTRL_MODE_STOP, DC_CMD_DISPLAY_COMMAND);
2440
2441         msleep(10);
2442
2443         _tegra_dc_controller_disable(dc);
2444
2445         /* _tegra_dc_controller_reset_enable deasserts reset */
2446         _tegra_dc_controller_reset_enable(dc);
2447
2448         dc->enabled = true;
2449
2450         /* reopen host read bus */
2451         val = tegra_dc_readl(dc, DC_CMD_CONT_SYNCPT_VSYNC);
2452         val &= ~(0x00000100);
2453         val |= 0x100;
2454         tegra_dc_writel(dc, val, DC_CMD_CONT_SYNCPT_VSYNC);
2455
2456 unlock:
2457         mutex_unlock(&dc->lock);
2458         mutex_unlock(&shared_lock);
2459         trace_display_reset(dc);
2460 }
2461 #endif
2462
2463 static void tegra_dc_underflow_worker(struct work_struct *work)
2464 {
2465         struct tegra_dc *dc = container_of(
2466                 to_delayed_work(work), struct tegra_dc, underflow_work);
2467
2468         mutex_lock(&dc->lock);
2469         tegra_dc_get(dc);
2470
2471         if (dc->enabled) {
2472                 tegra_dc_underflow_handler(dc);
2473         }
2474         tegra_dc_put(dc);
2475         mutex_unlock(&dc->lock);
2476 }
2477
2478 #ifdef CONFIG_SWITCH
2479 static ssize_t switch_modeset_print_mode(struct switch_dev *sdev, char *buf)
2480 {
2481         struct tegra_dc *dc =
2482                 container_of(sdev, struct tegra_dc, modeset_switch);
2483
2484         if (!sdev->state)
2485                 return sprintf(buf, "offline\n");
2486
2487         return sprintf(buf, "%dx%d\n", dc->mode.h_active, dc->mode.v_active);
2488 }
2489 #endif
2490
2491 static void tegra_dc_add_modes(struct tegra_dc *dc)
2492 {
2493         struct fb_monspecs specs;
2494         int i;
2495
2496         memset(&specs, 0, sizeof(specs));
2497         specs.max_x = dc->mode.h_active * 1000;
2498         specs.max_y = dc->mode.v_active * 1000;
2499         specs.modedb_len = dc->out->n_modes;
2500         specs.modedb = kzalloc(specs.modedb_len *
2501                 sizeof(struct fb_videomode), GFP_KERNEL);
2502         for (i = 0; i < dc->out->n_modes; i++)
2503                 tegra_dc_to_fb_videomode(&specs.modedb[i],
2504                         &dc->out->modes[i]);
2505         tegra_fb_update_monspecs(dc->fb, &specs, NULL);
2506         kfree(specs.modedb);
2507 }
2508
2509 static int tegra_dc_probe(struct platform_device *ndev)
2510 {
2511         struct tegra_dc *dc;
2512         struct tegra_dc_mode *mode;
2513         struct clk *clk;
2514 #ifndef CONFIG_TEGRA_ISOMGR
2515         struct clk *emc_clk;
2516 #endif
2517         int isomgr_client_id = -1;
2518         struct resource *res;
2519         struct resource *base_res;
2520         struct resource *fb_mem = NULL;
2521         int ret = 0;
2522         void __iomem *base;
2523         int irq;
2524         int i;
2525
2526         if (!ndev->dev.platform_data) {
2527                 dev_err(&ndev->dev, "no platform data\n");
2528                 return -ENOENT;
2529         }
2530
2531         dc = kzalloc(sizeof(struct tegra_dc), GFP_KERNEL);
2532         if (!dc) {
2533                 dev_err(&ndev->dev, "can't allocate memory for tegra_dc\n");
2534                 return -ENOMEM;
2535         }
2536
2537         irq = platform_get_irq_byname(ndev, "irq");
2538         if (irq <= 0) {
2539                 dev_err(&ndev->dev, "no irq\n");
2540                 ret = -ENOENT;
2541                 goto err_free;
2542         }
2543
2544         res = platform_get_resource_byname(ndev, IORESOURCE_MEM, "regs");
2545         if (!res) {
2546                 dev_err(&ndev->dev, "no mem resource\n");
2547                 ret = -ENOENT;
2548                 goto err_free;
2549         }
2550
2551         base_res = request_mem_region(res->start, resource_size(res),
2552                 ndev->name);
2553         if (!base_res) {
2554                 dev_err(&ndev->dev, "request_mem_region failed\n");
2555                 ret = -EBUSY;
2556                 goto err_free;
2557         }
2558
2559         base = ioremap(res->start, resource_size(res));
2560         if (!base) {
2561                 dev_err(&ndev->dev, "registers can't be mapped\n");
2562                 ret = -EBUSY;
2563                 goto err_release_resource_reg;
2564         }
2565         if (TEGRA_DISPLAY_BASE == res->start) {
2566                 dc->vblank_syncpt = NVSYNCPT_VBLANK0;
2567                 dc->win_syncpt[0] = NVSYNCPT_DISP0_A;
2568                 dc->win_syncpt[1] = NVSYNCPT_DISP0_B;
2569                 dc->win_syncpt[2] = NVSYNCPT_DISP0_C;
2570 #ifdef CONFIG_ARCH_TEGRA_14x_SOC
2571                 dc->win_syncpt[3] = NVSYNCPT_DISP0_D;
2572                 dc->win_syncpt[4] = NVSYNCPT_DISP0_H;
2573 #endif
2574                 dc->powergate_id = TEGRA_POWERGATE_DISA;
2575                 isomgr_client_id = TEGRA_ISO_CLIENT_DISP_0;
2576         } else if (TEGRA_DISPLAY2_BASE == res->start) {
2577                 dc->vblank_syncpt = NVSYNCPT_VBLANK1;
2578                 dc->win_syncpt[0] = NVSYNCPT_DISP1_A;
2579                 dc->win_syncpt[1] = NVSYNCPT_DISP1_B;
2580                 dc->win_syncpt[2] = NVSYNCPT_DISP1_C;
2581 #ifdef CONFIG_ARCH_TEGRA_14x_SOC
2582                 dc->win_syncpt[4] = NVSYNCPT_DISP1_H;
2583 #endif
2584                 dc->powergate_id = TEGRA_POWERGATE_DISB;
2585                 isomgr_client_id = TEGRA_ISO_CLIENT_DISP_1;
2586         } else {
2587                 dev_err(&ndev->dev,
2588                         "Unknown base address %#08x: unable to assign syncpt\n",
2589                         res->start);
2590         }
2591
2592
2593         fb_mem = platform_get_resource_byname(ndev, IORESOURCE_MEM, "fbmem");
2594
2595         clk = clk_get(&ndev->dev, NULL);
2596         if (IS_ERR_OR_NULL(clk)) {
2597                 dev_err(&ndev->dev, "can't get clock\n");
2598                 ret = -ENOENT;
2599                 goto err_iounmap_reg;
2600         }
2601
2602         dc->clk = clk;
2603         dc->shift_clk_div.mul = dc->shift_clk_div.div = 1;
2604         /* Initialize one shot work delay, it will be assigned by dsi
2605          * according to refresh rate later. */
2606         dc->one_shot_delay_ms = 40;
2607
2608         dc->base_res = base_res;
2609         dc->base = base;
2610         dc->irq = irq;
2611         dc->ndev = ndev;
2612         dc->pdata = ndev->dev.platform_data;
2613
2614         dc->bw_kbps = 0;
2615
2616         mutex_init(&dc->lock);
2617         mutex_init(&dc->one_shot_lock);
2618         init_completion(&dc->frame_end_complete);
2619         init_waitqueue_head(&dc->wq);
2620         init_waitqueue_head(&dc->timestamp_wq);
2621 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
2622         INIT_WORK(&dc->reset_work, tegra_dc_reset_worker);
2623 #endif
2624         INIT_WORK(&dc->vblank_work, tegra_dc_vblank);
2625         dc->vblank_ref_count = 0;
2626 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC) && !defined(CONFIG_ARCH_TEGRA_3x_SOC)
2627         INIT_WORK(&dc->vpulse2_work, tegra_dc_vpulse2);
2628 #endif
2629         dc->vpulse2_ref_count = 0;
2630         INIT_DELAYED_WORK(&dc->underflow_work, tegra_dc_underflow_worker);
2631         INIT_DELAYED_WORK(&dc->one_shot_work, tegra_dc_one_shot_worker);
2632
2633         tegra_dc_init_lut_defaults(&dc->fb_lut);
2634
2635         dc->n_windows = DC_N_WINDOWS;
2636         for (i = 0; i < dc->n_windows; i++) {
2637                 struct tegra_dc_win *win = &dc->windows[i];
2638                 win->idx = i;
2639                 win->dc = dc;
2640                 tegra_dc_init_csc_defaults(&win->csc);
2641                 tegra_dc_init_lut_defaults(&win->lut);
2642         }
2643
2644         ret = tegra_dc_set(dc, ndev->id);
2645         if (ret < 0) {
2646                 dev_err(&ndev->dev, "can't add dc\n");
2647                 goto err_put_clk;
2648         }
2649
2650         platform_set_drvdata(ndev, dc);
2651
2652 #ifdef CONFIG_SWITCH
2653         dc->modeset_switch.name = dev_name(&ndev->dev);
2654         dc->modeset_switch.state = 0;
2655         dc->modeset_switch.print_state = switch_modeset_print_mode;
2656         ret = switch_dev_register(&dc->modeset_switch);
2657         if (ret < 0)
2658                 dev_err(&ndev->dev, "failed to register switch driver\n");
2659 #endif
2660
2661         tegra_dc_feature_register(dc);
2662
2663         if (dc->pdata->default_out)
2664                 tegra_dc_set_out(dc, dc->pdata->default_out);
2665         else
2666                 dev_err(&ndev->dev, "No default output specified.  Leaving output disabled.\n");
2667         dc->mode_dirty = false; /* ignore changes tegra_dc_set_out has done */
2668
2669 #ifdef CONFIG_TEGRA_ISOMGR
2670         if (isomgr_client_id == -1) {
2671                 dc->isomgr_handle = NULL;
2672         } else {
2673                 dc->isomgr_handle = tegra_isomgr_register(isomgr_client_id,
2674                         tegra_dc_calc_min_bandwidth(dc),
2675                         tegra_dc_bandwidth_renegotiate, dc);
2676                 if (IS_ERR(dc->isomgr_handle)) {
2677                         dev_err(&dc->ndev->dev,
2678                                 "could not register isomgr. err=%ld\n",
2679                                 PTR_ERR(dc->isomgr_handle));
2680                         ret = -ENOENT;
2681                         goto err_put_clk;
2682                 }
2683         }
2684 #else
2685         /*
2686          * The emc is a shared clock, it will be set based on
2687          * the requirements for each user on the bus.
2688          */
2689         emc_clk = clk_get(&ndev->dev, "emc");
2690         if (IS_ERR_OR_NULL(emc_clk)) {
2691                 dev_err(&ndev->dev, "can't get emc clock\n");
2692                 ret = -ENOENT;
2693                 goto err_put_clk;
2694         }
2695         dc->emc_clk = emc_clk;
2696 #endif
2697
2698         dc->ext = tegra_dc_ext_register(ndev, dc);
2699         if (IS_ERR_OR_NULL(dc->ext)) {
2700                 dev_warn(&ndev->dev, "Failed to enable Tegra DC extensions.\n");
2701                 dc->ext = NULL;
2702         }
2703
2704         /* interrupt handler must be registered before tegra_fb_register() */
2705         if (request_threaded_irq(irq, NULL, tegra_dc_irq, IRQF_ONESHOT,
2706                         dev_name(&ndev->dev), dc)) {
2707                 dev_err(&ndev->dev, "request_irq %d failed\n", irq);
2708                 ret = -EBUSY;
2709                 goto err_disable_dc;
2710         }
2711         disable_dc_irq(dc);
2712
2713         tegra_pd_add_device(&tegra_mc_chain_a, &ndev->dev);
2714         pm_runtime_use_autosuspend(&ndev->dev);
2715         pm_runtime_set_autosuspend_delay(&ndev->dev, 100);
2716         pm_runtime_enable(&ndev->dev);
2717
2718         if (dc->pdata->flags & TEGRA_DC_FLAG_ENABLED) {
2719                 _tegra_dc_set_default_videomode(dc);
2720                 dc->enabled = _tegra_dc_enable(dc);
2721         }
2722
2723         tegra_dc_create_debugfs(dc);
2724
2725         dev_info(&ndev->dev, "probed\n");
2726
2727         if (dc->pdata->fb) {
2728                 if (dc->enabled && dc->pdata->fb->bits_per_pixel == -1) {
2729                         unsigned long fmt;
2730                         tegra_dc_writel(dc,
2731                                         WINDOW_A_SELECT << dc->pdata->fb->win,
2732                                         DC_CMD_DISPLAY_WINDOW_HEADER);
2733
2734                         fmt = tegra_dc_readl(dc, DC_WIN_COLOR_DEPTH);
2735                         dc->pdata->fb->bits_per_pixel =
2736                                 tegra_dc_fmt_bpp(fmt);
2737                 }
2738
2739                 mode = tegra_dc_get_override_mode(dc);
2740                 if (mode) {
2741                         dc->pdata->fb->xres = mode->h_active;
2742                         dc->pdata->fb->yres = mode->v_active;
2743                 }
2744
2745                 tegra_dc_io_start(dc);
2746                 dc->fb = tegra_fb_register(ndev, dc, dc->pdata->fb, fb_mem);
2747                 tegra_dc_io_end(dc);
2748                 if (IS_ERR_OR_NULL(dc->fb)) {
2749                         dc->fb = NULL;
2750                         dev_err(&ndev->dev, "failed to register fb\n");
2751                         goto err_remove_debugfs;
2752                 }
2753         }
2754
2755         if (dc->out && dc->out->n_modes)
2756                 tegra_dc_add_modes(dc);
2757
2758         if (dc->out && dc->out->hotplug_init)
2759                 dc->out->hotplug_init(&ndev->dev);
2760
2761         if (dc->out_ops && dc->out_ops->detect)
2762                 dc->out_ops->detect(dc);
2763         else
2764                 dc->connected = true;
2765
2766         /* Powergate display module when it's unconnected. */
2767         if (!tegra_dc_get_connected(dc))
2768                 tegra_dc_powergate_locked(dc);
2769
2770         tegra_dc_create_sysfs(&dc->ndev->dev);
2771
2772         return 0;
2773
2774 err_remove_debugfs:
2775         tegra_dc_remove_debugfs(dc);
2776         free_irq(irq, dc);
2777 err_disable_dc:
2778         if (dc->ext) {
2779                 tegra_dc_ext_disable(dc->ext);
2780                 tegra_dc_ext_unregister(dc->ext);
2781         }
2782         mutex_lock(&dc->lock);
2783         if (dc->enabled)
2784                 _tegra_dc_disable(dc);
2785         dc->enabled = false;
2786         mutex_unlock(&dc->lock);
2787 #ifdef CONFIG_SWITCH
2788         switch_dev_unregister(&dc->modeset_switch);
2789 #endif
2790 #ifdef CONFIG_TEGRA_ISOMGR
2791         tegra_isomgr_unregister(dc->isomgr_handle);
2792 #else
2793         clk_put(emc_clk);
2794 #endif
2795 err_put_clk:
2796         clk_put(clk);
2797 err_iounmap_reg:
2798         iounmap(base);
2799         if (fb_mem)
2800                 release_resource(fb_mem);
2801 err_release_resource_reg:
2802         release_resource(base_res);
2803 err_free:
2804         kfree(dc);
2805
2806         return ret;
2807 }
2808
2809 static int tegra_dc_remove(struct platform_device *ndev)
2810 {
2811         struct tegra_dc *dc = platform_get_drvdata(ndev);
2812
2813         tegra_dc_remove_sysfs(&dc->ndev->dev);
2814         tegra_dc_remove_debugfs(dc);
2815
2816         if (dc->fb) {
2817                 tegra_fb_unregister(dc->fb);
2818                 if (dc->fb_mem)
2819                         release_resource(dc->fb_mem);
2820         }
2821
2822         tegra_dc_ext_disable(dc->ext);
2823
2824         if (dc->ext)
2825                 tegra_dc_ext_unregister(dc->ext);
2826
2827         mutex_lock(&dc->lock);
2828         if (dc->enabled)
2829                 _tegra_dc_disable(dc);
2830         dc->enabled = false;
2831         mutex_unlock(&dc->lock);
2832         synchronize_irq(dc->irq); /* wait for IRQ handlers to finish */
2833
2834 #ifdef CONFIG_SWITCH
2835         switch_dev_unregister(&dc->modeset_switch);
2836 #endif
2837         free_irq(dc->irq, dc);
2838 #ifdef CONFIG_TEGRA_ISOMGR
2839         if (dc->isomgr_handle) {
2840                 tegra_isomgr_unregister(dc->isomgr_handle);
2841                 dc->isomgr_handle = NULL;
2842         }
2843 #else
2844         clk_put(dc->emc_clk);
2845 #endif
2846         clk_put(dc->clk);
2847         iounmap(dc->base);
2848         if (dc->fb_mem)
2849                 release_resource(dc->base_res);
2850         kfree(dc);
2851         tegra_dc_set(NULL, ndev->id);
2852
2853         return 0;
2854 }
2855
2856 #ifdef CONFIG_PM
2857 static int tegra_dc_suspend(struct platform_device *ndev, pm_message_t state)
2858 {
2859         struct tegra_dc *dc = platform_get_drvdata(ndev);
2860
2861         trace_display_suspend(dc);
2862         dev_info(&ndev->dev, "suspend\n");
2863
2864         tegra_dc_ext_disable(dc->ext);
2865
2866         mutex_lock(&dc->lock);
2867         tegra_dc_io_start(dc);
2868
2869         if (dc->out_ops && dc->out_ops->suspend)
2870                 dc->out_ops->suspend(dc);
2871
2872         if (dc->enabled) {
2873                 _tegra_dc_disable(dc);
2874
2875                 dc->suspended = true;
2876         }
2877
2878         if (dc->out && dc->out->postsuspend) {
2879                 dc->out->postsuspend();
2880                 if (dc->out->type && dc->out->type == TEGRA_DC_OUT_HDMI)
2881                         /*
2882                          * avoid resume event due to voltage falling
2883                          */
2884                         msleep(100);
2885         }
2886
2887         tegra_dc_io_end(dc);
2888         mutex_unlock(&dc->lock);
2889         synchronize_irq(dc->irq); /* wait for IRQ handlers to finish */
2890
2891         return 0;
2892 }
2893
2894 static int tegra_dc_resume(struct platform_device *ndev)
2895 {
2896         struct tegra_dc *dc = platform_get_drvdata(ndev);
2897
2898         trace_display_resume(dc);
2899         dev_info(&ndev->dev, "resume\n");
2900
2901         mutex_lock(&dc->lock);
2902         dc->suspended = false;
2903
2904         /* To pan the fb on resume */
2905         tegra_fb_pan_display_reset(dc->fb);
2906
2907         if (dc->enabled) {
2908                 dc->enabled = false;
2909                 _tegra_dc_set_default_videomode(dc);
2910                 dc->enabled = _tegra_dc_enable(dc);
2911         }
2912
2913         if (dc->out && dc->out->hotplug_init)
2914                 dc->out->hotplug_init(&ndev->dev);
2915
2916         if (dc->out_ops && dc->out_ops->resume)
2917                 dc->out_ops->resume(dc);
2918         mutex_unlock(&dc->lock);
2919
2920         return 0;
2921 }
2922
2923 #endif /* CONFIG_PM */
2924
2925 static void tegra_dc_shutdown(struct platform_device *ndev)
2926 {
2927         struct tegra_dc *dc = platform_get_drvdata(ndev);
2928
2929         if (!dc || !dc->enabled)
2930                 return;
2931
2932         /* Hack: no windows blanking for simulation to save shutdown time */
2933         if (!tegra_platform_is_linsim())
2934                 tegra_dc_blank(dc);
2935         tegra_dc_disable(dc);
2936 }
2937
2938 extern int suspend_set(const char *val, struct kernel_param *kp)
2939 {
2940         if (!strcmp(val, "dump"))
2941                 dump_regs(tegra_dcs[0]);
2942 #ifdef CONFIG_PM
2943         else if (!strcmp(val, "suspend"))
2944                 tegra_dc_suspend(tegra_dcs[0]->ndev, PMSG_SUSPEND);
2945         else if (!strcmp(val, "resume"))
2946                 tegra_dc_resume(tegra_dcs[0]->ndev);
2947 #endif
2948
2949         return 0;
2950 }
2951
2952 extern int suspend_get(char *buffer, struct kernel_param *kp)
2953 {
2954         return 0;
2955 }
2956
2957 int suspend;
2958
2959 module_param_call(suspend, suspend_set, suspend_get, &suspend, 0644);
2960
2961 struct platform_driver tegra_dc_driver = {
2962         .driver = {
2963                 .name = "tegradc",
2964                 .owner = THIS_MODULE,
2965         },
2966         .probe = tegra_dc_probe,
2967         .remove = tegra_dc_remove,
2968 #ifdef CONFIG_PM
2969         .suspend = tegra_dc_suspend,
2970         .resume = tegra_dc_resume,
2971 #endif
2972         .shutdown = tegra_dc_shutdown,
2973 };
2974
2975 #ifndef MODULE
2976 static int __init parse_disp_params(char *options, struct tegra_dc_mode *mode)
2977 {
2978         int i, params[11];
2979         char *p;
2980
2981         for (i = 0; i < ARRAY_SIZE(params); i++) {
2982                 if ((p = strsep(&options, ",")) != NULL) {
2983                         if (*p)
2984                                 params[i] = simple_strtoul(p, &p, 10);
2985                 } else
2986                         return -EINVAL;
2987         }
2988
2989         if ((mode->pclk = params[0]) == 0)
2990                 return -EINVAL;
2991
2992         mode->h_active      = params[1];
2993         mode->v_active      = params[2];
2994         mode->h_ref_to_sync = params[3];
2995         mode->v_ref_to_sync = params[4];
2996         mode->h_sync_width  = params[5];
2997         mode->v_sync_width  = params[6];
2998         mode->h_back_porch  = params[7];
2999         mode->v_back_porch  = params[8];
3000         mode->h_front_porch = params[9];
3001         mode->v_front_porch = params[10];
3002
3003         return 0;
3004 }
3005
3006 static int __init tegra_dc_mode_override(char *str)
3007 {
3008         char *p = str, *options;
3009
3010         if (!p || !*p)
3011                 return -EINVAL;
3012
3013         p = strstr(str, "hdmi:");
3014         if (p) {
3015                 p += 5;
3016                 options = strsep(&p, ";");
3017                 if (parse_disp_params(options, &override_disp_mode[TEGRA_DC_OUT_HDMI]))
3018                         return -EINVAL;
3019         }
3020
3021         p = strstr(str, "rgb:");
3022         if (p) {
3023                 p += 4;
3024                 options = strsep(&p, ";");
3025                 if (parse_disp_params(options, &override_disp_mode[TEGRA_DC_OUT_RGB]))
3026                         return -EINVAL;
3027         }
3028
3029         p = strstr(str, "dsi:");
3030         if (p) {
3031                 p += 4;
3032                 options = strsep(&p, ";");
3033                 if (parse_disp_params(options, &override_disp_mode[TEGRA_DC_OUT_DSI]))
3034                         return -EINVAL;
3035         }
3036
3037         return 0;
3038 }
3039
3040 __setup("disp_params=", tegra_dc_mode_override);
3041 #endif
3042
3043 static int __init tegra_dc_module_init(void)
3044 {
3045         int ret = tegra_dc_ext_module_init();
3046         if (ret)
3047                 return ret;
3048         return platform_driver_register(&tegra_dc_driver);
3049 }
3050
3051 static void __exit tegra_dc_module_exit(void)
3052 {
3053         platform_driver_unregister(&tegra_dc_driver);
3054         tegra_dc_ext_module_exit();
3055 }
3056
3057 module_exit(tegra_dc_module_exit);
3058 module_init(tegra_dc_module_init);