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 } 962