From 6248473234a212f4c5cad01b91d8b0ca70e6b28f Mon Sep 17 00:00:00 2001 From: Frank Voorburg Date: Tue, 9 Apr 2019 19:02:40 +0000 Subject: [PATCH] Refs #788. Added support for Vector CAN devices (XL driver) to the host tools. git-svn-id: https://svn.code.sf.net/p/openblt/code/trunk@673 5dc33758-31d5-4daf-9ae8-b24bf3d40d73 --- Host/BootCommander.exe | Bin 57344 -> 57344 bytes Host/MicroBoot.exe | Bin 1940992 -> 1940992 bytes Host/Source/BootCommander/main.c | 1 + Host/Source/LibOpenBLT/candriver.c | 5 + .../port/windows/canif/vector/vxlapi.h | 6008 +++++++++++++++++ .../port/windows/canif/vector/xlLoadlib.c | 554 ++ .../port/windows/canif/vector/xldriver.c | 862 +++ .../port/windows/canif/vector/xldriver.h | 50 + Host/Source/MicroBoot/MicroBoot.lps | 14 +- .../MicroBoot/transportxcpcandialog.lfm | 51 +- .../MicroBoot/transportxcpcandialog.pas | 8 +- Host/libopenblt.dll | Bin 165888 -> 193536 bytes 12 files changed, 7520 insertions(+), 33 deletions(-) create mode 100644 Host/Source/LibOpenBLT/port/windows/canif/vector/vxlapi.h create mode 100644 Host/Source/LibOpenBLT/port/windows/canif/vector/xlLoadlib.c create mode 100644 Host/Source/LibOpenBLT/port/windows/canif/vector/xldriver.c create mode 100644 Host/Source/LibOpenBLT/port/windows/canif/vector/xldriver.h diff --git a/Host/BootCommander.exe b/Host/BootCommander.exe index 0aab0404444bab97572b087ccaa90e19b8c7255e..06255332fc912f70a2c1c0bc4334b29db997701a 100644 GIT binary patch delta 10015 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 NyAp5Sl5JJX{})}|nX&)? diff --git a/Host/MicroBoot.exe b/Host/MicroBoot.exe index 8f361a614af9eb0e1014f62f3a90714b5fe72a6a..d2ce5cedb3cc1be84ba304baacc66a99738cc858 100644 GIT binary patch delta 3132 zcmZuz3sh9c8J>HW1r>0S$MEpp6%p|TY83GuIKoDcif%0|RyQc}5D;`F3mQ>bSy0z? zPq7OQRTHEkCt{n3(Ygyh>QP&&R@-3_LQ+nOk(1kh_94pYJ?CTQpZVvT z|Ns7(SqxXo3|Go(PWiVKVWe+Ds8)lJ?pSj+?{}4aSBmFYlei?V#d?5S%f(v1;2L1u zSi&DF;W=9g&kt&S<1cDa8;20O98XF&@w>PdTkj@5lIJH#M6rdR!j;+PZ{fe3zks%C zQ7iblyst4+I(`dm({jN{K-FIcA#+BwdAUGyS$DbcDMv4pWheMlu9(!E;0uB-+zmoK z0mh%WQeShjU``*R#}4_OLGS+(`WY+kZ)P81nKft68@brUCYI5mqoE^5sJ(4u4t@eTzQEQw- zs=i)2p1hHX!%0{s_6uoY<5{lpaI-NVh}&egg_$^r|5*pjIfbFo)A}THdY9R_8|G=u ztRE$ds!Q!*4>PGcZ>u_(gqHLU`|z^fsqSTZw(Q%Pc_1{QB7FK#cWMRHTHe}%$nad|Qq@E3~Sj|=z zu{lusRSmSpLB2G^6_xS2JLhob9sB>iWu-yG-cBWYl(yezVS%f-`r~uSxUUQ87g|)E zRB^XkDnzdIE$Lmf0cOpqU2TI97MpKSIwUi+x5q)kR#qL;vS723rOn)RuaVvO+(qV@ zT{nVk9gxWx+a8jhjZ^s{fiz{~#Kg~vm~Nd^2J4xAFFHK>eFKtZZoG4oRp90KbJI=x zt^FCUQ%$dZPa<=0DF0z5S(t;PjHrfgs|FdZMK!1f z`TV;kWgz?gHut@xxV%ql)9utCQ#ajH2$U}~NH;x|bW7;d^W+z~IE!0GF6ZKKzWqJ& z*IYayY?vW+4=^k)aWb4QApUuHvT{*`LvrtHXV>47-fl^KO#itR625CB>O349IS9$Q zPWGRo`asNQYKv+>t;tVB3RH;f@#It<4(Bq+r93<#`t}`0*blWtRbT5P3%x9=es!T2 z_$|1mMQW*ZfX0*Od3e&86&~A%#B9Zreb;;J`{&4%tvGsak!PU!TsOOkUKh9?{sN*A zPz?}?uDioZJ49DP>$)1V$;Vsq?5wqU5dES`SGf|wMQu)A;ktId&Kx`J!#ORR2&Ygr z1pIRQ<9|Si`8+}f`r;F|r=s>IJ&@0~8=|f4o^2Y)oB8-&=&-VD%Rt$pQm3+3GQ9ww z^?aDsM zU6FcA>P1?g4a<$>L?IR`5`K6lwSf~Hm45ml1SX#3I-C+@*dO<2Aesy1gSR5Zq^fms z)afKivZNlSiy2K!g-e>TW>u|O%_>B#jOBedi=5tK^*;xHdgRm&Y8v85%r8FN}SE1IBUv9(KeEyyV-hbXl z(u#0YKuoYhGL*+7eV{oxjoM$3gGG2Mmr2eQ;pmtL5I4KV<8FB<{tG*~?*Lq0b8-@W znogb<;qlyI5>kwpaI46=V!Y71aWm|3lpHI@p=$ zx8pilTUIam;(=^DG3>zFxJWbjuBrpV$+W7*A+Z;Uqi2u8K(I6q)o2j)KhBOY{9@?I zXdRAYKjAuDz+EcA)Z6EAxds{HlAQk?*e1S<6HisFzpQ0ay!@)b*17Q)FFCS9zsZeI zwaLF9`VZaM^6S+o`id3>xM6EuiL}s9apOUjU491od)=7!WQM{E-jzPQ)z}&z3B?>~c_h?a z`b4;rSm85fc<105N_0;)Y(JZ+MD?%ORdbXm?5KNDXkRe zathL1DXt3g4$wHyPvrX5ktxmtgvd7qVgykb#bmO-PV^?T>cml`Z<{!V6dJ|FE{fk7 z#d4sSS|v6yr?K2D@^zK?mTPiqwfGiH?x+^2lVNn3Jfk2-pU=-Bc?ZSi$1_E_uk18( z4=y5C4~kozD{V6li7{M&LYB5eC%fixSVOW7iz{6YpB@&YJP!ZzIIJK~OyX)Th`ez` S%;H*!^@zB`=4BS21^y4qE#{8^ delta 2988 zcmZ8j3s6)?7VY<700o?pPxE^Z5Fz3RS54xtaG}8Q6J;}5VbC~HK;#!uL;Qr8&?A#5~Jw}|43ySlMbB%8IGL6DSeinzqL_stAJc~yt*)Aw?2 z-+Q|o3~i-`w$i%8zM3tRl$;`@K}(40z2;5)NE`g5r}OF)xkOG={|@&mr>eij9mREH zF~6sn=d8s%Kdkc(zMvzm93kYhV9;;m%Q%g-eP8(r!_xK#*5pD=~gaYA#@I-haCLksvyb(SKU&JJY5}`s&M))E85dl`8 zLxII#a_La<1`Uj=Z*nKZyv)axJWj5x?$<#Z3`bqECAu|s1dVgnT#tyGmM+Pe+to~V4;3~rY_lsoQ z)lEtkS=3#u@J6pxK%6_bq;<1jpZp@3Q@UI4V<6f7Yq(u9;~3+IDLU$7N(wL=cjwYH2CYe6xEtaca9Z=xyu>mu;kG(nh-smj4Jzv*?9WF3yqk|b;erH%&r zT-lxOJYFpPF&MIG5UA7st$RrRneYf%qt zuv)&|Q`3p9t<`lwSZVoy)T-L9C8l2XuL6|3ep&X$FU|BHsVJVQ&%ve5G?P04VL3E} zk39nOb7(~Hn8GJ-p~AOLg~&&lC0*HUn$K z&Rv%qIl|81=xk&i_~y|$nP+ow^9L)P-AX_gjX8ORN!@i--RbQ}vC}q|(upZ}=F}so zudwy}fIH0N2{EwsXXTj6hRf`GEQK5<9(H1bi%&Ml^>Flr6zTQQ=_p+ zk|ayYUUo>9si|<5W|CRmVAjYDVvhrH{pn_>ih@PU?N{QDJ_QR#G2^a5QnJLX9y07y z6KH&s3cnxA{xv;jzo5*K{a@s?kD-n%diN{2K@VA%V`S_aj?PAX3Xk5T?Vbr)=sjaM zT-ZXRR5by1$x!|hDe*HWr?TJ?c(8@Wa_yijq|q-dLS6YC+kRzKA{~RcuD}}8Wpi>O zQ)^*eAr0dg=nH8)_c5F+q>DVbOpNgmek!Cve@MM7-`7q{S{E}t>X)A!3%){fCE4{p z>-AZTAKIMlc zTW=aR2Ug+bWsNdjEz<^>*2r{;Oi#(Q3?6KyF;QHY<6Somv*l=Kf5e)|nbv+e8mS24 zw$Vnn(5!yAb? zzlg?h|FA+4&F7$w56ZY$OqqwLpfOkzkOfezVWs``z4lZ;nkL)4?QA_wWMPQe0@R)_m9RxJo^p)RR>2u z30h@MIw@>-=Q`oSM}nGD!IO`KDHD27QG?!*5Pe#R;*XWViqpa_E)l*yEi`cfu(4T~ z&1qnNvk>Q|`9jxtD=ZLhHw#O-Hf!)1fpG^)so>U9uC*TjPAKG{U~8^juseo&xKBaS}Hd`m4lc zPUGTgaTyxlsTP^%WVh69MSLl=??<_VHDU~Gs}L35ZpVlsJwLl7k57P`HDWF&S{LjQ zXK^ZrzgzpLH5GR36<r@NE3W6R!H2ctHmjdm9Pq8`Q> diff --git a/Host/Source/BootCommander/main.c b/Host/Source/BootCommander/main.c index 93b4e74c..845decd8 100644 --- a/Host/Source/BootCommander/main.c +++ b/Host/Source/BootCommander/main.c @@ -531,6 +531,7 @@ static void DisplayProgramUsage(void) printf(" peak_pcanusb -> Peak System PCAN-USB.\n"); printf(" kvaser_leaflight -> Kvaser Leaf Light V2.\n"); printf(" lawicel_canusb -> Lawicel CANUSB.\n"); + printf(" vector_xldriver -> Vector XL Driver.\n"); printf(" -c=[value] Zero based index of the CAN channel if multiple CAN\n"); printf(" channels are supported for the CAN adapter, as a 32-\n"); printf(" bit value (Default = 0).\n"); diff --git a/Host/Source/LibOpenBLT/candriver.c b/Host/Source/LibOpenBLT/candriver.c index 324c8354..7339c020 100644 --- a/Host/Source/LibOpenBLT/candriver.c +++ b/Host/Source/LibOpenBLT/candriver.c @@ -39,6 +39,7 @@ #include "pcanusb.h" /* Peak PCAN-USB interface */ #include "leaflight.h" /* Kvaser Leaf Light v2 interface */ #include "canusb.h" /* Lawicel CANUSB interface */ +#include "xldriver.h" /* Vector XL driver interface */ #endif #if defined(PLATFORM_LINUX) #include "socketcan.h" /* SocketCAN interface */ @@ -94,6 +95,10 @@ void CanInit(tCanSettings const * settings) { canIfPtr = CanUsbGetInterface(); } + else if (strcmp(settings->devicename, "vector_xldriver") == 0) + { + canIfPtr = VectorXlGetInterface(); + } #endif #if defined(PLATFORM_LINUX) /* On Linux, the device name is the name of the SocketCAN link, so always link diff --git a/Host/Source/LibOpenBLT/port/windows/canif/vector/vxlapi.h b/Host/Source/LibOpenBLT/port/windows/canif/vector/vxlapi.h new file mode 100644 index 00000000..2fb1b824 --- /dev/null +++ b/Host/Source/LibOpenBLT/port/windows/canif/vector/vxlapi.h @@ -0,0 +1,6008 @@ +/*---------------------------------------------------------------------------- +| File: +| vxlapi.h +| Project: +| Multi Bus driver for Windows 7 / Windows 8 / Windows 10 +| +| Description: +| Driver Interface Prototypes - customer version +| +|----------------------------------------------------------------------------- +| $Author: visstz $ $Date: 2016-06-13 15:31:06 +0200 (Mo, 13 Jun 2016) $ $Revision: 58894 $ +| $Id: vxlpubbase.h 58894 2016-06-13 13:31:06Z visstz $ +|----------------------------------------------------------------------------- +| Copyright (c) 2016 by Vector Informatik GmbH. All rights reserved. + ----------------------------------------------------------------------------*/ + + +#ifndef _V_XLAPI_H_ +#define _V_XLAPI_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#define DYNAMIC_XLDRIVER_DLL + +#define _XL_EXPORT_API __stdcall +#define _EXPORT_API __stdcall + #if defined (DYNAMIC_CANDRIVER_DLL) || defined (DYNAMIC_XLDRIVER_DLL) + #define _XL_EXPORT_DECL _XL_EXPORT_API + #define _XL_EXPORT_DEF _XL_EXPORT_API + #else + // not used for dynamic load of dll + #define _XL_EXPORT_DECL __declspec(dllimport) _XL_EXPORT_API + #define _XL_EXPORT_DEF __declspec(dllimport) _XL_EXPORT_API + #endif + + + +// Functions have the following parameters +#define DEFPARAMS XLportHandle portHandle, XLaccess accessMask, XLuserHandle userHandle +// Almost all xlFr... Functions have the following parameters +#define DEFFRPARAM XLportHandle portHandle, XLaccess accessMask + +// Marcos for interface definition and implementation +#ifdef DYNAMIC_XLDRIVER_DLL + + #ifdef DO_NOT_DEFINE_EXTERN_DECLARATION + + // All DECL_STDXL_FUNC have return type XLstatus + #define DECL_STDXL_FUNC(apiname, apitype, args) \ + typedef XLstatus (_XL_EXPORT_API *apitype) args + + #else // DO_NOT_DEFINE_EXTERN_DECLARATION + + #define DECL_STDXL_FUNC(apiname, apitype, args) \ + typedef XLstatus (_XL_EXPORT_API *apitype) args; \ + extern apitype apiname + + #endif // DO_NOT_DEFINE_EXTERN_DECLARATION + +#else // DYNAMIC_XLDRIVER_DLL + + // All DECL_STDXL_FUNC have return type XLstatus + #define DECL_STDXL_FUNC(apiname, apitype, args) \ + XLstatus _XL_EXPORT_DECL apiname args + #define IMPL_STDXL_FUNC(apiname, args) \ + XLstatus _XL_EXPORT_DEF apiname args + +#endif // DYNAMIC_XLDRIVER_DLL + + +// Bus types +#define XL_BUS_TYPE_NONE 0x00000000 +#define XL_BUS_TYPE_CAN 0x00000001 +#define XL_BUS_TYPE_LIN 0x00000002 +#define XL_BUS_TYPE_FLEXRAY 0x00000004 +#define XL_BUS_TYPE_AFDX 0x00000008 // former BUS_TYPE_BEAN +#define XL_BUS_TYPE_MOST 0x00000010 +#define XL_BUS_TYPE_DAIO 0x00000040 // IO cab/piggy +#define XL_BUS_TYPE_J1708 0x00000100 +#define XL_BUS_TYPE_ETHERNET 0x00001000 +#define XL_BUS_TYPE_A429 0x00002000 + +//------------------------------------------------------------------------------ +// Transceiver types +//------------------------------------------------------------------------------ +// CAN Cab +#define XL_TRANSCEIVER_TYPE_NONE 0x0000 +#define XL_TRANSCEIVER_TYPE_CAN_251 0x0001 +#define XL_TRANSCEIVER_TYPE_CAN_252 0x0002 +#define XL_TRANSCEIVER_TYPE_CAN_DNOPTO 0x0003 +#define XL_TRANSCEIVER_TYPE_CAN_SWC_PROTO 0x0005 //!< Prototype. Driver may latch-up. +#define XL_TRANSCEIVER_TYPE_CAN_SWC 0x0006 +#define XL_TRANSCEIVER_TYPE_CAN_EVA 0x0007 +#define XL_TRANSCEIVER_TYPE_CAN_FIBER 0x0008 +#define XL_TRANSCEIVER_TYPE_CAN_1054_OPTO 0x000B //!< 1054 with optical isolation +#define XL_TRANSCEIVER_TYPE_CAN_SWC_OPTO 0x000C //!< SWC with optical isolation +#define XL_TRANSCEIVER_TYPE_CAN_B10011S 0x000D //!< B10011S truck-and-trailer +#define XL_TRANSCEIVER_TYPE_CAN_1050 0x000E //!< 1050 +#define XL_TRANSCEIVER_TYPE_CAN_1050_OPTO 0x000F //!< 1050 with optical isolation +#define XL_TRANSCEIVER_TYPE_CAN_1041 0x0010 //!< 1041 +#define XL_TRANSCEIVER_TYPE_CAN_1041_OPTO 0x0011 //!< 1041 with optical isolation +#define XL_TRANSCEIVER_TYPE_CAN_VIRTUAL 0x0016 //!< Virtual CAN Trasceiver for Virtual CAN Bus Driver +#define XL_TRANSCEIVER_TYPE_LIN_6258_OPTO 0x0017 //!< Vector LINcab 6258opto with transceiver Infineon TLE6258 +#define XL_TRANSCEIVER_TYPE_LIN_6259_OPTO 0x0019 //!< Vector LINcab 6259opto with transceiver Infineon TLE6259 +#define XL_TRANSCEIVER_TYPE_DAIO_8444_OPTO 0x001D //!< Vector IOcab 8444 (8 dig.Inp.; 4 dig.Outp.; 4 ana.Inp.; 4 ana.Outp.) +#define XL_TRANSCEIVER_TYPE_CAN_1041A_OPTO 0x0021 //!< 1041A with optical isolation +#define XL_TRANSCEIVER_TYPE_LIN_6259_MAG 0x0023 //!< LIN transceiver 6259, with transceiver Infineon TLE6259, magnetically isolated, stress functionality +#define XL_TRANSCEIVER_TYPE_LIN_7259_MAG 0x0025 //!< LIN transceiver 7259, with transceiver Infineon TLE7259, magnetically isolated, stress functionality +#define XL_TRANSCEIVER_TYPE_LIN_7269_MAG 0x0027 //!< LIN transceiver 7269, with transceiver Infineon TLE7269, magnetically isolated, stress functionality +#define XL_TRANSCEIVER_TYPE_CAN_1054_MAG 0x0033 //!< TJA1054, magnetically isolated, with selectable termination resistor (via 4th IO line) +#define XL_TRANSCEIVER_TYPE_CAN_251_MAG 0x0035 //!< 82C250/251 or equivalent, magnetically isolated +#define XL_TRANSCEIVER_TYPE_CAN_1050_MAG 0x0037 //!< TJA1050, magnetically isolated +#define XL_TRANSCEIVER_TYPE_CAN_1040_MAG 0x0039 //!< TJA1040, magnetically isolated +#define XL_TRANSCEIVER_TYPE_CAN_1041A_MAG 0x003B //!< TJA1041A, magnetically isolated +#define XL_TRANSCEIVER_TYPE_TWIN_CAN_1041A_MAG 0x0080 //!< TWINcab with two TJA1041, magnetically isolated +#define XL_TRANSCEIVER_TYPE_TWIN_LIN_7269_MAG 0x0081 //!< TWINcab with two 7259, Infineon TLE7259, magnetically isolated, stress functionality +#define XL_TRANSCEIVER_TYPE_TWIN_CAN_1041AV2_MAG 0x0082 //!< TWINcab with two TJA1041, magnetically isolated +#define XL_TRANSCEIVER_TYPE_TWIN_CAN_1054_1041A_MAG 0x0083 //!< TWINcab with TJA1054A and TJA1041A with magnetic isolation + +// CAN PiggyBack +#define XL_TRANSCEIVER_TYPE_PB_CAN_251 0x0101 +#define XL_TRANSCEIVER_TYPE_PB_CAN_1054 0x0103 +#define XL_TRANSCEIVER_TYPE_PB_CAN_251_OPTO 0x0105 +#define XL_TRANSCEIVER_TYPE_PB_CAN_SWC 0x010B +// 0x010D not supported, 0x010F, 0x0111, 0x0113 reserved for future use!! +#define XL_TRANSCEIVER_TYPE_PB_CAN_1054_OPTO 0x0115 +#define XL_TRANSCEIVER_TYPE_PB_CAN_SWC_OPTO 0x0117 +#define XL_TRANSCEIVER_TYPE_PB_CAN_TT_OPTO 0x0119 +#define XL_TRANSCEIVER_TYPE_PB_CAN_1050 0x011B +#define XL_TRANSCEIVER_TYPE_PB_CAN_1050_OPTO 0x011D +#define XL_TRANSCEIVER_TYPE_PB_CAN_1041 0x011F +#define XL_TRANSCEIVER_TYPE_PB_CAN_1041_OPTO 0x0121 +#define XL_TRANSCEIVER_TYPE_PB_LIN_6258_OPTO 0x0129 //!< LIN piggy back with transceiver Infineon TLE6258 +#define XL_TRANSCEIVER_TYPE_PB_LIN_6259_OPTO 0x012B //!< LIN piggy back with transceiver Infineon TLE6259 +#define XL_TRANSCEIVER_TYPE_PB_LIN_6259_MAG 0x012D //!< LIN piggy back with transceiver Infineon TLE6259, magnetically isolated, stress functionality +#define XL_TRANSCEIVER_TYPE_PB_CAN_1041A_OPTO 0x012F //!< CAN transceiver 1041A +#define XL_TRANSCEIVER_TYPE_PB_LIN_7259_MAG 0x0131 //!< LIN piggy back with transceiver Infineon TLE7259, magnetically isolated, stress functionality +#define XL_TRANSCEIVER_TYPE_PB_LIN_7269_MAG 0x0133 //!< LIN piggy back with transceiver Infineon TLE7269, magnetically isolated, stress functionality +#define XL_TRANSCEIVER_TYPE_PB_CAN_251_MAG 0x0135 //!< 82C250/251 or compatible, magnetically isolated +#define XL_TRANSCEIVER_TYPE_PB_CAN_1050_MAG 0x0136 //!< TJA 1050, magnetically isolated +#define XL_TRANSCEIVER_TYPE_PB_CAN_1040_MAG 0x0137 //!< TJA 1040, magnetically isolated +#define XL_TRANSCEIVER_TYPE_PB_CAN_1041A_MAG 0x0138 //!< TJA 1041A, magnetically isolated +#define XL_TRANSCEIVER_TYPE_PB_DAIO_8444_OPTO 0x0139 //!< optically isolated IO piggy +#define XL_TRANSCEIVER_TYPE_PB_CAN_1054_MAG 0x013B //!< TJA1054, magnetically isolated, with selectable termination resistor (via 4th IO line) +#define XL_TRANSCEIVER_TYPE_CAN_1051_CAP_FIX 0x013C //!< TJA1051 - fixed transceiver on e.g. 16xx/8970 +#define XL_TRANSCEIVER_TYPE_DAIO_1021_FIX 0x013D //!< Onboard IO of VN1630/VN1640 +#define XL_TRANSCEIVER_TYPE_LIN_7269_CAP_FIX 0x013E //!< TLE7269 - fixed transceiver on 1611 +#define XL_TRANSCEIVER_TYPE_PB_CAN_1051_CAP 0x013F //!< TJA 1051, capacitive isolated +#define XL_TRANSCEIVER_TYPE_PB_CAN_SWC_7356_CAP 0x0140 //!< Single Wire NCV7356, capacitive isolated +#define XL_TRANSCEIVER_TYPE_PB_CAN_1055_CAP 0x0141 //!< TJA1055, capacitive isolated, with selectable termination resistor (via 4th IO line) +#define XL_TRANSCEIVER_TYPE_PB_CAN_1057_CAP 0x0142 //!< TJA 1057, capacitive isolated +#define XL_TRANSCEIVER_TYPE_A429_HOLT8596_FIX 0x0143 //!< Onboard HOLT 8596 TX transceiver on VN0601 +#define XL_TRANSCEIVER_TYPE_A429_HOLT8455_FIX 0x0144 //!< Onboard HOLT 8455 RX transceiver on VN0601 + + +// FlexRay PiggyBacks +#define XL_TRANSCEIVER_TYPE_PB_FR_1080 0x0201 //!< TJA 1080 +#define XL_TRANSCEIVER_TYPE_PB_FR_1080_MAG 0x0202 //!< TJA 1080 magnetically isolated piggy +#define XL_TRANSCEIVER_TYPE_PB_FR_1080A_MAG 0x0203 //!< TJA 1080A magnetically isolated piggy +#define XL_TRANSCEIVER_TYPE_PB_FR_1082_CAP 0x0204 //!< TJA 1082 capacitive isolated piggy +#define XL_TRANSCEIVER_TYPE_PB_FRC_1082_CAP 0x0205 //!< TJA 1082 capacitive isolated piggy with CANpiggy form factor +#define XL_TRANSCEIVER_TYPE_FR_1082_CAP_FIX 0x0206 //!< TJA 1082 capacitive isolated piggy fixed transceiver - e.g. 7610 + +#define XL_TRANSCEIVER_TYPE_MOST150_ONBOARD 0x0220 //!< Onboard MOST150 transceiver of VN2640 + +// Ethernet Phys +#define XL_TRANSCEIVER_TYPE_ETH_BCM54810_FIX 0x0230 //!< Onboard Broadcom Ethernet PHY on VN5610 and VX0312 +#define XL_TRANSCEIVER_TYPE_ETH_AR8031_FIX 0x0231 //!< Onboard Atheros Ethernet PHY +#define XL_TRANSCEIVER_TYPE_ETH_BCM89810_FIX 0x0232 //!< Onboard Broadcom Ethernet PHY +#define XL_TRANSCEIVER_TYPE_ETH_TJA1100_FIX 0x0233 //!< Onboard NXP Ethernet PHY +#define XL_TRANSCEIVER_TYPE_ETH_BCM54810_89811_FIX 0x0234 //!< Onboard Broadcom Ethernet PHYs (e.g. VN5610A - BCM54810: RJ45, BCM89811: DSUB) + +// IOpiggy 8642 +#define XL_TRANSCEIVER_TYPE_PB_DAIO_8642 0x0280 //!< Iopiggy for VN8900 +#define XL_TRANSCEIVER_TYPE_DAIO_AL_ONLY 0x028f //!< virtual piggy type for activation line only (e.g. VN8810ini) +#define XL_TRANSCEIVER_TYPE_DAIO_1021_FIX_WITH_AL 0x0290 //!< On board IO with Activation Line (e.g. VN5640) +#define XL_TRANSCEIVER_TYPE_DAIO_AL_WU 0x0291 //!< virtual piggy type for activation line and WakeUp Line only (e.g. VN5610A) + + +//------------------------------------------------------------------------------ +// Transceiver Operation Modes +//------------------------------------------------------------------------------ +#define XL_TRANSCEIVER_LINEMODE_NA ((unsigned int)0x0000) +#define XL_TRANSCEIVER_LINEMODE_TWO_LINE ((unsigned int)0x0001) +#define XL_TRANSCEIVER_LINEMODE_CAN_H ((unsigned int)0x0002) +#define XL_TRANSCEIVER_LINEMODE_CAN_L ((unsigned int)0x0003) +#define XL_TRANSCEIVER_LINEMODE_SWC_SLEEP ((unsigned int)0x0004) //!< SWC Sleep Mode. +#define XL_TRANSCEIVER_LINEMODE_SWC_NORMAL ((unsigned int)0x0005) //!< SWC Normal Mode. +#define XL_TRANSCEIVER_LINEMODE_SWC_FAST ((unsigned int)0x0006) //!< SWC High-Speed Mode. +#define XL_TRANSCEIVER_LINEMODE_SWC_WAKEUP ((unsigned int)0x0007) //!< SWC Wakeup Mode. +#define XL_TRANSCEIVER_LINEMODE_SLEEP ((unsigned int)0x0008) +#define XL_TRANSCEIVER_LINEMODE_NORMAL ((unsigned int)0x0009) +#define XL_TRANSCEIVER_LINEMODE_STDBY ((unsigned int)0x000a) //!< Standby for those who support it +#define XL_TRANSCEIVER_LINEMODE_TT_CAN_H ((unsigned int)0x000b) //!< truck & trailer: operating mode single wire using CAN high +#define XL_TRANSCEIVER_LINEMODE_TT_CAN_L ((unsigned int)0x000c) //!< truck & trailer: operating mode single wire using CAN low +#define XL_TRANSCEIVER_LINEMODE_EVA_00 ((unsigned int)0x000d) //!< CANcab Eva +#define XL_TRANSCEIVER_LINEMODE_EVA_01 ((unsigned int)0x000e) //!< CANcab Eva +#define XL_TRANSCEIVER_LINEMODE_EVA_10 ((unsigned int)0x000f) //!< CANcab Eva +#define XL_TRANSCEIVER_LINEMODE_EVA_11 ((unsigned int)0x0010) //!< CANcab Eva + +//------------------------------------------------------------------------------ +// Transceiver Status Flags +//------------------------------------------------------------------------------ +// (not all used, but for compatibility reasons) +#define XL_TRANSCEIVER_STATUS_PRESENT ((unsigned int)0x0001) +#define XL_TRANSCEIVER_STATUS_POWER_GOOD ((unsigned int)0x0010) +#define XL_TRANSCEIVER_STATUS_EXT_POWER_GOOD ((unsigned int)0x0020) +#define XL_TRANSCEIVER_STATUS_NOT_SUPPORTED ((unsigned int)0x0040) + + +//////////////////////////////////////////////////////////////////////////////// +// driver status +#define XL_SUCCESS 0 //=0x0000 +#define XL_PENDING 1 //=0x0001 + +#define XL_ERR_QUEUE_IS_EMPTY 10 //=0x000A +#define XL_ERR_QUEUE_IS_FULL 11 //=0x000B +#define XL_ERR_TX_NOT_POSSIBLE 12 //=0x000C +#define XL_ERR_NO_LICENSE 14 //=0x000E +#define XL_ERR_WRONG_PARAMETER 101 //=0x0065 +#define XL_ERR_TWICE_REGISTER 110 //=0x006E +#define XL_ERR_INVALID_CHAN_INDEX 111 //=0x006F +#define XL_ERR_INVALID_ACCESS 112 //=0x0070 +#define XL_ERR_PORT_IS_OFFLINE 113 //=0x0071 +#define XL_ERR_CHAN_IS_ONLINE 116 //=0x0074 +#define XL_ERR_NOT_IMPLEMENTED 117 //=0x0075 +#define XL_ERR_INVALID_PORT 118 //=0x0076 +#define XL_ERR_HW_NOT_READY 120 //=0x0078 +#define XL_ERR_CMD_TIMEOUT 121 //=0x0079 +#define XL_ERR_CMD_HANDLING 122 //=0x007A +#define XL_ERR_HW_NOT_PRESENT 129 //=0x0081 +#define XL_ERR_NOTIFY_ALREADY_ACTIVE 131 //=0x0083 +#define XL_ERR_INVALID_TAG 132 //=0x0084 +#define XL_ERR_INVALID_RESERVED_FLD 133 //=0x0085 +#define XL_ERR_INVALID_SIZE 134 //=0x0086 +#define XL_ERR_INSUFFICIENT_BUFFER 135 //=0x0087 +#define XL_ERR_ERROR_CRC 136 //=0x0088 +#define XL_ERR_BAD_EXE_FORMAT 137 //=0x0089 +#define XL_ERR_NO_SYSTEM_RESOURCES 138 //=0x008A +#define XL_ERR_NOT_FOUND 139 //=0x008B +#define XL_ERR_INVALID_ADDRESS 140 //=0x008C +#define XL_ERR_REQ_NOT_ACCEP 141 //=0x008D +#define XL_ERR_INVALID_LEVEL 142 //=0x008E +#define XL_ERR_NO_DATA_DETECTED 143 //=0x008F +#define XL_ERR_INTERNAL_ERROR 144 //=0x0090 +#define XL_ERR_UNEXP_NET_ERR 145 //=0x0091 +#define XL_ERR_INVALID_USER_BUFFER 146 //=0x0092 +#define XL_ERR_NO_RESOURCES 152 //=0x0098 +#define XL_ERR_WRONG_CHIP_TYPE 153 //=0x0099 +#define XL_ERR_WRONG_COMMAND 154 //=0x009A +#define XL_ERR_INVALID_HANDLE 155 //=0x009B +#define XL_ERR_RESERVED_NOT_ZERO 157 //=0x009D +#define XL_ERR_INIT_ACCESS_MISSING 158 //=0x009E +#define XL_ERR_CANNOT_OPEN_DRIVER 201 //=0x00C9 +#define XL_ERR_WRONG_BUS_TYPE 202 //=0x00CA +#define XL_ERR_DLL_NOT_FOUND 203 //=0x00CB +#define XL_ERR_INVALID_CHANNEL_MASK 204 //=0x00CC +#define XL_ERR_NOT_SUPPORTED 205 //=0x00CD +// special stream defines +#define XL_ERR_CONNECTION_BROKEN 210 //=0x00D2 +#define XL_ERR_CONNECTION_CLOSED 211 //=0x00D3 +#define XL_ERR_INVALID_STREAM_NAME 212 //=0x00D4 +#define XL_ERR_CONNECTION_FAILED 213 //=0x00D5 +#define XL_ERR_STREAM_NOT_FOUND 214 //=0x00D6 +#define XL_ERR_STREAM_NOT_CONNECTED 215 //=0x00D7 +#define XL_ERR_QUEUE_OVERRUN 216 //=0x00D8 +#define XL_ERROR 255 //=0x00FF + +#define XL_ERR_INVALID_DLC 0x0201 // DLC with invalid value +#define XL_ERR_INVALID_CANID 0x0202 // CAN Id has invalid bits set +#define XL_ERR_INVALID_FDFLAG_MODE20 0x0203 // flag set that must not be set when configured for CAN20 (e.g. EDL) +#define XL_ERR_EDL_RTR 0x0204 // RTR must not be set in combination with EDL +#define XL_ERR_EDL_NOT_SET 0x0205 // EDL is not set but BRS and/or ESICTRL is +#define XL_ERR_UNKNOWN_FLAG 0x0206 // unknown bit in flags field is set +/////////////////////////////////////////////////////////////////////////////// +// Ethernet API error code (range: 0x1100..0x11FF) +#define XL_ERR_ETH_PHY_ACTIVATION_FAILED 0x1100 +#define XL_ERR_ETH_MAC_RESET_FAILED 0x1101 +#define XL_ERR_ETH_MAC_NOT_READY 0x1102 +#define XL_ERR_ETH_PHY_CONFIG_ABORTED 0x1103 +#define XL_ERR_ETH_RESET_FAILED 0x1104 +#define XL_ERR_ETH_SET_CONFIG_DELAYED 0x1105 //Requested config was stored but could not be immediately activated +#define XL_ERR_ETH_UNSUPPORTED_FEATURE 0x1106 //Requested feature/function not supported by device +#define XL_ERR_ETH_MAC_ACTIVATION_FAILED 0x1107 +#define XL_ERR_ETH_FILTER_INVALID 0x1108 //Requested filter setting is invalid +#define XL_ERR_ETH_FILTER_UNAVAILABLE 0x1109 //Filtering is not available (not supported by hardware, in use by other application, ...) +#define XL_ERR_ETH_FILTER_NO_INIT_ACCESS 0x110A //Missing init access for one or more channels referenced by filter +#define XL_ERR_ETH_FILTER_TOO_COMPLEX 0x110B //Specified filter setting is too complex to be fully supported + + + +enum e_XLevent_type { + XL_NO_COMMAND = 0, + XL_RECEIVE_MSG = 1, + XL_CHIP_STATE = 4, + XL_TRANSCEIVER = 6, + XL_TIMER = 8, + XL_TRANSMIT_MSG = 10, + XL_SYNC_PULSE = 11, + XL_APPLICATION_NOTIFICATION = 15, + + + //for LIN we have special events + XL_LIN_MSG = 20, + XL_LIN_ERRMSG = 21, + XL_LIN_SYNCERR = 22, + XL_LIN_NOANS = 23, + XL_LIN_WAKEUP = 24, + XL_LIN_SLEEP = 25, + XL_LIN_CRCINFO = 26, + + // for D/A IO bus + XL_RECEIVE_DAIO_DATA = 32, //!< D/A IO data message + + XL_RECEIVE_DAIO_PIGGY = 34, //!< D/A IO Piggy data message +}; + + + + +// +// common event tags +// +#define XL_RECEIVE_MSG ((unsigned short)0x0001) +#define XL_CHIP_STATE ((unsigned short)0x0004) +#define XL_TRANSCEIVER_INFO ((unsigned short)0x0006) +#define XL_TRANSCEIVER (XL_TRANSCEIVER_INFO) +#define XL_TIMER_EVENT ((unsigned short)0x0008) +#define XL_TIMER (XL_TIMER_EVENT) +#define XL_TRANSMIT_MSG ((unsigned short)0x000A) +#define XL_SYNC_PULSE ((unsigned short)0x000B) +#define XL_APPLICATION_NOTIFICATION ((unsigned short)0x000F) + +// +// LIN event tags +// +#define LIN_MSG ((unsigned short)0x0014) +#define LIN_ERRMSG ((unsigned short)0x0015) +#define LIN_SYNCERR ((unsigned short)0x0016) +#define LIN_NOANS ((unsigned short)0x0017) +#define LIN_WAKEUP ((unsigned short)0x0018) +#define LIN_SLEEP ((unsigned short)0x0019) +#define LIN_CRCINFO ((unsigned short)0x001A) + +// +// DAIO event tags +// +#define RECEIVE_DAIO_DATA ((unsigned short)0x0020) //!< D/A IO data message + + + + +// +// FlexRay event tags +// +#define XL_FR_START_CYCLE ((unsigned short)0x0080) +#define XL_FR_RX_FRAME ((unsigned short)0x0081) +#define XL_FR_TX_FRAME ((unsigned short)0x0082) +#define XL_FR_TXACK_FRAME ((unsigned short)0x0083) +#define XL_FR_INVALID_FRAME ((unsigned short)0x0084) +#define XL_FR_WAKEUP ((unsigned short)0x0085) +#define XL_FR_SYMBOL_WINDOW ((unsigned short)0x0086) +#define XL_FR_ERROR ((unsigned short)0x0087) + #define XL_FR_ERROR_POC_MODE ((unsigned char)0x01) + #define XL_FR_ERROR_SYNC_FRAMES_BELOWMIN ((unsigned char)0x02) + #define XL_FR_ERROR_SYNC_FRAMES_OVERLOAD ((unsigned char)0x03) + #define XL_FR_ERROR_CLOCK_CORR_FAILURE ((unsigned char)0x04) + #define XL_FR_ERROR_NIT_FAILURE ((unsigned char)0x05) + #define XL_FR_ERROR_CC_ERROR ((unsigned char)0x06) +#define XL_FR_STATUS ((unsigned short)0x0088) +#define XL_FR_NM_VECTOR ((unsigned short)0x008A) +#define XL_FR_TRANCEIVER_STATUS ((unsigned short)0x008B) +#define XL_FR_SPY_FRAME ((unsigned short)0x008E) +#define XL_FR_SPY_SYMBOL ((unsigned short)0x008F) + + +// +// CAPL-On-Board event tags +// + + +// +// MOST25 event tags +// +#define XL_MOST_START 0x0101 +#define XL_MOST_STOP 0x0102 +#define XL_MOST_EVENTSOURCES 0x0103 +#define XL_MOST_ALLBYPASS 0x0107 +#define XL_MOST_TIMINGMODE 0x0108 +#define XL_MOST_FREQUENCY 0x0109 +#define XL_MOST_REGISTER_BYTES 0x010a +#define XL_MOST_REGISTER_BITS 0x010b +#define XL_MOST_SPECIAL_REGISTER 0x010c +#define XL_MOST_CTRL_RX_SPY 0x010d +#define XL_MOST_CTRL_RX_OS8104 0x010e +#define XL_MOST_CTRL_TX 0x010f +#define XL_MOST_ASYNC_MSG 0x0110 +#define XL_MOST_ASYNC_TX 0x0111 +#define XL_MOST_SYNC_ALLOCTABLE 0x0112 +#define XL_MOST_SYNC_VOLUME_STATUS 0x0116 +#define XL_MOST_RXLIGHT 0x0117 +#define XL_MOST_TXLIGHT 0x0118 +#define XL_MOST_LOCKSTATUS 0x0119 +#define XL_MOST_ERROR 0x011a +#define XL_MOST_CTRL_RXBUFFER 0x011c +#define XL_MOST_SYNC_TX_UNDERFLOW 0x011d +#define XL_MOST_SYNC_RX_OVERFLOW 0x011e +#define XL_MOST_CTRL_SYNC_AUDIO 0x011f +#define XL_MOST_SYNC_MUTE_STATUS 0x0120 +#define XL_MOST_GENLIGHTERROR 0x0121 +#define XL_MOST_GENLOCKERROR 0x0122 +#define XL_MOST_TXLIGHT_POWER 0x0123 +#define XL_MOST_CTRL_BUSLOAD 0x0126 +#define XL_MOST_ASYNC_BUSLOAD 0x0127 +#define XL_MOST_CTRL_SYNC_AUDIO_EX 0x012a +#define XL_MOST_TIMINGMODE_SPDIF 0x012b +#define XL_MOST_STREAM_STATE 0x012c +#define XL_MOST_STREAM_BUFFER 0x012d + + + + +// +// MOST150 event tags +// +#define XL_START ((unsigned short)0x0200) +#define XL_STOP ((unsigned short)0x0201) +#define XL_MOST150_EVENT_SOURCE ((unsigned short)0x0203) +#define XL_MOST150_DEVICE_MODE ((unsigned short)0x0204) +#define XL_MOST150_SYNC_ALLOC_INFO ((unsigned short)0x0205) +#define XL_MOST150_FREQUENCY ((unsigned short)0x0206) +#define XL_MOST150_SPECIAL_NODE_INFO ((unsigned short)0x0207) +#define XL_MOST150_CTRL_RX ((unsigned short)0x0208) +#define XL_MOST150_CTRL_TX_ACK ((unsigned short)0x0209) +#define XL_MOST150_ASYNC_SPY ((unsigned short)0x020A) +#define XL_MOST150_ASYNC_RX ((unsigned short)0x020B) +#define XL_MOST150_SYNC_VOLUME_STATUS ((unsigned short)0x020D) +#define XL_MOST150_TX_LIGHT ((unsigned short)0x020E) +#define XL_MOST150_RXLIGHT_LOCKSTATUS ((unsigned short)0x020F) +#define XL_MOST150_ERROR ((unsigned short)0x0210) +#define XL_MOST150_CONFIGURE_RX_BUFFER ((unsigned short)0x0211) +#define XL_MOST150_CTRL_SYNC_AUDIO ((unsigned short)0x0212) +#define XL_MOST150_SYNC_MUTE_STATUS ((unsigned short)0x0213) +#define XL_MOST150_LIGHT_POWER ((unsigned short)0x0214) +#define XL_MOST150_GEN_LIGHT_ERROR ((unsigned short)0x0215) +#define XL_MOST150_GEN_LOCK_ERROR ((unsigned short)0x0216) +#define XL_MOST150_CTRL_BUSLOAD ((unsigned short)0x0217) +#define XL_MOST150_ASYNC_BUSLOAD ((unsigned short)0x0218) +#define XL_MOST150_ETHERNET_RX ((unsigned short)0x0219) +#define XL_MOST150_SYSTEMLOCK_FLAG ((unsigned short)0x021A) +#define XL_MOST150_SHUTDOWN_FLAG ((unsigned short)0x021B) +#define XL_MOST150_CTRL_SPY ((unsigned short)0x021C) +#define XL_MOST150_ASYNC_TX_ACK ((unsigned short)0x021D) +#define XL_MOST150_ETHERNET_SPY ((unsigned short)0x021E) +#define XL_MOST150_ETHERNET_TX_ACK ((unsigned short)0x021F) +#define XL_MOST150_SPDIFMODE ((unsigned short)0x0220) +#define XL_MOST150_ECL_LINE_CHANGED ((unsigned short)0x0222) +#define XL_MOST150_ECL_TERMINATION_CHANGED ((unsigned short)0x0223) +#define XL_MOST150_NW_STARTUP ((unsigned short)0x0224) +#define XL_MOST150_NW_SHUTDOWN ((unsigned short)0x0225) +#define XL_MOST150_STREAM_STATE ((unsigned short)0x0226) +#define XL_MOST150_STREAM_TX_BUFFER ((unsigned short)0x0227) +#define XL_MOST150_STREAM_RX_BUFFER ((unsigned short)0x0228) +#define XL_MOST150_STREAM_TX_LABEL ((unsigned short)0x0229) +#define XL_MOST150_STREAM_TX_UNDERFLOW ((unsigned short)0x022B) +#define XL_MOST150_GEN_BYPASS_STRESS ((unsigned short)0x022C) +#define XL_MOST150_ECL_SEQUENCE ((unsigned short)0x022D) +#define XL_MOST150_ECL_GLITCH_FILTER ((unsigned short)0x022E) +#define XL_MOST150_SSO_RESULT ((unsigned short)0x022F) + + +// +// CAN/CAN-FD event tags +// Rx +#define XL_CAN_EV_TAG_RX_OK ((unsigned short)0x0400) +#define XL_CAN_EV_TAG_RX_ERROR ((unsigned short)0x0401) +#define XL_CAN_EV_TAG_TX_ERROR ((unsigned short)0x0402) +#define XL_CAN_EV_TAG_TX_REQUEST ((unsigned short)0x0403) +#define XL_CAN_EV_TAG_TX_OK ((unsigned short)0x0404) +#define XL_CAN_EV_TAG_CHIP_STATE ((unsigned short)0x0409) + +// CAN/CAN-FD event tags +// Tx +#define XL_CAN_EV_TAG_TX_MSG ((unsigned short)0x0440) +// +// Ethernet event tags +// +#define XL_ETH_EVENT_TAG_FRAMERX ((unsigned short)0x0500) //Event data type T_XL_ETH_DATAFRAME_RX +#define XL_ETH_EVENT_TAG_FRAMERX_ERROR ((unsigned short)0x0501) //Event data type T_XL_ETH_DATAFRAME_RX_ERROR +#define XL_ETH_EVENT_TAG_FRAMETX_ERROR ((unsigned short)0x0506) //Event data type T_XL_ETH_DATAFRAME_TX_ERROR +#define XL_ETH_EVENT_TAG_FRAMETX_ERROR_SWITCH ((unsigned short)0x0507) //Event data type T_XL_ETH_DATAFRAME_TX_ERR_SW +#define XL_ETH_EVENT_TAG_FRAMETX_ACK ((unsigned short)0x0510) //Event data type T_XL_ETH_DATAFRAME_TXACK +#define XL_ETH_EVENT_TAG_FRAMETX_ACK_SWITCH ((unsigned short)0x0511) //Event data type T_XL_ETH_DATAFRAME_TXACK_SW +#define XL_ETH_EVENT_TAG_FRAMETX_ACK_OTHER_APP ((unsigned short)0x0513) //Event data type T_XL_ETH_DATAFRAME_TXACK_OTHERAPP +#define XL_ETH_EVENT_TAG_FRAMETX_ERROR_OTHER_APP ((unsigned short)0x0514) //Event data type T_XL_ETH_DATAFRAME_TX_ERR_OTHERAPP +#define XL_ETH_EVENT_TAG_CHANNEL_STATUS ((unsigned short)0x0520) //Event data type T_XL_ETH_CHANNEL_STATUS +#define XL_ETH_EVENT_TAG_CONFIGRESULT ((unsigned short)0x0530) //Event data type T_XL_ETH_CONFIG_RESULT +#define XL_ETH_EVENT_TAG_LOSTEVENT ((unsigned short)0x05fe) //Indication that one or more intended events could not be generated. Event data type T_XL_ETH_LOSTEVENT +#define XL_ETH_EVENT_TAG_ERROR ((unsigned short)0x05ff) //Generic error + +// +// ARINC429 event tags +// +#define XL_A429_EV_TAG_TX_OK ((unsigned short)0x0600) +#define XL_A429_EV_TAG_TX_ERR ((unsigned short)0x0601) +#define XL_A429_EV_TAG_RX_OK ((unsigned short)0x0608) +#define XL_A429_EV_TAG_RX_ERR ((unsigned short)0x0609) +#define XL_A429_EV_TAG_BUS_STATISTIC ((unsigned short)0x060F) + +typedef unsigned __int64 XLuint64; + +#include + + +// defines for XL_APPLICATION_NOTIFICATION_EV::notifyReason +#define XL_NOTIFY_REASON_CHANNEL_ACTIVATION 1 +#define XL_NOTIFY_REASON_CHANNEL_DEACTIVATION 2 +#define XL_NOTIFY_REASON_PORT_CLOSED 3 + +typedef struct s_xl_application_notification { + unsigned int notifyReason; // XL_NOTIFY_REASON_xxx + unsigned int reserved[7]; +} XL_APPLICATION_NOTIFICATION_EV; + + + +// defines for XL_SYNC_PULSE_EV::triggerSource and s_xl_sync_pulse::pulseCode +#define XL_SYNC_PULSE_EXTERNAL 0x00 +#define XL_SYNC_PULSE_OUR 0x01 +#define XL_SYNC_PULSE_OUR_SHARED 0x02 + +// definition of the sync pulse event for xl interface versions V3 and higher +// (XL_INTERFACE_VERSION_V3, XL_INTERFACE_VERSION_V4, ..) +typedef struct s_xl_sync_pulse_ev { + unsigned int triggerSource; //!< e.g. external or internal trigger source + unsigned int reserved; + XLuint64 time; //!< internally generated timestamp +} XL_SYNC_PULSE_EV; + +// definition of the sync pulse event for xl interface versions V1 and V2 +// (XL_INTERFACE_VERSION_V1, XL_INTERFACE_VERSION_V2) +#include +struct s_xl_sync_pulse { + unsigned char pulseCode; //!< generated by us + XLuint64 time; //!< 1 ns resolution +}; + +#include + + + + +#include + + +//------------------------------------------------------------------------------ +// defines for the supported hardware +#define XL_HWTYPE_NONE 0 +#define XL_HWTYPE_VIRTUAL 1 +#define XL_HWTYPE_CANCARDX 2 +#define XL_HWTYPE_CANAC2PCI 6 +#define XL_HWTYPE_CANCARDY 12 +#define XL_HWTYPE_CANCARDXL 15 +#define XL_HWTYPE_CANCASEXL 21 +#define XL_HWTYPE_CANCASEXL_LOG_OBSOLETE 23 +#define XL_HWTYPE_CANBOARDXL 25 // CANboardXL, CANboardXL PCIe +#define XL_HWTYPE_CANBOARDXL_PXI 27 // CANboardXL pxi +#define XL_HWTYPE_VN2600 29 +#define XL_HWTYPE_VN2610 XL_HWTYPE_VN2600 +#define XL_HWTYPE_VN3300 37 +#define XL_HWTYPE_VN3600 39 +#define XL_HWTYPE_VN7600 41 +#define XL_HWTYPE_CANCARDXLE 43 +#define XL_HWTYPE_VN8900 45 +#define XL_HWTYPE_VN8950 47 +#define XL_HWTYPE_VN2640 53 +#define XL_HWTYPE_VN1610 55 +#define XL_HWTYPE_VN1630 57 +#define XL_HWTYPE_VN1640 59 +#define XL_HWTYPE_VN8970 61 +#define XL_HWTYPE_VN1611 63 +#define XL_HWTYPE_VN5610 65 +#define XL_HWTYPE_VN7570 67 +#define XL_HWTYPE_IPCLIENT 69 +#define XL_HWTYPE_IPSERVER 71 +#define XL_HWTYPE_VX1121 73 +#define XL_HWTYPE_VX1131 75 +#define XL_HWTYPE_VT6204 77 + +#define XL_HWTYPE_VN1630_LOG 79 +#define XL_HWTYPE_VN7610 81 +#define XL_HWTYPE_VN7572 83 +#define XL_HWTYPE_VN8972 85 +#define XL_HWTYPE_VN0601 87 +#define XL_HWTYPE_VX0312 91 +#define XL_HWTYPE_VN8800 95 +#define XL_HWTYPE_IPCL8800 96 +#define XL_HWTYPE_IPSRV8800 97 +#define XL_HWTYPE_CSMCAN 98 +#define XL_HWTYPE_VN5610A 101 +#define XL_HWTYPE_VN7640 102 +#define XL_MAX_HWTYPE 102 +#include +//////////////////////////////////////////////////////////////////////////////// +typedef char *XLstringType; + +//////////////////////////////////////////////////////////////////////////////// +// accessmask +typedef XLuint64 XLaccess; + +//////////////////////////////////////////////////////////////////////////////// +// handle for xlSetNotification +typedef HANDLE XLhandle; + +//////////////////////////////////////////////////////////////////////////////// +// LIN lib +//------------------------------------------------------------------------------ +// defines for LIN +//------------------------------------------------------------------------------ + +// defines for xlLinSetChannelParams +#define XL_LIN_MASTER (unsigned int) 01 //!< channel is a LIN master +#define XL_LIN_SLAVE (unsigned int) 02 //!< channel is a LIN slave +#define XL_LIN_VERSION_1_3 (unsigned int) 0x01 //!< LIN version 1.3 +#define XL_LIN_VERSION_2_0 (unsigned int) 0x02 //!< LIN version 2.0 +#define XL_LIN_VERSION_2_1 (unsigned int) 0x03 //!< LIN version 2.1 + +// defines for xlLinSetSlave +#define XL_LIN_CALC_CHECKSUM (unsigned short) 0x100 //!< flag for automatic 'classic' checksum calculation +#define XL_LIN_CALC_CHECKSUM_ENHANCED (unsigned short) 0x200 //!< flag for automatic 'enhanced' checksum calculation + +// defines for xlLinSetSleepMode +#define XL_LIN_SET_SILENT (unsigned int) 0x01 //!< set hardware into sleep mode +#define XL_LIN_SET_WAKEUPID (unsigned int) 0x03 //!< set hardware into sleep mode and send a request at wake-up + +// defines for xlLinSetChecksum. For LIN >= 2.0 there can be used two different Checksum models. +#define XL_LIN_CHECKSUM_CLASSIC (unsigned char) 0x00 //!< Use classic CRC +#define XL_LIN_CHECKSUM_ENHANCED (unsigned char) 0x01 //!< Use enhanced CRC +#define XL_LIN_CHECKSUM_UNDEFINED (unsigned char) 0xff //!< Set the checksum calculation to undefined. + +// defines for the sleep mode event: XL_LIN_SLEEP +#define XL_LIN_STAYALIVE (unsigned char) 0x00 //!< flag if nothing changes +#define XL_LIN_SET_SLEEPMODE (unsigned char) 0x01 //!< flag if the hardware is set into the sleep mode +#define XL_LIN_COMESFROM_SLEEPMODE (unsigned char) 0x02 //!< flag if the hardware comes from the sleep mode + +// defines for the wake up event: XL_LIN_WAKEUP +#define XL_LIN_WAKUP_INTERNAL (unsigned char) 0x01 //!< flag to signal a internal WAKEUP (event) + +// defines for xlLINSetDLC +#define XL_LIN_UNDEFINED_DLC (unsigned char) 0xff //!< set the DLC to undefined + +// defines for xlLinSwitchSlave +#define XL_LIN_SLAVE_ON (unsigned char) 0xff //!< switch on the LIN slave +#define XL_LIN_SLAVE_OFF (unsigned char) 0x00 //!< switch off the LIN slave + +//------------------------------------------------------------------------------ +// structures for LIN +//------------------------------------------------------------------------------ +typedef struct { + unsigned int LINMode; //!< XL_LIN_SLAVE | XL_LIN_MASTER + int baudrate; //!< the baudrate will be calculated within the API. Here: e.g. 9600, 19200 + unsigned int LINVersion; //!< define for the LIN version (actual V1.3 of V2.0) + unsigned int reserved; //!< for future use +} XLlinStatPar; + + +//////////////////////////////////////////////////////////////////////////////// +// Defines +//------------------------------------------------------------------------------ +// message flags +#ifndef MAX_MSG_LEN +#define MAX_MSG_LEN 8 +#endif + +// interface version for our events +#define XL_INTERFACE_VERSION_V2 2 +#define XL_INTERFACE_VERSION_V3 3 +#define XL_INTERFACE_VERSION_V4 4 +//current version +#define XL_INTERFACE_VERSION XL_INTERFACE_VERSION_V3 + +#define XL_CAN_EXT_MSG_ID 0x80000000 + +#define XL_CAN_MSG_FLAG_ERROR_FRAME 0x01 +#define XL_CAN_MSG_FLAG_OVERRUN 0x02 //!< Overrun in Driver or CAN Controller, + //!< previous msgs have been lost. +#define XL_CAN_MSG_FLAG_NERR 0x04 //!< Line Error on Lowspeed +#define XL_CAN_MSG_FLAG_WAKEUP 0x08 //!< High Voltage Message on Single Wire CAN +#define XL_CAN_MSG_FLAG_REMOTE_FRAME 0x10 +#define XL_CAN_MSG_FLAG_RESERVED_1 0x20 +#define XL_CAN_MSG_FLAG_TX_COMPLETED 0x40 //!< Message Transmitted +#define XL_CAN_MSG_FLAG_TX_REQUEST 0x80 //!< Transmit Message stored into Controller +#define XL_CAN_MSG_FLAG_SRR_BIT_DOM 0x0200 //!< SRR bit in CAN message is dominant + +#define XL_EVENT_FLAG_OVERRUN 0x01 //!< Used in XLevent.flags + +// LIN flags +#define XL_LIN_MSGFLAG_TX XL_CAN_MSG_FLAG_TX_COMPLETED //!< LIN TX flag +#define XL_LIN_MSGFLAG_CRCERROR 0x81 //!< Wrong LIN CRC + +//------------------------------------------------------------------------------ +// structure for XL_RECEIVE_MSG, XL_TRANSMIT_MSG + +struct s_xl_can_msg { /* 32 Bytes */ + unsigned long id; + unsigned short flags; + unsigned short dlc; + XLuint64 res1; + unsigned char data [MAX_MSG_LEN]; + XLuint64 res2; + }; + + + +//------------------------------------------------------------------------------ +// structure for XL_TRANSMIT_DAIO_DATA + +// flags masks +#define XL_DAIO_DATA_GET 0x8000 +#define XL_DAIO_DATA_VALUE_DIGITAL 0x0001 +#define XL_DAIO_DATA_VALUE_ANALOG 0x0002 +#define XL_DAIO_DATA_PWM 0x0010 + +// optional function flags +#define XL_DAIO_MODE_PULSE 0x0020 // generates pulse in values of PWM + +struct s_xl_daio_data { /* 32 Bytes */ + unsigned short flags; // 2 + unsigned int timestamp_correction; // 4 + unsigned char mask_digital; // 1 + unsigned char value_digital; // 1 + unsigned char mask_analog; // 1 + unsigned char reserved0; // 1 + unsigned short value_analog[4]; // 8 + unsigned int pwm_frequency; // 4 + unsigned short pwm_value; // 2 + unsigned int reserved1; // 4 + unsigned int reserved2; // 4 +}; + +typedef struct s_xl_io_digital_data { + unsigned int digitalInputData; +} XL_IO_DIGITAL_DATA; + +typedef struct s_xl_io_analog_data { + unsigned int measuredAnalogData0; + unsigned int measuredAnalogData1; + unsigned int measuredAnalogData2; + unsigned int measuredAnalogData3; +} XL_IO_ANALOG_DATA; + +struct s_xl_daio_piggy_data { /* xx Bytes */ + unsigned int daioEvtTag; + unsigned int triggerType; + union { + XL_IO_DIGITAL_DATA digital; + XL_IO_ANALOG_DATA analog; + } data; +}; + +//------------------------------------------------------------------------------ +// structure for XL_CHIP_STATE + +#define XL_CHIPSTAT_BUSOFF 0x01 +#define XL_CHIPSTAT_ERROR_PASSIVE 0x02 +#define XL_CHIPSTAT_ERROR_WARNING 0x04 +#define XL_CHIPSTAT_ERROR_ACTIVE 0x08 + + +struct s_xl_chip_state { + unsigned char busStatus; + unsigned char txErrorCounter; + unsigned char rxErrorCounter; + }; + +//------------------------------------------------------------------------------ +// structure and defines for XL_TRANSCEIVER +#define XL_TRANSCEIVER_EVENT_NONE 0 +#define XL_TRANSCEIVER_EVENT_INSERTED 1 //!< cable was inserted +#define XL_TRANSCEIVER_EVENT_REMOVED 2 //!< cable was removed +#define XL_TRANSCEIVER_EVENT_STATE_CHANGE 3 //!< transceiver state changed + +struct s_xl_transceiver { + unsigned char event_reason; //!< reason for what was event sent + unsigned char is_present; //!< allways valid transceiver presence flag + }; + +//------------------------------------------------------------------------------ +// defines for SET_OUTPUT_MODE +#define XL_OUTPUT_MODE_SILENT 0 //!< switch CAN trx into default silent mode +#define XL_OUTPUT_MODE_NORMAL 1 //!< switch CAN trx into normal mode +#define XL_OUTPUT_MODE_TX_OFF 2 //!< switch CAN trx into silent mode with tx pin off +#define XL_OUTPUT_MODE_SJA_1000_SILENT 3 //!< switch CAN trx into SJA1000 silent mode + +//------------------------------------------------------------------------------ +// Transceiver modes +#define XL_TRANSCEIVER_EVENT_ERROR 1 +#define XL_TRANSCEIVER_EVENT_CHANGED 2 + +//////////////////////////////////////////////////////////////////////////////// +// LIN lib +//------------------------------------------------------------------------------ +// LIN event structures +struct s_xl_lin_msg { + unsigned char id; + unsigned char dlc; + unsigned short flags; + unsigned char data[8]; + unsigned char crc; +}; +struct s_xl_lin_sleep { + unsigned char flag; +}; + +struct s_xl_lin_no_ans { + unsigned char id; +}; + +struct s_xl_lin_wake_up { + unsigned char flag; + unsigned char unused[3]; + unsigned int startOffs; // spec >= 2.0 only, else 0 + unsigned int width; // spec >= 2.0 only, else 0 +}; + +struct s_xl_lin_crc_info { + unsigned char id; + unsigned char flags; +}; + +//------------------------------------------------------------------------------ +// LIN messages structure +union s_xl_lin_msg_api { + struct s_xl_lin_msg linMsg; + struct s_xl_lin_no_ans linNoAns; + struct s_xl_lin_wake_up linWakeUp; + struct s_xl_lin_sleep linSleep; + struct s_xl_lin_crc_info linCRCinfo; +}; + + +//------------------------------------------------------------------------------ +// BASIC bus message structure +union s_xl_tag_data { + struct s_xl_can_msg msg; + struct s_xl_chip_state chipState; + union s_xl_lin_msg_api linMsgApi; + struct s_xl_sync_pulse syncPulse; + struct s_xl_daio_data daioData; + struct s_xl_transceiver transceiver; + struct s_xl_daio_piggy_data daioPiggyData; + }; + +typedef unsigned char XLeventTag; + +//------------------------------------------------------------------------------ +// XL_EVENT structures +// event type definition + +struct s_xl_event { + XLeventTag tag; // 1 + unsigned char chanIndex; // 1 + unsigned short transId; // 2 + unsigned short portHandle; // 2 internal use only !!!! + unsigned char flags; // 1 (e.g. XL_EVENT_FLAG_OVERRUN) + unsigned char reserved; // 1 + XLuint64 timeStamp; // 8 + union s_xl_tag_data tagData; // 32 Bytes + }; + // -------- + // 48 Bytes + +typedef struct s_xl_event XLevent; +// message name to acquire a unique message id from windows +#define DriverNotifyMessageName "VectorCanDriverChangeNotifyMessage" + +//------------------------------------------------------------------------------ +// build a channels mask from the channels index +#define XL_CHANNEL_MASK(x) (1I64<<(x)) + +#define XL_MAX_APPNAME 32 + +//------------------------------------------------------------------------------ +// driver status +typedef short XLstatus; + + +//defines for xlGetDriverConfig structures +#define XL_MAX_LENGTH 31 +#define XL_CONFIG_MAX_CHANNELS 64 + + +//activate - channel flags +#define XL_ACTIVATE_NONE 0 +#define XL_ACTIVATE_RESET_CLOCK 8 + +#define XL_BUS_COMPATIBLE_CAN XL_BUS_TYPE_CAN +#define XL_BUS_COMPATIBLE_LIN XL_BUS_TYPE_LIN +#define XL_BUS_COMPATIBLE_FLEXRAY XL_BUS_TYPE_FLEXRAY +#define XL_BUS_COMPATIBLE_MOST XL_BUS_TYPE_MOST +#define XL_BUS_COMPATIBLE_DAIO XL_BUS_TYPE_DAIO //io cab/piggy +#define XL_BUS_COMPATIBLE_J1708 XL_BUS_TYPE_J1708 +#define XL_BUS_COMPATIBLE_ETHERNET XL_BUS_TYPE_ETHERNET +#define XL_BUS_COMPATIBLE_A429 XL_BUS_TYPE_A429 + +// the following bus types can be used with the current cab / piggy +#define XL_BUS_ACTIVE_CAP_CAN (XL_BUS_COMPATIBLE_CAN<<16) +#define XL_BUS_ACTIVE_CAP_LIN (XL_BUS_COMPATIBLE_LIN<<16) +#define XL_BUS_ACTIVE_CAP_FLEXRAY (XL_BUS_COMPATIBLE_FLEXRAY<<16) +#define XL_BUS_ACTIVE_CAP_MOST (XL_BUS_COMPATIBLE_MOST<<16) +#define XL_BUS_ACTIVE_CAP_DAIO (XL_BUS_COMPATIBLE_DAIO<<16) +#define XL_BUS_ACTIVE_CAP_J1708 (XL_BUS_COMPATIBLE_J1708<<16) +#define XL_BUS_ACTIVE_CAP_ETHERNET (XL_BUS_COMPATIBLE_ETHERNET<<16) +#define XL_BUS_ACTIVE_CAP_A429 (XL_BUS_COMPATIBLE_A429<<16) + +#define XL_BUS_NAME_NONE "" +#define XL_BUS_NAME_CAN "CAN" +#define XL_BUS_NAME_LIN "LIN" +#define XL_BUS_NAME_FLEXRAY "FlexRay" +#define XL_BUS_NAME_STREAM "Stream" +#define XL_BUS_NAME_MOST "MOST" +#define XL_BUS_NAME_DAIO "DAIO" +#define XL_BUS_NAME_HWSYNC_KEYPAD "HWSYNC_KEYPAD" +#define XL_BUS_NAME_J1708 "J1708" +#define XL_BUS_NAME_KLINE "K-Line" +#define XL_BUS_NAME_ETHERNET "Ethernet" +#define XL_BUS_NAME_AFDX "AFDX" +#define XL_BUS_NAME_A429 "ARINC429" + + +//------------------------------------------------------------------------------ +// acceptance filter + +#define XL_CAN_STD 01 //!< flag for standard ID's +#define XL_CAN_EXT 02 //!< flag for extended ID's + +//------------------------------------------------------------------------------ +// bit timing + + +typedef struct { + unsigned int arbitrationBitRate; + unsigned int sjwAbr; // CAN bus timing for nominal / arbitration bit rate + unsigned int tseg1Abr; + unsigned int tseg2Abr; + unsigned int dataBitRate; + unsigned int sjwDbr; // CAN bus timing for data bit rate + unsigned int tseg1Dbr; + unsigned int tseg2Dbr; + unsigned int reserved[2]; // has to be zero +} XLcanFdConf; + + +typedef struct { + unsigned long bitRate; + unsigned char sjw; + unsigned char tseg1; + unsigned char tseg2; + unsigned char sam; // 1 or 3 + } XLchipParams; + +// defines for XLbusParams::data::most::activeSpeedGrade and compatibleSpeedGrade +#define XL_BUS_PARAMS_MOST_SPEED_GRADE_25 0x01 +#define XL_BUS_PARAMS_MOST_SPEED_GRADE_150 0x02 + + +//defines for XLbusParams::data::can/canFD::canOpMode +#define XL_BUS_PARAMS_CANOPMODE_CAN20 0x01 //channel operates in CAN20 +#define XL_BUS_PARAMS_CANOPMODE_CANFD 0x02 //channel operates in CANFD + +typedef struct { + unsigned int busType; + union { + struct { + unsigned int bitRate; + unsigned char sjw; + unsigned char tseg1; + unsigned char tseg2; + unsigned char sam; // 1 or 3 + unsigned char outputMode; + unsigned char reserved[7]; + unsigned char canOpMode; + } can; + struct { + unsigned int arbitrationBitRate; // CAN bus timing for nominal / arbitration bit rate + unsigned char sjwAbr; + unsigned char tseg1Abr; + unsigned char tseg2Abr; + unsigned char samAbr; // 1 or 3 + unsigned char outputMode; + unsigned char sjwDbr; // CAN bus timing for data bit rate + unsigned char tseg1Dbr; + unsigned char tseg2Dbr; + unsigned int dataBitRate; + unsigned char canOpMode; + } canFD; + struct { + unsigned int activeSpeedGrade; + unsigned int compatibleSpeedGrade; + unsigned int inicFwVersion; + } most; + struct { + // status and cfg mode are part of xlFrGetChannelConfiguration, too + unsigned int status; // XL_FR_CHANNEL_CFG_STATUS_xxx + unsigned int cfgMode; // XL_FR_CHANNEL_CFG_MODE_xxx + unsigned int baudrate; // FlexRay baudrate in kBaud + } flexray; + struct { + unsigned char macAddr[6]; // MAC address (starting with MSB!) + unsigned char connector; // XL_ETH_STATUS_CONNECTOR_xxx + unsigned char phy; // XL_ETH_STATUS_PHY_xxx + unsigned char link; // XL_ETH_STATUS_LINK_xxx + unsigned char speed; // XL_ETH_STATUS_SPEED_xxx + unsigned char clockMode; // XL_ETH_STATUS_CLOCK_xxx + unsigned char bypass; // XL_ETH_BYPASS_xxx + } ethernet; + struct { + unsigned short channelDirection; + unsigned short res1; + union { + struct { + unsigned int bitrate; + unsigned int parity; + unsigned int minGap; + } tx; + struct { + unsigned int bitrate; + unsigned int minBitrate; + unsigned int maxBitrate; + unsigned int parity; + unsigned int minGap; + unsigned int autoBaudrate; + } rx; + unsigned char raw[24]; + } dir; + } a429; + unsigned char raw[28]; + } data; +} XLbusParams; + +// porthandle +#define XL_INVALID_PORTHANDLE (-1) +typedef long XLportHandle, *pXLportHandle; + +// defines for the connectionInfo (only for the USB devices) +#define XL_CONNECTION_INFO_USB_UNKNOWN 0 +#define XL_CONNECTION_INFO_USB_FULLSPEED 1 +#define XL_CONNECTION_INFO_USB_HIGHSPEED 2 +#define XL_CONNECTION_INFO_USB_SUPERSPEED 3 +// defines for FPGA core types (fpgaCoreCapabilities) +#define XL_FPGA_CORE_TYPE_NONE 0 +#define XL_FPGA_CORE_TYPE_CAN 1 +#define XL_FPGA_CORE_TYPE_LIN 2 +#define XL_FPGA_CORE_TYPE_LIN_RX 3 + +//#defines for specialDeviceStatus +#define XL_SPECIAL_DEVICE_STAT_FPGA_UPDATE_DONE 0x01 //!< automatic driver FPGA flashing done + +// structure for xlGetLicenseInfo function +// This structure is returned as an array from the xlGetLicenseInfo. It contains all available licenses on +// the queried channels. The position inside the array is defined by the license itself, e.g. the license for +// the Advanced-Flexray-Library is always at the same array index. +typedef struct s_xl_license_info { + unsigned char bAvailable; //!< License is available + char licName[65]; //!< Name of the license as NULL-terminated string +} XL_LICENSE_INFO; +typedef XL_LICENSE_INFO XLlicenseInfo; + +// structures for xlGetDriverConfig +typedef struct s_xl_channel_config { + char name [XL_MAX_LENGTH + 1]; + unsigned char hwType; //!< HWTYPE_xxxx (see above) + unsigned char hwIndex; //!< Index of the hardware (same type) (0,1,...) + unsigned char hwChannel; //!< Index of the channel (same hardware) (0,1,...) + unsigned short transceiverType; //!< TRANSCEIVER_TYPE_xxxx (see above) + unsigned short transceiverState; //!< transceiver state (XL_TRANSCEIVER_STATUS...) + unsigned short configError; //!< XL_CHANNEL_CONFIG_ERROR_XXX (see above) + unsigned char channelIndex; //!< Global channel index (0,1,...) + XLuint64 channelMask; //!< Global channel mask (=1< + +//////////////////////////////////////////////////////////////////////////////// +// MOST lib +//------------------------------------------------------------------------------ +// special MOST defines + +#define XLuserHandle unsigned short + +// size of allocation table +#define MOST_ALLOC_TABLE_SIZE 64 // size of channel alloctaion table + 4Bytes (MPR, MDR; ?, ?) + +/////////////////////////////////////////////////////// +// Remote Api RDNI +#define XL_IPv4 4 +#define XL_IPv6 6 +#define XL_MAX_REMOTE_DEVICE_INFO 16 +#define XL_ALL_REMOTE_DEVICES 0xFFFFFFFF +#define XL_MAX_REMOTE_ALIAS_SIZE 64 + +#define XL_REMOTE_OFFLINE 1 +#define XL_REMOTE_ONLINE 2 +#define XL_REMOTE_BUSY 3 +#define XL_REMOTE_CONNECION_REFUSED 4 + +#define XL_REMOTE_ADD_PERMANENT 0x0 +#define XL_REMOTE_ADD_TEMPORARY 0x1 + +#define XL_REMOTE_REGISTER_NONE 0x0 +#define XL_REMOTE_REGISTER_CONNECT 0x1 +#define XL_REMOTE_REGISTER_TEMP_CONNECT 0x2 + +#define XL_REMOTE_DISCONNECT_NONE 0x0 +#define XL_REMOTE_DISCONNECT_REMOVE_ENTRY 0x1 + +#define XL_REMOTE_DEVICE_AVAILABLE 0x00000001 // the device is present +#define XL_REMOTE_DEVICE_CONFIGURED 0x00000002 // the device has a configuration entry in registry +#define XL_REMOTE_DEVICE_CONNECTED 0x00000004 // the device is connected too this client +#define XL_REMOTE_DEVICE_ENABLED 0x00000008 // the driver should open a connection to this client +#define XL_REMOTE_DEVICE_BUSY 0x00000010 // the device is used by another client +#define XL_REMOTE_DEVICE_TEMP_CONFIGURED 0x00000020 // the device is temporary configured, it has not entry in registry + +#define XL_REMOTE_NO_NET_SEARCH 0 +#define XL_REMOTE_NET_SEARCH 1 + +#define XL_REMOTE_DEVICE_TYPE_UNKNOWN 0 +#define XL_REMOTE_DEVICE_TYPE_VN8900 1 +#define XL_REMOTE_DEVICE_TYPE_STANDARD_PC 2 +#define XL_REMOTE_DEVICE_TYPE_VX 3 +#define XL_REMOTE_DEVICE_TYPE_VN8800 4 + +typedef unsigned int XLremoteHandle; +typedef unsigned int XLdeviceAccess; +typedef unsigned int XLremoteStatus; + +#include + +typedef struct s_xl_ip_address { + union { + unsigned int v4; + unsigned int v6[4]; + } ip; + unsigned int prefixLength; + unsigned int ipVersion; + unsigned int configPort; + unsigned int eventPort; +} XLipAddress; + +typedef struct s_xl_remote_location_config { + char hostName[64]; + char alias[64]; + XLipAddress ipAddress; + XLipAddress userIpAddress; + unsigned int deviceType; + unsigned int serialNumber; + unsigned int articleNumber; + XLremoteHandle remoteHandle; +} XLremoteLocationConfig; + +typedef struct s_xl_remote_device { + char deviceName[32]; + unsigned int hwType; + unsigned int articleNumber; + unsigned int serialNumber; + unsigned int reserved; +} XLremoteDevice; + +typedef struct s_xl_remote_device_info { + XLremoteLocationConfig locationConfig; + unsigned int flags; + unsigned int reserved; + unsigned int nbrOfDevices; + XLremoteDevice deviceInfo[XL_MAX_REMOTE_DEVICE_INFO]; +} XLremoteDeviceInfo; + + + +#include + +// flags for channelCapabilities +// Time-Sync +#define XL_CHANNEL_FLAG_TIME_SYNC_RUNNING 0x00000001 +#define XL_CHANNEL_FLAG_NO_HWSYNC_SUPPORT 0x00000400 //Device is not capable of hardware-based time synchronization via Sync-line +// used to distinguish between VN2600 (w/o SPDIF) and VN2610 (with S/PDIF) +#define XL_CHANNEL_FLAG_SPDIF_CAPABLE 0x00004000 +#define XL_CHANNEL_FLAG_CANFD_BOSCH_SUPPORT 0x20000000 +#define XL_CHANNEL_FLAG_CANFD_ISO_SUPPORT 0x80000000 +// max. size of rx fifo for rx event in bytes +#define RX_FIFO_MOST_QUEUE_SIZE_MAX 1048576 +#define RX_FIFO_MOST_QUEUE_SIZE_MIN 8192 + + +// defines for xlMostSwitchEventSources +#define XL_MOST_SOURCE_ASYNC_SPY 0x8000 +#define XL_MOST_SOURCE_ASYNC_RX 0x1000 +#define XL_MOST_SOURCE_ASYNC_TX 0x0800 +#define XL_MOST_SOURCE_CTRL_OS8104A 0x0400 +#define XL_MOST_SOURCE_CTRL_SPY 0x0100 +#define XL_MOST_SOURCE_ALLOC_TABLE 0x0080 +#define XL_MOST_SOURCE_SYNC_RC_OVER 0x0040 +#define XL_MOST_SOURCE_SYNC_TX_UNDER 0x0020 +#define XL_MOST_SOURCE_SYNCLINE 0x0010 +#define XL_MOST_SOURCE_ASYNC_RX_FIFO_OVER 0x0008 + +// data for XL_MOST_ERROR: +#define XL_MOST_OS8104_TX_LOCK_ERROR 0x00000001 +#define XL_MOST_OS8104_SPDIF_LOCK_ERROR 0x00000002 +#define XL_MOST_OS8104_ASYNC_BUFFER_FULL 0x00000003 +#define XL_MOST_OS8104_ASYNC_CRC_ERROR 0x00000004 +#define XL_MOST_ASYNC_TX_UNDERRUN 0x00000005 +#define XL_MOST_CTRL_TX_UNDERRUN 0x00000006 +#define XL_MOST_MCU_TS_CMD_QUEUE_UNDERRUN 0x00000007 +#define XL_MOST_MCU_TS_CMD_QUEUE_OVERRUN 0x00000008 +#define XL_MOST_CMD_TX_UNDERRUN 0x00000009 +#define XL_MOST_SYNCPULSE_ERROR 0x0000000A +#define XL_MOST_OS8104_CODING_ERROR 0x0000000B +#define XL_MOST_ERROR_UNKNOWN_COMMAND 0x0000000C +#define XL_MOST_ASYNC_RX_OVERFLOW_ERROR 0x0000000D +#define XL_MOST_FPGA_TS_FIFO_OVERFLOW 0x0000000E +#define XL_MOST_SPY_OVERFLOW_ERROR 0x0000000F +#define XL_MOST_CTRL_TYPE_QUEUE_OVERFLOW 0x00000010 +#define XL_MOST_ASYNC_TYPE_QUEUE_OVERFLOW 0x00000011 +#define XL_MOST_CTRL_UNKNOWN_TYPE 0x00000012 +#define XL_MOST_CTRL_QUEUE_UNDERRUN 0x00000013 +#define XL_MOST_ASYNC_UNKNOWN_TYPE 0x00000014 +#define XL_MOST_ASYNC_QUEUE_UNDERRUN 0x00000015 + +// data for demanded timstamps +#define XL_MOST_DEMANDED_START 0x00000001 + +#define XL_MOST_RX_DATA_SIZE 1028 +#define XL_MOST_TS_DATA_SIZE 12 +#define XL_MOST_RX_ELEMENT_HEADER_SIZE 32 +#define XL_MOST_CTRL_RX_SPY_SIZE 36 +#define XL_MOST_CTRL_RX_OS8104_SIZE 28 +#define XL_MOST_SPECIAL_REGISTER_CHANGE_SIZE 20 +#define XL_MOST_ERROR_EV_SIZE_4 4 // dwords +#define XL_MOST_ERROR_EV_SIZE 16 // bytes + + +// defines for the audio devices +#define XL_MOST_DEVICE_CASE_LINE_IN 0 +#define XL_MOST_DEVICE_CASE_LINE_OUT 1 +#define XL_MOST_DEVICE_SPDIF_IN 7 +#define XL_MOST_DEVICE_SPDIF_OUT 8 +#define XL_MOST_DEVICE_SPDIF_IN_OUT_SYNC 11 + +// defines for xlMostCtrlSyncAudioEx, mode +#define XL_MOST_SPDIF_LOCK_OFF 0 +#define XL_MOST_SPDIF_LOCK_ON 1 + +// defines for the XL_MOST_SYNC_MUTES_STATUS event +#define XL_MOST_NO_MUTE 0 +#define XL_MOST_MUTE 1 + +// defines for the event sources in XLmostEvent +#define XL_MOST_VN2600 0x01 +#define XL_MOST_OS8104A 0x02 +#define XL_MOST_OS8104B 0x04 +#define XL_MOST_SPY 0x08 + +// defines for xlMostSetAllBypass and XL_MOST_ALLBYPASS +#define XL_MOST_MODE_DEACTIVATE 0 +#define XL_MOST_MODE_ACTIVATE 1 +#define XL_MOST_MODE_FORCE_DEACTIVATE 2 + +#define XL_MOST_RX_BUFFER_CLEAR_ONCE 2 + +// defines for xlMostSetTimingMode and the XL_MOST_TIMINGMODE(_SPDIF)_EV event. +#define XL_MOST_TIMING_SLAVE 0 +#define XL_MOST_TIMING_MASTER 1 +#define XL_MOST_TIMING_SLAVE_SPDIF_MASTER 2 +#define XL_MOST_TIMING_SLAVE_SPDIF_SLAVE 3 +#define XL_MOST_TIMING_MASTER_SPDIF_MASTER 4 +#define XL_MOST_TIMING_MASTER_SPDIF_SLAVE 5 +#define XL_MOST_TIMING_MASTER_FROM_SPDIF_SLAVE 6 + + +// defines for xlMostSetFrequency and the XL_MOST_FREQUENCY_EV event. +#define XL_MOST_FREQUENCY_44100 0 +#define XL_MOST_FREQUENCY_48000 1 +#define XL_MOST_FREQUENCY_ERROR 2 + +// defines for xlMostSetTxLight +#define XL_MOST_LIGHT_OFF 0 +#define XL_MOST_LIGHT_FORCE_ON 1 // unmodulated on +#define XL_MOST_LIGHT_MODULATED 2 // modulated light + +//defines for xlMostSetTxLightPower and the XL_MOST_TXLIGHT_POWER_EV event. +#define XL_MOST_LIGHT_FULL 100 +#define XL_MOST_LIGHT_3DB 50 + +// defines for the XL_MOST_LOCKSTATUS event +#define XL_MOST_UNLOCK 5 +#define XL_MOST_LOCK 6 +#define XL_MOST_STATE_UNKNOWN 9 + +// defines for the XL_MOST_CTRL_RX_OS8104 event (tx event) +#define XL_MOST_TX_WHILE_UNLOCKED 0x80000000 +#define XL_MOST_TX_TIMEOUT 0x40000000 +#define XL_MOST_DIRECTION_RX 0 +#define XL_MOST_DIRECTION_TX 1 + +#define XL_MOST_NO_QUEUE_OVERFLOW 0x0000 // No rx-queue overflow occured +#define XL_MOST_QUEUE_OVERFLOW 0x8000 // Overflow of rx-queue in firmware when trying to add a rx-event +#define XL_MOST_COMMAND_FAILED 0x4000 +#define XL_MOST_INTERNAL_OVERFLOW 0x2000 // Overflow of command-timestamp-queue in firmware +#define XL_MOST_MEASUREMENT_NOT_ACTIVE 0x1000 +#define XL_MOST_QUEUE_OVERFLOW_ASYNC 0x0800 // Overflow of async rx-queue in firmware when trying to add a packet +#define XL_MOST_QUEUE_OVERFLOW_CTRL 0x0400 // Overflow of rx-queue in firmware when trying to add a message +#define XL_MOST_NOT_SUPPORTED 0x0200 +#define XL_MOST_QUEUE_OVERFLOW_DRV 0x0100 // Overflow occured when trying to add an event to application rx-queue + +#define XL_MOST_NA_CHANGED 0x0001 // node address changed +#define XL_MOST_GA_CHANGED 0x0002 // group address changed +#define XL_MOST_APA_CHANGED 0x0004 // alternative packet address changed +#define XL_MOST_NPR_CHANGED 0x0008 // node position register changed +#define XL_MOST_MPR_CHANGED 0x0010 // max position register changed +#define XL_MOST_NDR_CHANGED 0x0020 // node delay register changed +#define XL_MOST_MDR_CHANGED 0x0040 // max delay register changed +#define XL_MOST_SBC_CHANGED 0x0080 // +#define XL_MOST_XTIM_CHANGED 0x0100 // +#define XL_MOST_XRTY_CHANGED 0x0200 // + +// defines for the MOST register (xlMostWriteRegister) +#define XL_MOST_bGA 0x89 // Group Address +#define XL_MOST_bNAH 0x8A // Node Address High +#define XL_MOST_bNAL 0x8B // Node Address Low +#define XL_MOST_bSDC2 0x8C // Source Data Control 2 +#define XL_MOST_bSDC3 0x8D // Source Data Control 3 +#define XL_MOST_bCM2 0x8E // Clock Manager 2 +#define XL_MOST_bNDR 0x8F // Node Delay +#define XL_MOST_bMPR 0x90 // Maximum Position +#define XL_MOST_bMDR 0x91 // Maximum Delay +#define XL_MOST_bCM4 0x93 // Clock Manager 4 +#define XL_MOST_bSBC 0x96 // Synchronous Bandwidth Control +#define XL_MOST_bXSR2 0x97 // Transceiver Status 2 + +#define XL_MOST_bRTYP 0xA0 // Receive Message Type +#define XL_MOST_bRSAH 0xA1 // Source Address High +#define XL_MOST_bRSAL 0xA2 // Source Address Low +#define XL_MOST_bRCD0 0xA3 // Receive Control Data 0 --> bRCD16 = bRCD0+16 + +#define XL_MOST_bXTIM 0xBE // Transmit Retry Time +#define XL_MOST_bXRTY 0xBF // Transmit Retries + +#define XL_MOST_bXPRI 0xC0 // Transmit Priority +#define XL_MOST_bXTYP 0xC1 // Transmit Message Type +#define XL_MOST_bXTAH 0xC2 // Target Address High +#define XL_MOST_bXTAL 0xC3 // Target Address Low +#define XL_MOST_bXCD0 0xC4 // Transmit Control Data 0 --> bXCD16 = bXCD0+16 + +#define XL_MOST_bXTS 0xD5 // Transmit Transfer Status + +#define XL_MOST_bPCTC 0xE2 // Packet Control +#define XL_MOST_bPCTS 0xE3 // Packet Status + +// defines +#define XL_MOST_SPY_RX_STATUS_NO_LIGHT 0x01 +#define XL_MOST_SPY_RX_STATUS_NO_LOCK 0x02 +#define XL_MOST_SPY_RX_STATUS_BIPHASE_ERROR 0x04 +#define XL_MOST_SPY_RX_STATUS_MESSAGE_LENGTH_ERROR 0x08 +#define XL_MOST_SPY_RX_STATUS_PARITY_ERROR 0x10 +#define XL_MOST_SPY_RX_STATUS_FRAME_LENGTH_ERROR 0x20 +#define XL_MOST_SPY_RX_STATUS_PREAMBLE_TYPE_ERROR 0x40 +#define XL_MOST_SPY_RX_STATUS_CRC_ERROR 0x80 + +// defines for status of async frames +#define XL_MOST_ASYNC_NO_ERROR 0x00 +#define XL_MOST_ASYNC_SBC_ERROR 0x0C +#define XL_MOST_ASYNC_NEXT_STARTS_TO_EARLY 0x0D +#define XL_MOST_ASYNC_TO_LONG 0x0E + +#define XL_MOST_ASYNC_UNLOCK 0x0F // unlock occured within receiption of packet + +// defines for XL_MOST_SYNC_PULSE_EV member trigger_source +#define SYNC_PULSE_EXTERNAL 0x00 +#define SYNC_PULSE_OUR 0x01 + +// ctrlType value within the XL_CTRL_SPY event +#define XL_MOST_CTRL_TYPE_NORMAL 0x00 +#define XL_MOST_CTRL_TYPE_REMOTE_READ 0x01 +#define XL_MOST_CTRL_TYPE_REMOTE_WRITE 0x02 +#define XL_MOST_CTRL_TYPE_RESOURCE_ALLOCATE 0x03 +#define XL_MOST_CTRL_TYPE_RESOURCE_DEALLOCATE 0x04 +#define XL_MOST_CTRL_TYPE_GET_SOURCE 0x05 + +// counterType for the xlMost****GenerateBusload function +#define XL_MOST_BUSLOAD_COUNTER_TYPE_NONE 0x00 +#define XL_MOST_BUSLOAD_COUNTER_TYPE_1_BYTE 0x01 +#define XL_MOST_BUSLOAD_COUNTER_TYPE_2_BYTE 0x02 +#define XL_MOST_BUSLOAD_COUNTER_TYPE_3_BYTE 0x03 +#define XL_MOST_BUSLOAD_COUNTER_TYPE_4_BYTE 0x04 + +// selection bits for xlMostGetDeviceStates / CMD_GET_DEVICE_STATE->selection_mask +#define XL_MOST_STATESEL_LIGHTLOCK 0x0001 +#define XL_MOST_STATESEL_REGISTERBUNCH1 0x0002 +#define XL_MOST_STATESEL_BYPASSTIMING 0x0004 +#define XL_MOST_STATESEL_REGISTERBUNCH2 0x0008 +#define XL_MOST_STATESEL_REGISTERBUNCH3 0x0010 +#define XL_MOST_STATESEL_VOLUMEMUTE 0x0020 +#define XL_MOST_STATESEL_EVENTSOURCE 0x0040 +#define XL_MOST_STATESEL_RXBUFFERMODE 0x0080 +#define XL_MOST_STATESEL_ALLOCTABLE 0x0100 +#define XL_MOST_STATESEL_SUPERVISOR_LOCKSTATUS 0x0200 +#define XL_MOST_STATESEL_SUPERVISOR_MESSAGE 0x0400 + +// defines for sync data streaming +#define XL_MOST_STREAM_RX_DATA 0 // RX streaming: MOST -> PC +#define XL_MOST_STREAM_TX_DATA 1 // TX streaming: PC -> MOST + +#define XL_MOST_STREAM_ADD_FRAME_HEADER 1 // only for RX: additionally the orig. TS + status information are reported + +// stream states +#define XL_MOST_STREAM_STATE_CLOSED 0x01 +#define XL_MOST_STREAM_STATE_OPENED 0x02 +#define XL_MOST_STREAM_STATE_STARTED 0x03 +#define XL_MOST_STREAM_STATE_STOPPED 0x04 +#define XL_MOST_STREAM_STATE_START_PENDING 0x05 // waiting for result from hw +#define XL_MOST_STREAM_STATE_STOP_PENDING 0x06 // waiting for result from hw +#define XL_MOST_STREAM_STATE_UNKNOWN 0xFF + +// stream modes +#define XL_MOST_STREAM_ACTIVATE 0 +#define XL_MOST_STREAM_DEACTIVATE 1 + +#define XL_MOST_STREAM_INVALID_HANDLE 0 + +// latency values +#define XL_MOST_STREAM_LATENCY_VERY_LOW 0 +#define XL_MOST_STREAM_LATENCY_LOW 1 +#define XL_MOST_STREAM_LATENCY_MEDIUM 2 +#define XL_MOST_STREAM_LATENCY_HIGH 3 +#define XL_MOST_STREAM_LATENCY_VERY_HIGH 4 + +// error defines for sync data streaming +#define XL_MOST_STREAM_ERR_NO_ERROR 0x00 +#define XL_MOST_STREAM_ERR_INVALID_HANDLE 0x01 +#define XL_MOST_STREAM_ERR_NO_MORE_BUFFERS_AVAILABLE 0x02 +#define XL_MOST_STREAM_ERR_ANY_BUFFER_LOCKED 0x03 +#define XL_MOST_STREAM_ERR_WRITE_RE_FAILED 0x04 +#define XL_MOST_STREAM_ERR_STREAM_ALREADY_STARTED 0x05 +#define XL_MOST_STREAM_ERR_TX_BUFFER_UNDERRUN 0x06 +#define XL_MOST_STREAM_ERR_RX_BUFFER_OVERFLOW 0x07 +#define XL_MOST_STREAM_ERR_INSUFFICIENT_RESOURCES 0x08 + + +#include +// ------------------------------------------------------------- +// Structures for MOST events +// ------------------------------------------------------------- + +typedef struct s_xl_most_ctrl_spy { + unsigned int arbitration; + unsigned short targetAddress; + unsigned short sourceAddress; + unsigned char ctrlType; + unsigned char ctrlData[17]; + unsigned short crc; + unsigned short txStatus; + unsigned short ctrlRes; + unsigned int spyRxStatus; +} XL_MOST_CTRL_SPY_EV; + +typedef struct s_xl_most_ctrl_msg { + unsigned char ctrlPrio; + unsigned char ctrlType; + unsigned short targetAddress; + unsigned short sourceAddress; + unsigned char ctrlData[17]; + unsigned char direction; // transmission or real receiption + unsigned int status; // unused for real rx msgs +} XL_MOST_CTRL_MSG_EV; + +typedef struct s_xl_most_async_msg { + unsigned int status; // read as last data from PLD but stored first + unsigned int crc; // not used + unsigned char arbitration; + unsigned char length; // real length of async data in quadlets + unsigned short targetAddress; + unsigned short sourceAddress; + unsigned char asyncData[1018]; // max size but only used data is transmitted to pc +} XL_MOST_ASYNC_MSG_EV; + +typedef struct s_xl_most_async_tx { + unsigned char arbitration; + unsigned char length; // real length of async data in quadlets + unsigned short targetAddress; + unsigned short sourceAddress; + unsigned char asyncData[1014]; // worst case +} XL_MOST_ASYNC_TX_EV; + +typedef struct s_xl_most_special_register { + unsigned int changeMask; // see defines "XL_MOST_..._CHANGED" + unsigned int lockStatus; + unsigned char register_bNAH; + unsigned char register_bNAL; + unsigned char register_bGA; + unsigned char register_bAPAH; + unsigned char register_bAPAL; + unsigned char register_bNPR; + unsigned char register_bMPR; + unsigned char register_bNDR; + unsigned char register_bMDR; + unsigned char register_bSBC; + unsigned char register_bXTIM; + unsigned char register_bXRTY; +} XL_MOST_SPECIAL_REGISTER_EV; + +typedef struct s_xl_most_event_source { + unsigned int mask; + unsigned int state; +} XL_MOST_EVENT_SOURCE_EV; + +typedef struct s_xl_most_all_bypass { + unsigned int bypassState; +} XL_MOST_ALL_BYPASS_EV; + +typedef struct s_xl_most_timing_mode { + unsigned int timingmode; +} XL_MOST_TIMING_MODE_EV; + +typedef struct s_xl_most_timing_mode_spdif { + unsigned int timingmode; +} XL_MOST_TIMING_MODE_SPDIF_EV; + +typedef struct s_xl_most_frequency { + unsigned int frequency; +} XL_MOST_FREQUENCY_EV; + +typedef struct s_xl_most_register_bytes { + unsigned int number; + unsigned int address; + unsigned char value[16]; +} XL_MOST_REGISTER_BYTES_EV; + +typedef struct s_xl_most_register_bits { + unsigned int address; + unsigned int value; + unsigned int mask; +} XL_MOST_REGISTER_BITS_EV; + +typedef struct s_xl_most_sync_alloc { + unsigned char allocTable[MOST_ALLOC_TABLE_SIZE]; +} XL_MOST_SYNC_ALLOC_EV; + +typedef struct s_xl_most_ctrl_sync_audio { + unsigned int channelMask[4]; + unsigned int device; + unsigned int mode; +} XL_MOST_CTRL_SYNC_AUDIO_EV; + +typedef struct s_xl_most_ctrl_sync_audio_ex { + unsigned int channelMask[16]; + unsigned int device; + unsigned int mode; +} XL_MOST_CTRL_SYNC_AUDIO_EX_EV; + +typedef struct s_xl_most_sync_volume_status { + unsigned int device; + unsigned int volume; +} XL_MOST_SYNC_VOLUME_STATUS_EV; + +typedef struct s_xl_most_sync_mutes_status { + unsigned int device; + unsigned int mute; +} XL_MOST_SYNC_MUTES_STATUS_EV; + +typedef struct s_xl_most_rx_light { + unsigned int light; +} XL_MOST_RX_LIGHT_EV; + +typedef struct s_xl_most_tx_light { + unsigned int light; +} XL_MOST_TX_LIGHT_EV; + +typedef struct s_xl_most_light_power { + unsigned int lightPower; +} XL_MOST_LIGHT_POWER_EV; + +typedef struct s_xl_most_lock_status { + unsigned int lockStatus; +} XL_MOST_LOCK_STATUS_EV; + +typedef struct s_xl_most_supervisor_lock_status { + unsigned int supervisorLockStatus; +} XL_MOST_SUPERVISOR_LOCK_STATUS_EV; + +typedef struct s_xl_most_gen_light_error { + unsigned int lightOnTime; + unsigned int lightOffTime; + unsigned int repeat; +} XL_MOST_GEN_LIGHT_ERROR_EV; + +typedef struct s_xl_most_gen_lock_error { + unsigned int lockOnTime; + unsigned int lockOffTime; + unsigned int repeat; +} XL_MOST_GEN_LOCK_ERROR_EV; + +typedef struct s_xl_most_rx_buffer { + unsigned int mode; +} XL_MOST_RX_BUFFER_EV; + +typedef struct s_xl_most_error { + unsigned int errorCode; + unsigned int parameter[3]; +} XL_MOST_ERROR_EV; + +typedef XL_SYNC_PULSE_EV XL_MOST_SYNC_PULSE_EV; + +typedef struct s_xl_most_ctrl_busload { + unsigned int busloadCtrlStarted; +} XL_MOST_CTRL_BUSLOAD_EV; + +typedef struct s_xl_most_async_busload { + unsigned int busloadAsyncStarted; +} XL_MOST_ASYNC_BUSLOAD_EV; + +typedef struct s_xl_most_stream_state { + unsigned int streamHandle; + unsigned int streamState; // see XL_MOST_STREAM_STATE_... + unsigned int streamError; // see XL_MOST_STREAM_ERR_... + unsigned int reserved; +} XL_MOST_STREAM_STATE_EV; + +typedef struct s_xl_most_stream_buffer { + unsigned int streamHandle; +#ifdef _MSC_VER + unsigned char *POINTER_32 pBuffer; // 32bit LSDW of buffer pointer +#else + unsigned int pBuffer; // 32bit LSDW of buffer pointer +#endif + unsigned int validBytes; + unsigned int status; // // see XL_MOST_STREAM_ERR_... + unsigned int pBuffer_highpart; +} XL_MOST_STREAM_BUFFER_EV; + + +typedef struct s_xl_most_sync_tx_underflow { + unsigned int streamHandle; + unsigned int reserved; +} XL_MOST_SYNC_TX_UNDERFLOW_EV; + +typedef struct s_xl_most_sync_rx_overflow { + unsigned int streamHandle; + unsigned int reserved; +} XL_MOST_SYNC_RX_OVERFLOW_EV; + +#define XL_MOST_EVENT_HEADER_SIZE 32 +#define XL_MOST_EVENT_MAX_DATA_SIZE 1024 +#define XL_MOST_EVENT_MAX_SIZE (XL_MOST_EVENT_HEADER_SIZE + XL_MOST_EVENT_MAX_DATA_SIZE) + +// rx event definition +union s_xl_most_tag_data { + XL_MOST_CTRL_SPY_EV mostCtrlSpy; + XL_MOST_CTRL_MSG_EV mostCtrlMsg; + XL_MOST_ASYNC_MSG_EV mostAsyncMsg; // received async frame + XL_MOST_ASYNC_TX_EV mostAsyncTx; // async frame tx acknowledge + XL_MOST_SPECIAL_REGISTER_EV mostSpecialRegister; + XL_MOST_EVENT_SOURCE_EV mostEventSource; + XL_MOST_ALL_BYPASS_EV mostAllBypass; + XL_MOST_TIMING_MODE_EV mostTimingMode; + XL_MOST_TIMING_MODE_SPDIF_EV mostTimingModeSpdif; + XL_MOST_FREQUENCY_EV mostFrequency; + XL_MOST_REGISTER_BYTES_EV mostRegisterBytes; + XL_MOST_REGISTER_BITS_EV mostRegisterBits; + XL_MOST_SYNC_ALLOC_EV mostSyncAlloc; + XL_MOST_CTRL_SYNC_AUDIO_EV mostCtrlSyncAudio; + XL_MOST_CTRL_SYNC_AUDIO_EX_EV mostCtrlSyncAudioEx; + XL_MOST_SYNC_VOLUME_STATUS_EV mostSyncVolumeStatus; + XL_MOST_SYNC_MUTES_STATUS_EV mostSyncMuteStatus; + XL_MOST_RX_LIGHT_EV mostRxLight; + XL_MOST_TX_LIGHT_EV mostTxLight; + XL_MOST_LIGHT_POWER_EV mostLightPower; + XL_MOST_LOCK_STATUS_EV mostLockStatus; + XL_MOST_GEN_LIGHT_ERROR_EV mostGenLightError; + XL_MOST_GEN_LOCK_ERROR_EV mostGenLockError; + XL_MOST_RX_BUFFER_EV mostRxBuffer; + XL_MOST_ERROR_EV mostError; + XL_MOST_SYNC_PULSE_EV mostSyncPulse; + XL_MOST_CTRL_BUSLOAD_EV mostCtrlBusload; + XL_MOST_ASYNC_BUSLOAD_EV mostAsyncBusload; + XL_MOST_STREAM_STATE_EV mostStreamState; + XL_MOST_STREAM_BUFFER_EV mostStreamBuffer; + XL_MOST_SYNC_TX_UNDERFLOW_EV mostSyncTxUnderflow; + XL_MOST_SYNC_RX_OVERFLOW_EV mostSyncRxOverflow; +}; + + +typedef unsigned short XLmostEventTag; + +struct s_xl_most_event { + unsigned int size; // 4 - overall size of the complete event + XLmostEventTag tag; // 2 - type of the event + unsigned short channelIndex; // 2 + unsigned int userHandle; // 4 - internal use only + unsigned short flagsChip; // 2 + unsigned short reserved; // 2 + XLuint64 timeStamp; // 8 + XLuint64 timeStampSync; // 8 + // --------- + // 32 bytes -> XL_MOST_EVENT_HEADER_SIZE + union s_xl_most_tag_data tagData; +}; + +typedef struct s_xl_most_event XLmostEvent; + +typedef XL_MOST_CTRL_MSG_EV XLmostCtrlMsg; +typedef XL_MOST_ASYNC_TX_EV XLmostAsyncMsg; + +typedef struct s_xl_most_ctrl_busload_configuration { + unsigned int transmissionRate; + unsigned int counterType; + unsigned int counterPosition; + XL_MOST_CTRL_MSG_EV busloadCtrlMsg; +} XL_MOST_CTRL_BUSLOAD_CONFIGURATION; + + +typedef struct s_xl_most_async_busload_configuration { + unsigned int transmissionRate; + unsigned int counterType; + unsigned int counterPosition; + XL_MOST_ASYNC_TX_EV busloadAsyncMsg; +} XL_MOST_ASYNC_BUSLOAD_CONFIGURATION; + +typedef XL_MOST_CTRL_BUSLOAD_CONFIGURATION XLmostCtrlBusloadConfiguration; +typedef XL_MOST_ASYNC_BUSLOAD_CONFIGURATION XLmostAsyncBusloadConfiguration; + +typedef struct s_xl_most_device_state { + unsigned int selectionMask; + // XL_MOST_STATESEL_LIGHTLOCK + unsigned int lockState; // see XL_MOST_LOCK_STATUS_EV + unsigned int rxLight; // see XL_MOST_RX_LIGHT_EV + unsigned int txLight; // see XL_MOST_TX_LIGHT_EV + unsigned int txLightPower; // see XL_MOST_LIGHT_POWER_EV + // XL_MOST_STATESEL_REGISTERBUNCH1 + unsigned char registerBunch1[16]; // 16 OS8104 registers (0x87...0x96 -> NPR...SBC) + // XL_MOST_STATESEL_BYPASSTIMING + unsigned int bypassState; // see XL_MOST_ALL_BYPASS_EV + unsigned int timingMode; // see XL_MOST_TIMING_MODE_EV + unsigned int frequency; // frame rate (if master); see XL_MOST_FREQUENCY_EV + // XL_MOST_STATESEL_REGISTERBUNCH2 + unsigned char registerBunch2[2]; // 2 OS8104 registers (0xBE, 0xBF -> XTIM, XRTY) + // XL_MOST_STATESEL_REGISTERBUNCH3 + unsigned char registerBunch3[2]; // 2 OS8104 registers (0xE8, 0xE9 -> APAH, APAL) + // XL_MOST_STATESEL_VOLUMEMUTE + unsigned int volume[2]; // volume state for DEVICE_CASE_LINE_IN, DEVICE_CASE_LINE_OUT + unsigned int mute[2]; // mute state for DEVICE_CASE_LINE_IN, DEVICE_CASE_LINE_OUT + // XL_MOST_STATESEL_EVENTSOURCE + unsigned int eventSource; // see XL_MOST_EVENT_SOURCE_EV + // XL_MOST_STATESEL_RXBUFFERMODE + unsigned int rxBufferMode; // see XL_MOST_RX_BUFFER_EV + // XL_MOST_STATESEL_ALLOCTABLE + unsigned char allocTable[MOST_ALLOC_TABLE_SIZE]; // see XL_MOST_SYNC_ALLOC_EV + // XL_MOST_STATESEL_SUPERVISOR_LOCKSTATUS + unsigned int supervisorLockStatus; + // XL_MOST_STATESEL_SUPERVISOR_MESSAGE + unsigned int broadcastedConfigStatus; + unsigned int adrNetworkMaster; + unsigned int abilityToWake; +} XL_MOST_DEVICE_STATE; + +typedef XL_MOST_DEVICE_STATE XLmostDeviceState; + +typedef struct s_xl_most_stream_open { + unsigned int* pStreamHandle; + unsigned int numSyncChannels; + unsigned int direction; + unsigned int options; + unsigned int latency; +} XL_MOST_STREAM_OPEN; + +typedef XL_MOST_STREAM_OPEN XLmostStreamOpen; + +typedef struct s_xl_most_stream_info { + unsigned int streamHandle; + unsigned int numSyncChannels; + unsigned int direction; + unsigned int options; + unsigned int latency; + unsigned int streamState; + unsigned int reserved; + unsigned char syncChannels[60]; +} XL_MOST_STREAM_INFO; + +typedef XL_MOST_STREAM_INFO XLmostStreamInfo; + + +#include +#include + +///////////////////////////////////////////////////////////////////////////////////////////////////////// +// FlexRay XL API +///////////////////////////////////////////////////////////////////////////////////////////////////////// + +#define XL_FR_MAX_DATA_LENGTH 254 + + +///////////////////////////////////////////////////////////////////////////////////////////////////////// +// function structures +///////////////////////////////////////////////////////////////////////////////////////////////////////// + + +// structure for xlFrSetConfiguration +typedef struct s_xl_fr_cluster_configuration { + + unsigned int busGuardianEnable; + unsigned int baudrate; + unsigned int busGuardianTick; + unsigned int externalClockCorrectionMode; + unsigned int gColdStartAttempts; + unsigned int gListenNoise; + unsigned int gMacroPerCycle; + unsigned int gMaxWithoutClockCorrectionFatal; + unsigned int gMaxWithoutClockCorrectionPassive; + unsigned int gNetworkManagementVectorLength; + unsigned int gNumberOfMinislots; + unsigned int gNumberOfStaticSlots; + unsigned int gOffsetCorrectionStart; + unsigned int gPayloadLengthStatic; + unsigned int gSyncNodeMax; + unsigned int gdActionPointOffset; + unsigned int gdDynamicSlotIdlePhase; + unsigned int gdMacrotick; + unsigned int gdMinislot; + unsigned int gdMiniSlotActionPointOffset; + unsigned int gdNIT; + unsigned int gdStaticSlot; + unsigned int gdSymbolWindow; + unsigned int gdTSSTransmitter; + unsigned int gdWakeupSymbolRxIdle; + unsigned int gdWakeupSymbolRxLow; + unsigned int gdWakeupSymbolRxWindow; + unsigned int gdWakeupSymbolTxIdle; + unsigned int gdWakeupSymbolTxLow; + unsigned int pAllowHaltDueToClock; + unsigned int pAllowPassiveToActive; + unsigned int pChannels; + unsigned int pClusterDriftDamping; + unsigned int pDecodingCorrection; + unsigned int pDelayCompensationA; + unsigned int pDelayCompensationB; + unsigned int pExternOffsetCorrection; + unsigned int pExternRateCorrection; + unsigned int pKeySlotUsedForStartup; + unsigned int pKeySlotUsedForSync; + unsigned int pLatestTx; + unsigned int pMacroInitialOffsetA; + unsigned int pMacroInitialOffsetB; + unsigned int pMaxPayloadLengthDynamic; + unsigned int pMicroInitialOffsetA; + unsigned int pMicroInitialOffsetB; + unsigned int pMicroPerCycle; + unsigned int pMicroPerMacroNom; + unsigned int pOffsetCorrectionOut; + unsigned int pRateCorrectionOut; + unsigned int pSamplesPerMicrotick; + unsigned int pSingleSlotEnabled; + unsigned int pWakeupChannel; + unsigned int pWakeupPattern; + unsigned int pdAcceptedStartupRange; + unsigned int pdListenTimeout; + unsigned int pdMaxDrift; + unsigned int pdMicrotick; + unsigned int gdCASRxLowMax; + unsigned int gChannels; + unsigned int vExternOffsetControl; + unsigned int vExternRateControl; + unsigned int pChannelsMTS; + + unsigned int framePresetData; //!< 16-bit value with data for pre-initializing the Flexray payload data words + + unsigned int reserved[15]; +} XLfrClusterConfig; + + +// structure and defines for function xlFrGetChannelConfig +typedef struct s_xl_fr_channel_config { + unsigned int status; // XL_FR_CHANNEL_CFG_STATUS_xxx + unsigned int cfgMode; // XL_FR_CHANNEL_CFG_MODE_xxx + unsigned int reserved[6]; + XLfrClusterConfig xlFrClusterConfig; // same as used in function xlFrSetConfig +} XLfrChannelConfig; + +// defines for XLfrChannelConfig::status and XLbusParams::data::flexray::status +#define XL_FR_CHANNEL_CFG_STATUS_INIT_APP_PRESENT ((unsigned int) 0x01) +#define XL_FR_CHANNEL_CFG_STATUS_CHANNEL_ACTIVATED ((unsigned int) 0x02) +#define XL_FR_CHANNEL_CFG_STATUS_VALID_CLUSTER_CFG ((unsigned int) 0x04) +#define XL_FR_CHANNEL_CFG_STATUS_VALID_CFG_MODE ((unsigned int) 0x08) + +// defines for XLfrChannelConfig::cfgMode and XLbusParams::data::flexray::cfgMode +#define XL_FR_CHANNEL_CFG_MODE_SYNCHRONOUS 1 +#define XL_FR_CHANNEL_CFG_MODE_COMBINED 2 +#define XL_FR_CHANNEL_CFG_MODE_ASYNCHRONOUS 3 + + +// defines for xlFrSetMode (frModes) +#define XL_FR_MODE_NORMAL 0x00 //!< setup the VN3000 (eRay) normal operation mode. (default mode) +#define XL_FR_MODE_COLD_NORMAL 0x04 //!< setup the VN3000 (Fujitsu) normal operation mode. (default mode) + +// defines for xlFrSetMode (frStartupAttributes) +#define XL_FR_MODE_NONE 0x00 //!< for normal use +#define XL_FR_MODE_WAKEUP 0x01 //!< for wakeup +#define XL_FR_MODE_COLDSTART_LEADING 0x02 //!< Coldstart path initiating the schedule synchronization +#define XL_FR_MODE_COLDSTART_FOLLOWING 0x03 //!< Coldstart path joining other coldstart nodes +#define XL_FR_MODE_WAKEUP_AND_COLDSTART_LEADING 0x04 //!< Send Wakeup and Coldstart path initiating the schedule synchronization +#define XL_FR_MODE_WAKEUP_AND_COLDSTART_FOLLOWING 0x05 //!< Send Wakeup and Coldstart path joining other coldstart nodes + +// structure for xlFrSetMode +typedef struct s_xl_fr_set_modes { + unsigned int frMode; + unsigned int frStartupAttributes; + unsigned int reserved[30]; +} XLfrMode; + +// defines for xlFrSetupSymbolWindow +#define XL_FR_SYMBOL_MTS 0x01 //!< defines a MTS (Media Access Test Symbol) +#define XL_FR_SYMBOL_CAS 0x02 //!< defines a CAS (Collision Avoidance Symbol) + + +// FR transceiver xlFrSetTransceiverMode modes +#define XL_FR_TRANSCEIVER_MODE_SLEEP 0x01 +#define XL_FR_TRANSCEIVER_MODE_NORMAL 0x02 +#define XL_FR_TRANSCEIVER_MODE_RECEIVE_ONLY 0x03 +#define XL_FR_TRANSCEIVER_MODE_STANDBY 0x04 + +// defines for XL_FR_SYNC_PULSE_EV::triggerSource +#define XL_FR_SYNC_PULSE_EXTERNAL XL_SYNC_PULSE_EXTERNAL +#define XL_FR_SYNC_PULSE_OUR XL_SYNC_PULSE_OUR +#define XL_FR_SYNC_PULSE_OUR_SHARED XL_SYNC_PULSE_OUR_SHARED + +// defines for xlFrActivateSpy, mode +#define XL_FR_SPY_MODE_ASYNCHRONOUS 0x01 +#include + +#include + +// defines for xlFrSetAcceptanceFilter +////////////////////////////////////// +// filterStatus +#define XL_FR_FILTER_PASS 0x00000000 //!< maching frame passes the filter +#define XL_FR_FILTER_BLOCK 0x00000001 //!< maching frame is blocked + +// filterTypeMask +#define XL_FR_FILTER_TYPE_DATA 0x00000001 //!< specifies a data frame +#define XL_FR_FILTER_TYPE_NF 0x00000002 //!< specifies a null frame in an used cycle +#define XL_FR_FILTER_TYPE_FILLUP_NF 0x00000004 //!< specifies a null frame in an unused cycle + +// filterChannelMask +#define XL_FR_FILTER_CHANNEL_A 0x00000001 //!< specifies FlexRay channel A for the PC +#define XL_FR_FILTER_CHANNEL_B 0x00000002 //!< specifies FlexRay channel B for the PC +typedef struct s_xl_fr_acceptance_filter { + unsigned int filterStatus; //!< defines if the specified frame should be blocked or pass the filter + unsigned int filterTypeMask; //!< specifies the frame type that should be filtered + unsigned int filterFirstSlot; //!< beginning of the slot range + unsigned int filterLastSlot; //!< end of the slot range (can be the same as filterFirstSlot) + unsigned int filterChannelMask; //!< channel A, B for PC, channel A, B for COB +} XLfrAcceptanceFilter; +#include + +///////////////////////////////////////////////////////////////////////////////////////////////////////// +// Flags for the flagsChip parameter +///////////////////////////////////////////////////////////////////////////////////////////////////////// +#define XL_FR_CHANNEL_A ((unsigned short)0x01) +#define XL_FR_CHANNEL_B ((unsigned short)0x02) +#define XL_FR_CHANNEL_AB ((unsigned short)(XL_FR_CHANNEL_A|XL_FR_CHANNEL_B)) +#define XL_FR_CC_COLD_A ((unsigned short)0x04) //!< second CC channel A to initiate the coldstart +#define XL_FR_CC_COLD_B ((unsigned short)0x08) //!< second CC channel B to initiate the coldstart +#define XL_FR_CC_COLD_AB ((unsigned short)(XL_FR_CC_COLD_A|XL_FR_CC_COLD_B)) +#define XL_FR_SPY_CHANNEL_A ((unsigned short)0x10) //!< Spy mode flags +#define XL_FR_SPY_CHANNEL_B ((unsigned short)0x20) //!< Spy mode flags + +#define XL_FR_QUEUE_OVERFLOW ((unsigned short)0x0100) //!< driver queue overflow + + +///////////////////////////////////////////////////////////////////////////////////////////////////////// +// T_FLEXRAY_FRAME structure flags / defines +///////////////////////////////////////////////////////////////////////////////////////////////////////// +// defines for T_FLEXRAY_FRAME member flags +#define XL_FR_FRAMEFLAG_STARTUP ((unsigned short) 0x0001) //!< indicates a startup frame +#define XL_FR_FRAMEFLAG_SYNC ((unsigned short) 0x0002) //!< indicates a sync frame +#define XL_FR_FRAMEFLAG_NULLFRAME ((unsigned short) 0x0004) //!< indicates a nullframe +#define XL_FR_FRAMEFLAG_PAYLOAD_PREAMBLE ((unsigned short) 0x0008) //!< indicates a present payload preamble bit +#define XL_FR_FRAMEFLAG_FR_RESERVED ((unsigned short) 0x0010) //!< reserved by Flexray protocol + +#define XL_FR_FRAMEFLAG_REQ_TXACK ((unsigned short) 0x0020) //!< used for Tx events only +#define XL_FR_FRAMEFLAG_TXACK_SS XL_FR_FRAMEFLAG_REQ_TXACK //!< indicates TxAck of SingleShot; used for TxAck events only +#define XL_FR_FRAMEFLAG_RX_UNEXPECTED XL_FR_FRAMEFLAG_REQ_TXACK //!< indicates unexpected Rx frame; used for Rx events only + +#define XL_FR_FRAMEFLAG_NEW_DATA_TX ((unsigned short) 0x0040) //!< flag used with TxAcks to indicate first TxAck after data update +#define XL_FR_FRAMEFLAG_DATA_UPDATE_LOST ((unsigned short) 0x0080) //!< flag used with TxAcks indicating that data update has been lost + +#define XL_FR_FRAMEFLAG_SYNTAX_ERROR ((unsigned short) 0x0200) +#define XL_FR_FRAMEFLAG_CONTENT_ERROR ((unsigned short) 0x0400) +#define XL_FR_FRAMEFLAG_SLOT_BOUNDARY_VIOLATION ((unsigned short) 0x0800) +#define XL_FR_FRAMEFLAG_TX_CONFLICT ((unsigned short) 0x1000) +#define XL_FR_FRAMEFLAG_EMPTY_SLOT ((unsigned short) 0x2000) +#define XL_FR_FRAMEFLAG_FRAME_TRANSMITTED ((unsigned short) 0x8000) //!< Only used with TxAcks: Frame has been transmitted. If not set after transmission, an error has occurred. + +// XL_FR_SPY_FRAME_EV event: frameError value +#define XL_FR_SPY_FRAMEFLAG_FRAMING_ERROR ((unsigned char)0x01) +#define XL_FR_SPY_FRAMEFLAG_HEADER_CRC_ERROR ((unsigned char)0x02) +#define XL_FR_SPY_FRAMEFLAG_FRAME_CRC_ERROR ((unsigned char)0x04) +#define XL_FR_SPY_FRAMEFLAG_BUS_ERROR ((unsigned char)0x08) + +// XL_FR_SPY_FRAME_EV event: frameCRC value +#define XL_FR_SPY_FRAMEFLAG_FRAME_CRC_NEW_LAYOUT ((unsigned int)0x80000000) + +// XL_FR_TX_FRAME event: txMode flags +#define XL_FR_TX_MODE_CYCLIC ((unsigned char)0x01) //!< 'normal' cyclic mode +#define XL_FR_TX_MODE_SINGLE_SHOT ((unsigned char)0x02) //!< sends only a single shot +#define XL_FR_TX_MODE_NONE ((unsigned char)0xff) //!< switch off TX + +// XL_FR_TX_FRAME event: incrementSize values +#define XL_FR_PAYLOAD_INCREMENT_8BIT ((unsigned char) 8) +#define XL_FR_PAYLOAD_INCREMENT_16BIT ((unsigned char) 16) +#define XL_FR_PAYLOAD_INCREMENT_32BIT ((unsigned char) 32) +#define XL_FR_PAYLOAD_INCREMENT_NONE ((unsigned char) 0) + +// XL_FR_STATUS event: statusType (POC status) +#define XL_FR_STATUS_DEFAULT_CONFIG 0x00 //!< indicates the actual state of the POC in operation control +#define XL_FR_STATUS_READY 0x01 //!< ... +#define XL_FR_STATUS_NORMAL_ACTIVE 0x02 //!< ... +#define XL_FR_STATUS_NORMAL_PASSIVE 0x03 //!< ... +#define XL_FR_STATUS_HALT 0x04 //!< ... +#define XL_FR_STATUS_MONITOR_MODE 0x05 //!< ... +#define XL_FR_STATUS_CONFIG 0x0f //!< ... + +#define XL_FR_STATUS_WAKEUP_STANDBY 0x10 //!< indicates the actual state of the POC in the wakeup path +#define XL_FR_STATUS_WAKEUP_LISTEN 0x11 //!< ... +#define XL_FR_STATUS_WAKEUP_SEND 0x12 //!< ... +#define XL_FR_STATUS_WAKEUP_DETECT 0x13 //!< ... + +#define XL_FR_STATUS_STARTUP_PREPARE 0x20 //!< indicates the actual state of the POC in the startup path +#define XL_FR_STATUS_COLDSTART_LISTEN 0x21 //!< ... +#define XL_FR_STATUS_COLDSTART_COLLISION_RESOLUTION 0x22 //!< ... +#define XL_FR_STATUS_COLDSTART_CONSISTENCY_CHECK 0x23 //!< ... +#define XL_FR_STATUS_COLDSTART_GAP 0x24 //!< ... +#define XL_FR_STATUS_COLDSTART_JOIN 0x25 //!< ... +#define XL_FR_STATUS_INTEGRATION_COLDSTART_CHECK 0x26 //!< ... +#define XL_FR_STATUS_INTEGRATION_LISTEN 0x27 //!< ... +#define XL_FR_STATUS_INTEGRATION_CONSISTENCY_CHECK 0x28 //!< ... +#define XL_FR_STATUS_INITIALIZE_SCHEDULE 0x29 //!< ... +#define XL_FR_STATUS_ABORT_STARTUP 0x2a //!< ... +#define XL_FR_STATUS_STARTUP_SUCCESS 0x2b //!< ... + +// XL_FR_ERROR event: XL_FR_ERROR_POC_MODE, errorMode +#define XL_FR_ERROR_POC_ACTIVE 0x00 //!< Indicates the actual error mode of the POC: active (green) +#define XL_FR_ERROR_POC_PASSIVE 0x01 //!< Indicates the actual error mode of the POC: passive (yellow) +#define XL_FR_ERROR_POC_COMM_HALT 0x02 //!< Indicates the actual error mode of the POC: comm-halt (red) + +// XL_FR_ERROR event: XL_FR_ERROR_NIT_FAILURE, flags +#define XL_FR_ERROR_NIT_SENA 0x100 //!< Syntax Error during NIT Channel A +#define XL_FR_ERROR_NIT_SBNA 0x200 //!< Slot Boundary Violation during NIT Channel B +#define XL_FR_ERROR_NIT_SENB 0x400 //!< Syntax Error during NIT Channel A +#define XL_FR_ERROR_NIT_SBNB 0x800 //!< Slot Boundary Violation during NIT Channel B + +// XL_FR_ERROR event: XL_FR_ERROR_CLOCK_CORR_FAILURE, flags +#define XL_FR_ERROR_MISSING_OFFSET_CORRECTION 0x00000001 //!< Set if no sync frames were received. -> no offset correction possible. +#define XL_FR_ERROR_MAX_OFFSET_CORRECTION_REACHED 0x00000002 //!< Set if max. offset correction limit is reached. +#define XL_FR_ERROR_MISSING_RATE_CORRECTION 0x00000004 //!< Set if no even/odd sync frames were received -> no rate correction possible. +#define XL_FR_ERROR_MAX_RATE_CORRECTION_REACHED 0x00000008 //!< Set if max. rate correction limit is reached. + +// XL_FR_ERROR event: XL_FR_ERROR_CC_ERROR, erayEir +#define XL_FR_ERROR_CC_PERR 0x00000040 //!< Parity Error, data from MHDS (internal ERay error) +#define XL_FR_ERROR_CC_IIBA 0x00000200 //!< Illegal Input Buffer Access (internal ERay error) +#define XL_FR_ERROR_CC_IOBA 0x00000400 //!< Illegal Output Buffer Access (internal ERay error) +#define XL_FR_ERROR_CC_MHF 0x00000800 //!< Message Handler Constraints Flag data from MHDF (internal ERay error) +#define XL_FR_ERROR_CC_EDA 0x00010000 //!< Error Detection on channel A, data from ACS +#define XL_FR_ERROR_CC_LTVA 0x00020000 //!< Latest Transmit Violation on channel A +#define XL_FR_ERROR_CC_TABA 0x00040000 //!< Transmit Across Boundary on Channel A +#define XL_FR_ERROR_CC_EDB 0x01000000 //!< Error Detection on channel B, data from ACS +#define XL_FR_ERROR_CC_LTVB 0x02000000 //!< Latest Transmit Violation on channel B +#define XL_FR_ERROR_CC_TABB 0x04000000 //!< Transmit Across Boundary on Channel B + +// XL_FR_WAKEUP event: wakeupStatus +#define XL_FR_WAKEUP_UNDEFINED 0x00 //!< No wakeup attempt since CONFIG state was left. (e.g. when a wakeup pattern A|B is received) +#define XL_FR_WAKEUP_RECEIVED_HEADER 0x01 //!< Frame header without coding violation received. +#define XL_FR_WAKEUP_RECEIVED_WUP 0x02 //!< Wakeup pattern on the configured wakeup channel received. +#define XL_FR_WAKEUP_COLLISION_HEADER 0x03 //!< Detected collision during wakeup pattern transmission received. +#define XL_FR_WAKEUP_COLLISION_WUP 0x04 //!< Collision during wakeup pattern transmission received. +#define XL_FR_WAKEUP_COLLISION_UNKNOWN 0x05 //!< Set when the CC stops wakeup. +#define XL_FR_WAKEUP_TRANSMITTED 0x06 //!< Completed the transmission of the wakeup pattern. +#define XL_FR_WAKEUP_EXTERNAL_WAKEUP 0x07 //!< wakeup comes from external +#define XL_FR_WAKEUP_WUP_RECEIVED_WITHOUT_WUS_TX 0x10 //!< wakeupt pattern received from flexray bus +#define XL_FR_WAKEUP_RESERVED 0xFF + +// XL_FR_SYMBOL_WINDOW event: flags +#define XL_FR_SYMBOL_STATUS_SESA 0x01 //!< Syntax Error in Symbol Window Channel A +#define XL_FR_SYMBOL_STATUS_SBSA 0x02 //!< Slot Boundary Violation in Symbol Window Channel A +#define XL_FR_SYMBOL_STATUS_TCSA 0x04 //!< Transmission Conflict in Symbol Window Channel A +#define XL_FR_SYMBOL_STATUS_SESB 0x08 //!< Syntax Error in Symbol Window Channel B +#define XL_FR_SYMBOL_STATUS_SBSB 0x10 //!< Slot Boundary Violation in Symbol Window Channel B +#define XL_FR_SYMBOL_STATUS_TCSB 0x20 //!< Transmission Conflict in Symbol Window Channel B +#define XL_FR_SYMBOL_STATUS_MTSA 0x40 //!< MTS received in Symbol Window Channel A +#define XL_FR_SYMBOL_STATUS_MTSB 0x80 //!< MTS received in Symbol Window Channel B + + +#include + +#define XL_FR_RX_EVENT_HEADER_SIZE 32 +#define XL_FR_MAX_EVENT_SIZE 512 + +///////////////////////////////////////////////////////////////////////////////////////////////////////// +// Structures for FlexRay events +///////////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef struct s_xl_fr_start_cycle { + unsigned int cycleCount; + int vRateCorrection; + int vOffsetCorrection; + unsigned int vClockCorrectionFailed; + unsigned int vAllowPassivToActive; + unsigned int reserved[3]; +} XL_FR_START_CYCLE_EV; + +typedef struct s_xl_fr_rx_frame { + unsigned short flags; + unsigned short headerCRC; + unsigned short slotID; + unsigned char cycleCount; + unsigned char payloadLength; + unsigned char data[XL_FR_MAX_DATA_LENGTH]; +} XL_FR_RX_FRAME_EV; + +typedef struct s_xl_fr_tx_frame { + unsigned short flags; + unsigned short slotID; + unsigned char offset; + unsigned char repetition; + unsigned char payloadLength; + unsigned char txMode; + unsigned char incrementSize; + unsigned char incrementOffset; + unsigned char reserved0; + unsigned char reserved1; + unsigned char data[XL_FR_MAX_DATA_LENGTH]; +} XL_FR_TX_FRAME_EV; + +typedef struct s_xl_fr_wakeup { + unsigned char cycleCount; //!< Actual cyclecount. + unsigned char wakeupStatus; //!< XL_FR_WAKEUP_UNDEFINED, ... + unsigned char reserved[6]; +} XL_FR_WAKEUP_EV; + +typedef struct s_xl_fr_symbol_window { + unsigned int symbol; //!< XL_FR_SYMBOL_MTS, ... + unsigned int flags; //!< XL_FR_SYMBOL_STATUS_SESA, ... + unsigned char cycleCount; //!< Actual cyclecount. + unsigned char reserved[7]; +} XL_FR_SYMBOL_WINDOW_EV; + +typedef struct s_xl_fr_status { + unsigned int statusType; //!< POC status XL_FR_STATUS_ defines like, normal, active... + unsigned int reserved; +} XL_FR_STATUS_EV; + +typedef struct s_xl_fr_nm_vector { + unsigned char nmVector[12]; + unsigned char cycleCount; //!< Actual cyclecount. + unsigned char reserved[3]; +} XL_FR_NM_VECTOR_EV; + +typedef XL_SYNC_PULSE_EV XL_FR_SYNC_PULSE_EV; + +typedef struct s_xl_fr_error_poc_mode { + unsigned char errorMode; //!< error mode like: active, passive, comm_halt + unsigned char reserved[3]; +} XL_FR_ERROR_POC_MODE_EV; + +typedef struct s_xl_fr_error_sync_frames { + unsigned short evenSyncFramesA; //!< valid RX/TX sync frames on frCh A for even cycles + unsigned short oddSyncFramesA; //!< valid RX/TX sync frames on frCh A for odd cycles + unsigned short evenSyncFramesB; //!< valid RX/TX sync frames on frCh B for even cycles + unsigned short oddSyncFramesB; //!< valid RX/TX sync frames on frCh B for odd cycles + unsigned int reserved; +} XL_FR_ERROR_SYNC_FRAMES_EV; + +typedef struct s_xl_fr_error_clock_corr_failure { + unsigned short evenSyncFramesA; //!< valid RX/TX sync frames on frCh A for even cycles + unsigned short oddSyncFramesA; //!< valid RX/TX sync frames on frCh A for odd cycles + unsigned short evenSyncFramesB; //!< valid RX/TX sync frames on frCh B for even cycles + unsigned short oddSyncFramesB; //!< valid RX/TX sync frames on frCh B for odd cycles + unsigned int flags; //!< missing/maximum rate/offset correction flags. + unsigned int clockCorrFailedCounter; //!< E-Ray: CCEV register (CCFC value) + unsigned int reserved; +} XL_FR_ERROR_CLOCK_CORR_FAILURE_EV; + +typedef struct s_xl_fr_error_nit_failure { + unsigned int flags; //!< flags for NIT boundary, syntax error... + unsigned int reserved; +} XL_FR_ERROR_NIT_FAILURE_EV; + +typedef struct s_xl_fr_error_cc_error { + unsigned int ccError; //!< internal CC errors (Transmit Across Boundary, Transmit Violation...) + unsigned int reserved; +} XL_FR_ERROR_CC_ERROR_EV; + +union s_xl_fr_error_info { + XL_FR_ERROR_POC_MODE_EV frPocMode; //!< E-RAY: EIR_PEMC + XL_FR_ERROR_SYNC_FRAMES_EV frSyncFramesBelowMin; //!< E-RAY: EIR_SFBM + XL_FR_ERROR_SYNC_FRAMES_EV frSyncFramesOverload; //!< E-RAY: EIR_SFO + XL_FR_ERROR_CLOCK_CORR_FAILURE_EV frClockCorrectionFailure;//!< E-RAY: EIR_CCF + XL_FR_ERROR_NIT_FAILURE_EV frNitFailure; //!< NIT part of the E_RAY: SWNIT register + XL_FR_ERROR_CC_ERROR_EV frCCError; //!< internal CC error flags (E-RAY: EIR) +}; + +typedef struct s_xl_fr_error { + unsigned char tag; + unsigned char cycleCount; + unsigned char reserved[6]; + union s_xl_fr_error_info errorInfo; +} XL_FR_ERROR_EV; + +typedef struct s_xl_fr_spy_frame { + unsigned int frameLength; + unsigned char frameError; //!< XL_FR_SPY_FRAMEFLAG_XXX values + unsigned char tssLength; + unsigned short headerFlags; + unsigned short slotID; + unsigned short headerCRC; + unsigned char payloadLength; + unsigned char cycleCount; + unsigned short reserved; + unsigned int frameCRC; + unsigned char data[XL_FR_MAX_DATA_LENGTH]; +} XL_FR_SPY_FRAME_EV; + +typedef struct s_xl_fr_spy_symbol { + unsigned short lowLength; + unsigned short reserved; + } XL_FR_SPY_SYMBOL_EV; + + +///////////////////////////////////////////////////////////////////////////////////////////////////////// +// rx event definition +///////////////////////////////////////////////////////////////////////////////////////////////////////// + +union s_xl_fr_tag_data { + XL_FR_START_CYCLE_EV frStartCycle; + XL_FR_RX_FRAME_EV frRxFrame; + XL_FR_TX_FRAME_EV frTxFrame; + XL_FR_WAKEUP_EV frWakeup; + XL_FR_SYMBOL_WINDOW_EV frSymbolWindow; + XL_FR_ERROR_EV frError; + XL_FR_STATUS_EV frStatus; + XL_FR_NM_VECTOR_EV frNmVector; + XL_FR_SYNC_PULSE_EV frSyncPulse; + XL_FR_SPY_FRAME_EV frSpyFrame; + XL_FR_SPY_SYMBOL_EV frSpySymbol; + + XL_APPLICATION_NOTIFICATION_EV applicationNotification; + + unsigned char raw[XL_FR_MAX_EVENT_SIZE - XL_FR_RX_EVENT_HEADER_SIZE]; +}; + +typedef unsigned short XLfrEventTag; + +struct s_xl_fr_event { + unsigned int size; // 4 - overall size of the complete event + XLfrEventTag tag; // 2 - type of the event + unsigned short channelIndex; // 2 + unsigned int userHandle; // 4 + unsigned short flagsChip; // 2 - frChannel e.g. XL_FR_CHANNEL_A (lower 8 bit), queue overflow (upper 8bit) + unsigned short reserved; // 2 + XLuint64 timeStamp; // 8 - raw timestamp + XLuint64 timeStampSync; // 8 - timestamp which is synchronized by the driver + // --------- + // 32 bytes -> XL_FR_RX_EVENT_HEADER_SIZE + union s_xl_fr_tag_data tagData; +}; + +typedef struct s_xl_fr_event XLfrEvent; + + +#include +#include +///////////////////////////////////////////////////////////////////////////////////////////////////////// +// IO XL API +///////////////////////////////////////////////////////////////////////////////////////////////////////// + +// global IO defines +// type defines for XLdaioTriggerMode.portTypeMask +#define XL_DAIO_PORT_TYPE_MASK_DIGITAL 0x01 +#define XL_DAIO_PORT_TYPE_MASK_ANALOG 0x02 + +// type defines for XLdaioTriggerMode.triggerType +#define XL_DAIO_TRIGGER_TYPE_CYCLIC 0x01 +#define XL_DAIO_TRIGGER_TYPE_PORT 0x02 + +/////////////////////////////////////////////// +// defines for xlIoSetTriggerMode +typedef struct s_xl_daio_trigger_mode { + unsigned int portTypeMask; //!< Use defines XL_DAIO_PORT_TYPE_MASK_xxx. Unused for VN1630/VN1640. + unsigned int triggerType; //!< Use defines XL_DAIO_TRIGGER_TYPE_xxx from above + + union triggerTypeParams { + unsigned int cycleTime; //!< specify time in microseconds + struct { + unsigned int portMask; + unsigned int type; //!< Use defines XL_DAIO_TRIGGER_TYPE_xxx from below + } digital; + } param; + +} XLdaioTriggerMode; +#define XL_DAIO_TRIGGER_TYPE_RISING 0x01 +#define XL_DAIO_TRIGGER_TYPE_FALLING 0x02 +#define XL_DAIO_TRIGGER_TYPE_BOTH 0x03 + +/////////////////////////////////////////////// +// defines for xlIoConfigurePorts +typedef struct xl_daio_set_port{ + unsigned int portType; //!< Only one signal group is allowed. One of the defines XL_DAIO_PORT_TYPE_MASK_* + unsigned int portMask; //!< Mask of affected ports. + unsigned int portFunction[8]; //!< Special function of port. One of the defines XL_DAIO_PORT_DIGITAL_* or XL_DAIO_PORT_ANALOG_* + unsigned int reserved[8]; //!< Set this parameters to zero! +} XLdaioSetPort; + +// for digital ports: +#define XL_DAIO_PORT_DIGITAL_IN 0x00 +#define XL_DAIO_PORT_DIGITAL_PUSHPULL 0x01 +#define XL_DAIO_PORT_DIGITAL_OPENDRAIN 0x02 +#define XL_DAIO_PORT_DIGITAL_IN_OUT 0x06 //(only for WakeUp line) + +// for analog ports: +#define XL_DAIO_PORT_ANALOG_IN 0x00 +#define XL_DAIO_PORT_ANALOG_OUT 0x01 +#define XL_DAIO_PORT_ANALOG_DIFF 0x02 +#define XL_DAIO_PORT_ANALOG_OFF 0x03 + +/////////////////////////////////////////////// +// defines for xlIoSetDigOutLevel +#define XL_DAIO_DO_LEVEL_0V 0 +#define XL_DAIO_DO_LEVEL_5V 5 +#define XL_DAIO_DO_LEVEL_12V 12 + +/////////////////////////////////////////////// +// defines for xlIoSetDigitalOutput +typedef struct xl_daio_digital_params{ + unsigned int portMask; //!< Use defines XL_DAIO_PORT_MASK_DIGITAL_* + unsigned int valueMask; //!< Specify the port value (ON/HIGH – 1 | OFF/LOW - 0) +} XLdaioDigitalParams; + +// defines for portMask +#define XL_DAIO_PORT_MASK_DIGITAL_D0 0x01 +#define XL_DAIO_PORT_MASK_DIGITAL_D1 0x02 +#define XL_DAIO_PORT_MASK_DIGITAL_D2 0x04 +#define XL_DAIO_PORT_MASK_DIGITAL_D3 0x08 +#define XL_DAIO_PORT_MASK_DIGITAL_D4 0x10 +#define XL_DAIO_PORT_MASK_DIGITAL_D5 0x20 +#define XL_DAIO_PORT_MASK_DIGITAL_D6 0x40 +#define XL_DAIO_PORT_MASK_DIGITAL_D7 0x80 + +/////////////////////////////////////////////// +// defines for xlIoSetAnalogOutput +typedef struct xl_daio_analog_params { + unsigned int portMask; //!< Use defines XL_DAIO_PORT_MASK_ANALOG_* + unsigned int value[8]; //!< 12-bit values +} XLdaioAnalogParams; + +/////////////////////////////////////////////// +// defines for XLdaioAnalogParams::portMask +#define XL_DAIO_PORT_MASK_ANALOG_A0 0x01 +#define XL_DAIO_PORT_MASK_ANALOG_A1 0x02 +#define XL_DAIO_PORT_MASK_ANALOG_A2 0x04 +#define XL_DAIO_PORT_MASK_ANALOG_A3 0x08 + +/////////////////////////////////////////////// +// event ids +#define XL_DAIO_EVT_ID_DIGITAL XL_DAIO_PORT_TYPE_MASK_DIGITAL +#define XL_DAIO_EVT_ID_ANALOG XL_DAIO_PORT_TYPE_MASK_ANALOG +#include + + +///////////////////////////////////////////////////////////////////////////////////////////////////////// +// Ethernet API +///////////////////////////////////////////////////////////////////////////////////////////////////////// + +#define XL_ETH_EVENT_SIZE_HEADER (unsigned short) 32 +#define XL_ETH_EVENT_SIZE_MAX (unsigned int) 2048 + +#define XL_ETH_RX_FIFO_QUEUE_SIZE_MAX (unsigned int) (8*1024*1024) //!< Maximum size of ethernet receive queue: 8 MByte +#define XL_ETH_RX_FIFO_QUEUE_SIZE_MIN (unsigned int) (64*1024) //!< Minimum size of ethernet receive queue: 64 KByte + +#define XL_ETH_PAYLOAD_SIZE_MAX (unsigned int) 1500 // maximum payload length for sending an ethernet packet +#define XL_ETH_PAYLOAD_SIZE_MIN (unsigned int) 46 // minimum payload length for sending an ethernet packet (42 octets with VLAN tag present) +#define XL_ETH_RAW_FRAME_SIZE_MAX (unsigned int) 1600 // maximum buffer size for storing a "raw" Ethernet frame (including VLAN tags, if present) + +//////////////////////////////////////////////// +// Infos in the flagsChip parameter of Ethernet events +//////////////////////////////////////////////// +#define XL_ETH_CONNECTOR_RJ45 (unsigned short) 0x0001 +#define XL_ETH_CONNECTOR_DSUB (unsigned short) 0x0002 +#define XL_ETH_PHY_IEEE (unsigned short) 0x0004 +#define XL_ETH_PHY_BROADR (unsigned short) 0x0008 +#define XL_ETH_FRAME_BYPASSED (unsigned short) 0x0010 // For Rx and RxError events +#define XL_ETH_QUEUE_OVERFLOW (unsigned short) 0x0100 +#define XL_ETH_BYPASS_QUEUE_OVERFLOW (unsigned short) 0x8000 //MAC bypass queue full condition occurred, one or more packets dropped + +#define XL_ETH_MACADDR_OCTETS 6 +#define XL_ETH_ETHERTYPE_OCTETS 2 +#define XL_ETH_VLANTAG_OCTETS 4 + +//////////////////////////////////////////////// +// Values for xlEthSetConfig +//////////////////////////////////////////////// + +// speed +#define XL_ETH_MODE_SPEED_AUTO_100 2 /* Set connection speed set to 100 Mbps via auto-negotiation */ +#define XL_ETH_MODE_SPEED_AUTO_1000 4 /* Set connection speed to 1000 Mbps via auto-negotiation */ +#define XL_ETH_MODE_SPEED_AUTO_100_1000 5 /* Set connection speed automatically to either 100 or 1000 Mbps */ +#define XL_ETH_MODE_SPEED_FIXED_100 8 /* Set connection speed to 100 Mbps. Auto-negotiation disabled. */ + +// duplex +#define XL_ETH_MODE_DUPLEX_DONT_CARE 0 /* Used for BroadR-Reach since only full duplex mode possible. */ +#define XL_ETH_MODE_DUPLEX_AUTO 1 /* Duplex mode set via auto-negotiation. Requires connection speed set to an "auto" value. Only for IEEE 802.3*/ +#define XL_ETH_MODE_DUPLEX_FULL 3 /* Full duplex mode. Only for IEEE 802.3 */ + +// connector +#define XL_ETH_MODE_CONNECTOR_RJ45 1 /* Using RJ-45 connector */ +#define XL_ETH_MODE_CONNECTOR_DSUB 2 /* Using D-Sub connector */ + +// phy +#define XL_ETH_MODE_PHY_IEEE_802_3 1 /* Set IEEE 802.3 */ +#define XL_ETH_MODE_PHY_BROADR_REACH 2 /* Set BroadR-Reach */ + +// clockMode +#define XL_ETH_MODE_CLOCK_DONT_CARE 0 /* Used for IEEE 802.3 100 and 10 MBit */ +#define XL_ETH_MODE_CLOCK_AUTO 1 /* Clock mode set automatically via auto-negotiation. Only for 1000Base-T if speed mode is one of the "auto" modes */ +#define XL_ETH_MODE_CLOCK_MASTER 2 /* Clock mode is master. Only for 1000Base-T or BroadR-Reach */ +#define XL_ETH_MODE_CLOCK_SLAVE 3 /* Clock mode is slave. Only for 1000Base-T or BroadR-Reach */ + +// mdiMode +#define XL_ETH_MODE_MDI_AUTO 1 /* Perform MDI auto detection */ +#define XL_ETH_MODE_MDI_STRAIGHT 2 /* Direct MDI (connected to switch) */ +#define XL_ETH_MODE_MDI_CROSSOVER 3 /* Crossover MDI (connected to endpoint) */ + +// brPairs +#define XL_ETH_MODE_BR_PAIR_DONT_CARE 0 /* Used for IEEE 802.3 */ +#define XL_ETH_MODE_BR_PAIR_1PAIR 1 /* BR 1-pair connection. Only for BroadR-Reach */ + + +//////////////////////////////////////////////// + + +//////////////////////////////////////////////// +// Values for T_XL_ETH_CHANNEL_STATUS event +//////////////////////////////////////////////// + +// T_XL_ETH_CHANNEL_STATUS.link +#define XL_ETH_STATUS_LINK_UNKNOWN 0 /* The link state could not be determined (e.g. lost connection to board) */ +#define XL_ETH_STATUS_LINK_DOWN 1 /* Link is down (no cable attached, no configuration set, configuration does not match) */ +#define XL_ETH_STATUS_LINK_UP 2 /* Link is up */ +#define XL_ETH_STATUS_LINK_ERROR 4 /* Link is in error state (e.g. auto-negotiation failed) */ + +// T_XL_ETH_CHANNEL_STATUS.speed +#define XL_ETH_STATUS_SPEED_UNKNOWN 0 /* Connection speed could not be determined (e.g. during auto-negotiation or if link down) */ +#define XL_ETH_STATUS_SPEED_100 2 /* Link speed is 100 Mbps */ +#define XL_ETH_STATUS_SPEED_1000 3 /* Link speed is 1000 Mbps */ + +// T_XL_ETH_CHANNEL_STATUS.duplex +#define XL_ETH_STATUS_DUPLEX_UNKNOWN 0 /* Duplex mode could not be determined (e.g. during auto-negotiation or if link down) */ +#define XL_ETH_STATUS_DUPLEX_FULL 2 /* Full duplex mode */ + +// T_XL_ETH_CHANNEL_STATUS.mdiType +#define XL_ETH_STATUS_MDI_UNKNOWN 0 /* MDI mode could not be determined (e.g. during auto-negotiation or if link down) */ +#define XL_ETH_STATUS_MDI_STRAIGHT 1 /* Direct MDI */ +#define XL_ETH_STATUS_MDI_CROSSOVER 2 /* Crossover MDI */ + +// T_XL_ETH_CHANNEL_STATUS.activeConnector +#define XL_ETH_STATUS_CONNECTOR_RJ45 1 /* Using RJ-45 connector */ +#define XL_ETH_STATUS_CONNECTOR_DSUB 2 /* Using D-Sub connector */ + +// T_XL_ETH_CHANNEL_STATUS.activePhy +#define XL_ETH_STATUS_PHY_UNKNOWN 0 /* PHY is currently uhknown (e.g. if link is down) */ +#define XL_ETH_STATUS_PHY_IEEE_802_3 1 /* PHY is IEEE 802.3 */ +#define XL_ETH_STATUS_PHY_BROADR_REACH 2 /* PHY is BroadR-Reach */ + +// T_XL_ETH_CHANNEL_STATUS.clockMode +#define XL_ETH_STATUS_CLOCK_DONT_CARE 0 /* Clock mode not relevant. Only for IEEE 802.3 100/10 MBit */ +#define XL_ETH_STATUS_CLOCK_MASTER 1 /* Clock mode is master. Only for 1000Base-T or BroadR-Reach */ +#define XL_ETH_STATUS_CLOCK_SLAVE 2 /* Clock mode is slave. Only for 1000Base-T or BroadR-Reach */ + +// T_XL_ETH_CHANNEL_STATUS.brPairs +#define XL_ETH_STATUS_BR_PAIR_DONT_CARE 0 /* No BR pair available. Only for IEEE 802.3 1000/100/10 MBit */ +#define XL_ETH_STATUS_BR_PAIR_1PAIR 1 /* BR 1-pair connection. Only for BroadR-Reach */ + + +//////////////////////////////////////////////// + +// T_XL_ETH_DATAFRAME_RX_ERROR.errorFlags +#define XL_ETH_RX_ERROR_INVALID_LENGTH ((unsigned int) 0x00000001) /* Invalid length error. Set when the receive frame has an invalid length as defined by IEEE802.3 */ +#define XL_ETH_RX_ERROR_INVALID_CRC ((unsigned int) 0x00000002) /* CRC error. Set when frame is received with CRC-32 error but valid length */ +#define XL_ETH_RX_ERROR_PHY_ERROR ((unsigned int) 0x00000004) /* Corrupted receive frame caused by a PHY error */ + +// T_XL_ETH_DATAFRAME_TX.flags +// T_XL_ETH_DATAFRAME_TXACK.flags +// T_XL_ETH_DATAFRAME_TXACK_OTHERAPP.flags +// T_XL_ETH_DATAFRAME_TXACK_SW.flags +#define XL_ETH_DATAFRAME_FLAGS_USE_SOURCE_MAC (unsigned int) 0x00000001 /* Use the given source MAC address (not set by hardware) */ + +// Bypass values +#define XL_ETH_BYPASS_INACTIVE 0 /* Bypass inactive (default state) */ +#define XL_ETH_BYPASS_PHY 1 /* Bypass active via PHY loop */ +#define XL_ETH_BYPASS_MACCORE 2 /* Bypass active via L2 switch (using MAC cores) */ + +// T_XL_ETH_DATAFRAME_TX_ERROR.errorType +// T_XL_ETH_DATAFRAME_TX_ERR_SW.errorType +// T_XL_ETH_DATAFRAME_TX_ERR_OTHERAPP.errorType +#define XL_ETH_TX_ERROR_BYPASS_ENABLED 1 /* Bypass activated */ +#define XL_ETH_TX_ERROR_NO_LINK 2 /* No Link */ +#define XL_ETH_TX_ERROR_PHY_NOT_CONFIGURED 3 /* PHY not yet configured */ +#define XL_ETH_TX_ERROR_INVALID_LENGTH 7 /* Frame with invalid length transmitted */ + + +#include + +/////////////////////////////////////////////////////////////////////////////////// +// Structures for Ethernet API +/////////////////////////////////////////////////////////////////////////////////// + +typedef unsigned short XLethEventTag; + +typedef struct s_xl_eth_frame { + unsigned short etherType; /* Ethernet type in network byte order */ + unsigned char payload[XL_ETH_PAYLOAD_SIZE_MAX]; +} T_XL_ETH_FRAME; + +typedef union s_xl_eth_framedata { + unsigned char rawData[XL_ETH_RAW_FRAME_SIZE_MAX]; + T_XL_ETH_FRAME ethFrame; +} T_XL_ETH_FRAMEDATA; + +typedef struct s_xl_eth_dataframe_rx { + unsigned int frameIdentifier; /* FPGA internal identifier unique to every received frame */ + unsigned int frameDuration; /* transmit duration of the Ethernet frame, in nanoseconds */ + unsigned short dataLen; /* Overall data length of */ + unsigned short reserved; /* currently reserved field - not used, ignore */ + unsigned int reserved2[3]; /* currently reserved field - not used, ignore */ + unsigned int fcs; /* Frame Check Sum */ + unsigned char destMAC[XL_ETH_MACADDR_OCTETS]; /* Destination MAC address */ + unsigned char sourceMAC[XL_ETH_MACADDR_OCTETS]; /* Source MAC address */ + T_XL_ETH_FRAMEDATA frameData; +} T_XL_ETH_DATAFRAME_RX; + +typedef struct s_xl_eth_dataframe_rxerror { + unsigned int frameIdentifier; /* FPGA internal identifier unique to every received frame */ + unsigned int frameDuration; /* transmit duration of the Ethernet frame, in nanoseconds */ + unsigned int errorFlags; /* Error information (XL_ETH_RX_ERROR_*) */ + unsigned short dataLen; /* Overall data length of */ + unsigned short reserved; /* currently reserved field - not used, ignore */ + unsigned int reserved2[3]; /* currently reserved field - not used, ignore */ + unsigned int fcs; /* Frame Check Sum */ + unsigned char destMAC[XL_ETH_MACADDR_OCTETS]; /* Destination MAC address */ + unsigned char sourceMAC[XL_ETH_MACADDR_OCTETS]; /* Source MAC address */ + T_XL_ETH_FRAMEDATA frameData; +} T_XL_ETH_DATAFRAME_RX_ERROR; + +typedef struct s_xl_eth_dataframe_tx { + unsigned int frameIdentifier; /* FPGA internal identifier unique to every frame sent */ + unsigned int flags; /* Flags to specify whether to use the given source MAC and FCS (see XL_ETH_DATAFRAME_FLAGS_) */ + unsigned short dataLen; /* Overall data length of */ + unsigned short reserved; /* currently reserved field - must be set to "0" */ + unsigned int reserved2[4]; /* reserved field - must be set to "0" */ + unsigned char destMAC[XL_ETH_MACADDR_OCTETS]; /* Destination MAC address */ + unsigned char sourceMAC[XL_ETH_MACADDR_OCTETS]; /* Source MAC address */ + T_XL_ETH_FRAMEDATA frameData; +} T_XL_ETH_DATAFRAME_TX; + +typedef struct s_xl_eth_dataframe_tx_event { + unsigned int frameIdentifier; /* FPGA internal identifier unique to every frame sent */ + unsigned int flags; /* Flags signalizing whether the given source MAC and FCS have been used by the send request (see XL_ETH_DATAFRAME_FLAGS_) */ + unsigned short dataLen; /* Overall data length of */ + unsigned short reserved; /* currently reserved field - not used, ignore */ + unsigned int frameDuration; /* transmit duration of the Ethernet frame, in nanoseconds */ + unsigned int reserved2[2]; /* currently reserved field - not used, ignore */ + unsigned int fcs; /* Frame Check Sum */ + unsigned char destMAC[XL_ETH_MACADDR_OCTETS]; /* Destination MAC address */ + unsigned char sourceMAC[XL_ETH_MACADDR_OCTETS]; /* Source MAC address */ + T_XL_ETH_FRAMEDATA frameData; +} T_XL_ETH_DATAFRAME_TX_EVENT; + +typedef T_XL_ETH_DATAFRAME_TX_EVENT T_XL_ETH_DATAFRAME_TXACK; +typedef T_XL_ETH_DATAFRAME_TX_EVENT T_XL_ETH_DATAFRAME_TXACK_SW; +typedef T_XL_ETH_DATAFRAME_TX_EVENT T_XL_ETH_DATAFRAME_TXACK_OTHERAPP; + +typedef struct s_xl_eth_dataframe_txerror { + unsigned int errorType; /* Error information */ + T_XL_ETH_DATAFRAME_TX_EVENT txFrame; +} T_XL_ETH_DATAFRAME_TX_ERROR; + +typedef T_XL_ETH_DATAFRAME_TX_ERROR T_XL_ETH_DATAFRAME_TX_ERR_SW; +typedef T_XL_ETH_DATAFRAME_TX_ERROR T_XL_ETH_DATAFRAME_TX_ERR_OTHERAPP; + +#include +#include + +typedef struct s_xl_eth_config_result { + unsigned int result; +} T_XL_ETH_CONFIG_RESULT; + +typedef struct s_xl_eth_channel_status { + unsigned int link; /* (XL_ETH_STATUS_LINK_*) Ethernet connection status */ + unsigned int speed; /* (XL_ETH_STATUS_SPEED_*) Link connection speed */ + unsigned int duplex; /* (XL_ETH_STATUS_DUPLEX_*) Ethernet duplex mode. 1000Base-T always uses full duplex. */ + unsigned int mdiType; /* (XL_ETH_STATUS_MDI_*) Currently active MDI-mode */ + unsigned int activeConnector;/* (XL_ETH_STATUS_CONNECTOR_*) Connector (plug) to use (BroadR-REACH or RJ-45). */ + unsigned int activePhy; /* (XL_ETH_STATUS_PHY_*) Currently active physical layer */ + unsigned int clockMode; /* (XL_ETH_STATUS_CLOCK_*) When in 1000Base-T or BroadR-mode, currently active mode */ + unsigned int brPairs; /* (XL_ETH_STATUS_BR_PAIR_*) When in BroadR-mode, number of used cable pairs */ +} T_XL_ETH_CHANNEL_STATUS; + +typedef struct s_xl_eth_lostevent { + XLethEventTag eventTypeLost; /* Type of event lost */ + unsigned short reserved; /* currently reserved field - not used */ + unsigned int reason; /* Reason code why the events were lost (0 means unknown) */ + union { + struct { + unsigned int frameIdentifier; /* FPGA internal identifier unique to every frame sent */ + unsigned int fcs; /* Frame Check Sum */ + unsigned char sourceMAC[XL_ETH_MACADDR_OCTETS]; /* Source MAC address */ + unsigned char reserved[2]; /* currently reserved field - not used */ + } txAck, txAckSw; + struct { + unsigned int errorType; + unsigned int frameIdentifier; /* FPGA internal identifier unique to every frame sent */ + unsigned int fcs; /* Frame Check Sum */ + unsigned char sourceMAC[XL_ETH_MACADDR_OCTETS]; /* Source MAC address */ + unsigned char reserved[2]; /* currently reserved field - not used */ + } txError, txErrorSw; + unsigned int reserved[20]; + } eventInfo; +} T_XL_ETH_LOSTEVENT; + +typedef struct s_xl_eth_event { + unsigned int size; // 4 - overall size of the complete event, depending on event type and piggybacked data + XLethEventTag tag; // 2 - type of the event + unsigned short channelIndex; // 2 + unsigned int userHandle; // 4 + unsigned short flagsChip; // 2 + unsigned short reserved; // 2 + XLuint64 reserved1; // 8 + XLuint64 timeStampSync; // 8 - timestamp which is synchronized by the driver + // --------- + // 32 bytes -> XL_ETH_EVENT_SIZE_HEADER + + union s_xl_eth_tag_data { + unsigned char rawData[XL_ETH_EVENT_SIZE_MAX]; + T_XL_ETH_DATAFRAME_RX frameRxOk; //(tag==XL_ETH_EVENT_TAG_FRAMERX) Frame received from network + T_XL_ETH_DATAFRAME_RX_ERROR frameRxError; //(tag==XL_ETH_EVENT_TAG_FRAMERX_ERROR) Erroneous frame received from network + T_XL_ETH_DATAFRAME_TXACK frameTxAck; //(tag==XL_ETH_EVENT_TAG_FRAMETX_ACK) ACK for frame sent by application + T_XL_ETH_DATAFRAME_TXACK_SW frameTxAckSw; //(tag==XL_ETH_EVENT_TAG_FRAMETX_ACK_SWITCH) ACK for frame sent by switch + T_XL_ETH_DATAFRAME_TXACK_OTHERAPP frameTxAckOtherApp;//(tag==XL_ETH_EVENT_TAG_FRAMETX_ERROR_OTHER_APP) ACK for frame sent by another application + T_XL_ETH_DATAFRAME_TX_ERROR frameTxError; //(tag==XL_ETH_EVENT_TAG_FRAMETX_ERROR) NACK for frame sent by application (frame could not be transmitted) + T_XL_ETH_DATAFRAME_TX_ERR_SW frameTxErrorSw; //(tag==XL_ETH_EVENT_TAG_FRAMETX_ERROR_SWITCH) NACK for frame sent by switch. May indicate internal processing failure (e.g. queue full condition) + T_XL_ETH_DATAFRAME_TX_ERR_OTHERAPP frameTxErrorOtherApp;//(tag==XL_ETH_EVENT_TAG_FRAMETX_ERROR_OTHER_APP) NACK for frame sent by another application + T_XL_ETH_CONFIG_RESULT configResult; + T_XL_ETH_CHANNEL_STATUS channelStatus; + XL_SYNC_PULSE_EV syncPulse; + T_XL_ETH_LOSTEVENT lostEvent; //(tag==XL_ETH_EVENT_TAG_LOSTEVENT) Indication that one or more events have been lost + } tagData; +} T_XL_ETH_EVENT; + +typedef struct { + unsigned int speed; /* (XL_ETH_MODE_SPEED_*) Connection speed setting */ + unsigned int duplex; /* (XL_ETH_MODE_DUPLEX_*) Duplex mode setting. Not relevant for BroadR-REACH mode, set to "nochange" or "auto". */ + unsigned int connector; /* (XL_ETH_MODE_CONNECTOR_*) Connector to use */ + unsigned int phy; /* (XL_ETH_MODE_PHY_*) Physical interface to enable */ + unsigned int clockMode; /* (XL_ETH_MODE_CLOCK_*) Master or slave clock mode setting (1000Base-T/BroadR-REACH mode only). */ + unsigned int mdiMode; /* (XL_ETH_MODE_MDI_*) Currently active MDI-mode */ + unsigned int brPairs; /* (XL_ETH_MODE_BR_PAIR_*) Number of cable pairs to use (BroadR-REACH mode only). */ +} T_XL_ETH_CONFIG; + +#include + +///////////////////////////////////////////////////////////////////////////////////////////////////////// +// MOST150 XL API +///////////////////////////////////////////////////////////////////////////////////////////////////////// + +#define XL_MOST150_RX_EVENT_HEADER_SIZE (unsigned short) 32 +#define XL_MOST150_MAX_EVENT_DATA_SIZE (unsigned int) 2048 +#define MOST150_SYNC_ALLOC_INFO_SIZE (unsigned int) 372 + +#define XL_MOST150_CTRL_PAYLOAD_MAX_SIZE (unsigned short) 45 +#define XL_MOST150_ASYNC_PAYLOAD_MAX_SIZE (unsigned short) 1524 // maximum valid length (s. INIC User Manual) +#define XL_MOST150_ETHERNET_PAYLOAD_MAX_SIZE (unsigned short) 1506 // maximum valid length (s. INIC User Manual) +#define XL_MOST150_ASYNC_SEND_PAYLOAD_MAX_SIZE (unsigned short) 1600 // maximum length for sending a MDP +#define XL_MOST150_ETHERNET_SEND_PAYLOAD_MAX_SIZE (unsigned short) 1600 // maximum length for sending a MEP + + +///////////////////////////////////////////////////////////////////////////////////////////////////////// +// Flags for the flagsChip parameter +///////////////////////////////////////////////////////////////////////////////////////////////////////// +#define XL_MOST150_VN2640 (unsigned short) 0x0001 //!< common VN2640 event +#define XL_MOST150_INIC (unsigned short) 0x0002 //!< event was generated by INIC +#define XL_MOST150_SPY (unsigned short) 0x0004 //!< event was generated by spy +#define XL_MOST150_QUEUE_OVERFLOW (unsigned short) 0x0100 //!< queue overflow occured (some events are lost) + +// XL_MOST150_EVENT_SOURCE_EV.mask +#define XL_MOST150_SOURCE_SPECIAL_NODE (unsigned int) 0x00000001 +#define XL_MOST150_SOURCE_SYNC_ALLOC_INFO (unsigned int) 0x00000004 +#define XL_MOST150_SOURCE_CTRL_SPY (unsigned int) 0x00000008 +#define XL_MOST150_SOURCE_ASYNC_SPY (unsigned int) 0x00000010 +#define XL_MOST150_SOURCE_ETH_SPY (unsigned int) 0x00000020 +#define XL_MOST150_SOURCE_SHUTDOWN_FLAG (unsigned int) 0x00000040 +#define XL_MOST150_SOURCE_SYSTEMLOCK_FLAG (unsigned int) 0x00000080 +#define XL_MOST150_SOURCE_LIGHTLOCK_SPY (unsigned int) 0x00000200 +#define XL_MOST150_SOURCE_LIGHTLOCK_INIC (unsigned int) 0x00000400 +#define XL_MOST150_SOURCE_ECL_CHANGE (unsigned int) 0x00000800 +#define XL_MOST150_SOURCE_LIGHT_STRESS (unsigned int) 0x00001000 +#define XL_MOST150_SOURCE_LOCK_STRESS (unsigned int) 0x00002000 +#define XL_MOST150_SOURCE_BUSLOAD_CTRL (unsigned int) 0x00004000 +#define XL_MOST150_SOURCE_BUSLOAD_ASYNC (unsigned int) 0x00008000 +#define XL_MOST150_SOURCE_CTRL_MLB (unsigned int) 0x00010000 +#define XL_MOST150_SOURCE_ASYNC_MLB (unsigned int) 0x00020000 +#define XL_MOST150_SOURCE_ETH_MLB (unsigned int) 0x00040000 +#define XL_MOST150_SOURCE_TXACK_MLB (unsigned int) 0x00080000 +#define XL_MOST150_SOURCE_STREAM_UNDERFLOW (unsigned int) 0x00100000 +#define XL_MOST150_SOURCE_STREAM_OVERFLOW (unsigned int) 0x00200000 +#define XL_MOST150_SOURCE_STREAM_RX_DATA (unsigned int) 0x00400000 +#define XL_MOST150_SOURCE_ECL_SEQUENCE (unsigned int) 0x00800000 + +// XL_MOST150_DEVICE_MODE_EV.deviceMode +#define XL_MOST150_DEVICEMODE_SLAVE (unsigned char) 0x00 +#define XL_MOST150_DEVICEMODE_MASTER (unsigned char) 0x01 +#define XL_MOST150_DEVICEMODE_STATIC_MASTER (unsigned char) 0x03 +#define XL_MOST150_DEVICEMODE_RETIMED_BYPASS_SLAVE (unsigned char) 0x04 +#define XL_MOST150_DEVICEMODE_RETIMED_BYPASS_MASTER (unsigned char) 0x05 + +// XL_MOST150_FREQUENCY_EV.frequency +#define XL_MOST150_FREQUENCY_44100 (unsigned int) 0x00000000 +#define XL_MOST150_FREQUENCY_48000 (unsigned int) 0x00000001 +#define XL_MOST150_FREQUENCY_ERROR (unsigned int) 0x00000002 + +// XL_MOST150_SPECIAL_NODE_INFO_EV.changeMask +#define XL_MOST150_NA_CHANGED (unsigned int) 0x00000001 +#define XL_MOST150_GA_CHANGED (unsigned int) 0x00000002 +#define XL_MOST150_NPR_CHANGED (unsigned int) 0x00000004 +#define XL_MOST150_MPR_CHANGED (unsigned int) 0x00000008 +#define XL_MOST150_SBC_CHANGED (unsigned int) 0x00000010 +#define XL_MOST150_CTRL_RETRY_PARAMS_CHANGED (unsigned int) 0x00000060 +#define XL_MOST150_ASYNC_RETRY_PARAMS_CHANGED (unsigned int) 0x00000180 +#define XL_MOST150_MAC_ADDR_CHANGED (unsigned int) 0x00000200 +#define XL_MOST150_NPR_SPY_CHANGED (unsigned int) 0x00000400 +#define XL_MOST150_MPR_SPY_CHANGED (unsigned int) 0x00000800 +#define XL_MOST150_SBC_SPY_CHANGED (unsigned int) 0x00001000 +#define XL_MOST150_INIC_NISTATE_CHANGED (unsigned int) 0x00002000 +#define XL_MOST150_SPECIAL_NODE_MASK_CHANGED (unsigned int) 0x00003FFF + +// Retry Parameters +#define XL_MOST150_CTRL_RETRY_TIME_MIN (unsigned int) 3 // Time Unit: 16 MOST Frames +#define XL_MOST150_CTRL_RETRY_TIME_MAX (unsigned int) 31 +#define XL_MOST150_CTRL_SEND_ATTEMPT_MIN (unsigned int) 1 +#define XL_MOST150_CTRL_SEND_ATTEMPT_MAX (unsigned int) 16 +#define XL_MOST150_ASYNC_RETRY_TIME_MIN (unsigned int) 0 // Time Unit: 1 MOST Frame +#define XL_MOST150_ASYNC_RETRY_TIME_MAX (unsigned int) 255 +#define XL_MOST150_ASYNC_SEND_ATTEMPT_MIN (unsigned int) 1 // For both MDP and MEP +#define XL_MOST150_ASYNC_SEND_ATTEMPT_MAX (unsigned int) 16 + +// NIStates +#define XL_MOST150_INIC_NISTATE_NET_OFF (unsigned int) 0x00000000 +#define XL_MOST150_INIC_NISTATE_NET_INIT (unsigned int) 0x00000001 +#define XL_MOST150_INIC_NISTATE_NET_RBD (unsigned int) 0x00000002 +#define XL_MOST150_INIC_NISTATE_NET_ON (unsigned int) 0x00000003 +#define XL_MOST150_INIC_NISTATE_NET_RBD_RESULT (unsigned int) 0x00000004 + +// XL_MOST150_CTRL_TX_ACK_EV.status +#define XL_MOST150_TX_OK (unsigned int) 0x00000001 +#define XL_MOST150_TX_FAILED_FORMAT_ERROR (unsigned int) 0x00000002 +#define XL_MOST150_TX_FAILED_NETWORK_OFF (unsigned int) 0x00000004 +#define XL_MOST150_TX_FAILED_TIMEOUT (unsigned int) 0x00000005 +#define XL_MOST150_TX_FAILED_WRONG_TARGET (unsigned int) 0x00000008 +#define XL_MOST150_TX_OK_ONE_SUCCESS (unsigned int) 0x00000009 +#define XL_MOST150_TX_FAILED_BAD_CRC (unsigned int) 0x0000000C +#define XL_MOST150_TX_FAILED_RECEIVER_BUFFER_FULL (unsigned int) 0x0000000E + +// XL_MOST150_CTRL_SPY_EV.validMask +// XL_MOST150_ASYNC_SPY_EV.validMask +// XL_MOST150_ETHERNET_SPY_EV.validMask +#define XL_MOST150_VALID_DATALENANNOUNCED (unsigned int) 0x00000001 +#define XL_MOST150_VALID_SOURCEADDRESS (unsigned int) 0x00000002 +#define XL_MOST150_VALID_TARGETADDRESS (unsigned int) 0x00000004 +#define XL_MOST150_VALID_PACK (unsigned int) 0x00000008 +#define XL_MOST150_VALID_CACK (unsigned int) 0x00000010 +#define XL_MOST150_VALID_PINDEX (unsigned int) 0x00000020 +#define XL_MOST150_VALID_PRIORITY (unsigned int) 0x00000040 +#define XL_MOST150_VALID_CRC (unsigned int) 0x00000080 +#define XL_MOST150_VALID_CRCCALCULATED (unsigned int) 0x00000100 +#define XL_MOST150_VALID_MESSAGE (unsigned int) 0x80000000 + +// XL_MOST150_CTRL_SPY_EV.pAck +// XL_MOST150_ASYNC_SPY_EV.pAck +// XL_MOST150_ETHERNET_SPY_EV.pAck +#define XL_MOST150_PACK_OK (unsigned int) 0x00000004 +#define XL_MOST150_PACK_BUFFER_FULL (unsigned int) 0x00000001 +#define XL_MOST150_PACK_NO_RESPONSE (unsigned int) 0x00000000 // maybe spy before receiver + +// XL_MOST150_CTRL_SPY_EV.cAck +// XL_MOST150_ASYNC_SPY_EV.cAck +// XL_MOST150_ETHERNET_SPY_EV.cAck +#define XL_MOST150_CACK_OK (unsigned int) 0x00000004 +#define XL_MOST150_CACK_CRC_ERROR (unsigned int) 0x00000001 +#define XL_MOST150_CACK_NO_RESPONSE (unsigned int) 0x00000000 // maybe spy before receiver + +//XL_MOST150_ASYNC_RX_EV.length +#define XL_MOST150_ASYNC_INVALID_RX_LENGTH (unsigned int) 0x00008000 // flag indicating a received MDP with length > XL_MOST150_ASYNC_PAYLOAD_MAX_SIZE + +//XL_MOST150_ETHERNET_RX_EV.length +#define XL_MOST150_ETHERNET_INVALID_RX_LENGTH (unsigned int) 0x80000000 // flag indicating a received MEP with length > XL_MOST150_ETHERNET_PAYLOAD_MAX_SIZE + +// XL_MOST150_TX_LIGHT_EV.light +#define XL_MOST150_LIGHT_OFF (unsigned int) 0x00000000 +#define XL_MOST150_LIGHT_FORCE_ON (unsigned int) 0x00000001 +#define XL_MOST150_LIGHT_MODULATED (unsigned int) 0x00000002 + +// XL_MOST150_RXLIGHT_LOCKSTATUS_EV.status +//#define XL_MOST150_LIGHT_OFF (unsigned int) 0x00000000 +#define XL_MOST150_LIGHT_ON_UNLOCK (unsigned int) 0x00000003 +#define XL_MOST150_LIGHT_ON_LOCK (unsigned int) 0x00000004 +#define XL_MOST150_LIGHT_ON_STABLE_LOCK (unsigned int) 0x00000005 +#define XL_MOST150_LIGHT_ON_CRITICAL_UNLOCK (unsigned int) 0x00000006 + +// XL_MOST150_ERROR_EV.errorCode +#define XL_MOST150_ERROR_ASYNC_TX_ACK_HANDLE (unsigned int) 0x00000001 +#define XL_MOST150_ERROR_ETH_TX_ACK_HANDLE (unsigned int) 0x00000002 + +// XL_MOST150_CONFIGURE_RX_BUFFER_EV.bufferType +#define XL_MOST150_RX_BUFFER_TYPE_CTRL (unsigned int) 0x00000001 +#define XL_MOST150_RX_BUFFER_TYPE_ASYNC (unsigned int) 0x00000002 + +// XL_MOST150_CONFIGURE_RX_BUFFER_EV.bufferMode +#define XL_MOST150_RX_BUFFER_NORMAL_MODE (unsigned int) 0x00000000 +#define XL_MOST150_RX_BUFFER_BLOCK_MODE (unsigned int) 0x00000001 + +// XL_MOST150_CTRL_SYNC_AUDIO_EV.device +#define XL_MOST150_DEVICE_LINE_IN (unsigned int) 0x00000000 +#define XL_MOST150_DEVICE_LINE_OUT (unsigned int) 0x00000001 +#define XL_MOST150_DEVICE_SPDIF_IN (unsigned int) 0x00000002 +#define XL_MOST150_DEVICE_SPDIF_OUT (unsigned int) 0x00000003 +#define XL_MOST150_DEVICE_ALLOC_BANDWIDTH (unsigned int) 0x00000004 + +// XL_MOST150_CTRL_SYNC_AUDIO_EV.mode +#define XL_MOST150_DEVICE_MODE_OFF (unsigned int) 0x00000000 +#define XL_MOST150_DEVICE_MODE_ON (unsigned int) 0x00000001 +#define XL_MOST150_DEVICE_MODE_OFF_BYPASS_CLOSED (unsigned int) 0x00000002 +#define XL_MOST150_DEVICE_MODE_OFF_NOT_IN_NETON (unsigned int) 0x00000003 +#define XL_MOST150_DEVICE_MODE_OFF_NO_MORE_RESOURCES (unsigned int) 0x00000004 +#define XL_MOST150_DEVICE_MODE_OFF_NOT_ENOUGH_FREE_BW (unsigned int) 0x00000005 +#define XL_MOST150_DEVICE_MODE_OFF_DUE_TO_NET_OFF (unsigned int) 0x00000006 +#define XL_MOST150_DEVICE_MODE_OFF_DUE_TO_CFG_NOT_OK (unsigned int) 0x00000007 +#define XL_MOST150_DEVICE_MODE_OFF_COMMUNICATION_ERROR (unsigned int) 0x00000008 +#define XL_MOST150_DEVICE_MODE_OFF_STREAM_CONN_ERROR (unsigned int) 0x00000009 +#define XL_MOST150_DEVICE_MODE_OFF_CL_ALREADY_USED (unsigned int) 0x0000000A +#define XL_MOST150_DEVICE_MODE_CL_NOT_ALLOCATED (unsigned int) 0x000000FF + +// Maximum number of CL that can be allocated for device XL_MOST150_DEVICE_ALLOC_BANDWIDTH +#define XL_MOST150_ALLOC_BANDWIDTH_NUM_CL_MAX 10 + +// special CL for xlMost150CtrlSyncAudio to de-allocate all CLs for device XL_MOST150_DEVICE_ALLOC_BANDWIDTH +#define XL_MOST150_CL_DEALLOC_ALL (unsigned int) 0x00000FFF + +// XL_MOST150_SYNC_VOLUME_STATUS_EV.volume +#define XL_MOST150_VOLUME_MIN (unsigned int) 0x00000000 +#define XL_MOST150_VOLUME_MAX (unsigned int) 0x000000FF + +// XL_MOST150_SYNC_MUTE_STATUS_EV.mute +#define XL_MOST150_NO_MUTE (unsigned int) 0x00000000 +#define XL_MOST150_MUTE (unsigned int) 0x00000001 + +// XL_MOST150_LIGHT_POWER_EV.lightPower +#define XL_MOST150_LIGHT_FULL (unsigned int) 0x00000064 +#define XL_MOST150_LIGHT_3DB (unsigned int) 0x00000032 + +// XL_MOST150_SYSTEMLOCK_FLAG_EV.state +#define XL_MOST150_SYSTEMLOCK_FLAG_NOT_SET (unsigned int) 0x00000000 +#define XL_MOST150_SYSTEMLOCK_FLAG_SET (unsigned int) 0x00000001 + +// XL_MOST150_SHUTDOWN_FLAG_EV.state +#define XL_MOST150_SHUTDOWN_FLAG_NOT_SET (unsigned int) 0x00000000 +#define XL_MOST150_SHUTDOWN_FLAG_SET (unsigned int) 0x00000001 + +// ECL +// xlMost150SetECLLine +#define XL_MOST150_ECL_LINE_LOW (unsigned int) 0x00000000 +#define XL_MOST150_ECL_LINE_HIGH (unsigned int) 0x00000001 +// xlMost150SetECLTermination +#define XL_MOST150_ECL_LINE_PULL_UP_NOT_ACTIVE (unsigned int) 0x00000000 +#define XL_MOST150_ECL_LINE_PULL_UP_ACTIVE (unsigned int) 0x00000001 + +// xlMost150EclConfigureSeq +// Maximum number of states that can be configured for a sequence +#define XL_MOST150_ECL_SEQ_NUM_STATES_MAX 200 +// Value range for duration of ECL sequence states +#define XL_MOST150_ECL_SEQ_DURATION_MIN 1 // -> 100 µs +#define XL_MOST150_ECL_SEQ_DURATION_MAX 655350 // -> 65535 ms + +// xlMost150EclSetGlitchFilter +// Value range for setting the glitch filter +#define XL_MOST150_ECL_GLITCH_FILTER_MIN 50 // -> 50 µs +#define XL_MOST150_ECL_GLITCH_FILTER_MAX 50000 // -> 50 ms + +// XL_MOST150_GEN_LIGHT_ERROR_EV.stressStarted +// XL_MOST150_GEN_LOCK_ERROR_EV.stressStarted +// XL_MOST150_CTRL_BUSLOAD.busloadStarted +// XL_MOST150_ASYNC_BUSLOAD.busloadStarted +// XL_MOST150_ECL_SEQUENCE_EV.sequenceStarted +#define XL_MOST150_MODE_DEACTIVATED 0 +#define XL_MOST150_MODE_ACTIVATED 1 + +// busloadType for xlMost150AsyncConfigureBusload +#define XL_MOST150_BUSLOAD_TYPE_DATA_PACKET 0 +#define XL_MOST150_BUSLOAD_TYPE_ETHERNET_PACKET 1 + +// counterType for the xlMost150****ConfigureBusload function +#define XL_MOST150_BUSLOAD_COUNTER_TYPE_NONE 0x00 +#define XL_MOST150_BUSLOAD_COUNTER_TYPE_1_BYTE 0x01 +#define XL_MOST150_BUSLOAD_COUNTER_TYPE_2_BYTE 0x02 +#define XL_MOST150_BUSLOAD_COUNTER_TYPE_3_BYTE 0x03 +#define XL_MOST150_BUSLOAD_COUNTER_TYPE_4_BYTE 0x04 + + +// XL_MOST150_SPDIF_MODE_EV.spdifMode +#define XL_MOST150_SPDIF_MODE_SLAVE (unsigned int) 0x00000000 +#define XL_MOST150_SPDIF_MODE_MASTER (unsigned int) 0x00000001 + +// XL_MOST150_SPDIF_MODE_EV.spdifError +#define XL_MOST150_SPDIF_ERR_NO_ERROR (unsigned int) 0x00000000 +#define XL_MOST150_SPDIF_ERR_HW_COMMUNICATION (unsigned int) 0x00000001 + +// XL_MOST150_NW_STARTUP_EV.error +#define XL_MOST150_STARTUP_NO_ERROR (unsigned int) 0x00000000 +// XL_MOST150_NW_STARTUP_EV.errorInfo +#define XL_MOST150_STARTUP_NO_ERRORINFO (unsigned int) 0xFFFFFFFF + +// XL_MOST150_NW_SHUTDOWN_EV.error +#define XL_MOST150_SHUTDOWN_NO_ERROR (unsigned int) 0x00000000 +// XL_MOST150_NW_SHUTDOWN_EV.errorInfo +#define XL_MOST150_SHUTDOWN_NO_ERRORINFO (unsigned int) 0xFFFFFFFF + +/// Values for synchronous streaming API +#define XL_MOST150_STREAM_RX_DATA 0 // RX streaming: MOST -> PC +#define XL_MOST150_STREAM_TX_DATA 1 // TX streaming: PC -> MOST + +#define XL_MOST150_STREAM_INVALID_HANDLE 0 + +// stream states +#define XL_MOST150_STREAM_STATE_CLOSED 0x01 +#define XL_MOST150_STREAM_STATE_OPENED 0x02 +#define XL_MOST150_STREAM_STATE_STARTED 0x03 +#define XL_MOST150_STREAM_STATE_STOPPED 0x04 +#define XL_MOST150_STREAM_STATE_START_PENDING 0x05 // waiting for result from hw +#define XL_MOST150_STREAM_STATE_STOP_PENDING 0x06 // waiting for result from hw +#define XL_MOST150_STREAM_STATE_OPEN_PENDING 0x07 // waiting for result from hw +#define XL_MOST150_STREAM_STATE_CLOSE_PENDING 0x08 // waiting for result from hw + +// TX Streaming: Maximum number of bytes that can be streamed per MOST frame +#define XL_MOST150_STREAM_TX_BYTES_PER_FRAME_MIN 1 +#define XL_MOST150_STREAM_TX_BYTES_PER_FRAME_MAX 152 + +// RX Streaming: Maximum number of connection labels that can be streamed +#define XL_MOST150_STREAM_RX_NUM_CL_MAX 8 + +// valid connection label range +#define XL_MOST150_STREAM_CL_MIN (unsigned int) 0x000C +#define XL_MOST150_STREAM_CL_MAX (unsigned int) 0x017F + +// XL_MOST150_STREAM_STATE_EV.streamError +// XL_MOST150_STREAM_TX_LABEL_EV.errorInfo +#define XL_MOST150_STREAM_STATE_ERROR_NO_ERROR 0 +#define XL_MOST150_STREAM_STATE_ERROR_NOT_ENOUGH_BW 1 +#define XL_MOST150_STREAM_STATE_ERROR_NET_OFF 2 +#define XL_MOST150_STREAM_STATE_ERROR_CONFIG_NOT_OK 3 +#define XL_MOST150_STREAM_STATE_ERROR_CL_DISAPPEARED 4 +#define XL_MOST150_STREAM_STATE_ERROR_INIC_SC_ERROR 5 +#define XL_MOST150_STREAM_STATE_ERROR_DEVICEMODE_BYPASS 6 +#define XL_MOST150_STREAM_STATE_ERROR_NISTATE_NOT_NETON 7 +#define XL_MOST150_STREAM_STATE_ERROR_INIC_BUSY 8 +#define XL_MOST150_STREAM_STATE_ERROR_CL_MISSING 9 +#define XL_MOST150_STREAM_STATE_ERROR_NUM_BYTES_MISMATCH 10 +#define XL_MOST150_STREAM_STATE_ERROR_INIC_COMMUNICATION 11 + +// XL_MOST150_STREAM_TX_BUFFER_EV.status +#define XL_MOST150_STREAM_BUFFER_ERROR_NO_ERROR 0 +#define XL_MOST150_STREAM_BUFFER_ERROR_NOT_ENOUGH_DATA 1 +#define XL_MOST150_STREAM_BUFFER_TX_FIFO_CLEARED 2 + +// XL_MOST150_STREAM_RX_BUFFER_EV.status +//#define XL_MOST150_STREAM_BUFFER_ERROR_NO_ERROR 0 +#define XL_MOST150_STREAM_BUFFER_ERROR_STOP_BY_APP 1 +#define XL_MOST150_STREAM_BUFFER_ERROR_MOST_SIGNAL_OFF 2 +#define XL_MOST150_STREAM_BUFFER_ERROR_UNLOCK 3 +#define XL_MOST150_STREAM_BUFFER_ERROR_CL_MISSING 4 +#define XL_MOST150_STREAM_BUFFER_ERROR_ALL_CL_MISSING 5 +#define XL_MOST150_STREAM_BUFFER_ERROR_OVERFLOW 128 // overflow bit + +// latency values +#define XL_MOST150_STREAM_LATENCY_VERY_LOW 0 +#define XL_MOST150_STREAM_LATENCY_LOW 1 +#define XL_MOST150_STREAM_LATENCY_MEDIUM 2 +#define XL_MOST150_STREAM_LATENCY_HIGH 3 +#define XL_MOST150_STREAM_LATENCY_VERY_HIGH 4 + + +// bypass stress maximum/minimum timing parameter in msec +#define XL_MOST150_BYPASS_STRESS_TIME_MIN 10 +#define XL_MOST150_BYPASS_STRESS_TIME_MAX 65535 + +// XL_MOST150_GEN_BYPASS_STRESS_EV.stressStarted +#define XL_MOST150_BYPASS_STRESS_STOPPED 0 +#define XL_MOST150_BYPASS_STRESS_STARTED 1 +#define XL_MOST150_BYPASS_STRESS_STOPPED_LIGHT_OFF 2 +#define XL_MOST150_BYPASS_STRESS_STOPPED_DEVICE_MODE 3 + + +// xlMost150SetSSOResult +// XL_MOST150_SSO_RESULT_EV.status +#define XL_MOST150_SSO_RESULT_NO_RESULT (unsigned int) 0x00000000 +#define XL_MOST150_SSO_RESULT_NO_FAULT_SAVED (unsigned int) 0x00000001 +#define XL_MOST150_SSO_RESULT_SUDDEN_SIGNAL_OFF (unsigned int) 0x00000002 +#define XL_MOST150_SSO_RESULT_CRITICAL_UNLOCK (unsigned int) 0x00000003 + + +#include + +////////////////////////////////////////////////////////////// +// Structures for MOST150 events +////////////////////////////////////////////////////////////// + +typedef unsigned short XLmostEventTag; + + +typedef struct s_xl_most150_event_source{ + unsigned int sourceMask; +} XL_MOST150_EVENT_SOURCE_EV; + +typedef struct s_xl_most150_device_mode { + unsigned int deviceMode; +} XL_MOST150_DEVICE_MODE_EV; + +typedef struct s_xl_most150_frequency { + unsigned int frequency; +} XL_MOST150_FREQUENCY_EV; + +typedef struct s_xl_most150_special_node_info{ + unsigned int changeMask; + unsigned short nodeAddress; + unsigned short groupAddress; + unsigned char npr; + unsigned char mpr; + unsigned char sbc; + unsigned char ctrlRetryTime; + unsigned char ctrlSendAttempts; + unsigned char asyncRetryTime; + unsigned char asyncSendAttempts; + unsigned char macAddr[6]; + unsigned char nprSpy; + unsigned char mprSpy; + unsigned char sbcSpy; + unsigned char inicNIState; + unsigned char reserved1[3]; + unsigned int reserved2[3]; +} XL_MOST150_SPECIAL_NODE_INFO_EV; + +typedef struct s_xl_most150_ctrl_rx { + unsigned short targetAddress; + unsigned short sourceAddress; + unsigned char fblockId; + unsigned char instId; + unsigned short functionId; + unsigned char opType; + unsigned char telId; + unsigned short telLen; + unsigned char ctrlData[45]; +} XL_MOST150_CTRL_RX_EV; + +typedef struct s_xl_most150_ctrl_spy{ + unsigned int frameCount; + unsigned int msgDuration; // duration of message transmission in [ns] + unsigned char priority; + unsigned short targetAddress; + unsigned char pAck; + unsigned short ctrlDataLenAnnounced; + unsigned char reserved0; + unsigned char pIndex; + unsigned short sourceAddress; + unsigned short reserved1; + unsigned short crc; + unsigned short crcCalculated; + unsigned char cAck; + unsigned short ctrlDataLen; // number of bytes contained in ctrlData[] + unsigned char reserved2; + unsigned int status; // currently not used + unsigned int validMask; + unsigned char ctrlData[51]; +} XL_MOST150_CTRL_SPY_EV; + +typedef struct s_xl_most150_async_rx_msg { + unsigned short length; + unsigned short targetAddress; + unsigned short sourceAddress; + unsigned char asyncData[1524]; +} XL_MOST150_ASYNC_RX_EV; + +typedef struct s_xl_most150_async_spy_msg { + unsigned int frameCount; + unsigned int pktDuration; // duration of data packet transmission in [ns] + unsigned short asyncDataLenAnnounced; + unsigned short targetAddress; + unsigned char pAck; + unsigned char pIndex; + unsigned short sourceAddress; + unsigned int crc; + unsigned int crcCalculated; + unsigned char cAck; + unsigned short asyncDataLen; // number of bytes contained in asyncData[] + unsigned char reserved; + unsigned int status; // currently not used + unsigned int validMask; + unsigned char asyncData[1524]; +} XL_MOST150_ASYNC_SPY_EV; + +typedef struct s_xl_most150_ethernet_rx { + unsigned char sourceAddress[6]; + unsigned char targetAddress[6]; + unsigned int length; + unsigned char ethernetData[1510]; +} XL_MOST150_ETHERNET_RX_EV; + +typedef struct s_xl_most150_ethernet_spy { + unsigned int frameCount; + unsigned int pktDuration; // duration of ethernet packet transmission in [ns] + unsigned short ethernetDataLenAnnounced; + unsigned char targetAddress[6]; + unsigned char pAck; + unsigned char sourceAddress[6]; + unsigned char reserved0; + unsigned int crc; + unsigned int crcCalculated; + unsigned char cAck; + unsigned short ethernetDataLen; // number of bytes contained in ethernetData[] + unsigned char reserved1; + unsigned int status; // currently not used + unsigned int validMask; + unsigned char ethernetData[1506]; +} XL_MOST150_ETHERNET_SPY_EV; + +typedef struct s_xl_most150_cl_info { + unsigned short label; + unsigned short channelWidth; +} XL_MOST150_CL_INFO; + +typedef struct s_xl_most150_sync_alloc_info { + XL_MOST150_CL_INFO allocTable[MOST150_SYNC_ALLOC_INFO_SIZE]; +} XL_MOST150_SYNC_ALLOC_INFO_EV; + + +typedef struct s_xl_most150_sync_volume_status { + unsigned int device; + unsigned int volume; +} XL_MOST150_SYNC_VOLUME_STATUS_EV; + +typedef struct s_xl_most150_tx_light { + unsigned int light; +} XL_MOST150_TX_LIGHT_EV; + +typedef struct s_xl_most150_rx_light_lock_status { + unsigned int status; +} XL_MOST150_RXLIGHT_LOCKSTATUS_EV; + +typedef struct s_xl_most150_error { + unsigned int errorCode; + unsigned int parameter[3]; +} XL_MOST150_ERROR_EV; + +typedef struct s_xl_most150_configure_rx_buffer { + unsigned int bufferType; + unsigned int bufferMode; +} XL_MOST150_CONFIGURE_RX_BUFFER_EV; + +typedef struct s_xl_most150_ctrl_sync_audio { + unsigned int label; + unsigned int width; + unsigned int device; + unsigned int mode; +} XL_MOST150_CTRL_SYNC_AUDIO_EV; + +typedef struct s_xl_most150_sync_mute_status { + unsigned int device; + unsigned int mute; +} XL_MOST150_SYNC_MUTE_STATUS_EV; + +typedef struct s_xl_most150_tx_light_power { + unsigned int lightPower; +} XL_MOST150_LIGHT_POWER_EV; + +typedef struct s_xl_most150_gen_light_error { + unsigned int stressStarted; +} XL_MOST150_GEN_LIGHT_ERROR_EV; + +typedef struct s_xl_most150_gen_lock_error { + unsigned int stressStarted; +} XL_MOST150_GEN_LOCK_ERROR_EV; + +typedef struct s_xl_most150_ctrl_busload { + unsigned long busloadStarted; +} XL_MOST150_CTRL_BUSLOAD_EV; + +typedef struct s_xl_most150_async_busload { + unsigned long busloadStarted; +} XL_MOST150_ASYNC_BUSLOAD_EV; + +typedef struct s_xl_most150_systemlock_flag { + unsigned int state; +} XL_MOST150_SYSTEMLOCK_FLAG_EV; + +typedef struct s_xl_most150_shutdown_flag { + unsigned int state; +} XL_MOST150_SHUTDOWN_FLAG_EV; + +typedef struct s_xl_most150_spdif_mode { + unsigned int spdifMode; + unsigned int spdifError; +} XL_MOST150_SPDIF_MODE_EV; + +typedef struct s_xl_most150_ecl { + unsigned int eclLineState; +} XL_MOST150_ECL_EV; + +typedef struct s_xl_most150_ecl_termination { + unsigned int resistorEnabled; +} XL_MOST150_ECL_TERMINATION_EV; + +typedef struct s_xl_most150_nw_startup { + unsigned int error; + unsigned int errorInfo; +} XL_MOST150_NW_STARTUP_EV; + +typedef struct s_xl_most150_nw_shutdown { + unsigned int error; + unsigned int errorInfo; +} XL_MOST150_NW_SHUTDOWN_EV; + +typedef struct s_xl_most150_stream_state { + unsigned int streamHandle; + unsigned int streamState; + unsigned int streamError; +} XL_MOST150_STREAM_STATE_EV; + +typedef struct s_xl_most150_stream_tx_buffer { + unsigned int streamHandle; + unsigned int numberOfBytes; + unsigned int status; +} XL_MOST150_STREAM_TX_BUFFER_EV; + +typedef struct s_xl_most150_stream_rx_buffer { + unsigned int streamHandle; + unsigned int numberOfBytes; + unsigned int status; + unsigned int labelInfo; +} XL_MOST150_STREAM_RX_BUFFER_EV; + +typedef struct s_xl_most150_stream_tx_underflow { + unsigned int streamHandle; + unsigned int reserved; +} XL_MOST150_STREAM_TX_UNDERFLOW_EV; + +typedef struct s_xl_most150_stream_tx_label { + unsigned int streamHandle; + unsigned int errorInfo; + unsigned int connLabel; + unsigned int width; +} XL_MOST150_STREAM_TX_LABEL_EV; + +typedef struct s_xl_most150_gen_bypass_stress { + unsigned int stressStarted; +} XL_MOST150_GEN_BYPASS_STRESS_EV; + +typedef struct s_xl_most150_ecl_sequence { + unsigned int sequenceStarted; +} XL_MOST150_ECL_SEQUENCE_EV; + +typedef struct s_xl_most150_ecl_glitch_filter { + unsigned int duration; +} XL_MOST150_ECL_GLITCH_FILTER_EV; + +typedef struct s_xl_most150_sso_result { + unsigned int status; +} XL_MOST150_SSO_RESULT_EV; + + +typedef struct s_xl_most150_ctrl_tx_ack { + unsigned short targetAddress; + unsigned short sourceAddress; + unsigned char ctrlPrio; + unsigned char ctrlSendAttempts; + unsigned char reserved[2]; + unsigned int status; + + // ctrlData structure: + // ----------------------------------------------------------------------- + // FBlockID | InstID | FunctionID | OpType | TelID | TelLen | Payload + // ----------------------------------------------------------------------- + // 8 bit | 8 bit | 12 bit | 4 bit | 4 bit | 12 bit | 0 .. 45 byte + // ----------------------------------------------------------------------- + // ctrlData[0]: FBlockID + // ctrlData[1]: InstID + // ctrlData[2]: FunctionID (upper 8 bits) + // ctrlData[3]: FunctionID (lower 4 bits) + OpType (4 bits) + // ctrlData[4]: TelId (4 bits) + TelLen (upper 4 bits) + // ctrlData[5]: TelLen (lower 8 bits) + // ctrlData[6..50]: Payload + unsigned char ctrlData[51]; +} XL_MOST150_CTRL_TX_ACK_EV; + +typedef struct s_xl_most150_async_tx_ack { + unsigned char priority; + unsigned char asyncSendAttempts; + unsigned short length; + unsigned short targetAddress; + unsigned short sourceAddress; + unsigned int status; + unsigned char asyncData[1524]; +} XL_MOST150_ASYNC_TX_ACK_EV; + +typedef struct s_xl_most150_ethernet_tx { + unsigned char priority; + unsigned char ethSendAttempts; + unsigned char sourceAddress[6]; + unsigned char targetAddress[6]; + unsigned char reserved[2]; + unsigned int length; + unsigned char ethernetData[1510]; +} XL_MOST150_ETHERNET_TX_ACK_EV; + +typedef struct s_xl_most150_hw_sync { + unsigned int pulseCode; +} XL_MOST150_HW_SYNC_EV; + +typedef struct s_xl_event_most150 { + + unsigned int size; // 4 - overall size of the complete event + XLmostEventTag tag; // 2 - type of the event + unsigned short channelIndex; // 2 + unsigned int userHandle; // 4 + unsigned short flagsChip; // 2 + unsigned short reserved; // 2 + XLuint64 timeStamp; // 8 - raw timestamp + XLuint64 timeStampSync; // 8 - timestamp which is synchronized by the driver + // --------- + // 32 bytes -> XL_MOST_EVENT_HEADER_SIZE + union { + unsigned char rawData[XL_MOST150_MAX_EVENT_DATA_SIZE]; + XL_MOST150_EVENT_SOURCE_EV mostEventSource; + XL_MOST150_DEVICE_MODE_EV mostDeviceMode; + XL_MOST150_FREQUENCY_EV mostFrequency; + XL_MOST150_SPECIAL_NODE_INFO_EV mostSpecialNodeInfo; + XL_MOST150_CTRL_RX_EV mostCtrlRx; + XL_MOST150_CTRL_TX_ACK_EV mostCtrlTxAck; + XL_MOST150_ASYNC_SPY_EV mostAsyncSpy; + XL_MOST150_ASYNC_RX_EV mostAsyncRx; + XL_MOST150_SYNC_ALLOC_INFO_EV mostSyncAllocInfo; + XL_MOST150_SYNC_VOLUME_STATUS_EV mostSyncVolumeStatus; + XL_MOST150_TX_LIGHT_EV mostTxLight; + XL_MOST150_RXLIGHT_LOCKSTATUS_EV mostRxLightLockStatus; + XL_MOST150_ERROR_EV mostError; + XL_MOST150_CONFIGURE_RX_BUFFER_EV mostConfigureRxBuffer; + XL_MOST150_CTRL_SYNC_AUDIO_EV mostCtrlSyncAudio; + XL_MOST150_SYNC_MUTE_STATUS_EV mostSyncMuteStatus; + XL_MOST150_LIGHT_POWER_EV mostLightPower; + XL_MOST150_GEN_LIGHT_ERROR_EV mostGenLightError; + XL_MOST150_GEN_LOCK_ERROR_EV mostGenLockError; + XL_MOST150_CTRL_BUSLOAD_EV mostCtrlBusload; + XL_MOST150_ASYNC_BUSLOAD_EV mostAsyncBusload; + XL_MOST150_ETHERNET_RX_EV mostEthernetRx; + XL_MOST150_SYSTEMLOCK_FLAG_EV mostSystemLockFlag; + XL_MOST150_SHUTDOWN_FLAG_EV mostShutdownFlag; + XL_MOST150_SPDIF_MODE_EV mostSpdifMode; + XL_MOST150_ECL_EV mostEclEvent; + XL_MOST150_ECL_TERMINATION_EV mostEclTermination; + XL_MOST150_CTRL_SPY_EV mostCtrlSpy; + XL_MOST150_ASYNC_TX_ACK_EV mostAsyncTxAck; + XL_MOST150_ETHERNET_SPY_EV mostEthernetSpy; + XL_MOST150_ETHERNET_TX_ACK_EV mostEthernetTxAck; + XL_MOST150_HW_SYNC_EV mostHWSync; + XL_MOST150_NW_STARTUP_EV mostStartup; + XL_MOST150_NW_SHUTDOWN_EV mostShutdown; + XL_MOST150_STREAM_STATE_EV mostStreamState; + XL_MOST150_STREAM_TX_BUFFER_EV mostStreamTxBuffer; + XL_MOST150_STREAM_RX_BUFFER_EV mostStreamRxBuffer; + XL_MOST150_STREAM_TX_UNDERFLOW_EV mostStreamTxUnderflow; + XL_MOST150_STREAM_TX_LABEL_EV mostStreamTxLabel; + XL_MOST150_GEN_BYPASS_STRESS_EV mostGenBypassStress; + XL_MOST150_ECL_SEQUENCE_EV mostEclSequence; + XL_MOST150_ECL_GLITCH_FILTER_EV mostEclGlitchFilter; + XL_MOST150_SSO_RESULT_EV mostSsoResult; + } tagData; +} XLmost150event; + + +/////////////////////////////////////////////////////////////////////////////////// +// Structures for MOST150 API commands +/////////////////////////////////////////////////////////////////////////////////// + +//XLstatus xlMost150SetSpecialNodeInfo(DEFPARAMS, XLmost150SetSpecialNodeInfo *specialodeInfo); +typedef struct s_xl_set_most150_special_node_info { + unsigned int changeMask; // see XL_MOST150_SPECIAL_NODE_MASK_CHANGED + unsigned int nodeAddress; + unsigned int groupAddress; + unsigned int sbc; + unsigned int ctrlRetryTime; + unsigned int ctrlSendAttempts; + unsigned int asyncRetryTime; + unsigned int asyncSendAttempts; + unsigned char macAddr[6]; +} XLmost150SetSpecialNodeInfo; + +//XLstatus xlMost150CtrlTransmit(DEFPARAMS, XLmost150CtrlTxMsg *pCtrlTxMsg); +typedef struct s_xl_most150_ctrl_tx_msg { + unsigned int ctrlPrio; // Prio: Currently fixed to 0x01 for Control Messages + unsigned int ctrlSendAttempts; // 1..16 attempts, set an invalid value to use the default value set by xlMost150SetCtrlRetryParameters + unsigned int targetAddress; + + // ctrlData structure: + // ----------------------------------------------------------------------- + // FBlockID | InstID | FunctionID | OpType | TelID | TelLen | Payload + // ----------------------------------------------------------------------- + // 8 bit | 8 bit | 12 bit | 4 bit | 4 bit | 12 bit | 0 .. 45 byte + // ----------------------------------------------------------------------- + // ctrlData[0]: FBlockID + // ctrlData[1]: InstID + // ctrlData[2]: FunctionID (upper 8 bits) + // ctrlData[3]: FunctionID (lower 4 bits) + OpType (4 bits) + // ctrlData[4]: TelId (4 bits) + TelLen (upper 4 bits) + // ctrlData[5]: TelLen (lower 8 bits) + // ctrlData[6..50]: Payload + unsigned char ctrlData[51]; +} XLmost150CtrlTxMsg; + +//XLstatus xlMost150AsyncTransmit(DEFPARAMS, XLmost150AsyncTxMsg *pAsyncTxMsg); +typedef struct s_xl_most150_async_tx_msg { + unsigned int priority; // Prio: Currently fixed to 0x00 for MDP /MEP + unsigned int asyncSendAttempts; // 1..16 attempts,set an invalid value to use the default value set by xlMost150SetAsyncRetryParameters + unsigned int length; // max. 1600 bytes + unsigned int targetAddress; + unsigned char asyncData[XL_MOST150_ASYNC_SEND_PAYLOAD_MAX_SIZE]; +} XLmost150AsyncTxMsg; + +//XLstatus xlMost150EthernetTransmit(DEFPARAMS, XLmost150EthernetTxMsg *pEthernetTxMsg); +typedef struct s_xl_most150_ethernet_tx_msg { + unsigned int priority; // Prio: Currently fixed to 0x00 for MDP /MEP + unsigned int ethSendAttempts; // 1..16 attempts, set an invalid value to use the default value set by xlMost150SetAsyncRetryParameters + unsigned char sourceAddress[6]; + unsigned char targetAddress[6]; + unsigned int length; // max. 1600 bytes + unsigned char ethernetData[XL_MOST150_ETHERNET_SEND_PAYLOAD_MAX_SIZE]; +} XLmost150EthernetTxMsg; + +//XLstatus xlMost150CtrlSyncAudio(DEFPARAMS, XLmost150SyncAudioParameter *syncAudioParameter); +typedef struct s_xl_most150_sync_audio_parameter { + unsigned int label; + unsigned int width; + unsigned int device; + unsigned int mode; +} XLmost150SyncAudioParameter; + +//XLstatus xlMost150CtrlConfigureBusload(DEFPARAMS, XLmost150CtrlBusloadConfig *pCtrlBusloadConfig); +typedef struct s_xl_most150_ctrl_busload_config { + unsigned int transmissionRate; + unsigned int counterType; + unsigned int counterPosition; // counter can be only be set in the payload -> position 0 means first payload byte! + XLmost150CtrlTxMsg busloadCtrlMsg; +} XLmost150CtrlBusloadConfig; + +//XLstatus xlMost150AsyncConfigureBusload(DEFPARAMS, XLmost150AsyncBusloadConfig *pAsyncBusloadConfig); +typedef struct s_xl_most150_async_busload_config { + unsigned int busloadType; + unsigned int transmissionRate; + unsigned int counterType; + unsigned int counterPosition; + union { + unsigned char rawBusloadPkt[1540]; + XLmost150AsyncTxMsg busloadAsyncPkt; + XLmost150EthernetTxMsg busloadEthernetPkt; + } busloadPkt; +} XLmost150AsyncBusloadConfig; + +//XLstatus xlMost150StreamOpen(DEFPARAMS, XLmost150StreamOpen* pStreamOpen); +typedef struct s_xl_most150_stream_open { + unsigned int* pStreamHandle; + unsigned int direction; + unsigned int numBytesPerFrame; + unsigned int reserved; + unsigned int latency; +} XLmost150StreamOpen; + +//XLstatus xlMost150StreamGetInfo(DEFPARAMS, XLmost150StreamInfo* pStreamInfo); +typedef struct s_xl_most150_stream_get_info { + unsigned int streamHandle; + unsigned int numBytesPerFrame; + unsigned int direction; + unsigned int reserved; + unsigned int latency; + unsigned int streamState; + unsigned int connLabels[XL_MOST150_STREAM_RX_NUM_CL_MAX]; +} XLmost150StreamInfo; + + +#include + +#include + +/////////////////////////////////////////////////////////////////////// +// CAN / CAN-FD types and definitions +/////////////////////////////////////////////////////////////////////// + +#define XL_CAN_MAX_DATA_LEN 64 +#define XL_CANFD_RX_EVENT_HEADER_SIZE 32 +#define XL_CANFD_MAX_EVENT_SIZE 128 + +//////////////////////////////////////////////////////////////////////// +// get the number of databytes from dlc/edl/rtr in received events +#define CANFD_GET_NUM_DATABYTES(dlc, edl, rtr) \ + ((rtr)?0: \ + (dlc)<9?(dlc): \ + !(edl)?8: \ + (dlc)== 9?12: \ + (dlc)==10?16: \ + (dlc)==11?20: \ + (dlc)==12?24: \ + (dlc)==13?32: \ + (dlc)==14?48:64) + +// to be used with XLcanTxEvent::XL_CAN_TX_MSG::msgFlags +#define XL_CAN_TXMSG_FLAG_EDL 0x0001 // extended data length +#define XL_CAN_TXMSG_FLAG_BRS 0x0002 // baud rate switch +#define XL_CAN_TXMSG_FLAG_RTR 0x0010 // remote transmission request +#define XL_CAN_TXMSG_FLAG_HIGHPRIO 0x0080 // high priority message - clears all send buffers - then transmits +#define XL_CAN_TXMSG_FLAG_WAKEUP 0x0200 // generate a wakeup message + + +// to be used with +// XLcanRxEvent::XL_CAN_EV_RX_MSG::msgFlags +// XLcanRxEvent::XL_CAN_EV_TX_REQUEST::msgFlags +// XLcanRxEvent::XL_CAN_EV_RX_MSG::msgFlags +// XLcanRxEvent::XL_CAN_EV_TX_REMOVED::msgFlags +// XLcanRxEvent::XL_CAN_EV_ERROR::msgFlags +#define XL_CAN_RXMSG_FLAG_EDL 0x0001 // extended data length +#define XL_CAN_RXMSG_FLAG_BRS 0x0002 // baud rate switch +#define XL_CAN_RXMSG_FLAG_ESI 0x0004 // error state indicator +#define XL_CAN_RXMSG_FLAG_RTR 0x0010 // remote transmission request +#define XL_CAN_RXMSG_FLAG_EF 0x0200 // error frame (only posssible in XL_CAN_EV_TX_REQUEST/XL_CAN_EV_TX_REMOVED) +#define XL_CAN_RXMSG_FLAG_ARB_LOST 0x0400 // Arbitration Lost + // set if the receiving node tried to transmit a message but lost arbitration process +#define XL_CAN_RXMSG_FLAG_WAKEUP 0x2000 // high voltage message on single wire CAN +#define XL_CAN_RXMSG_FLAG_TE 0x4000 // 1: transceiver error detected + + + +//////////////////////////////////////////////////////////////////////// +// CAN / CAN-FD tx event definitions +//////////////////////////////////////////////////////////////////////// + +typedef struct { + unsigned int canId; + unsigned int msgFlags; + unsigned char dlc; + unsigned char reserved[7]; + unsigned char data[XL_CAN_MAX_DATA_LEN]; +} XL_CAN_TX_MSG; + +typedef struct { + unsigned short tag; // 2 - type of the event + unsigned short transId; // 2 + unsigned char channelIndex; // 1 - internal has to be 0 + unsigned char reserved[3]; // 3 - has to be zero + + union { + XL_CAN_TX_MSG canMsg; + } tagData; +} XLcanTxEvent; + + + +//////////////////////////////////////////////////////////////////////// +// CAN / CAN-FD rx event definitions +//////////////////////////////////////////////////////////////////////// + +// used with XL_CAN_EV_TAG_RX_OK, XL_CAN_EV_TAG_TX_OK +typedef struct { + unsigned int canId; + unsigned int msgFlags; + unsigned int crc; + unsigned char reserved1[12]; + unsigned short totalBitCnt; + unsigned char dlc; + unsigned char reserved[5]; + unsigned char data[XL_CAN_MAX_DATA_LEN]; +} XL_CAN_EV_RX_MSG; + +typedef struct { + unsigned int canId; + unsigned int msgFlags; + unsigned char dlc; + unsigned char reserved1; + unsigned short reserved; + unsigned char data[XL_CAN_MAX_DATA_LEN]; +} XL_CAN_EV_TX_REQUEST; + + +// to be used with XL_CAN_EV_TAG_CHIP_STATE +typedef struct { + unsigned char busStatus; + unsigned char txErrorCounter; + unsigned char rxErrorCounter; + unsigned char reserved; + unsigned int reserved0; +} XL_CAN_EV_CHIP_STATE; + + +typedef XL_SYNC_PULSE_EV XL_CAN_EV_SYNC_PULSE; + +// to be used with XL_CAN_EV_ERROR::errorCode +#define XL_CAN_ERRC_BIT_ERROR 1 +#define XL_CAN_ERRC_FORM_ERROR 2 +#define XL_CAN_ERRC_STUFF_ERROR 3 +#define XL_CAN_ERRC_OTHER_ERROR 4 +#define XL_CAN_ERRC_CRC_ERROR 5 +#define XL_CAN_ERRC_ACK_ERROR 6 +#define XL_CAN_ERRC_NACK_ERROR 7 +#define XL_CAN_ERRC_OVLD_ERROR 8 +#define XL_CAN_ERRC_EXCPT_ERROR 9 + +//to be used with XL_CAN_EV_TAG_RX_ERROR/XL_CAN_EV_TAG_TX_ERROR +typedef struct { + unsigned char errorCode; + unsigned char reserved[95]; +} XL_CAN_EV_ERROR; + +// to be used with XLcanRxEvent::flagsChip +#define XL_CAN_QUEUE_OVERFLOW 0x100 + +// max./min size of application rx fifo (bytes) +#define RX_FIFO_CANFD_QUEUE_SIZE_MAX 524288 // 0,5 MByte +#define RX_FIFO_CANFD_QUEUE_SIZE_MIN 8192 // 8 kByte + + +//------------------------------------------------------------------------------ +// General RX Event +typedef struct { + unsigned int size; // 4 - overall size of the complete event + unsigned short tag; // 2 - type of the event + unsigned short channelIndex; // 2 + unsigned int userHandle; // 4 (lower 12 bit available for CAN) + unsigned short flagsChip; // 2 queue overflow (upper 8bit) + unsigned short reserved0; // 2 + XLuint64 reserved1; // 8 + XLuint64 timeStampSync; // 8 - timestamp which is synchronized by the driver + + union { + unsigned char raw[XL_CANFD_MAX_EVENT_SIZE - XL_CANFD_RX_EVENT_HEADER_SIZE]; + XL_CAN_EV_RX_MSG canRxOkMsg; + XL_CAN_EV_RX_MSG canTxOkMsg; + XL_CAN_EV_TX_REQUEST canTxRequest; + + XL_CAN_EV_ERROR canError; + XL_CAN_EV_CHIP_STATE canChipState; + XL_CAN_EV_SYNC_PULSE canSyncPulse; + } tagData; +} XLcanRxEvent; +#include + +#include + +/* ============================================================================== */ +/* */ +/* (2) DEFINES / MACROS */ +/* */ +/* ============================================================================== */ + +/////////////////////////////////////////////////////////////////////// +// ARINC429 types and definitions +/////////////////////////////////////////////////////////////////////// + +// defines for XL_A429_PARAMS::channelDirection +#define XL_A429_MSG_CHANNEL_DIR_TX 0x01 +#define XL_A429_MSG_CHANNEL_DIR_RX 0x02 + +// to be used with XL_A429_PARAMS::data::tx::bitrate +#define XL_A429_MSG_BITRATE_SLOW_MIN 10500 +#define XL_A429_MSG_BITRATE_SLOW_MAX 16000 +#define XL_A429_MSG_BITRATE_FAST_MIN 90000 +#define XL_A429_MSG_BITRATE_FAST_MAX 110000 + +// to be used with XL_A429_PARAMS::data::tx/rx::minGap +#define XL_A429_MSG_GAP_4BIT 32 + +// to be used with XL_A429_PARAMS::rx::minBitrate/maxBitrate +#define XL_A429_MSG_BITRATE_RX_MIN 10000 +#define XL_A429_MSG_BITRATE_RX_MAX 120000 + +// to be used with XL_A429_PARAMS::rx::autoBaudrate +#define XL_A429_MSG_AUTO_BAUDRATE_DISABLED 0 +#define XL_A429_MSG_AUTO_BAUDRATE_ENABLED 1 + +// to be used with XL_A429_TX_MSG::flags +#define XL_A429_MSG_FLAG_ON_REQUEST 0x00000001 +#define XL_A429_MSG_FLAG_CYCLIC 0x00000002 +#define XL_A429_MSG_FLAG_DELETE_CYCLIC 0x00000004 + +// to be used with XL_A429_TX_MSG::cycleTime +#define XL_A429_MSG_CYCLE_MAX 0x3FFFFFFF + +// to be used with XL_A429_TX_MSG::gap +#define XL_A429_MSG_GAP_DEFAULT 0 // get minGap config from set channel params +#define XL_A429_MSG_GAP_MAX 0x000FFFFF + +// to be used with XL_A429_PARAMS::data::parity +// to be used with XL_A429_TX_MSG::parity +#define XL_A429_MSG_PARITY_DEFAULT 0 // get parity config from set channel params +#define XL_A429_MSG_PARITY_DISABLED 1 // tx: get parity config from transmit data - rx: check disabled +#define XL_A429_MSG_PARITY_ODD 2 +#define XL_A429_MSG_PARITY_EVEN 3 + +// to be used with XLa429RxEvent::XL_A429_EV_TX_OK::msgCtrl +#define XL_A429_EV_TX_MSG_CTRL_ON_REQUEST 0 +#define XL_A429_EV_TX_MSG_CTRL_CYCLIC 1 + +// to be used with XLa429RxEvent::XL_A429_EV_TX_ERR::errorReason +#define XL_A429_EV_TX_ERROR_ACCESS_DENIED 0 +#define XL_A429_EV_TX_ERROR_TRANSMISSION_ERROR 1 + +// to be used with XLa429RxEvent::XL_A429_EV_RX_ERR::errorReason +#define XL_A429_EV_RX_ERROR_GAP_VIOLATION 0 +#define XL_A429_EV_RX_ERROR_PARITY 1 +#define XL_A429_EV_RX_ERROR_BITRATE_LOW 2 +#define XL_A429_EV_RX_ERROR_BITRATE_HIGH 3 +#define XL_A429_EV_RX_ERROR_FRAME_FORMAT 4 +#define XL_A429_EV_RX_ERROR_CODING_RZ 5 +#define XL_A429_EV_RX_ERROR_DUTY_FACTOR 6 +#define XL_A429_EV_RX_ERROR_AVG_BIT_LENGTH 7 + +// to be used with XLa429RxEvent::flagsChip +#define XL_A429_QUEUE_OVERFLOW 0x100 + +// max./min size of application rx fifo (bytes) +#define XL_A429_RX_FIFO_QUEUE_SIZE_MAX 524288 // 0,5 MByte +#define XL_A429_RX_FIFO_QUEUE_SIZE_MIN 8192 // 8 kByte + +/* ============================================================================== */ +/* */ +/* (3) TYPE DEFINITIONS */ +/* */ +/* ============================================================================== */ + +//////////////////////////////////////////////////////////////////////// +// ARINC429 paramter configuration definitions +//////////////////////////////////////////////////////////////////////// + +typedef struct s_xl_a429_params { + unsigned short channelDirection; + unsigned short res1; + union { + struct { + unsigned int bitrate; + unsigned int parity; + unsigned int minGap; + } tx; + struct { + unsigned int bitrate; + unsigned int minBitrate; + unsigned int maxBitrate; + unsigned int parity; + unsigned int minGap; + unsigned int autoBaudrate; + } rx; + unsigned char raw[28]; + } data; +} XL_A429_PARAMS; + +//////////////////////////////////////////////////////////////////////// +// ARINC429 tx event definitions +//////////////////////////////////////////////////////////////////////// + +typedef struct s_xl_a429_msg_tx { + unsigned short userHandle; + unsigned short res1; + unsigned int flags; + unsigned int cycleTime; + unsigned int gap; + unsigned char label; + unsigned char parity; + unsigned short res2; + unsigned int data; +} XL_A429_MSG_TX; + +//////////////////////////////////////////////////////////////////////// +// ARINC429 rx event definitions +//////////////////////////////////////////////////////////////////////// + +// used with XL_A429_EV_TAG_TX_OK +typedef struct s_xl_a429_ev_tx_ok { + unsigned int frameLength; + unsigned int bitrate; + unsigned char label; + unsigned char msgCtrl; + unsigned short res1; + unsigned int data; +} XL_A429_EV_TX_OK; + +// used with XL_A429_EV_TAG_TX_ERR +typedef struct s_xl_a429_ev_tx_err { + unsigned int frameLength; + unsigned int bitrate; + unsigned char errorPosition; + unsigned char errorReason; + unsigned char label; + unsigned char res1; + unsigned int data; +} XL_A429_EV_TX_ERR; + +// used with XL_A429_EV_TAG_RX_OK +typedef struct s_xl_a429_ev_rx_ok { + unsigned int frameLength; + unsigned int bitrate; + unsigned char label; + unsigned char res1[3]; + unsigned int data; +} XL_A429_EV_RX_OK; + +// used with XL_A429_EV_TAG_RX_ERR +typedef struct s_xl_a429_ev_rx_err { + unsigned int frameLength; + unsigned int bitrate; + unsigned int bitLengthOfLastBit; + unsigned char errorPosition; + unsigned char errorReason; + unsigned char label; + unsigned char res1; + unsigned int data; +} XL_A429_EV_RX_ERR; + +// used with XL_A429_EV_TAG_BUS_STATISTIC +typedef struct s_xl_a429_ev_bus_statistic { + unsigned int busLoad; // 0.00-100.00% + unsigned int res1[3]; +} XL_A429_EV_BUS_STATISTIC; + +typedef XL_SYNC_PULSE_EV XL_A429_EV_SYNC_PULSE; + +typedef struct { + unsigned int size; // 4 - overall size of the complete event + unsigned short tag; // 2 - type of the event + unsigned char channelIndex; // 1 + unsigned char reserved; // 1 + unsigned int userHandle; // 4 (lower 12 bit available for CAN) + unsigned short flagsChip; // 2 queue overflow (upper 8bit) + unsigned short reserved0; // 1 + XLuint64 timeStamp; // 8 - raw timestamp + XLuint64 timeStampSync; // 8 - timestamp which is synchronized by the driver + + union { + XL_A429_EV_TX_OK a429TxOkMsg; + XL_A429_EV_TX_ERR a429TxErrMsg; + XL_A429_EV_RX_OK a429RxOkMsg; + XL_A429_EV_RX_ERR a429RxErrMsg; + XL_A429_EV_BUS_STATISTIC a429BusStatistic; + XL_A429_EV_SYNC_PULSE a429SyncPulse; + } tagData; +} XLa429RxEvent; + +#include +/////////////////////////////////////////////////////////////////////////////// +// Function calls +//////////////////////////////////////////////////////////////////////////////// +// common functions +/*------------------------------------------------------------------------------ +xlOpenDriver(): +-------------------------------------------------------------------------------- +The Application calls this function to get access to the driver. +*/ + +#ifdef DYNAMIC_XLDRIVER_DLL + // in case of dynamic loading the application defines this function + typedef XLstatus (_XL_EXPORT_API *XLOPENDRIVER) (void); +#else + XLstatus _XL_EXPORT_DECL xlOpenDriver(void); +#endif + +/*------------------------------------------------------------------------------ +xlCloseDriver (): +-------------------------------------------------------------------------------- +The driver is closed. +This is used to unload the driver, if no more application is using it. +Does not close the open ports !!! +*/ + +#ifdef DYNAMIC_XLDRIVER_DLL + typedef XLstatus (_XL_EXPORT_API *XLCLOSEDRIVER) (void); +#else + XLstatus _XL_EXPORT_DECL xlCloseDriver(void); +#endif + +/*------------------------------------------------------------------------------ +xlSetApplConfig(): +xlGetApplConfig(): +-------------------------------------------------------------------------------- +Handle the application configuration for VCANCONF.EXE +*/ + +/* +Returns the hwIndex, hwChannel and hwType for a specific Application and application channel. +This gives the ability to register own applications into the Vector +CAN DRIVER CONFIGURATION. +AppName: Zero terminated string containing the Name of the Application. +AppChannel: Channel of the application +hwType, hwIndex, hwChannel: contains the the hardware information on success. +This values can be used in a subsequent call to xlGetChannelMask or xlGetChannelIndex. +*/ + +DECL_STDXL_FUNC( xlGetApplConfig, XLGETAPPLCONFIG, ( + char *appName, // Used timerrate would be 250us. +*/ + +DECL_STDXL_FUNC ( xlSetTimerRateAndChannel, XLSETTIMERRATEANDCHANNEL, ( + XLportHandle portHandle, + XLaccess *timerChannelMask, + unsigned long *timerRate) + ); + + +/*------------------------------------------------------------------------------ +xlResetClock(): +-------------------------------------------------------------------------------- +The clock generating timestamps for the port will be reset +*/ + +DECL_STDXL_FUNC ( xlResetClock, XLRESETCLOCK, (XLportHandle portHandle)); + +/*------------------------------------------------------------------------------ +xlSetNotification(): +-------------------------------------------------------------------------------- +Setup an event to notify the application if there are messages in the +ports receive queue. +queueLevel specifies the number of messages that triggers the event. +Note that the event is triggered only once, when the queueLevel is +reached. An application should read all available messages by xlReceive +to be sure to re enable the event. The API generates the handle by +itself. For LIN the queueLevel is fix to one. +*/ + +DECL_STDXL_FUNC ( xlSetNotification, XLSETNOTIFICATION, ( + XLportHandle portHandle, + XLhandle *pHandle, + int queueLevel) + ); + + +/*------------------------------------------------------------------------------ +xlSetTimerBasedNotifiy(): +-------------------------------------------------------------------------------- +Setup a event to notify the application based on the timerrate which can +be set by xlSetTimerRate()/xlSetTimerRateAndChannel(). +*/ + +DECL_STDXL_FUNC ( xlSetTimerBasedNotify, XLSETTIMERBASEDNOTIFY, ( + XLportHandle portHandle, + XLhandle *pHandle) + ); + +/*------------------------------------------------------------------------------ +xlFlushReceiveQueue(): +-------------------------------------------------------------------------------- +The receive queue of the port will be flushed. +*/ + +DECL_STDXL_FUNC ( xlFlushReceiveQueue, XLFLUSHRECEIVEQUEUE, (XLportHandle portHandle)); + +/*------------------------------------------------------------------------------ +xlGetReceiveQueueLevel(): +-------------------------------------------------------------------------------- +The count of events in the receive queue of the port will be returned. +*/ + +DECL_STDXL_FUNC ( xlGetReceiveQueueLevel, XLGETRECEIVEQUEUELEVEL, ( + XLportHandle portHandle, + int *level) + ); + +/*------------------------------------------------------------------------------ +xlActivateChannel(): +-------------------------------------------------------------------------------- +The selected channels go 'on the bus'. Type of the bus is specified by busType parameter. +Additional parameters can be specified by flags parameter. +*/ + +DECL_STDXL_FUNC ( xlActivateChannel, XLACTIVATECHANNEL, ( + XLportHandle portHandle, + XLaccess accessMask, + unsigned int busType, + unsigned int flags) + ); + + +/*------------------------------------------------------------------------------ +xlReceive(): +-------------------------------------------------------------------------------- +The driver is asked to retrieve burst of Events from the +application's receive queue. This function is optimized +for speed. pEventCount on start must contain size of the buffer in +messages, on return it sets number of really received messages (messages +written to pEvents buffer). +Application must allocate pEvents buffer big enough to hold number of +messages requested by pEventCount parameter. +It returns VERR_QUEUE_IS_EMPTY and *pEventCount=0 if no event +was received. +The function only works for CAN, LIN, DAIO. For MOST there is a different +function +*/ + +DECL_STDXL_FUNC ( xlReceive, XLRECEIVE, ( + XLportHandle portHandle, + unsigned int *pEventCount, + XLevent *pEvents) + ); + +/*------------------------------------------------------------------------------ +xlGetErrorString(): +xlGetEventString(): +xlCanGetEventString(): +-------------------------------------------------------------------------------- +Utility Functions +*/ +#ifdef DYNAMIC_XLDRIVER_DLL + typedef XLstringType (_XL_EXPORT_API *XLGETERRORSTRING) ( XLstatus err ); + typedef XLstringType (_XL_EXPORT_API *XLGETEVENTSTRING)( XLevent *pEv ); + typedef XLstringType (_XL_EXPORT_API *XLCANGETEVENTSTRING)( XLcanRxEvent *pEv ); +#else + XLstringType _XL_EXPORT_DECL xlGetErrorString( XLstatus err ); + XLstringType _XL_EXPORT_DECL xlGetEventString( XLevent *pEv ); + XLstringType _XL_EXPORT_DECL xlCanGetEventString( XLcanRxEvent *pEv ); +#endif + +/*------------------------------------------------------------------------------ +xlOemContact(): +-------------------------------------------------------------------------------- +*/ + +DECL_STDXL_FUNC ( xlOemContact, XLOEMCONTACT, (XLportHandle portHandle, unsigned long Channel, XLuint64 context1, XLuint64 *context2)); + +/*------------------------------------------------------------------------------ +xlGetSyncTime(): +-------------------------------------------------------------------------------- +Function is reading high precision (1ns) card time used for time synchronization +of Party Line trigger (sync line). +*/ + +DECL_STDXL_FUNC ( xlGetSyncTime, XLGETSYNCTIME, ( + XLportHandle portHandle, + XLuint64 *pTime ) + ); + +/*------------------------------------------------------------------------------ +xlGetChannelTime(): +-------------------------------------------------------------------------------- +Function reads the 64-bit PC-based card time. +*/ + +DECL_STDXL_FUNC ( xlGetChannelTime, XLGETCHANNELTIME, ( + XLportHandle portHandle, + XLaccess accessMask, + XLuint64 *pChannelTime ) + ); + +/*------------------------------------------------------------------------------ +xlGenerateSyncPulse(): +-------------------------------------------------------------------------------- +Activates short sync pulse on desired channel. Channels mask should not +define two channels of one hardware. + +*/ + +DECL_STDXL_FUNC ( xlGenerateSyncPulse, XLGENERATESYNCPULSE, ( + XLportHandle portHandle, + XLaccess accessMask) + ); + +/*------------------------------------------------------------------------------ +xlPopupHwConfig(): +-------------------------------------------------------------------------------- +*/ + +DECL_STDXL_FUNC ( xlPopupHwConfig, XLPOPUPHWCONFIG, ( + char *callSign, + unsigned int waitForFinish) + ); + + +/*------------------------------------------------------------------------------ +xlDeactivateChannel(): +-------------------------------------------------------------------------------- +The selected channels go 'off the bus'. +Its now possible to initialize +*/ + +DECL_STDXL_FUNC ( xlDeactivateChannel, XLDEACTIVATECHANNEL, ( + XLportHandle portHandle, + XLaccess accessMask) + ); + +/*------------------------------------------------------------------------------ +xlClosePort(): +-------------------------------------------------------------------------------- +The port is closed, channels are deactivated. +*/ + +DECL_STDXL_FUNC ( xlClosePort, XLCLOSEPORT, ( + XLportHandle portHandle) + ); + +//////////////////////////////////////////////////////////////////////////////// +// CAN functions +//////////////////////////////////////////////////////////////////////////////// +/*------------------------------------------------------------------------------ +xlCanFlushTransmitQueue(): +// TODO: fr MOST nutzen +-------------------------------------------------------------------------------- +The transmit queue of the selected channel will be flushed. +*/ + +DECL_STDXL_FUNC ( xlCanFlushTransmitQueue, XLCANFLUSHTRANSMITQUEUE, ( + XLportHandle portHandle, XLaccess accessMask) + ); + +/*------------------------------------------------------------------------------ +xlCanSetChannelOutput(): +-------------------------------------------------------------------------------- +The output mode for the CAN chips of the channels defined by accessMask, is set +to OUTPUT_MODE_NORMAL or OUTPUT_MODE_SILENT. +The port must have init access to the channels. +*/ + +DECL_STDXL_FUNC ( xlCanSetChannelOutput, XLCANSETCHANNELOUTPUT, ( + XLportHandle portHandle, + XLaccess accessMask, + int mode) + ); + + +/*------------------------------------------------------------------------------ +xlCanSetChannelMode(): +-------------------------------------------------------------------------------- +For the CAN channels defined by AccessMask is set +whether the caller will get a TX and/or a TXRQ +receipt for transmitted messages. +The port must have init access to the channels. +*/ + +DECL_STDXL_FUNC ( xlCanSetChannelMode, XLCANSETCHANNELMODE, ( + XLportHandle portHandle, + XLaccess accessMask, + int tx, + int txrq) + ); + +/*------------------------------------------------------------------------------ +xlCanSetReceiveMode(): +-------------------------------------------------------------------------------- +*/ + +DECL_STDXL_FUNC (xlCanSetReceiveMode, XLCANSETRECEIVEMODE, ( + XLportHandle Port, // Port Handle + unsigned char ErrorFrame, // suppress Error Frames + unsigned char ChipState // suppress Chip States + ) + ); + + +/*------------------------------------------------------------------------------*/ +/** xlCanSetChannelTransceiver(): + *\brief The transceiver mode is set for all channels defined by accessMask. + * The port must have init access to the channels. + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device state + * \param type [IN] Reserved. Should always be set to zero! + * \param lineMode [IN] Transceiver operation mode (specified by defines 'XL_TRANSCEIVER_LINEMODE_*') + * \param resNet [IN] Reserved. Should always be set to zero! + */ + +DECL_STDXL_FUNC ( xlCanSetChannelTransceiver, XLCANSETCHANNELTRANSCEIVER, ( + XLportHandle portHandle, + XLaccess accessMask, + int type, + int lineMode, + int resNet) + ); + +/*------------------------------------------------------------------------------ +xlCanSetChannelParams(): +xlCanSetChannelParamsC200(): +xlCanSetChannelBitrate(): +-------------------------------------------------------------------------------- +The channels defined by accessMask will be initialized with the +given parameters. +The port must have init access to the channels. +*/ + +DECL_STDXL_FUNC ( xlCanSetChannelParams, XLCANSETCHANNELPARAMS, ( + XLportHandle portHandle, + XLaccess accessMask, + XLchipParams* pChipParams) + ); + +DECL_STDXL_FUNC ( xlCanSetChannelParamsC200, XLCANSETCHANNELPARAMSC200, ( + XLportHandle portHandle, + XLaccess accessMask, + unsigned char btr0, + unsigned char btr1) + ); + +DECL_STDXL_FUNC ( xlCanSetChannelBitrate, XLCANSETCHANNELBITRATE, ( + XLportHandle portHandle, + XLaccess accessMask, + unsigned long bitrate) + ); + +//------------------------------------------------------------------------------ +// xlCanFdSetConfiguration +//-------------------------------------------------------------------------------- +// configures CAN-FD +DECL_STDXL_FUNC ( xlCanFdSetConfiguration, XLCANFDSETCONFIGURATION, ( + XLportHandle portHandle, + XLaccess accessMask, + XLcanFdConf* pCanFdConf) + ); + +//------------------------------------------------------------------------------ +// xlCanReceive +//-------------------------------------------------------------------------------- +// receives a CAN/CAN-FD event from the applications receive queue +DECL_STDXL_FUNC ( xlCanReceive, XLCANRECEIVE, ( + XLportHandle portHandle, + XLcanRxEvent* pXlCanRxEvt) + ); + +//------------------------------------------------------------------------------ +// xlCanTransmitEx +//-------------------------------------------------------------------------------- +// transmits a number of CAN / CAN-FD events +DECL_STDXL_FUNC ( xlCanTransmitEx, XLCANTRANSMITEX, ( + XLportHandle portHandle, + XLaccess accessMask, + unsigned int msgCnt, + unsigned int* pMsgCntSent, + XLcanTxEvent* pXlCanTxEvt) + ); + +/*------------------------------------------------------------------------------ +xlCanSetAcceptance(): +-------------------------------------------------------------------------------- +Set the acceptance filter +Filters for std and ext ids are handled independent in the driver. +Use mask=0xFFFF,code=0xFFFF or mask=0xFFFFFFFF,code=0xFFFFFFFF to fully close +the filter. +*/ + +DECL_STDXL_FUNC ( xlCanSetChannelAcceptance, XLCANSETCHANNELACCEPTANCE, ( + XLportHandle portHandle, + XLaccess accessMask, + unsigned long code, + unsigned long mask, + unsigned int idRange) + ); + +/*------------------------------------------------------------------------------ +xlCanAddAcceptanceRange(): +xlCanRemoveAcceptanceRange(): +xlCanResetAcceptance(): +-------------------------------------------------------------------------------- +*/ + +DECL_STDXL_FUNC ( xlCanAddAcceptanceRange, XLCANADDACCEPTANCERANGE, ( + XLportHandle portHandle, + XLaccess accessMask, + unsigned long first_id, + unsigned long last_id) + ); +DECL_STDXL_FUNC ( xlCanRemoveAcceptanceRange, XLCANREMOVEACCEPTANCERANGE, ( + XLportHandle portHandle, + XLaccess accessMask, + unsigned long first_id, + unsigned long last_id) + ); +DECL_STDXL_FUNC ( xlCanResetAcceptance, XLCANRESETACCEPTANCE, ( + XLportHandle portHandle, + XLaccess accessMask, + unsigned int idRange); + ); + +/*------------------------------------------------------------------------------ +xlCanRequestChipState(): +-------------------------------------------------------------------------------- +The state of the selected channels is requested. +The answer will be received as an event (XL_CHIP_STATE). +*/ + +DECL_STDXL_FUNC ( xlCanRequestChipState, XLCANREQUESTCHIPSTATE, ( + XLportHandle portHandle, + XLaccess accessMask) + ); + +/*------------------------------------------------------------------------------ +xlCanTransmit(): +-------------------------------------------------------------------------------- +This function is designed to send different messages to supported bus. +Usually pEvents is a pointer to XLevent array. pEvents points to variable +which contains information about how many messages should be transmitted +to desired channels. It must be less or same as pEventCount buffer size +in messages. On return function writes number of transmitted messages +(moved to device queue for transmitting). + +*/ + +DECL_STDXL_FUNC ( xlCanTransmit, XLCANTRANSMIT, ( + XLportHandle portHandle, + XLaccess accessMask, + unsigned int *pEventCount, + void *pEvents) + ); + +/*------------------------------------------------------------------------------ +xlSetGlobalTimeSync(): +-------------------------------------------------------------------------------- +To query and change the global time sync setting +*/ +DECL_STDXL_FUNC ( xlSetGlobalTimeSync, XLSETGLOBALTIMESYNC, (unsigned long newValue, + unsigned long *previousValue)); + + +/*------------------------------------------------------------------------------ +xlCheckLicense(): +-------------------------------------------------------------------------------- +For all channels the port wants to use it is checked whether +the hardware is licensed for the type of application. +If not the application should terminate. +*/ + +DECL_STDXL_FUNC ( xlCheckLicense, XLCHECKLICENSE, ( + XLportHandle portHandle, + XLaccess accessMask, + unsigned long protectionCode) + ); + + +/********************************************************************/ +/** xlGetLicenseInfo() + *\brief Function to get available licenses from Vector devices. + * This function returns the available licenses in an array of XLlicenseInfo structures. This array contains all available licenses on + * the queried channels. The position inside the array is defined by the license itself, e.g. the license for + * the Advanced-Flexray-Library is always at the same array index. + * \param channelMask [IN] : Channelmask for which to query the available licenses + * \param *pLicInfoArray [OUT]: Array with license overview + * \param licInfoArraySize [IN] : Size of array pointed to with 'pLicInfo' (number of array entries) + * \return XLstatus General status information is returned. + * XL_SUCCESS if no error occurred. + * XL_ERR_NO_RESOURCES if the given array size is too small to copy all available licenses into it. + * XL_ERROR if general error occurred. +*/ +DECL_STDXL_FUNC ( xlGetLicenseInfo, XLGETLICENSEINFO, ( + XLaccess channelMask, + XLlicenseInfo *pLicInfoArray, + unsigned int licInfoArraySize) + ); + + +//////////////////////////////////////////////////////////////////////////////// +// LIN functions +//////////////////////////////////////////////////////////////////////////////// + +DECL_STDXL_FUNC( xlLinSetChannelParams, XLLINSETCHANNELPARAMS, (XLportHandle portHandle, XLaccess accessMask, XLlinStatPar vStatPar)); +DECL_STDXL_FUNC( xlLinSetDLC, XLLINSETDLC, (XLportHandle portHandle, XLaccess accessMask, unsigned char dlc[64])); +DECL_STDXL_FUNC( xlLinSetSlave, XLLINSETSLAVE, (XLportHandle portHandle, XLaccess accessMask, unsigned char linId, unsigned char data[8], unsigned char dlc, unsigned short checksum)); +DECL_STDXL_FUNC( xlLinSendRequest, XLLINSENDREQUEST, (XLportHandle portHandle, XLaccess accessMask, unsigned char linId, unsigned int flags)); +DECL_STDXL_FUNC( xlLinSetSleepMode, XLLINSETSLEEPMODE, (XLportHandle portHandle, XLaccess accessMask, unsigned int flags, unsigned char linId)); +DECL_STDXL_FUNC( xlLinWakeUp, XLLINWAKEUP, (XLportHandle portHandle, XLaccess accessMask)); +DECL_STDXL_FUNC( xlLinSetChecksum, XLLINSETCHECKSUM, (XLportHandle portHandle, XLaccess accessMask, unsigned char checksum[60])); +DECL_STDXL_FUNC( xlLinSwitchSlave, XLLINSWITCHSLAVE, (XLportHandle portHandle, XLaccess accessMask, unsigned char linID, unsigned char mode)); + +//////////////////////////////////////////////////////////////////////////////// +// DAIO Function Declarations (IOcab) +//////////////////////////////////////////////////////////////////////////////// + +DECL_STDXL_FUNC (xlDAIOSetPWMOutput , XLDAIOSETPWMOUTPUT, (XLportHandle portHandle, XLaccess accessMask, unsigned int frequency, unsigned int value)); +DECL_STDXL_FUNC (xlDAIOSetDigitalOutput , XLDAIOSETDIGITALOUTPUT, (XLportHandle portHandle, XLaccess accessMask, unsigned int outputMask, unsigned int valuePattern)); +DECL_STDXL_FUNC (xlDAIOSetAnalogOutput , XLDAIOSETANALOGOUTPUT, (XLportHandle portHandle, XLaccess accessMask, unsigned int analogLine1, unsigned int analogLine2, unsigned int analogLine3, unsigned int analogLine4)); +DECL_STDXL_FUNC (xlDAIORequestMeasurement , XLDAIOREQUESTMEASUREMENT, (XLportHandle portHandle, XLaccess accessMask)); +DECL_STDXL_FUNC (xlDAIOSetDigitalParameters , XLDAIOSETDIGITALPARAMETERS, (XLportHandle portHandle, XLaccess accessMask, unsigned int inputMask, unsigned int outputMask)); +DECL_STDXL_FUNC (xlDAIOSetAnalogParameters , XLDAIOSETANALOGPARAMETERS, (XLportHandle portHandle, XLaccess accessMask, unsigned int inputMask, unsigned int outputMask, unsigned int highRangeMask)); +DECL_STDXL_FUNC (xlDAIOSetAnalogTrigger , XLDAIOSETANALOGTRIGGER, (XLportHandle portHandle, XLaccess accessMask, unsigned int triggerMask, unsigned int triggerLevel, unsigned int triggerEventMode)); +DECL_STDXL_FUNC (xlDAIOSetMeasurementFrequency , XLDAIOSETMEASUREMENTFREQUENCY, (XLportHandle portHandle, XLaccess accessMask, unsigned int measurementInterval)); +DECL_STDXL_FUNC (xlDAIOSetDigitalTrigger , XLDAIOSETDIGITALTRIGGER, (XLportHandle portHandle, XLaccess accessMask, unsigned int triggerMask)); + + +//////////////////////////////////////////////////////////////////////////////// +// extern declaration for dynamically linking... for functions without the macro +//////////////////////////////////////////////////////////////////////////////// + +#ifdef DYNAMIC_XLDRIVER_DLL +# ifndef DO_NOT_DEFINE_EXTERN_DECLARATION + + XLstatus xlOpenDriver(void); + XLstatus xlCloseDriver(void); + + extern XLGETCHANNELINDEX xlGetChannelIndex; + extern XLGETCHANNELMASK xlGetChannelMask; + + extern XLGETEVENTSTRING xlGetEventString; + extern XLCANGETEVENTSTRING xlCanGetEventString; + extern XLGETERRORSTRING xlGetErrorString; + +# endif +#endif + +//////////////////////////////////////////////////////////////////////////////// +// MOST Function Declarations +//////////////////////////////////////////////////////////////////////////////// + +// apiname, apitype, parameters in parenthesis + +/** + * Common principles: + * If not mentioned otherwise, all APIs are asynchronous and will trigger an action in VN2600. + * Results are delivered in events which can be fetched by xlMostReceive. + * + * Common Parameters: DEFPARAMS + * XLportHandle portHandle: was previously fetched by xlOpenPort API. + * XLaccess accessMask: determines on which channels an API should work. + * XLuserHandle userHandle: used to match the response of the driver to the requests of the application + * if an event is received spontaneously, e.g. MPR changed then the userHandle == 0 + * Common Return Value: + * XLstatus: common return value of most APIs which indicates whether a command was + * successfully launched or e.g. whether a command queue overflow happened + */ + +/** \brief fetching events from driver queue. + * This method is used to fetch events, either bus events or acknowledgments + * for commands from the driver queue. Each call delivers only one event (if an event is available). \n + * It is a synchronous mode and either delivers event data immediately, or + * indicates an error condition with its return value. + * \param XLportHandle portHandle: [IN] was previously fetched by xlOpenPort API (TODO) + * \param XLaccess accessMask: [IN] determines on which channels an API should work (TODO) + * \param pEventBuffer [IN] This parameter must point to a buffer to which the driver can copy + * the next event of the receive queue + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostReceive, XLFP_MOSTRECEIVE, (XLportHandle portHandle, XLmostEvent* pEventBuffer)); + +/** \brief Activates or deactivates the different event sources of VN2600. + * This method is used to select which bus events should be delivered by VN2600. + * Either CtrlNode, CtrlSpy, AsyncNode or AsyncSpy messages \n + * ResponseEvent: XL_MOST_EVENTSOURCES + * \param sourceMask [IN] each bit stands for an event source and can separately be set. + * Use the definitions of the sourcemask... + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostSwitchEventSources, XLFP_MOSTSWITCHEVENTSOURCES,(DEFPARAMS, unsigned short sourceMask)); + +/** \brief Activates or deactivates the bypass of the OS8104. + * This method is used to switch the Bypass OS8104 (register TODO:) on and off \n + * ResponseEvent: XL_MOST_ALLBYPASS + * \param bypassMode [IN] bypass open/close + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostSetAllBypass, XLFP_MOSTSETALLBYPASS, (DEFPARAMS, unsigned char bypassMode)); + +/** \brief Reads out the bypass mode of the OS8104. + * This method is asynchronous and requests the event used to switch the Bypass OS8104. + * ResponseEvent: XL_MOST_ALLBYPASS + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostGetAllBypass, XLFP_MOSTGETALLBYPASS, (DEFPARAMS)); + +/** \brief Switches the OS8104 into slave or master mode. + * This method is used to switch the OS8104 into the timing master or slave mode\n + * ResponseEvent: XL_MOST_TIMINGMODE + * \param timingMode [IN] MOST master/slave + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostSetTimingMode, XLFP_MOSTSETTIMINGMODE, (DEFPARAMS, unsigned char timingMode)); + +/** \brief Triggers the event XL_MOST_TIMINGMODE. + * This method is used to trigger the event XL_MOST_TIMINGMODE, which will deliver + * information whether the OS8104 is configured in slave or master mode.\n + * ResponseEvent: XL_MOST_TIMINGMODE + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostGetTimingMode, XLFP_MOSTGETTIMINGMODE, (DEFPARAMS)); + +/** \brief Selects the MOST frequency either to 44.1 kHz or 48 kHz. + * This method is used to select either 44.1 kHz or 48 kHz as + * bus clock when the OS8104 of VN2600 acts as timing master \n + * ResponseEvent: XL_MOST_FREQUENCY + * \param frequency [IN] 44,1kHz, 48kHz + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostSetFrequency, XLFP_MOSTSETFREQUENCY, (DEFPARAMS, unsigned short frequency)); + +/** \brief Triggers the event XL_MOST_FREQUENCY. + * This method is used to trigger the event XL_MOST_FREQUENCY, which will deliver + * information whether the OS8104 of VN2600 as timing master + * generates 44.1 kHz or 48 kHz as bus clock.\n + * ResponseEvent: XL_MOST_FREQUENCY + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostGetFrequency, XLFP_MOSTGETFREQUENCY, (DEFPARAMS)); + +/** \brief Allows to write up to 16 byte register in the OS8104. + * This method is used to write numbyte (up to 16) bytes into the registers of the OS8104 + * beginning from adr. \n + * ResponseEvent: XL_MOST_REGISTER_BYTES + * \param adr [IN] address (MAP) of register to which the first byte is written + * \param numBytes [IN] number of successive bytes to be written to the registers + * \param data [IN] bytes to be written + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostWriteRegister, XLFP_MOSTWRITEREGISTER, (DEFPARAMS, unsigned short adr, unsigned char numBytes, unsigned char data[16])); + +/** \brief Triggers the event XL_MOST_REGISTER_BYTES. + * This method is used to read out registers of the OS8104. + * The results will be delivered in the event XL_MOST_REGISTER_BYTES\n + * ResponseEvent: XL_MOST_REGISTER_BYTES + * \param adr [IN] address (MAP) of register from which the first byte is read + * \param numBytes [IN] number of successive bytes to be read + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostReadRegister, XLFP_MOSTREADREGISTER, (DEFPARAMS, unsigned short adr, unsigned char numBytes)); + +/** \brief Allows to write single or multiple bits of one byte register in the OS8104. + * This method is used to write bits into a register of the OS8104 \n + * ResponseEvent: XL_MOST_REGISTER_BYTES + * \param adr [IN] address (MAP) of the register + * \param mask [IN] each bit in mask corresponds to a bit in the register. + * 1 means this bit will be written, 0 means that the bit is not influenced + * \param value [IN] the byte to be written respecting the parameter mask + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostWriteRegisterBit, XLFP_MOSTWRITEREGISTERBIT, (DEFPARAMS, unsigned short adr, unsigned char mask, unsigned char value)); + +/** \brief Sending a MOST Ctrl Message. + * This method is used to send a ctrl message to the MOST ring. + * The members ctrlType, targetAdr, ctrlData[17], TODO: prio of pCtrlMsg will be used, + * all other members don't care for the transmit request. + * A XL_MOST_CTRL_MSG event will be delivered with dir==Tx and txStatus set to + * report success or failure of the transmission.\n + * ResponseEvent: XL_MOST_CTRL_MSG + * \param pCtrlMsg [IN] structure with all relevant data needed for a transmit request + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostCtrlTransmit, XLFP_MOSTCTRLTRANSMIT, (DEFPARAMS, XLmostCtrlMsg* pCtrlMsg)); + +/** \brief Sending a MOST Async Message (Packet). + * This method is used to send an asynchronous message (packet) to the MOST ring. + * The members arbitration, targetAdr, asyncData[1014], length, TODO: prio of pAsyncMsg will be used, + * all other members don't care for the transmit request. + * TODO: arbitration has to be calculated by the sender or will be calculated by the driver/firmware? + * A XL_MOST_ASYNC_MSG event will be delivered with dir==Tx and txStatus set to + * report success or failure of the transmission.\n + * ResponseEvent: XL_MOST_ASYNC_MSG + * \param pAsyncMsg [IN] structure with all relevant data needed for a transmit request + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostAsyncTransmit, XLFP_MOSTASYNCTRANSMIT, (DEFPARAMS, XLmostAsyncMsg* pAsyncMsg)); + +/** \brief Triggers the event XL_MOST_SYNC_ALLOCTABLE. + * This method is used to trigger the event XL_MOST_SYNC_ALLOCTABLE, + * which delivers the complete allocation table of the OS8104.\n + * ResponseEvent: XL_MOST_SYNC_ALLOCTABLE + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostSyncGetAllocTable, XLFP_MOSTSYNCGETALLOCTABLE, (DEFPARAMS)); + +/** \brief Programming the routing engine (RE) for audio channels. + * This method is used to program the routing engine (RE) of the OS8104 in order + * to either stream audio data from the line in of VN2600 to certain MOST channels allocated before, + * or to stream audio data from certain MOST channels to the headphone output of VN2600. \n + * ResponseEvent: XL_MOST_CTRL_SYNC_AUDIO + * \param channel[4] [IN] channel numbers to be routed + * \param device [IN] device, e.g.: audio line in/audio line out + * \param mode [IN] audio mode + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostCtrlSyncAudio, XLFP_MOSTCTRLSYNCAUDIO, (DEFPARAMS, unsigned int channel[4], unsigned int device, unsigned int mode)); + +/** \brief Programming the routing engine (RE) for audio channels. + * This method is used to program the routing engine (RE) of the OS8104 in order + * to either stream audio data from the line in of VN2600 to certain MOST channels allocated before, + * or to stream audio data from certain MOST channels to the headphone output of VN2600. \n + * ResponseEvent: XL_MOST_CTRL_SYNC_AUDIO_EX + * \param channel[16] [IN] channel numbers to be routed (including SPDIF) + * \param device [IN] device, e.g.: audio line in/audio line out, SPDIF in/out + * \param mode [IN] audio mode + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostCtrlSyncAudioEx, XLFP_MOSTCTRLSYNCAUDIOEX, (DEFPARAMS, unsigned int channel[16], unsigned int device, unsigned int mode)); + +/** \brief Setting the volume/attenuation for line in and line out. + * This method is used to set the volume/attenuation of the line in or line out of VN2600.\n + * ResponseEvent: XL_MOST_SYNC_VOLUME_STATUS + * \param device [IN] device, e.g.: audio line in/audio line out + * \param volume [IN] 0..255: 0..100% of volume + * \return XLstatus general status information +*/ +DECL_STDXL_FUNC( xlMostSyncVolume, XLFP_MOSTSYNCVOLUME, (DEFPARAMS, unsigned int device, unsigned char volume)); + +/** \brief Setting mute for line in and line out. + * This method is used to switch mute on or off for the line in or line out of VN2600.\n + * ResponseEvent: XL_MOST_SYNC_VOLUME_STATUS + * \param device [IN] device, e.g.: audio line in/audio line out + * \param mute [IN] mute on/mute off + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostSyncMute, XLFP_MOSTSYNCMUTE, (DEFPARAMS, unsigned int device, unsigned char mute)); + +/** \brief Triggers the event XL_MOST_SYNC_VOLUME_STATUS. + * This method is used to trigger the event XL_MOST_SYNC_VOLUME_STATUS, + * which delivers the information about volume status of line in and line out.\n + * ResponseEvent: XL_MOST_SYNC_VOLUME_STATUS + * \param device [IN] device, e.g.: audio line in/audio line out + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostSyncGetVolumeStatus,XLFP_MOSTSYNCGETVOLUMESTATUS,(DEFPARAMS, unsigned int device)); + +/** \brief Triggers the event XL_MOST_SYNC_MUTE_STATUS. + * This method is used to trigger the event XL_MOST_SYNC_MUTE_STATUS, + * which delivers the information about mute status of line in and line out.\n + * ResponseEvent: XL_MOST_SYNC_MUTE_STATUS + * \param device [IN] device, e.g.: audio line in/audio line out + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostSyncGetMuteStatus, XLFP_MOSTSYNCGETMUTESTATUS,(DEFPARAMS, unsigned int device)); + +/** \brief Triggers the event XL_MOST_SYNC_MUTE_STATUS. + * This method delivers the recent light status at the Rx Pin of the OS8104.\n + * ResponseEvent: XL_MOST_SYNC_MUTE_STATUS + * \param device [IN] device, e.g.: audio line in/audio line out + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostGetRxLight, XLFP_MOSTGETRXLIGHT, (DEFPARAMS)); + +/** \brief Switching the Tx light of VN2600. + * This method is used to switch the Tx light of VN2600 off, to normal or to constant on\n + * ResponseEvent: XL_MOST_TXLIGHT + * \param txLight [IN] tx light on, off or modulated + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostSetTxLight, XLFP_MOSTSETTXLIGHT, (DEFPARAMS, unsigned char txLight)); + +/** \brief Triggers the event XL_MOST_TXLIGHT. + * This method is used to trigger the event XL_MOST_TXLIGHT, + * which delivers the recent light status at the Tx Pin of the OS8104.\n + * ResponseEvent: XL_MOST_TXLIGHT + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostGetTxLight, XLFP_MOSTGETTXLIGHT, (DEFPARAMS)); + +/** \brief Switching the Tx light power of the FOT. + * This method is used to switch the Tx light power of the FOT to normal or -3 dB\n + * ResponseEvent: XL_MOST_TXLIGHT + * \param attenuation [IN] tx power + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostSetLightPower, XLFP_MOSTSETLIGHTPOWER, (DEFPARAMS, unsigned char attenuation)); + +// TODO: GetLightPower?? + +/** \brief Triggers the event XL_MOST_LOCKSTATUS. + * This method is used to trigger the event XL_MOST_LOCKSTATUS, + * which delivers the recent lock status at the Rx Pin of the OS8104.\n + * ResponseEvent: XL_MOST_LOCKSTATUS + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostGetLockStatus, XLFP_MOSTGETLOCKSTATUS, (DEFPARAMS)); + +/** \brief Starts and stops the light error generator. + * This method is used to start (repeat>0) or stop (repeat==0) the light error generator + * which switches the Tx light on and off or configured periods.\n + * ResponseEvent: XL_MOST_GENLIGHTERROR + * \param lightOffTime [IN] duration of light off in ms + * \param lightOnTime [IN] duration of modulated light on in ms + * \param repeat [IN] repetition of light on light off sequence, or repeat==0: stop the generation + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostGenerateLightError, XLFP_MOSTGENERATELIGHTERROR,(DEFPARAMS, unsigned long lightOffTime, unsigned long lightOnTime, unsigned short repeat)); + +/** \brief Starts and stops the lock error generator. + * This method is used to start (repeat>0) or stop (repeat==0) the lock error generator + * which switches the Tx light between modulated on and permanent on for configured periods.\n + * ResponseEvent: XL_MOST_GENLOCKERROR + * \param unmodTime [IN] duration of light off in ms + * \param modTime [IN] duration of modulated light on in ms + * \param repeat [IN] repetition of sequence, or repeat==0: stop the generation + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostGenerateLockError, XLFP_MOSTGENERATELOCKERROR, (DEFPARAMS, unsigned long unmodTime, unsigned long modTime, unsigned short repeat)); + +/** \brief prevent firmware from emptying the Rx buffer of the OS8104 + * This method is used to Switch the stress mode on or off, where the + * Rx buffer of the OS8104 is not emptied by the firmware + * which switches the Tx light between modulated on and permanent on for configured periods.\n + * ResponseEvent: XL_MOST_CTRL_RXBUFFER + * \param bufferMode [IN] specifies the buffer mode + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostCtrlRxBuffer, XLFP_MOSTCTRLRXBUFFER, (DEFPARAMS, unsigned short bufferMode)); + +/** \brief Twinkle the power led from the VN2600. + * ResponseEvent: none + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMostTwinklePowerLed, XLFP_MOSTTWINKLEPOWERLED, (DEFPARAMS)); + +/** \brief Prepares and configures busload generation with MOST control frames. + * Attention: Has to be called before "xlMostCtrlGenerateBusload". + * ResponseEvent: none + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param pCtrlBusloadConfiguration [IN] structure containing the ctrl msg used for busload generation and configuration, + * it's storage has has to be supplied by the caller + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMostCtrlConfigureBusload, XLFP_MOSTCTRLCONFIGUREBUSLOAD, (DEFPARAMS, + XLmostCtrlBusloadConfiguration* pCtrlBusloadConfiguration)); + +/** \brief Starts busload generation with MOST control frames. + * Attention: "xlMostCtrlConfigureBusload" has to be called before. + * ResponseEvent: XL_MOST_CTRL_BUSLOAD + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param numberCtrlFrames [IN] number of busload ctrl messages (0xFFFFFFFF indicates infinite number of messages) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMostCtrlGenerateBusload, XLFP_MOSTCTRLGENERATEBUSLOAD, (DEFPARAMS, unsigned long numberCtrlFrames)); + +/** \brief Prepares and configures busload generation of MOST asynchronous frames. + * Attention: Has to be called before "xlMostAsyncGenerateBusload". + * ResponseEvent: none + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param pAsyncBusloadConfiguration [IN] structure containing the async msg used for busload generation and configuration, + * it's storage has has to be supplied by the caller + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMostAsyncConfigureBusload, XLFP_MOSTASYNCCONFIGUREBUSLOAD, (DEFPARAMS, + XLmostAsyncBusloadConfiguration* pAsyncBusloadConfiguration)); + +/** \brief Starts busload generation with MOST asynchronous frames. + * Attention: "xlMostAsyncConfigureBusload" has to be called before. + * ResponseEvent: XL_MOST_ASYNC_BUSLOAD + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param numberAsyncFrames [IN] number of busload async messages (0xFFFFFFFF indicates infinite number of messages) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMostAsyncGenerateBusload, XLFP_MOSTASYNCGENERATEBUSLOAD, (DEFPARAMS, unsigned long numberAsyncFrames)); + + +/** \brief Opens a stream (Rx / Tx) for routing synchronous data to or from the MOST bus (synchronous channel). + * Attention: Has to be called before "xlMostStreamBufferAllocate". + * ResponseEvent: none + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param pStreamOpen [IN] structure containing the stream parameters - + * it's storage has has to be supplied by the caller + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMostStreamOpen, XLFP_MOSTSTREAMOPEN, (DEFPARAMS, XLmostStreamOpen* pStreamOpen)); + + +/** \brief Closes an opened a stream (Rx / Tx) used for routing synchronous data to or from the MOST bus (synchronous channel). + * ResponseEvent: none + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param streamHandle [IN] stream handle returned by xlMostStreamOpen + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMostStreamClose, XLFP_MOSTSTREAMCLOSE, (DEFPARAMS, unsigned int streamHandle)); + + +/** \brief Starts the streaming (Rx / Tx) of synchronous data to or from the MOST bus (synchronous channel). + * Attention: Has to be called after "xlMostStreamOpen and xlMostStreamBufferAllocate" were called. + * ResponseEvent: none + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param streamHandle [IN] stream handle returned by xlMostStreamOpen + * \param syncChannels [IN] synchronous channels (bytes) used for streaming. + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMostStreamStart, XLFP_MOSTSTREAMSTART, (DEFPARAMS, unsigned int streamHandle, unsigned char syncChannels[60])); + + +/** \brief Stops the streaming (Rx / Tx) of synchronous data to or from the MOST bus (synchronous channel). + * Attention: Has to be called before "xlMostStreamBufferDeallocate". + * ResponseEvent: none + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param streamHandle [IN] stream handle returned by xlMostStreamOpen + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMostStreamStop, XLFP_MOSTSTREAMSTOP, (DEFPARAMS, unsigned int streamHandle)); + + +/** \brief Allocates a buffer for streaming (RX / Tx) of synchronous data to or from the MOST bus (synchronous channel). + * Attention: Has to be called before "xlMostStreamStart". + * ResponseEvent: none + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param streamHandle [IN] stream handle returned by xlMostStreamOpen + * \param ppBuffer [OUT] pointer to the buffer used for streaming + * memory allocation is done by the driver + * has to be released by calling xlMostStreamBufferDeallocate + * \param pBufferSize [OUT] buffer size. + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMostStreamBufferAllocate, XLFP_MOSTSTREAMBUFFERALLOCATE, (DEFPARAMS, unsigned int streamHandle, unsigned char** ppBuffer, unsigned int* pBufferSize)); + + +/** \brief Deallocates any buffer allocated with "xlMostStreamBufferAllocate". + * Attention: Has to be called before "xlMostStreamClose". Afterwards no buffer must be accessed! + * ResponseEvent: none + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param streamHandle [IN] stream handle returned by xlMostStreamOpen + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMostStreamBufferDeallocateAll, XLFP_MOSTSTREAMBUFFERDEALLOCATEALL, (DEFPARAMS, unsigned int streamHandle)); + + +/** \brief Notifies the driver the next buffer to be used for streaming synchronous data to or from the MOST bus (synchronous channel). + * ResponseEvent: none + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param streamHandle [IN] stream handle returned by xlMostStreamOpen + * \param pBuffer [IN] pointer to the next buffer used for streaming + * \param filledBytes [IN] size of the next buffer to be used for streaming + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMostStreamBufferSetNext, XLFP_MOSTSTREAMBUFFERSETNEXT, (DEFPARAMS, unsigned int streamHandle, unsigned char* pBuffer, unsigned int filledBytes)); + + +/** \brief Retrieves the stream information. + * This method is used to gather the recent stream state information.\n + * ResponseEvent: None + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param pStreamInfo [OUT] Pointer to the stream information. + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMostStreamGetInfo, XLFP_MOSTSTREAMGETINFO, (DEFPARAMS, XLmostStreamInfo* pStreamInfo)); + + +/** \brief Clears the content of the buffer(s) which are not already sent. + * This method is used to clear the content of any TX streaming buffer which has not been sent yet.\n + * ResponseEvent: None + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param streamHandle [IN] stream handle returned by xlMostStreamOpen. + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMostStreamBufferClearAll, XLFP_MOSTSTREAMBUFFERCLEARALL, (DEFPARAMS, unsigned int streamHandle)); + + +//////////////////////////////////////////////////////////////////////////////// +// FlexRay Function Declarations +//////////////////////////////////////////////////////////////////////////////// + +/** \brief Setup the FlexRay node + * ResponseEvent: + * \param portHandle [IN] handle specifying the port to be configured + * \param accessMask [IN] mask specifying the port's channel + * \param pxlClusterConfig [IN] structure to the cluster config structure + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC (xlFrSetConfiguration, XLFP_FRSETCONFIGURATION, (DEFFRPARAM, XLfrClusterConfig *pxlClusterConfig)); + + +/** \brief Get configuration of a FlexRay channel + * ResponseEvent: + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the information + * \param XLfrChannelConfig [OUT] pointer to the FlexRay channel configuration structure + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC (xlFrGetChannelConfiguration, XLFP_FRGETCHANNELCONFIGURATION, (DEFFRPARAM, XLfrChannelConfig* pxlFrChannelConfig)); + +/** \brief Setup the FlexRay mode + * ResponseEvent: + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param pxlFrMode [IN] structure to the FlexRay mode structure (e.g.: normal-, monitor-, clusterScan mode). + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC (xlFrSetMode, XLFP_FRSETMODE, (DEFFRPARAM, XLfrMode *pxlFrMode)); + +/** \brief Initialize the cold start and define the sync event + * ResponseEvent: + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param pEventBuffer [IN] pointer to the startup and sync frame + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC (xlFrInitStartupAndSync, XLFP_FRINITSTARTUPANDSYNC, (DEFFRPARAM, XLfrEvent *pEventBuffer)); + +/** \brief setup the symbol window. + * ResponseEvent: + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param frChannel [IN] FlexRay channel, like A,B, both... + * \param symbolWindowMask [IN] symbol window mask like MTS. + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC (xlFrSetupSymbolWindow, XLFP_FRSETUPSYMBOLWINDOW, (DEFFRPARAM, unsigned int frChannel, + unsigned int symbolWindowMask)); + +/** \brief Reads the FlexRay events + * ResponseEvent: + * \param portHandle [IN] handle to port from which the information is requested + * \param pEventBuffer [OUT] pointer to the FlexRay RX event + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC (xlFrReceive, XLFP_FRRECEIVE, (XLportHandle portHandle, XLfrEvent *pEventBuffer)); + +/** \brief Transmit a FlexRay event + * ResponseEvent: + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param pEventBuffer [IN] pointer to the FlexRay TX event + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC (xlFrTransmit, XLFP_FRTRANSMIT, (DEFFRPARAM, XLfrEvent *pEventBuffer)); + +/** \brief + * ResponseEvent: + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param frChannel [IN] FlexRay channel. e.g. CHANNEL_A... + * \param mode [IN] transceiver mode. e.g. sleep + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC (xlFrSetTransceiverMode, XLFP_FRSETTRANSCEIVERMODE, (DEFFRPARAM, unsigned int frChannel, unsigned int mode)); + +/** \brief + * ResponseEvent: + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param symbolWindow [IN] defines the symbol window (e.g. MTS). + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC (xlFrSendSymbolWindow, XLFP_FRSENDSYMBOLWINDOW, (DEFFRPARAM, unsigned int symbolWindow)); + +/** \brief + * ResponseEvent: + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param mode [IN] specifies the spy mode: XL_FR_SPY_MODE_*** + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC (xlFrActivateSpy, XLFP_FRACTIVATESPY, (DEFFRPARAM, unsigned int mode)); + + +/** \brief Function to set the filter type for a range of slots. + * ResponseEvent: + * \param pAcceptanceFilter [IN] type and ranges of slots + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC (xlFrSetAcceptanceFilter, XLFP_FRSETACCEPTANCEFILTER, (DEFFRPARAM, + XLfrAcceptanceFilter *pAcceptanceFilter)); + +/** \brief The application gets the information, which remote channels are available in the system. The user + * must provide the memory (pointer to XLdriverConfig structure). + * \param pDriverConfig [OUT] The remote driver configuration structure. + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlGetRemoteDriverConfig, XLGETREMOTEDRIVERCONFIG, (XLdriverConfig *pDriverConfig)); + + +/** \brief The application gets the available RDNI network devices. The buffer is allocated by DLL and can be + * freed by a call of xlReleaseRemoteDeviceInfo. + * \param deviceList [OUT] Pointer receiving the address of the buffer containing the device configuration information. + * \param nbrOfRemoteDevices [OUT] The number of available network devices. + * \param netSearch [IN] One of the defines: XL_REMOTE_NET_SEARCH or XL_REMOTE_NO_NET_SEARCH + * + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlGetRemoteDeviceInfo, XLGETREMOTEDEVICEINFO, (XLremoteDeviceInfo **deviceList, unsigned int *nbrOfRemoteDevices, unsigned int netSearch)); + +/** \brief Frees the buffer allocated by a call to xlGetRemoteDeviceInfo. + * \param deviceList [IN] Pointer containing the address of the buffer. + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlReleaseRemoteDeviceInfo, XLRELEASEREMOTEDEVICEINFO, (XLremoteDeviceInfo **deviceList)); + +/** \brief The application establishes a connection to a RDNI network device. + * \param remoteHandle [IN] DLL internal handle of the device retrieved by a call to xlGetRemoteDeviceInfo. + * \param deviceMask [IN] not used + * \param flags [IN] specify if the connection shall be permanent or temporary (until next reboot) + * One of the defines: XL_REMOTE_ADD_PERMANENT, XL_REMOTE_ADD_TEMPORARY + * + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlAddRemoteDevice, XLADDREMOTEDEVICE, (XLremoteHandle remoteHandle, XLdeviceAccess deviceMask, unsigned int flags)); + +/** \brief The application closes a connection to a RDNI network device. + * \param remoteHandle [IN] DLL internal handle of the device retrieved by a call to xlGetRemoteDeviceInfo. + * \param deviceMask [IN] not used + * \param flags [IN] Server entry removal flag. + * + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlRemoveRemoteDevice, XLREMOVEREMOTEDEVICE, (XLremoteHandle remoteHandle, XLdeviceAccess deviceMask, unsigned int flags)); + +/** \brief Updates a list of remote device information objects + * \param deviceList [IN] An array of device information objects to be updated + * \param nbrOfRemoteDevices [IN] Number of elements in the list. + + * + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlUpdateRemoteDeviceInfo, XLUPDATEREMOTEDEVICEINFO, (XLremoteDeviceInfo *deviceList, unsigned int nbrOfRemoteDevices)); + +/** \brief Retrieves the hardware type and hardware index of the channels in driver config structure that belong to the remote device. + * \param remoteHandle [IN] Handle of the remote device. + * \param hwType [OUT] Hardware type of the channels. + * \param hwIndex [OUT] Hardware index of the channels. + + * + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlGetRemoteHwInfo, XLGETREMOTEHWINFO, (XLremoteHandle remoteHandle, int *hwType, int *hwIndex, int *isPresent)); + +/** \brief Registers a manual configured network node. + * \param hwType [IN] Hardware type of the device to be registered. + * \param ipAddress [IN] IP address of the device. + * \param flags [IN] Specify one of the defines: + * XL_REMOTE_REGISTER_NONE, XL_REMOTE_REGISTER_CONNECT, XL_REMOTE_REGISTER_TEMP_CONNECT + * + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlRegisterRemoteDevice, XLREGISTERREMOTEDEVICE, (int hwType, XLipAddress *ipAddress, unsigned int flags)); + + +/////////////////////////////////////////////////////////// +// IOpiggy API functions (Public) +/////////////////////////////////////////////////////////// + +/** \brief Setup the DAIO trigger for the analog, digital and the pwm ports. A port group must not + * have more than one trigger source. + * \param pxlDaioTriggerMode [IN] Pointer to the trigger mode structure + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC ( xlIoSetTriggerMode, XLIOSETTRIGGERMODE, (DEFFRPARAM, XLdaioTriggerMode* pxlDaioTriggerMode)); + +/** \brief Sets the values of digital outputs. + * \param pxlDaioDigitalParams [IN] Pointer to the digital parameter structure + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC(xlIoSetDigitalOutput, XLIOSETDIGITALOUTPUT, (DEFFRPARAM, XLdaioDigitalParams *pxlDaioDigitalParams)); + + +/** \brief Setup the DAIO ports. + * \param pxlDaioSetPort [IN] Pointer to the XLdaioSetPort structure. + * \return XLstatus general status information + */ +DECL_STDXL_FUNC ( xlIoConfigurePorts, XLIOCONFIGUREPORTS, (DEFFRPARAM, XLdaioSetPort *pxlDaioSetPort)); + +/** \brief Defines the voltage level where a digital signal is measured as logical high and where it is measured as logical low. + * \param level [IN] 10bit value which defines voltage level [mV] for input threshold of digital ports. + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC( xlIoSetDigInThreshold, XLIOSETDIGINTHRESHOLD, (DEFFRPARAM, unsigned int level)); + +/** \brief Set the voltage of the high level of the digital outputs in push-pull mode. + * \param level [IN] One of the defines XL_DAIO_DO_LEVEL_* + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC( xlIoSetDigOutLevel, XLIOSETDIGOUTLEVEL, (DEFFRPARAM, unsigned int level)); + +/** \brief Set the values for the analog outputs. + * \param pxlDaioAnalogParams [IN] Pointer to the analog parameter structure + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC(xlIoSetAnalogOutput, XLIOSETANALOGOUTPUT, (DEFFRPARAM, XLdaioAnalogParams *pxlDaioAnalogParams)); + +/** \brief Start measurements. + * \param portTypeMask [IN] Port types on which to start the measurements. Use defines XL_DAIO_PORT_TYPE_MASK_*. + * \return XLstatus general status information + */ + +DECL_STDXL_FUNC(xlIoStartSampling, XLIOSTARTSAMPLING, (DEFFRPARAM, unsigned int portTypeMask)); + +//////////////////////////////////////////////////////////////////////////////// +// MOST150 Function Declarations +//////////////////////////////////////////////////////////////////////////////// + +// apiname, apitype, parameters in parenthesis + +/** + * Common principles: + * If not mentioned otherwise, all APIs are asynchronous and will trigger an action in VN2640. + * Results are delivered in events which can be fetched by xlMost150Receive. + * + * Common Parameters: DEFPARAMS + * XLportHandle portHandle: was previously fetched by xlOpenPort API. + * XLaccess accessMask: determines on which channels an API should work. + * XLuserHandle userHandle: used to match the response of the driver to the requests of the application + * if an event is received spontaneously, e.g. MPR changed then the userHandle == 0 + * Common Return Value: + * XLstatus: common return value of most APIs which indicates whether a command was + * successfully launched or e.g. whether a command queue overflow happened + */ + +/** \brief fetching events from driver queue. + * This method is used to fetch events, either bus events or acknowledgments + * for commands from the driver queue. Each call delivers only one event (if an event is available). \n + * It is a synchronous mode and either delivers event data immediately, or + * indicates an error condition with its return value. + * \param XLportHandle portHandle: [IN] was previously fetched by xlOpenPort API + * \param XLaccess accessMask: [IN] determines on which channels an API should work + * \param pEventBuffer [IN] This parameter must point to a buffer to which the driver can copy + * the next event of the receive queue + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150Receive, XLFP_MOST150RECEIVE, (XLportHandle portHandle, XLmost150event* pEventBuffer)); + +/** \brief Twinkle the power led from the VN2640. + * ResponseEvent: none + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150TwinklePowerLed, XLFP_MOST150TWINKLEPOWERLED, (DEFPARAMS)); + +/** \brief Activates or deactivates the different event sources of VN2640. + * This method is used to select which bus events should be delivered by VN2640. + * ResponseEvent: XL_MOST150_EVENT_SOURCE + * \param sourceMask [IN] each bit stands for an event source and can separately be set. + * Use the definitions of the source mask (see XL_MOST150_SOURCE_...). + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150SwitchEventSources, XLFP_MOST150SWITCHEVENTSOURCES,(DEFPARAMS, unsigned int sourceMask)); + + +/** \brief Sets the device mode. + * This method is used to switch the device mode to either Master, Slave or bypass \n + * ResponseEvent: XL_MOST150_DEVICE_MODE + * \param deviceMode [IN] device mode (see XL_MOST150_DEVICEMODE_...) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150SetDeviceMode, XLFP_MOST150SETDEVICEMODE, (DEFPARAMS, unsigned int deviceMode)); + +/** \brief Requests the current device mode. + * This method is asynchronous and requests the event used to switch device mode. + * ResponseEvent: XL_MOST150_DEVICE_MODE + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150GetDeviceMode, XLFP_MOST150GETDEVICEMODE, (DEFPARAMS)); + +/** \brief Switches the SPDIF mode to slave or master mode. + * This method is used to switch into the SPDIF master or SPDIF slave mode \n + * ResponseEvent: XL_MOST150_SPDIFMODE + * \param spdifMode [IN] MOST master/slave, ... + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150SetSPDIFMode, XLFP_MOST150SETSPDIFMODE, (DEFPARAMS, unsigned int spdifMode)); + +/** \brief Requests the current SPDIF mode. + * This method is used to trigger the event XL_MOST150_SPDIFMODE, which will deliver + * information whether the SPDIF is configured in slave or master mode.\n + * ResponseEvent: XL_MOST150_SPDIFMODE + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150GetSPDIFMode, XLFP_MOST150GETSPDIFMODE, (DEFPARAMS)); + + +/** \brief Set one or more parameters of the special node info at once. + * ResponseEvent: XL_MOST150_SPECIAL_NODE_INFO + * \param pSpecialNodeInfo [IN] contains the parameter to set + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150SetSpecialNodeInfo, XLFP_MOST150SETSPECIALNODEINFO, (DEFPARAMS, XLmost150SetSpecialNodeInfo *pSpecialNodeInfo)); + +/** \brief Requests one or more parameters of the special node info at once. + * ResponseEvent: XL_MOST150_SPECIAL_NODE_INFO + * \param requestMask [IN] contains a mask of parameter to get (see XL_MOST150_SPECIAL_NODE_MASK_CHANGED) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150GetSpecialNodeInfo, XLFP_MOST150GETSPECIALNODEINFO, (DEFPARAMS, unsigned int requestMask)); + +/** \brief Set the frequency of the MOST150 ring. + * ResponseEvent: XL_MOST150_FREQUENCY + * \param frequency [IN] contains the frequency to be set. Only as timing master! (see XL_MOST150_FREQUENCY_...) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150SetFrequency, XLFP_MOST150SETFREQUENCY, (DEFPARAMS, unsigned int frequency)); + +/** \brief Requests the frequency of the MOST150 ring. + * ResponseEvent: XL_MOST150_FREQUENCY + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150GetFrequency, XLFP_MOST150GETFREQUENCY, (DEFPARAMS)); + +/** \brief Transmit a control message on the MOST150 ring. + * ResponseEvent: XL_MOST150_CTRL_TX + * \param pCtrlTxMsg [IN] pointer to structure that contains the control message to be sent + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150CtrlTransmit, XLFP_MOST150CTRLTRANSMIT, (DEFPARAMS, XLmost150CtrlTxMsg *pCtrlTxMsg)); + +/** \brief Transmit a data packet (MDP) on the MOST150 ring. + * ResponseEvent: XL_MOST150_ASYNC_TX + * \param pAsyncTxMsg [IN] pointer to structure that contains the MOST Data Packet (MDP) to be sent + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150AsyncTransmit, XLFP_MOST150ASYNCTRANSMIT, (DEFPARAMS, XLmost150AsyncTxMsg *pAsyncTxMsg)); + +/** \brief Transmit a Ethernet packet (MEP) on the MOST150 ring. + * ResponseEvent: XL_MOST150_ETHERNET_TX + * \param pEthernetTxMsg [IN] pointer to structure that contains the MOST Ethernet Packet (MEP) to be sent + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150EthernetTransmit, XLFP_MOST150ETHTRANSMIT, (DEFPARAMS, XLmost150EthernetTxMsg *pEthernetTxMsg)); + +/** \brief Requests the state of the system lock flag. + * ResponseEvent: XL_MOST150_SYSTEMLOCK_FLAG + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150GetSystemLockFlag, XLFP_MOST150GETSYSTEMLOCK, (DEFPARAMS)); + +/** \brief Requests the state of the shutdown flag. + * ResponseEvent: XL_MOST150_SHUTDOWN_FLAG + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150GetShutdownFlag, XLFP_MOST150GETSHUTDOWN, (DEFPARAMS)); + +/** \brief Shutdown the MOST150 ring. + * ResponseEvent: + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150Shutdown, XLFP_MOST150SHUTDOWN, (DEFPARAMS)); + +/** \brief Startup the MOST150 ring. + * ResponseEvent: + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150Startup, XLFP_MOST150STARTUP, (DEFPARAMS)); + +/** \brief Requests the current allocation information. + * \n + * ResponseEvent: XL_MOST150_SYNC_ALLOC_INFO + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150SyncGetAllocTable, XLFP_MOST150GETALLOCTABLE, (DEFPARAMS)); + +/** \brief Set the parameters for audio functions. + * ResponseEvent: XL_MOST150_CTRL_SYNC_AUDIO + * \param pSyncAudioParameter [IN] pointer to structure that contains the data + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150CtrlSyncAudio, XLFP_MOST150CTRLSYNCAUDIO, (DEFPARAMS, XLmost150SyncAudioParameter *pSyncAudioParameter)); + +/** \brief Set the volume of Line In/Out audio device. + * ResponseEvent: XL_MOST150_SYNC_VOLUME_STATUS + * \param device [IN] specifies the device (see XL_MOST150_DEVICE_LINE_IN, ...) + * \param volume [IN] specifies the volume + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150SyncSetVolume, XLFP_MOST150SYNCSETVOLUME, (DEFPARAMS, unsigned int device, unsigned int volume)); + +/** \brief Requests the volume of Line In/Out audio device. + * \n + * ResponseEvent: XL_MOST150_SYNC_VOLUME_STATUS + * \param device [IN] specifies the device (see XL_MOST150_DEVICE_LINE_IN, ...) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150SyncGetVolume, XLFP_MOST150SYNCGETVOLUME, (DEFPARAMS, unsigned int device)); + +/** \brief Set mute state of Line In/Out or S/PDIF In/Out audio device. + * ResponseEvent: XL_MOST150_SYNC_MUTE_STATUS + * \param device [IN] specifies the device (see XL_MOST150_DEVICE_...) + * \param mute [IN] specifies the mute status (on / off) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150SyncSetMute, XLFP_MOST150SYNCSETMUTE, (DEFPARAMS, unsigned int device, unsigned int mute)); + +/** \brief Requests mute state of Line In/Out or S/PDIF In/Out audio device. + * ResponseEvent: XL_MOST150_SYNC_MUTE_STATUS + * \param device [IN] specifies the device (see XL_MOST150_DEVICE_LINE_IN, ...) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150SyncGetMute, XLFP_MOST150SYNCGETMUTE, (DEFPARAMS, unsigned int device)); + +/** \brief Requests the FOR and lock status either from the spy or from INIC. + * ResponseEvent: XL_MOST150_RXLIGHT_LOCKSTATUS + * \param fromSpy [IN] defines the source, to get the light & lock status from + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150GetRxLightLockStatus, XLFP_MOST150GETLIGHTLOCKSTATUS, (DEFPARAMS, unsigned int fromSpy)); + +/** \brief Set the FOT output mode. + * \n + * ResponseEvent: XL_MOST150_TX_LIGHT + * \param txLight [IN] mode of the output (modulated (on) or off) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150SetTxLight, XLFP_MOST150SETTXLIGHT, (DEFPARAMS, unsigned int txLight)); + +/** \brief Requests the FOT output mode. + * ResponseEvent: XL_MOST150_TX_LIGHT + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150GetTxLight, XLFP_MOST150GETTXLIGHT, (DEFPARAMS)); + +/** \brief Set the FOT output power. + * \n + * ResponseEvent: XL_MOST150_LIGHT_POWER + * \param attenuation [IN] tx light power (no attenuation / -3dB attenuation) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150SetTxLightPower, XLFP_MOST150SETTXLIGHTPOWER, (DEFPARAMS, unsigned int attenuation)); + +/** \brief Controls the light error generation. + * \n + * ResponseEvent: XL_MOST150_GEN_LIGHT_ERROR + * \param lightOffTime [IN] duration of light off in [ms] + * \param lightOnTime [IN] duration of light on in [ms] + * \param repeat [IN] number of error intervals + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150GenerateLightError, XLFP_MOST150GENLIGHTERROR, (DEFPARAMS, unsigned int lightOffTime, unsigned int lightOnTime, unsigned int repeat)); + +/** \brief Control the lock error generation. + * \n + * ResponseEvent: XL_MOST150_GEN_LOCK_ERROR + * \param unlockTime [IN] duration of unlock in [ms] + * \param lockTime [IN] duration of lock in [ms] + * \param repeat [IN] number of error intervals + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150GenerateLockError, XLFP_MOST150GENLOCKERROR, (DEFPARAMS, unsigned int unlockTime, unsigned int lockTime, unsigned int repeat)); + +/** \brief Configures the receive buffer for control messages and packets of the INIC. + * \n + * ResponseEvent: XL_MOST150_CONFIGURE_RX_BUFFER + * \param bufferType [IN] Bit mask for receive buffer type (control messages and/or packets (MDP/MEP)). + * \param bufferMode [IN] Block or un-block receive buffer + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150ConfigureRxBuffer, XLFP_MOST150CONFIGURERXBUFFER, (DEFPARAMS, unsigned int bufferType, unsigned int bufferMode)); + +/** \brief Defines the control message which should be transmitted with xlMost150CtrlGenerateBusload(). + * ResponseEvent: + * \param pCtrlBusLoad [IN] pointer to structure that contains the control message + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150CtrlConfigureBusload, XLFP_MOST150CTRLCONFIGLOAD, (DEFPARAMS, XLmost150CtrlBusloadConfig *pCtrlBusLoad)); + +/** \brief Starts or stops the control message busload by sending the control message defined with xlMost150CtrlConfigureBusload(). + * ResponseEvent: XL_MOST150_CTRL_BUSLOAD + * \param numberCtrlFrames [IN] number of control messages to be sent + * 0: stop sending + * < 0xFFFFFFFF: number of messages to be sent + * 0xFFFFFFFF: send continuously + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150CtrlGenerateBusload, XLFP_MOST150CTRLGENLOAD, (DEFPARAMS, unsigned long numberCtrlFrames)); + +/** \brief Define the data or Ethernet packet that should be transmitted with xlMost150AsyncGenerateBusload(). + * ResponseEvent: + * \param pAsyncBusLoad [IN] pointer to structure that contains either the data or the Ethernet packet + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150AsyncConfigureBusload, XLFP_MOST150ASYNCCONFIGLOAD, (DEFPARAMS, XLmost150AsyncBusloadConfig *pAsyncBusLoad)); + +/** \brief Starts or stops the packet busload by sending either the data or Ethernet packet defined with xlMost150AsyncConfigureBusload(). + * ResponseEvent: XL_MOST150_ASYNC_BUSLOAD + * \param numberAsyncPackets [IN] number of data or Ethernet packets to be sent + * 0: stop sending + * < 0xFFFFFFFF: number of packets to be sent + * 0xFFFFFFFF: send continuously + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150AsyncGenerateBusload, XLFP_MOST150ASYNCGENLOAD, (DEFPARAMS, unsigned long numberAsyncPackets)); + + +/** \brief Set the ECL state. + * ResponseEvent: XL_MOST150_ECL_LINE_CHANGED + * \param eclLineState [IN] ECL state to be set: XL_MOST150_ECL_LINE_LOW, XL_MOST150_ECL_LINE_HIGH + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150SetECLLine, XLFP_MOST150SETECLLINE, (DEFPARAMS, unsigned int eclLineState)); + + +/** \brief Set the ECL termination resistor state. + * ResponseEvent: XL_MOST150_ECL_TERMINATION_CHANGED + * \param eclLineTermination [IN] ECL line termination resistor state to be set: + * XL_MOST150_ECL_LINE_PULL_UP_NOT_ACTIVE, XL_MOST150_ECL_LINE_PULL_UP_ACTIVE + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150SetECLTermination, XLFP_MOST150SETECLTERMINATION, (DEFPARAMS, unsigned int eclLineTermination)); + +/** \brief Requests the current ECL state and settings. + * This method is asynchronous and requests the event used to get the ECL line state, termination and glitch filter setting. + * ResponseEvent: XL_MOST150_ECL_LINE_CHANGED, XL_MOST150_ECL_TERMINATION_CHANGED, XL_MOST150_ECL_GLITCH_FILTER + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlMost150GetECLInfo, XLFP_MOST150GETECLINFO, (DEFPARAMS)); + +/** \brief Opens a stream (Rx / Tx) for routing synchronous data to or from the MOST bus (synchronous channel). + * ResponseEvent: XL_MOST150_STREAM_STATE + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param pStreamOpen [IN] structure containing the stream parameters - + * it's storage has has to be supplied by the caller + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150StreamOpen, XLFP_MOST150STREAMOPEN, (DEFPARAMS, XLmost150StreamOpen* pStreamOpen)); + + +/** \brief Closes an opened a stream (Rx / Tx) used for routing synchronous data to or from the MOST bus (synchronous channel). + * ResponseEvent: XL_MOST150_STREAM_STATE + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param streamHandle [IN] stream handle returned by xlMostStreamOpen + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150StreamClose, XLFP_MOST150STREAMCLOSE, (DEFPARAMS, unsigned int streamHandle)); + + +/** \brief Starts the streaming (Rx / Tx) of synchronous data to or from the MOST bus (synchronous channel). + * Attention: Has to be called after XL_MOST150_STREAM_STATE "Opened" was received. + * ResponseEvent: XL_MOST150_STREAM_STATE + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param streamHandle [IN] stream handle returned by xlMostStreamOpen + * \param numConnLabels [IN] Number of connection labels to stream (only used for Rx streaming, max. 8 labels can be streamed!) + * \param pConnLabels [IN] connection label(s) (only used for Rx streaming) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150StreamStart, XLFP_MOST150STREAMSTART, (DEFPARAMS, unsigned int streamHandle, + unsigned int numConnLabels, + unsigned int* pConnLabels)); + + +/** \brief Stops the streaming (Rx / Tx) of synchronous data to or from the MOST bus (synchronous channel). + * Attention: Has to be called after XL_MOST150_STREAM_STATE "Started" was received. + * ResponseEvent: XL_MOST150_STREAM_STATE + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param streamHandle [IN] stream handle returned by xlMostStreamOpen + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150StreamStop, XLFP_MOST150STREAMSTOP, (DEFPARAMS, unsigned int streamHandle)); + +/** \brief Provides further streaming data to be sent to the MOST bus (synchronous channel). + * ResponseEvent: XL_MOST150_STREAM_TX_BUFFER as soon as further data is required. + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param streamHandle [IN] stream handle returned by xlMostStreamOpen + * \param pBuffer [IN] pointer to the buffer used for streaming + * \param pNumberOfBytes [IN]/[OUT] number of bytes contained in the buffer to be used for streaming. + * In case of not all bytes could be stored, this parameters contains the adjusted + * number of bytes stored and the function returns an error (XL_ERR_QUEUE_IS_FULL). + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150StreamTransmitData, XLFP_MOST150STREAMTRANSMITDATA, (DEFPARAMS, unsigned int streamHandle, unsigned char* pBuffer, unsigned int* pNumberOfBytes)); + +/** \brief Clears the content of the driver's Tx FIFO. + * This method is used to clear the content of the driver's TX streaming FIFO which has not been sent yet.\n + * ResponseEvent: None + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param streamHandle [IN] stream handle returned by xlMostStreamOpen. + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150StreamClearTxFifo, XLFP_MOST150STREAMCLEARTXFIFO, (DEFPARAMS, unsigned int streamHandle)); + +/** \brief Retrieves the stream information. + * This method is used to gather the recent stream state information.\n + * ResponseEvent: None + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel from where to get the device's state + * \param userHandle [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param pStreamInfo [OUT] Pointer to the stream information. + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150StreamGetInfo, XLFP_MOST150STREAMGETINFO, (DEFPARAMS, XLmost150StreamInfo* pStreamInfo)); + +/** \brief Initializes the Rx Streaming FIFO. + * This method is used to initialize the FIFO for storing the received streaming data.\n + * ResponseEvent: None + * \param portHandle [IN] handle to port from which the information is requested + * \param accessMask [IN] mask specifying the port's channel + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150StreamInitRxFifo, XLFP_MOST150STREAMINITRXFIFO, (XLportHandle portHandle, XLaccess accessMask)); + +/** \brief Fetches streaming data from the driver queue. + * This method is used to fetch received streaming data. The application is triggered by + * a XL_MOST150_STREAM_RX_BUFFER event to call this method. + * It is a synchronous mode and either delivers streaming data immediately, or + * indicates an error condition with its return value. + * \param XLportHandle portHandle: [IN] was previously fetched by xlOpenPort API + * \param XLaccess accessMask: [IN] determines on which channel an API should work + * \param pBuffer [IN] Pointer to a buffer to which the driver can copy + * the streaming data of the receive queue + * \param pBufferSize [IN] Determines the maximum buffer size + * [OUT] The number of actually copied data bytes + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150StreamReceiveData, XLFP_MOST150STREAMRECEIVEDATA, (XLportHandle portHandle, XLaccess accessMask, + unsigned char* pBuffer, unsigned int* pBufferSize)); + +/** \brief Controls the bypass stress generation. + * \param XLportHandle portHandle: [IN] was previously fetched by xlOpenPort API + * \param XLaccess accessMask: [IN] determines on which channel an API should work + * \param XLuserHandle userHandle: [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param bypassCloseTime [IN] duration of bypass close time in [ms] (minimum value: 10 ms) + * \param bypassOpenTime [IN] duration of bypass open time in [ms] (minimum value: 10 ms) + * \param repeat [IN] number of error intervals + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150GenerateBypassStress, XLFP_MOST150GENERATEBYPASSSTRESS, (DEFPARAMS, unsigned int bypassCloseTime, + unsigned int bypassOpenTime, unsigned int repeat)); + +/** \brief Configures a sequence for the ECL. + * \param XLportHandle portHandle: [IN] was previously fetched by xlOpenPort API + * \param XLaccess accessMask: [IN] determines on which channel an API should work + * \param XLuserHandle userHandle: [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param numStates [IN] Number of states during the sequence (max. XL_MOST150_ECL_SEQ_NUM_STATES_MAX) + * \param pEclStates [IN] Pointer to a buffer containing the ECL sequence states (1: High, 0: Low) + * \param pEclStatesDuration [IN] Pointer to a buffer containing the ECL sequence states duration in multiple of 100 µs (max. value XL_MOST150_ECL_SEQ_DURATION_MAX) + * NOTE: Both buffers have to have at least the size DWORDS! + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150EclConfigureSeq, XLFP_MOST150ECLCONFIGURESEQ, (DEFPARAMS, unsigned int numStates, + unsigned int* pEclStates, + unsigned int* pEclStatesDuration)); + +/** \brief Starts or stops the previously configured ECL sequence. + * \param XLportHandle portHandle: [IN] was previously fetched by xlOpenPort API + * \param XLaccess accessMask: [IN] determines on which channel an API should work + * \param XLuserHandle userHandle: [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param start [IN] Starts (1) or stops (0) the configured ECL sequence + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150EclGenerateSeq, XLFP_MOST150ECLGENERATESEQ, (DEFPARAMS, unsigned int start)); + +/** \brief Configures the glitch filter for detecting ECL state changes. + * \param XLportHandle portHandle: [IN] was previously fetched by xlOpenPort API + * \param XLaccess accessMask: [IN] determines on which channel an API should work + * \param XLuserHandle userHandle: [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param duration [IN] Duration (in µs) of glitches to be filtered. Value range: 50 µs .. 50 ms (Default: 1 ms) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150SetECLGlitchFilter, XLFP_MOST150SETECLGLITCHFILTER, (DEFPARAMS, unsigned int duration)); + + +/** \brief Sets the SSOResult value - needed for resetting the value to 0x00 (No Result) after Shutdown Result analysis has been done. + * ResponseEvent: XL_MOST150_SSO_RESULT. + * \param XLportHandle portHandle: [IN] was previously fetched by xlOpenPort API + * \param XLaccess accessMask: [IN] determines on which channel an API should work + * \param XLuserHandle userHandle: [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \param ssoCUStatus [IN] SSOCUStatus (currently only the value is allowed!) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150SetSSOResult, XLFP_MOST150SETSSORESULT, (DEFPARAMS, unsigned int ssoCUStatus)); + +/** \brief Requests the SSOResult value. + * ResponseEvent: XL_MOST150_SSO_RESULT. + * \param XLportHandle portHandle: [IN] was previously fetched by xlOpenPort API + * \param XLaccess accessMask: [IN] determines on which channel an API should work + * \param XLuserHandle userHandle: [IN] used to match the response of the driver to the requests of the application + * if an event is received spontaneously + * \return XLstatus general status information + */ +DECL_STDXL_FUNC (xlMost150GetSSOResult, XLFP_MOST150GETSSORESULT, (DEFPARAMS)); + +//////////////////////////////////////////////////////////////////////////////// +// Ethernet Function Declarations +//////////////////////////////////////////////////////////////////////////////// + +// apiname, apitype, parameters in parenthesis + +/** + * Common principles: + * If not mentioned otherwise, all APIs are asynchronous and will trigger an action in VN56xx. + * Results are delivered in events which can be fetched by xlEthReceive. + * + * Common Parameters: DEFPARAMS + * XLportHandle portHandle: was previously fetched by xlOpenPort API. + * XLaccess accessMask: determines on which channels an API should work. + * XLuserHandle userHandle: used to match the response of the driver to the requests of the application + * if an event is received spontaneously, e.g. MPR changed then the userHandle == 0 + * Common Return Value: + * XLstatus: common return value of most APIs which indicates whether a command was + * successfully launched or e.g. whether a command queue overflow happened + */ + +/** \brief Configures basic Ethernet settings. + * This method is used to configure the basic Ethernets settings like speed, connector, etc. \n + * ResponseEvent: XL_ETH_CONFIG_RESULT + * \param config [IN] new configuration to set + * \return XLstatus general status information + */ +DECL_STDXL_FUNC(xlEthSetConfig, XLFP_ETHSETCONFIG, (DEFPARAMS, const T_XL_ETH_CONFIG *config)); + +/** \brief Synchronously read the last Ethernet configuration settings. + * This allows an application to detect if a change in configuration is necessary.\n + * ResponseEvent: none + * \param config [OUT] current configuration + * \return XLstatus general status information + */ +DECL_STDXL_FUNC(xlEthGetConfig, XLFP_ETHGETCONFIG, (DEFPARAMS, T_XL_ETH_CONFIG *config)); + +/** \brief Fetching events from driver queue. + * This method is used to fetch events, either bus events or acknowledgments + * for commands from the driver queue. Each call delivers only one event (if an event is available). \n + * It is a synchronous mode and either delivers event data immediately, or + * indicates an error condition with its return value. + * \param XLportHandle portHandle: [IN] was previously fetched by xlOpenPort API + * \param ethEventBuffer [IN] This parameter must point to a buffer to which the driver can copy + * the next event of the receive queue. The "size" member of this struct + * specifies the maximum size of the buffer (header plus receive data); upon return, + * it holds the actual size. + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlEthReceive, XLFP_ETHRECEIVE, (XLportHandle portHandle, T_XL_ETH_EVENT *ethEventBuffer)); + +/** \brief Configures the bypass of two channels. + * This method is used to enable the bypass of two channels or to disable the bypass for several channels\n + * ResponseEvent: XL_ETH_CONFIG + * \param mode [IN] Bypass state (one of XL_ETH_BYPASS_INACTIVE, XL_ETH_BYPASS_PHY, XL_ETH_BYPASS_MACCORE) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC(xlEthSetBypass, XLFP_ETHSETBYPASS, (DEFPARAMS, unsigned int mode)); + +/** \brief Twinkle the Status led from the VN5610. + * ResponseEvent: none + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlEthTwinkleStatusLed, XLFP_ETHTWINKLESTATUSLED, (DEFPARAMS)); + +/** \brief Transmit a data frame to the network. + * This method is asynchronous; a confirmation of the transmit is received via an XL_ETH_TX_OK/XL_ETH_TX_ERROR event. + * ResponseEvent: XL_ETH_TX_OK, XL_ETH_TX_ERROR + * \param data: [IN] pointer to an Ethernet data frame to be sent + * \return XLstatus general status information + */ +DECL_STDXL_FUNC( xlEthTransmit, XLFP_ETHTRANSMIT, (DEFPARAMS, const T_XL_ETH_DATAFRAME_TX *data)); + +//////////////////////////////////////////////////////////////////////////////// +// ARINC429 Function Declarations +//////////////////////////////////////////////////////////////////////////////// +// apiname, apitype, parameters in parenthesis + +/** + * Common Parameters: DEFPARAMS + * XLportHandle portHandle: was previously fetched by xlOpenPort API. + * XLaccess accessMask: determines on which channels an API should work. + * Common Return Value: + * XLstatus: common return value of most APIs which indicates whether a command was + * successfully launched or e.g. whether a command queue overflow happened + */ + +/** \brief Fetching events from driver queue. + * This method is used to fetch events, either bus events or acknowledgments + * for commands from the driver queue. Each call delivers only one event (if an event is available). \n + * It is a synchronous mode and either delivers event data immediately, or + * indicates an error condition with its return value. + * \param portHandle: [IN] was previously fetched by xlOpenPort API + * \param pXlA429RxEvt: [IN] This parameter must point to a buffer to which the driver can copy + * the next event of the receive queue. The "size" member of this struct + * specifies the maximum size of the buffer (header plus receive data); upon return, + * it holds the actual size. + * \return XLstatus general status information + */ +DECL_STDXL_FUNC(xlA429Receive, XLFP_A429RECEIVE, (XLportHandle portHandle, XLa429RxEvent* pXlA429RxEvt)); + +/** \brief Configures basic Arinc429 settings. + * This method is used to configure the basic Arinc429 settings like parity, bitrate, etc. \n + * \param pXlA429Params: [IN] new Arinc429 parameter to set + * \return XLstatus general status information + */ +DECL_STDXL_FUNC(xlA429SetChannelParams, XLFP_A429SETCHANNELPARAMS, (DEFFRPARAM, XL_A429_PARAMS* pXlA429Params)); + +/** \brief Transmit a Arinc429 word to the network. + * This method is asynchronous; a confirmation of the transmit is received via an XL_A429_EV_TAG_TX_OK/XL_A429_EV_TAG_TX_ERR event. + * \param pXlA429MsgTx: [IN] pointer to an Arinc429 frame to be sent + * \return XLstatus general status information + */ +DECL_STDXL_FUNC(xlA429Transmit, XLFP_A429TRANSMIT, (DEFFRPARAM, unsigned int msgCnt, unsigned int* pMsgCntSent, XL_A429_MSG_TX* pXlA429MsgTx)); + +//////////////////////////////////////////////////////////////////////////////// +// Vector Keyman Function Declarations +//////////////////////////////////////////////////////////////////////////////// +// apiname, apitype, parameters in parenthesis + +/** \brief Returns connected Keyman license dongles. + * This method returns the connected Keyman license dongles + * \param boxCount: [IN] number of connected Keyman license Dongles + * \return XLstatus general status information + */ +DECL_STDXL_FUNC(xlGetKeymanBoxes, XLFP_GETKEYMANBOXES, (unsigned int* boxCount)); + +/** \brief Returns serial number and license info. + * This method returns serial number and license info (license bits) of selected Keyman License dongle + * \param boxIndex: [IN] index of found Keyman License Dongle (zero based) + * \param boxMask: [OUT] mask of Keyman Dongle + * \param boxSerial: [OUT] serial number of Keyman Dongle + * \param licInfo: [OUT] license Info (license bits in license array) + * \return XLstatus general status information + */ +DECL_STDXL_FUNC(xlGetKeymanInfo, XLFP_GETKEYMANINFO, (unsigned int boxIndex, unsigned int* boxMask, unsigned int* boxSerial, XLuint64* licInfo)); + + +#ifdef __cplusplus +} +#endif // _cplusplus + +#endif // _V_XLAPI_H_ + + + + diff --git a/Host/Source/LibOpenBLT/port/windows/canif/vector/xlLoadlib.c b/Host/Source/LibOpenBLT/port/windows/canif/vector/xlLoadlib.c new file mode 100644 index 00000000..7b3e4f49 --- /dev/null +++ b/Host/Source/LibOpenBLT/port/windows/canif/vector/xlLoadlib.c @@ -0,0 +1,554 @@ +/*--------------------------------------------------------------------------------------- +| File: +| xlLoadlib.c +| Project: +| xlCANcontrol, xlMOSTView, xlFlexDemo +| +| Description: +| For the dynamically linking of the XL Driver Library. +| +| +|----------------------------------------------------------------------------- +| $Author: vishsh $ $Date: 2016-05-19 08:45:09 +0200 (Thu, 19 May 2016) $ $Revision: 57918 $ +| $Id: xlLoadlib.c 57918 2016-05-19 06:45:09Z vishsh $ +|----------------------------------------------------------------------------- +| Copyright (c) 2014 by Vector Informatik GmbH. All rights reserved. + ----------------------------------------------------------------------------*/ + +#include +#ifndef _MFC_VER +# include +#endif +#include + +/////////////////////////////////////////////////////////////////////////// +//Global variables +//////////////////////////////////////////////////////////////////////////// + +// function pointers + + XLGETAPPLCONFIG xlGetApplConfig = NULL; + XLSETAPPLCONFIG xlSetApplConfig = NULL; + XLGETDRIVERCONFIG xlGetDriverConfig = NULL; + XLGETCHANNELINDEX xlGetChannelIndex = NULL; + XLGETCHANNELMASK xlGetChannelMask = NULL; + XLOPENPORT xlOpenPort = NULL; + XLSETTIMERRATE xlSetTimerRate = NULL; + XLRESETCLOCK xlResetClock = NULL; + XLSETNOTIFICATION xlSetNotification = NULL; + XLFLUSHRECEIVEQUEUE xlFlushReceiveQueue = NULL; + XLGETRECEIVEQUEUELEVEL xlGetReceiveQueueLevel = NULL; + XLACTIVATECHANNEL xlActivateChannel = NULL; + XLRECEIVE xlReceive = NULL; + XLGETEVENTSTRING xlGetEventString = NULL; + XLGETERRORSTRING xlGetErrorString = NULL; + XLGETSYNCTIME xlGetSyncTime = NULL; + XLGENERATESYNCPULSE xlGenerateSyncPulse = NULL; + XLPOPUPHWCONFIG xlPopupHwConfig = NULL; + XLDEACTIVATECHANNEL xlDeactivateChannel = NULL; + XLCLOSEPORT xlClosePort = NULL; + XLSETTIMERBASEDNOTIFY xlSetTimerBasedNotify = NULL; + XLSETTIMERRATEANDCHANNEL xlSetTimerRateAndChannel = NULL; + XLGETLICENSEINFO xlGetLicenseInfo = NULL; + XLGETCHANNELTIME xlGetChannelTime = NULL; + XLGETREMOTEDRIVERCONFIG xlGetRemoteDriverConfig = NULL; + + // CAN specific functions + XLCANSETCHANNELOUTPUT xlCanSetChannelOutput = NULL; + XLCANSETCHANNELMODE xlCanSetChannelMode = NULL; + XLCANSETRECEIVEMODE xlCanSetReceiveMode = NULL; + XLCANSETCHANNELTRANSCEIVER xlCanSetChannelTransceiver = NULL; + XLCANSETCHANNELPARAMS xlCanSetChannelParams = NULL; + XLCANSETCHANNELPARAMSC200 xlCanSetChannelParamsC200 = NULL; + XLCANSETCHANNELBITRATE xlCanSetChannelBitrate = NULL; + XLCANSETCHANNELACCEPTANCE xlCanSetChannelAcceptance = NULL; + XLCANADDACCEPTANCERANGE xlCanAddAcceptanceRange = NULL; + XLCANREMOVEACCEPTANCERANGE xlCanRemoveAcceptanceRange = NULL; + XLCANRESETACCEPTANCE xlCanResetAcceptance = NULL; + XLCANREQUESTCHIPSTATE xlCanRequestChipState = NULL; + XLCANFLUSHTRANSMITQUEUE xlCanFlushTransmitQueue = NULL; + XLCANTRANSMIT xlCanTransmit = NULL; + + // CAN-FD specific functions + XLCANFDSETCONFIGURATION xlCanFdSetConfiguration = NULL; + XLCANTRANSMITEX xlCanTransmitEx = NULL; + XLCANRECEIVE xlCanReceive = NULL; + XLCANGETEVENTSTRING xlCanGetEventString = NULL; + + // LIN specific functions + XLLINSETCHANNELPARAMS xlLinSetChannelParams = NULL; + XLLINSETDLC xlLinSetDLC = NULL; + XLLINSETSLAVE xlLinSetSlave = NULL; + XLLINSENDREQUEST xlLinSendRequest = NULL; + XLLINSETSLEEPMODE xlLinSetSleepMode = NULL; + XLLINWAKEUP xlLinWakeUp = NULL; + XLLINSETCHECKSUM xlLinSetChecksum = NULL; + XLLINSWITCHSLAVE xlLinSwitchSlave = NULL; + + + // IOcab specific functions + XLDAIOSETPWMOUTPUT xlDAIOSetPWMOutput = NULL; + XLDAIOSETDIGITALOUTPUT xlDAIOSetDigitalOutput = NULL; + XLDAIOSETANALOGOUTPUT xlDAIOSetAnalogOutput = NULL; + XLDAIOREQUESTMEASUREMENT xlDAIORequestMeasurement = NULL; + XLDAIOSETDIGITALPARAMETERS xlDAIOSetDigitalParameters = NULL; + XLDAIOSETANALOGPARAMETERS xlDAIOSetAnalogParameters = NULL; + XLDAIOSETANALOGTRIGGER xlDAIOSetAnalogTrigger = NULL; + XLDAIOSETMEASUREMENTFREQUENCY xlDAIOSetMeasurementFrequency = NULL; + + // MOST specific functions + XLFP_MOSTRECEIVE xlMostReceive = NULL; + XLFP_MOSTCTRLTRANSMIT xlMostCtrlTransmit = NULL; + XLFP_MOSTSWITCHEVENTSOURCES xlMostSwitchEventSources = NULL; + XLFP_MOSTSETALLBYPASS xlMostSetAllBypass = NULL; + XLFP_MOSTGETALLBYPASS xlMostGetAllBypass = NULL; + XLFP_MOSTSETTIMINGMODE xlMostSetTimingMode = NULL; + XLFP_MOSTGETTIMINGMODE xlMostGetTimingMode = NULL; + XLFP_MOSTSETFREQUENCY xlMostSetFrequency = NULL; + XLFP_MOSTGETFREQUENCY xlMostGetFrequency = NULL; + XLFP_MOSTWRITEREGISTER xlMostWriteRegister = NULL; + XLFP_MOSTREADREGISTER xlMostReadRegister = NULL; + XLFP_MOSTWRITEREGISTERBIT xlMostWriteRegisterBit = NULL; + XLFP_MOSTSYNCGETALLOCTABLE xlMostSyncGetAllocTable = NULL; + XLFP_MOSTCTRLSYNCAUDIO xlMostCtrlSyncAudio = NULL; + XLFP_MOSTCTRLSYNCAUDIOEX xlMostCtrlSyncAudioEx = NULL; + XLFP_MOSTSYNCVOLUME xlMostSyncVolume = NULL; + XLFP_MOSTSYNCMUTE xlMostSyncMute = NULL; + XLFP_MOSTSYNCGETVOLUMESTATUS xlMostSyncGetVolumeStatus = NULL; + XLFP_MOSTSYNCGETMUTESTATUS xlMostSyncGetMuteStatus = NULL; + XLFP_MOSTGETRXLIGHT xlMostGetRxLight = NULL; + XLFP_MOSTSETTXLIGHT xlMostSetTxLight = NULL; + XLFP_MOSTGETTXLIGHT xlMostGetTxLight = NULL; + XLFP_MOSTSETLIGHTPOWER xlMostSetLightPower = NULL; + XLFP_MOSTGETLOCKSTATUS xlMostGetLockStatus = NULL; + XLFP_MOSTGENERATELIGHTERROR xlMostGenerateLightError = NULL; + XLFP_MOSTGENERATELOCKERROR xlMostGenerateLockError = NULL; + XLFP_MOSTCTRLRXBUFFER xlMostCtrlRxBuffer = NULL; + XLFP_MOSTTWINKLEPOWERLED xlMostTwinklePowerLed = NULL; + XLFP_MOSTASYNCTRANSMIT xlMostAsyncTransmit = NULL; + XLFP_MOSTCTRLCONFIGUREBUSLOAD xlMostCtrlConfigureBusload = NULL; + XLFP_MOSTCTRLGENERATEBUSLOAD xlMostCtrlGenerateBusload = NULL; + XLFP_MOSTASYNCCONFIGUREBUSLOAD xlMostAsyncConfigureBusload = NULL; + XLFP_MOSTASYNCGENERATEBUSLOAD xlMostAsyncGenerateBusload = NULL; + XLFP_MOSTSTREAMOPEN xlMostStreamOpen = NULL; + XLFP_MOSTSTREAMCLOSE xlMostStreamClose = NULL; + XLFP_MOSTSTREAMSTART xlMostStreamStart = NULL; + XLFP_MOSTSTREAMSTOP xlMostStreamStop = NULL; + XLFP_MOSTSTREAMBUFFERALLOCATE xlMostStreamBufferAllocate = NULL; + XLFP_MOSTSTREAMBUFFERDEALLOCATEALL xlMostStreamBufferDeallocateAll = NULL; + XLFP_MOSTSTREAMBUFFERSETNEXT xlMostStreamBufferSetNext = NULL; + XLFP_MOSTSTREAMGETINFO xlMostStreamGetInfo = NULL; + XLFP_MOSTSTREAMBUFFERCLEARALL xlMostStreamBufferClearAll = NULL; + + // FlexRay specific functions + XLFP_FRSETCONFIGURATION xlFrSetConfiguration = NULL; + XLFP_FRGETCHANNELCONFIGURATION xlFrGetChannelConfiguration = NULL; + XLFP_FRSETMODE xlFrSetMode = NULL; + XLFP_FRINITSTARTUPANDSYNC xlFrInitStartupAndSync = NULL; + XLFP_FRSETUPSYMBOLWINDOW xlFrSetupSymbolWindow = NULL; + XLFP_FRRECEIVE xlFrReceive = NULL; + XLFP_FRTRANSMIT xlFrTransmit = NULL; + XLFP_FRSETTRANSCEIVERMODE xlFrSetTransceiverMode = NULL; + XLFP_FRSENDSYMBOLWINDOW xlFrSendSymbolWindow = NULL; + XLFP_FRACTIVATESPY xlFrActivateSpy = NULL; + XLFP_FRSETACCEPTANCEFILTER xlFrSetAcceptanceFilter = NULL; + + // MOST150 specific functions + XLFP_MOST150SWITCHEVENTSOURCES xlMost150SwitchEventSources = NULL; + XLFP_MOST150SETDEVICEMODE xlMost150SetDeviceMode = NULL; + XLFP_MOST150GETDEVICEMODE xlMost150GetDeviceMode = NULL; + XLFP_MOST150SETSPDIFMODE xlMost150SetSPDIFMode = NULL; + XLFP_MOST150GETSPDIFMODE xlMost150GetSPDIFMode = NULL; + XLFP_MOST150RECEIVE xlMost150Receive = NULL; + XLFP_MOST150SETSPECIALNODEINFO xlMost150SetSpecialNodeInfo = NULL; + XLFP_MOST150GETSPECIALNODEINFO xlMost150GetSpecialNodeInfo = NULL; + XLFP_MOST150SETFREQUENCY xlMost150SetFrequency = NULL; + XLFP_MOST150GETFREQUENCY xlMost150GetFrequency = NULL; + XLFP_MOST150CTRLTRANSMIT xlMost150CtrlTransmit = NULL; + XLFP_MOST150ASYNCTRANSMIT xlMost150AsyncTransmit = NULL; + XLFP_MOST150ETHTRANSMIT xlMost150EthernetTransmit = NULL; + XLFP_MOST150GETSYSTEMLOCK xlMost150GetSystemLockFlag = NULL; + XLFP_MOST150GETSHUTDOWN xlMost150GetShutdownFlag = NULL; + XLFP_MOST150SHUTDOWN xlMost150Shutdown = NULL; + XLFP_MOST150STARTUP xlMost150Startup = NULL; + XLFP_MOST150GETALLOCTABLE xlMost150SyncGetAllocTable = NULL; + XLFP_MOST150CTRLSYNCAUDIO xlMost150CtrlSyncAudio = NULL; + XLFP_MOST150SYNCSETVOLUME xlMost150SyncSetVolume = NULL; + XLFP_MOST150SYNCGETVOLUME xlMost150SyncGetVolume = NULL; + XLFP_MOST150SYNCSETMUTE xlMost150SyncSetMute = NULL; + XLFP_MOST150SYNCGETMUTE xlMost150SyncGetMute = NULL; + XLFP_MOST150GETLIGHTLOCKSTATUS xlMost150GetRxLightLockStatus = NULL; + XLFP_MOST150SETTXLIGHT xlMost150SetTxLight = NULL; + XLFP_MOST150GETTXLIGHT xlMost150GetTxLight = NULL; + XLFP_MOST150SETTXLIGHTPOWER xlMost150SetTxLightPower = NULL; + XLFP_MOST150GENLIGHTERROR xlMost150GenerateLightError = NULL; + XLFP_MOST150GENLOCKERROR xlMost150GenerateLockError = NULL; + XLFP_MOST150CONFIGURERXBUFFER xlMost150ConfigureRxBuffer = NULL; + XLFP_MOST150CTRLCONFIGLOAD xlMost150CtrlConfigureBusload = NULL; + XLFP_MOST150CTRLGENLOAD xlMost150CtrlGenerateBusload = NULL; + XLFP_MOST150ASYNCCONFIGLOAD xlMost150AsyncConfigureBusload = NULL; + XLFP_MOST150ASYNCGENLOAD xlMost150AsyncGenerateBusload = NULL; + XLFP_MOST150SETECLLINE xlMost150SetECLLine = NULL; + XLFP_MOST150SETECLTERMINATION xlMost150SetECLTermination = NULL; + XLFP_MOST150TWINKLEPOWERLED xlMost150TwinklePowerLed = NULL; + XLFP_MOST150GETECLINFO xlMost150GetECLInfo = NULL; + XLFP_MOST150STREAMOPEN xlMost150StreamOpen = NULL; + XLFP_MOST150STREAMCLOSE xlMost150StreamClose = NULL; + XLFP_MOST150STREAMSTART xlMost150StreamStart = NULL; + XLFP_MOST150STREAMSTOP xlMost150StreamStop = NULL; + XLFP_MOST150STREAMTRANSMITDATA xlMost150StreamTransmitData = NULL; + XLFP_MOST150STREAMCLEARTXFIFO xlMost150StreamClearTxFifo = NULL; + XLFP_MOST150STREAMGETINFO xlMost150StreamGetInfo = NULL; + XLFP_MOST150STREAMINITRXFIFO xlMost150StreamInitRxFifo = NULL; + XLFP_MOST150STREAMRECEIVEDATA xlMost150StreamReceiveData = NULL; + XLFP_MOST150GENERATEBYPASSSTRESS xlMost150GenerateBypassStress = NULL; + XLFP_MOST150ECLCONFIGURESEQ xlMost150EclConfigureSeq = NULL; + XLFP_MOST150ECLGENERATESEQ xlMost150EclGenerateSeq = NULL; + XLFP_MOST150SETECLGLITCHFILTER xlMost150SetECLGlitchFilter = NULL; + XLFP_MOST150SETSSORESULT xlMost150SetSSOResult = NULL; + XLFP_MOST150GETSSORESULT xlMost150GetSSOResult = NULL; + + // Ethernet specific funtions + XLFP_ETHSETCONFIG xlEthSetConfig = NULL; + XLFP_ETHGETCONFIG xlEthGetConfig = NULL; + XLFP_ETHRECEIVE xlEthReceive = NULL; + XLFP_ETHSETBYPASS xlEthSetBypass = NULL; + XLFP_ETHTWINKLESTATUSLED xlEthTwinkleStatusLed = NULL; + XLFP_ETHTRANSMIT xlEthTransmit = NULL; + + // IOpiggy specific functions + XLIOSETTRIGGERMODE xlIoSetTriggerMode = NULL; + XLIOSETDIGITALOUTPUT xlIoSetDigitalOutput = NULL; + XLIOCONFIGUREPORTS xlIoConfigurePorts = NULL; + XLIOSETDIGINTHRESHOLD xlIoSetDigInThreshold = NULL; + XLIOSETDIGOUTLEVEL xlIoSetDigOutLevel = NULL; + XLIOSETANALOGOUTPUT xlIoSetAnalogOutput = NULL; + XLIOSTARTSAMPLING xlIoStartSampling = NULL; + + // Remote specific functions + XLGETREMOTEDEVICEINFO xlGetRemoteDeviceInfo = NULL; + XLRELEASEREMOTEDEVICEINFO xlReleaseRemoteDeviceInfo = NULL; + XLADDREMOTEDEVICE xlAddRemoteDevice = NULL; + XLREMOVEREMOTEDEVICE xlRemoveRemoteDevice = NULL; + XLUPDATEREMOTEDEVICEINFO xlUpdateRemoteDeviceInfo = NULL; + XLGETREMOTEHWINFO xlGetRemoteHwInfo = NULL; + + // A429 specific functions + XLFP_A429RECEIVE xlA429Receive = NULL; + XLFP_A429SETCHANNELPARAMS xlA429SetChannelParams = NULL; + XLFP_A429TRANSMIT xlA429Transmit = NULL; + + // Keyman license dongle specific functions + XLFP_GETKEYMANBOXES xlGetKeymanBoxes = NULL; + XLFP_GETKEYMANINFO xlGetKeymanInfo = NULL; + + //Local variables + static XLCLOSEDRIVER xlDllCloseDriver = NULL; + static XLOPENDRIVER xlDllOpenDriver = NULL; + + static HINSTANCE hxlDll; + +//////////////////////////////////////////////////////////////////////////// + +//! xlLoadLibrary() + +//! Loads API functions from DLL +//! +//////////////////////////////////////////////////////////////////////////// + +XLstatus xlLoadLibrary(char const * library){ + + if (!hxlDll) + hxlDll = LoadLibrary(library); + + if (!hxlDll){ +#ifdef _MFC_VER + #ifdef WIN64 + MessageBox(NULL,"Dynamic XL Driver Library - not found (vxlapi64.dll)","XL API",MB_OK|MB_ICONEXCLAMATION); + #else + MessageBox(NULL,"Dynamic XL Driver Library - not found (vxlapi.dll)","XL API",MB_OK|MB_ICONEXCLAMATION); + #endif +#else + #ifdef WIN64 + printf("Dynamic XL Driver Library - not found (vxlapi64.dll)\n"); + #else + printf("Dynamic XL Driver Library - not found (vxlapi.dll)\n"); + #endif +#endif + return XL_ERROR; + } else { + + unsigned int NotFoundAll = 0; + + if ( (xlDllOpenDriver = (XLOPENDRIVER)GetProcAddress(hxlDll,"xlOpenDriver") )==NULL) NotFoundAll= 1; + if ( (xlDllCloseDriver = (XLCLOSEDRIVER)GetProcAddress(hxlDll,"xlCloseDriver") )==NULL) NotFoundAll= 2; + + // bus independed functions + if ( (xlGetApplConfig = (XLGETAPPLCONFIG)GetProcAddress(hxlDll,"xlGetApplConfig") )==NULL) NotFoundAll= 3; + if ( (xlSetApplConfig = (XLSETAPPLCONFIG)GetProcAddress(hxlDll,"xlSetApplConfig") )==NULL) NotFoundAll= 4; + if ( (xlGetDriverConfig = (XLGETDRIVERCONFIG)GetProcAddress(hxlDll,"xlGetDriverConfig") )==NULL) NotFoundAll= 5; + if ( (xlGetChannelIndex = (XLGETCHANNELINDEX)GetProcAddress(hxlDll,"xlGetChannelIndex") )==NULL) NotFoundAll= 6; + if ( (xlGetChannelMask = (XLGETCHANNELMASK)GetProcAddress(hxlDll,"xlGetChannelMask") )==NULL) NotFoundAll= 7; + if ( (xlOpenPort = (XLOPENPORT)GetProcAddress(hxlDll,"xlOpenPort") )==NULL) NotFoundAll= 8; + if ( (xlSetTimerRate = (XLSETTIMERRATE)GetProcAddress(hxlDll,"xlSetTimerRate") )==NULL) NotFoundAll= 9; + if ( (xlResetClock = (XLRESETCLOCK)GetProcAddress(hxlDll,"xlResetClock") )==NULL) NotFoundAll=10; + if ( (xlSetNotification = (XLSETNOTIFICATION)GetProcAddress(hxlDll,"xlSetNotification") )==NULL) NotFoundAll=11; + if ( (xlFlushReceiveQueue = (XLFLUSHRECEIVEQUEUE)GetProcAddress(hxlDll,"xlFlushReceiveQueue") )==NULL) NotFoundAll=12; + if ( (xlGetReceiveQueueLevel = (XLGETRECEIVEQUEUELEVEL)GetProcAddress(hxlDll,"xlGetReceiveQueueLevel") )==NULL) NotFoundAll=13; + if ( (xlActivateChannel = (XLACTIVATECHANNEL)GetProcAddress(hxlDll,"xlActivateChannel") )==NULL) NotFoundAll=14; + if ( (xlReceive = (XLRECEIVE)GetProcAddress(hxlDll,"xlReceive") )==NULL) NotFoundAll=15; + if ( (xlGetEventString = (XLGETEVENTSTRING)GetProcAddress(hxlDll,"xlGetEventString") )==NULL) NotFoundAll=16; + if ( (xlGetErrorString = (XLGETERRORSTRING)GetProcAddress(hxlDll,"xlGetErrorString") )==NULL) NotFoundAll=17; + if ( (xlGenerateSyncPulse = (XLGENERATESYNCPULSE)GetProcAddress(hxlDll,"xlGenerateSyncPulse") )==NULL) NotFoundAll=18; + if ( (xlGetSyncTime = (XLGETSYNCTIME) GetProcAddress(hxlDll,"xlGetSyncTime") )==NULL) NotFoundAll=19; + if ( (xlPopupHwConfig = (XLPOPUPHWCONFIG)GetProcAddress(hxlDll,"xlPopupHwConfig") )==NULL) NotFoundAll=20; + if ( (xlDeactivateChannel = (XLDEACTIVATECHANNEL)GetProcAddress(hxlDll,"xlDeactivateChannel") )==NULL) NotFoundAll=21; + if ( (xlClosePort = (XLCLOSEPORT )GetProcAddress(hxlDll,"xlClosePort") )==NULL) NotFoundAll=22; + if ( (xlSetTimerBasedNotify = (XLSETTIMERBASEDNOTIFY)GetProcAddress(hxlDll,"xlSetTimerBasedNotify") )==NULL) NotFoundAll=110; + if ( (xlSetTimerRateAndChannel = (XLSETTIMERRATEANDCHANNEL) GetProcAddress(hxlDll, "xlSetTimerRateAndChannel") )==NULL) NotFoundAll=111; + if ( (xlGetLicenseInfo = (XLGETLICENSEINFO) GetProcAddress(hxlDll, "xlGetLicenseInfo") )==NULL) NotFoundAll=112; + if ( (xlGetChannelTime = (XLGETCHANNELTIME)GetProcAddress(hxlDll,"xlGetChannelTime") )==NULL) NotFoundAll=113; + if( (xlGetRemoteDriverConfig = (XLGETREMOTEDRIVERCONFIG) GetProcAddress(hxlDll, "xlGetRemoteDriverConfig") ) == NULL) NotFoundAll=114; + + // CAN specific functions + if ( (xlCanSetChannelOutput = (XLCANSETCHANNELOUTPUT)GetProcAddress(hxlDll,"xlCanSetChannelOutput") )==NULL) NotFoundAll=23; + if ( (xlCanSetChannelMode = (XLCANSETCHANNELMODE)GetProcAddress(hxlDll,"xlCanSetChannelMode") )==NULL) NotFoundAll=24; + if ( (xlCanSetReceiveMode = (XLCANSETRECEIVEMODE)GetProcAddress(hxlDll,"xlCanSetReceiveMode") ) == NULL) NotFoundAll=25; + if ( (xlCanSetChannelTransceiver = (XLCANSETCHANNELTRANSCEIVER)GetProcAddress(hxlDll,"xlCanSetChannelTransceiver") ) == NULL) NotFoundAll=26; + if ( (xlCanSetChannelParams = (XLCANSETCHANNELPARAMS)GetProcAddress(hxlDll,"xlCanSetChannelParams") ) == NULL) NotFoundAll=27; + if ( (xlCanSetChannelParamsC200 = (XLCANSETCHANNELPARAMSC200)GetProcAddress(hxlDll,"xlCanSetChannelParamsC200") )==NULL) NotFoundAll=28; + if ( (xlCanSetChannelBitrate = (XLCANSETCHANNELBITRATE)GetProcAddress(hxlDll,"xlCanSetChannelBitrate") )==NULL) NotFoundAll=29; + if ( (xlCanSetChannelAcceptance = (XLCANSETCHANNELACCEPTANCE)GetProcAddress(hxlDll,"xlCanSetChannelAcceptance") )==NULL) NotFoundAll=30; + if ( (xlCanAddAcceptanceRange = (XLCANADDACCEPTANCERANGE)GetProcAddress(hxlDll,"xlCanAddAcceptanceRange") )==NULL) NotFoundAll=31; + if ( (xlCanRemoveAcceptanceRange = (XLCANREMOVEACCEPTANCERANGE)GetProcAddress(hxlDll,"xlCanRemoveAcceptanceRange") )==NULL) NotFoundAll=32; + if ( (xlCanResetAcceptance = (XLCANRESETACCEPTANCE)GetProcAddress(hxlDll,"xlCanResetAcceptance") )==NULL) NotFoundAll=33; + if ( (xlCanRequestChipState = (XLCANREQUESTCHIPSTATE)GetProcAddress(hxlDll,"xlCanRequestChipState") )==NULL) NotFoundAll=34; + if ( (xlCanFlushTransmitQueue = (XLCANFLUSHTRANSMITQUEUE)GetProcAddress(hxlDll,"xlCanFlushTransmitQueue") )==NULL) NotFoundAll=35; + if ( (xlCanTransmit = (XLCANTRANSMIT)GetProcAddress(hxlDll,"xlCanTransmit") )==NULL) NotFoundAll=36; + + // LIN specific functions + if ( (xlLinSetChannelParams = (XLLINSETCHANNELPARAMS)GetProcAddress(hxlDll,"xlLinSetChannelParams") )==NULL) NotFoundAll=37; + if ( (xlLinSetDLC = (XLLINSETDLC)GetProcAddress(hxlDll,"xlLinSetDLC") )==NULL) NotFoundAll=38; + if ( (xlLinSetSlave = (XLLINSETSLAVE)GetProcAddress(hxlDll,"xlLinSetSlave") )==NULL) NotFoundAll=39; + if ( (xlLinSendRequest = (XLLINSENDREQUEST)GetProcAddress(hxlDll,"xlLinSendRequest") )==NULL) NotFoundAll=40; + if ( (xlLinWakeUp = (XLLINWAKEUP) GetProcAddress(hxlDll,"xlLinWakeUp") )==NULL) NotFoundAll=41; + if ( (xlLinSetChecksum = (XLLINSETCHECKSUM) GetProcAddress(hxlDll,"xlLinSetChecksum") )==NULL) NotFoundAll=42; + if ( (xlLinSwitchSlave = (XLLINSWITCHSLAVE) GetProcAddress(hxlDll,"xlLinSwitchSlave") )==NULL) NotFoundAll=43; + if ( (xlLinSetSleepMode = (XLLINSETSLEEPMODE) GetProcAddress(hxlDll,"xlLinSetSleepMode") )==NULL) NotFoundAll=190; + + // IOcab specific functions + if ( (xlDAIOSetPWMOutput = (XLDAIOSETPWMOUTPUT)GetProcAddress(hxlDll,"xlDAIOSetPWMOutput") )==NULL) NotFoundAll=44; + if ( (xlDAIOSetDigitalOutput = (XLDAIOSETDIGITALOUTPUT)GetProcAddress(hxlDll,"xlDAIOSetDigitalOutput") )==NULL) NotFoundAll=45; + if ( (xlDAIOSetAnalogOutput = (XLDAIOSETANALOGOUTPUT)GetProcAddress(hxlDll,"xlDAIOSetAnalogOutput") )==NULL) NotFoundAll=46; + if ( (xlDAIORequestMeasurement = (XLDAIOREQUESTMEASUREMENT)GetProcAddress(hxlDll,"xlDAIORequestMeasurement") )==NULL) NotFoundAll=47; + if ( (xlDAIOSetDigitalParameters = (XLDAIOSETDIGITALPARAMETERS) GetProcAddress(hxlDll,"xlDAIOSetDigitalParameters") )==NULL) NotFoundAll=48; + if ( (xlDAIOSetAnalogParameters = (XLDAIOSETANALOGPARAMETERS)GetProcAddress(hxlDll,"xlDAIOSetAnalogParameters") )==NULL) NotFoundAll=49; + if ( (xlDAIOSetAnalogTrigger = (XLDAIOSETANALOGTRIGGER) GetProcAddress(hxlDll,"xlDAIOSetAnalogTrigger") )==NULL) NotFoundAll=50; + if ( (xlDAIOSetMeasurementFrequency = (XLDAIOSETMEASUREMENTFREQUENCY)GetProcAddress(hxlDll,"xlDAIOSetMeasurementFrequency") )==NULL) NotFoundAll=51; + + // MOST specific functions + if ((xlMostReceive = (XLFP_MOSTRECEIVE) GetProcAddress(hxlDll,"xlMostReceive")) == NULL) NotFoundAll=52; + if ((xlMostCtrlTransmit = (XLFP_MOSTCTRLTRANSMIT) GetProcAddress(hxlDll,"xlMostCtrlTransmit")) == NULL) NotFoundAll=53; + if ((xlMostSwitchEventSources = (XLFP_MOSTSWITCHEVENTSOURCES) GetProcAddress(hxlDll,"xlMostSwitchEventSources")) == NULL) NotFoundAll=54; + if ((xlMostSetAllBypass = (XLFP_MOSTSETALLBYPASS) GetProcAddress(hxlDll,"xlMostSetAllBypass")) == NULL) NotFoundAll=55; + if ((xlMostGetAllBypass = (XLFP_MOSTGETALLBYPASS) GetProcAddress(hxlDll,"xlMostGetAllBypass")) == NULL) NotFoundAll=56; + if ((xlMostSetTimingMode = (XLFP_MOSTSETTIMINGMODE) GetProcAddress(hxlDll,"xlMostSetTimingMode")) == NULL) NotFoundAll=57; + if ((xlMostGetTimingMode = (XLFP_MOSTGETTIMINGMODE) GetProcAddress(hxlDll,"xlMostGetTimingMode")) == NULL) NotFoundAll=58; + if ((xlMostSetFrequency = (XLFP_MOSTSETFREQUENCY) GetProcAddress(hxlDll,"xlMostSetFrequency")) == NULL) NotFoundAll=59; + if ((xlMostGetFrequency = (XLFP_MOSTGETFREQUENCY) GetProcAddress(hxlDll,"xlMostGetFrequency")) == NULL) NotFoundAll=60; + if ((xlMostWriteRegister = (XLFP_MOSTWRITEREGISTER) GetProcAddress(hxlDll,"xlMostWriteRegister")) == NULL) NotFoundAll=61; + if ((xlMostReadRegister = (XLFP_MOSTREADREGISTER) GetProcAddress(hxlDll,"xlMostReadRegister")) == NULL) NotFoundAll=62; + if ((xlMostWriteRegisterBit = (XLFP_MOSTWRITEREGISTERBIT) GetProcAddress(hxlDll,"xlMostWriteRegisterBit")) == NULL) NotFoundAll=63; + if ((xlMostSyncGetAllocTable = (XLFP_MOSTSYNCGETALLOCTABLE) GetProcAddress(hxlDll,"xlMostSyncGetAllocTable")) == NULL) NotFoundAll=64; + if ((xlMostCtrlSyncAudio = (XLFP_MOSTCTRLSYNCAUDIO) GetProcAddress(hxlDll,"xlMostCtrlSyncAudio")) == NULL) NotFoundAll=65; + if ((xlMostCtrlSyncAudioEx = (XLFP_MOSTCTRLSYNCAUDIOEX) GetProcAddress(hxlDll,"xlMostCtrlSyncAudioEx")) == NULL) NotFoundAll=66; + if ((xlMostSyncVolume = (XLFP_MOSTSYNCVOLUME) GetProcAddress(hxlDll,"xlMostSyncVolume")) == NULL) NotFoundAll=67; + if ((xlMostSyncMute = (XLFP_MOSTSYNCMUTE) GetProcAddress(hxlDll,"xlMostSyncMute")) == NULL) NotFoundAll=68; + if ((xlMostSyncGetVolumeStatus = (XLFP_MOSTSYNCGETVOLUMESTATUS) GetProcAddress(hxlDll,"xlMostSyncGetVolumeStatus")) == NULL) NotFoundAll=69; + if ((xlMostSyncGetMuteStatus = (XLFP_MOSTSYNCGETMUTESTATUS) GetProcAddress(hxlDll,"xlMostSyncGetMuteStatus")) == NULL) NotFoundAll=70; + if ((xlMostGetRxLight = (XLFP_MOSTGETRXLIGHT) GetProcAddress(hxlDll,"xlMostGetRxLight")) == NULL) NotFoundAll=71; + if ((xlMostSetTxLight = (XLFP_MOSTSETTXLIGHT) GetProcAddress(hxlDll,"xlMostSetTxLight")) == NULL) NotFoundAll=72; + if ((xlMostGetTxLight = (XLFP_MOSTGETTXLIGHT) GetProcAddress(hxlDll,"xlMostGetTxLight")) == NULL) NotFoundAll=73; + if ((xlMostSetLightPower = (XLFP_MOSTSETLIGHTPOWER) GetProcAddress(hxlDll,"xlMostSetLightPower")) == NULL) NotFoundAll=74; + if ((xlMostGetLockStatus = (XLFP_MOSTGETLOCKSTATUS) GetProcAddress(hxlDll,"xlMostGetLockStatus")) == NULL) NotFoundAll=75; + if ((xlMostGenerateLightError = (XLFP_MOSTGENERATELIGHTERROR) GetProcAddress(hxlDll,"xlMostGenerateLightError")) == NULL) NotFoundAll=76; + if ((xlMostGenerateLockError = (XLFP_MOSTGENERATELOCKERROR) GetProcAddress(hxlDll,"xlMostGenerateLockError")) == NULL) NotFoundAll=77; + if ((xlMostCtrlRxBuffer = (XLFP_MOSTCTRLRXBUFFER) GetProcAddress(hxlDll,"xlMostCtrlRxBuffer")) == NULL) NotFoundAll=78; + if ((xlMostTwinklePowerLed = (XLFP_MOSTTWINKLEPOWERLED) GetProcAddress(hxlDll,"xlMostTwinklePowerLed")) == NULL) NotFoundAll=79; + if ((xlMostAsyncTransmit = (XLFP_MOSTASYNCTRANSMIT) GetProcAddress(hxlDll,"xlMostAsyncTransmit")) == NULL) NotFoundAll=80; + if ((xlMostCtrlConfigureBusload = (XLFP_MOSTCTRLCONFIGUREBUSLOAD) GetProcAddress(hxlDll,"xlMostCtrlConfigureBusload")) == NULL) NotFoundAll=81; + if ((xlMostCtrlGenerateBusload = (XLFP_MOSTCTRLGENERATEBUSLOAD) GetProcAddress(hxlDll,"xlMostCtrlGenerateBusload")) == NULL) NotFoundAll=82; + if ((xlMostAsyncConfigureBusload = (XLFP_MOSTASYNCCONFIGUREBUSLOAD) GetProcAddress(hxlDll,"xlMostAsyncConfigureBusload")) == NULL) NotFoundAll=83; + if ((xlMostAsyncGenerateBusload = (XLFP_MOSTASYNCGENERATEBUSLOAD) GetProcAddress(hxlDll,"xlMostAsyncGenerateBusload")) == NULL) NotFoundAll=84; + if ((xlMostStreamOpen = (XLFP_MOSTSTREAMOPEN) GetProcAddress(hxlDll,"xlMostStreamOpen")) == NULL) NotFoundAll=85; + if ((xlMostStreamClose = (XLFP_MOSTSTREAMCLOSE) GetProcAddress(hxlDll,"xlMostStreamClose")) == NULL) NotFoundAll=86; + if ((xlMostStreamStart = (XLFP_MOSTSTREAMSTART) GetProcAddress(hxlDll,"xlMostStreamStart")) == NULL) NotFoundAll=87; + if ((xlMostStreamStop = (XLFP_MOSTSTREAMSTOP) GetProcAddress(hxlDll,"xlMostStreamStop")) == NULL) NotFoundAll=88; + if ((xlMostStreamBufferAllocate = (XLFP_MOSTSTREAMBUFFERALLOCATE) GetProcAddress(hxlDll,"xlMostStreamBufferAllocate")) == NULL) NotFoundAll=89; + if ((xlMostStreamBufferDeallocateAll = (XLFP_MOSTSTREAMBUFFERDEALLOCATEALL) GetProcAddress(hxlDll,"xlMostStreamBufferDeallocateAll")) == NULL) NotFoundAll=90; + if ((xlMostStreamBufferSetNext = (XLFP_MOSTSTREAMBUFFERSETNEXT) GetProcAddress(hxlDll,"xlMostStreamBufferSetNext")) == NULL) NotFoundAll=91; + if ((xlMostStreamGetInfo = (XLFP_MOSTSTREAMGETINFO) GetProcAddress(hxlDll,"xlMostStreamGetInfo")) == NULL) NotFoundAll=92; + if ((xlMostStreamBufferClearAll = (XLFP_MOSTSTREAMBUFFERCLEARALL) GetProcAddress(hxlDll,"xlMostStreamBufferClearAll")) == NULL) NotFoundAll=93; + + // FlexRay specific functions + if ((xlFrSetConfiguration = (XLFP_FRSETCONFIGURATION) GetProcAddress(hxlDll,"xlFrSetConfiguration")) == NULL) NotFoundAll=100; + if ((xlFrGetChannelConfiguration = (XLFP_FRGETCHANNELCONFIGURATION) GetProcAddress(hxlDll,"xlFrGetChannelConfiguration")) == NULL) NotFoundAll=101; + if ((xlFrSetMode = (XLFP_FRSETMODE) GetProcAddress(hxlDll,"xlFrSetMode")) == NULL) NotFoundAll=102; + if ((xlFrInitStartupAndSync = (XLFP_FRINITSTARTUPANDSYNC) GetProcAddress(hxlDll,"xlFrInitStartupAndSync")) == NULL) NotFoundAll=103; + if ((xlFrSetupSymbolWindow = (XLFP_FRSETUPSYMBOLWINDOW) GetProcAddress(hxlDll,"xlFrSetupSymbolWindow")) == NULL) NotFoundAll=104; + if ((xlFrReceive = (XLFP_FRRECEIVE) GetProcAddress(hxlDll,"xlFrReceive")) == NULL) NotFoundAll=105; + if ((xlFrTransmit = (XLFP_FRTRANSMIT) GetProcAddress(hxlDll,"xlFrTransmit")) == NULL) NotFoundAll=106; + if ((xlFrSetTransceiverMode = (XLFP_FRSETTRANSCEIVERMODE) GetProcAddress(hxlDll,"xlFrSetTransceiverMode")) == NULL) NotFoundAll=107; + if ((xlFrSendSymbolWindow = (XLFP_FRSENDSYMBOLWINDOW) GetProcAddress(hxlDll,"xlFrSendSymbolWindow")) == NULL) NotFoundAll=108; + if ((xlFrActivateSpy = (XLFP_FRACTIVATESPY) GetProcAddress(hxlDll,"xlFrActivateSpy")) == NULL) NotFoundAll=109; + if ((xlFrSetAcceptanceFilter = (XLFP_FRSETACCEPTANCEFILTER) GetProcAddress(hxlDll,"xlFrSetAcceptanceFilter")) == NULL) NotFoundAll=120; + + // MOST150 specific functions + if ((xlMost150SwitchEventSources = (XLFP_MOST150SWITCHEVENTSOURCES) GetProcAddress(hxlDll,"xlMost150SwitchEventSources")) == NULL) NotFoundAll=110; + if ((xlMost150SetDeviceMode = (XLFP_MOST150SETDEVICEMODE) GetProcAddress(hxlDll,"xlMost150SetDeviceMode")) == NULL) NotFoundAll=112; + if ((xlMost150GetDeviceMode = (XLFP_MOST150GETDEVICEMODE) GetProcAddress(hxlDll,"xlMost150GetDeviceMode")) == NULL) NotFoundAll=113; + if ((xlMost150SetSPDIFMode = (XLFP_MOST150SETSPDIFMODE) GetProcAddress(hxlDll,"xlMost150SetSPDIFMode")) == NULL) NotFoundAll=114; + if ((xlMost150GetSPDIFMode = (XLFP_MOST150GETSPDIFMODE) GetProcAddress(hxlDll,"xlMost150GetSPDIFMode")) == NULL) NotFoundAll=115; + if ((xlMost150Receive = (XLFP_MOST150RECEIVE) GetProcAddress(hxlDll,"xlMost150Receive")) == NULL) NotFoundAll=130; + if ((xlMost150SetSpecialNodeInfo = (XLFP_MOST150SETSPECIALNODEINFO) GetProcAddress(hxlDll,"xlMost150SetSpecialNodeInfo")) == NULL) NotFoundAll=131; + if ((xlMost150GetSpecialNodeInfo = (XLFP_MOST150GETSPECIALNODEINFO) GetProcAddress(hxlDll,"xlMost150GetSpecialNodeInfo")) == NULL) NotFoundAll=132; + if ((xlMost150SetFrequency = (XLFP_MOST150SETFREQUENCY) GetProcAddress(hxlDll,"xlMost150SetFrequency")) == NULL) NotFoundAll=133; + if ((xlMost150GetFrequency = (XLFP_MOST150GETFREQUENCY) GetProcAddress(hxlDll,"xlMost150GetFrequency")) == NULL) NotFoundAll=134; + if ((xlMost150CtrlTransmit = (XLFP_MOST150CTRLTRANSMIT) GetProcAddress(hxlDll,"xlMost150CtrlTransmit")) == NULL) NotFoundAll=135; + if ((xlMost150AsyncTransmit = (XLFP_MOST150ASYNCTRANSMIT) GetProcAddress(hxlDll,"xlMost150AsyncTransmit")) == NULL) NotFoundAll=136; + if ((xlMost150EthernetTransmit = (XLFP_MOST150ETHTRANSMIT) GetProcAddress(hxlDll,"xlMost150EthernetTransmit")) == NULL) NotFoundAll=137; + if ((xlMost150GetSystemLockFlag = (XLFP_MOST150GETSYSTEMLOCK) GetProcAddress(hxlDll,"xlMost150GetSystemLockFlag")) == NULL) NotFoundAll=138; + if ((xlMost150GetShutdownFlag = (XLFP_MOST150GETSHUTDOWN) GetProcAddress(hxlDll,"xlMost150GetShutdownFlag")) == NULL) NotFoundAll=139; + if ((xlMost150Shutdown = (XLFP_MOST150SHUTDOWN) GetProcAddress(hxlDll,"xlMost150Shutdown")) == NULL) NotFoundAll=140; + if ((xlMost150Startup = (XLFP_MOST150STARTUP) GetProcAddress(hxlDll,"xlMost150Startup")) == NULL) NotFoundAll=141; + if ((xlMost150SyncGetAllocTable = (XLFP_MOST150GETALLOCTABLE) GetProcAddress(hxlDll,"xlMost150SyncGetAllocTable")) == NULL) NotFoundAll=142; + if ((xlMost150CtrlSyncAudio = (XLFP_MOST150CTRLSYNCAUDIO) GetProcAddress(hxlDll,"xlMost150CtrlSyncAudio")) == NULL) NotFoundAll=143; + if ((xlMost150SyncSetVolume = (XLFP_MOST150SYNCSETVOLUME) GetProcAddress(hxlDll,"xlMost150SyncSetVolume")) == NULL) NotFoundAll=144; + if ((xlMost150SyncGetVolume = (XLFP_MOST150SYNCGETVOLUME) GetProcAddress(hxlDll,"xlMost150SyncGetVolume")) == NULL) NotFoundAll=145; + if ((xlMost150SyncSetMute = (XLFP_MOST150SYNCSETMUTE) GetProcAddress(hxlDll,"xlMost150SyncSetMute")) == NULL) NotFoundAll=146; + if ((xlMost150SyncGetMute = (XLFP_MOST150SYNCGETMUTE) GetProcAddress(hxlDll,"xlMost150SyncGetMute")) == NULL) NotFoundAll=147; + if ((xlMost150GetRxLightLockStatus = (XLFP_MOST150GETLIGHTLOCKSTATUS) GetProcAddress(hxlDll,"xlMost150GetRxLightLockStatus")) == NULL) NotFoundAll=148; + if ((xlMost150SetTxLight = (XLFP_MOST150SETTXLIGHT) GetProcAddress(hxlDll,"xlMost150SetTxLight")) == NULL) NotFoundAll=149; + if ((xlMost150GetTxLight = (XLFP_MOST150GETTXLIGHT) GetProcAddress(hxlDll,"xlMost150GetTxLight")) == NULL) NotFoundAll=150; + if ((xlMost150SetTxLightPower = (XLFP_MOST150SETTXLIGHTPOWER) GetProcAddress(hxlDll,"xlMost150SetTxLightPower")) == NULL) NotFoundAll=151; + if ((xlMost150GenerateLightError = (XLFP_MOST150GENLIGHTERROR) GetProcAddress(hxlDll,"xlMost150GenerateLightError")) == NULL) NotFoundAll=152; + if ((xlMost150GenerateLockError = (XLFP_MOST150GENLOCKERROR) GetProcAddress(hxlDll,"xlMost150GenerateLockError")) == NULL) NotFoundAll=153; + if ((xlMost150ConfigureRxBuffer = (XLFP_MOST150CONFIGURERXBUFFER) GetProcAddress(hxlDll,"xlMost150ConfigureRxBuffer")) == NULL) NotFoundAll=154; + if ((xlMost150CtrlConfigureBusload = (XLFP_MOST150CTRLCONFIGLOAD) GetProcAddress(hxlDll,"xlMost150CtrlConfigureBusload")) == NULL) NotFoundAll=155; + if ((xlMost150CtrlGenerateBusload = (XLFP_MOST150CTRLGENLOAD) GetProcAddress(hxlDll,"xlMost150CtrlGenerateBusload")) == NULL) NotFoundAll=156; + if ((xlMost150AsyncConfigureBusload = (XLFP_MOST150ASYNCCONFIGLOAD) GetProcAddress(hxlDll,"xlMost150AsyncConfigureBusload")) == NULL) NotFoundAll=157; + if ((xlMost150AsyncGenerateBusload = (XLFP_MOST150ASYNCGENLOAD) GetProcAddress(hxlDll,"xlMost150AsyncGenerateBusload")) == NULL) NotFoundAll=158; + if ((xlMost150SetECLLine = (XLFP_MOST150SETECLLINE) GetProcAddress(hxlDll,"xlMost150SetECLLine")) == NULL) NotFoundAll=163; + if ((xlMost150SetECLTermination = (XLFP_MOST150SETECLTERMINATION) GetProcAddress(hxlDll,"xlMost150SetECLTermination")) == NULL) NotFoundAll=164; + if ((xlMost150TwinklePowerLed = (XLFP_MOST150TWINKLEPOWERLED) GetProcAddress(hxlDll,"xlMost150TwinklePowerLed")) == NULL) NotFoundAll=165; + if ((xlMost150GetECLInfo = (XLFP_MOST150GETECLINFO) GetProcAddress(hxlDll,"xlMost150GetECLInfo")) == NULL) NotFoundAll=166; + if ((xlMost150StreamOpen = (XLFP_MOST150STREAMOPEN) GetProcAddress(hxlDll,"xlMost150StreamOpen")) == NULL) NotFoundAll=167; + if ((xlMost150StreamClose = (XLFP_MOST150STREAMCLOSE) GetProcAddress(hxlDll,"xlMost150StreamClose")) == NULL) NotFoundAll=168; + if ((xlMost150StreamStart = (XLFP_MOST150STREAMSTART) GetProcAddress(hxlDll,"xlMost150StreamStart")) == NULL) NotFoundAll=169; + if ((xlMost150StreamStop = (XLFP_MOST150STREAMSTOP) GetProcAddress(hxlDll,"xlMost150StreamStop")) == NULL) NotFoundAll=170; + if ((xlMost150StreamTransmitData = (XLFP_MOST150STREAMTRANSMITDATA) GetProcAddress(hxlDll,"xlMost150StreamTransmitData")) == NULL) NotFoundAll=171; + if ((xlMost150StreamClearTxFifo = (XLFP_MOST150STREAMCLEARTXFIFO) GetProcAddress(hxlDll,"xlMost150StreamClearTxFifo")) == NULL) NotFoundAll=172; + if ((xlMost150StreamGetInfo = (XLFP_MOST150STREAMGETINFO) GetProcAddress(hxlDll,"xlMost150StreamGetInfo")) == NULL) NotFoundAll=173; + if ((xlMost150StreamInitRxFifo = (XLFP_MOST150STREAMINITRXFIFO) GetProcAddress(hxlDll,"xlMost150StreamInitRxFifo")) == NULL) NotFoundAll=174; + if ((xlMost150StreamReceiveData = (XLFP_MOST150STREAMRECEIVEDATA) GetProcAddress(hxlDll,"xlMost150StreamReceiveData")) == NULL) NotFoundAll=175; + if ((xlMost150GenerateBypassStress = (XLFP_MOST150GENERATEBYPASSSTRESS) GetProcAddress(hxlDll,"xlMost150GenerateBypassStress")) == NULL) NotFoundAll=176; + if ((xlMost150EclConfigureSeq = (XLFP_MOST150ECLCONFIGURESEQ) GetProcAddress(hxlDll,"xlMost150EclConfigureSeq")) == NULL) NotFoundAll=177; + if ((xlMost150EclGenerateSeq = (XLFP_MOST150ECLGENERATESEQ) GetProcAddress(hxlDll,"xlMost150EclGenerateSeq")) == NULL) NotFoundAll=178; + if ((xlMost150SetECLGlitchFilter = (XLFP_MOST150SETECLGLITCHFILTER) GetProcAddress(hxlDll,"xlMost150SetECLGlitchFilter")) == NULL) NotFoundAll=179; + if ((xlMost150SetSSOResult = (XLFP_MOST150SETSSORESULT) GetProcAddress(hxlDll,"xlMost150SetSSOResult")) == NULL) NotFoundAll=180; + if ((xlMost150GetSSOResult = (XLFP_MOST150GETSSORESULT) GetProcAddress(hxlDll,"xlMost150GetSSOResult")) == NULL) NotFoundAll=181; + + // CAN-FD specific functions + if ((xlCanFdSetConfiguration = (XLCANFDSETCONFIGURATION) GetProcAddress(hxlDll,"xlCanFdSetConfiguration")) == NULL) NotFoundAll=200; + if ((xlCanTransmitEx = (XLCANTRANSMITEX) GetProcAddress(hxlDll,"xlCanTransmitEx")) == NULL) NotFoundAll=201; + if ((xlCanReceive = (XLCANRECEIVE) GetProcAddress(hxlDll,"xlCanReceive")) == NULL) NotFoundAll=202; + if ((xlCanGetEventString = (XLCANGETEVENTSTRING) GetProcAddress(hxlDll,"xlCanGetEventString")) == NULL) NotFoundAll=203; + + // IO piggy specific functions + if ((xlIoSetTriggerMode = (XLIOSETTRIGGERMODE) GetProcAddress(hxlDll,"xlIoSetTriggerMode")) == NULL) NotFoundAll=250; + if ((xlIoSetDigitalOutput = (XLIOSETDIGITALOUTPUT) GetProcAddress(hxlDll,"xlIoSetDigitalOutput")) == NULL) NotFoundAll=251; + if ((xlIoConfigurePorts = (XLIOCONFIGUREPORTS) GetProcAddress(hxlDll,"xlIoConfigurePorts")) == NULL) NotFoundAll=252; + if ((xlIoSetDigInThreshold = (XLIOSETDIGINTHRESHOLD) GetProcAddress(hxlDll,"xlIoSetDigInThreshold")) == NULL) NotFoundAll=253; + if ((xlIoSetDigOutLevel = (XLIOSETDIGOUTLEVEL) GetProcAddress(hxlDll,"xlIoSetDigOutLevel")) == NULL) NotFoundAll=254; + if ((xlIoSetAnalogOutput = (XLIOSETANALOGOUTPUT) GetProcAddress(hxlDll,"xlIoSetAnalogOutput")) == NULL) NotFoundAll=255; + if ((xlIoStartSampling = (XLIOSTARTSAMPLING) GetProcAddress(hxlDll,"xlIoStartSampling")) == NULL) NotFoundAll=256; + + // Ethernet specific functions + if ((xlEthSetConfig = (XLFP_ETHSETCONFIG) GetProcAddress(hxlDll,"xlEthSetConfig")) == NULL) NotFoundAll=300; + if ((xlEthGetConfig = (XLFP_ETHGETCONFIG) GetProcAddress(hxlDll,"xlEthGetConfig")) == NULL) NotFoundAll=301; + if ((xlEthReceive = (XLFP_ETHRECEIVE) GetProcAddress(hxlDll,"xlEthReceive")) == NULL) NotFoundAll=302; + if ((xlEthSetBypass = (XLFP_ETHSETBYPASS) GetProcAddress(hxlDll,"xlEthSetBypass")) == NULL) NotFoundAll=303; + if ((xlEthTwinkleStatusLed = (XLFP_ETHTWINKLESTATUSLED) GetProcAddress(hxlDll,"xlEthTwinkleStatusLed")) == NULL) NotFoundAll=304; + if ((xlEthTransmit = (XLFP_ETHTRANSMIT) GetProcAddress(hxlDll,"xlEthTransmit")) == NULL) NotFoundAll=305; + + // Remove specifig functions + if ((xlGetRemoteDeviceInfo = (XLGETREMOTEDEVICEINFO) GetProcAddress(hxlDll,"xlGetRemoteDeviceInfo")) == NULL) NotFoundAll=400; + if ((xlReleaseRemoteDeviceInfo = (XLRELEASEREMOTEDEVICEINFO) GetProcAddress(hxlDll,"xlReleaseRemoteDeviceInfo")) == NULL) NotFoundAll=401; + if ((xlAddRemoteDevice = (XLADDREMOTEDEVICE) GetProcAddress(hxlDll,"xlAddRemoteDevice")) == NULL) NotFoundAll=402; + if ((xlRemoveRemoteDevice = (XLREMOVEREMOTEDEVICE) GetProcAddress(hxlDll,"xlRemoveRemoteDevice")) == NULL) NotFoundAll=403; + if ((xlUpdateRemoteDeviceInfo = (XLUPDATEREMOTEDEVICEINFO) GetProcAddress(hxlDll,"xlUpdateRemoteDeviceInfo")) == NULL) NotFoundAll=405; + if ((xlGetRemoteHwInfo = (XLGETREMOTEHWINFO) GetProcAddress(hxlDll,"xlGetRemoteHwInfo")) == NULL) NotFoundAll=406; + + // A429 specific functions + if ((xlA429Receive = (XLFP_A429RECEIVE)GetProcAddress(hxlDll,"xlA429Receive") )==NULL) NotFoundAll=500; + if ((xlA429SetChannelParams = (XLFP_A429SETCHANNELPARAMS)GetProcAddress(hxlDll,"xlA429SetChannelParams") )==NULL) NotFoundAll=501; + if ((xlA429Transmit = (XLFP_A429TRANSMIT)GetProcAddress(hxlDll,"xlA429Transmit") )==NULL) NotFoundAll=502; + + // Keyman license dongle specific functions + if ((xlGetKeymanBoxes = (XLFP_GETKEYMANBOXES)GetProcAddress(hxlDll,"xlGetKeymanBoxes") )==NULL) NotFoundAll=600; + if ((xlGetKeymanInfo = (XLFP_GETKEYMANINFO)GetProcAddress(hxlDll,"xlGetKeymanInfo") )==NULL) NotFoundAll=601; + + if (NotFoundAll) { + return XL_ERROR; + } + } + return XL_SUCCESS; +} + +//////////////////////////////////////////////////////////////////////////// + +//! canUnloadLibrary() + +//! Unload XL API DLL +//! +//////////////////////////////////////////////////////////////////////////// + +XLstatus xlUnloadLibrary(void){ + if (hxlDll) { + (void)FreeLibrary( hxlDll ); + hxlDll = 0; + } + return XL_SUCCESS; +} + +//////////////////////////////////////////////////////////////////////////// + +//! xlOpenDriver() + +//! Automatically loads DLL and then opens driver +//! +//////////////////////////////////////////////////////////////////////////// + +XLstatus xlOpenDriver(void){ + +#ifdef WIN64 + if (xlLoadLibrary("vxlapi64")!=XL_SUCCESS) return XL_ERR_CANNOT_OPEN_DRIVER; +#else + if (xlLoadLibrary("vxlapi")!=XL_SUCCESS) return XL_ERR_CANNOT_OPEN_DRIVER; +#endif + return xlDllOpenDriver(); +} + +//////////////////////////////////////////////////////////////////////////// + +//! xlCloseDriver() + +//! Automatically close DLL +//! +//////////////////////////////////////////////////////////////////////////// + +XLstatus xlCloseDriver(void){ + (void)xlDllCloseDriver(); + return xlUnloadLibrary(); +} + diff --git a/Host/Source/LibOpenBLT/port/windows/canif/vector/xldriver.c b/Host/Source/LibOpenBLT/port/windows/canif/vector/xldriver.c new file mode 100644 index 00000000..2f45f1b3 --- /dev/null +++ b/Host/Source/LibOpenBLT/port/windows/canif/vector/xldriver.c @@ -0,0 +1,862 @@ +/************************************************************************************//** +* \file xldriver.c +* \brief Vector XL driver interface source file. +* \ingroup XLDRIVER +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2019 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include /* for assertions */ +#include /* for standard integer types */ +#include /* for NULL declaration */ +#include /* for boolean type */ +#include /* for standard library */ +#include /* for string library */ +#include "candriver.h" /* Generic CAN driver module */ +#include "util.h" /* Utility module */ +#include "xldriver.h" /* Vector XL driver interface */ +#include /* for Windows API */ +#include /* for XL CAN driver library */ + +/**************************************************************************************** +* Macro definitions +****************************************************************************************/ +/** \brief Internal driver queue size in CAN events. */ +#define VECTOR_XL_RX_QUEUE_SIZE (4096u) + + +/*************************************************************************************** +* Function prototypes +****************************************************************************************/ +/* CAN interface functions. */ +static void VectorXlInit(tCanSettings const * settings); +static void VectorXlTerminate(void); +static bool VectorXlConnect(void); +static void VectorXlDisconnect(void); +static bool VectorXlTransmit(tCanMsg const * msg); +static bool VectorXlIsBusError(void); +static void VectorXlRegisterEvents(tCanEvents const * events); +/* Baudrate conversion utility function. */ +static uint32_t VectorXlConvertToRawBitrate(tCanBaudrate baudrate); +/* CAN event reception thread. */ +static DWORD WINAPI VectorXlReceptionThread(LPVOID pv); + + +/**************************************************************************************** +* Local constant declarations +****************************************************************************************/ +/** \brief CAN interface structure filled with Vector XL driver specifics. */ +static const tCanInterface pVectorXlInterface = +{ + VectorXlInit, + VectorXlTerminate, + VectorXlConnect, + VectorXlDisconnect, + VectorXlTransmit, + VectorXlIsBusError, + VectorXlRegisterEvents +}; + + +/**************************************************************************************** +* Local data declarations +****************************************************************************************/ +/** \brief The settings to use in this CAN interface. */ +static tCanSettings vectorXlSettings; + +/** \brief List with callback functions that this driver should use. */ +static tCanEvents * vectorXlEventsList; + +/** \brief Total number of event entries into the \ref vectorXlEventsList list. */ +static uint32_t vectorXlEventsEntries; + +/** \brief The handle to the CAN port needed for API functions. */ +static XLportHandle vectorXlPortHandle; + +/** \brief The mask for the configured CAN channel. */ +static XLaccess vectorXLChannelMask; + +/** \brief Boolean flag to track if the driver was opened or not. ***/ +static bool vectorXlDriverOpened; + +/** \brief Boolean flag to track if the port was opened or not. ***/ +static bool vectorXlPortOpened; + +/** \brief Boolean flag to track if the channel was activated or not. ***/ +static bool vectorXlChannelActivated; + +/** \brief Boolean flag to detect if a CAN bus error state was detected. ***/ +static bool vectorXlBusErrorDetected; + +/** \brief Handle for the event to terminate the reception thread. */ +static HANDLE vectorXlTerminateEvent; + +/** \brief Handle for a CAN related event. */ +static HANDLE vectorXlCanEvent; + +/** \brief Handle for the CAN reception thread. */ +static HANDLE vectorXlRxThreadHandle; + + +/***********************************************************************************//** +** \brief Obtains a pointer to the CAN interface structure, so that it can be linked +** to the generic CAN driver module. +** \return Pointer to CAN interface structure. +** +****************************************************************************************/ +tCanInterface const * VectorXlGetInterface(void) +{ + return &pVectorXlInterface; +} /*** end of VectorXlGetInterface ***/ + + +/************************************************************************************//** +** \brief Initializes the CAN interface. +** \param settings Pointer to the CAN interface settings. +** +****************************************************************************************/ +static void VectorXlInit(tCanSettings const * settings) +{ + char * canDeviceName; + XLstatus xlStatus = XL_ERROR; + + /* Initialize locals. */ + vectorXlEventsList = NULL; + vectorXlEventsEntries = 0; + vectorXlPortHandle = XL_INVALID_PORTHANDLE; + vectorXLChannelMask = 0; + vectorXlDriverOpened = false; + vectorXlPortOpened = false; + vectorXlChannelActivated = false; + vectorXlBusErrorDetected = false; + vectorXlTerminateEvent = NULL; + vectorXlCanEvent = NULL; + vectorXlRxThreadHandle = NULL; + + /* This module uses critical sections so initialize them. */ + UtilCriticalSectionInit(); + + /* Reset CAN interface settings. */ + vectorXlSettings.devicename = ""; + vectorXlSettings.channel = 0; + vectorXlSettings.baudrate = CAN_BR500K; + vectorXlSettings.code = 0x00000000u; + vectorXlSettings.mask = 0x00000000u; + + /* Check parameters. */ + assert(settings != NULL); + + /* Only continue with valid parameters. */ + if (settings != NULL) /*lint !e774 */ + { + /* Shallow copy the CAN interface settings for later usage. */ + vectorXlSettings = *settings; + /* The devicename is a pointer and it is not gauranteed that it stays valid so we need + * to deep copy this one. note the +1 for '\0' in malloc. + */ + assert(settings->devicename != NULL); + if (settings->devicename != NULL) /*lint !e774 */ + { + canDeviceName = malloc(strlen(settings->devicename) + 1); + assert(canDeviceName != NULL); + if (canDeviceName != NULL) /*lint !e774 */ + { + strcpy(canDeviceName, settings->devicename); + vectorXlSettings.devicename = canDeviceName; + } + } + + /* Open the XL driver and dynamically load its functions. */ + xlStatus = xlOpenDriver(); + /* Assert that the driver was opened. If it could not be opened, that means that + * either the XL driver was not installed on the system (vxlapi.dll/vxlapi64.dll) + * or in incompatible vection is installed. Either way the user needs to be + * informed that something is not properly configured on the PC system. + */ + assert(xlStatus == XL_SUCCESS); + /* Update flag to determine if the driver should be closed at a later point. */ + if (xlStatus == XL_SUCCESS) + { + vectorXlDriverOpened = true; + } + } +} /*** end of VectorXlInit ***/ + + +/************************************************************************************//** +** \brief Terminates the CAN interface. +** +****************************************************************************************/ +static void VectorXlTerminate(void) +{ + /* Close the XL driver if necessary. */ + if (vectorXlDriverOpened) + { + (void)xlCloseDriver(); + vectorXlDriverOpened = false; + } + + /* Release memory that was allocated for storing the device name. */ + if (vectorXlSettings.devicename != NULL) + { + free((char *)vectorXlSettings.devicename); + } + /* Reset CAN interface settings. */ + vectorXlSettings.devicename = ""; + vectorXlSettings.channel = 0; + vectorXlSettings.baudrate = CAN_BR500K; + vectorXlSettings.code = 0x00000000u; + vectorXlSettings.mask = 0x00000000u; + /* Release memory that was allocated for CAN events and reset the entry count. */ + if ( (vectorXlEventsList != NULL) && (vectorXlEventsEntries != 0) ) + { + free(vectorXlEventsList); + vectorXlEventsEntries = 0; + } + /* This module used critical sections so terminate them. */ + UtilCriticalSectionTerminate(); +} /*** end of VectorXlTerminate ***/ + + +/************************************************************************************//** +** \brief Connects the CAN interface. +** \return True if connected, false otherwise. +** +****************************************************************************************/ +static bool VectorXlConnect(void) +{ + bool result = true; + XLstatus xlStatus; + XLdriverConfig xlDrvConfig; + char xlAppName[XL_MAX_LENGTH + 1] = ""; + XLaccess xlPermissionMask = 0; + uint32_t xlBitrate; + + /* Invalidate handles. */ + vectorXlTerminateEvent = NULL; + vectorXlCanEvent = NULL; + vectorXlRxThreadHandle = NULL; + /* Reset the bus error detected flag. */ + vectorXlBusErrorDetected = false; + + /* Obtain the hardware configuration. */ + xlStatus = xlGetDriverConfig(&xlDrvConfig); + /* Evaluate the result. */ + if (xlStatus != XL_SUCCESS) + { + result = false; + } + + /* Check if the requested channel is actually available. */ + if (result) + { + if (vectorXlSettings.channel >= xlDrvConfig.channelCount) + { + result = false; + } + else + { + /* Does the requested channel actually support CAN? */ + if ((xlDrvConfig.channel[vectorXlSettings.channel].channelBusCapabilities & + XL_BUS_ACTIVE_CAP_CAN) == 0) + { + result = false; + } + } + } + + /* Open the port. */ + if (result) + { + /* Invalidate the port handle and reset the port opened flag. */ + vectorXlPortHandle = XL_INVALID_PORTHANDLE; + vectorXlPortOpened = false; + /* Initialize the access and permission masks. */ + vectorXLChannelMask = xlDrvConfig.channel[vectorXlSettings.channel].channelMask; + xlPermissionMask = vectorXLChannelMask; + /* Attempt to open the port. */ + xlStatus = xlOpenPort(&vectorXlPortHandle, xlAppName, vectorXLChannelMask, + &xlPermissionMask, VECTOR_XL_RX_QUEUE_SIZE, + XL_INTERFACE_VERSION, XL_BUS_TYPE_CAN); + /* Evaluate the result. */ + if ((xlStatus != XL_SUCCESS) || (vectorXlPortHandle == XL_INVALID_PORTHANDLE)) + { + result = false; + } + else + { + /* Update flag to determine if the port should be closed at a later point. */ + vectorXlPortOpened = true; + } + } + + /* Configure the baudrate if initialization access is available. Otherwise skip this + * part, assuming that whomever does have this access already configured the correct + * baudrate. + */ + if (result) + { + if (vectorXLChannelMask == xlPermissionMask) + { + /* Determine the requested bitrate in bits/second. */ + xlBitrate = VectorXlConvertToRawBitrate(vectorXlSettings.baudrate); + /* Attempt to configure the communication speed. */ + xlStatus = xlCanSetChannelBitrate(vectorXlPortHandle, vectorXLChannelMask, + xlBitrate); + /* Evaluate the result. */ + if (xlStatus != XL_SUCCESS) + { + result = false; + } + } + } + + /* Configure normal output mode. */ + if (result) + { + xlStatus = xlCanSetChannelOutput(vectorXlPortHandle, vectorXLChannelMask, + XL_OUTPUT_MODE_NORMAL); + /* Evaluate the result. */ + if (xlStatus != XL_SUCCESS) + { + result = false; + } + } + + /* Suppress error frame reception and allow chipstate info events. */ + if (result) + { + xlStatus = xlCanSetReceiveMode(vectorXlPortHandle, 1, 0); + /* Evaluate the result. */ + if (xlStatus != XL_SUCCESS) + { + result = false; + } + } + + /* Create the terminate event handle used in the reception thread. */ + if (result) + { + vectorXlTerminateEvent = CreateEvent(NULL, TRUE, FALSE, ""); + if (vectorXlTerminateEvent == NULL) + { + result = false; + } + } + + /* Obtain handle for notification events. */ + if (result) + { + xlStatus = xlSetNotification(vectorXlPortHandle, &vectorXlCanEvent, 1); + /* Evaluate the result. */ + if (xlStatus != XL_SUCCESS) + { + result = false; + } + } + + /* Configure the acceptance mask. */ + if (result) + { + /* Use bit logic to determine if the filter should accept standard 11-bit and/or + * extended 29-bit identifiers: + * acceptStdId = ((mask & code & CAN_MSG_EXT_ID_MASK) == 0) + * acceptExtId = ((mask & code & CAN_MSG_EXT_ID_MASK) != 0) || + * ((mask & CAN_MSG_EXT_ID_MASK) == 0) + */ + bool acceptStdID = ((vectorXlSettings.mask & vectorXlSettings.code & CAN_MSG_EXT_ID_MASK) == 0); + bool acceptExtID = ((vectorXlSettings.mask & vectorXlSettings.code & CAN_MSG_EXT_ID_MASK) != 0) || + ((vectorXlSettings.mask & CAN_MSG_EXT_ID_MASK) == 0); + + /* Start by closing the acceptance filters for all 11-bit and 29-bit identifiers. */ + (void)xlCanSetChannelAcceptance(vectorXlPortHandle, vectorXLChannelMask, + 0x00000fffu, 0x00000fffu, XL_CAN_STD); + (void)xlCanSetChannelAcceptance(vectorXlPortHandle, vectorXLChannelMask, + 0xffffffffu, 0xffffffffu, XL_CAN_EXT); + + /* Configure acceptance filter for standard 11-bit identifiers. */ + if (acceptStdID) + { + xlStatus = xlCanSetChannelAcceptance(vectorXlPortHandle, vectorXLChannelMask, + vectorXlSettings.code & 0x1fffffffu, + vectorXlSettings.mask & 0x1fffffffu, + XL_CAN_STD); + /* Evaluate the result. */ + if (xlStatus != XL_SUCCESS) + { + result = false; + } + } + /* Configure acceptance filter for extended 29-bit identifiers. */ + if ((acceptExtID) && (result)) + { + xlStatus = xlCanSetChannelAcceptance(vectorXlPortHandle, vectorXLChannelMask, + vectorXlSettings.code & 0x1fffffffu, + vectorXlSettings.mask & 0x1fffffffu, + XL_CAN_EXT); + /* Evaluate the result. */ + if (xlStatus != XL_SUCCESS) + { + result = false; + } + } + } + + /* Activate the channel. */ + if (result) + { + /* Reset the channel activated flag. */ + vectorXlChannelActivated = false; + /* Attempt to activate the channel. */ + xlStatus = xlActivateChannel(vectorXlPortHandle, vectorXLChannelMask, + XL_BUS_TYPE_CAN, XL_ACTIVATE_RESET_CLOCK); + /* Evaluate the result. */ + if (xlStatus != XL_SUCCESS) + { + result = false; + } + else + { + /* Update the channel activated flag. */ + vectorXlChannelActivated = true; + } + } + + /* Start the reception thread. */ + if (result) + { + vectorXlRxThreadHandle = CreateThread(NULL, 0, VectorXlReceptionThread, + NULL, 0, NULL); + if (vectorXlRxThreadHandle == NULL) + { + result = false; + } + } + + /* Cleanup in case this function was not successful. */ + if (!result) + { + /* Deactivate the channel if it was activated. */ + if (vectorXlChannelActivated) + { + (void)xlDeactivateChannel(vectorXlPortHandle, vectorXLChannelMask); + vectorXlChannelActivated = false; + } + /* Invalidate the notification event if it was set. */ + if (vectorXlCanEvent != NULL) + { + vectorXlCanEvent = NULL; + } + /* Close the termination event handle if it was created. */ + if (vectorXlTerminateEvent != NULL) + { + /* Close the event handle. */ + (void)CloseHandle(vectorXlTerminateEvent); + vectorXlTerminateEvent = NULL; + } + /* Close the port if it was opened. */ + if (vectorXlPortOpened) + { + (void)xlClosePort(vectorXlPortHandle); + vectorXlPortOpened = false; + } + } + + /* Give the result back to the caller. */ + return result; +} /*** end of VectorXlConnect ***/ + + +/************************************************************************************//** +** \brief Disconnects the CAN interface. +** +****************************************************************************************/ +static void VectorXlDisconnect(void) +{ + /* Stop the reception thread. */ + if (vectorXlRxThreadHandle != NULL) + { + /* Trigger event to request the reception thread to stop. */ + (void)SetEvent(vectorXlTerminateEvent); + /* Wait for the thread to signal termination. */ + (void)WaitForSingleObject(vectorXlRxThreadHandle, INFINITE); + /* Close the thread handle. */ + (void)CloseHandle(vectorXlRxThreadHandle); + vectorXlRxThreadHandle = NULL; + } + + /* Close the termination event handle if it was created. */ + if (vectorXlTerminateEvent != NULL) + { + /* Close the event handle. */ + (void)CloseHandle(vectorXlTerminateEvent); + vectorXlTerminateEvent = NULL; + } + /* Invalidate the notification event if it was set. */ + if (vectorXlCanEvent != NULL) + { + vectorXlCanEvent = NULL; + } + /* Deactivate the channel if necessary. */ + if (vectorXlChannelActivated) + { + (void)xlDeactivateChannel(vectorXlPortHandle, vectorXLChannelMask); + vectorXlChannelActivated = false; + } + + /* Close the XL port if necessary. */ + if (vectorXlPortOpened) + { + (void)xlClosePort(vectorXlPortHandle); + vectorXlPortOpened = false; + } +} /*** end of VectorXlDisconnect ***/ + + +/************************************************************************************//** +** \brief Submits a message for transmission on the CAN bus. +** \param msg Pointer to CAN message structure. +** \return True if successful, false otherwise. +** +****************************************************************************************/ +static bool VectorXlTransmit(tCanMsg const * msg) +{ + bool result = false; + tCanEvents const * pEvents; + XLstatus xlStatus = XL_ERROR; + XLevent xlEvent[1]; + unsigned int txMsgCount = 1; + uint8_t byteIdx; + + /* Check parameters. */ + assert(msg != NULL); + + /* Only continue with valid parameters. */ + if (msg != NULL) /*lint !e774 */ + { + /* Convert the CAN message to the XLevent format. */ + memset(xlEvent, 0, sizeof(xlEvent)); + xlEvent[0].tag = XL_TRANSMIT_MSG; + xlEvent[0].tagData.msg.flags = 0; + if ((msg->id & CAN_MSG_EXT_ID_MASK) == 0) + { + xlEvent[0].tagData.msg.id = msg->id & 0x7ffu; + } + else + { + xlEvent[0].tagData.msg.id = msg->id & 0x1fffffffu; + xlEvent[0].tagData.msg.id |= XL_CAN_EXT_MSG_ID; + } + xlEvent[0].tagData.msg.dlc = msg->dlc; + if (xlEvent[0].tagData.msg.dlc > CAN_MSG_MAX_LEN) + { + xlEvent[0].tagData.msg.dlc = CAN_MSG_MAX_LEN; + } + for (byteIdx = 0; byteIdx < msg->dlc; byteIdx++) + { + xlEvent[0].tagData.msg.data[byteIdx] = msg->data[byteIdx]; + } + + /* Attempt to submit the message for transmission. */ + xlStatus = xlCanTransmit(vectorXlPortHandle, vectorXLChannelMask, &txMsgCount, + xlEvent); + /* Check the result. */ + if (xlStatus == XL_SUCCESS) + { + /* Update result value to success. */ + result = true; + /* Trigger transmit complete event(s). */ + pEvents = vectorXlEventsList; + for (uint32_t idx = 0; idx < vectorXlEventsEntries; idx++) + { + if (pEvents != NULL) + { + if (pEvents->MsgTxed != NULL) + { + pEvents->MsgTxed(msg); + } + /* Move on to the next entry in the list. */ + pEvents++; + } + } + } + } + /* Give the result back to the caller. */ + return result; +} /*** end of VectorXlTransmit ***/ + + +/************************************************************************************//** +** \brief Checks if a bus off or bus heavy situation occurred. +** \return True if a bus error situation was detected, false otherwise. +** +****************************************************************************************/ +static bool VectorXlIsBusError(void) +{ + bool result = false; + + /* To obtain the bus off and error passive state info, a chip state message must + * be requested, which is then received and processed by the reception thread. + */ + (void)xlCanRequestChipState(vectorXlPortHandle, vectorXLChannelMask); + + /* Enter critical section. */ + UtilCriticalSectionEnter(); + + /* Was a bus error chip state detected by the reception thread? */ + if (vectorXlBusErrorDetected) + { + /* Reset the flag to be able to detect the next bus error event. */ + vectorXlBusErrorDetected = false; + /* Update the result. */ + result = true; + } + + /* Exit critical section. */ + UtilCriticalSectionExit(); + + /* Give the result back to the caller. */ + return result; +} /*** end of VectorXlIsBusError ***/ + + +/************************************************************************************//** +** \brief Registers the event callback functions that should be called by the CAN +** interface. +** \param events Pointer to structure with event callback function pointers. +** +****************************************************************************************/ +static void VectorXlRegisterEvents(tCanEvents const * events) +{ + /* Check parameters. */ + assert(events != NULL); + + /* Only continue with valid parameters. */ + if (events != NULL) /*lint !e774 */ + { + /* Increase length of the list to make space for one more event entry. Note that + * it is okay to call realloc with a NULL pointer. In this case it simply behaves + * as malloc. + */ + vectorXlEventsList = realloc(vectorXlEventsList, + (sizeof(tCanEvents) * (vectorXlEventsEntries + 1))); + /* Assert reallocation. */ + assert(vectorXlEventsList != NULL); + /* Only continue if reallocation was successful. */ + if (vectorXlEventsList != NULL) + { + /* Increment events entry count. */ + vectorXlEventsEntries++; + /* Store the events in the new entry. */ + vectorXlEventsList[vectorXlEventsEntries - 1] = *events; + } + /* Reallocation failed. */ + else + { + /* Reset events entry count. */ + vectorXlEventsEntries = 0; + } + } +} /*** end of VectorXlRegisterEvents ***/ + + +/************************************************************************************//** +** \brief Converts the baudrate enumerated type value to a bitrate in bits/second. +** \param baudrate Baudrate enumarated type. +** \return Bitrate in bits/second. +** +****************************************************************************************/ +static uint32_t VectorXlConvertToRawBitrate(tCanBaudrate baudrate) +{ + uint32_t result = 500000; + + switch (baudrate) + { + case CAN_BR10K: + result = 10000; + break; + case CAN_BR20K: + result = 20000; + break; + case CAN_BR50K: + result = 50000; + break; + case CAN_BR100K: + result = 100000; + break; + case CAN_BR125K: + result = 125000; + break; + case CAN_BR250K: + result = 250000; + break; + case CAN_BR500K: + result = 500000; + break; + case CAN_BR800K: + result = 800000; + break; + case CAN_BR1M: + result = 1000000; + break; + default: + /* Default to a common used baudrate as a fallback. */ + result = 500000; + break; + } + /* Give the result back to the caller. */ + return result; +} /*** end of VectorXlConvertToRawBitrate ***/ + + +/************************************************************************************//** +** \brief CAN event reception thread. +** \param pv Pointer to thread parameters. +** \return Thread exit code. +** +****************************************************************************************/ +static DWORD WINAPI VectorXlReceptionThread(LPVOID pv) +{ + DWORD waitResult; + HANDLE handles[] = + { + vectorXlCanEvent, + vectorXlTerminateEvent + }; + bool running = true; + XLstatus xlStatus; + unsigned int xlEventCount; + XLevent xlEvent; + tCanMsg rxMsg; + uint8_t byteIdx; + tCanEvents const * pEvents; + + /* Parameter not used. */ + (void)pv; + + /* Enter thread's infinite loop. */ + while (running) + { + waitResult = WaitForMultipleObjects(sizeof(handles)/sizeof(handles[0]), handles, + FALSE, INFINITE); + switch (waitResult) + { + /* CAN reception event. */ + case WAIT_OBJECT_0 + 0: /*lint !e835 */ + /* Empty out the event queue. */ + xlStatus = XL_SUCCESS; + while (xlStatus == XL_SUCCESS) + { + /* Set the number of events to request to read. */ + xlEventCount = 1; + xlStatus = xlReceive(vectorXlPortHandle, &xlEventCount, &xlEvent); + if (xlStatus != XL_ERR_QUEUE_IS_EMPTY ) + { + /* Was is a message reception event? */ + if (xlEvent.tag == XL_RECEIVE_MSG) + { + /* Only process actual newly received messages and ignore things such as + * a confirmation of a message transmission. + */ + if (xlEvent.tagData.msg.flags == 0) + { + /* Read out the message identifier. */ + if ((xlEvent.tagData.msg.id & XL_CAN_EXT_MSG_ID) == 0) + { + rxMsg.id = xlEvent.tagData.msg.id & 0x7ffu; + } + else + { + rxMsg.id = xlEvent.tagData.msg.id & 0x1fffffffu; + rxMsg.id |= CAN_MSG_EXT_ID_MASK; + } + /* Read out the message length. */ + if (xlEvent.tagData.msg.dlc > CAN_MSG_MAX_LEN) + { + rxMsg.dlc = CAN_MSG_MAX_LEN; + } + else + { + rxMsg.dlc = (uint8_t)xlEvent.tagData.msg.dlc; + } + /* Read out the message data. */ + for (byteIdx = 0; byteIdx < rxMsg.dlc; byteIdx++) + { + rxMsg.data[byteIdx] = xlEvent.tagData.msg.data[byteIdx]; + } + /* Trigger message reception event(s). */ + pEvents = vectorXlEventsList; + for (uint32_t idx = 0; idx < vectorXlEventsEntries; idx++) + { + if (pEvents != NULL) + { + if (pEvents->MsgRxed != NULL) + { + pEvents->MsgRxed(&rxMsg); + } + /* Move on to the next entry in the list. */ + pEvents++; + } + } + } + } + /* Was is a chip state event? */ + else if (xlEvent.tag == XL_CHIP_STATE) + { + /* Is a bus off or bus have state reported? */ + if ( ((xlEvent.tagData.chipState.busStatus & XL_CHIPSTAT_BUSOFF) != 0) || + ((xlEvent.tagData.chipState.busStatus & XL_CHIPSTAT_ERROR_PASSIVE) != 0)) + { + /* Enter critical section. */ + UtilCriticalSectionEnter(); + /* Set bus error flag. Note that this flag is automatically reset by + * VectorXlIsBusError. + */ + vectorXlBusErrorDetected = true; + /* Exit critical section. */ + UtilCriticalSectionExit(); + } + } + } + } + break; + + /* Termination event. */ + default: + case WAIT_OBJECT_0 + 1: /*lint !e835 */ + /* Stop thread. */ + running = false; + break; + } + } + /* Exit thread. */ + return 0; + +} /*** end of VectorXlReceptionThread ***/ + + +/*********************************** end of xldriver.c *********************************/ + diff --git a/Host/Source/LibOpenBLT/port/windows/canif/vector/xldriver.h b/Host/Source/LibOpenBLT/port/windows/canif/vector/xldriver.h new file mode 100644 index 00000000..84283a90 --- /dev/null +++ b/Host/Source/LibOpenBLT/port/windows/canif/vector/xldriver.h @@ -0,0 +1,50 @@ +/************************************************************************************//** +* \file xldriver.h +* \brief Vector XL driver interface header file. +* \ingroup XLDRIVER +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2019 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ +/************************************************************************************//** +* \defgroup XLDRIVER Vector XL Driver USB to CAN interface +* \brief This module implements the CAN interface for the Vector XL Driver. +* \ingroup CanDriver +****************************************************************************************/ +#ifndef XLDRIVER_H +#define XLDRIVER_H + +#ifdef __cplusplus +extern "C" { +#endif + +/*************************************************************************************** +* Function prototypes +****************************************************************************************/ +tCanInterface const * VectorXlGetInterface(void); + +#ifdef __cplusplus +} +#endif + +#endif /* XLDRIVER_H */ +/*********************************** end of xldriver.h *********************************/ diff --git a/Host/Source/MicroBoot/MicroBoot.lps b/Host/Source/MicroBoot/MicroBoot.lps index c7597652..3e7a3424 100644 --- a/Host/Source/MicroBoot/MicroBoot.lps +++ b/Host/Source/MicroBoot/MicroBoot.lps @@ -19,8 +19,7 @@ - - + @@ -48,7 +47,7 @@ - + @@ -73,7 +72,7 @@ - + @@ -108,10 +107,13 @@ - + + + + @@ -153,7 +155,7 @@ - + diff --git a/Host/Source/MicroBoot/transportxcpcandialog.lfm b/Host/Source/MicroBoot/transportxcpcandialog.lfm index f579162c..97555323 100644 --- a/Host/Source/MicroBoot/transportxcpcandialog.lfm +++ b/Host/Source/MicroBoot/transportxcpcandialog.lfm @@ -8,12 +8,12 @@ object TransportXcpCanForm: TTransportXcpCanForm ClientWidth = 407 OnCreate = FormCreate OnDestroy = FormDestroy - LCLVersion = '1.6.2.0' + LCLVersion = '1.6.4.0' object LblCommunication: TLabel Left = 8 - Height = 17 + Height = 15 Top = 8 - Width = 96 + Width = 87 Caption = 'Communication' Font.Style = [fsBold] ParentColor = False @@ -21,15 +21,16 @@ object TransportXcpCanForm: TTransportXcpCanForm end object CmbDevice: TComboBox Left = 120 - Height = 31 + Height = 23 Hint = 'Name of the CAN adapter' Top = 35 Width = 224 - ItemHeight = 0 + ItemHeight = 15 Items.Strings = ( 'Peak System PCAN-USB' 'Kvaser Leaf Light v2' 'Lawicel CANUSB' + 'Vector XL Driver' ) ParentShowHint = False ShowHint = True @@ -38,19 +39,19 @@ object TransportXcpCanForm: TTransportXcpCanForm end object LblDevice: TLabel Left = 24 - Height = 17 + Height = 15 Top = 38 - Width = 41 + Width = 38 Caption = 'Device:' ParentColor = False end object CmbChannel: TComboBox Left = 120 - Height = 31 + Height = 23 Hint = 'Zero based index of the CAN channel, if multiple CAN channels are supported for the CAN adapter' Top = 75 Width = 224 - ItemHeight = 0 + ItemHeight = 15 Items.Strings = ( '0' '1' @@ -76,19 +77,19 @@ object TransportXcpCanForm: TTransportXcpCanForm end object LblChannel: TLabel Left = 24 - Height = 17 + Height = 15 Top = 78 - Width = 49 + Width = 47 Caption = 'Channel:' ParentColor = False end object CmbBaudrate: TComboBox Left = 120 - Height = 31 + Height = 23 Hint = 'The communication speed in bits per second' Top = 115 Width = 224 - ItemHeight = 0 + ItemHeight = 15 Items.Strings = ( '1 MBit/sec' '800 kBit/sec' @@ -107,17 +108,17 @@ object TransportXcpCanForm: TTransportXcpCanForm end object LblBaudrate: TLabel Left = 24 - Height = 17 + Height = 15 Top = 118 - Width = 55 + Width = 50 Caption = 'Baudrate:' ParentColor = False end object LblIdentifiers: TLabel Left = 8 - Height = 17 + Height = 15 Top = 160 - Width = 63 + Width = 58 Caption = 'Identifiers' Font.Style = [fsBold] ParentColor = False @@ -125,7 +126,7 @@ object TransportXcpCanForm: TTransportXcpCanForm end object EdtTransmitId: TEdit Left = 120 - Height = 29 + Height = 23 Hint = 'CAN identifier for transmitting XCP command messages from the host to the target, as a 32-bit hexadecimal value (Default = 667h)' Top = 187 Width = 224 @@ -138,15 +139,15 @@ object TransportXcpCanForm: TTransportXcpCanForm end object LblTransmitId: TLabel Left = 24 - Height = 17 + Height = 15 Top = 190 - Width = 84 + Width = 78 Caption = 'Transmit (hex):' ParentColor = False end object EdtReceiveId: TEdit Left = 120 - Height = 29 + Height = 23 Hint = 'CAN identifier for receiving XCP response messages from the target to the host, as a 32-bit hexadecimal value (Default = 7E1h)' Top = 227 Width = 224 @@ -159,18 +160,18 @@ object TransportXcpCanForm: TTransportXcpCanForm end object LblReceiveId: TLabel Left = 24 - Height = 17 + Height = 15 Top = 230 - Width = 77 + Width = 72 Caption = 'Receive (hex):' ParentColor = False end object CbxExtended: TCheckBox Left = 120 - Height = 23 + Height = 19 Hint = 'Check if the CAN identifiers are 29-bit extended (Default = 11-bit standard)' Top = 267 - Width = 200 + Width = 185 Caption = '29-bit extended CAN identifiers' OnChange = CbxExtendedChange ParentShowHint = False diff --git a/Host/Source/MicroBoot/transportxcpcandialog.pas b/Host/Source/MicroBoot/transportxcpcandialog.pas index cb089c8c..67729872 100644 --- a/Host/Source/MicroBoot/transportxcpcandialog.pas +++ b/Host/Source/MicroBoot/transportxcpcandialog.pas @@ -218,7 +218,9 @@ begin if FTransportXcpCanConfig.Device = 'kvaser_leaflight' then CmbDevice.ItemIndex := 1 else if FTransportXcpCanConfig.Device = 'lawicel_canusb' then - CmbDevice.ItemIndex := 2; + CmbDevice.ItemIndex := 2 + else if FTransportXcpCanConfig.Device = 'vector_xldriver' then + CmbDevice.ItemIndex := 3; {$ENDIF} CmbChannel.ItemIndex := 0; if FTransportXcpCanConfig.Channel <= LongWord(CmbChannel.Items.Count) then @@ -266,7 +268,9 @@ begin if CmbDevice.ItemIndex = 1 then FTransportXcpCanConfig.Device := 'kvaser_leaflight' else if CmbDevice.ItemIndex = 2 then - FTransportXcpCanConfig.Device := 'lawicel_canusb'; + FTransportXcpCanConfig.Device := 'lawicel_canusb' + else if CmbDevice.ItemIndex = 3 then + FTransportXcpCanConfig.Device := 'vector_xldriver'; {$ENDIF} FTransportXcpCanConfig.Channel := CmbChannel.ItemIndex; case CmbBaudrate.ItemIndex of diff --git a/Host/libopenblt.dll b/Host/libopenblt.dll index 1a5877d1512d8abe511abcf89e41459c14d837f2..09ad4b996f155d5298439021d0a0a4348139d1c0 100644 GIT binary patch literal 193536 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 delta 42215 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