1 /*
2 * SPDX-FileCopyrightText: Copyright (c) 1993-2023 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 #include "deprecated/rmapi_deprecated.h"
25
26
27 #include "class/cl00b1.h" // NV01_MEMORY_HW_RESOURCES
28 #include "class/cl003e.h" // NV01_MEMORY_SYSTEM
29 #include "class/cl0071.h" // NV01_MEMORY_SYSTEM_OS_DESCRIPTOR
30 #include "class/cl50a0.h" // NV50_MEMORY_VIRTUAL
31 #include "class/cl0040.h" // NV01_MEMORY_LOCAL_USER
32 #include "class/cl0042.h" // NV_MEMORY_EXTENDED_USER
33
34 #include "ctrl/ctrl0041.h" // NV04_MEMORY
35 #include "ctrl/ctrl2080/ctrl2080fb.h" // NV2080_CTRL_FB_INFO
36
37 typedef NV_STATUS RmVidHeapControlFunc(DEPRECATED_CONTEXT *, NVOS32_PARAMETERS *);
38
39 typedef struct {
40 NvU32 function; // NVOS32_FUNCTION_* value
41 RmVidHeapControlFunc *pFunc; // pointer to handler
42 } RmVidHeapControlEntry;
43
44 // forward declarations
45 static NV_STATUS _nvos32FunctionAllocSize(DEPRECATED_CONTEXT *, NVOS32_PARAMETERS *);
46 static NV_STATUS _nvos32FunctionAllocSizeRange(DEPRECATED_CONTEXT *, NVOS32_PARAMETERS *);
47 static NV_STATUS _nvos32FunctionAllocTiledPitchHeight(DEPRECATED_CONTEXT *, NVOS32_PARAMETERS *);
48 static NV_STATUS _nvos32FunctionFree(DEPRECATED_CONTEXT *, NVOS32_PARAMETERS *);
49 static NV_STATUS _nvos32FunctionInfo(DEPRECATED_CONTEXT *, NVOS32_PARAMETERS *);
50 static NV_STATUS _nvos32FunctionDump(DEPRECATED_CONTEXT *, NVOS32_PARAMETERS *);
51 static NV_STATUS _nvos32FunctionReleaseReacquireCompr(DEPRECATED_CONTEXT *, NVOS32_PARAMETERS *);
52 static NV_STATUS _nvos32FunctionGetMemAlignment(DEPRECATED_CONTEXT *, NVOS32_PARAMETERS *);
53 static NV_STATUS _nvos32FunctionHwAlloc(DEPRECATED_CONTEXT *, NVOS32_PARAMETERS *);
54 static NV_STATUS _nvos32FunctionHwFree(DEPRECATED_CONTEXT *, NVOS32_PARAMETERS *);
55 static NV_STATUS _nvos32FunctionAllocOsDesc(DEPRECATED_CONTEXT *, NVOS32_PARAMETERS *);
56
57 static const RmVidHeapControlEntry rmVidHeapControlTable[] = {
58
59 { NVOS32_FUNCTION_ALLOC_SIZE, _nvos32FunctionAllocSize },
60 { NVOS32_FUNCTION_ALLOC_SIZE_RANGE, _nvos32FunctionAllocSizeRange },
61 { NVOS32_FUNCTION_ALLOC_TILED_PITCH_HEIGHT, _nvos32FunctionAllocTiledPitchHeight },
62 { NVOS32_FUNCTION_FREE, _nvos32FunctionFree },
63 { NVOS32_FUNCTION_INFO, _nvos32FunctionInfo },
64 { NVOS32_FUNCTION_DUMP, _nvos32FunctionDump },
65 { NVOS32_FUNCTION_RELEASE_COMPR, _nvos32FunctionReleaseReacquireCompr },
66 { NVOS32_FUNCTION_REACQUIRE_COMPR, _nvos32FunctionReleaseReacquireCompr },
67 { NVOS32_FUNCTION_GET_MEM_ALIGNMENT, _nvos32FunctionGetMemAlignment },
68 { NVOS32_FUNCTION_HW_ALLOC, _nvos32FunctionHwAlloc },
69 { NVOS32_FUNCTION_HW_FREE, _nvos32FunctionHwFree },
70 { NVOS32_FUNCTION_ALLOC_OS_DESCRIPTOR, _nvos32FunctionAllocOsDesc },
71 };
72
73 static NvU32 rmVidHeapControlTableSize = sizeof(rmVidHeapControlTable) / sizeof(rmVidHeapControlTable[0]);
74
75 void
RmDeprecatedVidHeapControl(DEPRECATED_CONTEXT * pContext,NVOS32_PARAMETERS * pArgs)76 RmDeprecatedVidHeapControl
77 (
78 DEPRECATED_CONTEXT *pContext,
79 NVOS32_PARAMETERS *pArgs
80 )
81 {
82 NvU32 i;
83 NV_STATUS status;
84
85 // IVC heap is supported only on embedded platforms.
86 if (pArgs->ivcHeapNumber > NVOS32_IVC_HEAP_NUMBER_DONT_ALLOCATE_ON_IVC_HEAP)
87 {
88 status = NV_ERR_NOT_SUPPORTED;
89 goto done;
90 }
91
92 // search rmVidHeapControlTable for handler
93 for (i = 0; i < rmVidHeapControlTableSize; i++)
94 if (pArgs->function == rmVidHeapControlTable[i].function)
95 break;
96
97 // check that we have a valid handler
98 if (i == rmVidHeapControlTableSize)
99 {
100 status = NV_ERR_INVALID_ARGUMENT;
101 goto done;
102 }
103
104 // issue the call
105 status = rmVidHeapControlTable[i].pFunc(pContext, pArgs);
106
107 done:
108 pArgs->status = status;
109 }
110
111 // Helper macros to convert old vidheapctrl param structs into NV_MEMORY_ALLOCATION_PARAMS
112 #define _COPY_IN(newField, oldField) allocParams.newField = pArgs->data.oldField;
113 #define _COPY_OUT(newField, oldField) pArgs->data.oldField = allocParams.newField;
114 #define _NO_COPY(newField, oldField)
115
116 static NV_STATUS
_rmVidHeapControlAllocCommon(DEPRECATED_CONTEXT * pContext,NVOS32_PARAMETERS * pArgs,NvHandle hClient,NvHandle hDevice,NvHandle * phMemory,NV_MEMORY_ALLOCATION_PARAMS * pUserParams)117 _rmVidHeapControlAllocCommon
118 (
119 DEPRECATED_CONTEXT *pContext,
120 NVOS32_PARAMETERS *pArgs,
121 NvHandle hClient,
122 NvHandle hDevice,
123 NvHandle *phMemory,
124 NV_MEMORY_ALLOCATION_PARAMS *pUserParams
125 )
126 {
127 NV_STATUS status;
128 NvU32 externalClassId;
129
130 if (0 == (pUserParams->flags & NVOS32_ALLOC_FLAGS_MEMORY_HANDLE_PROVIDED))
131 {
132 // RmAlloc will generate a handle when hMemory = 0
133 *phMemory = 0;
134 }
135
136 pUserParams->hVASpace = pArgs->hVASpace;
137
138 if (pUserParams->flags & NVOS32_ALLOC_FLAGS_VIRTUAL)
139 externalClassId = NV50_MEMORY_VIRTUAL;
140 else if (FLD_TEST_DRF(OS32, _ATTR2, _USE_EGM, _TRUE, pUserParams->attr2))
141 externalClassId = NV_MEMORY_EXTENDED_USER;
142 else if (FLD_TEST_DRF(OS32, _ATTR, _LOCATION, _VIDMEM, pUserParams->attr))
143 externalClassId = NV01_MEMORY_LOCAL_USER;
144 else
145 externalClassId = NV01_MEMORY_SYSTEM;
146
147 status = pContext->RmAlloc(pContext, hClient, hDevice, phMemory, externalClassId,
148 pUserParams, sizeof(*pUserParams));
149
150 pArgs->free = 0;
151 pArgs->total = 0;
152
153 return status;
154 }
155
156 static NV_STATUS
_nvos32FunctionAllocSize(DEPRECATED_CONTEXT * pContext,NVOS32_PARAMETERS * pArgs)157 _nvos32FunctionAllocSize
158 (
159 DEPRECATED_CONTEXT *pContext,
160 NVOS32_PARAMETERS *pArgs
161 )
162 {
163 NV_MEMORY_ALLOCATION_PARAMS allocParams = {0};
164 NV_STATUS status = NV_OK;
165
166 // Range begin/end are captured only if the appropriate flag bit is set.
167 if (pArgs->data.AllocSize.flags & NVOS32_ALLOC_FLAGS_USE_BEGIN_END)
168 {
169 allocParams.rangeLo = pArgs->data.AllocSize.rangeBegin;
170 allocParams.rangeHi = pArgs->data.AllocSize.rangeEnd;
171 }
172 else
173 {
174 allocParams.rangeLo = 0;
175 allocParams.rangeHi = 0;
176 }
177
178 #define ALLOC_SIZE_PARAMS(_IN, _IN_OUT) \
179 _IN(owner, AllocSize.owner) \
180 _IN(type, AllocSize.type) \
181 _IN(flags, AllocSize.flags) \
182 _IN(height, AllocSize.height) \
183 _IN(width, AllocSize.width) \
184 _IN_OUT(size, AllocSize.size) \
185 _IN(alignment, AllocSize.alignment) \
186 _IN(numaNode, AllocSize.numaNode) \
187 _IN_OUT(offset, AllocSize.offset) \
188 _IN_OUT(attr, AllocSize.attr) \
189 _IN_OUT(attr2, AllocSize.attr2) \
190 _IN_OUT(format, AllocSize.format) \
191 _IN_OUT(limit, AllocSize.limit) \
192 _IN_OUT(address, AllocSize.address) \
193 _IN_OUT(comprCovg, AllocSize.comprCovg) \
194 _IN_OUT(zcullCovg, AllocSize.zcullCovg) \
195 _IN_OUT(ctagOffset, AllocSize.ctagOffset)
196
197 ALLOC_SIZE_PARAMS(_COPY_IN, _COPY_IN);
198
199 pArgs->data.AllocSize.partitionStride = 256;
200
201 // get memory
202 status = _rmVidHeapControlAllocCommon(pContext,
203 pArgs,
204 pArgs->hRoot,
205 pArgs->hObjectParent,
206 &pArgs->data.AllocSize.hMemory,
207 &allocParams);
208
209 ALLOC_SIZE_PARAMS(_NO_COPY, _COPY_OUT);
210
211 return status;
212 }
213
214 static NV_STATUS
_nvos32FunctionAllocSizeRange(DEPRECATED_CONTEXT * pContext,NVOS32_PARAMETERS * pArgs)215 _nvos32FunctionAllocSizeRange
216 (
217 DEPRECATED_CONTEXT *pContext,
218 NVOS32_PARAMETERS *pArgs
219 )
220 {
221 NV_MEMORY_ALLOCATION_PARAMS allocParams = {0};
222 NV_STATUS status = NV_OK;
223
224 #define ALLOC_SIZE_RANGE_PARAMS(_IN, _IN_OUT) \
225 _IN(owner, AllocSizeRange.owner) \
226 _IN(type, AllocSizeRange.type) \
227 _IN(flags, AllocSizeRange.flags) \
228 _IN(rangeLo, AllocSizeRange.rangeBegin) \
229 _IN(rangeHi, AllocSizeRange.rangeEnd) \
230 _IN_OUT(size, AllocSizeRange.size) \
231 _IN(alignment, AllocSizeRange.alignment) \
232 _IN(numaNode, AllocSizeRange.numaNode) \
233 _IN_OUT(offset, AllocSizeRange.offset) \
234 _IN_OUT(attr, AllocSizeRange.attr) \
235 _IN_OUT(attr2, AllocSizeRange.attr2) \
236 _IN_OUT(format, AllocSizeRange.format) \
237 _IN_OUT(limit, AllocSizeRange.limit) \
238 _IN_OUT(address, AllocSizeRange.address) \
239 _IN_OUT(comprCovg, AllocSizeRange.comprCovg) \
240 _IN_OUT(zcullCovg, AllocSizeRange.zcullCovg) \
241 _IN_OUT(ctagOffset, AllocSizeRange.ctagOffset)
242
243 ALLOC_SIZE_RANGE_PARAMS(_COPY_IN, _COPY_IN);
244
245 pArgs->data.AllocSizeRange.partitionStride = 256;
246
247 // get memory
248 status = _rmVidHeapControlAllocCommon(pContext,
249 pArgs,
250 pArgs->hRoot,
251 pArgs->hObjectParent,
252 &pArgs->data.AllocSizeRange.hMemory,
253 &allocParams);
254
255 ALLOC_SIZE_RANGE_PARAMS(_NO_COPY, _COPY_OUT);
256
257 return status;
258 }
259
260 static NV_STATUS
_nvos32FunctionAllocTiledPitchHeight(DEPRECATED_CONTEXT * pContext,NVOS32_PARAMETERS * pArgs)261 _nvos32FunctionAllocTiledPitchHeight
262 (
263 DEPRECATED_CONTEXT *pContext,
264 NVOS32_PARAMETERS *pArgs
265 )
266 {
267 NV_MEMORY_ALLOCATION_PARAMS allocParams = {0};
268 NV_STATUS status = NV_OK;
269
270 pArgs->data.AllocTiledPitchHeight.size =
271 (NvU64)pArgs->data.AllocTiledPitchHeight.height * pArgs->data.AllocTiledPitchHeight.pitch;
272
273 // Range begin/end are captured only if the appropriate flag bit is set.
274 if (pArgs->data.AllocTiledPitchHeight.flags & NVOS32_ALLOC_FLAGS_USE_BEGIN_END)
275 {
276 allocParams.rangeLo = pArgs->data.AllocTiledPitchHeight.rangeBegin;
277 allocParams.rangeHi = pArgs->data.AllocTiledPitchHeight.rangeEnd;
278 }
279 else
280 {
281 allocParams.rangeLo = 0;
282 allocParams.rangeHi = 0;
283 }
284
285 #define ALLOC_TILE_PITCH_PARAMS(_IN, _IN_OUT) \
286 _IN(owner, AllocTiledPitchHeight.owner) \
287 _IN(type, AllocTiledPitchHeight.type) \
288 _IN(flags, AllocTiledPitchHeight.flags) \
289 _IN(height, AllocTiledPitchHeight.height) \
290 _IN(width, AllocTiledPitchHeight.width) \
291 _IN(pitch, AllocTiledPitchHeight.pitch) \
292 _IN_OUT(size, AllocTiledPitchHeight.size) \
293 _IN(alignment, AllocTiledPitchHeight.alignment) \
294 _IN(numaNode, AllocTiledPitchHeight.numaNode) \
295 _IN_OUT(offset, AllocTiledPitchHeight.offset) \
296 _IN_OUT(attr, AllocTiledPitchHeight.attr) \
297 _IN_OUT(attr2, AllocTiledPitchHeight.attr2) \
298 _IN_OUT(format, AllocTiledPitchHeight.format) \
299 _IN_OUT(limit, AllocTiledPitchHeight.limit) \
300 _IN_OUT(address, AllocTiledPitchHeight.address) \
301 _IN_OUT(comprCovg, AllocTiledPitchHeight.comprCovg) \
302 _IN_OUT(zcullCovg, AllocTiledPitchHeight.zcullCovg) \
303 _IN_OUT(ctagOffset, AllocTiledPitchHeight.ctagOffset)
304
305 ALLOC_TILE_PITCH_PARAMS(_COPY_IN, _COPY_IN);
306
307 pArgs->data.AllocTiledPitchHeight.partitionStride = 256;
308
309 // get memory
310 status = _rmVidHeapControlAllocCommon(pContext,
311 pArgs,
312 pArgs->hRoot,
313 pArgs->hObjectParent,
314 &pArgs->data.AllocTiledPitchHeight.hMemory,
315 &allocParams);
316
317 ALLOC_TILE_PITCH_PARAMS(_NO_COPY, _COPY_OUT);
318
319 return status;
320 }
321
322 static NV_STATUS
_nvos32FunctionFree(DEPRECATED_CONTEXT * pContext,NVOS32_PARAMETERS * pArgs)323 _nvos32FunctionFree
324 (
325 DEPRECATED_CONTEXT *pContext,
326 NVOS32_PARAMETERS *pArgs
327 )
328 {
329 NvHandle hMemory;
330 NvHandle hClient = pArgs->hRoot;
331
332 if ((pArgs->data.Free.flags & NVOS32_FREE_FLAGS_MEMORY_HANDLE_PROVIDED) == 0)
333 {
334 return NV_ERR_INVALID_ARGUMENT;
335 }
336
337 hMemory = pArgs->data.Free.hMemory;
338
339 return pContext->RmFree(pContext, hClient, hMemory);
340 }
341
342 static NV_STATUS
_nvos32FunctionInfo(DEPRECATED_CONTEXT * pContext,NVOS32_PARAMETERS * pArgs)343 _nvos32FunctionInfo
344 (
345 DEPRECATED_CONTEXT *pContext,
346 NVOS32_PARAMETERS *pArgs
347 )
348 {
349 NV2080_CTRL_FB_GET_INFO_V2_PARAMS fbInfoParams = {0};
350 NV_STATUS status;
351 NvHandle hSubDevice;
352 NvBool bMustFreeSubDevice;
353 NvHandle hClient = pArgs->hRoot;
354 NvHandle hDevice = pArgs->hObjectParent;
355
356 status = RmDeprecatedFindOrCreateSubDeviceHandle(pContext, hClient, hDevice,
357 &hSubDevice, &bMustFreeSubDevice);
358
359 if (status != NV_OK)
360 return status;
361
362 fbInfoParams.fbInfoListSize = 6;
363
364 fbInfoParams.fbInfoList[0].index = NV2080_CTRL_FB_INFO_INDEX_HEAP_FREE;
365 fbInfoParams.fbInfoList[1].index = NV2080_CTRL_FB_INFO_INDEX_HEAP_SIZE;
366 fbInfoParams.fbInfoList[2].index = NV2080_CTRL_FB_INFO_INDEX_FB_TAX_SIZE_KB;
367 fbInfoParams.fbInfoList[3].index = NV2080_CTRL_FB_INFO_INDEX_HEAP_BASE_KB;
368 fbInfoParams.fbInfoList[4].index = NV2080_CTRL_FB_INFO_INDEX_LARGEST_FREE_REGION_SIZE_KB;
369 fbInfoParams.fbInfoList[5].index = NV2080_CTRL_FB_INFO_INDEX_LARGEST_FREE_REGION_BASE_KB;
370
371 status = pContext->RmControl(pContext, hClient, hSubDevice,
372 NV2080_CTRL_CMD_FB_GET_INFO_V2,
373 &fbInfoParams,
374 sizeof(fbInfoParams));
375
376 pArgs->free = ((NvU64)fbInfoParams.fbInfoList[0].data << 10);
377 pArgs->total = ((NvU64)fbInfoParams.fbInfoList[1].data << 10);
378 pArgs->total += ((NvU64)fbInfoParams.fbInfoList[2].data << 10); // For vGPU, add FB tax incurred by host RM
379 pArgs->data.Info.base = ((NvU64)fbInfoParams.fbInfoList[3].data << 10);
380 pArgs->data.Info.size = ((NvU64)fbInfoParams.fbInfoList[4].data << 10);
381 pArgs->data.Info.offset = ((NvU64)fbInfoParams.fbInfoList[5].data << 10);
382
383 if (bMustFreeSubDevice)
384 {
385 pContext->RmFree(pContext, hClient, hSubDevice);
386 }
387
388 return status;
389 }
390
391 static NV_STATUS
_nvos32FunctionDump(DEPRECATED_CONTEXT * pContext,NVOS32_PARAMETERS * pArgs)392 _nvos32FunctionDump
393 (
394 DEPRECATED_CONTEXT *pContext,
395 NVOS32_PARAMETERS *pArgs
396 )
397 {
398 // Not supported since PMA
399 return NV_ERR_NOT_SUPPORTED;
400 }
401
402 static NV_STATUS
_nvos32FunctionReleaseReacquireCompr(DEPRECATED_CONTEXT * pContext,NVOS32_PARAMETERS * pArgs)403 _nvos32FunctionReleaseReacquireCompr
404 (
405 DEPRECATED_CONTEXT *pContext,
406 NVOS32_PARAMETERS *pArgs
407 )
408 {
409 NV_STATUS status = NV_OK;
410 NV0041_CTRL_UPDATE_SURFACE_COMPRESSION_PARAMS updateParams = {0};
411
412 // We're using ReleaseCompr here when we have that _and_ ReacquireCompr to deal with in
413 // terms of args. AT least we can make sure they aren't broken runtime...
414 if ( !( ( NV_OFFSETOF(NVOS32_PARAMETERS, data.ReleaseCompr.flags) ==
415 NV_OFFSETOF(NVOS32_PARAMETERS, data.ReacquireCompr.flags) ) &&
416 ( NV_OFFSETOF(NVOS32_PARAMETERS, data.ReleaseCompr.hMemory) ==
417 NV_OFFSETOF(NVOS32_PARAMETERS, data.ReacquireCompr.hMemory) ) &&
418 ( NV_OFFSETOF(NVOS32_PARAMETERS, data.ReleaseCompr.owner) ==
419 NV_OFFSETOF(NVOS32_PARAMETERS, data.ReacquireCompr.owner) ) ) )
420 {
421 return NV_ERR_GENERIC;
422 }
423
424 if (!(pArgs->data.ReleaseCompr.flags & NVOS32_RELEASE_COMPR_FLAGS_MEMORY_HANDLE_PROVIDED))
425 return NV_ERR_INVALID_FLAGS;
426
427 updateParams.bRelease = (pArgs->function == NVOS32_FUNCTION_RELEASE_COMPR);
428
429 status = pContext->RmControl(pContext, pArgs->hRoot, pArgs->data.ReleaseCompr.hMemory,
430 NV0041_CTRL_CMD_UPDATE_SURFACE_COMPRESSION,
431 &updateParams,
432 sizeof(updateParams));
433
434 return status;
435 }
436
437 static NV_STATUS
_nvos32FunctionGetMemAlignment(DEPRECATED_CONTEXT * pContext,NVOS32_PARAMETERS * pArgs)438 _nvos32FunctionGetMemAlignment
439 (
440 DEPRECATED_CONTEXT *pContext,
441 NVOS32_PARAMETERS *pArgs
442 )
443 {
444 NV2080_CTRL_FB_GET_MEM_ALIGNMENT_PARAMS allocParams = {0};
445 NV_STATUS status = NV_OK;
446 NvHandle hSubDevice;
447 NvBool bMustFreeSubDevice;
448
449 #define GET_MEMORY_ALIGNMENT_PARAMS(_IN, _IN_OUT) \
450 _IN_OUT(alignType, AllocHintAlignment.alignType) \
451 _IN_OUT(alignAttr, AllocHintAlignment.alignAttr) \
452 _IN_OUT(alignInputFlags, AllocHintAlignment.alignInputFlags) \
453 _IN_OUT(alignSize, AllocHintAlignment.alignSize) \
454 _IN_OUT(alignHeight, AllocHintAlignment.alignHeight) \
455 _IN_OUT(alignWidth, AllocHintAlignment.alignWidth) \
456 _IN_OUT(alignPitch, AllocHintAlignment.alignPitch) \
457 _IN_OUT(alignPad, AllocHintAlignment.alignPad) \
458 _IN_OUT(alignMask, AllocHintAlignment.alignMask) \
459 _IN_OUT(alignOutputFlags[0], AllocHintAlignment.alignOutputFlags[0]) \
460 _IN_OUT(alignOutputFlags[1], AllocHintAlignment.alignOutputFlags[1]) \
461 _IN_OUT(alignOutputFlags[2], AllocHintAlignment.alignOutputFlags[2]) \
462 _IN_OUT(alignOutputFlags[3], AllocHintAlignment.alignOutputFlags[3]) \
463 _IN_OUT(alignBank[0], AllocHintAlignment.alignBank[0]) \
464 _IN_OUT(alignBank[1], AllocHintAlignment.alignBank[1]) \
465 _IN_OUT(alignBank[2], AllocHintAlignment.alignBank[2]) \
466 _IN_OUT(alignBank[3], AllocHintAlignment.alignBank[3]) \
467 _IN_OUT(alignKind, AllocHintAlignment.alignKind) \
468 _IN_OUT(alignAdjust, AllocHintAlignment.alignAdjust) \
469 _IN_OUT(alignAttr2, AllocHintAlignment.alignAttr2)
470
471 GET_MEMORY_ALIGNMENT_PARAMS(_COPY_IN, _COPY_IN);
472
473 // Param can be either a hSubdevice or hDevice, control is on subdevice
474 status = RmDeprecatedFindOrCreateSubDeviceHandle(pContext, pArgs->hRoot, pArgs->hObjectParent,
475 &hSubDevice, &bMustFreeSubDevice);
476 if (status != NV_OK)
477 return status;
478
479 status = pContext->RmControl(pContext, pArgs->hRoot, hSubDevice,
480 NV2080_CTRL_CMD_FB_GET_MEM_ALIGNMENT,
481 &allocParams,
482 sizeof(allocParams));
483
484
485 GET_MEMORY_ALIGNMENT_PARAMS(_NO_COPY, _COPY_OUT);
486
487 if (bMustFreeSubDevice)
488 {
489 pContext->RmFree(pContext, pArgs->hRoot, hSubDevice);
490 }
491
492 return status;
493 }
494
495 static NV_STATUS
_nvos32FunctionHwAlloc(DEPRECATED_CONTEXT * pContext,NVOS32_PARAMETERS * pArgs)496 _nvos32FunctionHwAlloc
497 (
498 DEPRECATED_CONTEXT *pContext,
499 NVOS32_PARAMETERS *pArgs
500 )
501 {
502 NV_MEMORY_HW_RESOURCES_ALLOCATION_PARAMS allocParams = {0};
503 NV_STATUS status = NV_OK;
504
505 #define ALLOC_HW_RESOURCES_PARAMS(_IN, _IN_OUT, _OUT) \
506 _IN (owner, HwAlloc.allocOwner) \
507 _IN_OUT(type, HwAlloc.allocType) \
508 _IN (attr, HwAlloc.allocAttr) \
509 _IN_OUT(flags, HwAlloc.allocInputFlags) \
510 _IN_OUT(size, HwAlloc.allocSize) \
511 _IN_OUT(height, HwAlloc.allocHeight) \
512 _IN_OUT(width, HwAlloc.allocWidth) \
513 _IN_OUT(pitch, HwAlloc.allocPitch) \
514 _IN_OUT(alignment, HwAlloc.allocMask) \
515 _IN_OUT(comprCovg, HwAlloc.allocComprCovg) \
516 _IN_OUT(zcullCovg, HwAlloc.allocZcullCovg) \
517 _IN_OUT(bindResultFunc, HwAlloc.bindResultFunc) \
518 _IN_OUT(pHandle, HwAlloc.pHandle) \
519 _OUT (attr, HwAlloc.retAttr) \
520 _IN_OUT(kind, HwAlloc.kind) \
521 _IN_OUT(osDeviceHandle, HwAlloc.osDeviceHandle) \
522 _IN (attr2, HwAlloc.allocAttr2) \
523 _OUT (attr2, HwAlloc.retAttr2) \
524 _IN_OUT(compPageShift, HwAlloc.comprInfo.compPageShift) \
525 _IN_OUT(compressedKind, HwAlloc.comprInfo.compressedKind) \
526 _IN_OUT(compTagLineMin, HwAlloc.comprInfo.compTagLineMin) \
527 _IN_OUT(compPageIndexLo, HwAlloc.comprInfo.compPageIndexLo) \
528 _IN_OUT(compPageIndexHi, HwAlloc.comprInfo.compPageIndexHi) \
529 _IN_OUT(compTagLineMultiplier, HwAlloc.comprInfo.compTagLineMultiplier) \
530 _IN_OUT(uncompressedKind, HwAlloc.uncompressedKind) \
531 _IN_OUT(allocAddr, HwAlloc.allocAddr)
532
533 if (0 == (pArgs->data.AllocOsDesc.flags & NVOS32_ALLOC_FLAGS_MEMORY_HANDLE_PROVIDED))
534 {
535 // RmAlloc will generate a handle when hMemory = 0
536 pArgs->data.HwAlloc.allochMemory = 0;
537 }
538
539 ALLOC_HW_RESOURCES_PARAMS(_COPY_IN, _COPY_IN, _NO_COPY);
540
541 status = pContext->RmAlloc(pContext,
542 pArgs->hRoot,
543 pArgs->hObjectParent,
544 &pArgs->data.HwAlloc.allochMemory,
545 NV01_MEMORY_HW_RESOURCES,
546 &allocParams,
547 sizeof(allocParams));
548
549 pArgs->data.HwAlloc.hResourceHandle = pArgs->data.HwAlloc.allochMemory;
550
551 ALLOC_HW_RESOURCES_PARAMS(_NO_COPY, _COPY_OUT,_COPY_OUT);
552
553 return status;
554 }
555
556 static NV_STATUS
_nvos32FunctionHwFree(DEPRECATED_CONTEXT * pContext,NVOS32_PARAMETERS * pArgs)557 _nvos32FunctionHwFree
558 (
559 DEPRECATED_CONTEXT *pContext,
560 NVOS32_PARAMETERS *pArgs
561 )
562 {
563 NvHandle hMemory = pArgs->data.HwFree.hResourceHandle;
564 NvHandle hClient = pArgs->hRoot;
565
566 return pContext->RmFree(pContext, hClient, hMemory);
567 }
568
569 static NV_STATUS
_nvos32FunctionAllocOsDesc(DEPRECATED_CONTEXT * pContext,NVOS32_PARAMETERS * pArgs)570 _nvos32FunctionAllocOsDesc
571 (
572 DEPRECATED_CONTEXT *pContext,
573 NVOS32_PARAMETERS *pArgs
574 )
575 {
576 NV_OS_DESC_MEMORY_ALLOCATION_PARAMS allocParams = {0};
577 NV_STATUS status = NV_OK;
578
579 allocParams.type = pArgs->data.AllocOsDesc.type;
580 allocParams.flags = pArgs->data.AllocOsDesc.flags;
581 allocParams.attr = pArgs->data.AllocOsDesc.attr;
582 allocParams.attr2 = pArgs->data.AllocOsDesc.attr2;
583 allocParams.descriptor = pArgs->data.AllocOsDesc.descriptor;
584 allocParams.limit = pArgs->data.AllocOsDesc.limit;
585 allocParams.descriptorType = pArgs->data.AllocOsDesc.descriptorType;
586
587 if (0 == (pArgs->data.AllocOsDesc.flags & NVOS32_ALLOC_FLAGS_MEMORY_HANDLE_PROVIDED))
588 {
589 // RmAlloc will generate a handle when hMemory = 0
590 pArgs->data.AllocOsDesc.hMemory = 0;
591 }
592
593 status = pContext->RmAlloc(pContext,
594 pArgs->hRoot,
595 pArgs->hObjectParent,
596 &pArgs->data.AllocOsDesc.hMemory,
597 NV01_MEMORY_SYSTEM_OS_DESCRIPTOR,
598 &allocParams,
599 sizeof(allocParams));
600
601 return status;
602 }
603