mbltml.py Source File

mbltml.py Source File#

mbltml: mbltml.py Source File
mbltml v1.4
mbltml — KR
 
import os
import glob
import platform
from ctypes import *
from pathlib import Path
from typing import List
 
 
MBLTML_DRIVER_VERSION_BUFFER_SIZE = 80
MBLTML_ON_DEVICE_DRIVER_VERSION_BUFFER_SIZE = 80
MBLTML_FIRMWARE_VERSION_BUFFER_SIZE = 80
MBLTML_NODE_NAME_BUFFER_SIZE = 80
 
mbltmlDriverType_t = c_uint
MBLTML_DRIVER_ERROR = 0x0  
MBLTML_DRIVER_ARIES = 0x1  
MBLTML_DRIVER_REGULUS = 0x2  
MBLTML_DRIVER_REGULUS_USB = 0x4  
 
mbltmlTargetDeviceType_t = c_uint
MBLTML_TARGET_DEVICE_ARIES_RA = 0x00000001  
MBLTML_TARGET_DEVICE_REGULUS_RA = 0x00000002  
MBLTML_TARGET_DEVICE_ARIES_RB = 0x00000003  
MBLTML_TARGET_DEVICE_REGULUS_RB = 0x00000004  
MBLTML_TARGET_DEVICE_REGULUS_RA_USB = 0x00000005  
MBLTML_TARGET_DEVICE_REGULUS_RB_USB = 0x00000006  
MBLTML_TARGET_DEVICE_ERROR = 0x7FFFFFFF  
 
mbltmlStatusCode_t = c_uint
MBLTML_SUCCESS = 0  
MBLTML_DRIVER_NOT_FOUND = 2  
MBLTML_INVALID_ARGUMENT = 3  
MBLTML_UNINITIALIZED = 1  
MBLTML_NOT_SUPPORTED = 4  
MBLTML_INSUFFICIENT_LENGTH = 5  
MBLTML_DEVICE_NOT_FOUND = 6  
 
mbltmlExtraPmicId_t = c_uint
MBLTML_EXTRA_PMIC_ID_NPU = 0  
MBLTML_EXTRA_PMIC_ID_DDR = 1  
MBLTML_EXTRA_PMIC_ID_PMIC = 2  
MBLTML_EXTRA_PMIC_ID_GOLDFINGER = 3  
 
mbltmlCluster_t = c_uint
MBLTML_CLUSTER_0 = 0x00010000  
MBLTML_CLUSTER_1 = 0x00020000  
MBLTML_CLUSTER_ERROR = 0x7FFF0000  
 
mbltmlCore_t = c_uint
MBLTML_CORE_0 = 1  
MBLTML_CORE_1 = 2  
MBLTML_CORE_2 = 3  
MBLTML_CORE_3 = 4  
MBLTML_CORE_GLOBAL = 0x0000FFFE  
MBLTML_CORE_ERROR = 0x0000FFFF  
 
 
# Classes
class mbltmlCoreId_t(Structure):
    """@brief Composite identifier of an NPU core (cluster + core).
 
    @var cluster Cluster to which the core belongs (mbltmlCluster_t).
    @var core    Core within the cluster (mbltmlCore_t).
    """
 
    cluster: mbltmlCluster_t
    core: mbltmlCore_t
    _fields_ = [
        ("cluster", mbltmlCluster_t),
        ("core", mbltmlCore_t),
    ]
 
    def __repr__(self):
        d = {"cluster": self.cluster, "core": self.core}
        return "{}({})".format(
            self.__class__.__name__,
            ", ".join("{}={}".format(k, v) for k, v in d.items()),
        )
 
 
class mbltmlCoreInfo_t(Structure):
    """@brief Per-core usage record returned by mbltmlGetCoreInfos().
 
    Utilization for the core can be computed as @c npu_time / @c interval
    when @c interval is non-zero.
 
    @var core_id  Identifier of the core (mbltmlCoreId_t).
    @var npu_time Accumulated NPU active time on the core, in microseconds.
    @var interval Sampling interval covered by @c npu_time, in microseconds.
    """
 
    core_id: mbltmlCoreId_t
    npu_time: c_int64
    interval: c_int64
    _fields_ = [
        ("core_id", mbltmlCoreId_t),
        ("npu_time", c_int64),
        ("interval", c_int64),
    ]
 
    def __repr__(self):
        d = {
            "core_id": self.core_id,
            "npu_time": self.npu_time,
            "interval": self.interval,
        }
        return "{}({})".format(
            self.__class__.__name__,
            ", ".join("{}={}".format(k, v) for k, v in d.items()),
        )
 
 
