# -*- coding: utf-8 -*-
#####
# Tencent Tech, All Rights Reserved. 2019-2020 Copyright (c)
#####

##
# Python bindings for the ZXML library
##
from ctypes import *
from ctypes.util import find_library
import sys
import os
import threading
import string

## C Type mappings ##
## Enums

zxmlReturn = c_uint
ZXML_SUCCESS = 0
ZXML_ERROR_UNINITIALIZED = 1
ZXML_ERROR_INVALID_ARGUMENT = 2
ZXML_ERROR_NOT_SUPPORTED = 3
ZXML_ERROR_LIBRARY_NOT_FOUND = 4
ZXML_ERROR_NOT_SUPPORTED_ERROR_CODE = 5
ZXML_ERROR_DRIVER_NOT_LOADED = 6
ZXML_ERROR_ESL_PORT_NUMBER_ERR = 7
ZXML_ERROR_INVALID_INPUT = 8
ZXML_ERROR_MAX = 255

zxmlErrorMessage = {
    ZXML_SUCCESS : 'succeed',
    ZXML_ERROR_UNINITIALIZED : 'device uninitialized',
    ZXML_ERROR_INVALID_ARGUMENT : 'invalid argument',
    ZXML_ERROR_NOT_SUPPORTED : 'not supported',
    ZXML_ERROR_LIBRARY_NOT_FOUND : 'library not found',
    ZXML_ERROR_NOT_SUPPORTED_ERROR_CODE : 'not supported error code',
    ZXML_ERROR_DRIVER_NOT_LOADED : 'driver not loaded',
    ZXML_ERROR_ESL_PORT_NUMBER_ERR : 'esl port number error',
    ZXML_ERROR_INVALID_INPUT : 'invalid input',
    ZXML_ERROR_MAX : 'error max'
}

zxmlLinkSpeed_t = c_uint
ZXML_LINK_SPEED_GEN1 = 1
ZXML_LINK_SPEED_GEN2 = 2
ZXML_LINK_SPEED_GEN3 = 3
ZXML_LINK_SPEED_GEN4 = 4
ZXML_LINK_SPEED_GEN5 = 5

zxmlEslLinkSpeed_t = c_uint
ZXML_ESL_LINK_SPEED_GEN1 = 1
ZXML_ESL_LINK_SPEED_GEN2 = 2
ZXML_ESL_LINK_SPEED_GEN3 = 3
ZXML_ESL_LINK_SPEED_GEN4 = 4
ZXML_ESL_LINK_SPEED_GEN5 = 5
ZXML_ESL_LINK_SPEED_ESM_2P5GT   = 16
ZXML_ESL_LINK_SPEED_ESM_5GT = 17
ZXML_ESL_LINK_SPEED_ESM_8GT = 18
ZXML_ESL_LINK_SPEED_ESM_16GT = 19
ZXML_ESL_LINK_SPEED_ESM_20GT = 20
ZXML_ESL_LINK_SPEED_ESM_25GT = 21

zxmlLinkWidth_t = c_uint
ZXML_LINK_WIDTH_X1 = 1
ZXML_LINK_WIDTH_X2 = 2
ZXML_LINK_WIDTH_X4 = 4
ZXML_LINK_WIDTH_X8 = 8
ZXML_LINK_WIDTH_X16 = 16

zxmlEslLinkWidth_t = c_uint
ZXML_ESL_LINK_WIDTH_X1 = 1
ZXML_ESL_LINK_WIDTH_X2 = 2
ZXML_ESL_LINK_WIDTH_X4 = 4
ZXML_ESL_LINK_WIDTH_X8 = 8
ZXML_ESL_LINK_WIDTH_X16 = 16

zxmlEslPortType_t = c_uint
ZXML_ESL_PORT_RC = 0
ZXML_ESL_PORT_EP = 1

## driver version buffer length
ZXML_DRIVER_VER_LEN = 128

## max buffer length
ZXML_MAX_CHAR_BUFF_LEN = 128

