X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fcmdline.c;h=b7a88f65e1cf20c5ed58229cbc1d12071f686815;hb=b6df9fc8715f9a925136006b18fdd65f9c621757;hp=2c82098b1cf5d1787918e9df0b98fde4926029e6;hpb=a47aa8b97afe46da6032910d88109948b4c49b21;p=dpdk.git

diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index 2c82098b1c..b7a88f65e1 100644
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -1,7 +1,7 @@
 /*-
  *   BSD LICENSE
  * 
- *   Copyright(c) 2010-2012 Intel Corporation. All rights reserved.
+ *   Copyright(c) 2010-2013 Intel Corporation. All rights reserved.
  *   All rights reserved.
  * 
  *   Redistribution and use in source and binary forms, with or without 
@@ -81,6 +81,8 @@
 
 #include "testpmd.h"
 
+static void cmd_reconfig_device_queue(portid_t id, uint8_t dev, uint8_t queue);
+
 /* *** HELP *** */
 struct cmd_help_result {
 	cmdline_fixed_string_t help;
@@ -172,6 +174,9 @@ static void cmd_help_parsed(__attribute__((unused)) void *parsed_result,
 		       "- set flow_ctrl rx on|off tx on|off high_water low_water "
 						"pause_time send_xon port_id \n"
 		       "    Set the link flow control parameter on the port \n"
+		       "- set pfc_ctrl rx on|off tx on|off high_water low_water "
+						"pause_time priority port_id \n"
+		       "    Set the priority flow control parameter on the port \n"
 		       "- write reg port_id reg_off value\n"
 		       "    Set value of a port register\n"
 		       "- write regfield port_id reg_off bit_x bit_y value\n"
@@ -217,8 +222,40 @@ static void cmd_help_parsed(__attribute__((unused)) void *parsed_result,
 		       "    ip_src_address port_src dst ip_dst_address port_dst\n"
 		       "    flexbytes flexbytes_values vlan vlan_id soft soft_id\n"
 		       "- set_masks_filter port_id only_ip_flow 0|1 src_mask\n"
-		       "    ip_src_mask  port_src_mask dst_mask ip_dst_mask\n"
+		       "    ip_src_mask port_src_mask dst_mask ip_dst_mask\n"
 		       "    port_dst_mask flexbytes 0|1 vlan_id 0|1 vlan_prio 0|1\n"
+		       "- set_ipv6_masks_filter port_id only_ip_flow 0|1 src_mask\n"
+		       "    ip_src_mask port_src_mask dst_mask ip_dst_mask\n"
+		       "    port_dst_mask flexbytes 0|1 vlan_id 0|1\n"
+		       "    vlan_prio 0|1 compare_dst 0|1\n"
+		       "\n");
+	cmdline_printf(cl,
+		       "Port Operations:\n"
+		       "--------------\n"
+		       "- port start|stop|close all|X\n"
+		       "    start/stop/close all ports or port X\n"
+		       "- port config all|X speed 10|100|1000|10000|auto "
+		       "duplex half|full|auto\n"
+		       "    set speed for all ports or port X\n"
+		       "- port config all rxq|txq|rxd|txd value\n"
+		       "    set number for rxq/txq/rxd/txd\n"
+		       "- port config all max-pkt-len value\n"
+		       "    set the max packet lenght\n"
+		       "- port config all crc-strip|rx-cksum|hw-vlan|drop-en on|off\n"
+		       "    set crc-strip/rx-checksum/hardware-vlan/drop_en on or off"
+		       "\n"
+		       "- port config all rss ip|udp|none\n"
+		       "    set rss mode\n"
+		       "- port config port-id dcb vt on|off nb-tcs pfc on|off\n"
+		       "    set dcb mode\n"
+		       "- port config all burst value\n"
+		       "    set the number of packet per burst\n"
+		       "- port config all txpt|txht|txwt|rxpt|rxht|rxwt value\n"
+		       "    set ring prefetch/host/writeback threshold for "
+		       "tx/rx queue\n"
+		       "- port config all txfreet|txrst|rxfreet value\n"
+		       "    set free threshold for rx/tx, or set tx rs bit "
+		       "threshold\n"
 		       "\n");
 	cmdline_printf(cl,
 		       "Misc:\n"
@@ -241,6 +278,900 @@ cmdline_parse_inst_t cmd_help = {
 	},
 };
 
+/* *** start/stop/close all ports *** */
+struct cmd_operate_port_result {
+	cmdline_fixed_string_t keyword;
+	cmdline_fixed_string_t name;
+	cmdline_fixed_string_t value;
+};
+
+static void cmd_operate_port_parsed(void *parsed_result,
+				__attribute__((unused)) struct cmdline *cl,
+				__attribute__((unused)) void *data)
+{
+	struct cmd_operate_port_result *res = parsed_result;
+
+	if (!strcmp(res->name, "start"))
+		start_port(RTE_PORT_ALL);
+	else if (!strcmp(res->name, "stop"))
+		stop_port(RTE_PORT_ALL);
+	else if (!strcmp(res->name, "close"))
+		close_port(RTE_PORT_ALL);
+	else
+		printf("Unknown parameter\n");
+}
+
+cmdline_parse_token_string_t cmd_operate_port_all_cmd =
+	TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, keyword,
+								"port");
+cmdline_parse_token_string_t cmd_operate_port_all_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, name,
+						"start#stop#close");
+cmdline_parse_token_string_t cmd_operate_port_all_all =
+	TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, value, "all");
+
+cmdline_parse_inst_t cmd_operate_port = {
+	.f = cmd_operate_port_parsed,
+	.data = NULL,
+	.help_str = "port start|stop|close all: start/stop/close all ports",
+	.tokens = {
+		(void *)&cmd_operate_port_all_cmd,
+		(void *)&cmd_operate_port_all_port,
+		(void *)&cmd_operate_port_all_all,
+		NULL,
+	},
+};
+
+/* *** start/stop/close specific port *** */
+struct cmd_operate_specific_port_result {
+	cmdline_fixed_string_t keyword;
+	cmdline_fixed_string_t name;
+	uint8_t value;
+};
+
+static void cmd_operate_specific_port_parsed(void *parsed_result,
+			__attribute__((unused)) struct cmdline *cl,
+				__attribute__((unused)) void *data)
+{
+	struct cmd_operate_specific_port_result *res = parsed_result;
+
+	if (!strcmp(res->name, "start"))
+		start_port(res->value);
+	else if (!strcmp(res->name, "stop"))
+		stop_port(res->value);
+	else if (!strcmp(res->name, "close"))
+		close_port(res->value);
+	else
+		printf("Unknown parameter\n");
+}
+
+cmdline_parse_token_string_t cmd_operate_specific_port_cmd =
+	TOKEN_STRING_INITIALIZER(struct cmd_operate_specific_port_result,
+							keyword, "port");
+cmdline_parse_token_string_t cmd_operate_specific_port_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_operate_specific_port_result,
+						name, "start#stop#close");
+cmdline_parse_token_num_t cmd_operate_specific_port_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_operate_specific_port_result,
+							value, UINT8);
+
+cmdline_parse_inst_t cmd_operate_specific_port = {
+	.f = cmd_operate_specific_port_parsed,
+	.data = NULL,
+	.help_str = "port start|stop|close X: start/stop/close port X",
+	.tokens = {
+		(void *)&cmd_operate_specific_port_cmd,
+		(void *)&cmd_operate_specific_port_port,
+		(void *)&cmd_operate_specific_port_id,
+		NULL,
+	},
+};
+
+/* *** configure speed for all ports *** */
+struct cmd_config_speed_all {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t keyword;
+	cmdline_fixed_string_t all;
+	cmdline_fixed_string_t item1;
+	cmdline_fixed_string_t item2;
+	cmdline_fixed_string_t value1;
+	cmdline_fixed_string_t value2;
+};
+
+static void
+cmd_config_speed_all_parsed(void *parsed_result,
+			__attribute__((unused)) struct cmdline *cl,
+			__attribute__((unused)) void *data)
+{
+	struct cmd_config_speed_all *res = parsed_result;
+	uint16_t link_speed = ETH_LINK_SPEED_AUTONEG;
+	uint16_t link_duplex = 0;
+	portid_t pid;
+
+	if (!all_ports_stopped()) {
+		printf("Please stop all ports first\n");
+		return;
+	}
+
+	if (!strcmp(res->value1, "10"))
+		link_speed = ETH_LINK_SPEED_10;
+	else if (!strcmp(res->value1, "100"))
+		link_speed = ETH_LINK_SPEED_100;
+	else if (!strcmp(res->value1, "1000"))
+		link_speed = ETH_LINK_SPEED_1000;
+	else if (!strcmp(res->value1, "10000"))
+		link_speed = ETH_LINK_SPEED_10000;
+	else if (!strcmp(res->value1, "auto"))
+		link_speed = ETH_LINK_SPEED_AUTONEG;
+	else {
+		printf("Unknown parameter\n");
+		return;
+	}
+
+	if (!strcmp(res->value2, "half"))
+		link_duplex = ETH_LINK_HALF_DUPLEX;
+	else if (!strcmp(res->value2, "full"))
+		link_duplex = ETH_LINK_FULL_DUPLEX;
+	else if (!strcmp(res->value2, "auto"))
+		link_duplex = ETH_LINK_AUTONEG_DUPLEX;
+	else {
+		printf("Unknown parameter\n");
+		return;
+	}
+
+	for (pid = 0; pid < nb_ports; pid++) {
+		ports[pid].dev_conf.link_speed = link_speed;
+		ports[pid].dev_conf.link_duplex = link_duplex;
+	}
+
+	cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
+}
+
+cmdline_parse_token_string_t cmd_config_speed_all_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, port, "port");
+cmdline_parse_token_string_t cmd_config_speed_all_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, keyword,
+							"config");
+cmdline_parse_token_string_t cmd_config_speed_all_all =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, all, "all");
+cmdline_parse_token_string_t cmd_config_speed_all_item1 =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, item1, "speed");
+cmdline_parse_token_string_t cmd_config_speed_all_value1 =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, value1,
+						"10#100#1000#10000#auto");
+cmdline_parse_token_string_t cmd_config_speed_all_item2 =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, item2, "duplex");
+cmdline_parse_token_string_t cmd_config_speed_all_value2 =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, value2,
+						"half#full#auto");
+
+cmdline_parse_inst_t cmd_config_speed_all = {
+	.f = cmd_config_speed_all_parsed,
+	.data = NULL,
+	.help_str = "port config all speed 10|100|1000|10000|auto duplex "
+							"half|full|auto",
+	.tokens = {
+		(void *)&cmd_config_speed_all_port,
+		(void *)&cmd_config_speed_all_keyword,
+		(void *)&cmd_config_speed_all_all,
+		(void *)&cmd_config_speed_all_item1,
+		(void *)&cmd_config_speed_all_value1,
+		(void *)&cmd_config_speed_all_item2,
+		(void *)&cmd_config_speed_all_value2,
+		NULL,
+	},
+};
+
+/* *** configure speed for specific port *** */
+struct cmd_config_speed_specific {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t keyword;
+	uint8_t id;
+	cmdline_fixed_string_t item1;
+	cmdline_fixed_string_t item2;
+	cmdline_fixed_string_t value1;
+	cmdline_fixed_string_t value2;
+};
+
+static void
+cmd_config_speed_specific_parsed(void *parsed_result,
+				__attribute__((unused)) struct cmdline *cl,
+				__attribute__((unused)) void *data)
+{
+	struct cmd_config_speed_specific *res = parsed_result;
+	uint16_t link_speed = ETH_LINK_SPEED_AUTONEG;
+	uint16_t link_duplex = 0;
+
+	if (!all_ports_stopped()) {
+		printf("Please stop all ports first\n");
+		return;
+	}
+
+	if (res->id >= nb_ports) {
+		printf("Port id %d must be less than %d\n", res->id, nb_ports);
+		return;
+	}
+
+	if (!strcmp(res->value1, "10"))
+		link_speed = ETH_LINK_SPEED_10;
+	else if (!strcmp(res->value1, "100"))
+		link_speed = ETH_LINK_SPEED_100;
+	else if (!strcmp(res->value1, "1000"))
+		link_speed = ETH_LINK_SPEED_1000;
+	else if (!strcmp(res->value1, "10000"))
+		link_speed = ETH_LINK_SPEED_10000;
+	else if (!strcmp(res->value1, "auto"))
+		link_speed = ETH_LINK_SPEED_AUTONEG;
+	else {
+		printf("Unknown parameter\n");
+		return;
+	}
+
+	if (!strcmp(res->value2, "half"))
+		link_duplex = ETH_LINK_HALF_DUPLEX;
+	else if (!strcmp(res->value2, "full"))
+		link_duplex = ETH_LINK_FULL_DUPLEX;
+	else if (!strcmp(res->value2, "auto"))
+		link_duplex = ETH_LINK_AUTONEG_DUPLEX;
+	else {
+		printf("Unknown parameter\n");
+		return;
+	}
+
+	ports[res->id].dev_conf.link_speed = link_speed;
+	ports[res->id].dev_conf.link_duplex = link_duplex;
+
+	cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
+}
+
+
+cmdline_parse_token_string_t cmd_config_speed_specific_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, port,
+								"port");
+cmdline_parse_token_string_t cmd_config_speed_specific_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, keyword,
+								"config");
+cmdline_parse_token_num_t cmd_config_speed_specific_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_config_speed_specific, id, UINT8);
+cmdline_parse_token_string_t cmd_config_speed_specific_item1 =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, item1,
+								"speed");
+cmdline_parse_token_string_t cmd_config_speed_specific_value1 =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, value1,
+						"10#100#1000#10000#auto");
+cmdline_parse_token_string_t cmd_config_speed_specific_item2 =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, item2,
+								"duplex");
+cmdline_parse_token_string_t cmd_config_speed_specific_value2 =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, value2,
+							"half#full#auto");
+
+cmdline_parse_inst_t cmd_config_speed_specific = {
+	.f = cmd_config_speed_specific_parsed,
+	.data = NULL,
+	.help_str = "port config X speed 10|100|1000|10000|auto duplex "
+							"half|full|auto",
+	.tokens = {
+		(void *)&cmd_config_speed_specific_port,
+		(void *)&cmd_config_speed_specific_keyword,
+		(void *)&cmd_config_speed_specific_id,
+		(void *)&cmd_config_speed_specific_item1,
+		(void *)&cmd_config_speed_specific_value1,
+		(void *)&cmd_config_speed_specific_item2,
+		(void *)&cmd_config_speed_specific_value2,
+		NULL,
+	},
+};
+
+/* *** configure txq/rxq, txd/rxd *** */
+struct cmd_config_rx_tx {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t keyword;
+	cmdline_fixed_string_t all;
+	cmdline_fixed_string_t name;
+	uint16_t value;
+};
+
+static void
+cmd_config_rx_tx_parsed(void *parsed_result,
+			__attribute__((unused)) struct cmdline *cl,
+			__attribute__((unused)) void *data)
+{
+	struct cmd_config_rx_tx *res = parsed_result;
+
+	if (!all_ports_stopped()) {
+		printf("Please stop all ports first\n");
+		return;
+	}
+
+	if (!strcmp(res->name, "rxq")) {
+		if (res->value <= 0) {
+			printf("rxq %d invalid - must be > 0\n", res->value);
+			return;
+		}
+		nb_rxq = res->value;
+	}
+	else if (!strcmp(res->name, "txq")) {
+		if (res->value <= 0) {
+			printf("txq %d invalid - must be > 0\n", res->value);
+			return;
+		}
+		nb_txq = res->value;
+	}
+	else if (!strcmp(res->name, "rxd")) {
+		if (res->value <= 0 || res->value > RTE_TEST_RX_DESC_MAX) {
+			printf("rxd %d invalid - must be > 0 && <= %d\n",
+					res->value, RTE_TEST_RX_DESC_MAX);
+			return;
+		}
+		nb_rxd = res->value;
+	} else if (!strcmp(res->name, "txd")) {
+		if (res->value <= 0 || res->value > RTE_TEST_TX_DESC_MAX) {
+			printf("txd %d invalid - must be > 0 && <= %d\n",
+					res->value, RTE_TEST_TX_DESC_MAX);
+			return;
+		}
+		nb_txd = res->value;
+	} else {
+		printf("Unknown parameter\n");
+		return;
+	}
+
+	init_port_config();
+
+	cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
+}
+
+cmdline_parse_token_string_t cmd_config_rx_tx_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, port, "port");
+cmdline_parse_token_string_t cmd_config_rx_tx_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, keyword, "config");
+cmdline_parse_token_string_t cmd_config_rx_tx_all =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, all, "all");
+cmdline_parse_token_string_t cmd_config_rx_tx_name =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, name,
+						"rxq#txq#rxd#txd");
+cmdline_parse_token_num_t cmd_config_rx_tx_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_config_rx_tx, value, UINT16);
+
+cmdline_parse_inst_t cmd_config_rx_tx = {
+	.f = cmd_config_rx_tx_parsed,
+	.data = NULL,
+	.help_str = "port config all rxq|txq|rxd|txd value",
+	.tokens = {
+		(void *)&cmd_config_rx_tx_port,
+		(void *)&cmd_config_rx_tx_keyword,
+		(void *)&cmd_config_rx_tx_all,
+		(void *)&cmd_config_rx_tx_name,
+		(void *)&cmd_config_rx_tx_value,
+		NULL,
+	},
+};
+
+/* *** config max packet length *** */
+struct cmd_config_max_pkt_len_result {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t keyword;
+	cmdline_fixed_string_t all;
+	cmdline_fixed_string_t name;
+	uint32_t value;
+};
+
+static void
+cmd_config_max_pkt_len_parsed(void *parsed_result,
+				__attribute__((unused)) struct cmdline *cl,
+				__attribute__((unused)) void *data)
+{
+	struct cmd_config_max_pkt_len_result *res = parsed_result;
+
+	if (!all_ports_stopped()) {
+		printf("Please stop all ports first\n");
+		return;
+	}
+
+	if (!strcmp(res->name, "max-pkt-len")) {
+		if (res->value < ETHER_MIN_LEN) {
+			printf("max-pkt-len can not be less than %d\n",
+							ETHER_MIN_LEN);
+			return;
+		}
+		if (res->value == rx_mode.max_rx_pkt_len)
+			return;
+
+		rx_mode.max_rx_pkt_len = res->value;
+		if (res->value > ETHER_MAX_LEN)
+			rx_mode.jumbo_frame = 1;
+		else
+			rx_mode.jumbo_frame = 0;
+	} else {
+		printf("Unknown parameter\n");
+		return;
+	}
+
+	init_port_config();
+
+	cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
+}
+
+cmdline_parse_token_string_t cmd_config_max_pkt_len_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, port,
+								"port");
+cmdline_parse_token_string_t cmd_config_max_pkt_len_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, keyword,
+								"config");
+cmdline_parse_token_string_t cmd_config_max_pkt_len_all =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, all,
+								"all");
+cmdline_parse_token_string_t cmd_config_max_pkt_len_name =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, name,
+								"max-pkt-len");
+cmdline_parse_token_num_t cmd_config_max_pkt_len_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_config_max_pkt_len_result, value,
+								UINT32);
+
+cmdline_parse_inst_t cmd_config_max_pkt_len = {
+	.f = cmd_config_max_pkt_len_parsed,
+	.data = NULL,
+	.help_str = "port config all max-pkt-len value",
+	.tokens = {
+		(void *)&cmd_config_max_pkt_len_port,
+		(void *)&cmd_config_max_pkt_len_keyword,
+		(void *)&cmd_config_max_pkt_len_all,
+		(void *)&cmd_config_max_pkt_len_name,
+		(void *)&cmd_config_max_pkt_len_value,
+		NULL,
+	},
+};
+
+/* *** configure rx mode *** */
+struct cmd_config_rx_mode_flag {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t keyword;
+	cmdline_fixed_string_t all;
+	cmdline_fixed_string_t name;
+	cmdline_fixed_string_t value;
+};
+
+static void
+cmd_config_rx_mode_flag_parsed(void *parsed_result,
+				__attribute__((unused)) struct cmdline *cl,
+				__attribute__((unused)) void *data)
+{
+	struct cmd_config_rx_mode_flag *res = parsed_result;
+
+	if (!all_ports_stopped()) {
+		printf("Please stop all ports first\n");
+		return;
+	}
+
+	if (!strcmp(res->name, "crc-strip")) {
+		if (!strcmp(res->value, "on"))
+			rx_mode.hw_strip_crc = 1;
+		else if (!strcmp(res->value, "off"))
+			rx_mode.hw_strip_crc = 0;
+		else {
+			printf("Unknown parameter\n");
+			return;
+		}
+	} else if (!strcmp(res->name, "rx-cksum")) {
+		if (!strcmp(res->value, "on"))
+			rx_mode.hw_ip_checksum = 1;
+		else if (!strcmp(res->value, "off"))
+			rx_mode.hw_ip_checksum = 0;
+		else {
+			printf("Unknown parameter\n");
+			return;
+		}
+	} else if (!strcmp(res->name, "hw-vlan")) {
+		if (!strcmp(res->value, "on")) {
+			rx_mode.hw_vlan_filter = 1;
+			rx_mode.hw_vlan_strip  = 1;
+		}
+		else if (!strcmp(res->value, "off")) {
+			rx_mode.hw_vlan_filter = 0;
+			rx_mode.hw_vlan_strip  = 0;
+		}
+		else {
+			printf("Unknown parameter\n");
+			return;
+		}
+	} else if (!strcmp(res->name, "drop-en")) {
+		if (!strcmp(res->value, "on"))
+			rx_drop_en = 1;
+		else if (!strcmp(res->value, "off"))
+			rx_drop_en = 0;
+		else {
+			printf("Unknown parameter\n");
+			return;
+		}
+	} else {
+		printf("Unknown parameter\n");
+		return;
+	}
+
+	init_port_config();
+
+	cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
+}
+
+cmdline_parse_token_string_t cmd_config_rx_mode_flag_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, port, "port");
+cmdline_parse_token_string_t cmd_config_rx_mode_flag_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, keyword,
+								"config");
+cmdline_parse_token_string_t cmd_config_rx_mode_flag_all =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, all, "all");
+cmdline_parse_token_string_t cmd_config_rx_mode_flag_name =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, name,
+					"crc-strip#rx-cksum#hw-vlan");
+cmdline_parse_token_string_t cmd_config_rx_mode_flag_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, value,
+							"on#off");
+
+cmdline_parse_inst_t cmd_config_rx_mode_flag = {
+	.f = cmd_config_rx_mode_flag_parsed,
+	.data = NULL,
+	.help_str = "port config all crc-strip|rx-cksum|hw-vlan on|off",
+	.tokens = {
+		(void *)&cmd_config_rx_mode_flag_port,
+		(void *)&cmd_config_rx_mode_flag_keyword,
+		(void *)&cmd_config_rx_mode_flag_all,
+		(void *)&cmd_config_rx_mode_flag_name,
+		(void *)&cmd_config_rx_mode_flag_value,
+		NULL,
+	},
+};
+
+/* *** configure rss *** */
+struct cmd_config_rss {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t keyword;
+	cmdline_fixed_string_t all;
+	cmdline_fixed_string_t name;
+	cmdline_fixed_string_t value;
+};
+
+static void
+cmd_config_rss_parsed(void *parsed_result,
+			__attribute__((unused)) struct cmdline *cl,
+			__attribute__((unused)) void *data)
+{
+	struct cmd_config_rss *res = parsed_result;
+
+	if (!all_ports_stopped()) {
+		printf("Please stop all ports first\n");
+		return;
+	}
+
+	if (!strcmp(res->value, "ip"))
+		rss_hf = ETH_RSS_IPV4 | ETH_RSS_IPV6;
+	else if (!strcmp(res->value, "udp"))
+		rss_hf = ETH_RSS_IPV4 | ETH_RSS_IPV6 | ETH_RSS_IPV4_UDP;
+	else if (!strcmp(res->value, "none"))
+		rss_hf = 0;
+	else {
+		printf("Unknown parameter\n");
+		return;
+	}
+
+	init_port_config();
+
+	cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
+}
+
+cmdline_parse_token_string_t cmd_config_rss_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_rss, port, "port");
+cmdline_parse_token_string_t cmd_config_rss_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_rss, keyword, "config");
+cmdline_parse_token_string_t cmd_config_rss_all =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_rss, all, "all");
+cmdline_parse_token_string_t cmd_config_rss_name =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_rss, name, "rss");
+cmdline_parse_token_string_t cmd_config_rss_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_rss, value, "ip#udp#none");
+
+cmdline_parse_inst_t cmd_config_rss = {
+	.f = cmd_config_rss_parsed,
+	.data = NULL,
+	.help_str = "port config all rss ip|udp|none",
+	.tokens = {
+		(void *)&cmd_config_rss_port,
+		(void *)&cmd_config_rss_keyword,
+		(void *)&cmd_config_rss_all,
+		(void *)&cmd_config_rss_name,
+		(void *)&cmd_config_rss_value,
+		NULL,
+	},
+};
+
+/* *** Configure DCB *** */
+struct cmd_config_dcb {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t config;
+	uint8_t port_id; 
+	cmdline_fixed_string_t dcb;
+	cmdline_fixed_string_t vt;
+	cmdline_fixed_string_t vt_en;
+	uint8_t num_tcs; 
+	cmdline_fixed_string_t pfc;
+	cmdline_fixed_string_t pfc_en;
+};
+
+static void
+cmd_config_dcb_parsed(void *parsed_result,
+                        __attribute__((unused)) struct cmdline *cl,
+                        __attribute__((unused)) void *data)
+{
+	struct cmd_config_dcb *res = parsed_result;
+	struct dcb_config dcb_conf;
+	portid_t port_id = res->port_id;
+	struct rte_port *port;
+	
+	port = &ports[port_id];
+	/** Check if the port is not started **/
+	if (port->port_status != RTE_PORT_STOPPED) {
+		printf("Please stop port %d first\n",port_id);
+		return;
+	}
+		
+	dcb_conf.num_tcs = (enum rte_eth_nb_tcs) res->num_tcs;
+	if ((dcb_conf.num_tcs != ETH_4_TCS) && (dcb_conf.num_tcs != ETH_8_TCS)){
+		printf("The invalid number of traffic class,only 4 or 8 allowed\n");
+		return;
+	}
+
+	/* DCB in VT mode */
+	if (!strncmp(res->vt_en, "on",2)) 
+		dcb_conf.dcb_mode = DCB_VT_ENABLED;	
+	else
+		dcb_conf.dcb_mode = DCB_ENABLED;
+
+	if (!strncmp(res->pfc_en, "on",2)) {
+		dcb_conf.pfc_en = 1;
+	}
+	else
+		dcb_conf.pfc_en = 0;
+
+	if (init_port_dcb_config(port_id,&dcb_conf) != 0) {
+		printf("Cannot initialize network ports\n");
+		return;
+	}
+
+	cmd_reconfig_device_queue(port_id, 1, 1);
+}
+ 
+cmdline_parse_token_string_t cmd_config_dcb_port =
+        TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, port, "port");
+cmdline_parse_token_string_t cmd_config_dcb_config =
+        TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, config, "config");
+cmdline_parse_token_num_t cmd_config_dcb_port_id =
+        TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, port_id, UINT8);
+cmdline_parse_token_string_t cmd_config_dcb_dcb =
+        TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, dcb, "dcb");
+cmdline_parse_token_string_t cmd_config_dcb_vt =
+        TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, vt, "vt");
+cmdline_parse_token_string_t cmd_config_dcb_vt_en =
+        TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, vt_en, "on#off");
+cmdline_parse_token_num_t cmd_config_dcb_num_tcs =
+        TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, num_tcs, UINT8);
+cmdline_parse_token_string_t cmd_config_dcb_pfc=
+        TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, pfc, "pfc");
+cmdline_parse_token_string_t cmd_config_dcb_pfc_en =
+        TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, pfc_en, "on#off");
+
+cmdline_parse_inst_t cmd_config_dcb = {
+        .f = cmd_config_dcb_parsed,
+        .data = NULL,
+        .help_str = "port config port-id dcb vt on|off nb-tcs pfc on|off",
+        .tokens = {
+		(void *)&cmd_config_dcb_port,
+		(void *)&cmd_config_dcb_config,
+		(void *)&cmd_config_dcb_port_id,
+		(void *)&cmd_config_dcb_dcb,
+		(void *)&cmd_config_dcb_vt,
+		(void *)&cmd_config_dcb_vt_en,
+		(void *)&cmd_config_dcb_num_tcs,
+		(void *)&cmd_config_dcb_pfc,
+		(void *)&cmd_config_dcb_pfc_en,
+                NULL,
+        },
+};
+
+/* *** configure number of packets per burst *** */
+struct cmd_config_burst {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t keyword;
+	cmdline_fixed_string_t all;
+	cmdline_fixed_string_t name;
+	uint16_t value;
+};
+
+static void
+cmd_config_burst_parsed(void *parsed_result,
+			__attribute__((unused)) struct cmdline *cl,
+			__attribute__((unused)) void *data)
+{
+	struct cmd_config_burst *res = parsed_result;
+
+	if (!all_ports_stopped()) {
+		printf("Please stop all ports first\n");
+		return;
+	}
+
+	if (!strcmp(res->name, "burst")) {
+		if (res->value < 1 || res->value > MAX_PKT_BURST) {
+			printf("burst must be >= 1 && <= %d\n", MAX_PKT_BURST);
+			return;
+		}
+		nb_pkt_per_burst = res->value;
+	} else {
+		printf("Unknown parameter\n");
+		return;
+	}
+
+	init_port_config();
+
+	cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
+}
+
+cmdline_parse_token_string_t cmd_config_burst_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_burst, port, "port");
+cmdline_parse_token_string_t cmd_config_burst_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_burst, keyword, "config");
+cmdline_parse_token_string_t cmd_config_burst_all =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_burst, all, "all");
+cmdline_parse_token_string_t cmd_config_burst_name =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_burst, name, "burst");
+cmdline_parse_token_num_t cmd_config_burst_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_config_burst, value, UINT16);
+
+cmdline_parse_inst_t cmd_config_burst = {
+	.f = cmd_config_burst_parsed,
+	.data = NULL,
+	.help_str = "port config all burst value",
+	.tokens = {
+		(void *)&cmd_config_burst_port,
+		(void *)&cmd_config_burst_keyword,
+		(void *)&cmd_config_burst_all,
+		(void *)&cmd_config_burst_name,
+		(void *)&cmd_config_burst_value,
+		NULL,
+	},
+};
+
+/* *** configure rx/tx queues *** */
+struct cmd_config_thresh {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t keyword;
+	cmdline_fixed_string_t all;
+	cmdline_fixed_string_t name;
+	uint8_t value;
+};
+
+static void
+cmd_config_thresh_parsed(void *parsed_result,
+			__attribute__((unused)) struct cmdline *cl,
+			__attribute__((unused)) void *data)
+{
+	struct cmd_config_thresh *res = parsed_result;
+
+	if (!all_ports_stopped()) {
+		printf("Please stop all ports first\n");
+		return;
+	}
+
+	if (!strcmp(res->name, "txpt"))
+		tx_thresh.pthresh = res->value;
+	else if(!strcmp(res->name, "txht"))
+		tx_thresh.hthresh = res->value;
+	else if(!strcmp(res->name, "txwt"))
+		tx_thresh.wthresh = res->value;
+	else if(!strcmp(res->name, "rxpt"))
+		rx_thresh.pthresh = res->value;
+	else if(!strcmp(res->name, "rxht"))
+		rx_thresh.hthresh = res->value;
+	else if(!strcmp(res->name, "rxwt"))
+		rx_thresh.wthresh = res->value;
+	else {
+		printf("Unknown parameter\n");
+		return;
+	}
+
+	init_port_config();
+
+	cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
+}
+
+cmdline_parse_token_string_t cmd_config_thresh_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, port, "port");
+cmdline_parse_token_string_t cmd_config_thresh_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, keyword, "config");
+cmdline_parse_token_string_t cmd_config_thresh_all =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, all, "all");
+cmdline_parse_token_string_t cmd_config_thresh_name =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, name,
+				"txpt#txht#txwt#rxpt#rxht#rxwt");
+cmdline_parse_token_num_t cmd_config_thresh_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_config_thresh, value, UINT8);
+
+cmdline_parse_inst_t cmd_config_thresh = {
+	.f = cmd_config_thresh_parsed,
+	.data = NULL,
+	.help_str = "port config all txpt|txht|txwt|rxpt|rxht|rxwt value",
+	.tokens = {
+		(void *)&cmd_config_thresh_port,
+		(void *)&cmd_config_thresh_keyword,
+		(void *)&cmd_config_thresh_all,
+		(void *)&cmd_config_thresh_name,
+		(void *)&cmd_config_thresh_value,
+		NULL,
+	},
+};
+
+/* *** configure free/rs threshold *** */
+struct cmd_config_threshold {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t keyword;
+	cmdline_fixed_string_t all;
+	cmdline_fixed_string_t name;
+	uint16_t value;
+};
+
+static void
+cmd_config_threshold_parsed(void *parsed_result,
+			__attribute__((unused)) struct cmdline *cl,
+			__attribute__((unused)) void *data)
+{
+	struct cmd_config_threshold *res = parsed_result;
+
+	if (!all_ports_stopped()) {
+		printf("Please stop all ports first\n");
+		return;
+	}
+
+	if (!strcmp(res->name, "txfreet"))
+		tx_free_thresh = res->value;
+	else if (!strcmp(res->name, "txrst"))
+		tx_rs_thresh = res->value;
+	else if (!strcmp(res->name, "rxfreet"))
+		rx_free_thresh = res->value;
+	else {
+		printf("Unknown parameter\n");
+		return;
+	}
+
+	init_port_config();
+
+	cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
+}
+
+cmdline_parse_token_string_t cmd_config_threshold_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, port, "port");
+cmdline_parse_token_string_t cmd_config_threshold_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, keyword,
+								"config");
+cmdline_parse_token_string_t cmd_config_threshold_all =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, all, "all");
+cmdline_parse_token_string_t cmd_config_threshold_name =
+	TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, name,
+						"txfreet#txrst#rxfreet");
+cmdline_parse_token_num_t cmd_config_threshold_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_config_threshold, value, UINT16);
+
+cmdline_parse_inst_t cmd_config_threshold = {
+	.f = cmd_config_threshold_parsed,
+	.data = NULL,
+	.help_str = "port config all txfreet|txrst|rxfreet value",
+	.tokens = {
+		(void *)&cmd_config_threshold_port,
+		(void *)&cmd_config_threshold_keyword,
+		(void *)&cmd_config_threshold_all,
+		(void *)&cmd_config_threshold_name,
+		(void *)&cmd_config_threshold_value,
+		NULL,
+	},
+};
+
 /* *** stop *** */
 struct cmd_stop_result {
 	cmdline_fixed_string_t stop;
@@ -601,7 +1532,7 @@ cmd_vlan_offload_parsed(void *parsed_result,
 	str[i]='\0';
 	tmp = strtoul(str, NULL, 0);
 	/* If port_id greater that what portid_t can represent, return */
-	if(tmp > 255)
+	if(tmp >= RTE_MAX_ETHPORTS)
 		return;
 	port_id = (portid_t)tmp;
 
@@ -1414,9 +2345,11 @@ struct cmd_pkt_filter_masks_result {
 	uint8_t  port_id;
 	cmdline_fixed_string_t src_mask;
 	uint32_t ip_src_mask;
+	uint16_t ipv6_src_mask;
 	uint16_t port_src_mask;
 	cmdline_fixed_string_t dst_mask;
 	uint32_t ip_dst_mask;
+	uint16_t ipv6_dst_mask;
 	uint16_t port_dst_mask;
 	cmdline_fixed_string_t flexbytes;
 	uint8_t flexbytes_value;
@@ -1426,6 +2359,8 @@ struct cmd_pkt_filter_masks_result {
 	uint8_t  vlan_prio_value;
 	cmdline_fixed_string_t only_ip_flow;
 	uint8_t  only_ip_flow_value;
+	cmdline_fixed_string_t comp_ipv6_dst;
+	uint8_t  comp_ipv6_dst_value;
 };
 
 static void
@@ -1473,7 +2408,7 @@ cmdline_parse_token_num_t cmd_pkt_filter_masks_port_src_mask =
 			      port_src_mask, UINT16);
 cmdline_parse_token_string_t cmd_pkt_filter_masks_dst_mask =
 	TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_masks_result,
-				 src_mask, "dst_mask");
+				 dst_mask, "dst_mask");
 cmdline_parse_token_num_t cmd_pkt_filter_masks_ip_dst_mask =
 	TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result,
 			      ip_dst_mask, UINT32);
