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