class zxmlDeviceInfo_t(Structure):
    _fields_ = [
        ('name', c_char * ZXML_MAX_CHAR_BUFF_LEN),
        ('vendor_id', c_uint),
        ('device_id', c_uint),
        ('domain_id', c_uint),
        ('bus_id', c_uint),
        ('dev_id', c_uint),
        ('func_id', c_uint),
        ('logic_id', c_uint),
    ]

class zxmlDevPowerInfo_t(Structure):
    _fields_ = [
        ('pwr_capability', c_float),
        ('cur_pwr_consumption', c_float),
    ]

class zxmlDriverInfo_t(Structure):
    _fields_ = [
        ('driver_ver', c_char * ZXML_DRIVER_VER_LEN),
    ]

class zxmlDevMemInfo_t(Structure):
    _fields_ = [
        ('mem_total_size', c_ulonglong),
        ('mem_used', c_uint),
    ]

class zxmlClusterHbmMemInfo_t(Structure):
    _fields_ = [
        ('mem_total_size', c_ulonglong),
        ('mem_used', c_uint),
    ]

class zxmlDevClkInfo_t(Structure):
    _fields_ = [
        ('cur_hbm_clock', c_uint),
        ('cur_dtu_clock', c_uint),
    ]

class zxmlDevThermalInfo_t(Structure):
    _fields_ = [
        ('cur_dev_temp', c_float),
        ('cur_hbm0_temp', c_float),
        ('cur_hbm1_temp', c_float),
    ]

class zxmlDevThermalInfoV2_t(Structure):
    _fields_ = [
       ('cur_asic_temp', c_float),
       ('cur_mem_temp', c_float),
       ('cur_board_temp', c_float),
    ]

class zxmlDevVoltInfo_t(Structure):
    _fields_ = [
        ('vdd_dtu', c_float),
        ('vdd_soc', c_float),
        ('vdd_hbmqc', c_float),
        ('vdd_1v8', c_float),
        ('vdd_vddp', c_float),
    ]

class zxmlPcieLinkInfo_t(Structure):
    _fields_ = [
        ('link_speed', c_uint),
        ('max_link_speed', c_uint),
        ('link_width', c_uint),
        ('max_link_width', c_uint),
    ]

class zxmlPcieThroughputInfo_t(Structure):
    _fields_ = [
        ('tx_throughput', c_float),
        ('rx_throughput', c_float),
        ('tx_nak', c_ulonglong),
        ('rx_nak', c_ulonglong),
    ]

class zxmlEslLinkInfo_t(Structure):
    _fields_ = [
        ('link_speed', c_uint),
        ('max_link_speed', c_uint),
        ('link_width', c_uint),
        ('max_link_width', c_uint),
    ]

class zxmlEslThroughputInfo_t(Structure):
    _fields_ = [
        ('tx_throughput', c_float),
        ('rx_throughput', c_float),
        ('tx_nak', c_ulonglong),
        ('rx_nak', c_ulonglong),
    ]

class zxmlEslPortInfo_t(Structure):
    _fields_ = [
        ('connected', c_uint),
        ('uuid', c_char * 16),
        ('vendor_id', c_uint),
        ('device_id', c_uint),
        ('domain_id', c_uint),
        ('bus_id', c_uint),
        ('dev_id', c_uint),
        ('func_id', c_uint),
        ('port_id', c_uint),
        ('port_type', zxmlEslPortType_t),

        ('remote_card_id', c_uint),
        ('remote_uuid', c_char * 16),
        ('remote_vendor_id', c_uint),
        ('remote_device_id', c_uint),
        ('remote_domain_id', c_uint),
        ('remote_bus_id', c_uint),
        ('remote_dev_id', c_uint),
        ('remote_func_id', c_uint),
        ('remote_port_id', c_uint),
        ('remote_port_type', zxmlEslPortType_t),
    ]

# handler zxml library
zxmlLib = None

## Error Checking ##
def zxmlError(err_code):
    if(err_code >= ZXML_ERROR_MAX):
        raise Exception("error code not supported!")

    if(err_code != ZXML_SUCCESS):
        raise Exception('error ' + zxmlErrorMessage[err_code])

