mirror of
https://github.com/NVIDIA/open-gpu-kernel-modules.git
synced 2026-02-09 17:50:00 +00:00
689 lines
34 KiB
C++
689 lines
34 KiB
C++
/*
|
|
* SPDX-FileCopyrightText: Copyright (c) 1993-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
|
|
* SPDX-License-Identifier: MIT
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
/******************************* DisplayPort *******************************\
|
|
* *
|
|
* Module: dp_connector.h *
|
|
* This is the primary client interface. *
|
|
* *
|
|
\***************************************************************************/
|
|
#ifndef INCLUDED_DP_CONNECTOR_H
|
|
#define INCLUDED_DP_CONNECTOR_H
|
|
|
|
#include "dp_auxdefs.h"
|
|
#include "dp_object.h"
|
|
#include "dp_mainlink.h"
|
|
#include "dp_auxbus.h"
|
|
#include "dp_address.h"
|
|
#include "dp_guid.h"
|
|
#include "dp_evoadapter.h"
|
|
#include "dp_auxbus.h"
|
|
#include "dp_auxretry.h"
|
|
#include "displayport.h"
|
|
#include "dp_vrr.h"
|
|
#include "../../modeset/timing/nvt_dsc_pps.h"
|
|
#include "ctrl/ctrl0073/ctrl0073dp.h"
|
|
|
|
namespace DisplayPort
|
|
{
|
|
class EvoInterface;
|
|
|
|
typedef enum
|
|
{
|
|
DP_TESTMESSAGE_STATUS_SUCCESS = 0,
|
|
DP_TESTMESSAGE_STATUS_ERROR = 0xDEADBEEF,
|
|
DP_TESTMESSAGE_STATUS_ERROR_INSUFFICIENT_INPUT_BUFFER = 0xDEADBEED,
|
|
DP_TESTMESSAGE_STATUS_ERROR_INVALID_PARAM = 0xDEADBEEC
|
|
// new error code should be here
|
|
} DP_TESTMESSAGE_STATUS;
|
|
|
|
typedef enum
|
|
{
|
|
False = 0,
|
|
True = 1,
|
|
Indeterminate = 2
|
|
} TriState;
|
|
|
|
enum ConnectorType
|
|
{
|
|
connectorDisplayPort,
|
|
connectorHDMI,
|
|
connectorDVI,
|
|
connectorVGA
|
|
};
|
|
|
|
typedef struct portMap
|
|
{
|
|
NvU16 validMap; // port i is valid = bit i is high
|
|
NvU16 inputMap; // port i is input port = bit i is high && validMap bit i is high
|
|
NvU16 internalMap; // port i is internal = bit i is high && validMap bit i is high
|
|
} PortMap;
|
|
|
|
enum ForceDsc
|
|
{
|
|
DSC_DEFAULT,
|
|
DSC_FORCE_ENABLE,
|
|
DSC_FORCE_DISABLE
|
|
};
|
|
|
|
struct DpModesetParams
|
|
{
|
|
unsigned headIndex;
|
|
ModesetInfo modesetInfo;
|
|
DP_COLORFORMAT colorFormat;
|
|
NV0073_CTRL_CMD_DP_SET_MSA_PROPERTIES_PARAMS msaparams;
|
|
|
|
DpModesetParams() : headIndex(0), modesetInfo(), colorFormat(dpColorFormat_Unknown), msaparams() {}
|
|
|
|
DpModesetParams(unsigned newHeadIndex,
|
|
ModesetInfo newModesetInfo,
|
|
DP_COLORFORMAT newColorFormat = dpColorFormat_Unknown) :
|
|
headIndex(newHeadIndex),
|
|
modesetInfo(newModesetInfo),
|
|
colorFormat(newColorFormat),
|
|
msaparams() {}
|
|
|
|
DpModesetParams(unsigned newHeadIndex,
|
|
ModesetInfo *newModesetInfo,
|
|
DP_COLORFORMAT newColorFormat = dpColorFormat_Unknown) :
|
|
headIndex(newHeadIndex),
|
|
modesetInfo(*newModesetInfo),
|
|
colorFormat(newColorFormat),
|
|
msaparams() {}
|
|
|
|
};
|
|
|
|
struct DscOutParams
|
|
{
|
|
unsigned PPS[DSC_MAX_PPS_SIZE_DWORD]; // Out - PPS SDP data
|
|
};
|
|
|
|
struct DscParams
|
|
{
|
|
bool bCheckWithDsc; // [IN] - Client telling DP Library to check with DSC.
|
|
ForceDsc forceDsc; // [IN] - Client telling DP Library to force enable/disable DSC
|
|
DSC_INFO::FORCED_DSC_PARAMS* forcedParams; // [IN] - Client telling DP Library to force certain DSC params.
|
|
bool bEnableDsc; // [OUT] - DP Library telling client that DSC is needed for this mode.
|
|
unsigned bitsPerPixelX16; // [IN/OUT] - Bits per pixel value multiplied by 16
|
|
DscOutParams *pDscOutParams; // [OUT] - DSC parameters
|
|
|
|
DscParams() : bCheckWithDsc(false), forceDsc(DSC_DEFAULT), forcedParams(NULL), bEnableDsc(false), bitsPerPixelX16(0), pDscOutParams(NULL) {}
|
|
};
|
|
|
|
class Group;
|
|
|
|
bool SetConfigSingleHeadMultiStreamMode(Group **targets, // Array of group pointers given for getting configured in single head multistream mode.
|
|
NvU32 displayIDs[], // Array of displayIDs given for getting configured in single head multistream mode.
|
|
NvU32 numStreams, // Number of streams driven out from single head.
|
|
DP_SINGLE_HEAD_MULTI_STREAM_MODE mode, // Configuration mode : SST or MST
|
|
bool bSetConfig, // Set or clear the configuration.
|
|
NvU8 vbiosPrimaryDispIdIndex = DP_SINGLE_HEAD_MULTI_STREAM_PIPELINE_ID_PRIMARY, // VBIOS primary display ID index in displayIDs[] array
|
|
bool bEnableAudioOverRightPanel = false); // Audio MUX config : right or left panel
|
|
|
|
//
|
|
// Device object
|
|
// This object represents a displayport device. Devices are not reported
|
|
// to clients until the EDID is already on file.
|
|
//
|
|
class Device : virtual public Object
|
|
{
|
|
public:
|
|
|
|
virtual bool isPlugged() = 0;
|
|
virtual bool isVideoSink() = 0; // Invariant: won't change once reported
|
|
virtual bool isAudioSink() = 0; // Invariant
|
|
|
|
virtual bool isLoop() = 0; // the address starts and ends at th same device
|
|
virtual bool isRedundant() = 0;
|
|
virtual bool isMustDisconnect() = 0; // Is this monitor's head being attach preventing
|
|
// us from enumerating other panels?
|
|
virtual bool isZombie() = 0; // Head is attached but we're not connected
|
|
virtual bool isCableOk() = 0; // cable can be not ok, whenwe saw hpd, device connected, but can't talk over aux
|
|
|
|
virtual bool isLogical() = 0; // Is device connected to logical port
|
|
|
|
virtual Address getTopologyAddress() const = 0; // Invariant
|
|
virtual bool isMultistream() = 0;
|
|
|
|
virtual ConnectorType getConnectorType() = 0; // Invariant
|
|
|
|
virtual unsigned getEDIDSize() const= 0; // Invariant
|
|
// Copies EDID into client buffer. Fails if the buffer is too small
|
|
virtual bool getEDID(char * buffer, unsigned size) const = 0;
|
|
|
|
virtual unsigned getRawEDIDSize() const= 0;
|
|
// Copies RawEDID into client buffer. Fails if the buffer is too small
|
|
virtual bool getRawEDID(char * buffer, unsigned size) const = 0;
|
|
|
|
virtual bool getPCONCaps(PCONCaps *pPCONCaps) = 0;
|
|
|
|
virtual bool isFallbackEdid() = 0; // is the device edid a fallback one?
|
|
virtual GUID getGUID() const = 0; // Returns the GUID for the device
|
|
virtual bool isPowerSuspended() = 0;
|
|
virtual bool isActive() = 0; // Whether the device has a head attached to it
|
|
virtual TriState hdcpAvailableHop() = 0; // Whether the device support HDCP,
|
|
// regardless of whether the path leading to it supports HDCP.
|
|
virtual TriState hdcpAvailable() = 0; // Whether HDCP can be enabled.
|
|
// Note this checks that the entire path to the node support HDCP.
|
|
|
|
virtual PortMap getPortMap() const = 0;
|
|
|
|
virtual void setPanelPowerParams(bool bSinkPowerStateD0, bool bPanelPowerStateOn) = 0;
|
|
virtual Group * getOwningGroup() = 0; // Return the group this device is currently a member of
|
|
|
|
virtual AuxBus * getRawAuxChannel() = 0; // No automatic retry on DEFER. See limitations in dp_auxbus.h
|
|
virtual AuxRetry * getAuxChannel() = 0; // User friendly AUX interface
|
|
|
|
virtual Device * getParent() = 0;
|
|
virtual Device * getChild(unsigned portNumber) = 0;
|
|
|
|
virtual void dpcdOverrides() = 0; // Apply DPCD overrides if required
|
|
|
|
virtual bool getDpcdRevision(unsigned * major, unsigned * minor) = 0; // get the dpcd revision (maybe cached)
|
|
|
|
virtual bool getSDPExtnForColorimetrySupported() = 0;
|
|
|
|
virtual bool getPanelFwRevision(NvU16 *revision) = 0;
|
|
|
|
virtual bool getIgnoreMSACap() = 0;
|
|
|
|
virtual AuxRetry::status setIgnoreMSAEnable(bool msaTimingParamIgnoreEn) = 0;
|
|
|
|
virtual NvBool isDSCPossible() = 0;
|
|
|
|
virtual NvBool isDSCSupported() = 0;
|
|
|
|
virtual NvBool isDSCDecompressionSupported() = 0;
|
|
|
|
virtual NvBool isDSCPassThroughSupported() = 0;
|
|
|
|
virtual DscCaps getDscCaps() = 0;
|
|
|
|
//
|
|
// This function returns the device itself or its parent device that is doing
|
|
// DSC decompression for it.
|
|
//
|
|
virtual Device* getDevDoingDscDecompression() = 0;
|
|
virtual void markDeviceForDeletion() = 0;
|
|
|
|
virtual bool getRawDscCaps(NvU8 *buffer, NvU32 bufferSize) = 0;
|
|
|
|
// This interface is still nascent. Please don't use it. Read size limit is 16 bytes.
|
|
virtual AuxBus::status getDpcdData(unsigned offset, NvU8 * buffer,
|
|
unsigned sizeRequested,
|
|
unsigned * sizeCompleted,
|
|
unsigned * pNakReason = NULL) = 0;
|
|
|
|
virtual AuxBus::status setDpcdData(unsigned offset, NvU8 * buffer,
|
|
unsigned sizeRequested,
|
|
unsigned * sizeCompleted,
|
|
unsigned * pNakReason = NULL) = 0;
|
|
|
|
virtual AuxBus::status dscCrcControl(NvBool bEnable, gpuDscCrc *gpuData, sinkDscCrc *sinkData) = 0;
|
|
virtual AuxBus::status queryFecData(NvU8 *fecStatus, NvU16 **fecErrorCount, NvU32 flags) = 0;
|
|
|
|
//
|
|
// The address send here will be right shifted by the library. DD should
|
|
// send the DDC address without the shift.
|
|
// Parameter bForceMot in both getI2cData and setI2cData is used to forfully set
|
|
// the MOT bit. It is needed for some special cases where the MOT bit shouldn't
|
|
// be set but some customers need it to please their monitors.
|
|
//
|
|
virtual bool getI2cData(unsigned offset, NvU8 * buffer, unsigned sizeRequested, unsigned * sizeCompleted, bool bForceMot = false) = 0;
|
|
virtual bool setI2cData(unsigned offset, NvU8 * buffer, unsigned sizeRequested, unsigned * sizeCompleted, bool bForceMot = false) = 0;
|
|
|
|
//
|
|
// Calls VRR enablement implementation in dp_vrr.cpp.
|
|
// The enablement steps include interaction over DPAux in the vendor specific
|
|
// DPCD space.
|
|
//
|
|
virtual bool startVrrEnablement() = 0; // VF: calls actual enablement code.
|
|
virtual void resetVrrEnablement() = 0; // VF: resets enablement state.
|
|
virtual bool isVrrMonitorEnabled() = 0; // VF: gets monitor enablement state.
|
|
virtual bool isVrrDriverEnabled() = 0; // VF: gets driver enablement state.
|
|
|
|
// If the sink support MSA override in MST environment.
|
|
virtual bool isMSAOverMSTCapable() = 0;
|
|
virtual bool isFakedMuxDevice() = 0;
|
|
|
|
virtual bool setPanelReplayConfig(panelReplayConfig prcfg) = 0;
|
|
virtual bool isPanelReplaySupported() = 0;
|
|
virtual bool getPanelReplayStatus(PanelReplayStatus *pPrStatus) = 0;
|
|
|
|
protected:
|
|
virtual ~Device() {}
|
|
|
|
};
|
|
|
|
class Group : virtual public Object
|
|
{
|
|
public:
|
|
|
|
//
|
|
// Routines for changing which panels are in a group. To move a stream to a new
|
|
// monitor without a modeset:
|
|
// remove(old_panel)
|
|
// insert(new_panel)
|
|
// The library will automatically switch over to the new configuration
|
|
//
|
|
virtual void insert(Device * dev) = 0;
|
|
virtual void remove(Device * dev) = 0;
|
|
|
|
//
|
|
// group->enumDevices(0) - Get first element
|
|
// group->enumDevices(i) - Get next element
|
|
//
|
|
// for (Device * i = group->enumDevices(0); i; i = group->enumDevices(i))
|
|
//
|
|
virtual Device * enumDevices(Device * previousDevice) = 0;
|
|
|
|
virtual void destroy() = 0; // Destroy the group object
|
|
|
|
// Toggles the encryption status for the stream.
|
|
// Returns whether encryption is currently enabled.
|
|
virtual bool hdcpGetEncrypted() = 0;
|
|
|
|
protected:
|
|
virtual ~Group() {}
|
|
|
|
};
|
|
|
|
class Connector : virtual public Object
|
|
{
|
|
public:
|
|
//
|
|
// Normally the Connector::EventSink callsback can occur in response to the following
|
|
// 1. Timer callbacks
|
|
// 2. notifyLongPulse/notifyShortPulse
|
|
//
|
|
class EventSink
|
|
{
|
|
public:
|
|
virtual void newDevice(Device * dev) = 0; // New device appears in topology
|
|
virtual void lostDevice(Device * dev) = 0; // Lost device from topology
|
|
// Device object ceases to exist after this call
|
|
|
|
virtual void notifyMustDisconnect(Group * grp) = 0; // Notification that an attached head is preventing
|
|
// us from completing detection of a newly connected device
|
|
|
|
virtual void notifyDetectComplete() = 0; // Rolling call. Happens every time we've done another full
|
|
// detect on the topology
|
|
|
|
virtual void bandwidthChangeNotification(Device * dev, bool isComplianceMode) = 0; // Available bandwidth to panel has changed, or panel has
|
|
// become a zombie
|
|
|
|
virtual void notifyZombieStateChange(Device * dev, bool zombied) = 0; // Notification that zombie device was attached or dettached
|
|
virtual void notifyCableOkStateChange(Device * dev, bool cableOk) = 0; // Notification that device got cable state chagne (true - cable is good, false - cables is bad)
|
|
virtual void notifyHDCPCapDone(Device * dev, bool hdcpCap) = 0; // Notification that device's HDCP cap detection is done and get state change.
|
|
virtual void notifyMCCSEvent(Device * dev) = 0; // Notification that an MCCS event is coming
|
|
};
|
|
|
|
// Query current Device topology
|
|
virtual Device * enumDevices(Device * previousDevice) = 0;
|
|
|
|
// Called before system enters an S3 state
|
|
virtual void pause() = 0;
|
|
|
|
// Get maximum link configuration
|
|
virtual LinkConfiguration getMaxLinkConfig() = 0;
|
|
|
|
// Get currently active link configuration
|
|
virtual LinkConfiguration getActiveLinkConfig() = 0;
|
|
|
|
// Get Current link configuration
|
|
virtual void getCurrentLinkConfig(unsigned & laneCount, NvU64 & linkRate) = 0;
|
|
|
|
// Get the clock calculation supported by the panel
|
|
virtual unsigned getPanelDataClockMultiplier() = 0;
|
|
|
|
// Get the clock calculation supported by the GPU
|
|
virtual unsigned getGpuDataClockMultiplier() = 0;
|
|
|
|
// Resume from standby/initial boot notification
|
|
// The library is considered to start up in the suspended state. You must make this
|
|
// API call to enable the library. None of the library APIs are functional before
|
|
// this call.
|
|
//
|
|
// Returns the group representing the firmware panel if any is active.
|
|
//
|
|
// plugged Does RM report the root-port DisplayId in
|
|
// its plugged connector mask
|
|
//
|
|
// firmwareLinkHandsOff RM does NOT report the rootport displayId as active,
|
|
// but one of the active panels shares the same SOR.
|
|
//
|
|
// firmwareDPActive RM reports the rootport displayId in the active device list
|
|
// but display-driver hasn't yet performed its first modeset.
|
|
//
|
|
// isUefiSystem DD tells the library whether this system is a UEFI based
|
|
// one so that the library can get the current and max link config
|
|
// from RM/UEFI instead of trying to determine them on its own.
|
|
//
|
|
// firmwareHead Head being used to drive the firmware
|
|
// display, if firmwareDPActive is true.
|
|
//
|
|
// bFirmwareLinkUseMultistream
|
|
// Specifies whether the firmware connector is being driven in SST
|
|
// (false) or MST (true) mode.
|
|
//
|
|
// bDisableVbiosScratchRegisterUpdate
|
|
// Disables update of
|
|
// NV_PDISP_SOR_DP_SCRATCH_RAD/MISC scratch
|
|
// pad registers with last lit up display
|
|
// address. This address is used by VBIOS in
|
|
// case of driver unload or BSOD.
|
|
//
|
|
// bAllowMST Allow/Disallow Multi-streaming
|
|
//
|
|
virtual Group * resume(bool firmwareLinkHandsOff,
|
|
bool firmwareDPActive,
|
|
bool plugged,
|
|
bool isUefiSystem = false,
|
|
unsigned firmwareHead = 0,
|
|
bool bFirmwareLinkUseMultistream = false,
|
|
bool bDisableVbiosScratchRegisterUpdate = false,
|
|
bool bAllowMST = true) = 0;
|
|
|
|
// The display-driver should enable hands off mode when attempting
|
|
// to use a shared resource (such as the SOR) in a non-DP configuration.
|
|
virtual void enableLinkHandsOff() = 0;
|
|
virtual void releaseLinkHandsOff() = 0;
|
|
|
|
// Usage scenario:
|
|
// beginCompoundQuery()
|
|
// compoundQueryAttach(1280x1024)
|
|
// compoundQueryAttach(1920x1080)
|
|
// .endCompoundQuery()
|
|
// Will tell you if you have sufficient bandwidth to operate
|
|
// two panels at 1920x1080 and 1280x1024 assuming all currently
|
|
// attached panels are detached.
|
|
virtual void beginCompoundQuery() = 0;
|
|
|
|
//
|
|
// twoChannelAudioHz
|
|
// If you need 192khz stereo specify 192000 here.
|
|
//
|
|
// eightChannelAudioHz
|
|
// Same setting for multi channel audio.
|
|
// DisplayPort encodes 3-8 channel streams as 8 channel
|
|
//
|
|
// pixelClockHz
|
|
// Requested pixel clock for the mode
|
|
//
|
|
// depth
|
|
// Requested color depth
|
|
//
|
|
virtual bool compoundQueryAttach(Group * target,
|
|
unsigned twoChannelAudioHz,
|
|
unsigned eightChannelAudioHz,
|
|
NvU64 pixelClockHz,
|
|
unsigned rasterWidth,
|
|
unsigned rasterHeight,
|
|
unsigned rasterBlankStartX,
|
|
unsigned rasterBlankEndX,
|
|
unsigned depth) = 0;
|
|
|
|
virtual bool compoundQueryAttach(Group * target,
|
|
const DpModesetParams &modesetParams, // Modeset info
|
|
DscParams *pDscParams) = 0; // DSC parameters
|
|
|
|
virtual bool endCompoundQuery() = 0;
|
|
|
|
// Interface to indicate if clients need to perform a head shutdown before a modeset
|
|
virtual bool isHeadShutDownNeeded(Group * target, // Group of panels we're attaching to this head
|
|
unsigned headIndex,
|
|
unsigned twoChannelAudioHz, // if you need 192khz stereo specify 192000 here
|
|
unsigned eightChannelAudioHz, // Same setting for multi channel audio.
|
|
// DisplayPort encodes 3-8 channel streams as 8 channel
|
|
NvU64 pixelClockHz, // Requested pixel clock for the mode
|
|
unsigned rasterWidth,
|
|
unsigned rasterHeight,
|
|
unsigned rasterBlankStartX,
|
|
unsigned rasterBlankEndX,
|
|
unsigned depth) = 0;
|
|
|
|
// Interface to indicate if clients need to perform a head shutdown before a modeset
|
|
virtual bool isHeadShutDownNeeded(Group * target, // Group of panels we're attaching to this head
|
|
unsigned headIndex,
|
|
ModesetInfo modesetInfo) = 0; // Modeset info relevant DSC data
|
|
|
|
//
|
|
// Interface for clients to query library if the link is going to be trained during notifyAttachBegin(modeset).
|
|
// Note: This API is not intended to know if a link training will be performed during assessment of the link.
|
|
// This API is added to see if library can avoid link training during modeset so that client can take necessary decision
|
|
// to avoid a destructive modeset from UEFI mode at post to a GPU driver detected mode
|
|
// (thus prevent a visible glitch - i.e. Smooth Transition)
|
|
//
|
|
// How isLinkTrainingNeededForModeset API is different from isHeadShutDownNeeded API -
|
|
// In case of MST : we always shutdown head and link train if link is inactive, so both APIs return TRUE
|
|
// In case of SST :
|
|
// - If requested link config < active link config, we shutdown head to prevent overflow
|
|
// as head will still be driving at higher mode during link training to lower mode
|
|
// So both APIs return TRUE
|
|
// - If requested link config >= active link config, we don't need a head shutdown since
|
|
// SOR clocks can be changed by entering flush mode but will need to link train for mode change
|
|
// So isHeadShutDownNeeded returns FALSE and isLinkTrainingNeededForModeset returns TRUE
|
|
//
|
|
virtual bool isLinkTrainingNeededForModeset (ModesetInfo modesetInfo) = 0;
|
|
|
|
// Notify library before/after modeset (update)
|
|
virtual bool notifyAttachBegin(Group * target, // Group of panels we're attaching to this head
|
|
unsigned headIndex,
|
|
unsigned twoChannelAudioHz, // if you need 192khz stereo specify 192000 here
|
|
unsigned eightChannelAudioHz, // Same setting for multi channel audio.
|
|
// DisplayPort encodes 3-8 channel streams as 8 channel
|
|
NvU64 pixelClockHz, // Requested pixel clock for the mode
|
|
unsigned rasterWidth,
|
|
unsigned rasterHeight,
|
|
unsigned rasterBlankStartX,
|
|
unsigned rasterBlankEndX,
|
|
unsigned depth) = 0;
|
|
|
|
// Group of panels we're attaching to this head
|
|
virtual bool notifyAttachBegin(Group * target, const DpModesetParams &modesetParams) = 0;
|
|
|
|
virtual void readRemoteHdcpCaps() = 0;
|
|
|
|
// modeset might be cancelled when NAB failed
|
|
virtual void notifyAttachEnd(bool modesetCancelled) = 0;
|
|
|
|
//
|
|
// Client needs to be notified about the SST<->MST transition,
|
|
// based on which null modeset will be sent.
|
|
//
|
|
virtual bool isLinkAwaitingTransition() = 0;
|
|
|
|
virtual void resetLinkTrainingCounter() = 0;
|
|
|
|
// Notify library before/after shutdown (update)
|
|
virtual void notifyDetachBegin(Group * target) = 0;
|
|
virtual void notifyDetachEnd(bool bKeepOdAlive = false) = 0;
|
|
|
|
// Notify library to assess PCON link capability
|
|
virtual bool assessPCONLinkCapability(PCONLinkControl *params) = 0;
|
|
|
|
// Notify library of hotplug/IRQ
|
|
virtual void notifyLongPulse(bool statusConnected) = 0;
|
|
virtual void notifyShortPulse() = 0;
|
|
|
|
// Notify Library when ACPI initialization is done
|
|
virtual void notifyAcpiInitDone() = 0;
|
|
|
|
// Notify Library when GPU capability changes. Usually because power event.
|
|
virtual void notifyGPUCapabilityChange() = 0;
|
|
virtual void notifyHBR2WAREngage() = 0;
|
|
|
|
// Create a new Group. Note that if you wish to do a modeset but send the
|
|
// stream nowhere, you may do a modeset with an EMPTY group. This is expected
|
|
// to be the mechanism by which monitor faking is implemented.
|
|
virtual Group * newGroup() = 0;
|
|
|
|
// Shutdown and the destroy the connector manager
|
|
virtual void destroy() = 0;
|
|
|
|
virtual void createFakeMuxDevice(const NvU8 *buffer, NvU32 bufferSize) = 0;
|
|
virtual void deleteFakeMuxDevice() = 0;
|
|
virtual bool getRawDscCaps(NvU8 *buffer, NvU32 bufferSize) = 0;
|
|
|
|
//
|
|
// OS Modeset Order mitigation causes the library to delay the reporting
|
|
// of new devices until they can be safely turned on.
|
|
// When enabled the library client will not see connection events until
|
|
// MustDisconnect messages are processed.
|
|
//
|
|
// Policy state should be set before the library is brought out of
|
|
// the suspended state.
|
|
//
|
|
// Important Note: This option changes the definition of QueryMode.
|
|
// Without OS order mitigation query mode assumes that you will
|
|
// deatach all of the heads from any zombied monitors *before*
|
|
// activating the new panel. If your driver cannot guarantee
|
|
// this invariant, then it must enable order mitigation.
|
|
//
|
|
virtual void setPolicyModesetOrderMitigation(bool enabled) = 0;
|
|
|
|
//
|
|
// force LT at NAB for compliance test (Power Management) in Win10 RS2+ (WDDM 2.2)
|
|
//
|
|
// RS2 no longer sends an explicit call for setPanelPowerParams during the Resume.
|
|
// It does that by specifying an additional flag during the call to SetTimings. Due to
|
|
// this DP lib doesn't get chance to perform this transition from setPanelPowerParams
|
|
// and since it was already skipping LT in NAB/modeswitch, so LT get missed out on the
|
|
// compliance device during resume from S3/S4.
|
|
//
|
|
virtual void setPolicyForceLTAtNAB(bool enabled) = 0;
|
|
|
|
//
|
|
// There are cases where OS does not detach heads from connector immediately after hot-unplug,
|
|
// on next hot-plug there is no guarantee that newly connected sink is capable to drive existing
|
|
// raster timings. Flush mode has following restriction
|
|
// When exiting flush mode S/W should ensure that the final
|
|
// link clock & lane count should be able to support existing raster.
|
|
// If we run into this situation and use flush mode then that will cause display engine to hang.
|
|
// This variable ensures to assess link safely in this situation and instead of using flush mode ask
|
|
// DD to detach/reattach heads for link training.
|
|
//
|
|
virtual void setPolicyAssessLinkSafely(bool enabled) = 0;
|
|
|
|
//
|
|
// These interfaces are meant to be used *ONLY* for tool purposes.
|
|
// Clients should *NOT* use them for their own implementation.
|
|
//
|
|
// Sets the preferred link config which the tool has requested to train to.
|
|
// Each set call should be paired with a reset call. Also, preferred link configs won't persist across HPDs.
|
|
// It is advisable to do compound queries before setting a mode on a preferred config.
|
|
// Compound queries and notify attaches(link train) would use the preferred link config unless it is reset again.
|
|
// (not advisable to leave a preferred link config always ON).
|
|
//
|
|
virtual bool setPreferredLinkConfig(LinkConfiguration & lc, bool commit,
|
|
bool force = false,
|
|
LinkTrainingType forceTrainType = NORMAL_LINK_TRAINING) = 0;
|
|
|
|
//
|
|
// Resets the preferred link config and lets the library go back to default LT policy.
|
|
// Should follow a previous set call.
|
|
//
|
|
virtual bool resetPreferredLinkConfig(bool force=false) = 0;
|
|
|
|
//
|
|
// These interfaces are used by client to allow/disallow
|
|
// Multi-streaming.
|
|
//
|
|
// If connected sink is MST capable then:
|
|
// Client should detach all active MST video/audio streams before
|
|
// disallowing MST, vise-versa client should detach active SST
|
|
// stream before allowing MST.
|
|
//
|
|
virtual void setAllowMultiStreaming(bool bAllowMST) = 0;
|
|
virtual bool getAllowMultiStreaming(void) = 0;
|
|
|
|
// This function reads sink MST capability from DPCD register(s).
|
|
virtual bool getSinkMultiStreamCap(void) = 0;
|
|
|
|
// These interfaces are Deprecated, use setAllowMultiStreaming()
|
|
virtual void setDp11ProtocolForced() = 0;
|
|
virtual void resetDp11ProtocolForced() = 0;
|
|
virtual bool isDp11ProtocolForced() = 0;
|
|
|
|
virtual bool getHDCPAbortCodesDP12(NvU32 &hdcpAbortCodesDP12) = 0;
|
|
|
|
virtual bool getOuiSink(unsigned &ouiId, char * modelName,
|
|
size_t modelNameBufferSize, NvU8 & chipRevision) = 0;
|
|
|
|
virtual bool getIgnoreSourceOuiHandshake() = 0;
|
|
virtual void setIgnoreSourceOuiHandshake(bool bIgnore) = 0;
|
|
|
|
//
|
|
// The following function is to be used to get the capability bit that tells the client whether the connector
|
|
// can do multistream.
|
|
//
|
|
virtual bool isMultiStreamCapable() = 0;
|
|
virtual bool isFlushSupported() = 0;
|
|
virtual bool isStreamCloningEnabled() = 0;
|
|
virtual NvU32 maxLinkRateSupported() = 0;
|
|
virtual bool isFECSupported() = 0;
|
|
virtual bool isFECCapable() = 0;
|
|
|
|
// Following APIs are for link test/config for DP Test Utility
|
|
virtual bool getTestPattern(NV0073_CTRL_DP_TESTPATTERN *pTestPattern) = 0;
|
|
virtual bool setTestPattern(NV0073_CTRL_DP_TESTPATTERN testPattern,
|
|
NvU8 laneMask, NV0073_CTRL_DP_CSTM cstm,
|
|
NvBool bIsHBR2, NvBool bSkipLaneDataOverride) = 0;
|
|
// "data" is an array of NV0073_CTRL_MAX_LANES unsigned ints
|
|
virtual bool getLaneConfig(NvU32 *numLanes, NvU32 *data) = 0;
|
|
// "data" is an array of NV0073_CTRL_MAX_LANES unsigned ints
|
|
virtual bool setLaneConfig(NvU32 numLanes, NvU32 *data) = 0;
|
|
|
|
virtual DP_TESTMESSAGE_STATUS sendDPTestMessage(void *pBuffer,
|
|
NvU32 requestSize,
|
|
NvU32 *pDpStatus) = 0;
|
|
|
|
virtual DP_TESTMESSAGE_STATUS getStreamIDs(NvU32 *pStreamIDs, NvU32 *pCount) = 0;
|
|
// Function to configure power up/down for DP Main Link
|
|
virtual void configurePowerState(bool bPowerUp) = 0;
|
|
|
|
virtual void readPsrCapabilities(vesaPsrSinkCaps *caps) = 0;
|
|
virtual bool updatePsrConfiguration(vesaPsrConfig config) = 0;
|
|
virtual bool readPsrConfiguration(vesaPsrConfig *config) = 0;
|
|
virtual bool readPsrState(vesaPsrState *psrState) = 0;
|
|
virtual bool readPsrDebugInfo(vesaPsrDebugStatus *psrDbgState) = 0;
|
|
virtual bool writePsrErrorStatus(vesaPsrErrorStatus psrErr) = 0;
|
|
virtual bool readPsrErrorStatus(vesaPsrErrorStatus *psrErr) = 0;
|
|
virtual bool writePsrEvtIndicator(vesaPsrEventIndicator psrErr) = 0;
|
|
virtual bool readPsrEvtIndicator(vesaPsrEventIndicator *psrErr) = 0;
|
|
virtual bool updatePsrLinkState(bool bTrainLink) = 0;
|
|
|
|
protected:
|
|
virtual ~Connector() {}
|
|
};
|
|
|
|
//
|
|
// Library routine to create primary port interface
|
|
// (Not intended to be used by display driver)
|
|
Connector * createConnector(MainLink * mainInterface, // DisplayDriver implemented MainLink object
|
|
AuxBus * auxInterface, // DisplayDriver implemented AuxRetry wrapper
|
|
Timer * timerInterface, // DisplayDriver provided Timer services
|
|
Connector::EventSink * sink); // Interface to notify DisplayDriver of events
|
|
}
|
|
#endif //INCLUDED_DP_CONNECTOR_H
|