1 //===========================================================================
2 // Copyright (C) 2022-23 Intel Corporation
3 // This software and the related documents are Intel copyrighted materials, and
4 // your use of them is governed by the express license under which they were
5 // provided to you ("License"). Unless the License provides otherwise, you may
6 // not use, modify, copy, publish, distribute, disclose or transmit this software
7 // or the related documents without Intel's prior written permission. This software
8 // and the related documents are provided as is, with no express or implied
9 // warranties, other than those that are expressly stated in the License.
10 //--------------------------------------------------------------------------
20 #if defined(__cplusplus)
28 #if defined(__cplusplus)
32 // Intel 'ctlApi' common types
33 #if !defined(__GNUC__)
36 ///////////////////////////////////////////////////////////////////////////////
37 #ifndef CTL_MAKE_VERSION
38 /// @brief Generates generic ::'ctlApi' API versions
39 #define CTL_MAKE_VERSION( _major, _minor ) (( _major << 16 )|( _minor & 0x0000ffff))
40 #endif // CTL_MAKE_VERSION
42 ///////////////////////////////////////////////////////////////////////////////
43 #ifndef CTL_MAJOR_VERSION
44 /// @brief Extracts ::'ctlApi' API major version
45 #define CTL_MAJOR_VERSION( _ver ) ( _ver >> 16 )
46 #endif // CTL_MAJOR_VERSION
48 ///////////////////////////////////////////////////////////////////////////////
49 #ifndef CTL_MINOR_VERSION
50 /// @brief Extracts ::'ctlApi' API minor version
51 #define CTL_MINOR_VERSION( _ver ) ( _ver & 0x0000ffff )
52 #endif // CTL_MINOR_VERSION
54 ///////////////////////////////////////////////////////////////////////////////
55 #ifndef CTL_IMPL_MAJOR_VERSION
56 /// @brief ::'ctlApi' API major version of this implementation
57 #define CTL_IMPL_MAJOR_VERSION 1
58 #endif // CTL_IMPL_MAJOR_VERSION
60 ///////////////////////////////////////////////////////////////////////////////
61 #ifndef CTL_IMPL_MINOR_VERSION
62 /// @brief ::'ctlApi' API minor version of this implementation
63 #define CTL_IMPL_MINOR_VERSION 1
64 #endif // CTL_IMPL_MINOR_VERSION
66 ///////////////////////////////////////////////////////////////////////////////
67 #ifndef CTL_IMPL_VERSION
68 /// @brief ::'ctlApi' API version of this implementation
69 #define CTL_IMPL_VERSION CTL_MAKE_VERSION( CTL_IMPL_MAJOR_VERSION, CTL_IMPL_MINOR_VERSION )
70 #endif // CTL_IMPL_VERSION
72 ///////////////////////////////////////////////////////////////////////////////
75 /// @brief Calling convention for all API functions
76 #define CTL_APICALL __cdecl
79 #endif // defined(_WIN32)
82 ///////////////////////////////////////////////////////////////////////////////
85 /// @brief Microsoft-specific dllexport storage-class attribute
86 #define CTL_APIEXPORT __declspec(dllexport)
89 #endif // defined(_WIN32)
90 #endif // CTL_APIEXPORT
92 ///////////////////////////////////////////////////////////////////////////////
95 /// @brief Microsoft-specific dllexport storage-class attribute
96 #define CTL_DLLEXPORT __declspec(dllexport)
97 #endif // defined(_WIN32)
98 #endif // CTL_DLLEXPORT
100 ///////////////////////////////////////////////////////////////////////////////
101 #ifndef CTL_DLLEXPORT
103 /// @brief GCC-specific dllexport storage-class attribute
104 #define CTL_DLLEXPORT __attribute__ ((visibility ("default")))
106 #define CTL_DLLEXPORT
107 #endif // __GNUC__ >= 4
108 #endif // CTL_DLLEXPORT
110 ///////////////////////////////////////////////////////////////////////////////
112 /// @brief Generic macro for enumerator bit masks
113 #define CTL_BIT( _i ) ( 1 << _i )
116 ///////////////////////////////////////////////////////////////////////////////
117 /// @brief Supported initialization flags
118 typedef uint32_t ctl_init_flags_t
;
119 typedef enum _ctl_init_flag_t
121 CTL_INIT_FLAG_USE_LEVEL_ZERO
= CTL_BIT(0), ///< Use Level0 or not. This is usually required for telemetry,
122 ///< performance, frequency related APIs
123 CTL_INIT_FLAG_MAX
= 0x80000000
127 ///////////////////////////////////////////////////////////////////////////////
128 /// @brief Version information
129 typedef uint32_t ctl_version_info_t
;
131 ///////////////////////////////////////////////////////////////////////////////
132 /// @brief Handle of a control API instance
133 typedef struct _ctl_api_handle_t
*ctl_api_handle_t
;
135 ///////////////////////////////////////////////////////////////////////////////
136 /// @brief Handle of a device adapter instance
137 typedef struct _ctl_device_adapter_handle_t
*ctl_device_adapter_handle_t
;
139 ///////////////////////////////////////////////////////////////////////////////
140 /// @brief Handle of a device temperature sensor
141 typedef struct _ctl_temp_handle_t
*ctl_temp_handle_t
;
143 ///////////////////////////////////////////////////////////////////////////////
144 /// @brief Handle for a device frequency domain
145 typedef struct _ctl_freq_handle_t
*ctl_freq_handle_t
;
147 ///////////////////////////////////////////////////////////////////////////////
148 /// @brief Handle of a power device.
149 typedef struct _ctl_pwr_handle_t
*ctl_pwr_handle_t
;
151 ///////////////////////////////////////////////////////////////////////////////
152 /// @brief Handle of a device fan
153 typedef struct _ctl_fan_handle_t
*ctl_fan_handle_t
;
155 ///////////////////////////////////////////////////////////////////////////////
156 /// @brief Handle of a device memory module
157 typedef struct _ctl_mem_handle_t
*ctl_mem_handle_t
;
159 ///////////////////////////////////////////////////////////////////////////////
160 /// @brief Handle of a device engine group
161 typedef struct _ctl_engine_handle_t
*ctl_engine_handle_t
;
163 ///////////////////////////////////////////////////////////////////////////////
164 /// @brief Base for all properties types
165 typedef struct _ctl_base_interface_t
167 uint32_t Size
; ///< [in] size of this structure
168 uint8_t Version
; ///< [in] version of this structure
170 } ctl_base_interface_t
;
172 ///////////////////////////////////////////////////////////////////////////////
173 /// @brief Value type
174 typedef enum _ctl_property_value_type_t
176 CTL_PROPERTY_VALUE_TYPE_BOOL
= 0, ///< Boolean
177 CTL_PROPERTY_VALUE_TYPE_FLOAT
= 1, ///< Float
178 CTL_PROPERTY_VALUE_TYPE_INT32
= 2, ///< Int32
179 CTL_PROPERTY_VALUE_TYPE_UINT32
= 3, ///< Unsigned Int32
180 CTL_PROPERTY_VALUE_TYPE_ENUM
= 4, ///< Enum
181 CTL_PROPERTY_VALUE_TYPE_CUSTOM
= 5, ///< Custom argument
182 CTL_PROPERTY_VALUE_TYPE_MAX
184 } ctl_property_value_type_t
;
186 ///////////////////////////////////////////////////////////////////////////////
187 /// @brief Property range details, a generic struct to hold min/max/step size
188 /// information of various feature properties
189 typedef struct _ctl_property_range_info_t
191 float min_possible_value
; ///< [out] Minimum possible value
192 float max_possible_value
; ///< [out] Maximum possible value
193 float step_size
; ///< [out] Step size possible
194 float default_value
; ///< [out] Default value
196 } ctl_property_range_info_t
;
198 ///////////////////////////////////////////////////////////////////////////////
199 /// @brief Property range details of integer type, a generic struct to hold
200 /// min/max/step size information of various feature properties
201 typedef struct _ctl_property_range_info_int_t
203 int32_t min_possible_value
; ///< [out] Minimum possible value
204 int32_t max_possible_value
; ///< [out] Maximum possible value
205 int32_t step_size
; ///< [out] Step size possible
206 int32_t default_value
; ///< [out] Default value
208 } ctl_property_range_info_int_t
;
210 ///////////////////////////////////////////////////////////////////////////////
211 /// @brief Property range details of unsigned integer type, a generic struct to
212 /// hold min/max/step size information of various feature properties
213 typedef struct _ctl_property_range_info_uint_t
215 uint32_t min_possible_value
; ///< [out] Minimum possible value
216 uint32_t max_possible_value
; ///< [out] Maximum possible value
217 uint32_t step_size
; ///< [out] Step size possible
218 uint32_t default_value
; ///< [out] Default value
220 } ctl_property_range_info_uint_t
;
222 ///////////////////////////////////////////////////////////////////////////////
223 /// @brief Bool feature details
224 typedef struct _ctl_property_info_boolean_t
226 bool DefaultState
; ///< [out] Default state
228 } ctl_property_info_boolean_t
;
230 ///////////////////////////////////////////////////////////////////////////////
231 /// @brief Bool feature for get/set
232 typedef struct _ctl_property_boolean_t
234 bool Enable
; ///< [in,out] Enable
236 } ctl_property_boolean_t
;
238 ///////////////////////////////////////////////////////////////////////////////
239 /// @brief Enumeration feature details
240 typedef struct _ctl_property_info_enum_t
242 uint64_t SupportedTypes
; ///< [out] Supported possible values represented as a bitmask
243 uint32_t DefaultType
; ///< [out] Default type
245 } ctl_property_info_enum_t
;
247 ///////////////////////////////////////////////////////////////////////////////
248 /// @brief Enumeration feature for get/set
249 typedef struct _ctl_property_enum_t
251 uint32_t EnableType
; ///< [in,out] Enable with specific type
253 } ctl_property_enum_t
;
255 ///////////////////////////////////////////////////////////////////////////////
256 /// @brief Float feature details
257 typedef struct _ctl_property_info_float_t
259 bool DefaultEnable
; ///< [in,out] DefaultEnable
260 ctl_property_range_info_t RangeInfo
; ///< [out] Min/max/default/step details
262 } ctl_property_info_float_t
;
264 ///////////////////////////////////////////////////////////////////////////////
265 /// @brief Float feature for get/set
266 typedef struct _ctl_property_float_t
268 bool Enable
; ///< [in,out] Enable
269 float Value
; ///< [in,out] Value
271 } ctl_property_float_t
;
273 ///////////////////////////////////////////////////////////////////////////////
274 /// @brief Int32 feature details
275 typedef struct _ctl_property_info_int_t
277 bool DefaultEnable
; ///< [in,out] DefaultEnable
278 ctl_property_range_info_int_t RangeInfo
; ///< [out] Min/max/default/step details
280 } ctl_property_info_int_t
;
282 ///////////////////////////////////////////////////////////////////////////////
283 /// @brief Int32 feature for get/set
284 typedef struct _ctl_property_int_t
286 bool Enable
; ///< [in,out] Enable
287 int32_t Value
; ///< [in,out] Value
289 } ctl_property_int_t
;
291 ///////////////////////////////////////////////////////////////////////////////
292 /// @brief Int32 feature details
293 typedef struct _ctl_property_info_uint_t
295 bool DefaultEnable
; ///< [in,out] DefaultEnable
296 ctl_property_range_info_uint_t RangeInfo
; ///< [out] Min/max/default/step details
298 } ctl_property_info_uint_t
;
300 ///////////////////////////////////////////////////////////////////////////////
301 /// @brief Int32 feature for get/set
302 typedef struct _ctl_property_uint_t
304 bool Enable
; ///< [in,out] Enable
305 uint32_t Value
; ///< [in,out] Value
307 } ctl_property_uint_t
;
309 ///////////////////////////////////////////////////////////////////////////////
310 /// @brief Feature element details, union of bool/float/enum property_info
311 /// structs. Used for feature specific capability check
312 typedef union _ctl_property_info_t
314 ctl_property_info_boolean_t BoolType
; ///< [in,out] Boolean type fields
315 ctl_property_info_float_t FloatType
; ///< [in,out] Float type fields
316 ctl_property_info_int_t IntType
; ///< [in,out] Int type fields
317 ctl_property_info_enum_t EnumType
; ///< [in,out] Enum type fields
318 ctl_property_info_uint_t UIntType
; ///< [in,out] Unsigned Int type fields
320 } ctl_property_info_t
;
322 ///////////////////////////////////////////////////////////////////////////////
323 /// @brief Feature element details, union of bool/float/enum property structs.
324 /// Used for get/set calls
325 typedef union _ctl_property_t
327 ctl_property_boolean_t BoolType
; ///< [in,out] Boolean type fields
328 ctl_property_float_t FloatType
; ///< [in,out] Float type fields
329 ctl_property_int_t IntType
; ///< [in,out] Int type fields
330 ctl_property_enum_t EnumType
; ///< [in,out] Enum type fields
331 ctl_property_uint_t UIntType
; ///< [in,out] Unsigned Int type fields
335 ///////////////////////////////////////////////////////////////////////////////
336 /// @brief Defines Return/Error codes.
337 /// All generic error (bit30) codes are between 0x40000000-0x4000FFFF.
338 /// All 3D (bit 29) specific error codes are between 0x60000000-0x6000FFFF.
339 /// All media (bit 28) specific error codes are between 0x50000000-0x5000FFFF.
340 /// All display (bit 27) specific error codes are between 0x48000000-0x4800FFFF
341 /// All core (bit 26) specific error codes are between 0x44000000-0x4400FFFF
342 /// Success result code with additional info are between 0x00000001-0x0000FFFF.
343 typedef enum _ctl_result_t
345 CTL_RESULT_SUCCESS
= 0x00000000, ///< success
346 CTL_RESULT_SUCCESS_STILL_OPEN_BY_ANOTHER_CALLER
= 0x00000001, ///< success but still open by another caller
347 CTL_RESULT_ERROR_SUCCESS_END
= 0x0000FFFF, ///< "Success group error code end value, not to be used
349 CTL_RESULT_ERROR_GENERIC_START
= 0x40000000, ///< Generic error code starting value, not to be used
350 CTL_RESULT_ERROR_NOT_INITIALIZED
= 0x40000001, ///< Result not initialized
351 CTL_RESULT_ERROR_ALREADY_INITIALIZED
= 0x40000002, ///< Already initialized
352 CTL_RESULT_ERROR_DEVICE_LOST
= 0x40000003, ///< Device hung, reset, was removed, or driver update occurred
353 CTL_RESULT_ERROR_OUT_OF_HOST_MEMORY
= 0x40000004, ///< Insufficient host memory to satisfy call
354 CTL_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
= 0x40000005, ///< Insufficient device memory to satisfy call
355 CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
= 0x40000006, ///< Access denied due to permission level
356 CTL_RESULT_ERROR_NOT_AVAILABLE
= 0x40000007, ///< Resource was removed
357 CTL_RESULT_ERROR_UNINITIALIZED
= 0x40000008, ///< Library not initialized
358 CTL_RESULT_ERROR_UNSUPPORTED_VERSION
= 0x40000009, ///< Generic error code for unsupported versions
359 CTL_RESULT_ERROR_UNSUPPORTED_FEATURE
= 0x4000000a, ///< Generic error code for unsupported features
360 CTL_RESULT_ERROR_INVALID_ARGUMENT
= 0x4000000b, ///< Generic error code for invalid arguments
361 CTL_RESULT_ERROR_INVALID_API_HANDLE
= 0x4000000c, ///< API handle in invalid
362 CTL_RESULT_ERROR_INVALID_NULL_HANDLE
= 0x4000000d, ///< Handle argument is not valid
363 CTL_RESULT_ERROR_INVALID_NULL_POINTER
= 0x4000000e, ///< Pointer argument may not be nullptr
364 CTL_RESULT_ERROR_INVALID_SIZE
= 0x4000000f, ///< Size argument is invalid (e.g., must not be zero)
365 CTL_RESULT_ERROR_UNSUPPORTED_SIZE
= 0x40000010, ///< Size argument is not supported by the device (e.g., too large)
366 CTL_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT
= 0x40000011, ///< Image format is not supported by the device
367 CTL_RESULT_ERROR_DATA_READ
= 0x40000012, ///< Data read error
368 CTL_RESULT_ERROR_DATA_WRITE
= 0x40000013, ///< Data write error
369 CTL_RESULT_ERROR_DATA_NOT_FOUND
= 0x40000014, ///< Data not found error
370 CTL_RESULT_ERROR_NOT_IMPLEMENTED
= 0x40000015, ///< Function not implemented
371 CTL_RESULT_ERROR_OS_CALL
= 0x40000016, ///< Operating system call failure
372 CTL_RESULT_ERROR_KMD_CALL
= 0x40000017, ///< Kernel mode driver call failure
373 CTL_RESULT_ERROR_UNLOAD
= 0x40000018, ///< Library unload failure
374 CTL_RESULT_ERROR_ZE_LOADER
= 0x40000019, ///< Level0 loader not found
375 CTL_RESULT_ERROR_INVALID_OPERATION_TYPE
= 0x4000001a, ///< Invalid operation type
376 CTL_RESULT_ERROR_NULL_OS_INTERFACE
= 0x4000001b,///< Null OS interface
377 CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE
= 0x4000001c, ///< Null OS adapter handle
378 CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE
= 0x4000001d,///< Null display output handle
379 CTL_RESULT_ERROR_WAIT_TIMEOUT
= 0x4000001e, ///< Timeout in Wait function
380 CTL_RESULT_ERROR_PERSISTANCE_NOT_SUPPORTED
= 0x4000001f,///< Persistance not supported
381 CTL_RESULT_ERROR_PLATFORM_NOT_SUPPORTED
= 0x40000020, ///< Platform not supported
382 CTL_RESULT_ERROR_UNKNOWN_APPLICATION_UID
= 0x40000021, ///< Unknown Appplicaion UID in Initialization call
383 CTL_RESULT_ERROR_INVALID_ENUMERATION
= 0x40000022, ///< The enum is not valid
384 CTL_RESULT_ERROR_FILE_DELETE
= 0x40000023, ///< Error in file delete operation
385 CTL_RESULT_ERROR_RESET_DEVICE_REQUIRED
= 0x40000024,///< The device requires a reset.
386 CTL_RESULT_ERROR_FULL_REBOOT_REQUIRED
= 0x40000025, ///< The device requires a full reboot.
387 CTL_RESULT_ERROR_LOAD
= 0x40000026, ///< Library load failure
388 CTL_RESULT_ERROR_UNKNOWN
= 0x4000FFFF, ///< Unknown or internal error
389 CTL_RESULT_ERROR_RETRY_OPERATION
= 0x40010000, ///< Operation failed, retry previous operation again
390 CTL_RESULT_ERROR_GENERIC_END
= 0x4000FFFF, ///< "Generic error code end value, not to be used
392 CTL_RESULT_ERROR_CORE_START
= 0x44000000, ///< Core error code starting value, not to be used
393 CTL_RESULT_ERROR_CORE_OVERCLOCK_NOT_SUPPORTED
= 0x44000001, ///< The Overclock is not supported.
394 CTL_RESULT_ERROR_CORE_OVERCLOCK_VOLTAGE_OUTSIDE_RANGE
= 0x44000002, ///< The Voltage exceeds the acceptable min/max.
395 CTL_RESULT_ERROR_CORE_OVERCLOCK_FREQUENCY_OUTSIDE_RANGE
= 0x44000003, ///< The Frequency exceeds the acceptable min/max.
396 CTL_RESULT_ERROR_CORE_OVERCLOCK_POWER_OUTSIDE_RANGE
= 0x44000004, ///< The Power exceeds the acceptable min/max.
397 CTL_RESULT_ERROR_CORE_OVERCLOCK_TEMPERATURE_OUTSIDE_RANGE
= 0x44000005, ///< The Power exceeds the acceptable min/max.
398 CTL_RESULT_ERROR_CORE_OVERCLOCK_IN_VOLTAGE_LOCKED_MODE
= 0x44000006,///< The Overclock is in voltage locked mode.
399 CTL_RESULT_ERROR_CORE_OVERCLOCK_RESET_REQUIRED
= 0x44000007,///< It indicates that the requested change will not be applied until the
400 ///< device is reset.
401 CTL_RESULT_ERROR_CORE_OVERCLOCK_WAIVER_NOT_SET
= 0x44000008,///< The $OverclockWaiverSet function has not been called.
402 CTL_RESULT_ERROR_CORE_END
= 0x0440FFFF, ///< "Core error code end value, not to be used
404 CTL_RESULT_ERROR_3D_START
= 0x60000000, ///< 3D error code starting value, not to be used
405 CTL_RESULT_ERROR_3D_END
= 0x6000FFFF, ///< "3D error code end value, not to be used
407 CTL_RESULT_ERROR_MEDIA_START
= 0x50000000, ///< Media error code starting value, not to be used
408 CTL_RESULT_ERROR_MEDIA_END
= 0x5000FFFF, ///< "Media error code end value, not to be used
410 CTL_RESULT_ERROR_DISPLAY_START
= 0x48000000, ///< Display error code starting value, not to be used
411 CTL_RESULT_ERROR_INVALID_AUX_ACCESS_FLAG
= 0x48000001, ///< Invalid flag for Aux access
412 CTL_RESULT_ERROR_INVALID_SHARPNESS_FILTER_FLAG
= 0x48000002,///< Invalid flag for Sharpness
413 CTL_RESULT_ERROR_DISPLAY_NOT_ATTACHED
= 0x48000003, ///< Error for Display not attached
414 CTL_RESULT_ERROR_DISPLAY_NOT_ACTIVE
= 0x48000004, ///< Error for display attached but not active
415 CTL_RESULT_ERROR_INVALID_POWERFEATURE_OPTIMIZATION_FLAG
= 0x48000005, ///< Error for invalid power optimization flag
416 CTL_RESULT_ERROR_INVALID_POWERSOURCE_TYPE_FOR_DPST
= 0x48000006,///< DPST is supported only in DC Mode
417 CTL_RESULT_ERROR_INVALID_PIXTX_GET_CONFIG_QUERY_TYPE
= 0x48000007, ///< Invalid query type for pixel transformation get configuration
418 CTL_RESULT_ERROR_INVALID_PIXTX_SET_CONFIG_OPERATION_TYPE
= 0x48000008, ///< Invalid operation type for pixel transformation set configuration
419 CTL_RESULT_ERROR_INVALID_SET_CONFIG_NUMBER_OF_SAMPLES
= 0x48000009, ///< Invalid number of samples for pixel transformation set configuration
420 CTL_RESULT_ERROR_INVALID_PIXTX_BLOCK_ID
= 0x4800000a, ///< Invalid block id for pixel transformation
421 CTL_RESULT_ERROR_INVALID_PIXTX_BLOCK_TYPE
= 0x4800000b, ///< Invalid block type for pixel transformation
422 CTL_RESULT_ERROR_INVALID_PIXTX_BLOCK_NUMBER
= 0x4800000c, ///< Invalid block number for pixel transformation
423 CTL_RESULT_ERROR_INSUFFICIENT_PIXTX_BLOCK_CONFIG_MEMORY
= 0x4800000d, ///< Insufficient memery allocated for BlockConfigs
424 CTL_RESULT_ERROR_3DLUT_INVALID_PIPE
= 0x4800000e, ///< Invalid pipe for 3dlut
425 CTL_RESULT_ERROR_3DLUT_INVALID_DATA
= 0x4800000f, ///< Invalid 3dlut data
426 CTL_RESULT_ERROR_3DLUT_NOT_SUPPORTED_IN_HDR
= 0x48000010, ///< 3dlut not supported in HDR
427 CTL_RESULT_ERROR_3DLUT_INVALID_OPERATION
= 0x48000011, ///< Invalid 3dlut operation
428 CTL_RESULT_ERROR_3DLUT_UNSUCCESSFUL
= 0x48000012, ///< 3dlut call unsuccessful
429 CTL_RESULT_ERROR_AUX_DEFER
= 0x48000013, ///< AUX defer failure
430 CTL_RESULT_ERROR_AUX_TIMEOUT
= 0x48000014, ///< AUX timeout failure
431 CTL_RESULT_ERROR_AUX_INCOMPLETE_WRITE
= 0x48000015, ///< AUX incomplete write failure
432 CTL_RESULT_ERROR_I2C_AUX_STATUS_UNKNOWN
= 0x48000016, ///< I2C/AUX unkonown failure
433 CTL_RESULT_ERROR_I2C_AUX_UNSUCCESSFUL
= 0x48000017, ///< I2C/AUX unsuccessful
434 CTL_RESULT_ERROR_LACE_INVALID_DATA_ARGUMENT_PASSED
= 0x48000018,///< Lace Incorrrect AggressivePercent data or LuxVsAggressive Map data
436 CTL_RESULT_ERROR_EXTERNAL_DISPLAY_ATTACHED
= 0x48000019,///< External Display is Attached hence fail the Display Switch
437 CTL_RESULT_ERROR_CUSTOM_MODE_STANDARD_CUSTOM_MODE_EXISTS
= 0x4800001a, ///< Standard custom mode exists
438 CTL_RESULT_ERROR_CUSTOM_MODE_NON_CUSTOM_MATCHING_MODE_EXISTS
= 0x4800001b, ///< Non custom matching mode exists
439 CTL_RESULT_ERROR_CUSTOM_MODE_INSUFFICIENT_MEMORY
= 0x4800001c, ///< Custom mode insufficent memory
440 CTL_RESULT_ERROR_DISPLAY_END
= 0x4800FFFF, ///< "Display error code end value, not to be used
446 ///////////////////////////////////////////////////////////////////////////////
447 #ifndef CTL_MAX_DEVICE_NAME_LEN
448 /// @brief Maximum IPC handle size
449 #define CTL_MAX_DEVICE_NAME_LEN 100
450 #endif // CTL_MAX_DEVICE_NAME_LEN
452 ///////////////////////////////////////////////////////////////////////////////
453 #ifndef CTL_MAX_RESERVED_SIZE
454 /// @brief Maximum reserved size for future members.
455 #define CTL_MAX_RESERVED_SIZE 116
456 #endif // CTL_MAX_RESERVED_SIZE
458 ///////////////////////////////////////////////////////////////////////////////
459 /// @brief General Physical Units.
460 typedef enum _ctl_units_t
462 CTL_UNITS_FREQUENCY_MHZ
= 0, ///< Type is Frequency with units in MHz.
463 CTL_UNITS_OPERATIONS_GTS
= 1, ///< Type is Frequency with units in GT/s (gigatransfers per second).
464 CTL_UNITS_OPERATIONS_MTS
= 2, ///< Type is Frequency with units in MT/s (megatransfers per second).
465 CTL_UNITS_VOLTAGE_VOLTS
= 3, ///< Type is Voltage with units in Volts.
466 CTL_UNITS_POWER_WATTS
= 4, ///< Type is Power with units in Watts.
467 CTL_UNITS_TEMPERATURE_CELSIUS
= 5, ///< Type is Temperature with units in Celsius.
468 CTL_UNITS_ENERGY_JOULES
= 6, ///< Type is Energy with units in Joules.
469 CTL_UNITS_TIME_SECONDS
= 7, ///< Type is Time with units in Seconds.
470 CTL_UNITS_MEMORY_BYTES
= 8, ///< Type is Memory with units in Bytes.
471 CTL_UNITS_ANGULAR_SPEED_RPM
= 9, ///< Type is Angular Speed with units in Revolutions per Minute.
472 CTL_UNITS_UNKNOWN
= 0x4800FFFF, ///< Type of units unknown.
477 ///////////////////////////////////////////////////////////////////////////////
478 /// @brief General Data Types.
479 typedef enum _ctl_data_type_t
481 CTL_DATA_TYPE_INT8
= 0, ///< The data type is 8 bit signed integer.
482 CTL_DATA_TYPE_UINT8
= 1, ///< The data type is 8 bit unsigned integer.
483 CTL_DATA_TYPE_INT16
= 2, ///< The data type is 16 bit signed integer.
484 CTL_DATA_TYPE_UINT16
= 3, ///< The data type is 16 bit unsigned integer.
485 CTL_DATA_TYPE_INT32
= 4, ///< The data type is 32 bit signed integer.
486 CTL_DATA_TYPE_UINT32
= 5, ///< The data type is 32 bit unsigned integer.
487 CTL_DATA_TYPE_INT64
= 6, ///< The data type is 64 bit signed integer.
488 CTL_DATA_TYPE_UINT64
= 7, ///< The data type is 64 bit unsigned integer.
489 CTL_DATA_TYPE_FLOAT
= 8, ///< The data type is 32 bit floating point.
490 CTL_DATA_TYPE_DOUBLE
= 9, ///< The data type is 64 bit floating point.
491 CTL_DATA_TYPE_STRING_ASCII
= 10, ///< The data type is an array of 8 bit unsigned integers.
492 CTL_DATA_TYPE_STRING_UTF16
= 11, ///< The data type is an array of 16 bit unsigned integers.
493 CTL_DATA_TYPE_STRING_UTF132
= 12, ///< The data type is an array of 32 bit unsigned integers.
494 CTL_DATA_TYPE_UNKNOWN
= 0x4800FFFF, ///< The data type is unknown.
499 ///////////////////////////////////////////////////////////////////////////////
500 /// @brief Union for Generic Data.
503 /// - The telemetry data items could be of different types.
504 /// - Refer to ::ctl_data_type_t to find the current type.
505 typedef union _ctl_data_value_t
507 int8_t data8
; ///< [out] The data type is 8 bit signed integer.
508 uint8_t datau8
; ///< [out] The data type is 8 bit unsigned integer.
509 int16_t data16
; ///< [out] The data type is 16 bit signed integer.
510 uint16_t datau16
; ///< [out] The data type is 16 bit unsigned integer.
511 int32_t data32
; ///< [out] The data type is 32 bit signed integer.
512 uint32_t datau32
; ///< [out] The data type is 32 bit unsigned integer.
513 int64_t data64
; ///< [out] The data type is 64 bit signed integer.
514 uint64_t datau64
; ///< [out] The data type is 64 bit unsigned integer.
515 float datafloat
; ///< [out] The data type is 32 bit floating point.
516 double datadouble
; ///< [out] The data type is 64 bit floating point.
520 ///////////////////////////////////////////////////////////////////////////////
521 /// @brief Base for all properties types
522 typedef struct _ctl_base_properties_t
524 uint32_t Size
; ///< [in] size of this structure
525 uint8_t Version
; ///< [in] version of this structure
527 } ctl_base_properties_t
;
529 ///////////////////////////////////////////////////////////////////////////////
530 /// @brief Application Unique ID
531 typedef struct _ctl_application_id_t
533 uint32_t Data1
; ///< [in] Data1
534 uint16_t Data2
; ///< [in] Data2
535 uint16_t Data3
; ///< [in] Data3
536 uint8_t Data4
[8]; ///< [in] Data4
538 } ctl_application_id_t
;
540 ///////////////////////////////////////////////////////////////////////////////
541 /// @brief Init arguments
542 typedef struct _ctl_init_args_t
544 uint32_t Size
; ///< [in] size of this structure
545 uint8_t Version
; ///< [in] version of this structure
546 ctl_version_info_t AppVersion
; ///< [in][release] App's IGCL version
547 ctl_init_flags_t flags
; ///< [in][release] Caller version
548 ctl_version_info_t SupportedVersion
; ///< [out][release] IGCL implementation version
549 ctl_application_id_t ApplicationUID
; ///< [in] Application Provided Unique ID.Application can pass all 0's as
554 ///////////////////////////////////////////////////////////////////////////////
555 /// @brief Reserved struct
556 typedef struct _ctl_reserved_args_t
558 uint32_t Size
; ///< [in] size of this structure
559 uint8_t Version
; ///< [in] version of this structure
560 void* pSpecialArg
; ///< [in] Reserved struct
561 uint32_t ArgSize
; ///< [in] struct size
563 } ctl_reserved_args_t
;
565 ///////////////////////////////////////////////////////////////////////////////
566 /// @brief Reserved base struct
567 typedef struct _ctl_reserved_args_base_t
569 ctl_application_id_t ReservedFuncID
; ///< [in] Unique ID for reserved/special function
571 } ctl_reserved_args_base_t
;
573 ///////////////////////////////////////////////////////////////////////////////
574 /// @brief Reserved - Unlock function capability
575 typedef struct _ctl_unlock_capability_t
577 ctl_application_id_t ReservedFuncID
; ///< [in] Unique ID for reserved/special function
578 ctl_application_id_t UnlockCapsID
; ///< [in] Unique ID to unlock a specific function
580 } ctl_unlock_capability_t
;
582 ///////////////////////////////////////////////////////////////////////////////
583 /// @brief Used by loader like modules to specify runtime implementation details
584 typedef struct _ctl_runtime_path_args_t
586 uint32_t Size
; ///< [in] size of this structure
587 uint8_t Version
; ///< [in] version of this structure
588 ctl_application_id_t UnlockID
; ///< [in] Unique ID for reserved/special function
589 wchar_t* pRuntimePath
; ///< [in] Path to runtime DLL
590 uint16_t DeviceID
; ///< [in] Device ID of interest to caller. pRuntimePath should not be NULL.
591 uint8_t RevID
; ///< [in] Revision ID of interest to caller. pRuntimePath should not be
594 } ctl_runtime_path_args_t
;
596 ///////////////////////////////////////////////////////////////////////////////
597 /// @brief Control Api Init
600 /// - Control Api Init
603 /// - CTL_RESULT_SUCCESS
604 /// - CTL_RESULT_ERROR_UNINITIALIZED
605 /// - CTL_RESULT_ERROR_DEVICE_LOST
606 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
607 /// + `nullptr == pInitDesc`
608 /// + `nullptr == phAPIHandle`
609 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
610 CTL_APIEXPORT ctl_result_t CTL_APICALL
612 ctl_init_args_t
* pInitDesc
, ///< [in][out] App's control API version
613 ctl_api_handle_t
* phAPIHandle
///< [in][out][release] Control API handle
616 ///////////////////////////////////////////////////////////////////////////////
617 /// @brief Control Api Destroy
620 /// - Control Api Close
623 /// - CTL_RESULT_SUCCESS
624 /// - CTL_RESULT_ERROR_UNINITIALIZED
625 /// - CTL_RESULT_ERROR_DEVICE_LOST
626 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
627 /// + `nullptr == hAPIHandle`
628 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
629 CTL_APIEXPORT ctl_result_t CTL_APICALL
631 ctl_api_handle_t hAPIHandle
///< [in][release] Control API implementation handle obtained during init
635 ///////////////////////////////////////////////////////////////////////////////
636 /// @brief Runtime path
639 /// - Control Api set runtime path. Optional call from a loader which allows
640 /// the loaded runtime to enumerate only the adapters which the specified
641 /// runtime is responsible for. This is done usually by a loader or by
642 /// callers who know how to get the specific runtime of interest. This
643 /// call right now is reserved for use by Intel components.
646 /// - CTL_RESULT_SUCCESS
647 /// - CTL_RESULT_ERROR_UNINITIALIZED
648 /// - CTL_RESULT_ERROR_DEVICE_LOST
649 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
650 /// + `nullptr == pArgs`
651 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
652 CTL_APIEXPORT ctl_result_t CTL_APICALL
654 ctl_runtime_path_args_t
* pArgs
///< [in] Runtime path
657 ///////////////////////////////////////////////////////////////////////////////
658 /// @brief Supported Functions
659 typedef uint32_t ctl_supported_functions_flags_t
;
660 typedef enum _ctl_supported_functions_flag_t
662 CTL_SUPPORTED_FUNCTIONS_FLAG_DISPLAY
= CTL_BIT(0), ///< [out] Is Display supported
663 CTL_SUPPORTED_FUNCTIONS_FLAG_3D
= CTL_BIT(1), ///< [out] Is 3D supported
664 CTL_SUPPORTED_FUNCTIONS_FLAG_MEDIA
= CTL_BIT(2),///< [out] Is Media supported
665 CTL_SUPPORTED_FUNCTIONS_FLAG_MAX
= 0x80000000
667 } ctl_supported_functions_flag_t
;
669 ///////////////////////////////////////////////////////////////////////////////
670 /// @brief Firmware version
671 typedef struct _ctl_firmware_version_t
673 uint64_t major_version
; ///< [out] Major version
674 uint64_t minor_version
; ///< [out] Minor version
675 uint64_t build_number
; ///< [out] Build number
677 } ctl_firmware_version_t
;
679 ///////////////////////////////////////////////////////////////////////////////
680 /// @brief DeviceType
681 typedef enum _ctl_device_type_t
683 CTL_DEVICE_TYPE_GRAPHICS
= 1, ///< Graphics Device type
684 CTL_DEVICE_TYPE_SYSTEM
= 2, ///< System Device type
689 ///////////////////////////////////////////////////////////////////////////////
690 /// @brief Adapter Properties
691 typedef uint32_t ctl_adapter_properties_flags_t
;
692 typedef enum _ctl_adapter_properties_flag_t
694 CTL_ADAPTER_PROPERTIES_FLAG_INTEGRATED
= CTL_BIT(0),///< [out] Is Integrated Graphics adapter
695 CTL_ADAPTER_PROPERTIES_FLAG_MAX
= 0x80000000
697 } ctl_adapter_properties_flag_t
;
699 ///////////////////////////////////////////////////////////////////////////////
700 /// @brief Device Adapter properties
701 typedef struct _ctl_device_adapter_properties_t
703 uint32_t Size
; ///< [in] size of this structure
704 uint8_t Version
; ///< [in] version of this structure
705 void* pDeviceID
; ///< [in,out] OS specific Device ID
706 uint32_t device_id_size
; ///< [in] size of the device ID
707 ctl_device_type_t device_type
; ///< [out] Device Type
708 ctl_supported_functions_flags_t supported_subfunction_flags
;///< [out] Supported functions
709 uint64_t driver_version
; ///< [out] Driver version
710 ctl_firmware_version_t firmware_version
; ///< [out] Firmware version
711 uint32_t pci_vendor_id
; ///< [out] PCI Vendor ID
712 uint32_t pci_device_id
; ///< [out] PCI Device ID
713 uint32_t rev_id
; ///< [out] PCI Revision ID
714 uint32_t num_eus_per_sub_slice
; ///< [out] Number of EUs per sub-slice
715 uint32_t num_sub_slices_per_slice
; ///< [out] Number of sub-slices per slice
716 uint32_t num_slices
; ///< [out] Number of slices
717 char name
[CTL_MAX_DEVICE_NAME_LEN
]; ///< [out] Device name
718 ctl_adapter_properties_flags_t graphics_adapter_properties
; ///< [out] Graphics Adapter Properties
719 uint32_t Frequency
; ///< [out] Clock frequency for this device. Supported only for Version > 0
720 uint16_t pci_subsys_id
; ///< [out] PCI SubSys ID, Supported only for Version > 1
721 uint16_t pci_subsys_vendor_id
; ///< [out] PCI SubSys Vendor ID, Supported only for Version > 1
722 char reserved
[CTL_MAX_RESERVED_SIZE
]; ///< [out] Reserved
724 } ctl_device_adapter_properties_t
;
726 ///////////////////////////////////////////////////////////////////////////////
727 /// @brief OperationType
728 typedef enum _ctl_operation_type_t
730 CTL_OPERATION_TYPE_READ
= 1, ///< Read operation
731 CTL_OPERATION_TYPE_WRITE
= 2, ///< Write operation
732 CTL_OPERATION_TYPE_MAX
734 } ctl_operation_type_t
;
736 ///////////////////////////////////////////////////////////////////////////////
737 /// @brief Generic Structure for Void* datatypes
738 typedef struct _ctl_generic_void_datatype_t
740 void* pData
; ///< [in,out]void pointer to memory
741 uint32_t size
; ///< [in,out]size of the allocated memory
743 } ctl_generic_void_datatype_t
;
745 ///////////////////////////////////////////////////////////////////////////////
746 /// @brief Generic Structure for Revision datatypes
747 typedef struct _ctl_revision_datatype_t
749 uint8_t major_version
; ///< [in,out]Major Version
750 uint8_t minor_version
; ///< [in,out]Minor Version
751 uint8_t revision_version
; ///< [in,out]Revision Version
753 } ctl_revision_datatype_t
;
755 ///////////////////////////////////////////////////////////////////////////////
756 /// @brief Property Type flags
757 typedef uint32_t ctl_property_type_flags_t
;
758 typedef enum _ctl_property_type_flag_t
760 CTL_PROPERTY_TYPE_FLAG_DISPLAY
= CTL_BIT(0), ///< Display type. Supported scenarios: Sharpness/gamma/CSC
761 CTL_PROPERTY_TYPE_FLAG_3D
= CTL_BIT(1), ///< 3D type. Supported scenarios: All set calls via IGCL's 3D APIs
762 CTL_PROPERTY_TYPE_FLAG_MEDIA
= CTL_BIT(2), ///< Media type. Supported scenarios: All set calls via IGCL's media APIs
763 CTL_PROPERTY_TYPE_FLAG_CORE
= CTL_BIT(3), ///< For future: Core graphic event types like clocking, frequency etc.
764 CTL_PROPERTY_TYPE_FLAG_MAX
= 0x80000000
766 } ctl_property_type_flag_t
;
768 ///////////////////////////////////////////////////////////////////////////////
769 /// @brief Arguments related to wait for a property change function
770 typedef struct _ctl_wait_property_change_args_t
772 uint32_t Size
; ///< [in] size of this structure
773 uint8_t Version
; ///< [in] version of this structure
774 ctl_property_type_flags_t PropertyType
; ///< [in] Type of the property
775 uint32_t TimeOutMilliSec
; ///< [in][release] Time-out interval in milliseconds. Specify 0xFFFFFFFF if
776 ///< time-out is not desired
777 uint32_t EventMiscFlags
; ///< [in][release] Event flags for future use
778 void* pReserved
; ///< [in][release] Reserved for future use
779 uint64_t ReservedOutFlags
; ///< [out] Reserved out argument for future use
781 } ctl_wait_property_change_args_t
;
783 ///////////////////////////////////////////////////////////////////////////////
784 /// @brief Display orientation (rotation)
785 typedef enum _ctl_display_orientation_t
787 CTL_DISPLAY_ORIENTATION_0
= 0, ///< 0 Degree
788 CTL_DISPLAY_ORIENTATION_90
= 1, ///< 90 Degree
789 CTL_DISPLAY_ORIENTATION_180
= 2, ///< 180 Degree
790 CTL_DISPLAY_ORIENTATION_270
= 3, ///< 270 Degree
791 CTL_DISPLAY_ORIENTATION_MAX
793 } ctl_display_orientation_t
;
795 ///////////////////////////////////////////////////////////////////////////////
797 typedef struct _ctl_rect_t
799 int32_t Left
; ///< [in,out] Left
800 int32_t Top
; ///< [in,out] Top
801 int32_t Right
; ///< [in,out] Right
802 int32_t Bottom
; ///< [in,out] Bottom
806 ///////////////////////////////////////////////////////////////////////////////
807 /// @brief Wait for a property change. Note that this is a blocking call
810 /// - Wait for a property change in display, 3d, media etc.
813 /// - CTL_RESULT_SUCCESS
814 /// - CTL_RESULT_ERROR_UNINITIALIZED
815 /// - CTL_RESULT_ERROR_DEVICE_LOST
816 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
817 /// + `nullptr == hDeviceAdapter`
818 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
819 /// + `nullptr == pArgs`
820 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
821 CTL_APIEXPORT ctl_result_t CTL_APICALL
822 ctlWaitForPropertyChange(
823 ctl_device_adapter_handle_t hDeviceAdapter
, ///< [in][release] handle to control device adapter
824 ctl_wait_property_change_args_t
* pArgs
///< [in] Argument containing information about which property changes to
828 ///////////////////////////////////////////////////////////////////////////////
829 /// @brief Reserved function
832 /// - Reserved function
835 /// - CTL_RESULT_SUCCESS
836 /// - CTL_RESULT_ERROR_UNINITIALIZED
837 /// - CTL_RESULT_ERROR_DEVICE_LOST
838 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
839 /// + `nullptr == hDeviceAdapter`
840 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
841 /// + `nullptr == pArgs`
842 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
843 CTL_APIEXPORT ctl_result_t CTL_APICALL
845 ctl_device_adapter_handle_t hDeviceAdapter
, ///< [in][release] handle to control device adapter
846 ctl_reserved_args_t
* pArgs
///< [in] Argument containing information
849 ///////////////////////////////////////////////////////////////////////////////
850 /// @brief Forward-declare ctl_base_interface_t
851 typedef struct _ctl_base_interface_t ctl_base_interface_t
;
853 ///////////////////////////////////////////////////////////////////////////////
854 /// @brief Forward-declare ctl_property_range_info_t
855 typedef struct _ctl_property_range_info_t ctl_property_range_info_t
;
857 ///////////////////////////////////////////////////////////////////////////////
858 /// @brief Forward-declare ctl_property_range_info_int_t
859 typedef struct _ctl_property_range_info_int_t ctl_property_range_info_int_t
;
861 ///////////////////////////////////////////////////////////////////////////////
862 /// @brief Forward-declare ctl_property_range_info_uint_t
863 typedef struct _ctl_property_range_info_uint_t ctl_property_range_info_uint_t
;
865 ///////////////////////////////////////////////////////////////////////////////
866 /// @brief Forward-declare ctl_property_info_boolean_t
867 typedef struct _ctl_property_info_boolean_t ctl_property_info_boolean_t
;
869 ///////////////////////////////////////////////////////////////////////////////
870 /// @brief Forward-declare ctl_property_boolean_t
871 typedef struct _ctl_property_boolean_t ctl_property_boolean_t
;
873 ///////////////////////////////////////////////////////////////////////////////
874 /// @brief Forward-declare ctl_property_info_enum_t
875 typedef struct _ctl_property_info_enum_t ctl_property_info_enum_t
;
877 ///////////////////////////////////////////////////////////////////////////////
878 /// @brief Forward-declare ctl_property_enum_t
879 typedef struct _ctl_property_enum_t ctl_property_enum_t
;
881 ///////////////////////////////////////////////////////////////////////////////
882 /// @brief Forward-declare ctl_property_info_float_t
883 typedef struct _ctl_property_info_float_t ctl_property_info_float_t
;
885 ///////////////////////////////////////////////////////////////////////////////
886 /// @brief Forward-declare ctl_property_float_t
887 typedef struct _ctl_property_float_t ctl_property_float_t
;
889 ///////////////////////////////////////////////////////////////////////////////
890 /// @brief Forward-declare ctl_property_info_int_t
891 typedef struct _ctl_property_info_int_t ctl_property_info_int_t
;
893 ///////////////////////////////////////////////////////////////////////////////
894 /// @brief Forward-declare ctl_property_int_t
895 typedef struct _ctl_property_int_t ctl_property_int_t
;
897 ///////////////////////////////////////////////////////////////////////////////
898 /// @brief Forward-declare ctl_property_info_uint_t
899 typedef struct _ctl_property_info_uint_t ctl_property_info_uint_t
;
901 ///////////////////////////////////////////////////////////////////////////////
902 /// @brief Forward-declare ctl_property_uint_t
903 typedef struct _ctl_property_uint_t ctl_property_uint_t
;
905 ///////////////////////////////////////////////////////////////////////////////
906 /// @brief Forward-declare ctl_base_properties_t
907 typedef struct _ctl_base_properties_t ctl_base_properties_t
;
909 ///////////////////////////////////////////////////////////////////////////////
910 /// @brief Forward-declare ctl_application_id_t
911 typedef struct _ctl_application_id_t ctl_application_id_t
;
913 ///////////////////////////////////////////////////////////////////////////////
914 /// @brief Forward-declare ctl_init_args_t
915 typedef struct _ctl_init_args_t ctl_init_args_t
;
917 ///////////////////////////////////////////////////////////////////////////////
918 /// @brief Forward-declare ctl_reserved_args_t
919 typedef struct _ctl_reserved_args_t ctl_reserved_args_t
;
921 ///////////////////////////////////////////////////////////////////////////////
922 /// @brief Forward-declare ctl_reserved_args_base_t
923 typedef struct _ctl_reserved_args_base_t ctl_reserved_args_base_t
;
925 ///////////////////////////////////////////////////////////////////////////////
926 /// @brief Forward-declare ctl_unlock_capability_t
927 typedef struct _ctl_unlock_capability_t ctl_unlock_capability_t
;
929 ///////////////////////////////////////////////////////////////////////////////
930 /// @brief Forward-declare ctl_runtime_path_args_t
931 typedef struct _ctl_runtime_path_args_t ctl_runtime_path_args_t
;
933 ///////////////////////////////////////////////////////////////////////////////
934 /// @brief Forward-declare ctl_firmware_version_t
935 typedef struct _ctl_firmware_version_t ctl_firmware_version_t
;
937 ///////////////////////////////////////////////////////////////////////////////
938 /// @brief Forward-declare ctl_device_adapter_properties_t
939 typedef struct _ctl_device_adapter_properties_t ctl_device_adapter_properties_t
;
941 ///////////////////////////////////////////////////////////////////////////////
942 /// @brief Forward-declare ctl_generic_void_datatype_t
943 typedef struct _ctl_generic_void_datatype_t ctl_generic_void_datatype_t
;
945 ///////////////////////////////////////////////////////////////////////////////
946 /// @brief Forward-declare ctl_revision_datatype_t
947 typedef struct _ctl_revision_datatype_t ctl_revision_datatype_t
;
949 ///////////////////////////////////////////////////////////////////////////////
950 /// @brief Forward-declare ctl_wait_property_change_args_t
951 typedef struct _ctl_wait_property_change_args_t ctl_wait_property_change_args_t
;
953 ///////////////////////////////////////////////////////////////////////////////
954 /// @brief Forward-declare ctl_rect_t
955 typedef struct _ctl_rect_t ctl_rect_t
;
957 ///////////////////////////////////////////////////////////////////////////////
958 /// @brief Forward-declare ctl_endurance_gaming_caps_t
959 typedef struct _ctl_endurance_gaming_caps_t ctl_endurance_gaming_caps_t
;
961 ///////////////////////////////////////////////////////////////////////////////
962 /// @brief Forward-declare ctl_endurance_gaming_t
963 typedef struct _ctl_endurance_gaming_t ctl_endurance_gaming_t
;
965 ///////////////////////////////////////////////////////////////////////////////
966 /// @brief Forward-declare ctl_endurance_gaming2_t
967 typedef struct _ctl_endurance_gaming2_t ctl_endurance_gaming2_t
;
969 ///////////////////////////////////////////////////////////////////////////////
970 /// @brief Forward-declare ctl_adaptivesync_caps_t
971 typedef struct _ctl_adaptivesync_caps_t ctl_adaptivesync_caps_t
;
973 ///////////////////////////////////////////////////////////////////////////////
974 /// @brief Forward-declare ctl_adaptivesync_getset_t
975 typedef struct _ctl_adaptivesync_getset_t ctl_adaptivesync_getset_t
;
977 ///////////////////////////////////////////////////////////////////////////////
978 /// @brief Forward-declare ctl_3d_app_profiles_caps_t
979 typedef struct _ctl_3d_app_profiles_caps_t ctl_3d_app_profiles_caps_t
;
981 ///////////////////////////////////////////////////////////////////////////////
982 /// @brief Forward-declare ctl_3d_app_profiles_t
983 typedef struct _ctl_3d_app_profiles_t ctl_3d_app_profiles_t
;
985 ///////////////////////////////////////////////////////////////////////////////
986 /// @brief Forward-declare ctl_3d_tier_details_t
987 typedef struct _ctl_3d_tier_details_t ctl_3d_tier_details_t
;
989 ///////////////////////////////////////////////////////////////////////////////
990 /// @brief Forward-declare ctl_3d_feature_details_t
991 typedef struct _ctl_3d_feature_details_t ctl_3d_feature_details_t
;
993 ///////////////////////////////////////////////////////////////////////////////
994 /// @brief Forward-declare ctl_3d_feature_caps_t
995 typedef struct _ctl_3d_feature_caps_t ctl_3d_feature_caps_t
;
997 ///////////////////////////////////////////////////////////////////////////////
998 /// @brief Forward-declare ctl_3d_feature_getset_t
999 typedef struct _ctl_3d_feature_getset_t ctl_3d_feature_getset_t
;
1001 ///////////////////////////////////////////////////////////////////////////////
1002 /// @brief Forward-declare ctl_kmd_load_features_t
1003 typedef struct _ctl_kmd_load_features_t ctl_kmd_load_features_t
;
1005 ///////////////////////////////////////////////////////////////////////////////
1006 /// @brief Forward-declare ctl_display_timing_t
1007 typedef struct _ctl_display_timing_t ctl_display_timing_t
;
1009 ///////////////////////////////////////////////////////////////////////////////
1010 /// @brief Forward-declare ctl_display_properties_t
1011 typedef struct _ctl_display_properties_t ctl_display_properties_t
;
1013 ///////////////////////////////////////////////////////////////////////////////
1014 /// @brief Forward-declare ctl_adapter_display_encoder_properties_t
1015 typedef struct _ctl_adapter_display_encoder_properties_t ctl_adapter_display_encoder_properties_t
;
1017 ///////////////////////////////////////////////////////////////////////////////
1018 /// @brief Forward-declare ctl_sharpness_filter_properties_t
1019 typedef struct _ctl_sharpness_filter_properties_t ctl_sharpness_filter_properties_t
;
1021 ///////////////////////////////////////////////////////////////////////////////
1022 /// @brief Forward-declare ctl_sharpness_caps_t
1023 typedef struct _ctl_sharpness_caps_t ctl_sharpness_caps_t
;
1025 ///////////////////////////////////////////////////////////////////////////////
1026 /// @brief Forward-declare ctl_sharpness_settings_t
1027 typedef struct _ctl_sharpness_settings_t ctl_sharpness_settings_t
;
1029 ///////////////////////////////////////////////////////////////////////////////
1030 /// @brief Forward-declare ctl_i2c_access_args_t
1031 typedef struct _ctl_i2c_access_args_t ctl_i2c_access_args_t
;
1033 ///////////////////////////////////////////////////////////////////////////////
1034 /// @brief Forward-declare ctl_aux_access_args_t
1035 typedef struct _ctl_aux_access_args_t ctl_aux_access_args_t
;
1037 ///////////////////////////////////////////////////////////////////////////////
1038 /// @brief Forward-declare ctl_power_optimization_caps_t
1039 typedef struct _ctl_power_optimization_caps_t ctl_power_optimization_caps_t
;
1041 ///////////////////////////////////////////////////////////////////////////////
1042 /// @brief Forward-declare ctl_power_optimization_lrr_t
1043 typedef struct _ctl_power_optimization_lrr_t ctl_power_optimization_lrr_t
;
1045 ///////////////////////////////////////////////////////////////////////////////
1046 /// @brief Forward-declare ctl_power_optimization_psr_t
1047 typedef struct _ctl_power_optimization_psr_t ctl_power_optimization_psr_t
;
1049 ///////////////////////////////////////////////////////////////////////////////
1050 /// @brief Forward-declare ctl_power_optimization_dpst_t
1051 typedef struct _ctl_power_optimization_dpst_t ctl_power_optimization_dpst_t
;
1053 ///////////////////////////////////////////////////////////////////////////////
1054 /// @brief Forward-declare ctl_power_optimization_settings_t
1055 typedef struct _ctl_power_optimization_settings_t ctl_power_optimization_settings_t
;
1057 ///////////////////////////////////////////////////////////////////////////////
1058 /// @brief Forward-declare ctl_set_brightness_t
1059 typedef struct _ctl_set_brightness_t ctl_set_brightness_t
;
1061 ///////////////////////////////////////////////////////////////////////////////
1062 /// @brief Forward-declare ctl_get_brightness_t
1063 typedef struct _ctl_get_brightness_t ctl_get_brightness_t
;
1065 ///////////////////////////////////////////////////////////////////////////////
1066 /// @brief Forward-declare ctl_pixtx_color_primaries_t
1067 typedef struct _ctl_pixtx_color_primaries_t ctl_pixtx_color_primaries_t
;
1069 ///////////////////////////////////////////////////////////////////////////////
1070 /// @brief Forward-declare ctl_pixtx_pixel_format_t
1071 typedef struct _ctl_pixtx_pixel_format_t ctl_pixtx_pixel_format_t
;
1073 ///////////////////////////////////////////////////////////////////////////////
1074 /// @brief Forward-declare ctl_pixtx_1dlut_config_t
1075 typedef struct _ctl_pixtx_1dlut_config_t ctl_pixtx_1dlut_config_t
;
1077 ///////////////////////////////////////////////////////////////////////////////
1078 /// @brief Forward-declare ctl_pixtx_matrix_config_t
1079 typedef struct _ctl_pixtx_matrix_config_t ctl_pixtx_matrix_config_t
;
1081 ///////////////////////////////////////////////////////////////////////////////
1082 /// @brief Forward-declare ctl_pixtx_3dlut_sample_t
1083 typedef struct _ctl_pixtx_3dlut_sample_t ctl_pixtx_3dlut_sample_t
;
1085 ///////////////////////////////////////////////////////////////////////////////
1086 /// @brief Forward-declare ctl_pixtx_3dlut_config_t
1087 typedef struct _ctl_pixtx_3dlut_config_t ctl_pixtx_3dlut_config_t
;
1089 ///////////////////////////////////////////////////////////////////////////////
1090 /// @brief Forward-declare ctl_pixtx_block_config_t
1091 typedef struct _ctl_pixtx_block_config_t ctl_pixtx_block_config_t
;
1093 ///////////////////////////////////////////////////////////////////////////////
1094 /// @brief Forward-declare ctl_pixtx_pipe_get_config_t
1095 typedef struct _ctl_pixtx_pipe_get_config_t ctl_pixtx_pipe_get_config_t
;
1097 ///////////////////////////////////////////////////////////////////////////////
1098 /// @brief Forward-declare ctl_pixtx_pipe_set_config_t
1099 typedef struct _ctl_pixtx_pipe_set_config_t ctl_pixtx_pipe_set_config_t
;
1101 ///////////////////////////////////////////////////////////////////////////////
1102 /// @brief Forward-declare ctl_panel_descriptor_access_args_t
1103 typedef struct _ctl_panel_descriptor_access_args_t ctl_panel_descriptor_access_args_t
;
1105 ///////////////////////////////////////////////////////////////////////////////
1106 /// @brief Forward-declare ctl_retro_scaling_settings_t
1107 typedef struct _ctl_retro_scaling_settings_t ctl_retro_scaling_settings_t
;
1109 ///////////////////////////////////////////////////////////////////////////////
1110 /// @brief Forward-declare ctl_retro_scaling_caps_t
1111 typedef struct _ctl_retro_scaling_caps_t ctl_retro_scaling_caps_t
;
1113 ///////////////////////////////////////////////////////////////////////////////
1114 /// @brief Forward-declare ctl_scaling_caps_t
1115 typedef struct _ctl_scaling_caps_t ctl_scaling_caps_t
;
1117 ///////////////////////////////////////////////////////////////////////////////
1118 /// @brief Forward-declare ctl_scaling_settings_t
1119 typedef struct _ctl_scaling_settings_t ctl_scaling_settings_t
;
1121 ///////////////////////////////////////////////////////////////////////////////
1122 /// @brief Forward-declare ctl_lace_lux_aggr_map_entry_t
1123 typedef struct _ctl_lace_lux_aggr_map_entry_t ctl_lace_lux_aggr_map_entry_t
;
1125 ///////////////////////////////////////////////////////////////////////////////
1126 /// @brief Forward-declare ctl_lace_lux_aggr_map_t
1127 typedef struct _ctl_lace_lux_aggr_map_t ctl_lace_lux_aggr_map_t
;
1129 ///////////////////////////////////////////////////////////////////////////////
1130 /// @brief Forward-declare ctl_lace_config_t
1131 typedef struct _ctl_lace_config_t ctl_lace_config_t
;
1133 ///////////////////////////////////////////////////////////////////////////////
1134 /// @brief Forward-declare ctl_sw_psr_settings_t
1135 typedef struct _ctl_sw_psr_settings_t ctl_sw_psr_settings_t
;
1137 ///////////////////////////////////////////////////////////////////////////////
1138 /// @brief Forward-declare ctl_intel_arc_sync_monitor_params_t
1139 typedef struct _ctl_intel_arc_sync_monitor_params_t ctl_intel_arc_sync_monitor_params_t
;
1141 ///////////////////////////////////////////////////////////////////////////////
1142 /// @brief Forward-declare ctl_mux_properties_t
1143 typedef struct _ctl_mux_properties_t ctl_mux_properties_t
;
1145 ///////////////////////////////////////////////////////////////////////////////
1146 /// @brief Forward-declare ctl_intel_arc_sync_profile_params_t
1147 typedef struct _ctl_intel_arc_sync_profile_params_t ctl_intel_arc_sync_profile_params_t
;
1149 ///////////////////////////////////////////////////////////////////////////////
1150 /// @brief Forward-declare ctl_edid_management_args_t
1151 typedef struct _ctl_edid_management_args_t ctl_edid_management_args_t
;
1153 ///////////////////////////////////////////////////////////////////////////////
1154 /// @brief Forward-declare ctl_get_set_custom_mode_args_t
1155 typedef struct _ctl_get_set_custom_mode_args_t ctl_get_set_custom_mode_args_t
;
1157 ///////////////////////////////////////////////////////////////////////////////
1158 /// @brief Forward-declare ctl_custom_src_mode_t
1159 typedef struct _ctl_custom_src_mode_t ctl_custom_src_mode_t
;
1161 ///////////////////////////////////////////////////////////////////////////////
1162 /// @brief Forward-declare ctl_child_display_target_mode_t
1163 typedef struct _ctl_child_display_target_mode_t ctl_child_display_target_mode_t
;
1165 ///////////////////////////////////////////////////////////////////////////////
1166 /// @brief Forward-declare ctl_combined_display_child_info_t
1167 typedef struct _ctl_combined_display_child_info_t ctl_combined_display_child_info_t
;
1169 ///////////////////////////////////////////////////////////////////////////////
1170 /// @brief Forward-declare ctl_combined_display_args_t
1171 typedef struct _ctl_combined_display_args_t ctl_combined_display_args_t
;
1173 ///////////////////////////////////////////////////////////////////////////////
1174 /// @brief Forward-declare ctl_genlock_display_info_t
1175 typedef struct _ctl_genlock_display_info_t ctl_genlock_display_info_t
;
1177 ///////////////////////////////////////////////////////////////////////////////
1178 /// @brief Forward-declare ctl_genlock_target_mode_list_t
1179 typedef struct _ctl_genlock_target_mode_list_t ctl_genlock_target_mode_list_t
;
1181 ///////////////////////////////////////////////////////////////////////////////
1182 /// @brief Forward-declare ctl_genlock_topology_t
1183 typedef struct _ctl_genlock_topology_t ctl_genlock_topology_t
;
1185 ///////////////////////////////////////////////////////////////////////////////
1186 /// @brief Forward-declare ctl_genlock_args_t
1187 typedef struct _ctl_genlock_args_t ctl_genlock_args_t
;
1189 ///////////////////////////////////////////////////////////////////////////////
1190 /// @brief Forward-declare ctl_engine_properties_t
1191 typedef struct _ctl_engine_properties_t ctl_engine_properties_t
;
1193 ///////////////////////////////////////////////////////////////////////////////
1194 /// @brief Forward-declare ctl_engine_stats_t
1195 typedef struct _ctl_engine_stats_t ctl_engine_stats_t
;
1197 ///////////////////////////////////////////////////////////////////////////////
1198 /// @brief Forward-declare ctl_fan_speed_t
1199 typedef struct _ctl_fan_speed_t ctl_fan_speed_t
;
1201 ///////////////////////////////////////////////////////////////////////////////
1202 /// @brief Forward-declare ctl_fan_temp_speed_t
1203 typedef struct _ctl_fan_temp_speed_t ctl_fan_temp_speed_t
;
1205 ///////////////////////////////////////////////////////////////////////////////
1206 /// @brief Forward-declare ctl_fan_speed_table_t
1207 typedef struct _ctl_fan_speed_table_t ctl_fan_speed_table_t
;
1209 ///////////////////////////////////////////////////////////////////////////////
1210 /// @brief Forward-declare ctl_fan_properties_t
1211 typedef struct _ctl_fan_properties_t ctl_fan_properties_t
;
1213 ///////////////////////////////////////////////////////////////////////////////
1214 /// @brief Forward-declare ctl_fan_config_t
1215 typedef struct _ctl_fan_config_t ctl_fan_config_t
;
1217 ///////////////////////////////////////////////////////////////////////////////
1218 /// @brief Forward-declare ctl_freq_properties_t
1219 typedef struct _ctl_freq_properties_t ctl_freq_properties_t
;
1221 ///////////////////////////////////////////////////////////////////////////////
1222 /// @brief Forward-declare ctl_freq_range_t
1223 typedef struct _ctl_freq_range_t ctl_freq_range_t
;
1225 ///////////////////////////////////////////////////////////////////////////////
1226 /// @brief Forward-declare ctl_freq_state_t
1227 typedef struct _ctl_freq_state_t ctl_freq_state_t
;
1229 ///////////////////////////////////////////////////////////////////////////////
1230 /// @brief Forward-declare ctl_freq_throttle_time_t
1231 typedef struct _ctl_freq_throttle_time_t ctl_freq_throttle_time_t
;
1233 ///////////////////////////////////////////////////////////////////////////////
1234 /// @brief Forward-declare ctl_video_processing_super_resolution_info_t
1235 typedef struct _ctl_video_processing_super_resolution_info_t ctl_video_processing_super_resolution_info_t
;
1237 ///////////////////////////////////////////////////////////////////////////////
1238 /// @brief Forward-declare ctl_video_processing_super_resolution_t
1239 typedef struct _ctl_video_processing_super_resolution_t ctl_video_processing_super_resolution_t
;
1241 ///////////////////////////////////////////////////////////////////////////////
1242 /// @brief Forward-declare ctl_video_processing_noise_reduction_info_t
1243 typedef struct _ctl_video_processing_noise_reduction_info_t ctl_video_processing_noise_reduction_info_t
;
1245 ///////////////////////////////////////////////////////////////////////////////
1246 /// @brief Forward-declare ctl_video_processing_noise_reduction_t
1247 typedef struct _ctl_video_processing_noise_reduction_t ctl_video_processing_noise_reduction_t
;
1249 ///////////////////////////////////////////////////////////////////////////////
1250 /// @brief Forward-declare ctl_video_processing_adaptive_contrast_enhancement_info_t
1251 typedef struct _ctl_video_processing_adaptive_contrast_enhancement_info_t ctl_video_processing_adaptive_contrast_enhancement_info_t
;
1253 ///////////////////////////////////////////////////////////////////////////////
1254 /// @brief Forward-declare ctl_video_processing_adaptive_contrast_enhancement_t
1255 typedef struct _ctl_video_processing_adaptive_contrast_enhancement_t ctl_video_processing_adaptive_contrast_enhancement_t
;
1257 ///////////////////////////////////////////////////////////////////////////////
1258 /// @brief Forward-declare ctl_video_processing_standard_color_correction_info_t
1259 typedef struct _ctl_video_processing_standard_color_correction_info_t ctl_video_processing_standard_color_correction_info_t
;
1261 ///////////////////////////////////////////////////////////////////////////////
1262 /// @brief Forward-declare ctl_video_processing_standard_color_correction_t
1263 typedef struct _ctl_video_processing_standard_color_correction_t ctl_video_processing_standard_color_correction_t
;
1265 ///////////////////////////////////////////////////////////////////////////////
1266 /// @brief Forward-declare ctl_video_processing_total_color_correction_info_t
1267 typedef struct _ctl_video_processing_total_color_correction_info_t ctl_video_processing_total_color_correction_info_t
;
1269 ///////////////////////////////////////////////////////////////////////////////
1270 /// @brief Forward-declare ctl_video_processing_total_color_correction_t
1271 typedef struct _ctl_video_processing_total_color_correction_t ctl_video_processing_total_color_correction_t
;
1273 ///////////////////////////////////////////////////////////////////////////////
1274 /// @brief Forward-declare ctl_video_processing_feature_details_t
1275 typedef struct _ctl_video_processing_feature_details_t ctl_video_processing_feature_details_t
;
1277 ///////////////////////////////////////////////////////////////////////////////
1278 /// @brief Forward-declare ctl_video_processing_feature_caps_t
1279 typedef struct _ctl_video_processing_feature_caps_t ctl_video_processing_feature_caps_t
;
1281 ///////////////////////////////////////////////////////////////////////////////
1282 /// @brief Forward-declare ctl_video_processing_feature_getset_t
1283 typedef struct _ctl_video_processing_feature_getset_t ctl_video_processing_feature_getset_t
;
1285 ///////////////////////////////////////////////////////////////////////////////
1286 /// @brief Forward-declare ctl_mem_properties_t
1287 typedef struct _ctl_mem_properties_t ctl_mem_properties_t
;
1289 ///////////////////////////////////////////////////////////////////////////////
1290 /// @brief Forward-declare ctl_mem_state_t
1291 typedef struct _ctl_mem_state_t ctl_mem_state_t
;
1293 ///////////////////////////////////////////////////////////////////////////////
1294 /// @brief Forward-declare ctl_mem_bandwidth_t
1295 typedef struct _ctl_mem_bandwidth_t ctl_mem_bandwidth_t
;
1297 ///////////////////////////////////////////////////////////////////////////////
1298 /// @brief Forward-declare ctl_oc_telemetry_item_t
1299 typedef struct _ctl_oc_telemetry_item_t ctl_oc_telemetry_item_t
;
1301 ///////////////////////////////////////////////////////////////////////////////
1302 /// @brief Forward-declare ctl_oc_control_info_t
1303 typedef struct _ctl_oc_control_info_t ctl_oc_control_info_t
;
1305 ///////////////////////////////////////////////////////////////////////////////
1306 /// @brief Forward-declare ctl_oc_properties_t
1307 typedef struct _ctl_oc_properties_t ctl_oc_properties_t
;
1309 ///////////////////////////////////////////////////////////////////////////////
1310 /// @brief Forward-declare ctl_oc_vf_pair_t
1311 typedef struct _ctl_oc_vf_pair_t ctl_oc_vf_pair_t
;
1313 ///////////////////////////////////////////////////////////////////////////////
1314 /// @brief Forward-declare ctl_psu_info_t
1315 typedef struct _ctl_psu_info_t ctl_psu_info_t
;
1317 ///////////////////////////////////////////////////////////////////////////////
1318 /// @brief Forward-declare ctl_power_telemetry_t
1319 typedef struct _ctl_power_telemetry_t ctl_power_telemetry_t
;
1321 ///////////////////////////////////////////////////////////////////////////////
1322 /// @brief Forward-declare ctl_pci_address_t
1323 typedef struct _ctl_pci_address_t ctl_pci_address_t
;
1325 ///////////////////////////////////////////////////////////////////////////////
1326 /// @brief Forward-declare ctl_pci_speed_t
1327 typedef struct _ctl_pci_speed_t ctl_pci_speed_t
;
1329 ///////////////////////////////////////////////////////////////////////////////
1330 /// @brief Forward-declare ctl_pci_properties_t
1331 typedef struct _ctl_pci_properties_t ctl_pci_properties_t
;
1333 ///////////////////////////////////////////////////////////////////////////////
1334 /// @brief Forward-declare ctl_pci_state_t
1335 typedef struct _ctl_pci_state_t ctl_pci_state_t
;
1337 ///////////////////////////////////////////////////////////////////////////////
1338 /// @brief Forward-declare ctl_power_properties_t
1339 typedef struct _ctl_power_properties_t ctl_power_properties_t
;
1341 ///////////////////////////////////////////////////////////////////////////////
1342 /// @brief Forward-declare ctl_power_energy_counter_t
1343 typedef struct _ctl_power_energy_counter_t ctl_power_energy_counter_t
;
1345 ///////////////////////////////////////////////////////////////////////////////
1346 /// @brief Forward-declare ctl_power_sustained_limit_t
1347 typedef struct _ctl_power_sustained_limit_t ctl_power_sustained_limit_t
;
1349 ///////////////////////////////////////////////////////////////////////////////
1350 /// @brief Forward-declare ctl_power_burst_limit_t
1351 typedef struct _ctl_power_burst_limit_t ctl_power_burst_limit_t
;
1353 ///////////////////////////////////////////////////////////////////////////////
1354 /// @brief Forward-declare ctl_power_peak_limit_t
1355 typedef struct _ctl_power_peak_limit_t ctl_power_peak_limit_t
;
1357 ///////////////////////////////////////////////////////////////////////////////
1358 /// @brief Forward-declare ctl_power_limits_t
1359 typedef struct _ctl_power_limits_t ctl_power_limits_t
;
1361 ///////////////////////////////////////////////////////////////////////////////
1362 /// @brief Forward-declare ctl_energy_threshold_t
1363 typedef struct _ctl_energy_threshold_t ctl_energy_threshold_t
;
1365 ///////////////////////////////////////////////////////////////////////////////
1366 /// @brief Forward-declare ctl_temp_properties_t
1367 typedef struct _ctl_temp_properties_t ctl_temp_properties_t
;
1371 #if !defined(__GNUC__)
1372 #pragma endregion // common
1374 // Intel 'ctlApi' for Device Adapter
1375 #if !defined(__GNUC__)
1378 ///////////////////////////////////////////////////////////////////////////////
1379 /// @brief Feature type
1380 typedef enum _ctl_3d_feature_t
1382 CTL_3D_FEATURE_FRAME_PACING
= 0, ///< Frame pacing. Contains generic enum type fields
1383 CTL_3D_FEATURE_ENDURANCE_GAMING
= 1, ///< Endurance gaming. Contains generic integer type fields. Value will be
1384 ///< interpreted as the max FPS to be used when in DC mode globally or per
1386 CTL_3D_FEATURE_FRAME_LIMIT
= 2, ///< Frame limit for games. Contains generic integer type fields. Value
1387 ///< will be interpreted as the max FPS to be used independent of system
1389 CTL_3D_FEATURE_ANISOTROPIC
= 3, ///< ANISOTROPIC. Contains generic enum type fields
1390 CTL_3D_FEATURE_CMAA
= 4, ///< CMAA. Contains generic enum type fields
1391 CTL_3D_FEATURE_TEXTURE_FILTERING_QUALITY
= 5, ///< Texture filtering quality. Contains generic enum type fields
1392 CTL_3D_FEATURE_ADAPTIVE_TESSELLATION
= 6, ///< Adaptive tessellation quality. Contains generic integer type fields
1393 CTL_3D_FEATURE_SHARPENING_FILTER
= 7, ///< Sharpening Filter. Contains generic integer type fields
1394 CTL_3D_FEATURE_MSAA
= 8, ///< Msaa. Contains generic enum type fields
1395 CTL_3D_FEATURE_GAMING_FLIP_MODES
= 9, ///< Various Gaming flip modes like speed frame, smooth sync & force async
1396 ///< flip. Contains generic enum type fields
1397 CTL_3D_FEATURE_ADAPTIVE_SYNC_PLUS
= 10, ///< Adaptive sync plus. Refer custom field ::ctl_adaptivesync_caps_t &
1398 ///< ::ctl_adaptivesync_getset_t
1399 CTL_3D_FEATURE_APP_PROFILES
= 11, ///< Game Compatibility & Performance Profiles. Refer custom field
1400 ///< ::ctl_3d_app_profiles_caps_t & ::ctl_3d_app_profiles_t
1401 CTL_3D_FEATURE_APP_PROFILE_DETAILS
= 12, ///< Game Profile Customization. Refer custom field ::ctl_3d_tier_details_t
1402 CTL_3D_FEATURE_EMULATED_TYPED_64BIT_ATOMICS
= 13, ///< Emulated Typed 64bit Atomics support in DG2
1407 ///////////////////////////////////////////////////////////////////////////////
1408 /// @brief 3D feature misc flags
1409 typedef uint32_t ctl_3d_feature_misc_flags_t
;
1410 typedef enum _ctl_3d_feature_misc_flag_t
1412 CTL_3D_FEATURE_MISC_FLAG_DX11
= CTL_BIT(0), ///< Feature supported on DX11
1413 CTL_3D_FEATURE_MISC_FLAG_DX12
= CTL_BIT(1), ///< Feature supported on DX12
1414 CTL_3D_FEATURE_MISC_FLAG_VULKAN
= CTL_BIT(2), ///< Feature supported on VULKAN
1415 CTL_3D_FEATURE_MISC_FLAG_LIVE_CHANGE
= CTL_BIT(3), ///< User can change feature live without restarting the game
1416 CTL_3D_FEATURE_MISC_FLAG_MAX
= 0x80000000
1418 } ctl_3d_feature_misc_flag_t
;
1420 ///////////////////////////////////////////////////////////////////////////////
1421 /// @brief Anisotropic values possible
1422 typedef enum _ctl_3d_anisotropic_types_t
1424 CTL_3D_ANISOTROPIC_TYPES_APP_CHOICE
= 0, ///< Application choice
1425 CTL_3D_ANISOTROPIC_TYPES_2X
= 2, ///< 2X
1426 CTL_3D_ANISOTROPIC_TYPES_4X
= 4, ///< 4X
1427 CTL_3D_ANISOTROPIC_TYPES_8X
= 8, ///< 8X
1428 CTL_3D_ANISOTROPIC_TYPES_16X
= 16, ///< 16X
1429 CTL_3D_ANISOTROPIC_TYPES_MAX
1431 } ctl_3d_anisotropic_types_t
;
1433 ///////////////////////////////////////////////////////////////////////////////
1434 /// @brief Texture filtering values possible
1435 typedef enum _ctl_3d_texture_filtering_quality_types_t
1437 CTL_3D_TEXTURE_FILTERING_QUALITY_TYPES_PERFORMANCE
= 0, ///< Performance
1438 CTL_3D_TEXTURE_FILTERING_QUALITY_TYPES_BALANCED
= 1,///< Balanced
1439 CTL_3D_TEXTURE_FILTERING_QUALITY_TYPES_QUALITY
= 2, ///< Quality
1440 CTL_3D_TEXTURE_FILTERING_QUALITY_TYPES_MAX
1442 } ctl_3d_texture_filtering_quality_types_t
;
1444 ///////////////////////////////////////////////////////////////////////////////
1445 /// @brief Frame pacing values possible
1446 typedef enum _ctl_3d_frame_pacing_types_t
1448 CTL_3D_FRAME_PACING_TYPES_DISABLE
= 0, ///< Disable
1449 CTL_3D_FRAME_PACING_TYPES_ENABLE_MODE_FRAME_NO_SMOOTHENING
= 1, ///< Enable with scheduler without any frame smoothening
1450 CTL_3D_FRAME_PACING_TYPES_ENABLE_MODE_FRAME_MAX_SMOOTHENING
= 2,///< Enable with scheduler with maximum smoothness
1451 CTL_3D_FRAME_PACING_TYPES_ENABLE_MODE_COMPETITIVE_GAMING
= 3, ///< Enable with scheduler in competitive gaming mode
1452 CTL_3D_FRAME_PACING_TYPES_MAX
1454 } ctl_3d_frame_pacing_types_t
;
1456 ///////////////////////////////////////////////////////////////////////////////
1457 /// @brief Endurance Gaming control possible
1458 typedef enum _ctl_3d_endurance_gaming_control_t
1460 CTL_3D_ENDURANCE_GAMING_CONTROL_TURN_OFF
= 0, ///< Endurance Gaming disable
1461 CTL_3D_ENDURANCE_GAMING_CONTROL_TURN_ON
= 1, ///< Endurance Gaming enable
1462 CTL_3D_ENDURANCE_GAMING_CONTROL_AUTO
= 2, ///< Endurance Gaming auto
1463 CTL_3D_ENDURANCE_GAMING_CONTROL_MAX
1465 } ctl_3d_endurance_gaming_control_t
;
1467 ///////////////////////////////////////////////////////////////////////////////
1468 /// @brief Endurance Gaming modes possible
1469 typedef enum _ctl_3d_endurance_gaming_mode_t
1471 CTL_3D_ENDURANCE_GAMING_MODE_BETTER_PERFORMANCE
= 0,///< Endurance Gaming better performance mode
1472 CTL_3D_ENDURANCE_GAMING_MODE_BALANCED
= 1, ///< Endurance Gaming balanced mode
1473 CTL_3D_ENDURANCE_GAMING_MODE_MAXIMUM_BATTERY
= 2, ///< Endurance Gaming maximum battery mode
1474 CTL_3D_ENDURANCE_GAMING_MODE_MAX
1476 } ctl_3d_endurance_gaming_mode_t
;
1478 ///////////////////////////////////////////////////////////////////////////////
1479 /// @brief Cmaa values possible
1480 typedef enum _ctl_3d_cmaa_types_t
1482 CTL_3D_CMAA_TYPES_TURN_OFF
= 0, ///< Turn off
1483 CTL_3D_CMAA_TYPES_OVERRIDE_MSAA
= 1, ///< Override MSAA
1484 CTL_3D_CMAA_TYPES_ENHANCE_APPLICATION
= 2, ///< Enhance Application
1485 CTL_3D_CMAA_TYPES_MAX
1487 } ctl_3d_cmaa_types_t
;
1489 ///////////////////////////////////////////////////////////////////////////////
1490 /// @brief Adaptive Tessellation
1491 typedef enum _ctl_3d_adaptive_tessellation_types_t
1493 CTL_3D_ADAPTIVE_TESSELLATION_TYPES_TURN_OFF
= 0,///< Turn off
1494 CTL_3D_ADAPTIVE_TESSELLATION_TYPES_TURN_ON
= 1, ///< Turn on
1495 CTL_3D_ADAPTIVE_TESSELLATION_TYPES_MAX
1497 } ctl_3d_adaptive_tessellation_types_t
;
1499 ///////////////////////////////////////////////////////////////////////////////
1500 /// @brief Sharpening filter values possible
1501 typedef enum _ctl_3d_sharpening_filter_types_t
1503 CTL_3D_SHARPENING_FILTER_TYPES_TURN_OFF
= 0, ///< Turn off
1504 CTL_3D_SHARPENING_FILTER_TYPES_TURN_ON
= 1, ///< Turn on
1505 CTL_3D_SHARPENING_FILTER_TYPES_MAX
1507 } ctl_3d_sharpening_filter_types_t
;
1509 ///////////////////////////////////////////////////////////////////////////////
1510 /// @brief MSAA values possible
1511 typedef enum _ctl_3d_msaa_types_t
1513 CTL_3D_MSAA_TYPES_APP_CHOICE
= 0, ///< Application choice
1514 CTL_3D_MSAA_TYPES_DISABLED
= 1, ///< Disabled. MSAA count 1
1515 CTL_3D_MSAA_TYPES_2X
= 2, ///< 2X
1516 CTL_3D_MSAA_TYPES_4X
= 4, ///< 4X
1517 CTL_3D_MSAA_TYPES_8X
= 8, ///< 8X
1518 CTL_3D_MSAA_TYPES_16X
= 16, ///< 16X
1519 CTL_3D_MSAA_TYPES_MAX
1521 } ctl_3d_msaa_types_t
;
1523 ///////////////////////////////////////////////////////////////////////////////
1524 /// @brief Gaming flip modes
1525 typedef uint32_t ctl_gaming_flip_mode_flags_t
;
1526 typedef enum _ctl_gaming_flip_mode_flag_t
1528 CTL_GAMING_FLIP_MODE_FLAG_APPLICATION_DEFAULT
= CTL_BIT(0), ///< Application Default
1529 CTL_GAMING_FLIP_MODE_FLAG_VSYNC_OFF
= CTL_BIT(1), ///< Convert all sync flips to async on the next possible scanline.
1530 CTL_GAMING_FLIP_MODE_FLAG_VSYNC_ON
= CTL_BIT(2),///< Convert all async flips to sync flips.
1531 CTL_GAMING_FLIP_MODE_FLAG_SMOOTH_SYNC
= CTL_BIT(3), ///< Reduce tearing effect with async flips
1532 CTL_GAMING_FLIP_MODE_FLAG_SPEED_FRAME
= CTL_BIT(4), ///< Application unaware triple buffering
1533 CTL_GAMING_FLIP_MODE_FLAG_CAPPED_FPS
= CTL_BIT(5), ///< Limit the game FPS to panel RR
1534 CTL_GAMING_FLIP_MODE_FLAG_MAX
= 0x80000000
1536 } ctl_gaming_flip_mode_flag_t
;
1538 ///////////////////////////////////////////////////////////////////////////////
1539 /// @brief Endurance Gaming caps
1540 typedef struct _ctl_endurance_gaming_caps_t
1542 ctl_property_info_enum_t EGControlCaps
; ///< [out] Endurance Gaming control capability
1543 ctl_property_info_enum_t EGModeCaps
; ///< [out] Endurance Gaming mode capability
1545 } ctl_endurance_gaming_caps_t
;
1547 ///////////////////////////////////////////////////////////////////////////////
1548 /// @brief Endurance Gaming Get/Set
1549 typedef struct _ctl_endurance_gaming_t
1551 ctl_3d_endurance_gaming_control_t EGControl
; ///< [in,out] Endurance Gaming control - Off/On/Auto
1552 ctl_3d_endurance_gaming_mode_t EGMode
; ///< [in,out] Endurance Gaming mode - Better Performance/Balanced/Maximum
1555 } ctl_endurance_gaming_t
;
1557 ///////////////////////////////////////////////////////////////////////////////
1558 /// @brief Endurance Gaming version2 Get/Set
1559 typedef struct _ctl_endurance_gaming2_t
1561 ctl_3d_endurance_gaming_control_t EGControl
; ///< [in,out] Endurance Gaming control - Off/On/Auto
1562 ctl_3d_endurance_gaming_mode_t EGMode
; ///< [in,out] Endurance Gaming mode - Better Performance/Balanced/Maximum
1564 bool IsFPRequired
; ///< [out] Is frame pacing required, dynamic state
1565 double TargetFPS
; ///< [out] Target FPS for frame pacing
1566 double RefreshRate
; ///< [out] Refresh rate used to calculate target fps
1567 uint32_t Reserved
[4]; ///< [out] Reserved fields
1569 } ctl_endurance_gaming2_t
;
1571 ///////////////////////////////////////////////////////////////////////////////
1572 /// @brief Adaptive sync plus caps
1573 typedef struct _ctl_adaptivesync_caps_t
1575 bool AdaptiveBalanceSupported
; ///< [out] Adaptive balance supported
1576 ctl_property_info_float_t AdaptiveBalanceStrengthCaps
; ///< [out] Strength of adaptive balance algorithm - min/max/steps/default
1578 } ctl_adaptivesync_caps_t
;
1580 ///////////////////////////////////////////////////////////////////////////////
1581 /// @brief Adaptive sync plus
1582 typedef struct _ctl_adaptivesync_getset_t
1584 bool AdaptiveSync
; ///< [in,out] Adaptive sync. Note that in Windows, OS controls state of
1585 ///< adaptive sync and which game gets the feature using it's own policies
1586 bool AdaptiveBalance
; ///< [in,out] Adaptive balance
1587 bool AllowAsyncForHighFPS
; ///< [in,out] Allow async flips when FPS is higher than max refresh rate of
1589 float AdaptiveBalanceStrength
; ///< [in,out] Adaptive balance strength
1591 } ctl_adaptivesync_getset_t
;
1593 ///////////////////////////////////////////////////////////////////////////////
1594 /// @brief Game tier types
1595 typedef uint32_t ctl_3d_tier_type_flags_t
;
1596 typedef enum _ctl_3d_tier_type_flag_t
1598 CTL_3D_TIER_TYPE_FLAG_COMPATIBILITY
= CTL_BIT(0), ///< Compatibility Tier
1599 CTL_3D_TIER_TYPE_FLAG_PERFORMANCE
= CTL_BIT(1), ///< Performance Tier
1600 CTL_3D_TIER_TYPE_FLAG_MAX
= 0x80000000
1602 } ctl_3d_tier_type_flag_t
;
1604 ///////////////////////////////////////////////////////////////////////////////
1605 /// @brief Game tiers
1606 typedef uint32_t ctl_3d_tier_profile_flags_t
;
1607 typedef enum _ctl_3d_tier_profile_flag_t
1609 CTL_3D_TIER_PROFILE_FLAG_TIER_1
= CTL_BIT(0), ///< Tier 1 Profile
1610 CTL_3D_TIER_PROFILE_FLAG_TIER_2
= CTL_BIT(1), ///< Tier 2 Profile
1611 CTL_3D_TIER_PROFILE_FLAG_TIER_RECOMMENDED
= CTL_BIT(30),///< Recommended Tier Profile. If set other tier values shouldn't be set
1612 CTL_3D_TIER_PROFILE_FLAG_MAX
= 0x80000000
1614 } ctl_3d_tier_profile_flag_t
;
1616 ///////////////////////////////////////////////////////////////////////////////
1617 /// @brief Game Profile Capabilities. Typically these remain the same across
1619 typedef struct _ctl_3d_app_profiles_caps_t
1621 ctl_3d_tier_type_flags_t SupportedTierTypes
; ///< [out] Tier of interest for capability check
1622 uint64_t Reserved
; ///< [in,out] Reserved for future
1624 } ctl_3d_app_profiles_caps_t
;
1626 ///////////////////////////////////////////////////////////////////////////////
1627 /// @brief Game Profile tiers
1628 typedef struct _ctl_3d_app_profiles_t
1630 ctl_3d_tier_type_flag_t TierType
; ///< [in] Tier type
1631 ctl_3d_tier_profile_flags_t SupportedTierProfiles
; ///< [out] Supported tier profiles bitmask
1632 ctl_3d_tier_profile_flags_t DefaultEnabledTierProfiles
; ///< [out] Default tiers which driver will enable if there is no user
1633 ///< specific setting for global or per application
1634 ctl_3d_tier_profile_flags_t CustomizationSupportedTierProfiles
; ///< [out] Tiers supporting customization - reserved for future
1635 ctl_3d_tier_profile_flags_t EnabledTierProfiles
;///< [in,out] Tier profile(s) to be enabled/disabled in the case of a set
1636 ///< call. For a get call this will return the currently enabled tiers
1637 ctl_3d_tier_profile_flags_t CustomizationEnabledTierProfiles
; ///< [in,out] Tier profile(s) which are customized. Caller shall call
1638 ///< ::ctl_3d_tier_details_t to get specifics if any.
1639 uint64_t Reserved
; ///< [in,out] Reserved for future
1641 } ctl_3d_app_profiles_t
;
1643 ///////////////////////////////////////////////////////////////////////////////
1644 /// @brief Game Profile tiers details
1645 typedef struct _ctl_3d_tier_details_t
1647 ctl_3d_tier_type_flag_t TierType
; ///< [in] Tier type
1648 ctl_3d_tier_profile_flag_t TierProfile
; ///< [in] Tier profile(s) for get/set details
1649 uint64_t Reserved
[4]; ///< [in,out] Reserved for future
1651 } ctl_3d_tier_details_t
;
1653 ///////////////////////////////////////////////////////////////////////////////
1654 /// @brief Emulated Typed 64bit Atomics
1655 typedef enum _ctl_emulated_typed_64bit_atomics_types_t
1657 CTL_EMULATED_TYPED_64BIT_ATOMICS_TYPES_DEFAULT
= 0, ///< Default settings is based on workload/driver decision.
1658 CTL_EMULATED_TYPED_64BIT_ATOMICS_TYPES_TURN_ON
= 1, ///< Force Turn on
1659 CTL_EMULATED_TYPED_64BIT_ATOMICS_TYPES_TURN_OFF
= 2,///< Force Turn off
1660 CTL_EMULATED_TYPED_64BIT_ATOMICS_TYPES_MAX
1662 } ctl_emulated_typed_64bit_atomics_types_t
;
1664 ///////////////////////////////////////////////////////////////////////////////
1665 /// @brief 3D feature capability details which will have range/supported and
1667 typedef struct _ctl_3d_feature_details_t
1669 ctl_3d_feature_t FeatureType
; ///< [out] 3D feature type
1670 ctl_property_value_type_t ValueType
; ///< [out] Type of value
1671 ctl_property_info_t Value
; ///< [out] Union of various type of values for 3D features. For enum types
1672 ///< this can be anisotropic/frame pacing etc. This member is valid iff
1673 ///< ValueType is not CTL_PROPERTY_VALUE_TYPE_CUSTOM
1674 int32_t CustomValueSize
; ///< [in] CustomValue buffer size. Typically for a feature requiring custom
1675 ///< struct, caller will know of it upfront and can provide the right size
1677 void* pCustomValue
; ///< [in,out] Pointer to a custom structure. Caller should allocate this
1678 ///< buffer with known custom feature structure size. This member is valid
1679 ///< iff ValueType is CTL_PROPERTY_VALUE_TYPE_CUSTOM
1680 bool PerAppSupport
; ///< [out] Flag indicating whether the feature is supported per application
1682 int64_t ConflictingFeatures
; ///< [out] Mask of ::ctl_3d_feature_t values which can't be enabled along
1683 ///< with the mentioned FeatureType. If this is 0, it meant the feature
1684 ///< doesn't have any conflicts with other features
1685 int16_t FeatureMiscSupport
; ///< [out] 3D Feature Miscellaneous support flags. This will be based on
1686 ///< ::ctl_3d_feature_misc_flags_t
1687 int16_t Reserved
; ///< [out] Reserved
1688 int16_t Reserved1
; ///< [out] Reserved
1689 int16_t Reserved2
; ///< [out] Reserved
1691 } ctl_3d_feature_details_t
;
1693 ///////////////////////////////////////////////////////////////////////////////
1694 /// @brief 3D feature which are controllable
1695 typedef struct _ctl_3d_feature_caps_t
1697 uint32_t Size
; ///< [in] size of this structure
1698 uint8_t Version
; ///< [in] version of this structure
1699 uint32_t NumSupportedFeatures
; ///< [in,out] Number of elements in supported features array
1700 ctl_3d_feature_details_t
* pFeatureDetails
; ///< [in,out] Array of feature details
1702 } ctl_3d_feature_caps_t
;
1704 ///////////////////////////////////////////////////////////////////////////////
1705 /// @brief 3D feature for get/set
1706 typedef struct _ctl_3d_feature_getset_t
1708 uint32_t Size
; ///< [in] size of this structure
1709 uint8_t Version
; ///< [in] version of this structure
1710 ctl_3d_feature_t FeatureType
; ///< [in] Features interested in
1711 char* ApplicationName
; ///< [in] Application name for which the property type is applicable. If
1712 ///< this is an empty string then this will get/set global settings for the
1713 ///< given adapter. Note that this should contain only the name of the
1714 ///< application and not the system specific path
1715 int8_t ApplicationNameLength
; ///< [in] Length of ApplicationName string
1716 bool bSet
; ///< [in] Set this if it's a set call
1717 ctl_property_value_type_t ValueType
; ///< [in] Type of value. Caller has to ensure it provides the right value
1718 ///< type which decides how one read the union structure below
1719 ctl_property_t Value
; ///< [in,out] Union of various type of values for 3D features. For enum
1720 ///< types this can be anisotropic/frame pacing etc. This member is valid
1721 ///< iff ValueType is not CTL_PROPERTY_VALUE_TYPE_CUSTOM
1722 int32_t CustomValueSize
; ///< [in] CustomValue buffer size. Typically for a feature requiring custom
1723 ///< struct, caller will know of it upfront and cn provide the right size
1725 void* pCustomValue
; ///< [in,out] Pointer to a custom structure. Caller should allocate this
1726 ///< buffer with known custom feature structure size. This member is valid
1727 ///< iff ValueType is CTL_PROPERTY_VALUE_TYPE_CUSTOM
1729 } ctl_3d_feature_getset_t
;
1731 ///////////////////////////////////////////////////////////////////////////////
1732 /// @brief Load KMD gaming features. Restricted function
1733 typedef struct _ctl_kmd_load_features_t
1735 ctl_application_id_t ReservedFuncID
; ///< [in] Unique ID for reserved/special function
1736 bool bLoad
; ///< [in] If set, will load known KMD features. If not set will reset known
1737 ///< KMD features to default
1738 int64_t SubsetFeatureMask
; ///< [in,out] Mask indicating the subset of KMD features within
1739 ///< ::ctl_3d_feature_t values. Default of 0 indicate all KMD features
1740 char* ApplicationName
; ///< [in] Application name for which the KMD properties are loaded for. If
1741 ///< this is an empty string then this will load global settings for the
1742 ///< given adapter. Note that this should contain only the name of the
1743 ///< application and not the system specific path
1744 int8_t ApplicationNameLength
; ///< [in] Length of ApplicationName string
1746 } ctl_kmd_load_features_t
;
1748 ///////////////////////////////////////////////////////////////////////////////
1749 /// @brief Get 3D capabilities
1752 /// - The application gets 3D properties
1755 /// - CTL_RESULT_SUCCESS
1756 /// - CTL_RESULT_ERROR_UNINITIALIZED
1757 /// - CTL_RESULT_ERROR_DEVICE_LOST
1758 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
1759 /// + `nullptr == hDAhandle`
1760 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
1761 /// + `nullptr == pFeatureCaps`
1762 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
1763 CTL_APIEXPORT ctl_result_t CTL_APICALL
1764 ctlGetSupported3DCapabilities(
1765 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to display adapter
1766 ctl_3d_feature_caps_t
* pFeatureCaps
///< [in,out][release] 3D properties
1769 ///////////////////////////////////////////////////////////////////////////////
1770 /// @brief Get/Set 3D feature
1773 /// - 3D feature details
1776 /// - CTL_RESULT_SUCCESS
1777 /// - CTL_RESULT_ERROR_UNINITIALIZED
1778 /// - CTL_RESULT_ERROR_DEVICE_LOST
1779 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
1780 /// + `nullptr == hDAhandle`
1781 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
1782 /// + `nullptr == pFeature`
1783 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
1784 CTL_APIEXPORT ctl_result_t CTL_APICALL
1786 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to display adapter
1787 ctl_3d_feature_getset_t
* pFeature
///< [in][release] 3D feature get/set parameter
1791 #if !defined(__GNUC__)
1792 #pragma endregion // 3D
1794 // Intel 'ctlApi' for Device Adapter
1795 #if !defined(__GNUC__)
1796 #pragma region display
1798 ///////////////////////////////////////////////////////////////////////////////
1799 /// @brief Handle of a display output instance
1800 typedef struct _ctl_display_output_handle_t
*ctl_display_output_handle_t
;
1802 ///////////////////////////////////////////////////////////////////////////////
1803 /// @brief Check Driver version
1806 /// - The application checks driver version
1809 /// - CTL_RESULT_SUCCESS
1810 /// - CTL_RESULT_ERROR_UNINITIALIZED
1811 /// - CTL_RESULT_ERROR_DEVICE_LOST
1812 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
1813 /// + `nullptr == hDeviceAdapter`
1814 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
1815 CTL_APIEXPORT ctl_result_t CTL_APICALL
1816 ctlCheckDriverVersion(
1817 ctl_device_adapter_handle_t hDeviceAdapter
, ///< [in][release] handle to control device adapter
1818 ctl_version_info_t version_info
///< [in][release] Driver version info
1821 ///////////////////////////////////////////////////////////////////////////////
1822 /// @brief Enumerate devices
1825 /// - The application enumerates all device adapters in the system
1828 /// - CTL_RESULT_SUCCESS
1829 /// - CTL_RESULT_ERROR_UNINITIALIZED
1830 /// - CTL_RESULT_ERROR_DEVICE_LOST
1831 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
1832 /// + `nullptr == hAPIHandle`
1833 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
1834 /// + `nullptr == pCount`
1835 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
1836 CTL_APIEXPORT ctl_result_t CTL_APICALL
1837 ctlEnumerateDevices(
1838 ctl_api_handle_t hAPIHandle
, ///< [in][release] Applications should pass the Control API handle returned
1839 ///< by the CtlInit function
1840 uint32_t* pCount
, ///< [in,out][release] pointer to the number of device instances. If count
1841 ///< is zero, then the api will update the value with the total
1842 ///< number of drivers available. If count is non-zero, then the api will
1843 ///< only retrieve the number of drivers.
1844 ///< If count is larger than the number of drivers available, then the api
1845 ///< will update the value with the correct number of drivers available.
1846 ctl_device_adapter_handle_t
* phDevices
///< [in,out][optional][release][range(0, *pCount)] array of driver
1847 ///< instance handles
1850 ///////////////////////////////////////////////////////////////////////////////
1851 /// @brief Enumerate display outputs
1854 /// - Enumerates display output capabilities
1857 /// - CTL_RESULT_SUCCESS
1858 /// - CTL_RESULT_ERROR_UNINITIALIZED
1859 /// - CTL_RESULT_ERROR_DEVICE_LOST
1860 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
1861 /// + `nullptr == hDeviceAdapter`
1862 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
1863 /// + `nullptr == pCount`
1864 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
1865 CTL_APIEXPORT ctl_result_t CTL_APICALL
1866 ctlEnumerateDisplayOutputs(
1867 ctl_device_adapter_handle_t hDeviceAdapter
, ///< [in][release] handle to control device adapter
1868 uint32_t* pCount
, ///< [in,out][release] pointer to the number of display output instances.
1869 ///< If count is zero, then the api will update the value with the total
1870 ///< number of outputs available. If count is non-zero, then the api will
1871 ///< only retrieve the number of outputs.
1872 ///< If count is larger than the number of drivers available, then the api
1873 ///< will update the value with the correct number of drivers available.
1874 ctl_display_output_handle_t
* phDisplayOutputs
///< [in,out][optional][release][range(0, *pCount)] array of display output
1875 ///< instance handles
1878 ///////////////////////////////////////////////////////////////////////////////
1879 /// @brief OS specific Display identifiers
1880 typedef union _ctl_os_display_encoder_identifier_t
1882 uint32_t WindowsDisplayEncoderID
; ///< [out] Windows OS Display encoder ID
1883 ctl_generic_void_datatype_t DisplayEncoderID
; ///< [out] Display encoder ID for non-windows OS
1885 } ctl_os_display_encoder_identifier_t
;
1887 ///////////////////////////////////////////////////////////////////////////////
1888 /// @brief Various display types
1889 typedef enum _ctl_display_output_types_t
1891 CTL_DISPLAY_OUTPUT_TYPES_INVALID
= 0, ///< Invalid
1892 CTL_DISPLAY_OUTPUT_TYPES_DISPLAYPORT
= 1, ///< DisplayPort
1893 CTL_DISPLAY_OUTPUT_TYPES_HDMI
= 2, ///< HDMI
1894 CTL_DISPLAY_OUTPUT_TYPES_DVI
= 3, ///< DVI
1895 CTL_DISPLAY_OUTPUT_TYPES_MIPI
= 4, ///< MIPI
1896 CTL_DISPLAY_OUTPUT_TYPES_CRT
= 5, ///< CRT
1897 CTL_DISPLAY_OUTPUT_TYPES_MAX
1899 } ctl_display_output_types_t
;
1901 ///////////////////////////////////////////////////////////////////////////////
1902 /// @brief Supported output bits per color (bpc) bitmasks
1903 typedef uint32_t ctl_output_bpc_flags_t
;
1904 typedef enum _ctl_output_bpc_flag_t
1906 CTL_OUTPUT_BPC_FLAG_6BPC
= CTL_BIT(0), ///< [out] Is 6bpc supported
1907 CTL_OUTPUT_BPC_FLAG_8BPC
= CTL_BIT(1), ///< [out] Is 8bpc supported
1908 CTL_OUTPUT_BPC_FLAG_10BPC
= CTL_BIT(2), ///< [out] Is 10bpc supported
1909 CTL_OUTPUT_BPC_FLAG_12BPC
= CTL_BIT(3), ///< [out] Is 12bpc supported
1910 CTL_OUTPUT_BPC_FLAG_MAX
= 0x80000000
1912 } ctl_output_bpc_flag_t
;
1914 ///////////////////////////////////////////////////////////////////////////////
1915 /// @brief Display output features. This will indicate only the high level
1917 typedef uint32_t ctl_std_display_feature_flags_t
;
1918 typedef enum _ctl_std_display_feature_flag_t
1920 CTL_STD_DISPLAY_FEATURE_FLAG_HDCP
= CTL_BIT(0), ///< [out] Is HDCP supported
1921 CTL_STD_DISPLAY_FEATURE_FLAG_HD_AUDIO
= CTL_BIT(1), ///< [out] Is HD Audio supported
1922 CTL_STD_DISPLAY_FEATURE_FLAG_PSR
= CTL_BIT(2), ///< [out] Is VESA PSR supported
1923 CTL_STD_DISPLAY_FEATURE_FLAG_ADAPTIVESYNC_VRR
= CTL_BIT(3), ///< [out] Is VESA Adaptive Sync or HDMI VRR supported
1924 CTL_STD_DISPLAY_FEATURE_FLAG_VESA_COMPRESSION
= CTL_BIT(4), ///< [out] Is display compression (VESA DSC) supported
1925 CTL_STD_DISPLAY_FEATURE_FLAG_HDR
= CTL_BIT(5), ///< [out] Is HDR supported
1926 CTL_STD_DISPLAY_FEATURE_FLAG_HDMI_QMS
= CTL_BIT(6), ///< [out] Is HDMI QMS supported
1927 CTL_STD_DISPLAY_FEATURE_FLAG_MAX
= 0x80000000
1929 } ctl_std_display_feature_flag_t
;
1931 ///////////////////////////////////////////////////////////////////////////////
1932 /// @brief Advanced Graphics Features provided by Intel Graphics Adapter. This
1933 /// will indicate only the high level capabilities
1934 typedef uint32_t ctl_intel_display_feature_flags_t
;
1935 typedef enum _ctl_intel_display_feature_flag_t
1937 CTL_INTEL_DISPLAY_FEATURE_FLAG_DPST
= CTL_BIT(0), ///< [out] Is DPST supported
1938 CTL_INTEL_DISPLAY_FEATURE_FLAG_LACE
= CTL_BIT(1), ///< [out] Is LACE supported
1939 CTL_INTEL_DISPLAY_FEATURE_FLAG_DRRS
= CTL_BIT(2), ///< [out] Is DRRS supported
1940 CTL_INTEL_DISPLAY_FEATURE_FLAG_MAX
= 0x80000000
1942 } ctl_intel_display_feature_flag_t
;
1944 ///////////////////////////////////////////////////////////////////////////////
1945 /// @brief Attached Display Mux Type
1946 typedef enum _ctl_attached_display_mux_type_t
1948 CTL_ATTACHED_DISPLAY_MUX_TYPE_NATIVE
= 0, ///< [out] Native DP / HDMI
1949 CTL_ATTACHED_DISPLAY_MUX_TYPE_THUNDERBOLT
= 1, ///< [out] Thunderbolt
1950 CTL_ATTACHED_DISPLAY_MUX_TYPE_TYPE_C
= 2, ///< [out] USB Type C
1951 CTL_ATTACHED_DISPLAY_MUX_TYPE_USB4
= 3, ///< [out] USB4
1952 CTL_ATTACHED_DISPLAY_MUX_TYPE_MAX
1954 } ctl_attached_display_mux_type_t
;
1956 ///////////////////////////////////////////////////////////////////////////////
1957 /// @brief Signal Standard
1958 typedef enum _ctl_signal_standard_type_t
1960 CTL_SIGNAL_STANDARD_TYPE_UNKNOWN
= 0, ///< [out] Unknown Signal Standard
1961 CTL_SIGNAL_STANDARD_TYPE_CUSTOM
= 1, ///< [out] Custom added timing
1962 CTL_SIGNAL_STANDARD_TYPE_DMT
= 2, ///< [out] DMT timing
1963 CTL_SIGNAL_STANDARD_TYPE_GTF
= 3, ///< [out] GTF Timing
1964 CTL_SIGNAL_STANDARD_TYPE_CVT
= 4, ///< [out] CVT Timing
1965 CTL_SIGNAL_STANDARD_TYPE_CTA
= 5, ///< [out] CTA Timing
1966 CTL_SIGNAL_STANDARD_TYPE_MAX
1968 } ctl_signal_standard_type_t
;
1970 ///////////////////////////////////////////////////////////////////////////////
1971 /// @brief Protocol Converter Location
1972 typedef uint32_t ctl_protocol_converter_location_flags_t
;
1973 typedef enum _ctl_protocol_converter_location_flag_t
1975 CTL_PROTOCOL_CONVERTER_LOCATION_FLAG_ONBOARD
= CTL_BIT(0), ///< [out] OnBoard Protocol Converter
1976 CTL_PROTOCOL_CONVERTER_LOCATION_FLAG_EXTERNAL
= CTL_BIT(1), ///< [out] External Dongle
1977 CTL_PROTOCOL_CONVERTER_LOCATION_FLAG_MAX
= 0x80000000
1979 } ctl_protocol_converter_location_flag_t
;
1981 ///////////////////////////////////////////////////////////////////////////////
1982 /// @brief [out] Display Output configuration related flags which indicate how
1983 /// the output pixel stream drive the panel
1984 typedef uint32_t ctl_display_config_flags_t
;
1985 typedef enum _ctl_display_config_flag_t
1987 CTL_DISPLAY_CONFIG_FLAG_DISPLAY_ACTIVE
= CTL_BIT(0),///< [out] DisplayActive 0: InActive 1: Active
1988 CTL_DISPLAY_CONFIG_FLAG_DISPLAY_ATTACHED
= CTL_BIT(1), ///< [out] DisplayAttached.This Bit indicates if any dongle/display/hub is
1989 ///< attached to the encoder. 0: Not Attached 1: Attached
1990 CTL_DISPLAY_CONFIG_FLAG_IS_DONGLE_CONNECTED_TO_ENCODER
= CTL_BIT(2),///< [out] This BIT will be set if a dongle/hub/onboard protocol converter
1991 ///< , is attached to the encoder
1992 CTL_DISPLAY_CONFIG_FLAG_DITHERING_ENABLED
= CTL_BIT(3), ///< [out] This BIT will be set if dithering is enabled on the encoder
1993 CTL_DISPLAY_CONFIG_FLAG_MAX
= 0x80000000
1995 } ctl_display_config_flag_t
;
1997 ///////////////////////////////////////////////////////////////////////////////
1998 /// @brief [out] Encoder configuration related flags which indicate how the
1999 /// output pixel stream drive the panel
2000 typedef uint32_t ctl_encoder_config_flags_t
;
2001 typedef enum _ctl_encoder_config_flag_t
2003 CTL_ENCODER_CONFIG_FLAG_INTERNAL_DISPLAY
= CTL_BIT(0), ///< [out] Internal connection or not
2004 CTL_ENCODER_CONFIG_FLAG_VESA_TILED_DISPLAY
= CTL_BIT(1),///< [out] VESA DisplayID based tiled display which is driven by either
2005 ///< multiple physical connections (DisplayPort SST) or virtual streams
2006 ///< (DisplayPort MST)
2007 CTL_ENCODER_CONFIG_FLAG_TYPEC_CAPABLE
= CTL_BIT(2), ///< [out] This is set if encoder supports type c display
2008 CTL_ENCODER_CONFIG_FLAG_TBT_CAPABLE
= CTL_BIT(3), ///< [out] This is set if encoder supports Thunderbolt display
2009 CTL_ENCODER_CONFIG_FLAG_DITHERING_SUPPORTED
= CTL_BIT(4), ///< [out] This BIT will be set if encoder supports dithering
2010 CTL_ENCODER_CONFIG_FLAG_VIRTUAL_DISPLAY
= CTL_BIT(5), ///< [out] This BIT will be set if this is a virtual display.Hardware based
2011 ///< features will not be applicable to this display.For collage display
2012 ///< this will be set for the virtual output created by driver. For split
2013 ///< display this will be set for the virtual split displays created out of
2014 ///< one single physical display
2015 CTL_ENCODER_CONFIG_FLAG_HIDDEN_DISPLAY
= CTL_BIT(6),///< [out] This BIT will be set if display is hidden from OS
2016 CTL_ENCODER_CONFIG_FLAG_COLLAGE_DISPLAY
= CTL_BIT(7), ///< [out] This BIT will be set if this is a collage display
2017 CTL_ENCODER_CONFIG_FLAG_SPLIT_DISPLAY
= CTL_BIT(8), ///< [out] This BIT will be set if this is a split display
2018 CTL_ENCODER_CONFIG_FLAG_COMPANION_DISPLAY
= CTL_BIT(9), ///< [out] This BIT will be set if this is a companion display
2019 CTL_ENCODER_CONFIG_FLAG_MAX
= 0x80000000
2021 } ctl_encoder_config_flag_t
;
2023 ///////////////////////////////////////////////////////////////////////////////
2024 /// @brief Display Timing
2025 typedef struct _ctl_display_timing_t
2027 uint32_t Size
; ///< [in] size of this structure
2028 uint8_t Version
; ///< [in] version of this structure
2029 uint64_t PixelClock
; ///< [out] Pixel Clock in Hz
2030 uint32_t HActive
; ///< [out] Horizontal Active
2031 uint32_t VActive
; ///< [out] Vertical Active
2032 uint32_t HTotal
; ///< [out] Horizontal Total
2033 uint32_t VTotal
; ///< [out] Vertical Total
2034 uint32_t HBlank
; ///< [out] Horizontal Blank
2035 uint32_t VBlank
; ///< [out] Vertical Blank
2036 uint32_t HSync
; ///< [out] Horizontal Blank
2037 uint32_t VSync
; ///< [out] Vertical Blank
2038 float RefreshRate
; ///< [out] Refresh Rate
2039 ctl_signal_standard_type_t SignalStandard
; ///< [out] Signal Standard
2040 uint8_t VicId
; ///< [out] VIC ID for CTA timings
2042 } ctl_display_timing_t
;
2044 ///////////////////////////////////////////////////////////////////////////////
2045 /// @brief This structure will contain the properties of the display currently
2046 /// attached to the encoder.
2047 typedef struct _ctl_display_properties_t
2049 uint32_t Size
; ///< [in] size of this structure
2050 uint8_t Version
; ///< [in] version of this structure
2051 ctl_os_display_encoder_identifier_t Os_display_encoder_handle
; ///< [out] OS specific Display ID
2052 ctl_display_output_types_t Type
; ///< [out] Device Type from display HW stand point. If a DisplayPort
2053 ///< protocol converter is involved, this will indicate it's DisplayPort.
2054 ///< The protocol converter's output will be available from
2055 ///< ProtocolConverterOutput field
2056 ctl_attached_display_mux_type_t AttachedDisplayMuxType
; ///< [out] Attached Display Mux Type
2057 ctl_display_output_types_t ProtocolConverterOutput
; ///< [out] Protocol output type which can be used if config flags indicate
2058 ///< it's a protocol converter. If it's not a protocol converter this will
2059 ///< be set to CTL_DISPLAY_OUTPUT_TYPES_INVALID
2060 ctl_revision_datatype_t SupportedSpec
; ///< [out] Supported industry spec version.
2061 ctl_output_bpc_flags_t SupportedOutputBPCFlags
; ///< [out] Supported output bits per color. Refer ::ctl_output_bpc_flag_t.
2062 ///< This is independent of RGB or YCbCr output.This is the max BPC
2063 ///< supported.BPC will vary per mode based on restrictions like bandwidth
2064 ///< and monitor support
2065 ctl_protocol_converter_location_flags_t ProtocolConverterType
; ///< [out] Currently Active Protocol Converter. Refer
2066 ///< ::ctl_protocol_converter_location_flag_t
2067 ctl_display_config_flags_t DisplayConfigFlags
; ///< [out] Output configuration related flags which indicate how the output
2068 ///< pixel stream drive the panel. Refer ::ctl_display_config_flag_t
2069 ctl_std_display_feature_flags_t FeatureEnabledFlags
;///< [out] Enabled Display features.Refer ::ctl_std_display_feature_flag_t.
2070 ctl_std_display_feature_flags_t FeatureSupportedFlags
; ///< [out] Display Supported feature.Refer ::ctl_std_display_feature_flag_t
2071 ctl_intel_display_feature_flags_t AdvancedFeatureEnabledFlags
; ///< [out] Enabled advanced feature.Refer
2072 ///< ::ctl_intel_display_feature_flag_t.
2073 ctl_intel_display_feature_flags_t AdvancedFeatureSupportedFlags
;///< [out] Supported advanced feature.Refer
2074 ///< ::ctl_intel_display_feature_flag_t.
2075 ctl_display_timing_t Display_Timing_Info
; ///< [out] Applied Timing on the Display
2076 uint32_t ReservedFields
[16]; ///< [out] Reserved field of 64 bytes
2078 } ctl_display_properties_t
;
2080 ///////////////////////////////////////////////////////////////////////////////
2081 /// @brief Adapter's display encoder properties
2082 typedef struct _ctl_adapter_display_encoder_properties_t
2084 uint32_t Size
; ///< [in] size of this structure
2085 uint8_t Version
; ///< [in] version of this structure
2086 ctl_os_display_encoder_identifier_t Os_display_encoder_handle
; ///< [out] OS specific Display ID
2087 ctl_display_output_types_t Type
; ///< [out] Device Type from display HW stand point. If a DisplayPort
2088 ///< protocol converter is involved, this will indicate it's DisplayPort.
2089 ///< The protocol converter's output will be available from
2090 ///< ProtocolConverterOutput field
2091 bool IsOnBoardProtocolConverterOutputPresent
; ///< [out] Protocol output type which can be used if it's a protocol
2092 ///< converter. If it's not a protocol converter this will be set to
2093 ///< CTL_DISPLAY_OUTPUT_TYPES_INVALID
2094 ctl_revision_datatype_t SupportedSpec
; ///< [out] Supported industry spec version
2095 ctl_output_bpc_flags_t SupportedOutputBPCFlags
; ///< [out] Supported output bits per color. Refer ::ctl_output_bpc_flag_t.
2096 ///< This is independent of RGB or YCbCr output.This is the max BPC
2097 ///< supported.BPC will vary per mode based on restrictions like bandwidth
2098 ///< and monitor support
2099 ctl_encoder_config_flags_t EncoderConfigFlags
; ///< [out] Output configuration related flags which indicate how the output
2100 ///< pixel stream drive the panel. Refer ::ctl_encoder_config_flag_t
2102 ///< Virtual = 1: This indicates that its a software display. Hardware
2103 ///< based features will not be applicable to this display.
2104 ///< Collage=1,Virtual=1: Indicates the fake display output created by
2105 ///< driver which has the combined resolution of multiple physical displays
2106 ///< involved in collage configuration
2107 ///< Collage=1,Virtual=0: Indicates the child physical displays involved
2108 ///< in a collage configuration. These are real physical outputs
2109 ///< Split=1,Virtual=1 : Indicates the fake display output created by
2110 ///< driver which occupies a portion of a real physical display
2111 ///< Split=1,Virtual=0 : Indicates the physical display which got split
2112 ///< to form multiple split displays
2113 ///< Split=1,Collage=1 : Invalid combination
2114 ctl_std_display_feature_flags_t FeatureSupportedFlags
; ///< [out] Adapter Supported feature flags. Refer
2115 ///< ::ctl_std_display_feature_flag_t
2116 ctl_intel_display_feature_flags_t AdvancedFeatureSupportedFlags
;///< [out] Advanced Features Supported by the Adapter. Refer
2117 ///< ::ctl_intel_display_feature_flag_t
2118 uint32_t ReservedFields
[16]; ///< [out] Reserved field of 64 bytes
2120 } ctl_adapter_display_encoder_properties_t
;
2122 ///////////////////////////////////////////////////////////////////////////////
2123 /// @brief Get Device Properties
2126 /// - The application gets device properties
2129 /// - CTL_RESULT_SUCCESS
2130 /// - CTL_RESULT_ERROR_UNINITIALIZED
2131 /// - CTL_RESULT_ERROR_DEVICE_LOST
2132 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2133 /// + `nullptr == hDAhandle`
2134 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2135 /// + `nullptr == pProperties`
2136 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2137 CTL_APIEXPORT ctl_result_t CTL_APICALL
2138 ctlGetDeviceProperties(
2139 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to control device adapter
2140 ctl_device_adapter_properties_t
* pProperties
///< [in,out][release] Query result for device properties
2143 ///////////////////////////////////////////////////////////////////////////////
2144 /// @brief Get Display Properties
2147 /// - The application gets display properties
2150 /// - CTL_RESULT_SUCCESS
2151 /// - CTL_RESULT_ERROR_UNINITIALIZED
2152 /// - CTL_RESULT_ERROR_DEVICE_LOST
2153 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2154 /// + `nullptr == hDisplayOutput`
2155 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2156 /// + `nullptr == pProperties`
2157 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2158 CTL_APIEXPORT ctl_result_t CTL_APICALL
2159 ctlGetDisplayProperties(
2160 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
2161 ctl_display_properties_t
* pProperties
///< [in,out][release] Query result for display properties
2164 ///////////////////////////////////////////////////////////////////////////////
2165 /// @brief Get Adapter Display encoder Properties
2168 /// - The application gets the graphic adapters display encoder properties
2171 /// - CTL_RESULT_SUCCESS
2172 /// - CTL_RESULT_ERROR_UNINITIALIZED
2173 /// - CTL_RESULT_ERROR_DEVICE_LOST
2174 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2175 /// + `nullptr == hDisplayOutput`
2176 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2177 /// + `nullptr == pProperties`
2178 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2179 CTL_APIEXPORT ctl_result_t CTL_APICALL
2180 ctlGetAdaperDisplayEncoderProperties(
2181 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
2182 ctl_adapter_display_encoder_properties_t
* pProperties
///< [in,out][release] Query result for adapter display encoder properties
2185 ///////////////////////////////////////////////////////////////////////////////
2186 /// @brief Get Level0 Device handle
2189 /// - The application gets OneAPI Level0 Device handles
2192 /// - CTL_RESULT_SUCCESS
2193 /// - CTL_RESULT_ERROR_UNINITIALIZED
2194 /// - CTL_RESULT_ERROR_DEVICE_LOST
2195 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2196 /// + `nullptr == hDAhandle`
2197 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2198 /// + `nullptr == pZeDevice`
2199 /// + `nullptr == hInstance`
2200 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2201 CTL_APIEXPORT ctl_result_t CTL_APICALL
2203 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to display adapter
2204 void* pZeDevice
, ///< [out][release] ze_device handle
2205 void** hInstance
///< [out][release] Module instance which caller can use to get export
2206 ///< functions directly
2209 ///////////////////////////////////////////////////////////////////////////////
2210 /// @brief Various sharpness filter types
2211 typedef uint32_t ctl_sharpness_filter_type_flags_t
;
2212 typedef enum _ctl_sharpness_filter_type_flag_t
2214 CTL_SHARPNESS_FILTER_TYPE_FLAG_NON_ADAPTIVE
= CTL_BIT(0), ///< Non-adaptive sharpness
2215 CTL_SHARPNESS_FILTER_TYPE_FLAG_ADAPTIVE
= CTL_BIT(1), ///< Adaptive sharpness
2216 CTL_SHARPNESS_FILTER_TYPE_FLAG_MAX
= 0x80000000
2218 } ctl_sharpness_filter_type_flag_t
;
2220 ///////////////////////////////////////////////////////////////////////////////
2221 /// @brief Sharpness filter properties
2222 typedef struct _ctl_sharpness_filter_properties_t
2224 ctl_sharpness_filter_type_flags_t FilterType
; ///< [out] Filter type. Refer ::ctl_sharpness_filter_type_flag_t
2225 ctl_property_range_info_t FilterDetails
; ///< [out] Min, max & step size information
2227 } ctl_sharpness_filter_properties_t
;
2229 ///////////////////////////////////////////////////////////////////////////////
2230 /// @brief Various sharpness filter types
2231 typedef struct _ctl_sharpness_caps_t
2233 uint32_t Size
; ///< [in] size of this structure
2234 uint8_t Version
; ///< [in] version of this structure
2235 ctl_sharpness_filter_type_flags_t SupportedFilterFlags
; ///< [out] Supported sharpness filters for a given display output. Refer
2236 ///< ::ctl_sharpness_filter_type_flag_t
2237 uint8_t NumFilterTypes
; ///< [out] Number of elements in filter properties array
2238 ctl_sharpness_filter_properties_t
* pFilterProperty
; ///< [in,out] Array of filter properties structure describing supported
2239 ///< filter capabilities. Caller should provide a pre-allocated memory for
2242 } ctl_sharpness_caps_t
;
2244 ///////////////////////////////////////////////////////////////////////////////
2245 /// @brief Current sharpness setting
2246 typedef struct _ctl_sharpness_settings_t
2248 uint32_t Size
; ///< [in] size of this structure
2249 uint8_t Version
; ///< [in] version of this structure
2250 bool Enable
; ///< [in,out] Current or new state of sharpness setting
2251 ctl_sharpness_filter_type_flags_t FilterType
; ///< [in,out] Current or new filter to be set. Refer
2252 ///< ::ctl_sharpness_filter_type_flag_t
2253 float Intensity
; ///< [in,out] Setting intensity to be applied
2255 } ctl_sharpness_settings_t
;
2257 ///////////////////////////////////////////////////////////////////////////////
2258 /// @brief Get Sharpness capability
2261 /// - Returns sharpness capability
2264 /// - CTL_RESULT_SUCCESS
2265 /// - CTL_RESULT_ERROR_UNINITIALIZED
2266 /// - CTL_RESULT_ERROR_DEVICE_LOST
2267 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2268 /// + `nullptr == hDisplayOutput`
2269 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2270 /// + `nullptr == pSharpnessCaps`
2271 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2272 CTL_APIEXPORT ctl_result_t CTL_APICALL
2273 ctlGetSharpnessCaps(
2274 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
2275 ctl_sharpness_caps_t
* pSharpnessCaps
///< [in,out][release] Query result for sharpness capability
2278 ///////////////////////////////////////////////////////////////////////////////
2279 /// @brief Get Sharpness setting
2282 /// - Returns current sharpness settings
2285 /// - CTL_RESULT_SUCCESS
2286 /// - CTL_RESULT_ERROR_UNINITIALIZED
2287 /// - CTL_RESULT_ERROR_DEVICE_LOST
2288 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2289 /// + `nullptr == hDisplayOutput`
2290 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2291 /// + `nullptr == pSharpnessSettings`
2292 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2293 CTL_APIEXPORT ctl_result_t CTL_APICALL
2294 ctlGetCurrentSharpness(
2295 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
2296 ctl_sharpness_settings_t
* pSharpnessSettings
///< [in,out][release] Query result for sharpness current settings
2299 ///////////////////////////////////////////////////////////////////////////////
2300 /// @brief Set Sharpness setting
2303 /// - Set current sharpness settings
2306 /// - CTL_RESULT_SUCCESS
2307 /// - CTL_RESULT_ERROR_UNINITIALIZED
2308 /// - CTL_RESULT_ERROR_DEVICE_LOST
2309 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2310 /// + `nullptr == hDisplayOutput`
2311 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2312 /// + `nullptr == pSharpnessSettings`
2313 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2314 CTL_APIEXPORT ctl_result_t CTL_APICALL
2315 ctlSetCurrentSharpness(
2316 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
2317 ctl_sharpness_settings_t
* pSharpnessSettings
///< [in][release] Set sharpness current settings
2320 ///////////////////////////////////////////////////////////////////////////////
2321 #ifndef CTL_I2C_MAX_DATA_SIZE
2322 /// @brief I2C Maximum data size
2323 #define CTL_I2C_MAX_DATA_SIZE 0x0080
2324 #endif // CTL_I2C_MAX_DATA_SIZE
2326 ///////////////////////////////////////////////////////////////////////////////
2327 /// @brief I2CFlags bitmasks
2328 typedef uint32_t ctl_i2c_flags_t
;
2329 typedef enum _ctl_i2c_flag_t
2331 CTL_I2C_FLAG_ATOMICI2C
= CTL_BIT(0), ///< Force Atomic I2C
2332 CTL_I2C_FLAG_MAX
= 0x80000000
2336 ///////////////////////////////////////////////////////////////////////////////
2337 /// @brief I2C access arguments
2338 typedef struct _ctl_i2c_access_args_t
2340 uint32_t Size
; ///< [in] size of this structure
2341 uint8_t Version
; ///< [in] version of this structure
2342 uint32_t DataSize
; ///< [in,out] Valid data size
2343 uint32_t Address
; ///< [in] Adreess to read or write
2344 ctl_operation_type_t OpType
; ///< [in] Operation type, 1 for Read, 2 for Write, for Write operation, App
2345 ///< needs to run with admin privileges
2346 uint32_t Offset
; ///< [in] Offset
2347 ctl_i2c_flags_t Flags
; ///< [in] I2C Flags. Refer ::ctl_i2c_flag_t
2348 uint64_t RAD
; ///< [in] RAD, For Future use, to be used for branch devices, Interface
2349 ///< will be provided to get RAD
2350 uint8_t Data
[CTL_I2C_MAX_DATA_SIZE
]; ///< [in,out] Data array
2352 } ctl_i2c_access_args_t
;
2354 ///////////////////////////////////////////////////////////////////////////////
2355 /// @brief I2C Access
2358 /// - The application does I2C aceess
2361 /// - CTL_RESULT_SUCCESS
2362 /// - CTL_RESULT_ERROR_UNINITIALIZED
2363 /// - CTL_RESULT_ERROR_DEVICE_LOST
2364 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2365 /// + `nullptr == hDisplayOutput`
2366 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2367 /// + `nullptr == pI2cAccessArgs`
2368 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2369 /// - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Invalid operation type"
2370 /// - ::CTL_RESULT_ERROR_INVALID_SIZE - "Invalid I2C data size"
2371 /// - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS - "Insufficient permissions"
2372 /// - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
2373 /// - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
2374 /// - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
2375 /// - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
2376 /// - ::CTL_RESULT_ERROR_KMD_CALL - "Kernal mode driver call failure"
2377 CTL_APIEXPORT ctl_result_t CTL_APICALL
2379 ctl_display_output_handle_t hDisplayOutput
, ///< [in] Handle to display output
2380 ctl_i2c_access_args_t
* pI2cAccessArgs
///< [in,out] I2c access arguments
2383 ///////////////////////////////////////////////////////////////////////////////
2384 #ifndef CTL_AUX_MAX_DATA_SIZE
2385 /// @brief Aux Maximum data size
2386 #define CTL_AUX_MAX_DATA_SIZE 132
2387 #endif // CTL_AUX_MAX_DATA_SIZE
2389 ///////////////////////////////////////////////////////////////////////////////
2390 /// @brief AUX Flags bitmasks
2391 typedef uint32_t ctl_aux_flags_t
;
2392 typedef enum _ctl_aux_flag_t
2394 CTL_AUX_FLAG_NATIVE_AUX
= CTL_BIT(0), ///< For Native AUX operation
2395 CTL_AUX_FLAG_I2C_AUX
= CTL_BIT(1), ///< For I2C AUX operation
2396 CTL_AUX_FLAG_I2C_AUX_MOT
= CTL_BIT(2), ///< For I2C AUX MOT operation
2397 CTL_AUX_FLAG_MAX
= 0x80000000
2401 ///////////////////////////////////////////////////////////////////////////////
2402 /// @brief AUX access arguments
2403 typedef struct _ctl_aux_access_args_t
2405 uint32_t Size
; ///< [in] size of this structure
2406 uint8_t Version
; ///< [in] version of this structure
2407 ctl_operation_type_t OpType
; ///< [in] Operation type, 1 for Read, 2 for Write, for Write operation, App
2408 ///< needs to run with admin privileges
2409 ctl_aux_flags_t Flags
; ///< [in] Aux Flags. Refer ::ctl_aux_flag_t
2410 uint32_t Address
; ///< [in] Adreess to read or write
2411 uint64_t RAD
; ///< [in] RAD, For Future use, to be used for branch devices, Interface
2412 ///< will be provided to get RAD
2413 uint32_t PortID
; ///< [in] Port ID, For Future use, to be used for SST tiled devices
2414 uint32_t DataSize
; ///< [in,out] Valid data size
2415 uint8_t Data
[CTL_AUX_MAX_DATA_SIZE
]; ///< [in,out] Data array
2417 } ctl_aux_access_args_t
;
2419 ///////////////////////////////////////////////////////////////////////////////
2420 /// @brief Aux Access
2423 /// - The application does Aux aceess, PSR needs to be disabled for AUX
2427 /// - CTL_RESULT_SUCCESS
2428 /// - CTL_RESULT_ERROR_UNINITIALIZED
2429 /// - CTL_RESULT_ERROR_DEVICE_LOST
2430 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2431 /// + `nullptr == hDisplayOutput`
2432 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2433 /// + `nullptr == pAuxAccessArgs`
2434 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2435 /// - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Invalid operation type"
2436 /// - ::CTL_RESULT_ERROR_INVALID_SIZE - "Invalid AUX data size"
2437 /// - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS - "Insufficient permissions"
2438 /// - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
2439 /// - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
2440 /// - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
2441 /// - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
2442 /// - ::CTL_RESULT_ERROR_INVALID_AUX_ACCESS_FLAG - "Invalid flag for AUX access"
2443 /// - ::CTL_RESULT_ERROR_KMD_CALL - "Kernal mode driver call failure"
2444 CTL_APIEXPORT ctl_result_t CTL_APICALL
2446 ctl_display_output_handle_t hDisplayOutput
, ///< [in] Handle to display output
2447 ctl_aux_access_args_t
* pAuxAccessArgs
///< [in,out] Aux access arguments
2450 ///////////////////////////////////////////////////////////////////////////////
2451 /// @brief Power saving features (Each individual feature's set & get call can be
2452 /// called only once at a time)
2453 typedef uint32_t ctl_power_optimization_flags_t
;
2454 typedef enum _ctl_power_optimization_flag_t
2456 CTL_POWER_OPTIMIZATION_FLAG_FBC
= CTL_BIT(0), ///< Frame buffer compression
2457 CTL_POWER_OPTIMIZATION_FLAG_PSR
= CTL_BIT(1), ///< Panel self refresh
2458 CTL_POWER_OPTIMIZATION_FLAG_DPST
= CTL_BIT(2), ///< Display power saving technology (Panel technology dependent)
2459 CTL_POWER_OPTIMIZATION_FLAG_LRR
= CTL_BIT(3), ///< Low refresh rate (LRR/ALRR/UBRR), UBRR is supported only for IGCC and
2460 ///< NDA clients. UBZRR and UBLRR both can not be enabled at the same time,
2461 ///< only one can be enabled at a given time
2462 CTL_POWER_OPTIMIZATION_FLAG_MAX
= 0x80000000
2464 } ctl_power_optimization_flag_t
;
2466 ///////////////////////////////////////////////////////////////////////////////
2467 /// @brief GPU/Panel/TCON dependent power optimization technology
2468 typedef uint32_t ctl_power_optimization_dpst_flags_t
;
2469 typedef enum _ctl_power_optimization_dpst_flag_t
2471 CTL_POWER_OPTIMIZATION_DPST_FLAG_BKLT
= CTL_BIT(0), ///< Intel DPST with Backlight control
2472 CTL_POWER_OPTIMIZATION_DPST_FLAG_PANEL_CABC
= CTL_BIT(1), ///< Panel TCON specific Content Adaptive Control mechanism
2473 CTL_POWER_OPTIMIZATION_DPST_FLAG_OPST
= CTL_BIT(2), ///< Intel OLED Power Saving Technology
2474 CTL_POWER_OPTIMIZATION_DPST_FLAG_ELP
= CTL_BIT(3), ///< TCON based Edge Luminance Profile
2475 CTL_POWER_OPTIMIZATION_DPST_FLAG_EPSM
= CTL_BIT(4), ///< Extra power saving mode
2476 CTL_POWER_OPTIMIZATION_DPST_FLAG_MAX
= 0x80000000
2478 } ctl_power_optimization_dpst_flag_t
;
2480 ///////////////////////////////////////////////////////////////////////////////
2481 /// @brief Power Source
2482 typedef enum _ctl_power_source_t
2484 CTL_POWER_SOURCE_AC
= 0, ///< Power Source AC
2485 CTL_POWER_SOURCE_DC
= 1, ///< Power Source DC
2486 CTL_POWER_SOURCE_MAX
2488 } ctl_power_source_t
;
2490 ///////////////////////////////////////////////////////////////////////////////
2491 /// @brief Power Optimization Plan
2492 typedef enum _ctl_power_optimization_plan_t
2494 CTL_POWER_OPTIMIZATION_PLAN_BALANCED
= 0, ///< Balanced mode
2495 CTL_POWER_OPTIMIZATION_PLAN_HIGH_PERFORMANCE
= 1, ///< High Performance Mode
2496 CTL_POWER_OPTIMIZATION_PLAN_POWER_SAVER
= 2, ///< Power Saver Mode
2497 CTL_POWER_OPTIMIZATION_PLAN_MAX
2499 } ctl_power_optimization_plan_t
;
2501 ///////////////////////////////////////////////////////////////////////////////
2502 /// @brief Type of low refresh rate feature
2503 typedef uint32_t ctl_power_optimization_lrr_flags_t
;
2504 typedef enum _ctl_power_optimization_lrr_flag_t
2506 CTL_POWER_OPTIMIZATION_LRR_FLAG_LRR10
= CTL_BIT(0), ///< LRR 1.0
2507 CTL_POWER_OPTIMIZATION_LRR_FLAG_LRR20
= CTL_BIT(1), ///< LRR 2.0
2508 CTL_POWER_OPTIMIZATION_LRR_FLAG_LRR25
= CTL_BIT(2), ///< LRR 2.5
2509 CTL_POWER_OPTIMIZATION_LRR_FLAG_ALRR
= CTL_BIT(3), ///< Autonomous LRR
2510 CTL_POWER_OPTIMIZATION_LRR_FLAG_UBLRR
= CTL_BIT(4), ///< User based low refresh rate
2511 CTL_POWER_OPTIMIZATION_LRR_FLAG_UBZRR
= CTL_BIT(5), ///< User based zero refresh rate
2512 CTL_POWER_OPTIMIZATION_LRR_FLAG_MAX
= 0x80000000
2514 } ctl_power_optimization_lrr_flag_t
;
2516 ///////////////////////////////////////////////////////////////////////////////
2517 /// @brief Power optimization caps
2518 typedef struct _ctl_power_optimization_caps_t
2520 uint32_t Size
; ///< [in] size of this structure
2521 uint8_t Version
; ///< [in] version of this structure
2522 ctl_power_optimization_flags_t SupportedFeatures
; ///< [out] Supported power optimization features. Refer
2523 ///< ::ctl_power_optimization_flag_t
2525 } ctl_power_optimization_caps_t
;
2527 ///////////////////////////////////////////////////////////////////////////////
2528 /// @brief Get Power optimization features
2531 /// - Returns power optimization capabilities
2534 /// - CTL_RESULT_SUCCESS
2535 /// - CTL_RESULT_ERROR_UNINITIALIZED
2536 /// - CTL_RESULT_ERROR_DEVICE_LOST
2537 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2538 /// + `nullptr == hDisplayOutput`
2539 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2540 /// + `nullptr == pPowerOptimizationCaps`
2541 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2542 CTL_APIEXPORT ctl_result_t CTL_APICALL
2543 ctlGetPowerOptimizationCaps(
2544 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
2545 ctl_power_optimization_caps_t
* pPowerOptimizationCaps
///< [in,out][release] Query result for power optimization features
2548 ///////////////////////////////////////////////////////////////////////////////
2549 /// @brief LRR detailed settings
2550 typedef struct _ctl_power_optimization_lrr_t
2552 uint32_t Size
; ///< [in] size of this structure
2553 uint8_t Version
; ///< [in] version of this structure
2554 ctl_power_optimization_lrr_flags_t SupportedLRRTypes
; ///< [out] LRR type(s). Refer ::ctl_power_optimization_lrr_flag_t
2555 ctl_power_optimization_lrr_flags_t CurrentLRRTypes
; ///< [in,out] Current enabled LRR type(s) or the LRR type(s) to set to.
2556 ///< Refer ::ctl_power_optimization_lrr_flag_t
2557 bool bRequirePSRDisable
; ///< [out] Require PSR disable for any change in the selected LRR feature.
2558 ///< Caller can re-enable PSR once the respective LRR feature is
2559 ///< enable/disabled. E.g. for UBRR based on platform this flag may not be
2560 ///< set in which case caller doesn't need to do an explicit PSR disable
2561 uint16_t LowRR
; ///< [out] Lowest RR used for LRR functionality if known to source
2563 } ctl_power_optimization_lrr_t
;
2565 ///////////////////////////////////////////////////////////////////////////////
2566 /// @brief PSR detailed settings
2567 typedef struct _ctl_power_optimization_psr_t
2569 uint32_t Size
; ///< [in] size of this structure
2570 uint8_t Version
; ///< [in] version of this structure
2571 uint8_t PSRVersion
; ///< [in,out] A value of 1 means PSR1, 2 means PSR2
2572 bool FullFetchUpdate
; ///< [in,out] Full fetch and update
2574 } ctl_power_optimization_psr_t
;
2576 ///////////////////////////////////////////////////////////////////////////////
2577 /// @brief DPST detailed settings
2578 typedef struct _ctl_power_optimization_dpst_t
2580 uint32_t Size
; ///< [in] size of this structure
2581 uint8_t Version
; ///< [in] version of this structure
2582 uint8_t MinLevel
; ///< [out] Minimum supported aggressiveness level
2583 uint8_t MaxLevel
; ///< [out] Maximum supported aggressiveness level
2584 uint8_t Level
; ///< [in,out] Current aggressiveness level to be set
2585 ctl_power_optimization_dpst_flags_t SupportedFeatures
; ///< [out] Supported features
2586 ctl_power_optimization_dpst_flags_t EnabledFeatures
;///< [in,out] Features enabled or to be enabled
2588 } ctl_power_optimization_dpst_t
;
2590 ///////////////////////////////////////////////////////////////////////////////
2591 /// @brief Feature specific power optimization data
2592 typedef union _ctl_power_optimization_feature_specific_info_t
2594 ctl_power_optimization_lrr_t LRRInfo
; ///< [out] LRR info
2595 ctl_power_optimization_psr_t PSRInfo
; ///< [in,out] PSR info
2596 ctl_power_optimization_dpst_t DPSTInfo
; ///< [in,out] DPST info
2598 } ctl_power_optimization_feature_specific_info_t
;
2600 ///////////////////////////////////////////////////////////////////////////////
2601 /// @brief Power optimization settings
2602 typedef struct _ctl_power_optimization_settings_t
2604 uint32_t Size
; ///< [in] size of this structure
2605 uint8_t Version
; ///< [in] version of this structure
2606 ctl_power_optimization_plan_t PowerOptimizationPlan
;///< [in] Power optimization power plan (max power/max perf/balanced)
2607 ctl_power_optimization_flags_t PowerOptimizationFeature
;///< [in] Power optimization feature interested in. Refer
2608 ///< ::ctl_power_optimization_flag_t
2609 bool Enable
; ///< [in,out] Enable state
2610 ctl_power_optimization_feature_specific_info_t FeatureSpecificData
; ///< [in,out] Data specific to the feature caller is interested in
2611 ctl_power_source_t PowerSource
; ///< [in] AC/DC
2613 } ctl_power_optimization_settings_t
;
2615 ///////////////////////////////////////////////////////////////////////////////
2616 /// @brief Brightness settings for SET call
2617 typedef struct _ctl_set_brightness_t
2619 uint32_t Size
; ///< [in] size of this structure
2620 uint8_t Version
; ///< [in] version of this structure
2621 uint32_t TargetBrightness
; ///< [in] The brightness level that the display need to transitioning to in
2622 ///< milli-percentage. Range is 0-100000 (100%)
2623 uint32_t SmoothTransitionTimeInMs
; ///< [in] Transition Time for brightness to take effect in milli-seconds.
2624 ///< If its 0 then it will be an immediate change. Maximum possible value
2626 uint32_t ReservedFields
[4]; ///< [in] Reserved for future use
2628 } ctl_set_brightness_t
;
2630 ///////////////////////////////////////////////////////////////////////////////
2631 /// @brief Brightness settings for GET call
2632 typedef struct _ctl_get_brightness_t
2634 uint32_t Size
; ///< [in] size of this structure
2635 uint8_t Version
; ///< [in] version of this structure
2636 uint32_t TargetBrightness
; ///< [out] The brightness level that the display is currently transitioning
2637 ///< to in milli-percentage. If not in a transition, this should equal the
2638 ///< current brightness. Range is 0-100000 (100%)
2639 uint32_t CurrentBrightness
; ///< [out] The current brightness level of the display in milli-percentage
2640 uint32_t ReservedFields
[4]; ///< [out] Reserved for future use
2642 } ctl_get_brightness_t
;
2644 ///////////////////////////////////////////////////////////////////////////////
2645 /// @brief Get Power optimization setting
2648 /// - Returns power optimization setting for a specific feature
2651 /// - CTL_RESULT_SUCCESS
2652 /// - CTL_RESULT_ERROR_UNINITIALIZED
2653 /// - CTL_RESULT_ERROR_DEVICE_LOST
2654 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2655 /// + `nullptr == hDisplayOutput`
2656 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2657 /// + `nullptr == pPowerOptimizationSettings`
2658 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2659 /// - ::CTL_RESULT_ERROR_INVALID_POWERFEATURE_OPTIMIZATION_FLAG - "Unsupported PowerOptimizationFeature"
2660 /// - ::CTL_RESULT_ERROR_INVALID_POWERSOURCE_TYPE_FOR_DPST - "DPST is supported only in DC Mode"
2661 CTL_APIEXPORT ctl_result_t CTL_APICALL
2662 ctlGetPowerOptimizationSetting(
2663 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
2664 ctl_power_optimization_settings_t
* pPowerOptimizationSettings
///< [in,out][release] Power optimization data to be fetched
2667 ///////////////////////////////////////////////////////////////////////////////
2668 /// @brief Set Power optimization setting
2671 /// - Set power optimization setting for a specific feature
2674 /// - CTL_RESULT_SUCCESS
2675 /// - CTL_RESULT_ERROR_UNINITIALIZED
2676 /// - CTL_RESULT_ERROR_DEVICE_LOST
2677 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2678 /// + `nullptr == hDisplayOutput`
2679 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2680 /// + `nullptr == pPowerOptimizationSettings`
2681 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2682 /// - ::CTL_RESULT_ERROR_INVALID_POWERFEATURE_OPTIMIZATION_FLAG - "Unsupported PowerOptimizationFeature"
2683 /// - ::CTL_RESULT_ERROR_INVALID_POWERSOURCE_TYPE_FOR_DPST - "DPST is supported only in DC Mode"
2684 CTL_APIEXPORT ctl_result_t CTL_APICALL
2685 ctlSetPowerOptimizationSetting(
2686 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
2687 ctl_power_optimization_settings_t
* pPowerOptimizationSettings
///< [in][release] Power optimization data to be applied
2690 ///////////////////////////////////////////////////////////////////////////////
2691 /// @brief Set Brightness on companion display
2694 /// - Set Brightness for a target display. Currently support is only for
2695 /// companion display.
2698 /// - CTL_RESULT_SUCCESS
2699 /// - CTL_RESULT_ERROR_UNINITIALIZED
2700 /// - CTL_RESULT_ERROR_DEVICE_LOST
2701 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2702 /// + `nullptr == hDisplayOutput`
2703 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2704 /// + `nullptr == pSetBrightnessSetting`
2705 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2706 /// - ::CTL_RESULT_ERROR_INVALID_ARGUMENT - "Invalid Brightness data passed as argument"
2707 /// - ::CTL_RESULT_ERROR_DISPLAY_NOT_ACTIVE - "Display not active"
2708 /// - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Currently Brightness API is supported only on companion display"
2709 CTL_APIEXPORT ctl_result_t CTL_APICALL
2710 ctlSetBrightnessSetting(
2711 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
2712 ctl_set_brightness_t
* pSetBrightnessSetting
///< [in][release] Brightness settings to be applied
2715 ///////////////////////////////////////////////////////////////////////////////
2716 /// @brief Get Brightness setting
2719 /// - Get Brightness for a target display. Currently support is only for
2720 /// companion display.
2723 /// - CTL_RESULT_SUCCESS
2724 /// - CTL_RESULT_ERROR_UNINITIALIZED
2725 /// - CTL_RESULT_ERROR_DEVICE_LOST
2726 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2727 /// + `nullptr == hDisplayOutput`
2728 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2729 /// + `nullptr == pGetBrightnessSetting`
2730 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2731 /// - ::CTL_RESULT_ERROR_DISPLAY_NOT_ACTIVE - "Display not active"
2732 /// - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Currently Brightness API is supported only on companion display"
2733 CTL_APIEXPORT ctl_result_t CTL_APICALL
2734 ctlGetBrightnessSetting(
2735 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
2736 ctl_get_brightness_t
* pGetBrightnessSetting
///< [out][release] Brightness settings data to be fetched
2739 ///////////////////////////////////////////////////////////////////////////////
2740 #ifndef CTL_MAX_NUM_SAMPLES_PER_CHANNEL_1D_LUT
2741 /// @brief Maximum number of samples per channel 1D LUT
2742 #define CTL_MAX_NUM_SAMPLES_PER_CHANNEL_1D_LUT 8192
2743 #endif // CTL_MAX_NUM_SAMPLES_PER_CHANNEL_1D_LUT
2745 ///////////////////////////////////////////////////////////////////////////////
2746 /// @brief Pixtx pipe set configuration flags bitmasks
2747 typedef uint32_t ctl_pixtx_pipe_set_config_flags_t
;
2748 typedef enum _ctl_pixtx_pipe_set_config_flag_t
2750 CTL_PIXTX_PIPE_SET_CONFIG_FLAG_PERSIST_ACROSS_POWER_EVENTS
= CTL_BIT(0),///< For maintaining persistance across power events
2751 CTL_PIXTX_PIPE_SET_CONFIG_FLAG_MAX
= 0x80000000
2753 } ctl_pixtx_pipe_set_config_flag_t
;
2755 ///////////////////////////////////////////////////////////////////////////////
2756 /// @brief Pixel transformation block types
2757 typedef enum _ctl_pixtx_block_type_t
2759 CTL_PIXTX_BLOCK_TYPE_1D_LUT
= 1, ///< Block type 1D LUT
2760 CTL_PIXTX_BLOCK_TYPE_3D_LUT
= 2, ///< Block type 3D LUT
2761 CTL_PIXTX_BLOCK_TYPE_3X3_MATRIX
= 3, ///< Block type 3x3 matrix
2762 CTL_PIXTX_BLOCK_TYPE_3X3_MATRIX_AND_OFFSETS
= 4,///< Block type 3x3 matrix and offsets
2763 CTL_PIXTX_BLOCK_TYPE_MAX
2765 } ctl_pixtx_block_type_t
;
2767 ///////////////////////////////////////////////////////////////////////////////
2768 /// @brief Pixel transformation LUT sampling types
2769 typedef enum _ctl_pixtx_lut_sampling_type_t
2771 CTL_PIXTX_LUT_SAMPLING_TYPE_UNIFORM
= 0, ///< Uniform LUT sampling
2772 CTL_PIXTX_LUT_SAMPLING_TYPE_NONUNIFORM
= 1, ///< Non uniform LUT sampling, Required mainly in HDR mode
2773 CTL_PIXTX_LUT_SAMPLING_TYPE_MAX
2775 } ctl_pixtx_lut_sampling_type_t
;
2777 ///////////////////////////////////////////////////////////////////////////////
2778 /// @brief Configuration query types
2779 typedef enum _ctl_pixtx_config_query_type_t
2781 CTL_PIXTX_CONFIG_QUERY_TYPE_CAPABILITY
= 0, ///< Get complete pixel processing pipeline capability
2782 CTL_PIXTX_CONFIG_QUERY_TYPE_CURRENT
= 1, ///< Get the configuration set through last set call
2783 CTL_PIXTX_CONFIG_QUERY_TYPE_MAX
2785 } ctl_pixtx_config_query_type_t
;
2787 ///////////////////////////////////////////////////////////////////////////////
2788 /// @brief Configuration operation types
2789 typedef enum _ctl_pixtx_config_opertaion_type_t
2791 CTL_PIXTX_CONFIG_OPERTAION_TYPE_RESTORE_DEFAULT
= 1,///< Restore block by block or entire pipe line. Use NumBlocks = 0 to
2793 CTL_PIXTX_CONFIG_OPERTAION_TYPE_SET_CUSTOM
= 2, ///< Custom LUT or matrix can be set thorugh this option.
2794 CTL_PIXTX_CONFIG_OPERTAION_TYPE_MAX
2796 } ctl_pixtx_config_opertaion_type_t
;
2798 ///////////////////////////////////////////////////////////////////////////////
2799 /// @brief Pixel transformation gamma encoding types
2800 typedef enum _ctl_pixtx_gamma_encoding_type_t
2802 CTL_PIXTX_GAMMA_ENCODING_TYPE_SRGB
= 0, ///< Gamma encoding SRGB
2803 CTL_PIXTX_GAMMA_ENCODING_TYPE_REC709
= 1, ///< Gamma encoding REC709, Applicable for REC2020 as well
2804 CTL_PIXTX_GAMMA_ENCODING_TYPE_ST2084
= 2, ///< Gamma encoding ST2084
2805 CTL_PIXTX_GAMMA_ENCODING_TYPE_HLG
= 3, ///< Gamma encoding HLG
2806 CTL_PIXTX_GAMMA_ENCODING_TYPE_LINEAR
= 4, ///< Gamma encoding linear
2807 CTL_PIXTX_GAMMA_ENCODING_TYPE_MAX
2809 } ctl_pixtx_gamma_encoding_type_t
;
2811 ///////////////////////////////////////////////////////////////////////////////
2812 /// @brief Pixel transformation color space types
2813 typedef enum _ctl_pixtx_color_space_t
2815 CTL_PIXTX_COLOR_SPACE_REC709
= 0, ///< Color space REC709
2816 CTL_PIXTX_COLOR_SPACE_REC2020
= 1, ///< Color space REC2020
2817 CTL_PIXTX_COLOR_SPACE_ADOBE_RGB
= 2, ///< Color space AdobeRGB
2818 CTL_PIXTX_COLOR_SPACE_P3_D65
= 3, ///< Color space P3_D65
2819 CTL_PIXTX_COLOR_SPACE_P3_DCI
= 4, ///< Color space P3_DCI
2820 CTL_PIXTX_COLOR_SPACE_P3_D60
= 5, ///< Color space P3_D60
2821 CTL_PIXTX_COLOR_SPACE_CUSTOM
= 0xFFFF, ///< Color space custom, Refer ::ctl_pixtx_color_primaries_t for color
2822 ///< primary details
2823 CTL_PIXTX_COLOR_SPACE_MAX
2825 } ctl_pixtx_color_space_t
;
2827 ///////////////////////////////////////////////////////////////////////////////
2828 /// @brief Pixel transformation color model types
2829 typedef enum _ctl_pixtx_color_model_t
2831 CTL_PIXTX_COLOR_MODEL_RGB_FR
= 0, ///< Color model RGB full range
2832 CTL_PIXTX_COLOR_MODEL_RGB_LR
= 1, ///< Color model RGB limited range
2833 CTL_PIXTX_COLOR_MODEL_YCBCR_422_FR
= 2, ///< Color model YCBCR 422 full range
2834 CTL_PIXTX_COLOR_MODEL_YCBCR_422_LR
= 3, ///< Color model YCBCR 422 limited range
2835 CTL_PIXTX_COLOR_MODEL_YCBCR_420_FR
= 4, ///< Color model YCBCR 420 full range
2836 CTL_PIXTX_COLOR_MODEL_YCBCR_420_LR
= 5, ///< Color model YCBCR 420 limited range
2837 CTL_PIXTX_COLOR_MODEL_MAX
2839 } ctl_pixtx_color_model_t
;
2841 ///////////////////////////////////////////////////////////////////////////////
2842 /// @brief Pixel transformation color primaries
2843 typedef struct _ctl_pixtx_color_primaries_t
2845 uint32_t Size
; ///< [in] size of this structure
2846 uint8_t Version
; ///< [in] version of this structure
2847 double xR
; ///< [out] CIE1931 x value with maximum red pixel value
2848 double yR
; ///< [out] CIE1931 y value with maximum red pixel value
2849 double xG
; ///< [out] CIE1931 x value with maximum green pixel value
2850 double yG
; ///< [out] CIE1931 y value with maximum green pixel value
2851 double xB
; ///< [out] CIE1931 x value with maximum blue pixel value
2852 double yB
; ///< [out] CIE1931 y value with maximum blue pixel value
2853 double xW
; ///< [out] CIE1931 x value with maximum white pixel value
2854 double yW
; ///< [out] CIE1931 y value with maximum white pixel value
2856 } ctl_pixtx_color_primaries_t
;
2858 ///////////////////////////////////////////////////////////////////////////////
2859 /// @brief Pixel transformation pixel format
2860 typedef struct _ctl_pixtx_pixel_format_t
2862 uint32_t Size
; ///< [in] size of this structure
2863 uint8_t Version
; ///< [in] version of this structure
2864 uint32_t BitsPerColor
; ///< [out] Bits per color, It Will be 16 for FP16 case
2865 bool IsFloat
; ///< [out] Will be set for FP16 or other floating point encoding schemes
2866 ctl_pixtx_gamma_encoding_type_t EncodingType
; ///< [out] Encoding type
2867 ctl_pixtx_color_space_t ColorSpace
; ///< [out] Color space
2868 ctl_pixtx_color_model_t ColorModel
; ///< [out] Color model
2869 ctl_pixtx_color_primaries_t ColorPrimaries
; ///< [out] Color primaries, Used mainly for custom color space
2870 double MaxBrightness
; ///< [out] Maximum brightness of pixel values. If no input is given,
2871 ///< default will be set to sRGB during set call. If panel capability is
2872 ///< not known get call will default to sRGB.
2873 double MinBrightness
; ///< [out] Minimum brightness of pixel values
2875 } ctl_pixtx_pixel_format_t
;
2877 ///////////////////////////////////////////////////////////////////////////////
2878 /// @brief Pixel transformation 1D LUT configuration
2879 typedef struct _ctl_pixtx_1dlut_config_t
2881 uint32_t Size
; ///< [in] size of this structure
2882 uint8_t Version
; ///< [in] version of this structure
2883 ctl_pixtx_lut_sampling_type_t SamplingType
; ///< [in,out] Blocks with non-uniform sampling capability support unifrom
2884 ///< sampling also but not vice versa.
2885 uint32_t NumSamplesPerChannel
; ///< [in,out] Number of samples per channel. Resampled internally based on
2886 ///< HW capability for uniformly sampled LUT.Maximum supported value is
2887 ///< ::CTL_MAX_NUM_SAMPLES_PER_CHANNEL_1D_LUT Caller needs to use exact
2888 ///< sampling position given in pSamplePositions for non-uniformly sampled
2890 uint32_t NumChannels
; ///< [in,out] Number of channels, 1 for Grey scale LUT, 3 for RGB LUT
2891 double* pSampleValues
; ///< [in,out] Pointer to sample values, R array followed by G and B arrays
2892 ///< in case of multi-channel LUT. Allocation size for pSampleValues should
2893 ///< be NumSamplesPerChannel * NumChannels * sizeof(double)
2894 double* pSamplePositions
; ///< [out] LUT (same for all channels) to represent sampling positions for
2895 ///< non-uniformly sampled LUTs.Can be NULL in case uniformly sampled LUTs
2897 } ctl_pixtx_1dlut_config_t
;
2899 ///////////////////////////////////////////////////////////////////////////////
2900 /// @brief Pixel transformation matrix configuration
2901 typedef struct _ctl_pixtx_matrix_config_t
2903 uint32_t Size
; ///< [in] size of this structure
2904 uint8_t Version
; ///< [in] version of this structure
2905 double PreOffsets
[3]; ///< [in,out] Pre offsets
2906 double PostOffsets
[3]; ///< [in,out] Post offsets
2907 double Matrix
[3][3]; ///< [in,out] 3x3 Matrix
2909 } ctl_pixtx_matrix_config_t
;
2911 ///////////////////////////////////////////////////////////////////////////////
2912 /// @brief Pixel transformation 3D LUT sample. Samples are converted to integer
2913 /// based on underlying HW capabilities. Hence slight precision loss will
2914 /// be observed while getting sample values.
2915 typedef struct _ctl_pixtx_3dlut_sample_t
2917 double Red
; ///< [in,out] Red output value
2918 double Green
; ///< [in,out] Green output value
2919 double Blue
; ///< [in,out] Blue output value
2921 } ctl_pixtx_3dlut_sample_t
;
2923 ///////////////////////////////////////////////////////////////////////////////
2924 /// @brief Pixel transformation 3D LUT configuration
2925 typedef struct _ctl_pixtx_3dlut_config_t
2927 uint32_t Size
; ///< [in] size of this structure
2928 uint8_t Version
; ///< [in] version of this structure
2929 uint32_t NumSamplesPerChannel
; ///< [in,out] Number of samples per channel
2930 ctl_pixtx_3dlut_sample_t
* pSampleValues
; ///< [in,out] Pointer to sample values, R in outer most loop followed by G
2933 } ctl_pixtx_3dlut_config_t
;
2935 ///////////////////////////////////////////////////////////////////////////////
2936 /// @brief Pixel transformation configuration
2937 typedef union _ctl_pixtx_config_t
2939 ctl_pixtx_1dlut_config_t OneDLutConfig
; ///< [in,out] 1D LUT configuration
2940 ctl_pixtx_3dlut_config_t ThreeDLutConfig
; ///< [in,out] 3D LUT configuration
2941 ctl_pixtx_matrix_config_t MatrixConfig
; ///< [in,out] Matrix configuration
2943 } ctl_pixtx_config_t
;
2945 ///////////////////////////////////////////////////////////////////////////////
2946 /// @brief Pixel transformation block configuration
2947 typedef struct _ctl_pixtx_block_config_t
2949 uint32_t Size
; ///< [in] size of this structure
2950 uint8_t Version
; ///< [in] version of this structure
2951 uint32_t BlockId
; ///< [in,out] Unique ID for each pixel processing block. Id for a block is
2952 ///< fixed for a platform.
2953 ctl_pixtx_block_type_t BlockType
; ///< [in,out] Block type
2954 ctl_pixtx_config_t Config
; ///< [in,out] Configuration
2956 } ctl_pixtx_block_config_t
;
2958 ///////////////////////////////////////////////////////////////////////////////
2959 /// @brief Pixel transformation pipe get configuration
2960 typedef struct _ctl_pixtx_pipe_get_config_t
2962 uint32_t Size
; ///< [in] size of this structure
2963 uint8_t Version
; ///< [in] version of this structure
2964 ctl_pixtx_config_query_type_t QueryType
; ///< [in] Query operation type
2965 ctl_pixtx_pixel_format_t InputPixelFormat
; ///< [out] Input pixel format
2966 ctl_pixtx_pixel_format_t OutputPixelFormat
; ///< [out] Output pixel format
2967 uint32_t NumBlocks
; ///< [out] Number of blocks
2968 ctl_pixtx_block_config_t
* pBlockConfigs
; ///< [out] Pointer to specific configs
2970 } ctl_pixtx_pipe_get_config_t
;
2972 ///////////////////////////////////////////////////////////////////////////////
2973 /// @brief Pixel transformation pipe set configuration
2974 typedef struct _ctl_pixtx_pipe_set_config_t
2976 uint32_t Size
; ///< [in] size of this structure
2977 uint8_t Version
; ///< [in] version of this structure
2978 ctl_pixtx_config_opertaion_type_t OpertaionType
;///< [in] Set operation type
2979 ctl_pixtx_pipe_set_config_flags_t Flags
; ///< [in] Config flags. Refer ::ctl_pixtx_pipe_set_config_flag_t
2980 uint32_t NumBlocks
; ///< [in] Number of blocks
2981 ctl_pixtx_block_config_t
* pBlockConfigs
; ///< [in,out] Array of block specific configs
2983 } ctl_pixtx_pipe_set_config_t
;
2985 ///////////////////////////////////////////////////////////////////////////////
2986 /// @brief Pixel transformation get pipe configuration
2989 /// - The application does pixel transformation get pipe configuration
2992 /// - CTL_RESULT_SUCCESS
2993 /// - CTL_RESULT_ERROR_UNINITIALIZED
2994 /// - CTL_RESULT_ERROR_DEVICE_LOST
2995 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2996 /// + `nullptr == hDisplayOutput`
2997 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2998 /// + `nullptr == pPixTxGetConfigArgs`
2999 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3000 /// - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS - "Insufficient permissions"
3001 /// - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
3002 /// - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
3003 /// - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
3004 /// - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
3005 /// - ::CTL_RESULT_ERROR_KMD_CALL - "Kernal mode driver call failure"
3006 /// - ::CTL_RESULT_ERROR_INVALID_PIXTX_GET_CONFIG_QUERY_TYPE - "Invalid query type"
3007 /// - ::CTL_RESULT_ERROR_INVALID_PIXTX_BLOCK_ID - "Invalid block id"
3008 /// - ::CTL_RESULT_ERROR_INSUFFICIENT_PIXTX_BLOCK_CONFIG_MEMORY - "Insufficient memery allocated for BlockConfigs"
3009 /// - ::CTL_RESULT_ERROR_3DLUT_INVALID_PIPE - "Invalid pipe for 3dlut"
3010 /// - ::CTL_RESULT_ERROR_3DLUT_INVALID_DATA - "Invalid 3dlut data"
3011 /// - ::CTL_RESULT_ERROR_3DLUT_NOT_SUPPORTED_IN_HDR - "3dlut not supported in HDR"
3012 /// - ::CTL_RESULT_ERROR_3DLUT_INVALID_OPERATION - "Invalid 3dlut operation"
3013 /// - ::CTL_RESULT_ERROR_3DLUT_UNSUCCESSFUL - "3dlut call unsuccessful"
3014 CTL_APIEXPORT ctl_result_t CTL_APICALL
3015 ctlPixelTransformationGetConfig(
3016 ctl_display_output_handle_t hDisplayOutput
, ///< [in] Handle to display output
3017 ctl_pixtx_pipe_get_config_t
* pPixTxGetConfigArgs
///< [in,out] Pixel transformation get pipe configiguration arguments
3020 ///////////////////////////////////////////////////////////////////////////////
3021 /// @brief Pixel transformation set pipe configuration
3024 /// - The application does pixel transformation set pipe configuration
3027 /// - CTL_RESULT_SUCCESS
3028 /// - CTL_RESULT_ERROR_UNINITIALIZED
3029 /// - CTL_RESULT_ERROR_DEVICE_LOST
3030 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3031 /// + `nullptr == hDisplayOutput`
3032 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3033 /// + `nullptr == pPixTxSetConfigArgs`
3034 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3035 /// - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS - "Insufficient permissions"
3036 /// - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
3037 /// - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
3038 /// - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
3039 /// - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
3040 /// - ::CTL_RESULT_ERROR_KMD_CALL - "Kernal mode driver call failure"
3041 /// - ::CTL_RESULT_ERROR_INVALID_PIXTX_SET_CONFIG_OPERATION_TYPE - "Invalid operation type"
3042 /// - ::CTL_RESULT_ERROR_INVALID_SET_CONFIG_NUMBER_OF_SAMPLES - "Invalid number of samples"
3043 /// - ::CTL_RESULT_ERROR_INVALID_PIXTX_BLOCK_ID - "Invalid block id"
3044 /// - ::CTL_RESULT_ERROR_PERSISTANCE_NOT_SUPPORTED - "Persistance not supported"
3045 /// - ::CTL_RESULT_ERROR_3DLUT_INVALID_PIPE - "Invalid pipe for 3dlut"
3046 /// - ::CTL_RESULT_ERROR_3DLUT_INVALID_DATA - "Invalid 3dlut data"
3047 /// - ::CTL_RESULT_ERROR_3DLUT_NOT_SUPPORTED_IN_HDR - "3dlut not supported in HDR"
3048 /// - ::CTL_RESULT_ERROR_3DLUT_INVALID_OPERATION - "Invalid 3dlut operation"
3049 /// - ::CTL_RESULT_ERROR_3DLUT_UNSUCCESSFUL - "3dlut call unsuccessful"
3050 CTL_APIEXPORT ctl_result_t CTL_APICALL
3051 ctlPixelTransformationSetConfig(
3052 ctl_display_output_handle_t hDisplayOutput
, ///< [in] Handle to display output
3053 ctl_pixtx_pipe_set_config_t
* pPixTxSetConfigArgs
///< [in,out] Pixel transformation set pipe configiguration arguments
3056 ///////////////////////////////////////////////////////////////////////////////
3057 /// @brief Panel descriptor access arguments
3058 typedef struct _ctl_panel_descriptor_access_args_t
3060 uint32_t Size
; ///< [in] size of this structure
3061 uint8_t Version
; ///< [in] version of this structure
3062 ctl_operation_type_t OpType
; ///< [in] Operation type, 1 for Read, 2 for Write. App needs to run with
3063 ///< admin privileges for Write operation, Currently only Read operation is
3065 uint32_t BlockNumber
; ///< [in] Block number, Need to provide only if acccessing EDID
3066 uint32_t DescriptorDataSize
; ///< [in] Descriptor data size, Should be 0 for querying the size and
3067 ///< should be DescriptorDataSize derived from query call otherwise
3068 uint8_t* pDescriptorData
; ///< [in,out] Panel descriptor data
3070 } ctl_panel_descriptor_access_args_t
;
3072 ///////////////////////////////////////////////////////////////////////////////
3073 /// @brief Panel Descriptor Access
3076 /// - The application does EDID or Display ID access
3079 /// - CTL_RESULT_SUCCESS
3080 /// - CTL_RESULT_ERROR_UNINITIALIZED
3081 /// - CTL_RESULT_ERROR_DEVICE_LOST
3082 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3083 /// + `nullptr == hDisplayOutput`
3084 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3085 /// + `nullptr == pPanelDescriptorAccessArgs`
3086 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3087 /// - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Invalid operation type"
3088 /// - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS - "Insufficient permissions"
3089 /// - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
3090 /// - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
3091 /// - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
3092 /// - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
3093 /// - ::CTL_RESULT_ERROR_KMD_CALL - "Kernal mode driver call failure"
3094 CTL_APIEXPORT ctl_result_t CTL_APICALL
3095 ctlPanelDescriptorAccess(
3096 ctl_display_output_handle_t hDisplayOutput
, ///< [in] Handle to display output
3097 ctl_panel_descriptor_access_args_t
* pPanelDescriptorAccessArgs
///< [in,out] Panel descriptor access arguments
3100 ///////////////////////////////////////////////////////////////////////////////
3101 /// @brief Retro Scaling Types
3102 typedef uint32_t ctl_retro_scaling_type_flags_t
;
3103 typedef enum _ctl_retro_scaling_type_flag_t
3105 CTL_RETRO_SCALING_TYPE_FLAG_INTEGER
= CTL_BIT(0), ///< Integer Scaling
3106 CTL_RETRO_SCALING_TYPE_FLAG_NEAREST_NEIGHBOUR
= CTL_BIT(1), ///< Nearest Neighbour Scaling
3107 CTL_RETRO_SCALING_TYPE_FLAG_MAX
= 0x80000000
3109 } ctl_retro_scaling_type_flag_t
;
3111 ///////////////////////////////////////////////////////////////////////////////
3112 /// @brief Set/Get Retro Scaling Type
3113 typedef struct _ctl_retro_scaling_settings_t
3115 uint32_t Size
; ///< [in] size of this structure
3116 uint8_t Version
; ///< [in] version of this structure
3117 bool Get
; ///< [in][release] Set to true to get current scaling . Set to False to Set
3119 bool Enable
; ///< [in,out] State of the scaler
3120 ctl_retro_scaling_type_flags_t RetroScalingType
;///< [out] Requested retro scaling types. Refer
3121 ///< ::ctl_retro_scaling_type_flag_t
3123 } ctl_retro_scaling_settings_t
;
3125 ///////////////////////////////////////////////////////////////////////////////
3126 /// @brief Retro Scaling caps
3127 typedef struct _ctl_retro_scaling_caps_t
3129 uint32_t Size
; ///< [in] size of this structure
3130 uint8_t Version
; ///< [in] version of this structure
3131 ctl_retro_scaling_type_flags_t SupportedRetroScaling
; ///< [out] Supported retro scaling types
3133 } ctl_retro_scaling_caps_t
;
3135 ///////////////////////////////////////////////////////////////////////////////
3136 /// @brief Get Supported Retro Scaling Types
3139 /// - Returns supported retro scaling capabilities
3142 /// - CTL_RESULT_SUCCESS
3143 /// - CTL_RESULT_ERROR_UNINITIALIZED
3144 /// - CTL_RESULT_ERROR_DEVICE_LOST
3145 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3146 /// + `nullptr == hDAhandle`
3147 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3148 /// + `nullptr == pRetroScalingCaps`
3149 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3150 CTL_APIEXPORT ctl_result_t CTL_APICALL
3151 ctlGetSupportedRetroScalingCapability(
3152 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to adapter
3153 ctl_retro_scaling_caps_t
* pRetroScalingCaps
///< [in,out][release] Query result for supported retro scaling types
3156 ///////////////////////////////////////////////////////////////////////////////
3157 /// @brief Get/Set Retro Scaling
3160 /// - Get or Set the status of retro scaling.This Api will do a physical
3161 /// modeset resulting in flash on the screen
3164 /// - CTL_RESULT_SUCCESS
3165 /// - CTL_RESULT_ERROR_UNINITIALIZED
3166 /// - CTL_RESULT_ERROR_DEVICE_LOST
3167 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3168 /// + `nullptr == hDAhandle`
3169 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3170 /// + `nullptr == pGetSetRetroScalingType`
3171 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3172 CTL_APIEXPORT ctl_result_t CTL_APICALL
3173 ctlGetSetRetroScaling(
3174 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to adapter
3175 ctl_retro_scaling_settings_t
* pGetSetRetroScalingType
///< [in,out][release] Get or Set the retro scaling type
3178 ///////////////////////////////////////////////////////////////////////////////
3179 /// @brief Scaling Types
3180 typedef uint32_t ctl_scaling_type_flags_t
;
3181 typedef enum _ctl_scaling_type_flag_t
3183 CTL_SCALING_TYPE_FLAG_IDENTITY
= CTL_BIT(0), ///< No scaling is applied and display manages scaling itself when possible
3184 CTL_SCALING_TYPE_FLAG_CENTERED
= CTL_BIT(1), ///< Source is not scaled but place in the center of the target display
3185 CTL_SCALING_TYPE_FLAG_STRETCHED
= CTL_BIT(2), ///< Source is stretched to fit the target size
3186 CTL_SCALING_TYPE_FLAG_ASPECT_RATIO_CENTERED_MAX
= CTL_BIT(3), ///< The aspect ratio is maintained with the source centered
3187 CTL_SCALING_TYPE_FLAG_CUSTOM
= CTL_BIT(4), ///< None of the standard types match this .Additional parameters are
3188 ///< required which should be set via a private driver interface
3189 CTL_SCALING_TYPE_FLAG_MAX
= 0x80000000
3191 } ctl_scaling_type_flag_t
;
3193 ///////////////////////////////////////////////////////////////////////////////
3194 /// @brief Scaling caps
3195 typedef struct _ctl_scaling_caps_t
3197 uint32_t Size
; ///< [in] size of this structure
3198 uint8_t Version
; ///< [in] version of this structure
3199 ctl_scaling_type_flags_t SupportedScaling
; ///< [out] Supported scaling types. Refer ::ctl_scaling_type_flag_t
3201 } ctl_scaling_caps_t
;
3203 ///////////////////////////////////////////////////////////////////////////////
3204 /// @brief Set/Get Scaling type
3205 typedef struct _ctl_scaling_settings_t
3207 uint32_t Size
; ///< [in] size of this structure
3208 uint8_t Version
; ///< [in] version of this structure
3209 bool Enable
; ///< [in,out] State of the scaler
3210 ctl_scaling_type_flags_t ScalingType
; ///< [in,out] Requested scaling types. Refer ::ctl_scaling_type_flag_t
3211 uint32_t CustomScalingX
; ///< [in,out] Custom Scaling X resolution
3212 uint32_t CustomScalingY
; ///< [in,out] Custom Scaling Y resolution
3213 bool HardwareModeSet
; ///< [in] Flag to indicate hardware modeset should be done to apply the
3214 ///< scaling.Setting this to true would result in a flash on the screen. If
3215 ///< this flag is set to false , API will request the OS to do a virtual
3216 ///< modeset , but the OS can ignore this request and do a hardware modeset
3217 ///< in some instances
3219 } ctl_scaling_settings_t
;
3221 ///////////////////////////////////////////////////////////////////////////////
3222 /// @brief Get Supported Scaling Types
3225 /// - Returns supported scaling capabilities
3228 /// - CTL_RESULT_SUCCESS
3229 /// - CTL_RESULT_ERROR_UNINITIALIZED
3230 /// - CTL_RESULT_ERROR_DEVICE_LOST
3231 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3232 /// + `nullptr == hDisplayOutput`
3233 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3234 /// + `nullptr == pScalingCaps`
3235 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3236 CTL_APIEXPORT ctl_result_t CTL_APICALL
3237 ctlGetSupportedScalingCapability(
3238 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
3239 ctl_scaling_caps_t
* pScalingCaps
///< [in,out][release] Query result for supported scaling types
3242 ///////////////////////////////////////////////////////////////////////////////
3243 /// @brief Get Current Scaling
3246 /// - Returns current active scaling
3249 /// - CTL_RESULT_SUCCESS
3250 /// - CTL_RESULT_ERROR_UNINITIALIZED
3251 /// - CTL_RESULT_ERROR_DEVICE_LOST
3252 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3253 /// + `nullptr == hDisplayOutput`
3254 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3255 /// + `nullptr == pGetCurrentScalingType`
3256 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3257 CTL_APIEXPORT ctl_result_t CTL_APICALL
3258 ctlGetCurrentScaling(
3259 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
3260 ctl_scaling_settings_t
* pGetCurrentScalingType
///< [in,out][release] Query result for active scaling types
3263 ///////////////////////////////////////////////////////////////////////////////
3264 /// @brief Set Scaling Type
3267 /// - Returns current active scaling
3270 /// - CTL_RESULT_SUCCESS
3271 /// - CTL_RESULT_ERROR_UNINITIALIZED
3272 /// - CTL_RESULT_ERROR_DEVICE_LOST
3273 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3274 /// + `nullptr == hDisplayOutput`
3275 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3276 /// + `nullptr == pSetScalingType`
3277 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3278 CTL_APIEXPORT ctl_result_t CTL_APICALL
3279 ctlSetCurrentScaling(
3280 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
3281 ctl_scaling_settings_t
* pSetScalingType
///< [in,out][release] Set scaling types
3284 ///////////////////////////////////////////////////////////////////////////////
3285 /// @brief Ambient light based enhancement table entry
3286 typedef struct _ctl_lace_lux_aggr_map_entry_t
3288 uint32_t Lux
; ///< [in,out] Ambient lux
3289 uint8_t AggressivenessPercent
; ///< [in,out] Pixel boost agressiveness
3291 } ctl_lace_lux_aggr_map_entry_t
;
3293 ///////////////////////////////////////////////////////////////////////////////
3294 /// @brief Ambient light based enhancement table
3295 typedef struct _ctl_lace_lux_aggr_map_t
3297 uint32_t MaxNumEntries
; ///< [out] Max Number of entries in mapping table supported
3298 uint32_t NumEntries
; ///< [in,out] Number of entries in the given mapping table
3299 ctl_lace_lux_aggr_map_entry_t
* pLuxToAggrMappingTable
; ///< [in] Max number of Entries which can be passed in
3300 ///< LuxToAggrMappingTable
3302 } ctl_lace_lux_aggr_map_t
;
3304 ///////////////////////////////////////////////////////////////////////////////
3305 /// @brief Data specific to the mode caller is interested in
3306 typedef union _ctl_lace_aggr_config_t
3308 uint8_t FixedAggressivenessLevelPercent
; ///< [in,out] Fixed aggressiveness level, applicable for
3309 ///< CTL_LACE_MODE_FIXED_AGGR_LEVEL
3310 ctl_lace_lux_aggr_map_t AggrLevelMap
; ///< [in,out] Lux to enhancement mapping table, applicable for
3311 ///< CTL_LACE_MODE_AMBIENT_ADAPTIVE
3313 } ctl_lace_aggr_config_t
;
3315 ///////////////////////////////////////////////////////////////////////////////
3316 /// @brief Get Operations used for additional settings
3317 typedef uint32_t ctl_get_operation_flags_t
;
3318 typedef enum _ctl_get_operation_flag_t
3320 CTL_GET_OPERATION_FLAG_CURRENT
= CTL_BIT(0), ///< Get the details set through last set call
3321 CTL_GET_OPERATION_FLAG_DEFAULT
= CTL_BIT(1), ///< Get the driver default values
3322 CTL_GET_OPERATION_FLAG_CAPABILITY
= CTL_BIT(2), ///< Get capability
3323 CTL_GET_OPERATION_FLAG_MAX
= 0x80000000
3325 } ctl_get_operation_flag_t
;
3327 ///////////////////////////////////////////////////////////////////////////////
3328 /// @brief Set Operations used for additional settings
3329 typedef enum _ctl_set_operation_t
3331 CTL_SET_OPERATION_RESTORE_DEFAULT
= 0, ///< Restore default values
3332 CTL_SET_OPERATION_CUSTOM
= 1, ///< Set custom values
3333 CTL_SET_OPERATION_MAX
3335 } ctl_set_operation_t
;
3337 ///////////////////////////////////////////////////////////////////////////////
3338 /// @brief Lace Trigger Modes
3339 typedef uint32_t ctl_lace_trigger_flags_t
;
3340 typedef enum _ctl_lace_trigger_flag_t
3342 CTL_LACE_TRIGGER_FLAG_AMBIENT_LIGHT
= CTL_BIT(0), ///< LACE enhancement depends on Ambient light
3343 CTL_LACE_TRIGGER_FLAG_FIXED_AGGRESSIVENESS
= CTL_BIT(1),///< LACE enhancement is as per given fixed aggressiveness level
3344 CTL_LACE_TRIGGER_FLAG_MAX
= 0x80000000
3346 } ctl_lace_trigger_flag_t
;
3348 ///////////////////////////////////////////////////////////////////////////////
3349 /// @brief Set/Get LACE Config
3350 typedef struct _ctl_lace_config_t
3352 uint32_t Size
; ///< [in] size of this structure
3353 uint8_t Version
; ///< [in] version of this structure
3354 bool Enabled
; ///< [in,out] Enable or disable LACE feature
3355 ctl_get_operation_flags_t OpTypeGet
; ///< [in] Get Operations used for additional settings
3356 ctl_set_operation_t OpTypeSet
; ///< [in] Set Operations used for additional settings
3357 ctl_lace_trigger_flags_t Trigger
; ///< [in,out] LACE operating mode to be Triggerd
3358 ctl_lace_aggr_config_t LaceConfig
; ///< [in,out] Data specific to the mode, caller is interested in
3360 } ctl_lace_config_t
;
3362 ///////////////////////////////////////////////////////////////////////////////
3363 /// @brief Get LACE Config
3366 /// - Returns current LACE Config
3369 /// - CTL_RESULT_SUCCESS
3370 /// - CTL_RESULT_ERROR_UNINITIALIZED
3371 /// - CTL_RESULT_ERROR_DEVICE_LOST
3372 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3373 /// + `nullptr == hDisplayOutput`
3374 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3375 /// + `nullptr == pLaceConfig`
3376 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3377 /// - ::CTL_RESULT_ERROR_LACE_INVALID_DATA_ARGUMENT_PASSED - "Lace Incorrrect AggressivePercent data or LuxVsAggressive Map data passed by user"
3378 CTL_APIEXPORT ctl_result_t CTL_APICALL
3380 ctl_display_output_handle_t hDisplayOutput
, ///< [in] Handle to display output
3381 ctl_lace_config_t
* pLaceConfig
///< [out]Lace configuration
3384 ///////////////////////////////////////////////////////////////////////////////
3385 /// @brief Sets LACE Config
3388 /// - Sets LACE Config
3391 /// - CTL_RESULT_SUCCESS
3392 /// - CTL_RESULT_ERROR_UNINITIALIZED
3393 /// - CTL_RESULT_ERROR_DEVICE_LOST
3394 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3395 /// + `nullptr == hDisplayOutput`
3396 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3397 /// + `nullptr == pLaceConfig`
3398 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3399 /// - ::CTL_RESULT_ERROR_LACE_INVALID_DATA_ARGUMENT_PASSED - "Lace Incorrrect AggressivePercent data or LuxVsAggressive Map data passed by user"
3400 CTL_APIEXPORT ctl_result_t CTL_APICALL
3402 ctl_display_output_handle_t hDisplayOutput
, ///< [in]Handle to display output
3403 ctl_lace_config_t
* pLaceConfig
///< [in]Lace configuration
3406 ///////////////////////////////////////////////////////////////////////////////
3407 /// @brief Get Software PSR status/Set Software PSR settings
3408 typedef struct _ctl_sw_psr_settings_t
3410 uint32_t Size
; ///< [in] size of this structure
3411 uint8_t Version
; ///< [in] version of this structure
3412 bool Set
; ///< [in][release] Set to False to Get Software PSR status. Set to True to
3413 ///< Enable/Disable Software PSR
3414 bool Supported
; ///< [out] When Get is True, returns if SW PSR is supported
3415 bool Enable
; ///< [in,out] When Get is True, returns current state of Software PSR.
3416 ///< When Get is False, Enables/Diasbles Software PSR
3418 } ctl_sw_psr_settings_t
;
3420 ///////////////////////////////////////////////////////////////////////////////
3421 /// @brief Get Software PSR caps/Set software PSR State
3424 /// - Returns Software PSR status or Sets Software PSR capabilities. This is
3425 /// a reserved capability. By default, software PSR is not supported/will
3426 /// not be enabled, need application to activate it, please contact Intel
3430 /// - CTL_RESULT_SUCCESS
3431 /// - CTL_RESULT_ERROR_UNINITIALIZED
3432 /// - CTL_RESULT_ERROR_DEVICE_LOST
3433 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3434 /// + `nullptr == hDisplayOutput`
3435 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3436 /// + `nullptr == pSoftwarePsrSetting`
3437 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3438 CTL_APIEXPORT ctl_result_t CTL_APICALL
3440 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
3441 ctl_sw_psr_settings_t
* pSoftwarePsrSetting
///< [in,out][release] Get Software PSR caps/state or Set Software PSR
3445 ///////////////////////////////////////////////////////////////////////////////
3446 /// @brief Intel Arc Sync Monitor Params
3447 typedef struct _ctl_intel_arc_sync_monitor_params_t
3449 uint32_t Size
; ///< [in] size of this structure
3450 uint8_t Version
; ///< [in] version of this structure
3451 bool IsIntelArcSyncSupported
; ///< [out] Intel Arc Sync support for the monitor
3452 float MinimumRefreshRateInHz
; ///< [out] Minimum Intel Arc Sync refresh rate supported by the monitor
3453 float MaximumRefreshRateInHz
; ///< [out] Maximum Intel Arc Sync refresh rate supported by the monitor
3454 uint32_t MaxFrameTimeIncreaseInUs
; ///< [out] Max frame time increase in micro seconds from DID2.1 Adaptive
3456 uint32_t MaxFrameTimeDecreaseInUs
; ///< [out] Max frame time decrease in micro seconds from DID2.1 Adaptive
3459 } ctl_intel_arc_sync_monitor_params_t
;
3461 ///////////////////////////////////////////////////////////////////////////////
3462 /// @brief Get Intel Arc Sync information for monitor
3465 /// - Returns Intel Arc Sync information for selected monitor
3468 /// - CTL_RESULT_SUCCESS
3469 /// - CTL_RESULT_ERROR_UNINITIALIZED
3470 /// - CTL_RESULT_ERROR_DEVICE_LOST
3471 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3472 /// + `nullptr == hDisplayOutput`
3473 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3474 /// + `nullptr == pIntelArcSyncMonitorParams`
3475 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3476 CTL_APIEXPORT ctl_result_t CTL_APICALL
3477 ctlGetIntelArcSyncInfoForMonitor(
3478 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
3479 ctl_intel_arc_sync_monitor_params_t
* pIntelArcSyncMonitorParams
///< [in,out][release] Intel Arc Sync params for monitor
3482 ///////////////////////////////////////////////////////////////////////////////
3483 /// @brief Handle of a MUX output instance
3484 typedef struct _ctl_mux_output_handle_t
*ctl_mux_output_handle_t
;
3486 ///////////////////////////////////////////////////////////////////////////////
3487 /// @brief Enumerate Display MUX Devices on this system across adapters
3490 /// - The application enumerates all MUX devices in the system
3493 /// - CTL_RESULT_SUCCESS
3494 /// - CTL_RESULT_ERROR_UNINITIALIZED
3495 /// - CTL_RESULT_ERROR_DEVICE_LOST
3496 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3497 /// + `nullptr == hAPIHandle`
3498 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3499 /// + `nullptr == pCount`
3500 /// + `nullptr == phMuxDevices`
3501 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3502 CTL_APIEXPORT ctl_result_t CTL_APICALL
3503 ctlEnumerateMuxDevices(
3504 ctl_api_handle_t hAPIHandle
, ///< [in][release] Applications should pass the Control API handle returned
3505 ///< by the CtlInit function
3506 uint32_t* pCount
, ///< [in,out][release] pointer to the number of MUX device instances. If
3507 ///< input count is zero, then the api will update the value with the total
3508 ///< number of MUX devices available and return the Count value. If input
3509 ///< count is non-zero, then the api will only retrieve the number of MUX Devices.
3510 ///< If count is larger than the number of MUX devices available, then the
3511 ///< api will update the value with the correct number of MUX devices available.
3512 ctl_mux_output_handle_t
* phMuxDevices
///< [out][range(0, *pCount)] array of MUX device instance handles
3515 ///////////////////////////////////////////////////////////////////////////////
3516 /// @brief Display MUX device properties
3517 typedef struct _ctl_mux_properties_t
3519 uint32_t Size
; ///< [in] size of this structure
3520 uint8_t Version
; ///< [in] version of this structure
3521 uint8_t MuxId
; ///< [out] MUX ID of this MUX device enumerated
3522 uint32_t Count
; ///< [in,out] Pointer to the number of display output instances this MUX
3523 ///< object can drive. If count is zero, then the api will update the value
3525 ///< number of outputs available. If count is non-zero, then the api will
3526 ///< only retrieve the number of outputs.
3527 ///< If count is larger than the number of display outputs MUX can drive,
3528 ///< then the api will update the value with the correct number of display
3529 ///< outputs MUX can driver.
3530 ctl_display_output_handle_t
* phDisplayOutputs
; ///< [in,out][range(0, *pCount)] Array of display output instance handles
3531 ///< this MUX device can drive
3532 uint8_t IndexOfDisplayOutputOwningMux
; ///< [out] [range(0, (Count-1))] This is the index into the
3533 ///< phDisplayOutputs list to the display output which currently owns the
3534 ///< MUX output. This doesn't mean display is active
3536 } ctl_mux_properties_t
;
3538 ///////////////////////////////////////////////////////////////////////////////
3539 /// @brief Get Display Mux properties
3542 /// - Get the propeties of the Mux device
3545 /// - CTL_RESULT_SUCCESS
3546 /// - CTL_RESULT_ERROR_UNINITIALIZED
3547 /// - CTL_RESULT_ERROR_DEVICE_LOST
3548 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3549 /// + `nullptr == hMuxDevice`
3550 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3551 /// + `nullptr == pMuxProperties`
3552 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3553 CTL_APIEXPORT ctl_result_t CTL_APICALL
3554 ctlGetMuxProperties(
3555 ctl_mux_output_handle_t hMuxDevice
, ///< [in] MUX device instance handle
3556 ctl_mux_properties_t
* pMuxProperties
///< [in,out] MUX device properties
3559 ///////////////////////////////////////////////////////////////////////////////
3560 /// @brief Switch Mux output
3563 /// - Switches the MUX output
3566 /// - CTL_RESULT_SUCCESS
3567 /// - CTL_RESULT_ERROR_UNINITIALIZED
3568 /// - CTL_RESULT_ERROR_DEVICE_LOST
3569 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3570 /// + `nullptr == hMuxDevice`
3571 /// + `nullptr == hInactiveDisplayOutput`
3572 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3573 CTL_APIEXPORT ctl_result_t CTL_APICALL
3575 ctl_mux_output_handle_t hMuxDevice
, ///< [in] MUX device instance handle
3576 ctl_display_output_handle_t hInactiveDisplayOutput
///< [out] Input selection for this MUX, which if active will drive the
3577 ///< output of this MUX device. This should be one of the display output
3578 ///< handles reported under this MUX device's properties.
3581 ///////////////////////////////////////////////////////////////////////////////
3582 /// @brief Intel Arc Sync profile
3583 typedef enum _ctl_intel_arc_sync_profile_t
3585 CTL_INTEL_ARC_SYNC_PROFILE_INVALID
= 0, ///< Invalid profile
3586 CTL_INTEL_ARC_SYNC_PROFILE_RECOMMENDED
= 1, ///< Default. Selects appropriate profile based on the monitor. COMPATIBLE
3587 ///< profile is applied if profile is not available for the monitor
3588 CTL_INTEL_ARC_SYNC_PROFILE_EXCELLENT
= 2, ///< Unconstrained. Full VRR range of the monitor can be used
3589 CTL_INTEL_ARC_SYNC_PROFILE_GOOD
= 3, ///< Some minor range constraints, unlikely to effect user experience but
3590 ///< can reduce flicker on some monitors
3591 CTL_INTEL_ARC_SYNC_PROFILE_COMPATIBLE
= 4, ///< Significant constraints that will reduce flicker considerably but are
3592 ///< likely to cause some level of judder onscreen especially when refresh
3593 ///< rates are changing rapidly
3594 CTL_INTEL_ARC_SYNC_PROFILE_OFF
= 5, ///< Disable Intel Arc Sync on this monitor. This disables variable rate
3595 ///< flips on this monitor. All sync flips will occur at the OS requested
3597 CTL_INTEL_ARC_SYNC_PROFILE_VESA
= 6, ///< Applies vesa specified constraints if the monitor has provided them,
3598 ///< COMPATIBLE profile if not
3599 CTL_INTEL_ARC_SYNC_PROFILE_CUSTOM
= 7, ///< Unlocks controls to set a custom Intel Arc Sync profile
3600 CTL_INTEL_ARC_SYNC_PROFILE_MAX
3602 } ctl_intel_arc_sync_profile_t
;
3604 ///////////////////////////////////////////////////////////////////////////////
3605 /// @brief Intel Arc Sync Profile Params
3606 typedef struct _ctl_intel_arc_sync_profile_params_t
3608 uint32_t Size
; ///< [in] size of this structure
3609 uint8_t Version
; ///< [in] version of this structure
3610 ctl_intel_arc_sync_profile_t IntelArcSyncProfile
; ///< [in,out] Intel Arc Sync profile used by driver. Refer
3611 ///< ::ctl_intel_arc_sync_profile_t
3612 float MaxRefreshRateInHz
; ///< [in,out] Maximum refresh rate utilized by the driver
3613 float MinRefreshRateInHz
; ///< [in,out] Minimum refresh rate utilized by the driver
3614 uint32_t MaxFrameTimeIncreaseInUs
; ///< [in,out] Maximum frame time increase (in micro seconds) imposed by the
3616 uint32_t MaxFrameTimeDecreaseInUs
; ///< [in,out] Maximum frame time decrease (in micro seconds) imposed by the
3619 } ctl_intel_arc_sync_profile_params_t
;
3621 ///////////////////////////////////////////////////////////////////////////////
3622 /// @brief Get Intel Arc Sync profile
3625 /// - Returns Intel Arc Sync profile for selected monitor
3628 /// - CTL_RESULT_SUCCESS
3629 /// - CTL_RESULT_ERROR_UNINITIALIZED
3630 /// - CTL_RESULT_ERROR_DEVICE_LOST
3631 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3632 /// + `nullptr == hDisplayOutput`
3633 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3634 /// + `nullptr == pIntelArcSyncProfileParams`
3635 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3636 CTL_APIEXPORT ctl_result_t CTL_APICALL
3637 ctlGetIntelArcSyncProfile(
3638 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
3639 ctl_intel_arc_sync_profile_params_t
* pIntelArcSyncProfileParams
///< [in,out][release] Intel Arc Sync params for monitor
3642 ///////////////////////////////////////////////////////////////////////////////
3643 /// @brief Set Intel Arc Sync profile
3646 /// - Sets Intel Arc Sync profile for selected monitor. In a mux situation,
3647 /// this API should be called for all display IDs associated with a
3648 /// physical display.
3651 /// - CTL_RESULT_SUCCESS
3652 /// - CTL_RESULT_ERROR_UNINITIALIZED
3653 /// - CTL_RESULT_ERROR_DEVICE_LOST
3654 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3655 /// + `nullptr == hDisplayOutput`
3656 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3657 /// + `nullptr == pIntelArcSyncProfileParams`
3658 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3659 CTL_APIEXPORT ctl_result_t CTL_APICALL
3660 ctlSetIntelArcSyncProfile(
3661 ctl_display_output_handle_t hDisplayOutput
, ///< [in][release] Handle to display output
3662 ctl_intel_arc_sync_profile_params_t
* pIntelArcSyncProfileParams
///< [in][release] Intel Arc Sync params for monitor
3665 ///////////////////////////////////////////////////////////////////////////////
3666 /// @brief EDID Management operation type
3667 typedef enum _ctl_edid_management_optype_t
3669 CTL_EDID_MANAGEMENT_OPTYPE_READ_EDID
= 1, ///< This operation type is to read an output's EDID. Set edid_type input
3670 ///< arg to read MONITOR EDID or previously OVERRIDDEN EDID or CURRENT
3671 ///< active EDID. Read EDID is a 2 pass call. First call with size = 0,
3672 ///< pEdidBuf = nullptr to get the size, then call with allocated buffer to
3673 ///< get the EDID data. READ operation is applicable for any normal, edid
3674 ///< locked or edid overridden display output device.
3675 CTL_EDID_MANAGEMENT_OPTYPE_LOCK_EDID
= 2, ///< To make an output always connected with OVERRIDE or MONITOR EDID
3676 ///< across reboots. When output isn't connected call with OVERRIDE EDID;
3677 ///< when connected, either set OVERRIDE and provide pEdidBuf or set
3678 ///< MONITOR and driver will use monitor's EDID. There is no change to EDID
3679 ///< stored in Monitor. Cannot be called when override is active. Any OS
3680 ///< EDID override will take precedence over IGCL override.
3681 CTL_EDID_MANAGEMENT_OPTYPE_UNLOCK_EDID
= 3, ///< To undo lock EDID operation, i.e. it makes output as detached in
3682 ///< response to unplug. This operation removes past supplied EDID; output
3683 ///< status is reported to OS as it is; output restores back to monitor's
3684 ///< EDID when it is connected
3685 CTL_EDID_MANAGEMENT_OPTYPE_OVERRIDE_EDID
= 4, ///< To replace an output's EDID with supplied one (pEdidBuf) only when
3686 ///< physical display is connected. There is no change to EDID stored in
3687 ///< Monitor. Cannot apply this operation on locked output. When no output
3688 ///< device attached, the supplied EDID will be persisted in driver for
3689 ///< future use. Any OS EDID override will take precedence over IGCL
3691 CTL_EDID_MANAGEMENT_OPTYPE_UNDO_OVERRIDE_EDID
= 5, ///< To undo override EDID operation, that is remove previously overridden
3692 ///< EDID on an output. Output restores back to monitor's EDID when it is
3694 CTL_EDID_MANAGEMENT_OPTYPE_MAX
3696 } ctl_edid_management_optype_t
;
3698 ///////////////////////////////////////////////////////////////////////////////
3699 /// @brief EDID type. Used in LOCK_EDID and READ_EDID calls.
3700 typedef enum _ctl_edid_type_t
3702 CTL_EDID_TYPE_CURRENT
= 1, ///< [in] Used to return currently active EDID in READ_EDID call.
3703 CTL_EDID_TYPE_OVERRIDE
= 2, ///< [in] Is it user supplied EDID. Used in LOCK_EDID call with Supplied
3704 ///< EDID or in READ_EDID to get Supplied EDID.
3705 CTL_EDID_TYPE_MONITOR
= 3, ///< [in] Is it Monitor's EDID. Used in LOCK_EDID and READ_EDID calls.
3710 ///////////////////////////////////////////////////////////////////////////////
3711 /// @brief Edid management operation Out Flags
3712 typedef uint32_t ctl_edid_management_out_flags_t
;
3713 typedef enum _ctl_edid_management_out_flag_t
3715 CTL_EDID_MANAGEMENT_OUT_FLAG_OS_CONN_NOTIFICATION
= CTL_BIT(0), ///< [out] If OS was notified about a connection change. App will need to
3716 ///< wait for the OS action to complete.
3717 CTL_EDID_MANAGEMENT_OUT_FLAG_SUPPLIED_EDID
= CTL_BIT(1),///< [out] Is it previously supplied EDID, set for READ_EDID(CURRENT).
3718 CTL_EDID_MANAGEMENT_OUT_FLAG_MONITOR_EDID
= CTL_BIT(2), ///< [out] Is it Monitor's EDID, set for READ_EDID(CURRENT).
3719 CTL_EDID_MANAGEMENT_OUT_FLAG_DISPLAY_CONNECTED
= CTL_BIT(3),///< [out] Is Monitor physically connected
3720 CTL_EDID_MANAGEMENT_OUT_FLAG_MAX
= 0x80000000
3722 } ctl_edid_management_out_flag_t
;
3724 ///////////////////////////////////////////////////////////////////////////////
3725 /// @brief EDID management
3726 typedef struct _ctl_edid_management_args_t
3728 uint32_t Size
; ///< [in] size of this structure
3729 uint8_t Version
; ///< [in] version of this structure
3730 ctl_edid_management_optype_t OpType
; ///< [in] EDID managmeent operation type
3731 ctl_edid_type_t EdidType
; ///< [in] EDID Type, Monitor or Supplied
3732 uint32_t EdidSize
; ///< [in,out] EDID Size, should be 0 for querying the size of EDID, should
3733 ///< be previously returned size to read EDID. if buffer isn't big enough
3734 ///< to fit EDID, returns size of EDID bytes.
3735 uint8_t* pEdidBuf
; ///< [in,out] buffer holding EDID data
3736 ctl_edid_management_out_flags_t OutFlags
; ///< [out] Output flags to inform about status of EDID management
3739 } ctl_edid_management_args_t
;
3741 ///////////////////////////////////////////////////////////////////////////////
3742 /// @brief EDID Management allows managing an output's EDID or Plugged Status.
3745 /// - To manage output's EDID or Display ID. Supports native DP SST and HDMI
3749 /// - CTL_RESULT_SUCCESS
3750 /// - CTL_RESULT_ERROR_UNINITIALIZED
3751 /// - CTL_RESULT_ERROR_DEVICE_LOST
3752 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3753 /// + `nullptr == hDisplayOutput`
3754 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3755 /// + `nullptr == pEdidManagementArgs`
3756 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3757 /// - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Invalid operation type"
3758 /// - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
3759 /// - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
3760 /// - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
3761 /// - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
3762 /// - ::CTL_RESULT_ERROR_KMD_CALL - "Kernal mode driver call failure"
3763 /// - ::CTL_RESULT_ERROR_INVALID_ARGUMENT - "Invalid combination of parameters"
3764 /// - ::CTL_RESULT_ERROR_DISPLAY_NOT_ATTACHED - "Error for Output Device not attached"
3765 /// - ::CTL_RESULT_ERROR_OUT_OF_DEVICE_MEMORY - "Insufficient device memory to satisfy call"
3766 /// - ::CTL_RESULT_ERROR_DATA_NOT_FOUND - "Requested EDID data not present."
3767 CTL_APIEXPORT ctl_result_t CTL_APICALL
3769 ctl_display_output_handle_t hDisplayOutput
, ///< [in] Handle to display output
3770 ctl_edid_management_args_t
* pEdidManagementArgs
///< [in,out] EDID management arguments
3773 ///////////////////////////////////////////////////////////////////////////////
3774 /// @brief Custom mode operation types
3775 typedef enum _ctl_custom_mode_operation_types_t
3777 CTL_CUSTOM_MODE_OPERATION_TYPES_GET_CUSTOM_SOURCE_MODES
= 0,///< Get details of all previous applied custom modes if any.
3778 CTL_CUSTOM_MODE_OPERATION_TYPES_ADD_CUSTOM_SOURCE_MODE
= 1, ///< Add a new mode. Allows only single mode adition at a time.
3779 CTL_CUSTOM_MODE_OPERATION_TYPES_REMOVE_CUSTOM_SOURCE_MODES
= 2, ///< Remove previously added custom mode. Allows single or multiple mode
3780 ///< removal at a time.
3781 CTL_CUSTOM_MODE_OPERATION_TYPES_MAX
3783 } ctl_custom_mode_operation_types_t
;
3785 ///////////////////////////////////////////////////////////////////////////////
3786 /// @brief Get/Set Custom Mode
3787 typedef struct _ctl_get_set_custom_mode_args_t
3789 uint32_t Size
; ///< [in] size of this structure
3790 uint8_t Version
; ///< [in] version of this structure
3791 ctl_custom_mode_operation_types_t CustomModeOpType
; ///< [in] Custom mode operation type
3792 uint32_t NumOfModes
; ///< [in,out] Number of Custom Src Modes to be added/removed/Read.
3793 ctl_custom_src_mode_t
* pCustomSrcModeList
; ///< [in,out] Custom mode source list which holds source modes to be
3794 ///< added/removed/Read.
3796 } ctl_get_set_custom_mode_args_t
;
3798 ///////////////////////////////////////////////////////////////////////////////
3799 /// @brief Get/Set Custom Mode
3800 typedef struct _ctl_custom_src_mode_t
3802 uint32_t SourceX
; ///< [in,out] CustomMode Source X Size
3803 uint32_t SourceY
; ///< [in,out] CustomMode Source Y Size
3805 } ctl_custom_src_mode_t
;
3807 ///////////////////////////////////////////////////////////////////////////////
3808 /// @brief Get/Set Custom mode.
3811 /// - To get or set custom mode.
3812 /// - Add custom source mode operation supports only single mode additon at
3814 /// - Remove custom source mode operation supports single or multiple mode
3815 /// removal at a time.
3818 /// - CTL_RESULT_SUCCESS
3819 /// - CTL_RESULT_ERROR_UNINITIALIZED
3820 /// - CTL_RESULT_ERROR_DEVICE_LOST
3821 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3822 /// + `nullptr == hDisplayOutput`
3823 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3824 /// + `nullptr == pCustomModeArgs`
3825 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3826 /// - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Invalid operation type"
3827 /// - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
3828 /// - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
3829 /// - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
3830 /// - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
3831 /// - ::CTL_RESULT_ERROR_KMD_CALL - "Kernal mode driver call failure"
3832 /// - ::CTL_RESULT_ERROR_INVALID_ARGUMENT - "Invalid combination of parameters"
3833 /// - ::CTL_RESULT_ERROR_CUSTOM_MODE_STANDARD_CUSTOM_MODE_EXISTS - "Standard custom mode exists"
3834 /// - ::CTL_RESULT_ERROR_CUSTOM_MODE_NON_CUSTOM_MATCHING_MODE_EXISTS - "Non custom matching mode exists"
3835 /// - ::CTL_RESULT_ERROR_CUSTOM_MODE_INSUFFICIENT_MEMORY - "Custom mode insufficent memory"
3836 CTL_APIEXPORT ctl_result_t CTL_APICALL
3837 ctlGetSetCustomMode(
3838 ctl_display_output_handle_t hDisplayOutput
, ///< [in] Handle to display output
3839 ctl_get_set_custom_mode_args_t
* pCustomModeArgs
///< [in,out] Custom mode arguments
3842 ///////////////////////////////////////////////////////////////////////////////
3843 /// @brief Combined Display operation type
3844 typedef enum _ctl_combined_display_optype_t
3846 CTL_COMBINED_DISPLAY_OPTYPE_IS_SUPPORTED_CONFIG
= 1,///< To check whether given outputs can form a combined display, no changes
3848 CTL_COMBINED_DISPLAY_OPTYPE_ENABLE
= 2, ///< To setup and enable a combined display
3849 CTL_COMBINED_DISPLAY_OPTYPE_DISABLE
= 3, ///< To disable combined display
3850 CTL_COMBINED_DISPLAY_OPTYPE_QUERY_CONFIG
= 4, ///< To query combined display configuration
3851 CTL_COMBINED_DISPLAY_OPTYPE_MAX
3853 } ctl_combined_display_optype_t
;
3855 ///////////////////////////////////////////////////////////////////////////////
3856 /// @brief Combined Display's child display target mode
3857 typedef struct _ctl_child_display_target_mode_t
3859 uint32_t Width
; ///< [in,out] Width
3860 uint32_t Height
; ///< [in,out] Height
3861 float RefreshRate
; ///< [in,out] Refresh Rate
3862 uint32_t ReservedFields
[4]; ///< [out] Reserved field of 16 bytes
3864 } ctl_child_display_target_mode_t
;
3866 ///////////////////////////////////////////////////////////////////////////////
3867 /// @brief Combined Display's child display information
3868 typedef struct _ctl_combined_display_child_info_t
3870 ctl_display_output_handle_t hDisplayOutput
; ///< [in,out] Display output handle under combined display configuration
3871 ctl_rect_t FbSrc
; ///< [in,out] FrameBuffer source's RECT within Combined Display respective
3872 ctl_rect_t FbPos
; ///< [in,out] FrameBuffer target's RECT within output size
3873 ctl_display_orientation_t DisplayOrientation
; ///< [in,out] 0/180 Degree Display orientation (rotation)
3874 ctl_child_display_target_mode_t TargetMode
; ///< [in,out] Desired target mode (width, height, refresh)
3876 } ctl_combined_display_child_info_t
;
3878 ///////////////////////////////////////////////////////////////////////////////
3879 /// @brief Combined Display arguments
3880 typedef struct _ctl_combined_display_args_t
3882 uint32_t Size
; ///< [in] size of this structure
3883 uint8_t Version
; ///< [in] version of this structure
3884 ctl_combined_display_optype_t OpType
; ///< [in] Combined display operation type
3885 bool IsSupported
; ///< [out] Returns yes/no in response to IS_SUPPORTED_CONFIG command
3886 uint8_t NumOutputs
; ///< [in,out] Number of outputs part of desired combined display
3888 uint32_t CombinedDesktopWidth
; ///< [in,out] Width of desired combined display configuration
3889 uint32_t CombinedDesktopHeight
; ///< [in,out] Height of desired combined display configuration
3890 ctl_combined_display_child_info_t
* pChildInfo
; ///< [in,out] List of child display information respective to each output
3891 ctl_display_output_handle_t hCombinedDisplayOutput
; ///< [in,out] Handle to combined display output
3893 } ctl_combined_display_args_t
;
3895 ///////////////////////////////////////////////////////////////////////////////
3896 /// @brief Get/Set Combined Display
3899 /// - To get or set combined display.
3902 /// - CTL_RESULT_SUCCESS
3903 /// - CTL_RESULT_ERROR_UNINITIALIZED
3904 /// - CTL_RESULT_ERROR_DEVICE_LOST
3905 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3906 /// + `nullptr == hDeviceAdapter`
3907 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3908 /// + `nullptr == pCombinedDisplayArgs`
3909 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3910 /// - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Invalid operation type"
3911 /// - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS - "Insufficient permissions"
3912 /// - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
3913 /// - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
3914 /// - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
3915 /// - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
3916 /// - ::CTL_RESULT_ERROR_KMD_CALL - "Kernel mode driver call failure"
3917 /// - ::CTL_RESULT_ERROR_FEATURE_NOT_SUPPORTED - "Combined Display feature is not supported in this platform"
3918 CTL_APIEXPORT ctl_result_t CTL_APICALL
3919 ctlGetSetCombinedDisplay(
3920 ctl_device_adapter_handle_t hDeviceAdapter
, ///< [in][release] Handle to control device adapter
3921 ctl_combined_display_args_t
* pCombinedDisplayArgs
///< [in,out] Setup and get combined display arguments
3924 ///////////////////////////////////////////////////////////////////////////////
3925 /// @brief Display Genlock Operations
3926 typedef enum _ctl_genlock_operation_t
3928 CTL_GENLOCK_OPERATION_GET_TIMING_DETAILS
= 0, ///< Get details of GENLOCK support and timing information
3929 CTL_GENLOCK_OPERATION_VALIDATE
= 1, ///< Driver to verify that the topology is Genlock capable
3930 CTL_GENLOCK_OPERATION_ENABLE
= 2, ///< Enable GENLOCK
3931 CTL_GENLOCK_OPERATION_DISABLE
= 3, ///< Disable GENLOCK
3932 CTL_GENLOCK_OPERATION_GET_TOPOLOGY
= 4, ///< Get details of the current Genlock topology that is applied
3933 CTL_GENLOCK_OPERATION_MAX
3935 } ctl_genlock_operation_t
;
3937 ///////////////////////////////////////////////////////////////////////////////
3938 /// @brief Display Genlock Info
3939 typedef struct _ctl_genlock_display_info_t
3941 ctl_display_output_handle_t hDisplayOutput
; ///< [in,out] Display output handle under Genlock topology
3942 bool IsPrimary
; ///< [in,out] Genlock Primary
3944 } ctl_genlock_display_info_t
;
3946 ///////////////////////////////////////////////////////////////////////////////
3947 /// @brief Genlock Target Mode List
3948 typedef struct _ctl_genlock_target_mode_list_t
3950 ctl_display_output_handle_t hDisplayOutput
; ///< [in] Display output handle for whom target mode list is required
3951 uint32_t NumModes
; ///< [in,out] Number of supported Modes that is returned from a driver
3952 ctl_display_timing_t
* pTargetModes
; ///< [out] Display Genlock operation and information
3954 } ctl_genlock_target_mode_list_t
;
3956 ///////////////////////////////////////////////////////////////////////////////
3957 /// @brief Genlock Topology
3958 typedef struct _ctl_genlock_topology_t
3960 uint8_t NumGenlockDisplays
; ///< [in,out] Number of Genlock displays
3961 bool IsPrimaryGenlockSystem
; ///< [in,out] Primary Genlock system
3962 ctl_display_timing_t CommonTargetMode
; ///< [in] Common target mode
3963 ctl_genlock_display_info_t
* pGenlockDisplayInfo
;///< [in,out] List of Genlock display info
3964 ctl_genlock_target_mode_list_t
* pGenlockModeList
; ///< [out] List of Genlock target modes
3966 } ctl_genlock_topology_t
;
3968 ///////////////////////////////////////////////////////////////////////////////
3969 /// @brief Display Genlock Arg type
3970 typedef struct _ctl_genlock_args_t
3972 uint32_t Size
; ///< [in] size of this structure
3973 uint8_t Version
; ///< [in] version of this structure
3974 ctl_genlock_operation_t Operation
; ///< [in] Display Genlock Operation
3975 ctl_genlock_topology_t GenlockTopology
; ///< [in,out] Display Genlock array of topology structures
3976 bool IsGenlockEnabled
; ///< [out] Whether the feature is currently enabled or not
3977 bool IsGenlockPossible
; ///< [out] Indicates if Genlock can be enabled/disabled with the given
3980 } ctl_genlock_args_t
;
3982 ///////////////////////////////////////////////////////////////////////////////
3983 /// @brief Get/Set Display Genlock
3986 /// - To get or set Display Genlock.
3989 /// - CTL_RESULT_SUCCESS
3990 /// - CTL_RESULT_ERROR_UNINITIALIZED
3991 /// - CTL_RESULT_ERROR_DEVICE_LOST
3992 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3993 /// + `nullptr == hDeviceAdapter`
3994 /// + `nullptr == pGenlockArgs`
3995 /// + `nullptr == hFailureDeviceAdapter`
3996 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3997 /// - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
3998 /// - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
3999 /// - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
4000 /// - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
4001 /// - ::CTL_RESULT_ERROR_INVALID_SIZE - "Invalid topology structure size"
4002 /// - ::CTL_RESULT_ERROR_KMD_CALL - "Kernel mode driver call failure"
4003 CTL_APIEXPORT ctl_result_t CTL_APICALL
4004 ctlGetSetDisplayGenlock(
4005 ctl_device_adapter_handle_t
* hDeviceAdapter
, ///< [in][release] Handle to control device adapter
4006 ctl_genlock_args_t
** pGenlockArgs
, ///< [in,out] Display Genlock operation and information
4007 uint32_t AdapterCount
, ///< [in] Number of device adapters
4008 ctl_device_adapter_handle_t
* hFailureDeviceAdapter
///< [out] Handle to address the failure device adapter in an error case
4012 #if !defined(__GNUC__)
4013 #pragma endregion // display
4015 // Intel 'ctlApi' for Device Adapter - Engine groups
4016 #if !defined(__GNUC__)
4017 #pragma region engine
4019 ///////////////////////////////////////////////////////////////////////////////
4020 /// @brief Accelerator engine groups
4021 typedef enum _ctl_engine_group_t
4023 CTL_ENGINE_GROUP_GT
= 0, ///< Access information about all engines combined.
4024 CTL_ENGINE_GROUP_RENDER
= 1, ///< Access information about all render and compute engines combined.
4025 CTL_ENGINE_GROUP_MEDIA
= 2, ///< Access information about all media engines combined.
4026 CTL_ENGINE_GROUP_MAX
4028 } ctl_engine_group_t
;
4030 ///////////////////////////////////////////////////////////////////////////////
4031 /// @brief Engine group properties
4032 typedef struct _ctl_engine_properties_t
4034 uint32_t Size
; ///< [in] size of this structure
4035 uint8_t Version
; ///< [in] version of this structure
4036 ctl_engine_group_t type
; ///< [out] The engine group
4038 } ctl_engine_properties_t
;
4040 ///////////////////////////////////////////////////////////////////////////////
4041 /// @brief Engine activity counters
4044 /// - Percent utilization is calculated by taking two snapshots (s1, s2) and
4045 /// using the equation: %util = (s2.activeTime - s1.activeTime) /
4046 /// (s2.timestamp - s1.timestamp)
4047 typedef struct _ctl_engine_stats_t
4049 uint32_t Size
; ///< [in] size of this structure
4050 uint8_t Version
; ///< [in] version of this structure
4051 uint64_t activeTime
; ///< [out] Monotonic counter for time in microseconds that this resource is
4052 ///< actively running workloads.
4053 uint64_t timestamp
; ///< [out] Monotonic timestamp counter in microseconds when activeTime
4054 ///< counter was sampled.
4055 ///< This timestamp should only be used to calculate delta time between
4056 ///< snapshots of this structure.
4057 ///< Never take the delta of this timestamp with the timestamp from a
4058 ///< different structure since they are not guaranteed to have the same base.
4059 ///< The absolute value of the timestamp is only valid during within the
4060 ///< application and may be different on the next execution.
4062 } ctl_engine_stats_t
;
4064 ///////////////////////////////////////////////////////////////////////////////
4065 /// @brief Get handle of engine groups
4068 /// - The application may call this function from simultaneous threads.
4069 /// - The implementation of this function should be lock-free.
4072 /// - CTL_RESULT_SUCCESS
4073 /// - CTL_RESULT_ERROR_UNINITIALIZED
4074 /// - CTL_RESULT_ERROR_DEVICE_LOST
4075 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4076 /// + `nullptr == hDAhandle`
4077 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4078 /// + `nullptr == pCount`
4079 CTL_APIEXPORT ctl_result_t CTL_APICALL
4080 ctlEnumEngineGroups(
4081 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to adapter
4082 uint32_t* pCount
, ///< [in,out] pointer to the number of components of this type.
4083 ///< if count is zero, then the driver shall update the value with the
4084 ///< total number of components of this type that are available.
4085 ///< if count is greater than the number of components of this type that
4086 ///< are available, then the driver shall update the value with the correct
4087 ///< number of components.
4088 ctl_engine_handle_t
* phEngine
///< [in,out][optional][range(0, *pCount)] array of handle of components of
4090 ///< if count is less than the number of components of this type that are
4091 ///< available, then the driver shall only retrieve that number of
4092 ///< component handles.
4095 ///////////////////////////////////////////////////////////////////////////////
4096 /// @brief Get engine group properties
4099 /// - The application may call this function from simultaneous threads.
4100 /// - The implementation of this function should be lock-free.
4103 /// - CTL_RESULT_SUCCESS
4104 /// - CTL_RESULT_ERROR_UNINITIALIZED
4105 /// - CTL_RESULT_ERROR_DEVICE_LOST
4106 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4107 /// + `nullptr == hEngine`
4108 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4109 /// + `nullptr == pProperties`
4110 CTL_APIEXPORT ctl_result_t CTL_APICALL
4111 ctlEngineGetProperties(
4112 ctl_engine_handle_t hEngine
, ///< [in] Handle for the component.
4113 ctl_engine_properties_t
* pProperties
///< [in,out] The properties for the specified engine group.
4116 ///////////////////////////////////////////////////////////////////////////////
4117 /// @brief Get the activity stats for an engine group
4120 /// - The application may call this function from simultaneous threads.
4121 /// - The implementation of this function should be lock-free.
4124 /// - CTL_RESULT_SUCCESS
4125 /// - CTL_RESULT_ERROR_UNINITIALIZED
4126 /// - CTL_RESULT_ERROR_DEVICE_LOST
4127 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4128 /// + `nullptr == hEngine`
4129 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4130 /// + `nullptr == pStats`
4131 CTL_APIEXPORT ctl_result_t CTL_APICALL
4132 ctlEngineGetActivity(
4133 ctl_engine_handle_t hEngine
, ///< [in] Handle for the component.
4134 ctl_engine_stats_t
* pStats
///< [in,out] Will contain a snapshot of the engine group activity
4139 #if !defined(__GNUC__)
4140 #pragma endregion // engine
4142 // Intel 'ctlApi' for Device Adapter- Fan management
4143 #if !defined(__GNUC__)
4146 ///////////////////////////////////////////////////////////////////////////////
4147 /// @brief Fan resource speed mode
4148 typedef enum _ctl_fan_speed_mode_t
4150 CTL_FAN_SPEED_MODE_DEFAULT
= 0, ///< The fan speed is operating using the hardware default settings
4151 CTL_FAN_SPEED_MODE_FIXED
= 1, ///< The fan speed is currently set to a fixed value
4152 CTL_FAN_SPEED_MODE_TABLE
= 2, ///< The fan speed is currently controlled dynamically by hardware based on
4153 ///< a temp/speed table
4154 CTL_FAN_SPEED_MODE_MAX
4156 } ctl_fan_speed_mode_t
;
4158 ///////////////////////////////////////////////////////////////////////////////
4159 /// @brief Fan speed units
4160 typedef enum _ctl_fan_speed_units_t
4162 CTL_FAN_SPEED_UNITS_RPM
= 0, ///< The fan speed is in units of revolutions per minute (rpm)
4163 CTL_FAN_SPEED_UNITS_PERCENT
= 1, ///< The fan speed is a percentage of the maximum speed of the fan
4164 CTL_FAN_SPEED_UNITS_MAX
4166 } ctl_fan_speed_units_t
;
4168 ///////////////////////////////////////////////////////////////////////////////
4169 /// @brief Fan speed
4170 typedef struct _ctl_fan_speed_t
4172 uint32_t Size
; ///< [in] size of this structure
4173 uint8_t Version
; ///< [in] version of this structure
4174 int32_t speed
; ///< [in,out] The speed of the fan. On output, a value of -1 indicates that
4175 ///< there is no fixed fan speed setting.
4176 ctl_fan_speed_units_t units
; ///< [in,out] The units that the fan speed is expressed in. On output, if
4177 ///< fan speed is -1 then units should be ignored.
4181 ///////////////////////////////////////////////////////////////////////////////
4182 /// @brief Fan temperature/speed pair
4183 typedef struct _ctl_fan_temp_speed_t
4185 uint32_t Size
; ///< [in] size of this structure
4186 uint8_t Version
; ///< [in] version of this structure
4187 uint32_t temperature
; ///< [in,out] Temperature in degrees Celsius.
4188 ctl_fan_speed_t speed
; ///< [in,out] The speed of the fan
4190 } ctl_fan_temp_speed_t
;
4192 ///////////////////////////////////////////////////////////////////////////////
4193 #ifndef CTL_FAN_TEMP_SPEED_PAIR_COUNT
4194 /// @brief Maximum number of fan temperature/speed pairs in the fan speed table.
4195 #define CTL_FAN_TEMP_SPEED_PAIR_COUNT 32
4196 #endif // CTL_FAN_TEMP_SPEED_PAIR_COUNT
4198 ///////////////////////////////////////////////////////////////////////////////
4199 /// @brief Fan speed table
4200 typedef struct _ctl_fan_speed_table_t
4202 uint32_t Size
; ///< [in] size of this structure
4203 uint8_t Version
; ///< [in] version of this structure
4204 int32_t numPoints
; ///< [in,out] The number of valid points in the fan speed table. 0 means
4205 ///< that there is no fan speed table configured. -1 means that a fan speed
4206 ///< table is not supported by the hardware.
4207 ctl_fan_temp_speed_t table
[CTL_FAN_TEMP_SPEED_PAIR_COUNT
]; ///< [in,out] Array of temperature/fan speed pairs. The table is ordered
4208 ///< based on temperature from lowest to highest.
4210 } ctl_fan_speed_table_t
;
4212 ///////////////////////////////////////////////////////////////////////////////
4213 /// @brief Fan properties
4214 typedef struct _ctl_fan_properties_t
4216 uint32_t Size
; ///< [in] size of this structure
4217 uint8_t Version
; ///< [in] version of this structure
4218 bool canControl
; ///< [out] Indicates if software can control the fan speed assuming the
4219 ///< user has permissions
4220 uint32_t supportedModes
; ///< [out] Bitfield of supported fan configuration modes
4221 ///< (1<<::ctl_fan_speed_mode_t)
4222 uint32_t supportedUnits
; ///< [out] Bitfield of supported fan speed units
4223 ///< (1<<::ctl_fan_speed_units_t)
4224 int32_t maxRPM
; ///< [out] The maximum RPM of the fan. A value of -1 means that this
4225 ///< property is unknown.
4226 int32_t maxPoints
; ///< [out] The maximum number of points in the fan temp/speed table. A
4227 ///< value of -1 means that this fan doesn't support providing a temp/speed
4230 } ctl_fan_properties_t
;
4232 ///////////////////////////////////////////////////////////////////////////////
4233 /// @brief Fan configuration
4234 typedef struct _ctl_fan_config_t
4236 uint32_t Size
; ///< [in] size of this structure
4237 uint8_t Version
; ///< [in] version of this structure
4238 ctl_fan_speed_mode_t mode
; ///< [in,out] The fan speed mode (fixed, temp-speed table)
4239 ctl_fan_speed_t speedFixed
; ///< [in,out] The current fixed fan speed setting
4240 ctl_fan_speed_table_t speedTable
; ///< [out] A table containing temperature/speed pairs
4244 ///////////////////////////////////////////////////////////////////////////////
4245 /// @brief Get handle of fans
4248 /// - The application may call this function from simultaneous threads.
4249 /// - The implementation of this function should be lock-free.
4252 /// - CTL_RESULT_SUCCESS
4253 /// - CTL_RESULT_ERROR_UNINITIALIZED
4254 /// - CTL_RESULT_ERROR_DEVICE_LOST
4255 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4256 /// + `nullptr == hDAhandle`
4257 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4258 /// + `nullptr == pCount`
4259 CTL_APIEXPORT ctl_result_t CTL_APICALL
4261 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to the adapter
4262 uint32_t* pCount
, ///< [in,out] pointer to the number of components of this type.
4263 ///< if count is zero, then the driver shall update the value with the
4264 ///< total number of components of this type that are available.
4265 ///< if count is greater than the number of components of this type that
4266 ///< are available, then the driver shall update the value with the correct
4267 ///< number of components.
4268 ctl_fan_handle_t
* phFan
///< [in,out][optional][range(0, *pCount)] array of handle of components of
4270 ///< if count is less than the number of components of this type that are
4271 ///< available, then the driver shall only retrieve that number of
4272 ///< component handles.
4275 ///////////////////////////////////////////////////////////////////////////////
4276 /// @brief Get fan properties
4279 /// - The application may call this function from simultaneous threads.
4280 /// - The implementation of this function should be lock-free.
4283 /// - CTL_RESULT_SUCCESS
4284 /// - CTL_RESULT_ERROR_UNINITIALIZED
4285 /// - CTL_RESULT_ERROR_DEVICE_LOST
4286 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4287 /// + `nullptr == hFan`
4288 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4289 /// + `nullptr == pProperties`
4290 CTL_APIEXPORT ctl_result_t CTL_APICALL
4291 ctlFanGetProperties(
4292 ctl_fan_handle_t hFan
, ///< [in] Handle for the component.
4293 ctl_fan_properties_t
* pProperties
///< [in,out] Will contain the properties of the fan.
4296 ///////////////////////////////////////////////////////////////////////////////
4297 /// @brief Get fan configurations and the current fan speed mode (default, fixed,
4298 /// temp-speed table)
4301 /// - The application may call this function from simultaneous threads.
4302 /// - The implementation of this function should be lock-free.
4305 /// - CTL_RESULT_SUCCESS
4306 /// - CTL_RESULT_ERROR_UNINITIALIZED
4307 /// - CTL_RESULT_ERROR_DEVICE_LOST
4308 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4309 /// + `nullptr == hFan`
4310 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4311 /// + `nullptr == pConfig`
4312 CTL_APIEXPORT ctl_result_t CTL_APICALL
4314 ctl_fan_handle_t hFan
, ///< [in] Handle for the component.
4315 ctl_fan_config_t
* pConfig
///< [in,out] Will contain the current configuration of the fan.
4318 ///////////////////////////////////////////////////////////////////////////////
4319 /// @brief Configure the fan to run with hardware factory settings (set mode to
4320 /// ::CTL_FAN_SPEED_MODE_DEFAULT)
4323 /// - The application may call this function from simultaneous threads.
4324 /// - The implementation of this function should be lock-free.
4327 /// - CTL_RESULT_SUCCESS
4328 /// - CTL_RESULT_ERROR_UNINITIALIZED
4329 /// - CTL_RESULT_ERROR_DEVICE_LOST
4330 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4331 /// + `nullptr == hFan`
4332 /// - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
4333 /// + User does not have permissions to make these modifications.
4334 CTL_APIEXPORT ctl_result_t CTL_APICALL
4335 ctlFanSetDefaultMode(
4336 ctl_fan_handle_t hFan
///< [in] Handle for the component.
4339 ///////////////////////////////////////////////////////////////////////////////
4340 /// @brief Configure the fan to rotate at a fixed speed (set mode to
4341 /// ::CTL_FAN_SPEED_MODE_FIXED)
4344 /// - The application may call this function from simultaneous threads.
4345 /// - The implementation of this function should be lock-free.
4348 /// - CTL_RESULT_SUCCESS
4349 /// - CTL_RESULT_ERROR_UNINITIALIZED
4350 /// - CTL_RESULT_ERROR_DEVICE_LOST
4351 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4352 /// + `nullptr == hFan`
4353 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4354 /// + `nullptr == speed`
4355 /// - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
4356 /// + User does not have permissions to make these modifications.
4357 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_FEATURE
4358 /// + Fixing the fan speed not supported by the hardware or the fan speed units are not supported. See ::ctl_fan_properties_t.supportedModes and ::ctl_fan_properties_t.supportedUnits.
4359 CTL_APIEXPORT ctl_result_t CTL_APICALL
4360 ctlFanSetFixedSpeedMode(
4361 ctl_fan_handle_t hFan
, ///< [in] Handle for the component.
4362 const ctl_fan_speed_t
* speed
///< [in] The fixed fan speed setting
4365 ///////////////////////////////////////////////////////////////////////////////
4366 /// @brief Configure the fan to adjust speed based on a temperature/speed table
4367 /// (set mode to ::CTL_FAN_SPEED_MODE_TABLE)
4370 /// - The application may call this function from simultaneous threads.
4371 /// - The implementation of this function should be lock-free.
4374 /// - CTL_RESULT_SUCCESS
4375 /// - CTL_RESULT_ERROR_UNINITIALIZED
4376 /// - CTL_RESULT_ERROR_DEVICE_LOST
4377 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4378 /// + `nullptr == hFan`
4379 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4380 /// + `nullptr == speedTable`
4381 /// - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
4382 /// + User does not have permissions to make these modifications.
4383 /// - ::CTL_RESULT_ERROR_INVALID_ARGUMENT
4384 /// + The temperature/speed pairs in the array are not sorted on temperature from lowest to highest.
4385 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_FEATURE
4386 /// + Fan speed table not supported by the hardware or the fan speed units are not supported. See ::ctl_fan_properties_t.supportedModes and ::ctl_fan_properties_t.supportedUnits.
4387 CTL_APIEXPORT ctl_result_t CTL_APICALL
4388 ctlFanSetSpeedTableMode(
4389 ctl_fan_handle_t hFan
, ///< [in] Handle for the component.
4390 const ctl_fan_speed_table_t
* speedTable
///< [in] A table containing temperature/speed pairs.
4393 ///////////////////////////////////////////////////////////////////////////////
4394 /// @brief Get current state of a fan - current mode and speed
4397 /// - The application may call this function from simultaneous threads.
4398 /// - The implementation of this function should be lock-free.
4401 /// - CTL_RESULT_SUCCESS
4402 /// - CTL_RESULT_ERROR_UNINITIALIZED
4403 /// - CTL_RESULT_ERROR_DEVICE_LOST
4404 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4405 /// + `nullptr == hFan`
4406 /// - CTL_RESULT_ERROR_INVALID_ENUMERATION
4407 /// + `::CTL_FAN_SPEED_UNITS_PERCENT < units`
4408 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4409 /// + `nullptr == pSpeed`
4410 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_FEATURE
4411 /// + The requested fan speed units are not supported. See ::ctl_fan_properties_t.supportedUnits.
4412 CTL_APIEXPORT ctl_result_t CTL_APICALL
4414 ctl_fan_handle_t hFan
, ///< [in] Handle for the component.
4415 ctl_fan_speed_units_t units
, ///< [in] The units in which the fan speed should be returned.
4416 int32_t* pSpeed
///< [in,out] Will contain the current speed of the fan in the units
4417 ///< requested. A value of -1 indicates that the fan speed cannot be
4422 #if !defined(__GNUC__)
4423 #pragma endregion // fan
4425 // Intel 'ctlApi' for Device Adapter - Frequency domains
4426 #if !defined(__GNUC__)
4427 #pragma region frequency
4429 ///////////////////////////////////////////////////////////////////////////////
4430 /// @brief Frequency domains.
4431 typedef enum _ctl_freq_domain_t
4433 CTL_FREQ_DOMAIN_GPU
= 0, ///< GPU Core Domain.
4434 CTL_FREQ_DOMAIN_MEMORY
= 1, ///< Local Memory Domain.
4437 } ctl_freq_domain_t
;
4439 ///////////////////////////////////////////////////////////////////////////////
4440 /// @brief Frequency properties
4441 typedef struct _ctl_freq_properties_t
4443 uint32_t Size
; ///< [in] size of this structure
4444 uint8_t Version
; ///< [in] version of this structure
4445 ctl_freq_domain_t type
; ///< [out] The hardware block that this frequency domain controls (GPU,
4447 bool canControl
; ///< [out] Indicates if software can control the frequency of this domain
4448 ///< assuming the user has permissions
4449 double min
; ///< [out] The minimum hardware clock frequency in units of MHz.
4450 double max
; ///< [out] The maximum non-overclock hardware clock frequency in units of
4453 } ctl_freq_properties_t
;
4455 ///////////////////////////////////////////////////////////////////////////////
4456 /// @brief Frequency range between which the hardware can operate. The limits can
4457 /// be above or below the hardware limits - the hardware will clamp
4459 typedef struct _ctl_freq_range_t
4461 uint32_t Size
; ///< [in] size of this structure
4462 uint8_t Version
; ///< [in] version of this structure
4463 double min
; ///< [in,out] The min frequency in MHz below which hardware frequency
4464 ///< management will not request frequencies. On input, setting to 0 will
4465 ///< permit the frequency to go down to the hardware minimum. On output, a
4466 ///< negative value indicates that no external minimum frequency limit is
4468 double max
; ///< [in,out] The max frequency in MHz above which hardware frequency
4469 ///< management will not request frequencies. On input, setting to 0 or a
4470 ///< very big number will permit the frequency to go all the way up to the
4471 ///< hardware maximum. On output, a negative number indicates that no
4472 ///< external maximum frequency limit is in effect.
4476 ///////////////////////////////////////////////////////////////////////////////
4477 /// @brief Frequency throttle reasons
4478 typedef uint32_t ctl_freq_throttle_reason_flags_t
;
4479 typedef enum _ctl_freq_throttle_reason_flag_t
4481 CTL_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP
= CTL_BIT(0), ///< frequency throttled due to average power excursion (PL1)
4482 CTL_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP
= CTL_BIT(1), ///< frequency throttled due to burst power excursion (PL2)
4483 CTL_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT
= CTL_BIT(2), ///< frequency throttled due to current excursion (PL4)
4484 CTL_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT
= CTL_BIT(3), ///< frequency throttled due to thermal excursion (T > TjMax)
4485 CTL_FREQ_THROTTLE_REASON_FLAG_PSU_ALERT
= CTL_BIT(4), ///< frequency throttled due to power supply assertion
4486 CTL_FREQ_THROTTLE_REASON_FLAG_SW_RANGE
= CTL_BIT(5),///< frequency throttled due to software supplied frequency range
4487 CTL_FREQ_THROTTLE_REASON_FLAG_HW_RANGE
= CTL_BIT(6),///< frequency throttled due to a sub block that has a lower frequency
4488 ///< range when it receives clocks
4489 CTL_FREQ_THROTTLE_REASON_FLAG_MAX
= 0x80000000
4491 } ctl_freq_throttle_reason_flag_t
;
4493 ///////////////////////////////////////////////////////////////////////////////
4494 /// @brief Frequency state
4495 typedef struct _ctl_freq_state_t
4497 uint32_t Size
; ///< [in] size of this structure
4498 uint8_t Version
; ///< [in] version of this structure
4499 double currentVoltage
; ///< [out] Current voltage in Volts. A negative value indicates that this
4500 ///< property is not known.
4501 double request
; ///< [out] The current frequency request in MHz. A negative value indicates
4502 ///< that this property is not known.
4503 double tdp
; ///< [out] The maximum frequency in MHz supported under the current TDP
4504 ///< conditions. This fluctuates dynamically based on the power and thermal
4505 ///< limits of the part. A negative value indicates that this property is
4507 double efficient
; ///< [out] The efficient minimum frequency in MHz. A negative value
4508 ///< indicates that this property is not known.
4509 double actual
; ///< [out] The resolved frequency in MHz. A negative value indicates that
4510 ///< this property is not known.
4511 ctl_freq_throttle_reason_flags_t throttleReasons
; ///< [out] The reasons that the frequency is being limited by the hardware.
4512 ///< Returns 0 (frequency not throttled) or a combination of ::ctl_freq_throttle_reason_flag_t.
4516 ///////////////////////////////////////////////////////////////////////////////
4517 /// @brief Frequency throttle time snapshot
4520 /// - Percent time throttled is calculated by taking two snapshots (s1, s2)
4521 /// and using the equation: %throttled = (s2.throttleTime -
4522 /// s1.throttleTime) / (s2.timestamp - s1.timestamp)
4523 typedef struct _ctl_freq_throttle_time_t
4525 uint32_t Size
; ///< [in] size of this structure
4526 uint8_t Version
; ///< [in] version of this structure
4527 uint64_t throttleTime
; ///< [out] The monotonic counter of time in microseconds that the frequency
4528 ///< has been limited by the hardware.
4529 uint64_t timestamp
; ///< [out] Microsecond timestamp when throttleTime was captured.
4530 ///< This timestamp should only be used to calculate delta time between
4531 ///< snapshots of this structure.
4532 ///< Never take the delta of this timestamp with the timestamp from a
4533 ///< different structure since they are not guaranteed to have the same base.
4534 ///< The absolute value of the timestamp is only valid during within the
4535 ///< application and may be different on the next execution.
4537 } ctl_freq_throttle_time_t
;
4539 ///////////////////////////////////////////////////////////////////////////////
4540 /// @brief Get handle of frequency domains
4543 /// - The application may call this function from simultaneous threads.
4544 /// - The implementation of this function should be lock-free.
4547 /// - CTL_RESULT_SUCCESS
4548 /// - CTL_RESULT_ERROR_UNINITIALIZED
4549 /// - CTL_RESULT_ERROR_DEVICE_LOST
4550 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4551 /// + `nullptr == hDAhandle`
4552 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4553 /// + `nullptr == pCount`
4554 CTL_APIEXPORT ctl_result_t CTL_APICALL
4555 ctlEnumFrequencyDomains(
4556 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to display adapter
4557 uint32_t* pCount
, ///< [in,out] pointer to the number of components of this type.
4558 ///< if count is zero, then the driver shall update the value with the
4559 ///< total number of components of this type that are available.
4560 ///< if count is greater than the number of components of this type that
4561 ///< are available, then the driver shall update the value with the correct
4562 ///< number of components.
4563 ctl_freq_handle_t
* phFrequency
///< [in,out][optional][range(0, *pCount)] array of handle of components of
4565 ///< if count is less than the number of components of this type that are
4566 ///< available, then the driver shall only retrieve that number of
4567 ///< component handles.
4570 ///////////////////////////////////////////////////////////////////////////////
4571 /// @brief Get frequency properties - available frequencies
4574 /// - The application may call this function from simultaneous threads.
4575 /// - The implementation of this function should be lock-free.
4578 /// - CTL_RESULT_SUCCESS
4579 /// - CTL_RESULT_ERROR_UNINITIALIZED
4580 /// - CTL_RESULT_ERROR_DEVICE_LOST
4581 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4582 /// + `nullptr == hFrequency`
4583 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4584 /// + `nullptr == pProperties`
4585 CTL_APIEXPORT ctl_result_t CTL_APICALL
4586 ctlFrequencyGetProperties(
4587 ctl_freq_handle_t hFrequency
, ///< [in] Handle for the component.
4588 ctl_freq_properties_t
* pProperties
///< [in,out] The frequency properties for the specified domain.
4591 ///////////////////////////////////////////////////////////////////////////////
4592 /// @brief Get available non-overclocked hardware clock frequencies for the
4593 /// frequency domain
4596 /// - The list of available frequencies is returned in order of slowest to
4598 /// - The application may call this function from simultaneous threads.
4599 /// - The implementation of this function should be lock-free.
4602 /// - CTL_RESULT_SUCCESS
4603 /// - CTL_RESULT_ERROR_UNINITIALIZED
4604 /// - CTL_RESULT_ERROR_DEVICE_LOST
4605 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4606 /// + `nullptr == hFrequency`
4607 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4608 /// + `nullptr == pCount`
4609 CTL_APIEXPORT ctl_result_t CTL_APICALL
4610 ctlFrequencyGetAvailableClocks(
4611 ctl_freq_handle_t hFrequency
, ///< [in] Device handle of the device.
4612 uint32_t* pCount
, ///< [in,out] pointer to the number of frequencies.
4613 ///< if count is zero, then the driver shall update the value with the
4614 ///< total number of frequencies that are available.
4615 ///< if count is greater than the number of frequencies that are available,
4616 ///< then the driver shall update the value with the correct number of frequencies.
4617 double* phFrequency
///< [in,out][optional][range(0, *pCount)] array of frequencies in units of
4618 ///< MHz and sorted from slowest to fastest.
4619 ///< if count is less than the number of frequencies that are available,
4620 ///< then the driver shall only retrieve that number of frequencies.
4623 ///////////////////////////////////////////////////////////////////////////////
4624 /// @brief Get current frequency limits
4627 /// - The application may call this function from simultaneous threads.
4628 /// - The implementation of this function should be lock-free.
4631 /// - CTL_RESULT_SUCCESS
4632 /// - CTL_RESULT_ERROR_UNINITIALIZED
4633 /// - CTL_RESULT_ERROR_DEVICE_LOST
4634 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4635 /// + `nullptr == hFrequency`
4636 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4637 /// + `nullptr == pLimits`
4638 CTL_APIEXPORT ctl_result_t CTL_APICALL
4639 ctlFrequencyGetRange(
4640 ctl_freq_handle_t hFrequency
, ///< [in] Handle for the component.
4641 ctl_freq_range_t
* pLimits
///< [in,out] The range between which the hardware can operate for the
4642 ///< specified domain.
4645 ///////////////////////////////////////////////////////////////////////////////
4646 /// @brief Set frequency range between which the hardware can operate.
4649 /// - The application may call this function from simultaneous threads.
4650 /// - The implementation of this function should be lock-free.
4653 /// - CTL_RESULT_SUCCESS
4654 /// - CTL_RESULT_ERROR_UNINITIALIZED
4655 /// - CTL_RESULT_ERROR_DEVICE_LOST
4656 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4657 /// + `nullptr == hFrequency`
4658 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4659 /// + `nullptr == pLimits`
4660 /// - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
4661 /// + User does not have permissions to make these modifications.
4662 CTL_APIEXPORT ctl_result_t CTL_APICALL
4663 ctlFrequencySetRange(
4664 ctl_freq_handle_t hFrequency
, ///< [in] Handle for the component.
4665 const ctl_freq_range_t
* pLimits
///< [in] The limits between which the hardware can operate for the
4666 ///< specified domain.
4669 ///////////////////////////////////////////////////////////////////////////////
4670 /// @brief Get current frequency state - frequency request, actual frequency, TDP
4674 /// - The application may call this function from simultaneous threads.
4675 /// - The implementation of this function should be lock-free.
4678 /// - CTL_RESULT_SUCCESS
4679 /// - CTL_RESULT_ERROR_UNINITIALIZED
4680 /// - CTL_RESULT_ERROR_DEVICE_LOST
4681 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4682 /// + `nullptr == hFrequency`
4683 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4684 /// + `nullptr == pState`
4685 CTL_APIEXPORT ctl_result_t CTL_APICALL
4686 ctlFrequencyGetState(
4687 ctl_freq_handle_t hFrequency
, ///< [in] Handle for the component.
4688 ctl_freq_state_t
* pState
///< [in,out] Frequency state for the specified domain.
4691 ///////////////////////////////////////////////////////////////////////////////
4692 /// @brief Get frequency throttle time
4695 /// - The application may call this function from simultaneous threads.
4696 /// - The implementation of this function should be lock-free.
4699 /// - CTL_RESULT_SUCCESS
4700 /// - CTL_RESULT_ERROR_UNINITIALIZED
4701 /// - CTL_RESULT_ERROR_DEVICE_LOST
4702 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4703 /// + `nullptr == hFrequency`
4704 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4705 /// + `nullptr == pThrottleTime`
4706 CTL_APIEXPORT ctl_result_t CTL_APICALL
4707 ctlFrequencyGetThrottleTime(
4708 ctl_freq_handle_t hFrequency
, ///< [in] Handle for the component.
4709 ctl_freq_throttle_time_t
* pThrottleTime
///< [in,out] Will contain a snapshot of the throttle time counters for the
4710 ///< specified domain.
4714 #if !defined(__GNUC__)
4715 #pragma endregion // frequency
4717 // Intel 'ctlApi' for Device Adapter
4718 #if !defined(__GNUC__)
4719 #pragma region media
4721 ///////////////////////////////////////////////////////////////////////////////
4722 /// @brief Feature type
4723 typedef enum _ctl_video_processing_feature_t
4725 CTL_VIDEO_PROCESSING_FEATURE_FILM_MODE_DETECTION
= 0, ///< Film mode detection. Contains CTL_PROPERTY_VALUE_TYPE_BOOL ValueType.
4726 CTL_VIDEO_PROCESSING_FEATURE_NOISE_REDUCTION
= 1, ///< Noise reduction. Contains CTL_PROPERTY_VALUE_TYPE_CUSTOM type field
4727 ///< using struct ::ctl_video_processing_noise_reduction_t.
4728 CTL_VIDEO_PROCESSING_FEATURE_SHARPNESS
= 2, ///< Sharpness. Contains CTL_PROPERTY_VALUE_TYPE_UINT32 ValueType.
4729 CTL_VIDEO_PROCESSING_FEATURE_ADAPTIVE_CONTRAST_ENHANCEMENT
= 3, ///< Adaptive contrast enhancement. Contains
4730 ///< CTL_PROPERTY_VALUE_TYPE_CUSTOM type field using struct
4731 ///< ::ctl_video_processing_adaptive_contrast_enhancement_t.
4732 CTL_VIDEO_PROCESSING_FEATURE_SUPER_RESOLUTION
= 4, ///< Super resolution. Contains CTL_PROPERTY_VALUE_TYPE_CUSTOM ValueType
4733 ///< using ::ctl_video_processing_super_resolution_t. By defaut, Super
4734 ///< resolution is not active, need application to activate it, please
4735 ///< contact Intel for super resolution activation.
4736 CTL_VIDEO_PROCESSING_FEATURE_STANDARD_COLOR_CORRECTION
= 5, ///< Standard color correction. Controls Hue, Saturation, Contrast,
4737 ///< Brightness. Contains CTL_PROPERTY_VALUE_TYPE_CUSTOM type field using
4738 ///< struct ::ctl_video_processing_standard_color_correction_t.
4739 CTL_VIDEO_PROCESSING_FEATURE_TOTAL_COLOR_CORRECTION
= 6,///< Total color correction. Controls Red, Green, Blue, Yellow, Cyan,
4740 ///< Magenta. Contains CTL_PROPERTY_VALUE_TYPE_CUSTOM type field using
4741 ///< struct ::ctl_video_processing_total_color_correction_t.
4742 CTL_VIDEO_PROCESSING_FEATURE_SKIN_TONE_ENHANCEMENT
= 7, ///< Skin tone enhancement. Contains CTL_PROPERTY_VALUE_TYPE_UINT32
4744 CTL_VIDEO_PROCESSING_FEATURE_MAX
4746 } ctl_video_processing_feature_t
;
4748 ///////////////////////////////////////////////////////////////////////////////
4749 /// @brief Super resolution values possible
4750 typedef uint32_t ctl_video_processing_super_resolution_flags_t
;
4751 typedef enum _ctl_video_processing_super_resolution_flag_t
4753 CTL_VIDEO_PROCESSING_SUPER_RESOLUTION_FLAG_DISABLE
= CTL_BIT(0),///< Disable
4754 CTL_VIDEO_PROCESSING_SUPER_RESOLUTION_FLAG_ENABLE_DEFAULT_SCENARIO_MODE
= CTL_BIT(1), ///< Enable with default super resolution mode
4755 CTL_VIDEO_PROCESSING_SUPER_RESOLUTION_FLAG_ENABLE_CONFERENCE_SCENARIO_MODE
= CTL_BIT(2),///< Super resolution mode targeted at video conference content
4756 CTL_VIDEO_PROCESSING_SUPER_RESOLUTION_FLAG_ENABLE_CAMERA_SCENARIO_MODE
= CTL_BIT(3),///< Super resolution mode targeted at camera capture content (e.g.
4757 ///< security camera)
4758 CTL_VIDEO_PROCESSING_SUPER_RESOLUTION_FLAG_MAX
= 0x80000000
4760 } ctl_video_processing_super_resolution_flag_t
;
4762 ///////////////////////////////////////////////////////////////////////////////
4763 /// @brief Super Resolution feature details structure to be used with
4764 /// SUPER_RESOLUTION
4765 typedef struct _ctl_video_processing_super_resolution_info_t
4767 uint32_t Size
; ///< [in] size of this structure
4768 uint8_t Version
; ///< [in] version of this structure
4769 ctl_video_processing_super_resolution_flags_t super_resolution_flag
;///< [in,out] SUPER_RESOLUTION flag
4770 ctl_property_info_uint_t super_resolution_range_in_width
; ///< [in,out] The range of input width information(min, max, default and
4771 ///< step size)which super resolution is capable of supporting.
4772 ctl_property_info_uint_t super_resolution_range_in_height
; ///< [in,out] The range of input height information(min, max, default and
4773 ///< step size)which super resolution is capable of supporting.
4774 uint32_t ReservedFields
[16]; ///< [out] Reserved field of 64 bytes
4776 } ctl_video_processing_super_resolution_info_t
;
4778 ///////////////////////////////////////////////////////////////////////////////
4779 /// @brief Super Resolution Get/Set structure to be used with SUPER_RESOLUTION
4780 typedef struct _ctl_video_processing_super_resolution_t
4782 uint32_t Size
; ///< [in] size of this structure
4783 uint8_t Version
; ///< [in] version of this structure
4784 ctl_video_processing_super_resolution_flags_t super_resolution_flag
;///< [in,out] SUPER_RESOLUTION flag
4785 bool super_resolution_max_in_enabled
; ///< [in,out] The enabling of maximum input width and height limition. If
4786 ///< enabled, super resolution will always take effect if the input
4787 ///< resolution is smaller than the below specified max resolution;
4788 ///< otherwise, super_resolution_max_in_width and
4789 ///< super_resolution_max_in_height will be ignored
4790 uint32_t super_resolution_max_in_width
; ///< [in,out] The maximum input width limition value setting which super
4791 ///< resolution will be allowed to enabled.
4792 uint32_t super_resolution_max_in_height
; ///< [in,out] The maximum input height limiation value setting which super
4793 ///< resolution will be allowed to enabled.
4794 bool super_resolution_reboot_reset
; ///< [in,out] Resetting of super resolution after rebooting.
4795 uint32_t ReservedFields
[15]; ///< [out] Reserved field of 60 bytes
4796 char ReservedBytes
[3]; ///< [out] Reserved field of 3 bytes
4798 } ctl_video_processing_super_resolution_t
;
4800 ///////////////////////////////////////////////////////////////////////////////
4801 /// @brief Noise Reduction feature details structure to be used with
4803 typedef struct _ctl_video_processing_noise_reduction_info_t
4805 uint32_t Size
; ///< [in] size of this structure
4806 uint8_t Version
; ///< [in] version of this structure
4807 ctl_property_info_uint_t noise_reduction
; ///< [in,out] Noise reduction min, max, default and step size information
4808 bool noise_reduction_auto_detect_supported
; ///< [in,out] Noise reduction Auto Detect is supported; only valid if
4809 ///< NOISE_REDUCTION is enabled. If enabled, noise reduction level is
4810 ///< automatically determined and set value is not used.
4811 ctl_property_info_boolean_t noise_reduction_auto_detect
;///< [in,out] Noise reduction auto detect default information
4812 uint32_t ReservedFields
[16]; ///< [out] Reserved field of 64 bytes
4814 } ctl_video_processing_noise_reduction_info_t
;
4816 ///////////////////////////////////////////////////////////////////////////////
4817 /// @brief Noise Reduction Get/Set structure to be used with NOISE_REDUCTION
4818 typedef struct _ctl_video_processing_noise_reduction_t
4820 uint32_t Size
; ///< [in] size of this structure
4821 uint8_t Version
; ///< [in] version of this structure
4822 ctl_property_uint_t noise_reduction
; ///< [in,out] Noise reduction enable and value setting
4823 ctl_property_boolean_t noise_reduction_auto_detect
; ///< [in,out] Noise reduction auto detect setting
4824 uint32_t ReservedFields
[16]; ///< [out] Reserved field of 64 bytes
4826 } ctl_video_processing_noise_reduction_t
;
4828 ///////////////////////////////////////////////////////////////////////////////
4829 /// @brief Adaptive Contrast Enhancement feature details structure to be used
4830 /// with ADAPTIVE_CONTRAST_ENHANCEMENT
4831 typedef struct _ctl_video_processing_adaptive_contrast_enhancement_info_t
4833 uint32_t Size
; ///< [in] size of this structure
4834 uint8_t Version
; ///< [in] version of this structure
4835 ctl_property_info_uint_t adaptive_contrast_enhancement
; ///< [in,out] Adaptive Contrast Enhancement min, max, default and step size
4837 bool adaptive_contrast_enhancement_coexistence_supported
; ///< [in,out] Adaptive contrast enhancement coexistance is supported; only
4838 ///< valid if ADAPTIVE_CONTRAST_ENHANCEMENT is enabled. If enabled, Video
4839 ///< adaptive contrast ehancement will be allowed to be enabled and coexist
4840 ///< with Display adaptive contrast ehancement feature.
4841 ctl_property_info_boolean_t adaptive_contrast_enhancement_coexistence
; ///< [in,out] Adaptive contrast enhancement coexistence default information
4842 uint32_t ReservedFields
[16]; ///< [out] Reserved field of 64 bytes
4844 } ctl_video_processing_adaptive_contrast_enhancement_info_t
;
4846 ///////////////////////////////////////////////////////////////////////////////
4847 /// @brief Adaptive Contrast Enhancement Get/Set structure to be used with
4848 /// ADAPTIVE_CONTRAST_ENHANCEMENT
4849 typedef struct _ctl_video_processing_adaptive_contrast_enhancement_t
4851 uint32_t Size
; ///< [in] size of this structure
4852 uint8_t Version
; ///< [in] version of this structure
4853 ctl_property_uint_t adaptive_contrast_enhancement
; ///< [in,out] Adaptive Contrast Enhancement enable and value setting
4854 ctl_property_boolean_t adaptive_contrast_enhancement_coexistence
; ///< [in,out] Adaptive contrast enhancement coexistance setting
4855 uint32_t ReservedFields
[16]; ///< [out] Reserved field of 64 bytes
4857 } ctl_video_processing_adaptive_contrast_enhancement_t
;
4859 ///////////////////////////////////////////////////////////////////////////////
4860 /// @brief Standard Color Correction feature details structure to be used with
4861 /// STANDARD_COLOR_CORRECTION
4862 typedef struct _ctl_video_processing_standard_color_correction_info_t
4864 uint32_t Size
; ///< [in] size of this structure
4865 uint8_t Version
; ///< [in] version of this structure
4866 bool standard_color_correction_default_enable
; ///< [in,out] STANDARD_COLOR_CORRECTION default enable setting. This
4867 ///< global settings controls all of Hue, Saturation, Contrast, Brightness
4868 ///< enabling. Individual Enable controls shall be ignored.
4869 ctl_property_info_float_t brightness
; ///< [in,out] Brightness min, max, default and step size information
4870 ctl_property_info_float_t contrast
; ///< [in,out] Contrast min, max, default and step size information
4871 ctl_property_info_float_t hue
; ///< [in,out] Hue min, max, default and step size information
4872 ctl_property_info_float_t saturation
; ///< [in,out] Saturation min, max, default and step size information
4873 uint32_t ReservedFields
[16]; ///< [out] Reserved field of 64 bytes
4875 } ctl_video_processing_standard_color_correction_info_t
;
4877 ///////////////////////////////////////////////////////////////////////////////
4878 /// @brief Standard Color Correction Get/Set structure to be used with
4879 /// STANDARD_COLOR_CORRECTION
4880 typedef struct _ctl_video_processing_standard_color_correction_t
4882 uint32_t Size
; ///< [in] size of this structure
4883 uint8_t Version
; ///< [in] version of this structure
4884 bool standard_color_correction_enable
; ///< [in,out] STANDARD_COLOR_CORRECTION enable setting. This global
4885 ///< setting controls all of Hue, Saturation, Contrast, Brightness
4887 float brightness
; ///< [in,out] Brightness value
4888 float contrast
; ///< [in,out] Contrast value
4889 float hue
; ///< [in,out] Hue value
4890 float saturation
; ///< [in,out] Saturation value
4891 uint32_t ReservedFields
[16]; ///< [out] Reserved field of 64 bytes
4893 } ctl_video_processing_standard_color_correction_t
;
4895 ///////////////////////////////////////////////////////////////////////////////
4896 /// @brief Total Color Correction Get/Set structure to be used with
4897 /// TOTAL_COLOR_CORRECTION
4898 typedef struct _ctl_video_processing_total_color_correction_info_t
4900 uint32_t Size
; ///< [in] size of this structure
4901 uint8_t Version
; ///< [in] version of this structure
4902 bool total_color_correction_default_enable
; ///< [in,out] TOTAL_COLOR_CORRECTION enable setting. This global setting
4903 ///< controls all of Red, Green, Blue, Yellow, Cyan, Magenta enabling.
4904 ///< Individual Enable controls shall be ignored.
4905 ctl_property_info_uint_t red
; ///< [in,out] Red min, max, default and step size information
4906 ctl_property_info_uint_t green
; ///< [in,out] Green min, max, default and step size information
4907 ctl_property_info_uint_t blue
; ///< [in,out] Blue min, max, default and step size information
4908 ctl_property_info_uint_t yellow
; ///< [in,out] Yellow min, max, default and step size information
4909 ctl_property_info_uint_t cyan
; ///< [in,out] Cyan min, max, default and step size information
4910 ctl_property_info_uint_t magenta
; ///< [in,out] Magenta min, max, default and step size information
4911 uint32_t ReservedFields
[16]; ///< [out] Reserved field of 64 bytes
4913 } ctl_video_processing_total_color_correction_info_t
;
4915 ///////////////////////////////////////////////////////////////////////////////
4916 /// @brief Total Color Correction Get/Set structure to be used with
4917 /// TOTAL_COLOR_CORRECTION
4918 typedef struct _ctl_video_processing_total_color_correction_t
4920 uint32_t Size
; ///< [in] size of this structure
4921 uint8_t Version
; ///< [in] version of this structure
4922 bool total_color_correction_enable
; ///< [in,out] TOTAL_COLOR_CORRECTION enable setting. This global setting
4923 ///< controls all of Red, Green, Blue, Yellow, Cyan, Magenta enabling.
4924 uint32_t red
; ///< [in,out] Red value
4925 uint32_t green
; ///< [in,out] Green value
4926 uint32_t blue
; ///< [in,out] Blue value
4927 uint32_t yellow
; ///< [in,out] Yellow value
4928 uint32_t cyan
; ///< [in,out] Cyan value
4929 uint32_t magenta
; ///< [in,out] Magenta value
4930 uint32_t ReservedFields
[16]; ///< [out] Reserved field of 64 bytes
4932 } ctl_video_processing_total_color_correction_t
;
4934 ///////////////////////////////////////////////////////////////////////////////
4935 /// @brief Video Processing feature details which will have range supported and
4937 typedef struct _ctl_video_processing_feature_details_t
4939 uint32_t Size
; ///< [in] size of this structure
4940 uint8_t Version
; ///< [in] version of this structure
4941 ctl_video_processing_feature_t FeatureType
; ///< [out] Video processing feature type
4942 ctl_property_value_type_t ValueType
; ///< [out] Type of value
4943 ctl_property_info_t Value
; ///< [out] Union of various type of values for Video Processing features.
4944 ///< For enum types this can be noise reduction, color control etc. This
4945 ///< member is valid iff ValueType is not CTL_PROPERTY_VALUE_TYPE_CUSTOM
4946 int32_t CustomValueSize
; ///< [in] CustomValue buffer size
4947 void* pCustomValue
; ///< [in,out] Pointer to a custom structure. Features that use CustomType,
4948 ///< after the first query for all of the supported features the user needs
4949 ///< to allocate this buffer and then query again just this specific
4950 ///< feature for the structure to be filled in. Caller should allocate this
4951 ///< buffer with known custom feature structure size. This member is valid
4952 ///< iff ValueType is CTL_PROPERTY_VALUE_TYPE_CUSTOM.
4953 uint32_t ReservedFields
[16]; ///< [out] Reserved field of 64 bytes
4955 } ctl_video_processing_feature_details_t
;
4957 ///////////////////////////////////////////////////////////////////////////////
4958 /// @brief Video Processing features which are controllable
4959 typedef struct _ctl_video_processing_feature_caps_t
4961 uint32_t Size
; ///< [in] size of this structure
4962 uint8_t Version
; ///< [in] version of this structure
4963 uint32_t NumSupportedFeatures
; ///< [in,out] Number of elements in supported features array
4964 ctl_video_processing_feature_details_t
* pFeatureDetails
;///< [in,out] Array of supported features and their details
4965 uint32_t ReservedFields
[16]; ///< [out] Reserved field of 64 bytes
4967 } ctl_video_processing_feature_caps_t
;
4969 ///////////////////////////////////////////////////////////////////////////////
4970 /// @brief Video Processing feature for get/set
4971 typedef struct _ctl_video_processing_feature_getset_t
4973 uint32_t Size
; ///< [in] size of this structure
4974 uint8_t Version
; ///< [in] version of this structure
4975 ctl_video_processing_feature_t FeatureType
; ///< [in] Features interested in
4976 char* ApplicationName
; ///< [in] Application name for which the property type is applicable. If
4977 ///< this is an empty string then this will get/set global settings for the
4978 ///< given adapter. Note that this should contain only the name of the
4979 ///< application and not the system specific path. [This is not currently
4980 ///< supported and should be an empty string.]
4981 int8_t ApplicationNameLength
; ///< [in] Length of ApplicationName string
4982 bool bSet
; ///< [in] Set this if it's a set call
4983 ctl_property_value_type_t ValueType
; ///< [in] Type of value. Caller has to ensure it provides the right value
4984 ///< type which decides how one read the union structure below
4985 ctl_property_t Value
; ///< [in,out] Union of various type of values for Video Processing
4986 ///< features. For enum types this can be noise reduction, color control
4987 ///< etc. This member is valid iff ValueType is not
4988 ///< CTL_PROPERTY_VALUE_TYPE_CUSTOM
4989 int32_t CustomValueSize
; ///< [in] CustomValue buffer size. For a feature requiring custom struct,
4990 ///< caller will know of it upfront the struct to use based on the feautre
4991 ///< and can provide the right size info here
4992 void* pCustomValue
; ///< [in,out] Pointer to a custom structure. Caller should allocate this
4993 ///< buffer with known custom feature structure size. This member is valid
4994 ///< iff ValueType is CTL_PROPERTY_VALUE_TYPE_CUSTOM
4995 uint32_t ReservedFields
[16]; ///< [out] Reserved field of 64 bytes
4997 } ctl_video_processing_feature_getset_t
;
4999 ///////////////////////////////////////////////////////////////////////////////
5000 /// @brief Get Video Processing capabilities
5003 /// - The application gets Video Processing properties
5006 /// - CTL_RESULT_SUCCESS
5007 /// - CTL_RESULT_ERROR_UNINITIALIZED
5008 /// - CTL_RESULT_ERROR_DEVICE_LOST
5009 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5010 /// + `nullptr == hDAhandle`
5011 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5012 /// + `nullptr == pFeatureCaps`
5013 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
5014 CTL_APIEXPORT ctl_result_t CTL_APICALL
5015 ctlGetSupportedVideoProcessingCapabilities(
5016 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to display adapter
5017 ctl_video_processing_feature_caps_t
* pFeatureCaps
///< [in,out][release] Video Processing properties
5020 ///////////////////////////////////////////////////////////////////////////////
5021 /// @brief Get/Set Video Processing feature details
5024 /// - Video Processing feature details
5027 /// - CTL_RESULT_SUCCESS
5028 /// - CTL_RESULT_ERROR_UNINITIALIZED
5029 /// - CTL_RESULT_ERROR_DEVICE_LOST
5030 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5031 /// + `nullptr == hDAhandle`
5032 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5033 /// + `nullptr == pFeature`
5034 /// - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
5035 CTL_APIEXPORT ctl_result_t CTL_APICALL
5036 ctlGetSetVideoProcessingFeature(
5037 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to display adapter
5038 ctl_video_processing_feature_getset_t
* pFeature
///< [in][release] Video Processing feature get/set parameter
5042 #if !defined(__GNUC__)
5043 #pragma endregion // media
5045 // Intel 'ctlApi' for Device Adapter - Memory management
5046 #if !defined(__GNUC__)
5047 #pragma region memory
5049 ///////////////////////////////////////////////////////////////////////////////
5050 /// @brief Memory module types
5051 typedef enum _ctl_mem_type_t
5053 CTL_MEM_TYPE_HBM
= 0, ///< HBM memory
5054 CTL_MEM_TYPE_DDR
= 1, ///< DDR memory
5055 CTL_MEM_TYPE_DDR3
= 2, ///< DDR3 memory
5056 CTL_MEM_TYPE_DDR4
= 3, ///< DDR4 memory
5057 CTL_MEM_TYPE_DDR5
= 4, ///< DDR5 memory
5058 CTL_MEM_TYPE_LPDDR
= 5, ///< LPDDR memory
5059 CTL_MEM_TYPE_LPDDR3
= 6, ///< LPDDR3 memory
5060 CTL_MEM_TYPE_LPDDR4
= 7, ///< LPDDR4 memory
5061 CTL_MEM_TYPE_LPDDR5
= 8, ///< LPDDR5 memory
5062 CTL_MEM_TYPE_GDDR4
= 9, ///< GDDR4 memory
5063 CTL_MEM_TYPE_GDDR5
= 10, ///< GDDR5 memory
5064 CTL_MEM_TYPE_GDDR5X
= 11, ///< GDDR5X memory
5065 CTL_MEM_TYPE_GDDR6
= 12, ///< GDDR6 memory
5066 CTL_MEM_TYPE_GDDR6X
= 13, ///< GDDR6X memory
5067 CTL_MEM_TYPE_GDDR7
= 14, ///< GDDR7 memory
5068 CTL_MEM_TYPE_UNKNOWN
= 15, ///< UNKNOWN memory
5073 ///////////////////////////////////////////////////////////////////////////////
5074 /// @brief Memory module location
5075 typedef enum _ctl_mem_loc_t
5077 CTL_MEM_LOC_SYSTEM
= 0, ///< System memory
5078 CTL_MEM_LOC_DEVICE
= 1, ///< On board local device memory
5083 ///////////////////////////////////////////////////////////////////////////////
5084 /// @brief Memory properties
5085 typedef struct _ctl_mem_properties_t
5087 uint32_t Size
; ///< [in] size of this structure
5088 uint8_t Version
; ///< [in] version of this structure
5089 ctl_mem_type_t type
; ///< [out] The memory type
5090 ctl_mem_loc_t location
; ///< [out] Location of this memory (system, device)
5091 uint64_t physicalSize
; ///< [out] Physical memory size in bytes. A value of 0 indicates that this
5092 ///< property is not known. However, a call to ::ctlMemoryGetState() will
5093 ///< correctly return the total size of usable memory.
5094 int32_t busWidth
; ///< [out] Width of the memory bus. A value of -1 means that this property
5096 int32_t numChannels
; ///< [out] The number of memory channels. A value of -1 means that this
5097 ///< property is unknown.
5099 } ctl_mem_properties_t
;
5101 ///////////////////////////////////////////////////////////////////////////////
5102 /// @brief Memory state - health, allocated
5105 /// - Percent allocation is given by 100 * (size - free / size.
5106 /// - Percent free is given by 100 * free / size.
5107 typedef struct _ctl_mem_state_t
5109 uint32_t Size
; ///< [in] size of this structure
5110 uint8_t Version
; ///< [in] version of this structure
5111 uint64_t free
; ///< [out] The free memory in bytes
5112 uint64_t size
; ///< [out] The total allocatable memory in bytes (can be less than
5113 ///< ::ctl_mem_properties_t.physicalSize)
5117 ///////////////////////////////////////////////////////////////////////////////
5118 /// @brief Memory bandwidth
5121 /// - Percent bandwidth is calculated by taking two snapshots (s1, s2) and
5122 /// using the equation: %bw = 10^6 * ((s2.readCounter - s1.readCounter) +
5123 /// (s2.writeCounter - s1.writeCounter)) / (s2.maxBandwidth *
5124 /// (s2.timestamp - s1.timestamp))
5125 typedef struct _ctl_mem_bandwidth_t
5127 uint32_t Size
; ///< [in] size of this structure
5128 uint8_t Version
; ///< [in] version of this structure
5129 uint64_t maxBandwidth
; ///< [out] Current maximum bandwidth in units of bytes/sec
5130 uint64_t timestamp
; ///< [out] The timestamp (in microseconds) when these measurements were sampled.
5131 ///< This timestamp should only be used to calculate delta time between
5132 ///< snapshots of this structure.
5133 ///< Never take the delta of this timestamp with the timestamp from a
5134 ///< different structure since they are not guaranteed to have the same base.
5135 ///< The absolute value of the timestamp is only valid during within the
5136 ///< application and may be different on the next execution.
5137 uint64_t readCounter
; ///< [out] Total bytes read from memory. Supported only for Version > 0
5138 uint64_t writeCounter
; ///< [out] Total bytes written to memory. Supported only for Version > 0
5140 } ctl_mem_bandwidth_t
;
5142 ///////////////////////////////////////////////////////////////////////////////
5143 /// @brief Get handle of memory modules
5146 /// - The application may call this function from simultaneous threads.
5147 /// - The implementation of this function should be lock-free.
5150 /// - CTL_RESULT_SUCCESS
5151 /// - CTL_RESULT_ERROR_UNINITIALIZED
5152 /// - CTL_RESULT_ERROR_DEVICE_LOST
5153 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5154 /// + `nullptr == hDAhandle`
5155 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5156 /// + `nullptr == pCount`
5157 CTL_APIEXPORT ctl_result_t CTL_APICALL
5158 ctlEnumMemoryModules(
5159 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to display adapter
5160 uint32_t* pCount
, ///< [in,out] pointer to the number of components of this type.
5161 ///< if count is zero, then the driver shall update the value with the
5162 ///< total number of components of this type that are available.
5163 ///< if count is greater than the number of components of this type that
5164 ///< are available, then the driver shall update the value with the correct
5165 ///< number of components.
5166 ctl_mem_handle_t
* phMemory
///< [in,out][optional][range(0, *pCount)] array of handle of components of
5168 ///< if count is less than the number of components of this type that are
5169 ///< available, then the driver shall only retrieve that number of
5170 ///< component handles.
5173 ///////////////////////////////////////////////////////////////////////////////
5174 /// @brief Get memory properties
5177 /// - The application may call this function from simultaneous threads.
5178 /// - The implementation of this function should be lock-free.
5181 /// - CTL_RESULT_SUCCESS
5182 /// - CTL_RESULT_ERROR_UNINITIALIZED
5183 /// - CTL_RESULT_ERROR_DEVICE_LOST
5184 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5185 /// + `nullptr == hMemory`
5186 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5187 /// + `nullptr == pProperties`
5188 CTL_APIEXPORT ctl_result_t CTL_APICALL
5189 ctlMemoryGetProperties(
5190 ctl_mem_handle_t hMemory
, ///< [in] Handle for the component.
5191 ctl_mem_properties_t
* pProperties
///< [in,out] Will contain memory properties.
5194 ///////////////////////////////////////////////////////////////////////////////
5195 /// @brief Get memory state - health, allocated
5198 /// - The application may call this function from simultaneous threads.
5199 /// - The implementation of this function should be lock-free.
5202 /// - CTL_RESULT_SUCCESS
5203 /// - CTL_RESULT_ERROR_UNINITIALIZED
5204 /// - CTL_RESULT_ERROR_DEVICE_LOST
5205 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5206 /// + `nullptr == hMemory`
5207 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5208 /// + `nullptr == pState`
5209 CTL_APIEXPORT ctl_result_t CTL_APICALL
5211 ctl_mem_handle_t hMemory
, ///< [in] Handle for the component.
5212 ctl_mem_state_t
* pState
///< [in,out] Will contain the current health and allocated memory.
5215 ///////////////////////////////////////////////////////////////////////////////
5216 /// @brief Get memory bandwidth
5219 /// - The application may call this function from simultaneous threads.
5220 /// - The implementation of this function should be lock-free.
5223 /// - CTL_RESULT_SUCCESS
5224 /// - CTL_RESULT_ERROR_UNINITIALIZED
5225 /// - CTL_RESULT_ERROR_DEVICE_LOST
5226 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5227 /// + `nullptr == hMemory`
5228 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5229 /// + `nullptr == pBandwidth`
5230 /// - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
5231 /// + User does not have permissions to query this telemetry.
5232 CTL_APIEXPORT ctl_result_t CTL_APICALL
5233 ctlMemoryGetBandwidth(
5234 ctl_mem_handle_t hMemory
, ///< [in] Handle for the component.
5235 ctl_mem_bandwidth_t
* pBandwidth
///< [in,out] Will contain the current health, free memory, total memory
5240 #if !defined(__GNUC__)
5241 #pragma endregion // memory
5243 // Intel 'ctlApi' for Device Adapter - Overclock
5244 #if !defined(__GNUC__)
5245 #pragma region overclock
5247 ///////////////////////////////////////////////////////////////////////////////
5248 /// @brief Telemetry Item for each telemetry property
5251 /// - If the supported field is true, then the entire structure has valid
5253 /// - The ::ctl_data_value_t is of type ::ctl_data_type_t and units
5255 typedef struct _ctl_oc_telemetry_item_t
5257 bool bSupported
; ///< [out] Indicates if the value is supported.
5258 ctl_units_t units
; ///< [out] Indicates the units of the value.
5259 ctl_data_type_t type
; ///< [out] Indicates the data type.
5260 ctl_data_value_t value
; ///< [out] The value of type ::ctl_data_type_t and units ::ctl_units_t.
5262 } ctl_oc_telemetry_item_t
;
5264 ///////////////////////////////////////////////////////////////////////////////
5265 /// @brief Overclocking Control Information
5268 /// - Whether the device supports overclocking.
5270 /// bSupported/bRelative/bReference/units/min/max/step/default/reference
5271 /// values for the available overclock controls
5272 /// - The idea is to facilitate the way the applications present overclock
5273 /// settings to the user. If bSupported is false, the corresponding
5274 /// overclock control is not supported
5275 /// - The setting units will be an enum that enables the application to know
5276 /// the units for the control setting e.g. MHz. The min and max settings
5277 /// give the limits for the control.
5278 /// - The step setting gives the minimum change in the control value (plus
5279 /// or minus) - if a control is not changed by at least this amount, the
5280 /// hardware may round up or down.
5281 /// - The default values gives the manufacturing setting for the control.
5282 /// Some controls such as frequency offset and voltage offset are
5283 /// relative; in this case, bRelative will be true, otherwise the control
5284 /// settings are absolute values.
5285 /// - For relative controls and if bReference is true, the reference value
5286 /// gives the absolute value at the default setting.
5287 /// - If bReference is false, the absolute value of the default setting is
5288 /// no not known and it is probably better to display the setting to users
5289 /// as percentage offsets.
5290 typedef struct _ctl_oc_control_info_t
5292 bool bSupported
; ///< [out] Indicates if the values are known.
5293 bool bRelative
; ///< [out] Indicates if the values are meant to be taken as relative values
5294 ///< instead of absolut values.
5295 bool bReference
; ///< [out] For relative values, this indicates if a reference is available.
5296 ctl_units_t units
; ///< [out] Units for the values.
5297 double min
; ///< [out] Minimum Value.
5298 double max
; ///< [out] Maximum Value.
5299 double step
; ///< [out] Step Value.
5300 double Default
; ///< [out] Default Value.
5301 double reference
; ///< [out] Reference Value if the bReference is true.
5303 } ctl_oc_control_info_t
;
5305 ///////////////////////////////////////////////////////////////////////////////
5306 /// @brief Overclock properties
5307 typedef struct _ctl_oc_properties_t
5309 uint32_t Size
; ///< [in] size of this structure
5310 uint8_t Version
; ///< [in] version of this structure
5311 bool bSupported
; ///< [out] Indicates if the adapter supports overclocking.
5312 ctl_oc_control_info_t gpuFrequencyOffset
; ///< [out] related to function ::ctlOverclockGpuFrequencyOffsetSet
5313 ctl_oc_control_info_t gpuVoltageOffset
; ///< [out] related to function ::ctlOverclockGpuVoltageOffsetSet
5314 ctl_oc_control_info_t vramFrequencyOffset
; ///< [out] related to function ::ctlOverclockVramFrequencyOffsetSet
5315 ctl_oc_control_info_t vramVoltageOffset
; ///< [out] related to function ::ctlOverclockVramVoltageOffsetSet
5316 ctl_oc_control_info_t powerLimit
; ///< [out] related to function ::ctlOverclockPowerLimitSet
5317 ctl_oc_control_info_t temperatureLimit
; ///< [out] related to function ::ctlOverclockTemperatureLimitSet
5319 } ctl_oc_properties_t
;
5321 ///////////////////////////////////////////////////////////////////////////////
5322 /// @brief Overclock Voltage Frequency Pair
5323 typedef struct _ctl_oc_vf_pair_t
5325 uint32_t Size
; ///< [in] size of this structure
5326 uint8_t Version
; ///< [in] version of this structure
5327 double Voltage
; ///< [in,out] Voltage component of the pair in mV.
5328 double Frequency
; ///< [in,out] Frequency component of the pair in MHz.
5332 ///////////////////////////////////////////////////////////////////////////////
5333 #ifndef CTL_PSU_COUNT
5334 /// @brief Maximum number power supply units.
5335 #define CTL_PSU_COUNT 5
5336 #endif // CTL_PSU_COUNT
5338 ///////////////////////////////////////////////////////////////////////////////
5339 /// @brief PSU Type.
5340 typedef enum _ctl_psu_type_t
5342 CTL_PSU_TYPE_PSU_NONE
= 0, ///< Type of the PSU is unknown.
5343 CTL_PSU_TYPE_PSU_PCIE
= 1, ///< Type of the PSU is PCIe
5344 CTL_PSU_TYPE_PSU_6PIN
= 2, ///< Type of the PSU is 6 PIN
5345 CTL_PSU_TYPE_PSU_8PIN
= 3, ///< Type of the PSU is 8 PIN
5350 ///////////////////////////////////////////////////////////////////////////////
5352 typedef struct _ctl_psu_info_t
5354 bool bSupported
; ///< [out] Indicates if this PSU entry is supported.
5355 ctl_psu_type_t psuType
; ///< [out] Type of the PSU.
5356 ctl_oc_telemetry_item_t energyCounter
; ///< [out] Snapshot of the monotonic energy counter maintained by hardware.
5357 ///< It measures the total energy consumed this power source. By taking the
5358 ///< delta between two snapshots and dividing by the delta time in seconds,
5359 ///< an application can compute the average power.
5360 ctl_oc_telemetry_item_t voltage
; ///< [out] Instantaneous snapshot of the voltage of this power source.
5364 ///////////////////////////////////////////////////////////////////////////////
5365 #ifndef CTL_FAN_COUNT
5366 /// @brief Maximum number of Fans
5367 #define CTL_FAN_COUNT 5
5368 #endif // CTL_FAN_COUNT
5370 ///////////////////////////////////////////////////////////////////////////////
5371 /// @brief Power Telemetry
5372 typedef struct _ctl_power_telemetry_t
5374 uint32_t Size
; ///< [in] size of this structure
5375 uint8_t Version
; ///< [in] version of this structure
5376 ctl_oc_telemetry_item_t timeStamp
; ///< [out] Snapshot of the timestamp counter that measures the total time
5377 ///< since Jan 1, 1970 UTC. It is a decimal value in seconds with a minimum
5378 ///< accuracy of 1 millisecond.
5379 ctl_oc_telemetry_item_t gpuEnergyCounter
; ///< [out] Snapshot of the monotonic energy counter maintained by hardware.
5380 ///< It measures the total energy consumed by the GPU chip. By taking the
5381 ///< delta between two snapshots and dividing by the delta time in seconds,
5382 ///< an application can compute the average power.
5383 ctl_oc_telemetry_item_t gpuVoltage
; ///< [out] Instantaneous snapshot of the voltage feeding the GPU chip. It
5384 ///< is measured at the power supply output - chip input will be lower.
5385 ctl_oc_telemetry_item_t gpuCurrentClockFrequency
; ///< [out] Instantaneous snapshot of the GPU chip frequency.
5386 ctl_oc_telemetry_item_t gpuCurrentTemperature
; ///< [out] Instantaneous snapshot of the GPU chip temperature, read from
5387 ///< the sensor reporting the highest value.
5388 ctl_oc_telemetry_item_t globalActivityCounter
; ///< [out] Snapshot of the monotonic global activity counter. It measures
5389 ///< the time in seconds (accurate down to 1 millisecond) that any GPU
5390 ///< engine is busy. By taking the delta between two snapshots and dividing
5391 ///< by the delta time in seconds, an application can compute the average
5392 ///< percentage utilization of the GPU..
5393 ctl_oc_telemetry_item_t renderComputeActivityCounter
; ///< [out] Snapshot of the monotonic 3D/compute activity counter. It
5394 ///< measures the time in seconds (accurate down to 1 millisecond) that any
5395 ///< 3D render/compute engine is busy. By taking the delta between two
5396 ///< snapshots and dividing by the delta time in seconds, an application
5397 ///< can compute the average percentage utilization of all 3D
5398 ///< render/compute blocks in the GPU.
5399 ctl_oc_telemetry_item_t mediaActivityCounter
; ///< [out] Snapshot of the monotonic media activity counter. It measures
5400 ///< the time in seconds (accurate down to 1 millisecond) that any media
5401 ///< engine is busy. By taking the delta between two snapshots and dividing
5402 ///< by the delta time in seconds, an application can compute the average
5403 ///< percentage utilization of all media blocks in the GPU.
5404 bool gpuPowerLimited
; ///< [out] Instantaneous indication that the desired GPU frequency is being
5405 ///< throttled because the GPU chip is exceeding the maximum power limits.
5406 ///< Increasing the power limits using ::ctlOverclockPowerLimitSet() is one
5407 ///< way to remove this limitation.
5408 bool gpuTemperatureLimited
; ///< [out] Instantaneous indication that the desired GPU frequency is being
5409 ///< throttled because the GPU chip is exceeding the temperature limits.
5410 ///< Increasing the temperature limits using
5411 ///< ::ctlOverclockTemperatureLimitSet() is one way to reduce this
5412 ///< limitation. Improving the cooling solution is another way.
5413 bool gpuCurrentLimited
; ///< [out] Instantaneous indication that the desired GPU frequency is being
5414 ///< throttled because the GPU chip has exceeded the power supply current
5415 ///< limits. A better power supply is required to reduce this limitation.
5416 bool gpuVoltageLimited
; ///< [out] Instantaneous indication that the GPU frequency cannot be
5417 ///< increased because the voltage limits have been reached. Increase the
5418 ///< voltage offset using ::ctlOverclockGpuVoltageOffsetSet() is one way to
5419 ///< reduce this limitation.
5420 bool gpuUtilizationLimited
; ///< [out] Instantaneous indication that due to lower GPU utilization, the
5421 ///< hardware has lowered the GPU frequency.
5422 ctl_oc_telemetry_item_t vramEnergyCounter
; ///< [out] Snapshot of the monotonic energy counter maintained by hardware.
5423 ///< It measures the total energy consumed by the local memory modules. By
5424 ///< taking the delta between two snapshots and dividing by the delta time
5425 ///< in seconds, an application can compute the average power.
5426 ctl_oc_telemetry_item_t vramVoltage
; ///< [out] Instantaneous snapshot of the voltage feeding the memory
5428 ctl_oc_telemetry_item_t vramCurrentClockFrequency
; ///< [out] Instantaneous snapshot of the raw clock frequency driving the
5429 ///< memory modules.
5430 ctl_oc_telemetry_item_t vramCurrentEffectiveFrequency
; ///< [out] Instantaneous snapshot of the effective data transfer rate that
5431 ///< the memory modules can sustain based on the current clock frequency..
5432 ctl_oc_telemetry_item_t vramReadBandwidthCounter
; ///< [out] Instantaneous snapshot of the monotonic counter that measures
5433 ///< the read traffic from the memory modules. By taking the delta between
5434 ///< two snapshots and dividing by the delta time in seconds, an
5435 ///< application can compute the average read bandwidth.
5436 ctl_oc_telemetry_item_t vramWriteBandwidthCounter
; ///< [out] Instantaneous snapshot of the monotonic counter that measures
5437 ///< the write traffic to the memory modules. By taking the delta between
5438 ///< two snapshots and dividing by the delta time in seconds, an
5439 ///< application can compute the average write bandwidth.
5440 ctl_oc_telemetry_item_t vramCurrentTemperature
; ///< [out] Instantaneous snapshot of the GPU chip temperature, read from
5441 ///< the sensor reporting the highest value.
5442 bool vramPowerLimited
; ///< [out] Instantaneous indication that the memory frequency is being
5443 ///< throttled because the memory modules are exceeding the maximum power
5445 bool vramTemperatureLimited
; ///< [out] Instantaneous indication that the memory frequency is being
5446 ///< throttled because the memory modules are exceeding the temperature
5448 bool vramCurrentLimited
; ///< [out] Instantaneous indication that the memory frequency is being
5449 ///< throttled because the memory modules have exceeded the power supply
5450 ///< current limits.
5451 bool vramVoltageLimited
; ///< [out] Instantaneous indication that the memory frequency cannot be
5452 ///< increased because the voltage limits have been reached.
5453 bool vramUtilizationLimited
; ///< [out] Instantaneous indication that due to lower memory traffic, the
5454 ///< hardware has lowered the memory frequency.
5455 ctl_oc_telemetry_item_t totalCardEnergyCounter
; ///< [out] Total Card Energy Counter.
5456 ctl_psu_info_t psu
[CTL_PSU_COUNT
]; ///< [out] PSU voltage and power.
5457 ctl_oc_telemetry_item_t fanSpeed
[CTL_FAN_COUNT
];///< [out] Fan speed.
5459 } ctl_power_telemetry_t
;
5461 ///////////////////////////////////////////////////////////////////////////////
5462 /// @brief Get overclock properties - available properties.
5465 /// - CTL_RESULT_SUCCESS
5466 /// - CTL_RESULT_ERROR_UNINITIALIZED
5467 /// - CTL_RESULT_ERROR_DEVICE_LOST
5468 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5469 /// + `nullptr == hDeviceHandle`
5470 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5471 /// + `nullptr == pOcProperties`
5472 CTL_APIEXPORT ctl_result_t CTL_APICALL
5473 ctlOverclockGetProperties(
5474 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5475 ctl_oc_properties_t
* pOcProperties
///< [in,out] The overclocking properties for the specified domain.
5478 ///////////////////////////////////////////////////////////////////////////////
5479 /// @brief Overclock Waiver - Warranty Waiver.
5482 /// - Most of the overclock functions will return an error if the waiver is
5483 /// not set. This is because most overclock settings will increase the
5484 /// electric/thermal stress on the part and thus reduce its lifetime.
5485 /// - By setting the waiver, the user is indicate that they are accepting a
5486 /// reduction in the lifetime of the part.
5487 /// - It is the responsibility of overclock applications to notify each user
5488 /// at least once with a popup of the dangers and requiring acceptance.
5489 /// - Only once the user has accepted should this function be called by the
5491 /// - It is acceptable for the application to cache the user choice and call
5492 /// this function on future executions without issuing the popup.
5495 /// - CTL_RESULT_SUCCESS
5496 /// - CTL_RESULT_ERROR_UNINITIALIZED
5497 /// - CTL_RESULT_ERROR_DEVICE_LOST
5498 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5499 /// + `nullptr == hDeviceHandle`
5500 CTL_APIEXPORT ctl_result_t CTL_APICALL
5501 ctlOverclockWaiverSet(
5502 ctl_device_adapter_handle_t hDeviceHandle
///< [in][release] Handle to display adapter
5505 ///////////////////////////////////////////////////////////////////////////////
5506 /// @brief Get the Overclock Frequency Offset for the GPU in MHz.
5509 /// - Determine the current frequency offset in effect (refer to
5510 /// ::ctlOverclockGpuFrequencyOffsetSet() for details).
5511 /// - The value returned may be different from the value that was previously
5512 /// set by the application depending on hardware limitations or if the
5513 /// function ::ctlOverclockGpuFrequencyOffsetSet() has been called or
5514 /// another application that has changed the value.
5517 /// - CTL_RESULT_SUCCESS
5518 /// - CTL_RESULT_ERROR_UNINITIALIZED
5519 /// - CTL_RESULT_ERROR_DEVICE_LOST
5520 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5521 /// + `nullptr == hDeviceHandle`
5522 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5523 /// + `nullptr == pOcFrequencyOffset`
5524 CTL_APIEXPORT ctl_result_t CTL_APICALL
5525 ctlOverclockGpuFrequencyOffsetGet(
5526 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5527 double* pOcFrequencyOffset
///< [in,out] The Turbo Overclocking Frequency Desired in MHz.
5530 ///////////////////////////////////////////////////////////////////////////////
5531 /// @brief Set the Overclock Frequency Offset for the GPU in MHZ.
5534 /// - The purpose of this function is to increase/decrease the frequency at
5535 /// which typical workloads will run within the same thermal budget.
5536 /// - The frequency offset is expressed in units of ±1MHz.
5537 /// - The actual operating frequency for each workload is not guaranteed to
5538 /// change exactly by the specified offset.
5539 /// - For positive frequency offsets, the factory maximum frequency may
5540 /// increase by up to the specified amount.
5541 /// - For negative frequency offsets, the overclock waiver must have been
5542 /// set since this can result in running the part at voltages beyond the
5543 /// part warrantee limits. An error is returned if the waiver has not been
5545 /// - Specifying large values for the frequency offset can lead to
5546 /// instability. It is recommended that changes are made in small
5547 /// increments and stability/performance measured running intense GPU
5548 /// workloads before increasing further.
5549 /// - This setting is not persistent through system reboots or driver
5550 /// resets/hangs. It is up to the overclock application to reapply the
5551 /// settings in those cases.
5552 /// - This setting can cause system/device instability. It is up to the
5553 /// overclock application to detect if the system has rebooted
5554 /// unexpectedly or the device was restarted. When this occurs, the
5555 /// application should not reapply the overclock settings automatically
5556 /// but instead return to previously known good settings or notify the
5557 /// user that the settings are not being applied.
5560 /// - CTL_RESULT_SUCCESS
5561 /// - CTL_RESULT_ERROR_UNINITIALIZED
5562 /// - CTL_RESULT_ERROR_DEVICE_LOST
5563 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5564 /// + `nullptr == hDeviceHandle`
5565 CTL_APIEXPORT ctl_result_t CTL_APICALL
5566 ctlOverclockGpuFrequencyOffsetSet(
5567 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5568 double ocFrequencyOffset
///< [in] The Turbo Overclocking Frequency Desired in MHz.
5571 ///////////////////////////////////////////////////////////////////////////////
5572 /// @brief Get the Overclock Gpu Voltage Offset in mV.
5575 /// - Determine the current voltage offset in effect on the hardware (refer
5576 /// to ::ctlOverclockGpuVoltageOffsetSet for details).
5577 /// - The value returned may be different from the value that was previously
5578 /// set by the application depending on hardware limitations or if the
5579 /// function ::ctlOverclockGpuVoltageOffsetSet has been called or another
5580 /// application that has changed the value.
5583 /// - CTL_RESULT_SUCCESS
5584 /// - CTL_RESULT_ERROR_UNINITIALIZED
5585 /// - CTL_RESULT_ERROR_DEVICE_LOST
5586 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5587 /// + `nullptr == hDeviceHandle`
5588 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5589 /// + `nullptr == pOcVoltageOffset`
5590 CTL_APIEXPORT ctl_result_t CTL_APICALL
5591 ctlOverclockGpuVoltageOffsetGet(
5592 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5593 double* pOcVoltageOffset
///< [in,out] The Turbo Overclocking Frequency Desired in mV.
5596 ///////////////////////////////////////////////////////////////////////////////
5597 /// @brief Set the Overclock Gpu Voltage Offset in mV.
5600 /// - The purpose of this function is to attempt to run the GPU up to higher
5601 /// voltages beyond the part warrantee limits. This can permit running at
5602 /// even higher frequencies than can be obtained using the frequency
5603 /// offset setting, but at the risk of reducing the lifetime of the part.
5604 /// - The voltage offset is expressed in units of ±millivolts with values
5605 /// permitted down to a resolution of 1 millivolt.
5606 /// - The overclock waiver must be set before calling this function
5607 /// otherwise and error will be returned.
5608 /// - There is no guarantee that a workload can operate at the higher
5609 /// frequencies permitted by this setting. Significantly more heat will be
5610 /// generated at these high frequencies/voltages which will necessitate a
5611 /// good cooling solution.
5614 /// - CTL_RESULT_SUCCESS
5615 /// - CTL_RESULT_ERROR_UNINITIALIZED
5616 /// - CTL_RESULT_ERROR_DEVICE_LOST
5617 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5618 /// + `nullptr == hDeviceHandle`
5619 CTL_APIEXPORT ctl_result_t CTL_APICALL
5620 ctlOverclockGpuVoltageOffsetSet(
5621 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5622 double ocVoltageOffset
///< [in] The Turbo Overclocking Frequency Desired in mV.
5625 ///////////////////////////////////////////////////////////////////////////////
5626 /// @brief Gets the Locked GPU Voltage for Overclocking in mV.
5629 /// - The purpose of this function is to determine if the current values of
5630 /// the frequency/voltage lock.
5631 /// - If the lock is not currently active, will return 0 for frequency and
5633 /// - Note that the operating frequency/voltage may be lower than these
5634 /// settings if power/thermal limits are exceeded.
5637 /// - CTL_RESULT_SUCCESS
5638 /// - CTL_RESULT_ERROR_UNINITIALIZED
5639 /// - CTL_RESULT_ERROR_DEVICE_LOST
5640 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5641 /// + `nullptr == hDeviceHandle`
5642 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5643 /// + `nullptr == pVfPair`
5644 CTL_APIEXPORT ctl_result_t CTL_APICALL
5645 ctlOverclockGpuLockGet(
5646 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5647 ctl_oc_vf_pair_t
* pVfPair
///< [out] The current locked voltage and frequency.
5650 ///////////////////////////////////////////////////////////////////////////////
5651 /// @brief Locks the GPU voltage for Overclocking in mV.
5654 /// - The purpose of this function is to provide an interface for scanners
5655 /// to lock the frequency and voltage to fixed values.
5656 /// - The frequency is expressed in units of MHz with a resolution of 1MHz.
5657 /// - The voltage is expressed in units of ±millivolts with values
5658 /// permitted down to a resolution of 1 millivolt.
5659 /// - The overclock waiver must be set since fixing the voltage at a high
5660 /// value puts unnecessary stress on the part.
5661 /// - The actual frequency may reduce depending on power/thermal
5663 /// - Requesting a frequency and/or voltage of 0 will return the hardware to
5664 /// dynamic frequency/voltage management with any previous frequency
5665 /// offset or voltage offset settings reapplied.
5668 /// - CTL_RESULT_SUCCESS
5669 /// - CTL_RESULT_ERROR_UNINITIALIZED
5670 /// - CTL_RESULT_ERROR_DEVICE_LOST
5671 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5672 /// + `nullptr == hDeviceHandle`
5673 CTL_APIEXPORT ctl_result_t CTL_APICALL
5674 ctlOverclockGpuLockSet(
5675 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5676 ctl_oc_vf_pair_t vFPair
///< [in] The current locked voltage and frequency.
5679 ///////////////////////////////////////////////////////////////////////////////
5680 /// @brief Get the current Vram Frequency Offset in GT/s.
5683 /// - The purpose of this function is to return the current VRAM frequency
5684 /// offset in units of GT/s.
5687 /// - CTL_RESULT_SUCCESS
5688 /// - CTL_RESULT_ERROR_UNINITIALIZED
5689 /// - CTL_RESULT_ERROR_DEVICE_LOST
5690 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5691 /// + `nullptr == hDeviceHandle`
5692 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5693 /// + `nullptr == pOcFrequencyOffset`
5694 CTL_APIEXPORT ctl_result_t CTL_APICALL
5695 ctlOverclockVramFrequencyOffsetGet(
5696 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5697 double* pOcFrequencyOffset
///< [in,out] The current Memory Frequency in GT/s.
5700 ///////////////////////////////////////////////////////////////////////////////
5701 /// @brief Set the desired Vram frquency Offset in GT/s
5704 /// - The purpose of this function is to increase/decrease the frequency of
5706 /// - The frequency offset is expressed in units of GT/s with a minimum step
5707 /// size given by ::ctlOverclockGetProperties.
5708 /// - The actual operating frequency for each workload is not guaranteed to
5709 /// change exactly by the specified offset.
5710 /// - The waiver must be set using clibOverclockWaiverSet() before this
5711 /// function can be called.
5712 /// - This setting is not persistent through system reboots or driver
5713 /// resets/hangs. It is up to the overclock application to reapply the
5714 /// settings in those cases.
5715 /// - This setting can cause system/device instability. It is up to the
5716 /// overclock application to detect if the system has rebooted
5717 /// unexpectedly or the device was restarted. When this occurs, the
5718 /// application should not reapply the overclock settings automatically
5719 /// but instead return to previously known good settings or notify the
5720 /// user that the settings are not being applied.
5721 /// - If the memory controller doesn't support changes to frequency on the
5722 /// fly, one of the following return codes will be given:
5723 /// - ::CTL_RESULT_ERROR_RESET_DEVICE_REQUIRED: The requested memory
5724 /// overclock will be applied when the device is reset or the system is
5725 /// rebooted. In this case, the overclock software should check if the
5726 /// overclock request was applied after the reset/reboot. If it was and
5727 /// when the overclock application shuts down gracefully and if the
5728 /// overclock application wants the setting to be persistent, the
5729 /// application should request the same overclock settings again so that
5730 /// they will be applied on the next reset/reboot. If this is not done,
5731 /// then every time the device is reset and overclock is requested, the
5732 /// device needs to be reset a second time.
5733 /// - ::CTL_RESULT_ERROR_FULL_REBOOT_REQUIRED: The requested memory
5734 /// overclock will be applied when the system is rebooted. In this case,
5735 /// the overclock software should check if the overclock request was
5736 /// applied after the reboot. If it was and when the overclock application
5737 /// shuts down gracefully and if the overclock application wants the
5738 /// setting to be persistent, the application should request the same
5739 /// overclock settings again so that they will be applied on the next
5740 /// reset/reboot. If this is not done and the overclock setting is
5741 /// requested after the reboot has occurred, a second reboot will be
5745 /// - CTL_RESULT_SUCCESS
5746 /// - CTL_RESULT_ERROR_UNINITIALIZED
5747 /// - CTL_RESULT_ERROR_DEVICE_LOST
5748 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5749 /// + `nullptr == hDeviceHandle`
5750 CTL_APIEXPORT ctl_result_t CTL_APICALL
5751 ctlOverclockVramFrequencyOffsetSet(
5752 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5753 double ocFrequencyOffset
///< [in] The desired Memory Frequency in GT/s.
5756 ///////////////////////////////////////////////////////////////////////////////
5757 /// @brief Get the Overclock Vram Voltage Offset in mV.
5760 /// - The purpose of this function is to increase/decrease the voltage of
5762 /// - The voltage offset is expressed in units of millivolts with a minimum
5763 /// step size given by ::ctlOverclockGetProperties.
5764 /// - The waiver must be set using ::ctlOverclockWaiverSet before this
5765 /// function can be called.
5766 /// - This setting is not persistent through system reboots or driver
5767 /// resets/hangs. It is up to the overclock application to reapply the
5768 /// settings in those cases.
5769 /// - This setting can cause system/device instability. It is up to the
5770 /// overclock application to detect if the system has rebooted
5771 /// unexpectedly or the device was restarted. When this occurs, the
5772 /// application should not reapply the overclock settings automatically
5773 /// but instead return to previously known good settings or notify the
5774 /// user that the settings are not being applied.
5775 /// - If the memory controller doesn't support changes to voltage on the
5776 /// fly, one of the following return codes will be given:
5777 /// - ::CTL_RESULT_ERROR_RESET_DEVICE_REQUIRED: The requested memory
5778 /// overclock will be applied when the device is reset or the system is
5779 /// rebooted. In this case, the overclock software should check if the
5780 /// overclock request was applied after the reset/reboot. If it was and
5781 /// when the overclock application shuts down gracefully and if the
5782 /// overclock application wants the setting to be persistent, the
5783 /// application should request the same overclock settings again so that
5784 /// they will be applied on the next reset/reboot. If this is not done,
5785 /// then every time the device is reset and overclock is requested, the
5786 /// device needs to be reset a second time.
5787 /// - ::CTL_RESULT_ERROR_FULL_REBOOT_REQUIRED: The requested memory
5788 /// overclock will be applied when the system is rebooted. In this case,
5789 /// the overclock software should check if the overclock request was
5790 /// applied after the reboot. If it was and when the overclock application
5791 /// shuts down gracefully and if the overclock application wants the
5792 /// setting to be persistent, the application should request the same
5793 /// overclock settings again so that they will be applied on the next
5794 /// reset/reboot. If this is not done and the overclock setting is
5795 /// requested after the reboot has occurred, a second reboot will be
5799 /// - CTL_RESULT_SUCCESS
5800 /// - CTL_RESULT_ERROR_UNINITIALIZED
5801 /// - CTL_RESULT_ERROR_DEVICE_LOST
5802 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5803 /// + `nullptr == hDeviceHandle`
5804 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5805 /// + `nullptr == pVoltage`
5806 CTL_APIEXPORT ctl_result_t CTL_APICALL
5807 ctlOverclockVramVoltageOffsetGet(
5808 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5809 double* pVoltage
///< [out] The current locked voltage in mV.
5812 ///////////////////////////////////////////////////////////////////////////////
5813 /// @brief Set the Overclock Vram Voltage Offset in mV.
5816 /// - The purpose of this function is to set the maximum sustained power
5817 /// limit. If the average GPU power averaged over a few seconds exceeds
5818 /// this value, the frequency of the GPU will be throttled.
5819 /// - Set a value of 0 to disable this power limit. In this case, the GPU
5820 /// frequency will not throttle due to average power but may hit other
5824 /// - CTL_RESULT_SUCCESS
5825 /// - CTL_RESULT_ERROR_UNINITIALIZED
5826 /// - CTL_RESULT_ERROR_DEVICE_LOST
5827 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5828 /// + `nullptr == hDeviceHandle`
5829 CTL_APIEXPORT ctl_result_t CTL_APICALL
5830 ctlOverclockVramVoltageOffsetSet(
5831 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5832 double voltage
///< [in] The voltage to be locked in mV.
5835 ///////////////////////////////////////////////////////////////////////////////
5836 /// @brief Get the sustained power limit in mW.
5839 /// - The purpose of this function is to read the current sustained power
5841 /// - A value of 0 means that the limit is disabled - the GPU frequency can
5842 /// run as high as possible until other limits are hit.
5845 /// - CTL_RESULT_SUCCESS
5846 /// - CTL_RESULT_ERROR_UNINITIALIZED
5847 /// - CTL_RESULT_ERROR_DEVICE_LOST
5848 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5849 /// + `nullptr == hDeviceHandle`
5850 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5851 /// + `nullptr == pSustainedPowerLimit`
5852 CTL_APIEXPORT ctl_result_t CTL_APICALL
5853 ctlOverclockPowerLimitGet(
5854 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5855 double* pSustainedPowerLimit
///< [in,out] The current sustained power limit in mW.
5858 ///////////////////////////////////////////////////////////////////////////////
5859 /// @brief Set the sustained power limit in mW.
5862 /// - The purpose of this function is to set the maximum sustained power
5863 /// limit. If the average GPU power averaged over a few seconds exceeds
5864 /// this value, the frequency of the GPU will be throttled.
5865 /// - Set a value of 0 to disable this power limit. In this case, the GPU
5866 /// frequency will not throttle due to average power but may hit other
5870 /// - CTL_RESULT_SUCCESS
5871 /// - CTL_RESULT_ERROR_UNINITIALIZED
5872 /// - CTL_RESULT_ERROR_DEVICE_LOST
5873 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5874 /// + `nullptr == hDeviceHandle`
5875 CTL_APIEXPORT ctl_result_t CTL_APICALL
5876 ctlOverclockPowerLimitSet(
5877 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5878 double sustainedPowerLimit
///< [in] The desired sustained power limit in mW.
5881 ///////////////////////////////////////////////////////////////////////////////
5882 /// @brief Get the current temperature limit in Celsius.
5885 /// - The purpose of this function is to read the current thermal limit.
5888 /// - CTL_RESULT_SUCCESS
5889 /// - CTL_RESULT_ERROR_UNINITIALIZED
5890 /// - CTL_RESULT_ERROR_DEVICE_LOST
5891 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5892 /// + `nullptr == hDeviceHandle`
5893 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5894 /// + `nullptr == pTemperatureLimit`
5895 CTL_APIEXPORT ctl_result_t CTL_APICALL
5896 ctlOverclockTemperatureLimitGet(
5897 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5898 double* pTemperatureLimit
///< [in,out] The current temperature limit in Celsius.
5901 ///////////////////////////////////////////////////////////////////////////////
5902 /// @brief Set the temperature limit in Celsius.
5905 /// - The purpose of this function is to change the maximum thermal limit.
5906 /// When the GPU temperature exceeds this value, the GPU frequency will be
5910 /// - CTL_RESULT_SUCCESS
5911 /// - CTL_RESULT_ERROR_UNINITIALIZED
5912 /// - CTL_RESULT_ERROR_DEVICE_LOST
5913 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5914 /// + `nullptr == hDeviceHandle`
5915 CTL_APIEXPORT ctl_result_t CTL_APICALL
5916 ctlOverclockTemperatureLimitSet(
5917 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5918 double temperatureLimit
///< [in] The desired temperature limit in Celsius.
5921 ///////////////////////////////////////////////////////////////////////////////
5922 /// @brief Get Power Telemetry.
5925 /// - Limited rate of 50 ms, any call under 50 ms will return the same
5929 /// - CTL_RESULT_SUCCESS
5930 /// - CTL_RESULT_ERROR_UNINITIALIZED
5931 /// - CTL_RESULT_ERROR_DEVICE_LOST
5932 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5933 /// + `nullptr == hDeviceHandle`
5934 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5935 /// + `nullptr == pTelemetryInfo`
5936 CTL_APIEXPORT ctl_result_t CTL_APICALL
5937 ctlPowerTelemetryGet(
5938 ctl_device_adapter_handle_t hDeviceHandle
, ///< [in][release] Handle to display adapter
5939 ctl_power_telemetry_t
* pTelemetryInfo
///< [out] The overclocking properties for the specified domain.
5943 #if !defined(__GNUC__)
5944 #pragma endregion // overclock
5946 // Intel 'ctlApi' for Device Adapter - PCI Information
5947 #if !defined(__GNUC__)
5950 ///////////////////////////////////////////////////////////////////////////////
5951 /// @brief PCI address
5952 typedef struct _ctl_pci_address_t
5954 uint32_t Size
; ///< [in] size of this structure
5955 uint8_t Version
; ///< [in] version of this structure
5956 uint32_t domain
; ///< [out] BDF domain
5957 uint32_t bus
; ///< [out] BDF bus
5958 uint32_t device
; ///< [out] BDF device
5959 uint32_t function
; ///< [out] BDF function
5961 } ctl_pci_address_t
;
5963 ///////////////////////////////////////////////////////////////////////////////
5964 /// @brief PCI speed
5965 typedef struct _ctl_pci_speed_t
5967 uint32_t Size
; ///< [in] size of this structure
5968 uint8_t Version
; ///< [in] version of this structure
5969 int32_t gen
; ///< [out] The link generation. A value of -1 means that this property is
5971 int32_t width
; ///< [out] The number of lanes. A value of -1 means that this property is
5973 int64_t maxBandwidth
; ///< [out] The maximum bandwidth in bytes/sec (sum of all lanes). A value
5974 ///< of -1 means that this property is unknown.
5978 ///////////////////////////////////////////////////////////////////////////////
5979 /// @brief Static PCI properties
5980 typedef struct _ctl_pci_properties_t
5982 uint32_t Size
; ///< [in] size of this structure
5983 uint8_t Version
; ///< [in] version of this structure
5984 ctl_pci_address_t address
; ///< [out] The BDF address
5985 ctl_pci_speed_t maxSpeed
; ///< [out] Fastest port configuration supported by the device (sum of all
5987 bool resizable_bar_supported
; ///< [out] Support for Resizable Bar on this device.
5988 bool resizable_bar_enabled
; ///< [out] Resizable Bar enabled on this device
5990 } ctl_pci_properties_t
;
5992 ///////////////////////////////////////////////////////////////////////////////
5993 /// @brief Dynamic PCI state
5994 typedef struct _ctl_pci_state_t
5996 uint32_t Size
; ///< [in] size of this structure
5997 uint8_t Version
; ///< [in] version of this structure
5998 ctl_pci_speed_t speed
; ///< [out] The current port configure speed
6002 ///////////////////////////////////////////////////////////////////////////////
6003 /// @brief Get PCI properties - address, max speed
6006 /// - The application may call this function from simultaneous threads.
6007 /// - The implementation of this function should be lock-free.
6010 /// - CTL_RESULT_SUCCESS
6011 /// - CTL_RESULT_ERROR_UNINITIALIZED
6012 /// - CTL_RESULT_ERROR_DEVICE_LOST
6013 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6014 /// + `nullptr == hDAhandle`
6015 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6016 /// + `nullptr == pProperties`
6017 CTL_APIEXPORT ctl_result_t CTL_APICALL
6018 ctlPciGetProperties(
6019 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to display adapter
6020 ctl_pci_properties_t
* pProperties
///< [in,out] Will contain the PCI properties.
6023 ///////////////////////////////////////////////////////////////////////////////
6024 /// @brief Get current PCI state - current speed
6027 /// - The application may call this function from simultaneous threads.
6028 /// - The implementation of this function should be lock-free.
6031 /// - CTL_RESULT_SUCCESS
6032 /// - CTL_RESULT_ERROR_UNINITIALIZED
6033 /// - CTL_RESULT_ERROR_DEVICE_LOST
6034 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6035 /// + `nullptr == hDAhandle`
6036 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6037 /// + `nullptr == pState`
6038 CTL_APIEXPORT ctl_result_t CTL_APICALL
6040 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to display adapter
6041 ctl_pci_state_t
* pState
///< [in,out] Will contain the PCI properties.
6045 #if !defined(__GNUC__)
6046 #pragma endregion // pci
6048 // Intel 'ctlApi' for Device Adapter - Power management
6049 #if !defined(__GNUC__)
6050 #pragma region power
6052 ///////////////////////////////////////////////////////////////////////////////
6053 /// @brief Properties related to device power settings
6054 typedef struct _ctl_power_properties_t
6056 uint32_t Size
; ///< [in] size of this structure
6057 uint8_t Version
; ///< [in] version of this structure
6058 bool canControl
; ///< [out] Software can change the power limits of this domain assuming the
6059 ///< user has permissions.
6060 int32_t defaultLimit
; ///< [out] The factory default TDP power limit of the part in milliwatts. A
6061 ///< value of -1 means that this is not known.
6062 int32_t minLimit
; ///< [out] The minimum power limit in milliwatts that can be requested.
6063 int32_t maxLimit
; ///< [out] The maximum power limit in milliwatts that can be requested.
6065 } ctl_power_properties_t
;
6067 ///////////////////////////////////////////////////////////////////////////////
6068 /// @brief Energy counter snapshot
6071 /// - Average power is calculated by taking two snapshots (s1, s2) and using
6072 /// the equation: PowerWatts = (s2.energy - s1.energy) / (s2.timestamp -
6074 typedef struct _ctl_power_energy_counter_t
6076 uint32_t Size
; ///< [in] size of this structure
6077 uint8_t Version
; ///< [in] version of this structure
6078 uint64_t energy
; ///< [out] The monotonic energy counter in microjoules.
6079 uint64_t timestamp
; ///< [out] Microsecond timestamp when energy was captured.
6080 ///< This timestamp should only be used to calculate delta time between
6081 ///< snapshots of this structure.
6082 ///< Never take the delta of this timestamp with the timestamp from a
6083 ///< different structure since they are not guaranteed to have the same base.
6084 ///< The absolute value of the timestamp is only valid during within the
6085 ///< application and may be different on the next execution.
6087 } ctl_power_energy_counter_t
;
6089 ///////////////////////////////////////////////////////////////////////////////
6090 /// @brief Sustained power limits
6093 /// - The power controller (Punit) will throttle the operating frequency if
6094 /// the power averaged over a window (typically seconds) exceeds this
6096 typedef struct _ctl_power_sustained_limit_t
6098 bool enabled
; ///< [in,out] indicates if the limit is enabled (true) or ignored (false)
6099 int32_t power
; ///< [in,out] power limit in milliwatts
6100 int32_t interval
; ///< [in,out] power averaging window (Tau) in milliseconds
6102 } ctl_power_sustained_limit_t
;
6104 ///////////////////////////////////////////////////////////////////////////////
6105 /// @brief Burst power limit
6108 /// - The power controller (Punit) will throttle the operating frequency of
6109 /// the device if the power averaged over a few milliseconds exceeds a
6110 /// limit known as PL2. Typically PL2 > PL1 so that it permits the
6111 /// frequency to burst higher for short periods than would be otherwise
6112 /// permitted by PL1.
6113 typedef struct _ctl_power_burst_limit_t
6115 bool enabled
; ///< [in,out] indicates if the limit is enabled (true) or ignored (false)
6116 int32_t power
; ///< [in,out] power limit in milliwatts
6118 } ctl_power_burst_limit_t
;
6120 ///////////////////////////////////////////////////////////////////////////////
6121 /// @brief Peak power limit
6124 /// - The power controller (Punit) will preemptively throttle the operating
6125 /// frequency of the device when the instantaneous power exceeds this
6126 /// limit. The limit is known as PL4. It expresses the maximum power that
6127 /// can be drawn from the power supply.
6128 /// - If this power limit is removed or set too high, the power supply will
6129 /// generate an interrupt when it detects an overcurrent condition and the
6130 /// power controller will throttle the device frequencies down to min. It
6131 /// is thus better to tune the PL4 value in order to avoid such
6133 typedef struct _ctl_power_peak_limit_t
6135 int32_t powerAC
; ///< [in,out] power limit in milliwatts for the AC power source.
6136 int32_t powerDC
; ///< [in,out] power limit in milliwatts for the DC power source. On input,
6137 ///< this is ignored if the product does not have a battery. On output,
6138 ///< this will be -1 if the product does not have a battery.
6140 } ctl_power_peak_limit_t
;
6142 ///////////////////////////////////////////////////////////////////////////////
6143 /// @brief Power limits
6144 typedef struct _ctl_power_limits_t
6146 uint32_t Size
; ///< [in] size of this structure
6147 uint8_t Version
; ///< [in] version of this structure
6148 ctl_power_sustained_limit_t sustainedPowerLimit
;///< [in,out] sustained power limit.
6149 ctl_power_burst_limit_t burstPowerLimit
; ///< [in,out] burst power limit.
6150 ctl_power_peak_limit_t peakPowerLimits
; ///< [in,out] peak power limit.
6152 } ctl_power_limits_t
;
6154 ///////////////////////////////////////////////////////////////////////////////
6155 /// @brief Energy threshold
6159 typedef struct _ctl_energy_threshold_t
6161 uint32_t Size
; ///< [in] size of this structure
6162 uint8_t Version
; ///< [in] version of this structure
6163 bool enable
; ///< [in,out] Indicates if the energy threshold is enabled.
6164 double threshold
; ///< [in,out] The energy threshold in Joules. Will be 0.0 if no threshold
6166 uint32_t processId
; ///< [in,out] The host process ID that set the energy threshold. Will be
6167 ///< 0xFFFFFFFF if no threshold has been set.
6169 } ctl_energy_threshold_t
;
6171 ///////////////////////////////////////////////////////////////////////////////
6172 /// @brief Get handle of power domains
6175 /// - The application may call this function from simultaneous threads.
6176 /// - The implementation of this function should be lock-free.
6179 /// - CTL_RESULT_SUCCESS
6180 /// - CTL_RESULT_ERROR_UNINITIALIZED
6181 /// - CTL_RESULT_ERROR_DEVICE_LOST
6182 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6183 /// + `nullptr == hDAhandle`
6184 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6185 /// + `nullptr == pCount`
6186 CTL_APIEXPORT ctl_result_t CTL_APICALL
6187 ctlEnumPowerDomains(
6188 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to display adapter
6189 uint32_t* pCount
, ///< [in,out] pointer to the number of components of this type.
6190 ///< if count is zero, then the driver shall update the value with the
6191 ///< total number of components of this type that are available.
6192 ///< if count is greater than the number of components of this type that
6193 ///< are available, then the driver shall update the value with the correct
6194 ///< number of components.
6195 ctl_pwr_handle_t
* phPower
///< [in,out][optional][range(0, *pCount)] array of handle of components of
6197 ///< if count is less than the number of components of this type that are
6198 ///< available, then the driver shall only retrieve that number of
6199 ///< component handles.
6202 ///////////////////////////////////////////////////////////////////////////////
6203 /// @brief Get properties related to a power domain
6206 /// - The application may call this function from simultaneous threads.
6207 /// - The implementation of this function should be lock-free.
6210 /// - CTL_RESULT_SUCCESS
6211 /// - CTL_RESULT_ERROR_UNINITIALIZED
6212 /// - CTL_RESULT_ERROR_DEVICE_LOST
6213 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6214 /// + `nullptr == hPower`
6215 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6216 /// + `nullptr == pProperties`
6217 CTL_APIEXPORT ctl_result_t CTL_APICALL
6218 ctlPowerGetProperties(
6219 ctl_pwr_handle_t hPower
, ///< [in] Handle for the component.
6220 ctl_power_properties_t
* pProperties
///< [in,out] Structure that will contain property data.
6223 ///////////////////////////////////////////////////////////////////////////////
6224 /// @brief Get energy counter
6227 /// - The application may call this function from simultaneous threads.
6228 /// - The implementation of this function should be lock-free.
6231 /// - CTL_RESULT_SUCCESS
6232 /// - CTL_RESULT_ERROR_UNINITIALIZED
6233 /// - CTL_RESULT_ERROR_DEVICE_LOST
6234 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6235 /// + `nullptr == hPower`
6236 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6237 /// + `nullptr == pEnergy`
6238 CTL_APIEXPORT ctl_result_t CTL_APICALL
6239 ctlPowerGetEnergyCounter(
6240 ctl_pwr_handle_t hPower
, ///< [in] Handle for the component.
6241 ctl_power_energy_counter_t
* pEnergy
///< [in,out] Will contain the latest snapshot of the energy counter and
6242 ///< timestamp when the last counter value was measured.
6245 ///////////////////////////////////////////////////////////////////////////////
6246 /// @brief Get power limits
6249 /// - The application may call this function from simultaneous threads.
6250 /// - The implementation of this function should be lock-free.
6253 /// - CTL_RESULT_SUCCESS
6254 /// - CTL_RESULT_ERROR_UNINITIALIZED
6255 /// - CTL_RESULT_ERROR_DEVICE_LOST
6256 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6257 /// + `nullptr == hPower`
6258 CTL_APIEXPORT ctl_result_t CTL_APICALL
6260 ctl_pwr_handle_t hPower
, ///< [in] Handle for the component.
6261 ctl_power_limits_t
* pPowerLimits
///< [in,out][optional] Structure that will contain the power limits.
6264 ///////////////////////////////////////////////////////////////////////////////
6265 /// @brief Set power limits
6268 /// - The application may call this function from simultaneous threads.
6269 /// - The implementation of this function should be lock-free.
6272 /// - CTL_RESULT_SUCCESS
6273 /// - CTL_RESULT_ERROR_UNINITIALIZED
6274 /// - CTL_RESULT_ERROR_DEVICE_LOST
6275 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6276 /// + `nullptr == hPower`
6277 /// - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
6278 /// + User does not have permissions to make these modifications.
6279 /// - ::CTL_RESULT_ERROR_NOT_AVAILABLE
6280 /// + The device is in use, meaning that the GPU is under Over clocking, applying power limits under overclocking is not supported.
6281 CTL_APIEXPORT ctl_result_t CTL_APICALL
6283 ctl_pwr_handle_t hPower
, ///< [in] Handle for the component.
6284 const ctl_power_limits_t
* pPowerLimits
///< [in][optional] Structure that will contain the power limits.
6288 #if !defined(__GNUC__)
6289 #pragma endregion // power
6291 // Intel 'ctlApi' for Device Adapter - Temperature Sensors
6292 #if !defined(__GNUC__)
6293 #pragma region temperature
6295 ///////////////////////////////////////////////////////////////////////////////
6296 /// @brief Temperature sensors
6297 typedef enum _ctl_temp_sensors_t
6299 CTL_TEMP_SENSORS_GLOBAL
= 0, ///< The maximum temperature across all device sensors
6300 CTL_TEMP_SENSORS_GPU
= 1, ///< The maximum temperature across all sensors in the GPU
6301 CTL_TEMP_SENSORS_MEMORY
= 2, ///< The maximum temperature across all sensors in the local memory
6302 CTL_TEMP_SENSORS_GLOBAL_MIN
= 3, ///< The minimum temperature across all device sensors
6303 CTL_TEMP_SENSORS_GPU_MIN
= 4, ///< The minimum temperature across all sensors in the GPU
6304 CTL_TEMP_SENSORS_MEMORY_MIN
= 5, ///< The minimum temperature across all sensors in the local device memory
6305 CTL_TEMP_SENSORS_MAX
6307 } ctl_temp_sensors_t
;
6309 ///////////////////////////////////////////////////////////////////////////////
6310 /// @brief Temperature sensor properties
6311 typedef struct _ctl_temp_properties_t
6313 uint32_t Size
; ///< [in] size of this structure
6314 uint8_t Version
; ///< [in] version of this structure
6315 ctl_temp_sensors_t type
; ///< [out] Which part of the device the temperature sensor measures
6316 double maxTemperature
; ///< [out] Will contain the maximum temperature for the specific device in
6317 ///< degrees Celsius.
6319 } ctl_temp_properties_t
;
6321 ///////////////////////////////////////////////////////////////////////////////
6322 /// @brief Get handle of temperature sensors
6325 /// - The application may call this function from simultaneous threads.
6326 /// - The implementation of this function should be lock-free.
6329 /// - CTL_RESULT_SUCCESS
6330 /// - CTL_RESULT_ERROR_UNINITIALIZED
6331 /// - CTL_RESULT_ERROR_DEVICE_LOST
6332 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6333 /// + `nullptr == hDAhandle`
6334 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6335 /// + `nullptr == pCount`
6336 CTL_APIEXPORT ctl_result_t CTL_APICALL
6337 ctlEnumTemperatureSensors(
6338 ctl_device_adapter_handle_t hDAhandle
, ///< [in][release] Handle to display adapter
6339 uint32_t* pCount
, ///< [in,out] pointer to the number of components of this type.
6340 ///< if count is zero, then the driver shall update the value with the
6341 ///< total number of components of this type that are available.
6342 ///< if count is greater than the number of components of this type that
6343 ///< are available, then the driver shall update the value with the correct
6344 ///< number of components.
6345 ctl_temp_handle_t
* phTemperature
///< [in,out][optional][range(0, *pCount)] array of handle of components of
6347 ///< if count is less than the number of components of this type that are
6348 ///< available, then the driver shall only retrieve that number of
6349 ///< component handles.
6352 ///////////////////////////////////////////////////////////////////////////////
6353 /// @brief Get temperature sensor properties
6356 /// - The application may call this function from simultaneous threads.
6357 /// - The implementation of this function should be lock-free.
6360 /// - CTL_RESULT_SUCCESS
6361 /// - CTL_RESULT_ERROR_UNINITIALIZED
6362 /// - CTL_RESULT_ERROR_DEVICE_LOST
6363 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6364 /// + `nullptr == hTemperature`
6365 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6366 /// + `nullptr == pProperties`
6367 CTL_APIEXPORT ctl_result_t CTL_APICALL
6368 ctlTemperatureGetProperties(
6369 ctl_temp_handle_t hTemperature
, ///< [in] Handle for the component.
6370 ctl_temp_properties_t
* pProperties
///< [in,out] Will contain the temperature sensor properties.
6373 ///////////////////////////////////////////////////////////////////////////////
6374 /// @brief Get the temperature from a specified sensor
6377 /// - The application may call this function from simultaneous threads.
6378 /// - The implementation of this function should be lock-free.
6381 /// - CTL_RESULT_SUCCESS
6382 /// - CTL_RESULT_ERROR_UNINITIALIZED
6383 /// - CTL_RESULT_ERROR_DEVICE_LOST
6384 /// - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6385 /// + `nullptr == hTemperature`
6386 /// - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6387 /// + `nullptr == pTemperature`
6388 CTL_APIEXPORT ctl_result_t CTL_APICALL
6389 ctlTemperatureGetState(
6390 ctl_temp_handle_t hTemperature
, ///< [in] Handle for the component.
6391 double* pTemperature
///< [in,out] Will contain the temperature read from the specified sensor
6392 ///< in degrees Celsius.
6396 #if !defined(__GNUC__)
6397 #pragma endregion // temperature
6401 ///////////////////////////////////////////////////////////////////////////////
6402 /// @brief Function-pointer for ctlInit
6403 typedef ctl_result_t (CTL_APICALL
*ctl_pfnInit_t
)(
6409 ///////////////////////////////////////////////////////////////////////////////
6410 /// @brief Function-pointer for ctlClose
6411 typedef ctl_result_t (CTL_APICALL
*ctl_pfnClose_t
)(
6416 ///////////////////////////////////////////////////////////////////////////////
6417 /// @brief Function-pointer for ctlSetRuntimePath
6418 typedef ctl_result_t (CTL_APICALL
*ctl_pfnSetRuntimePath_t
)(
6419 ctl_runtime_path_args_t
*
6423 ///////////////////////////////////////////////////////////////////////////////
6424 /// @brief Function-pointer for ctlWaitForPropertyChange
6425 typedef ctl_result_t (CTL_APICALL
*ctl_pfnWaitForPropertyChange_t
)(
6426 ctl_device_adapter_handle_t
,
6427 ctl_wait_property_change_args_t
*
6431 ///////////////////////////////////////////////////////////////////////////////
6432 /// @brief Function-pointer for ctlReservedCall
6433 typedef ctl_result_t (CTL_APICALL
*ctl_pfnReservedCall_t
)(
6434 ctl_device_adapter_handle_t
,
6435 ctl_reserved_args_t
*
6439 ///////////////////////////////////////////////////////////////////////////////
6440 /// @brief Function-pointer for ctlGetSupported3DCapabilities
6441 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetSupported3DCapabilities_t
)(
6442 ctl_device_adapter_handle_t
,
6443 ctl_3d_feature_caps_t
*
6447 ///////////////////////////////////////////////////////////////////////////////
6448 /// @brief Function-pointer for ctlGetSet3DFeature
6449 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetSet3DFeature_t
)(
6450 ctl_device_adapter_handle_t
,
6451 ctl_3d_feature_getset_t
*
6455 ///////////////////////////////////////////////////////////////////////////////
6456 /// @brief Function-pointer for ctlCheckDriverVersion
6457 typedef ctl_result_t (CTL_APICALL
*ctl_pfnCheckDriverVersion_t
)(
6458 ctl_device_adapter_handle_t
,
6463 ///////////////////////////////////////////////////////////////////////////////
6464 /// @brief Function-pointer for ctlEnumerateDevices
6465 typedef ctl_result_t (CTL_APICALL
*ctl_pfnEnumerateDevices_t
)(
6468 ctl_device_adapter_handle_t
*
6472 ///////////////////////////////////////////////////////////////////////////////
6473 /// @brief Function-pointer for ctlEnumerateDisplayOutputs
6474 typedef ctl_result_t (CTL_APICALL
*ctl_pfnEnumerateDisplayOutputs_t
)(
6475 ctl_device_adapter_handle_t
,
6477 ctl_display_output_handle_t
*
6481 ///////////////////////////////////////////////////////////////////////////////
6482 /// @brief Function-pointer for ctlGetDeviceProperties
6483 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetDeviceProperties_t
)(
6484 ctl_device_adapter_handle_t
,
6485 ctl_device_adapter_properties_t
*
6489 ///////////////////////////////////////////////////////////////////////////////
6490 /// @brief Function-pointer for ctlGetDisplayProperties
6491 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetDisplayProperties_t
)(
6492 ctl_display_output_handle_t
,
6493 ctl_display_properties_t
*
6497 ///////////////////////////////////////////////////////////////////////////////
6498 /// @brief Function-pointer for ctlGetAdaperDisplayEncoderProperties
6499 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetAdaperDisplayEncoderProperties_t
)(
6500 ctl_display_output_handle_t
,
6501 ctl_adapter_display_encoder_properties_t
*
6505 ///////////////////////////////////////////////////////////////////////////////
6506 /// @brief Function-pointer for ctlGetZeDevice
6507 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetZeDevice_t
)(
6508 ctl_device_adapter_handle_t
,
6514 ///////////////////////////////////////////////////////////////////////////////
6515 /// @brief Function-pointer for ctlGetSharpnessCaps
6516 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetSharpnessCaps_t
)(
6517 ctl_display_output_handle_t
,
6518 ctl_sharpness_caps_t
*
6522 ///////////////////////////////////////////////////////////////////////////////
6523 /// @brief Function-pointer for ctlGetCurrentSharpness
6524 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetCurrentSharpness_t
)(
6525 ctl_display_output_handle_t
,
6526 ctl_sharpness_settings_t
*
6530 ///////////////////////////////////////////////////////////////////////////////
6531 /// @brief Function-pointer for ctlSetCurrentSharpness
6532 typedef ctl_result_t (CTL_APICALL
*ctl_pfnSetCurrentSharpness_t
)(
6533 ctl_display_output_handle_t
,
6534 ctl_sharpness_settings_t
*
6538 ///////////////////////////////////////////////////////////////////////////////
6539 /// @brief Function-pointer for ctlI2CAccess
6540 typedef ctl_result_t (CTL_APICALL
*ctl_pfnI2CAccess_t
)(
6541 ctl_display_output_handle_t
,
6542 ctl_i2c_access_args_t
*
6546 ///////////////////////////////////////////////////////////////////////////////
6547 /// @brief Function-pointer for ctlAUXAccess
6548 typedef ctl_result_t (CTL_APICALL
*ctl_pfnAUXAccess_t
)(
6549 ctl_display_output_handle_t
,
6550 ctl_aux_access_args_t
*
6554 ///////////////////////////////////////////////////////////////////////////////
6555 /// @brief Function-pointer for ctlGetPowerOptimizationCaps
6556 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetPowerOptimizationCaps_t
)(
6557 ctl_display_output_handle_t
,
6558 ctl_power_optimization_caps_t
*
6562 ///////////////////////////////////////////////////////////////////////////////
6563 /// @brief Function-pointer for ctlGetPowerOptimizationSetting
6564 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetPowerOptimizationSetting_t
)(
6565 ctl_display_output_handle_t
,
6566 ctl_power_optimization_settings_t
*
6570 ///////////////////////////////////////////////////////////////////////////////
6571 /// @brief Function-pointer for ctlSetPowerOptimizationSetting
6572 typedef ctl_result_t (CTL_APICALL
*ctl_pfnSetPowerOptimizationSetting_t
)(
6573 ctl_display_output_handle_t
,
6574 ctl_power_optimization_settings_t
*
6578 ///////////////////////////////////////////////////////////////////////////////
6579 /// @brief Function-pointer for ctlSetBrightnessSetting
6580 typedef ctl_result_t (CTL_APICALL
*ctl_pfnSetBrightnessSetting_t
)(
6581 ctl_display_output_handle_t
,
6582 ctl_set_brightness_t
*
6586 ///////////////////////////////////////////////////////////////////////////////
6587 /// @brief Function-pointer for ctlGetBrightnessSetting
6588 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetBrightnessSetting_t
)(
6589 ctl_display_output_handle_t
,
6590 ctl_get_brightness_t
*
6594 ///////////////////////////////////////////////////////////////////////////////
6595 /// @brief Function-pointer for ctlPixelTransformationGetConfig
6596 typedef ctl_result_t (CTL_APICALL
*ctl_pfnPixelTransformationGetConfig_t
)(
6597 ctl_display_output_handle_t
,
6598 ctl_pixtx_pipe_get_config_t
*
6602 ///////////////////////////////////////////////////////////////////////////////
6603 /// @brief Function-pointer for ctlPixelTransformationSetConfig
6604 typedef ctl_result_t (CTL_APICALL
*ctl_pfnPixelTransformationSetConfig_t
)(
6605 ctl_display_output_handle_t
,
6606 ctl_pixtx_pipe_set_config_t
*
6610 ///////////////////////////////////////////////////////////////////////////////
6611 /// @brief Function-pointer for ctlPanelDescriptorAccess
6612 typedef ctl_result_t (CTL_APICALL
*ctl_pfnPanelDescriptorAccess_t
)(
6613 ctl_display_output_handle_t
,
6614 ctl_panel_descriptor_access_args_t
*
6618 ///////////////////////////////////////////////////////////////////////////////
6619 /// @brief Function-pointer for ctlGetSupportedRetroScalingCapability
6620 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetSupportedRetroScalingCapability_t
)(
6621 ctl_device_adapter_handle_t
,
6622 ctl_retro_scaling_caps_t
*
6626 ///////////////////////////////////////////////////////////////////////////////
6627 /// @brief Function-pointer for ctlGetSetRetroScaling
6628 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetSetRetroScaling_t
)(
6629 ctl_device_adapter_handle_t
,
6630 ctl_retro_scaling_settings_t
*
6634 ///////////////////////////////////////////////////////////////////////////////
6635 /// @brief Function-pointer for ctlGetSupportedScalingCapability
6636 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetSupportedScalingCapability_t
)(
6637 ctl_display_output_handle_t
,
6642 ///////////////////////////////////////////////////////////////////////////////
6643 /// @brief Function-pointer for ctlGetCurrentScaling
6644 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetCurrentScaling_t
)(
6645 ctl_display_output_handle_t
,
6646 ctl_scaling_settings_t
*
6650 ///////////////////////////////////////////////////////////////////////////////
6651 /// @brief Function-pointer for ctlSetCurrentScaling
6652 typedef ctl_result_t (CTL_APICALL
*ctl_pfnSetCurrentScaling_t
)(
6653 ctl_display_output_handle_t
,
6654 ctl_scaling_settings_t
*
6658 ///////////////////////////////////////////////////////////////////////////////
6659 /// @brief Function-pointer for ctlGetLACEConfig
6660 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetLACEConfig_t
)(
6661 ctl_display_output_handle_t
,
6666 ///////////////////////////////////////////////////////////////////////////////
6667 /// @brief Function-pointer for ctlSetLACEConfig
6668 typedef ctl_result_t (CTL_APICALL
*ctl_pfnSetLACEConfig_t
)(
6669 ctl_display_output_handle_t
,
6674 ///////////////////////////////////////////////////////////////////////////////
6675 /// @brief Function-pointer for ctlSoftwarePSR
6676 typedef ctl_result_t (CTL_APICALL
*ctl_pfnSoftwarePSR_t
)(
6677 ctl_display_output_handle_t
,
6678 ctl_sw_psr_settings_t
*
6682 ///////////////////////////////////////////////////////////////////////////////
6683 /// @brief Function-pointer for ctlGetIntelArcSyncInfoForMonitor
6684 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetIntelArcSyncInfoForMonitor_t
)(
6685 ctl_display_output_handle_t
,
6686 ctl_intel_arc_sync_monitor_params_t
*
6690 ///////////////////////////////////////////////////////////////////////////////
6691 /// @brief Function-pointer for ctlEnumerateMuxDevices
6692 typedef ctl_result_t (CTL_APICALL
*ctl_pfnEnumerateMuxDevices_t
)(
6695 ctl_mux_output_handle_t
*
6699 ///////////////////////////////////////////////////////////////////////////////
6700 /// @brief Function-pointer for ctlGetMuxProperties
6701 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetMuxProperties_t
)(
6702 ctl_mux_output_handle_t
,
6703 ctl_mux_properties_t
*
6707 ///////////////////////////////////////////////////////////////////////////////
6708 /// @brief Function-pointer for ctlSwitchMux
6709 typedef ctl_result_t (CTL_APICALL
*ctl_pfnSwitchMux_t
)(
6710 ctl_mux_output_handle_t
,
6711 ctl_display_output_handle_t
6715 ///////////////////////////////////////////////////////////////////////////////
6716 /// @brief Function-pointer for ctlGetIntelArcSyncProfile
6717 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetIntelArcSyncProfile_t
)(
6718 ctl_display_output_handle_t
,
6719 ctl_intel_arc_sync_profile_params_t
*
6723 ///////////////////////////////////////////////////////////////////////////////
6724 /// @brief Function-pointer for ctlSetIntelArcSyncProfile
6725 typedef ctl_result_t (CTL_APICALL
*ctl_pfnSetIntelArcSyncProfile_t
)(
6726 ctl_display_output_handle_t
,
6727 ctl_intel_arc_sync_profile_params_t
*
6731 ///////////////////////////////////////////////////////////////////////////////
6732 /// @brief Function-pointer for ctlEdidManagement
6733 typedef ctl_result_t (CTL_APICALL
*ctl_pfnEdidManagement_t
)(
6734 ctl_display_output_handle_t
,
6735 ctl_edid_management_args_t
*
6739 ///////////////////////////////////////////////////////////////////////////////
6740 /// @brief Function-pointer for ctlGetSetCustomMode
6741 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetSetCustomMode_t
)(
6742 ctl_display_output_handle_t
,
6743 ctl_get_set_custom_mode_args_t
*
6747 ///////////////////////////////////////////////////////////////////////////////
6748 /// @brief Function-pointer for ctlGetSetCombinedDisplay
6749 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetSetCombinedDisplay_t
)(
6750 ctl_device_adapter_handle_t
,
6751 ctl_combined_display_args_t
*
6755 ///////////////////////////////////////////////////////////////////////////////
6756 /// @brief Function-pointer for ctlGetSetDisplayGenlock
6757 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetSetDisplayGenlock_t
)(
6758 ctl_device_adapter_handle_t
*,
6759 ctl_genlock_args_t
**,
6761 ctl_device_adapter_handle_t
*
6765 ///////////////////////////////////////////////////////////////////////////////
6766 /// @brief Function-pointer for ctlEnumEngineGroups
6767 typedef ctl_result_t (CTL_APICALL
*ctl_pfnEnumEngineGroups_t
)(
6768 ctl_device_adapter_handle_t
,
6770 ctl_engine_handle_t
*
6774 ///////////////////////////////////////////////////////////////////////////////
6775 /// @brief Function-pointer for ctlEngineGetProperties
6776 typedef ctl_result_t (CTL_APICALL
*ctl_pfnEngineGetProperties_t
)(
6777 ctl_engine_handle_t
,
6778 ctl_engine_properties_t
*
6782 ///////////////////////////////////////////////////////////////////////////////
6783 /// @brief Function-pointer for ctlEngineGetActivity
6784 typedef ctl_result_t (CTL_APICALL
*ctl_pfnEngineGetActivity_t
)(
6785 ctl_engine_handle_t
,
6790 ///////////////////////////////////////////////////////////////////////////////
6791 /// @brief Function-pointer for ctlEnumFans
6792 typedef ctl_result_t (CTL_APICALL
*ctl_pfnEnumFans_t
)(
6793 ctl_device_adapter_handle_t
,
6799 ///////////////////////////////////////////////////////////////////////////////
6800 /// @brief Function-pointer for ctlFanGetProperties
6801 typedef ctl_result_t (CTL_APICALL
*ctl_pfnFanGetProperties_t
)(
6803 ctl_fan_properties_t
*
6807 ///////////////////////////////////////////////////////////////////////////////
6808 /// @brief Function-pointer for ctlFanGetConfig
6809 typedef ctl_result_t (CTL_APICALL
*ctl_pfnFanGetConfig_t
)(
6815 ///////////////////////////////////////////////////////////////////////////////
6816 /// @brief Function-pointer for ctlFanSetDefaultMode
6817 typedef ctl_result_t (CTL_APICALL
*ctl_pfnFanSetDefaultMode_t
)(
6822 ///////////////////////////////////////////////////////////////////////////////
6823 /// @brief Function-pointer for ctlFanSetFixedSpeedMode
6824 typedef ctl_result_t (CTL_APICALL
*ctl_pfnFanSetFixedSpeedMode_t
)(
6826 const ctl_fan_speed_t
*
6830 ///////////////////////////////////////////////////////////////////////////////
6831 /// @brief Function-pointer for ctlFanSetSpeedTableMode
6832 typedef ctl_result_t (CTL_APICALL
*ctl_pfnFanSetSpeedTableMode_t
)(
6834 const ctl_fan_speed_table_t
*
6838 ///////////////////////////////////////////////////////////////////////////////
6839 /// @brief Function-pointer for ctlFanGetState
6840 typedef ctl_result_t (CTL_APICALL
*ctl_pfnFanGetState_t
)(
6842 ctl_fan_speed_units_t
,
6847 ///////////////////////////////////////////////////////////////////////////////
6848 /// @brief Function-pointer for ctlEnumFrequencyDomains
6849 typedef ctl_result_t (CTL_APICALL
*ctl_pfnEnumFrequencyDomains_t
)(
6850 ctl_device_adapter_handle_t
,
6856 ///////////////////////////////////////////////////////////////////////////////
6857 /// @brief Function-pointer for ctlFrequencyGetProperties
6858 typedef ctl_result_t (CTL_APICALL
*ctl_pfnFrequencyGetProperties_t
)(
6860 ctl_freq_properties_t
*
6864 ///////////////////////////////////////////////////////////////////////////////
6865 /// @brief Function-pointer for ctlFrequencyGetAvailableClocks
6866 typedef ctl_result_t (CTL_APICALL
*ctl_pfnFrequencyGetAvailableClocks_t
)(
6873 ///////////////////////////////////////////////////////////////////////////////
6874 /// @brief Function-pointer for ctlFrequencyGetRange
6875 typedef ctl_result_t (CTL_APICALL
*ctl_pfnFrequencyGetRange_t
)(
6881 ///////////////////////////////////////////////////////////////////////////////
6882 /// @brief Function-pointer for ctlFrequencySetRange
6883 typedef ctl_result_t (CTL_APICALL
*ctl_pfnFrequencySetRange_t
)(
6885 const ctl_freq_range_t
*
6889 ///////////////////////////////////////////////////////////////////////////////
6890 /// @brief Function-pointer for ctlFrequencyGetState
6891 typedef ctl_result_t (CTL_APICALL
*ctl_pfnFrequencyGetState_t
)(
6897 ///////////////////////////////////////////////////////////////////////////////
6898 /// @brief Function-pointer for ctlFrequencyGetThrottleTime
6899 typedef ctl_result_t (CTL_APICALL
*ctl_pfnFrequencyGetThrottleTime_t
)(
6901 ctl_freq_throttle_time_t
*
6905 ///////////////////////////////////////////////////////////////////////////////
6906 /// @brief Function-pointer for ctlGetSupportedVideoProcessingCapabilities
6907 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetSupportedVideoProcessingCapabilities_t
)(
6908 ctl_device_adapter_handle_t
,
6909 ctl_video_processing_feature_caps_t
*
6913 ///////////////////////////////////////////////////////////////////////////////
6914 /// @brief Function-pointer for ctlGetSetVideoProcessingFeature
6915 typedef ctl_result_t (CTL_APICALL
*ctl_pfnGetSetVideoProcessingFeature_t
)(
6916 ctl_device_adapter_handle_t
,
6917 ctl_video_processing_feature_getset_t
*
6921 ///////////////////////////////////////////////////////////////////////////////
6922 /// @brief Function-pointer for ctlEnumMemoryModules
6923 typedef ctl_result_t (CTL_APICALL
*ctl_pfnEnumMemoryModules_t
)(
6924 ctl_device_adapter_handle_t
,
6930 ///////////////////////////////////////////////////////////////////////////////
6931 /// @brief Function-pointer for ctlMemoryGetProperties
6932 typedef ctl_result_t (CTL_APICALL
*ctl_pfnMemoryGetProperties_t
)(
6934 ctl_mem_properties_t
*
6938 ///////////////////////////////////////////////////////////////////////////////
6939 /// @brief Function-pointer for ctlMemoryGetState
6940 typedef ctl_result_t (CTL_APICALL
*ctl_pfnMemoryGetState_t
)(
6946 ///////////////////////////////////////////////////////////////////////////////
6947 /// @brief Function-pointer for ctlMemoryGetBandwidth
6948 typedef ctl_result_t (CTL_APICALL
*ctl_pfnMemoryGetBandwidth_t
)(
6950 ctl_mem_bandwidth_t
*
6954 ///////////////////////////////////////////////////////////////////////////////
6955 /// @brief Function-pointer for ctlOverclockGetProperties
6956 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockGetProperties_t
)(
6957 ctl_device_adapter_handle_t
,
6958 ctl_oc_properties_t
*
6962 ///////////////////////////////////////////////////////////////////////////////
6963 /// @brief Function-pointer for ctlOverclockWaiverSet
6964 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockWaiverSet_t
)(
6965 ctl_device_adapter_handle_t
6969 ///////////////////////////////////////////////////////////////////////////////
6970 /// @brief Function-pointer for ctlOverclockGpuFrequencyOffsetGet
6971 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockGpuFrequencyOffsetGet_t
)(
6972 ctl_device_adapter_handle_t
,
6977 ///////////////////////////////////////////////////////////////////////////////
6978 /// @brief Function-pointer for ctlOverclockGpuFrequencyOffsetSet
6979 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockGpuFrequencyOffsetSet_t
)(
6980 ctl_device_adapter_handle_t
,
6985 ///////////////////////////////////////////////////////////////////////////////
6986 /// @brief Function-pointer for ctlOverclockGpuVoltageOffsetGet
6987 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockGpuVoltageOffsetGet_t
)(
6988 ctl_device_adapter_handle_t
,
6993 ///////////////////////////////////////////////////////////////////////////////
6994 /// @brief Function-pointer for ctlOverclockGpuVoltageOffsetSet
6995 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockGpuVoltageOffsetSet_t
)(
6996 ctl_device_adapter_handle_t
,
7001 ///////////////////////////////////////////////////////////////////////////////
7002 /// @brief Function-pointer for ctlOverclockGpuLockGet
7003 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockGpuLockGet_t
)(
7004 ctl_device_adapter_handle_t
,
7009 ///////////////////////////////////////////////////////////////////////////////
7010 /// @brief Function-pointer for ctlOverclockGpuLockSet
7011 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockGpuLockSet_t
)(
7012 ctl_device_adapter_handle_t
,
7017 ///////////////////////////////////////////////////////////////////////////////
7018 /// @brief Function-pointer for ctlOverclockVramFrequencyOffsetGet
7019 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockVramFrequencyOffsetGet_t
)(
7020 ctl_device_adapter_handle_t
,
7025 ///////////////////////////////////////////////////////////////////////////////
7026 /// @brief Function-pointer for ctlOverclockVramFrequencyOffsetSet
7027 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockVramFrequencyOffsetSet_t
)(
7028 ctl_device_adapter_handle_t
,
7033 ///////////////////////////////////////////////////////////////////////////////
7034 /// @brief Function-pointer for ctlOverclockVramVoltageOffsetGet
7035 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockVramVoltageOffsetGet_t
)(
7036 ctl_device_adapter_handle_t
,
7041 ///////////////////////////////////////////////////////////////////////////////
7042 /// @brief Function-pointer for ctlOverclockVramVoltageOffsetSet
7043 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockVramVoltageOffsetSet_t
)(
7044 ctl_device_adapter_handle_t
,
7049 ///////////////////////////////////////////////////////////////////////////////
7050 /// @brief Function-pointer for ctlOverclockPowerLimitGet
7051 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockPowerLimitGet_t
)(
7052 ctl_device_adapter_handle_t
,
7057 ///////////////////////////////////////////////////////////////////////////////
7058 /// @brief Function-pointer for ctlOverclockPowerLimitSet
7059 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockPowerLimitSet_t
)(
7060 ctl_device_adapter_handle_t
,
7065 ///////////////////////////////////////////////////////////////////////////////
7066 /// @brief Function-pointer for ctlOverclockTemperatureLimitGet
7067 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockTemperatureLimitGet_t
)(
7068 ctl_device_adapter_handle_t
,
7073 ///////////////////////////////////////////////////////////////////////////////
7074 /// @brief Function-pointer for ctlOverclockTemperatureLimitSet
7075 typedef ctl_result_t (CTL_APICALL
*ctl_pfnOverclockTemperatureLimitSet_t
)(
7076 ctl_device_adapter_handle_t
,
7081 ///////////////////////////////////////////////////////////////////////////////
7082 /// @brief Function-pointer for ctlPowerTelemetryGet
7083 typedef ctl_result_t (CTL_APICALL
*ctl_pfnPowerTelemetryGet_t
)(
7084 ctl_device_adapter_handle_t
,
7085 ctl_power_telemetry_t
*
7089 ///////////////////////////////////////////////////////////////////////////////
7090 /// @brief Function-pointer for ctlPciGetProperties
7091 typedef ctl_result_t (CTL_APICALL
*ctl_pfnPciGetProperties_t
)(
7092 ctl_device_adapter_handle_t
,
7093 ctl_pci_properties_t
*
7097 ///////////////////////////////////////////////////////////////////////////////
7098 /// @brief Function-pointer for ctlPciGetState
7099 typedef ctl_result_t (CTL_APICALL
*ctl_pfnPciGetState_t
)(
7100 ctl_device_adapter_handle_t
,
7105 ///////////////////////////////////////////////////////////////////////////////
7106 /// @brief Function-pointer for ctlEnumPowerDomains
7107 typedef ctl_result_t (CTL_APICALL
*ctl_pfnEnumPowerDomains_t
)(
7108 ctl_device_adapter_handle_t
,
7114 ///////////////////////////////////////////////////////////////////////////////
7115 /// @brief Function-pointer for ctlPowerGetProperties
7116 typedef ctl_result_t (CTL_APICALL
*ctl_pfnPowerGetProperties_t
)(
7118 ctl_power_properties_t
*
7122 ///////////////////////////////////////////////////////////////////////////////
7123 /// @brief Function-pointer for ctlPowerGetEnergyCounter
7124 typedef ctl_result_t (CTL_APICALL
*ctl_pfnPowerGetEnergyCounter_t
)(
7126 ctl_power_energy_counter_t
*
7130 ///////////////////////////////////////////////////////////////////////////////
7131 /// @brief Function-pointer for ctlPowerGetLimits
7132 typedef ctl_result_t (CTL_APICALL
*ctl_pfnPowerGetLimits_t
)(
7138 ///////////////////////////////////////////////////////////////////////////////
7139 /// @brief Function-pointer for ctlPowerSetLimits
7140 typedef ctl_result_t (CTL_APICALL
*ctl_pfnPowerSetLimits_t
)(
7142 const ctl_power_limits_t
*
7146 ///////////////////////////////////////////////////////////////////////////////
7147 /// @brief Function-pointer for ctlEnumTemperatureSensors
7148 typedef ctl_result_t (CTL_APICALL
*ctl_pfnEnumTemperatureSensors_t
)(
7149 ctl_device_adapter_handle_t
,
7155 ///////////////////////////////////////////////////////////////////////////////
7156 /// @brief Function-pointer for ctlTemperatureGetProperties
7157 typedef ctl_result_t (CTL_APICALL
*ctl_pfnTemperatureGetProperties_t
)(
7159 ctl_temp_properties_t
*
7163 ///////////////////////////////////////////////////////////////////////////////
7164 /// @brief Function-pointer for ctlTemperatureGetState
7165 typedef ctl_result_t (CTL_APICALL
*ctl_pfnTemperatureGetState_t
)(
7171 #if defined(__cplusplus)
7175 #endif // _CTL_API_H