def zxmlLoadLibrary():
    global zxmlLib
    if (zxmlLib == None):
        try:
            zxmlLib = CDLL('libzxml.so')
        except OSError as ose:
            print('library not found!')
            raise
        finally:
            pass

# function entry list
zxmlFunctionEntryList_cache = dict()

def zxmlGetFunctionEntry(entry_str):
    global zxmlLib

    if entry_str in zxmlFunctionEntryList_cache:
        return zxmlFunctionEntryList_cache[entry_str]

    try:
        if (zxmlLib == None):
            zxmlError(ZXML_ERROR_UNINITIALIZED)

        zxmlFunctionEntryList_cache[entry_str] = getattr(zxmlLib, entry_str)
        return zxmlFunctionEntryList_cache[entry_str]
    finally:
        pass

# init device and library
def zxmlInit(no_driver=False):
    """
    Init zxml libary

    parameters:
              no_driver(bool): not use kmd

    return:
           ZXML_SUCCESS
    """
    zxmlLoadLibrary()
    func = zxmlGetFunctionEntry("ZxmlInit")
    c_no_driver = c_bool(no_driver)
    try:
        ret = func(c_no_driver)
        zxmlError(ret)
    except Exception as e:
        raise

    return ret

# shutdown and release loaded library
def zxmlShutdown():
    """
    Close zxml libary, release allocated resource

    parameters:
              None

    return:
           None
    """
    zxmlLoadLibrary()
    func = zxmlGetFunctionEntry("ZxmlShutdown")
    try:
        func()
    except Exception as e:
        raise

    return None

def zxmlErrorString(ret_val):
    """
    Translate returned error code to string

    parameters:
            ret_val (zxmlReturn): function return value

    return:
          string of return value
    """
    fn = zxmlGetFunctionEntry("ZxmlErrorString")
    fn.restype = c_char_p # the return result should be a string
    ret = fn(ret_val)
    return ret

def zxmlDriverVer():
    """
    Get KMD (kernel mode driver) version info

    parameters:
              None

    return:
          string of driver version
    """
    c_driver_info = create_string_buffer(ZXML_DRIVER_VER_LEN)
    fn = zxmlGetFunctionEntry("ZxmlGetDriverVer")
    ret = fn(c_driver_info)
    zxmlError(ret)

    return c_driver_info.value

def zxmlLibVer():
    """
    Get ZXML lib version info

    parameters:
              None

    return:
          string of zxml lib version
    """
    c_zxml_ver_info = create_string_buffer(ZXML_DRIVER_VER_LEN)
    fn = zxmlGetFunctionEntry("ZxmlGetLibVer")
    ret = fn(c_zxml_ver_info)
    zxmlError(ret)

    return c_zxml_ver_info.value

def zxmlSelDevByIndex(idx):
    """
    Select current device by index

    parameters:
              idx (int): selected device index

    return:
          None

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    fn = zxmlGetFunctionEntry("ZxmlSelDevByIndex")
    c_idx = c_uint(idx)
    ret = fn(c_idx)
    zxmlError(ret)

def zxmlGetDevCount():
    """
    Get total DTU device numbers in the system

    parameters:
              None

    return:
          total device numbers

    error:
          ZXML_ERROR_UNINITIALIZED: library not initialized
    """
    cnt = c_uint()
    fn = zxmlGetFunctionEntry("ZxmlGetDevCount")
    ret = fn(byref(cnt))
    zxmlError(ret)
    return cnt.value

def zxmlGetDevName(idx):
    """
    Get DTU device name

    parameters:
              idx (int): selected device index

    return:
          device name in string

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_name = create_string_buffer(ZXML_MAX_CHAR_BUFF_LEN)
    fn = zxmlGetFunctionEntry("ZxmlGetDevName")

    ret = fn(c_idx, c_name)
    zxmlError(ret)
    return c_name.value