class mbltmlProcessInfo_t(Structure):
    """@brief Per-process usage record returned by mbltmlGetProcessInfos().
 
    Utilization for the process can be computed as
    @c total_npu_time_us / @c total_interval_us when @c total_interval_us
    is non-zero.
 
    @var pid               Process ID.
    @var counts            Number of NPU samples attributed to the process.
    @var npu_memory_usage  Device memory currently used by the process, in bytes.
    @var total_interval_us Total sampling interval, in microseconds.
    @var total_npu_time_us Total NPU active time used by the process, in microseconds.
    """
 
    pid: c_int
    counts: c_int
    npu_memory_usage: c_int64
    total_interval_us: c_int64
    total_npu_time_us: c_int64
    _fields_ = [
        ("pid", c_int),
        ("counts", c_int),
        ("npu_memory_usage", c_int64),
        ("total_interval_us", c_int64),
        ("total_npu_time_us", c_int64),
    ]
 
    def __repr__(self):
        d = {
            "pid": self.pid,
            "counts": self.counts,
            "npu_memory_usage": self.npu_memory_usage,
            "total_interval_us": self.total_interval_us,
            "total_npu_time_us": self.total_npu_time_us,
        }
        return "{}({})".format(
            self.__class__.__name__,
            ", ".join("{}={}".format(k, v) for k, v in d.items()),
        )
 
 
