1 /* 2 * SPDX-FileCopyrightText: Copyright (c) 2013-2015 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 3 * SPDX-License-Identifier: MIT 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be included in 13 * all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21 * DEALINGS IN THE SOFTWARE. 22 */ 23 24 #ifndef __NVKMS_H__ 25 #define __NVKMS_H__ 26 27 #include "nvkms-types.h" 28 #include "nvkms-api.h" 29 30 #ifdef __cplusplus 31 extern "C" { 32 #endif 33 34 extern NVEvoInfoStringRec dummyInfoString; 35 36 NVDevEvoPtr nvFindDevEvoByDeviceId(NvU32 deviceId); 37 NvU8 nvGetGpuLogIndex(void); 38 void nvEvoDetachConnector(NVConnectorEvoRec *pConnectorEvo, const NvU32 head, 39 NVEvoModesetUpdateState *pModesetUpdateState); 40 void nvEvoAttachConnector(NVConnectorEvoRec *pConnectorEvo, 41 const NvU32 head, 42 const NvU32 isPrimaryHead, 43 NVDPLibModesetStatePtr pDpLibModesetState, 44 NVEvoModesetUpdateState *pModesetUpdateState); 45 void nvEvoUpdateAndKickOff(const NVDispEvoRec *pDispEvo, NvBool sync, 46 NVEvoUpdateState *updateState, NvBool releaseElv); 47 void nvDoIMPUpdateEvo(NVDispEvoPtr pDispEvo, 48 NVEvoUpdateState *updateState); 49 void nvEvoArmLightweightSupervisor(NVDispEvoPtr pDispEvo, 50 const NvU32 head, 51 NvBool isVrr, 52 NvBool enable); 53 54 void nvSetViewPortsEvo(NVDispEvoPtr pDispEvo, 55 const NvU32 head, NVEvoUpdateState *updateState); 56 void nvSetViewPortPointInEvo(NVDispEvoPtr pDispEvo, 57 const NvU32 head, 58 const NvU16 x, 59 NvU16 y, 60 NVEvoUpdateState *updateState); 61 void 62 nvConstructNvModeTimingsFromHwModeTimings(const NVHwModeTimingsEvo *pTimings, 63 NvModeTimingsPtr pModeTimings); 64 void nvEvoSetTimings(NVDispEvoPtr pDispEvo, const NvU32 head, 65 NVEvoUpdateState *updateState); 66 void nvInitScalingUsageBounds(const NVDevEvoRec *pDevEvo, 67 struct NvKmsScalingUsageBounds *pScaling); 68 NvBool nvComputeScalingUsageBounds(const NVEvoScalerCaps *pScalerCaps, 69 const NvU32 inWidth, const NvU32 inHeight, 70 const NvU32 outWidth, const NvU32 outHeight, 71 NVEvoScalerTaps hTaps, NVEvoScalerTaps vTaps, 72 struct NvKmsScalingUsageBounds *out); 73 NvBool nvAssignScalerTaps(const NVDevEvoRec *pDevEvo, 74 const NVEvoScalerCaps *pScalerCaps, 75 const NvU32 inWidth, const NvU32 inHeight, 76 const NvU32 outWidth, const NvU32 outHeight, 77 NvBool doubleScan, 78 NVEvoScalerTaps *hTapsOut, NVEvoScalerTaps *vTapsOut); 79 NvBool nvValidateHwModeTimingsViewPort(const NVDevEvoRec *pDevEvo, 80 const NVEvoScalerCaps *pScalerCaps, 81 NVHwModeTimingsEvoPtr pTimings, 82 NVEvoInfoStringPtr pInfoString); 83 void nvAssignDefaultUsageBounds(const NVDispEvoRec *pDispEvo, 84 NVHwModeViewPortEvo *pViewPort); 85 void nvUnionUsageBounds(const struct NvKmsUsageBounds *a, 86 const struct NvKmsUsageBounds *b, 87 struct NvKmsUsageBounds *ret); 88 void nvIntersectUsageBounds(const struct NvKmsUsageBounds *a, 89 const struct NvKmsUsageBounds *b, 90 struct NvKmsUsageBounds *ret); 91 NvBool UsageBoundsEqual(const struct NvKmsUsageBounds *a, 92 const struct NvKmsUsageBounds *b); 93 NvU64 nvEvoGetFormatsWithEqualOrLowerUsageBound( 94 const enum NvKmsSurfaceMemoryFormat format, 95 const NvU64 supportedFormatsCapMask); 96 void nvCancelLowerDispBandwidthTimer(NVDevEvoPtr pDevEvo); 97 void nvScheduleLowerDispBandwidthTimer(NVDevEvoPtr pDevEvo); 98 void nvAssertAllDpysAreInactive(NVDevEvoPtr pDevEvo); 99 void nvEvoLockStatePreModeset(NVDevEvoPtr pDevEvo, NvU32 *dispNeedsEarlyUpdate, 100 NVEvoUpdateState *updateState); 101 void nvEvoLockStatePostModeset(NVDevEvoPtr pDevEvo, const NvBool doRasterLock); 102 NvBool nvSetUsageBoundsEvo( 103 NVDevEvoPtr pDevEvo, 104 NvU32 sd, 105 NvU32 head, 106 const struct NvKmsUsageBounds *pUsage, 107 NVEvoUpdateState *updateState); 108 void nvEnableMidFrameAndDWCFWatermark(NVDevEvoPtr pDevEvo, 109 NvU32 sd, 110 NvU32 head, 111 NvBool enable, 112 NVEvoUpdateState *pUpdateState); 113 114 void nvEvoHeadSetControlOR(NVDispEvoPtr pDispEvo, 115 const NvU32 head, NVEvoUpdateState *pUpdateState); 116 117 void nvChooseDitheringEvo( 118 const NVConnectorEvoRec *pConnectorEvo, 119 enum NvKmsDpyAttributeColorBpcValue bpc, 120 const NVDpyAttributeRequestedDitheringConfig *pReqDithering, 121 NVDpyAttributeCurrentDitheringConfig *pCurrDithering); 122 123 void nvSetDitheringEvo( 124 NVDispEvoPtr pDispEvo, 125 const NvU32 head, 126 const NVDpyAttributeCurrentDitheringConfig *pCurrDithering, 127 NVEvoUpdateState *pUpdateState); 128 129 NvBool nvEnableFrameLockEvo(NVDispEvoPtr pDispEvo); 130 NvBool nvDisableFrameLockEvo(NVDispEvoPtr pDispEvo); 131 NvBool nvQueryRasterLockEvo(const NVDpyEvoRec *pDpyEvo, NvS64 *val); 132 void nvInvalidateTopologiesEvo(void); 133 NvBool nvSetFlipLockEvo(NVDpyEvoPtr pDpyEvo, NvS64 value); 134 NvBool nvGetFlipLockEvo(const NVDpyEvoRec *pDpyEvo, NvS64 *pValue); 135 NvBool nvAllowFlipLockEvo(NVDispEvoPtr pDispEvo, NvS64 value); 136 NvBool nvSetStereoEvo(const NVDispEvoRec *pDispEvo, 137 const NvU32 head, NvBool enable); 138 NvBool nvGetStereoEvo(const NVDispEvoRec *pDispEvo, const NvU32 head); 139 struct NvKmsCompositionParams nvDefaultCursorCompositionParams(const NVDevEvoRec *pDevEvo); 140 NvBool nvAllocCoreChannelEvo(NVDevEvoPtr pDevEvo); 141 void nvFreeCoreChannelEvo(NVDevEvoPtr pDevEvo); 142 143 void nvEvoUpdateSliVideoBridge(NVDevEvoPtr pDevEvo); 144 145 void nvSetDVCEvo(NVDispEvoPtr pDispEvo, 146 const NvU32 head, 147 NvS32 dvc, 148 NVEvoUpdateState *updateState); 149 void nvSetImageSharpeningEvo(NVDispEvoRec *pDispEvo, const NvU32 head, 150 const NvU32 value, NVEvoUpdateState *updateState); 151 152 NvBool nvLayerSetPositionEvo( 153 NVDevEvoPtr pDevEvo, 154 const struct NvKmsSetLayerPositionRequest *pRequest); 155 156 NvBool nvConstructHwModeTimingsEvo(const NVDpyEvoRec *pDpyEvo, 157 const struct NvKmsMode *pKmsMode, 158 const struct NvKmsSize *pViewPortSizeIn, 159 const struct NvKmsRect *pViewPortOut, 160 NVHwModeTimingsEvoPtr pTimings, 161 const struct NvKmsModeValidationParams 162 *pParams, 163 NVEvoInfoStringPtr pInfoString); 164 165 NvBool nvConstructHwModeTimingsImpCheckEvo( 166 const NVConnectorEvoRec *pConnectorEvo, 167 const NVHwModeTimingsEvo *pTimings, 168 const NvBool enableDsc, 169 const NvBool b2Heads1Or, 170 const enum NvKmsDpyAttributeCurrentColorSpaceValue colorSpace, 171 const enum NvKmsDpyAttributeColorBpcValue colorBpc, 172 const struct NvKmsModeValidationParams *pParams, 173 NVHwModeTimingsEvo timings[NVKMS_MAX_HEADS_PER_DISP], 174 NvU32 *pNumHeads, 175 NVEvoInfoStringPtr pInfoString); 176 177 NvBool nvDowngradeColorSpaceAndBpc( 178 const NVColorFormatInfoRec *pSupportedColorFormats, 179 enum NvKmsDpyAttributeCurrentColorSpaceValue *pColorSpace, 180 enum NvKmsDpyAttributeColorBpcValue *pColorBpc, 181 enum NvKmsDpyAttributeColorRangeValue *pColorRange); 182 183 NvBool nvDPValidateModeEvo(NVDpyEvoPtr pDpyEvo, 184 NVHwModeTimingsEvoPtr pTimings, 185 const NvBool b2Heads1Or, 186 NVDscInfoEvoRec *pDscInfo, 187 const struct NvKmsModeValidationParams *pParams); 188 189 NvBool nvEvoUpdateHwModeTimingsViewPort( 190 const NVDpyEvoRec *pDpyEvo, 191 const struct NvKmsModeValidationParams *pModeValidationParams, 192 const struct NvKmsSize *pViewPortSizeIn, 193 const struct NvKmsRect *pViewPortOut, 194 NVHwModeTimingsEvo *pTimings); 195 196 typedef struct _NVValidateImpOneDispHeadParamsRec 197 { 198 const NVConnectorEvoRec *pConnectorEvo; 199 const struct NvKmsUsageBounds *pUsage; 200 NvU32 activeRmId; 201 enum nvKmsPixelDepth pixelDepth; 202 NVHwModeTimingsEvoPtr pTimings; 203 NvBool enableDsc; 204 NvBool b2Heads1Or; 205 } NVValidateImpOneDispHeadParamsRec; 206 207 NvBool nvValidateImpOneDisp( 208 NVDispEvoPtr pDispEvo, 209 const NVValidateImpOneDispHeadParamsRec timingsParams[NVKMS_MAX_HEADS_PER_DISP], 210 NvBool requireBootClocks, 211 NVEvoReallocateBandwidthMode reallocBandwidth, 212 NvU32 *pMinIsoBandwidthKBPS, 213 NvU32 *pMinDramFloorKBPS); 214 215 NvBool nvAllocateDisplayBandwidth( 216 NVDispEvoPtr pDispEvo, 217 NvU32 newIsoBandwidthKBPS, 218 NvU32 newDramFloorKBPS); 219 220 NvBool nvValidateImpOneDispDowngrade( 221 NVDispEvoPtr pDispEvo, 222 const NVValidateImpOneDispHeadParamsRec timingsParams[NVKMS_MAX_HEADS_PER_DISP], 223 NvBool requireBootClocks, 224 NVEvoReallocateBandwidthMode reallocBandwidth, 225 NvU32 downgradePossibleHeadsBitMask); 226 227 NvBool nvFrameLockServerPossibleEvo(const NVDpyEvoRec *pDpyEvo); 228 NvBool nvFrameLockClientPossibleEvo(const NVDpyEvoRec *pDpyEvo); 229 230 void nvEvoSetLut(NVDispEvoPtr pDispEvo, NvU32 apiHead, NvBool kickoff, 231 const struct NvKmsSetLutCommonParams *pParams); 232 NvBool nvValidateSetLutCommonParams( 233 const NVDevEvoRec *pDevEvo, 234 const struct NvKmsSetLutCommonParams *pParams); 235 236 NvBool nvChooseColorRangeEvo( 237 enum NvKmsOutputTf tf, 238 const enum NvKmsDpyAttributeColorRangeValue requestedColorRange, 239 const enum NvKmsDpyAttributeCurrentColorSpaceValue colorSpace, 240 const enum NvKmsDpyAttributeColorBpcValue colorBpc, 241 enum NvKmsDpyAttributeColorRangeValue *pColorRange); 242 243 NvBool nvChooseCurrentColorSpaceAndRangeEvo( 244 const NVDpyEvoRec *pDpyEvo, 245 enum NvYuv420Mode yuv420Mode, 246 enum NvKmsOutputTf tf, 247 const enum NvKmsDpyAttributeRequestedColorSpaceValue requestedColorSpace, 248 const enum NvKmsDpyAttributeColorRangeValue requestedColorRange, 249 enum NvKmsDpyAttributeCurrentColorSpaceValue *pCurrentColorSpace, 250 enum NvKmsDpyAttributeColorBpcValue *pCurrentColorBpc, 251 enum NvKmsDpyAttributeColorRangeValue *pCurrentColorRange); 252 253 void nvUpdateCurrentHardwareColorSpaceAndRangeEvo( 254 NVDispEvoPtr pDispEvo, 255 const NvU32 head, 256 const enum NvKmsDpyAttributeCurrentColorSpaceValue colorSpace, 257 const enum NvKmsDpyAttributeColorRangeValue colorRange, 258 NVEvoUpdateState *pUpdateState); 259 260 NvBool nvAssignSOREvo(const NVDispEvoRec *pDispEvo, const NvU32 displayId, 261 const NvBool b2Heads1Or, const NvU32 sorExcludeMask); 262 263 void nvSetSwapBarrierNotifyEvo(NVDispEvoPtr pDispEvo, 264 NvBool enable, NvBool isPre); 265 266 void nvUnbloatHwModeTimingsEvo(NVHwModeTimingsEvoPtr pTimings, NvU32 factor); 267 268 NvBool nvReadCRC32Evo(NVDispEvoPtr pDispEvo, NvU32 head, 269 CRC32NotifierCrcOut *crcOut /* out */); 270 271 NvBool nvFreeDevEvo(NVDevEvoPtr pDevEvo); 272 NVDevEvoPtr nvAllocDevEvo(const struct NvKmsAllocDeviceRequest *pRequest, 273 enum NvKmsAllocDeviceStatus *pStatus); 274 NvU32 nvGetActiveSorMask(const NVDispEvoRec *pDispEvo); 275 NvBool nvUpdateFlipLockEvoOneHead(NVDispEvoPtr pDispEvo, const NvU32 head, 276 NvU32 *val, NvBool set, 277 NvBool *needsEarlyUpdate, 278 NVEvoUpdateState *updateState); 279 280 void nvEvoSetLUTContextDma(NVDispEvoPtr pDispEvo, 281 const NvU32 head, NVEvoUpdateState *pUpdateState); 282 283 NvBool nvEvoPollForNoMethodPending(NVDevEvoPtr pDevEvo, 284 const NvU32 sd, 285 NVEvoChannelPtr pChannel, 286 NvU64 *pStartTime, 287 const NvU32 timeout); 288 289 static inline void nvAssertSameSemaphoreSurface( 290 const NVFlipChannelEvoHwState *pHwState) 291 { 292 293 /*! 294 * pHwState->syncObject contains separate fields to track the semaphore 295 * surface used for acquire, and the semaphore surface used for release. 296 * Prior to NvDisplay 4.0, display HW only supports using a single semaphore 297 * surface for both acquire and release. As such, assert that the semaphore 298 * surfaces in pHwState->syncObject are the same, and that we're also not 299 * using syncpoints. This is enforced during flip validation. 300 */ 301 302 nvAssert(pHwState->syncObject.u.semaphores.acquireSurface.pSurfaceEvo == 303 pHwState->syncObject.u.semaphores.releaseSurface.pSurfaceEvo); 304 305 nvAssert(!pHwState->syncObject.usingSyncpt); 306 } 307 308 void nvDPSerializerHandleDPIRQ(NVDispEvoPtr pDispEvo, 309 NVConnectorEvoPtr pConnectorEvo); 310 311 void nvDPSerializerPreSetMode(NVDispEvoPtr pDispEvo, 312 NVConnectorEvoPtr pConnectorEvo); 313 314 void nvDPSerializerPostSetMode(NVDispEvoPtr pDispEvo, 315 NVConnectorEvoPtr pConnectorEvo); 316 317 NvBool nvFramelockSetControlUnsyncEvo(NVDispEvoPtr pDispEvo, const NvU32 headMask, 318 NvBool server); 319 320 NvBool nvIsHDRCapableHead(const NVDispEvoRec *pDispEvo, 321 NvU32 apiHead); 322 323 NvU32 nvGetHDRSrcMaxLum(const NVFlipChannelEvoHwState *pHwState); 324 325 NvBool nvNeedsTmoLut(NVDevEvoPtr pDevEvo, 326 NVEvoChannelPtr pChannel, 327 const NVFlipChannelEvoHwState *pHwState, 328 NvU32 srcMaxLum, 329 NvU32 targetMaxCLL); 330 331 NvBool nvIsCscMatrixIdentity(const struct NvKmsCscMatrix *matrix); 332 333 enum nvKmsPixelDepth nvEvoColorSpaceBpcToPixelDepth( 334 const enum NvKmsDpyAttributeCurrentColorSpaceValue colorSpace, 335 const enum NvKmsDpyAttributeColorBpcValue colorBpc); 336 337 void nvSuspendDevEvo(NVDevEvoRec *pDevEvo); 338 NvBool nvResumeDevEvo(NVDevEvoRec *pDevEvo); 339 340 NvBool nvGetDefaultColorSpace( 341 const NVColorFormatInfoRec *pColorFormatsInfo, 342 enum NvKmsDpyAttributeCurrentColorSpaceValue *pColorSpace, 343 enum NvKmsDpyAttributeColorBpcValue *pColorBpc); 344 345 static inline void nvEvoSetFlipOccurredEvent(const NVDispEvoRec *pDispEvo, 346 const NvU32 head, 347 const NvU32 layer, 348 struct nvkms_ref_ptr *ref_ptr, 349 NVEvoModesetUpdateState 350 *pModesetUpdate) 351 { 352 nvAssert((head < pDispEvo->pDevEvo->numHeads) && 353 (layer < pDispEvo->pDevEvo->head[head].numLayers)); 354 pModesetUpdate->flipOccurredEvent[head].layer[layer].ref_ptr = ref_ptr; 355 pModesetUpdate->flipOccurredEvent[head].layer[layer].changed = TRUE; 356 } 357 358 void nvEvoPreModesetRegisterFlipOccurredEvent(NVDispEvoRec *pDispEvo, 359 const NvU32 head, 360 const NVEvoModesetUpdateState 361 *pModesetUpdate); 362 363 void nvEvoPostModesetUnregisterFlipOccurredEvent(NVDispEvoRec *pDispEvo, 364 const NvU32 head, 365 const NVEvoModesetUpdateState 366 *pModesetUpdate); 367 368 void nvEvoLockStateSetMergeMode(NVDispEvoPtr pDispEvo); 369 370 void nvEvoEnableMergeModePreModeset(NVDispEvoRec *pDispEvo, 371 const NvU32 headsMask, 372 NVEvoUpdateState *pUpdateState); 373 void nvEvoEnableMergeModePostModeset(NVDispEvoRec *pDispEvo, 374 const NvU32 headsMask, 375 NVEvoUpdateState *pUpdateState); 376 void nvEvoDisableMergeMode(NVDispEvoRec *pDispEvo, 377 const NvU32 headsMask, 378 NVEvoUpdateState *pUpdateState); 379 380 void nvEvoDisableHwYUV420Packer(const NVDispEvoRec *pDispEvo, 381 const NvU32 head, 382 NVEvoUpdateState *pUpdateState); 383 384 NvBool nvEvoGetSingleTileHwModeTimings(const NVHwModeTimingsEvo *pSrc, 385 const NvU32 numTiles, 386 NVHwModeTimingsEvo *pDst); 387 388 NvBool nvEvoUse2Heads1OR(const NVDpyEvoRec *pDpyEvo, 389 const NVHwModeTimingsEvo *pTimings, 390 const struct NvKmsModeValidationParams *pParams); 391 392 #ifdef __cplusplus 393 }; 394 #endif 395 396 #endif /* __NVKMS_H__ */ 397