def zxmlGetDevUuid(idx):
    """
    Get DTU device UUID(Universally Unique Identifier)

    parameters:
              idx (int): selected device index

    return:
          device UUID in string

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_uuid = create_string_buffer(ZXML_MAX_CHAR_BUFF_LEN)
    fn = zxmlGetFunctionEntry("ZxmlGetDevUuid")

    ret = fn(c_idx, c_uuid)
    zxmlError(ret)
    return c_uuid.value

def zxmlGetDevSn(idx):
    """
    Get DTU device SN info(Serial Number)

    parameters:
              idx (int): selected device index

    return:
          device SN in string

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_sn = create_string_buffer(ZXML_MAX_CHAR_BUFF_LEN)
    fn = zxmlGetFunctionEntry("ZxmlGetDevSn")

    ret = fn(c_idx, c_sn)
    zxmlError(ret)
    return c_sn.value

def zxmlGetDevPn(idx):
    """
    Get DTU device PN info(Part Number)

    parameters:
              idx (int): selected device index

    return:
          device PN in string

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_pn = create_string_buffer(ZXML_MAX_CHAR_BUFF_LEN)
    fn = zxmlGetFunctionEntry("ZxmlGetDevPn")

    ret = fn(c_idx, c_pn)
    zxmlError(ret)
    return c_pn.value

def zxmlGetFwVersion(idx):
    """
    Get DTU firmware version

    parameters:
              idx (int): selected device index

    return:
          DTU firmware version in string

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_fw_ver = create_string_buffer(ZXML_MAX_CHAR_BUFF_LEN)
    fn = zxmlGetFunctionEntry("ZxmlGetFwVersion")

    ret = fn(c_idx, c_fw_ver)
    zxmlError(ret)
    return c_fw_ver.value


## device
#def zxmlGetDevFanSpeed(idx):
#    """
#    Get DTU Fan speed
#
#    parameters:
#              idx (int): selected device index
#
#    return:
#          DTU Fan speed in int
#
#    error:
#          | ZXML_ERROR_UNINITIALIZED: library not initialized
#          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
#    """
#    c_idx = c_uint(idx)
#    c_fan_speed = c_uint()
#    fn = zxmlGetFunctionEntry("ZxmlGetDevFanSpeed")
#    ret = fn(c_idx, byref(c_fan_speed))
#
#    zxmlError(ret)
#    return c_fan_speed.value
#
def zxmlGetDevTemp(idx):
    """
    Get DTU/MEM temperature

    parameters:
              idx (int): selected device index

    return:
          | zxmlDevThermalInfo_t:cur_dev_temp(float): DTU temperature,[1,95] celsius
          | zxmlDevThermalInfo_t:cur_hbm0_temp(float): MEM0 temperature,[1,95] celsius
          | zxmlDevThermalInfo_t:cur_hbm1_temp(float): MEM1 temperature,[1,95] celsius

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_ther = zxmlDevThermalInfo_t()
    fn = zxmlGetFunctionEntry("ZxmlGetDevTemp")
    ret = fn(c_idx, byref(c_ther))

    zxmlError(ret)
    return c_ther

def zxmlGetDevTempV2(idx):
    """
    Get DTU/MEM temperature
    """
    c_idx = c_uint(idx)
    c_ther = zxmlDevThermalInfoV2_t()
    fn = zxmlGetFunctionEntry("ZxmlGetDevTempV2")
    ret = fn(c_idx, byref(c_ther))

    zxmlError(ret)
    return c_ther

def zxmlGetDevVolt(idx):
    """
    Get DTU voltage

    parameters:
              idx (int): selected device index

    return:
          | zxmlDevVoltInfo_t:vdd_dtu(float): DTU voltage
          | zxmlDevVoltInfo_t:vdd_soc(float): soc voltage
          | zxmlDevVoltInfo_t:vdd_hbmqc(float): HBMQC voltage
          | zxmlDevVoltInfo_t:vdd_1v8(float): VDD 1V8 voltage
          | zxmlDevVoltInfo_t:vdd_vddp(float): VDD VDDP voltage

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_ther = zxmlDevVoltInfo_t()
    fn = zxmlGetFunctionEntry("ZxmlGetDevVolt")
    ret = fn(c_idx, byref(c_ther))

    zxmlError(ret)
    return c_ther

