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