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