def zxmlGetDevPwr(idx):
    """
    Get DTU power consumption

    parameters:
              idx (int): selected device index

    return:
          | zxmlDevPowerInfo_t:pwr_capability(float): DTU power capability,225 watt
          | zxmlDevPowerInfo_t:cur_pwr_consumption(float): DTU current power consumption,[1,225] watt

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_pwr = zxmlDevPowerInfo_t()
    fn = zxmlGetFunctionEntry("ZxmlGetDevPwr")
    ret = fn(c_idx, byref(c_pwr))

    zxmlError(ret)
    return c_pwr

def zxmlGetDevDpmLevel(idx):
    """
    Get DTU DPM(Dynamic Power Managerment) level

    parameters:
              idx (int): selected device index

    return:
          DPM level in int

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_dpm = c_uint()
    fn = zxmlGetFunctionEntry("ZxmlGetDevDpmLevel")
    ret = fn(c_idx, byref(c_dpm))

    zxmlError(ret)
    return c_dpm.value

def zxmlGetDevDtuUsage(idx):
    """
    Get DTU usage

    parameters:
              idx (int): selected device index

    return:
          DTU usage value in float

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_dtu_usage = c_float()
    fn = zxmlGetFunctionEntry("ZxmlGetDevDtuUsage")
    ret = fn(c_idx, byref(c_dtu_usage))

    zxmlError(ret)
    return c_dtu_usage.value

def zxmlGetDevDtuUsageAsync(idx):
    """
    Get DTU usage Async

    parameters:
              idx (int): selected device index

    return:
          DTU usage value in float

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_dtu_usage = c_float()
    fn = zxmlGetFunctionEntry("ZxmlGetDevDtuUsageAsync")
    ret = fn(c_idx, byref(c_dtu_usage))

    zxmlError(ret)
    return c_dtu_usage.value

def zxmlGetDevClk(idx):
    """
    Get DTU/Mem clock frequency

    parameters:
              idx (int): selected device index

    return:
          zxmlDevClkInfo_t:cur_hbm_clock (int): memory clock frequency
          zxmlDevClkInfo_t:cur_dtu_clock (int): DTU clock frequency

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_clk = zxmlDevClkInfo_t()
    fn = zxmlGetFunctionEntry("ZxmlGetDevClk")
    ret = fn(c_idx, byref(c_clk))

    zxmlError(ret)
    return c_clk

def zxmlDumpDevList():
    """
    Dump device list in system

    parameters:
              None

    return:
          None

    error:
          ZXML_ERROR_UNINITIALIZED: library not initialized
    """
    fn = zxmlGetFunctionEntry("ZxmlDumpDevList")
    ret = fn()

    zxmlError(ret)

def zxmlGetDevInfo(idx):
    """
    Get detailed DTU information

    parameters:
              idx (int): selected device index

    return:
          | zxmlDeviceInfo_t:name (char []): device name
          | zxmlDeviceInfo_t:vendor_id (c_uint): PCIe Vendor ID
          | zxmlDeviceInfo_t:device_id (c_uint): PCIe Device ID
          | zxmlDeviceInfo_t:domain_id (c_uint): PCIe Domain ID
          | zxmlDeviceInfo_t:bus_id (c_uint): PCIe Bus number
          | zxmlDeviceInfo_t:dev_id (c_uint): PCIe Device number
          | zxmlDeviceInfo_t:func_id (c_uint): PCIe Function number
          | zxmlDeviceInfo_t:logic_id (c_uint): device logic id

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_dev_info = zxmlDeviceInfo_t()
    fn = zxmlGetFunctionEntry("ZxmlGetDevInfo")
    ret = fn(c_idx, byref(c_dev_info))

    zxmlError(ret)
    return c_dev_info


