/**
*
* 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;
}
