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

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