drivers/video/rockchip/hdmi/rockchip-hdmiv2/rockchip_hdmiv2_hw.c

   1 #include <linux/clk.h>
   2 #include <linux/delay.h>
   3 #include <linux/interrupt.h>
   4 #include <linux/rockchip/cru.h>
   5 #include <linux/rockchip/grf.h>
   6 #include <linux/rockchip/iomap.h>
   7 #include "rockchip_hdmiv2.h"
   8 #include "rockchip_hdmiv2_hw.h"
   9
  10 static const struct phy_mpll_config_tab PHY_MPLL_TABLE[] = {
  11 /*      tmdsclk = (pixclk / ref_cntrl ) * (fbdiv2 * fbdiv1) / nctrl / tmdsmhl
  12  *      opmode: 0:HDMI1.4       1:HDMI2.0
  13  *
  14  *      |pixclock|      tmdsclock|pixrepet|colordepth|prepdiv|tmdsmhl|opmode|
  15  *              fbdiv2|fbdiv1|ref_cntrl|nctrl|propctrl|intctrl|gmpctrl|
  16  */
  17         {27000000,      27000000,       0,      8,      0,      0,      0,
  18                 2,      3,      0,      3,      3,      0,      0},
  19         {27000000,      33750000,       0,      10,     1,      0,      0,
  20                 5,      1,      0,      3,      3,      0,      0},
  21         {27000000,      40500000,       0,      12,     2,      0,      0,
  22                 3,      3,      0,      3,      3,      0,      0},
  23         {27000000,      54000000,       0,      16,     3,      0,      0,
  24                 2,      3,      0,      2,      5,      0,      1},
  25         {59400000,      59400000,       0,      8,      0,      0,      0,
  26                 1,      3,      0,      2,      5,      0,      1},
  27         {59400000,      74250000,       0,      10,     1,      0,      0,
  28                 5,      0,      0,      2,      5,      0,      1},
  29         {59400000,      89100000,       0,      12,     2,      0,      0,
  30                 2,      2,      0,      2,      5,      0,      1},
  31         {59400000,      118800000,      0,      16,     3,      0,      0,
  32                 1,      3,      0,      1,      7,      0,      2},
  33         {65000000,      65000000,       0,      8,      0,      0,      0,
  34                 1,      3,      0,      2,      5,      0,      1},
  35         {74250000,      74250000,       0,      8,      0,      0,      0,
  36                 4,      3,      3,      2,      7,      0,      3},
  37         {74250000,      92812500,       0,      10,     1,      0,      0,
  38                 5,      0,      1,      1,      7,      0,      2},
  39         {74250000,      111375000,      0,      12,     2,      0,      0,
  40                 1,      2,      0,      1,      7,      0,      2},
  41         {74250000,      148500000,      0,      16,     3,      0,      0,
  42                 1,      3,      0,      1,      7,      0,      2},
  43         {83500000,      83500000,       0,      8,      0,      0,      0,
  44                 1,      3,      0,      2,      5,      0,      1},
  45         {85500000,      85500000,       0,      8,      0,      0,      0,
  46                 1,      3,      0,      2,      5,      0,      1},
  47         {106500000,     106500000,      0,      8,      0,      0,      0,
  48                 1,      1,      0,      1,      7,      0,      2},
  49         {108000000,     108000000,      0,      8,      0,      0,      0,
  50                 1,      1,      0,      1,      7,      0,      2},
  51         {146250000,     146250000,      0,      8,      0,      0,      0,
  52                 1,      1,      0,      1,      7,      0,      2},
  53         {148500000,     74250000,       0,      8,      0,      0,      0,
  54                 1,      1,      1,      1,      0,      0,      3},
  55         {148500000,     148500000,      0,      8,      0,      0,      0,
  56                 1,      1,      0,      1,      0,      0,      3},
  57         {148500000,     185625000,      0,      10,     1,      0,      0,
  58                 5,      0,      3,      0,      7,      0,      3},
  59         {148500000,     222750000,      0,      12,     2,      0,      0,
  60                 1,      2,      1,      0,      7,      0,      3},
  61         {148500000,     297000000,      0,      16,     3,      0,      0,
  62                 1,      1,      0,      0,      7,      0,      3},
  63         {148500000,     297000000,      0,      8,      0,      0,      0,
  64                 1,      1,      0,      0,      0,      0,      3},
  65         {148500000,     594000000,      0,      8,      0,      3,      1,
  66                 1,      3,      0,      0,      0,      0,      3},
  67         {297000000,     148500000,      0,      8,      0,      0,      0,
  68                 1,      0,      1,      0,      0,      0,      3},
  69         {297000000,     297000000,      0,      8,      0,      0,      0,
  70                 1,      0,      0,      0,      0,      0,      3},
  71         {297000000,     371250000,      0,      10,     1,      3,      1,
  72                 5,      1,      3,      1,      7,      0,      3},
  73         {297000000,     445500000,      0,      12,     2,      3,      1,
  74                 1,      2,      0,      1,      7,      0,      3},
  75         {297000000,     594000000,      0,      16,     3,      3,      1,
  76                 1,      3,      1,      0,      0,      0,      3},
  77         {594000000,     297000000,      0,      8,      0,      0,      0,
  78                 1,      0,      1,      0,      0,      0,      3},
  79         {594000000,     371250000,      0,      10,     1,      3,      1,
  80                 5,      0,      3,      0,      7,      0,      3},
  81         {594000000,     445500000,      0,      12,     2,      3,      1,
  82                 1,      2,      1,      1,      7,      0,      3},
  83         {594000000,     594000000,      0,      16,     3,      3,      1,
  84                 1,      3,      3,      0,      0,      0,      3},
  85         {594000000,     594000000,      0,      8,      0,      3,      1,
  86                 1,      3,      3,      0,      0,      0,      3},
  87 };
  88
  89 static const struct ext_pll_config_tab EXT_PLL_TABLE[] = {
  90         {27000000,      27000000,       8,      1,      90,     3,      2,
  91                 2,      10,     3,      3,      4,      0,      1,      40,
  92                 8},
  93         {27000000,      33750000,       10,     1,      90,     1,      3,
  94                 3,      10,     3,      3,      4,      0,      1,      40,
  95                 8},
  96         {59400000,      59400000,       8,      1,      99,     3,      2,
  97                 2,      1,      3,      3,      4,      0,      1,      40,
  98                 8},
  99         {59400000,      74250000,       10,     1,      99,     1,      2,
 100                 2,      1,      3,      3,      4,      0,      1,      40,
 101                 8},
 102         {74250000,      74250000,       8,      1,      99,     1,      2,
 103                 2,      1,      2,      3,      4,      0,      1,      40,
 104                 8},
 105         {74250000,      92812500,       10,     4,      495,    1,      2,
 106                 2,      1,      3,      3,      4,      0,      2,      40,
 107                 4},
 108         {148500000,     148500000,      8,      1,      99,     1,      1,
 109                 1,      1,      2,      2,      2,      0,      2,      40,
 110                 4},
 111         {148500000,     185625000,      10,     4,      495,    0,      2,
 112                 2,      1,      3,      2,      2,      0,      4,      40,
 113                 2},
 114         {297000000,     297000000,      8,      1,      99,     0,      1,
 115                 1,      1,      0,      2,      2,      0,      4,      40,
 116                 2},
 117         {297000000,     371250000,      10,     4,      495,    1,      2,
 118                 0,      1,      3,      1,      1,      0,      8,      40,
 119                 1},
 120         {594000000,     297000000,      8,      1,      99,     0,      1,
 121                 1,      1,      0,      2,      1,      0,      4,      40,
 122                 2},
 123         {594000000,     371250000,      10,     4,      495,    1,      2,
 124                 0,      1,      3,      1,      1,      1,      8,      40,
 125                 1},
 126         {594000000,     594000000,      8,      1,      99,     0,      2,
 127                 0,      1,      0,      1,      1,      0,      8,      40,
 128                 1},
 129 };
 130
 131 /* ddc i2c master reset */
 132 static void rockchip_hdmiv2_i2cm_reset(struct hdmi_dev *hdmi_dev)
 133 {
 134         hdmi_msk_reg(hdmi_dev, I2CM_SOFTRSTZ,
 135                      m_I2CM_SOFTRST, v_I2CM_SOFTRST(0));
 136         usleep_range(90, 100);
 137 }
 138
 139 /*set read/write offset,set read/write mode*/
 140 static void rockchip_hdmiv2_i2cm_write_request(struct hdmi_dev *hdmi_dev,
 141                                                u8 offset, u8 data)
 142 {
 143         hdmi_writel(hdmi_dev, I2CM_ADDRESS, offset);
 144         hdmi_writel(hdmi_dev, I2CM_DATAO, data);
 145         hdmi_msk_reg(hdmi_dev, I2CM_OPERATION, m_I2CM_WR, v_I2CM_WR(1));
 146 }
 147
 148 static void rockchip_hdmiv2_i2cm_read_request(struct hdmi_dev *hdmi_dev,
 149                                               u8 offset)
 150 {
 151         hdmi_writel(hdmi_dev, I2CM_ADDRESS, offset);
 152         hdmi_msk_reg(hdmi_dev, I2CM_OPERATION, m_I2CM_RD, v_I2CM_RD(1));
 153 }
 154
 155 static void rockchip_hdmiv2_i2cm_write_data(struct hdmi_dev *hdmi_dev,
 156                                             u8 data, u8 offset)
 157 {
 158         u8 interrupt;
 159         int trytime = 2;
 160         int i = 20;
 161
 162         while (trytime-- > 0) {
 163                 rockchip_hdmiv2_i2cm_write_request(hdmi_dev, offset, data);
 164                 while (i--) {
 165                         usleep_range(900, 1000);
 166                         interrupt = hdmi_readl(hdmi_dev, IH_I2CM_STAT0);
 167                         if (interrupt)
 168                                 hdmi_writel(hdmi_dev,
 169                                             IH_I2CM_STAT0, interrupt);
 170
 171                         if (interrupt & (m_SCDC_READREQ |
 172                                          m_I2CM_DONE | m_I2CM_ERROR))
 173                                 break;
 174                 }
 175
 176                 if (interrupt & m_I2CM_DONE) {
 177                         dev_dbg(hdmi_dev->hdmi->dev,
 178                                 "[%s] write offset %02x data %02x success\n",
 179                                 __func__, offset, data);
 180                         trytime = 0;
 181                 } else if ((interrupt & m_I2CM_ERROR) || (i == -1)) {
 182                         dev_err(hdmi_dev->hdmi->dev,
 183                                 "[%s] write data error\n", __func__);
 184                         rockchip_hdmiv2_i2cm_reset(hdmi_dev);
 185                 }
 186         }
 187 }
 188
 189 static int rockchip_hdmiv2_i2cm_read_data(struct hdmi_dev *hdmi_dev, u8 offset)
 190 {
 191         u8 interrupt, val;
 192         int trytime = 2;
 193         int i = 20;
 194
 195         while (trytime-- > 0) {
 196                 rockchip_hdmiv2_i2cm_read_request(hdmi_dev, offset);
 197                 while (i--) {
 198                         usleep_range(900, 1000);
 199                         interrupt = hdmi_readl(hdmi_dev, IH_I2CM_STAT0);
 200                         if (interrupt)
 201                                 hdmi_writel(hdmi_dev, IH_I2CM_STAT0, interrupt);
 202
 203                         if (interrupt & (m_SCDC_READREQ |
 204                                 m_I2CM_DONE | m_I2CM_ERROR))
 205                                 break;
 206                 }
 207
 208                 if (interrupt & m_I2CM_DONE) {
 209                         val = hdmi_readl(hdmi_dev, I2CM_DATAI);
 210                         trytime = 0;
 211                 } else if ((interrupt & m_I2CM_ERROR) || (i == -1)) {
 212                         pr_err("[%s] read data error\n", __func__);
 213                         rockchip_hdmiv2_i2cm_reset(hdmi_dev);
 214                 }
 215         }
 216         return val;
 217 }
 218
 219 static void rockchip_hdmiv2_i2cm_mask_int(struct hdmi_dev *hdmi_dev, int mask)
 220 {
 221         if (!mask) {
 222                 hdmi_msk_reg(hdmi_dev, I2CM_INT,
 223                              m_I2CM_DONE_MASK, v_I2CM_DONE_MASK(0));
 224                 hdmi_msk_reg(hdmi_dev, I2CM_CTLINT,
 225                              m_I2CM_NACK_MASK | m_I2CM_ARB_MASK,
 226                              v_I2CM_NACK_MASK(0) | v_I2CM_ARB_MASK(0));
 227         } else {
 228                 hdmi_msk_reg(hdmi_dev, I2CM_INT,
 229                              m_I2CM_DONE_MASK, v_I2CM_DONE_MASK(1));
 230                 hdmi_msk_reg(hdmi_dev, I2CM_CTLINT,
 231                              m_I2CM_NACK_MASK | m_I2CM_ARB_MASK,
 232                              v_I2CM_NACK_MASK(1) | v_I2CM_ARB_MASK(1));
 233         }
 234 }
 235
 236 #define I2C_DIV_FACTOR 1000000
 237 static u16 i2c_count(u16 sfrclock, u16 sclmintime)
 238 {
 239         unsigned long tmp_scl_period = 0;
 240
 241         if (((sfrclock * sclmintime) % I2C_DIV_FACTOR) != 0)
 242                 tmp_scl_period = (unsigned long)((sfrclock * sclmintime) +
 243                                 (I2C_DIV_FACTOR - ((sfrclock * sclmintime) %
 244                                 I2C_DIV_FACTOR))) / I2C_DIV_FACTOR;
 245         else
 246                 tmp_scl_period = (unsigned long)(sfrclock * sclmintime) /
 247                                 I2C_DIV_FACTOR;
 248
 249         return (u16)(tmp_scl_period);
 250 }
 251
 252 #define EDID_I2C_MIN_SS_SCL_HIGH_TIME   9625
 253 #define EDID_I2C_MIN_SS_SCL_LOW_TIME    10000
 254
 255 static void rockchip_hdmiv2_i2cm_clk_init(struct hdmi_dev *hdmi_dev)
 256 {
 257         int value;
 258
 259         /* Set DDC I2C CLK which divided from DDC_CLK. */
 260         value = i2c_count(24000, EDID_I2C_MIN_SS_SCL_HIGH_TIME);
 261         hdmi_writel(hdmi_dev, I2CM_SS_SCL_HCNT_0_ADDR,
 262                     value & 0xff);
 263         hdmi_writel(hdmi_dev, I2CM_SS_SCL_HCNT_1_ADDR,
 264                     (value >> 8) & 0xff);
 265         value = i2c_count(24000, EDID_I2C_MIN_SS_SCL_LOW_TIME);
 266         hdmi_writel(hdmi_dev, I2CM_SS_SCL_LCNT_0_ADDR,
 267                     value & 0xff);
 268         hdmi_writel(hdmi_dev, I2CM_SS_SCL_LCNT_1_ADDR,
 269                     (value >> 8) & 0xff);
 270         hdmi_msk_reg(hdmi_dev, I2CM_DIV, m_I2CM_FAST_STD_MODE,
 271                      v_I2CM_FAST_STD_MODE(STANDARD_MODE));
 272 }
 273
 274 static int rockchip_hdmiv2_scdc_get_sink_version(struct hdmi_dev *hdmi_dev)
 275 {
 276         return rockchip_hdmiv2_i2cm_read_data(hdmi_dev, SCDC_SINK_VER);
 277 }
 278
 279 static void rockchip_hdmiv2_scdc_set_source_version(struct hdmi_dev *hdmi_dev,
 280                                                     u8 version)
 281 {
 282         rockchip_hdmiv2_i2cm_write_data(hdmi_dev, version, SCDC_SOURCE_VER);
 283 }
 284
 285 static void rockchip_hdmiv2_scdc_read_request(struct hdmi_dev *hdmi_dev,
 286                                               int enable)
 287 {
 288         hdmi_msk_reg(hdmi_dev, I2CM_SCDC_READ_UPDATE,
 289                      m_I2CM_READ_REQ_EN, v_I2CM_READ_REQ_EN(enable));
 290         rockchip_hdmiv2_i2cm_write_data(hdmi_dev, enable, SCDC_CONFIG_0);
 291 }
 292
 293 #ifdef HDMI_20_SCDC
 294 static void rockchip_hdmiv2_scdc_update_read(struct hdmi_dev *hdmi_dev)
 295 {
 296         hdmi_msk_reg(hdmi_dev, I2CM_SCDC_READ_UPDATE,
 297                      m_I2CM_READ_UPDATE, v_I2CM_READ_UPDATE(1));
 298 }
 299
 300 static int rockchip_hdmiv2_scdc_get_scambling_status(struct hdmi_dev *hdmi_dev)
 301 {
 302         int val;
 303
 304         val = rockchip_hdmiv2_i2cm_read_data(hdmi_dev, SCDC_SCRAMBLER_STAT);
 305         return val;
 306 }
 307
 308 static void rockchip_hdmiv2_scdc_enable_polling(struct hdmi_dev *hdmi_dev,
 309                                                 int enable)
 310 {
 311         rockchip_hdmiv2_scdc_read_request(hdmi_dev, enable);
 312         hdmi_msk_reg(hdmi_dev, I2CM_SCDC_READ_UPDATE,
 313                      m_I2CM_UPRD_VSYNC_EN, v_I2CM_UPRD_VSYNC_EN(enable));
 314 }
 315
 316 static int rockchip_hdmiv2_scdc_get_status_reg0(struct hdmi_dev *hdmi_dev)
 317 {
 318         rockchip_hdmiv2_scdc_read_request(hdmi_dev, 1);
 319         rockchip_hdmiv2_scdc_update_read(hdmi_dev);
 320         return hdmi_readl(hdmi_dev, I2CM_SCDC_UPDATE0);
 321 }
 322
 323 static int rockchip_hdmiv2_scdc_get_status_reg1(struct hdmi_dev *hdmi_dev)
 324 {
 325         rockchip_hdmiv2_scdc_read_request(hdmi_dev, 1);
 326         rockchip_hdmiv2_scdc_update_read(hdmi_dev);
 327         return hdmi_readl(hdmi_dev, I2CM_SCDC_UPDATE1);
 328 }
 329 #endif
 330
 331 static void rockchip_hdmiv2_scdc_init(struct hdmi_dev *hdmi_dev)
 332 {
 333         rockchip_hdmiv2_i2cm_reset(hdmi_dev);
 334         rockchip_hdmiv2_i2cm_mask_int(hdmi_dev, 1);
 335         rockchip_hdmiv2_i2cm_clk_init(hdmi_dev);
 336         /* set scdc i2c addr */
 337         hdmi_writel(hdmi_dev, I2CM_SLAVE, DDC_I2C_SCDC_ADDR);
 338         rockchip_hdmiv2_i2cm_mask_int(hdmi_dev, 0);/*enable interrupt*/
 339 }
 340
 341 static void rockchip_hdmiv2_scdc_set_tmds_rate(struct hdmi_dev *hdmi_dev)
 342 {
 343         int stat;
 344
 345         mutex_lock(&hdmi_dev->ddc_lock);
 346         rockchip_hdmiv2_scdc_init(hdmi_dev);
 347         stat = rockchip_hdmiv2_i2cm_read_data(hdmi_dev,
 348                                               SCDC_TMDS_CONFIG);
 349         if (hdmi_dev->tmdsclk > 340000000)
 350                 stat |= 2;
 351         else
 352                 stat &= 0x1;
 353         rockchip_hdmiv2_i2cm_write_data(hdmi_dev,
 354                                         stat, SCDC_TMDS_CONFIG);
 355         mutex_unlock(&hdmi_dev->ddc_lock);
 356 }
 357
 358 static int rockchip_hdmiv2_scrambling_enable(struct hdmi_dev *hdmi_dev,
 359                                              int enable)
 360 {
 361         HDMIDBG("%s enable %d\n", __func__, enable);
 362         if (enable == 1) {
 363                 /* Write on Rx the bit Scrambling_Enable, register 0x20 */
 364                 rockchip_hdmiv2_i2cm_write_data(hdmi_dev, 1, SCDC_TMDS_CONFIG);
 365                 /* TMDS software reset request */
 366                 hdmi_msk_reg(hdmi_dev, MC_SWRSTZREQ,
 367                              m_TMDS_SWRST, v_TMDS_SWRST(0));
 368                 /* Enable/Disable Scrambling */
 369                 hdmi_msk_reg(hdmi_dev, FC_SCRAMBLER_CTRL,
 370                              m_FC_SCRAMBLE_EN, v_FC_SCRAMBLE_EN(1));
 371         } else {
 372                 /* Enable/Disable Scrambling */
 373                 hdmi_msk_reg(hdmi_dev, FC_SCRAMBLER_CTRL,
 374                              m_FC_SCRAMBLE_EN, v_FC_SCRAMBLE_EN(0));
 375                 /* TMDS software reset request */
 376                 hdmi_msk_reg(hdmi_dev, MC_SWRSTZREQ,
 377                              m_TMDS_SWRST, v_TMDS_SWRST(0));
 378                 /* Write on Rx the bit Scrambling_Enable, register 0x20 */
 379                 rockchip_hdmiv2_i2cm_write_data(hdmi_dev, 0, SCDC_TMDS_CONFIG);
 380         }
 381         return 0;
 382 }
 383
 384 static const struct ext_pll_config_tab *get_phy_ext_tab(
 385                 unsigned int pixclock, unsigned int tmdsclk,
 386                 char colordepth)
 387 {
 388         int i;
 389
 390         if (pixclock == 0)
 391                 return NULL;
 392         HDMIDBG("%s pixClock %u tmdsclk %u colorDepth %d\n",
 393                 __func__, pixclock, tmdsclk, colordepth);
 394         for (i = 0; i < ARRAY_SIZE(EXT_PLL_TABLE); i++) {
 395                 if ((EXT_PLL_TABLE[i].pix_clock == pixclock) &&
 396                     (EXT_PLL_TABLE[i].tmdsclock == tmdsclk) &&
 397                     (EXT_PLL_TABLE[i].color_depth == colordepth))
 398                         return &EXT_PLL_TABLE[i];
 399         }
 400         return NULL;
 401 }
 402
 403 static const struct phy_mpll_config_tab *get_phy_mpll_tab(
 404                 unsigned int pixclock, unsigned int tmdsclk,
 405                 char pixrepet, char colordepth)
 406 {
 407         int i;
 408
 409         if (pixclock == 0)
 410                 return NULL;
 411         HDMIDBG("%s pixClock %u tmdsclk %u pixRepet %d colorDepth %d\n",
 412                 __func__, pixclock, tmdsclk, pixrepet, colordepth);
 413         for (i = 0; i < ARRAY_SIZE(PHY_MPLL_TABLE); i++) {
 414                 if ((PHY_MPLL_TABLE[i].pix_clock == pixclock) &&
 415                     (PHY_MPLL_TABLE[i].tmdsclock == tmdsclk) &&
 416                     (PHY_MPLL_TABLE[i].pix_repet == pixrepet) &&
 417                     (PHY_MPLL_TABLE[i].color_depth == colordepth))
 418                         return &PHY_MPLL_TABLE[i];
 419         }
 420         return NULL;
 421 }
 422
 423 static void rockchip_hdmiv2_powerdown(struct hdmi_dev *hdmi_dev)
 424 {
 425         hdmi_msk_reg(hdmi_dev, PHY_MASK, m_PHY_LOCK, v_PHY_LOCK(1));
 426         if (hdmi_dev->soctype != HDMI_SOC_RK322X) {
 427                 hdmi_msk_reg(hdmi_dev, PHY_CONF0,
 428                              m_PDDQ_SIG | m_TXPWRON_SIG |
 429                              m_ENHPD_RXSENSE_SIG | m_SVSRET_SIG,
 430                              v_PDDQ_SIG(1) | v_TXPWRON_SIG(0) |
 431                              v_ENHPD_RXSENSE_SIG(1)) | v_SVSRET_SIG(0);
 432         } else {
 433                 hdmi_msk_reg(hdmi_dev, PHY_CONF0,
 434                              m_TXPWRON_SIG | m_ENHPD_RXSENSE_SIG,
 435                              v_TXPWRON_SIG(0) | v_ENHPD_RXSENSE_SIG(0));
 436                 regmap_write(hdmi_dev->grf_base,
 437                              RK322X_GRF_SOC_CON2,
 438                              RK322X_PLL_PDATA_DEN);
 439         }
 440         hdmi_writel(hdmi_dev, MC_CLKDIS, 0x7f);
 441 }
 442
 443 int rockchip_hdmiv2_write_phy(struct hdmi_dev *hdmi_dev,
 444                               int reg_addr, int val)
 445 {
 446         int trytime = 2, i = 0, op_status = 0;
 447
 448         if (hdmi_dev->phybase) {
 449                 writel_relaxed(val, hdmi_dev->phybase + (reg_addr) * 0x04);
 450                 return 0;
 451         }
 452         while (trytime--) {
 453                 hdmi_writel(hdmi_dev, PHY_I2CM_ADDRESS, reg_addr);
 454                 hdmi_writel(hdmi_dev, PHY_I2CM_DATAO_1, (val >> 8) & 0xff);
 455                 hdmi_writel(hdmi_dev, PHY_I2CM_DATAO_0, val & 0xff);
 456                 hdmi_writel(hdmi_dev, PHY_I2CM_OPERATION, m_PHY_I2CM_WRITE);
 457
 458                 i = 20;
 459                 while (i--) {
 460                         usleep_range(900, 1000);
 461                         op_status = hdmi_readl(hdmi_dev, IH_I2CMPHY_STAT0);
 462                         if (op_status)
 463                                 hdmi_writel(hdmi_dev,
 464                                             IH_I2CMPHY_STAT0,
 465                                             op_status);
 466
 467                         if (op_status & (m_I2CMPHY_DONE | m_I2CMPHY_ERR))
 468                                 break;
 469                 }
 470
 471                 if (!(op_status & m_I2CMPHY_DONE))
 472                         dev_err(hdmi_dev->hdmi->dev,
 473                                 "[%s] operation error,trytime=%d\n",
 474                                 __func__, trytime);
 475                 else
 476                         return 0;
 477                 msleep(100);
 478         }
 479
 480         return -1;
 481 }
 482
 483 int rockchip_hdmiv2_read_phy(struct hdmi_dev *hdmi_dev,
 484                              int reg_addr)
 485 {
 486         int trytime = 2, i = 0, op_status = 0;
 487         int val = 0;
 488
 489         if (hdmi_dev->phybase)
 490                 return readl_relaxed(hdmi_dev->phybase + (reg_addr) * 0x04);
 491
 492         while (trytime--) {
 493                 hdmi_writel(hdmi_dev, PHY_I2CM_ADDRESS, reg_addr);
 494                 hdmi_writel(hdmi_dev, PHY_I2CM_DATAI_1, 0x00);
 495                 hdmi_writel(hdmi_dev, PHY_I2CM_DATAI_0, 0x00);
 496                 hdmi_writel(hdmi_dev, PHY_I2CM_OPERATION, m_PHY_I2CM_READ);
 497
 498                 i = 20;
 499                 while (i--) {
 500                         usleep_range(900, 1000);
 501                         op_status = hdmi_readl(hdmi_dev, IH_I2CMPHY_STAT0);
 502                         if (op_status)
 503                                 hdmi_writel(hdmi_dev, IH_I2CMPHY_STAT0,
 504                                             op_status);
 505
 506                         if (op_status & (m_I2CMPHY_DONE | m_I2CMPHY_ERR))
 507                                 break;
 508                 }
 509
 510                 if (!(op_status & m_I2CMPHY_DONE)) {
 511                         pr_err("[%s] operation error,trytime=%d\n",
 512                                __func__, trytime);
 513                 } else {
 514                         val = hdmi_readl(hdmi_dev, PHY_I2CM_DATAI_1);
 515                         val = (val & 0xff) << 8;
 516                         val += (hdmi_readl(hdmi_dev, PHY_I2CM_DATAI_0) & 0xff);
 517                         pr_debug("phy_reg0x%02x: 0x%04x",
 518                                  reg_addr, val);
 519                         return val;
 520                 }
 521                 msleep(100);
 522         }
 523
 524         return -1;
 525 }
 526
 527 #define PHY_TIMEOUT     10000
 528
 529 static int ext_phy_config(struct hdmi_dev *hdmi_dev)
 530 {
 531         int stat = 0, i = 0, temp;
 532         const struct ext_pll_config_tab *phy_ext = NULL;
 533
 534         if (hdmi_dev->grf_base)
 535                 regmap_write(hdmi_dev->grf_base,
 536                              RK322X_GRF_SOC_CON2,
 537                              RK322X_PLL_POWER_DOWN |
 538                              RK322X_PLL_PDATA_DEN);
 539         if (hdmi_dev->tmdsclk_ratio_change &&
 540             hdmi_dev->hdmi->edid.scdc_present == 1)
 541                 rockchip_hdmiv2_scdc_set_tmds_rate(hdmi_dev);
 542
 543         /* config the required PHY I2C register */
 544         phy_ext = get_phy_ext_tab(hdmi_dev->pixelclk,
 545                                   hdmi_dev->tmdsclk,
 546                                   hdmi_dev->colordepth);
 547         if (phy_ext) {
 548                 stat = ((phy_ext->pll_nf >> 1) & EXT_PHY_PLL_FB_BIT8_MASK) |
 549                        ((phy_ext->vco_div_5 & 1) << 5) |
 550                        (phy_ext->pll_nd & EXT_PHY_PLL_PRE_DIVIDER_MASK);
 551                 rockchip_hdmiv2_write_phy(hdmi_dev,
 552                                           EXT_PHY_PLL_PRE_DIVIDER, stat);
 553                 stat = phy_ext->pll_nf & 0xff;
 554                 rockchip_hdmiv2_write_phy(hdmi_dev,
 555                                           EXT_PHY_PLL_FB_DIVIDER, stat);
 556                 stat = (phy_ext->pclk_divider_a & EXT_PHY_PCLK_DIVIDERA_MASK) |
 557                        ((phy_ext->pclk_divider_b & 3) << 5);
 558                 rockchip_hdmiv2_write_phy(hdmi_dev,
 559                                           EXT_PHY_PCLK_DIVIDER1, stat);
 560                 stat = (phy_ext->pclk_divider_d & EXT_PHY_PCLK_DIVIDERD_MASK) |
 561                        ((phy_ext->pclk_divider_c & 3) << 5);
 562                 rockchip_hdmiv2_write_phy(hdmi_dev,
 563                                           EXT_PHY_PCLK_DIVIDER2, stat);
 564                 stat = ((phy_ext->tmsd_divider_c & 3) << 4) |
 565                        ((phy_ext->tmsd_divider_a & 3) << 2) |
 566                        (phy_ext->tmsd_divider_b & 3);
 567                 rockchip_hdmiv2_write_phy(hdmi_dev,
 568                                           EXT_PHY_TMDSCLK_DIVIDER, stat);
 569                 rockchip_hdmiv2_write_phy(hdmi_dev,
 570                                           EXT_PHY_PPLL_FB_DIVIDER,
 571                                           phy_ext->ppll_nf);
 572
 573                 if (phy_ext->ppll_no == 1) {
 574                         rockchip_hdmiv2_write_phy(hdmi_dev,
 575                                                   EXT_PHY_PPLL_POST_DIVIDER,
 576                                                   0);
 577                         stat = 0x20 | phy_ext->ppll_nd;
 578                         rockchip_hdmiv2_write_phy(hdmi_dev,
 579                                                   EXT_PHY_PPLL_PRE_DIVIDER,
 580                                                   stat);
 581                 } else {
 582                         stat = ((phy_ext->ppll_no / 2) - 1) << 4;
 583                         rockchip_hdmiv2_write_phy(hdmi_dev,
 584                                                   EXT_PHY_PPLL_POST_DIVIDER,
 585                                                   stat);
 586                         stat = 0xe0 | phy_ext->ppll_nd;
 587                         rockchip_hdmiv2_write_phy(hdmi_dev,
 588                                                   EXT_PHY_PPLL_PRE_DIVIDER,
 589                                                   stat);
 590                 }
 591         } else {
 592                 pr_err("%s no supported phy configuration.\n", __func__);
 593                 return -1;
 594         }
 595
 596         if (hdmi_dev->phy_table) {
 597                 for (i = 0; i < hdmi_dev->phy_table_size; i++) {
 598                         temp = hdmi_dev->phy_table[i].maxfreq;
 599                         if (hdmi_dev->tmdsclk <= temp)
 600                                 break;
 601                 }
 602         }
 603
 604         if (i != hdmi_dev->phy_table_size) {
 605                 if (hdmi_dev->phy_table[i].slopeboost) {
 606                         rockchip_hdmiv2_write_phy(hdmi_dev,
 607                                                   EXT_PHY_SIGNAL_CTRL, 0xff);
 608                         temp = hdmi_dev->phy_table[i].slopeboost - 1;
 609                         stat = ((temp & 3) << 6) | ((temp & 3) << 4) |
 610                                ((temp & 3) << 2) | (temp & 3);
 611                         rockchip_hdmiv2_write_phy(hdmi_dev,
 612                                                   EXT_PHY_SLOPEBOOST, stat);
 613                 } else {
 614                         rockchip_hdmiv2_write_phy(hdmi_dev,
 615                                                   EXT_PHY_SIGNAL_CTRL, 0x0f);
 616                 }
 617                 stat = ((hdmi_dev->phy_table[i].pre_emphasis & 3) << 4) |
 618                        ((hdmi_dev->phy_table[i].pre_emphasis & 3) << 2) |
 619                        (hdmi_dev->phy_table[i].pre_emphasis & 3);
 620                 rockchip_hdmiv2_write_phy(hdmi_dev,
 621                                           EXT_PHY_PREEMPHASIS, stat);
 622                 stat = ((hdmi_dev->phy_table[i].clk_level & 0xf) << 4) |
 623                        (hdmi_dev->phy_table[i].data2_level & 0xf);
 624                 rockchip_hdmiv2_write_phy(hdmi_dev,
 625                                           EXT_PHY_LEVEL1, stat);
 626                 stat = ((hdmi_dev->phy_table[i].data1_level & 0xf) << 4) |
 627                        (hdmi_dev->phy_table[i].data0_level & 0xf);
 628                 rockchip_hdmiv2_write_phy(hdmi_dev,
 629                                           EXT_PHY_LEVEL2, stat);
 630         } else {
 631                 rockchip_hdmiv2_write_phy(hdmi_dev,
 632                                           EXT_PHY_SIGNAL_CTRL, 0x0f);
 633         }
 634         rockchip_hdmiv2_write_phy(hdmi_dev, 0xf3, 0x22);
 635
 636         stat = clk_get_rate(hdmi_dev->pclk_phy) / 100000;
 637         rockchip_hdmiv2_write_phy(hdmi_dev, EXT_PHY_TERM_CAL,
 638                                   ((stat >> 8) & 0xff) | 0x80);
 639         rockchip_hdmiv2_write_phy(hdmi_dev, EXT_PHY_TERM_CAL_DIV_L,
 640                                   stat & 0xff);
 641         if (hdmi_dev->tmdsclk > 340000000)
 642                 stat = EXT_PHY_AUTO_R100_OHMS;
 643         else if (hdmi_dev->tmdsclk > 200000000)
 644                 stat = EXT_PHY_AUTO_R50_OHMS;
 645         else
 646                 stat = EXT_PHY_AUTO_ROPEN_CIRCUIT;
 647         rockchip_hdmiv2_write_phy(hdmi_dev, EXT_PHY_TERM_RESIS_AUTO,
 648                                   stat | 0x20);
 649         rockchip_hdmiv2_write_phy(hdmi_dev, EXT_PHY_TERM_CAL,
 650                                   (stat >> 8) & 0xff);
 651         if (hdmi_dev->tmdsclk > 200000000)
 652                 stat = 0;
 653         else
 654                 stat = 0x11;
 655         rockchip_hdmiv2_write_phy(hdmi_dev, EXT_PHY_PLL_BW, stat);
 656         rockchip_hdmiv2_write_phy(hdmi_dev, EXT_PHY_PPLL_BW, 0x27);
 657         if (hdmi_dev->grf_base)
 658                 regmap_write(hdmi_dev->grf_base,
 659                              RK322X_GRF_SOC_CON2,
 660                              RK322X_PLL_POWER_UP);
 661         if (hdmi_dev->tmdsclk_ratio_change)
 662                 msleep(100);
 663         else
 664                 usleep_range(900, 1000);
 665         hdmi_msk_reg(hdmi_dev, PHY_CONF0,
 666                      m_TXPWRON_SIG, v_TXPWRON_SIG(1));
 667         i = 0;
 668         while (i++ < PHY_TIMEOUT) {
 669                 if ((i % 10) == 0) {
 670                         temp = EXT_PHY_PPLL_POST_DIVIDER;
 671                         stat = rockchip_hdmiv2_read_phy(hdmi_dev, temp);
 672                         if (stat & EXT_PHY_PPLL_LOCK_STATUS_MASK)
 673                                 break;
 674                         usleep_range(1000, 2000);
 675                 }
 676         }
 677         if ((stat & EXT_PHY_PPLL_LOCK_STATUS_MASK) == 0) {
 678                 stat = hdmi_readl(hdmi_dev, MC_LOCKONCLOCK);
 679                 dev_err(hdmi_dev->hdmi->dev,
 680                         "PHY PLL not locked: PCLK_ON=%ld,TMDSCLK_ON=%ld\n",
 681                         (stat & m_PCLK_ON) >> 6, (stat & m_TMDSCLK_ON) >> 5);
 682                 return -1;
 683         }
 684
 685         if (hdmi_dev->grf_base)
 686                 regmap_write(hdmi_dev->grf_base,
 687                              RK322X_GRF_SOC_CON2,
 688                              RK322X_PLL_PDATA_EN);
 689
 690         return 0;
 691 }
 692
 693 static int rockchip_hdmiv2_config_phy(struct hdmi_dev *hdmi_dev)
 694 {
 695         int stat = 0, i = 0;
 696         const struct phy_mpll_config_tab *phy_mpll = NULL;
 697
 698         if (hdmi_dev->soctype == HDMI_SOC_RK322X) {
 699                 return ext_phy_config(hdmi_dev);
 700         } else if (hdmi_dev->soctype == HDMI_SOC_RK3366) {
 701                 if (hdmi_dev->pixelclk > 148500000)
 702                         clk_set_rate(hdmi_dev->pclk_phy, 148500000);
 703                 else
 704                         clk_set_rate(hdmi_dev->pclk_phy, hdmi_dev->pixelclk);
 705         }
 706
 707         hdmi_msk_reg(hdmi_dev, PHY_I2CM_DIV,
 708                      m_PHY_I2CM_FAST_STD, v_PHY_I2CM_FAST_STD(0));
 709         hdmi_msk_reg(hdmi_dev, PHY_MASK, m_PHY_LOCK, v_PHY_LOCK(1));
 710         /* power off PHY */
 711         hdmi_msk_reg(hdmi_dev, PHY_CONF0,
 712                      m_PDDQ_SIG | m_TXPWRON_SIG | m_SVSRET_SIG,
 713                      v_PDDQ_SIG(1) | v_TXPWRON_SIG(0) | v_SVSRET_SIG(1));
 714
 715         if (hdmi_dev->tmdsclk_ratio_change &&
 716             hdmi_dev->hdmi->edid.scdc_present == 1)
 717                 rockchip_hdmiv2_scdc_set_tmds_rate(hdmi_dev);
 718
 719         /* reset PHY */
 720         hdmi_writel(hdmi_dev, MC_PHYRSTZ, v_PHY_RSTZ(1));
 721         usleep_range(1000, 2000);
 722         hdmi_writel(hdmi_dev, MC_PHYRSTZ, v_PHY_RSTZ(0));
 723
 724         /* Set slave address as PHY GEN2 address */
 725         hdmi_writel(hdmi_dev, PHY_I2CM_SLAVE, PHY_GEN2_ADDR);
 726
 727         /* config the required PHY I2C register */
 728         if (hdmi_dev->soctype == HDMI_SOC_RK3366 &&
 729             hdmi_dev->pixelclk > 148500000)
 730                 phy_mpll = get_phy_mpll_tab(148500000,
 731                                             hdmi_dev->tmdsclk,
 732                                             hdmi_dev->pixelrepeat - 1,
 733                                             hdmi_dev->colordepth);
 734         else
 735                 phy_mpll = get_phy_mpll_tab(hdmi_dev->pixelclk,
 736                                             hdmi_dev->tmdsclk,
 737                                             hdmi_dev->pixelrepeat - 1,
 738                                             hdmi_dev->colordepth);
 739         if (phy_mpll) {
 740                 rockchip_hdmiv2_write_phy(hdmi_dev, PHYTX_OPMODE_PLLCFG,
 741                                           v_PREP_DIV(phy_mpll->prep_div) |
 742                                           v_TMDS_CNTRL(
 743                                           phy_mpll->tmdsmhl_cntrl) |
 744                                           v_OPMODE(phy_mpll->opmode) |
 745                                           v_FBDIV2_CNTRL(
 746                                           phy_mpll->fbdiv2_cntrl) |
 747                                           v_FBDIV1_CNTRL(
 748                                           phy_mpll->fbdiv1_cntrl) |
 749                                           v_REF_CNTRL(phy_mpll->ref_cntrl) |
 750                                           v_MPLL_N_CNTRL(phy_mpll->n_cntrl));
 751                 rockchip_hdmiv2_write_phy(hdmi_dev, PHYTX_PLLCURRCTRL,
 752                                           v_MPLL_PROP_CNTRL(
 753                                           phy_mpll->prop_cntrl) |
 754                                           v_MPLL_INT_CNTRL(
 755                                           phy_mpll->int_cntrl));
 756                 rockchip_hdmiv2_write_phy(hdmi_dev, PHYTX_PLLGMPCTRL,
 757                                           v_MPLL_GMP_CNTRL(
 758                                           phy_mpll->gmp_cntrl));
 759         }
 760
 761         if (hdmi_dev->phy_table) {
 762                 for (i = 0; i < hdmi_dev->phy_table_size; i++)
 763                         if (hdmi_dev->tmdsclk <= hdmi_dev->phy_table[i].maxfreq)
 764                                 break;
 765         }
 766         if (i == hdmi_dev->phy_table_size) {
 767                 pr_info("%s use default phy settings\n", __func__);
 768                 rockchip_hdmiv2_write_phy(hdmi_dev, PHYTX_CLKSYMCTRL,
 769                                           v_OVERRIDE(1) | v_SLOPEBOOST(0) |
 770                                           v_TX_SYMON(1) | v_CLK_SYMON(1) |
 771                                           v_PREEMPHASIS(0));
 772                 if (hdmi_dev->tmdsclk > 340000000)
 773                         rockchip_hdmiv2_write_phy(hdmi_dev, PHYTX_VLEVCTRL,
 774                                                   v_SUP_TXLVL(9) |
 775                                                   v_SUP_CLKLVL(17));
 776                 else if (hdmi_dev->tmdsclk > 165000000)
 777                         rockchip_hdmiv2_write_phy(hdmi_dev,
 778                                                   PHYTX_VLEVCTRL,
 779                                                   v_SUP_TXLVL(14) |
 780                                                   v_SUP_CLKLVL(17));
 781                 else
 782                         rockchip_hdmiv2_write_phy(hdmi_dev,
 783                                                   PHYTX_VLEVCTRL,
 784                                                   v_SUP_TXLVL(18) |
 785                                                   v_SUP_CLKLVL(17));
 786         } else {
 787                 stat = v_OVERRIDE(1) | v_TX_SYMON(1) | v_CLK_SYMON(1) |
 788                        v_PREEMPHASIS(hdmi_dev->phy_table[i].pre_emphasis) |
 789                        v_SLOPEBOOST(hdmi_dev->phy_table[i].slopeboost);
 790                 rockchip_hdmiv2_write_phy(hdmi_dev, PHYTX_CLKSYMCTRL, stat);
 791
 792                 stat = v_SUP_CLKLVL(hdmi_dev->phy_table[i].clk_level) |
 793                        v_SUP_TXLVL(hdmi_dev->phy_table[i].data0_level);
 794                 rockchip_hdmiv2_write_phy(hdmi_dev, PHYTX_VLEVCTRL, stat);
 795         }
 796
 797         if (hdmi_dev->tmdsclk > 340000000)
 798                 rockchip_hdmiv2_write_phy(hdmi_dev, PHYTX_TERM_RESIS,
 799                                           v_TX_TERM(R50_OHMS));
 800         else
 801                 rockchip_hdmiv2_write_phy(hdmi_dev, PHYTX_TERM_RESIS,
 802                                           v_TX_TERM(R100_OHMS));
 803         /* rockchip_hdmiv2_write_phy(hdmi_dev, 0x05, 0x8000); */
 804         if (hdmi_dev->tmdsclk_ratio_change)
 805                 msleep(100);
 806         /* power on PHY */
 807         hdmi_writel(hdmi_dev, PHY_CONF0, 0x2e);
 808
 809         /* check if the PHY PLL is locked */
 810
 811         i = 0;
 812         while (i++ < PHY_TIMEOUT) {
 813                 if ((i % 10) == 0) {
 814                         stat = hdmi_readl(hdmi_dev, PHY_STAT0);
 815                         if (stat & m_PHY_LOCK)
 816                                 break;
 817                         usleep_range(1000, 2000);
 818                 }
 819         }
 820         if ((stat & m_PHY_LOCK) == 0) {
 821                 stat = hdmi_readl(hdmi_dev, MC_LOCKONCLOCK);
 822                 dev_err(hdmi_dev->hdmi->dev,
 823                         "PHY PLL not locked: PCLK_ON=%ld,TMDSCLK_ON=%ld\n",
 824                         (stat & m_PCLK_ON) >> 6, (stat & m_TMDSCLK_ON) >> 5);
 825                 return -1;
 826         }
 827         hdmi_msk_reg(hdmi_dev, PHY_MASK, m_PHY_LOCK, v_PHY_LOCK(0));
 828         return 0;
 829 }
 830
 831 static int rockchip_hdmiv2_video_framecomposer(struct hdmi *hdmi_drv,
 832                                                struct hdmi_video *vpara)
 833 {
 834         struct hdmi_dev *hdmi_dev = hdmi_drv->property->priv;
 835         int value, vsync_pol, hsync_pol, de_pol;
 836         struct hdmi_video_timing *timing = NULL;
 837         struct fb_videomode *mode = NULL;
 838         u32 sink_version, tmdsclk;
 839
 840         vsync_pol = hdmi_drv->lcdc->cur_screen->pin_vsync;
 841         hsync_pol = hdmi_drv->lcdc->cur_screen->pin_hsync;
 842         de_pol = (hdmi_drv->lcdc->cur_screen->pin_den == 0) ? 1 : 0;
 843
 844         hdmi_msk_reg(hdmi_dev, A_VIDPOLCFG,
 845                      m_DATAEN_POL | m_VSYNC_POL | m_HSYNC_POL,
 846                      v_DATAEN_POL(de_pol) |
 847                      v_VSYNC_POL(vsync_pol) |
 848                      v_HSYNC_POL(hsync_pol));
 849
 850         timing = (struct hdmi_video_timing *)hdmi_vic2timing(vpara->vic);
 851         if (!timing) {
 852                 dev_err(hdmi_drv->dev,
 853                         "[%s] not found vic %d\n", __func__, vpara->vic);
 854                 return -ENOENT;
 855         }
 856         mode = &timing->mode;
 857         if (vpara->color_input == HDMI_COLOR_YCBCR420)
 858                 tmdsclk = mode->pixclock / 2;
 859         else if (vpara->format_3d == HDMI_3D_FRAME_PACKING)
 860                 tmdsclk = 2 * mode->pixclock;
 861         else
 862                 tmdsclk = mode->pixclock;
 863         if (vpara->color_output != HDMI_COLOR_YCBCR422) {
 864                 switch (vpara->color_output_depth) {
 865                 case 10:
 866                         tmdsclk += tmdsclk / 4;
 867                         break;
 868                 case 12:
 869                         tmdsclk += tmdsclk / 2;
 870                         break;
 871                 case 16:
 872                         tmdsclk += tmdsclk;
 873                         break;
 874                 case 8:
 875                 default:
 876                         break;
 877                 }
 878         } else if (vpara->color_output_depth > 12) {
 879                 /* YCbCr422 mode only support up to 12bit */
 880                 vpara->color_output_depth = 12;
 881         }
 882         if ((tmdsclk > 594000000) ||
 883             (tmdsclk > 340000000 &&
 884              tmdsclk > hdmi_drv->edid.maxtmdsclock)) {
 885                 pr_warn("out of max tmds clock, limit to 8bit\n");
 886                 vpara->color_output_depth = 8;
 887                 if (vpara->color_input == HDMI_COLOR_YCBCR420)
 888                         tmdsclk = mode->pixclock / 2;
 889                 else if (vpara->format_3d != HDMI_3D_FRAME_PACKING)
 890                         tmdsclk = mode->pixclock;
 891                 else
 892                         return -1;
 893         }
 894
 895         if ((tmdsclk > 340000000) ||
 896             (tmdsclk < 340000000 && hdmi_dev->tmdsclk > 340000000))
 897                 hdmi_dev->tmdsclk_ratio_change = true;
 898         else
 899                 hdmi_dev->tmdsclk_ratio_change = false;
 900
 901         hdmi_dev->tmdsclk = tmdsclk;
 902         if (vpara->format_3d == HDMI_3D_FRAME_PACKING)
 903                 hdmi_dev->pixelclk = 2 * mode->pixclock;
 904         else
 905                 hdmi_dev->pixelclk = mode->pixclock;
 906         hdmi_dev->pixelrepeat = timing->pixelrepeat;
 907         /* hdmi_dev->colordepth is used for find pll config.
 908          * For YCbCr422, tmdsclk is same on all color depth.
 909          */
 910         if (vpara->color_output == HDMI_COLOR_YCBCR422)
 911                 hdmi_dev->colordepth = 8;
 912         else
 913                 hdmi_dev->colordepth = vpara->color_output_depth;
 914         pr_info("pixel clk is %lu tmds clk is %u\n",
 915                 hdmi_dev->pixelclk, hdmi_dev->tmdsclk);
 916         /* Start/stop HDCP keepout window generation */
 917         hdmi_msk_reg(hdmi_dev, FC_INVIDCONF,
 918                      m_FC_HDCP_KEEPOUT, v_FC_HDCP_KEEPOUT(1));
 919         if (hdmi_drv->edid.scdc_present == 1 && !hdmi_drv->uboot) {
 920                 if (tmdsclk > 340000000 ||
 921                     hdmi_drv->edid.lte_340mcsc_scramble) {
 922                         /* used for HDMI 2.0 TX */
 923                         mutex_lock(&hdmi_dev->ddc_lock);
 924                         rockchip_hdmiv2_scdc_init(hdmi_dev);
 925                         sink_version =
 926                         rockchip_hdmiv2_scdc_get_sink_version(hdmi_dev);
 927                         pr_info("sink scdc version is %d\n", sink_version);
 928                         sink_version = hdmi_drv->edid.hf_vsdb_version;
 929                         rockchip_hdmiv2_scdc_set_source_version(hdmi_dev,
 930                                                                 sink_version);
 931                         if (hdmi_drv->edid.rr_capable == 1)
 932                                 rockchip_hdmiv2_scdc_read_request(hdmi_dev, 1);
 933                         rockchip_hdmiv2_scrambling_enable(hdmi_dev, 1);
 934                         mutex_unlock(&hdmi_dev->ddc_lock);
 935                 } else {
 936                         mutex_lock(&hdmi_dev->ddc_lock);
 937                         rockchip_hdmiv2_scdc_init(hdmi_dev);
 938                         rockchip_hdmiv2_scrambling_enable(hdmi_dev, 0);
 939                         mutex_unlock(&hdmi_dev->ddc_lock);
 940                 }
 941         } else {
 942                 hdmi_msk_reg(hdmi_dev, FC_SCRAMBLER_CTRL,
 943                              m_FC_SCRAMBLE_EN, v_FC_SCRAMBLE_EN(0));
 944         }
 945
 946         hdmi_msk_reg(hdmi_dev, FC_INVIDCONF,
 947                      m_FC_VSYNC_POL | m_FC_HSYNC_POL | m_FC_DE_POL |
 948                      m_FC_HDMI_DVI | m_FC_INTERLACE_MODE,
 949                      v_FC_VSYNC_POL(vsync_pol) | v_FC_HSYNC_POL(hsync_pol) |
 950                      v_FC_DE_POL(de_pol) | v_FC_HDMI_DVI(vpara->sink_hdmi) |
 951                      v_FC_INTERLACE_MODE(mode->vmode));
 952         if ((mode->vmode & FB_VMODE_INTERLACED) &&
 953             vpara->format_3d != HDMI_3D_FRAME_PACKING)
 954                 hdmi_msk_reg(hdmi_dev, FC_INVIDCONF,
 955                              m_FC_VBLANK, v_FC_VBLANK(1));
 956         else
 957                 hdmi_msk_reg(hdmi_dev, FC_INVIDCONF,
 958                              m_FC_VBLANK, v_FC_VBLANK(0));
 959
 960         value = mode->xres;
 961         if (vpara->color_input == HDMI_COLOR_YCBCR420)
 962                 value = value / 2;
 963         hdmi_writel(hdmi_dev, FC_INHACTIV1, v_FC_HACTIVE1(value >> 8));
 964         hdmi_writel(hdmi_dev, FC_INHACTIV0, (value & 0xff));
 965
 966         if (vpara->format_3d == HDMI_3D_FRAME_PACKING) {
 967                 if (mode->vmode == 0)
 968                         value = 2 * mode->yres +
 969                                 mode->upper_margin +
 970                                 mode->lower_margin +
 971                                 mode->vsync_len;
 972                 else
 973                         value = 2 * mode->yres +
 974                                 3 * (mode->upper_margin +
 975                                      mode->lower_margin +
 976                                      mode->vsync_len) + 2;
 977         } else {
 978                 value = mode->yres;
 979         }
 980         hdmi_writel(hdmi_dev, FC_INVACTIV1, v_FC_VACTIVE1(value >> 8));
 981         hdmi_writel(hdmi_dev, FC_INVACTIV0, (value & 0xff));
 982
 983         value = mode->hsync_len + mode->left_margin + mode->right_margin;
 984         if (vpara->color_input == HDMI_COLOR_YCBCR420)
 985                 value = value / 2;
 986         hdmi_writel(hdmi_dev, FC_INHBLANK1, v_FC_HBLANK1(value >> 8));
 987         hdmi_writel(hdmi_dev, FC_INHBLANK0, (value & 0xff));
 988
 989         value = mode->vsync_len + mode->upper_margin + mode->lower_margin;
 990         hdmi_writel(hdmi_dev, FC_INVBLANK, (value & 0xff));
 991
 992         value = mode->right_margin;
 993         if (vpara->color_input == HDMI_COLOR_YCBCR420)
 994                 value = value / 2;
 995         hdmi_writel(hdmi_dev, FC_HSYNCINDELAY1, v_FC_HSYNCINDEAY1(value >> 8));
 996         hdmi_writel(hdmi_dev, FC_HSYNCINDELAY0, (value & 0xff));
 997
 998         value = mode->lower_margin;
 999         hdmi_writel(hdmi_dev, FC_VSYNCINDELAY, (value & 0xff));
1000
1001         value = mode->hsync_len;
1002         if (vpara->color_input == HDMI_COLOR_YCBCR420)
1003                 value = value / 2;
1004         hdmi_writel(hdmi_dev, FC_HSYNCINWIDTH1, v_FC_HSYNCWIDTH1(value >> 8));
1005         hdmi_writel(hdmi_dev, FC_HSYNCINWIDTH0, (value & 0xff));
1006
1007         value = mode->vsync_len;
1008         hdmi_writel(hdmi_dev, FC_VSYNCINWIDTH, (value & 0xff));
1009
1010         /* Set the control period minimum duration (min. of 12 pixel
1011          * clock cycles, refer to HDMI 1.4b specification)
1012          */
1013         hdmi_writel(hdmi_dev, FC_CTRLDUR, 12);
1014         hdmi_writel(hdmi_dev, FC_EXCTRLDUR, 32);
1015
1016         /* spacing < 256^2 * config / tmdsClock, spacing <= 50ms
1017          * worst case: tmdsClock == 25MHz => config <= 19
1018          */
1019         hdmi_writel(hdmi_dev, FC_EXCTRLSPAC,
1020                     (hdmi_dev->tmdsclk / 1000) * 50 / (256 * 512));
1021
1022         hdmi_writel(hdmi_dev, FC_PRCONF,
1023                     v_FC_PR_FACTOR(timing->pixelrepeat) |
1024                     v_FC_PR_FACTOR_OUT(timing->pixelrepeat - 1));
1025
1026         return 0;
1027 }
1028
1029 static int rockchip_hdmiv2_video_packetizer(struct hdmi_dev *hdmi_dev,
1030                                             struct hdmi_video *vpara)
1031 {
1032         unsigned char color_depth = COLOR_DEPTH_24BIT_DEFAULT;
1033         unsigned char output_select = 0;
1034         unsigned char remap_size = 0;
1035
1036         if (vpara->color_output == HDMI_COLOR_YCBCR422) {
1037                 switch (vpara->color_output_depth) {
1038                 case 8:
1039                         remap_size = YCC422_16BIT;
1040                         break;
1041                 case 10:
1042                         remap_size = YCC422_20BIT;
1043                         break;
1044                 case 12:
1045                         remap_size = YCC422_24BIT;
1046                         break;
1047                 default:
1048                         remap_size = YCC422_16BIT;
1049                         break;
1050                 }
1051
1052                 output_select = OUT_FROM_YCC422_REMAP;
1053                 /*Config remap size for the different color Depth*/
1054                 hdmi_msk_reg(hdmi_dev, VP_REMAP,
1055                              m_YCC422_SIZE, v_YCC422_SIZE(remap_size));
1056         } else {
1057                 switch (vpara->color_output_depth) {
1058                 case 10:
1059                         color_depth = COLOR_DEPTH_30BIT;
1060                         output_select = OUT_FROM_PIXEL_PACKING;
1061                         break;
1062                 case 12:
1063                         color_depth = COLOR_DEPTH_36BIT;
1064                         output_select = OUT_FROM_PIXEL_PACKING;
1065                         break;
1066                 case 16:
1067                         color_depth = COLOR_DEPTH_48BIT;
1068                         output_select = OUT_FROM_PIXEL_PACKING;
1069                         break;
1070                 case 8:
1071                 default:
1072                         color_depth = COLOR_DEPTH_24BIT_DEFAULT;
1073                         output_select = OUT_FROM_8BIT_BYPASS;
1074                         break;
1075                 }
1076         }
1077         /*Config Color Depth*/
1078         hdmi_msk_reg(hdmi_dev, VP_PR_CD,
1079                      m_COLOR_DEPTH, v_COLOR_DEPTH(color_depth));
1080         /*Config pixel repettion*/
1081         hdmi_msk_reg(hdmi_dev, VP_PR_CD, m_DESIRED_PR_FACTOR,
1082                      v_DESIRED_PR_FACTOR(hdmi_dev->pixelrepeat - 1));
1083         if (hdmi_dev->pixelrepeat > 1)
1084                 hdmi_msk_reg(hdmi_dev, VP_CONF,
1085                              m_PIXEL_REPET_EN | m_BYPASS_SEL,
1086                              v_PIXEL_REPET_EN(1) | v_BYPASS_SEL(0));
1087         else
1088                 hdmi_msk_reg(hdmi_dev, VP_CONF,
1089                              m_PIXEL_REPET_EN | m_BYPASS_SEL,
1090                              v_PIXEL_REPET_EN(0) | v_BYPASS_SEL(1));
1091
1092         /*config output select*/
1093         if (output_select == OUT_FROM_PIXEL_PACKING) { /* pixel packing */
1094                 hdmi_msk_reg(hdmi_dev, VP_CONF,
1095                              m_BYPASS_EN | m_PIXEL_PACK_EN |
1096                              m_YCC422_EN | m_OUTPUT_SEL,
1097                              v_BYPASS_EN(0) | v_PIXEL_PACK_EN(1) |
1098                              v_YCC422_EN(0) | v_OUTPUT_SEL(output_select));
1099         } else if (output_select == OUT_FROM_YCC422_REMAP) { /* YCC422 */
1100                 hdmi_msk_reg(hdmi_dev, VP_CONF,
1101                              m_BYPASS_EN | m_PIXEL_PACK_EN |
1102                              m_YCC422_EN | m_OUTPUT_SEL,
1103                              v_BYPASS_EN(0) | v_PIXEL_PACK_EN(0) |
1104                              v_YCC422_EN(1) | v_OUTPUT_SEL(output_select));
1105         } else if (output_select == OUT_FROM_8BIT_BYPASS ||
1106                    output_select == 3) { /* bypass */
1107                 hdmi_msk_reg(hdmi_dev, VP_CONF,
1108                              m_BYPASS_EN | m_PIXEL_PACK_EN |
1109                              m_YCC422_EN | m_OUTPUT_SEL,
1110                              v_BYPASS_EN(1) | v_PIXEL_PACK_EN(0) |
1111                              v_YCC422_EN(0) | v_OUTPUT_SEL(output_select));
1112         }
1113
1114 #if defined(HDMI_VIDEO_STUFFING)
1115         /* YCC422 and pixel packing stuffing*/
1116         hdmi_msk_reg(hdmi_dev, VP_STUFF, m_PR_STUFFING, v_PR_STUFFING(1));
1117         hdmi_msk_reg(hdmi_dev, VP_STUFF,
1118                      m_YCC422_STUFFING | m_PP_STUFFING,
1119                      v_YCC422_STUFFING(1) | v_PP_STUFFING(1));
1120 #endif
1121         return 0;
1122 }
1123
1124 static int rockchip_hdmiv2_video_sampler(struct hdmi_dev *hdmi_dev,
1125                                          struct hdmi_video *vpara)
1126 {
1127         int map_code = 0;
1128
1129         if (vpara->color_input == HDMI_COLOR_YCBCR422) {
1130                 /* YCC422 mapping is discontinued - only map 1 is supported */
1131                 switch (vpara->color_output_depth) {
1132                 case 8:
1133                         map_code = VIDEO_YCBCR422_8BIT;
1134                         break;
1135                 case 10:
1136                         map_code = VIDEO_YCBCR422_10BIT;
1137                         break;
1138                 case 12:
1139                         map_code = VIDEO_YCBCR422_12BIT;
1140                         break;
1141                 default:
1142                         map_code = VIDEO_YCBCR422_8BIT;
1143                         break;
1144                 }
1145         } else if (vpara->color_input == HDMI_COLOR_YCBCR420 ||
1146                    vpara->color_input == HDMI_COLOR_YCBCR444) {
1147                 switch (vpara->color_output_depth) {
1148                 case 10:
1149                         map_code = VIDEO_YCBCR444_10BIT;
1150                         break;
1151                 case 12:
1152                         map_code = VIDEO_YCBCR444_12BIT;
1153                         break;
1154                 case 16:
1155                         map_code = VIDEO_YCBCR444_16BIT;
1156                         break;
1157                 case 8:
1158                 default:
1159                         map_code = VIDEO_YCBCR444_8BIT;
1160                         break;
1161                 }
1162         } else {
1163                 switch (vpara->color_output_depth) {
1164                 case 10:
1165                         map_code = VIDEO_RGB444_10BIT;
1166                         break;
1167                 case 12:
1168                         map_code = VIDEO_RGB444_12BIT;
1169                         break;
1170                 case 16:
1171                         map_code = VIDEO_RGB444_16BIT;
1172                         break;
1173                 case 8:
1174                 default:
1175                         map_code = VIDEO_RGB444_8BIT;
1176                         break;
1177                 }
1178                 map_code += (vpara->color_input == HDMI_COLOR_YCBCR444) ?
1179                             8 : 0;
1180         }
1181
1182         /* Set Data enable signal from external
1183          * and set video sample input mapping
1184          */
1185         hdmi_msk_reg(hdmi_dev, TX_INVID0,
1186                      m_INTERNAL_DE_GEN | m_VIDEO_MAPPING,
1187                      v_INTERNAL_DE_GEN(0) | v_VIDEO_MAPPING(map_code));
1188
1189 #if defined(HDMI_VIDEO_STUFFING)
1190         hdmi_writel(hdmi_dev, TX_GYDATA0, 0x00);
1191         hdmi_writel(hdmi_dev, TX_GYDATA1, 0x00);
1192         hdmi_msk_reg(hdmi_dev, TX_INSTUFFING,
1193                      m_GYDATA_STUFF, v_GYDATA_STUFF(1));
1194         hdmi_writel(hdmi_dev, TX_RCRDATA0, 0x00);
1195         hdmi_writel(hdmi_dev, TX_RCRDATA1, 0x00);
1196         hdmi_msk_reg(hdmi_dev, TX_INSTUFFING,
1197                      m_RCRDATA_STUFF, v_RCRDATA_STUFF(1));
1198         hdmi_writel(hdmi_dev, TX_BCBDATA0, 0x00);
1199         hdmi_writel(hdmi_dev, TX_BCBDATA1, 0x00);
1200         hdmi_msk_reg(hdmi_dev, TX_INSTUFFING,
1201                      m_BCBDATA_STUFF, v_BCBDATA_STUFF(1));
1202 #endif
1203         return 0;
1204 }
1205
1206 static const char coeff_csc[][24] = {
1207                 /*   G          R           B           Bias
1208                  *   A1    |    A2     |    A3     |    A4    |
1209                  *   B1    |    B2     |    B3     |    B4    |
1210                  *   C1    |    C2     |    C3     |    C4    |
1211                  */
1212         {       /* CSC_RGB_0_255_TO_RGB_16_235_8BIT */
1213                 0x36, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,         /*G*/
1214                 0x00, 0x00, 0x36, 0xf7, 0x00, 0x00, 0x00, 0x40,         /*R*/
1215                 0x00, 0x00, 0x00, 0x00, 0x36, 0xf7, 0x00, 0x40,         /*B*/
1216         },
1217         {       /* CSC_RGB_0_255_TO_RGB_16_235_10BIT */
1218                 0x36, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,         /*G*/
1219                 0x00, 0x00, 0x36, 0xf7, 0x00, 0x00, 0x01, 0x00,         /*R*/
1220                 0x00, 0x00, 0x00, 0x00, 0x36, 0xf7, 0x01, 0x00,         /*B*/
1221         },
1222         {       /* CSC_RGB_0_255_TO_ITU601_16_235_8BIT */
1223                 0x20, 0x40, 0x10, 0x80, 0x06, 0x40, 0x00, 0x40,         /*Y*/
1224                 0xe8, 0x80, 0x1c, 0x00, 0xfb, 0x80, 0x02, 0x00,         /*Cr*/
1225                 0xed, 0x80, 0xf6, 0x80, 0x1c, 0x00, 0x02, 0x00,         /*Cb*/
1226         },
1227         {       /* CSC_RGB_0_255_TO_ITU601_16_235_10BIT */
1228                 0x20, 0x40, 0x10, 0x80, 0x06, 0x40, 0x01, 0x00,         /*Y*/
1229                 0xe8, 0x80, 0x1c, 0x00, 0xfb, 0x80, 0x08, 0x00,         /*Cr*/
1230                 0xed, 0x80, 0xf6, 0x80, 0x1c, 0x00, 0x08, 0x00,         /*Cb*/
1231         },
1232         {       /* CSC_RGB_0_255_TO_ITU709_16_235_8BIT */
1233                 0x27, 0x40, 0x0b, 0xc0, 0x04, 0x00, 0x00, 0x40,         /*Y*/
1234                 0xe6, 0x80, 0x1c, 0x00, 0xfd, 0x80, 0x02, 0x00,         /*Cr*/
1235                 0xea, 0x40, 0xf9, 0x80, 0x1c, 0x00, 0x02, 0x00,         /*Cb*/
1236         },
1237         {       /* CSC_RGB_0_255_TO_ITU709_16_235_10BIT */
1238                 0x27, 0x40, 0x0b, 0xc0, 0x04, 0x00, 0x01, 0x00,         /*Y*/
1239                 0xe6, 0x80, 0x1c, 0x00, 0xfd, 0x80, 0x08, 0x00,         /*Cr*/
1240                 0xea, 0x40, 0xf9, 0x80, 0x1c, 0x00, 0x08, 0x00,         /*Cb*/
1241         },
1242                 /* Y            Cr          Cb          Bias */
1243         {       /* CSC_ITU601_16_235_TO_RGB_0_255_8BIT */
1244                 0x20, 0x00, 0x69, 0x26, 0x74, 0xfd, 0x01, 0x0e,         /*G*/
1245                 0x20, 0x00, 0x2c, 0xdd, 0x00, 0x00, 0x7e, 0x9a,         /*R*/
1246                 0x20, 0x00, 0x00, 0x00, 0x38, 0xb4, 0x7e, 0x3b,         /*B*/
1247         },
1248         {       /* CSC_ITU709_16_235_TO_RGB_0_255_8BIT */
1249                 0x20, 0x00, 0x71, 0x06, 0x7a, 0x02, 0x00, 0xa7,         /*G*/
1250                 0x20, 0x00, 0x32, 0x64, 0x00, 0x00, 0x7e, 0x6d,         /*R*/
1251                 0x20, 0x00, 0x00, 0x00, 0x3b, 0x61, 0x7e, 0x25,         /*B*/
1252         },
1253 };
1254
1255 static int rockchip_hdmiv2_video_csc(struct hdmi_dev *hdmi_dev,
1256                                      struct hdmi_video *vpara)
1257 {
1258         int i, mode, interpolation, decimation, csc_scale;
1259         const char *coeff = NULL;
1260         unsigned char color_depth = 0;
1261
1262         if (vpara->color_input == vpara->color_output) {
1263                 hdmi_msk_reg(hdmi_dev, MC_FLOWCTRL,
1264                              m_FEED_THROUGH_OFF, v_FEED_THROUGH_OFF(0));
1265                 return 0;
1266         }
1267
1268         if (vpara->color_input == HDMI_COLOR_YCBCR422 &&
1269             vpara->color_output != HDMI_COLOR_YCBCR422 &&
1270             vpara->color_output != HDMI_COLOR_YCBCR420) {
1271                 interpolation = 1;
1272                 hdmi_msk_reg(hdmi_dev, CSC_CFG,
1273                              m_CSC_INTPMODE, v_CSC_INTPMODE(interpolation));
1274         }
1275
1276         if ((vpara->color_input == HDMI_COLOR_RGB_0_255 ||
1277              vpara->color_input == HDMI_COLOR_YCBCR444) &&
1278              vpara->color_output == HDMI_COLOR_YCBCR422) {
1279                 decimation = 1;
1280                 hdmi_msk_reg(hdmi_dev, CSC_CFG,
1281                              m_CSC_DECIMODE, v_CSC_DECIMODE(decimation));
1282         }
1283
1284         switch (vpara->vic) {
1285         case HDMI_720X480I_60HZ_4_3:
1286         case HDMI_720X576I_50HZ_4_3:
1287         case HDMI_720X480P_60HZ_4_3:
1288         case HDMI_720X576P_50HZ_4_3:
1289         case HDMI_720X480I_60HZ_16_9:
1290         case HDMI_720X576I_50HZ_16_9:
1291         case HDMI_720X480P_60HZ_16_9:
1292         case HDMI_720X576P_50HZ_16_9:
1293                 if (vpara->color_input == HDMI_COLOR_RGB_0_255 &&
1294                     vpara->color_output >= HDMI_COLOR_YCBCR444) {
1295                         mode = CSC_RGB_0_255_TO_ITU601_16_235_8BIT;
1296                         csc_scale = 0;
1297                 } else if (vpara->color_input >= HDMI_COLOR_YCBCR444 &&
1298                            vpara->color_output == HDMI_COLOR_RGB_0_255) {
1299                         mode = CSC_ITU601_16_235_TO_RGB_0_255_8BIT;
1300                         csc_scale = 1;
1301                 }
1302                 break;
1303         default:
1304                 if (vpara->color_input == HDMI_COLOR_RGB_0_255 &&
1305                     vpara->color_output >= HDMI_COLOR_YCBCR444) {
1306                         mode = CSC_RGB_0_255_TO_ITU709_16_235_8BIT;
1307                         csc_scale = 0;
1308                 } else if (vpara->color_input >= HDMI_COLOR_YCBCR444 &&
1309                            vpara->color_output == HDMI_COLOR_RGB_0_255) {
1310                         mode = CSC_ITU709_16_235_TO_RGB_0_255_8BIT;
1311                         csc_scale = 1;
1312                 }
1313                 break;
1314         }
1315
1316         if ((vpara->color_input == HDMI_COLOR_RGB_0_255) &&
1317             (vpara->color_output == HDMI_COLOR_RGB_16_235)) {
1318                 mode = CSC_RGB_0_255_TO_RGB_16_235_8BIT;
1319                 csc_scale = 0;
1320         }
1321
1322         switch (vpara->color_output_depth) {
1323         case 10:
1324                 color_depth = COLOR_DEPTH_30BIT;
1325                 mode += 1;
1326                 break;
1327         case 12:
1328                 color_depth = COLOR_DEPTH_36BIT;
1329                 mode += 2;
1330                 break;
1331         case 16:
1332                 color_depth = COLOR_DEPTH_48BIT;
1333                 mode += 3;
1334                 break;
1335         case 8:
1336         default:
1337                 color_depth = COLOR_DEPTH_24BIT;
1338                 break;
1339         }
1340
1341         coeff = coeff_csc[mode];
1342         for (i = 0; i < 24; i++)
1343                 hdmi_writel(hdmi_dev, CSC_COEF_A1_MSB + i, coeff[i]);
1344
1345         hdmi_msk_reg(hdmi_dev, CSC_SCALE,
1346                      m_CSC_SCALE, v_CSC_SCALE(csc_scale));
1347         /*config CSC_COLOR_DEPTH*/
1348         hdmi_msk_reg(hdmi_dev, CSC_SCALE,
1349                      m_CSC_COLOR_DEPTH, v_CSC_COLOR_DEPTH(color_depth));
1350
1351         /* enable CSC */
1352         hdmi_msk_reg(hdmi_dev, MC_FLOWCTRL,
1353                      m_FEED_THROUGH_OFF, v_FEED_THROUGH_OFF(1));
1354
1355         return 0;
1356 }
1357
1358 static int hdmi_dev_detect_hotplug(struct hdmi *hdmi)
1359 {
1360         struct hdmi_dev *hdmi_dev = hdmi->property->priv;
1361         u32 value;
1362
1363         value = hdmi_readl(hdmi_dev, PHY_STAT0);
1364         HDMIDBG("[%s] reg%x value %02x\n", __func__, PHY_STAT0, value);
1365         if (value & m_PHY_HPD)
1366                 return HDMI_HPD_ACTIVED;
1367
1368         return HDMI_HPD_REMOVED;
1369 }
1370
1371 static int hdmi_dev_read_edid(struct hdmi *hdmi, int block, unsigned char *buff)
1372 {
1373         struct hdmi_dev *hdmi_dev = hdmi->property->priv;
1374         int i = 0, n = 0, index = 0, ret = -1, trytime = 5;
1375         int offset = (block % 2) * 0x80;
1376         int interrupt = 0;
1377
1378         HDMIDBG("[%s] block %d\n", __func__, block);
1379
1380         rockchip_hdmiv2_i2cm_reset(hdmi_dev);
1381
1382         /* Set DDC I2C CLK which divided from DDC_CLK to 100KHz. */
1383         rockchip_hdmiv2_i2cm_clk_init(hdmi_dev);
1384
1385         /* Enable I2C interrupt for reading edid */
1386         rockchip_hdmiv2_i2cm_mask_int(hdmi_dev, 0);
1387
1388         hdmi_writel(hdmi_dev, I2CM_SLAVE, DDC_I2C_EDID_ADDR);
1389         hdmi_writel(hdmi_dev, I2CM_SEGADDR, DDC_I2C_SEG_ADDR);
1390         hdmi_writel(hdmi_dev, I2CM_SEGPTR, block / 2);
1391         for (n = 0; n < HDMI_EDID_BLOCK_SIZE / 8; n++) {
1392                 for (trytime = 0; trytime < 5; trytime++) {
1393                         hdmi_writel(hdmi_dev, I2CM_ADDRESS, offset + 8 * n);
1394                         /* enable extend sequential read operation */
1395                         if (block == 0)
1396                                 hdmi_msk_reg(hdmi_dev, I2CM_OPERATION,
1397                                              m_I2CM_RD8, v_I2CM_RD8(1));
1398                         else
1399                                 hdmi_msk_reg(hdmi_dev, I2CM_OPERATION,
1400                                              m_I2CM_RD8_EXT,
1401                                              v_I2CM_RD8_EXT(1));
1402
1403                         i = 20;
1404                         while (i--) {
1405                                 usleep_range(900, 1000);
1406                                 interrupt = hdmi_readl(hdmi_dev,
1407                                                        IH_I2CM_STAT0);
1408                                 if (interrupt)
1409                                         hdmi_writel(hdmi_dev,
1410                                                     IH_I2CM_STAT0, interrupt);
1411
1412                                 if (interrupt &
1413                                     (m_SCDC_READREQ | m_I2CM_DONE |
1414                                      m_I2CM_ERROR))
1415                                         break;
1416                         }
1417
1418                         if (interrupt & m_I2CM_DONE) {
1419                                 for (index = 0; index < 8; index++)
1420                                         buff[8 * n + index] =
1421                                                 hdmi_readl(hdmi_dev,
1422                                                            I2CM_READ_BUFF0 +
1423                                                            index);
1424
1425                                 if (n == HDMI_EDID_BLOCK_SIZE / 8 - 1) {
1426                                         ret = 0;
1427                                         goto exit;
1428                                 }
1429                                 break;
1430                         } else if ((interrupt & m_I2CM_ERROR) || (i == -1)) {
1431                                 dev_err(hdmi->dev,
1432                                         "[%s] edid read %d error\n",
1433                                         __func__, offset + 8 * n);
1434                         }
1435                 }
1436                 if (trytime == 5) {
1437                         dev_err(hdmi->dev,
1438                                 "[%s] edid read error\n", __func__);
1439                         break;
1440                 }
1441         }
1442
1443 exit:
1444         /* Disable I2C interrupt */
1445         rockchip_hdmiv2_i2cm_mask_int(hdmi_dev, 1);
1446         return ret;
1447 }
1448
1449 static void hdmi_dev_config_avi(struct hdmi_dev *hdmi_dev,
1450                                 struct hdmi_video *vpara)
1451 {
1452         unsigned char colorimetry, ext_colorimetry, aspect_ratio, y1y0;
1453         unsigned char rgb_quan_range = AVI_QUANTIZATION_RANGE_DEFAULT;
1454
1455         hdmi_msk_reg(hdmi_dev, FC_DATAUTO3, m_AVI_AUTO, v_AVI_AUTO(0));
1456         hdmi_msk_reg(hdmi_dev, IH_FC_STAT1,
1457                      m_AVI_INFOFRAME, v_AVI_INFOFRAME(1));
1458         /* Set AVI infoFrame Data byte1 */
1459         if (vpara->color_output == HDMI_COLOR_YCBCR444)
1460                 y1y0 = AVI_COLOR_MODE_YCBCR444;
1461         else if (vpara->color_output == HDMI_COLOR_YCBCR422)
1462                 y1y0 = AVI_COLOR_MODE_YCBCR422;
1463         else if (vpara->color_output == HDMI_COLOR_YCBCR420)
1464                 y1y0 = AVI_COLOR_MODE_YCBCR420;
1465         else
1466                 y1y0 = AVI_COLOR_MODE_RGB;
1467
1468         hdmi_msk_reg(hdmi_dev, FC_AVICONF0,
1469                      m_FC_ACTIV_FORMAT | m_FC_RGC_YCC,
1470                      v_FC_RGC_YCC(y1y0) | v_FC_ACTIV_FORMAT(1));
1471
1472         /* Set AVI infoFrame Data byte2 */
1473         switch (vpara->vic) {
1474         case HDMI_720X480I_60HZ_4_3:
1475         case HDMI_720X576I_50HZ_4_3:
1476         case HDMI_720X480P_60HZ_4_3:
1477         case HDMI_720X576P_50HZ_4_3:
1478                 aspect_ratio = AVI_CODED_FRAME_ASPECT_4_3;
1479                 if (vpara->colorimetry == HDMI_COLORIMETRY_NO_DATA)
1480                         colorimetry = AVI_COLORIMETRY_SMPTE_170M;
1481                 break;
1482         case HDMI_720X480I_60HZ_16_9:
1483         case HDMI_720X576I_50HZ_16_9:
1484         case HDMI_720X480P_60HZ_16_9:
1485         case HDMI_720X576P_50HZ_16_9:
1486                 aspect_ratio = AVI_CODED_FRAME_ASPECT_16_9;
1487                 if (vpara->colorimetry == HDMI_COLORIMETRY_NO_DATA)
1488                         colorimetry = AVI_COLORIMETRY_SMPTE_170M;
1489                 break;
1490         default:
1491                 aspect_ratio = AVI_CODED_FRAME_ASPECT_16_9;
1492                 if (vpara->colorimetry == HDMI_COLORIMETRY_NO_DATA)
1493                         colorimetry = AVI_COLORIMETRY_ITU709;
1494         }
1495
1496         if (vpara->colorimetry > HDMI_COLORIMETRY_ITU709) {
1497                 colorimetry = AVI_COLORIMETRY_EXTENDED;
1498                 ext_colorimetry = vpara->colorimetry;
1499         } else if (vpara->color_output == HDMI_COLOR_RGB_16_235 ||
1500                  vpara->color_output == HDMI_COLOR_RGB_0_255) {
1501                 colorimetry = AVI_COLORIMETRY_NO_DATA;
1502                 ext_colorimetry = 0;
1503         } else if (vpara->colorimetry != HDMI_COLORIMETRY_NO_DATA) {
1504                 colorimetry = vpara->colorimetry;
1505         }
1506
1507         hdmi_writel(hdmi_dev, FC_AVICONF1,
1508                     v_FC_COLORIMETRY(colorimetry) |
1509                     v_FC_PIC_ASPEC_RATIO(aspect_ratio) |
1510                     v_FC_ACT_ASPEC_RATIO(ACTIVE_ASPECT_RATE_DEFAULT));
1511
1512         /* Set AVI infoFrame Data byte3 */
1513         hdmi_msk_reg(hdmi_dev, FC_AVICONF2,
1514                      m_FC_EXT_COLORIMETRY | m_FC_QUAN_RANGE,
1515                      v_FC_EXT_COLORIMETRY(ext_colorimetry) |
1516                      v_FC_QUAN_RANGE(rgb_quan_range));
1517
1518         /* Set AVI infoFrame Data byte4 */
1519         if ((vpara->vic > 92 && vpara->vic < 96) ||
1520             (vpara->vic == 98) ||
1521             (vpara->vic & HDMI_VIDEO_DMT))
1522                 hdmi_writel(hdmi_dev, FC_AVIVID, 0);
1523         else
1524                 hdmi_writel(hdmi_dev, FC_AVIVID, vpara->vic & 0xff);
1525         /* Set AVI infoFrame Data byte5 */
1526         hdmi_msk_reg(hdmi_dev, FC_AVICONF3, m_FC_YQ | m_FC_CN,
1527                      v_FC_YQ(YQ_LIMITED_RANGE) | v_FC_CN(CN_GRAPHICS));
1528         hdmi_msk_reg(hdmi_dev, FC_DATAUTO3, m_AVI_AUTO, v_AVI_AUTO(1));
1529 }
1530
1531 static int hdmi_dev_config_vsi(struct hdmi *hdmi,
1532                                unsigned char vic_3d, unsigned char format)
1533 {
1534         int i = 0, id = 0x000c03;
1535         unsigned char data[3] = {0};
1536
1537         struct hdmi_dev *hdmi_dev = hdmi->property->priv;
1538
1539         HDMIDBG("[%s] vic %d format %d.\n", __func__, vic_3d, format);
1540
1541         hdmi_msk_reg(hdmi_dev, FC_DATAUTO0, m_VSD_AUTO, v_VSD_AUTO(0));
1542         hdmi_writel(hdmi_dev, FC_VSDIEEEID2, id & 0xff);
1543         hdmi_writel(hdmi_dev, FC_VSDIEEEID1, (id >> 8) & 0xff);
1544         hdmi_writel(hdmi_dev, FC_VSDIEEEID0, (id >> 16) & 0xff);
1545
1546         data[0] = format << 5;  /* PB4 --HDMI_Video_Format */
1547         switch (format) {
1548         case HDMI_VIDEO_FORMAT_4KX2K:
1549                 data[1] = vic_3d;       /* PB5--HDMI_VIC */
1550                 data[2] = 0;
1551                 break;
1552         case HDMI_VIDEO_FORMAT_3D:
1553                 data[1] = vic_3d << 4;  /* PB5--3D_Structure field */
1554                 data[2] = 0;            /* PB6--3D_Ext_Data field */
1555                 break;
1556         default:
1557                 data[1] = 0;
1558                 data[2] = 0;
1559                 break;
1560         }
1561
1562         for (i = 0; i < 3; i++)
1563                 hdmi_writel(hdmi_dev, FC_VSDPAYLOAD0 + i, data[i]);
1564         hdmi_writel(hdmi_dev, FC_VSDSIZE, 0x6);
1565
1566         hdmi_writel(hdmi_dev, FC_DATAUTO1, 0);
1567         hdmi_writel(hdmi_dev, FC_DATAUTO2, 0x11);
1568         hdmi_msk_reg(hdmi_dev, FC_DATAUTO0, m_VSD_AUTO, v_VSD_AUTO(1));
1569         return 0;
1570 }
1571
1572 static int hdmi_dev_config_spd(struct hdmi *hdmi, const char *vendor,
1573                                const char *product, char deviceinfo)
1574 {
1575         struct hdmi_dev *hdmi_dev;
1576         int i, len;
1577
1578         if (!hdmi || !vendor || !product)
1579                 return -1;
1580         hdmi_dev = hdmi->property->priv;
1581
1582         hdmi_msk_reg(hdmi_dev, FC_DATAUTO0, m_SPD_AUTO, v_SPD_AUTO(0));
1583         len = strlen(vendor);
1584         for (i = 0; i < 8; i++) {
1585                 if (i < len)
1586                         hdmi_writel(hdmi_dev, FC_SPDVENDORNAME0 + i,
1587                                     vendor[i]);
1588                 else
1589                         hdmi_writel(hdmi_dev, FC_SPDVENDORNAME0 + i,
1590                                     0);
1591         }
1592         len = strlen(product);
1593         for (i = 0; i < 16; i++) {
1594                 if (i < len)
1595                         hdmi_writel(hdmi_dev, FC_SPDPRODUCTNAME0 + i,
1596                                     product[i]);
1597                 else
1598                         hdmi_writel(hdmi_dev, FC_SPDPRODUCTNAME0 + i,
1599                                     0);
1600         }
1601         hdmi_writel(hdmi_dev, FC_SPDDEVICEINF, deviceinfo);
1602         hdmi_msk_reg(hdmi_dev, FC_DATAUTO0, m_SPD_AUTO, v_SPD_AUTO(1));
1603         return 0;
1604 }
1605
1606 static int hdmi_dev_config_video(struct hdmi *hdmi, struct hdmi_video *vpara)
1607 {
1608         struct hdmi_dev *hdmi_dev = hdmi->property->priv;
1609
1610         HDMIDBG("%s vic %d 3dformat %d color mode %d color depth %d\n",
1611                 __func__, vpara->vic, vpara->format_3d,
1612                 vpara->color_output, vpara->color_output_depth);
1613
1614         if (hdmi_dev->soctype == HDMI_SOC_RK3288)
1615                 vpara->color_input = HDMI_COLOR_RGB_0_255;
1616
1617         if (!hdmi->uboot) {
1618                 /* before configure video, we power off phy */
1619                 if (hdmi_dev->soctype != HDMI_SOC_RK322X) {
1620                         hdmi_msk_reg(hdmi_dev, PHY_CONF0,
1621                                      m_PDDQ_SIG | m_TXPWRON_SIG,
1622                                      v_PDDQ_SIG(1) | v_TXPWRON_SIG(0));
1623                 } else {
1624                         hdmi_msk_reg(hdmi_dev, PHY_CONF0,
1625                                      m_ENHPD_RXSENSE_SIG,
1626                                      v_ENHPD_RXSENSE_SIG(1));
1627                         regmap_write(hdmi_dev->grf_base,
1628                                      RK322X_GRF_SOC_CON2,
1629                                      RK322X_PLL_POWER_DOWN);
1630                 }
1631                 /* force output blue */
1632                 if (vpara->color_output == HDMI_COLOR_RGB_0_255) {
1633                         hdmi_writel(hdmi_dev, FC_DBGTMDS2, 0x00);       /*R*/
1634                         hdmi_writel(hdmi_dev, FC_DBGTMDS1, 0x00);       /*G*/
1635                         hdmi_writel(hdmi_dev, FC_DBGTMDS0, 0x00);       /*B*/
1636                 } else if (vpara->color_output == HDMI_COLOR_RGB_16_235) {
1637                         hdmi_writel(hdmi_dev, FC_DBGTMDS2, 0x10);       /*R*/
1638                         hdmi_writel(hdmi_dev, FC_DBGTMDS1, 0x10);       /*G*/
1639                         hdmi_writel(hdmi_dev, FC_DBGTMDS0, 0x10);       /*B*/
1640                 } else {
1641                         hdmi_writel(hdmi_dev, FC_DBGTMDS2, 0x80);       /*Cr*/
1642                         hdmi_writel(hdmi_dev, FC_DBGTMDS1, 0x10);       /*Y*/
1643                         hdmi_writel(hdmi_dev, FC_DBGTMDS0, 0x80);       /*Cb*/
1644                 }
1645                 hdmi_msk_reg(hdmi_dev, FC_DBGFORCE,
1646                              m_FC_FORCEVIDEO, v_FC_FORCEVIDEO(1));
1647                 hdmi_writel(hdmi_dev, MC_CLKDIS, m_HDCPCLK_DISABLE);
1648         }
1649
1650         if (rockchip_hdmiv2_video_framecomposer(hdmi, vpara) < 0)
1651                 return -1;
1652
1653         if (rockchip_hdmiv2_video_packetizer(hdmi_dev, vpara) < 0)
1654                 return -1;
1655         /* Color space convert */
1656         if (rockchip_hdmiv2_video_csc(hdmi_dev, vpara) < 0)
1657                 return -1;
1658         if (rockchip_hdmiv2_video_sampler(hdmi_dev, vpara) < 0)
1659                 return -1;
1660
1661         if (vpara->sink_hdmi == OUTPUT_HDMI) {
1662                 hdmi_dev_config_avi(hdmi_dev, vpara);
1663                 hdmi_dev_config_spd(hdmi, hdmi_dev->vendor_name,
1664                                     hdmi_dev->product_name,
1665                                     hdmi_dev->deviceinfo);
1666                 if (vpara->format_3d != HDMI_3D_NONE) {
1667                         hdmi_dev_config_vsi(hdmi,
1668                                             vpara->format_3d,
1669                                             HDMI_VIDEO_FORMAT_3D);
1670                 } else if ((vpara->vic > 92 && vpara->vic < 96) ||
1671                          (vpara->vic == 98)) {
1672                         vpara->vic = (vpara->vic == 98) ?
1673                                      4 : (96 - vpara->vic);
1674                         hdmi_dev_config_vsi(hdmi,
1675                                             vpara->vic,
1676                                             HDMI_VIDEO_FORMAT_4KX2K);
1677                 } else {
1678                         hdmi_dev_config_vsi(hdmi,
1679                                             vpara->vic,
1680                                             HDMI_VIDEO_FORMAT_NORMAL);
1681                 }
1682                 dev_info(hdmi->dev, "[%s] success output HDMI.\n", __func__);
1683         } else {
1684                 dev_info(hdmi->dev, "[%s] success output DVI.\n", __func__);
1685         }
1686
1687         if (!hdmi->uboot)
1688                 rockchip_hdmiv2_config_phy(hdmi_dev);
1689         else
1690                 hdmi_msk_reg(hdmi_dev, PHY_MASK, m_PHY_LOCK, v_PHY_LOCK(0));
1691         return 0;
1692 }
1693
1694 static void hdmi_dev_config_aai(struct hdmi_dev *hdmi_dev,
1695                                 struct hdmi_audio *audio)
1696 {
1697         /* Refer to CEA861-E Audio infoFrame
1698          * Set both Audio Channel Count and Audio Coding
1699          * Type Refer to Stream Head for HDMI
1700          */
1701         hdmi_msk_reg(hdmi_dev, FC_AUDICONF0,
1702                      m_FC_CHN_CNT | m_FC_CODING_TYPE,
1703                      v_FC_CHN_CNT(audio->channel - 1) | v_FC_CODING_TYPE(0));
1704
1705         /* Set both Audio Sample Size and Sample Frequency
1706          * Refer to Stream Head for HDMI
1707          */
1708         hdmi_msk_reg(hdmi_dev, FC_AUDICONF1,
1709                      m_FC_SAMPLE_SIZE | m_FC_SAMPLE_FREQ,
1710                      v_FC_SAMPLE_SIZE(0) | v_FC_SAMPLE_FREQ(0));
1711
1712         /* Set Channel Allocation */
1713         hdmi_writel(hdmi_dev, FC_AUDICONF2, 0x00);
1714
1715         /* Set LFEPBLDOWN-MIX INH and LSV */
1716         hdmi_writel(hdmi_dev, FC_AUDICONF3, 0x00);
1717 }
1718
1719 static int hdmi_dev_config_audio(struct hdmi *hdmi, struct hdmi_audio *audio)
1720 {
1721         struct hdmi_dev *hdmi_dev = hdmi->property->priv;
1722         int word_length = 0, channel = 0, mclk_fs;
1723         unsigned int N = 0, CTS = 0;
1724         int rate = 0;
1725
1726         HDMIDBG("%s\n", __func__);
1727
1728         if (audio->channel < 3)
1729                 channel = I2S_CHANNEL_1_2;
1730         else if (audio->channel < 5)
1731                 channel = I2S_CHANNEL_3_4;
1732         else if (audio->channel < 7)
1733                 channel = I2S_CHANNEL_5_6;
1734         else
1735                 channel = I2S_CHANNEL_7_8;
1736
1737         switch (audio->rate) {
1738         case HDMI_AUDIO_FS_32000:
1739                 mclk_fs = FS_128;
1740                 rate = AUDIO_32K;
1741                 if (hdmi_dev->tmdsclk >= 594000000)
1742                         N = N_32K_HIGHCLK;
1743                 else if (hdmi_dev->tmdsclk >= 297000000)
1744                         N = N_32K_MIDCLK;
1745                 else
1746                         N = N_32K_LOWCLK;
1747                 /*div a num to avoid the value is exceed 2^32(int)*/
1748                 CTS = CALC_CTS(N, hdmi_dev->tmdsclk / 1000, 32);
1749                 break;
1750         case HDMI_AUDIO_FS_44100:
1751                 mclk_fs = FS_128;
1752                 rate = AUDIO_441K;
1753                 if (hdmi_dev->tmdsclk >= 594000000)
1754                         N = N_441K_HIGHCLK;
1755                 else if (hdmi_dev->tmdsclk >= 297000000)
1756                         N = N_441K_MIDCLK;
1757                 else
1758                         N = N_441K_LOWCLK;
1759
1760                 CTS = CALC_CTS(N, hdmi_dev->tmdsclk / 100, 441);
1761                 break;
1762         case HDMI_AUDIO_FS_48000:
1763                 mclk_fs = FS_128;
1764                 rate = AUDIO_48K;
1765                 if (hdmi_dev->tmdsclk >= 594000000)     /*FS_153.6*/
1766                         N = N_48K_HIGHCLK;
1767                 else if (hdmi_dev->tmdsclk >= 297000000)
1768                         N = N_48K_MIDCLK;
1769                 else
1770                         N = N_48K_LOWCLK;
1771
1772                 CTS = CALC_CTS(N, hdmi_dev->tmdsclk / 1000, 48);
1773                 break;
1774         case HDMI_AUDIO_FS_88200:
1775                 mclk_fs = FS_128;
1776                 rate = AUDIO_882K;
1777                 if (hdmi_dev->tmdsclk >= 594000000)
1778                         N = N_882K_HIGHCLK;
1779                 else if (hdmi_dev->tmdsclk >= 297000000)
1780                         N = N_882K_MIDCLK;
1781                 else
1782                         N = N_882K_LOWCLK;
1783
1784                 CTS = CALC_CTS(N, hdmi_dev->tmdsclk / 100, 882);
1785                 break;
1786         case HDMI_AUDIO_FS_96000:
1787                 mclk_fs = FS_128;
1788                 rate = AUDIO_96K;
1789                 if (hdmi_dev->tmdsclk >= 594000000)     /*FS_153.6*/
1790                         N = N_96K_HIGHCLK;
1791                 else if (hdmi_dev->tmdsclk >= 297000000)
1792                         N = N_96K_MIDCLK;
1793                 else
1794                         N = N_96K_LOWCLK;
1795
1796                 CTS = CALC_CTS(N, hdmi_dev->tmdsclk / 1000, 96);
1797                 break;
1798         case HDMI_AUDIO_FS_176400:
1799                 mclk_fs = FS_128;
1800                 rate = AUDIO_1764K;
1801                 if (hdmi_dev->tmdsclk >= 594000000)
1802                         N = N_1764K_HIGHCLK;
1803                 else if (hdmi_dev->tmdsclk >= 297000000)
1804                         N = N_1764K_MIDCLK;
1805                 else
1806                         N = N_1764K_LOWCLK;
1807
1808                 CTS = CALC_CTS(N, hdmi_dev->tmdsclk / 100, 1764);
1809                 break;
1810         case HDMI_AUDIO_FS_192000:
1811                 mclk_fs = FS_128;
1812                 rate = AUDIO_192K;
1813                 if (hdmi_dev->tmdsclk >= 594000000)     /*FS_153.6*/
1814                         N = N_192K_HIGHCLK;
1815                 else if (hdmi_dev->tmdsclk >= 297000000)
1816                         N = N_192K_MIDCLK;
1817                 else
1818                         N = N_192K_LOWCLK;
1819
1820                 CTS = CALC_CTS(N, hdmi_dev->tmdsclk / 1000, 192);
1821                 break;
1822         default:
1823                 dev_err(hdmi_dev->hdmi->dev,
1824                         "[%s] not support such sample rate %d\n",
1825                         __func__, audio->rate);
1826                 return -ENOENT;
1827         }
1828
1829         switch (audio->word_length) {
1830         case HDMI_AUDIO_WORD_LENGTH_16bit:
1831                 word_length = I2S_16BIT_SAMPLE;
1832                 break;
1833         case HDMI_AUDIO_WORD_LENGTH_20bit:
1834                 word_length = I2S_20BIT_SAMPLE;
1835                 break;
1836         case HDMI_AUDIO_WORD_LENGTH_24bit:
1837                 word_length = I2S_24BIT_SAMPLE;
1838                 break;
1839         default:
1840                 word_length = I2S_16BIT_SAMPLE;
1841         }
1842
1843         HDMIDBG("rate = %d, tmdsclk = %u, N = %d, CTS = %d\n",
1844                 audio->rate, hdmi_dev->tmdsclk, N, CTS);
1845         /* more than 2 channels => layout 1 else layout 0 */
1846         hdmi_msk_reg(hdmi_dev, FC_AUDSCONF,
1847                      m_AUD_PACK_LAYOUT,
1848                      v_AUD_PACK_LAYOUT((audio->channel > 2) ? 1 : 0));
1849
1850         if (hdmi_dev->audiosrc == HDMI_AUDIO_SRC_SPDIF) {
1851                 mclk_fs = FS_128;
1852                 hdmi_msk_reg(hdmi_dev, AUD_CONF0,
1853                              m_I2S_SEL, v_I2S_SEL(AUDIO_SPDIF_GPA));
1854                 hdmi_msk_reg(hdmi_dev, AUD_SPDIF1,
1855                              m_SET_NLPCM | m_SPDIF_WIDTH,
1856                              v_SET_NLPCM(PCM_LINEAR) |
1857                              v_SPDIF_WIDTH(word_length));
1858                 /*Mask fifo empty and full int and reset fifo*/
1859                 hdmi_msk_reg(hdmi_dev, AUD_SPDIFINT,
1860                              m_FIFO_EMPTY_MASK | m_FIFO_FULL_MASK,
1861                              v_FIFO_EMPTY_MASK(1) | v_FIFO_FULL_MASK(1));
1862                 hdmi_msk_reg(hdmi_dev, AUD_SPDIF0,
1863                              m_SW_SAUD_FIFO_RST, v_SW_SAUD_FIFO_RST(1));
1864         } else {
1865                 /*Mask fifo empty and full int and reset fifo*/
1866                 hdmi_msk_reg(hdmi_dev, AUD_INT,
1867                              m_FIFO_EMPTY_MASK | m_FIFO_FULL_MASK,
1868                              v_FIFO_EMPTY_MASK(1) | v_FIFO_FULL_MASK(1));
1869                 hdmi_msk_reg(hdmi_dev, AUD_CONF0,
1870                              m_SW_AUD_FIFO_RST, v_SW_AUD_FIFO_RST(1));
1871                 hdmi_writel(hdmi_dev, MC_SWRSTZREQ, 0xF7);
1872                 hdmi_writel(hdmi_dev, AUD_CONF2, 0x0);
1873                 usleep_range(90, 100);
1874                 if (channel == I2S_CHANNEL_7_8) {
1875                         HDMIDBG("hbr mode.\n");
1876                         hdmi_writel(hdmi_dev, AUD_CONF2, 0x1);
1877                         word_length = I2S_24BIT_SAMPLE;
1878                 } else if ((audio->rate == HDMI_AUDIO_FS_48000) ||
1879                            (audio->rate == HDMI_AUDIO_FS_192000)) {
1880                         HDMIDBG("nlpcm mode.\n");
1881                         hdmi_writel(hdmi_dev, AUD_CONF2, 0x2);
1882                         word_length = I2S_24BIT_SAMPLE;
1883                 } else {
1884                         hdmi_writel(hdmi_dev, AUD_CONF2, 0x0);
1885                 }
1886                 hdmi_msk_reg(hdmi_dev, AUD_CONF0,
1887                              m_I2S_SEL | m_I2S_IN_EN,
1888                              v_I2S_SEL(AUDIO_I2S) | v_I2S_IN_EN(channel));
1889                 hdmi_writel(hdmi_dev, AUD_CONF1,
1890                             v_I2S_MODE(I2S_STANDARD_MODE) |
1891                             v_I2S_WIDTH(word_length));
1892         }
1893
1894         hdmi_msk_reg(hdmi_dev, AUD_INPUTCLKFS,
1895                      m_LFS_FACTOR, v_LFS_FACTOR(mclk_fs));
1896
1897         /*Set N value*/
1898         hdmi_msk_reg(hdmi_dev, AUD_N3, m_NCTS_ATOMIC_WR, v_NCTS_ATOMIC_WR(1));
1899         /*Set CTS by manual*/
1900         hdmi_msk_reg(hdmi_dev, AUD_CTS3,
1901                      m_N_SHIFT | m_CTS_MANUAL | m_AUD_CTS3,
1902                      v_N_SHIFT(N_SHIFT_1) |
1903                      v_CTS_MANUAL(1) |
1904                      v_AUD_CTS3(CTS >> 16));
1905         hdmi_writel(hdmi_dev, AUD_CTS2, (CTS >> 8) & 0xff);
1906         hdmi_writel(hdmi_dev, AUD_CTS1, CTS & 0xff);
1907
1908         hdmi_msk_reg(hdmi_dev, AUD_N3, m_AUD_N3, v_AUD_N3(N >> 16));
1909         hdmi_writel(hdmi_dev, AUD_N2, (N >> 8) & 0xff);
1910         hdmi_writel(hdmi_dev, AUD_N1, N & 0xff);
1911
1912         /* set channel status register */
1913         hdmi_msk_reg(hdmi_dev, FC_AUDSCHNLS7,
1914                      m_AUDIO_SAMPLE_RATE, v_AUDIO_SAMPLE_RATE(rate));
1915         hdmi_writel(hdmi_dev, FC_AUDSCHNLS8, ((~rate) << 4) | 0x2);
1916
1917         hdmi_msk_reg(hdmi_dev, AUD_CONF0,
1918                      m_SW_AUD_FIFO_RST, v_SW_AUD_FIFO_RST(1));
1919
1920         hdmi_dev_config_aai(hdmi_dev, audio);
1921
1922         return 0;
1923 }
1924
1925 static int hdmi_dev_control_output(struct hdmi *hdmi, int enable)
1926 {
1927         struct hdmi_dev *hdmi_dev = hdmi->property->priv;
1928         struct hdmi_video vpara;
1929
1930         HDMIDBG("[%s] %d\n", __func__, enable);
1931         if (enable == HDMI_AV_UNMUTE) {
1932                 hdmi_writel(hdmi_dev, FC_DBGFORCE, 0x00);
1933                 if (hdmi->edid.sink_hdmi == OUTPUT_HDMI)
1934                         hdmi_msk_reg(hdmi_dev, FC_GCP,
1935                                      m_FC_SET_AVMUTE | m_FC_CLR_AVMUTE,
1936                                      v_FC_SET_AVMUTE(0) | v_FC_CLR_AVMUTE(1));
1937         } else {
1938                 if (enable & HDMI_VIDEO_MUTE) {
1939                         hdmi_msk_reg(hdmi_dev, FC_DBGFORCE,
1940                                      m_FC_FORCEVIDEO, v_FC_FORCEVIDEO(1));
1941                         if (hdmi->edid.sink_hdmi == OUTPUT_HDMI) {
1942                                 hdmi_msk_reg(hdmi_dev, FC_GCP,
1943                                              m_FC_SET_AVMUTE |
1944                                              m_FC_CLR_AVMUTE,
1945                                              v_FC_SET_AVMUTE(1) |
1946                                              v_FC_CLR_AVMUTE(0));
1947                                 vpara.vic = hdmi->vic;
1948                                 vpara.color_output = HDMI_COLOR_RGB_0_255;
1949                                 hdmi_dev_config_avi(hdmi_dev, &vpara);
1950                                 while ((!hdmi_readl(hdmi_dev, IH_FC_STAT1)) &
1951                                        m_AVI_INFOFRAME) {
1952                                         usleep_range(900, 1000);
1953                                 }
1954                         }
1955                 }
1956 /*              if (enable & HDMI_AUDIO_MUTE) {
1957  *                      hdmi_msk_reg(hdmi_dev, FC_AUDSCONF,
1958  *                                   m_AUD_PACK_SAMPFIT,
1959  *                                   v_AUD_PACK_SAMPFIT(0x0F));
1960  *              }
1961  */
1962                 if (enable == (HDMI_VIDEO_MUTE | HDMI_AUDIO_MUTE)) {
1963                         if (hdmi->ops->hdcp_power_off_cb)
1964                                 hdmi->ops->hdcp_power_off_cb(hdmi);
1965                         rockchip_hdmiv2_powerdown(hdmi_dev);
1966                 }
1967         }
1968         return 0;
1969 }
1970
1971 static int hdmi_dev_insert(struct hdmi *hdmi)
1972 {
1973         struct hdmi_dev *hdmi_dev = hdmi->property->priv;
1974
1975         HDMIDBG("%s\n", __func__);
1976         if (!hdmi->uboot)
1977                 hdmi_writel(hdmi_dev, MC_CLKDIS, m_HDCPCLK_DISABLE);
1978         return HDMI_ERROR_SUCCESS;
1979 }
1980
1981 static int hdmi_dev_remove(struct hdmi *hdmi)
1982 {
1983         struct hdmi_dev *hdmi_dev = hdmi->property->priv;
1984
1985         HDMIDBG("%s\n", __func__);
1986         if (hdmi->ops->hdcp_power_off_cb)
1987                 hdmi->ops->hdcp_power_off_cb(hdmi);
1988         rockchip_hdmiv2_powerdown(hdmi_dev);
1989         hdmi_dev->tmdsclk = 0;
1990         return HDMI_ERROR_SUCCESS;
1991 }
1992
1993 static int hdmi_dev_enable(struct hdmi *hdmi)
1994 {
1995         struct hdmi_dev *hdmi_dev = hdmi->property->priv;
1996
1997         HDMIDBG("%s\n", __func__);
1998         if (!hdmi_dev->enable) {
1999                 hdmi_writel(hdmi_dev, IH_MUTE, 0x00);
2000                 hdmi_dev->enable = 1;
2001         }
2002         hdmi_submit_work(hdmi, HDMI_HPD_CHANGE, 10, 0);
2003         return 0;
2004 }
2005
2006 static int hdmi_dev_disable(struct hdmi *hdmi)
2007 {
2008         struct hdmi_dev *hdmi_dev = hdmi->property->priv;
2009
2010         HDMIDBG("%s\n", __func__);
2011         if (hdmi_dev->enable) {
2012                 hdmi_dev->enable = 0;
2013                 hdmi_writel(hdmi_dev, IH_MUTE, 0x1);
2014         }
2015         return 0;
2016 }
2017
2018 void rockchip_hdmiv2_dev_init_ops(struct hdmi_ops *ops)
2019 {
2020         if (ops) {
2021                 ops->enable     = hdmi_dev_enable;
2022                 ops->disable    = hdmi_dev_disable;
2023                 ops->getstatus  = hdmi_dev_detect_hotplug;
2024                 ops->insert     = hdmi_dev_insert;
2025                 ops->remove     = hdmi_dev_remove;
2026                 ops->getedid    = hdmi_dev_read_edid;
2027                 ops->setvideo   = hdmi_dev_config_video;
2028                 ops->setaudio   = hdmi_dev_config_audio;
2029                 ops->setmute    = hdmi_dev_control_output;
2030                 ops->setvsi     = hdmi_dev_config_vsi;
2031         }
2032 }
2033
2034 void rockchip_hdmiv2_dev_initial(struct hdmi_dev *hdmi_dev)
2035 {
2036         struct hdmi *hdmi = hdmi_dev->hdmi;
2037
2038         if (!hdmi->uboot) {
2039                 pr_info("reset hdmi\n");
2040                 if (hdmi_dev->soctype == HDMI_SOC_RK3288) {
2041                         rk3288_cru_set_soft_reset(RK3288_SOFT_RST_HDMI, true);
2042                         usleep_range(10, 20);
2043                         rk3288_cru_set_soft_reset(RK3288_SOFT_RST_HDMI, false);
2044                 } else {
2045                         if (hdmi_dev->soctype == HDMI_SOC_RK322X) {
2046                                 regmap_write(hdmi_dev->grf_base,
2047                                              RK322X_GRF_SOC_CON2,
2048                                              RK322X_DDC_MASK_EN);
2049                                 regmap_write(hdmi_dev->grf_base,
2050                                              RK322X_GRF_SOC_CON6,
2051                                              RK322X_IO_3V_DOMAIN);
2052                         }
2053                         reset_control_assert(hdmi_dev->reset);
2054                         usleep_range(10, 20);
2055                         reset_control_deassert(hdmi_dev->reset);
2056                 }
2057                 rockchip_hdmiv2_powerdown(hdmi_dev);
2058         } else {
2059                 hdmi->hotplug = hdmi_dev_detect_hotplug(hdmi);
2060                 if (hdmi->hotplug != HDMI_HPD_ACTIVED)
2061                         hdmi->uboot = 0;
2062         }
2063         /*mute unnecessary interrupt, only enable hpd*/
2064         hdmi_writel(hdmi_dev, IH_MUTE_FC_STAT0, 0xff);
2065         hdmi_writel(hdmi_dev, IH_MUTE_FC_STAT1, 0xff);
2066         hdmi_writel(hdmi_dev, IH_MUTE_FC_STAT2, 0xff);
2067         hdmi_writel(hdmi_dev, IH_MUTE_AS_STAT0, 0xff);
2068         hdmi_writel(hdmi_dev, IH_MUTE_PHY_STAT0, 0xfc);
2069         hdmi_writel(hdmi_dev, IH_MUTE_I2CM_STAT0, 0xff);
2070         hdmi_writel(hdmi_dev, IH_MUTE_CEC_STAT0, 0xff);
2071         hdmi_writel(hdmi_dev, IH_MUTE_VP_STAT0, 0xff);
2072         hdmi_writel(hdmi_dev, IH_MUTE_I2CMPHY_STAT0, 0xff);
2073         hdmi_writel(hdmi_dev, IH_MUTE_AHBDMAAUD_STAT0, 0xff);
2074
2075         /* disable hdcp interrupt */
2076         hdmi_writel(hdmi_dev, A_APIINTMSK, 0xff);
2077         hdmi_writel(hdmi_dev, PHY_MASK, 0xf1);
2078
2079         if (hdmi->property->feature & SUPPORT_CEC)
2080                 rockchip_hdmiv2_cec_init(hdmi);
2081         if (hdmi->property->feature & SUPPORT_HDCP)
2082                 rockchip_hdmiv2_hdcp_init(hdmi);
2083 }
2084
2085 irqreturn_t rockchip_hdmiv2_dev_irq(int irq, void *priv)
2086 {
2087         struct hdmi_dev *hdmi_dev = priv;
2088         struct hdmi *hdmi = hdmi_dev->hdmi;
2089         char phy_pol = hdmi_readl(hdmi_dev, PHY_POL0);
2090         char phy_status = hdmi_readl(hdmi_dev, PHY_STAT0);
2091         char phy_int0 = hdmi_readl(hdmi_dev, PHY_INI0);
2092         /*read interrupt*/
2093         char fc_stat0 = hdmi_readl(hdmi_dev, IH_FC_STAT0);
2094         char fc_stat1 = hdmi_readl(hdmi_dev, IH_FC_STAT1);
2095         char fc_stat2 = hdmi_readl(hdmi_dev, IH_FC_STAT2);
2096         char aud_int = hdmi_readl(hdmi_dev, IH_AS_SATA0);
2097         char phy_int = hdmi_readl(hdmi_dev, IH_PHY_STAT0);
2098         char vp_stat0 = hdmi_readl(hdmi_dev, IH_VP_STAT0);
2099         char cec_int = hdmi_readl(hdmi_dev, IH_CEC_STAT0);
2100         char hdcp_int = hdmi_readl(hdmi_dev, A_APIINTSTAT);
2101         char hdcp2_int = hdmi_readl(hdmi_dev, HDCP2REG_STAT);
2102
2103         /*clear interrupt*/
2104         hdmi_writel(hdmi_dev, IH_FC_STAT0, fc_stat0);
2105         hdmi_writel(hdmi_dev, IH_FC_STAT1, fc_stat1);
2106         hdmi_writel(hdmi_dev, IH_FC_STAT2, fc_stat2);
2107         hdmi_writel(hdmi_dev, IH_VP_STAT0, vp_stat0);
2108
2109         if (phy_int0 || phy_int) {
2110                 if ((phy_int0 & m_PHY_LOCK) &&
2111                     (phy_pol & m_PHY_LOCK) == 0) {
2112                         pr_info("hdmi phy pll unlock\n");
2113                         hdmi_submit_work(hdmi, HDMI_SET_VIDEO, 0, 0);
2114                 }
2115                 phy_pol = (phy_int0 & (~phy_status)) | ((~phy_int0) & phy_pol);
2116                 hdmi_writel(hdmi_dev, PHY_POL0, phy_pol);
2117                 hdmi_writel(hdmi_dev, IH_PHY_STAT0, phy_int);
2118                 if ((phy_int & m_HPD) || ((phy_int & 0x3c) == 0x3c))
2119                         hdmi_submit_work(hdmi, HDMI_HPD_CHANGE, 20, 0);
2120         }
2121
2122         /* Audio error */
2123         if (aud_int) {
2124                 hdmi_writel(hdmi_dev, IH_AS_SATA0, aud_int);
2125                 hdmi_msk_reg(hdmi_dev, AUD_CONF0,
2126                              m_SW_AUD_FIFO_RST, v_SW_AUD_FIFO_RST(1));
2127                 hdmi_writel(hdmi_dev, MC_SWRSTZREQ, 0xF7);
2128         }
2129         /* CEC */
2130         if (cec_int) {
2131                 hdmi_writel(hdmi_dev, IH_CEC_STAT0, cec_int);
2132                 if (hdmi_dev->hdmi->property->feature & SUPPORT_CEC)
2133                         rockchip_hdmiv2_cec_isr(hdmi_dev, cec_int);
2134         }
2135         /* HDCP */
2136         if (hdcp_int) {
2137                 hdmi_writel(hdmi_dev, A_APIINTCLR, hdcp_int);
2138                 rockchip_hdmiv2_hdcp_isr(hdmi_dev, hdcp_int);
2139         }
2140
2141         /* HDCP2 */
2142         if (hdcp2_int) {
2143                 hdmi_writel(hdmi_dev, HDCP2REG_STAT, hdcp2_int);
2144                 pr_info("hdcp2_int is 0x%02x\n", hdcp2_int);
2145                 if ((hdcp2_int & m_HDCP2_AUTH_FAIL ||
2146                      hdcp2_int & m_HDCP2_AUTH_LOST) &&
2147                     hdmi_dev->hdcp2_start) {
2148                         pr_info("hdcp2 failed or lost\n");
2149                         hdmi_dev->hdcp2_start();
2150                 }
2151         }
2152         return IRQ_HANDLED;
2153 }