MOKA/pqAutomationApp
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

更新UCD-API库及文档

Browse Source
This commit is contained in:
xinzhu.yin
2026-07-02 17:16:18 +08:00
parent a500751d85
commit 9fa811a9eb
290 changed files with 9558 additions and 2306 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
UniTAP/libs/lib_tsi/TSI.dll
View File

Binary file not shown.

5
UniTAP/libs/lib_tsi/__init__.py
View File

@@ -1,3 +1,4 @@
from UniTAP.libs.lib_tsi.tsi_types import *
from UniTAP.libs.lib_tsi.tsi import *
import UniTAP.libs.lib_tsi.tsi_types as ci
import UniTAP.libs.lib_tsi.tsi_private_types as p_ci
import UniTAP.libs.lib_tsi.tsi
from UniTAP.libs.lib_tsi.tsi_io import BaseIO, DeviceIO, PortIO

BIN
UniTAP/libs/lib_tsi/bundle.information Normal file
View File

Binary file not shown.

222
UniTAP/libs/lib_tsi/tsi.py
View File

@@ -1,14 +1,18 @@
import warnings
from enum import IntEnum
from UniTAP.libs.lib_tsi.tsi_private_types import *
from _ctypes import Structure
import UniTAP.libs.lib_tsi.tsi_private_types as p_ci
import UniTAP.libs.lib_tsi.tsi_types as ci
from UniTAP.libs.lib_helper import OS_Requirements, lib_method_wrapper
from ctypes import c_char_p, c_uint32, c_void_p, c_int32, POINTER, create_string_buffer, byref, \
sizeof, c_uint64, c_ubyte, c_bool
sizeof, c_uint64, c_ubyte, c_bool, c_uint
from UniTAP.utils import tsi_logging as logging
CTYPES_TYPE_LIST = [c_char_p, c_uint32, c_void_p, c_int32, c_uint64, c_ubyte, c_bool]
callback = None
@@ -21,6 +25,14 @@ class Singleton(type):
return cls._instances[cls]
class TSIInitializationFailed(Exception):
"""
Redefinition of base exception.
Define error of 'TSI library initialization failed'.
"""
pass
class TSIWrapper(metaclass=Singleton):
_TSI_CURRENT_VERSION = 12
@@ -63,100 +75,104 @@ class TSIWrapper(metaclass=Singleton):
def initialize(self):
self._TSIX_Init = lib_method_wrapper(self.lib.TSIX_Init, [POINTER(TSI_INIT_CONFIGURATION)],
TSI_RESULT)
self._TSI_Init = lib_method_wrapper(self.lib.TSI_Init, [c_uint32], TSI_RESULT)
self._TSI_Clean = lib_method_wrapper(self.lib.TSI_Clean, [], TSI_RESULT)
ci.TSI_RESULT)
self._TSI_Init = lib_method_wrapper(self.lib.TSI_Init, [c_uint32], ci.TSI_RESULT)
self._TSI_Clean = lib_method_wrapper(self.lib.TSI_Clean, [], ci.TSI_RESULT)
self._TSI_DEV_GetDeviceCount = lib_method_wrapper(self.lib.TSIX_DEV_GetDeviceCount, [],
TSI_RESULT)
ci.TSI_RESULT)
self._TSIX_DEV_GetDeviceName = lib_method_wrapper(self.lib.TSIX_DEV_GetDeviceName,
[TSI_DEVICE_ID, c_char_p, c_uint32],
TSI_RESULT)
[ci.TSI_DEVICE_ID, c_char_p, c_uint32],
ci.TSI_RESULT)
self._TSIX_DEV_OpenDevice = lib_method_wrapper(self.lib.TSIX_DEV_OpenDevice,
[TSI_DEVICE_ID, POINTER(TSI_RESULT)],
TSI_HANDLE)
[ci.TSI_DEVICE_ID, POINTER(ci.TSI_RESULT)],
ci.TSI_HANDLE)
self._TSIX_DEV_SelectRole = lib_method_wrapper(self.lib.TSIX_DEV_SelectRole,
[TSI_HANDLE, c_int32],
TSI_RESULT)
[ci.TSI_HANDLE, c_int32],
ci.TSI_RESULT)
self._TSIX_DEV_RescanDevices = lib_method_wrapper(self.lib.TSIX_DEV_RescanDevices,
[c_int32, c_int32, c_int32],
TSI_RESULT)
ci.TSI_RESULT)
self._TSIX_DEV_GetDeviceRoleName = lib_method_wrapper(self.lib.TSIX_DEV_GetDeviceRoleName,
[TSI_HANDLE, c_int32, c_char_p,
[ci.TSI_HANDLE, c_int32, c_char_p,
c_uint32],
TSI_RESULT)
ci.TSI_RESULT)
self._TSIX_DEV_GetDeviceRoleCount = lib_method_wrapper(self.lib.TSIX_DEV_GetDeviceRoleCount,
[TSI_HANDLE, ],
TSI_RESULT)
[ci.TSI_HANDLE, ],
ci.TSI_RESULT)
self._TSIX_DEV_CloseDevice = lib_method_wrapper(self.lib.TSIX_DEV_CloseDevice,
[TSI_HANDLE, ],
TSI_RESULT)
[ci.TSI_HANDLE, ],
ci.TSI_RESULT)
self._TSI2_TS_SetConfigItem = lib_method_wrapper(self.lib.TSI2_TS_SetConfigItem,
[TSI_HANDLE, TSI_LOGICAL_PORT,
TSI_CONFIG_ID,
[ci.TSI_HANDLE, ci.TSI_TEST_ID,
ci.TSI_CONFIG_ID,
c_void_p, c_uint32],
TSI_RESULT)
ci.TSI_RESULT)
self._TSIX_TS_SetConfigItem = lib_method_wrapper(self.lib.TSIX_TS_SetConfigItem,
[TSI_HANDLE, TSI_CONFIG_ID, c_void_p,
[ci.TSI_HANDLE, ci.TSI_CONFIG_ID, c_void_p,
c_uint32],
TSI_RESULT)
ci.TSI_RESULT)
self._TSI2_TS_GetConfigItem = lib_method_wrapper(self.lib.TSI2_TS_GetConfigItem,
[TSI_HANDLE, TSI_LOGICAL_PORT,
TSI_CONFIG_ID,
[ci.TSI_HANDLE, ci.TSI_TEST_ID,
ci.TSI_CONFIG_ID,
c_void_p, c_uint32],
TSI_RESULT)
ci.TSI_RESULT)
self._TSIX_TS_GetConfigItem = lib_method_wrapper(self.lib.TSIX_TS_GetConfigItem,
[TSI_HANDLE, TSI_CONFIG_ID, c_void_p,
[ci.TSI_HANDLE, ci.TSI_CONFIG_ID, c_void_p,
c_uint32],
TSI_RESULT)
ci.TSI_RESULT)
self._TSI_MISC_GetErrorDescription = lib_method_wrapper(
self.lib.TSI_MISC_GetErrorDescription,
[TSI_RESULT, c_char_p, c_uint32],
TSI_RESULT)
[ci.TSI_RESULT, c_char_p, c_uint32],
ci.TSI_RESULT)
self._TSIX_PORT_Select = lib_method_wrapper(self.lib.TSIX_PORT_Select,
[TSI_HANDLE, TSI_LOGICAL_PORT],
TSI_RESULT)
[ci.TSI_HANDLE, ci.TSI_TEST_ID],
ci.TSI_RESULT)
self._TSIX_PORT_Deselect = lib_method_wrapper(self.lib.TSIX_PORT_Deselect,
[TSI_HANDLE, TSI_LOGICAL_PORT],
TSI_RESULT)
[ci.TSI_HANDLE, ci.TSI_TEST_ID],
ci.TSI_RESULT)
self._TSIX_TS_RunTest = lib_method_wrapper(self.lib.TSIX_TS_RunTest,
[TSI_HANDLE, TSI_TEST_ID],
TSI_RESULT)
[ci.TSI_HANDLE, ci.TSI_TEST_ID],
ci.TSI_RESULT)
self._TSIX_TS_AbortTests = lib_method_wrapper(self.lib.TSIX_TS_AbortTests,
[TSI_HANDLE],
TSI_RESULT)
[ci.TSI_HANDLE],
ci.TSI_RESULT)
self._TSIX_PORT_GetTestCount = lib_method_wrapper(self.lib.TSIX_PORT_GetTestCount,
[TSI_HANDLE, TSI_LOGICAL_PORT],
TSI_RESULT)
[ci.TSI_HANDLE, ci.TSI_TEST_ID],
ci.TSI_RESULT)
self._TSIX_PORT_GetTestInfo = lib_method_wrapper(self.lib.TSIX_PORT_GetTestInfo,
[TSI_HANDLE, TSI_LOGICAL_PORT, c_int32,
POINTER(TSI_TEST_ID),
[ci.TSI_HANDLE, p_ci.TSI_LOGICAL_PORT, c_int32,
POINTER(ci.TSI_TEST_ID),
POINTER(c_int32), c_char_p, c_uint32],
TSI_RESULT)
ci.TSI_RESULT)
self._TSIX_STLOG_WaitMessage = lib_method_wrapper(self.lib.TSIX_STLOG_WaitMessage,
[TSI_HANDLE, c_int32],
TSI_RESULT)
[ci.TSI_HANDLE, c_int32],
ci.TSI_RESULT)
self._TSIX_STLOG_GetMessageData = lib_method_wrapper(self.lib.TSIX_STLOG_GetMessageData,
[TSI_HANDLE, c_char_p, c_uint32,
[ci.TSI_HANDLE, c_char_p, c_uint32,
POINTER(c_uint32)],
TSI_RESULT)
ci.TSI_RESULT)
self._TSI_CreateEventParser = lib_method_wrapper(self.lib.TSI_CreateEventParser,
[POINTER(TSI_RESULT), c_uint32],
TSI_PARSER)
[POINTER(ci.TSI_RESULT), c_uint32],
ci.TSI_PARSER)
self._TSI_RemoveEventParser = lib_method_wrapper(self.lib.TSI_RemoveEventParser,
[TSI_PARSER, ],
TSI_RESULT)
[ci.TSI_PARSER, ],
ci.TSI_RESULT)
self._TSI_GetParsedEventData = lib_method_wrapper(self.lib.TSI_GetParsedEventData,
[TSI_PARSER, POINTER(c_ubyte), c_int32,
[ci.TSI_PARSER, POINTER(c_ubyte), c_int32,
POINTER(c_uint64), c_char_p, c_int32,
c_char_p,
c_int32, c_char_p, c_int32, c_char_p,
c_int32],
TSI_RESULT)
ci.TSI_RESULT)
self._TSI_DEV_SetSearchMask = lib_method_wrapper(self.lib.TSI_DEV_SetSearchMask,
[TSI_DEVICE_CAPS, TSI_DEVICE_CAPS],
TSI_RESULT)
[ci.TSI_DEVICE_CAPS, ci.TSI_DEVICE_CAPS],
ci.TSI_RESULT)
result = self.__TSIX_Init()
return self.__TSIX_Init() if logging.is_enabled() else self.__TSI_Init()
if result < ci.TSI_SUCCESS:
raise TSIInitializationFailed(f"TSI initialization failed with error code {result}")
return result
def deinitialize(self):
return self.__TSI_Clean()
@@ -170,8 +186,8 @@ class TSIWrapper(metaclass=Singleton):
logging.log((level + 1) * 10, message.decode())
except Exception as exc:
warnings.warn(f"[UniTAP] Logger function receive exception: {exc}")
callback = TSI_USER_LOG_FUNCTION(ofp_impl)
callback = ci.TSI_USER_LOG_FUNCTION(ofp_impl)
def __TSIX_Init(self):
global callback
@@ -179,7 +195,7 @@ class TSIWrapper(metaclass=Singleton):
config = TSI_INIT_CONFIGURATION()
config.size = sizeof(config)
config.version = self._TSI_CURRENT_VERSION
config.function = callback
config.function = callback if logging.is_enabled() else ci.TSI_USER_LOG_FUNCTION(0)
return self._TSIX_Init(byref(config))
@@ -193,12 +209,12 @@ class TSIWrapper(metaclass=Singleton):
return self._TSI_DEV_GetDeviceCount()
def TSIX_DEV_GetDeviceName(self, device_id: int):
_device_name = create_string_buffer(TSI_NAME_SIZE)
result = self._TSIX_DEV_GetDeviceName(device_id, _device_name, TSI_NAME_SIZE)
_device_name = create_string_buffer(ci.TSI_NAME_SIZE)
result = self._TSIX_DEV_GetDeviceName(device_id, _device_name, ci.TSI_NAME_SIZE)
return result, from_cstr(_device_name)
def TSIX_DEV_OpenDevice(self, device_id: int):
result = c_int32(TSI_SUCCESS)
result = c_int32(ci.TSI_SUCCESS)
device = self._TSIX_DEV_OpenDevice(c_uint32(device_id), byref(result))
return device
@@ -260,8 +276,11 @@ class TSIWrapper(metaclass=Singleton):
_data = data_type(data.value)
result = self._TSI2_TS_SetConfigItem(device_handle, config_id, byref(_data),
sizeof(_data))
elif issubclass(type(data), Structure):
result = self._TSIX_TS_SetConfigItem(device_handle, config_id, byref(data),
sizeof(data))
else:
result = TSI_ERROR_NOT_IMPLEMENTED
result = ci.TSI_ERROR_NOT_IMPLEMENTED
return result
@@ -286,8 +305,11 @@ class TSIWrapper(metaclass=Singleton):
sizeof(_data))
elif type(data) == list or type(data) == bytearray:
_data = (data_type * data_count)(*data)
result = self._TSIX_TS_SetConfigItem(device_handle, config_id, byref(_data),
sizeof(_data))
if config_id == ci.TSI_MEMORY_LAYOUT:
result = self._TSIX_TS_SetConfigItem(device_handle, config_id, byref(_data), data_count)
else:
result = self._TSIX_TS_SetConfigItem(device_handle, config_id, byref(_data), sizeof(_data))
elif type(data) == str:
_data = create_string_buffer(data_count)
_data.value = str.encode(data)
@@ -304,7 +326,7 @@ class TSIWrapper(metaclass=Singleton):
result = self._TSIX_TS_SetConfigItem(device_handle, config_id, byref(data),
sizeof(data))
else:
result = TSI_ERROR_NOT_IMPLEMENTED
result = ci.TSI_ERROR_NOT_IMPLEMENTED
return result
@@ -361,22 +383,22 @@ class TSIWrapper(metaclass=Singleton):
return result, from_cstr(err_msg)
def TSIX_PORT_Select(self, device: TSI_HANDLE, port):
def TSIX_PORT_Select(self, device: ci.TSI_HANDLE, port):
return self._TSIX_PORT_Select(device, port)
def TSIX_PORT_Deselect(self, device: TSI_HANDLE, port):
def TSIX_PORT_Deselect(self, device: ci.TSI_HANDLE, port):
return self._TSIX_PORT_Deselect(device, port)
def TSIX_TS_RunTest(self, device: TSI_HANDLE, test_id: int):
def TSIX_TS_RunTest(self, device: ci.TSI_HANDLE, test_id: int):
return self._TSIX_TS_RunTest(device, c_uint32(test_id))
def TSIX_TS_AbortTests(self, device: TSI_HANDLE):
def TSIX_TS_AbortTests(self, device: ci.TSI_HANDLE):
return self._TSIX_TS_AbortTests(device)
def TSIX_PORT_GetTestCount(self, device: TSI_HANDLE, port: TSI_LOGICAL_PORT):
def TSIX_PORT_GetTestCount(self, device: ci.TSI_HANDLE, port: ci.TSI_TEST_ID):
return self._TSIX_PORT_GetTestCount(device, port)
def TSIX_PORT_GetTestInfo(self, device: TSI_HANDLE, port: TSI_LOGICAL_PORT, test_index: int):
def TSIX_PORT_GetTestInfo(self, device: ci.TSI_HANDLE, port: ci.TSI_TEST_ID, test_index: int):
msg_size = c_uint32(1024)
test_id = c_uint32(0)
msg_buffer = create_string_buffer(msg_size.value)
@@ -386,10 +408,10 @@ class TSIWrapper(metaclass=Singleton):
msg_buffer, msg_size)
return test_id.value, test_flags.value, from_cstr(msg_buffer)
def TSIX_STLOG_WaitMessage(self, device: TSI_HANDLE, max_wait: int):
def TSIX_STLOG_WaitMessage(self, device: ci.TSI_HANDLE, max_wait: int):
return self._TSIX_STLOG_WaitMessage(device, c_int32(max_wait))
def TSIX_STLOG_GetMessageData(self, device: TSI_HANDLE):
def TSIX_STLOG_GetMessageData(self, device: ci.TSI_HANDLE):
msg_size = c_uint32(1024)
out_size = c_uint32(0)
msg_buffer = create_string_buffer(msg_size.value)
@@ -399,7 +421,7 @@ class TSIWrapper(metaclass=Singleton):
return result, from_cstr(msg_buffer), out_size.value
def TSI_CreateEventParser(self, timestamp_res: int = 100):
result = c_int32(TSI_SUCCESS)
result = c_int32(ci.TSI_SUCCESS)
return self._TSI_CreateEventParser(byref(result), c_uint32(timestamp_res))
def TSI_RemoveEventParser(self, parser):
@@ -428,14 +450,14 @@ class TSIWrapper(metaclass=Singleton):
if to_dict:
return result, \
{
'timestamp': timestamp.value,
'type': from_cstr(typeStr),
'brief': from_cstr(briefStr),
'content': from_cstr(contentStr),
'source': from_cstr(eventSourceStr),
'data': data[12:]
}
{
'timestamp': timestamp.value,
'type': from_cstr(typeStr),
'brief': from_cstr(briefStr),
'content': from_cstr(contentStr),
'source': from_cstr(eventSourceStr),
'data': data[12:]
}
else:
return result, timestamp.value, from_cstr(typeStr), from_cstr(briefStr), from_cstr(
contentStr), from_cstr(
@@ -467,19 +489,21 @@ class TSI_INIT_CONFIGURATION(Structure):
super().__init__(*args, **kwargs)
self.size = 0
self.version = 0
self.function = TSI_USER_LOG_FUNCTION()
self.function = ci.TSI_USER_LOG_FUNCTION()
_fields_ = [
("size", c_uint),
("version", c_uint),
("function", TSI_USER_LOG_FUNCTION),
("function", ci.TSI_USER_LOG_FUNCTION),
]
def get_config_item_name(config_item) -> str:
items = globals().items()
variable_name = [k for k, v in items if v == config_item][0]
return variable_name
for module in (ci, p_ci):
for k, v in vars(module).items():
if v == config_item:
return k
raise Exception(f"Item {config_item} not found in tsi.py and private_types_tsi.py")
def from_cstr(src_str):
@@ -494,10 +518,10 @@ def to_cstr(src_str):
def show_error(error_code):
if error_code >= TSI_SUCCESS:
if error_code >= ci.TSI_SUCCESS:
return False
result = TSI_MISC_GetErrorDescription(error_code)
if result[0] < TSI_SUCCESS:
if result[0] < ci.TSI_SUCCESS:
val = f"Error {str(error_code)}: (No description available)\n"
else:
val = f"Error {str(error_code)}: {str(result[1])}\n"
@@ -576,7 +600,7 @@ def TSI_MISC_GetErrorDescription(error):
return TSIWrapper().TSI_MISC_GetErrorDescription(error)
def TSIX_PORT_Select(device: TSI_HANDLE, port):
def TSIX_PORT_Select(device: ci.TSI_HANDLE, port):
return TSIWrapper().TSIX_PORT_Select(device, port)
@@ -584,27 +608,27 @@ def TSIX_PORT_Deselect(device, port):
return TSIWrapper().TSIX_PORT_Deselect(device, port)
def TSIX_TS_RunTest(device: TSI_HANDLE, test_id: int):
def TSIX_TS_RunTest(device: ci.TSI_HANDLE, test_id: int):
return TSIWrapper().TSIX_TS_RunTest(device, test_id)
def TSIX_TS_AbortTests(device: TSI_HANDLE):
def TSIX_TS_AbortTests(device: ci.TSI_HANDLE):
return TSIWrapper().TSIX_TS_AbortTests(device)
def TSIX_PORT_GetTestCount(device: TSI_HANDLE, port: TSI_LOGICAL_PORT):
def TSIX_PORT_GetTestCount(device: ci.TSI_HANDLE, port: ci.TSI_TEST_ID):
return TSIWrapper().TSIX_PORT_GetTestCount(device, port)
def TSIX_PORT_GetTestInfo(device: TSI_HANDLE, port: TSI_LOGICAL_PORT, test_index: int):
def TSIX_PORT_GetTestInfo(device: ci.TSI_HANDLE, port: ci.TSI_TEST_ID, test_index: int):
return TSIWrapper().TSIX_PORT_GetTestInfo(device, port, test_index)
def TSIX_STLOG_WaitMessage(device: TSI_HANDLE, max_wait: int):
def TSIX_STLOG_WaitMessage(device: ci.TSI_HANDLE, max_wait: int):
return TSIWrapper().TSIX_STLOG_WaitMessage(device, max_wait)
def TSIX_STLOG_GetMessageData(device: TSI_HANDLE):
def TSIX_STLOG_GetMessageData(device: ci.TSI_HANDLE):
return TSIWrapper().TSIX_STLOG_GetMessageData(device)

154
UniTAP/libs/lib_tsi/tsi_io.py
View File

@@ -3,23 +3,11 @@ from ctypes import c_uint32, c_char
from typing import Callable, Tuple, List
from enum import IntEnum
from .tsi import (TSI_HANDLE, TSI_LOGICAL_PORT, TSI_SUCCESS, \
TSIX_TS_SetConfigItem, TSIX_TS_GetConfigItem, TSIX_TS_SetPortConfigItem, \
TSIX_TS_GetPortConfigItem, TSIX_Init, TSI_Clean, TSIX_DEV_RescanDevices, \
TSIX_DEV_OpenDevice, TSIX_DEV_GetDeviceName, TSIX_DEV_GetDeviceCount,
TSIX_DEV_CloseDevice, \
TSIX_DEV_GetDeviceRoleCount, TSIX_DEV_SelectRole, TSIX_DEV_GetDeviceRoleName,
TSIX_PORT_Select, \
get_config_item_name, TSIX_TS_RunTest, TSIX_STLOG_WaitMessage,
TSIX_STLOG_GetMessageData, \
TSIX_PORT_GetTestCount, TSIX_PORT_GetTestInfo, TSI_TS_OF_MODE, \
TSI_OFMODE_RUN_CALL_STRUCT_PROCEDURE, TSI_TS_OF_REQ_ID, TSI_TS_OF_CALLBACK,
TSI_FW_VERSION_TEXT,
Structure, TSI_TEST_STATUS, TSI_DEVICE_INFO_R, TSI_BUNDLE_VERSION_TEXT, \
TSI_OFMODE_RUN_CALL_STRUCT_PROCEDURE_AND_RESULT, TSI_DEV_SetSearchMask,
DeviceMaskInternal, \
TSI_TEST_LOG_CONFIGURATION, TSI_TEST_ERROR_CODE_R, TSI_TEST_PASSED, TSI_TEST_FAILED,
TSI_TEST_NOT_STARTED, TSI_TEST_ABORTED, TSIX_TS_AbortTests, TSI_TEST_DLG_CONFIG)
from _ctypes import Structure
import UniTAP.libs.lib_tsi.tsi_types as ci
import UniTAP.libs.lib_tsi.tsi as tsi
import UniTAP.libs.lib_tsi.tsi_private_types as p_ci
from UniTAP.utils import tsi_logging as logging
@@ -53,7 +41,7 @@ class TestDialogConfig(Structure):
class PortIO:
def __init__(self, device: TSI_HANDLE, index: TSI_LOGICAL_PORT, protocol: PortProtocol):
def __init__(self, device: ci.TSI_HANDLE, index: p_ci.TSI_LOGICAL_PORT, protocol: PortProtocol):
logging.info(f"[UniTAP] PortIO.init: {self}")
self.__device = device
self.__index = index
@@ -63,30 +51,30 @@ class PortIO:
def __del__(self):
logging.info(f"[UniTAP] PortIO.del: {self}")
def set(self, config_id, data, data_type=c_uint32, data_count=1, data_size=0):
result = TSIX_TS_SetPortConfigItem(self.__device, self.__index, config_id, data, data_type,
data_count,
data_size)
def set(self, config_id: int, data, data_type=c_uint32, data_count=1, data_size=0):
result = tsi.TSIX_TS_SetPortConfigItem(self.__device, self.__index, config_id, data, data_type,
data_count,
data_size)
if isinstance(data, bytearray):
logging.debug(f"[UniTAP] PortIO.set {self} {get_config_item_name(config_id)} "
logging.debug(f"[UniTAP] PortIO.set {self} {tsi.get_config_item_name(config_id)} "
f"with data: {data[:(10 if len(data) > 10 else len(data))]}[{len(data)}] "
f"({type(data)}); result: {result}")
else:
logging.debug(f"[UniTAP] PortIO.set {self} {get_config_item_name(config_id)} "
logging.debug(f"[UniTAP] PortIO.set {self} {tsi.get_config_item_name(config_id)} "
f"with data: {data} ({type(data)}); result: {result}")
return result
def get(self, config_id, data_type=c_uint32, data_count=1):
result = TSIX_TS_GetPortConfigItem(self.__device, self.__index, config_id, data_type,
data_count)
def get(self, config_id: int, data_type=c_uint32, data_count=1):
result = tsi.TSIX_TS_GetPortConfigItem(self.__device, self.__index, config_id, data_type,
data_count)
logging.debug(
f"PortIO.get {self} {get_config_item_name(config_id)} "
f"PortIO.get {self} {tsi.get_config_item_name(config_id)} "
f"with type: {data_type}[{data_count}]; result: {result}")
return result
def active(self):
TSIX_PORT_Select(self.__device, self.__index)
tsi.TSIX_PORT_Select(self.__device, self.__index)
def get_test_list(self) -> List[Tuple[int, int, str]]:
test_list = []
@@ -102,10 +90,10 @@ class PortIO:
return self.__index
def __get_test_count(self) -> int:
return TSIX_PORT_GetTestCount(self.__device, self.__index)
return tsi.TSIX_PORT_GetTestCount(self.__device, self.__index)
def __get_test_info(self, test_id: int):
return TSIX_PORT_GetTestInfo(self.__device, self.__index, test_id)
return tsi.TSIX_PORT_GetTestInfo(self.__device, self.__index, test_id)
class DeviceIO:
@@ -113,13 +101,12 @@ class DeviceIO:
def __init__(self, index: int):
logging.info(f"[UniTAP] DeviceIO.init: {self}")
self.__device = TSIX_DEV_OpenDevice(index)
self.__device = tsi.TSIX_DEV_OpenDevice(index)
self.__port_io_list = [] # type: list[PortIO]
self.__current_role = None
def __del__(self):
self.__port_io_list.clear()
TSIX_DEV_CloseDevice(self.__device)
self.close()
logging.info(f"[UniTAP] DeviceIO.del: {self}")
@property
@@ -127,35 +114,35 @@ class DeviceIO:
return self.__device
def set(self, config_id, data, data_type=c_uint32, data_count=1, data_size=0):
return TSIX_TS_SetConfigItem(self.__device, config_id, data, data_type, data_count,
data_size)
return tsi.TSIX_TS_SetConfigItem(self.__device, config_id, data, data_type, data_count,
data_size)
def get(self, config_id, data_type=c_uint32, data_count=1):
return TSIX_TS_GetConfigItem(self.__device, config_id, data_type, data_count)
return tsi.TSIX_TS_GetConfigItem(self.__device, config_id, data_type, data_count)
def get_device_role_count(self) -> int:
return TSIX_DEV_GetDeviceRoleCount(self.__device)
return tsi.TSIX_DEV_GetDeviceRoleCount(self.__device)
def get_device_role_name(self, index) -> str:
return TSIX_DEV_GetDeviceRoleName(self.__device, index)[1]
return tsi.TSIX_DEV_GetDeviceRoleName(self.__device, index)[1]
def select_role(self, index):
logging.info(
f"[UniTAP] DeviceIO.select_role: {index}")
return TSIX_DEV_SelectRole(self.__device, index)
return tsi.TSIX_DEV_SelectRole(self.__device, index)
def create_port_io(self, index, protocol: PortProtocol) -> PortIO:
self.__port_io_list.append(PortIO(self.__device, index, protocol))
return weakref.proxy(self.__port_io_list[-1])
def set_opf_callback(self, callback: Callable):
TSIX_TS_SetConfigItem(self.__device, TSI_TS_OF_MODE,
TSI_OFMODE_RUN_CALL_STRUCT_PROCEDURE_AND_RESULT)
TSIX_TS_SetConfigItem(self.__device, TSI_TS_OF_REQ_ID, -1)
TSIX_TS_SetConfigItem(self.__device, TSI_TS_OF_CALLBACK, callback)
tsi.TSIX_TS_SetConfigItem(self.__device, ci.TSI_TS_OF_MODE,
ci.TSI_OFMODE_RUN_CALL_STRUCT_PROCEDURE_AND_RESULT)
tsi.TSIX_TS_SetConfigItem(self.__device, ci.TSI_TS_OF_REQ_ID, -1)
tsi.TSIX_TS_SetConfigItem(self.__device, ci.TSI_TS_OF_CALLBACK, callback)
def set_opf_config(self, config: TestDialogConfig):
self.set(TSI_TEST_DLG_CONFIG, config)
self.set(p_ci.TSI_TEST_DLG_CONFIG, config)
def get_test_list(self) -> List[Tuple[int, int, str]]:
test_list = []
@@ -168,50 +155,62 @@ class DeviceIO:
f"[UniTAP] DeviceIO.run_test with id: {hex(test_id)} "
f"(group={test_id >> 16 & 0xffff}; test={test_id & 0xffff})")
result = TSIX_TS_RunTest(self.__device, test_id)
result = tsi.TSIX_TS_RunTest(self.__device, test_id)
if result not in [TSI_TEST_PASSED, TSI_TEST_FAILED, TSI_TEST_NOT_STARTED, TSI_TEST_ABORTED]:
result = TSI_TEST_FAILED
if result not in [ci.TSI_TEST_PASSED, ci.TSI_TEST_FAILED, ci.TSI_TEST_NOT_STARTED, ci.TSI_TEST_ABORTED]:
result = ci.TSI_TEST_FAILED
return result
def abort_test(self):
logging.info(f"[UniTAP] DeviceIO.abort_test")
return TSIX_TS_AbortTests(self.__device)
return tsi.TSIX_TS_AbortTests(self.__device)
def set_test_config(self, config: int):
if config > 0xffffffff or config < 0:
raise ValueError("Test config value must be more than 0 and less than 0xffffffff")
TSIX_TS_SetConfigItem(self.__device, TSI_TEST_LOG_CONFIGURATION, config)
tsi.TSIX_TS_SetConfigItem(self.__device, ci.TSI_TEST_LOG_CONFIGURATION, config)
def is_log_message_available(self, max_wait_timeout=5000) -> int:
return int(TSIX_STLOG_WaitMessage(self.__device, max_wait_timeout))
return int(tsi.TSIX_STLOG_WaitMessage(self.__device, max_wait_timeout))
def get_test_log_message(self) -> str:
return TSIX_STLOG_GetMessageData(self.__device)
return tsi.TSIX_STLOG_GetMessageData(self.__device)
def get_test_status(self) -> TestStatus:
return TSIX_TS_GetConfigItem(self.__device, TSI_TEST_STATUS, TestStatus, 1)[1]
return tsi.TSIX_TS_GetConfigItem(self.__device, p_ci.TSI_TEST_STATUS, TestStatus, 1)[1]
def get_test_error_code(self) -> int:
return TSIX_TS_GetConfigItem(self.__device, TSI_TEST_ERROR_CODE_R, c_uint32, 1)[1]
return tsi.TSIX_TS_GetConfigItem(self.__device, p_ci.TSI_TEST_ERROR_CODE_R, c_uint32, 1)[1]
def get_fw_version_string(self):
return TSIX_TS_GetConfigItem(self.__device, TSI_FW_VERSION_TEXT, c_char,
self.MAX_FW_VERSION_STR_SIZE)[1].value.decode('utf-8')
return tsi.TSIX_TS_GetConfigItem(self.__device, ci.TSI_FW_VERSION_TEXT, c_char,
self.MAX_FW_VERSION_STR_SIZE)[1].value.decode('utf-8')
def get_prepared_fw_info(self):
return TSIX_TS_GetConfigItem(self.__device, TSI_DEVICE_INFO_R, c_char,
self.MAX_FW_VERSION_STR_SIZE)[1].value.decode('utf-8')
return tsi.TSIX_TS_GetConfigItem(self.__device, p_ci.TSI_DEVICE_INFO_R, c_char,
self.MAX_FW_VERSION_STR_SIZE)[1].value.decode('utf-8')
def get_bundle_version(self):
ver = TSIX_TS_GetConfigItem(self.__device, TSI_BUNDLE_VERSION_TEXT, c_char,
self.MAX_FW_VERSION_STR_SIZE)[1].value.decode('utf-8')
ver = tsi.TSIX_TS_GetConfigItem(self.__device, ci.TSI_BUNDLE_VERSION_TEXT, c_char,
self.MAX_FW_VERSION_STR_SIZE)[1].value.decode('utf-8')
if ver == '':
ver = 'not specified (NOT FOR SHARING)'
return ver
def is_fw_update_available(self) -> bool:
return bool(tsi.TSIX_TS_GetConfigItem(self.__device, p_ci.TSI_UPDATE_INFO_TEXT_R, c_char,
self.MAX_FW_VERSION_STR_SIZE)[1].value.decode('utf-8') != '')
def get_fw_update_info(self) -> str:
ver = tsi.TSIX_TS_GetConfigItem(self.__device, p_ci.TSI_UPDATE_INFO_TEXT_R, c_char,
self.MAX_FW_VERSION_STR_SIZE)[1].value.decode('utf-8')
if ver == '':
ver = "No update needed"
return ver
def set_role(self, role):
self.__current_role = role
@@ -220,37 +219,44 @@ class DeviceIO:
return weakref.proxy(self.__current_role)
return None
def get_role_type(self):
if self.__current_role is not None:
return type(self.__current_role)
return None
def reset(self):
command = 4
tsi.TSIX_TS_SetConfigItem(self.__device, ci.TSI_DEVICE_HW_RESET, command)
def close(self):
self.__port_io_list.clear()
tsi.TSIX_DEV_CloseDevice(self.__device)
class BaseIO:
def __init__(self):
self.__ref_count = TSIX_Init()
self.__ref_count = tsi.TSIX_Init()
logging.info(f"[UniTAP] BaseIO.init: {self}; Ref count: {self.__ref_count}")
TSIX_DEV_RescanDevices()
tsi.TSIX_DEV_RescanDevices()
def cleanup(self):
self.__ref_count = TSI_Clean()
self.__ref_count = tsi.TSI_Clean()
logging.info(f"[UniTAP] BaseIO.del: {self}; Ref count: {self.__ref_count}")
def rescan_devices(self):
if self.__ref_count > 0:
TSIX_DEV_RescanDevices()
return
logging.error("[UniTAP] BaseIO.rescan_devices call without TSI_Init")
def get_device_count(self) -> int:
if self.__ref_count > 0:
return TSIX_DEV_GetDeviceCount()
return tsi.TSIX_DEV_GetDeviceCount()
logging.error("[UniTAP] BaseIO.get_device_count call without TSI_Init")
def get_device_name(self, index) -> str:
if self.__ref_count > 0:
return TSIX_DEV_GetDeviceName(index)[1]
return tsi.TSIX_DEV_GetDeviceName(index)[1]
logging.error("[UniTAP] BaseIO.get_device_name call without TSI_Init")
def get_devices_by_mask(self, require_caps: DeviceMaskInternal,
unallowed_caps: DeviceMaskInternal):
def get_devices_by_mask(self, require_caps: p_ci.DeviceMaskInternal,
unallowed_caps: p_ci.DeviceMaskInternal):
if self.__ref_count > 0:
return TSI_DEV_SetSearchMask(require_caps.value, unallowed_caps.value)
return tsi.TSI_DEV_SetSearchMask(require_caps.value, unallowed_caps.value)
logging.error("[UniTAP] BaseIO.get_devices_by_mask call without TSI_Init")
def create_device_io(self, index: int) -> DeviceIO:

159
UniTAP/libs/lib_tsi/tsi_private_types.py
View File

@@ -1,20 +1,23 @@
from UniTAP.libs.lib_tsi.tsi_types import *
from ctypes import c_uint
from enum import IntEnum
import UniTAP.libs.lib_tsi.tsi_types as ci
TSI_CAP_OWNER_UNKNOWN = 0x0
TSI_CAP_OWNER_NONE = 0x1
TSI_CAP_OWNER_TEST_SYSTEM = 0x2
TSI_CAP_OWNER_PREVIEW = 0x3
TSI_CAP_OWNER = TSI_BASE_LEGACY_CAP(0x1f)
TSI_CAP_OWNER = ci.TSI_BASE_LEGACY_CAP(0x1f)
TSI_SEARCHOPTIONS_FIX_500_IN_UCDCONFIG = 0x80000000
TSI_VIDCAP_AVAILABLE_FRAME_COUNT_R = TSI_BASE_LEGACY_VIDCAP(0x1d)
TSI_VIDCAP_CAPTURE_STATUS_R = TSI_BASE_LEGACY_VIDCAP(0x1e)
TSI_VIDCAP_AVAILABLE_FRAME_COUNT_R = ci.TSI_BASE_LEGACY_VIDCAP(0x1d)
TSI_VIDCAP_CAPTURE_STATUS_R = ci.TSI_BASE_LEGACY_VIDCAP(0x1e)
TSI_VIDCAP_AVAILABLE_FRAME_COUNT = TSI_VIDCAP_AVAILABLE_FRAME_COUNT_R
TSI_CRC_MEASUREMENT_DATA_R = TSI_BASE_R_CRC_VIDEO(0x3)
TSI_CRC_MEASUREMENT_DATA_R = ci.TSI_BASE_R_CRC_VIDEO(0x3)
TSI_AUDCAP_PACKET_HEADER_R = TSI_BASE_LEGACY_AUDCAP(0xe)
TSI_AUDCAP_PACKET_HEADER_R = ci.TSI_BASE_LEGACY_AUDCAP(0xe)
TSI_PG_ADAPTIVE_SYNC_CTRL = 0x733
TSI_PG_ADAPTIVE_SYNC_CAPS = 0x734
@@ -24,59 +27,59 @@ TSI_PG_PR_CAPS_R = 0x737
TSI_PG_PR_CTRL_W = 0x738
TSI_PG_PR_STATUS_R = 0x738
TSI_PG_PR_CFG = 0x739
TSI_DPTX_EVENTS = TSI_BASE_DPTX(0x0e)
TSI_DPTX_POST_LT_FEATURES = TSI_BASE_DPTX(0x68)
TSI_DPTX_SDP_CTRL = TSI_BASE_DPTX(0x74)
TSI_DPTX_EVENTS = ci.TSI_BASE_DPTX(0x0e)
TSI_DPTX_POST_LT_FEATURES = ci.TSI_BASE_DPTX(0x68)
TSI_DPTX_SDP_CTRL = ci.TSI_BASE_DPTX(0x74)
TSI_TEST_STATUS = 0x80000019 # Used for reading test status.
TSI_DEVICE_INFO_R = 0x80000020 # Used for reading FW version
TSI_TEST_ERROR_CODE_R = 0x80000021 # Used for reading test error code
TSI_PDC_DPAM_CONFIG_R = TSI_BASE_PDC(0x33)
TSI_PDC_HW_CAPS_R = TSI_BASE_PDC(0x00)
TSI_PDC_CONTRACT_DATA = TSI_BASE_PDC(0x09)
TSI_PDC_TX_ID_VDO_CNT = TSI_BASE_PDC(0x14)
TSI_PDC_TX_ID_VDO = TSI_BASE_PDC(0x15)
TSI_PDC_DPAM_CONFIG_R = ci.TSI_BASE_PDC(0x33)
TSI_PDC_HW_CAPS_R = ci.TSI_BASE_PDC(0x00)
TSI_PDC_CONTRACT_DATA = ci.TSI_BASE_PDC(0x09)
TSI_PDC_TX_ID_VDO_CNT = ci.TSI_BASE_PDC(0x14)
TSI_PDC_TX_ID_VDO = ci.TSI_BASE_PDC(0x15)
TSI_DPTX_OUT_LC = TSI_BASE_DPTX(0x52)
TSI_DPTX_OUT_BR = TSI_BASE_DPTX(0x53)
TSI_DPTX_OUT_LINK_MODE = TSI_BASE_DPTX(0x54)
TSI_DP2TX_OUT_BR = TSI_BASE_DPTX(0x55)
TSI_DP2TX_OUT_LC = TSI_BASE_DPTX(0x5A)
TSI_DP2TX_OUT_TEST_PATTERN = TSI_BASE_DPTX(0x5B)
TSI_DPTX_OUT_LC = ci.TSI_BASE_DPTX(0x52)
TSI_DPTX_OUT_BR = ci.TSI_BASE_DPTX(0x53)
TSI_DPTX_OUT_LINK_MODE = ci.TSI_BASE_DPTX(0x54)
TSI_DP2TX_OUT_BR = ci.TSI_BASE_DPTX(0x55)
TSI_DP2TX_OUT_LC = ci.TSI_BASE_DPTX(0x5A)
TSI_DP2TX_OUT_TEST_PATTERN = ci.TSI_BASE_DPTX(0x5B)
TSI_MLEG_CONTROL = TSI_BASE_MLEG(0x00)
TSI_MLEG_SYMBOL_REPLACE_A = TSI_BASE_MLEG(0x01)
TSI_MLEG_SYMBOL_REPLACE_MASK_A = TSI_BASE_MLEG(0x02)
TSI_MLEG_SYMBOL_REPLACE_B = TSI_BASE_MLEG(0x03)
TSI_MLEG_SYMBOL_REPLACE_MASK_B = TSI_BASE_MLEG(0x04)
TSI_MLEG_DELAY_COUNTER = TSI_BASE_MLEG(0x0A)
TSI_MLEG_LANE0_REPLACE_COUNTERS = TSI_BASE_MLEG(0x05)
TSI_MLEG_LANE1_REPLACE_COUNTERS = TSI_BASE_MLEG(0x06)
TSI_MLEG_LANE2_REPLACE_COUNTERS = TSI_BASE_MLEG(0x07)
TSI_MLEG_LANE3_REPLACE_COUNTERS = TSI_BASE_MLEG(0x08)
TSI_MLEG_CONTROL = ci.TSI_BASE_MLEG(0x00)
TSI_MLEG_SYMBOL_REPLACE_A = ci.TSI_BASE_MLEG(0x01)
TSI_MLEG_SYMBOL_REPLACE_MASK_A = ci.TSI_BASE_MLEG(0x02)
TSI_MLEG_SYMBOL_REPLACE_B = ci.TSI_BASE_MLEG(0x03)
TSI_MLEG_SYMBOL_REPLACE_MASK_B = ci.TSI_BASE_MLEG(0x04)
TSI_MLEG_DELAY_COUNTER = ci.TSI_BASE_MLEG(0x0A)
TSI_MLEG_LANE0_REPLACE_COUNTERS = ci.TSI_BASE_MLEG(0x05)
TSI_MLEG_LANE1_REPLACE_COUNTERS = ci.TSI_BASE_MLEG(0x06)
TSI_MLEG_LANE2_REPLACE_COUNTERS = ci.TSI_BASE_MLEG(0x07)
TSI_MLEG_LANE3_REPLACE_COUNTERS = ci.TSI_BASE_MLEG(0x08)
TSI_HDCP_2X_CFG = TSI_BASE_LEGACY_HDCP2(0x2)
TSI_HDCP_2X_CFG = ci.TSI_BASE_LEGACY_HDCP2(0x2)
TSI_W_PDC_EPR_MODE_CONTROL = TSI_BASE_PDC(0x04)
TSI_W_PDC_EPR_MODE_CONTROL = ci.TSI_BASE_PDC(0x04)
TSI_EVCAP_TIMESTAMP = TSI_BASE_LEGACY_EVCAP(0x8)
TSI_EVCAP_TIMESTAMP = ci.TSI_BASE_LEGACY_EVCAP(0x8)
TSI_DPRX_INF_VALID_EX = TSI_BASE_DPRX(0x29)
TSI_DPRX_SDP_CRC16_CTRL = TSI_BASE_DPRX(0x98)
TSI_DPRX_SDP_CRC16_COUNTERS = TSI_BASE_DPRX(0x99)
TSI_DPRX_INF_VALID_EX = ci.TSI_BASE_DPRX(0x29)
TSI_DPRX_SDP_CRC16_CTRL = ci.TSI_BASE_DPRX(0x98)
TSI_DPRX_SDP_CRC16_COUNTERS = ci.TSI_BASE_DPRX(0x99)
TSI_HDRX_INF_STATUS = TSI_BASE_HDRX(0x0C)
TSI_HDRX_INF_VALID = TSI_BASE_HDRX(0x0D)
TSI_HDRX_INF_SELECT = TSI_BASE_HDRX(0x0E)
TSI_HDRX_INF_DATA = TSI_BASE_HDRX(0x0F)
TSI_HDRX_INF_STATUS = ci.TSI_BASE_HDRX(0x0C)
TSI_HDRX_INF_VALID = ci.TSI_BASE_HDRX(0x0D)
TSI_HDRX_INF_SELECT = ci.TSI_BASE_HDRX(0x0E)
TSI_HDRX_INF_DATA = ci.TSI_BASE_HDRX(0x0F)
MAX_EDID_SIZE = 4096
TSI_DPRX_DSC_TEST_CRC = TSI_BASE_DPRX(0x43)
TSI_DPRX_CRD_FEATURES = TSI_BASE_DPRX(0x63)
TSI_DPRX_ALPM_LT_INFO_R = TSI_BASE_DPRX(0x38)
TSI_DPRX_DSC_TEST_CRC = ci.TSI_BASE_DPRX(0x43)
TSI_DPRX_CRD_FEATURES = ci.TSI_BASE_DPRX(0x63)
TSI_DPRX_ALPM_LT_INFO_R = ci.TSI_BASE_DPRX(0x38)
TSI_DPRX_MSA_INFO_R = TSI_BASE_DPRX(0x48)
TSI_DPRX_MST_STATUS_R = TSI_BASE_DPRX(0x49)
TSI_DPRX_MSA_INFO_R = ci.TSI_BASE_DPRX(0x48)
TSI_DPRX_MST_STATUS_R = ci.TSI_BASE_DPRX(0x49)
TSI_GENERIC_STATUS = 0x210 # TSI State flags. NOTE: Access mode changes to R+W
@@ -86,15 +89,15 @@ TSI_HDCP_COMPLIANT_R = 0x8000f002
TSI_DSC_BLOCK_NO = 0x80000009 # Used for stating start & end address to DSC PG. Changed 20191202 because not properly reserved.
TSI_CRC_DEFINITIONS = TSI_BASE_CRC_VIDEO(14) # CRC definitions. Default setting is 0
TSI_CRC_WINDOW_0_0 = TSI_BASE_CRC_VIDEO(15) # Left border/window pixel for first window 15..0. Top border/window line for first window 31..16. Default setting is 0
TSI_CRC_WINDOW_0_1 = TSI_BASE_CRC_VIDEO(16) # Right border pixel/ window width for first window. 15..0. Bottom border line / window height for first window 31..16. Default setting is 0
TSI_CRC_WINDOW_1_0 = TSI_BASE_CRC_VIDEO(17) # Left border/window pixel for second window 15..0. Top border/window line for second window 31..16. Default setting is 0
TSI_CRC_WINDOW_1_1 = TSI_BASE_CRC_VIDEO(18) # Right border pixel/ window width for second window. 15..0. Bottom border line / window height for second window 31..16. Default setting is 0
TSI_CRC_WINDOW_2_0 = TSI_BASE_CRC_VIDEO(19) # Left border/window pixel for third window 15..0. Top border/window line for third window 31..16. Default setting is 0
TSI_CRC_WINDOW_2_1 = TSI_BASE_CRC_VIDEO(20) # Right border pixel/ window width for third window. 15..0. Bottom border line / window height for third window 31..16. Default setting is 0
TSI_CRC_WINDOW_3_0 = TSI_BASE_CRC_VIDEO(21) # Left border/window pixel for fourth window 15..0. Top border/window line for fourth window 31..16. Default setting is 0
TSI_CRC_WINDOW_3_1 = TSI_BASE_CRC_VIDEO(22) # Right border pixel/ window width for fourth window. 15..0. Bottom border line / window height for fourth window 31..16. Default setting is 0
TSI_CRC_DEFINITIONS = ci.TSI_BASE_CRC_VIDEO(14) # CRC definitions. Default setting is 0
TSI_CRC_WINDOW_0_0 = ci.TSI_BASE_CRC_VIDEO(15) # Left border/window pixel for first window 15..0. Top border/window line for first window 31..16. Default setting is 0
TSI_CRC_WINDOW_0_1 = ci.TSI_BASE_CRC_VIDEO(16) # Right border pixel/ window width for first window. 15..0. Bottom border line / window height for first window 31..16. Default setting is 0
TSI_CRC_WINDOW_1_0 = ci.TSI_BASE_CRC_VIDEO(17) # Left border/window pixel for second window 15..0. Top border/window line for second window 31..16. Default setting is 0
TSI_CRC_WINDOW_1_1 = ci.TSI_BASE_CRC_VIDEO(18) # Right border pixel/ window width for second window. 15..0. Bottom border line / window height for second window 31..16. Default setting is 0
TSI_CRC_WINDOW_2_0 = ci.TSI_BASE_CRC_VIDEO(19) # Left border/window pixel for third window 15..0. Top border/window line for third window 31..16. Default setting is 0
TSI_CRC_WINDOW_2_1 = ci.TSI_BASE_CRC_VIDEO(20) # Right border pixel/ window width for third window. 15..0. Bottom border line / window height for third window 31..16. Default setting is 0
TSI_CRC_WINDOW_3_0 = ci.TSI_BASE_CRC_VIDEO(21) # Left border/window pixel for fourth window 15..0. Top border/window line for fourth window 31..16. Default setting is 0
TSI_CRC_WINDOW_3_1 = ci.TSI_BASE_CRC_VIDEO(22) # Right border pixel/ window width for fourth window. 15..0. Bottom border line / window height for fourth window 31..16. Default setting is 0
TSI_R_LC_COUNT = 0x80000010 # Number of licenses available.
TSI_W_LC_SELECT = 0x80000011 # Index from 0 to LC_Count-1: Select which license to access through the CI's below
@@ -107,34 +110,48 @@ TSI_W_LC_HAS_CODE = 0x80000017 # Check if specified code is
TSI_R_LC_SHA_TYPE = 0x80000018 # Check SHA type used in device.
TSI_DEVICE_DESCRIPTOR = 0x81000000
TSI_DEBUG_INFORMATION = 0x82000000
TSI_DEBUG_INFORMATION = 0x82000000
TSI_SELECT_SUITE = TSI_BASE_TEST(0x04)
TSI_TEST_DLG_CONFIG = TSI_BASE_TEST(0x22)
TSI_SELECT_SUITE = ci.TSI_BASE_TEST(0x04)
TSI_TEST_DLG_CONFIG = ci.TSI_BASE_TEST(0x22)
TSI_LOGICAL_PORT = c_uint
TSI_PORT_FLAGS = c_uint
TSI_DPRX_ALPM_STATS_CONTROL_W = TSI_BASE_DPRX(0x60)
TSI_DPRX_ALPM_STATS_STATUS_R = TSI_BASE_DPRX(0x60)
TSI_DPRX_ALPM_STATS_VB_R = TSI_BASE_DPRX(0x61)
TSI_DPRX_ALPM_STATS_IFP_R = TSI_BASE_DPRX(0x62)
TSI_DPRX_ALPM_STATS_CONTROL_W = ci.TSI_BASE_DPRX(0x60)
TSI_DPRX_ALPM_STATS_STATUS_R = ci.TSI_BASE_DPRX(0x60)
TSI_DPRX_ALPM_STATS_VB_R = ci.TSI_BASE_DPRX(0x61)
TSI_DPRX_ALPM_STATS_IFP_R = ci.TSI_BASE_DPRX(0x62)
TSI_DPRX_ALPM_STATS_CTRL_W = TSI_DPRX_ALPM_STATS_CONTROL_W
TSI_DSC_TX_CRC = TSI_BASE_DSC(0x01)
TSI_DSC_MEMORY_BLOCK = TSI_BASE_DSC(0x05)
TSI_DSC_DATA_SIZE = TSI_BASE_DSC(0x06)
TSI_DSC_TX_CRC = ci.TSI_BASE_DSC(0x01)
TSI_DSC_MEMORY_BLOCK = ci.TSI_BASE_DSC(0x05)
TSI_DSC_DATA_SIZE = ci.TSI_BASE_DSC(0x06)
TSI_TERMINAL_RW = 0xFFFFFFFE
TSI_DPTX_CABLE_ATTRIBUTES_R = TSI_BASE_DPTX(0x6E)
TSI_DPRX_CABLE_ATTRIBUTES_R = TSI_BASE_DPRX(0x6E)
TSI_DPTX_CABLE_ATTRIBUTES_R = ci.TSI_BASE_DPTX(0x6E)
TSI_DPRX_CABLE_ATTRIBUTES_R = ci.TSI_BASE_DPRX(0x6E)
TSI_DPRX_LT_INTERNAL_USE = 0x50000000 + 0xFFFFF
TSI_DPRX_LT_ROUTE_CREATE = TSI_BASE_LEGACY_DPRX(0x1A + TSI_DPRX_LT_INTERNAL_USE)
TSI_UPDATE_AVAILABLE_COUNT_R = ci.TSI_BASE_UPDATE(0x16)
TSI_UPDATE_AVAILABLE_LIST_R = ci.TSI_BASE_UPDATE(0x17)
TSI_UPDATE_INFO_TEXT_R = ci.TSI_BASE_UPDATE(0x18)
class AvailableUpdateStruct(ci.Structure):
_fields_ = [
('chipType', ci.c_char_p),
('currentVersion', ci.c_char_p),
('availableVersion', ci.c_char_p),
]
def __str__(self) -> str:
return (f"Type: {self.chipType.decode(errors='ignore')}\n"
f"Current version: {self.currentVersion.decode(errors='ignore')}\n"
f"Available version: {self.availableVersion.decode(errors='ignore')}\n")
class DeviceMaskInternal(IntEnum):
Sink = TSI_DEVCAP_SINK
Source = TSI_DEVCAP_SOURCE
All = TSI_DEVCAP_ALL_CAPS
Sink = ci.TSI_DEVCAP_SINK
Source = ci.TSI_DEVCAP_SOURCE
All = ci.TSI_DEVCAP_ALL_CAPS
Nothing = 0

40
UniTAP/libs/lib_tsi/tsi_types.py
View File

@@ -1,8 +1,8 @@
import platform
from typing import List
from ctypes import c_void_p, c_int, c_uint, Structure, c_char_p, POINTER, c_bool, c_uint32, \
c_uint64, c_int8, c_uint8, c_char, c_int16, c_int32, c_int64
from ctypes import (c_void_p, c_int, c_uint, Structure, c_char_p, POINTER, c_bool, c_uint32, c_int32, c_uint8, c_char,
c_size_t, c_uint16, c_uint64)
from enum import IntEnum
from ctypes import wintypes
@@ -34,6 +34,7 @@ TSI_BASE_LEGACY_HDCP1 = lambda offset: (0x280 + offset) # Reserved range from 0
TSI_BASE_LEGACY_HDCP2 = lambda offset: (0x290 + offset) # Reserved range from 0x290 to 0x29f.
TSI_BASE_LEGACY_LVDS = lambda offset: (0x2a0 + offset) # Reserved range from 0x2a0 to 0x2af.
TSI_BASE_LEGACY_DPRX = lambda offset: (0x2b0 + offset) # Reserved range from 0x2b0 to 0x2ef.
TSI_BASE_LEGACY_EARC_AUDGEN = lambda offset: (0x2c0 + offset) # Reserved range from 0x2f0 to 0x2ff.
TSI_BASE_LEGACY_AUDGEN = lambda offset: (0x2f0 + offset) # Reserved range from 0x2f0 to 0x2ff.
TSI_BASE_LEGACY_CAP = lambda offset: (0x300 + offset) # Reserved range from 0x300 to 0x31f.
TSI_BASE_LEGACY_VIDCAP = lambda offset: (0x320 + offset) # Reserved range from 0x320 to 0x33f.
@@ -92,12 +93,14 @@ TSI_BASE_HDRX = lambda offset: (0x50000000 + 0x23000 + offset)
TSI_BASE_HDTX = lambda offset: (0x50000000 + 0x24000 + offset)
TSI_BASE_SPDIF = lambda offset: (0x50000000 + 0x25000 + offset)
TSI_BASE_PDC = lambda offset: (0x50000000 + 0x26000 + offset)
TSI_BASE_PACKETSGEN = lambda offset: (0x50000000 + 0x2A000 + offset)
TSI_BASE_PLAYBACK = lambda offset: (0x50000000 + 0x2B000 + offset)
TSI_BASE_BULK_CAPTURE = lambda offset: (0x50000000 + 0x2C000 + offset)
TSI_BASE_MLEG = lambda offset: (0x50000000 + 0x2D000 + offset)
TSI_BASE_DSC = lambda offset: (0x50000000 + 0x32000 + offset)
TSI_BASE_INPUT = lambda offset: (0x50000000 + 0x99000 + offset)
TSI_BASE_DID = lambda offset: (0x50000000 + 0xF0000 + offset)
TSI_BASE_UPDATE = lambda offset: (0x50000000 + 0x7000 + offset)
# !CI_PARSE_ENABLE
@@ -325,6 +328,7 @@ TSI_FLAG_QUEUED = 0x00000010 # Signal There are queued frames present on device
TSI_FLAG_CAPTURE_STOP = 0x00000020 # Signal Capture was stopped during last GetFrame call.
TSI_FLAG_CAPTURE_START = 0x00000040 # Signal Capture was (re)started during last CaptureState call.
TSI_FLAG_HDCP_PROTECTED = 0x00000080 # Signal HDCP protected content.
TSI_DEVICE_HW_RESET_STATUS = 0x80000022 # Check soft-reset device status
TSI_FW_VERSION_TEXT = TSI_DEVICE_FIRMWARE_INFO
TSI_PARAGRP_REFERENCE_1 = 0x7f000001 # Refers to ID's 0x10 - 0x17
# !CI_PARSE_ENABLE
@@ -515,6 +519,8 @@ TSI_PG_CUSTOM_TIMING_DSC_VSYNC = TSI_BASE_LEGACY_PATGEN(0x31)
TSI_PG_CUSTOM_TIMING_ASPECT_RATIO = TSI_BASE_LEGACY_PATGEN(0x32)
TSI_PG_CUSTOM_PATTERN_SCROLLING_CONTROL = TSI_BASE_TPG(0x0)
TSI_PG_CUSTOM_PATTERN_SCROLLING_CONFIG = TSI_BASE_TPG(0x1)
TSI_PG_PREDEF_PATTERN_PARAM_1 = TSI_BASE_TPG(0xC)
TSI_PG_PREDEF_PATTERN_PARAM_2 = TSI_BASE_TPG(0xD)
TSI_PG_PREDEF_PATTERN_ID_R = TSI_BASE_LEGACY_PATGEN(0x13)
TSI_W_PG_PREDEF_PATTERN_SELECT = TSI_PG_PREDEF_PATTERN_SELECT
@@ -530,6 +536,16 @@ TSI_PG_CUSTOM_PATTERN_INDEX = TSI_PG_CUSTOM_PATTERN_MEMORY_BLOCK_INDEX
TSI_PG_CUSTOM_PATTERN_DATA = TSI_PG_CUSTOM_PATTERN_DATA_W
TSI_PG_CUSTOM_PATTERN_CHAINED_DATA = TSI_PG_CUSTOM_PATTERN_CHAINED_DATA_W
TSI_PACKETGEN_MEM_BLOCK = TSI_BASE_PACKETSGEN(0x0)
TSI_PACKETGEN_CONTROL_W = TSI_BASE_PACKETSGEN(0x1)
TSI_PACKETGEN_STATUS_R = TSI_BASE_PACKETSGEN(0x2)
TSI_PACKETGEN_CAPS_R = TSI_BASE_PACKETSGEN(0x3)
TSI_PACKETGEN_PACKETS_NUMBER = TSI_BASE_PACKETSGEN(0x4)
TSI_PACKETGEN_PACKET_SELECT_W = TSI_BASE_PACKETSGEN(0x5)
TSI_PACKETGEN_PACKET_DATA = TSI_BASE_PACKETSGEN(0x6)
TSI_PACKETGEN_PACKET_REQUIRED_MEMORY = TSI_BASE_PACKETSGEN(0x7)
TSI_AUDGEN_CONTROL_W = TSI_BASE_LEGACY_AUDGEN(0x0)
TSI_AUDGEN_STATUS_R = TSI_BASE_LEGACY_AUDGEN(0x1)
TSI_AUDGEN_SIGNAL_TYPE = TSI_BASE_LEGACY_AUDGEN(0x2)
@@ -652,6 +668,7 @@ TSI_AUDCAP_CHANNEL_STATUS_R = TSI_BASE_LEGACY_AUDCAP(0xa)
TSI_AUDCAP_MIN_BUFFER_SIZE_R = TSI_BASE_LEGACY_AUDCAP(0xb)
TSI_AUDCAP_SAMPLE_SERVICE_INFO_R = TSI_BASE_LEGACY_AUDCAP(0xc)
TSI_AUDCAP_STATUS_R = TSI_BASE_LEGACY_AUDCAP(0xd)
TSI_AUDCAP_SAMPLE_BITS_SIZE_R = TSI_BASE_LEGACY_AUDCAP(0xf)
TSI_R_AUDCAP_CHANNEL_COUNT = TSI_AUDCAP_CHANNEL_COUNT_R
TSI_R_AUDCAP_SAMPLE_COUNT = TSI_AUDCAP_SAMPLE_COUNT_R
@@ -850,6 +867,7 @@ TSI_DPRX_AUX_SWING_CAPS_R = TSI_BASE_LEGACY_DPRX(0x20)
TSI_DPRX_AUX_SWING_CONTROL = TSI_BASE_LEGACY_DPRX(0x21)
TSI_DP2RX_CUSTOM_RATE_CAPS_R = TSI_BASE_LEGACY_DPRX(0x22)
TSI_DP2RX_CUSTOM_RATE_MAP = TSI_BASE_LEGACY_DPRX(0x23)
TSI_DPRX_LT_ROUTE_CREATE = TSI_BASE_LEGACY_DPRX(0x24)
TSI_DPRX_LINK_CONTROL = TSI_BASE_DPRX(0x3)
TSI_DPRX_HW_CAPS_R = TSI_BASE_DPRX(0x4)
@@ -1125,6 +1143,24 @@ TSI_HDRX_EARC_EDID_OFFSET = TSI_BASE_HDRX(0x52)
TSI_HDRX_EARC_EDID_DATA = TSI_BASE_HDRX(0x53)
TSI_HDRX_EARC_LATENCY = TSI_BASE_HDRX(0x54)
TSI_HDRX_EARC_LATENCY_REQ = TSI_BASE_HDRX(0x55)
# eARC audio generator
TSI_EARC_AUDGEN_CONTROL_W = TSI_BASE_LEGACY_EARC_AUDGEN(0x0)
TSI_EARC_AUDGEN_STATUS_R = TSI_BASE_LEGACY_EARC_AUDGEN(0x1)
TSI_EARC_AUDGEN_SIGNAL_TYPE = TSI_BASE_LEGACY_EARC_AUDGEN(0x2)
TSI_EARC_AUDGEN_SIGNAL_FREQ = TSI_BASE_LEGACY_EARC_AUDGEN(0x3)
TSI_EARC_AUDGEN_SIGNAL_BLOCK = TSI_BASE_LEGACY_EARC_AUDGEN(0x4)
TSI_EARC_AUDGEN_SIGNAL_VOLUME = TSI_BASE_LEGACY_EARC_AUDGEN(0x5)
TSI_EARC_AUDGEN_CHANNEL_COUNT = TSI_BASE_LEGACY_EARC_AUDGEN(0x6)
TSI_EARC_AUDGEN_SAMPLE_RATE = TSI_BASE_LEGACY_EARC_AUDGEN(0x7)
TSI_EARC_AUDGEN_SAMPLE_SIZE = TSI_BASE_LEGACY_EARC_AUDGEN(0x8)
TSI_EARC_AUDGEN_AUDIO_SIZE = TSI_BASE_LEGACY_EARC_AUDGEN(0x9)
TSI_EARC_AUDGEN_CONFIG = TSI_BASE_LEGACY_EARC_AUDGEN(0xA)
TSI_EARC_AUDGEN_PACKET_TYPE = TSI_BASE_LEGACY_EARC_AUDGEN(0xB)
TSI_EARC_AUDGEN_CHANNELS_STS = TSI_BASE_LEGACY_EARC_AUDGEN(0xC)
TSI_EARC_AUDGEN_USE_CHANNELS_INFO = TSI_BASE_LEGACY_EARC_AUDGEN(0xD)
TSI_EARC_AUDGEN_CHANNELS_INFO = TSI_BASE_LEGACY_EARC_AUDGEN(0xE)
# RM9124 ABOVE
TSI_HDRX_HDCP_CAPS_R = TSI_BASE_HDRX(0x10)
TSI_HDRX_HDCP_STATUS_R = TSI_BASE_HDRX(0x11)