@@ -1524,6 +2459,74 @@ cmdline_parse_inst_t cmd_set_masks_filter = {
 	},
 };
 
+static void
+cmd_pkt_filter_masks_ipv6_parsed(void *parsed_result,
+			  __attribute__((unused)) struct cmdline *cl,
+			  __attribute__((unused)) void *data)
+{
+	struct rte_fdir_masks fdir_masks;
+	struct cmd_pkt_filter_masks_result *res = parsed_result;
+
+	memset(&fdir_masks, 0, sizeof(struct rte_fdir_masks));
+
+	fdir_masks.set_ipv6_mask = 1;
+	fdir_masks.only_ip_flow  = res->only_ip_flow_value;
+	fdir_masks.vlan_id       = res->vlan_id_value;
+	fdir_masks.vlan_prio     = res->vlan_prio_value;
+	fdir_masks.dst_ipv6_mask = res->ipv6_dst_mask;
+	fdir_masks.src_ipv6_mask = res->ipv6_src_mask;
+	fdir_masks.src_port_mask = res->port_src_mask;
+	fdir_masks.dst_port_mask = res->port_dst_mask;
+	fdir_masks.flexbytes     = res->flexbytes_value;
+	fdir_masks.comp_ipv6_dst = res->comp_ipv6_dst_value;
+
+	fdir_set_masks(res->port_id, &fdir_masks);
+}
+
+cmdline_parse_token_string_t cmd_pkt_filter_masks_filter_mask_ipv6 =
+	TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_masks_result,
+				 filter_mask, "set_ipv6_masks_filter");
+cmdline_parse_token_num_t cmd_pkt_filter_masks_src_mask_ipv6_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result,
+			      ipv6_src_mask, UINT16);
+cmdline_parse_token_num_t cmd_pkt_filter_masks_dst_mask_ipv6_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result,
+			      ipv6_dst_mask, UINT16);
+
+cmdline_parse_token_string_t cmd_pkt_filter_masks_comp_ipv6_dst =
+	TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_masks_result,
+				 comp_ipv6_dst, "compare_dst");
+cmdline_parse_token_num_t cmd_pkt_filter_masks_comp_ipv6_dst_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result,
+			      comp_ipv6_dst_value, UINT8);
+
+cmdline_parse_inst_t cmd_set_ipv6_masks_filter = {
+	.f = cmd_pkt_filter_masks_ipv6_parsed,
+	.data = NULL,
+	.help_str = "setup ipv6 masks filter",
+	.tokens = {
+		(void *)&cmd_pkt_filter_masks_filter_mask_ipv6,
+		(void *)&cmd_pkt_filter_masks_port_id,
+		(void *)&cmd_pkt_filter_masks_only_ip_flow,
+		(void *)&cmd_pkt_filter_masks_only_ip_flow_value,
+		(void *)&cmd_pkt_filter_masks_src_mask,
+		(void *)&cmd_pkt_filter_masks_src_mask_ipv6_value,
+		(void *)&cmd_pkt_filter_masks_port_src_mask,
+		(void *)&cmd_pkt_filter_masks_dst_mask,
+		(void *)&cmd_pkt_filter_masks_dst_mask_ipv6_value,
+		(void *)&cmd_pkt_filter_masks_port_dst_mask,
+		(void *)&cmd_pkt_filter_masks_flexbytes,
+		(void *)&cmd_pkt_filter_masks_flexbytes_value,
+		(void *)&cmd_pkt_filter_masks_vlan_id,
+		(void *)&cmd_pkt_filter_masks_vlan_id_value,
+		(void *)&cmd_pkt_filter_masks_vlan_prio,
+		(void *)&cmd_pkt_filter_masks_vlan_prio_value,
+		(void *)&cmd_pkt_filter_masks_comp_ipv6_dst,
+		(void *)&cmd_pkt_filter_masks_comp_ipv6_dst_value,
+		NULL,
+	},
+};
+
 /* *** SETUP ETHERNET LINK FLOW CONTROL *** */
 struct cmd_link_flow_ctrl_set_result {
 	cmdline_fixed_string_t set;
@@ -1627,6 +2630,109 @@ cmdline_parse_inst_t cmd_link_flow_control_set = {
 	},
 };
 
