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 <drm/drmP.h> 16 #include <drm/drm_atomic_helper.h> 17 #include <drm/drm_crtc_helper.h> 18 #include <drm/drm_dp_helper.h> 19 #include <drm/drm_edid.h> 20 #include <drm/drm_of.h> 21 22 #include <linux/clk.h> 23 #include <linux/component.h> 24 #include <linux/extcon.h> 25 #include <linux/firmware.h> 26 #include <linux/regmap.h> 27 #include <linux/reset.h> 28 #include <linux/mfd/syscon.h> 29 #include <linux/phy/phy.h> 30 31 #include <sound/hdmi-codec.h> 32 33 #include "cdn-dp-core.h" 34 #include "cdn-dp-reg.h" 35 #include "rockchip_drm_vop.h" 36 37 #define connector_to_dp(c) \ 38 container_of(c, struct cdn_dp_device, connector) 39 40 #define encoder_to_dp(c) \ 41 container_of(c, struct cdn_dp_device, encoder) 42 43 #define GRF_SOC_CON9 0x6224 44 #define DP_SEL_VOP_LIT BIT(12) 45 #define GRF_SOC_CON26 0x6268 46 #define UPHY_SEL_BIT 3 47 #define UPHY_SEL_MASK BIT(19) 48 #define DPTX_HPD_SEL (3 << 12) 49 #define DPTX_HPD_DEL (2 << 12) 50 #define DPTX_HPD_SEL_MASK (3 << 28) 51 52 #define CDN_FW_TIMEOUT_MS (64 * 1000) 53 #define CDN_DPCD_TIMEOUT_MS 5000 54 #define CDN_DP_FIRMWARE "rockchip/dptx.bin" 55 56 struct cdn_dp_data { 57 u8 max_phy; 58 }; 59 60 struct cdn_dp_data rk3399_cdn_dp = { 61 .max_phy = 2, 62 }; 63 64 static const struct of_device_id cdn_dp_dt_ids[] = { 65 { .compatible = "rockchip,rk3399-cdn-dp", 66 .data = (void *)&rk3399_cdn_dp }, 67 {} 68 }; 69 70 MODULE_DEVICE_TABLE(of, cdn_dp_dt_ids); 71 72 static int cdn_dp_grf_write(struct cdn_dp_device *dp, 73 unsigned int reg, unsigned int val) 74 { 75 int ret; 76 77 ret = clk_prepare_enable(dp->grf_clk); 78 if (ret) { 79 DRM_DEV_ERROR(dp->dev, "Failed to prepare_enable grf clock\n"); 80 return ret; 81 } 82 83 ret = regmap_write(dp->grf, reg, val); 84 if (ret) { 85 DRM_DEV_ERROR(dp->dev, "Could not write to GRF: %d\n", ret); 86 return ret; 87 } 88 89 clk_disable_unprepare(dp->grf_clk); 90 91 return 0; 92 } 93 94 static int cdn_dp_clk_enable(struct cdn_dp_device *dp) 95 { 96 int ret; 97 u32 rate; 98 99 ret = clk_prepare_enable(dp->pclk); 100 if (ret < 0) { 101 DRM_DEV_ERROR(dp->dev, "cannot enable dp pclk %d\n", ret); 102 goto err_pclk; 103 } 104 105 ret = clk_prepare_enable(dp->core_clk); 106 if (ret < 0) { 107 DRM_DEV_ERROR(dp->dev, "cannot enable core_clk %d\n", ret); 108 goto err_core_clk; 109 } 110 111 ret = pm_runtime_get_sync(dp->dev); 112 if (ret < 0) { 113 DRM_DEV_ERROR(dp->dev, "cannot get pm runtime %d\n", ret); 114 goto err_pclk; 115 } 116 117 reset_control_assert(dp->core_rst); 118 reset_control_assert(dp->dptx_rst); 119 reset_control_assert(dp->apb_rst); 120 reset_control_deassert(dp->core_rst); 121 reset_control_deassert(dp->dptx_rst); 122 reset_control_deassert(dp->apb_rst); 123 124 rate = clk_get_rate(dp->core_clk); 125 if (!rate) { 126 DRM_DEV_ERROR(dp->dev, "get clk rate failed: %d\n", rate); 127 goto err_set_rate; 128 } 129 130 cdn_dp_set_fw_clk(dp, rate); 131 cdn_dp_clock_reset(dp); 132 133 return 0; 134 135 err_set_rate: 136 clk_disable_unprepare(dp->core_clk); 137 err_core_clk: 138 clk_disable_unprepare(dp->pclk); 139 err_pclk: 140 return ret; 141 } 142 143 static void cdn_dp_clk_disable(struct cdn_dp_device *dp) 144 { 145 pm_runtime_put_sync(dp->dev); 146 clk_disable_unprepare(dp->pclk); 147 clk_disable_unprepare(dp->core_clk); 148 } 149 150 static int cdn_dp_get_port_lanes(struct cdn_dp_port *port) 151 { 152 struct extcon_dev *edev = port->extcon; 153 union extcon_property_value property; 154 int dptx; 155 u8 lanes; 156 157 dptx = extcon_get_state(edev, EXTCON_DISP_DP); 158 if (dptx > 0) { 159 extcon_get_property(edev, EXTCON_DISP_DP, 160 EXTCON_PROP_USB_SS, &property); 161 if (property.intval) 162 lanes = 2; 163 else 164 lanes = 4; 165 } else { 166 lanes = 0; 167 } 168 169 return lanes; 170 } 171 172 static int cdn_dp_get_sink_count(struct cdn_dp_device *dp, u8 *sink_count) 173 { 174 int ret; 175 u8 value; 176 177 *sink_count = 0; 178 ret = cdn_dp_dpcd_read(dp, DP_SINK_COUNT, &value, 1); 179 if (ret) 180 return ret; 181 182 *sink_count = DP_GET_SINK_COUNT(value); 183 return 0; 184 } 185 186 static struct cdn_dp_port *cdn_dp_connected_port(struct cdn_dp_device *dp) 187 { 188 struct cdn_dp_port *port; 189 int i, lanes; 190 191 for (i = 0; i < dp->ports; i++) { 192 port = dp->port[i]; 193 lanes = cdn_dp_get_port_lanes(port); 194 if (lanes) 195 return port; 196 } 197 return NULL; 198 } 199 200 static bool cdn_dp_check_sink_connection(struct cdn_dp_device *dp) 201 { 202 unsigned long timeout = jiffies + msecs_to_jiffies(CDN_DPCD_TIMEOUT_MS); 203 struct cdn_dp_port *port; 204 u8 sink_count = 0; 205 206 if (dp->active_port < 0 || dp->active_port >= dp->ports) { 207 DRM_DEV_ERROR(dp->dev, "active_port is wrong!\n"); 208 return false; 209 } 210 211 port = dp->port[dp->active_port]; 212 213 /* 214 * Attempt to read sink count, retry in case the sink may not be ready. 215 * 216 * Sinks are *supposed* to come up within 1ms from an off state, but 217 * some docks need more time to power up. 218 */ 219 while (time_before(jiffies, timeout)) { 220 if (!extcon_get_state(port->extcon, EXTCON_DISP_DP)) 221 return false; 222 223 if (!cdn_dp_get_sink_count(dp, &sink_count)) 224 return sink_count ? true : false; 225 226 usleep_range(5000, 10000); 227 } 228 229 DRM_DEV_ERROR(dp->dev, "Get sink capability timed out\n"); 230 return false; 231 } 232 233 static enum drm_connector_status 234 cdn_dp_connector_detect(struct drm_connector *connector, bool force) 235 { 236 struct cdn_dp_device *dp = connector_to_dp(connector); 237 enum drm_connector_status status = connector_status_disconnected; 238 239 mutex_lock(&dp->lock); 240 if (dp->connected) 241 status = connector_status_connected; 242 mutex_unlock(&dp->lock); 243 244 return status; 245 } 246 247 static void cdn_dp_connector_destroy(struct drm_connector *connector) 248 { 249 drm_connector_unregister(connector); 250 drm_connector_cleanup(connector); 251 } 252 253 static const struct drm_connector_funcs cdn_dp_atomic_connector_funcs = { 254 .dpms = drm_atomic_helper_connector_dpms, 255 .detect = cdn_dp_connector_detect, 256 .destroy = cdn_dp_connector_destroy, 257 .fill_modes = drm_helper_probe_single_connector_modes, 258 .reset = drm_atomic_helper_connector_reset, 259 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 260 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 261 }; 262 263 static int cdn_dp_connector_get_modes(struct drm_connector *connector) 264 { 265 struct cdn_dp_device *dp = connector_to_dp(connector); 266 struct edid *edid; 267 int ret = 0; 268 269 mutex_lock(&dp->lock); 270 edid = dp->edid; 271 if (edid) { 272 DRM_DEV_DEBUG_KMS(dp->dev, "got edid: width[%d] x height[%d]\n", 273 edid->width_cm, edid->height_cm); 274 275 dp->sink_has_audio = drm_detect_monitor_audio(edid); 276 ret = drm_add_edid_modes(connector, edid); 277 if (ret) { 278 drm_mode_connector_update_edid_property(connector, 279 edid); 280 drm_edid_to_eld(connector, edid); 281 } 282 } 283 mutex_unlock(&dp->lock); 284 285 return ret; 286 } 287 288 static struct drm_encoder * 289 cdn_dp_connector_best_encoder(struct drm_connector *connector) 290 { 291 struct cdn_dp_device *dp = connector_to_dp(connector); 292 293 return &dp->encoder; 294 } 295 296 static int cdn_dp_connector_mode_valid(struct drm_connector *connector, 297 struct drm_display_mode *mode) 298 { 299 struct cdn_dp_device *dp = connector_to_dp(connector); 300 struct drm_display_info *display_info = &dp->connector.display_info; 301 u32 requested, actual, rate, sink_max, source_max = 0; 302 u8 lanes, bpc; 303 304 /* If DP is disconnected, every mode is invalid */ 305 if (!dp->connected) 306 return MODE_BAD; 307 308 switch (display_info->bpc) { 309 case 10: 310 bpc = 10; 311 break; 312 case 6: 313 bpc = 6; 314 break; 315 default: 316 bpc = 8; 317 break; 318 } 319 320 requested = mode->clock * bpc * 3 / 1000; 321 322 source_max = dp->lanes; 323 sink_max = drm_dp_max_lane_count(dp->dpcd); 324 lanes = min(source_max, sink_max); 325 326 source_max = drm_dp_bw_code_to_link_rate(CDN_DP_MAX_LINK_RATE); 327 sink_max = drm_dp_max_link_rate(dp->dpcd); 328 rate = min(source_max, sink_max); 329 330 actual = rate * lanes / 100; 331 332 /* efficiency is about 0.8 */ 333 actual = actual * 8 / 10; 334 335 if (requested > actual) { 336 DRM_DEV_DEBUG_KMS(dp->dev, 337 "requested=%d, actual=%d, clock=%d\n", 338 requested, actual, mode->clock); 339 return MODE_CLOCK_HIGH; 340 } 341 342 return MODE_OK; 343 } 344 345 static struct drm_connector_helper_funcs cdn_dp_connector_helper_funcs = { 346 .get_modes = cdn_dp_connector_get_modes, 347 .best_encoder = cdn_dp_connector_best_encoder, 348 .mode_valid = cdn_dp_connector_mode_valid, 349 }; 350 351 static int cdn_dp_firmware_init(struct cdn_dp_device *dp) 352 { 353 int ret; 354 const u32 *iram_data, *dram_data; 355 const struct firmware *fw = dp->fw; 356 const struct cdn_firmware_header *hdr; 357 358 hdr = (struct cdn_firmware_header *)fw->data; 359 if (fw->size != le32_to_cpu(hdr->size_bytes)) { 360 DRM_DEV_ERROR(dp->dev, "firmware is invalid\n"); 361 return -EINVAL; 362 } 363 364 iram_data = (const u32 *)(fw->data + hdr->header_size); 365 dram_data = (const u32 *)(fw->data + hdr->header_size + hdr->iram_size); 366 367 ret = cdn_dp_load_firmware(dp, iram_data, hdr->iram_size, 368 dram_data, hdr->dram_size); 369 if (ret) 370 return ret; 371 372 ret = cdn_dp_set_firmware_active(dp, true); 373 if (ret) { 374 DRM_DEV_ERROR(dp->dev, "active ucpu failed: %d\n", ret); 375 return ret; 376 } 377 378 return cdn_dp_event_config(dp); 379 } 380 381 static int cdn_dp_get_sink_capability(struct cdn_dp_device *dp) 382 { 383 int ret; 384 385 if (!cdn_dp_check_sink_connection(dp)) 386 return -ENODEV; 387 388 ret = cdn_dp_dpcd_read(dp, DP_DPCD_REV, dp->dpcd, 389 DP_RECEIVER_CAP_SIZE); 390 if (ret) { 391 DRM_DEV_ERROR(dp->dev, "Failed to get caps %d\n", ret); 392 return ret; 393 } 394 395 kfree(dp->edid); 396 dp->edid = drm_do_get_edid(&dp->connector, 397 cdn_dp_get_edid_block, dp); 398 return 0; 399 } 400 401 static int cdn_dp_enable_phy(struct cdn_dp_device *dp, struct cdn_dp_port *port) 402 { 403 union extcon_property_value property; 404 int ret; 405 406 ret = cdn_dp_grf_write(dp, GRF_SOC_CON26, 407 (port->id << UPHY_SEL_BIT) | UPHY_SEL_MASK); 408 if (ret) 409 return ret; 410 411 if (!port->phy_enabled) { 412 ret = phy_power_on(port->phy); 413 if (ret) { 414 DRM_DEV_ERROR(dp->dev, "phy power on failed: %d\n", 415 ret); 416 goto err_phy; 417 } 418 port->phy_enabled = true; 419 } 420 421 ret = cdn_dp_grf_write(dp, GRF_SOC_CON26, 422 DPTX_HPD_SEL_MASK | DPTX_HPD_SEL); 423 if (ret) { 424 DRM_DEV_ERROR(dp->dev, "Failed to write HPD_SEL %d\n", ret); 425 goto err_power_on; 426 } 427 428 ret = cdn_dp_get_hpd_status(dp); 429 if (ret <= 0) { 430 if (!ret) 431 DRM_DEV_ERROR(dp->dev, "hpd does not exist\n"); 432 goto err_power_on; 433 } 434 435 ret = extcon_get_property(port->extcon, EXTCON_DISP_DP, 436 EXTCON_PROP_USB_TYPEC_POLARITY, &property); 437 if (ret) { 438 DRM_DEV_ERROR(dp->dev, "get property failed\n"); 439 goto err_power_on; 440 } 441 442 port->lanes = cdn_dp_get_port_lanes(port); 443 ret = cdn_dp_set_host_cap(dp, port->lanes, property.intval); 444 if (ret) { 445 DRM_DEV_ERROR(dp->dev, "set host capabilities failed: %d\n", 446 ret); 447 goto err_power_on; 448 } 449 450 dp->active_port = port->id; 451 return 0; 452 453 err_power_on: 454 if (phy_power_off(port->phy)) 455 DRM_DEV_ERROR(dp->dev, "phy power off failed: %d", ret); 456 else 457 port->phy_enabled = false; 458 459 err_phy: 460 cdn_dp_grf_write(dp, GRF_SOC_CON26, 461 DPTX_HPD_SEL_MASK | DPTX_HPD_DEL); 462 return ret; 463 } 464 465 static int cdn_dp_disable_phy(struct cdn_dp_device *dp, 466 struct cdn_dp_port *port) 467 { 468 int ret; 469 470 if (port->phy_enabled) { 471 ret = phy_power_off(port->phy); 472 if (ret) { 473 DRM_DEV_ERROR(dp->dev, "phy power off failed: %d", ret); 474 return ret; 475 } 476 } 477 478 port->phy_enabled = false; 479 port->lanes = 0; 480 dp->active_port = -1; 481 return 0; 482 } 483 484 static int cdn_dp_disable(struct cdn_dp_device *dp) 485 { 486 int ret, i; 487 488 if (!dp->active) 489 return 0; 490 491 for (i = 0; i < dp->ports; i++) 492 cdn_dp_disable_phy(dp, dp->port[i]); 493 494 ret = cdn_dp_grf_write(dp, GRF_SOC_CON26, 495 DPTX_HPD_SEL_MASK | DPTX_HPD_DEL); 496 if (ret) { 497 DRM_DEV_ERROR(dp->dev, "Failed to clear hpd sel %d\n", 498 ret); 499 return ret; 500 } 501 502 cdn_dp_set_firmware_active(dp, false); 503 cdn_dp_clk_disable(dp); 504 dp->active = false; 505 dp->link.rate = 0; 506 dp->link.num_lanes = 0; 507 if (!dp->connected) { 508 kfree(dp->edid); 509 dp->edid = NULL; 510 } 511 512 return 0; 513 } 514 515 static int cdn_dp_enable(struct cdn_dp_device *dp) 516 { 517 int ret, i, lanes; 518 struct cdn_dp_port *port; 519 520 port = cdn_dp_connected_port(dp); 521 if (!port) { 522 DRM_DEV_ERROR(dp->dev, 523 "Can't enable without connection\n"); 524 return -ENODEV; 525 } 526 527 if (dp->active) 528 return 0; 529 530 ret = cdn_dp_clk_enable(dp); 531 if (ret) 532 return ret; 533 534 ret = cdn_dp_firmware_init(dp); 535 if (ret) { 536 DRM_DEV_ERROR(dp->dev, "firmware init failed: %d", ret); 537 goto err_clk_disable; 538 } 539 540 /* only enable the port that connected with downstream device */ 541 for (i = port->id; i < dp->ports; i++) { 542 port = dp->port[i]; 543 lanes = cdn_dp_get_port_lanes(port); 544 if (lanes) { 545 ret = cdn_dp_enable_phy(dp, port); 546 if (ret) 547 continue; 548 549 ret = cdn_dp_get_sink_capability(dp); 550 if (ret) { 551 cdn_dp_disable_phy(dp, port); 552 } else { 553 dp->active = true; 554 dp->lanes = port->lanes; 555 return 0; 556 } 557 } 558 } 559 560 err_clk_disable: 561 cdn_dp_clk_disable(dp); 562 return ret; 563 } 564 565 static void cdn_dp_encoder_mode_set(struct drm_encoder *encoder, 566 struct drm_display_mode *mode, 567 struct drm_display_mode *adjusted) 568 { 569 struct cdn_dp_device *dp = encoder_to_dp(encoder); 570 struct drm_display_info *display_info = &dp->connector.display_info; 571 struct video_info *video = &dp->video_info; 572 573 switch (display_info->bpc) { 574 case 10: 575 video->color_depth = 10; 576 break; 577 case 6: 578 video->color_depth = 6; 579 break; 580 default: 581 video->color_depth = 8; 582 break; 583 } 584 585 video->color_fmt = PXL_RGB; 586 video->v_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NVSYNC); 587 video->h_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NHSYNC); 588 589 memcpy(&dp->mode, adjusted, sizeof(*mode)); 590 } 591 592 static bool cdn_dp_check_link_status(struct cdn_dp_device *dp) 593 { 594 u8 link_status[DP_LINK_STATUS_SIZE]; 595 struct cdn_dp_port *port = cdn_dp_connected_port(dp); 596 u8 sink_lanes = drm_dp_max_lane_count(dp->dpcd); 597 598 if (!port || !dp->link.rate || !dp->link.num_lanes) 599 return false; 600 601 if (cdn_dp_dpcd_read(dp, DP_LANE0_1_STATUS, link_status, 602 DP_LINK_STATUS_SIZE)) { 603 DRM_ERROR("Failed to get link status\n"); 604 return false; 605 } 606 607 /* if link training is requested we should perform it always */ 608 return drm_dp_channel_eq_ok(link_status, min(port->lanes, sink_lanes)); 609 } 610 611 static void cdn_dp_encoder_enable(struct drm_encoder *encoder) 612 { 613 struct cdn_dp_device *dp = encoder_to_dp(encoder); 614 int ret, val; 615 struct rockchip_crtc_state *state; 616 617 ret = drm_of_encoder_active_endpoint_id(dp->dev->of_node, encoder); 618 if (ret < 0) { 619 DRM_DEV_ERROR(dp->dev, "Could not get vop id, %d", ret); 620 return; 621 } 622 623 DRM_DEV_DEBUG_KMS(dp->dev, "vop %s output to cdn-dp\n", 624 (ret) ? "LIT" : "BIG"); 625 state = to_rockchip_crtc_state(encoder->crtc->state); 626 if (ret) { 627 val = DP_SEL_VOP_LIT | (DP_SEL_VOP_LIT << 16); 628 state->output_mode = ROCKCHIP_OUT_MODE_P888; 629 } else { 630 val = DP_SEL_VOP_LIT << 16; 631 state->output_mode = ROCKCHIP_OUT_MODE_AAAA; 632 } 633 634 ret = cdn_dp_grf_write(dp, GRF_SOC_CON9, val); 635 if (ret) 636 return; 637 638 mutex_lock(&dp->lock); 639 640 ret = cdn_dp_enable(dp); 641 if (ret) { 642 DRM_DEV_ERROR(dp->dev, "Failed to enable encoder %d\n", 643 ret); 644 goto out; 645 } 646 if (!cdn_dp_check_link_status(dp)) { 647 ret = cdn_dp_train_link(dp); 648 if (ret) { 649 DRM_DEV_ERROR(dp->dev, "Failed link train %d\n", ret); 650 goto out; 651 } 652 } 653 654 ret = cdn_dp_set_video_status(dp, CONTROL_VIDEO_IDLE); 655 if (ret) { 656 DRM_DEV_ERROR(dp->dev, "Failed to idle video %d\n", ret); 657 goto out; 658 } 659 660 ret = cdn_dp_config_video(dp); 661 if (ret) { 662 DRM_DEV_ERROR(dp->dev, "Failed to config video %d\n", ret); 663 goto out; 664 } 665 666 ret = cdn_dp_set_video_status(dp, CONTROL_VIDEO_VALID); 667 if (ret) { 668 DRM_DEV_ERROR(dp->dev, "Failed to valid video %d\n", ret); 669 goto out; 670 } 671 out: 672 mutex_unlock(&dp->lock); 673 } 674 675 static void cdn_dp_encoder_disable(struct drm_encoder *encoder) 676 { 677 struct cdn_dp_device *dp = encoder_to_dp(encoder); 678 int ret; 679 680 mutex_lock(&dp->lock); 681 if (dp->active) { 682 ret = cdn_dp_disable(dp); 683 if (ret) { 684 DRM_DEV_ERROR(dp->dev, "Failed to disable encoder %d\n", 685 ret); 686 } 687 } 688 mutex_unlock(&dp->lock); 689 690 /* 691 * In the following 2 cases, we need to run the event_work to re-enable 692 * the DP: 693 * 1. If there is not just one port device is connected, and remove one 694 * device from a port, the DP will be disabled here, at this case, 695 * run the event_work to re-open DP for the other port. 696 * 2. If re-training or re-config failed, the DP will be disabled here. 697 * run the event_work to re-connect it. 698 */ 699 if (!dp->connected && cdn_dp_connected_port(dp)) 700 schedule_work(&dp->event_work); 701 } 702 703 static int cdn_dp_encoder_atomic_check(struct drm_encoder *encoder, 704 struct drm_crtc_state *crtc_state, 705 struct drm_connector_state *conn_state) 706 { 707 struct rockchip_crtc_state *s = to_rockchip_crtc_state(crtc_state); 708 709 s->output_mode = ROCKCHIP_OUT_MODE_AAAA; 710 s->output_type = DRM_MODE_CONNECTOR_DisplayPort; 711 712 return 0; 713 } 714 715 static const struct drm_encoder_helper_funcs cdn_dp_encoder_helper_funcs = { 716 .mode_set = cdn_dp_encoder_mode_set, 717 .enable = cdn_dp_encoder_enable, 718 .disable = cdn_dp_encoder_disable, 719 .atomic_check = cdn_dp_encoder_atomic_check, 720 }; 721 722 static const struct drm_encoder_funcs cdn_dp_encoder_funcs = { 723 .destroy = drm_encoder_cleanup, 724 }; 725 726 static int cdn_dp_parse_dt(struct cdn_dp_device *dp) 727 { 728 struct device *dev = dp->dev; 729 struct device_node *np = dev->of_node; 730 struct platform_device *pdev = to_platform_device(dev); 731 struct resource *res; 732 733 dp->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf"); 734 if (IS_ERR(dp->grf)) { 735 DRM_DEV_ERROR(dev, "cdn-dp needs rockchip,grf property\n"); 736 return PTR_ERR(dp->grf); 737 } 738 739 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 740 dp->regs = devm_ioremap_resource(dev, res); 741 if (IS_ERR(dp->regs)) { 742 DRM_DEV_ERROR(dev, "ioremap reg failed\n"); 743 return PTR_ERR(dp->regs); 744 } 745 746 dp->core_clk = devm_clk_get(dev, "core-clk"); 747 if (IS_ERR(dp->core_clk)) { 748 DRM_DEV_ERROR(dev, "cannot get core_clk_dp\n"); 749 return PTR_ERR(dp->core_clk); 750 } 751 752 dp->pclk = devm_clk_get(dev, "pclk"); 753 if (IS_ERR(dp->pclk)) { 754 DRM_DEV_ERROR(dev, "cannot get pclk\n"); 755 return PTR_ERR(dp->pclk); 756 } 757 758 dp->spdif_clk = devm_clk_get(dev, "spdif"); 759 if (IS_ERR(dp->spdif_clk)) { 760 DRM_DEV_ERROR(dev, "cannot get spdif_clk\n"); 761 return PTR_ERR(dp->spdif_clk); 762 } 763 764 dp->grf_clk = devm_clk_get(dev, "grf"); 765 if (IS_ERR(dp->grf_clk)) { 766 DRM_DEV_ERROR(dev, "cannot get grf clk\n"); 767 return PTR_ERR(dp->grf_clk); 768 } 769 770 dp->spdif_rst = devm_reset_control_get(dev, "spdif"); 771 if (IS_ERR(dp->spdif_rst)) { 772 DRM_DEV_ERROR(dev, "no spdif reset control found\n"); 773 return PTR_ERR(dp->spdif_rst); 774 } 775 776 dp->dptx_rst = devm_reset_control_get(dev, "dptx"); 777 if (IS_ERR(dp->dptx_rst)) { 778 DRM_DEV_ERROR(dev, "no uphy reset control found\n"); 779 return PTR_ERR(dp->dptx_rst); 780 } 781 782 dp->core_rst = devm_reset_control_get(dev, "core"); 783 if (IS_ERR(dp->core_rst)) { 784 DRM_DEV_ERROR(dev, "no core reset control found\n"); 785 return PTR_ERR(dp->core_rst); 786 } 787 788 dp->apb_rst = devm_reset_control_get(dev, "apb"); 789 if (IS_ERR(dp->apb_rst)) { 790 DRM_DEV_ERROR(dev, "no apb reset control found\n"); 791 return PTR_ERR(dp->apb_rst); 792 } 793 794 return 0; 795 } 796 797 static int cdn_dp_audio_hw_params(struct device *dev, void *data, 798 struct hdmi_codec_daifmt *daifmt, 799 struct hdmi_codec_params *params) 800 { 801 struct cdn_dp_device *dp = dev_get_drvdata(dev); 802 struct audio_info audio = { 803 .sample_width = params->sample_width, 804 .sample_rate = params->sample_rate, 805 .channels = params->channels, 806 }; 807 int ret; 808 809 mutex_lock(&dp->lock); 810 if (!dp->active) { 811 ret = -ENODEV; 812 goto out; 813 } 814 815 switch (daifmt->fmt) { 816 case HDMI_I2S: 817 audio.format = AFMT_I2S; 818 break; 819 case HDMI_SPDIF: 820 audio.format = AFMT_SPDIF; 821 break; 822 default: 823 DRM_DEV_ERROR(dev, "Invalid format %d\n", daifmt->fmt); 824 ret = -EINVAL; 825 goto out; 826 } 827 828 ret = cdn_dp_audio_config(dp, &audio); 829 if (!ret) 830 dp->audio_info = audio; 831 832 out: 833 mutex_unlock(&dp->lock); 834 return ret; 835 } 836 837 static void cdn_dp_audio_shutdown(struct device *dev, void *data) 838 { 839 struct cdn_dp_device *dp = dev_get_drvdata(dev); 840 int ret; 841 842 mutex_lock(&dp->lock); 843 if (!dp->active) 844 goto out; 845 846 ret = cdn_dp_audio_stop(dp, &dp->audio_info); 847 if (!ret) 848 dp->audio_info.format = AFMT_UNUSED; 849 out: 850 mutex_unlock(&dp->lock); 851 } 852 853 static int cdn_dp_audio_digital_mute(struct device *dev, void *data, 854 bool enable) 855 { 856 struct cdn_dp_device *dp = dev_get_drvdata(dev); 857 int ret; 858 859 mutex_lock(&dp->lock); 860 if (!dp->active) { 861 ret = -ENODEV; 862 goto out; 863 } 864 865 ret = cdn_dp_audio_mute(dp, enable); 866 867 out: 868 mutex_unlock(&dp->lock); 869 return ret; 870 } 871 872 static int cdn_dp_audio_get_eld(struct device *dev, void *data, 873 u8 *buf, size_t len) 874 { 875 struct cdn_dp_device *dp = dev_get_drvdata(dev); 876 877 memcpy(buf, dp->connector.eld, min(sizeof(dp->connector.eld), len)); 878 879 return 0; 880 } 881 882 static const struct hdmi_codec_ops audio_codec_ops = { 883 .hw_params = cdn_dp_audio_hw_params, 884 .audio_shutdown = cdn_dp_audio_shutdown, 885 .digital_mute = cdn_dp_audio_digital_mute, 886 .get_eld = cdn_dp_audio_get_eld, 887 }; 888 889 static int cdn_dp_audio_codec_init(struct cdn_dp_device *dp, 890 struct device *dev) 891 { 892 struct hdmi_codec_pdata codec_data = { 893 .i2s = 1, 894 .spdif = 1, 895 .ops = &audio_codec_ops, 896 .max_i2s_channels = 8, 897 }; 898 899 dp->audio_pdev = platform_device_register_data( 900 dev, HDMI_CODEC_DRV_NAME, PLATFORM_DEVID_AUTO, 901 &codec_data, sizeof(codec_data)); 902 903 return PTR_ERR_OR_ZERO(dp->audio_pdev); 904 } 905 906 static int cdn_dp_request_firmware(struct cdn_dp_device *dp) 907 { 908 int ret; 909 unsigned long timeout = jiffies + msecs_to_jiffies(CDN_FW_TIMEOUT_MS); 910 unsigned long sleep = 1000; 911 912 WARN_ON(!mutex_is_locked(&dp->lock)); 913 914 if (dp->fw_loaded) 915 return 0; 916 917 /* Drop the lock before getting the firmware to avoid blocking boot */ 918 mutex_unlock(&dp->lock); 919 920 while (time_before(jiffies, timeout)) { 921 ret = request_firmware(&dp->fw, CDN_DP_FIRMWARE, dp->dev); 922 if (ret == -ENOENT) { 923 msleep(sleep); 924 sleep *= 2; 925 continue; 926 } else if (ret) { 927 DRM_DEV_ERROR(dp->dev, 928 "failed to request firmware: %d\n", ret); 929 goto out; 930 } 931 932 dp->fw_loaded = true; 933 ret = 0; 934 goto out; 935 } 936 937 DRM_DEV_ERROR(dp->dev, "Timed out trying to load firmware\n"); 938 ret = -ETIMEDOUT; 939 out: 940 mutex_lock(&dp->lock); 941 return ret; 942 } 943 944 static void cdn_dp_pd_event_work(struct work_struct *work) 945 { 946 struct cdn_dp_device *dp = container_of(work, struct cdn_dp_device, 947 event_work); 948 struct drm_connector *connector = &dp->connector; 949 enum drm_connector_status old_status; 950 951 int ret; 952 953 mutex_lock(&dp->lock); 954 955 if (dp->suspended) 956 goto out; 957 958 ret = cdn_dp_request_firmware(dp); 959 if (ret) 960 goto out; 961 962 dp->connected = true; 963 964 /* Not connected, notify userspace to disable the block */ 965 if (!cdn_dp_connected_port(dp)) { 966 DRM_DEV_INFO(dp->dev, "Not connected. Disabling cdn\n"); 967 dp->connected = false; 968 969 /* Connected but not enabled, enable the block */ 970 } else if (!dp->active) { 971 DRM_DEV_INFO(dp->dev, "Connected, not enabled. Enabling cdn\n"); 972 ret = cdn_dp_enable(dp); 973 if (ret) { 974 DRM_DEV_ERROR(dp->dev, "Enable dp failed %d\n", ret); 975 dp->connected = false; 976 } 977 978 /* Enabled and connected to a dongle without a sink, notify userspace */ 979 } else if (!cdn_dp_check_sink_connection(dp)) { 980 DRM_DEV_INFO(dp->dev, "Connected without sink. Assert hpd\n"); 981 dp->connected = false; 982 983 /* Enabled and connected with a sink, re-train if requested */ 984 } else if (!cdn_dp_check_link_status(dp)) { 985 unsigned int rate = dp->link.rate; 986 unsigned int lanes = dp->link.num_lanes; 987 struct drm_display_mode *mode = &dp->mode; 988 989 DRM_DEV_INFO(dp->dev, "Connected with sink. Re-train link\n"); 990 ret = cdn_dp_train_link(dp); 991 if (ret) { 992 dp->connected = false; 993 DRM_DEV_ERROR(dp->dev, "Train link failed %d\n", ret); 994 goto out; 995 } 996 997 /* If training result is changed, update the video config */ 998 if (mode->clock && 999 (rate != dp->link.rate || lanes != dp->link.num_lanes)) { 1000 ret = cdn_dp_config_video(dp); 1001 if (ret) { 1002 dp->connected = false; 1003 DRM_DEV_ERROR(dp->dev, 1004 "Failed to config video %d\n", 1005 ret); 1006 } 1007 } 1008 } 1009 1010 out: 1011 mutex_unlock(&dp->lock); 1012 1013 old_status = connector->status; 1014 connector->status = connector->funcs->detect(connector, false); 1015 if (old_status != connector->status) 1016 drm_kms_helper_hotplug_event(dp->drm_dev); 1017 } 1018 1019 static int cdn_dp_pd_event(struct notifier_block *nb, 1020 unsigned long event, void *priv) 1021 { 1022 struct cdn_dp_port *port = container_of(nb, struct cdn_dp_port, 1023 event_nb); 1024 struct cdn_dp_device *dp = port->dp; 1025 1026 /* 1027 * It would be nice to be able to just do the work inline right here. 1028 * However, we need to make a bunch of calls that might sleep in order 1029 * to turn on the block/phy, so use a worker instead. 1030 */ 1031 schedule_work(&dp->event_work); 1032 1033 return NOTIFY_DONE; 1034 } 1035 1036 static int cdn_dp_bind(struct device *dev, struct device *master, void *data) 1037 { 1038 struct cdn_dp_device *dp = dev_get_drvdata(dev); 1039 struct drm_encoder *encoder; 1040 struct drm_connector *connector; 1041 struct cdn_dp_port *port; 1042 struct drm_device *drm_dev = data; 1043 int ret, i; 1044 1045 ret = cdn_dp_parse_dt(dp); 1046 if (ret < 0) 1047 return ret; 1048 1049 dp->drm_dev = drm_dev; 1050 dp->connected = false; 1051 dp->active = false; 1052 dp->active_port = -1; 1053 1054 INIT_WORK(&dp->event_work, cdn_dp_pd_event_work); 1055 1056 encoder = &dp->encoder; 1057 1058 encoder->possible_crtcs = drm_of_find_possible_crtcs(drm_dev, 1059 dev->of_node); 1060 DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs); 1061 1062 ret = drm_encoder_init(drm_dev, encoder, &cdn_dp_encoder_funcs, 1063 DRM_MODE_ENCODER_TMDS, NULL); 1064 if (ret) { 1065 DRM_ERROR("failed to initialize encoder with drm\n"); 1066 return ret; 1067 } 1068 1069 drm_encoder_helper_add(encoder, &cdn_dp_encoder_helper_funcs); 1070 1071 connector = &dp->connector; 1072 connector->polled = DRM_CONNECTOR_POLL_HPD; 1073 connector->dpms = DRM_MODE_DPMS_OFF; 1074 1075 ret = drm_connector_init(drm_dev, connector, 1076 &cdn_dp_atomic_connector_funcs, 1077 DRM_MODE_CONNECTOR_DisplayPort); 1078 if (ret) { 1079 DRM_ERROR("failed to initialize connector with drm\n"); 1080 goto err_free_encoder; 1081 } 1082 1083 drm_connector_helper_add(connector, &cdn_dp_connector_helper_funcs); 1084 1085 ret = drm_mode_connector_attach_encoder(connector, encoder); 1086 if (ret) { 1087 DRM_ERROR("failed to attach connector and encoder\n"); 1088 goto err_free_connector; 1089 } 1090 1091 cdn_dp_audio_codec_init(dp, dev); 1092 1093 for (i = 0; i < dp->ports; i++) { 1094 port = dp->port[i]; 1095 1096 port->event_nb.notifier_call = cdn_dp_pd_event; 1097 ret = devm_extcon_register_notifier(dp->dev, port->extcon, 1098 EXTCON_DISP_DP, 1099 &port->event_nb); 1100 if (ret) { 1101 DRM_DEV_ERROR(dev, 1102 "register EXTCON_DISP_DP notifier err\n"); 1103 goto err_free_connector; 1104 } 1105 } 1106 1107 pm_runtime_enable(dev); 1108 1109 schedule_work(&dp->event_work); 1110 1111 return 0; 1112 1113 err_free_connector: 1114 drm_connector_cleanup(connector); 1115 err_free_encoder: 1116 drm_encoder_cleanup(encoder); 1117 return ret; 1118 } 1119 1120 static void cdn_dp_unbind(struct device *dev, struct device *master, void *data) 1121 { 1122 struct cdn_dp_device *dp = dev_get_drvdata(dev); 1123 struct drm_encoder *encoder = &dp->encoder; 1124 struct drm_connector *connector = &dp->connector; 1125 1126 cancel_work_sync(&dp->event_work); 1127 platform_device_unregister(dp->audio_pdev); 1128 cdn_dp_encoder_disable(encoder); 1129 encoder->funcs->destroy(encoder); 1130 connector->funcs->destroy(connector); 1131 1132 pm_runtime_disable(dev); 1133 release_firmware(dp->fw); 1134 kfree(dp->edid); 1135 dp->edid = NULL; 1136 } 1137 1138 static const struct component_ops cdn_dp_component_ops = { 1139 .bind = cdn_dp_bind, 1140 .unbind = cdn_dp_unbind, 1141 }; 1142 1143 int cdn_dp_suspend(struct device *dev) 1144 { 1145 struct cdn_dp_device *dp = dev_get_drvdata(dev); 1146 int ret = 0; 1147 1148 mutex_lock(&dp->lock); 1149 if (dp->active) 1150 ret = cdn_dp_disable(dp); 1151 dp->suspended = true; 1152 mutex_unlock(&dp->lock); 1153 1154 return ret; 1155 } 1156 1157 int cdn_dp_resume(struct device *dev) 1158 { 1159 struct cdn_dp_device *dp = dev_get_drvdata(dev); 1160 1161 mutex_lock(&dp->lock); 1162 dp->suspended = false; 1163 if (dp->fw_loaded) 1164 schedule_work(&dp->event_work); 1165 mutex_unlock(&dp->lock); 1166 1167 return 0; 1168 } 1169 1170 static int cdn_dp_probe(struct platform_device *pdev) 1171 { 1172 struct device *dev = &pdev->dev; 1173 const struct of_device_id *match; 1174 struct cdn_dp_data *dp_data; 1175 struct cdn_dp_port *port; 1176 struct cdn_dp_device *dp; 1177 struct extcon_dev *extcon; 1178 struct phy *phy; 1179 int i; 1180 1181 dp = devm_kzalloc(dev, sizeof(*dp), GFP_KERNEL); 1182 if (!dp) 1183 return -ENOMEM; 1184 dp->dev = dev; 1185 1186 match = of_match_node(cdn_dp_dt_ids, pdev->dev.of_node); 1187 dp_data = (struct cdn_dp_data *)match->data; 1188 1189 for (i = 0; i < dp_data->max_phy; i++) { 1190 extcon = extcon_get_edev_by_phandle(dev, i); 1191 phy = devm_of_phy_get_by_index(dev, dev->of_node, i); 1192 1193 if (PTR_ERR(extcon) == -EPROBE_DEFER || 1194 PTR_ERR(phy) == -EPROBE_DEFER) 1195 return -EPROBE_DEFER; 1196 1197 if (IS_ERR(extcon) || IS_ERR(phy)) 1198 continue; 1199 1200 port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL); 1201 if (!dp) 1202 return -ENOMEM; 1203 1204 port->extcon = extcon; 1205 port->phy = phy; 1206 port->dp = dp; 1207 port->id = i; 1208 dp->port[dp->ports++] = port; 1209 } 1210 1211 if (!dp->ports) { 1212 DRM_DEV_ERROR(dev, "missing extcon or phy\n"); 1213 return -EINVAL; 1214 } 1215 1216 mutex_init(&dp->lock); 1217 dev_set_drvdata(dev, dp); 1218 1219 return component_add(dev, &cdn_dp_component_ops); 1220 } 1221 1222 static int cdn_dp_remove(struct platform_device *pdev) 1223 { 1224 struct cdn_dp_device *dp = platform_get_drvdata(pdev); 1225 1226 cdn_dp_suspend(dp->dev); 1227 component_del(&pdev->dev, &cdn_dp_component_ops); 1228 1229 return 0; 1230 } 1231 1232 static void cdn_dp_shutdown(struct platform_device *pdev) 1233 { 1234 struct cdn_dp_device *dp = platform_get_drvdata(pdev); 1235 1236 cdn_dp_suspend(dp->dev); 1237 } 1238 1239 static const struct dev_pm_ops cdn_dp_pm_ops = { 1240 SET_SYSTEM_SLEEP_PM_OPS(cdn_dp_suspend, 1241 cdn_dp_resume) 1242 }; 1243 1244 static struct platform_driver cdn_dp_driver = { 1245 .probe = cdn_dp_probe, 1246 .remove = cdn_dp_remove, 1247 .shutdown = cdn_dp_shutdown, 1248 .driver = { 1249 .name = "cdn-dp", 1250 .owner = THIS_MODULE, 1251 .of_match_table = of_match_ptr(cdn_dp_dt_ids), 1252 .pm = &cdn_dp_pm_ops, 1253 }, 1254 }; 1255 1256 module_platform_driver(cdn_dp_driver); 1257 1258 MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>"); 1259 MODULE_DESCRIPTION("cdn DP Driver"); 1260 MODULE_LICENSE("GPL v2"); 1261