NVIDIA/open-gpu-kernel-modules
1
0
Fork 0
mirror of https://github.com/NVIDIA/open-gpu-kernel-modules.git synced 2026-02-05 07:39:57 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
54d69484da940413ba6017df9cf43bed8b75da46
open-gpu-kernel-modules/src/common/sdk/nvidia/inc/ctrl/ctrl2080/ctrl2080fb.h
Bernhard Stoeckner 54d69484da 570.86.15
2025-01-27 19:36:56 +01:00

2857 lines
121 KiB
C
Raw Blame History

/*
* SPDX-FileCopyrightText: Copyright (c) 2006-2024 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.
*/
#pragma once
#include <nvtypes.h>
//
// This file was generated with FINN, an NVIDIA coding tool.
// Source file: ctrl/ctrl2080/ctrl2080fb.finn
//
#include "ctrl/ctrl2080/ctrl2080base.h"
/* NV20_SUBDEVICE_XX fb control commands and parameters */
#include "nvlimits.h"
#include "nvcfg_sdk.h"
/*
* NV2080_CTRL_FB_INFO
*
* This structure represents a single 32bit fb engine value. Clients
* request a particular fb engine value by specifying a unique fb
* information index.
*
* Legal fb information index values are:
* NV2080_CTRL_FB_INFO_INDEX_TILE_REGION_COUNT
* This index is used to request the number of tiled regions supported
* by the associated subdevice. The return value is GPU
* implementation-dependent. A return value of 0 indicates the GPU
* does not support tiling.
* NV2080_CTRL_FB_INFO_INDEX_COMPRESSION_SIZE
* This index is used to request the amount of compression (in bytes)
* supported by the associated subdevice. The return value is GPU
* implementation-dependent. A return value of 0 indicates the GPU
* does not support compression.
* Nv2080_CTRL_FB_INFO_INDEX_DRAM_PAGE_STRIDE
* This index is used to request the DRAM page stride (in bytes)
* supported by the associated subdevice. The return value is GPU
* implementation-dependent.
* NV2080_CTRL_FB_INFO_INDEX_TILE_REGION_FREE_COUNT
* This index is used to request the number of free tiled regions on
* the associated subdevice. The return value represents the current
* number of free tiled regions at the time the command is processed and
* is not guaranteed to remain unchanged. A return value of 0 indicates
* that there are no available tiled regions on the associated subdevice.
* NV2080_CTRL_FB_INFO_INDEX_PARTITION_COUNT
* This index is used to request the number of frame buffer partitions
* on the associated subdevice. Starting with Fermi there are now two units
* with the name framebuffer partitions. On those chips this index returns
* the number of FBPAs. For number of FBPs use
* NV2080_CTRL_FB_INFO_INDEX_FBP_COUNT.
* This an SMC aware attribute, thus necessary partition subscription is
* required if the device is partitioned.
* NV2080_CTRL_FB_INFO_INDEX_RAM_SIZE
* This index is used to request the amount of framebuffer memory in
* kilobytes physically present on the associated subdevice. This
* value will never exceed the value reported by
* NV2080_CTRL_FB_INFO_INDEX_TOTAL_RAM_SIZE.
* This an SMC aware attribute, so the per-partition framebuffer memory
* size will be returned when the client has a partition subscription.
* NV2080_CTRL_FB_INFO_INDEX_TOTAL_RAM_SIZE
* This index is used to request the total amount of video memory in
* kilobytes for use with the associated subdevice. This value will
* reflect both framebuffer memory as well as any system memory dedicated
* for use with the subdevice.
* This an SMC aware attribute, so the per-partition video memory size
* will be returned when the client has a partition subscription.
* NV2080_CTRL_FB_INFO_INDEX_HEAP_SIZE
* This index is used to request the amount of total RAM in kilobytes
* available for user allocations. This value reflects the total ram
* size less the amount of memory reserved for internal use.
* This an SMC aware attribute, thus necessary partition subscription is
* required if the device is partitioned.
* NV2080_CTRL_FB_INFO_INDEX_HEAP_START
* This index is used to request the offset for start of heap in
* kilobytes.
* This an SMC aware attribute, thus necessary partition subscription is
* required if the device is partitioned.
* NV2080_CTRL_FB_INFO_INDEX_HEAP_FREE
* This index is used to request the available amount of video memory in
* kilobytes for use with the associated subdevice or the SMC partition.
* This an SMC aware attribute, thus necessary partition subscription is
* required to query per partition information, if the device is partitioned.
* Alternatively, the SMC/MIG monitor capability can be acquired to query
* aggregate available memory across all the valid partitions.
* NV2080_CTRL_FB_INFO_INDEX_MAPPABLE_HEAP_SIZE
* This index reflects the amount of heap memory in kilobytes that
* is accessible by the CPU. On subdevices with video memory sizes that
* exceed the amount that can be bus mappable this value will be less
* than that reported by NV2080_CTRL_FB_INFO_INDEX_HEAP_SIZE.
* This an SMC aware attribute, thus necessary partition subscription is
* required if the device is partitioned.
* NV2080_CTRL_FB_INFO_INDEX_BUS_WIDTH
* This index is used to request the FB bus bandwidth on the associated
* subdevice.
* NV2080_CTRL_FB_INFO_INDEX_RAM_CFG
* This index is used to request the implementation-dependent RAM
* configuration value of the associated subdevice.
* NV2080_CTRL_FB_INFO_INDEX_RAM_TYPE
* This index is used to request the type of RAM used for the framebuffer
* on the associated subdevice. Legal RAM types include:
* NV2080_CTRL_FB_INFO_RAM_TYPE_UNKNOWN
* NV2080_CTRL_FB_INFO_RAM_TYPE_SDRAM
* NV2080_CTRL_FB_INFO_RAM_TYPE_DDR1
* NV2080_CTRL_FB_INFO_RAM_TYPE_DDR2
* NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR2
* NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR3
* NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR4
* NV2080_CTRL_FB_INFO_RAM_TYPE_DDR3
* NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR5
* NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR5X
* NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR6
* NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR6X
* NV2080_CTRL_FB_INFO_RAM_TYPE_LPDDR2
* NV2080_CTRL_FB_INFO_RAM_TYPE_LPDDR4
* NV2080_CTRL_FB_INFO_RAM_TYPE_LPDDR5
* NV2080_CTRL_FB_INFO_INDEX_BANK_COUNT
* This index is used to request the number of FB banks on the associated
* subdevice.
* NV2080_CTRL_FB_INFO_INDEX_OVERLAY_OFFSET_ADJUSTMENT
* This index is used to request the offset relative to the start of the
* overlay surface(s), in bytes, at which scanout should happen if the
* primary and the overlay surfaces are all aligned on large page
* boundaries.
* NV2080_CTRL_FB_INFO_INDEX_GPU_VADDR_SPACE_SIZE_KB
* This index is used to request the size of the GPU's virtual address
* space in kilobytes.
* NV2080_CTRL_FB_INFO_INDEX_GPU_VADDR_HEAP_SIZE_KB
* This index is used to request the size of the GPU's virtual address
* space heap (minus RM-reserved space) in kilobytes.
* NV2080_CTRL_FB_INFO_INDEX_GPU_VADDR_MAPPBLE_SIZE_KB
* This index is used to request the size of the GPU's BAR1 mappable
* virtual address space in kilobytes.
* NV2080_CTRL_FB_INFO_INDEX_EFFECTIVE_BW
* This index is deprecated, and returns zero value.
* NV2080_CTRL_FB_INFO_INDEX_PARTITION_MASK
* NV2080_CTRL_FB_INFO_INDEX_PARTITION_MASK_0
* NV2080_CTRL_FB_INFO_INDEX_PARTITION_MASK_1
* This index is used to request the mask of currently active partitions.
* Each active partition has an ID that's equivalent to the corresponding
* bit position in the mask.
* This an SMC aware attribute, thus necessary partition subscription is
* required if the device is partitioned.
* This value is moving from 32bits to 64bits, so PARTITION_MASK
* (though kept for backwards compatibility on older chips), on newer chips
* will be replaced by:
* PARTITION_MASK_0 for the lower 32bits
* PARTITION_MASK_1 for the upper 32bits
* Note that PARTITION_MASK and PARTITION_MASK_0 are handled the same, and
* use the same enum value.
* NV2080_CTRL_FB_INFO_INDEX_LTC_MASK
* NV2080_CTRL_FB_INFO_INDEX_LTC_MASK_0
* NV2080_CTRL_FB_INFO_INDEX_LTC_MASK_1
* This index is used to request the mask of currently active LTCs.
* Each active LTC has an ID that's equivalent to the corresponding
* bit position in the mask.
* This an SMC aware attribute, thus necessary partition subscription is
* required if the device is partitioned.
* This value is moving from 32bits to 64bits, so LTC_MASK
* (though kept for backwards compatibility on older chips), on newer chips
* will be replaced by:
* LTC_MASK_0 for the lower 32bits
* LTC_MASK_1 for the upper 32bits
* Note that LTC_MASK and LTC_MASK_0 are handled the same, and
* use the same enum value.
* NV2080_CTRL_FB_INFO_INDEX_VISTA_RESERVED_HEAP_SIZE
* This index is used to request the amount of total RAM in kilobytes
* reserved for internal RM allocations on Vista. This will need to
* be subtracted from the total heap size to get the amount available to
* KMD.
* This an SMC aware attribute, thus necessary partition subscription is
* required if the device is partitioned.
* NV2080_CTRL_FB_INFO_INDEX_RAM_LOCATION
* This index is used to distinguish between different memory
* configurations.
* NV2080_CTRL_FB_INFO_INDEX_FB_IS_BROKEN
* This index is used to check if the FB is functional
* NV2080_CTRL_FB_INFO_INDEX_FBP_COUNT
* This index is used to get the number of FBPs on the subdevice. This
* field is not to be confused with
* NV2080_CTRL_FB_INFO_INDEX_PARTITION_COUNT (returns number of FBPAs).
* Starting with Fermi the term partition is an ambiguous term, both FBP
* and FBPA mean FB partitions. The FBPA is the low level DRAM controller,
* while a FBP is the aggregation of one or more FBPAs, L2, ROP, and some
* other units.
* This an SMC aware attribute, thus necessary partition subscription is
* required if the device is partitioned.
* NV2080_CTRL_FB_INFO_INDEX_L2CACHE_SIZE
* This index is used to get the size of the L2 cache in Bytes.
* A value of zero indicates that the L2 cache isn't supported on the
* associated subdevice.
* NV2080_CTRL_FB_INFO_INDEX_MEMORYINFO_VENDOR_ID
* This index is used to get the memory vendor ID information from
* the Memory Information Table in the VBIOS. Legal memory Vendor ID
* values include:
* NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_UNKNOWN
* NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_RESERVED
* NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_SAMSUNG
* NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_QIMONDA
* NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_ELPIDA
* NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_ETRON
* NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_NANYA
* NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_HYNIX
* NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_MOSEL
* NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_WINBOND
* NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_ESMT
* NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_MICRON
* NV2080_CTRL_FB_INFO_INDEX_BAR1_AVAIL_SIZE
* This index is used to request the amount of unused bar1 space. The
* data returned is a value in KB. It is not guaranteed to be entirely
* accurate since it is a snapshot at a particular time and can
* change quickly.
* NV2080_CTRL_FB_INFO_INDEX_BAR1_MAX_CONTIGUOUS_AVAIL_SIZE
* This index is used to request the amount of largest unused contiguous
* block in bar1 space. The data returned is a value in KB. It is not
* guaranteed to be entirely accurate since it is a snapshot at a particular
* time and can change quickly.
* NV2080_CTRL_FB_INFO_INDEX_USABLE_RAM_SIZE
* This index is used to request the amount of usable framebuffer memory in
* kilobytes physically present on the associated subdevice. This
* value will never exceed the value reported by
* NV2080_CTRL_FB_INFO_INDEX_TOTAL_RAM_SIZE.
* This an SMC aware attribute, thus necessary partition subscription is
* required if the device is partitioned.
* NV2080_CTRL_FB_INFO_INDEX_LTC_COUNT
* Returns the active LTC count across all active FBPs.
* This an SMC aware attribute, thus necessary partition subscription is
* required if the device is partitioned.
* NV2080_CTRL_FB_INFO_INDEX_LTS_COUNT
* Returns the active LTS count across all active LTCs.
* This an SMC aware attribute, thus necessary partition subscription is
* required if the device is partitioned.
* NV2080_CTRL_FB_INFO_INDEX_PSEUDO_CHANNEL_MODE
* This is used to identify if pseudo-channel mode is enabled for HBM
* NV2080_CTRL_FB_INFO_INDEX_SMOOTHDISP_RSVD_BAR1_SIZE
* This is used by WDDM-KMD to determine whether and how much RM reserved BAR1 for smooth transition
* NV2080_CTRL_FB_INFO_INDEX_HEAP_OFFLINE_SIZE
* Returns the total size of the all dynamically offlined pages in KiB
* NV2080_CTRL_FB_INFO_INDEX_1TO1_COMPTAG_ENABLED
* Returns true if 1to1 comptag is enabled
* NV2080_CTRL_FB_INFO_INDEX_SUSPEND_RESUME_RSVD_SIZE
* Returns the total size of the memory(FB) that will saved/restored during save/restore cycle
* NV2080_CTRL_FB_INFO_INDEX_ALLOW_PAGE_RETIREMENT
* Returns true if page retirement is allowed
* NV2080_CTRL_FB_INFO_POISON_FUSE_ENABLED
* Returns true if poison fuse is enabled
* NV2080_CTRL_FB_INFO_FBPA_ECC_ENABLED
* Returns true if ECC is enabled for FBPA
* NV2080_CTRL_FB_INFO_DYNAMIC_PAGE_OFFLINING_ENABLED
* Returns true if dynamic page blacklisting is enabled
* NV2080_CTRL_FB_INFO_INDEX_FORCED_BAR1_64KB_MAPPING_ENABLED
* Returns true if 64KB mapping on BAR1 is force-enabled
* NV2080_CTRL_FB_INFO_INDEX_P2P_MAILBOX_SIZE
* Returns the P2P mailbox size to be allocated by the client.
* Returns 0 if the P2P mailbox is allocated by RM.
* NV2080_CTRL_FB_INFO_INDEX_P2P_MAILBOX_ALIGNMENT_SIZE
* Returns the P2P mailbox alignment requirement.
* Returns 0 if the P2P mailbox is allocated by RM.
* NV2080_CTRL_FB_INFO_INDEX_P2P_MAILBOX_BAR1_MAX_OFFSET_64KB
* Returns the P2P mailbox max offset requirement.
* Returns 0 if the P2P mailbox is allocated by RM.
* NV2080_CTRL_FB_INFO_INDEX_PROTECTED_MEM_SIZE_TOTAL_KB
* Returns total protected memory when memory protection is enabled
* Returns 0 when memory protection is not enabled.
* NV2080_CTRL_FB_INFO_INDEX_PROTECTED_MEM_SIZE_FREE_KB
* Returns protected memory available for allocation when memory
* protection is enabled.
* Returns 0 when memory protection is not enabled.
* NV2080_CTRL_FB_INFO_INDEX_ECC_STATUS_SIZE
* Returns the ECC status size (corresponds to subpartitions or channels
* depending on architecture/memory type).
* NV2080_CTRL_FB_INFO_INDEX_IS_ZERO_FB
* Returns true if FB is not present on this chip
*/
typedef NVXXXX_CTRL_XXX_INFO NV2080_CTRL_FB_INFO;
/* valid fb info index values */
#define NV2080_CTRL_FB_INFO_INDEX_TILE_REGION_COUNT (0x00000000U) // Deprecated
#define NV2080_CTRL_FB_INFO_INDEX_COMPRESSION_SIZE (0x00000001U)
#define NV2080_CTRL_FB_INFO_INDEX_DRAM_PAGE_STRIDE (0x00000002U)
#define NV2080_CTRL_FB_INFO_INDEX_TILE_REGION_FREE_COUNT (0x00000003U)
#define NV2080_CTRL_FB_INFO_INDEX_PARTITION_COUNT (0x00000004U)
#define NV2080_CTRL_FB_INFO_INDEX_BAR1_SIZE (0x00000005U)
#define NV2080_CTRL_FB_INFO_INDEX_BANK_SWIZZLE_ALIGNMENT (0x00000006U)
#define NV2080_CTRL_FB_INFO_INDEX_RAM_SIZE (0x00000007U)
#define NV2080_CTRL_FB_INFO_INDEX_TOTAL_RAM_SIZE (0x00000008U)
#define NV2080_CTRL_FB_INFO_INDEX_HEAP_SIZE (0x00000009U)
#define NV2080_CTRL_FB_INFO_INDEX_MAPPABLE_HEAP_SIZE (0x0000000AU)
#define NV2080_CTRL_FB_INFO_INDEX_BUS_WIDTH (0x0000000BU)
#define NV2080_CTRL_FB_INFO_INDEX_RAM_CFG (0x0000000CU)
#define NV2080_CTRL_FB_INFO_INDEX_RAM_TYPE (0x0000000DU)
#define NV2080_CTRL_FB_INFO_INDEX_BANK_COUNT (0x0000000EU)
#define NV2080_CTRL_FB_INFO_INDEX_OVERLAY_OFFSET_ADJUSTMENT (0x0000000FU) // Deprecated (index reused to return 0)
#define NV2080_CTRL_FB_INFO_INDEX_GPU_VADDR_SPACE_SIZE_KB (0x0000000FU) // Deprecated (index reused to return 0)
#define NV2080_CTRL_FB_INFO_INDEX_GPU_VADDR_HEAP_SIZE_KB (0x0000000FU) // Deprecated (index reused to return 0)
#define NV2080_CTRL_FB_INFO_INDEX_GPU_VADDR_MAPPBLE_SIZE_KB (0x0000000FU) // Deprecated (index reused to return 0)
#define NV2080_CTRL_FB_INFO_INDEX_EFFECTIVE_BW (0x0000000FU) // Deprecated (index reused to return 0)
#define NV2080_CTRL_FB_INFO_INDEX_FB_TAX_SIZE_KB (0x00000010U)
#define NV2080_CTRL_FB_INFO_INDEX_HEAP_BASE_KB (0x00000011U)
#define NV2080_CTRL_FB_INFO_INDEX_LARGEST_FREE_REGION_SIZE_KB (0x00000012U)
#define NV2080_CTRL_FB_INFO_INDEX_LARGEST_FREE_REGION_BASE_KB (0x00000013U)
#define NV2080_CTRL_FB_INFO_INDEX_PARTITION_MASK (0x00000014U)
#define NV2080_CTRL_FB_INFO_INDEX_VISTA_RESERVED_HEAP_SIZE (0x00000015U)
#define NV2080_CTRL_FB_INFO_INDEX_HEAP_FREE (0x00000016U)
#define NV2080_CTRL_FB_INFO_INDEX_RAM_LOCATION (0x00000017U)
#define NV2080_CTRL_FB_INFO_INDEX_FB_IS_BROKEN (0x00000018U)
#define NV2080_CTRL_FB_INFO_INDEX_FBP_COUNT (0x00000019U)
#define NV2080_CTRL_FB_INFO_INDEX_FBP_MASK (0x0000001AU)
#define NV2080_CTRL_FB_INFO_INDEX_L2CACHE_SIZE (0x0000001BU)
#define NV2080_CTRL_FB_INFO_INDEX_MEMORYINFO_VENDOR_ID (0x0000001CU)
#define NV2080_CTRL_FB_INFO_INDEX_BAR1_AVAIL_SIZE (0x0000001DU)
#define NV2080_CTRL_FB_INFO_INDEX_HEAP_START (0x0000001EU)
#define NV2080_CTRL_FB_INFO_INDEX_BAR1_MAX_CONTIGUOUS_AVAIL_SIZE (0x0000001FU)
#define NV2080_CTRL_FB_INFO_INDEX_USABLE_RAM_SIZE (0x00000020U)
#define NV2080_CTRL_FB_INFO_INDEX_TRAINIG_2T (0x00000021U)
#define NV2080_CTRL_FB_INFO_INDEX_LTC_COUNT (0x00000022U)
#define NV2080_CTRL_FB_INFO_INDEX_LTS_COUNT (0x00000023U)
#define NV2080_CTRL_FB_INFO_INDEX_L2CACHE_ONLY_MODE (0x00000024U)
#define NV2080_CTRL_FB_INFO_INDEX_PSEUDO_CHANNEL_MODE (0x00000025U)
#define NV2080_CTRL_FB_INFO_INDEX_SMOOTHDISP_RSVD_BAR1_SIZE (0x00000026U)
#define NV2080_CTRL_FB_INFO_INDEX_HEAP_OFFLINE_SIZE (0x00000027U)
#define NV2080_CTRL_FB_INFO_INDEX_1TO1_COMPTAG_ENABLED (0x00000028U)
#define NV2080_CTRL_FB_INFO_INDEX_SUSPEND_RESUME_RSVD_SIZE (0x00000029U)
#define NV2080_CTRL_FB_INFO_INDEX_ALLOW_PAGE_RETIREMENT (0x0000002AU)
#define NV2080_CTRL_FB_INFO_INDEX_LTC_MASK (0x0000002BU)
#define NV2080_CTRL_FB_INFO_POISON_FUSE_ENABLED (0x0000002CU)
#define NV2080_CTRL_FB_INFO_FBPA_ECC_ENABLED (0x0000002DU)
#define NV2080_CTRL_FB_INFO_DYNAMIC_PAGE_OFFLINING_ENABLED (0x0000002EU)
#define NV2080_CTRL_FB_INFO_INDEX_FORCED_BAR1_64KB_MAPPING_ENABLED (0x0000002FU)
#define NV2080_CTRL_FB_INFO_INDEX_P2P_MAILBOX_SIZE (0x00000030U)
#define NV2080_CTRL_FB_INFO_INDEX_P2P_MAILBOX_ALIGNMENT (0x00000031U)
#define NV2080_CTRL_FB_INFO_INDEX_P2P_MAILBOX_BAR1_MAX_OFFSET_64KB (0x00000032U)
#define NV2080_CTRL_FB_INFO_INDEX_PROTECTED_MEM_SIZE_TOTAL_KB (0x00000033U)
#define NV2080_CTRL_FB_INFO_INDEX_PROTECTED_MEM_SIZE_FREE_KB (0x00000034U)
#define NV2080_CTRL_FB_INFO_INDEX_ECC_STATUS_SIZE (0x00000035U)
#define NV2080_CTRL_FB_INFO_INDEX_IS_ZERO_FB (0x00000036U)
#define NV2080_CTRL_FB_INFO_INDEX_PARTITION_MASK_0 (NV2080_CTRL_FB_INFO_INDEX_PARTITION_MASK)
#define NV2080_CTRL_FB_INFO_INDEX_PARTITION_MASK_1 (0x00000037U)
#define NV2080_CTRL_FB_INFO_INDEX_LTC_MASK_0 (NV2080_CTRL_FB_INFO_INDEX_LTC_MASK)
#define NV2080_CTRL_FB_INFO_INDEX_LTC_MASK_1 (0x00000038U)
#define NV2080_CTRL_FB_INFO_MAX_LIST_SIZE (0x00000039U)
#define NV2080_CTRL_FB_INFO_INDEX_MAX (0x38U) /* finn: Evaluated from "(NV2080_CTRL_FB_INFO_MAX_LIST_SIZE - 1)" */
/* valid fb RAM type values */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_UNKNOWN (0x00000000U)
#define NV2080_CTRL_FB_INFO_RAM_TYPE_SDRAM (0x00000001U)
#define NV2080_CTRL_FB_INFO_RAM_TYPE_DDR1 (0x00000002U) /* SDDR and GDDR (aka DDR1 and GDDR1) */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_SDDR2 (0x00000003U) /* SDDR2 Used on NV43 and later */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_DDR2 NV2080_CTRL_FB_INFO_RAM_TYPE_SDDR2 /* Deprecated alias */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR2 (0x00000004U) /* GDDR2 Used on NV30 and some NV36 */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR3 (0x00000005U) /* GDDR3 Used on NV40 and later */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR4 (0x00000006U) /* GDDR4 Used on G80 and later (deprecated) */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_SDDR3 (0x00000007U) /* SDDR3 Used on G9x and later */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_DDR3 NV2080_CTRL_FB_INFO_RAM_TYPE_SDDR3 /* Deprecated alias */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR5 (0x00000008U) /* GDDR5 Used on GT21x and later */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_LPDDR2 (0x00000009U) /* LPDDR (Low Power SDDR) used on T2x and later. */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_SDDR4 (0x0000000CU) /* SDDR4 Used on Maxwell and later */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_LPDDR4 (0x0000000DU) /* LPDDR (Low Power SDDR) used on T21x and later.*/
#define NV2080_CTRL_FB_INFO_RAM_TYPE_HBM1 (0x0000000EU) /* HBM1 (High Bandwidth Memory) used on GP100 */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_HBM2 (0x0000000FU) /* HBM2 (High Bandwidth Memory-pseudo channel) */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR5X (0x00000010U) /* GDDR5X Used on GP10x */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR6 (0x00000011U) /* GDDR6 Used on TU10x */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR6X (0x00000012U) /* GDDR6X Used on GA10x */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_LPDDR5 (0x00000013U) /* LPDDR (Low Power SDDR) used on T23x and later.*/
#define NV2080_CTRL_FB_INFO_RAM_TYPE_HBM3 (0x00000014U) /* HBM3 (High Bandwidth Memory) v3 */
#define NV2080_CTRL_FB_INFO_RAM_TYPE_GDDR7 (0x00000015U) /* GDDR7 */
/* valid RAM LOCATION types */
#define NV2080_CTRL_FB_INFO_RAM_LOCATION_GPU_DEDICATED (0x00000000U)
#define NV2080_CTRL_FB_INFO_RAM_LOCATION_SYS_SHARED (0x00000001U)
#define NV2080_CTRL_FB_INFO_RAM_LOCATION_SYS_DEDICATED (0x00000002U)
/* valid Memory Vendor ID values */
#define NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_SAMSUNG (0x00000001U)
#define NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_QIMONDA (0x00000002U)
#define NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_ELPIDA (0x00000003U)
#define NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_ETRON (0x00000004U)
#define NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_NANYA (0x00000005U)
#define NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_HYNIX (0x00000006U)
#define NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_MOSEL (0x00000007U)
#define NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_WINBOND (0x00000008U)
#define NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_ESMT (0x00000009U)
#define NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_MICRON (0x0000000FU)
#define NV2080_CTRL_FB_INFO_MEMORYINFO_VENDOR_ID_UNKNOWN (0xFFFFFFFFU)
#define NV2080_CTRL_FB_INFO_PSEUDO_CHANNEL_MODE_UNSUPPORTED (0x00000000U)
#define NV2080_CTRL_FB_INFO_PSEUDO_CHANNEL_MODE_DISABLED (0x00000001U)
#define NV2080_CTRL_FB_INFO_PSEUDO_CHANNEL_MODE_ENABLED (0x00000002U)
/**
* NV2080_CTRL_CMD_FB_GET_INFO
*
* This command returns fb engine information for the associated GPU.
* Requests to retrieve fb information use a list of one or more
* NV2080_CTRL_FB_INFO structures.
*
* fbInfoListSize
* This field specifies the number of entries on the caller's
* fbInfoList.
* fbInfoList
* This field specifies a pointer in the caller's address space
* to the buffer into which the fb information is to be returned.
* This buffer must be at least as big as fbInfoListSize multiplied
* by the size of the NV2080_CTRL_FB_INFO structure.
*
* Possible status values returned are:
* NV_OK
* NV_ERR_INVALID_PARAM_STRUCT
* NV_ERR_INVALID_ARGUMENT
* NV_ERR_OPERATING_SYSTEM
*/
#define NV2080_CTRL_CMD_FB_GET_INFO (0x20801301U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_INFO_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_GET_INFO_PARAMS_MESSAGE_ID (0x1U)
typedef struct NV2080_CTRL_FB_GET_INFO_PARAMS {
NvU32 fbInfoListSize;
NV_DECLARE_ALIGNED(NvP64 fbInfoList, 8);
} NV2080_CTRL_FB_GET_INFO_PARAMS;
#define NV2080_CTRL_CMD_FB_GET_INFO_V2 (0x20801303U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_INFO_V2_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_GET_INFO_V2_PARAMS_MESSAGE_ID (0x3U)
typedef struct NV2080_CTRL_FB_GET_INFO_V2_PARAMS {
NvU32 fbInfoListSize;
NV2080_CTRL_FB_INFO fbInfoList[NV2080_CTRL_FB_INFO_MAX_LIST_SIZE];
} NV2080_CTRL_FB_GET_INFO_V2_PARAMS;
/*
* NV2080_CTRL_CMD_FB_GET_BAR1_OFFSET
*
* This command returns the GPU virtual address of a bar1
* allocation, given the CPU virtual address.
*
* cpuVirtAddress
* This field specifies the associated CPU virtual address of the
* memory allocation.
* gpuVirtAddress
* The GPU virtual address associated with the allocation
* is returned in this field.
*
* Possible status values returned are
* NV_OK
* NV_ERR_INVALID_PARAM_STRUCT
* NV_ERR_NOT_SUPPORTED
* NV_ERR_INVALID_ARGUMENT
*/
#define NV2080_CTRL_CMD_FB_GET_BAR1_OFFSET (0x20801310U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_BAR1_OFFSET_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_GET_BAR1_OFFSET_PARAMS_MESSAGE_ID (0x10U)
typedef struct NV2080_CTRL_FB_GET_BAR1_OFFSET_PARAMS {
NV_DECLARE_ALIGNED(NvP64 cpuVirtAddress, 8);
NV_DECLARE_ALIGNED(NvU64 gpuVirtAddress, 8);
} NV2080_CTRL_FB_GET_BAR1_OFFSET_PARAMS;
/*
* NV2080_CTRL_FB_CMD_GET_CALIBRATION_LOCK_FAILED
*
* This command returns the failure counts for calibration.
*
* uFlags
* Just one for now -- ehether to reset the counts.
* driveStrengthRiseCount
* This parameter specifies the failure count for drive strength rising.
* driveStrengthFallCount
* This parameter specifies the failure count for drive strength falling.
* driveStrengthTermCount
* This parameter specifies the failure count for drive strength
* termination.
* slewStrengthRiseCount
* This parameter specifies the failure count for slew strength rising.
* slewStrengthFallCount
* This parameter specifies the failure count for slew strength falling.
* slewStrengthTermCount
* This parameter specifies the failure count for slew strength
* termination.
*
* Possible status values returned are:
* NV_OK
* NVOS_STATUS_INVALID_PARAM_STRUCT
* NVOS_STATUS_NOT_SUPPORTED
* NV_ERR_INVALID_ARGUMENT
*/
#define NV2080_CTRL_CMD_FB_GET_CALIBRATION_LOCK_FAILED (0x2080130cU) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_CALIBRATION_LOCK_FAILED_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_GET_CALIBRATION_LOCK_FAILED_PARAMS_MESSAGE_ID (0xCU)
typedef struct NV2080_CTRL_FB_GET_CALIBRATION_LOCK_FAILED_PARAMS {
NvU32 flags;
NvU32 driveStrengthRiseCount;
NvU32 driveStrengthFallCount;
NvU32 driveStrengthTermCount;
NvU32 slewStrengthRiseCount;
NvU32 slewStrengthFallCount;
} NV2080_CTRL_FB_GET_CALIBRATION_LOCK_FAILED_PARAMS;
/* valid flags parameter values */
#define NV2080_CTRL_CMD_FB_GET_CAL_FLAG_NONE (0x00000000U)
#define NV2080_CTRL_CMD_FB_GET_CAL_FLAG_RESET (0x00000001U)
/*
* NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL
*
* If supported by hardware and the OS, this command implements a streamlined version of
* NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE which can be called at high IRQL and Bypass the
* RM Lock.
*
* Requires the following NVOS54_PARAMETERS to be set for raised IRQ / Lock Bypass operation:
* NVOS54_FLAGS_IRQL_RAISED
* NVOS54_FLAGS_LOCK_BYPASS
*
* flags
* Contains flags to control various aspects of the flush. Valid values
* are defined in NV2080_CTRL_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL_FLAGS*.
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
* NV_ERR_INVALID_STATE
* NV_ERR_INVALID_ARGUMENT
*
* See Also:
* NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE
* This is the more generalized version which is not intended to be called at raised IRQ level
* NV0080_CTRL_CMD_DMA_FLUSH
* Performs flush operations in broadcast for the GPU cache and other hardware
* engines. Use this call if you want to flush all GPU caches in a
* broadcast device.
* NV0041_CTRL_CMD_SURFACE_FLUSH_GPU_CACHE
* Flushes memory associated with a single allocation if the hardware
* supports it. Use this call if you want to flush a single allocation and
* you have a memory object describing the physical memory.
*/
#define NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL (0x2080130dU) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL_PARAMS_MESSAGE_ID (0xDU)
typedef struct NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL_PARAMS {
NvU32 flags;
} NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL_PARAMS;
/* valid fields and values for flags */
#define NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL_FLAGS_WRITE_BACK 0:0
#define NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL_FLAGS_WRITE_BACK_NO (0x00000000U)
#define NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL_FLAGS_WRITE_BACK_YES (0x00000001U)
#define NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL_FLAGS_INVALIDATE 1:1
#define NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL_FLAGS_INVALIDATE_NO (0x00000000U)
#define NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL_FLAGS_INVALIDATE_YES (0x00000001U)
#define NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL_FLAGS_FB_FLUSH 2:2
#define NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL_FLAGS_FB_FLUSH_NO (0x00000000U)
#define NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE_IRQL_FLAGS_FB_FLUSH_YES (0x00000001U)
/*
* NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE
*
* This command flushes a cache on the GPU which all memory accesses go
* through. The types of flushes supported by this API may not be supported by
* all hardware. Attempting an unsupported flush type will result in an error.
*
* addressArray
* An array of physical addresses in the aperture defined by
* NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_APERTURE. Each entry points to a
* contiguous block of memory of size memBlockSizeBytes. The addresses are
* aligned down to addressAlign before coalescing adjacent addresses and
* sending flushes to hardware.
* addressAlign
* Used to align-down addresses held in addressArray. A value of 0 will be
* forced to 1 to avoid a divide by zero. Value is treated as minimum
* alignment and any hardware alignment requirements above this value will
* be honored.
* addressArraySize
* The number of entries in addressArray.
* memBlockSizeBytes
* The size in bytes of each memory block pointed to by addressArray.
* flags
* Contains flags to control various aspects of the flush. Valid values
* are defined in NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS*. Not all flags are
* valid for all defined FLUSH_MODEs or all GPUs.
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
* NV_ERR_INVALID_STATE
* NV_ERR_INVALID_ARGUMENT
*
* See Also:
* NV0080_CTRL_CMD_DMA_FLUSH
* Performs flush operations in broadcast for the GPU cache and other hardware
* engines. Use this call if you want to flush all GPU caches in a
* broadcast device.
* NV0041_CTRL_CMD_SURFACE_FLUSH_GPU_CACHE
* Flushes memory associated with a single allocation if the hardware
* supports it. Use this call if you want to flush a single allocation and
* you have a memory object describing the physical memory.
*/
#define NV2080_CTRL_CMD_FB_FLUSH_GPU_CACHE (0x2080130eU) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_FLUSH_GPU_CACHE_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_MAX_ADDRESSES 500U
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_PARAMS_MESSAGE_ID (0xEU)
typedef struct NV2080_CTRL_FB_FLUSH_GPU_CACHE_PARAMS {
NV_DECLARE_ALIGNED(NvU64 addressArray[NV2080_CTRL_FB_FLUSH_GPU_CACHE_MAX_ADDRESSES], 8);
NvU32 addressArraySize;
NvU32 addressAlign;
NV_DECLARE_ALIGNED(NvU64 memBlockSizeBytes, 8);
NvU32 flags;
} NV2080_CTRL_FB_FLUSH_GPU_CACHE_PARAMS;
/* valid fields and values for flags */
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_APERTURE 1:0
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_APERTURE_VIDEO_MEMORY (0x00000000U)
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_APERTURE_SYSTEM_MEMORY (0x00000001U)
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_APERTURE_PEER_MEMORY (0x00000002U)
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_WRITE_BACK 2:2
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_WRITE_BACK_NO (0x00000000U)
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_WRITE_BACK_YES (0x00000001U)
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_INVALIDATE 3:3
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_INVALIDATE_NO (0x00000000U)
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_INVALIDATE_YES (0x00000001U)
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_FLUSH_MODE 4:4
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_FLUSH_MODE_ADDRESS_ARRAY (0x00000000U)
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_FLUSH_MODE_FULL_CACHE (0x00000001U)
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_FB_FLUSH 5:5
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_FB_FLUSH_NO (0x00000000U)
#define NV2080_CTRL_FB_FLUSH_GPU_CACHE_FLAGS_FB_FLUSH_YES (0x00000001U)
/*
* NV2080_CTRL_CMD_FB_IS_KIND
*
* This command is used to perform various operations like 'IS_KIND_VALID',
* 'IS_KIND_COMPRESSIBLE'on the kind passed by the caller. The operation to be
* performed should be passed in the 'operation' parameter of
* NV2080_CTRL_FB_IS_KIND_PARAMS, the kind on which the operation is to be
* performed should be passed in the 'kind' parameter. The result of the
* operation (true/false) will be returned in the 'result' parameter.
*
* operation
* Specifies what operation is to be performed on the kind passed by the
* caller. The supported operations are
* NV2080_CTRL_FB_IS_KIND_OPERATION_SUPPORTED
* This operation checks whether the kind passed in the 'kind'
* parameter of the 'NV2080_CTRL_FB_IS_KIND_PARAMS' structure is
* supported for this GPU. Returns nonzero value in 'result' parameter
* if the input kind is supported, else returns zero in the result.
* NV2080_CTRL_FB_IS_KIND_OPERATION_COMPRESSIBLE
* This operation checks whether the kind passed in the 'kind'
* parameter of the 'NV2080_CTRL_FB_IS_KIND_PARAMS' structure is
* compressible. Returns nonzero value in 'result' parameter if the
* input kind is compressible, else returns zero in the result.
* NV2080_CTRL_FB_IS_KIND_OPERATION_COMPRESSIBLE_1
* This operation checks whether the kind passed in the 'kind'
* parameter of the 'NV2080_CTRL_FB_IS_KIND_PARAMS' structure supports
* 1 bit compression. Returns nonzero value in 'result' parameter if
* kind supports 1 bit compression, else returns zero in the result.
* NV2080_CTRL_FB_IS_KIND_OPERATION_COMPRESSIBLE_2
* This operation checks whether the kind passed in the 'kind'
* parameter of the 'NV2080_CTRL_FB_IS_KIND_PARAMS' structure supports
* 2 bit compression. Returns nonzero value in 'result' parameter if
* kind supports 1 bit compression, else returns zero in the result.
* NV2080_CTRL_FB_IS_KIND_OPERATION_COMPRESSIBLE_4
* This operation checks whether the kind passed in the 'kind'
* parameter of the 'NV2080_CTRL_FB_IS_KIND_PARAMS' structure supports
* 4 bit compression. Returns nonzero value in 'result' parameter if
* kind supports 4 bit compression, else returns zero in the result.
* NV2080_CTRL_FB_IS_KIND_OPERATION_ZBC
* This operation checks whether the kind passed in the 'kind'
* parameter of the 'NV2080_CTRL_FB_IS_KIND_PARAMS' structure
* supports ZBC. Returns nonzero value in 'result' parameter if the
* input kind supports ZBC, else returns zero in the result.
* NV2080_CTRL_FB_IS_KIND_OPERATION_ZBC_ALLOWS_1
* This operation checks whether the kind passed in the 'kind'
* parameter of the 'NV2080_CTRL_FB_IS_KIND_PARAMS' structure
* supports 1 bit ZBC. Returns nonzero value in 'result' parameter if
* the input kind supports 1 bit ZBC, else returns zero in the result.
* NV2080_CTRL_FB_IS_KIND_OPERATION_ZBC_ALLOWS_2
* This operation checks whether the kind passed in the 'kind'
* parameter of the 'NV2080_CTRL_FB_IS_KIND_PARAMS' structure
* supports 2 bit ZBC. Returns nonzero value in 'result' parameter if
* the input kind supports 2 bit ZBC, else returns zero in the result.
* NV2080_CTRL_FB_IS_KIND_OPERATION_ZBC_ALLOWS_4
* This operation checks whether the kind passed in the 'kind'
* parameter of the 'NV2080_CTRL_FB_IS_KIND_PARAMS' structure
* supports 4 bit ZBC. Returns nonzero value in 'result' parameter if
* the input kind supports 4 bit ZBC, else returns zero in the result.
* kind
* Specifies the kind on which the operation is to be carried out. The
* legal range of values for the kind parameter is different on different
* GPUs. For e.g. on Fermi, valid range is 0x00 to 0xfe. Still, some values
* inside this legal range can be invalid i.e. not defined.
* So its always better to first check if a particular kind is supported on
* the current GPU with 'NV2080_CTRL_FB_IS_KIND_SUPPORTED' operation.
* result
* Upon return, this parameter will hold the result (true/false) of the
* operation performed on the kind.
*
* Possible status values returned are:
* NV_OK
* NV_ERR_INVALID_ARGUMENT
*/
#define NV2080_CTRL_CMD_FB_IS_KIND (0x20801313U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_IS_KIND_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_IS_KIND_PARAMS_MESSAGE_ID (0x13U)
typedef struct NV2080_CTRL_FB_IS_KIND_PARAMS {
NvU32 operation;
NvU32 kind;
NvBool result;
} NV2080_CTRL_FB_IS_KIND_PARAMS;
/* valid values for operation */
#define NV2080_CTRL_FB_IS_KIND_OPERATION_SUPPORTED (0x00000000U)
#define NV2080_CTRL_FB_IS_KIND_OPERATION_COMPRESSIBLE (0x00000001U)
#define NV2080_CTRL_FB_IS_KIND_OPERATION_COMPRESSIBLE_1 (0x00000002U)
#define NV2080_CTRL_FB_IS_KIND_OPERATION_COMPRESSIBLE_2 (0x00000003U)
#define NV2080_CTRL_FB_IS_KIND_OPERATION_COMPRESSIBLE_4 (0x00000004U)
#define NV2080_CTRL_FB_IS_KIND_OPERATION_ZBC (0x00000005U)
#define NV2080_CTRL_FB_IS_KIND_OPERATION_ZBC_ALLOWS_1 (0x00000006U)
#define NV2080_CTRL_FB_IS_KIND_OPERATION_ZBC_ALLOWS_2 (0x00000007U)
#define NV2080_CTRL_FB_IS_KIND_OPERATION_ZBC_ALLOWS_4 (0x00000008U)
/**
* NV2080_CTRL_CMD_FB_GET_GPU_CACHE_INFO
*
* This command returns the state of a cache which all GPU memory accesess go
* through.
*
* powerState
* Returns the power state of the cache. Possible values are defined in
* NV2080_CTRL_FB_GET_GPU_CACHE_INFO_POWER_STATE.
*
* writeMode
* Returns the write mode of the cache. Possible values are defined in
* NV2080_CTRL_FB_GET_GPU_CACHE_INFO_WRITE_MODE.
*
* bypassMode
* Returns the bypass mode of the L2 cache. Possible values are defined in
* NV2080_CTRL_FB_GET_GPU_CACHE_INFO_BYPASS_MODE.
*
* rcmState
* Returns the RCM state of the cache. Possible values are defined in
* NV2080_CTRL_FB_GET_GPU_CACHE_INFO_RCM_STATE.
*
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
* NV_ERR_INVALID_STATE
* NV_ERR_INVALID_ARGUMENT
*/
#define NV2080_CTRL_CMD_FB_GET_GPU_CACHE_INFO (0x20801315U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_GPU_CACHE_INFO_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_GET_GPU_CACHE_INFO_PARAMS_MESSAGE_ID (0x15U)
typedef struct NV2080_CTRL_FB_GET_GPU_CACHE_INFO_PARAMS {
NvU32 powerState;
NvU32 writeMode;
NvU32 bypassMode;
NvU32 rcmState;
} NV2080_CTRL_FB_GET_GPU_CACHE_INFO_PARAMS;
/* valid values for powerState */
#define NV2080_CTRL_FB_GET_GPU_CACHE_INFO_POWER_STATE_ENABLED (0x00000000U)
#define NV2080_CTRL_FB_GET_GPU_CACHE_INFO_POWER_STATE_DISABLED (0x00000001U)
/* valid values for writeMode */
#define NV2080_CTRL_FB_GET_GPU_CACHE_INFO_WRITE_MODE_WRITETHROUGH (0x00000000U)
#define NV2080_CTRL_FB_GET_GPU_CACHE_INFO_WRITE_MODE_WRITEBACK (0x00000001U)
/* valid values for bypassMode */
#define NV2080_CTRL_FB_GET_GPU_CACHE_INFO_BYPASS_MODE_DISABLED (0x00000000U)
#define NV2080_CTRL_FB_GET_GPU_CACHE_INFO_BYPASS_MODE_ENABLED (0x00000001U)
/* valid values for rcmState */
#define NV2080_CTRL_FB_GET_GPU_CACHE_INFO_RCM_STATE_FULL (0x00000000U)
#define NV2080_CTRL_FB_GET_GPU_CACHE_INFO_RCM_STATE_TRANSITIONING (0x00000001U)
#define NV2080_CTRL_FB_GET_GPU_CACHE_INFO_RCM_STATE_REDUCED (0x00000002U)
#define NV2080_CTRL_FB_GET_GPU_CACHE_INFO_RCM_STATE_ZERO_CACHE (0x00000003U)
/*
* NV2080_CTRL_FB_CMD_GET_FB_REGION_INFO
*
* This command returns the FB memory region characteristics.
*
* numFBRegions
* Number of valid regions returned in fbRegion[]
* fbRegion[].base
* Base address of region. The first valid address in the range
* [base..limit].
* fbRegion[].limit
* Last/end address of region. The last valid address in the range
* [base..limit].
* (limit - base + 1) = size of the region
* fbRegion[].reserved
* Amount of memory that RM speculatively needs within the region. A
* client doing its own memory management should leave at least this much
* memory available for RM use. This particularly applies to a driver
* model like LDDM.
* fbRegion[].performance
* Relative performance of this region compared to other regions.
* The definition is vague, and only connotes relative bandwidth or
* performance. The higher the value, the higher the performance.
* fbRegion[].supportCompressed
* TRUE if compressed surfaces/kinds are supported
* FALSE if compressed surfaces/kinds are not allowed to be allocated in
* this region
* fbRegion[].supportISO
* TRUE if ISO surfaces/kinds are supported (Display, cursor, video)
* FALSE if ISO surfaces/kinds are not allowed to be allocated in this
* region
* fbRegion[].bProtected
* TRUE if this region is a protected memory region. If true only
* allocations marked as protected (NVOS32_ALLOC_FLAGS_PROTECTED) can be
* allocated in this region.
* fbRegion[].blackList[] - DEPRECATED: Use supportISO
* TRUE for each NVOS32_TYPE_IMAGE* that is NOT allowed in this region.
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_GET_FB_REGION_INFO (0x20801320U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_CMD_FB_GET_FB_REGION_INFO_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_CMD_FB_GET_FB_REGION_INFO_MEM_TYPES 17U
typedef NvBool NV2080_CTRL_CMD_FB_GET_FB_REGION_SURFACE_MEM_TYPE_FLAG[NV2080_CTRL_CMD_FB_GET_FB_REGION_INFO_MEM_TYPES];
typedef struct NV2080_CTRL_CMD_FB_GET_FB_REGION_FB_REGION_INFO {
NV_DECLARE_ALIGNED(NvU64 base, 8);
NV_DECLARE_ALIGNED(NvU64 limit, 8);
NV_DECLARE_ALIGNED(NvU64 reserved, 8);
NvU32 performance;
NvBool supportCompressed;
NvBool supportISO;
NvBool bProtected;
NV2080_CTRL_CMD_FB_GET_FB_REGION_SURFACE_MEM_TYPE_FLAG blackList;
} NV2080_CTRL_CMD_FB_GET_FB_REGION_FB_REGION_INFO;
#define NV2080_CTRL_CMD_FB_GET_FB_REGION_INFO_MAX_ENTRIES 16U
#define NV2080_CTRL_CMD_FB_GET_FB_REGION_INFO_PARAMS_MESSAGE_ID (0x20U)
typedef struct NV2080_CTRL_CMD_FB_GET_FB_REGION_INFO_PARAMS {
NvU32 numFBRegions;
NV_DECLARE_ALIGNED(NV2080_CTRL_CMD_FB_GET_FB_REGION_FB_REGION_INFO fbRegion[NV2080_CTRL_CMD_FB_GET_FB_REGION_INFO_MAX_ENTRIES], 8);
} NV2080_CTRL_CMD_FB_GET_FB_REGION_INFO_PARAMS;
/*
* NV2080_CTRL_CMD_FB_OFFLINE_PAGES
*
* This command adds video memory page addresses to the list of offlined
* addresses so that they're not allocated to any client. The newly offlined
* addresses take effect after a reboot.
*
* offlined
* This input parameter is an array of NV2080_CTRL_FB_OFFLINED_ADDRESS_INFO
* structures, containing the video memory physical page numbers that
* are to be blacklisted. This array can hold a maximum of NV2080_CTRL_FB_
* BLACKLIST_PAGES_MAX_PAGES address pairs. Valid entries are adjacent.
* pageSize
* This input parameter contains the size of the page that is to be
* blacklisted.
* validEntries
* This input parameter specifies the number of valid entries in the
* offlined array.
* numPagesAdded
* This output parameter specifies how many of the validEntries were
* actually offlined. If numPagesAdded < validEntries, it
* means that only addresses from offlined[0] to offlined[numPagesAdded - 1]
* were added to the list of offlined addresses.
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
* NV_ERR_INVALID_ARGUMENT
*/
#define NV2080_CTRL_CMD_FB_OFFLINE_PAGES (0x20801321U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_OFFLINE_PAGES_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_OFFLINED_PAGES_MAX_PAGES (0x00000040U)
#define NV2080_CTRL_FB_OFFLINED_PAGES_INVALID_ADDRESS (0xffffffffffffffffULL)
#define NV2080_CTRL_FB_OFFLINED_PAGES_PAGE_SIZE_4K (0x00000000U)
#define NV2080_CTRL_FB_OFFLINED_PAGES_PAGE_SIZE_64K (0x00000001U)
#define NV2080_CTRL_FB_OFFLINED_PAGES_PAGE_SIZE_128K (0x00000002U)
/*
* NV2080_CTRL_FB_OFFLINED_ADDRESS_INFO
*
* pageAddressWithEccOn
* Address of the memory page retired when ECC is enabled on the board.
* pageAddressWithEccOff
* Address of the memory page retired when ECC is disabled on the board.
* rbcAddress
* Row/Bank/Column Address of the faulty memory which caused the page to
* be retired
* source
* The reason for the page to be retired
* status
* Non-exceptional reasons for a page retirement failure
* NV2080_CTRL_FB_OFFLINED_PAGES_STATUS_OK
* No error
* NV2080_CTRL_FB_OFFLINED_PAGES_STATUS_PENDING_RETIREMENT
* The given address is already pending retirement or has
* been retired during the current driver run. The page
* will be offlined during the next driver run.
* NV2080_CTRL_FB_OFFLINED_PAGES_STATUS_BLACKLISTING_FAILED
* The given page was retired on a previous driver run,
* so it should not be accessible unless offlining failed.
* Failing to offline a page is strongly indicative of a
* driver offlining bug.
* NV2080_CTRL_FB_OFFLINED_PAGES_STATUS_TABLE_FULL
* The PBL is full and no more pages can be retired
* NV2080_CTRL_FB_OFFLINED_PAGES_STATUS_INTERNAL_ERROR
* Internal driver error
*
*/
typedef struct NV2080_CTRL_FB_OFFLINED_ADDRESS_INFO {
NV_DECLARE_ALIGNED(NvU64 pageAddressWithEccOn, 8);
NV_DECLARE_ALIGNED(NvU64 pageAddressWithEccOff, 8);
NvU32 rbcAddress;
NvU32 source;
NvU32 status;
NvU32 timestamp;
} NV2080_CTRL_FB_OFFLINED_ADDRESS_INFO;
/* valid values for source */
#define NV2080_CTRL_FB_OFFLINED_PAGES_SOURCE_DPR_MULTIPLE_SBE (0x00000002U)
#define NV2080_CTRL_FB_OFFLINED_PAGES_SOURCE_DPR_DBE (0x00000004U)
/* valid values for status */
#define NV2080_CTRL_FB_OFFLINED_PAGES_STATUS_OK (0x00000000U)
#define NV2080_CTRL_FB_OFFLINED_PAGES_STATUS_PENDING_RETIREMENT (0x00000001U)
#define NV2080_CTRL_FB_OFFLINED_PAGES_STATUS_BLACKLISTING_FAILED (0x00000002U)
#define NV2080_CTRL_FB_OFFLINED_PAGES_STATUS_TABLE_FULL (0x00000003U)
#define NV2080_CTRL_FB_OFFLINED_PAGES_STATUS_INTERNAL_ERROR (0x00000004U)
/* deprecated */
#define NV2080_CTRL_FB_OFFLINED_PAGES_SOURCE_MULTIPLE_SBE NV2080_CTRL_FB_OFFLINED_PAGES_SOURCE_DPR_MULTIPLE_SBE
#define NV2080_CTRL_FB_OFFLINED_PAGES_SOURCE_DBE NV2080_CTRL_FB_OFFLINED_PAGES_SOURCE_DPR_DBE
#define NV2080_CTRL_FB_OFFLINE_PAGES_PARAMS_MESSAGE_ID (0x21U)
typedef struct NV2080_CTRL_FB_OFFLINE_PAGES_PARAMS {
NV_DECLARE_ALIGNED(NV2080_CTRL_FB_OFFLINED_ADDRESS_INFO offlined[NV2080_CTRL_FB_OFFLINED_PAGES_MAX_PAGES], 8);
NvU32 pageSize;
NvU32 validEntries;
NvU32 numPagesAdded;
} NV2080_CTRL_FB_OFFLINE_PAGES_PARAMS;
/*
* NV2080_CTRL_CMD_FB_GET_OFFLINED_PAGES
*
* This command returns the list of video memory page addresses in the
* Inforom's blacklist.
*
* offlined
* This output parameter is an array of NV2080_CTRL_FB_BLACKLIST_ADDRESS_
* INFO structures, containing the video memory physical page numbers that
* are blacklisted. This array can hold a maximum of NV2080_CTRL_FB_
* BLACKLIST_PAGES_MAX_PAGES address pairs. Valid entries are adjacent.
* The array also contains the Row/Bank/Column Address and source.
* validEntries
* This output parameter specifies the number of valid entries in the
* offlined array.
* bRetirementPending (DEPRECATED, use retirementPending instead)
* This output parameter returns if any pages on the list are pending
* retirement.
* retirementPending
* Communicates to the caller whether retirement updates are pending and the
* reason for the updates. Possible fields are:
* NV2080_CTRL_FB_GET_OFFLINED_PAGES_RETIREMENT_PENDING_*:
* NV2080_CTRL_FB_GET_OFFLINED_PAGES_RETIREMENT_PENDING_SBE:
* Indicates whether pages are pending retirement due to SBE.
* NV2080_CTRL_FB_GET_OFFLINED_PAGES_RETIREMENT_PENDING_DBE:
* Indicates whether pages are pending retirement due to DBE. Driver
* reload needed to retire bad memory pages and allow compute app runs.
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_GET_OFFLINED_PAGES (0x20801322U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_OFFLINED_PAGES_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_GET_OFFLINED_PAGES_RETIREMENT_PENDING_SBE 0:0
#define NV2080_CTRL_FB_GET_OFFLINED_PAGES_RETIREMENT_PENDING_SBE_FALSE 0U
#define NV2080_CTRL_FB_GET_OFFLINED_PAGES_RETIREMENT_PENDING_SBE_TRUE 1U
#define NV2080_CTRL_FB_GET_OFFLINED_PAGES_RETIREMENT_PENDING_DBE 1:1
#define NV2080_CTRL_FB_GET_OFFLINED_PAGES_RETIREMENT_PENDING_DBE_FALSE 0U
#define NV2080_CTRL_FB_GET_OFFLINED_PAGES_RETIREMENT_PENDING_DBE_TRUE 1U
#define NV2080_CTRL_FB_GET_OFFLINED_PAGES_PARAMS_MESSAGE_ID (0x22U)
typedef struct NV2080_CTRL_FB_GET_OFFLINED_PAGES_PARAMS {
NV_DECLARE_ALIGNED(NV2080_CTRL_FB_OFFLINED_ADDRESS_INFO offlined[NV2080_CTRL_FB_OFFLINED_PAGES_MAX_PAGES], 8);
NvU32 validEntries;
NvBool bRetirementPending;
NvU8 retirementPending;
} NV2080_CTRL_FB_GET_OFFLINED_PAGES_PARAMS;
/*
* NV2080_CTRL_CMD_FB_QUERY_ACR_REGION
*
* This control command is used to query the secured region allocated
*
* queryType
* NV2080_CTRL_CMD_FB_ACR_QUERY_GET_REGION_STATUS: Provides the alloc
* status and ACR region ID.
* NV2080_CTRL_CMD_FB_QUERY_MAP_REGION : Maps the region on BAR1
* it returns the "pCpuAddr" and pPriv to user.
* NV2080_CTRL_CMD_FB_QUERY_UNMAP_REGION: Unmaps the mapped region.
* it takes the pPriv as input
*
* clientReq : struct ACR_REQUEST_PARAMS
* It is used to find the allocated ACR region for that client
* clientId : ACR Client ID
* reqReadMask : read mask of ACR region
* reqWriteMask : Write mask of ACR region
* regionSize : ACR region Size
*
* clientReqStatus : struct ACR_STATUS_PARAMS
* This struct is stores the output of requested ACR region.
* allocStatus : Allocated Status of ACR region
* regionId : ACR region ID
* physicalAddress : Physical address on FB
*
*
* NV2080_CTRL_CMD_FB_ACR_QUERY_ERROR_CODE
* NV2080_CTRL_CMD_FB_ACR_QUERY_ERROR_NONE : Control command executed successfully
* NV2080_CTRL_CMD_FB_ACR_QUERY_ERROR_INVALID_CLIENT_REQUEST : Please check the parameter
* for ACR client request
* NV2080_CTRL_CMD_FB_ACR_QUERY_ERROR_FAILED_TO_MAP_ON_BAR1 : RM Fails to map ACR region
* on BAR1
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_QUERY_ACR_REGION (0x20801325U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_CMD_FB_QUERY_ACR_REGION_PARAMS_MESSAGE_ID" */
//
// We can create an ACR region by using RMCreateAcrRegion[1|2] regkey or mods -acr[1|2]_size
// Client ID for such region is 2 in RM.
//
#define NV2080_CTRL_CMD_FB_ACR_CLIENT_ID 2U
typedef enum NV2080_CTRL_CMD_FB_ACR_QUERY_TYPE {
NV2080_CTRL_CMD_FB_ACR_QUERY_GET_CLIENT_REGION_STATUS = 0,
NV2080_CTRL_CMD_FB_ACR_QUERY_GET_REGION_PROPERTY = 1,
NV2080_CTRL_CMD_FB_ACR_QUERY_GET_FALCON_STATUS = 2,
} NV2080_CTRL_CMD_FB_ACR_QUERY_TYPE;
typedef enum NV2080_CTRL_CMD_FB_ACR_QUERY_ERROR_CODE {
NV2080_CTRL_CMD_FB_ACR_QUERY_ERROR_NONE = 0,
NV2080_CTRL_CMD_FB_ACR_QUERY_ERROR_INVALID_CLIENT_REQUEST = 1,
} NV2080_CTRL_CMD_FB_ACR_QUERY_ERROR_CODE;
typedef struct ACR_REQUEST_PARAMS {
NvU32 clientId;
NvU32 reqReadMask;
NvU32 reqWriteMask;
NvU32 regionSize;
} ACR_REQUEST_PARAMS;
typedef struct ACR_REGION_ID_PROP {
NvU32 regionId;
NvU32 readMask;
NvU32 writeMask;
NvU32 regionSize;
NvU32 clientMask;
NV_DECLARE_ALIGNED(NvU64 physicalAddress, 8);
} ACR_REGION_ID_PROP;
typedef struct ACR_STATUS_PARAMS {
NvU32 allocStatus;
NvU32 regionId;
NV_DECLARE_ALIGNED(NvU64 physicalAddress, 8);
} ACR_STATUS_PARAMS;
typedef struct ACR_REGION_HANDLE {
NvHandle hClient;
NvHandle hParent;
NvHandle hMemory;
NvU32 hClass;
NvHandle hDevice;
} ACR_REGION_HANDLE;
typedef struct ACR_FALCON_LS_STATUS {
NvU16 falconId;
NvBool bIsInLs;
} ACR_FALCON_LS_STATUS;
#define NV2080_CTRL_CMD_FB_QUERY_ACR_REGION_PARAMS_MESSAGE_ID (0x25U)
typedef struct NV2080_CTRL_CMD_FB_QUERY_ACR_REGION_PARAMS {
NV2080_CTRL_CMD_FB_ACR_QUERY_TYPE queryType;
NV2080_CTRL_CMD_FB_ACR_QUERY_ERROR_CODE errorCode;
NV_DECLARE_ALIGNED(ACR_REGION_ID_PROP acrRegionIdProp, 8);
ACR_REQUEST_PARAMS clientReq;
NV_DECLARE_ALIGNED(ACR_STATUS_PARAMS clientReqStatus, 8);
ACR_REGION_HANDLE handle;
ACR_FALCON_LS_STATUS falconStatus;
} NV2080_CTRL_CMD_FB_QUERY_ACR_REGION_PARAMS;
/*
* NV2080_CTRL_CMD_FB_CLEAR_OFFLINED_PAGES
*
* This command clears offlined video memory page addresses from the Inforom.
*
* sourceMask
* This is a bit mask of NV2080_CTRL_FB_OFFLINED_PAGES_SOURCE. Pages
* offlined from the specified sources will be cleared/removed from the
* Inforom PBL object denylist.
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_CLEAR_OFFLINED_PAGES (0x20801326U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_CLEAR_OFFLINED_PAGES_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_CLEAR_OFFLINED_PAGES_PARAMS_MESSAGE_ID (0x26U)
typedef struct NV2080_CTRL_FB_CLEAR_OFFLINED_PAGES_PARAMS {
NvU32 sourceMask;
} NV2080_CTRL_FB_CLEAR_OFFLINED_PAGES_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_GET_COMPBITCOPY_INFO
*
* Gets pointer to then object of class CompBitCopy, which is used for swizzling
* compression bits in the compression backing store. The caller is expected to
* have the appropriate headers for class CompBitCopy. Also retrieves values of some
* parameters needed to call the compbit swizzling method.
*
* @params[out] void *pCompBitCopyObj
* Opaque pointer to object of class CompBitCopy
* @params[out] void *pSwizzleParams
* Opaque pointer to values needed to call the compbit
* swizzle method.
*
* Possible status values returned are:
* NV_OK NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_GET_COMPBITCOPY_INFO (0x20801327U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_CMD_FB_GET_COMPBITCOPY_INFO_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_CMD_FB_GET_COMPBITCOPY_INFO_PARAMS_MESSAGE_ID (0x27U)
typedef struct NV2080_CTRL_CMD_FB_GET_COMPBITCOPY_INFO_PARAMS {
NV_DECLARE_ALIGNED(NvP64 pCompBitCopyObj, 8);
NV_DECLARE_ALIGNED(NvP64 pSwizzleParams, 8);
} NV2080_CTRL_CMD_FB_GET_COMPBITCOPY_INFO_PARAMS;
/*
* NV2080_CTRL_CMD_FB_GET_LTC_INFO_FOR_FBP
*
* Gets the count and mask of LTCs for a given FBP.
*
* fbpIndex
* The physical index of the FBP to get LTC info for.
* ltcMask
* The mask of active LTCs for the given FBP.
* ltcCount
* The count of active LTCs for the given FBP.
* ltsMask
* The mask of active LTSs for the given FBP
* ltsCount
* The count of active LTSs for the given FBP
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_GET_LTC_INFO_FOR_FBP (0x20801328U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_LTC_INFO_FOR_FBP_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_GET_LTC_INFO_FOR_FBP_PARAMS_MESSAGE_ID (0x28U)
typedef struct NV2080_CTRL_FB_GET_LTC_INFO_FOR_FBP_PARAMS {
NvU8 fbpIndex;
NvU32 ltcMask;
NvU32 ltcCount;
NvU32 ltsMask;
NvU32 ltsCount;
} NV2080_CTRL_FB_GET_LTC_INFO_FOR_FBP_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_COMPBITCOPY_SET_CONTEXT < Deprecated >
*
* "set the context" for following CompBitCopy member functions.
* These are the CompBitCopy member variables that remain connstant
* over multiple CompBitCopy member function calls, yet stay the same
* throughout a single surface eviction.
*
* @params[in] UINT64 backingStorePA;
* Physical Address of the Backing Store
* @params[in] UINT08 *backingStoreVA;
* Virtual Address of the Backing Store
* @params[in] UINT64 backingStoreChunkPA;
* Physical Address of the "Chunk Buffer"
* @params[in] UINT08 *backingStoreChunkVA;
* Virtual Address of the "Chunk Buffer"
* @params[in] UINT32 backingStoreChunkSize;
* Size of the "Chunk Buffer"
* @params[in] UINT08 *cacheWriteBitMap;
* Pointer to the bitmap which parts of the
* "Chunk" was updated.
* @params[in] bool backingStoreChunkOverfetch;
* Overfetch factor.
* @params[in] UINT32 PageSizeSrc;
* Page size of Source Surface.
* @params[in] UINT32 PageSizeDest;
* page size of Destination Surface.
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_COMPBITCOPY_SET_CONTEXT (0x20801329U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | 0x29" */
typedef struct NV2080_CTRL_CMD_FB_COMPBITCOPY_SET_CONTEXT_PARAMS {
NvU32 CBCBaseAddress;
NV_DECLARE_ALIGNED(NvU64 backingStorePA, 8);
NV_DECLARE_ALIGNED(NvU8 *backingStoreVA, 8);
NV_DECLARE_ALIGNED(NvU64 backingStoreChunkPA, 8);
NV_DECLARE_ALIGNED(NvU8 *backingStoreChunkVA, 8);
NvU32 backingStoreChunkSize;
NV_DECLARE_ALIGNED(NvU8 *cacheWriteBitMap, 8);
NvBool backingStoreChunkOverfetch;
NvU32 PageSizeSrc;
NvU32 PageSizeDest;
} NV2080_CTRL_CMD_FB_COMPBITCOPY_SET_CONTEXT_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_COMPBITCOPY_GET_COMPBITS < Deprecated >
*
* Retrieves the Compression and Fast Clear bits for the surface+offset given.
*
* @params[out] NvU32 *fcbits;
* Fast Clear Bits returned
* @params[out] NvU32 *compbits;
* Compression Bits returned
* @params[in] NvU64 dataPhysicalStart;
* Start Address of Data
* @params[in] NvU64 surfaceOffset;
* Offset in the surface
* @params[in] NvU32 comptagLine;
* Compression Tag Number
* @params[in] NvBool upper64KBCompbitSel;
* Selects Upper or Lower 64K
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTEDD
*/
#define NV2080_CTRL_CMD_FB_COMPBITCOPY_GET_COMPBITS (0x2080132aU) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | 0x2A" */
typedef struct NV2080_CTRL_CMD_FB_COMPBITCOPY_GET_COMPBITS_PARAMS {
NV_DECLARE_ALIGNED(NvU32 *fcbits, 8);
NV_DECLARE_ALIGNED(NvU32 *compbits, 8);
NV_DECLARE_ALIGNED(NvU64 dataPhysicalStart, 8);
NV_DECLARE_ALIGNED(NvU64 surfaceOffset, 8);
NvU32 comptagLine;
NvBool upper64KBCompbitSel;
} NV2080_CTRL_CMD_FB_COMPBITCOPY_GET_COMPBITS_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_COMPBITCOPY_PUT_COMPBITS < Deprecated >
*
* Sets the Compression and Fast Clear bits for the surface+offset given.
*
* @params[in] NvU32 fcbits;
* Fast Clear Bits to write.
* @params[in] NvU32 compbits;
* Compression Bits to write
* @params[in] NvBool writeFc;
* Indicates if Fast Clear Bits should be written
* @params[in] NvU64 dataPhysicalStart;
* Start Address of Data
* @params[in] NvU64 surfaceOffset;
* Offset in the surface
* @params[in] NvU32 comptagLine;
* Compression Tag Number
* @params[in] NvBool upper64KBCompbitSel;
* Selects Upper or Lower 64K
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_COMPBITCOPY_PUT_COMPBITS (0x2080132bU) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | 0x2B" */
typedef struct NV2080_CTRL_CMD_FB_COMPBITCOPY_PUT_COMPBITS_PARAMS {
NvU32 fcbits;
NvU32 compbits;
NvBool writeFc;
NV_DECLARE_ALIGNED(NvU64 dataPhysicalStart, 8);
NV_DECLARE_ALIGNED(NvU64 surfaceOffset, 8);
NvU32 comptagLine;
NvBool upper64KBCompbitSel;
} NV2080_CTRL_CMD_FB_COMPBITCOPY_PUT_COMPBITS_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_COMPBITCOPY_READ_COMPBITS64KB < Deprecated >
*
* Read 64KB chunk of CompBits
*
* @params[in] NvU64 SrcDataPhysicalStart;
* Start Address of Data
* @params[in] NvU32 SrcComptagLine;
* Compression Tag Number
* @params[in] NvU32 page64KB;
* Which 64K block to read from.
* @params[out] NvU32 *compbitBuffer;
* Buffer for CompBits read,
* @params[in] NvBool upper64KBCompbitSel;
* Selects Upper or Lower 64K
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_COMPBITCOPY_READ_COMPBITS64KB (0x2080132cU) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | 0x2C" */
typedef struct NV2080_CTRL_CMD_FB_COMPBITCOPY_READ_COMPBITS64KB_PARAMS {
NV_DECLARE_ALIGNED(NvU64 SrcDataPhysicalStart, 8);
NvU32 SrcComptagLine;
NvU32 page64KB;
NV_DECLARE_ALIGNED(NvU32 *compbitBuffer, 8);
NvBool upper64KBCompbitSel;
} NV2080_CTRL_CMD_FB_COMPBITCOPY_READ_COMPBITS64KB_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_COMPBITCOPY_WRITE_COMPBITS64KB < Deprecated >
*
* Write 64K chunk of COmpBits.
*
* @params[in] NvU64 SrcDataPhysicalStart;
* Start Address of Data
* @params[in] NvU32 SrcComptagLine;
* Compression Tag Number
* @params[in] NvU32 page64KB;
* Which 64K block to read from.
* @params[in] NvU32 *compbitBuffer;
* Buffer for CompBits to write.
* @params[in] NvBool upper64KBCompbitSel
* Selects Upper or Lower 64K
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_COMPBITCOPY_WRITE_COMPBITS64KB (0x2080132dU) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | 0x2D" */
typedef struct NV2080_CTRL_CMD_FB_COMPBITCOPY_WRITE_COMPBITS64KB_PARAMS {
NV_DECLARE_ALIGNED(NvU64 DstDataPhysicalStart, 8);
NvU32 DstComptagLine;
NvU32 page64KB;
NV_DECLARE_ALIGNED(NvU32 *compbitBuffer, 8);
NvBool upper64KBCompbitSel;
} NV2080_CTRL_CMD_FB_COMPBITCOPY_WRITE_COMPBITS64KB_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_COMPBITCOPY_SET_FORCE_BAR1 < Deprecated >
*
* Used by MODS (and possibly other clients) to have compbit code write
* write directly to BAR1, rather than a intermediate buffer.
*
* @params[in] NvBool bForceBar1;
* Enables or disables direct writes to BAR1.
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_COMPBITCOPY_SET_FORCE_BAR1 (0x20801335U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | 0x35" */
typedef struct NV2080_CTRL_CMD_FB_COMPBITCOPY_SET_FORCE_BAR1_PARAMS {
NvBool bForceBar1;
} NV2080_CTRL_CMD_FB_COMPBITCOPY_SET_FORCE_BAR1_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_GET_AMAP_CONF
*
* Fills in fields of a structure of class ConfParamsV1, which is used for
* swizzling compression bits in the compression backing store.
* The caller is expected to have the appropriate headers for class ConfParamsV1.
*
* @params[in|out] void *pAmapConfParms
* Opaque pointer to structure of values for ConfParamsV1
* @params[in|out] void *pCbcSwizzleParms
* Opaque pointer to structure of values for CbcSwizzleParamsV1
*
* Possible status values returned are:
* NV_OK NV_ERR_NOT_SUPPORTED
*
* pCbcSwizzleParams will be filled in with certain parameters from
* @CbcSwizzleParamsV1. However, the caller is responsible for making sure
* all parameters are filled in before using it.
*/
#define NV2080_CTRL_CMD_FB_GET_AMAP_CONF (0x20801336U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_CMD_FB_GET_AMAP_CONF_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_CMD_FB_GET_AMAP_CONF_PARAMS_MESSAGE_ID (0x36U)
typedef struct NV2080_CTRL_CMD_FB_GET_AMAP_CONF_PARAMS {
NV_DECLARE_ALIGNED(NvP64 pAmapConfParams, 8);
NV_DECLARE_ALIGNED(NvP64 pCbcSwizzleParams, 8);
} NV2080_CTRL_CMD_FB_GET_AMAP_CONF_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_CBC_OP
*
* Provides a way for clients to request a CBC Operation
*
* @params[in] CTRL_CMD_FB_CBC_OP fbCBCOp
* CBC Operation requested.
* Valid Values:
* CTRL_CMD_FB_CBC_OP_CLEAN
* CTRL_CMD_FB_CBC_OP_INVALIDATE
*
* Possible status values returned are:
* NV_OK NV_ERR_NOT_SUPPORTED NV_ERR_INVALID_ARGUMENT NV_ERR_TIMEOUT
*/
#define NV2080_CTRL_CMD_FB_CBC_OP (0x20801337U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_CMD_FB_CBC_OP_PARAMS_MESSAGE_ID" */
/*!
* Permitted CBC Operations
*/
typedef enum CTRL_CMD_FB_CBC_OP {
CTRL_CMD_FB_CBC_OP_CLEAN = 0,
CTRL_CMD_FB_CBC_OP_INVALIDATE = 1,
} CTRL_CMD_FB_CBC_OP;
#define NV2080_CTRL_CMD_FB_CBC_OP_PARAMS_MESSAGE_ID (0x37U)
typedef struct NV2080_CTRL_CMD_FB_CBC_OP_PARAMS {
CTRL_CMD_FB_CBC_OP fbCBCOp;
} NV2080_CTRL_CMD_FB_CBC_OP_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_GET_CTAGS_FOR_CBC_EVICTION
*
* The call will fetch the compression tags reserved for CBC eviction.
*
* Each comptag will correspond to a unique compression cacheline. The usage of
* these comptags is to evict the CBC by making accesses to a dummy compressed page,
* thereby evicting each CBC line.
*
* @param [in][out] NvU32 pCompTags
* Array of reserved compression tags of size @ref NV2080_MAX_CTAGS_FOR_CBC_EVICTION
* @param [out] numCompTags
* Number of entries returned in @ref pCompTags
*
* @returns
* NV_OK
* NV_ERR_INVALID_STATE
* NV_ERR_OUT_OF_RANGE
* NV_ERR_INVALID_PARAMETER
*/
#define NV2080_CTRL_CMD_FB_GET_CTAGS_FOR_CBC_EVICTION (0x20801338U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_CTAGS_FOR_CBC_EVICTION_PARAMS_MESSAGE_ID" */
/*!
* Max size of @ref NV2080_CTRL_FB_GET_CTAGS_FOR_CBC_EVICTION_PARAMS::pCompTags
* Arbitrary, but sufficiently large number. Should be checked against CBC size.
*/
#define NV2080_MAX_CTAGS_FOR_CBC_EVICTION 0x7FU
#define NV2080_CTRL_FB_GET_CTAGS_FOR_CBC_EVICTION_PARAMS_MESSAGE_ID (0x38U)
typedef struct NV2080_CTRL_FB_GET_CTAGS_FOR_CBC_EVICTION_PARAMS {
NvU32 pCompTags[NV2080_MAX_CTAGS_FOR_CBC_EVICTION];
NvU32 numCompTags;
} NV2080_CTRL_FB_GET_CTAGS_FOR_CBC_EVICTION_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_ALLOC_COMP_RESOURCE
*
* This Call will allocate compression tag
*
* @params[in] NvU32 attr
* Stores the information:
* 1. NVOS32_ATTR_COMPR_REQUIRED or not
* 2. NVOS32_ATTR_PAGE_SIZE
* @params[in] NvU32 attr2
* Determine whether to allocate
* an entire cache line or allocate by size
* @params[in] NvU32 size
* Specify the size of allocation, in pages not bytes
* @params[in] NvU32 ctagOffset
* Determine the offset usage of the allocation
* @params[out] NvU32 hwResId
* Stores the result of the allocation
* @params[out] NvU32 RetcompTagLineMin
* The resulting min Ctag Number from the allocation
* @params[out] NvU32 RetcompTagLineMax
* The resulting max Ctag Number from the allocation
* @returns
* NV_OK
* NV_ERR_INSUFFICIENT_RESOURCES
* NV_ERR_INVALID_ARGUMENT
* NV_ERR_INVALID_STATE
*/
#define NV2080_CTRL_CMD_FB_ALLOC_COMP_RESOURCE (0x20801339U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_CMD_FB_ALLOC_COMP_RESOURCE_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_CMD_FB_ALLOC_COMP_RESOURCE_PARAMS_MESSAGE_ID (0x39U)
typedef struct NV2080_CTRL_CMD_FB_ALLOC_COMP_RESOURCE_PARAMS {
NvU32 attr;
NvU32 attr2;
NvU32 size;
NvU32 ctagOffset;
NvU32 hwResId;
NvU32 retCompTagLineMin;
NvU32 retCompTagLineMax;
} NV2080_CTRL_CMD_FB_ALLOC_COMP_RESOURCE_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_FREE_TILE
*
* This control call is used to release tile back to the free pool
*
* @params[in] NvU32 hwResId
* Stores the information of a previous allocation
* @returns
* NV_OK
* NV_ERR_INVALID_ARGUMENT
* NV_ERR_INVALID_STATE
*/
#define NV2080_CTRL_CMD_FB_FREE_TILE (0x2080133aU) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_CMD_FB_FREE_TILE_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_CMD_FB_FREE_TILE_PARAMS_MESSAGE_ID (0x3AU)
typedef struct NV2080_CTRL_CMD_FB_FREE_TILE_PARAMS {
NvU32 hwResId;
} NV2080_CTRL_CMD_FB_FREE_TILE_PARAMS;
/*
* NV2080_CTRL_CMD_FB_SETUP_VPR_REGION
*
* This control command is used to request vpr region setup
*
* requestType
* NV2080_CTRL_CMD_FB_SET_VPR: Request to setup VPR
*
* requestParams : struct VPR_REQUEST_PARAMS
* It contains the VPR region request details like,
* startAddr : FB offset from which we need to setup VPR
* size : required size of the region
*
* statusParams : struct VPR_STATUS_PARAMS
* This struct stores the output of requested VPR region
* status : Whether the request was successful
*
* NV2080_CTRL_CMD_FB_VPR_ERROR_CODE :
* NV2080_CTRL_CMD_FB_VPR_ERROR_GENERIC : Some unknown error occurred
* NV2080_CTRL_CMD_FB_VPR_ERROR_INVALID_CLIENT_REQUEST : Request was invalid
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_SETUP_VPR_REGION (0x2080133bU) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_CMD_FB_SETUP_VPR_REGION_PARAMS_MESSAGE_ID" */
typedef enum NV2080_CTRL_CMD_FB_VPR_REQUEST_TYPE {
NV2080_CTRL_CMD_FB_SET_VPR = 0,
} NV2080_CTRL_CMD_FB_VPR_REQUEST_TYPE;
typedef enum NV2080_CTRL_CMD_FB_VPR_ERROR_CODE {
NV2080_CTRL_CMD_FB_VPR_ERROR_GENERIC = 0,
NV2080_CTRL_CMD_FB_VPR_ERROR_INVALID_CLIENT_REQUEST = 1,
} NV2080_CTRL_CMD_FB_VPR_ERROR_CODE;
typedef struct VPR_REQUEST_PARAMS {
NvU32 startAddr;
NvU32 size;
} VPR_REQUEST_PARAMS;
typedef struct VPR_STATUS_PARAMS {
NvU32 status;
} VPR_STATUS_PARAMS;
#define NV2080_CTRL_CMD_FB_SETUP_VPR_REGION_PARAMS_MESSAGE_ID (0x3BU)
typedef struct NV2080_CTRL_CMD_FB_SETUP_VPR_REGION_PARAMS {
NV2080_CTRL_CMD_FB_VPR_REQUEST_TYPE requestType;
VPR_REQUEST_PARAMS requestParams;
VPR_STATUS_PARAMS statusParams;
} NV2080_CTRL_CMD_FB_SETUP_VPR_REGION_PARAMS;
typedef struct NV2080_CTRL_CMD_FB_SETUP_VPR_REGION_PARAMS *PNV2080_CTRL_CMD_FB_SETUP_VPR_REGION_PARAMS;
/*
* NV2080_CTRL_CMD_FB_GET_CLI_MANAGED_OFFLINED_PAGES
*
* This command returns the list of offlined video memory page addresses in the
* region managed by Client
*
* offlinedPages
* This output parameter is an array of video memory physical page numbers that
* are offlined. This array can hold a maximum of NV2080_CTRL_FB_
* OFFLINED_PAGES_MAX_PAGES addresses.
* pageSize
* This output parameter contains the size of the page that is offlined.
* validEntries
* This output parameter specifies the number of valid entries in the
* offlined array.
*
* Possible status values returned are:
* NV_OK
*/
#define NV2080_CTRL_CMD_FB_GET_CLI_MANAGED_OFFLINED_PAGES (0x2080133cU) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_CLI_MANAGED_OFFLINED_PAGES_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_GET_CLI_MANAGED_OFFLINED_PAGES_PARAMS_MESSAGE_ID (0x3CU)
typedef struct NV2080_CTRL_FB_GET_CLI_MANAGED_OFFLINED_PAGES_PARAMS {
NvU32 offlinedPages[NV2080_CTRL_FB_OFFLINED_PAGES_MAX_PAGES]; // A 32B can hold enough.
NvU32 pageSize;
NvU32 validEntries;
} NV2080_CTRL_FB_GET_CLI_MANAGED_OFFLINED_PAGES_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_GET_COMPBITCOPY_CONSTRUCT_INFO
*
* This command returns parameters required to initialize compbit copy object
* used by address mapping library
*
* defaultPageSize
* Page size used by @ref CompBitCopy methods
* comptagsPerCacheLine
* Number of compression tags in a single compression cache line.
* unpackedComptagLinesPerCacheLine;
* From hw (not adjusted for CompBits code) Number of compression tags
* in a single compression cache line.
* compCacheLineSizePerLTC;
* Size of compression cache line per L2 slice. Size in Bytes.
* unpackedCompCacheLineSizePerLTC;
* From hw (not adjusted for CompBits code) size of compression
* cache line per L2 slice. Size in Bytes
* slicesPerLTC;
* Number of L2 slices per L2 cache.
* numActiveLTCs;
* Number of active L2 caches. (Not floorswept)
* familyName;
* Family name for the GPU.
* chipName;
* Chip name for the GPU.
* bitsPerRAMEntry;
* Bits per RAM entry. (Need better doc)
* ramBankWidth;
* Width of RAM bank. (Need better doc)
* bitsPerComptagLine;
* Number of bits per compression tag line.
* ramEntriesPerCompCacheLine;
* Number of RAM entries spanned by 1 compression cache line.
* comptagLineSize;
* Size of compression tag line, in Bytes.
*
* Possible status values returned are:
* NV_OK
*/
#define NV2080_CTRL_CMD_FB_GET_COMPBITCOPY_CONSTRUCT_INFO (0x2080133dU) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_CMD_FB_GET_COMPBITCOPY_CONSTRUCT_INFO_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_CMD_FB_GET_COMPBITCOPY_CONSTRUCT_INFO_PARAMS_MESSAGE_ID (0x3DU)
typedef struct NV2080_CTRL_CMD_FB_GET_COMPBITCOPY_CONSTRUCT_INFO_PARAMS {
NvU32 defaultPageSize;
NvU32 comptagsPerCacheLine;
NvU32 unpackedComptagLinesPerCacheLine;
NvU32 compCacheLineSizePerLTC;
NvU32 unpackedCompCacheLineSizePerLTC;
NvU32 slicesPerLTC;
NvU32 numActiveLTCs;
NvU32 familyName;
NvU32 chipName;
NvU32 bitsPerRAMEntry;
NvU32 ramBankWidth;
NvU32 bitsPerComptagLine;
NvU32 ramEntriesPerCompCacheLine;
NvU32 comptagLineSize;
} NV2080_CTRL_CMD_FB_GET_COMPBITCOPY_CONSTRUCT_INFO_PARAMS;
/*
* NV2080_CTRL_CMD_FB_SET_RRD
*
* Sets the row-to-row delay on the GPU's FB
*
* Possible status values returned are:
* NV_OK
* Any error code
*/
#define NV2080_CTRL_CMD_FB_SET_RRD (0x2080133eU) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_SET_RRD_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_SET_RRD_RESET_VALUE (~((NvU32)0))
#define NV2080_CTRL_FB_SET_RRD_PARAMS_MESSAGE_ID (0x3EU)
typedef struct NV2080_CTRL_FB_SET_RRD_PARAMS {
NvU32 rrd;
} NV2080_CTRL_FB_SET_RRD_PARAMS;
/*
* NV2080_CTRL_FB_SET_READ_WRITE_LIMIT_PARAMS
*
* This is not a control call of it's own, but there are common definitions for
* the two NV2080_CTRL_CMD_FB_SET_READ/WRITE_LIMIT control calls.
*/
typedef struct NV2080_CTRL_FB_SET_READ_WRITE_LIMIT_PARAMS {
NvU8 limit;
} NV2080_CTRL_FB_SET_READ_WRITE_LIMIT_PARAMS;
#define NV2080_CTRL_FB_SET_READ_WRITE_LIMIT_RESET_VALUE (0xffU)
/*
* NV2080_CTRL_CMD_FB_SET_READ_LIMIT
*
* Sets the READ_LIMIT to be used in the NV_PFB_FBPA_DIR_ARB_CFG0 register
*
* limit
* The limit value to use
*
* Possible status values returned are:
* NV_OK
* Any error code
*/
#define NV2080_CTRL_CMD_FB_SET_READ_LIMIT (0x2080133fU) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_SET_READ_LIMIT_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_SET_READ_LIMIT_RESET_VALUE NV2080_CTRL_FB_SET_READ_WRITE_LIMIT_RESET_VALUE
#define NV2080_CTRL_FB_SET_READ_LIMIT_PARAMS_MESSAGE_ID (0x3FU)
typedef NV2080_CTRL_FB_SET_READ_WRITE_LIMIT_PARAMS NV2080_CTRL_FB_SET_READ_LIMIT_PARAMS;
/*
* NV2080_CTRL_CMD_FB_SET_WRITE_LIMIT
*
* Sets the WRITE_LIMIT to be used in the NV_PFB_FBPA_DIR_ARB_CFG0 register
*
* limit
* The limit value to us
*
* Possible status values returned are:
* NV_OK
* Any error code
*/
#define NV2080_CTRL_CMD_FB_SET_WRITE_LIMIT (0x20801340U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_SET_WRITE_LIMIT_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_SET_WRITE_LIMIT_RESET_VALUE NV2080_CTRL_FB_SET_READ_WRITE_LIMIT_RESET_VALUE
#define NV2080_CTRL_FB_SET_WRITE_LIMIT_PARAMS_MESSAGE_ID (0x40U)
typedef NV2080_CTRL_FB_SET_READ_WRITE_LIMIT_PARAMS NV2080_CTRL_FB_SET_WRITE_LIMIT_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_PATCH_PBR_FOR_MINING
*
* Patches some VBIOS values related to PBR to better suit mining applications
*
* bEnable
* Set the mining-specific values or reset to the original values
*
* Possible status values returned are:
* NV_OK
* Any error code
*/
#define NV2080_CTRL_CMD_FB_PATCH_PBR_FOR_MINING (0x20801341U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_PATCH_PBR_FOR_MINING_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_PATCH_PBR_FOR_MINING_PARAMS_MESSAGE_ID (0x41U)
typedef struct NV2080_CTRL_FB_PATCH_PBR_FOR_MINING_PARAMS {
NvBool bEnable;
} NV2080_CTRL_FB_PATCH_PBR_FOR_MINING_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_GET_MEM_ALIGNMENT
*
* Get memory alignment. Replacement for NVOS32_FUNCTION_GET_MEM_ALIGNMENT
*/
#define NV2080_CTRL_CMD_FB_GET_MEM_ALIGNMENT (0x20801342U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_MEM_ALIGNMENT_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_GET_MEM_ALIGNMENT_MAX_BANKS (4U)
#define NV2080_CTRL_FB_GET_MEM_ALIGNMENT_PARAMS_MESSAGE_ID (0x42U)
typedef struct NV2080_CTRL_FB_GET_MEM_ALIGNMENT_PARAMS {
NvU32 alignType; // Input
NvU32 alignAttr;
NvU32 alignInputFlags;
NvU32 alignHead;
NV_DECLARE_ALIGNED(NvU64 alignSize, 8);
NvU32 alignHeight;
NvU32 alignWidth;
NvU32 alignPitch;
NvU32 alignPad;
NvU32 alignMask;
NvU32 alignOutputFlags[NV2080_CTRL_FB_GET_MEM_ALIGNMENT_MAX_BANKS];
NvU32 alignBank[NV2080_CTRL_FB_GET_MEM_ALIGNMENT_MAX_BANKS];
NvU32 alignKind;
NvU32 alignAdjust; // Output -- If non-zero the amount we need to adjust the offset
NvU32 alignAttr2;
} NV2080_CTRL_FB_GET_MEM_ALIGNMENT_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_GET_CBC_BASEADDR
*
* Get the CBC Base physical address
* This control call is required by error containment tests
* NV2080_CTRL_CMD_FB_GET_AMAP_CONF can also return CBC base address
* but it requires kernel privilege, and it not callalble from SRT test
*
* @params[out] NvU64 cbcBaseAddr
* Base physical address for CBC data.
*
* Possible status values returned are:
* NV_OK NV_ERR_NOT_SUPPORTED
*
*/
#define NV2080_CTRL_CMD_FB_GET_CBC_BASE_ADDR (0x20801343U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_CMD_FB_GET_CBC_BASE_ADDR_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_CMD_FB_GET_CBC_BASE_ADDR_PARAMS_MESSAGE_ID (0x43U)
typedef struct NV2080_CTRL_CMD_FB_GET_CBC_BASE_ADDR_PARAMS {
NvU32 cbcBaseAddress;
NvU32 compCacheLineSize;
NV_DECLARE_ALIGNED(NvU64 backingStoreStartPA, 8);
NV_DECLARE_ALIGNED(NvU64 backingStoreAllocPA, 8);
NvU32 backingStoreChunkOverfetch;
} NV2080_CTRL_CMD_FB_GET_CBC_BASE_ADDR_PARAMS;
#define NV2080_CTRL_FB_REMAP_ENTRY_FLAGS_PENDING 0:0
#define NV2080_CTRL_FB_REMAP_ENTRY_FLAGS_PENDING_FALSE 0U
#define NV2080_CTRL_FB_REMAP_ENTRY_FLAGS_PENDING_TRUE 1U
typedef struct NV2080_CTRL_FB_REMAP_ENTRY {
NvU32 remapRegVal;
NvU32 timestamp;
NvU8 fbpa;
NvU8 sublocation;
NvU8 source;
NvU8 flags;
} NV2080_CTRL_FB_REMAP_ENTRY;
/* valid values for source */
#define NV2080_CTRL_FB_REMAPPED_ROW_SOURCE_SBE_FIELD (0x00000002U)
#define NV2080_CTRL_FB_REMAPPED_ROW_SOURCE_DBE_FIELD (0x00000003U)
#define NV2080_CTRL_FB_REMAPPED_ROWS_MAX_ROWS (0x00000200U)
/*
* NV2080_CTRL_CMD_FB_GET_REMAPPED_ROWS
*
* This command returns the list of remapped rows stored in the Inforom.
*
* entryCount
* This output parameter specifies the number of remapped rows
* flags
* This output parameter contains info on whether or not there are pending
* remappings and whether or not a remapping failed
* entries
* This output parameter is an array of NV2080_CTRL_FB_REMAP_ENTRY
* containing inforomation on the remapping that occurred. This array can
* hold a maximum of NV2080_CTRL_FB_REMAPPED_ROWS_MAX_ROWS
*
* Possible status values returned are:
* NV_OK
* NV_ERR_INVALID_ARGUMENT
* NV_ERR_INVALID_POINTER
* NV_ERR_OBJECT_NOT_FOUND
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_GET_REMAPPED_ROWS (0x20801344U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_REMAPPED_ROWS_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_GET_REMAPPED_ROWS_FLAGS_PENDING \
NV2080_CTRL_FB_REMAP_ENTRY_FLAGS_PENDING
#define NV2080_CTRL_FB_GET_REMAPPED_ROWS_FLAGS_PENDING_FALSE NV2080_CTRL_FB_REMAP_ENTRY_FLAGS_PENDING_FALSE
#define NV2080_CTRL_FB_GET_REMAPPED_ROWS_FLAGS_PENDING_TRUE NV2080_CTRL_FB_REMAP_ENTRY_FLAGS_PENDING_TRUE
#define NV2080_CTRL_FB_GET_REMAPPED_ROWS_FLAGS_FAILURE 1:1
#define NV2080_CTRL_FB_GET_REMAPPED_ROWS_FLAGS_FAILURE_FALSE 0U
#define NV2080_CTRL_FB_GET_REMAPPED_ROWS_FLAGS_FAILURE_TRUE 1U
#define NV2080_CTRL_FB_GET_REMAPPED_ROWS_PARAMS_MESSAGE_ID (0x44U)
typedef struct NV2080_CTRL_FB_GET_REMAPPED_ROWS_PARAMS {
NvU32 entryCount;
NvU8 flags;
NV2080_CTRL_FB_REMAP_ENTRY entries[NV2080_CTRL_FB_REMAPPED_ROWS_MAX_ROWS];
} NV2080_CTRL_FB_GET_REMAPPED_ROWS_PARAMS;
// Max size of the queryParams in Bytes, so that the NV2080_CTRL_FB_FS_INFO_QUERY struct is still 32B
#define NV2080_CTRL_FB_FS_INFO_MAX_QUERY_SIZE 24U
/*!
* Structure holding the out params for NV2080_CTRL_FB_FS_INFO_INVALID_QUERY.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_INVALID_QUERY_PARAMS {
// Unused param, will ensure the size of NV2080_CTRL_FB_FS_INFO_QUERY struct to be 32B
NvU8 data[NV2080_CTRL_FB_FS_INFO_MAX_QUERY_SIZE];
} NV2080_CTRL_FB_FS_INFO_INVALID_QUERY_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_FBP_MASK.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_FBP_MASK_PARAMS {
/*!
* [in]: swizzId
* PartitionID associated with a created smc partition. Currently used only for a
* device monitoring client to get the physical values of the FB. The client needs to pass
* 'NV2080_CTRL_GPU_PARTITION_ID_INVALID' explicitly if it wants RM to ignore the swizzId.
* RM will consider this request similar to a legacy case.
* The client's subscription is used only as a capability check and not as an input swizzId.
*/
NvU32 swizzId;
/*!
* [out]: physical/local fbp mask.
*/
NV_DECLARE_ALIGNED(NvU64 fbpEnMask, 8);
} NV2080_CTRL_FB_FS_INFO_FBP_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_LTC_MASK.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_LTC_MASK_PARAMS {
/*!
* [in]: physical/local FB partition index.
*/
NvU32 fbpIndex;
/*!
* [out]: physical/local ltc mask.
*/
NvU32 ltcEnMask;
} NV2080_CTRL_FB_FS_INFO_LTC_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_LTS_MASK.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_LTS_MASK_PARAMS {
/*!
* [in]: physical/local FB partition index.
*/
NvU32 fbpIndex;
/*!
* [out]: physical/local lts mask.
* Note that lts bits are flattened out for all ltc with in a fbp.
*/
NvU32 ltsEnMask;
} NV2080_CTRL_FB_FS_INFO_LTS_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_FBPA_MASK.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_FBPA_MASK_PARAMS {
/*!
* [in]: physical/local FB partition index.
*/
NvU32 fbpIndex;
/*!
* [out]: physical/local FBPA mask.
*/
NvU32 fbpaEnMask;
} NV2080_CTRL_FB_FS_INFO_FBPA_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_FBPA_SUBP_MASK.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_FBPA_SUBP_MASK_PARAMS {
/*!
* [in]: physical/local FB partition index.
*/
NvU32 fbpIndex;
/*!
* [out]: physical/local FBPA-SubPartition mask.
*/
NvU32 fbpaSubpEnMask;
} NV2080_CTRL_FB_FS_INFO_FBPA_SUBP_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_FBP_LOGICAL_MAP
*/
typedef struct NV2080_CTRL_FB_FS_INFO_FBP_LOGICAL_MAP_PARAMS {
/*!
* [in]: physical/local FB partition index.
*/
NvU32 fbpIndex;
/*!
* [out]: Logical/local FBP index
*/
NvU32 fbpLogicalIndex;
} NV2080_CTRL_FB_FS_INFO_FBP_LOGICAL_MAP_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_ROP_MASK.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_ROP_MASK_PARAMS {
/*!
* [in]: physical/local FB partition index.
*/
NvU32 fbpIndex;
/*!
* [out]: physical/local ROP mask.
*/
NvU32 ropEnMask;
} NV2080_CTRL_FB_FS_INFO_ROP_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LTC_MASK.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LTC_MASK_PARAMS {
/*!
* [in]: Physical FB partition index.
*/
NvU32 fbpIndex;
/*!
* [in]: swizzId
* PartitionID associated with a created smc partition.
*/
NvU32 swizzId;
/*!
* [out]: physical ltc mask.
*/
NvU32 ltcEnMask;
} NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LTC_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LTS_MASK.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LTS_MASK_PARAMS {
/*!
* [in]: Physical FB partition index.
*/
NvU32 fbpIndex;
/*!
* [in]: swizzId
* PartitionID associated with a created smc partition.
*/
NvU32 swizzId;
/*!
* [out]: physical lts mask.
*/
NvU32 ltsEnMask;
} NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LTS_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_PROFILER_MON_FBPA_MASK.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_PROFILER_MON_FBPA_MASK_PARAMS {
/*!
* [in]: Physical FB partition index.
*/
NvU32 fbpIndex;
/*!
* [in]: swizzId
* PartitionID associated with a created smc partition.
*/
NvU32 swizzId;
/*!
* [out]: physical fbpa mask.
*/
NvU32 fbpaEnMask;
} NV2080_CTRL_FB_FS_INFO_PROFILER_MON_FBPA_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_PROFILER_MON_ROP_MASK.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_PROFILER_MON_ROP_MASK_PARAMS {
/*!
* [in]: Physical FB partition index.
*/
NvU32 fbpIndex;
/*!
* [in]: swizzId
* PartitionID associated with a created smc partition.
*/
NvU32 swizzId;
/*!
* [out]: physical rop mask.
*/
NvU32 ropEnMask;
} NV2080_CTRL_FB_FS_INFO_PROFILER_MON_ROP_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_PROFILER_MON_FBPA_SUBP_MASK.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_PROFILER_MON_FBPA_SUBP_MASK_PARAMS {
/*!
* [in]: Physical FB partition index.
*/
NvU32 fbpIndex;
/*!
* [in]: swizzId
* PartitionID associated with a created smc partition. Currently used only for a
* device monitoring client to get the physical values of the FB. The client needs to pass
* 'NV2080_CTRL_GPU_PARTITION_ID_INVALID' explicitly if it wants RM to ignore the swizzId.
* RM will consider this request similar to a legacy case.
* The client's subscription is used only as a capability check and not as an input swizzId.
*/
NvU32 swizzId;
/*!
* [out]: physical FBPA_SubPartition mask associated with requested partition.
*/
NV_DECLARE_ALIGNED(NvU64 fbpaSubpEnMask, 8);
} NV2080_CTRL_FB_FS_INFO_PROFILER_MON_FBPA_SUBP_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_SYSL2_FS_INFO_SYSLTC_MASK.
*/
typedef struct NV2080_CTRL_SYSL2_FS_INFO_SYSLTC_MASK_PARAMS {
/*!
* [in]: physical/local sys Id.
*/
NvU32 sysIdx;
/*!
* [out]: physical/local sysltc mask.
*/
NvU32 sysl2LtcEnMask;
} NV2080_CTRL_SYSL2_FS_INFO_SYSLTC_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_SYSL2_FS_INFO_SYSLTS_MASK.
*/
typedef struct NV2080_CTRL_SYSL2_FS_INFO_SYSLTS_MASK_PARAMS {
/*!
* [IN]: physical/local SYS index.
*/
NvU32 sysIdx;
/*!
* [OUT]: physical/local lts mask.
* Note: this lts mask should be flattened out within a sys chiplet
*/
NV_DECLARE_ALIGNED(NvU64 sysl2LtsEnMask, 8);
} NV2080_CTRL_SYSL2_FS_INFO_SYSLTS_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_PAC_MASK.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_PAC_MASK_PARAMS {
/*!
* [in]: physical/local FB partition index.
*/
NvU32 fbpIndex;
/*!
* [out]: physical/local PAC mask.
*/
NvU32 pacEnMask;
} NV2080_CTRL_FB_FS_INFO_PAC_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_LOGICAL_LTC_MASK.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_LOGICAL_LTC_MASK_PARAMS {
/*!
* [in]: physical/local FB partition index.
*/
NvU32 fbpIndex;
/*!
* [out]: logical/local ltc mask.
*/
NV_DECLARE_ALIGNED(NvU64 logicalLtcEnMask, 8);
} NV2080_CTRL_FB_FS_INFO_LOGICAL_LTC_MASK_PARAMS;
/*!
* Structure holding the in/out params for NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LOGICAL_LTC_MASK.
*/
typedef struct NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LOGICAL_LTC_MASK_PARAMS {
/*!
* [in]: Physical FB partition index.
*/
NvU32 fbpIndex;
/*!
* [in]: swizzId
* PartitionID associated with a created smc partition.
*/
NvU32 swizzId;
/*!
* [out]: logical ltc mask.
*/
NV_DECLARE_ALIGNED(NvU64 logicalLtcEnMask, 8);
} NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LOGICAL_LTC_MASK_PARAMS;
// Possible values for queryType
#define NV2080_CTRL_FB_FS_INFO_INVALID_QUERY 0x0U
#define NV2080_CTRL_FB_FS_INFO_FBP_MASK 0x1U
#define NV2080_CTRL_FB_FS_INFO_LTC_MASK 0x2U
#define NV2080_CTRL_FB_FS_INFO_LTS_MASK 0x3U
#define NV2080_CTRL_FB_FS_INFO_FBPA_MASK 0x4U
#define NV2080_CTRL_FB_FS_INFO_ROP_MASK 0x5U
#define NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LTC_MASK 0x6U
#define NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LTS_MASK 0x7U
#define NV2080_CTRL_FB_FS_INFO_PROFILER_MON_FBPA_MASK 0x8U
#define NV2080_CTRL_FB_FS_INFO_PROFILER_MON_ROP_MASK 0x9U
#define NV2080_CTRL_FB_FS_INFO_FBPA_SUBP_MASK 0xAU
#define NV2080_CTRL_FB_FS_INFO_PROFILER_MON_FBPA_SUBP_MASK 0xBU
#define NV2080_CTRL_FB_FS_INFO_FBP_LOGICAL_MAP 0xCU
#define NV2080_CTRL_SYSL2_FS_INFO_SYSLTC_MASK 0xDU
#define NV2080_CTRL_FB_FS_INFO_PAC_MASK 0xEU
#define NV2080_CTRL_FB_FS_INFO_LOGICAL_LTC_MASK 0xFU
#define NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LOGICAL_LTC_MASK 0x10U
#define NV2080_CTRL_SYSL2_FS_INFO_SYSLTS_MASK 0x11U
typedef struct NV2080_CTRL_FB_FS_INFO_QUERY {
NvU16 queryType;
NvU8 reserved[2];
NvU32 status;
union {
NV2080_CTRL_FB_FS_INFO_INVALID_QUERY_PARAMS inv;
NV_DECLARE_ALIGNED(NV2080_CTRL_FB_FS_INFO_FBP_MASK_PARAMS fbp, 8);
NV2080_CTRL_FB_FS_INFO_LTC_MASK_PARAMS ltc;
NV2080_CTRL_FB_FS_INFO_LTS_MASK_PARAMS lts;
NV2080_CTRL_FB_FS_INFO_FBPA_MASK_PARAMS fbpa;
NV2080_CTRL_FB_FS_INFO_ROP_MASK_PARAMS rop;
NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LTC_MASK_PARAMS dmLtc;
NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LTS_MASK_PARAMS dmLts;
NV2080_CTRL_FB_FS_INFO_PROFILER_MON_FBPA_MASK_PARAMS dmFbpa;
NV2080_CTRL_FB_FS_INFO_PROFILER_MON_ROP_MASK_PARAMS dmRop;
NV_DECLARE_ALIGNED(NV2080_CTRL_FB_FS_INFO_PROFILER_MON_FBPA_SUBP_MASK_PARAMS dmFbpaSubp, 8);
NV2080_CTRL_FB_FS_INFO_FBPA_SUBP_MASK_PARAMS fbpaSubp;
NV2080_CTRL_FB_FS_INFO_FBP_LOGICAL_MAP_PARAMS fbpLogicalMap;
NV2080_CTRL_SYSL2_FS_INFO_SYSLTC_MASK_PARAMS sysl2Ltc;
NV2080_CTRL_FB_FS_INFO_PAC_MASK_PARAMS pac;
NV_DECLARE_ALIGNED(NV2080_CTRL_FB_FS_INFO_LOGICAL_LTC_MASK_PARAMS logicalLtc, 8);
NV_DECLARE_ALIGNED(NV2080_CTRL_FB_FS_INFO_PROFILER_MON_LOGICAL_LTC_MASK_PARAMS dmLogicalLtc, 8);
NV_DECLARE_ALIGNED(NV2080_CTRL_SYSL2_FS_INFO_SYSLTS_MASK_PARAMS sysl2Lts, 8);
} queryParams;
} NV2080_CTRL_FB_FS_INFO_QUERY;
// Max number of queries that can be batched in a single call to NV2080_CTRL_CMD_FB_GET_FS_INFO
#define NV2080_CTRL_FB_FS_INFO_MAX_QUERIES 120U
#define NV2080_CTRL_FB_GET_FS_INFO_PARAMS_MESSAGE_ID (0x46U)
typedef struct NV2080_CTRL_FB_GET_FS_INFO_PARAMS {
NvU16 numQueries;
NvU8 reserved[6];
NV_DECLARE_ALIGNED(NV2080_CTRL_FB_FS_INFO_QUERY queries[NV2080_CTRL_FB_FS_INFO_MAX_QUERIES], 8);
} NV2080_CTRL_FB_GET_FS_INFO_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_GET_FS_INFO
*
* This control call returns the fb engine information for a partition/GPU.
* Supports an interface so that the caller can issue multiple queries by batching them
* in a single call. Returns the first error it encounters.
*
* numQueries[IN]
* - Specifies the number of valid queries.
*
* Possible status values returned are:
* NV_OK
* NV_ERR_INVALID_PARAM_STRUCT
* NV_ERR_INVALID_ARGUMENT
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_GET_FS_INFO (0x20801346U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_FS_INFO_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_HISTOGRAM_IDX_NO_REMAPPED_ROWS (0x0U)
#define NV2080_CTRL_FB_HISTOGRAM_IDX_SINGLE_REMAPPED_ROW (0x1U)
#define NV2080_CTRL_FB_HISTOGRAM_IDX_MIXED_REMAPPED_REMAINING_ROWS (0x2U)
#define NV2080_CTRL_FB_HISTOGRAM_IDX_SINGLE_REMAINING_ROW (0x3U)
#define NV2080_CTRL_FB_HISTOGRAM_IDX_MAX_REMAPPED_ROWS (0x4U)
#define NV2080_CTRL_FB_GET_ROW_REMAPPER_HISTOGRAM_PARAMS_MESSAGE_ID (0x47U)
typedef struct NV2080_CTRL_FB_GET_ROW_REMAPPER_HISTOGRAM_PARAMS {
NvU32 histogram[5];
} NV2080_CTRL_FB_GET_ROW_REMAPPER_HISTOGRAM_PARAMS;
/*!
* NV2080_CTRL_CMD_FB_GET_ROW_REMAPPER_HISTOGRAM
*
* This control call returns stats on the number of banks that have a certain
* number of rows remapped in the bank. Specifically the number of banks that
* have 0, 1, 2 through (max-2), max-1 and max number of rows remapped in the
* bank. Values will be returned in an array.
*
* Index values are:
*
* NV2080_CTRL_FB_HISTOGRAM_IDX_NO_REMAPPED_ROWS
* Number of banks with zero rows remapped
NV2080_CTRL_FB_HISTOGRAM_IDX_SINGLE_REMAPPED_ROW
* Number of banks with one row remapped
NV2080_CTRL_FB_HISTOGRAM_IDX_MIXED_REMAPPED_REMAINING_ROWS
* Number of banks with 2 through (max-2) rows remapped
NV2080_CTRL_FB_HISTOGRAM_IDX_SINGLE_REMAINING_ROW
* Number of banks with (max-1) rows remapped
NV2080_CTRL_FB_HISTOGRAM_IDX_MAX_REMAPPED_ROWS
* Number of banks with max rows remapped
*
* Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_GET_ROW_REMAPPER_HISTOGRAM (0x20801347U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_ROW_REMAPPER_HISTOGRAM_PARAMS_MESSAGE_ID" */
/*
* NV2080_CTRL_CMD_FB_GET_DYNAMICALLY_BLACKLISTED_PAGES
*
* This command returns the list of dynamically blacklisted video memory page addresses
* after last driver load.
*
* blackList
* This output parameter is an array of NV2080_CTRL_FB_DYNAMIC_BLACKLIST_ADDRESS_INFO
* This array can hold a maximum of NV2080_CTRL_FB_DYNAMIC_BLACKLIST_MAX_ENTRIES.
* validEntries
* This output parameter specifies the number of valid entries in the
* blackList array.
* baseIndex
* With the limit of up to 512 blacklisted pages, the size of this array
* exceeds the rpc buffer limit. This control call will collect the data
* in multiple passes. This parameter indicates the start index of the
* data to be passed back to the caller
* This cannot be greater than NV2080_CTRL_FB_DYNAMIC_BLACKLIST_MAX_PAGES
* bMore
* This parameter indicates whether there are more valid elements to be
* fetched.
*
* Possible status values returned are:
* NV_OK
*/
#define NV2080_CTRL_CMD_FB_GET_DYNAMIC_OFFLINED_PAGES (0x20801348U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_DYNAMIC_OFFLINED_PAGES_PARAMS_MESSAGE_ID" */
/* Maximum pages that can be dynamically blacklisted */
#define NV2080_CTRL_FB_DYNAMIC_BLACKLIST_MAX_PAGES 512U
/*
* Maximum entries that can be sent in a single pass of
* NV2080_CTRL_CMD_FB_GET_DYNAMIC_OFFLINED_PAGES
*/
#define NV2080_CTRL_FB_DYNAMIC_BLACKLIST_MAX_ENTRIES 64U
/**
* NV2080_CTRL_FB_DYNAMIC_OFFLINED_ADDRESS_INFO
* pageNumber
* This output parameter specifies the dynamically blacklisted page number.
* source
* The reason for the page to be retired. Valid values for
* this parameter include:
* NV2080_CTRL_FB_OFFLINED_PAGES_SOURCE_INVALID
* Invalid source.
* NV2080_CTRL_FB_OFFLINED_PAGES_SOURCE_DPR_DBE
* Page retired by dynamic page retirement due to a double bit
* error seen.
*/
typedef struct NV2080_CTRL_FB_DYNAMIC_OFFLINED_ADDRESS_INFO {
NV_DECLARE_ALIGNED(NvU64 pageNumber, 8);
NvU8 source;
} NV2080_CTRL_FB_DYNAMIC_OFFLINED_ADDRESS_INFO;
#define NV2080_CTRL_FB_GET_DYNAMIC_OFFLINED_PAGES_PARAMS_MESSAGE_ID (0x48U)
typedef struct NV2080_CTRL_FB_GET_DYNAMIC_OFFLINED_PAGES_PARAMS {
NV_DECLARE_ALIGNED(NV2080_CTRL_FB_DYNAMIC_OFFLINED_ADDRESS_INFO offlined[NV2080_CTRL_FB_DYNAMIC_BLACKLIST_MAX_ENTRIES], 8);
NvU32 validEntries;
NvU32 baseIndex;
NvBool bMore;
} NV2080_CTRL_FB_GET_DYNAMIC_OFFLINED_PAGES_PARAMS;
/* valid values for source */
#define NV2080_CTRL_FB_DYNAMIC_BLACKLISTED_PAGES_SOURCE_INVALID (0x00000000U)
#define NV2080_CTRL_FB_DYNAMIC_BLACKLISTED_PAGES_SOURCE_DPR_DBE (0x00000001U)
/*
* NV2080_CTRL_CMD_FB_GET_CLIENT_ALLOCATION_INFO
*
* This control command is used by clients to query information pertaining to client allocations.
*
*
* @params [IN/OUT] NvU64 allocCount:
* Client specifies the allocation count that it received using the
* previous NV2080_CTRL_CMD_FB_GET_CLIENT_ALLOCATION_INFO control call.
* RM will get the total number of allocations known by RM and fill
* allocCount with it.
*
* @params [IN] NvP64 pAllocInfo:
* Pointer to the buffer allocated by client of size NV2080_CTRL_CMD_FB_ALLOCATION_INFO *
* allocCount. RM returns the info pertaining to each of the contiguous client
* allocation chunks in pAllocInfo. The format of the allocation information is given by
* NV2080_CTRL_CMD_FB_ALLOCATION_INFO. The client has to sort the returned information if
* it wants to retain the legacy behavior of SORTED BY OFFSET. Information is only returned
* if and only if allocCount[IN]>=allocCount[OUT] and clientCount[IN]>=clientCount[OUT].
*
* @params [IN/OUT] NvP64 clientCount:
* Client specifies the client count that it received using the
* previous NV2080_CTRL_CMD_FB_GET_CLIENT_ALLOCATION_INFO control call.
* RM will get the total number of clients that have allocations with RM
* and fill clientCount with it.
*
* @params [IN] NvP64 pClientInfo:
* Pointer to the buffer allocated by client of size NV2080_CTRL_CMD_FB_CLIENT_INFO *
* clientCount. RM returns the info pertaining to each of the clients that have allocations
* known about by RM in pClientInfo. The format of the allocation information is given by
* NV2080_CTRL_CMD_FB_CLIENT_INFO. Information is only returned if and only if
* allocCount[IN]>=allocCount[OUT] and clientCount[IN]>=clientCount[OUT].
*
* @returns Possible status values returned are:
* NV_OK
* NV_ERR_INVALID_POINTER
* NV_ERR_NO_MEMORY
*
* @Usage: All privileged RM clients for debugging only. Initially, call this with allocCount =
* clientCount = 0 to get client count, and then call again with allocated memory and sizes.
* Client can repeat with the new count-sized allocations until a maximum try count is
* reached or client is out of memory.
*/
#define NV2080_CTRL_CMD_FB_GET_CLIENT_ALLOCATION_INFO (0x20801349U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_CMD_FB_GET_CLIENT_ALLOCATION_INFO_PARAMS_MESSAGE_ID" */
/*
* These work with the FLD_SET_REF_NUM and FLD_TEST_REF macros and describe the 'flags' member
* of the NV2080_CTRL_CMD_FB_ALLOCATION_INFO struct.
*/
// Address space of the allocation
#define NV2080_CTRL_CMD_FB_ALLOCATION_FLAGS_TYPE 4:0
#define NV2080_CTRL_CMD_FB_ALLOCATION_FLAGS_TYPE_SYSMEM 0U
#define NV2080_CTRL_CMD_FB_ALLOCATION_FLAGS_TYPE_VIDMEM 1U
// Whether the allocation is shared
#define NV2080_CTRL_CMD_FB_ALLOCATION_FLAGS_SHARED 5:5
#define NV2080_CTRL_CMD_FB_ALLOCATION_FLAGS_SHARED_FALSE 0U
#define NV2080_CTRL_CMD_FB_ALLOCATION_FLAGS_SHARED_TRUE 1U
// Whether this client owns this allocation
#define NV2080_CTRL_CMD_FB_ALLOCATION_FLAGS_OWNER 6:6
#define NV2080_CTRL_CMD_FB_ALLOCATION_FLAGS_OWNER_FALSE 0U
#define NV2080_CTRL_CMD_FB_ALLOCATION_FLAGS_OWNER_TRUE 1U
typedef struct NV2080_CTRL_CMD_FB_ALLOCATION_INFO {
NvU32 client; /* [OUT] Identifies the client that made or shares the allocation (index into pClientInfo)*/
NvU32 flags; /* [OUT] Flags associated with the allocation (see previous defines) */
NV_DECLARE_ALIGNED(NvU64 beginAddr, 8); /* [OUT] Starting physical address of the chunk */
NV_DECLARE_ALIGNED(NvU64 size, 8); /* [OUT] Size of the allocated contiguous chunk in bytes */
} NV2080_CTRL_CMD_FB_ALLOCATION_INFO;
typedef struct NV2080_CTRL_CMD_FB_CLIENT_INFO {
NvHandle handle; /* [OUT] Handle of the client that made or shares the allocation */
NvU32 pid; /* [OUT] PID of the client that made or shares the allocation */
/* For the definition of the subprocessID and subprocessName params, see NV0000_CTRL_CMD_SET_SUB_PROCESS_ID */
NvU32 subProcessID; /* [OUT] Subprocess ID of the client that made or shares the allocation */
char subProcessName[NV_PROC_NAME_MAX_LENGTH]; /* [OUT] Subprocess Name of the client that made or shares the allocation */
} NV2080_CTRL_CMD_FB_CLIENT_INFO;
#define NV2080_CTRL_CMD_FB_GET_CLIENT_ALLOCATION_INFO_PARAMS_MESSAGE_ID (0x49U)
typedef struct NV2080_CTRL_CMD_FB_GET_CLIENT_ALLOCATION_INFO_PARAMS {
NV_DECLARE_ALIGNED(NvU64 allocCount, 8);
NV_DECLARE_ALIGNED(NvP64 pAllocInfo, 8);
NV_DECLARE_ALIGNED(NvU64 clientCount, 8);
NV_DECLARE_ALIGNED(NvP64 pClientInfo, 8);
} NV2080_CTRL_CMD_FB_GET_CLIENT_ALLOCATION_INFO_PARAMS;
/*
* NV2080_CTRL_CMD_FB_UPDATE_NUMA_STATUS
*
* This control command is used by clients to update the NUMA status.
*
* @params [IN] NvBool bOnline:
*
* @returns Possible status values returned are:
* NV_OK
* NV_ERR_INVALID_STATE
*
*/
#define NV2080_CTRL_CMD_FB_UPDATE_NUMA_STATUS (0x20801350U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_UPDATE_NUMA_STATUS_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_UPDATE_NUMA_STATUS_PARAMS_MESSAGE_ID (0x50U)
typedef struct NV2080_CTRL_FB_UPDATE_NUMA_STATUS_PARAMS {
NvBool bOnline;
} NV2080_CTRL_FB_UPDATE_NUMA_STATUS_PARAMS;
/*
* NV2080_CTRL_CMD_FB_GET_NUMA_INFO
*
* This control command is used by clients to get per-subdevice or
* subscribed MIG partition(when MIG is enabled) NUMA memory information as
* assigned by the system.
*
* numaNodeId[OUT]
* - Specifies the NUMA node ID.
*
* numaMemAddr[OUT]
* - Specifies the NUMA memory address.
*
* numaMemSize[OUT]
* - Specifies the NUMA memory size.
*
* numaOfflineAddressesCount[IN/OUT]
* - If non-zero, then it specifies the maximum number of entries in
* numaOfflineAddresses[] for which the information is required.
* It will be updated with the actual number of entries present in
* the numaOfflineAddresses[].
*
* numaOfflineAddresses[OUT]
* - If numaOfflineAddressesCount is non-zero, it contains the addresses
* of offline pages in the NUMA region.
*
* @returns Possible status values returned are:
* NV_OK
* NV_ERR_INVALID_ARGUMENT
*/
#define NV2080_CTRL_CMD_FB_GET_NUMA_INFO (0x20801351U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_NUMA_INFO_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_NUMA_INFO_MAX_OFFLINE_ADDRESSES 64U
#define NV2080_CTRL_FB_GET_NUMA_INFO_PARAMS_MESSAGE_ID (0x51U)
typedef struct NV2080_CTRL_FB_GET_NUMA_INFO_PARAMS {
NvS32 numaNodeId;
NV_DECLARE_ALIGNED(NvU64 numaMemAddr, 8);
NV_DECLARE_ALIGNED(NvU64 numaMemSize, 8);
NvU32 numaOfflineAddressesCount;
NV_DECLARE_ALIGNED(NvU64 numaOfflineAddresses[NV2080_CTRL_FB_NUMA_INFO_MAX_OFFLINE_ADDRESSES], 8);
} NV2080_CTRL_FB_GET_NUMA_INFO_PARAMS;
/*
* NV2080_CTRL_CMD_FB_GET_SEMAPHORE_SURFACE_LAYOUT
*
* This control command is used by clients to get NV_SEMAPHORE_SURFACE layout/caps before allocation.
* A semaphore surface can be viewed as an array of independent semaphore entries.
*
* maxSubmittedSemaphoreValueOffset[OUT]
* - An offset of the max submitted value, relative to the semaphore surface entry start, if used.
* Used to emulate 64-bit semaphore values on chips where 64-bit semaphores are not supported.
*
* monitoredFenceThresholdOffset[OUT]
* - An offset of the monitored fence memory, relative to the semaphore surface entry start, if supported.
*
* size[OUT]
* - A size of a single semaphore surface entry.
*
* caps[OUT]
* - A mask of NV2080_CTRL_FB_GET_SEMAPHORE_SURFACE_LAYOUT_CAPS_* values.
*/
#define NV2080_CTRL_CMD_FB_GET_SEMAPHORE_SURFACE_LAYOUT (0x20801352U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_SEMAPHORE_SURFACE_LAYOUT_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_GET_SEMAPHORE_SURFACE_LAYOUT_CAPS_MONITORED_FENCE_SUPPORTED (0x00000001U)
#define NV2080_CTRL_FB_GET_SEMAPHORE_SURFACE_LAYOUT_CAPS_64BIT_SEMAPHORES_SUPPORTED (0x00000002U)
#define NV2080_CTRL_FB_GET_SEMAPHORE_SURFACE_LAYOUT_PARAMS_MESSAGE_ID (0x52U)
typedef struct NV2080_CTRL_FB_GET_SEMAPHORE_SURFACE_LAYOUT_PARAMS {
NV_DECLARE_ALIGNED(NvU64 maxSubmittedSemaphoreValueOffset, 8);
NV_DECLARE_ALIGNED(NvU64 monitoredFenceThresholdOffset, 8);
NV_DECLARE_ALIGNED(NvU64 size, 8);
NvU32 caps;
} NV2080_CTRL_FB_GET_SEMAPHORE_SURFACE_LAYOUT_PARAMS;
typedef struct NV2080_CTRL_CMD_FB_STATS_ENTRY {
//! Total physical memory available (accounts row-remapping)
NV_DECLARE_ALIGNED(NvU64 totalSize, 8);
//! Total reserved memory (includes both Region 1 and region 2)
NV_DECLARE_ALIGNED(NvU64 rsvdSize, 8);
//! Total usable memory (Region 0) for OS/KMD
NV_DECLARE_ALIGNED(NvU64 osSize, 8);
//! Region 1 (RM Internal) memory
NV_DECLARE_ALIGNED(NvU64 r1Size, 8);
//! Region 2 (Reserved) memory
NV_DECLARE_ALIGNED(NvU64 r2Size, 8);
//! Free memory (reserved but not allocated)
NV_DECLARE_ALIGNED(NvU64 freeSize, 8);
} NV2080_CTRL_CMD_FB_STATS_ENTRY;
/*
* NV2080_CTRL_CMD_GMMU_COMMIT_TLB_INVALIDATE
*
* This control command is used by clients to commit TLB invalidates
*
* gfid[OUT]
* - Specifices GPU function ID.
*
* invalidateAll[OUT]
* - Specifies whether to invalidate all using boolean
*
* @returns Possible status values returned are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
*
*/
#define NV2080_CTRL_CMD_GMMU_COMMIT_TLB_INVALIDATE (0x20801353U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_GMMU_COMMIT_TLB_INVALIDATE_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_GMMU_COMMIT_TLB_INVALIDATE_PARAMS_MESSAGE_ID (0x53U)
typedef struct NV2080_CTRL_GMMU_COMMIT_TLB_INVALIDATE_PARAMS {
NvU32 gfid;
NvBool invalidateAll;
} NV2080_CTRL_GMMU_COMMIT_TLB_INVALIDATE_PARAMS;
typedef struct NV2080_CTRL_CMD_FB_STATS_OWNER_INFO {
//! Total allocated size for this owner
NV_DECLARE_ALIGNED(NvU64 allocSize, 8);
//! Total memory blocks belonging this owner
NvU32 numBlocks;
//! Total reserved size for this owner
NV_DECLARE_ALIGNED(NvU64 rsvdSize, 8);
} NV2080_CTRL_CMD_FB_STATS_OWNER_INFO;
#define NV2080_CTRL_CMD_FB_STATS_MAX_OWNER 200U
/*
* NV2080_CTRL_CMD_FB_STATS_GET
*
* Get the FB allocations info.
*/
#define NV2080_CTRL_CMD_FB_STATS_GET (0x2080132a) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_CMD_FB_STATS_GET_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_CMD_FB_STATS_GET_PARAMS_MESSAGE_ID (0x2AU)
typedef struct NV2080_CTRL_CMD_FB_STATS_GET_PARAMS {
//! Version id for driver and tool matching
NV_DECLARE_ALIGNED(NvU64 version, 8);
//! All sizes info
NV_DECLARE_ALIGNED(NV2080_CTRL_CMD_FB_STATS_ENTRY fbSizeInfo, 8);
//! Level 2 owner info table
NV_DECLARE_ALIGNED(NV2080_CTRL_CMD_FB_STATS_OWNER_INFO fbBlockInfo[NV2080_CTRL_CMD_FB_STATS_MAX_OWNER], 8);
} NV2080_CTRL_CMD_FB_STATS_GET_PARAMS;
/*
* NV2080_CTRL_CMD_FB_GET_STATIC_BAR1_INFO
*
* This command returns the GPU static BAR1 Info
* This is for general P2P DMA. NV50_P2P is for GPU P2P.
*
* @params [OUT] NvBool bStaticBar1Enabled:
* This field indicates the static BAR1 mode is enabled. All the following fields are valid
* only if static BAR1 mode is enabled.
* @params [OUT] NvU64 staticBar1StartOffset:
* Static BAR1 may start at nonzero BAR1 address.
* This field indicates the start offset of the static BAR1.
* @params [OUT] NvU64 staticBar1Size:
* This field indicates the size of the static BAR1.
*
* Possible status values returned are
* NV_OK
* NV_ERR_INVALID_PARAM_STRUCT
* NV_ERR_NOT_SUPPORTED
* NV_ERR_INVALID_ARGUMENT
*/
#define NV2080_CTRL_CMD_FB_GET_STATIC_BAR1_INFO (0x20801354U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_STATIC_BAR1_INFO_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_GET_STATIC_BAR1_INFO_PARAMS_MESSAGE_ID (0x54U)
typedef struct NV2080_CTRL_FB_GET_STATIC_BAR1_INFO_PARAMS {
NvBool bStaticBar1Enabled;
NV_DECLARE_ALIGNED(NvU64 staticBar1StartOffset, 8);
NV_DECLARE_ALIGNED(NvU64 staticBar1Size, 8);
} NV2080_CTRL_FB_GET_STATIC_BAR1_INFO_PARAMS;
/*
* NV2080_CTRL_CMD_FB_QUERY_DRAM_ENCRYPTION_PENDING_CONFIGURATION
*
* This command returns the current DRAM encryption configuration
* setting for a GPU given its subdevice handle. The value returned
* is the current DRAM encryption setting for the GPU stored in non-volatile
* memory on the board.
*
* currentConfiguration
* The current DRAM encryption configuration setting.
*
* Possible status return values are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
* NV_ERR_INVALID_STATE
*/
#define NV2080_CTRL_CMD_FB_QUERY_DRAM_ENCRYPTION_PENDING_CONFIGURATION (0x20801355U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_QUERY_DRAM_ENCRYPTION_PENDING_CONFIGURATION_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_QUERY_DRAM_ENCRYPTION_PENDING_CONFIGURATION_DISABLED (0x00000000U)
#define NV2080_CTRL_FB_QUERY_DRAM_ENCRYPTION_PENDING_CONFIGURATION_ENABLED (0x00000001U)
#define NV2080_CTRL_FB_QUERY_DRAM_ENCRYPTION_PENDING_CONFIGURATION_PARAMS_MESSAGE_ID (0x55U)
typedef struct NV2080_CTRL_FB_QUERY_DRAM_ENCRYPTION_PENDING_CONFIGURATION_PARAMS {
NvU32 currentConfiguration;
} NV2080_CTRL_FB_QUERY_DRAM_ENCRYPTION_PENDING_CONFIGURATION_PARAMS;
/*
* NV2080_CTRL_CMD_FB_SET_DRAM_ENCRYPTION_CONFIGURATION
*
* This command changes the DRAM encryption configuration setting for
* a GPU given its subdevice handle. The value specified is stored
* in non-volatile memory on the board and will take effect with the
* next GPU reset.
*
* newConfiguration
* The new configuration setting to take effect with
* the next GPU reset.
*
* Possible status return values are:
* NV_OK
* NV_ERR_INVALID_ARGUMENT
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_SET_DRAM_ENCRYPTION_CONFIGURATION (0x20801356U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_SET_DRAM_ENCRYPTION_CONFIGURATION_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_FB_SET_DRAM_ENCRYPTION_CONFIGURATION_DISABLE (0x00000000U)
#define NV2080_CTRL_FB_SET_DRAM_ENCRYPTION_CONFIGURATION_ENABLE (0x00000001U)
#define NV2080_CTRL_FB_SET_DRAM_ENCRYPTION_CONFIGURATION_PARAMS_MESSAGE_ID (0x56U)
typedef struct NV2080_CTRL_FB_SET_DRAM_ENCRYPTION_CONFIGURATION_PARAMS {
NvU32 newConfiguration;
} NV2080_CTRL_FB_SET_DRAM_ENCRYPTION_CONFIGURATION_PARAMS;
/*
* NV2080_CTRL_CMD_FB_GET_STATUS
*
* This control command is used by clients to get the FB availabilty status,
* i.e whether the GPU Memory is ready for use or not for MIG and non-MIG cases
*
* fbStatus[OUT]
* This parameter returns the various values of FB availability status.
* Valid values include:
* NV2080_CTRL_FB_STATUS_FAILED
* On Non Self hosted (Non NUMA) systems - this status is not expected since
* FB memory is available as part of GPU initialization itself.
* On Direct connected Self hosted systems - this status is not expected since
* FB memory is available as part of GPU initialization itself.
* On Nvswitch connected Self hosted systems - this status indicates that either
* the memory onlining has failed or fabric probe response has failed.
* GPU reset maybe required in such a case.
* NV2080_CTRL_FB_STATUS_READY
* On Non Self hosted systems - this status is always returned as memory is ready
* after GPU initialization is complete.
* On Self hosted systems - this status indicates that the FB memory has been onlined
* successfully and is available for client/user allocations.
* NV2080_CTRL_FB_STATUS_PENDING
* On Non Self hosted systems - this status is not expected
* On Direct connected Self hosted systems - this status is not expected since
* FB memory is available as part of GPU initialization itself.
* On Nvswitch connected Self hosted systems - This status indicates memory is yet to
* be onlined or is in progress since we are either still waiting for a fabric
* probe response or a fabric probe request hasn't been sent yet.
* NV2080_CTRL_FB_STATUS_NOT_APPLICABLE
* This status indicates that this is a system with no FB memory.
*
*
* @returns Possible status values returned are:
* NV_OK
* NV_ERR_INVALID_STATE
* NV_ERR_NOT_SUPPORTED
* NV_ERR_NOT_READY
* NV_ERR_INVALID_LOCK_STATE
*/
#define NV2080_CTRL_CMD_FB_GET_STATUS (0x20801357U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_GET_STATUS_PARAMS_MESSAGE_ID" */
// NUMA Memory Onlining Status
#define NV2080_CTRL_FB_STATUS_FAILED (0x00000000U)
#define NV2080_CTRL_FB_STATUS_READY (0x00000001U)
#define NV2080_CTRL_FB_STATUS_PENDING (0x00000002U)
#define NV2080_CTRL_FB_STATUS_NOT_APPLICABLE (0x00000003U)
#define NV2080_CTRL_FB_GET_STATUS_PARAMS_MESSAGE_ID (0x57U)
typedef struct NV2080_CTRL_FB_GET_STATUS_PARAMS {
NvU32 fbStatus;
} NV2080_CTRL_FB_GET_STATUS_PARAMS;
/*
* NV2080_CTRL_CMD_FB_QUERY_DRAM_ENCRYPTION_INFOROM_SUPPORT
*
* This command returns whether or not DRAM encryption config object is supported via the InfoROM.
*
* isSupported [OUT]
* This parameter returns whether the DRAM Encryption inforom object is present in the inforom.
* The various values of isSupported is:
* 1. NV2080_CTRL_CMD_FB_QUERY_DRAM_ENCRYPTION_INFOROM_SUPPORT_DISABLED
* 2. NV2080_CTRL_CMD_FB_QUERY_DRAM_ENCRYPTION_INFOROM_SUPPORT_ENABLED
*
* Possible status return values are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
*/
#define NV2080_CTRL_CMD_FB_QUERY_DRAM_ENCRYPTION_INFOROM_SUPPORT (0x20801358U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_DRAM_ENCRYPTION_INFOROM_SUPPORT_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_CMD_FB_QUERY_DRAM_ENCRYPTION_INFOROM_SUPPORT_DISABLED (0x00000000U)
#define NV2080_CTRL_CMD_FB_QUERY_DRAM_ENCRYPTION_INFOROM_SUPPORT_ENABLED (0x00000001U)
#define NV2080_CTRL_FB_DRAM_ENCRYPTION_INFOROM_SUPPORT_PARAMS_MESSAGE_ID (0x58U)
typedef struct NV2080_CTRL_FB_DRAM_ENCRYPTION_INFOROM_SUPPORT_PARAMS {
NvU32 isSupported;
} NV2080_CTRL_FB_DRAM_ENCRYPTION_INFOROM_SUPPORT_PARAMS;
/*
* NV2080_CTRL_CMD_FB_QUERY_DRAM_ENCRYPTION_STATUS
*
* This command returns the current DRAM encryption status.
*
* currentStatus
* The current DRAM encryption status.
*
* Possible status return values are:
* NV_OK
* NV_ERR_NOT_SUPPORTED
* NV_ERR_INVALID_STATE
*/
#define NV2080_CTRL_CMD_FB_QUERY_DRAM_ENCRYPTION_STATUS (0x20801359U) /* finn: Evaluated from "(FINN_NV20_SUBDEVICE_0_FB_INTERFACE_ID << 8) | NV2080_CTRL_FB_QUERY_DRAM_ENCRYPTION_STATUS_PARAMS_MESSAGE_ID" */
#define NV2080_CTRL_CMD_FB_QUERY_DRAM_ENCRYPTION_STATUS_DISABLED (0x00000000U)
#define NV2080_CTRL_CMD_FB_QUERY_DRAM_ENCRYPTION_STATUS_ENABLED (0x00000001U)
#define NV2080_CTRL_FB_QUERY_DRAM_ENCRYPTION_STATUS_PARAMS_MESSAGE_ID (0x59U)
typedef struct NV2080_CTRL_FB_QUERY_DRAM_ENCRYPTION_STATUS_PARAMS {
NvU32 currentStatus;
} NV2080_CTRL_FB_QUERY_DRAM_ENCRYPTION_STATUS_PARAMS;
/* _ctrl2080fb_h_ */
Reference in New Issue View Git Blame Copy Permalink