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