## memory info
def zxmlGetDevMem(idx):
    """
    Get device memory information

    parameters:
              idx (int): selected device index

    return:
          | zxmlDevMemInfo_t:mem_total_size (c_uint): memory size
          | zxmlDevMemInfo_t:mem_used (c_uint): memory usage

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_mem_info = zxmlDevMemInfo_t()
    fn = zxmlGetFunctionEntry("ZxmlGetDevMem")
    ret = fn(c_idx, byref(c_mem_info))

    zxmlError(ret)
    return c_mem_info


## cluster memory info
def zxmlGetClusterMem(idx, cluster_idx):
    """
    Get device memory information

    parameters:
              idx (int): selected device index
              cluster_idx (int): selected cluster index

    return:
          | zxmlClusterHbmMemInfo_t:mem_total_size (c_uint): memory size
          | zxmlClusterHbmMemInfo_t:mem_used (c_uint): memory usage

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_cluster_idx = c_uint(cluster_idx)
    c_mem_info = zxmlClusterHbmMemInfo_t()
    fn = zxmlGetFunctionEntry("ZxmlGetClusterMem")
    ret = fn(c_idx, c_cluster_idx, byref(c_mem_info))

    zxmlError(ret)
    return c_mem_info

def zxmlGetEccStatus(idx):
    """
    Get device memory ECC status

    parameters:
              idx (int): selected device index

    return:
          ECC enablement status in int

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_idx = c_uint(idx)
    c_ecc = c_uint()
    fn = zxmlGetFunctionEntry("ZxmlGetEccStatus")
    ret = fn(c_idx, byref(c_ecc))

    zxmlError(ret)
    return c_ecc.value

## PCIe
def zxmlGetPcieLinkSpeed(idx):
    """
    Get device PCIe link speed

    parameters:
              idx (int): selected device index

    return:
          link speed info in zxmlPcieSpeed_t

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_dev_idx = c_uint(idx)
    c_link_speed = zxmlLinkSpeed_t(idx)
    fn = zxmlGetFunctionEntry("ZxmlGetPcieLinkSpeed")

    ret = fn(c_dev_idx, byref(c_link_speed))
    zxmlError(ret)

    return c_link_speed.value

def zxmlGetPcieLinkWidth(idx):
    """
    Get device PCIe link width

    parameters:
              idx (int): selected device index

    return:
          link width info in zxmlPcieWidth_t

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_dev_idx = c_uint(idx)
    c_link_width = zxmlLinkWidth_t(idx)
    fn = zxmlGetFunctionEntry("ZxmlGetPcieLinkWidth")

    ret = fn(c_dev_idx, byref(c_link_width))
    zxmlError(ret)

    return c_link_width.value

def zxmlGetPcieLinkInfo(idx):
    """
    Get device PCIe link information

    parameters:
              idx (int): selected device index

    return:
          | zxmlPcieLinkInfo_t:link_speed : PCIe link speed
          | zxmlPcieLinkInfo_t:max_link_speed : PCIe supported max link speed
          | zxmlPcieLinkInfo_t:link_width : PCIe link width
          | zxmlPcieLinkInfo_t:max_link_width : PCIe supported max link width

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_dev_idx = c_uint(idx)
    c_link_info = zxmlPcieLinkInfo_t(0, 0, 0, 0)

    fn = zxmlGetFunctionEntry("ZxmlGetPcieLinkInfo")

    ret = fn(c_dev_idx, byref(c_link_info))
    zxmlError(ret)

    return c_link_info

def zxmlGetPcieThroughput(idx):
    """
    Get device PCIe link throughput info. It will collect information in 10ms

    parameters:
              idx (int): selected device index

    return:
          | zxmlPcieThroughputInfo_t:tx_throughput(float) : PCIe link Tx throughput
          | zxmlPcieThroughputInfo_t:rx_throughput(float) : PCIe link Rx throughput
          | zxmlPcieThroughputInfo_t:tx_nak(uint64) : PCIe link Tx NAK counts
          | zxmlPcieThroughputInfo_t:rx_nak(uint64) : PCIe link Rx NAK counts

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_dev_idx = c_uint(idx)
    c_throughtput = zxmlPcieThroughputInfo_t()

    fn = zxmlGetFunctionEntry("ZxmlGetPcieThroughput")

    ret = fn(c_dev_idx, byref(c_throughtput))
    zxmlError(ret)

    return c_throughtput

## ESL
def zxmlGetEslPortNum(idx):
    """
    Get device ESL port number

    parameters:
              idx (int): selected device index

    return:
          ESL port number in int

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_dev_idx = c_uint(idx)
    c_port_num = c_uint()

    fn = zxmlGetFunctionEntry("ZxmlGetEslPortNum")

    ret = fn(c_dev_idx, byref(c_port_num))
    zxmlError(ret)

    return c_port_num.value

