Update dependencies
[temp2RGB.git] / IntelArc / igcl_api.h
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 //--------------------------------------------------------------------------
11
12 /**
13 *
14 * @file ctl_api.h
15 * @version v1-r1
16 *
17 */
18 #ifndef _CTL_API_H
19 #define _CTL_API_H
20 #if defined(__cplusplus)
21 #pragma once
22 #endif
23
24 // standard headers
25 #include <stdint.h>
26 #include <stddef.h>
27
28 #if defined(__cplusplus)
29 extern "C" {
30 #endif
31
32 // Intel 'ctlApi' common types
33 #if !defined(__GNUC__)
34 #pragma region common
35 #endif
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
41
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
47
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
53
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
59
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
65
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
71
72 ///////////////////////////////////////////////////////////////////////////////
73 #ifndef CTL_APICALL
74 #if defined(_WIN32)
75 /// @brief Calling convention for all API functions
76 #define CTL_APICALL __cdecl
77 #else
78 #define CTL_APICALL
79 #endif // defined(_WIN32)
80 #endif // CTL_APICALL
81
82 ///////////////////////////////////////////////////////////////////////////////
83 #ifndef CTL_APIEXPORT
84 #if defined(_WIN32)
85 /// @brief Microsoft-specific dllexport storage-class attribute
86 #define CTL_APIEXPORT __declspec(dllexport)
87 #else
88 #define CTL_APIEXPORT
89 #endif // defined(_WIN32)
90 #endif // CTL_APIEXPORT
91
92 ///////////////////////////////////////////////////////////////////////////////
93 #ifndef CTL_DLLEXPORT
94 #if defined(_WIN32)
95 /// @brief Microsoft-specific dllexport storage-class attribute
96 #define CTL_DLLEXPORT __declspec(dllexport)
97 #endif // defined(_WIN32)
98 #endif // CTL_DLLEXPORT
99
100 ///////////////////////////////////////////////////////////////////////////////
101 #ifndef CTL_DLLEXPORT
102 #if __GNUC__ >= 4
103 /// @brief GCC-specific dllexport storage-class attribute
104 #define CTL_DLLEXPORT __attribute__ ((visibility ("default")))
105 #else
106 #define CTL_DLLEXPORT
107 #endif // __GNUC__ >= 4
108 #endif // CTL_DLLEXPORT
109
110 ///////////////////////////////////////////////////////////////////////////////
111 #ifndef CTL_BIT
112 /// @brief Generic macro for enumerator bit masks
113 #define CTL_BIT( _i ) ( 1 << _i )
114 #endif // CTL_BIT
115
116 ///////////////////////////////////////////////////////////////////////////////
117 /// @brief Supported initialization flags
118 typedef uint32_t ctl_init_flags_t;
119 typedef enum _ctl_init_flag_t
120 {
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
124
125 } ctl_init_flag_t;
126
127 ///////////////////////////////////////////////////////////////////////////////
128 /// @brief Version information
129 typedef uint32_t ctl_version_info_t;
130
131 ///////////////////////////////////////////////////////////////////////////////
132 /// @brief Handle of a control API instance
133 typedef struct _ctl_api_handle_t *ctl_api_handle_t;
134
135 ///////////////////////////////////////////////////////////////////////////////
136 /// @brief Handle of a device adapter instance
137 typedef struct _ctl_device_adapter_handle_t *ctl_device_adapter_handle_t;
138
139 ///////////////////////////////////////////////////////////////////////////////
140 /// @brief Handle of a device temperature sensor
141 typedef struct _ctl_temp_handle_t *ctl_temp_handle_t;
142
143 ///////////////////////////////////////////////////////////////////////////////
144 /// @brief Handle for a device frequency domain
145 typedef struct _ctl_freq_handle_t *ctl_freq_handle_t;
146
147 ///////////////////////////////////////////////////////////////////////////////
148 /// @brief Handle of a power device.
149 typedef struct _ctl_pwr_handle_t *ctl_pwr_handle_t;
150
151 ///////////////////////////////////////////////////////////////////////////////
152 /// @brief Handle of a device fan
153 typedef struct _ctl_fan_handle_t *ctl_fan_handle_t;
154
155 ///////////////////////////////////////////////////////////////////////////////
156 /// @brief Handle of a device memory module
157 typedef struct _ctl_mem_handle_t *ctl_mem_handle_t;
158
159 ///////////////////////////////////////////////////////////////////////////////
160 /// @brief Handle of a device engine group
161 typedef struct _ctl_engine_handle_t *ctl_engine_handle_t;
162
163 ///////////////////////////////////////////////////////////////////////////////
164 /// @brief Base for all properties types
165 typedef struct _ctl_base_interface_t
166 {
167 uint32_t Size; ///< [in] size of this structure
168 uint8_t Version; ///< [in] version of this structure
169
170 } ctl_base_interface_t;
171
172 ///////////////////////////////////////////////////////////////////////////////
173 /// @brief Value type
174 typedef enum _ctl_property_value_type_t
175 {
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
183
184 } ctl_property_value_type_t;
185
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
190 {
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
195
196 } ctl_property_range_info_t;
197
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
202 {
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
207
208 } ctl_property_range_info_int_t;
209
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
214 {
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
219
220 } ctl_property_range_info_uint_t;
221
222 ///////////////////////////////////////////////////////////////////////////////
223 /// @brief Bool feature details
224 typedef struct _ctl_property_info_boolean_t
225 {
226 bool DefaultState; ///< [out] Default state
227
228 } ctl_property_info_boolean_t;
229
230 ///////////////////////////////////////////////////////////////////////////////
231 /// @brief Bool feature for get/set
232 typedef struct _ctl_property_boolean_t
233 {
234 bool Enable; ///< [in,out] Enable
235
236 } ctl_property_boolean_t;
237
238 ///////////////////////////////////////////////////////////////////////////////
239 /// @brief Enumeration feature details
240 typedef struct _ctl_property_info_enum_t
241 {
242 uint64_t SupportedTypes; ///< [out] Supported possible values represented as a bitmask
243 uint32_t DefaultType; ///< [out] Default type
244
245 } ctl_property_info_enum_t;
246
247 ///////////////////////////////////////////////////////////////////////////////
248 /// @brief Enumeration feature for get/set
249 typedef struct _ctl_property_enum_t
250 {
251 uint32_t EnableType; ///< [in,out] Enable with specific type
252
253 } ctl_property_enum_t;
254
255 ///////////////////////////////////////////////////////////////////////////////
256 /// @brief Float feature details
257 typedef struct _ctl_property_info_float_t
258 {
259 bool DefaultEnable; ///< [in,out] DefaultEnable
260 ctl_property_range_info_t RangeInfo; ///< [out] Min/max/default/step details
261
262 } ctl_property_info_float_t;
263
264 ///////////////////////////////////////////////////////////////////////////////
265 /// @brief Float feature for get/set
266 typedef struct _ctl_property_float_t
267 {
268 bool Enable; ///< [in,out] Enable
269 float Value; ///< [in,out] Value
270
271 } ctl_property_float_t;
272
273 ///////////////////////////////////////////////////////////////////////////////
274 /// @brief Int32 feature details
275 typedef struct _ctl_property_info_int_t
276 {
277 bool DefaultEnable; ///< [in,out] DefaultEnable
278 ctl_property_range_info_int_t RangeInfo; ///< [out] Min/max/default/step details
279
280 } ctl_property_info_int_t;
281
282 ///////////////////////////////////////////////////////////////////////////////
283 /// @brief Int32 feature for get/set
284 typedef struct _ctl_property_int_t
285 {
286 bool Enable; ///< [in,out] Enable
287 int32_t Value; ///< [in,out] Value
288
289 } ctl_property_int_t;
290
291 ///////////////////////////////////////////////////////////////////////////////
292 /// @brief Int32 feature details
293 typedef struct _ctl_property_info_uint_t
294 {
295 bool DefaultEnable; ///< [in,out] DefaultEnable
296 ctl_property_range_info_uint_t RangeInfo; ///< [out] Min/max/default/step details
297
298 } ctl_property_info_uint_t;
299
300 ///////////////////////////////////////////////////////////////////////////////
301 /// @brief Int32 feature for get/set
302 typedef struct _ctl_property_uint_t
303 {
304 bool Enable; ///< [in,out] Enable
305 uint32_t Value; ///< [in,out] Value
306
307 } ctl_property_uint_t;
308
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
313 {
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
319
320 } ctl_property_info_t;
321
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
326 {
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
332
333 } ctl_property_t;
334
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
344 {
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
348 ///< "
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
391 ///< "
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
403 ///< "
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
406 ///< "
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
409 ///< "
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
435 ///< passed by user
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
441 ///< "
442 CTL_RESULT_MAX
443
444 } ctl_result_t;
445
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
451
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
457
458 ///////////////////////////////////////////////////////////////////////////////
459 /// @brief General Physical Units.
460 typedef enum _ctl_units_t
461 {
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.
473 CTL_UNITS_MAX
474
475 } ctl_units_t;
476
477 ///////////////////////////////////////////////////////////////////////////////
478 /// @brief General Data Types.
479 typedef enum _ctl_data_type_t
480 {
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.
495 CTL_DATA_TYPE_MAX
496
497 } ctl_data_type_t;
498
499 ///////////////////////////////////////////////////////////////////////////////
500 /// @brief Union for Generic Data.
501 ///
502 /// @details
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
506 {
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.
517
518 } ctl_data_value_t;
519
520 ///////////////////////////////////////////////////////////////////////////////
521 /// @brief Base for all properties types
522 typedef struct _ctl_base_properties_t
523 {
524 uint32_t Size; ///< [in] size of this structure
525 uint8_t Version; ///< [in] version of this structure
526
527 } ctl_base_properties_t;
528
529 ///////////////////////////////////////////////////////////////////////////////
530 /// @brief Application Unique ID
531 typedef struct _ctl_application_id_t
532 {
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
537
538 } ctl_application_id_t;
539
540 ///////////////////////////////////////////////////////////////////////////////
541 /// @brief Init arguments
542 typedef struct _ctl_init_args_t
543 {
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
550 ///< the default ID
551
552 } ctl_init_args_t;
553
554 ///////////////////////////////////////////////////////////////////////////////
555 /// @brief Reserved struct
556 typedef struct _ctl_reserved_args_t
557 {
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
562
563 } ctl_reserved_args_t;
564
565 ///////////////////////////////////////////////////////////////////////////////
566 /// @brief Reserved base struct
567 typedef struct _ctl_reserved_args_base_t
568 {
569 ctl_application_id_t ReservedFuncID; ///< [in] Unique ID for reserved/special function
570
571 } ctl_reserved_args_base_t;
572
573 ///////////////////////////////////////////////////////////////////////////////
574 /// @brief Reserved - Unlock function capability
575 typedef struct _ctl_unlock_capability_t
576 {
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
579
580 } ctl_unlock_capability_t;
581
582 ///////////////////////////////////////////////////////////////////////////////
583 /// @brief Used by loader like modules to specify runtime implementation details
584 typedef struct _ctl_runtime_path_args_t
585 {
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
592 ///< NULL.
593
594 } ctl_runtime_path_args_t;
595
596 ///////////////////////////////////////////////////////////////////////////////
597 /// @brief Control Api Init
598 ///
599 /// @details
600 /// - Control Api Init
601 ///
602 /// @returns
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
611 ctlInit(
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
614 );
615
616 ///////////////////////////////////////////////////////////////////////////////
617 /// @brief Control Api Destroy
618 ///
619 /// @details
620 /// - Control Api Close
621 ///
622 /// @returns
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
630 ctlClose(
631 ctl_api_handle_t hAPIHandle ///< [in][release] Control API implementation handle obtained during init
632 ///< call
633 );
634
635 ///////////////////////////////////////////////////////////////////////////////
636 /// @brief Runtime path
637 ///
638 /// @details
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.
644 ///
645 /// @returns
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
653 ctlSetRuntimePath(
654 ctl_runtime_path_args_t* pArgs ///< [in] Runtime path
655 );
656
657 ///////////////////////////////////////////////////////////////////////////////
658 /// @brief Supported Functions
659 typedef uint32_t ctl_supported_functions_flags_t;
660 typedef enum _ctl_supported_functions_flag_t
661 {
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
666
667 } ctl_supported_functions_flag_t;
668
669 ///////////////////////////////////////////////////////////////////////////////
670 /// @brief Firmware version
671 typedef struct _ctl_firmware_version_t
672 {
673 uint64_t major_version; ///< [out] Major version
674 uint64_t minor_version; ///< [out] Minor version
675 uint64_t build_number; ///< [out] Build number
676
677 } ctl_firmware_version_t;
678
679 ///////////////////////////////////////////////////////////////////////////////
680 /// @brief DeviceType
681 typedef enum _ctl_device_type_t
682 {
683 CTL_DEVICE_TYPE_GRAPHICS = 1, ///< Graphics Device type
684 CTL_DEVICE_TYPE_SYSTEM = 2, ///< System Device type
685 CTL_DEVICE_TYPE_MAX
686
687 } ctl_device_type_t;
688
689 ///////////////////////////////////////////////////////////////////////////////
690 /// @brief Adapter Properties
691 typedef uint32_t ctl_adapter_properties_flags_t;
692 typedef enum _ctl_adapter_properties_flag_t
693 {
694 CTL_ADAPTER_PROPERTIES_FLAG_INTEGRATED = CTL_BIT(0),///< [out] Is Integrated Graphics adapter
695 CTL_ADAPTER_PROPERTIES_FLAG_MAX = 0x80000000
696
697 } ctl_adapter_properties_flag_t;
698
699 ///////////////////////////////////////////////////////////////////////////////
700 /// @brief Device Adapter properties
701 typedef struct _ctl_device_adapter_properties_t
702 {
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
723
724 } ctl_device_adapter_properties_t;
725
726 ///////////////////////////////////////////////////////////////////////////////
727 /// @brief OperationType
728 typedef enum _ctl_operation_type_t
729 {
730 CTL_OPERATION_TYPE_READ = 1, ///< Read operation
731 CTL_OPERATION_TYPE_WRITE = 2, ///< Write operation
732 CTL_OPERATION_TYPE_MAX
733
734 } ctl_operation_type_t;
735
736 ///////////////////////////////////////////////////////////////////////////////
737 /// @brief Generic Structure for Void* datatypes
738 typedef struct _ctl_generic_void_datatype_t
739 {
740 void* pData; ///< [in,out]void pointer to memory
741 uint32_t size; ///< [in,out]size of the allocated memory
742
743 } ctl_generic_void_datatype_t;
744
745 ///////////////////////////////////////////////////////////////////////////////
746 /// @brief Generic Structure for Revision datatypes
747 typedef struct _ctl_revision_datatype_t
748 {
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
752
753 } ctl_revision_datatype_t;
754
755 ///////////////////////////////////////////////////////////////////////////////
756 /// @brief Property Type flags
757 typedef uint32_t ctl_property_type_flags_t;
758 typedef enum _ctl_property_type_flag_t
759 {
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
765
766 } ctl_property_type_flag_t;
767
768 ///////////////////////////////////////////////////////////////////////////////
769 /// @brief Arguments related to wait for a property change function
770 typedef struct _ctl_wait_property_change_args_t
771 {
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
780
781 } ctl_wait_property_change_args_t;
782
783 ///////////////////////////////////////////////////////////////////////////////
784 /// @brief Display orientation (rotation)
785 typedef enum _ctl_display_orientation_t
786 {
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
792
793 } ctl_display_orientation_t;
794
795 ///////////////////////////////////////////////////////////////////////////////
796 /// @brief Rectangle
797 typedef struct _ctl_rect_t
798 {
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
803
804 } ctl_rect_t;
805
806 ///////////////////////////////////////////////////////////////////////////////
807 /// @brief Wait for a property change. Note that this is a blocking call
808 ///
809 /// @details
810 /// - Wait for a property change in display, 3d, media etc.
811 ///
812 /// @returns
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
825 ///< listen for
826 );
827
828 ///////////////////////////////////////////////////////////////////////////////
829 /// @brief Reserved function
830 ///
831 /// @details
832 /// - Reserved function
833 ///
834 /// @returns
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
844 ctlReservedCall(
845 ctl_device_adapter_handle_t hDeviceAdapter, ///< [in][release] handle to control device adapter
846 ctl_reserved_args_t* pArgs ///< [in] Argument containing information
847 );
848
849 ///////////////////////////////////////////////////////////////////////////////
850 /// @brief Forward-declare ctl_base_interface_t
851 typedef struct _ctl_base_interface_t ctl_base_interface_t;
852
853 ///////////////////////////////////////////////////////////////////////////////
854 /// @brief Forward-declare ctl_property_range_info_t
855 typedef struct _ctl_property_range_info_t ctl_property_range_info_t;
856
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;
860
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;
864
865 ///////////////////////////////////////////////////////////////////////////////
866 /// @brief Forward-declare ctl_property_info_boolean_t
867 typedef struct _ctl_property_info_boolean_t ctl_property_info_boolean_t;
868
869 ///////////////////////////////////////////////////////////////////////////////
870 /// @brief Forward-declare ctl_property_boolean_t
871 typedef struct _ctl_property_boolean_t ctl_property_boolean_t;
872
873 ///////////////////////////////////////////////////////////////////////////////
874 /// @brief Forward-declare ctl_property_info_enum_t
875 typedef struct _ctl_property_info_enum_t ctl_property_info_enum_t;
876
877 ///////////////////////////////////////////////////////////////////////////////
878 /// @brief Forward-declare ctl_property_enum_t
879 typedef struct _ctl_property_enum_t ctl_property_enum_t;
880
881 ///////////////////////////////////////////////////////////////////////////////
882 /// @brief Forward-declare ctl_property_info_float_t
883 typedef struct _ctl_property_info_float_t ctl_property_info_float_t;
884
885 ///////////////////////////////////////////////////////////////////////////////
886 /// @brief Forward-declare ctl_property_float_t
887 typedef struct _ctl_property_float_t ctl_property_float_t;
888
889 ///////////////////////////////////////////////////////////////////////////////
890 /// @brief Forward-declare ctl_property_info_int_t
891 typedef struct _ctl_property_info_int_t ctl_property_info_int_t;
892
893 ///////////////////////////////////////////////////////////////////////////////
894 /// @brief Forward-declare ctl_property_int_t
895 typedef struct _ctl_property_int_t ctl_property_int_t;
896
897 ///////////////////////////////////////////////////////////////////////////////
898 /// @brief Forward-declare ctl_property_info_uint_t
899 typedef struct _ctl_property_info_uint_t ctl_property_info_uint_t;
900
901 ///////////////////////////////////////////////////////////////////////////////
902 /// @brief Forward-declare ctl_property_uint_t
903 typedef struct _ctl_property_uint_t ctl_property_uint_t;
904
905 ///////////////////////////////////////////////////////////////////////////////
906 /// @brief Forward-declare ctl_base_properties_t
907 typedef struct _ctl_base_properties_t ctl_base_properties_t;
908
909 ///////////////////////////////////////////////////////////////////////////////
910 /// @brief Forward-declare ctl_application_id_t
911 typedef struct _ctl_application_id_t ctl_application_id_t;
912
913 ///////////////////////////////////////////////////////////////////////////////
914 /// @brief Forward-declare ctl_init_args_t
915 typedef struct _ctl_init_args_t ctl_init_args_t;
916
917 ///////////////////////////////////////////////////////////////////////////////
918 /// @brief Forward-declare ctl_reserved_args_t
919 typedef struct _ctl_reserved_args_t ctl_reserved_args_t;
920
921 ///////////////////////////////////////////////////////////////////////////////
922 /// @brief Forward-declare ctl_reserved_args_base_t
923 typedef struct _ctl_reserved_args_base_t ctl_reserved_args_base_t;
924
925 ///////////////////////////////////////////////////////////////////////////////
926 /// @brief Forward-declare ctl_unlock_capability_t
927 typedef struct _ctl_unlock_capability_t ctl_unlock_capability_t;
928
929 ///////////////////////////////////////////////////////////////////////////////
930 /// @brief Forward-declare ctl_runtime_path_args_t
931 typedef struct _ctl_runtime_path_args_t ctl_runtime_path_args_t;
932
933 ///////////////////////////////////////////////////////////////////////////////
934 /// @brief Forward-declare ctl_firmware_version_t
935 typedef struct _ctl_firmware_version_t ctl_firmware_version_t;
936
937 ///////////////////////////////////////////////////////////////////////////////
938 /// @brief Forward-declare ctl_device_adapter_properties_t
939 typedef struct _ctl_device_adapter_properties_t ctl_device_adapter_properties_t;
940
941 ///////////////////////////////////////////////////////////////////////////////
942 /// @brief Forward-declare ctl_generic_void_datatype_t
943 typedef struct _ctl_generic_void_datatype_t ctl_generic_void_datatype_t;
944
945 ///////////////////////////////////////////////////////////////////////////////
946 /// @brief Forward-declare ctl_revision_datatype_t
947 typedef struct _ctl_revision_datatype_t ctl_revision_datatype_t;
948
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;
952
953 ///////////////////////////////////////////////////////////////////////////////
954 /// @brief Forward-declare ctl_rect_t
955 typedef struct _ctl_rect_t ctl_rect_t;
956
957 ///////////////////////////////////////////////////////////////////////////////
958 /// @brief Forward-declare ctl_endurance_gaming_caps_t
959 typedef struct _ctl_endurance_gaming_caps_t ctl_endurance_gaming_caps_t;
960
961 ///////////////////////////////////////////////////////////////////////////////
962 /// @brief Forward-declare ctl_endurance_gaming_t
963 typedef struct _ctl_endurance_gaming_t ctl_endurance_gaming_t;
964
965 ///////////////////////////////////////////////////////////////////////////////
966 /// @brief Forward-declare ctl_endurance_gaming2_t
967 typedef struct _ctl_endurance_gaming2_t ctl_endurance_gaming2_t;
968
969 ///////////////////////////////////////////////////////////////////////////////
970 /// @brief Forward-declare ctl_adaptivesync_caps_t
971 typedef struct _ctl_adaptivesync_caps_t ctl_adaptivesync_caps_t;
972
973 ///////////////////////////////////////////////////////////////////////////////
974 /// @brief Forward-declare ctl_adaptivesync_getset_t
975 typedef struct _ctl_adaptivesync_getset_t ctl_adaptivesync_getset_t;
976
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;
980
981 ///////////////////////////////////////////////////////////////////////////////
982 /// @brief Forward-declare ctl_3d_app_profiles_t
983 typedef struct _ctl_3d_app_profiles_t ctl_3d_app_profiles_t;
984
985 ///////////////////////////////////////////////////////////////////////////////
986 /// @brief Forward-declare ctl_3d_tier_details_t
987 typedef struct _ctl_3d_tier_details_t ctl_3d_tier_details_t;
988
989 ///////////////////////////////////////////////////////////////////////////////
990 /// @brief Forward-declare ctl_3d_feature_details_t
991 typedef struct _ctl_3d_feature_details_t ctl_3d_feature_details_t;
992
993 ///////////////////////////////////////////////////////////////////////////////
994 /// @brief Forward-declare ctl_3d_feature_caps_t
995 typedef struct _ctl_3d_feature_caps_t ctl_3d_feature_caps_t;
996
997 ///////////////////////////////////////////////////////////////////////////////
998 /// @brief Forward-declare ctl_3d_feature_getset_t
999 typedef struct _ctl_3d_feature_getset_t ctl_3d_feature_getset_t;
1000
1001 ///////////////////////////////////////////////////////////////////////////////
1002 /// @brief Forward-declare ctl_kmd_load_features_t
1003 typedef struct _ctl_kmd_load_features_t ctl_kmd_load_features_t;
1004
1005 ///////////////////////////////////////////////////////////////////////////////
1006 /// @brief Forward-declare ctl_display_timing_t
1007 typedef struct _ctl_display_timing_t ctl_display_timing_t;
1008
1009 ///////////////////////////////////////////////////////////////////////////////
1010 /// @brief Forward-declare ctl_display_properties_t
1011 typedef struct _ctl_display_properties_t ctl_display_properties_t;
1012
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;
1016
1017 ///////////////////////////////////////////////////////////////////////////////
1018 /// @brief Forward-declare ctl_sharpness_filter_properties_t
1019 typedef struct _ctl_sharpness_filter_properties_t ctl_sharpness_filter_properties_t;
1020
1021 ///////////////////////////////////////////////////////////////////////////////
1022 /// @brief Forward-declare ctl_sharpness_caps_t
1023 typedef struct _ctl_sharpness_caps_t ctl_sharpness_caps_t;
1024
1025 ///////////////////////////////////////////////////////////////////////////////
1026 /// @brief Forward-declare ctl_sharpness_settings_t
1027 typedef struct _ctl_sharpness_settings_t ctl_sharpness_settings_t;
1028
1029 ///////////////////////////////////////////////////////////////////////////////
1030 /// @brief Forward-declare ctl_i2c_access_args_t
1031 typedef struct _ctl_i2c_access_args_t ctl_i2c_access_args_t;
1032
1033 ///////////////////////////////////////////////////////////////////////////////
1034 /// @brief Forward-declare ctl_aux_access_args_t
1035 typedef struct _ctl_aux_access_args_t ctl_aux_access_args_t;
1036
1037 ///////////////////////////////////////////////////////////////////////////////
1038 /// @brief Forward-declare ctl_power_optimization_caps_t
1039 typedef struct _ctl_power_optimization_caps_t ctl_power_optimization_caps_t;
1040
1041 ///////////////////////////////////////////////////////////////////////////////
1042 /// @brief Forward-declare ctl_power_optimization_lrr_t
1043 typedef struct _ctl_power_optimization_lrr_t ctl_power_optimization_lrr_t;
1044
1045 ///////////////////////////////////////////////////////////////////////////////
1046 /// @brief Forward-declare ctl_power_optimization_psr_t
1047 typedef struct _ctl_power_optimization_psr_t ctl_power_optimization_psr_t;
1048
1049 ///////////////////////////////////////////////////////////////////////////////
1050 /// @brief Forward-declare ctl_power_optimization_dpst_t
1051 typedef struct _ctl_power_optimization_dpst_t ctl_power_optimization_dpst_t;
1052
1053 ///////////////////////////////////////////////////////////////////////////////
1054 /// @brief Forward-declare ctl_power_optimization_settings_t
1055 typedef struct _ctl_power_optimization_settings_t ctl_power_optimization_settings_t;
1056
1057 ///////////////////////////////////////////////////////////////////////////////
1058 /// @brief Forward-declare ctl_set_brightness_t
1059 typedef struct _ctl_set_brightness_t ctl_set_brightness_t;
1060
1061 ///////////////////////////////////////////////////////////////////////////////
1062 /// @brief Forward-declare ctl_get_brightness_t
1063 typedef struct _ctl_get_brightness_t ctl_get_brightness_t;
1064
1065 ///////////////////////////////////////////////////////////////////////////////
1066 /// @brief Forward-declare ctl_pixtx_color_primaries_t
1067 typedef struct _ctl_pixtx_color_primaries_t ctl_pixtx_color_primaries_t;
1068
1069 ///////////////////////////////////////////////////////////////////////////////
1070 /// @brief Forward-declare ctl_pixtx_pixel_format_t
1071 typedef struct _ctl_pixtx_pixel_format_t ctl_pixtx_pixel_format_t;
1072
1073 ///////////////////////////////////////////////////////////////////////////////
1074 /// @brief Forward-declare ctl_pixtx_1dlut_config_t
1075 typedef struct _ctl_pixtx_1dlut_config_t ctl_pixtx_1dlut_config_t;
1076
1077 ///////////////////////////////////////////////////////////////////////////////
1078 /// @brief Forward-declare ctl_pixtx_matrix_config_t
1079 typedef struct _ctl_pixtx_matrix_config_t ctl_pixtx_matrix_config_t;
1080
1081 ///////////////////////////////////////////////////////////////////////////////
1082 /// @brief Forward-declare ctl_pixtx_3dlut_sample_t
1083 typedef struct _ctl_pixtx_3dlut_sample_t ctl_pixtx_3dlut_sample_t;
1084
1085 ///////////////////////////////////////////////////////////////////////////////
1086 /// @brief Forward-declare ctl_pixtx_3dlut_config_t
1087 typedef struct _ctl_pixtx_3dlut_config_t ctl_pixtx_3dlut_config_t;
1088
1089 ///////////////////////////////////////////////////////////////////////////////
1090 /// @brief Forward-declare ctl_pixtx_block_config_t
1091 typedef struct _ctl_pixtx_block_config_t ctl_pixtx_block_config_t;
1092
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;
1096
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;
1100
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;
1104
1105 ///////////////////////////////////////////////////////////////////////////////
1106 /// @brief Forward-declare ctl_retro_scaling_settings_t
1107 typedef struct _ctl_retro_scaling_settings_t ctl_retro_scaling_settings_t;
1108
1109 ///////////////////////////////////////////////////////////////////////////////
1110 /// @brief Forward-declare ctl_retro_scaling_caps_t
1111 typedef struct _ctl_retro_scaling_caps_t ctl_retro_scaling_caps_t;
1112
1113 ///////////////////////////////////////////////////////////////////////////////
1114 /// @brief Forward-declare ctl_scaling_caps_t
1115 typedef struct _ctl_scaling_caps_t ctl_scaling_caps_t;
1116
1117 ///////////////////////////////////////////////////////////////////////////////
1118 /// @brief Forward-declare ctl_scaling_settings_t
1119 typedef struct _ctl_scaling_settings_t ctl_scaling_settings_t;
1120
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;
1124
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;
1128
1129 ///////////////////////////////////////////////////////////////////////////////
1130 /// @brief Forward-declare ctl_lace_config_t
1131 typedef struct _ctl_lace_config_t ctl_lace_config_t;
1132
1133 ///////////////////////////////////////////////////////////////////////////////
1134 /// @brief Forward-declare ctl_sw_psr_settings_t
1135 typedef struct _ctl_sw_psr_settings_t ctl_sw_psr_settings_t;
1136
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;
1140
1141 ///////////////////////////////////////////////////////////////////////////////
1142 /// @brief Forward-declare ctl_mux_properties_t
1143 typedef struct _ctl_mux_properties_t ctl_mux_properties_t;
1144
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;
1148
1149 ///////////////////////////////////////////////////////////////////////////////
1150 /// @brief Forward-declare ctl_edid_management_args_t
1151 typedef struct _ctl_edid_management_args_t ctl_edid_management_args_t;
1152
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;
1156
1157 ///////////////////////////////////////////////////////////////////////////////
1158 /// @brief Forward-declare ctl_custom_src_mode_t
1159 typedef struct _ctl_custom_src_mode_t ctl_custom_src_mode_t;
1160
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;
1164
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;
1168
1169 ///////////////////////////////////////////////////////////////////////////////
1170 /// @brief Forward-declare ctl_combined_display_args_t
1171 typedef struct _ctl_combined_display_args_t ctl_combined_display_args_t;
1172
1173 ///////////////////////////////////////////////////////////////////////////////
1174 /// @brief Forward-declare ctl_genlock_display_info_t
1175 typedef struct _ctl_genlock_display_info_t ctl_genlock_display_info_t;
1176
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;
1180
1181 ///////////////////////////////////////////////////////////////////////////////
1182 /// @brief Forward-declare ctl_genlock_topology_t
1183 typedef struct _ctl_genlock_topology_t ctl_genlock_topology_t;
1184
1185 ///////////////////////////////////////////////////////////////////////////////
1186 /// @brief Forward-declare ctl_genlock_args_t
1187 typedef struct _ctl_genlock_args_t ctl_genlock_args_t;
1188
1189 ///////////////////////////////////////////////////////////////////////////////
1190 /// @brief Forward-declare ctl_engine_properties_t
1191 typedef struct _ctl_engine_properties_t ctl_engine_properties_t;
1192
1193 ///////////////////////////////////////////////////////////////////////////////
1194 /// @brief Forward-declare ctl_engine_stats_t
1195 typedef struct _ctl_engine_stats_t ctl_engine_stats_t;
1196
1197 ///////////////////////////////////////////////////////////////////////////////
1198 /// @brief Forward-declare ctl_fan_speed_t
1199 typedef struct _ctl_fan_speed_t ctl_fan_speed_t;
1200
1201 ///////////////////////////////////////////////////////////////////////////////
1202 /// @brief Forward-declare ctl_fan_temp_speed_t
1203 typedef struct _ctl_fan_temp_speed_t ctl_fan_temp_speed_t;
1204
1205 ///////////////////////////////////////////////////////////////////////////////
1206 /// @brief Forward-declare ctl_fan_speed_table_t
1207 typedef struct _ctl_fan_speed_table_t ctl_fan_speed_table_t;
1208
1209 ///////////////////////////////////////////////////////////////////////////////
1210 /// @brief Forward-declare ctl_fan_properties_t
1211 typedef struct _ctl_fan_properties_t ctl_fan_properties_t;
1212
1213 ///////////////////////////////////////////////////////////////////////////////
1214 /// @brief Forward-declare ctl_fan_config_t
1215 typedef struct _ctl_fan_config_t ctl_fan_config_t;
1216
1217 ///////////////////////////////////////////////////////////////////////////////
1218 /// @brief Forward-declare ctl_freq_properties_t
1219 typedef struct _ctl_freq_properties_t ctl_freq_properties_t;
1220
1221 ///////////////////////////////////////////////////////////////////////////////
1222 /// @brief Forward-declare ctl_freq_range_t
1223 typedef struct _ctl_freq_range_t ctl_freq_range_t;
1224
1225 ///////////////////////////////////////////////////////////////////////////////
1226 /// @brief Forward-declare ctl_freq_state_t
1227 typedef struct _ctl_freq_state_t ctl_freq_state_t;
1228
1229 ///////////////////////////////////////////////////////////////////////////////
1230 /// @brief Forward-declare ctl_freq_throttle_time_t
1231 typedef struct _ctl_freq_throttle_time_t ctl_freq_throttle_time_t;
1232
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;
1236
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;
1240
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;
1244
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;
1248
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;
1252
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;
1256
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;
1260
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;
1264
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;
1268
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;
1272
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;
1276
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;
1280
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;
1284
1285 ///////////////////////////////////////////////////////////////////////////////
1286 /// @brief Forward-declare ctl_mem_properties_t
1287 typedef struct _ctl_mem_properties_t ctl_mem_properties_t;
1288
1289 ///////////////////////////////////////////////////////////////////////////////
1290 /// @brief Forward-declare ctl_mem_state_t
1291 typedef struct _ctl_mem_state_t ctl_mem_state_t;
1292
1293 ///////////////////////////////////////////////////////////////////////////////
1294 /// @brief Forward-declare ctl_mem_bandwidth_t
1295 typedef struct _ctl_mem_bandwidth_t ctl_mem_bandwidth_t;
1296
1297 ///////////////////////////////////////////////////////////////////////////////
1298 /// @brief Forward-declare ctl_oc_telemetry_item_t
1299 typedef struct _ctl_oc_telemetry_item_t ctl_oc_telemetry_item_t;
1300
1301 ///////////////////////////////////////////////////////////////////////////////
1302 /// @brief Forward-declare ctl_oc_control_info_t
1303 typedef struct _ctl_oc_control_info_t ctl_oc_control_info_t;
1304
1305 ///////////////////////////////////////////////////////////////////////////////
1306 /// @brief Forward-declare ctl_oc_properties_t
1307 typedef struct _ctl_oc_properties_t ctl_oc_properties_t;
1308
1309 ///////////////////////////////////////////////////////////////////////////////
1310 /// @brief Forward-declare ctl_oc_vf_pair_t
1311 typedef struct _ctl_oc_vf_pair_t ctl_oc_vf_pair_t;
1312
1313 ///////////////////////////////////////////////////////////////////////////////
1314 /// @brief Forward-declare ctl_psu_info_t
1315 typedef struct _ctl_psu_info_t ctl_psu_info_t;
1316
1317 ///////////////////////////////////////////////////////////////////////////////
1318 /// @brief Forward-declare ctl_power_telemetry_t
1319 typedef struct _ctl_power_telemetry_t ctl_power_telemetry_t;
1320
1321 ///////////////////////////////////////////////////////////////////////////////
1322 /// @brief Forward-declare ctl_pci_address_t
1323 typedef struct _ctl_pci_address_t ctl_pci_address_t;
1324
1325 ///////////////////////////////////////////////////////////////////////////////
1326 /// @brief Forward-declare ctl_pci_speed_t
1327 typedef struct _ctl_pci_speed_t ctl_pci_speed_t;
1328
1329 ///////////////////////////////////////////////////////////////////////////////
1330 /// @brief Forward-declare ctl_pci_properties_t
1331 typedef struct _ctl_pci_properties_t ctl_pci_properties_t;
1332
1333 ///////////////////////////////////////////////////////////////////////////////
1334 /// @brief Forward-declare ctl_pci_state_t
1335 typedef struct _ctl_pci_state_t ctl_pci_state_t;
1336
1337 ///////////////////////////////////////////////////////////////////////////////
1338 /// @brief Forward-declare ctl_power_properties_t
1339 typedef struct _ctl_power_properties_t ctl_power_properties_t;
1340
1341 ///////////////////////////////////////////////////////////////////////////////
1342 /// @brief Forward-declare ctl_power_energy_counter_t
1343 typedef struct _ctl_power_energy_counter_t ctl_power_energy_counter_t;
1344
1345 ///////////////////////////////////////////////////////////////////////////////
1346 /// @brief Forward-declare ctl_power_sustained_limit_t
1347 typedef struct _ctl_power_sustained_limit_t ctl_power_sustained_limit_t;
1348
1349 ///////////////////////////////////////////////////////////////////////////////
1350 /// @brief Forward-declare ctl_power_burst_limit_t
1351 typedef struct _ctl_power_burst_limit_t ctl_power_burst_limit_t;
1352
1353 ///////////////////////////////////////////////////////////////////////////////
1354 /// @brief Forward-declare ctl_power_peak_limit_t
1355 typedef struct _ctl_power_peak_limit_t ctl_power_peak_limit_t;
1356
1357 ///////////////////////////////////////////////////////////////////////////////
1358 /// @brief Forward-declare ctl_power_limits_t
1359 typedef struct _ctl_power_limits_t ctl_power_limits_t;
1360
1361 ///////////////////////////////////////////////////////////////////////////////
1362 /// @brief Forward-declare ctl_energy_threshold_t
1363 typedef struct _ctl_energy_threshold_t ctl_energy_threshold_t;
1364
1365 ///////////////////////////////////////////////////////////////////////////////
1366 /// @brief Forward-declare ctl_temp_properties_t
1367 typedef struct _ctl_temp_properties_t ctl_temp_properties_t;
1368
1369
1370
1371 #if !defined(__GNUC__)
1372 #pragma endregion // common
1373 #endif
1374 // Intel 'ctlApi' for Device Adapter
1375 #if !defined(__GNUC__)
1376 #pragma region 3D
1377 #endif
1378 ///////////////////////////////////////////////////////////////////////////////
1379 /// @brief Feature type
1380 typedef enum _ctl_3d_feature_t
1381 {
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
1385 ///< application
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
1388 ///< power state
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
1403 CTL_3D_FEATURE_MAX
1404
1405 } ctl_3d_feature_t;
1406
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
1411 {
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
1417
1418 } ctl_3d_feature_misc_flag_t;
1419
1420 ///////////////////////////////////////////////////////////////////////////////
1421 /// @brief Anisotropic values possible
1422 typedef enum _ctl_3d_anisotropic_types_t
1423 {
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
1430
1431 } ctl_3d_anisotropic_types_t;
1432
1433 ///////////////////////////////////////////////////////////////////////////////
1434 /// @brief Texture filtering values possible
1435 typedef enum _ctl_3d_texture_filtering_quality_types_t
1436 {
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
1441
1442 } ctl_3d_texture_filtering_quality_types_t;
1443
1444 ///////////////////////////////////////////////////////////////////////////////
1445 /// @brief Frame pacing values possible
1446 typedef enum _ctl_3d_frame_pacing_types_t
1447 {
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
1453
1454 } ctl_3d_frame_pacing_types_t;
1455
1456 ///////////////////////////////////////////////////////////////////////////////
1457 /// @brief Endurance Gaming control possible
1458 typedef enum _ctl_3d_endurance_gaming_control_t
1459 {
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
1464
1465 } ctl_3d_endurance_gaming_control_t;
1466
1467 ///////////////////////////////////////////////////////////////////////////////
1468 /// @brief Endurance Gaming modes possible
1469 typedef enum _ctl_3d_endurance_gaming_mode_t
1470 {
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
1475
1476 } ctl_3d_endurance_gaming_mode_t;
1477
1478 ///////////////////////////////////////////////////////////////////////////////
1479 /// @brief Cmaa values possible
1480 typedef enum _ctl_3d_cmaa_types_t
1481 {
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
1486
1487 } ctl_3d_cmaa_types_t;
1488
1489 ///////////////////////////////////////////////////////////////////////////////
1490 /// @brief Adaptive Tessellation
1491 typedef enum _ctl_3d_adaptive_tessellation_types_t
1492 {
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
1496
1497 } ctl_3d_adaptive_tessellation_types_t;
1498
1499 ///////////////////////////////////////////////////////////////////////////////
1500 /// @brief Sharpening filter values possible
1501 typedef enum _ctl_3d_sharpening_filter_types_t
1502 {
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
1506
1507 } ctl_3d_sharpening_filter_types_t;
1508
1509 ///////////////////////////////////////////////////////////////////////////////
1510 /// @brief MSAA values possible
1511 typedef enum _ctl_3d_msaa_types_t
1512 {
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
1520
1521 } ctl_3d_msaa_types_t;
1522
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
1527 {
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
1535
1536 } ctl_gaming_flip_mode_flag_t;
1537
1538 ///////////////////////////////////////////////////////////////////////////////
1539 /// @brief Endurance Gaming caps
1540 typedef struct _ctl_endurance_gaming_caps_t
1541 {
1542 ctl_property_info_enum_t EGControlCaps; ///< [out] Endurance Gaming control capability
1543 ctl_property_info_enum_t EGModeCaps; ///< [out] Endurance Gaming mode capability
1544
1545 } ctl_endurance_gaming_caps_t;
1546
1547 ///////////////////////////////////////////////////////////////////////////////
1548 /// @brief Endurance Gaming Get/Set
1549 typedef struct _ctl_endurance_gaming_t
1550 {
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
1553 ///< Battery
1554
1555 } ctl_endurance_gaming_t;
1556
1557 ///////////////////////////////////////////////////////////////////////////////
1558 /// @brief Endurance Gaming version2 Get/Set
1559 typedef struct _ctl_endurance_gaming2_t
1560 {
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
1563 ///< Battery
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
1568
1569 } ctl_endurance_gaming2_t;
1570
1571 ///////////////////////////////////////////////////////////////////////////////
1572 /// @brief Adaptive sync plus caps
1573 typedef struct _ctl_adaptivesync_caps_t
1574 {
1575 bool AdaptiveBalanceSupported; ///< [out] Adaptive balance supported
1576 ctl_property_info_float_t AdaptiveBalanceStrengthCaps; ///< [out] Strength of adaptive balance algorithm - min/max/steps/default
1577
1578 } ctl_adaptivesync_caps_t;
1579
1580 ///////////////////////////////////////////////////////////////////////////////
1581 /// @brief Adaptive sync plus
1582 typedef struct _ctl_adaptivesync_getset_t
1583 {
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
1588 ///< the panel
1589 float AdaptiveBalanceStrength; ///< [in,out] Adaptive balance strength
1590
1591 } ctl_adaptivesync_getset_t;
1592
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
1597 {
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
1601
1602 } ctl_3d_tier_type_flag_t;
1603
1604 ///////////////////////////////////////////////////////////////////////////////
1605 /// @brief Game tiers
1606 typedef uint32_t ctl_3d_tier_profile_flags_t;
1607 typedef enum _ctl_3d_tier_profile_flag_t
1608 {
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
1613
1614 } ctl_3d_tier_profile_flag_t;
1615
1616 ///////////////////////////////////////////////////////////////////////////////
1617 /// @brief Game Profile Capabilities. Typically these remain the same across
1618 /// games.
1619 typedef struct _ctl_3d_app_profiles_caps_t
1620 {
1621 ctl_3d_tier_type_flags_t SupportedTierTypes; ///< [out] Tier of interest for capability check
1622 uint64_t Reserved; ///< [in,out] Reserved for future
1623
1624 } ctl_3d_app_profiles_caps_t;
1625
1626 ///////////////////////////////////////////////////////////////////////////////
1627 /// @brief Game Profile tiers
1628 typedef struct _ctl_3d_app_profiles_t
1629 {
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
1640
1641 } ctl_3d_app_profiles_t;
1642
1643 ///////////////////////////////////////////////////////////////////////////////
1644 /// @brief Game Profile tiers details
1645 typedef struct _ctl_3d_tier_details_t
1646 {
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
1650
1651 } ctl_3d_tier_details_t;
1652
1653 ///////////////////////////////////////////////////////////////////////////////
1654 /// @brief Emulated Typed 64bit Atomics
1655 typedef enum _ctl_emulated_typed_64bit_atomics_types_t
1656 {
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
1661
1662 } ctl_emulated_typed_64bit_atomics_types_t;
1663
1664 ///////////////////////////////////////////////////////////////////////////////
1665 /// @brief 3D feature capability details which will have range/supported and
1666 /// default values
1667 typedef struct _ctl_3d_feature_details_t
1668 {
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
1676 ///< info here
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
1681 ///< or not
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
1690
1691 } ctl_3d_feature_details_t;
1692
1693 ///////////////////////////////////////////////////////////////////////////////
1694 /// @brief 3D feature which are controllable
1695 typedef struct _ctl_3d_feature_caps_t
1696 {
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
1701
1702 } ctl_3d_feature_caps_t;
1703
1704 ///////////////////////////////////////////////////////////////////////////////
1705 /// @brief 3D feature for get/set
1706 typedef struct _ctl_3d_feature_getset_t
1707 {
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
1724 ///< info here
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
1728
1729 } ctl_3d_feature_getset_t;
1730
1731 ///////////////////////////////////////////////////////////////////////////////
1732 /// @brief Load KMD gaming features. Restricted function
1733 typedef struct _ctl_kmd_load_features_t
1734 {
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
1745
1746 } ctl_kmd_load_features_t;
1747
1748 ///////////////////////////////////////////////////////////////////////////////
1749 /// @brief Get 3D capabilities
1750 ///
1751 /// @details
1752 /// - The application gets 3D properties
1753 ///
1754 /// @returns
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
1767 );
1768
1769 ///////////////////////////////////////////////////////////////////////////////
1770 /// @brief Get/Set 3D feature
1771 ///
1772 /// @details
1773 /// - 3D feature details
1774 ///
1775 /// @returns
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
1785 ctlGetSet3DFeature(
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
1788 );
1789
1790
1791 #if !defined(__GNUC__)
1792 #pragma endregion // 3D
1793 #endif
1794 // Intel 'ctlApi' for Device Adapter
1795 #if !defined(__GNUC__)
1796 #pragma region display
1797 #endif
1798 ///////////////////////////////////////////////////////////////////////////////
1799 /// @brief Handle of a display output instance
1800 typedef struct _ctl_display_output_handle_t *ctl_display_output_handle_t;
1801
1802 ///////////////////////////////////////////////////////////////////////////////
1803 /// @brief Check Driver version
1804 ///
1805 /// @details
1806 /// - The application checks driver version
1807 ///
1808 /// @returns
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
1819 );
1820
1821 ///////////////////////////////////////////////////////////////////////////////
1822 /// @brief Enumerate devices
1823 ///
1824 /// @details
1825 /// - The application enumerates all device adapters in the system
1826 ///
1827 /// @returns
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
1848 );
1849
1850 ///////////////////////////////////////////////////////////////////////////////
1851 /// @brief Enumerate display outputs
1852 ///
1853 /// @details
1854 /// - Enumerates display output capabilities
1855 ///
1856 /// @returns
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
1876 );
1877
1878 ///////////////////////////////////////////////////////////////////////////////
1879 /// @brief OS specific Display identifiers
1880 typedef union _ctl_os_display_encoder_identifier_t
1881 {
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
1884
1885 } ctl_os_display_encoder_identifier_t;
1886
1887 ///////////////////////////////////////////////////////////////////////////////
1888 /// @brief Various display types
1889 typedef enum _ctl_display_output_types_t
1890 {
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
1898
1899 } ctl_display_output_types_t;
1900
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
1905 {
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
1911
1912 } ctl_output_bpc_flag_t;
1913
1914 ///////////////////////////////////////////////////////////////////////////////
1915 /// @brief Display output features. This will indicate only the high level
1916 /// capabilities
1917 typedef uint32_t ctl_std_display_feature_flags_t;
1918 typedef enum _ctl_std_display_feature_flag_t
1919 {
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
1928
1929 } ctl_std_display_feature_flag_t;
1930
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
1936 {
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
1941
1942 } ctl_intel_display_feature_flag_t;
1943
1944 ///////////////////////////////////////////////////////////////////////////////
1945 /// @brief Attached Display Mux Type
1946 typedef enum _ctl_attached_display_mux_type_t
1947 {
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
1953
1954 } ctl_attached_display_mux_type_t;
1955
1956 ///////////////////////////////////////////////////////////////////////////////
1957 /// @brief Signal Standard
1958 typedef enum _ctl_signal_standard_type_t
1959 {
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
1967
1968 } ctl_signal_standard_type_t;
1969
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
1974 {
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
1978
1979 } ctl_protocol_converter_location_flag_t;
1980
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
1986 {
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
1994
1995 } ctl_display_config_flag_t;
1996
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
2002 {
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
2020
2021 } ctl_encoder_config_flag_t;
2022
2023 ///////////////////////////////////////////////////////////////////////////////
2024 /// @brief Display Timing
2025 typedef struct _ctl_display_timing_t
2026 {
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
2041
2042 } ctl_display_timing_t;
2043
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
2048 {
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
2077
2078 } ctl_display_properties_t;
2079
2080 ///////////////////////////////////////////////////////////////////////////////
2081 /// @brief Adapter's display encoder properties
2082 typedef struct _ctl_adapter_display_encoder_properties_t
2083 {
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
2101 ///< Note:
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
2119
2120 } ctl_adapter_display_encoder_properties_t;
2121
2122 ///////////////////////////////////////////////////////////////////////////////
2123 /// @brief Get Device Properties
2124 ///
2125 /// @details
2126 /// - The application gets device properties
2127 ///
2128 /// @returns
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
2141 );
2142
2143 ///////////////////////////////////////////////////////////////////////////////
2144 /// @brief Get Display Properties
2145 ///
2146 /// @details
2147 /// - The application gets display properties
2148 ///
2149 /// @returns
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
2162 );
2163
2164 ///////////////////////////////////////////////////////////////////////////////
2165 /// @brief Get Adapter Display encoder Properties
2166 ///
2167 /// @details
2168 /// - The application gets the graphic adapters display encoder properties
2169 ///
2170 /// @returns
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
2183 );
2184
2185 ///////////////////////////////////////////////////////////////////////////////
2186 /// @brief Get Level0 Device handle
2187 ///
2188 /// @details
2189 /// - The application gets OneAPI Level0 Device handles
2190 ///
2191 /// @returns
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
2202 ctlGetZeDevice(
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
2207 );
2208
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
2213 {
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
2217
2218 } ctl_sharpness_filter_type_flag_t;
2219
2220 ///////////////////////////////////////////////////////////////////////////////
2221 /// @brief Sharpness filter properties
2222 typedef struct _ctl_sharpness_filter_properties_t
2223 {
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
2226
2227 } ctl_sharpness_filter_properties_t;
2228
2229 ///////////////////////////////////////////////////////////////////////////////
2230 /// @brief Various sharpness filter types
2231 typedef struct _ctl_sharpness_caps_t
2232 {
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
2240 ///< this.
2241
2242 } ctl_sharpness_caps_t;
2243
2244 ///////////////////////////////////////////////////////////////////////////////
2245 /// @brief Current sharpness setting
2246 typedef struct _ctl_sharpness_settings_t
2247 {
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
2254
2255 } ctl_sharpness_settings_t;
2256
2257 ///////////////////////////////////////////////////////////////////////////////
2258 /// @brief Get Sharpness capability
2259 ///
2260 /// @details
2261 /// - Returns sharpness capability
2262 ///
2263 /// @returns
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
2276 );
2277
2278 ///////////////////////////////////////////////////////////////////////////////
2279 /// @brief Get Sharpness setting
2280 ///
2281 /// @details
2282 /// - Returns current sharpness settings
2283 ///
2284 /// @returns
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
2297 );
2298
2299 ///////////////////////////////////////////////////////////////////////////////
2300 /// @brief Set Sharpness setting
2301 ///
2302 /// @details
2303 /// - Set current sharpness settings
2304 ///
2305 /// @returns
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
2318 );
2319
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
2325
2326 ///////////////////////////////////////////////////////////////////////////////
2327 /// @brief I2CFlags bitmasks
2328 typedef uint32_t ctl_i2c_flags_t;
2329 typedef enum _ctl_i2c_flag_t
2330 {
2331 CTL_I2C_FLAG_ATOMICI2C = CTL_BIT(0), ///< Force Atomic I2C
2332 CTL_I2C_FLAG_MAX = 0x80000000
2333
2334 } ctl_i2c_flag_t;
2335
2336 ///////////////////////////////////////////////////////////////////////////////
2337 /// @brief I2C access arguments
2338 typedef struct _ctl_i2c_access_args_t
2339 {
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
2351
2352 } ctl_i2c_access_args_t;
2353
2354 ///////////////////////////////////////////////////////////////////////////////
2355 /// @brief I2C Access
2356 ///
2357 /// @details
2358 /// - The application does I2C aceess
2359 ///
2360 /// @returns
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
2378 ctlI2CAccess(
2379 ctl_display_output_handle_t hDisplayOutput, ///< [in] Handle to display output
2380 ctl_i2c_access_args_t* pI2cAccessArgs ///< [in,out] I2c access arguments
2381 );
2382
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
2388
2389 ///////////////////////////////////////////////////////////////////////////////
2390 /// @brief AUX Flags bitmasks
2391 typedef uint32_t ctl_aux_flags_t;
2392 typedef enum _ctl_aux_flag_t
2393 {
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
2398
2399 } ctl_aux_flag_t;
2400
2401 ///////////////////////////////////////////////////////////////////////////////
2402 /// @brief AUX access arguments
2403 typedef struct _ctl_aux_access_args_t
2404 {
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
2416
2417 } ctl_aux_access_args_t;
2418
2419 ///////////////////////////////////////////////////////////////////////////////
2420 /// @brief Aux Access
2421 ///
2422 /// @details
2423 /// - The application does Aux aceess, PSR needs to be disabled for AUX
2424 /// call.
2425 ///
2426 /// @returns
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
2445 ctlAUXAccess(
2446 ctl_display_output_handle_t hDisplayOutput, ///< [in] Handle to display output
2447 ctl_aux_access_args_t* pAuxAccessArgs ///< [in,out] Aux access arguments
2448 );
2449
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
2455 {
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
2463
2464 } ctl_power_optimization_flag_t;
2465
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
2470 {
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
2477
2478 } ctl_power_optimization_dpst_flag_t;
2479
2480 ///////////////////////////////////////////////////////////////////////////////
2481 /// @brief Power Source
2482 typedef enum _ctl_power_source_t
2483 {
2484 CTL_POWER_SOURCE_AC = 0, ///< Power Source AC
2485 CTL_POWER_SOURCE_DC = 1, ///< Power Source DC
2486 CTL_POWER_SOURCE_MAX
2487
2488 } ctl_power_source_t;
2489
2490 ///////////////////////////////////////////////////////////////////////////////
2491 /// @brief Power Optimization Plan
2492 typedef enum _ctl_power_optimization_plan_t
2493 {
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
2498
2499 } ctl_power_optimization_plan_t;
2500
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
2505 {
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
2513
2514 } ctl_power_optimization_lrr_flag_t;
2515
2516 ///////////////////////////////////////////////////////////////////////////////
2517 /// @brief Power optimization caps
2518 typedef struct _ctl_power_optimization_caps_t
2519 {
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
2524
2525 } ctl_power_optimization_caps_t;
2526
2527 ///////////////////////////////////////////////////////////////////////////////
2528 /// @brief Get Power optimization features
2529 ///
2530 /// @details
2531 /// - Returns power optimization capabilities
2532 ///
2533 /// @returns
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
2546 );
2547
2548 ///////////////////////////////////////////////////////////////////////////////
2549 /// @brief LRR detailed settings
2550 typedef struct _ctl_power_optimization_lrr_t
2551 {
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
2562
2563 } ctl_power_optimization_lrr_t;
2564
2565 ///////////////////////////////////////////////////////////////////////////////
2566 /// @brief PSR detailed settings
2567 typedef struct _ctl_power_optimization_psr_t
2568 {
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
2573
2574 } ctl_power_optimization_psr_t;
2575
2576 ///////////////////////////////////////////////////////////////////////////////
2577 /// @brief DPST detailed settings
2578 typedef struct _ctl_power_optimization_dpst_t
2579 {
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
2587
2588 } ctl_power_optimization_dpst_t;
2589
2590 ///////////////////////////////////////////////////////////////////////////////
2591 /// @brief Feature specific power optimization data
2592 typedef union _ctl_power_optimization_feature_specific_info_t
2593 {
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
2597
2598 } ctl_power_optimization_feature_specific_info_t;
2599
2600 ///////////////////////////////////////////////////////////////////////////////
2601 /// @brief Power optimization settings
2602 typedef struct _ctl_power_optimization_settings_t
2603 {
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
2612
2613 } ctl_power_optimization_settings_t;
2614
2615 ///////////////////////////////////////////////////////////////////////////////
2616 /// @brief Brightness settings for SET call
2617 typedef struct _ctl_set_brightness_t
2618 {
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
2625 ///< is 1000ms.
2626 uint32_t ReservedFields[4]; ///< [in] Reserved for future use
2627
2628 } ctl_set_brightness_t;
2629
2630 ///////////////////////////////////////////////////////////////////////////////
2631 /// @brief Brightness settings for GET call
2632 typedef struct _ctl_get_brightness_t
2633 {
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
2641
2642 } ctl_get_brightness_t;
2643
2644 ///////////////////////////////////////////////////////////////////////////////
2645 /// @brief Get Power optimization setting
2646 ///
2647 /// @details
2648 /// - Returns power optimization setting for a specific feature
2649 ///
2650 /// @returns
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
2665 );
2666
2667 ///////////////////////////////////////////////////////////////////////////////
2668 /// @brief Set Power optimization setting
2669 ///
2670 /// @details
2671 /// - Set power optimization setting for a specific feature
2672 ///
2673 /// @returns
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
2688 );
2689
2690 ///////////////////////////////////////////////////////////////////////////////
2691 /// @brief Set Brightness on companion display
2692 ///
2693 /// @details
2694 /// - Set Brightness for a target display. Currently support is only for
2695 /// companion display.
2696 ///
2697 /// @returns
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
2713 );
2714
2715 ///////////////////////////////////////////////////////////////////////////////
2716 /// @brief Get Brightness setting
2717 ///
2718 /// @details
2719 /// - Get Brightness for a target display. Currently support is only for
2720 /// companion display.
2721 ///
2722 /// @returns
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
2737 );
2738
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
2744
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
2749 {
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
2752
2753 } ctl_pixtx_pipe_set_config_flag_t;
2754
2755 ///////////////////////////////////////////////////////////////////////////////
2756 /// @brief Pixel transformation block types
2757 typedef enum _ctl_pixtx_block_type_t
2758 {
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
2764
2765 } ctl_pixtx_block_type_t;
2766
2767 ///////////////////////////////////////////////////////////////////////////////
2768 /// @brief Pixel transformation LUT sampling types
2769 typedef enum _ctl_pixtx_lut_sampling_type_t
2770 {
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
2774
2775 } ctl_pixtx_lut_sampling_type_t;
2776
2777 ///////////////////////////////////////////////////////////////////////////////
2778 /// @brief Configuration query types
2779 typedef enum _ctl_pixtx_config_query_type_t
2780 {
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
2784
2785 } ctl_pixtx_config_query_type_t;
2786
2787 ///////////////////////////////////////////////////////////////////////////////
2788 /// @brief Configuration operation types
2789 typedef enum _ctl_pixtx_config_opertaion_type_t
2790 {
2791 CTL_PIXTX_CONFIG_OPERTAION_TYPE_RESTORE_DEFAULT = 1,///< Restore block by block or entire pipe line. Use NumBlocks = 0 to
2792 ///< restore all.
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
2795
2796 } ctl_pixtx_config_opertaion_type_t;
2797
2798 ///////////////////////////////////////////////////////////////////////////////
2799 /// @brief Pixel transformation gamma encoding types
2800 typedef enum _ctl_pixtx_gamma_encoding_type_t
2801 {
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
2808
2809 } ctl_pixtx_gamma_encoding_type_t;
2810
2811 ///////////////////////////////////////////////////////////////////////////////
2812 /// @brief Pixel transformation color space types
2813 typedef enum _ctl_pixtx_color_space_t
2814 {
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
2824
2825 } ctl_pixtx_color_space_t;
2826
2827 ///////////////////////////////////////////////////////////////////////////////
2828 /// @brief Pixel transformation color model types
2829 typedef enum _ctl_pixtx_color_model_t
2830 {
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
2838
2839 } ctl_pixtx_color_model_t;
2840
2841 ///////////////////////////////////////////////////////////////////////////////
2842 /// @brief Pixel transformation color primaries
2843 typedef struct _ctl_pixtx_color_primaries_t
2844 {
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
2855
2856 } ctl_pixtx_color_primaries_t;
2857
2858 ///////////////////////////////////////////////////////////////////////////////
2859 /// @brief Pixel transformation pixel format
2860 typedef struct _ctl_pixtx_pixel_format_t
2861 {
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
2874
2875 } ctl_pixtx_pixel_format_t;
2876
2877 ///////////////////////////////////////////////////////////////////////////////
2878 /// @brief Pixel transformation 1D LUT configuration
2879 typedef struct _ctl_pixtx_1dlut_config_t
2880 {
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
2889 ///< LUTs.
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
2896
2897 } ctl_pixtx_1dlut_config_t;
2898
2899 ///////////////////////////////////////////////////////////////////////////////
2900 /// @brief Pixel transformation matrix configuration
2901 typedef struct _ctl_pixtx_matrix_config_t
2902 {
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
2908
2909 } ctl_pixtx_matrix_config_t;
2910
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
2916 {
2917 double Red; ///< [in,out] Red output value
2918 double Green; ///< [in,out] Green output value
2919 double Blue; ///< [in,out] Blue output value
2920
2921 } ctl_pixtx_3dlut_sample_t;
2922
2923 ///////////////////////////////////////////////////////////////////////////////
2924 /// @brief Pixel transformation 3D LUT configuration
2925 typedef struct _ctl_pixtx_3dlut_config_t
2926 {
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
2931 ///< and B
2932
2933 } ctl_pixtx_3dlut_config_t;
2934
2935 ///////////////////////////////////////////////////////////////////////////////
2936 /// @brief Pixel transformation configuration
2937 typedef union _ctl_pixtx_config_t
2938 {
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
2942
2943 } ctl_pixtx_config_t;
2944
2945 ///////////////////////////////////////////////////////////////////////////////
2946 /// @brief Pixel transformation block configuration
2947 typedef struct _ctl_pixtx_block_config_t
2948 {
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
2955
2956 } ctl_pixtx_block_config_t;
2957
2958 ///////////////////////////////////////////////////////////////////////////////
2959 /// @brief Pixel transformation pipe get configuration
2960 typedef struct _ctl_pixtx_pipe_get_config_t
2961 {
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
2969
2970 } ctl_pixtx_pipe_get_config_t;
2971
2972 ///////////////////////////////////////////////////////////////////////////////
2973 /// @brief Pixel transformation pipe set configuration
2974 typedef struct _ctl_pixtx_pipe_set_config_t
2975 {
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
2982
2983 } ctl_pixtx_pipe_set_config_t;
2984
2985 ///////////////////////////////////////////////////////////////////////////////
2986 /// @brief Pixel transformation get pipe configuration
2987 ///
2988 /// @details
2989 /// - The application does pixel transformation get pipe configuration
2990 ///
2991 /// @returns
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
3018 );
3019
3020 ///////////////////////////////////////////////////////////////////////////////
3021 /// @brief Pixel transformation set pipe configuration
3022 ///
3023 /// @details
3024 /// - The application does pixel transformation set pipe configuration
3025 ///
3026 /// @returns
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
3054 );
3055
3056 ///////////////////////////////////////////////////////////////////////////////
3057 /// @brief Panel descriptor access arguments
3058 typedef struct _ctl_panel_descriptor_access_args_t
3059 {
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
3064 ///< supported
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
3069
3070 } ctl_panel_descriptor_access_args_t;
3071
3072 ///////////////////////////////////////////////////////////////////////////////
3073 /// @brief Panel Descriptor Access
3074 ///
3075 /// @details
3076 /// - The application does EDID or Display ID access
3077 ///
3078 /// @returns
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
3098 );
3099
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
3104 {
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
3108
3109 } ctl_retro_scaling_type_flag_t;
3110
3111 ///////////////////////////////////////////////////////////////////////////////
3112 /// @brief Set/Get Retro Scaling Type
3113 typedef struct _ctl_retro_scaling_settings_t
3114 {
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
3118 ///< the scaling
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
3122
3123 } ctl_retro_scaling_settings_t;
3124
3125 ///////////////////////////////////////////////////////////////////////////////
3126 /// @brief Retro Scaling caps
3127 typedef struct _ctl_retro_scaling_caps_t
3128 {
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
3132
3133 } ctl_retro_scaling_caps_t;
3134
3135 ///////////////////////////////////////////////////////////////////////////////
3136 /// @brief Get Supported Retro Scaling Types
3137 ///
3138 /// @details
3139 /// - Returns supported retro scaling capabilities
3140 ///
3141 /// @returns
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
3154 );
3155
3156 ///////////////////////////////////////////////////////////////////////////////
3157 /// @brief Get/Set Retro Scaling
3158 ///
3159 /// @details
3160 /// - Get or Set the status of retro scaling.This Api will do a physical
3161 /// modeset resulting in flash on the screen
3162 ///
3163 /// @returns
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
3176 );
3177
3178 ///////////////////////////////////////////////////////////////////////////////
3179 /// @brief Scaling Types
3180 typedef uint32_t ctl_scaling_type_flags_t;
3181 typedef enum _ctl_scaling_type_flag_t
3182 {
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
3190
3191 } ctl_scaling_type_flag_t;
3192
3193 ///////////////////////////////////////////////////////////////////////////////
3194 /// @brief Scaling caps
3195 typedef struct _ctl_scaling_caps_t
3196 {
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
3200
3201 } ctl_scaling_caps_t;
3202
3203 ///////////////////////////////////////////////////////////////////////////////
3204 /// @brief Set/Get Scaling type
3205 typedef struct _ctl_scaling_settings_t
3206 {
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
3218
3219 } ctl_scaling_settings_t;
3220
3221 ///////////////////////////////////////////////////////////////////////////////
3222 /// @brief Get Supported Scaling Types
3223 ///
3224 /// @details
3225 /// - Returns supported scaling capabilities
3226 ///
3227 /// @returns
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
3240 );
3241
3242 ///////////////////////////////////////////////////////////////////////////////
3243 /// @brief Get Current Scaling
3244 ///
3245 /// @details
3246 /// - Returns current active scaling
3247 ///
3248 /// @returns
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
3261 );
3262
3263 ///////////////////////////////////////////////////////////////////////////////
3264 /// @brief Set Scaling Type
3265 ///
3266 /// @details
3267 /// - Returns current active scaling
3268 ///
3269 /// @returns
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
3282 );
3283
3284 ///////////////////////////////////////////////////////////////////////////////
3285 /// @brief Ambient light based enhancement table entry
3286 typedef struct _ctl_lace_lux_aggr_map_entry_t
3287 {
3288 uint32_t Lux; ///< [in,out] Ambient lux
3289 uint8_t AggressivenessPercent; ///< [in,out] Pixel boost agressiveness
3290
3291 } ctl_lace_lux_aggr_map_entry_t;
3292
3293 ///////////////////////////////////////////////////////////////////////////////
3294 /// @brief Ambient light based enhancement table
3295 typedef struct _ctl_lace_lux_aggr_map_t
3296 {
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
3301
3302 } ctl_lace_lux_aggr_map_t;
3303
3304 ///////////////////////////////////////////////////////////////////////////////
3305 /// @brief Data specific to the mode caller is interested in
3306 typedef union _ctl_lace_aggr_config_t
3307 {
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
3312
3313 } ctl_lace_aggr_config_t;
3314
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
3319 {
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
3324
3325 } ctl_get_operation_flag_t;
3326
3327 ///////////////////////////////////////////////////////////////////////////////
3328 /// @brief Set Operations used for additional settings
3329 typedef enum _ctl_set_operation_t
3330 {
3331 CTL_SET_OPERATION_RESTORE_DEFAULT = 0, ///< Restore default values
3332 CTL_SET_OPERATION_CUSTOM = 1, ///< Set custom values
3333 CTL_SET_OPERATION_MAX
3334
3335 } ctl_set_operation_t;
3336
3337 ///////////////////////////////////////////////////////////////////////////////
3338 /// @brief Lace Trigger Modes
3339 typedef uint32_t ctl_lace_trigger_flags_t;
3340 typedef enum _ctl_lace_trigger_flag_t
3341 {
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
3345
3346 } ctl_lace_trigger_flag_t;
3347
3348 ///////////////////////////////////////////////////////////////////////////////
3349 /// @brief Set/Get LACE Config
3350 typedef struct _ctl_lace_config_t
3351 {
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
3359
3360 } ctl_lace_config_t;
3361
3362 ///////////////////////////////////////////////////////////////////////////////
3363 /// @brief Get LACE Config
3364 ///
3365 /// @details
3366 /// - Returns current LACE Config
3367 ///
3368 /// @returns
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
3379 ctlGetLACEConfig(
3380 ctl_display_output_handle_t hDisplayOutput, ///< [in] Handle to display output
3381 ctl_lace_config_t* pLaceConfig ///< [out]Lace configuration
3382 );
3383
3384 ///////////////////////////////////////////////////////////////////////////////
3385 /// @brief Sets LACE Config
3386 ///
3387 /// @details
3388 /// - Sets LACE Config
3389 ///
3390 /// @returns
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
3401 ctlSetLACEConfig(
3402 ctl_display_output_handle_t hDisplayOutput, ///< [in]Handle to display output
3403 ctl_lace_config_t* pLaceConfig ///< [in]Lace configuration
3404 );
3405
3406 ///////////////////////////////////////////////////////////////////////////////
3407 /// @brief Get Software PSR status/Set Software PSR settings
3408 typedef struct _ctl_sw_psr_settings_t
3409 {
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
3417
3418 } ctl_sw_psr_settings_t;
3419
3420 ///////////////////////////////////////////////////////////////////////////////
3421 /// @brief Get Software PSR caps/Set software PSR State
3422 ///
3423 /// @details
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
3427 /// for activation.
3428 ///
3429 /// @returns
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
3439 ctlSoftwarePSR(
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
3442 ///< state
3443 );
3444
3445 ///////////////////////////////////////////////////////////////////////////////
3446 /// @brief Intel Arc Sync Monitor Params
3447 typedef struct _ctl_intel_arc_sync_monitor_params_t
3448 {
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
3455 ///< Sync block
3456 uint32_t MaxFrameTimeDecreaseInUs; ///< [out] Max frame time decrease in micro seconds from DID2.1 Adaptive
3457 ///< Sync block
3458
3459 } ctl_intel_arc_sync_monitor_params_t;
3460
3461 ///////////////////////////////////////////////////////////////////////////////
3462 /// @brief Get Intel Arc Sync information for monitor
3463 ///
3464 /// @details
3465 /// - Returns Intel Arc Sync information for selected monitor
3466 ///
3467 /// @returns
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
3480 );
3481
3482 ///////////////////////////////////////////////////////////////////////////////
3483 /// @brief Handle of a MUX output instance
3484 typedef struct _ctl_mux_output_handle_t *ctl_mux_output_handle_t;
3485
3486 ///////////////////////////////////////////////////////////////////////////////
3487 /// @brief Enumerate Display MUX Devices on this system across adapters
3488 ///
3489 /// @details
3490 /// - The application enumerates all MUX devices in the system
3491 ///
3492 /// @returns
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
3513 );
3514
3515 ///////////////////////////////////////////////////////////////////////////////
3516 /// @brief Display MUX device properties
3517 typedef struct _ctl_mux_properties_t
3518 {
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
3524 ///< with the total
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
3535
3536 } ctl_mux_properties_t;
3537
3538 ///////////////////////////////////////////////////////////////////////////////
3539 /// @brief Get Display Mux properties
3540 ///
3541 /// @details
3542 /// - Get the propeties of the Mux device
3543 ///
3544 /// @returns
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
3557 );
3558
3559 ///////////////////////////////////////////////////////////////////////////////
3560 /// @brief Switch Mux output
3561 ///
3562 /// @details
3563 /// - Switches the MUX output
3564 ///
3565 /// @returns
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
3574 ctlSwitchMux(
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.
3579 );
3580
3581 ///////////////////////////////////////////////////////////////////////////////
3582 /// @brief Intel Arc Sync profile
3583 typedef enum _ctl_intel_arc_sync_profile_t
3584 {
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
3596 ///< refresh rate
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
3601
3602 } ctl_intel_arc_sync_profile_t;
3603
3604 ///////////////////////////////////////////////////////////////////////////////
3605 /// @brief Intel Arc Sync Profile Params
3606 typedef struct _ctl_intel_arc_sync_profile_params_t
3607 {
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
3615 ///< driver
3616 uint32_t MaxFrameTimeDecreaseInUs; ///< [in,out] Maximum frame time decrease (in micro seconds) imposed by the
3617 ///< driver
3618
3619 } ctl_intel_arc_sync_profile_params_t;
3620
3621 ///////////////////////////////////////////////////////////////////////////////
3622 /// @brief Get Intel Arc Sync profile
3623 ///
3624 /// @details
3625 /// - Returns Intel Arc Sync profile for selected monitor
3626 ///
3627 /// @returns
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
3640 );
3641
3642 ///////////////////////////////////////////////////////////////////////////////
3643 /// @brief Set Intel Arc Sync profile
3644 ///
3645 /// @details
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.
3649 ///
3650 /// @returns
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
3663 );
3664
3665 ///////////////////////////////////////////////////////////////////////////////
3666 /// @brief EDID Management operation type
3667 typedef enum _ctl_edid_management_optype_t
3668 {
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
3690 ///< override.
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
3693 ///< connected
3694 CTL_EDID_MANAGEMENT_OPTYPE_MAX
3695
3696 } ctl_edid_management_optype_t;
3697
3698 ///////////////////////////////////////////////////////////////////////////////
3699 /// @brief EDID type. Used in LOCK_EDID and READ_EDID calls.
3700 typedef enum _ctl_edid_type_t
3701 {
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.
3706 CTL_EDID_TYPE_MAX
3707
3708 } ctl_edid_type_t;
3709
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
3714 {
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
3721
3722 } ctl_edid_management_out_flag_t;
3723
3724 ///////////////////////////////////////////////////////////////////////////////
3725 /// @brief EDID management
3726 typedef struct _ctl_edid_management_args_t
3727 {
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
3737 ///< operations
3738
3739 } ctl_edid_management_args_t;
3740
3741 ///////////////////////////////////////////////////////////////////////////////
3742 /// @brief EDID Management allows managing an output's EDID or Plugged Status.
3743 ///
3744 /// @details
3745 /// - To manage output's EDID or Display ID. Supports native DP SST and HDMI
3746 /// Display types.
3747 ///
3748 /// @returns
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
3768 ctlEdidManagement(
3769 ctl_display_output_handle_t hDisplayOutput, ///< [in] Handle to display output
3770 ctl_edid_management_args_t* pEdidManagementArgs ///< [in,out] EDID management arguments
3771 );
3772
3773 ///////////////////////////////////////////////////////////////////////////////
3774 /// @brief Custom mode operation types
3775 typedef enum _ctl_custom_mode_operation_types_t
3776 {
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
3782
3783 } ctl_custom_mode_operation_types_t;
3784
3785 ///////////////////////////////////////////////////////////////////////////////
3786 /// @brief Get/Set Custom Mode
3787 typedef struct _ctl_get_set_custom_mode_args_t
3788 {
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.
3795
3796 } ctl_get_set_custom_mode_args_t;
3797
3798 ///////////////////////////////////////////////////////////////////////////////
3799 /// @brief Get/Set Custom Mode
3800 typedef struct _ctl_custom_src_mode_t
3801 {
3802 uint32_t SourceX; ///< [in,out] CustomMode Source X Size
3803 uint32_t SourceY; ///< [in,out] CustomMode Source Y Size
3804
3805 } ctl_custom_src_mode_t;
3806
3807 ///////////////////////////////////////////////////////////////////////////////
3808 /// @brief Get/Set Custom mode.
3809 ///
3810 /// @details
3811 /// - To get or set custom mode.
3812 /// - Add custom source mode operation supports only single mode additon at
3813 /// a time.
3814 /// - Remove custom source mode operation supports single or multiple mode
3815 /// removal at a time.
3816 ///
3817 /// @returns
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
3840 );
3841
3842 ///////////////////////////////////////////////////////////////////////////////
3843 /// @brief Combined Display operation type
3844 typedef enum _ctl_combined_display_optype_t
3845 {
3846 CTL_COMBINED_DISPLAY_OPTYPE_IS_SUPPORTED_CONFIG = 1,///< To check whether given outputs can form a combined display, no changes
3847 ///< are applied
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
3852
3853 } ctl_combined_display_optype_t;
3854
3855 ///////////////////////////////////////////////////////////////////////////////
3856 /// @brief Combined Display's child display target mode
3857 typedef struct _ctl_child_display_target_mode_t
3858 {
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
3863
3864 } ctl_child_display_target_mode_t;
3865
3866 ///////////////////////////////////////////////////////////////////////////////
3867 /// @brief Combined Display's child display information
3868 typedef struct _ctl_combined_display_child_info_t
3869 {
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)
3875
3876 } ctl_combined_display_child_info_t;
3877
3878 ///////////////////////////////////////////////////////////////////////////////
3879 /// @brief Combined Display arguments
3880 typedef struct _ctl_combined_display_args_t
3881 {
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
3887 ///< configuration
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
3892
3893 } ctl_combined_display_args_t;
3894
3895 ///////////////////////////////////////////////////////////////////////////////
3896 /// @brief Get/Set Combined Display
3897 ///
3898 /// @details
3899 /// - To get or set combined display.
3900 ///
3901 /// @returns
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
3922 );
3923
3924 ///////////////////////////////////////////////////////////////////////////////
3925 /// @brief Display Genlock Operations
3926 typedef enum _ctl_genlock_operation_t
3927 {
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
3934
3935 } ctl_genlock_operation_t;
3936
3937 ///////////////////////////////////////////////////////////////////////////////
3938 /// @brief Display Genlock Info
3939 typedef struct _ctl_genlock_display_info_t
3940 {
3941 ctl_display_output_handle_t hDisplayOutput; ///< [in,out] Display output handle under Genlock topology
3942 bool IsPrimary; ///< [in,out] Genlock Primary
3943
3944 } ctl_genlock_display_info_t;
3945
3946 ///////////////////////////////////////////////////////////////////////////////
3947 /// @brief Genlock Target Mode List
3948 typedef struct _ctl_genlock_target_mode_list_t
3949 {
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
3953
3954 } ctl_genlock_target_mode_list_t;
3955
3956 ///////////////////////////////////////////////////////////////////////////////
3957 /// @brief Genlock Topology
3958 typedef struct _ctl_genlock_topology_t
3959 {
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
3965
3966 } ctl_genlock_topology_t;
3967
3968 ///////////////////////////////////////////////////////////////////////////////
3969 /// @brief Display Genlock Arg type
3970 typedef struct _ctl_genlock_args_t
3971 {
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
3978 ///< topology
3979
3980 } ctl_genlock_args_t;
3981
3982 ///////////////////////////////////////////////////////////////////////////////
3983 /// @brief Get/Set Display Genlock
3984 ///
3985 /// @details
3986 /// - To get or set Display Genlock.
3987 ///
3988 /// @returns
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
4009 );
4010
4011
4012 #if !defined(__GNUC__)
4013 #pragma endregion // display
4014 #endif
4015 // Intel 'ctlApi' for Device Adapter - Engine groups
4016 #if !defined(__GNUC__)
4017 #pragma region engine
4018 #endif
4019 ///////////////////////////////////////////////////////////////////////////////
4020 /// @brief Accelerator engine groups
4021 typedef enum _ctl_engine_group_t
4022 {
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
4027
4028 } ctl_engine_group_t;
4029
4030 ///////////////////////////////////////////////////////////////////////////////
4031 /// @brief Engine group properties
4032 typedef struct _ctl_engine_properties_t
4033 {
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
4037
4038 } ctl_engine_properties_t;
4039
4040 ///////////////////////////////////////////////////////////////////////////////
4041 /// @brief Engine activity counters
4042 ///
4043 /// @details
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
4048 {
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.
4061
4062 } ctl_engine_stats_t;
4063
4064 ///////////////////////////////////////////////////////////////////////////////
4065 /// @brief Get handle of engine groups
4066 ///
4067 /// @details
4068 /// - The application may call this function from simultaneous threads.
4069 /// - The implementation of this function should be lock-free.
4070 ///
4071 /// @returns
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
4089 ///< this type.
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.
4093 );
4094
4095 ///////////////////////////////////////////////////////////////////////////////
4096 /// @brief Get engine group properties
4097 ///
4098 /// @details
4099 /// - The application may call this function from simultaneous threads.
4100 /// - The implementation of this function should be lock-free.
4101 ///
4102 /// @returns
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.
4114 );
4115
4116 ///////////////////////////////////////////////////////////////////////////////
4117 /// @brief Get the activity stats for an engine group
4118 ///
4119 /// @details
4120 /// - The application may call this function from simultaneous threads.
4121 /// - The implementation of this function should be lock-free.
4122 ///
4123 /// @returns
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
4135 ///< counters.
4136 );
4137
4138
4139 #if !defined(__GNUC__)
4140 #pragma endregion // engine
4141 #endif
4142 // Intel 'ctlApi' for Device Adapter- Fan management
4143 #if !defined(__GNUC__)
4144 #pragma region fan
4145 #endif
4146 ///////////////////////////////////////////////////////////////////////////////
4147 /// @brief Fan resource speed mode
4148 typedef enum _ctl_fan_speed_mode_t
4149 {
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
4155
4156 } ctl_fan_speed_mode_t;
4157
4158 ///////////////////////////////////////////////////////////////////////////////
4159 /// @brief Fan speed units
4160 typedef enum _ctl_fan_speed_units_t
4161 {
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
4165
4166 } ctl_fan_speed_units_t;
4167
4168 ///////////////////////////////////////////////////////////////////////////////
4169 /// @brief Fan speed
4170 typedef struct _ctl_fan_speed_t
4171 {
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.
4178
4179 } ctl_fan_speed_t;
4180
4181 ///////////////////////////////////////////////////////////////////////////////
4182 /// @brief Fan temperature/speed pair
4183 typedef struct _ctl_fan_temp_speed_t
4184 {
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
4189
4190 } ctl_fan_temp_speed_t;
4191
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
4197
4198 ///////////////////////////////////////////////////////////////////////////////
4199 /// @brief Fan speed table
4200 typedef struct _ctl_fan_speed_table_t
4201 {
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.
4209
4210 } ctl_fan_speed_table_t;
4211
4212 ///////////////////////////////////////////////////////////////////////////////
4213 /// @brief Fan properties
4214 typedef struct _ctl_fan_properties_t
4215 {
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
4228 ///< table.
4229
4230 } ctl_fan_properties_t;
4231
4232 ///////////////////////////////////////////////////////////////////////////////
4233 /// @brief Fan configuration
4234 typedef struct _ctl_fan_config_t
4235 {
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
4241
4242 } ctl_fan_config_t;
4243
4244 ///////////////////////////////////////////////////////////////////////////////
4245 /// @brief Get handle of fans
4246 ///
4247 /// @details
4248 /// - The application may call this function from simultaneous threads.
4249 /// - The implementation of this function should be lock-free.
4250 ///
4251 /// @returns
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
4260 ctlEnumFans(
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
4269 ///< this type.
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.
4273 );
4274
4275 ///////////////////////////////////////////////////////////////////////////////
4276 /// @brief Get fan properties
4277 ///
4278 /// @details
4279 /// - The application may call this function from simultaneous threads.
4280 /// - The implementation of this function should be lock-free.
4281 ///
4282 /// @returns
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.
4294 );
4295
4296 ///////////////////////////////////////////////////////////////////////////////
4297 /// @brief Get fan configurations and the current fan speed mode (default, fixed,
4298 /// temp-speed table)
4299 ///
4300 /// @details
4301 /// - The application may call this function from simultaneous threads.
4302 /// - The implementation of this function should be lock-free.
4303 ///
4304 /// @returns
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
4313 ctlFanGetConfig(
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.
4316 );
4317
4318 ///////////////////////////////////////////////////////////////////////////////
4319 /// @brief Configure the fan to run with hardware factory settings (set mode to
4320 /// ::CTL_FAN_SPEED_MODE_DEFAULT)
4321 ///
4322 /// @details
4323 /// - The application may call this function from simultaneous threads.
4324 /// - The implementation of this function should be lock-free.
4325 ///
4326 /// @returns
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.
4337 );
4338
4339 ///////////////////////////////////////////////////////////////////////////////
4340 /// @brief Configure the fan to rotate at a fixed speed (set mode to
4341 /// ::CTL_FAN_SPEED_MODE_FIXED)
4342 ///
4343 /// @details
4344 /// - The application may call this function from simultaneous threads.
4345 /// - The implementation of this function should be lock-free.
4346 ///
4347 /// @returns
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
4363 );
4364
4365 ///////////////////////////////////////////////////////////////////////////////
4366 /// @brief Configure the fan to adjust speed based on a temperature/speed table
4367 /// (set mode to ::CTL_FAN_SPEED_MODE_TABLE)
4368 ///
4369 /// @details
4370 /// - The application may call this function from simultaneous threads.
4371 /// - The implementation of this function should be lock-free.
4372 ///
4373 /// @returns
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.
4391 );
4392
4393 ///////////////////////////////////////////////////////////////////////////////
4394 /// @brief Get current state of a fan - current mode and speed
4395 ///
4396 /// @details
4397 /// - The application may call this function from simultaneous threads.
4398 /// - The implementation of this function should be lock-free.
4399 ///
4400 /// @returns
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
4413 ctlFanGetState(
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
4418 ///< measured.
4419 );
4420
4421
4422 #if !defined(__GNUC__)
4423 #pragma endregion // fan
4424 #endif
4425 // Intel 'ctlApi' for Device Adapter - Frequency domains
4426 #if !defined(__GNUC__)
4427 #pragma region frequency
4428 #endif
4429 ///////////////////////////////////////////////////////////////////////////////
4430 /// @brief Frequency domains.
4431 typedef enum _ctl_freq_domain_t
4432 {
4433 CTL_FREQ_DOMAIN_GPU = 0, ///< GPU Core Domain.
4434 CTL_FREQ_DOMAIN_MEMORY = 1, ///< Local Memory Domain.
4435 CTL_FREQ_DOMAIN_MAX
4436
4437 } ctl_freq_domain_t;
4438
4439 ///////////////////////////////////////////////////////////////////////////////
4440 /// @brief Frequency properties
4441 typedef struct _ctl_freq_properties_t
4442 {
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,
4446 ///< memory, ...)
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
4451 ///< MHz.
4452
4453 } ctl_freq_properties_t;
4454
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
4458 /// appropriately.
4459 typedef struct _ctl_freq_range_t
4460 {
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
4467 ///< in effect.
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.
4473
4474 } ctl_freq_range_t;
4475
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
4480 {
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
4490
4491 } ctl_freq_throttle_reason_flag_t;
4492
4493 ///////////////////////////////////////////////////////////////////////////////
4494 /// @brief Frequency state
4495 typedef struct _ctl_freq_state_t
4496 {
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
4506 ///< not known.
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.
4513
4514 } ctl_freq_state_t;
4515
4516 ///////////////////////////////////////////////////////////////////////////////
4517 /// @brief Frequency throttle time snapshot
4518 ///
4519 /// @details
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
4524 {
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.
4536
4537 } ctl_freq_throttle_time_t;
4538
4539 ///////////////////////////////////////////////////////////////////////////////
4540 /// @brief Get handle of frequency domains
4541 ///
4542 /// @details
4543 /// - The application may call this function from simultaneous threads.
4544 /// - The implementation of this function should be lock-free.
4545 ///
4546 /// @returns
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
4564 ///< this type.
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.
4568 );
4569
4570 ///////////////////////////////////////////////////////////////////////////////
4571 /// @brief Get frequency properties - available frequencies
4572 ///
4573 /// @details
4574 /// - The application may call this function from simultaneous threads.
4575 /// - The implementation of this function should be lock-free.
4576 ///
4577 /// @returns
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.
4589 );
4590
4591 ///////////////////////////////////////////////////////////////////////////////
4592 /// @brief Get available non-overclocked hardware clock frequencies for the
4593 /// frequency domain
4594 ///
4595 /// @details
4596 /// - The list of available frequencies is returned in order of slowest to
4597 /// fastest.
4598 /// - The application may call this function from simultaneous threads.
4599 /// - The implementation of this function should be lock-free.
4600 ///
4601 /// @returns
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.
4621 );
4622
4623 ///////////////////////////////////////////////////////////////////////////////
4624 /// @brief Get current frequency limits
4625 ///
4626 /// @details
4627 /// - The application may call this function from simultaneous threads.
4628 /// - The implementation of this function should be lock-free.
4629 ///
4630 /// @returns
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.
4643 );
4644
4645 ///////////////////////////////////////////////////////////////////////////////
4646 /// @brief Set frequency range between which the hardware can operate.
4647 ///
4648 /// @details
4649 /// - The application may call this function from simultaneous threads.
4650 /// - The implementation of this function should be lock-free.
4651 ///
4652 /// @returns
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.
4667 );
4668
4669 ///////////////////////////////////////////////////////////////////////////////
4670 /// @brief Get current frequency state - frequency request, actual frequency, TDP
4671 /// limits
4672 ///
4673 /// @details
4674 /// - The application may call this function from simultaneous threads.
4675 /// - The implementation of this function should be lock-free.
4676 ///
4677 /// @returns
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.
4689 );
4690
4691 ///////////////////////////////////////////////////////////////////////////////
4692 /// @brief Get frequency throttle time
4693 ///
4694 /// @details
4695 /// - The application may call this function from simultaneous threads.
4696 /// - The implementation of this function should be lock-free.
4697 ///
4698 /// @returns
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.
4711 );
4712
4713
4714 #if !defined(__GNUC__)
4715 #pragma endregion // frequency
4716 #endif
4717 // Intel 'ctlApi' for Device Adapter
4718 #if !defined(__GNUC__)
4719 #pragma region media
4720 #endif
4721 ///////////////////////////////////////////////////////////////////////////////
4722 /// @brief Feature type
4723 typedef enum _ctl_video_processing_feature_t
4724 {
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
4743 ///< ValueType.
4744 CTL_VIDEO_PROCESSING_FEATURE_MAX
4745
4746 } ctl_video_processing_feature_t;
4747
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
4752 {
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
4759
4760 } ctl_video_processing_super_resolution_flag_t;
4761
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
4766 {
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
4775
4776 } ctl_video_processing_super_resolution_info_t;
4777
4778 ///////////////////////////////////////////////////////////////////////////////
4779 /// @brief Super Resolution Get/Set structure to be used with SUPER_RESOLUTION
4780 typedef struct _ctl_video_processing_super_resolution_t
4781 {
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
4797
4798 } ctl_video_processing_super_resolution_t;
4799
4800 ///////////////////////////////////////////////////////////////////////////////
4801 /// @brief Noise Reduction feature details structure to be used with
4802 /// NOISE_REDUCTION
4803 typedef struct _ctl_video_processing_noise_reduction_info_t
4804 {
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
4813
4814 } ctl_video_processing_noise_reduction_info_t;
4815
4816 ///////////////////////////////////////////////////////////////////////////////
4817 /// @brief Noise Reduction Get/Set structure to be used with NOISE_REDUCTION
4818 typedef struct _ctl_video_processing_noise_reduction_t
4819 {
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
4825
4826 } ctl_video_processing_noise_reduction_t;
4827
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
4832 {
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
4836 ///< information
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
4843
4844 } ctl_video_processing_adaptive_contrast_enhancement_info_t;
4845
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
4850 {
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
4856
4857 } ctl_video_processing_adaptive_contrast_enhancement_t;
4858
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
4863 {
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
4874
4875 } ctl_video_processing_standard_color_correction_info_t;
4876
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
4881 {
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
4886 ///< enabling.
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
4892
4893 } ctl_video_processing_standard_color_correction_t;
4894
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
4899 {
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
4912
4913 } ctl_video_processing_total_color_correction_info_t;
4914
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
4919 {
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
4931
4932 } ctl_video_processing_total_color_correction_t;
4933
4934 ///////////////////////////////////////////////////////////////////////////////
4935 /// @brief Video Processing feature details which will have range supported and
4936 /// default values
4937 typedef struct _ctl_video_processing_feature_details_t
4938 {
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
4954
4955 } ctl_video_processing_feature_details_t;
4956
4957 ///////////////////////////////////////////////////////////////////////////////
4958 /// @brief Video Processing features which are controllable
4959 typedef struct _ctl_video_processing_feature_caps_t
4960 {
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
4966
4967 } ctl_video_processing_feature_caps_t;
4968
4969 ///////////////////////////////////////////////////////////////////////////////
4970 /// @brief Video Processing feature for get/set
4971 typedef struct _ctl_video_processing_feature_getset_t
4972 {
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
4996
4997 } ctl_video_processing_feature_getset_t;
4998
4999 ///////////////////////////////////////////////////////////////////////////////
5000 /// @brief Get Video Processing capabilities
5001 ///
5002 /// @details
5003 /// - The application gets Video Processing properties
5004 ///
5005 /// @returns
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
5018 );
5019
5020 ///////////////////////////////////////////////////////////////////////////////
5021 /// @brief Get/Set Video Processing feature details
5022 ///
5023 /// @details
5024 /// - Video Processing feature details
5025 ///
5026 /// @returns
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
5039 );
5040
5041
5042 #if !defined(__GNUC__)
5043 #pragma endregion // media
5044 #endif
5045 // Intel 'ctlApi' for Device Adapter - Memory management
5046 #if !defined(__GNUC__)
5047 #pragma region memory
5048 #endif
5049 ///////////////////////////////////////////////////////////////////////////////
5050 /// @brief Memory module types
5051 typedef enum _ctl_mem_type_t
5052 {
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
5069 CTL_MEM_TYPE_MAX
5070
5071 } ctl_mem_type_t;
5072
5073 ///////////////////////////////////////////////////////////////////////////////
5074 /// @brief Memory module location
5075 typedef enum _ctl_mem_loc_t
5076 {
5077 CTL_MEM_LOC_SYSTEM = 0, ///< System memory
5078 CTL_MEM_LOC_DEVICE = 1, ///< On board local device memory
5079 CTL_MEM_LOC_MAX
5080
5081 } ctl_mem_loc_t;
5082
5083 ///////////////////////////////////////////////////////////////////////////////
5084 /// @brief Memory properties
5085 typedef struct _ctl_mem_properties_t
5086 {
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
5095 ///< is unknown.
5096 int32_t numChannels; ///< [out] The number of memory channels. A value of -1 means that this
5097 ///< property is unknown.
5098
5099 } ctl_mem_properties_t;
5100
5101 ///////////////////////////////////////////////////////////////////////////////
5102 /// @brief Memory state - health, allocated
5103 ///
5104 /// @details
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
5108 {
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)
5114
5115 } ctl_mem_state_t;
5116
5117 ///////////////////////////////////////////////////////////////////////////////
5118 /// @brief Memory bandwidth
5119 ///
5120 /// @details
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
5126 {
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
5139
5140 } ctl_mem_bandwidth_t;
5141
5142 ///////////////////////////////////////////////////////////////////////////////
5143 /// @brief Get handle of memory modules
5144 ///
5145 /// @details
5146 /// - The application may call this function from simultaneous threads.
5147 /// - The implementation of this function should be lock-free.
5148 ///
5149 /// @returns
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
5167 ///< this type.
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.
5171 );
5172
5173 ///////////////////////////////////////////////////////////////////////////////
5174 /// @brief Get memory properties
5175 ///
5176 /// @details
5177 /// - The application may call this function from simultaneous threads.
5178 /// - The implementation of this function should be lock-free.
5179 ///
5180 /// @returns
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.
5192 );
5193
5194 ///////////////////////////////////////////////////////////////////////////////
5195 /// @brief Get memory state - health, allocated
5196 ///
5197 /// @details
5198 /// - The application may call this function from simultaneous threads.
5199 /// - The implementation of this function should be lock-free.
5200 ///
5201 /// @returns
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
5210 ctlMemoryGetState(
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.
5213 );
5214
5215 ///////////////////////////////////////////////////////////////////////////////
5216 /// @brief Get memory bandwidth
5217 ///
5218 /// @details
5219 /// - The application may call this function from simultaneous threads.
5220 /// - The implementation of this function should be lock-free.
5221 ///
5222 /// @returns
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
5236 ///< size.
5237 );
5238
5239
5240 #if !defined(__GNUC__)
5241 #pragma endregion // memory
5242 #endif
5243 // Intel 'ctlApi' for Device Adapter - Overclock
5244 #if !defined(__GNUC__)
5245 #pragma region overclock
5246 #endif
5247 ///////////////////////////////////////////////////////////////////////////////
5248 /// @brief Telemetry Item for each telemetry property
5249 ///
5250 /// @details
5251 /// - If the supported field is true, then the entire structure has valid
5252 /// information.
5253 /// - The ::ctl_data_value_t is of type ::ctl_data_type_t and units
5254 /// ::ctl_units_t
5255 typedef struct _ctl_oc_telemetry_item_t
5256 {
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.
5261
5262 } ctl_oc_telemetry_item_t;
5263
5264 ///////////////////////////////////////////////////////////////////////////////
5265 /// @brief Overclocking Control Information
5266 ///
5267 /// @details
5268 /// - Whether the device supports overclocking.
5269 /// - The
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
5291 {
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.
5302
5303 } ctl_oc_control_info_t;
5304
5305 ///////////////////////////////////////////////////////////////////////////////
5306 /// @brief Overclock properties
5307 typedef struct _ctl_oc_properties_t
5308 {
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
5318
5319 } ctl_oc_properties_t;
5320
5321 ///////////////////////////////////////////////////////////////////////////////
5322 /// @brief Overclock Voltage Frequency Pair
5323 typedef struct _ctl_oc_vf_pair_t
5324 {
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.
5329
5330 } ctl_oc_vf_pair_t;
5331
5332 ///////////////////////////////////////////////////////////////////////////////
5333 #ifndef CTL_PSU_COUNT
5334 /// @brief Maximum number power supply units.
5335 #define CTL_PSU_COUNT 5
5336 #endif // CTL_PSU_COUNT
5337
5338 ///////////////////////////////////////////////////////////////////////////////
5339 /// @brief PSU Type.
5340 typedef enum _ctl_psu_type_t
5341 {
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
5346 CTL_PSU_TYPE_MAX
5347
5348 } ctl_psu_type_t;
5349
5350 ///////////////////////////////////////////////////////////////////////////////
5351 /// @brief PSU Info
5352 typedef struct _ctl_psu_info_t
5353 {
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.
5361
5362 } ctl_psu_info_t;
5363
5364 ///////////////////////////////////////////////////////////////////////////////
5365 #ifndef CTL_FAN_COUNT
5366 /// @brief Maximum number of Fans
5367 #define CTL_FAN_COUNT 5
5368 #endif // CTL_FAN_COUNT
5369
5370 ///////////////////////////////////////////////////////////////////////////////
5371 /// @brief Power Telemetry
5372 typedef struct _ctl_power_telemetry_t
5373 {
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
5427 ///< modules.
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
5444 ///< limits.
5445 bool vramTemperatureLimited; ///< [out] Instantaneous indication that the memory frequency is being
5446 ///< throttled because the memory modules are exceeding the temperature
5447 ///< limits.
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.
5458
5459 } ctl_power_telemetry_t;
5460
5461 ///////////////////////////////////////////////////////////////////////////////
5462 /// @brief Get overclock properties - available properties.
5463 ///
5464 /// @returns
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.
5476 );
5477
5478 ///////////////////////////////////////////////////////////////////////////////
5479 /// @brief Overclock Waiver - Warranty Waiver.
5480 ///
5481 /// @details
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
5490 /// application.
5491 /// - It is acceptable for the application to cache the user choice and call
5492 /// this function on future executions without issuing the popup.
5493 ///
5494 /// @returns
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
5503 );
5504
5505 ///////////////////////////////////////////////////////////////////////////////
5506 /// @brief Get the Overclock Frequency Offset for the GPU in MHz.
5507 ///
5508 /// @details
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.
5515 ///
5516 /// @returns
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.
5528 );
5529
5530 ///////////////////////////////////////////////////////////////////////////////
5531 /// @brief Set the Overclock Frequency Offset for the GPU in MHZ.
5532 ///
5533 /// @details
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
5544 /// set.
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.
5558 ///
5559 /// @returns
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.
5569 );
5570
5571 ///////////////////////////////////////////////////////////////////////////////
5572 /// @brief Get the Overclock Gpu Voltage Offset in mV.
5573 ///
5574 /// @details
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.
5581 ///
5582 /// @returns
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.
5594 );
5595
5596 ///////////////////////////////////////////////////////////////////////////////
5597 /// @brief Set the Overclock Gpu Voltage Offset in mV.
5598 ///
5599 /// @details
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.
5612 ///
5613 /// @returns
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.
5623 );
5624
5625 ///////////////////////////////////////////////////////////////////////////////
5626 /// @brief Gets the Locked GPU Voltage for Overclocking in mV.
5627 ///
5628 /// @details
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
5632 /// voltage.
5633 /// - Note that the operating frequency/voltage may be lower than these
5634 /// settings if power/thermal limits are exceeded.
5635 ///
5636 /// @returns
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.
5648 );
5649
5650 ///////////////////////////////////////////////////////////////////////////////
5651 /// @brief Locks the GPU voltage for Overclocking in mV.
5652 ///
5653 /// @details
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
5662 /// limitations.
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.
5666 ///
5667 /// @returns
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.
5677 );
5678
5679 ///////////////////////////////////////////////////////////////////////////////
5680 /// @brief Get the current Vram Frequency Offset in GT/s.
5681 ///
5682 /// @details
5683 /// - The purpose of this function is to return the current VRAM frequency
5684 /// offset in units of GT/s.
5685 ///
5686 /// @returns
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.
5698 );
5699
5700 ///////////////////////////////////////////////////////////////////////////////
5701 /// @brief Set the desired Vram frquency Offset in GT/s
5702 ///
5703 /// @details
5704 /// - The purpose of this function is to increase/decrease the frequency of
5705 /// VRAM.
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
5742 /// required.
5743 ///
5744 /// @returns
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.
5754 );
5755
5756 ///////////////////////////////////////////////////////////////////////////////
5757 /// @brief Get the Overclock Vram Voltage Offset in mV.
5758 ///
5759 /// @details
5760 /// - The purpose of this function is to increase/decrease the voltage of
5761 /// VRAM.
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
5796 /// required.
5797 ///
5798 /// @returns
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.
5810 );
5811
5812 ///////////////////////////////////////////////////////////////////////////////
5813 /// @brief Set the Overclock Vram Voltage Offset in mV.
5814 ///
5815 /// @details
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
5821 /// limits.
5822 ///
5823 /// @returns
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.
5833 );
5834
5835 ///////////////////////////////////////////////////////////////////////////////
5836 /// @brief Get the sustained power limit in mW.
5837 ///
5838 /// @details
5839 /// - The purpose of this function is to read the current sustained power
5840 /// limit.
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.
5843 ///
5844 /// @returns
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.
5856 );
5857
5858 ///////////////////////////////////////////////////////////////////////////////
5859 /// @brief Set the sustained power limit in mW.
5860 ///
5861 /// @details
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
5867 /// limits.
5868 ///
5869 /// @returns
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.
5879 );
5880
5881 ///////////////////////////////////////////////////////////////////////////////
5882 /// @brief Get the current temperature limit in Celsius.
5883 ///
5884 /// @details
5885 /// - The purpose of this function is to read the current thermal limit.
5886 ///
5887 /// @returns
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.
5899 );
5900
5901 ///////////////////////////////////////////////////////////////////////////////
5902 /// @brief Set the temperature limit in Celsius.
5903 ///
5904 /// @details
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
5907 /// throttled.
5908 ///
5909 /// @returns
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.
5919 );
5920
5921 ///////////////////////////////////////////////////////////////////////////////
5922 /// @brief Get Power Telemetry.
5923 ///
5924 /// @details
5925 /// - Limited rate of 50 ms, any call under 50 ms will return the same
5926 /// information.
5927 ///
5928 /// @returns
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.
5940 );
5941
5942
5943 #if !defined(__GNUC__)
5944 #pragma endregion // overclock
5945 #endif
5946 // Intel 'ctlApi' for Device Adapter - PCI Information
5947 #if !defined(__GNUC__)
5948 #pragma region pci
5949 #endif
5950 ///////////////////////////////////////////////////////////////////////////////
5951 /// @brief PCI address
5952 typedef struct _ctl_pci_address_t
5953 {
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
5960
5961 } ctl_pci_address_t;
5962
5963 ///////////////////////////////////////////////////////////////////////////////
5964 /// @brief PCI speed
5965 typedef struct _ctl_pci_speed_t
5966 {
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
5970 ///< unknown.
5971 int32_t width; ///< [out] The number of lanes. A value of -1 means that this property is
5972 ///< unknown.
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.
5975
5976 } ctl_pci_speed_t;
5977
5978 ///////////////////////////////////////////////////////////////////////////////
5979 /// @brief Static PCI properties
5980 typedef struct _ctl_pci_properties_t
5981 {
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
5986 ///< lanes)
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
5989
5990 } ctl_pci_properties_t;
5991
5992 ///////////////////////////////////////////////////////////////////////////////
5993 /// @brief Dynamic PCI state
5994 typedef struct _ctl_pci_state_t
5995 {
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
5999
6000 } ctl_pci_state_t;
6001
6002 ///////////////////////////////////////////////////////////////////////////////
6003 /// @brief Get PCI properties - address, max speed
6004 ///
6005 /// @details
6006 /// - The application may call this function from simultaneous threads.
6007 /// - The implementation of this function should be lock-free.
6008 ///
6009 /// @returns
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.
6021 );
6022
6023 ///////////////////////////////////////////////////////////////////////////////
6024 /// @brief Get current PCI state - current speed
6025 ///
6026 /// @details
6027 /// - The application may call this function from simultaneous threads.
6028 /// - The implementation of this function should be lock-free.
6029 ///
6030 /// @returns
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
6039 ctlPciGetState(
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.
6042 );
6043
6044
6045 #if !defined(__GNUC__)
6046 #pragma endregion // pci
6047 #endif
6048 // Intel 'ctlApi' for Device Adapter - Power management
6049 #if !defined(__GNUC__)
6050 #pragma region power
6051 #endif
6052 ///////////////////////////////////////////////////////////////////////////////
6053 /// @brief Properties related to device power settings
6054 typedef struct _ctl_power_properties_t
6055 {
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.
6064
6065 } ctl_power_properties_t;
6066
6067 ///////////////////////////////////////////////////////////////////////////////
6068 /// @brief Energy counter snapshot
6069 ///
6070 /// @details
6071 /// - Average power is calculated by taking two snapshots (s1, s2) and using
6072 /// the equation: PowerWatts = (s2.energy - s1.energy) / (s2.timestamp -
6073 /// s1.timestamp)
6074 typedef struct _ctl_power_energy_counter_t
6075 {
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.
6086
6087 } ctl_power_energy_counter_t;
6088
6089 ///////////////////////////////////////////////////////////////////////////////
6090 /// @brief Sustained power limits
6091 ///
6092 /// @details
6093 /// - The power controller (Punit) will throttle the operating frequency if
6094 /// the power averaged over a window (typically seconds) exceeds this
6095 /// limit.
6096 typedef struct _ctl_power_sustained_limit_t
6097 {
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
6101
6102 } ctl_power_sustained_limit_t;
6103
6104 ///////////////////////////////////////////////////////////////////////////////
6105 /// @brief Burst power limit
6106 ///
6107 /// @details
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
6114 {
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
6117
6118 } ctl_power_burst_limit_t;
6119
6120 ///////////////////////////////////////////////////////////////////////////////
6121 /// @brief Peak power limit
6122 ///
6123 /// @details
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
6132 /// excursions.
6133 typedef struct _ctl_power_peak_limit_t
6134 {
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.
6139
6140 } ctl_power_peak_limit_t;
6141
6142 ///////////////////////////////////////////////////////////////////////////////
6143 /// @brief Power limits
6144 typedef struct _ctl_power_limits_t
6145 {
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.
6151
6152 } ctl_power_limits_t;
6153
6154 ///////////////////////////////////////////////////////////////////////////////
6155 /// @brief Energy threshold
6156 ///
6157 /// @details
6158 /// - .
6159 typedef struct _ctl_energy_threshold_t
6160 {
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
6165 ///< has been set.
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.
6168
6169 } ctl_energy_threshold_t;
6170
6171 ///////////////////////////////////////////////////////////////////////////////
6172 /// @brief Get handle of power domains
6173 ///
6174 /// @details
6175 /// - The application may call this function from simultaneous threads.
6176 /// - The implementation of this function should be lock-free.
6177 ///
6178 /// @returns
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
6196 ///< this type.
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.
6200 );
6201
6202 ///////////////////////////////////////////////////////////////////////////////
6203 /// @brief Get properties related to a power domain
6204 ///
6205 /// @details
6206 /// - The application may call this function from simultaneous threads.
6207 /// - The implementation of this function should be lock-free.
6208 ///
6209 /// @returns
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.
6221 );
6222
6223 ///////////////////////////////////////////////////////////////////////////////
6224 /// @brief Get energy counter
6225 ///
6226 /// @details
6227 /// - The application may call this function from simultaneous threads.
6228 /// - The implementation of this function should be lock-free.
6229 ///
6230 /// @returns
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.
6243 );
6244
6245 ///////////////////////////////////////////////////////////////////////////////
6246 /// @brief Get power limits
6247 ///
6248 /// @details
6249 /// - The application may call this function from simultaneous threads.
6250 /// - The implementation of this function should be lock-free.
6251 ///
6252 /// @returns
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
6259 ctlPowerGetLimits(
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.
6262 );
6263
6264 ///////////////////////////////////////////////////////////////////////////////
6265 /// @brief Set power limits
6266 ///
6267 /// @details
6268 /// - The application may call this function from simultaneous threads.
6269 /// - The implementation of this function should be lock-free.
6270 ///
6271 /// @returns
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
6282 ctlPowerSetLimits(
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.
6285 );
6286
6287
6288 #if !defined(__GNUC__)
6289 #pragma endregion // power
6290 #endif
6291 // Intel 'ctlApi' for Device Adapter - Temperature Sensors
6292 #if !defined(__GNUC__)
6293 #pragma region temperature
6294 #endif
6295 ///////////////////////////////////////////////////////////////////////////////
6296 /// @brief Temperature sensors
6297 typedef enum _ctl_temp_sensors_t
6298 {
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
6306
6307 } ctl_temp_sensors_t;
6308
6309 ///////////////////////////////////////////////////////////////////////////////
6310 /// @brief Temperature sensor properties
6311 typedef struct _ctl_temp_properties_t
6312 {
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.
6318
6319 } ctl_temp_properties_t;
6320
6321 ///////////////////////////////////////////////////////////////////////////////
6322 /// @brief Get handle of temperature sensors
6323 ///
6324 /// @details
6325 /// - The application may call this function from simultaneous threads.
6326 /// - The implementation of this function should be lock-free.
6327 ///
6328 /// @returns
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
6346 ///< this type.
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.
6350 );
6351
6352 ///////////////////////////////////////////////////////////////////////////////
6353 /// @brief Get temperature sensor properties
6354 ///
6355 /// @details
6356 /// - The application may call this function from simultaneous threads.
6357 /// - The implementation of this function should be lock-free.
6358 ///
6359 /// @returns
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.
6371 );
6372
6373 ///////////////////////////////////////////////////////////////////////////////
6374 /// @brief Get the temperature from a specified sensor
6375 ///
6376 /// @details
6377 /// - The application may call this function from simultaneous threads.
6378 /// - The implementation of this function should be lock-free.
6379 ///
6380 /// @returns
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.
6393 );
6394
6395
6396 #if !defined(__GNUC__)
6397 #pragma endregion // temperature
6398 #endif
6399
6400
6401 ///////////////////////////////////////////////////////////////////////////////
6402 /// @brief Function-pointer for ctlInit
6403 typedef ctl_result_t (CTL_APICALL *ctl_pfnInit_t)(
6404 ctl_init_args_t*,
6405 ctl_api_handle_t*
6406 );
6407
6408
6409 ///////////////////////////////////////////////////////////////////////////////
6410 /// @brief Function-pointer for ctlClose
6411 typedef ctl_result_t (CTL_APICALL *ctl_pfnClose_t)(
6412 ctl_api_handle_t
6413 );
6414
6415
6416 ///////////////////////////////////////////////////////////////////////////////
6417 /// @brief Function-pointer for ctlSetRuntimePath
6418 typedef ctl_result_t (CTL_APICALL *ctl_pfnSetRuntimePath_t)(
6419 ctl_runtime_path_args_t*
6420 );
6421
6422
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*
6428 );
6429
6430
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*
6436 );
6437
6438
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*
6444 );
6445
6446
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*
6452 );
6453
6454
6455 ///////////////////////////////////////////////////////////////////////////////
6456 /// @brief Function-pointer for ctlCheckDriverVersion
6457 typedef ctl_result_t (CTL_APICALL *ctl_pfnCheckDriverVersion_t)(
6458 ctl_device_adapter_handle_t,
6459 ctl_version_info_t
6460 );
6461
6462
6463 ///////////////////////////////////////////////////////////////////////////////
6464 /// @brief Function-pointer for ctlEnumerateDevices
6465 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumerateDevices_t)(
6466 ctl_api_handle_t,
6467 uint32_t*,
6468 ctl_device_adapter_handle_t*
6469 );
6470
6471
6472 ///////////////////////////////////////////////////////////////////////////////
6473 /// @brief Function-pointer for ctlEnumerateDisplayOutputs
6474 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumerateDisplayOutputs_t)(
6475 ctl_device_adapter_handle_t,
6476 uint32_t*,
6477 ctl_display_output_handle_t*
6478 );
6479
6480
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*
6486 );
6487
6488
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*
6494 );
6495
6496
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*
6502 );
6503
6504
6505 ///////////////////////////////////////////////////////////////////////////////
6506 /// @brief Function-pointer for ctlGetZeDevice
6507 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetZeDevice_t)(
6508 ctl_device_adapter_handle_t,
6509 void*,
6510 void**
6511 );
6512
6513
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*
6519 );
6520
6521
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*
6527 );
6528
6529
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*
6535 );
6536
6537
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*
6543 );
6544
6545
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*
6551 );
6552
6553
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*
6559 );
6560
6561
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*
6567 );
6568
6569
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*
6575 );
6576
6577
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*
6583 );
6584
6585
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*
6591 );
6592
6593
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*
6599 );
6600
6601
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*
6607 );
6608
6609
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*
6615 );
6616
6617
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*
6623 );
6624
6625
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*
6631 );
6632
6633
6634 ///////////////////////////////////////////////////////////////////////////////
6635 /// @brief Function-pointer for ctlGetSupportedScalingCapability
6636 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetSupportedScalingCapability_t)(
6637 ctl_display_output_handle_t,
6638 ctl_scaling_caps_t*
6639 );
6640
6641
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*
6647 );
6648
6649
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*
6655 );
6656
6657
6658 ///////////////////////////////////////////////////////////////////////////////
6659 /// @brief Function-pointer for ctlGetLACEConfig
6660 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetLACEConfig_t)(
6661 ctl_display_output_handle_t,
6662 ctl_lace_config_t*
6663 );
6664
6665
6666 ///////////////////////////////////////////////////////////////////////////////
6667 /// @brief Function-pointer for ctlSetLACEConfig
6668 typedef ctl_result_t (CTL_APICALL *ctl_pfnSetLACEConfig_t)(
6669 ctl_display_output_handle_t,
6670 ctl_lace_config_t*
6671 );
6672
6673
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*
6679 );
6680
6681
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*
6687 );
6688
6689
6690 ///////////////////////////////////////////////////////////////////////////////
6691 /// @brief Function-pointer for ctlEnumerateMuxDevices
6692 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumerateMuxDevices_t)(
6693 ctl_api_handle_t,
6694 uint32_t*,
6695 ctl_mux_output_handle_t*
6696 );
6697
6698
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*
6704 );
6705
6706
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
6712 );
6713
6714
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*
6720 );
6721
6722
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*
6728 );
6729
6730
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*
6736 );
6737
6738
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*
6744 );
6745
6746
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*
6752 );
6753
6754
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**,
6760 uint32_t,
6761 ctl_device_adapter_handle_t*
6762 );
6763
6764
6765 ///////////////////////////////////////////////////////////////////////////////
6766 /// @brief Function-pointer for ctlEnumEngineGroups
6767 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumEngineGroups_t)(
6768 ctl_device_adapter_handle_t,
6769 uint32_t*,
6770 ctl_engine_handle_t*
6771 );
6772
6773
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*
6779 );
6780
6781
6782 ///////////////////////////////////////////////////////////////////////////////
6783 /// @brief Function-pointer for ctlEngineGetActivity
6784 typedef ctl_result_t (CTL_APICALL *ctl_pfnEngineGetActivity_t)(
6785 ctl_engine_handle_t,
6786 ctl_engine_stats_t*
6787 );
6788
6789
6790 ///////////////////////////////////////////////////////////////////////////////
6791 /// @brief Function-pointer for ctlEnumFans
6792 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumFans_t)(
6793 ctl_device_adapter_handle_t,
6794 uint32_t*,
6795 ctl_fan_handle_t*
6796 );
6797
6798
6799 ///////////////////////////////////////////////////////////////////////////////
6800 /// @brief Function-pointer for ctlFanGetProperties
6801 typedef ctl_result_t (CTL_APICALL *ctl_pfnFanGetProperties_t)(
6802 ctl_fan_handle_t,
6803 ctl_fan_properties_t*
6804 );
6805
6806
6807 ///////////////////////////////////////////////////////////////////////////////
6808 /// @brief Function-pointer for ctlFanGetConfig
6809 typedef ctl_result_t (CTL_APICALL *ctl_pfnFanGetConfig_t)(
6810 ctl_fan_handle_t,
6811 ctl_fan_config_t*
6812 );
6813
6814
6815 ///////////////////////////////////////////////////////////////////////////////
6816 /// @brief Function-pointer for ctlFanSetDefaultMode
6817 typedef ctl_result_t (CTL_APICALL *ctl_pfnFanSetDefaultMode_t)(
6818 ctl_fan_handle_t
6819 );
6820
6821
6822 ///////////////////////////////////////////////////////////////////////////////
6823 /// @brief Function-pointer for ctlFanSetFixedSpeedMode
6824 typedef ctl_result_t (CTL_APICALL *ctl_pfnFanSetFixedSpeedMode_t)(
6825 ctl_fan_handle_t,
6826 const ctl_fan_speed_t*
6827 );
6828
6829
6830 ///////////////////////////////////////////////////////////////////////////////
6831 /// @brief Function-pointer for ctlFanSetSpeedTableMode
6832 typedef ctl_result_t (CTL_APICALL *ctl_pfnFanSetSpeedTableMode_t)(
6833 ctl_fan_handle_t,
6834 const ctl_fan_speed_table_t*
6835 );
6836
6837
6838 ///////////////////////////////////////////////////////////////////////////////
6839 /// @brief Function-pointer for ctlFanGetState
6840 typedef ctl_result_t (CTL_APICALL *ctl_pfnFanGetState_t)(
6841 ctl_fan_handle_t,
6842 ctl_fan_speed_units_t,
6843 int32_t*
6844 );
6845
6846
6847 ///////////////////////////////////////////////////////////////////////////////
6848 /// @brief Function-pointer for ctlEnumFrequencyDomains
6849 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumFrequencyDomains_t)(
6850 ctl_device_adapter_handle_t,
6851 uint32_t*,
6852 ctl_freq_handle_t*
6853 );
6854
6855
6856 ///////////////////////////////////////////////////////////////////////////////
6857 /// @brief Function-pointer for ctlFrequencyGetProperties
6858 typedef ctl_result_t (CTL_APICALL *ctl_pfnFrequencyGetProperties_t)(
6859 ctl_freq_handle_t,
6860 ctl_freq_properties_t*
6861 );
6862
6863
6864 ///////////////////////////////////////////////////////////////////////////////
6865 /// @brief Function-pointer for ctlFrequencyGetAvailableClocks
6866 typedef ctl_result_t (CTL_APICALL *ctl_pfnFrequencyGetAvailableClocks_t)(
6867 ctl_freq_handle_t,
6868 uint32_t*,
6869 double*
6870 );
6871
6872
6873 ///////////////////////////////////////////////////////////////////////////////
6874 /// @brief Function-pointer for ctlFrequencyGetRange
6875 typedef ctl_result_t (CTL_APICALL *ctl_pfnFrequencyGetRange_t)(
6876 ctl_freq_handle_t,
6877 ctl_freq_range_t*
6878 );
6879
6880
6881 ///////////////////////////////////////////////////////////////////////////////
6882 /// @brief Function-pointer for ctlFrequencySetRange
6883 typedef ctl_result_t (CTL_APICALL *ctl_pfnFrequencySetRange_t)(
6884 ctl_freq_handle_t,
6885 const ctl_freq_range_t*
6886 );
6887
6888
6889 ///////////////////////////////////////////////////////////////////////////////
6890 /// @brief Function-pointer for ctlFrequencyGetState
6891 typedef ctl_result_t (CTL_APICALL *ctl_pfnFrequencyGetState_t)(
6892 ctl_freq_handle_t,
6893 ctl_freq_state_t*
6894 );
6895
6896
6897 ///////////////////////////////////////////////////////////////////////////////
6898 /// @brief Function-pointer for ctlFrequencyGetThrottleTime
6899 typedef ctl_result_t (CTL_APICALL *ctl_pfnFrequencyGetThrottleTime_t)(
6900 ctl_freq_handle_t,
6901 ctl_freq_throttle_time_t*
6902 );
6903
6904
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*
6910 );
6911
6912
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*
6918 );
6919
6920
6921 ///////////////////////////////////////////////////////////////////////////////
6922 /// @brief Function-pointer for ctlEnumMemoryModules
6923 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumMemoryModules_t)(
6924 ctl_device_adapter_handle_t,
6925 uint32_t*,
6926 ctl_mem_handle_t*
6927 );
6928
6929
6930 ///////////////////////////////////////////////////////////////////////////////
6931 /// @brief Function-pointer for ctlMemoryGetProperties
6932 typedef ctl_result_t (CTL_APICALL *ctl_pfnMemoryGetProperties_t)(
6933 ctl_mem_handle_t,
6934 ctl_mem_properties_t*
6935 );
6936
6937
6938 ///////////////////////////////////////////////////////////////////////////////
6939 /// @brief Function-pointer for ctlMemoryGetState
6940 typedef ctl_result_t (CTL_APICALL *ctl_pfnMemoryGetState_t)(
6941 ctl_mem_handle_t,
6942 ctl_mem_state_t*
6943 );
6944
6945
6946 ///////////////////////////////////////////////////////////////////////////////
6947 /// @brief Function-pointer for ctlMemoryGetBandwidth
6948 typedef ctl_result_t (CTL_APICALL *ctl_pfnMemoryGetBandwidth_t)(
6949 ctl_mem_handle_t,
6950 ctl_mem_bandwidth_t*
6951 );
6952
6953
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*
6959 );
6960
6961
6962 ///////////////////////////////////////////////////////////////////////////////
6963 /// @brief Function-pointer for ctlOverclockWaiverSet
6964 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockWaiverSet_t)(
6965 ctl_device_adapter_handle_t
6966 );
6967
6968
6969 ///////////////////////////////////////////////////////////////////////////////
6970 /// @brief Function-pointer for ctlOverclockGpuFrequencyOffsetGet
6971 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockGpuFrequencyOffsetGet_t)(
6972 ctl_device_adapter_handle_t,
6973 double*
6974 );
6975
6976
6977 ///////////////////////////////////////////////////////////////////////////////
6978 /// @brief Function-pointer for ctlOverclockGpuFrequencyOffsetSet
6979 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockGpuFrequencyOffsetSet_t)(
6980 ctl_device_adapter_handle_t,
6981 double
6982 );
6983
6984
6985 ///////////////////////////////////////////////////////////////////////////////
6986 /// @brief Function-pointer for ctlOverclockGpuVoltageOffsetGet
6987 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockGpuVoltageOffsetGet_t)(
6988 ctl_device_adapter_handle_t,
6989 double*
6990 );
6991
6992
6993 ///////////////////////////////////////////////////////////////////////////////
6994 /// @brief Function-pointer for ctlOverclockGpuVoltageOffsetSet
6995 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockGpuVoltageOffsetSet_t)(
6996 ctl_device_adapter_handle_t,
6997 double
6998 );
6999
7000
7001 ///////////////////////////////////////////////////////////////////////////////
7002 /// @brief Function-pointer for ctlOverclockGpuLockGet
7003 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockGpuLockGet_t)(
7004 ctl_device_adapter_handle_t,
7005 ctl_oc_vf_pair_t*
7006 );
7007
7008
7009 ///////////////////////////////////////////////////////////////////////////////
7010 /// @brief Function-pointer for ctlOverclockGpuLockSet
7011 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockGpuLockSet_t)(
7012 ctl_device_adapter_handle_t,
7013 ctl_oc_vf_pair_t
7014 );
7015
7016
7017 ///////////////////////////////////////////////////////////////////////////////
7018 /// @brief Function-pointer for ctlOverclockVramFrequencyOffsetGet
7019 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockVramFrequencyOffsetGet_t)(
7020 ctl_device_adapter_handle_t,
7021 double*
7022 );
7023
7024
7025 ///////////////////////////////////////////////////////////////////////////////
7026 /// @brief Function-pointer for ctlOverclockVramFrequencyOffsetSet
7027 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockVramFrequencyOffsetSet_t)(
7028 ctl_device_adapter_handle_t,
7029 double
7030 );
7031
7032
7033 ///////////////////////////////////////////////////////////////////////////////
7034 /// @brief Function-pointer for ctlOverclockVramVoltageOffsetGet
7035 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockVramVoltageOffsetGet_t)(
7036 ctl_device_adapter_handle_t,
7037 double*
7038 );
7039
7040
7041 ///////////////////////////////////////////////////////////////////////////////
7042 /// @brief Function-pointer for ctlOverclockVramVoltageOffsetSet
7043 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockVramVoltageOffsetSet_t)(
7044 ctl_device_adapter_handle_t,
7045 double
7046 );
7047
7048
7049 ///////////////////////////////////////////////////////////////////////////////
7050 /// @brief Function-pointer for ctlOverclockPowerLimitGet
7051 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockPowerLimitGet_t)(
7052 ctl_device_adapter_handle_t,
7053 double*
7054 );
7055
7056
7057 ///////////////////////////////////////////////////////////////////////////////
7058 /// @brief Function-pointer for ctlOverclockPowerLimitSet
7059 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockPowerLimitSet_t)(
7060 ctl_device_adapter_handle_t,
7061 double
7062 );
7063
7064
7065 ///////////////////////////////////////////////////////////////////////////////
7066 /// @brief Function-pointer for ctlOverclockTemperatureLimitGet
7067 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockTemperatureLimitGet_t)(
7068 ctl_device_adapter_handle_t,
7069 double*
7070 );
7071
7072
7073 ///////////////////////////////////////////////////////////////////////////////
7074 /// @brief Function-pointer for ctlOverclockTemperatureLimitSet
7075 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockTemperatureLimitSet_t)(
7076 ctl_device_adapter_handle_t,
7077 double
7078 );
7079
7080
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*
7086 );
7087
7088
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*
7094 );
7095
7096
7097 ///////////////////////////////////////////////////////////////////////////////
7098 /// @brief Function-pointer for ctlPciGetState
7099 typedef ctl_result_t (CTL_APICALL *ctl_pfnPciGetState_t)(
7100 ctl_device_adapter_handle_t,
7101 ctl_pci_state_t*
7102 );
7103
7104
7105 ///////////////////////////////////////////////////////////////////////////////
7106 /// @brief Function-pointer for ctlEnumPowerDomains
7107 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumPowerDomains_t)(
7108 ctl_device_adapter_handle_t,
7109 uint32_t*,
7110 ctl_pwr_handle_t*
7111 );
7112
7113
7114 ///////////////////////////////////////////////////////////////////////////////
7115 /// @brief Function-pointer for ctlPowerGetProperties
7116 typedef ctl_result_t (CTL_APICALL *ctl_pfnPowerGetProperties_t)(
7117 ctl_pwr_handle_t,
7118 ctl_power_properties_t*
7119 );
7120
7121
7122 ///////////////////////////////////////////////////////////////////////////////
7123 /// @brief Function-pointer for ctlPowerGetEnergyCounter
7124 typedef ctl_result_t (CTL_APICALL *ctl_pfnPowerGetEnergyCounter_t)(
7125 ctl_pwr_handle_t,
7126 ctl_power_energy_counter_t*
7127 );
7128
7129
7130 ///////////////////////////////////////////////////////////////////////////////
7131 /// @brief Function-pointer for ctlPowerGetLimits
7132 typedef ctl_result_t (CTL_APICALL *ctl_pfnPowerGetLimits_t)(
7133 ctl_pwr_handle_t,
7134 ctl_power_limits_t*
7135 );
7136
7137
7138 ///////////////////////////////////////////////////////////////////////////////
7139 /// @brief Function-pointer for ctlPowerSetLimits
7140 typedef ctl_result_t (CTL_APICALL *ctl_pfnPowerSetLimits_t)(
7141 ctl_pwr_handle_t,
7142 const ctl_power_limits_t*
7143 );
7144
7145
7146 ///////////////////////////////////////////////////////////////////////////////
7147 /// @brief Function-pointer for ctlEnumTemperatureSensors
7148 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumTemperatureSensors_t)(
7149 ctl_device_adapter_handle_t,
7150 uint32_t*,
7151 ctl_temp_handle_t*
7152 );
7153
7154
7155 ///////////////////////////////////////////////////////////////////////////////
7156 /// @brief Function-pointer for ctlTemperatureGetProperties
7157 typedef ctl_result_t (CTL_APICALL *ctl_pfnTemperatureGetProperties_t)(
7158 ctl_temp_handle_t,
7159 ctl_temp_properties_t*
7160 );
7161
7162
7163 ///////////////////////////////////////////////////////////////////////////////
7164 /// @brief Function-pointer for ctlTemperatureGetState
7165 typedef ctl_result_t (CTL_APICALL *ctl_pfnTemperatureGetState_t)(
7166 ctl_temp_handle_t,
7167 double*
7168 );
7169
7170
7171 #if defined(__cplusplus)
7172 } // extern "C"
7173 #endif
7174
7175 #endif // _CTL_API_H