Lines Matching defs:mhdp
58 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
61 if (mhdp->bridge_attached)
62 writel(readl(mhdp->regs + CDNS_APB_INT_MASK) &
64 mhdp->regs + CDNS_APB_INT_MASK);
69 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
71 writel(readl(mhdp->regs + CDNS_APB_INT_MASK) |
73 mhdp->regs + CDNS_APB_INT_MASK);
76 static int cdns_mhdp_mailbox_read(struct cdns_mhdp_device *mhdp)
80 WARN_ON(!mutex_is_locked(&mhdp->mbox_mutex));
82 ret = readx_poll_timeout(readl, mhdp->regs + CDNS_MAILBOX_EMPTY,
88 return readl(mhdp->regs + CDNS_MAILBOX_RX_DATA) & 0xff;
91 static int cdns_mhdp_mailbox_write(struct cdns_mhdp_device *mhdp, u8 val)
95 WARN_ON(!mutex_is_locked(&mhdp->mbox_mutex));
97 ret = readx_poll_timeout(readl, mhdp->regs + CDNS_MAILBOX_FULL,
103 writel(val, mhdp->regs + CDNS_MAILBOX_TX_DATA);
108 static int cdns_mhdp_mailbox_recv_header(struct cdns_mhdp_device *mhdp,
118 ret = cdns_mhdp_mailbox_read(mhdp);
134 if (cdns_mhdp_mailbox_read(mhdp) < 0)
143 static int cdns_mhdp_mailbox_recv_data(struct cdns_mhdp_device *mhdp,
150 ret = cdns_mhdp_mailbox_read(mhdp);
160 static int cdns_mhdp_mailbox_send(struct cdns_mhdp_device *mhdp, u8 module_id,
171 ret = cdns_mhdp_mailbox_write(mhdp, header[i]);
177 ret = cdns_mhdp_mailbox_write(mhdp, message[i]);
186 int cdns_mhdp_reg_read(struct cdns_mhdp_device *mhdp, u32 addr, u32 *value)
193 mutex_lock(&mhdp->mbox_mutex);
195 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_GENERAL,
201 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_GENERAL,
207 ret = cdns_mhdp_mailbox_recv_data(mhdp, resp, sizeof(resp));
220 mutex_unlock(&mhdp->mbox_mutex);
222 dev_err(mhdp->dev, "Failed to read register\n");
230 int cdns_mhdp_reg_write(struct cdns_mhdp_device *mhdp, u16 addr, u32 val)
238 mutex_lock(&mhdp->mbox_mutex);
240 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
243 mutex_unlock(&mhdp->mbox_mutex);
249 int cdns_mhdp_reg_write_bit(struct cdns_mhdp_device *mhdp, u16 addr,
260 mutex_lock(&mhdp->mbox_mutex);
262 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
265 mutex_unlock(&mhdp->mbox_mutex);
271 int cdns_mhdp_dpcd_read(struct cdns_mhdp_device *mhdp,
280 mutex_lock(&mhdp->mbox_mutex);
282 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
287 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
293 ret = cdns_mhdp_mailbox_recv_data(mhdp, reg, sizeof(reg));
297 ret = cdns_mhdp_mailbox_recv_data(mhdp, data, len);
300 mutex_unlock(&mhdp->mbox_mutex);
306 int cdns_mhdp_dpcd_write(struct cdns_mhdp_device *mhdp, u32 addr, u8 value)
315 mutex_lock(&mhdp->mbox_mutex);
317 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
322 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
327 ret = cdns_mhdp_mailbox_recv_data(mhdp, reg, sizeof(reg));
335 mutex_unlock(&mhdp->mbox_mutex);
338 dev_err(mhdp->dev, "dpcd write failed: %d\n", ret);
343 int cdns_mhdp_set_firmware_active(struct cdns_mhdp_device *mhdp, bool enable)
354 mutex_lock(&mhdp->mbox_mutex);
357 ret = cdns_mhdp_mailbox_write(mhdp, msg[i]);
363 ret = cdns_mhdp_mailbox_recv_data(mhdp, msg, sizeof(msg));
370 mutex_unlock(&mhdp->mbox_mutex);
373 dev_err(mhdp->dev, "set firmware active failed\n");
378 int cdns_mhdp_get_hpd_status(struct cdns_mhdp_device *mhdp)
383 mutex_lock(&mhdp->mbox_mutex);
385 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
390 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
396 ret = cdns_mhdp_mailbox_recv_data(mhdp, &status, sizeof(status));
400 mutex_unlock(&mhdp->mbox_mutex);
402 dev_dbg(mhdp->dev, "%s: HPD %splugged\n", __func__,
408 mutex_unlock(&mhdp->mbox_mutex);
417 struct cdns_mhdp_device *mhdp = data;
421 mutex_lock(&mhdp->mbox_mutex);
427 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
432 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
438 ret = cdns_mhdp_mailbox_recv_data(mhdp, reg, sizeof(reg));
442 ret = cdns_mhdp_mailbox_recv_data(mhdp, edid, length);
450 mutex_unlock(&mhdp->mbox_mutex);
453 dev_err(mhdp->dev, "get block[%d] edid failed: %d\n",
460 int cdns_mhdp_read_hpd_event(struct cdns_mhdp_device *mhdp)
465 mutex_lock(&mhdp->mbox_mutex);
467 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
472 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
477 ret = cdns_mhdp_mailbox_recv_data(mhdp, &event, sizeof(event));
479 mutex_unlock(&mhdp->mbox_mutex);
484 dev_dbg(mhdp->dev, "%s: %s%s%s%s\n", __func__,
494 int cdns_mhdp_adjust_lt(struct cdns_mhdp_device *mhdp, unsigned int nlanes,
504 dev_err(mhdp->dev, "invalid number of lanes: %u\n", nlanes);
513 mutex_lock(&mhdp->mbox_mutex);
515 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
522 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
528 ret = cdns_mhdp_mailbox_recv_data(mhdp, hdr, sizeof(hdr));
536 ret = cdns_mhdp_mailbox_recv_data(mhdp, link_status,
540 mutex_unlock(&mhdp->mbox_mutex);
543 dev_err(mhdp->dev, "Failed to adjust Link Training.\n");
575 static unsigned int cdns_mhdp_max_link_rate(struct cdns_mhdp_device *mhdp)
577 return min(mhdp->host.link_rate, mhdp->sink.link_rate);
580 static u8 cdns_mhdp_max_num_lanes(struct cdns_mhdp_device *mhdp)
582 return min(mhdp->sink.lanes_cnt, mhdp->host.lanes_cnt);
585 static u8 cdns_mhdp_eq_training_pattern_supported(struct cdns_mhdp_device *mhdp)
587 return fls(mhdp->host.pattern_supp & mhdp->sink.pattern_supp);
590 static bool cdns_mhdp_get_ssc_supported(struct cdns_mhdp_device *mhdp)
593 return mhdp->host.ssc && mhdp->sink.ssc;
596 static enum drm_connector_status cdns_mhdp_detect(struct cdns_mhdp_device *mhdp)
598 dev_dbg(mhdp->dev, "%s: %d\n", __func__, mhdp->plugged);
600 if (mhdp->plugged)
606 static int cdns_mhdp_check_fw_version(struct cdns_mhdp_device *mhdp)
611 fw_ver = (readl(mhdp->regs + CDNS_VER_H) << 8)
612 | readl(mhdp->regs + CDNS_VER_L);
614 lib_ver = (readl(mhdp->regs + CDNS_LIB_H_ADDR) << 8)
615 | readl(mhdp->regs + CDNS_LIB_L_ADDR);
630 dev_err(mhdp->dev, "Unsupported FW version: fw_ver = %u, lib_ver = %u\n",
641 dev_dbg(mhdp->dev, "FW version: v%u.%u.%u\n", major_num, minor_num,
647 struct cdns_mhdp_device *mhdp)
653 writel(CDNS_CPU_STALL, mhdp->regs + CDNS_APB_CTRL);
655 memcpy_toio(mhdp->regs + CDNS_MHDP_IMEM, fw->data, fw->size);
658 writel(0, mhdp->regs + CDNS_APB_CTRL);
664 ret = readl_poll_timeout(mhdp->regs + CDNS_KEEP_ALIVE, reg,
668 dev_err(mhdp->dev,
673 ret = cdns_mhdp_check_fw_version(mhdp);
678 readl(mhdp->regs + CDNS_SW_EVENT0);
679 readl(mhdp->regs + CDNS_SW_EVENT1);
680 readl(mhdp->regs + CDNS_SW_EVENT2);
681 readl(mhdp->regs + CDNS_SW_EVENT3);
684 ret = cdns_mhdp_set_firmware_active(mhdp, true);
688 spin_lock(&mhdp->start_lock);
690 mhdp->hw_state = MHDP_HW_READY;
701 cdns_mhdp_bridge_hpd_enable(&mhdp->bridge);
703 spin_unlock(&mhdp->start_lock);
705 wake_up(&mhdp->fw_load_wq);
706 dev_dbg(mhdp->dev, "DP FW activated\n");
713 struct cdns_mhdp_device *mhdp = context;
717 dev_dbg(mhdp->dev, "firmware callback\n");
720 dev_err(mhdp->dev, "%s: No firmware.\n", __func__);
724 ret = cdns_mhdp_fw_activate(fw, mhdp);
739 spin_lock(&mhdp->start_lock);
740 bridge_attached = mhdp->bridge_attached;
741 spin_unlock(&mhdp->start_lock);
743 if (mhdp->connector.dev)
744 drm_kms_helper_hotplug_event(mhdp->bridge.dev);
746 drm_bridge_hpd_notify(&mhdp->bridge, cdns_mhdp_detect(mhdp));
750 static int cdns_mhdp_load_firmware(struct cdns_mhdp_device *mhdp)
754 ret = request_firmware_nowait(THIS_MODULE, true, FW_NAME, mhdp->dev,
755 GFP_KERNEL, mhdp, cdns_mhdp_fw_cb);
757 dev_err(mhdp->dev, "failed to load firmware (%s), ret: %d\n",
768 struct cdns_mhdp_device *mhdp = dev_get_drvdata(aux->dev);
780 ret = cdns_mhdp_dpcd_write(mhdp,
785 dev_err(mhdp->dev,
792 ret = cdns_mhdp_dpcd_read(mhdp, msg->address,
795 dev_err(mhdp->dev,
806 static int cdns_mhdp_link_training_init(struct cdns_mhdp_device *mhdp)
812 drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
817 if (!mhdp->host.scrambler)
820 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG, reg32);
822 cdns_mhdp_reg_write(mhdp, CDNS_DP_ENHNCD,
823 mhdp->sink.enhanced & mhdp->host.enhanced);
825 cdns_mhdp_reg_write(mhdp, CDNS_DP_LANE_EN,
826 CDNS_DP_LANE_EN_LANES(mhdp->link.num_lanes));
828 cdns_mhdp_link_configure(&mhdp->aux, &mhdp->link);
829 phy_cfg.dp.link_rate = mhdp->link.rate / 100;
830 phy_cfg.dp.lanes = mhdp->link.num_lanes;
835 phy_cfg.dp.ssc = cdns_mhdp_get_ssc_supported(mhdp);
839 ret = phy_configure(mhdp->phy, &phy_cfg);
841 dev_err(mhdp->dev, "%s: phy_configure() failed: %d\n",
846 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG,
852 drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
858 static void cdns_mhdp_get_adjust_train(struct cdns_mhdp_device *mhdp,
867 max_pre_emph = CDNS_PRE_EMPHASIS(mhdp->host.pre_emphasis)
869 max_volt_swing = CDNS_VOLT_SWING(mhdp->host.volt_swing);
871 for (i = 0; i < mhdp->link.num_lanes; i++) {
928 static void cdns_mhdp_adjust_requested_eq(struct cdns_mhdp_device *mhdp,
931 u8 max_pre = CDNS_PRE_EMPHASIS(mhdp->host.pre_emphasis);
932 u8 max_volt = CDNS_VOLT_SWING(mhdp->host.volt_swing);
936 for (i = 0; i < mhdp->link.num_lanes; i++) {
942 if (mhdp->host.volt_swing & CDNS_FORCE_VOLT_SWING)
945 if (mhdp->host.pre_emphasis & CDNS_FORCE_PRE_EMPHASIS)
952 struct cdns_mhdp_device *mhdp,
959 for (i = 0; i < mhdp->link.num_lanes; i++) {
967 dev_dbg(mhdp->dev, "%s, %u lanes, %u Mbps, vs %s, pe %s\n",
969 mhdp->link.num_lanes, mhdp->link.rate / 100,
973 static bool cdns_mhdp_link_training_channel_eq(struct cdns_mhdp_device *mhdp,
984 dev_dbg(mhdp->dev, "Starting EQ phase\n");
991 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG, reg32);
993 drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
997 drm_dp_dpcd_read_link_status(&mhdp->aux, link_status);
1000 cdns_mhdp_get_adjust_train(mhdp, link_status, lanes_data,
1002 phy_cfg.dp.lanes = mhdp->link.num_lanes;
1003 phy_cfg.dp.ssc = cdns_mhdp_get_ssc_supported(mhdp);
1007 ret = phy_configure(mhdp->phy, &phy_cfg);
1009 dev_err(mhdp->dev, "%s: phy_configure() failed: %d\n",
1014 cdns_mhdp_adjust_lt(mhdp, mhdp->link.num_lanes,
1017 r = drm_dp_clock_recovery_ok(link_status, mhdp->link.num_lanes);
1021 if (drm_dp_channel_eq_ok(link_status, mhdp->link.num_lanes)) {
1022 cdns_mhdp_print_lt_status("EQ phase ok", mhdp,
1029 cdns_mhdp_adjust_requested_eq(mhdp, link_status);
1033 cdns_mhdp_print_lt_status("EQ phase failed", mhdp, &phy_cfg);
1038 static void cdns_mhdp_adjust_requested_cr(struct cdns_mhdp_device *mhdp,
1042 const u8 max_volt = CDNS_VOLT_SWING(mhdp->host.volt_swing);
1043 const u8 max_pre = CDNS_PRE_EMPHASIS(mhdp->host.pre_emphasis);
1046 for (i = 0; i < mhdp->link.num_lanes; i++) {
1049 val = mhdp->host.volt_swing & CDNS_FORCE_VOLT_SWING ?
1053 val = mhdp->host.pre_emphasis & CDNS_FORCE_PRE_EMPHASIS ?
1060 void cdns_mhdp_validate_cr(struct cdns_mhdp_device *mhdp, bool *cr_done,
1066 const u8 max_volt = CDNS_VOLT_SWING(mhdp->host.volt_swing);
1067 const u8 max_pre = CDNS_PRE_EMPHASIS(mhdp->host.pre_emphasis);
1074 *cr_done = drm_dp_clock_recovery_ok(after_cr, mhdp->link.num_lanes);
1076 for (i = 0; i < mhdp->link.num_lanes; i++) {
1099 static bool cdns_mhdp_link_training_cr(struct cdns_mhdp_device *mhdp)
1108 dev_dbg(mhdp->dev, "Starting CR phase\n");
1110 ret = cdns_mhdp_link_training_init(mhdp);
1114 drm_dp_dpcd_read_link_status(&mhdp->aux, link_status);
1121 cdns_mhdp_get_adjust_train(mhdp, link_status, lanes_data,
1123 phy_cfg.dp.lanes = mhdp->link.num_lanes;
1124 phy_cfg.dp.ssc = cdns_mhdp_get_ssc_supported(mhdp);
1128 ret = phy_configure(mhdp->phy, &phy_cfg);
1130 dev_err(mhdp->dev, "%s: phy_configure() failed: %d\n",
1135 cdns_mhdp_adjust_lt(mhdp, mhdp->link.num_lanes, 100,
1138 cdns_mhdp_validate_cr(mhdp, &cr_done, &same_before_adjust,
1145 dev_err(mhdp->dev, "CR: max swing reached\n");
1150 cdns_mhdp_print_lt_status("CR phase ok", mhdp,
1168 cdns_mhdp_adjust_requested_cr(mhdp, link_status,
1174 cdns_mhdp_print_lt_status("CR phase failed", mhdp, &phy_cfg);
1194 static int cdns_mhdp_link_training(struct cdns_mhdp_device *mhdp,
1198 const u8 eq_tps = cdns_mhdp_eq_training_pattern_supported(mhdp);
1202 if (!cdns_mhdp_link_training_cr(mhdp)) {
1203 if (drm_dp_link_rate_to_bw_code(mhdp->link.rate) !=
1205 dev_dbg(mhdp->dev,
1207 cdns_mhdp_lower_link_rate(&mhdp->link);
1210 } else if (mhdp->link.num_lanes > 1) {
1211 dev_dbg(mhdp->dev,
1213 mhdp->link.num_lanes >>= 1;
1214 mhdp->link.rate = cdns_mhdp_max_link_rate(mhdp);
1219 dev_err(mhdp->dev,
1224 if (cdns_mhdp_link_training_channel_eq(mhdp, eq_tps,
1228 if (mhdp->link.num_lanes > 1) {
1229 dev_dbg(mhdp->dev,
1231 mhdp->link.num_lanes >>= 1;
1234 } else if (drm_dp_link_rate_to_bw_code(mhdp->link.rate) !=
1236 dev_dbg(mhdp->dev,
1238 cdns_mhdp_lower_link_rate(&mhdp->link);
1239 mhdp->link.num_lanes = cdns_mhdp_max_num_lanes(mhdp);
1244 dev_err(mhdp->dev, "Link training failed during EQ phase\n");
1248 dev_dbg(mhdp->dev, "Link training ok. Lanes: %u, Rate %u Mbps\n",
1249 mhdp->link.num_lanes, mhdp->link.rate / 100);
1251 drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
1252 mhdp->host.scrambler ? 0 :
1255 ret = cdns_mhdp_reg_read(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, ®32);
1257 dev_err(mhdp->dev,
1263 reg32 |= CDNS_DP_NUM_LANES(mhdp->link.num_lanes);
1266 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, reg32);
1270 if (!mhdp->host.scrambler)
1272 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG, reg32);
1278 if (!mhdp->host.scrambler)
1280 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG, reg32);
1282 drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
1288 static u32 cdns_mhdp_get_training_interval_us(struct cdns_mhdp_device *mhdp,
1295 dev_err(mhdp->dev,
1300 static void cdns_mhdp_fill_host_caps(struct cdns_mhdp_device *mhdp)
1306 mhdp->host.lanes_cnt = mhdp->phy->attrs.bus_width;
1307 if (!mhdp->host.lanes_cnt)
1308 mhdp->host.lanes_cnt = 4;
1310 link_rate = mhdp->phy->attrs.max_link_rate;
1317 mhdp->host.link_rate = link_rate;
1318 mhdp->host.volt_swing = CDNS_VOLT_SWING(3);
1319 mhdp->host.pre_emphasis = CDNS_PRE_EMPHASIS(3);
1320 mhdp->host.pattern_supp = CDNS_SUPPORT_TPS(1) |
1323 mhdp->host.lane_mapping = CDNS_LANE_MAPPING_NORMAL;
1324 mhdp->host.fast_link = false;
1325 mhdp->host.enhanced = true;
1326 mhdp->host.scrambler = true;
1327 mhdp->host.ssc = false;
1330 static void cdns_mhdp_fill_sink_caps(struct cdns_mhdp_device *mhdp,
1333 mhdp->sink.link_rate = mhdp->link.rate;
1334 mhdp->sink.lanes_cnt = mhdp->link.num_lanes;
1335 mhdp->sink.enhanced = !!(mhdp->link.capabilities &
1339 mhdp->sink.ssc = !!(dpcd[DP_MAX_DOWNSPREAD] &
1343 mhdp->sink.pattern_supp = CDNS_SUPPORT_TPS(1) | CDNS_SUPPORT_TPS(2);
1345 mhdp->sink.pattern_supp |= CDNS_SUPPORT_TPS(3);
1347 mhdp->sink.pattern_supp |= CDNS_SUPPORT_TPS(4);
1350 mhdp->sink.fast_link = !!(dpcd[DP_MAX_DOWNSPREAD] &
1354 static int cdns_mhdp_link_up(struct cdns_mhdp_device *mhdp)
1362 WARN_ON(!mutex_is_locked(&mhdp->link_mutex));
1364 drm_dp_dpcd_readb(&mhdp->aux, DP_TRAINING_AUX_RD_INTERVAL,
1372 err = drm_dp_dpcd_read(&mhdp->aux, addr, dpcd, DP_RECEIVER_CAP_SIZE);
1374 dev_err(mhdp->dev, "Failed to read receiver capabilities\n");
1378 mhdp->link.revision = dpcd[0];
1379 mhdp->link.rate = drm_dp_bw_code_to_link_rate(dpcd[1]);
1380 mhdp->link.num_lanes = dpcd[2] & DP_MAX_LANE_COUNT_MASK;
1383 mhdp->link.capabilities |= DP_LINK_CAP_ENHANCED_FRAMING;
1385 dev_dbg(mhdp->dev, "Set sink device power state via DPCD\n");
1386 drm_dp_link_power_up(&mhdp->aux, mhdp->link.revision);
1388 cdns_mhdp_fill_sink_caps(mhdp, dpcd);
1390 mhdp->link.rate = cdns_mhdp_max_link_rate(mhdp);
1391 mhdp->link.num_lanes = cdns_mhdp_max_num_lanes(mhdp);
1394 err = cdns_mhdp_reg_read(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, &resp);
1396 dev_err(mhdp->dev,
1403 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, resp);
1406 amp[0] = cdns_mhdp_get_ssc_supported(mhdp) ? DP_SPREAD_AMP_0_5 : 0;
1408 drm_dp_dpcd_write(&mhdp->aux, DP_DOWNSPREAD_CTRL, amp, 2);
1410 if (mhdp->host.fast_link & mhdp->sink.fast_link) {
1411 dev_err(mhdp->dev, "fastlink not supported\n");
1416 interval_us = cdns_mhdp_get_training_interval_us(mhdp, interval);
1418 cdns_mhdp_link_training(mhdp, interval_us)) {
1419 dev_err(mhdp->dev, "Link training failed. Exiting.\n");
1423 mhdp->link_up = true;
1428 static void cdns_mhdp_link_down(struct cdns_mhdp_device *mhdp)
1430 WARN_ON(!mutex_is_locked(&mhdp->link_mutex));
1432 if (mhdp->plugged)
1433 drm_dp_link_power_down(&mhdp->aux, mhdp->link.revision);
1435 mhdp->link_up = false;
1438 static const struct drm_edid *cdns_mhdp_edid_read(struct cdns_mhdp_device *mhdp,
1441 if (!mhdp->plugged)
1444 return drm_edid_read_custom(connector, cdns_mhdp_get_edid_block, mhdp);
1449 struct cdns_mhdp_device *mhdp = connector_to_mhdp(connector);
1453 if (!mhdp->plugged)
1456 drm_edid = cdns_mhdp_edid_read(mhdp, connector);
1461 dev_err(mhdp->dev, "Failed to read EDID\n");
1474 mhdp->display_fmt.color_format))
1475 dev_warn(mhdp->dev,
1480 connector->display_info.bpc < mhdp->display_fmt.bpc)
1481 dev_warn(mhdp->dev, "%s: Display bpc only %d < %d\n",
1483 mhdp->display_fmt.bpc);
1492 struct cdns_mhdp_device *mhdp = connector_to_mhdp(conn);
1494 return cdns_mhdp_detect(mhdp);
1523 bool cdns_mhdp_bandwidth_ok(struct cdns_mhdp_device *mhdp,
1536 bpp = cdns_mhdp_get_bpp(&mhdp->display_fmt);
1540 dev_dbg(mhdp->dev,
1554 struct cdns_mhdp_device *mhdp = connector_to_mhdp(conn);
1556 mutex_lock(&mhdp->link_mutex);
1558 if (!cdns_mhdp_bandwidth_ok(mhdp, mode, mhdp->link.num_lanes,
1559 mhdp->link.rate)) {
1560 mutex_unlock(&mhdp->link_mutex);
1564 mutex_unlock(&mhdp->link_mutex);
1571 struct cdns_mhdp_device *mhdp = connector_to_mhdp(conn);
1576 if (!mhdp->hdcp_supported)
1623 static int cdns_mhdp_connector_init(struct cdns_mhdp_device *mhdp)
1626 struct drm_connector *conn = &mhdp->connector;
1627 struct drm_bridge *bridge = &mhdp->bridge;
1635 dev_err(mhdp->dev, "Failed to initialize connector with drm\n");
1648 dev_err(mhdp->dev, "Failed to attach connector to encoder\n");
1652 if (mhdp->hdcp_supported)
1662 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
1666 dev_dbg(mhdp->dev, "%s\n", __func__);
1668 mhdp->aux.drm_dev = bridge->dev;
1669 ret = drm_dp_aux_register(&mhdp->aux);
1674 ret = cdns_mhdp_connector_init(mhdp);
1679 spin_lock(&mhdp->start_lock);
1681 mhdp->bridge_attached = true;
1682 hw_ready = mhdp->hw_state == MHDP_HW_READY;
1684 spin_unlock(&mhdp->start_lock);
1692 drm_dp_aux_unregister(&mhdp->aux);
1696 static void cdns_mhdp_configure_video(struct cdns_mhdp_device *mhdp,
1704 u8 stream_id = mhdp->stream_id;
1708 pxlfmt = mhdp->display_fmt.color_format;
1709 bpc = mhdp->display_fmt.bpc;
1719 bpp = cdns_mhdp_get_bpp(&mhdp->display_fmt);
1768 cdns_mhdp_reg_write(mhdp, CDNS_BND_HSYNC2VSYNC(stream_id),
1776 cdns_mhdp_reg_write(mhdp, CDNS_HSYNC2VSYNC_POL_CTRL(stream_id),
1779 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_PXL_REPR(stream_id), pxl_repr);
1787 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_SP(stream_id), dp_framer_sp);
1791 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRONT_BACK_PORCH(stream_id),
1795 cdns_mhdp_reg_write(mhdp, CDNS_DP_BYTE_COUNT(stream_id),
1799 cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_HORIZONTAL_0(stream_id),
1808 cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_HORIZONTAL_1(stream_id),
1812 cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_VERTICAL_0(stream_id),
1821 cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_VERTICAL_1(stream_id),
1827 if (mhdp->display_fmt.y_only)
1833 cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_MISC(stream_id),
1836 cdns_mhdp_reg_write(mhdp, CDNS_DP_HORIZONTAL(stream_id),
1840 cdns_mhdp_reg_write(mhdp, CDNS_DP_VERTICAL_0(stream_id),
1849 cdns_mhdp_reg_write(mhdp, CDNS_DP_VERTICAL_1(stream_id), dp_vertical_1);
1851 cdns_mhdp_reg_write_bit(mhdp, CDNS_DP_VB_ID(stream_id), 2, 1,
1855 ret = cdns_mhdp_reg_read(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, &framer);
1857 dev_err(mhdp->dev,
1864 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, framer);
1867 static void cdns_mhdp_sst_enable(struct cdns_mhdp_device *mhdp,
1877 rate = mhdp->link.rate / 1000;
1879 bpp = cdns_mhdp_get_bpp(&mhdp->display_fmt);
1882 available_bandwidth = mhdp->link.num_lanes * rate;
1892 line_thresh = line_thresh1 - line_thresh2 / (s32)mhdp->link.num_lanes;
1895 mhdp->stream_id = 0;
1897 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_TU,
1902 cdns_mhdp_reg_write(mhdp, CDNS_DP_LINE_THRESH(0),
1905 cdns_mhdp_reg_write(mhdp, CDNS_DP_STREAM_CONFIG_2(0),
1909 cdns_mhdp_configure_video(mhdp, mode);
1915 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
1925 dev_dbg(mhdp->dev, "bridge enable\n");
1927 mutex_lock(&mhdp->link_mutex);
1929 if (mhdp->plugged && !mhdp->link_up) {
1930 ret = cdns_mhdp_link_up(mhdp);
1935 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->enable)
1936 mhdp->info->ops->enable(mhdp);
1939 ret = cdns_mhdp_reg_read(mhdp, CDNS_DPTX_CAR, &resp);
1941 dev_err(mhdp->dev, "Failed to read CDNS_DPTX_CAR %d\n", ret);
1945 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_CAR,
1957 if (mhdp->hdcp_supported &&
1958 mhdp->hw_state == MHDP_HW_READY &&
1961 mutex_unlock(&mhdp->link_mutex);
1962 cdns_mhdp_hdcp_enable(mhdp, conn_state->hdcp_content_type);
1963 mutex_lock(&mhdp->link_mutex);
1976 if (!cdns_mhdp_bandwidth_ok(mhdp, mode, mhdp->link.num_lanes,
1977 mhdp->link.rate)) {
1982 cdns_mhdp_sst_enable(mhdp, mode);
1992 dev_dbg(mhdp->dev, "%s: Enabling mode %s\n", __func__, mode->name);
1994 mhdp->bridge_enabled = true;
1997 mutex_unlock(&mhdp->link_mutex);
1999 schedule_work(&mhdp->modeset_retry_work);
2005 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2008 dev_dbg(mhdp->dev, "%s\n", __func__);
2010 mutex_lock(&mhdp->link_mutex);
2012 if (mhdp->hdcp_supported)
2013 cdns_mhdp_hdcp_disable(mhdp);
2015 mhdp->bridge_enabled = false;
2016 cdns_mhdp_reg_read(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, &resp);
2019 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, resp);
2021 cdns_mhdp_link_down(mhdp);
2024 cdns_mhdp_reg_read(mhdp, CDNS_DPTX_CAR, &resp);
2025 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_CAR,
2028 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->disable)
2029 mhdp->info->ops->disable(mhdp);
2031 mutex_unlock(&mhdp->link_mutex);
2036 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2038 dev_dbg(mhdp->dev, "%s\n", __func__);
2040 drm_dp_aux_unregister(&mhdp->aux);
2042 spin_lock(&mhdp->start_lock);
2044 mhdp->bridge_attached = false;
2046 spin_unlock(&mhdp->start_lock);
2048 writel(~0, mhdp->regs + CDNS_APB_INT_MASK);
2121 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2124 mutex_lock(&mhdp->link_mutex);
2126 if (!cdns_mhdp_bandwidth_ok(mhdp, mode, mhdp->link.num_lanes,
2127 mhdp->link.rate)) {
2128 dev_err(mhdp->dev, "%s: Not enough BW for %s (%u lanes at %u Mbps)\n",
2129 __func__, mode->name, mhdp->link.num_lanes,
2130 mhdp->link.rate / 100);
2131 mutex_unlock(&mhdp->link_mutex);
2139 if (mhdp->info)
2140 bridge_state->input_bus_cfg.flags = *mhdp->info->input_bus_flags;
2142 mutex_unlock(&mhdp->link_mutex);
2149 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2151 return cdns_mhdp_detect(mhdp);
2157 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2159 return cdns_mhdp_edid_read(mhdp, connector);
2178 static bool cdns_mhdp_detect_hpd(struct cdns_mhdp_device *mhdp, bool *hpd_pulse)
2184 hpd_event = cdns_mhdp_read_hpd_event(mhdp);
2188 dev_warn(mhdp->dev, "%s: read event failed: %d\n",
2193 hpd_status = cdns_mhdp_get_hpd_status(mhdp);
2195 dev_warn(mhdp->dev, "%s: get hpd status failed: %d\n",
2206 static int cdns_mhdp_update_link_status(struct cdns_mhdp_device *mhdp)
2210 bool old_plugged = mhdp->plugged;
2216 mutex_lock(&mhdp->link_mutex);
2218 mhdp->plugged = cdns_mhdp_detect_hpd(mhdp, &hpd_pulse);
2220 if (!mhdp->plugged) {
2221 cdns_mhdp_link_down(mhdp);
2222 mhdp->link.rate = mhdp->host.link_rate;
2223 mhdp->link.num_lanes = mhdp->host.lanes_cnt;
2233 if (hpd_pulse && old_plugged == mhdp->plugged) {
2234 ret = drm_dp_dpcd_read_link_status(&mhdp->aux, status);
2241 drm_dp_channel_eq_ok(status, mhdp->link.num_lanes) &&
2242 drm_dp_clock_recovery_ok(status, mhdp->link.num_lanes))
2246 mhdp->link_up = false;
2249 if (!mhdp->link_up) {
2250 ret = cdns_mhdp_link_up(mhdp);
2255 if (mhdp->bridge_enabled) {
2256 state = drm_priv_to_bridge_state(mhdp->bridge.base.state);
2274 if (!cdns_mhdp_bandwidth_ok(mhdp, current_mode, mhdp->link.num_lanes,
2275 mhdp->link.rate)) {
2280 dev_dbg(mhdp->dev, "%s: Enabling mode %s\n", __func__,
2283 cdns_mhdp_sst_enable(mhdp, current_mode);
2286 mutex_unlock(&mhdp->link_mutex);
2292 struct cdns_mhdp_device *mhdp;
2295 mhdp = container_of(work, typeof(*mhdp), modeset_retry_work);
2297 conn = &mhdp->connector;
2310 drm_kms_helper_hotplug_event(mhdp->bridge.dev);
2315 struct cdns_mhdp_device *mhdp = data;
2319 apb_stat = readl(mhdp->regs + CDNS_APB_INT_STATUS);
2323 sw_ev0 = readl(mhdp->regs + CDNS_SW_EVENT0);
2331 spin_lock(&mhdp->start_lock);
2332 bridge_attached = mhdp->bridge_attached;
2333 spin_unlock(&mhdp->start_lock);
2336 schedule_work(&mhdp->hpd_work);
2340 mhdp->sw_events |= (sw_ev0 & ~CDNS_DPTX_HPD);
2341 wake_up(&mhdp->sw_events_wq);
2347 u32 cdns_mhdp_wait_for_sw_event(struct cdns_mhdp_device *mhdp, u32 event)
2351 ret = wait_event_timeout(mhdp->sw_events_wq,
2352 mhdp->sw_events & event,
2355 dev_dbg(mhdp->dev, "SW event 0x%x timeout\n", event);
2359 ret = mhdp->sw_events;
2360 mhdp->sw_events &= ~event;
2368 struct cdns_mhdp_device *mhdp = container_of(work,
2373 ret = cdns_mhdp_update_link_status(mhdp);
2374 if (mhdp->connector.dev) {
2376 schedule_work(&mhdp->modeset_retry_work);
2378 drm_kms_helper_hotplug_event(mhdp->bridge.dev);
2380 drm_bridge_hpd_notify(&mhdp->bridge, cdns_mhdp_detect(mhdp));
2387 struct cdns_mhdp_device *mhdp;
2393 mhdp = devm_drm_bridge_alloc(dev, struct cdns_mhdp_device, bridge,
2395 if (IS_ERR(mhdp))
2396 return PTR_ERR(mhdp);
2404 mhdp->clk = clk;
2405 mhdp->dev = dev;
2406 mutex_init(&mhdp->mbox_mutex);
2407 mutex_init(&mhdp->link_mutex);
2408 spin_lock_init(&mhdp->start_lock);
2410 drm_dp_aux_init(&mhdp->aux);
2411 mhdp->aux.dev = dev;
2412 mhdp->aux.transfer = cdns_mhdp_transfer;
2414 mhdp->regs = devm_platform_ioremap_resource(pdev, 0);
2415 if (IS_ERR(mhdp->regs)) {
2417 return PTR_ERR(mhdp->regs);
2420 mhdp->sapb_regs = devm_platform_ioremap_resource_byname(pdev, "mhdptx-sapb");
2421 if (IS_ERR(mhdp->sapb_regs)) {
2422 mhdp->hdcp_supported = false;
2426 mhdp->hdcp_supported = true;
2429 mhdp->phy = devm_of_phy_get_by_index(dev, pdev->dev.of_node, 0);
2430 if (IS_ERR(mhdp->phy)) {
2432 return PTR_ERR(mhdp->phy);
2435 platform_set_drvdata(pdev, mhdp);
2437 mhdp->info = of_device_get_match_data(dev);
2447 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->init) {
2448 ret = mhdp->info->ops->init(mhdp);
2457 writel(rate % 1000000, mhdp->regs + CDNS_SW_CLK_L);
2458 writel(rate / 1000000, mhdp->regs + CDNS_SW_CLK_H);
2462 writel(~0, mhdp->regs + CDNS_APB_INT_MASK);
2465 ret = devm_request_threaded_irq(mhdp->dev, irq, NULL,
2467 "mhdp8546", mhdp);
2474 cdns_mhdp_fill_host_caps(mhdp);
2477 mhdp->link.rate = mhdp->host.link_rate;
2478 mhdp->link.num_lanes = mhdp->host.lanes_cnt;
2481 mhdp->display_fmt.y_only = false;
2482 mhdp->display_fmt.color_format = DRM_COLOR_FORMAT_RGB444;
2483 mhdp->display_fmt.bpc = 8;
2485 mhdp->bridge.of_node = pdev->dev.of_node;
2486 mhdp->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID |
2488 mhdp->bridge.type = DRM_MODE_CONNECTOR_DisplayPort;
2490 ret = phy_init(mhdp->phy);
2492 dev_err(mhdp->dev, "Failed to initialize PHY: %d\n", ret);
2497 INIT_WORK(&mhdp->modeset_retry_work, cdns_mhdp_modeset_retry_fn);
2498 INIT_WORK(&mhdp->hpd_work, cdns_mhdp_hpd_work);
2500 init_waitqueue_head(&mhdp->fw_load_wq);
2501 init_waitqueue_head(&mhdp->sw_events_wq);
2503 ret = cdns_mhdp_load_firmware(mhdp);
2507 if (mhdp->hdcp_supported)
2508 cdns_mhdp_hdcp_init(mhdp);
2510 drm_bridge_add(&mhdp->bridge);
2515 phy_exit(mhdp->phy);
2517 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->exit)
2518 mhdp->info->ops->exit(mhdp);
2528 struct cdns_mhdp_device *mhdp = platform_get_drvdata(pdev);
2532 drm_bridge_remove(&mhdp->bridge);
2534 ret = wait_event_timeout(mhdp->fw_load_wq,
2535 mhdp->hw_state == MHDP_HW_READY,
2537 spin_lock(&mhdp->start_lock);
2538 mhdp->hw_state = MHDP_HW_STOPPED;
2539 spin_unlock(&mhdp->start_lock);
2542 dev_err(mhdp->dev, "%s: Timeout waiting for fw loading\n",
2545 ret = cdns_mhdp_set_firmware_active(mhdp, false);
2547 dev_err(mhdp->dev, "Failed to stop firmware (%pe)\n",
2551 phy_exit(mhdp->phy);
2553 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->exit)
2554 mhdp->info->ops->exit(mhdp);
2559 cancel_work_sync(&mhdp->modeset_retry_work);
2560 flush_work(&mhdp->hpd_work);
2561 /* Ignoring mhdp->hdcp.check_work and mhdp->hdcp.prop_work here. */