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