_clib = None
 
 
def _loadLibrary() -> None:
    global _clib
    if _clib != None:
        return
    lib_fname = "mbltml.dll" if platform.system() == "Windows" else f"libmbltml.so*"
    pattern = os.path.join(Path(__file__).resolve().parent, lib_fname)
    candidates = glob.glob(pattern)
    if not candidates:
        raise FileNotFoundError(f"No library matching {pattern}")
    candidates.sort(key=len, reverse=True)
    _clib = CDLL(str(candidates[0]))
 
    _clib.mbltmlInit.argtypes = []
    _clib.mbltmlInit.restype = mbltmlStatusCode_t
    _clib.mbltmlShutdown.argtypes = []
    _clib.mbltmlShutdown.restype = mbltmlStatusCode_t
    _clib.mbltmlGetDeviceCount.argtypes = [POINTER(c_uint)]
    _clib.mbltmlGetDeviceCount.restype = mbltmlStatusCode_t
    _clib.mbltmlGetTargetDeviceCount.argtypes = [
        mbltmlTargetDeviceType_t,
        POINTER(c_uint),
    ]
    _clib.mbltmlGetTargetDeviceCount.restype = mbltmlStatusCode_t
    _clib.mbltmlGetDriverVersion.argtypes = [mbltmlDriverType_t, POINTER(c_char), c_int]
    _clib.mbltmlGetDriverVersion.restype = mbltmlStatusCode_t
    _clib.mbltmlGetDriverRevision.argtypes = [mbltmlDriverType_t, POINTER(c_uint)]
    _clib.mbltmlGetDriverRevision.restype = mbltmlStatusCode_t
    _clib.mbltmlGetNodeName.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_char),
        c_int,
    ]
    _clib.mbltmlGetNodeName.restype = mbltmlStatusCode_t
    _clib.mbltmlGetDriverType.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(mbltmlDriverType_t),
    ]
    _clib.mbltmlGetDriverType.restype = mbltmlStatusCode_t
    _clib.mbltmlGetOnDeviceDriverVersion.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_char),
        c_uint,
    ]
    _clib.mbltmlGetOnDeviceDriverVersion.restype = mbltmlStatusCode_t
    _clib.mbltmlGetOnDeviceDriverRevision.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_uint),
    ]
    _clib.mbltmlGetOnDeviceDriverRevision.restype = mbltmlStatusCode_t
    _clib.mbltmlGetFirmwareVersion.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_char),
        c_uint,
    ]
    _clib.mbltmlGetFirmwareVersion.restype = mbltmlStatusCode_t
    _clib.mbltmlGetFirmwareRevision.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_uint),
    ]
    _clib.mbltmlGetFirmwareRevision.restype = mbltmlStatusCode_t
    _clib.mbltmlGetFirmwareCRC.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_uint),
    ]
    _clib.mbltmlGetFirmwareCRC.restype = mbltmlStatusCode_t
    _clib.mbltmlGetTemperature.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_int),
    ]
    _clib.mbltmlGetTemperature.restype = mbltmlStatusCode_t
    _clib.mbltmlGetSignalType.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_uint),
    ]
    _clib.mbltmlGetSignalType.restype = mbltmlStatusCode_t
    _clib.mbltmlGetNPUClock.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_uint),
    ]
    _clib.mbltmlGetNPUClock.restype = mbltmlStatusCode_t
    _clib.mbltmlGetBusClock.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_uint),
    ]
    _clib.mbltmlGetBusClock.restype = mbltmlStatusCode_t
    _clib.mbltmlGetFanDuty.argtypes = [mbltmlTargetDeviceType_t, c_int, POINTER(c_int)]
    _clib.mbltmlGetFanDuty.restype = mbltmlStatusCode_t
    _clib.mbltmlGetVendorId.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_uint),
    ]
    _clib.mbltmlGetVendorId.restype = mbltmlStatusCode_t
    _clib.mbltmlGetDeviceId.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_uint),
    ]
    _clib.mbltmlGetDeviceId.restype = mbltmlStatusCode_t
    _clib.mbltmlGetSubVendorId.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_uint),
    ]
    _clib.mbltmlGetSubVendorId.restype = mbltmlStatusCode_t
    _clib.mbltmlGetSubDeviceId.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_uint),
    ]
    _clib.mbltmlGetSubDeviceId.restype = mbltmlStatusCode_t
    _clib.mbltmlGetPcieGen.argtypes = [mbltmlTargetDeviceType_t, c_int, POINTER(c_uint)]
    _clib.mbltmlGetPcieGen.restype = mbltmlStatusCode_t
    _clib.mbltmlGetPcieLanes.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_uint),
    ]
    _clib.mbltmlGetPcieLanes.restype = mbltmlStatusCode_t
    _clib.mbltmlGetPcieRev.argtypes = [mbltmlTargetDeviceType_t, c_int, POINTER(c_uint)]
    _clib.mbltmlGetPcieRev.restype = mbltmlStatusCode_t
    _clib.mbltmlGetPcieClassCode.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_uint),
    ]
    _clib.mbltmlGetPcieClassCode.restype = mbltmlStatusCode_t
    _clib.mbltmlGetTotalPower.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_double),
    ]
    _clib.mbltmlGetTotalPower.restype = mbltmlStatusCode_t
    _clib.mbltmlGetTotalCurrent.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_double),
    ]
    _clib.mbltmlGetTotalCurrent.restype = mbltmlStatusCode_t
    _clib.mbltmlGetTotalVoltage.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_double),
    ]
    _clib.mbltmlGetTotalVoltage.restype = mbltmlStatusCode_t
    _clib.mbltmlGetExtraPmicPower.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_double),
    ]
    _clib.mbltmlGetExtraPmicPower.restype = mbltmlStatusCode_t
    _clib.mbltmlGetExtraPmicCurrent.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_double),
    ]
    _clib.mbltmlGetExtraPmicCurrent.restype = mbltmlStatusCode_t
    _clib.mbltmlGetExtraPmicVoltage.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_double),
    ]
    _clib.mbltmlGetExtraPmicVoltage.restype = mbltmlStatusCode_t
    _clib.mbltmlGetExtraPmicId.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(mbltmlExtraPmicId_t),
    ]
    _clib.mbltmlGetExtraPmicId.restype = mbltmlStatusCode_t
    _clib.mbltmlGetTotalUtilization.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_double),
    ]
    _clib.mbltmlGetTotalUtilization.restype = mbltmlStatusCode_t
    _clib.mbltmlGetMemoryUsage.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_int64),
    ]
    _clib.mbltmlGetMemoryUsage.restype = mbltmlStatusCode_t
    _clib.mbltmlGetMemoryTotal.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(c_int64),
    ]
    _clib.mbltmlGetMemoryTotal.restype = mbltmlStatusCode_t
    _clib.mbltmlGetProcessInfos.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(mbltmlProcessInfo_t),
        POINTER(c_uint),
    ]
    _clib.mbltmlGetProcessInfos.restype = mbltmlStatusCode_t
    _clib.mbltmlGetCoreInfos.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        POINTER(mbltmlCoreInfo_t),
        POINTER(c_uint),
    ]
    _clib.mbltmlGetCoreInfos.restype = mbltmlStatusCode_t
    _clib.mbltmlSetExtraPmicID.argtypes = [
        mbltmlTargetDeviceType_t,
        c_int,
        mbltmlExtraPmicId_t,
    ]
    _clib.mbltmlSetExtraPmicID.restype = mbltmlStatusCode_t
 
 