+/* *** SETUP ETHERNET PIRORITY FLOW CONTROL *** */
+struct cmd_priority_flow_ctrl_set_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t pfc_ctrl;
+	cmdline_fixed_string_t rx;
+	cmdline_fixed_string_t rx_pfc_mode;
+	cmdline_fixed_string_t tx;
+	cmdline_fixed_string_t tx_pfc_mode;
+	uint32_t high_water;
+	uint32_t low_water;
+	uint16_t pause_time;
+	uint8_t  priority;
+	uint8_t  port_id;
+};
+
+static void
+cmd_priority_flow_ctrl_set_parsed(void *parsed_result,
+		       __attribute__((unused)) struct cmdline *cl,
+		       __attribute__((unused)) void *data)
+{
+	struct cmd_priority_flow_ctrl_set_result *res = parsed_result;
+	struct rte_eth_pfc_conf pfc_conf;
+	int rx_fc_enable, tx_fc_enable;
+	int ret;
+
+	/*
+	 * Rx on/off, flow control is enabled/disabled on RX side. This can indicate
+	 * the RTE_FC_TX_PAUSE, Transmit pause frame at the Rx side.
+	 * Tx on/off, flow control is enabled/disabled on TX side. This can indicate
+	 * the RTE_FC_RX_PAUSE, Respond to the pause frame at the Tx side.
+	 */
+	static enum rte_eth_fc_mode rx_tx_onoff_2_pfc_mode[2][2] = {
+			{RTE_FC_NONE, RTE_FC_RX_PAUSE}, {RTE_FC_TX_PAUSE, RTE_FC_FULL}
+	};
+
+	rx_fc_enable = (!strncmp(res->rx_pfc_mode, "on",2)) ? 1 : 0;
+	tx_fc_enable = (!strncmp(res->tx_pfc_mode, "on",2)) ? 1 : 0;
+	pfc_conf.fc.mode       = rx_tx_onoff_2_pfc_mode[rx_fc_enable][tx_fc_enable];
+	pfc_conf.fc.high_water = res->high_water;
+	pfc_conf.fc.low_water  = res->low_water;
+	pfc_conf.fc.pause_time = res->pause_time;
+	pfc_conf.priority      = res->priority;
+
+	ret = rte_eth_dev_priority_flow_ctrl_set(res->port_id, &pfc_conf);
+	if (ret != 0)
+		printf("bad priority flow contrl parameter, return code = %d \n", ret);
+}
+
+cmdline_parse_token_string_t cmd_pfc_set_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
+				set, "set");
+cmdline_parse_token_string_t cmd_pfc_set_flow_ctrl =
+	TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
+				pfc_ctrl, "pfc_ctrl");
+cmdline_parse_token_string_t cmd_pfc_set_rx =
+	TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
+				rx, "rx");
+cmdline_parse_token_string_t cmd_pfc_set_rx_mode =
+	TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
+				rx_pfc_mode, "on#off");
+cmdline_parse_token_string_t cmd_pfc_set_tx =
+	TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
+				tx, "tx");
+cmdline_parse_token_string_t cmd_pfc_set_tx_mode =
+	TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
+				tx_pfc_mode, "on#off");
+cmdline_parse_token_num_t cmd_pfc_set_high_water =
+	TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
+				high_water, UINT32);
+cmdline_parse_token_num_t cmd_pfc_set_low_water =
+	TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
+				low_water, UINT32);
+cmdline_parse_token_num_t cmd_pfc_set_pause_time =
+	TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
+				pause_time, UINT16);
+cmdline_parse_token_num_t cmd_pfc_set_priority =
+	TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
+				priority, UINT8);
+cmdline_parse_token_num_t cmd_pfc_set_portid =
+	TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
+				port_id, UINT8);
+
+cmdline_parse_inst_t cmd_priority_flow_control_set = {
+	.f = cmd_priority_flow_ctrl_set_parsed,
+	.data = NULL,
+	.help_str = "Configure the Ethernet priority flow control: set pfc_ctrl rx on|off\n\
+			tx on|off high_water low_water pause_time priority port_id",
+	.tokens = {
+		(void *)&cmd_pfc_set_set,
+		(void *)&cmd_pfc_set_flow_ctrl,
+		(void *)&cmd_pfc_set_rx,
+		(void *)&cmd_pfc_set_rx_mode,
+		(void *)&cmd_pfc_set_tx,
+		(void *)&cmd_pfc_set_tx_mode,
+		(void *)&cmd_pfc_set_high_water,
+		(void *)&cmd_pfc_set_low_water,
+		(void *)&cmd_pfc_set_pause_time,
+		(void *)&cmd_pfc_set_priority,
+		(void *)&cmd_pfc_set_portid,
+		NULL,
+	},
+};
+
 /* *** RESET CONFIGURATION *** */
 struct cmd_reset_result {
 	cmdline_fixed_string_t reset;
@@ -2259,7 +3365,7 @@ cmdline_parse_token_string_t cmd_mac_addr_what =
 				"add#remove");
 cmdline_parse_token_num_t cmd_mac_addr_portnum =
 		TOKEN_NUM_INITIALIZER(struct cmd_mac_addr_result, port_num, UINT8);
