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 nvEvoFlipUpdate(NVDispEvoPtr pDispEvo,
50 NVEvoUpdateState *updateState);
51 void nvEvoArmLightweightSupervisor(NVDispEvoPtr pDispEvo,
52 const NvU32 head,
53 NvBool isVrr,
54 NvBool enable);
55
56 void nvSetViewPortsEvo(NVDispEvoPtr pDispEvo,
57 const NvU32 head, NVEvoUpdateState *updateState);
58 void nvSetViewPortPointInEvo(NVDispEvoPtr pDispEvo,
59 const NvU32 head,
60 const NvU16 x,
61 NvU16 y,
62 NVEvoUpdateState *updateState);
63 void
64 nvConstructNvModeTimingsFromHwModeTimings(const NVHwModeTimingsEvo *pTimings,
65 NvModeTimingsPtr pModeTimings);
66 void nvEvoSetTimings(NVDispEvoPtr pDispEvo, const NvU32 head,
67 NVEvoUpdateState *updateState);
68 void nvInitScalingUsageBounds(const NVDevEvoRec *pDevEvo,
69 struct NvKmsScalingUsageBounds *pScaling);
70 NvBool nvComputeScalingUsageBounds(const NVEvoScalerCaps *pScalerCaps,
71 const NvU32 inWidth, const NvU32 inHeight,
72 const NvU32 outWidth, const NvU32 outHeight,
73 NVEvoScalerTaps hTaps, NVEvoScalerTaps vTaps,
74 struct NvKmsScalingUsageBounds *out);
75 NvBool nvAssignScalerTaps(const NVDevEvoRec *pDevEvo,
76 const NVEvoScalerCaps *pScalerCaps,
77 const NvU32 inWidth, const NvU32 inHeight,
78 const NvU32 outWidth, const NvU32 outHeight,
79 NvBool doubleScan,
80 NVEvoScalerTaps *hTapsOut, NVEvoScalerTaps *vTapsOut);
81 NvBool nvValidateHwModeTimingsViewPort(const NVDevEvoRec *pDevEvo,
82 const NVEvoScalerCaps *pScalerCaps,
83 NVHwModeTimingsEvoPtr pTimings,
84 NVEvoInfoStringPtr pInfoString);
85 void nvAssignDefaultUsageBounds(const NVDispEvoRec *pDispEvo,
86 NVHwModeViewPortEvo *pViewPort);
87 void nvUnionUsageBounds(const struct NvKmsUsageBounds *a,
88 const struct NvKmsUsageBounds *b,
89 struct NvKmsUsageBounds *ret);
90 void nvIntersectUsageBounds(const struct NvKmsUsageBounds *a,
91 const struct NvKmsUsageBounds *b,
92 struct NvKmsUsageBounds *ret);
93 NvBool UsageBoundsEqual(const struct NvKmsUsageBounds *a,
94 const struct NvKmsUsageBounds *b);
95 NvU64 nvEvoGetFormatsWithEqualOrLowerUsageBound(
96 const enum NvKmsSurfaceMemoryFormat format,
97 const NvU64 supportedFormatsCapMask);
98 void nvCancelLowerDispBandwidthTimer(NVDevEvoPtr pDevEvo);
99 void nvScheduleLowerDispBandwidthTimer(NVDevEvoPtr pDevEvo);
100 void nvAssertAllDpysAreInactive(NVDevEvoPtr pDevEvo);
101 void nvEvoLockStatePreModeset(NVDevEvoPtr pDevEvo);
102 void nvEvoLockStatePostModeset(NVDevEvoPtr pDevEvo, const NvBool doRasterLock);
103 NvBool nvSetFlipLockGroup(NVDevEvoRec *pDevEvo[NV_MAX_SUBDEVICES],
104 const struct NvKmsSetFlipLockGroupRequest *pRequest);
105 void nvEvoRemoveOverlappingFlipLockRequestGroupsForModeset(
106 NVDevEvoPtr pDevEvo,
107 const struct NvKmsSetModeRequest *pRequest);
108 NvBool nvSetUsageBoundsEvo(
109 NVDevEvoPtr pDevEvo,
110 NvU32 sd,
111 NvU32 head,
112 const struct NvKmsUsageBounds *pUsage,
113 NVEvoUpdateState *updateState);
114 void nvEnableMidFrameAndDWCFWatermark(NVDevEvoPtr pDevEvo,
115 NvU32 sd,
116 NvU32 head,
117 NvBool enable,
118 NVEvoUpdateState *pUpdateState);
119
120 void nvEvoHeadSetControlOR(NVDispEvoPtr pDispEvo,
121 const NvU32 head, NVEvoUpdateState *pUpdateState);
122
123 void nvChooseDitheringEvo(
124 const NVConnectorEvoRec *pConnectorEvo,
125 enum NvKmsDpyAttributeColorBpcValue bpc,
126 const NVDpyAttributeRequestedDitheringConfig *pReqDithering,
127 NVDpyAttributeCurrentDitheringConfig *pCurrDithering);
128
129 void nvSetDitheringEvo(
130 NVDispEvoPtr pDispEvo,
131 const NvU32 head,
132 const NVDpyAttributeCurrentDitheringConfig *pCurrDithering,
133 NVEvoUpdateState *pUpdateState);
134
135 NvBool nvEnableFrameLockEvo(NVDispEvoPtr pDispEvo);
136 NvBool nvDisableFrameLockEvo(NVDispEvoPtr pDispEvo);
137 NvBool nvQueryRasterLockEvo(const NVDpyEvoRec *pDpyEvo, NvS64 *val);
138 void nvInvalidateRasterLockGroupsEvo(void);
139 NvBool nvSetFlipLockEvo(NVDpyEvoPtr pDpyEvo, NvS64 value);
140 NvBool nvGetFlipLockEvo(const NVDpyEvoRec *pDpyEvo, NvS64 *pValue);
141 NvBool nvAllowFlipLockEvo(NVDispEvoPtr pDispEvo, NvS64 value);
142 NvBool nvSetStereoEvo(const NVDispEvoRec *pDispEvo,
143 const NvU32 head, NvBool enable);
144 NvBool nvGetStereoEvo(const NVDispEvoRec *pDispEvo, const NvU32 head);
145 struct NvKmsCompositionParams nvDefaultCursorCompositionParams(const NVDevEvoRec *pDevEvo);
146 NvBool nvAllocCoreChannelEvo(NVDevEvoPtr pDevEvo);
147 void nvFreeCoreChannelEvo(NVDevEvoPtr pDevEvo);
148
149 void nvEvoUpdateSliVideoBridge(NVDevEvoPtr pDevEvo);
150
151 void nvSetDVCEvo(NVDispEvoPtr pDispEvo,
152 const NvU32 head,
153 NvS32 dvc,
154 NVEvoUpdateState *updateState);
155 void nvSetImageSharpeningEvo(NVDispEvoRec *pDispEvo, const NvU32 head,
156 const NvU32 value, NVEvoUpdateState *updateState);
157
158 NvBool nvLayerSetPositionEvo(
159 NVDevEvoPtr pDevEvo,
160 const struct NvKmsSetLayerPositionRequest *pRequest);
161
162 NvBool nvConstructHwModeTimingsEvo(const NVDpyEvoRec *pDpyEvo,
163 const struct NvKmsMode *pKmsMode,
164 const struct NvKmsSize *pViewPortSizeIn,
165 const struct NvKmsRect *pViewPortOut,
166 NVHwModeTimingsEvoPtr pTimings,
167 const struct NvKmsModeValidationParams
168 *pParams,
169 NVEvoInfoStringPtr pInfoString);
170
171 NvBool nvConstructHwModeTimingsImpCheckEvo(
172 const NVConnectorEvoRec *pConnectorEvo,
173 const NVHwModeTimingsEvo *pTimings,
174 const NvBool enableDsc,
175 const NvBool b2Heads1Or,
176 const enum NvKmsDpyAttributeCurrentColorSpaceValue colorSpace,
177 const enum NvKmsDpyAttributeColorBpcValue colorBpc,
178 const struct NvKmsModeValidationParams *pParams,
179 NVHwModeTimingsEvo timings[NVKMS_MAX_HEADS_PER_DISP],
180 NvU32 *pNumHeads,
181 NVEvoInfoStringPtr pInfoString);
182
183 NvBool nvDowngradeColorSpaceAndBpc(
184 const NVColorFormatInfoRec *pSupportedColorFormats,
185 enum NvKmsDpyAttributeCurrentColorSpaceValue *pColorSpace,
186 enum NvKmsDpyAttributeColorBpcValue *pColorBpc,
187 enum NvKmsDpyAttributeColorRangeValue *pColorRange);
188
189 NvBool nvDPValidateModeEvo(NVDpyEvoPtr pDpyEvo,
190 NVHwModeTimingsEvoPtr pTimings,
191 enum NvKmsDpyAttributeCurrentColorSpaceValue *pColorSpace,
192 enum NvKmsDpyAttributeColorBpcValue *pColorBpc,
193 const NvBool b2Heads1Or,
194 NVDscInfoEvoRec *pDscInfo,
195 const struct NvKmsModeValidationParams *pParams);
196
197 NvBool nvEvoUpdateHwModeTimingsViewPort(
198 const NVDpyEvoRec *pDpyEvo,
199 const struct NvKmsModeValidationParams *pModeValidationParams,
200 const struct NvKmsSize *pViewPortSizeIn,
201 const struct NvKmsRect *pViewPortOut,
202 NVHwModeTimingsEvo *pTimings);
203
204 typedef struct _NVValidateImpOneDispHeadParamsRec
205 {
206 const NVConnectorEvoRec *pConnectorEvo;
207 const struct NvKmsUsageBounds *pUsage;
208 NvU32 activeRmId;
209 enum nvKmsPixelDepth pixelDepth;
210 NVHwModeTimingsEvoPtr pTimings;
211 NvBool enableDsc;
212 NvBool b2Heads1Or;
213 } NVValidateImpOneDispHeadParamsRec;
214
215 NvBool nvValidateImpOneDisp(
216 NVDispEvoPtr pDispEvo,
217 const NVValidateImpOneDispHeadParamsRec timingsParams[NVKMS_MAX_HEADS_PER_DISP],
218 NvBool requireBootClocks,
219 NVEvoReallocateBandwidthMode reallocBandwidth,
220 NvU32 *pMinIsoBandwidthKBPS,
221 NvU32 *pMinDramFloorKBPS);
222
223 NvBool nvAllocateDisplayBandwidth(
224 NVDispEvoPtr pDispEvo,
225 NvU32 newIsoBandwidthKBPS,
226 NvU32 newDramFloorKBPS);
227
228 NvBool nvValidateImpOneDispDowngrade(
229 NVDispEvoPtr pDispEvo,
230 const NVValidateImpOneDispHeadParamsRec timingsParams[NVKMS_MAX_HEADS_PER_DISP],
231 NvBool requireBootClocks,
232 NVEvoReallocateBandwidthMode reallocBandwidth,
233 NvU32 downgradePossibleHeadsBitMask);
234
235 NvBool nvFrameLockServerPossibleEvo(const NVDpyEvoRec *pDpyEvo);
236 NvBool nvFrameLockClientPossibleEvo(const NVDpyEvoRec *pDpyEvo);
237
238 NvBool nvEvoLUTNotifiersNeedCommit(NVDispEvoPtr pDispEvo);
239 int nvEvoCommitLUTNotifiers(NVDispEvoPtr pDispEvo);
240 void nvEvoClearStagedLUTNotifiers(NVDispEvoPtr pDispEvo);
241 void nvEvoStageLUTNotifier(NVDispEvoPtr pDispEvo, NvU32 apiHead);
242 NvBool nvEvoIsLUTNotifierComplete(NVDispEvoPtr pDispEvo, NvU32 apiHead);
243 void nvEvoWaitForLUTNotifier(const NVDispEvoPtr pDispEvo, NvU32 apiHead);
244
245 void nvEvoSetLut(NVDispEvoPtr pDispEvo, NvU32 apiHead, NvBool kickoff,
246 const struct NvKmsSetLutCommonParams *pParams);
247 NvBool nvValidateSetLutCommonParams(
248 const NVDevEvoRec *pDevEvo,
249 const struct NvKmsSetLutCommonParams *pParams);
250
251 NvBool nvChooseColorRangeEvo(
252 enum NvKmsOutputColorimetry colorimetry,
253 const enum NvKmsDpyAttributeColorRangeValue requestedColorRange,
254 const enum NvKmsDpyAttributeCurrentColorSpaceValue colorSpace,
255 const enum NvKmsDpyAttributeColorBpcValue colorBpc,
256 enum NvKmsDpyAttributeColorRangeValue *pColorRange);
257
258 NvBool nvChooseCurrentColorSpaceAndRangeEvo(
259 const NVDpyEvoRec *pDpyEvo,
260 const NVHwModeTimingsEvo *pHwTimings,
261 NvU8 hdmiFrlBpc,
262 enum NvKmsOutputColorimetry colorimetry,
263 const enum NvKmsDpyAttributeRequestedColorSpaceValue requestedColorSpace,
264 const enum NvKmsDpyAttributeColorRangeValue requestedColorRange,
265 enum NvKmsDpyAttributeCurrentColorSpaceValue *pCurrentColorSpace,
266 enum NvKmsDpyAttributeColorBpcValue *pCurrentColorBpc,
267 enum NvKmsDpyAttributeColorRangeValue *pCurrentColorRange);
268
269 void nvUpdateCurrentHardwareColorSpaceAndRangeEvo(
270 NVDispEvoPtr pDispEvo,
271 const NvU32 head,
272 const enum NvKmsOutputColorimetry colorimetry,
273 const enum NvKmsDpyAttributeCurrentColorSpaceValue colorSpace,
274 const enum NvKmsDpyAttributeColorRangeValue colorRange,
275 NVEvoUpdateState *pUpdateState);
276
277 NvBool nvAssignSOREvo(const NVDispEvoRec *pDispEvo, const NvU32 displayId,
278 const NvBool b2Heads1Or, const NvU32 sorExcludeMask);
279
280 void nvSetSwapBarrierNotifyEvo(NVDispEvoPtr pDispEvo,
281 NvBool enable, NvBool isPre);
282
283 void nvUnbloatHwModeTimingsEvo(NVHwModeTimingsEvoPtr pTimings, NvU32 factor);
284
285 NvBool nvReadCRC32Evo(NVDispEvoPtr pDispEvo, NvU32 head,
286 CRC32NotifierCrcOut *crcOut /* out */);
287
288 NvBool nvFreeDevEvo(NVDevEvoPtr pDevEvo);
289 NVDevEvoPtr nvAllocDevEvo(const struct NvKmsAllocDeviceRequest *pRequest,
290 enum NvKmsAllocDeviceStatus *pStatus);
291 NvU32 nvGetActiveSorMask(const NVDispEvoRec *pDispEvo);
292 NvBool nvUpdateFlipLockEvoOneHead(NVDispEvoPtr pDispEvo, const NvU32 head,
293 NvU32 *val, NvBool set,
294 NVEvoUpdateState *updateState);
295
296 void nvEvoSetLUTContextDma(NVDispEvoPtr pDispEvo,
297 const NvU32 head, NVEvoUpdateState *pUpdateState);
298
299 NvBool nvEvoPollForNoMethodPending(NVDevEvoPtr pDevEvo,
300 const NvU32 sd,
301 NVEvoChannelPtr pChannel,
302 NvU64 *pStartTime,
303 const NvU32 timeout);
304
nvAssertSameSemaphoreSurface(const NVFlipChannelEvoHwState * pHwState)305 static inline void nvAssertSameSemaphoreSurface(
306 const NVFlipChannelEvoHwState *pHwState)
307 {
308
309 /*!
310 * pHwState->syncObject contains separate fields to track the semaphore
311 * surface used for acquire, and the semaphore surface used for release.
312 * Prior to NvDisplay 4.0, display HW only supports using a single semaphore
313 * surface for both acquire and release. As such, assert that the semaphore
314 * surfaces in pHwState->syncObject are the same, and that we're also not
315 * using syncpoints. This is enforced during flip validation.
316 */
317
318 nvAssert(pHwState->syncObject.u.semaphores.acquireSurface.pSurfaceEvo ==
319 pHwState->syncObject.u.semaphores.releaseSurface.pSurfaceEvo);
320
321 nvAssert(!pHwState->syncObject.usingSyncpt);
322 }
323
324 void nvDPSerializerHandleDPIRQ(NVDispEvoPtr pDispEvo,
325 NVConnectorEvoPtr pConnectorEvo);
326
327 void nvDPSerializerPreSetMode(NVDispEvoPtr pDispEvo,
328 NVConnectorEvoPtr pConnectorEvo);
329
330 void nvDPSerializerPostSetMode(NVDispEvoPtr pDispEvo,
331 NVConnectorEvoPtr pConnectorEvo);
332
333 NvBool nvFramelockSetControlUnsyncEvo(NVDispEvoPtr pDispEvo, const NvU32 headMask,
334 NvBool server);
335
336 NvU32 nvGetHDRSrcMaxLum(const NVFlipChannelEvoHwState *pHwState);
337
338 NvBool nvNeedsTmoLut(NVDevEvoPtr pDevEvo,
339 NVEvoChannelPtr pChannel,
340 const NVFlipChannelEvoHwState *pHwState,
341 NvU32 srcMaxLum,
342 NvU32 targetMaxCLL);
343
344 NvBool nvIsCscMatrixIdentity(const struct NvKmsCscMatrix *matrix);
345
346 enum nvKmsPixelDepth nvEvoColorSpaceBpcToPixelDepth(
347 const enum NvKmsDpyAttributeCurrentColorSpaceValue colorSpace,
348 const enum NvKmsDpyAttributeColorBpcValue colorBpc);
349
350 void nvSuspendDevEvo(NVDevEvoRec *pDevEvo);
351 NvBool nvResumeDevEvo(NVDevEvoRec *pDevEvo);
352
353 NvBool nvGetDefaultColorSpace(
354 const NVColorFormatInfoRec *pColorFormatsInfo,
355 enum NvKmsDpyAttributeCurrentColorSpaceValue *pColorSpace,
356 enum NvKmsDpyAttributeColorBpcValue *pColorBpc);
357
nvEvoSetFlipOccurredEvent(const NVDispEvoRec * pDispEvo,const NvU32 head,const NvU32 layer,struct nvkms_ref_ptr * ref_ptr,NVEvoModesetUpdateState * pModesetUpdate)358 static inline void nvEvoSetFlipOccurredEvent(const NVDispEvoRec *pDispEvo,
359 const NvU32 head,
360 const NvU32 layer,
361 struct nvkms_ref_ptr *ref_ptr,
362 NVEvoModesetUpdateState
363 *pModesetUpdate)
364 {
365 nvAssert((head < pDispEvo->pDevEvo->numHeads) &&
366 (layer < pDispEvo->pDevEvo->head[head].numLayers));
367 pModesetUpdate->flipOccurredEvent[head].layer[layer].ref_ptr = ref_ptr;
368 pModesetUpdate->flipOccurredEvent[head].layer[layer].changed = TRUE;
369 }
370
371 void nvEvoPreModesetRegisterFlipOccurredEvent(NVDispEvoRec *pDispEvo,
372 const NvU32 head,
373 const NVEvoModesetUpdateState
374 *pModesetUpdate);
375
376 void nvEvoPostModesetUnregisterFlipOccurredEvent(NVDispEvoRec *pDispEvo,
377 const NvU32 head,
378 const NVEvoModesetUpdateState
379 *pModesetUpdate);
380
381 void nvEvoLockStateSetMergeMode(NVDispEvoPtr pDispEvo);
382
383 void nvEvoEnableMergeModePreModeset(NVDispEvoRec *pDispEvo,
384 const NvU32 headsMask,
385 NVEvoUpdateState *pUpdateState);
386 void nvEvoEnableMergeModePostModeset(NVDispEvoRec *pDispEvo,
387 const NvU32 headsMask,
388 NVEvoUpdateState *pUpdateState);
389 void nvEvoDisableMergeMode(NVDispEvoRec *pDispEvo,
390 const NvU32 headsMask,
391 NVEvoUpdateState *pUpdateState);
392
393 void nvEvoDisableHwYUV420Packer(const NVDispEvoRec *pDispEvo,
394 const NvU32 head,
395 NVEvoUpdateState *pUpdateState);
396
397 NvBool nvEvoGetSingleTileHwModeTimings(const NVHwModeTimingsEvo *pSrc,
398 const NvU32 numTiles,
399 NVHwModeTimingsEvo *pDst);
400
401 NvBool nvEvoUse2Heads1OR(const NVDpyEvoRec *pDpyEvo,
402 const NVHwModeTimingsEvo *pTimings,
403 const struct NvKmsModeValidationParams *pParams);
404
405 NvU32 nvGetRefreshRate10kHz(const NVHwModeTimingsEvo *pTimings);
406
407 NvBool nvIsLockGroupFlipLocked(const NVLockGroup *pLockGroup);
408
409 NvBool nvEvoIsConsoleActive(const NVDevEvoRec *pDevEvo);
410
411 #ifdef __cplusplus
412 };
413 #endif
414
415 #endif /* __NVKMS_H__ */
416