/* * 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 // // 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_ */