class MBLTMLError(Exception):
    """@brief Base exception raised by the mbltml Python binding.
 
    Wraps a non-success mbltmlStatusCode_t returned by the underlying C
    library. Instantiating MBLTMLError with a known status code yields the
    matching subclass (e.g., MBLTMLInvalidArgumentError).
 
    @var code The mbltmlStatusCode_t value associated with this exception.
    """
 
    _code_to_class = {}
    _errcode_to_string = {
        MBLTML_DRIVER_NOT_FOUND: "Driver is not found",
        MBLTML_INVALID_ARGUMENT: "Invalid Argument",
        MBLTML_UNINITIALIZED: "Uninitilized mbltml.",
        MBLTML_NOT_SUPPORTED: "Unspported Function for Target Device",
        MBLTML_INSUFFICIENT_LENGTH: "Insufficient Length",
        MBLTML_DEVICE_NOT_FOUND: "Device is not found",
    }
 
    def __new__(cls, code: mbltmlStatusCode_t):
        if cls is MBLTMLError and code in MBLTMLError._code_to_class:
            cls = MBLTMLError._code_to_class[code]
        obj = Exception.__new__(cls)
        obj.code = code
        return obj
 
    def __str__(self):
        return MBLTMLError._errcode_to_string[self.code]
 
    def __eq__(self, other):
        return self.code == other.code
 
 
class MBLTMLDriverNotFoundError(MBLTMLError):
    """@brief Raised when the required driver cannot be located.
 
    Wraps MBLTML_DRIVER_NOT_FOUND.
    """
 
    pass
 
 
class MBLTMLInvalidArgumentError(MBLTMLError):
    """@brief Raised when one or more arguments are invalid.
 
    Wraps MBLTML_INVALID_ARGUMENT. Typical causes include a NULL pointer or
    a @c dev_no that is out of range of the target device type's device count.
    """
 
    pass
 
 
class MBLTMLUninitializedError(MBLTMLError):
    """@brief Raised when an API is called before initialization.
 
    Wraps MBLTML_UNINITIALIZED. Call mbltmlInit() first.
    """
 
    pass
 
 
class MBLTMLNotSupportedError(MBLTMLError):
    """@brief Raised when the feature is not supported on the target device.
 
    Wraps MBLTML_NOT_SUPPORTED.
    """
 
    pass
 
 
class MBLTMLInsufficientLengthError(MBLTMLError):
    """@brief Raised when the output buffer is too small to hold the result.
 
    Wraps MBLTML_INSUFFICIENT_LENGTH.
    """
 
    pass
 
 
class MBLTMLDeviceNotFoundError(MBLTMLError):
    """@brief Raised when the requested device cannot be located.
 
    Wraps MBLTML_DEVICE_NOT_FOUND.
    """
 
    pass
 
 
MBLTMLError._code_to_class = {
    MBLTML_DRIVER_NOT_FOUND: MBLTMLDriverNotFoundError,
    MBLTML_INVALID_ARGUMENT: MBLTMLInvalidArgumentError,
    MBLTML_UNINITIALIZED: MBLTMLUninitializedError,
    MBLTML_NOT_SUPPORTED: MBLTMLNotSupportedError,
    MBLTML_INSUFFICIENT_LENGTH: MBLTMLInsufficientLengthError,
    MBLTML_DEVICE_NOT_FOUND: MBLTMLDeviceNotFoundError,
}
 
 
def _mbltmlThrowError(ret: mbltmlStatusCode_t) -> None:
    if ret != MBLTML_SUCCESS:
        raise MBLTMLError(ret)
 
 
# Function calls
def mbltmlInit() -> None:
    """@brief Initialize the mbltml library.
 
    @throws MBLTMLError on failure.
    """
    _loadLibrary()
    ret = _clib.mbltmlInit()
    _mbltmlThrowError(ret)
 
 
