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 void tegra_dc_vsync_enable(struct tegra_dc *dc)
1569 {
1570         mutex_lock(&dc->lock);
1571         _tegra_dc_vsync_enable(dc);
1572         mutex_unlock(&dc->lock);
1573 }
1574
1575 /* assumes dc->lock is already taken. */
1576 static void _tegra_dc_vsync_disable(struct tegra_dc *dc)
1577 {
1578         int vsync_irq;
1579
1580         if (dc->out->type == TEGRA_DC_OUT_DSI)
1581                 vsync_irq = MSF_INT;
1582         else
1583                 vsync_irq = V_BLANK_INT;
1584         clear_bit(V_BLANK_USER, &dc->vblank_ref_count);
1585         if (!dc->vblank_ref_count)
1586                 tegra_dc_mask_interrupt(dc, vsync_irq);
1587         tegra_dc_release_dc_out(dc);
1588 }
1589
1590 void tegra_dc_vsync_disable(struct tegra_dc *dc)
1591 {
1592         mutex_lock(&dc->lock);
1593         _tegra_dc_vsync_disable(dc);
1594         mutex_unlock(&dc->lock);
1595 }
1596
1597 /* assumes dc->lock is already taken. */
1598 static void _tegra_dc_user_vsync_enable(struct tegra_dc *dc, bool enable)
1599 {
1600         if (enable) {
1601                 dc->out->user_needs_vblank++;
1602                 init_completion(&dc->out->user_vblank_comp);
1603                 _tegra_dc_vsync_enable(dc);
1604         } else {
1605                 _tegra_dc_vsync_disable(dc);
1606                 dc->out->user_needs_vblank--;
1607         }
1608 }
1609
1610 int tegra_dc_wait_for_vsync(struct tegra_dc *dc)
1611 {
1612         unsigned long timeout_ms;
1613         unsigned long refresh; /* in 1000th Hz */
1614         int ret;
1615
1616         mutex_lock(&dc->lp_lock);
1617         mutex_lock(&dc->lock);
1618         if (!dc->enabled) {
1619                 ret = -ENOTTY;
1620                 goto out;
1621         }
1622         refresh = tegra_dc_calc_refresh(&dc->mode);
1623         /* time out if waiting took more than 2 frames */
1624         timeout_ms = DIV_ROUND_UP(2 * 1000000, refresh);
1625         _tegra_dc_user_vsync_enable(dc, true);
1626         mutex_unlock(&dc->lock);
1627
1628         ret = wait_for_completion_interruptible_timeout(
1629                 &dc->out->user_vblank_comp, msecs_to_jiffies(timeout_ms));
1630
1631         mutex_lock(&dc->lock);
1632         _tegra_dc_user_vsync_enable(dc, false);
1633 out:
1634         mutex_unlock(&dc->lock);
1635         mutex_unlock(&dc->lp_lock);
1636         return ret;
1637 }
1638
1639 static void tegra_dc_prism_update_backlight(struct tegra_dc *dc)
1640 {
1641         /* Do the actual brightness update outside of the mutex dc->lock */
1642         if (dc->out->sd_settings && !dc->out->sd_settings->bl_device &&
1643                 dc->out->sd_settings->bl_device_name) {
1644                 char *bl_device_name =
1645                         dc->out->sd_settings->bl_device_name;
1646                 dc->out->sd_settings->bl_device =
1647                         get_backlight_device_by_name(bl_device_name);
1648         }
1649
1650         if (dc->out->sd_settings && dc->out->sd_settings->bl_device) {
1651                 struct backlight_device *bl = dc->out->sd_settings->bl_device;
1652                 backlight_update_status(bl);
1653         }
1654 }
1655
1656 static void tegra_dc_vblank(struct work_struct *work)
1657 {
1658         struct tegra_dc *dc = container_of(work, struct tegra_dc, vblank_work);
1659         bool nvsd_updated = false;
1660
1661         mutex_lock(&dc->lock);
1662
1663         if (!dc->enabled) {
1664                 mutex_unlock(&dc->lock);
1665                 return;
1666         }
1667
1668         tegra_dc_get(dc);
1669
1670         /* Clear the V_BLANK_FLIP bit of vblank ref-count if update is clean. */
1671         if (!tegra_dc_windows_are_dirty(dc))
1672                 clear_bit(V_BLANK_FLIP, &dc->vblank_ref_count);
1673
1674         /* Update the SD brightness */
1675         if (dc->out->sd_settings && !dc->out->sd_settings->use_vpulse2) {
1676                 nvsd_updated = nvsd_update_brightness(dc);
1677                 /* Ref-count vblank if nvsd is on-going. Otherwise, clean the
1678                  * V_BLANK_NVSD bit of vblank ref-count. */
1679                 if (nvsd_updated) {
1680                         set_bit(V_BLANK_NVSD, &dc->vblank_ref_count);
1681                         tegra_dc_unmask_interrupt(dc, V_BLANK_INT);
1682                 } else {
1683                         clear_bit(V_BLANK_NVSD, &dc->vblank_ref_count);
1684                 }
1685         }
1686
1687         /* Mask vblank interrupt if ref-count is zero. */
1688         if (!dc->vblank_ref_count)
1689                 tegra_dc_mask_interrupt(dc, V_BLANK_INT);
1690
1691         tegra_dc_put(dc);
1692         mutex_unlock(&dc->lock);
1693
1694         /* Do the actual brightness update outside of the mutex dc->lock */
1695         if (nvsd_updated)
1696                 tegra_dc_prism_update_backlight(dc);
1697 }
1698
1699 static void tegra_dc_one_shot_worker(struct work_struct *work)
1700 {
1701         struct tegra_dc *dc = container_of(
1702                 to_delayed_work(work), struct tegra_dc, one_shot_work);
1703         mutex_lock(&dc->lock);
1704
1705         /* memory client has gone idle */
1706         tegra_dc_clear_bandwidth(dc);
1707
1708         if (dc->out_ops && dc->out_ops->idle) {
1709                 tegra_dc_io_start(dc);
1710                 dc->out_ops->idle(dc);
1711                 tegra_dc_io_end(dc);
1712         }
1713
1714         mutex_unlock(&dc->lock);
1715 }
1716
1717 /* return an arbitrarily large number if count overflow occurs.
1718  * make it a nice base-10 number to show up in stats output */
1719 static u64 tegra_dc_underflow_count(struct tegra_dc *dc, unsigned reg)
1720 {
1721         unsigned count = tegra_dc_readl(dc, reg);
1722
1723         tegra_dc_writel(dc, 0, reg);
1724         return ((count & 0x80000000) == 0) ? count : 10000000000ll;
1725 }
1726
1727 static void tegra_dc_underflow_handler(struct tegra_dc *dc)
1728 {
1729         const u32 masks[] = {
1730                 WIN_A_UF_INT,
1731                 WIN_B_UF_INT,
1732                 WIN_C_UF_INT,
1733 #if defined(CONFIG_ARCH_TEGRA_14x_SOC) || defined(CONFIG_ARCH_TEGRA_12x_SOC)
1734                 WIN_D_UF_INT,
1735                 HC_UF_INT,
1736                 WIN_T_UF_INT,
1737 #endif
1738         };
1739         int i;
1740
1741         dc->stats.underflows++;
1742         if (dc->underflow_mask & WIN_A_UF_INT)
1743                 dc->stats.underflows_a += tegra_dc_underflow_count(dc,
1744                         DC_WINBUF_AD_UFLOW_STATUS);
1745         if (dc->underflow_mask & WIN_B_UF_INT)
1746                 dc->stats.underflows_b += tegra_dc_underflow_count(dc,
1747                         DC_WINBUF_BD_UFLOW_STATUS);
1748         if (dc->underflow_mask & WIN_C_UF_INT)
1749                 dc->stats.underflows_c += tegra_dc_underflow_count(dc,
1750                         DC_WINBUF_CD_UFLOW_STATUS);
1751 #if defined(CONFIG_ARCH_TEGRA_14x_SOC) || defined(CONFIG_ARCH_TEGRA_12x_SOC)
1752         if (dc->underflow_mask & HC_UF_INT)
1753                 dc->stats.underflows_h += tegra_dc_underflow_count(dc,
1754                         DC_WINBUF_HD_UFLOW_STATUS);
1755         if (dc->underflow_mask & WIN_D_UF_INT)
1756                 dc->stats.underflows_d += tegra_dc_underflow_count(dc,
1757                         DC_WINBUF_DD_UFLOW_STATUS);
1758         if (dc->underflow_mask & WIN_T_UF_INT)
1759                 dc->stats.underflows_t += tegra_dc_underflow_count(dc,
1760                         DC_WINBUF_TD_UFLOW_STATUS);
1761 #endif
1762
1763         /* Check for any underflow reset conditions */
1764         for_each_set_bit(i, &dc->valid_windows, DC_N_WINDOWS) {
1765                 if (WARN_ONCE(i >= ARRAY_SIZE(masks),
1766                         "underflow stats unsupported"))
1767                         break; /* bail if the table above is missing entries */
1768                 if (!masks[i])
1769                         continue; /* skip empty entries */
1770
1771                 if (dc->underflow_mask & masks[i]) {
1772                         dc->windows[i].underflows++;
1773
1774 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
1775                         if (i < 3 && dc->windows[i].underflows > 4) {
1776                                 schedule_work(&dc->reset_work);
1777                                 /* reset counter */
1778                                 dc->windows[i].underflows = 0;
1779                                 trace_display_reset(dc);
1780                         }
1781 #endif
1782 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
1783                         if (i < 3 && dc->windows[i].underflows > 4) {
1784                                 trace_display_reset(dc);
1785                                 tegra_dc_writel(dc, UF_LINE_FLUSH,
1786                                                 DC_DISP_DISP_MISC_CONTROL);
1787                                 tegra_dc_writel(dc, GENERAL_UPDATE,
1788                                                 DC_CMD_STATE_CONTROL);
1789                                 tegra_dc_writel(dc, GENERAL_ACT_REQ,
1790                                                 DC_CMD_STATE_CONTROL);
1791
1792                                 tegra_dc_writel(dc, 0,
1793                                                 DC_DISP_DISP_MISC_CONTROL);
1794                                 tegra_dc_writel(dc, GENERAL_UPDATE,
1795                                                 DC_CMD_STATE_CONTROL);
1796                                 tegra_dc_writel(dc, GENERAL_ACT_REQ,
1797                                                 DC_CMD_STATE_CONTROL);
1798                         }
1799 #endif
1800                 } else {
1801                         dc->windows[i].underflows = 0;
1802                 }
1803         }
1804
1805         /* Clear the underflow mask now that we've checked it. */
1806         tegra_dc_writel(dc, dc->underflow_mask, DC_CMD_INT_STATUS);
1807         dc->underflow_mask = 0;
1808         tegra_dc_unmask_interrupt(dc, ALL_UF_INT());
1809         trace_underflow(dc);
1810 }
1811
1812 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC) && !defined(CONFIG_ARCH_TEGRA_3x_SOC)
1813 static void tegra_dc_vpulse2(struct work_struct *work)
1814 {
1815         struct tegra_dc *dc = container_of(work, struct tegra_dc, vpulse2_work);
1816         bool nvsd_updated = false;
1817
1818         mutex_lock(&dc->lock);
1819
1820         if (!dc->enabled) {
1821                 mutex_unlock(&dc->lock);
1822                 return;
1823         }
1824
1825         tegra_dc_get(dc);
1826
1827         /* Clear the V_PULSE2_FLIP if no update */
1828         if (!tegra_dc_windows_are_dirty(dc))
1829                 clear_bit(V_PULSE2_FLIP, &dc->vpulse2_ref_count);
1830
1831         /* Update the SD brightness */
1832         if (dc->out->sd_settings && dc->out->sd_settings->use_vpulse2) {
1833                 nvsd_updated = nvsd_update_brightness(dc);
1834                 if (nvsd_updated) {
1835                         set_bit(V_PULSE2_NVSD, &dc->vpulse2_ref_count);
1836                         tegra_dc_unmask_interrupt(dc, V_PULSE2_INT);
1837                 } else {
1838                         clear_bit(V_PULSE2_NVSD, &dc->vpulse2_ref_count);
1839                 }
1840         }
1841
1842         /* Mask vpulse2 interrupt if ref-count is zero. */
1843         if (!dc->vpulse2_ref_count)
1844                 tegra_dc_mask_interrupt(dc, V_PULSE2_INT);
1845
1846         tegra_dc_put(dc);
1847         mutex_unlock(&dc->lock);
1848
1849         /* Do the actual brightness update outside of the mutex dc->lock */
1850         if (nvsd_updated)
1851                 tegra_dc_prism_update_backlight(dc);
1852 }
1853 #endif
1854
1855 static void tegra_dc_process_vblank(struct tegra_dc *dc, ktime_t timestamp)
1856 {
1857         if (test_bit(V_BLANK_USER, &dc->vblank_ref_count))
1858                 tegra_dc_ext_process_vblank(dc->ndev->id, timestamp);
1859 }
1860
1861 static void tegra_dc_one_shot_irq(struct tegra_dc *dc, unsigned long status,
1862                                 ktime_t timestamp)
1863 {
1864         /* pending user vblank, so wakeup */
1865         if (status & (V_BLANK_INT | MSF_INT)) {
1866                 if (dc->out->user_needs_vblank > 0)
1867                         complete(&dc->out->user_vblank_comp);
1868                 tegra_dc_process_vblank(dc, timestamp);
1869         }
1870
1871         if (status & V_BLANK_INT) {
1872                 /* Sync up windows. */
1873                 tegra_dc_trigger_windows(dc);
1874
1875                 /* Schedule any additional bottom-half vblank actvities. */
1876                 queue_work(system_freezable_wq, &dc->vblank_work);
1877         }
1878
1879         if (status & FRAME_END_INT) {
1880                 /* Mark the frame_end as complete. */
1881                 dc->crc_pending = false;
1882                 if (!completion_done(&dc->frame_end_complete))
1883                         complete(&dc->frame_end_complete);
1884                 if (!completion_done(&dc->crc_complete))
1885                         complete(&dc->crc_complete);
1886
1887                 if (dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE && !dc->nvsr)
1888                         tegra_dc_put(dc);
1889         }
1890
1891 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC) && !defined(CONFIG_ARCH_TEGRA_3x_SOC)
1892         if (status & V_PULSE2_INT)
1893                 queue_work(system_freezable_wq, &dc->vpulse2_work);
1894 #endif
1895 }
1896
1897 static void tegra_dc_continuous_irq(struct tegra_dc *dc, unsigned long status,
1898                                 ktime_t timestamp)
1899 {
1900         /* Schedule any additional bottom-half vblank actvities. */
1901         if (status & V_BLANK_INT)
1902                 queue_work(system_freezable_wq, &dc->vblank_work);
1903
1904         if (status & (V_BLANK_INT | MSF_INT))
1905                 tegra_dc_process_vblank(dc, timestamp);
1906
1907         if (status & FRAME_END_INT) {
1908                 struct timespec tm = CURRENT_TIME;
1909                 dc->frame_end_timestamp = timespec_to_ns(&tm);
1910                 wake_up(&dc->timestamp_wq);
1911
1912                 /* Mark the frame_end as complete. */
1913                 if (!completion_done(&dc->frame_end_complete))
1914                         complete(&dc->frame_end_complete);
1915                 if (!completion_done(&dc->crc_complete))
1916                         complete(&dc->crc_complete);
1917
1918                 tegra_dc_trigger_windows(dc);
1919         }
1920
1921 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC) && !defined(CONFIG_ARCH_TEGRA_3x_SOC)
1922         if (status & V_PULSE2_INT)
1923                 queue_work(system_freezable_wq, &dc->vpulse2_work);
1924 #endif
1925 }
1926
1927 /* XXX: Not sure if we limit look ahead to 1 frame */
1928 bool tegra_dc_is_within_n_vsync(struct tegra_dc *dc, s64 ts)
1929 {
1930         BUG_ON(!dc->frametime_ns);
1931         return ((ts - dc->frame_end_timestamp) < dc->frametime_ns);
1932 }
1933
1934 bool tegra_dc_does_vsync_separate(struct tegra_dc *dc, s64 new_ts, s64 old_ts)
1935 {
1936         BUG_ON(!dc->frametime_ns);
1937         return (((new_ts - old_ts) > dc->frametime_ns)
1938                 || (div_s64((new_ts - dc->frame_end_timestamp), dc->frametime_ns)
1939                         != div_s64((old_ts - dc->frame_end_timestamp),
1940                                 dc->frametime_ns)));
1941 }
1942
1943 static irqreturn_t tegra_dc_irq(int irq, void *ptr)
1944 {
1945         ktime_t timestamp = ktime_get();
1946         struct tegra_dc *dc = ptr;
1947         unsigned long status;
1948         unsigned long underflow_mask;
1949         u32 val;
1950         int need_disable = 0;
1951
1952         if (tegra_platform_is_fpga())
1953                 return IRQ_NONE;
1954
1955         mutex_lock(&dc->lock);
1956         if (!tegra_dc_is_powered(dc)) {
1957                 mutex_unlock(&dc->lock);
1958                 return IRQ_HANDLED;
1959         }
1960
1961         tegra_dc_get(dc);
1962
1963         if (!dc->enabled || !nvhost_module_powered_ext(dc->ndev)) {
1964                 dev_dbg(&dc->ndev->dev, "IRQ when DC not powered!\n");
1965                 status = tegra_dc_readl(dc, DC_CMD_INT_STATUS);
1966                 tegra_dc_writel(dc, status, DC_CMD_INT_STATUS);
1967                 tegra_dc_put(dc);
1968                 mutex_unlock(&dc->lock);
1969                 return IRQ_HANDLED;
1970         }
1971
1972         /* clear all status flags except underflow, save those for the worker */
1973         status = tegra_dc_readl(dc, DC_CMD_INT_STATUS);
1974         tegra_dc_writel(dc, status & ~ALL_UF_INT(), DC_CMD_INT_STATUS);
1975         val = tegra_dc_readl(dc, DC_CMD_INT_MASK);
1976         tegra_dc_writel(dc, val & ~ALL_UF_INT(), DC_CMD_INT_MASK);
1977
1978         /*
1979          * Overlays can get thier internal state corrupted during and underflow
1980          * condition.  The only way to fix this state is to reset the DC.
1981          * if we get 4 consecutive frames with underflows, assume we're
1982          * hosed and reset.
1983          */
1984         underflow_mask = status & ALL_UF_INT();
1985
1986         /* Check underflow */
1987         if (underflow_mask) {
1988                 dc->underflow_mask |= underflow_mask;
1989                 schedule_delayed_work(&dc->underflow_work,
1990                         msecs_to_jiffies(1));
1991         }
1992
1993         if (dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE)
1994                 tegra_dc_one_shot_irq(dc, status, timestamp);
1995         else
1996                 tegra_dc_continuous_irq(dc, status, timestamp);
1997
1998         if (dc->nvsr)
1999                 tegra_dc_nvsr_irq(dc->nvsr, status);
2000
2001         /* update video mode if it has changed since the last frame */
2002         if (status & (FRAME_END_INT | V_BLANK_INT))
2003                 if (tegra_dc_update_mode(dc))
2004                         need_disable = 1; /* force display off on error */
2005
2006         tegra_dc_put(dc);
2007         mutex_unlock(&dc->lock);
2008
2009         if (need_disable)
2010                 tegra_dc_disable(dc);
2011         return IRQ_HANDLED;
2012 }
2013
2014 void tegra_dc_set_color_control(struct tegra_dc *dc)
2015 {
2016         u32 color_control;
2017
2018         switch (dc->out->depth) {
2019         case 3:
2020                 color_control = BASE_COLOR_SIZE111;
2021                 break;
2022
2023         case 6:
2024                 color_control = BASE_COLOR_SIZE222;
2025                 break;
2026
2027         case 8:
2028                 color_control = BASE_COLOR_SIZE332;
2029                 break;
2030
2031         case 9:
2032                 color_control = BASE_COLOR_SIZE333;
2033                 break;
2034
2035         case 12:
2036                 color_control = BASE_COLOR_SIZE444;
2037                 break;
2038
2039         case 15:
2040                 color_control = BASE_COLOR_SIZE555;
2041                 break;
2042
2043         case 16:
2044                 color_control = BASE_COLOR_SIZE565;
2045                 break;
2046
2047         case 18:
2048                 color_control = BASE_COLOR_SIZE666;
2049                 break;
2050
2051         default:
2052                 color_control = BASE_COLOR_SIZE888;
2053                 break;
2054         }
2055
2056         switch (dc->out->dither) {
2057         case TEGRA_DC_UNDEFINED_DITHER:
2058         case TEGRA_DC_DISABLE_DITHER:
2059                 color_control |= DITHER_CONTROL_DISABLE;
2060                 break;
2061         case TEGRA_DC_ORDERED_DITHER:
2062                 color_control |= DITHER_CONTROL_ORDERED;
2063                 break;
2064 #ifdef CONFIG_TEGRA_DC_TEMPORAL_DITHER
2065         case TEGRA_DC_TEMPORAL_DITHER:
2066                 color_control |= DITHER_CONTROL_TEMPORAL;
2067                 break;
2068 #else
2069         case TEGRA_DC_ERRDIFF_DITHER:
2070                 /* The line buffer for error-diffusion dither is limited
2071                  * to 1280 pixels per line. This limits the maximum
2072                  * horizontal active area size to 1280 pixels when error
2073                  * diffusion is enabled.
2074                  */
2075                 BUG_ON(dc->mode.h_active > 1280);
2076                 color_control |= DITHER_CONTROL_ERRDIFF;
2077                 break;
2078 #endif
2079         default:
2080                 dev_err(&dc->ndev->dev, "Error: Unsupported dithering mode\n");
2081         }
2082
2083 #ifdef CONFIG_TEGRA_DC_CMU
2084         if (dc->cmu_enabled)
2085                 color_control |= CMU_ENABLE;
2086 #endif
2087
2088         tegra_dc_writel(dc, color_control, DC_DISP_DISP_COLOR_CONTROL);
2089 }
2090
2091 static u32 get_syncpt(struct tegra_dc *dc, int idx)
2092 {
2093         if (idx >= 0 && idx < ARRAY_SIZE(dc->win_syncpt))
2094                 return dc->win_syncpt[idx];
2095         BUG();
2096 }
2097
2098 static void tegra_dc_init_vpulse2_int(struct tegra_dc *dc)
2099 {
2100 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC) && !defined(CONFIG_ARCH_TEGRA_3x_SOC)
2101         u32 start, end;
2102         unsigned long val;
2103
2104         val = V_PULSE2_H_POSITION(0) | V_PULSE2_LAST(0x1);
2105         tegra_dc_writel(dc, val, DC_DISP_V_PULSE2_CONTROL);
2106
2107         start = dc->mode.v_ref_to_sync + dc->mode.v_sync_width +
2108                 dc->mode.v_back_porch + dc->mode.v_active;
2109         end = start + 1;
2110         val = V_PULSE2_START_A(start) + V_PULSE2_END_A(end);
2111         tegra_dc_writel(dc, val, DC_DISP_V_PULSE2_POSITION_A);
2112
2113         val = tegra_dc_readl(dc, DC_CMD_INT_ENABLE);
2114         val |= V_PULSE2_INT;
2115         tegra_dc_writel(dc, val , DC_CMD_INT_ENABLE);
2116
2117         tegra_dc_mask_interrupt(dc, V_PULSE2_INT);
2118         tegra_dc_writel(dc, V_PULSE_2_ENABLE, DC_DISP_DISP_SIGNAL_OPTIONS0);
2119 #endif
2120 }
2121
2122 static int tegra_dc_init(struct tegra_dc *dc)
2123 {
2124         int i;
2125         int int_enable;
2126         u32 val;
2127
2128         tegra_dc_io_start(dc);
2129         tegra_dc_writel(dc, 0x00000100, DC_CMD_GENERAL_INCR_SYNCPT_CNTRL);
2130         if (dc->ndev->id == 0) {
2131                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY0A,
2132                                       TEGRA_MC_PRIO_MED);
2133                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY0B,
2134                                       TEGRA_MC_PRIO_MED);
2135                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY0C,
2136                                       TEGRA_MC_PRIO_MED);
2137 #if defined(CONFIG_ARCH_TEGRA_2x_SOC) || defined(CONFIG_ARCH_TEGRA_3x_SOC)
2138                 /* only present on Tegra2 and 3 */
2139                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY1B,
2140                                       TEGRA_MC_PRIO_MED);
2141 #endif
2142                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAYHC,
2143                                       TEGRA_MC_PRIO_HIGH);
2144         } else if (dc->ndev->id == 1) {
2145                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY0AB,
2146                                       TEGRA_MC_PRIO_MED);
2147                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY0BB,
2148                                       TEGRA_MC_PRIO_MED);
2149                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY0CB,
2150                                       TEGRA_MC_PRIO_MED);
2151 #if defined(CONFIG_ARCH_TEGRA_2x_SOC) || defined(CONFIG_ARCH_TEGRA_3x_SOC)
2152                 /* only present on Tegra2 and 3 */
2153                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAY1BB,
2154                                       TEGRA_MC_PRIO_MED);
2155 #endif
2156                 tegra_mc_set_priority(TEGRA_MC_CLIENT_DISPLAYHCB,
2157                                       TEGRA_MC_PRIO_HIGH);
2158         }
2159         tegra_dc_writel(dc, 0x00000100 | dc->vblank_syncpt,
2160                         DC_CMD_CONT_SYNCPT_VSYNC);
2161
2162         tegra_dc_writel(dc, 0x00004700, DC_CMD_INT_TYPE);
2163 #if defined(CONFIG_ARCH_TEGRA_14x_SOC) || defined(CONFIG_ARCH_TEGRA_12x_SOC)
2164         tegra_dc_writel(dc, WIN_A_OF_INT | WIN_B_OF_INT | WIN_C_OF_INT |
2165                 WIN_T_UF_INT | WIN_D_UF_INT | HC_UF_INT |
2166                 WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT,
2167                 DC_CMD_INT_POLARITY);
2168 #else
2169         tegra_dc_writel(dc, WIN_A_OF_INT | WIN_B_OF_INT | WIN_C_OF_INT |
2170                 WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT,
2171                 DC_CMD_INT_POLARITY);
2172 #endif
2173         tegra_dc_writel(dc, 0x00202020, DC_DISP_MEM_HIGH_PRIORITY);
2174         tegra_dc_writel(dc, 0x00010101, DC_DISP_MEM_HIGH_PRIORITY_TIMER);
2175 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
2176         tegra_dc_writel(dc, 0x00000000, DC_DISP_DISP_MISC_CONTROL);
2177 #endif
2178         /* enable interrupts for vblank, frame_end and underflows */
2179         int_enable = (FRAME_END_INT | V_BLANK_INT | ALL_UF_INT());
2180         /* for panels with one-shot mode enable tearing effect interrupt */
2181         if (dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE)
2182                 int_enable |= MSF_INT;
2183
2184         tegra_dc_writel(dc, int_enable, DC_CMD_INT_ENABLE);
2185         tegra_dc_writel(dc, ALL_UF_INT(), DC_CMD_INT_MASK);
2186         tegra_dc_init_vpulse2_int(dc);
2187
2188 #if !defined(CONFIG_TEGRA_DC_BLENDER_GEN2)
2189         tegra_dc_writel(dc, 0x00000000, DC_DISP_BORDER_COLOR);
2190 #else
2191         tegra_dc_writel(dc, 0x00000000, DC_DISP_BLEND_BACKGROUND_COLOR);
2192 #endif
2193
2194 #ifdef CONFIG_TEGRA_DC_CMU
2195         _tegra_dc_update_cmu(dc, tegra_dc_get_cmu(dc));
2196 #endif
2197         tegra_dc_set_color_control(dc);
2198         for_each_set_bit(i, &dc->valid_windows, DC_N_WINDOWS) {
2199                 struct tegra_dc_win *win = &dc->windows[i];
2200                 tegra_dc_writel(dc, WINDOW_A_SELECT << i,
2201                                 DC_CMD_DISPLAY_WINDOW_HEADER);
2202                 tegra_dc_set_csc(dc, &win->csc);
2203                 tegra_dc_set_lut(dc, win);
2204                 tegra_dc_set_scaling_filter(dc);
2205         }
2206
2207 #ifdef CONFIG_TEGRA_DC_WIN_H
2208         /* Window H is set to window mode by default for t14x. */
2209         tegra_dc_writel(dc, WINH_CURS_SELECT(1),
2210                         DC_DISP_BLEND_CURSOR_CONTROL);
2211 #endif
2212
2213         for_each_set_bit(i, &dc->valid_windows, DC_N_WINDOWS) {
2214                 u32 syncpt = get_syncpt(dc, i);
2215
2216                 /* refuse to operate on invalid syncpts */
2217                 if (WARN_ON(syncpt == NVSYNCPT_INVALID))
2218                         continue;
2219
2220                 dc->syncpt[i].id = syncpt;
2221
2222                 if (!nvhost_syncpt_read_ext_check(dc->ndev, syncpt, &val))
2223                         dc->syncpt[i].min = dc->syncpt[i].max = val;
2224         }
2225
2226         dc->crc_pending = false;
2227
2228         trace_display_mode(dc, &dc->mode);
2229
2230         if (dc->mode.pclk) {
2231                 if (!dc->initialized) {
2232                         if (tegra_dc_program_mode(dc, &dc->mode)) {
2233                                 tegra_dc_io_end(dc);
2234                                 return -EINVAL;
2235                         }
2236                 } else {
2237                         dev_info(&dc->ndev->dev, "DC initialized, "
2238                                         "skipping tegra_dc_program_mode.\n");
2239                 }
2240         }
2241
2242         /* Initialize SD AFTER the modeset.
2243            nvsd_init handles the sd_settings = NULL case. */
2244         nvsd_init(dc, dc->out->sd_settings);
2245
2246         tegra_dc_io_end(dc);
2247
2248         return 0;
2249 }
2250
2251 static bool _tegra_dc_controller_enable(struct tegra_dc *dc)
2252 {
2253         int failed_init = 0;
2254         int i;
2255
2256         if (WARN_ON(!dc || !dc->out || !dc->out_ops))
2257                 return false;
2258
2259         tegra_dc_unpowergate_locked(dc);
2260
2261         if (dc->out->enable)
2262                 dc->out->enable(&dc->ndev->dev);
2263
2264         tegra_dc_setup_clk(dc, dc->clk);
2265
2266         /* dc clk always on for continuous mode */
2267         if (!(dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE))
2268                 tegra_dc_clk_enable(dc);
2269         else
2270                 tegra_dvfs_set_rate(dc->clk, dc->mode.pclk);
2271
2272         tegra_dc_get(dc);
2273
2274         tegra_dc_power_on(dc);
2275
2276         /* do not accept interrupts during initialization */
2277         tegra_dc_writel(dc, 0, DC_CMD_INT_MASK);
2278
2279         enable_dc_irq(dc);
2280
2281         failed_init = tegra_dc_init(dc);
2282         if (failed_init) {
2283                 tegra_dc_writel(dc, 0, DC_CMD_INT_MASK);
2284                 disable_irq_nosync(dc->irq);
2285                 tegra_dc_clear_bandwidth(dc);
2286                 if (dc->out && dc->out->disable)
2287                         dc->out->disable();
2288                 tegra_dc_put(dc);
2289                 if (!(dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE))
2290                         tegra_dc_clk_disable(dc);
2291                 else
2292                         tegra_dvfs_set_rate(dc->clk, 0);
2293                 return false;
2294         }
2295
2296         tegra_dpaux_pad_power(dc, false);
2297
2298         if (dc->out_ops && dc->out_ops->enable)
2299                 dc->out_ops->enable(dc);
2300
2301         /* force a full blending update */
2302         for (i = 0; i < DC_N_WINDOWS; i++)
2303                 dc->blend.z[i] = -1;
2304
2305         tegra_dc_ext_enable(dc->ext);
2306
2307         /* initialize cursor to defaults, as driver depends on HW state */
2308         tegra_dc_writel(dc, 0, DC_DISP_CURSOR_START_ADDR);
2309         tegra_dc_writel(dc, 0, DC_DISP_CURSOR_START_ADDR_NS);
2310 #if defined(CONFIG_ARCH_TEGRA_12x_SOC)
2311         tegra_dc_writel(dc, 0, DC_DISP_CURSOR_START_ADDR_HI);
2312         tegra_dc_writel(dc, 0, DC_DISP_CURSOR_START_ADDR_HI_NS);
2313 #endif
2314         tegra_dc_writel(dc, 0, DC_DISP_CURSOR_POSITION);
2315         tegra_dc_writel(dc, 0, DC_DISP_CURSOR_POSITION_NS);
2316         tegra_dc_writel(dc, 0xffffff, DC_DISP_CURSOR_FOREGROUND); /* white */
2317         tegra_dc_writel(dc, 0x000000, DC_DISP_CURSOR_BACKGROUND); /* black */
2318         tegra_dc_writel(dc, 0, DC_DISP_BLEND_CURSOR_CONTROL);
2319
2320         trace_display_enable(dc);
2321
2322         tegra_dc_writel(dc, GENERAL_UPDATE, DC_CMD_STATE_CONTROL);
2323         tegra_dc_writel(dc, GENERAL_ACT_REQ, DC_CMD_STATE_CONTROL);
2324
2325         if (dc->out->postpoweron)
2326                 dc->out->postpoweron(&dc->ndev->dev);
2327
2328         if (dc->out_ops && dc->out_ops->postpoweron)
2329                 dc->out_ops->postpoweron(dc);
2330
2331         tegra_log_resume_time();
2332         /*
2333          * We will need to reinitialize the display the next time panel
2334          * is enabled.
2335          */
2336         dc->out->flags &= ~TEGRA_DC_OUT_INITIALIZED_MODE;
2337
2338         tegra_dc_put(dc);
2339
2340         return true;
2341 }
2342
2343 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
2344 static bool _tegra_dc_controller_reset_enable(struct tegra_dc *dc)
2345 {
2346         bool ret = true;
2347
2348         if (WARN_ON(!dc || !dc->out || !dc->out_ops))
2349                 return false;
2350
2351         if (dc->out->enable)
2352                 dc->out->enable(&dc->ndev->dev);
2353
2354         tegra_dc_setup_clk(dc, dc->clk);
2355         tegra_dc_clk_enable(dc);
2356
2357         if (dc->ndev->id == 0 && tegra_dcs[1] != NULL) {
2358                 mutex_lock(&tegra_dcs[1]->lock);
2359                 disable_irq_nosync(tegra_dcs[1]->irq);
2360         } else if (dc->ndev->id == 1 && tegra_dcs[0] != NULL) {
2361                 mutex_lock(&tegra_dcs[0]->lock);
2362                 disable_irq_nosync(tegra_dcs[0]->irq);
2363         }
2364
2365         msleep(5);
2366         tegra_periph_reset_assert(dc->clk);
2367         msleep(2);
2368         if (tegra_platform_is_silicon()) {
2369                 tegra_periph_reset_deassert(dc->clk);
2370                 msleep(1);
2371         }
2372
2373         if (dc->ndev->id == 0 && tegra_dcs[1] != NULL) {
2374                 enable_dc_irq(tegra_dcs[1]);
2375                 mutex_unlock(&tegra_dcs[1]->lock);
2376         } else if (dc->ndev->id == 1 && tegra_dcs[0] != NULL) {
2377                 enable_dc_irq(tegra_dcs[0]);
2378                 mutex_unlock(&tegra_dcs[0]->lock);
2379         }
2380
2381         enable_dc_irq(dc);
2382
2383         if (tegra_dc_init(dc)) {
2384                 dev_err(&dc->ndev->dev, "cannot initialize\n");
2385                 ret = false;
2386         }
2387
2388         if (dc->out_ops && dc->out_ops->enable)
2389                 dc->out_ops->enable(dc);
2390
2391         if (dc->out->postpoweron)
2392                 dc->out->postpoweron(&dc->ndev->dev);
2393
2394         /* force a full blending update */
2395         dc->blend.z[0] = -1;
2396
2397         tegra_dc_ext_enable(dc->ext);
2398
2399         if (!ret) {
2400                 dev_err(&dc->ndev->dev, "initialization failed,disabling");
2401                 _tegra_dc_controller_disable(dc);
2402         }
2403
2404         trace_display_reset(dc);
2405         return ret;
2406 }
2407 #endif
2408
2409 static int _tegra_dc_set_default_videomode(struct tegra_dc *dc)
2410 {
2411         if (dc->mode.pclk == 0) {
2412                 switch (dc->out->type) {
2413                 case TEGRA_DC_OUT_HDMI:
2414                 /* If DC is enable called, and HDMI is connected,
2415                  * but DC is not initialized by bootloader and no
2416                  * mode is set up, then set a fallback mode.
2417                  */
2418                 if (tegra_dc_hpd(dc) && (!dc->initialized)) {
2419                         return tegra_dc_set_fb_mode(dc, &tegra_dc_vga_mode, 0);
2420                 } else
2421                         return false;
2422
2423                 break;
2424
2425                 case TEGRA_DC_OUT_DP:
2426                         return tegra_dc_set_fb_mode(dc, &tegra_dc_vga_mode, 0);
2427
2428                 /* Do nothing for other outputs for now */
2429                 case TEGRA_DC_OUT_RGB:
2430
2431                 case TEGRA_DC_OUT_DSI:
2432
2433                 default:
2434                         return false;
2435                 }
2436         }
2437
2438         return false;
2439 }
2440
2441 int tegra_dc_set_default_videomode(struct tegra_dc *dc)
2442 {
2443         return _tegra_dc_set_default_videomode(dc);
2444 }
2445
2446 static bool _tegra_dc_enable(struct tegra_dc *dc)
2447 {
2448         if (dc->mode.pclk == 0)
2449                 return false;
2450
2451         if (!dc->out)
2452                 return false;
2453
2454         if (dc->enabled)
2455                 return true;
2456
2457         pm_runtime_get_sync(&dc->ndev->dev);
2458
2459         if (dc->out->type == TEGRA_DC_OUT_HDMI && !tegra_dc_hpd(dc))
2460                 return false;
2461
2462         if (!_tegra_dc_controller_enable(dc)) {
2463                 pm_runtime_put_sync(&dc->ndev->dev);
2464                 return false;
2465         }
2466
2467         return true;
2468 }
2469
2470 void tegra_dc_enable(struct tegra_dc *dc)
2471 {
2472         if (WARN_ON(!dc || !dc->out || !dc->out_ops))
2473                 return;
2474
2475         mutex_lock(&dc->lock);
2476
2477         if (!dc->enabled)
2478                 dc->enabled = _tegra_dc_enable(dc);
2479
2480         mutex_unlock(&dc->lock);
2481         trace_display_mode(dc, &dc->mode);
2482 }
2483
2484 void tegra_dc_disable_window(struct tegra_dc *dc, unsigned win)
2485 {
2486         struct tegra_dc_win *w = &dc->windows[win];
2487
2488         /* reset window bandwidth */
2489         w->bandwidth = 0;
2490         w->new_bandwidth = 0;
2491
2492         /* disable windows */
2493         w->flags &= ~TEGRA_WIN_FLAG_ENABLED;
2494
2495         /* refuse to operate on invalid syncpts */
2496         if (WARN_ON(dc->syncpt[win].id == NVSYNCPT_INVALID))
2497                 return;
2498
2499         /* flush any pending syncpt waits */
2500         dc->syncpt[win].max += 1;
2501         while (dc->syncpt[win].min < dc->syncpt[win].max) {
2502                 trace_display_syncpt_flush(dc, dc->syncpt[win].id,
2503                         dc->syncpt[win].min, dc->syncpt[win].max);
2504                 dc->syncpt[win].min++;
2505                 nvhost_syncpt_cpu_incr_ext(dc->ndev, dc->syncpt[win].id);
2506         }
2507 }
2508
2509 static void _tegra_dc_controller_disable(struct tegra_dc *dc)
2510 {
2511         unsigned i;
2512
2513         tegra_dc_get(dc);
2514
2515         if (atomic_read(&dc->holding)) {
2516                 /* Force release all refs but the last one */
2517                 atomic_set(&dc->holding, 1);
2518                 tegra_dc_release_dc_out(dc);
2519         }
2520
2521         if (dc->out && dc->out->prepoweroff)
2522                 dc->out->prepoweroff();
2523
2524         if (dc->out_ops && dc->out_ops->disable)
2525                 dc->out_ops->disable(dc);
2526
2527         if (tegra_powergate_is_powered(dc->powergate_id))
2528                 tegra_dc_writel(dc, 0, DC_CMD_INT_MASK);
2529
2530         disable_irq_nosync(dc->irq);
2531
2532         tegra_dc_clear_bandwidth(dc);
2533
2534         if (dc->out && dc->out->disable)
2535                 dc->out->disable();
2536
2537         for_each_set_bit(i, &dc->valid_windows, DC_N_WINDOWS) {
2538                 tegra_dc_disable_window(dc, i);
2539         }
2540         trace_display_disable(dc);
2541
2542         if (dc->out_ops && dc->out_ops->postpoweroff)
2543                 dc->out_ops->postpoweroff(dc);
2544
2545         tegra_dc_put(dc);
2546
2547         /* disable always on dc clk in continuous mode */
2548         if (!(dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE))
2549                 tegra_dc_clk_disable(dc);
2550         else
2551                 tegra_dvfs_set_rate(dc->clk, 0);
2552 }
2553
2554 void tegra_dc_stats_enable(struct tegra_dc *dc, bool enable)
2555 {
2556 #if 0 /* underflow interrupt is already enabled by dc reset worker */
2557         u32 val;
2558         if (dc->enabled)  {
2559                 val = tegra_dc_readl(dc, DC_CMD_INT_ENABLE);
2560                 if (enable)
2561                         val |= (WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT);
2562                 else
2563                         val &= ~(WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT);
2564                 tegra_dc_writel(dc, val, DC_CMD_INT_ENABLE);
2565         }
2566 #endif
2567 }
2568
2569 bool tegra_dc_stats_get(struct tegra_dc *dc)
2570 {
2571 #if 0 /* right now it is always enabled */
2572         u32 val;
2573         bool res;
2574
2575         if (dc->enabled)  {
2576                 val = tegra_dc_readl(dc, DC_CMD_INT_ENABLE);
2577                 res = !!(val & (WIN_A_UF_INT | WIN_B_UF_INT | WIN_C_UF_INT));
2578         } else {
2579                 res = false;
2580         }
2581
2582         return res;
2583 #endif
2584         return true;
2585 }
2586
2587 /* blank selected windows by disabling them */
2588 void tegra_dc_blank(struct tegra_dc *dc, unsigned windows)
2589 {
2590         struct tegra_dc_win *dcwins[DC_N_WINDOWS];
2591         unsigned i;
2592         unsigned long int blank_windows;
2593         int nr_win = 0;
2594
2595         blank_windows = windows & dc->valid_windows;
2596
2597         if (!blank_windows)
2598                 return;
2599
2600         for_each_set_bit(i, &blank_windows, DC_N_WINDOWS) {
2601                 dcwins[nr_win] = tegra_dc_get_window(dc, i);
2602                 if (!dcwins[nr_win])
2603                         continue;
2604                 dcwins[nr_win++]->flags &= ~TEGRA_WIN_FLAG_ENABLED;
2605         }
2606
2607         tegra_dc_update_windows(dcwins, nr_win);
2608         tegra_dc_sync_windows(dcwins, nr_win);
2609         tegra_dc_program_bandwidth(dc, true);
2610 }
2611
2612 int tegra_dc_restore(struct tegra_dc *dc)
2613 {
2614         return tegra_dc_ext_restore(dc->ext);
2615 }
2616
2617 static void _tegra_dc_disable(struct tegra_dc *dc)
2618 {
2619 #ifdef CONFIG_TEGRA_DC_CMU
2620         /* power down resets the registers, setting to true
2621          * causes CMU to be restored in tegra_dc_init(). */
2622         dc->cmu_dirty = true;
2623 #endif
2624
2625         if (dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE) {
2626                 mutex_lock(&dc->one_shot_lock);
2627                 cancel_delayed_work_sync(&dc->one_shot_work);
2628         }
2629
2630         tegra_dc_io_start(dc);
2631         _tegra_dc_controller_disable(dc);
2632         tegra_dc_io_end(dc);
2633
2634         tegra_dc_powergate_locked(dc);
2635
2636         if (dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE)
2637                 mutex_unlock(&dc->one_shot_lock);
2638         pm_runtime_put(&dc->ndev->dev);
2639
2640         tegra_log_suspend_time();
2641 }
2642
2643 void tegra_dc_disable(struct tegra_dc *dc)
2644 {
2645         if (WARN_ON(!dc || !dc->out || !dc->out_ops))
2646                 return;
2647
2648         if (!tegra_dc_ext_disable(dc->ext))
2649                 tegra_dc_blank(dc, BLANK_ALL);
2650
2651         /* it's important that new underflow work isn't scheduled before the
2652          * lock is acquired. */
2653         cancel_delayed_work_sync(&dc->underflow_work);
2654
2655         mutex_lock(&dc->lp_lock);
2656         mutex_lock(&dc->lock);
2657
2658         if (dc->enabled) {
2659                 dc->enabled = false;
2660                 dc->blanked = false;
2661
2662                 if (!dc->suspended)
2663                         _tegra_dc_disable(dc);
2664         }
2665
2666 #ifdef CONFIG_SWITCH
2667         switch_set_state(&dc->modeset_switch, 0);
2668 #endif
2669         mutex_unlock(&dc->lock);
2670         mutex_unlock(&dc->lp_lock);
2671         synchronize_irq(dc->irq);
2672         trace_display_mode(dc, &dc->mode);
2673
2674         /* disable pending clks due to uncompleted frames */
2675         while (tegra_is_clk_enabled(dc->clk))
2676                 tegra_dc_put(dc);
2677 }
2678
2679 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
2680 static void tegra_dc_reset_worker(struct work_struct *work)
2681 {
2682         struct tegra_dc *dc =
2683                 container_of(work, struct tegra_dc, reset_work);
2684
2685         unsigned long val = 0;
2686
2687         mutex_lock(&shared_lock);
2688
2689         dev_warn(&dc->ndev->dev,
2690                 "overlay stuck in underflow state.  resetting.\n");
2691
2692         tegra_dc_ext_disable(dc->ext);
2693
2694         mutex_lock(&dc->lock);
2695
2696         if (dc->enabled == false)
2697                 goto unlock;
2698
2699         dc->enabled = false;
2700
2701         /*
2702          * off host read bus
2703          */
2704         val = tegra_dc_readl(dc, DC_CMD_CONT_SYNCPT_VSYNC);
2705         val &= ~(0x00000100);
2706         tegra_dc_writel(dc, val, DC_CMD_CONT_SYNCPT_VSYNC);
2707
2708         /*
2709          * set DC to STOP mode
2710          */
2711         tegra_dc_writel(dc, DISP_CTRL_MODE_STOP, DC_CMD_DISPLAY_COMMAND);
2712
2713         msleep(10);
2714
2715         _tegra_dc_controller_disable(dc);
2716
2717         /* _tegra_dc_controller_reset_enable deasserts reset */
2718         _tegra_dc_controller_reset_enable(dc);
2719
2720         dc->enabled = true;
2721
2722         /* reopen host read bus */
2723         val = tegra_dc_readl(dc, DC_CMD_CONT_SYNCPT_VSYNC);
2724         val &= ~(0x00000100);
2725         val |= 0x100;
2726         tegra_dc_writel(dc, val, DC_CMD_CONT_SYNCPT_VSYNC);
2727
2728 unlock:
2729         mutex_unlock(&dc->lock);
2730         mutex_unlock(&shared_lock);
2731         trace_display_reset(dc);
2732 }
2733 #endif
2734
2735 static void tegra_dc_underflow_worker(struct work_struct *work)
2736 {
2737         struct tegra_dc *dc = container_of(
2738                 to_delayed_work(work), struct tegra_dc, underflow_work);
2739
2740         mutex_lock(&dc->lock);
2741         tegra_dc_get(dc);
2742
2743         if (dc->enabled) {
2744                 tegra_dc_underflow_handler(dc);
2745         }
2746         tegra_dc_put(dc);
2747         mutex_unlock(&dc->lock);
2748 }
2749
2750 #ifdef CONFIG_SWITCH
2751 static ssize_t switch_modeset_print_mode(struct switch_dev *sdev, char *buf)
2752 {
2753         struct tegra_dc *dc =
2754                 container_of(sdev, struct tegra_dc, modeset_switch);
2755
2756         if (!sdev->state)
2757                 return sprintf(buf, "offline\n");
2758
2759         return sprintf(buf, "%dx%d\n", dc->mode.h_active, dc->mode.v_active);
2760 }
2761 #endif
2762
2763 static int tegra_dc_probe(struct platform_device *ndev)
2764 {
2765         struct tegra_dc *dc;
2766         struct tegra_dc_mode *mode;
2767         struct tegra_dc_platform_data *dt_pdata = NULL;
2768         struct clk *clk;
2769 #ifndef CONFIG_TEGRA_ISOMGR
2770         struct clk *emc_clk;
2771 #else
2772         int isomgr_client_id = -1;
2773 #endif
2774         struct device_node *np = ndev->dev.of_node;
2775         struct resource *res;
2776         struct resource dt_res;
2777         struct resource *base_res;
2778         struct resource *fb_mem = NULL;
2779         int ret = 0;
2780         void __iomem *base;
2781         int irq;
2782         int i;
2783
2784         if (!np && !ndev->dev.platform_data) {
2785                 dev_err(&ndev->dev, "no platform data\n");
2786                 return -ENOENT;
2787         }
2788
2789         /* Specify parameters for the maximum physical segment size. */
2790         ndev->dev.dma_parms = &tegra_dc_dma_parameters;
2791
2792         dc = kzalloc(sizeof(struct tegra_dc), GFP_KERNEL);
2793         if (!dc) {
2794                 dev_err(&ndev->dev, "can't allocate memory for tegra_dc\n");
2795                 return -ENOMEM;
2796         }
2797
2798         if (np) {
2799                 dt_pdata = of_dc_parse_platform_data(ndev);
2800                 if (dt_pdata == NULL)
2801                         goto err_free;
2802
2803 #ifdef CONFIG_OF
2804                 irq = of_irq_to_resource(np, 0, NULL);
2805                 if (!irq)
2806                         goto err_free;
2807 #endif
2808
2809                 ret = of_address_to_resource(np, 0, &dt_res);
2810                 if (ret)
2811                         goto err_free;
2812
2813                 if (dt_res.start == TEGRA_DISPLAY_BASE)
2814                         ndev->id = 0;
2815                 else if (dt_res.start == TEGRA_DISPLAY2_BASE)
2816                         ndev->id = 1;
2817                 else
2818                         goto err_free;
2819
2820                 res = &dt_res;
2821         } else {
2822                 irq = platform_get_irq_byname(ndev, "irq");
2823                 if (irq <= 0) {
2824                         dev_err(&ndev->dev, "no irq\n");
2825                         ret = -ENOENT;
2826                         goto err_free;
2827                 }
2828
2829                 res = platform_get_resource_byname(ndev,
2830                         IORESOURCE_MEM, "regs");
2831                 if (!res) {
2832                         dev_err(&ndev->dev, "no mem resource\n");
2833                         ret = -ENOENT;
2834                         goto err_free;
2835                 }
2836         }
2837
2838         base_res = request_mem_region(res->start, resource_size(res),
2839                 ndev->name);
2840         if (!base_res) {
2841                 dev_err(&ndev->dev, "request_mem_region failed\n");
2842                 ret = -EBUSY;
2843                 goto err_free;
2844         }
2845
2846         base = ioremap(res->start, resource_size(res));
2847         if (!base) {
2848                 dev_err(&ndev->dev, "registers can't be mapped\n");
2849                 ret = -EBUSY;
2850                 goto err_release_resource_reg;
2851         }
2852
2853         for (i = 0; i < DC_N_WINDOWS; i++)
2854                 dc->win_syncpt[i] = NVSYNCPT_INVALID;
2855
2856         if (TEGRA_DISPLAY_BASE == res->start) {
2857                 dc->vblank_syncpt = NVSYNCPT_VBLANK0;
2858                 dc->win_syncpt[0] = NVSYNCPT_DISP0_A;
2859                 dc->win_syncpt[1] = NVSYNCPT_DISP0_B;
2860                 dc->win_syncpt[2] = NVSYNCPT_DISP0_C;
2861                 dc->valid_windows = 0x07;
2862 #ifdef CONFIG_ARCH_TEGRA_14x_SOC
2863                 dc->win_syncpt[3] = NVSYNCPT_DISP0_D;
2864                 dc->win_syncpt[4] = NVSYNCPT_DISP0_H;
2865                 dc->valid_windows |= 0x18;
2866 #elif defined(CONFIG_ARCH_TEGRA_12x_SOC)
2867                 dc->win_syncpt[3] = NVSYNCPT_DISP0_D;
2868                 dc->valid_windows |= 0x08;
2869 #endif
2870                 dc->powergate_id = TEGRA_POWERGATE_DISA;
2871 #ifdef CONFIG_TEGRA_ISOMGR
2872                 isomgr_client_id = TEGRA_ISO_CLIENT_DISP_0;
2873 #endif
2874         } else if (TEGRA_DISPLAY2_BASE == res->start) {
2875                 dc->vblank_syncpt = NVSYNCPT_VBLANK1;
2876                 dc->win_syncpt[0] = NVSYNCPT_DISP1_A;
2877                 dc->win_syncpt[1] = NVSYNCPT_DISP1_B;
2878                 dc->win_syncpt[2] = NVSYNCPT_DISP1_C;
2879                 dc->valid_windows = 0x07;
2880 #ifdef CONFIG_ARCH_TEGRA_14x_SOC
2881                 dc->win_syncpt[4] = NVSYNCPT_DISP1_H;
2882                 dc->valid_windows |= 0x10;
2883 #endif
2884                 dc->powergate_id = TEGRA_POWERGATE_DISB;
2885 #ifdef CONFIG_TEGRA_ISOMGR
2886                 isomgr_client_id = TEGRA_ISO_CLIENT_DISP_1;
2887 #endif
2888         } else {
2889                 dev_err(&ndev->dev,
2890                         "Unknown base address %llx: unable to assign syncpt\n",
2891                         (u64)res->start);
2892         }
2893
2894         if (np) {
2895                 struct resource of_fb_res;
2896                 if (ndev->id == 0)
2897                         tegra_get_fb_resource(&of_fb_res);
2898                 else /*ndev->id == 1*/
2899                         tegra_get_fb2_resource(&of_fb_res);
2900
2901                 fb_mem = kzalloc(sizeof(struct resource), GFP_KERNEL);
2902                 if (fb_mem == NULL) {
2903                         ret = -ENOMEM;
2904                         goto err_iounmap_reg;
2905                 }
2906                 fb_mem->name = "fbmem";
2907                 fb_mem->flags = IORESOURCE_MEM;
2908                 fb_mem->start = (resource_size_t)of_fb_res.start;
2909                 fb_mem->end = (resource_size_t)of_fb_res.end;
2910         } else {
2911                 fb_mem = platform_get_resource_byname(ndev,
2912                         IORESOURCE_MEM, "fbmem");
2913         }
2914
2915         clk = clk_get(&ndev->dev, NULL);
2916         if (IS_ERR_OR_NULL(clk)) {
2917                 dev_err(&ndev->dev, "can't get clock\n");
2918                 ret = -ENOENT;
2919                 goto err_iounmap_reg;
2920         }
2921
2922         dc->clk = clk;
2923         dc->shift_clk_div.mul = dc->shift_clk_div.div = 1;
2924         /* Initialize one shot work delay, it will be assigned by dsi
2925          * according to refresh rate later. */
2926         dc->one_shot_delay_ms = 40;
2927
2928         dc->base_res = base_res;
2929         dc->base = base;
2930         dc->irq = irq;
2931         dc->ndev = ndev;
2932
2933         if (!np)
2934                 dc->pdata = ndev->dev.platform_data;
2935         else
2936                 dc->pdata = dt_pdata;
2937
2938         dc->bw_kbps = 0;
2939
2940         mutex_init(&dc->lock);
2941         mutex_init(&dc->one_shot_lock);
2942         mutex_init(&dc->lp_lock);
2943         init_completion(&dc->frame_end_complete);
2944         init_completion(&dc->crc_complete);
2945         init_waitqueue_head(&dc->wq);
2946         init_waitqueue_head(&dc->timestamp_wq);
2947 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
2948         INIT_WORK(&dc->reset_work, tegra_dc_reset_worker);
2949 #endif
2950         INIT_WORK(&dc->vblank_work, tegra_dc_vblank);
2951         dc->vblank_ref_count = 0;
2952 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC) && !defined(CONFIG_ARCH_TEGRA_3x_SOC)
2953         INIT_WORK(&dc->vpulse2_work, tegra_dc_vpulse2);
2954 #endif
2955         dc->vpulse2_ref_count = 0;
2956         INIT_DELAYED_WORK(&dc->underflow_work, tegra_dc_underflow_worker);
2957         INIT_DELAYED_WORK(&dc->one_shot_work, tegra_dc_one_shot_worker);
2958
2959         tegra_dc_init_lut_defaults(&dc->fb_lut);
2960
2961         dc->n_windows = DC_N_WINDOWS;
2962         for (i = 0; i < DC_N_WINDOWS; i++) {
2963                 struct tegra_dc_win *win = &dc->windows[i];
2964                 struct tegra_dc_win *tmp_win = &dc->tmp_wins[i];
2965                 if (!test_bit(i, &dc->valid_windows))
2966                         win->flags |= TEGRA_WIN_FLAG_INVALID;
2967                 win->idx = i;
2968                 win->dc = dc;
2969                 tmp_win->idx = i;
2970                 tmp_win->dc = dc;
2971                 tegra_dc_init_csc_defaults(&win->csc);
2972                 tegra_dc_init_lut_defaults(&win->lut);
2973         }
2974
2975         ret = tegra_dc_set(dc, ndev->id);
2976         if (ret < 0) {
2977                 dev_err(&ndev->dev, "can't add dc\n");
2978                 goto err_put_clk;
2979         }
2980
2981         platform_set_drvdata(ndev, dc);
2982
2983 #ifdef CONFIG_SWITCH
2984         dc->modeset_switch.name = dev_name(&ndev->dev);
2985         dc->modeset_switch.state = 0;
2986         dc->modeset_switch.print_state = switch_modeset_print_mode;
2987         ret = switch_dev_register(&dc->modeset_switch);
2988         if (ret < 0)
2989                 dev_err(&ndev->dev, "failed to register switch driver\n");
2990 #endif
2991
2992         tegra_dc_feature_register(dc);
2993
2994         if (dc->pdata->default_out) {
2995                 ret = tegra_dc_set_out(dc, dc->pdata->default_out);
2996                 if (ret < 0) {
2997                         dev_err(&dc->ndev->dev, "failed to initialize DC out ops\n");
2998                         goto err_put_clk;
2999                 }
3000         } else {
3001                 dev_err(&ndev->dev,
3002                         "No default output specified.  Leaving output disabled.\n");
3003         }
3004         dc->mode_dirty = false; /* ignore changes tegra_dc_set_out has done */
3005
3006 #ifndef CONFIG_TEGRA_ISOMGR
3007                 /*
3008                  * The emc is a shared clock, it will be set based on
3009                  * the requirements for each user on the bus.
3010                  */
3011                 emc_clk = clk_get(&ndev->dev, "emc");
3012                 if (IS_ERR_OR_NULL(emc_clk)) {
3013                         dev_err(&ndev->dev, "can't get emc clock\n");
3014                         ret = -ENOENT;
3015                         goto err_put_clk;
3016                 }
3017                 dc->emc_clk = emc_clk;
3018 #endif
3019
3020         dc->ext = tegra_dc_ext_register(ndev, dc);
3021         if (IS_ERR_OR_NULL(dc->ext)) {
3022                 dev_warn(&ndev->dev, "Failed to enable Tegra DC extensions.\n");
3023                 dc->ext = NULL;
3024         }
3025
3026         /* interrupt handler must be registered before tegra_fb_register() */
3027         if (request_threaded_irq(irq, NULL, tegra_dc_irq, IRQF_ONESHOT,
3028                         dev_name(&ndev->dev), dc)) {
3029                 dev_err(&ndev->dev, "request_irq %d failed\n", irq);
3030                 ret = -EBUSY;
3031                 goto err_disable_dc;
3032         }
3033         disable_dc_irq(dc);
3034
3035         tegra_pd_add_device(&ndev->dev);
3036         pm_runtime_use_autosuspend(&ndev->dev);
3037         pm_runtime_set_autosuspend_delay(&ndev->dev, 100);
3038         pm_runtime_enable(&ndev->dev);
3039
3040 #ifdef CONFIG_TEGRA_DC_CMU
3041         /* if bootloader leaves this head enabled, then skip CMU programming. */
3042         dc->cmu_dirty = (dc->pdata->flags & TEGRA_DC_FLAG_ENABLED) == 0;
3043         dc->cmu_enabled = dc->pdata->cmu_enable;
3044 #endif
3045
3046         if (dc->pdata->flags & TEGRA_DC_FLAG_ENABLED) {
3047                 _tegra_dc_set_default_videomode(dc);
3048                 dc->enabled = _tegra_dc_enable(dc);
3049
3050 #if !defined(CONFIG_ARCH_TEGRA_11x_SOC) && !defined(CONFIG_ARCH_TEGRA_14x_SOC)
3051                 /* BL or PG init will keep DISA unpowergated after booting.
3052                  * Adding an extra powergate to balance the refcount
3053                  * since _tegra_dc_enable() increases the refcount.
3054                  */
3055                 if (dc->powergate_id == TEGRA_POWERGATE_DISA)
3056                         tegra_dc_powergate_locked(dc);
3057 #endif
3058         }
3059
3060 #ifdef CONFIG_TEGRA_ISOMGR
3061         if (isomgr_client_id == -1) {
3062                 dc->isomgr_handle = NULL;
3063         } else {
3064                 dc->isomgr_handle = tegra_isomgr_register(isomgr_client_id,
3065                         tegra_dc_calc_min_bandwidth(dc),
3066                         tegra_dc_bandwidth_renegotiate, dc);
3067                 if (IS_ERR(dc->isomgr_handle)) {
3068                         dev_err(&dc->ndev->dev,
3069                                 "could not register isomgr. err=%ld\n",
3070                                 PTR_ERR(dc->isomgr_handle));
3071                         ret = -ENOENT;
3072                         goto err_put_clk;
3073                 }
3074                 dc->reserved_bw = tegra_dc_calc_min_bandwidth(dc);
3075                 /*
3076                  * Use maximum value so we can try to reserve as much as
3077                  * needed until we are told by isomgr to backoff.
3078                  */
3079                 dc->available_bw = UINT_MAX;
3080         }
3081 #endif
3082
3083         tegra_dc_create_debugfs(dc);
3084
3085         dev_info(&ndev->dev, "probed\n");
3086
3087         if (dc->pdata->fb) {
3088                 if (dc->enabled && dc->pdata->fb->bits_per_pixel == -1) {
3089                         unsigned long fmt;
3090                         tegra_dc_writel(dc,
3091                                         WINDOW_A_SELECT << dc->pdata->fb->win,
3092                                         DC_CMD_DISPLAY_WINDOW_HEADER);
3093
3094                         fmt = tegra_dc_readl(dc, DC_WIN_COLOR_DEPTH);
3095                         dc->pdata->fb->bits_per_pixel =
3096                                 tegra_dc_fmt_bpp(fmt);
3097                 }
3098
3099                 mode = tegra_dc_get_override_mode(dc);
3100                 if (mode) {
3101                         dc->pdata->fb->xres = mode->h_active;
3102                         dc->pdata->fb->yres = mode->v_active;
3103                 }
3104
3105                 tegra_dc_io_start(dc);
3106                 dc->fb = tegra_fb_register(ndev, dc, dc->pdata->fb, fb_mem);
3107                 tegra_dc_io_end(dc);
3108                 if (IS_ERR_OR_NULL(dc->fb)) {
3109                         dc->fb = NULL;
3110                         dev_err(&ndev->dev, "failed to register fb\n");
3111                         goto err_remove_debugfs;
3112                 }
3113         }
3114
3115         if (dc->out && dc->out->hotplug_init)
3116                 dc->out->hotplug_init(&ndev->dev);
3117
3118         if (dc->out_ops) {
3119                 if (dc->out_ops->detect)
3120                         dc->connected = dc->out_ops->detect(dc);
3121                 else
3122                         dc->connected = true;
3123         }
3124         else
3125                 dc->connected = false;
3126
3127         /* Powergate display module when it's unconnected. */
3128         /* detect() function, if presetns, responsible for the powergate */
3129         if (!tegra_dc_get_connected(dc) &&
3130                         !(dc->out_ops && dc->out_ops->detect))
3131                 tegra_dc_powergate_locked(dc);
3132
3133         tegra_dc_create_sysfs(&dc->ndev->dev);
3134
3135         /*
3136          * Overriding the display mode only applies for modes set up during
3137          * boot. It should not apply for e.g. HDMI hotplug.
3138          */
3139         dc->initialized = false;
3140
3141         return 0;
3142
3143 err_remove_debugfs:
3144         tegra_dc_remove_debugfs(dc);
3145         free_irq(irq, dc);
3146 err_disable_dc:
3147         if (dc->ext) {
3148                 tegra_dc_ext_disable(dc->ext);
3149                 tegra_dc_ext_unregister(dc->ext);
3150         }
3151         mutex_lock(&dc->lock);
3152         if (dc->enabled)
3153                 _tegra_dc_disable(dc);
3154         dc->enabled = false;
3155         mutex_unlock(&dc->lock);
3156 #ifdef CONFIG_SWITCH
3157         switch_dev_unregister(&dc->modeset_switch);
3158 #endif
3159 #ifdef CONFIG_TEGRA_ISOMGR
3160         tegra_isomgr_unregister(dc->isomgr_handle);
3161 #else
3162         clk_put(emc_clk);
3163 #endif
3164 err_put_clk:
3165         clk_put(clk);
3166 err_iounmap_reg:
3167         iounmap(base);
3168         if (fb_mem) {
3169                 if (!np)
3170                         release_resource(fb_mem);
3171                 else
3172                         kfree(fb_mem);
3173         }
3174 err_release_resource_reg:
3175         release_resource(base_res);
3176 err_free:
3177         kfree(dc);
3178
3179         return ret;
3180 }
3181
3182 static int tegra_dc_remove(struct platform_device *ndev)
3183 {
3184         struct tegra_dc *dc = platform_get_drvdata(ndev);
3185         struct device_node *np = ndev->dev.of_node;
3186
3187         tegra_dc_remove_sysfs(&dc->ndev->dev);
3188         tegra_dc_remove_debugfs(dc);
3189
3190         if (dc->fb) {
3191                 tegra_fb_unregister(dc->fb);
3192                 if (dc->fb_mem) {
3193                         if (!np)
3194                                 release_resource(dc->fb_mem);
3195                         else
3196                                 kfree(dc->fb_mem);
3197                 }
3198         }
3199
3200         tegra_dc_ext_disable(dc->ext);
3201
3202         if (dc->ext)
3203                 tegra_dc_ext_unregister(dc->ext);
3204
3205         mutex_lock(&dc->lock);
3206         if (dc->enabled)
3207                 _tegra_dc_disable(dc);
3208         dc->enabled = false;
3209         mutex_unlock(&dc->lock);
3210         synchronize_irq(dc->irq); /* wait for IRQ handlers to finish */
3211
3212 #ifdef CONFIG_SWITCH
3213         switch_dev_unregister(&dc->modeset_switch);
3214 #endif
3215         free_irq(dc->irq, dc);
3216 #ifdef CONFIG_TEGRA_ISOMGR
3217         if (dc->isomgr_handle) {
3218                 tegra_isomgr_unregister(dc->isomgr_handle);
3219                 dc->isomgr_handle = NULL;
3220         }
3221 #else
3222         clk_put(dc->emc_clk);
3223 #endif
3224         clk_put(dc->clk);
3225         iounmap(dc->base);
3226         if (dc->fb_mem)
3227                 release_resource(dc->base_res);
3228         kfree(dc);
3229         tegra_dc_set(NULL, ndev->id);
3230
3231         return 0;
3232 }
3233
3234 #ifdef CONFIG_PM
3235 static int tegra_dc_suspend(struct platform_device *ndev, pm_message_t state)
3236 {
3237         struct tegra_dc *dc = platform_get_drvdata(ndev);
3238         int ret = 0;
3239
3240         trace_display_suspend(dc);
3241         dev_info(&ndev->dev, "suspend\n");
3242
3243         tegra_dc_ext_disable(dc->ext);
3244
3245         mutex_lock(&dc->lock);
3246         ret = tegra_dc_io_start(dc);
3247
3248         if (dc->out_ops && dc->out_ops->suspend)
3249                 dc->out_ops->suspend(dc);
3250
3251         if (dc->enabled) {
3252                 _tegra_dc_disable(dc);
3253
3254                 dc->suspended = true;
3255         }
3256
3257         if (dc->out && dc->out->postsuspend) {
3258                 dc->out->postsuspend();
3259                 /* avoid resume event due to voltage falling on interfaces that
3260                  * support hotplug wake. And only do this if a panel is
3261                  * connected, if we are already disconnected, then no phantom
3262                  * hotplug can occur by disabling the voltage.
3263                  */
3264                 if ((dc->out->flags & TEGRA_DC_OUT_HOTPLUG_WAKE_LP0)
3265                         && tegra_dc_get_connected(dc))
3266                         msleep(100);
3267         }
3268
3269         if (!ret)
3270                 tegra_dc_io_end(dc);
3271
3272 #ifdef CONFIG_TEGRA_DC_CMU
3273         /*
3274          * CMU settings are lost when the DC goes to sleep. User-space will
3275          * perform a blank ioctl upon resume which will call tegra_dc_init()
3276          * and apply CMU settings again, but only if the cached values are
3277          * different from those specified. Clearing the cache here ensures
3278          * that this will happen.
3279          *
3280          * It would be better to reapply the CMU settings in tegra_dc_resume(),
3281          * but color corruption sometimes happens if we do so and
3282          * tegra_dc_init() seems to be the only safe place for this.
3283          */
3284         memset(&dc->cmu, 0, sizeof(dc->cmu));
3285 #endif
3286
3287         mutex_unlock(&dc->lock);
3288         synchronize_irq(dc->irq); /* wait for IRQ handlers to finish */
3289
3290         return 0;
3291 }
3292
3293 static int tegra_dc_resume(struct platform_device *ndev)
3294 {
3295         struct tegra_dc *dc = platform_get_drvdata(ndev);
3296
3297         trace_display_resume(dc);
3298         dev_info(&ndev->dev, "resume\n");
3299
3300         mutex_lock(&dc->lock);
3301         dc->suspended = false;
3302
3303         /* To pan the fb on resume */
3304         tegra_fb_pan_display_reset(dc->fb);
3305
3306         if (dc->enabled) {
3307                 dc->enabled = false;
3308                 _tegra_dc_set_default_videomode(dc);
3309                 dc->enabled = _tegra_dc_enable(dc);
3310         }
3311
3312         if (dc->out && dc->out->hotplug_init)
3313                 dc->out->hotplug_init(&ndev->dev);
3314
3315         if (dc->out_ops && dc->out_ops->resume)
3316                 dc->out_ops->resume(dc);
3317
3318         mutex_unlock(&dc->lock);
3319
3320         return 0;
3321 }
3322
3323 #endif /* CONFIG_PM */
3324
3325 static void tegra_dc_shutdown(struct platform_device *ndev)
3326 {
3327         struct tegra_dc *dc = platform_get_drvdata(ndev);
3328
3329         if (WARN_ON(!dc || !dc->out || !dc->out_ops))
3330                 return;
3331
3332         if (!dc->enabled)
3333                 return;
3334
3335         tegra_dc_disable(dc);
3336 }
3337
3338 extern int suspend_set(const char *val, struct kernel_param *kp)
3339 {
3340         if (!strcmp(val, "dump"))
3341                 dump_regs(tegra_dcs[0]);
3342 #ifdef CONFIG_PM
3343         else if (!strcmp(val, "suspend"))
3344                 tegra_dc_suspend(tegra_dcs[0]->ndev, PMSG_SUSPEND);
3345         else if (!strcmp(val, "resume"))
3346                 tegra_dc_resume(tegra_dcs[0]->ndev);
3347 #endif
3348
3349         return 0;
3350 }
3351
3352 extern int suspend_get(char *buffer, struct kernel_param *kp)
3353 {
3354         return 0;
3355 }
3356
3357 int suspend;
3358
3359 module_param_call(suspend, suspend_set, suspend_get, &suspend, 0644);
3360
3361
3362 #ifdef CONFIG_OF
3363 static struct of_device_id tegra_display_of_match[] = {
3364         {.compatible = "nvidia,tegra114-dc", },
3365         {.compatible = "nvidia,tegra124-dc", },
3366         { },
3367 };
3368 #endif
3369
3370 struct platform_driver tegra_dc_driver = {
3371         .driver = {
3372                 .name = "tegradc",
3373                 .owner = THIS_MODULE,
3374 #ifdef CONFIG_OF
3375                 .of_match_table =
3376                         of_match_ptr(tegra_display_of_match),
3377 #endif
3378         },
3379         .probe = tegra_dc_probe,
3380         .remove = tegra_dc_remove,
3381 #ifdef CONFIG_PM
3382         .suspend = tegra_dc_suspend,
3383         .resume = tegra_dc_resume,
3384 #endif
3385         .shutdown = tegra_dc_shutdown,
3386 };
3387
3388 #ifndef MODULE
3389 static int __init parse_disp_params(char *options, struct tegra_dc_mode *mode)
3390 {
3391         int i, params[11];
3392         char *p;
3393
3394         for (i = 0; i < ARRAY_SIZE(params); i++) {
3395                 if ((p = strsep(&options, ",")) != NULL) {
3396                         if (*p)
3397                                 params[i] = simple_strtoul(p, &p, 10);
3398                 } else
3399                         return -EINVAL;
3400         }
3401
3402         if ((mode->pclk = params[0]) == 0)
3403                 return -EINVAL;
3404
3405         mode->h_active      = params[1];
3406         mode->v_active      = params[2];
3407         mode->h_ref_to_sync = params[3];
3408         mode->v_ref_to_sync = params[4];
3409         mode->h_sync_width  = params[5];
3410         mode->v_sync_width  = params[6];
3411         mode->h_back_porch  = params[7];
3412         mode->v_back_porch  = params[8];
3413         mode->h_front_porch = params[9];
3414         mode->v_front_porch = params[10];
3415
3416         return 0;
3417 }
3418
3419 static int __init tegra_dc_mode_override(char *str)
3420 {
3421         char *p = str, *options;
3422
3423         if (!p || !*p)
3424                 return -EINVAL;
3425
3426         p = strstr(str, "hdmi:");
3427         if (p) {
3428                 p += 5;
3429                 options = strsep(&p, ";");
3430                 if (parse_disp_params(options, &override_disp_mode[TEGRA_DC_OUT_HDMI]))
3431                         return -EINVAL;
3432         }
3433
3434         p = strstr(str, "rgb:");
3435         if (p) {
3436                 p += 4;
3437                 options = strsep(&p, ";");
3438                 if (parse_disp_params(options, &override_disp_mode[TEGRA_DC_OUT_RGB]))
3439                         return -EINVAL;
3440         }
3441
3442         p = strstr(str, "dsi:");
3443         if (p) {
3444                 p += 4;
3445                 options = strsep(&p, ";");
3446                 if (parse_disp_params(options, &override_disp_mode[TEGRA_DC_OUT_DSI]))
3447                         return -EINVAL;
3448         }
3449
3450         return 0;
3451 }
3452
3453 __setup("disp_params=", tegra_dc_mode_override);
3454 #endif
3455
3456 static int __init tegra_dc_module_init(void)
3457 {
3458         int ret = tegra_dc_ext_module_init();
3459         if (ret)
3460                 return ret;
3461         return platform_driver_register(&tegra_dc_driver);
3462 }
3463
3464 static void __exit tegra_dc_module_exit(void)
3465 {
3466         platform_driver_unregister(&tegra_dc_driver);
3467         tegra_dc_ext_module_exit();
3468 }
3469
3470 module_exit(tegra_dc_module_exit);
3471 module_init(tegra_dc_module_init);