msm: ipa: Add TTL update test cases

Add basic IPv4 and Ipv6 test cases for TTL update in HW
based on filtering and routing rules. Also, consists of
several minor fixes during bring up.

Change-Id: Ib363434b20ad2fc8cf29c78bb5db667959f2dbfd
Signed-off-by: Chaitanya Pratapa <[email protected]>

drivers/platform/msm/ipa/ipa_test_module/ipa_test_module_impl.c

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: GPL-2.0-only
 /*
 * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
+* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
 */
 
 #include <linux/types.h>	/* u32 */
@@ -350,7 +351,7 @@ static ssize_t channel_write_gsi(struct file *filp, const char __user *buf,
 	int res = 0;
 	void *data_address = channel_dev->mem.base
 		+ channel_dev->mem_buff_index * TX_BUFF_SIZE;
-	u32 data_phys_addr = channel_dev->mem.phys_base
+	u64 data_phys_addr = channel_dev->mem.phys_base
 		+ channel_dev->mem_buff_index * TX_BUFF_SIZE;
 	struct gsi_xfer_elem gsi_xfer;
 
@@ -413,7 +414,7 @@ static ssize_t channel_read_gsi(struct file *filp, char __user *buf,
 			break;
 
 		IPATEST_DBG("channel empty %d/%d\n", i + 1, max_retry);
-		msleep(5);
+		msleep(1000);
 	}
 
 	if (i == max_retry) {
@@ -449,6 +450,8 @@ static ssize_t channel_read_gsi(struct file *filp, char __user *buf,
 		return 0;
 	}
 
+	msleep(20);
+
 	IPATEST_DBG("Returning %d.\n", xfer_notify.bytes_xfered);
 	return xfer_notify.bytes_xfered;
 }
@@ -2741,13 +2744,6 @@ int configure_system_7(void)
 
 	memset(&ipa_ep_cfg, 0, sizeof(ipa_ep_cfg));
 
-	res = exception_hdl_init();
-	if (0 != res) {
-		IPATEST_ERR("exception_hdl_init() failed (%d)\n", res);
-		return res;
-	}
-
-
 	/* Connect first Rx IPA --> APPS MEM */
 	memset(&sys_in, 0, sizeof(sys_in));
 	sys_in.client = IPA_CLIENT_TEST2_CONS;
@@ -3134,7 +3130,8 @@ int configure_system_20(void)
 	u32 ipa_pipe_num;
 
 	memset(&ipa_ep_cfg, 0, sizeof(ipa_ep_cfg));
-
+	ipa_ep_cfg.hdr.hdr_len = 18;
+	sys_in.ipa_ep_cfg = ipa_ep_cfg;
 
 	/* Connect first Rx IPA --> AP MEM */
 	memset(&sys_in, 0, sizeof(sys_in));
@@ -4215,6 +4212,8 @@ static int configure_app_to_ipa_path(struct ipa_channel_config __user *to_ipa_us
 	/* Connect IPA --> Apps */
 	memset(&sys_in, 0, sizeof(sys_in));
 	sys_in.client = to_ipa_channel_config.client;
+	sys_in.notify = &notify_upon_exception;
+	sys_in.priv = &(p_exception_hdl_data->notify_cb_data);
 	IPATEST_DBG("copying from 0x%px\n", to_ipa_channel_config.cfg);
 	retval = copy_from_user(&sys_in.ipa_ep_cfg, to_ipa_channel_config.cfg, to_ipa_channel_config.config_size);
 	if (retval) {
@@ -4379,6 +4378,12 @@ static int configure_test_scenario(
 		return -EFAULT;
 	}
 
+	if (isUlso) {
+		rx_size = RX_SZ_ULSO;
+	} else {
+		rx_size = RX_SZ;
+	}
+
 	for (i = 0 ; i < ipa_test_config_header->from_ipa_channels_num ; i++) {
 		IPATEST_DBG("starting configuration of from_ipa_%d\n", i);
 		retval = configure_app_from_ipa_path(from_ipa_channel_config_array[i], isUlso);
@@ -4388,12 +4393,6 @@ static int configure_test_scenario(
 		}
 	}
 
-	if (isUlso) {
-		rx_size = RX_SZ_ULSO;
-	} else {
-		rx_size = RX_SZ;
-	}
-
 	retval = insert_descriptors_into_rx_endpoints(RX_BUFF_SIZE);
 	if (retval) {
 		IPATEST_ERR("RX descriptors failed\n");
@@ -4426,33 +4425,41 @@ fail:
 
 static int handle_add_hdr_hpc(unsigned long ioctl_arg)
 {
-    struct ipa_ioc_add_hdr hdrs;
+    struct ipa_ioc_add_hdr *hdrs;
     struct ipa_hdr_add *hdr;
     int retval;
 
 	IPATEST_ERR("copying from 0x%px\n", (u8 *)ioctl_arg);
-	retval = copy_from_user(&hdrs, (u8 *)ioctl_arg, sizeof(hdrs) + sizeof(*hdr));
+	hdrs = kzalloc(sizeof(struct ipa_ioc_add_hdr) + sizeof(struct ipa_hdr_add), GFP_KERNEL);
+	if (!hdrs)
+		return -ENOMEM;
+	retval = copy_from_user(hdrs, (u8 *)ioctl_arg,
+				sizeof(struct ipa_ioc_add_hdr) + sizeof(struct ipa_hdr_add));
 	if (retval) {
 			IPATEST_ERR("failing copying header from user\n");
+			kfree(hdrs);
 			return retval;
 	}
-    retval = ipa3_add_hdr_hpc(&hdrs);
+    retval = ipa3_add_hdr_hpc(hdrs);
     if (retval) {
         IPATEST_ERR("ipa3_add_hdr_hpc failed\n");
+        kfree(hdrs);
         return retval;
     }
 	IPATEST_ERR("ELIAD: \n");
-	hdr = &hdrs.hdr[0];
+	hdr = &hdrs->hdr[0];
     if (hdr->status) {
         IPATEST_ERR("ipa3_add_hdr_hpc failed\n");
         return hdr->status;
     }
 	IPATEST_ERR("ELIAD: \n");
-    if (copy_to_user((void __user *)ioctl_arg, &hdrs, sizeof(hdrs) + sizeof(*hdr))) {
+    if (copy_to_user((void __user *)ioctl_arg, hdrs,
+    	sizeof(struct ipa_ioc_add_hdr) + sizeof(struct ipa_hdr_add))) {
         retval = -EFAULT;
     }
 	IPATEST_ERR("ELIAD: \n");
 
+	kfree(hdrs);
     return 0;
 }
 
@@ -4814,6 +4821,10 @@ static int __init ipa_test_init(void)
 	if (ret != 0)
 		IPATEST_DBG("datapath_ds_init() failed (%d)\n", ret);
 
+	ret = exception_hdl_init();
+	if (ret != 0)
+		IPATEST_DBG("exception_hdl_init() failed (%d)\n", ret);
+
 	return ret;
 }
 

kernel-tests/RoutingTests.cpp

@@ -25,6 +25,40 @@
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Changes from Qualcomm Innovation Center are provided under the following license:
+ *
+ * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted (subject to the limitations in the
+ * disclaimer below) provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *
+ *     * Neither the name of Qualcomm Innovation Center, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
+ * GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
+ * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+ * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
  */
 
 #include <stdio.h>
@@ -45,6 +79,8 @@
 #include "IPAFilteringTable.h"
 
 #define TOS_FIELD_OFFSET (1)
+#define IPV4_TTL_OFFSET      (8)
+#define IPV4_CSUM_OFFSET     (10)
 #define DST_ADDR_LSB_OFFSET_IPV4 (19)
 #define SRC_ADDR_LSB_OFFSET_IPV4 (15)
 #define DST_ADDR_MSB_OFFSET_IPV6 (24)
@@ -54,6 +90,7 @@
 #define FLOW_CLASS_MSB_OFFSET_IPV6 (1)
 #define FLOW_CLASS_MB_OFFSET_IPV6 (2)
 #define FLOW_CLASS_LSB_OFFSET_IPV6 (3)
+#define HOP_LIMIT_OFFSET_IPV6 (7)
 #define IPV4_DST_PORT_OFFSET (20+2)
 #define IPV6_SRC_PORT_OFFSET (40)
 #define IPV6_DST_PORT_OFFSET (40+2)
@@ -479,6 +516,23 @@ public:
 		return false;
 	}
 
+	inline bool IsTTLUpdated_v5_5(size_t SendSize, size_t RecvSize, void *Buff)
+	{
+		struct ipa3_hw_pkt_status_hw_v5_5 *pStatus = (struct ipa3_hw_pkt_status_hw_v5_5 *)Buff;
+
+		if (VerifyStatusReceived(SendSize,RecvSize) == false){
+			return false;
+		}
+
+		if(!((bool)pStatus->ttl_dec)){
+			printf ("%s::cache miss!! \n",__FUNCTION__);
+			return true;
+		}
+
+		printf ("%s::cache hit!! \n",__FUNCTION__);
+		return false;
+	}
+
 	static RoutingDriverWrapper m_routing;
 	static Filtering m_filtering;
 
@@ -5095,39 +5149,1031 @@ public:
 	} // Run()
 };
 
-static class IpaRoutingBlockTest1 ipaRoutingBlockTest1;
-static class IpaRoutingBlockTest2 ipaRoutingBlockTest2;
-static class IpaRoutingBlockTest3 ipaRoutingBlockTest3;
-static class IpaRoutingBlockTest4 ipaRoutingBlockTest4;
-static class IpaRoutingBlockTest5 ipaRoutingBlockTest5;
-static class IpaRoutingBlockTest006 ipaRoutingBlockTest006;
-static class IpaRoutingBlockTest007 ipaRoutingBlockTest007;
-static class IpaRoutingBlockTest008 ipaRoutingBlockTest008;
-static class IpaRoutingBlockTest009 ipaRoutingBlockTest009;
+/*---------------------------------------------------------------------------*/
+/* Test50: Test TTL update by routing to a destination address							     */
+/*---------------------------------------------------------------------------*/
+class IpaRoutingBlockTest050 : public IpaRoutingBlockTestFixture
+{
+public:
+	IpaRoutingBlockTest050()
+	{
+		m_name = "IpaRoutingBlockTest050";
+		m_description =" \
+		Routing block test 050 - Destination address exact match\1. Generate and commit a single routing tables. \
+		2. Generate and commit Three routing rules: (DST & Mask Match). \
+			All DST_IP == (192.169.2.170 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST2_CONS \
+			All DST_IP == (192.168.2.255 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST3_CONS\
+			All other traffic goes to pipe IPA_CLIENT_TEST4_CONS \
+		3. Check if TTL is updated. ";
+		m_IpaIPType = IPA_IP_v4;
+		m_minIPAHwType = IPA_HW_v5_5;
+		Register(*this);
+	}
 
-static class IpaRoutingBlockTest010 ipaRoutingBlockTest010;
-static class IpaRoutingBlockTest011 ipaRoutingBlockTest011;
-static class IpaRoutingBlockTest012 ipaRoutingBlockTest012;
-static class IpaRoutingBlockTest013 ipaRoutingBlockTest013;
-static class IpaRoutingBlockTest014 ipaRoutingBlockTest014;
-static class IpaRoutingBlockTest015 ipaRoutingBlockTest015;
-static class IpaRoutingBlockTest016 ipaRoutingBlockTest016;
-static class IpaRoutingBlockTest017 ipaRoutingBlockTest017;
-static class IpaRoutingBlockTest018 ipaRoutingBlockTest018;
+	bool Run()
+	{
+		bool res = false;
+		bool isSuccess = false;
 
-static class IpaRoutingBlockTest020 ipaRoutingBlockTest020;
-static class IpaRoutingBlockTest021 ipaRoutingBlockTest021;
-static class IpaRoutingBlockTest022 ipaRoutingBlockTest022;
-static class IpaRoutingBlockTest023 ipaRoutingBlockTest023;
-static class IpaRoutingBlockTest024 ipaRoutingBlockTest024;
-static class IpaRoutingBlockTest025 ipaRoutingBlockTest025;
-static class IpaRoutingBlockTest026 ipaRoutingBlockTest026;
-static class IpaRoutingBlockTest027 ipaRoutingBlockTest027;
-static class IpaRoutingBlockTest028 ipaRoutingBlockTest028;
+		// Add the relevant routing rules
+		res = AddRules();
+		if (false == res) {
+			printf("Failed adding routing rules.\n");
+			return false;
+		}
 
-static class IpaRoutingBlockTest030 ipaRoutingBlockTest030;
-static class IpaRoutingBlockTest031 ipaRoutingBlockTest031;
+		// Load input data (IP packet) from file
+		res = LoadFiles(IPA_IP_v4);
+		if (false == res) {
+			printf("Failed loading files.\n");
+			return false;
+		}
 
-static class IpaRoutingBlockTest040 ipaRoutingBlockTest040;
+		// Send first packet
+		m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV4] = 0xFF;
+		m_sendBuffer[IPV4_TTL_OFFSET] = 5;
+		isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
+		if (false == isSuccess)
+		{
+			printf("SendData failure.\n");
+			return false;
+		}
+
+		// Send second packet
+		m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
+		m_sendBuffer2[IPV4_TTL_OFFSET] = 4;
+		isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize2);
+		if (false == isSuccess)
+		{
+			printf("SendData failure.\n");
+			return false;
+		}
+
+		// Send third packet
+		m_sendBuffer3[IPV4_TTL_OFFSET] = 3;
+		isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
+		if (false == isSuccess)
+		{
+			printf("SendData failure.\n");
+			return false;
+		}
+
+		// Receive packets from the channels and compare results
+		isSuccess = ReceivePacketsAndCompare();
+
+		return isSuccess;
+	} // Run()
+
+	bool ReceivePacketsAndCompare()
+	{
+		size_t receivedSize = 0;
+		size_t receivedSize2 = 0;
+		size_t receivedSize3 = 0;
+		bool pkt1_cmp_succ, pkt2_cmp_succ, pkt3_cmp_succ;
+		uint16_t csum = 0;
+
+		// Receive results
+		Byte *rxBuff1 = new Byte[0x400];
+		Byte *rxBuff2 = new Byte[0x400];
+		Byte *rxBuff3 = new Byte[0x400];
+
+		if (NULL == rxBuff1 || NULL == rxBuff2 || NULL == rxBuff3)
+		{
+			printf("Memory allocation error.\n");
+			return false;
+		}
+
+		memset(rxBuff1, 0, 0x400);
+		memset(rxBuff2, 0, 0x400);
+		memset(rxBuff3, 0, 0x400);
+
+		receivedSize = m_consumer.ReceiveData(rxBuff1, 0x400);
+		printf("Received %zu bytes on %s.\n", receivedSize, m_consumer.m_fromChannelName.c_str());
+
+		receivedSize2 = m_consumer2.ReceiveData(rxBuff2, 0x400);
+		printf("Received %zu bytes on %s.\n", receivedSize2, m_consumer2.m_fromChannelName.c_str());
+
+		receivedSize3 = m_defaultConsumer.ReceiveData(rxBuff3, 0x400);
+		printf("Received %zu bytes on %s.\n", receivedSize3, m_defaultConsumer.m_fromChannelName.c_str());
+
+		/* Update TTL values. */
+		m_sendBuffer[IPV4_TTL_OFFSET] = 4;
+		m_sendBuffer2[IPV4_TTL_OFFSET] = 3;
+
+		/* Update Checksum.*/
+		csum = *((uint16_t *)(m_sendBuffer + IPV4_CSUM_OFFSET));
+		csum += 1;
+		*((uint16_t *)(m_sendBuffer+ IPV4_CSUM_OFFSET)) = csum;
+
+		csum = *((uint16_t *)(m_sendBuffer2 + IPV4_CSUM_OFFSET));
+		csum += 1;
+		*((uint16_t *)(m_sendBuffer2 + IPV4_CSUM_OFFSET)) = csum;
+
+		/* Compare results */
+		pkt1_cmp_succ = CompareResultVsGolden(m_sendBuffer,  m_sendSize,  rxBuff1, receivedSize);
+		pkt2_cmp_succ = CompareResultVsGolden(m_sendBuffer2, m_sendSize2, rxBuff2, receivedSize2);
+		pkt3_cmp_succ = CompareResultVsGolden(m_sendBuffer3, m_sendSize3, rxBuff3, receivedSize3);
+
+		size_t recievedBufferSize =
+			MAX3(receivedSize, receivedSize2, receivedSize3) * 3;
+		size_t sentBufferSize =
+			MAX3(m_sendSize, m_sendSize2, m_sendSize3) * 3;
+		char *recievedBuffer = new char[recievedBufferSize];
+		char *sentBuffer = new char[sentBufferSize];
+
+		if (NULL == recievedBuffer || NULL == sentBuffer) {
+			printf("Memory allocation error\n");
+			return false;
+		}
+
+		size_t j;
+		memset(recievedBuffer, 0, recievedBufferSize);
+		memset(sentBuffer, 0, sentBufferSize);
+		for(j = 0; j < m_sendSize; j++)
+		    snprintf(&sentBuffer[3 * j], sentBufferSize - (3 * j + 1), " %02X", m_sendBuffer[j]);
+		for(j = 0; j < receivedSize; j++)
+		    snprintf(&recievedBuffer[3 * j], recievedBufferSize - (3 * j + 1), " %02X", rxBuff1[j]);
+		printf("Expected Value1(%zu)\n%s\n, Received Value1(%zu)\n%s\n-->Value1 %s\n",
+			m_sendSize,sentBuffer,receivedSize,recievedBuffer,
+			pkt1_cmp_succ?"Match":"no Match");
+
+		memset(recievedBuffer, 0, recievedBufferSize);
+		memset(sentBuffer, 0, sentBufferSize);
+		for(j = 0; j < m_sendSize2; j++)
+		    snprintf(&sentBuffer[3 * j], sentBufferSize - (3 * j + 1), " %02X", m_sendBuffer2[j]);
+		for(j = 0; j < receivedSize2; j++)
+		    snprintf(&recievedBuffer[3 * j], recievedBufferSize - (3 * j + 1), " %02X", rxBuff2[j]);
+		printf("Expected Value2 (%zu)\n%s\n, Received Value2(%zu)\n%s\n-->Value2 %s\n",
+			m_sendSize2,sentBuffer,receivedSize2,recievedBuffer,
+			pkt2_cmp_succ?"Match":"no Match");
+
+		memset(recievedBuffer, 0, recievedBufferSize);
+		memset(sentBuffer, 0, sentBufferSize);
+		for(j = 0; j < m_sendSize3; j++)
+		    snprintf(&sentBuffer[3 * j], sentBufferSize - (3 * j + 1), " %02X", m_sendBuffer3[j]);
+		for(j = 0; j < receivedSize3; j++)
+		    snprintf(&recievedBuffer[3 * j], recievedBufferSize - (3 * j + 1), " %02X", rxBuff3[j]);
+		printf("Expected Value3 (%zu)\n%s\n, Received Value3(%zu)\n%s\n-->Value3 %s\n",
+			m_sendSize3,sentBuffer,receivedSize3,recievedBuffer,
+			pkt3_cmp_succ?"Match":"no Match");
+
+		delete[] recievedBuffer;
+		delete[] sentBuffer;
+
+		delete[] rxBuff1;
+		delete[] rxBuff2;
+		delete[] rxBuff3;
+
+		return pkt1_cmp_succ && pkt2_cmp_succ && pkt3_cmp_succ;
+	}
+
+
+	bool AddRules()
+	{
+		struct ipa_ioc_add_rt_rule_v2 *rt_rule;
+		struct ipa_rt_rule_add_v2 *rt_rule_entry;
+		const int NUM_RULES = 3;
+
+		rt_rule = (struct ipa_ioc_add_rt_rule_v2 *)
+			calloc(1, sizeof(struct ipa_ioc_add_rt_rule_v2));
+
+		if(!rt_rule) {
+			printf("fail\n");
+			return false;
+		}
+
+		rt_rule->rules = (uint64_t)calloc(3, sizeof(struct ipa_rt_rule_add_v2));
+		if(!rt_rule->rules) {
+			printf("fail\n");
+			return false;
+		}
+
+		rt_rule->commit = 1;
+		rt_rule->num_rules = NUM_RULES;
+		rt_rule->ip = IPA_IP_v4;
+		strlcpy(rt_rule->rt_tbl_name, "LAN", sizeof(rt_rule->rt_tbl_name));
 
+		rt_rule_entry = &(((struct ipa_rt_rule_add_v2 *)rt_rule->rules)[0]);
+		rt_rule_entry->at_rear = 0;
+		rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
+//		rt_rule_entry->rule.hdr_hdl = hdr_entry->hdr_hdl; // gidons, there is no support for header insertion / removal yet.
+		rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
+		rt_rule_entry->rule.attrib.u.v4.dst_addr      = 0xC0A802FF;
+		rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
+		rt_rule_entry->rule.ttl_update = 1;
+
+		rt_rule_entry = &(((struct ipa_rt_rule_add_v2 *)rt_rule->rules)[1]);
+		rt_rule_entry->at_rear = 0;
+		rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
+//		rt_rule_entry->rule.hdr_hdl = hdr_entry->hdr_hdl; // gidons, there is no support for header insertion / removal yet.
+		rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
+		rt_rule_entry->rule.attrib.u.v4.dst_addr      = 0xC0A802AA;
+		rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
+		rt_rule_entry->rule.ttl_update = 1;
+
+		rt_rule_entry = &(((struct ipa_rt_rule_add_v2 *)rt_rule->rules)[2]);
+		rt_rule_entry->at_rear = 1;
+		rt_rule_entry->rule.ttl_update = 0;
+		rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
+
+		if (false == m_routing.AddRoutingRule(rt_rule))
+		{
+			printf("Routing rule addition failed!\n");
+			return false;
+		}
+
+		printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
+
+		free(rt_rule);
+
+		InitFilteringBlock();
+
+		return true;
+	}
+};
+
+/*--------------------------------------------------------------------------*/
+/* Test51: IPv4 - Tests routing hashable vs non hashable priorities			*/
+/*--------------------------------------------------------------------------*/
+class IpaRoutingBlockTest051 : public IpaRoutingBlockTestFixture
+{
+public:
+
+	IpaRoutingBlockTest051()
+	{
+		m_name = "IpaRoutingBlockTest051";
+		m_description =" \
+		Routing block test 051 - Destination address exact match hashable priority higher than non hashable \
+		both match the packet but only hashable should hit, second packet should get cache hit, \
+		Check if TTL is updated.\
+		2. Generate and commit Three routing rules: (DST & Mask Match). \
+			All DST_IP == (192.168.2.170 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST2_CONS \
+			All DST_IP == (192.168.2.170 & 255.255.255.255)traffic goes to pipe IPA_CLIENT_TEST3_CONS\
+			All other traffic goes to pipe IPA_CLIENT_TEST4_CONS \
+		3. Check if TTL is updated.";
+		m_IpaIPType = IPA_IP_v4;
+		m_minIPAHwType = IPA_HW_v5_5;
+		Register(*this);
+	}
+
+	bool Setup()
+	{
+		return IpaRoutingBlockTestFixture:: Setup(true);
+	}
+
+	bool AddRules()
+	{
+		struct ipa_ioc_add_rt_rule_v2 *rt_rule;
+		struct ipa_rt_rule_add_v2 *rt_rule_entry;
+		const int NUM_RULES = 3;
+
+		rt_rule = (struct ipa_ioc_add_rt_rule_v2 *)
+			calloc(1, sizeof(struct ipa_ioc_add_rt_rule_v2));
+
+		if(!rt_rule) {
+			printf("fail\n");
+			return false;
+		}
+
+		rt_rule->rules = (uint64_t)calloc(3, sizeof(struct ipa_rt_rule_add_v2));
+		if(!rt_rule->rules) {
+			printf("fail\n");
+			return false;
+		}
+
+		rt_rule->commit = 1;
+		rt_rule->num_rules = NUM_RULES;
+		rt_rule->ip = IPA_IP_v4;
+		strlcpy(rt_rule->rt_tbl_name, "LAN", sizeof(rt_rule->rt_tbl_name));
+
+		rt_rule_entry = &(((struct ipa_rt_rule_add_v2 *)rt_rule->rules)[0]);
+		rt_rule_entry->at_rear = 1;
+		rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
+		rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
+		rt_rule_entry->rule.attrib.u.v4.dst_addr      = 0xC0A802AA; //192.168.02.170
+		rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
+		rt_rule_entry->rule.hashable = 1; // hashable
+		rt_rule_entry->rule.ttl_update = 1; // TTL Update
+
+		rt_rule_entry = &(((struct ipa_rt_rule_add_v2 *)rt_rule->rules)[1]);
+		rt_rule_entry->at_rear = 1;
+		rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
+		rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
+		rt_rule_entry->rule.attrib.u.v4.dst_addr      = 0xC0A802AA; //192.168.02.170
+		rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
+		rt_rule_entry->rule.hashable = 0; // non hashable
+		rt_rule_entry->rule.ttl_update = 1; // TTL Update
+
+		rt_rule_entry = &(((struct ipa_rt_rule_add_v2 *)rt_rule->rules)[2]);
+		rt_rule_entry->at_rear = 1;
+		rt_rule_entry->rule.ttl_update = 0; // TTL Update
+		rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
+
+		if (false == m_routing.AddRoutingRule(rt_rule))
+		{
+			printf("Routing rule addition failed!\n");
+			return false;
+		}
+
+		printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
+
+		free(rt_rule);
+
+		InitFilteringBlock();
+
+		return true;
+	}
+
+	bool Run()
+	{
+		bool res = false;
+		bool isSuccess = false;
+
+		// Add the relevant routing rules
+		res = AddRules();
+		if (false == res) {
+			printf("Failed adding routing rules.\n");
+			return false;
+		}
+
+		// Load input data (IP packet) from file
+		res = LoadFiles(IPA_IP_v4);
+		if (false == res) {
+			printf("Failed loading files.\n");
+			return false;
+		}
+
+		// Send first packet
+		m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
+		m_sendBuffer[IPV4_TTL_OFFSET] = 5;
+		isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
+		if (false == isSuccess)
+		{
+			printf("SendData failure.\n");
+			return false;
+		}
+
+		// Send second packet
+		m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV4] = 0xAA;
+		m_sendBuffer2[IPV4_TTL_OFFSET] = 4;
+		isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize2);
+		if (false == isSuccess)
+		{
+			printf("SendData failure.\n");
+			return false;
+		}
+
+		// Send third packet
+		m_sendBuffer3[IPV4_TTL_OFFSET] = 3;
+		isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
+		if (false == isSuccess)
+		{
+			printf("SendData failure.\n");
+			return false;
+		}
+
+		// Receive packets from the channels and compare results
+		isSuccess = ReceivePacketsAndCompare();
+
+		return isSuccess;
+	} // Run()
+
+	bool ReceivePacketsAndCompare()
+	{
+		size_t receivedSize = 0;
+		size_t receivedSize2 = 0;
+		size_t receivedSize3 = 0;
+		bool isSuccess = true;
+		uint16_t csum = 0;
+
+		// Receive results
+		Byte *rxBuff1 = new Byte[0x400];
+		Byte *rxBuff2 = new Byte[0x400];
+		Byte *rxBuff3 = new Byte[0x400];
+
+		if (NULL == rxBuff1 || NULL == rxBuff2 || NULL == rxBuff3)
+		{
+			printf("Memory allocation error.\n");
+			return false;
+		}
+
+		receivedSize = m_consumer.ReceiveData(rxBuff1, 0x400);
+		printf("Received %zu bytes on %s.\n", receivedSize, m_consumer.m_fromChannelName.c_str());
+
+		receivedSize2 = m_consumer.ReceiveData(rxBuff2, 0x400);
+		printf("Received %zu bytes on %s.\n", receivedSize2, m_consumer2.m_fromChannelName.c_str());
+
+		receivedSize3 = m_defaultConsumer.ReceiveData(rxBuff3, 0x400);
+		printf("Received %zu bytes on %s.\n", receivedSize3, m_defaultConsumer.m_fromChannelName.c_str());
+
+		/* Update TTL values. */
+		m_sendBuffer[IPV4_TTL_OFFSET] = 4;
+		m_sendBuffer2[IPV4_TTL_OFFSET] = 3;
+
+		/* Update Checksum.*/
+		csum = *((uint16_t *)(m_sendBuffer + IPV4_CSUM_OFFSET));
+		csum += 1;
+		*((uint16_t *)(m_sendBuffer+ IPV4_CSUM_OFFSET)) = csum;
+
+		csum = *((uint16_t *)(m_sendBuffer2 + IPV4_CSUM_OFFSET));
+		csum += 1;
+		*((uint16_t *)(m_sendBuffer2 + IPV4_CSUM_OFFSET)) = csum;
+
+		/* Compare results */
+		isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer,  m_sendSize,  rxBuff1, receivedSize);
+		isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer2, m_sendSize2, rxBuff2, receivedSize2);
+		isSuccess &= CompareResultVsGolden_w_Status(m_sendBuffer3, m_sendSize3, rxBuff3, receivedSize3);
+
+		isSuccess &= (TestManager::GetInstance()->GetIPAHwType() >= IPA_HW_v5_0) ?
+			IsCacheMiss_v5_0(m_sendSize, receivedSize, rxBuff1) : IsCacheMiss(m_sendSize,receivedSize,rxBuff1);
+		isSuccess &= (TestManager::GetInstance()->GetIPAHwType() >= IPA_HW_v5_0) ?
+			IsCacheHit_v5_0(m_sendSize2, receivedSize2, rxBuff2) : IsCacheHit(m_sendSize2,receivedSize2,rxBuff2);
+		isSuccess &= (TestManager::GetInstance()->GetIPAHwType() >= IPA_HW_v5_0) ?
+			IsCacheMiss_v5_0(m_sendSize3, receivedSize3, rxBuff3) : IsCacheMiss(m_sendSize3,receivedSize3,rxBuff3);
+
+		isSuccess &= (TestManager::GetInstance()->GetIPAHwType() >= IPA_HW_v5_5) ?
+			IsTTLUpdated_v5_5(m_sendSize, receivedSize, rxBuff1) : true;
+		isSuccess &= (TestManager::GetInstance()->GetIPAHwType() >= IPA_HW_v5_5) ?
+			IsTTLUpdated_v5_5(m_sendSize2, receivedSize2, rxBuff2) : true;
+		isSuccess &= (TestManager::GetInstance()->GetIPAHwType() >= IPA_HW_v5_5) ?
+			!IsTTLUpdated_v5_5(m_sendSize3, receivedSize3, rxBuff3) : true;
+
+		size_t recievedBufferSize = receivedSize * 3;
+		size_t sentBufferSize = m_sendSize * 3;
+		char *recievedBuffer = new char[recievedBufferSize];
+		char *sentBuffer = new char[sentBufferSize];
+
+		memset(recievedBuffer, 0, recievedBufferSize);
+		memset(sentBuffer, 0, sentBufferSize);
+
+		print_packets(receivedSize, m_sendSize, recievedBufferSize, sentBufferSize, rxBuff1, m_sendBuffer, recievedBuffer, sentBuffer);
+		print_packets(receivedSize2, m_sendSize2, recievedBufferSize, sentBufferSize, rxBuff2, m_sendBuffer2, recievedBuffer, sentBuffer);
+		print_packets(receivedSize3, m_sendSize3, recievedBufferSize, sentBufferSize, rxBuff3, m_sendBuffer3, recievedBuffer, sentBuffer);
+
+		delete[] recievedBuffer;
+		delete[] sentBuffer;
+
+		delete[] rxBuff1;
+		delete[] rxBuff2;
+		delete[] rxBuff3;
+
+		return isSuccess;
+	}
+};
+
+/*---------------------------------------------------------------------------*/
+/* Test52: IPv6 - Test TTL update by routing to destination address */
+/*---------------------------------------------------------------------------*/
+class IpaRoutingBlockTest052 : public IpaRoutingBlockTestFixture
+{
+public:
+	IpaRoutingBlockTest052()
+	{
+		m_name = "IpaRoutingBlockTest052";
+		m_description =" \
+		Routing block test 052 - IPv6 Destination address exact match and check if TTL is updated \
+		1. Generate and commit a single routing tables. \
+		2. Generate and commit Three routing rules: (DST & Mask Match). \
+			All DST_IP ==	0XFF020000 \
+							0x00000000 \
+							0x00000000 \
+							0X000000FF \
+		traffic goes to pipe IPA_CLIENT_TEST2_CONS \
+		All DST_IP ==	0XFF020000 \
+						0x00000000 \
+						0x00000000 \
+						0X000000FF \
+		traffic goes to pipe IPA_CLIENT_TEST3_CONS\
+		All other traffic goes to pipe IPA_CLIENT_TEST4_CONS \
+		3. Check if TTL is updated.";
+		m_IpaIPType = IPA_IP_v6;
+		m_minIPAHwType = IPA_HW_v5_5;
+		Register(*this);
+	}
+
+	bool Run()
+	{
+		bool res = false;
+		bool isSuccess = false;
+
+		// Add the relevant routing rules
+		res = AddRules();
+		if (false == res) {
+			printf("Failed adding routing rules.\n");
+			return false;
+		}
+
+		// Load input data (IP packet) from file
+		res = LoadFiles(IPA_IP_v6);
+		if (false == res) {
+			printf("Failed loading files.\n");
+			return false;
+		}
+
+		// Send first packet
+		m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
+		m_sendBuffer[HOP_LIMIT_OFFSET_IPV6] = 5;
+		isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
+		if (false == isSuccess)
+		{
+			printf("SendData failure.\n");
+			return false;
+		}
+
+		// Send second packet
+		m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV6] = 0xAA;
+		m_sendBuffer2[HOP_LIMIT_OFFSET_IPV6] = 4;
+		isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
+		if (false == isSuccess)
+		{
+			printf("SendData failure.\n");
+			return false;
+		}
+
+		// Send third packet
+		m_sendBuffer3[HOP_LIMIT_OFFSET_IPV6] = 3;
+		isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
+		if (false == isSuccess)
+		{
+			printf("SendData failure.\n");
+			return false;
+		}
+
+		// Receive packets from the channels and compare results
+		isSuccess = ReceivePacketsAndCompare();
+
+		return isSuccess;
+	} // Run()
+
+	bool ReceivePacketsAndCompare()
+	{
+		size_t receivedSize = 0;
+		size_t receivedSize2 = 0;
+		size_t receivedSize3 = 0;
+		bool pkt1_cmp_succ, pkt2_cmp_succ, pkt3_cmp_succ;
+
+		// Receive results
+		Byte *rxBuff1 = new Byte[0x400];
+		Byte *rxBuff2 = new Byte[0x400];
+		Byte *rxBuff3 = new Byte[0x400];
+
+		if (NULL == rxBuff1 || NULL == rxBuff2 || NULL == rxBuff3)
+		{
+			printf("Memory allocation error.\n");
+			return false;
+		}
+
+		memset(rxBuff1, 0, 0x400);
+		memset(rxBuff2, 0, 0x400);
+		memset(rxBuff3, 0, 0x400);
+
+		receivedSize = m_consumer.ReceiveData(rxBuff1, 0x400);
+		printf("Received %zu bytes on %s.\n", receivedSize, m_consumer.m_fromChannelName.c_str());
+
+		receivedSize2 = m_consumer2.ReceiveData(rxBuff2, 0x400);
+		printf("Received %zu bytes on %s.\n", receivedSize2, m_consumer2.m_fromChannelName.c_str());
+
+		receivedSize3 = m_defaultConsumer.ReceiveData(rxBuff3, 0x400);
+		printf("Received %zu bytes on %s.\n", receivedSize3, m_defaultConsumer.m_fromChannelName.c_str());
+
+		/* Update TTL values. */
+		m_sendBuffer[HOP_LIMIT_OFFSET_IPV6] = 4;
+		m_sendBuffer2[HOP_LIMIT_OFFSET_IPV6] = 3;
+
+		/* Compare results */
+		pkt1_cmp_succ = CompareResultVsGolden(m_sendBuffer,  m_sendSize,  rxBuff1, receivedSize);
+		pkt2_cmp_succ = CompareResultVsGolden(m_sendBuffer2, m_sendSize2, rxBuff2, receivedSize2);
+		pkt3_cmp_succ = CompareResultVsGolden(m_sendBuffer3, m_sendSize3, rxBuff3, receivedSize3);
+
+		size_t recievedBufferSize =
+			MAX3(receivedSize, receivedSize2, receivedSize3) * 3;
+		size_t sentBufferSize =
+			MAX3(m_sendSize, m_sendSize2, m_sendSize3) * 3;
+		char *recievedBuffer = new char[recievedBufferSize];
+		char *sentBuffer = new char[sentBufferSize];
+
+		if (NULL == recievedBuffer || NULL == sentBuffer) {
+			printf("Memory allocation error\n");
+			return false;
+		}
+
+		size_t j;
+		memset(recievedBuffer, 0, recievedBufferSize);
+		memset(sentBuffer, 0, sentBufferSize);
+		for(j = 0; j < m_sendSize; j++)
+		    snprintf(&sentBuffer[3 * j], sentBufferSize - (3 * j + 1), " %02X", m_sendBuffer[j]);
+		for(j = 0; j < receivedSize; j++)
+		    snprintf(&recievedBuffer[3 * j], recievedBufferSize - (3 * j + 1), " %02X", rxBuff1[j]);
+		printf("Expected Value1(%zu)\n%s\n, Received Value1(%zu)\n%s\n-->Value1 %s\n",
+			m_sendSize,sentBuffer,receivedSize,recievedBuffer,
+			pkt1_cmp_succ?"Match":"no Match");
+
+		memset(recievedBuffer, 0, recievedBufferSize);
+		memset(sentBuffer, 0, sentBufferSize);
+		for(j = 0; j < m_sendSize2; j++)
+		    snprintf(&sentBuffer[3 * j], sentBufferSize - (3 * j + 1), " %02X", m_sendBuffer2[j]);
+		for(j = 0; j < receivedSize2; j++)
+		    snprintf(&recievedBuffer[3 * j], recievedBufferSize - (3 * j + 1), " %02X", rxBuff2[j]);
+		printf("Expected Value2 (%zu)\n%s\n, Received Value2(%zu)\n%s\n-->Value2 %s\n",
+			m_sendSize2,sentBuffer,receivedSize2,recievedBuffer,
+			pkt2_cmp_succ?"Match":"no Match");
+
+		memset(recievedBuffer, 0, recievedBufferSize);
+		memset(sentBuffer, 0, sentBufferSize);
+		for(j = 0; j < m_sendSize3; j++)
+		    snprintf(&sentBuffer[3 * j], sentBufferSize - (3 * j + 1), " %02X", m_sendBuffer3[j]);
+		for(j = 0; j < receivedSize3; j++)
+		    snprintf(&recievedBuffer[3 * j], recievedBufferSize - (3 * j + 1), " %02X", rxBuff3[j]);
+		printf("Expected Value3 (%zu)\n%s\n, Received Value3(%zu)\n%s\n-->Value3 %s\n",
+			m_sendSize3,sentBuffer,receivedSize3,recievedBuffer,
+			pkt3_cmp_succ?"Match":"no Match");
+
+		delete[] recievedBuffer;
+		delete[] sentBuffer;
+
+		delete[] rxBuff1;
+		delete[] rxBuff2;
+		delete[] rxBuff3;
+
+		return pkt1_cmp_succ && pkt2_cmp_succ && pkt3_cmp_succ;
+	}
+
+	bool AddRules()
+	{
+		struct ipa_ioc_add_rt_rule_v2 *rt_rule;
+		struct ipa_rt_rule_add_v2 *rt_rule_entry;
+		const int NUM_RULES = 3;
+
+		rt_rule = (struct ipa_ioc_add_rt_rule_v2 *)
+			calloc(1, sizeof(struct ipa_ioc_add_rt_rule_v2));
+
+		if(!rt_rule) {
+			printf("fail\n");
+			return false;
+		}
+
+		rt_rule->rules = (uint64_t)calloc(3, sizeof(struct ipa_rt_rule_add_v2));
+		if(!rt_rule->rules) {
+			printf("fail\n");
+			return false;
+		}
+
+		rt_rule->commit = 1;
+		rt_rule->num_rules = NUM_RULES;
+		rt_rule->ip = IPA_IP_v6;
+		strlcpy(rt_rule->rt_tbl_name, "LAN", sizeof(rt_rule->rt_tbl_name));
+
+		rt_rule_entry = &(((struct ipa_rt_rule_add_v2 *)rt_rule->rules)[0]);
+		rt_rule_entry->at_rear = 0;
+		rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
+//		rt_rule_entry->rule.hdr_hdl = hdr_entry->hdr_hdl; // gidons, there is no support for header insertion / removal yet.
+		rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[0]      = 0XFF020000;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[1]      = 0x00000000;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[2]      = 0x00000000;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[3]      = 0X000000FF;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
+		rt_rule_entry->rule.ttl_update = 1; // TTL Update
+
+		rt_rule_entry = &(((struct ipa_rt_rule_add_v2 *)rt_rule->rules)[1]);
+		rt_rule_entry->at_rear = 0;
+		rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
+//		rt_rule_entry->rule.hdr_hdl = hdr_entry->hdr_hdl; // gidons, there is no support for header insertion / removal yet.
+		rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[0]      = 0XFF020000;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[1]      = 0x00000000;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[2]      = 0x00000000;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[3]      = 0X000000AA;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
+		rt_rule_entry->rule.ttl_update = 1; // TTL Update
+
+		rt_rule_entry = &(((struct ipa_rt_rule_add_v2 *)rt_rule->rules)[2]);
+		rt_rule_entry->at_rear = 1;
+		rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
+		rt_rule_entry->rule.ttl_update = 0; // TTL Update
+		if (false == m_routing.AddRoutingRule(rt_rule))
+		{
+			printf("Routing rule addition failed!\n");
+			return false;
+		}
+
+		printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
+
+		free(rt_rule);
+
+		InitFilteringBlock();
+
+		return true;
+	}
+};
+
+/*---------------------------------------------------------------------------------------*/
+/* Test53: IPv6 - Test TTL update by routing to destination address and check for status */
+/*---------------------------------------------------------------------------------------*/
+class IpaRoutingBlockTest053 : public IpaRoutingBlockTestFixture
+{
+public:
+	IpaRoutingBlockTest053()
+	{
+		m_name = "IpaRoutingBlockTest053";
+		m_description =" \
+		Routing block test 053 - IPv6 Destination address exact match and check if TTL is updated \
+		1. Generate and commit a single routing tables. \
+		2. Generate and commit Three routing rules: (DST & Mask Match). \
+			All DST_IP ==	0XFF020000 \
+							0x00000000 \
+							0x00000000 \
+							0X000000FF \
+		traffic goes to pipe IPA_CLIENT_TEST2_CONS \
+		All DST_IP ==	0XFF020000 \
+						0x00000000 \
+						0x00000000 \
+						0X000000FF \
+		traffic goes to pipe IPA_CLIENT_TEST3_CONS\
+		All other traffic goes to pipe IPA_CLIENT_TEST4_CONS \
+		3. Check if TTL is updated and also the status has TTL bit updated.";
+		m_IpaIPType = IPA_IP_v6;
+		m_minIPAHwType = IPA_HW_v5_5;
+		Register(*this);
+	}
+
+	bool Setup()
+	{
+		return IpaRoutingBlockTestFixture:: Setup(true);
+	}
+
+	bool Run()
+	{
+		bool res = false;
+		bool isSuccess = false;
+
+		// Add the relevant routing rules
+		res = AddRules();
+		if (false == res) {
+			printf("Failed adding routing rules.\n");
+			return false;
+		}
+
+		// Load input data (IP packet) from file
+		res = LoadFiles(IPA_IP_v6);
+		if (false == res) {
+			printf("Failed loading files.\n");
+			return false;
+		}
+
+		// Send first packet
+		m_sendBuffer[DST_ADDR_LSB_OFFSET_IPV6] = 0xFF;
+		m_sendBuffer[HOP_LIMIT_OFFSET_IPV6] = 5;
+		isSuccess = m_producer.SendData(m_sendBuffer, m_sendSize);
+		if (false == isSuccess)
+		{
+			printf("SendData failure.\n");
+			return false;
+		}
+
+		// Send second packet
+		m_sendBuffer2[DST_ADDR_LSB_OFFSET_IPV6] = 0xAA;
+		m_sendBuffer2[HOP_LIMIT_OFFSET_IPV6] = 4;
+		isSuccess = m_producer.SendData(m_sendBuffer2, m_sendSize);
+		if (false == isSuccess)
+		{
+			printf("SendData failure.\n");
+			return false;
+		}
+
+		// Send third packet
+		m_sendBuffer3[HOP_LIMIT_OFFSET_IPV6] = 3;
+		isSuccess = m_producer.SendData(m_sendBuffer3, m_sendSize3);
+		if (false == isSuccess)
+		{
+			printf("SendData failure.\n");
+			return false;
+		}
+
+		// Receive packets from the channels and compare results
+		isSuccess = ReceivePacketsAndCompare();
+
+		return isSuccess;
+	} // Run()
+
+	bool ReceivePacketsAndCompare()
+	{
+		size_t receivedSize = 0;
+		size_t receivedSize2 = 0;
+		size_t receivedSize3 = 0;
+		bool pkt1_cmp_succ, pkt2_cmp_succ, pkt3_cmp_succ;
+
+		// Receive results
+		Byte *rxBuff1 = new Byte[0x400];
+		Byte *rxBuff2 = new Byte[0x400];
+		Byte *rxBuff3 = new Byte[0x400];
+
+		if (NULL == rxBuff1 || NULL == rxBuff2 || NULL == rxBuff3)
+		{
+			printf("Memory allocation error.\n");
+			return false;
+		}
+
+		memset(rxBuff1, 0, 0x400);
+		memset(rxBuff2, 0, 0x400);
+		memset(rxBuff3, 0, 0x400);
+
+		receivedSize = m_consumer.ReceiveData(rxBuff1, 0x400);
+		printf("Received %zu bytes on %s.\n", receivedSize, m_consumer.m_fromChannelName.c_str());
+
+		receivedSize2 = m_consumer2.ReceiveData(rxBuff2, 0x400);
+		printf("Received %zu bytes on %s.\n", receivedSize2, m_consumer2.m_fromChannelName.c_str());
+
+		receivedSize3 = m_defaultConsumer.ReceiveData(rxBuff3, 0x400);
+		printf("Received %zu bytes on %s.\n", receivedSize3, m_defaultConsumer.m_fromChannelName.c_str());
+
+		/* Update TTL values. */
+		m_sendBuffer[HOP_LIMIT_OFFSET_IPV6] = 4;
+		m_sendBuffer2[HOP_LIMIT_OFFSET_IPV6] = 3;
+
+		/* Compare results */
+		pkt1_cmp_succ = CompareResultVsGolden_w_Status(m_sendBuffer,  m_sendSize,  rxBuff1, receivedSize);
+		pkt2_cmp_succ = CompareResultVsGolden_w_Status(m_sendBuffer2, m_sendSize2, rxBuff2, receivedSize2);
+		pkt3_cmp_succ = CompareResultVsGolden_w_Status(m_sendBuffer3, m_sendSize3, rxBuff3, receivedSize3);
+
+		pkt1_cmp_succ &= (TestManager::GetInstance()->GetIPAHwType() >= IPA_HW_v5_5) ?
+			IsTTLUpdated_v5_5(m_sendSize, receivedSize, rxBuff1) : true;
+		pkt2_cmp_succ &= (TestManager::GetInstance()->GetIPAHwType() >= IPA_HW_v5_5) ?
+			IsTTLUpdated_v5_5(m_sendSize2, receivedSize2, rxBuff2) : true;
+		pkt3_cmp_succ &= (TestManager::GetInstance()->GetIPAHwType() >= IPA_HW_v5_5) ?
+			!IsTTLUpdated_v5_5(m_sendSize3, receivedSize3, rxBuff3) : true;
+
+		size_t recievedBufferSize =
+			MAX3(receivedSize, receivedSize2, receivedSize3) * 3;
+		size_t sentBufferSize =
+			MAX3(m_sendSize, m_sendSize2, m_sendSize3) * 3;
+		char *recievedBuffer = new char[recievedBufferSize];
+		char *sentBuffer = new char[sentBufferSize];
+
+		if (NULL == recievedBuffer || NULL == sentBuffer) {
+			printf("Memory allocation error\n");
+			return false;
+		}
+
+		size_t j;
+		memset(recievedBuffer, 0, recievedBufferSize);
+		memset(sentBuffer, 0, sentBufferSize);
+		for(j = 0; j < m_sendSize; j++)
+		    snprintf(&sentBuffer[3 * j], sentBufferSize - (3 * j + 1), " %02X", m_sendBuffer[j]);
+		for(j = 0; j < receivedSize; j++)
+		    snprintf(&recievedBuffer[3 * j], recievedBufferSize - (3 * j + 1), " %02X", rxBuff1[j]);
+		printf("Expected Value1(%zu)\n%s\n, Received Value1(%zu)\n%s\n-->Value1 %s\n",
+			m_sendSize,sentBuffer,receivedSize,recievedBuffer,
+			pkt1_cmp_succ?"Match":"no Match");
+
+		memset(recievedBuffer, 0, recievedBufferSize);
+		memset(sentBuffer, 0, sentBufferSize);
+		for(j = 0; j < m_sendSize2; j++)
+		    snprintf(&sentBuffer[3 * j], sentBufferSize - (3 * j + 1), " %02X", m_sendBuffer2[j]);
+		for(j = 0; j < receivedSize2; j++)
+		    snprintf(&recievedBuffer[3 * j], recievedBufferSize - (3 * j + 1), " %02X", rxBuff2[j]);
+		printf("Expected Value2 (%zu)\n%s\n, Received Value2(%zu)\n%s\n-->Value2 %s\n",
+			m_sendSize2,sentBuffer,receivedSize2,recievedBuffer,
+			pkt2_cmp_succ?"Match":"no Match");
+
+		memset(recievedBuffer, 0, recievedBufferSize);
+		memset(sentBuffer, 0, sentBufferSize);
+		for(j = 0; j < m_sendSize3; j++)
+		    snprintf(&sentBuffer[3 * j], sentBufferSize - (3 * j + 1), " %02X", m_sendBuffer3[j]);
+		for(j = 0; j < receivedSize3; j++)
+		    snprintf(&recievedBuffer[3 * j], recievedBufferSize - (3 * j + 1), " %02X", rxBuff3[j]);
+		printf("Expected Value3 (%zu)\n%s\n, Received Value3(%zu)\n%s\n-->Value3 %s\n",
+			m_sendSize3,sentBuffer,receivedSize3,recievedBuffer,
+			pkt3_cmp_succ?"Match":"no Match");
+
+		delete[] recievedBuffer;
+		delete[] sentBuffer;
+
+		delete[] rxBuff1;
+		delete[] rxBuff2;
+		delete[] rxBuff3;
+
+		return pkt1_cmp_succ && pkt2_cmp_succ && pkt3_cmp_succ;
+	}
+
+	bool AddRules()
+	{
+		struct ipa_ioc_add_rt_rule_v2 *rt_rule;
+		struct ipa_rt_rule_add_v2 *rt_rule_entry;
+		const int NUM_RULES = 3;
+
+		rt_rule = (struct ipa_ioc_add_rt_rule_v2 *)
+			calloc(1, sizeof(struct ipa_ioc_add_rt_rule_v2));
+
+		if(!rt_rule) {
+			printf("fail\n");
+			return false;
+		}
+
+		rt_rule->rules = (uint64_t)calloc(3, sizeof(struct ipa_rt_rule_add_v2));
+		if(!rt_rule->rules) {
+			printf("fail\n");
+			return false;
+		}
+
+		rt_rule->commit = 1;
+		rt_rule->num_rules = NUM_RULES;
+		rt_rule->ip = IPA_IP_v6;
+		strlcpy(rt_rule->rt_tbl_name, "LAN", sizeof(rt_rule->rt_tbl_name));
+
+		rt_rule_entry = &(((struct ipa_rt_rule_add_v2 *)rt_rule->rules)[0]);
+		rt_rule_entry->at_rear = 0;
+		rt_rule_entry->rule.dst = IPA_CLIENT_TEST2_CONS;
+//		rt_rule_entry->rule.hdr_hdl = hdr_entry->hdr_hdl; // gidons, there is no support for header insertion / removal yet.
+		rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[0]      = 0XFF020000;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[1]      = 0x00000000;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[2]      = 0x00000000;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[3]      = 0X000000FF;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
+		rt_rule_entry->rule.ttl_update = 1; // TTL Update
+
+		rt_rule_entry = &(((struct ipa_rt_rule_add_v2 *)rt_rule->rules)[1]);
+		rt_rule_entry->at_rear = 0;
+		rt_rule_entry->rule.dst = IPA_CLIENT_TEST3_CONS;
+//		rt_rule_entry->rule.hdr_hdl = hdr_entry->hdr_hdl; // gidons, there is no support for header insertion / removal yet.
+		rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[0]      = 0XFF020000;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[1]      = 0x00000000;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[2]      = 0x00000000;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr[3]      = 0X000000AA;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
+		rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
+		rt_rule_entry->rule.ttl_update = 1; // TTL Update
+
+		rt_rule_entry = &(((struct ipa_rt_rule_add_v2 *)rt_rule->rules)[2]);
+		rt_rule_entry->at_rear = 1;
+		rt_rule_entry->rule.dst = IPA_CLIENT_TEST4_CONS;
+		rt_rule_entry->rule.ttl_update = 0; // TTL Update
+		if (false == m_routing.AddRoutingRule(rt_rule))
+		{
+			printf("Routing rule addition failed!\n");
+			return false;
+		}
+
+		printf("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
+
+		free(rt_rule);
+
+		InitFilteringBlock();
+
+		return true;
+	}
+};
+
+
+static class IpaRoutingBlockTest1 ipaRoutingBlockTest1;
+static class IpaRoutingBlockTest2 ipaRoutingBlockTest2;
+static class IpaRoutingBlockTest3 ipaRoutingBlockTest3;
+static class IpaRoutingBlockTest4 ipaRoutingBlockTest4;
+static class IpaRoutingBlockTest5 ipaRoutingBlockTest5;
+static class IpaRoutingBlockTest006 ipaRoutingBlockTest006;
+static class IpaRoutingBlockTest007 ipaRoutingBlockTest007;
+static class IpaRoutingBlockTest008 ipaRoutingBlockTest008;
+static class IpaRoutingBlockTest009 ipaRoutingBlockTest009;
+
+static class IpaRoutingBlockTest010 ipaRoutingBlockTest010;
+static class IpaRoutingBlockTest011 ipaRoutingBlockTest011;
+static class IpaRoutingBlockTest012 ipaRoutingBlockTest012;
+static class IpaRoutingBlockTest013 ipaRoutingBlockTest013;
+static class IpaRoutingBlockTest014 ipaRoutingBlockTest014;
+static class IpaRoutingBlockTest015 ipaRoutingBlockTest015;
+static class IpaRoutingBlockTest016 ipaRoutingBlockTest016;
+static class IpaRoutingBlockTest017 ipaRoutingBlockTest017;
+static class IpaRoutingBlockTest018 ipaRoutingBlockTest018;
+
+static class IpaRoutingBlockTest020 ipaRoutingBlockTest020;
+static class IpaRoutingBlockTest021 ipaRoutingBlockTest021;
+static class IpaRoutingBlockTest022 ipaRoutingBlockTest022;
+static class IpaRoutingBlockTest023 ipaRoutingBlockTest023;
+static class IpaRoutingBlockTest024 ipaRoutingBlockTest024;
+static class IpaRoutingBlockTest025 ipaRoutingBlockTest025;
+static class IpaRoutingBlockTest026 ipaRoutingBlockTest026;
+static class IpaRoutingBlockTest027 ipaRoutingBlockTest027;
+static class IpaRoutingBlockTest028 ipaRoutingBlockTest028;
+
+static class IpaRoutingBlockTest030 ipaRoutingBlockTest030;
+static class IpaRoutingBlockTest031 ipaRoutingBlockTest031;
+
+static class IpaRoutingBlockTest040 ipaRoutingBlockTest040;
 
+static class IpaRoutingBlockTest050 ipaRoutingBlockTest050;
+static class IpaRoutingBlockTest051 ipaRoutingBlockTest051;
+static class IpaRoutingBlockTest052 ipaRoutingBlockTest052;
+static class IpaRoutingBlockTest053 ipaRoutingBlockTest053;

kernel-tests/TestsUtils.cpp

@@ -25,6 +25,40 @@
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Changes from Qualcomm Innovation Center are provided under the following license:
+ *
+ * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted (subject to the limitations in the
+ * disclaimer below) provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *
+ *     * Neither the name of Qualcomm Innovation Center, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
+ * GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
+ * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+ * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
  */
 
 #include <stdio.h>
@@ -47,8 +81,8 @@ using namespace std;
 extern Logger g_Logger;
 
 static uint8_t IPv4Packet[IP4_PACKET_SIZE] = {
-		0x45, 0x00, 0x00, 0x29,
-		0x00, 0x00, 0x40, 0x00,
+		0x45, 0x00, 0x00, 0x46,
+		0x45, 0x00, 0x00, 0x00,
 		0xff, 0x06, 0xf5, 0xfd,// Protocol = 06 (TCP)
 		0xc0, 0xa8, 0x02, 0x13,// IPv4 SRC Addr 192.168.2.19
 		0xc0, 0xa8, 0x02, 0x68,// IPv4 DST Addr 192.168.2.104
@@ -117,7 +151,7 @@ static const uint8_t Eth2IPv4Packet[] =
 	0x08, 0x00,		// ETH2 TYPE IPv4 - ETH_P_IP 0x0800
 
 	// IPv4
-	0x45, 0x00, 0x00, 0x2e,
+	0x45, 0x00, 0x00, 0x29,
 	0x00, 0x00, 0x40, 0x00,
 	0xff, 0x06, 0xf5, 0xfd, // Protocol = 06 (TCP)
 	0xc0, 0xa8, 0x02, 0x13, // IPv4 SRC Addr 192.168.2.19
@@ -161,7 +195,7 @@ static const uint8_t WLANEth2IPv4Packet[] =
 	0x08, 0x00,			// ETH2 TYPE IPv4 - ETH_P_IP 0x0800
 
 	// IPv4
-	0x45, 0x00, 0x00, 0x2e,
+	0x45, 0x00, 0x00, 0x29,
 	0x00, 0x00, 0x40, 0x00,
 	0xff, 0x06, 0xf5, 0xfd,	// Protocol = 06 (TCP)
 	0xc0, 0xa8, 0x02, 0x13,	// IPv4 SRC Addr 192.168.2.19
@@ -188,7 +222,7 @@ static const uint8_t WLAN802_3IPv4Packet[] =
 	0x08, 0x00,				// Ethrtype - 0x0800
 
 	// IPv4
-	0x45, 0x00, 0x00, 0x2e,
+	0x45, 0x00, 0x00, 0x29,
 	0x00, 0x00, 0x40, 0x00,
 	0xff, 0x06, 0xf5, 0xfd,	// Protocol = 06 (TCP)
 	0xc0, 0xa8, 0x02, 0x13,	// IPv4 SRC Addr 192.168.2.19
@@ -1221,13 +1255,36 @@ bool CompareResultVsGolden(Byte *goldenBuffer,   unsigned int goldenSize,
 	return !memcmp((void*)receivedBuffer, (void*)goldenBuffer, goldenSize);
 }
 
+size_t GetPacketStatusSize(void)
+{
+		switch (TestManager::GetInstance()->GetIPAHwType()) {
+				case IPA_HW_v5_5:
+						return sizeof(struct ipa3_hw_pkt_status_hw_v5_5);
+				case IPA_HW_v5_0:
+				case IPA_HW_v5_1:
+						return sizeof(struct ipa3_hw_pkt_status_hw_v5_0);
+				default:
+						return sizeof(struct ipa3_hw_pkt_status);
+		}
+}
+
 bool CompareResultVsGolden_w_Status(Byte *goldenBuffer,   unsigned int goldenSize,
 			   Byte *receivedBuffer, unsigned int receivedSize)
 {
 	size_t stts_size = sizeof(struct ipa3_hw_pkt_status);
 
-	if (TestManager::GetInstance()->GetIPAHwType() >= IPA_HW_v5_0) {
-		stts_size = sizeof(struct ipa3_hw_pkt_status_hw_v5_0);
+	switch (TestManager::GetInstance()->GetIPAHwType()) {
+		case IPA_HW_v5_5:
+				stts_size = sizeof(struct ipa3_hw_pkt_status_hw_v5_5);
+				break;
+		case IPA_HW_v5_0:
+		case IPA_HW_v5_1:
+				stts_size = sizeof(struct ipa3_hw_pkt_status_hw_v5_0);
+				break;
+		default:
+				stts_size = sizeof(struct ipa3_hw_pkt_status);
+				break;
+
 	}
 
 	if ((receivedSize - stts_size) != goldenSize) {

kernel-tests/main.cpp

@@ -25,6 +25,40 @@
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Changes from Qualcomm Innovation Center are provided under the following license:
+ *
+ * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted (subject to the limitations in the
+ * disclaimer below) provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *
+ *     * Neither the name of Qualcomm Innovation Center, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
+ * GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
+ * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+ * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
  */
 
 #include <getopt.h>
@@ -49,7 +83,7 @@ string sFormat = "ip_accelerator <control_flag> <suit/name>, ..., <suit/name>\n"
 							"ip_accelerator " SHOW_SUIT_FLAG  "\n"
 							"or ip_accelerator --chooser "
 							"for menu chooser interface\n";
-#define MAX_SUITES 17
+#define MAX_SUITES 19
 
 #undef strcasesame
 #define strcasesame(x, y) \