mirror of
https://github.com/fumiama/gozel.git
synced 2026-06-05 00:10:24 +08:00
725 lines
38 KiB
Go
725 lines
38 KiB
Go
// Code generated by cmd/gen. DO NOT EDIT.
|
|
|
|
/*
|
|
*
|
|
* Copyright (C) 2019-2025 Intel Corporation
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*
|
|
* @file zes_api.h
|
|
* @version v1.15-r1.15.31
|
|
*
|
|
*/
|
|
|
|
package gozel
|
|
|
|
import (
|
|
"unsafe"
|
|
|
|
"github.com/fumiama/gozel/internal/zecall"
|
|
)
|
|
|
|
// ZesOverclockDomain (zes_overclock_domain_t) Overclock domains.
|
|
type ZesOverclockDomain uintptr
|
|
|
|
const (
|
|
ZES_OVERCLOCK_DOMAIN_CARD ZesOverclockDomain = 1 // ZES_OVERCLOCK_DOMAIN_CARD Overclocking card level properties such as temperature limits.
|
|
ZES_OVERCLOCK_DOMAIN_PACKAGE ZesOverclockDomain = 2 // ZES_OVERCLOCK_DOMAIN_PACKAGE Overclocking package level properties such as power limits.
|
|
ZES_OVERCLOCK_DOMAIN_GPU_ALL ZesOverclockDomain = 4 // ZES_OVERCLOCK_DOMAIN_GPU_ALL Overclocking a GPU that has all accelerator assets on the same PLL/VR.
|
|
ZES_OVERCLOCK_DOMAIN_GPU_RENDER_COMPUTE ZesOverclockDomain = 8 // ZES_OVERCLOCK_DOMAIN_GPU_RENDER_COMPUTE Overclocking a GPU with render and compute assets on the same PLL/VR.
|
|
ZES_OVERCLOCK_DOMAIN_GPU_RENDER ZesOverclockDomain = 16 // ZES_OVERCLOCK_DOMAIN_GPU_RENDER Overclocking a GPU with render assets on its own PLL/VR.
|
|
ZES_OVERCLOCK_DOMAIN_GPU_COMPUTE ZesOverclockDomain = 32 // ZES_OVERCLOCK_DOMAIN_GPU_COMPUTE Overclocking a GPU with compute assets on its own PLL/VR.
|
|
ZES_OVERCLOCK_DOMAIN_GPU_MEDIA ZesOverclockDomain = 64 // ZES_OVERCLOCK_DOMAIN_GPU_MEDIA Overclocking a GPU with media assets on its own PLL/VR.
|
|
ZES_OVERCLOCK_DOMAIN_VRAM ZesOverclockDomain = 128 // ZES_OVERCLOCK_DOMAIN_VRAM Overclocking device local memory.
|
|
ZES_OVERCLOCK_DOMAIN_ADM ZesOverclockDomain = 256 // ZES_OVERCLOCK_DOMAIN_ADM Overclocking LLC/L4 cache.
|
|
ZES_OVERCLOCK_DOMAIN_FORCE_UINT32 ZesOverclockDomain = 0x7fffffff // ZES_OVERCLOCK_DOMAIN_FORCE_UINT32 Value marking end of ZES_OVERCLOCK_DOMAIN_* ENUMs
|
|
|
|
)
|
|
|
|
// ZesOverclockControl (zes_overclock_control_t) Overclock controls.
|
|
type ZesOverclockControl uintptr
|
|
|
|
const (
|
|
ZES_OVERCLOCK_CONTROL_VF ZesOverclockControl = 1 // ZES_OVERCLOCK_CONTROL_VF This control permits setting a custom V-F curve.
|
|
ZES_OVERCLOCK_CONTROL_FREQ_OFFSET ZesOverclockControl = 2 // ZES_OVERCLOCK_CONTROL_FREQ_OFFSET The V-F curve of the overclock domain can be shifted up or down using
|
|
|
|
///< this control.
|
|
|
|
ZES_OVERCLOCK_CONTROL_VMAX_OFFSET ZesOverclockControl = 4 // ZES_OVERCLOCK_CONTROL_VMAX_OFFSET This control is used to increase the permitted voltage above the
|
|
|
|
///< shipped voltage maximum.
|
|
|
|
ZES_OVERCLOCK_CONTROL_FREQ ZesOverclockControl = 8 // ZES_OVERCLOCK_CONTROL_FREQ This control permits direct changes to the operating frequency.
|
|
ZES_OVERCLOCK_CONTROL_VOLT_LIMIT ZesOverclockControl = 16 // ZES_OVERCLOCK_CONTROL_VOLT_LIMIT This control prevents frequencies that would push the voltage above
|
|
|
|
///< this value, typically used by V-F scanners.
|
|
|
|
ZES_OVERCLOCK_CONTROL_POWER_SUSTAINED_LIMIT ZesOverclockControl = 32 // ZES_OVERCLOCK_CONTROL_POWER_SUSTAINED_LIMIT This control changes the sustained power limit (PL1).
|
|
ZES_OVERCLOCK_CONTROL_POWER_BURST_LIMIT ZesOverclockControl = 64 // ZES_OVERCLOCK_CONTROL_POWER_BURST_LIMIT This control changes the burst power limit (PL2).
|
|
ZES_OVERCLOCK_CONTROL_POWER_PEAK_LIMIT ZesOverclockControl = 128 // ZES_OVERCLOCK_CONTROL_POWER_PEAK_LIMIT his control changes the peak power limit (PL4).
|
|
ZES_OVERCLOCK_CONTROL_ICCMAX_LIMIT ZesOverclockControl = 256 // ZES_OVERCLOCK_CONTROL_ICCMAX_LIMIT This control changes the value of IccMax..
|
|
ZES_OVERCLOCK_CONTROL_TEMP_LIMIT ZesOverclockControl = 512 // ZES_OVERCLOCK_CONTROL_TEMP_LIMIT This control changes the value of TjMax.
|
|
ZES_OVERCLOCK_CONTROL_ITD_DISABLE ZesOverclockControl = 1024 // ZES_OVERCLOCK_CONTROL_ITD_DISABLE This control permits disabling the adaptive voltage feature ITD
|
|
ZES_OVERCLOCK_CONTROL_ACM_DISABLE ZesOverclockControl = 2048 // ZES_OVERCLOCK_CONTROL_ACM_DISABLE This control permits disabling the adaptive voltage feature ACM.
|
|
ZES_OVERCLOCK_CONTROL_FORCE_UINT32 ZesOverclockControl = 0x7fffffff // ZES_OVERCLOCK_CONTROL_FORCE_UINT32 Value marking end of ZES_OVERCLOCK_CONTROL_* ENUMs
|
|
|
|
)
|
|
|
|
// ZesOverclockMode (zes_overclock_mode_t) Overclock modes.
|
|
type ZesOverclockMode uintptr
|
|
|
|
const (
|
|
ZES_OVERCLOCK_MODE_MODE_OFF ZesOverclockMode = 0 // ZES_OVERCLOCK_MODE_MODE_OFF Overclock mode is off
|
|
ZES_OVERCLOCK_MODE_MODE_STOCK ZesOverclockMode = 2 // ZES_OVERCLOCK_MODE_MODE_STOCK Stock (manufacturing settings) are being used.
|
|
ZES_OVERCLOCK_MODE_MODE_ON ZesOverclockMode = 3 // ZES_OVERCLOCK_MODE_MODE_ON Overclock mode is on.
|
|
ZES_OVERCLOCK_MODE_MODE_UNAVAILABLE ZesOverclockMode = 4 // ZES_OVERCLOCK_MODE_MODE_UNAVAILABLE Overclocking is unavailable at this time since the system is running
|
|
|
|
///< on battery.
|
|
|
|
ZES_OVERCLOCK_MODE_MODE_DISABLED ZesOverclockMode = 5 // ZES_OVERCLOCK_MODE_MODE_DISABLED Overclock mode is disabled.
|
|
ZES_OVERCLOCK_MODE_FORCE_UINT32 ZesOverclockMode = 0x7fffffff // ZES_OVERCLOCK_MODE_FORCE_UINT32 Value marking end of ZES_OVERCLOCK_MODE_* ENUMs
|
|
|
|
)
|
|
|
|
// ZesControlState (zes_control_state_t) Overclock control states.
|
|
type ZesControlState uintptr
|
|
|
|
const (
|
|
ZES_CONTROL_STATE_STATE_UNSET ZesControlState = 0 // ZES_CONTROL_STATE_STATE_UNSET No overclock control has not been changed by the driver since the last
|
|
|
|
///< boot/reset.
|
|
|
|
ZES_CONTROL_STATE_STATE_ACTIVE ZesControlState = 2 // ZES_CONTROL_STATE_STATE_ACTIVE The overclock control has been set and it is active.
|
|
ZES_CONTROL_STATE_STATE_DISABLED ZesControlState = 3 // ZES_CONTROL_STATE_STATE_DISABLED The overclock control value has been disabled due to the current power
|
|
|
|
///< configuration (typically when running on DC).
|
|
|
|
ZES_CONTROL_STATE_FORCE_UINT32 ZesControlState = 0x7fffffff // ZES_CONTROL_STATE_FORCE_UINT32 Value marking end of ZES_CONTROL_STATE_* ENUMs
|
|
|
|
)
|
|
|
|
// ZesPendingAction (zes_pending_action_t) Overclock pending actions.
|
|
type ZesPendingAction uintptr
|
|
|
|
const (
|
|
ZES_PENDING_ACTION_PENDING_NONE ZesPendingAction = 0 // ZES_PENDING_ACTION_PENDING_NONE There no pending actions. .
|
|
ZES_PENDING_ACTION_PENDING_IMMINENT ZesPendingAction = 1 // ZES_PENDING_ACTION_PENDING_IMMINENT The requested change is in progress and should complete soon.
|
|
ZES_PENDING_ACTION_PENDING_COLD_RESET ZesPendingAction = 2 // ZES_PENDING_ACTION_PENDING_COLD_RESET The requested change requires a device cold reset (hotplug, system
|
|
|
|
///< boot).
|
|
|
|
ZES_PENDING_ACTION_PENDING_WARM_RESET ZesPendingAction = 3 // ZES_PENDING_ACTION_PENDING_WARM_RESET The requested change requires a device warm reset (PCIe FLR).
|
|
ZES_PENDING_ACTION_FORCE_UINT32 ZesPendingAction = 0x7fffffff // ZES_PENDING_ACTION_FORCE_UINT32 Value marking end of ZES_PENDING_ACTION_* ENUMs
|
|
|
|
)
|
|
|
|
// ZesVfProgramType (zes_vf_program_type_t) Overclock V-F curve programing.
|
|
type ZesVfProgramType uintptr
|
|
|
|
const (
|
|
ZES_VF_PROGRAM_TYPE_VF_ARBITRARY ZesVfProgramType = 0 // ZES_VF_PROGRAM_TYPE_VF_ARBITRARY Can program an arbitrary number of V-F points up to the maximum number
|
|
|
|
///< and each point can have arbitrary voltage and frequency values within
|
|
///< the min/max/step limits
|
|
|
|
ZES_VF_PROGRAM_TYPE_VF_FREQ_FIXED ZesVfProgramType = 1 // ZES_VF_PROGRAM_TYPE_VF_FREQ_FIXED Can only program the voltage for the V-F points that it reads back -
|
|
|
|
///< the frequency of those points cannot be changed
|
|
|
|
ZES_VF_PROGRAM_TYPE_VF_VOLT_FIXED ZesVfProgramType = 2 // ZES_VF_PROGRAM_TYPE_VF_VOLT_FIXED Can only program the frequency for the V-F points that is reads back -
|
|
|
|
///< the voltage of each point cannot be changed.
|
|
|
|
ZES_VF_PROGRAM_TYPE_FORCE_UINT32 ZesVfProgramType = 0x7fffffff // ZES_VF_PROGRAM_TYPE_FORCE_UINT32 Value marking end of ZES_VF_PROGRAM_TYPE_* ENUMs
|
|
|
|
)
|
|
|
|
// ZesVfType (zes_vf_type_t) VF type
|
|
type ZesVfType uintptr
|
|
|
|
const (
|
|
ZES_VF_TYPE_VOLT ZesVfType = 0 // ZES_VF_TYPE_VOLT VF Voltage point
|
|
ZES_VF_TYPE_FREQ ZesVfType = 1 // ZES_VF_TYPE_FREQ VF Frequency point
|
|
ZES_VF_TYPE_FORCE_UINT32 ZesVfType = 0x7fffffff // ZES_VF_TYPE_FORCE_UINT32 Value marking end of ZES_VF_TYPE_* ENUMs
|
|
|
|
)
|
|
|
|
// ZesVfArrayType (zes_vf_array_type_t) VF type
|
|
type ZesVfArrayType uintptr
|
|
|
|
const (
|
|
ZES_VF_ARRAY_TYPE_USER_VF_ARRAY ZesVfArrayType = 0 // ZES_VF_ARRAY_TYPE_USER_VF_ARRAY User V-F array
|
|
ZES_VF_ARRAY_TYPE_DEFAULT_VF_ARRAY ZesVfArrayType = 1 // ZES_VF_ARRAY_TYPE_DEFAULT_VF_ARRAY Default V-F array
|
|
ZES_VF_ARRAY_TYPE_LIVE_VF_ARRAY ZesVfArrayType = 2 // ZES_VF_ARRAY_TYPE_LIVE_VF_ARRAY Live V-F array
|
|
ZES_VF_ARRAY_TYPE_FORCE_UINT32 ZesVfArrayType = 0x7fffffff // ZES_VF_ARRAY_TYPE_FORCE_UINT32 Value marking end of ZES_VF_ARRAY_TYPE_* ENUMs
|
|
|
|
)
|
|
|
|
// ZesOverclockProperties (zes_overclock_properties_t) Overclock properties
|
|
// /
|
|
// / @details
|
|
// / - Information on the overclock domain type and all the contols that are
|
|
// / part of the domain.
|
|
type ZesOverclockProperties struct {
|
|
Stype ZesStructureType // Stype [in] type of this structure
|
|
Pnext unsafe.Pointer // Pnext [in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).
|
|
Domaintype ZesOverclockDomain // Domaintype [out] The hardware block that this overclock domain controls (GPU, VRAM, ...)
|
|
Availablecontrols uint32 // Availablecontrols [out] Returns the overclock controls that are supported (a bit for each of enum ::zes_overclock_control_t). If no bits are set, the domain doesn't support overclocking.
|
|
Vfprogramtype ZesVfProgramType // Vfprogramtype [out] Type of V-F curve programming that is permitted:.
|
|
Numberofvfpoints uint32 // Numberofvfpoints [out] Number of VF points that can be programmed - max_num_points
|
|
|
|
}
|
|
|
|
// ZesControlProperty (zes_control_property_t) Overclock Control properties
|
|
// /
|
|
// / @details
|
|
// / - Provides all the control capabilities supported by the device for the
|
|
// / overclock domain.
|
|
type ZesControlProperty struct {
|
|
Minvalue float64 // Minvalue [out] This provides information about the limits of the control value so that the driver can calculate the set of valid values.
|
|
Maxvalue float64 // Maxvalue [out] This provides information about the limits of the control value so that the driver can calculate the set of valid values.
|
|
Stepvalue float64 // Stepvalue [out] This provides information about the limits of the control value so that the driver can calculate the set of valid values.
|
|
Refvalue float64 // Refvalue [out] The reference value provides the anchor point, UIs can combine this with the user offset request to show the anticipated improvement.
|
|
Defaultvalue float64 // Defaultvalue [out] The shipped out-of-box position of this control. Driver can request this value at any time to return to the out-of-box behavior.
|
|
|
|
}
|
|
|
|
// ZesVfProperty (zes_vf_property_t) Overclock VF properties
|
|
// /
|
|
// / @details
|
|
// / - Provides all the VF capabilities supported by the device for the
|
|
// / overclock domain.
|
|
type ZesVfProperty struct {
|
|
Minfreq float64 // Minfreq [out] Read the minimum frequency that can be be programmed in the custom V-F point..
|
|
Maxfreq float64 // Maxfreq [out] Read the maximum frequency that can be be programmed in the custom V-F point..
|
|
Stepfreq float64 // Stepfreq [out] Read the frequency step that can be be programmed in the custom V-F point..
|
|
Minvolt float64 // Minvolt [out] Read the minimum voltage that can be be programmed in the custom V-F point..
|
|
Maxvolt float64 // Maxvolt [out] Read the maximum voltage that can be be programmed in the custom V-F point..
|
|
Stepvolt float64 // Stepvolt [out] Read the voltage step that can be be programmed in the custom V-F point.
|
|
|
|
}
|
|
|
|
// ZesDeviceSetOverclockWaiver Set the overclock waiver.The overclock waiver setting is persistent
|
|
// / until the next pcode boot
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDevice`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / + This product does not support overclocking
|
|
func ZesDeviceSetOverclockWaiver(
|
|
hDevice ZesDeviceHandle, // hDevice [in] Sysman handle of the device.
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesDeviceSetOverclockWaiver", uintptr(hDevice))
|
|
}
|
|
|
|
// ZesDeviceGetOverclockDomains Get the list of supported overclock domains for this device
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDevice`
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
|
|
// / + `nullptr == pOverclockDomains`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / + Overclocking is not supported on this control domain
|
|
func ZesDeviceGetOverclockDomains(
|
|
hDevice ZesDeviceHandle, // hDevice [in] Sysman handle of the device.
|
|
pOverclockDomains *uint32, // pOverclockDomains [in,out] Returns the overclock domains that are supported (a bit for each of enum ::zes_overclock_domain_t). If no bits are set, the device doesn't support overclocking.
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesDeviceGetOverclockDomains", uintptr(hDevice), uintptr(unsafe.Pointer(pOverclockDomains)))
|
|
}
|
|
|
|
// ZesDeviceGetOverclockControls Get the list of supported overclock controls available for one of the
|
|
// / supported overclock domains on the device
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDevice`
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
|
|
// / + `::ZES_OVERCLOCK_DOMAIN_ADM < domainType`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
|
|
// / + `nullptr == pAvailableControls`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / + Overclocking is not supported on this control domain
|
|
func ZesDeviceGetOverclockControls(
|
|
hDevice ZesDeviceHandle, // hDevice [in] Sysman handle of the device.
|
|
domainType ZesOverclockDomain, // domainType [in] Domain type.
|
|
pAvailableControls *uint32, // pAvailableControls [in,out] Returns the overclock controls that are supported for the specified overclock domain (a bit for each of enum ::zes_overclock_control_t).
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesDeviceGetOverclockControls", uintptr(hDevice), uintptr(domainType), uintptr(unsafe.Pointer(pAvailableControls)))
|
|
}
|
|
|
|
// ZesDeviceResetOverclockSettings Reset all overclock settings to default values (shipped = 1 or
|
|
// / manufacturing =0)
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDevice`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / + Overclocking is not supported on this control domain
|
|
func ZesDeviceResetOverclockSettings(
|
|
hDevice ZesDeviceHandle, // hDevice [in] Sysman handle of the device.
|
|
onShippedState ZeBool, // onShippedState [in] True will reset to shipped state; false will reset to manufacturing state
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesDeviceResetOverclockSettings", uintptr(hDevice), uintptr(onShippedState))
|
|
}
|
|
|
|
// ZesDeviceReadOverclockState Determine the state of overclocking
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDevice`
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
|
|
// / + `nullptr == pOverclockMode`
|
|
// / + `nullptr == pWaiverSetting`
|
|
// / + `nullptr == pOverclockState`
|
|
// / + `nullptr == pPendingAction`
|
|
// / + `nullptr == pPendingReset`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / + Overclocking is not supported on this control domain
|
|
func ZesDeviceReadOverclockState(
|
|
hDevice ZesDeviceHandle, // hDevice [in] Sysman handle of the device.
|
|
pOverclockMode *ZesOverclockMode, // pOverclockMode [out] One of overclock mode.
|
|
pWaiverSetting *ZeBool, // pWaiverSetting [out] Waiver setting: 0 = Waiver not set, 1 = waiver has been set.
|
|
pOverclockState *ZeBool, // pOverclockState [out] Current settings 0 =manufacturing state, 1= shipped state)..
|
|
pPendingAction *ZesPendingAction, // pPendingAction [out] This enum is returned when the driver attempts to set an overclock control or reset overclock settings.
|
|
pPendingReset *ZeBool, // pPendingReset [out] Pending reset 0 =manufacturing state, 1= shipped state)..
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesDeviceReadOverclockState", uintptr(hDevice), uintptr(unsafe.Pointer(pOverclockMode)), uintptr(unsafe.Pointer(pWaiverSetting)), uintptr(unsafe.Pointer(pOverclockState)), uintptr(unsafe.Pointer(pPendingAction)), uintptr(unsafe.Pointer(pPendingReset)))
|
|
}
|
|
|
|
// ZesDeviceEnumOverclockDomains Get handle of overclock domains
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDevice`
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
|
|
// / + `nullptr == pCount`
|
|
func ZesDeviceEnumOverclockDomains(
|
|
hDevice ZesDeviceHandle, // hDevice [in] Sysman handle of the device.
|
|
pCount *uint32, // pCount [in,out] pointer to the number of components of this type. if count is zero, then the driver shall update the value with the total number of components of this type that are available. if count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.
|
|
phDomainHandle *ZesOverclockHandle, // phDomainHandle [in,out][optional][range(0, *pCount)] array of handle of components of this type. if count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesDeviceEnumOverclockDomains", uintptr(hDevice), uintptr(unsafe.Pointer(pCount)), uintptr(unsafe.Pointer(phDomainHandle)))
|
|
}
|
|
|
|
// ZesOverclockGetDomainProperties Get overclock domain control properties
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDomainHandle`
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
|
|
// / + `nullptr == pDomainProperties`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / + Overclocking is not supported on this control domain
|
|
func ZesOverclockGetDomainProperties(
|
|
hDomainHandle ZesOverclockHandle, // hDomainHandle [in] Handle for the component domain.
|
|
pDomainProperties *ZesOverclockProperties, // pDomainProperties [in,out] The overclock properties for the specified domain.
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesOverclockGetDomainProperties", uintptr(hDomainHandle), uintptr(unsafe.Pointer(pDomainProperties)))
|
|
}
|
|
|
|
// ZesOverclockGetDomainVFProperties Read overclock VF min,max and step values
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDomainHandle`
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
|
|
// / + `nullptr == pVFProperties`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / + Overclocking is not supported on this control domain
|
|
func ZesOverclockGetDomainVFProperties(
|
|
hDomainHandle ZesOverclockHandle, // hDomainHandle [in] Handle for the component domain.
|
|
pVFProperties *ZesVfProperty, // pVFProperties [in,out] The VF min,max,step for a specified domain.
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesOverclockGetDomainVFProperties", uintptr(hDomainHandle), uintptr(unsafe.Pointer(pVFProperties)))
|
|
}
|
|
|
|
// ZesOverclockGetDomainControlProperties Read overclock control values - min/max/step/default/ref
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDomainHandle`
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
|
|
// / + `::ZES_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
|
|
// / + `nullptr == pControlProperties`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / + Overclocking is not supported on this control domain
|
|
func ZesOverclockGetDomainControlProperties(
|
|
hDomainHandle ZesOverclockHandle, // hDomainHandle [in] Handle for the component domain.
|
|
DomainControl ZesOverclockControl, // DomainControl [in] Handle for the component.
|
|
pControlProperties *ZesControlProperty, // pControlProperties [in,out] overclock control values.
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesOverclockGetDomainControlProperties", uintptr(hDomainHandle), uintptr(DomainControl), uintptr(unsafe.Pointer(pControlProperties)))
|
|
}
|
|
|
|
// ZesOverclockGetControlCurrentValue Read the current value for a given overclock control
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDomainHandle`
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
|
|
// / + `::ZES_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
|
|
// / + `nullptr == pValue`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / + Overclocking is not supported on this control domain
|
|
func ZesOverclockGetControlCurrentValue(
|
|
hDomainHandle ZesOverclockHandle, // hDomainHandle [in] Handle for the component.
|
|
DomainControl ZesOverclockControl, // DomainControl [in] Overclock Control.
|
|
pValue *float64, // pValue [in,out] Getting overclock control value for the specified control.
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesOverclockGetControlCurrentValue", uintptr(hDomainHandle), uintptr(DomainControl), uintptr(unsafe.Pointer(pValue)))
|
|
}
|
|
|
|
// ZesOverclockGetControlPendingValue Read the the reset pending value for a given overclock control
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDomainHandle`
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
|
|
// / + `::ZES_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
|
|
// / + `nullptr == pValue`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / + Overclocking is not supported on this control domain
|
|
func ZesOverclockGetControlPendingValue(
|
|
hDomainHandle ZesOverclockHandle, // hDomainHandle [in] Handle for the component domain.
|
|
DomainControl ZesOverclockControl, // DomainControl [in] Overclock Control.
|
|
pValue *float64, // pValue [out] Returns the pending value for a given control. The units and format of the value depend on the control type.
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesOverclockGetControlPendingValue", uintptr(hDomainHandle), uintptr(DomainControl), uintptr(unsafe.Pointer(pValue)))
|
|
}
|
|
|
|
// ZesOverclockSetControlUserValue Set the value for a given overclock control
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDomainHandle`
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
|
|
// / + `::ZES_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
|
|
// / + `nullptr == pPendingAction`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / + Overclocking is not supported on this control domain
|
|
func ZesOverclockSetControlUserValue(
|
|
hDomainHandle ZesOverclockHandle, // hDomainHandle [in] Handle for the component domain.
|
|
DomainControl ZesOverclockControl, // DomainControl [in] Domain Control.
|
|
pValue float64, // pValue [in] The new value of the control. The units and format of the value depend on the control type.
|
|
pPendingAction *ZesPendingAction, // pPendingAction [out] Pending overclock setting.
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesOverclockSetControlUserValue", uintptr(hDomainHandle), uintptr(DomainControl), uintptr(pValue), uintptr(unsafe.Pointer(pPendingAction)))
|
|
}
|
|
|
|
// ZesOverclockGetControlState Determine the state of an overclock control
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDomainHandle`
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
|
|
// / + `::ZES_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
|
|
// / + `nullptr == pControlState`
|
|
// / + `nullptr == pPendingAction`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / + Overclocking is not supported on this control domain
|
|
func ZesOverclockGetControlState(
|
|
hDomainHandle ZesOverclockHandle, // hDomainHandle [in] Handle for the component domain.
|
|
DomainControl ZesOverclockControl, // DomainControl [in] Domain Control.
|
|
pControlState *ZesControlState, // pControlState [out] Current overclock control state.
|
|
pPendingAction *ZesPendingAction, // pPendingAction [out] Pending overclock setting.
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesOverclockGetControlState", uintptr(hDomainHandle), uintptr(DomainControl), uintptr(unsafe.Pointer(pControlState)), uintptr(unsafe.Pointer(pPendingAction)))
|
|
}
|
|
|
|
// ZesOverclockGetVFPointValues Read the frequency or voltage of a V-F point from the default or
|
|
// / custom V-F curve.
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDomainHandle`
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
|
|
// / + `::ZES_VF_TYPE_FREQ < VFType`
|
|
// / + `::ZES_VF_ARRAY_TYPE_LIVE_VF_ARRAY < VFArrayType`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
|
|
// / + `nullptr == PointValue`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / + Overclocking is not supported on this control domain
|
|
func ZesOverclockGetVFPointValues(
|
|
hDomainHandle ZesOverclockHandle, // hDomainHandle [in] Handle for the component domain.
|
|
VFType ZesVfType, // VFType [in] Voltage or Freqency point to read.
|
|
VFArrayType ZesVfArrayType, // VFArrayType [in] User,Default or Live VF array to read from
|
|
PointIndex uint32, // PointIndex [in] Point index - number between (0, max_num_points - 1).
|
|
PointValue *uint32, // PointValue [out] Returns the frequency in 1kHz units or voltage in millivolt units from the custom V-F curve at the specified zero-based index
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesOverclockGetVFPointValues", uintptr(hDomainHandle), uintptr(VFType), uintptr(VFArrayType), uintptr(PointIndex), uintptr(unsafe.Pointer(PointValue)))
|
|
}
|
|
|
|
// ZesOverclockSetVFPointValues Write the frequency or voltage of a V-F point to custom V-F curve.
|
|
// /
|
|
// / @details
|
|
// / - The application may call this function from simultaneous threads.
|
|
// / - The implementation of this function should be lock-free.
|
|
// /
|
|
// / @returns
|
|
// / - ::ZE_RESULT_SUCCESS
|
|
// / - ::ZE_RESULT_ERROR_UNINITIALIZED
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_LOST
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
|
|
// / - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
|
|
// / - ::ZE_RESULT_ERROR_NOT_AVAILABLE
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
|
|
// / - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
|
|
// / - ::ZE_RESULT_ERROR_UNKNOWN
|
|
// / - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
|
|
// / + `nullptr == hDomainHandle`
|
|
// / - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
|
|
// / + `::ZES_VF_TYPE_FREQ < VFType`
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION
|
|
// / - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
|
|
// / + Overclocking is not supported on this control domain
|
|
func ZesOverclockSetVFPointValues(
|
|
hDomainHandle ZesOverclockHandle, // hDomainHandle [in] Handle for the component domain.
|
|
VFType ZesVfType, // VFType [in] Voltage or Freqency point to read.
|
|
PointIndex uint32, // PointIndex [in] Point index - number between (0, max_num_points - 1).
|
|
PointValue uint32, // PointValue [in] Writes frequency in 1kHz units or voltage in millivolt units to custom V-F curve at the specified zero-based index
|
|
) (ZeResult, error) {
|
|
return zecall.Call[ZeResult]("zesOverclockSetVFPointValues", uintptr(hDomainHandle), uintptr(VFType), uintptr(PointIndex), uintptr(PointValue))
|
|
}
|