def mbltmlShutdown() -> None:
    """@brief Release all resources held by the mbltml library.
 
    After this call, any further API usage requires re-initialization via
    mbltmlInit().
 
    @throws MBLTMLError on failure.
    """
    _loadLibrary()
    ret = _clib.mbltmlShutdown()
    _mbltmlThrowError(ret)
 
 
def mbltmlGetDeviceCount() -> int:
    """@brief Get the total number of devices detected by the library.
 
    @note Supported on all driver types.
 
    This returns the number of all detected devices regardless of their target
    device type, including devices whose target device type could not be
    identified.
 
    @attention Do not confuse this with mbltmlGetTargetDeviceCount(). Since
    unidentified devices are not addressable by any (target_device_type,
    dev_no) pair, this count may exceed the sum over every
    mbltmlTargetDeviceType_t.
 
    @return The number of devices detected.
    @throws MBLTMLError on failure.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetDeviceCount(byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetTargetDeviceCount(target_device_type: mbltmlTargetDeviceType_t) -> int:
    """@brief Get the number of detected devices of a specific target device type.
 
    @note Supported on all driver types.
 
    @param target_device_type Target device type whose device count is queried.
    @return The number of devices of @p target_device_type detected, or 0 if
            none is detected.
    @throws MBLTMLError on failure.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetTargetDeviceCount(target_device_type, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetDriverVersion(driver_type: mbltmlDriverType_t) -> str:
    """@brief Get the driver version string for a specific driver.
 
    @note Supported on all driver types.
 
    @param driver_type Driver type whose driver version is queried.
    @return The driver version string.
    @throws MBLTMLError on failure.
    """
    _loadLibrary()
    buf = create_string_buffer(MBLTML_DRIVER_VERSION_BUFFER_SIZE)
    ret = _clib.mbltmlGetDriverVersion(
        driver_type, buf, MBLTML_DRIVER_VERSION_BUFFER_SIZE
    )
    _mbltmlThrowError(ret)
    return buf.value.decode()
 
 
def mbltmlGetDriverRevision(driver_type: mbltmlDriverType_t) -> int:
    """@brief Get the driver revision number for a specific driver.
 
    @note Supported on all driver types.
 
    @param driver_type Driver type whose driver revision is queried.
    @return The driver revision number.
    @throws MBLTMLError on failure.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetDriverRevision(driver_type, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetNodeName(target_device_type: mbltmlTargetDeviceType_t, dev_no: int) -> str:
    """@brief Get the node name of a device.
 
    @note Supported on all driver types.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The node name string.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    buf = create_string_buffer(MBLTML_NODE_NAME_BUFFER_SIZE)
    ret = _clib.mbltmlGetNodeName(
        target_device_type, dev_no, buf, MBLTML_NODE_NAME_BUFFER_SIZE
    )
    _mbltmlThrowError(ret)
    return buf.value.decode()
 
 
def mbltmlGetDriverType(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> mbltmlDriverType_t:
    """@brief Get the driver type of a device.
 
    @note Supported on all driver types.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The mbltmlDriverType_t of the device.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetDriverType(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetOnDeviceDriverVersion(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> str:
    """@brief Get the on-device driver version string of a device.
 
    @note Supported on MBLTML_DRIVER_REGULUS_USB only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The on-device driver version string.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    buf = create_string_buffer(MBLTML_ON_DEVICE_DRIVER_VERSION_BUFFER_SIZE)
    ret = _clib.mbltmlGetOnDeviceDriverVersion(
        target_device_type, dev_no, buf, MBLTML_ON_DEVICE_DRIVER_VERSION_BUFFER_SIZE
    )
    _mbltmlThrowError(ret)
    return buf.value.decode()
 
 
def mbltmlGetOnDeviceDriverRevision(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> int:
    """@brief Get the on-device driver revision number of a device.
 
    @note Supported on MBLTML_DRIVER_REGULUS_USB only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The on-device driver revision.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetOnDeviceDriverRevision(
        target_device_type, dev_no, byref(value)
    )
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetFirmwareVersion(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> str:
    """@brief Get the firmware version string of a device.
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The firmware version string.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    buf = create_string_buffer(MBLTML_FIRMWARE_VERSION_BUFFER_SIZE)
    ret = _clib.mbltmlGetFirmwareVersion(
        target_device_type, dev_no, buf, MBLTML_FIRMWARE_VERSION_BUFFER_SIZE
    )
    _mbltmlThrowError(ret)
    return buf.value.decode()
 
 
def mbltmlGetFirmwareRevision(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> int:
    """@brief Get the firmware revision number of a device.
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The firmware revision.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetFirmwareRevision(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetFirmwareCRC(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> int:
    """@brief Get the CRC of the currently-loaded firmware image.
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The firmware CRC.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetFirmwareCRC(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetTemperature(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> int:
    """@brief Get the current die temperature of a device.
 
    @note Supported on all driver types.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The temperature reading.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_int()
    ret = _clib.mbltmlGetTemperature(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetSignalType(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> int:
    """@brief Get the current signal-type indicator reported by the device.
 
    @note Supported on all driver types.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The signal-type value.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetSignalType(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetNPUClock(target_device_type: mbltmlTargetDeviceType_t, dev_no: int) -> int:
    """@brief Get the current NPU clock frequency of a device.
 
    @note Supported on all driver types.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The NPU clock value.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetNPUClock(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetBusClock(target_device_type: mbltmlTargetDeviceType_t, dev_no: int) -> int:
    """@brief Get the current bus clock frequency of a device.
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The bus clock value.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetBusClock(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetFanDuty(target_device_type: mbltmlTargetDeviceType_t, dev_no: int) -> int:
    """@brief Get the current cooling-fan duty cycle of a device.
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The fan duty value.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_int()
    ret = _clib.mbltmlGetFanDuty(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetVendorId(target_device_type: mbltmlTargetDeviceType_t, dev_no: int) -> int:
    """@brief Get the PCIe vendor ID of a device.
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The vendor ID.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetVendorId(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetDeviceId(target_device_type: mbltmlTargetDeviceType_t, dev_no: int) -> int:
    """@brief Get the PCIe device ID of a device.
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The device ID.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetDeviceId(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetSubVendorId(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> int:
    """@brief Get the PCIe subsystem vendor ID of a device.
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The subsystem vendor ID.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetSubVendorId(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetSubDeviceId(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> int:
    """@brief Get the PCIe subsystem device ID of a device.
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The subsystem device ID.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetSubDeviceId(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetPcieGen(target_device_type: mbltmlTargetDeviceType_t, dev_no: int) -> int:
    """@brief Get the negotiated PCIe link generation of a device.
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The PCIe generation.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetPcieGen(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetPcieLanes(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> int:
    """@brief Get the negotiated PCIe link width (in lanes) of a device.
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The lane count.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetPcieLanes(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetPcieRev(target_device_type: mbltmlTargetDeviceType_t, dev_no: int) -> int:
    """@brief Get the PCIe configuration-space revision ID of a device.
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The revision value.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetPcieRev(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetPcieClassCode(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> int:
    """@brief Get the PCIe configuration-space class code of a device.
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The class code.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetPcieClassCode(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetTotalPower(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> float:
    """@brief Get the total instantaneous power consumption of a device (W).
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The power reading.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_double()
    ret = _clib.mbltmlGetTotalPower(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetTotalCurrent(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> float:
    """@brief Get the total instantaneous current draw of a device (A).
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The current reading.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_double()
    ret = _clib.mbltmlGetTotalCurrent(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetTotalVoltage(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> float:
    """@brief Get the total instantaneous supply voltage of a device (V).
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The voltage reading.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_double()
    ret = _clib.mbltmlGetTotalVoltage(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetExtraPmicPower(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> float:
    """@brief Get the power consumption of the extra PMIC rail currently
           selected for the device (W).
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    The selected rail is controlled by mbltmlSetExtraPmicID() and can be
    queried via mbltmlGetExtraPmicId().
 
    The firmware refreshes this reading once per second. After changing the
    selected rail with mbltmlSetExtraPmicID(), allow up to 1 second for the
    new rail's value to be reported.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The power reading.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_double()
    ret = _clib.mbltmlGetExtraPmicPower(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetExtraPmicCurrent(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> float:
    """@brief Get the current of the extra PMIC rail currently selected
           for the device (A).
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    The firmware refreshes this reading once per second. After changing the
    selected rail with mbltmlSetExtraPmicID(), allow up to 1 second for the
    new rail's value to be reported.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The current reading.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_double()
    ret = _clib.mbltmlGetExtraPmicCurrent(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetExtraPmicVoltage(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> float:
    """@brief Get the voltage of the extra PMIC rail currently selected
           for the device (V).
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    The firmware refreshes this reading once per second. After changing the
    selected rail with mbltmlSetExtraPmicID(), allow up to 1 second for the
    new rail's value to be reported.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The voltage reading.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_double()
    ret = _clib.mbltmlGetExtraPmicVoltage(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetExtraPmicId(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> mbltmlExtraPmicId_t:
    """@brief Get the extra PMIC rail currently selected for the device.
 
    @note Supported on MBLTML_DRIVER_ARIES only.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The selected mbltmlExtraPmicId_t value.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetExtraPmicId(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetTotalUtilization(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> float:
    """@brief Get the overall NPU utilization of a device.
 
    @note Supported on all driver types.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The utilization value (typically a ratio in [0.0, 1.0] or a percentage).
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_double()
    ret = _clib.mbltmlGetTotalUtilization(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetMemoryUsage(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> int:
    """@brief Get the amount of device memory currently in use.
 
    @note Supported on all driver types.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The in-use memory in bytes.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_int64()
    ret = _clib.mbltmlGetMemoryUsage(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetMemoryTotal(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> int:
    """@brief Get the total amount of device memory available.
 
    @note Supported on all driver types.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return The total memory in bytes.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_int64()
    ret = _clib.mbltmlGetMemoryTotal(target_device_type, dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetProcessInfos(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> List[mbltmlProcessInfo_t]:
    """@brief Get per-process usage information for a device.
 
    @note Supported on all driver types.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return List of mbltmlProcessInfo_t records; empty if no process is running.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    c_count = c_uint(0)
    ret = _clib.mbltmlGetProcessInfos(target_device_type, dev_no, None, byref(c_count))
    _mbltmlThrowError(ret)
    if c_count.value == 0:  # No running process
        return []
    c_count.value = c_count.value * 2  # Padding to handle increased process number
    info_array = mbltmlProcessInfo_t * c_count.value
    infos = info_array()
    ret = _clib.mbltmlGetProcessInfos(target_device_type, dev_no, infos, byref(c_count))
    _mbltmlThrowError(ret)
    return [infos[i] for i in range(c_count.value)]
 
 
def mbltmlGetCoreInfos(
    target_device_type: mbltmlTargetDeviceType_t, dev_no: int
) -> List[mbltmlCoreInfo_t]:
    """@brief Get per-core usage information for a device.
 
    @note Supported on all driver types.
 
    @param target_device_type Target device type of the device.
    @param dev_no Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @return List of mbltmlCoreInfo_t records.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    c_count = c_uint(0)
    ret = _clib.mbltmlGetCoreInfos(target_device_type, dev_no, None, byref(c_count))
    _mbltmlThrowError(ret)
    if c_count.value == 0:  # No core
        return []
    c_count.value = c_count.value
    info_array = mbltmlCoreInfo_t * c_count.value
    infos = info_array()
    ret = _clib.mbltmlGetCoreInfos(target_device_type, dev_no, infos, byref(c_count))
    _mbltmlThrowError(ret)
    return [infos[i] for i in range(c_count.value)]
 
 
def mbltmlSetExtraPmicID(
    target_device_type: mbltmlTargetDeviceType_t,
    dev_no: int,
    pmic_id: mbltmlExtraPmicId_t,
) -> None:
    """@brief Select which extra PMIC rail subsequent mbltmlGetExtraPmic*() queries refer to.
 
    @note Supported on aries-rb device (MBLTML_TARGET_DEVICE_ARIES_RB) only.
 
    The underlying readings are refreshed by firmware once per second; allow
    up to 1 second after this call before mbltmlGetExtraPmicPower(),
    mbltmlGetExtraPmicCurrent() and mbltmlGetExtraPmicVoltage() reflect the
    newly selected rail.
 
    @param target_device_type Target device type of the device.
    @param dev_no  Device index within @p target_device_type. Device count is obtained via mbltmlGetTargetDeviceCount().
    @param pmic_id Identifier of the extra PMIC rail to select.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the @p target_device_type device count.
    @throws MBLTMLDeviceNotFoundError if no device of @p target_device_type is detected.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    ret = _clib.mbltmlSetExtraPmicID(target_device_type, dev_no, pmic_id)
    _mbltmlThrowError(ret)
 
 