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>

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;
+}