drivers/video/rockchip/dp/cdn-dp-reg.c

   1 /*
   2  * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd
   3  * Author: Chris Zhong <zyw@rock-chips.com>
   4  *
   5  * This software is licensed under the terms of the GNU General Public
   6  * License version 2, as published by the Free Software Foundation, and
   7  * may be copied, distributed, and modified under those terms.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 #include <linux/clk.h>
  16 #include <linux/device.h>
  17 #include <linux/delay.h>
  18 #include <linux/io.h>
  19 #include <linux/iopoll.h>
  20 #include <linux/reset.h>
  21
  22 #include "cdn-dp-reg.h"
  23
  24 #define CDN_DP_SPDIF_CLK                200000000
  25 #define FW_ALIVE_TIMEOUT_US             1000000
  26 #define MAILBOX_RETRY_US                1000
  27 #define MAILBOX_TIMEOUT_US              5000000
  28 #define LINK_TRAINING_RETRY_MS          20
  29 #define LINK_TRAINING_TIMEOUT_MS        500
  30
  31 void cdn_dp_set_fw_clk(struct cdn_dp_device *dp, u32 clk)
  32 {
  33         writel(clk / 1000000, dp->regs + SW_CLK_H);
  34 }
  35
  36 void cdn_dp_clock_reset(struct cdn_dp_device *dp)
  37 {
  38         u32 val;
  39
  40         val = DPTX_FRMR_DATA_CLK_RSTN_EN |
  41               DPTX_FRMR_DATA_CLK_EN |
  42               DPTX_PHY_DATA_RSTN_EN |
  43               DPTX_PHY_DATA_CLK_EN |
  44               DPTX_PHY_CHAR_RSTN_EN |
  45               DPTX_PHY_CHAR_CLK_EN |
  46               SOURCE_AUX_SYS_CLK_RSTN_EN |
  47               SOURCE_AUX_SYS_CLK_EN |
  48               DPTX_SYS_CLK_RSTN_EN |
  49               DPTX_SYS_CLK_EN |
  50               CFG_DPTX_VIF_CLK_RSTN_EN |
  51               CFG_DPTX_VIF_CLK_EN;
  52         writel(val, dp->regs + SOURCE_DPTX_CAR);
  53
  54         val = SOURCE_PHY_RSTN_EN | SOURCE_PHY_CLK_EN;
  55         writel(val, dp->regs + SOURCE_PHY_CAR);
  56
  57         val = SOURCE_PKT_SYS_RSTN_EN |
  58               SOURCE_PKT_SYS_CLK_EN |
  59               SOURCE_PKT_DATA_RSTN_EN |
  60               SOURCE_PKT_DATA_CLK_EN;
  61         writel(val, dp->regs + SOURCE_PKT_CAR);
  62
  63         val = SPDIF_CDR_CLK_RSTN_EN |
  64               SPDIF_CDR_CLK_EN |
  65               SOURCE_AIF_SYS_RSTN_EN |
  66               SOURCE_AIF_SYS_CLK_EN |
  67               SOURCE_AIF_CLK_RSTN_EN |
  68               SOURCE_AIF_CLK_EN;
  69         writel(val, dp->regs + SOURCE_AIF_CAR);
  70
  71         val = SOURCE_CIPHER_SYSTEM_CLK_RSTN_EN |
  72               SOURCE_CIPHER_SYS_CLK_EN |
  73               SOURCE_CIPHER_CHAR_CLK_RSTN_EN |
  74               SOURCE_CIPHER_CHAR_CLK_EN;
  75         writel(val, dp->regs + SOURCE_CIPHER_CAR);
  76
  77         val = SOURCE_CRYPTO_SYS_CLK_RSTN_EN |
  78               SOURCE_CRYPTO_SYS_CLK_EN;
  79         writel(val, dp->regs + SOURCE_CRYPTO_CAR);
  80
  81         val = ~(MAILBOX_INT_MASK_BIT | PIF_INT_MASK_BIT) & ALL_INT_MASK;
  82         writel(val, dp->regs + APB_INT_MASK);
  83 }
  84
  85 static int cdn_dp_mailbox_read(struct cdn_dp_device *dp, bool force)
  86 {
  87         int val, ret;
  88
  89         if (!dp->fw_actived && !force)
  90                 return -EPERM;
  91
  92         ret = readx_poll_timeout(readl, dp->regs + MAILBOX_EMPTY_ADDR,
  93                                  val, !val, MAILBOX_RETRY_US,
  94                                  MAILBOX_TIMEOUT_US);
  95         if (ret < 0)
  96                 return ret;
  97
  98         return readl(dp->regs + MAILBOX0_RD_DATA) & 0xff;
  99 }
 100
 101 static int cdp_dp_mailbox_write(struct cdn_dp_device *dp, u8 val, bool force)
 102 {
 103         int ret, full;
 104
 105         if (!dp->fw_actived && !force)
 106                 return -EPERM;
 107
 108         ret = readx_poll_timeout(readl, dp->regs + MAILBOX_FULL_ADDR,
 109                                  full, !full, MAILBOX_RETRY_US,
 110                                  MAILBOX_TIMEOUT_US);
 111         if (ret < 0)
 112                 return ret;
 113
 114         writel(val, dp->regs + MAILBOX0_WR_DATA);
 115
 116         return 0;
 117 }
 118
 119 static int cdn_dp_mailbox_validate_receive(struct cdn_dp_device *dp,
 120                                            u8 module_id, u8 opcode,
 121                                            u8 req_size)
 122 {
 123         u32 mbox_size, i;
 124         u8 header[4];
 125         int ret;
 126
 127         /* read the header of the message */
 128         for (i = 0; i < 4; i++) {
 129                 ret = cdn_dp_mailbox_read(dp, 0);
 130                 if (ret < 0)
 131                         return ret;
 132
 133                 header[i] = ret;
 134         }
 135
 136         mbox_size = (header[2] << 8) | header[3];
 137
 138         if (opcode != header[0] || module_id != header[1] ||
 139             req_size != mbox_size) {
 140                 /*
 141                  * If the message in mailbox is not what we want, we need to
 142                  * clear the mailbox by read.
 143                  */
 144                 for (i = 0; i < mbox_size; i++)
 145                         if (cdn_dp_mailbox_read(dp, 0) < 0)
 146                                 break;
 147
 148                 return -EINVAL;
 149         }
 150
 151         return 0;
 152 }
 153
 154 static int cdn_dp_mailbox_read_receive(struct cdn_dp_device *dp,
 155                                        u8 *buff, u8 buff_size)
 156 {
 157         u32 i;
 158         int ret;
 159
 160         for (i = 0; i < buff_size; i++) {
 161                 ret = cdn_dp_mailbox_read(dp, 0);
 162                 if (ret < 0)
 163                         return ret;
 164
 165                 buff[i] = ret;
 166         }
 167
 168         return 0;
 169 }
 170
 171 static int cdn_dp_mailbox_send(struct cdn_dp_device *dp, u8 module_id,
 172                                u8 opcode, u16 size, u8 *message)
 173 {
 174         u8 header[4];
 175         int ret, i;
 176
 177         header[0] = opcode;
 178         header[1] = module_id;
 179         header[2] = (size >> 8) & 0xff;
 180         header[3] = size & 0xff;
 181
 182         for (i = 0; i < 4; i++) {
 183                 ret = cdp_dp_mailbox_write(dp, header[i], 0);
 184                 if (ret)
 185                         return ret;
 186         }
 187
 188         for (i = 0; i < size; i++) {
 189                 ret = cdp_dp_mailbox_write(dp, message[i], 0);
 190                 if (ret)
 191                         return ret;
 192         }
 193
 194         return 0;
 195 }
 196
 197 static int cdn_dp_reg_write(struct cdn_dp_device *dp, u16 addr, u32 val)
 198 {
 199         u8 msg[6];
 200
 201         msg[0] = (addr >> 8) & 0xff;
 202         msg[1] = addr & 0xff;
 203         msg[2] = (val >> 24) & 0xff;
 204         msg[3] = (val >> 16) & 0xff;
 205         msg[4] = (val >> 8) & 0xff;
 206         msg[5] = val & 0xff;
 207         return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_REGISTER,
 208                                    sizeof(msg), msg);
 209 }
 210
 211 static int cdn_dp_reg_write_bit(struct cdn_dp_device *dp, u16 addr,
 212                                 u8 start_bit, u8 bits_no, u32 val)
 213 {
 214         u8 field[8];
 215
 216         field[0] = (addr >> 8) & 0xff;
 217         field[1] = addr & 0xff;
 218         field[2] = start_bit;
 219         field[3] = bits_no;
 220         field[4] = (val >> 24) & 0xff;
 221         field[5] = (val >> 16) & 0xff;
 222         field[6] = (val >> 8) & 0xff;
 223         field[7] = val & 0xff;
 224
 225         return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_FIELD,
 226                                    sizeof(field), field);
 227 }
 228
 229 int cdn_dp_dpcd_read(struct cdn_dp_device *dp, u32 addr, u8 *data, u16 len)
 230 {
 231         u8 msg[5], reg[5];
 232         int ret;
 233
 234         msg[0] = (len >> 8) & 0xff;
 235         msg[1] = len & 0xff;
 236         msg[2] = (addr >> 16) & 0xff;
 237         msg[3] = (addr >> 8) & 0xff;
 238         msg[4] = addr & 0xff;
 239         ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_READ_DPCD,
 240                                   sizeof(msg), msg);
 241         if (ret)
 242                 goto err_dpcd_read;
 243
 244         ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
 245                                               DPTX_READ_DPCD,
 246                                               sizeof(reg) + len);
 247         if (ret)
 248                 goto err_dpcd_read;
 249
 250         ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg));
 251         if (ret)
 252                 goto err_dpcd_read;
 253
 254         ret = cdn_dp_mailbox_read_receive(dp, data, len);
 255
 256 err_dpcd_read:
 257         return ret;
 258 }
 259
 260 int cdn_dp_dpcd_write(struct cdn_dp_device *dp, u32 addr, u8 value)
 261 {
 262         u8 msg[6], reg[5];
 263         int ret;
 264
 265         msg[0] = 0;
 266         msg[1] = 1;
 267         msg[2] = (addr >> 16) & 0xff;
 268         msg[3] = (addr >> 8) & 0xff;
 269         msg[4] = addr & 0xff;
 270         msg[5] = value;
 271         ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_DPCD,
 272                                   sizeof(msg), msg);
 273         if (ret)
 274                 goto err_dpcd_write;
 275
 276         ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
 277                                               DPTX_WRITE_DPCD, sizeof(reg));
 278         if (ret)
 279                 goto err_dpcd_write;
 280
 281         ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg));
 282         if (ret)
 283                 goto err_dpcd_write;
 284
 285         if (addr != (reg[2] << 16 | reg[3] << 8 | reg[4]))
 286                 ret = -EINVAL;
 287
 288 err_dpcd_write:
 289         if (ret)
 290                 dev_err(dp->dev, "dpcd write failed: %d\n", ret);
 291         return ret;
 292 }
 293
 294 int cdn_dp_load_firmware(struct cdn_dp_device *dp, const u32 *i_mem,
 295                          u32 i_size, const u32 *d_mem, u32 d_size)
 296 {
 297         u32 reg;
 298         int i, ret;
 299
 300         /* reset ucpu before load firmware*/
 301         writel(APB_IRAM_PATH | APB_DRAM_PATH | APB_XT_RESET,
 302                dp->regs + APB_CTRL);
 303
 304         for (i = 0; i < i_size; i += 4)
 305                 writel(*i_mem++, dp->regs + ADDR_IMEM + i);
 306
 307         for (i = 0; i < d_size; i += 4)
 308                 writel(*d_mem++, dp->regs + ADDR_DMEM + i);
 309
 310         /* un-reset ucpu */
 311         writel(0, dp->regs + APB_CTRL);
 312
 313         /* check the keep alive register to make sure fw working */
 314         ret = readx_poll_timeout(readl, dp->regs + KEEP_ALIVE,
 315                                  reg, reg, 2000, FW_ALIVE_TIMEOUT_US);
 316         if (ret < 0) {
 317                 dev_err(dp->dev, "failed to loaded the FW reg = %x\n", reg);
 318                 return -EINVAL;
 319         }
 320
 321         reg = readl(dp->regs + VER_L) & 0xff;
 322         dp->fw_version = reg;
 323         reg = readl(dp->regs + VER_H) & 0xff;
 324         dp->fw_version |= reg << 8;
 325         reg = readl(dp->regs + VER_LIB_L_ADDR) & 0xff;
 326         dp->fw_version |= reg << 16;
 327         reg = readl(dp->regs + VER_LIB_H_ADDR) & 0xff;
 328         dp->fw_version |= reg << 24;
 329
 330         dev_dbg(dp->dev, "firmware version: %x\n", dp->fw_version);
 331
 332         return 0;
 333 }
 334
 335 int cdn_dp_set_firmware_active(struct cdn_dp_device *dp, bool enable)
 336 {
 337         u8 msg[5];
 338         int ret, i;
 339
 340         msg[0] = GENERAL_MAIN_CONTROL;
 341         msg[1] = MB_MODULE_ID_GENERAL;
 342         msg[2] = 0;
 343         msg[3] = 1;
 344         msg[4] = enable ? FW_ACTIVE : FW_STANDBY;
 345
 346         for (i = 0; i < sizeof(msg); i++) {
 347                 ret = cdp_dp_mailbox_write(dp, msg[i], 1);
 348                 if (ret)
 349                         goto err_set_firmware_active;
 350         }
 351
 352         /* read the firmware state */
 353         for (i = 0; i < sizeof(msg); i++)  {
 354                 ret = cdn_dp_mailbox_read(dp, 1);
 355                 if (ret < 0)
 356                         goto err_set_firmware_active;
 357
 358                 msg[i] = ret;
 359         }
 360
 361         dp->fw_actived = (msg[4] == FW_ACTIVE);
 362         ret = 0;
 363
 364 err_set_firmware_active:
 365         if (ret < 0)
 366                 dev_err(dp->dev, "set firmware active failed\n");
 367         return ret;
 368 }
 369
 370 int cdn_dp_set_host_cap(struct cdn_dp_device *dp, u8 lanes, bool flip)
 371 {
 372         u8 msg[8];
 373         int ret;
 374
 375         msg[0] = CDN_DP_MAX_LINK_RATE;
 376         msg[1] = lanes | (0x1 << 4);
 377         msg[2] = VOLTAGE_LEVEL_2;
 378         msg[3] = PRE_EMPHASIS_LEVEL_3;
 379         msg[4] = PTS1 | PTS2 | PTS3 | PTS4;
 380         msg[5] = FAST_LT_NOT_SUPPORT;
 381         msg[6] = flip ? LANE_MAPPING_FLIPPED : LANE_MAPPING_NORMAL;
 382         msg[7] = ENHANCED;
 383
 384         ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX,
 385                                   DPTX_SET_HOST_CAPABILITIES,
 386                                   sizeof(msg), msg);
 387         if (ret)
 388                 goto err_set_host_cap;
 389
 390         ret = cdn_dp_reg_write(dp, DP_AUX_SWAP_INVERSION_CONTROL,
 391                                AUX_HOST_INVERT);
 392
 393 err_set_host_cap:
 394         if (ret)
 395                 dev_err(dp->dev, "set host cap failed: %d\n", ret);
 396         return ret;
 397 }
 398
 399 int cdn_dp_event_config(struct cdn_dp_device *dp)
 400 {
 401         u8 msg[5];
 402         int ret;
 403
 404         memset(msg, 0, sizeof(msg));
 405
 406         msg[0] = DPTX_EVENT_ENABLE_HPD | DPTX_EVENT_ENABLE_TRAINING;
 407
 408         ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_ENABLE_EVENT,
 409                                   sizeof(msg), msg);
 410         if (ret)
 411                 dev_err(dp->dev, "set event config failed: %d\n", ret);
 412
 413         return ret;
 414 }
 415
 416 u32 cdn_dp_get_event(struct cdn_dp_device *dp)
 417 {
 418         return readl(dp->regs + SW_EVENTS0);
 419 }
 420
 421 int cdn_dp_get_hpd_status(struct cdn_dp_device *dp)
 422 {
 423         u8 status;
 424         int ret;
 425
 426         ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_HPD_STATE,
 427                                   0, NULL);
 428         if (ret)
 429                 goto err_get_hpd;
 430
 431         ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
 432                                               DPTX_HPD_STATE, sizeof(status));
 433         if (ret)
 434                 goto err_get_hpd;
 435
 436         ret = cdn_dp_mailbox_read_receive(dp, &status, sizeof(status));
 437         if (ret)
 438                 goto err_get_hpd;
 439
 440         return status;
 441
 442 err_get_hpd:
 443         dev_err(dp->dev, "get hpd status failed: %d\n", ret);
 444         return ret;
 445 }
 446
 447 int cdn_dp_get_edid_block(void *data, u8 *edid,
 448                           unsigned int block, size_t length)
 449 {
 450         struct cdn_dp_device *dp = data;
 451         u8 msg[2], reg[2];
 452         int ret;
 453
 454         msg[0] = block / 2;
 455         msg[1] = block % 2;
 456
 457         ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_GET_EDID,
 458                                   sizeof(msg), msg);
 459         if (ret)
 460                 goto err_get_edid;
 461
 462         ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
 463                                               DPTX_GET_EDID,
 464                                               sizeof(reg) + length);
 465         if (ret)
 466                 goto err_get_edid;
 467
 468         ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg));
 469         if (ret)
 470                 goto err_get_edid;
 471
 472         ret = cdn_dp_mailbox_read_receive(dp, edid, length);
 473         if (ret)
 474                 goto err_get_edid;
 475
 476         if (reg[0] != length || reg[1] != block / 2)
 477                 ret = -EINVAL;
 478
 479 err_get_edid:
 480         if (ret)
 481                 dev_err(dp->dev, "get block[%d] edid failed: %d\n", block, ret);
 482         return ret;
 483 }
 484
 485 int cdn_dp_training_start(struct cdn_dp_device *dp)
 486 {
 487         unsigned long timeout;
 488         u8 msg, event[2];
 489         int ret;
 490
 491         msg = LINK_TRAINING_RUN;
 492
 493         /* start training */
 494         ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_TRAINING_CONTROL,
 495                                   sizeof(msg), &msg);
 496         if (ret)
 497                 goto err_training_start;
 498
 499         timeout = jiffies + msecs_to_jiffies(LINK_TRAINING_TIMEOUT_MS);
 500         while (time_before(jiffies, timeout)) {
 501                 msleep(LINK_TRAINING_RETRY_MS);
 502                 ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX,
 503                                           DPTX_READ_EVENT, 0, NULL);
 504                 if (ret)
 505                         goto err_training_start;
 506
 507                 ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
 508                                                       DPTX_READ_EVENT,
 509                                                       sizeof(event));
 510                 if (ret)
 511                         goto err_training_start;
 512
 513                 ret = cdn_dp_mailbox_read_receive(dp, event, sizeof(event));
 514                 if (ret)
 515                         goto err_training_start;
 516
 517                 if (event[1] & EQ_PHASE_FINISHED)
 518                         return 0;
 519         }
 520
 521         ret = -ETIMEDOUT;
 522
 523 err_training_start:
 524         dev_err(dp->dev, "training failed: %d\n", ret);
 525         return ret;
 526 }
 527
 528 int cdn_dp_get_training_status(struct cdn_dp_device *dp)
 529 {
 530         u8 status[10];
 531         int ret;
 532
 533         ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_READ_LINK_STAT,
 534                                   0, NULL);
 535         if (ret)
 536                 goto err_get_training_status;
 537
 538         ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
 539                                               DPTX_READ_LINK_STAT,
 540                                               sizeof(status));
 541         if (ret)
 542                 goto err_get_training_status;
 543
 544         ret = cdn_dp_mailbox_read_receive(dp, status, sizeof(status));
 545         if (ret)
 546                 goto err_get_training_status;
 547
 548         dp->link.rate = status[0];
 549         dp->link.num_lanes = status[1];
 550
 551 err_get_training_status:
 552         if (ret)
 553                 dev_err(dp->dev, "get training status failed: %d\n", ret);
 554         return ret;
 555 }
 556
 557 int cdn_dp_set_video_status(struct cdn_dp_device *dp, int active)
 558 {
 559         u8 msg;
 560         int ret;
 561
 562         msg = !!active;
 563
 564         ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_SET_VIDEO,
 565                                   sizeof(msg), &msg);
 566         if (ret)
 567                 dev_err(dp->dev, "set video status failed: %d\n", ret);
 568
 569         return ret;
 570 }
 571
 572 static int cdn_dp_get_msa_misc(struct video_info *video,
 573                                struct drm_display_mode *mode)
 574 {
 575         u32 msa_misc;
 576         u8 val[2];
 577
 578         switch (video->color_fmt) {
 579         case PXL_RGB:
 580         case Y_ONLY:
 581                 val[0] = 0;
 582                 break;
 583         /* set YUV default color space conversion to BT601 */
 584         case YCBCR_4_4_4:
 585                 val[0] = 6 + BT_601 * 8;
 586                 break;
 587         case YCBCR_4_2_2:
 588                 val[0] = 5 + BT_601 * 8;
 589                 break;
 590         case YCBCR_4_2_0:
 591                 val[0] = 5;
 592                 break;
 593         };
 594
 595         switch (video->color_depth) {
 596         case 6:
 597                 val[1] = 0;
 598                 break;
 599         case 8:
 600                 val[1] = 1;
 601                 break;
 602         case 10:
 603                 val[1] = 2;
 604                 break;
 605         case 12:
 606                 val[1] = 3;
 607                 break;
 608         case 16:
 609                 val[1] = 4;
 610                 break;
 611         };
 612
 613         msa_misc = 2 * val[0] + 32 * val[1] +
 614                    ((video->color_fmt == Y_ONLY) ? (1 << 14) : 0);
 615
 616         return msa_misc;
 617 }
 618
 619 int cdn_dp_config_video(struct cdn_dp_device *dp)
 620 {
 621         struct video_info *video = &dp->video_info;
 622         struct drm_display_mode *mode = &dp->mode;
 623         u64 symbol, tmp;
 624         u32 val, link_rate;
 625         u8 bit_per_pix, tu_size_reg = TU_SIZE;
 626         int ret;
 627
 628         bit_per_pix = (video->color_fmt == YCBCR_4_2_2) ?
 629                       (video->color_depth * 2) : (video->color_depth * 3);
 630
 631         link_rate = drm_dp_bw_code_to_link_rate(dp->link.rate) / 1000;
 632
 633         val = VIF_BYPASS_INTERLACE;
 634         ret = cdn_dp_reg_write(dp, BND_HSYNC2VSYNC, val);
 635         if (ret)
 636                 goto err_config_video;
 637
 638         ret = cdn_dp_reg_write(dp, HSYNC2VSYNC_POL_CTRL, 0);
 639         if (ret)
 640                 goto err_config_video;
 641
 642         /*
 643          * get a best tu_size and valid symbol:
 644          * 1. chose Lclk freq(162Mhz, 270Mhz, 540Mhz), set TU to 32
 645          * 2. calculate VS(valid symbol) = TU * Pclk * Bpp / (Lclk * Lanes)
 646          * 3. if VS > *.85 or VS < *.1 or VS < 2 or TU < VS + 4, then set
 647          *    TU += 2 and repeat 2nd step.
 648          */
 649         do {
 650                 tu_size_reg += 2;
 651                 tmp = tu_size_reg * mode->clock * bit_per_pix;
 652                 tmp /= dp->link.num_lanes * link_rate * 8;
 653                 symbol = tmp / 1000;
 654         } while ((symbol <= 1) || (tu_size_reg - symbol < 4) ||
 655                  (tmp % 1000 > 850) || (tmp % 1000 < 100));
 656
 657         val = symbol + (tu_size_reg << 8);
 658         ret = cdn_dp_reg_write(dp, DP_FRAMER_TU, val);
 659         if (ret)
 660                 goto err_config_video;
 661
 662         /* set the FIFO Buffer size */
 663         val = ((mode->clock * (symbol + 1) / 1000) + link_rate);
 664         val /= (dp->link.num_lanes * link_rate);
 665         val = 8 * (symbol + 1) / bit_per_pix - val;
 666         val += 2;
 667         ret = cdn_dp_reg_write(dp, DP_VC_TABLE(15), val);
 668
 669         switch (video->color_depth) {
 670         case 6:
 671                 val = BCS_6;
 672                 break;
 673         case 8:
 674                 val = BCS_8;
 675                 break;
 676         case 10:
 677                 val = BCS_10;
 678                 break;
 679         case 12:
 680                 val = BCS_12;
 681                 break;
 682         case 16:
 683                 val = BCS_16;
 684                 break;
 685         };
 686
 687         val += video->color_fmt << 8;
 688         ret = cdn_dp_reg_write(dp, DP_FRAMER_PXL_REPR, val);
 689         if (ret)
 690                 goto err_config_video;
 691
 692         val = video->h_sync_polarity ? DP_FRAMER_SP_HSP : 0;
 693         val |= video->v_sync_polarity ? DP_FRAMER_SP_VSP : 0;
 694         ret = cdn_dp_reg_write(dp, DP_FRAMER_SP, val);
 695         if (ret)
 696                 goto err_config_video;
 697
 698         val = (mode->hsync_start - mode->hdisplay) << 16;
 699         val |= mode->htotal - mode->hsync_end;
 700         ret = cdn_dp_reg_write(dp, DP_FRONT_BACK_PORCH, val);
 701         if (ret)
 702                 goto err_config_video;
 703
 704         val = mode->hdisplay * bit_per_pix / 8;
 705         ret = cdn_dp_reg_write(dp, DP_BYTE_COUNT, val);
 706         if (ret)
 707                 goto err_config_video;
 708
 709         val = mode->htotal | ((mode->htotal - mode->hsync_start) << 16);
 710         ret = cdn_dp_reg_write(dp, MSA_HORIZONTAL_0, val);
 711         if (ret)
 712                 goto err_config_video;
 713
 714         val = mode->hsync_end - mode->hsync_start;
 715         val |= (mode->hdisplay << 16) | (video->h_sync_polarity << 15);
 716         ret = cdn_dp_reg_write(dp, MSA_HORIZONTAL_1, val);
 717         if (ret)
 718                 goto err_config_video;
 719
 720         val = mode->vtotal;
 721         val |= ((mode->vtotal - mode->vsync_start) << 16);
 722         ret = cdn_dp_reg_write(dp, MSA_VERTICAL_0, val);
 723         if (ret)
 724                 goto err_config_video;
 725
 726         val = mode->vsync_end - mode->vsync_start;
 727         val |= mode->vdisplay << 16 | (video->v_sync_polarity << 15);
 728         ret = cdn_dp_reg_write(dp, MSA_VERTICAL_1, val);
 729         if (ret)
 730                 goto err_config_video;
 731
 732         val = cdn_dp_get_msa_misc(video, mode);
 733         ret = cdn_dp_reg_write(dp, MSA_MISC, val);
 734         if (ret)
 735                 goto err_config_video;
 736
 737         ret = cdn_dp_reg_write(dp, STREAM_CONFIG, 1);
 738         if (ret)
 739                 goto err_config_video;
 740
 741         val = mode->hsync_end - mode->hsync_start;
 742         val |= (mode->hdisplay << 16);
 743         ret = cdn_dp_reg_write(dp, DP_HORIZONTAL, val);
 744         if (ret)
 745                 goto err_config_video;
 746
 747         val = mode->vtotal;
 748         val -= (mode->vtotal - mode->vdisplay);
 749         val |= (mode->vtotal - mode->vsync_start) << 16;
 750         ret = cdn_dp_reg_write(dp, DP_VERTICAL_0, val);
 751         if (ret)
 752                 goto err_config_video;
 753
 754         val = mode->vtotal;
 755         ret = cdn_dp_reg_write(dp, DP_VERTICAL_1, val);
 756         if (ret)
 757                 goto err_config_video;
 758
 759         val =  0;
 760         ret = cdn_dp_reg_write_bit(dp, DP_VB_ID, 2, 1, val);
 761
 762 err_config_video:
 763         if (ret)
 764                 dev_err(dp->dev, "config video failed: %d\n", ret);
 765         return ret;
 766 }
 767
 768 int cdn_dp_audio_stop(struct cdn_dp_device *dp, struct audio_info *audio)
 769 {
 770         u32 val;
 771         int ret;
 772
 773         ret = cdn_dp_reg_write(dp, AUDIO_PACK_CONTROL, 0);
 774         if (ret) {
 775                 dev_err(dp->dev, "audio stop failed: %d\n", ret);
 776                 return ret;
 777         }
 778
 779         val = SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS;
 780         val |= SPDIF_FIFO_MID_RANGE(0xe0);
 781         val |= SPDIF_JITTER_THRSH(0xe0);
 782         val |= SPDIF_JITTER_AVG_WIN(7);
 783         writel(val, dp->regs + SPDIF_CTRL_ADDR);
 784
 785         /* clearn the audio config and reset */
 786         writel(0, dp->regs + AUDIO_SRC_CNTL);
 787         writel(0, dp->regs + AUDIO_SRC_CNFG);
 788         writel(AUDIO_SW_RST, dp->regs + AUDIO_SRC_CNTL);
 789         writel(0, dp->regs + AUDIO_SRC_CNTL);
 790
 791         /* reset smpl2pckt component  */
 792         writel(0, dp->regs + SMPL2PKT_CNTL);
 793         writel(AUDIO_SW_RST, dp->regs + SMPL2PKT_CNTL);
 794         writel(0, dp->regs + SMPL2PKT_CNTL);
 795
 796         /* reset FIFO */
 797         writel(AUDIO_SW_RST, dp->regs + FIFO_CNTL);
 798         writel(0, dp->regs + FIFO_CNTL);
 799
 800         if (audio->format == AFMT_SPDIF)
 801                 clk_disable_unprepare(dp->spdif_clk);
 802
 803         return 0;
 804 }
 805
 806 int cdn_dp_audio_mute(struct cdn_dp_device *dp, bool enable)
 807 {
 808         int ret;
 809
 810         ret = cdn_dp_reg_write_bit(dp, DP_VB_ID, 4, 1, enable);
 811         if (ret)
 812                 dev_err(dp->dev, "audio mute failed: %d\n", ret);
 813
 814         return ret;
 815 }
 816
 817 static void cdn_dp_audio_config_i2s(struct cdn_dp_device *dp,
 818                                     struct audio_info *audio)
 819 {
 820         int sub_pckt_num = 1, i2s_port_en_val = 0xf, i;
 821         u32 val;
 822
 823         if (audio->channels == 2) {
 824                 if (dp->link.num_lanes == 1)
 825                         sub_pckt_num = 2;
 826                 else
 827                         sub_pckt_num = 4;
 828
 829                 i2s_port_en_val = 1;
 830         } else if (audio->channels == 4) {
 831                 i2s_port_en_val = 3;
 832         }
 833
 834         writel(0x0, dp->regs + SPDIF_CTRL_ADDR);
 835
 836         writel(SYNC_WR_TO_CH_ZERO, dp->regs + FIFO_CNTL);
 837
 838         val = MAX_NUM_CH(audio->channels);
 839         val |= NUM_OF_I2S_PORTS(audio->channels);
 840         val |= AUDIO_TYPE_LPCM;
 841         val |= CFG_SUB_PCKT_NUM(sub_pckt_num);
 842         writel(val, dp->regs + SMPL2PKT_CNFG);
 843
 844         if (audio->sample_width == 16)
 845                 val = 0;
 846         else if (audio->sample_width == 24)
 847                 val = 1 << 9;
 848         else
 849                 val = 2 << 9;
 850
 851         val |= AUDIO_CH_NUM(audio->channels);
 852         val |= I2S_DEC_PORT_EN(i2s_port_en_val);
 853         val |= TRANS_SMPL_WIDTH_32;
 854         writel(val, dp->regs + AUDIO_SRC_CNFG);
 855
 856         for (i = 0; i < (audio->channels + 1) / 2; i++) {
 857                 if (audio->sample_width == 16)
 858                         val = (0x08 << 8) | (0x08 << 20);
 859                 else if (audio->sample_width == 24)
 860                         val = (0x0b << 8) | (0x0b << 20);
 861
 862                 val |= ((2 * i) << 4) | ((2 * i + 1) << 16);
 863                 writel(val, dp->regs + STTS_BIT_CH(i));
 864         }
 865
 866         switch (audio->sample_rate) {
 867         case 32000:
 868                 val = SAMPLING_FREQ(3) |
 869                       ORIGINAL_SAMP_FREQ(0xc);
 870                 break;
 871         case 44100:
 872                 val = SAMPLING_FREQ(0) |
 873                       ORIGINAL_SAMP_FREQ(0xf);
 874                 break;
 875         case 48000:
 876                 val = SAMPLING_FREQ(2) |
 877                       ORIGINAL_SAMP_FREQ(0xd);
 878                 break;
 879         case 88200:
 880                 val = SAMPLING_FREQ(8) |
 881                       ORIGINAL_SAMP_FREQ(0x7);
 882                 break;
 883         case 96000:
 884                 val = SAMPLING_FREQ(0xa) |
 885                       ORIGINAL_SAMP_FREQ(5);
 886                 break;
 887         case 176400:
 888                 val = SAMPLING_FREQ(0xc) |
 889                       ORIGINAL_SAMP_FREQ(3);
 890                 break;
 891         case 192000:
 892                 val = SAMPLING_FREQ(0xe) |
 893                       ORIGINAL_SAMP_FREQ(1);
 894                 break;
 895         }
 896         val |= 4;
 897         writel(val, dp->regs + COM_CH_STTS_BITS);
 898
 899         writel(SMPL2PKT_EN, dp->regs + SMPL2PKT_CNTL);
 900         writel(I2S_DEC_START, dp->regs + AUDIO_SRC_CNTL);
 901 }
 902
 903 static void cdn_dp_audio_config_spdif(struct cdn_dp_device *dp)
 904 {
 905         u32 val;
 906
 907         val = SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS;
 908         val |= SPDIF_FIFO_MID_RANGE(0xe0);
 909         val |= SPDIF_JITTER_THRSH(0xe0);
 910         val |= SPDIF_JITTER_AVG_WIN(7);
 911         writel(val, dp->regs + SPDIF_CTRL_ADDR);
 912
 913         writel(SYNC_WR_TO_CH_ZERO, dp->regs + FIFO_CNTL);
 914
 915         val = MAX_NUM_CH(2) | AUDIO_TYPE_LPCM | CFG_SUB_PCKT_NUM(4);
 916         writel(val, dp->regs + SMPL2PKT_CNFG);
 917         writel(SMPL2PKT_EN, dp->regs + SMPL2PKT_CNTL);
 918
 919         val = SPDIF_ENABLE | SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS;
 920         val |= SPDIF_FIFO_MID_RANGE(0xe0);
 921         val |= SPDIF_JITTER_THRSH(0xe0);
 922         val |= SPDIF_JITTER_AVG_WIN(7);
 923         writel(val, dp->regs + SPDIF_CTRL_ADDR);
 924
 925         clk_prepare_enable(dp->spdif_clk);
 926         clk_set_rate(dp->spdif_clk, CDN_DP_SPDIF_CLK);
 927 }
 928
 929 int cdn_dp_audio_config(struct cdn_dp_device *dp, struct audio_info *audio)
 930 {
 931         int ret;
 932
 933         /* reset the spdif clk before config */
 934         if (audio->format == AFMT_SPDIF) {
 935                 reset_control_assert(dp->spdif_rst);
 936                 reset_control_deassert(dp->spdif_rst);
 937         }
 938
 939         ret = cdn_dp_reg_write(dp, CM_LANE_CTRL, LANE_REF_CYC);
 940         if (ret)
 941                 goto err_audio_config;
 942
 943         ret = cdn_dp_reg_write(dp, CM_CTRL, 0);
 944         if (ret)
 945                 goto err_audio_config;
 946
 947         if (audio->format == AFMT_I2S)
 948                 cdn_dp_audio_config_i2s(dp, audio);
 949         else
 950                 cdn_dp_audio_config_spdif(dp);
 951
 952         ret = cdn_dp_reg_write(dp, AUDIO_PACK_CONTROL, AUDIO_PACK_EN);
 953
 954 err_audio_config:
 955         if (ret)
 956                 dev_err(dp->dev, "audio config failed: %d\n", ret);
 957         return ret;
 958 }