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