def zxmlGetEslPortInfo(idx, port_id):
    """
    Get device ESL port info

    parameters:
              | idx (int): selected device index
              | port_id (int): selected ESL port ID

    return:
          | zxmlEslPortInfo_t:connected(c_uint) : port connected status
          | zxmlEslPortInfo_t:vendor_id(char [16]) : port vendor id
          | zxmlEslPortInfo_t:device_id(c_uint) : port device id
          | zxmlEslPortInfo_t:domain_id(c_uint) : port domain id
          | zxmlEslPortInfo_t:bus_id(char [16]) : port bus id
          | zxmlEslPortInfo_t:dev_id(c_uint) : port device id
          | zxmlEslPortInfo_t:func_id(c_uint) : port function id
          | zxmlEslPortInfo_t:port_id(c_uint) : port id
          | zxmlEslPortInfo_t:port_type(zxmlEslPortType_t) : port type
          | zxmlEslPortInfo_t:remote_card_id(c_uint) : remote port card id
          | zxmlEslPortInfo_t:remote_vendor_id(char [16]) :remote port vendor id
          | zxmlEslPortInfo_t:remote_device_id(c_uint) :remote port device id
          | zxmlEslPortInfo_t:remote_domain_id(c_uint) :remote port domain id
          | zxmlEslPortInfo_t:remote_bus_id(char [16]) :remote port bus id
          | zxmlEslPortInfo_t:remote_dev_id(c_uint) :remote port device id
          | zxmlEslPortInfo_t:remote_func_id(c_uint) :remote port function id
          | zxmlEslPortInfo_t:remote_port_id(c_uint) :remote port id
          | zxmlEslPortInfo_t:remote_port_type(zxmlEslPortType_t) :remote port type

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_dev_idx = c_uint(idx)
    c_port_id = c_uint(port_id)
    c_port_info = zxmlEslPortInfo_t()

    fn = zxmlGetFunctionEntry("ZxmlGetEslPortInfo")

    ret = fn(c_dev_idx, c_port_id, byref(c_port_info))
    zxmlError(ret)

    return c_port_info

def zxmlGetEslLinkInfo(idx, port_id):
    """
    Get device ESL port link info

    parameters:
              | idx (int): selected device index
              | port_id (int): selected ESL port ID

    return:
          | zxmlEslLinkInfo_t:link_speed(zxmlEslSpeed_t) : port link speed
          | zxmlEslLinkInfo_t:max_link_speed(zxmlEslSpeed_t) : port max supported link speed
          | zxmlEslLinkInfo_t:link_width(zxmlEslWidth_t) : port link width
          | zxmlEslLinkInfo_t:max_link_width(zxmlEslWidth_t) : port max supported link width

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_dev_idx = c_uint(idx)
    c_port_id = c_uint(port_id)
    c_link_info = zxmlEslLinkInfo_t()

    fn = zxmlGetFunctionEntry("ZxmlGetEslLinkInfo")

    ret = fn(c_dev_idx, c_port_id, byref(c_link_info))
    zxmlError(ret)

    return c_link_info

def zxmlGetEslThroughput(idx, port_id):
    """
    Get device ESL port throughput info

    parameters:
              | idx (int): selected device index
              | port_id (int): selected ESL port ID

    return:
          | zxmlEslThroughputInfo_t:tx_throughput(float) : port tx throughput
          | zxmlEslThroughputInfo_t:rx_throughput(float) : port rx throughput
          | zxmlEslThroughputInfo_t:tx_nak(uint64) : port tx total NAK counts
          | zxmlEslThroughputInfo_t:rx_nak(uint64) : port rx total NAK counts

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
          | ZXML_ERROR_ESL_PORT_NUMBER_ERR: ESL port number error
    """
    c_dev_idx = c_uint(idx)
    c_port_id = c_uint(port_id)
    c_throughput = zxmlEslThroughputInfo_t()

    fn = zxmlGetFunctionEntry("ZxmlGetEslThroughput")

    ret = fn(c_dev_idx, c_port_id, byref(c_throughput))
    zxmlError(ret)

    return c_throughput

