/** * * This function determines whether downstream RX device is MST/SST capable. * * @param InstancePtr is a pointer to the XDpTxSs core instance. * * @return * - XST_SUCCESS if the RX device is MST enabled. * - XST_FAILURE if the RX device is SST enabled. * * @note None. * ******************************************************************************/ u32 XDpTxSs_IsMstCapable(XDpTxSs *InstancePtr) { u32 Status; /* Verify argument.*/ Xil_AssertNonvoid(InstancePtr != NULL); /* Check RX device is MST capable */ Status = XDp_TxMstCapable(InstancePtr->DpPtr); return Status; }
/** * * This function sets transport mode (SST/MST). * * @param InstancePtr is a pointer to the XDpTxSs core instance. * @param Mode specifies the type of transport mode that will be set. * - 0 = Single-Stream Transport mode, * - 1 = Multi-Stream Transport mode, * * @return * - XST_SUCCESS, if transport mode is set successfully to either * MST or SST when RX device is MST and mode is less than or * equal to supported mode. * - XST_FAILURE, if setting to already set mode or mode is * greater than supported mode. * * @note Transport mode is set to either MST or SST when system is MST * and RX device is MST capable. * ******************************************************************************/ u32 XDpTxSs_SetTransportMode(XDpTxSs *InstancePtr, u8 Mode) { u32 Status; /* Verify arguments. */ Xil_AssertNonvoid(InstancePtr != NULL); Xil_AssertNonvoid((Mode == 0x0) || (Mode == 0x1)); /* Check for MST */ if (Mode == InstancePtr->UsrOpt.MstSupport) { xdbg_printf(XDBG_DEBUG_GENERAL,"SS INFO:Subsystem is " "already in %s mode \n\r",Mode?"MST":"SST"); Status = XST_FAILURE; } /* Check for mode less than supported mode */ else if (Mode <= InstancePtr->Config.MstSupport) { /* Check RX device is MST capable */ Status = XDp_TxMstCapable(InstancePtr->DpPtr); if ((Status != XST_SUCCESS) && (Mode > InstancePtr->UsrOpt.MstSupport)) { xdbg_printf(XDBG_DEBUG_GENERAL,"SS INFO: RX device " "is SST capable. No change in mode.\n\r"); Status = XST_FAILURE; } else if ((Status == XST_SUCCESS) && ((Mode < InstancePtr->UsrOpt.MstSupport) || (Mode > InstancePtr->UsrOpt.MstSupport))) { xdbg_printf(XDBG_DEBUG_GENERAL,"SS INFO::setting " "Subsystem mode from %s to %s mode \n\r", (InstancePtr->UsrOpt.MstSupport?"MST":"SST"), (Mode?"MST":"SST")); InstancePtr->UsrOpt.MstSupport = Mode; Status = XST_SUCCESS; } } /* Everything else */ else { xdbg_printf(XDBG_DEBUG_GENERAL,"SS ERR::Subsystem does not " "support %s \n\r", Mode?"MST":"SST"); Status = XST_FAILURE; } return Status; }
/** * The main entry point for the multi-stream transport (MST) example using the * XDp driver. This function will either discover the topology and map streams * to the sinks in the sink list, or map streams to relative addresses. * * @param InstancePtr is a pointer to the XDp instance. * @param DeviceId is the unique device ID of the DisplayPort TX core * instance. * * @return * - XST_FAILURE if the system setup failed. * - XST_SUCCESS should never return since this function, if setup * was successful, is blocking. * * @note If system setup was successful, this function is blocking. * *******************************************************************************/ u32 Dptx_MstExample(XDp *InstancePtr, u16 DeviceId) { u32 Status; /* Do platform initialization here. This is hardware system specific - * it is up to the user to implement this function. */ Dptx_PlatformInit(); /******************/ Status = Dptx_SetupExample(InstancePtr, DeviceId); if (Status != XST_SUCCESS) { return XST_FAILURE; } Status = XDp_TxMstCapable(InstancePtr); if (Status != XST_SUCCESS) { /* If the immediate downstream RX device is an MST monitor and * the DisplayPort Configuration Data (DPCD) does not indicate * MST capability, it is likely that the MST or DisplayPort v1.2 * option must be selected from the monitor's option menu. * Likewise, the DisplayPort TX core must be configured to * support MST mode. */ xil_printf("!!! Verify DisplayPort MST capabilities in the TX " "and/or RX device.\n"); return XST_FAILURE; } do { Status = Dptx_MstExampleRun(InstancePtr); if (Status == XST_DATA_LOST) { xil_printf("!!! Link lost... Need to re-train.\n"); } } while (Status != XST_SUCCESS); /* Do not return. */ xil_printf("MST example DONE.\n"); while (1); return XST_SUCCESS; }
/** * * This function starts the DisplayPort Transmitter Subsystem including all * sub-cores. * * @param InstancePtr is a pointer to the XDpTxSs core instance. * * @return * - XST_SUCCESS, if DP TX Subsystem and its included sub-cores * configured successfully. * - XST_FAILURE, otherwise. * * @note None. * ******************************************************************************/ u32 XDpTxSs_Start(XDpTxSs *InstancePtr) { u32 Status; u32 Index; u8 SinkTotal; #if (XPAR_XDUALSPLITTER_NUM_INSTANCES > 0) u8 VertSplit; #endif /* Verify arguments. */ Xil_AssertNonvoid(InstancePtr != NULL); Xil_AssertNonvoid((InstancePtr->UsrOpt.MstSupport == 0) || (InstancePtr->UsrOpt.MstSupport == 1)); /* Check for downstream device connected */ if (!XDp_TxIsConnected(InstancePtr->DpPtr)) { xdbg_printf(XDBG_DEBUG_GENERAL,"SS ERR: RX device " "is not connected!\n\r"); return XST_FAILURE; } /* Check RX device is MST capable */ Status = XDp_TxMstCapable(InstancePtr->DpPtr); if ((Status == XST_SUCCESS) && (InstancePtr->Config.MstSupport)) { if (InstancePtr->UsrOpt.MstSupport < InstancePtr->Config.MstSupport) { /* Enable SST mode when RX is MST */ InstancePtr->UsrOpt.MstSupport = 0; /* set maximum number of streams to one */ InstancePtr->UsrOpt.NumOfStreams = 1; xdbg_printf(XDBG_DEBUG_GENERAL,"SS INFO: Setting " "to SST even though RX device is with MST " "capable!\n\r"); } else { /* Enable MST mode */ InstancePtr->UsrOpt.MstSupport = InstancePtr->Config.MstSupport; /* Restore maximum number of supported streams */ InstancePtr->UsrOpt.NumOfStreams = InstancePtr->Config.NumMstStreams; xdbg_printf(XDBG_DEBUG_GENERAL,"SS INFO: RX device " "is with MST capable!\n\r"); } } else { /* Enable SST mode */ InstancePtr->UsrOpt.MstSupport = 0; /* set maximum number of streams to one */ InstancePtr->UsrOpt.NumOfStreams = 1; xdbg_printf(XDBG_DEBUG_GENERAL,"SS INFO: RX device " "is with SST capable. OR Design supports only SST " "mode.\n\r"); } /* Start DisplayPort sub-core configuration */ Status = XDpTxSs_DpTxStart(InstancePtr->DpPtr, InstancePtr->UsrOpt.MstSupport, InstancePtr->UsrOpt.Bpc, InstancePtr->UsrOpt.VmId); if (Status != XST_SUCCESS) { xdbg_printf(XDBG_DEBUG_GENERAL,"SS ERR: DP Start failed " "in %s!\n\r", InstancePtr->UsrOpt.MstSupport?"MST":"SST"); return Status; } /* Align video mode being set in DisplayPort */ InstancePtr->UsrOpt.VmId = InstancePtr->DpPtr->TxInstance.MsaConfig[0].Vtm.VmId; /* Set number of stream to number of sinks found. Make sure that sink * total does not exceed total number supported streams in by Subsystem * configuration. */ if (InstancePtr->UsrOpt.MstSupport) { SinkTotal = InstancePtr->DpPtr->TxInstance.Topology.SinkTotal; InstancePtr->UsrOpt.NumOfStreams = (SinkTotal > InstancePtr->UsrOpt.NumOfStreams)? InstancePtr->UsrOpt.NumOfStreams:SinkTotal; } #if (XPAR_XDUALSPLITTER_NUM_INSTANCES > 0) if (InstancePtr->DsPtr) { /* Check video mode and MST support */ if ((InstancePtr->UsrOpt.VmId == XVIDC_VM_UHD2_60_P) && (InstancePtr->UsrOpt.MstSupport)) { /* Vertical split mode */ VertSplit = (TRUE); } else { /* Bypass mode */ VertSplit = (FALSE); } /* Setup Dual Splitter in either bypass/vertical split mode */ Status = XDpTxSs_DsSetup(InstancePtr->DsPtr, VertSplit, &InstancePtr->DpPtr->TxInstance.MsaConfig[0]); if (Status != XST_SUCCESS) { xdbg_printf(XDBG_DEBUG_GENERAL,"SS ERR: DS start " "failed!\n\r"); return Status; } } #endif /* Setup VTC */ for (Index = 0; Index < InstancePtr->UsrOpt.NumOfStreams; Index++) { if (InstancePtr->VtcPtr[Index]) { Status = XDpTxSs_VtcSetup(InstancePtr->VtcPtr[Index], &InstancePtr->DpPtr->TxInstance.MsaConfig[Index]); if (Status != XST_SUCCESS) { xdbg_printf(XDBG_DEBUG_GENERAL,"SS ERR: " "VTC%d setup failed!\n\r", Index); return Status; } } } return XST_SUCCESS; }