drivers/gpu/drm/rockchip/cdn-dp-reg.c

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