def zxmlGetDevClusterCount(idx):
    """
    Get total DTU device cluster numbers in the dtu

    parameters:
              | idx (int): selected device index

    return:
          total device cluster numbers

    error:
          ZXML_ERROR_UNINITIALIZED: library not initialized
    """
    cnt = c_uint()
    c_dev_idx = c_uint(idx)
    fn = zxmlGetFunctionEntry("ZxmlGetClusterCount")
    ret = fn(c_dev_idx, byref(cnt))
    zxmlError(ret)
    return cnt.value

def zxmlGetDevClusterUsage(idx, cluster_idx):
    """
    Get DTU usage

    parameters:
              idx (int): selected device index

    return:
          DTU usage value in float

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_dev_idx = c_uint(idx)
    c_cluster_idx = c_uint(cluster_idx)
    c_cluster_usage = c_float()
    fn = zxmlGetFunctionEntry("ZxmlGetDevClusterUsage")
    ret = fn(c_dev_idx, c_cluster_idx, byref(c_cluster_usage))

    zxmlError(ret)
    return c_cluster_usage.value

def zxmlGetDevHealth(idx):
    """
    Get DTU usage

    parameters:
              idx (int): selected device index

    return:
          DTU usage value in float

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_dev_idx = c_uint(idx)
    c_dev_health = c_bool()
    fn = zxmlGetFunctionEntry("ZxmlGetDevHealth")
    ret = fn(c_dev_idx, byref(c_dev_health))

    zxmlError(ret)
    return c_dev_health.value

## vGCU numbers per GCU
def zxmlGetVdevCount(idx):
    """
    Get virtual GCU numbers in the GCU.

    parameters:
              idx (int): selected device index

    return:
          total virtual GCU per GCU.

    error:
          ZXML_ERROR_UNINITIALIZED: library not initialized
    """
    cnt = c_uint()
    c_dev_idx = c_uint(idx)
    fn = zxmlGetFunctionEntry("ZxmlGetVdevCount")
    ret = fn(c_dev_idx, byref(cnt))
    zxmlError(ret)
    return cnt.value

## vGCU memory info
def zxmlGetVdevDtuMem(idx, vdev_idx):
    """
    Get vGCU mem info.

    parameters:
              idx (int): selected device index
              vdev_idx (int): selected vGCU index

    return:
          | zxmlDevMemInfo_t:mem_total_size (c_uint): memory size
          | zxmlDevMemInfo_t:mem_used (c_uint): memory usage

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_dev_idx = c_uint(idx)
    c_vdev_idx = c_uint(vdev_idx)
    c_vdev_mem_info = zxmlDevMemInfo_t()
    fn = zxmlGetFunctionEntry("ZxmlGetVdevMem")
    ret = fn(c_dev_idx, c_vdev_idx, byref(c_vdev_mem_info))

    zxmlError(ret)
    return c_vdev_mem_info

## vGCU usage info
def zxmlGetVdevDtuUsage(idx, vdev_idx):
    """
    Get vGCU usage

    parameters:
              idx (int): selected device index
              vdev_idx (int): selected vGCU index

    return:
          vGCU usage value in float

    error:
          | ZXML_ERROR_UNINITIALIZED: library not initialized
          | ZXML_ERROR_INVALID_ARGUMENT: invalid input parameters
    """
    c_dev_idx = c_uint(idx)
    c_vdev_idx = c_uint(vdev_idx)
    c_vdev_usage = c_float()
    fn = zxmlGetFunctionEntry("ZxmlGetVdevDtuUsage")
    ret = fn(c_dev_idx, c_vdev_idx, byref(c_vdev_usage))

    zxmlError(ret)
    return c_vdev_usage.value