summaryrefslogtreecommitdiffstats
path: root/Src/VodXml.cpp
diff options
context:
space:
mode:
authorChristian Gromm <christian.gromm@microchip.com>2016-12-08 13:51:04 +0100
committerChristian Gromm <christian.gromm@microchip.com>2016-12-08 13:51:04 +0100
commit8c5f2324d7aa61669324aec1a0ad091fe1379489 (patch)
tree29cbdcdbe3657e1400d596ec3d560a2573d80817 /Src/VodXml.cpp
parente89ba11bd9111f02a940f227cf979f1947e975ac (diff)
src: unicens: import sources
This patch adds the source tree of the NetworkManager v3.0.4. Additionally, it provides the needed configuration scripts. Change-Id: I23778b51423b51a4f87741957e0fb208bceb79b3 Signed-off-by: Christian Gromm <christian.gromm@microchip.com>
Diffstat (limited to 'Src/VodXml.cpp')
-rw-r--r--Src/VodXml.cpp1112
1 files changed, 1112 insertions, 0 deletions
diff --git a/Src/VodXml.cpp b/Src/VodXml.cpp
new file mode 100644
index 0000000..edf27c5
--- /dev/null
+++ b/Src/VodXml.cpp
@@ -0,0 +1,1112 @@
+/*
+ * Video On Demand Samples
+ *
+ * Copyright (C) 2015 Microchip Technology Germany II GmbH & Co. KG
+ *
+ * This program 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.
+ *
+ * This program 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 should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You may also obtain this software under a propriety license from Microchip.
+ * Please contact Microchip for further information.
+ *
+ */
+
+#include "SafeVector.h"
+#include "Console.h"
+#include "VodXml.h"
+
+#define TAG_ADDRESS ((xmlChar *)"channel_addr")
+#define TAG_ADDRESS_HEX ((xmlChar *)"channel_addr_hex")
+#define TAG_ASYNC_BANDWIDTH ((xmlChar *)"async_bandwidth")
+#define TAG_BLOCKWIDTH ((xmlChar *)"blockwidth")
+#define TAG_OFFSET ((xmlChar *)"offset")
+#define TAG_BUFFER_SIZE ((xmlChar *)"buffer_size")
+#define TAG_CHANNEL ((xmlChar *)"channel")
+#define TAG_CHANNEL_ID ((xmlChar *)"channel_id")
+#define TAG_DATA_TYPE ((xmlChar *)"data_type")
+#define TAG_AIM_TYPE ((xmlChar *)"aim_type")
+#define TAG_DEVICE ((xmlChar *)"device")
+#define TAG_DEVICE_API_VERSION ((xmlChar *)"device_api_ver")
+#define TAG_DEVICE_MLB_SPEED ((xmlChar *)"open_mlb_port_speed")
+#define TAG_DEVICE_TYPE ((xmlChar *)"device_type")
+#define TAG_DEVICE_TYPE_HEX ((xmlChar *)"device_type_hex")
+#define TAG_DIR ((xmlChar *)"dir")
+#define TAG_ENDPOINT ((xmlChar *)"endpoint")
+#define TAG_TSI_PORT_ID ((xmlChar *)"tsi_port_id")
+#define TAG_TSI_PORT_MODE ((xmlChar *)"tsi_port_mode")
+#define TAG_I2S_V1_CLKDRIVEMODE ((xmlChar *)"i2s_v1_clock_drive_mode")
+#define TAG_I2S_V1_OPTION ((xmlChar *)"i2s_v1_option")
+#define TAG_I2S_V1_DATAFORMAT ((xmlChar *)"i2s_v1_data_format")
+#define TAG_I2S_V1_PIN ((xmlChar *)"i2s_v1_pin")
+#define TAG_I2S_OPTION ((xmlChar *)"i2s_option")
+#define TAG_I2S_CLOCK_DIR ((xmlChar *)"i2s_clock_dir")
+#define TAG_I2S_CLOCK_DELAY ((xmlChar *)"i2s_clock_delay")
+#define TAG_I2S_FS_SPEED ((xmlChar *)"i2s_fs_speed")
+#define TAG_I2S_ALIGN ((xmlChar *)"i2s_align")
+#define TAG_I2S_PIN ((xmlChar *)"i2s_pin")
+#define TAG_INSTANCE ((xmlChar *)"instance")
+#define TAG_LOCAL_CONNECTION ((xmlChar *)"local_connection")
+#define TAG_NETWORK_CONFIG ((xmlChar *)"network_config")
+#define TAG_NETWORK_MANAGER ((xmlChar *)"network_manager")
+#define TAG_NUMBER_OF_BUFFERS ((xmlChar *)"number_of_buffers")
+#define TAG_PACKETS_XACT ((xmlChar *)"packets_per_xact")
+#define TAG_PACKETS_XACT_HEX ((xmlChar *)"packets_per_xact_hex")
+#define TAG_PORT_ID ((xmlChar *)"port_id")
+#define TAG_ROUTE ((xmlChar *)"route")
+#define TAG_SCRIPT ((xmlChar *)"script")
+#define TAG_SOCKET ((xmlChar *)"socket")
+#define TAG_SUBBUFFER_SIZE ((xmlChar *)"subbuffer_size")
+#define TAG_TERMINAL ((xmlChar *)"terminal")
+#define TAG_TIMING_MASTER ((xmlChar *)"timing_master")
+
+#define VAL_AIM_TYPE_CDEV ((char*)"CDEV")
+#define VAL_AIM_TYPE_AUDIO ((char*)"AUDIO")
+#define VAL_AIM_TYPE_V4L ((char*)"V4L")
+
+#define VAL_PORT_MLB ((char*)"MLB")
+#define VAL_PORT_TSI ((char*)"TSI")
+#define VAL_PORT_I2S ((char*)"I2S")
+#define VAL_PORT_I2C ((char*)"I2C")
+#define VAL_PORT_USB ((char*)"USB")
+#define VAL_PORT_PCIE ((char*)"PCIE")
+#define VAL_PORT_MOST ((char*)"MOST")
+
+#define VAL_DATATYPE_SYNC ((char*)"SYNC")
+#define VAL_DATATYPE_ISOC ((char*)"ISOC")
+#define VAL_DATATYPE_ASYNC ((char*)"ASYNC")
+#define VAL_DATATYPE_CTRL ((char*)"CTRL")
+
+#define VAL_DIR_IN ((char*)"IN")
+#define VAL_DIR_OUT ((char*)"OUT")
+
+#define VAL_TSI_V1_PORT_0 ((char*)"TSI_PORT0")
+#define VAL_TSI_V1_PORT_1 ((char*)"TSI_PORT1")
+
+#define VAL_TSI_V1_SLAVE ((char*)"TSI_SLAVE")
+#define VAL_TSI_V1_MASTER ((char*)"TSI_MASTER")
+
+#define VAL_I2S_V1_CLK_OUTPUT ((char*)"Output")
+#define VAL_I2S_V1_CLK_INPUT ((char*)"Input")
+#define VAL_I2S_V1_CLK_ISOCOUT ((char*)"IsocOutput")
+#define VAL_I2S_V1_CLK_ISOCIN ((char*)"IsocInput")
+
+#define VAL_I2S_V1_OPTION_INOUT ((char*)"InOut")
+#define VAL_I2S_V1_OPTION_DUALIN ((char*)"DualIn")
+#define VAL_I2S_V1_OPTION_DUALOUT ((char*)"DualOut")
+#define VAL_I2S_V1_OPTION_FULL ((char*)"FullStream")
+#define VAL_I2S_V1_OPTION_WILDCARD ((char*)"Wildcard")
+
+#define VAL_I2S_V1_FMT_D64Fs16 ((char*)"Delay64Fs16Bit")
+#define VAL_I2S_V1_FMT_D64Fs24 ((char*)"Delay64Fs24Bit")
+#define VAL_I2S_V1_FMT_D64FsSeq ((char*)"Delay64FsSeq")
+#define VAL_I2S_V1_FMT_D128FsSeq ((char*)"Delay128FsSeq")
+#define VAL_I2S_V1_FMT_D256FsSeq ((char*)"Delay256FsSeq")
+#define VAL_I2S_V1_FMT_R64Fs16 ((char*)"Right64Fs16Bit")
+#define VAL_I2S_V1_FMT_R64Fs24 ((char*)"Right64Fs24Bit")
+#define VAL_I2S_V1_FMT_Seq64Fs ((char*)"Seq64Fs")
+#define VAL_I2S_V1_FMT_Seq128Fs ((char*)"Seq128Fs")
+#define VAL_I2S_V1_FMT_Seq256Fs ((char*)"Seq256Fs")
+#define VAL_I2S_V1_FMT_L64Fs16 ((char*)"Left64Fs16Bit")
+#define VAL_I2S_V1_FMT_L64Fs24 ((char*)"Left64Fs24Bit")
+#define VAL_I2S_V1_FMT_D512FsSeq ((char*)"Delay512FsSeq")
+#define VAL_I2S_V1_FMT_Seq512Fs ((char*)"Seq512Fs")
+
+#define VAL_I2S_V1_PIN_SR0 ((char*)"SR0Pin")
+#define VAL_I2S_V1_PIN_SX0 ((char*)"SX0Pin")
+#define VAL_I2S_V1_PIN_SR1 ((char*)"SR1Pin")
+#define VAL_I2S_V1_PIN_SX1 ((char*)"SX1Pin")
+#define VAL_I2S_V1_PIN_SR2 ((char*)"SR2Pin")
+#define VAL_I2S_V1_PIN_SX2 ((char*)"SX2Pin")
+#define VAL_I2S_V1_PIN_SR3 ((char*)"SR3Pin")
+#define VAL_I2S_V1_PIN_SX3 ((char*)"SX3Pin")
+#define VAL_I2S_V1_PIN_FSY_SCK ((char*)"FSY_SCK_Pins")
+
+#define VAL_I2S_OPTION_INOUT ((char*)"InOut")
+#define VAL_I2S_OPTION_DUALIN ((char*)"DualIn")
+#define VAL_I2S_OPTION_DUALOUT ((char*)"DualOut")
+#define VAL_I2S_OPTION_WILDCARD ((char*)"Wildcard")
+
+#define VAL_I2S_CLOCK_OUTPUT ((char*)"Output")
+#define VAL_I2S_CLOCK_INPUT ((char*)"Input")
+#define VAL_I2S_CLOCK_WILDCARD ((char*)"Wildcard")
+
+#define VAL_I2S_ALIGNMENT_L16 ((char*)"Left16")
+#define VAL_I2S_ALIGNMENT_L24 ((char*)"Left24")
+#define VAL_I2S_ALIGNMENT_R16 ((char*)"Right16")
+#define VAL_I2S_ALIGNMENT_R24 ((char*)"Right24")
+#define VAL_I2S_SEQUENTIAL ((char*)"Seq")
+
+#define VAL_I2S_PIN_SRXA0 ((char*)"SRXA0")
+#define VAL_I2S_PIN_SRXA1 ((char*)"SRXA1")
+#define VAL_I2S_PIN_SRXB0 ((char*)"SRXB0")
+#define VAL_I2S_PIN_SRXB1 ((char*)"SRXB1")
+
+#define UNKNOWN_ENDPOINT_ADDR 0xFF
+
+#define XML_STRCMP(x,y) (strcmp(reinterpret_cast< const char* >(x), reinterpret_cast< const char* >(y)) == 0)
+
+CVodXml::CVodXml( const char *szFile ) : CXml( szFile )
+{
+
+}
+
+bool CVodXml::GetLocalInicConfigurations( uint8_t *rxEndpoint, uint8_t *txEndpoint )
+{
+ if( NULL == rxEndpoint || NULL == txEndpoint )
+ return false;
+ *rxEndpoint = UNKNOWN_ENDPOINT_ADDR;
+ *txEndpoint = UNKNOWN_ENDPOINT_ADDR;
+ CXml rootXml( *( ( CXml * )this ) );
+ bool success = rootXml.SetToTopNode();
+ if( success && rootXml.FindNode( TAG_NETWORK_MANAGER ) )
+ {
+ CXml xmlNWM( rootXml );
+ success = xmlNWM.FindFirstChildNode();
+ while( success && xmlNWM.FindNode( TAG_ENDPOINT ) )
+ {
+ ConsolePrintf( PRIO_LOW, "NETWORK_MANAGER\r\n" );
+ xmlChar interface[XML_DEFAULT_VALUE_LEN];
+ if( xmlNWM.GetChildValue( TAG_PORT_ID, interface ) )
+ {
+ if( XML_STRCMP(interface, VAL_PORT_I2C) )
+ {
+ ConsolePrintf( PRIO_LOW,
+ "GetLocalInicConfigurations found I2C, returning without channel addresses\r\n" );
+ return true;
+ }
+ }
+ xmlChar dataType[XML_DEFAULT_VALUE_LEN];
+ xmlChar direction[XML_DEFAULT_VALUE_LEN];
+ dataType[0] = '\0';
+ direction[0] = '\0';
+ int epAddress;
+ success &= xmlNWM.GetChildValue( TAG_DATA_TYPE, dataType );
+ ConsolePrintf( PRIO_LOW, " Type:%s\r\n", dataType );
+ success &= xmlNWM.GetChildValue( TAG_DIR, direction );
+ ConsolePrintf( PRIO_LOW, " Direction:%s\r\n", direction );
+ if( !xmlNWM.GetChildValueInt( TAG_ADDRESS, epAddress ) )
+ {
+ xmlChar szTmp[XML_DEFAULT_VALUE_LEN];
+ if( xmlNWM.GetChildValue( TAG_ADDRESS_HEX, szTmp, XML_DEFAULT_VALUE_LEN ) )
+ epAddress = ConvertToInt( szTmp );
+ }
+ ConsolePrintf( PRIO_LOW, " Address:%d\r\n", epAddress );
+
+ if( success )
+ {
+ if( XML_STRCMP(dataType, VAL_DATATYPE_CTRL) )
+ {
+ if( XML_STRCMP(direction, VAL_DIR_IN) )
+ {
+ *rxEndpoint = epAddress;
+ }
+ else if( XML_STRCMP(direction, VAL_DIR_OUT) )
+ {
+ *txEndpoint = epAddress;
+ }
+ }
+ }
+ else
+ {
+ ConsolePrintf( PRIO_ERROR, "Failed to retrieve Endpoint config\n" );
+ }
+ xmlNWM.FindNextNode();
+ }
+ }
+ return success && ( 0xFF != *rxEndpoint ) && ( 0xFF != *txEndpoint );
+}
+
+bool CVodXml::GetMostParameters(bool *isTimingMaster, uint32_t *asyncBandwidth)
+{
+ if( NULL == isTimingMaster || NULL == asyncBandwidth )
+ {
+ ConsolePrintf( PRIO_ERROR, RED"GetMostParameters was"\
+ " called with wrong parameters"RESETCOLOR"\n" );
+ return false;
+ }
+ uint8_t serverNum = 0;
+ CXml xmlNWM( *( ( CXml * )this ) );
+ bool success = xmlNWM.SetToTopNode();
+ if( success && xmlNWM.FindNode( TAG_NETWORK_MANAGER ) )
+ {
+ success = xmlNWM.FindFirstChildNode();
+ while( success && xmlNWM.FindNode( TAG_LOCAL_CONNECTION ) )
+ {
+ serverNum += 1;
+ xmlNWM.FindNextNode();
+ }
+ }
+ //Be compatible to old XML API
+ if( !success || 0 == serverNum )
+ {
+ success = GetNetworkConfiguration( isTimingMaster, asyncBandwidth );
+ return success;
+ }
+
+ if( success )
+ success = xmlNWM.SetToTopNode();
+ if( success )
+ success = xmlNWM.FindNode( TAG_NETWORK_MANAGER );
+ if( success )
+ success = xmlNWM.FindFirstChildNode();
+
+ if( success && xmlNWM.FindNode( TAG_LOCAL_CONNECTION ) )
+ {
+ CXml xmlLC( xmlNWM );
+ int bw;
+ int tm = true;
+ success &= xmlNWM.GetChildValueInt( TAG_TIMING_MASTER, tm );
+ if (success)
+ {
+ ConsolePrintf( PRIO_LOW, " Timing Master:%d\r\n", tm );
+ success &= xmlNWM.GetChildValueInt( TAG_ASYNC_BANDWIDTH, bw );
+ if (success)
+ {
+ *isTimingMaster = tm;
+ *asyncBandwidth = bw;
+ ConsolePrintf( PRIO_LOW, "Asynchronous Bandwidth:%d\r\n", bw );
+ }
+ }
+ }
+ return success;
+}
+
+bool CVodXml::GetLocalInicConfigurations( uint8_t *rxEndpoint[], uint8_t *txEndpoint[], uint32_t *apiVersion[],
+ SocketPort_t *hwPort[], bool *isTimingMaster[], uint32_t *asyncBandwidth[], uint8_t *serverNum )
+{
+ if( NULL == rxEndpoint || NULL == txEndpoint || NULL == serverNum ||
+ NULL == apiVersion || NULL == hwPort || NULL == isTimingMaster ||
+ NULL == asyncBandwidth )
+ {
+ ConsolePrintf( PRIO_ERROR, RED"GetLocalInicConfigurations was"\
+ " called with wrong parameters"RESETCOLOR"\n" );
+ return false;
+ }
+ *rxEndpoint = NULL;
+ *txEndpoint = NULL;
+ *apiVersion = NULL;
+ *hwPort = NULL;
+ *isTimingMaster = NULL;
+ *asyncBandwidth = NULL;
+ *serverNum = 0;
+ CXml xmlNWM( *( ( CXml * )this ) );
+ bool success = xmlNWM.SetToTopNode();
+ if( success && xmlNWM.FindNode( TAG_NETWORK_MANAGER ) )
+ {
+ success = xmlNWM.FindFirstChildNode();
+ while( success && xmlNWM.FindNode( TAG_LOCAL_CONNECTION ) )
+ {
+ *serverNum = *serverNum + 1;
+ xmlNWM.FindNextNode();
+ }
+ }
+ //Be compatible to old XML API
+ if( !success || 0 == *serverNum )
+ {
+ uint8_t rxEP;
+ uint8_t txEP;
+ bool tm;
+ uint32_t bw;
+ success = GetLocalInicConfigurations( &rxEP, &txEP );
+ if( success )
+ success = GetNetworkConfiguration( &tm, &bw );
+
+ if( success )
+ {
+ *rxEndpoint = ( uint8_t * )calloc( 1, sizeof( uint8_t ) );
+ *txEndpoint = ( uint8_t * )calloc( 1, sizeof( uint8_t ) );
+ *apiVersion = ( uint32_t * )calloc( 1, sizeof( uint32_t ) );
+ *hwPort = ( SocketPort_t * )calloc( 1, sizeof( SocketPort_t ) );
+ *isTimingMaster = ( bool * )calloc( 1, sizeof( bool ) );
+ *asyncBandwidth = ( uint32_t * )calloc( 1, sizeof( uint32_t ) );
+ ( *rxEndpoint )[0] = rxEP;
+ ( *txEndpoint )[0] = txEP;
+ ( *apiVersion )[0] = GetServerDeviceApi();
+ ( *hwPort )[0] = GetServerHardwareInterface();
+ ( *isTimingMaster )[0] = tm;
+ ( *asyncBandwidth )[0] = bw;
+ *serverNum = 1;
+ }
+ return success;
+ }
+ //New method to get multiple instances of local configurations
+ *rxEndpoint = ( uint8_t * )calloc( *serverNum, sizeof( uint8_t ) );
+ *txEndpoint = ( uint8_t * )calloc( *serverNum, sizeof( uint8_t ) );
+ *apiVersion = ( uint32_t * )calloc( *serverNum, sizeof( uint32_t ) );
+ *hwPort = ( SocketPort_t * )calloc( *serverNum, sizeof( SocketPort_t ) );
+ *isTimingMaster = ( bool * )calloc( *serverNum, sizeof( bool ) );
+ *asyncBandwidth = ( uint32_t * )calloc( *serverNum, sizeof( uint32_t ) );
+
+ if( success )
+ success = xmlNWM.SetToTopNode();
+ if( success )
+ success = xmlNWM.FindNode( TAG_NETWORK_MANAGER );
+ if( success )
+ success = xmlNWM.FindFirstChildNode();
+
+ uint8_t currentCon = 0;
+ while( success && xmlNWM.FindNode( TAG_LOCAL_CONNECTION ) && currentCon < *serverNum )
+ {
+ int apiVer = -1;
+ CXml xmlLC( xmlNWM );
+ if( xmlLC.GetChildValueInt( TAG_DEVICE_API_VERSION, apiVer ) )
+ {
+ ( *apiVersion )[currentCon] = ( uint32_t )apiVer;
+ ConsolePrintf( PRIO_LOW, "[Con:%d] API Version: %d\r\n", currentCon, apiVer );
+ }
+ ( *hwPort )[currentCon] = PORT_UNKNOWN;
+ xmlChar interface[XML_DEFAULT_VALUE_LEN];
+ if( xmlLC.GetChildValue( TAG_PORT_ID, interface ) )
+ {
+ ConsolePrintf( PRIO_LOW, "[Con:%d] HW Type: %s\r\n", currentCon, interface );
+
+ if( XML_STRCMP(interface, VAL_PORT_MLB) )
+ ( *hwPort )[currentCon] = PORT_MLB;
+ else if( XML_STRCMP(interface, VAL_PORT_TSI) )
+ ( *hwPort )[currentCon] = PORT_TSI;
+ else if( XML_STRCMP(interface, VAL_PORT_USB) )
+ ( *hwPort )[currentCon] = PORT_USB;
+ else if( XML_STRCMP(interface, VAL_PORT_I2C) )
+ ( *hwPort )[currentCon] = PORT_I2C;
+ }
+ int isMaster = true;
+ int bw = 40;
+ success &= xmlNWM.GetChildValueInt( TAG_TIMING_MASTER, isMaster );
+ ConsolePrintf( PRIO_LOW, "[Con:%d] Timing Master:%d\r\n", currentCon, isMaster );
+ success &= xmlNWM.GetChildValueInt( TAG_ASYNC_BANDWIDTH, bw );
+ ConsolePrintf( PRIO_LOW, "[Con:%d] Asynchronous Bandwidth:%d\r\n", currentCon, bw );
+ ( *isTimingMaster )[currentCon] = isMaster;
+ ( *asyncBandwidth )[currentCon] = bw;
+ success = xmlLC.FindFirstChildNode();
+ while( success && xmlLC.FindNode( TAG_ENDPOINT ) )
+ {
+ xmlChar dataType[XML_DEFAULT_VALUE_LEN];
+ xmlChar direction[XML_DEFAULT_VALUE_LEN];
+ dataType[0] = '\0';
+ direction[0] = '\0';
+ int epAddress;
+ success &= xmlLC.GetChildValue( TAG_DATA_TYPE, dataType );
+ ConsolePrintf( PRIO_LOW, "[Con:%d] Type:%s\r\n", currentCon, dataType );
+ success &= xmlLC.GetChildValue( TAG_DIR, direction );
+ ConsolePrintf( PRIO_LOW, "[Con:%d] Direction:%s\r\n", currentCon, direction );
+ if( !xmlLC.GetChildValueInt( TAG_ADDRESS, epAddress ) )
+ {
+ xmlChar szTmp[XML_DEFAULT_VALUE_LEN];
+ if( xmlLC.GetChildValue( TAG_ADDRESS_HEX, szTmp, XML_DEFAULT_VALUE_LEN ) )
+ epAddress = ConvertToInt( szTmp );
+ }
+ ConsolePrintf( PRIO_LOW, "[Con:%d] Address:%d\r\n", currentCon, epAddress );
+
+ if( success )
+ {
+ if( XML_STRCMP(dataType, VAL_DATATYPE_CTRL) )
+ {
+ if( XML_STRCMP(direction, VAL_DIR_IN) )
+ {
+ ( *rxEndpoint )[currentCon] = epAddress;
+ }
+ else if( XML_STRCMP(direction, VAL_DIR_OUT) )
+ {
+ ( *txEndpoint )[currentCon] = epAddress;
+ }
+ }
+ }
+ else
+ {
+ ConsolePrintf( PRIO_ERROR, "Failed to retrieve Endpoint config\n" );
+ }
+ xmlLC.FindNextNode();
+ }
+ currentCon++;
+ xmlNWM.FindNextNode();
+ }
+ return success;
+}
+
+SocketPort_t CVodXml::GetServerHardwareInterface()
+{
+ //Be compatible to old configurations, which had no interface declaration
+ SocketPort_t hwInterface = PORT_USB;
+ CXml rootXml( *( ( CXml * )this ) );
+ bool success = rootXml.SetToTopNode();
+ if( success && rootXml.FindNode( TAG_NETWORK_MANAGER ) )
+ {
+ CXml xmlNWM( rootXml );
+ success = xmlNWM.FindFirstChildNode();
+ if( success && xmlNWM.FindNode( TAG_ENDPOINT ) )
+ {
+ xmlChar interface[XML_DEFAULT_VALUE_LEN];
+
+ if( xmlNWM.GetChildValue( TAG_PORT_ID, interface ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - Port ID : %s\r\n", interface );
+ if( XML_STRCMP(interface, VAL_PORT_MLB) )
+ hwInterface = PORT_MLB;
+ else if( XML_STRCMP(interface, VAL_PORT_USB) )
+ hwInterface = PORT_USB;
+ else if( XML_STRCMP(interface, VAL_PORT_I2C) )
+ hwInterface = PORT_I2C;
+ }
+ }
+ }
+ return hwInterface;
+}
+
+uint32_t CVodXml::GetServerDeviceApi()
+{
+ //Be compatible to old configurations, which had no API declaration
+ uint32_t deviceApi = 2;
+ CXml rootXml( *( ( CXml * )this ) );
+ bool success = rootXml.SetToTopNode();
+ if( success && rootXml.FindNode( TAG_NETWORK_MANAGER ) )
+ {
+ CXml xmlNWM( rootXml );
+ success = xmlNWM.FindFirstChildNode();
+ if( success && xmlNWM.FindNode( TAG_ENDPOINT ) )
+ {
+ ConsolePrintf( PRIO_LOW, "NETWORK_MANAGER\r\n" );
+ int apiVer;
+ if( xmlNWM.GetChildValueInt( TAG_DEVICE_API_VERSION, apiVer ) )
+ {
+ deviceApi = apiVer;
+ ConsolePrintf( PRIO_LOW, " - Device API Version: %d\r\n", apiVer );
+ }
+ }
+ }
+ return deviceApi;
+}
+
+uint32_t CVodXml::GetDeviceApi( uint32_t deviceType )
+{
+ uint32_t deviceApi = 0xFFFFFFFF;
+ bool success = true;
+ CXml Xml( *( ( CXml * )this ) );
+ success = Xml.SetToTopNode();
+ success &= Xml.FindNode( TAG_NETWORK_MANAGER );
+ success &= Xml.FindFirstChildNode();
+
+ while( success && Xml.FindNode( TAG_DEVICE ) )
+ {
+ int xmlDeviceType = -1;
+ int xmlDeviceApiVer = -1;
+ if( !Xml.GetChildValueInt( TAG_DEVICE_TYPE, xmlDeviceType ) )
+ {
+ xmlChar szTmp[XML_DEFAULT_VALUE_LEN];
+ if( Xml.GetChildValue( TAG_DEVICE_TYPE_HEX, szTmp, XML_DEFAULT_VALUE_LEN ) )
+ xmlDeviceType = ConvertToInt( szTmp );
+ }
+ if( ( uint32_t )xmlDeviceType == deviceType )
+ {
+ success &= Xml.GetChildValueInt( TAG_DEVICE_API_VERSION, xmlDeviceApiVer );
+ if( success )
+ {
+ ConsolePrintf( PRIO_LOW, "Device API Version %d for device type: 0x%X\r\n", xmlDeviceApiVer,
+ xmlDeviceType );
+ deviceApi = xmlDeviceApiVer;
+ break;
+ }
+ }
+ Xml.FindNextNode();
+ }
+ return deviceApi;
+}
+
+MlbPortSpeed_t CVodXml::GetDeviceMlbPortSpeed( uint32_t deviceType )
+{
+ MlbPortSpeed_t mlbSpeed = MlbSpeedNotSet;
+ bool success = true;
+ CXml Xml( *( ( CXml * )this ) );
+ success = Xml.SetToTopNode();
+ success &= Xml.FindNode( TAG_NETWORK_MANAGER );
+ success &= Xml.FindFirstChildNode();
+
+ while( success && Xml.FindNode( TAG_DEVICE ) )
+ {
+ int xmlDeviceType;
+ int xmlDeviceMlbPortSpeed = -1;
+ if( !Xml.GetChildValueInt( TAG_DEVICE_TYPE, xmlDeviceType ) )
+ {
+ xmlChar szTmp[XML_DEFAULT_VALUE_LEN];
+ if( Xml.GetChildValue( TAG_DEVICE_TYPE_HEX, szTmp, XML_DEFAULT_VALUE_LEN ) )
+ xmlDeviceType = ConvertToInt( szTmp );
+ }
+ ConsolePrintf( PRIO_LOW, "DeviceType: %d\r\n", xmlDeviceType );
+ if( ( uint32_t )xmlDeviceType == deviceType )
+ {
+ success &= Xml.GetChildValueInt( TAG_DEVICE_MLB_SPEED, xmlDeviceMlbPortSpeed );
+ if( success )
+ {
+ ConsolePrintf( PRIO_LOW, "Device MLB speed %d for device type: 0x%X\r\n", xmlDeviceMlbPortSpeed,
+ xmlDeviceType );
+ switch( xmlDeviceMlbPortSpeed )
+ {
+ case 256:
+ mlbSpeed = MlbSpeed256FS;
+ break;
+ case 512:
+ mlbSpeed = MlbSpeed512FS;
+ break;
+ case 1024:
+ mlbSpeed = MlbSpeed1024FS;
+ break;
+ case 2048:
+ mlbSpeed = MlbSpeed2048FS;
+ break;
+ case 3072:
+ mlbSpeed = MlbSpeed3072FS;
+ break;
+ case 4096:
+ mlbSpeed = MlbSpeed4096FS;
+ break;
+ case 6144:
+ mlbSpeed = MlbSpeed6144FS;
+ break;
+ case 8192:
+ mlbSpeed = MlbSpeed8192FS;
+ break;
+ default:
+ mlbSpeed = MlbSpeedNotSet;
+ break;
+ }
+ break;
+ }
+ }
+ Xml.FindNextNode();
+ }
+ return mlbSpeed;
+}
+
+bool CVodXml::GetNetworkConfiguration( bool *isTimingMaster, uint32_t *asyncBandwidth )
+{
+ if( NULL == isTimingMaster || NULL == asyncBandwidth )
+ return false;
+ *isTimingMaster = true;
+ *asyncBandwidth = 40;
+ CXml rootXml( *( ( CXml * )this ) );
+ bool success = rootXml.SetToTopNode();
+ if( success && rootXml.FindNode( TAG_NETWORK_MANAGER ) )
+ {
+ CXml xmlNWM( rootXml );
+ success = xmlNWM.FindFirstChildNode();
+ while( success && xmlNWM.FindNode( TAG_NETWORK_CONFIG ) )
+ {
+ ConsolePrintf( PRIO_LOW, "NETWORK_MANAGER\r\n" );
+ int isMaster;
+ int bw;
+ success &= xmlNWM.GetChildValueInt( TAG_TIMING_MASTER, isMaster );
+ ConsolePrintf( PRIO_LOW, " Is Timing Master:%d\r\n", isMaster );
+ success &= xmlNWM.GetChildValueInt( TAG_ASYNC_BANDWIDTH, bw );
+ ConsolePrintf( PRIO_LOW, " Asynchronous Bandwidth:%d\r\n", bw );
+ if( success )
+ {
+ *isTimingMaster = isMaster;
+ *asyncBandwidth = bw;
+ break;
+ }
+ else
+ {
+ ConsolePrintf( PRIO_ERROR, "Failed to retrieve Network config\n" );
+ }
+ xmlNWM.FindNextNode();
+ }
+ }
+ return success;
+}
+
+
+bool CVodXml::GetChannelConfigurations( uint32_t deviceType, CSafeVector<CChannelConfiguration *> &allChannels )
+{
+ bool success = false;
+ bool found = false;
+ CXml Xml( *( ( CXml * )this ) );
+ success = Xml.SetToTopNode();
+ success &= Xml.FindNode( TAG_NETWORK_MANAGER );
+ success &= Xml.FindFirstChildNode();
+
+ while( !found && Xml.FindNode( TAG_DEVICE ) )
+ {
+ int xmlDeviceType = -1;
+ char *externalScript = NULL;
+ xmlChar szTmp[XML_DEFAULT_VALUE_LEN];
+ if( !Xml.GetChildValueInt( TAG_DEVICE_TYPE, xmlDeviceType ) )
+ {
+ xmlChar szTmp[XML_DEFAULT_VALUE_LEN];
+ if( Xml.GetChildValue( TAG_DEVICE_TYPE_HEX, szTmp, XML_DEFAULT_VALUE_LEN ) )
+ xmlDeviceType = ConvertToInt( szTmp );
+ }
+ if( ( uint32_t )xmlDeviceType != deviceType )
+ {
+ Xml.FindNextNode();
+ continue;
+ }
+ ConsolePrintf( PRIO_LOW, "DeviceType: %d (0x%X)\r\n", xmlDeviceType, xmlDeviceType );
+ szTmp[0] = '\0';
+ if( Xml.GetChildValue( TAG_SCRIPT, szTmp ) )
+ {
+ int scriptLen = xmlStrlen( szTmp );
+ externalScript = ( char * )malloc( scriptLen + 1 );
+ if( NULL != externalScript )
+ {
+ memcpy( externalScript, szTmp, scriptLen );
+ externalScript[scriptLen] = '\0';
+ }
+ ConsolePrintf( PRIO_LOW, "External script:'%s'\r\n", externalScript );
+ }
+ found = true;
+ CXml Channel( Xml );
+ success = Channel.FindFirstChildNode();
+
+ while( success && Channel.FindNode( TAG_CHANNEL ) )
+ {
+ int channelId;
+ success &= Channel.GetChildValueInt( TAG_CHANNEL_ID, channelId );
+ if( success )
+ {
+ ConsolePrintf( PRIO_LOW, " Channel: %u\r\n", channelId );
+ CChannelConfiguration *channelConfig = new CChannelConfiguration();
+ allChannels.PushBack( channelConfig );
+ channelConfig->deviceType = xmlDeviceType;
+ channelConfig->channelId = channelId;
+ channelConfig->externalScipt = externalScript;
+ CXml Socket( Channel );
+ success = Socket.FindFirstChildNode();
+ while( Socket.FindNode( TAG_SOCKET ) )
+ {
+ ConsolePrintf( PRIO_LOW, " Socket:\r\n" );
+ int nTmp;
+ CSocketConfiguration *sockConfig = NULL;
+ szTmp[0] = '\0';
+ if( Socket.GetChildValue( TAG_DIR, szTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - Direction : %s\r\n", szTmp );
+ if( XML_STRCMP(szTmp, VAL_DIR_IN) )
+ sockConfig = &channelConfig->inSocket;
+ else if( XML_STRCMP(szTmp, VAL_DIR_OUT) )
+ sockConfig = &channelConfig->outSocket;
+ }
+ if( NULL == sockConfig )
+ {
+ ConsolePrintf( PRIO_ERROR, RED"VodXml can not detect socket direction"RESETCOLOR"\n" );
+ return false; //unknown target socket
+ }
+
+ szTmp[0] = '\0';
+ if( Socket.GetChildValue( TAG_PORT_ID, szTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - Port ID : %s\r\n", szTmp );
+ if( XML_STRCMP(szTmp, VAL_PORT_MLB) )
+ sockConfig->port = PORT_MLB;
+ else if( XML_STRCMP(szTmp, VAL_PORT_TSI) )
+ sockConfig->port = PORT_TSI;
+ else if( XML_STRCMP(szTmp, VAL_PORT_I2S) )
+ sockConfig->port = PORT_I2S;
+ else if( XML_STRCMP(szTmp, VAL_PORT_USB) )
+ sockConfig->port = PORT_USB;
+ else if( XML_STRCMP(szTmp, VAL_PORT_PCIE) )
+ sockConfig->port = PORT_PCIE;
+ else if( XML_STRCMP(szTmp, VAL_PORT_MOST) )
+ sockConfig->port = PORT_MOST;
+ else
+ sockConfig->port = PORT_UNKNOWN;
+ }
+
+ szTmp[0] = '\0';
+ if( Socket.GetChildValue( TAG_DATA_TYPE, szTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - Data Type : %s\r\n", szTmp );
+ if( XML_STRCMP(szTmp, VAL_DATATYPE_SYNC) )
+ sockConfig->type = EP_Synchron;
+ else if( XML_STRCMP(szTmp, VAL_DATATYPE_ISOC) )
+ sockConfig->type = EP_Isochron;
+ else if( XML_STRCMP(szTmp, VAL_DATATYPE_ASYNC) )
+ sockConfig->type = EP_Asynchron;
+ else if( XML_STRCMP(szTmp, VAL_DATATYPE_CTRL) )
+ sockConfig->type = EP_Control;
+ else
+ sockConfig->type = EP_Unknown;
+ }
+
+ if( Socket.GetChildValueInt( TAG_OFFSET, nTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - Splitted Offset: %d\r\n", nTmp );
+ sockConfig->splittedOffset = nTmp;
+ }
+
+ if( Socket.GetChildValueInt( TAG_BLOCKWIDTH, nTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - Blockwidth: %d\r\n", nTmp );
+ sockConfig->blockWidth = nTmp;
+ }
+
+ if( Socket.GetChildValueInt( TAG_ADDRESS, nTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - Channel Address: 0x%X\r\n", nTmp );
+ sockConfig->address = nTmp;
+ }
+ else if( Socket.GetChildValue( TAG_ADDRESS_HEX, szTmp, XML_DEFAULT_VALUE_LEN ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - Channel Address (hex): 0x%X\r\n", nTmp );
+ sockConfig->address = ConvertToInt( szTmp );
+ }
+
+ if( Socket.GetChildValueInt( TAG_NUMBER_OF_BUFFERS, nTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - Number of Buffers: %d\r\n", nTmp );
+ sockConfig->amountOfBuffers = nTmp;
+ }
+
+ if( Socket.GetChildValueInt( TAG_BUFFER_SIZE, nTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - Buffer Size: %d\r\n", nTmp );
+ sockConfig->bufferSize = nTmp;
+ }
+
+ if( Socket.GetChildValueInt( TAG_PACKETS_XACT, nTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - Packets per Transaction: %d\r\n", nTmp );
+ sockConfig->packetsPerTransaction = nTmp;
+ }
+ else
+ {
+ if( Socket.GetChildValue( TAG_PACKETS_XACT_HEX, szTmp, XML_DEFAULT_VALUE_LEN ) )
+ {
+ sockConfig->packetsPerTransaction = ConvertToInt( szTmp );
+ ConsolePrintf( PRIO_LOW, " - Packets per Transaction: 0x%X\r\n", sockConfig->packetsPerTransaction );
+ }
+ }
+
+ if( Socket.GetChildValueInt( TAG_SUBBUFFER_SIZE, nTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - Subbuffer Size: %d\r\n", nTmp );
+ sockConfig->subbufferSize = nTmp;
+ }
+
+ if( Socket.GetChildValue( TAG_AIM_TYPE, szTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - TAG_AIM_TYPE : %s\r\n", szTmp );
+ if( XML_STRCMP(szTmp, VAL_AIM_TYPE_CDEV) )
+ sockConfig->aimType = AIM_CDEV;
+ else if( XML_STRCMP(szTmp, VAL_AIM_TYPE_AUDIO) )
+ sockConfig->aimType = AIM_AUDIO;
+ else if( XML_STRCMP(szTmp, VAL_AIM_TYPE_V4L) )
+ sockConfig->aimType = AIM_V4L;
+ else
+ sockConfig->aimType = AIM_UNKNOWN;
+ }
+
+ if( PORT_TSI == sockConfig->port )
+ {
+ if( Socket.GetChildValue( TAG_TSI_PORT_ID, szTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - TSI Port ID : %s\r\n", szTmp );
+ if( XML_STRCMP(szTmp, VAL_TSI_V1_PORT_0) )
+ sockConfig->tsiConfig.tsiPortInstance = V1TsiPortInstance0;
+ else if( XML_STRCMP(szTmp, VAL_TSI_V1_PORT_1) )
+ sockConfig->tsiConfig.tsiPortInstance = V1TsiPortInstance1;
+ }
+ if( Socket.GetChildValue( TAG_TSI_PORT_MODE, szTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - TSI Port Mode : %s\r\n", szTmp );
+ if( XML_STRCMP(szTmp, VAL_TSI_V1_SLAVE) )
+ sockConfig->tsiConfig.tsiPortMode = V1TsiPortModeSlave;
+ else if( XML_STRCMP(szTmp, VAL_TSI_V1_MASTER) )
+ sockConfig->tsiConfig.tsiPortMode = V1TsiPortModeMaster;
+ }
+ }
+ else if( PORT_I2S == sockConfig->port )
+ {
+ sockConfig->i2sConfig.portClkDriveModeV1 = V1I2sClockModeUnknown;
+ sockConfig->i2sConfig.portOptionV1 = V1I2sStreamingPortWildcard; //Be backward compatible
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sDataFormatUnknown;
+ sockConfig->i2sConfig.pinV1 = V1I2sInvalidPin;
+ sockConfig->i2sConfig.portOption = V3I2SOptionUnknown;
+ sockConfig->i2sConfig.clockMode = V3I2SClockModeUnknown;
+ sockConfig->i2sConfig.delayMode = V3I2SDelayUnknown;
+ sockConfig->i2sConfig.portSpeed = V3I2SSpeedUnknown;
+ sockConfig->i2sConfig.alignment = V3I2SAlignUnknown;
+ sockConfig->i2sConfig.pin = V3I2SInvalidPin;
+ szTmp[0] = '\0';
+ if( Socket.GetChildValue( TAG_I2S_V1_CLKDRIVEMODE, szTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - I2S V1 clock drive mode : %s\r\n", szTmp );
+ if( XML_STRCMP(szTmp, VAL_I2S_V1_CLK_OUTPUT) )
+ sockConfig->i2sConfig.portClkDriveModeV1 = V1I2sClockModeOutput;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_CLK_INPUT) )
+ sockConfig->i2sConfig.portClkDriveModeV1 = V1I2sClockModeInput;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_CLK_ISOCOUT) )
+ sockConfig->i2sConfig.portClkDriveModeV1 = V1I2sClockModeIsocOutput;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_CLK_ISOCIN) )
+ sockConfig->i2sConfig.portClkDriveModeV1 = V1I2sClockModeIsocInput;
+ }
+
+ if( Socket.GetChildValue( TAG_I2S_V1_OPTION, szTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - I2S V1 port option : %s\r\n", szTmp );
+ if( XML_STRCMP(szTmp, VAL_I2S_V1_OPTION_INOUT ) )
+ sockConfig->i2sConfig.portOptionV1 = V1I2sStreamingPortInOut;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_OPTION_DUALIN ) )
+ sockConfig->i2sConfig.portOptionV1 = V1I2sStreamingPortDualIn;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_OPTION_DUALOUT ) )
+ sockConfig->i2sConfig.portOptionV1 = V1I2sStreamingPortDualOut;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_OPTION_FULL ) )
+ sockConfig->i2sConfig.portOptionV1 = V1I2sStreamingPortFullStream;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_OPTION_WILDCARD ) )
+ sockConfig->i2sConfig.portOptionV1 = V1I2sStreamingPortWildcard;
+ }
+
+ szTmp[0] = '\0';
+ if( Socket.GetChildValue( TAG_I2S_V1_DATAFORMAT, szTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - I2S V1 data format : %s\r\n", szTmp );
+ if( XML_STRCMP(szTmp, VAL_I2S_V1_FMT_D64Fs16) )
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sDelay64Fs16Bit;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_FMT_D64Fs24) )
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sDelay64Fs24Bit;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_FMT_D64FsSeq) )
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sDelay64FsSeq;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_FMT_D128FsSeq) )
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sDelay128FsSeq;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_FMT_D256FsSeq) )
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sDelay256FsSeq;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_FMT_R64Fs16) )
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sRight64Fs16Bit;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_FMT_R64Fs24) )
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sRight64Fs24Bit;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_FMT_Seq64Fs) )
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sSeq64Fs;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_FMT_Seq128Fs) )
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sSeq128Fs;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_FMT_Seq256Fs) )
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sSeq256Fs;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_FMT_L64Fs16) )
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sLeft64Fs16Bit;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_FMT_L64Fs24) )
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sLeft64Fs24Bit;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_FMT_D512FsSeq) )
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sDelay512FsSeq;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_FMT_Seq512Fs) )
+ sockConfig->i2sConfig.streamingDataFormatV1 = V1I2sSeq512Fs;
+ }
+
+ szTmp[0] = '\0';
+ if( Socket.GetChildValue( TAG_I2S_V1_PIN, szTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - I2S V1 pin : %s\r\n", szTmp );
+ if( XML_STRCMP(szTmp, VAL_I2S_V1_PIN_SR0) )
+ sockConfig->i2sConfig.pinV1 = V1I2sSR0Pin;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_PIN_SX0) )
+ sockConfig->i2sConfig.pinV1 = V1I2sSX0Pin;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_PIN_SR1) )
+ sockConfig->i2sConfig.pinV1 = V1I2sSR1Pin;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_PIN_SX1) )
+ sockConfig->i2sConfig.pinV1 = V1I2sSX1Pin;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_PIN_SR2) )
+ sockConfig->i2sConfig.pinV1 = V1I2sSR2Pin;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_PIN_SX2) )
+ sockConfig->i2sConfig.pinV1 = V1I2sSX2Pin;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_PIN_SR3) )
+ sockConfig->i2sConfig.pinV1 = V1I2sSR3Pin;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_PIN_SX3) )
+ sockConfig->i2sConfig.pinV1 = V1I2sSX3Pin;
+ else if( XML_STRCMP(szTmp, VAL_I2S_V1_PIN_FSY_SCK) )
+ sockConfig->i2sConfig.pinV1 = V1I2sFSYSCKPins;
+ }
+
+
+ szTmp[0] = '\0';
+ if( Socket.GetChildValue( TAG_I2S_OPTION, szTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - I2S OPTION : %s\r\n", szTmp );
+ if( XML_STRCMP(szTmp, VAL_I2S_OPTION_INOUT) )
+ sockConfig->i2sConfig.portOption = V3I2SOptionInOut;
+ else if( XML_STRCMP(szTmp, VAL_I2S_OPTION_DUALIN) )
+ sockConfig->i2sConfig.portOption = V3I2SOptionDualIn;
+ else if( XML_STRCMP(szTmp, VAL_I2S_OPTION_DUALOUT) )
+ sockConfig->i2sConfig.portOption = V3I2SOptionDualOut;
+ }
+
+ szTmp[0] = '\0';
+ if( Socket.GetChildValue( TAG_I2S_CLOCK_DIR, szTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - I2S clock direction : %s\r\n", szTmp );
+ if( XML_STRCMP(szTmp, VAL_I2S_CLOCK_OUTPUT) )
+ sockConfig->i2sConfig.clockMode = V3I2SClockModeOutput;
+ else if( XML_STRCMP(szTmp, VAL_I2S_CLOCK_INPUT) )
+ sockConfig->i2sConfig.clockMode = V3I2SClockModeInput;
+ else if( XML_STRCMP(szTmp, VAL_I2S_OPTION_WILDCARD) )
+ sockConfig->i2sConfig.clockMode = V3I2SClockModeWildcard;
+ }
+
+ if( Socket.GetChildValueInt( TAG_I2S_CLOCK_DELAY, nTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - I2S clock delay: %d\r\n", nTmp );
+ if( 0 == nTmp )
+ sockConfig->i2sConfig.delayMode = V3I2SDelayOff;
+ else if( 1 == nTmp )
+ sockConfig->i2sConfig.delayMode = V3I2SDelayEnabled;
+ else if( 2 == nTmp )
+ sockConfig->i2sConfig.delayMode = V3I2SDelayWildcard;
+ }
+
+ if( Socket.GetChildValueInt( TAG_I2S_FS_SPEED, nTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - I2S FS speed: %d\r\n", nTmp );
+ switch( nTmp )
+ {
+ case 64:
+ sockConfig->i2sConfig.portSpeed = V3I2SSpeed64FS;
+ break;
+ case 128:
+ sockConfig->i2sConfig.portSpeed = V3I2SSpeed128FS;
+ break;
+ case 256:
+ sockConfig->i2sConfig.portSpeed = V3I2SSpeed256FS;
+ break;
+ case 512:
+ sockConfig->i2sConfig.portSpeed = V3I2SSpeed512FS;
+ break;
+ case 0:
+ sockConfig->i2sConfig.portSpeed = V3I2SSpeedWildcard;
+ break;
+ }
+ }
+
+ szTmp[0] = '\0';
+ if( Socket.GetChildValue( TAG_I2S_ALIGN, szTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - I2S alignment : %s\r\n", szTmp );
+ if( XML_STRCMP(szTmp, VAL_I2S_ALIGNMENT_L16) )
+ sockConfig->i2sConfig.alignment = V3I2SAlignLeft16;
+ else if( XML_STRCMP(szTmp, VAL_I2S_ALIGNMENT_L24) )
+ sockConfig->i2sConfig.alignment = V3I2SAlignLeft24;
+ else if( XML_STRCMP(szTmp, VAL_I2S_ALIGNMENT_R16) )
+ sockConfig->i2sConfig.alignment = V3I2SAlignRight16;
+ else if( XML_STRCMP(szTmp, VAL_I2S_ALIGNMENT_R24) )
+ sockConfig->i2sConfig.alignment = V3I2SAlignRight24;
+ else if( XML_STRCMP(szTmp, VAL_I2S_SEQUENTIAL) )
+ sockConfig->i2sConfig.alignment = V3I2SAlignSeq;
+ }
+
+ szTmp[0] = '\0';
+ if( Socket.GetChildValue( TAG_I2S_PIN, szTmp ) )
+ {
+ ConsolePrintf( PRIO_LOW, " - I2S Pin : %s\r\n", szTmp );
+ if( XML_STRCMP(szTmp, VAL_I2S_PIN_SRXA0) )
+ sockConfig->i2sConfig.pin = V3I2SSRXA0;
+ else if( XML_STRCMP(szTmp, VAL_I2S_PIN_SRXA1) )
+ sockConfig->i2sConfig.pin = V3I2SSRXA1;
+ else if( XML_STRCMP(szTmp, VAL_I2S_PIN_SRXB0) )
+ sockConfig->i2sConfig.pin = V3I2SSRXB0;
+ else if( XML_STRCMP(szTmp, VAL_I2S_PIN_SRXB1) )
+ sockConfig->i2sConfig.pin = V3I2SSRXB1;
+ }
+ }
+
+ Socket.FindNextNode();
+ }
+ }
+ Channel.FindNextNode();
+ }
+ Xml.FindNextNode();
+ }
+ return success && found;
+}
+
+bool CVodXml::GetRouteTerminals( CRouteTerminal *routeTerminal, CSafeVector<CRouteTerminal *> &allRouteTerminals )
+{
+ bool success = false;
+ bool found = false;
+ CXml Xml( *( ( CXml * )this ) );
+ success = Xml.SetToTopNode();
+ success &= Xml.FindNode( TAG_NETWORK_MANAGER );
+ success &= Xml.FindFirstChildNode();
+
+ while( success && Xml.FindNode( TAG_ROUTE ) )
+ {
+ CXml t1( Xml );
+ t1.FindFirstChildNode();
+
+ int deviceType = -1;
+ int instance = -1;
+ int channelId = -1;
+
+ while( t1.FindNode( TAG_TERMINAL ) &&
+ t1.GetChildValueInt( TAG_CHANNEL_ID, channelId ) &&
+ t1.GetChildValueInt( TAG_INSTANCE, instance ) )
+ {
+ if( !t1.GetChildValueInt( TAG_DEVICE_TYPE, deviceType ) )
+ {
+ xmlChar szTmp[XML_DEFAULT_VALUE_LEN];
+ if( t1.GetChildValue( TAG_DEVICE_TYPE_HEX, szTmp, XML_DEFAULT_VALUE_LEN ) )
+ deviceType = ConvertToInt( szTmp );
+ }
+ if( routeTerminal->deviceType != ( uint32_t )deviceType ||
+ routeTerminal->channelId != ( uint32_t )channelId ||
+ routeTerminal->instance != ( uint32_t )instance )
+ {
+ t1.FindNextNode();
+ continue;
+ }
+
+ CXml t2( Xml );
+ t2.FindFirstChildNode();
+
+ while( t2.FindNode( TAG_TERMINAL ) )
+ {
+ deviceType = -1;
+ if( !t2.GetChildValueInt( TAG_DEVICE_TYPE, deviceType ) )
+ {
+ xmlChar szTmp[XML_DEFAULT_VALUE_LEN];
+ if( t2.GetChildValue( TAG_DEVICE_TYPE_HEX, szTmp, XML_DEFAULT_VALUE_LEN ) )
+ deviceType = ConvertToInt( szTmp );
+ }
+ if( !t2.GetChildValueInt( TAG_CHANNEL_ID, channelId ) ||
+ !t2.GetChildValueInt( TAG_INSTANCE, instance ) ||
+ ( routeTerminal->deviceType == ( uint32_t )deviceType &&
+ routeTerminal->channelId == ( uint32_t )channelId &&
+ routeTerminal->instance == ( uint32_t )instance ) )
+ {
+ t2.FindNextNode();
+ continue;
+ }
+ bool alreadyStored = false;
+ for( uint32_t i = 0; found && i < allRouteTerminals.Size(); i++ )
+ {
+ if( allRouteTerminals[i]->deviceType == ( uint32_t )deviceType &&
+ allRouteTerminals[i]->channelId == ( uint32_t )channelId &&
+ allRouteTerminals[i]->instance == ( uint32_t )instance )
+ {
+ alreadyStored = true;
+ break;
+ }
+ }
+ if( !alreadyStored )
+ {
+ CRouteTerminal *terminal = new CRouteTerminal();
+ if( NULL != terminal )
+ {
+ terminal->deviceType = deviceType;
+ terminal->channelId = channelId;
+ terminal->instance = instance;
+ allRouteTerminals.PushBack( terminal );
+ found = true;
+ }
+ }
+ t2.FindNextNode();
+ }
+ t1.FindNextNode();
+ }
+ Xml.FindNextNode();
+ }
+ return success && found;
+}