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