From 416ab1ffb1692dcfb765f5afbffa6f824e35bc34 Mon Sep 17 00:00:00 2001 From: anovikova Date: Wed, 6 Aug 2025 21:51:47 +0300 Subject: [PATCH] testing v1 --- .gitignore | 35 + TestTa1.pro | 18 + WDMTMKv2.cpp | 2105 ++++++++++++++++++++++++++++++++++++++++++++++++ WDMTMKv2.h | 1020 +++++++++++++++++++++++ declarations.h | 22 + main.cpp | 14 + mainwindow.cpp | 61 ++ mainwindow.h | 24 + stdafx.cpp | 5 + stdafx.h | 15 + testinfo.cpp | 303 +++++++ testinfo.h | 46 ++ 12 files changed, 3668 insertions(+) create mode 100644 .gitignore create mode 100644 TestTa1.pro create mode 100644 WDMTMKv2.cpp create mode 100644 WDMTMKv2.h create mode 100644 declarations.h create mode 100644 main.cpp create mode 100644 mainwindow.cpp create mode 100644 mainwindow.h create mode 100644 stdafx.cpp create mode 100644 stdafx.h create mode 100644 testinfo.cpp create mode 100644 testinfo.h diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ee6f957 --- /dev/null +++ b/.gitignore @@ -0,0 +1,35 @@ +*.a +*.o +*.md +*.exe +*.user +*.Debug +*.Release +*.stash +MakeFile +*.bin +*.m +*.txt +*.mpd +*.sens +*.kna +*.djvu +resource/ +*.qrc +resource.h +*.png +*.jpeg +*.mp3 +*.wav +*.db +*.dll +data/ +debug/ +platforms/ +release/ +compiler/ +src_build/ +html/ +log/ +doc/ +QtXml/ \ No newline at end of file diff --git a/TestTa1.pro b/TestTa1.pro new file mode 100644 index 0000000..a241f89 --- /dev/null +++ b/TestTa1.pro @@ -0,0 +1,18 @@ +QT += testlib +QT -= gui + +greaterThan(QT_MAJOR_VERSION, 4): QT += widgets + +SOURCES += \ + WDMTMKv2.cpp \ + main.cpp \ + mainwindow.cpp \ + stdafx.cpp \ + testinfo.cpp + +HEADERS += \ + WDMTMKv2.h \ + declarations.h \ + mainwindow.h \ + stdafx.h \ + testinfo.h diff --git a/WDMTMKv2.cpp b/WDMTMKv2.cpp new file mode 100644 index 0000000..73e3a97 --- /dev/null +++ b/WDMTMKv2.cpp @@ -0,0 +1,2105 @@ +/*****************************************************************************/ +/* WDMTMK API v4.08 for Microsoft Windows ELCUS, 1998, 2011. */ +/* Interface to driver TMK1553B.SYS v4.08 */ +/* Interface to driver USB_TA_DRV.dll v1.9.2 */ +/* for Windows 98/ME/2000/XP/Vista/7 */ +/*****************************************************************************/ + +//#ifndef _TMK1553B_ +//#define _TMK1553B_ +#include +#include +#include "WDMTMKv2.h" + +HANDLE _ahVTMK4Event[MAX_TMK_NUMBER+1]; +HANDLE _hVTMK4VxD[MAX_TMK_NUMBER+1]; +int _VTMK4tmkMaxNum = -1; +int _VTMK4mrtMaxNum = -1; +int _VTMK4tmkCurNum = 0; +char _VTMK4usbFlag[MAX_TMK_NUMBER+1]; +int _VTMK4tmkDrvnum[MAX_TMK_NUMBER+1]; + +HINSTANCE hUSBDrvDll = NULL; + +DWORD TmkOpen() +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[6]; + DWORD _cbVTMK4Ret; + PEZUSB_DRIVER_VERSION version; + int iTMK; + int nTMK = -1; + int nMRT = -1; + int loaded = 1; + int nTMKb = 0; + int badver = 0; + char tmkName[32]; + char cc = 0x5c; + + for (iTMK = 0; iTMK <= MAX_TMK_NUMBER; ++iTMK) + { + _VTMK4usbFlag[iTMK] = 0; + sprintf (tmkName, "%c%c.%cTMK1553BDevice%d",cc,cc,cc,iTMK); + _hVTMK4VxD[iTMK] = CreateFileA(tmkName, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL); + + if (_hVTMK4VxD[iTMK] != INVALID_HANDLE_VALUE) + { + if (!DeviceIoControl(_hVTMK4VxD[iTMK], (DWORD)IOCTL_TMK_GetVersion, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL) || + _awVTMK4OutBuf[0] < TMK_VERSION_MIN) + { + badver = 1; + } + _VTMK4tmkDrvnum[iTMK] = iTMK; + nTMK = iTMK; + if (iTMK < 8) + nMRT = iTMK; + + CloseHandle(_hVTMK4VxD[iTMK]); + } + _hVTMK4VxD[iTMK] = NULL; + _ahVTMK4Event[iTMK] = 0; + } + if(badver) + return VTMK_BAD_VERSION; + + if(!hUSBDrvDll) + hUSBDrvDll = LoadLibrary(TEXT("USB_TA_DRV.dll")); + + if(hUSBDrvDll != NULL) + { + if(!(ptmkError = (int*)GetProcAddress(hUSBDrvDll, "tmkError"))) + {ptmkError = &ftmkError;loaded = 0;} + if(!(tmkconfig_usb = (htmkconfig_usb) GetProcAddress(hUSBDrvDll, "tmkconfig_usb"))) + {tmkconfig_usb = ftmkconfig_usb;loaded = 0;} + if(!(tmkdone_usb = (htmkdone_usb) GetProcAddress(hUSBDrvDll, "tmkdone_usb"))) + {tmkdone_usb = ftmkdone_usb;loaded = 0;} + if(!(tmkselect_usb = (htmkselect_usb) GetProcAddress(hUSBDrvDll, "tmkselect_usb"))) + {tmkselect_usb = ftmkselect_usb;loaded = 0;} + if(!(Read_DLL_EvD_usb = (hRead_DLL_EvD_usb) GetProcAddress(hUSBDrvDll, "Read_DLL_EvD_usb"))) + {Read_DLL_EvD_usb = fRead_DLL_EvD_usb;loaded = 0;} + if(!(tmktimeout_usb = (htmktimeout_usb) GetProcAddress(hUSBDrvDll, "tmktimeout_usb"))) + {tmktimeout_usb = ftmktimeout_usb;loaded = 0;} + if(!(tmksetcwbits_usb = (htmksetcwbits_usb) GetProcAddress(hUSBDrvDll, "tmksetcwbits_usb"))) + {tmksetcwbits_usb = ftmksetcwbits_usb;loaded = 0;} + if(!(tmkclrcwbits_usb = (htmkclrcwbits_usb) GetProcAddress(hUSBDrvDll, "tmkclrcwbits_usb"))) + {tmkclrcwbits_usb = ftmkclrcwbits_usb;loaded = 0;} + if(!(tmkgetcwbits_usb = (htmkgetcwbits_usb) GetProcAddress(hUSBDrvDll, "tmkclrcwbits_usb"))) + {tmkgetcwbits_usb = ftmkgetcwbits_usb;loaded = 0;} + if(!(tmkgetmode_usb = (htmkgetmode_usb) GetProcAddress(hUSBDrvDll, "tmkgetmode_usb"))) + {tmkgetmode_usb = ftmkgetmode_usb;loaded = 0;} + if(!(tmkdefdac_usb = (htmkdefdac_usb) GetProcAddress(hUSBDrvDll, "tmkdefdac_usb"))) + {tmkdefdac_usb = ftmkdefdac_usb;loaded = 0;} + if(!(tmkgetdac_usb = (htmkgetdac_usb) GetProcAddress(hUSBDrvDll, "tmkgetdac_usb"))) + {tmkgetdac_usb = ftmkgetdac_usb;loaded = 0;} + if(!(bcreset_usb = (hbcreset_usb) GetProcAddress(hUSBDrvDll, "bcreset_usb"))) + {bcreset_usb = fbcreset_usb;loaded = 0;} + if(!(bcdefirqmode_usb = (hbcdefirqmode_usb) GetProcAddress(hUSBDrvDll, "bcdefirqmode_usb"))) + {bcdefirqmode_usb = fbcdefirqmode_usb;loaded = 0;} + if(!(bcgetirqmode_usb = (hbcgetirqmode_usb) GetProcAddress(hUSBDrvDll, "bcgetirqmode_usb"))) + {bcgetirqmode_usb = fbcgetirqmode_usb;loaded = 0;} + if(!(bcgetmaxbase_usb = (hbcgetmaxbase_usb) GetProcAddress(hUSBDrvDll, "bcgetmaxbase_usb"))) + {bcgetmaxbase_usb = fbcgetmaxbase_usb;loaded = 0;} + if(!(bcgetmaxbase_usb = (hbcgetmaxbase_usb) GetProcAddress(hUSBDrvDll, "bcgetmaxbase_usb"))) + {bcgetmaxbase_usb = fbcgetmaxbase_usb;loaded = 0;} + if(!(bcdefbase_usb = (hbcdefbase_usb) GetProcAddress(hUSBDrvDll, "bcdefbase_usb"))) + {bcdefbase_usb = fbcdefbase_usb;loaded = 0;} + if(!(bcgetbase_usb = (hbcgetbase_usb) GetProcAddress(hUSBDrvDll, "bcgetbase_usb"))) + {bcgetbase_usb = fbcgetbase_usb;loaded = 0;} + if(!(bcputw_usb = (hbcputw_usb) GetProcAddress(hUSBDrvDll, "bcputw_usb"))) + {bcputw_usb = fbcputw_usb;loaded = 0;} + if(!(bcgetw_usb = (hbcgetw_usb) GetProcAddress(hUSBDrvDll, "bcgetw_usb"))) + {bcgetw_usb = fbcgetw_usb;loaded = 0;} + if(!(bcgetansw_usb = (hbcgetansw_usb) GetProcAddress(hUSBDrvDll, "bcgetansw_usb"))) + {bcgetansw_usb = fbcgetansw_usb;loaded = 0;} + if(!(bcputblk_usb = (hbcputblk_usb) GetProcAddress(hUSBDrvDll, "bcputblk_usb"))) + {bcputblk_usb = fbcputblk_usb;loaded = 0;} + if(!(bcgetblk_usb = (hbcgetblk_usb) GetProcAddress(hUSBDrvDll, "bcgetblk_usb"))) + {bcgetblk_usb = fbcgetblk_usb;loaded = 0;} + if(!(bcdefbus_usb = (hbcdefbus_usb) GetProcAddress(hUSBDrvDll, "bcdefbus_usb"))) + {bcdefbus_usb = fbcdefbus_usb;loaded = 0;} + if(!(bcgetbus_usb = (hbcgetbus_usb) GetProcAddress(hUSBDrvDll, "bcgetbus_usb"))) + {bcgetbus_usb = fbcgetbus_usb;loaded = 0;} + if(!(bcstart_usb = (hbcstart_usb) GetProcAddress(hUSBDrvDll, "bcstart_usb"))) + {bcstart_usb = fbcstart_usb;loaded = 0;} + if(!(bcstartx_usb = (hbcstartx_usb) GetProcAddress(hUSBDrvDll, "bcstartx_usb"))) + {bcstartx_usb = fbcstartx_usb;loaded = 0;} + if(!(bcdeflink_usb = (hbcdeflink_usb) GetProcAddress(hUSBDrvDll, "bcdeflink_usb"))) + {bcdeflink_usb = fbcdeflink_usb;loaded = 0;} + if(!(bcgetlink_usb = (hbcgetlink_usb) GetProcAddress(hUSBDrvDll, "bcgetlink_usb"))) + {bcgetlink_usb = fbcgetlink_usb;loaded = 0;} + if(!(bcstop_usb = (hbcstop_usb) GetProcAddress(hUSBDrvDll, "bcstop_usb"))) + {bcstop_usb = fbcstop_usb;loaded = 0;} + if(!(bcgetstate_usb = (hbcgetstate_usb) GetProcAddress(hUSBDrvDll, "bcgetstate_usb"))) + {bcgetstate_usb = fbcgetstate_usb;loaded = 0;} + if(!(rtreset_usb = (hrtreset_usb) GetProcAddress(hUSBDrvDll, "rtreset_usb"))) + {rtreset_usb = frtreset_usb;loaded = 0;} + if(!(rtdefirqmode_usb = (hrtdefirqmode_usb) GetProcAddress(hUSBDrvDll, "rtdefirqmode_usb"))) + {rtdefirqmode_usb = frtdefirqmode_usb;loaded = 0;} + if(!(rtgetirqmode_usb = (hrtgetirqmode_usb) GetProcAddress(hUSBDrvDll, "rtgetirqmode_usb"))) + {rtgetirqmode_usb = frtgetirqmode_usb;loaded = 0;} + if(!(rtdefmode_usb = (hrtdefmode_usb) GetProcAddress(hUSBDrvDll, "rtdefmode_usb"))) + {rtdefmode_usb = frtdefmode_usb;loaded = 0;} + if(!(rtgetmode_usb = (hrtgetmode_usb) GetProcAddress(hUSBDrvDll, "rtgetmode_usb"))) + {rtgetmode_usb = frtgetmode_usb;loaded = 0;} + if(!(rtgetmaxpage_usb = (hrtgetmaxpage_usb) GetProcAddress(hUSBDrvDll, "rtgetmaxpage_usb"))) + {rtgetmaxpage_usb = frtgetmaxpage_usb;loaded = 0;} + if(!(rtdefpage_usb = (hrtdefpage_usb) GetProcAddress(hUSBDrvDll, "rtdefpage_usb"))) + {rtdefpage_usb = frtdefpage_usb;loaded = 0;} + if(!(rtgetpage_usb = (hrtgetpage_usb) GetProcAddress(hUSBDrvDll, "rtgetpage_usb"))) + {rtgetpage_usb = frtgetpage_usb;loaded = 0;} + if(!(rtdefpagepc_usb = (hrtdefpagepc_usb) GetProcAddress(hUSBDrvDll, "rtdefpagepc_usb"))) + {rtdefpagepc_usb = frtdefpagepc_usb;loaded = 0;} + if(!(rtdefpagebus_usb = (hrtdefpagebus_usb) GetProcAddress(hUSBDrvDll, "rtdefpagebus_usb"))) + {rtdefpagebus_usb = frtdefpagebus_usb;loaded = 0;} + if(!(rtgetpagepc_usb = (hrtgetpagepc_usb) GetProcAddress(hUSBDrvDll, "rtgetpagepc_usb"))) + {rtgetpagepc_usb = frtgetpagepc_usb;loaded = 0;} + if(!(rtgetpagebus_usb = (hrtgetpagebus_usb) GetProcAddress(hUSBDrvDll, "rtgetpagebus_usb"))) + {rtgetpagebus_usb = frtgetpagebus_usb;loaded = 0;} + if(!(rtdefaddress_usb = (hrtdefaddress_usb) GetProcAddress(hUSBDrvDll, "rtdefaddress_usb"))) + {rtdefaddress_usb = frtdefaddress_usb;loaded = 0;} + if(!(rtgetaddress_usb = (hrtgetaddress_usb) GetProcAddress(hUSBDrvDll, "rtgetaddress_usb"))) + {rtgetaddress_usb = frtgetaddress_usb;loaded = 0;} + if(!(rtdefsubaddr_usb = (hrtdefsubaddr_usb) GetProcAddress(hUSBDrvDll, "rtdefsubaddr_usb"))) + {rtdefsubaddr_usb = frtdefsubaddr_usb;loaded = 0;} + if(!(rtgetsubaddr_usb = (hrtgetsubaddr_usb) GetProcAddress(hUSBDrvDll, "rtgetsubaddr_usb"))) + {rtgetsubaddr_usb = frtgetsubaddr_usb;loaded = 0;} + if(!(rtputw_usb = (hrtputw_usb) GetProcAddress(hUSBDrvDll, "rtputw_usb"))) + {rtputw_usb = frtputw_usb;loaded = 0;} + if(!(rtgetw_usb = (hrtgetw_usb) GetProcAddress(hUSBDrvDll, "rtgetw_usb"))) + {rtgetw_usb = frtgetw_usb;loaded = 0;} + if(!(rtputblk_usb = (hrtputblk_usb) GetProcAddress(hUSBDrvDll, "rtputblk_usb"))) + {rtputblk_usb = frtputblk_usb;loaded = 0;} + if(!(rtgetblk_usb = (hrtgetblk_usb) GetProcAddress(hUSBDrvDll, "rtgetblk_usb"))) + {rtgetblk_usb = frtgetblk_usb;loaded = 0;} + if(!(rtsetanswbits_usb = (hrtsetanswbits_usb) GetProcAddress(hUSBDrvDll, "rtsetanswbits_usb"))) + {rtsetanswbits_usb = frtsetanswbits_usb;loaded = 0;} + if(!(rtclranswbits_usb = (hrtclranswbits_usb) GetProcAddress(hUSBDrvDll, "rtclranswbits_usb"))) + {rtclranswbits_usb = frtclranswbits_usb;loaded = 0;} + if(!(rtgetanswbits_usb = (hrtgetanswbits_usb) GetProcAddress(hUSBDrvDll, "rtgetanswbits_usb"))) + {rtgetanswbits_usb = frtgetanswbits_usb;loaded = 0;} + if(!(rtgetflags_usb = (hrtgetflags_usb) GetProcAddress(hUSBDrvDll, "rtgetflags_usb"))) + {rtgetflags_usb = frtgetflags_usb;loaded = 0;} + if(!(rtputflags_usb = (hrtputflags_usb) GetProcAddress(hUSBDrvDll, "rtputflags_usb"))) + {rtputflags_usb = frtputflags_usb;loaded = 0;} + if(!(rtsetflag_usb = (hrtsetflag_usb) GetProcAddress(hUSBDrvDll, "rtsetflag_usb"))) + {rtsetflag_usb = frtsetflag_usb;loaded = 0;} + if(!(rtclrflag_usb = (hrtclrflag_usb) GetProcAddress(hUSBDrvDll, "rtclrflag_usb"))) + {rtclrflag_usb = frtclrflag_usb;loaded = 0;} + if(!(rtgetflag_usb = (hrtgetflag_usb) GetProcAddress(hUSBDrvDll, "rtgetflag_usb"))) + {rtgetflag_usb = frtgetflag_usb;loaded = 0;} + if(!(rtputflag_usb = (hrtputflag_usb) GetProcAddress(hUSBDrvDll, "rtputflag_usb"))) + {rtputflag_usb = frtputflag_usb;loaded = 0;} + if(!(rtgetstate_usb = (hrtgetstate_usb) GetProcAddress(hUSBDrvDll, "rtgetstate_usb"))) + {rtgetstate_usb = frtgetstate_usb;loaded = 0;} + if(!(rtbusy_usb = (hrtbusy_usb) GetProcAddress(hUSBDrvDll, "rtbusy_usb"))) + {rtbusy_usb = frtbusy_usb;loaded = 0;} + if(!(rtlock_usb = (hrtlock_usb) GetProcAddress(hUSBDrvDll, "rtlock_usb"))) + {rtlock_usb = frtlock_usb;loaded = 0;} + if(!(rtunlock_usb = (hrtunlock_usb) GetProcAddress(hUSBDrvDll, "rtunlock_usb"))) + {rtunlock_usb = frtunlock_usb;loaded = 0;} + if(!(rtgetcmddata_usb = (hrtgetcmddata_usb) GetProcAddress(hUSBDrvDll, "rtgetcmddata_usb"))) + {rtgetcmddata_usb = frtgetcmddata_usb;loaded = 0;} + if(!(rtputcmddata_usb = (hrtputcmddata_usb) GetProcAddress(hUSBDrvDll, "rtputcmddata_usb"))) + {rtputcmddata_usb = frtputcmddata_usb;loaded = 0;} + if(!(mtreset_usb = (hmtreset_usb) GetProcAddress(hUSBDrvDll, "mtreset_usb"))) + {mtreset_usb = fmtreset_usb;loaded = 0;} + if(!(mtgetsw_usb = (hmtgetsw_usb) GetProcAddress(hUSBDrvDll, "mtgetsw_usb"))) + {mtgetsw_usb = fmtgetsw_usb;loaded = 0;} + if(!(rtenable_usb = (hrtenable_usb) GetProcAddress(hUSBDrvDll, "rtenable_usb"))) + {rtenable_usb = frtenable_usb;loaded = 0;} + if(!(mrtselected_usb = (hmrtselected_usb) GetProcAddress(hUSBDrvDll, "mrtselected_usb"))) + {mrtselected_usb = fmrtselected_usb;loaded = 0;} + if(!(mrtgetstate_usb = (hmrtgetstate_usb) GetProcAddress(hUSBDrvDll, "mrtgetstate_usb"))) + {mrtgetstate_usb = fmrtgetstate_usb;loaded = 0;} + if(!(mrtdefbrcsubaddr0_usb = (hmrtdefbrcsubaddr0_usb) GetProcAddress(hUSBDrvDll, "mrtdefbrcsubaddr0_usb"))) + {mrtdefbrcsubaddr0_usb = fmrtdefbrcsubaddr0_usb;loaded = 0;} + if(!(mrtreset_usb = (hmrtreset_usb) GetProcAddress(hUSBDrvDll, "mrtreset_usb"))) + {mrtreset_usb = fmrtreset_usb;loaded = 0;} + if(!(tmktimer_usb = (htmktimer_usb) GetProcAddress(hUSBDrvDll, "tmktimer_usb"))) + {tmktimer_usb = ftmktimer_usb;loaded = 0;} + if(!(tmkgettimer_usb = (htmkgettimer_usb) GetProcAddress(hUSBDrvDll, "tmkgettimer_usb"))) + {tmkgettimer_usb = ftmkgettimer_usb;loaded = 0;} + if(!(tmkgettimerl_usb = (htmkgettimerl_usb) GetProcAddress(hUSBDrvDll, "tmkgettimerl_usb"))) + {tmkgettimerl_usb = ftmkgettimerl_usb;loaded = 0;} + if(!(bcgetmsgtime_usb = (hbcgetmsgtime_usb) GetProcAddress(hUSBDrvDll, "bcgetmsgtime_usb"))) + {bcgetmsgtime_usb = fbcgetmsgtime_usb;loaded = 0;} + if(!(rtgetmsgtime_usb = (hrtgetmsgtime_usb) GetProcAddress(hUSBDrvDll, "rtgetmsgtime_usb"))) + {rtgetmsgtime_usb = frtgetmsgtime_usb;loaded = 0;} + if(!(tmkgethwver_usb = (htmkgethwver_usb) GetProcAddress(hUSBDrvDll, "tmkgethwver_usb"))) + {tmkgethwver_usb = ftmkgethwver_usb;loaded = 0;} + if(!(tmkgetevtime_usb = (htmkgetevtime_usb) GetProcAddress(hUSBDrvDll, "tmkgetevtime_usb"))) + {tmkgetevtime_usb = ftmkgetevtime_usb;loaded = 0;} + if(!(tmkdefevent_usb = (htmkdefevent_usb) GetProcAddress(hUSBDrvDll, "tmkdefevent_usb"))) + {tmkdefevent_usb = ftmkdefevent_usb;loaded = 0;} + if(!(tmkswtimer_usb = (htmkswtimer_usb) GetProcAddress(hUSBDrvDll, "tmkswtimer_usb"))) + {tmkswtimer_usb = ftmkswtimer_usb;loaded = 0;} + if(!(tmkgetswtimer_usb = (htmkgetswtimer_usb) GetProcAddress(hUSBDrvDll, "tmkgetswtimer_usb"))) + {tmkgetswtimer_usb = ftmkgetswtimer_usb;loaded = 0;} + if(!(tmktimeout_usb = (htmktimeout_usb) GetProcAddress(hUSBDrvDll, "tmktimeout_usb"))) + {tmktimeout_usb = ftmktimeout_usb;loaded = 0;} + if(!(mrtdefbrcpage_usb = (hmrtdefbrcpage_usb) GetProcAddress(hUSBDrvDll, "mrtdefbrcpage_usb"))) + {mrtdefbrcpage_usb = fmrtdefbrcpage_usb;loaded = 0;} + if(!(mrtgetbrcpage_usb = (hmrtgetbrcpage_usb) GetProcAddress(hUSBDrvDll, "mrtgetbrcpage_usb"))) + {mrtgetbrcpage_usb = fmrtgetbrcpage_usb;loaded = 0;} + + if(!(MonitorHwStart_usb = (hMonitorHwStart_usb) GetProcAddress(hUSBDrvDll, "MonitorHwStart_usb"))) + {MonitorHwStart_usb = fMonitorHwStart_usb;loaded = 0;} + if(!(MonitorHwGetMessage_usb = (hMonitorHwGetMessage_usb) GetProcAddress(hUSBDrvDll, "MonitorHwGetMessage_usb"))) + {MonitorHwGetMessage_usb = fMonitorHwGetMessage_usb;loaded = 0;} + if(!(MonitorHwStop_usb = (hMonitorHwStop_usb) GetProcAddress(hUSBDrvDll, "MonitorHwStop_usb"))) + {MonitorHwStop_usb = fMonitorHwStop_usb;loaded = 0;} + + if(!(tmkrawio_usb = (htmkrawio_usb) GetProcAddress(hUSBDrvDll, "tmkrawio_usb"))) + {tmkrawio_usb = ftmkrawio_usb;loaded = 0;} + if(!(rtgap_usb = (hrtgap_usb) GetProcAddress(hUSBDrvDll, "rtgap_usb"))) + {rtgap_usb = frtgap_usb;loaded = 0;} + if(!(tmkreadsn_usb = (htmkreadsn_usb) GetProcAddress(hUSBDrvDll, "tmkreadsn_usb"))) + {tmkreadsn_usb = ftmkreadsn_usb;loaded = 0;} + + + if(loaded) + { + nTMKb = 0; + for(iTMK = 0; iTMK <= MAX_USBTA_NUM; ++iTMK) + { + if(nMRT+1+nTMKb > MAX_USBTA_NUM) + break; + sprintf (tmkName,"%c%c.%cEZUSB-%d",cc,cc,cc,iTMK); + _hVTMK4VxD[nMRT+1+nTMKb] = CreateFileA(tmkName, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL); + + if (_hVTMK4VxD[nMRT+1+nTMKb] != INVALID_HANDLE_VALUE) + { + DeviceIoControl(_hVTMK4VxD[nMRT+1+nTMKb], (DWORD)IOCTL_EZUSB_GET_DRIVER_VERSION, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 6, &_cbVTMK4Ret, NULL); + version = (PEZUSB_DRIVER_VERSION) _awVTMK4OutBuf; + if(((DWORD)(version->MajorVersion << 16)+(DWORD)(version->MinorVersion)) < ((DWORD)(EZUSB_MAJOR_VERSION_MIN << 16)+(DWORD)(EZUSB_MINOR_VERSION_MIN))) + { + badver = 1; + } + _VTMK4usbFlag[nMRT+1+nTMKb] = 1; + _VTMK4tmkDrvnum[nMRT+1+nTMKb]=iTMK; + CloseHandle(_hVTMK4VxD[nMRT+1+nTMKb]); + _hVTMK4VxD[nMRT+1+nTMKb] = NULL; + nTMKb++; + } + else + _hVTMK4VxD[nMRT+1+nTMKb] = NULL; + } + if(badver) + return VTMK_BAD_VERSION; + nMRT += nTMKb; + if(nTMK < MAX_USBTA_NUM) + nTMK += nTMKb; + } + } + + if (nTMK == -1) + return 1; + + _VTMK4tmkMaxNum = nTMK; + _VTMK4mrtMaxNum = nMRT; + + return 0; +} + +void TmkClose() +{ + int iTMK; + for (iTMK = 0; iTMK <= _VTMK4tmkMaxNum; ++iTMK) + { + if (_hVTMK4VxD[iTMK]) + CloseHandle(_hVTMK4VxD[iTMK]); + _ahVTMK4Event[iTMK] = 0; + _hVTMK4VxD[iTMK] = NULL; + _VTMK4usbFlag[iTMK] = 0; + _VTMK4tmkDrvnum[iTMK] = -1; + } + + _VTMK4tmkMaxNum = -1; + + tmkconfig_usb = ftmkconfig_usb; + tmkdone_usb = ftmkdone_usb; + tmkselect_usb = ftmkselect_usb; + tmkdefevent_usb = ftmkdefevent_usb; + Read_DLL_EvD_usb = fRead_DLL_EvD_usb; + tmksetcwbits_usb = ftmksetcwbits_usb; + tmkclrcwbits_usb = ftmkclrcwbits_usb; + tmkgetcwbits_usb = ftmkgetcwbits_usb; + tmkgetmode_usb = ftmkgetmode_usb; + tmkdefdac_usb = ftmkdefdac_usb; + tmkgetdac_usb = ftmkgetdac_usb; + bcreset_usb = fbcreset_usb; + bcdefirqmode_usb = fbcdefirqmode_usb; + bcgetirqmode_usb = fbcgetirqmode_usb; + bcgetmaxbase_usb = fbcgetmaxbase_usb; + bcdefbase_usb = fbcdefbase_usb; + bcgetbase_usb = fbcgetbase_usb; + bcputw_usb = fbcputw_usb; + bcgetw_usb = fbcgetw_usb; + bcgetansw_usb = fbcgetansw_usb; + bcputblk_usb = fbcputblk_usb; + bcgetblk_usb = fbcgetblk_usb; + bcdefbus_usb = fbcdefbus_usb; + bcgetbus_usb = fbcgetbus_usb; + bcstart_usb = fbcstart_usb; + bcstartx_usb = fbcstartx_usb; + bcdeflink_usb = fbcdeflink_usb; + bcgetlink_usb = fbcgetlink_usb; + bcstop_usb = fbcstop_usb; + bcgetstate_usb = fbcgetstate_usb; + rtreset_usb = frtreset_usb; + rtdefirqmode_usb = frtdefirqmode_usb; + rtgetirqmode_usb = frtgetirqmode_usb; + rtdefmode_usb = frtdefmode_usb; + rtgetmode_usb = frtgetmode_usb; + rtgetmaxpage_usb = frtgetmaxpage_usb; + rtdefpage_usb = frtdefpage_usb; + rtgetpage_usb = frtgetpage_usb; + rtdefpagepc_usb = frtdefpagepc_usb; + rtdefpagebus_usb = frtdefpagebus_usb; + rtgetpagepc_usb = frtgetpagepc_usb; + rtgetpagebus_usb = frtgetpagebus_usb; + rtdefaddress_usb = frtdefaddress_usb; + rtgetaddress_usb = frtgetaddress_usb; + rtdefsubaddr_usb = frtdefsubaddr_usb; + rtgetsubaddr_usb = frtgetsubaddr_usb; + rtputw_usb = frtputw_usb; + rtgetw_usb = frtgetw_usb; + rtputblk_usb = frtputblk_usb; + rtgetblk_usb = frtgetblk_usb; + rtsetanswbits_usb = frtsetanswbits_usb; + rtclranswbits_usb = frtclranswbits_usb; + rtgetanswbits_usb = frtgetanswbits_usb; + rtgetflags_usb = frtgetflags_usb; + rtputflags_usb = frtputflags_usb; + rtsetflag_usb = frtsetflag_usb; + rtclrflag_usb = frtclrflag_usb; + rtgetflag_usb = frtgetflag_usb; + rtputflag_usb = frtputflag_usb; + rtgetstate_usb = frtgetstate_usb; + rtbusy_usb = frtbusy_usb; + rtlock_usb = frtlock_usb; + rtunlock_usb = frtunlock_usb; + rtgetcmddata_usb = frtgetcmddata_usb; + rtputcmddata_usb = frtputcmddata_usb; + mtreset_usb = fmtreset_usb; + mtgetsw_usb = fmtgetsw_usb; + rtenable_usb = frtenable_usb; + mrtselected_usb = fmrtselected_usb; + mrtgetstate_usb = fmrtgetstate_usb; + mrtdefbrcsubaddr0_usb = fmrtdefbrcsubaddr0_usb; + mrtreset_usb = fmrtreset_usb; + tmktimer_usb = ftmktimer_usb; + tmkgettimer_usb = ftmkgettimer_usb; + tmkgettimerl_usb = ftmkgettimerl_usb; + bcgetmsgtime_usb = fbcgetmsgtime_usb; + rtgetmsgtime_usb = frtgetmsgtime_usb; + tmkgethwver_usb = ftmkgethwver_usb; + tmkgetevtime_usb = ftmkgetevtime_usb; + tmkswtimer_usb = ftmkswtimer_usb; + tmkgetswtimer_usb = ftmkgetswtimer_usb; + tmktimeout_usb = ftmktimeout_usb; + mrtdefbrcpage_usb = fmrtdefbrcpage_usb; + mrtgetbrcpage_usb = fmrtgetbrcpage_usb; + + MonitorHwStart_usb = fMonitorHwStart_usb; + MonitorHwGetMessage_usb = fMonitorHwGetMessage_usb; + MonitorHwStop_usb = fMonitorHwStop_usb; + + tmkrawio_usb = ftmkrawio_usb; + rtgap_usb = frtgap_usb; + tmkreadsn_usb = ftmkreadsn_usb; + + if(hUSBDrvDll) + FreeLibrary(hUSBDrvDll); + hUSBDrvDll = NULL; +} + +int tmkgetmaxn() +{ + return _VTMK4tmkMaxNum; +} + +int tmkconfig(int tmkNumber) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + int Status; + char tmkName[32]; + + if (_VTMK4tmkMaxNum == -1) + return TMK_BAD_NUMBER; + + if (_hVTMK4VxD[tmkNumber] != NULL) + return TMK_BAD_NUMBER; + + if (tmkNumber < 0 || tmkNumber > _VTMK4tmkMaxNum) + return TMK_BAD_NUMBER; + + if (_VTMK4usbFlag[tmkNumber]) + { + sprintf (tmkName,"%c%c.%cEZUSB-%d",0x5c,0x5c,0x5c,_VTMK4tmkDrvnum[tmkNumber]); + _hVTMK4VxD[tmkNumber] = CreateFileA(tmkName, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL); + + if (_hVTMK4VxD[tmkNumber] == INVALID_HANDLE_VALUE) + { + _hVTMK4VxD[tmkNumber] = NULL; + return TMK_BAD_NUMBER; + } + + if(DeviceIoControl(_hVTMK4VxD[tmkNumber], (DWORD)IOCTL_EZUSB_SET_CURPROC, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL)) + { + Status = tmkconfig_usb(_VTMK4tmkDrvnum[tmkNumber], 9, 0, 0); + if(Status == 0) + { + _VTMK4tmkCurNum = tmkNumber; + return Status; + } + } + + CloseHandle (_hVTMK4VxD[tmkNumber]); + _hVTMK4VxD[tmkNumber] = NULL; + return TMK_BAD_NUMBER; + } + + sprintf (tmkName,"%c%c.%cTMK1553BDevice%d",0x5c,0x5c,0x5c,tmkNumber); + _hVTMK4VxD[tmkNumber] = CreateFileA(tmkName, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL + ); + if (_hVTMK4VxD[tmkNumber] == INVALID_HANDLE_VALUE) + { + _hVTMK4VxD[tmkNumber] = NULL; + return TMK_BAD_NUMBER; + } + + _awVTMK4InBuf[0] = (WORD)tmkNumber; + DeviceIoControl(_hVTMK4VxD[tmkNumber], (DWORD)IOCTL_TMK_tmkconfig, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + if (_awVTMK4OutBuf[0] != 0) + { + CloseHandle (_hVTMK4VxD[tmkNumber]); + _hVTMK4VxD[tmkNumber] = NULL; + } + _VTMK4tmkCurNum = tmkNumber; + return (int)_awVTMK4OutBuf[0]; +} + +int tmkdone(int tmkNumber) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + int iTMK; + + if (tmkNumber == ALL_TMKS) + { + for (iTMK = 0; iTMK <= _VTMK4tmkMaxNum; ++iTMK) + { + if(_VTMK4usbFlag[iTMK]) + { + _ahVTMK4Event[iTMK] = 0; + if(_hVTMK4VxD[iTMK]) + CloseHandle (_hVTMK4VxD[iTMK]); + _hVTMK4VxD[iTMK] = NULL; + tmkdone_usb(_VTMK4tmkDrvnum[iTMK]); + } + else + { + if (_hVTMK4VxD[iTMK] == NULL) + continue; + _awVTMK4InBuf[0] = (WORD)iTMK; + DeviceIoControl(_hVTMK4VxD[iTMK], (DWORD)IOCTL_TMK_tmkdone, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + + _ahVTMK4Event[iTMK] = 0; + CloseHandle(_hVTMK4VxD[iTMK]); + _hVTMK4VxD[iTMK] = NULL; + } + } + } + else if (tmkNumber >= 0 && tmkNumber <= _VTMK4tmkMaxNum && _hVTMK4VxD[tmkNumber] != NULL) + { + if(_VTMK4usbFlag[tmkNumber]) + { + _ahVTMK4Event[tmkNumber] = 0; + CloseHandle (_hVTMK4VxD[tmkNumber]); + _hVTMK4VxD[tmkNumber] = NULL; + tmkdone_usb(_VTMK4tmkDrvnum[tmkNumber]); + } + else + { + _awVTMK4InBuf[0] = (WORD)tmkNumber; + DeviceIoControl(_hVTMK4VxD[tmkNumber], (DWORD)IOCTL_TMK_tmkdone, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + + _ahVTMK4Event[tmkNumber] = 0; + CloseHandle (_hVTMK4VxD[tmkNumber]); + _hVTMK4VxD[tmkNumber] = NULL; + } + } + + return 0; +} + +int tmkselect(int tmkNumber) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + + if (tmkNumber < 0 || tmkNumber > _VTMK4tmkMaxNum) + return TMK_BAD_NUMBER; + if ((_hVTMK4VxD[tmkNumber] != INVALID_HANDLE_VALUE) && (_hVTMK4VxD[tmkNumber] != 0)) + { + if (_VTMK4usbFlag[tmkNumber]) + { + _VTMK4tmkCurNum = tmkNumber; + tmkselect_usb(_VTMK4tmkDrvnum[tmkNumber]); + return 0; + } + + //************** ********************************************************** + _awVTMK4InBuf[0] = tmkNumber; + DeviceIoControl(_hVTMK4VxD[tmkNumber], (DWORD)IOCTL_TMK_tmkselect, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + + if (_awVTMK4OutBuf[0] == 0) + _VTMK4tmkCurNum = tmkNumber; + return _awVTMK4OutBuf[0]; + //******************************************************************************************************************* + //return 0; + } + else + return TMK_BAD_NUMBER; +} + +int tmkselected() +{ + return _VTMK4tmkCurNum; +} + +TMK_DATA tmkgetmode() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgetmode, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return tmkgetmode_usb(); +} + +int tmkdefdac(int dacValue) +{ + if ((_hVTMK4VxD[_VTMK4tmkCurNum])&&(_VTMK4usbFlag[_VTMK4tmkCurNum])) + return tmkdefdac_usb(dacValue); + else + return TMK_BAD_NUMBER; +} + +int tmkgetdac(int *dacValue, int *dacMode) +{ + if ((_hVTMK4VxD[_VTMK4tmkCurNum])&&(_VTMK4usbFlag[_VTMK4tmkCurNum])) + return tmkgetdac_usb(dacValue, dacMode); + else + { + *dacValue = 0; + *dacMode = 0; + return TMK_BAD_NUMBER; + } +} + +void tmksetcwbits(TMK_DATA tmkSetControl) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = tmkSetControl; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmksetcwbits, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + tmksetcwbits_usb(tmkSetControl); +} + +void tmkclrcwbits(TMK_DATA tmkClrControl) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = tmkClrControl; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkclrcwbits, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + tmkclrcwbits_usb(tmkClrControl); +} + +TMK_DATA tmkgetcwbits() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgetcwbits, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return tmkgetcwbits_usb(); +} + +void tmkdefevent(HANDLE hEvent, BOOL fEventSet) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[8], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + DWORD64 hVxDEvent; + hVxDEvent = (DWORD64)hEvent; + _ahVTMK4Event[_VTMK4tmkCurNum] = hEvent; +// _awVTMK4InBuf[0] = 0; +// _awVTMK4InBuf[1] = 0; + _awVTMK4InBuf[2] = LOWORD(fEventSet); + _awVTMK4InBuf[3] = HIWORD(fEventSet); + *(PDWORD64)(_awVTMK4InBuf+4) = hVxDEvent; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkdefevent, _awVTMK4InBuf, 16, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + tmkdefevent_usb(hEvent); +#else + WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + DWORD hVxDEvent; + +/* int iTMK; + if (hEvent != 0) + { + for (iTMK = 0; iTMK <= MAX_TMK_NUMBER; ++iTMK) + { + if (hEvent == _ahVTMK4Event[iTMK]) + break; + } + if (iTMK > MAX_TMK_NUMBER) + { + hVxDEvent = (DWORD)hEvent; + _ahVTMK4Event[_VTMK4tmkCurNum] = hEvent; + } + } + else + { + hVxDEvent = 0; + _ahVTMK4Event[_VTMK4tmkCurNum] = 0; + } +*/ + hVxDEvent = (DWORD)hEvent; + _ahVTMK4Event[_VTMK4tmkCurNum] = hEvent; + _awVTMK4InBuf[0] = LOWORD(hVxDEvent); + _awVTMK4InBuf[1] = HIWORD(hVxDEvent); + _awVTMK4InBuf[2] = LOWORD(fEventSet); + _awVTMK4InBuf[3] = HIWORD(fEventSet); + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkdefevent, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + tmkdefevent_usb(hEvent); +#endif +} + +void tmkgetevd(TTmkEventData *pEvD) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[6]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgetevd, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 12, &_cbVTMK4Ret, NULL); + + pEvD->nInt = ((DWORD*)(_awVTMK4OutBuf))[0]; + switch (pEvD->wMode = _awVTMK4OutBuf[2]) + { + case BC_MODE: + switch (pEvD->nInt) + { + case 1: + pEvD->bc.wResult = _awVTMK4OutBuf[3]; + break; + case 2: + pEvD->bc.wResult = _awVTMK4OutBuf[3]; + pEvD->bc.wAW1 = _awVTMK4OutBuf[4]; + pEvD->bc.wAW2 = _awVTMK4OutBuf[5]; + break; + case 3: + pEvD->bcx.wResultX = _awVTMK4OutBuf[3]; + pEvD->bcx.wBase = _awVTMK4OutBuf[4]; + break; + case 4: + pEvD->bcx.wBase = _awVTMK4OutBuf[3]; + break; + } + break; + case MT_MODE: + switch (pEvD->nInt) + { + case 3: + pEvD->mt.wResultX = _awVTMK4OutBuf[3]; + pEvD->mt.wBase = _awVTMK4OutBuf[4]; + break; + case 4: + pEvD->mt.wBase = _awVTMK4OutBuf[3]; + break; + } + break; + case RT_MODE: + switch (pEvD->nInt) + { + case 1: + pEvD->rt.wCmd = _awVTMK4OutBuf[3]; + break; + case 2: + case 3: + pEvD->rt.wStatus = _awVTMK4OutBuf[3]; + break; + } + break; + case UNDEFINED_MODE: + switch (pEvD->nInt) + { + case 5: + pEvD->tmk.wRequest = _awVTMK4OutBuf[3]; +// pEvD->tmk.dwTimer = *((DWORD*)(&_awVTMK4OutBuf[4])); + break; + } + break; + } + } + else + { + TListEvD evd_s; + Read_DLL_EvD_usb(&evd_s); + + pEvD->nInt = evd_s.nInt; + pEvD->wMode = evd_s.wMode; + switch (pEvD->wMode) + { + case BC_MODE: + switch (pEvD->nInt) + { + case 1: + pEvD->bc.wResult = evd_s.awEvData[0]; + break; + case 2: + pEvD->bc.wResult = evd_s.awEvData[0]; + pEvD->bc.wAW1 = evd_s.awEvData[1]; + pEvD->bc.wAW2 = evd_s.awEvData[2]; + break; + case 3: + pEvD->bcx.wResultX = evd_s.awEvData[0]; + pEvD->bcx.wBase = evd_s.awEvData[1]; + break; + case 4: + pEvD->bcx.wBase = evd_s.awEvData[0]; + break; + } + break; + case MT_MODE: + switch (pEvD->nInt) + { + case 3: + pEvD->mt.wResultX = evd_s.awEvData[0]; + pEvD->mt.wBase = evd_s.awEvData[1]; + break; + case 4: + pEvD->mt.wBase = evd_s.awEvData[0]; + break; + } + break; + case RT_MODE: + switch (pEvD->nInt) + { + case 1: + pEvD->rt.wCmd = evd_s.awEvData[0]; + break; + case 2: + case 3: + pEvD->rt.wStatus = evd_s.awEvData[0]; + break; + } + break; + case UNDEFINED_MODE: + switch (pEvD->nInt) + { + case 5: + pEvD->tmk.wRequest = evd_s.awEvData[0]; +// pEvD->tmk.dwTimer = *((DWORD*)(&_awVTMK4OutBuf[4])); + break; + case 255: + pEvD->raw.wData1 = evd_s.awEvData[0]; + pEvD->raw.wData2 = evd_s.awEvData[1]; + break; + } + break; + } + } +} + +void tmkgetinfo(TTmkConfigData *pConfD) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + *(PDWORD64)(_awVTMK4InBuf) = (DWORD64)pConfD; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgetinfo, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + } +#else + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = LOWORD(pConfD); + _awVTMK4InBuf[1] = HIWORD(pConfD); + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgetinfo, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + } +#endif + else + { + pConfD->nType = TA; + strcpy(pConfD->szName, "TA1USB"); + pConfD->wPorts1 = 0; + pConfD->wPorts2 = 0; + pConfD->wIrq1 = 0; + pConfD->wIrq2 = 0; + pConfD->wIODelay = 0; + } +} + +int bcreset() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return(DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcreset, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return bcreset_usb(); +} + +void bc_def_tldw(TMK_DATA wTLDW) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = wTLDW; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bc_def_tldw, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); +} + +void bc_enable_di() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bc_enable_di, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); +} + +void bc_disable_di() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bc_disable_di, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); +} + +int bcdefirqmode(TMK_DATA bcIrqMode) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcIrqMode; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcdefirqmode, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return bcdefirqmode_usb(bcIrqMode); +} + +TMK_DATA bcgetirqmode() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetirqmode, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return bcgetirqmode_usb(); +} + +TMK_DATA bcgetmaxbase() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetmaxbase, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return bcgetmaxbase_usb(); +} + +int bcdefbase(TMK_DATA bcBasePC) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcBasePC; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcdefbase, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return bcdefbase_usb(bcBasePC); +} + +TMK_DATA bcgetbase() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetbase, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return bcgetbase_usb(); +} + +void bcputw(TMK_DATA bcAddr, TMK_DATA bcData) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcAddr; + _awVTMK4InBuf[1] = bcData; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcputw, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + bcputw_usb(bcAddr, bcData); +} + +TMK_DATA bcgetw(TMK_DATA bcAddr) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcAddr; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetw, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return bcgetw_usb(bcAddr); +} + +DWORD bcgetansw(TMK_DATA bcCtrlCode) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcCtrlCode; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetansw, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return bcgetansw_usb(bcCtrlCode); +} + +void bcputblk(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[8], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcAddr; +// _awVTMK4InBuf[1] = 0; +// _awVTMK4InBuf[2] = 0; + _awVTMK4InBuf[3] = cwLength; + *(PDWORD64)(_awVTMK4InBuf+4) = (DWORD64)pcBuffer; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcputblk, _awVTMK4InBuf, 16, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + bcputblk_usb(bcAddr, pcBuffer, cwLength); +#else + WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcAddr; + _awVTMK4InBuf[1] = (WORD)(LOWORD(pcBuffer)); + _awVTMK4InBuf[2] = (WORD)(HIWORD(pcBuffer)); + _awVTMK4InBuf[3] = cwLength; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcputblk, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + bcputblk_usb(bcAddr, pcBuffer, cwLength); +#endif +} + +void bcgetblk(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[8], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcAddr; +// _awVTMK4InBuf[1] = 0; +// _awVTMK4InBuf[2] = 0; + _awVTMK4InBuf[3] = cwLength; + *(PDWORD64)(_awVTMK4InBuf+4) = (DWORD64)pcBuffer; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetblk, _awVTMK4InBuf, 16, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + bcgetblk_usb(bcAddr, pcBuffer, cwLength); +#else + WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcAddr; + _awVTMK4InBuf[1] = (WORD)(LOWORD(pcBuffer)); + _awVTMK4InBuf[2] = (WORD)(HIWORD(pcBuffer)); + _awVTMK4InBuf[3] = cwLength; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetblk, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + bcgetblk_usb(bcAddr, pcBuffer, cwLength); +#endif +} + +int bcdefbus(TMK_DATA bcBus) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcBus; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcdefbus, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return bcdefbus_usb(bcBus); +} + +TMK_DATA bcgetbus() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetbus, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return bcgetbus_usb(); +} + +int bcstart(TMK_DATA bcBase, TMK_DATA bcCtrlCode) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcBase; + _awVTMK4InBuf[1] = bcCtrlCode; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcstart, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return bcstart_usb(bcBase, bcCtrlCode); +} + +int bcstartx(TMK_DATA bcBase, TMK_DATA bcCtrlCode) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcBase; + _awVTMK4InBuf[1] = bcCtrlCode; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcstartx, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return bcstartx_usb(bcBase, bcCtrlCode); +} + +int bcdeflink(TMK_DATA bcBase, TMK_DATA bcCtrlCode) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcBase; + _awVTMK4InBuf[1] = bcCtrlCode; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcdeflink, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return bcdeflink_usb(bcBase, bcCtrlCode); +} + +DWORD bcgetlink() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetlink, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return bcgetlink_usb(); +} + +TMK_DATA bcstop() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcstop, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return bcstop_usb(); +} + +DWORD bcgetstate() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetstate, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return bcgetstate_usb(); +} + +int rtreset() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtreset, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return rtreset_usb(); +} + +int rtdefirqmode(TMK_DATA rtIrqMode) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtIrqMode; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtdefirqmode, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return rtdefirqmode_usb(rtIrqMode); +} + +TMK_DATA rtgetirqmode() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetirqmode, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetirqmode_usb(); +} + +int rtdefmode(TMK_DATA rtMode) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtMode; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtdefmode, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return rtdefmode_usb(rtMode); +} + +TMK_DATA rtgetmode() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetmode, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetmode_usb(); +} + +TMK_DATA rtgetmaxpage() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetmaxpage, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetmaxpage_usb(); +} + +int rtdefpage(TMK_DATA rtPage) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtPage; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtdefpage, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return rtdefpage_usb(rtPage); +} + +TMK_DATA rtgetpage() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetpage, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetpage_usb(); +} + +int rtdefpagepc(TMK_DATA rtPagePC) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtPagePC; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtdefpagepc, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return rtdefpagepc_usb(rtPagePC); +} + +int rtdefpagebus(TMK_DATA rtPageBus) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtPageBus; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtdefpagebus, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return rtdefpagebus_usb(rtPageBus); +} + +TMK_DATA rtgetpagepc() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetpagepc, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetpagepc_usb(); +} + +TMK_DATA rtgetpagebus() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetpagebus, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetpagebus_usb(); +} + +int rtdefaddress(TMK_DATA rtAddress) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtAddress; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtdefaddress, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return rtdefaddress_usb(rtAddress); +} + +TMK_DATA rtgetaddress() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetaddress, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetaddress_usb(); +} + +void rtdefsubaddr(TMK_DATA rtDir, TMK_DATA rtSubAddr) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtDir; + _awVTMK4InBuf[1] = rtSubAddr; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtdefsubaddr, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtdefsubaddr_usb(rtDir, rtSubAddr); +} + +TMK_DATA rtgetsubaddr() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetsubaddr, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetsubaddr_usb(); +} + +void rtputw(TMK_DATA rtAddr, TMK_DATA rtData) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtAddr; + _awVTMK4InBuf[1] = rtData; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtputw, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtputw_usb(rtAddr, rtData); +} + +TMK_DATA rtgetw(TMK_DATA rtAddr) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtAddr; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetw, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetw_usb(rtAddr); +} + +void rtputblk(TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[8], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtAddr; +// _awVTMK4InBuf[1] = 0; +// _awVTMK4InBuf[2] = 0; + _awVTMK4InBuf[3] = cwLength; + *(PDWORD64)(_awVTMK4InBuf+4) = (DWORD64)pcBuffer; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtputblk, _awVTMK4InBuf, 16, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtputblk_usb(rtAddr, pcBuffer, cwLength); +#else + WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtAddr; + _awVTMK4InBuf[1] = (WORD)(LOWORD(pcBuffer)); + _awVTMK4InBuf[2] = (WORD)(HIWORD(pcBuffer)); + _awVTMK4InBuf[3] = cwLength; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtputblk, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtputblk_usb(rtAddr, pcBuffer, cwLength); +#endif +} + +void rtgetblk(TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[8], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtAddr; +// _awVTMK4InBuf[1] = 0; +// _awVTMK4InBuf[2] = 0; + _awVTMK4InBuf[3] = cwLength; + *(PDWORD64)(_awVTMK4InBuf+4) = (DWORD64)pcBuffer; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetblk, _awVTMK4InBuf, 16, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtgetblk_usb(rtAddr, pcBuffer, cwLength); +#else + WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtAddr; + _awVTMK4InBuf[1] = (WORD)(LOWORD(pcBuffer)); + _awVTMK4InBuf[2] = (WORD)(HIWORD(pcBuffer)); + _awVTMK4InBuf[3] = cwLength; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetblk, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtgetblk_usb(rtAddr, pcBuffer, cwLength); +#endif +} + +void rtsetanswbits(TMK_DATA rtSetControl) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtSetControl; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtsetanswbits, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtsetanswbits_usb(rtSetControl); +} + +void rtclranswbits(TMK_DATA rtClrControl) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtClrControl; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtclranswbits, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtclranswbits_usb(rtClrControl); +} + +TMK_DATA rtgetanswbits() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetanswbits, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetanswbits_usb(); +} + +void rtgetflags(void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[12], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; +// _awVTMK4InBuf[0] = 0; +// _awVTMK4InBuf[1] = 0; + _awVTMK4InBuf[2] = rtDir; + _awVTMK4InBuf[3] = rtFlagMin; + _awVTMK4InBuf[4] = rtFlagMax; + *(PDWORD64)(_awVTMK4InBuf+8) = (DWORD64)pcBuffer; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetflags, _awVTMK4InBuf, 24, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtgetflags_usb(pcBuffer, rtDir, rtFlagMin, rtFlagMax); +#else + WORD _awVTMK4InBuf[5], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = (WORD)(LOWORD(pcBuffer)); + _awVTMK4InBuf[1] = (WORD)(HIWORD(pcBuffer)); + _awVTMK4InBuf[2] = rtDir; + _awVTMK4InBuf[3] = rtFlagMin; + _awVTMK4InBuf[4] = rtFlagMax; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetflags, _awVTMK4InBuf, 10, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtgetflags_usb(pcBuffer, rtDir, rtFlagMin, rtFlagMax); +#endif +} + +void rtputflags(void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[12], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; +// _awVTMK4InBuf[0] = 0; +// _awVTMK4InBuf[1] = 0; + _awVTMK4InBuf[2] = rtDir; + _awVTMK4InBuf[3] = rtFlagMin; + _awVTMK4InBuf[4] = rtFlagMax; + *(PDWORD64)(_awVTMK4InBuf+8) = (DWORD64)pcBuffer; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtputflags, _awVTMK4InBuf, 24, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtputflags_usb(pcBuffer, rtDir, rtFlagMin, rtFlagMax); +#else + WORD _awVTMK4InBuf[5], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = (WORD)(LOWORD(pcBuffer)); + _awVTMK4InBuf[1] = (WORD)(HIWORD(pcBuffer)); + _awVTMK4InBuf[2] = rtDir; + _awVTMK4InBuf[3] = rtFlagMin; + _awVTMK4InBuf[4] = rtFlagMax; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtputflags, _awVTMK4InBuf, 10, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtputflags_usb(pcBuffer, rtDir, rtFlagMin, rtFlagMax); +#endif +} + +void rtsetflag() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtsetflag, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtsetflag_usb(); +} + +void rtclrflag() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtclrflag, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtclrflag_usb(); +} + +TMK_DATA rtgetflag(TMK_DATA rtDir, TMK_DATA rtSubAddr) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtDir; + _awVTMK4InBuf[1] = rtSubAddr; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetflag, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetflag_usb(rtDir, rtSubAddr); +} + +TMK_DATA rtgetstate() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetstate, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetstate_usb(); +} + +TMK_DATA rtbusy() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtbusy, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtbusy_usb(); +} + +void rtlock(TMK_DATA rtDir, TMK_DATA rtSubAddr) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtDir; + _awVTMK4InBuf[1] = rtSubAddr; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtlock, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtlock_usb(rtDir, rtSubAddr); +} + +void rtunlock() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtunlock, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtunlock_usb(); +} + +TMK_DATA rtgetcmddata(TMK_DATA rtBusCommand) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtBusCommand; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetcmddata, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetcmddata_usb(rtBusCommand); +} +void rtputcmddata(TMK_DATA rtBusCommand, TMK_DATA rtData) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtBusCommand; + _awVTMK4InBuf[1] = rtData; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtputcmddata, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtputcmddata_usb(rtBusCommand, rtData); +} + +int mtreset() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mtreset, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return mtreset_usb(); +} + +TMK_DATA mtgetsw() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mtgetsw, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return mtgetsw_usb(); +} + +TMK_DATA rtenable(TMK_DATA rtEnable) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtEnable; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtenable, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtenable_usb(rtEnable); +} + +int mrtgetmaxn() +{ + return _VTMK4mrtMaxNum; +/* + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mrtgetmaxn, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return ((int)(_awVTMK4OutBuf[0])); +*/ +} + +DWORD mrtconfig(int mrtNumber) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + DWORD RTN,RT0,iRT; + int err; + char tmkName[32]; + + if (_hVTMK4VxD[mrtNumber] != NULL) + return 0; + + if (!_VTMK4usbFlag[mrtNumber]) + { + sprintf (tmkName,"%c%c.%cTMK1553BDevice%d",0x5c,0x5c,0x5c,mrtNumber); + _hVTMK4VxD[mrtNumber] = CreateFileA(tmkName, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL + ); + if (_hVTMK4VxD[mrtNumber] == INVALID_HANDLE_VALUE) + { + _hVTMK4VxD[mrtNumber] = NULL; + return 0; + } + + _awVTMK4InBuf[0] = (WORD)mrtNumber; + DeviceIoControl(_hVTMK4VxD[mrtNumber], (DWORD)IOCTL_TMK_mrtconfig, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + if (_awVTMK4OutBuf[0] != 0 && _awVTMK4OutBuf[1] != 0) + { + RT0 = (DWORD)_awVTMK4OutBuf[0]; + RTN = (DWORD)_awVTMK4OutBuf[1] + RT0 - 1; + // + for (iRT = RT0; iRT < RTN; ++iRT) + { + if (_hVTMK4VxD[iRT] != NULL) + { + err = 1; + break; + } + sprintf (tmkName,"%c%c.%cTMK1553BDevice%d",0x5c,0x5c,0x5c,iRT); + _hVTMK4VxD[iRT] = CreateFileA(tmkName, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL + ); + if (_hVTMK4VxD[iRT] == INVALID_HANDLE_VALUE) + { + _hVTMK4VxD[iRT] = NULL; + err = 1; + break; + } + }//for(iRT = RT0; iRT < RTN; iRT++) + if (err) + { + for (--iRT; iRT >= RT0; --iRT) + { + CloseHandle(_hVTMK4VxD[iRT]); + _hVTMK4VxD[iRT] = 0; + } + } + }//if(_awVTMK4OutBuf[0] != 0 && _awVTMK4OutBuf[1] != 0) + else + { + err = 1; + } + if (err) + { + CloseHandle(_hVTMK4VxD[mrtNumber]); + _hVTMK4VxD[mrtNumber] = 0; + return 0; + } + return (_awVTMK4OutBuf[0] + (_awVTMK4OutBuf[1]<<16)); + } + else + return 0; +} + +int mrtselected() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mrtselected, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return ((int)(_awVTMK4OutBuf[0])); + } + else + return mrtselected_usb(); +} + +TMK_DATA mrtgetstate() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mrtgetstate, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return mrtgetstate_usb(); +} + +void mrtdefbrcsubaddr0() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mrtdefbrcsubaddr0, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + mrtdefbrcsubaddr0_usb(); +} + +int mrtreset() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mrtreset, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return mrtreset_usb(); +} + +TMK_DATA tmktimer(TMK_DATA tmkTimerCtrl) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = tmkTimerCtrl; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmktimer, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return tmktimer_usb(tmkTimerCtrl); +} + +DWORD tmkgettimer() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgettimer, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return tmkgettimer_usb(); +} +TMK_DATA tmkgettimerl() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgettimerl, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return (TMK_DATA)tmkgettimerl_usb(); +} +DWORD bcgetmsgtime() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetmsgtime, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return bcgetmsgtime_usb(); +} +DWORD rtgetmsgtime() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetmsgtime, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return rtgetmsgtime_usb(); +} + +TMK_DATA tmkgethwver() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgethwver, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return tmkgethwver_usb(); +} + +DWORD tmkgetevtime() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgetevtime, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return tmkgetevtime_usb(); +} + +TMK_DATA tmkswtimer(TMK_DATA tmkTimerCtrl) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = tmkTimerCtrl; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkswtimer, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return tmkswtimer_usb(tmkTimerCtrl); +} + +DWORD tmkgetswtimer() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgetswtimer, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return tmkgetswtimer_usb(); +} + +TMK_DATA tmktimeout(TMK_DATA tmkTimeOut) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = tmkTimeOut; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmktimeout, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return tmktimeout_usb(tmkTimeOut); +} + +int mrtdefbrcpage(TMK_DATA mrtBrcPage) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = mrtBrcPage; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mrtdefbrcpage, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return mrtdefbrcpage_usb(mrtBrcPage); +} + +TMK_DATA mrtgetbrcpage() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mrtgetbrcpage, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return mrtgetbrcpage_usb(); +} + +int mbcinit(TMK_DATA mbcId) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = mbcId; + if(_VTMK4usbFlag[_VTMK4tmkCurNum] == 0) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mbcinit, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return TMK_BAD_NUMBER; +} + +int mbcpreparex(TMK_DATA mbcId, TMK_DATA bcBase, TMK_DATA bcCtrlCode, TMK_DATA mbcDelay) +{ + WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = mbcId; + _awVTMK4InBuf[1] = bcBase; + _awVTMK4InBuf[2] = bcCtrlCode; + _awVTMK4InBuf[3] = mbcDelay; + if(_VTMK4usbFlag[_VTMK4tmkCurNum] == 0) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mbcpreparex, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return TMK_BAD_NUMBER; +} + +int mbcstartx(TMK_DATA mbcId) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = mbcId; + if(_VTMK4usbFlag[_VTMK4tmkCurNum] == 0) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mbcstartx, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return TMK_BAD_NUMBER; +} + +TMK_DATA mbcalloc() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if(_VTMK4usbFlag[_VTMK4tmkCurNum] == 0) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mbcalloc, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return 0; +} + +int mbcfree(TMK_DATA mbcId) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = mbcId; + if(_VTMK4usbFlag[_VTMK4tmkCurNum] == 0) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mbcfree, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return TMK_BAD_NUMBER; +} + +DWORD MT_Start(DWORD dwBufSize, HANDLE hEvent) +{ + if (_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + return MonitorHwStart_usb(dwBufSize, hEvent); + } + else + return TMK_BAD_NUMBER; +} + +DWORD MT_GetMessage(WORD * Data, DWORD dwBufSize, int FillFlag, DWORD * dwMsWritten) +{ + if (_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + return MonitorHwGetMessage_usb(Data, dwBufSize, FillFlag, dwMsWritten); + } + else + return TMK_BAD_NUMBER; +} + +DWORD MT_Stop() +{ + if (_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + return MonitorHwStop_usb(); + } + else + return TMK_BAD_NUMBER; +} + +unsigned int tmkrawio(unsigned int *buf_out, unsigned int *buf_in) +{ + if (_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + return tmkrawio_usb(buf_out, buf_in); + } + else + return TMK_BAD_NUMBER; +} + +TMK_DATA rtgap(TMK_DATA Gap) +{ + if (_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + return rtgap_usb(Gap); + } + else + return 0; +} + +int tmkreadsn() +{ + if (_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + return tmkreadsn_usb(); + } + else + return TMK_BAD_NUMBER; +} +//#endif diff --git a/WDMTMKv2.h b/WDMTMKv2.h new file mode 100644 index 0000000..3ad16b2 --- /dev/null +++ b/WDMTMKv2.h @@ -0,0 +1,1020 @@ +/*****************************************************************************/ +/* WDMTMK API v4.08 for Microsoft Windows. ELCUS, 1998, 2011. */ +/* Interface to driver TMK1553B.SYS v4.08 */ +/* Interface to driver USB_TA_DRV.dll v1.9.2 for Windows 98/ME/2000/XP */ +/* for Windows 98/ME/2000/XP/Vista/7 */ +/*****************************************************************************/ + +//#ifndef _TMK1553B_ +//#define _TMK1553B_ + +//************************************************************************** +#include +#include +typedef uint16_t WORD; +typedef unsigned __LONG32 DWORD; +typedef void *HANDLE; +typedef int BOOL; +//************************************************************************** + +#define TMK_DATA unsigned short +#define tmkError *ptmkError + +#ifndef _TMK1553B_MRT +#define _TMK1553B_MRT +#endif + +#define TMK_VERSION_MIN 0x0406 /* v4.06 */ +#define TMK_VERSION 0x0408 /* v4.08 */ + +#define EZUSB_MAJOR_VERSION_MIN 02 +#define EZUSB_MINOR_VERSION_MIN 01 + +#ifdef _TMK1553B_MRT +#define MAX_TMK_NUMBER (8+64-1) +#else +#define MAX_TMK_NUMBER (8-1) +#endif //def TMK1553B_MRT + +#ifndef MAX_USBTA_NUM +#define MAX_USBTA_NUM (8-1) +#endif + +#define TMK_INT_TIMER 0x4000 +#define TMK_INT_BUSJAM 0x2000 +#define TMK_INT_FIFO_OVF 0x0400 + +#define MIN_TMK_TYPE 2 +#define MAX_TMK_TYPE 12 + +#define TMK400 2 +#define TMKMPC 3 +#define RTMK400 4 +#define TMKX 5 +#define TMKXI 6 +#define MRTX 7 +#define MRTXI 8 +#define TA 9 +#define TAI 10 +#define MRTA 11 +#define MRTAI 12 + +#define ALL_TMKS 0x00FF + +#define MBC_ALLOC_FAIL 0xFFFF + +#define GET_RT_GAP 0xFFFF +#define RT_GAP_DEFAULT 0 +#define RT_GAP_OPT1 1 + +#define GET_TIMEOUT 0xFFFF + +#define SWTIMER_OFF 0x0000 +#define SWTIMER_ON 0x0400 +#define SWTIMER_EVENT 0x8000 +#define SWTIMER_RESET 0xFBFF + +#define GET_SWTIMER_CTRL 0xFFFF + +#define TIMER_RESET 0xFBFF +#define TIMER_OFF 0x0000 +#define TIMER_16BIT 0x1400 +#define TIMER_32BIT 0x0400 +#define TIMER_1US 0x0000 +#define TIMER_2US 0x0080 +#define TIMER_4US 0x0100 +#define TIMER_8US 0x0180 +#define TIMER_16US 0x0200 +#define TIMER_32US 0x0280 +#define TIMER_64US 0x0300 +#define TIMER_STOP 0x0380 +#define TIMER_SYN 0x0040 +#define TIMER_SYND 0x0020 +#define TIMER_SA 0x001F + +#define TIMER_NOSTOP 0x2000 + +#define TIMER_MASK 0x17FF +#define TIMER_STEP 0x0380 +#define TIMER_BITS 0x3400 + +#define GET_TIMER_CTRL 0xFFFF + +#define DATA_BC_RT 0x00 +#define DATA_BC_RT_BRCST 0x08 +#define DATA_RT_BC 0x01 +#define DATA_RT_RT 0x02 +#define DATA_RT_RT_BRCST 0x0A +#define CTRL_C_A 0x03 +#define CTRL_C_BRCST 0x0B +#define CTRL_CD_A 0x04 +#define CTRL_CD_BRCST 0x0C +#define CTRL_C_AD 0x05 + +#define CC_FMT_1 0x00 +#define CC_FMT_2 0x01 +#define CC_FMT_3 0x02 +#define CC_FMT_4 0x03 +#define CC_FMT_5 0x05 +#define CC_FMT_6 0x04 +#define CC_FMT_7 0x08 +#define CC_FMT_8 0x0A +#define CC_FMT_9 0x0B +#define CC_FMT_10 0x0C + +#define BUS_A 0 +#define BUS_B 1 +#define BUS_1 0 +#define BUS_2 1 + +#define S_ERAO_MASK 0x01 +#define S_MEO_MASK 0x02 +#define S_IB_MASK 0x04 +#define S_TO_MASK 0x08 +#define S_EM_MASK 0x10 +#define S_EBC_MASK 0x20 +#define S_DI_MASK 0x40 +#define S_ELN_MASK 0x80 +#define S_G1_MASK 0x1000 +#define S_G2_MASK 0x2000 + +#define NWORDS_MASK 0x001F +#define CMD_MASK 0x041F +#define SUBADDR_MASK 0x03E0 +#define CI_MASK 0x03E0 +#define HBIT_MASK 0x0200 +#define RT_DIR_MASK 0x0400 +#define ADDRESS_MASK 0xF800 +#define RTFL_MASK 0x0001 +#define DNBA_MASK 0x0002 +#define SSFL_MASK 0x0004 +#define BUSY_MASK 0x0008 +#define BRCST_MASK 0x0010 +#define NULL_MASK 0x00E0 +#define SREQ_MASK 0x0100 +#define ERROR_MASK 0x0400 + +#define SREQ 0x01 +#define BUSY 0x02 +#define SSFL 0x04 +#define RTFL 0x08 +#define DNBA 0x10 + +#define CWB0 0x20 +#define CWB1 0x40 + +#define BC_MODE 0x00 +#define RT_MODE 0x80 +#define MT_MODE 0x100 +#define MRT_MODE 0x280 +#define UNDEFINED_MODE 0xFFFF + +#define RT_TRANSMIT 0x0400 +#define RT_RECEIVE 0x0000 + +#define RT_ERROR_MASK 0x4000 + +#define RT_FLAG 0x8000 +#define RT_FLAG_MASK 0x8000 + +#define RT_HBIT_MODE 0x0001 +#define RT_FLAG_MODE 0x0002 +#define RT_BRCST_MODE 0x0004 +#define RT_DATA_BL 0x2000 +#define RT_GENER1_BL 0x0004 +#define RT_GENER2_BL 0x4000 +#define BC_GENER1_BL 0x0004 +#define BC_GENER2_BL 0x4000 +#define MT_GENER1_BL 0x0004 +#define MT_GENER2_BL 0x4000 +#define TMK_IRQ_OFF 0x8000 + +#define CX_CC_MASK 0x000F +#define CX_CONT_MASK 0x0010 +#define CX_BUS_MASK 0x0020 +#define CX_SIG_MASK 0x8000 +#define CX_INT_MASK 0x0020 + +#define CX_CONT 0x0010 +#define CX_STOP 0x0000 +#define CX_BUS_0 0x0000 +#define CX_BUS_A 0x0000 +#define CX_BUS_1 0x0020 +#define CX_BUS_B 0x0020 +#define CX_NOSIG 0x0000 +#define CX_SIG 0x8000 +#define CX_INT 0x0000 +#define CX_NOINT 0x0020 + +#define SX_NOERR 0 +#define SX_MEO 1 +#define SX_TOA 2 +#define SX_TOD 3 +#define SX_ELN 4 +#define SX_ERAO 5 +#define SX_ESYN 6 +#define SX_EBC 7 + +#define SX_ERR_MASK 0x0007 +#define SX_IB_MASK 0x0008 +#define SX_G1_MASK 0x0010 +#define SX_G2_MASK 0x0020 +#define SX_K2_MASK 0x0100 +#define SX_K1_MASK 0x0200 +#define SX_SCC_MASK 0x3C00 +#define SX_ME_MASK 0x4000 +#define SX_BUS_MASK 0x8000 + +#define SX_BUS_0 0x0000 +#define SX_BUS_A 0x0000 +#define SX_BUS_1 0x8000 +#define SX_BUS_B 0x8000 + +#define GET_IO_DELAY 0xFFFF + +#define RT_ENABLE 0x0000 +#define RT_DISABLE 0x001F +#define RT_GET_ENABLE 0xFFFF + +#define CW(ADDR,DIR,SUBADDR,NWORDS) ((TMK_DATA)(((ADDR)<<11)|(DIR)|((SUBADDR)<<5)|((NWORDS)&0x1F))) +#define CWM(ADDR,COMMAND) ((TMK_DATA)(((ADDR)<<11)|(CI_MASK)|(COMMAND))) +#define CWMC(ADDR,CI,COMMAND) ((TMK_DATA)(((ADDR)<<11)|((CI)&0x03E0)|(COMMAND))) + +/*#define CMD_ILLEGAL 0x000*/ +#define CMD_DYNAMIC_BUS_CONTROL 0x400 +#define CMD_SYNCHRONIZE 0x401 +#define CMD_TRANSMIT_STATUS_WORD 0x402 +#define CMD_INITIATE_SELF_TEST 0x403 +#define CMD_TRANSMITTER_SHUTDOWN 0x404 +#define CMD_OVERRIDE_TRANSMITTER_SHUTDOWN 0x405 +#define CMD_INHIBIT_TERMINAL_FLAG_BIT 0x406 +#define CMD_OVERRIDE_INHIBIT_TERMINAL_FLAG_BIT 0x407 +#define CMD_RESET_REMOTE_TERMINAL 0x408 +#define CMD_TRANSMIT_VECTOR_WORD 0x410 +#define CMD_SYNCHRONIZE_WITH_DATA_WORD 0x011 +#define CMD_TRANSMIT_LAST_COMMAND_WORD 0x412 +#define CMD_TRANSMIT_BUILT_IN_TEST_WORD 0x413 + +#define TMK_ERROR_0 0xE0040000 +#define TMK_BAD_TYPE (1 + TMK_ERROR_0) +#define TMK_BAD_IRQ (2 + TMK_ERROR_0) +#define TMK_BAD_NUMBER (3 + TMK_ERROR_0) +#define BC_BAD_BUS (4 + TMK_ERROR_0) +#define BC_BAD_BASE (5 + TMK_ERROR_0) +#define BC_BAD_LEN (6 + TMK_ERROR_0) +#define RT_BAD_PAGE (7 + TMK_ERROR_0) +#define RT_BAD_LEN (8 + TMK_ERROR_0) +#define RT_BAD_ADDRESS (9 + TMK_ERROR_0) +#define RT_BAD_FUNC (10 + TMK_ERROR_0) +#define BC_BAD_FUNC (11 + TMK_ERROR_0) +#define TMK_BAD_FUNC (12 + TMK_ERROR_0) +#define VTMK_BAD_VERSION (13 + TMK_ERROR_0) + +#define VTMK_tmkconfig 2 +#define VTMK_tmkdone 3 +#define VTMK_tmkgetmaxn 4 +#define VTMK_tmkselect 5 +#define VTMK_tmkselected 6 +#define VTMK_tmkgetmode 7 +#define VTMK_tmksetcwbits 8 +#define VTMK_tmkclrcwbits 9 +#define VTMK_tmkgetcwbits 10 +#define VTMK_tmkdefevent 11 +#define VTMK_tmkgetevd 12 + +#define VTMK_bcreset 13 +#define VTMK_bc_def_tldw 14 +#define VTMK_bc_enable_di 15 +#define VTMK_bc_disable_di 16 +#define VTMK_bcdefirqmode 17 +#define VTMK_bcgetirqmode 18 +#define VTMK_bcgetmaxbase 19 +#define VTMK_bcdefbase 20 +#define VTMK_bcgetbase 21 +#define VTMK_bcputw 22 +#define VTMK_bcgetw 23 +#define VTMK_bcgetansw 24 +#define VTMK_bcputblk 25 +#define VTMK_bcgetblk 26 +#define VTMK_bcdefbus 27 +#define VTMK_bcgetbus 28 +#define VTMK_bcstart 29 +#define VTMK_bcstartx 30 +#define VTMK_bcdeflink 31 +#define VTMK_bcgetlink 32 +#define VTMK_bcstop 33 +#define VTMK_bcgetstate 34 + +#define VTMK_rtreset 35 +#define VTMK_rtdefirqmode 36 +#define VTMK_rtgetirqmode 37 +#define VTMK_rtdefmode 38 +#define VTMK_rtgetmode 39 +#define VTMK_rtgetmaxpage 40 +#define VTMK_rtdefpage 41 +#define VTMK_rtgetpage 42 +#define VTMK_rtdefpagepc 43 +#define VTMK_rtdefpagebus 44 +#define VTMK_rtgetpagepc 45 +#define VTMK_rtgetpagebus 46 +#define VTMK_rtdefaddress 47 +#define VTMK_rtgetaddress 48 +#define VTMK_rtdefsubaddr 49 +#define VTMK_rtgetsubaddr 50 +#define VTMK_rtputw 51 +#define VTMK_rtgetw 52 +#define VTMK_rtputblk 53 +#define VTMK_rtgetblk 54 +#define VTMK_rtsetanswbits 55 +#define VTMK_rtclranswbits 56 +#define VTMK_rtgetanswbits 57 +#define VTMK_rtgetflags 58 +#define VTMK_rtputflags 59 +#define VTMK_rtsetflag 60 +#define VTMK_rtclrflag 61 +#define VTMK_rtgetflag 62 +#define VTMK_rtgetstate 63 +#define VTMK_rtbusy 64 +#define VTMK_rtlock 65 +#define VTMK_rtunlock 66 +#define VTMK_rtgetcmddata 67 +#define VTMK_rtputcmddata 68 + +#define VTMK_mtreset 69 +#define VTMK_mtdefirqmode 70 +#define VTMK_mtgetirqmode 71 +#define VTMK_mtgetmaxbase 72 +#define VTMK_mtdefbase 73 +#define VTMK_mtgetbase 74 +#define VTMK_mtputw 75 +#define VTMK_mtgetw 76 +#define VTMK_mtgetsw 77 +#define VTMK_mtputblk 78 +#define VTMK_mtgetblk 79 +#define VTMK_mtstartx 80 +#define VTMK_mtdeflink 81 +#define VTMK_mtgetlink 82 +#define VTMK_mtstop 83 +#define VTMK_mtgetstate 84 + +#define VTMK_tmkgetinfo 85 +#define VTMK_GetVersion 86 + +#define VTMK_rtenable 87 + +#define VTMK_mrtgetmaxn 88 +#define VTMK_mrtconfig 89 +#define VTMK_mrtselected 90 +#define VTMK_mrtgetstate 91 +#define VTMK_mrtdefbrcsubaddr0 92 +#define VTMK_mrtreset 93 + +#define VTMK_tmktimer 94 +#define VTMK_tmkgettimer 95 +#define VTMK_tmkgettimerl 96 +#define VTMK_bcgetmsgtime 97 +#define VTMK_mtgetmsgtime 98 +#define VTMK_rtgetmsgtime 99 + +#define VTMK_tmkgethwver 100 + +#define VTMK_tmkgetevtime 101 +#define VTMK_tmkswtimer 102 +#define VTMK_tmkgetswtimer 103 + +#define VTMK_tmktimeout 104 + +#define VTMK_mrtdefbrcpage 105 +#define VTMK_mrtgetbrcpage 106 + +#define VTMK_mbcinit 107 +#define VTMK_mbcpreparex 108 +#define VTMK_mbcstartx 109 +#define VTMK_mbcalloc 110 +#define VTMK_mbcfree 111 + +#define CTL_CODE( DeviceType, Function, Method, Access ) ( \ + ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \ +) + + +#define METHOD_BUFFERED 0 +#define METHOD_IN_DIRECT 1 +#define METHOD_OUT_DIRECT 2 +#define METHOD_NEITHER 3 +#define FILE_ANY_ACCESS 0 +#define FILE_READ_ACCESS ( 0x0001 ) // file & pipe +#define FILE_WRITE_ACCESS ( 0x0002 ) // file & pipe +#define TMK_KRNLDRVR 0x8000 +#define IOCTL_TMK_tmkconfig CTL_CODE(TMK_KRNLDRVR, VTMK_tmkconfig+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkdone CTL_CODE(TMK_KRNLDRVR, VTMK_tmkdone+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkgetmaxn CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgetmaxn+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkselect CTL_CODE(TMK_KRNLDRVR, VTMK_tmkselect+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkselected CTL_CODE(TMK_KRNLDRVR, VTMK_tmkselected+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkgetmode CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgetmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmksetcwbits CTL_CODE(TMK_KRNLDRVR, VTMK_tmksetcwbits+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkclrcwbits CTL_CODE(TMK_KRNLDRVR, VTMK_tmkclrcwbits+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkgetcwbits CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgetcwbits+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkdefevent CTL_CODE(TMK_KRNLDRVR, VTMK_tmkdefevent+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkgetevd CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgetevd+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcreset CTL_CODE(TMK_KRNLDRVR, VTMK_bcreset+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bc_def_tldw CTL_CODE(TMK_KRNLDRVR, VTMK_bc_def_tldw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bc_enable_di CTL_CODE(TMK_KRNLDRVR, VTMK_bc_enable_di+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bc_disable_di CTL_CODE(TMK_KRNLDRVR, VTMK_bc_disable_di+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcdefirqmode CTL_CODE(TMK_KRNLDRVR, VTMK_bcdefirqmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetirqmode CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetirqmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetmaxbase CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetmaxbase+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcdefbase CTL_CODE(TMK_KRNLDRVR, VTMK_bcdefbase+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetbase CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetbase+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcputw CTL_CODE(TMK_KRNLDRVR, VTMK_bcputw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetw CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetansw CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetansw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcputblk CTL_CODE(TMK_KRNLDRVR, VTMK_bcputblk+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetblk CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetblk+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcdefbus CTL_CODE(TMK_KRNLDRVR, VTMK_bcdefbus+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetbus CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetbus+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcstart CTL_CODE(TMK_KRNLDRVR, VTMK_bcstart+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcstartx CTL_CODE(TMK_KRNLDRVR, VTMK_bcstartx+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcdeflink CTL_CODE(TMK_KRNLDRVR, VTMK_bcdeflink+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetlink CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetlink+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcstop CTL_CODE(TMK_KRNLDRVR, VTMK_bcstop+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetstate CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetstate+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_rtreset CTL_CODE(TMK_KRNLDRVR, VTMK_rtreset+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtdefirqmode CTL_CODE(TMK_KRNLDRVR, VTMK_rtdefirqmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetirqmode CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetirqmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtdefmode CTL_CODE(TMK_KRNLDRVR, VTMK_rtdefmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetmode CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetmaxpage CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetmaxpage+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtdefpage CTL_CODE(TMK_KRNLDRVR, VTMK_rtdefpage+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetpage CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetpage+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtdefpagepc CTL_CODE(TMK_KRNLDRVR, VTMK_rtdefpagepc+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtdefpagebus CTL_CODE(TMK_KRNLDRVR, VTMK_rtdefpagebus+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetpagepc CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetpagepc+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetpagebus CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetpagebus+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtdefaddress CTL_CODE(TMK_KRNLDRVR, VTMK_rtdefaddress+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetaddress CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetaddress+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtdefsubaddr CTL_CODE(TMK_KRNLDRVR, VTMK_rtdefsubaddr+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetsubaddr CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetsubaddr+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtputw CTL_CODE(TMK_KRNLDRVR, VTMK_rtputw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetw CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtputblk CTL_CODE(TMK_KRNLDRVR, VTMK_rtputblk+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetblk CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetblk+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtsetanswbits CTL_CODE(TMK_KRNLDRVR, VTMK_rtsetanswbits+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtclranswbits CTL_CODE(TMK_KRNLDRVR, VTMK_rtclranswbits+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetanswbits CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetanswbits+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetflags CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetflags+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtputflags CTL_CODE(TMK_KRNLDRVR, VTMK_rtputflags+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtsetflag CTL_CODE(TMK_KRNLDRVR, VTMK_rtsetflag+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtclrflag CTL_CODE(TMK_KRNLDRVR, VTMK_rtclrflag+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetflag CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetflag+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetstate CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetstate+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtbusy CTL_CODE(TMK_KRNLDRVR, VTMK_rtbusy+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtlock CTL_CODE(TMK_KRNLDRVR, VTMK_rtlock+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtunlock CTL_CODE(TMK_KRNLDRVR, VTMK_rtunlock+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetcmddata CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetcmddata+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtputcmddata CTL_CODE(TMK_KRNLDRVR, VTMK_rtputcmddata+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_mtreset CTL_CODE(TMK_KRNLDRVR, VTMK_mtreset+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtdefirqmode CTL_CODE(TMK_KRNLDRVR, VTMK_mtdefirqmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetirqmode CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetirqmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetmaxbase CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetmaxbase+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtdefbase CTL_CODE(TMK_KRNLDRVR, VTMK_mtdefbase+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetbase CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetbase+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtputw CTL_CODE(TMK_KRNLDRVR, VTMK_mtputw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetw CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetsw CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetsw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtputblk CTL_CODE(TMK_KRNLDRVR, VTMK_mtputblk+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetblk CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetblk+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtstartx CTL_CODE(TMK_KRNLDRVR, VTMK_mtstartx+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtdeflink CTL_CODE(TMK_KRNLDRVR, VTMK_mtdeflink+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetlink CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetlink+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtstop CTL_CODE(TMK_KRNLDRVR, VTMK_mtstop+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetstate CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetstate+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_tmkgetinfo CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgetinfo+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_GetVersion CTL_CODE(TMK_KRNLDRVR, VTMK_GetVersion+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_rtenable CTL_CODE(TMK_KRNLDRVR, VTMK_rtenable+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_mrtgetmaxn CTL_CODE(TMK_KRNLDRVR, VTMK_mrtgetmaxn+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mrtconfig CTL_CODE(TMK_KRNLDRVR, VTMK_mrtconfig+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mrtselected CTL_CODE(TMK_KRNLDRVR, VTMK_mrtselected+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mrtgetstate CTL_CODE(TMK_KRNLDRVR, VTMK_mrtgetstate+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mrtdefbrcsubaddr0 CTL_CODE(TMK_KRNLDRVR, VTMK_mrtdefbrcsubaddr0+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mrtreset CTL_CODE(TMK_KRNLDRVR, VTMK_mrtreset+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_tmktimer CTL_CODE(TMK_KRNLDRVR, VTMK_tmktimer+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkgettimer CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgettimer+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkgettimerl CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgettimerl+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetmsgtime CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetmsgtime+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetmsgtime CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetmsgtime+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetmsgtime CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetmsgtime+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_tmkgethwver CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgethwver+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_tmkgetevtime CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgetevtime+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkswtimer CTL_CODE(TMK_KRNLDRVR, VTMK_tmkswtimer+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkgetswtimer CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgetswtimer+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_tmktimeout CTL_CODE(TMK_KRNLDRVR, VTMK_tmktimeout+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_mrtdefbrcpage CTL_CODE(TMK_KRNLDRVR, VTMK_mrtdefbrcpage+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mrtgetbrcpage CTL_CODE(TMK_KRNLDRVR, VTMK_mrtgetbrcpage+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_mbcinit CTL_CODE(TMK_KRNLDRVR, VTMK_mbcinit+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mbcpreparex CTL_CODE(TMK_KRNLDRVR, VTMK_mbcpreparex+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mbcstartx CTL_CODE(TMK_KRNLDRVR, VTMK_mbcstartx+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mbcalloc CTL_CODE(TMK_KRNLDRVR, VTMK_mbcalloc+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mbcfree CTL_CODE(TMK_KRNLDRVR, VTMK_mbcfree+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define Ezusb_IOCTL_INDEX 0x0800 +#define FILE_DEVICE_UNKNOWN 0x00000022 + +#define IOCTL_EZUSB_GET_DRIVER_VERSION CTL_CODE(FILE_DEVICE_UNKNOWN, Ezusb_IOCTL_INDEX+29, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_EZUSB_SET_CURPROC CTL_CODE(FILE_DEVICE_UNKNOWN, Ezusb_IOCTL_INDEX+34, METHOD_BUFFERED, FILE_ANY_ACCESS) + +typedef struct _EZUSB_DRIVER_VERSION +{ + WORD MajorVersion; + WORD MinorVersion; + WORD BuildVersion; +} EZUSB_DRIVER_VERSION, *PEZUSB_DRIVER_VERSION; + +typedef struct +{ + short nType; + char szName[10]; + unsigned short wPorts1; + unsigned short wPorts2; + unsigned short wIrq1; + unsigned short wIrq2; + unsigned short wIODelay; +} TTmkConfigData; + +typedef struct +{ + int nInt; + unsigned short wMode; + union + { + struct + { + unsigned short wResult; + unsigned short wAW1; + unsigned short wAW2; + } bc; + struct + { + unsigned short wBase; + unsigned short wResultX; + } bcx; + struct + { + unsigned short wStatus; + unsigned short wCmd; + } rt; + struct + { + unsigned short wBase; + unsigned short wResultX; + } mt; + struct + { + unsigned short wStatus; + } mrt; + struct + { + unsigned short wRequest; +// DWORD dwTimer; + } tmk; + struct + { + unsigned short wData1; + unsigned short wData2; + } raw; + }; +} TTmkEventData; + +DWORD TmkOpen(); +void TmkClose(); +void tmkgetinfo(TTmkConfigData *pConfD); +void tmkgetevd( TTmkEventData *pEvD ); +void tmkdefevent( HANDLE hEvent, BOOL fEventSet ); +int tmkgetmaxn(); +int tmkconfig( int tmkNumber ); +int tmkdone( int tmkNumber ); +int tmkselect( int tmkNumber ); +int tmkselected(); +TMK_DATA tmkgetmode(); +int tmkdefdac(int dacValue); +int tmkgetdac(int *dacValue, int *dacMode); +void tmksetcwbits( TMK_DATA tmkSetControl ); +void tmkclrcwbits( TMK_DATA tmkClrControl ); +TMK_DATA tmkgetcwbits(); +int bcreset(); +void bc_def_tldw( TMK_DATA wTLDW ); +void bc_enable_di(); +void bc_disable_di(); +int bcdefirqmode( TMK_DATA bcIrqMode ); +TMK_DATA bcgetirqmode(); +TMK_DATA bcgetmaxbase(); +int bcdefbase( TMK_DATA bcBasePC ); +TMK_DATA bcgetbase(); +void bcputw( TMK_DATA bcAddr, TMK_DATA bcData ); +TMK_DATA bcgetw( TMK_DATA bcAddr ); +DWORD bcgetansw( TMK_DATA bcCtrlCode ); +void bcputblk( TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength ); +void bcgetblk( TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength ); +int bcdefbus( TMK_DATA bcBus ); +TMK_DATA bcgetbus(); +int bcstart( TMK_DATA bcBase, TMK_DATA bcCtrlCode ); +int bcstartx( TMK_DATA bcBase, TMK_DATA bcCtrlCode ); +int bcdeflink( TMK_DATA bcBase, TMK_DATA bcCtrlCode ); +DWORD bcgetlink(); +TMK_DATA bcstop(); +DWORD bcgetstate(); +int rtreset(); +int rtdefirqmode( TMK_DATA rtIrqMode ); +TMK_DATA rtgetirqmode(); +int rtdefmode( TMK_DATA rtMode ); +TMK_DATA rtgetmode(); +TMK_DATA rtgetmaxpage(); +int rtdefpage( TMK_DATA rtPage ); +TMK_DATA rtgetpage(); +int rtdefpagepc( TMK_DATA rtPagePC ); +int rtdefpagebus( TMK_DATA rtPageBus ); +TMK_DATA rtgetpagepc(); +TMK_DATA rtgetpagebus(); +int rtdefaddress( TMK_DATA rtAddress ); +TMK_DATA rtgetaddress(); +void rtdefsubaddr( TMK_DATA rtDir, TMK_DATA rtSubAddr); +TMK_DATA rtgetsubaddr(); +void rtputw( TMK_DATA rtAddr, TMK_DATA rtData ); +TMK_DATA rtgetw( TMK_DATA rtAddr ); +void rtputblk( TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength ); +void rtgetblk( TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength ); +void rtsetanswbits( TMK_DATA rtSetControl ); +void rtclranswbits( TMK_DATA rtClrControl ); +TMK_DATA rtgetanswbits(); +void rtgetflags( void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax ); +void rtputflags( void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax ); +void rtsetflag(); +void rtclrflag(); +TMK_DATA rtgetflag( TMK_DATA rtDir, TMK_DATA rtSubAddr ); +TMK_DATA rtgetstate(); +TMK_DATA rtbusy(); +void rtlock( TMK_DATA rtDir, TMK_DATA rtSubAddr ); +void rtunlock(); +TMK_DATA rtgetcmddata( TMK_DATA rtBusCommand ); +void rtputcmddata( TMK_DATA rtBusCommand, TMK_DATA rtData ); +int mtreset(); +TMK_DATA mtgetsw(); +#define mtdefirqmode bcdefirqmode +#define mtgetirqmode bcgetirqmode +#define mtgetmaxbase bcgetmaxbase +#define mtdefbase bcdefbase +#define mtgetbase bcgetbase +#define mtputw bcputw +#define mtgetw bcgetw +#define mtputblk bcputblk +#define mtgetblk bcgetblk +#define mtstartx bcstartx +#define mtdeflink bcdeflink +#define mtgetlink bcgetlink +#define mtstop bcstop +#define mtgetstate bcgetstate + +TMK_DATA rtenable(TMK_DATA rtEnable); + +int mrtgetmaxn(); +DWORD mrtconfig(int tmkNumber); +int mrtselected(); +TMK_DATA mrtgetstate(); +void mrtdefbrcsubaddr0(); +int mrtreset(); + +TMK_DATA tmktimer(TMK_DATA tmkTimerCtrl); +DWORD tmkgettimer(); +TMK_DATA tmkgettimerl(); +DWORD bcgetmsgtime(); +#define mtgetmsgtime bcgetmsgtime +DWORD rtgetmsgtime(); +TMK_DATA tmkgethwver(); + +DWORD tmkgetevtime(); +TMK_DATA tmkswtimer(TMK_DATA tmkTimerCtrl); +DWORD tmkgetswtimer(); + +TMK_DATA tmktimeout(TMK_DATA tmkTimeOut); + +int mrtdefbrcpage(TMK_DATA mrtBrcPage); +TMK_DATA mrtgetbrcpage(); + +int mbcinit(TMK_DATA mbcId); +int mbcpreparex(TMK_DATA mbcId, TMK_DATA bcBase, TMK_DATA bcCtrlCode, TMK_DATA mbcDelay); +int mbcstartx(TMK_DATA mbcId); +TMK_DATA mbcalloc(); +int mbcfree(TMK_DATA mbcId); + +DWORD MT_Start(DWORD dwBufSize, HANDLE hEvent); +DWORD MT_GetMessage(WORD * Data, DWORD dwBufSize, int FillFlag, DWORD * dwMsWritten); +DWORD MT_Stop(); + +unsigned int tmkrawio(unsigned int *buf_out, unsigned int *buf_in); +TMK_DATA rtgap(TMK_DATA Gap); +int tmkreadsn(); + +typedef struct +{ + int nInt; + unsigned int empty; + unsigned int wMode; + unsigned int awEvData[3]; +// PEPROCESS hProc; + unsigned int empty1; + unsigned int empty2; +} TListEvD, *pTListEvD; + +typedef int (__cdecl *htmkconfig_usb) (int tmkNumber, int wType, int PortsAddr1, int PortsAddr2); +typedef int (__cdecl *htmkdone_usb) (int tmkNumber); +typedef int (__cdecl *htmkselect_usb)(int tmkNumber); +typedef void (__cdecl *htmkdefevent_usb)(void *hEvent); +typedef int (__cdecl *hRead_DLL_EvD_usb)(TListEvD *evd); +typedef void (__cdecl *htmksetcwbits_usb)(TMK_DATA tmkSetControl); +typedef void (__cdecl *htmkclrcwbits_usb)(TMK_DATA tmkClrControl); +typedef TMK_DATA (__cdecl *htmkgetcwbits_usb)(); +typedef TMK_DATA (__cdecl *htmkgetmode_usb)(); +typedef int (__cdecl *htmkdefdac_usb)(int dacValue); +typedef int (__cdecl *htmkgetdac_usb)(int *value, int *mode); +typedef int (__cdecl *hbcreset_usb)(); +typedef int (__cdecl *hbcdefirqmode_usb)(TMK_DATA bcIrqMode); +typedef TMK_DATA (__cdecl *hbcgetirqmode_usb)(); +typedef TMK_DATA (__cdecl *hbcgetmaxbase_usb)(); +typedef int (__cdecl *hbcdefbase_usb)(TMK_DATA bcBasePC); +typedef TMK_DATA (__cdecl *hbcgetbase_usb)(); +typedef void (__cdecl *hbcputw_usb)(TMK_DATA bcAddr, TMK_DATA bcData); +typedef TMK_DATA (__cdecl *hbcgetw_usb)(TMK_DATA bcAddr); +typedef DWORD (__cdecl *hbcgetansw_usb)(TMK_DATA bcCtrlCode); +typedef void (__cdecl *hbcputblk_usb)(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength); +typedef void (__cdecl *hbcgetblk_usb)(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength); +typedef int (__cdecl *hbcdefbus_usb)(TMK_DATA bcBus); +typedef TMK_DATA (__cdecl *hbcgetbus_usb)(); +typedef int (__cdecl *hbcstart_usb)(TMK_DATA bcBase, TMK_DATA bcCtrlCode); +typedef int (__cdecl *hbcstartx_usb)(TMK_DATA bcBase, TMK_DATA bcCtrlCode); +typedef int (__cdecl *hbcdeflink_usb)(TMK_DATA bcBase, TMK_DATA bcCtrlCode); +typedef DWORD (__cdecl *hbcgetlink_usb)(); +typedef TMK_DATA (__cdecl *hbcstop_usb)(); +typedef DWORD (__cdecl *hbcgetstate_usb)(); +typedef int (__cdecl *hrtreset_usb)(); +typedef int (__cdecl *hrtdefirqmode_usb)(TMK_DATA rtIrqMode); +typedef TMK_DATA (__cdecl *hrtgetirqmode_usb)(); +typedef int (__cdecl *hrtdefmode_usb)(TMK_DATA rtMode); +typedef TMK_DATA (__cdecl *hrtgetmode_usb)(); +typedef TMK_DATA (__cdecl *hrtgetmaxpage_usb)(); +typedef int (__cdecl *hrtdefpage_usb)(TMK_DATA rtPage); +typedef TMK_DATA (__cdecl *hrtgetpage_usb)(); +typedef int (__cdecl *hrtdefpagepc_usb)(TMK_DATA rtPagePC); +typedef int (__cdecl *hrtdefpagebus_usb)(TMK_DATA rtPageBus); +typedef TMK_DATA (__cdecl *hrtgetpagepc_usb)(); +typedef TMK_DATA (__cdecl *hrtgetpagebus_usb)(); +typedef int (__cdecl *hrtdefaddress_usb)(TMK_DATA rtAddress); +typedef TMK_DATA (__cdecl *hrtgetaddress_usb)(); +typedef void (__cdecl *hrtdefsubaddr_usb)(TMK_DATA rtDir, TMK_DATA rtSubAddr); +typedef TMK_DATA (__cdecl *hrtgetsubaddr_usb)(); +typedef void (__cdecl *hrtputw_usb)(TMK_DATA rtAddr, TMK_DATA rtData); +typedef TMK_DATA (__cdecl *hrtgetw_usb)(TMK_DATA rtAddr); +typedef void (__cdecl *hrtputblk_usb)(TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength); +typedef void (__cdecl *hrtgetblk_usb)(TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength); +typedef void (__cdecl *hrtsetanswbits_usb)(TMK_DATA rtSetControl); +typedef void (__cdecl *hrtclranswbits_usb)(TMK_DATA rtClrControl); +typedef TMK_DATA (__cdecl *hrtgetanswbits_usb)(); +typedef void (__cdecl *hrtgetflags_usb)(void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax); +typedef void (__cdecl *hrtputflags_usb)(void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax); +typedef void (__cdecl *hrtsetflag_usb)(); +typedef void (__cdecl *hrtclrflag_usb)(); +typedef TMK_DATA (__cdecl *hrtgetflag_usb)(TMK_DATA rtDir, TMK_DATA rtSubAddr); +typedef void (__cdecl *hrtputflag_usb)(TMK_DATA rtDir, TMK_DATA rtSubAddr, TMK_DATA rtFlag); +typedef TMK_DATA (__cdecl *hrtgetstate_usb)(); +typedef TMK_DATA (__cdecl *hrtbusy_usb)(); +typedef void (__cdecl *hrtlock_usb)(TMK_DATA rtDir, TMK_DATA rtSubAddr); +typedef void (__cdecl *hrtunlock_usb)(); +typedef TMK_DATA (__cdecl *hrtgetcmddata_usb)(TMK_DATA rtBusCommand); +typedef void (__cdecl *hrtputcmddata_usb)(TMK_DATA rtBusCommand, TMK_DATA rtData); +typedef int (__cdecl *hmtreset_usb)(); +typedef TMK_DATA (__cdecl *hmtgetsw_usb)(); +typedef TMK_DATA (__cdecl *hrtenable_usb)(TMK_DATA rtEnable); +typedef int (__cdecl *hmrtselected_usb)(); +typedef TMK_DATA (__cdecl *hmrtgetstate_usb)(); +typedef void (__cdecl *hmrtdefbrcsubaddr0_usb)(); +typedef int (__cdecl *hmrtreset_usb)(); +typedef TMK_DATA (__cdecl *htmktimer_usb)(TMK_DATA TimerCtrl); +typedef DWORD (__cdecl *htmkgettimer_usb)(); +typedef DWORD (__cdecl *htmkgettimerl_usb)(); +typedef DWORD (__cdecl *hbcgetmsgtime_usb)(); +typedef DWORD (__cdecl *hrtgetmsgtime_usb)(); +typedef TMK_DATA (__cdecl *htmkgethwver_usb)(); +typedef DWORD (__cdecl *htmkgetevtime_usb)(); +typedef TMK_DATA (__cdecl *htmkswtimer_usb)(TMK_DATA tmkTimerCtrl); +typedef DWORD (__cdecl *htmkgetswtimer_usb)(); +typedef TMK_DATA (__cdecl *htmktimeout_usb)(TMK_DATA tmkTimeOut); +typedef int (__cdecl *hmrtdefbrcpage_usb)(TMK_DATA mrtBrcPage); +typedef TMK_DATA (__cdecl *hmrtgetbrcpage_usb)(); + +typedef DWORD (__cdecl *hMonitorHwStart_usb)(DWORD dwBufSize, HANDLE hEvent); +typedef DWORD (__cdecl *hMonitorHwGetMessage_usb)(WORD * Data, DWORD dwBufSize, BOOL FillFlag, DWORD * dwMsWritten); +typedef DWORD (__cdecl *hMonitorHwStop_usb)(void); + +typedef unsigned int (__cdecl *htmkrawio_usb)(unsigned int *buf_out, unsigned int *buf_in); +typedef TMK_DATA (__cdecl *hrtgap_usb)(TMK_DATA Gap); +typedef int (__cdecl *htmkreadsn_usb)(void); + +int ftmkError = -1; + +int ftmkconfig_usb (int tmkNumber, int wType, int PortsAddr1, int PortsAddr2){return -1;} +int ftmkdone_usb (int tmkNumber){return -1;} +int ftmkselect_usb(int tmkNumber){return -1;} +void ftmkdefevent_usb(void *hEvent){} +int fRead_DLL_EvD_usb(TListEvD *evd){return -1;} +void ftmksetcwbits_usb(TMK_DATA tmkSetControl){} +void ftmkclrcwbits_usb(TMK_DATA tmkClrControl){} +TMK_DATA ftmkgetcwbits_usb(){return -1;} +TMK_DATA ftmkgetmode_usb(){return -1;} +int ftmkdefdac_usb(int dacValue){return -1;} +int ftmkgetdac_usb(int *value, int *mode){return -1;} +int fbcreset_usb(){return -1;} +int fbcdefirqmode_usb(TMK_DATA bcIrqMode){return -1;} +TMK_DATA fbcgetirqmode_usb(){return -1;} +TMK_DATA fbcgetmaxbase_usb(){return -1;} +int fbcdefbase_usb(TMK_DATA bcBasePC){return -1;} +TMK_DATA fbcgetbase_usb(){return -1;} +void fbcputw_usb(TMK_DATA bcAddr, TMK_DATA bcData){} +TMK_DATA fbcgetw_usb(TMK_DATA bcAddr){return -1;} +DWORD fbcgetansw_usb(TMK_DATA bcCtrlCode){return -1;} +void fbcputblk_usb(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength){} +void fbcgetblk_usb(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength){} +int fbcdefbus_usb(TMK_DATA bcBus){return -1;} +TMK_DATA fbcgetbus_usb(){return -1;} +int fbcstart_usb(TMK_DATA bcBase, TMK_DATA bcCtrlCode){return -1;} +int fbcstartx_usb(TMK_DATA bcBase, TMK_DATA bcCtrlCode){return -1;} +int fbcdeflink_usb(TMK_DATA bcBase, TMK_DATA bcCtrlCode){return -1;} +DWORD fbcgetlink_usb(){return -1;} +TMK_DATA fbcstop_usb(){return -1;} +DWORD fbcgetstate_usb(){return -1;} +int frtreset_usb(){return -1;} +int frtdefirqmode_usb(TMK_DATA rtIrqMode){return -1;} +TMK_DATA frtgetirqmode_usb(){return -1;} +int frtdefmode_usb(TMK_DATA rtMode){return -1;} +TMK_DATA frtgetmode_usb(){return -1;} +TMK_DATA frtgetmaxpage_usb(){return -1;} +int frtdefpage_usb(TMK_DATA rtPage){return -1;} +TMK_DATA frtgetpage_usb(){return -1;} +int frtdefpagepc_usb(TMK_DATA rtPagePC){return -1;} +int frtdefpagebus_usb(TMK_DATA rtPageBus){return -1;} +TMK_DATA frtgetpagepc_usb(){return -1;} +TMK_DATA frtgetpagebus_usb(){return -1;} +int frtdefaddress_usb(TMK_DATA rtAddress){return -1;} +TMK_DATA frtgetaddress_usb(){return -1;} +void frtdefsubaddr_usb(TMK_DATA rtDir, TMK_DATA rtSubAddr){} +TMK_DATA frtgetsubaddr_usb(){return -1;} +void frtputw_usb(TMK_DATA rtAddr, TMK_DATA rtData){} +TMK_DATA frtgetw_usb(TMK_DATA rtAddr){return -1;} +void frtputblk_usb(TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength){} +void frtgetblk_usb(TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength){} +void frtsetanswbits_usb(TMK_DATA rtSetControl){} +void frtclranswbits_usb(TMK_DATA rtClrControl){} +TMK_DATA frtgetanswbits_usb(){return -1;} +void frtgetflags_usb(void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax){} +void frtputflags_usb(void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax){} +void frtsetflag_usb(){} +void frtclrflag_usb(){} +TMK_DATA frtgetflag_usb(TMK_DATA rtDir, TMK_DATA rtSubAddr){return -1;} +void frtputflag_usb(TMK_DATA rtDir, TMK_DATA rtSubAddr, TMK_DATA rtFlag){} +TMK_DATA frtgetstate_usb(){return -1;} +TMK_DATA frtbusy_usb(){return -1;} +void frtlock_usb(TMK_DATA rtDir, TMK_DATA rtSubAddr){} +void frtunlock_usb(){} +TMK_DATA frtgetcmddata_usb(TMK_DATA rtBusCommand){return -1;} +void frtputcmddata_usb(TMK_DATA rtBusCommand, TMK_DATA rtData){} +int fmtreset_usb(){return -1;} +TMK_DATA fmtgetsw_usb(){return -1;} +TMK_DATA frtenable_usb(TMK_DATA rtEnable){return -1;} +int fmrtselected_usb(){return -1;} +TMK_DATA fmrtgetstate_usb(){return -1;} +void fmrtdefbrcsubaddr0_usb(){} +int fmrtreset_usb(){return -1;} +TMK_DATA ftmktimer_usb(TMK_DATA TimerCtrl){return -1;} +DWORD ftmkgettimer_usb(){return -1;} +DWORD ftmkgettimerl_usb(){return -1;} +DWORD fbcgetmsgtime_usb(){return -1;} +DWORD frtgetmsgtime_usb(){return -1;} +TMK_DATA ftmkgethwver_usb(){return -1;} +DWORD ftmkgetevtime_usb(){return -1;} +TMK_DATA ftmkswtimer_usb(TMK_DATA tmkTimerCtrl){return -1;} +DWORD ftmkgetswtimer_usb(){return -1;} +TMK_DATA ftmktimeout_usb(WORD tmkTimeOut){return -1;} +int fmrtdefbrcpage_usb(TMK_DATA mrtBrcPage){return -1;} +TMK_DATA fmrtgetbrcpage_usb(){return 0;} + +DWORD fMonitorHwStart_usb(DWORD dwBufSize, HANDLE hEvent){return -1;} +DWORD fMonitorHwGetMessage_usb(WORD * Data, DWORD dwBufSize, BOOL FillFlag, DWORD * dwMsWritten){return -1;} +DWORD fMonitorHwStop_usb(void){return -1;} + +unsigned int ftmkrawio_usb(unsigned int *buf_out, unsigned int *buf_in){return -1;} +TMK_DATA frtgap_usb(TMK_DATA Gap){return -1;} +int ftmkreadsn_usb(void){return -1;} + +int *ptmkError; + +htmkconfig_usb tmkconfig_usb = ftmkconfig_usb; +htmkdone_usb tmkdone_usb = ftmkdone_usb; +htmkselect_usb tmkselect_usb = ftmkselect_usb; +htmkdefevent_usb tmkdefevent_usb = ftmkdefevent_usb; +hRead_DLL_EvD_usb Read_DLL_EvD_usb = fRead_DLL_EvD_usb; +htmksetcwbits_usb tmksetcwbits_usb = ftmksetcwbits_usb; +htmkclrcwbits_usb tmkclrcwbits_usb = ftmkclrcwbits_usb; +htmkgetcwbits_usb tmkgetcwbits_usb = ftmkgetcwbits_usb; +htmkgetmode_usb tmkgetmode_usb = ftmkgetmode_usb; +htmkdefdac_usb tmkdefdac_usb = ftmkdefdac_usb; +htmkgetdac_usb tmkgetdac_usb = ftmkgetdac_usb; +hbcreset_usb bcreset_usb = fbcreset_usb; +hbcdefirqmode_usb bcdefirqmode_usb = fbcdefirqmode_usb; +hbcgetirqmode_usb bcgetirqmode_usb = fbcgetirqmode_usb; +hbcgetmaxbase_usb bcgetmaxbase_usb = fbcgetmaxbase_usb; +hbcdefbase_usb bcdefbase_usb = fbcdefbase_usb; +hbcgetbase_usb bcgetbase_usb = fbcgetbase_usb; +hbcputw_usb bcputw_usb = fbcputw_usb; +hbcgetw_usb bcgetw_usb = fbcgetw_usb; +hbcgetansw_usb bcgetansw_usb = fbcgetansw_usb; +hbcputblk_usb bcputblk_usb = fbcputblk_usb; +hbcgetblk_usb bcgetblk_usb = fbcgetblk_usb; +hbcdefbus_usb bcdefbus_usb = fbcdefbus_usb; +hbcgetbus_usb bcgetbus_usb = fbcgetbus_usb; +hbcstart_usb bcstart_usb = fbcstart_usb; +hbcstartx_usb bcstartx_usb = fbcstartx_usb; +hbcdeflink_usb bcdeflink_usb = fbcdeflink_usb; +hbcgetlink_usb bcgetlink_usb = fbcgetlink_usb; +hbcstop_usb bcstop_usb = fbcstop_usb; +hbcgetstate_usb bcgetstate_usb = fbcgetstate_usb; +hrtreset_usb rtreset_usb = frtreset_usb; +hrtdefirqmode_usb rtdefirqmode_usb = frtdefirqmode_usb; +hrtgetirqmode_usb rtgetirqmode_usb = frtgetirqmode_usb; +hrtdefmode_usb rtdefmode_usb = frtdefmode_usb; +hrtgetmode_usb rtgetmode_usb = frtgetmode_usb; +hrtgetmaxpage_usb rtgetmaxpage_usb = frtgetmaxpage_usb; +hrtdefpage_usb rtdefpage_usb = frtdefpage_usb; +hrtgetpage_usb rtgetpage_usb = frtgetpage_usb; +hrtdefpagepc_usb rtdefpagepc_usb = frtdefpagepc_usb; +hrtdefpagebus_usb rtdefpagebus_usb = frtdefpagebus_usb; +hrtgetpagepc_usb rtgetpagepc_usb = frtgetpagepc_usb; +hrtgetpagebus_usb rtgetpagebus_usb = frtgetpagebus_usb; +hrtdefaddress_usb rtdefaddress_usb = frtdefaddress_usb; +hrtgetaddress_usb rtgetaddress_usb = frtgetaddress_usb; +hrtdefsubaddr_usb rtdefsubaddr_usb = frtdefsubaddr_usb; +hrtgetsubaddr_usb rtgetsubaddr_usb = frtgetsubaddr_usb; +hrtputw_usb rtputw_usb = frtputw_usb; +hrtgetw_usb rtgetw_usb = frtgetw_usb; +hrtputblk_usb rtputblk_usb = frtputblk_usb; +hrtgetblk_usb rtgetblk_usb = frtgetblk_usb; +hrtsetanswbits_usb rtsetanswbits_usb = frtsetanswbits_usb; +hrtclranswbits_usb rtclranswbits_usb = frtclranswbits_usb; +hrtgetanswbits_usb rtgetanswbits_usb = frtgetanswbits_usb; +hrtgetflags_usb rtgetflags_usb = frtgetflags_usb; +hrtputflags_usb rtputflags_usb = frtputflags_usb; +hrtsetflag_usb rtsetflag_usb = frtsetflag_usb; +hrtclrflag_usb rtclrflag_usb = frtclrflag_usb; +hrtgetflag_usb rtgetflag_usb = frtgetflag_usb; +hrtputflag_usb rtputflag_usb = frtputflag_usb; +hrtgetstate_usb rtgetstate_usb = frtgetstate_usb; +hrtbusy_usb rtbusy_usb = frtbusy_usb; +hrtlock_usb rtlock_usb = frtlock_usb; +hrtunlock_usb rtunlock_usb = frtunlock_usb; +hrtgetcmddata_usb rtgetcmddata_usb = frtgetcmddata_usb; +hrtputcmddata_usb rtputcmddata_usb = frtputcmddata_usb; +hmtreset_usb mtreset_usb = fmtreset_usb; +hmtgetsw_usb mtgetsw_usb = fmtgetsw_usb; +hrtenable_usb rtenable_usb = frtenable_usb; +hmrtselected_usb mrtselected_usb = fmrtselected_usb; +hmrtgetstate_usb mrtgetstate_usb = fmrtgetstate_usb; +hmrtdefbrcsubaddr0_usb mrtdefbrcsubaddr0_usb = fmrtdefbrcsubaddr0_usb; +hmrtreset_usb mrtreset_usb = fmrtreset_usb; +htmktimer_usb tmktimer_usb = ftmktimer_usb; +htmkgettimer_usb tmkgettimer_usb = ftmkgettimer_usb; +htmkgettimerl_usb tmkgettimerl_usb = ftmkgettimerl_usb; +hbcgetmsgtime_usb bcgetmsgtime_usb = fbcgetmsgtime_usb; +hrtgetmsgtime_usb rtgetmsgtime_usb = frtgetmsgtime_usb; +htmkgethwver_usb tmkgethwver_usb = ftmkgethwver_usb; +htmkgetevtime_usb tmkgetevtime_usb = ftmkgetevtime_usb; +htmkswtimer_usb tmkswtimer_usb = ftmkswtimer_usb; +htmkgetswtimer_usb tmkgetswtimer_usb = ftmkgetswtimer_usb; +htmktimeout_usb tmktimeout_usb = ftmktimeout_usb; +hmrtdefbrcpage_usb mrtdefbrcpage_usb = fmrtdefbrcpage_usb; +hmrtgetbrcpage_usb mrtgetbrcpage_usb = fmrtgetbrcpage_usb; + +hMonitorHwStart_usb MonitorHwStart_usb = fMonitorHwStart_usb; +hMonitorHwGetMessage_usb MonitorHwGetMessage_usb = fMonitorHwGetMessage_usb; +hMonitorHwStop_usb MonitorHwStop_usb = fMonitorHwStop_usb; + +htmkrawio_usb tmkrawio_usb = ftmkrawio_usb; +hrtgap_usb rtgap_usb = frtgap_usb; +htmkreadsn_usb tmkreadsn_usb = ftmkreadsn_usb; diff --git a/declarations.h b/declarations.h new file mode 100644 index 0000000..68fe40a --- /dev/null +++ b/declarations.h @@ -0,0 +1,22 @@ +#ifndef DECLARATIONS_H +#define DECLARATIONS_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif // DECLARATIONS_H diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..f3af046 --- /dev/null +++ b/main.cpp @@ -0,0 +1,14 @@ +#include "mainwindow.h" +#include "testinfo.h" + +#include + +int main(int argc, char *argv[]) +{ + QApplication a(argc, argv); + //MainWindow w; + //w.show(); + + QTest::qExec(new testInfo, argc, argv); + return a.exec(); +} diff --git a/mainwindow.cpp b/mainwindow.cpp new file mode 100644 index 0000000..8b4a894 --- /dev/null +++ b/mainwindow.cpp @@ -0,0 +1,61 @@ +#include "mainwindow.h" + +#include +//#include "WDMTMKv2.cpp" + +int hTmk; + +MainWindow::MainWindow() +{ + init_mainwindowobj(); + init_connections(); +} + +void MainWindow::init_mainwindowobj() +{ + qDebug() << "Startyem"; + + Window = new QWidget; + + Button = new QPushButton("Start"); + Label = new QLabel("Test"); + + QVBoxLayout *layout = new QVBoxLayout(Window); + layout->addWidget(Label); + layout->addWidget(Button); + + Window->setLayout(layout); + setCentralWidget(Window); +} + +void MainWindow::init_connections() +{ + connect(Button, + SIGNAL(clicked()), + this, + SLOT(test_tmkopen())); +} + +void MainWindow::test_tmkopen() +{ + /*if(TmkOpen()) + Label->setText("TmkOpen() failed"); + else + Label->setText("TmkOpen() successful!"); + + qDebug() << tmkgetmaxn(); + qDebug() << mrtgetmaxn(); + + hTmk = 0; + if (tmkconfig(hTmk) != 0) + qDebug() << "tmkconfig() failed!"; + else + qDebug() << "tmkconfig() successful!"; + + TmkClose();*/ +} + +MainWindow::~MainWindow() +{ + qDebug() << "End"; +} diff --git a/mainwindow.h b/mainwindow.h new file mode 100644 index 0000000..b7632b0 --- /dev/null +++ b/mainwindow.h @@ -0,0 +1,24 @@ +#ifndef MAINWINDOW_H +#define MAINWINDOW_H + +#include "declarations.h" + +class MainWindow:public QMainWindow +{ + Q_OBJECT +public: + void init_mainwindowobj(); //the function of this class + explicit MainWindow(); //constructor + void init_connections(); + ~MainWindow(); //destructor + +public slots: + void test_tmkopen(); + +private: + QWidget *Window = new QWidget; + QLabel *Label; + QPushButton *Button; +}; + +#endif // MAINWINDOW_H diff --git a/stdafx.cpp b/stdafx.cpp new file mode 100644 index 0000000..f525293 --- /dev/null +++ b/stdafx.cpp @@ -0,0 +1,5 @@ +// stdafx.cpp : source file that includes just the standard includes +// bcrt.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" diff --git a/stdafx.h b/stdafx.h new file mode 100644 index 0000000..3f466dd --- /dev/null +++ b/stdafx.h @@ -0,0 +1,15 @@ +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#pragma once + +#ifndef _WIN64_WINNT // Allow use of features specific to Windows XP or later. +#define _WIN64_WINNT 0x0501 // Change this to the appropriate value to target other versions of Windows. +#endif + +#include +#include + +#include diff --git a/testinfo.cpp b/testinfo.cpp new file mode 100644 index 0000000..dae24da --- /dev/null +++ b/testinfo.cpp @@ -0,0 +1,303 @@ +#include +#include "testinfo.h" +#include "WDMTMKv2.cpp" +#include + +void testInfo::init() +{ + if (isFailed) + { + qDebug() << "Skip"; + QSKIP(""); + } +} + +void testInfo::cleanup() +{ + bool a = QTest::currentTestFailed(); + if (a) + isFailed = a; +} + +void testInfo::cleanupTestCase() +{ + qDebug() << "TmkClose()"; + TmkClose(); +} + +void testInfo::testTmkOpen() +{ + DWORD a; + + a = TmkOpen(); + QCOMPARE(a, DWORD(0)); +} + +void testInfo::testtmkgetmaxn() +{ + QCOMPARE(tmkgetmaxn(), (int)(0)); +} + +void testInfo::testmrtgetmaxn() +{ + QCOMPARE(tmkgetmaxn(), (int)(0)); +} + +void testInfo::testtmkconfig() +{ + int hTmk = 0; + + QCOMPARE(tmkconfig(hTmk), (int)(0)); +} + +void testInfo::testtmkselect() +{ + int hTmk = 0; + + QCOMPARE(tmkselect(hTmk), (int)(0)); +} + +void testInfo::testtmkgetinfo() +{ + TTmkConfigData tmkCfg; + int hTmk = 0; + + tmkgetinfo(&tmkCfg); + QCOMPARE(hTmk, (int)(0)); //Device Number + QCOMPARE(tmkCfg.nType, (short)(9)); //Device Type + QCOMPARE(tmkCfg.szName, "TA1USB"); //Device Name + QCOMPARE(tmkCfg.wPorts1, (unsigned short)(0)); //Device I/O Ports + + if (tmkCfg.wPorts2 == (unsigned short)(0xFFFF)) //Device I/O Ports + ; + else + QCOMPARE(tmkCfg.wPorts2, (unsigned short)(0)); + + if (tmkCfg.wIrq2 == (unsigned short)(0xFF)) + QCOMPARE(tmkCfg.wIrq1, (unsigned short)(0)); //Device Interrupt + else + { + QCOMPARE(tmkCfg.wIrq1, (unsigned short)(0)); //Device Interrupts + QCOMPARE(tmkCfg.wIrq2, (unsigned short)(0)); + } + + QCOMPARE(tmkCfg.wIODelay, (unsigned short)(0)); //Device I/O Delay +} + +void testInfo::testtmkgethwver() +{ + QCOMPARE(tmkgethwver(), (unsigned short)(11)); +} + +void testInfo::testbcreset() +{ + QCOMPARE(bcreset(), (int)(0)); +} + +void testInfo::testbcgetmaxbase() +{ + QCOMPARE(bcgetmaxbase(), (unsigned short)(1023)); +} + +void testInfo::testbcputgetw() +{ + int fError; + unsigned short wBase, wAddr; + unsigned short wMaxBase = bcgetmaxbase(); + + for (wBase = 0; wBase <= wMaxBase; ++wBase) + { + bcdefbase(wBase); + for (wAddr = 0; wAddr <= 63; ++wAddr) + { + bcputw(wAddr, wAddr|(wBase<<6)); + } + } + + fError = 0; + for (wBase = 0; wBase <= wMaxBase; ++wBase) + { + bcdefbase(wBase); + for (wAddr = 0; wAddr <= 63; ++wAddr) + { + if (bcgetw(wAddr) != (unsigned short)(wAddr|(wBase<<6))) + fError = 1; + } + } + + QCOMPARE(fError, (int)(0)); +} + +void testInfo::testbcputgetblk() +{ + int fError; + unsigned short awBuf[64]; + unsigned short wBase, wAddr; + unsigned short wMaxBase = bcgetmaxbase(); + + for (wBase = 0; wBase <= wMaxBase; ++wBase) + { + bcdefbase(wBase); + for (wAddr = 0; wAddr <= 63; ++wAddr) + { + awBuf[63-wAddr] = wBase+(wAddr<<8); + } + bcputblk(0, awBuf, 64); + } + + fError = 0; + for (wBase = 0; wBase <= wMaxBase; ++wBase) + { + bcdefbase(wBase); + bcgetblk(0, awBuf, 64); + for (wAddr = 0; wAddr <= 63; ++wAddr) + { + if (awBuf[63-wAddr] != (wBase+(wAddr<<8))) + fError = 1; + } + } + + QCOMPARE(fError, (int)(0)); +} + +void testInfo::testrtreset() +{ + QCOMPARE(rtreset(), (int)(0)); +} + +void testInfo::testrtgetmaxpage() +{ + QCOMPARE(rtgetmaxpage(), (unsigned short)(0)); +} + +void testInfo::testrtputgetw() +{ + int fError; + unsigned short wPage, wAddr, wSubAddr; + unsigned short wMaxPage = rtgetmaxpage(); + + for (wPage = 0; wPage <= wMaxPage; ++wPage) + { + rtdefpage(wPage); + for (wSubAddr = 0; wSubAddr <= 0x1F; ++wSubAddr) + { + rtdefsubaddr(RT_RECEIVE, wSubAddr); + for (wAddr = 0; wAddr <= 31; ++wAddr) + rtputw(wAddr, wAddr|(wSubAddr<<8)|(wPage<<13)); + rtdefsubaddr(RT_TRANSMIT, wSubAddr); + for (wAddr = 0; wAddr <= 31; ++wAddr) + rtputw(wAddr, (wAddr+32)|(wSubAddr<<8)|(wPage<<13)); + } + } + + fError = 0; + for (wPage = 0; wPage <= wMaxPage; ++wPage) + { + rtdefpage(wPage); + for (wSubAddr = 0; wSubAddr <= 0x1F; ++wSubAddr) + { + rtdefsubaddr(RT_RECEIVE, wSubAddr); + for (wAddr = 0; wAddr <= 31; ++wAddr) + { + if (rtgetw(wAddr) != (wAddr|(wSubAddr<<8)|(wPage<<13))) + fError = 1; + } + rtdefsubaddr(RT_TRANSMIT, wSubAddr); + for (wAddr = 0; wAddr <= 31; ++wAddr) + { + if (rtgetw(wAddr) != ((wAddr+32)|(wSubAddr<<8)|(wPage<<13))) + fError = 1; + } + } + } + + QCOMPARE(fError, (int)(0)); +} + +void testInfo::testrtputgetblk() +{ + int fError; + unsigned short awBuf[64]; + unsigned short wPage, wAddr, wSubAddr; + unsigned short wMaxPage = rtgetmaxpage(); + + for (wPage = 0; wPage <= wMaxPage; ++wPage) + { + rtdefpage(wPage); + for (wSubAddr = 0; wSubAddr <= 0x1F; ++wSubAddr) + { + rtdefsubaddr(RT_RECEIVE, wSubAddr); + for (wAddr = 0; wAddr <= 31; ++wAddr) + awBuf[31-wAddr] = wSubAddr|(wAddr<<8)|(wPage<<13); + rtputblk(0, awBuf, 32); + rtdefsubaddr(RT_TRANSMIT, wSubAddr); + for (wAddr = 0; wAddr <= 31; ++wAddr) + awBuf[31-wAddr] = (wSubAddr+32)|(wAddr<<8)|(wPage<<13); + rtputblk(0, awBuf, 32); + } + } + + fError = 0; + for (wPage = 0; wPage <= wMaxPage; ++wPage) + { + rtdefpage(wPage); + for (wSubAddr = 0; wSubAddr <= 0x1F; ++wSubAddr) + { + rtdefsubaddr(RT_RECEIVE, wSubAddr); + rtgetblk(0, awBuf, 32); + for (wAddr = 0; wAddr <= 31; ++wAddr) + { + if (awBuf[31-wAddr] != (wSubAddr|(wAddr<<8)|(wPage<<13))) + fError = 1; + } + rtdefsubaddr(RT_TRANSMIT, wSubAddr); + rtgetblk(0, awBuf, 32); + for (wAddr = 0; wAddr <= 31; ++wAddr) + { + if (awBuf[31-wAddr] != ((wSubAddr+32)|(wAddr<<8)|(wPage<<13))) + fError = 1; + } + } + } + + QCOMPARE(fError, (int)(0)); +} + +void testInfo::testgetInt() +{ + HANDLE hEvent; + TTmkEventData tmkEvD; + + hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); + QVERIFY(hEvent); + tmkdefevent(hEvent, TRUE); + tmkgetevd(&tmkEvD); + QCOMPARE(tmkEvD.nInt, (int)(0)); + bcdefbase(0); + bcputw(0, 0xFFE1); + bcstart(0, CTRL_C_BRCST); + + switch (WaitForSingleObject(hEvent, 1000)) + { + case WAIT_OBJECT_0: + ResetEvent(hEvent); + qDebug() << "We got interrupt!"; + break; + + case WAIT_TIMEOUT: + qDebug() << "We didn't get interrupt!"; + break; + + default: + qDebug() << "Somebody abandon our interrupt waiting!"; + break; + } + + tmkgetevd(&tmkEvD); + QCOMPARE(tmkEvD.nInt, (int)(1)); + + tmkdefevent(0,TRUE); + CloseHandle(hEvent); +} + + diff --git a/testinfo.h b/testinfo.h new file mode 100644 index 0000000..8c019c4 --- /dev/null +++ b/testinfo.h @@ -0,0 +1,46 @@ +#ifndef TESTINFO_H +#define TESTINFO_H + +#include +#include + +class testInfo:public QObject +{ + Q_OBJECT + +private slots: + + void testTmkOpen(); + void testtmkgetmaxn(); + void testmrtgetmaxn(); + void testtmkconfig(); + void testtmkselect(); + void testtmkgetinfo(); + void testtmkgethwver(); + + //Now we'll test onboard RAM in Bus Controller mode + void testbcreset(); + void testbcgetmaxbase(); + void testbcputgetw(); + void testbcputgetblk(); + + //Now we'll test onboard RAM in Remote Terminal mode + void testrtreset(); + void testrtgetmaxpage(); + void testrtputgetw(); + void testrtputgetblk(); + + + //Now we'll test interrupt in Bus Controller mode + void testgetInt(); + + void init(); + void cleanup(); + void cleanupTestCase(); + +protected: + + bool isFailed = false; +}; + +#endif // TESTINFO_H