-cmdline_parse_token_string_t cmd_mac_addr_addr =
+cmdline_parse_token_etheraddr_t cmd_mac_addr_addr =
 		TOKEN_ETHERADDR_INITIALIZER(struct cmd_mac_addr_result, address);
 
 cmdline_parse_inst_t cmd_mac_addr = {
@@ -2361,6 +3467,8 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_tx_vlan_reset,
 	(cmdline_parse_inst_t *)&cmd_tx_cksum_set,
 	(cmdline_parse_inst_t *)&cmd_link_flow_control_set,
+	(cmdline_parse_inst_t *)&cmd_priority_flow_control_set,
+	(cmdline_parse_inst_t *)&cmd_config_dcb,
 	(cmdline_parse_inst_t *)&cmd_read_reg,
 	(cmdline_parse_inst_t *)&cmd_read_reg_bit_field,
 	(cmdline_parse_inst_t *)&cmd_read_reg_bit,
@@ -2375,9 +3483,21 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_upd_perfect_filter,
 	(cmdline_parse_inst_t *)&cmd_rm_perfect_filter,
 	(cmdline_parse_inst_t *)&cmd_set_masks_filter,
+	(cmdline_parse_inst_t *)&cmd_set_ipv6_masks_filter,
 	(cmdline_parse_inst_t *)&cmd_stop,
 	(cmdline_parse_inst_t *)&cmd_mac_addr,
 	(cmdline_parse_inst_t *)&cmd_set_qmap,
+	(cmdline_parse_inst_t *)&cmd_operate_port,
+	(cmdline_parse_inst_t *)&cmd_operate_specific_port,
+	(cmdline_parse_inst_t *)&cmd_config_speed_all,
+	(cmdline_parse_inst_t *)&cmd_config_speed_specific,
+	(cmdline_parse_inst_t *)&cmd_config_rx_tx,
+	(cmdline_parse_inst_t *)&cmd_config_max_pkt_len,
+	(cmdline_parse_inst_t *)&cmd_config_rx_mode_flag,
+	(cmdline_parse_inst_t *)&cmd_config_rss,
+	(cmdline_parse_inst_t *)&cmd_config_burst,
+	(cmdline_parse_inst_t *)&cmd_config_thresh,
+	(cmdline_parse_inst_t *)&cmd_config_threshold,
 	NULL,
 };
 
@@ -2394,3 +3514,27 @@ prompt(void)
 	cmdline_interact(cl);
 	cmdline_stdin_exit(cl);
 }
+
+static void
+cmd_reconfig_device_queue(portid_t id, uint8_t dev, uint8_t queue)
+{
+	if (id < nb_ports) {
+		/* check if need_reconfig has been set to 1 */
+		if (ports[id].need_reconfig == 0)
+			ports[id].need_reconfig = dev;
+		/* check if need_reconfig_queues has been set to 1 */
+		if (ports[id].need_reconfig_queues == 0)
+			ports[id].need_reconfig_queues = queue;
+	} else {
+		portid_t pid;
+
+		for (pid = 0; pid < nb_ports; pid++) {
+			/* check if need_reconfig has been set to 1 */
+			if (ports[pid].need_reconfig == 0)
+				ports[pid].need_reconfig = dev;
+			/* check if need_reconfig_queues has been set to 1 */
+			if (ports[pid].need_reconfig_queues == 0)
+				ports[pid].need_reconfig_queues = queue;
+		}
+	}
+}